ACPR/android_system_core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge "Revert "Skip F2FS formatting for dev option enabled devices"" into main

Browse source
This commit is contained in:
Dan Shi 2024-08-31 03:10:10 +00:00 • committed by Gerrit Code Review
commit 5e359c04ac
1 changed files with 18 additions and 46 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

64
fs_mgr/fs_mgr.cpp
View file

@ -38,8 +38,10 @@
#include <array> #include <array>
#include <chrono> #include <chrono>
#include <functional>
#include <map> #include <map>
#include <memory> #include <memory>
#include <numeric>
#include <string> #include <string>
#include <string_view> #include <string_view>
#include <thread> #include <thread>
@ -64,7 +66,6 @@
#include <fs_mgr/file_wait.h> #include <fs_mgr/file_wait.h>
#include <fs_mgr_overlayfs.h> #include <fs_mgr_overlayfs.h>
#include <fscrypt/fscrypt.h> #include <fscrypt/fscrypt.h>
#include <fstab/fstab.h>
#include <libdm/dm.h> #include <libdm/dm.h>
#include <libdm/loop_control.h> #include <libdm/loop_control.h>
#include <liblp/metadata_format.h> #include <liblp/metadata_format.h>
@ -81,7 +82,7 @@
#define F2FS_FSCK_BIN "/system/bin/fsck.f2fs" #define F2FS_FSCK_BIN "/system/bin/fsck.f2fs"
#define MKSWAP_BIN "/system/bin/mkswap" #define MKSWAP_BIN "/system/bin/mkswap"
#define TUNE2FS_BIN "/system/bin/tune2fs" #define TUNE2FS_BIN "/system/bin/tune2fs"
#define RESIZE2FS_BIN "/system/bin/resize2fs" #define RESIZE2FS_BIN "/system/bin/resize2fs"
#define FSCK_LOG_FILE "/dev/fscklogs/log" #define FSCK_LOG_FILE "/dev/fscklogs/log"
@ -137,8 +138,8 @@ enum FsStatFlags {
static void log_fs_stat(const std::string& blk_device, int fs_stat) { static void log_fs_stat(const std::string& blk_device, int fs_stat) {
std::string msg = std::string msg =
android::base::StringPrintf("\nfs_stat,%s,0x%x\n", blk_device.c_str(), fs_stat); android::base::StringPrintf("\nfs_stat,%s,0x%x\n", blk_device.c_str(), fs_stat);
android::base::unique_fd fd(TEMP_FAILURE_RETRY( android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(FSCK_LOG_FILE, O_WRONLY | O_CLOEXEC |
open(FSCK_LOG_FILE, O_WRONLY | O_CLOEXEC | O_APPEND | O_CREAT, 0664))); O_APPEND | O_CREAT, 0664)));
if (fd == -1 || !android::base::WriteStringToFd(msg, fd)) { if (fd == -1 || !android::base::WriteStringToFd(msg, fd)) {
LWARNING << __FUNCTION__ << "() cannot log " << msg; LWARNING << __FUNCTION__ << "() cannot log " << msg;
} }
@ -592,7 +593,7 @@ static void tune_metadata_csum(const std::string& blk_device, const FstabEntry&
// Must give `-T now` to prevent last_fsck_time from growing too large, // Must give `-T now` to prevent last_fsck_time from growing too large,
// otherwise, tune2fs won't enable metadata_csum. // otherwise, tune2fs won't enable metadata_csum.
const char* tune2fs_args[] = {TUNE2FS_BIN, "-O", "metadata_csum,64bit,extent", const char* tune2fs_args[] = {TUNE2FS_BIN, "-O", "metadata_csum,64bit,extent",
"-T", "now", blk_device.c_str()}; "-T", "now", blk_device.c_str()};
const char* resize2fs_args[] = {RESIZE2FS_BIN, "-b", blk_device.c_str()}; const char* resize2fs_args[] = {RESIZE2FS_BIN, "-b", blk_device.c_str()};
@ -1429,34 +1430,6 @@ bool WasMetadataEncryptionInterrupted(const FstabEntry& entry) {
return access(fs_mgr_metadata_encryption_in_progress_file_name(entry).c_str(), R_OK) == 0; return access(fs_mgr_metadata_encryption_in_progress_file_name(entry).c_str(), R_OK) == 0;
} }
FstabEntry* LocateFormattableEntry(FstabEntry* const begin, FstabEntry* const end) {
const bool dev_option_enabled =
android::base::GetBoolProperty("ro.product.build.16k_page.enabled", false);
FstabEntry* f2fs_entry = nullptr;
for (auto iter = begin; iter->blk_device == begin->blk_device && iter < end; iter++) {
if (iter->fs_mgr_flags.formattable) {
if (getpagesize() != 4096 && is_f2fs(iter->fs_type) && dev_option_enabled) {
f2fs_entry = iter;
continue;
}
if (f2fs_entry) {
LOG(INFO) << "Skipping F2FS format for block device " << iter->blk_device << " @ "
<< iter->mount_point
<< " in non-4K mode for dev option enabled devices, "
"as these devices need to toggle between 4K/16K mode, and F2FS does "
"not support page_size != block_size configuration.";
}
return iter;
}
}
if (f2fs_entry) {
LOG(INFO) << "Using F2FS for " << f2fs_entry->blk_device << " @ " << f2fs_entry->mount_point
<< " even though we are in non-4K mode. Device might require a data wipe after "
"going back to 4K mode, as F2FS does not support page_size != block_size";
}
return f2fs_entry;
}
// When multiple fstab records share the same mount_point, it will try to mount each // When multiple fstab records share the same mount_point, it will try to mount each
// one in turn, and ignore any duplicates after a first successful mount. // one in turn, and ignore any duplicates after a first successful mount.
// Returns -1 on error, and FS_MGR_MNTALL_* otherwise. // Returns -1 on error, and FS_MGR_MNTALL_* otherwise.
@ -1567,8 +1540,8 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
} }
} }
int last_idx_inspected = -1; int last_idx_inspected;
const int top_idx = i; int top_idx = i;
int attempted_idx = -1; int attempted_idx = -1;
bool encryption_interrupted = WasMetadataEncryptionInterrupted(current_entry); bool encryption_interrupted = WasMetadataEncryptionInterrupted(current_entry);
@ -1618,8 +1591,7 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
// Success! Go get the next one. // Success! Go get the next one.
continue; continue;
} }
auto formattable_entry =
LocateFormattableEntry(fstab->data() + top_idx, fstab->data() + fstab->size());
// Mounting failed, understand why and retry. // Mounting failed, understand why and retry.
wiped = partition_wiped(current_entry.blk_device.c_str()); wiped = partition_wiped(current_entry.blk_device.c_str());
if (mount_errno != EBUSY && mount_errno != EACCES && if (mount_errno != EBUSY && mount_errno != EACCES &&
@ -1647,12 +1619,12 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
encryptable = FS_MGR_MNTALL_DEV_IS_METADATA_ENCRYPTED; encryptable = FS_MGR_MNTALL_DEV_IS_METADATA_ENCRYPTED;
set_type_property(encryptable); set_type_property(encryptable);
if (!call_vdc({"cryptfs", "encryptFstab", formattable_entry->blk_device, if (!call_vdc({"cryptfs", "encryptFstab", current_entry.blk_device,
formattable_entry->mount_point, "true" /* shouldFormat */, current_entry.mount_point, "true" /* shouldFormat */,
formattable_entry->fs_type, current_entry.fs_type,
formattable_entry->fs_mgr_flags.is_zoned ? "true" : "false", current_entry.fs_mgr_flags.is_zoned ? "true" : "false",
std::to_string(formattable_entry->length), std::to_string(current_entry.length),
android::base::Join(formattable_entry->user_devices, ' ')}, android::base::Join(current_entry.user_devices, ' ')},
nullptr)) { nullptr)) {
LERROR << "Encryption failed"; LERROR << "Encryption failed";
} else { } else {
@ -1661,7 +1633,7 @@ int fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
} }
} }
if (fs_mgr_do_format(*formattable_entry) == 0) { if (fs_mgr_do_format(current_entry) == 0) {
// Let's replay the mount actions. // Let's replay the mount actions.
i = top_idx - 1; i = top_idx - 1;
continue; continue;
@ -1777,12 +1749,12 @@ int fs_mgr_do_mount_one(const FstabEntry& entry, const std::string& alt_mount_po
int ret = prepare_fs_for_mount(entry.blk_device, entry, mount_point); int ret = prepare_fs_for_mount(entry.blk_device, entry, mount_point);
// Wiped case doesn't require to try __mount below. // Wiped case doesn't require to try __mount below.
if (ret & FS_STAT_INVALID_MAGIC) { if (ret & FS_STAT_INVALID_MAGIC) {
return FS_MGR_DOMNT_FAILED; return FS_MGR_DOMNT_FAILED;
} }
ret = __mount(entry.blk_device, mount_point, entry); ret = __mount(entry.blk_device, mount_point, entry);
if (ret) { if (ret) {
ret = (errno == EBUSY) ? FS_MGR_DOMNT_BUSY : FS_MGR_DOMNT_FAILED; ret = (errno == EBUSY) ? FS_MGR_DOMNT_BUSY : FS_MGR_DOMNT_FAILED;
} }
return ret; return ret;