img_from_target_files.py revision 01ce19c95f358ac8ef9bb939d2637ac976320401 
1#!/usr/bin/env python
2#
3# Copyright (C) 2008 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"""
18Given a target-files zipfile, produces an image zipfile suitable for
19use with 'fastboot update'.
20
21Usage:  img_from_target_files [flags] input_target_files output_image_zip
22
23  -b  (--board_config)  <file>
24      Deprecated.
25
26  -z  (--bootable_zip)
27      Include only the bootable images (eg 'boot' and 'recovery') in
28      the output.
29
30"""
31
32import sys
33
34if sys.hexversion < 0x02040000:
35  print >> sys.stderr, "Python 2.4 or newer is required."
36  sys.exit(1)
37
38import errno
39import os
40import re
41import shutil
42import subprocess
43import tempfile
44import zipfile
45
46# missing in Python 2.4 and before
47if not hasattr(os, "SEEK_SET"):
48  os.SEEK_SET = 0
49
50import build_image
51import common
52
53OPTIONS = common.OPTIONS
54
55
56def AddSystem(output_zip, sparse=True):
57  """Turn the contents of SYSTEM into a system image and store it in
58  output_zip."""
59
60  print "creating system.img..."
61
62  img = tempfile.NamedTemporaryFile()
63
64  # The name of the directory it is making an image out of matters to
65  # mkyaffs2image.  It wants "system" but we have a directory named
66  # "SYSTEM", so create a symlink.
67  try:
68    os.symlink(os.path.join(OPTIONS.input_tmp, "SYSTEM"),
69               os.path.join(OPTIONS.input_tmp, "system"))
70  except OSError, e:
71      # bogus error on my mac version?
72      #   File "./build/tools/releasetools/img_from_target_files", line 86, in AddSystem
73      #     os.path.join(OPTIONS.input_tmp, "system"))
74      # OSError: [Errno 17] File exists
75    if (e.errno == errno.EEXIST):
76      pass
77
78  image_props = build_image.ImagePropFromGlobalDict(OPTIONS.info_dict,
79                                                    "system")
80  fstab = OPTIONS.info_dict["fstab"]
81  if fstab:
82    image_props["fs_type" ] = fstab["/system"].fs_type
83  succ = build_image.BuildImage(os.path.join(OPTIONS.input_tmp, "system"),
84                                image_props, img.name)
85  assert succ, "build system.img image failed"
86
87  if sparse:
88    img.seek(os.SEEK_SET, 0)
89    data = img.read()
90    img.close()
91  else:
92    success, name = build_image.UnsparseImage(img.name, replace=False)
93    if not success:
94      assert False, "unsparsing system.img failed"
95    try:
96      with open(name) as f:
97        data = f.read()
98    finally:
99      os.unlink(name)
100
101  common.ZipWriteStr(output_zip, "system.img", data)
102
103
104def AddVendor(output_zip):
105  """Turn the contents of VENDOR into vendor.img and store it in
106  output_zip."""
107
108  image_props = build_image.ImagePropFromGlobalDict(OPTIONS.info_dict,
109                                                    "vendor")
110  # The build system has to explicitly request for vendor.img.
111  if "fs_type" not in image_props:
112    return
113
114  print "creating vendor.img..."
115
116  img = tempfile.NamedTemporaryFile()
117
118  # The name of the directory it is making an image out of matters to
119  # mkyaffs2image.  It wants "vendor" but we have a directory named
120  # "VENDOR", so create a symlink or an empty directory if VENDOR does not
121  # exist.
122  if not os.path.exists(os.path.join(OPTIONS.input_tmp, "vendor")):
123    if os.path.exists(os.path.join(OPTIONS.input_tmp, "VENDOR")):
124      os.symlink(os.path.join(OPTIONS.input_tmp, "VENDOR"),
125                 os.path.join(OPTIONS.input_tmp, "vendor"))
126    else:
127      os.mkdir(os.path.join(OPTIONS.input_tmp, "vendor"))
128
129  img = tempfile.NamedTemporaryFile()
130
131  fstab = OPTIONS.info_dict["fstab"]
132  if fstab:
133    image_props["fs_type" ] = fstab["/vendor"].fs_type
134  succ = build_image.BuildImage(os.path.join(OPTIONS.input_tmp, "vendor"),
135                                image_props, img.name)
136  assert succ, "build vendor.img image failed"
137
138  common.CheckSize(img.name, "vendor.img", OPTIONS.info_dict)
139  output_zip.write(img.name, "vendor.img")
140  img.close()
141
142
143def AddUserdata(output_zip):
144  """Create an empty userdata image and store it in output_zip."""
145
146  image_props = build_image.ImagePropFromGlobalDict(OPTIONS.info_dict,
147                                                    "data")
148  # If no userdata_size is provided for extfs, skip userdata.img.
149  if (image_props.get("fs_type", "").startswith("ext") and
150      not image_props.get("partition_size")):
151    return
152
153  print "creating userdata.img..."
154
155  # The name of the directory it is making an image out of matters to
156  # mkyaffs2image.  So we create a temp dir, and within it we create an
157  # empty dir named "data", and build the image from that.
158  temp_dir = tempfile.mkdtemp()
159  user_dir = os.path.join(temp_dir, "data")
160  os.mkdir(user_dir)
161  img = tempfile.NamedTemporaryFile()
162
163  fstab = OPTIONS.info_dict["fstab"]
164  if fstab:
165    image_props["fs_type" ] = fstab["/data"].fs_type
166  succ = build_image.BuildImage(user_dir, image_props, img.name)
167  assert succ, "build userdata.img image failed"
168
169  common.CheckSize(img.name, "userdata.img", OPTIONS.info_dict)
170  output_zip.write(img.name, "userdata.img")
171  img.close()
172  os.rmdir(user_dir)
173  os.rmdir(temp_dir)
174
175
176def AddCache(output_zip):
177  """Create an empty cache image and store it in output_zip."""
178
179  image_props = build_image.ImagePropFromGlobalDict(OPTIONS.info_dict,
180                                                    "cache")
181  # The build system has to explicitly request for cache.img.
182  if "fs_type" not in image_props:
183    return
184
185  print "creating cache.img..."
186
187  # The name of the directory it is making an image out of matters to
188  # mkyaffs2image.  So we create a temp dir, and within it we create an
189  # empty dir named "cache", and build the image from that.
190  temp_dir = tempfile.mkdtemp()
191  user_dir = os.path.join(temp_dir, "cache")
192  os.mkdir(user_dir)
193  img = tempfile.NamedTemporaryFile()
194
195  fstab = OPTIONS.info_dict["fstab"]
196  if fstab:
197    image_props["fs_type" ] = fstab["/cache"].fs_type
198  succ = build_image.BuildImage(user_dir, image_props, img.name)
199  assert succ, "build cache.img image failed"
200
201  common.CheckSize(img.name, "cache.img", OPTIONS.info_dict)
202  output_zip.write(img.name, "cache.img")
203  img.close()
204  os.rmdir(user_dir)
205  os.rmdir(temp_dir)
206
207
208def CopyInfo(output_zip):
209  """Copy the android-info.txt file from the input to the output."""
210  output_zip.write(os.path.join(OPTIONS.input_tmp, "OTA", "android-info.txt"),
211                   "android-info.txt")
212
213
214def main(argv):
215  bootable_only = [False]
216
217  def option_handler(o, a):
218    if o in ("-b", "--board_config"):
219      pass       # deprecated
220    if o in ("-z", "--bootable_zip"):
221      bootable_only[0] = True
222    else:
223      return False
224    return True
225
226  args = common.ParseOptions(argv, __doc__,
227                             extra_opts="b:z",
228                             extra_long_opts=["board_config=",
229                                              "bootable_zip"],
230                             extra_option_handler=option_handler)
231
232  bootable_only = bootable_only[0]
233
234  if len(args) != 2:
235    common.Usage(__doc__)
236    sys.exit(1)
237
238  OPTIONS.input_tmp, input_zip = common.UnzipTemp(args[0])
239  OPTIONS.info_dict = common.LoadInfoDict(input_zip)
240
241  # If this image was originally labelled with SELinux contexts, make sure we
242  # also apply the labels in our new image. During building, the "file_contexts"
243  # is in the out/ directory tree, but for repacking from target-files.zip it's
244  # in the root directory of the ramdisk.
245  if "selinux_fc" in OPTIONS.info_dict:
246    OPTIONS.info_dict["selinux_fc"] = os.path.join(OPTIONS.input_tmp, "BOOT", "RAMDISK",
247        "file_contexts")
248
249  output_zip = zipfile.ZipFile(args[1], "w", compression=zipfile.ZIP_DEFLATED)
250
251  common.GetBootableImage(
252      "boot.img", "boot.img", OPTIONS.input_tmp, "BOOT").AddToZip(output_zip)
253  common.GetBootableImage(
254      "recovery.img", "recovery.img", OPTIONS.input_tmp,
255      "RECOVERY").AddToZip(output_zip)
256
257  if not bootable_only:
258    AddSystem(output_zip)
259    AddVendor(output_zip)
260    AddUserdata(output_zip)
261    AddCache(output_zip)
262    CopyInfo(output_zip)
263
264  print "cleaning up..."
265  output_zip.close()
266  shutil.rmtree(OPTIONS.input_tmp)
267
268  print "done."
269
270
271if __name__ == '__main__':
272  try:
273    common.CloseInheritedPipes()
274    main(sys.argv[1:])
275  except common.ExternalError, e:
276    print
277    print "   ERROR: %s" % (e,)
278    print
279    sys.exit(1)
280