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

Commit f875de23 authored by Treehugger Robot's avatar Treehugger Robot Committed by Automerger Merge Worker
Browse files

Merge "Chang flash task to take in source" am: 059954a6 

Original change: https://android-review.googlesource.com/c/platform/system/core/+/2600795



Change-Id: I6b8ce50db02ff581384dfce4625b746e9cbee671
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 003175df 059954a6

fastboot/fastboot.cpp

+23 −24
Original line number Diff line number Diff line
@@ -1487,13 +1487,20 @@ static std::string repack_ramdisk(const char* pname, struct fastboot_buffer* buf 
    return partition;

}



void do_flash(const char* pname, const char* fname, const bool apply_vbmeta) {

void do_flash(const char* pname, const char* fname, const bool apply_vbmeta,

              const FlashingPlan* fp) {

    verbose("Do flash %s %s", pname, fname);

    struct fastboot_buffer buf;



    if (!load_buf(fname, &buf)) {

    if (fp->source) {

        unique_fd fd = fp->source->OpenFile(fname);

        if (fd < 0 || !load_buf_fd(std::move(fd), &buf)) {

            die("could not load '%s': %s", fname, strerror(errno));

        }

    } else if (!load_buf(fname, &buf)) {

        die("cannot load '%s': %s", fname, strerror(errno));

    }



    if (is_logical(pname)) {

        fb->ResizePartition(pname, std::to_string(buf.image_size));

    }
@@ -1592,7 +1599,7 @@ std::unique_ptr<FlashTask> ParseFlashCommand(const FlashingPlan* fp, 
    if (img_name.empty()) {

        img_name = partition + ".img";

    }

    return std::make_unique<FlashTask>(slot, partition, img_name, apply_vbmeta);

    return std::make_unique<FlashTask>(slot, partition, img_name, apply_vbmeta, fp);

}



std::unique_ptr<RebootTask> ParseRebootCommand(const FlashingPlan* fp,
@@ -1666,7 +1673,7 @@ void AddResizeTasks(const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>* 
}



static bool IsIgnore(const std::vector<std::string>& command) {

    if (command[0][0] == '#') {

    if (command.size() == 0 || command[0][0] == '#') {

        return true;

    }

    return false;
@@ -1748,16 +1755,6 @@ std::vector<std::unique_ptr<Task>> ParseFastbootInfo(const FlashingPlan* fp, 
    return tasks;

}



std::vector<std::unique_ptr<Task>> ParseFastbootInfo(const FlashingPlan* fp, std::ifstream& fs) {

    std::string text;

    std::vector<std::string> file;

    // Get os_partitions that need to be resized

    while (std::getline(fs, text)) {

        file.emplace_back(text);

    }

    return ParseFastbootInfo(fp, file);

}



FlashAllTool::FlashAllTool(FlashingPlan* fp) : fp_(fp) {}



void FlashAllTool::Flash() {
@@ -1777,16 +1774,17 @@ void FlashAllTool::Flash() { 


    CancelSnapshotIfNeeded();



    std::string path = find_item_given_name("fastboot-info.txt");

    std::ifstream stream(path);

    if (!stream || stream.eof()) {

    std::vector<char> contents;

    if (!fp_->source->ReadFile("fastboot-info.txt", &contents)) {

        LOG(VERBOSE) << "Flashing from hardcoded images. fastboot-info.txt is empty or does not "

                        "exist";

        HardcodedFlash();

        return;

    }



    std::vector<std::unique_ptr<Task>> tasks = ParseFastbootInfo(fp_, stream);

    std::vector<std::unique_ptr<Task>> tasks =

            ParseFastbootInfo(fp_, Split({contents.data(), contents.size()}, "\n"));



    if (tasks.empty()) {

        LOG(FATAL) << "Invalid fastboot-info.txt file.";

    }
@@ -2115,7 +2113,7 @@ bool should_flash_in_userspace(const std::string& partition_name) { 
}



static bool wipe_super(const android::fs_mgr::LpMetadata& metadata, const std::string& slot,

                       std::string* message) {

                       std::string* message, const FlashingPlan* fp) {

    auto super_device = GetMetadataSuperBlockDevice(metadata);

    auto block_size = metadata.geometry.logical_block_size;

    auto super_bdev_name = android::fs_mgr::GetBlockDevicePartitionName(*super_device);
@@ -2155,7 +2153,7 @@ static bool wipe_super(const android::fs_mgr::LpMetadata& metadata, const std::s 


        auto image_path = temp_dir.path + "/"s + image_name;

        auto flash = [&](const std::string& partition_name) {

            do_flash(partition_name.c_str(), image_path.c_str(), false);

            do_flash(partition_name.c_str(), image_path.c_str(), false, fp);

        };

        do_for_partitions(partition, slot, flash, force_slot);
@@ -2164,7 +2162,8 @@ static bool wipe_super(const android::fs_mgr::LpMetadata& metadata, const std::s 
    return true;

}



static void do_wipe_super(const std::string& image, const std::string& slot_override) {

static void do_wipe_super(const std::string& image, const std::string& slot_override,

                          const FlashingPlan* fp) {

    if (access(image.c_str(), R_OK) != 0) {

        die("Could not read image: %s", image.c_str());

    }
@@ -2179,7 +2178,7 @@ static void do_wipe_super(const std::string& image, const std::string& slot_over 
    }



    std::string message;

    if (!wipe_super(*metadata.get(), slot, &message)) {

    if (!wipe_super(*metadata.get(), slot, &message, fp)) {

        die(message);

    }

}
@@ -2476,7 +2475,7 @@ int FastBootTool::Main(int argc, char* argv[]) { 
            }

            if (fname.empty()) die("cannot determine image filename for '%s'", pname.c_str());



            FlashTask task(fp->slot_override, pname, fname, is_vbmeta_partition(pname));

            FlashTask task(fp->slot_override, pname, fname, is_vbmeta_partition(pname), fp.get());

            task.Run();

        } else if (command == "flash:raw") {

            std::string partition = next_arg(&args);
@@ -2571,7 +2570,7 @@ int FastBootTool::Main(int argc, char* argv[]) { 
            } else {

                image = next_arg(&args);

            }

            do_wipe_super(image, fp->slot_override);

            do_wipe_super(image, fp->slot_override, fp.get());

        } else if (command == "snapshot-update") {

            std::string arg;

            if (!args.empty()) {

fastboot/fastboot.h

+2 −1
Original line number Diff line number Diff line
@@ -124,7 +124,8 @@ class FlashAllTool { 


bool should_flash_in_userspace(const std::string& partition_name);

bool is_userspace_fastboot();

void do_flash(const char* pname, const char* fname, const bool apply_vbmeta);

void do_flash(const char* pname, const char* fname, const bool apply_vbmeta,

              const FlashingPlan* fp);

void do_for_partitions(const std::string& part, const std::string& slot,

                       const std::function<void(const std::string&)>& func, bool force_slot);

std::string find_item(const std::string& item);

fastboot/task.cpp

+3 −3
Original line number Diff line number Diff line
@@ -27,8 +27,8 @@ 


using namespace std::string_literals;

FlashTask::FlashTask(const std::string& slot, const std::string& pname, const std::string& fname,

                     const bool apply_vbmeta)

    : pname_(pname), fname_(fname), slot_(slot), apply_vbmeta_(apply_vbmeta) {}

                     const bool apply_vbmeta, const FlashingPlan* fp)

    : pname_(pname), fname_(fname), slot_(slot), apply_vbmeta_(apply_vbmeta), fp_(fp) {}



void FlashTask::Run() {

    auto flash = [&](const std::string& partition) {
@@ -41,7 +41,7 @@ void FlashTask::Run() { 
                "And try again. If you are intentionally trying to "

                "overwrite a fixed partition, use --force.");

        }

        do_flash(partition.c_str(), fname_.c_str(), apply_vbmeta_);

        do_flash(partition.c_str(), fname_.c_str(), apply_vbmeta_, fp_);

    };

    do_for_partitions(pname_, slot_, flash, true);

}

fastboot/task.h

+2 −1
Original line number Diff line number Diff line
@@ -46,7 +46,7 @@ class Task { 
class FlashTask : public Task {

  public:

    FlashTask(const std::string& slot, const std::string& pname, const std::string& fname,

              const bool apply_vbmeta);

              const bool apply_vbmeta, const FlashingPlan* fp);

    virtual FlashTask* AsFlashTask() override { return this; }



    std::string GetPartition() { return pname_; }
@@ -60,6 +60,7 @@ class FlashTask : public Task { 
    const std::string fname_;

    const std::string slot_;

    const bool apply_vbmeta_;

    const FlashingPlan* fp_;

};



class RebootTask : public Task {