Merge "Add fastbootd." (f57b123d) · Commits · e / os / android_system_core

fastboot/Android.bp

+65 −0

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

		cc_library_host_static {
		name: "libfastboot2",

		@@ -54,3 +68,54 @@ cc_library_host_static {
		export_include_dirs: ["."],

		}

		cc_defaults {
		name: "fastboot_defaults",

		cflags: [
		"-Wall",
		"-Wextra",
		"-Werror",
		"-Wvla",
		],
		rtti: true,

		clang_cflags: [
		"-Wthread-safety",
		],
		}

		cc_binary {
		name: "fastbootd",
		defaults: ["fastboot_defaults"],

		recovery: true,

		srcs: [
		"device/commands.cpp",
		"device/fastboot_device.cpp",
		"device/main.cpp",
		"device/usb_client.cpp",
		],

		shared_libs: [
		"libasyncio",
		"libext4_utils",
		"libsparse",
		"liblog",
		"libbootloader_message",
		"libhidltransport",
		"libhidlbase",
		"libhwbinder",
		"libbase",
		"libutils",
		"libcutils",
		"libfs_mgr",
		],

		static_libs: [
		"libadbd",
		],

		cpp_std: "c++17",
		}

fastboot/constants.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -27,6 +27,8 @@
		#define FB_CMD_REBOOT "reboot"
		#define FB_CMD_SHUTDOWN "shutdown"
		#define FB_CMD_REBOOT_BOOTLOADER "reboot-bootloader"
		#define FB_CMD_REBOOT_RECOVERY "reboot-recovery"
		#define FB_CMD_REBOOT_FASTBOOT "reboot-fastboot"
		#define FB_CMD_POWERDOWN "powerdown"

		#define RESPONSE_OKAY "OKAY"

fastboot/device/commands.cpp

0 → 100644

+126 −0

Original line number	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 "commands.h"

		#include <sys/socket.h>
		#include <sys/un.h>

		#include <android-base/logging.h>
		#include <android-base/parseint.h>
		#include <android-base/properties.h>
		#include <android-base/stringprintf.h>
		#include <android-base/strings.h>
		#include <android-base/unique_fd.h>
		#include <cutils/android_reboot.h>

		#include "fastboot_device.h"

		bool DownloadHandler(FastbootDevice* device, const std::vector<std::string>& args) {
		if (args.size() < 2) {
		return device->WriteStatus(FastbootResult::FAIL, "size argument unspecified");
		}
		// arg[0] is the command name, arg[1] contains size of data to be downloaded
		unsigned int size;
		if (!android::base::ParseUint("0x" + args[1], &size, UINT_MAX)) {
		return device->WriteStatus(FastbootResult::FAIL, "Invalid size");
		}
		device->get_download_data().resize(size);
		if (!device->WriteStatus(FastbootResult::DATA, android::base::StringPrintf("%08x", size))) {
		return false;
		}

		if (device->HandleData(true, &device->get_download_data())) {
		return device->WriteStatus(FastbootResult::OKAY, "");
		}

		PLOG(ERROR) << "Couldn't download data";
		return device->WriteStatus(FastbootResult::FAIL, "Couldn't download data");
		}

		bool SetActiveHandler(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		return device->WriteStatus(FastbootResult::OKAY, "");
		}

		bool ShutDownHandler(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		auto result = device->WriteStatus(FastbootResult::OKAY, "Shutting down");
		android::base::SetProperty(ANDROID_RB_PROPERTY, "shutdown,fastboot");
		device->CloseDevice();
		TEMP_FAILURE_RETRY(pause());
		return result;
		}

		bool RebootHandler(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		auto result = device->WriteStatus(FastbootResult::OKAY, "Rebooting");
		android::base::SetProperty(ANDROID_RB_PROPERTY, "reboot,from_fastboot");
		device->CloseDevice();
		TEMP_FAILURE_RETRY(pause());
		return result;
		}

		bool RebootBootloaderHandler(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		auto result = device->WriteStatus(FastbootResult::OKAY, "Rebooting bootloader");
		android::base::SetProperty(ANDROID_RB_PROPERTY, "reboot,bootloader");
		device->CloseDevice();
		TEMP_FAILURE_RETRY(pause());
		return result;
		}

		bool RebootFastbootHandler(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		auto result = device->WriteStatus(FastbootResult::OKAY, "Rebooting fastboot");
		android::base::SetProperty(ANDROID_RB_PROPERTY, "reboot,fastboot");
		device->CloseDevice();
		TEMP_FAILURE_RETRY(pause());
		return result;
		}

		static bool EnterRecovery() {
		const char msg_switch_to_recovery = 'r';

		android::base::unique_fd sock(socket(AF_UNIX, SOCK_STREAM, 0));
		if (sock < 0) {
		PLOG(ERROR) << "Couldn't create sock";
		return false;
		}

		struct sockaddr_un addr = {.sun_family = AF_UNIX};
		strncpy(addr.sun_path, "/dev/socket/recovery", sizeof(addr.sun_path) - 1);
		if (connect(sock, (struct sockaddr*)&addr, sizeof(addr)) < 0) {
		PLOG(ERROR) << "Couldn't connect to recovery";
		return false;
		}
		// Switch to recovery will not update the boot reason since it does not
		// require a reboot.
		auto ret = write(sock, &msg_switch_to_recovery, sizeof(msg_switch_to_recovery));
		if (ret != sizeof(msg_switch_to_recovery)) {
		PLOG(ERROR) << "Couldn't write message to switch to recovery";
		return false;
		}

		return true;
		}

		bool RebootRecoveryHandler(FastbootDevice* device, const std::vector<std::string>& /* args */) {
		auto status = true;
		if (EnterRecovery()) {
		status = device->WriteStatus(FastbootResult::OKAY, "Rebooting to recovery");
		} else {
		status = device->WriteStatus(FastbootResult::FAIL, "Unable to reboot to recovery");
		}
		device->CloseDevice();
		TEMP_FAILURE_RETRY(pause());
		return status;
		}

fastboot/device/commands.h

0 → 100644

+40 −0

Original line number	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.
		*/
		#pragma once

		#include <functional>
		#include <string>
		#include <vector>

		class FastbootDevice;

		enum class FastbootResult {
		OKAY,
		FAIL,
		INFO,
		DATA,
		};

		// Execute a command with the given arguments (possibly empty).
		using CommandHandler = std::function<bool(FastbootDevice*, const std::vector<std::string>&)>;

		bool DownloadHandler(FastbootDevice* device, const std::vector<std::string>& args);
		bool SetActiveHandler(FastbootDevice* device, const std::vector<std::string>& args);
		bool ShutDownHandler(FastbootDevice* device, const std::vector<std::string>& args);
		bool RebootHandler(FastbootDevice* device, const std::vector<std::string>& args);
		bool RebootBootloaderHandler(FastbootDevice* device, const std::vector<std::string>& args);
		bool RebootFastbootHandler(FastbootDevice* device, const std::vector<std::string>& args);
		bool RebootRecoveryHandler(FastbootDevice* device, const std::vector<std::string>& args);

fastboot/device/fastboot_device.cpp

0 → 100644

+104 −0

Original line number	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 "fastboot_device.h"

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

		#include <algorithm>

		#include "constants.h"
		#include "usb_client.h"

		FastbootDevice::FastbootDevice()
		: kCommandMap({
		{FB_CMD_SET_ACTIVE, SetActiveHandler},
		{FB_CMD_DOWNLOAD, DownloadHandler},
		{FB_CMD_SHUTDOWN, ShutDownHandler},
		{FB_CMD_REBOOT, RebootHandler},
		{FB_CMD_REBOOT_BOOTLOADER, RebootBootloaderHandler},
		{FB_CMD_REBOOT_FASTBOOT, RebootFastbootHandler},
		{FB_CMD_REBOOT_RECOVERY, RebootRecoveryHandler},
		}),
		transport_(std::make_unique<ClientUsbTransport>()) {}

		FastbootDevice::~FastbootDevice() {
		CloseDevice();
		}

		void FastbootDevice::CloseDevice() {
		transport_->Close();
		}

		bool FastbootDevice::WriteStatus(FastbootResult result, const std::string& message) {
		constexpr size_t kResponseReasonSize = 4;
		constexpr size_t kNumResponseTypes = 4; // "FAIL", "OKAY", "INFO", "DATA"
		char buf[FB_RESPONSE_SZ];
		constexpr size_t kMaxMessageSize = sizeof(buf) - kResponseReasonSize;
		size_t msg_len = std::min(kMaxMessageSize, message.size());

		constexpr const char* kResultStrings[kNumResponseTypes] = {RESPONSE_OKAY, RESPONSE_FAIL,
		RESPONSE_INFO, RESPONSE_DATA};

		if (static_cast<size_t>(result) >= kNumResponseTypes) {
		return false;
		}

		memcpy(buf, kResultStrings[static_cast<size_t>(result)], kResponseReasonSize);
		memcpy(buf + kResponseReasonSize, message.c_str(), msg_len);

		size_t response_len = kResponseReasonSize + msg_len;
		auto write_ret = this->get_transport()->Write(buf, response_len);
		if (write_ret != static_cast<ssize_t>(response_len)) {
		PLOG(ERROR) << "Failed to write " << message;
		return false;
		}

		return true;
		}

		bool FastbootDevice::HandleData(bool read, std::vector<char>* data) {
		auto read_write_data_size = read ? this->get_transport()->Read(data->data(), data->size())
		: this->get_transport()->Write(data->data(), data->size());
		if (read_write_data_size == -1 \|\| static_cast<size_t>(read_write_data_size) != data->size()) {
		return false;
		}
		return true;
		}

		void FastbootDevice::ExecuteCommands() {
		char command[FB_RESPONSE_SZ + 1];
		for (;;) {
		auto bytes_read = transport_->Read(command, FB_RESPONSE_SZ);
		if (bytes_read == -1) {
		PLOG(ERROR) << "Couldn't read command";
		return;
		}
		command[bytes_read] = '\0';

		LOG(INFO) << "Fastboot command: " << command;
		auto args = android::base::Split(command, ":");
		auto found_command = kCommandMap.find(args[0]);
		if (found_command == kCommandMap.end()) {
		WriteStatus(FastbootResult::FAIL, "Unrecognized command");
		continue;
		}
		if (!found_command->second(this, args)) {
		return;
		}
		}
		}