tequilaOS/platform_bootable_recovery
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge "minadbd: Support adb reboot under sideload/rescue modes."

Browse source
This commit is contained in:
Tao Bao 2019-04-24 20:33:18 +00:00 committed by Gerrit Code Review
commit cf1f715d62
9 changed files with 176 additions and 60 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

98
install/adb_install.cpp
View file

@ -31,6 +31,7 @@
#include <atomic>
#include <functional>
#include <map>
#include <utility>
#include <vector>
#include <android-base/file.h>
@ -44,30 +45,34 @@
#include "install/install.h"
#include "minadbd_types.h"
#include "otautil/sysutil.h"
#include "recovery_ui/device.h"
#include "recovery_ui/ui.h"
using CommandFunction = std::function<bool()>;
// A CommandFunction returns a pair of (result, should_continue), which indicates the command
// execution result and whether it should proceed to the next iteration. The execution result will
// always be sent to the minadbd side.
using CommandFunction = std::function<std::pair<bool, bool>()>;
static bool SetUsbConfig(const std::string& state) {
android::base::SetProperty("sys.usb.config", state);
return android::base::WaitForProperty("sys.usb.state", state);
}
// Parses the minadbd command in |message|; returns MinadbdCommands::kError upon errors.
static MinadbdCommands ParseMinadbdCommands(const std::string& message) {
// Parses the minadbd command in |message|; returns MinadbdCommand::kError upon errors.
static MinadbdCommand ParseMinadbdCommand(const std::string& message) {
if (!android::base::StartsWith(message, kMinadbdCommandPrefix)) {
LOG(ERROR) << "Failed to parse command in message " << message;
return MinadbdCommands::kError;
return MinadbdCommand::kError;
}
auto cmd_code_string = message.substr(strlen(kMinadbdCommandPrefix));
auto cmd_code = android::base::get_unaligned<uint32_t>(cmd_code_string.c_str());
if (cmd_code >= static_cast<uint32_t>(MinadbdCommands::kError)) {
if (cmd_code >= static_cast<uint32_t>(MinadbdCommand::kError)) {
LOG(ERROR) << "Unsupported command code: " << cmd_code;
return MinadbdCommands::kError;
return MinadbdCommand::kError;
}
return static_cast<MinadbdCommands>(cmd_code);
return static_cast<MinadbdCommand>(cmd_code);
}
static bool WriteStatusToFd(MinadbdCommandStatus status, int fd) {
@ -82,13 +87,15 @@ static bool WriteStatusToFd(MinadbdCommandStatus status, int fd) {
return true;
}
// Installs the package from FUSE. Returns true if the installation succeeds, and false otherwise.
static bool AdbInstallPackageHandler(RecoveryUI* ui, int* result) {
// Installs the package from FUSE. Returns the installation result and whether it should continue
// waiting for new commands.
static auto AdbInstallPackageHandler(RecoveryUI* ui, int* result) {
// How long (in seconds) we wait for the package path to be ready. It doesn't need to be too long
// because the minadbd service has already issued an install command. FUSE_SIDELOAD_HOST_PATHNAME
// will start to exist once the host connects and starts serving a package. Poll for its
// appearance. (Note that inotify doesn't work with FUSE.)
constexpr int ADB_INSTALL_TIMEOUT = 15;
bool should_continue = true;
*result = INSTALL_ERROR;
for (int i = 0; i < ADB_INSTALL_TIMEOUT; ++i) {
struct stat st;
@ -97,6 +104,7 @@ static bool AdbInstallPackageHandler(RecoveryUI* ui, int* result) {
sleep(1);
continue;
} else {
should_continue = false;
ui->Print("\nTimed out waiting for fuse to be ready.\n\n");
break;
}
@ -108,13 +116,39 @@ static bool AdbInstallPackageHandler(RecoveryUI* ui, int* result) {
// Calling stat() on this magic filename signals the FUSE to exit.
struct stat st;
stat(FUSE_SIDELOAD_HOST_EXIT_PATHNAME, &st);
return *result == INSTALL_SUCCESS;
return std::make_pair(*result == INSTALL_SUCCESS, should_continue);
}
// Parses and executes the command from minadbd. Returns false if we enter an invalid state so that
// the caller can kill the minadbd service properly.
static bool HandleMessageFromMinadbd(
int socket_fd, const std::map<MinadbdCommands, CommandFunction>& command_map) {
static auto AdbRebootHandler(MinadbdCommand command, int* result,
Device::BuiltinAction* reboot_action) {
switch (command) {
case MinadbdCommand::kRebootBootloader:
*reboot_action = Device::REBOOT_BOOTLOADER;
break;
case MinadbdCommand::kRebootFastboot:
*reboot_action = Device::ENTER_FASTBOOT;
break;
case MinadbdCommand::kRebootRecovery:
*reboot_action = Device::ENTER_RECOVERY;
break;
case MinadbdCommand::kRebootRescue:
// Use Device::REBOOT_RESCUE instead of Device::ENTER_RESCUE. This allows rebooting back into
// rescue mode (potentially using a newly installed recovery image).
*reboot_action = Device::REBOOT_RESCUE;
break;
case MinadbdCommand::kRebootAndroid:
default:
*reboot_action = Device::REBOOT;
break;
}
*result = INSTALL_REBOOT;
return std::make_pair(true, false);
}
// Parses and executes the command from minadbd. Returns whether the caller should keep waiting for
// next command.
static bool HandleMessageFromMinadbd(int socket_fd,
const std::map<MinadbdCommand, CommandFunction>& command_map) {
char buffer[kMinadbdMessageSize];
if (!android::base::ReadFully(socket_fd, buffer, kMinadbdMessageSize)) {
PLOG(ERROR) << "Failed to read message from minadbd";
@ -122,8 +156,8 @@ static bool HandleMessageFromMinadbd(
}
std::string message(buffer, buffer + kMinadbdMessageSize);
auto command_type = ParseMinadbdCommands(message);
if (command_type == MinadbdCommands::kError) {
auto command_type = ParseMinadbdCommand(message);
if (command_type == MinadbdCommand::kError) {
return false;
}
if (command_map.find(command_type) == command_map.end()) {
@ -135,17 +169,19 @@ static bool HandleMessageFromMinadbd(
// We have received a valid command, execute the corresponding function.
const auto& command_func = command_map.at(command_type);
if (!command_func()) {
LOG(ERROR) << "Failed to execute command " << static_cast<unsigned int>(command_type);
return WriteStatusToFd(MinadbdCommandStatus::kFailure, socket_fd);
const auto [result, should_continue] = command_func();
LOG(INFO) << "Command " << static_cast<uint32_t>(command_type) << " finished with " << result;
if (!WriteStatusToFd(result ? MinadbdCommandStatus::kSuccess : MinadbdCommandStatus::kFailure,
socket_fd)) {
return false;
}
return WriteStatusToFd(MinadbdCommandStatus::kSuccess, socket_fd);
return should_continue;
}
// TODO(xunchang) add a wrapper function and kill the minadbd service there.
static void ListenAndExecuteMinadbdCommands(
pid_t minadbd_pid, android::base::unique_fd&& socket_fd,
const std::map<MinadbdCommands, CommandFunction>& command_map) {
const std::map<MinadbdCommand, CommandFunction>& command_map) {
android::base::unique_fd epoll_fd(epoll_create1(O_CLOEXEC));
if (epoll_fd == -1) {
PLOG(ERROR) << "Failed to create epoll";
@ -230,7 +266,7 @@ static void ListenAndExecuteMinadbdCommands(
// b11. exit the listening loop
//
static void CreateMinadbdServiceAndExecuteCommands(
const std::map<MinadbdCommands, CommandFunction>& command_map, bool rescue_mode) {
const std::map<MinadbdCommand, CommandFunction>& command_map, bool rescue_mode) {
signal(SIGPIPE, SIG_IGN);
android::base::unique_fd recovery_socket;
@ -271,7 +307,6 @@ static void CreateMinadbdServiceAndExecuteCommands(
std::thread listener_thread(ListenAndExecuteMinadbdCommands, child, std::move(recovery_socket),
std::ref(command_map));
if (listener_thread.joinable()) {
listener_thread.join();
}
@ -289,7 +324,7 @@ static void CreateMinadbdServiceAndExecuteCommands(
signal(SIGPIPE, SIG_DFL);
}
int ApplyFromAdb(RecoveryUI* ui, bool rescue_mode) {
int ApplyFromAdb(RecoveryUI* ui, bool rescue_mode, Device::BuiltinAction* reboot_action) {
// Save the usb state to restore after the sideload operation.
std::string usb_state = android::base::GetProperty("sys.usb.state", "none");
// Clean up state and stop adbd.
@ -307,8 +342,19 @@ int ApplyFromAdb(RecoveryUI* ui, bool rescue_mode) {
}
int install_result = INSTALL_ERROR;
std::map<MinadbdCommands, CommandFunction> command_map{
{ MinadbdCommands::kInstall, std::bind(&AdbInstallPackageHandler, ui, &install_result) },
std::map<MinadbdCommand, CommandFunction> command_map{
{ MinadbdCommand::kInstall, std::bind(&AdbInstallPackageHandler, ui, &install_result) },
{ MinadbdCommand::kRebootAndroid, std::bind(&AdbRebootHandler, MinadbdCommand::kRebootAndroid,
&install_result, reboot_action) },
{ MinadbdCommand::kRebootBootloader,
std::bind(&AdbRebootHandler, MinadbdCommand::kRebootBootloader, &install_result,
reboot_action) },
{ MinadbdCommand::kRebootFastboot, std::bind(&AdbRebootHandler, MinadbdCommand::kRebootFastboot,
&install_result, reboot_action) },
{ MinadbdCommand::kRebootRecovery, std::bind(&AdbRebootHandler, MinadbdCommand::kRebootRecovery,
&install_result, reboot_action) },
{ MinadbdCommand::kRebootRescue,
std::bind(&AdbRebootHandler, MinadbdCommand::kRebootRescue, &install_result, reboot_action) },
};
CreateMinadbdServiceAndExecuteCommands(command_map, rescue_mode);

6
install/include/install/adb_install.h
View file

@ -16,6 +16,10 @@
#pragma once
#include <recovery_ui/device.h>
#include <recovery_ui/ui.h>
int ApplyFromAdb(RecoveryUI* ui, bool rescue_mode);
// Applies a package via `adb sideload` or `adb rescue`. Returns the install result (in `enum
// InstallResult`). When a reboot has been requested, INSTALL_REBOOT will be the return value, with
// the reboot target set in reboot_action.
int ApplyFromAdb(RecoveryUI* ui, bool rescue_mode, Device::BuiltinAction* reboot_action);

3
install/include/install/install.h
View file

@ -34,7 +34,8 @@ enum InstallResult {
INSTALL_NONE,
INSTALL_SKIPPED,
INSTALL_RETRY,
INSTALL_KEY_INTERRUPTED
INSTALL_KEY_INTERRUPTED,
INSTALL_REBOOT,
};
enum class OtaType {

43
minadbd/minadbd_services.cpp
View file

@ -64,7 +64,7 @@ void SetSideloadMountPoint(const std::string& path) {
sideload_mount_point = path;
}
static bool WriteCommandToFd(MinadbdCommands cmd, int fd) {
static bool WriteCommandToFd(MinadbdCommand cmd, int fd) {
char message[kMinadbdMessageSize];
memcpy(message, kMinadbdCommandPrefix, strlen(kMinadbdStatusPrefix));
android::base::put_unaligned(message + strlen(kMinadbdStatusPrefix), cmd);
@ -109,7 +109,7 @@ static MinadbdErrorCode RunAdbFuseSideload(int sfd, const std::string& args,
LOG(INFO) << "sideload-host file size " << file_size << ", block size " << block_size;
if (!WriteCommandToFd(MinadbdCommands::kInstall, minadbd_socket)) {
if (!WriteCommandToFd(MinadbdCommand::kInstall, minadbd_socket)) {
return kMinadbdSocketIOError;
}
@ -175,7 +175,45 @@ static void RescueGetpropHostService(unique_fd sfd, const std::string& prop) {
}
}
// Reboots into the given target. We don't reboot directly from minadbd, but going through recovery
// instead. This allows recovery to finish all the pending works (clear BCB, save logs etc) before
// the reboot.
static void RebootHostService(unique_fd /* sfd */, const std::string& target) {
MinadbdCommand command;
if (target == "bootloader") {
command = MinadbdCommand::kRebootBootloader;
} else if (target == "rescue") {
command = MinadbdCommand::kRebootRescue;
} else if (target == "recovery") {
command = MinadbdCommand::kRebootRecovery;
} else if (target == "fastboot") {
command = MinadbdCommand::kRebootFastboot;
} else {
command = MinadbdCommand::kRebootAndroid;
}
if (!WriteCommandToFd(command, minadbd_socket)) {
exit(kMinadbdSocketIOError);
}
MinadbdCommandStatus status;
if (!WaitForCommandStatus(minadbd_socket, &status)) {
exit(kMinadbdMessageFormatError);
}
}
unique_fd daemon_service_to_fd(std::string_view name, atransport* /* transport */) {
// Common services that are supported both in sideload and rescue modes.
if (ConsumePrefix(&name, "reboot:")) {
// "reboot:<target>", where target must be one of the following.
std::string args(name);
if (args.empty() || args == "bootloader" || args == "rescue" || args == "recovery" ||
args == "fastboot") {
return create_service_thread("reboot",
std::bind(RebootHostService, std::placeholders::_1, args));
}
return unique_fd{};
}
// Rescue-specific services.
if (rescue_mode) {
if (ConsumePrefix(&name, "rescue-install:")) {
// rescue-install:<file-size>:<block-size>
@ -191,6 +229,7 @@ unique_fd daemon_service_to_fd(std::string_view name, atransport* /* transport *
return unique_fd{};
}
// Sideload-specific services.
if (name.starts_with("sideload:")) {
// This exit status causes recovery to print a special error message saying to use a newer adb
// (that supports sideload-host).

6
minadbd/minadbd_services_test.cpp
View file

@ -62,7 +62,7 @@ class MinadbdServicesTest : public ::testing::Test {
signal(SIGPIPE, SIG_DFL);
}
void ReadAndCheckCommandMessage(int fd, MinadbdCommands expected_command) {
void ReadAndCheckCommandMessage(int fd, MinadbdCommand expected_command) {
std::vector<uint8_t> received(kMinadbdMessageSize, '\0');
ASSERT_TRUE(android::base::ReadFully(fd, received.data(), kMinadbdMessageSize));
@ -147,7 +147,7 @@ TEST_F(MinadbdServicesTest, SideloadHostService_wrong_command_format) {
unique_fd fd = daemon_service_to_fd(command, nullptr);
ASSERT_NE(-1, fd);
WaitForFusePath();
ReadAndCheckCommandMessage(recovery_socket_, MinadbdCommands::kInstall);
ReadAndCheckCommandMessage(recovery_socket_, MinadbdCommand::kInstall);
struct stat sb;
ASSERT_EQ(0, stat(exit_flag_.c_str(), &sb));
@ -188,7 +188,7 @@ TEST_F(MinadbdServicesTest, SideloadHostService_read_data_from_fuse) {
unique_fd fd = daemon_service_to_fd("sideload-host:4096:4096", nullptr);
ASSERT_NE(-1, fd);
ReadAndCheckCommandMessage(recovery_socket_, MinadbdCommands::kInstall);
ReadAndCheckCommandMessage(recovery_socket_, MinadbdCommand::kInstall);
// Mimic the response from adb host.
std::string adb_message(8, '\0');

13
minadbd/minadbd_types.h
View file

@ -43,12 +43,19 @@ enum class MinadbdCommandStatus : uint32_t {
kFailure = 1,
};
enum class MinadbdCommands : uint32_t {
enum class MinadbdCommand : uint32_t {
kInstall = 0,
kUiPrint = 1,
kError = 2,
kRebootAndroid = 2,
kRebootBootloader = 3,
kRebootFastboot = 4,
kRebootRecovery = 5,
kRebootRescue = 6,
// Last but invalid command.
kError,
};
static_assert(kMinadbdMessageSize == sizeof(kMinadbdCommandPrefix) - 1 + sizeof(MinadbdCommands));
static_assert(kMinadbdMessageSize == sizeof(kMinadbdCommandPrefix) - 1 + sizeof(MinadbdCommand));
static_assert(kMinadbdMessageSize ==
sizeof(kMinadbdStatusPrefix) - 1 + sizeof(MinadbdCommandStatus));

58
recovery.cpp
View file

@ -512,6 +512,7 @@ static Device::BuiltinAction prompt_and_wait(Device* device, int status) {
case Device::REBOOT:
case Device::SHUTDOWN:
case Device::REBOOT_BOOTLOADER:
case Device::REBOOT_RESCUE:
case Device::ENTER_FASTBOOT:
case Device::ENTER_RECOVERY:
return chosen_action;
@ -537,32 +538,36 @@ static Device::BuiltinAction prompt_and_wait(Device* device, int status) {
if (!ui->IsTextVisible()) return Device::NO_ACTION;
break;
}
case Device::APPLY_ADB_SIDELOAD:
case Device::APPLY_SDCARD:
case Device::ENTER_RESCUE: {
save_current_log = true;
bool adb = true;
Device::BuiltinAction reboot_action;
if (chosen_action == Device::ENTER_RESCUE) {
// Switch to graphics screen.
ui->ShowText(false);
status = ApplyFromAdb(ui, true /* rescue_mode */);
ui->ShowText(true);
status = ApplyFromAdb(ui, true /* rescue_mode */, &reboot_action);
} else if (chosen_action == Device::APPLY_ADB_SIDELOAD) {
status = ApplyFromAdb(ui, false /* rescue_mode */);
status = ApplyFromAdb(ui, false /* rescue_mode */, &reboot_action);
} else {
adb = false;
status = ApplyFromSdcard(device, ui);
}
ui->Print("\nInstall from %s completed with status %d.\n", adb ? "ADB" : "SD card", status);
if (status == INSTALL_REBOOT) {
return reboot_action;
}
if (status != INSTALL_SUCCESS) {
ui->SetBackground(RecoveryUI::ERROR);
ui->Print("Installation aborted.\n");
copy_logs(save_current_log, has_cache, sehandle);
} else if (!ui->IsTextVisible()) {
return Device::NO_ACTION; // reboot if logs aren't visible
} else {
ui->Print("\nInstall from %s complete.\n", adb ? "ADB" : "SD card");
}
break;
}
@ -841,6 +846,9 @@ Device::BuiltinAction start_recovery(Device* device, const std::vector<std::stri
ui->Print("Supported API: %d\n", kRecoveryApiVersion);
int status = INSTALL_SUCCESS;
// next_action indicates the next target to reboot into upon finishing the install. It could be
// overridden to a different reboot target per user request.
Device::BuiltinAction next_action = shutdown_after ? Device::SHUTDOWN : Device::REBOOT;
if (update_package != nullptr) {
// It's not entirely true that we will modify the flash. But we want
@ -924,19 +932,18 @@ Device::BuiltinAction start_recovery(Device* device, const std::vector<std::stri
status = INSTALL_ERROR;
}
} else if (sideload) {
// 'adb reboot sideload' acts the same as user presses key combinations
// to enter the sideload mode. When 'sideload-auto-reboot' is used, text
// display will NOT be turned on by default. And it will reboot after
// sideload finishes even if there are errors. Unless one turns on the
// text display during the installation. This is to enable automated
// 'adb reboot sideload' acts the same as user presses key combinations to enter the sideload
// mode. When 'sideload-auto-reboot' is used, text display will NOT be turned on by default. And
// it will reboot after sideload finishes even if there are errors. This is to enable automated
// testing.
save_current_log = true;
if (!sideload_auto_reboot) {
ui->ShowText(true);
}
status = ApplyFromAdb(ui, false /* rescue_mode */);
status = ApplyFromAdb(ui, false /* rescue_mode */, &next_action);
ui->Print("\nInstall from ADB complete (status: %d).\n", status);
if (sideload_auto_reboot) {
status = INSTALL_REBOOT;
ui->Print("Rebooting automatically.\n");
}
} else if (fsck_unshare_blocks) {
@ -961,23 +968,26 @@ Device::BuiltinAction start_recovery(Device* device, const std::vector<std::stri
}
}
Device::BuiltinAction after = shutdown_after ? Device::SHUTDOWN : Device::REBOOT;
// 1. If the recovery menu is visible, prompt and wait for commands.
// 2. If the state is INSTALL_NONE, wait for commands. (i.e. In user build, manually reboot into
// recovery to sideload a package.)
// 3. sideload_auto_reboot is an option only available in user-debug build, reboot the device
// without waiting.
// 4. In all other cases, reboot the device. Therefore, normal users will observe the device
// reboot after it shows the "error" screen for 5s.
if ((status == INSTALL_NONE && !sideload_auto_reboot) || ui->IsTextVisible()) {
Device::BuiltinAction temp = prompt_and_wait(device, status);
if (temp != Device::NO_ACTION) {
after = temp;
// Determine the next action.
// - If the state is INSTALL_REBOOT, device will reboot into the target as specified in
// `next_action`.
// - If the recovery menu is visible, prompt and wait for commands.
// - If the state is INSTALL_NONE, wait for commands (e.g. in user build, one manually boots
// into recovery to sideload a package or to wipe the device).
// - In all other cases, reboot the device. Therefore, normal users will observe the device
// rebooting a) immediately upon successful finish (INSTALL_SUCCESS); or b) an "error" screen
// for 5s followed by an automatic reboot.
if (status != INSTALL_REBOOT) {
if (status == INSTALL_NONE || ui->IsTextVisible()) {
Device::BuiltinAction temp = prompt_and_wait(device, status);
if (temp != Device::NO_ACTION) {
next_action = temp;
}
}
}
// Save logs and clean up before rebooting or shutting down.
finish_recovery();
return after;
return next_action;
}

5
recovery_main.cpp
View file

@ -477,6 +477,11 @@ int main(int argc, char** argv) {
android::base::SetProperty(ANDROID_RB_PROPERTY, "reboot,bootloader");
break;
case Device::REBOOT_RESCUE:
ui->Print("Rebooting to rescue...\n");
android::base::SetProperty(ANDROID_RB_PROPERTY, "reboot,rescue");
break;
case Device::ENTER_FASTBOOT:
if (logical_partitions_mapped()) {
ui->Print("Partitions may be mounted - rebooting to enter fastboot.");

4
recovery_ui/include/recovery_ui/device.h
View file

@ -50,7 +50,11 @@ class Device {
KEY_INTERRUPTED = 13,
ENTER_FASTBOOT = 14,
ENTER_RECOVERY = 15,
// ENTER vs REBOOT: The latter will trigger a reboot that uses `rescue` as the reboot target.
// So it goes from rescue -> bootloader -> rescue, whereas ENTER_RESCUE switches from recovery
// -> rescue directly.
ENTER_RESCUE = 16,
REBOOT_RESCUE = 17,
};
explicit Device(RecoveryUI* ui);