zircon/system/ulib/fs-host/common.cpp

// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <assert.h>
#include <getopt.h>
#include <inttypes.h>
#include <libgen.h>
#include <limits.h>
#include <sys/stat.h>

#include <fbl/algorithm.h>
#include <fbl/auto_call.h>

#include "fs-host/common.h"

#define MIN_ARGS 3

// Options struct.
struct {
    const char* name;
    Option option;
    const char* argument;
    const char* default_value;
    const char* help;
} OPTS[] = {
    {"depfile",  Option::kDepfile,  "",        nullptr,
        "Produce a depfile"},
    {"readonly", Option::kReadonly, "",        nullptr,
        "Mount filesystem read-only"},
    {"offset",   Option::kOffset,   "[bytes]", "0",
        "Byte offset at which minfs partition starts"},
    {"length",   Option::kLength,   "[bytes]", "Remaining Length",
        "Length in bytes of minfs partition"},
    {"compress", Option::kCompress, "",        nullptr,
        "Compress files before adding them to blobfs"},
    {"sizes", Option::kSizes, "[file]", nullptr,
        "Record sizes of written entries to file"},
    {"help",     Option::kHelp,     "",        nullptr,
        "Display this message"},
};

// Commands struct.
// clang-format off
struct {
    const char* name;
    Command command;
    uint32_t flags;
    ArgType arg_type;
    const char* help;
} CMDS[] = {
    {"create",         Command::kMkfs,               O_RDWR | O_CREAT, ArgType::kOptional,
        "Initialize filesystem."},
    {"mkfs",           Command::kMkfs,               O_RDWR | O_CREAT, ArgType::kOptional,
        "Initialize filesystem."},
    {"check",          Command::kFsck,               O_RDONLY,         ArgType::kNone,
        "Check filesystem integrity."},
    {"fsck",           Command::kFsck,               O_RDONLY,         ArgType::kNone,
        "Check filesystem integrity."},
    {"used-data-size", Command::kUsedDataSize,       O_RDONLY,         ArgType::kNone,
        "Prints total bytes consumed by data."},
    {"used-inodes",    Command::kUsedInodes,         O_RDONLY,         ArgType::kNone,
        "Prints number of allocated inodes."},
    {"used-size",      Command::kUsedSize,           O_RDONLY,         ArgType::kNone,
        "Prints total bytes used by data and reserved for fs internal data structures."},
    {"add",            Command::kAdd,                O_RDWR,           ArgType::kMany,
        "Add files to an fs image (additional arguments required)."},
    {"cp",             Command::kCp,                 O_RDWR,           ArgType::kTwo,
        "Copy to/from fs."},
    {"mkdir",          Command::kMkdir,              O_RDWR,           ArgType::kOne,
        "Create directory."},
    {"ls",             Command::kLs,                 O_RDONLY,         ArgType::kOne,
        "List contents of directory."},
    {"manifest",       Command::kManifest,           O_RDWR,           ArgType::kOne,
        "Add files to fs as specified in manifest (deprecated)."},
};
// clang-format on

// Arguments struct.
struct {
    const char* name;
    Argument argument;
} ARGS[] = {
    {"--manifest", Argument::kManifest},
    {"--blob",     Argument::kBlob},
};

zx_status_t FsCreator::ProcessAndRun(int argc, char** argv) {
    zx_status_t status;
    if ((status = ProcessArgs(argc, argv)) != ZX_OK) {
        return status;
    }

    return RunCommand();
}

zx_status_t FsCreator::Usage() {
    fprintf(stderr,
            "usage: %s [ <option>* ] <file-or-device>[@<size>] <command> [ <arg>* ]\n\n",
            GetToolName());

    // Display all valid pre-command options.
    bool first = true;
    for (unsigned n = 0; n < fbl::count_of(OPTS); n++) {
        if (IsOptionValid(OPTS[n].option)) {
            fprintf(stderr, "%-8s -%c|--%-8s ", first ? "options:" : "",
                    OPTS[n].name[0], OPTS[n].name);

            fprintf(stderr, "%-8s", OPTS[n].argument);

            fprintf(stderr, "\t%s\n", OPTS[n].help);
            if (OPTS[n].default_value != nullptr) {
                fprintf(stderr, "%33s(Default = %s)\n", "", OPTS[n].default_value);
            }
            first = false;
        }
    }
    fprintf(stderr, "\n");

    // Display all valid commands.
    first = true;
    for (unsigned n = 0; n < fbl::count_of(CMDS); n++) {
        if (IsCommandValid(CMDS[n].command)) {
            fprintf(stderr, "%9s %-10s %s\n", first ? "commands:" : "",
                    CMDS[n].name, CMDS[n].help);
            first = false;
        }
    }
    fprintf(stderr, "\n");

    // Display all valid '--' arguments.
    fprintf(stderr, "arguments (valid for create, one or more required for add):\n");
    for (unsigned n = 0; n < fbl::count_of(ARGS); n++) {
        if (IsArgumentValid(ARGS[n].argument)) {
            fprintf(stderr, "\t%-10s <path>\n", ARGS[n].name);
        }
    }

    return ZX_ERR_INVALID_ARGS;
}

zx_status_t FsCreator::ProcessManifest(char* manifest_path) {
    fbl::unique_fd manifest_fd(open(manifest_path, O_RDONLY, 0644));
    if (!manifest_fd) {
        fprintf(stderr, "error: cannot open '%s'\n", manifest_path);
        return ZX_ERR_IO;
    }

    char dir_path[PATH_MAX];
    strncpy(dir_path, dirname(manifest_path), PATH_MAX);
    FILE* manifest = fdopen(manifest_fd.release(), "r");
    while (true) {
        // Keep processing lines in the manifest until we have reached EOF.
        zx_status_t status = ProcessManifestLine(manifest, dir_path);
        if (status == ZX_ERR_OUT_OF_RANGE) {
            fclose(manifest);
            return ZX_OK;
        } else if (status != ZX_OK) {
            fclose(manifest);
            return status;
        }
    }
}

zx_status_t FsCreator::ParseManifestLine(FILE* manifest, const char* dir_path, char* src, char* dst) {
    size_t size = 0;
    char* line = nullptr;

    // Always free the line on exiting this method.
    auto cleanup = fbl::MakeAutoCall([&line]() { if (line) free(line); });

    // Retrieve the next line from the manifest.
    ssize_t r = getline(&line, &size, manifest);
    if (r < 0) {
        return ZX_ERR_OUT_OF_RANGE;
    }

    // Exit early if line is commented out
    if (line[0] == '#') {
        return ZX_OK;
    }

    char* equals = strchr(line, '=');
    char* src_start = line;

    if (equals != nullptr) {
        // If we found an '=', there is a destination in this line.
        // (Note that destinations are allowed but not required for blobfs.)
        if (strchr(equals + 1, '=') != nullptr) {
            fprintf(stderr, "Too many '=' in input\n");
            return ZX_ERR_INVALID_ARGS;
        }

        src_start = equals + 1;
        equals[0] = '\0';

        strncat(dst, line, PATH_MAX - strlen(dst));
    }

    // If the source is not an absolute path, append the manifest's local directory.
    if (src_start[0] != '/') {
        strncpy(src, dir_path, PATH_MAX);
        strncat(src, "/", PATH_MAX - strlen(src));
    }

    strncat(src, src_start, PATH_MAX - strlen(src));

    // Set the source path to terminate if it currently ends in a new line.
    char* new_line = strchr(src, '\n');
    if (new_line != nullptr) {
        *new_line = '\0';
    }

    return ZX_OK;
}

zx_status_t FsCreator::ProcessArgs(int argc, char** argv) {
    if (argc < MIN_ARGS) {
        fprintf(stderr, "Not enough args\n");
        return Usage();
    }

    bool depfile_needed = false;

    // Read options.
    while (true) {
        // Set up options struct for pre-device option processing.
        unsigned index = 0;
        struct option opts[fbl::count_of(OPTS) + 1];
        for (unsigned n = 0; n < fbl::count_of(OPTS); n++) {
            if (IsOptionValid(OPTS[n].option)) {
                opts[index].name = OPTS[n].name;
                opts[index].has_arg = strlen(OPTS[n].argument) ? required_argument : no_argument;
                opts[index].flag = nullptr;
                opts[index].val = OPTS[n].name[0];
                index++;
            }
        }

        opts[index] = {nullptr, 0, nullptr, 0};

        int opt_index;
        int c = getopt_long(argc, argv, "+dro:l:cs:h", opts, &opt_index);
        if (c < 0) {
            break;
        }
        switch (c) {
        case 'd':
            depfile_needed = true;
            break;
        case 'r':
            read_only_ = true;
            break;
        case 'o':
            offset_ = atoll(optarg);
            if (offset_ < 0) {
                fprintf(stderr, "error: offset < 0\n");
                return ZX_ERR_INVALID_ARGS;
            }
            break;
        case 'l':
            length_ = atoll(optarg);
            if (length_ < 0) {
                fprintf(stderr, "error: length < 0\n");
                return ZX_ERR_INVALID_ARGS;
            }
            break;
        case 'c':
            compress_ = true;
            break;
        case 's': {
            const char* const sizes_file = optarg;
            if (!size_recorder_.OpenSizeFile(sizes_file)) {
                fprintf(stderr, "error: cannot open '%s'\n", sizes_file);
                return ZX_ERR_IO;
            }
            break;
        }
        case 'h':
        default:
            return Usage();
        }

    }

    argc -= optind;
    argv += optind;

    if (argc < 2) {
        fprintf(stderr, "Not enough arguments\n");
        return Usage();
    }

    // Read device name.
    char* device = argv[0];
    argc--;
    argv++;

    // Read command name.
    char* command = argv[0];
    argc--;
    argv++;

    uint32_t open_flags = 0;
    ArgType arg_type = ArgType::kNone;

    // Validate command.
    for (unsigned i = 0; i < sizeof(CMDS) / sizeof(CMDS[0]); i++) {
        if (!strcmp(command, CMDS[i].name)) {
            if (!IsCommandValid(CMDS[i].command)) {
                fprintf(stderr, "Invalid command %s\n", command);
                return Usage();
            }

            command_ = CMDS[i].command;
            open_flags = read_only_ ? O_RDONLY : CMDS[i].flags;
            arg_type = CMDS[i].arg_type;
        }
    }

    if (command_ == Command::kNone) {
        fprintf(stderr, "Unknown command: %s\n", argv[0]);
        return Usage();
    }

    // Parse the size argument (if any) from the device string.
    size_t requested_size = 0;
    if (ParseSize(device, &requested_size) != ZX_OK) {
        return Usage();
    }

    // Open the target device. Do this before we continue processing arguments, in case we are
    // copying directories from a minfs image and need to pre-process them.
    fd_.reset(open(device, open_flags, 0644));
    if (!fd_) {
        fprintf(stderr, "error: cannot open '%s'\n", device);
        return ZX_ERR_IO;
    }

    struct stat stats;
    if (fstat(fd_.get(), &stats) < 0) {
        fprintf(stderr, "Failed to stat device %s\n", device);
        return ZX_ERR_IO;
    }

    // Unless we are creating an image, the length_ has already been decided.
    if (command_ != Command::kMkfs) {
        if (length_) {
            if (offset_ + length_ > stats.st_size) {
                fprintf(stderr, "Must specify offset + length <= file size\n");
                return ZX_ERR_INVALID_ARGS;
            }
        } else {
            length_ = stats.st_size - offset_;
        }
    }

    // Verify that we've received a valid number of arguments for the given command.
    bool valid = true;
    switch (arg_type) {
    case ArgType::kNone:
        valid = argc == 0;
        break;
    case ArgType::kOne:
        valid = argc == 1;
        break;
    case ArgType::kTwo:
        valid = argc == 2;
        break;
    case ArgType::kMany:
        valid = argc;
        break;
    case ArgType::kOptional:
        break;
    default:
        return ZX_ERR_INTERNAL;
    }

    if (!valid) {
        fprintf(stderr, "Invalid arguments\n");
        return Usage();
    }

    // Process remaining arguments.
    while (argc > 0) {
        // Default to 2 arguments processed for manifest. If ProcessCustom is called, processed
        // will be populated with the actual number of arguments used.
        uint8_t processed = 2;
        if (!strcmp(argv[0], "--manifest")) {
            if (argc < 2) {
                return ZX_ERR_INVALID_ARGS;
            }

            zx_status_t status;
            if ((status = ProcessManifest(argv[1])) != ZX_OK) {
                return status;
            }
        } else if (ProcessCustom(argc, argv, &processed) != ZX_OK) {
            fprintf(stderr, "ProcessCustom failed\n");
            return Usage();
        }

        argc -= processed;
        argv += processed;
    }

    // Resize the file if we need to.
    zx_status_t status;
    if ((status = ResizeFile(requested_size, stats)) != ZX_OK) {
        return status;
    }

    if (depfile_needed) {
        size_t len = strlen(device);
        assert(len+2 < PATH_MAX);
        char buf[PATH_MAX] = {0};
        memcpy(&buf[0], device, strlen(device));
        buf[len++] = '.';
        buf[len++] = 'd';

        depfile_.reset(open(buf, O_CREAT|O_TRUNC|O_WRONLY, 0644));
        if (!depfile_) {
            fprintf(stderr, "error: cannot open '%s'\n", buf);
            return ZX_ERR_IO;
        }

        // update the buf to be suitable to pass to AppendDepfile.
        buf[len-2] = ':';
        buf[len-1] = 0;

        status = AppendDepfile(&buf[0]);
    }

    return status;
}

zx_status_t FsCreator::AppendDepfile(const char* str) {
    if (!depfile_) {
        return ZX_OK;
    }

    size_t len = strlen(str);
    assert(len < PATH_MAX);
    char buf[PATH_MAX] = {0};
    memcpy(&buf[0], str, len);
    buf[len++] = ' ';

    std::lock_guard<std::mutex> lock(depfile_lock_);

    // this code makes assumptions about the size of atomic writes on target
    // platforms which currently hold true, but are not part of e.g. POSIX.
    ssize_t result = write(depfile_.get(), buf, len);
    if (result < 0 || static_cast<size_t>(result) != len) {
        fprintf(stderr, "error: depfile append error\n");
        return ZX_ERR_IO;
    }
    return ZX_OK;
}

zx_status_t FsCreator::RunCommand() {
    if (!fd_) {
        fprintf(stderr, "Failed to open fd before running command\n");
        return ZX_ERR_INTERNAL;
    }

    switch (command_) {
    case Command::kMkfs:
        return Mkfs();
    case Command::kFsck:
        return Fsck();
    case Command::kUsedDataSize:
        return UsedDataSize();
    case Command::kUsedInodes:
        return UsedInodes();
    case Command::kUsedSize:
        return UsedSize();
    case Command::kAdd:
    case Command::kCp:
    case Command::kManifest:
    case Command::kMkdir:
        return Add();
    case Command::kLs:
        return Ls();
    default:
        fprintf(stderr, "Error: Command not defined\n");
        return ZX_ERR_INTERNAL;
    }
}

zx_status_t FsCreator::ParseSize(char* device, size_t* out) {
    char* sizestr = nullptr;
    if ((sizestr = strchr(device, '@')) != nullptr) {
        if (command_ != Command::kMkfs) {
            fprintf(stderr, "Cannot specify size for this command\n");
            return ZX_ERR_INVALID_ARGS;
        }
        // Create a file with an explicitly requested size
        *sizestr++ = 0;
        char* end;
        size_t size = strtoull(sizestr, &end, 10);
        if (end == sizestr) {
            fprintf(stderr, "%s: bad size: %s\n", GetToolName(), sizestr);
            return ZX_ERR_INVALID_ARGS;
        }
        switch (end[0]) {
        case 'M':
        case 'm':
            size *= (1024 * 1024);
            end++;
            break;
        case 'G':
        case 'g':
            size *= (1024 * 1024 * 1024);
            end++;
            break;
        }
        if (end[0] || size == 0) {
            fprintf(stderr, "%s: bad size: %s\n", GetToolName(), sizestr);
            return ZX_ERR_INVALID_ARGS;
        }

        if (length_ && static_cast<size_t>(offset_ + length_) > size) {
            fprintf(stderr, "Must specify size > offset + length\n");
            return ZX_ERR_INVALID_ARGS;
        }
        *out = size;
    }

    return ZX_OK;
}

zx_status_t FsCreator::ResizeFile(off_t requested_size, struct stat stats) {
    // Calculate the total required size for the fs image, given all files that have been processed
    // up to this point.
    off_t required_size;
    zx_status_t status = CalculateRequiredSize(&required_size);
    if (status != ZX_OK) {
        return status;
    }

    bool is_block = S_ISBLK(stats.st_mode);

    if (requested_size) {
        if (requested_size < required_size) {
            // If the size requested by @ is smaller than the size required, return an error.
            fprintf(stderr, "Must specify size larger than required size %" PRIu64 "\n",
                    required_size);
            return ZX_ERR_INVALID_ARGS;
        } else if (is_block) {
            // Do not allow re-sizing for block devices.
            fprintf(stderr, "%s: @size argument is not supported for block device targets\n",
                    GetToolName());
            return ZX_ERR_INVALID_ARGS;
        }
    }

    if (command_ == Command::kMkfs && !is_block &&
        (stats.st_size != required_size || requested_size)) {
        // Only truncate the file size under the following conditions:
        // 1.  We are creating the fs store for the first time.
        // 2.  We are not operating on a block device.
        // 3a. The current file size is different than the size required for the specified files, OR
        // 3b. The user has requested a particular size using the @ argument.
        off_t truncate_size = requested_size ? requested_size : required_size;

        if (length_ && (offset_ + length_) > truncate_size) {
            // If an offset+length were specified and they are smaller than the minimum required,
            // return an error.
            fprintf(stderr, "Length %" PRIu64 " too small for required size %" PRIu64 "\n", length_,
                    truncate_size);
            return ZX_ERR_INVALID_ARGS;
        }

        if (ftruncate(fd_.get(), truncate_size)) {
            fprintf(stderr, "error: cannot truncate device\n");
            return ZX_ERR_IO;
        }

        if (!length_) {
            length_ = truncate_size - offset_;
        }
    } else if (!length_) {
        // If not otherwise specified, update length to be equal to the size of the image.
        length_ = stats.st_size - offset_;
    }

    return ZX_OK;
}