Merge changes from topic "libsnapshot_prep" (233c32a4) · Commits · e / os / android_system_core

fs_mgr/libsnapshot/Android.bp

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -49,6 +49,7 @@ filegroup {
	name: "libsnapshot_sources",		name: "libsnapshot_sources",
	srcs: [		srcs: [
	"snapshot.cpp",		"snapshot.cpp",
			"utility.cpp",
	],		],
	}		}

fs_mgr/libsnapshot/include/libsnapshot/snapshot.h

+38 −27

Original line number	Original line	Diff line number	Diff line
	@@ -211,25 +211,44 @@ class SnapshotManager final {
	std::unique_ptr<LockedFile> OpenFile(const std::string& file, int open_flags, int lock_flags);		std::unique_ptr<LockedFile> OpenFile(const std::string& file, int open_flags, int lock_flags);
	bool Truncate(LockedFile* file);		bool Truncate(LockedFile* file);

			enum class SnapshotState : int { None, Created, Merging, MergeCompleted };
			static std::string to_string(SnapshotState state);

			// This state is persisted per-snapshot in /metadata/ota/snapshots/.
			struct SnapshotStatus {
			SnapshotState state = SnapshotState::None;
			uint64_t device_size = 0;
			uint64_t snapshot_size = 0;
			uint64_t cow_partition_size = 0;
			uint64_t cow_file_size = 0;

			// These are non-zero when merging.
			uint64_t sectors_allocated = 0;
			uint64_t metadata_sectors = 0;
			};

	// Create a new snapshot record. This creates the backing COW store and		// Create a new snapshot record. This creates the backing COW store and
	// persists information needed to map the device. The device can be mapped		// persists information needed to map the device. The device can be mapped
	// with MapSnapshot().		// with MapSnapshot().
	//		//
	// \|device_size\| should be the size of the base_device that will be passed		// \|status\|.device_size should be the size of the base_device that will be passed
	// via MapDevice(). \|snapshot_size\| should be the number of bytes in the		// via MapDevice(). \|status\|.snapshot_size should be the number of bytes in the
	// base device, starting from 0, that will be snapshotted. The cow_size		// base device, starting from 0, that will be snapshotted. \|status\|.cow_file_size
	// should be the amount of space that will be allocated to store snapshot		// should be the amount of space that will be allocated to store snapshot
	// deltas.		// deltas.
	//		//
	// If \|snapshot_size\| < device_size, then the device will always		// If \|status\|.snapshot_size < \|status\|.device_size, then the device will always
	// be mapped with two table entries: a dm-snapshot range covering		// be mapped with two table entries: a dm-snapshot range covering
	// snapshot_size, and a dm-linear range covering the remainder.		// snapshot_size, and a dm-linear range covering the remainder.
	//		//
	// All sizes are specified in bytes, and the device and snapshot sizes		// All sizes are specified in bytes, and the device, snapshot and COW partition sizes
	// must be a multiple of the sector size (512 bytes). \|cow_size\| will		// must be a multiple of the sector size (512 bytes). COW file size will be rounded up
	// be rounded up to the nearest sector.		// to the nearest sector.
	bool CreateSnapshot(LockedFile* lock, const std::string& name, uint64_t device_size,		bool CreateSnapshot(LockedFile* lock, const std::string& name, SnapshotStatus status);
	uint64_t snapshot_size, uint64_t cow_size);
			// \|name\| should be the base partition name (e.g. "system_a"). Create the
			// backing COW image using the size previously passed to CreateSnapshot().
			bool CreateCowImage(LockedFile* lock, const std::string& name);

	// Map a snapshot device that was previously created with CreateSnapshot.		// Map a snapshot device that was previously created with CreateSnapshot.
	// If a merge was previously initiated, the device-mapper table will have a		// If a merge was previously initiated, the device-mapper table will have a
	@@ -239,15 +258,23 @@ class SnapshotManager final {
	// timeout_ms is 0, then no wait will occur and \|dev_path\| may not yet		// timeout_ms is 0, then no wait will occur and \|dev_path\| may not yet
	// exist on return.		// exist on return.
	bool MapSnapshot(LockedFile* lock, const std::string& name, const std::string& base_device,		bool MapSnapshot(LockedFile* lock, const std::string& name, const std::string& base_device,
	const std::chrono::milliseconds& timeout_ms, std::string* dev_path);		const std::string& cow_device, const std::chrono::milliseconds& timeout_ms,
			std::string* dev_path);

			// Map a COW image that was previous created with CreateCowImage.
			bool MapCowImage(const std::string& name, const std::chrono::milliseconds& timeout_ms,
			std::string* cow_image_device);

	// Remove the backing copy-on-write image for the named snapshot. The		// Remove the backing copy-on-write image and snapshot states for the named snapshot. The
	// caller is responsible for ensuring that the snapshot is unmapped.		// caller is responsible for ensuring that the snapshot is unmapped.
	bool DeleteSnapshot(LockedFile* lock, const std::string& name);		bool DeleteSnapshot(LockedFile* lock, const std::string& name);

	// Unmap a snapshot device previously mapped with MapSnapshotDevice().		// Unmap a snapshot device previously mapped with MapSnapshotDevice().
	bool UnmapSnapshot(LockedFile* lock, const std::string& name);		bool UnmapSnapshot(LockedFile* lock, const std::string& name);

			// Unmap a COW image device previously mapped with MapCowImage().
			bool UnmapCowImage(const std::string& name);

	// Unmap and remove all known snapshots.		// Unmap and remove all known snapshots.
	bool RemoveAllSnapshots(LockedFile* lock);		bool RemoveAllSnapshots(LockedFile* lock);

	@@ -270,22 +297,6 @@ class SnapshotManager final {
	bool WriteUpdateState(LockedFile* file, UpdateState state);		bool WriteUpdateState(LockedFile* file, UpdateState state);
	std::string GetStateFilePath() const;		std::string GetStateFilePath() const;

	enum class SnapshotState : int { Created, Merging, MergeCompleted };
	static std::string to_string(SnapshotState state);

	// This state is persisted per-snapshot in /metadata/ota/snapshots/.
	struct SnapshotStatus {
	SnapshotState state;
	uint64_t device_size;
	uint64_t snapshot_size;
	uint64_t cow_partition_size;
	uint64_t cow_file_size;

	// These are non-zero when merging.
	uint64_t sectors_allocated = 0;
	uint64_t metadata_sectors = 0;
	};

	// Helpers for merging.		// Helpers for merging.
	bool SwitchSnapshotToMerge(LockedFile* lock, const std::string& name);		bool SwitchSnapshotToMerge(LockedFile* lock, const std::string& name);
	bool RewriteSnapshotDeviceTable(const std::string& dm_name);		bool RewriteSnapshotDeviceTable(const std::string& dm_name);

fs_mgr/libsnapshot/snapshot.cpp

+137 −57

Original line number	Original line	Diff line number	Diff line
	@@ -36,6 +36,8 @@
	#include <libfiemap/image_manager.h>		#include <libfiemap/image_manager.h>
	#include <liblp/liblp.h>		#include <liblp/liblp.h>

			#include "utility.h"

	namespace android {		namespace android {
	namespace snapshot {		namespace snapshot {

	@@ -54,6 +56,7 @@ using android::fs_mgr::CreateLogicalPartitionParams;
	using android::fs_mgr::GetPartitionName;		using android::fs_mgr::GetPartitionName;
	using android::fs_mgr::LpMetadata;		using android::fs_mgr::LpMetadata;
	using android::fs_mgr::SlotNumberForSlotSuffix;		using android::fs_mgr::SlotNumberForSlotSuffix;
			using std::chrono::duration_cast;
	using namespace std::chrono_literals;		using namespace std::chrono_literals;
	using namespace std::string_literals;		using namespace std::string_literals;

	@@ -99,10 +102,14 @@ SnapshotManager::SnapshotManager(IDeviceInfo* device) : device_(device) {
	metadata_dir_ = device_->GetMetadataDir();		metadata_dir_ = device_->GetMetadataDir();
	}		}

	static std::string GetCowName(const std::string& snapshot_name) {		[[maybe_unused]] static std::string GetCowName(const std::string& snapshot_name) {
	return snapshot_name + "-cow";		return snapshot_name + "-cow";
	}		}

			static std::string GetCowImageDeviceName(const std::string& snapshot_name) {
			return snapshot_name + "-cow-img";
			}

	static std::string GetBaseDeviceName(const std::string& partition_name) {		static std::string GetBaseDeviceName(const std::string& partition_name) {
	return partition_name + "-base";		return partition_name + "-base";
	}		}
	@@ -177,49 +184,60 @@ bool SnapshotManager::FinishedSnapshotWrites() {
	}		}

	bool SnapshotManager::CreateSnapshot(LockedFile* lock, const std::string& name,		bool SnapshotManager::CreateSnapshot(LockedFile* lock, const std::string& name,
	uint64_t device_size, uint64_t snapshot_size,		SnapshotManager::SnapshotStatus status) {
	uint64_t cow_size) {
	CHECK(lock);		CHECK(lock);
	if (!EnsureImageManager()) return false;		CHECK(lock->lock_mode() == LOCK_EX);

	// Sanity check these sizes. Like liblp, we guarantee the partition size		// Sanity check these sizes. Like liblp, we guarantee the partition size
	// is respected, which means it has to be sector-aligned. (This guarantee		// is respected, which means it has to be sector-aligned. (This guarantee
	// is useful for locating avb footers correctly). The COW size, however,		// is useful for locating avb footers correctly). The COW size, however,
	// can be arbitrarily larger than specified, so we can safely round it up.		// can be arbitrarily larger than specified, so we can safely round it up.
	if (device_size % kSectorSize != 0) {		if (status.device_size % kSectorSize != 0) {
	LOG(ERROR) << "Snapshot " << name		LOG(ERROR) << "Snapshot " << name
	<< " device size is not a multiple of the sector size: " << device_size;		<< " device size is not a multiple of the sector size: " << status.device_size;
	return false;		return false;
	}		}
	if (snapshot_size % kSectorSize != 0) {		if (status.snapshot_size % kSectorSize != 0) {
	LOG(ERROR) << "Snapshot " << name		LOG(ERROR) << "Snapshot " << name << " snapshot size is not a multiple of the sector size: "
	<< " snapshot size is not a multiple of the sector size: " << snapshot_size;		<< status.snapshot_size;
	return false;		return false;
	}		}

	// Round the COW size up to the nearest sector.		// Round the COW size up to the nearest sector.
	cow_size += kSectorSize - 1;		status.cow_file_size += kSectorSize - 1;
	cow_size &= ~(kSectorSize - 1);		status.cow_file_size &= ~(kSectorSize - 1);

	LOG(INFO) << "Snapshot " << name << " will have COW size " << cow_size;		status.state = SnapshotState::Created;
			status.sectors_allocated = 0;
	// Note, we leave the status file hanging around if we fail to create the		status.metadata_sectors = 0;
	// actual backing image. This is harmless, since it'll get removed when
	// CancelUpdate is called.
	SnapshotStatus status = {
	.state = SnapshotState::Created,
	.device_size = device_size,
	.snapshot_size = snapshot_size,
	.cow_file_size = cow_size,
	};
	if (!WriteSnapshotStatus(lock, name, status)) {		if (!WriteSnapshotStatus(lock, name, status)) {
	PLOG(ERROR) << "Could not write snapshot status: " << name;		PLOG(ERROR) << "Could not write snapshot status: " << name;
	return false;		return false;
	}		}
			return true;
			}

			bool SnapshotManager::CreateCowImage(LockedFile* lock, const std::string& name) {
			CHECK(lock);
			CHECK(lock->lock_mode() == LOCK_EX);
			if (!EnsureImageManager()) return false;

			SnapshotStatus status;
			if (!ReadSnapshotStatus(lock, name, &status)) {
			return false;
			}

	auto cow_name = GetCowName(name);		// The COW file size should have been rounded up to the nearest sector in CreateSnapshot.
			// Sanity check this.
			if (status.cow_file_size % kSectorSize != 0) {
			LOG(ERROR) << "Snapshot " << name << " COW file size is not a multiple of the sector size: "
			<< status.cow_file_size;
			return false;
			}

			std::string cow_image_name = GetCowImageDeviceName(name);
	int cow_flags = IImageManager::CREATE_IMAGE_DEFAULT;		int cow_flags = IImageManager::CREATE_IMAGE_DEFAULT;
	if (!images_->CreateBackingImage(cow_name, cow_size, cow_flags)) {		if (!images_->CreateBackingImage(cow_image_name, status.cow_file_size, cow_flags)) {
	return false;		return false;
	}		}

	@@ -238,11 +256,11 @@ bool SnapshotManager::CreateSnapshot(LockedFile* lock, const std::string& name,
	// workaround that will be discussed again when the kernel API gets		// workaround that will be discussed again when the kernel API gets
	// consolidated.		// consolidated.
	ssize_t dm_snap_magic_size = 4; // 32 bit		ssize_t dm_snap_magic_size = 4; // 32 bit
	return images_->ZeroFillNewImage(cow_name, dm_snap_magic_size);		return images_->ZeroFillNewImage(cow_image_name, dm_snap_magic_size);
	}		}

	bool SnapshotManager::MapSnapshot(LockedFile* lock, const std::string& name,		bool SnapshotManager::MapSnapshot(LockedFile* lock, const std::string& name,
	const std::string& base_device,		const std::string& base_device, const std::string& cow_device,
	const std::chrono::milliseconds& timeout_ms,		const std::chrono::milliseconds& timeout_ms,
	std::string* dev_path) {		std::string* dev_path) {
	CHECK(lock);		CHECK(lock);
	@@ -288,22 +306,7 @@ bool SnapshotManager::MapSnapshot(LockedFile* lock, const std::string& name,
	uint64_t snapshot_sectors = status.snapshot_size / kSectorSize;		uint64_t snapshot_sectors = status.snapshot_size / kSectorSize;
	uint64_t linear_sectors = (status.device_size - status.snapshot_size) / kSectorSize;		uint64_t linear_sectors = (status.device_size - status.snapshot_size) / kSectorSize;

	auto cow_name = GetCowName(name);

	bool ok;
	std::string cow_dev;
	if (has_local_image_manager_) {
	// If we forced a local image manager, it means we don't have binder,
	// which means first-stage init. We must use device-mapper.
	const auto& opener = device_->GetPartitionOpener();
	ok = images_->MapImageWithDeviceMapper(opener, cow_name, &cow_dev);
	} else {
	ok = images_->MapImageDevice(cow_name, timeout_ms, &cow_dev);
	}
	if (!ok) {
	LOG(ERROR) << "Could not map image device: " << cow_name;
	return false;
	}

	auto& dm = DeviceMapper::Instance();		auto& dm = DeviceMapper::Instance();

	@@ -335,11 +338,10 @@ bool SnapshotManager::MapSnapshot(LockedFile* lock, const std::string& name,
	auto snap_name = (linear_sectors > 0) ? GetSnapshotExtraDeviceName(name) : name;		auto snap_name = (linear_sectors > 0) ? GetSnapshotExtraDeviceName(name) : name;

	DmTable table;		DmTable table;
	table.Emplace<DmTargetSnapshot>(0, snapshot_sectors, base_device, cow_dev, mode,		table.Emplace<DmTargetSnapshot>(0, snapshot_sectors, base_device, cow_device, mode,
	kSnapshotChunkSize);		kSnapshotChunkSize);
	if (!dm.CreateDevice(snap_name, table, dev_path, timeout_ms)) {		if (!dm.CreateDevice(snap_name, table, dev_path, timeout_ms)) {
	LOG(ERROR) << "Could not create snapshot device: " << snap_name;		LOG(ERROR) << "Could not create snapshot device: " << snap_name;
	images_->UnmapImageDevice(cow_name);
	return false;		return false;
	}		}

	@@ -355,7 +357,6 @@ bool SnapshotManager::MapSnapshot(LockedFile* lock, const std::string& name,
	if (!dm.CreateDevice(name, table, dev_path, timeout_ms)) {		if (!dm.CreateDevice(name, table, dev_path, timeout_ms)) {
	LOG(ERROR) << "Could not create outer snapshot device: " << name;		LOG(ERROR) << "Could not create outer snapshot device: " << name;
	dm.DeleteDevice(snap_name);		dm.DeleteDevice(snap_name);
	images_->UnmapImageDevice(cow_name);
	return false;		return false;
	}		}
	}		}
	@@ -366,9 +367,29 @@ bool SnapshotManager::MapSnapshot(LockedFile* lock, const std::string& name,
	return true;		return true;
	}		}

			bool SnapshotManager::MapCowImage(const std::string& name,
			const std::chrono::milliseconds& timeout_ms,
			std::string* cow_dev) {
			if (!EnsureImageManager()) return false;
			auto cow_image_name = GetCowImageDeviceName(name);

			bool ok;
			if (has_local_image_manager_) {
			// If we forced a local image manager, it means we don't have binder,
			// which means first-stage init. We must use device-mapper.
			const auto& opener = device_->GetPartitionOpener();
			ok = images_->MapImageWithDeviceMapper(opener, cow_image_name, cow_dev);
			} else {
			ok = images_->MapImageDevice(cow_image_name, timeout_ms, cow_dev);
			}
			if (!ok) {
			LOG(ERROR) << "Could not map image device: " << cow_image_name;
			}
			return ok;
			}

	bool SnapshotManager::UnmapSnapshot(LockedFile* lock, const std::string& name) {		bool SnapshotManager::UnmapSnapshot(LockedFile* lock, const std::string& name) {
	CHECK(lock);		CHECK(lock);
	if (!EnsureImageManager()) return false;

	SnapshotStatus status;		SnapshotStatus status;
	if (!ReadSnapshotStatus(lock, name, &status)) {		if (!ReadSnapshotStatus(lock, name, &status)) {
	@@ -389,23 +410,25 @@ bool SnapshotManager::UnmapSnapshot(LockedFile* lock, const std::string& name) {
	return false;		return false;
	}		}

	auto cow_name = GetCowName(name);
	if (images_->IsImageMapped(cow_name) && !images_->UnmapImageDevice(cow_name)) {
	return false;
	}
	return true;		return true;
	}		}

			bool SnapshotManager::UnmapCowImage(const std::string& name) {
			if (!EnsureImageManager()) return false;
			return images_->UnmapImageIfExists(GetCowImageDeviceName(name));
			}

	bool SnapshotManager::DeleteSnapshot(LockedFile* lock, const std::string& name) {		bool SnapshotManager::DeleteSnapshot(LockedFile* lock, const std::string& name) {
	CHECK(lock);		CHECK(lock);
			CHECK(lock->lock_mode() == LOCK_EX);
	if (!EnsureImageManager()) return false;		if (!EnsureImageManager()) return false;

	auto cow_name = GetCowName(name);		auto cow_image_name = GetCowImageDeviceName(name);
	if (images_->BackingImageExists(cow_name)) {		if (images_->BackingImageExists(cow_image_name)) {
	if (images_->IsImageMapped(cow_name) && !images_->UnmapImageDevice(cow_name)) {		if (!images_->UnmapImageIfExists(cow_image_name)) {
	return false;		return false;
	}		}
	if (!images_->DeleteBackingImage(cow_name)) {		if (!images_->DeleteBackingImage(cow_image_name)) {
	return false;		return false;
	}		}
	}		}
	@@ -1153,9 +1176,28 @@ bool SnapshotManager::CreateLogicalAndSnapshotPartitions(const std::string& supe
	return true;		return true;
	}		}

			static std::chrono::milliseconds GetRemainingTime(
			const std::chrono::milliseconds& timeout,
			const std::chrono::time_point<std::chrono::steady_clock>& begin) {
			// If no timeout is specified, execute all commands without specifying any timeout.
			if (timeout.count() == 0) return std::chrono::milliseconds(0);
			auto passed_time = std::chrono::steady_clock::now() - begin;
			auto remaining_time = timeout - duration_cast<std::chrono::milliseconds>(passed_time);
			if (remaining_time.count() <= 0) {
			LOG(ERROR) << "MapPartitionWithSnapshot has reached timeout " << timeout.count() << "ms ("
			<< remaining_time.count() << "ms remaining)";
			// Return min() instead of remaining_time here because 0 is treated as a special value for
			// no timeout, where the rest of the commands will still be executed.
			return std::chrono::milliseconds::min();
			}
			return remaining_time;
			}

	bool SnapshotManager::MapPartitionWithSnapshot(LockedFile* lock,		bool SnapshotManager::MapPartitionWithSnapshot(LockedFile* lock,
	CreateLogicalPartitionParams params,		CreateLogicalPartitionParams params,
	std::string* path) {		std::string* path) {
			auto begin = std::chrono::steady_clock::now();

	CHECK(lock);		CHECK(lock);
	path->clear();		path->clear();

	@@ -1207,6 +1249,11 @@ bool SnapshotManager::MapPartitionWithSnapshot(LockedFile* lock,
	params.device_name = GetBaseDeviceName(params.GetPartitionName());		params.device_name = GetBaseDeviceName(params.GetPartitionName());
	}		}

			AutoDeviceList created_devices;

			// Create the base device for the snapshot, or if there is no snapshot, the
			// device itself. This device consists of the real blocks in the super
			// partition that this logical partition occupies.
	auto& dm = DeviceMapper::Instance();		auto& dm = DeviceMapper::Instance();
	std::string ignore_path;		std::string ignore_path;
	if (!CreateLogicalPartition(params, &ignore_path)) {		if (!CreateLogicalPartition(params, &ignore_path)) {
	@@ -1214,7 +1261,10 @@ bool SnapshotManager::MapPartitionWithSnapshot(LockedFile* lock,
	<< " as device " << params.GetDeviceName();		<< " as device " << params.GetDeviceName();
	return false;		return false;
	}		}
			created_devices.EmplaceBack<AutoUnmapDevice>(&dm, params.GetDeviceName());

	if (!live_snapshot_status.has_value()) {		if (!live_snapshot_status.has_value()) {
			created_devices.Release();
	return true;		return true;
	}		}

	@@ -1225,10 +1275,35 @@ bool SnapshotManager::MapPartitionWithSnapshot(LockedFile* lock,
	LOG(ERROR) << "Could not determine major/minor for: " << params.GetDeviceName();		LOG(ERROR) << "Could not determine major/minor for: " << params.GetDeviceName();
	return false;		return false;
	}		}
	if (!MapSnapshot(lock, params.GetPartitionName(), base_device, {}, path)) {
			// If there is a timeout specified, compute the remaining time to call Map* functions.
			// init calls CreateLogicalAndSnapshotPartitions, which has no timeout specified. Still call
			// Map* functions in this case.
			auto remaining_time = GetRemainingTime(params.timeout_ms, begin);
			if (remaining_time.count() < 0) return false;

			std::string cow_image_device;
			if (!MapCowImage(params.GetPartitionName(), remaining_time, &cow_image_device)) {
			LOG(ERROR) << "Could not map cow image for partition: " << params.GetPartitionName();
			return false;
			}
			created_devices.EmplaceBack<AutoUnmapImage>(images_.get(),
			GetCowImageDeviceName(params.partition_name));

			// TODO: map cow linear device here
			std::string cow_device = cow_image_device;

			remaining_time = GetRemainingTime(params.timeout_ms, begin);
			if (remaining_time.count() < 0) return false;

			if (!MapSnapshot(lock, params.GetPartitionName(), base_device, cow_device, remaining_time,
			path)) {
	LOG(ERROR) << "Could not map snapshot for partition: " << params.GetPartitionName();		LOG(ERROR) << "Could not map snapshot for partition: " << params.GetPartitionName();
	return false;		return false;
	}		}
			// No need to add params.GetPartitionName() to created_devices since it is immediately released.

			created_devices.Release();

	LOG(INFO) << "Mapped " << params.GetPartitionName() << " as snapshot device at " << *path;		LOG(INFO) << "Mapped " << params.GetPartitionName() << " as snapshot device at " << *path;

	@@ -1373,7 +1448,9 @@ bool SnapshotManager::ReadSnapshotStatus(LockedFile* lock, const std::string& na
	return false;		return false;
	}		}

	if (pieces[0] == "created") {		if (pieces[0] == "none") {
			status->state = SnapshotState::None;
			} else if (pieces[0] == "created") {
	status->state = SnapshotState::Created;		status->state = SnapshotState::Created;
	} else if (pieces[0] == "merging") {		} else if (pieces[0] == "merging") {
	status->state = SnapshotState::Merging;		status->state = SnapshotState::Merging;
	@@ -1381,6 +1458,7 @@ bool SnapshotManager::ReadSnapshotStatus(LockedFile* lock, const std::string& na
	status->state = SnapshotState::MergeCompleted;		status->state = SnapshotState::MergeCompleted;
	} else {		} else {
	LOG(ERROR) << "Unrecognized state " << pieces[0] << " for snapshot: " << name;		LOG(ERROR) << "Unrecognized state " << pieces[0] << " for snapshot: " << name;
			return false;
	}		}

	if (!android::base::ParseUint(pieces[1], &status->device_size)) {		if (!android::base::ParseUint(pieces[1], &status->device_size)) {
	@@ -1412,6 +1490,8 @@ bool SnapshotManager::ReadSnapshotStatus(LockedFile* lock, const std::string& na

	std::string SnapshotManager::to_string(SnapshotState state) {		std::string SnapshotManager::to_string(SnapshotState state) {
	switch (state) {		switch (state) {
			case SnapshotState::None:
			return "none";
	case SnapshotState::Created:		case SnapshotState::Created:
	return "created";		return "created";
	case SnapshotState::Merging:		case SnapshotState::Merging:

fs_mgr/libsnapshot/snapshot_test.cpp

+70 −26

File changed.

Preview size limit exceeded, changes collapsed.

fs_mgr/libsnapshot/utility.cpp

0 → 100644

+56 −0

Original line number	Original line	Diff line number	Diff line
			// Copyright (C) 2019 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.

			#include "utility.h"

			#include <android-base/logging.h>
			#include <android-base/strings.h>

			namespace android {
			namespace snapshot {

			void AutoDevice::Release() {
			name_.clear();
			}

			AutoDeviceList::~AutoDeviceList() {
			// Destroy devices in the reverse order because newer devices may have dependencies
			// on older devices.
			for (auto it = devices_.rbegin(); it != devices_.rend(); ++it) {
			it->reset();
			}
			}

			void AutoDeviceList::Release() {
			for (auto&& p : devices_) {
			p->Release();
			}
			}

			AutoUnmapDevice::~AutoUnmapDevice() {
			if (name_.empty()) return;
			if (!dm_->DeleteDeviceIfExists(name_)) {
			LOG(ERROR) << "Failed to auto unmap device " << name_;
			}
			}

			AutoUnmapImage::~AutoUnmapImage() {
			if (name_.empty()) return;
			if (!images_->UnmapImageIfExists(name_)) {
			LOG(ERROR) << "Failed to auto unmap cow image " << name_;
			}
			}

			} // namespace snapshot
			} // namespace android