Android系統Recovery工做原理之使用update.zip升級過程分析（一）---u...

時間  2019-12-06
標籤 android 系統 recovery 原理 使用 update.zip update zip 升級 過程 分析 欄目 Android 简体版
原文   原文鏈接
 這篇及之後的篇幅將經過分析update.zip包在具體Android系統升級的過程，來理解Android系統中Recovery模式服務的工做原理。咱們先從update.zip包的製做開始，而後是Android系統的啓動模式分析，Recovery工做原理，如何從咱們上層開始選擇system update到重啓到Recovery服務，以及在Recovery服務中具體怎樣處理update.zip包升級的，咱們的安裝腳本updater-script怎樣被解析並執行的等一系列問題。分析過程當中所用的Android源碼是gingerbread0919（tcc88xx開發板標配的），測試開發板是tcc88xx。這是在工做中總結的文檔，固然在網上參考了很多內容，若有雷同純屬巧合吧，在分析過程當中也存在不少未解決的問題，也但願你們不吝指教。


1、 update.zip包的目錄結構
          |----boot.img
          |----system/
          |----recovery/
                `|----recovery-from-boot.p
                `|----etc/
                        `|----install-recovery.sh
          |---META-INF/
              `|CERT.RSA
              `|CERT.SF
              `|MANIFEST.MF
              `|----com/
                     `|----google/
                             `|----android/
                                    `|----update-binary
                                    `|----updater-script
                             `|----android/
                                    `|----metadata
2、 update.zip包目錄結構詳解
         以上是咱們用命令make otapackage 製做的update.zip包的標準目錄結構。
          一、boot.img是更新boot分區所須要的文件。這個boot.img主要包括kernel+ramdisk。

         二、system/目錄的內容在升級後會放在系統的system分區。主要用來更新系統的一些應用或則應用會用到的一些庫等等。能夠將Android源碼編譯out/target/product/tcc8800/system/中的全部文件拷貝到這個目錄來代替。java

          三、recovery/目錄中的recovery-from-boot.p是boot.img和recovery.img的補丁(patch),主要用來更新recovery分區，其中etc/目錄下的install-recovery.sh是更新腳本。
          四、update-binary是一個二進制文件，至關於一個腳本解釋器，可以識別updater-script中描述的操做。該文件在Android源碼編譯後out/target/product/tcc8800/system bin/updater生成，可將updater重命名爲update-binary獲得。
               該文件在具體的更新包中的名字由源碼中bootable/recovery/install.c中的宏ASSUMED_UPDATE_BINARY_NAME的值而定。
          五、updater-script：此文件是一個腳本文件，具體描述了更新過程。咱們能夠根據具體狀況編寫該腳原本適應咱們的具體需求。該文件的命名由源碼中bootable/recovery/updater/updater.c文件中的宏SCRIPT_NAME的值而定。
          六、 metadata文件是描述設備信息及環境變量的元數據。主要包括一些編譯選項，簽名公鑰，時間戳以及設備型號等。
          七、咱們還能夠在包中添加userdata目錄，來更新系統中的用戶數據部分。這部份內容在更新後會存放在系統的/data目錄下。

         八、update.zip包的簽名：update.zip更新包在製做完成後須要對其簽名，不然在升級時會出現認證失敗的錯誤提示。並且簽名要使用和目標板一致的加密公鑰。加密公鑰及加密須要的三個文件在Android源碼編譯後生成的具體路徑爲：node

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

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

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

              咱們用命令make otapackage製做生成的update.zip包是已簽過名的，若是本身作update.zip包時必須手動對其簽名。git

              具體的加密方法：$ 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包是命令執行完生成的已經簽過名的包。
          九、MANIFEST.MF：這個manifest文件定義了與包的組成結構相關的數據。相似Android應用的mainfest.xml文件。
        十、CERT.RSA：與簽名文件相關聯的簽名程序塊文件，它存儲了用於簽名JAR文件的公共簽名。
        十一、CERT.SF：這是JAR文件的簽名文件，其中前綴CERT表明簽名者。
        另外，在具體升級時，對update.zip包檢查時大體會分三步：①檢驗SF文件與RSA文件是否匹配。②檢驗MANIFEST.MF與簽名文件中的digest是否一致。③檢驗包中的文件與MANIFEST中所描述的是否一致。
3、 Android升級包update.zip的生成過程分析

         1) 對於update.zip包的製做有兩種方式，即手動製做和命令生成。shell

          第一種手動製做：即按照update.zip的目錄結構手動建立咱們須要的目錄。而後將對應的文件拷貝到相應的目錄下，好比咱們向系統中新加一個應用程序。能夠將新增的應用拷貝到咱們新建的update/system/app/下（system目錄是事先拷貝編譯源碼後生成的system目錄），打包並簽名後，拷貝到SD卡就可使用了。這種方式在實際的tcc8800開發板中未測試成功。簽名部分未經過，可能與具體的開發板相關。express

          第二種製做方式：命令製做。Android源碼系統中爲咱們提供了製做update.zip刷機包的命令，即make otapackage。該命令在編譯源碼完成後並在源碼根目錄下執行。 具體操做方式：在源碼根目錄下執行apache

                ①$ . build/envsetup.sh。 api

                ②$ 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貼出來以下：

          

[plain] view plain copy print ?
  1. # -----------------------------------------------------------------  
  2. # A zip of the directories that map to the target filesystem.  
  3. # This zip can be used to create an OTA package or filesystem image  
  4. # as a post-build step.  
  5. #  
  6. name := $(TARGET_PRODUCT)  
  7. ifeq ($(TARGET_BUILD_TYPE),debug)  
  8.   name := $(name)_debug  
  9. endif  
  10. name := $(name)-target_files-$(FILE_NAME_TAG)  
  11.   
  12. intermediates := $(call intermediates-dir-for,PACKAGING,target_files)  
  13. BUILT_TARGET_FILES_PACKAGE := $(intermediates)/$(name).zip  
  14. $(BUILT_TARGET_FILES_PACKAGE): intermediates := $(intermediates)  
  15. $(BUILT_TARGET_FILES_PACKAGE): \  
  16.         zip_root := $(intermediates)/$(name)  
  17.   
  18. # $(1): Directory to copy  
  19. # $(2): Location to copy it to  
  20. # The "ls -A" is to prevent "acp s/* d" from failing if s is empty.  
  21. define package_files-copy-root  
  22.   if [ -d "$(strip $(1))" -a "$$(ls -A $(1))" ]; then \  
  23.     mkdir -p $(2) && \  
  24.     $(ACP) -rd $(strip $(1))/* $(2); \  
  25.   fi  
  26. endef  
  27.   
  28. built_ota_tools := \  
  29.     $(call intermediates-dir-for,EXECUTABLES,applypatch)/applypatch \  
  30.     $(call intermediates-dir-for,EXECUTABLES,applypatch_static)/applypatch_static \  
  31.     $(call intermediates-dir-for,EXECUTABLES,check_prereq)/check_prereq \  
  32.     $(call intermediates-dir-for,EXECUTABLES,updater)/updater  
  33. $(BUILT_TARGET_FILES_PACKAGE): PRIVATE_OTA_TOOLS := $(built_ota_tools)  
  34.   
  35. $(BUILT_TARGET_FILES_PACKAGE): PRIVATE_RECOVERY_API_VERSION := $(RECOVERY_API_VERSION)  
  36.   
  37. ifeq ($(TARGET_RELEASETOOLS_EXTENSIONS),)  
  38. # default to common dir for device vendor  
  39. $(BUILT_TARGET_FILES_PACKAGE): tool_extensions := $(TARGET_DEVICE_DIR)/../common  
  40. else  
  41. $(BUILT_TARGET_FILES_PACKAGE): tool_extensions := $(TARGET_RELEASETOOLS_EXTENSIONS)  
  42. endif  
  43.   
  44. # Depending on the various images guarantees that the underlying  
  45. # directories are up-to-date.  
  46. $(BUILT_TARGET_FILES_PACKAGE): \  
  47.         $(INSTALLED_BOOTIMAGE_TARGET) \  
  48.         $(INSTALLED_RADIOIMAGE_TARGET) \  
  49.         $(INSTALLED_RECOVERYIMAGE_TARGET) \  
  50.         $(INSTALLED_SYSTEMIMAGE) \  
  51.         $(INSTALLED_USERDATAIMAGE_TARGET) \  
  52.         $(INSTALLED_ANDROID_INFO_TXT_TARGET) \  
  53.         $(built_ota_tools) \  
  54.         $(APKCERTS_FILE) \  
  55.         $(HOST_OUT_EXECUTABLES)/fs_config \  
  56.         | $(ACP)  
  57.     @echo "Package target files: $@"  
  58.     $(hide) rm -rf $@ $(zip_root)  
  59.     $(hide) mkdir -p $(dir $@) $(zip_root)  
  60.     @# Components of the recovery image  
  61.     $(hide) mkdir -p $(zip_root)/RECOVERY  
  62.     $(hide) $(call package_files-copy-root, \  
  63.         $(TARGET_RECOVERY_ROOT_OUT),$(zip_root)/RECOVERY/RAMDISK)  
  64. ifdef INSTALLED_KERNEL_TARGET  
  65.     $(hide) $(ACP) $(INSTALLED_KERNEL_TARGET) $(zip_root)/RECOVERY/kernel  
  66. endif  
  67. ifdef INSTALLED_2NDBOOTLOADER_TARGET  
  68.     $(hide) $(ACP) \  
  69.         $(INSTALLED_2NDBOOTLOADER_TARGET) $(zip_root)/RECOVERY/second  
  70. endif  
  71. ifdef BOARD_KERNEL_CMDLINE  
  72.     $(hide) echo "$(BOARD_KERNEL_CMDLINE)" > $(zip_root)/RECOVERY/cmdline  
  73. endif  
  74. ifdef BOARD_KERNEL_BASE  
  75.     $(hide) echo "$(BOARD_KERNEL_BASE)" > $(zip_root)/RECOVERY/base  
  76. endif  
  77. ifdef BOARD_KERNEL_PAGESIZE  
  78.     $(hide) echo "$(BOARD_KERNEL_PAGESIZE)" > $(zip_root)/RECOVERY/pagesize  
  79. endif  
  80.     @# Components of the boot image  
  81.     $(hide) mkdir -p $(zip_root)/BOOT  
  82.     $(hide) $(call package_files-copy-root, \  
  83.         $(TARGET_ROOT_OUT),$(zip_root)/BOOT/RAMDISK)  
  84. ifdef INSTALLED_KERNEL_TARGET  
  85.     $(hide) $(ACP) $(INSTALLED_KERNEL_TARGET) $(zip_root)/BOOT/kernel  
  86. endif  
  87. ifdef INSTALLED_2NDBOOTLOADER_TARGET  
  88.     $(hide) $(ACP) \  
  89.         $(INSTALLED_2NDBOOTLOADER_TARGET) $(zip_root)/BOOT/second  
  90. endif  
  91. ifdef BOARD_KERNEL_CMDLINE  
  92.     $(hide) echo "$(BOARD_KERNEL_CMDLINE)" > $(zip_root)/BOOT/cmdline  
  93. endif  
  94. ifdef BOARD_KERNEL_BASE  
  95.     $(hide) echo "$(BOARD_KERNEL_BASE)" > $(zip_root)/BOOT/base  
  96. endif  
  97. ifdef BOARD_KERNEL_PAGESIZE  
  98.     $(hide) echo "$(BOARD_KERNEL_PAGESIZE)" > $(zip_root)/BOOT/pagesize  
  99. endif  
  100.     $(hide) $(foreach t,$(INSTALLED_RADIOIMAGE_TARGET),\  
  101.                 mkdir -p $(zip_root)/RADIO; \  
  102.                 $(ACP) $(t) $(zip_root)/RADIO/$(notdir $(t));)  
  103.     @# Contents of the system image  
  104.     $(hide) $(call package_files-copy-root, \  
  105.         $(SYSTEMIMAGE_SOURCE_DIR),$(zip_root)/SYSTEM)  
  106.     @# Contents of the data image  
  107.     $(hide) $(call package_files-copy-root, \  
  108.         $(TARGET_OUT_DATA),$(zip_root)/DATA)  
  109.     @# Extra contents of the OTA package  
  110.     $(hide) mkdir -p $(zip_root)/OTA/bin  
  111.     $(hide) $(ACP) $(INSTALLED_ANDROID_INFO_TXT_TARGET) $(zip_root)/OTA/  
  112.     $(hide) $(ACP) $(PRIVATE_OTA_TOOLS) $(zip_root)/OTA/bin/  
  113.     @# Files that do not end up in any images, but are necessary to  
  114.     @# build them.  
  115.     $(hide) mkdir -p $(zip_root)/META  
  116.     $(hide) $(ACP) $(APKCERTS_FILE) $(zip_root)/META/apkcerts.txt  
  117.     $(hide) echo "$(PRODUCT_OTA_PUBLIC_KEYS)" > $(zip_root)/META/otakeys.txt  
  118.     $(hide) echo "recovery_api_version=$(PRIVATE_RECOVERY_API_VERSION)" > $(zip_root)/META/misc_info.txt  
  119. ifdef BOARD_FLASH_BLOCK_SIZE  
  120.     $(hide) echo "blocksize=$(BOARD_FLASH_BLOCK_SIZE)" >> $(zip_root)/META/misc_info.txt  
  121. endif  
  122. ifdef BOARD_BOOTIMAGE_PARTITION_SIZE  
  123.     $(hide) echo "boot_size=$(BOARD_BOOTIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt  
  124. endif  
  125. ifdef BOARD_RECOVERYIMAGE_PARTITION_SIZE  
  126.     $(hide) echo "recovery_size=$(BOARD_RECOVERYIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt  
  127. endif  
  128. ifdef BOARD_SYSTEMIMAGE_PARTITION_SIZE  
  129.     $(hide) echo "system_size=$(BOARD_SYSTEMIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt  
  130. endif  
  131. ifdef BOARD_USERDATAIMAGE_PARTITION_SIZE  
  132.     $(hide) echo "userdata_size=$(BOARD_USERDATAIMAGE_PARTITION_SIZE)" >> $(zip_root)/META/misc_info.txt  
  133. endif  
  134.     $(hide) echo "tool_extensions=$(tool_extensions)" >> $(zip_root)/META/misc_info.txt  
  135. ifdef mkyaffs2_extra_flags  
  136.     $(hide) echo "mkyaffs2_extra_flags=$(mkyaffs2_extra_flags)" >> $(zip_root)/META/misc_info.txt  
  137. endif  
  138.     @# Zip everything up, preserving symlinks  
  139.     $(hide) (cd $(zip_root) && zip -qry ../$(notdir $@) .)  
  140.     @# Run fs_config on all the system files in the zip, and save the output  
  141.     $(hide) zipinfo -1 $@ | awk -F/ 'BEGIN { OFS="/" } /^SYSTEM\// {$$1 = "system"; print}' | $(HOST_OUT_EXECUTABLES)/fs_config > $(zip_root)/META/filesystem_config.txt  
  142.     $(hide) (cd $(zip_root) && zip -q ../$(notdir $@) META/filesystem_config.txt)  
  143.   
  144.   
  145. target-files-package: $(BUILT_TARGET_FILES_PACKAGE)  
  146.   
  147.   
  148. ifneq ($(TARGET_SIMULATOR),true)  
  149. ifneq ($(TARGET_PRODUCT),sdk)  
  150. ifneq ($(TARGET_DEVICE),generic)  
  151. ifneq ($(TARGET_NO_KERNEL),true)  
  152. ifneq ($(recovery_fstab),)  
# ----------------------------------------------------------------- # 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 plain copy print ?
  1. #!/usr/bin/env python   
  2. #   
  3. # Copyright (C) 2008 The Android Open Source Project   
  4. #   
  5. # Licensed under the Apache License, Version 2.0 (the "License");   
  6. # you may not use this file except in compliance with the License.   
  7. # You may obtain a copy of the License at   
  8. #   
  9. #      http://www.apache.org/licenses/LICENSE-2.0   
  10. #   
  11. # Unless required by applicable law or agreed to in writing, software   
  12. # distributed under the License is distributed on an "AS IS" BASIS,   
  13. # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   
  14. # See the License for the specific language governing permissions and   
  15. # limitations under the License.   
  16.   
  17. """ 
  18. Given a target-files zipfile, produces an OTA package that installs 
  19. that build.  An incremental OTA is produced if -i is given, otherwise 
  20. a full OTA is produced. 
  21.  
  22. Usage:  ota_from_target_files [flags] input_target_files output_ota_package 
  23.  
  24.   -b  (--board_config)  <file> 
  25.       Deprecated. 
  26.  
  27.   -k  (--package_key)  <key> 
  28.       Key to use to sign the package (default is 
  29.       "build/target/product/security/testkey"). 
  30.  
  31.   -i  (--incremental_from)  <file> 
  32.       Generate an incremental OTA using the given target-files zip as 
  33.       the starting build. 
  34.  
  35.   -w  (--wipe_user_data) 
  36.       Generate an OTA package that will wipe the user data partition 
  37.       when installed. 
  38.  
  39.   -n  (--no_prereq) 
  40.       Omit the timestamp prereq check normally included at the top of 
  41.       the build scripts (used for developer OTA packages which 
  42.       legitimately need to go back and forth). 
  43.  
  44.   -e  (--extra_script)  <file> 
  45.       Insert the contents of file at the end of the update script. 
  46.  
  47. """  
#!/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 plain copy print ?
  1. import sys  
  2.   
  3. if sys.hexversion < 0x02040000:  
  4.   print >> sys.stderr, "Python 2.4 or newer is required."  
  5.   sys.exit(1)  
  6.   
  7. import copy  
  8. import errno  
  9. import os  
  10. import re  
  11. import sha  
  12. import subprocess  
  13. import tempfile  
  14. import time  
  15. import zipfile  
  16.   
  17. import common  
  18. import edify_generator  
  19.   
  20. OPTIONS = common.OPTIONS  
  21. OPTIONS.package_key = "build/target/product/security/testkey"  
  22. OPTIONS.incremental_source = None  
  23. OPTIONS.require_verbatim = set()  
  24. OPTIONS.prohibit_verbatim = set(("system/build.prop",))  
  25. OPTIONS.patch_threshold = 0.95  
  26. OPTIONS.wipe_user_data = False  
  27. OPTIONS.omit_prereq = False  
  28. OPTIONS.extra_script = None  
  29. OPTIONS.worker_threads = 3  
  30.   
  31. def MostPopularKey(d, default):  
  32.   """Given a dict, return the key corresponding to the largest 
  33.   value.  Returns 'default' if the dict is empty."""  
  34.   x = [(v, k) for (k, v) in d.iteritems()]  
  35.   if not x: return default  
  36.   x.sort()  
  37.   return x[-1][1]  
  38.   
  39.   
  40. def IsSymlink(info):  
  41.   """Return true if the zipfile.ZipInfo object passed in represents a 
  42.   symlink."""  
  43.   return (info.external_attr >> 16) == 0120777  
  44.   
  45.   
  46. class Item:  
  47.   """Items represent the metadata (user, group, mode) of files and 
  48.   directories in the system image."""  
  49.   ITEMS = {}  
  50.   def __init__(self, name, dir=False):  
  51.     self.name = name  
  52.     self.uid = None  
  53.     self.gid = None  
  54.     self.mode = None  
  55.     self.dir = dir  
  56.   
  57.     if name:  
  58.       self.parent = Item.Get(os.path.dirname(name), dir=True)  
  59.       self.parent.children.append(self)  
  60.     else:  
  61.       self.parent = None  
  62.     if dir:  
  63.       self.children = []  
  64.   
  65.   def Dump(self, indent=0):  
  66.     if self.uid is not None:  
  67.       print "%s%s %d %d %o" % ("  "*indent, self.name, self.uid, self.gid, self.mode)  
  68.     else:  
  69.       print "%s%s %s %s %s" % ("  "*indent, self.name, self.uid, self.gid, self.mode)  
  70.     if self.dir:  
  71.       print "%s%s" % ("  "*indent, self.descendants)  
  72.       print "%s%s" % ("  "*indent, self.best_subtree)  
  73.       for i in self.children:  
  74.         i.Dump(indent=indent+1)  
  75.  
  76.   @classmethod  
  77.   def Get(cls, name, dir=False):  
  78.     if name not in cls.ITEMS:  
  79.       cls.ITEMS[name] = Item(name, dir=dir)  
  80.     return cls.ITEMS[name]  
  81.  
  82.   @classmethod  
  83.   def GetMetadata(cls, input_zip):  
  84.   
  85.     try:  
  86.       # See if the target_files contains a record of what the uid,   
  87.       # gid, and mode is supposed to be.   
  88.       output = input_zip.read("META/filesystem_config.txt")  
  89.     except KeyError:  
  90.       # Run the external 'fs_config' program to determine the desired   
  91.       # uid, gid, and mode for every Item object.  Note this uses the   
  92.       # one in the client now, which might not be the same as the one   
  93.       # used when this target_files was built.   
  94.       p = common.Run(["fs_config"], stdin=subprocess.PIPE,  
  95.                      stdout=subprocess.PIPE, stderr=subprocess.PIPE)  
  96.       suffix = { False: "", True: "/" }  
  97.       input = "".join(["%s%s\n" % (i.name, suffix[i.dir])  
  98.                        for i in cls.ITEMS.itervalues() if i.name])  
  99.       output, error = p.communicate(input)  
  100.       assert not error  
  101.   
  102.     for line in output.split("\n"):  
  103.       if not line: continue  
  104.       name, uid, gid, mode = line.split()  
  105.       i = cls.ITEMS.get(name, None)  
  106.       if i is not None:  
  107.         i.uid = int(uid)  
  108.         i.gid = int(gid)  
  109.         i.mode = int(mode, 8)  
  110.         if i.dir:  
  111.           i.children.sort(key=lambda i: i.name)  
  112.   
  113.     # set metadata for the files generated by this script.   
  114.     i = cls.ITEMS.get("system/recovery-from-boot.p", None)  
  115.     if i: i.uid, i.gid, i.mode = 0, 0, 0644  
  116.     i = cls.ITEMS.get("system/etc/install-recovery.sh", None)  
  117.     if i: i.uid, i.gid, i.mode = 0, 0, 0544  
  118.   
  119.   def CountChildMetadata(self):  
  120.     """Count up the (uid, gid, mode) tuples for all children and 
  121.     determine the best strategy for using set_perm_recursive and 
  122.     set_perm to correctly chown/chmod all the files to their desired 
  123.     values.  Recursively calls itself for all descendants. 
  124.  
  125.     Returns a dict of {(uid, gid, dmode, fmode): count} counting up 
  126.     all descendants of this node.  (dmode or fmode may be None.)  Also 
  127.     sets the best_subtree of each directory Item to the (uid, gid, 
  128.     dmode, fmode) tuple that will match the most descendants of that 
  129.     Item. 
  130.     """  
  131.   
  132.     assert self.dir  
  133.     d = self.descendants = {(self.uid, self.gid, self.mode, None): 1}  
  134.     for i in self.children:  
  135.       if i.dir:  
  136.         for k, v in i.CountChildMetadata().iteritems():  
  137.           d[k] = d.get(k, 0) + v  
  138.       else:  
  139.         k = (i.uid, i.gid, None, i.mode)  
  140.         d[k] = d.get(k, 0) + 1  
  141.   
  142.     # Find the (uid, gid, dmode, fmode) tuple that matches the most   
  143.     # descendants.   
  144.   
  145.     # First, find the (uid, gid) pair that matches the most   
  146.     # descendants.   
  147.     ug = {}  
  148.     for (uid, gid, _, _), count in d.iteritems():  
  149.       ug[(uid, gid)] = ug.get((uid, gid), 0) + count  
  150.     ug = MostPopularKey(ug, (0, 0))  
  151.   
  152.     # Now find the dmode and fmode that match the most descendants   
  153.     # with that (uid, gid), and choose those.   
  154.     best_dmode = (0, 0755)  
  155.     best_fmode = (0, 0644)  
  156.     for k, count in d.iteritems():  
  157.       if k[:2] != ug: continue  
  158.       if k[2] is not None and count >= best_dmode[0]: best_dmode = (count, k[2])  
  159.       if k[3] is not None and count >= best_fmode[0]: best_fmode = (count, k[3])  
  160.     self.best_subtree = ug + (best_dmode[1], best_fmode[1])  
  161.   
  162.     return d  
  163.   
  164.   def SetPermissions(self, script):  
  165.     """Append set_perm/set_perm_recursive commands to 'script' to 
  166.     set all permissions, users, and groups for the tree of files 
  167.     rooted at 'self'."""  
  168.   
  169.     self.CountChildMetadata()  
  170.   
  171.     def recurse(item, current):  
  172.       # current is the (uid, gid, dmode, fmode) tuple that the current   
  173.       # item (and all its children) have already been set to.  We only   
  174.       # need to issue set_perm/set_perm_recursive commands if we're   
  175.       # supposed to be something different.   
  176.       if item.dir:  
  177.         if current != item.best_subtree:  
  178.           script.SetPermissionsRecursive("/"+item.name, *item.best_subtree)  
  179.           current = item.best_subtree  
  180.   
  181.         if item.uid != current[0] or item.gid != current[1] or \  
  182.            item.mode != current[2]:  
  183.           script.SetPermissions("/"+item.name, item.uid, item.gid, item.mode)  
  184.   
  185.         for i in item.children:  
  186.           recurse(i, current)  
  187.       else:  
  188.         if item.uid != current[0] or item.gid != current[1] or \  
  189.                item.mode != current[3]:  
  190.           script.SetPermissions("/"+item.name, item.uid, item.gid, item.mode)  
  191.   
  192.     recurse(self, (-1, -1, -1, -1))  
  193.   
  194.   
  195. def CopySystemFiles(input_zip, output_zip=None,  
  196.                     substitute=None):  
  197.   """Copies files underneath system/ in the input zip to the output 
  198.   zip.  Populates the Item class with their metadata, and returns a 
  199.   list of symlinks.  output_zip may be None, in which case the copy is 
  200.   skipped (but the other side effects still happen).  substitute is an 
  201.   optional dict of {output filename: contents} to be output instead of 
  202.   certain input files. 
  203.   """  
  204.   
  205.   symlinks = []  
  206.   
  207.   for info in input_zip.infolist():  
  208.     if info.filename.startswith("SYSTEM/"):  
  209.       basefilename = info.filename[7:]  
  210.       if IsSymlink(info):  
  211.         symlinks.append((input_zip.read(info.filename),  
  212.                          "/system/" + basefilename))  
  213.       else:  
  214.         info2 = copy.copy(info)  
  215.         fn = info2.filename = "system/" + basefilename  
  216.         if substitute and fn in substitute and substitute[fn] is None:  
  217.           continue  
  218.         if output_zip is not None:  
  219.           if substitute and fn in substitute:  
  220.             data = substitute[fn]  
  221.           else:  
  222.             data = input_zip.read(info.filename)  
  223.           output_zip.writestr(info2, data)  
  224.         if fn.endswith("/"):  
  225.           Item.Get(fn[:-1], dir=True)  
  226.         else:  
  227.           Item.Get(fn, dir=False)  
  228.   
  229.   symlinks.sort()  
  230.   return symlinks  
  231.   
  232.   
  233. def SignOutput(temp_zip_name, output_zip_name):  
  234.   key_passwords = common.GetKeyPasswords([OPTIONS.package_key])  
  235.   pw = key_passwords[OPTIONS.package_key]  
  236.   
  237.   common.SignFile(temp_zip_name, output_zip_name, OPTIONS.package_key, pw,  
  238.                   whole_file=True)  
  239.   
  240.   
  241. def AppendAssertions(script, input_zip):  
  242.   device = GetBuildProp("ro.product.device", input_zip)  
  243.   script.AssertDevice(device)  
  244.   
  245.   
  246. def MakeRecoveryPatch(output_zip, recovery_img, boot_img):  
  247.   """Generate a binary patch that creates the recovery image starting 
  248.   with the boot image.  (Most of the space in these images is just the 
  249.   kernel, which is identical for the two, so the resulting patch 
  250.   should be efficient.)  Add it to the output zip, along with a shell 
  251.   script that is run from init.rc on first boot to actually do the 
  252.   patching and install the new recovery image. 
  253.  
  254.   recovery_img and boot_img should be File objects for the 
  255.   corresponding images. 
  256.  
  257.   Returns an Item for the shell script, which must be made 
  258.   executable. 
  259.   """  
  260.   
  261.   d = common.Difference(recovery_img, boot_img)  
  262.   _, _, patch = d.ComputePatch()  
  263.   common.ZipWriteStr(output_zip, "recovery/recovery-from-boot.p", patch)  
  264.   Item.Get("system/recovery-from-boot.p", dir=False)  
  265.   
  266.   boot_type, boot_device = common.GetTypeAndDevice("/boot", OPTIONS.info_dict)  
  267.   recovery_type, recovery_device = common.GetTypeAndDevice("/recovery", OPTIONS.info_dict)  
  268.   
  269.   # Images with different content will have a different first page, so   
  270.   # we check to see if this recovery has already been installed by   
  271.   # testing just the first 2k.   
  272.   HEADER_SIZE = 2048  
  273.   header_sha1 = sha.sha(recovery_img.data[:HEADER_SIZE]).hexdigest()  
  274.   sh = """#!/system/bin/sh 
  275. if ! applypatch -c %(recovery_type)s:%(recovery_device)s:%(header_size)d:%(header_sha1)s; then 
  276.   log -t recovery "Installing new recovery image" 
  277.   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 
  278. else 
  279.   log -t recovery "Recovery image already installed" 
  280. fi 
  281. """ % { 'boot_size': boot_img.size,  
  282.         'boot_sha1': boot_img.sha1,  
  283.         'header_size': HEADER_SIZE,  
  284.         'header_sha1': header_sha1,  
  285.         'recovery_size': recovery_img.size,  
  286.         'recovery_sha1': recovery_img.sha1,  
  287.         'boot_type': boot_type,  
  288.         'boot_device': boot_device,  
  289.         'recovery_type': recovery_type,  
  290.         'recovery_device': recovery_device,  
  291.         }  
  292.   common.ZipWriteStr(output_zip, "recovery/etc/install-recovery.sh", sh)  
  293.   return Item.Get("system/etc/install-recovery.sh", dir=False)  
  294.   
  295.   
  296. def WriteFullOTAPackage(input_zip, output_zip):  
  297.   # TODO: how to determine this?  We don't know what version it will   
  298.   # be installed on top of.  For now, we expect the API just won't   
  299.   # change very often.   
  300.   script = edify_generator.EdifyGenerator(3, OPTIONS.info_dict)  
  301.   
  302.   metadata = {"post-build": GetBuildProp("ro.build.fingerprint", input_zip),  
  303.               "pre-device": GetBuildProp("ro.product.device", input_zip),  
  304.               "post-timestamp": GetBuildProp("ro.build.date.utc", input_zip),  
  305.               }  
  306.   
  307.   device_specific = common.DeviceSpecificParams(  
  308.       input_zip=input_zip,  
  309.       input_version=OPTIONS.info_dict["recovery_api_version"],  
  310.       output_zip=output_zip,  
  311.       script=script,  
  312.       input_tmp=OPTIONS.input_tmp,  
  313.       metadata=metadata,  
  314.       info_dict=OPTIONS.info_dict)  
  315.   
  316.   if not OPTIONS.omit_prereq:  
  317.     ts = GetBuildProp("ro.build.date.utc", input_zip)  
  318.     script.AssertOlderBuild(ts)  
  319.   
  320.   AppendAssertions(script, input_zip)  
  321.   device_specific.FullOTA_Assertions()  
  322.   
  323.   script.ShowProgress(0.5, 0)  
  324.   
  325.   if OPTIONS.wipe_user_data:  
  326.     script.FormatPartition("/data")  
  327.   
  328.   script.FormatPartition("/system")  
  329.   script.Mount("/system")  
  330.   script.UnpackPackageDir("recovery", "/system")  
  331.   script.UnpackPackageDir("system", "/system")  
  332.   
  333.   symlinks = CopySystemFiles(input_zip, output_zip)  
  334.   script.MakeSymlinks(symlinks)  
  335.   
  336.   boot_img = common.File("boot.img", common.BuildBootableImage(  
  337.       os.path.join(OPTIONS.input_tmp, "BOOT")))  
  338.   recovery_img = common.File("recovery.img", common.BuildBootableImage(  
  339.       os.path.join(OPTIONS.input_tmp, "RECOVERY")))  
  340.   MakeRecoveryPatch(output_zip, recovery_img, boot_img)  
  341.   
  342.   Item.GetMetadata(input_zip)  
  343.   Item.Get("system").SetPermissions(script)  
  344.   
  345.   common.CheckSize(boot_img.data, "boot.img", OPTIONS.info_dict)  
  346.   common.ZipWriteStr(output_zip, "boot.img", boot_img.data)  
  347.   script.ShowProgress(0.2, 0)  
  348.   
  349.   script.ShowProgress(0.2, 10)  
  350.   script.WriteRawImage("/boot", "boot.img")  
  351.   
  352.   script.ShowProgress(0.1, 0)  
  353.   device_specific.FullOTA_InstallEnd()  
  354.   
  355.   if OPTIONS.extra_script is not None:  
  356.     script.AppendExtra(OPTIONS.extra_script)  
  357.   
  358.   script.UnmountAll()  
  359.   script.AddToZip(input_zip, output_zip)  
  360.   WriteMetadata(metadata, output_zip)  
  361.   
  362.   
  363. def WriteMetadata(metadata, output_zip):  
  364.   common.ZipWriteStr(output_zip, "META-INF/com/android/metadata",  
  365.                      "".join(["%s=%s\n" % kv  
  366.                               for kv in sorted(metadata.iteritems())]))  
  367.   
  368.   
  369.   
  370.   
  371. def LoadSystemFiles(z):  
  372.   """Load all the files from SYSTEM/... in a given target-files 
  373.   ZipFile, and return a dict of {filename: File object}."""  
  374.   out = {}  
  375.   for info in z.infolist():  
  376.     if info.filename.startswith("SYSTEM/") and not IsSymlink(info):  
  377.       fn = "system/" + info.filename[7:]  
  378.       data = z.read(info.filename)  
  379.       out[fn] = common.File(fn, data)  
  380.   return out  
  381.   
  382.   
  383. def GetBuildProp(property, z):  
  384.   """Return the fingerprint of the build of a given target-files 
  385.   ZipFile object."""  
  386.   bp = z.read("SYSTEM/build.prop")  
  387.   if not property:  
  388.     return bp  
  389.   m = re.search(re.escape(property) + r"=(.*)\n", bp)  
  390.   if not m:  
  391.     raise common.ExternalError("couldn't find %s in build.prop" % (property,))  
  392.   return m.group(1).strip()  
  393.   
  394.   
  395. def WriteIncrementalOTAPackage(target_zip, source_zip, output_zip):  
  396.   source_version = OPTIONS.source_info_dict["recovery_api_version"]  
  397.   target_version = OPTIONS.target_info_dict["recovery_api_version"]  
  398.   
  399.   if source_version == 0:  
  400.     print ("WARNING: generating edify script for a source that "  
  401.            "can't install it.")  
  402.   script = edify_generator.EdifyGenerator(source_version, OPTIONS.info_dict)  
  403.   
  404.   metadata = {"pre-device": GetBuildProp("ro.product.device", source_zip),  
  405.               "post-timestamp": GetBuildProp("ro.build.date.utc", target_zip),  
  406.               }  
  407.   
  408.   device_specific = common.DeviceSpecificParams(  
  409.       source_zip=source_zip,  
  410.       source_version=source_version,  
  411.       target_zip=target_zip,  
  412.       target_version=target_version,  
  413.       output_zip=output_zip,  
  414.       script=script,  
  415.       metadata=metadata,  
  416.       info_dict=OPTIONS.info_dict)  
  417.   
  418.   print "Loading target..."  
  419.   target_data = LoadSystemFiles(target_zip)  
  420.   print "Loading source..."  
  421.   source_data = LoadSystemFiles(source_zip)  
  422.   
  423.   verbatim_targets = []  
  424.   patch_list = []  
  425.   diffs = []  
  426.   largest_source_size = 0  
  427.   for fn in sorted(target_data.keys()):  
  428.     tf = target_data[fn]  
  429.     assert fn == tf.name  
  430.     sf = source_data.get(fn, None)  
  431.   
  432.     if sf is None or fn in OPTIONS.require_verbatim:  
  433.       # This file should be included verbatim   
  434.       if fn in OPTIONS.prohibit_verbatim:  
  435.         raise common.ExternalError("\"%s\" must be sent verbatim" % (fn,))  
  436.       print "send", fn, "verbatim"  
  437.       tf.AddToZip(output_zip)  
  438.       verbatim_targets.append((fn, tf.size))  
  439.     elif tf.sha1 != sf.sha1:  
  440.       # File is different; consider sending as a patch   
  441.       diffs.append(common.Difference(tf, sf))  
  442.     else:  
  443.       # Target file identical to source.   
  444.       pass  
  445.   
  446.   common.ComputeDifferences(diffs)  
  447.   
  448.   for diff in diffs:  
  449.     tf, sf, d = diff.GetPatch()  
  450.     if d is None or len(d) > tf.size * OPTIONS.patch_threshold:  
  451.       # patch is almost as big as the file; don't bother patching   
  452.       tf.AddToZip(output_zip)  
  453.       verbatim_targets.append((tf.name, tf.size))  
  454.     else:  
  455.       common.ZipWriteStr(output_zip, "patch/" + tf.name + ".p", d)  
  456.       patch_list.append((tf.name, tf, sf, tf.size, sha.sha(d).hexdigest()))  
  457.       largest_source_size = max(largest_source_size, sf.size)  
  458.   
  459.   source_fp = GetBuildProp("ro.build.fingerprint", source_zip)  
  460.   target_fp = GetBuildProp("ro.build.fingerprint", target_zip)  
  461.   metadata["pre-build"] = source_fp  
  462.   metadata["post-build"] = target_fp  
  463.   
  464.   script.Mount("/system")  
  465.   script.AssertSomeFingerprint(source_fp, target_fp)  
  466.   
  467.   source_boot = common.File("/tmp/boot.img",  
  468.                             common.BuildBootableImage(  
  469.                                 os.path.join(OPTIONS.source_tmp, "BOOT")))  
  470.   target_boot = common.File("/tmp/boot.img",  
  471.                             common.BuildBootableImage(  
  472.                                 os.path.join(OPTIONS.target_tmp, "BOOT")))  
  473.   updating_boot = (source_boot.data != target_boot.data)  
  474.   
  475.   source_recovery = common.File("system/recovery.img",  
  476.                                 common.BuildBootableImage(  
  477.                                     os.path.join(OPTIONS.source_tmp, "RECOVERY")))  
  478.   target_recovery = common.File("system/recovery.img",  
  479.                                 common.BuildBootableImage(  
  480.                                     os.path.join(OPTIONS.target_tmp, "RECOVERY")))  
  481.   updating_recovery = (source_recovery.data != target_recovery.data)  
  482.   
  483.   # Here's how we divide up the progress bar:   
  484.   #  0.1 for verifying the start state (PatchCheck calls)   
  485.   #  0.8 for applying patches (ApplyPatch calls)   
  486.   #  0.1 for unpacking verbatim files, symlinking, and doing the   
  487.   #      device-specific commands.   
  488.   
  489.   AppendAssertions(script, target_zip)  
  490.   device_specific.IncrementalOTA_Assertions()  
  491.   
  492.   script.Print("Verifying current system...")  
  493.   
  494.   script.ShowProgress(0.1, 0)  
  495.   total_verify_size = float(sum([i[2].size for i in patch_list]) + 1)  
  496.   if updating_boot:  
  497.     total_verify_size += source_boot.size  
  498.   so_far = 0  
  499.   
  500.   for fn, tf, sf, size, patch_sha in patch_list:  
  501.     script.PatchCheck("/"+fn, tf.sha1, sf.sha1)  
  502.     so_far += sf.size  
  503.     script.SetProgress(so_far / total_verify_size)  
  504.   
  505.   if updating_boot:  
  506.     d = common.Difference(target_boot, source_boot)  
  507.     _, _, d = d.ComputePatch()  
  508.     print "boot      target: %d  source: %d  diff: %d" % (  
  509.         target_boot.size, source_boot.size, len(d))  
  510.   
  511.     common.ZipWriteStr(output_zip, "patch/boot.img.p", d)  
  512.   
  513.     boot_type, boot_device = common.GetTypeAndDevice("/boot", OPTIONS.info_dict)  
  514.   
  515.     script.PatchCheck("%s:%s:%d:%s:%d:%s" %  
  516.                       (boot_type, boot_device,  
  517.                        source_boot.size, source_boot.sha1,  
  518.                        target_boot.size, target_boot.sha1))  
  519.     so_far += source_boot.size  
  520.     script.SetProgress(so_far / total_verify_size)  
  521.   
  522.   if patch_list or updating_recovery or updating_boot:  
  523.     script.CacheFreeSpaceCheck(largest_source_size)  
  524.   
  525.   device_specific.IncrementalOTA_VerifyEnd()  
  526.   
  527.   script.Comment("---- start making changes here ----")  
  528.   
  529.   if OPTIONS.wipe_user_data:  
  530.     script.Print("Erasing user data...")  
  531.     script.FormatPartition("/data")  
  532.   
  533.   script.Print("Removing unneeded files...")  
  534.   script.DeleteFiles(["/"+i[0] for i in verbatim_targets] +  
  535.                      ["/"+i for i in sorted(source_data)  
  536.                             if i not in target_data] +  
  537.                      ["/system/recovery.img"])  
  538.   
  539.   script.ShowProgress(0.8, 0)  
  540.   total_patch_size = float(sum([i[1].size for i in patch_list]) + 1)  
  541.   if updating_boot:  
  542.     total_patch_size += target_boot.size  
  543.   so_far = 0  
  544.   
  545.   script.Print("Patching system files...")  
  546.   for fn, tf, sf, size, _ in patch_list:  
  547.     script.ApplyPatch("/"+fn, "-", tf.size, tf.sha1, sf.sha1, "patch/"+fn+".p")  
  548.     so_far += tf.size  
  549.     script.SetProgress(so_far / total_patch_size)  
  550.   
  551.   if updating_boot:  
  552.     # Produce the boot image by applying a patch to the current   
  553.     # contents of the boot partition, and write it back to the   
  554.     # partition.   
  555.     script.Print("Patching boot image...")  
  556.     script.ApplyPatch("%s:%s:%d:%s:%d:%s"  
  557.                       % (boot_type, boot_device,  
  558.                          source_boot.size, source_boot.sha1,  
  559.                          target_boot.size, target_boot.sha1),  
  560.                       "-",  
  561.                       target_boot.size, target_boot.sha1,  
  562.                       source_boot.sha1, "patch/boot.img.p")  
  563.     so_far += target_boot.size  
  564.     script.SetProgress(so_far / total_patch_size)  
  565.     print "boot image changed; including."  
  566.   else:  
  567.     print "boot image unchanged; skipping."  
  568.   
  569.   if updating_recovery:  
  570.     # Is it better to generate recovery as a patch from the current   
  571.     # boot image, or from the previous recovery image?  For large   
  572.     # updates with significant kernel changes, probably the former.   
  573.     # For small updates where the kernel hasn't changed, almost   
  574.     # certainly the latter.  We pick the first option.  Future   
  575.     # complicated schemes may let us effectively use both.   
  576.     #   
  577.     # A wacky possibility: as long as there is room in the boot   
  578.     # partition, include the binaries and image files from recovery in   
  579.     # the boot image (though not in the ramdisk) so they can be used   
  580.     # as fodder for constructing the recovery image.   
  581.     MakeRecoveryPatch(output_zip, target_recovery, target_boot)  
  582.     script.DeleteFiles(["/system/recovery-from-boot.p",  
  583.                         "/system/etc/install-recovery.sh"])  
  584.     print "recovery image changed; including as patch from boot."  
  585.   else:  
  586.     print "recovery image unchanged; skipping."  
  587.   
  588.   script.ShowProgress(0.1, 10)  
  589.   
  590.   target_symlinks = CopySystemFiles(target_zip, None)  
  591.   
  592.   target_symlinks_d = dict([(i[1], i[0]) for i in target_symlinks])  
  593.   temp_script = script.MakeTemporary()  
  594.   Item.GetMetadata(target_zip)  
  595.   Item.Get("system").SetPermissions(temp_script)  
  596.   
  597.   # Note that this call will mess up the tree of Items, so make sure   
  598.   # we're done with it.   
  599.   source_symlinks = CopySystemFiles(source_zip, None)  
  600.   source_symlinks_d = dict([(i[1], i[0]) for i in source_symlinks])  
  601.   
  602.   # Delete all the symlinks in source that aren't in target.  This   
  603.   # needs to happen before verbatim files are unpacked, in case a   
  604.   # symlink in the source is replaced by a real file in the target.   
  605.   to_delete = []  
  606.   for dest, link in source_symlinks:  
  607.     if link not in target_symlinks_d:  
  608.       to_delete.append(link)  
  609.   script.DeleteFiles(to_delete)  
  610.   
  611.   if verbatim_targets:  
  612.     script.Print("Unpacking new files...")  
  613.     script.UnpackPackageDir("system", "/system")  
  614.   
  615.   if updating_recovery:  
  616.     script.Print("Unpacking new recovery...")  
  617.     script.UnpackPackageDir("recovery", "/system")  
  618.   
  619.   script.Print("Symlinks and permissions...")  
  620.   
  621.   # Create all the symlinks that don't already exist, or point to   
  622.   # somewhere different than what we want.  Delete each symlink before   
  623.   # creating it, since the 'symlink' command won't overwrite.   
  624.   to_create = []  
  625.   for dest, link in target_symlinks:  
  626.     if link in source_symlinks_d:  
  627.       if dest != source_symlinks_d[link]:  
  628.         to_create.append((dest, link))  
  629.     else:  
  630.       to_create.append((dest, link))  
  631.   script.DeleteFiles([i[1] for i in to_create])  
  632.   script.MakeSymlinks(to_create)  
  633.   
  634.   # Now that the symlinks are created, we can set all the   
  635.   # permissions.   
  636.   script.AppendScript(temp_script)  
  637.   
  638.   # Do device-specific installation (eg, write radio image).   
  639.   device_specific.IncrementalOTA_InstallEnd()  
  640.   
  641.   if OPTIONS.extra_script is not None:  
  642.     scirpt.AppendExtra(OPTIONS.extra_script)  
  643.   
  644.   script.AddToZip(target_zip, output_zip)  
  645.   WriteMetadata(metadata, output_zip)  
  646.   
  647.   
  648. def main(argv):  
  649.   
  650.   def option_handler(o, a):  
  651.     if o in ("-b", "--board_config"):  
  652.       pass   # deprecated   
  653.     elif o in ("-k", "--package_key"):  
  654.       OPTIONS.package_key = a  
  655.     elif o in ("-i", "--incremental_from"):  
  656.       OPTIONS.incremental_source = a  
  657.     elif o in ("-w", "--wipe_user_data"):  
  658.       OPTIONS.wipe_user_data = True  
  659.     elif o in ("-n", "--no_prereq"):  
  660.       OPTIONS.omit_prereq = True  
  661.     elif o in ("-e", "--extra_script"):  
  662.       OPTIONS.extra_script = a  
  663.     elif o in ("--worker_threads"):  
  664.       OPTIONS.worker_threads = int(a)  
  665.     else:  
  666.       return False  
  667.     return True  
  668.   
  669.   args = common.ParseOptions(argv, __doc__,  
  670.                              extra_opts="b:k:i:d:wne:",  
  671.                              extra_long_opts=["board_config=",  
  672.                                               "package_key=",  
  673.                                               "incremental_from=",  
  674.                                               "wipe_user_data",  
  675.                                               "no_prereq",  
  676.                                               "extra_script=",  
  677.                                               "worker_threads="],  
  678.                              extra_option_handler=option_handler)  
  679.   
  680.   if len(args) != 2:  
  681.     common.Usage(__doc__)  
  682.     sys.exit(1)  
  683.   
  684.   if OPTIONS.extra_script is not None:  
  685.     OPTIONS.extra_script = open(OPTIONS.extra_script).read()  
  686.   
  687.   print "unzipping target target-files..."  
  688.   OPTIONS.input_tmp = common.UnzipTemp(args[0])  
  689.   
  690.   OPTIONS.target_tmp = OPTIONS.input_tmp  
  691.   input_zip = zipfile.ZipFile(args[0], "r")  
  692.   OPTIONS.info_dict = common.LoadInfoDict(input_zip)  
  693.   if OPTIONS.verbose:  
  694.     print "--- target info ---"  
  695.     common.DumpInfoDict(OPTIONS.info_dict)  
  696.   
  697.   if OPTIONS.device_specific is None:  
  698.     OPTIONS.device_specific = OPTIONS.info_dict.get("tool_extensions", None)  
  699.   if OPTIONS.device_specific is not None:  
  700.     OPTIONS.device_specific = os.path.normpath(OPTIONS.device_specific)  
  701.     print "using device-specific extensions in", OPTIONS.device_specific  
  702.   
  703.   if OPTIONS.package_key:  
  704.     temp_zip_file = tempfile.NamedTemporaryFile()  
  705.     output_zip = zipfile.ZipFile(temp_zip_file, "w",  
  706.                                  compression=zipfile.ZIP_DEFLATED)  
  707.   else:  
  708.     output_zip = zipfile.ZipFile(args[1], "w",  
  709.                                  compression=zipfile.ZIP_DEFLATED)  
  710.   
  711.   if OPTIONS.incremental_source is None:  
  712.     WriteFullOTAPackage(input_zip, output_zip)  
  713.   else:  
  714.     print "unzipping source target-files..."  
  715.     OPTIONS.source_tmp = common.UnzipTemp(OPTIONS.incremental_source)  
  716.     source_zip = zipfile.ZipFile(OPTIONS.incremental_source, "r")  
  717.     OPTIONS.target_info_dict = OPTIONS.info_dict  
  718.     OPTIONS.source_info_dict = common.LoadInfoDict(source_zip)  
  719.     if OPTIONS.verbose:  
  720.       print "--- source info ---"  
  721.       common.DumpInfoDict(OPTIONS.source_info_dict)  
  722.     WriteIncrementalOTAPackage(input_zip, source_zip, output_zip)  
  723.   
  724.   output_zip.close()  
  725.   if OPTIONS.package_key:  
  726.     SignOutput(temp_zip_file.name, args[1])  
  727.     temp_zip_file.close()  
  728.   
  729.   common.Cleanup()  
  730.   
  731.   print "done."  
  732.   
  733.   
  734. if __name__ == '__main__':  
  735.   try:  
  736.     common.CloseInheritedPipes()  
  737.     main(sys.argv[1:])  
  738.   except common.ExternalError, e:  
  739.     print  
  740.     print "   ERROR: %s" % (e,)  
  741.     print  
  742.     sys.exit(1)  
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卡中就能夠用來升級了。
4、 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）有關。此問題在下一篇博客已經解決。


             在下一篇中講解制做增量包失敗的緣由，以及解決方案。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程