Merge "Added support for flash task" (6183722b) · Commits · e / os / android_system_core

fastboot/Android.bp

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -294,6 +294,7 @@ cc_library_host_static {
	"udp.cpp",		"udp.cpp",
	"util.cpp",		"util.cpp",
	"vendor_boot_img_utils.cpp",		"vendor_boot_img_utils.cpp",
			"task.cpp",
	],		],

	// Only version the final binaries		// Only version the final binaries

fastboot/fastboot.cpp

+14 −26

Original line number	Original line	Diff line number	Diff line
	@@ -44,8 +44,12 @@
	#include <unistd.h>		#include <unistd.h>

	#include <chrono>		#include <chrono>
			#include <fstream>
	#include <functional>		#include <functional>
			#include <iostream>
			#include <memory>
	#include <regex>		#include <regex>
			#include <sstream>
	#include <string>		#include <string>
	#include <thread>		#include <thread>
	#include <utility>		#include <utility>
	@@ -216,7 +220,7 @@ static std::string find_item_given_name(const std::string& img_name) {
	return std::string(dir) + "/" + img_name;		return std::string(dir) + "/" + img_name;
	}		}

	static std::string find_item(const std::string& item) {		std::string find_item(const std::string& item) {
	for (size_t i = 0; i < images.size(); ++i) {		for (size_t i = 0; i < images.size(); ++i) {
	if (!images[i].nickname.empty() && item == images[i].nickname) {		if (!images[i].nickname.empty() && item == images[i].nickname) {
	return find_item_given_name(images[i].img_name);		return find_item_given_name(images[i].img_name);
	@@ -546,8 +550,7 @@ static void list_devices() {
	usb_open(list_devices_callback);		usb_open(list_devices_callback);
	NetworkDeviceConnected(/* print */ true);		NetworkDeviceConnected(/* print */ true);
	}		}
			void syntax_error(const char* fmt, ...) {
	static void syntax_error(const char* fmt, ...) {
	fprintf(stderr, "fastboot: usage: ");		fprintf(stderr, "fastboot: usage: ");

	va_list ap;		va_list ap;
	@@ -1410,9 +1413,8 @@ static void do_for_partition(const std::string& part, const std::string& slot,
	* partition names. If force_slot is true, it will fail if a slot is specified, and the given		* partition names. If force_slot is true, it will fail if a slot is specified, and the given
	* partition does not support slots.		* partition does not support slots.
	*/		*/
	static void do_for_partitions(const std::string& part, const std::string& slot,		void do_for_partitions(const std::string& part, const std::string& slot,
	const std::function<void(const std::string&)>& func,		const std::function<void(const std::string&)>& func, bool force_slot) {
	bool force_slot) {
	std::string has_slot;		std::string has_slot;
	// \|part\| can be vendor_boot:default. Query has-slot on the first token only.		// \|part\| can be vendor_boot:default. Query has-slot on the first token only.
	auto part_tokens = android::base::Split(part, ":");		auto part_tokens = android::base::Split(part, ":");
	@@ -1508,7 +1510,7 @@ static std::string repack_ramdisk(const char* pname, struct fastboot_buffer* buf
	return partition;		return partition;
	}		}

	static void do_flash(const char* pname, const char* fname) {		void do_flash(const char* pname, const char* fname) {
	verbose("Do flash %s %s", pname, fname);		verbose("Do flash %s %s", pname, fname);
	struct fastboot_buffer buf;		struct fastboot_buffer buf;

	@@ -1537,12 +1539,12 @@ static void set_active(const std::string& slot_override) {
	}		}
	}		}

	static bool is_userspace_fastboot() {		bool is_userspace_fastboot() {
	std::string value;		std::string value;
	return fb->GetVar("is-userspace", &value) == fastboot::SUCCESS && value == "yes";		return fb->GetVar("is-userspace", &value) == fastboot::SUCCESS && value == "yes";
	}		}

	static void reboot_to_userspace_fastboot() {		void reboot_to_userspace_fastboot() {
	fb->RebootTo("fastboot");		fb->RebootTo("fastboot");

	auto* old_transport = fb->set_transport(nullptr);		auto* old_transport = fb->set_transport(nullptr);
	@@ -2029,7 +2031,7 @@ failed:
	}		}
	}		}

	static bool should_flash_in_userspace(const std::string& partition_name) {		bool should_flash_in_userspace(const std::string& partition_name) {
	if (!get_android_product_out()) {		if (!get_android_product_out()) {
	return false;		return false;
	}		}
	@@ -2416,7 +2418,6 @@ int FastBootTool::Main(int argc, char* argv[]) {
	fb->Boot();		fb->Boot();
	} else if (command == FB_CMD_FLASH) {		} else if (command == FB_CMD_FLASH) {
	std::string pname = next_arg(&args);		std::string pname = next_arg(&args);

	std::string fname;		std::string fname;
	if (!args.empty()) {		if (!args.empty()) {
	fname = next_arg(&args);		fname = next_arg(&args);
	@@ -2424,21 +2425,8 @@ int FastBootTool::Main(int argc, char* argv[]) {
	fname = find_item(pname);		fname = find_item(pname);
	}		}
	if (fname.empty()) die("cannot determine image filename for '%s'", pname.c_str());		if (fname.empty()) die("cannot determine image filename for '%s'", pname.c_str());
			FlashTask task(slot_override, force_flash, pname, fname);
	auto flash = [&](const std::string& partition) {		task.Run();
	if (should_flash_in_userspace(partition) && !is_userspace_fastboot() &&
	!force_flash) {
	die("The partition you are trying to flash is dynamic, and "
	"should be flashed via fastbootd. Please run:\n"
	"\n"
	" fastboot reboot fastboot\n"
	"\n"
	"And try again. If you are intentionally trying to "
	"overwrite a fixed partition, use --force.");
	}
	do_flash(partition.c_str(), fname.c_str());
	};
	do_for_partitions(pname, slot_override, flash, true);
	} else if (command == "flash:raw") {		} else if (command == "flash:raw") {
	std::string partition = next_arg(&args);		std::string partition = next_arg(&args);
	std::string kernel = next_arg(&args);		std::string kernel = next_arg(&args);

fastboot/fastboot.h

+11 −0

Original line number	Original line	Diff line number	Diff line
	@@ -27,6 +27,8 @@
	*/		*/
	#pragma once		#pragma once

			#include <string>

	#include <bootimg.h>		#include <bootimg.h>

	class FastBootTool {		class FastBootTool {
	@@ -37,3 +39,12 @@ class FastBootTool {
	void ParseOsVersion(boot_img_hdr_v1, const char);		void ParseOsVersion(boot_img_hdr_v1, const char);
	unsigned ParseFsOption(const char*);		unsigned ParseFsOption(const char*);
	};		};

			bool should_flash_in_userspace(const std::string& partition_name);
			bool is_userspace_fastboot();
			void do_flash(const char* pname, const char* fname);
			void do_for_partitions(const std::string& part, const std::string& slot,
			const std::function<void(const std::string&)>& func, bool force_slot);
			std::string find_item(const std::string& item);
			void reboot_to_userspace_fastboot();
			void syntax_error(const char* fmt, ...);

fastboot/task.cpp

0 → 100644

+46 −0

Original line number	Original line	Diff line number	Diff line
			//
			// Copyright (C) 2023 The Android Open Source Project
			//
			// Licensed under the Apache License, Version 2.0 (the "License");
			// you may not use this file except in compliance with the License.
			// You may obtain a copy of the License at
			//
			// http://www.apache.org/licenses/LICENSE-2.0
			//
			// Unless required by applicable law or agreed to in writing, software
			// distributed under the License is distributed on an "AS IS" BASIS,
			// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
			// See the License for the specific language governing permissions and
			// limitations under the License.
			//
			#include "task.h"

			#include "fastboot.h"
			#include "util.h"

			FlashTask::FlashTask(const std::string& _slot) : slot_(_slot){};
			FlashTask::FlashTask(const std::string& _slot, bool _force_flash)
			: slot_(_slot), force_flash_(_force_flash) {}
			FlashTask::FlashTask(const std::string& _slot, bool _force_flash, const std::string& _pname)
			: pname_(_pname), fname_(find_item(_pname)), slot_(_slot), force_flash_(_force_flash) {
			if (fname_.empty()) die("cannot determine image filename for '%s'", pname_.c_str());
			}
			FlashTask::FlashTask(const std::string& _slot, bool _force_flash, const std::string& _pname,
			const std::string& _fname)
			: pname_(_pname), fname_(_fname), slot_(_slot), force_flash_(_force_flash) {}

			void FlashTask::Run() {
			auto flash = [&](const std::string& partition) {
			if (should_flash_in_userspace(partition) && !is_userspace_fastboot() && !force_flash_) {
			die("The partition you are trying to flash is dynamic, and "
			"should be flashed via fastbootd. Please run:\n"
			"\n"
			" fastboot reboot fastboot\n"
			"\n"
			"And try again. If you are intentionally trying to "
			"overwrite a fixed partition, use --force.");
			}
			do_flash(partition.c_str(), fname_.c_str());
			};
			do_for_partitions(pname_, slot_, flash, true);
			}

fastboot/task.h

+18 −1

Original line number	Original line	Diff line number	Diff line
	@@ -26,6 +26,23 @@ class Task {
	public:		public:
	Task() = default;		Task() = default;
	virtual void Run() = 0;		virtual void Run() = 0;
	virtual bool Parse(const std::string& text) = 0;
	virtual ~Task() = default;		virtual ~Task() = default;
	};		};

			class FlashTask : public Task {
			public:
			FlashTask(const std::string& _slot);
			FlashTask(const std::string& _slot, bool _force_flash);
			FlashTask(const std::string& _slot, bool _force_flash, const std::string& _pname);
			FlashTask(const std::string& _slot, bool _force_flash, const std::string& _pname,
			const std::string& _fname);

			void Run() override;
			~FlashTask() {}

			private:
			const std::string pname_;
			const std::string fname_;
			const std::string slot_;
			bool force_flash_ = false;
			};