Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 1 | #!/usr/bin/env python |
| 2 | # |
| 3 | # Copyright (C) 2014 The Android Open Source Project |
| 4 | # |
| 5 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | # you may not use this file except in compliance with the License. |
| 7 | # You may obtain a copy of the License at |
| 8 | # |
| 9 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | # |
| 11 | # Unless required by applicable law or agreed to in writing, software |
| 12 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | # See the License for the specific language governing permissions and |
| 15 | # limitations under the License. |
| 16 | |
| 17 | """ |
| 18 | Given a target-files zipfile that does not contain images (ie, does |
| 19 | not have an IMAGES/ top-level subdirectory), produce the images and |
| 20 | add them to the zipfile. |
| 21 | |
Tianjie Xu | b48589a | 2016-08-03 19:21:52 -0700 | [diff] [blame] | 22 | Usage: add_img_to_target_files [flag] target_files |
| 23 | |
| 24 | -a (--add_missing) |
| 25 | Build and add missing images to "IMAGES/". If this option is |
| 26 | not specified, this script will simply exit when "IMAGES/" |
| 27 | directory exists in the target file. |
| 28 | |
| 29 | -r (--rebuild_recovery) |
| 30 | Rebuild the recovery patch and write it to the system image. Only |
| 31 | meaningful when system image needs to be rebuilt. |
| 32 | |
| 33 | --replace_verity_private_key |
| 34 | Replace the private key used for verity signing. (same as the option |
| 35 | in sign_target_files_apks) |
| 36 | |
| 37 | --replace_verity_public_key |
| 38 | Replace the certificate (public key) used for verity verification. (same |
| 39 | as the option in sign_target_files_apks) |
| 40 | |
| 41 | --is_signing |
| 42 | Skip building & adding the images for "userdata" and "cache" if we |
| 43 | are signing the target files. |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 44 | """ |
| 45 | |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 46 | from __future__ import print_function |
| 47 | |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 48 | import sys |
| 49 | |
| 50 | if sys.hexversion < 0x02070000: |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 51 | print("Python 2.7 or newer is required.", file=sys.stderr) |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 52 | sys.exit(1) |
| 53 | |
Tao Bao | 822f584 | 2015-09-30 16:01:14 -0700 | [diff] [blame] | 54 | import datetime |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 55 | import errno |
| 56 | import os |
David Zeuthen | d995f4b | 2016-01-29 16:59:17 -0500 | [diff] [blame] | 57 | import shlex |
Ying Wang | 2a04839 | 2015-06-25 13:56:53 -0700 | [diff] [blame] | 58 | import shutil |
David Zeuthen | d995f4b | 2016-01-29 16:59:17 -0500 | [diff] [blame] | 59 | import subprocess |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 60 | import tempfile |
| 61 | import zipfile |
| 62 | |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 63 | import build_image |
| 64 | import common |
Tianjie Xu | f1a1318 | 2017-01-19 17:39:30 -0800 | [diff] [blame^] | 65 | import rangelib |
Tianjie Xu | cfa8622 | 2016-03-07 16:31:19 -0800 | [diff] [blame] | 66 | import sparse_img |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 67 | |
| 68 | OPTIONS = common.OPTIONS |
| 69 | |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 70 | OPTIONS.add_missing = False |
| 71 | OPTIONS.rebuild_recovery = False |
Baligh Uddin | 59f4ff1 | 2015-09-16 21:20:30 -0700 | [diff] [blame] | 72 | OPTIONS.replace_verity_public_key = False |
| 73 | OPTIONS.replace_verity_private_key = False |
Tianjie Xu | b48589a | 2016-08-03 19:21:52 -0700 | [diff] [blame] | 74 | OPTIONS.is_signing = False |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 75 | |
Tianjie Xu | cfa8622 | 2016-03-07 16:31:19 -0800 | [diff] [blame] | 76 | def GetCareMap(which, imgname): |
| 77 | """Generate care_map of system (or vendor) partition""" |
| 78 | |
| 79 | assert which in ("system", "vendor") |
| 80 | _, blk_device = common.GetTypeAndDevice("/" + which, OPTIONS.info_dict) |
| 81 | |
| 82 | simg = sparse_img.SparseImage(imgname) |
| 83 | care_map_list = [] |
| 84 | care_map_list.append(blk_device) |
| 85 | care_map_list.append(simg.care_map.to_string_raw()) |
Tianjie Xu | f1a1318 | 2017-01-19 17:39:30 -0800 | [diff] [blame^] | 86 | |
| 87 | care_map_ranges = simg.care_map |
| 88 | key = which + "_adjusted_partition_size" |
| 89 | adjusted_blocks = OPTIONS.info_dict.get(key) |
| 90 | if adjusted_blocks: |
| 91 | assert adjusted_blocks > 0, "blocks should be positive for " + which |
| 92 | care_map_ranges = care_map_ranges.intersect(rangelib.RangeSet( |
| 93 | "0-%d" % (adjusted_blocks,))) |
| 94 | |
| 95 | care_map_list.append(care_map_ranges.to_string_raw()) |
Tianjie Xu | cfa8622 | 2016-03-07 16:31:19 -0800 | [diff] [blame] | 96 | return care_map_list |
| 97 | |
| 98 | |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 99 | def AddSystem(output_zip, prefix="IMAGES/", recovery_img=None, boot_img=None): |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 100 | """Turn the contents of SYSTEM into a system image and store it in |
David Zeuthen | d995f4b | 2016-01-29 16:59:17 -0500 | [diff] [blame] | 101 | output_zip. Returns the name of the system image file.""" |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 102 | |
| 103 | prebuilt_path = os.path.join(OPTIONS.input_tmp, prefix, "system.img") |
| 104 | if os.path.exists(prebuilt_path): |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 105 | print("system.img already exists in %s, no need to rebuild..." % (prefix,)) |
David Zeuthen | d995f4b | 2016-01-29 16:59:17 -0500 | [diff] [blame] | 106 | return prebuilt_path |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 107 | |
| 108 | def output_sink(fn, data): |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 109 | ofile = open(os.path.join(OPTIONS.input_tmp, "SYSTEM", fn), "w") |
| 110 | ofile.write(data) |
| 111 | ofile.close() |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 112 | |
| 113 | if OPTIONS.rebuild_recovery: |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 114 | print("Building new recovery patch") |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 115 | common.MakeRecoveryPatch(OPTIONS.input_tmp, output_sink, recovery_img, |
| 116 | boot_img, info_dict=OPTIONS.info_dict) |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 117 | |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 118 | block_list = common.MakeTempFile(prefix="system-blocklist-", suffix=".map") |
| 119 | imgname = BuildSystem(OPTIONS.input_tmp, OPTIONS.info_dict, |
| 120 | block_list=block_list) |
David Zeuthen | d995f4b | 2016-01-29 16:59:17 -0500 | [diff] [blame] | 121 | |
Dan Albert | 8e0178d | 2015-01-27 15:53:15 -0800 | [diff] [blame] | 122 | common.ZipWrite(output_zip, imgname, prefix + "system.img") |
| 123 | common.ZipWrite(output_zip, block_list, prefix + "system.map") |
David Zeuthen | d995f4b | 2016-01-29 16:59:17 -0500 | [diff] [blame] | 124 | return imgname |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 125 | |
| 126 | |
| 127 | def BuildSystem(input_dir, info_dict, block_list=None): |
| 128 | """Build the (sparse) system image and return the name of a temp |
| 129 | file containing it.""" |
| 130 | return CreateImage(input_dir, info_dict, "system", block_list=block_list) |
| 131 | |
| 132 | |
Alex Light | 4e358ab | 2016-06-16 14:47:10 -0700 | [diff] [blame] | 133 | def AddSystemOther(output_zip, prefix="IMAGES/"): |
| 134 | """Turn the contents of SYSTEM_OTHER into a system_other image |
| 135 | and store it in output_zip.""" |
| 136 | |
| 137 | prebuilt_path = os.path.join(OPTIONS.input_tmp, prefix, "system_other.img") |
| 138 | if os.path.exists(prebuilt_path): |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 139 | print("system_other.img already exists in %s, no need to rebuild..." % ( |
| 140 | prefix,)) |
Alex Light | 4e358ab | 2016-06-16 14:47:10 -0700 | [diff] [blame] | 141 | return |
| 142 | |
| 143 | imgname = BuildSystemOther(OPTIONS.input_tmp, OPTIONS.info_dict) |
| 144 | common.ZipWrite(output_zip, imgname, prefix + "system_other.img") |
| 145 | |
| 146 | def BuildSystemOther(input_dir, info_dict): |
| 147 | """Build the (sparse) system_other image and return the name of a temp |
| 148 | file containing it.""" |
| 149 | return CreateImage(input_dir, info_dict, "system_other", block_list=None) |
| 150 | |
| 151 | |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 152 | def AddVendor(output_zip, prefix="IMAGES/"): |
| 153 | """Turn the contents of VENDOR into a vendor image and store in it |
| 154 | output_zip.""" |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 155 | |
| 156 | prebuilt_path = os.path.join(OPTIONS.input_tmp, prefix, "vendor.img") |
| 157 | if os.path.exists(prebuilt_path): |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 158 | print("vendor.img already exists in %s, no need to rebuild..." % (prefix,)) |
Tianjie Xu | cfa8622 | 2016-03-07 16:31:19 -0800 | [diff] [blame] | 159 | return prebuilt_path |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 160 | |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 161 | block_list = common.MakeTempFile(prefix="vendor-blocklist-", suffix=".map") |
| 162 | imgname = BuildVendor(OPTIONS.input_tmp, OPTIONS.info_dict, |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 163 | block_list=block_list) |
Dan Albert | 8e0178d | 2015-01-27 15:53:15 -0800 | [diff] [blame] | 164 | common.ZipWrite(output_zip, imgname, prefix + "vendor.img") |
| 165 | common.ZipWrite(output_zip, block_list, prefix + "vendor.map") |
Tianjie Xu | cfa8622 | 2016-03-07 16:31:19 -0800 | [diff] [blame] | 166 | return imgname |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 167 | |
| 168 | |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 169 | def BuildVendor(input_dir, info_dict, block_list=None): |
| 170 | """Build the (sparse) vendor image and return the name of a temp |
| 171 | file containing it.""" |
| 172 | return CreateImage(input_dir, info_dict, "vendor", block_list=block_list) |
| 173 | |
| 174 | |
| 175 | def CreateImage(input_dir, info_dict, what, block_list=None): |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 176 | print("creating " + what + ".img...") |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 177 | |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 178 | img = common.MakeTempFile(prefix=what + "-", suffix=".img") |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 179 | |
| 180 | # The name of the directory it is making an image out of matters to |
| 181 | # mkyaffs2image. It wants "system" but we have a directory named |
| 182 | # "SYSTEM", so create a symlink. |
| 183 | try: |
| 184 | os.symlink(os.path.join(input_dir, what.upper()), |
| 185 | os.path.join(input_dir, what)) |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 186 | except OSError as e: |
| 187 | # bogus error on my mac version? |
| 188 | # File "./build/tools/releasetools/img_from_target_files" |
| 189 | # os.path.join(OPTIONS.input_tmp, "system")) |
| 190 | # OSError: [Errno 17] File exists |
| 191 | if e.errno == errno.EEXIST: |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 192 | pass |
| 193 | |
| 194 | image_props = build_image.ImagePropFromGlobalDict(info_dict, what) |
| 195 | fstab = info_dict["fstab"] |
Tianjie Xu | cfa8622 | 2016-03-07 16:31:19 -0800 | [diff] [blame] | 196 | mount_point = "/" + what |
| 197 | if fstab and mount_point in fstab: |
| 198 | image_props["fs_type"] = fstab[mount_point].fs_type |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 199 | |
Tao Bao | 822f584 | 2015-09-30 16:01:14 -0700 | [diff] [blame] | 200 | # Use a fixed timestamp (01/01/2009) when packaging the image. |
| 201 | # Bug: 24377993 |
| 202 | epoch = datetime.datetime.fromtimestamp(0) |
| 203 | timestamp = (datetime.datetime(2009, 1, 1) - epoch).total_seconds() |
| 204 | image_props["timestamp"] = int(timestamp) |
| 205 | |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 206 | if what == "system": |
| 207 | fs_config_prefix = "" |
| 208 | else: |
| 209 | fs_config_prefix = what + "_" |
| 210 | |
| 211 | fs_config = os.path.join( |
| 212 | input_dir, "META/" + fs_config_prefix + "filesystem_config.txt") |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 213 | if not os.path.exists(fs_config): |
| 214 | fs_config = None |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 215 | |
Ying Wang | a2292c9 | 2015-03-24 19:07:40 -0700 | [diff] [blame] | 216 | # Override values loaded from info_dict. |
| 217 | if fs_config: |
| 218 | image_props["fs_config"] = fs_config |
Ying Wang | a2292c9 | 2015-03-24 19:07:40 -0700 | [diff] [blame] | 219 | if block_list: |
| 220 | image_props["block_list"] = block_list |
Ying Wang | a2292c9 | 2015-03-24 19:07:40 -0700 | [diff] [blame] | 221 | |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 222 | succ = build_image.BuildImage(os.path.join(input_dir, what), |
Ying Wang | a2292c9 | 2015-03-24 19:07:40 -0700 | [diff] [blame] | 223 | image_props, img) |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 224 | assert succ, "build " + what + ".img image failed" |
| 225 | |
Tianjie Xu | f1a1318 | 2017-01-19 17:39:30 -0800 | [diff] [blame^] | 226 | is_verity_partition = "verity_block_device" in image_props |
| 227 | verity_supported = image_props.get("verity") == "true" |
| 228 | if is_verity_partition and verity_supported: |
| 229 | adjusted_blocks_value = image_props.get("partition_size") |
| 230 | if adjusted_blocks_value: |
| 231 | adjusted_blocks_key = what + "_adjusted_partition_size" |
| 232 | info_dict[adjusted_blocks_key] = int(adjusted_blocks_value)/4096 - 1 |
| 233 | |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 234 | return img |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 235 | |
| 236 | |
| 237 | def AddUserdata(output_zip, prefix="IMAGES/"): |
Ying Wang | 2a04839 | 2015-06-25 13:56:53 -0700 | [diff] [blame] | 238 | """Create a userdata image and store it in output_zip. |
| 239 | |
| 240 | In most case we just create and store an empty userdata.img; |
| 241 | But the invoker can also request to create userdata.img with real |
| 242 | data from the target files, by setting "userdata_img_with_data=true" |
| 243 | in OPTIONS.info_dict. |
| 244 | """ |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 245 | |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 246 | prebuilt_path = os.path.join(OPTIONS.input_tmp, prefix, "userdata.img") |
| 247 | if os.path.exists(prebuilt_path): |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 248 | print("userdata.img already exists in %s, no need to rebuild..." % ( |
| 249 | prefix,)) |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 250 | return |
| 251 | |
Elliott Hughes | 305b088 | 2016-06-15 17:04:54 -0700 | [diff] [blame] | 252 | # Skip userdata.img if no size. |
Tao Bao | 2c15d9e | 2015-07-09 11:51:16 -0700 | [diff] [blame] | 253 | image_props = build_image.ImagePropFromGlobalDict(OPTIONS.info_dict, "data") |
Elliott Hughes | 305b088 | 2016-06-15 17:04:54 -0700 | [diff] [blame] | 254 | if not image_props.get("partition_size"): |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 255 | return |
| 256 | |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 257 | print("creating userdata.img...") |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 258 | |
Tao Bao | 822f584 | 2015-09-30 16:01:14 -0700 | [diff] [blame] | 259 | # Use a fixed timestamp (01/01/2009) when packaging the image. |
| 260 | # Bug: 24377993 |
| 261 | epoch = datetime.datetime.fromtimestamp(0) |
| 262 | timestamp = (datetime.datetime(2009, 1, 1) - epoch).total_seconds() |
| 263 | image_props["timestamp"] = int(timestamp) |
| 264 | |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 265 | # The name of the directory it is making an image out of matters to |
| 266 | # mkyaffs2image. So we create a temp dir, and within it we create an |
Ying Wang | 2a04839 | 2015-06-25 13:56:53 -0700 | [diff] [blame] | 267 | # empty dir named "data", or a symlink to the DATA dir, |
| 268 | # and build the image from that. |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 269 | temp_dir = tempfile.mkdtemp() |
| 270 | user_dir = os.path.join(temp_dir, "data") |
Ying Wang | 2a04839 | 2015-06-25 13:56:53 -0700 | [diff] [blame] | 271 | empty = (OPTIONS.info_dict.get("userdata_img_with_data") != "true") |
| 272 | if empty: |
| 273 | # Create an empty dir. |
| 274 | os.mkdir(user_dir) |
| 275 | else: |
| 276 | # Symlink to the DATA dir. |
| 277 | os.symlink(os.path.join(OPTIONS.input_tmp, "DATA"), |
| 278 | user_dir) |
| 279 | |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 280 | img = tempfile.NamedTemporaryFile() |
| 281 | |
| 282 | fstab = OPTIONS.info_dict["fstab"] |
| 283 | if fstab: |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 284 | image_props["fs_type"] = fstab["/data"].fs_type |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 285 | succ = build_image.BuildImage(user_dir, image_props, img.name) |
| 286 | assert succ, "build userdata.img image failed" |
| 287 | |
| 288 | common.CheckSize(img.name, "userdata.img", OPTIONS.info_dict) |
Tao Bao | 2ed665a | 2015-04-01 11:21:55 -0700 | [diff] [blame] | 289 | common.ZipWrite(output_zip, img.name, prefix + "userdata.img") |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 290 | img.close() |
Ying Wang | 2a04839 | 2015-06-25 13:56:53 -0700 | [diff] [blame] | 291 | shutil.rmtree(temp_dir) |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 292 | |
| 293 | |
David Zeuthen | 2ce63ed | 2016-09-15 13:43:54 -0400 | [diff] [blame] | 294 | def AddVBMeta(output_zip, boot_img_path, system_img_path, prefix="IMAGES/"): |
| 295 | """Create a VBMeta image and store it in output_zip.""" |
| 296 | _, img_file_name = tempfile.mkstemp() |
| 297 | avbtool = os.getenv('AVBTOOL') or "avbtool" |
| 298 | cmd = [avbtool, "make_vbmeta_image", |
| 299 | "--output", img_file_name, |
| 300 | "--include_descriptors_from_image", boot_img_path, |
| 301 | "--include_descriptors_from_image", system_img_path, |
| 302 | "--generate_dm_verity_cmdline_from_hashtree", system_img_path] |
| 303 | common.AppendAVBSigningArgs(cmd) |
| 304 | args = OPTIONS.info_dict.get("board_avb_make_vbmeta_image_args", None) |
| 305 | if args and args.strip(): |
| 306 | cmd.extend(shlex.split(args)) |
| 307 | p = common.Run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) |
| 308 | p.communicate() |
| 309 | assert p.returncode == 0, "avbtool make_vbmeta_image failed" |
| 310 | common.ZipWrite(output_zip, img_file_name, prefix + "vbmeta.img") |
| 311 | |
| 312 | |
David Zeuthen | 2532862 | 2016-04-08 15:08:03 -0400 | [diff] [blame] | 313 | def AddPartitionTable(output_zip, prefix="IMAGES/"): |
| 314 | """Create a partition table image and store it in output_zip.""" |
| 315 | |
| 316 | _, img_file_name = tempfile.mkstemp() |
| 317 | _, bpt_file_name = tempfile.mkstemp() |
| 318 | |
| 319 | # use BPTTOOL from environ, or "bpttool" if empty or not set. |
| 320 | bpttool = os.getenv("BPTTOOL") or "bpttool" |
| 321 | cmd = [bpttool, "make_table", "--output_json", bpt_file_name, |
| 322 | "--output_gpt", img_file_name] |
| 323 | input_files_str = OPTIONS.info_dict["board_bpt_input_files"] |
| 324 | input_files = input_files_str.split(" ") |
| 325 | for i in input_files: |
| 326 | cmd.extend(["--input", i]) |
| 327 | disk_size = OPTIONS.info_dict.get("board_bpt_disk_size") |
| 328 | if disk_size: |
| 329 | cmd.extend(["--disk_size", disk_size]) |
| 330 | args = OPTIONS.info_dict.get("board_bpt_make_table_args") |
| 331 | if args: |
| 332 | cmd.extend(shlex.split(args)) |
| 333 | |
| 334 | p = common.Run(cmd, stdout=subprocess.PIPE) |
| 335 | p.communicate() |
| 336 | assert p.returncode == 0, "bpttool make_table failed" |
| 337 | |
| 338 | common.ZipWrite(output_zip, img_file_name, prefix + "partition-table.img") |
| 339 | common.ZipWrite(output_zip, bpt_file_name, prefix + "partition-table.bpt") |
| 340 | |
| 341 | |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 342 | def AddCache(output_zip, prefix="IMAGES/"): |
| 343 | """Create an empty cache image and store it in output_zip.""" |
| 344 | |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 345 | prebuilt_path = os.path.join(OPTIONS.input_tmp, prefix, "cache.img") |
| 346 | if os.path.exists(prebuilt_path): |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 347 | print("cache.img already exists in %s, no need to rebuild..." % (prefix,)) |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 348 | return |
| 349 | |
Tao Bao | 2c15d9e | 2015-07-09 11:51:16 -0700 | [diff] [blame] | 350 | image_props = build_image.ImagePropFromGlobalDict(OPTIONS.info_dict, "cache") |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 351 | # The build system has to explicitly request for cache.img. |
| 352 | if "fs_type" not in image_props: |
| 353 | return |
| 354 | |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 355 | print("creating cache.img...") |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 356 | |
Tao Bao | 822f584 | 2015-09-30 16:01:14 -0700 | [diff] [blame] | 357 | # Use a fixed timestamp (01/01/2009) when packaging the image. |
| 358 | # Bug: 24377993 |
| 359 | epoch = datetime.datetime.fromtimestamp(0) |
| 360 | timestamp = (datetime.datetime(2009, 1, 1) - epoch).total_seconds() |
| 361 | image_props["timestamp"] = int(timestamp) |
| 362 | |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 363 | # The name of the directory it is making an image out of matters to |
| 364 | # mkyaffs2image. So we create a temp dir, and within it we create an |
| 365 | # empty dir named "cache", and build the image from that. |
| 366 | temp_dir = tempfile.mkdtemp() |
| 367 | user_dir = os.path.join(temp_dir, "cache") |
| 368 | os.mkdir(user_dir) |
| 369 | img = tempfile.NamedTemporaryFile() |
| 370 | |
| 371 | fstab = OPTIONS.info_dict["fstab"] |
| 372 | if fstab: |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 373 | image_props["fs_type"] = fstab["/cache"].fs_type |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 374 | succ = build_image.BuildImage(user_dir, image_props, img.name) |
| 375 | assert succ, "build cache.img image failed" |
| 376 | |
| 377 | common.CheckSize(img.name, "cache.img", OPTIONS.info_dict) |
Tao Bao | 2ed665a | 2015-04-01 11:21:55 -0700 | [diff] [blame] | 378 | common.ZipWrite(output_zip, img.name, prefix + "cache.img") |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 379 | img.close() |
| 380 | os.rmdir(user_dir) |
| 381 | os.rmdir(temp_dir) |
| 382 | |
| 383 | |
| 384 | def AddImagesToTargetFiles(filename): |
| 385 | OPTIONS.input_tmp, input_zip = common.UnzipTemp(filename) |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 386 | |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 387 | if not OPTIONS.add_missing: |
| 388 | for n in input_zip.namelist(): |
| 389 | if n.startswith("IMAGES/"): |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 390 | print("target_files appears to already contain images.") |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 391 | sys.exit(1) |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 392 | |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 393 | try: |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 394 | input_zip.getinfo("VENDOR/") |
| 395 | has_vendor = True |
| 396 | except KeyError: |
| 397 | has_vendor = False |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 398 | |
Alex Light | 4e358ab | 2016-06-16 14:47:10 -0700 | [diff] [blame] | 399 | has_system_other = "SYSTEM_OTHER/" in input_zip.namelist() |
| 400 | |
Tao Bao | 2c15d9e | 2015-07-09 11:51:16 -0700 | [diff] [blame] | 401 | OPTIONS.info_dict = common.LoadInfoDict(input_zip, OPTIONS.input_tmp) |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 402 | |
Tao Bao | 2ed665a | 2015-04-01 11:21:55 -0700 | [diff] [blame] | 403 | common.ZipClose(input_zip) |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 404 | output_zip = zipfile.ZipFile(filename, "a", |
Tao Bao | 9c84e50 | 2016-08-22 10:31:05 -0700 | [diff] [blame] | 405 | compression=zipfile.ZIP_DEFLATED, |
| 406 | allowZip64=True) |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 407 | |
Tao Bao | db45efa | 2015-10-27 19:25:18 -0700 | [diff] [blame] | 408 | has_recovery = (OPTIONS.info_dict.get("no_recovery") != "true") |
David Zeuthen | d995f4b | 2016-01-29 16:59:17 -0500 | [diff] [blame] | 409 | system_root_image = (OPTIONS.info_dict.get("system_root_image", None) == "true") |
Tao Bao | db45efa | 2015-10-27 19:25:18 -0700 | [diff] [blame] | 410 | |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 411 | def banner(s): |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 412 | print("\n\n++++ " + s + " ++++\n\n") |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 413 | |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 414 | prebuilt_path = os.path.join(OPTIONS.input_tmp, "IMAGES", "boot.img") |
| 415 | boot_image = None |
| 416 | if os.path.exists(prebuilt_path): |
David Zeuthen | d995f4b | 2016-01-29 16:59:17 -0500 | [diff] [blame] | 417 | banner("boot") |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 418 | print("boot.img already exists in IMAGES/, no need to rebuild...") |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 419 | if OPTIONS.rebuild_recovery: |
| 420 | boot_image = common.GetBootableImage( |
| 421 | "IMAGES/boot.img", "boot.img", OPTIONS.input_tmp, "BOOT") |
| 422 | else: |
David Zeuthen | 2ce63ed | 2016-09-15 13:43:54 -0400 | [diff] [blame] | 423 | banner("boot") |
| 424 | boot_image = common.GetBootableImage( |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 425 | "IMAGES/boot.img", "boot.img", OPTIONS.input_tmp, "BOOT") |
David Zeuthen | 2ce63ed | 2016-09-15 13:43:54 -0400 | [diff] [blame] | 426 | if boot_image: |
| 427 | boot_image.AddToZip(output_zip) |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 428 | |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 429 | recovery_image = None |
Tao Bao | db45efa | 2015-10-27 19:25:18 -0700 | [diff] [blame] | 430 | if has_recovery: |
| 431 | banner("recovery") |
| 432 | prebuilt_path = os.path.join(OPTIONS.input_tmp, "IMAGES", "recovery.img") |
| 433 | if os.path.exists(prebuilt_path): |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 434 | print("recovery.img already exists in IMAGES/, no need to rebuild...") |
Tao Bao | db45efa | 2015-10-27 19:25:18 -0700 | [diff] [blame] | 435 | if OPTIONS.rebuild_recovery: |
| 436 | recovery_image = common.GetBootableImage( |
| 437 | "IMAGES/recovery.img", "recovery.img", OPTIONS.input_tmp, |
| 438 | "RECOVERY") |
| 439 | else: |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 440 | recovery_image = common.GetBootableImage( |
| 441 | "IMAGES/recovery.img", "recovery.img", OPTIONS.input_tmp, "RECOVERY") |
Tao Bao | db45efa | 2015-10-27 19:25:18 -0700 | [diff] [blame] | 442 | if recovery_image: |
| 443 | recovery_image.AddToZip(output_zip) |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 444 | |
Tao Bao | d42e97e | 2016-11-30 12:11:57 -0800 | [diff] [blame] | 445 | banner("recovery (two-step image)") |
| 446 | # The special recovery.img for two-step package use. |
| 447 | recovery_two_step_image = common.GetBootableImage( |
| 448 | "IMAGES/recovery-two-step.img", "recovery-two-step.img", |
| 449 | OPTIONS.input_tmp, "RECOVERY", two_step_image=True) |
| 450 | if recovery_two_step_image: |
| 451 | recovery_two_step_image.AddToZip(output_zip) |
| 452 | |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 453 | banner("system") |
David Zeuthen | d995f4b | 2016-01-29 16:59:17 -0500 | [diff] [blame] | 454 | system_img_path = AddSystem( |
| 455 | output_zip, recovery_img=recovery_image, boot_img=boot_image) |
Tianjie Xu | 737afb9 | 2016-07-11 11:42:53 -0700 | [diff] [blame] | 456 | vendor_img_path = None |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 457 | if has_vendor: |
| 458 | banner("vendor") |
Tianjie Xu | 737afb9 | 2016-07-11 11:42:53 -0700 | [diff] [blame] | 459 | vendor_img_path = AddVendor(output_zip) |
Alex Light | 4e358ab | 2016-06-16 14:47:10 -0700 | [diff] [blame] | 460 | if has_system_other: |
| 461 | banner("system_other") |
| 462 | AddSystemOther(output_zip) |
Tianjie Xu | b48589a | 2016-08-03 19:21:52 -0700 | [diff] [blame] | 463 | if not OPTIONS.is_signing: |
| 464 | banner("userdata") |
| 465 | AddUserdata(output_zip) |
| 466 | banner("cache") |
| 467 | AddCache(output_zip) |
David Zeuthen | 2532862 | 2016-04-08 15:08:03 -0400 | [diff] [blame] | 468 | if OPTIONS.info_dict.get("board_bpt_enable", None) == "true": |
| 469 | banner("partition-table") |
| 470 | AddPartitionTable(output_zip) |
David Zeuthen | 2ce63ed | 2016-09-15 13:43:54 -0400 | [diff] [blame] | 471 | if OPTIONS.info_dict.get("board_avb_enable", None) == "true": |
| 472 | banner("vbmeta") |
| 473 | boot_contents = boot_image.WriteToTemp() |
| 474 | AddVBMeta(output_zip, boot_contents.name, system_img_path) |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 475 | |
Wei Wang | 2e735ca | 2016-05-10 22:48:13 -0700 | [diff] [blame] | 476 | # For devices using A/B update, copy over images from RADIO/ and/or |
| 477 | # VENDOR_IMAGES/ to IMAGES/ and make sure we have all the needed |
| 478 | # images ready under IMAGES/. All images should have '.img' as extension. |
Tianjie Xu | aaca421 | 2016-06-28 14:34:03 -0700 | [diff] [blame] | 479 | banner("radio") |
Tao Bao | a0421cd | 2015-11-16 16:32:27 -0800 | [diff] [blame] | 480 | ab_partitions = os.path.join(OPTIONS.input_tmp, "META", "ab_partitions.txt") |
| 481 | if os.path.exists(ab_partitions): |
| 482 | with open(ab_partitions, 'r') as f: |
| 483 | lines = f.readlines() |
Tianjie Xu | cfa8622 | 2016-03-07 16:31:19 -0800 | [diff] [blame] | 484 | # For devices using A/B update, generate care_map for system and vendor |
| 485 | # partitions (if present), then write this file to target_files package. |
| 486 | care_map_list = [] |
Tao Bao | a0421cd | 2015-11-16 16:32:27 -0800 | [diff] [blame] | 487 | for line in lines: |
Tianjie Xu | cfa8622 | 2016-03-07 16:31:19 -0800 | [diff] [blame] | 488 | if line.strip() == "system" and OPTIONS.info_dict.get( |
| 489 | "system_verity_block_device", None) is not None: |
Tianjie Xu | 737afb9 | 2016-07-11 11:42:53 -0700 | [diff] [blame] | 490 | assert os.path.exists(system_img_path) |
| 491 | care_map_list += GetCareMap("system", system_img_path) |
Tianjie Xu | cfa8622 | 2016-03-07 16:31:19 -0800 | [diff] [blame] | 492 | if line.strip() == "vendor" and OPTIONS.info_dict.get( |
| 493 | "vendor_verity_block_device", None) is not None: |
Tianjie Xu | 737afb9 | 2016-07-11 11:42:53 -0700 | [diff] [blame] | 494 | assert os.path.exists(vendor_img_path) |
| 495 | care_map_list += GetCareMap("vendor", vendor_img_path) |
Tianjie Xu | cfa8622 | 2016-03-07 16:31:19 -0800 | [diff] [blame] | 496 | |
Tao Bao | a0421cd | 2015-11-16 16:32:27 -0800 | [diff] [blame] | 497 | img_name = line.strip() + ".img" |
Tianjie Xu | aaca421 | 2016-06-28 14:34:03 -0700 | [diff] [blame] | 498 | prebuilt_path = os.path.join(OPTIONS.input_tmp, "IMAGES", img_name) |
| 499 | if os.path.exists(prebuilt_path): |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 500 | print("%s already exists, no need to overwrite..." % (img_name,)) |
Tianjie Xu | aaca421 | 2016-06-28 14:34:03 -0700 | [diff] [blame] | 501 | continue |
| 502 | |
Tao Bao | a0421cd | 2015-11-16 16:32:27 -0800 | [diff] [blame] | 503 | img_radio_path = os.path.join(OPTIONS.input_tmp, "RADIO", img_name) |
Wei Wang | 2e735ca | 2016-05-10 22:48:13 -0700 | [diff] [blame] | 504 | img_vendor_dir = os.path.join( |
| 505 | OPTIONS.input_tmp, "VENDOR_IMAGES") |
Tao Bao | a0421cd | 2015-11-16 16:32:27 -0800 | [diff] [blame] | 506 | if os.path.exists(img_radio_path): |
| 507 | common.ZipWrite(output_zip, img_radio_path, |
| 508 | os.path.join("IMAGES", img_name)) |
Wei Wang | 2e735ca | 2016-05-10 22:48:13 -0700 | [diff] [blame] | 509 | else: |
| 510 | for root, _, files in os.walk(img_vendor_dir): |
| 511 | if img_name in files: |
| 512 | common.ZipWrite(output_zip, os.path.join(root, img_name), |
| 513 | os.path.join("IMAGES", img_name)) |
| 514 | break |
Tao Bao | a0421cd | 2015-11-16 16:32:27 -0800 | [diff] [blame] | 515 | |
| 516 | # Zip spec says: All slashes MUST be forward slashes. |
| 517 | img_path = 'IMAGES/' + img_name |
| 518 | assert img_path in output_zip.namelist(), "cannot find " + img_name |
| 519 | |
Tianjie Xu | cfa8622 | 2016-03-07 16:31:19 -0800 | [diff] [blame] | 520 | if care_map_list: |
| 521 | file_path = "META/care_map.txt" |
| 522 | common.ZipWriteStr(output_zip, file_path, '\n'.join(care_map_list)) |
| 523 | |
Tao Bao | 2ed665a | 2015-04-01 11:21:55 -0700 | [diff] [blame] | 524 | common.ZipClose(output_zip) |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 525 | |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 526 | def main(argv): |
Baligh Uddin | 59f4ff1 | 2015-09-16 21:20:30 -0700 | [diff] [blame] | 527 | def option_handler(o, a): |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 528 | if o in ("-a", "--add_missing"): |
| 529 | OPTIONS.add_missing = True |
| 530 | elif o in ("-r", "--rebuild_recovery",): |
| 531 | OPTIONS.rebuild_recovery = True |
Baligh Uddin | 59f4ff1 | 2015-09-16 21:20:30 -0700 | [diff] [blame] | 532 | elif o == "--replace_verity_private_key": |
| 533 | OPTIONS.replace_verity_private_key = (True, a) |
| 534 | elif o == "--replace_verity_public_key": |
| 535 | OPTIONS.replace_verity_public_key = (True, a) |
Tianjie Xu | b48589a | 2016-08-03 19:21:52 -0700 | [diff] [blame] | 536 | elif o == "--is_signing": |
| 537 | OPTIONS.is_signing = True |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 538 | else: |
| 539 | return False |
| 540 | return True |
| 541 | |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 542 | args = common.ParseOptions( |
| 543 | argv, __doc__, extra_opts="ar", |
Baligh Uddin | 59f4ff1 | 2015-09-16 21:20:30 -0700 | [diff] [blame] | 544 | extra_long_opts=["add_missing", "rebuild_recovery", |
| 545 | "replace_verity_public_key=", |
| 546 | "replace_verity_private_key=", |
Tao Bao | 4581042 | 2016-10-17 16:20:12 -0700 | [diff] [blame] | 547 | "is_signing"], |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 548 | extra_option_handler=option_handler) |
Michael Runge | 2e0d8fc | 2014-11-13 21:41:08 -0800 | [diff] [blame] | 549 | |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 550 | |
| 551 | if len(args) != 1: |
| 552 | common.Usage(__doc__) |
| 553 | sys.exit(1) |
| 554 | |
| 555 | AddImagesToTargetFiles(args[0]) |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 556 | print("done.") |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 557 | |
| 558 | if __name__ == '__main__': |
| 559 | try: |
| 560 | common.CloseInheritedPipes() |
| 561 | main(sys.argv[1:]) |
Dan Albert | 8b72aef | 2015-03-23 19:13:21 -0700 | [diff] [blame] | 562 | except common.ExternalError as e: |
Tao Bao | 89fbb0f | 2017-01-10 10:47:58 -0800 | [diff] [blame] | 563 | print("\n ERROR: %s\n" % (e,)) |
Doug Zongker | 3c84f56 | 2014-07-31 11:06:30 -0700 | [diff] [blame] | 564 | sys.exit(1) |
Doug Zongker | fc44a51 | 2014-08-26 13:10:25 -0700 | [diff] [blame] | 565 | finally: |
| 566 | common.Cleanup() |