| // Copyright 2017 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. |
| |
| #define _XOPEN_SOURCE |
| |
| #include <errno.h> |
| #include <limits.h> |
| #include <string.h> |
| |
| #include <fbl/algorithm.h> |
| #include <minfs/fsck.h> |
| #include <minfs/host.h> |
| #include <minfs/minfs.h> |
| #include <minfs/transaction-limits.h> |
| |
| #include <utility> |
| |
| #include "minfs.h" |
| |
| char kDot[2] = "."; |
| char kDotDot[3] = ".."; |
| |
| namespace { |
| template <class T> uint32_t ToU32(T in) { |
| if (in > std::numeric_limits<uint32_t>::max()) { |
| fprintf(stderr, "out of range %" PRIuMAX "\n", |
| static_cast<uintmax_t>(in)); |
| exit(-1); |
| } |
| return static_cast<uint32_t>(in); |
| } |
| } // namespace |
| |
| // Returns the string version of |mode|. |
| static const char* GetModeString(uint32_t mode) { |
| switch (mode & S_IFMT) { |
| case S_IFREG: |
| return "-"; |
| case S_IFCHR: |
| return "c"; |
| case S_IFBLK: |
| return "b"; |
| case S_IFDIR: |
| return "d"; |
| default: |
| return "?"; |
| } |
| } |
| |
| // Adds PATH_PREFIX to path if it isn't there |
| void GetHostPath(const char* path, char* out) { |
| out[0] = 0; |
| int remaining = PATH_MAX; |
| |
| if (strncmp(path, PATH_PREFIX, PREFIX_SIZE)) { |
| strncat(out, PATH_PREFIX, remaining); |
| remaining -= strlen(PATH_PREFIX); |
| } |
| |
| strncat(out, path, remaining); |
| } |
| |
| // Checks if the given |path| is a directory, and return the answer in |*result|. |
| zx_status_t IsDirectory(const char* path, bool* result) { |
| struct stat s; |
| bool host = host_path(path); |
| |
| if (host) { |
| if (stat(path, &s) < 0) { |
| return ZX_ERR_IO; |
| } |
| } else { |
| if (!emu_is_mounted()) { |
| fprintf(stderr, "Cannot check directory of unmounted minfs partition\n"); |
| return ZX_ERR_INTERNAL; |
| } |
| |
| if (emu_stat(path, &s) < 0) { |
| return ZX_ERR_IO; |
| } |
| } |
| |
| if (S_ISDIR(s.st_mode)) { |
| *result = true; |
| } else { |
| *result = false; |
| } |
| return ZX_OK; |
| } |
| |
| // Copies a file to minfs from the host, or vice versa. |
| zx_status_t CopyFile(const char* src_path, const char* dst_path) { |
| FileWrapper src; |
| FileWrapper dst; |
| |
| if (FileWrapper::Open(src_path, O_RDONLY, 0, &src) < 0) { |
| fprintf(stderr, "error: cannot open file '%s'\n", src_path); |
| return ZX_ERR_IO; |
| } |
| |
| if (FileWrapper::Open(dst_path, O_WRONLY | O_CREAT | O_EXCL, 0644, &dst) < 0) { |
| fprintf(stderr, "error: cannot open file '%s'\n", dst_path); |
| return ZX_ERR_IO; |
| } |
| |
| char buffer[256 * 1024]; |
| ssize_t r; |
| for (;;) { |
| if ((r = src.Read(buffer, sizeof(buffer))) < 0) { |
| fprintf(stderr, "error: reading from '%s'\n", src_path); |
| break; |
| } else if (r == 0) { |
| break; |
| } |
| void* ptr = buffer; |
| ssize_t len = r; |
| while (len > 0) { |
| if ((r = dst.Write(ptr, len)) < 0) { |
| fprintf(stderr, "error: writing to '%s'\n", dst_path); |
| goto done; |
| } |
| ptr = (void*)((uintptr_t)ptr + r); |
| len -= r; |
| } |
| } |
| done: |
| return r == 0 ? ZX_OK : ZX_ERR_IO; |
| } |
| |
| // Attempts to make the directory at |path|. |
| // Returns a positive result if creation was successful or the specified directory already exists. |
| zx_status_t MakeDirectory(const char* path) { |
| if (DirWrapper::Make(path, 0777) && errno != EEXIST) { |
| fprintf(stderr, "minfs: could not create directory %s: %s\n", path, strerror(errno)); |
| return ZX_ERR_IO; |
| } |
| |
| return ZX_OK; |
| } |
| |
| zx_status_t MinfsCreator::Usage() { |
| zx_status_t status = FsCreator::Usage(); |
| |
| // Additional information about manifest format. |
| fprintf(stderr, "\nThe format of the manifest must be as follows:\n"); |
| fprintf(stderr, "\t'dst/path=src/path'\n"); |
| fprintf(stderr, "with one dst/src pair on each line.\n"); |
| |
| fprintf(stderr, "\nPrefix all minfs paths with '::' " |
| "(unless they are included in a manifest).\n"); |
| return status; |
| } |
| |
| bool MinfsCreator::IsCommandValid(Command command) { |
| switch (command) { |
| case Command::kMkfs: |
| case Command::kFsck: |
| case Command::kUsedDataSize: |
| case Command::kUsedInodes: |
| case Command::kUsedSize: |
| case Command::kLs: |
| case Command::kCp: |
| case Command::kManifest: |
| case Command::kMkdir: |
| case Command::kAdd: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool MinfsCreator::IsOptionValid(Option option) { |
| switch (option) { |
| case Option::kDepfile: |
| case Option::kReadonly: |
| case Option::kOffset: |
| case Option::kLength: |
| case Option::kHelp: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| bool MinfsCreator::IsArgumentValid(Argument argument) { |
| switch (argument) { |
| case Argument::kManifest: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| zx_status_t MinfsCreator::ProcessManifestLine(FILE* manifest, const char* dir_path) { |
| char src[PATH_MAX]; |
| src[0] = '\0'; |
| char dst[PATH_MAX]; |
| dst[0] = '\0'; |
| |
| zx_status_t status; |
| if ((status = ParseManifestLine(manifest, dir_path, &src[0], &dst[0])) != ZX_OK) { |
| return status; |
| } |
| |
| if (!strlen(src) || !strlen(dst)) { |
| fprintf(stderr, "Manifest line must specify source and destination files\n"); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| bool dir; |
| if ((status = IsDirectory(src, &dir)) != ZX_OK) { |
| return status; |
| } |
| |
| if (dir) { |
| fprintf(stderr, "Manifest cannot specify directory as source\n"); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| // Make dst into minfs path. |
| char emu_dst[PATH_MAX]; |
| GetHostPath(dst, emu_dst); |
| |
| // Process parent directories. |
| if ((status = ProcessParentDirectories(emu_dst)) != ZX_OK) { |
| return status; |
| } |
| |
| // Copy src to dst. |
| return ProcessFile(src, emu_dst); |
| } |
| |
| zx_status_t MinfsCreator::ProcessCustom(int argc, char** argv, uint8_t* processed) { |
| uint8_t required_args = 0; |
| |
| switch (GetCommand()) { |
| case Command::kLs: |
| __FALLTHROUGH; |
| case Command::kMkdir: { |
| required_args = 1; |
| if (argc != required_args) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| // A non-host path is required here since the ls and mkdir commands must be run on minfs. |
| if (host_path(argv[0])) { |
| fprintf(stderr, "Must specify path with prefix '::'"); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| // ls and mkdir can only be run on one path at a time. |
| if (!dir_list_.is_empty()) { |
| fprintf(stderr, "Too many paths specified\n"); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| if (GetCommand() == Command::kLs) { |
| dir_list_.push_back(argv[0]); |
| return ZX_OK; |
| } |
| |
| zx_status_t status; |
| if ((status = ProcessParentDirectories(argv[0])) != ZX_OK) { |
| return status; |
| } |
| |
| if ((status = ProcessDirectory(argv[0])) != ZX_OK) { |
| return status; |
| } |
| break; |
| } |
| case Command::kCp: { |
| required_args = 2; |
| if (argc != required_args) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| // If our source file is located within minfs, we need to mount the minfs image so that we |
| // can process any child files/directories. |
| zx_status_t status; |
| if (!host_path(argv[0]) && (status = MountMinfs()) != ZX_OK) { |
| return status; |
| } |
| |
| char src[PATH_MAX]; |
| char dst[PATH_MAX]; |
| strncpy(src, argv[0], PATH_MAX); |
| strncpy(dst, argv[1], PATH_MAX); |
| |
| if ((status = ProcessParentDirectories(dst)) != ZX_OK) { |
| return status; |
| } |
| |
| if ((status = ProcessEntityAndChildren(src, dst)) != ZX_OK) { |
| return status; |
| } |
| break; |
| } |
| case Command::kManifest: { |
| required_args = 1; |
| if (argc != required_args) { |
| return ZX_ERR_INVALID_ARGS; |
| } |
| zx_status_t status; |
| if ((status = ProcessManifest(argv[0])) != ZX_OK) { |
| return status; |
| } |
| break; |
| } |
| default: |
| fprintf(stderr, "Arguments not supported\n"); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| *processed = required_args; |
| return ZX_OK; |
| } |
| |
| zx_status_t MinfsCreator::CalculateRequiredSize(off_t* out) { |
| uint32_t dir_count = |
| static_cast<uint32_t>(dir_list_.size() + 1); // dir_list_ + root |
| |
| // This is a rough estimate of how many directory data blocks will be needed. |
| // This is not super robust and will not hold up if directories start requiring indirect blocks, |
| // but for our current purposes it should be sufficient. |
| uint32_t dir_blocks = ToU32(dir_count + (dir_bytes_ / minfs::kMinfsBlockSize)); |
| |
| minfs::Superblock info; |
| info.flags = 0; |
| info.inode_count = minfs::kMinfsDefaultInodeCount; |
| info.block_count = ToU32(data_blocks_ + dir_blocks); |
| |
| // Calculate number of blocks we will need for all minfs structures. |
| uint32_t inode_bitmap_blocks = (info.inode_count + minfs::kMinfsBlockBits - 1) |
| / minfs::kMinfsBlockBits; |
| uint32_t block_bitmap_blocks = (info.block_count + minfs::kMinfsBlockBits - 1) |
| / minfs::kMinfsBlockBits; |
| uint32_t inode_table_blocks = (info.inode_count + minfs::kMinfsInodesPerBlock - 1) |
| / minfs::kMinfsInodesPerBlock; |
| |
| info.ibm_block = 8; |
| info.abm_block = info.ibm_block + fbl::round_up(inode_bitmap_blocks, 8u); |
| info.ino_block = info.abm_block + fbl::round_up(block_bitmap_blocks, 8u); |
| info.journal_start_block = info.ino_block + inode_table_blocks; |
| minfs::TransactionLimits limits(info); |
| info.dat_block = info.journal_start_block + limits.GetRecommendedJournalBlocks(); |
| |
| *out = (info.dat_block + info.block_count) * minfs::kMinfsBlockSize; |
| return ZX_OK; |
| } |
| |
| zx_status_t MinfsCreator::Mkfs() { |
| zx_status_t status; |
| fbl::unique_ptr<minfs::Bcache> bc; |
| |
| // Create the bcache. |
| if ((status = GenerateBcache(&bc)) != ZX_OK) { |
| return status; |
| } |
| |
| // Consume the bcache to mkfs. |
| if ((status = minfs::Mkfs(std::move(bc))) != ZX_OK) { |
| return status; |
| } |
| |
| // Add any directories/files that have been pre-processed. |
| if ((status = Add()) != ZX_OK) { |
| fprintf(stderr, "Warning: Adding files on create failed - required size may have been " |
| "miscalculated\n"); |
| } |
| |
| return status; |
| } |
| |
| zx_status_t MinfsCreator::Fsck() { |
| zx_status_t status; |
| fbl::unique_ptr<minfs::Bcache> bc; |
| if ((status = GenerateBcache(&bc)) != ZX_OK) { |
| return status; |
| } |
| return minfs::Fsck(std::move(bc)); |
| } |
| |
| zx_status_t MinfsCreator::UsedDataSize() { |
| zx_status_t status; |
| uint64_t size; |
| fbl::unique_ptr<minfs::Bcache> bc; |
| if ((status = GenerateBcache(&bc)) != ZX_OK) { |
| return status; |
| } |
| if ((status = minfs::UsedDataSize(bc, &size)) != ZX_OK) { |
| return status; |
| } |
| |
| printf("%" PRIu64 "\n", size); |
| return ZX_OK; |
| } |
| |
| zx_status_t MinfsCreator::UsedInodes() { |
| zx_status_t status; |
| uint64_t used_inodes; |
| fbl::unique_ptr<minfs::Bcache> bc; |
| if ((status = GenerateBcache(&bc)) != ZX_OK) { |
| return status; |
| } |
| if ((status = minfs::UsedInodes(bc, &used_inodes)) != ZX_OK) { |
| return status; |
| } |
| |
| printf("%" PRIu64 "\n", used_inodes); |
| return ZX_OK; |
| } |
| |
| zx_status_t MinfsCreator::UsedSize() { |
| zx_status_t status; |
| uint64_t size; |
| fbl::unique_ptr<minfs::Bcache> bc; |
| if ((status = GenerateBcache(&bc)) != ZX_OK) { |
| return status; |
| } |
| if ((status = minfs::UsedSize(bc, &size)) != ZX_OK) { |
| return status; |
| } |
| |
| printf("%" PRIu64 "\n", size); |
| return ZX_OK; |
| } |
| |
| zx_status_t MinfsCreator::Add() { |
| zx_status_t status; |
| // Mount the minfs. |
| if ((status = MountMinfs()) != ZX_OK) { |
| return status; |
| } |
| |
| // Make all directories. |
| for (size_t n = 0; n < dir_list_.size(); n++) { |
| if ((status = MakeDirectory(dir_list_[n].c_str())) != ZX_OK) { |
| return status; |
| } |
| } |
| |
| // Copy all files. |
| for (size_t n = 0; n < file_list_.size(); n++) { |
| if ((status = AppendDepfile(file_list_[n].first.c_str())) != ZX_OK) { |
| return status; |
| } |
| if ((status = CopyFile(file_list_[n].first.c_str(), file_list_[n].second.c_str())) != ZX_OK) { |
| return status; |
| } |
| } |
| |
| return ZX_OK; |
| } |
| |
| zx_status_t MinfsCreator::Ls() { |
| if (!file_list_.is_empty() || dir_list_.size() != 1) { |
| fprintf(stderr, "ls requires one argument\n"); |
| return Usage(); |
| } |
| |
| zx_status_t status; |
| if ((status = MountMinfs()) != ZX_OK) { |
| return status; |
| } |
| |
| const char* path = dir_list_[0].c_str(); |
| if (strncmp(path, PATH_PREFIX, PREFIX_SIZE)) { |
| fprintf(stderr, "error: ls can only operate minfs paths (must start with %s)\n", |
| PATH_PREFIX); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| |
| DIR* d = emu_opendir(path); |
| if (!d) { |
| return ZX_ERR_IO; |
| } |
| |
| struct dirent* dir_entry; |
| char tmp[2048]; |
| struct stat stats; |
| while ((dir_entry = emu_readdir(d)) != nullptr) { |
| if (strcmp(dir_entry->d_name, ".") && strcmp(dir_entry->d_name, "..")) { |
| memset(&stats, 0, sizeof(struct stat)); |
| if ((strlen(dir_entry->d_name) + strlen(path) + 2) <= sizeof(tmp)) { |
| snprintf(tmp, sizeof(tmp), "%s/%s", path, dir_entry->d_name); |
| emu_stat(tmp, &stats); |
| } |
| fprintf(stdout, "%s %8jd %s\n", GetModeString(stats.st_mode), |
| static_cast<intmax_t>(stats.st_size), dir_entry->d_name); |
| } |
| } |
| emu_closedir(d); |
| return ZX_OK; |
| } |
| |
| zx_status_t MinfsCreator::ProcessEntityAndChildren(char* src, char* dst) { |
| bool dir; |
| zx_status_t status; |
| if ((status = IsDirectory(src, &dir)) != ZX_OK) { |
| return status; |
| } |
| |
| if (dir) { |
| ProcessDirectory(dst); |
| } else { |
| return ProcessFile(src, dst); |
| } |
| |
| DirWrapper current_dir; |
| if (DirWrapper::Open(src, ¤t_dir)) { |
| return ZX_ERR_IO; |
| } |
| |
| size_t src_len = strlen(src); |
| size_t dst_len = strlen(dst); |
| struct dirent* dir_entry; |
| while ((dir_entry = current_dir.ReadDir()) != nullptr) { |
| if (!strcmp(dir_entry->d_name, ".") || !strcmp(dir_entry->d_name, "..")) { |
| continue; |
| } |
| size_t name_len = strlen(dir_entry->d_name); |
| if (src_len + name_len + 1 > PATH_MAX - 1 || |
| dst_len + name_len + 1 > PATH_MAX - 1) { |
| fprintf(stderr, "Path size exceeds PATH_MAX\n"); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| strncat(src, "/", 1); |
| strncat(src, dir_entry->d_name, PATH_MAX - src_len - 2); |
| strncat(dst, "/", 1); |
| strncat(dst, dir_entry->d_name, PATH_MAX - dst_len - 2); |
| |
| zx_status_t status = ProcessEntityAndChildren(src, dst); |
| if (status != ZX_OK) { |
| return status; |
| } |
| |
| src[src_len] = '\0'; |
| dst[dst_len] = '\0'; |
| } |
| return 0; |
| } |
| |
| zx_status_t MinfsCreator::ProcessParentDirectories(char* path) { |
| // Create parent directories if they don't exist. |
| char* slash = strchr(path, '/'); |
| while (slash != nullptr) { |
| *slash = '\0'; |
| |
| char emu_path[PATH_MAX]; |
| GetHostPath(path, emu_path); |
| |
| zx_status_t status; |
| if ((status = ProcessDirectory(emu_path)) != ZX_OK) { |
| return status; |
| } |
| |
| *slash = '/'; |
| slash = strchr(slash + 1, '/'); |
| } |
| |
| return ZX_OK; |
| } |
| |
| zx_status_t MinfsCreator::ProcessDirectory(char* path) { |
| if (!strncmp(path, PATH_PREFIX, strlen(path))) { |
| // If |path| is the minfs root directory ("::"), return without processing. |
| return ZX_OK; |
| } |
| |
| // Check to see if |path| has already been processed. |
| bool found = false; |
| for (size_t i = 0; i < dir_list_.size(); i++) { |
| if (!strcmp(path, dir_list_[i].c_str())) { |
| found = true; |
| break; |
| } |
| } |
| |
| if (!found) { |
| // Only process the directory if it has not already been processed. |
| if (GetCommand() == Command::kMkfs && !host_path(path)) { |
| // Only calculate required space if we are running mkfs, and this is a minfs path. |
| ProcessDirectoryEntry(path); |
| ProcessDirectoryEntry(kDot); |
| ProcessDirectoryEntry(kDotDot); |
| } |
| |
| dir_list_.push_back(path); |
| } |
| |
| return ZX_OK; |
| } |
| |
| zx_status_t MinfsCreator::ProcessFile(char* src, char* dst) { |
| struct stat stats; |
| int result = host_path(src) ? stat(src, &stats) : emu_stat(src, &stats); |
| if (result < 0) { |
| fprintf(stderr, "Failed to stat file %s\n", src); |
| return ZX_ERR_IO; |
| } |
| |
| // Check if the file already exists in file_list_. |
| for (size_t n = 0; n < file_list_.size(); n++) { |
| if (!strcmp(dst, file_list_[n].second.c_str())) { |
| if (!strcmp(src, file_list_[n].first.c_str())) { |
| return ZX_OK; |
| } |
| |
| // If the file does exist but the source does not match, return an error. |
| fprintf(stderr, |
| "Error: Source %s does not match existing source %s for destination %s\n", |
| src, file_list_[n].first.c_str(), dst); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| } |
| |
| if (GetCommand() == Command::kMkfs && !host_path(dst)) { |
| // Only calculate required size if we are copying to minfs, and we are mkfsing. |
| zx_status_t status; |
| if ((status = ProcessBlocks(stats.st_size)) != ZX_OK) { |
| return status; |
| } |
| |
| ProcessDirectoryEntry(dst); |
| } |
| |
| file_list_.push_back(std::make_pair(src, dst)); |
| return ZX_OK; |
| } |
| |
| void MinfsCreator::ProcessDirectoryEntry(char* path) { |
| if (path == nullptr) { |
| return; |
| } |
| char* last_slash = strrchr(path, '/'); |
| last_slash = last_slash == nullptr ? path : last_slash + 1; |
| size_t component_length = strlen(last_slash); |
| if (component_length > std::numeric_limits<uint8_t>::max()) { |
| fprintf(stderr, "component too long"); |
| exit(-1); |
| } |
| dir_bytes_ += minfs::DirentSize(static_cast<uint8_t>(component_length)); |
| } |
| |
| zx_status_t MinfsCreator::ProcessBlocks(off_t file_size) { |
| uint64_t total_blocks = 0; |
| uint32_t remaining = ToU32((file_size + minfs::kMinfsBlockSize - 1) / minfs::kMinfsBlockSize); |
| |
| // Add direct blocks to the total. |
| uint32_t direct_blocks = fbl::min(remaining, minfs::kMinfsDirect); |
| total_blocks += direct_blocks; |
| remaining -= direct_blocks; |
| |
| if (remaining) { |
| // If more blocks remain, calculate how many indirect blocks we need. |
| uint32_t indirect_blocks = fbl::min( |
| (remaining + minfs::kMinfsDirectPerIndirect + 1) / minfs::kMinfsDirectPerIndirect, |
| minfs::kMinfsIndirect); |
| |
| direct_blocks = fbl::min(remaining, indirect_blocks * minfs::kMinfsDirectPerIndirect); |
| |
| // Add blocks to the total, and update remaining. |
| total_blocks += indirect_blocks + direct_blocks; |
| remaining -= direct_blocks; |
| |
| if (remaining) { |
| // If blocks remain past the indirect block range, calculate required doubly indirect |
| // and indirect blocks. |
| uint32_t dindirect_blocks = fbl::min( |
| (remaining + minfs::kMinfsDirectPerDindirect + 1) / minfs::kMinfsDirectPerDindirect, |
| minfs::kMinfsDoublyIndirect); |
| |
| indirect_blocks = fbl::min( |
| (remaining + minfs::kMinfsDirectPerIndirect + 1) / minfs::kMinfsDirectPerIndirect, |
| minfs::kMinfsDirectPerIndirect * minfs::kMinfsDoublyIndirect); |
| |
| direct_blocks = fbl::min(remaining, |
| minfs::kMinfsDoublyIndirect * minfs::kMinfsDirectPerDindirect); |
| |
| // Add blocks to the total, and update remaining. |
| total_blocks += dindirect_blocks + indirect_blocks + direct_blocks; |
| remaining -= direct_blocks; |
| |
| if (remaining) { |
| // If we still have more blocks remaining at this point, the file is larger than |
| // the current minfs max file size. |
| fprintf(stderr, "Error: File too large for minfs @ %" PRIu64 " bytes\n", file_size); |
| return ZX_ERR_INVALID_ARGS; |
| } |
| } |
| } |
| |
| // Add calculated blocks to the total so far. |
| data_blocks_ += total_blocks; |
| return ZX_OK; |
| } |
| |
| zx_status_t MinfsCreator::GenerateBcache(fbl::unique_ptr<minfs::Bcache>* out) { |
| uint32_t block_count = static_cast<uint32_t>(GetLength() / minfs::kMinfsBlockSize); |
| |
| // Duplicate the fd so that we can re-open the minfs partition if we need to. |
| int dupfd = dup(fd_.get()); |
| |
| fbl::unique_ptr<minfs::Bcache> bc; |
| if (minfs::Bcache::Create(&bc, std::move(fd_), block_count) < 0) { |
| fprintf(stderr, "error: cannot create block cache\n"); |
| return ZX_ERR_IO; |
| } |
| |
| bc->SetOffset(GetOffset()); |
| fd_.reset(dupfd); |
| *out = std::move(bc); |
| return ZX_OK; |
| } |
| |
| zx_status_t MinfsCreator::MountMinfs() { |
| if (emu_is_mounted()) { |
| // If we have already mounted minfs, do nothing. |
| return ZX_OK; |
| } |
| |
| zx_status_t status; |
| fbl::unique_ptr<minfs::Bcache> bc; |
| if ((status = GenerateBcache(&bc)) != ZX_OK) { |
| return status; |
| } |
| |
| return emu_mount_bcache(std::move(bc)); |
| } |
| |
| int main(int argc, char** argv) { |
| MinfsCreator minfs; |
| |
| if (minfs.ProcessAndRun(argc, argv) != ZX_OK) { |
| return -1; |
| } |
| |
| return 0; |
| } |
