diff --git a/mkbootimg/Android.bp b/mkbootimg/Android.bp deleted file mode 100644 index c3cf74651..000000000 --- a/mkbootimg/Android.bp +++ /dev/null @@ -1,64 +0,0 @@ -// Copyright 2012 The Android Open Source Project - -cc_library_headers { - name: "libmkbootimg_abi_headers", - vendor_available: true, - export_include_dirs: ["include"], -} - -cc_library_headers { - name: "bootimg_headers", - vendor_available: true, - recovery_available: true, - export_include_dirs: ["include/bootimg"], - host_supported: true, - target: { - windows: { - enabled: true, - }, - }, -} - -cc_library { - name: "libmkbootimg_abi_check", - vendor_available: true, - vndk: { - enabled: true, - }, - srcs: [ - "mkbootimg_dummy.cpp", - ], - header_libs: ["libmkbootimg_abi_headers"], - export_header_lib_headers: ["libmkbootimg_abi_headers"], -} - -python_defaults { - name: "mkbootimg_defaults", - - version: { - py2: { - enabled: true, - embedded_launcher: true, - }, - py3: { - enabled: false, - embedded_launcher: false, - }, - }, -} - -python_binary_host { - name: "mkbootimg", - defaults: ["mkbootimg_defaults"], - srcs: [ - "mkbootimg.py", - ], -} - -python_binary_host { - name: "unpack_bootimg", - defaults: ["mkbootimg_defaults"], - srcs: [ - "unpack_bootimg.py", - ], -} diff --git a/mkbootimg/OWNERS b/mkbootimg/OWNERS deleted file mode 100644 index 3a008605d..000000000 --- a/mkbootimg/OWNERS +++ /dev/null @@ -1,2 +0,0 @@ -hridya@google.com -tbao@google.com diff --git a/mkbootimg/include/abi_check/mkbootimg_abi_check.h b/mkbootimg/include/abi_check/mkbootimg_abi_check.h deleted file mode 100644 index d478aba09..000000000 --- a/mkbootimg/include/abi_check/mkbootimg_abi_check.h +++ /dev/null @@ -1,28 +0,0 @@ -/* - * Copyright (C) 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. - */ - -#include - -// This header has been created for the following reaons: -// 1) In order for a change in a user defined type to be classified as API / -// ABI breaking, it needs to be referenced by an 'exported interface' -// (in this case the function mkbootimg_dummy). -// 2) Since 'mkbootimg_dummy' needs to be exported, we need to have it -// exposed through a public header. -// 3) It is desirable not to pollute bootimg.h with interfaces which are not -// 'used' in reality by on device binaries. Furthermore, bootimg.h might -// be exported by a library in the future, so we must avoid polluting it. -void mkbootimg_dummy(boot_img_hdr*); diff --git a/mkbootimg/include/bootimg/bootimg.h b/mkbootimg/include/bootimg/bootimg.h deleted file mode 100644 index 9ee786927..000000000 --- a/mkbootimg/include/bootimg/bootimg.h +++ /dev/null @@ -1,160 +0,0 @@ -/* - * Copyright (C) 2007 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. - */ - -#pragma once - -#include - -#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 - -// The bootloader expects the structure of boot_img_hdr with header -// version 0 to be as follows: -struct boot_img_hdr_v0 { - // Must be BOOT_MAGIC. - uint8_t magic[BOOT_MAGIC_SIZE]; - - uint32_t kernel_size; /* size in bytes */ - uint32_t kernel_addr; /* physical load addr */ - - uint32_t ramdisk_size; /* size in bytes */ - uint32_t ramdisk_addr; /* physical load addr */ - - uint32_t second_size; /* size in bytes */ - uint32_t second_addr; /* physical load addr */ - - uint32_t tags_addr; /* physical addr for kernel tags */ - uint32_t page_size; /* flash page size we assume */ - - // Version of 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": - // (7 bits for each of A, B, C; 7 bits for (Y-2000), 4 bits for M) - // os_version = A[31:25] B[24:18] C[17:11] (Y-2000)[10:4] M[3:0] - uint32_t os_version; - -#if __cplusplus - void SetOsVersion(unsigned major, unsigned minor, unsigned patch) { - os_version &= ((1 << 11) - 1); - os_version |= (((major & 0x7f) << 25) | ((minor & 0x7f) << 18) | ((patch & 0x7f) << 11)); - } - - void SetOsPatchLevel(unsigned year, unsigned month) { - os_version &= ~((1 << 11) - 1); - os_version |= (((year - 2000) & 0x7f) << 4) | ((month & 0xf) << 0); - } -#endif - - uint8_t name[BOOT_NAME_SIZE]; /* asciiz product name */ - - uint8_t cmdline[BOOT_ARGS_SIZE]; - - uint32_t id[8]; /* timestamp / checksum / sha1 / etc */ - - // Supplemental command line data; kept here to maintain - // binary compatibility with older versions of mkbootimg. - uint8_t extra_cmdline[BOOT_EXTRA_ARGS_SIZE]; -} __attribute__((packed)); - -/* - * 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 0, 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 - */ - -struct boot_img_hdr_v1 : public boot_img_hdr_v0 { - uint32_t recovery_dtbo_size; /* size in bytes for recovery DTBO/ACPIO image */ - uint64_t recovery_dtbo_offset; /* offset to recovery dtbo/acpio in boot image */ - uint32_t header_size; -} __attribute__((packed)); - -/* When the boot image header has a version of 2, 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/acpio | p pages - * +---------------------+ - * | dtb | q 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 - * q = (dtb_size + page_size - 1) / page_size - * - * 0. all entities are page_size aligned in flash - * 1. kernel, ramdisk and DTB are required (size != 0) - * 2. recovery_dtbo/recovery_acpio 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, dtb) at - * the specified physical address (kernel_addr, etc) - * 5. If booting to recovery mode in a non-A/B device, extract recovery - * dtbo/acpio and apply the correct set of overlays on the base device tree - * depending on the hardware/product revision. - * 6. prepare tags at tag_addr. kernel_args[] is - * appended to the kernel commandline in the tags. - * 7. r0 = 0, r1 = MACHINE_TYPE, r2 = tags_addr - * 8. if second_size != 0: jump to second_addr - * else: jump to kernel_addr - */ -struct boot_img_hdr_v2 : public boot_img_hdr_v1 { - uint32_t dtb_size; /* size in bytes for DTB image */ - uint64_t dtb_addr; /* physical load address for DTB image */ -} __attribute__((packed)); diff --git a/mkbootimg/mkbootimg.py b/mkbootimg/mkbootimg.py deleted file mode 100644 index 934f28e43..000000000 --- a/mkbootimg/mkbootimg.py +++ /dev/null @@ -1,236 +0,0 @@ -#!/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: - - if filesize(args.dtb) == 0: - raise ValueError("DTB image must not be empty.") - - 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() diff --git a/mkbootimg/mkbootimg_dummy.cpp b/mkbootimg/mkbootimg_dummy.cpp deleted file mode 100644 index 410d37909..000000000 --- a/mkbootimg/mkbootimg_dummy.cpp +++ /dev/null @@ -1,24 +0,0 @@ -/* - * Copyright (C) 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. - */ - -#include - -void mkbootimg_dummy(boot_img_hdr* hdr) { - // TODO: Hack to trigger abi checks, remove this. - if (hdr) { - hdr--; - } -} diff --git a/mkbootimg/unpack_bootimg.py b/mkbootimg/unpack_bootimg.py deleted file mode 100755 index 789bf5e6d..000000000 --- a/mkbootimg/unpack_bootimg.py +++ /dev/null @@ -1,152 +0,0 @@ -#!/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, dtb 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: %#x' % kernel_ramdisk_second_info[1]) - print('ramdisk size: %s' % kernel_ramdisk_second_info[2]) - print('ramdisk load address: %#x' % kernel_ramdisk_second_info[3]) - print('second bootloader size: %s' % kernel_ramdisk_second_info[4]) - print('second bootloader load address: %#x' % kernel_ramdisk_second_info[5]) - print('kernel tags load address: %#x' % 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_offset = unpack('Q', args.boot_img.read(8))[0] - print('recovery dtbo offset: %#x' % recovery_dtbo_offset) - boot_header_size = unpack('I', args.boot_img.read(4))[0] - print('boot header size: %s' % boot_header_size) - else: - recovery_dtbo_size = 0 - if version > 1: - dtb_size = unpack('I', args.boot_img.read(4))[0] - print('dtb size: %s' % dtb_size) - dtb_load_address = unpack('Q', args.boot_img.read(8))[0] - print('dtb address: %#x' % dtb_load_address) - else: - dtb_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')) - - if second_size > 0: - 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: - image_info_list.append((recovery_dtbo_offset, recovery_dtbo_size, - 'recovery_dtbo')) - if dtb_size > 0: - num_second_pages = get_number_of_pages(second_size, page_size) - num_recovery_dtbo_pages = get_number_of_pages(recovery_dtbo_size, page_size) - dtb_offset = page_size * ( - num_header_pages + num_kernel_pages + num_ramdisk_pages + num_second_pages + - num_recovery_dtbo_pages - ) - - image_info_list.append((dtb_offset, dtb_size, 'dtb')) - - 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, recovery dtbo and dtb') - 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()