Merge "Remove old C fs_mgr interface" (7303edd1) · Commits · e / os / android_system_core

fs_mgr/fs_mgr.cpp

+3 −57

Original line number	Diff line number	Diff line
		@@ -378,7 +378,7 @@ static void tune_quota(const std::string& blk_device, const FstabEntry& entry,
		// Set the number of reserved filesystem blocks if needed.
		static void tune_reserved_size(const std::string& blk_device, const FstabEntry& entry,
		const struct ext4_super_block* sb, int* fs_stat) {
		if (!entry.fs_mgr_flags.reserved_size) {
		if (entry.reserved_size != 0) {
		return;
		}

		@@ -551,7 +551,7 @@ static int prepare_fs_for_mount(const std::string& blk_device, const FstabEntry&
		}

		if (is_extfs(entry.fs_type) &&
		(entry.fs_mgr_flags.reserved_size \|\| entry.fs_mgr_flags.file_encryption \|\|
		(entry.reserved_size != 0 \|\| entry.fs_mgr_flags.file_encryption \|\|
		entry.fs_mgr_flags.fs_verity)) {
		struct ext4_super_block sb;

		@@ -806,7 +806,7 @@ static bool needs_block_encryption(const FstabEntry& entry) {
		}

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

		@@ -1374,18 +1374,6 @@ static int fs_mgr_do_mount_helper(Fstab* fstab, const std::string& n_name,
		return FS_MGR_DOMNT_FAILED;
		}

		int fs_mgr_do_mount(fstab* fstab, const char* n_name, char* n_blk_device, char* tmp_mount_point) {
		auto new_fstab = LegacyFstabToFstab(fstab);
		return fs_mgr_do_mount_helper(&new_fstab, n_name, n_blk_device, tmp_mount_point, -1);
		}

		int fs_mgr_do_mount(fstab* fstab, const char* n_name, char* n_blk_device, char* tmp_mount_point,
		bool needs_checkpoint) {
		auto new_fstab = LegacyFstabToFstab(fstab);
		return fs_mgr_do_mount_helper(&new_fstab, n_name, n_blk_device, tmp_mount_point,
		needs_checkpoint);
		}

		int fs_mgr_do_mount(Fstab* fstab, const char* n_name, char* n_blk_device, char* tmp_mount_point) {
		return fs_mgr_do_mount_helper(fstab, n_name, n_blk_device, tmp_mount_point, -1);
		}
		@@ -1556,48 +1544,6 @@ bool fs_mgr_swapon_all(const Fstab& fstab) {
		return ret;
		}

		struct fstab_rec const* fs_mgr_get_crypt_entry(fstab const* fstab) {
		int i;

		if (!fstab) {
		return NULL;
		}

		/* Look for the encryptable partition to find the data */
		for (i = 0; i < fstab->num_entries; i++) {
		/* Don't deal with vold managed enryptable partitions here */
		if (!(fstab->recs[i].fs_mgr_flags & MF_VOLDMANAGED) &&
		(fstab->recs[i].fs_mgr_flags &
		(MF_CRYPT \| MF_FORCECRYPT \| MF_FORCEFDEORFBE \| MF_FILEENCRYPTION))) {
		return &fstab->recs[i];
		}
		}
		return NULL;
		}

		/*
		* key_loc must be at least PROPERTY_VALUE_MAX bytes long
		*
		* real_blk_device must be at least PROPERTY_VALUE_MAX bytes long
		*/
		void fs_mgr_get_crypt_info(fstab* fstab, char* key_loc, char* real_blk_device, size_t size) {
		struct fstab_rec const* rec = fs_mgr_get_crypt_entry(fstab);
		if (key_loc) {
		if (rec) {
		strlcpy(key_loc, rec->key_loc, size);
		} else {
		*key_loc = '\0';
		}
		}
		if (real_blk_device) {
		if (rec) {
		strlcpy(real_blk_device, rec->blk_device, size);
		} else {
		*real_blk_device = '\0';
		}
		}
		}

		bool fs_mgr_load_verity_state(int* mode) {
		/* return the default mode, unless any of the verified partitions are in
		* logging mode, in which case return that */

fs_mgr/fs_mgr_fstab.cpp

+0 −225

Original line number	Diff line number	Diff line
		@@ -175,7 +175,6 @@ void ParseMountFlags(const std::string& flags, FstabEntry* entry) {
		}

		void ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
		entry->fs_mgr_flags.val = 0U;
		for (const auto& flag : Split(flags, ",")) {
		std::string arg;
		if (auto equal_sign = flag.find('='); equal_sign != std::string::npos) {
		@@ -239,18 +238,14 @@ void ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
		}
		} else if (StartsWith(flag, "length=")) {
		// The length flag is followed by an = and the size of the partition.
		entry->fs_mgr_flags.length = true;
		if (!ParseInt(arg, &entry->length)) {
		LWARNING << "Warning: length= flag malformed: " << arg;
		}
		} else if (StartsWith(flag, "swapprio=")) {
		entry->fs_mgr_flags.swap_prio = true;
		if (!ParseInt(arg, &entry->swap_prio)) {
		LWARNING << "Warning: length= flag malformed: " << arg;
		}
		} else if (StartsWith(flag, "zramsize=")) {
		entry->fs_mgr_flags.zram_size = true;

		if (!arg.empty() && arg.back() == '%') {
		arg.pop_back();
		int val;
		@@ -282,13 +277,11 @@ void ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
		entry->file_contents_mode = "aes-256-xts";
		entry->file_names_mode = "aes-256-cts";
		} else if (StartsWith(flag, "max_comp_streams=")) {
		entry->fs_mgr_flags.max_comp_streams = true;
		if (!ParseInt(arg, &entry->max_comp_streams)) {
		LWARNING << "Warning: max_comp_streams= flag malformed: " << arg;
		}
		} else if (StartsWith(flag, "reservedsize=")) {
		// The reserved flag is followed by an = and the reserved size of the partition.
		entry->fs_mgr_flags.reserved_size = true;
		uint64_t size;
		if (!ParseByteCount(arg, &size)) {
		LWARNING << "Warning: reservedsize= flag malformed: " << arg;
		@@ -298,7 +291,6 @@ void ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
		} else if (StartsWith(flag, "eraseblk=")) {
		// The erase block size flag is followed by an = and the flash erase block size. Get it,
		// check that it is a power of 2 and at least 4096, and return it.
		entry->fs_mgr_flags.erase_blk_size = true;
		off64_t val;
		if (!ParseInt(arg, &val) \|\| val < 4096 \|\| (val & (val - 1)) != 0) {
		LWARNING << "Warning: eraseblk= flag malformed: " << arg;
		@@ -308,7 +300,6 @@ void ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
		} else if (StartsWith(flag, "logicalblk=")) {
		// The logical block size flag is followed by an = and the flash logical block size. Get
		// it, check that it is a power of 2 and at least 4096, and return it.
		entry->fs_mgr_flags.logical_blk_size = true;
		off64_t val;
		if (!ParseInt(arg, &val) \|\| val < 4096 \|\| (val & (val - 1)) != 0) {
		LWARNING << "Warning: logicalblk= flag malformed: " << arg;
		@@ -320,23 +311,18 @@ void ParseFsMgrFlags(const std::string& flags, FstabEntry* entry) {
		entry->vbmeta_partition = arg;
		} else if (StartsWith(flag, "keydirectory=")) {
		// The metadata flag is followed by an = and the directory for the keys.
		entry->fs_mgr_flags.key_directory = true;
		entry->key_dir = arg;
		} else if (StartsWith(flag, "sysfs_path=")) {
		// The path to trigger device gc by idle-maint of vold.
		entry->fs_mgr_flags.sysfs = true;
		entry->sysfs_path = arg;
		} else if (StartsWith(flag, "zram_loopback_path=")) {
		// The path to use loopback for zram.
		entry->fs_mgr_flags.zram_loopback_path = true;
		entry->zram_loopback_path = arg;
		} else if (StartsWith(flag, "zram_loopback_size=")) {
		entry->fs_mgr_flags.zram_loopback_size = true;
		if (!ParseByteCount(arg, &entry->zram_loopback_size)) {
		LWARNING << "Warning: zram_loopback_size= flag malformed: " << arg;
		}
		} else if (StartsWith(flag, "zram_backing_dev_path=")) {
		entry->fs_mgr_flags.zram_backing_dev_path = true;
		entry->zram_backing_dev_path = arg;
		} else if (StartsWith(flag, "avb_key=")) {
		entry->avb_key = arg;
		@@ -778,214 +764,3 @@ bool is_dt_compatible() {

		return false;
		}

		// Everything from here down is deprecated and will be removed shortly.

		using android::fs_mgr::Fstab;
		using android::fs_mgr::FstabEntry;
		using android::fs_mgr::ReadDefaultFstab;
		using android::fs_mgr::ReadFstabFromFile;

		struct fstab* fs_mgr_read_fstab(const char* fstab_path) {
		Fstab fstab;
		if (!ReadFstabFromFile(fstab_path, &fstab)) {
		return nullptr;
		}

		return FstabToLegacyFstab(fstab);
		}

		struct fstab* fs_mgr_read_fstab_default() {
		Fstab fstab;
		if (!ReadDefaultFstab(&fstab)) {
		return nullptr;
		}

		return FstabToLegacyFstab(fstab);
		}

		void fs_mgr_free_fstab(struct fstab *fstab)
		{
		int i;

		if (!fstab) {
		return;
		}

		for (i = 0; i < fstab->num_entries; i++) {
		/* Free the pointers return by strdup(3) */
		free(fstab->recs[i].blk_device);
		free(fstab->recs[i].logical_partition_name);
		free(fstab->recs[i].mount_point);
		free(fstab->recs[i].fs_type);
		free(fstab->recs[i].fs_options);
		free(fstab->recs[i].key_loc);
		free(fstab->recs[i].key_dir);
		free(fstab->recs[i].label);
		free(fstab->recs[i].file_contents_mode);
		free(fstab->recs[i].file_names_mode);
		free(fstab->recs[i].sysfs_path);
		free(fstab->recs[i].zram_loopback_path);
		free(fstab->recs[i].zram_backing_dev_path);
		}

		/* Free the fstab_recs array created by calloc(3) */
		free(fstab->recs);

		/* Free fstab */
		free(fstab);
		}

		struct fstab_rec* fs_mgr_get_entry_for_mount_point(struct fstab* fstab, const std::string& path) {
		if (!fstab) {
		return nullptr;
		}
		for (int i = 0; i < fstab->num_entries; i++) {
		if (fstab->recs[i].mount_point && path == fstab->recs[i].mount_point) {
		return &fstab->recs[i];
		}
		}
		return nullptr;
		}

		FstabEntry FstabRecToFstabEntry(const fstab_rec* fstab_rec) {
		FstabEntry entry;
		entry.blk_device = fstab_rec->blk_device;
		entry.logical_partition_name = fstab_rec->logical_partition_name;
		entry.mount_point = fstab_rec->mount_point;
		entry.fs_type = fstab_rec->fs_type;
		entry.flags = fstab_rec->flags;
		entry.fs_options = fstab_rec->fs_options;
		entry.fs_mgr_flags.val = fstab_rec->fs_mgr_flags;
		entry.key_loc = fstab_rec->key_loc;
		entry.key_dir = fstab_rec->key_dir;
		entry.verity_loc = fstab_rec->verity_loc;
		entry.length = fstab_rec->length;
		entry.label = fstab_rec->label;
		entry.partnum = fstab_rec->partnum;
		entry.swap_prio = fstab_rec->swap_prio;
		entry.max_comp_streams = fstab_rec->max_comp_streams;
		entry.zram_size = fstab_rec->zram_size;
		entry.reserved_size = fstab_rec->reserved_size;
		entry.file_contents_mode = fstab_rec->file_contents_mode;
		entry.file_names_mode = fstab_rec->file_names_mode;
		entry.erase_blk_size = fstab_rec->erase_blk_size;
		entry.logical_blk_size = fstab_rec->logical_blk_size;
		entry.sysfs_path = fstab_rec->sysfs_path;
		entry.zram_loopback_path = fstab_rec->zram_loopback_path;
		entry.zram_loopback_size = fstab_rec->zram_loopback_size;
		entry.zram_backing_dev_path = fstab_rec->zram_backing_dev_path;

		return entry;
		}

		Fstab LegacyFstabToFstab(const struct fstab* legacy_fstab) {
		Fstab fstab;
		for (int i = 0; i < legacy_fstab->num_entries; i++) {
		fstab.emplace_back(FstabRecToFstabEntry(&legacy_fstab->recs[i]));
		}

		return fstab;
		}

		fstab* FstabToLegacyFstab(const Fstab& fstab) {
		struct fstab* legacy_fstab = static_cast<struct fstab*>(calloc(1, sizeof(struct fstab)));
		legacy_fstab->num_entries = fstab.size();
		legacy_fstab->recs =
		static_cast<fstab_rec*>(calloc(legacy_fstab->num_entries, sizeof(fstab_rec)));

		for (int i = 0; i < legacy_fstab->num_entries; i++) {
		legacy_fstab->recs[i].blk_device = strdup(fstab[i].blk_device.c_str());
		legacy_fstab->recs[i].logical_partition_name =
		strdup(fstab[i].logical_partition_name.c_str());
		legacy_fstab->recs[i].mount_point = strdup(fstab[i].mount_point.c_str());
		legacy_fstab->recs[i].fs_type = strdup(fstab[i].fs_type.c_str());
		legacy_fstab->recs[i].flags = fstab[i].flags;
		legacy_fstab->recs[i].fs_options = strdup(fstab[i].fs_options.c_str());
		legacy_fstab->recs[i].fs_mgr_flags = fstab[i].fs_mgr_flags.val;
		legacy_fstab->recs[i].key_loc = strdup(fstab[i].key_loc.c_str());
		legacy_fstab->recs[i].key_dir = strdup(fstab[i].key_dir.c_str());
		legacy_fstab->recs[i].verity_loc = strdup(fstab[i].verity_loc.c_str());
		legacy_fstab->recs[i].length = fstab[i].length;
		legacy_fstab->recs[i].label = strdup(fstab[i].label.c_str());
		legacy_fstab->recs[i].partnum = fstab[i].partnum;
		legacy_fstab->recs[i].swap_prio = fstab[i].swap_prio;
		legacy_fstab->recs[i].max_comp_streams = fstab[i].max_comp_streams;
		legacy_fstab->recs[i].zram_size = fstab[i].zram_size;
		legacy_fstab->recs[i].reserved_size = fstab[i].reserved_size;
		legacy_fstab->recs[i].file_contents_mode = strdup(fstab[i].file_contents_mode.c_str());
		legacy_fstab->recs[i].file_names_mode = strdup(fstab[i].file_names_mode.c_str());
		legacy_fstab->recs[i].erase_blk_size = fstab[i].erase_blk_size;
		legacy_fstab->recs[i].logical_blk_size = fstab[i].logical_blk_size;
		legacy_fstab->recs[i].sysfs_path = strdup(fstab[i].sysfs_path.c_str());
		legacy_fstab->recs[i].zram_loopback_path = strdup(fstab[i].zram_loopback_path.c_str());
		legacy_fstab->recs[i].zram_loopback_size = fstab[i].zram_loopback_size;
		legacy_fstab->recs[i].zram_backing_dev_path = strdup(fstab[i].zram_backing_dev_path.c_str());
		}
		return legacy_fstab;
		}

		int fs_mgr_is_voldmanaged(const struct fstab_rec *fstab)
		{
		return fstab->fs_mgr_flags & MF_VOLDMANAGED;
		}

		int fs_mgr_is_nonremovable(const struct fstab_rec *fstab)
		{
		return fstab->fs_mgr_flags & MF_NONREMOVABLE;
		}

		int fs_mgr_is_verified(const struct fstab_rec *fstab)
		{
		return fstab->fs_mgr_flags & MF_VERIFY;
		}

		int fs_mgr_is_encryptable(const struct fstab_rec *fstab)
		{
		return fstab->fs_mgr_flags & (MF_CRYPT \| MF_FORCECRYPT \| MF_FORCEFDEORFBE);
		}

		void fs_mgr_get_file_encryption_modes(const struct fstab_rec* fstab, const char** contents_mode_ret,
		const char** filenames_mode_ret) {
		*contents_mode_ret = fstab->file_contents_mode;
		*filenames_mode_ret = fstab->file_names_mode;
		}

		int fs_mgr_is_convertible_to_fbe(const struct fstab_rec *fstab)
		{
		return fstab->fs_mgr_flags & MF_FORCEFDEORFBE;
		}

		int fs_mgr_is_noemulatedsd(const struct fstab_rec *fstab)
		{
		return fstab->fs_mgr_flags & MF_NOEMULATEDSD;
		}

		int fs_mgr_is_notrim(const struct fstab_rec* fstab) {
		return fstab->fs_mgr_flags & MF_NOTRIM;
		}

		int fs_mgr_is_quota(const struct fstab_rec* fstab) {
		return fstab->fs_mgr_flags & MF_QUOTA;
		}

		int fs_mgr_has_sysfs_path(const struct fstab_rec *fstab)
		{
		return fstab->fs_mgr_flags & MF_SYSFS;
		}

		int fs_mgr_is_logical(const struct fstab_rec* fstab) {
		return fstab->fs_mgr_flags & MF_LOGICAL;
		}

		int fs_mgr_is_checkpoint(const struct fstab_rec* fstab) {
		return fstab->fs_mgr_flags & (MF_CHECKPOINT_FS \| MF_CHECKPOINT_BLK);
		}

		int fs_mgr_is_checkpoint_fs(const struct fstab_rec* fstab) {
		return fstab->fs_mgr_flags & MF_CHECKPOINT_FS;
		}

		int fs_mgr_is_checkpoint_blk(const struct fstab_rec* fstab) {
		return fstab->fs_mgr_flags & MF_CHECKPOINT_BLK;
		}

fs_mgr/include/fs_mgr.h

+0 −5

Original line number	Diff line number	Diff line
		@@ -65,9 +65,6 @@ int fs_mgr_mount_all(android::fs_mgr::Fstab* fstab, int mount_mode);
		#define FS_MGR_DOMNT_FAILED (-1)
		#define FS_MGR_DOMNT_BUSY (-2)
		#define FS_MGR_DOMNT_SUCCESS 0
		int fs_mgr_do_mount(fstab* fstab, const char* n_name, char* n_blk_device, char* tmp_mount_point);
		int fs_mgr_do_mount(fstab* fstab, const char* n_name, char* n_blk_device, char* tmp_mount_point,
		bool needs_checkpoint);
		int fs_mgr_do_mount(android::fs_mgr::Fstab* fstab, const char* n_name, char* n_blk_device,
		char* tmp_mount_point);
		int fs_mgr_do_mount(android::fs_mgr::Fstab* fstab, const char* n_name, char* n_blk_device,
		@@ -75,8 +72,6 @@ int fs_mgr_do_mount(android::fs_mgr::Fstab* fstab, const char* n_name, char* n_b
		int fs_mgr_do_mount_one(const android::fs_mgr::FstabEntry& entry,
		const std::string& mount_point = "");
		int fs_mgr_do_tmpfs_mount(const char *n_name);
		fstab_rec const* fs_mgr_get_crypt_entry(fstab const* fstab);
		void fs_mgr_get_crypt_info(fstab* fstab, char* key_loc, char* real_blk_device, size_t size);
		bool fs_mgr_load_verity_state(int* mode);
		bool fs_mgr_update_verity_state(
		std::function<void(const std::string& mount_point, int mode)> callback);

fs_mgr/include_fstab/fstab/fstab.h

+30 −121

Original line number	Diff line number	Diff line
		@@ -16,75 +16,13 @@

		#pragma once

		#include <linux/dm-ioctl.h>
		#include <stdbool.h>
		#include <stdint.h>
		#include <stdio.h>
		#include <sys/types.h>

		#include <set>
		#include <string>
		#include <vector>

		/*
		* The entries must be kept in the same order as they were seen in the fstab.
		* Unless explicitly requested, a lookup on mount point should always
		* return the 1st one.
		*/
		struct fstab {
		int num_entries;
		struct fstab_rec* recs;
		};

		struct fstab_rec {
		char* blk_device;
		char* logical_partition_name;
		char* mount_point;
		char* fs_type;
		unsigned long flags;
		char* fs_options;
		uint64_t fs_mgr_flags;
		char* key_loc;
		char* key_dir;
		char* verity_loc;
		off64_t length;
		char* label;
		int partnum;
		int swap_prio;
		int max_comp_streams;
		off64_t zram_size;
		off64_t reserved_size;
		char* file_contents_mode;
		char* file_names_mode;
		off64_t erase_blk_size;
		off64_t logical_blk_size;
		char* sysfs_path;
		char* zram_loopback_path;
		uint64_t zram_loopback_size;
		char* zram_backing_dev_path;
		};

		struct fstab* fs_mgr_read_fstab_default();
		struct fstab* fs_mgr_read_fstab(const char* fstab_path);
		void fs_mgr_free_fstab(struct fstab* fstab);

		struct fstab_rec* fs_mgr_get_entry_for_mount_point(struct fstab* fstab, const std::string& path);
		int fs_mgr_is_voldmanaged(const struct fstab_rec* fstab);
		int fs_mgr_is_nonremovable(const struct fstab_rec* fstab);
		int fs_mgr_is_verified(const struct fstab_rec* fstab);
		int fs_mgr_is_encryptable(const struct fstab_rec* fstab);
		void fs_mgr_get_file_encryption_modes(const struct fstab_rec* fstab, const char** contents_mode_ret,
		const char** filenames_mode_ret);
		int fs_mgr_is_convertible_to_fbe(const struct fstab_rec* fstab);
		int fs_mgr_is_noemulatedsd(const struct fstab_rec* fstab);
		int fs_mgr_is_notrim(const struct fstab_rec* fstab);
		int fs_mgr_is_quota(const struct fstab_rec* fstab);
		int fs_mgr_is_logical(const struct fstab_rec* fstab);
		int fs_mgr_is_checkpoint(const struct fstab_rec* fstab);
		int fs_mgr_is_checkpoint_fs(const struct fstab_rec* fstab);
		int fs_mgr_is_checkpoint_blk(const struct fstab_rec* fstab);
		int fs_mgr_has_sysfs_path(const struct fstab_rec* fstab);

		std::string fs_mgr_get_slot_suffix();
		std::string fs_mgr_get_other_slot_suffix();

		@@ -119,23 +57,13 @@ struct FstabEntry {
		std::string zram_backing_dev_path;
		std::string avb_key;

		// TODO: Remove this union once fstab_rec is deprecated. It only serves as a
		// convenient way to convert between fstab_rec::fs_mgr_flags and these bools.
		union FsMgrFlags {
		uint64_t val;
		struct {
		// bit 0
		struct FsMgrFlags {
		bool wait : 1;
		bool check : 1;
		bool crypt : 1;
		bool nonremovable : 1;
		bool vold_managed : 1;
		bool length : 1;
		bool recovery_only : 1;
		bool swap_prio : 1;

		// bit 8
		bool zram_size : 1;
		bool verify : 1;
		bool force_crypt : 1;
		bool no_emulated_sd : 1; // No emulated sdcard daemon; sd card is the only external
		@@ -144,35 +72,19 @@ struct FstabEntry {
		bool file_encryption : 1;
		bool formattable : 1;
		bool slot_select : 1;

		// bit 16
		bool force_fde_or_fbe : 1;
		bool late_mount : 1;
		bool no_fail : 1;
		bool verify_at_boot : 1;
		bool max_comp_streams : 1;
		bool reserved_size : 1;
		bool quota : 1;
		bool erase_blk_size : 1;

		// bit 24
		bool logical_blk_size : 1;
		bool avb : 1;
		bool key_directory : 1;
		bool sysfs : 1;
		bool logical : 1;
		bool checkpoint_blk : 1;
		bool checkpoint_fs : 1;
		bool first_stage_mount : 1;

		// bit 32
		bool slot_select_other : 1;
		bool zram_loopback_path : 1;
		bool zram_loopback_size : 1;
		bool zram_backing_dev_path : 1;
		bool fs_verity : 1;
		};
		} fs_mgr_flags;
		} fs_mgr_flags = {};

		bool is_encryptable() const {
		return fs_mgr_flags.crypt \|\| fs_mgr_flags.force_crypt \|\| fs_mgr_flags.force_fde_or_fbe;
		@@ -180,6 +92,8 @@ struct FstabEntry {
		};

		// An Fstab is a collection of FstabEntry structs.
		// The entries must be kept in the same order as they were seen in the fstab.
		// Unless explicitly requested, a lookup on mount point should always return the 1st one.
		using Fstab = std::vector<FstabEntry>;

		bool ReadFstabFromFile(const std::string& path, Fstab* fstab);
		@@ -195,8 +109,3 @@ std::set<std::string> GetBootDevices();

		} // namespace fs_mgr
		} // namespace android

		// Temporary conversion functions.
		android::fs_mgr::FstabEntry FstabRecToFstabEntry(const fstab_rec* fstab_rec);
		android::fs_mgr::Fstab LegacyFstabToFstab(const struct fstab* legacy_fstab);
		fstab* FstabToLegacyFstab(const android::fs_mgr::Fstab& fstab);

fs_mgr/tests/fs_mgr_test.cpp

+110 −101

File changed.

Preview size limit exceeded, changes collapsed.