payload_consumer/partition_writer.cc - platform/system/update_engine - Git at Google

 //
 // 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.
 //
 #include <update_engine/payload_consumer/partition_writer.h>

 #include <fcntl.h>
 #include <linux/fs.h>
 #include <sys/mman.h>

 #include <inttypes.h>

 #include <algorithm>
 #include <initializer_list>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>

 #include <base/strings/string_number_conversions.h>
 #include <base/strings/string_util.h>
 #include <base/strings/stringprintf.h>

 #include "update_engine/common/terminator.h"
 #include "update_engine/common/utils.h"
 #include "update_engine/payload_consumer/bzip_extent_writer.h"
 #include "update_engine/payload_consumer/cached_file_descriptor.h"
 #include "update_engine/payload_consumer/extent_reader.h"
 #include "update_engine/payload_consumer/extent_writer.h"
 #include "update_engine/payload_consumer/file_descriptor_utils.h"
 #include "update_engine/payload_consumer/install_operation_executor.h"
 #include "update_engine/payload_consumer/install_plan.h"
 #include "update_engine/payload_consumer/mount_history.h"
 #include "update_engine/payload_consumer/payload_constants.h"
 #include "update_engine/payload_consumer/xz_extent_writer.h"
 #include "update_engine/payload_generator/extent_utils.h"

 namespace chromeos_update_engine {

 namespace {
 constexpr uint64_t kCacheSize = 1024 * 1024;  // 1MB

 // Discard the tail of the block device referenced by |fd|, from the offset
 // |data_size| until the end of the block device. Returns whether the data was
 // discarded.

 bool DiscardPartitionTail(const FileDescriptorPtr& fd, uint64_t data_size) {
   uint64_t part_size = fd->BlockDevSize();
   if (!part_size || part_size <= data_size)
     return false;

   struct blkioctl_request {
     int number;
     const char* name;
   };
   const std::initializer_list<blkioctl_request> blkioctl_requests = {
       {BLKDISCARD, "BLKDISCARD"},
       {BLKSECDISCARD, "BLKSECDISCARD"},
 #ifdef BLKZEROOUT
       {BLKZEROOUT, "BLKZEROOUT"},
 #endif
   };
   for (const auto& req : blkioctl_requests) {
     int error = 0;
     if (fd->BlkIoctl(req.number, data_size, part_size - data_size, &error) &&
         error == 0) {
       return true;
     }
     LOG(WARNING) << "Error discarding the last "
                  << (part_size - data_size) / 1024 << " KiB using ioctl("
                  << req.name << ")";
   }
   return false;
 }

 }  // namespace

 using google::protobuf::RepeatedPtrField;

 // Opens path for read/write. On success returns an open FileDescriptor
 // and sets *err to 0. On failure, sets *err to errno and returns nullptr.
 FileDescriptorPtr OpenFile(const char* path,
                            int mode,
                            bool cache_writes,
                            int* err) {
   // Try to mark the block device read-only based on the mode. Ignore any
   // failure since this won't work when passing regular files.
   bool read_only = (mode & O_ACCMODE) == O_RDONLY;
   utils::SetBlockDeviceReadOnly(path, read_only);

   FileDescriptorPtr fd(new EintrSafeFileDescriptor());
   if (cache_writes && !read_only) {
     fd = FileDescriptorPtr(new CachedFileDescriptor(fd, kCacheSize));
     LOG(INFO) << "Caching writes.";
   }
   if (!fd->Open(path, mode, 000)) {
     *err = errno;
     PLOG(ERROR) << "Unable to open file " << path;
     return nullptr;
   }
   *err = 0;
   return fd;
 }

 PartitionWriter::PartitionWriter(
     const PartitionUpdate& partition_update,
     const InstallPlan::Partition& install_part,
     DynamicPartitionControlInterface* dynamic_control,
     size_t block_size,
     bool is_interactive)
     : partition_update_(partition_update),
       install_part_(install_part),
       dynamic_control_(dynamic_control),
       verified_source_fd_(block_size, install_part.source_path),
       interactive_(is_interactive),
       block_size_(block_size),
       install_op_executor_(block_size) {}

 PartitionWriter::~PartitionWriter() {
   Close();
 }

 bool PartitionWriter::OpenSourcePartition(uint32_t source_slot,
                                           bool source_may_exist) {
   source_path_.clear();
   if (!source_may_exist) {
     return true;
   }
   if (install_part_.source_size > 0 && !install_part_.source_path.empty()) {
     source_path_ = install_part_.source_path;
     if (!verified_source_fd_.Open()) {
       LOG(ERROR) << "Unable to open source partition " << install_part_.name
                  << " on slot " << BootControlInterface::SlotName(source_slot)
                  << ", file " << source_path_;
       return false;
     }
   }
   return true;
 }

 bool PartitionWriter::Init(const InstallPlan* install_plan,
                            bool source_may_exist,
                            size_t next_op_index) {
   const PartitionUpdate& partition = partition_update_;
   uint32_t source_slot = install_plan->source_slot;
   uint32_t target_slot = install_plan->target_slot;
   TEST_AND_RETURN_FALSE(OpenSourcePartition(source_slot, source_may_exist));

   // We shouldn't open the source partition in certain cases, e.g. some dynamic
   // partitions in delta payload, partitions included in the full payload for
   // partial updates. Use the source size as the indicator.

   target_path_ = install_part_.target_path;
   int err;

   int flags = O_RDWR;
   if (!interactive_)
     flags |= O_DSYNC;

   LOG(INFO) << "Opening " << target_path_ << " partition with"
             << (interactive_ ? "out" : "") << " O_DSYNC";

   target_fd_ = OpenFile(target_path_.c_str(), flags, true, &err);
   if (!target_fd_) {
     LOG(ERROR) << "Unable to open target partition "
                << partition.partition_name() << " on slot "
                << BootControlInterface::SlotName(target_slot) << ", file "
                << target_path_;
     return false;
   }

   LOG(INFO) << "Applying " << partition.operations().size()
             << " operations to partition \"" << partition.partition_name()
             << "\"";

   // Discard the end of the partition, but ignore failures.
   DiscardPartitionTail(target_fd_, install_part_.target_size);

   return true;
 }

 bool PartitionWriter::PerformReplaceOperation(const InstallOperation& operation,
                                               const void* data,
                                               size_t count) {
   // Setup the ExtentWriter stack based on the operation type.
   std::unique_ptr<ExtentWriter> writer = CreateBaseExtentWriter();
   return install_op_executor_.ExecuteReplaceOperation(
       operation, std::move(writer), data, count);
 }

 bool PartitionWriter::PerformZeroOrDiscardOperation(
     const InstallOperation& operation) {
 #ifdef BLKZEROOUT
   int request =
       (operation.type() == InstallOperation::ZERO ? BLKZEROOUT : BLKDISCARD);
 #else   // !defined(BLKZEROOUT)
   auto writer = CreateBaseExtentWriter();
   return install_op_executor_.ExecuteZeroOrDiscardOperation(operation,
                                                             writer.get());
 #endif  // !defined(BLKZEROOUT)

   for (const Extent& extent : operation.dst_extents()) {
     const uint64_t start = extent.start_block() * block_size_;
     const uint64_t length = extent.num_blocks() * block_size_;
     int result = 0;
     if (target_fd_->BlkIoctl(request, start, length, &result) && result == 0) {
       continue;
     }
     // In case of failure, we fall back to writing 0 for the entire operation.
     PLOG(WARNING) << "BlkIoctl failed. Falling back to write 0s for remainder "
                      "of this operation.";
     auto writer = CreateBaseExtentWriter();
     return install_op_executor_.ExecuteZeroOrDiscardOperation(
         operation, std::move(writer));
   }
   return true;
 }

 bool PartitionWriter::PerformSourceCopyOperation(
     const InstallOperation& operation, ErrorCode* error) {
   // The device may optimize the SOURCE_COPY operation.
   // Being this a device-specific optimization let DynamicPartitionController
   // decide it the operation should be skipped.
   const PartitionUpdate& partition = partition_update_;

   InstallOperation buf;
   const bool should_optimize = dynamic_control_->OptimizeOperation(
       partition.partition_name(), operation, &buf);
   const InstallOperation& optimized = should_optimize ? buf : operation;

   // Invoke ChooseSourceFD with original operation, so that it can properly
   // verify source hashes. Optimized operation might contain a smaller set of
   // extents, or completely empty.
   auto source_fd = ChooseSourceFD(operation, error);
   if (source_fd == nullptr) {
     LOG(ERROR) << "Unrecoverable source hash mismatch found on partition "
                << partition.partition_name()
                << " extents: " << ExtentsToString(operation.src_extents());
     return false;
   }

   auto writer = CreateBaseExtentWriter();
   return install_op_executor_.ExecuteSourceCopyOperation(
       optimized, std::move(writer), source_fd);
 }

 bool PartitionWriter::PerformDiffOperation(const InstallOperation& operation,
                                            ErrorCode* error,
                                            const void* data,
                                            size_t count) {
   FileDescriptorPtr source_fd = ChooseSourceFD(operation, error);
   TEST_AND_RETURN_FALSE(source_fd != nullptr);

   auto writer = CreateBaseExtentWriter();
   return install_op_executor_.ExecuteDiffOperation(
       operation, std::move(writer), source_fd, data, count);
 }

 FileDescriptorPtr PartitionWriter::ChooseSourceFD(
     const InstallOperation& operation, ErrorCode* error) {
   return verified_source_fd_.ChooseSourceFD(operation, error);
 }

 int PartitionWriter::Close() {
   int err = 0;

   source_path_.clear();

   if (target_fd_ && !target_fd_->Close()) {
     err = errno;
     PLOG(ERROR) << "Error closing target partition";
     if (!err)
       err = 1;
   }
   target_fd_.reset();
   target_path_.clear();

   return -err;
 }

 void PartitionWriter::CheckpointUpdateProgress(size_t next_op_index) {
   target_fd_->Flush();
 }

 std::unique_ptr<ExtentWriter> PartitionWriter::CreateBaseExtentWriter() {
   return std::make_unique<DirectExtentWriter>(target_fd_);
 }

 bool PartitionWriter::ValidateSourceHash(const brillo::Blob& calculated_hash,
                                          const InstallOperation& operation,
                                          const FileDescriptorPtr source_fd,
                                          ErrorCode* error) {
   using std::string;
   using std::vector;
   brillo::Blob expected_source_hash(operation.src_sha256_hash().begin(),
                                     operation.src_sha256_hash().end());
   if (calculated_hash != expected_source_hash) {
     LOG(ERROR) << "The hash of the source data on disk for this operation "
                << "doesn't match the expected value. This could mean that the "
                << "delta update payload was targeted for another version, or "
                << "that the source partition was modified after it was "
                << "installed, for example, by mounting a filesystem.";
     LOG(ERROR) << "Expected:   sha256|hex = "
                << base::HexEncode(expected_source_hash.data(),
                                   expected_source_hash.size());
     LOG(ERROR) << "Calculated: sha256|hex = "
                << base::HexEncode(calculated_hash.data(),
                                   calculated_hash.size());

     vector<string> source_extents;
     for (const Extent& ext : operation.src_extents()) {
       source_extents.push_back(
           base::StringPrintf("%" PRIu64 ":%" PRIu64,
                              static_cast<uint64_t>(ext.start_block()),
                              static_cast<uint64_t>(ext.num_blocks())));
     }
     LOG(ERROR) << "Operation source (offset:size) in blocks: "
                << base::JoinString(source_extents, ",");

     // Log remount history if this device is an ext4 partition.
     LogMountHistory(source_fd);

     *error = ErrorCode::kDownloadStateInitializationError;
     return false;
   }
   return true;
 }

 }  // namespace chromeos_update_engine
	//
	// 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.
	//
	#include <update_engine/payload_consumer/partition_writer.h>

	#include <fcntl.h>
	#include <linux/fs.h>
	#include <sys/mman.h>

	#include <inttypes.h>

	#include <algorithm>
	#include <initializer_list>
	#include <memory>
	#include <string>
	#include <utility>
	#include <vector>

	#include <base/strings/string_number_conversions.h>
	#include <base/strings/string_util.h>
	#include <base/strings/stringprintf.h>

	#include "update_engine/common/terminator.h"
	#include "update_engine/common/utils.h"
	#include "update_engine/payload_consumer/bzip_extent_writer.h"
	#include "update_engine/payload_consumer/cached_file_descriptor.h"
	#include "update_engine/payload_consumer/extent_reader.h"
	#include "update_engine/payload_consumer/extent_writer.h"
	#include "update_engine/payload_consumer/file_descriptor_utils.h"
	#include "update_engine/payload_consumer/install_operation_executor.h"
	#include "update_engine/payload_consumer/install_plan.h"
	#include "update_engine/payload_consumer/mount_history.h"
	#include "update_engine/payload_consumer/payload_constants.h"
	#include "update_engine/payload_consumer/xz_extent_writer.h"
	#include "update_engine/payload_generator/extent_utils.h"

	namespace chromeos_update_engine {

	namespace {
	constexpr uint64_t kCacheSize = 1024 * 1024; // 1MB

	// Discard the tail of the block device referenced by \|fd\|, from the offset
	// \|data_size\| until the end of the block device. Returns whether the data was
	// discarded.

	bool DiscardPartitionTail(const FileDescriptorPtr& fd, uint64_t data_size) {
	uint64_t part_size = fd->BlockDevSize();
	if (!part_size \|\| part_size <= data_size)
	return false;

	struct blkioctl_request {
	int number;
	const char* name;
	};
	const std::initializer_list<blkioctl_request> blkioctl_requests = {
	{BLKDISCARD, "BLKDISCARD"},
	{BLKSECDISCARD, "BLKSECDISCARD"},
	#ifdef BLKZEROOUT
	{BLKZEROOUT, "BLKZEROOUT"},
	#endif
	};
	for (const auto& req : blkioctl_requests) {
	int error = 0;
	if (fd->BlkIoctl(req.number, data_size, part_size - data_size, &error) &&
	error == 0) {
	return true;
	}
	LOG(WARNING) << "Error discarding the last "
	<< (part_size - data_size) / 1024 << " KiB using ioctl("
	<< req.name << ")";
	}
	return false;
	}

	} // namespace

	using google::protobuf::RepeatedPtrField;

	// Opens path for read/write. On success returns an open FileDescriptor
	// and sets err to 0. On failure, sets err to errno and returns nullptr.
	FileDescriptorPtr OpenFile(const char* path,
	int mode,
	bool cache_writes,
	int* err) {
	// Try to mark the block device read-only based on the mode. Ignore any
	// failure since this won't work when passing regular files.
	bool read_only = (mode & O_ACCMODE) == O_RDONLY;
	utils::SetBlockDeviceReadOnly(path, read_only);

	FileDescriptorPtr fd(new EintrSafeFileDescriptor());
	if (cache_writes && !read_only) {
	fd = FileDescriptorPtr(new CachedFileDescriptor(fd, kCacheSize));
	LOG(INFO) << "Caching writes.";
	}
	if (!fd->Open(path, mode, 000)) {
	*err = errno;
	PLOG(ERROR) << "Unable to open file " << path;
	return nullptr;
	}
	*err = 0;
	return fd;
	}

	PartitionWriter::PartitionWriter(
	const PartitionUpdate& partition_update,
	const InstallPlan::Partition& install_part,
	DynamicPartitionControlInterface* dynamic_control,
	size_t block_size,
	bool is_interactive)
	: partition_update_(partition_update),
	install_part_(install_part),
	dynamic_control_(dynamic_control),
	verified_source_fd_(block_size, install_part.source_path),
	interactive_(is_interactive),
	block_size_(block_size),
	install_op_executor_(block_size) {}

	PartitionWriter::~PartitionWriter() {
	Close();
	}

	bool PartitionWriter::OpenSourcePartition(uint32_t source_slot,
	bool source_may_exist) {
	source_path_.clear();
	if (!source_may_exist) {
	return true;
	}
	if (install_part_.source_size > 0 && !install_part_.source_path.empty()) {
	source_path_ = install_part_.source_path;
	if (!verified_source_fd_.Open()) {
	LOG(ERROR) << "Unable to open source partition " << install_part_.name
	<< " on slot " << BootControlInterface::SlotName(source_slot)
	<< ", file " << source_path_;
	return false;
	}
	}
	return true;
	}

	bool PartitionWriter::Init(const InstallPlan* install_plan,
	bool source_may_exist,
	size_t next_op_index) {
	const PartitionUpdate& partition = partition_update_;
	uint32_t source_slot = install_plan->source_slot;
	uint32_t target_slot = install_plan->target_slot;
	TEST_AND_RETURN_FALSE(OpenSourcePartition(source_slot, source_may_exist));

	// We shouldn't open the source partition in certain cases, e.g. some dynamic
	// partitions in delta payload, partitions included in the full payload for
	// partial updates. Use the source size as the indicator.

	target_path_ = install_part_.target_path;
	int err;

	int flags = O_RDWR;
	if (!interactive_)
	flags \|= O_DSYNC;

	LOG(INFO) << "Opening " << target_path_ << " partition with"
	<< (interactive_ ? "out" : "") << " O_DSYNC";

	target_fd_ = OpenFile(target_path_.c_str(), flags, true, &err);
	if (!target_fd_) {
	LOG(ERROR) << "Unable to open target partition "
	<< partition.partition_name() << " on slot "
	<< BootControlInterface::SlotName(target_slot) << ", file "
	<< target_path_;
	return false;
	}

	LOG(INFO) << "Applying " << partition.operations().size()
	<< " operations to partition \"" << partition.partition_name()
	<< "\"";

	// Discard the end of the partition, but ignore failures.
	DiscardPartitionTail(target_fd_, install_part_.target_size);

	return true;
	}

	bool PartitionWriter::PerformReplaceOperation(const InstallOperation& operation,
	const void* data,
	size_t count) {
	// Setup the ExtentWriter stack based on the operation type.
	std::unique_ptr<ExtentWriter> writer = CreateBaseExtentWriter();
	return install_op_executor_.ExecuteReplaceOperation(
	operation, std::move(writer), data, count);
	}

	bool PartitionWriter::PerformZeroOrDiscardOperation(
	const InstallOperation& operation) {
	#ifdef BLKZEROOUT
	int request =
	(operation.type() == InstallOperation::ZERO ? BLKZEROOUT : BLKDISCARD);
	#else // !defined(BLKZEROOUT)
	auto writer = CreateBaseExtentWriter();
	return install_op_executor_.ExecuteZeroOrDiscardOperation(operation,
	writer.get());
	#endif // !defined(BLKZEROOUT)

	for (const Extent& extent : operation.dst_extents()) {
	const uint64_t start = extent.start_block() * block_size_;
	const uint64_t length = extent.num_blocks() * block_size_;
	int result = 0;
	if (target_fd_->BlkIoctl(request, start, length, &result) && result == 0) {
	continue;
	}
	// In case of failure, we fall back to writing 0 for the entire operation.
	PLOG(WARNING) << "BlkIoctl failed. Falling back to write 0s for remainder "
	"of this operation.";
	auto writer = CreateBaseExtentWriter();
	return install_op_executor_.ExecuteZeroOrDiscardOperation(
	operation, std::move(writer));
	}
	return true;
	}

	bool PartitionWriter::PerformSourceCopyOperation(
	const InstallOperation& operation, ErrorCode* error) {
	// The device may optimize the SOURCE_COPY operation.
	// Being this a device-specific optimization let DynamicPartitionController
	// decide it the operation should be skipped.
	const PartitionUpdate& partition = partition_update_;

	InstallOperation buf;
	const bool should_optimize = dynamic_control_->OptimizeOperation(
	partition.partition_name(), operation, &buf);
	const InstallOperation& optimized = should_optimize ? buf : operation;

	// Invoke ChooseSourceFD with original operation, so that it can properly
	// verify source hashes. Optimized operation might contain a smaller set of
	// extents, or completely empty.
	auto source_fd = ChooseSourceFD(operation, error);
	if (source_fd == nullptr) {
	LOG(ERROR) << "Unrecoverable source hash mismatch found on partition "
	<< partition.partition_name()
	<< " extents: " << ExtentsToString(operation.src_extents());
	return false;
	}

	auto writer = CreateBaseExtentWriter();
	return install_op_executor_.ExecuteSourceCopyOperation(
	optimized, std::move(writer), source_fd);
	}

	bool PartitionWriter::PerformDiffOperation(const InstallOperation& operation,
	ErrorCode* error,
	const void* data,
	size_t count) {
	FileDescriptorPtr source_fd = ChooseSourceFD(operation, error);
	TEST_AND_RETURN_FALSE(source_fd != nullptr);

	auto writer = CreateBaseExtentWriter();
	return install_op_executor_.ExecuteDiffOperation(
	operation, std::move(writer), source_fd, data, count);
	}

	FileDescriptorPtr PartitionWriter::ChooseSourceFD(
	const InstallOperation& operation, ErrorCode* error) {
	return verified_source_fd_.ChooseSourceFD(operation, error);
	}

	int PartitionWriter::Close() {
	int err = 0;

	source_path_.clear();

	if (target_fd_ && !target_fd_->Close()) {
	err = errno;
	PLOG(ERROR) << "Error closing target partition";
	if (!err)
	err = 1;
	}
	target_fd_.reset();
	target_path_.clear();

	return -err;
	}

	void PartitionWriter::CheckpointUpdateProgress(size_t next_op_index) {
	target_fd_->Flush();
	}

	std::unique_ptr<ExtentWriter> PartitionWriter::CreateBaseExtentWriter() {
	return std::make_unique<DirectExtentWriter>(target_fd_);
	}

	bool PartitionWriter::ValidateSourceHash(const brillo::Blob& calculated_hash,
	const InstallOperation& operation,
	const FileDescriptorPtr source_fd,
	ErrorCode* error) {
	using std::string;
	using std::vector;
	brillo::Blob expected_source_hash(operation.src_sha256_hash().begin(),
	operation.src_sha256_hash().end());
	if (calculated_hash != expected_source_hash) {
	LOG(ERROR) << "The hash of the source data on disk for this operation "
	<< "doesn't match the expected value. This could mean that the "
	<< "delta update payload was targeted for another version, or "
	<< "that the source partition was modified after it was "
	<< "installed, for example, by mounting a filesystem.";
	LOG(ERROR) << "Expected: sha256\|hex = "
	<< base::HexEncode(expected_source_hash.data(),
	expected_source_hash.size());
	LOG(ERROR) << "Calculated: sha256\|hex = "
	<< base::HexEncode(calculated_hash.data(),
	calculated_hash.size());

	vector<string> source_extents;
	for (const Extent& ext : operation.src_extents()) {
	source_extents.push_back(
	base::StringPrintf("%" PRIu64 ":%" PRIu64,
	static_cast<uint64_t>(ext.start_block()),
	static_cast<uint64_t>(ext.num_blocks())));
	}
	LOG(ERROR) << "Operation source (offset:size) in blocks: "
	<< base::JoinString(source_extents, ",");

	// Log remount history if this device is an ext4 partition.
	LogMountHistory(source_fd);

	*error = ErrorCode::kDownloadStateInitializationError;
	return false;
	}
	return true;
	}

	} // namespace chromeos_update_engine