Snap for 4796401 from 93d48fe0b6e891d785caefdc02065da58e749c69 to pi-release (f2ca6c24) · Commits · e / os / android_system_core

CleanSpec.mk

+3 −0

Original line number	Diff line number	Diff line
		@@ -74,3 +74,6 @@ $(call add-clean-step, rm -rf $(PRODUCT_OUT)/root/root)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/etc/ld.config.txt)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/etc/llndk.libraries.txt)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/etc/vndksp.libraries.txt)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/etc/ld.config.txt)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/etc/llndk.libraries.txt)
		$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/etc/vndksp.libraries.txt)

fs_mgr/fs_mgr_fstab.cpp

+60 −0

Original line number	Diff line number	Diff line
		@@ -679,6 +679,49 @@ static struct fstab in_place_merge(struct fstab a, struct fstab *b)
		return a;
		}

		/* Extracts <device>s from the by-name symlinks specified in a fstab:
		* /dev/block/<type>/<device>/by-name/<partition>
		*
		* <type> can be: platform, pci or vbd.
		*
		* For example, given the following entries in the input fstab:
		* /dev/block/platform/soc/1da4000.ufshc/by-name/system
		* /dev/block/pci/soc.0/f9824900.sdhci/by-name/vendor
		* it returns a set { "soc/1da4000.ufshc", "soc.0/f9824900.sdhci" }.
		*/
		static std::set<std::string> extract_boot_devices(const fstab& fstab) {
		std::set<std::string> boot_devices;

		for (int i = 0; i < fstab.num_entries; i++) {
		std::string blk_device(fstab.recs[i].blk_device);
		// Skips blk_device that doesn't conform to the format.
		if (!android::base::StartsWith(blk_device, "/dev/block") \|\|
		android::base::StartsWith(blk_device, "/dev/block/by-name") \|\|
		android::base::StartsWith(blk_device, "/dev/block/bootdevice/by-name")) {
		continue;
		}
		// Skips non-by_name blk_device.
		// /dev/block/<type>/<device>/by-name/<partition>
		// ^ slash_by_name
		auto slash_by_name = blk_device.find("/by-name");
		if (slash_by_name == std::string::npos) continue;
		blk_device.erase(slash_by_name); // erases /by-name/<partition>

		// Erases /dev/block/, now we have <type>/<device>
		blk_device.erase(0, std::string("/dev/block/").size());

		// <type>/<device>
		// ^ first_slash
		auto first_slash = blk_device.find('/');
		if (first_slash == std::string::npos) continue;

		auto boot_device = blk_device.substr(first_slash + 1);
		if (!boot_device.empty()) boot_devices.insert(std::move(boot_device));
		}

		return boot_devices;
		}

		struct fstab fs_mgr_read_fstab(const char fstab_path)
		{
		FILE *fstab_file;
		@@ -855,6 +898,23 @@ struct fstab_rec* fs_mgr_get_entry_for_mount_point(struct fstab* fstab, const st
		return nullptr;
		}

		std::set<std::string> fs_mgr_get_boot_devices() {
		// boot_devices can be specified in device tree.
		std::string dt_value;
		std::string file_name = get_android_dt_dir() + "/boot_devices";
		if (read_dt_file(file_name, &dt_value)) {
		auto boot_devices = android::base::Split(dt_value, ",");
		return std::set<std::string>(boot_devices.begin(), boot_devices.end());
		}

		// Fallback to extract boot devices from fstab.
		std::unique_ptr<fstab, decltype(&fs_mgr_free_fstab)> fstab(fs_mgr_read_fstab_default(),
		fs_mgr_free_fstab);
		if (fstab) return extract_boot_devices(*fstab);

		return {};
		}

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

fs_mgr/include_fstab/fstab/fstab.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -22,6 +22,7 @@
		#include <stdint.h>
		#include <stdio.h>

		#include <set>
		#include <string>

		/*
		@@ -87,5 +88,6 @@ int fs_mgr_is_quota(const struct fstab_rec* fstab);
		int fs_mgr_has_sysfs_path(const struct fstab_rec* fstab);

		std::string fs_mgr_get_slot_suffix();
		std::set<std::string> fs_mgr_get_boot_devices();

		#endif /* __CORE_FS_TAB_H */

init/devices.cpp

+16 −8

Original line number	Diff line number	Diff line
		@@ -329,10 +329,10 @@ std::vector<std::string> DeviceHandler::GetBlockDeviceSymlinks(const Uevent& uev
		<< partition_name_sanitized << "'";
		}
		links.emplace_back(link_path + "/by-name/" + partition_name_sanitized);
		// Adds symlink: /dev/block/by-name/<partition_name>.
		if (boot_devices_.find(device) != boot_devices_.end()) {
		links.emplace_back("/dev/block/by-name/" + partition_name_sanitized);
		}

		if (uevent.partition_num >= 0) {
		links.emplace_back(link_path + "/by-num/p" + std::to_string(uevent.partition_num));
		}

		auto last_slash = uevent.path.rfind('/');
		@@ -350,8 +350,14 @@ void DeviceHandler::HandleDevice(const std::string& action, const std::string& d
		PLOG(ERROR) << "Failed to create directory " << Dirname(link);
		}

		if (symlink(devpath.c_str(), link.c_str()) && errno != EEXIST) {
		if (symlink(devpath.c_str(), link.c_str())) {
		if (errno != EEXIST) {
		PLOG(ERROR) << "Failed to symlink " << devpath << " to " << link;
		} else if (std::string link_path;
		Readlink(link, &link_path) && link_path != devpath) {
		PLOG(ERROR) << "Failed to symlink " << devpath << " to " << link
		<< ", which already links to: " << link_path;
		}
		}
		}
		}
		@@ -415,16 +421,18 @@ void DeviceHandler::HandleDeviceEvent(const Uevent& uevent) {

		DeviceHandler::DeviceHandler(std::vector<Permissions> dev_permissions,
		std::vector<SysfsPermissions> sysfs_permissions,
		std::vector<Subsystem> subsystems, bool skip_restorecon)
		std::vector<Subsystem> subsystems, std::set<std::string> boot_devices,
		bool skip_restorecon)
		: dev_permissions_(std::move(dev_permissions)),
		sysfs_permissions_(std::move(sysfs_permissions)),
		subsystems_(std::move(subsystems)),
		boot_devices_(std::move(boot_devices)),
		skip_restorecon_(skip_restorecon),
		sysfs_mount_point_("/sys") {}

		DeviceHandler::DeviceHandler()
		: DeviceHandler(std::vector<Permissions>{}, std::vector<SysfsPermissions>{},
		std::vector<Subsystem>{}, false) {}
		std::vector<Subsystem>{}, std::set<std::string>{}, false) {}

		} // namespace init
		} // namespace android

init/devices.h

+4 −2

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@
		#include <sys/types.h>

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

		@@ -103,8 +104,8 @@ class DeviceHandler {

		DeviceHandler();
		DeviceHandler(std::vector<Permissions> dev_permissions,
		std::vector<SysfsPermissions> sysfs_permissions,
		std::vector<Subsystem> subsystems, bool skip_restorecon);
		std::vector<SysfsPermissions> sysfs_permissions, std::vector<Subsystem> subsystems,
		std::set<std::string> boot_devices, bool skip_restorecon);
		~DeviceHandler(){};

		void HandleDeviceEvent(const Uevent& uevent);
		@@ -125,6 +126,7 @@ class DeviceHandler {
		std::vector<Permissions> dev_permissions_;
		std::vector<SysfsPermissions> sysfs_permissions_;
		std::vector<Subsystem> subsystems_;
		std::set<std::string> boot_devices_;
		bool skip_restorecon_;
		std::string sysfs_mount_point_;
		};