Merge "fastbootd: Refactor for getvar all." (13d6d75d) · Commits · e / os / android_system_core

fastboot/device/commands.cpp

+8 −3

Original line number	Diff line number	Diff line
		@@ -43,7 +43,8 @@ using ::android::hardware::boot::V1_0::Slot;
		using namespace android::fs_mgr;

		bool GetVarHandler(FastbootDevice* device, const std::vector<std::string>& args) {
		using VariableHandler = std::function<bool(FastbootDevice*, const std::vector<std::string>&)>;
		using VariableHandler =
		std::function<bool(FastbootDevice, const std::vector<std::string>&, std::string)>;
		const std::unordered_map<std::string, VariableHandler> kVariableMap = {
		{FB_VAR_VERSION, GetVersion},
		{FB_VAR_VERSION_BOOTLOADER, GetBootloaderVersion},
		@@ -65,11 +66,15 @@ bool GetVarHandler(FastbootDevice* device, const std::vector<std::string>& args)
		// args[0] is command name, args[1] is variable.
		auto found_variable = kVariableMap.find(args[1]);
		if (found_variable == kVariableMap.end()) {
		return device->WriteStatus(FastbootResult::FAIL, "Unknown variable");
		return device->WriteFail("Unknown variable");
		}

		std::string message;
		std::vector<std::string> getvar_args(args.begin() + 2, args.end());
		return found_variable->second(device, getvar_args);
		if (!found_variable->second(device, getvar_args, &message)) {
		return device->WriteFail(message);
		}
		return device->WriteOkay(message);
		}

		bool EraseHandler(FastbootDevice* device, const std::vector<std::string>& args) {

fastboot/device/variables.cpp

+100 −51

Original line number	Diff line number	Diff line
		@@ -35,141 +35,190 @@ using ::android::hardware::boot::V1_0::Slot;
		constexpr int kMaxDownloadSizeDefault = 0x20000000;
		constexpr char kFastbootProtocolVersion[] = "0.4";

		bool GetVersion(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		return device->WriteOkay(kFastbootProtocolVersion);
		bool GetVersion(FastbootDevice* /* device /, const std::vector<std::string>& / args */,
		std::string* message) {
		*message = kFastbootProtocolVersion;
		return true;
		}

		bool GetBootloaderVersion(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		return device->WriteOkay(android::base::GetProperty("ro.bootloader", ""));
		bool GetBootloaderVersion(FastbootDevice* /* device /, const std::vector<std::string>& / args */,
		std::string* message) {
		*message = android::base::GetProperty("ro.bootloader", "");
		return true;
		}

		bool GetBasebandVersion(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		return device->WriteOkay(android::base::GetProperty("ro.build.expect.baseband", ""));
		bool GetBasebandVersion(FastbootDevice* /* device /, const std::vector<std::string>& / args */,
		std::string* message) {
		*message = android::base::GetProperty("ro.build.expect.baseband", "");
		return true;
		}

		bool GetProduct(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		return device->WriteOkay(android::base::GetProperty("ro.product.device", ""));
		bool GetProduct(FastbootDevice* /* device /, const std::vector<std::string>& / args */,
		std::string* message) {
		*message = android::base::GetProperty("ro.product.device", "");
		return true;
		}

		bool GetSerial(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		return device->WriteOkay(android::base::GetProperty("ro.serialno", ""));
		bool GetSerial(FastbootDevice* /* device /, const std::vector<std::string>& / args */,
		std::string* message) {
		*message = android::base::GetProperty("ro.serialno", "");
		return true;
		}

		bool GetSecure(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		return device->WriteOkay(android::base::GetBoolProperty("ro.secure", "") ? "yes" : "no");
		bool GetSecure(FastbootDevice* /* device /, const std::vector<std::string>& / args */,
		std::string* message) {
		*message = android::base::GetBoolProperty("ro.secure", "") ? "yes" : "no";
		return true;
		}

		bool GetCurrentSlot(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		bool GetCurrentSlot(FastbootDevice* device, const std::vector<std::string>& /* args */,
		std::string* message) {
		std::string suffix = device->GetCurrentSlot();
		std::string slot = suffix.size() == 2 ? suffix.substr(1) : suffix;
		return device->WriteOkay(slot);
		*message = suffix.size() == 2 ? suffix.substr(1) : suffix;
		return true;
		}

		bool GetSlotCount(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		bool GetSlotCount(FastbootDevice* device, const std::vector<std::string>& /* args */,
		std::string* message) {
		auto boot_control_hal = device->boot_control_hal();
		if (!boot_control_hal) {
		return "0";
		*message = "0";
		} else {
		*message = std::to_string(boot_control_hal->getNumberSlots());
		}
		return device->WriteOkay(std::to_string(boot_control_hal->getNumberSlots()));
		return true;
		}

		bool GetSlotSuccessful(FastbootDevice* device, const std::vector<std::string>& args) {
		bool GetSlotSuccessful(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message) {
		if (args.empty()) {
		return device->WriteFail("Missing argument");
		*message = "Missing argument";
		return false;
		}
		Slot slot;
		if (!GetSlotNumber(args[0], &slot)) {
		return device->WriteFail("Invalid slot");
		*message = "Invalid slot";
		return false;
		}
		auto boot_control_hal = device->boot_control_hal();
		if (!boot_control_hal) {
		return device->WriteFail("Device has no slots");
		*message = "Device has no slots";
		return false;
		}
		if (boot_control_hal->isSlotMarkedSuccessful(slot) != BoolResult::TRUE) {
		return device->WriteOkay("no");
		*message = "no";
		} else {
		*message = "yes";
		}
		return device->WriteOkay("yes");
		return true;
		}

		bool GetSlotUnbootable(FastbootDevice* device, const std::vector<std::string>& args) {
		bool GetSlotUnbootable(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message) {
		if (args.empty()) {
		return device->WriteFail("Missing argument");
		*message = "Missing argument";
		return false;
		}
		Slot slot;
		if (!GetSlotNumber(args[0], &slot)) {
		return device->WriteFail("Invalid slot");
		*message = "Invalid slot";
		return false;
		}
		auto boot_control_hal = device->boot_control_hal();
		if (!boot_control_hal) {
		return device->WriteFail("Device has no slots");
		*message = "Device has no slots";
		return false;
		}
		if (boot_control_hal->isSlotBootable(slot) != BoolResult::TRUE) {
		return device->WriteOkay("yes");
		*message = "yes";
		} else {
		*message = "no";
		}
		return device->WriteOkay("no");
		return true;
		}

		bool GetMaxDownloadSize(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		return device->WriteOkay(std::to_string(kMaxDownloadSizeDefault));
		bool GetMaxDownloadSize(FastbootDevice* /* device /, const std::vector<std::string>& / args */,
		std::string* message) {
		*message = std::to_string(kMaxDownloadSizeDefault);
		return true;
		}

		bool GetUnlocked(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		return device->WriteOkay("yes");
		bool GetUnlocked(FastbootDevice* /* device /, const std::vector<std::string>& / args */,
		std::string* message) {
		*message = "yes";
		return true;
		}

		bool GetHasSlot(FastbootDevice* device, const std::vector<std::string>& args) {
		bool GetHasSlot(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message) {
		if (args.empty()) {
		return device->WriteFail("Missing argument");
		*message = "Missing argument";
		return false;
		}
		std::string slot_suffix = device->GetCurrentSlot();
		if (slot_suffix.empty()) {
		return device->WriteOkay("no");
		*message = "no";
		return true;
		}
		std::string partition_name = args[0] + slot_suffix;
		if (FindPhysicalPartition(partition_name) \|\|
		LogicalPartitionExists(partition_name, slot_suffix)) {
		return device->WriteOkay("yes");
		*message = "yes";
		} else {
		*message = "no";
		}
		return device->WriteOkay("no");
		return true;
		}

		bool GetPartitionSize(FastbootDevice* device, const std::vector<std::string>& args) {
		bool GetPartitionSize(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message) {
		if (args.size() < 1) {
		return device->WriteFail("Missing argument");
		*message = "Missing argument";
		return false;
		}
		// Zero-length partitions cannot be created through device-mapper, so we
		// special case them here.
		bool is_zero_length;
		if (LogicalPartitionExists(args[0], device->GetCurrentSlot(), &is_zero_length) &&
		is_zero_length) {
		return device->WriteOkay("0");
		*message = "0";
		return true;
		}
		// Otherwise, open the partition as normal.
		PartitionHandle handle;
		if (!OpenPartition(device, args[0], &handle)) {
		return device->WriteFail("Could not open partition");
		*message = "Could not open partition";
		return false;
		}
		uint64_t size = get_block_device_size(handle.fd());
		return device->WriteOkay(android::base::StringPrintf("%" PRIX64, size));
		*message = android::base::StringPrintf("%" PRIX64, size);
		return true;
		}

		bool GetPartitionIsLogical(FastbootDevice* device, const std::vector<std::string>& args) {
		bool GetPartitionIsLogical(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message) {
		if (args.size() < 1) {
		return device->WriteFail("Missing argument");
		*message = "Missing argument";
		return false;
		}
		// Note: if a partition name is in both the GPT and the super partition, we
		// return "true", to be consistent with prefering to flash logical partitions
		// over physical ones.
		std::string partition_name = args[0];
		if (LogicalPartitionExists(partition_name, device->GetCurrentSlot())) {
		return device->WriteOkay("yes");
		*message = "yes";
		return true;
		}
		if (FindPhysicalPartition(partition_name)) {
		return device->WriteOkay("no");
		*message = "no";
		return true;
		}
		return device->WriteFail("Partition not found");
		*message = "Partition not found";
		return false;
		}

		bool GetIsUserspace(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		return device->WriteOkay("yes");
		bool GetIsUserspace(FastbootDevice* /* device /, const std::vector<std::string>& / args */,
		std::string* message) {
		*message = "yes";
		return true;
		}

fastboot/device/variables.h

+27 −16

Original line number	Diff line number	Diff line
		@@ -21,19 +21,30 @@

		class FastbootDevice;

		bool GetVersion(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetBootloaderVersion(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetBasebandVersion(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetProduct(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetSerial(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetSecure(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetCurrentSlot(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetSlotCount(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetSlotSuccessful(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetSlotUnbootable(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetMaxDownloadSize(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetUnlocked(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetHasSlot(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetPartitionSize(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetPartitionIsLogical(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetIsUserspace(FastbootDevice* device, const std::vector<std::string>& args);
		bool GetVersion(FastbootDevice* device, const std::vector<std::string>& args, std::string* message);
		bool GetBootloaderVersion(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message);
		bool GetBasebandVersion(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message);
		bool GetProduct(FastbootDevice* device, const std::vector<std::string>& args, std::string* message);
		bool GetSerial(FastbootDevice* device, const std::vector<std::string>& args, std::string* message);
		bool GetSecure(FastbootDevice* device, const std::vector<std::string>& args, std::string* message);
		bool GetCurrentSlot(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message);
		bool GetSlotCount(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message);
		bool GetSlotSuccessful(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message);
		bool GetSlotUnbootable(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message);
		bool GetMaxDownloadSize(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message);
		bool GetUnlocked(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message);
		bool GetHasSlot(FastbootDevice* device, const std::vector<std::string>& args, std::string* message);
		bool GetPartitionSize(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message);
		bool GetPartitionIsLogical(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message);
		bool GetIsUserspace(FastbootDevice* device, const std::vector<std::string>& args,
		std::string* message);