Merge changes from topic "recovery_dtbo" (3ac69463) · Commits · e / os / android_system_core

mkbootimg/Android.mk

+9 −0

Original line number	Diff line number	Diff line
		@@ -9,3 +9,12 @@ LOCAL_IS_HOST_MODULE := true
		LOCAL_MODULE := mkbootimg

		include $(BUILD_PREBUILT)

		include $(CLEAR_VARS)
		LOCAL_SRC_FILES := unpack_bootimg
		LOCAL_MODULE_CLASS := EXECUTABLES
		LOCAL_IS_HOST_MODULE := true

		LOCAL_MODULE := unpack_bootimg

		include $(BUILD_PREBUILT)

mkbootimg/bootimg.h

+83 −30

Original line number	Diff line number	Diff line
		@@ -20,16 +20,18 @@
		#ifndef _BOOT_IMAGE_H_
		#define _BOOT_IMAGE_H_

		typedef struct boot_img_hdr boot_img_hdr;

		#define BOOT_MAGIC "ANDROID!"
		#define BOOT_MAGIC_SIZE 8
		#define BOOT_NAME_SIZE 16
		#define BOOT_ARGS_SIZE 512
		#define BOOT_EXTRA_ARGS_SIZE 1024

		struct boot_img_hdr
		{
		#define BOOT_HEADER_VERSION_ZERO 0
		/*
		* Bootloader expects the structure of boot_img_hdr with header version
		* BOOT_HEADER_VERSION_ZERO to be as follows:
		*/
		struct boot_img_hdr_v0 {
		uint8_t magic[BOOT_MAGIC_SIZE];

		uint32_t kernel_size; /* size in bytes */
		@@ -43,7 +45,10 @@ struct boot_img_hdr

		uint32_t tags_addr; /* physical addr for kernel tags */
		uint32_t page_size; /* flash page size we assume */
		uint32_t unused; /* reserved for future expansion: MUST be 0 */
		/*
		* version for the boot image header.
		*/
		uint32_t header_version;

		/* operating system version and security patch level; for
		* version "A.B.C" and patch level "Y-M-D":
		@@ -64,30 +69,78 @@ struct boot_img_hdr
		} __attribute__((packed));

		/*
		** +-----------------+
		** \| boot header \| 1 page
		** +-----------------+
		** \| kernel \| n pages
		** +-----------------+
		** \| ramdisk \| m pages
		** +-----------------+
		** \| second stage \| o pages
		** +-----------------+
		**
		** n = (kernel_size + page_size - 1) / page_size
		** m = (ramdisk_size + page_size - 1) / page_size
		** o = (second_size + page_size - 1) / page_size
		**
		** 0. all entities are page_size aligned in flash
		** 1. kernel and ramdisk are required (size != 0)
		** 2. second is optional (second_size == 0 -> no second)
		** 3. load each element (kernel, ramdisk, second) at
		** the specified physical address (kernel_addr, etc)
		** 4. prepare tags at tag_addr. kernel_args[] is
		** appended to the kernel commandline in the tags.
		** 5. r0 = 0, r1 = MACHINE_TYPE, r2 = tags_addr
		** 6. if second_size != 0: jump to second_addr
		** else: jump to kernel_addr
		* It is expected that callers would explicitly specify which version of the
		* boot image header they need to use.
		*/
		typedef struct boot_img_hdr_v0 boot_img_hdr;

		/* When a boot header is of version BOOT_HEADER_VERSION_ZERO, the structure of boot image is as
		* follows:
		*
		* +-----------------+
		* \| boot header \| 1 page
		* +-----------------+
		* \| kernel \| n pages
		* +-----------------+
		* \| ramdisk \| m pages
		* +-----------------+
		* \| second stage \| o pages
		* +-----------------+
		*
		* n = (kernel_size + page_size - 1) / page_size
		* m = (ramdisk_size + page_size - 1) / page_size
		* o = (second_size + page_size - 1) / page_size
		*
		* 0. all entities are page_size aligned in flash
		* 1. kernel and ramdisk are required (size != 0)
		* 2. second is optional (second_size == 0 -> no second)
		* 3. load each element (kernel, ramdisk, second) at
		* the specified physical address (kernel_addr, etc)
		* 4. prepare tags at tag_addr. kernel_args[] is
		* appended to the kernel commandline in the tags.
		* 5. r0 = 0, r1 = MACHINE_TYPE, r2 = tags_addr
		* 6. if second_size != 0: jump to second_addr
		* else: jump to kernel_addr
		*/

		#define BOOT_HEADER_VERSION_ONE 1

		struct boot_img_hdr_v1 : public boot_img_hdr_v0 {
		uint32_t recovery_dtbo_size; /* size in bytes for recovery DTBO image */
		uint64_t recovery_dtbo_offset; /* physical load addr */
		uint32_t header_size;
		} __attribute__((packed));

		/* When the boot image header has a version of BOOT_HEADER_VERSION_ONE, the structure of the boot
		* image is as follows:
		*
		* +-----------------+
		* \| boot header \| 1 page
		* +-----------------+
		* \| kernel \| n pages
		* +-----------------+
		* \| ramdisk \| m pages
		* +-----------------+
		* \| second stage \| o pages
		* +-----------------+
		* \| recovery dtbo \| p pages
		* +-----------------+
		* n = (kernel_size + page_size - 1) / page_size
		* m = (ramdisk_size + page_size - 1) / page_size
		* o = (second_size + page_size - 1) / page_size
		* p = (recovery_dtbo_size + page_size - 1) / page_size
		*
		* 0. all entities are page_size aligned in flash
		* 1. kernel and ramdisk are required (size != 0)
		* 2. recovery_dtbo is required for recovery.img in non-A/B devices(recovery_dtbo_size != 0)
		* 3. second is optional (second_size == 0 -> no second)
		* 4. load each element (kernel, ramdisk, second, recovery_dtbo) at
		* the specified physical address (kernel_addr, etc)
		* 5. prepare tags at tag_addr. kernel_args[] is
		* appended to the kernel commandline in the tags.
		* 6. r0 = 0, r1 = MACHINE_TYPE, r2 = tags_addr
		* 7. if second_size != 0: jump to second_addr
		* else: jump to kernel_addr
		*/

		#if 0

mkbootimg/mkbootimg

+17 −1

Original line number	Diff line number	Diff line
		@@ -57,7 +57,7 @@ def write_header(args):
		args.base + args.second_offset, # physical load addr
		args.base + args.tags_offset, # physical addr for kernel tags
		args.pagesize, # flash page size we assume
		0, # future expansion: MUST be 0
		args.header_version, # version of bootimage header
		(args.os_version << 11) \| args.os_patch_level)) # os version and patch level
		args.output.write(pack('16s', args.board.encode())) # asciiz product name
		args.output.write(pack('512s', args.cmdline[:512].encode()))
		@@ -66,10 +66,20 @@ def write_header(args):
		update_sha(sha, args.kernel)
		update_sha(sha, args.ramdisk)
		update_sha(sha, args.second)

		if args.header_version > 0:
		update_sha(sha, args.recovery_dtbo)

		img_id = pack('32s', sha.digest())

		args.output.write(img_id)
		args.output.write(pack('1024s', args.cmdline[512:].encode()))

		if args.header_version > 0:
		args.output.write(pack('I', filesize(args.recovery_dtbo))) # size in bytes
		args.output.write(pack('Q', args.base + args.recovery_dtbo_offset)) # physical load addr
		args.output.write(pack('I', args.output.tell() + 4)) # size of boot header

		pad_file(args.output, args.pagesize)
		return img_id

		@@ -132,6 +142,7 @@ def parse_cmdline():
		required=True)
		parser.add_argument('--ramdisk', help='path to the ramdisk', type=FileType('rb'))
		parser.add_argument('--second', help='path to the 2nd bootloader', type=FileType('rb'))
		parser.add_argument('--recovery_dtbo', help='path to the recovery DTBO', type=FileType('rb'))
		parser.add_argument('--cmdline', help='extra arguments to be passed on the '
		'kernel command line', default='', action=ValidateStrLenAction, maxlen=1536)
		parser.add_argument('--base', help='base address', type=parse_int, default=0x10000000)
		@@ -139,6 +150,8 @@ def parse_cmdline():
		parser.add_argument('--ramdisk_offset', help='ramdisk offset', type=parse_int, default=0x01000000)
		parser.add_argument('--second_offset', help='2nd bootloader offset', type=parse_int,
		default=0x00f00000)
		parser.add_argument('--recovery_dtbo_offset', help='recovery dtbo offset', type=parse_int,
		default=0x0f000000)
		parser.add_argument('--os_version', help='operating system version', type=parse_os_version,
		default=0)
		parser.add_argument('--os_patch_level', help='operating system patch level',
		@@ -150,6 +163,7 @@ def parse_cmdline():
		choices=[2**i for i in range(11,15)], default=2048)
		parser.add_argument('--id', help='print the image ID on standard output',
		action='store_true')
		parser.add_argument('--header_version', help='boot image header version', type=parse_int, default=0)
		parser.add_argument('-o', '--output', help='output file name', type=FileType('wb'),
		required=True)
		return parser.parse_args()
		@@ -160,6 +174,8 @@ def write_data(args):
		write_padded_file(args.output, args.ramdisk, args.pagesize)
		write_padded_file(args.output, args.second, args.pagesize)

		if args.header_version > 0:
		write_padded_file(args.output, args.recovery_dtbo, args.pagesize)

		def main():
		args = parse_cmdline()

mkbootimg/unpack_bootimg

0 → 100755

+137 −0

Original line number	Diff line number	Diff line
		#!/usr/bin/env python
		# Copyright 2018, 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.

		"""unpacks the bootimage.

		Extracts the kernel, ramdisk, second bootloader and recovery dtbo images.
		"""

		from __future__ import print_function
		from argparse import ArgumentParser, FileType
		from struct import unpack
		import os


		def create_out_dir(dir_path):
		"""creates a directory 'dir_path' if it does not exist"""
		if not os.path.exists(dir_path):
		os.makedirs(dir_path)


		def extract_image(offset, size, bootimage, extracted_image_name):
		"""extracts an image from the bootimage"""
		bootimage.seek(offset)
		with open(extracted_image_name, 'wb') as file_out:
		file_out.write(bootimage.read(size))


		def get_number_of_pages(image_size, page_size):
		"""calculates the number of pages required for the image"""
		return (image_size + page_size - 1) / page_size


		def unpack_bootimage(args):
		"""extracts kernel, ramdisk, second bootloader and recovery dtbo"""
		boot_magic = unpack('8s', args.boot_img.read(8))
		print('boot_magic: %s' % boot_magic)
		kernel_ramdisk_second_info = unpack('10I', args.boot_img.read(10 * 4))
		print('kernel_size: %s' % kernel_ramdisk_second_info[0])
		print('kernel load address: %s' % kernel_ramdisk_second_info[1])
		print('ramdisk size: %s' % kernel_ramdisk_second_info[2])
		print('ramdisk load address: %s' % kernel_ramdisk_second_info[3])
		print('second bootloader size: %s' % kernel_ramdisk_second_info[4])
		print('second bootloader load address: %s' % kernel_ramdisk_second_info[5])
		print('kernel tags load address: %s' % kernel_ramdisk_second_info[6])
		print('page size: %s' % kernel_ramdisk_second_info[7])
		print('boot image header version: %s' % kernel_ramdisk_second_info[8])
		print('os version and patch level: %s' % kernel_ramdisk_second_info[9])

		product_name = unpack('16s', args.boot_img.read(16))
		print('product name: %s' % product_name)
		cmdline = unpack('512s', args.boot_img.read(512))
		print('command line args: %s' % cmdline)

		args.boot_img.read(32) # ignore SHA

		extra_cmdline = unpack('1024s', args.boot_img.read(1024))
		print('additional command line args: %s' % extra_cmdline)

		kernel_size = kernel_ramdisk_second_info[0]
		ramdisk_size = kernel_ramdisk_second_info[2]
		second_size = kernel_ramdisk_second_info[4]
		page_size = kernel_ramdisk_second_info[7]
		version = kernel_ramdisk_second_info[8]
		if version > 0:
		recovery_dtbo_size = unpack('I', args.boot_img.read(1 * 4))[0]
		print('recovery dtbo size: %s' % recovery_dtbo_size)
		recovery_dtbo_address = unpack('Q', args.boot_img.read(8))[0]
		print('recovery dtbo load address: %s' % recovery_dtbo_address)
		boot_header_size = unpack('I', args.boot_img.read(4))[0]
		print('boot header size: %s' % boot_header_size)
		else:
		recovery_dtbo_size = 0

		# The first page contains the boot header
		num_header_pages = 1

		num_kernel_pages = get_number_of_pages(kernel_size, page_size)
		kernel_offset = page_size * num_header_pages # header occupies a page
		image_info_list = [(kernel_offset, kernel_size, 'kernel')]

		num_ramdisk_pages = get_number_of_pages(ramdisk_size, page_size)
		ramdisk_offset = page_size * (num_header_pages + num_kernel_pages
		) # header + kernel
		image_info_list.append((ramdisk_offset, ramdisk_size, 'ramdisk'))

		num_second_pages = get_number_of_pages(second_size, page_size)
		second_offset = page_size * (
		num_header_pages + num_kernel_pages + num_ramdisk_pages
		) # header + kernel + ramdisk
		image_info_list.append((second_offset, second_size, 'second'))

		if recovery_dtbo_size > 0:
		dtbo_offset = page_size * (num_header_pages + num_kernel_pages +
		num_ramdisk_pages + num_second_pages)
		image_info_list.append((dtbo_offset, recovery_dtbo_size,
		'recovery_dtbo'))

		for image_info in image_info_list:
		extract_image(image_info[0], image_info[1], args.boot_img,
		os.path.join(args.out, image_info[2]))


		def parse_cmdline():
		"""parse command line arguments"""
		parser = ArgumentParser(
		description='Unpacks boot.img/recovery.img, extracts the kernel,'
		'ramdisk, second bootloader and recovery dtbo')
		parser.add_argument(
		'--boot_img',
		help='path to boot image',
		type=FileType('rb'),
		required=True)
		parser.add_argument('--out', help='path to out binaries', default='out')
		return parser.parse_args()


		def main():
		"""parse arguments and unpack boot image"""
		args = parse_cmdline()
		create_out_dir(args.out)
		unpack_bootimage(args)


		if __name__ == '__main__':
		main()