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