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

Commit 0d30718d authored by Daniel Zheng's avatar Daniel Zheng
Browse files

Added support for flash task 

Added Flash Task

Test: tested on raven
Change-Id: I4a6c22f795440afeba18497745dddf8d5c570f65
Bug: 194686221

changed flash {partition_name} to work with tasks

Test: tested flash {partition_name} on raven
Change-Id: I1fa45b949ad8e5017026dd542dfe1389279a9e64
Bug: 194686221
parent 77f4cb4d

fastboot/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -294,6 +294,7 @@ cc_library_host_static { 
        "udp.cpp",

        "util.cpp",

        "vendor_boot_img_utils.cpp",

        "task.cpp",

    ],



    // Only version the final binaries

fastboot/fastboot.cpp

+14 −26
Original line number Diff line number Diff line
@@ -44,8 +44,12 @@ 
#include <unistd.h>



#include <chrono>

#include <fstream>

#include <functional>

#include <iostream>

#include <memory>

#include <regex>

#include <sstream>

#include <string>

#include <thread>

#include <utility>
@@ -216,7 +220,7 @@ static std::string find_item_given_name(const std::string& img_name) { 
    return std::string(dir) + "/" + img_name;

}



static std::string find_item(const std::string& item) {

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

    for (size_t i = 0; i < images.size(); ++i) {

        if (!images[i].nickname.empty() && item == images[i].nickname) {

            return find_item_given_name(images[i].img_name);
@@ -546,8 +550,7 @@ static void list_devices() { 
    usb_open(list_devices_callback);

    NetworkDeviceConnected(/* print */ true);

}



static void syntax_error(const char* fmt, ...) {

void syntax_error(const char* fmt, ...) {

    fprintf(stderr, "fastboot: usage: ");



    va_list ap;
@@ -1410,9 +1413,8 @@ static void do_for_partition(const std::string& part, const std::string& slot, 
 * partition names. If force_slot is true, it will fail if a slot is specified, and the given

 * partition does not support slots.

 */

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

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

                              bool force_slot) {

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 has_slot;

    // |part| can be vendor_boot:default. Query has-slot on the first token only.

    auto part_tokens = android::base::Split(part, ":");
@@ -1508,7 +1510,7 @@ static std::string repack_ramdisk(const char* pname, struct fastboot_buffer* buf 
    return partition;

}



static void do_flash(const char* pname, const char* fname) {

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

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

    struct fastboot_buffer buf;
@@ -1537,12 +1539,12 @@ static void set_active(const std::string& slot_override) { 
    }

}



static bool is_userspace_fastboot() {

bool is_userspace_fastboot() {

    std::string value;

    return fb->GetVar("is-userspace", &value) == fastboot::SUCCESS && value == "yes";

}



static void reboot_to_userspace_fastboot() {

void reboot_to_userspace_fastboot() {

    fb->RebootTo("fastboot");



    auto* old_transport = fb->set_transport(nullptr);
@@ -2029,7 +2031,7 @@ failed: 
    }

}



static bool should_flash_in_userspace(const std::string& partition_name) {

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

    if (!get_android_product_out()) {

        return false;

    }
@@ -2416,7 +2418,6 @@ int FastBootTool::Main(int argc, char* argv[]) { 
            fb->Boot();

        } else if (command == FB_CMD_FLASH) {

            std::string pname = next_arg(&args);



            std::string fname;

            if (!args.empty()) {

                fname = next_arg(&args);
@@ -2424,21 +2425,8 @@ int FastBootTool::Main(int argc, char* argv[]) { 
                fname = find_item(pname);

            }

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



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

                if (should_flash_in_userspace(partition) && !is_userspace_fastboot() &&

                    !force_flash) {

                    die("The partition you are trying to flash is dynamic, and "

                        "should be flashed via fastbootd. Please run:\n"

                        "\n"

                        "    fastboot reboot fastboot\n"

                        "\n"

                        "And try again. If you are intentionally trying to "

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

                }

                do_flash(partition.c_str(), fname.c_str());

            };

            do_for_partitions(pname, slot_override, flash, true);

            FlashTask task(slot_override, force_flash, pname, fname);

            task.Run();

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

            std::string partition = next_arg(&args);

            std::string kernel = next_arg(&args);

fastboot/fastboot.h

+11 −0
Original line number Diff line number Diff line
@@ -27,6 +27,8 @@ 
 */

#pragma once



#include <string>



#include <bootimg.h>



class FastBootTool {
@@ -37,3 +39,12 @@ class FastBootTool { 
    void ParseOsVersion(boot_img_hdr_v1*, const char*);

    unsigned ParseFsOption(const char*);

};



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

bool is_userspace_fastboot();

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

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

void reboot_to_userspace_fastboot();

void syntax_error(const char* fmt, ...);

fastboot/task.cpp

0 → 100644
+46 −0
Original line number Diff line number Diff line 
//

// Copyright (C) 2023 The Android Open Source Project

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//      http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

//

#include "task.h"



#include "fastboot.h"

#include "util.h"



FlashTask::FlashTask(const std::string& _slot) : slot_(_slot){};

FlashTask::FlashTask(const std::string& _slot, bool _force_flash)

    : slot_(_slot), force_flash_(_force_flash) {}

FlashTask::FlashTask(const std::string& _slot, bool _force_flash, const std::string& _pname)

    : pname_(_pname), fname_(find_item(_pname)), slot_(_slot), force_flash_(_force_flash) {

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

}

FlashTask::FlashTask(const std::string& _slot, bool _force_flash, const std::string& _pname,

                     const std::string& _fname)

    : pname_(_pname), fname_(_fname), slot_(_slot), force_flash_(_force_flash) {}



void FlashTask::Run() {

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

        if (should_flash_in_userspace(partition) && !is_userspace_fastboot() && !force_flash_) {

            die("The partition you are trying to flash is dynamic, and "

                "should be flashed via fastbootd. Please run:\n"

                "\n"

                "    fastboot reboot fastboot\n"

                "\n"

                "And try again. If you are intentionally trying to "

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

        }

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

    };

    do_for_partitions(pname_, slot_, flash, true);

}

fastboot/task.h

+18 −1
Original line number Diff line number Diff line
@@ -26,6 +26,23 @@ class Task { 
  public:

    Task() = default;

    virtual void Run() = 0;

    virtual bool Parse(const std::string& text) = 0;

    virtual ~Task() = default;

};



class FlashTask : public Task {

  public:

    FlashTask(const std::string& _slot);

    FlashTask(const std::string& _slot, bool _force_flash);

    FlashTask(const std::string& _slot, bool _force_flash, const std::string& _pname);

    FlashTask(const std::string& _slot, bool _force_flash, const std::string& _pname,

              const std::string& _fname);



    void Run() override;

    ~FlashTask() {}



  private:

    const std::string pname_;

    const std::string fname_;

    const std::string slot_;

    bool force_flash_ = false;

};