Merge "Remove system/core/mkbootimg"

// 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",

    ],

}

hridya@google.com

tbao@google.com

/*

 * 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 <bootimg/bootimg.h>

// 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*);

/*

 * 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 <stdint.h>

#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));

#!/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()