Merge "first stage mount: removing the requirement of by-name prefix for AVB" (cdad92fd) · Commits · e / os / android_system_core

fs_mgr/fs_mgr.cpp

+2 −19

Original line number	Diff line number	Diff line
		@@ -744,23 +744,6 @@ static int handle_encryptable(const struct fstab_rec* rec)
		}
		}

		static std::string extract_by_name_prefix(struct fstab* fstab) {
		// We assume that there's an entry for the /misc mount point in the
		// fstab file and use that to get the device file by-name prefix.
		// The device needs not to have an actual /misc partition.
		// e.g.,
		// - /dev/block/platform/soc.0/7824900.sdhci/by-name/misc ->
		// - /dev/block/platform/soc.0/7824900.sdhci/by-name/
		struct fstab_rec* fstab_entry = fs_mgr_get_entry_for_mount_point(fstab, "/misc");
		if (fstab_entry == nullptr) {
		LERROR << "/misc mount point not found in fstab";
		return "";
		}
		std::string full_path(fstab_entry->blk_device);
		size_t end_slash = full_path.find_last_of("/");
		return full_path.substr(0, end_slash + 1);
		}

		// TODO: add ueventd notifiers if they don't exist.
		// This is just doing a wait_for_device for maximum of 1s
		int fs_mgr_test_access(const char *device) {
		@@ -850,7 +833,7 @@ int fs_mgr_mount_all(struct fstab *fstab, int mount_mode)

		if (fstab->recs[i].fs_mgr_flags & MF_AVB) {
		if (!avb_handle) {
		avb_handle = FsManagerAvbHandle::Open(extract_by_name_prefix(fstab));
		avb_handle = FsManagerAvbHandle::Open(*fstab);
		if (!avb_handle) {
		LERROR << "Failed to open FsManagerAvbHandle";
		return FS_MGR_MNTALL_FAIL;
		@@ -1060,7 +1043,7 @@ int fs_mgr_do_mount(struct fstab fstab, const char n_name, char *n_blk_device,

		if (fstab->recs[i].fs_mgr_flags & MF_AVB) {
		if (!avb_handle) {
		avb_handle = FsManagerAvbHandle::Open(extract_by_name_prefix(fstab));
		avb_handle = FsManagerAvbHandle::Open(*fstab);
		if (!avb_handle) {
		LERROR << "Failed to open FsManagerAvbHandle";
		return FS_MGR_DOMNT_FAILED;

fs_mgr/fs_mgr_avb.cpp

+16 −7

Original line number	Diff line number	Diff line
		@@ -14,6 +14,8 @@
		* limitations under the License.
		*/

		#include "fs_mgr_avb.h"

		#include <errno.h>
		#include <fcntl.h>
		#include <inttypes.h>
		@@ -38,9 +40,8 @@
		#include <utils/Compat.h>

		#include "fs_mgr.h"
		#include "fs_mgr_avb.h"
		#include "fs_mgr_avb_ops.h"
		#include "fs_mgr_priv.h"
		#include "fs_mgr_priv_avb_ops.h"
		#include "fs_mgr_priv_dm_ioctl.h"
		#include "fs_mgr_priv_sha.h"

		@@ -457,12 +458,21 @@ static bool get_hashtree_descriptor(const std::string& partition_name,
		return true;
		}

		FsManagerAvbUniquePtr FsManagerAvbHandle::Open(const std::string& device_file_by_name_prefix) {
		if (device_file_by_name_prefix.empty()) {
		LERROR << "Missing device file by-name prefix";
		FsManagerAvbUniquePtr FsManagerAvbHandle::Open(const fstab& fstab) {
		FsManagerAvbOps avb_ops(fstab);
		return DoOpen(&avb_ops);
		}

		FsManagerAvbUniquePtr FsManagerAvbHandle::Open(ByNameSymlinkMap&& by_name_symlink_map) {
		if (by_name_symlink_map.empty()) {
		LERROR << "Empty by_name_symlink_map when opening FsManagerAvbHandle";
		return nullptr;
		}
		FsManagerAvbOps avb_ops(std::move(by_name_symlink_map));
		return DoOpen(&avb_ops);
		}

		FsManagerAvbUniquePtr FsManagerAvbHandle::DoOpen(FsManagerAvbOps* avb_ops) {
		// Gets the expected hash value of vbmeta images from kernel cmdline.
		std::unique_ptr<FsManagerAvbVerifier> avb_verifier = FsManagerAvbVerifier::Create();
		if (!avb_verifier) {
		@@ -476,8 +486,7 @@ FsManagerAvbUniquePtr FsManagerAvbHandle::Open(const std::string& device_file_by
		return nullptr;
		}

		FsManagerAvbOps avb_ops(device_file_by_name_prefix);
		AvbSlotVerifyResult verify_result = avb_ops.AvbSlotVerify(
		AvbSlotVerifyResult verify_result = avb_ops->AvbSlotVerify(
		fs_mgr_get_slot_suffix(), avb_verifier->IsDeviceUnlocked(), &avb_handle->avb_slot_data_);

		// Only allow two verify results:

fs_mgr/fs_mgr_avb_ops.cpp

+27 −13

Original line number	Diff line number	Diff line
		@@ -22,6 +22,8 @@
		* SOFTWARE.
		*/

		#include "fs_mgr_priv_avb_ops.h"

		#include <errno.h>
		#include <fcntl.h>
		#include <stdlib.h>
		@@ -36,7 +38,6 @@
		#include <utils/Compat.h>

		#include "fs_mgr.h"
		#include "fs_mgr_avb_ops.h"
		#include "fs_mgr_priv.h"

		static AvbIOResult read_from_partition(AvbOps* ops, const char* partition, int64_t offset,
		@@ -88,11 +89,7 @@ static AvbIOResult dummy_get_unique_guid_for_partition(AvbOps* ops ATTRIBUTE_UNU
		return AVB_IO_RESULT_OK;
		}

		FsManagerAvbOps::FsManagerAvbOps(const std::string& device_file_by_name_prefix)
		: device_file_by_name_prefix_(device_file_by_name_prefix) {
		if (device_file_by_name_prefix_.back() != '/') {
		device_file_by_name_prefix_ += '/';
		}
		void FsManagerAvbOps::InitializeAvbOps() {
		// We only need to provide the implementation of read_from_partition()
		// operation since that's all what is being used by the avb_slot_verify().
		// Other I/O operations are only required in bootloader but not in
		@@ -109,13 +106,31 @@ FsManagerAvbOps::FsManagerAvbOps(const std::string& device_file_by_name_prefix)
		avb_ops_.user_data = this;
		}

		FsManagerAvbOps::FsManagerAvbOps(std::map<std::string, std::string>&& by_name_symlink_map)
		: by_name_symlink_map_(std::move(by_name_symlink_map)) {
		InitializeAvbOps();
		}

		FsManagerAvbOps::FsManagerAvbOps(const fstab& fstab) {
		// Constructs the by-name symlink map for each fstab record.
		// /dev/block/platform/soc.0/7824900.sdhci/by-name/system_a =>
		// by_name_symlink_map_["system_a"] = "/dev/block/platform/soc.0/7824900.sdhci/by-name/system_a"
		for (int i = 0; i < fstab.num_entries; i++) {
		std::string partition_name = basename(fstab.recs[i].blk_device);
		by_name_symlink_map_[partition_name] = fstab.recs[i].blk_device;
		}
		InitializeAvbOps();
		}

		AvbIOResult FsManagerAvbOps::ReadFromPartition(const char* partition, int64_t offset,
		size_t num_bytes, void* buffer,
		size_t* out_num_read) {
		// Appends \|partition\| to the device_file_by_name_prefix_, e.g.,
		// - /dev/block/platform/soc.0/7824900.sdhci/by-name/ ->
		// - /dev/block/platform/soc.0/7824900.sdhci/by-name/system_a
		std::string path = device_file_by_name_prefix_ + partition;
		const auto iter = by_name_symlink_map_.find(partition);
		if (iter == by_name_symlink_map_.end()) {
		LERROR << "by-name symlink not found for partition: '" << partition << "'";
		return AVB_IO_RESULT_ERROR_NO_SUCH_PARTITION;
		}
		std::string path = iter->second;

		// Ensures the device path (a symlink created by init) is ready to
		// access. fs_mgr_test_access() will test a few iterations if the
		@@ -126,7 +141,7 @@ AvbIOResult FsManagerAvbOps::ReadFromPartition(const char* partition, int64_t of

		android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY \| O_CLOEXEC)));
		if (fd < 0) {
		PERROR << "Failed to open " << path.c_str();
		PERROR << "Failed to open " << path;
		return AVB_IO_RESULT_ERROR_IO;
		}

		@@ -150,8 +165,7 @@ AvbIOResult FsManagerAvbOps::ReadFromPartition(const char* partition, int64_t of
		// for EOF).
		ssize_t num_read = TEMP_FAILURE_RETRY(pread64(fd, buffer, num_bytes, offset));
		if (num_read < 0 \|\| (size_t)num_read != num_bytes) {
		PERROR << "Failed to read " << num_bytes << " bytes from " << path.c_str() << " offset "
		<< offset;
		PERROR << "Failed to read " << num_bytes << " bytes from " << path << " offset " << offset;
		return AVB_IO_RESULT_ERROR_IO;
		}

fs_mgr/fs_mgr_avb_ops.h→fs_mgr/fs_mgr_priv_avb_ops.h

+11 −5

Original line number	Diff line number	Diff line
		@@ -22,8 +22,11 @@
		* SOFTWARE.
		*/

		#ifndef __CORE_FS_MGR_AVB_OPS_H
		#define __CORE_FS_MGR_AVB_OPS_H
		#ifndef __CORE_FS_MGR_PRIV_AVB_OPS_H
		#define __CORE_FS_MGR_PRIV_AVB_OPS_H

		#include <map>
		#include <string>

		#include <libavb/libavb.h>

		@@ -43,7 +46,8 @@
		//
		class FsManagerAvbOps {
		public:
		FsManagerAvbOps(const std::string& device_file_by_name_prefix);
		FsManagerAvbOps(const fstab& fstab);
		FsManagerAvbOps(std::map<std::string, std::string>&& by_name_symlink_map);

		static FsManagerAvbOps* GetInstanceFromAvbOps(AvbOps* ops) {
		return reinterpret_cast<FsManagerAvbOps*>(ops->user_data);
		@@ -56,7 +60,9 @@ class FsManagerAvbOps {
		AvbSlotVerifyData** out_data);

		private:
		void InitializeAvbOps();

		AvbOps avb_ops_;
		std::string device_file_by_name_prefix_;
		std::map<std::string, std::string> by_name_symlink_map_;
		};
		#endif /* __CORE_FS_MGR_AVB_OPS_H */
		#endif /* __CORE_FS_MGR_PRIV_AVB_OPS_H */

fs_mgr/include/fs_mgr_avb.h

+16 −3

Original line number	Diff line number	Diff line
		@@ -17,6 +17,7 @@
		#ifndef __CORE_FS_MGR_AVB_H
		#define __CORE_FS_MGR_AVB_H

		#include <map>
		#include <memory>
		#include <string>

		@@ -31,9 +32,13 @@ enum FsManagerAvbHandleStatus {
		kFsManagerAvbHandleErrorVerification = 2,
		};

		class FsManagerAvbOps;

		class FsManagerAvbHandle;
		using FsManagerAvbUniquePtr = std::unique_ptr<FsManagerAvbHandle>;

		using ByNameSymlinkMap = std::map<std::string, std::string>;

		// Provides a factory method to return a unique_ptr pointing to itself and the
		// SetUpAvb() function to extract dm-verity parameters from AVB metadata to
		// load verity table into kernel through ioctl.
		@@ -49,6 +54,13 @@ class FsManagerAvbHandle {
		// A typical usage will be:
		// - FsManagerAvbUniquePtr handle = FsManagerAvbHandle::Open();
		//
		// There are two overloaded Open() functions with a single parameter.
		// The argument can be a ByNameSymlinkMap describing the mapping from partition
		// name to by-name symlink, or a fstab file to which the ByNameSymlinkMap is
		// constructed from. e.g.,
		// - /dev/block/platform/soc.0/7824900.sdhci/by-name/system_a ->
		// - ByNameSymlinkMap["system_a"] = "/dev/block/platform/soc.0/7824900.sdhci/by-name/system_a"
		//
		// Possible return values:
		// - nullptr: any error when reading and verifying the metadata,
		// e.g., I/O error, digest value mismatch, size mismatch, etc.
		@@ -61,7 +73,8 @@ class FsManagerAvbHandle {
		// - a valid unique_ptr with status kFsMgrAvbHandleSuccess: the metadata
		// is verified and can be trusted.
		//
		static FsManagerAvbUniquePtr Open(const std::string& device_file_by_name_prefix);
		static FsManagerAvbUniquePtr Open(const fstab& fstab);
		static FsManagerAvbUniquePtr Open(ByNameSymlinkMap&& by_name_symlink_map);

		// Sets up dm-verity on the given fstab entry.
		// The 'wait_for_verity_dev' parameter makes this function wait for the
		@@ -88,10 +101,10 @@ class FsManagerAvbHandle {
		}
		};

		protected:
		private:
		FsManagerAvbHandle() : avb_slot_data_(nullptr), status_(kFsManagerAvbHandleUninitialized) {}
		static FsManagerAvbUniquePtr DoOpen(FsManagerAvbOps* avb_ops);

		private:
		AvbSlotVerifyData* avb_slot_data_;
		FsManagerAvbHandleStatus status_;
		std::string avb_version_;