Android(安卓)recovery 原理分析

转载自 http://blog.csdn.net/mu0206mu

这篇及以后的篇幅将通过分析update.zip包在具体Android系统升级的过程，来理解Android系统中Recovery模式服务的工作原理。我们先从update.zip包的制作开始，然后是Android系统的启动模式分析，Recovery工作原理，如何从我们上层开始选择system update到重启到Recovery服务，以及在Recovery服务中具体怎样处理update.zip包升级的，我们的安装脚本updater-script怎样被解析并执行的等一系列问题。分析过程中所用的Android源码是gingerbread0919（tcc88xx开发板标配的），测试开发板是tcc88xx。这是在工作中总结的文档，当然在网上参考了不少内容，如有雷同纯属巧合吧，在分析过程中也存在很多未解决的问题，也希望大家不吝指教。

2、system/目录的内容在升级后会放在系统的system分区。主要用来更新系统的一些应用或则应用会用到的一些库等等。可以将Android源码编译out/target/product/tcc8800/system/中的所有文件拷贝到这个目录来代替。

3、 recovery/目录中的recovery-from-boot.p是boot.img和recovery.img的补丁(patch),主要用来更新recovery分区，其中etc/目录下的install-recovery.sh是更新脚本。
4、 update-binary是一个二进制文件，相当于一个脚本解释器，能够识别updater-script中描述的操作。该文件在Android源码编译后out/target/product/tcc8800/systembin/updater生成，可将updater重命名为update-binary得到。
该文件在具体的更新包中的名字由源码中bootable/recovery/install.c中的宏ASSUMED_UPDATE_BINARY_NAME的值而定。
5、 updater-script：此文件是一个脚本文件，具体描述了更新过程。我们可以根据具体情况编写该脚本来适应我们的具体需求。该文件的命名由源码中bootable/recovery/updater/updater.c文件中的宏SCRIPT_NAME的值而定。
6、 metadata文件是描述设备信息及环境变量的元数据。主要包括一些编译选项，签名公钥，时间戳以及设备型号等。
7、我们还可以在包中添加userdata目录，来更新系统中的用户数据部分。这部分内容在更新后会存放在系统的/data目录下。

8、update.zip包的签名：update.zip更新包在制作完成后需要对其签名，否则在升级时会出现认证失败的错误提示。而且签名要使用和目标板一致的加密公钥。加密公钥及加密需要的三个文件在Android源码编译后生成的具体路径为：

out/host/linux-x86/framework/signapk.jar

build/target/product/security/testkey.x509.pem

build/target/product/security/testkey.pk8 。

我们用命令make otapackage制作生成的update.zip包是已签过名的，如果自己做update.zip包时必须手动对其签名。

具体的加密方法：$ java –jar gingerbread/out/host/linux/framework/signapk.jar –w gingerbread/build/target/product/security/testkey.x509.pem gingerbread/build/target/product/security/testkey.pk8 update.zip update_signed.zip
以上命令在update.zip包所在的路径下执行，其中signapk.jar testkey.x509.pem以及testkey.pk8文件的引用使用绝对路径。update.zip 是我们已经打好的包，update_signed.zip包是命令执行完生成的已经签过名的包。
9、 MANIFEST.MF：这个manifest文件定义了与包的组成结构相关的数据。类似Android应用的mainfest.xml文件。
10、 CERT.RSA：与签名文件相关联的签名程序块文件，它存储了用于签名JAR文件的公共签名。
11、 CERT.SF：这是JAR文件的签名文件，其中前缀CERT代表签名者。
另外，在具体升级时，对update.zip包检查时大致会分三步：①检验SF文件与RSA文件是否匹配。②检验MANIFEST.MF与签名文件中的digest是否一致。③检验包中的文件与MANIFEST中所描述的是否一致。
三、 Android升级包update.zip的生成过程分析

1) 对于update.zip包的制作有两种方式，即手动制作和命令生成。

第一种手动制作：即按照update.zip的目录结构手动创建我们需要的目录。然后将对应的文件拷贝到相应的目录下，比如我们向系统中新加一个应用程序。可以将新增的应用拷贝到我们新建的update/system/app/下（system目录是事先拷贝编译源码后生成的system目录），打包并签名后，拷贝到SD卡就可以使用了。这种方式在实际的tcc8800开发板中未测试成功。签名部分未通过，可能与具体的开发板相关。

第二种制作方式：命令制作。Android源码系统中为我们提供了制作update.zip刷机包的命令，即make otapackage。该命令在编译源码完成后并在源码根目录下执行。具体操作方式：在源码根目录下执行

①$ . build/envsetup.sh。

②$ lunch 然后选择你需要的配置(如17)。

③$ make otapackage。

在编译完源码后最好再执行一遍上面的①、②步防止执行③时出现未找到对应规则的错误提示。命令执行完成后生成的升级包所在位置在out/target/product/full_tcc8800_evm_target_files-eng.mumu.20120309.111059.zip将这个包重新命名为update.zip，并拷贝到SD卡中即可使用。

这种方式(即完全升级)在tcc8800开发板中已测试成功。

2) 使用make otapackage命令生成update.zip的过程分析。
在源码根目录下执行make otapackage命令生成update.zip包主要分为两步，第一步是根据Makefile执行编译生成一个update原包（zip格式）。第二步是运行一个python脚本，并以上一步准备的zip包作为输入，最终生成我们需要的升级包。下面进一步分析这两个过程。

第一步：编译Makefile。对应的Makefile文件所在位置：build/core/Makefile。从该文件的884行（tcc8800,gingerbread0919）开始会生成一个zip包，这个包最后会用来制作OTA package 或者filesystem image。先将这部分的对应的Makefile贴出来如下：

[python] view plain copy print ?

#-----------------------------------------------------------------
#Azipofthedirectoriesthatmaptothetargetfilesystem.
#ThiszipcanbeusedtocreateanOTApackageorfilesystemimage
#asapost-buildstep.
#
name:=$(TARGET_PRODUCT)
ifeq($(TARGET_BUILD_TYPE),debug)
name:=$(name)_debug
endif
name:=$(name)-target_files-$(FILE_NAME_TAG)
intermediates:=$(callintermediates-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):Directorytocopy
#$(2):Locationtocopyitto
#The"ls-A"istoprevent"acps/*d"fromfailingifsisempty.
definepackage_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:=\
$(callintermediates-dir-for,EXECUTABLES,applypatch)/applypatch\
$(callintermediates-dir-for,EXECUTABLES,applypatch_static)/applypatch_static\
$(callintermediates-dir-for,EXECUTABLES,check_prereq)/check_prereq\
$(callintermediates-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),)
#defaulttocommondirfordevicevendor
$(BUILT_TARGET_FILES_PACKAGE):tool_extensions:=$(TARGET_DEVICE_DIR)/../common
else
$(BUILT_TARGET_FILES_PACKAGE):tool_extensions:=$(TARGET_RELEASETOOLS_EXTENSIONS)
endif
#Dependingonthevariousimagesguaranteesthattheunderlying
#directoriesareup-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"Packagetargetfiles:$@"
$(hide)rm-rf$@$(zip_root)
$(hide)mkdir-p$(dir$@)$(zip_root)
@#Componentsoftherecoveryimage
$(hide)mkdir-p$(zip_root)/RECOVERY
$(hide)$(callpackage_files-copy-root,\
$(TARGET_RECOVERY_ROOT_OUT),$(zip_root)/RECOVERY/RAMDISK)
ifdefINSTALLED_KERNEL_TARGET
$(hide)$(ACP)$(INSTALLED_KERNEL_TARGET)$(zip_root)/RECOVERY/kernel
endif
ifdefINSTALLED_2NDBOOTLOADER_TARGET
$(hide)$(ACP)\
$(INSTALLED_2NDBOOTLOADER_TARGET)$(zip_root)/RECOVERY/second
endif
ifdefBOARD_KERNEL_CMDLINE
$(hide)echo"$(BOARD_KERNEL_CMDLINE)">$(zip_root)/RECOVERY/cmdline
endif
ifdefBOARD_KERNEL_BASE
$(hide)echo"$(BOARD_KERNEL_BASE)">$(zip_root)/RECOVERY/base
endif
ifdefBOARD_KERNEL_PAGESIZE
$(hide)echo"$(BOARD_KERNEL_PAGESIZE)">$(zip_root)/RECOVERY/pagesize
endif
@#Componentsofthebootimage
$(hide)mkdir-p$(zip_root)/BOOT
$(hide)$(callpackage_files-copy-root,\
$(TARGET_ROOT_OUT),$(zip_root)/BOOT/RAMDISK)
ifdefINSTALLED_KERNEL_TARGET
$(hide)$(ACP)$(INSTALLED_KERNEL_TARGET)$(zip_root)/BOOT/kernel
endif
ifdefINSTALLED_2NDBOOTLOADER_TARGET
$(hide)$(ACP)\
$(INSTALLED_2NDBOOTLOADER_TARGET)$(zip_root)/BOOT/second
endif
ifdefBOARD_KERNEL_CMDLINE
$(hide)echo"$(BOARD_KERNEL_CMDLINE)">$(zip_root)/BOOT/cmdline
endif
ifdefBOARD_KERNEL_BASE
$(hide)echo"$(BOARD_KERNEL_BASE)">$(zip_root)/BOOT/base
endif
ifdefBOARD_KERNEL_PAGESIZE
$(hide)echo"$(BOARD_KERNEL_PAGESIZE)">$(zip_root)/BOOT/pagesize
endif
$(hide)$(foreacht,$(INSTALLED_RADIOIMAGE_TARGET),\
mkdir-p$(zip_root)/RADIO;\
$(ACP)$(t)$(zip_root)/RADIO/$(notdir$(t));)
@#Contentsofthesystemimage
$(hide)$(callpackage_files-copy-root,\
$(SYSTEMIMAGE_SOURCE_DIR),$(zip_root)/SYSTEM)
@#Contentsofthedataimage
$(hide)$(callpackage_files-copy-root,\
$(TARGET_OUT_DATA),$(zip_root)/DATA)
@#ExtracontentsoftheOTApackage
$(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/
@#Filesthatdonotendupinanyimages,butarenecessaryto
@#buildthem.
$(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
ifdefBOARD_FLASH_BLOCK_SIZE
$(hide)echo"blocksize=$(BOARD_FLASH_BLOCK_SIZE)">>$(zip_root)/META/misc_info.txt
endif
ifdefBOARD_BOOTIMAGE_PARTITION_SIZE
$(hide)echo"boot_size=$(BOARD_BOOTIMAGE_PARTITION_SIZE)">>$(zip_root)/META/misc_info.txt
endif
ifdefBOARD_RECOVERYIMAGE_PARTITION_SIZE
$(hide)echo"recovery_size=$(BOARD_RECOVERYIMAGE_PARTITION_SIZE)">>$(zip_root)/META/misc_info.txt
endif
ifdefBOARD_SYSTEMIMAGE_PARTITION_SIZE
$(hide)echo"system_size=$(BOARD_SYSTEMIMAGE_PARTITION_SIZE)">>$(zip_root)/META/misc_info.txt
endif
ifdefBOARD_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
ifdefmkyaffs2_extra_flags
$(hide)echo"mkyaffs2_extra_flags=$(mkyaffs2_extra_flags)">>$(zip_root)/META/misc_info.txt
endif
@#Zipeverythingup,preservingsymlinks
$(hide)(cd$(zip_root)&&zip-qry../$(notdir$@).)
@#Runfs_configonallthesystemfilesinthezip,andsavetheoutput
$(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 plain copy print ?

#!/usr/bin/envpython
#
#Copyright(C)2008TheAndroidOpenSourceProject
#
#LicensedundertheApacheLicense,Version2.0(the"License");
#youmaynotusethisfileexceptincompliancewiththeLicense.
#YoumayobtainacopyoftheLicenseat
#
#http://www.apache.org/licenses/LICENSE-2.0
#
#Unlessrequiredbyapplicablelaworagreedtoinwriting,software
#distributedundertheLicenseisdistributedonan"ASIS"BASIS,
#WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
#SeetheLicenseforthespecificlanguagegoverningpermissionsand
#limitationsundertheLicense.
"""
Givenatarget-fileszipfile,producesanOTApackagethatinstalls
thatbuild.AnincrementalOTAisproducedif-iisgiven,otherwise
afullOTAisproduced.
Usage:ota_from_target_files[flags]input_target_filesoutput_ota_package
-b(--board_config)<file>
Deprecated.
-k(--package_key)<key>
Keytousetosignthepackage(defaultis
"build/target/product/security/testkey").
-i(--incremental_from)<file>
GenerateanincrementalOTAusingthegiventarget-fileszipas
thestartingbuild.
-w(--wipe_user_data)
GenerateanOTApackagethatwillwipetheuserdatapartition
wheninstalled.
-n(--no_prereq)
Omitthetimestampprereqchecknormallyincludedatthetopof
thebuildscripts(usedfordeveloperOTApackageswhich
legitimatelyneedtogobackandforth).
-e(--extra_script)<file>
Insertthecontentsoffileattheendoftheupdatescript.
"""

下面简单翻译一下他们的使用方法以及选项的作用。

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 plain copy print ?

importsys
ifsys.hexversion<0x02040000:
print>>sys.stderr,"Python2.4ornewerisrequired."
sys.exit(1)
importcopy
importerrno
importos
importre
importsha
importsubprocess
importtempfile
importtime
importzipfile
importcommon
importedify_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
defMostPopularKey(d,default):
"""Givenadict,returnthekeycorrespondingtothelargest
value.Returns'default'ifthedictisempty."""
x=[(v,k)for(k,v)ind.iteritems()]
ifnotx:returndefault
x.sort()
returnx[-1][1]
defIsSymlink(info):
"""Returntrueifthezipfile.ZipInfoobjectpassedinrepresentsa
symlink."""
return(info.external_attr>>16)==0120777
classItem:
"""Itemsrepresentthemetadata(user,group,mode)offilesand
directoriesinthesystemimage."""
ITEMS={}
def__init__(self,name,dir=False):
self.name=name
self.uid=None
self.gid=None
self.mode=None
self.dir=dir
ifname:
self.parent=Item.Get(os.path.dirname(name),dir=True)
self.parent.children.append(self)
else:
self.parent=None
ifdir:
self.children=[]
defDump(self,indent=0):
ifself.uidisnotNone:
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)
ifself.dir:
print"%s%s"%(""*indent,self.descendants)
print"%s%s"%(""*indent,self.best_subtree)
foriinself.children:
i.Dump(indent=indent+1)
@classmethod
defGet(cls,name,dir=False):
ifnamenotincls.ITEMS:
cls.ITEMS[name]=Item(name,dir=dir)
returncls.ITEMS[name]
@classmethod
defGetMetadata(cls,input_zip):
try:
#Seeifthetarget_filescontainsarecordofwhattheuid,
#gid,andmodeissupposedtobe.
output=input_zip.read("META/filesystem_config.txt")
exceptKeyError:
#Runtheexternal'fs_config'programtodeterminethedesired
#uid,gid,andmodeforeveryItemobject.Notethisusesthe
#oneintheclientnow,whichmightnotbethesameastheone
#usedwhenthistarget_fileswasbuilt.
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])
foriincls.ITEMS.itervalues()ifi.name])
output,error=p.communicate(input)
assertnoterror
forlineinoutput.split("\n"):
ifnotline:continue
name,uid,gid,mode=line.split()
i=cls.ITEMS.get(name,None)
ifiisnotNone:
i.uid=int(uid)
i.gid=int(gid)
i.mode=int(mode,8)
ifi.dir:
i.children.sort(key=lambdai:i.name)
#setmetadataforthefilesgeneratedbythisscript.
i=cls.ITEMS.get("system/recovery-from-boot.p",None)
ifi:i.uid,i.gid,i.mode=0,0,0644
i=cls.ITEMS.get("system/etc/install-recovery.sh",None)
ifi:i.uid,i.gid,i.mode=0,0,0544
defCountChildMetadata(self):
"""Countupthe(uid,gid,mode)tuplesforallchildrenand
determinethebeststrategyforusingset_perm_recursiveand
set_permtocorrectlychown/chmodallthefilestotheirdesired
values.Recursivelycallsitselfforalldescendants.
Returnsadictof{(uid,gid,dmode,fmode):count}countingup
alldescendantsofthisnode.(dmodeorfmodemaybeNone.)Also
setsthebest_subtreeofeachdirectoryItemtothe(uid,gid,
dmode,fmode)tuplethatwillmatchthemostdescendantsofthat
Item.
"""
assertself.dir
d=self.descendants={(self.uid,self.gid,self.mode,None):1}
foriinself.children:
ifi.dir:
fork,vini.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
#Findthe(uid,gid,dmode,fmode)tuplethatmatchesthemost
#descendants.
#First,findthe(uid,gid)pairthatmatchesthemost
#descendants.
ug={}
for(uid,gid,_,_),countind.iteritems():
ug[(uid,gid)]=ug.get((uid,gid),0)+count
ug=MostPopularKey(ug,(0,0))
#Nowfindthedmodeandfmodethatmatchthemostdescendants
#withthat(uid,gid),andchoosethose.
best_dmode=(0,0755)
best_fmode=(0,0644)
fork,countind.iteritems():
ifk[:2]!=ug:continue
ifk[2]isnotNoneandcount>=best_dmode[0]:best_dmode=(count,k[2])
ifk[3]isnotNoneandcount>=best_fmode[0]:best_fmode=(count,k[3])
self.best_subtree=ug+(best_dmode[1],best_fmode[1])
returnd
defSetPermissions(self,script):
"""Appendset_perm/set_perm_recursivecommandsto'script'to
setallpermissions,users,andgroupsforthetreeoffiles
rootedat'self'."""
self.CountChildMetadata()
defrecurse(item,current):
#currentisthe(uid,gid,dmode,fmode)tuplethatthecurrent
#item(andallitschildren)havealreadybeensetto.Weonly
#needtoissueset_perm/set_perm_recursivecommandsifwe're
#supposedtobesomethingdifferent.
ifitem.dir:
ifcurrent!=item.best_subtree:
script.SetPermissionsRecursive("/"+item.name,*item.best_subtree)
current=item.best_subtree
ifitem.uid!=current[0]oritem.gid!=current[1]or\
item.mode!=current[2]:
script.SetPermissions("/"+item.name,item.uid,item.gid,item.mode)
foriinitem.children:
recurse(i,current)
else:
ifitem.uid!=current[0]oritem.gid!=current[1]or\
item.mode!=current[3]:
script.SetPermissions("/"+item.name,item.uid,item.gid,item.mode)
recurse(self,(-1,-1,-1,-1))
defCopySystemFiles(input_zip,output_zip=None,
substitute=None):
"""Copiesfilesunderneathsystem/intheinputziptotheoutput
zip.PopulatestheItemclasswiththeirmetadata,andreturnsa
listofsymlinks.output_zipmaybeNone,inwhichcasethecopyis
skipped(buttheothersideeffectsstillhappen).substituteisan
optionaldictof{outputfilename:contents}tobeoutputinsteadof
certaininputfiles.
"""
symlinks=[]
forinfoininput_zip.infolist():
ifinfo.filename.startswith("SYSTEM/"):
basefilename=info.filename[7:]
ifIsSymlink(info):
symlinks.append((input_zip.read(info.filename),
"/system/"+basefilename))
else:
info2=copy.copy(info)
fn=info2.filename="system/"+basefilename
ifsubstituteandfninsubstituteandsubstitute[fn]isNone:
continue
ifoutput_zipisnotNone:
ifsubstituteandfninsubstitute:
data=substitute[fn]
else:
data=input_zip.read(info.filename)
output_zip.writestr(info2,data)
iffn.endswith("/"):
Item.Get(fn[:-1],dir=True)
else:
Item.Get(fn,dir=False)
symlinks.sort()
returnsymlinks
defSignOutput(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)
defAppendAssertions(script,input_zip):
device=GetBuildProp("ro.product.device",input_zip)
script.AssertDevice(device)
defMakeRecoveryPatch(output_zip,recovery_img,boot_img):
"""Generateabinarypatchthatcreatestherecoveryimagestarting
withthebootimage.(Mostofthespaceintheseimagesisjustthe
kernel,whichisidenticalforthetwo,sotheresultingpatch
shouldbeefficient.)Addittotheoutputzip,alongwithashell
scriptthatisrunfrominit.rconfirstboottoactuallydothe
patchingandinstallthenewrecoveryimage.
recovery_imgandboot_imgshouldbeFileobjectsforthe
correspondingimages.
ReturnsanItemfortheshellscript,whichmustbemade
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)
#Imageswithdifferentcontentwillhaveadifferentfirstpage,so
#wechecktoseeifthisrecoveryhasalreadybeeninstalledby
#testingjustthefirst2k.
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-trecovery"Installingnewrecoveryimage"
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-trecovery"Recoveryimagealreadyinstalled"
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)
returnItem.Get("system/etc/install-recovery.sh",dir=False)
defWriteFullOTAPackage(input_zip,output_zip):
#TODO:howtodeterminethis?Wedon'tknowwhatversionitwill
#beinstalledontopof.Fornow,weexpecttheAPIjustwon't
#changeveryoften.
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)
ifnotOPTIONS.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)
ifOPTIONS.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()
ifOPTIONS.extra_scriptisnotNone:
script.AppendExtra(OPTIONS.extra_script)
script.UnmountAll()
script.AddToZip(input_zip,output_zip)
WriteMetadata(metadata,output_zip)
defWriteMetadata(metadata,output_zip):
common.ZipWriteStr(output_zip,"META-INF/com/android/metadata",
"".join(["%s=%s\n"%kv
forkvinsorted(metadata.iteritems())]))
defLoadSystemFiles(z):
"""LoadallthefilesfromSYSTEM/...inagiventarget-files
ZipFile,andreturnadictof{filename:Fileobject}."""
out={}
forinfoinz.infolist():
ifinfo.filename.startswith("SYSTEM/")andnotIsSymlink(info):
fn="system/"+info.filename[7:]
data=z.read(info.filename)
out[fn]=common.File(fn,data)
returnout
defGetBuildProp(property,z):
"""Returnthefingerprintofthebuildofagiventarget-files
ZipFileobject."""
bp=z.read("SYSTEM/build.prop")
ifnotproperty:
returnbp
m=re.search(re.escape(property)+r"=(.*)\n",bp)
ifnotm:
raisecommon.ExternalError("couldn'tfind%sinbuild.prop"%(property,))
returnm.group(1).strip()
defWriteIncrementalOTAPackage(target_zip,source_zip,output_zip):
source_version=OPTIONS.source_info_dict["recovery_api_version"]
target_version=OPTIONS.target_info_dict["recovery_api_version"]
ifsource_version==0:
print("WARNING:generatingedifyscriptforasourcethat"
"can'tinstallit.")
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"Loadingtarget..."
target_data=LoadSystemFiles(target_zip)
print"Loadingsource..."
source_data=LoadSystemFiles(source_zip)
verbatim_targets=[]
patch_list=[]
diffs=[]
largest_source_size=0
forfninsorted(target_data.keys()):
tf=target_data[fn]
assertfn==tf.name
sf=source_data.get(fn,None)
ifsfisNoneorfninOPTIONS.require_verbatim:
#Thisfileshouldbeincludedverbatim
iffninOPTIONS.prohibit_verbatim:
raisecommon.ExternalError("\"%s\"mustbesentverbatim"%(fn,))
print"send",fn,"verbatim"
tf.AddToZip(output_zip)
verbatim_targets.append((fn,tf.size))
eliftf.sha1!=sf.sha1:
#Fileisdifferent;considersendingasapatch
diffs.append(common.Difference(tf,sf))
else:
#Targetfileidenticaltosource.
pass
common.ComputeDifferences(diffs)
fordiffindiffs:
tf,sf,d=diff.GetPatch()
ifdisNoneorlen(d)>tf.size*OPTIONS.patch_threshold:
#patchisalmostasbigasthefile;don'tbotherpatching
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'showwedivideuptheprogressbar:
#0.1forverifyingthestartstate(PatchCheckcalls)
#0.8forapplyingpatches(ApplyPatchcalls)
#0.1forunpackingverbatimfiles,symlinking,anddoingthe
#device-specificcommands.
AppendAssertions(script,target_zip)
device_specific.IncrementalOTA_Assertions()
script.Print("Verifyingcurrentsystem...")
script.ShowProgress(0.1,0)
total_verify_size=float(sum([i[2].sizeforiinpatch_list])+1)
ifupdating_boot:
total_verify_size+=source_boot.size
so_far=0
forfn,tf,sf,size,patch_shainpatch_list:
script.PatchCheck("/"+fn,tf.sha1,sf.sha1)
so_far+=sf.size
script.SetProgress(so_far/total_verify_size)
ifupdating_boot:
d=common.Difference(target_boot,source_boot)
_,_,d=d.ComputePatch()
print"boottarget:%dsource:%ddiff:%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)
ifpatch_listorupdating_recoveryorupdating_boot:
script.CacheFreeSpaceCheck(largest_source_size)
device_specific.IncrementalOTA_VerifyEnd()
script.Comment("----startmakingchangeshere----")
ifOPTIONS.wipe_user_data:
script.Print("Erasinguserdata...")
script.FormatPartition("/data")
script.Print("Removingunneededfiles...")
script.DeleteFiles(["/"+i[0]foriinverbatim_targets]+
["/"+iforiinsorted(source_data)
ifinotintarget_data]+
["/system/recovery.img"])
script.ShowProgress(0.8,0)
total_patch_size=float(sum([i[1].sizeforiinpatch_list])+1)
ifupdating_boot:
total_patch_size+=target_boot.size
so_far=0
script.Print("Patchingsystemfiles...")
forfn,tf,sf,size,_inpatch_list:
script.ApplyPatch("/"+fn,"-",tf.size,tf.sha1,sf.sha1,"patch/"+fn+".p")
so_far+=tf.size
script.SetProgress(so_far/total_patch_size)
ifupdating_boot:
#Producethebootimagebyapplyingapatchtothecurrent
#contentsofthebootpartition,andwriteitbacktothe
#partition.
script.Print("Patchingbootimage...")
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"bootimagechanged;including."
else:
print"bootimageunchanged;skipping."
ifupdating_recovery:
#Isitbettertogeneraterecoveryasapatchfromthecurrent
#bootimage,orfromthepreviousrecoveryimage?Forlarge
#updateswithsignificantkernelchanges,probablytheformer.
#Forsmallupdateswherethekernelhasn'tchanged,almost
#certainlythelatter.Wepickthefirstoption.Future
#complicatedschemesmayletuseffectivelyuseboth.
#
#Awackypossibility:aslongasthereisroomintheboot
#partition,includethebinariesandimagefilesfromrecoveryin
#thebootimage(thoughnotintheramdisk)sotheycanbeused
#asfodderforconstructingtherecoveryimage.
MakeRecoveryPatch(output_zip,target_recovery,target_boot)
script.DeleteFiles(["/system/recovery-from-boot.p",
"/system/etc/install-recovery.sh"])
print"recoveryimagechanged;includingaspatchfromboot."
else:
print"recoveryimageunchanged;skipping."
script.ShowProgress(0.1,10)
target_symlinks=CopySystemFiles(target_zip,None)
target_symlinks_d=dict([(i[1],i[0])foriintarget_symlinks])
temp_script=script.MakeTemporary()
Item.GetMetadata(target_zip)
Item.Get("system").SetPermissions(temp_script)
#NotethatthiscallwillmessupthetreeofItems,somakesure
#we'redonewithit.
source_symlinks=CopySystemFiles(source_zip,None)
source_symlinks_d=dict([(i[1],i[0])foriinsource_symlinks])
#Deleteallthesymlinksinsourcethataren'tintarget.This
#needstohappenbeforeverbatimfilesareunpacked,incasea
#symlinkinthesourceisreplacedbyarealfileinthetarget.
to_delete=[]
fordest,linkinsource_symlinks:
iflinknotintarget_symlinks_d:
to_delete.append(link)
script.DeleteFiles(to_delete)
ifverbatim_targets:
script.Print("Unpackingnewfiles...")
script.UnpackPackageDir("system","/system")
ifupdating_recovery:
script.Print("Unpackingnewrecovery...")
script.UnpackPackageDir("recovery","/system")
script.Print("Symlinksandpermissions...")
#Createallthesymlinksthatdon'talreadyexist,orpointto
#somewheredifferentthanwhatwewant.Deleteeachsymlinkbefore
#creatingit,sincethe'symlink'commandwon'toverwrite.
to_create=[]
fordest,linkintarget_symlinks:
iflinkinsource_symlinks_d:
ifdest!=source_symlinks_d[link]:
to_create.append((dest,link))
else:
to_create.append((dest,link))
script.DeleteFiles([i[1]foriinto_create])
script.MakeSymlinks(to_create)
#Nowthatthesymlinksarecreated,wecansetallthe
#permissions.
script.AppendScript(temp_script)
#Dodevice-specificinstallation(eg,writeradioimage).
device_specific.IncrementalOTA_InstallEnd()
ifOPTIONS.extra_scriptisnotNone:
scirpt.AppendExtra(OPTIONS.extra_script)
script.AddToZip(target_zip,output_zip)
WriteMetadata(metadata,output_zip)
defmain(argv):
defoption_handler(o,a):
ifoin("-b","--board_config"):
pass#deprecated
elifoin("-k","--package_key"):
OPTIONS.package_key=a
elifoin("-i","--incremental_from"):
OPTIONS.incremental_source=a
elifoin("-w","--wipe_user_data"):
OPTIONS.wipe_user_data=True
elifoin("-n","--no_prereq"):
OPTIONS.omit_prereq=True
elifoin("-e","--extra_script"):
OPTIONS.extra_script=a
elifoin("--worker_threads"):
OPTIONS.worker_threads=int(a)
else:
returnFalse
returnTrue
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)
iflen(args)!=2:
common.Usage(__doc__)
sys.exit(1)
ifOPTIONS.extra_scriptisnotNone:
OPTIONS.extra_script=open(OPTIONS.extra_script).read()
print"unzippingtargettarget-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)
ifOPTIONS.verbose:
print"---targetinfo---"
common.DumpInfoDict(OPTIONS.info_dict)
ifOPTIONS.device_specificisNone:
OPTIONS.device_specific=OPTIONS.info_dict.get("tool_extensions",None)
ifOPTIONS.device_specificisnotNone:
OPTIONS.device_specific=os.path.normpath(OPTIONS.device_specific)
print"usingdevice-specificextensionsin",OPTIONS.device_specific
ifOPTIONS.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)
ifOPTIONS.incremental_sourceisNone:
WriteFullOTAPackage(input_zip,output_zip)
else:
print"unzippingsourcetarget-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)
ifOPTIONS.verbose:
print"---sourceinfo---"
common.DumpInfoDict(OPTIONS.source_info_dict)
WriteIncrementalOTAPackage(input_zip,source_zip,output_zip)
output_zip.close()
ifOPTIONS.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:])
exceptcommon.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）有关。此问题在下一篇博客已经解决。

在下一篇中讲解制作增量包失败的原因，以及解决方案。

-------------------------------------------

Android系统Recovery工作原理之使用update.zip升级过程分析（二）---update.zip差分包问题的解决

在上一篇末尾提到的生成差分包时出现的问题，现已解决，由于最近比较忙，相隔的时间也比较长，所以单列一个篇幅提示大家。这个问题居然是源码中的问题，可能你已经制作成功了，不过我的这个问题确实是源码中的一个问题，不知道是不是一个bug，下文会具体分析！

一、生成OTA增量包失败的解决方案

在上一篇中末尾使用ota_from_target_files脚本制作update.zip增量包时失败，我们先将出现的错误贴出来。

在执行这个脚本的最后读取input_zip中RADIO/bootloader.img时出现错误，显示DeviceSpecifiParams这个对象中没有input_zip属性。

我们先从脚本中出现错误的调用函数中开始查找。出现错误的调用地方是在函WriteIncrementalOTAPackage（443行）中的device_specific.IncrementalOTA_InstallEnd()，其位于WriteIncrementalOTAPackage()中的末尾。进一步跟踪源码发现，这是一个回调函数，他的具体执行方法位于源码中/device/telechips/common/releasetools.py脚本中的IncrementalOTA_InstallEnd()函数。下面就分析这个函数的作用。

releasetools.py脚本中的两个函数FullOTA_InstallEnd()和IncrementalOTA_InstallEnd()的作用都是从输入包中读取RADIO/下的bootloader.img文件写到输出包中，同时生成安装bootloader.img时执行脚本的那部分命令。只不过一个是直接将输入包中的bootloader.img镜像写到输出包中，一个是先比较target_zip和source_zip中的bootloader.img是否不同（使用选项-i生成差分包时），然后将新的镜像写入输出包中。下面先将这个函数(位于/device/telechips/common/releasetools.py)的具体实现贴出来：

我们的实际情况是，在用命令make otapackage时生成的包中是没有这个RADIO目录下的bootloader.img镜像文件（因为这部分更新已被屏蔽掉了）。但是这个函数中对于从包中未读取到bootloader.img文件的情况是有错误处理的，即返回。所以我们要从出现的实际错误中寻找问题的原由。

真正出现错误的地方是：

target_bootloader=info.input_zip.read(“RADIO/bootloader.img”)。

出现错误的原因是：AttributeError：‘DeviceSpecificParams’object has no attribute ‘input_zip’，提示我们DeviceSpecificParams对象没有input_zip这个属性。

在用ota_from_target_files脚本制作差分包时使用了选项-i，并且只有这种情况有三个参数，即target_zip 、source_zip、 out_zip。而出现错误的地方是target_bootloader=info.input_zip_read(“RADIO/bootloader.img”)，它使用的是input_zip，我们要怀疑这个地方是不是使用错了，而应该使用info.target_zip.read()。下面可以证实一下我们的猜测。

从ota_from_target_files脚本中WriteFullOTAPackage()和WriteIncrementalOTAPackage这两个函数（分别用来生成全包和差分包）可以发现，在他们的开始部分都对device_specific进行了赋值。其中WriteFullOTAPackage()对应的参数是input_zip和out_zip，而WriteIncrementalOTAPackage对应的是target_zip,source_zip,out_zip，我们可以看一下在WriteIncrementalOTAPackage函数中这部分的具体实现：

从上图可以发现，在WriteIncrementalOTAPackage函数对DeviceSpecificParams对象进行初始化时确实使用的是target_zip而不是input_zip。而在releasetools.py脚本中使用的却是info.input_zip.read()，所以才会出现DeviceSpecificParams对象没有input_zip这个属性。由此我们找到了问题的所在(这是不是源码中的一个Bug？)。

将releasetools.py脚本IncrementalOTA_InstallEnd(info)函数中的 target_bootloader=info.input_zip.

read(“RADIO/bootloader.img”)为：target_bootloader=info.target_zip.read(“RADIO/bootloader.img”)，然后重新执行上面提到的制作差分包命令。就生成了我们需要的差分包update.zip。

二、差分包update.zip的更新测试

在上面制作差分包脚本命令中，生成差分包的原理是，参照第一个参数（target_zip），将第二个参数（source_zip）中不同的部分输出到第三个参数（output_zip）中。其中target_zip与source_zip的先后顺序不同，产生的差分包也将不同。

在实际的测试过程中，我们的增量包要删除之前添加的一个应用（在使用update.zip全包升级时增加的），其他的部分如内核都没有改动，所以生成的差分包很简单，只有META-INF这个文件夹。主要的不同都体现在updater-script脚本中，其中的#----start make changes here----之后的部分就是做出改变的部分，最主要的脚本命令是：delete(“/system/app/CheckUpdateAll.apk” , “/system/recovery.img”);在具体更新时它将删除CheckUpdateAll.apk这个应用。

为了大家参考，还是把这个差分包的升级脚本贴出来，其对应的完全升级的脚本在第九篇已贴出：

[python] view plain copy print ?

mount("yaffs2","MTD","system","/system");
assert(file_getprop("/system/build.prop","ro.build.fingerprint")=="telechips/full_tcc8800_evm/tcc8800:2.3.5/GRJ90/eng.mumu.20120309.100232:eng/test-keys"||
file_getprop("/system/build.prop","ro.build.fingerprint")=="telechips/full_tcc8800_evm/tcc8800:2.3.5/GRJ90/eng.mumu.20120309.100232:eng/test-keys");
assert(getprop("ro.product.device")=="tcc8800"||
getprop("ro.build.product")=="tcc8800");
ui_print("Verifyingcurrentsystem...");
show_progress(0.100000,0);
#----startmakingchangeshere----
ui_print("Removingunneededfiles...");
delete("/system/app/CheckUpdateAll.apk",
"/system/recovery.img");
show_progress(0.800000,0);
ui_print("Patchingsystemfiles...");
show_progress(0.100000,10);
ui_print("Symlinksandpermissions...");
set_perm_recursive(0,0,0755,0644,"/system");
set_perm_recursive(0,2000,0755,0755,"/system/bin");
set_perm(0,3003,02750,"/system/bin/netcfg");
set_perm(0,3004,02755,"/system/bin/ping");
set_perm(0,2000,06750,"/system/bin/run-as");
set_perm_recursive(1002,1002,0755,0440,"/system/etc/bluetooth");
set_perm(0,0,0755,"/system/etc/bluetooth");
set_perm(1000,1000,0640,"/system/etc/bluetooth/auto_pairing.conf");
set_perm(3002,3002,0444,"/system/etc/bluetooth/blacklist.conf");
set_perm(1002,1002,0440,"/system/etc/dbus.conf");
set_perm(1014,2000,0550,"/system/etc/dhcpcd/dhcpcd-run-hooks");
set_perm(0,2000,0550,"/system/etc/init.goldfish.sh");
set_perm_recursive(0,0,0755,0555,"/system/etc/ppp");
set_perm_recursive(0,2000,0755,0755,"/system/xbin");
set_perm(0,0,06755,"/system/xbin/librank");
set_perm(0,0,06755,"/system/xbin/procmem");
set_perm(0,0,06755,"/system/xbin/procrank");
set_perm(0,0,06755,"/system/xbin/su");
set_perm(0,0,06755,"/system/xbin/tcpdump");
unmount("/system");

在做更新测试时，我们要以target_zip系统为依据，也就是更新之前的开发板系统是用target_zip包升级后的系统。否则会更新就会失败，因为在更新时会从系统对应的目录下读取设备以及时间戳等信息(updater-script脚本一开始的部分)，进行匹配正确后才进行下一步的安装。

所有准备都完成后，将我们制作的差分包放到SD卡中，在Settings-->About Phone-->System Update-->Installed From SDCARD执行更新。最后更新完成并重启后，我们会发现之前的CheckUpdateAll.apk被成功删掉了，大功告成！

至此终于将update.zip包以及其对应的差分包制作成功了，下面的文章开始具体分析制作的update.zip包在实际的更新中所走的过程！

----------------------------------------

Android系统Recovery工作原理之使用update.zip升级过程分析（三）---Android系统的三种启动模式

以下的篇幅开始分析我们在上两个篇幅中生成的update.zip包在具体更新中所经过的过程，并根据源码分析每一部分的工作原理。

一、系统更新update.zip包的两种方式

1. 通过上一个文档，我们知道了怎样制作一个update.zip升级包用于升级系统。Android在升级系统时获得update.zip包的方式有两种。一种是离线升级，即手动拷贝升级包到SD卡（或NAND）中，通过settings-->About phone-->System Update-->选择从SD卡升级。另一种是在线升级，即OTA Install(over the air)。用户通过在线下载升级包到本地，然后更新。这种方式下的update.zip包一般被下载到系统的/CACHE分区下。

2. 无论将升级包放在什么位置，在使用update.zip更新时都会重启并进入Recovery模式，然后启动recovery服务（/sbin/recovery）来安装我们的update.zip包。

3. 为此，我们必须了解Recovery模式的工作原理以及Android系统重启时怎样进入Recovery工作模式而不是其他模式（如正常模式）。

二、Android系统中三种启动模式

首先我们要了解Android系统启动后可能会进入的几种工作模式。先看下图：

由上图可知Android系统启动后可能进入的模式有以下几种：

(一)MAGIC KEY（组合键）：

即用户在启动后通过按下组合键，进入不同的工作模式，具体有两种：

① camera + power：若用户在启动刚开始按了camera+power组合键则会进入bootloader模式，并可进一步进入fastboot（快速刷机模式）。

② home + power ：若用户在启动刚开始按了home+power组合键，系统会直接进入Recovery模式。以这种方式进入Recovery模式时系统会进入一个简单的UI（使用了minui）界面，用来提示用户进一步操作。在tcc8800开发板中提供了一下几种选项操作：

“reboot system now”

“apply update from sdcard”

“wipe data/factory reset”

“wipe cache partition”

(二)正常启动：

若启动过程中用户没有按下任何组合键，bootloader会读取位于MISC分区的启动控制信息块BCB（Bootloader Control Block）。它是一个结构体，存放着启动命令command。根据不同的命令，系统又可以进入三种不同的启动模式。我们先看一下这个结构体的定义。

struct bootloader_message{

char command[32]; //存放不同的启动命令

char status[32]; //update-radio或update-hboot完成存放执行结果

char recovery[1024]; //存放/cache/recovery/command中的命令

};

我们先看command可能的值，其他的在后文具体分析。command可能的值有两种，与值为空（即没有命令）一起区分三种启动模式。

①command=="boot-recovery"时，系统会进入Recovery模式。Recovery服务会具体根据/cache/recovery/command中的命令执行相应的操作（例如，升级update.zip或擦除cache，data等）。

②command=="update-radia"或"update-hboot"时，系统会进入更新firmware（更新bootloader），具体由bootloader完成。

③command为空时，即没有任何命令，系统会进入正常的启动，最后进入主系统（main system）。这种是最通常的启动流程。

Android系统不同的启动模式的进入是在不同的情形下触发的，我们从SD卡中升级我们的update.zip时会进入Recovery模式是其中一种，其他的比如：系统崩溃，或则在命令行输入启动命令式也会进入Recovery或其他的启动模式。

为了解我们的update.zip包具体是怎样在Recovery模式中更新完成，并重启到主系统的，我们还要分析Android中Recovery模式的工作原理。

下一篇幅开始看具体的Recovery模式工作原理，以及其在更新中的重要作用。

-------------------------------

Android系统Recovery模式的工作原理

在使用update.zip包升级时怎样从主系统（main system）重启进入Recovery模式，进入Recovery模式后怎样判断做何种操作，以及怎样获得主系统发送给Recovery服务的命令，这一系列问题的解决是通过整个软件平台的不同部分之间的密切通信配合来完成的。为此，我们必须要了解Recovery模式的工作原理，这样才能知道我们的update.zip包是怎样一步步进入Recovery中升级并最后到达主系统的。

一、Recovery模式中的三个部分

Recovery的工作需要整个软件平台的配合，从通信架构上来看，主要有三个部分。

①MainSystem：即上面提到的正常启动模式（BCB中无命令），是用boot.img启动的系统，Android的正常工作模式。更新时，在这种模式中我们的上层操作就是使用OTA或则从SD卡中升级update.zip包。在重启进入Recovery模式之前，会向BCB中写入命令，以便在重启后告诉bootloader进入Recovery模式。

②Recovery：系统进入Recovery模式后会装载Recovery分区，该分区包含recovery.img（同boot.img相同，包含了标准的内核和根文件系统）。进入该模式后主要是运行Recovery服务（/sbin/recovery）来做相应的操作（重启、升级update.zip、擦除cache分区等）。

③Bootloader：除了正常的加载启动系统之外，还会通过读取MISC分区（BCB）获得来至Main system和Recovery的消息。

二、Recovery模式中的两个通信接口

在Recovery服务中上述的三个实体之间的通信是必不可少的，他们相互之间又有以下两个通信接口。

(一)通过CACHE分区中的三个文件：

Recovery通过/cache/recovery/目录下的三个文件与mian system通信。具体如下

①/cache/recovery/command：这个文件保存着Main system传给Recovery的命令行，每一行就是一条命令，支持一下几种的组合。

--send_intent=anystring //write the text out to recovery/intent 在Recovery结束时在finish_recovery函数中将定义的intent字符串作为参数传进来，并写入到/cache/recovery/intent中

--update_package=root:path //verify install an OTA package file Main system将这条命令写入时,代表系统需要升级，在进入Recovery模式后，将该文件中的命令读取并写入BCB中，然后进行相应的更新update.zip包的操作。

--wipe_data //erase user data(and cache),then reboot。擦除用户数据。擦除data分区时必须要擦除cache分区。

--wipe_cache //wipe cache(but not user data),then reboot。擦除cache分区。

②/cache/recovery/log：Recovery模式在工作中的log打印。在recovery服务运行过程中，stdout以及stderr会重定位到/tmp/recovery.log在recovery退出之前会将其转存到/cache/recovery/log中，供查看。

③/cache/recovery/intent：Recovery传递给Main system的信息。作用不详。

(二)通过BCB（Bootloader Control Block）：

BCB是bootloader与Recovery的通信接口，也是Bootloader与Main system之间的通信接口。存储在flash中的MISC分区，占用三个page，其本身就是一个结构体，具体成员以及各成员含义如下：

struct bootloader_message{

char command[32];

char status[32];

char recovery[1024];

};

①command成员：其可能的取值我们在上文已经分析过了，即当我们想要在重启进入Recovery模式时，会更新这个成员的值。另外在成功更新后结束Recovery时，会清除这个成员的值，防止重启时再次进入Recovery模式。

②status：在完成相应的更新后，Bootloader会将执行结果写入到这个字段。

③recovery：可被Main System写入，也可被Recovery服务程序写入。该文件的内容格式为：

“recovery\n

<recoverycommand>\n

<recoverycommand>”

该文件存储的就是一个字符串，必须以recovery\n开头，否则这个字段的所有内容域会被忽略。“recovery\n”之后的部分，是/cache/recovery/command支持的命令。可以将其理解为Recovery操作过程中对命令操作的备份。Recovery对其操作的过程为：先读取BCB然后读取/cache/recovery/command，然后将二者重新写回BCB，这样在进入Main system之前，确保操作被执行。在操作之后进入Main system之前，Recovery又会清空BCB的command域和recovery域，这样确保重启后不再进入Recovery模式。

三、如何从Main System重启并进入Recovery模式

我们先看一下以上三个部分是怎样进行通信的，先看下图：

我们只看从Main System如何进入Recovery模式，其他的通信在后文中详述。先从Main System开始看，当我们在Main System使用update.zip包进行升级时，系统会重启并进入Recovery模式。在系统重启之前，我们可以看到，Main System定会向BCB中的command域写入boot-recovery(粉红色线)，用来告知Bootloader重启后进入recovery模式。这一步是必须的。至于Main System是否向recovery域写入值我们在源码中不能肯定这一点。即便如此，重启进入Recovery模式后Bootloader会从/cache/recovery/command中读取值并放入到BCB的recovery域。而Main System在重启之前肯定会向/cache/recovery/command中写入Recovery将要进行的操作命令。

至此，我们就大概知道了，在上层使用update.zip升级时，主系统是怎样告知重启后的系统进入Recovery模式的，以及在Recovery模式中完成什么样的操作。

下一篇开始分析第一个阶段，即我们在上层使用update.zip包升级时，Main System怎样重启并进入Recovery服务的细节流程。

文章开头我们就提到update.zip包来源有两种，一个是OTA在线下载（一般下载到/CACHE分区），一个是手动拷贝到SD卡中。不论是哪种方式获得update.zip包，在进入Recovery模式前，都未对这个zip包做处理。只是在重启之前将zip包的路径告诉了Recovery服务（通过将--update_package=CACHE:some_filename.zip或--update_package=SDCARD:update.zip命令写入到/cache/recovery/command中）。在这里我们假设update.zip包已经制作好并拷贝到了SD卡中，并以Settings-->About Phone-->System Update-->Installed From SDCARD方式升级。

我们的测试开发板是TCC8800，使用的Android源码是gingerbread0919，在这种方式下升级的源码位于gingerbread/device/telechips/common/apps/TelechipsSystemUpdater/src/com/telechips/android/systemupdater/下。下面我们具体分析这种升级方式下，我们的update.zip是怎样从上层一步步进入到Recovery模式的。

一、从System Update到Reboot

当我们依次选择Settings-->About Phone-->System Update-->Installed From SDCARD后会弹出一个对话框，提示已有update.zip包是否现在更新，我们从这个地方跟踪。这个对话框的源码是SystemUpdateInstallDialog.java。

①在mNowButton按钮的监听事件里，会调用mService.rebootAndUpdate（new File(mFile)）。这个mService就是SystemUpdateService的实例。这个类所在的源码文件是SystemUpdateService.java。这个函数的参数是一个文件。它肯定就是我们的update.zip包了。我们可以证实一下这个猜想。

②mFile的值：在SystemUpdateInstallDialog.java中的ServiceConnection中我们可以看到这个mFile的值有两个来源。

来源一：

mFile的一个来源是这个是否立即更新提示框接受的上一个Activity以“file”标记传来的值。这个Activity就是SystemUpdate.java。它是一个PreferenceActivity类型的。在其onPreferenceChange函数中定义了向下一个Activity传送的值，这个值是根据我们不同的选择而定的。如果我们在之前选择了从SD卡安装，则这个传下去的“file”值为“/sdcard/update.zip”。如果选择了从NAND安装，则对应的值为“/nand/update.zip”。

来源二：

另个一来源是从mService.getInstallFile()获得。我们进一步跟踪就可发现上面这个函数获得的值就是“/cache”+ mUpdateFileURL.getFile();这就是OTA在线下载后对应的文件路径。不论参数mFile的来源如何，我们可以发现在mNowButton按钮的监听事件里是将整个文件，也就是我们的update.zip包作为参数往rebootAndUpdate（）中传递的。

③rebootAndUpdate:在这个函数中Main System做了重启前的准备。继续跟踪下去会发现，在SystemUpdateService.java中的rebootAndUpdate函数中新建了一个线程，在这个线程中最后调用的就是RecoverySystem.installPackage(mContext,mFile)，我们的update.zip包也被传递进来了。

④RecoverySystem类：RecoverySystem类的源码所在文件路径为：gingerbread0919/frameworks/base/core/java/android/os/RecoverySystem.java。我们关心的是installPackage(Context context,FilepackageFile)函数。这个函数首先根据我们传过来的包文件，获取这个包文件的绝对路径filename。然后将其拼成arg=“--update_package=”+filename。它最终会被写入到BCB中。这个就是重启进入Recovery模式后，Recovery服务要进行的操作。它被传递到函数bootCommand(context,arg)。

⑤bootCommand()：在这个函数中才是Main System在重启前真正做的准备。主要做了以下事情，首先创建/cache/recovery/目录，删除这个目录下的command和log（可能不存在）文件在sqlite数据库中的备份。然后将上面④步中的arg命令写入到/cache/recovery/command文件中。下一步就是真正重启了。接下来看一下在重启函数reboot中所做的事情。

⑥pm.reboot()：重启之前先获得了PowerManager（电源管理）并进一步获得其系统服务。然后调用了pm.reboot(“recovery”)函数。他就是/gingerbread0919/bionic/libc/unistd/reboot.c中的reboot函数。这个函数实际上是一个系统调用，即__reboot(LINUX_REBOOT_MAGIC1,LINUX_REBOOT_MAGIC2,mode,NULL);从这个函数我们可以看出前两个参数就代表了我们的组合键，mode就是我们传过来的“recovery”。再进一步跟踪就到了汇编代码了，我们无法直接查看它的具体实现细节。但可以肯定的是这个函数只将“recovery”参数传递过去了，之后将“boot-recovery”写入到了MISC分区的BCB数据块的command域中。这样在重启之后Bootloader才知道要进入Recovery模式。

在这里我们无法肯定Main System在重启之前对BCB的recovery域是否进行了操作。其实在重启前是否更新BCB的recovery域是不重要的，因为进入Recovery服务后，Recovery会自动去/cache/recovery/command中读取要进行的操作然后写入到BCB的recovery域中。

至此，Main System就开始重启并进入Recovery模式。在这之前Main System做的最实质的就是两件事，一是将“boot-recovery”写入BCB的command域，二是将--update_package=/cache/update.zip”或则“--update_package=/sdcard/update.zip”写入/cache/recovery/command文件中。下面的部分就开始重启并进入Recovery服务了。

二、从reboot到Recovery服务

这个过程我们在上文（对照第一个图）已经讲过了。从Bootloader开始如果没有组合键按下，就从MISC分区读取BCB块的command域（在主系统时已经将“boot-recovery”写入）。然后就以Recovery模式开始启动。与正常启动不同的是Recovery模式下加载的镜像是recovery.img。这个镜像同boot.img类似，也包含了标准的内核和根文件系统。其后就与正常的启动系统类似，也是启动内核，然后启动文件系统。在进入文件系统后会执行/init，init的配置文件就是/init.rc。这个配置文件来自bootable/recovery/etc/init.rc。查看这个文件我们可以看到它做的事情很简单：

①设置环境变量。

②建立etc连接。

③新建目录，备用。

④挂载/tmp为内存文件系统tmpfs

⑤启动recovery（/sbin/recovery）服务。

⑥启动adbd服务(用于调试)。

这里最重要的就是当然就recovery服务了。在Recovery服务中将要完成我们的升级工作。

我们将在下一篇详细分析Recovery服务的流程细节。

Recovery服务毫无疑问是Recovery启动模式中最核心的部分。它完成Recovery模式所有的工作。Recovery程序对应的源码文件位于：/gingerbread0919/bootable/recovery/recovery.c。

一、Recovery的三类服务：

先看一下在这个源码文件中开始部分的一大段注释，这将对我们理解Recovery服务的主要功能有很大帮助。代码如下：

[cpp] view plain copy print ?

/*
*Therecoverytoolcommunicateswiththemainsystemthrough/cachefiles.
*/cache/recovery/command-INPUT-commandlinefortool,oneargperline
*/cache/recovery/log-OUTPUT-combinedlogfilefromrecoveryrun(s)
*/cache/recovery/intent-OUTPUT-intentthatwaspassedin
*
*Theargumentswhichmaybesuppliedintherecovery.commandfile:
*--send_intent=anystring-writethetextouttorecovery.intent
*--update_package=path-verifyinstallanOTApackagefile
*--wipe_data-eraseuserdata(andcache),thenreboot
*--wipe_cache-wipecache(butnotuserdata),thenreboot
*--set_encrypted_filesystem=on|off-enables/diasablesencryptedfs
*
*Aftercompleting,weremove/cache/recovery/commandandreboot.
*Argumentsmayalsobesuppliedinthebootloadercontrolblock(BCB).
*Theseimportantscenariosmustbesafelyrestartableatanypoint:
*
*FACTORYRESET
*1.userselects"factoryreset"
*2.mainsystemwrites"--wipe_data"to/cache/recovery/command
*3.mainsystemrebootsintorecovery
*4.get_args()writesBCBwith"boot-recovery"and"--wipe_data"
*--afterthis,rebootingwillrestarttheerase--
*5.erase_volume()reformats/data
*6.erase_volume()reformats/cache
*7.finish_recovery()erasesBCB
*--afterthis,rebootingwillrestartthemainsystem--
*8.main()callsreboot()tobootmainsystem
*
*OTAINSTALL
*1.mainsystemdownloadsOTApackageto/cache/some-filename.zip
*2.mainsystemwrites"--update_package=/cache/some-filename.zip"
*3.mainsystemrebootsintorecovery
*4.get_args()writesBCBwith"boot-recovery"and"--update_package=..."
*--afterthis,rebootingwillattempttoreinstalltheupdate--
*5.install_package()attemptstoinstalltheupdate
*NOTE:thepackageinstallmustitselfberestartablefromanypoint
*6.finish_recovery()erasesBCB
*--afterthis,rebootingwill(tryto)restartthemainsystem--
*7.**ifinstallfailed**
*7a.prompt_and_wait()showsanerroriconandwaitsfortheuser
*7b;theuserreboots(pullingthebattery,etc)intothemainsystem
*8.main()callsmaybe_install_firmware_update()
***iftheupdatecontainedradio/hbootfirmware**:
*8a.m_i_f_u()writesBCBwith"boot-recovery"and"--wipe_cache"
*--afterthis,rebootingwillreformatcache&restartmainsystem--
*8b.m_i_f_u()writesfirmwareimageintorawcachepartition
*8c.m_i_f_u()writesBCBwith"update-radio/hboot"and"--wipe_cache"
*--afterthis,rebootingwillattempttoreinstallfirmware--
*8d.bootloadertriestoflashfirmware
*8e.bootloaderwritesBCBwith"boot-recovery"(keeping"--wipe_cache")
*--afterthis,rebootingwillreformatcache&restartmainsystem--
*8f.erase_volume()reformats/cache
*8g.finish_recovery()erasesBCB
*--afterthis,rebootingwill(tryto)restartthemainsystem--
*9.main()callsreboot()tobootmainsystem
*
*SECUREFILESYSTEMSENABLE/DISABLE
*1.userselects"enableencryptedfilesystems"
*2.mainsystemwrites"--set_encrypted_filesystems=on|off"to
*/cache/recovery/command
*3.mainsystemrebootsintorecovery
*4.get_args()writesBCBwith"boot-recovery"and
*"--set_encrypted_filesystems=on|off"
*--afterthis,rebootingwillrestartthetransition--
*5.read_encrypted_fs_info()retrievesencryptedfilesystemssettingsfrom/data
*Settingsinclude:propertytospecifytheEncryptedFSistatusand
*FSencryptionkeyifenabled(notyetimplemented)
*6.erase_volume()reformats/data
*7.erase_volume()reformats/cache
*8.restore_encrypted_fs_info()writesrequiredencryptedfilesystemssettingsto/data
*Settingsinclude:propertytospecifytheEncryptedFSstatusand
*FSencryptionkeyifenabled(notyetimplemented)
*9.finish_recovery()erasesBCB
*--afterthis,rebootingwillrestartthemainsystem--
*10.main()callsreboot()tobootmainsystem
*/

从注释中我们可以看到Recovery的服务内容主要有三类：

①FACTORY RESET，恢复出厂设置。

②OTA INSTALL，即我们的update.zip包升级。

③ENCRYPTED FILE SYSTEM ENABLE/DISABLE，使能/关闭加密文件系统。具体的每一类服务的大概工作流程，注释中都有，我们在下文中会详细讲解OTA INSTALL的工作流程。这三类服务的大概的流程都是通用的，只是不同操作体现与不同的操作细节。下面我们看Recovery服务的通用流程。

二、Recovery服务的通用流程：

在这里我们以OTA INSTALL的流程为例具体分析。并从相关函数的调用过程图开始，如下图:

我们顺着流程图分析，从recovery.c的main函数开始：

1. ui_init()：Recovery服务使用了一个基于framebuffer的简单ui（miniui）系统。这个函数对其进行了简单的初始化。在Recovery服务的过程中主要用于显示一个背景图片（正在安装或安装失败）和一个进度条（用于显示进度）。另外还启动了两个线程，一个用于处理进度条的显示（progress_thread），另一个用于响应用户的按键（input_thread）。

2. get_arg()：这个函数主要做了上图中get_arg()往右往下直到parse arg/v的工作。我们对照着流程一个一个看。

①get_bootloader_message()：主要工作是根据分区的文件格式类型（mtd或emmc）从MISC分区中读取BCB数据块到一个临时的变量中。

②然后开始判断Recovery服务是否有带命令行的参数（/sbin/recovery，根据现有的逻辑是没有的），若没有就从BCB中读取recovery域。如果读取失败则从/cache/recovery/command中读取然后。这样这个BCB的临时变量中的recovery域就被更新了。在将这个BCB的临时变量写回真实的BCB之前，又更新的这个BCB临时变量的command域为“boot-recovery”。这样做的目的是如果在升级失败（比如升级还未结束就断电了）时，系统在重启之后还会进入Recovery模式，直到升级完成。

③在这个BCB临时变量的各个域都更新完成后使用set_bootloader_message()写回到真正的BCB块中。

这个过程可以用一个简单的图来概括，这样更清晰：

3. parserargc/argv：解析我们获得参数。注册所解析的命令（register_update_command），在下面的操作中会根据这一步解析的值进行一步步的判断，然后进行相应的操作。

4. if(update_package)：判断update_package是否有值，若有就表示需要升级更新包，此时就会调用install_package()（即图中红色的第二个阶段）。在这一步中将要完成安装实际的升级包。这是最为复杂，也是升级update.zip包最为核心的部分。我们在下一节详细分析这一过程。为从宏观上理解Recovery服务的框架，我们将这一步先略过，假设已经安装完成了。我们接着往下走，看安装完成后Recovery怎样一步步结束服务，并重启到新的主系统的。

5. if(wipe_data/wipe_cache)：这一步判断实际是两步，在源码中是先判断是否擦除data分区（用户数据部分）的，然后再判断是否擦除cache分区。值得注意的是在擦除data分区的时候必须连带擦除cache分区。在只擦除cache分区的情形下可以不擦除data分区。

6. maybe_install_firmware_update()：如果升级包中包含/radio/hboot firmware的更新，则会调用这个函数。查看源码发现，在注释中（OTA INSTALL）有这一个流程。但是main函数中并没有显示调用这个函数。目前尚未发现到底是在什么地方处理。但是其流程还是向上面的图示一样。即，① 先向BCB中写入“boot-recovery”和“—wipe_cache”之后将cache分区格式化，然后将firmware image 写入原始的cache分区中。②将命令“update-radio/hboot”和“—wipe_cache”写入BCB中，然后开始重新安装firmware并刷新firmware。③之后又会进入图示中的末尾，即finish_recovery()。

7. prompt_and_wait()：这个函数是在一个判断中被调用的。其意义是如果安装失败（update.zip包错误或验证签名失败），则等待用户的输入处理（如通过组合键reboot等）。

8. finish_recovery()：这是Recovery关闭并进入Main System的必经之路。其大体流程如下：

①将intent（字符串）的内容作为参数传进finish_recovery中。如果有intent需要告知Main System，则将其写入/cache/recovery/intent中。这个intent的作用尚不知有何用。

②将内存文件系统中的Recovery服务的日志（/tmp/recovery.log）拷贝到cache（/cache/recovery/log）分区中，以便告知重启后的Main System发生过什么。

③擦除MISC分区中的BCB数据块的内容，以便系统重启后不在进入Recovery模式而是进入更新后的主系统。

④删除/cache/recovery/command文件。这一步也是很重要的，因为重启后Bootloader会自动检索这个文件，如果未删除的话又会进入Recovery模式。原理在上面已经讲的很清楚了。

9. reboot()：这是一个系统调用。在这一步Recovery完成其服务重启并进入Main System。这次重启和在主系统中重启进入Recovery模式调用的函数是一样的，但是其方向是不一样的。所以参数也就不一样。查看源码发现，其重启模式是RB_AUTOBOOT。这是一个系统的宏。

至此，我们对Recovery服务的整个流程框架已有了大概的认识。下面就是升级update.zip包时特有的也是Recovery服务中关于安装升级包最核心的第二个阶段。即我们图例中的红色2的那个分支。

我们将在下一篇详细讲解这一部分，即Recovery服务的核心部分install_package函数

一、Recovery服务的核心install_package（升级update.zip特有）

和Recovery服务中的wipe_data、wipe_cache不同，install_package()是升级update.zip特有的一部分，也是最核心的部分。在这一步才真正开始对我们的update.zip包进行处理。下面就开始分析这一部分。还是先看图例：

这一部分的源码文件位于：/gingerbread0919/bootable/recovery/install.c。这是一个没有main函数的源码文件，还是把源码先贴出来如下：

[cpp] view plain copy print ?

/*
*Copyright(C)2007TheAndroidOpenSourceProject
*
*LicensedundertheApacheLicense,Version2.0(the"License");
*youmaynotusethisfileexceptincompliancewiththeLicense.
*YoumayobtainacopyoftheLicenseat
*
*http://www.apache.org/licenses/LICENSE-2.0
*
*Unlessrequiredbyapplicablelaworagreedtoinwriting,software
*distributedundertheLicenseisdistributedonan"ASIS"BASIS,
*WITHOUTWARRANTIESORCONDITIONSOFANYKIND,eitherexpressorimplied.
*SeetheLicenseforthespecificlanguagegoverningpermissionsand
*limitationsundertheLicense.
*/
#include<ctype.h>
#include<errno.h>
#include<fcntl.h>
#include<limits.h>
#include<sys/stat.h>
#include<sys/wait.h>
#include<unistd.h>
#include"common.h"
#include"install.h"
#include"mincrypt/rsa.h"
#include"minui/minui.h"
#include"minzip/SysUtil.h"
#include"minzip/Zip.h"
#include"mtdutils/mounts.h"
#include"mtdutils/mtdutils.h"
#include"roots.h"
#include"verifier.h"
#defineASSUMED_UPDATE_BINARY_NAME"META-INF/com/google/android/update-binary"
#definePUBLIC_KEYS_FILE"/res/keys"
//Ifthepackagecontainsanupdatebinary,extractitandrunit.
staticint
try_update_binary(constchar*path,ZipArchive*zip){
constZipEntry*binary_entry=
mzFindZipEntry(zip,ASSUMED_UPDATE_BINARY_NAME);
if(binary_entry==NULL){
mzCloseZipArchive(zip);
returnINSTALL_CORRUPT;
}
char*binary="/tmp/update_binary";
unlink(binary);
intfd=creat(binary,0755);
if(fd<0){
mzCloseZipArchive(zip);
LOGE("Can'tmake%s\n",binary);
return1;
}
boolok=mzExtractZipEntryToFile(zip,binary_entry,fd);
close(fd);
mzCloseZipArchive(zip);
if(!ok){
LOGE("Can'tcopy%s\n",ASSUMED_UPDATE_BINARY_NAME);
return1;
}
intpipefd[2];
pipe(pipefd);
//Whenexecutingtheupdatebinarycontainedinthepackage,the
//argumentspassedare:
//
//-theversionnumberforthisinterface
//
//-anfdtowhichtheprogramcanwriteinordertoupdatethe
//progressbar.Theprogramcanwritesingle-linecommands:
//
//progress<frac><secs>
//fillupthenext<frac>partofoftheprogressbar
//over<secs>seconds.If<secs>iszero,use
//set_progresscommandstomanuallycontrolthe
//progressofthissegmentofthebar
//
//set_progress<frac>
//<frac>shouldbebetween0.0and1.0;setsthe
//progressbarwithinthesegmentdefinedbythemost
//recentprogresscommand.
//
//firmware<"hboot"|"radio"><filename>
//arrangetoinstallthecontentsof<filename>inthe
//givenpartitiononreboot.
//
//(APIv2:<filename>maystartwith"PACKAGE:"to
//indicatetakingafilefromtheOTApackage.)
//
//(APIv3:thiscommandnolongerexists.)
//
//ui_print<string>
//display<string>onthescreen.
//
//-thenameofthepackagezipfile.
//
char**args=malloc(sizeof(char*)*5);
args[0]=binary;
args[1]=EXPAND(RECOVERY_API_VERSION);//definedinAndroid.mk
args[2]=malloc(10);
sprintf(args[2],"%d",pipefd[1]);
args[3]=(char*)path;
args[4]=NULL;
pid_tpid=fork();
if(pid==0){
close(pipefd[0]);
execv(binary,args);
fprintf(stdout,"E:Can'trun%s(%s)\n",binary,strerror(errno));
_exit(-1);
}
close(pipefd[1]);
charbuffer[1024];
FILE*from_child=fdopen(pipefd[0],"r");
while(fgets(buffer,sizeof(buffer),from_child)!=NULL){
char*command=strtok(buffer,"\n");
if(command==NULL){
continue;
}elseif(strcmp(command,"progress")==0){
char*fraction_s=strtok(NULL,"\n");
char*seconds_s=strtok(NULL,"\n");
floatfraction=strtof(fraction_s,NULL);
intseconds=strtol(seconds_s,NULL,10);
ui_show_progress(fraction*(1-VERIFICATION_PROGRESS_FRACTION),
seconds);
}elseif(strcmp(command,"set_progress")==0){
char*fraction_s=strtok(NULL,"\n");
floatfraction=strtof(fraction_s,NULL);
ui_set_progress(fraction);
}elseif(strcmp(command,"ui_print")==0){
char*str=strtok(NULL,"\n");
if(str){
ui_print("%s",str);
}else{
ui_print("\n");
}
}else{
LOGE("unknowncommand[%s]\n",command);
}
}
fclose(from_child);
intstatus;
waitpid(pid,&status,0);
if(!WIFEXITED(status)||WEXITSTATUS(status)!=0){
LOGE("Errorin%s\n(Status%d)\n",path,WEXITSTATUS(status));
returnINSTALL_ERROR;
}
returnINSTALL_SUCCESS;
}
//Readsafilecontainingoneormorepublickeysasproducedby
//DumpPublicKey:thisisanRSAPublicKeystructasitwouldappear
//asaCsourceliteral,eg:
//
//"{64,0xc926ad21,{1795090719,...,-695002876},{-857949815,...,1175080310}}"
//
//(Notethatthebracesandcommasinthisexampleareactual
//characterstheparserexpectstofindinthefile;theellipses
//indicatemorenumbersomittedfromthisexample.)
//
//Thefilemaycontainmultiplekeysinthisformat,separatedby
//commas.Thelastkeymustnotbefollowedbyacomma.
//
//ReturnsNULLifthefilefailedtoparse,orifitcontainzerokeys.
staticRSAPublicKey*
load_keys(constchar*filename,int*numKeys){
RSAPublicKey*out=NULL;
*numKeys=0;
FILE*f=fopen(filename,"r");
if(f==NULL){
LOGE("opening%s:%s\n",filename,strerror(errno));
gotoexit;
}
inti;
booldone=false;
while(!done){
++*numKeys;
out=realloc(out,*numKeys*sizeof(RSAPublicKey));
RSAPublicKey*key=out+(*numKeys-1);
if(fscanf(f,"{%i,0x%x,{%u",
&(key->len),&(key->n0inv),&(key->n[0]))!=3){
gotoexit;
}
if(key->len!=RSANUMWORDS){
LOGE("keylength(%d)doesnotmatchexpectedsize\n",key->len);
gotoexit;
}
for(i=1;i<key->len;++i){
if(fscanf(f,",%u",&(key->n[i]))!=1)gotoexit;
}
if(fscanf(f,"},{%u",&(key->rr[0]))!=1)gotoexit;
for(i=1;i<key->len;++i){
if(fscanf(f,",%u",&(key->rr[i]))!=1)gotoexit;
}
fscanf(f,"}}");
//ifthelineendsinacomma,thisfilehasmorekeys.
switch(fgetc(f)){
case',':
//morekeystocome.
break;
caseEOF:
done=true;
break;
default:
LOGE("unexpectedcharacterbetweenkeys\n");
gotoexit;
}
}
fclose(f);
returnout;
exit:
if(f)fclose(f);
free(out);
*numKeys=0;
returnNULL;
}
int
install_package(constchar*path)
{
ui_set_background(BACKGROUND_ICON_INSTALLING);
ui_print("Findingupdatepackage...\n");
ui_show_indeterminate_progress();
LOGI("Updatelocation:%s\n",path);
if(ensure_path_mounted(path)!=0){
LOGE("Can'tmount%s\n",path);
returnINSTALL_CORRUPT;
}
ui_print("Openingupdatepackage...\n");
intnumKeys;
RSAPublicKey*loadedKeys=load_keys(PUBLIC_KEYS_FILE,&numKeys);
if(loadedKeys==NULL){
LOGE("Failedtoloadkeys\n");
returnINSTALL_CORRUPT;
}
LOGI("%dkey(s)loadedfrom%s\n",numKeys,PUBLIC_KEYS_FILE);
//Giveverificationhalftheprogressbar...
ui_print("Verifyingupdatepackage...\n");
ui_show_progress(
VERIFICATION_PROGRESS_FRACTION,
VERIFICATION_PROGRESS_TIME);
interr;
err=verify_file(path,loadedKeys,numKeys);
free(loadedKeys);
LOGI("verify_filereturned%d\n",err);
if(err!=VERIFY_SUCCESS){
LOGE("signatureverificationfailed\n");
returnINSTALL_CORRUPT;
}
/*Trytoopenthepackage.
*/
ZipArchivezip;
err=mzOpenZipArchive(path,&zip);
if(err!=0){
LOGE("Can'topen%s\n(%s)\n",path,err!=-1?strerror(err):"bad");
returnINSTALL_CORRUPT;
}
/*Verifyandinstallthecontentsofthepackage.
*/
ui_print("Installingupdate...\n");
returntry_update_binary(path,&zip);
}

下面顺着上面的流程图和源码来分析这一流程：

①ensure_path_mount()：先判断所传的update.zip包路径所在的分区是否已经挂载。如果没有则先挂载。

②load_keys()：加载公钥源文件，路径位于/res/keys。这个文件在Recovery镜像的根文件系统中。

③verify_file()：对升级包update.zip包进行签名验证。

④mzOpenZipArchive()：打开升级包，并将相关的信息拷贝到一个临时的ZipArchinve变量中。这一步并未对我们的update.zip包解压。

⑤try_update_binary()：在这个函数中才是对我们的update.zip升级的地方。这个函数一开始先根据我们上一步获得的zip包信息，以及升级包的绝对路径将update_binary文件拷贝到内存文件系统的/tmp/update_binary中。以便后面使用。

⑥pipe()：创建管道，用于下面的子进程和父进程之间的通信。

⑦fork()：创建子进程。其中的子进程主要负责执行binary（execv(binary,args)，即执行我们的安装命令脚本），父进程负责接受子进程发送的命令去更新ui显示（显示当前的进度）。子父进程间通信依靠管道。

⑧其中，在创建子进程后，父进程有两个作用。一是通过管道接受子进程发送的命令来更新UI显示。二是等待子进程退出并返回INSTALL SUCCESS。其中子进程在解析执行安装脚本的同时所发送的命令有以下几种：

progress <frac><secs>：根据第二个参数secs（秒）来设置进度条。

set_progress <frac>：直接设置进度条，frac取值在0.0到0.1之间。

更多相关文章

随机推荐