blob: 5a024cec54bbf76e5bd4b214d87453f7609e1a09 [file] [log] [blame]
Doug Zongkereef39442009-04-02 12:14:19 -07001#!/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"""
Tao Bao30df8b42018-04-23 15:32:53 -070018Given a target-files zipfile, produces an OTA package that installs that build.
19An incremental OTA is produced if -i is given, otherwise a full OTA is produced.
Doug Zongkereef39442009-04-02 12:14:19 -070020
Tao Bao30df8b42018-04-23 15:32:53 -070021Usage: ota_from_target_files [options] input_target_files output_ota_package
Doug Zongkereef39442009-04-02 12:14:19 -070022
Tao Bao30df8b42018-04-23 15:32:53 -070023Common options that apply to both of non-A/B and A/B OTAs
24
25 --downgrade
26 Intentionally generate an incremental OTA that updates from a newer build
Tao Baofaa8e0b2018-04-12 14:31:43 -070027 to an older one (e.g. downgrading from P preview back to O MR1).
28 "ota-downgrade=yes" will be set in the package metadata file. A data wipe
29 will always be enforced when using this flag, so "ota-wipe=yes" will also
30 be included in the metadata file. The update-binary in the source build
31 will be used in the OTA package, unless --binary flag is specified. Please
32 also check the comment for --override_timestamp below.
Tao Bao30df8b42018-04-23 15:32:53 -070033
34 -i (--incremental_from) <file>
35 Generate an incremental OTA using the given target-files zip as the
36 starting build.
37
38 -k (--package_key) <key>
39 Key to use to sign the package (default is the value of
40 default_system_dev_certificate from the input target-files's
Tao Bao59cf0c52019-06-25 10:04:24 -070041 META/misc_info.txt, or "build/make/target/product/security/testkey" if
42 that value is not specified).
Doug Zongkerafb32ea2011-09-22 10:28:04 -070043
44 For incremental OTAs, the default value is based on the source
45 target-file, not the target build.
Doug Zongkereef39442009-04-02 12:14:19 -070046
Tao Bao30df8b42018-04-23 15:32:53 -070047 --override_timestamp
48 Intentionally generate an incremental OTA that updates from a newer build
Tao Baofaa8e0b2018-04-12 14:31:43 -070049 to an older one (based on timestamp comparison), by setting the downgrade
50 flag in the package metadata. This differs from --downgrade flag, as we
51 don't enforce a data wipe with this flag. Because we know for sure this is
52 NOT an actual downgrade case, but two builds happen to be cut in a reverse
53 order (e.g. from two branches). A legit use case is that we cut a new
54 build C (after having A and B), but want to enfore an update path of A ->
55 C -> B. Specifying --downgrade may not help since that would enforce a
56 data wipe for C -> B update.
57
58 We used to set a fake timestamp in the package metadata for this flow. But
59 now we consolidate the two cases (i.e. an actual downgrade, or a downgrade
60 based on timestamp) with the same "ota-downgrade=yes" flag, with the
61 difference being whether "ota-wipe=yes" is set.
Doug Zongkereef39442009-04-02 12:14:19 -070062
Tao Bao30df8b42018-04-23 15:32:53 -070063 --wipe_user_data
64 Generate an OTA package that will wipe the user data partition when
65 installed.
66
Yifan Hong50e79542018-11-08 17:44:12 -080067 --retrofit_dynamic_partitions
68 Generates an OTA package that updates a device to support dynamic
69 partitions (default False). This flag is implied when generating
70 an incremental OTA where the base build does not support dynamic
71 partitions but the target build does. For A/B, when this flag is set,
72 --skip_postinstall is implied.
73
xunchangabfa2652019-02-19 16:27:10 -080074 --skip_compatibility_check
Yifan Hong9276cf02019-08-21 16:37:04 -070075 Skip checking compatibility of the input target files package.
xunchangabfa2652019-02-19 16:27:10 -080076
xunchang1cfe2512019-02-19 14:14:48 -080077 --output_metadata_path
78 Write a copy of the metadata to a separate file. Therefore, users can
79 read the post build fingerprint without extracting the OTA package.
80
Yifan Hong65afc072020-04-17 10:08:10 -070081 --force_non_ab
82 This flag can only be set on an A/B device that also supports non-A/B
83 updates. Implies --two_step.
84 If set, generate that non-A/B update package.
85 If not set, generates A/B package for A/B device and non-A/B package for
86 non-A/B device.
87
Hongguang Chen49ab1b902020-10-19 14:15:43 -070088 -o (--oem_settings) <main_file[,additional_files...]>
89 Comma separated list of files used to specify the expected OEM-specific
90 properties on the OEM partition of the intended device. Multiple expected
91 values can be used by providing multiple files. Only the first dict will
92 be used to compute fingerprint, while the rest will be used to assert
93 OEM-specific properties.
94
Tao Bao30df8b42018-04-23 15:32:53 -070095Non-A/B OTA specific options
96
97 -b (--binary) <file>
98 Use the given binary as the update-binary in the output package, instead
99 of the binary in the build's target_files. Use for development only.
100
101 --block
102 Generate a block-based OTA for non-A/B device. We have deprecated the
103 support for file-based OTA since O. Block-based OTA will be used by
104 default for all non-A/B devices. Keeping this flag here to not break
105 existing callers.
106
107 -e (--extra_script) <file>
108 Insert the contents of file at the end of the update script.
Tao Bao43078aa2015-04-21 14:32:35 -0700109
leozwangaa6c1a12015-08-14 10:57:58 -0700110 --full_bootloader
111 Similar to --full_radio. When generating an incremental OTA, always
112 include a full copy of bootloader image.
113
Tao Bao30df8b42018-04-23 15:32:53 -0700114 --full_radio
115 When generating an incremental OTA, always include a full copy of radio
116 image. This option is only meaningful when -i is specified, because a full
117 radio is always included in a full OTA if applicable.
Michael Runge63f01de2014-10-28 19:24:19 -0700118
Tao Bao30df8b42018-04-23 15:32:53 -0700119 --log_diff <file>
120 Generate a log file that shows the differences in the source and target
121 builds for an incremental package. This option is only meaningful when -i
122 is specified.
123
Tao Bao8608cde2016-02-25 19:49:55 -0800124 --oem_no_mount
Tao Bao30df8b42018-04-23 15:32:53 -0700125 For devices with OEM-specific properties but without an OEM partition, do
126 not mount the OEM partition in the updater-script. This should be very
127 rarely used, since it's expected to have a dedicated OEM partition for
128 OEM-specific properties. Only meaningful when -o is specified.
Tao Bao8608cde2016-02-25 19:49:55 -0800129
Tao Bao30df8b42018-04-23 15:32:53 -0700130 --stash_threshold <float>
131 Specify the threshold that will be used to compute the maximum allowed
132 stash size (defaults to 0.8).
Doug Zongkerdbfaae52009-04-21 17:12:54 -0700133
Tao Bao30df8b42018-04-23 15:32:53 -0700134 -t (--worker_threads) <int>
135 Specify the number of worker-threads that will be used when generating
136 patches for incremental updates (defaults to 3).
Tao Bao3e6161a2017-02-28 11:48:48 -0800137
Tao Bao30df8b42018-04-23 15:32:53 -0700138 --verify
139 Verify the checksums of the updated system and vendor (if any) partitions.
140 Non-A/B incremental OTAs only.
Doug Zongker1c390a22009-05-14 19:06:36 -0700141
Doug Zongker9b23f2c2013-11-25 14:44:12 -0800142 -2 (--two_step)
Tao Bao30df8b42018-04-23 15:32:53 -0700143 Generate a 'two-step' OTA package, where recovery is updated first, so
144 that any changes made to the system partition are done using the new
145 recovery (new kernel, etc.).
146
147A/B OTA specific options
Doug Zongker9b23f2c2013-11-25 14:44:12 -0800148
Tianjie Xu1b079832019-08-28 12:19:23 -0700149 --disable_fec_computation
Kelvin Zhang456c6d92023-08-01 09:52:00 -0700150 Disable the on device FEC data computation for incremental updates. OTA will be larger but installation will be faster.
Tianjie Xu1b079832019-08-28 12:19:23 -0700151
Tao Baof7140c02018-01-30 17:09:24 -0800152 --include_secondary
153 Additionally include the payload for secondary slot images (default:
154 False). Only meaningful when generating A/B OTAs.
155
156 By default, an A/B OTA package doesn't contain the images for the
157 secondary slot (e.g. system_other.img). Specifying this flag allows
158 generating a separate payload that will install secondary slot images.
159
160 Such a package needs to be applied in a two-stage manner, with a reboot
161 in-between. During the first stage, the updater applies the primary
162 payload only. Upon finishing, it reboots the device into the newly updated
163 slot. It then continues to install the secondary payload to the inactive
164 slot, but without switching the active slot at the end (needs the matching
165 support in update_engine, i.e. SWITCH_SLOT_ON_REBOOT flag).
166
167 Due to the special install procedure, the secondary payload will be always
168 generated as a full payload.
169
Tao Baodea0f8b2016-06-20 17:55:06 -0700170 --payload_signer <signer>
171 Specify the signer when signing the payload and metadata for A/B OTAs.
172 By default (i.e. without this flag), it calls 'openssl pkeyutl' to sign
173 with the package private key. If the private key cannot be accessed
174 directly, a payload signer that knows how to do that should be specified.
175 The signer will be supplied with "-inkey <path_to_key>",
176 "-in <input_file>" and "-out <output_file>" parameters.
Baligh Uddin2abbbd02016-06-22 12:14:16 -0700177
178 --payload_signer_args <args>
179 Specify the arguments needed for payload signer.
Tao Bao15a146a2018-02-21 16:06:59 -0800180
Tianjie Xu21e6deb2019-10-07 18:01:00 -0700181 --payload_signer_maximum_signature_size <signature_size>
182 The maximum signature size (in bytes) that would be generated by the given
183 payload signer. Only meaningful when custom payload signer is specified
184 via '--payload_signer'.
185 If the signer uses a RSA key, this should be the number of bytes to
186 represent the modulus. If it uses an EC key, this is the size of a
187 DER-encoded ECDSA signature.
188
xunchang376cc7c2019-04-08 23:04:58 -0700189 --payload_signer_key_size <key_size>
Tianjie Xu21e6deb2019-10-07 18:01:00 -0700190 Deprecated. Use the '--payload_signer_maximum_signature_size' instead.
xunchang376cc7c2019-04-08 23:04:58 -0700191
Tianjied6867162020-05-10 14:30:13 -0700192 --boot_variable_file <path>
193 A file that contains the possible values of ro.boot.* properties. It's
194 used to calculate the possible runtime fingerprints when some
195 ro.product.* properties are overridden by the 'import' statement.
196 The file expects one property per line, and each line has the following
197 format: 'prop_name=value1,value2'. e.g. 'ro.boot.product.sku=std,pro'
Ben Fennemacd6de1b2024-04-25 08:17:09 -0700198 The path specified can either be relative to the current working directory
199 or the path to a file inside of input_target_files.
Tianjied6867162020-05-10 14:30:13 -0700200
Tao Bao15a146a2018-02-21 16:06:59 -0800201 --skip_postinstall
202 Skip the postinstall hooks when generating an A/B OTA package (default:
203 False). Note that this discards ALL the hooks, including non-optional
204 ones. Should only be used if caller knows it's safe to do so (e.g. all the
205 postinstall work is to dexopt apps and a data wipe will happen immediately
206 after). Only meaningful when generating A/B OTAs.
Yifan Hong38ab4d82020-06-18 15:19:56 -0700207
208 --partial "<PARTITION> [<PARTITION>[...]]"
209 Generate partial updates, overriding ab_partitions list with the given
Kelvin Zhanga10528c2023-01-03 15:14:53 -0800210 list. Specify --partial= without partition list to let tooling auto detect
211 partial partition list.
Hongguang Chen49ab1b902020-10-19 14:15:43 -0700212
213 --custom_image <custom_partition=custom_image>
214 Use the specified custom_image to update custom_partition when generating
215 an A/B OTA package. e.g. "--custom_image oem=oem.img --custom_image
216 cus=cus_test.img"
David Anderson45b42302021-03-11 12:58:32 -0800217
218 --disable_vabc
219 Disable Virtual A/B Compression, for builds that have compression enabled
220 by default.
Kelvin Zhang2a3e5b12021-05-04 18:20:34 -0400221
222 --vabc_downgrade
223 Don't disable Virtual A/B Compression for downgrading OTAs.
224 For VABC downgrades, we must finish merging before doing data wipe, and
225 since data wipe is required for downgrading OTA, this might cause long
226 wait time in recovery.
Kelvin Zhang1250bca2021-08-27 15:10:27 -0700227
228 --enable_vabc_xor
Kelvin Zhang456c6d92023-08-01 09:52:00 -0700229 Enable the VABC xor feature. Will reduce space requirements for OTA, but OTA installation will be slower.
Kelvin Zhang1250bca2021-08-27 15:10:27 -0700230
Tianjiee7ab38d2021-09-08 19:09:38 -0700231 --force_minor_version
232 Override the update_engine minor version for delta generation.
Kelvin Zhang9b6d4ec2021-10-28 09:34:31 -0700233
234 --compressor_types
235 A colon ':' separated list of compressors. Allowed values are bz2 and brotli.
Kelvin Zhang410bb382022-01-06 09:15:54 -0800236
237 --enable_zucchini
Kelvin Zhang456c6d92023-08-01 09:52:00 -0700238 Whether to enable to zucchini feature. Will generate smaller OTA but uses more memory, OTA generation will take longer.
239
240 --enable_puffdiff
241 Whether to enable to puffdiff feature. Will generate smaller OTA but uses more memory, OTA generation will take longer.
Kelvin Zhangf2728d62022-01-10 11:42:36 -0800242
243 --enable_lz4diff
244 Whether to enable lz4diff feature. Will generate smaller OTA for EROFS but
245 uses more memory.
Kelvin Zhange174c322022-03-01 15:51:09 -0800246
247 --spl_downgrade
248 Force generate an SPL downgrade OTA. Only needed if target build has an
249 older SPL.
Kelvin Zhang84b3a282022-03-04 12:26:20 -0800250
251 --vabc_compression_param
Daniel Zheng74955f82023-08-03 15:46:13 -0700252 Compression algorithm to be used for VABC. Available options: gz, lz4, zstd, brotli, none.
253 Compression level can be specified by appending ",$LEVEL" to option.
254 e.g. --vabc_compression_param=gz,9 specifies level 9 compression with gz algorithm
Kelvin Zhang0b7207c2022-08-26 17:49:08 +0000255
256 --security_patch_level
257 Override the security patch level in target files
Daniel Zhenga30989b2023-04-25 12:41:44 -0700258
259 --max_threads
260 Specify max number of threads allowed when generating A/B OTA
Kelvin Zhang8793a722023-12-07 13:19:47 -0800261
262 --vabc_cow_version
263 Specify the VABC cow version to be used
Daniel Zhenga567eae2024-01-08 14:20:49 -0800264
265 --compression_factor
Daniel Zhengcedc7652024-02-21 13:32:16 -0800266 Specify the maximum block size to be compressed at once during OTA. supported options: 4k, 8k, 16k, 32k, 64k, 128k, 256k
Doug Zongkereef39442009-04-02 12:14:19 -0700267"""
268
Tao Bao89fbb0f2017-01-10 10:47:58 -0800269from __future__ import print_function
270
Tao Bao32fcdab2018-10-12 10:30:39 -0700271import logging
Doug Zongkerfc44a512014-08-26 13:10:25 -0700272import multiprocessing
Kelvin Zhang65029a22020-11-03 10:07:51 -0500273import os
Tao Bao2dd1c482017-02-03 16:49:39 -0800274import os.path
Kelvin Zhang65029a22020-11-03 10:07:51 -0500275import re
Tao Bao15a146a2018-02-21 16:06:59 -0800276import shutil
Kelvin Zhang65029a22020-11-03 10:07:51 -0500277import subprocess
Tao Bao481bab82017-12-21 11:23:09 -0800278import sys
Doug Zongkereef39442009-04-02 12:14:19 -0700279import zipfile
280
Kelvin Zhang766eea72021-06-03 09:36:08 -0400281import care_map_pb2
Doug Zongkereef39442009-04-02 12:14:19 -0700282import common
Kelvin Zhang2e417382020-08-20 11:33:11 -0400283import ota_utils
Kelvin Zhang68252b82023-11-14 10:58:02 -0800284import payload_signer
Kelvin Zhang8f830002023-08-16 13:16:48 -0700285from ota_utils import (VABC_COMPRESSION_PARAM_SUPPORT, FinalizeMetadata, GetPackageMetadata,
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700286 PayloadGenerator, SECURITY_PATCH_LEVEL_PROP_NAME, ExtractTargetFiles, CopyTargetFilesDir)
Kelvin Zhang9dbe2ce2023-04-17 16:38:08 -0700287from common import DoesInputFileContain, IsSparseImage
Kelvin Zhang0876c412020-06-23 15:06:58 -0400288import target_files_diff
Kelvin Zhangcff4d762020-07-29 16:37:51 -0400289from non_ab_ota import GenerateNonAbOtaPackage
Kelvin Zhang059bf6e2022-08-12 14:03:41 -0700290from payload_signer import PayloadSigner
Kelvin Zhang0876c412020-06-23 15:06:58 -0400291
Tao Bao481bab82017-12-21 11:23:09 -0800292if sys.hexversion < 0x02070000:
293 print("Python 2.7 or newer is required.", file=sys.stderr)
294 sys.exit(1)
295
Tao Bao32fcdab2018-10-12 10:30:39 -0700296logger = logging.getLogger(__name__)
Tao Bao481bab82017-12-21 11:23:09 -0800297
Kelvin Zhang2e417382020-08-20 11:33:11 -0400298OPTIONS = ota_utils.OPTIONS
Michael Runge63f01de2014-10-28 19:24:19 -0700299OPTIONS.verify = False
Doug Zongkereef39442009-04-02 12:14:19 -0700300OPTIONS.patch_threshold = 0.95
Doug Zongkerdbfaae52009-04-21 17:12:54 -0700301OPTIONS.wipe_user_data = False
Doug Zongker1c390a22009-05-14 19:06:36 -0700302OPTIONS.extra_script = None
Doug Zongkerfc44a512014-08-26 13:10:25 -0700303OPTIONS.worker_threads = multiprocessing.cpu_count() // 2
304if OPTIONS.worker_threads == 0:
305 OPTIONS.worker_threads = 1
Doug Zongker9b23f2c2013-11-25 14:44:12 -0800306OPTIONS.two_step = False
Tao Baof7140c02018-01-30 17:09:24 -0800307OPTIONS.include_secondary = False
Tao Bao457cbf62017-03-06 09:56:01 -0800308OPTIONS.block_based = True
Doug Zongker25568482014-03-03 10:21:27 -0800309OPTIONS.updater_binary = None
Tianjie Xu9afb2212020-05-10 21:48:15 +0000310OPTIONS.oem_dicts = None
Michael Runge6e836112014-04-15 17:40:21 -0700311OPTIONS.oem_source = None
Tao Bao8608cde2016-02-25 19:49:55 -0800312OPTIONS.oem_no_mount = False
Tao Bao43078aa2015-04-21 14:32:35 -0700313OPTIONS.full_radio = False
leozwangaa6c1a12015-08-14 10:57:58 -0700314OPTIONS.full_bootloader = False
Tao Baod47d8e12015-05-21 14:09:49 -0700315# Stash size cannot exceed cache_size * threshold.
316OPTIONS.cache_size = None
317OPTIONS.stash_threshold = 0.8
Tao Baod62c6032015-11-30 09:40:20 -0800318OPTIONS.log_diff = None
Tao Bao5f8ff932017-03-21 22:35:00 -0700319OPTIONS.extracted_input = None
Tao Bao15a146a2018-02-21 16:06:59 -0800320OPTIONS.skip_postinstall = False
xunchangabfa2652019-02-19 16:27:10 -0800321OPTIONS.skip_compatibility_check = False
Tianjie Xu1b079832019-08-28 12:19:23 -0700322OPTIONS.disable_fec_computation = False
Kelvin Zhangcaf7bbc2020-11-20 14:09:42 -0500323OPTIONS.disable_verity_computation = False
Yifan Hong38ab4d82020-06-18 15:19:56 -0700324OPTIONS.partial = None
Hongguang Chen49ab1b902020-10-19 14:15:43 -0700325OPTIONS.custom_images = {}
Kelvin Zhangbbfa1822021-02-03 17:19:44 -0500326OPTIONS.disable_vabc = False
Kelvin Zhang80ff4662021-02-08 19:57:57 -0500327OPTIONS.spl_downgrade = False
Kelvin Zhang2a3e5b12021-05-04 18:20:34 -0400328OPTIONS.vabc_downgrade = False
Kelvin Zhang1250bca2021-08-27 15:10:27 -0700329OPTIONS.enable_vabc_xor = True
Tianjiee7ab38d2021-09-08 19:09:38 -0700330OPTIONS.force_minor_version = None
Kelvin Zhang9b6d4ec2021-10-28 09:34:31 -0700331OPTIONS.compressor_types = None
Kelvin Zhangf2728d62022-01-10 11:42:36 -0800332OPTIONS.enable_zucchini = True
Kelvin Zhang456c6d92023-08-01 09:52:00 -0700333OPTIONS.enable_puffdiff = None
Kelvin Zhangf2728d62022-01-10 11:42:36 -0800334OPTIONS.enable_lz4diff = False
Kelvin Zhang84b3a282022-03-04 12:26:20 -0800335OPTIONS.vabc_compression_param = None
Kelvin Zhang0b7207c2022-08-26 17:49:08 +0000336OPTIONS.security_patch_level = None
Daniel Zhenga30989b2023-04-25 12:41:44 -0700337OPTIONS.max_threads = None
Kelvin Zhang8793a722023-12-07 13:19:47 -0800338OPTIONS.vabc_cow_version = None
Daniel Zhenga567eae2024-01-08 14:20:49 -0800339OPTIONS.compression_factor = None
Daniel Zhenga30989b2023-04-25 12:41:44 -0700340
Tao Bao8dcf7382015-05-21 14:09:49 -0700341
Tao Bao15a146a2018-02-21 16:06:59 -0800342POSTINSTALL_CONFIG = 'META/postinstall_config.txt'
Yifan Hong50e79542018-11-08 17:44:12 -0800343DYNAMIC_PARTITION_INFO = 'META/dynamic_partitions_info.txt'
Kelvin Zhang8793a722023-12-07 13:19:47 -0800344MISC_INFO = 'META/misc_info.txt'
Yifan Hongb433eba2019-03-06 12:42:53 -0800345AB_PARTITIONS = 'META/ab_partitions.txt'
Kelvin Zhangcff4d762020-07-29 16:37:51 -0400346
Tao Baof0c4aa22018-04-30 20:29:30 -0700347# Files to be unzipped for target diffing purpose.
348TARGET_DIFFING_UNZIP_PATTERN = ['BOOT', 'RECOVERY', 'SYSTEM/*', 'VENDOR/*',
Yifan Hongcfb917a2020-05-07 14:58:20 -0700349 'PRODUCT/*', 'SYSTEM_EXT/*', 'ODM/*',
Ramji Jiyani13a41372022-01-27 07:05:08 +0000350 'VENDOR_DLKM/*', 'ODM_DLKM/*', 'SYSTEM_DLKM/*']
Yifan Hongb433eba2019-03-06 12:42:53 -0800351RETROFIT_DAP_UNZIP_PATTERN = ['OTA/super_*.img', AB_PARTITIONS]
Tao Bao3e759462019-09-17 22:43:11 -0700352
353# Images to be excluded from secondary payload. We essentially only keep
354# 'system_other' and bootloader partitions.
355SECONDARY_PAYLOAD_SKIPPED_IMAGES = [
Yifan Hongc08cbf02020-09-15 19:07:39 +0000356 'boot', 'dtbo', 'modem', 'odm', 'odm_dlkm', 'product', 'radio', 'recovery',
Ramji Jiyani13a41372022-01-27 07:05:08 +0000357 'system_dlkm', 'system_ext', 'vbmeta', 'vbmeta_system', 'vbmeta_vendor',
358 'vendor', 'vendor_boot']
Tao Bao6b0b2f92017-03-05 11:38:11 -0800359
Kelvin Zhang05ff7052021-02-10 09:13:26 -0500360
Tao Bao481bab82017-12-21 11:23:09 -0800361def _LoadOemDicts(oem_source):
Alain Vongsouvanh7f804ba2017-02-16 13:06:55 -0800362 """Returns the list of loaded OEM properties dict."""
Tao Bao481bab82017-12-21 11:23:09 -0800363 if not oem_source:
364 return None
365
Alain Vongsouvanh7f804ba2017-02-16 13:06:55 -0800366 oem_dicts = []
Tao Bao481bab82017-12-21 11:23:09 -0800367 for oem_file in oem_source:
jiajia tangc7c86972022-03-08 18:27:24 +0800368 oem_dicts.append(common.LoadDictionaryFromFile(oem_file))
Alain Vongsouvanh7f804ba2017-02-16 13:06:55 -0800369 return oem_dicts
Doug Zongkereef39442009-04-02 12:14:19 -0700370
Kelvin Zhang8793a722023-12-07 13:19:47 -0800371def ModifyKeyvalueList(content: str, key: str, value: str):
372 """ Update update the key value list with specified key and value
373 Args:
374 content: The string content of dynamic_partitions_info.txt. Each line
375 should be a key valur pair, where string before the first '=' are keys,
376 remaining parts are values.
377 key: the key of the key value pair to modify
378 value: the new value to replace with
379
380 Returns:
381 Updated content of the key value list
382 """
383 output_list = []
384 for line in content.splitlines():
385 if line.startswith(key+"="):
386 continue
387 output_list.append(line)
388 output_list.append("{}={}".format(key, value))
389 return "\n".join(output_list)
Doug Zongkereef39442009-04-02 12:14:19 -0700390
Kelvin Zhang84b3a282022-03-04 12:26:20 -0800391def ModifyVABCCompressionParam(content, algo):
392 """ Update update VABC Compression Param in dynamic_partitions_info.txt
393 Args:
394 content: The string content of dynamic_partitions_info.txt
395 algo: The compression algorithm should be used for VABC. See
396 https://cs.android.com/android/platform/superproject/+/master:system/core/fs_mgr/libsnapshot/cow_writer.cpp;l=127;bpv=1;bpt=1?q=CowWriter::ParseOptions&sq=
397 Returns:
398 Updated content of dynamic_partitions_info.txt , with custom compression algo
399 """
Kelvin Zhang8793a722023-12-07 13:19:47 -0800400 return ModifyKeyvalueList(content, "virtual_ab_compression_method", algo)
401
Kelvin Zhang84b3a282022-03-04 12:26:20 -0800402
Yifan Hong38ab4d82020-06-18 15:19:56 -0700403def UpdatesInfoForSpecialUpdates(content, partitions_filter,
404 delete_keys=None):
405 """ Updates info file for secondary payload generation, partial update, etc.
406
407 Scan each line in the info file, and remove the unwanted partitions from
408 the dynamic partition list in the related properties. e.g.
409 "super_google_dynamic_partitions_partition_list=system vendor product"
410 will become "super_google_dynamic_partitions_partition_list=system".
411
412 Args:
413 content: The content of the input info file. e.g. misc_info.txt.
414 partitions_filter: A function to filter the desired partitions from a given
415 list
416 delete_keys: A list of keys to delete in the info file
417
418 Returns:
419 A string of the updated info content.
420 """
421
422 output_list = []
423 # The suffix in partition_list variables that follows the name of the
424 # partition group.
425 list_suffix = 'partition_list'
426 for line in content.splitlines():
427 if line.startswith('#') or '=' not in line:
428 output_list.append(line)
429 continue
430 key, value = line.strip().split('=', 1)
431
432 if delete_keys and key in delete_keys:
433 pass
434 elif key.endswith(list_suffix):
435 partitions = value.split()
436 # TODO for partial update, partitions in the same group must be all
437 # updated or all omitted
438 partitions = filter(partitions_filter, partitions)
439 output_list.append('{}={}'.format(key, ' '.join(partitions)))
440 else:
441 output_list.append(line)
442 return '\n'.join(output_list)
443
444
Tao Bao15a146a2018-02-21 16:06:59 -0800445def GetTargetFilesZipForSecondaryImages(input_file, skip_postinstall=False):
Tao Baof7140c02018-01-30 17:09:24 -0800446 """Returns a target-files.zip file for generating secondary payload.
447
448 Although the original target-files.zip already contains secondary slot
449 images (i.e. IMAGES/system_other.img), we need to rename the files to the
450 ones without _other suffix. Note that we cannot instead modify the names in
451 META/ab_partitions.txt, because there are no matching partitions on device.
452
453 For the partitions that don't have secondary images, the ones for primary
454 slot will be used. This is to ensure that we always have valid boot, vbmeta,
455 bootloader images in the inactive slot.
456
Kelvin Zhangbd111cc2023-04-07 09:46:48 -0700457 After writing system_other to inactive slot's system partiiton,
458 PackageManagerService will read `ro.cp_system_other_odex`, and set
459 `sys.cppreopt` to "requested". Then, according to
460 system/extras/cppreopts/cppreopts.rc , init will mount system_other at
461 /postinstall, and execute `cppreopts` to copy optimized APKs from
462 /postinstall to /data .
463
Tao Baof7140c02018-01-30 17:09:24 -0800464 Args:
465 input_file: The input target-files.zip file.
Tao Bao15a146a2018-02-21 16:06:59 -0800466 skip_postinstall: Whether to skip copying the postinstall config file.
Tao Baof7140c02018-01-30 17:09:24 -0800467
468 Returns:
469 The filename of the target-files.zip for generating secondary payload.
470 """
Tianjie Xu1c808002019-09-11 00:29:26 -0700471
472 def GetInfoForSecondaryImages(info_file):
Yifan Hong38ab4d82020-06-18 15:19:56 -0700473 """Updates info file for secondary payload generation."""
Tianjie Xu1c808002019-09-11 00:29:26 -0700474 with open(info_file) as f:
Yifan Hong38ab4d82020-06-18 15:19:56 -0700475 content = f.read()
476 # Remove virtual_ab flag from secondary payload so that OTA client
477 # don't use snapshots for secondary update
478 delete_keys = ['virtual_ab', "virtual_ab_retrofit"]
479 return UpdatesInfoForSpecialUpdates(
480 content, lambda p: p not in SECONDARY_PAYLOAD_SKIPPED_IMAGES,
481 delete_keys)
Tianjie Xu1c808002019-09-11 00:29:26 -0700482
Tao Baof7140c02018-01-30 17:09:24 -0800483 target_file = common.MakeTempFile(prefix="targetfiles-", suffix=".zip")
484 target_zip = zipfile.ZipFile(target_file, 'w', allowZip64=True)
485
Kelvin Zhang5b9ca882023-08-01 10:03:17 -0700486 fileslist = []
487 for (root, dirs, files) in os.walk(input_file):
488 root = root.lstrip(input_file).lstrip("/")
489 fileslist.extend([os.path.join(root, d) for d in dirs])
490 fileslist.extend([os.path.join(root, d) for d in files])
Tao Bao12489802018-07-12 14:47:38 -0700491
Kelvin Zhang5b9ca882023-08-01 10:03:17 -0700492 input_tmp = input_file
493 for filename in fileslist:
494 unzipped_file = os.path.join(input_tmp, *filename.split('/'))
495 if filename == 'IMAGES/system_other.img':
Tao Baof7140c02018-01-30 17:09:24 -0800496 common.ZipWrite(target_zip, unzipped_file, arcname='IMAGES/system.img')
497
498 # Primary images and friends need to be skipped explicitly.
Kelvin Zhang5b9ca882023-08-01 10:03:17 -0700499 elif filename in ('IMAGES/system.img',
500 'IMAGES/system.map'):
Tao Baof7140c02018-01-30 17:09:24 -0800501 pass
Tao Bao3e759462019-09-17 22:43:11 -0700502
503 # Copy images that are not in SECONDARY_PAYLOAD_SKIPPED_IMAGES.
Kelvin Zhang5b9ca882023-08-01 10:03:17 -0700504 elif filename.startswith(('IMAGES/', 'RADIO/')):
505 image_name = os.path.basename(filename)
Tao Bao3e759462019-09-17 22:43:11 -0700506 if image_name not in ['{}.img'.format(partition) for partition in
507 SECONDARY_PAYLOAD_SKIPPED_IMAGES]:
Kelvin Zhang5b9ca882023-08-01 10:03:17 -0700508 common.ZipWrite(target_zip, unzipped_file, arcname=filename)
Tao Baof7140c02018-01-30 17:09:24 -0800509
Tao Bao15a146a2018-02-21 16:06:59 -0800510 # Skip copying the postinstall config if requested.
Kelvin Zhang5b9ca882023-08-01 10:03:17 -0700511 elif skip_postinstall and filename == POSTINSTALL_CONFIG:
Tao Bao15a146a2018-02-21 16:06:59 -0800512 pass
513
Kelvin Zhang5b9ca882023-08-01 10:03:17 -0700514 elif filename.startswith('META/'):
Tianjie Xu1c808002019-09-11 00:29:26 -0700515 # Remove the unnecessary partitions for secondary images from the
516 # ab_partitions file.
Kelvin Zhang5b9ca882023-08-01 10:03:17 -0700517 if filename == AB_PARTITIONS:
Tianjie Xu1c808002019-09-11 00:29:26 -0700518 with open(unzipped_file) as f:
519 partition_list = f.read().splitlines()
520 partition_list = [partition for partition in partition_list if partition
Tao Bao3e759462019-09-17 22:43:11 -0700521 and partition not in SECONDARY_PAYLOAD_SKIPPED_IMAGES]
Kelvin Zhang5b9ca882023-08-01 10:03:17 -0700522 common.ZipWriteStr(target_zip, filename,
Kelvin Zhang0876c412020-06-23 15:06:58 -0400523 '\n'.join(partition_list))
Tianjie Xu1c808002019-09-11 00:29:26 -0700524 # Remove the unnecessary partitions from the dynamic partitions list.
Kelvin Zhang5b9ca882023-08-01 10:03:17 -0700525 elif (filename == 'META/misc_info.txt' or
526 filename == DYNAMIC_PARTITION_INFO):
Tianjie Xu1c808002019-09-11 00:29:26 -0700527 modified_info = GetInfoForSecondaryImages(unzipped_file)
Kelvin Zhang5b9ca882023-08-01 10:03:17 -0700528 common.ZipWriteStr(target_zip, filename, modified_info)
Tianjie Xu1c808002019-09-11 00:29:26 -0700529 else:
Kelvin Zhang5b9ca882023-08-01 10:03:17 -0700530 common.ZipWrite(target_zip, unzipped_file, arcname=filename)
Tao Baof7140c02018-01-30 17:09:24 -0800531
Kelvin Zhangf92f7f02023-04-14 21:32:54 +0000532 common.ZipClose(target_zip)
Tao Baof7140c02018-01-30 17:09:24 -0800533
534 return target_file
535
536
Tao Bao15a146a2018-02-21 16:06:59 -0800537def GetTargetFilesZipWithoutPostinstallConfig(input_file):
538 """Returns a target-files.zip that's not containing postinstall_config.txt.
539
540 This allows brillo_update_payload script to skip writing all the postinstall
541 hooks in the generated payload. The input target-files.zip file will be
542 duplicated, with 'META/postinstall_config.txt' skipped. If input_file doesn't
543 contain the postinstall_config.txt entry, the input file will be returned.
544
545 Args:
546 input_file: The input target-files.zip filename.
547
548 Returns:
549 The filename of target-files.zip that doesn't contain postinstall config.
550 """
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700551 config_path = os.path.join(input_file, POSTINSTALL_CONFIG)
552 if os.path.exists(config_path):
553 os.unlink(config_path)
554 return input_file
Tao Bao15a146a2018-02-21 16:06:59 -0800555
Kelvin Zhang06400172021-03-05 15:42:03 -0500556
Kelvin Zhanga59bb272020-10-30 12:52:25 -0400557def ParseInfoDict(target_file_path):
Kelvin Zhangb97416e2023-05-15 11:13:26 -0700558 return common.LoadInfoDict(target_file_path)
Tao Bao15a146a2018-02-21 16:06:59 -0800559
Kelvin Zhang8793a722023-12-07 13:19:47 -0800560def ModifyTargetFilesDynamicPartitionInfo(input_file, key, value):
Kelvin Zhang84b3a282022-03-04 12:26:20 -0800561 """Returns a target-files.zip with a custom VABC compression param.
562 Args:
563 input_file: The input target-files.zip path
564 vabc_compression_param: Custom Virtual AB Compression algorithm
565
566 Returns:
567 The path to modified target-files.zip
568 """
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700569 if os.path.isdir(input_file):
570 dynamic_partition_info_path = os.path.join(
Kelvin Zhang8793a722023-12-07 13:19:47 -0800571 input_file, *DYNAMIC_PARTITION_INFO.split("/"))
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700572 with open(dynamic_partition_info_path, "r") as fp:
573 dynamic_partition_info = fp.read()
Kelvin Zhang8793a722023-12-07 13:19:47 -0800574 dynamic_partition_info = ModifyKeyvalueList(
575 dynamic_partition_info, key, value)
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700576 with open(dynamic_partition_info_path, "w") as fp:
577 fp.write(dynamic_partition_info)
578 return input_file
579
Kelvin Zhang84b3a282022-03-04 12:26:20 -0800580 target_file = common.MakeTempFile(prefix="targetfiles-", suffix=".zip")
581 shutil.copyfile(input_file, target_file)
582 common.ZipDelete(target_file, DYNAMIC_PARTITION_INFO)
583 with zipfile.ZipFile(input_file, 'r', allowZip64=True) as zfp:
584 dynamic_partition_info = zfp.read(DYNAMIC_PARTITION_INFO).decode()
Kelvin Zhang8793a722023-12-07 13:19:47 -0800585 dynamic_partition_info = ModifyKeyvalueList(
586 dynamic_partition_info, key, value)
Kelvin Zhang84b3a282022-03-04 12:26:20 -0800587 with zipfile.ZipFile(target_file, "a", allowZip64=True) as output_zip:
588 output_zip.writestr(DYNAMIC_PARTITION_INFO, dynamic_partition_info)
589 return target_file
590
Kelvin Zhang8793a722023-12-07 13:19:47 -0800591def GetTargetFilesZipForCustomVABCCompression(input_file, vabc_compression_param):
592 """Returns a target-files.zip with a custom VABC compression param.
593 Args:
594 input_file: The input target-files.zip path
595 vabc_compression_param: Custom Virtual AB Compression algorithm
596
597 Returns:
598 The path to modified target-files.zip
599 """
600 return ModifyTargetFilesDynamicPartitionInfo(input_file, "virtual_ab_compression_method", vabc_compression_param)
601
Kelvin Zhang84b3a282022-03-04 12:26:20 -0800602
Yifan Hong38ab4d82020-06-18 15:19:56 -0700603def GetTargetFilesZipForPartialUpdates(input_file, ab_partitions):
604 """Returns a target-files.zip for partial ota update package generation.
605
606 This function modifies ab_partitions list with the desired partitions before
607 calling the brillo_update_payload script. It also cleans up the reference to
Daniel Zhengcedc7652024-02-21 13:32:16 -0800608 the excluded partitions in the info file, e.g. misc_info.txt.
Yifan Hong38ab4d82020-06-18 15:19:56 -0700609
610 Args:
611 input_file: The input target-files.zip filename.
612 ab_partitions: A list of partitions to include in the partial update
613
614 Returns:
615 The filename of target-files.zip used for partial ota update.
616 """
617
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700618 original_ab_partitions = common.ReadFromInputFile(input_file, AB_PARTITIONS)
Yifan Hong38ab4d82020-06-18 15:19:56 -0700619
620 unrecognized_partitions = [partition for partition in ab_partitions if
621 partition not in original_ab_partitions]
622 if unrecognized_partitions:
623 raise ValueError("Unrecognized partitions when generating partial updates",
624 unrecognized_partitions)
625
626 logger.info("Generating partial updates for %s", ab_partitions)
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700627 for subdir in ["IMAGES", "RADIO", "PREBUILT_IMAGES"]:
628 image_dir = os.path.join(subdir)
629 if not os.path.exists(image_dir):
630 continue
631 for filename in os.listdir(image_dir):
632 filepath = os.path.join(image_dir, filename)
633 if filename.endswith(".img"):
634 partition_name = filename.removesuffix(".img")
635 if partition_name not in ab_partitions:
636 os.unlink(filepath)
Yifan Hong38ab4d82020-06-18 15:19:56 -0700637
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700638 common.WriteToInputFile(input_file, 'META/ab_partitions.txt',
639 '\n'.join(ab_partitions))
640 CARE_MAP_ENTRY = "META/care_map.pb"
641 if DoesInputFileContain(input_file, CARE_MAP_ENTRY):
642 caremap = care_map_pb2.CareMap()
643 caremap.ParseFromString(
644 common.ReadBytesFromInputFile(input_file, CARE_MAP_ENTRY))
645 filtered = [
646 part for part in caremap.partitions if part.name in ab_partitions]
647 del caremap.partitions[:]
648 caremap.partitions.extend(filtered)
649 common.WriteBytesToInputFile(input_file, CARE_MAP_ENTRY,
650 caremap.SerializeToString())
Yifan Hong38ab4d82020-06-18 15:19:56 -0700651
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700652 for info_file in ['META/misc_info.txt', DYNAMIC_PARTITION_INFO]:
653 if not DoesInputFileContain(input_file, info_file):
654 logger.warning('Cannot find %s in input zipfile', info_file)
655 continue
Yifan Hong38ab4d82020-06-18 15:19:56 -0700656
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700657 content = common.ReadFromInputFile(input_file, info_file)
658 modified_info = UpdatesInfoForSpecialUpdates(
659 content, lambda p: p in ab_partitions)
660 if OPTIONS.vabc_compression_param and info_file == DYNAMIC_PARTITION_INFO:
661 modified_info = ModifyVABCCompressionParam(
662 modified_info, OPTIONS.vabc_compression_param)
663 common.WriteToInputFile(input_file, info_file, modified_info)
Kelvin Zhang766eea72021-06-03 09:36:08 -0400664
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700665 def IsInPartialList(postinstall_line: str):
666 idx = postinstall_line.find("=")
667 if idx < 0:
668 return False
669 key = postinstall_line[:idx]
670 logger.info("%s %s", key, ab_partitions)
671 for part in ab_partitions:
672 if key.endswith("_" + part):
673 return True
674 return False
Yifan Hong38ab4d82020-06-18 15:19:56 -0700675
Kelvin Zhang1e774242023-06-17 09:18:15 -0700676 if common.DoesInputFileContain(input_file, POSTINSTALL_CONFIG):
677 postinstall_config = common.ReadFromInputFile(
678 input_file, POSTINSTALL_CONFIG)
679 postinstall_config = [
680 line for line in postinstall_config.splitlines() if IsInPartialList(line)]
681 if postinstall_config:
682 postinstall_config = "\n".join(postinstall_config)
683 common.WriteToInputFile(
684 input_file, POSTINSTALL_CONFIG, postinstall_config)
685 else:
686 os.unlink(os.path.join(input_file, POSTINSTALL_CONFIG))
Kelvin Zhang766eea72021-06-03 09:36:08 -0400687
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700688 return input_file
Yifan Hong38ab4d82020-06-18 15:19:56 -0700689
690
Yifan Hong50e79542018-11-08 17:44:12 -0800691def GetTargetFilesZipForRetrofitDynamicPartitions(input_file,
Yifan Hongb433eba2019-03-06 12:42:53 -0800692 super_block_devices,
693 dynamic_partition_list):
Yifan Hong50e79542018-11-08 17:44:12 -0800694 """Returns a target-files.zip for retrofitting dynamic partitions.
695
696 This allows brillo_update_payload to generate an OTA based on the exact
697 bits on the block devices. Postinstall is disabled.
698
699 Args:
700 input_file: The input target-files.zip filename.
701 super_block_devices: The list of super block devices
Yifan Hongb433eba2019-03-06 12:42:53 -0800702 dynamic_partition_list: The list of dynamic partitions
Yifan Hong50e79542018-11-08 17:44:12 -0800703
704 Returns:
705 The filename of target-files.zip with *.img replaced with super_*.img for
706 each block device in super_block_devices.
707 """
708 assert super_block_devices, "No super_block_devices are specified."
709
710 replace = {'OTA/super_{}.img'.format(dev): 'IMAGES/{}.img'.format(dev)
Tao Bao03fecb62018-11-28 10:59:23 -0800711 for dev in super_block_devices}
Yifan Hong50e79542018-11-08 17:44:12 -0800712
Yifan Hongb433eba2019-03-06 12:42:53 -0800713 # Remove partitions from META/ab_partitions.txt that is in
714 # dynamic_partition_list but not in super_block_devices so that
715 # brillo_update_payload won't generate update for those logical partitions.
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700716 ab_partitions_lines = common.ReadFromInputFile(
717 input_file, AB_PARTITIONS).split("\n")
718 ab_partitions = [line.strip() for line in ab_partitions_lines]
Yifan Hongb433eba2019-03-06 12:42:53 -0800719 # Assert that all super_block_devices are in ab_partitions
720 super_device_not_updated = [partition for partition in super_block_devices
721 if partition not in ab_partitions]
722 assert not super_device_not_updated, \
723 "{} is in super_block_devices but not in {}".format(
724 super_device_not_updated, AB_PARTITIONS)
725 # ab_partitions -= (dynamic_partition_list - super_block_devices)
Yifan Hongb433eba2019-03-06 12:42:53 -0800726 to_delete = [AB_PARTITIONS]
727
Yifan Hong50e79542018-11-08 17:44:12 -0800728 # Always skip postinstall for a retrofit update.
Yifan Hongb433eba2019-03-06 12:42:53 -0800729 to_delete += [POSTINSTALL_CONFIG]
Yifan Hong50e79542018-11-08 17:44:12 -0800730
731 # Delete dynamic_partitions_info.txt so that brillo_update_payload thinks this
732 # is a regular update on devices without dynamic partitions support.
733 to_delete += [DYNAMIC_PARTITION_INFO]
734
Tao Bao03fecb62018-11-28 10:59:23 -0800735 # Remove the existing partition images as well as the map files.
Tao Bao59cf0c52019-06-25 10:04:24 -0700736 to_delete += list(replace.values())
Tao Bao03fecb62018-11-28 10:59:23 -0800737 to_delete += ['IMAGES/{}.map'.format(dev) for dev in super_block_devices]
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700738 for item in to_delete:
739 os.unlink(os.path.join(input_file, item))
Yifan Hong50e79542018-11-08 17:44:12 -0800740
741 # Write super_{foo}.img as {foo}.img.
742 for src, dst in replace.items():
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700743 assert DoesInputFileContain(input_file, src), \
Tao Bao59cf0c52019-06-25 10:04:24 -0700744 'Missing {} in {}; {} cannot be written'.format(src, input_file, dst)
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700745 source_path = os.path.join(input_file, *src.split("/"))
746 target_path = os.path.join(input_file, *dst.split("/"))
747 os.rename(source_path, target_path)
Yifan Hong50e79542018-11-08 17:44:12 -0800748
Yifan Hongb433eba2019-03-06 12:42:53 -0800749 # Write new ab_partitions.txt file
Chirayu Desaic8edf8a2024-04-19 02:46:47 +0530750 new_ab_partitions = os.path.join(input_file, AB_PARTITIONS)
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700751 with open(new_ab_partitions, 'w') as f:
752 for partition in ab_partitions:
753 if (partition in dynamic_partition_list and
754 partition not in super_block_devices):
755 logger.info("Dropping %s from ab_partitions.txt", partition)
756 continue
757 f.write(partition + "\n")
Yifan Hongb433eba2019-03-06 12:42:53 -0800758
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700759 return input_file
Yifan Hong50e79542018-11-08 17:44:12 -0800760
Kelvin Zhanga59bb272020-10-30 12:52:25 -0400761
Kelvin Zhang0fda6292023-09-26 16:07:26 -0700762def GetTargetFilesZipForCustomImagesUpdates(input_file, custom_images: dict):
Hongguang Chen49ab1b902020-10-19 14:15:43 -0700763 """Returns a target-files.zip for custom partitions update.
764
765 This function modifies ab_partitions list with the desired custom partitions
766 and puts the custom images into the target target-files.zip.
767
768 Args:
Kelvin Zhang0fda6292023-09-26 16:07:26 -0700769 input_file: The input target-files extracted directory
Hongguang Chen49ab1b902020-10-19 14:15:43 -0700770 custom_images: A map of custom partitions and custom images.
771
772 Returns:
Kelvin Zhang0fda6292023-09-26 16:07:26 -0700773 The extracted dir of a target-files.zip which has renamed the custom images
774 in the IMAGES/ to their partition names.
Hongguang Chen49ab1b902020-10-19 14:15:43 -0700775 """
Kelvin Zhang0fda6292023-09-26 16:07:26 -0700776 for custom_image in custom_images.values():
777 if not os.path.exists(os.path.join(input_file, "IMAGES", custom_image)):
778 raise ValueError("Specified custom image {} not found in target files {}, available images are {}",
779 custom_image, input_file, os.listdir(os.path.join(input_file, "IMAGES")))
Gregory Montoir10e0dec2023-03-01 14:34:15 +0800780
Hongguang Chen49ab1b902020-10-19 14:15:43 -0700781 for custom_partition, custom_image in custom_images.items():
782 default_custom_image = '{}.img'.format(custom_partition)
783 if default_custom_image != custom_image:
Kelvin Zhang0fda6292023-09-26 16:07:26 -0700784 src = os.path.join(input_file, 'IMAGES', custom_image)
785 dst = os.path.join(input_file, 'IMAGES', default_custom_image)
786 os.rename(src, dst)
Hongguang Chen49ab1b902020-10-19 14:15:43 -0700787
Kelvin Zhang0fda6292023-09-26 16:07:26 -0700788 return input_file
Yifan Hong50e79542018-11-08 17:44:12 -0800789
Kelvin Zhang06400172021-03-05 15:42:03 -0500790
Kelvin Zhanga59bb272020-10-30 12:52:25 -0400791def GeneratePartitionTimestampFlags(partition_state):
792 partition_timestamps = [
793 part.partition_name + ":" + part.version
794 for part in partition_state]
795 return ["--partition_timestamps", ",".join(partition_timestamps)]
796
Kelvin Zhang06400172021-03-05 15:42:03 -0500797
Kelvin Zhang22c687c2021-01-21 10:51:57 -0500798def GeneratePartitionTimestampFlagsDowngrade(
Kelvin Zhang06400172021-03-05 15:42:03 -0500799 pre_partition_state, post_partition_state):
Kelvin Zhang80195722020-11-04 14:38:34 -0500800 assert pre_partition_state is not None
801 partition_timestamps = {}
Kelvin Zhang80195722020-11-04 14:38:34 -0500802 for part in post_partition_state:
Kelvin Zhang9a698e62022-05-09 10:20:52 -0700803 partition_timestamps[part.partition_name] = part.version
804 for part in pre_partition_state:
805 if part.partition_name in partition_timestamps:
806 partition_timestamps[part.partition_name] = \
Kelvin Zhang059bf6e2022-08-12 14:03:41 -0700807 max(part.version, partition_timestamps[part.partition_name])
Kelvin Zhang80195722020-11-04 14:38:34 -0500808 return [
Kelvin Zhang22c687c2021-01-21 10:51:57 -0500809 "--partition_timestamps",
Kelvin Zhang06400172021-03-05 15:42:03 -0500810 ",".join([key + ":" + val for (key, val)
811 in partition_timestamps.items()])
Kelvin Zhang22c687c2021-01-21 10:51:57 -0500812 ]
Kelvin Zhang80195722020-11-04 14:38:34 -0500813
Kelvin Zhang06400172021-03-05 15:42:03 -0500814
Kelvin Zhang65029a22020-11-03 10:07:51 -0500815def SupportsMainlineGkiUpdates(target_file):
816 """Return True if the build supports MainlineGKIUpdates.
817
818 This function scans the product.img file in IMAGES/ directory for
819 pattern |*/apex/com.android.gki.*.apex|. If there are files
820 matching this pattern, conclude that build supports mainline
821 GKI and return True
822
823 Args:
824 target_file: Path to a target_file.zip, or an extracted directory
825 Return:
826 True if thisb uild supports Mainline GKI Updates.
827 """
828 if target_file is None:
829 return False
830 if os.path.isfile(target_file):
831 target_file = common.UnzipTemp(target_file, ["IMAGES/product.img"])
832 if not os.path.isdir(target_file):
833 assert os.path.isdir(target_file), \
834 "{} must be a path to zip archive or dir containing extracted"\
835 " target_files".format(target_file)
836 image_file = os.path.join(target_file, "IMAGES", "product.img")
837
838 if not os.path.isfile(image_file):
839 return False
840
841 if IsSparseImage(image_file):
842 # Unsparse the image
843 tmp_img = common.MakeTempFile(suffix=".img")
844 subprocess.check_output(["simg2img", image_file, tmp_img])
845 image_file = tmp_img
846
847 cmd = ["debugfs_static", "-R", "ls -p /apex", image_file]
848 output = subprocess.check_output(cmd).decode()
849
850 pattern = re.compile(r"com\.android\.gki\..*\.apex")
851 return pattern.search(output) is not None
852
Kelvin Zhang06400172021-03-05 15:42:03 -0500853
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700854def ExtractOrCopyTargetFiles(target_file):
855 if os.path.isdir(target_file):
856 return CopyTargetFilesDir(target_file)
857 else:
858 return ExtractTargetFiles(target_file)
859
860
Daniel Zheng15a36a12024-01-16 12:38:58 -0800861def ValidateCompressionParam(target_info):
Kelvin Zhang7d1b29b2023-10-09 14:06:18 -0700862 vabc_compression_param = OPTIONS.vabc_compression_param
863 if vabc_compression_param:
Daniel Zheng15a36a12024-01-16 12:38:58 -0800864 minimum_api_level_required = VABC_COMPRESSION_PARAM_SUPPORT[vabc_compression_param.split(",")[0]]
Kelvin Zhang7d1b29b2023-10-09 14:06:18 -0700865 if target_info.vendor_api_level < minimum_api_level_required:
866 raise ValueError("Specified VABC compression param {} is only supported for API level >= {}, device is on API level {}".format(
867 vabc_compression_param, minimum_api_level_required, target_info.vendor_api_level))
868
869
Tao Baof0c4aa22018-04-30 20:29:30 -0700870def GenerateAbOtaPackage(target_file, output_file, source_file=None):
Tao Baofe5b69a2018-03-02 09:47:43 -0800871 """Generates an Android OTA package that has A/B update payload."""
Kelvin Zhang9dbe2ce2023-04-17 16:38:08 -0700872 # If input target_files are directories, create a copy so that we can modify
873 # them directly
Kelvin Zhang2f9a9ae2023-09-27 09:33:52 -0700874 target_info = common.BuildInfo(OPTIONS.info_dict, OPTIONS.oem_dicts)
875 if OPTIONS.disable_vabc and target_info.is_release_key:
876 raise ValueError("Disabling VABC on release-key builds is not supported.")
Daniel Zheng2826b1a2024-03-28 16:41:17 -0700877
Daniel Zheng15a36a12024-01-16 12:38:58 -0800878 ValidateCompressionParam(target_info)
Kelvin Zhang7d1b29b2023-10-09 14:06:18 -0700879 vabc_compression_param = target_info.vabc_compression_param
Kelvin Zhang2f9a9ae2023-09-27 09:33:52 -0700880
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700881 target_file = ExtractOrCopyTargetFiles(target_file)
882 if source_file is not None:
883 source_file = ExtractOrCopyTargetFiles(source_file)
Tao Baodea0f8b2016-06-20 17:55:06 -0700884 # Stage the output zip package for package signing.
Tao Bao491d7e22018-02-21 13:17:22 -0800885 if not OPTIONS.no_signing:
886 staging_file = common.MakeTempFile(suffix='.zip')
887 else:
888 staging_file = output_file
Tao Baoa652c002018-03-01 19:31:38 -0800889 output_zip = zipfile.ZipFile(staging_file, "w",
Kelvin Zhang22c687c2021-01-21 10:51:57 -0500890 compression=zipfile.ZIP_DEFLATED,
891 allowZip64=True)
Tao Baoc098e9e2016-01-07 13:03:56 -0800892
Tao Bao481bab82017-12-21 11:23:09 -0800893 if source_file is not None:
Kelvin Zhang6b10e152023-05-02 15:48:16 -0700894 source_file = ExtractTargetFiles(source_file)
Kelvin Zhang39aea442020-08-17 11:04:25 -0400895 assert "ab_partitions" in OPTIONS.source_info_dict, \
896 "META/ab_partitions.txt is required for ab_update."
897 assert "ab_partitions" in OPTIONS.target_info_dict, \
898 "META/ab_partitions.txt is required for ab_update."
Tao Bao1c320f82019-10-04 23:25:12 -0700899 target_info = common.BuildInfo(OPTIONS.target_info_dict, OPTIONS.oem_dicts)
900 source_info = common.BuildInfo(OPTIONS.source_info_dict, OPTIONS.oem_dicts)
Kelvin Zhang563750f2021-04-28 12:46:17 -0400901 # If source supports VABC, delta_generator/update_engine will attempt to
902 # use VABC. This dangerous, as the target build won't have snapuserd to
903 # serve I/O request when device boots. Therefore, disable VABC if source
904 # build doesn't supports it.
905 if not source_info.is_vabc or not target_info.is_vabc:
Kelvin Zhang10eac082021-06-10 14:32:19 -0400906 logger.info("Either source or target does not support VABC, disabling.")
Kelvin Zhang563750f2021-04-28 12:46:17 -0400907 OPTIONS.disable_vabc = True
Kelvin Zhang7d1b29b2023-10-09 14:06:18 -0700908 if OPTIONS.vabc_compression_param is None and \
909 source_info.vabc_compression_param != target_info.vabc_compression_param:
Kelvin Zhang8f830002023-08-16 13:16:48 -0700910 logger.info("Source build and target build use different compression methods {} vs {}, default to source builds parameter {}".format(
911 source_info.vabc_compression_param, target_info.vabc_compression_param, source_info.vabc_compression_param))
Kelvin Zhang7d1b29b2023-10-09 14:06:18 -0700912 vabc_compression_param = source_info.vabc_compression_param
Daniel Zheng474afa82024-02-28 12:59:52 -0800913 # Virtual AB Cow version 3 is introduced in Android U with improved memory
914 # and install time performance. All OTA's with
915 # both the source build and target build with VIRTUAL_AB_COW_VERSION = 3
916 # can support the new format. Otherwise, fallback on older versions
Daniel Zheng60922a42024-05-15 14:06:24 -0700917 if not OPTIONS.vabc_cow_version:
918 if not source_info.vabc_cow_version or not target_info.vabc_cow_version:
919 logger.info("Source or Target doesn't have VABC_COW_VERSION specified, default to version 2")
920 OPTIONS.vabc_cow_version = 2
921 elif source_info.vabc_cow_version != target_info.vabc_cow_version:
922 logger.info("Source and Target have different cow VABC_COW_VERSION specified, default to minimum version")
923 OPTIONS.vabc_cow_version = min(source_info.vabc_cow_version, target_info.vabc_cow_version)
Daniel Zheng2826b1a2024-03-28 16:41:17 -0700924
Kelvin Zhanga9a87ec2022-05-04 16:44:52 -0700925 # Virtual AB Compression was introduced in Androd S.
926 # Later, we backported VABC to Android R. But verity support was not
927 # backported, so if VABC is used and we are on Android R, disable
928 # verity computation.
929 if not OPTIONS.disable_vabc and source_info.is_android_r:
930 OPTIONS.disable_verity_computation = True
931 OPTIONS.disable_fec_computation = True
932
Tao Bao481bab82017-12-21 11:23:09 -0800933 else:
Kelvin Zhang39aea442020-08-17 11:04:25 -0400934 assert "ab_partitions" in OPTIONS.info_dict, \
935 "META/ab_partitions.txt is required for ab_update."
Tao Bao481bab82017-12-21 11:23:09 -0800936 source_info = None
Daniel Zheng60922a42024-05-15 14:06:24 -0700937 if not OPTIONS.vabc_cow_version:
938 if not target_info.vabc_cow_version:
939 OPTIONS.vabc_cow_version = 2
940 elif target_info.vabc_cow_version >= "3" and target_info.vendor_api_level < 35:
941 logger.warning(
942 "This full OTA is configured to use VABC cow version"
943 " 3 which is supported since"
944 " Android API level 35, but device is "
945 "launched with {} . If this full OTA is"
946 " served to a device running old build, OTA might fail due to "
947 "unsupported vabc cow version. For safety, version 2 is used because "
948 "it's supported since day 1.".format(
949 target_info.vendor_api_level))
Daniel Zheng2826b1a2024-03-28 16:41:17 -0700950 OPTIONS.vabc_cow_version = 2
Kelvin Zhang7d1b29b2023-10-09 14:06:18 -0700951 if OPTIONS.vabc_compression_param is None and vabc_compression_param:
Kelvin Zhang8f830002023-08-16 13:16:48 -0700952 minimum_api_level_required = VABC_COMPRESSION_PARAM_SUPPORT[
Kelvin Zhang7d1b29b2023-10-09 14:06:18 -0700953 vabc_compression_param]
Kelvin Zhang8f830002023-08-16 13:16:48 -0700954 if target_info.vendor_api_level < minimum_api_level_required:
955 logger.warning(
956 "This full OTA is configured to use VABC compression algorithm"
957 " {}, which is supported since"
958 " Android API level {}, but device is "
959 "launched with {} . If this full OTA is"
960 " served to a device running old build, OTA might fail due to "
961 "unsupported compression parameter. For safety, gz is used because "
962 "it's supported since day 1.".format(
Kelvin Zhang7d1b29b2023-10-09 14:06:18 -0700963 vabc_compression_param,
Kelvin Zhang8f830002023-08-16 13:16:48 -0700964 minimum_api_level_required,
965 target_info.vendor_api_level))
Kelvin Zhang7d1b29b2023-10-09 14:06:18 -0700966 vabc_compression_param = "gz"
Tao Baoc098e9e2016-01-07 13:03:56 -0800967
Kelvin Zhanga10528c2023-01-03 15:14:53 -0800968 if OPTIONS.partial == []:
969 logger.info(
970 "Automatically detecting partial partition list from input target files.")
971 OPTIONS.partial = target_info.get(
972 "partial_ota_update_partitions_list").split()
973 assert OPTIONS.partial, "Input target_file does not have"
974 " partial_ota_update_partitions_list defined, failed to auto detect partial"
975 " partition list. Please specify list of partitions to update manually via"
976 " --partial=a,b,c , or generate a complete OTA by removing the --partial"
977 " option"
978 OPTIONS.partial.sort()
979 if source_info:
980 source_partial_list = source_info.get(
981 "partial_ota_update_partitions_list").split()
982 if source_partial_list:
983 source_partial_list.sort()
984 if source_partial_list != OPTIONS.partial:
985 logger.warning("Source build and target build have different partial partition lists. Source: %s, target: %s, taking the intersection.",
986 source_partial_list, OPTIONS.partial)
987 OPTIONS.partial = list(
988 set(OPTIONS.partial) and set(source_partial_list))
989 OPTIONS.partial.sort()
990 logger.info("Automatically deduced partial partition list: %s",
991 OPTIONS.partial)
992
Kelvin Zhang10eac082021-06-10 14:32:19 -0400993 if target_info.vendor_suppressed_vabc:
994 logger.info("Vendor suppressed VABC. Disabling")
995 OPTIONS.disable_vabc = True
Kelvin Zhangf1758012022-01-26 10:18:18 -0800996
997 # Both source and target build need to support VABC XOR for us to use it.
998 # Source build's update_engine must be able to write XOR ops, and target
999 # build's snapuserd must be able to interpret XOR ops.
1000 if not target_info.is_vabc_xor or OPTIONS.disable_vabc or \
Kelvin Zhang84b3a282022-03-04 12:26:20 -08001001 (source_info is not None and not source_info.is_vabc_xor):
Kelvin Zhangad427382021-08-12 16:19:09 -07001002 logger.info("VABC XOR Not supported, disabling")
1003 OPTIONS.enable_vabc_xor = False
Kelvin Zhang49fadf42023-03-07 14:35:42 -08001004
Kelvin Zhang88043be2023-03-07 14:42:18 -08001005 if OPTIONS.vabc_compression_param == "none":
Kelvin Zhangfcd731e2023-04-04 10:28:11 -07001006 logger.info(
1007 "VABC Compression algorithm is set to 'none', disabling VABC xor")
Kelvin Zhang88043be2023-03-07 14:42:18 -08001008 OPTIONS.enable_vabc_xor = False
David Anderson1c596172023-04-14 16:01:55 -07001009
1010 if OPTIONS.enable_vabc_xor:
1011 api_level = -1
1012 if source_info is not None:
1013 api_level = source_info.vendor_api_level
1014 if api_level == -1:
1015 api_level = target_info.vendor_api_level
1016
1017 # XOR is only supported on T and higher.
1018 if api_level < 33:
1019 logger.error("VABC XOR not supported on this vendor, disabling")
1020 OPTIONS.enable_vabc_xor = False
1021
Kelvin Zhang7d1b29b2023-10-09 14:06:18 -07001022 if OPTIONS.vabc_compression_param:
1023 vabc_compression_param = OPTIONS.vabc_compression_param
1024
Yifan Hong38ab4d82020-06-18 15:19:56 -07001025 additional_args = []
1026
Hongguang Chen49ab1b902020-10-19 14:15:43 -07001027 # Prepare custom images.
1028 if OPTIONS.custom_images:
1029 target_file = GetTargetFilesZipForCustomImagesUpdates(
1030 target_file, OPTIONS.custom_images)
1031
Yifan Hong50e79542018-11-08 17:44:12 -08001032 if OPTIONS.retrofit_dynamic_partitions:
1033 target_file = GetTargetFilesZipForRetrofitDynamicPartitions(
Yifan Hongb433eba2019-03-06 12:42:53 -08001034 target_file, target_info.get("super_block_devices").strip().split(),
1035 target_info.get("dynamic_partition_list").strip().split())
Yifan Hong38ab4d82020-06-18 15:19:56 -07001036 elif OPTIONS.partial:
1037 target_file = GetTargetFilesZipForPartialUpdates(target_file,
1038 OPTIONS.partial)
Kelvin Zhang7d1b29b2023-10-09 14:06:18 -07001039 if vabc_compression_param != target_info.vabc_compression_param:
Kelvin Zhang84b3a282022-03-04 12:26:20 -08001040 target_file = GetTargetFilesZipForCustomVABCCompression(
Kelvin Zhang7d1b29b2023-10-09 14:06:18 -07001041 target_file, vabc_compression_param)
Kelvin Zhang8793a722023-12-07 13:19:47 -08001042 if OPTIONS.vabc_cow_version:
1043 target_file = ModifyTargetFilesDynamicPartitionInfo(target_file, "virtual_ab_cow_version", OPTIONS.vabc_cow_version)
Daniel Zhenga567eae2024-01-08 14:20:49 -08001044 if OPTIONS.compression_factor:
1045 target_file = ModifyTargetFilesDynamicPartitionInfo(target_file, "virtual_ab_compression_factor", OPTIONS.compression_factor)
Kelvin Zhang6b10e152023-05-02 15:48:16 -07001046 if OPTIONS.skip_postinstall:
Tao Bao15a146a2018-02-21 16:06:59 -08001047 target_file = GetTargetFilesZipWithoutPostinstallConfig(target_file)
Kelvin Zhang39aea442020-08-17 11:04:25 -04001048 # Target_file may have been modified, reparse ab_partitions
Kelvin Zhang9dbe2ce2023-04-17 16:38:08 -07001049 target_info.info_dict['ab_partitions'] = common.ReadFromInputFile(target_file,
1050 AB_PARTITIONS).strip().split("\n")
Tao Bao15a146a2018-02-21 16:06:59 -08001051
Kelvin Zhangb0360072023-05-09 20:30:53 -07001052 from check_target_files_vintf import CheckVintfIfTrebleEnabled
Kelvin Zhang414ca422021-08-27 15:12:08 -07001053 CheckVintfIfTrebleEnabled(target_file, target_info)
1054
Ben Fennemacd6de1b2024-04-25 08:17:09 -07001055 # Allow boot_variable_file to also exist in target-files
1056 if OPTIONS.boot_variable_file:
1057 if not os.path.isfile(OPTIONS.boot_variable_file):
1058 OPTIONS.boot_variable_file = os.path.join(target_file, OPTIONS.boot_variable_file)
Kelvin Zhang39aea442020-08-17 11:04:25 -04001059 # Metadata to comply with Android OTA package format.
1060 metadata = GetPackageMetadata(target_info, source_info)
Tao Bao40b18822018-01-30 18:19:04 -08001061 # Generate payload.
Kelvin Zhangfcd731e2023-04-04 10:28:11 -07001062 payload = PayloadGenerator(
Kelvin Zhangd51332c2023-10-23 10:03:02 -07001063 wipe_user_data=OPTIONS.wipe_user_data, minor_version=OPTIONS.force_minor_version, is_partial_update=OPTIONS.partial, spl_downgrade=OPTIONS.spl_downgrade)
Tao Bao40b18822018-01-30 18:19:04 -08001064
Kelvin Zhanga59bb272020-10-30 12:52:25 -04001065 partition_timestamps_flags = []
Tao Bao40b18822018-01-30 18:19:04 -08001066 # Enforce a max timestamp this payload can be applied on top of.
Tao Baoff1b86e2017-10-03 14:17:57 -07001067 if OPTIONS.downgrade:
HÃ¥kan Kvistb7797242023-12-13 15:02:28 +01001068 # When generating ota between merged target-files, partition build date can
1069 # decrease in target, at the same time as ro.build.date.utc increases,
1070 # so always pick largest value.
1071 max_timestamp = max(source_info.GetBuildProp("ro.build.date.utc"),
1072 str(metadata.postcondition.timestamp))
Kelvin Zhang80195722020-11-04 14:38:34 -05001073 partition_timestamps_flags = GeneratePartitionTimestampFlagsDowngrade(
Kelvin Zhang22c687c2021-01-21 10:51:57 -05001074 metadata.precondition.partition_state,
1075 metadata.postcondition.partition_state
1076 )
Tao Baoff1b86e2017-10-03 14:17:57 -07001077 else:
Tianjiea2076132020-08-19 17:25:32 -07001078 max_timestamp = str(metadata.postcondition.timestamp)
Kelvin Zhanga59bb272020-10-30 12:52:25 -04001079 partition_timestamps_flags = GeneratePartitionTimestampFlags(
1080 metadata.postcondition.partition_state)
Tao Baoc098e9e2016-01-07 13:03:56 -08001081
Kelvin Zhangf2728d62022-01-10 11:42:36 -08001082 if not ota_utils.IsZucchiniCompatible(source_file, target_file):
HÃ¥kan Kvist3db1ef62022-05-03 10:19:41 +02001083 logger.warning(
1084 "Builds doesn't support zucchini, or source/target don't have compatible zucchini versions. Disabling zucchini.")
Kelvin Zhangf2728d62022-01-10 11:42:36 -08001085 OPTIONS.enable_zucchini = False
1086
Kelvin Zhang0b7207c2022-08-26 17:49:08 +00001087 security_patch_level = target_info.GetBuildProp(
1088 "ro.build.version.security_patch")
1089 if OPTIONS.security_patch_level is not None:
1090 security_patch_level = OPTIONS.security_patch_level
1091
1092 additional_args += ["--security_patch_level", security_patch_level]
1093
Daniel Zhenga30989b2023-04-25 12:41:44 -07001094 if OPTIONS.max_threads:
1095 additional_args += ["--max_threads", OPTIONS.max_threads]
1096
Kelvin Zhangfcd731e2023-04-04 10:28:11 -07001097 additional_args += ["--enable_zucchini=" +
Kelvin Zhangf2728d62022-01-10 11:42:36 -08001098 str(OPTIONS.enable_zucchini).lower()]
Kelvin Zhang456c6d92023-08-01 09:52:00 -07001099 if OPTIONS.enable_puffdiff is not None:
1100 additional_args += ["--enable_puffdiff=" +
1101 str(OPTIONS.enable_puffdiff).lower()]
Kelvin Zhangf2728d62022-01-10 11:42:36 -08001102
1103 if not ota_utils.IsLz4diffCompatible(source_file, target_file):
Kelvin Zhang84b3a282022-03-04 12:26:20 -08001104 logger.warning(
Kelvin Zhang6fe2fc02022-01-13 12:38:49 -08001105 "Source build doesn't support lz4diff, or source/target don't have compatible lz4diff versions. Disabling lz4diff.")
Kelvin Zhangf2728d62022-01-10 11:42:36 -08001106 OPTIONS.enable_lz4diff = False
1107
Kelvin Zhangfcd731e2023-04-04 10:28:11 -07001108 additional_args += ["--enable_lz4diff=" +
Kelvin Zhangf2728d62022-01-10 11:42:36 -08001109 str(OPTIONS.enable_lz4diff).lower()]
1110
1111 if source_file and OPTIONS.enable_lz4diff:
1112 input_tmp = common.UnzipTemp(source_file, ["META/liblz4.so"])
1113 liblz4_path = os.path.join(input_tmp, "META", "liblz4.so")
1114 assert os.path.exists(
1115 liblz4_path), "liblz4.so not found in META/ dir of target file {}".format(liblz4_path)
1116 logger.info("Enabling lz4diff %s", liblz4_path)
1117 additional_args += ["--liblz4_path", liblz4_path]
Kelvin Zhang6fe2fc02022-01-13 12:38:49 -08001118 erofs_compression_param = OPTIONS.target_info_dict.get(
1119 "erofs_default_compressor")
1120 assert erofs_compression_param is not None, "'erofs_default_compressor' not found in META/misc_info.txt of target build. This is required to enable lz4diff."
1121 additional_args += ["--erofs_compression_param", erofs_compression_param]
Kelvin Zhang410bb382022-01-06 09:15:54 -08001122
Kelvin Zhangbbfa1822021-02-03 17:19:44 -05001123 if OPTIONS.disable_vabc:
Kelvin Zhangfcd731e2023-04-04 10:28:11 -07001124 additional_args += ["--disable_vabc=true"]
Kelvin Zhangf66caee2021-07-12 09:44:20 -04001125 if OPTIONS.enable_vabc_xor:
Kelvin Zhangfcd731e2023-04-04 10:28:11 -07001126 additional_args += ["--enable_vabc_xor=true"]
Kelvin Zhang9b6d4ec2021-10-28 09:34:31 -07001127 if OPTIONS.compressor_types:
1128 additional_args += ["--compressor_types", OPTIONS.compressor_types]
Kelvin Zhanga59bb272020-10-30 12:52:25 -04001129 additional_args += ["--max_timestamp", max_timestamp]
1130
1131 payload.Generate(
1132 target_file,
1133 source_file,
1134 additional_args + partition_timestamps_flags
Kelvin Zhang22c687c2021-01-21 10:51:57 -05001135 )
Tao Baoc098e9e2016-01-07 13:03:56 -08001136
Tao Bao40b18822018-01-30 18:19:04 -08001137 # Sign the payload.
Baligh Uddin968b9612022-09-08 02:17:58 +00001138 pw = OPTIONS.key_passwords[OPTIONS.package_key]
Kelvin Zhang059bf6e2022-08-12 14:03:41 -07001139 payload_signer = PayloadSigner(
Baligh Uddin968b9612022-09-08 02:17:58 +00001140 OPTIONS.package_key, OPTIONS.private_key_suffix,
1141 pw, OPTIONS.payload_signer)
Tao Baof7140c02018-01-30 17:09:24 -08001142 payload.Sign(payload_signer)
Tao Baoc098e9e2016-01-07 13:03:56 -08001143
Tao Bao40b18822018-01-30 18:19:04 -08001144 # Write the payload into output zip.
1145 payload.WriteToZip(output_zip)
Tao Baoc098e9e2016-01-07 13:03:56 -08001146
Tao Baof7140c02018-01-30 17:09:24 -08001147 # Generate and include the secondary payload that installs secondary images
1148 # (e.g. system_other.img).
1149 if OPTIONS.include_secondary:
1150 # We always include a full payload for the secondary slot, even when
1151 # building an incremental OTA. See the comments for "--include_secondary".
Tao Bao15a146a2018-02-21 16:06:59 -08001152 secondary_target_file = GetTargetFilesZipForSecondaryImages(
1153 target_file, OPTIONS.skip_postinstall)
Kelvin Zhangfa928692022-08-16 17:01:53 +00001154 secondary_payload = PayloadGenerator(secondary=True)
Tao Baodb1fe412018-02-09 23:15:05 -08001155 secondary_payload.Generate(secondary_target_file,
Kelvin Zhanga59bb272020-10-30 12:52:25 -04001156 additional_args=["--max_timestamp",
Kelvin Zhang22c687c2021-01-21 10:51:57 -05001157 max_timestamp])
Tao Baof7140c02018-01-30 17:09:24 -08001158 secondary_payload.Sign(payload_signer)
Tao Bao667ff572018-02-10 00:02:40 -08001159 secondary_payload.WriteToZip(output_zip)
Tao Baof7140c02018-01-30 17:09:24 -08001160
Tianjie Xucfa86222016-03-07 16:31:19 -08001161 # If dm-verity is supported for the device, copy contents of care_map
1162 # into A/B OTA package.
hungweichen22e3b012022-08-19 06:35:43 +00001163 if target_info.get("avb_enable") == "true":
Tianjie Xu4c05f4a2018-09-14 16:24:41 -07001164 # Adds care_map if either the protobuf format or the plain text one exists.
Kelvin Zhang9dbe2ce2023-04-17 16:38:08 -07001165 for care_map_name in ["care_map.pb", "care_map.txt"]:
1166 if not DoesInputFileContain(target_file, "META/" + care_map_name):
1167 continue
1168 care_map_data = common.ReadBytesFromInputFile(
1169 target_file, "META/" + care_map_name)
Tianjie Xu4c05f4a2018-09-14 16:24:41 -07001170 # In order to support streaming, care_map needs to be packed as
Tao Bao40b18822018-01-30 18:19:04 -08001171 # ZIP_STORED.
Tianjie Xu4c05f4a2018-09-14 16:24:41 -07001172 common.ZipWriteStr(output_zip, care_map_name, care_map_data,
Tao Bao481bab82017-12-21 11:23:09 -08001173 compress_type=zipfile.ZIP_STORED)
HÃ¥kan Kvistb8982fc2023-06-08 15:11:57 +02001174 # break here to avoid going into else when care map has been handled
1175 break
Tianjie Xucfa86222016-03-07 16:31:19 -08001176 else:
Tao Bao32fcdab2018-10-12 10:30:39 -07001177 logger.warning("Cannot find care map file in target_file package")
Tao Bao21803d32017-04-19 10:16:09 -07001178
Tianjiea5fca032021-06-01 22:06:28 -07001179 # Add the source apex version for incremental ota updates, and write the
1180 # result apex info to the ota package.
Kelvin Zhang9dbe2ce2023-04-17 16:38:08 -07001181 ota_apex_info = ota_utils.ConstructOtaApexInfo(target_file, source_file)
Tianjiea5fca032021-06-01 22:06:28 -07001182 if ota_apex_info is not None:
1183 common.ZipWriteStr(output_zip, "apex_info.pb", ota_apex_info,
1184 compress_type=zipfile.ZIP_STORED)
Kelvin Zhang7bd09912021-01-21 10:33:13 -05001185
Tao Baofe5b69a2018-03-02 09:47:43 -08001186 # We haven't written the metadata entry yet, which will be handled in
1187 # FinalizeMetadata().
Kelvin Zhangf92f7f02023-04-14 21:32:54 +00001188 common.ZipClose(output_zip)
Tao Baoc96316c2017-01-24 22:10:49 -08001189
Kelvin Zhangbf01f8b2022-08-30 18:25:43 +00001190 FinalizeMetadata(metadata, staging_file, output_file,
1191 package_key=OPTIONS.package_key)
Tao Baoc96316c2017-01-24 22:10:49 -08001192
Tao Baoc098e9e2016-01-07 13:03:56 -08001193
Doug Zongkereef39442009-04-02 12:14:19 -07001194def main(argv):
1195
1196 def option_handler(o, a):
Kelvin Zhang68252b82023-11-14 10:58:02 -08001197 if o in ("-i", "--incremental_from"):
Doug Zongkereef39442009-04-02 12:14:19 -07001198 OPTIONS.incremental_source = a
Tao Bao43078aa2015-04-21 14:32:35 -07001199 elif o == "--full_radio":
1200 OPTIONS.full_radio = True
leozwangaa6c1a12015-08-14 10:57:58 -07001201 elif o == "--full_bootloader":
1202 OPTIONS.full_bootloader = True
Tao Bao337633f2017-12-06 15:20:19 -08001203 elif o == "--wipe_user_data":
Doug Zongkerdbfaae52009-04-21 17:12:54 -07001204 OPTIONS.wipe_user_data = True
Tao Bao5d182562016-02-23 11:38:39 -08001205 elif o == "--downgrade":
1206 OPTIONS.downgrade = True
1207 OPTIONS.wipe_user_data = True
Tao Bao3e6161a2017-02-28 11:48:48 -08001208 elif o == "--override_timestamp":
Tao Baofaa8e0b2018-04-12 14:31:43 -07001209 OPTIONS.downgrade = True
Michael Runge6e836112014-04-15 17:40:21 -07001210 elif o in ("-o", "--oem_settings"):
Alain Vongsouvanh7f804ba2017-02-16 13:06:55 -08001211 OPTIONS.oem_source = a.split(',')
Tao Bao8608cde2016-02-25 19:49:55 -08001212 elif o == "--oem_no_mount":
1213 OPTIONS.oem_no_mount = True
Doug Zongker1c390a22009-05-14 19:06:36 -07001214 elif o in ("-e", "--extra_script"):
1215 OPTIONS.extra_script = a
Martin Blumenstingl374e1142014-05-31 20:42:55 +02001216 elif o in ("-t", "--worker_threads"):
1217 if a.isdigit():
1218 OPTIONS.worker_threads = int(a)
1219 else:
1220 raise ValueError("Cannot parse value %r for option %r - only "
1221 "integers are allowed." % (a, o))
Doug Zongker9b23f2c2013-11-25 14:44:12 -08001222 elif o in ("-2", "--two_step"):
1223 OPTIONS.two_step = True
Tao Baof7140c02018-01-30 17:09:24 -08001224 elif o == "--include_secondary":
1225 OPTIONS.include_secondary = True
Doug Zongker26e66192014-02-20 13:22:07 -08001226 elif o == "--no_signing":
Takeshi Kanemotoe153b342013-11-14 17:20:50 +09001227 OPTIONS.no_signing = True
Dan Albert8b72aef2015-03-23 19:13:21 -07001228 elif o == "--verify":
Michael Runge63f01de2014-10-28 19:24:19 -07001229 OPTIONS.verify = True
Doug Zongker26e66192014-02-20 13:22:07 -08001230 elif o == "--block":
1231 OPTIONS.block_based = True
Doug Zongker25568482014-03-03 10:21:27 -08001232 elif o in ("-b", "--binary"):
1233 OPTIONS.updater_binary = a
Tao Bao8dcf7382015-05-21 14:09:49 -07001234 elif o == "--stash_threshold":
1235 try:
1236 OPTIONS.stash_threshold = float(a)
1237 except ValueError:
1238 raise ValueError("Cannot parse value %r for option %r - expecting "
1239 "a float" % (a, o))
Tao Baod62c6032015-11-30 09:40:20 -08001240 elif o == "--log_diff":
1241 OPTIONS.log_diff = a
Dan Willemsencea5cd22017-03-21 14:44:27 -07001242 elif o == "--extracted_input_target_files":
1243 OPTIONS.extracted_input = a
Tao Bao15a146a2018-02-21 16:06:59 -08001244 elif o == "--skip_postinstall":
1245 OPTIONS.skip_postinstall = True
Yifan Hong50e79542018-11-08 17:44:12 -08001246 elif o == "--retrofit_dynamic_partitions":
1247 OPTIONS.retrofit_dynamic_partitions = True
xunchangabfa2652019-02-19 16:27:10 -08001248 elif o == "--skip_compatibility_check":
1249 OPTIONS.skip_compatibility_check = True
xunchang1cfe2512019-02-19 14:14:48 -08001250 elif o == "--output_metadata_path":
1251 OPTIONS.output_metadata_path = a
Tianjie Xu1b079832019-08-28 12:19:23 -07001252 elif o == "--disable_fec_computation":
1253 OPTIONS.disable_fec_computation = True
Kelvin Zhangcaf7bbc2020-11-20 14:09:42 -05001254 elif o == "--disable_verity_computation":
1255 OPTIONS.disable_verity_computation = True
Yifan Hong65afc072020-04-17 10:08:10 -07001256 elif o == "--force_non_ab":
1257 OPTIONS.force_non_ab = True
Tianjied6867162020-05-10 14:30:13 -07001258 elif o == "--boot_variable_file":
1259 OPTIONS.boot_variable_file = a
Yifan Hong38ab4d82020-06-18 15:19:56 -07001260 elif o == "--partial":
Kelvin Zhanga10528c2023-01-03 15:14:53 -08001261 if a:
1262 partitions = a.split()
1263 if not partitions:
1264 raise ValueError("Cannot parse partitions in {}".format(a))
1265 else:
1266 partitions = []
Yifan Hong38ab4d82020-06-18 15:19:56 -07001267 OPTIONS.partial = partitions
Hongguang Chen49ab1b902020-10-19 14:15:43 -07001268 elif o == "--custom_image":
1269 custom_partition, custom_image = a.split("=")
1270 OPTIONS.custom_images[custom_partition] = custom_image
Kelvin Zhangbbfa1822021-02-03 17:19:44 -05001271 elif o == "--disable_vabc":
1272 OPTIONS.disable_vabc = True
Kelvin Zhang80ff4662021-02-08 19:57:57 -05001273 elif o == "--spl_downgrade":
1274 OPTIONS.spl_downgrade = True
Kelvin Zhang06400172021-03-05 15:42:03 -05001275 OPTIONS.wipe_user_data = True
Kelvin Zhang2a3e5b12021-05-04 18:20:34 -04001276 elif o == "--vabc_downgrade":
1277 OPTIONS.vabc_downgrade = True
Kelvin Zhangf66caee2021-07-12 09:44:20 -04001278 elif o == "--enable_vabc_xor":
Kelvin Zhangf2728d62022-01-10 11:42:36 -08001279 assert a.lower() in ["true", "false"]
Kelvin Zhang1250bca2021-08-27 15:10:27 -07001280 OPTIONS.enable_vabc_xor = a.lower() != "false"
Tianjiee7ab38d2021-09-08 19:09:38 -07001281 elif o == "--force_minor_version":
1282 OPTIONS.force_minor_version = a
Kelvin Zhang9b6d4ec2021-10-28 09:34:31 -07001283 elif o == "--compressor_types":
1284 OPTIONS.compressor_types = a
Kelvin Zhang410bb382022-01-06 09:15:54 -08001285 elif o == "--enable_zucchini":
Kelvin Zhangf2728d62022-01-10 11:42:36 -08001286 assert a.lower() in ["true", "false"]
Kelvin Zhang410bb382022-01-06 09:15:54 -08001287 OPTIONS.enable_zucchini = a.lower() != "false"
Kelvin Zhang456c6d92023-08-01 09:52:00 -07001288 elif o == "--enable_puffdiff":
1289 assert a.lower() in ["true", "false"]
1290 OPTIONS.enable_puffdiff = a.lower() != "false"
Kelvin Zhangf2728d62022-01-10 11:42:36 -08001291 elif o == "--enable_lz4diff":
1292 assert a.lower() in ["true", "false"]
1293 OPTIONS.enable_lz4diff = a.lower() != "false"
Kelvin Zhang84b3a282022-03-04 12:26:20 -08001294 elif o == "--vabc_compression_param":
Daniel Zheng74955f82023-08-03 15:46:13 -07001295 words = a.split(",")
1296 assert len(words) >= 1 and len(words) <= 2
Kelvin Zhang84b3a282022-03-04 12:26:20 -08001297 OPTIONS.vabc_compression_param = a.lower()
Daniel Zheng74955f82023-08-03 15:46:13 -07001298 if len(words) == 2:
Daniel Zhengd9191002023-08-14 17:15:34 -07001299 if not words[1].lstrip("-").isdigit():
Daniel Zheng74955f82023-08-03 15:46:13 -07001300 raise ValueError("Cannot parse value %r for option $COMPRESSION_LEVEL - only "
Kelvin Zhang0fda6292023-09-26 16:07:26 -07001301 "integers are allowed." % words[1])
Kelvin Zhang0b7207c2022-08-26 17:49:08 +00001302 elif o == "--security_patch_level":
1303 OPTIONS.security_patch_level = a
Daniel Zhenga30989b2023-04-25 12:41:44 -07001304 elif o in ("--max_threads"):
1305 if a.isdigit():
1306 OPTIONS.max_threads = a
1307 else:
1308 raise ValueError("Cannot parse value %r for option %r - only "
1309 "integers are allowed." % (a, o))
Daniel Zhenga567eae2024-01-08 14:20:49 -08001310 elif o in ("--compression_factor"):
Daniel Zhengcedc7652024-02-21 13:32:16 -08001311 values = ["4k", "8k", "16k", "32k", "64k", "128k", "256k"]
Daniel Zhenga567eae2024-01-08 14:20:49 -08001312 if a[:-1].isdigit() and a in values and a.endswith("k"):
1313 OPTIONS.compression_factor = str(int(a[:-1]) * 1024)
1314 else:
Daniel Zhengcedc7652024-02-21 13:32:16 -08001315 raise ValueError("Please specify value from following options: 4k, 8k, 16k, 32k, 64k, 128k", "256k")
Daniel Zhenga567eae2024-01-08 14:20:49 -08001316
Kelvin Zhang8793a722023-12-07 13:19:47 -08001317 elif o == "--vabc_cow_version":
1318 if a.isdigit():
1319 OPTIONS.vabc_cow_version = a
1320 else:
1321 raise ValueError("Cannot parse value %r for option %r - only "
1322 "integers are allowed." % (a, o))
Doug Zongkereef39442009-04-02 12:14:19 -07001323 else:
1324 return False
Doug Zongkerdbfaae52009-04-21 17:12:54 -07001325 return True
Doug Zongkereef39442009-04-02 12:14:19 -07001326
1327 args = common.ParseOptions(argv, __doc__,
Kelvin Zhang4b588cf2021-11-09 08:42:11 -08001328 extra_opts="b:k:i:d:e:t:2o:",
1329 extra_long_opts=[
Kelvin Zhang4b588cf2021-11-09 08:42:11 -08001330 "incremental_from=",
1331 "full_radio",
1332 "full_bootloader",
1333 "wipe_user_data",
1334 "downgrade",
1335 "override_timestamp",
1336 "extra_script=",
1337 "worker_threads=",
1338 "two_step",
1339 "include_secondary",
1340 "no_signing",
1341 "block",
1342 "binary=",
1343 "oem_settings=",
1344 "oem_no_mount",
1345 "verify",
1346 "stash_threshold=",
1347 "log_diff=",
Kelvin Zhang4b588cf2021-11-09 08:42:11 -08001348 "extracted_input_target_files=",
1349 "skip_postinstall",
1350 "retrofit_dynamic_partitions",
1351 "skip_compatibility_check",
1352 "output_metadata_path=",
1353 "disable_fec_computation",
1354 "disable_verity_computation",
1355 "force_non_ab",
1356 "boot_variable_file=",
1357 "partial=",
1358 "custom_image=",
1359 "disable_vabc",
1360 "spl_downgrade",
1361 "vabc_downgrade",
1362 "enable_vabc_xor=",
1363 "force_minor_version=",
1364 "compressor_types=",
Kelvin Zhang318a4642022-03-08 15:13:01 -08001365 "enable_zucchini=",
Kelvin Zhang456c6d92023-08-01 09:52:00 -07001366 "enable_puffdiff=",
Kelvin Zhangf2728d62022-01-10 11:42:36 -08001367 "enable_lz4diff=",
Kelvin Zhang84b3a282022-03-04 12:26:20 -08001368 "vabc_compression_param=",
Kelvin Zhang0b7207c2022-08-26 17:49:08 +00001369 "security_patch_level=",
Daniel Zhenga30989b2023-04-25 12:41:44 -07001370 "max_threads=",
Kelvin Zhang8793a722023-12-07 13:19:47 -08001371 "vabc_cow_version=",
Daniel Zhenga567eae2024-01-08 14:20:49 -08001372 "compression_factor=",
Kelvin Zhang68252b82023-11-14 10:58:02 -08001373 ], extra_option_handler=[option_handler, payload_signer.signer_options])
Kelvin Zhanga10528c2023-01-03 15:14:53 -08001374 common.InitLogging()
Doug Zongkereef39442009-04-02 12:14:19 -07001375
1376 if len(args) != 2:
1377 common.Usage(__doc__)
1378 sys.exit(1)
1379
Tao Bao2db13852018-01-08 22:28:57 -08001380 # Load the build info dicts from the zip directly or the extracted input
1381 # directory. We don't need to unzip the entire target-files zips, because they
1382 # won't be needed for A/B OTAs (brillo_update_payload does that on its own).
1383 # When loading the info dicts, we don't need to provide the second parameter
1384 # to common.LoadInfoDict(). Specifying the second parameter allows replacing
1385 # some properties with their actual paths, such as 'selinux_fc',
1386 # 'ramdisk_dir', which won't be used during OTA generation.
Dan Willemsencea5cd22017-03-21 14:44:27 -07001387 if OPTIONS.extracted_input is not None:
Tao Bao2db13852018-01-08 22:28:57 -08001388 OPTIONS.info_dict = common.LoadInfoDict(OPTIONS.extracted_input)
Dan Willemsencea5cd22017-03-21 14:44:27 -07001389 else:
Kelvin Zhang9dbe2ce2023-04-17 16:38:08 -07001390 OPTIONS.info_dict = common.LoadInfoDict(args[0])
Kelvin Zhang80195722020-11-04 14:38:34 -05001391
Kelvin Zhang2a3e5b12021-05-04 18:20:34 -04001392 if OPTIONS.wipe_user_data:
1393 if not OPTIONS.vabc_downgrade:
1394 logger.info("Detected downgrade/datawipe OTA."
1395 "When wiping userdata, VABC OTA makes the user "
1396 "wait in recovery mode for merge to finish. Disable VABC by "
1397 "default. If you really want to do VABC downgrade, pass "
1398 "--vabc_downgrade")
1399 OPTIONS.disable_vabc = True
Kelvin Zhang80195722020-11-04 14:38:34 -05001400 # We should only allow downgrading incrementals (as opposed to full).
1401 # Otherwise the device may go back from arbitrary build with this full
1402 # OTA package.
Kelvin Zhang81641af2021-10-26 16:03:25 -07001403 if OPTIONS.incremental_source is None and OPTIONS.downgrade:
1404 raise ValueError("Cannot generate downgradable full OTAs")
Kelvin Zhang80195722020-11-04 14:38:34 -05001405
Yifan Hong38ab4d82020-06-18 15:19:56 -07001406 # TODO(xunchang) for retrofit and partial updates, maybe we should rebuild the
1407 # target-file and reload the info_dict. So the info will be consistent with
1408 # the modified target-file.
1409
Tao Bao32fcdab2018-10-12 10:30:39 -07001410 logger.info("--- target info ---")
1411 common.DumpInfoDict(OPTIONS.info_dict)
Tao Bao2db13852018-01-08 22:28:57 -08001412
1413 # Load the source build dict if applicable.
1414 if OPTIONS.incremental_source is not None:
1415 OPTIONS.target_info_dict = OPTIONS.info_dict
Kelvin Zhanga59bb272020-10-30 12:52:25 -04001416 OPTIONS.source_info_dict = ParseInfoDict(OPTIONS.incremental_source)
Tao Bao2db13852018-01-08 22:28:57 -08001417
Tao Bao32fcdab2018-10-12 10:30:39 -07001418 logger.info("--- source info ---")
1419 common.DumpInfoDict(OPTIONS.source_info_dict)
Tao Bao2db13852018-01-08 22:28:57 -08001420
Kelvin Zhang83ea7832020-11-11 13:07:10 -05001421 if OPTIONS.partial:
1422 OPTIONS.info_dict['ab_partitions'] = \
Kelvin Zhang06400172021-03-05 15:42:03 -05001423 list(
1424 set(OPTIONS.info_dict['ab_partitions']) & set(OPTIONS.partial)
1425 )
Kelvin Zhang83ea7832020-11-11 13:07:10 -05001426 if OPTIONS.source_info_dict:
1427 OPTIONS.source_info_dict['ab_partitions'] = \
Kelvin Zhang06400172021-03-05 15:42:03 -05001428 list(
1429 set(OPTIONS.source_info_dict['ab_partitions']) &
1430 set(OPTIONS.partial)
1431 )
Kelvin Zhang83ea7832020-11-11 13:07:10 -05001432
Tao Bao2db13852018-01-08 22:28:57 -08001433 # Load OEM dicts if provided.
Tao Bao481bab82017-12-21 11:23:09 -08001434 OPTIONS.oem_dicts = _LoadOemDicts(OPTIONS.oem_source)
1435
Yifan Hong50e79542018-11-08 17:44:12 -08001436 # Assume retrofitting dynamic partitions when base build does not set
Yifan Hong50611032018-11-20 14:27:38 -08001437 # use_dynamic_partitions but target build does.
Yifan Hong50e79542018-11-08 17:44:12 -08001438 if (OPTIONS.source_info_dict and
Yifan Hong50611032018-11-20 14:27:38 -08001439 OPTIONS.source_info_dict.get("use_dynamic_partitions") != "true" and
Kelvin Zhang06400172021-03-05 15:42:03 -05001440 OPTIONS.target_info_dict.get("use_dynamic_partitions") == "true"):
Yifan Hong50e79542018-11-08 17:44:12 -08001441 if OPTIONS.target_info_dict.get("dynamic_partition_retrofit") != "true":
1442 raise common.ExternalError(
1443 "Expect to generate incremental OTA for retrofitting dynamic "
1444 "partitions, but dynamic_partition_retrofit is not set in target "
1445 "build.")
1446 logger.info("Implicitly generating retrofit incremental OTA.")
1447 OPTIONS.retrofit_dynamic_partitions = True
1448
1449 # Skip postinstall for retrofitting dynamic partitions.
1450 if OPTIONS.retrofit_dynamic_partitions:
1451 OPTIONS.skip_postinstall = True
1452
Tao Baoc098e9e2016-01-07 13:03:56 -08001453 ab_update = OPTIONS.info_dict.get("ab_update") == "true"
Yifan Hong65afc072020-04-17 10:08:10 -07001454 allow_non_ab = OPTIONS.info_dict.get("allow_non_ab") == "true"
1455 if OPTIONS.force_non_ab:
Kelvin Zhang22c687c2021-01-21 10:51:57 -05001456 assert allow_non_ab,\
Kelvin Zhang06400172021-03-05 15:42:03 -05001457 "--force_non_ab only allowed on devices that supports non-A/B"
Yifan Hong65afc072020-04-17 10:08:10 -07001458 assert ab_update, "--force_non_ab only allowed on A/B devices"
1459
1460 generate_ab = not OPTIONS.force_non_ab and ab_update
Tao Baoc098e9e2016-01-07 13:03:56 -08001461
Christian Oderf63e2cd2017-05-01 22:30:15 +02001462 # Use the default key to sign the package if not specified with package_key.
1463 # package_keys are needed on ab_updates, so always define them if an
Yifan Hong65afc072020-04-17 10:08:10 -07001464 # A/B update is getting created.
1465 if not OPTIONS.no_signing or generate_ab:
Christian Oderf63e2cd2017-05-01 22:30:15 +02001466 if OPTIONS.package_key is None:
1467 OPTIONS.package_key = OPTIONS.info_dict.get(
1468 "default_system_dev_certificate",
Dan Willemsen0ab1be62019-04-09 21:35:37 -07001469 "build/make/target/product/security/testkey")
Christian Oderf63e2cd2017-05-01 22:30:15 +02001470 # Get signing keys
1471 OPTIONS.key_passwords = common.GetKeyPasswords([OPTIONS.package_key])
Kelvin Zhang4b588cf2021-11-09 08:42:11 -08001472
1473 # Only check for existence of key file if using the default signer.
1474 # Because the custom signer might not need the key file AT all.
1475 # b/191704641
Kelvin Zhang4fc3aa02021-11-16 18:58:58 -08001476 if not OPTIONS.payload_signer:
Kelvin Zhang4b588cf2021-11-09 08:42:11 -08001477 private_key_path = OPTIONS.package_key + OPTIONS.private_key_suffix
1478 if not os.path.exists(private_key_path):
1479 raise common.ExternalError(
1480 "Private key {} doesn't exist. Make sure you passed the"
1481 " correct key path through -k option".format(
1482 private_key_path)
1483 )
Kelvin Zhang4fc3aa02021-11-16 18:58:58 -08001484 signapk_abs_path = os.path.join(
1485 OPTIONS.search_path, OPTIONS.signapk_path)
1486 if not os.path.exists(signapk_abs_path):
1487 raise common.ExternalError(
1488 "Failed to find sign apk binary {} in search path {}. Make sure the correct search path is passed via -p".format(OPTIONS.signapk_path, OPTIONS.search_path))
Christian Oderf63e2cd2017-05-01 22:30:15 +02001489
Kelvin Zhang80ff4662021-02-08 19:57:57 -05001490 if OPTIONS.source_info_dict:
1491 source_build_prop = OPTIONS.source_info_dict["build.prop"]
1492 target_build_prop = OPTIONS.target_info_dict["build.prop"]
1493 source_spl = source_build_prop.GetProp(SECURITY_PATCH_LEVEL_PROP_NAME)
1494 target_spl = target_build_prop.GetProp(SECURITY_PATCH_LEVEL_PROP_NAME)
Kelvin Zhang05ff7052021-02-10 09:13:26 -05001495 is_spl_downgrade = target_spl < source_spl
Kelvin Zhang3d05f682023-02-24 10:50:53 -08001496 if is_spl_downgrade and target_build_prop.GetProp("ro.build.tags") == "release-keys":
1497 raise common.ExternalError(
1498 "Target security patch level {} is older than source SPL {} "
1499 "A locked bootloader will reject SPL downgrade no matter "
1500 "what(even if data wipe is done), so SPL downgrade on any "
1501 "release-keys build is not allowed.".format(target_spl, source_spl))
1502
Kelvin Zhangfcd731e2023-04-04 10:28:11 -07001503 logger.info("SPL downgrade on %s",
1504 target_build_prop.GetProp("ro.build.tags"))
Kelvin Zhang06400172021-03-05 15:42:03 -05001505 if is_spl_downgrade and not OPTIONS.spl_downgrade and not OPTIONS.downgrade:
Kelvin Zhang80ff4662021-02-08 19:57:57 -05001506 raise common.ExternalError(
Kelvin Zhang06400172021-03-05 15:42:03 -05001507 "Target security patch level {} is older than source SPL {} applying "
1508 "such OTA will likely cause device fail to boot. Pass --spl_downgrade "
1509 "to override this check. This script expects security patch level to "
1510 "be in format yyyy-mm-dd (e.x. 2021-02-05). It's possible to use "
1511 "separators other than -, so as long as it's used consistenly across "
1512 "all SPL dates".format(target_spl, source_spl))
Kelvin Zhang05ff7052021-02-10 09:13:26 -05001513 elif not is_spl_downgrade and OPTIONS.spl_downgrade:
1514 raise ValueError("--spl_downgrade specified but no actual SPL downgrade"
1515 " detected. Please only pass in this flag if you want a"
1516 " SPL downgrade. Target SPL: {} Source SPL: {}"
1517 .format(target_spl, source_spl))
Yifan Hong65afc072020-04-17 10:08:10 -07001518 if generate_ab:
Tao Baof0c4aa22018-04-30 20:29:30 -07001519 GenerateAbOtaPackage(
Tao Baoc098e9e2016-01-07 13:03:56 -08001520 target_file=args[0],
1521 output_file=args[1],
1522 source_file=OPTIONS.incremental_source)
1523
Dan Willemsencea5cd22017-03-21 14:44:27 -07001524 else:
Tao Baof0c4aa22018-04-30 20:29:30 -07001525 GenerateNonAbOtaPackage(
1526 target_file=args[0],
1527 output_file=args[1],
1528 source_file=OPTIONS.incremental_source)
Doug Zongkerfdd8e692009-08-03 17:27:48 -07001529
Tao Baof0c4aa22018-04-30 20:29:30 -07001530 # Post OTA generation works.
1531 if OPTIONS.incremental_source is not None and OPTIONS.log_diff:
1532 logger.info("Generating diff logs...")
1533 logger.info("Unzipping target-files for diffing...")
1534 target_dir = common.UnzipTemp(args[0], TARGET_DIFFING_UNZIP_PATTERN)
1535 source_dir = common.UnzipTemp(
1536 OPTIONS.incremental_source, TARGET_DIFFING_UNZIP_PATTERN)
Doug Zongkereb0a78a2014-01-27 10:01:06 -08001537
Tao Baof0c4aa22018-04-30 20:29:30 -07001538 with open(OPTIONS.log_diff, 'w') as out_file:
Tao Baof0c4aa22018-04-30 20:29:30 -07001539 target_files_diff.recursiveDiff(
1540 '', source_dir, target_dir, out_file)
Doug Zongker62d4f182014-08-04 16:06:43 -07001541
Tao Bao32fcdab2018-10-12 10:30:39 -07001542 logger.info("done.")
Doug Zongkereef39442009-04-02 12:14:19 -07001543
1544
1545if __name__ == '__main__':
1546 try:
Ying Wang7e6d4e42010-12-13 16:25:36 -08001547 common.CloseInheritedPipes()
Doug Zongkereef39442009-04-02 12:14:19 -07001548 main(sys.argv[1:])
Doug Zongkerfc44a512014-08-26 13:10:25 -07001549 finally:
1550 common.Cleanup()