[plain] view plaincopy
- # -----------------------------------------------------------------
- # A zip of the directories that map to the target filesystem.
- # This zip can be used to create an OTA package or filesystem image
- # as a post-build step.
- #
- name := $(TARGET_PRODUCT)
- ifeq ($(TARGET_BUILD_TYPE),debug)
- name := $(name)_debug
- endif
- name := $(name)-target_files-$(FILE_NAME_TAG)
-
- intermediates := $(call intermediates-dir-for,PACKAGING,target_files)
- BUILT_TARGET_FILES_PACKAGE := $(intermediates)/$(name).zip
- $(BUILT_TARGET_FILES_PACKAGE): intermediates := $(intermediates)
- $(BUILT_TARGET_FILES_PACKAGE): \
- zip_root := $(intermediates)/$(name)
-
- # $(1): Directory to copy
- # $(2): Location to copy it to
- # The "ls -A" is to prevent "acp s/* d" from failing if s is empty.
- define package_files-copy-root
- if [ -d "$(strip $(1))" -a "$$(ls -A $(1))" ]; then \
- mkdir -p $(2) && \
- $(ACP) -rd $(strip $(1))/* $(2); \
- fi
- endef
-
- built_ota_tools := \
- $(call intermediates-dir-for,EXECUTABLES,applypatch)/applypatch \
- $(call intermediates-dir-for,EXECUTABLES,applypatch_static)/applypatch_static \
- $(call intermediates-dir-for,EXECUTABLES,check_prereq)/check_prereq \
- $(call intermediates-dir-for,EXECUTABLES,updater)/updater
- $(BUILT_TARGET_FILES_PACKAGE): PRIVATE_OTA_TOOLS := $(built_ota_tools)
-
- $(BUILT_TARGET_FILES_PACKAGE): PRIVATE_RECOVERY_API_VERSION := $(RECOVERY_API_VERSION)
-
- ifeq ($(TARGET_RELEASETOOLS_EXTENSIONS),)
- # default to common dir for device vendor
- $(BUILT_TARGET_FILES_PACKAGE): tool_extensions := $(TARGET_DEVICE_DIR)/../common
- else
- $(BUILT_TARGET_FILES_PACKAGE): tool_extensions := $(TARGET_RELEASETOOLS_EXTENSIONS)
- endif
-
- # Depending on the various images guarantees that the underlying
- # directories are up-to-date.
- $(BUILT_TARGET_FILES_PACKAGE): \
- $(INSTALLED_BOOTIMAGE_TARGET) \
- $(INSTALLED_RADIOIMAGE_TARGET) \
- $(INSTALLED_RECOVERYIMAGE_TARGET) \
- $(INSTALLED_SYSTEMIMAGE) \
- $(INSTALLED_USERDATAIMAGE_TARGET) \
- $(INSTALLED_ANDROID_INFO_TXT_TARGET) \
- $(built_ota_tools) \
- $(APKCERTS_FILE) \
- $(HOST_OUT_EXECUTABLES)/fs_config \
- | $(ACP)
- @echo "Package target files: $@"
- $(hide) rm -rf $@ $(zip_root)
- $(hide) mkdir -p $(dir $@) $(zip_root)
- @# Components of the recovery image
- $(hide) mkdir -p $(zip_root)/RECOVERY
- $(hide) $(call package_files-copy-root, \
- $(TARGET_RECOVERY_ROOT_OUT),$(zip_root)/RECOVERY/RAMDISK)
- ifdef INSTALLED_KERNEL_TARGET
- $(hide) $(ACP) $(INSTALLED_KERNEL_TARGET) $(zip_root)/RECOVERY/kernel
- endif
- ifdef INSTALLED_2NDBOOTLOADER_TARGET
- $(hide) $(ACP) \
- $(INSTALLED_2NDBOOTLOADER_TARGET) $(zip_root)/RECOVERY/second
- endif
- ifdef BOARD_KERNEL_CMDLINE
- $(hide) echo "$(BOARD_KERNEL_CMDLINE)" > $(zip_root)/RECOVERY/cmdline
- endif
- ifdef BOARD_KERNEL_BASE
- $(hide) echo "$(BOARD_KERNEL_BASE)" > $(zip_root)/RECOVERY/base
- endif
- ifdef BOARD_KERNEL_PAGESIZE
- $(hide) echo "$(BOARD_KERNEL_PAGESIZE)" > $(zip_root)/RECOVERY/pagesize
- endif
- @# Components of the boot image
- $(hide) mkdir -p $(zip_root)/BOOT
- $(hide) $(call package_files-copy-root, \
- $(TARGET_ROOT_OUT),$(zip_root)/BOOT/RAMDISK)
- ifdef INSTALLED_KERNEL_TARGET
- $(hide) $(ACP) $(INSTALLED_KERNEL_TARGET) $(zip_root)/BOOT/kernel
- endif
- ifdef INSTALLED_2NDBOOTLOADER_TARGET
- $(hide) $(ACP) \
- $(INSTALLED_2NDBOOTLOADER_TARGET) $(zip_root)/BOOT/second
- endif
- ifdef BOARD_KERNEL_CMDLINE
- $(hide) echo "$(BOARD_KERNEL_CMDLINE)" > $(zip_root)/BOOT/cmdline
- endif
- ifdef BOARD_KERNEL_BASE
- $(hide) echo "$(BOARD_KERNEL_BASE)" > $(zip_root)/BOOT/base
- endif
- ifdef BOARD_KERNEL_PAGESIZE
- $(hide) echo "$(BOARD_KERNEL_PAGESIZE)" > $(zip_root)/BOOT/pagesize
- endif
- $(hide) $(foreach t,$(INSTALLED_RADIOIMAGE_TARGET),\
- mkdir -p $(zip_root)/RADIO; \
- $(ACP) $(t) $(zip_root)/RADIO/$(notdir $(t));)
- @# Contents of the system image
- $(hide) $(call package_files-copy-root, \
- $(SYSTEMIMAGE_SOURCE_DIR),$(zip_root)/SYSTEM)
- @# Contents of the data image
- $(hide) $(call package_files-copy-root, \
- $(TARGET_OUT_DATA),$(zip_root)/DATA)
- @# Extra contents of the OTA package
- $(hide) mkdir -p $(zip_root)/OTA/bin
- $(hide) $(ACP) $(INSTALLED_ANDROID_INFO_TXT_TARGET) $(zip_root)/OTA/
- $(hide) $(ACP) $(PRIVATE_OTA_TOOLS) $(zip_root)/OTA/bin/
- @# Files that do not end up in any images, but are necessary to
- @# build them.
- $(hide) mkdir -p $(zip_root)/META
- $(hide) $(ACP) $(APKCERTS_FILE) $(zip_root)/META/apkcerts.txt
- $(hide) echo "$(PRODUCT_OTA_PUBLIC_KEYS)" > $(zip_root)/META/otakeys.txt
- $(hide) echo "recovery_api_version=$(PRIVATE_RECOVERY_API_VERSION)" > $(zip_root)/META/misc_info.txt
- ifdef BOARD_FLASH_BLOCK_SIZE
- $(hide) echo "blocksize=$(BOARD_FLASH_BLOCK_SIZE)" >> $(zip_root)/META/misc_info.txt
- endif
- ifdef BOARD_BOOTIMAGE_PARTITION_SIZE
- $(hide) echo "boot_size=$(BOARD_BOOTIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt
- endif
- ifdef BOARD_RECOVERYIMAGE_PARTITION_SIZE
- $(hide) echo "recovery_size=$(BOARD_RECOVERYIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt
- endif
- ifdef BOARD_SYSTEMIMAGE_PARTITION_SIZE
- $(hide) echo "system_size=$(BOARD_SYSTEMIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt
- endif
- ifdef BOARD_USERDATAIMAGE_PARTITION_SIZE
- $(hide) echo "userdata_size=$(BOARD_USERDATAIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt
- endif
- $(hide) echo "tool_extensions=$(tool_extensions)" >> $(zip_root)/META/misc_info.txt
- ifdef mkyaffs2_extra_flags
- $(hide) echo "mkyaffs2_extra_flags=$(mkyaffs2_extra_flags)" >> $(zip_root)/META/misc_info.txt
- endif
- @# Zip everything up, preserving symlinks
- $(hide) (cd $(zip_root) && zip -qry ../$(notdir $@) .)
- @# Run fs_config on all the system files in the zip, and save the output
- $(hide) zipinfo -1 $@ | awk -F/ 'BEGIN { OFS="/" } /^SYSTEM\// {$$1 = "system"; print}' | $(HOST_OUT_EXECUTABLES)/fs_config > $(zip_root)/META/filesystem_config.txt
- $(hide) (cd $(zip_root) && zip -q ../$(notdir $@) META/filesystem_config.txt)
-
-
- target-files-package: $(BUILT_TARGET_FILES_PACKAGE)
-
-
- ifneq ($(TARGET_SIMULATOR),true)
- ifneq ($(TARGET_PRODUCT),sdk)
- ifneq ($(TARGET_DEVICE),generic)
- ifneq ($(TARGET_NO_KERNEL),true)
- ifneq ($(recovery_fstab),)
根据上面的Makefile可以分析这个包的生成过程: 首先创建一个root_zip根目录,并依次在此目录下创建所需要的如下其他目录 ①创建RECOVERY目录,并填充该目录的内容,包括kernel的镜像和recovery根文件系统的镜像。此目录最终用于生成recovery.img。 ②创建并填充BOOT目录。包含kernel和cmdline以及pagesize大小等,该目录最终用来生成boot.img。 ③向SYSTEM目录填充system image。 ④向DATA填充data image。 ⑤用于生成OTA package包所需要的额外的内容。主要包括一些bin命令。 ⑥创建META目录并向该目录下添加一些文本文件,如apkcerts.txt(描述apk文件用到的认证证书),misc_info.txt(描述Flash内存的块大小以及boot、recovery、system、userdata等分区的大小信息)。 ⑦使用保留连接选项压缩我们在上面获得的root_zip目录。 ⑧使用fs_config(build/tools/fs_config)配置上面的zip包内所有的系统文件(system/下各目录、文件)的权限属主等信息。fs_config包含了一个头文件#include“private/android_filesystem_config.h”。在这个头文件中以硬编码的方式设定了system目录下各文件的权限、属主。执行完配置后会将配置后的信息以文本方式输出 到META/filesystem_config.txt中。并再一次zip压缩成我们最终需要的原始包。 第二步:上面的zip包只是一个编译过程中生成的原始包。这个原始zip包在实际的编译过程中有两个作用,一是用来生成OTA update升级包,二是用来生成系统镜像。在编译过程中若生成OTA update升级包时会调用(具体位置在Makefile的1037行到1058行)一个名为ota_from_target_files的python脚本,位置在/build/tools/releasetools/ota_from_target_files。这个脚本的作用是以第一步生成的zip原始包作为输入,最终生成可用的OTA升级zip包。 下面我们分析使用这个脚本生成最终OTA升级包的过程。 ㈠ 首先看一下这个脚本开始部分的帮助文档。代码如下: [python] view plaincopy
- #!/usr/bin/env python
- #
- # Copyright (C) 2008 The Android Open Source Project
- #
- # Licensed under the Apache License, Version 2.0 (the "License");
- # you may not use this file except in compliance with the License.
- # You may obtain a copy of the License at
- #
- # http://www.apache.org/licenses/LICENSE-2.0
- #
- # Unless required by applicable law or agreed to in writing, software
- # distributed under the License is distributed on an "AS IS" BASIS,
- # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- # See the License for the specific language governing permissions and
- # limitations under the License.
-
- """
- Given a target-files zipfile, produces an OTA package that installs
- that build. An incremental OTA is produced if -i is given, otherwise
- a full OTA is produced.
-
- Usage: ota_from_target_files [flags] input_target_files output_ota_package
-
- -b (--board_config) <file>
- Deprecated.
-
- -k (--package_key) <key>
- Key to use to sign the package (default is
- "build/target/product/security/testkey").
-
- -i (--incremental_from) <file>
- Generate an incremental OTA using the given target-files zip as
- the starting build.
-
- -w (--wipe_user_data)
- Generate an OTA package that will wipe the user data partition
- when installed.
-
- -n (--no_prereq)
- Omit the timestamp prereq check normally included at the top of
- the build scripts (used for developer OTA packages which
- legitimately need to go back and forth).
-
- -e (--extra_script) <file>
- Insert the contents of file at the end of the update script.
-
- """
下面简单翻译一下他们的使用方法以及选项的作用。 Usage: ota_from_target_files [flags] input_target_files output_ota_package -b 过时的。 -k签名所使用的密钥 -i生成增量OTA包时使用此选项。后面我们会用到这个选项来生成OTA增量包。 -w是否清除userdata分区 -n在升级时是否不检查时间戳,缺省要检查,即缺省情况下只能基于旧版本升级。 -e是否有额外运行的脚本 -m执行过程中生成脚本(updater-script)所需要的格式,目前有两种即amend和edify。对应上两种版本升级时会采用不同的解释器。缺省会同时生成两种格式的脚 本。 -p定义脚本用到的一些可执行文件的路径。 -s定义额外运行脚本的路径。 -x定义额外运行的脚本可能用的键值对。 -v执行过程中打印出执行的命令。 -h命令帮助 ㈡ 下面我们分析ota_from_target_files这个python脚本是怎样生成最终zip包的。先讲这个脚本的代码贴出来如下: [python] view plaincopy
- import sys
-
- if sys.hexversion < 0x02040000:
- print >> sys.stderr, "Python 2.4 or newer is required."
- sys.exit(1)
-
- import copy
- import errno
- import os
- import re
- import sha
- import subprocess
- import tempfile
- import time
- import zipfile
-
- import common
- import edify_generator
-
- OPTIONS = common.OPTIONS
- OPTIONS.package_key = "build/target/product/security/testkey"
- OPTIONS.incremental_source = None
- OPTIONS.require_verbatim = set()
- OPTIONS.prohibit_verbatim = set(("system/build.prop",))
- OPTIONS.patch_threshold = 0.95
- OPTIONS.wipe_user_data = False
- OPTIONS.omit_prereq = False
- OPTIONS.extra_script = None
- OPTIONS.worker_threads = 3
-
- def MostPopularKey(d, default):
- """Given a dict, return the key corresponding to the largest
- value. Returns 'default' if the dict is empty."""
- x = [(v, k) for (k, v) in d.iteritems()]
- if not x: return default
- x.sort()
- return x[-1][1]
-
-
- def IsSymlink(info):
- """Return true if the zipfile.ZipInfo object passed in represents a
- symlink."""
- return (info.external_attr >> 16) == 0120777
-
-
- class Item:
- """Items represent the metadata (user, group, mode) of files and
- directories in the system image."""
- ITEMS = {}
- def __init__(self, name, dir=False):
- self.name = name
- self.uid = None
- self.gid = None
- self.mode = None
- self.dir = dir
-
- if name:
- self.parent = Item.Get(os.path.dirname(name), dir=True)
- self.parent.children.append(self)
- else:
- self.parent = None
- if dir:
- self.children = []
-
- def Dump(self, indent=0):
- if self.uid is not None:
- print "%s%s %d %d %o" % (" "*indent, self.name, self.uid, self.gid, self.mode)
- else:
- print "%s%s %s %s %s" % (" "*indent, self.name, self.uid, self.gid, self.mode)
- if self.dir:
- print "%s%s" % (" "*indent, self.descendants)
- print "%s%s" % (" "*indent, self.best_subtree)
- for i in self.children:
- i.Dump(indent=indent+1)
-
- @classmethod
- def Get(cls, name, dir=False):
- if name not in cls.ITEMS:
- cls.ITEMS[name] = Item(name, dir=dir)
- return cls.ITEMS[name]
-
- @classmethod
- def GetMetadata(cls, input_zip):
-
- try:
- # See if the target_files contains a record of what the uid,
- # gid, and mode is supposed to be.
- output = input_zip.read("META/filesystem_config.txt")
- except KeyError:
- # Run the external 'fs_config' program to determine the desired
- # uid, gid, and mode for every Item object. Note this uses the
- # one in the client now, which might not be the same as the one
- # used when this target_files was built.
- p = common.Run(["fs_config"], stdin=subprocess.PIPE,
- stdout=subprocess.PIPE, stderr=subprocess.PIPE)
- suffix = { False: "", True: "/" }
- input = "".join(["%s%s\n" % (i.name, suffix[i.dir])
- for i in cls.ITEMS.itervalues() if i.name])
- output, error = p.communicate(input)
- assert not error
-
- for line in output.split("\n"):
- if not line: continue
- name, uid, gid, mode = line.split()
- i = cls.ITEMS.get(name, None)
- if i is not None:
- i.uid = int(uid)
- i.gid = int(gid)
- i.mode = int(mode, 8)
- if i.dir:
- i.children.sort(key=lambda i: i.name)
-
- # set metadata for the files generated by this script.
- i = cls.ITEMS.get("system/recovery-from-boot.p", None)
- if i: i.uid, i.gid, i.mode = 0, 0, 0644
- i = cls.ITEMS.get("system/etc/install-recovery.sh", None)
- if i: i.uid, i.gid, i.mode = 0, 0, 0544
-
- def CountChildMetadata(self):
- """Count up the (uid, gid, mode) tuples for all children and
- determine the best strategy for using set_perm_recursive and
- set_perm to correctly chown/chmod all the files to their desired
- values. Recursively calls itself for all descendants.
-
- Returns a dict of {(uid, gid, dmode, fmode): count} counting up
- all descendants of this node. (dmode or fmode may be None.) Also
- sets the best_subtree of each directory Item to the (uid, gid,
- dmode, fmode) tuple that will match the most descendants of that
- Item.
- """
-
- assert self.dir
- d = self.descendants = {(self.uid, self.gid, self.mode, None): 1}
- for i in self.children:
- if i.dir:
- for k, v in i.CountChildMetadata().iteritems():
- d[k] = d.get(k, 0) + v
- else:
- k = (i.uid, i.gid, None, i.mode)
- d[k] = d.get(k, 0) + 1
-
- # Find the (uid, gid, dmode, fmode) tuple that matches the most
- # descendants.
-
- # First, find the (uid, gid) pair that matches the most
- # descendants.
- ug = {}
- for (uid, gid, _, _), count in d.iteritems():
- ug[(uid, gid)] = ug.get((uid, gid), 0) + count
- ug = MostPopularKey(ug, (0, 0))
-
- # Now find the dmode and fmode that match the most descendants
- # with that (uid, gid), and choose those.
- best_dmode = (0, 0755)
- best_fmode = (0, 0644)
- for k, count in d.iteritems():
- if k[:2] != ug: continue
- if k[2] is not None and count >= best_dmode[0]: best_dmode = (count, k[2])
- if k[3] is not None and count >= best_fmode[0]: best_fmode = (count, k[3])
- self.best_subtree = ug + (best_dmode[1], best_fmode[1])
-
- return d
-
- def SetPermissions(self, script):
- """Append set_perm/set_perm_recursive commands to 'script' to
- set all permissions, users, and groups for the tree of files
- rooted at 'self'."""
-
- self.CountChildMetadata()
-
- def recurse(item, current):
- # current is the (uid, gid, dmode, fmode) tuple that the current
- # item (and all its children) have already been set to. We only
- # need to issue set_perm/set_perm_recursive commands if we're
- # supposed to be something different.
- if item.dir:
- if current != item.best_subtree:
- script.SetPermissionsRecursive("/"+item.name, *item.best_subtree)
- current = item.best_subtree
-
- if item.uid != current[0] or item.gid != current[1] or \
- item.mode != current[2]:
- script.SetPermissions("/"+item.name, item.uid, item.gid, item.mode)
-
- for i in item.children:
- recurse(i, current)
- else:
- if item.uid != current[0] or item.gid != current[1] or \
- item.mode != current[3]:
- script.SetPermissions("/"+item.name, item.uid, item.gid, item.mode)
-
- recurse(self, (-1, -1, -1, -1))
-
-
- def CopySystemFiles(input_zip, output_zip=None,
- substitute=None):
- """Copies files underneath system/ in the input zip to the output
- zip. Populates the Item class with their metadata, and returns a
- list of symlinks. output_zip may be None, in which case the copy is
- skipped (but the other side effects still happen). substitute is an
- optional dict of {output filename: contents} to be output instead of
- certain input files.
- """
-
- symlinks = []
-
- for info in input_zip.infolist():
- if info.filename.startswith("SYSTEM/"):
- basefilename = info.filename[7:]
- if IsSymlink(info):
- symlinks.append((input_zip.read(info.filename),
- "/system/" + basefilename))
- else:
- info2 = copy.copy(info)
- fn = info2.filename = "system/" + basefilename
- if substitute and fn in substitute and substitute[fn] is None:
- continue
- if output_zip is not None:
- if substitute and fn in substitute:
- data = substitute[fn]
- else:
- data = input_zip.read(info.filename)
- output_zip.writestr(info2, data)
- if fn.endswith("/"):
- Item.Get(fn[:-1], dir=True)
- else:
- Item.Get(fn, dir=False)
-
- symlinks.sort()
- return symlinks
-
-
- def SignOutput(temp_zip_name, output_zip_name):
- key_passwords = common.GetKeyPasswords([OPTIONS.package_key])
- pw = key_passwords[OPTIONS.package_key]
-
- common.SignFile(temp_zip_name, output_zip_name, OPTIONS.package_key, pw,
- whole_file=True)
-
-
- def AppendAssertions(script, input_zip):
- device = GetBuildProp("ro.product.device", input_zip)
- script.AssertDevice(device)
-
-
- def MakeRecoveryPatch(output_zip, recovery_img, boot_img):
- """Generate a binary patch that creates the recovery image starting
- with the boot image. (Most of the space in these images is just the
- kernel, which is identical for the two, so the resulting patch
- should be efficient.) Add it to the output zip, along with a shell
- script that is run from init.rc on first boot to actually do the
- patching and install the new recovery image.
-
- recovery_img and boot_img should be File objects for the
- corresponding images.
-
- Returns an Item for the shell script, which must be made
- executable.
- """
-
- d = common.Difference(recovery_img, boot_img)
- _, _, patch = d.ComputePatch()
- common.ZipWriteStr(output_zip, "recovery/recovery-from-boot.p", patch)
- Item.Get("system/recovery-from-boot.p", dir=False)
-
- boot_type, boot_device = common.GetTypeAndDevice("/boot", OPTIONS.info_dict)
- recovery_type, recovery_device = common.GetTypeAndDevice("/recovery", OPTIONS.info_dict)
-
- # Images with different content will have a different first page, so
- # we check to see if this recovery has already been installed by
- # testing just the first 2k.
- HEADER_SIZE = 2048
- header_sha1 = sha.sha(recovery_img.data[:HEADER_SIZE]).hexdigest()
- sh = """#!/system/bin/sh
- if ! applypatch -c %(recovery_type)s:%(recovery_device)s:%(header_size)d:%(header_sha1)s; then
- log -t recovery "Installing new recovery image"
- applypatch %(boot_type)s:%(boot_device)s:%(boot_size)d:%(boot_sha1)s %(recovery_type)s:%(recovery_device)s %(recovery_sha1)s %(recovery_size)d %(boot_sha1)s:/system/recovery-from-boot.p
- else
- log -t recovery "Recovery image already installed"
- fi
- """ % { 'boot_size': boot_img.size,
- 'boot_sha1': boot_img.sha1,
- 'header_size': HEADER_SIZE,
- 'header_sha1': header_sha1,
- 'recovery_size': recovery_img.size,
- 'recovery_sha1': recovery_img.sha1,
- 'boot_type': boot_type,
- 'boot_device': boot_device,
- 'recovery_type': recovery_type,
- 'recovery_device': recovery_device,
- }
- common.ZipWriteStr(output_zip, "recovery/etc/install-recovery.sh", sh)
- return Item.Get("system/etc/install-recovery.sh", dir=False)
-
-
- def WriteFullOTAPackage(input_zip, output_zip):
- # TODO: how to determine this? We don't know what version it will
- # be installed on top of. For now, we expect the API just won't
- # change very often.
- script = edify_generator.EdifyGenerator(3, OPTIONS.info_dict)
-
- metadata = {"post-build": GetBuildProp("ro.build.fingerprint", input_zip),
- "pre-device": GetBuildProp("ro.product.device", input_zip),
- "post-timestamp": GetBuildProp("ro.build.date.utc", input_zip),
- }
-
- device_specific = common.DeviceSpecificParams(
- input_zip=input_zip,
- input_version=OPTIONS.info_dict["recovery_api_version"],
- output_zip=output_zip,
- script=script,
- input_tmp=OPTIONS.input_tmp,
- metadata=metadata,
- info_dict=OPTIONS.info_dict)
-
- if not OPTIONS.omit_prereq:
- ts = GetBuildProp("ro.build.date.utc", input_zip)
- script.AssertOlderBuild(ts)
-
- AppendAssertions(script, input_zip)
- device_specific.FullOTA_Assertions()
-
- script.ShowProgress(0.5, 0)
-
- if OPTIONS.wipe_user_data:
- script.FormatPartition("/data")
-
- script.FormatPartition("/system")
- script.Mount("/system")
- script.UnpackPackageDir("recovery", "/system")
- script.UnpackPackageDir("system", "/system")
-
- symlinks = CopySystemFiles(input_zip, output_zip)
- script.MakeSymlinks(symlinks)
-
- boot_img = common.File("boot.img", common.BuildBootableImage(
- os.path.join(OPTIONS.input_tmp, "BOOT")))
- recovery_img = common.File("recovery.img", common.BuildBootableImage(
- os.path.join(OPTIONS.input_tmp, "RECOVERY")))
- MakeRecoveryPatch(output_zip, recovery_img, boot_img)
-
- Item.GetMetadata(input_zip)
- Item.Get("system").SetPermissions(script)
-
- common.CheckSize(boot_img.data, "boot.img", OPTIONS.info_dict)
- common.ZipWriteStr(output_zip, "boot.img", boot_img.data)
- script.ShowProgress(0.2, 0)
-
- script.ShowProgress(0.2, 10)
- script.WriteRawImage("/boot", "boot.img")
-
- script.ShowProgress(0.1, 0)
- device_specific.FullOTA_InstallEnd()
-
- if OPTIONS.extra_script is not None:
- script.AppendExtra(OPTIONS.extra_script)
-
- script.UnmountAll()
- script.AddToZip(input_zip, output_zip)
- WriteMetadata(metadata, output_zip)
-
-
- def WriteMetadata(metadata, output_zip):
- common.ZipWriteStr(output_zip, "META-INF/com/android/metadata",
- "".join(["%s=%s\n" % kv
- for kv in sorted(metadata.iteritems())]))
-
-
-
-
- def LoadSystemFiles(z):
- """Load all the files from SYSTEM/... in a given target-files
- ZipFile, and return a dict of {filename: File object}."""
- out = {}
- for info in z.infolist():
- if info.filename.startswith("SYSTEM/") and not IsSymlink(info):
- fn = "system/" + info.filename[7:]
- data = z.read(info.filename)
- out[fn] = common.File(fn, data)
- return out
-
-
- def GetBuildProp(property, z):
- """Return the fingerprint of the build of a given target-files
- ZipFile object."""
- bp = z.read("SYSTEM/build.prop")
- if not property:
- return bp
- m = re.search(re.escape(property) + r"=(.*)\n", bp)
- if not m:
- raise common.ExternalError("couldn't find %s in build.prop" % (property,))
- return m.group(1).strip()
-
-
- def WriteIncrementalOTAPackage(target_zip, source_zip, output_zip):
- source_version = OPTIONS.source_info_dict["recovery_api_version"]
- target_version = OPTIONS.target_info_dict["recovery_api_version"]
-
- if source_version == 0:
- print ("WARNING: generating edify script for a source that "
- "can't install it.")
- script = edify_generator.EdifyGenerator(source_version, OPTIONS.info_dict)
-
- metadata = {"pre-device": GetBuildProp("ro.product.device", source_zip),
- "post-timestamp": GetBuildProp("ro.build.date.utc", target_zip),
- }
-
- device_specific = common.DeviceSpecificParams(
- source_zip=source_zip,
- source_version=source_version,
- target_zip=target_zip,
- target_version=target_version,
- output_zip=output_zip,
- script=script,
- metadata=metadata,
- info_dict=OPTIONS.info_dict)
-
- print "Loading target..."
- target_data = LoadSystemFiles(target_zip)
- print "Loading source..."
- source_data = LoadSystemFiles(source_zip)
-
- verbatim_targets = []
- patch_list = []
- diffs = []
- largest_source_size = 0
- for fn in sorted(target_data.keys()):
- tf = target_data[fn]
- assert fn == tf.name
- sf = source_data.get(fn, None)
-
- if sf is None or fn in OPTIONS.require_verbatim:
- # This file should be included verbatim
- if fn in OPTIONS.prohibit_verbatim:
- raise common.ExternalError("\"%s\" must be sent verbatim" % (fn,))
- print "send", fn, "verbatim"
- tf.AddToZip(output_zip)
- verbatim_targets.append((fn, tf.size))
- elif tf.sha1 != sf.sha1:
- # File is different; consider sending as a patch
- diffs.append(common.Difference(tf, sf))
- else:
- # Target file identical to source.
- pass
-
- common.ComputeDifferences(diffs)
-
- for diff in diffs:
- tf, sf, d = diff.GetPatch()
- if d is None or len(d) > tf.size * OPTIONS.patch_threshold:
- # patch is almost as big as the file; don't bother patching
- tf.AddToZip(output_zip)
- verbatim_targets.append((tf.name, tf.size))
- else:
- common.ZipWriteStr(output_zip, "patch/" + tf.name + ".p", d)
- patch_list.append((tf.name, tf, sf, tf.size, sha.sha(d).hexdigest()))
- largest_source_size = max(largest_source_size, sf.size)
-
- source_fp = GetBuildProp("ro.build.fingerprint", source_zip)
- target_fp = GetBuildProp("ro.build.fingerprint", target_zip)
- metadata["pre-build"] = source_fp
- metadata["post-build"] = target_fp
-
- script.Mount("/system")
- script.AssertSomeFingerprint(source_fp, target_fp)
-
- source_boot = common.File("/tmp/boot.img",
- common.BuildBootableImage(
- os.path.join(OPTIONS.source_tmp, "BOOT")))
- target_boot = common.File("/tmp/boot.img",
- common.BuildBootableImage(
- os.path.join(OPTIONS.target_tmp, "BOOT")))
- updating_boot = (source_boot.data != target_boot.data)
-
- source_recovery = common.File("system/recovery.img",
- common.BuildBootableImage(
- os.path.join(OPTIONS.source_tmp, "RECOVERY")))
- target_recovery = common.File("system/recovery.img",
- common.BuildBootableImage(
- os.path.join(OPTIONS.target_tmp, "RECOVERY")))
- updating_recovery = (source_recovery.data != target_recovery.data)
-
- # Here's how we divide up the progress bar:
- # 0.1 for verifying the start state (PatchCheck calls)
- # 0.8 for applying patches (ApplyPatch calls)
- # 0.1 for unpacking verbatim files, symlinking, and doing the
- # device-specific commands.
-
- AppendAssertions(script, target_zip)
- device_specific.IncrementalOTA_Assertions()
-
- script.Print("Verifying current system...")
-
- script.ShowProgress(0.1, 0)
- total_verify_size = float(sum([i[2].size for i in patch_list]) + 1)
- if updating_boot:
- total_verify_size += source_boot.size
- so_far = 0
-
- for fn, tf, sf, size, patch_sha in patch_list:
- script.PatchCheck("/"+fn, tf.sha1, sf.sha1)
- so_far += sf.size
- script.SetProgress(so_far / total_verify_size)
-
- if updating_boot:
- d = common.Difference(target_boot, source_boot)
- _, _, d = d.ComputePatch()
- print "boot target: %d source: %d diff: %d" % (
- target_boot.size, source_boot.size, len(d))
-
- common.ZipWriteStr(output_zip, "patch/boot.img.p", d)
-
- boot_type, boot_device = common.GetTypeAndDevice("/boot", OPTIONS.info_dict)
-
- script.PatchCheck("%s:%s:%d:%s:%d:%s" %
- (boot_type, boot_device,
- source_boot.size, source_boot.sha1,
- target_boot.size, target_boot.sha1))
- so_far += source_boot.size
- script.SetProgress(so_far / total_verify_size)
-
- if patch_list or updating_recovery or updating_boot:
- script.CacheFreeSpaceCheck(largest_source_size)
-
- device_specific.IncrementalOTA_VerifyEnd()
-
- script.Comment("---- start making changes here ----")
-
- if OPTIONS.wipe_user_data:
- script.Print("Erasing user data...")
- script.FormatPartition("/data")
-
- script.Print("Removing unneeded files...")
- script.DeleteFiles(["/"+i[0] for i in verbatim_targets] +
- ["/"+i for i in sorted(source_data)
- if i not in target_data] +
- ["/system/recovery.img"])
-
- script.ShowProgress(0.8, 0)
- total_patch_size = float(sum([i[1].size for i in patch_list]) + 1)
- if updating_boot:
- total_patch_size += target_boot.size
- so_far = 0
-
- script.Print("Patching system files...")
- for fn, tf, sf, size, _ in patch_list:
- script.ApplyPatch("/"+fn, "-", tf.size, tf.sha1, sf.sha1, "patch/"+fn+".p")
- so_far += tf.size
- script.SetProgress(so_far / total_patch_size)
-
- if updating_boot:
- # Produce the boot image by applying a patch to the current
- # contents of the boot partition, and write it back to the
- # partition.
- script.Print("Patching boot image...")
- script.ApplyPatch("%s:%s:%d:%s:%d:%s"
- % (boot_type, boot_device,
- source_boot.size, source_boot.sha1,
- target_boot.size, target_boot.sha1),
- "-",
- target_boot.size, target_boot.sha1,
- source_boot.sha1, "patch/boot.img.p")
- so_far += target_boot.size
- script.SetProgress(so_far / total_patch_size)
- print "boot image changed; including."
- else:
- print "boot image unchanged; skipping."
-
- if updating_recovery:
- # Is it better to generate recovery as a patch from the current
- # boot image, or from the previous recovery image? For large
- # updates with significant kernel changes, probably the former.
- # For small updates where the kernel hasn't changed, almost
- # certainly the latter. We pick the first option. Future
- # complicated schemes may let us effectively use both.
- #
- # A wacky possibility: as long as there is room in the boot
- # partition, include the binaries and image files from recovery in
- # the boot image (though not in the ramdisk) so they can be used
- # as fodder for constructing the recovery image.
- MakeRecoveryPatch(output_zip, target_recovery, target_boot)
- script.DeleteFiles(["/system/recovery-from-boot.p",
- "/system/etc/install-recovery.sh"])
- print "recovery image changed; including as patch from boot."
- else:
- print "recovery image unchanged; skipping."
-
- script.ShowProgress(0.1, 10)
-
- target_symlinks = CopySystemFiles(target_zip, None)
-
- target_symlinks_d = dict([(i[1], i[0]) for i in target_symlinks])
- temp_script = script.MakeTemporary()
- Item.GetMetadata(target_zip)
- Item.Get("system").SetPermissions(temp_script)
-
- # Note that this call will mess up the tree of Items, so make sure
- # we're done with it.
- source_symlinks = CopySystemFiles(source_zip, None)
- source_symlinks_d = dict([(i[1], i[0]) for i in source_symlinks])
-
- # Delete all the symlinks in source that aren't in target. This
- # needs to happen before verbatim files are unpacked, in case a
- # symlink in the source is replaced by a real file in the target.
- to_delete = []
- for dest, link in source_symlinks:
- if link not in target_symlinks_d:
- to_delete.append(link)
- script.DeleteFiles(to_delete)
-
- if verbatim_targets:
- script.Print("Unpacking new files...")
- script.UnpackPackageDir("system", "/system")
-
- if updating_recovery:
- script.Print("Unpacking new recovery...")
- script.UnpackPackageDir("recovery", "/system")
-
- script.Print("Symlinks and permissions...")
-
- # Create all the symlinks that don't already exist, or point to
- # somewhere different than what we want. Delete each symlink before
- # creating it, since the 'symlink' command won't overwrite.
- to_create = []
- for dest, link in target_symlinks:
- if link in source_symlinks_d:
- if dest != source_symlinks_d[link]:
- to_create.append((dest, link))
- else:
- to_create.append((dest, link))
- script.DeleteFiles([i[1] for i in to_create])
- script.MakeSymlinks(to_create)
-
- # Now that the symlinks are created, we can set all the
- # permissions.
- script.AppendScript(temp_script)
-
- # Do device-specific installation (eg, write radio image).
- device_specific.IncrementalOTA_InstallEnd()
-
- if OPTIONS.extra_script is not None:
- scirpt.AppendExtra(OPTIONS.extra_script)
-
- script.AddToZip(target_zip, output_zip)
- WriteMetadata(metadata, output_zip)
-
-
- def main(argv):
-
- def option_handler(o, a):
- if o in ("-b", "--board_config"):
- pass # deprecated
- elif o in ("-k", "--package_key"):
- OPTIONS.package_key = a
- elif o in ("-i", "--incremental_from"):
- OPTIONS.incremental_source = a
- elif o in ("-w", "--wipe_user_data"):
- OPTIONS.wipe_user_data = True
- elif o in ("-n", "--no_prereq"):
- OPTIONS.omit_prereq = True
- elif o in ("-e", "--extra_script"):
- OPTIONS.extra_script = a
- elif o in ("--worker_threads"):
- OPTIONS.worker_threads = int(a)
- else:
- return False
- return True
-
- args = common.ParseOptions(argv, __doc__,
- extra_opts="b:k:i:d:wne:",
- extra_long_opts=["board_config=",
- "package_key=",
- "incremental_from=",
- "wipe_user_data",
- "no_prereq",
- "extra_script=",
- "worker_threads="],
- extra_option_handler=option_handler)
-
- if len(args) != 2:
- common.Usage(__doc__)
- sys.exit(1)
-
- if OPTIONS.extra_script is not None:
- OPTIONS.extra_script = open(OPTIONS.extra_script).read()
-
- print "unzipping target target-files..."
- OPTIONS.input_tmp = common.UnzipTemp(args[0])
-
- OPTIONS.target_tmp = OPTIONS.input_tmp
- input_zip = zipfile.ZipFile(args[0], "r")
- OPTIONS.info_dict = common.LoadInfoDict(input_zip)
- if OPTIONS.verbose:
- print "--- target info ---"
- common.DumpInfoDict(OPTIONS.info_dict)
-
- if OPTIONS.device_specific is None:
- OPTIONS.device_specific = OPTIONS.info_dict.get("tool_extensions", None)
- if OPTIONS.device_specific is not None:
- OPTIONS.device_specific = os.path.normpath(OPTIONS.device_specific)
- print "using device-specific extensions in", OPTIONS.device_specific
-
- if OPTIONS.package_key:
- temp_zip_file = tempfile.NamedTemporaryFile()
- output_zip = zipfile.ZipFile(temp_zip_file, "w",
- compression=zipfile.ZIP_DEFLATED)
- else:
- output_zip = zipfile.ZipFile(args[1], "w",
- compression=zipfile.ZIP_DEFLATED)
-
- if OPTIONS.incremental_source is None:
- WriteFullOTAPackage(input_zip, output_zip)
- else:
- print "unzipping source target-files..."
- OPTIONS.source_tmp = common.UnzipTemp(OPTIONS.incremental_source)
- source_zip = zipfile.ZipFile(OPTIONS.incremental_source, "r")
- OPTIONS.target_info_dict = OPTIONS.info_dict
- OPTIONS.source_info_dict = common.LoadInfoDict(source_zip)
- if OPTIONS.verbose:
- print "--- source info ---"
- common.DumpInfoDict(OPTIONS.source_info_dict)
- WriteIncrementalOTAPackage(input_zip, source_zip, output_zip)
-
- output_zip.close()
- if OPTIONS.package_key:
- SignOutput(temp_zip_file.name, args[1])
- temp_zip_file.close()
-
- common.Cleanup()
-
- print "done."
-
-
- if __name__ == '__main__':
- try:
- common.CloseInheritedPipes()
- main(sys.argv[1:])
- except common.ExternalError, e:
- print
- print " ERROR: %s" % (e,)
- print
- sys.exit(1)
主函数main是python的入口函数,我们从main函数开始看,大概看一下main函数(脚本最后)里的流程就能知道脚本的执行过程了。 ① 在main函数的开头,首先将用户设定的option选项存入OPTIONS变量中,它是一个python中的类。紧接着判断有没有额外的脚本,如果有就读入到OPTIONS变量中。 ② 解压缩输入的zip包,即我们在上文生成的原始zip包。然后判断是否用到device-specific extensions(设备扩展)如果用到,随即读入到OPTIONS变量中。 ③ 判断是否签名,然后判断是否有新内容的增量源,有的话就解压该增量源包放入一个临时变量中(source_zip)。自此,所有的准备工作已完毕,随即会调用该 脚本中最主要的函数WriteFullOTAPackage(input_zip,output_zip) ④ WriteFullOTAPackage函数的处理过程是先获得脚本的生成器。默认格式是edify。然后获得metadata元数据,此数据来至于Android的一些环境变量。然后获得设备配置参数比如api函数的版本。然后判断是否忽略时间戳。 ⑤ WriteFullOTAPackage函数做完准备工作后就开始生成升级用的脚本文件(updater-script)了。生成脚本文件后将上一步获得的metadata元数据写入到输出包out_zip。 ⑥至此一个完整的update.zip升级包就生成了。生成位置在:out/target/product/tcc8800/full_tcc8800_evm-ota-eng.mumu.20120315.155326.zip。将升级包拷贝到SD卡中就可以用来升级了。 四、 Android OTA增量包update.zip的生成 在上面的过程中生成的update.zip升级包是全部系统的升级包。大小有80M多。这对手机用户来说,用来升级的流量是很大的。而且在实际升级中,我们只希望能够升级我们改变的那部分内容。这就需要使用增量包来升级。生成增量包的过程也需要上文中提到的ota_from_target_files.py的参与。 下面是制作update.zip增量包的过程。 ① 在源码根目录下依次执行下列命令 $ . build/envsetup.sh $ lunch 选择17 $ make $ make otapackage 执行上面的命令后会在out/target/product/tcc8800/下生成我们第一个系统升级包。我们先将其命名为A.zip ② 在源码中修改我们需要改变的部分,比如修改内核配置,增加新的驱动等等。修改后再一次执行上面的命令。就会生成第二个我们修改后生成的update.zip升级包。将 其命名为B.zip。 ③ 在上文中我们看了ota_from_target_files.py脚本的使用帮助,其中选项-i就是用来生成差分增量包的。使用方法是以上面的A.zip 和B.zip包作为输入,以update.zip包作 为输出。生成的update.zip就是我们最后需要的增量包。 具体使用方式是:将上述两个包拷贝到源码根目录下,然后执行下面的命令。 $ ./build/tools/releasetools/ota_from_target_files -i A.zip B.zip update.zip。 在执行上述命令时会出现未找到recovery_api_version的错误。原因是在执行上面的脚本时如果使用选项i则会调用WriteIncrementalOTAPackage会从A包和B包中的META目录下搜索misc_info.txt来读取recovery_api_version的值。但是在执行make otapackage命令时生成的update.zip包中没有这个目录更没有这个文档。 此时我们就需要使用执行make otapackage生成的原始的zip包。这个包的位置在out/target/product/tcc8800/obj/PACKAGING/target_files_intermediates/目录下,它是在用命令make otapackage之后的中间生产物,是最原始的升级包。我们将两次编译的生成的包分别重命名为A.zip和B.zip,并拷贝到SD卡根目录下重复执行上面的命令: $ ./build/tools/releasetools/ota_form_target_files -i A.zip B.zip update.zip。 在上述命令即将执行完毕时,在device/telechips/common/releasetools.py会调用IncrementalOTA_InstallEnd,在这个函数中读取包中的RADIO/bootloader.img。 而包中是没有这个目录和bootloader.img的。所以执行失败,未能生成对应的update.zip。可能与我们未修改bootloader(升级firmware)有关。此问题在下一篇博客已经解决。 |