build_image.py revision a2292c94d1d1c1759fee6ffce28b52fae91035b6 
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" % (FIXED_SALT, sparse_image_path, verity_image_path))
83  print cmd
84  status, output = commands.getstatusoutput(cmd)
85  if status:
86    print "Could not build verity tree! Error: %s" % output
87    return False
88  root, salt = output.split()
89  prop_dict["verity_root_hash"] = root
90  prop_dict["verity_salt"] = salt
91  return True
92
93def BuildVerityMetadata(image_size, verity_metadata_path, root_hash, salt,
94                        block_device, signer_path, key):
95  cmd = ("system/extras/verity/build_verity_metadata.py %s %s %s %s %s %s %s" %
96              (image_size,
97              verity_metadata_path,
98              root_hash,
99              salt,
100              block_device,
101              signer_path,
102              key))
103  print cmd
104  status, output = commands.getstatusoutput(cmd)
105  if status:
106    print "Could not build verity metadata! Error: %s" % output
107    return False
108  return True
109
110def Append2Simg(sparse_image_path, unsparse_image_path, error_message):
111  """Appends the unsparse image to the given sparse image.
112
113  Args:
114    sparse_image_path: the path to the (sparse) image
115    unsparse_image_path: the path to the (unsparse) image
116  Returns:
117    True on success, False on failure.
118  """
119  cmd = "append2simg %s %s"
120  cmd %= (sparse_image_path, unsparse_image_path)
121  print cmd
122  status, output = commands.getstatusoutput(cmd)
123  if status:
124    print "%s: %s" % (error_message, output)
125    return False
126  return True
127
128def BuildVerifiedImage(data_image_path, verity_image_path, verity_metadata_path):
129  if not Append2Simg(data_image_path, verity_metadata_path, "Could not append verity metadata!"):
130    return False
131  if not Append2Simg(data_image_path, verity_image_path, "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 verification
157  Returns:
158    True on success, False otherwise.
159  """
160  # get properties
161  image_size = prop_dict["partition_size"]
162  block_dev = prop_dict["verity_block_device"]
163  signer_key = prop_dict["verity_key"] + ".pk8"
164  signer_path = prop_dict["verity_signer_cmd"]
165
166  # make a tempdir
167  tempdir_name = tempfile.mkdtemp(suffix="_verity_images")
168
169  # get partial image paths
170  verity_image_path = os.path.join(tempdir_name, "verity.img")
171  verity_metadata_path = os.path.join(tempdir_name, "verity_metadata.img")
172
173  # build the verity tree and get the root hash and salt
174  if not BuildVerityTree(out_file, verity_image_path, prop_dict):
175    shutil.rmtree(tempdir_name, ignore_errors=True)
176    return False
177
178  # build the metadata blocks
179  root_hash = prop_dict["verity_root_hash"]
180  salt = prop_dict["verity_salt"]
181  if not BuildVerityMetadata(image_size,
182                              verity_metadata_path,
183                              root_hash,
184                              salt,
185                              block_dev,
186                              signer_path,
187                              signer_key):
188    shutil.rmtree(tempdir_name, ignore_errors=True)
189    return False
190
191  # build the full verified image
192  if not BuildVerifiedImage(out_file,
193                            verity_image_path,
194                            verity_metadata_path):
195    shutil.rmtree(tempdir_name, ignore_errors=True)
196    return False
197
198  shutil.rmtree(tempdir_name, ignore_errors=True)
199  return True
200
201def BuildImage(in_dir, prop_dict, out_file):
202  """Build an image to out_file from in_dir with property prop_dict.
203
204  Args:
205    in_dir: path of input directory.
206    prop_dict: property dictionary.
207    out_file: path of the output image file.
208
209  Returns:
210    True iff the image is built successfully.
211  """
212  # system_root_image=true: build a system.img that combines the contents of /system
213  # and the ramdisk, and can be mounted at the root of the file system.
214  origin_in = in_dir
215  fs_config = prop_dict.get("fs_config")
216  if (prop_dict.get("system_root_image") == "true"
217      and prop_dict["mount_point"] == "system"):
218    in_dir = tempfile.mkdtemp()
219    # Change the mount point to "/"
220    prop_dict["mount_point"] = "/"
221    if fs_config:
222      # We need to merge the fs_config files of system and ramdisk.
223      fd, merged_fs_config = tempfile.mkstemp(prefix="root_fs_config",
224                                              suffix=".txt")
225      os.close(fd)
226      with open(merged_fs_config, "w") as fw:
227        if "ramdisk_fs_config" in prop_dict:
228          with open(prop_dict["ramdisk_fs_config"]) as fr:
229            fw.writelines(fr.readlines())
230        with open(fs_config) as fr:
231          fw.writelines(fr.readlines())
232      fs_config = merged_fs_config
233
234  build_command = []
235  fs_type = prop_dict.get("fs_type", "")
236  run_fsck = 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:
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(["-m", prop_dict["mount_point"]])
272    if "selinux_fc" in prop_dict:
273      build_command.extend(["-c", prop_dict["selinux_fc"]])
274  elif fs_type.startswith("f2fs"):
275    build_command = ["mkf2fsuserimg.sh"]
276    build_command.extend([out_file, prop_dict["partition_size"]])
277  else:
278    build_command = ["mkyaffs2image", "-f"]
279    if prop_dict.get("mkyaffs2_extra_flags", None):
280      build_command.extend(prop_dict["mkyaffs2_extra_flags"].split())
281    build_command.append(in_dir)
282    build_command.append(out_file)
283    if "selinux_fc" in prop_dict:
284      build_command.append(prop_dict["selinux_fc"])
285      build_command.append(prop_dict["mount_point"])
286
287  if in_dir != origin_in:
288    # Construct a staging directory of the root file system.
289    ramdisk_dir = prop_dict.get("ramdisk_dir")
290    if ramdisk_dir:
291      shutil.rmtree(in_dir)
292      shutil.copytree(ramdisk_dir, in_dir, symlinks=True)
293    staging_system = os.path.join(in_dir, "system")
294    shutil.rmtree(staging_system, ignore_errors=True)
295    shutil.copytree(origin_in, staging_system, symlinks=True)
296  try:
297    exit_code = RunCommand(build_command)
298  finally:
299    if in_dir != origin_in:
300      # Clean up temporary directories and files.
301      shutil.rmtree(in_dir, ignore_errors=True)
302      if fs_config:
303        os.remove(fs_config)
304  if exit_code != 0:
305    return False
306
307  # create the verified image if this is to be verified
308  if verity_supported and is_verity_partition:
309    if not MakeVerityEnabledImage(out_file, prop_dict):
310      return False
311
312  if run_fsck and prop_dict.get("skip_fsck") != "true":
313    success, unsparse_image = UnsparseImage(out_file, replace=False)
314    if not success:
315      return False
316
317    # Run e2fsck on the inflated image file
318    e2fsck_command = ["e2fsck", "-f", "-n", unsparse_image]
319    exit_code = RunCommand(e2fsck_command)
320
321    os.remove(unsparse_image)
322
323  return exit_code == 0
324
325
326def ImagePropFromGlobalDict(glob_dict, mount_point):
327  """Build an image property dictionary from the global dictionary.
328
329  Args:
330    glob_dict: the global dictionary from the build system.
331    mount_point: such as "system", "data" etc.
332  """
333  d = {}
334  if "build.prop" in glob_dict:
335    bp = glob_dict["build.prop"]
336    if "ro.build.date.utc" in bp:
337      d["timestamp"] = bp["ro.build.date.utc"]
338
339  def copy_prop(src_p, dest_p):
340    if src_p in glob_dict:
341      d[dest_p] = str(glob_dict[src_p])
342
343  common_props = (
344      "extfs_sparse_flag",
345      "mkyaffs2_extra_flags",
346      "selinux_fc",
347      "skip_fsck",
348      "verity",
349      "verity_key",
350      "verity_signer_cmd"
351      )
352  for p in common_props:
353    copy_prop(p, p)
354
355  d["mount_point"] = mount_point
356  if mount_point == "system":
357    copy_prop("fs_type", "fs_type")
358    # Copy the generic sysetem fs type first, override with specific one if available.
359    copy_prop("system_fs_type", "fs_type")
360    copy_prop("system_size", "partition_size")
361    copy_prop("system_journal_size", "journal_size")
362    copy_prop("system_verity_block_device", "verity_block_device")
363    copy_prop("system_root_image","system_root_image")
364    copy_prop("ramdisk_dir","ramdisk_dir")
365  elif mount_point == "data":
366    # Copy the generic fs type first, override with specific one if available.
367    copy_prop("fs_type", "fs_type")
368    copy_prop("userdata_fs_type", "fs_type")
369    copy_prop("userdata_size", "partition_size")
370  elif mount_point == "cache":
371    copy_prop("cache_fs_type", "fs_type")
372    copy_prop("cache_size", "partition_size")
373  elif mount_point == "vendor":
374    copy_prop("vendor_fs_type", "fs_type")
375    copy_prop("vendor_size", "partition_size")
376    copy_prop("vendor_journal_size", "journal_size")
377    copy_prop("vendor_verity_block_device", "verity_block_device")
378  elif mount_point == "oem":
379    copy_prop("fs_type", "fs_type")
380    copy_prop("oem_size", "partition_size")
381    copy_prop("oem_journal_size", "journal_size")
382
383  return d
384
385
386def LoadGlobalDict(filename):
387  """Load "name=value" pairs from filename"""
388  d = {}
389  f = open(filename)
390  for line in f:
391    line = line.strip()
392    if not line or line.startswith("#"):
393      continue
394    k, v = line.split("=", 1)
395    d[k] = v
396  f.close()
397  return d
398
399
400def main(argv):
401  if len(argv) != 3:
402    print __doc__
403    sys.exit(1)
404
405  in_dir = argv[0]
406  glob_dict_file = argv[1]
407  out_file = argv[2]
408
409  glob_dict = LoadGlobalDict(glob_dict_file)
410  image_filename = os.path.basename(out_file)
411  mount_point = ""
412  if image_filename == "system.img":
413    mount_point = "system"
414  elif image_filename == "userdata.img":
415    mount_point = "data"
416  elif image_filename == "cache.img":
417    mount_point = "cache"
418  elif image_filename == "vendor.img":
419    mount_point = "vendor"
420  elif image_filename == "oem.img":
421    mount_point = "oem"
422  else:
423    print >> sys.stderr, "error: unknown image file name ", image_filename
424    exit(1)
425
426  image_properties = ImagePropFromGlobalDict(glob_dict, mount_point)
427  if not BuildImage(in_dir, image_properties, out_file):
428    print >> sys.stderr, "error: failed to build %s from %s" % (out_file, in_dir)
429    exit(1)
430
431
432if __name__ == '__main__':
433  main(sys.argv[1:])
434