build_image.py revision 2cd51cc7117a19d893f3734ef28c217279dc8967
1#!/usr/bin/env python 2# 3# Copyright (C) 2011 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""" 18Build image output_image_file from input_directory and properties_file. 19 20Usage: build_image input_directory properties_file output_image_file 21 22""" 23import os 24import os.path 25import subprocess 26import sys 27import commands 28import shutil 29import tempfile 30 31FIXED_SALT = "aee087a5be3b982978c923f566a94613496b417f2af592639bc80d141e34dfe7" 32 33def RunCommand(cmd): 34 """ Echo and run the given command 35 36 Args: 37 cmd: the command represented as a list of strings. 38 Returns: 39 The exit code. 40 """ 41 print "Running: ", " ".join(cmd) 42 p = subprocess.Popen(cmd) 43 p.communicate() 44 return p.returncode 45 46def GetVerityTreeSize(partition_size): 47 cmd = "build_verity_tree -s %d" 48 cmd %= partition_size 49 status, output = commands.getstatusoutput(cmd) 50 if status: 51 print output 52 return False, 0 53 return True, int(output) 54 55def GetVerityMetadataSize(partition_size): 56 cmd = "system/extras/verity/build_verity_metadata.py -s %d" 57 cmd %= partition_size 58 status, output = commands.getstatusoutput(cmd) 59 if status: 60 print output 61 return False, 0 62 return True, int(output) 63 64def AdjustPartitionSizeForVerity(partition_size): 65 """Modifies the provided partition size to account for the verity metadata. 66 67 This information is used to size the created image appropriately. 68 Args: 69 partition_size: the size of the partition to be verified. 70 Returns: 71 The size of the partition adjusted for verity metadata. 72 """ 73 success, verity_tree_size = GetVerityTreeSize(partition_size) 74 if not success: 75 return 0 76 success, verity_metadata_size = GetVerityMetadataSize(partition_size) 77 if not success: 78 return 0 79 return partition_size - verity_tree_size - verity_metadata_size 80 81def BuildVerityTree(sparse_image_path, verity_image_path, prop_dict): 82 cmd = "build_verity_tree -A %s %s %s" % ( 83 FIXED_SALT, sparse_image_path, verity_image_path) 84 print cmd 85 status, output = commands.getstatusoutput(cmd) 86 if status: 87 print "Could not build verity tree! Error: %s" % output 88 return False 89 root, salt = output.split() 90 prop_dict["verity_root_hash"] = root 91 prop_dict["verity_salt"] = salt 92 return True 93 94def BuildVerityMetadata(image_size, verity_metadata_path, root_hash, salt, 95 block_device, signer_path, key): 96 cmd_template = ( 97 "system/extras/verity/build_verity_metadata.py %s %s %s %s %s %s %s") 98 cmd = cmd_template % (image_size, verity_metadata_path, root_hash, salt, 99 block_device, signer_path, key) 100 print cmd 101 status, output = commands.getstatusoutput(cmd) 102 if status: 103 print "Could not build verity metadata! Error: %s" % output 104 return False 105 return True 106 107def Append2Simg(sparse_image_path, unsparse_image_path, error_message): 108 """Appends the unsparse image to the given sparse image. 109 110 Args: 111 sparse_image_path: the path to the (sparse) image 112 unsparse_image_path: the path to the (unsparse) image 113 Returns: 114 True on success, False on failure. 115 """ 116 cmd = "append2simg %s %s" 117 cmd %= (sparse_image_path, unsparse_image_path) 118 print cmd 119 status, output = commands.getstatusoutput(cmd) 120 if status: 121 print "%s: %s" % (error_message, output) 122 return False 123 return True 124 125def BuildVerifiedImage(data_image_path, verity_image_path, 126 verity_metadata_path): 127 if not Append2Simg(data_image_path, verity_metadata_path, 128 "Could not append verity metadata!"): 129 return False 130 if not Append2Simg(data_image_path, verity_image_path, 131 "Could not append verity tree!"): 132 return False 133 return True 134 135def UnsparseImage(sparse_image_path, replace=True): 136 img_dir = os.path.dirname(sparse_image_path) 137 unsparse_image_path = "unsparse_" + os.path.basename(sparse_image_path) 138 unsparse_image_path = os.path.join(img_dir, unsparse_image_path) 139 if os.path.exists(unsparse_image_path): 140 if replace: 141 os.unlink(unsparse_image_path) 142 else: 143 return True, unsparse_image_path 144 inflate_command = ["simg2img", sparse_image_path, unsparse_image_path] 145 exit_code = RunCommand(inflate_command) 146 if exit_code != 0: 147 os.remove(unsparse_image_path) 148 return False, None 149 return True, unsparse_image_path 150 151def MakeVerityEnabledImage(out_file, prop_dict): 152 """Creates an image that is verifiable using dm-verity. 153 154 Args: 155 out_file: the location to write the verifiable image at 156 prop_dict: a dictionary of properties required for image creation and 157 verification 158 Returns: 159 True on success, False otherwise. 160 """ 161 # get properties 162 image_size = prop_dict["partition_size"] 163 block_dev = prop_dict["verity_block_device"] 164 signer_key = prop_dict["verity_key"] + ".pk8" 165 signer_path = prop_dict["verity_signer_cmd"] 166 167 # make a tempdir 168 tempdir_name = tempfile.mkdtemp(suffix="_verity_images") 169 170 # get partial image paths 171 verity_image_path = os.path.join(tempdir_name, "verity.img") 172 verity_metadata_path = os.path.join(tempdir_name, "verity_metadata.img") 173 174 # build the verity tree and get the root hash and salt 175 if not BuildVerityTree(out_file, verity_image_path, prop_dict): 176 shutil.rmtree(tempdir_name, ignore_errors=True) 177 return False 178 179 # build the metadata blocks 180 root_hash = prop_dict["verity_root_hash"] 181 salt = prop_dict["verity_salt"] 182 if not BuildVerityMetadata(image_size, verity_metadata_path, root_hash, salt, 183 block_dev, signer_path, signer_key): 184 shutil.rmtree(tempdir_name, ignore_errors=True) 185 return False 186 187 # build the full verified image 188 if not BuildVerifiedImage(out_file, 189 verity_image_path, 190 verity_metadata_path): 191 shutil.rmtree(tempdir_name, ignore_errors=True) 192 return False 193 194 shutil.rmtree(tempdir_name, ignore_errors=True) 195 return True 196 197def BuildImage(in_dir, prop_dict, out_file): 198 """Build an image to out_file from in_dir with property prop_dict. 199 200 Args: 201 in_dir: path of input directory. 202 prop_dict: property dictionary. 203 out_file: path of the output image file. 204 205 Returns: 206 True iff the image is built successfully. 207 """ 208 # system_root_image=true: build a system.img that combines the contents of /system 209 # and the ramdisk, and can be mounted at the root of the file system. 210 origin_in = in_dir 211 fs_config = prop_dict.get("fs_config") 212 if (prop_dict.get("system_root_image") == "true" 213 and prop_dict["mount_point"] == "system"): 214 in_dir = tempfile.mkdtemp() 215 # Change the mount point to "/" 216 prop_dict["mount_point"] = "/" 217 if fs_config: 218 # We need to merge the fs_config files of system and ramdisk. 219 fd, merged_fs_config = tempfile.mkstemp(prefix="root_fs_config", 220 suffix=".txt") 221 os.close(fd) 222 with open(merged_fs_config, "w") as fw: 223 if "ramdisk_fs_config" in prop_dict: 224 with open(prop_dict["ramdisk_fs_config"]) as fr: 225 fw.writelines(fr.readlines()) 226 with open(fs_config) as fr: 227 fw.writelines(fr.readlines()) 228 fs_config = merged_fs_config 229 230 build_command = [] 231 fs_type = prop_dict.get("fs_type", "") 232 run_fsck = False 233 234 fs_spans_partition = True 235 if fs_type.startswith("squash"): 236 fs_spans_partition = False 237 238 is_verity_partition = "verity_block_device" in prop_dict 239 verity_supported = prop_dict.get("verity") == "true" 240 # adjust the partition size to make room for the hashes if this is to be verified 241 if verity_supported and is_verity_partition and fs_spans_partition: 242 partition_size = int(prop_dict.get("partition_size")) 243 adjusted_size = AdjustPartitionSizeForVerity(partition_size) 244 if not adjusted_size: 245 return False 246 prop_dict["partition_size"] = str(adjusted_size) 247 prop_dict["original_partition_size"] = str(partition_size) 248 249 if fs_type.startswith("ext"): 250 build_command = ["mkuserimg.sh"] 251 if "extfs_sparse_flag" in prop_dict: 252 build_command.append(prop_dict["extfs_sparse_flag"]) 253 run_fsck = True 254 build_command.extend([in_dir, out_file, fs_type, 255 prop_dict["mount_point"]]) 256 build_command.append(prop_dict["partition_size"]) 257 if "journal_size" in prop_dict: 258 build_command.extend(["-j", prop_dict["journal_size"]]) 259 if "timestamp" in prop_dict: 260 build_command.extend(["-T", str(prop_dict["timestamp"])]) 261 if fs_config: 262 build_command.extend(["-C", fs_config]) 263 if "block_list" in prop_dict: 264 build_command.extend(["-B", prop_dict["block_list"]]) 265 build_command.extend(["-L", prop_dict["mount_point"]]) 266 if "selinux_fc" in prop_dict: 267 build_command.append(prop_dict["selinux_fc"]) 268 elif fs_type.startswith("squash"): 269 build_command = ["mksquashfsimage.sh"] 270 build_command.extend([in_dir, out_file]) 271 build_command.extend(["-s"]) 272 build_command.extend(["-m", prop_dict["mount_point"]]) 273 if "selinux_fc" in prop_dict: 274 build_command.extend(["-c", prop_dict["selinux_fc"]]) 275 elif fs_type.startswith("f2fs"): 276 build_command = ["mkf2fsuserimg.sh"] 277 build_command.extend([out_file, prop_dict["partition_size"]]) 278 else: 279 build_command = ["mkyaffs2image", "-f"] 280 if prop_dict.get("mkyaffs2_extra_flags", None): 281 build_command.extend(prop_dict["mkyaffs2_extra_flags"].split()) 282 build_command.append(in_dir) 283 build_command.append(out_file) 284 if "selinux_fc" in prop_dict: 285 build_command.append(prop_dict["selinux_fc"]) 286 build_command.append(prop_dict["mount_point"]) 287 288 if in_dir != origin_in: 289 # Construct a staging directory of the root file system. 290 ramdisk_dir = prop_dict.get("ramdisk_dir") 291 if ramdisk_dir: 292 shutil.rmtree(in_dir) 293 shutil.copytree(ramdisk_dir, in_dir, symlinks=True) 294 staging_system = os.path.join(in_dir, "system") 295 shutil.rmtree(staging_system, ignore_errors=True) 296 shutil.copytree(origin_in, staging_system, symlinks=True) 297 try: 298 exit_code = RunCommand(build_command) 299 finally: 300 if in_dir != origin_in: 301 # Clean up temporary directories and files. 302 shutil.rmtree(in_dir, ignore_errors=True) 303 if fs_config: 304 os.remove(fs_config) 305 if exit_code != 0: 306 return False 307 308 if not fs_spans_partition: 309 mount_point = prop_dict.get("mount_point") 310 partition_size = int(prop_dict.get("partition_size")) 311 image_size = os.stat(out_file).st_size 312 if image_size > partition_size: 313 print "Error: %s image size of %d is larger than partition size of %d" % (mount_point, image_size, partition_size) 314 return False 315 if verity_supported and is_verity_partition: 316 if 2 * image_size - AdjustPartitionSizeForVerity(image_size) > partition_size: 317 print "Error: No more room on %s to fit verity data" % mount_point 318 return False 319 prop_dict["original_partition_size"] = prop_dict["partition_size"] 320 prop_dict["partition_size"] = str(image_size) 321 322 # create the verified image if this is to be verified 323 if verity_supported and is_verity_partition: 324 if not MakeVerityEnabledImage(out_file, prop_dict): 325 return False 326 327 if run_fsck and prop_dict.get("skip_fsck") != "true": 328 success, unsparse_image = UnsparseImage(out_file, replace=False) 329 if not success: 330 return False 331 332 # Run e2fsck on the inflated image file 333 e2fsck_command = ["e2fsck", "-f", "-n", unsparse_image] 334 exit_code = RunCommand(e2fsck_command) 335 336 os.remove(unsparse_image) 337 338 return exit_code == 0 339 340 341def ImagePropFromGlobalDict(glob_dict, mount_point): 342 """Build an image property dictionary from the global dictionary. 343 344 Args: 345 glob_dict: the global dictionary from the build system. 346 mount_point: such as "system", "data" etc. 347 """ 348 d = {} 349 if "build.prop" in glob_dict: 350 bp = glob_dict["build.prop"] 351 if "ro.build.date.utc" in bp: 352 d["timestamp"] = bp["ro.build.date.utc"] 353 354 def copy_prop(src_p, dest_p): 355 if src_p in glob_dict: 356 d[dest_p] = str(glob_dict[src_p]) 357 358 common_props = ( 359 "extfs_sparse_flag", 360 "mkyaffs2_extra_flags", 361 "selinux_fc", 362 "skip_fsck", 363 "verity", 364 "verity_key", 365 "verity_signer_cmd" 366 ) 367 for p in common_props: 368 copy_prop(p, p) 369 370 d["mount_point"] = mount_point 371 if mount_point == "system": 372 copy_prop("fs_type", "fs_type") 373 # Copy the generic sysetem fs type first, override with specific one if 374 # available. 375 copy_prop("system_fs_type", "fs_type") 376 copy_prop("system_size", "partition_size") 377 copy_prop("system_journal_size", "journal_size") 378 copy_prop("system_verity_block_device", "verity_block_device") 379 copy_prop("system_root_image","system_root_image") 380 copy_prop("ramdisk_dir","ramdisk_dir") 381 elif mount_point == "data": 382 # Copy the generic fs type first, override with specific one if available. 383 copy_prop("fs_type", "fs_type") 384 copy_prop("userdata_fs_type", "fs_type") 385 copy_prop("userdata_size", "partition_size") 386 elif mount_point == "cache": 387 copy_prop("cache_fs_type", "fs_type") 388 copy_prop("cache_size", "partition_size") 389 elif mount_point == "vendor": 390 copy_prop("vendor_fs_type", "fs_type") 391 copy_prop("vendor_size", "partition_size") 392 copy_prop("vendor_journal_size", "journal_size") 393 copy_prop("vendor_verity_block_device", "verity_block_device") 394 elif mount_point == "oem": 395 copy_prop("fs_type", "fs_type") 396 copy_prop("oem_size", "partition_size") 397 copy_prop("oem_journal_size", "journal_size") 398 399 return d 400 401 402def LoadGlobalDict(filename): 403 """Load "name=value" pairs from filename""" 404 d = {} 405 f = open(filename) 406 for line in f: 407 line = line.strip() 408 if not line or line.startswith("#"): 409 continue 410 k, v = line.split("=", 1) 411 d[k] = v 412 f.close() 413 return d 414 415 416def main(argv): 417 if len(argv) != 3: 418 print __doc__ 419 sys.exit(1) 420 421 in_dir = argv[0] 422 glob_dict_file = argv[1] 423 out_file = argv[2] 424 425 glob_dict = LoadGlobalDict(glob_dict_file) 426 image_filename = os.path.basename(out_file) 427 mount_point = "" 428 if image_filename == "system.img": 429 mount_point = "system" 430 elif image_filename == "userdata.img": 431 mount_point = "data" 432 elif image_filename == "cache.img": 433 mount_point = "cache" 434 elif image_filename == "vendor.img": 435 mount_point = "vendor" 436 elif image_filename == "oem.img": 437 mount_point = "oem" 438 else: 439 print >> sys.stderr, "error: unknown image file name ", image_filename 440 exit(1) 441 442 image_properties = ImagePropFromGlobalDict(glob_dict, mount_point) 443 if not BuildImage(in_dir, image_properties, out_file): 444 print >> sys.stderr, "error: failed to build %s from %s" % (out_file, 445 in_dir) 446 exit(1) 447 448 449if __name__ == '__main__': 450 main(sys.argv[1:]) 451