fs_mgr: Refactor by inlining trivial helpers
Inline some trivial helpers and remove unused header declarations.
Remove fs_mgr_*access() as it is really just access().
Remove fs_mgr_overlayfs_super_device() as we always want the primary
slot and having this wrapper isn't particularly helpful.
Test: adb-remount-test
Change-Id: I2581fd7c7d5071cbb97778535b7811dbcb80d76e
diff --git a/fs_mgr/fs_mgr_fstab.cpp b/fs_mgr/fs_mgr_fstab.cpp
index c85e831..ca27034 100644
--- a/fs_mgr/fs_mgr_fstab.cpp
+++ b/fs_mgr/fs_mgr_fstab.cpp
@@ -328,8 +328,7 @@
// some recovery fstabs still contain the FDE options since they didn't do
// anything in recovery mode anyway (except possibly to cause the
// reservation of a crypto footer) and thus never got removed.
- if (entry->fs_mgr_flags.crypt && !entry->fs_mgr_flags.vold_managed &&
- access("/system/bin/recovery", F_OK) != 0) {
+ if (entry->fs_mgr_flags.crypt && !entry->fs_mgr_flags.vold_managed && !InRecovery()) {
LERROR << "FDE is no longer supported; 'encryptable' can only be used for adoptable "
"storage";
return false;
@@ -520,6 +519,9 @@
// ramdisk's copy of the fstab had to be located in the root directory, but now
// the system/etc directory is supported too and is the preferred location.
std::string GetFstabPath() {
+ if (InRecovery()) {
+ return "/etc/recovery.fstab";
+ }
for (const char* prop : {"fstab_suffix", "hardware", "hardware.platform"}) {
std::string suffix;
@@ -835,15 +837,8 @@
fstab->clear();
ReadFstabFromDt(fstab, false /* verbose */);
- std::string default_fstab_path;
- // Use different fstab paths for normal boot and recovery boot, respectively
- if ((access("/sbin/recovery", F_OK) == 0) || (access("/system/bin/recovery", F_OK) == 0)) {
- default_fstab_path = "/etc/recovery.fstab";
- } else { // normal boot
- default_fstab_path = GetFstabPath();
- }
-
Fstab default_fstab;
+ const std::string default_fstab_path = GetFstabPath();
if (!default_fstab_path.empty() && ReadFstabFromFile(default_fstab_path, &default_fstab)) {
for (auto&& entry : default_fstab) {
fstab->emplace_back(std::move(entry));
@@ -936,6 +931,17 @@
return base_device + "-verity";
}
+bool InRecovery() {
+ // Check the existence of recovery binary instead of using the compile time
+ // __ANDROID_RECOVERY__ macro.
+ // If BOARD_USES_RECOVERY_AS_BOOT is true, both normal and recovery boot
+ // mode would use the same init binary, which would mean during normal boot
+ // the '/init' binary is actually a symlink pointing to
+ // init_second_stage.recovery, which would be compiled with
+ // __ANDROID_RECOVERY__ defined.
+ return access("/system/bin/recovery", F_OK) == 0 || access("/sbin/recovery", F_OK) == 0;
+}
+
} // namespace fs_mgr
} // namespace android
diff --git a/fs_mgr/fs_mgr_overlayfs_control.cpp b/fs_mgr/fs_mgr_overlayfs_control.cpp
index c9a8997..68576f2 100644
--- a/fs_mgr/fs_mgr_overlayfs_control.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_control.cpp
@@ -18,17 +18,10 @@
#include <errno.h>
#include <fcntl.h>
#include <linux/fs.h>
-#include <selinux/selinux.h>
-#include <stdio.h>
#include <stdlib.h>
-#include <string.h>
-#include <sys/mount.h>
-#include <sys/param.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <sys/types.h>
-#include <sys/utsname.h>
-#include <sys/vfs.h>
#include <unistd.h>
#include <algorithm>
@@ -38,13 +31,9 @@
#include <vector>
#include <android-base/file.h>
-#include <android-base/macros.h>
#include <android-base/properties.h>
#include <android-base/strings.h>
-#include <android-base/unique_fd.h>
-#include <ext4_utils/ext4_utils.h>
#include <fs_mgr.h>
-#include <fs_mgr/file_wait.h>
#include <fs_mgr_dm_linear.h>
#include <fs_mgr_overlayfs.h>
#include <fstab/fstab.h>
@@ -89,7 +78,7 @@
if (fs_mgr_is_dsu_running()) {
return false;
}
- return fs_mgr_access(kScratchImageMetadata);
+ return access(kScratchImageMetadata, F_OK) == 0;
}
static bool fs_mgr_rm_all(const std::string& path, bool* change = nullptr, int level = 0) {
@@ -198,10 +187,6 @@
return SlotNumberForSlotSuffix(fs_mgr_get_slot_suffix());
}
-static std::string fs_mgr_overlayfs_super_device(uint32_t slot_number) {
- return kPhysicalDevice + fs_mgr_get_super_partition_name(slot_number);
-}
-
static bool fs_mgr_overlayfs_has_logical(const Fstab& fstab) {
for (const auto& entry : fstab) {
if (entry.fs_mgr_flags.logical) {
@@ -261,8 +246,8 @@
}
auto slot_number = fs_mgr_overlayfs_slot_number();
- auto super_device = fs_mgr_overlayfs_super_device(slot_number);
- if (!fs_mgr_rw_access(super_device)) {
+ const auto super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();
+ if (access(super_device.c_str(), R_OK | W_OK)) {
return OverlayfsTeardownResult::Ok;
}
@@ -295,7 +280,7 @@
bool* change, bool* should_destroy_scratch = nullptr) {
const auto top = overlay + "/" + kOverlayTopDir;
- if (!fs_mgr_access(top)) {
+ if (access(top.c_str(), F_OK)) {
if (should_destroy_scratch) *should_destroy_scratch = true;
return true;
}
@@ -443,7 +428,7 @@
auto partition_create = !*partition_exists;
auto slot_number = fs_mgr_overlayfs_slot_number();
- auto super_device = fs_mgr_overlayfs_super_device(slot_number);
+ const auto super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();
auto builder = MetadataBuilder::New(super_device, slot_number);
if (!builder) {
LERROR << "open " << super_device << " metadata";
@@ -583,8 +568,8 @@
static bool CanUseSuperPartition(const Fstab& fstab) {
auto slot_number = fs_mgr_overlayfs_slot_number();
- auto super_device = fs_mgr_overlayfs_super_device(slot_number);
- if (!fs_mgr_rw_access(super_device) || !fs_mgr_overlayfs_has_logical(fstab)) {
+ const auto super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();
+ if (access(super_device.c_str(), R_OK | W_OK) || !fs_mgr_overlayfs_has_logical(fstab)) {
return false;
}
auto metadata = ReadMetadata(super_device, slot_number);
@@ -634,8 +619,8 @@
// If the partition exists, assume first that it can be mounted.
if (partition_exists) {
if (MountScratch(scratch_device)) {
- if (fs_mgr_access(kScratchMountPoint + "/"s + kOverlayTopDir) ||
- fs_mgr_filesystem_has_space(kScratchMountPoint)) {
+ const auto top = kScratchMountPoint + "/"s + kOverlayTopDir;
+ if (access(top.c_str(), F_OK) == 0 || fs_mgr_filesystem_has_space(kScratchMountPoint)) {
return true;
}
// declare it useless, no overrides and no free space
@@ -755,7 +740,7 @@
if (!info.device.empty()) {
return {std::move(info)};
}
- if (!fs_mgr_in_recovery()) {
+ if (!InRecovery()) {
return {};
}
@@ -778,8 +763,7 @@
}
// Avoid uart spam by first checking for a scratch partition.
- auto metadata_slot = fs_mgr_overlayfs_slot_number();
- auto super_device = fs_mgr_overlayfs_super_device(metadata_slot);
+ const auto super_device = kPhysicalDevice + fs_mgr_get_super_partition_name();
auto metadata = ReadCurrentMetadata(super_device);
if (!metadata) {
return {};
@@ -941,7 +925,7 @@
if (!OverlayfsTeardownAllowed()) {
return;
}
- if (!fs_mgr_in_recovery()) {
+ if (!InRecovery()) {
LERROR << __FUNCTION__ << "(): must be called within recovery.";
return;
}
diff --git a/fs_mgr/fs_mgr_overlayfs_control.h b/fs_mgr/fs_mgr_overlayfs_control.h
index 50e83e8..b175101 100644
--- a/fs_mgr/fs_mgr_overlayfs_control.h
+++ b/fs_mgr/fs_mgr_overlayfs_control.h
@@ -14,8 +14,6 @@
#pragma once
-#include <string>
-
#include <fstab/fstab.h>
// If "mount_point" is non-null, set up exactly one overlay.
diff --git a/fs_mgr/fs_mgr_overlayfs_mount.cpp b/fs_mgr/fs_mgr_overlayfs_mount.cpp
index e380f84..37e3058 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.cpp
+++ b/fs_mgr/fs_mgr_overlayfs_mount.cpp
@@ -14,16 +14,12 @@
* limitations under the License.
*/
-#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <linux/fs.h>
#include <selinux/selinux.h>
-#include <stdio.h>
#include <stdlib.h>
-#include <string.h>
#include <sys/mount.h>
-#include <sys/param.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <sys/types.h>
@@ -33,7 +29,6 @@
#include <algorithm>
#include <memory>
-#include <optional>
#include <string>
#include <vector>
@@ -45,7 +40,6 @@
#include <ext4_utils/ext4_utils.h>
#include <fs_mgr.h>
#include <fs_mgr/file_wait.h>
-#include <fs_mgr_dm_linear.h>
#include <fs_mgr_overlayfs.h>
#include <fstab/fstab.h>
#include <libdm/dm.h>
@@ -68,34 +62,15 @@
constexpr char kLowerdirOption[] = "lowerdir=";
constexpr char kUpperdirOption[] = "upperdir=";
-bool fs_mgr_access(const std::string& path) {
- return access(path.c_str(), F_OK) == 0;
-}
-
-bool fs_mgr_in_recovery() {
- // Check the existence of recovery binary instead of using the compile time
- // __ANDROID_RECOVERY__ macro.
- // If BOARD_USES_RECOVERY_AS_BOOT is true, both normal and recovery boot
- // mode would use the same init binary, which would mean during normal boot
- // the '/init' binary is actually a symlink pointing to
- // init_second_stage.recovery, which would be compiled with
- // __ANDROID_RECOVERY__ defined.
- return fs_mgr_access("/system/bin/recovery");
-}
-
bool fs_mgr_is_dsu_running() {
// Since android::gsi::CanBootIntoGsi() or android::gsi::MarkSystemAsGsi() is
// never called in recovery, the return value of android::gsi::IsGsiRunning()
// is not well-defined. In this case, just return false as being in recovery
// implies not running a DSU system.
- if (fs_mgr_in_recovery()) return false;
+ if (InRecovery()) return false;
return android::gsi::IsGsiRunning();
}
-static bool IsABDevice() {
- return !android::base::GetProperty("ro.boot.slot_suffix", "").empty();
-}
-
std::vector<const std::string> OverlayMountPoints() {
// Never fallback to legacy cache mount point if within a DSU system,
// because running a DSU system implies the device supports dynamic
@@ -106,7 +81,8 @@
// For non-A/B devices prefer cache backing storage if
// kPreferCacheBackingStorageProp property set.
- if (!IsABDevice() && android::base::GetBoolProperty(kPreferCacheBackingStorageProp, false) &&
+ if (fs_mgr_get_slot_suffix().empty() &&
+ android::base::GetBoolProperty(kPreferCacheBackingStorageProp, false) &&
android::base::GetIntProperty("ro.vendor.api_level", -1) < __ANDROID_API_T__) {
return {kCacheMountPoint, kScratchMountPoint};
}
@@ -119,11 +95,6 @@
return !stat(path.c_str(), &st) && S_ISDIR(st.st_mode);
}
-bool fs_mgr_rw_access(const std::string& path) {
- if (path.empty()) return false;
- return access(path.c_str(), R_OK | W_OK) == 0;
-}
-
// At less than 1% or 8MB of free space return value of false,
// means we will try to wrap with overlayfs.
bool fs_mgr_filesystem_has_space(const std::string& mount_point) {
@@ -146,7 +117,7 @@
if (entry->fs_mgr_flags.logical) {
fs_mgr_update_logical_partition(entry);
}
- if (fs_mgr_access(entry->blk_device)) {
+ if (access(entry->blk_device.c_str(), F_OK) == 0) {
return true;
}
if (entry->blk_device != "/dev/root") {
@@ -155,9 +126,9 @@
// special case for system-as-root (taimen and others)
auto blk_device = kPhysicalDevice + "system"s;
- if (!fs_mgr_access(blk_device)) {
+ if (access(blk_device.c_str(), F_OK)) {
blk_device += fs_mgr_get_slot_suffix();
- if (!fs_mgr_access(blk_device)) {
+ if (access(blk_device.c_str(), F_OK)) {
return false;
}
}
@@ -241,7 +212,7 @@
if (!fs_mgr_is_dir(upper)) continue;
auto work = dir + kWorkName;
if (!fs_mgr_is_dir(work)) continue;
- if (!fs_mgr_rw_access(work)) continue;
+ if (access(work.c_str(), R_OK | W_OK)) continue;
return dir;
}
return "";
@@ -528,11 +499,11 @@
// Mount kScratchMountPoint
bool MountScratch(const std::string& device_path, bool readonly) {
if (readonly) {
- if (!fs_mgr_access(device_path)) {
+ if (access(device_path.c_str(), F_OK)) {
LOG(ERROR) << "Path does not exist: " << device_path;
return false;
}
- } else if (!fs_mgr_rw_access(device_path)) {
+ } else if (access(device_path.c_str(), R_OK | W_OK)) {
LOG(ERROR) << "Path does not exist or is not readwrite: " << device_path;
return false;
}
@@ -644,7 +615,7 @@
return false;
}
// in recovery or fastbootd, not allowed!
- if (fs_mgr_in_recovery()) {
+ if (InRecovery()) {
if (verbose) {
LOG(ERROR) << "Unsupported overlayfs setup from recovery";
}
@@ -724,7 +695,7 @@
// if verity is still disabled, i.e. no reboot occurred), and skips calling
// fs_mgr_overlayfs_mount_all().
auto scratch_device = GetBootScratchDevice();
- if (!fs_mgr_rw_access(scratch_device)) {
+ if (access(scratch_device.c_str(), R_OK | W_OK)) {
return;
}
if (!WaitForFile(scratch_device, 10s)) {
@@ -733,7 +704,8 @@
if (!MountScratch(scratch_device, true /* readonly */)) {
return;
}
- auto has_overlayfs_dir = fs_mgr_access(kScratchMountPoint + "/"s + kOverlayTopDir);
+ const auto top = kScratchMountPoint + "/"s + kOverlayTopDir;
+ const bool has_overlayfs_dir = access(top.c_str(), F_OK) == 0;
fs_mgr_overlayfs_umount_scratch();
if (has_overlayfs_dir) {
MountScratch(scratch_device);
diff --git a/fs_mgr/fs_mgr_overlayfs_mount.h b/fs_mgr/fs_mgr_overlayfs_mount.h
index d9a93d4..f0afac1 100644
--- a/fs_mgr/fs_mgr_overlayfs_mount.h
+++ b/fs_mgr/fs_mgr_overlayfs_mount.h
@@ -49,9 +49,6 @@
};
bool fs_mgr_is_dsu_running();
-bool fs_mgr_in_recovery();
-bool fs_mgr_access(const std::string& path);
-bool fs_mgr_rw_access(const std::string& path);
bool fs_mgr_filesystem_has_space(const std::string& mount_point);
const std::string fs_mgr_mount_point(const std::string& mount_point);
bool OverlayfsSetupAllowed(bool verbose = false);
diff --git a/fs_mgr/fs_mgr_priv.h b/fs_mgr/fs_mgr_priv.h
index 46cdb62..c3b18c8 100644
--- a/fs_mgr/fs_mgr_priv.h
+++ b/fs_mgr/fs_mgr_priv.h
@@ -97,8 +97,6 @@
bool fs_mgr_is_ext4(const std::string& blk_device);
bool fs_mgr_is_f2fs(const std::string& blk_device);
-bool fs_mgr_teardown_verity(android::fs_mgr::FstabEntry* fstab);
-
bool fs_mgr_filesystem_available(const std::string& filesystem);
std::string fs_mgr_get_context(const std::string& mount_point);
diff --git a/fs_mgr/include_fstab/fstab/fstab.h b/fs_mgr/include_fstab/fstab/fstab.h
index 9cb1546..80b45ba 100644
--- a/fs_mgr/include_fstab/fstab/fstab.h
+++ b/fs_mgr/include_fstab/fstab/fstab.h
@@ -131,5 +131,7 @@
// expected name.
std::string GetVerityDeviceName(const FstabEntry& entry);
+bool InRecovery();
+
} // namespace fs_mgr
} // namespace android