statvfs.cpp

Go to the documentation of this file.

#include <sys/statvfs.h>
#include <sys/vfs.h>
#include <iostream>
#include <list>
#include "Options.h"
#include "throwcall.h"
 
class fieldHandlerBase {
  protected:
    std::string fieldName;
    std::string explanation;
  public:
    options::single<bool> opt;
    fieldHandlerBase(char shortName,
                     const std::string& aName,
                     const std::string& aExplanation) :
        fieldName(aName),
        explanation(aExplanation),
        opt(shortName, aName, aExplanation) {};
    virtual void print(const std::string& fsname,
                       const struct statvfs& stat,
                       bool printAll) = 0;
};
 
static options::single<bool> quiet('q', "quiet", "be quiet: no prefix to values");
 
template <typename T> class fieldHandlerTpl : public fieldHandlerBase {
    T statvfs::* field;
  public:
    fieldHandlerTpl(decltype(field) aField,
                    char shortName,
                    const std::string& aName,
                    const std::string& aExplanation) : fieldHandlerBase(shortName, aName, aExplanation),
        field(aField) {};
    void print(const std::string& fsname,
               const struct statvfs& stat,
               bool printAll) override {
        if (printAll || opt) {
            if (!quiet) {
                std::cout << fsname << " " << fieldName <<  ": ";
            }
            std::cout << stat.*field << "\n";
        }
    }
};
 
 
class idHandler : public fieldHandlerTpl<unsigned long> {
  public:
    idHandler(char shortName, const std::string& aName, const std::string& aExplanation) : fieldHandlerTpl<unsigned long>(&statvfs::f_fsid, shortName, aName, aExplanation) {};
    void print(const std::string& fsname,
               const struct statvfs& stat,
               bool printAll) override {
        std::cout << std::hex;
        fieldHandlerTpl::print(fsname, stat, printAll);
        std::cout << std::dec;
    }
};
 
// magic map, create via
// awk '/_MAGIC[ \t]/{print "\t{"$3",@"$2"@},"}' /usr/include/linux/magic.h  /usr/include/gpfs.h | tr @ '"'
static std::map<__fsword_t, std::string> magicMap {
    {0xadf5, "ADFS_SUPER_MAGIC"},
    {0xadff, "AFFS_SUPER_MAGIC"},
    {0x5346414F, "AFS_SUPER_MAGIC"},
    {0x0187, "AUTOFS_SUPER_MAGIC"},
    {0x73757245, "CODA_SUPER_MAGIC"},
    {0x28cd3d45, "CRAMFS_MAGIC"},
    {0x64626720, "DEBUGFS_MAGIC"},
    {0x73636673, "SECURITYFS_MAGIC"},
    {0xf97cff8c, "SELINUX_MAGIC"},
    {0x43415d53, "SMACK_MAGIC"},
    {0x858458f6, "RAMFS_MAGIC"},
    {0x01021994, "TMPFS_MAGIC"},
    {0x958458f6, "HUGETLBFS_MAGIC"},
    {0x73717368, "SQUASHFS_MAGIC"},
    {0xf15f, "ECRYPTFS_SUPER_MAGIC"},
    {0x414A53, "EFS_SUPER_MAGIC"},
    {0xEF53, "EXT2_SUPER_MAGIC"},
    {0xEF53, "EXT3_SUPER_MAGIC"},
    {0xabba1974, "XENFS_SUPER_MAGIC"},
    {0xEF53, "EXT4_SUPER_MAGIC"},
    {0x9123683E, "BTRFS_SUPER_MAGIC"},
    {0x3434, "NILFS_SUPER_MAGIC"},
    {0xF2F52010, "F2FS_SUPER_MAGIC"},
    {0xf995e849, "HPFS_SUPER_MAGIC"},
    {0x9660, "ISOFS_SUPER_MAGIC"},
    {0x72b6, "JFFS2_SUPER_MAGIC"},
    {0x6165676C, "PSTOREFS_MAGIC"},
    {0xde5e81e4, "EFIVARFS_MAGIC"},
    {0x00c0ffee, "HOSTFS_SUPER_MAGIC"},
    {0x794c7630, "OVERLAYFS_SUPER_MAGIC"},
    {0x137F, "MINIX_SUPER_MAGIC"},
    {0x2468, "MINIX2_SUPER_MAGIC"},
    {0x4d5a, "MINIX3_SUPER_MAGIC"},
    {0x4d44, "MSDOS_SUPER_MAGIC"},
    {0x564c, "NCP_SUPER_MAGIC"},
    {0x6969, "NFS_SUPER_MAGIC"},
    {0x9fa1, "OPENPROM_SUPER_MAGIC"},
    {0x002f, "QNX4_SUPER_MAGIC"},
    {0x68191122, "QNX6_SUPER_MAGIC"},
    {0x52654973, "REISERFS_SUPER_MAGIC"},
    {0x517B, "SMB_SUPER_MAGIC"},
    {0x27e0eb, "CGROUP_SUPER_MAGIC"},
    {0x7655821, "RDTGROUP_SUPER_MAGIC"},
    {0x57AC6E9D, "STACK_END_MAGIC"},
    {0x01021997, "V9FS_MAGIC"},
    {0x62646576, "BDEVFS_MAGIC"},
    {0x64646178, "DAXFS_MAGIC"},
    {0x42494e4d, "BINFMTFS_MAGIC"},
    {0x1cd1, "DEVPTS_SUPER_MAGIC"},
    {0xBAD1DEA, "FUTEXFS_SUPER_MAGIC"},
    {0x50495045, "PIPEFS_MAGIC"},
    {0x9fa0, "PROC_SUPER_MAGIC"},
    {0x534F434B, "SOCKFS_MAGIC"},
    {0x62656572, "SYSFS_MAGIC"},
    {0x9fa2, "USBDEVICE_SUPER_MAGIC"},
    {0x11307854, "MTD_INODE_FS_MAGIC"},
    {0x09041934, "ANON_INODE_FS_MAGIC"},
    {0x73727279, "BTRFS_TEST_MAGIC"},
    {0xcafe4a11, "BPF_FS_MAGIC"},
    // extras that are NOT in the magic.h
    {0x47504653, "GPFS_SUPER_MAGIC"}
};
 
int main(int argc, const char *argv[]) {
    options::parser parser("", "", {});
    std::list<fieldHandlerBase*> handlers;
    handlers.emplace_back(new fieldHandlerTpl<unsigned long>(&statvfs::f_bsize, 'b', "bsize", "block size"));
    handlers.emplace_back(new fieldHandlerTpl<unsigned long>(&statvfs::f_frsize, 'f', "frsize", "fragment size"));
    handlers.emplace_back(new fieldHandlerTpl<fsblkcnt_t>(&statvfs::f_blocks, 'B', "blocks", "size in frsize units"));
    handlers.emplace_back(new fieldHandlerTpl<fsblkcnt_t>(&statvfs::f_bfree, 'F', "bfree", "free blocks"));
    handlers.emplace_back(new fieldHandlerTpl<fsblkcnt_t>(&statvfs::f_bavail, 'A', "bavail", "available blocks"));
    handlers.emplace_back(new fieldHandlerTpl<fsfilcnt_t>(&statvfs::f_files, 'I', "files", "number of inodes"));
    handlers.emplace_back(new fieldHandlerTpl<fsfilcnt_t>(&statvfs::f_ffree, 'J', "ffree", "free inodes"));
    handlers.emplace_back(new fieldHandlerTpl<fsfilcnt_t>(&statvfs::f_favail, 'a', "favail", "available inodes"));
    handlers.emplace_back(new idHandler('i', "fsid", "filesystem id"));
    handlers.emplace_back(new fieldHandlerTpl<unsigned long>(&statvfs::f_flag, 'l', "fflag", "flags"));
    handlers.emplace_back(new fieldHandlerTpl<unsigned long>(&statvfs::f_namemax, 'm', "namemax", "max filename length"));
    options::single<bool> type('t', "type", "type of filesystem as number");
    options::single<bool> Type('T', "Type", "type of filesystem as string");
    options::positional<options::container<std::string>> fileSystems(10, "filesystems", "filesystems to look at");
    parser.fParse(argc, argv);
 
    bool printAll = !(type || Type);
    for (auto& handler : handlers) {
        if (handler->opt) {
            printAll = false;
        }
    }
 
    for (const auto& filesystem : fileSystems) {
        {
            struct statvfs stat;
            throwcall::good0(statvfs(filesystem.c_str(), &stat), "can't statvfs ", filesystem);
            for (auto& handler : handlers) {
                handler->print(filesystem, stat, printAll);
            }
        }
        if (type || Type || printAll) {
            struct statfs stat;
            throwcall::good0(statfs(filesystem.c_str(), &stat), "can't statfs ", filesystem);
            if (!quiet) {
                std::cout << filesystem << " " << "type" << ": ";
            }
            if (type || printAll) {
                std::cout << stat.f_type;
                if (Type || printAll) {
                    std::cout << " ";
                }
            }
            if (Type || printAll) {
                auto item = magicMap.find(stat.f_type);
                if (item == magicMap.end()) {
                    std::cout << "unknown";
                } else {
                    std::cout << item->second;
                }
            }
            std::cout << "\n";
        }
    }
}