Merge "Add a header-version argument to fastboot" (0f217b52) · Commits · e / os / android_system_core

fastboot/bootimg_utils.cpp

+13 −10

Original line number	Diff line number	Diff line
		@@ -34,26 +34,25 @@
		#include <stdlib.h>
		#include <string.h>

		void bootimg_set_cmdline(boot_img_hdr* h, const char* cmdline) {
		void bootimg_set_cmdline(boot_img_hdr_v1* h, const char* cmdline) {
		if (strlen(cmdline) >= sizeof(h->cmdline)) die("command line too large: %zu", strlen(cmdline));
		strcpy(reinterpret_cast<char*>(h->cmdline), cmdline);
		}

		boot_img_hdr* mkbootimg(void* kernel, int64_t kernel_size, off_t kernel_offset,
		void* ramdisk, int64_t ramdisk_size, off_t ramdisk_offset,
		void* second, int64_t second_size, off_t second_offset,
		size_t page_size, size_t base, off_t tags_offset,
		int64_t* bootimg_size)
		{
		boot_img_hdr_v1* mkbootimg(void* kernel, int64_t kernel_size, off_t kernel_offset, void* ramdisk,
		int64_t ramdisk_size, off_t ramdisk_offset, void* second,
		int64_t second_size, off_t second_offset, size_t page_size, size_t base,
		off_t tags_offset, uint32_t header_version, int64_t* bootimg_size) {
		size_t page_mask = page_size - 1;

		int64_t header_actual = sizeof(boot_img_hdr_v1) & (~page_mask);
		int64_t kernel_actual = (kernel_size + page_mask) & (~page_mask);
		int64_t ramdisk_actual = (ramdisk_size + page_mask) & (~page_mask);
		int64_t second_actual = (second_size + page_mask) & (~page_mask);

		*bootimg_size = page_size + kernel_actual + ramdisk_actual + second_actual;
		*bootimg_size = header_actual + kernel_actual + ramdisk_actual + second_actual;

		boot_img_hdr* hdr = reinterpret_cast<boot_img_hdr>(calloc(bootimg_size, 1));
		boot_img_hdr_v1* hdr = reinterpret_cast<boot_img_hdr_v1>(calloc(bootimg_size, 1));
		if (hdr == nullptr) {
		return hdr;
		}
		@@ -71,9 +70,13 @@ boot_img_hdr* mkbootimg(void* kernel, int64_t kernel_size, off_t kernel_offset,

		hdr->page_size = page_size;

		if (header_version) {
		hdr->header_version = header_version;
		hdr->header_size = sizeof(boot_img_hdr_v1);
		}

		memcpy(hdr->magic + page_size, kernel, kernel_size);
		memcpy(hdr->magic + page_size + kernel_actual, ramdisk, ramdisk_size);
		memcpy(hdr->magic + page_size + kernel_actual + ramdisk_actual, second, second_size);

		return hdr;
		}

fastboot/bootimg_utils.h

+5 −6

Original line number	Diff line number	Diff line
		@@ -33,11 +33,10 @@
		#include <inttypes.h>
		#include <sys/types.h>

		void bootimg_set_cmdline(boot_img_hdr* h, const char* cmdline);
		boot_img_hdr* mkbootimg(void* kernel, int64_t kernel_size, off_t kernel_offset,
		void* ramdisk, int64_t ramdisk_size, off_t ramdisk_offset,
		void* second, int64_t second_size, off_t second_offset,
		size_t page_size, size_t base, off_t tags_offset,
		int64_t* bootimg_size);
		void bootimg_set_cmdline(boot_img_hdr_v1* h, const char* cmdline);
		boot_img_hdr_v1* mkbootimg(void* kernel, int64_t kernel_size, off_t kernel_offset, void* ramdisk,
		int64_t ramdisk_size, off_t ramdisk_offset, void* second,
		int64_t second_size, off_t second_offset, size_t page_size, size_t base,
		off_t tags_offset, uint32_t header_version, int64_t* bootimg_size);

		#endif

fastboot/fastboot.cpp

+21 −8

Original line number	Diff line number	Diff line
		@@ -434,6 +434,9 @@ static int show_help() {
		" --unbuffered Do not buffer input or output.\n"
		" -v, --verbose Verbose output.\n"
		" --version Display version.\n"
		" --header-version Set boot image header version while\n"
		" using flash:raw and boot commands to \n"
		" to create a boot image.\n"
		" -h, --help show this message.\n"
		);
		// clang-format off
		@@ -442,17 +445,23 @@ static int show_help() {

		static void* load_bootable_image(const std::string& kernel, const std::string& ramdisk,
		const std::string& second_stage, int64_t* sz,
		const char* cmdline) {
		const char* cmdline, uint32_t header_version) {
		int64_t ksize;
		void* kdata = load_file(kernel.c_str(), &ksize);
		if (kdata == nullptr) die("cannot load '%s': %s", kernel.c_str(), strerror(errno));

		// Is this actually a boot image?
		if (ksize < static_cast<int64_t>(sizeof(boot_img_hdr))) {
		if (ksize < static_cast<int64_t>(sizeof(boot_img_hdr_v1))) {
		die("cannot load '%s': too short", kernel.c_str());
		}
		if (!memcmp(kdata, BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
		if (cmdline) bootimg_set_cmdline(reinterpret_cast<boot_img_hdr*>(kdata), cmdline);
		if (cmdline) bootimg_set_cmdline(reinterpret_cast<boot_img_hdr_v1*>(kdata), cmdline);
		uint32_t header_version_existing =
		reinterpret_cast<boot_img_hdr_v1*>(kdata)->header_version;
		if (header_version != header_version_existing) {
		die("header version mismatch, expected: %" PRIu32 " found %" PRIu32 "",
		header_version, header_version_existing);
		}

		if (!ramdisk.empty()) die("cannot boot a boot.img and ramdisk");

		@@ -476,13 +485,13 @@ static void* load_bootable_image(const std::string& kernel, const std::string& r

		fprintf(stderr,"creating boot image...\n");
		int64_t bsize = 0;
		void* bdata = mkbootimg(kdata, ksize, kernel_offset,
		boot_img_hdr_v1* bdata = mkbootimg(kdata, ksize, kernel_offset,
		rdata, rsize, ramdisk_offset,
		sdata, ssize, second_offset,
		page_size, base_addr, tags_offset, &bsize);
		page_size, base_addr, tags_offset, header_version, &bsize);
		if (bdata == nullptr) die("failed to create boot.img");

		if (cmdline) bootimg_set_cmdline((boot_img_hdr*) bdata, cmdline);
		if (cmdline) bootimg_set_cmdline(bdata, cmdline);
		fprintf(stderr, "creating boot image - %" PRId64 " bytes\n", bsize);
		*sz = bsize;

		@@ -1484,6 +1493,7 @@ int main(int argc, char **argv)
		bool erase_first = true;
		bool set_fbe_marker = false;
		void *data;
		uint32_t header_version = 0;
		int64_t sz;
		int longindex;
		std::string slot_override;
		@@ -1510,6 +1520,7 @@ int main(int argc, char **argv)
		{"version", no_argument, 0, 0},
		{"disable-verity", no_argument, 0, 0},
		{"disable-verification", no_argument, 0, 0},
		{"header-version", required_argument, 0, 0},
		#if !defined(_WIN32)
		{"wipe-and-use-fbe", no_argument, 0, 0},
		#endif
		@@ -1605,6 +1616,8 @@ int main(int argc, char **argv)
		wants_wipe = true;
		set_fbe_marker = true;
		#endif
		} else if (strcmp("header-version", longopts[longindex].name) == 0) {
		header_version = strtoul(optarg, nullptr, 0);
		} else {
		die("unknown option %s", longopts[longindex].name);
		}
		@@ -1735,7 +1748,7 @@ int main(int argc, char **argv)
		std::string second_stage;
		if (!args.empty()) second_stage = next_arg(&args);

		data = load_bootable_image(kernel, ramdisk, second_stage, &sz, cmdline);
		data = load_bootable_image(kernel, ramdisk, second_stage, &sz, cmdline, header_version);
		fb_queue_download("boot.img", data, sz);
		fb_queue_command("boot", "booting");
		} else if (command == "flash") {
		@@ -1764,7 +1777,7 @@ int main(int argc, char **argv)
		std::string second_stage;
		if (!args.empty()) second_stage = next_arg(&args);

		data = load_bootable_image(kernel, ramdisk, second_stage, &sz, cmdline);
		data = load_bootable_image(kernel, ramdisk, second_stage, &sz, cmdline, header_version);
		auto flashraw = [&](const std::string& partition) {
		fb_queue_flash(partition, data, sz);
		};