From 5769b268bf23fcbcb74d70b883339745d446847f Mon Sep 17 00:00:00 2001 From: Daniel Zheng Date: Wed, 21 Jun 2023 14:41:11 -0700 Subject: [PATCH] use FlashingPlan sparse_limit for testing Have get_sparse_limit() return FlashingPlan's sparse limit if set. Used for testing to compare task lists Test: fastboot_test Change-Id: I7ac1eb4dc83a53b3d7aa59aa668a780b4b550664 --- fastboot/fastboot.cpp | 36 ++++++++++++++++++------------------ fastboot/fastboot.h | 5 +++-- fastboot/task.cpp | 14 ++++++++------ fastboot/task.h | 3 ++- 4 files changed, 31 insertions(+), 27 deletions(-) diff --git a/fastboot/fastboot.cpp b/fastboot/fastboot.cpp index 42d4f60d0..7a036a255 100644 --- a/fastboot/fastboot.cpp +++ b/fastboot/fastboot.cpp @@ -104,7 +104,6 @@ static bool g_long_listing = false; // libsparse will support INT_MAX, but this results in large allocations, so // let's keep it at 1GB to avoid memory pressure on the host. static constexpr int64_t RESPARSE_LIMIT = 1 * 1024 * 1024 * 1024; -static uint64_t sparse_limit = 0; static int64_t target_sparse_limit = -1; static unsigned g_base_addr = 0x10000000; @@ -1016,8 +1015,8 @@ static uint64_t get_uint_var(const char* var_name) { return value; } -int64_t get_sparse_limit(int64_t size) { - int64_t limit = sparse_limit; +int64_t get_sparse_limit(int64_t size, const FlashingPlan* fp) { + int64_t limit = int64_t(fp->sparse_limit); if (limit == 0) { // Unlimited, so see what the target device's limit is. // TODO: shouldn't we apply this limit even if you've used -S? @@ -1038,7 +1037,7 @@ int64_t get_sparse_limit(int64_t size) { return 0; } -static bool load_buf_fd(unique_fd fd, struct fastboot_buffer* buf) { +static bool load_buf_fd(unique_fd fd, struct fastboot_buffer* buf, const FlashingPlan* fp) { int64_t sz = get_file_size(fd); if (sz == -1) { return false; @@ -1056,7 +1055,7 @@ static bool load_buf_fd(unique_fd fd, struct fastboot_buffer* buf) { } lseek(fd.get(), 0, SEEK_SET); - int64_t limit = get_sparse_limit(sz); + int64_t limit = get_sparse_limit(sz, fp); buf->fd = std::move(fd); if (limit) { buf->files = load_sparse_files(buf->fd.get(), limit); @@ -1072,7 +1071,7 @@ static bool load_buf_fd(unique_fd fd, struct fastboot_buffer* buf) { return true; } -static bool load_buf(const char* fname, struct fastboot_buffer* buf) { +static bool load_buf(const char* fname, struct fastboot_buffer* buf, const FlashingPlan* fp) { unique_fd fd(TEMP_FAILURE_RETRY(open(fname, O_RDONLY | O_BINARY))); if (fd == -1) { @@ -1088,7 +1087,7 @@ static bool load_buf(const char* fname, struct fastboot_buffer* buf) { return false; } - return load_buf_fd(std::move(fd), buf); + return load_buf_fd(std::move(fd), buf, fp); } static void rewrite_vbmeta_buffer(struct fastboot_buffer* buf, bool vbmeta_in_boot) { @@ -1490,12 +1489,12 @@ void do_flash(const char* pname, const char* fname, const bool apply_vbmeta, verbose("Do flash %s %s", pname, fname); struct fastboot_buffer buf; - if (fp->source) { + if (fp && fp->source) { unique_fd fd = fp->source->OpenFile(fname); - if (fd < 0 || !load_buf_fd(std::move(fd), &buf)) { + if (fd < 0 || !load_buf_fd(std::move(fd), &buf, fp)) { die("could not load '%s': %s", fname, strerror(errno)); } - } else if (!load_buf(fname, &buf)) { + } else if (!load_buf(fname, &buf, fp)) { die("cannot load '%s': %s", fname, strerror(errno)); } @@ -1873,7 +1872,7 @@ void FlashAllTool::FlashImages(const std::vectorsource->OpenFile(image->img_name); - if (fd < 0 || !load_buf_fd(std::move(fd), &buf)) { + if (fd < 0 || !load_buf_fd(std::move(fd), &buf, fp_)) { if (image->optional_if_no_image) { continue; } @@ -1982,7 +1981,7 @@ static unsigned fb_get_flash_block_size(std::string name) { void fb_perform_format(const std::string& partition, int skip_if_not_supported, const std::string& type_override, const std::string& size_override, - const unsigned fs_options) { + const unsigned fs_options, const FlashingPlan* fp) { std::string partition_type, partition_size; struct fastboot_buffer buf; @@ -1995,8 +1994,8 @@ void fb_perform_format(const std::string& partition, int skip_if_not_supported, if (target_sparse_limit > 0 && target_sparse_limit < limit) { limit = target_sparse_limit; } - if (sparse_limit > 0 && sparse_limit < limit) { - limit = sparse_limit; + if (fp->sparse_limit > 0 && fp->sparse_limit < limit) { + limit = fp->sparse_limit; } if (fb->GetVar("partition-type:" + partition, &partition_type) != fastboot::SUCCESS) { @@ -2051,7 +2050,7 @@ void fb_perform_format(const std::string& partition, int skip_if_not_supported, if (fd == -1) { die("Cannot open generated image: %s", strerror(errno)); } - if (!load_buf_fd(std::move(fd), &buf)) { + if (!load_buf_fd(std::move(fd), &buf, fp)) { die("Cannot read image: %s", strerror(errno)); } flash_buf(partition, &buf, is_vbmeta_partition(partition)); @@ -2286,7 +2285,7 @@ int FastBootTool::Main(int argc, char* argv[]) { serial = optarg; break; case 'S': - if (!android::base::ParseByteCount(optarg, &sparse_limit)) { + if (!android::base::ParseByteCount(optarg, &fp->sparse_limit)) { die("invalid sparse limit %s", optarg); } break; @@ -2404,7 +2403,8 @@ int FastBootTool::Main(int argc, char* argv[]) { std::string partition = next_arg(&args); auto format = [&](const std::string& partition) { - fb_perform_format(partition, 0, type_override, size_override, fp->fs_options); + fb_perform_format(partition, 0, type_override, size_override, fp->fs_options, + fp.get()); }; do_for_partitions(partition, fp->slot_override, format, true); } else if (command == "signature") { @@ -2498,7 +2498,7 @@ int FastBootTool::Main(int argc, char* argv[]) { std::string filename = next_arg(&args); struct fastboot_buffer buf; - if (!load_buf(filename.c_str(), &buf) || buf.type != FB_BUFFER_FD) { + if (!load_buf(filename.c_str(), &buf, fp.get()) || buf.type != FB_BUFFER_FD) { die("cannot load '%s'", filename.c_str()); } fb->Download(filename, buf.fd.get(), buf.sz); diff --git a/fastboot/fastboot.h b/fastboot/fastboot.h index ae488d82d..d4e0ae902 100644 --- a/fastboot/fastboot.h +++ b/fastboot/fastboot.h @@ -97,6 +97,7 @@ struct FlashingPlan { bool skip_secondary = false; bool force_flash = false; bool should_optimize_flash_super = true; + uint64_t sparse_limit = 0; std::string slot_override; std::string current_slot; @@ -176,11 +177,11 @@ Result ParseNetworkSerial(const std::string& seria bool supports_AB(); std::string GetPartitionName(const ImageEntry& entry, const std::string& current_slot_); void flash_partition_files(const std::string& partition, const std::vector& files); -int64_t get_sparse_limit(int64_t size); +int64_t get_sparse_limit(int64_t size, const FlashingPlan* fp); std::vector resparse_file(sparse_file* s, int64_t max_size); bool is_retrofit_device(); bool is_logical(const std::string& partition); void fb_perform_format(const std::string& partition, int skip_if_not_supported, const std::string& type_override, const std::string& size_override, - const unsigned fs_options); + const unsigned fs_options, const FlashingPlan* fp); diff --git a/fastboot/task.cpp b/fastboot/task.cpp index 96b952c94..c1b9a31a1 100644 --- a/fastboot/task.cpp +++ b/fastboot/task.cpp @@ -98,18 +98,20 @@ std::string RebootTask::ToString() { FlashSuperLayoutTask::FlashSuperLayoutTask(const std::string& super_name, std::unique_ptr helper, - SparsePtr sparse_layout, uint64_t super_size) + SparsePtr sparse_layout, uint64_t super_size, + const FlashingPlan* fp) : super_name_(super_name), helper_(std::move(helper)), sparse_layout_(std::move(sparse_layout)), - super_size_(super_size) {} + super_size_(super_size), + fp_(fp) {} void FlashSuperLayoutTask::Run() { // Use the reported super partition size as the upper limit, rather than // sparse_file_len, which (1) can fail and (2) is kind of expensive, since // it will map in all of the embedded fds. std::vector files; - if (int limit = get_sparse_limit(super_size_)) { + if (int limit = get_sparse_limit(super_size_, fp_)) { files = resparse_file(sparse_layout_.get(), limit); } else { files.emplace_back(std::move(sparse_layout_)); @@ -187,7 +189,7 @@ std::unique_ptr FlashSuperLayoutTask::Initialize( os_images.erase(std::remove_if(os_images.begin(), os_images.end(), remove_if_callback), os_images.end()); return std::make_unique(super_name, std::move(helper), std::move(s), - partition_size); + partition_size, fp); } std::unique_ptr FlashSuperLayoutTask::InitializeFromTasks( @@ -260,7 +262,7 @@ std::unique_ptr FlashSuperLayoutTask::InitializeFromTasks( tasks.erase(std::remove_if(tasks.begin(), tasks.end(), remove_if_callback), tasks.end()); return std::make_unique(super_name, std::move(helper), std::move(s), - partition_size); + partition_size, fp); } UpdateSuperTask::UpdateSuperTask(const FlashingPlan* fp) : fp_(fp) {} @@ -330,7 +332,7 @@ void WipeTask::Run() { LOG(ERROR) << "wipe task erase failed with partition: " << pname_; return; } - fb_perform_format(pname_, 1, partition_type, "", fp_->fs_options); + fb_perform_format(pname_, 1, partition_type, "", fp_->fs_options, fp_); } std::string WipeTask::ToString() { diff --git a/fastboot/task.h b/fastboot/task.h index 500655dbb..858f43a2e 100644 --- a/fastboot/task.h +++ b/fastboot/task.h @@ -82,7 +82,7 @@ class RebootTask : public Task { class FlashSuperLayoutTask : public Task { public: FlashSuperLayoutTask(const std::string& super_name, std::unique_ptr helper, - SparsePtr sparse_layout, uint64_t super_size); + SparsePtr sparse_layout, uint64_t super_size, const FlashingPlan* fp); static std::unique_ptr Initialize(const FlashingPlan* fp, std::vector& os_images); static std::unique_ptr InitializeFromTasks( @@ -96,6 +96,7 @@ class FlashSuperLayoutTask : public Task { std::unique_ptr helper_; SparsePtr sparse_layout_; uint64_t super_size_; + const FlashingPlan* fp_; }; class UpdateSuperTask : public Task {