Merge changes from topic "remove-fde" am: 8879f2723f am: 9558e12aac am: 79c96b6295 am: 4d7246705a (e7041a18) · Commits · e / os / android_system_core

fs_mgr/fs_mgr.cpp

+7 −74

Original line number	Diff line number	Diff line
		@@ -75,9 +75,6 @@
		#include "blockdev.h"
		#include "fs_mgr_priv.h"

		#define KEY_LOC_PROP "ro.crypto.keyfile.userdata"
		#define KEY_IN_FOOTER "footer"

		#define E2FSCK_BIN "/system/bin/e2fsck"
		#define F2FS_FSCK_BIN "/system/bin/fsck.f2fs"
		#define MKSWAP_BIN "/system/bin/mkswap"
		@@ -907,7 +904,7 @@ static bool mount_with_alternatives(const Fstab& fstab, int start_idx, int* end_
		<< "(): skipping mount due to invalid magic, mountpoint=" << fstab[i].mount_point
		<< " blk_dev=" << realpath(fstab[i].blk_device) << " rec[" << i
		<< "].fs_type=" << fstab[i].fs_type;
		mount_errno = EINVAL; // continue bootup for FDE
		mount_errno = EINVAL; // continue bootup for metadata encryption
		continue;
		}

		@@ -1005,50 +1002,22 @@ static bool TranslateExtLabels(FstabEntry* entry) {
		return false;
		}

		static bool needs_block_encryption(const FstabEntry& entry) {
		if (android::base::GetBoolProperty("ro.vold.forceencryption", false) && entry.is_encryptable())
		return true;
		if (entry.fs_mgr_flags.force_crypt) return true;
		if (entry.fs_mgr_flags.crypt) {
		// Check for existence of convert_fde breadcrumb file.
		auto convert_fde_name = entry.mount_point + "/misc/vold/convert_fde";
		if (access(convert_fde_name.c_str(), F_OK) == 0) return true;
		}
		if (entry.fs_mgr_flags.force_fde_or_fbe) {
		// Check for absence of convert_fbe breadcrumb file.
		auto convert_fbe_name = entry.mount_point + "/convert_fbe";
		if (access(convert_fbe_name.c_str(), F_OK) != 0) return true;
		}
		return false;
		}

		static bool should_use_metadata_encryption(const FstabEntry& entry) {
		return !entry.metadata_key_dir.empty() &&
		(entry.fs_mgr_flags.file_encryption \|\| entry.fs_mgr_flags.force_fde_or_fbe);
		return !entry.metadata_key_dir.empty() && entry.fs_mgr_flags.file_encryption;
		}

		// Check to see if a mountable volume has encryption requirements
		static int handle_encryptable(const FstabEntry& entry) {
		// If this is block encryptable, need to trigger encryption.
		if (needs_block_encryption(entry)) {
		if (umount(entry.mount_point.c_str()) == 0) {
		return FS_MGR_MNTALL_DEV_NEEDS_ENCRYPTION;
		} else {
		PWARNING << "Could not umount " << entry.mount_point << " - allow continue unencrypted";
		return FS_MGR_MNTALL_DEV_NOT_ENCRYPTED;
		}
		} else if (should_use_metadata_encryption(entry)) {
		if (should_use_metadata_encryption(entry)) {
		if (umount(entry.mount_point.c_str()) == 0) {
		return FS_MGR_MNTALL_DEV_NEEDS_METADATA_ENCRYPTION;
		} else {
		PERROR << "Could not umount " << entry.mount_point << " - fail since can't encrypt";
		return FS_MGR_MNTALL_FAIL;
		}
		} else if (entry.fs_mgr_flags.file_encryption \|\| entry.fs_mgr_flags.force_fde_or_fbe) {
		} else if (entry.fs_mgr_flags.file_encryption) {
		LINFO << entry.mount_point << " is file encrypted";
		return FS_MGR_MNTALL_DEV_FILE_ENCRYPTED;
		} else if (entry.is_encryptable()) {
		return FS_MGR_MNTALL_DEV_NOT_ENCRYPTED;
		} else {
		return FS_MGR_MNTALL_DEV_NOT_ENCRYPTABLE;
		}
		@@ -1056,9 +1025,6 @@ static int handle_encryptable(const FstabEntry& entry) {

		static void set_type_property(int status) {
		switch (status) {
		case FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED:
		SetProperty("ro.crypto.type", "block");
		break;
		case FS_MGR_MNTALL_DEV_FILE_ENCRYPTED:
		case FS_MGR_MNTALL_DEV_IS_METADATA_ENCRYPTED:
		case FS_MGR_MNTALL_DEV_NEEDS_METADATA_ENCRYPTION:
		@@ -1532,7 +1498,6 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {

		// Mounting failed, understand why and retry.
		wiped = partition_wiped(current_entry.blk_device.c_str());
		bool crypt_footer = false;
		if (mount_errno != EBUSY && mount_errno != EACCES &&
		current_entry.fs_mgr_flags.formattable && wiped) {
		// current_entry and attempted_entry point at the same partition, but sometimes
		@@ -1544,19 +1509,6 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {

		checkpoint_manager.Revert(&current_entry);

		if (current_entry.is_encryptable() && current_entry.key_loc != KEY_IN_FOOTER) {
		unique_fd fd(TEMP_FAILURE_RETRY(
		open(current_entry.key_loc.c_str(), O_WRONLY \| O_CLOEXEC)));
		if (fd >= 0) {
		LINFO << __FUNCTION__ << "(): also wipe " << current_entry.key_loc;
		wipe_block_device(fd, get_file_size(fd));
		} else {
		PERROR << __FUNCTION__ << "(): " << current_entry.key_loc << " wouldn't open";
		}
		} else if (current_entry.is_encryptable() && current_entry.key_loc == KEY_IN_FOOTER) {
		crypt_footer = true;
		}

		// EncryptInplace will be used when vdc gives an error or needs to format partitions
		// other than /data
		if (should_use_metadata_encryption(current_entry) &&
		@@ -1577,7 +1529,7 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
		}
		}

		if (fs_mgr_do_format(current_entry, crypt_footer) == 0) {
		if (fs_mgr_do_format(current_entry) == 0) {
		// Let's replay the mount actions.
		i = top_idx - 1;
		continue;
		@@ -1590,26 +1542,7 @@ MountAllResult fs_mgr_mount_all(Fstab* fstab, int mount_mode) {
		}

		// mount(2) returned an error, handle the encryptable/formattable case.
		if (mount_errno != EBUSY && mount_errno != EACCES && attempted_entry.is_encryptable()) {
		if (wiped) {
		LERROR << __FUNCTION__ << "(): " << attempted_entry.blk_device << " is wiped and "
		<< attempted_entry.mount_point << " " << attempted_entry.fs_type
		<< " is encryptable. Suggest recovery...";
		encryptable = FS_MGR_MNTALL_DEV_NEEDS_RECOVERY;
		continue;
		} else {
		// Need to mount a tmpfs at this mountpoint for now, and set
		// properties that vold will query later for decrypting
		LERROR << __FUNCTION__ << "(): possibly an encryptable blkdev "
		<< attempted_entry.blk_device << " for mount " << attempted_entry.mount_point
		<< " type " << attempted_entry.fs_type;
		if (fs_mgr_do_tmpfs_mount(attempted_entry.mount_point.c_str()) < 0) {
		++error_count;
		continue;
		}
		}
		encryptable = FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED;
		} else if (mount_errno != EBUSY && mount_errno != EACCES &&
		if (mount_errno != EBUSY && mount_errno != EACCES &&
		should_use_metadata_encryption(attempted_entry)) {
		if (!call_vdc({"cryptfs", "mountFstab", attempted_entry.blk_device,
		attempted_entry.mount_point},

fs_mgr/fs_mgr_format.cpp

+7 −14

Original line number	Diff line number	Diff line
		@@ -34,7 +34,6 @@
		#include <selinux/selinux.h>

		#include "fs_mgr_priv.h"
		#include "cryptfs.h"

		using android::base::unique_fd;

		@@ -58,7 +57,7 @@ static int get_dev_sz(const std::string& fs_blkdev, uint64_t* dev_sz) {
		}

		static int format_ext4(const std::string& fs_blkdev, const std::string& fs_mnt_point,
		bool crypt_footer, bool needs_projid, bool needs_metadata_csum) {
		bool needs_projid, bool needs_metadata_csum) {
		uint64_t dev_sz;
		int rc = 0;

		@@ -68,9 +67,6 @@ static int format_ext4(const std::string& fs_blkdev, const std::string& fs_mnt_p
		}

		/* Format the partition using the calculated length */
		if (crypt_footer) {
		dev_sz -= CRYPT_FOOTER_OFFSET;
		}

		std::string size_str = std::to_string(dev_sz / 4096);

		@@ -120,8 +116,8 @@ static int format_ext4(const std::string& fs_blkdev, const std::string& fs_mnt_p
		return rc;
		}

		static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool crypt_footer,
		bool needs_projid, bool needs_casefold, bool fs_compress) {
		static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool needs_projid,
		bool needs_casefold, bool fs_compress) {
		if (!dev_sz) {
		int rc = get_dev_sz(fs_blkdev, &dev_sz);
		if (rc) {
		@@ -130,9 +126,6 @@ static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool crypt
		}

		/* Format the partition using the calculated length */
		if (crypt_footer) {
		dev_sz -= CRYPT_FOOTER_OFFSET;
		}

		std::string size_str = std::to_string(dev_sz / 4096);

		@@ -159,7 +152,7 @@ static int format_f2fs(const std::string& fs_blkdev, uint64_t dev_sz, bool crypt
		return logwrap_fork_execvp(args.size(), args.data(), nullptr, false, LOG_KLOG, false, nullptr);
		}

		int fs_mgr_do_format(const FstabEntry& entry, bool crypt_footer) {
		int fs_mgr_do_format(const FstabEntry& entry) {
		LERROR << __FUNCTION__ << ": Format " << entry.blk_device << " as '" << entry.fs_type << "'";

		bool needs_casefold = false;
		@@ -171,10 +164,10 @@ int fs_mgr_do_format(const FstabEntry& entry, bool crypt_footer) {
		}

		if (entry.fs_type == "f2fs") {
		return format_f2fs(entry.blk_device, entry.length, crypt_footer, needs_projid,
		needs_casefold, entry.fs_mgr_flags.fs_compress);
		return format_f2fs(entry.blk_device, entry.length, needs_projid, needs_casefold,
		entry.fs_mgr_flags.fs_compress);
		} else if (entry.fs_type == "ext4") {
		return format_ext4(entry.blk_device, entry.mount_point, crypt_footer, needs_projid,
		return format_ext4(entry.blk_device, entry.mount_point, needs_projid,
		entry.fs_mgr_flags.ext_meta_csum);
		} else {
		LERROR << "File system type '" << entry.fs_type << "' is not supported";

fs_mgr/fs_mgr_fstab.cpp

+25 −15

Original line number	Diff line number	Diff line
		@@ -146,7 +146,7 @@ void ParseMountFlags(const std::string& flags, FstabEntry* entry) {
		entry->fs_options = std::move(fs_options);
		}

		void ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
		bool ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
		for (const auto& flag : Split(flags, ",")) {
		if (flag.empty() \|\| flag == "defaults") continue;
		std::string arg;
		@@ -188,10 +188,20 @@ void ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
		#undef CheckFlag

		// Then handle flags that take an argument.
		if (StartsWith(flag, "encryptable=")) {
		// The encryptable flag is followed by an = and the location of the keys.
		if (flag == "encryptable=userdata") {
		// The "encryptable" flag identifies adoptable storage volumes. The
		// argument to this flag must be "userdata".
		//
		// Historical note: this flag was originally meant just for /data,
		// to indicate that FDE (full disk encryption) can be enabled.
		// Unfortunately, it was also overloaded to identify adoptable
		// storage volumes. Today, FDE is no longer supported, leaving only
		// the adoptable storage volume meaning for this flag.
		entry->fs_mgr_flags.crypt = true;
		entry->key_loc = arg;
		} else if (StartsWith(flag, "encryptable=") \|\| StartsWith(flag, "forceencrypt=") \|\|
		StartsWith(flag, "forcefdeorfbe=")) {
		LERROR << "flag no longer supported: " << flag;
		return false;
		} else if (StartsWith(flag, "voldmanaged=")) {
		// The voldmanaged flag is followed by an = and the label, a colon and the partition
		// number or the word "auto", e.g. voldmanaged=sdcard:3
		@@ -235,18 +245,8 @@ void ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
		LWARNING << "Warning: zramsize= flag malformed: " << arg;
		}
		}
		} else if (StartsWith(flag, "forceencrypt=")) {
		// The forceencrypt flag is followed by an = and the location of the keys.
		entry->fs_mgr_flags.force_crypt = true;
		entry->key_loc = arg;
		} else if (StartsWith(flag, "fileencryption=")) {
		ParseFileEncryption(arg, entry);
		} else if (StartsWith(flag, "forcefdeorfbe=")) {
		// The forcefdeorfbe flag is followed by an = and the location of the keys. Get it and
		// return it.
		entry->fs_mgr_flags.force_fde_or_fbe = true;
		entry->key_loc = arg;
		entry->encryption_options = "aes-256-xts:aes-256-cts";
		} else if (StartsWith(flag, "max_comp_streams=")) {
		if (!ParseInt(arg, &entry->max_comp_streams)) {
		LWARNING << "Warning: max_comp_streams= flag malformed: " << arg;
		@@ -306,6 +306,13 @@ void ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
		LWARNING << "Warning: unknown flag: " << flag;
		}
		}

		if (entry->fs_mgr_flags.crypt && !entry->fs_mgr_flags.vold_managed) {
		LERROR << "FDE is no longer supported; 'encryptable' can only be used for adoptable "
		"storage";
		return false;
		}
		return true;
		}

		std::string InitAndroidDtDir() {
		@@ -576,7 +583,10 @@ bool ReadFstabFromFp(FILE* fstab_file, bool proc_mounts, Fstab* fstab_out) {
		goto err;
		}

		ParseFsMgrFlags(p, &entry);
		if (!ParseFsMgrFlags(p, &entry)) {
		LERROR << "Error parsing fs_mgr_flags";
		goto err;
		}

		if (entry.fs_mgr_flags.logical) {
		entry.logical_partition_name = entry.blk_device;

fs_mgr/fs_mgr_roots.cpp

+1 −2

Original line number	Diff line number	Diff line
		@@ -125,8 +125,7 @@ bool TryPathMount(FstabEntry* rec, const std::string& mount_pt) {
		int result = fs_mgr_do_mount_one(*rec, mount_point);
		if (result == -1 && rec->fs_mgr_flags.formattable) {
		PERROR << "Failed to mount " << mount_point << "; formatting";
		bool crypt_footer = rec->is_encryptable() && rec->key_loc == "footer";
		if (fs_mgr_do_format(*rec, crypt_footer) != 0) {
		if (fs_mgr_do_format(*rec) != 0) {
		PERROR << "Failed to format " << mount_point;
		return false;
		}

fs_mgr/include/fs_mgr.h

+1 −4

Original line number	Diff line number	Diff line
		@@ -56,9 +56,6 @@ enum mount_mode {
		#define FS_MGR_MNTALL_DEV_NEEDS_METADATA_ENCRYPTION 6
		#define FS_MGR_MNTALL_DEV_FILE_ENCRYPTED 5
		#define FS_MGR_MNTALL_DEV_NEEDS_RECOVERY 4
		#define FS_MGR_MNTALL_DEV_NEEDS_ENCRYPTION 3
		#define FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED 2
		#define FS_MGR_MNTALL_DEV_NOT_ENCRYPTED 1
		#define FS_MGR_MNTALL_DEV_NOT_ENCRYPTABLE 0
		#define FS_MGR_MNTALL_FAIL (-1)

		@@ -107,7 +104,7 @@ bool fs_mgr_update_logical_partition(android::fs_mgr::FstabEntry* entry);
		// device is in "check_at_most_once" mode.
		bool fs_mgr_verity_is_check_at_most_once(const android::fs_mgr::FstabEntry& entry);

		int fs_mgr_do_format(const android::fs_mgr::FstabEntry& entry, bool reserve_footer);
		int fs_mgr_do_format(const android::fs_mgr::FstabEntry& entry);

		#define FS_MGR_SETUP_VERITY_SKIPPED (-3)
		#define FS_MGR_SETUP_VERITY_DISABLED (-2)