From 7169f754cc4b806c54a049b838355483575c1785 Mon Sep 17 00:00:00 2001 From: Yifan Hong Date: Fri, 17 Apr 2020 10:08:10 -0700 Subject: [PATCH 1/2] Support forcefully generating non-AB packages. Force generate a non-A/B update package when requested. Bug: 154344887 Test: ota_from_target_files.py --force_non_ab ... Test: apply it as well Change-Id: I5e81eb161722e07ef50081b6a16685cbc9963ae2 --- core/Makefile | 20 ++++++++++------ core/board_config.mk | 24 ++++++++++++++++--- core/product.mk | 7 ++++++ target/product/virtual_ab_ota_plus_non_ab.mk | 21 ++++++++++++++++ tools/releasetools/blockimgdiff.py | 1 + tools/releasetools/common.py | 12 +++++++--- tools/releasetools/ota_from_target_files.py | 25 ++++++++++++++++---- 7 files changed, 93 insertions(+), 17 deletions(-) create mode 100644 target/product/virtual_ab_ota_plus_non_ab.mk diff --git a/core/Makefile b/core/Makefile index 6809d24f6c..d13d5cbd1c 100644 --- a/core/Makefile +++ b/core/Makefile @@ -3349,10 +3349,10 @@ endif # When building a standalone recovery image for non-A/B devices, recovery image must be self-signed # to be verified independently, and cannot be chained into vbmeta.img. See the link below for # details. -ifneq ($(AB_OTA_UPDATER),true) +ifeq ($(TARGET_OTA_ALLOW_NON_AB),true) ifneq ($(INSTALLED_RECOVERYIMAGE_TARGET),) $(if $(BOARD_AVB_RECOVERY_KEY_PATH),,\ - $(error BOARD_AVB_RECOVERY_KEY_PATH must be defined for non-A/B devices. \ + $(error BOARD_AVB_RECOVERY_KEY_PATH must be defined for if non-A/B is supported. \ See https://android.googlesource.com/platform/external/avb/+/master/README.md#booting-into-recovery)) endif endif @@ -3443,7 +3443,7 @@ $(eval $(_signing_args) := \ # The recovery partition in non-A/B devices should be verified separately. Skip adding the chain # partition descriptor for recovery partition into vbmeta.img. -$(if $(or $(filter true,$(AB_OTA_UPDATER)),$(filter-out recovery,$(part))),\ +$(if $(or $(filter-out true,$(TARGET_OTA_ALLOW_NON_AB)),$(filter-out recovery,$(part))),\ $(eval INTERNAL_AVB_MAKE_VBMETA_IMAGE_ARGS += \ --chain_partition $(part):$($(_rollback_index_location)):$(AVB_CHAIN_KEY_DIR)/$(part).avbpubkey)) @@ -4235,6 +4235,9 @@ ifeq ($(AB_OTA_UPDATER),true) $(hide) echo "build_type=$(TARGET_BUILD_VARIANT)" >> $@ $(hide) echo "ab_update=true" >> $@ endif +ifeq ($(TARGET_OTA_ALLOW_NON_AB),true) + $(hide) echo "allow_non_ab=true" >> $@ +endif ifdef BOARD_PREBUILT_DTBOIMAGE $(hide) echo "has_dtbo=true" >> $@ ifeq ($(BOARD_AVB_ENABLE),true) @@ -4312,10 +4315,13 @@ $(BUILT_TARGET_FILES_PACKAGE): PRIVATE_TOOL_EXTENSION := $(tool_extension) ifeq ($(AB_OTA_UPDATER),true) updater_dep := system/update_engine/update_engine.conf -else -# Build OTA tools if not using the AB Updater. +endif + +# Build OTA tools if non-A/B is allowed +ifeq ($(TARGET_OTA_ALLOW_NON_AB),true) updater_dep := $(built_ota_tools) endif + $(BUILT_TARGET_FILES_PACKAGE): $(updater_dep) # If we are using recovery as boot, output recovery files to BOOT/. @@ -4591,7 +4597,7 @@ endif @# Extra contents of the OTA package $(hide) mkdir -p $(zip_root)/OTA $(hide) cp $(INSTALLED_ANDROID_INFO_TXT_TARGET) $(zip_root)/OTA/ -ifneq ($(AB_OTA_UPDATER),true) +ifeq ($(TARGET_OTA_ALLOW_NON_AB),true) ifneq ($(built_ota_tools),) $(hide) mkdir -p $(zip_root)/OTA/bin $(hide) cp $(PRIVATE_OTA_TOOLS) $(zip_root)/OTA/bin/ @@ -4628,7 +4634,7 @@ ifneq ($(PRODUCT_ODM_BASE_FS_PATH),) $(hide) cp $(PRODUCT_ODM_BASE_FS_PATH) \ $(zip_root)/META/$(notdir $(PRODUCT_ODM_BASE_FS_PATH)) endif -ifneq ($(AB_OTA_UPDATER),true) +ifeq ($(TARGET_OTA_ALLOW_NON_AB),true) ifneq ($(INSTALLED_RECOVERYIMAGE_TARGET),) $(hide) PATH=$(INTERNAL_USERIMAGES_BINARY_PATHS):$$PATH MKBOOTIMG=$(MKBOOTIMG) \ $(MAKE_RECOVERY_PATCH) $(zip_root) $(zip_root) diff --git a/core/board_config.mk b/core/board_config.mk index a329cb1f25..86162b6f37 100644 --- a/core/board_config.mk +++ b/core/board_config.mk @@ -549,13 +549,31 @@ endif .KATI_READONLY := BUILDING_ODM_IMAGE ########################################### -# Ensure that only TARGET_RECOVERY_UPDATER_LIBS *or* AB_OTA_UPDATER is set. +# Ensure consistency among TARGET_RECOVERY_UPDATER_LIBS, AB_OTA_UPDATER, and PRODUCT_OTA_FORCE_NON_AB_PACKAGE. TARGET_RECOVERY_UPDATER_LIBS ?= AB_OTA_UPDATER ?= .KATI_READONLY := TARGET_RECOVERY_UPDATER_LIBS AB_OTA_UPDATER -ifeq ($(AB_OTA_UPDATER),true) + +# Ensure that if PRODUCT_OTA_FORCE_NON_AB_PACKAGE == true, then AB_OTA_UPDATER must be true +ifeq ($(PRODUCT_OTA_FORCE_NON_AB_PACKAGE),true) + ifneq ($(AB_OTA_UPDATER),true) + $(error AB_OTA_UPDATER must be set to true when PRODUCT_OTA_FORCE_NON_AB_PACKAGE is true) + endif +endif + +# In some configurations, A/B and non-A/B may coexist. Check TARGET_OTA_ALLOW_NON_AB +# to see if non-A/B is supported. +TARGET_OTA_ALLOW_NON_AB := false +ifneq ($(AB_OTA_UPDATER),true) + TARGET_OTA_ALLOW_NON_AB := true +else ifeq ($(PRODUCT_OTA_FORCE_NON_AB_PACKAGE),true) + TARGET_OTA_ALLOW_NON_AB := true +endif +.KATI_READONLY := TARGET_OTA_ALLOW_NON_AB + +ifneq ($(TARGET_OTA_ALLOW_NON_AB),true) ifneq ($(strip $(TARGET_RECOVERY_UPDATER_LIBS)),) - $(error Do not use TARGET_RECOVERY_UPDATER_LIBS when using AB_OTA_UPDATER) + $(error Do not use TARGET_RECOVERY_UPDATER_LIBS when using TARGET_OTA_ALLOW_NON_AB) endif endif diff --git a/core/product.mk b/core/product.mk index ea9be72a81..0aa07ef5b7 100644 --- a/core/product.mk +++ b/core/product.mk @@ -393,6 +393,13 @@ _product_single_value_vars += PRODUCT_VIRTUAL_AB_OTA # If set, device retrofits virtual A/B. _product_single_value_vars += PRODUCT_VIRTUAL_AB_OTA_RETROFIT +# If set, forcefully generate a non-A/B update package. +# Note: A device configuration should inherit from virtual_ab_ota_plus_non_ab.mk +# instead of setting this variable directly. +# Note: Use TARGET_OTA_ALLOW_NON_AB in the build system because +# TARGET_OTA_ALLOW_NON_AB takes the value of AB_OTA_UPDATER into account. +_product_single_value_vars += PRODUCT_OTA_FORCE_NON_AB_PACKAGE + # If set, Java module in product partition cannot use hidden APIs. _product_single_value_vars += PRODUCT_ENFORCE_PRODUCT_PARTITION_INTERFACE diff --git a/target/product/virtual_ab_ota_plus_non_ab.mk b/target/product/virtual_ab_ota_plus_non_ab.mk new file mode 100644 index 0000000000..325d75e3e7 --- /dev/null +++ b/target/product/virtual_ab_ota_plus_non_ab.mk @@ -0,0 +1,21 @@ +# +# Copyright (C) 2020 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. +# + +$(call inherit-product, $(SRC_TARGET_DIR)/product/virtual_ab_ota.mk) + +PRODUCT_OTA_FORCE_NON_AB_PACKAGE := true + +PRODUCT_PROPERTY_OVERRIDES += ro.virtual_ab.allow_non_ab=true diff --git a/tools/releasetools/blockimgdiff.py b/tools/releasetools/blockimgdiff.py index 72f065d19d..8b6a6900d5 100644 --- a/tools/releasetools/blockimgdiff.py +++ b/tools/releasetools/blockimgdiff.py @@ -1558,6 +1558,7 @@ class BlockImageDiff(object): split_large_apks = [] cache_size = common.OPTIONS.cache_size split_threshold = 0.125 + assert cache_size is not None max_blocks_per_transfer = int(cache_size * split_threshold / self.tgt.blocksize) empty = RangeSet() diff --git a/tools/releasetools/common.py b/tools/releasetools/common.py index 536d47f59f..7eb976d97b 100644 --- a/tools/releasetools/common.py +++ b/tools/releasetools/common.py @@ -702,12 +702,13 @@ def LoadDictionaryFromLines(lines): def LoadRecoveryFSTab(read_helper, fstab_version, recovery_fstab_path, system_root_image=False): class Partition(object): - def __init__(self, mount_point, fs_type, device, length, context): + def __init__(self, mount_point, fs_type, device, length, context, slotselect): self.mount_point = mount_point self.fs_type = fs_type self.device = device self.length = length self.context = context + self.slotselect = slotselect try: data = read_helper(recovery_fstab_path) @@ -735,10 +736,13 @@ def LoadRecoveryFSTab(read_helper, fstab_version, recovery_fstab_path, # It's a good line, parse it. length = 0 + slotselect = False options = options.split(",") for i in options: if i.startswith("length="): length = int(i[7:]) + elif i == "slotselect": + slotselect = True else: # Ignore all unknown options in the unified fstab. continue @@ -752,7 +756,8 @@ def LoadRecoveryFSTab(read_helper, fstab_version, recovery_fstab_path, mount_point = pieces[1] d[mount_point] = Partition(mount_point=mount_point, fs_type=pieces[2], - device=pieces[0], length=length, context=context) + device=pieces[0], length=length, context=context, + slotselect=slotselect) # / is used for the system mount point when the root directory is included in # system. Other areas assume system is always at "/system" so point /system @@ -767,7 +772,8 @@ def _FindAndLoadRecoveryFstab(info_dict, input_file, read_helper): """Finds the path to recovery fstab and loads its contents.""" # recovery fstab is only meaningful when installing an update via recovery # (i.e. non-A/B OTA). Skip loading fstab if device used A/B OTA. - if info_dict.get('ab_update') == 'true': + if info_dict.get('ab_update') == 'true' and \ + info_dict.get("allow_non_ab") != "true": return None # We changed recovery.fstab path in Q, from ../RAMDISK/etc/recovery.fstab to diff --git a/tools/releasetools/ota_from_target_files.py b/tools/releasetools/ota_from_target_files.py index 2126d11825..7ef367d531 100755 --- a/tools/releasetools/ota_from_target_files.py +++ b/tools/releasetools/ota_from_target_files.py @@ -78,6 +78,13 @@ Common options that apply to both of non-A/B and A/B OTAs Write a copy of the metadata to a separate file. Therefore, users can read the post build fingerprint without extracting the OTA package. + --force_non_ab + This flag can only be set on an A/B device that also supports non-A/B + updates. Implies --two_step. + If set, generate that non-A/B update package. + If not set, generates A/B package for A/B device and non-A/B package for + non-A/B device. + Non-A/B OTA specific options -b (--binary) @@ -247,6 +254,7 @@ OPTIONS.retrofit_dynamic_partitions = False OPTIONS.skip_compatibility_check = False OPTIONS.output_metadata_path = None OPTIONS.disable_fec_computation = False +OPTIONS.force_non_ab = False METADATA_NAME = 'META-INF/com/android/metadata' @@ -928,7 +936,7 @@ def GetPackageMetadata(target_info, source_info=None): 'ro.build.version.security_patch'), } - if target_info.is_ab: + if target_info.is_ab and not OPTIONS.force_non_ab: metadata['ota-type'] = 'AB' metadata['ota-required-cache'] = '0' else: @@ -2032,6 +2040,8 @@ def main(argv): OPTIONS.output_metadata_path = a elif o == "--disable_fec_computation": OPTIONS.disable_fec_computation = True + elif o == "--force_non_ab": + OPTIONS.force_non_ab = True else: return False return True @@ -2068,6 +2078,7 @@ def main(argv): "skip_compatibility_check", "output_metadata_path=", "disable_fec_computation", + "force_non_ab", ], extra_option_handler=option_handler) if len(args) != 2: @@ -2129,11 +2140,17 @@ def main(argv): OPTIONS.skip_postinstall = True ab_update = OPTIONS.info_dict.get("ab_update") == "true" + allow_non_ab = OPTIONS.info_dict.get("allow_non_ab") == "true" + if OPTIONS.force_non_ab: + assert allow_non_ab, "--force_non_ab only allowed on devices that supports non-A/B" + assert ab_update, "--force_non_ab only allowed on A/B devices" + + generate_ab = not OPTIONS.force_non_ab and ab_update # Use the default key to sign the package if not specified with package_key. # package_keys are needed on ab_updates, so always define them if an - # ab_update is getting created. - if not OPTIONS.no_signing or ab_update: + # A/B update is getting created. + if not OPTIONS.no_signing or generate_ab: if OPTIONS.package_key is None: OPTIONS.package_key = OPTIONS.info_dict.get( "default_system_dev_certificate", @@ -2141,7 +2158,7 @@ def main(argv): # Get signing keys OPTIONS.key_passwords = common.GetKeyPasswords([OPTIONS.package_key]) - if ab_update: + if generate_ab: GenerateAbOtaPackage( target_file=args[0], output_file=args[1], From ae6e0d5d28f1480dce42d702cf6fe7460bf5dd4c Mon Sep 17 00:00:00 2001 From: Yifan Hong Date: Thu, 7 May 2020 12:38:53 -0700 Subject: [PATCH 2/2] Use add_slot_suffix function in edify script Whenever a device is retrieved from fstab, wrap it with add_slot_suffix() if it has slotselect option. Test: change fstab (changes boot image, which is a static partition), change system partition (a dynamic partition), generate incremental OTA with --force_non_ab and apply it on cuttlefish Bug: 153581609 Change-Id: Id3f8e4425b65176baf1b0ff1ee07ab3d820a3a7f --- tools/releasetools/common.py | 58 ++++++++-- tools/releasetools/edify_generator.py | 118 ++++++++++++++++---- tools/releasetools/ota_from_target_files.py | 24 ++-- 3 files changed, 158 insertions(+), 42 deletions(-) diff --git a/tools/releasetools/common.py b/tools/releasetools/common.py index 7eb976d97b..dec72ecc38 100644 --- a/tools/releasetools/common.py +++ b/tools/releasetools/common.py @@ -2493,11 +2493,12 @@ class BlockDifference(object): self.device = 'map_partition("%s")' % partition else: if OPTIONS.source_info_dict is None: - _, device_path = GetTypeAndDevice("/" + partition, OPTIONS.info_dict) + _, device_expr = GetTypeAndDeviceExpr("/" + partition, + OPTIONS.info_dict) else: - _, device_path = GetTypeAndDevice("/" + partition, - OPTIONS.source_info_dict) - self.device = '"%s"' % device_path + _, device_expr = GetTypeAndDeviceExpr("/" + partition, + OPTIONS.source_info_dict) + self.device = device_expr @property def required_cache(self): @@ -2729,16 +2730,51 @@ PARTITION_TYPES = { "squashfs": "EMMC" } - -def GetTypeAndDevice(mount_point, info): +def GetTypeAndDevice(mount_point, info, check_no_slot=True): + """ + Use GetTypeAndDeviceExpr whenever possible. This function is kept for + backwards compatibility. It aborts if the fstab entry has slotselect option + (unless check_no_slot is explicitly set to False). + """ fstab = info["fstab"] if fstab: + if check_no_slot: + assert not fstab[mount_point].slotselect, \ + "Use GetTypeAndDeviceExpr instead" return (PARTITION_TYPES[fstab[mount_point].fs_type], fstab[mount_point].device) else: raise KeyError +def GetTypeAndDeviceExpr(mount_point, info): + """ + Return the filesystem of the partition, and an edify expression that evaluates + to the device at runtime. + """ + fstab = info["fstab"] + if fstab: + p = fstab[mount_point] + device_expr = '"%s"' % fstab[mount_point].device + if p.slotselect: + device_expr = 'add_slot_suffix(%s)' % device_expr + return (PARTITION_TYPES[fstab[mount_point].fs_type], device_expr) + else: + raise KeyError + + +def GetEntryForDevice(fstab, device): + """ + Returns: + The first entry in fstab whose device is the given value. + """ + if not fstab: + return None + for mount_point in fstab: + if fstab[mount_point].device == device: + return fstab[mount_point] + return None + def ParseCertificate(data): """Parses and converts a PEM-encoded certificate into DER-encoded. @@ -2863,8 +2899,10 @@ def MakeRecoveryPatch(input_dir, output_sink, recovery_img, boot_img, try: # The following GetTypeAndDevice()s need to use the path in the target # info_dict instead of source_info_dict. - boot_type, boot_device = GetTypeAndDevice("/boot", info_dict) - recovery_type, recovery_device = GetTypeAndDevice("/recovery", info_dict) + boot_type, boot_device = GetTypeAndDevice("/boot", info_dict, + check_no_slot=False) + recovery_type, recovery_device = GetTypeAndDevice("/recovery", info_dict, + check_no_slot=False) except KeyError: return @@ -2906,8 +2944,8 @@ fi 'recovery_size': recovery_img.size, 'recovery_sha1': recovery_img.sha1, 'boot_type': boot_type, - 'boot_device': boot_device, - 'recovery_type': recovery_type, + 'boot_device': boot_device + '$(getprop ro.boot.slot_suffix)', + 'recovery_type': recovery_type + '$(getprop ro.boot.slot_suffix)', 'recovery_device': recovery_device, 'bonus_args': bonus_args} diff --git a/tools/releasetools/edify_generator.py b/tools/releasetools/edify_generator.py index 7ed85fecc9..99e21f1c04 100644 --- a/tools/releasetools/edify_generator.py +++ b/tools/releasetools/edify_generator.py @@ -183,11 +183,30 @@ class EdifyGenerator(object): It checks the checksums of the given partitions. If none of them matches the expected checksum, updater will additionally look for a backup on /cache. """ + self._CheckSecondTokenNotSlotSuffixed(target, "PatchPartitionExprCheck") + self._CheckSecondTokenNotSlotSuffixed(source, "PatchPartitionExprCheck") + self.PatchPartitionExprCheck('"%s"' % target, '"%s"' % source) + + def PatchPartitionExprCheck(self, target_expr, source_expr): + """Checks whether updater can patch the given partitions. + + It checks the checksums of the given partitions. If none of them matches the + expected checksum, updater will additionally look for a backup on /cache. + + Args: + target_expr: an Edify expression that serves as the target arg to + patch_partition. Must be evaluated to a string in the form of + foo:bar:baz:quux + source_expr: an Edify expression that serves as the source arg to + patch_partition. Must be evaluated to a string in the form of + foo:bar:baz:quux + """ self.script.append(self.WordWrap(( - 'patch_partition_check("{target}",\0"{source}") ||\n abort(' - '"E{code}: \\"{target}\\" or \\"{source}\\" has unexpected ' - 'contents.");').format( - target=target, source=source, + 'patch_partition_check({target},\0{source}) ||\n abort(' + 'concat("E{code}: \\"",{target},"\\" or \\"",{source},"\\" has ' + 'unexpected contents."));').format( + target=target_expr, + source=source_expr, code=common.ErrorCode.BAD_PATCH_FILE))) def CacheFreeSpaceCheck(self, amount): @@ -218,8 +237,9 @@ class EdifyGenerator(object): mount_flags = mount_dict.get(p.fs_type, "") if p.context is not None: mount_flags = p.context + ("," + mount_flags if mount_flags else "") - self.script.append('mount("%s", "%s", "%s", "%s", "%s");' % ( - p.fs_type, common.PARTITION_TYPES[p.fs_type], p.device, + self.script.append('mount("%s", "%s", %s, "%s", "%s");' % ( + p.fs_type, common.PARTITION_TYPES[p.fs_type], + self._GetSlotSuffixDeviceForEntry(p), p.mount_point, mount_flags)) self.mounts.add(p.mount_point) @@ -242,8 +262,9 @@ class EdifyGenerator(object): raise ValueError("Partition %s cannot be tuned\n" % (partition,)) self.script.append( 'tune2fs(' + "".join(['"%s", ' % (i,) for i in options]) + - '"%s") || abort("E%d: Failed to tune partition %s");' % ( - p.device, common.ErrorCode.TUNE_PARTITION_FAILURE, partition)) + '%s) || abort("E%d: Failed to tune partition %s");' % ( + self._GetSlotSuffixDeviceForEntry(p), + common.ErrorCode.TUNE_PARTITION_FAILURE, partition)) def FormatPartition(self, partition): """Format the given partition, specified by its mount point (eg, @@ -252,18 +273,19 @@ class EdifyGenerator(object): fstab = self.fstab if fstab: p = fstab[partition] - self.script.append('format("%s", "%s", "%s", "%s", "%s");' % + self.script.append('format("%s", "%s", %s, "%s", "%s");' % (p.fs_type, common.PARTITION_TYPES[p.fs_type], - p.device, p.length, p.mount_point)) + self._GetSlotSuffixDeviceForEntry(p), + p.length, p.mount_point)) def WipeBlockDevice(self, partition): if partition not in ("/system", "/vendor"): raise ValueError(("WipeBlockDevice doesn't work on %s\n") % (partition,)) fstab = self.fstab size = self.info.get(partition.lstrip("/") + "_size", None) - device = fstab[partition].device + device = self._GetSlotSuffixDeviceForEntry(fstab[partition]) - self.script.append('wipe_block_device("%s", %s);' % (device, size)) + self.script.append('wipe_block_device(%s, %s);' % (device, size)) def ApplyPatch(self, srcfile, tgtfile, tgtsize, tgtsha1, *patchpairs): """Apply binary patches (in *patchpairs) to the given srcfile to @@ -296,14 +318,69 @@ class EdifyGenerator(object): self.PatchPartition(target, source, patch) def PatchPartition(self, target, source, patch): - """Applies the patch to the source partition and writes it to target.""" + """ + Applies the patch to the source partition and writes it to target. + + Args: + target: the target arg to patch_partition. Must be in the form of + foo:bar:baz:quux + source: the source arg to patch_partition. Must be in the form of + foo:bar:baz:quux + patch: the patch arg to patch_partition. Must be an unquoted string. + """ + self._CheckSecondTokenNotSlotSuffixed(target, "PatchPartitionExpr") + self._CheckSecondTokenNotSlotSuffixed(source, "PatchPartitionExpr") + self.PatchPartitionExpr('"%s"' % target, '"%s"' % source, '"%s"' % patch) + + def PatchPartitionExpr(self, target_expr, source_expr, patch_expr): + """ + Applies the patch to the source partition and writes it to target. + + Args: + target_expr: an Edify expression that serves as the target arg to + patch_partition. Must be evaluated to a string in the form of + foo:bar:baz:quux + source_expr: an Edify expression that serves as the source arg to + patch_partition. Must be evaluated to a string in the form of + foo:bar:baz:quux + patch_expr: an Edify expression that serves as the patch arg to + patch_partition. Must be evaluated to a string. + """ self.script.append(self.WordWrap(( - 'patch_partition("{target}",\0"{source}",\0' - 'package_extract_file("{patch}")) ||\n' - ' abort("E{code}: Failed to apply patch to {source}");').format( - target=target, source=source, patch=patch, + 'patch_partition({target},\0{source},\0' + 'package_extract_file({patch})) ||\n' + ' abort(concat(' + ' "E{code}: Failed to apply patch to ",{source}));').format( + target=target_expr, + source=source_expr, + patch=patch_expr, code=common.ErrorCode.APPLY_PATCH_FAILURE))) + def _GetSlotSuffixDeviceForEntry(self, entry=None): + """ + Args: + entry: the fstab entry of device "foo" + Returns: + An edify expression. Caller must not quote result. + If foo is slot suffixed, it returns + 'add_slot_suffix("foo")' + Otherwise it returns + '"foo"' (quoted) + """ + assert entry is not None + if entry.slotselect: + return 'add_slot_suffix("%s")' % entry.device + return '"%s"' % entry.device + + def _CheckSecondTokenNotSlotSuffixed(self, s, fn): + lst = s.split(':') + assert(len(s) == 4), "{} does not contain 4 tokens".format(s) + if self.fstab: + entry = common.GetEntryForDevice(s[1]) + if entry is not None: + assert not entry.slotselect, \ + "Use %s because %s is slot suffixed" % (fn, s[1]) + def WriteRawImage(self, mount_point, fn, mapfn=None): """Write the given package file into the partition for the given mount point.""" @@ -312,15 +389,16 @@ class EdifyGenerator(object): if fstab: p = fstab[mount_point] partition_type = common.PARTITION_TYPES[p.fs_type] - args = {'device': p.device, 'fn': fn} + device = self._GetSlotSuffixDeviceForEntry(p) + args = {'device': device, 'fn': fn} if partition_type == "EMMC": if mapfn: args["map"] = mapfn self.script.append( - 'package_extract_file("%(fn)s", "%(device)s", "%(map)s");' % args) + 'package_extract_file("%(fn)s", %(device)s, "%(map)s");' % args) else: self.script.append( - 'package_extract_file("%(fn)s", "%(device)s");' % args) + 'package_extract_file("%(fn)s", %(device)s);' % args) else: raise ValueError( "don't know how to write \"%s\" partitions" % p.fs_type) diff --git a/tools/releasetools/ota_from_target_files.py b/tools/releasetools/ota_from_target_files.py index 7ef367d531..d8b3c7dedf 100755 --- a/tools/releasetools/ota_from_target_files.py +++ b/tools/releasetools/ota_from_target_files.py @@ -1458,7 +1458,8 @@ else if get_stage("%(bcb_dev)s") != "3/3" then required_cache_sizes = [diff.required_cache for diff in block_diff_dict.values()] if updating_boot: - boot_type, boot_device = common.GetTypeAndDevice("/boot", source_info) + boot_type, boot_device_expr = common.GetTypeAndDeviceExpr("/boot", + source_info) d = common.Difference(target_boot, source_boot) _, _, d = d.ComputePatch() if d is None: @@ -1473,11 +1474,11 @@ else if get_stage("%(bcb_dev)s") != "3/3" then common.ZipWriteStr(output_zip, "boot.img.p", d) - script.PatchPartitionCheck( - "{}:{}:{}:{}".format( - boot_type, boot_device, target_boot.size, target_boot.sha1), - "{}:{}:{}:{}".format( - boot_type, boot_device, source_boot.size, source_boot.sha1)) + target_expr = 'concat("{}:",{},":{}:{}")'.format( + boot_type, boot_device_expr, target_boot.size, target_boot.sha1) + source_expr = 'concat("{}:",{},":{}:{}")'.format( + boot_type, boot_device_expr, source_boot.size, source_boot.sha1) + script.PatchPartitionExprCheck(target_expr, source_expr) required_cache_sizes.append(target_boot.size) @@ -1545,12 +1546,11 @@ else logger.info("boot image changed; including patch.") script.Print("Patching boot image...") script.ShowProgress(0.1, 10) - script.PatchPartition( - '{}:{}:{}:{}'.format( - boot_type, boot_device, target_boot.size, target_boot.sha1), - '{}:{}:{}:{}'.format( - boot_type, boot_device, source_boot.size, source_boot.sha1), - 'boot.img.p') + target_expr = 'concat("{}:",{},":{}:{}")'.format( + boot_type, boot_device_expr, target_boot.size, target_boot.sha1) + source_expr = 'concat("{}:",{},":{}:{}")'.format( + boot_type, boot_device_expr, source_boot.size, source_boot.sha1) + script.PatchPartitionExpr(target_expr, source_expr, '"boot.img.p"') else: logger.info("boot image unchanged; skipping.")