fileOpsTests.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>
#ifdef withGpfs
#include <gpfs.h>
#endif
 
#include "throwcall.h"
#include <OptionsChrono.h>
#include <algorithm>
#include <cmath>
#include <list>
#include <numeric>
#include <set>
#include <thread>
 
typedef std::chrono::high_resolution_clock clockType;
std::ostream& operator<< (std::ostream& stream,
                          clockType::duration t) {
    stream << std::fixed;
    stream << std::chrono::duration_cast<std::chrono::duration<double>>(t).count();
    return stream;
}
 
 
class baseTest {
  protected:
    std::string name;
    std::string description;
    std::list<std::pair<std::string, std::string>> parameters;
    std::list<std::pair<options::base&, std::string>> options;
 
    std::set<std::string> createdFiles;
 
    static options::single<unsigned int> repeat;
    static options::single<bool> cleanup;
    static options::single<bool> urandom;
    static options::single<bool> einsZweiDrei;
    static options::single<std::string> contentFile;
    static options::single<size_t> size;
    static options::single<unsigned int> blocks;
    static options::single<std::string> content;
    static options::single<bool> truncate;
    static options::single<std::chrono::duration<double>> time;
    static options::single<unsigned long> syncus;
    static options::single<unsigned long> skewus;
    static std::string descriptions;
  public:
    static std::map<std::string, baseTest*>& getList() {
        static std::remove_reference<decltype(getList())>::type list;
        return list;
    }
    static void setUpOptions() {
        urandom.fForbid({&einsZweiDrei, &content, &contentFile});
        einsZweiDrei.fForbid({&urandom, &content, &contentFile});
        content.fForbid({&size, &urandom, &einsZweiDrei, &contentFile});
        contentFile.fForbid({&urandom, &einsZweiDrei, &content, &size});
    }
    baseTest(const std::string& aName,
             const std::string& aDescription,
             const decltype(parameters)& aParameters,
             const decltype(options)& aOptions = {}):
        name(aName),
        description(aDescription),
        parameters(aParameters),
        options(aOptions) {
        getList().emplace(name, this);
 
        descriptions += name;
        descriptions += ": ";
        descriptions += description;
        descriptions += "\n";
        if (!options.empty()) {
            descriptions += "\toptions:\n";
            for (const auto& opt : options) {
                descriptions += "\t\t";
                descriptions += opt.first.fGetLongName();
                descriptions += ": ";
                descriptions += opt.second;
                descriptions += "\n";
            }
        }
        descriptions += "\tparameters:\n";
        for (const auto& par : parameters) {
            descriptions += "\t\t";
            descriptions += par.first;
            descriptions += ": ";
            descriptions += par.second;
            descriptions += "\n";
        }
    };
    static const std::string& getDescriptions() {
        return descriptions;
    }
    virtual void execute(const std::vector<std::string>& remainingOptions) = 0;
 
    void ensuredWrite(int fd, const std::string& data) {
        auto bytesToWrite = data.size();
        auto ptr = data.data();
        while (bytesToWrite > 0) {
            auto result = write(fd, ptr, bytesToWrite);
            if (result == -1) {
                if (errno == EINTR) {
                    continue;
                } else {
                    throwcall::badval(result, -1, "write ", bytesToWrite, " to fd ", fd);
                }
            } else {
                bytesToWrite -= result;
            }
        }
    }
    void ensuredRead(int fd, std::string& data) {
        auto bytesToRead = data.size();
        auto ptr = const_cast<char*>(data.data()); // c++17 legalizes this...
        while (bytesToRead > 0) {
            auto result = read(fd, ptr, bytesToRead);
            if (result == -1 && errno == EINTR) {
                continue;
            }
            throwcall::badval(result, -1, "read ", bytesToRead, " from fd ", fd);
            bytesToRead -= result;
        }
    }
    void Execute(const std::vector<std::string>& remainingOptions) {
 
        if (size > 0) {
            content.resize(size);
        }
 
        if (urandom) {
            auto fd = throwcall::badval(open("/dev/urandom", O_RDONLY), -1, "open /dev/urandom");
            ensuredRead(fd, content);
            throwcall::good0(close(fd), "close /dev/urandom");
        }
        if (einsZweiDrei) {
            auto s = content.size();
            content.clear();
            content.reserve(s);
            for (unsigned i = 0; true; i++) {
                auto number = std::to_string(i);
                if (content.size() + number.size() < content.capacity()) {
                    content += number;
                    if (content.size() < content.capacity()) {
                        content.push_back('\n');
                    }
                } else {
                    break;
                }
            }
            while (content.size() < content.capacity()) {
                content.push_back('+');
            }
        }
        if (!contentFile.empty()) {
            auto fd = throwcall::badval(open(contentFile.c_str(), O_RDONLY), -1, "open ", contentFile);
            struct stat statData;
            throwcall::good0(fstat(fd, &statData), "stat ", contentFile);
            content.resize(statData.st_size);
            ensuredRead(fd, content);
        }
 
        std::vector<clockType::duration> times;
        times.reserve(repeat);
 
        for (unsigned i = 0; i < repeat; i++) {
            if (syncus > 0) {
                auto now = std::chrono::system_clock::now();
                auto seconds = std::chrono::duration_cast<std::chrono::microseconds>(now.time_since_epoch()).count();
                auto divresult = std::div(seconds, syncus);
                auto then = std::chrono::system_clock::time_point(std::chrono::microseconds(divresult.quot * syncus + syncus + (i % syncus) * skewus));
                std::this_thread::sleep_until(then);
            }
            auto tStart = clockType::now();
            execute(remainingOptions);
            auto tStop = clockType::now();
            auto dt = tStop - tStart;
            times.push_back(dt);
        }
        if (cleanup) {
            for (const auto& file : createdFiles) {
                std::cout << "removing " << file << "\n";
                throwcall::good0(unlink(file.c_str()), "unlink ", file);
            }
        }
 
        if (repeat == 1) {
            std::cout << "took " << times.at(0) << "s\n";
        } else {
            auto minMax = std::minmax_element(times.begin(), times.end());
            std::cout << "minimum time: " << *(minMax.first) << "s\n";
            std::cout << "maximum time: " << *(minMax.second) << "s\n";
            auto sum = std::accumulate(times.begin(), times.end(), clockType::duration::zero());
            auto mean = std::chrono::duration_cast<std::chrono::duration<double>>(sum).count() / repeat;
            std::cout << "average time: " << mean << "s\n";
            std::map<double, unsigned long> histogram;
            unsigned bins = 10;
            auto range = std::chrono::duration_cast<std::chrono::duration<double>>(*(minMax.second) - * (minMax.first)).count();
            auto lowBorder = std::chrono::duration_cast<std::chrono::duration<double>>(*(minMax.first)).count();
            if (mean < lowBorder + range / 10) { // use log bins
                auto border = lowBorder;
                histogram[border] = 0;
                auto factor = std::pow(std::chrono::duration_cast<std::chrono::duration<double>>(*(minMax.second)).count() / lowBorder,
                                       1.0 / bins);
                for (unsigned i = 0; i < bins; i++) {
                    border *= factor;
                    histogram[border] = 0;
                }
            } else { // use lin bins
                lowBorder -= range / (2 * bins);
                if (lowBorder < 0) {
                    lowBorder = 0;
                }
                for (unsigned i = 0; i < bins + 1; i++) {
                    histogram[lowBorder + i * range / bins] = 0;
                }
            }
            for (auto t : times) {
                auto bin = histogram.begin();
                for (auto testBin = bin; testBin != histogram.end(); ++testBin) {
                    if (std::chrono::duration_cast<std::chrono::duration<double>>(t).count() < testBin->first) {
                        break;
                    }
                    bin = testBin;
                }
                bin->second++;
            }
            for (auto& bin : histogram) {
                std::cout << bin.first << ": " << bin.second << "\n";
            }
        }
    }
};
std::string baseTest::descriptions = "\npossible actions and their parameters:\n";
options::single<unsigned int> baseTest::repeat('r', "repeat",
        "repeat this many times", 1);
options::single<bool> baseTest::cleanup('C', "cleanup",
                                        "remove created files after running tests");
options::single<bool> baseTest::urandom('u', "urandom",
                                        "get content from /dev/urandom");
options::single<bool> baseTest::einsZweiDrei('1', "einszweidrei",
        "set content to decimal ascenfing numbers");
options::single<std::string> baseTest::contentFile('f', "contentFile",
        "name of file for content", "");
options::single<size_t> baseTest::size('s', "size",
                                       "size of content string", 0);
options::single<unsigned int> baseTest::blocks('b', "blocks",
        "number of blocks to write", 1);
 
options::single<std::string> baseTest::content('c', "content",
        "content of file", "blabla");
options::single<bool> baseTest::truncate('T',"truncate",
                                         "use O_TRUNC on open()");
options::single<std::chrono::duration<double>> baseTest::time('t', "time",
        "characteristic test time (s)",
        std::chrono::seconds(0));
options::single<unsigned long> baseTest::syncus('\0', "syncto",
        "sync start times to sync microseconds", 0);
options::single<unsigned long> baseTest::skewus('\0', "skew",
        "skew start times by skew microseconds", 0);
 
class tmpFile: public baseTest {
  public:
    tmpFile(): baseTest("tmpFile",
                            "create a file via O_TMPFILE", {
        {"dir", "directory to create the file in"},
        {"file", "path to the file to create"}
    }) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto dir = remainingOptions.at(0);
        auto file = remainingOptions.at(1);
        auto result = unlink(file.c_str());
        if (result == -1 && errno != ENOENT) {
            throwcall::good0(result, "unlink ", file);
        }
        auto fd = throwcall::badval(open(dir.c_str(), O_TMPFILE | O_WRONLY, 0777), -1,
                                    "open anonymous file in ", dir);
        ensuredWrite(fd, content);
        std::string path("/proc/self/fd/");
        path += std::to_string(fd);
        throwcall::good0(linkat(AT_FDCWD, path.c_str(), AT_FDCWD, file.c_str(), AT_SYMLINK_FOLLOW),
                         "link ", path, " to ", file);
        throwcall::good0(close(fd), "close ", file);
        createdFiles.emplace(file);
    }
};
static tmpFile tmpFileInstance;
 
class vimWrite: public baseTest {
  public:
    vimWrite(): baseTest("vimWrite",
                             "simulate the way vim writes a file", {
        {"file", "path to the file to create"
        }
    }) {};
 
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        std::string tildeFile(file);
        tildeFile += "~";
        struct stat buf;
        unlink(tildeFile.c_str());
        if (stat(file.c_str(), &buf) != 0) {
            if (errno == ENOENT) {
                auto fd = throwcall::badval(open(file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644), -1,
                                            "open ", file);
                ensuredWrite(fd, "this is the old file...\n");
                ensuredWrite(fd, content);
                ensuredWrite(fd, "this is the old file...\n");
                throwcall::good0(close(fd), "close ", file);
            }
        }
        throwcall::good0(rename(file.c_str(), tildeFile.c_str()),
                         "rename ", file, " to ", tildeFile);
        auto fd = throwcall::badval(open(file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644), -1,
                                    "open ", file);
        ensuredWrite(fd, content);
        throwcall::good0(fsync(fd), "sync ", file);
        throwcall::good0(close(fd), "close ", file);
        throwcall::good0(unlink(tildeFile.c_str()), "unlink ", tildeFile);
        createdFiles.emplace(file);
    }
};
static vimWrite vimWriteInstance;
 
 
class keepOpen: public baseTest {
  public:
    keepOpen(): baseTest("keepOpen",
                             "open file for reading and keep open", {
        {"file", "path to file"
        }
    },
    {{time, "keep open this long"}}) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        auto fd = throwcall::badval(open(file.c_str(), O_RDONLY), -1, "open ", file);
        std::this_thread::sleep_for(time);
        throwcall::good0(close(fd), "close ", file);
    }
};
static keepOpen keepOpenInstance;
 
 
class appendBlocks: public baseTest {
  public:
    appendBlocks(): baseTest("appendBlocks",
                                 "create a file and append blocks to it, changing the first one.", {
        {"file", "path to file"
        }
    },
    {{time, "wait this long between writes"}}) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        for (unsigned i = 0; i < blocks; i++) {
            if (i > 0) {
                std::this_thread::sleep_for(time);
            }
            auto fd = throwcall::badval(open(file.c_str(), O_CREAT | O_WRONLY, 0744), -1, "open ", file);
            throwcall::badval(lseek(fd, 0, SEEK_END), -1, "seek to end of ", file);
            ensuredWrite(fd, content);
            throwcall::badval(lseek(fd, 0, SEEK_SET), -1, "seek to start of ", file);
            ensuredWrite(fd, std::to_string(i));
            throwcall::good0(close(fd), "close ", file);
        }
        createdFiles.emplace(file);
    };
 
};
static appendBlocks appendBlocksInstance;
 
class simpleWrite: public baseTest {
  public:
    simpleWrite(): baseTest("simpleWrite",
                                "create a file and write into it", {
        {"file", "path to file"
        }
    },
        {{time, "wait this long between writes"},
         {truncate, "use O_TRUNC on open()"}}) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        auto fd = throwcall::badval(open(file.c_str(), O_CREAT | O_WRONLY | ( truncate ? O_TRUNC : 0), 0744), -1, "open ", file);
        for (unsigned i = 0; i < blocks; i++) {
            if (i > 0) {
                std::this_thread::sleep_for(time);
            }
            ensuredWrite(fd, content);
        }
        throwcall::good0(close(fd), "close ", file);
        createdFiles.emplace(file);
    };
};
static simpleWrite simpleWriteInstance;
 
 
class cpWrite: public baseTest {
  public:
    cpWrite(): baseTest("cpWrite",
                                "create a file and write into it like cp does", {
        {"file", "path to file"
        }
    },
    {{time, "wait this long between writes"}}) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        auto fd = throwcall::badval(open(file.c_str(), O_CREAT | O_WRONLY | O_EXCL, 0700), -1, "open ", file);
        for (unsigned i = 0; i < blocks; i++) {
            if (i > 0) {
                std::this_thread::sleep_for(time);
            }
            ensuredWrite(fd, content);
        }
        throwcall::good0(fchmod(fd,0755), "fchmod ", file);
        throwcall::good0(close(fd), "close ", file);
        createdFiles.emplace(file);
    };
};
static cpWrite cpWriteInstance;
 
 
class directWrite: public baseTest {
  public:
    directWrite(): baseTest("directWrite",
                                "create a file with O_DIRECT and write into it", {
        {"file", "path to file"
        }
    },
    {{time, "wait this long between writes"}}) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        // we need a page aligned buffer
        auto buffer = throwcall::badval(mmap(nullptr, content.size(),
                                             PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS,
                                             -1, 0),
                                        MAP_FAILED,
                                        "mmap ", content.size(), " bytes anonymously");
        memcpy(buffer, content.data(), content.size());
        auto fd = throwcall::badval(open(file.c_str(), O_CREAT | O_WRONLY | O_DIRECT, 0744), -1, "open ", file);
        for (unsigned i = 0; i < blocks; i++) {
            if (i > 0) {
                std::this_thread::sleep_for(time);
            }
            throwcall::good0(write(fd, buffer, content.size()) - content.size(), "write");
        }
        throwcall::good0(close(fd), "close ", file);
        throwcall::good0(munmap(buffer, content.size()), "munmap buffer");
        createdFiles.emplace(file);
    };
};
static directWrite directWriteInstance;
 
class mmapWrite: public baseTest {
  public:
    mmapWrite(): baseTest("mmapWrite",
                              "create a file, mmap() it and write into it", {
        {"file", "path to file"
        }
    }) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        auto fd = throwcall::badval(open(file.c_str(), O_CREAT | O_RDWR, 0744), -1, "open ", file);
        auto mapSize = content.size() * blocks;
        throwcall::good0(ftruncate(fd, mapSize), "truncate to ", mapSize, " bytes");
        auto map = throwcall::badval(mmap(nullptr, mapSize,
                                          PROT_WRITE, MAP_SHARED,
                                          fd, 0),
                                     MAP_FAILED,
                                     "mmap ", content.size(), " bytes from ", file);
        for (unsigned i = 0; i < blocks; i++) {
            memcpy(static_cast<char*>(map) + content.size()*i, content.data(), content.size());
        }
        throwcall::good0(munmap(map, mapSize), "munmap");
        throwcall::good0(close(fd), "close ", file);
        createdFiles.emplace(file);
    };
};
static mmapWrite mmapWriteInstance;
 
class sparseWrite: public baseTest {
  public:
    sparseWrite(): baseTest("sparseWrite",
                                "create a sparse file, data (hole data){blocks}", {
        {"file", "path to file"
        }
    }) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        auto fd = throwcall::badval(open(file.c_str(), O_CREAT | O_WRONLY, 0744), -1, "open ", file);
        ensuredWrite(fd, content);
        for (unsigned i = 0; i < blocks; i++) {
            throwcall::badval(lseek(fd, content.size(), SEEK_CUR), -1,
                              "lseek in ", file, " for ", content.size(), " bytes");
            ensuredWrite(fd, content);
        }
        throwcall::good0(close(fd), "close ", file);
        createdFiles.emplace(file);
    };
};
static sparseWrite sparseWriteInstance;
 
class sparseWrite2: public baseTest {
  public:
    sparseWrite2(): baseTest("sparseWrite2",
                                 "create a sparse file, hole (data hole){blocks}", {
        {"file", "path to file"
        }
    }) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        auto fd = throwcall::badval(open(file.c_str(), O_CREAT | O_WRONLY, 0744), -1, "open ", file);
        throwcall::badval(lseek(fd, content.size(), SEEK_CUR), -1,
                          "lseek in ", file, " for ", content.size(), " bytes");
        for (unsigned i = 0; i < blocks; i++) {
            ensuredWrite(fd, content);
            throwcall::good0(ftruncate(fd, lseek(fd, 0, SEEK_CUR) + content.size()), "truncate ", file);
            throwcall::badval(lseek(fd, content.size(), SEEK_CUR), -1,
                              "lseek in ", file, " for ", content.size(), " bytes");
        }
        throwcall::good0(close(fd), "close ", file);
        createdFiles.emplace(file);
    };
};
static sparseWrite2 sparseWriteInstance2;
 
 
 
class findMinHoleSize: public baseTest {
  public:
    findMinHoleSize(): baseTest("findMinHoleSize",
                                    "find minimum hole size", {
        {"file", "path to file"
        }
    }) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        auto fd = throwcall::badval(open(file.c_str(), O_CREAT | O_WRONLY, 0744), -1, "open ", file);
        struct stat statbuf;
        throwcall::good0(fstat(fd, &statbuf), "stat ", file);
        auto testSize = statbuf.st_blksize;
        while (testSize > 0) {
            throwcall::good0(close(fd), "close ", file);
            fd = throwcall::badval(open(file.c_str(), O_WRONLY | O_TRUNC, 0744), -1, "open ", file);
            throwcall::badval(lseek(fd, testSize, SEEK_SET), -1, "seek ", testSize, " in ", file);
            ensuredWrite(fd, content);
            throwcall::good0(close(fd), "close ", file);
            createdFiles.emplace(file);
            fd = throwcall::badval(open(file.c_str(), O_RDONLY), -1, "open ", file);
            auto dataPos = throwcall::badval(lseek(fd, 0, SEEK_DATA), -1, "seek data in ", file);
            if (dataPos != testSize) {
                break;
            }
            std::cout << testSize << " bytes hole size worked\n";
            testSize /= 2;
        }
    };
};
static findMinHoleSize findMinHoleSizeInstance;
 
 
class appendHole: public baseTest {
  public:
    appendHole(): baseTest("appendHole",
                               "append a hole to an existing file", {
        {"file", "path to file"
        }
    }) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        auto fd = throwcall::badval(open(file.c_str(), O_WRONLY, 0744), -1, "open ", file);
        auto oldFileEnd = throwcall::badval(lseek(fd, 0, SEEK_END), -1, "seek end of ", file);
        throwcall::good0(ftruncate(fd, oldFileEnd + content.size() * blocks), "truncate ", file);
        throwcall::good0(close(fd), "close ", file);
        createdFiles.emplace(file);
    };
};
static appendHole appendHoleInstance;
 
 
class createUnlinkCreate: public baseTest {
  public:
    createUnlinkCreate(): baseTest("createUnlink",
                                       "create, unlink, re-create a file", {
        {"file", "path to file"
        }
    }) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        auto fd = throwcall::badval(open(file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0744), -1, "open ", file);
        ensuredWrite(fd, "fist creation (before unlink)\n");
        ensuredWrite(fd, content);
        throwcall::good0(close(fd), "close ", file);
        throwcall::good0(unlink(file.c_str()), "unlink ", file);
        fd = throwcall::badval(open(file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0744), -1, "open ", file);
        ensuredWrite(fd, "second creation (after unlink)\n");
        ensuredWrite(fd, content);
        throwcall::good0(close(fd), "close ", file);
        createdFiles.emplace(file);
    };
};
static createUnlinkCreate createUnlinkCreateInstance;
 
class closeMvUpdate: public baseTest {
  public:
    closeMvUpdate(): baseTest("closeMvUpdate",
                                  "close, move, update a file", {
        {"file", "path to file"
        }
    }) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        std::string movedFile(file);
        movedFile += ".moved";
        auto fd = throwcall::badval(open(file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0744), -1, "open ", file);
        ensuredWrite(fd, content);
        throwcall::good0(close(fd), "close ", file);
        throwcall::good0(rename(file.c_str(), movedFile.c_str()),
                         "rename ", file, " to ", movedFile);
        struct timespec times[2] = {{0, UTIME_OMIT}, {0, UTIME_NOW}};
        throwcall::good0(utimensat(AT_FDCWD, movedFile.c_str(), times, 0),
                         "change mtime of ", file);
        createdFiles.emplace(movedFile);
    };
};
static closeMvUpdate closeMvUpdateInstance;
 
class createUnlinkClose: public baseTest {
  public:
    createUnlinkClose(): baseTest("createUnlinkClose",
                                      "create, unlink, update a file", {
        {"file", "path to file"
        }
    }) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        auto fd = throwcall::badval(open(file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0744), -1, "open ", file);
        throwcall::good0(unlink(file.c_str()), "unlink ", file);
        ensuredWrite(fd, content);
        throwcall::good0(close(fd), "close ", file);
    };
};
static createUnlinkClose createUnlinkCloseInstance;
 
class simpleRead: public baseTest {
  public:
    simpleRead(): baseTest("simpleRead",
                               "read file and compare to content", {
        {"file", "path to file"
        }
    }) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        auto fd = throwcall::badval(open(file.c_str(), O_RDONLY), -1, "open ", file);
        std::string data(content.size(), '\0');
        ensuredRead(fd, data);
        if (data.compare(content) != 0) {
            std::cout << "difference betwen content and file found\n";
        }
        throwcall::good0(close(fd), "close ", file);
    };
};
static simpleRead simpleReadInstance;
 
class mmapRead: public baseTest {
  public:
    mmapRead(): baseTest("mmapRead",
                             "read file via mmap() and compare to content", {
        {"file", "path to file"
        }
    }) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        auto fd = throwcall::badval(open(file.c_str(), O_RDONLY), -1, "open ", file);
        auto map = throwcall::badval(mmap(nullptr, content.size(),
                                          PROT_READ, MAP_PRIVATE | MAP_POPULATE,
                                          fd, 0),
                                     MAP_FAILED,
                                     "mmap ", content.size(), " bytes from ", file);
        auto data = static_cast<const char *>(map);
        if (content.compare(0, content.size(), data, content.size()) != 0) {
            std::cout << "difference betwen content and file found\n";
        }
        throwcall::good0(munmap(map, content.size()), "unmap ", file);
        throwcall::good0(close(fd), "close ", file);
    };
};
static mmapRead mmapReadInstance;
 
 
class truncateToSize: public baseTest {
  public:
    truncateToSize(): baseTest("truncateToSize",
                                   "truncate existing file to it;s size", {
        {"file", "path to file"
        }
    }) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        auto fd = throwcall::badval(open(file.c_str(), O_WRONLY), -1, "open ", file);
        struct stat statbuf;
        throwcall::good0(fstat(fd, &statbuf), "stat ", file);
        throwcall::good0(ftruncate(fd, statbuf.st_size), "truncate ", file, " to ", statbuf.st_size, " bytes");
        throwcall::good0(close(fd), "close ", file);
    };
};
static truncateToSize truncateToSizeInstance;
 
#ifdef withGpfs
class gpfsPrealloc: public baseTest {
  public:
    gpfsPrealloc(): baseTest("gpfsPrealloc",
                                 "write a file with gpfsRealloc", {
        {"file", "path to file"
        }
    }) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto file = remainingOptions.at(0);
        auto fd = throwcall::badval(open(file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0744), -1, "open ", file);
        throwcall::good0(gpfs_prealloc(fd, 0, content.size()),
                         "gpfs_prealloc ", content.size(), " bytes for ", file);
        ensuredWrite(fd, content);
        throwcall::good0(close(fd), "close ", file);
    };
};
static gpfsPrealloc gpfsPreallocInstance;
#endif
 
class uglyNames: public baseTest {
  public:
    uglyNames(): baseTest("uglyNames",
                                 "write files with ugly names", {
        {"dir", "directory to create the files in"
        }
    }) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto dir = remainingOptions.at(0);
        auto dirfd = throwcall::badval(open(dir.c_str(),O_PATH | O_DIRECTORY),-1,"can't open ",dir);
        std::list<std::string> names{"name with spaces",
                                     "name\nwith\nnewlines",
                                     "name\rwith\rreturns",
                                     "name\r\nwith\r\nCRLF",
                                     "name_with_\033[91mred\033[0m_part",
                                     "name_with_\xe2\x80\xadleft-to-right\xe2\x80\x8e_part",
                                     "name_with_\xe2\x82\xac_euro",
                                     "name_with_ɄɳɨȻʘΔε_unicode",
                                     "name_with_🤔💩☢_emojis",
                                     "name_with_䭫顙_more_unicode"
        };
        {
            std::list<std::pair<std::string,unsigned char>> ControlChars{
                {"SOH", 001},   {"STX", 002},   {"ETX", 003},   {"EOT", 004},
                                {"ENQ", 005},   {"ACK", 006},
                                        {"BEL", 007},
                                            {"BS", 010},
                                                {"HT", 011},
                                                    {"LF", 012},
                                                        {"VT", 013},
                                                            {"FF", 014},
                                                                {"CR", 015},
                                                                    {"SO", 016},
                                                                        {"SI", 017},
                                                                            {"DLE", 020},
                                                                                {"DC1", 021},
                                                                                    {"DC2", 022},
                                                                                        {"DC3", 023},
                                                                                            {"DC4", 024},
                                                                                                {"NAK", 025},
                                                                                                    {"SYN", 026},
                                                                                                        {"ETB", 027},
                                                                                                            {"CAN", 030},
                                                                                                                {"EM", 031},
{"SUB", 032},
{"ESC", 033},
{"FS", 034},
{"GS", 035},
{"RS", 036},
{"US", 037},
{"DEL",0177}
            };
            for (const auto& cc: ControlChars) {
                std::string ugly("name_with_");
                ugly.push_back(cc.second);
                ugly+="_char_";
                ugly+=std::to_string(cc.second);
                ugly+="_";
                ugly+=cc.first;
                names.push_back(ugly);
            }
        }
        {
            std::vector<std::pair<unsigned char, unsigned char>> ranges{{32,46},{58,63},{91,96},{123,126}};
            for (const auto& range: ranges) { 
                for (unsigned char c=range.first; c<=range.second; c++) {
                    std::string ugly("name_with_");
                    ugly.push_back(c);
                    ugly+="_char_";
                    ugly+=std::to_string(c);
                    names.push_back(ugly);
                }
            }
        }
        for (unsigned char c=128; c!=0; c++) {
            std::string ugly("name_with_");
            ugly.push_back(c);
            ugly+="_char_";
            ugly+=std::to_string(c);
            names.push_back(ugly);
        }
        {
            auto nameMax = throwcall::badval(fpathconf(dirfd,_PC_NAME_MAX),-1,"can't get max name length");
            auto ugly = std::to_string(nameMax);
            ugly.resize(nameMax,'b');
            names.push_back(ugly);
        }
 
        for (const auto& ugly: names) {
            std::string file(dir);
            file+="/";
            file+=ugly;
            auto fd = openat(dirfd,ugly.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0744);
            if (fd == -1 && errno == EINVAL) {
                std::cerr << "illegal file name \" << ugly << \" tried: ";
                for (auto c : ugly) {
                    std::cerr << std::hex << std::setw(2) << c;
                }
                std::cerr << std::dec << "\n";
                continue;
            } else {
                throwcall::badval(fd,-1, "open ", file);
            }
            ensuredWrite(fd, ugly);
            throwcall::good0(close(fd), "close ", file);
            createdFiles.emplace(file);
        }
    };
};
static uglyNames uglyNamesInstance;
 
class uglyPaths: public baseTest {
  public:
    uglyPaths(): baseTest("uglyPaths",
                                 "write files in paths with ugly names", {
        {"dir", "directory to create the paths in"
        }
    }) {};
    void execute(const std::vector<std::string>& remainingOptions) override {
        auto dir = remainingOptions.at(0);
        auto dirfd = throwcall::badval(open(dir.c_str(),O_PATH | O_DIRECTORY),-1,"can't open ",dir);
        std::list<std::string> names{"path with spaces",
                                     "path\nwith\nnewlines",
                                     "path\rwith\rreturns",
                                     "path\r\nwith\r\nCRLF",
                                     "path_with_\033[91mred\033[0m_part",
                                     "path_with_\xe2\x80\xadleft-to-right\xe2\x80\x8e_part",
                                     "path_with_\xe2\x82\xac_euro",
                                     "path_with_ɄɳɨȻʘΔε_unicode",
                                     "path_with_🤔💩☢_emojis",
                                     "path_with_䭫顙_more_unicode"
        };
        {
            auto nameMax = throwcall::badval(fpathconf(dirfd,_PC_NAME_MAX),-1,"can't get max name length");
            auto ugly = std::to_string(nameMax);
            ugly.resize(nameMax,'b');
            names.push_back(ugly);
        }
 
        for (const auto& ugly: names) {
            auto retval = mkdirat(dirfd,ugly.c_str(), 0777);
            if (retval == -1 && errno == EINVAL) {
                std::cerr << "illegal dir name \" << ugly << \" tried \n";
                continue;
            } else {
                throwcall::badval(retval,-1, "mkdir ", ugly);
            }
            std::string file(ugly);
            file += "/file";
            auto fd = throwcall::badval(openat(dirfd, file.c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0744),
                                        -1, "open ", file);
            ensuredWrite(fd, ugly);
            throwcall::good0(close(fd), "close ", file);
            createdFiles.emplace(dir + "/" + file);
        }
    };
};
static uglyPaths uglyPathsInstance;
 
 
int main(int argc, const char *argv[]) {
    options::parser parser("test utility for strange file operations",
                           baseTest::getDescriptions());
    baseTest::setUpOptions();
    options::positional<options::single<std::string>> action(10, "action", "test to execute",
            "");
    parser.fRequire(&action);
    for (const auto& test : baseTest::getList()) {
        action.fAddToRange(test.first);
    }
    auto remainingOptions = parser.fParse(argc, argv);
 
    auto test = baseTest::getList().find(action);
    if (test != baseTest::getList().end()) {
        test->second->Execute(remainingOptions);
    } else {
        std::cerr << "unknown action '" << action << "'\n";
        return EXIT_FAILURE;
    }
    return EXIT_SUCCESS;
}