Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 3cc23d5e authored by xunchang's avatar xunchang
Browse files

Move apply_from_sdcard to fuse_sdcard_install 

Move the sdcard installation function and all helper functions to a
separate file, and drop the dependency on common.h.

In the future, we want to move these functions into the install class.

Bug: 127071893
Test: unit tests pass
Change-Id: I0b7f7cbf0b68918e638e13878ca28bfca367088a
parent 5e6832a2

adb_install.cpp

+0 −1
Original line number Diff line number Diff line
@@ -35,7 +35,6 @@ 
#include "ui.h"



int apply_from_adb(bool* wipe_cache) {

  modified_flash = true;

  // 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.

fuse_sdcard_install.cpp

+167 −1
Original line number Diff line number Diff line
@@ -16,16 +16,110 @@ 


#include "fuse_sdcard_install.h"



#include <dirent.h>

#include <signal.h>

#include <sys/mount.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <unistd.h>



#include <algorithm>

#include <functional>

#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_sideload.h"

#include "install.h"

#include "roots.h"



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;

    }

  }



bool start_sdcard_fuse(const char* path) {

  // Unreachable.

}



static bool StartSdcardFuse(const std::string& path) {

  auto file_data_reader = std::make_unique<FuseFileDataProvider>(path, 65536);



  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;

}



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;

}

fuse_sdcard_install.h

+4 −1
Original line number Diff line number Diff line
@@ -16,4 +16,7 @@ 


#pragma once



bool start_sdcard_fuse(const char* path);
 
#include "device.h"

#include "ui.h"



int ApplyFromSdcard(Device* device, bool* wipe_cache, RecoveryUI* ui);

recovery.cpp

+21 −180
Original line number Diff line number Diff line
@@ -17,7 +17,6 @@ 
#include "recovery.h"



#include <ctype.h>

#include <dirent.h>

#include <errno.h>

#include <fcntl.h>

#include <getopt.h>
@@ -31,7 +30,6 @@ 
#include <string.h>

#include <sys/stat.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <unistd.h>



#include <algorithm>
@@ -57,7 +55,6 @@ 
#include "device.h"

#include "fsck_unshare_blocks.h"

#include "fuse_sdcard_install.h"

#include "fuse_sideload.h"

#include "install.h"

#include "logging.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* DATA_ROOT = "/data";

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

// 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);

}



// 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,

// 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.
@@ -293,72 +279,6 @@ bool SetUsbConfig(const std::string& 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) {

  std::vector<std::string> headers{ question1, question2 };

  std::vector<std::string> items{ " No", " Yes" };
@@ -709,85 +629,6 @@ static void run_graphics_test() { 
  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,

// 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) {
@@ -849,13 +690,13 @@ static Device::BuiltinAction prompt_and_wait(Device* device, int status) { 
        break;



      case Device::APPLY_ADB_SIDELOAD:

      case Device::APPLY_SDCARD:

        {

      case Device::APPLY_SDCARD: {

        modified_flash = true;

        bool adb = (chosen_action == Device::APPLY_ADB_SIDELOAD);

        if (adb) {

          status = apply_from_adb(&should_wipe_cache);

        } else {

            status = apply_from_sdcard(device, &should_wipe_cache);

          status = ApplyFromSdcard(device, &should_wipe_cache, ui);

        }



        if (status == INSTALL_SUCCESS && should_wipe_cache) {
@@ -873,8 +714,8 @@ static Device::BuiltinAction prompt_and_wait(Device* device, int status) { 
        } else {

          ui->Print("\nInstall from %s complete.\n", adb ? "ADB" : "SD card");

        }

        }

        break;

      }



      case Device::VIEW_RECOVERY_LOGS:

        choose_recovery_file(device);