The sparseMap command

tool to map the data and hole regions is sparse files More...

Functions
bool	is_nul (void *buffer, size_t count)
template<typename T >
void	printNumber (std::ostream &ost, T number)
template<typename T1 , typename T2 >
void	printRegion (std::ostream &ost, T1 start, T2 end)
int	main (int argc, const char *argv[])

Detailed Description

tool to map the data and hole regions is sparse files

Function Documentation

is_nul()

bool is_nul	(	void *	buffer,
		size_t	count
	)

Definition at line 20 of file sparseMap.cpp.

                                        {
    // 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;
}

Referenced by main().

Here is the caller graph for this function:

main()

int main	(	int	argc,
		const char *	argv[]
	)

Definition at line 48 of file sparseMap.cpp.

                                       {
    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;
}

References throwcall::badval(), options::parser::fParse(), options::base::fRequire(), throwcall::good0(), is_nul(), and printRegion().

Here is the call graph for this function:

printNumber()

template<typename T >

void printNumber	(	std::ostream &	ost,
		T	number
	)

Definition at line 33 of file sparseMap.cpp.

                                                                  {
    ost <<  std::dec << std::setw(16) << number;
    ost <<  " (" << std::hex << std::showbase << std::setw(10) << number << " )";
    ost <<  std::dec;
}

Referenced by printRegion().

Here is the caller graph for this function:

printRegion()

template<typename T1 , typename T2 >

void printRegion	(	std::ostream &	ost,
		T1	start,
		T2	end
	)

Definition at line 39 of file sparseMap.cpp.

                                                                                        {
    ost << "from ";
    printNumber(ost, start);
    ost << " to ";
    printNumber(ost, end);
    ost << " size ";
    printNumber(ost, end - start);
}

References printNumber(), and throttle::start.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function: