mkbootimg/mkbootimg.py - platform/system/core - Gitiles

 #!/usr/bin/env python
 # Copyright 2015, 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.

 from __future__ import print_function
 from sys import argv, exit, stderr
 from argparse import ArgumentParser, FileType, Action
 from os import fstat
 from struct import pack
 from hashlib import sha1
 import sys
 import re

 def filesize(f):
     if f is None:
         return 0
     try:
         return fstat(f.fileno()).st_size
     except OSError:
         return 0


 def update_sha(sha, f):
     if f:
         sha.update(f.read())
         f.seek(0)
         sha.update(pack('I', filesize(f)))
     else:
         sha.update(pack('I', 0))


 def pad_file(f, padding):
     pad = (padding - (f.tell() & (padding - 1))) & (padding - 1)
     f.write(pack(str(pad) + 'x'))


 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 get_recovery_dtbo_offset(args):
     """calculates the offset of recovery_dtbo image in the boot image"""
     num_header_pages = 1 # header occupies a page
     num_kernel_pages = get_number_of_pages(filesize(args.kernel), args.pagesize)
     num_ramdisk_pages = get_number_of_pages(filesize(args.ramdisk), args.pagesize)
     num_second_pages = get_number_of_pages(filesize(args.second), args.pagesize)
     dtbo_offset = args.pagesize * (num_header_pages + num_kernel_pages +
                                    num_ramdisk_pages + num_second_pages)
     return dtbo_offset


 def write_header(args):
     BOOT_IMAGE_HEADER_V1_SIZE = 1648
     BOOT_IMAGE_HEADER_V2_SIZE = 1660
     BOOT_MAGIC = 'ANDROID!'.encode()

     if (args.header_version > 2):
         raise ValueError('Boot header version %d not supported' % args.header_version)

     args.output.write(pack('8s', BOOT_MAGIC))
     args.output.write(pack('10I',
         filesize(args.kernel),                          # size in bytes
         args.base + args.kernel_offset,                 # physical load addr
         filesize(args.ramdisk),                         # size in bytes
         args.base + args.ramdisk_offset,                # physical load addr
         filesize(args.second),                          # size in bytes
         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
         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()))

     sha = sha1()
     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)
     if args.header_version > 1:
         update_sha(sha, args.dtb)

     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
         if args.recovery_dtbo:
             args.output.write(pack('Q', get_recovery_dtbo_offset(args))) # recovery dtbo offset
         else:
             args.output.write(pack('Q', 0)) # Will be set to 0 for devices without a recovery dtbo

     # Populate boot image header size for header versions 1 and 2.
     if args.header_version == 1:
         args.output.write(pack('I', BOOT_IMAGE_HEADER_V1_SIZE))
     elif args.header_version == 2:
         args.output.write(pack('I', BOOT_IMAGE_HEADER_V2_SIZE))

     if args.header_version > 1:
         args.output.write(pack('I', filesize(args.dtb)))   # size in bytes
         args.output.write(pack('Q', args.base + args.dtb_offset)) # dtb physical load address
     pad_file(args.output, args.pagesize)
     return img_id


 class ValidateStrLenAction(Action):
     def __init__(self, option_strings, dest, nargs=None, **kwargs):
         if 'maxlen' not in kwargs:
             raise ValueError('maxlen must be set')
         self.maxlen = int(kwargs['maxlen'])
         del kwargs['maxlen']
         super(ValidateStrLenAction, self).__init__(option_strings, dest, **kwargs)

     def __call__(self, parser, namespace, values, option_string=None):
         if len(values) > self.maxlen:
             raise ValueError('String argument too long: max {0:d}, got {1:d}'.
                 format(self.maxlen, len(values)))
         setattr(namespace, self.dest, values)


 def write_padded_file(f_out, f_in, padding):
     if f_in is None:
         return
     f_out.write(f_in.read())
     pad_file(f_out, padding)


 def parse_int(x):
     return int(x, 0)

 def parse_os_version(x):
     match = re.search(r'^(\d{1,3})(?:\.(\d{1,3})(?:\.(\d{1,3}))?)?', x)
     if match:
         a = int(match.group(1))
         b = c = 0
         if match.lastindex >= 2:
             b = int(match.group(2))
         if match.lastindex == 3:
             c = int(match.group(3))
         # 7 bits allocated for each field
         assert a < 128
         assert b < 128
         assert c < 128
         return (a << 14) | (b << 7) | c
     return 0

 def parse_os_patch_level(x):
     match = re.search(r'^(\d{4})-(\d{2})-(\d{2})', x)
     if match:
         y = int(match.group(1)) - 2000
         m = int(match.group(2))
         # 7 bits allocated for the year, 4 bits for the month
         assert y >= 0 and y < 128
         assert m > 0 and m <= 12
         return (y << 4) | m
     return 0

 def parse_cmdline():
     parser = ArgumentParser()
     parser.add_argument('--kernel', help='path to the kernel', type=FileType('rb'),
                         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('--dtb', help='path to dtb', type=FileType('rb'))
     recovery_dtbo_group = parser.add_mutually_exclusive_group()
     recovery_dtbo_group.add_argument('--recovery_dtbo', help='path to the recovery DTBO', type=FileType('rb'))
     recovery_dtbo_group.add_argument('--recovery_acpio', help='path to the recovery ACPIO',
                                      type=FileType('rb'), metavar='RECOVERY_ACPIO', dest='recovery_dtbo')
     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)
     parser.add_argument('--kernel_offset', help='kernel offset', type=parse_int, default=0x00008000)
     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('--dtb_offset', help='dtb offset', type=parse_int, default=0x01f00000)

     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',
                         type=parse_os_patch_level, default=0)
     parser.add_argument('--tags_offset', help='tags offset', type=parse_int, default=0x00000100)
     parser.add_argument('--board', help='board name', default='', action=ValidateStrLenAction,
                         maxlen=16)
     parser.add_argument('--pagesize', help='page size', type=parse_int,
                         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()


 def write_data(args):
     write_padded_file(args.output, args.kernel, args.pagesize)
     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)
     if args.header_version > 1:
         write_padded_file(args.output, args.dtb, args.pagesize)

 def main():
     args = parse_cmdline()
     img_id = write_header(args)
     write_data(args)
     if args.id:
         if isinstance(img_id, str):
             # Python 2's struct.pack returns a string, but py3 returns bytes.
             img_id = [ord(x) for x in img_id]
         print('0x' + ''.join('{:02x}'.format(c) for c in img_id))

 if __name__ == '__main__':
     main()
	#!/usr/bin/env python
	# Copyright 2015, 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.

	from __future__ import print_function
	from sys import argv, exit, stderr
	from argparse import ArgumentParser, FileType, Action
	from os import fstat
	from struct import pack
	from hashlib import sha1
	import sys
	import re

	def filesize(f):
	if f is None:
	return 0
	try:
	return fstat(f.fileno()).st_size
	except OSError:
	return 0


	def update_sha(sha, f):
	if f:
	sha.update(f.read())
	f.seek(0)
	sha.update(pack('I', filesize(f)))
	else:
	sha.update(pack('I', 0))


	def pad_file(f, padding):
	pad = (padding - (f.tell() & (padding - 1))) & (padding - 1)
	f.write(pack(str(pad) + 'x'))


	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 get_recovery_dtbo_offset(args):
	"""calculates the offset of recovery_dtbo image in the boot image"""
	num_header_pages = 1 # header occupies a page
	num_kernel_pages = get_number_of_pages(filesize(args.kernel), args.pagesize)
	num_ramdisk_pages = get_number_of_pages(filesize(args.ramdisk), args.pagesize)
	num_second_pages = get_number_of_pages(filesize(args.second), args.pagesize)
	dtbo_offset = args.pagesize * (num_header_pages + num_kernel_pages +
	num_ramdisk_pages + num_second_pages)
	return dtbo_offset


	def write_header(args):
	BOOT_IMAGE_HEADER_V1_SIZE = 1648
	BOOT_IMAGE_HEADER_V2_SIZE = 1660
	BOOT_MAGIC = 'ANDROID!'.encode()

	if (args.header_version > 2):
	raise ValueError('Boot header version %d not supported' % args.header_version)

	args.output.write(pack('8s', BOOT_MAGIC))
	args.output.write(pack('10I',
	filesize(args.kernel), # size in bytes
	args.base + args.kernel_offset, # physical load addr
	filesize(args.ramdisk), # size in bytes
	args.base + args.ramdisk_offset, # physical load addr
	filesize(args.second), # size in bytes
	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
	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()))

	sha = sha1()
	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)
	if args.header_version > 1:
	update_sha(sha, args.dtb)

	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
	if args.recovery_dtbo:
	args.output.write(pack('Q', get_recovery_dtbo_offset(args))) # recovery dtbo offset
	else:
	args.output.write(pack('Q', 0)) # Will be set to 0 for devices without a recovery dtbo

	# Populate boot image header size for header versions 1 and 2.
	if args.header_version == 1:
	args.output.write(pack('I', BOOT_IMAGE_HEADER_V1_SIZE))
	elif args.header_version == 2:
	args.output.write(pack('I', BOOT_IMAGE_HEADER_V2_SIZE))

	if args.header_version > 1:
	args.output.write(pack('I', filesize(args.dtb))) # size in bytes
	args.output.write(pack('Q', args.base + args.dtb_offset)) # dtb physical load address
	pad_file(args.output, args.pagesize)
	return img_id


	class ValidateStrLenAction(Action):
	def __init__(self, option_strings, dest, nargs=None, **kwargs):
	if 'maxlen' not in kwargs:
	raise ValueError('maxlen must be set')
	self.maxlen = int(kwargs['maxlen'])
	del kwargs['maxlen']
	super(ValidateStrLenAction, self).__init__(option_strings, dest, **kwargs)

	def __call__(self, parser, namespace, values, option_string=None):
	if len(values) > self.maxlen:
	raise ValueError('String argument too long: max {0:d}, got {1:d}'.
	format(self.maxlen, len(values)))
	setattr(namespace, self.dest, values)


	def write_padded_file(f_out, f_in, padding):
	if f_in is None:
	return
	f_out.write(f_in.read())
	pad_file(f_out, padding)


	def parse_int(x):
	return int(x, 0)

	def parse_os_version(x):
	match = re.search(r'^(\d{1,3})(?:\.(\d{1,3})(?:\.(\d{1,3}))?)?', x)
	if match:
	a = int(match.group(1))
	b = c = 0
	if match.lastindex >= 2:
	b = int(match.group(2))
	if match.lastindex == 3:
	c = int(match.group(3))
	# 7 bits allocated for each field
	assert a < 128
	assert b < 128
	assert c < 128
	return (a << 14) \| (b << 7) \| c
	return 0

	def parse_os_patch_level(x):
	match = re.search(r'^(\d{4})-(\d{2})-(\d{2})', x)
	if match:
	y = int(match.group(1)) - 2000
	m = int(match.group(2))
	# 7 bits allocated for the year, 4 bits for the month
	assert y >= 0 and y < 128
	assert m > 0 and m <= 12
	return (y << 4) \| m
	return 0

	def parse_cmdline():
	parser = ArgumentParser()
	parser.add_argument('--kernel', help='path to the kernel', type=FileType('rb'),
	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('--dtb', help='path to dtb', type=FileType('rb'))
	recovery_dtbo_group = parser.add_mutually_exclusive_group()
	recovery_dtbo_group.add_argument('--recovery_dtbo', help='path to the recovery DTBO', type=FileType('rb'))
	recovery_dtbo_group.add_argument('--recovery_acpio', help='path to the recovery ACPIO',
	type=FileType('rb'), metavar='RECOVERY_ACPIO', dest='recovery_dtbo')
	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)
	parser.add_argument('--kernel_offset', help='kernel offset', type=parse_int, default=0x00008000)
	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('--dtb_offset', help='dtb offset', type=parse_int, default=0x01f00000)

	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',
	type=parse_os_patch_level, default=0)
	parser.add_argument('--tags_offset', help='tags offset', type=parse_int, default=0x00000100)
	parser.add_argument('--board', help='board name', default='', action=ValidateStrLenAction,
	maxlen=16)
	parser.add_argument('--pagesize', help='page size', type=parse_int,
	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()


	def write_data(args):
	write_padded_file(args.output, args.kernel, args.pagesize)
	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)
	if args.header_version > 1:
	write_padded_file(args.output, args.dtb, args.pagesize)

	def main():
	args = parse_cmdline()
	img_id = write_header(args)
	write_data(args)
	if args.id:
	if isinstance(img_id, str):
	# Python 2's struct.pack returns a string, but py3 returns bytes.
	img_id = [ord(x) for x in img_id]
	print('0x' + ''.join('{:02x}'.format(c) for c in img_id))

	if __name__ == '__main__':
	main()