aosp/dynamic_partition_control_android.h - platform/system/update_engine - Git at Google


            
            //

            
            // Copyright (C) 2018 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.

            
            //


            #ifndef UPDATE_ENGINE_AOSP_DYNAMIC_PARTITION_CONTROL_ANDROID_H_

            
            #define UPDATE_ENGINE_AOSP_DYNAMIC_PARTITION_CONTROL_ANDROID_H_


            #include <memory>

            
            #include <set>

            
            #include <string>

            
            #include <string_view>

            
            #include <vector>


            #include <base/files/file_util.h>

            
            #include <libsnapshot/auto_device.h>

            
            #include <libsnapshot/snapshot.h>

            
            #include <libsnapshot/snapshot_writer.h>


            #include "update_engine/common/dynamic_partition_control_interface.h"


            namespace chromeos_update_engine {


            class DynamicPartitionControlAndroid : public DynamicPartitionControlInterface {

            
             public:

            
              // A directory where all partitions mapped by VABC is expected to be found.

            
              // Per earlier discussion with VAB team, this directory is unlikely to change.

            
              // So we declare it as a constant here.

            
              static constexpr std::string_view VABC_DEVICE_DIR = "/dev/block/mapper/";

            
              explicit DynamicPartitionControlAndroid(uint32_t source_slot);

            
              ~DynamicPartitionControlAndroid();


              FeatureFlag GetDynamicPartitionsFeatureFlag() override;

            
              FeatureFlag GetVirtualAbFeatureFlag() override;

            
              FeatureFlag GetVirtualAbCompressionFeatureFlag() override;

            
              bool OptimizeOperation(const std::string& partition_name,

            
                                     const InstallOperation& operation,

            
                                     InstallOperation* optimized) override;

            
              void Cleanup() override;


              bool PreparePartitionsForUpdate(uint32_t source_slot,

            
                                              uint32_t target_slot,

            
                                              const DeltaArchiveManifest& manifest,

            
                                              bool update,

            
                                              uint64_t* required_size) override;

            
              bool FinishUpdate(bool powerwash_required) override;

            
              std::unique_ptr<AbstractAction> GetCleanupPreviousUpdateAction(

            
                  BootControlInterface* boot_control,

            
                  PrefsInterface* prefs,

            
                  CleanupPreviousUpdateActionDelegateInterface* delegate) override;


              bool ResetUpdate(PrefsInterface* prefs) override;


              bool ListDynamicPartitionsForSlot(

            
                  uint32_t slot,

            
                  uint32_t current_slot,

            
                  std::vector<std::string>* partitions) override;


              bool VerifyExtentsForUntouchedPartitions(

            
                  uint32_t source_slot,

            
                  uint32_t target_slot,

            
                  const std::vector<std::string>& partitions) override;


              bool GetDeviceDir(std::string* path) override;


              // Return the device for partition |partition_name| at slot |slot|.

            
              // |current_slot| should be set to the current active slot.

            
              // Note: this function is only used by BootControl*::GetPartitionDevice.

            
              // Other callers should prefer BootControl*::GetPartitionDevice over

            
              // BootControl*::GetDynamicPartitionControl()->GetPartitionDevice().

            
              std::optional<PartitionDevice> GetPartitionDevice(

            
                  const std::string& partition_name,

            
                  uint32_t slot,

            
                  uint32_t current_slot,

            
                  bool not_in_payload);

            
              // Deprecated, please use GetPartitionDevice(string, uint32_t, uint32_t);

            
              // TODO(zhangkelvin) Remove below deprecated APIs.

            
              bool GetPartitionDevice(const std::string& partition_name,

            
                                      uint32_t slot,

            
                                      uint32_t current_slot,

            
                                      bool not_in_payload,

            
                                      std::string* device,

            
                                      bool* is_dynamic);


              bool GetPartitionDevice(const std::string& partition_name,

            
                                      uint32_t slot,

            
                                      uint32_t current_slot,

            
                                      std::string* device);


              // Partition name is expected to be unsuffixed. e.g. system, vendor

            
              // Return an interface to write to a snapshoted partition.

            
              std::unique_ptr<android::snapshot::ISnapshotWriter> OpenCowWriter(

            
                  const std::string& unsuffixed_partition_name,

            
                  const std::optional<std::string>& source_path,

            
                  bool is_append) override;

            
              std::unique_ptr<FileDescriptor> OpenCowFd(

            
                  const std::string& unsuffixed_partition_name,

            
                  const std::optional<std::string>&,

            
                  bool is_append = false) override;


              bool MapAllPartitions() override;

            
              bool UnmapAllPartitions() override;


              bool IsDynamicPartition(const std::string& part_name, uint32_t slot) override;


              bool UpdateUsesSnapshotCompression() override;


              std::optional<base::FilePath> GetSuperDevice();


             protected:

            
              // These functions are exposed for testing.


              // Unmap logical partition on device mapper. This is the reverse operation

            
              // of MapPartitionOnDeviceMapper.

            
              // Returns true if unmapped successfully.

            
              virtual bool UnmapPartitionOnDeviceMapper(

            
                  const std::string& target_partition_name);


              // Retrieves metadata from |super_device| at slot |slot|.

            
              virtual std::unique_ptr<android::fs_mgr::MetadataBuilder> LoadMetadataBuilder(

            
                  const std::string& super_device, uint32_t slot);


              // Retrieves metadata from |super_device| at slot |source_slot|. And

            
              // modifies the metadata so that during updates, the metadata can be written

            
              // to |target_slot|. In particular, on retrofit devices, the returned

            
              // metadata automatically includes block devices at |target_slot|.

            
              virtual std::unique_ptr<android::fs_mgr::MetadataBuilder> LoadMetadataBuilder(

            
                  const std::string& super_device,

            
                  uint32_t source_slot,

            
                  uint32_t target_slot);


              // Write metadata |builder| to |super_device| at slot |target_slot|.

            
              virtual bool StoreMetadata(const std::string& super_device,

            
                                         android::fs_mgr::MetadataBuilder* builder,

            
                                         uint32_t target_slot);


              // Map logical partition on device-mapper.

            
              // |super_device| is the device path of the physical partition ("super").

            
              // |target_partition_name| is the identifier used in metadata; for example,

            
              // "vendor_a"

            
              // |slot| is the selected slot to mount; for example, 0 for "_a".

            
              // Returns true if mapped successfully; if so, |path| is set to the device

            
              // path of the mapped logical partition.

            
              virtual bool MapPartitionOnDeviceMapper(

            
                  const std::string& super_device,

            
                  const std::string& target_partition_name,

            
                  uint32_t slot,

            
                  bool force_writable,

            
                  std::string* path);


              // Return true if a static partition exists at device path |path|.

            
              virtual bool DeviceExists(const std::string& path);


              // Returns the current state of the underlying device mapper device

            
              // with given name.

            
              // One of INVALID, SUSPENDED or ACTIVE.

            
              virtual android::dm::DmDeviceState GetState(const std::string& name);


              // Returns the path to the device mapper device node in '/dev' corresponding

            
              // to 'name'. If the device does not exist, false is returned, and the path

            
              // parameter is not set.

            
              virtual bool GetDmDevicePathByName(const std::string& name,

            
                                                 std::string* path);


              // Return the name of the super partition (which stores super partition

            
              // metadata) for a given slot.

            
              virtual std::string GetSuperPartitionName(uint32_t slot);


              virtual void set_fake_mapped_devices(const std::set<std::string>& fake);


              // Allow mock objects to override this to test recovery mode.

            
              virtual bool IsRecovery();


              // Determine path for system_other partition.

            
              // |source_slot| should be current slot.

            
              // |target_slot| should be "other" slot.

            
              // |partition_name_suffix| should be "system" + suffix(|target_slot|).

            
              // Return true and set |path| if successful.

            
              // Set |path| to empty if no need to erase system_other.

            
              // Set |should_unmap| to true if path needs to be unmapped later.

            
              //

            
              // Note: system_other cannot use GetPartitionDevice or

            
              // GetDynamicPartitionDevice because:

            
              // - super partition metadata may be loaded from the source slot

            
              // - UPDATED flag needs to be check to skip erasing if partition is not

            
              //   created by flashing tools

            
              // - Snapshots from previous update attempts should not be used.

            
              virtual bool GetSystemOtherPath(uint32_t source_slot,

            
                                              uint32_t target_slot,

            
                                              const std::string& partition_name_suffix,

            
                                              std::string* path,

            
                                              bool* should_unmap);


              // Returns true if any entry in the fstab file in |path| has AVB enabled,

            
              // false if not enabled, and nullopt for any error.

            
              virtual std::optional<bool> IsAvbEnabledInFstab(const std::string& path);


              // Returns true if system_other has AVB enabled, false if not enabled, and

            
              // nullopt for any error.

            
              virtual std::optional<bool> IsAvbEnabledOnSystemOther();


              // Erase system_other partition that may contain system_other.img.

            
              // After the update, the content of system_other may be corrupted but with

            
              // valid AVB footer. If the update is rolled back and factory data reset is

            
              // triggered, system_b fails to be mapped with verity errors (see

            
              // b/152444348). Erase the system_other so that mapping system_other is

            
              // skipped.

            
              virtual bool EraseSystemOtherAvbFooter(uint32_t source_slot,

            
                                                     uint32_t target_slot);


              // Helper for PreparePartitionsForUpdate. Used for devices with dynamic

            
              // partitions updating without snapshots.

            
              // If |delete_source| is set, source partitions are deleted before resizing

            
              // target partitions (using DeleteSourcePartitions).

            
              virtual bool PrepareDynamicPartitionsForUpdate(

            
                  uint32_t source_slot,

            
                  uint32_t target_slot,

            
                  const DeltaArchiveManifest& manifest,

            
                  bool delete_source);


              void SetSourceSlot(uint32_t slot) { source_slot_ = slot; }

            
              void SetTargetSlot(uint32_t slot) { target_slot_ = slot; }


             private:

            
              friend class DynamicPartitionControlAndroidTest;

            
              friend class SnapshotPartitionTestP;


              bool MapPartitionInternal(const std::string& super_device,

            
                                        const std::string& target_partition_name,

            
                                        uint32_t slot,

            
                                        bool force_writable,

            
                                        std::string* path);


              // Update |builder| according to |partition_metadata|.

            
              // - In Android mode, this is only called when the device

            
              //   does not have Virtual A/B.

            
              // - When sideloading, this maybe called as a fallback path if CoW cannot

            
              //   be created.

            
              bool UpdatePartitionMetadata(android::fs_mgr::MetadataBuilder* builder,

            
                                           uint32_t target_slot,

            
                                           const DeltaArchiveManifest& manifest);


              // Helper for PreparePartitionsForUpdate. Used for snapshotted partitions

            
              // for Virtual A/B update.

            
              bool PrepareSnapshotPartitionsForUpdate(uint32_t source_slot,

            
                                                      uint32_t target_slot,

            
                                                      const DeltaArchiveManifest& manifest,

            
                                                      uint64_t* required_size);


              enum SpaceLimit {

            
                // Most restricted: if sum(groups) > super / 2, error

            
                ERROR_IF_EXCEEDED_HALF_OF_SUPER,

            
                // Implies ERROR_IF_EXCEEDED_SUPER; then, if sum(groups) > super / 2, warn

            
                WARN_IF_EXCEEDED_HALF_OF_SUPER,

            
                // Least restricted: if sum(groups) > super, error

            
                ERROR_IF_EXCEEDED_SUPER,

            
              };

            
              // Helper of CheckSuperPartitionAllocatableSpace. Determine limit for groups

            
              // and partitions.

            
              SpaceLimit GetSpaceLimit(bool use_snapshot);


              // Returns true if the allocatable space in super partition is larger than

            
              // the size of dynamic partition groups in the manifest.

            
              bool CheckSuperPartitionAllocatableSpace(

            
                  android::fs_mgr::MetadataBuilder* builder,

            
                  const DeltaArchiveManifest& manifest,

            
                  bool use_snapshot);


              enum class DynamicPartitionDeviceStatus {

            
                SUCCESS,

            
                ERROR,

            
                TRY_STATIC,

            
              };


              // Return SUCCESS and path in |device| if partition is dynamic.

            
              // Return ERROR if any error.

            
              // Return TRY_STATIC if caller should resolve the partition as a static

            
              // partition instead.

            
              DynamicPartitionDeviceStatus GetDynamicPartitionDevice(

            
                  const base::FilePath& device_dir,

            
                  const std::string& partition_name_suffix,

            
                  uint32_t slot,

            
                  uint32_t current_slot,

            
                  bool not_in_payload,

            
                  std::string* device);


              // Return true if |partition_name_suffix| is a block device of

            
              // super partition metadata slot |slot|.

            
              bool IsSuperBlockDevice(const base::FilePath& device_dir,

            
                                      uint32_t current_slot,

            
                                      const std::string& partition_name_suffix);


              // If sideloading a full OTA, delete source partitions from |builder|.

            
              bool DeleteSourcePartitions(android::fs_mgr::MetadataBuilder* builder,

            
                                          uint32_t source_slot,

            
                                          const DeltaArchiveManifest& manifest);


              // Returns true if metadata is expected to be mounted, false otherwise.

            
              // Note that it returns false on non-Virtual A/B devices.

            
              //

            
              // Almost all functions of SnapshotManager depends on metadata being

            
              // mounted.

            
              // - In Android mode for Virtual A/B devices, assume it is mounted. If not,

            
              //   let caller fails when calling into SnapshotManager.

            
              // - In recovery for Virtual A/B devices, it is possible that metadata is

            
              // not

            
              //   formatted, hence it cannot be mounted. Caller should not call into

            
              //   SnapshotManager.

            
              // - On non-Virtual A/B devices, updates do not depend on metadata

            
              // partition.

            
              //   Caller should not call into SnapshotManager.

            
              //

            
              // This function does NOT mount metadata partition. Use

            
              // EnsureMetadataMounted to mount metadata partition.

            
              bool ExpectMetadataMounted();


              // Ensure /metadata is mounted. Returns true if successful, false otherwise.

            
              //

            
              // Note that this function returns true on non-Virtual A/B devices without

            
              // doing anything.

            
              bool EnsureMetadataMounted();


              // Set boolean flags related to target build. This includes flags like

            
              // target_supports_snapshot_ and is_target_dynamic_.

            
              bool SetTargetBuildVars(const DeltaArchiveManifest& manifest);


              std::set<std::string> mapped_devices_;

            
              const FeatureFlag dynamic_partitions_;

            
              const FeatureFlag virtual_ab_;

            
              const FeatureFlag virtual_ab_compression_;

            
              std::unique_ptr<android::snapshot::ISnapshotManager> snapshot_;

            
              std::unique_ptr<android::snapshot::AutoDevice> metadata_device_;

            
              bool target_supports_snapshot_ = false;

            
              // Whether the target partitions should be loaded as dynamic partitions. Set

            
              // by PreparePartitionsForUpdate() per each update.

            
              bool is_target_dynamic_ = false;


              uint32_t source_slot_ = UINT32_MAX;

            
              uint32_t target_slot_ = UINT32_MAX;

            
              std::vector<std::vector<std::string>> dynamic_partition_list_{2UL};


              DISALLOW_COPY_AND_ASSIGN(DynamicPartitionControlAndroid);

            
            };


            }  // namespace chromeos_update_engine


            #endif  // UPDATE_ENGINE_AOSP_DYNAMIC_PARTITION_CONTROL_ANDROID_H_
	//
	// Copyright (C) 2018 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.
	//

	#ifndef UPDATE_ENGINE_AOSP_DYNAMIC_PARTITION_CONTROL_ANDROID_H_
	#define UPDATE_ENGINE_AOSP_DYNAMIC_PARTITION_CONTROL_ANDROID_H_

	#include <memory>
	#include <set>
	#include <string>
	#include <string_view>
	#include <vector>

	#include <base/files/file_util.h>
	#include <libsnapshot/auto_device.h>
	#include <libsnapshot/snapshot.h>
	#include <libsnapshot/snapshot_writer.h>

	#include "update_engine/common/dynamic_partition_control_interface.h"

	namespace chromeos_update_engine {

	class DynamicPartitionControlAndroid : public DynamicPartitionControlInterface {
	public:
	// A directory where all partitions mapped by VABC is expected to be found.
	// Per earlier discussion with VAB team, this directory is unlikely to change.
	// So we declare it as a constant here.
	static constexpr std::string_view VABC_DEVICE_DIR = "/dev/block/mapper/";
	explicit DynamicPartitionControlAndroid(uint32_t source_slot);
	~DynamicPartitionControlAndroid();

	FeatureFlag GetDynamicPartitionsFeatureFlag() override;
	FeatureFlag GetVirtualAbFeatureFlag() override;
	FeatureFlag GetVirtualAbCompressionFeatureFlag() override;
	bool OptimizeOperation(const std::string& partition_name,
	const InstallOperation& operation,
	InstallOperation* optimized) override;
	void Cleanup() override;

	bool PreparePartitionsForUpdate(uint32_t source_slot,
	uint32_t target_slot,
	const DeltaArchiveManifest& manifest,
	bool update,
	uint64_t* required_size) override;
	bool FinishUpdate(bool powerwash_required) override;
	std::unique_ptr<AbstractAction> GetCleanupPreviousUpdateAction(
	BootControlInterface* boot_control,
	PrefsInterface* prefs,
	CleanupPreviousUpdateActionDelegateInterface* delegate) override;

	bool ResetUpdate(PrefsInterface* prefs) override;

	bool ListDynamicPartitionsForSlot(
	uint32_t slot,
	uint32_t current_slot,
	std::vector<std::string>* partitions) override;

	bool VerifyExtentsForUntouchedPartitions(
	uint32_t source_slot,
	uint32_t target_slot,
	const std::vector<std::string>& partitions) override;

	bool GetDeviceDir(std::string* path) override;

	// Return the device for partition \|partition_name\| at slot \|slot\|.
	// \|current_slot\| should be set to the current active slot.
	// Note: this function is only used by BootControl*::GetPartitionDevice.
	// Other callers should prefer BootControl*::GetPartitionDevice over
	// BootControl*::GetDynamicPartitionControl()->GetPartitionDevice().
	std::optional<PartitionDevice> GetPartitionDevice(
	const std::string& partition_name,
	uint32_t slot,
	uint32_t current_slot,
	bool not_in_payload);
	// Deprecated, please use GetPartitionDevice(string, uint32_t, uint32_t);
	// TODO(zhangkelvin) Remove below deprecated APIs.
	bool GetPartitionDevice(const std::string& partition_name,
	uint32_t slot,
	uint32_t current_slot,
	bool not_in_payload,
	std::string* device,
	bool* is_dynamic);

	bool GetPartitionDevice(const std::string& partition_name,
	uint32_t slot,
	uint32_t current_slot,
	std::string* device);

	// Partition name is expected to be unsuffixed. e.g. system, vendor
	// Return an interface to write to a snapshoted partition.
	std::unique_ptr<android::snapshot::ISnapshotWriter> OpenCowWriter(
	const std::string& unsuffixed_partition_name,
	const std::optional<std::string>& source_path,
	bool is_append) override;
	std::unique_ptr<FileDescriptor> OpenCowFd(
	const std::string& unsuffixed_partition_name,
	const std::optional<std::string>&,
	bool is_append = false) override;

	bool MapAllPartitions() override;
	bool UnmapAllPartitions() override;

	bool IsDynamicPartition(const std::string& part_name, uint32_t slot) override;

	bool UpdateUsesSnapshotCompression() override;

	std::optional<base::FilePath> GetSuperDevice();

	protected:
	// These functions are exposed for testing.

	// Unmap logical partition on device mapper. This is the reverse operation
	// of MapPartitionOnDeviceMapper.
	// Returns true if unmapped successfully.
	virtual bool UnmapPartitionOnDeviceMapper(
	const std::string& target_partition_name);

	// Retrieves metadata from \|super_device\| at slot \|slot\|.
	virtual std::unique_ptr<android::fs_mgr::MetadataBuilder> LoadMetadataBuilder(
	const std::string& super_device, uint32_t slot);

	// Retrieves metadata from \|super_device\| at slot \|source_slot\|. And
	// modifies the metadata so that during updates, the metadata can be written
	// to \|target_slot\|. In particular, on retrofit devices, the returned
	// metadata automatically includes block devices at \|target_slot\|.
	virtual std::unique_ptr<android::fs_mgr::MetadataBuilder> LoadMetadataBuilder(
	const std::string& super_device,
	uint32_t source_slot,
	uint32_t target_slot);

	// Write metadata \|builder\| to \|super_device\| at slot \|target_slot\|.
	virtual bool StoreMetadata(const std::string& super_device,
	android::fs_mgr::MetadataBuilder* builder,
	uint32_t target_slot);

	// Map logical partition on device-mapper.
	// \|super_device\| is the device path of the physical partition ("super").
	// \|target_partition_name\| is the identifier used in metadata; for example,
	// "vendor_a"
	// \|slot\| is the selected slot to mount; for example, 0 for "_a".
	// Returns true if mapped successfully; if so, \|path\| is set to the device
	// path of the mapped logical partition.
	virtual bool MapPartitionOnDeviceMapper(
	const std::string& super_device,
	const std::string& target_partition_name,
	uint32_t slot,
	bool force_writable,
	std::string* path);

	// Return true if a static partition exists at device path \|path\|.
	virtual bool DeviceExists(const std::string& path);

	// Returns the current state of the underlying device mapper device
	// with given name.
	// One of INVALID, SUSPENDED or ACTIVE.
	virtual android::dm::DmDeviceState GetState(const std::string& name);

	// Returns the path to the device mapper device node in '/dev' corresponding
	// to 'name'. If the device does not exist, false is returned, and the path
	// parameter is not set.
	virtual bool GetDmDevicePathByName(const std::string& name,
	std::string* path);

	// Return the name of the super partition (which stores super partition
	// metadata) for a given slot.
	virtual std::string GetSuperPartitionName(uint32_t slot);

	virtual void set_fake_mapped_devices(const std::set<std::string>& fake);

	// Allow mock objects to override this to test recovery mode.
	virtual bool IsRecovery();

	// Determine path for system_other partition.
	// \|source_slot\| should be current slot.
	// \|target_slot\| should be "other" slot.
	// \|partition_name_suffix\| should be "system" + suffix(\|target_slot\|).
	// Return true and set \|path\| if successful.
	// Set \|path\| to empty if no need to erase system_other.
	// Set \|should_unmap\| to true if path needs to be unmapped later.
	//
	// Note: system_other cannot use GetPartitionDevice or
	// GetDynamicPartitionDevice because:
	// - super partition metadata may be loaded from the source slot
	// - UPDATED flag needs to be check to skip erasing if partition is not
	// created by flashing tools
	// - Snapshots from previous update attempts should not be used.
	virtual bool GetSystemOtherPath(uint32_t source_slot,
	uint32_t target_slot,
	const std::string& partition_name_suffix,
	std::string* path,
	bool* should_unmap);

	// Returns true if any entry in the fstab file in \|path\| has AVB enabled,
	// false if not enabled, and nullopt for any error.
	virtual std::optional<bool> IsAvbEnabledInFstab(const std::string& path);

	// Returns true if system_other has AVB enabled, false if not enabled, and
	// nullopt for any error.
	virtual std::optional<bool> IsAvbEnabledOnSystemOther();

	// Erase system_other partition that may contain system_other.img.
	// After the update, the content of system_other may be corrupted but with
	// valid AVB footer. If the update is rolled back and factory data reset is
	// triggered, system_b fails to be mapped with verity errors (see
	// b/152444348). Erase the system_other so that mapping system_other is
	// skipped.
	virtual bool EraseSystemOtherAvbFooter(uint32_t source_slot,
	uint32_t target_slot);

	// Helper for PreparePartitionsForUpdate. Used for devices with dynamic
	// partitions updating without snapshots.
	// If \|delete_source\| is set, source partitions are deleted before resizing
	// target partitions (using DeleteSourcePartitions).
	virtual bool PrepareDynamicPartitionsForUpdate(
	uint32_t source_slot,
	uint32_t target_slot,
	const DeltaArchiveManifest& manifest,
	bool delete_source);

	void SetSourceSlot(uint32_t slot) { source_slot_ = slot; }
	void SetTargetSlot(uint32_t slot) { target_slot_ = slot; }

	private:
	friend class DynamicPartitionControlAndroidTest;
	friend class SnapshotPartitionTestP;

	bool MapPartitionInternal(const std::string& super_device,
	const std::string& target_partition_name,
	uint32_t slot,
	bool force_writable,
	std::string* path);

	// Update \|builder\| according to \|partition_metadata\|.
	// - In Android mode, this is only called when the device
	// does not have Virtual A/B.
	// - When sideloading, this maybe called as a fallback path if CoW cannot
	// be created.
	bool UpdatePartitionMetadata(android::fs_mgr::MetadataBuilder* builder,
	uint32_t target_slot,
	const DeltaArchiveManifest& manifest);

	// Helper for PreparePartitionsForUpdate. Used for snapshotted partitions
	// for Virtual A/B update.
	bool PrepareSnapshotPartitionsForUpdate(uint32_t source_slot,
	uint32_t target_slot,
	const DeltaArchiveManifest& manifest,
	uint64_t* required_size);

	enum SpaceLimit {
	// Most restricted: if sum(groups) > super / 2, error
	ERROR_IF_EXCEEDED_HALF_OF_SUPER,
	// Implies ERROR_IF_EXCEEDED_SUPER; then, if sum(groups) > super / 2, warn
	WARN_IF_EXCEEDED_HALF_OF_SUPER,
	// Least restricted: if sum(groups) > super, error
	ERROR_IF_EXCEEDED_SUPER,
	};
	// Helper of CheckSuperPartitionAllocatableSpace. Determine limit for groups
	// and partitions.
	SpaceLimit GetSpaceLimit(bool use_snapshot);

	// Returns true if the allocatable space in super partition is larger than
	// the size of dynamic partition groups in the manifest.
	bool CheckSuperPartitionAllocatableSpace(
	android::fs_mgr::MetadataBuilder* builder,
	const DeltaArchiveManifest& manifest,
	bool use_snapshot);

	enum class DynamicPartitionDeviceStatus {
	SUCCESS,
	ERROR,
	TRY_STATIC,
	};

	// Return SUCCESS and path in \|device\| if partition is dynamic.
	// Return ERROR if any error.
	// Return TRY_STATIC if caller should resolve the partition as a static
	// partition instead.
	DynamicPartitionDeviceStatus GetDynamicPartitionDevice(
	const base::FilePath& device_dir,
	const std::string& partition_name_suffix,
	uint32_t slot,
	uint32_t current_slot,
	bool not_in_payload,
	std::string* device);

	// Return true if \|partition_name_suffix\| is a block device of
	// super partition metadata slot \|slot\|.
	bool IsSuperBlockDevice(const base::FilePath& device_dir,
	uint32_t current_slot,
	const std::string& partition_name_suffix);

	// If sideloading a full OTA, delete source partitions from \|builder\|.
	bool DeleteSourcePartitions(android::fs_mgr::MetadataBuilder* builder,
	uint32_t source_slot,
	const DeltaArchiveManifest& manifest);

	// Returns true if metadata is expected to be mounted, false otherwise.
	// Note that it returns false on non-Virtual A/B devices.
	//
	// Almost all functions of SnapshotManager depends on metadata being
	// mounted.
	// - In Android mode for Virtual A/B devices, assume it is mounted. If not,
	// let caller fails when calling into SnapshotManager.
	// - In recovery for Virtual A/B devices, it is possible that metadata is
	// not
	// formatted, hence it cannot be mounted. Caller should not call into
	// SnapshotManager.
	// - On non-Virtual A/B devices, updates do not depend on metadata
	// partition.
	// Caller should not call into SnapshotManager.
	//
	// This function does NOT mount metadata partition. Use
	// EnsureMetadataMounted to mount metadata partition.
	bool ExpectMetadataMounted();

	// Ensure /metadata is mounted. Returns true if successful, false otherwise.
	//
	// Note that this function returns true on non-Virtual A/B devices without
	// doing anything.
	bool EnsureMetadataMounted();

	// Set boolean flags related to target build. This includes flags like
	// target_supports_snapshot_ and is_target_dynamic_.
	bool SetTargetBuildVars(const DeltaArchiveManifest& manifest);

	std::set<std::string> mapped_devices_;
	const FeatureFlag dynamic_partitions_;
	const FeatureFlag virtual_ab_;
	const FeatureFlag virtual_ab_compression_;
	std::unique_ptr<android::snapshot::ISnapshotManager> snapshot_;
	std::unique_ptr<android::snapshot::AutoDevice> metadata_device_;
	bool target_supports_snapshot_ = false;
	// Whether the target partitions should be loaded as dynamic partitions. Set
	// by PreparePartitionsForUpdate() per each update.
	bool is_target_dynamic_ = false;

	uint32_t source_slot_ = UINT32_MAX;
	uint32_t target_slot_ = UINT32_MAX;
	std::vector<std::vector<std::string>> dynamic_partition_list_{2UL};

	DISALLOW_COPY_AND_ASSIGN(DynamicPartitionControlAndroid);
	};

	} // namespace chromeos_update_engine

	#endif // UPDATE_ENGINE_AOSP_DYNAMIC_PARTITION_CONTROL_ANDROID_H_