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

Merge "Move apply_from_sdcard to fuse_sdcard_install"

Browse source
This commit is contained in:
Tianjie Xu 2019-03-20 17:43:46 +00:00 committed by Gerrit Code Review
commit 3c61cd02cf
4 changed files with 193 additions and 184 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
adb_install.cpp
View file

@ -35,7 +35,6 @@
#include "ui.h" #include "ui.h"
int apply_from_adb(bool* wipe_cache) { int apply_from_adb(bool* wipe_cache) {
modified_flash = true;
// Save the usb state to restore after the sideload operation. // Save the usb state to restore after the sideload operation.
std::string usb_state = android::base::GetProperty("sys.usb.state", "none"); std::string usb_state = android::base::GetProperty("sys.usb.state", "none");
// Clean up state and stop adbd. // Clean up state and stop adbd.

168
fuse_sdcard_install.cpp
View file

@ -16,16 +16,110 @@
#include "fuse_sdcard_install.h" #include "fuse_sdcard_install.h"
#include <dirent.h>
#include <signal.h>
#include <sys/mount.h> #include <sys/mount.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h> #include <unistd.h>
#include <algorithm>
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <vector>
#include <android-base/logging.h>
#include <android-base/strings.h>
#include "bootloader_message/bootloader_message.h"
#include "fuse_provider.h" #include "fuse_provider.h"
#include "fuse_sideload.h" #include "fuse_sideload.h"
#include "install.h"
#include "roots.h"
bool start_sdcard_fuse(const char* path) { static constexpr const char* SDCARD_ROOT = "/sdcard";
// How long (in seconds) we wait for the fuse-provided package file to
// appear, before timing out.
static constexpr int SDCARD_INSTALL_TIMEOUT = 10;
// Set the BCB to reboot back into recovery (it won't resume the install from
// sdcard though).
static void SetSdcardUpdateBootloaderMessage() {
std::vector<std::string> options;
std::string err;
if (!update_bootloader_message(options, &err)) {
LOG(ERROR) << "Failed to set BCB message: " << err;
}
}
// Returns the selected filename, or an empty string.
static std::string BrowseDirectory(const std::string& path, Device* device, RecoveryUI* ui) {
ensure_path_mounted(path);
std::unique_ptr<DIR, decltype(&closedir)> d(opendir(path.c_str()), closedir);
if (!d) {
PLOG(ERROR) << "error opening " << path;
return "";
}
std::vector<std::string> dirs;
std::vector<std::string> entries{ "../" }; // "../" is always the first entry.
dirent* de;
while ((de = readdir(d.get())) != nullptr) {
std::string name(de->d_name);
if (de->d_type == DT_DIR) {
// Skip "." and ".." entries.
if (name == "." || name == "..") continue;
dirs.push_back(name + "/");
} else if (de->d_type == DT_REG && android::base::EndsWithIgnoreCase(name, ".zip")) {
entries.push_back(name);
}
}
std::sort(dirs.begin(), dirs.end());
std::sort(entries.begin(), entries.end());
// Append dirs to the entries list.
entries.insert(entries.end(), dirs.begin(), dirs.end());
std::vector<std::string> headers{ "Choose a package to install:", path };
size_t chosen_item = 0;
while (true) {
chosen_item = ui->ShowMenu(
headers, entries, chosen_item, true,
std::bind(&Device::HandleMenuKey, device, std::placeholders::_1, std::placeholders::_2));
// Return if WaitKey() was interrupted.
if (chosen_item == static_cast<size_t>(RecoveryUI::KeyError::INTERRUPTED)) {
return "";
}
const std::string& item = entries[chosen_item];
if (chosen_item == 0) {
// Go up but continue browsing (if the caller is BrowseDirectory).
return "";
}
std::string new_path = path + "/" + item;
if (new_path.back() == '/') {
// Recurse down into a subdirectory.
new_path.pop_back();
std::string result = BrowseDirectory(new_path, device, ui);
if (!result.empty()) return result;
} else {
// Selected a zip file: return the path to the caller.
return new_path;
}
}
// Unreachable.
}
static bool StartSdcardFuse(const std::string& path) {
auto file_data_reader = std::make_unique<FuseFileDataProvider>(path, 65536); auto file_data_reader = std::make_unique<FuseFileDataProvider>(path, 65536);
if (!file_data_reader->Valid()) { if (!file_data_reader->Valid()) {
@ -38,3 +132,75 @@ bool start_sdcard_fuse(const char* path) {
return run_fuse_sideload(std::move(file_data_reader)) == 0; return run_fuse_sideload(std::move(file_data_reader)) == 0;
} }
int ApplyFromSdcard(Device* device, bool* wipe_cache, RecoveryUI* ui) {
if (ensure_path_mounted(SDCARD_ROOT) != 0) {
LOG(ERROR) << "\n-- Couldn't mount " << SDCARD_ROOT << ".\n";
return INSTALL_ERROR;
}
std::string path = BrowseDirectory(SDCARD_ROOT, device, ui);
if (path.empty()) {
LOG(ERROR) << "\n-- No package file selected.\n";
ensure_path_unmounted(SDCARD_ROOT);
return INSTALL_ERROR;
}
ui->Print("\n-- Install %s ...\n", path.c_str());
SetSdcardUpdateBootloaderMessage();
// We used to use fuse in a thread as opposed to a process. Since accessing
// through fuse involves going from kernel to userspace to kernel, it leads
// to deadlock when a page fault occurs. (Bug: 26313124)
pid_t child;
if ((child = fork()) == 0) {
bool status = StartSdcardFuse(path);
_exit(status ? EXIT_SUCCESS : EXIT_FAILURE);
}
// FUSE_SIDELOAD_HOST_PATHNAME will start to exist once the fuse in child
// process is ready.
int result = INSTALL_ERROR;
int status;
bool waited = false;
for (int i = 0; i < SDCARD_INSTALL_TIMEOUT; ++i) {
if (waitpid(child, &status, WNOHANG) == -1) {
result = INSTALL_ERROR;
waited = true;
break;
}
struct stat sb;
if (stat(FUSE_SIDELOAD_HOST_PATHNAME, &sb) == -1) {
if (errno == ENOENT && i < SDCARD_INSTALL_TIMEOUT - 1) {
sleep(1);
continue;
} else {
LOG(ERROR) << "Timed out waiting for the fuse-provided package.";
result = INSTALL_ERROR;
kill(child, SIGKILL);
break;
}
}
result = install_package(FUSE_SIDELOAD_HOST_PATHNAME, wipe_cache, false, 0 /*retry_count*/);
break;
}
if (!waited) {
// Calling stat() on this magic filename signals the fuse
// filesystem to shut down.
struct stat sb;
stat(FUSE_SIDELOAD_HOST_EXIT_PATHNAME, &sb);
waitpid(child, &status, 0);
}
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
LOG(ERROR) << "Error exit from the fuse process: " << WEXITSTATUS(status);
}
ensure_path_unmounted(SDCARD_ROOT);
return result;
}

5
fuse_sdcard_install.h
View file

@ -16,4 +16,7 @@
#pragma once #pragma once
bool start_sdcard_fuse(const char* path); #include "device.h"
#include "ui.h"
int ApplyFromSdcard(Device* device, bool* wipe_cache, RecoveryUI* ui);

203
recovery.cpp
View file

@ -17,7 +17,6 @@
#include "recovery.h" #include "recovery.h"
#include <ctype.h> #include <ctype.h>
#include <dirent.h>
#include <errno.h> #include <errno.h>
#include <fcntl.h> #include <fcntl.h>
#include <getopt.h> #include <getopt.h>
@ -31,7 +30,6 @@
#include <string.h> #include <string.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <sys/types.h> #include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h> #include <unistd.h>
#include <algorithm> #include <algorithm>
@ -57,7 +55,6 @@
#include "device.h" #include "device.h"
#include "fsck_unshare_blocks.h" #include "fsck_unshare_blocks.h"
#include "fuse_sdcard_install.h" #include "fuse_sdcard_install.h"
#include "fuse_sideload.h"
#include "install.h" #include "install.h"
#include "logging.h" #include "logging.h"
#include "otautil/dirutil.h" #include "otautil/dirutil.h"
@ -78,7 +75,6 @@ static constexpr const char* LOCALE_FILE = "/cache/recovery/last_locale";
static constexpr const char* CACHE_ROOT = "/cache"; static constexpr const char* CACHE_ROOT = "/cache";
static constexpr const char* DATA_ROOT = "/data"; static constexpr const char* DATA_ROOT = "/data";
static constexpr const char* METADATA_ROOT = "/metadata"; static constexpr const char* METADATA_ROOT = "/metadata";
static constexpr const char* SDCARD_ROOT = "/sdcard";
// We define RECOVERY_API_VERSION in Android.mk, which will be picked up by build system and packed // We define RECOVERY_API_VERSION in Android.mk, which will be picked up by build system and packed
// into target_files.zip. Assert the version defined in code and in Android.mk are consistent. // into target_files.zip. Assert the version defined in code and in Android.mk are consistent.
@ -138,16 +134,6 @@ bool is_ro_debuggable() {
return android::base::GetBoolProperty("ro.debuggable", false); return android::base::GetBoolProperty("ro.debuggable", false);
} }
// Set the BCB to reboot back into recovery (it won't resume the install from
// sdcard though).
static void set_sdcard_update_bootloader_message() {
std::vector<std::string> options;
std::string err;
if (!update_bootloader_message(options, &err)) {
LOG(ERROR) << "Failed to set BCB message: " << err;
}
}
// Clear the recovery command and prepare to boot a (hopefully working) system, // Clear the recovery command and prepare to boot a (hopefully working) system,
// copy our log file to cache as well (for the system to read). This function is // copy our log file to cache as well (for the system to read). This function is
// idempotent: call it as many times as you like. // idempotent: call it as many times as you like.
@ -293,72 +279,6 @@ bool SetUsbConfig(const std::string& state) {
return android::base::WaitForProperty("sys.usb.state", state); return android::base::WaitForProperty("sys.usb.state", state);
} }
// Returns the selected filename, or an empty string.
static std::string browse_directory(const std::string& path, Device* device) {
ensure_path_mounted(path);
std::unique_ptr<DIR, decltype(&closedir)> d(opendir(path.c_str()), closedir);
if (!d) {
PLOG(ERROR) << "error opening " << path;
return "";
}
std::vector<std::string> dirs;
std::vector<std::string> entries{ "../" }; // "../" is always the first entry.
dirent* de;
while ((de = readdir(d.get())) != nullptr) {
std::string name(de->d_name);
if (de->d_type == DT_DIR) {
// Skip "." and ".." entries.
if (name == "." || name == "..") continue;
dirs.push_back(name + "/");
} else if (de->d_type == DT_REG && android::base::EndsWithIgnoreCase(name, ".zip")) {
entries.push_back(name);
}
}
std::sort(dirs.begin(), dirs.end());
std::sort(entries.begin(), entries.end());
// Append dirs to the entries list.
entries.insert(entries.end(), dirs.begin(), dirs.end());
std::vector<std::string> headers{ "Choose a package to install:", path };
size_t chosen_item = 0;
while (true) {
chosen_item = ui->ShowMenu(
headers, entries, chosen_item, true,
std::bind(&Device::HandleMenuKey, device, std::placeholders::_1, std::placeholders::_2));
// Return if WaitKey() was interrupted.
if (chosen_item == static_cast<size_t>(RecoveryUI::KeyError::INTERRUPTED)) {
return "";
}
const std::string& item = entries[chosen_item];
if (chosen_item == 0) {
// Go up but continue browsing (if the caller is browse_directory).
return "";
}
std::string new_path = path + "/" + item;
if (new_path.back() == '/') {
// Recurse down into a subdirectory.
new_path.pop_back();
std::string result = browse_directory(new_path, device);
if (!result.empty()) return result;
} else {
// Selected a zip file: return the path to the caller.
return new_path;
}
}
// Unreachable.
}
static bool yes_no(Device* device, const char* question1, const char* question2) { static bool yes_no(Device* device, const char* question1, const char* question2) {
std::vector<std::string> headers{ question1, question2 }; std::vector<std::string> headers{ question1, question2 };
std::vector<std::string> items{ " No", " Yes" }; std::vector<std::string> items{ " No", " Yes" };
@ -709,85 +629,6 @@ static void run_graphics_test() {
ui->ShowText(true); ui->ShowText(true);
} }
// TODO(xunchang) move apply_from_sdcard() to fuse_sdcard_install.cpp
// How long (in seconds) we wait for the fuse-provided package file to
// appear, before timing out.
#define SDCARD_INSTALL_TIMEOUT 10
static int apply_from_sdcard(Device* device, bool* wipe_cache) {
modified_flash = true;
if (ensure_path_mounted(SDCARD_ROOT) != 0) {
ui->Print("\n-- Couldn't mount %s.\n", SDCARD_ROOT);
return INSTALL_ERROR;
}
std::string path = browse_directory(SDCARD_ROOT, device);
if (path.empty()) {
ui->Print("\n-- No package file selected.\n");
ensure_path_unmounted(SDCARD_ROOT);
return INSTALL_ERROR;
}
ui->Print("\n-- Install %s ...\n", path.c_str());
set_sdcard_update_bootloader_message();
// We used to use fuse in a thread as opposed to a process. Since accessing
// through fuse involves going from kernel to userspace to kernel, it leads
// to deadlock when a page fault occurs. (Bug: 26313124)
pid_t child;
if ((child = fork()) == 0) {
bool status = start_sdcard_fuse(path.c_str());
_exit(status ? EXIT_SUCCESS : EXIT_FAILURE);
}
// FUSE_SIDELOAD_HOST_PATHNAME will start to exist once the fuse in child
// process is ready.
int result = INSTALL_ERROR;
int status;
bool waited = false;
for (int i = 0; i < SDCARD_INSTALL_TIMEOUT; ++i) {
if (waitpid(child, &status, WNOHANG) == -1) {
result = INSTALL_ERROR;
waited = true;
break;
}
struct stat sb;
if (stat(FUSE_SIDELOAD_HOST_PATHNAME, &sb) == -1) {
if (errno == ENOENT && i < SDCARD_INSTALL_TIMEOUT-1) {
sleep(1);
continue;
} else {
LOG(ERROR) << "Timed out waiting for the fuse-provided package.";
result = INSTALL_ERROR;
kill(child, SIGKILL);
break;
}
}
result = install_package(FUSE_SIDELOAD_HOST_PATHNAME, wipe_cache, false, 0 /*retry_count*/);
break;
}
if (!waited) {
// Calling stat() on this magic filename signals the fuse
// filesystem to shut down.
struct stat sb;
stat(FUSE_SIDELOAD_HOST_EXIT_PATHNAME, &sb);
waitpid(child, &status, 0);
}
if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
LOG(ERROR) << "Error exit from the fuse process: " << WEXITSTATUS(status);
}
ensure_path_unmounted(SDCARD_ROOT);
return result;
}
// Returns REBOOT, SHUTDOWN, or REBOOT_BOOTLOADER. Returning NO_ACTION means to take the default, // Returns REBOOT, SHUTDOWN, or REBOOT_BOOTLOADER. Returning NO_ACTION means to take the default,
// which is to reboot or shutdown depending on if the --shutdown_after flag was passed to recovery. // which is to reboot or shutdown depending on if the --shutdown_after flag was passed to recovery.
static Device::BuiltinAction prompt_and_wait(Device* device, int status) { static Device::BuiltinAction prompt_and_wait(Device* device, int status) {
@ -849,32 +690,32 @@ static Device::BuiltinAction prompt_and_wait(Device* device, int status) {
break; break;
case Device::APPLY_ADB_SIDELOAD: case Device::APPLY_ADB_SIDELOAD:
case Device::APPLY_SDCARD: case Device::APPLY_SDCARD: {
{ modified_flash = true;
bool adb = (chosen_action == Device::APPLY_ADB_SIDELOAD); bool adb = (chosen_action == Device::APPLY_ADB_SIDELOAD);
if (adb) { if (adb) {
status = apply_from_adb(&should_wipe_cache); status = apply_from_adb(&should_wipe_cache);
} else { } else {
status = apply_from_sdcard(device, &should_wipe_cache); status = ApplyFromSdcard(device, &should_wipe_cache, ui);
} }
if (status == INSTALL_SUCCESS && should_wipe_cache) { if (status == INSTALL_SUCCESS && should_wipe_cache) {
if (!wipe_cache(false, device)) { if (!wipe_cache(false, device)) {
status = INSTALL_ERROR; status = INSTALL_ERROR;
}
}
if (status != INSTALL_SUCCESS) {
ui->SetBackground(RecoveryUI::ERROR);
ui->Print("Installation aborted.\n");
copy_logs(modified_flash, has_cache);
} 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");
} }
} }
if (status != INSTALL_SUCCESS) {
ui->SetBackground(RecoveryUI::ERROR);
ui->Print("Installation aborted.\n");
copy_logs(modified_flash, has_cache);
} 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; break;
}
case Device::VIEW_RECOVERY_LOGS: case Device::VIEW_RECOVERY_LOGS:
choose_recovery_file(device); choose_recovery_file(device);