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

Commit 059954a6 authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge "Chang flash task to take in source"

parents 2dc80e38 791a83bb

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 {