Merge "Fix-up coding style" am: 4a534ebc91 am: cfcaca92d1 (2d59ed1c) · Commits · e / os / android_system_core

fs_mgr/.clang-format

0 → 120000

+1 −0

Original line number	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	Diff line number	Diff line
		@@ -52,12 +52,10 @@
		"%" PRIu64 " %" PRIu64 " %s %s %s "

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

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

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

		/* 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
		@@ -85,10 +81,8 @@
		*/
		#define VERITY_TABLE_OPT_FEC_PARAMS(hashtree_desc, blk_device) \
		blk_device, hashtree_desc.fec_num_roots, \
		hashtree_desc.fec_offset / \
		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_blocks */ \
		hashtree_desc.fec_offset / hashtree_desc.data_block_size, /* fec_start */ \
		VERITY_TABLE_OPT_IGNZERO, VERITY_TABLE_OPT_RESTART

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

		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);

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

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

		if (hex.size() % 2 != 0) {
		@@ -156,8 +146,7 @@ static bool hex_to_bytes(uint8_t *bytes,
		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);

		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;
		}

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

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

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

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

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

		template <typename Hasher>
		static std::pair<size_t, bool> verify_vbmeta_digest(
		const AvbSlotVerifyData &verify_data, const androidboot_vbmeta &vbmeta_prop)
		{
		static std::pair<size_t, bool> verify_vbmeta_digest(const AvbSlotVerifyData& verify_data,
		const androidboot_vbmeta& vbmeta_prop) {
		size_t total_size = 0;
		Hasher hasher;
		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;
		}

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

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

		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) {
		LERROR << "No vbmeta images";
		return false;
		@@ -281,23 +262,17 @@ static bool verify_vbmeta_images(const AvbSlotVerifyData &verify_data,
		return true;
		}

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

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

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

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

		int res = 0;
		if (hashtree_desc.fec_size > 0) {
		res = snprintf(
		verity_params, bufsize,
		VERITY_TABLE_FORMAT VERITY_TABLE_OPT_FEC_FORMAT,
		VERITY_TABLE_PARAMS(hashtree_desc, blk_device.c_str(),
		root_digest.c_str(), salt.c_str()),
		res = snprintf(verity_params, bufsize, VERITY_TABLE_FORMAT VERITY_TABLE_OPT_FEC_FORMAT,
		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()));
		} else {
		res = snprintf(verity_params, bufsize,
		VERITY_TABLE_FORMAT VERITY_TABLE_OPT_DEFAULT_FORMAT,
		VERITY_TABLE_PARAMS(hashtree_desc, blk_device.c_str(),
		root_digest.c_str(), salt.c_str()),
		res = snprintf(verity_params, bufsize, VERITY_TABLE_FORMAT VERITY_TABLE_OPT_DEFAULT_FORMAT,
		VERITY_TABLE_PARAMS(hashtree_desc, blk_device.c_str(), root_digest.c_str(),
		salt.c_str()),
		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,
		const AvbHashtreeDescriptor& hashtree_desc,
		const std::string &salt,
		const std::string &root_digest)
		{
		const std::string& salt, const std::string& root_digest) {
		// Gets the device mapper fd.
		android::base::unique_fd fd(open("/dev/device-mapper", O_RDWR));
		if (fd < 0) {
		@@ -375,8 +344,7 @@ static bool hashtree_dm_verity_setup(struct fstab_rec *fstab_entry,
		}

		// Loads the verity mapping table.
		if (!hashtree_load_verity_table(io, mount_point, fd,
		std::string(fstab_entry->blk_device),
		if (!hashtree_load_verity_table(io, mount_point, fd, std::string(fstab_entry->blk_device),
		hashtree_desc, salt, root_digest)) {
		LERROR << "Couldn't load verity table!";
		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,
		const AvbSlotVerifyData& verify_data,
		AvbHashtreeDescriptor *out_hashtree_desc,
		std::string *out_salt,
		std::string *out_digest)
		{
		AvbHashtreeDescriptor* out_hashtree_desc, std::string* out_salt,
		std::string* out_digest) {
		bool found = false;
		const uint8_t* desc_partition_name;

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

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

		const uint8_t *desc_salt =
		desc_partition_name + out_hashtree_desc->partition_name_len;
		const uint8_t* desc_salt = desc_partition_name + out_hashtree_desc->partition_name_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;
		@@ -482,8 +439,7 @@ static bool get_hashtree_descriptor(const std::string &partition_name,
		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,
		// size, digest} in kernel cmdline. They will then be imported by init
		// 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 returned when there is an error.

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

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

		bool fs_mgr_is_avb_used()
		{
		bool fs_mgr_is_avb_used() {
		static bool result = init_is_avb_used();
		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);

		// 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
		// fs_mgr only deals with HASHTREE partitions.
		const char* requested_partitions[] = {nullptr};
		const char *ab_suffix =
		android::base::GetProperty("ro.boot.slot_suffix", "").c_str();
		AvbSlotVerifyResult verify_result = avb_slot_verify(
		fs_mgr_avb_ops, requested_partitions, ab_suffix,
		const char* ab_suffix = android::base::GetProperty("ro.boot.slot_suffix", "").c_str();
		AvbSlotVerifyResult verify_result =
		avb_slot_verify(fs_mgr_avb_ops, requested_partitions, ab_suffix,
		fs_mgr_vbmeta_prop.allow_verification_error, &fs_mgr_avb_verify_data);

		// 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.
		AvbVBMetaImageHeader vbmeta_header;
		avb_vbmeta_image_header_to_host_byte_order(
		(AvbVBMetaImageHeader *)fs_mgr_avb_verify_data->vbmeta_images[0]
		.vbmeta_data,
		(AvbVBMetaImageHeader*)fs_mgr_avb_verify_data->vbmeta_images[0].vbmeta_data,
		&vbmeta_header);

		bool hashtree_disabled = ((AvbVBMetaImageFlags)vbmeta_header.flags &
		AVB_VBMETA_IMAGE_FLAGS_HASHTREE_DISABLED);
		bool hashtree_disabled =
		((AvbVBMetaImageFlags)vbmeta_header.flags & AVB_VBMETA_IMAGE_FLAGS_HASHTREE_DISABLED);
		if (hashtree_disabled) {
		return FS_MGR_SETUP_AVB_HASHTREE_DISABLED;
		}
		@@ -577,8 +528,7 @@ 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) {
		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)
		{
		if (!fstab_entry \|\| !fs_mgr_avb_verify_data \|\|
		fs_mgr_avb_verify_data->num_vbmeta_images < 1) {
		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) {
		return FS_MGR_SETUP_AVB_FAIL;
		}

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

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

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

fs_mgr/fs_mgr_avb_ops.cpp

+25 −46

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

		static struct fstab* fs_mgr_fstab = nullptr;

		static AvbIOResult read_from_partition(AvbOps *ops ATTRIBUTE_UNUSED,
		const char *partition,
		int64_t offset,
		size_t num_bytes,
		void *buffer,
		size_t *out_num_read)
		{
		static AvbIOResult read_from_partition(AvbOps* ops ATTRIBUTE_UNUSED, const char* partition,
		int64_t offset, size_t num_bytes, void* buffer,
		size_t* out_num_read) {
		// 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
		// 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/system_a

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

		if (fstab_entry == nullptr) {
		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;
		}

		android::base::unique_fd fd(
		TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY \| O_CLOEXEC)));
		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();
		@@ -112,12 +106,11 @@ static AvbIOResult read_from_partition(AvbOps *ops ATTRIBUTE_UNUSED,

		// On Linux, we never get partial reads from block devices (except
		// for EOF).
		ssize_t num_read =
		TEMP_FAILURE_RETRY(pread64(fd, buffer, num_bytes, offset));
		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.c_str() << " offset "
		<< offset;
		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,
		size_t rollback_index_location
		ATTRIBUTE_UNUSED,
		uint64_t *out_rollback_index)
		{
		size_t rollback_index_location ATTRIBUTE_UNUSED,
		uint64_t* out_rollback_index) {
		// rollback_index has been checked in bootloader phase.
		// In user-space, returns the smallest value 0 to pass the check.
		*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(
		AvbOps *ops 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_metadata_length ATTRIBUTE_UNUSED,
		bool *out_is_trusted)
		{
		AvbOps* ops 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_metadata_length ATTRIBUTE_UNUSED, bool* out_is_trusted) {
		// vbmeta public key has been checked in bootloader phase.
		// 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,
		bool *out_is_unlocked)
		{
		bool* out_is_unlocked) {
		// The function is for bootloader to update the value into
		// androidboot.vbmeta.device_state in kernel cmdline.
		// 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;
		}

		static AvbIOResult dummy_get_unique_guid_for_partition(
		AvbOps *ops ATTRIBUTE_UNUSED,
		static AvbIOResult dummy_get_unique_guid_for_partition(AvbOps* ops ATTRIBUTE_UNUSED,
		const char* partition ATTRIBUTE_UNUSED,
		char *guid_buf,
		size_t guid_buf_size)
		{
		char* guid_buf, size_t guid_buf_size) {
		// The function is for bootloader to set the correct UUID
		// for a given partition in kernel cmdline.
		// 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;
		}

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

		// 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;
		}

		void fs_mgr_dummy_avb_ops_free(AvbOps *ops)
		{
		free(ops);
		}
		void fs_mgr_dummy_avb_ops_free(AvbOps* 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	Diff line number	Diff line
		@@ -17,28 +17,18 @@
		#ifndef __CORE_FS_MGR_PRIV_DM_IOCTL_H
		#define __CORE_FS_MGR_PRIV_DM_IOCTL_H

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

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

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

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

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

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

		#endif /* __CORE_FS_MGR_PRIV_DM_IOCTL_H */