diff --git a/fs_mgr/fs_mgr.cpp b/fs_mgr/fs_mgr.cpp index 316ff5efc..4e1360ea1 100644 --- a/fs_mgr/fs_mgr.cpp +++ b/fs_mgr/fs_mgr.cpp @@ -91,6 +91,8 @@ using android::fs_mgr::AvbHandle; using android::fs_mgr::AvbHashtreeResult; using android::fs_mgr::AvbUniquePtr; +using namespace std::literals; + // record fs stat enum FsStatFlags { FS_STAT_IS_EXT4 = 0x0001, @@ -131,10 +133,10 @@ bool fs_mgr_wait_for_file(const std::string& filename, } } -static void log_fs_stat(const char* blk_device, int fs_stat) -{ +static void log_fs_stat(const std::string& blk_device, int fs_stat) { if ((fs_stat & FS_STAT_IS_EXT4) == 0) return; // only log ext4 - std::string msg = android::base::StringPrintf("\nfs_stat,%s,0x%x\n", blk_device, fs_stat); + std::string msg = + android::base::StringPrintf("\nfs_stat,%s,0x%x\n", blk_device.c_str(), fs_stat); android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(FSCK_LOG_FILE, O_WRONLY | O_CLOEXEC | O_APPEND | O_CREAT, 0664))); if (fd == -1 || !android::base::WriteStringToFd(msg, fd)) { @@ -150,7 +152,7 @@ static bool is_f2fs(const std::string& fs_type) { return fs_type == "f2fs"; } -static std::string realpath(const char* blk_device) { +static std::string realpath(const std::string& blk_device) { std::string real_path; if (!Realpath(blk_device, &real_path)) { real_path = blk_device; @@ -166,14 +168,14 @@ static bool should_force_check(int fs_stat) { FS_STAT_SET_RESERVED_BLOCKS_FAILED | FS_STAT_ENABLE_ENCRYPTION_FAILED); } -static void check_fs(const char *blk_device, char *fs_type, char *target, int *fs_stat) -{ +static void check_fs(const std::string& blk_device, const std::string& fs_type, + const std::string& target, int* fs_stat) { int status; int ret; long tmpmnt_flags = MS_NOATIME | MS_NOEXEC | MS_NOSUID; - char tmpmnt_opts[64] = "errors=remount-ro"; - const char* e2fsck_argv[] = {E2FSCK_BIN, "-y", blk_device}; - const char* e2fsck_forced_argv[] = {E2FSCK_BIN, "-f", "-y", blk_device}; + auto tmpmnt_opts = "errors=remount-ro"s; + const char* e2fsck_argv[] = {E2FSCK_BIN, "-y", blk_device.c_str()}; + const char* e2fsck_forced_argv[] = {E2FSCK_BIN, "-f", "-y", blk_device.c_str()}; if (*fs_stat & FS_STAT_INVALID_MAGIC) { // will fail, so do not try return; @@ -196,18 +198,19 @@ static void check_fs(const char *blk_device, char *fs_type, char *target, int *f */ if (!(*fs_stat & FS_STAT_FULL_MOUNT_FAILED)) { // already tried if full mount failed errno = 0; - if (!strcmp(fs_type, "ext4")) { + if (fs_type == "ext4") { // This option is only valid with ext4 - strlcat(tmpmnt_opts, ",nomblk_io_submit", sizeof(tmpmnt_opts)); + tmpmnt_opts += ",nomblk_io_submit"; } - ret = mount(blk_device, target, fs_type, tmpmnt_flags, tmpmnt_opts); + ret = mount(blk_device.c_str(), target.c_str(), fs_type.c_str(), tmpmnt_flags, + tmpmnt_opts.c_str()); PINFO << __FUNCTION__ << "(): mount(" << blk_device << "," << target << "," << fs_type << ")=" << ret; if (!ret) { bool umounted = false; int retry_count = 5; while (retry_count-- > 0) { - umounted = umount(target) == 0; + umounted = umount(target.c_str()) == 0; if (umounted) { LINFO << __FUNCTION__ << "(): unmount(" << target << ") succeeded"; break; @@ -254,7 +257,7 @@ static void check_fs(const char *blk_device, char *fs_type, char *target, int *f } } } else if (is_f2fs(fs_type)) { - const char* f2fs_fsck_argv[] = {F2FS_FSCK_BIN, "-a", blk_device}; + const char* f2fs_fsck_argv[] = {F2FS_FSCK_BIN, "-a", blk_device.c_str()}; LINFO << "Running " << F2FS_FSCK_BIN << " -a " << realpath(blk_device); ret = android_fork_execvp_ext(ARRAY_SIZE(f2fs_fsck_argv), @@ -290,8 +293,9 @@ static bool is_ext4_superblock_valid(const struct ext4_super_block* es) { // Read the primary superblock from an ext4 filesystem. On failure return // false. If it's not an ext4 filesystem, also set FS_STAT_INVALID_MAGIC. -static bool read_ext4_superblock(const char* blk_device, struct ext4_super_block* sb, int* fs_stat) { - android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(blk_device, O_RDONLY | O_CLOEXEC))); +static bool read_ext4_superblock(const std::string& blk_device, struct ext4_super_block* sb, + int* fs_stat) { + android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(blk_device.c_str(), O_RDONLY | O_CLOEXEC))); if (fd < 0) { PERROR << "Failed to open '" << blk_device << "'"; @@ -332,7 +336,7 @@ static bool run_tune2fs(const char* argv[], int argc) { } // Enable/disable quota support on the filesystem if needed. -static void tune_quota(const char* blk_device, const struct fstab_rec* rec, +static void tune_quota(const std::string& blk_device, const struct fstab_rec* rec, const struct ext4_super_block* sb, int* fs_stat) { bool has_quota = (sb->s_feature_ro_compat & cpu_to_le32(EXT4_FEATURE_RO_COMPAT_QUOTA)) != 0; bool want_quota = fs_mgr_is_quota(rec) != 0; @@ -347,7 +351,7 @@ static void tune_quota(const char* blk_device, const struct fstab_rec* rec, return; } - const char* argv[] = {TUNE2FS_BIN, nullptr, nullptr, blk_device}; + const char* argv[] = {TUNE2FS_BIN, nullptr, nullptr, blk_device.c_str()}; if (want_quota) { LINFO << "Enabling quotas on " << blk_device; @@ -368,7 +372,7 @@ static void tune_quota(const char* blk_device, const struct fstab_rec* rec, } // Set the number of reserved filesystem blocks if needed. -static void tune_reserved_size(const char* blk_device, const struct fstab_rec* rec, +static void tune_reserved_size(const std::string& blk_device, const struct fstab_rec* rec, const struct ext4_super_block* sb, int* fs_stat) { if (!(rec->fs_mgr_flags & MF_RESERVEDSIZE)) { return; @@ -400,7 +404,8 @@ static void tune_reserved_size(const char* blk_device, const struct fstab_rec* r auto reserved_blocks_str = std::to_string(reserved_blocks); auto reserved_gid_str = std::to_string(AID_RESERVED_DISK); const char* argv[] = { - TUNE2FS_BIN, "-r", reserved_blocks_str.c_str(), "-g", reserved_gid_str.c_str(), blk_device}; + TUNE2FS_BIN, "-r", reserved_blocks_str.c_str(), "-g", reserved_gid_str.c_str(), + blk_device.c_str()}; if (!run_tune2fs(argv, ARRAY_SIZE(argv))) { LERROR << "Failed to run " TUNE2FS_BIN " to set the number of reserved blocks on " << blk_device; @@ -409,7 +414,7 @@ static void tune_reserved_size(const char* blk_device, const struct fstab_rec* r } // Enable file-based encryption if needed. -static void tune_encrypt(const char* blk_device, const struct fstab_rec* rec, +static void tune_encrypt(const std::string& blk_device, const struct fstab_rec* rec, const struct ext4_super_block* sb, int* fs_stat) { bool has_encrypt = (sb->s_feature_incompat & cpu_to_le32(EXT4_FEATURE_INCOMPAT_ENCRYPT)) != 0; bool want_encrypt = fs_mgr_is_file_encrypted(rec) != 0; @@ -424,7 +429,7 @@ static void tune_encrypt(const char* blk_device, const struct fstab_rec* rec, return; } - const char* argv[] = {TUNE2FS_BIN, "-Oencrypt", blk_device}; + const char* argv[] = {TUNE2FS_BIN, "-Oencrypt", blk_device.c_str()}; LINFO << "Enabling ext4 encryption on " << blk_device; if (!run_tune2fs(argv, ARRAY_SIZE(argv))) { @@ -438,8 +443,8 @@ static void tune_encrypt(const char* blk_device, const struct fstab_rec* rec, // false. If it's not an f2fs filesystem, also set FS_STAT_INVALID_MAGIC. #define F2FS_BLKSIZE 4096 #define F2FS_SUPER_OFFSET 1024 -static bool read_f2fs_superblock(const char* blk_device, int* fs_stat) { - android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(blk_device, O_RDONLY | O_CLOEXEC))); +static bool read_f2fs_superblock(const std::string& blk_device, int* fs_stat) { + android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(blk_device.c_str(), O_RDONLY | O_CLOEXEC))); __le32 sb1, sb2; if (fd < 0) { @@ -473,7 +478,7 @@ static bool read_f2fs_superblock(const char* blk_device, int* fs_stat) { // If needed, we'll also enable (or disable) filesystem features as specified by // the fstab record. // -static int prepare_fs_for_mount(const char* blk_device, const struct fstab_rec* rec) { +static int prepare_fs_for_mount(const std::string& blk_device, const struct fstab_rec* rec) { int fs_stat = 0; if (is_extfs(rec->fs_type)) { @@ -516,17 +521,6 @@ static int prepare_fs_for_mount(const char* blk_device, const struct fstab_rec* return fs_stat; } -static void remove_trailing_slashes(char *n) -{ - int len; - - len = strlen(n) - 1; - while ((*(n + len) == '/') && len) { - *(n + len) = '\0'; - len--; - } -} - // Mark the given block device as read-only, using the BLKROSET ioctl. bool fs_mgr_set_blk_ro(const std::string& blockdev) { unique_fd fd(TEMP_FAILURE_RETRY(open(blockdev.c_str(), O_RDONLY | O_CLOEXEC))); @@ -548,34 +542,28 @@ bool fs_mgr_is_device_unlocked() { return false; } -/* - * __mount(): wrapper around the mount() system call which also - * sets the underlying block device to read-only if the mount is read-only. - * See "man 2 mount" for return values. - */ -static int __mount(const char *source, const char *target, const struct fstab_rec *rec) -{ - unsigned long mountflags = rec->flags; - int ret; - int save_errno; - - /* We need this because sometimes we have legacy symlinks - * that are lingering around and need cleaning up. - */ +// __mount(): wrapper around the mount() system call which also +// sets the underlying block device to read-only if the mount is read-only. +// See "man 2 mount" for return values. +static int __mount(const std::string& source, const std::string& target, + const struct fstab_rec* rec) { + // We need this because sometimes we have legacy symlinks that are + // lingering around and need cleaning up. struct stat info; - if (!lstat(target, &info)) - if ((info.st_mode & S_IFMT) == S_IFLNK) - unlink(target); - mkdir(target, 0755); + if (lstat(target.c_str(), &info) == 0 && (info.st_mode & S_IFMT) == S_IFLNK) { + unlink(target.c_str()); + } + mkdir(target.c_str(), 0755); errno = 0; - ret = mount(source, target, rec->fs_type, mountflags, rec->fs_options); - save_errno = errno; + unsigned long mountflags = rec->flags; + int ret = mount(source.c_str(), target.c_str(), rec->fs_type, mountflags, rec->fs_options); + int save_errno = errno; const char* target_missing = ""; const char* source_missing = ""; if (save_errno == ENOENT) { - if (access(target, F_OK)) { + if (access(target.c_str(), F_OK)) { target_missing = "(missing)"; - } else if (access(source, F_OK)) { + } else if (access(source.c_str(), F_OK)) { source_missing = "(missing)"; } errno = save_errno; @@ -589,24 +577,32 @@ static int __mount(const char *source, const char *target, const struct fstab_re return ret; } -static int fs_match(const char *in1, const char *in2) -{ - char *n1; - char *n2; - int ret; +static bool fs_match(const std::string& in1, const std::string& in2) { + if (in1.empty() || in2.empty()) { + return false; + } - n1 = strdup(in1); - n2 = strdup(in2); + auto in1_end = in1.size() - 1; + while (in1_end > 0 && in1[in1_end] == '/') { + in1_end--; + } - remove_trailing_slashes(n1); - remove_trailing_slashes(n2); + auto in2_end = in2.size() - 1; + while (in2_end > 0 && in2[in2_end] == '/') { + in2_end--; + } - ret = !strcmp(n1, n2); + if (in1_end != in2_end) { + return false; + } - free(n1); - free(n2); + for (size_t i = 0; i <= in1_end; ++i) { + if (in1[i] != in2[i]) { + return false; + } + } - return ret; + return true; } /* @@ -746,17 +742,12 @@ static bool TranslateExtLabels(fstab_rec* rec) { } if (label == super_block.s_volume_name) { - char* new_blk_device; - - if (asprintf(&new_blk_device, "/dev/block/%s", ent->d_name) < 0) { - LERROR << "Could not allocate block device string"; - return false; - } + std::string new_blk_device = "/dev/block/"s + ent->d_name; LINFO << "resolved label " << rec->blk_device << " to " << new_blk_device; free(rec->blk_device); - rec->blk_device = new_blk_device; + rec->blk_device = strdup(new_blk_device.c_str()); return true; } } @@ -771,18 +762,14 @@ static bool needs_block_encryption(const struct fstab_rec* rec) return true; if (rec->fs_mgr_flags & MF_FORCECRYPT) return true; if (rec->fs_mgr_flags & MF_CRYPT) { - /* Check for existence of convert_fde breadcrumb file */ - char convert_fde_name[PATH_MAX]; - snprintf(convert_fde_name, sizeof(convert_fde_name), - "%s/misc/vold/convert_fde", rec->mount_point); - if (access(convert_fde_name, F_OK) == 0) return true; + // Check for existence of convert_fde breadcrumb file. + auto convert_fde_name = rec->mount_point + "%s/misc/vold/convert_fde"s; + if (access(convert_fde_name.c_str(), F_OK) == 0) return true; } if (rec->fs_mgr_flags & MF_FORCEFDEORFBE) { - /* Check for absence of convert_fbe breadcrumb file */ - char convert_fbe_name[PATH_MAX]; - snprintf(convert_fbe_name, sizeof(convert_fbe_name), - "%s/convert_fbe", rec->mount_point); - if (access(convert_fbe_name, F_OK) != 0) return true; + // Check for absence of convert_fbe breadcrumb file. + auto convert_fbe_name = rec->mount_point + "/convert_fbe"s; + if (access(convert_fbe_name.c_str(), F_OK) != 0) return true; } return false; } diff --git a/fs_mgr/fs_mgr_format.cpp b/fs_mgr/fs_mgr_format.cpp index 098366324..737deca3b 100644 --- a/fs_mgr/fs_mgr_format.cpp +++ b/fs_mgr/fs_mgr_format.cpp @@ -24,6 +24,7 @@ #include #include +#include #include #include #include @@ -34,30 +35,28 @@ #include "fs_mgr_priv.h" #include "cryptfs.h" -static int get_dev_sz(char *fs_blkdev, uint64_t *dev_sz) -{ - int fd; +using android::base::unique_fd; - if ((fd = open(fs_blkdev, O_RDONLY)) < 0) { +static int get_dev_sz(const std::string& fs_blkdev, uint64_t* dev_sz) { + unique_fd fd(TEMP_FAILURE_RETRY(open(fs_blkdev.c_str(), O_RDONLY | O_CLOEXEC))); + + if (fd < 0) { PERROR << "Cannot open block device"; return -1; } if ((ioctl(fd, BLKGETSIZE64, dev_sz)) == -1) { PERROR << "Cannot get block device size"; - close(fd); return -1; } - close(fd); return 0; } -static int format_ext4(char *fs_blkdev, char *fs_mnt_point, bool crypt_footer) -{ +static int format_ext4(const std::string& fs_blkdev, const std::string& fs_mnt_point, + bool crypt_footer) { uint64_t dev_sz; int rc = 0; - int status; rc = get_dev_sz(fs_blkdev, &dev_sz); if (rc) { @@ -71,7 +70,8 @@ static int format_ext4(char *fs_blkdev, char *fs_mnt_point, bool crypt_footer) std::string size_str = std::to_string(dev_sz / 4096); const char* const mke2fs_args[] = { - "/system/bin/mke2fs", "-t", "ext4", "-b", "4096", fs_blkdev, size_str.c_str(), nullptr}; + "/system/bin/mke2fs", "-t", "ext4", "-b", "4096", fs_blkdev.c_str(), + size_str.c_str(), nullptr}; rc = android_fork_execvp_ext(arraysize(mke2fs_args), const_cast(mke2fs_args), NULL, true, LOG_KLOG, true, nullptr, nullptr, 0); @@ -81,12 +81,7 @@ static int format_ext4(char *fs_blkdev, char *fs_mnt_point, bool crypt_footer) } const char* const e2fsdroid_args[] = { - "/system/bin/e2fsdroid", - "-e", - "-a", - fs_mnt_point, - fs_blkdev, - nullptr}; + "/system/bin/e2fsdroid", "-e", "-a", fs_mnt_point.c_str(), fs_blkdev.c_str(), nullptr}; rc = android_fork_execvp_ext(arraysize(e2fsdroid_args), const_cast(e2fsdroid_args), NULL, true, LOG_KLOG, true, nullptr, nullptr, 0); @@ -97,10 +92,7 @@ static int format_ext4(char *fs_blkdev, char *fs_mnt_point, bool crypt_footer) return rc; } -static int format_f2fs(char *fs_blkdev, uint64_t dev_sz, bool crypt_footer) -{ - int status; - +static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool crypt_footer) { if (!dev_sz) { int rc = get_dev_sz(fs_blkdev, &dev_sz); if (rc) { @@ -118,7 +110,7 @@ static int format_f2fs(char *fs_blkdev, uint64_t dev_sz, bool crypt_footer) const char* const args[] = { "/system/bin/make_f2fs", "-g", "android", - fs_blkdev, + fs_blkdev.c_str(), size_str.c_str(), nullptr };