Merge "Fix-up coding style" (4a534ebc) · Commits · e / os / android_system_core

fs_mgr/.clang-format

0 → 120000

+1 −0

Original line number	Original line	Diff line number	Diff line
			../init/.clang-format
			No newline at end of file

fs_mgr/fs_mgr_avb.cpp

+91 −146

Original line number	Original line	Diff line number	Diff line
	@@ -52,12 +52,10 @@
	"%" PRIu64 " %" PRIu64 " %s %s %s "		"%" PRIu64 " %" PRIu64 " %s %s %s "

	#define VERITY_TABLE_PARAMS(hashtree_desc, blk_device, digest, salt) \		#define VERITY_TABLE_PARAMS(hashtree_desc, blk_device, digest, salt) \
	hashtree_desc.dm_verity_version, blk_device, blk_device, \		hashtree_desc.dm_verity_version, blk_device, blk_device, hashtree_desc.data_block_size, \
	hashtree_desc.data_block_size, hashtree_desc.hash_block_size, \		hashtree_desc.hash_block_size, \
	hashtree_desc.image_size / \		hashtree_desc.image_size / hashtree_desc.data_block_size, /* num_data_blocks. */ \
	hashtree_desc.data_block_size, /* num_data_blocks. */ \		hashtree_desc.tree_offset / hashtree_desc.hash_block_size, /* hash_start_block. */ \
	hashtree_desc.tree_offset / \
	hashtree_desc.hash_block_size, /* hash_start_block. */ \
	(char*)hashtree_desc.hash_algorithm, digest, salt		(char*)hashtree_desc.hash_algorithm, digest, salt

	#define VERITY_TABLE_OPT_RESTART "restart_on_corruption"		#define VERITY_TABLE_OPT_RESTART "restart_on_corruption"
	@@ -67,8 +65,7 @@
	* <#opt_params> ignore_zero_blocks restart_on_corruption		* <#opt_params> ignore_zero_blocks restart_on_corruption
	*/		*/
	#define VERITY_TABLE_OPT_DEFAULT_FORMAT "2 %s %s"		#define VERITY_TABLE_OPT_DEFAULT_FORMAT "2 %s %s"
	#define VERITY_TABLE_OPT_DEFAULT_PARAMS \		#define VERITY_TABLE_OPT_DEFAULT_PARAMS VERITY_TABLE_OPT_IGNZERO, VERITY_TABLE_OPT_RESTART
	VERITY_TABLE_OPT_IGNZERO, VERITY_TABLE_OPT_RESTART

	/* The FEC (forward error correction) format of dm-verity optional parameters:		/* The FEC (forward error correction) format of dm-verity optional parameters:
	* <#opt_params> use_fec_from_device <fec_dev>		* <#opt_params> use_fec_from_device <fec_dev>
	@@ -76,8 +73,7 @@
	* ignore_zero_blocks restart_on_corruption		* ignore_zero_blocks restart_on_corruption
	*/		*/
	#define VERITY_TABLE_OPT_FEC_FORMAT \		#define VERITY_TABLE_OPT_FEC_FORMAT \
	"10 use_fec_from_device %s fec_roots %u fec_blocks %" PRIu64 \		"10 use_fec_from_device %s fec_roots %u fec_blocks %" PRIu64 " fec_start %" PRIu64 " %s %s"
	" fec_start %" PRIu64 " %s %s"

	/* Note that fec_blocks is the size that FEC covers, not the		/* Note that fec_blocks is the size that FEC covers, not the
	* size of the FEC data. Since we use FEC for everything up until		* size of the FEC data. Since we use FEC for everything up until
	@@ -85,10 +81,8 @@
	*/		*/
	#define VERITY_TABLE_OPT_FEC_PARAMS(hashtree_desc, blk_device) \		#define VERITY_TABLE_OPT_FEC_PARAMS(hashtree_desc, blk_device) \
	blk_device, hashtree_desc.fec_num_roots, \		blk_device, hashtree_desc.fec_num_roots, \
	hashtree_desc.fec_offset / \		hashtree_desc.fec_offset / hashtree_desc.data_block_size, /* fec_blocks */ \
	hashtree_desc.data_block_size, /* fec_blocks */ \		hashtree_desc.fec_offset / hashtree_desc.data_block_size, /* fec_start */ \
	hashtree_desc.fec_offset / \
	hashtree_desc.data_block_size, /* fec_start */ \
	VERITY_TABLE_OPT_IGNZERO, VERITY_TABLE_OPT_RESTART		VERITY_TABLE_OPT_IGNZERO, VERITY_TABLE_OPT_RESTART

	AvbSlotVerifyData* fs_mgr_avb_verify_data = nullptr;		AvbSlotVerifyData* fs_mgr_avb_verify_data = nullptr;
	@@ -109,8 +103,7 @@ struct androidboot_vbmeta {

	androidboot_vbmeta fs_mgr_vbmeta_prop;		androidboot_vbmeta fs_mgr_vbmeta_prop;

	static inline bool nibble_value(const char &c, uint8_t *value)		static inline bool nibble_value(const char& c, uint8_t* value) {
	{
	FS_MGR_CHECK(value != nullptr);		FS_MGR_CHECK(value != nullptr);

	switch (c) {		switch (c) {
	@@ -130,10 +123,7 @@ static inline bool nibble_value(const char &c, uint8_t *value)
	return true;		return true;
	}		}

	static bool hex_to_bytes(uint8_t *bytes,		static bool hex_to_bytes(uint8_t* bytes, size_t bytes_len, const std::string& hex) {
	size_t bytes_len,
	const std::string &hex)
	{
	FS_MGR_CHECK(bytes != nullptr);		FS_MGR_CHECK(bytes != nullptr);

	if (hex.size() % 2 != 0) {		if (hex.size() % 2 != 0) {
	@@ -156,8 +146,7 @@ static bool hex_to_bytes(uint8_t *bytes,
	return true;		return true;
	}		}

	static std::string bytes_to_hex(const uint8_t *bytes, size_t bytes_len)		static std::string bytes_to_hex(const uint8_t* bytes, size_t bytes_len) {
	{
	FS_MGR_CHECK(bytes != nullptr);		FS_MGR_CHECK(bytes != nullptr);

	static const char* hex_digits = "0123456789abcdef";		static const char* hex_digits = "0123456789abcdef";
	@@ -170,8 +159,7 @@ static std::string bytes_to_hex(const uint8_t *bytes, size_t bytes_len)
	return hex;		return hex;
	}		}

	static bool load_vbmeta_prop(androidboot_vbmeta *vbmeta_prop)		static bool load_vbmeta_prop(androidboot_vbmeta* vbmeta_prop) {
	{
	FS_MGR_CHECK(vbmeta_prop != nullptr);		FS_MGR_CHECK(vbmeta_prop != nullptr);

	std::string cmdline;		std::string cmdline;
	@@ -180,8 +168,7 @@ static bool load_vbmeta_prop(androidboot_vbmeta *vbmeta_prop)
	std::string hash_alg;		std::string hash_alg;
	std::string digest;		std::string digest;

	for (const auto &entry :		for (const auto& entry : android::base::Split(android::base::Trim(cmdline), " ")) {
	android::base::Split(android::base::Trim(cmdline), " ")) {
	std::vector<std::string> pieces = android::base::Split(entry, "=");		std::vector<std::string> pieces = android::base::Split(entry, "=");
	const std::string& key = pieces[0];		const std::string& key = pieces[0];
	const std::string& value = pieces[1];		const std::string& value = pieces[1];
	@@ -191,8 +178,7 @@ static bool load_vbmeta_prop(androidboot_vbmeta *vbmeta_prop)
	} else if (key == "androidboot.vbmeta.hash_alg") {		} else if (key == "androidboot.vbmeta.hash_alg") {
	hash_alg = value;		hash_alg = value;
	} else if (key == "androidboot.vbmeta.size") {		} else if (key == "androidboot.vbmeta.size") {
	if (!android::base::ParseUint(value.c_str(),		if (!android::base::ParseUint(value.c_str(), &vbmeta_prop->vbmeta_size)) {
	&vbmeta_prop->vbmeta_size)) {
	return false;		return false;
	}		}
	} else if (key == "androidboot.vbmeta.digest") {		} else if (key == "androidboot.vbmeta.digest") {
	@@ -220,10 +206,8 @@ static bool load_vbmeta_prop(androidboot_vbmeta *vbmeta_prop)
	return false;		return false;
	}		}

	if (!hex_to_bytes(vbmeta_prop->digest, sizeof(vbmeta_prop->digest),		if (!hex_to_bytes(vbmeta_prop->digest, sizeof(vbmeta_prop->digest), digest)) {
	digest)) {		LERROR << "Hash digest contains non-hexidecimal character: " << digest.c_str();
	LERROR << "Hash digest contains non-hexidecimal character: "
	<< digest.c_str();
	return false;		return false;
	}		}

	@@ -231,9 +215,8 @@ static bool load_vbmeta_prop(androidboot_vbmeta *vbmeta_prop)
	}		}

	template <typename Hasher>		template <typename Hasher>
	static std::pair<size_t, bool> verify_vbmeta_digest(		static std::pair<size_t, bool> verify_vbmeta_digest(const AvbSlotVerifyData& verify_data,
	const AvbSlotVerifyData &verify_data, const androidboot_vbmeta &vbmeta_prop)		const androidboot_vbmeta& vbmeta_prop) {
	{
	size_t total_size = 0;		size_t total_size = 0;
	Hasher hasher;		Hasher hasher;
	for (size_t n = 0; n < verify_data.num_vbmeta_images; n++) {		for (size_t n = 0; n < verify_data.num_vbmeta_images; n++) {
	@@ -242,15 +225,13 @@ static std::pair<size_t, bool> verify_vbmeta_digest(
	total_size += verify_data.vbmeta_images[n].vbmeta_size;		total_size += verify_data.vbmeta_images[n].vbmeta_size;
	}		}

	bool matched = (memcmp(hasher.finalize(), vbmeta_prop.digest,		bool matched = (memcmp(hasher.finalize(), vbmeta_prop.digest, Hasher::DIGEST_SIZE) == 0);
	Hasher::DIGEST_SIZE) == 0);

	return std::make_pair(total_size, matched);		return std::make_pair(total_size, matched);
	}		}

	static bool verify_vbmeta_images(const AvbSlotVerifyData& verify_data,		static bool verify_vbmeta_images(const AvbSlotVerifyData& verify_data,
	const androidboot_vbmeta &vbmeta_prop)		const androidboot_vbmeta& vbmeta_prop) {
	{
	if (verify_data.num_vbmeta_images == 0) {		if (verify_data.num_vbmeta_images == 0) {
	LERROR << "No vbmeta images";		LERROR << "No vbmeta images";
	return false;		return false;
	@@ -281,23 +262,17 @@ static bool verify_vbmeta_images(const AvbSlotVerifyData &verify_data,
	return true;		return true;
	}		}

	static bool hashtree_load_verity_table(		static bool hashtree_load_verity_table(struct dm_ioctl* io, const std::string& dm_device_name,
	struct dm_ioctl *io,		int fd, const std::string& blk_device,
	const std::string &dm_device_name,
	int fd,
	const std::string &blk_device,
	const AvbHashtreeDescriptor& hashtree_desc,		const AvbHashtreeDescriptor& hashtree_desc,
	const std::string &salt,		const std::string& salt, const std::string& root_digest) {
	const std::string &root_digest)
	{
	fs_mgr_verity_ioctl_init(io, dm_device_name, DM_STATUS_TABLE_FLAG);		fs_mgr_verity_ioctl_init(io, dm_device_name, DM_STATUS_TABLE_FLAG);

	// The buffer consists of [dm_ioctl][dm_target_spec][verity_params].		// The buffer consists of [dm_ioctl][dm_target_spec][verity_params].
	char* buffer = (char*)io;		char* buffer = (char*)io;

	// Builds the dm_target_spec arguments.		// Builds the dm_target_spec arguments.
	struct dm_target_spec *dm_target =		struct dm_target_spec* dm_target = (struct dm_target_spec*)&buffer[sizeof(struct dm_ioctl)];
	(struct dm_target_spec *)&buffer[sizeof(struct dm_ioctl)];
	io->target_count = 1;		io->target_count = 1;
	dm_target->status = 0;		dm_target->status = 0;
	dm_target->sector_start = 0;		dm_target->sector_start = 0;
	@@ -305,23 +280,19 @@ static bool hashtree_load_verity_table(
	strcpy(dm_target->target_type, "verity");		strcpy(dm_target->target_type, "verity");

	// Builds the verity params.		// Builds the verity params.
	char *verity_params =		char* verity_params = buffer + sizeof(struct dm_ioctl) + sizeof(struct dm_target_spec);
	buffer + sizeof(struct dm_ioctl) + sizeof(struct dm_target_spec);
	size_t bufsize = DM_BUF_SIZE - (verity_params - buffer);		size_t bufsize = DM_BUF_SIZE - (verity_params - buffer);

	int res = 0;		int res = 0;
	if (hashtree_desc.fec_size > 0) {		if (hashtree_desc.fec_size > 0) {
	res = snprintf(		res = snprintf(verity_params, bufsize, VERITY_TABLE_FORMAT VERITY_TABLE_OPT_FEC_FORMAT,
	verity_params, bufsize,		VERITY_TABLE_PARAMS(hashtree_desc, blk_device.c_str(), root_digest.c_str(),
	VERITY_TABLE_FORMAT VERITY_TABLE_OPT_FEC_FORMAT,		salt.c_str()),
	VERITY_TABLE_PARAMS(hashtree_desc, blk_device.c_str(),
	root_digest.c_str(), salt.c_str()),
	VERITY_TABLE_OPT_FEC_PARAMS(hashtree_desc, blk_device.c_str()));		VERITY_TABLE_OPT_FEC_PARAMS(hashtree_desc, blk_device.c_str()));
	} else {		} else {
	res = snprintf(verity_params, bufsize,		res = snprintf(verity_params, bufsize, VERITY_TABLE_FORMAT VERITY_TABLE_OPT_DEFAULT_FORMAT,
	VERITY_TABLE_FORMAT VERITY_TABLE_OPT_DEFAULT_FORMAT,		VERITY_TABLE_PARAMS(hashtree_desc, blk_device.c_str(), root_digest.c_str(),
	VERITY_TABLE_PARAMS(hashtree_desc, blk_device.c_str(),		salt.c_str()),
	root_digest.c_str(), salt.c_str()),
	VERITY_TABLE_OPT_DEFAULT_PARAMS);		VERITY_TABLE_OPT_DEFAULT_PARAMS);
	}		}

	@@ -348,9 +319,7 @@ static bool hashtree_load_verity_table(

	static bool hashtree_dm_verity_setup(struct fstab_rec* fstab_entry,		static bool hashtree_dm_verity_setup(struct fstab_rec* fstab_entry,
	const AvbHashtreeDescriptor& hashtree_desc,		const AvbHashtreeDescriptor& hashtree_desc,
	const std::string &salt,		const std::string& salt, const std::string& root_digest) {
	const std::string &root_digest)
	{
	// Gets the device mapper fd.		// Gets the device mapper fd.
	android::base::unique_fd fd(open("/dev/device-mapper", O_RDWR));		android::base::unique_fd fd(open("/dev/device-mapper", O_RDWR));
	if (fd < 0) {		if (fd < 0) {
	@@ -375,8 +344,7 @@ static bool hashtree_dm_verity_setup(struct fstab_rec *fstab_entry,
	}		}

	// Loads the verity mapping table.		// Loads the verity mapping table.
	if (!hashtree_load_verity_table(io, mount_point, fd,		if (!hashtree_load_verity_table(io, mount_point, fd, std::string(fstab_entry->blk_device),
	std::string(fstab_entry->blk_device),
	hashtree_desc, salt, root_digest)) {		hashtree_desc, salt, root_digest)) {
	LERROR << "Couldn't load verity table!";		LERROR << "Couldn't load verity table!";
	return false;		return false;
	@@ -405,21 +373,17 @@ static bool hashtree_dm_verity_setup(struct fstab_rec *fstab_entry,

	static bool get_hashtree_descriptor(const std::string& partition_name,		static bool get_hashtree_descriptor(const std::string& partition_name,
	const AvbSlotVerifyData& verify_data,		const AvbSlotVerifyData& verify_data,
	AvbHashtreeDescriptor *out_hashtree_desc,		AvbHashtreeDescriptor* out_hashtree_desc, std::string* out_salt,
	std::string *out_salt,		std::string* out_digest) {
	std::string *out_digest)
	{
	bool found = false;		bool found = false;
	const uint8_t* desc_partition_name;		const uint8_t* desc_partition_name;

	for (size_t i = 0; i < verify_data.num_vbmeta_images && !found; i++) {		for (size_t i = 0; i < verify_data.num_vbmeta_images && !found; i++) {
	// Get descriptors from vbmeta_images[i].		// Get descriptors from vbmeta_images[i].
	size_t num_descriptors;		size_t num_descriptors;
	std::unique_ptr<const AvbDescriptor *[], decltype(&avb_free)>		std::unique_ptr<const AvbDescriptor* [], decltype(&avb_free)> descriptors(
	descriptors(
	avb_descriptor_get_all(verify_data.vbmeta_images[i].vbmeta_data,		avb_descriptor_get_all(verify_data.vbmeta_images[i].vbmeta_data,
	verify_data.vbmeta_images[i].vbmeta_size,		verify_data.vbmeta_images[i].vbmeta_size, &num_descriptors),
	&num_descriptors),
	avb_free);		avb_free);

	if (!descriptors \|\| num_descriptors < 1) {		if (!descriptors \|\| num_descriptors < 1) {
	@@ -428,12 +392,9 @@ static bool get_hashtree_descriptor(const std::string &partition_name,

	// Ensures that hashtree descriptor is either in /vbmeta or in		// Ensures that hashtree descriptor is either in /vbmeta or in
	// the same partition for verity setup.		// the same partition for verity setup.
	std::string vbmeta_partition_name(		std::string vbmeta_partition_name(verify_data.vbmeta_images[i].partition_name);
	verify_data.vbmeta_images[i].partition_name);		if (vbmeta_partition_name != "vbmeta" && vbmeta_partition_name != partition_name) {
	if (vbmeta_partition_name != "vbmeta" &&		LWARNING << "Skip vbmeta image at " << verify_data.vbmeta_images[i].partition_name
	vbmeta_partition_name != partition_name) {
	LWARNING << "Skip vbmeta image at "
	<< verify_data.vbmeta_images[i].partition_name
	<< " for partition: " << partition_name.c_str();		<< " for partition: " << partition_name.c_str();
	continue;		continue;
	}		}
	@@ -445,20 +406,17 @@ static bool get_hashtree_descriptor(const std::string &partition_name,
	continue;		continue;
	}		}
	if (desc.tag == AVB_DESCRIPTOR_TAG_HASHTREE) {		if (desc.tag == AVB_DESCRIPTOR_TAG_HASHTREE) {
	desc_partition_name = (const uint8_t *)descriptors[j] +		desc_partition_name =
	sizeof(AvbHashtreeDescriptor);		(const uint8_t*)descriptors[j] + sizeof(AvbHashtreeDescriptor);
	if (!avb_hashtree_descriptor_validate_and_byteswap(		if (!avb_hashtree_descriptor_validate_and_byteswap(
	(AvbHashtreeDescriptor *)descriptors[j],		(AvbHashtreeDescriptor*)descriptors[j], out_hashtree_desc)) {
	out_hashtree_desc)) {
	continue;		continue;
	}		}
	if (out_hashtree_desc->partition_name_len !=		if (out_hashtree_desc->partition_name_len != partition_name.length()) {
	partition_name.length()) {
	continue;		continue;
	}		}
	// Notes that desc_partition_name is not NUL-terminated.		// Notes that desc_partition_name is not NUL-terminated.
	std::string hashtree_partition_name(		std::string hashtree_partition_name((const char*)desc_partition_name,
	(const char *)desc_partition_name,
	out_hashtree_desc->partition_name_len);		out_hashtree_desc->partition_name_len);
	if (hashtree_partition_name == partition_name) {		if (hashtree_partition_name == partition_name) {
	found = true;		found = true;
	@@ -472,8 +430,7 @@ static bool get_hashtree_descriptor(const std::string &partition_name,
	return false;		return false;
	}		}

	const uint8_t *desc_salt =		const uint8_t* desc_salt = desc_partition_name + out_hashtree_desc->partition_name_len;
	desc_partition_name + out_hashtree_desc->partition_name_len;
	*out_salt = bytes_to_hex(desc_salt, out_hashtree_desc->salt_len);		*out_salt = bytes_to_hex(desc_salt, out_hashtree_desc->salt_len);

	const uint8_t* desc_digest = desc_salt + out_hashtree_desc->salt_len;		const uint8_t* desc_digest = desc_salt + out_hashtree_desc->salt_len;
	@@ -482,8 +439,7 @@ static bool get_hashtree_descriptor(const std::string &partition_name,
	return true;		return true;
	}		}

	static bool init_is_avb_used()		static bool init_is_avb_used() {
	{
	// When AVB is used, boot loader should set androidboot.vbmeta.{hash_alg,		// When AVB is used, boot loader should set androidboot.vbmeta.{hash_alg,
	// size, digest} in kernel cmdline. They will then be imported by init		// size, digest} in kernel cmdline. They will then be imported by init
	// process to system properties: ro.boot.vbmeta.{hash_alg, size, digest}.		// process to system properties: ro.boot.vbmeta.{hash_alg, size, digest}.
	@@ -493,8 +449,7 @@ static bool init_is_avb_used()
	// be done in fs_mgr_load_vbmeta_images() and FS_MGR_SETUP_AVB_FAIL will		// be done in fs_mgr_load_vbmeta_images() and FS_MGR_SETUP_AVB_FAIL will
	// be returned when there is an error.		// be returned when there is an error.

	std::string hash_alg =		std::string hash_alg = android::base::GetProperty("ro.boot.vbmeta.hash_alg", "");
	android::base::GetProperty("ro.boot.vbmeta.hash_alg", "");

	if (hash_alg == "sha256" \|\| hash_alg == "sha512") {		if (hash_alg == "sha256" \|\| hash_alg == "sha512") {
	return true;		return true;
	@@ -503,14 +458,12 @@ static bool init_is_avb_used()
	return false;		return false;
	}		}

	bool fs_mgr_is_avb_used()		bool fs_mgr_is_avb_used() {
	{
	static bool result = init_is_avb_used();		static bool result = init_is_avb_used();
	return result;		return result;
	}		}

	int fs_mgr_load_vbmeta_images(struct fstab *fstab)		int fs_mgr_load_vbmeta_images(struct fstab* fstab) {
	{
	FS_MGR_CHECK(fstab != nullptr);		FS_MGR_CHECK(fstab != nullptr);

	// Gets the expected hash value of vbmeta images from		// Gets the expected hash value of vbmeta images from
	@@ -530,10 +483,9 @@ int fs_mgr_load_vbmeta_images(struct fstab *fstab)
	// of HASH partitions into fs_mgr_avb_verify_data, which is not required as		// of HASH partitions into fs_mgr_avb_verify_data, which is not required as
	// fs_mgr only deals with HASHTREE partitions.		// fs_mgr only deals with HASHTREE partitions.
	const char* requested_partitions[] = {nullptr};		const char* requested_partitions[] = {nullptr};
	const char *ab_suffix =		const char* ab_suffix = android::base::GetProperty("ro.boot.slot_suffix", "").c_str();
	android::base::GetProperty("ro.boot.slot_suffix", "").c_str();		AvbSlotVerifyResult verify_result =
	AvbSlotVerifyResult verify_result = avb_slot_verify(		avb_slot_verify(fs_mgr_avb_ops, requested_partitions, ab_suffix,
	fs_mgr_avb_ops, requested_partitions, ab_suffix,
	fs_mgr_vbmeta_prop.allow_verification_error, &fs_mgr_avb_verify_data);		fs_mgr_vbmeta_prop.allow_verification_error, &fs_mgr_avb_verify_data);

	// Only allow two verify results:		// Only allow two verify results:
	@@ -557,12 +509,11 @@ int fs_mgr_load_vbmeta_images(struct fstab *fstab)
	// Checks whether FLAGS_HASHTREE_DISABLED is set.		// Checks whether FLAGS_HASHTREE_DISABLED is set.
	AvbVBMetaImageHeader vbmeta_header;		AvbVBMetaImageHeader vbmeta_header;
	avb_vbmeta_image_header_to_host_byte_order(		avb_vbmeta_image_header_to_host_byte_order(
	(AvbVBMetaImageHeader *)fs_mgr_avb_verify_data->vbmeta_images[0]		(AvbVBMetaImageHeader*)fs_mgr_avb_verify_data->vbmeta_images[0].vbmeta_data,
	.vbmeta_data,
	&vbmeta_header);		&vbmeta_header);

	bool hashtree_disabled = ((AvbVBMetaImageFlags)vbmeta_header.flags &		bool hashtree_disabled =
	AVB_VBMETA_IMAGE_FLAGS_HASHTREE_DISABLED);		((AvbVBMetaImageFlags)vbmeta_header.flags & AVB_VBMETA_IMAGE_FLAGS_HASHTREE_DISABLED);
	if (hashtree_disabled) {		if (hashtree_disabled) {
	return FS_MGR_SETUP_AVB_HASHTREE_DISABLED;		return FS_MGR_SETUP_AVB_HASHTREE_DISABLED;
	}		}
	@@ -577,8 +528,7 @@ fail:
	return FS_MGR_SETUP_AVB_FAIL;		return FS_MGR_SETUP_AVB_FAIL;
	}		}

	void fs_mgr_unload_vbmeta_images()		void fs_mgr_unload_vbmeta_images() {
	{
	if (fs_mgr_avb_verify_data != nullptr) {		if (fs_mgr_avb_verify_data != nullptr) {
	avb_slot_verify_data_free(fs_mgr_avb_verify_data);		avb_slot_verify_data_free(fs_mgr_avb_verify_data);
	}		}
	@@ -588,32 +538,27 @@ void fs_mgr_unload_vbmeta_images()
	}		}
	}		}

	int fs_mgr_setup_avb(struct fstab_rec *fstab_entry)		int fs_mgr_setup_avb(struct fstab_rec* fstab_entry) {
	{		if (!fstab_entry \|\| !fs_mgr_avb_verify_data \|\| fs_mgr_avb_verify_data->num_vbmeta_images < 1) {
	if (!fstab_entry \|\| !fs_mgr_avb_verify_data \|\|
	fs_mgr_avb_verify_data->num_vbmeta_images < 1) {
	return FS_MGR_SETUP_AVB_FAIL;		return FS_MGR_SETUP_AVB_FAIL;
	}		}

	std::string partition_name(basename(fstab_entry->mount_point));		std::string partition_name(basename(fstab_entry->mount_point));
	if (!avb_validate_utf8((const uint8_t *)partition_name.c_str(),		if (!avb_validate_utf8((const uint8_t*)partition_name.c_str(), partition_name.length())) {
	partition_name.length())) {		LERROR << "Partition name: " << partition_name.c_str() << " is not valid UTF-8.";
	LERROR << "Partition name: " << partition_name.c_str()
	<< " is not valid UTF-8.";
	return FS_MGR_SETUP_AVB_FAIL;		return FS_MGR_SETUP_AVB_FAIL;
	}		}

	AvbHashtreeDescriptor hashtree_descriptor;		AvbHashtreeDescriptor hashtree_descriptor;
	std::string salt;		std::string salt;
	std::string root_digest;		std::string root_digest;
	if (!get_hashtree_descriptor(partition_name, *fs_mgr_avb_verify_data,		if (!get_hashtree_descriptor(partition_name, *fs_mgr_avb_verify_data, &hashtree_descriptor,
	&hashtree_descriptor, &salt, &root_digest)) {		&salt, &root_digest)) {
	return FS_MGR_SETUP_AVB_FAIL;		return FS_MGR_SETUP_AVB_FAIL;
	}		}

	// Converts HASHTREE descriptor to verity_table_params.		// Converts HASHTREE descriptor to verity_table_params.
	if (!hashtree_dm_verity_setup(fstab_entry, hashtree_descriptor, salt,		if (!hashtree_dm_verity_setup(fstab_entry, hashtree_descriptor, salt, root_digest)) {
	root_digest)) {
	return FS_MGR_SETUP_AVB_FAIL;		return FS_MGR_SETUP_AVB_FAIL;
	}		}

fs_mgr/fs_mgr_avb_ops.cpp

+25 −46

Original line number	Original line	Diff line number	Diff line
	@@ -41,13 +41,9 @@

	static struct fstab* fs_mgr_fstab = nullptr;		static struct fstab* fs_mgr_fstab = nullptr;

	static AvbIOResult read_from_partition(AvbOps *ops ATTRIBUTE_UNUSED,		static AvbIOResult read_from_partition(AvbOps* ops ATTRIBUTE_UNUSED, const char* partition,
	const char *partition,		int64_t offset, size_t num_bytes, void* buffer,
	int64_t offset,		size_t* out_num_read) {
	size_t num_bytes,
	void *buffer,
	size_t *out_num_read)
	{
	// The input \|partition\| name is with ab_suffix, e.g. system_a.		// The input \|partition\| name is with ab_suffix, e.g. system_a.
	// Slot suffix (e.g. _a) will be appended to the device file path		// Slot suffix (e.g. _a) will be appended to the device file path
	// for partitions having 'slotselect' optin in fstab file, but it		// for partitions having 'slotselect' optin in fstab file, but it
	@@ -62,8 +58,7 @@ static AvbIOResult read_from_partition(AvbOps *ops ATTRIBUTE_UNUSED,
	// - /dev/block/platform/soc.0/7824900.sdhci/by-name/misc ->		// - /dev/block/platform/soc.0/7824900.sdhci/by-name/misc ->
	// - /dev/block/platform/soc.0/7824900.sdhci/by-name/system_a		// - /dev/block/platform/soc.0/7824900.sdhci/by-name/system_a

	struct fstab_rec *fstab_entry =		struct fstab_rec* fstab_entry = fs_mgr_get_entry_for_mount_point(fs_mgr_fstab, "/misc");
	fs_mgr_get_entry_for_mount_point(fs_mgr_fstab, "/misc");

	if (fstab_entry == nullptr) {		if (fstab_entry == nullptr) {
	LERROR << "/misc mount point not found in fstab";		LERROR << "/misc mount point not found in fstab";
	@@ -86,8 +81,7 @@ static AvbIOResult read_from_partition(AvbOps *ops ATTRIBUTE_UNUSED,
	return AVB_IO_RESULT_ERROR_IO;		return AVB_IO_RESULT_ERROR_IO;
	}		}

	android::base::unique_fd fd(		android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY \| O_CLOEXEC)));
	TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY \| O_CLOEXEC)));

	if (fd < 0) {		if (fd < 0) {
	PERROR << "Failed to open " << path.c_str();		PERROR << "Failed to open " << path.c_str();
	@@ -112,12 +106,11 @@ static AvbIOResult read_from_partition(AvbOps *ops ATTRIBUTE_UNUSED,

	// On Linux, we never get partial reads from block devices (except		// On Linux, we never get partial reads from block devices (except
	// for EOF).		// for EOF).
	ssize_t num_read =		ssize_t num_read = TEMP_FAILURE_RETRY(pread64(fd, buffer, num_bytes, offset));
	TEMP_FAILURE_RETRY(pread64(fd, buffer, num_bytes, offset));

	if (num_read < 0 \|\| (size_t)num_read != num_bytes) {		if (num_read < 0 \|\| (size_t)num_read != num_bytes) {
	PERROR << "Failed to read " << num_bytes << " bytes from "		PERROR << "Failed to read " << num_bytes << " bytes from " << path.c_str() << " offset "
	<< path.c_str() << " offset " << offset;		<< offset;
	return AVB_IO_RESULT_ERROR_IO;		return AVB_IO_RESULT_ERROR_IO;
	}		}

	@@ -129,10 +122,8 @@ static AvbIOResult read_from_partition(AvbOps *ops ATTRIBUTE_UNUSED,
	}		}

	static AvbIOResult dummy_read_rollback_index(AvbOps* ops ATTRIBUTE_UNUSED,		static AvbIOResult dummy_read_rollback_index(AvbOps* ops ATTRIBUTE_UNUSED,
	size_t rollback_index_location		size_t rollback_index_location ATTRIBUTE_UNUSED,
	ATTRIBUTE_UNUSED,		uint64_t* out_rollback_index) {
	uint64_t *out_rollback_index)
	{
	// rollback_index has been checked in bootloader phase.		// rollback_index has been checked in bootloader phase.
	// In user-space, returns the smallest value 0 to pass the check.		// In user-space, returns the smallest value 0 to pass the check.
	*out_rollback_index = 0;		*out_rollback_index = 0;
	@@ -140,13 +131,9 @@ static AvbIOResult dummy_read_rollback_index(AvbOps *ops ATTRIBUTE_UNUSED,
	}		}

	static AvbIOResult dummy_validate_vbmeta_public_key(		static AvbIOResult dummy_validate_vbmeta_public_key(
	AvbOps *ops ATTRIBUTE_UNUSED,		AvbOps* ops ATTRIBUTE_UNUSED, const uint8_t* public_key_data ATTRIBUTE_UNUSED,
	const uint8_t *public_key_data ATTRIBUTE_UNUSED,		size_t public_key_length ATTRIBUTE_UNUSED, const uint8_t* public_key_metadata ATTRIBUTE_UNUSED,
	size_t public_key_length ATTRIBUTE_UNUSED,		size_t public_key_metadata_length ATTRIBUTE_UNUSED, bool* out_is_trusted) {
	const uint8_t *public_key_metadata ATTRIBUTE_UNUSED,
	size_t public_key_metadata_length ATTRIBUTE_UNUSED,
	bool *out_is_trusted)
	{
	// vbmeta public key has been checked in bootloader phase.		// vbmeta public key has been checked in bootloader phase.
	// In user-space, returns true to pass the check.		// In user-space, returns true to pass the check.
	//		//
	@@ -159,8 +146,7 @@ static AvbIOResult dummy_validate_vbmeta_public_key(
	}		}

	static AvbIOResult dummy_read_is_device_unlocked(AvbOps* ops ATTRIBUTE_UNUSED,		static AvbIOResult dummy_read_is_device_unlocked(AvbOps* ops ATTRIBUTE_UNUSED,
	bool *out_is_unlocked)		bool* out_is_unlocked) {
	{
	// The function is for bootloader to update the value into		// The function is for bootloader to update the value into
	// androidboot.vbmeta.device_state in kernel cmdline.		// androidboot.vbmeta.device_state in kernel cmdline.
	// In user-space, returns true as we don't need to update it anymore.		// In user-space, returns true as we don't need to update it anymore.
	@@ -168,12 +154,9 @@ static AvbIOResult dummy_read_is_device_unlocked(AvbOps *ops ATTRIBUTE_UNUSED,
	return AVB_IO_RESULT_OK;		return AVB_IO_RESULT_OK;
	}		}

	static AvbIOResult dummy_get_unique_guid_for_partition(		static AvbIOResult dummy_get_unique_guid_for_partition(AvbOps* ops ATTRIBUTE_UNUSED,
	AvbOps *ops ATTRIBUTE_UNUSED,
	const char* partition ATTRIBUTE_UNUSED,		const char* partition ATTRIBUTE_UNUSED,
	char *guid_buf,		char* guid_buf, size_t guid_buf_size) {
	size_t guid_buf_size)
	{
	// The function is for bootloader to set the correct UUID		// The function is for bootloader to set the correct UUID
	// for a given partition in kernel cmdline.		// for a given partition in kernel cmdline.
	// In user-space, returns a faking one as we don't need to update		// In user-space, returns a faking one as we don't need to update
	@@ -182,8 +165,7 @@ static AvbIOResult dummy_get_unique_guid_for_partition(
	return AVB_IO_RESULT_OK;		return AVB_IO_RESULT_OK;
	}		}

	AvbOps fs_mgr_dummy_avb_ops_new(struct fstab fstab)		AvbOps* fs_mgr_dummy_avb_ops_new(struct fstab* fstab) {
	{
	AvbOps* ops;		AvbOps* ops;

	// Assigns the fstab to the static variable for later use.		// Assigns the fstab to the static variable for later use.
	@@ -207,7 +189,4 @@ AvbOps fs_mgr_dummy_avb_ops_new(struct fstab fstab)
	return ops;		return ops;
	}		}

	void fs_mgr_dummy_avb_ops_free(AvbOps *ops)		void fs_mgr_dummy_avb_ops_free(AvbOps* ops) { free(ops); }
	{
	free(ops);
	}

fs_mgr/fs_mgr_dm_ioctl.cpp

+6 −21

File changed.

Preview size limit exceeded, changes collapsed.

fs_mgr/fs_mgr_priv_dm_ioctl.h

+7 −17

Original line number	Original line	Diff line number	Diff line
	@@ -17,28 +17,18 @@
	#ifndef __CORE_FS_MGR_PRIV_DM_IOCTL_H		#ifndef __CORE_FS_MGR_PRIV_DM_IOCTL_H
	#define __CORE_FS_MGR_PRIV_DM_IOCTL_H		#define __CORE_FS_MGR_PRIV_DM_IOCTL_H

	#include <string>
	#include <linux/dm-ioctl.h>		#include <linux/dm-ioctl.h>
			#include <string>

	void fs_mgr_verity_ioctl_init(struct dm_ioctl *io,		void fs_mgr_verity_ioctl_init(struct dm_ioctl* io, const std::string& name, unsigned flags);
	const std::string &name,
	unsigned flags);

	bool fs_mgr_create_verity_device(struct dm_ioctl *io,		bool fs_mgr_create_verity_device(struct dm_ioctl* io, const std::string& name, int fd);
	const std::string &name,
	int fd);

	bool fs_mgr_destroy_verity_device(struct dm_ioctl *io,		bool fs_mgr_destroy_verity_device(struct dm_ioctl* io, const std::string& name, int fd);
	const std::string &name,
	int fd);

	bool fs_mgr_get_verity_device_name(struct dm_ioctl *io,		bool fs_mgr_get_verity_device_name(struct dm_ioctl* io, const std::string& name, int fd,
	const std::string &name,
	int fd,
	std::string* out_dev_name);		std::string* out_dev_name);

	bool fs_mgr_resume_verity_table(struct dm_ioctl *io,		bool fs_mgr_resume_verity_table(struct dm_ioctl* io, const std::string& name, int fd);
	const std::string &name,
	int fd);

	#endif /* __CORE_FS_MGR_PRIV_DM_IOCTL_H */		#endif /* __CORE_FS_MGR_PRIV_DM_IOCTL_H */