build_image.py revision 8282282122a22f87c94862e97674bf48fd921d48 
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  """Build an image to out_file from in_dir with property prop_dict.
214
215  Args:
216    in_dir: path of input directory.
217    prop_dict: property dictionary.
218    out_file: path of the output image file.
219    fs_config: path to the fs_config file (typically
220      META/filesystem_config.txt).  If None then the configuration in
221      the local client will be used.
222    fc_config: path to the SELinux file_contexts file.  If None then
223      the value from prop_dict['selinux_fc'] will be used.
224
225  Returns:
226    True iff the image is built successfully.
227  """
228  build_command = []
229  fs_type = prop_dict.get("fs_type", "")
230  run_fsck = False
231
232  is_verity_partition = prop_dict.get("mount_point") == prop_dict.get("verity_mountpoint")
233  verity_supported = prop_dict.get("verity") == "true"
234  # adjust the partition size to make room for the hashes if this is to be verified
235  if verity_supported and is_verity_partition:
236    partition_size = int(prop_dict.get("partition_size"))
237    adjusted_size = AdjustPartitionSizeForVerity(partition_size)
238    if not adjusted_size:
239      return False
240    prop_dict["partition_size"] = str(adjusted_size)
241    prop_dict["original_partition_size"] = str(partition_size)
242
243  if fs_type.startswith("ext"):
244    build_command = ["mkuserimg.sh"]
245    if "extfs_sparse_flag" in prop_dict:
246      build_command.append(prop_dict["extfs_sparse_flag"])
247      run_fsck = True
248    build_command.extend([in_dir, out_file, fs_type,
249                          prop_dict["mount_point"]])
250    build_command.append(prop_dict["partition_size"])
251    if "timestamp" in prop_dict:
252      build_command.extend(["-T", str(prop_dict["timestamp"])])
253    if fs_config is not None:
254      build_command.extend(["-C", fs_config])
255    if fc_config is not None:
256      build_command.append(fc_config)
257    elif "selinux_fc" in prop_dict:
258      build_command.append(prop_dict["selinux_fc"])
259  else:
260    build_command = ["mkyaffs2image", "-f"]
261    if prop_dict.get("mkyaffs2_extra_flags", None):
262      build_command.extend(prop_dict["mkyaffs2_extra_flags"].split())
263    build_command.append(in_dir)
264    build_command.append(out_file)
265    if "selinux_fc" in prop_dict:
266      build_command.append(prop_dict["selinux_fc"])
267      build_command.append(prop_dict["mount_point"])
268
269  exit_code = RunCommand(build_command)
270  if exit_code != 0:
271    return False
272
273  # create the verified image if this is to be verified
274  if verity_supported and is_verity_partition:
275    if not MakeVerityEnabledImage(out_file, prop_dict):
276      return False
277
278  if run_fsck and prop_dict.get("skip_fsck") != "true":
279    success, unsparse_image = UnsparseImage(out_file, replace=False)
280    if not success:
281      return False
282
283    # Run e2fsck on the inflated image file
284    e2fsck_command = ["e2fsck", "-f", "-n", unsparse_image]
285    exit_code = RunCommand(e2fsck_command)
286
287    os.remove(unsparse_image)
288
289  return exit_code == 0
290
291
292def ImagePropFromGlobalDict(glob_dict, mount_point):
293  """Build an image property dictionary from the global dictionary.
294
295  Args:
296    glob_dict: the global dictionary from the build system.
297    mount_point: such as "system", "data" etc.
298  """
299  d = {}
300  if "build.prop" in glob_dict:
301    bp = glob_dict["build.prop"]
302    if "ro.build.date.utc" in bp:
303      d["timestamp"] = bp["ro.build.date.utc"]
304
305  def copy_prop(src_p, dest_p):
306    if src_p in glob_dict:
307      d[dest_p] = str(glob_dict[src_p])
308
309  common_props = (
310      "extfs_sparse_flag",
311      "mkyaffs2_extra_flags",
312      "selinux_fc",
313      "skip_fsck",
314      "verity",
315      "verity_block_device",
316      "verity_key",
317      "verity_signer_cmd",
318      "verity_mountpoint"
319      )
320  for p in common_props:
321    copy_prop(p, p)
322
323  d["mount_point"] = mount_point
324  if mount_point == "system":
325    copy_prop("fs_type", "fs_type")
326    copy_prop("system_size", "partition_size")
327  elif mount_point == "data":
328    copy_prop("fs_type", "fs_type")
329    copy_prop("userdata_size", "partition_size")
330  elif mount_point == "cache":
331    copy_prop("cache_fs_type", "fs_type")
332    copy_prop("cache_size", "partition_size")
333  elif mount_point == "vendor":
334    copy_prop("vendor_fs_type", "fs_type")
335    copy_prop("vendor_size", "partition_size")
336  elif mount_point == "oem":
337    copy_prop("fs_type", "fs_type")
338    copy_prop("oem_size", "partition_size")
339
340  return d
341
342
343def LoadGlobalDict(filename):
344  """Load "name=value" pairs from filename"""
345  d = {}
346  f = open(filename)
347  for line in f:
348    line = line.strip()
349    if not line or line.startswith("#"):
350      continue
351    k, v = line.split("=", 1)
352    d[k] = v
353  f.close()
354  return d
355
356
357def main(argv):
358  if len(argv) != 3:
359    print __doc__
360    sys.exit(1)
361
362  in_dir = argv[0]
363  glob_dict_file = argv[1]
364  out_file = argv[2]
365
366  glob_dict = LoadGlobalDict(glob_dict_file)
367  image_filename = os.path.basename(out_file)
368  mount_point = ""
369  if image_filename == "system.img":
370    mount_point = "system"
371  elif image_filename == "userdata.img":
372    mount_point = "data"
373  elif image_filename == "cache.img":
374    mount_point = "cache"
375  elif image_filename == "vendor.img":
376    mount_point = "vendor"
377  elif image_filename == "oem.img":
378    mount_point = "oem"
379  else:
380    print >> sys.stderr, "error: unknown image file name ", image_filename
381    exit(1)
382
383  image_properties = ImagePropFromGlobalDict(glob_dict, mount_point)
384  if not BuildImage(in_dir, image_properties, out_file):
385    print >> sys.stderr, "error: failed to build %s from %s" % (out_file, in_dir)
386    exit(1)
387
388
389if __name__ == '__main__':
390  main(sys.argv[1:])
391