snapuserd: Move socket and io_uring status out of core and into the server. (35badb7c) · Commits · e / os / android_system_core

fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.cpp

+8 −25

Original line number	Diff line number	Diff line
		@@ -31,30 +31,21 @@ using namespace android::dm;
		using android::base::unique_fd;

		SnapshotHandler::SnapshotHandler(std::string misc_name, std::string cow_device,
		std::string backing_device, std::string base_path_merge) {
		std::string backing_device, std::string base_path_merge,
		int num_worker_threads, bool use_iouring,
		bool perform_verification) {
		misc_name_ = std::move(misc_name);
		cow_device_ = std::move(cow_device);
		backing_store_device_ = std::move(backing_device);
		control_device_ = "/dev/dm-user/" + misc_name_;
		base_path_merge_ = std::move(base_path_merge);
		num_worker_threads_ = num_worker_threads;
		is_io_uring_enabled_ = use_iouring;
		perform_verification_ = perform_verification;
		}

		bool SnapshotHandler::InitializeWorkers() {
		int num_worker_threads = kNumWorkerThreads;

		// We will need multiple worker threads only during
		// device boot after OTA. For all other purposes,
		// one thread is sufficient. We don't want to consume
		// unnecessary memory especially during OTA install phase
		// when daemon will be up during entire post install phase.
		//
		// During boot up, we need multiple threads primarily for
		// update-verification.
		if (is_socket_present_) {
		num_worker_threads = 1;
		}

		for (int i = 0; i < num_worker_threads; i++) {
		for (int i = 0; i < num_worker_threads_; i++) {
		std::unique_ptr<Worker> wt =
		std::make_unique<Worker>(cow_device_, backing_store_device_, control_device_,
		misc_name_, base_path_merge_, GetSharedPtr());
		@@ -331,19 +322,11 @@ bool SnapshotHandler::Start() {
		std::async(std::launch::async, &Worker::RunThread, worker_threads_[i].get()));
		}

		bool partition_verification = true;

		// We don't want to read the blocks during first stage init or
		// during post-install phase.
		if (android::base::EndsWith(misc_name_, "-init") \|\| is_socket_present_) {
		partition_verification = false;
		}

		std::future<bool> merge_thread =
		std::async(std::launch::async, &Worker::RunMergeThread, merge_thread_.get());

		// Now that the worker threads are up, scan the partitions.
		if (partition_verification) {
		if (perform_verification_) {
		update_verify_->VerifyUpdatePartition();
		}

fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_core.h

+4 −4

Original line number	Diff line number	Diff line
		@@ -301,7 +301,8 @@ class Worker {
		class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
		public:
		SnapshotHandler(std::string misc_name, std::string cow_device, std::string backing_device,
		std::string base_path_merge);
		std::string base_path_merge, int num_workers, bool use_iouring,
		bool perform_verification);
		bool InitCowDevice();
		bool Start();

		@@ -369,8 +370,6 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
		// Total number of blocks to be merged in a given read-ahead buffer region
		void SetMergedBlockCountForNextCommit(int x) { total_ra_blocks_merged_ = x; }
		int GetTotalBlocksToMerge() { return total_ra_blocks_merged_; }
		void SetSocketPresent(bool socket) { is_socket_present_ = socket; }
		void SetIouringEnabled(bool io_uring_enabled) { is_io_uring_enabled_ = io_uring_enabled; }
		bool MergeInitiated() { return merge_initiated_; }
		bool MergeMonitored() { return merge_monitored_; }
		double GetMergePercentage() { return merge_completion_percentage_; }
		@@ -441,9 +440,10 @@ class SnapshotHandler : public std::enable_shared_from_this<SnapshotHandler> {
		bool merge_initiated_ = false;
		bool merge_monitored_ = false;
		bool attached_ = false;
		bool is_socket_present_;
		bool is_io_uring_enabled_ = false;
		bool scratch_space_ = false;
		int num_worker_threads_ = kNumWorkerThreads;
		bool perform_verification_ = true;

		std::unique_ptr<struct io_uring> ring_;
		std::unique_ptr<UpdateVerify> update_verify_;

fs_mgr/libsnapshot/snapuserd/user-space-merge/snapuserd_server.cpp

+21 −4

Original line number	Diff line number	Diff line
		@@ -29,6 +29,7 @@
		#include <android-base/logging.h>
		#include <android-base/properties.h>
		#include <android-base/scopeguard.h>
		#include <android-base/strings.h>
		#include <fs_mgr/file_wait.h>
		#include <snapuserd/snapuserd_client.h>
		#include "snapuserd_server.h"
		@@ -487,16 +488,32 @@ std::shared_ptr<HandlerThread> UserSnapshotServer::AddHandler(const std::string&
		const std::string& cow_device_path,
		const std::string& backing_device,
		const std::string& base_path_merge) {
		// We will need multiple worker threads only during
		// device boot after OTA. For all other purposes,
		// one thread is sufficient. We don't want to consume
		// unnecessary memory especially during OTA install phase
		// when daemon will be up during entire post install phase.
		//
		// During boot up, we need multiple threads primarily for
		// update-verification.
		int num_worker_threads = kNumWorkerThreads;
		if (is_socket_present_) {
		num_worker_threads = 1;
		}

		bool perform_verification = true;
		if (android::base::EndsWith(misc_name, "-init") \|\| is_socket_present_) {
		perform_verification = false;
		}

		auto snapuserd = std::make_shared<SnapshotHandler>(misc_name, cow_device_path, backing_device,
		base_path_merge);
		base_path_merge, num_worker_threads,
		io_uring_enabled_, perform_verification);
		if (!snapuserd->InitCowDevice()) {
		LOG(ERROR) << "Failed to initialize Snapuserd";
		return nullptr;
		}

		snapuserd->SetSocketPresent(is_socket_present_);
		snapuserd->SetIouringEnabled(io_uring_enabled_);

		if (!snapuserd->InitializeWorkers()) {
		LOG(ERROR) << "Failed to initialize workers";
		return nullptr;