Changing flashall to parse fastboot-info.txt
Test: tested on Raven
Change-Id: I9f26bf6025a0a6318f84be929091f4e82bd87556
diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp
index d7d2091..6b0df52 100644
--- a/fastboot/fastboot.cpp
+++ b/fastboot/fastboot.cpp
@@ -1284,7 +1284,7 @@
}
}
-static std::string get_current_slot() {
+std::string get_current_slot() {
std::string current_slot;
if (fb->GetVar("current-slot", ¤t_slot) != fastboot::SUCCESS) return "";
if (current_slot[0] == '_') current_slot.erase(0, 1);
@@ -1560,7 +1560,7 @@
}
}
-std::string GetPartitionName(const ImageEntry& entry, std::string& current_slot) {
+std::string GetPartitionName(const ImageEntry& entry, const std::string& current_slot) {
auto slot = entry.second;
if (slot.empty()) {
slot = current_slot;
@@ -1574,6 +1574,216 @@
return entry.first->part_name + "_" + slot;
}
+std::unique_ptr<FlashTask> ParseFlashCommand(const FlashingPlan* fp,
+ const std::vector<std::string>& parts) {
+ bool apply_vbmeta = false;
+ std::string slot = fp->slot_override;
+ std::string partition;
+ std::string img_name;
+ for (auto& part : parts) {
+ if (part == "--apply-vbmeta") {
+ apply_vbmeta = true;
+ } else if (part == "--slot-other") {
+ slot = fp->secondary_slot;
+ } else if (partition.empty()) {
+ partition = part;
+ } else if (img_name.empty()) {
+ img_name = part;
+ } else {
+ LOG(ERROR) << "unknown argument" << part
+ << " in fastboot-info.txt. parts: " << android::base::Join(parts, " ");
+ return nullptr;
+ }
+ }
+ if (partition.empty()) {
+ LOG(ERROR) << "partition name not found when parsing fastboot-info.txt. parts: "
+ << android::base::Join(parts, " ");
+ return nullptr;
+ }
+ if (img_name.empty()) {
+ img_name = partition + ".img";
+ }
+ return std::make_unique<FlashTask>(slot, partition, img_name, apply_vbmeta);
+}
+
+std::unique_ptr<RebootTask> ParseRebootCommand(const FlashingPlan* fp,
+ const std::vector<std::string>& parts) {
+ if (parts.empty()) return std::make_unique<RebootTask>(fp);
+ if (parts.size() > 1) {
+ LOG(ERROR) << "unknown arguments in reboot {target} in fastboot-info.txt: "
+ << android::base::Join(parts, " ");
+ return nullptr;
+ }
+ return std::make_unique<RebootTask>(fp, parts[0]);
+}
+
+std::unique_ptr<WipeTask> ParseWipeCommand(const FlashingPlan* fp,
+ const std::vector<std::string>& parts) {
+ if (parts.size() != 1) {
+ LOG(ERROR) << "unknown arguments in erase {partition} in fastboot-info.txt: "
+ << android::base::Join(parts, " ");
+ return nullptr;
+ }
+ return std::make_unique<WipeTask>(fp, parts[0]);
+}
+
+std::unique_ptr<Task> ParseFastbootInfoLine(const FlashingPlan* fp,
+ const std::vector<std::string>& command) {
+ if (command.size() == 0) {
+ return nullptr;
+ }
+ std::unique_ptr<Task> task;
+
+ if (command[0] == "flash") {
+ task = ParseFlashCommand(fp, std::vector<std::string>{command.begin() + 1, command.end()});
+ } else if (command[0] == "reboot") {
+ task = ParseRebootCommand(fp, std::vector<std::string>{command.begin() + 1, command.end()});
+ } else if (command[0] == "update-super" && command.size() == 1) {
+ task = std::make_unique<UpdateSuperTask>(fp);
+ } else if (command[0] == "erase" && command.size() == 2) {
+ task = ParseWipeCommand(fp, std::vector<std::string>{command.begin() + 1, command.end()});
+ }
+ if (!task) {
+ LOG(ERROR) << "unknown command parsing fastboot-info.txt line: "
+ << android::base::Join(command, " ");
+ }
+ return task;
+}
+
+void AddResizeTasks(const FlashingPlan* fp, std::vector<std::unique_ptr<Task>>* tasks) {
+ // expands "resize-partitions" into individual commands : resize {os_partition_1}, resize
+ // {os_partition_2}, etc.
+ std::vector<std::unique_ptr<Task>> resize_tasks;
+ std::optional<size_t> loc;
+ for (size_t i = 0; i < tasks->size(); i++) {
+ if (auto flash_task = tasks->at(i)->AsFlashTask()) {
+ if (should_flash_in_userspace(flash_task->GetPartitionAndSlot())) {
+ if (!loc) {
+ loc = i;
+ }
+ resize_tasks.emplace_back(std::make_unique<ResizeTask>(
+ fp, flash_task->GetPartition(), "0", fp->slot_override));
+ }
+ }
+ }
+ // if no logical partitions (although should never happen since system will always need to be
+ // flashed)
+ if (!loc) {
+ return;
+ }
+ tasks->insert(tasks->begin() + loc.value(), std::make_move_iterator(resize_tasks.begin()),
+ std::make_move_iterator(resize_tasks.end()));
+ return;
+}
+
+static bool IsNumber(const std::string& s) {
+ bool period = false;
+ for (size_t i = 0; i < s.length(); i++) {
+ if (!isdigit(s[i])) {
+ if (!period && s[i] == '.' && i != 0 && i != s.length() - 1) {
+ period = true;
+ } else {
+ return false;
+ }
+ }
+ }
+ return true;
+}
+
+static bool IsIgnore(const std::vector<std::string>& command) {
+ if (command[0][0] == '#') {
+ return true;
+ }
+ return false;
+}
+
+bool CheckFastbootInfoRequirements(const std::vector<std::string>& command) {
+ if (command.size() != 2) {
+ LOG(ERROR) << "unknown characters in version info in fastboot-info.txt -> "
+ << android::base::Join(command, " ");
+ return false;
+ }
+ if (command[0] != "version") {
+ LOG(ERROR) << "unknown characters in version info in fastboot-info.txt -> "
+ << android::base::Join(command, " ");
+ return false;
+ }
+
+ if (!IsNumber(command[1])) {
+ LOG(ERROR) << "version number contains non-numeric values in fastboot-info.txt -> "
+ << android::base::Join(command, " ");
+ return false;
+ }
+
+ LOG(VERBOSE) << "Checking 'fastboot-info.txt version'";
+ if (command[1] < PLATFORM_TOOLS_VERSION) {
+ return true;
+ }
+ LOG(ERROR) << "fasboot-info.txt version: " << command[1]
+ << " not compatible with host tool version --> " << PLATFORM_TOOLS_VERSION;
+ return false;
+}
+
+std::vector<std::unique_ptr<Task>> ParseFastbootInfo(const FlashingPlan* fp,
+ const std::vector<std::string>& file) {
+ std::vector<std::unique_ptr<Task>> tasks;
+ // Get os_partitions that need to be resized
+ for (auto& text : file) {
+ std::vector<std::string> command = android::base::Tokenize(text, " ");
+ if (IsIgnore(command)) {
+ continue;
+ }
+ if (command.size() > 1 && command[0] == "version") {
+ if (!CheckFastbootInfoRequirements(command)) {
+ return {};
+ }
+ continue;
+ } else if (command.size() >= 2 && command[0] == "if-wipe") {
+ if (!fp->wants_wipe) {
+ continue;
+ }
+ command.erase(command.begin());
+ }
+ auto task = ParseFastbootInfoLine(fp, command);
+ if (!task) {
+ LOG(ERROR) << "Error when parsing fastboot-info.txt, falling back on Hardcoded list: "
+ << text;
+ return {};
+ }
+ tasks.emplace_back(std::move(task));
+ }
+ if (auto flash_super_task = FlashSuperLayoutTask::InitializeFromTasks(fp, tasks)) {
+ auto it = tasks.begin();
+ for (size_t i = 0; i < tasks.size(); i++) {
+ if (auto flash_task = tasks[i]->AsFlashTask()) {
+ if (should_flash_in_userspace(flash_task->GetPartitionAndSlot())) {
+ break;
+ }
+ }
+ if (auto wipe_task = tasks[i]->AsWipeTask()) {
+ break;
+ }
+ it++;
+ }
+ tasks.insert(it, std::move(flash_super_task));
+ } else {
+ AddResizeTasks(fp, &tasks);
+ }
+ return tasks;
+}
+
+std::vector<std::unique_ptr<Task>> ParseFastbootInfo(const FlashingPlan* fp, std::ifstream& fs) {
+ if (!fs || fs.eof()) return {};
+
+ 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);
+}
+
class FlashAllTool {
public:
FlashAllTool(FlashingPlan* fp);
@@ -1586,6 +1796,7 @@
void CollectImages();
void FlashImages(const std::vector<std::pair<const Image*, std::string>>& images);
void FlashImage(const Image& image, const std::string& slot, fastboot_buffer* buf);
+ void HardcodedFlash();
std::vector<ImageEntry> boot_images_;
std::vector<ImageEntry> os_images_;
@@ -1611,38 +1822,23 @@
CancelSnapshotIfNeeded();
- // First flash boot partitions. We allow this to happen either in userspace
- // or in bootloader fastboot.
- FlashImages(boot_images_);
-
- std::vector<std::unique_ptr<Task>> tasks;
-
- if (auto flash_super_task = FlashSuperLayoutTask::Initialize(fp_, os_images_)) {
- tasks.emplace_back(std::move(flash_super_task));
- } else {
- // Sync the super partition. This will reboot to userspace fastboot if needed.
- tasks.emplace_back(std::make_unique<UpdateSuperTask>(fp_));
- // Resize any logical partition to 0, so each partition is reset to 0
- // extents, and will achieve more optimal allocation.
- for (const auto& [image, slot] : os_images_) {
- // Retrofit devices have two super partitions, named super_a and super_b.
- // On these devices, secondary slots must be flashed as physical
- // partitions (otherwise they would not mount on first boot). To enforce
- // this, we delete any logical partitions for the "other" slot.
- if (is_retrofit_device()) {
- std::string partition_name = image->part_name + "_"s + slot;
- if (image->IsSecondary() && is_logical(partition_name)) {
- fp_->fb->DeletePartition(partition_name);
- }
- tasks.emplace_back(std::make_unique<DeleteTask>(fp_, partition_name));
- }
- tasks.emplace_back(std::make_unique<ResizeTask>(fp_, image->part_name, "0", slot));
- }
+ std::string path = find_item_given_name("fastboot-info.txt");
+ std::ifstream stream(path);
+ std::vector<std::unique_ptr<Task>> tasks = ParseFastbootInfo(fp_, stream);
+ if (tasks.empty()) {
+ LOG(VERBOSE) << "Flashing from hardcoded images. fastboot-info.txt is empty or does not "
+ "exist";
+ HardcodedFlash();
+ return;
}
+ LOG(VERBOSE) << "Flashing from fastboot-info.txt";
for (auto& task : tasks) {
task->Run();
}
- FlashImages(os_images_);
+ if (fp_->wants_wipe) {
+ // avoid adding duplicate wipe tasks in fastboot main code.
+ fp_->wants_wipe = false;
+ }
}
void FlashAllTool::CheckRequirements() {
@@ -1693,6 +1889,42 @@
}
}
+void FlashAllTool::HardcodedFlash() {
+ CollectImages();
+ // First flash boot partitions. We allow this to happen either in userspace
+ // or in bootloader fastboot.
+ FlashImages(boot_images_);
+
+ std::vector<std::unique_ptr<Task>> tasks;
+
+ if (auto flash_super_task = FlashSuperLayoutTask::Initialize(fp_, os_images_)) {
+ tasks.emplace_back(std::move(flash_super_task));
+ } else {
+ // Sync the super partition. This will reboot to userspace fastboot if needed.
+ tasks.emplace_back(std::make_unique<UpdateSuperTask>(fp_));
+ // Resize any logical partition to 0, so each partition is reset to 0
+ // extents, and will achieve more optimal allocation.
+ for (const auto& [image, slot] : os_images_) {
+ // Retrofit devices have two super partitions, named super_a and super_b.
+ // On these devices, secondary slots must be flashed as physical
+ // partitions (otherwise they would not mount on first boot). To enforce
+ // this, we delete any logical partitions for the "other" slot.
+ if (is_retrofit_device()) {
+ std::string partition_name = image->part_name + "_"s + slot;
+ if (image->IsSecondary() && should_flash_in_userspace(partition_name)) {
+ fp_->fb->DeletePartition(partition_name);
+ }
+ tasks.emplace_back(std::make_unique<DeleteTask>(fp_, partition_name));
+ }
+ tasks.emplace_back(std::make_unique<ResizeTask>(fp_, image->part_name, "0", slot));
+ }
+ }
+ for (auto& i : tasks) {
+ i->Run();
+ }
+ FlashImages(os_images_);
+}
+
void FlashAllTool::FlashImages(const std::vector<std::pair<const Image*, std::string>>& images) {
for (const auto& [image, slot] : images) {
fastboot_buffer buf;