Remove fsck_unshare_blocks. (969787cf) · Commits · e / os / android_bootable_recovery

Android.bp

+0 −1

Original line number	Original line	Diff line number	Diff line
	@@ -90,7 +90,6 @@ cc_library_static {
	],		],

	srcs: [		srcs: [
	"fsck_unshare_blocks.cpp",
	"recovery.cpp",		"recovery.cpp",
	],		],

fsck_unshare_blocks.cpp

deleted100644 → 0

+0 −151

Original line number	Original line	Diff line number	Diff line
	/*
	* 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.
	*/

	#include "fsck_unshare_blocks.h"

	#include <errno.h>
	#include <fcntl.h>
	#include <spawn.h>
	#include <string.h>
	#include <sys/mount.h>
	#include <sys/stat.h>
	#include <sys/types.h>
	#include <sys/wait.h>
	#include <unistd.h>

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

	#include <android-base/logging.h>
	#include <android-base/properties.h>
	#include <android-base/unique_fd.h>
	#include <fs_mgr/roots.h>

	#include "recovery_utils/roots.h"

	static constexpr const char* SYSTEM_E2FSCK_BIN = "/system/bin/e2fsck_static";
	static constexpr const char* TMP_E2FSCK_BIN = "/tmp/e2fsck.bin";

	static bool copy_file(const char* source, const char* dest) {
	android::base::unique_fd source_fd(open(source, O_RDONLY));
	if (source_fd < 0) {
	PLOG(ERROR) << "open %s failed" << source;
	return false;
	}

	android::base::unique_fd dest_fd(open(dest, O_CREAT \| O_WRONLY, S_IRWXU));
	if (dest_fd < 0) {
	PLOG(ERROR) << "open %s failed" << dest;
	return false;
	}

	for (;;) {
	char buf[4096];
	ssize_t rv = read(source_fd, buf, sizeof(buf));
	if (rv < 0) {
	PLOG(ERROR) << "read failed";
	return false;
	}
	if (rv == 0) {
	break;
	}
	if (write(dest_fd, buf, rv) != rv) {
	PLOG(ERROR) << "write failed";
	return false;
	}
	}
	return true;
	}

	static bool run_e2fsck(const std::string& partition) {
	Volume* volume = volume_for_mount_point(partition);
	if (!volume) {
	LOG(INFO) << "No fstab entry for " << partition << ", skipping.";
	return true;
	}

	LOG(INFO) << "Running e2fsck on device " << volume->blk_device;

	std::vector<std::string> args = { TMP_E2FSCK_BIN, "-p", "-E", "unshare_blocks",
	volume->blk_device };
	std::vector<char*> argv(args.size());
	std::transform(args.cbegin(), args.cend(), argv.begin(),
	[](const std::string& arg) { return const_cast<char*>(arg.c_str()); });
	argv.push_back(nullptr);

	pid_t child;
	char* env[] = { nullptr };
	if (posix_spawn(&child, argv[0], nullptr, nullptr, argv.data(), env)) {
	PLOG(ERROR) << "posix_spawn failed";
	return false;
	}

	int status = 0;
	int ret = TEMP_FAILURE_RETRY(waitpid(child, &status, 0));
	if (ret < 0) {
	PLOG(ERROR) << "waitpid failed";
	return false;
	}
	if (!WIFEXITED(status)) {
	LOG(ERROR) << "e2fsck exited abnormally: " << status;
	return false;
	}
	int return_code = WEXITSTATUS(status);
	if (return_code >= 8) {
	LOG(ERROR) << "e2fsck could not unshare blocks: " << return_code;
	return false;
	}

	LOG(INFO) << "Successfully unshared blocks on " << partition;
	return true;
	}

	bool do_fsck_unshare_blocks() {
	// List of partitions we will try to e2fsck -E unshare_blocks.
	std::vector<std::string> partitions = { "/odm", "/oem", "/product", "/vendor" };

	// Temporarily mount system so we can copy e2fsck_static.
	auto system_root = android::fs_mgr::GetSystemRoot();
	bool mounted = ensure_path_mounted_at(system_root, "/mnt/system") != -1;
	partitions.push_back(system_root);

	if (!mounted) {
	LOG(ERROR) << "Failed to mount system image.";
	return false;
	}
	if (!copy_file(SYSTEM_E2FSCK_BIN, TMP_E2FSCK_BIN)) {
	LOG(ERROR) << "Could not copy e2fsck to /tmp.";
	return false;
	}
	if (umount("/mnt/system") < 0) {
	PLOG(ERROR) << "umount failed";
	return false;
	}

	bool ok = true;
	for (const auto& partition : partitions) {
	ok &= run_e2fsck(partition);
	}

	if (ok) {
	LOG(INFO) << "Finished running e2fsck.";
	} else {
	LOG(ERROR) << "Finished running e2fsck, but not all partitions succceeded.";
	}
	return ok;
	}

fsck_unshare_blocks.h

deleted100644 → 0

+0 −22

Original line number	Original line	Diff line number	Diff line
	/*
	* 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 _FILESYSTEM_CMDS_H
	#define _FILESYSTEM_CMDS_H

	bool do_fsck_unshare_blocks();

	#endif // _FILESYSTEM_CMDS_H

recovery.cpp

+1 −10

Original line number	Original line	Diff line number	Diff line
	@@ -45,7 +45,6 @@
	#include <ziparchive/zip_archive.h>		#include <ziparchive/zip_archive.h>

	#include "bootloader_message/bootloader_message.h"		#include "bootloader_message/bootloader_message.h"
	#include "fsck_unshare_blocks.h"
	#include "install/adb_install.h"		#include "install/adb_install.h"
	#include "install/fuse_install.h"		#include "install/fuse_install.h"
	#include "install/install.h"		#include "install/install.h"
	@@ -524,7 +523,6 @@ static void log_failure_code(ErrorCode code, const std::string& update_package)
	Device::BuiltinAction start_recovery(Device* device, const std::vector<std::string>& args) {		Device::BuiltinAction start_recovery(Device* device, const std::vector<std::string>& args) {
	static constexpr struct option OPTIONS[] = {		static constexpr struct option OPTIONS[] = {
	{ "fastboot", no_argument, nullptr, 0 },		{ "fastboot", no_argument, nullptr, 0 },
	{ "fsck_unshare_blocks", no_argument, nullptr, 0 },
	{ "install_with_fuse", no_argument, nullptr, 0 },		{ "install_with_fuse", no_argument, nullptr, 0 },
	{ "just_exit", no_argument, nullptr, 'x' },		{ "just_exit", no_argument, nullptr, 'x' },
	{ "locale", required_argument, nullptr, 0 },		{ "locale", required_argument, nullptr, 0 },
	@@ -557,7 +555,6 @@ Device::BuiltinAction start_recovery(Device* device, const std::vector<std::stri
	bool rescue = false;		bool rescue = false;
	bool just_exit = false;		bool just_exit = false;
	bool shutdown_after = false;		bool shutdown_after = false;
	bool fsck_unshare_blocks = false;
	int retry_count = 0;		int retry_count = 0;
	bool security_update = false;		bool security_update = false;
	std::string locale;		std::string locale;
	@@ -580,9 +577,7 @@ Device::BuiltinAction start_recovery(Device* device, const std::vector<std::stri
	break;		break;
	case 0: {		case 0: {
	std::string option = OPTIONS[option_index].name;		std::string option = OPTIONS[option_index].name;
	if (option == "fsck_unshare_blocks") {		if (option == "install_with_fuse") {
	fsck_unshare_blocks = true;
	} else if (option == "install_with_fuse") {
	install_with_fuse = true;		install_with_fuse = true;
	} else if (option == "locale" \|\| option == "fastboot" \|\| option == "reason") {		} else if (option == "locale" \|\| option == "fastboot" \|\| option == "reason") {
	// Handled in recovery_main.cpp		// Handled in recovery_main.cpp
	@@ -779,10 +774,6 @@ Device::BuiltinAction start_recovery(Device* device, const std::vector<std::stri
	save_current_log = true;		save_current_log = true;
	status = ApplyFromAdb(device, true /* rescue_mode */, &next_action);		status = ApplyFromAdb(device, true /* rescue_mode */, &next_action);
	ui->Print("\nInstall from ADB complete (status: %d).\n", status);		ui->Print("\nInstall from ADB complete (status: %d).\n", status);
	} else if (fsck_unshare_blocks) {
	if (!do_fsck_unshare_blocks()) {
	status = INSTALL_ERROR;
	}
	} else if (!just_exit) {		} else if (!just_exit) {
	// If this is an eng or userdebug build, automatically turn on the text display if no command		// If this is an eng or userdebug build, automatically turn on the text display if no command
	// is specified. Note that this should be called before setting the background to avoid		// is specified. Note that this should be called before setting the background to avoid