sparseMap.cpp

Go to the documentation of this file.

#include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
 
#include "throwcall.h"
#include <Options.h>
#include <algorithm>
#include <list>
#include <set>
 
bool is_nul(void *buffer, size_t count) {
    // we rely on start and size being properly aligned
    size_t words = count / sizeof(long);
 
    for (auto word = static_cast<long*>(buffer); words; --words) {
        if (*word++) {
            return false;
        }
    }
 
    return true;
}
 
template <typename T> void printNumber(std::ostream& ost, T number) {
    ost <<  std::dec << std::setw(16) << number;
    ost <<  " (" << std::hex << std::showbase << std::setw(10) << number << " )";
    ost <<  std::dec;
}
 
template <typename T1, typename T2> void printRegion(std::ostream& ost, T1 start, T2 end) {
    ost << "from ";
    printNumber(ost, start);
    ost << " to ";
    printNumber(ost, end);
    ost << " size ";
    printNumber(ost, end - start);
}
 
int main(int argc, const char *argv[]) {
    options::parser parser("map data and hole regions in sparse files");
    options::single<bool> findZeroes('f', "findZeroes", "look for blocks of zeroes", false);
    options::single<size_t> defaultBlockSize('b', "blockSize", "block size to search in (o: take from filesystem)", 0);
    options::single<bool> preserveAtime('p', "preserveAtime", "preserve atime of the file", false);
    preserveAtime.fRequire(&findZeroes);
    defaultBlockSize.fRequire(&findZeroes);
    auto remainingOptions = parser.fParse(argc, argv);
 
 
 
    for (const auto& file : remainingOptions) {
        auto fd = throwcall::badval(open(file.c_str(), O_RDONLY), -1, "open ", file);
        struct stat statbuf;
        throwcall::good0(fstat(fd, &statbuf), "stat ", file);
        std::cout << file << " has " << statbuf.st_size << " bytes, " <<
                  statbuf.st_blocks << " blocks, i.e. " << statbuf.st_blocks * 512 << " bytes allocated, " <<
                  (statbuf.st_blocks * 512.) / static_cast<double>(statbuf.st_size) << " fill factor\n";
 
        auto blockSize = statbuf.st_blksize;
        if (defaultBlockSize != 0) {
            blockSize = defaultBlockSize;
        }
 
        void* blkBuf = nullptr;
        if (findZeroes) {
            blkBuf = throwcall::badval(mmap(nullptr, blockSize,
                                            PROT_READ | PROT_WRITE, MAP_ANONYMOUS | MAP_PRIVATE,
                                            -1, 0), MAP_FAILED,
                                       "mmap block buffer with ", blockSize, " bytes");
        }
 
 
        std::vector<std::pair<int, std::string>> what({{SEEK_HOLE, "data"}, {SEEK_DATA, "hole"}});
        for (decltype(statbuf.st_size) pos = 0, toggle = 1, region = 0;
                pos < statbuf.st_size;
                toggle ^= 1) {
            auto next = lseek(fd, pos, what.at(toggle).first);
            if (next == -1 && errno == ENXIO) { // we found a hole at the end of the file
                next = statbuf.st_size;
            } else {
                throwcall::badval(next, -1,
                                  "seek ", file, "for ", what.at(toggle).second,
                                  ", from offset ", pos);
            }
            if (next != pos) {
                region++;
                std::cout << std::setw(6) << region << ": " << what.at(toggle).second << "\t";
                printRegion(std::cout, pos, next);
                std::cout << "\n";
                if (findZeroes && what.at(toggle).first == SEEK_HOLE) {
                    size_t zeroBlocksStart = 0;
                    bool lastBlockWasData = true;
                    for (auto offset = pos; offset < next;) {
                        auto bytesRead = pread(fd, blkBuf, blockSize, offset);
                        if (is_nul(blkBuf, blockSize)) {
                            if (lastBlockWasData) {
                                zeroBlocksStart = offset;
                            }
                            lastBlockWasData = false;
                        } else {
                            if (!lastBlockWasData) {
                                std::cout << "\tzeroes\t";
                                printRegion(std::cout, zeroBlocksStart, offset);
                                std::cout << "\n";
                            }
                            lastBlockWasData = true;
                        }
                        offset += bytesRead;
                    }
                    if (!lastBlockWasData) {
                        std::cout << "\tzeroes";
                        printRegion(std::cout, zeroBlocksStart, next);
                        std::cout << "\n";
                    }
                }
            }
            pos = next;
        }
        if (preserveAtime) {
            struct timespec times[2];
            memcpy(&times[0], &statbuf.st_atim, sizeof(struct timespec));
            memcpy(&times[1], &statbuf.st_mtim, sizeof(struct timespec));
            throwcall::good0(futimens(fd, times), "set tims stamps on ", file, " to old values");
        }
 
        throwcall::good0(close(fd), "close ", file);
        if (blkBuf != nullptr) {
            throwcall::good0(munmap(blkBuf, blockSize), "munmap block buffer with ", blockSize, " bytes");
        }
    }
    return EXIT_SUCCESS;
}