The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2008 The Android Open Source Project |
| 3 | * All rights reserved. |
| 4 | * |
| 5 | * Redistribution and use in source and binary forms, with or without |
| 6 | * modification, are permitted provided that the following conditions |
| 7 | * are met: |
| 8 | * * Redistributions of source code must retain the above copyright |
| 9 | * notice, this list of conditions and the following disclaimer. |
| 10 | * * Redistributions in binary form must reproduce the above copyright |
| 11 | * notice, this list of conditions and the following disclaimer in |
Tsu Chiang Chuang | ee52055 | 2011-02-25 18:38:53 -0800 | [diff] [blame] | 12 | * the documentation and/or other materials provided with the |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 13 | * distribution. |
| 14 | * |
| 15 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| 16 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| 17 | * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS |
| 18 | * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE |
| 19 | * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, |
| 20 | * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, |
| 21 | * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS |
Tsu Chiang Chuang | ee52055 | 2011-02-25 18:38:53 -0800 | [diff] [blame] | 22 | * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 23 | * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| 24 | * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| 25 | * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| 26 | * SUCH DAMAGE. |
| 27 | */ |
| 28 | |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 29 | #include "fastboot.h" |
| 30 | |
Mark Salyzyn | 5957c1f | 2014-04-30 14:05:28 -0700 | [diff] [blame] | 31 | #include <ctype.h> |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 32 | #include <errno.h> |
| 33 | #include <fcntl.h> |
Colin Cross | 8879f98 | 2012-05-22 17:53:34 -0700 | [diff] [blame] | 34 | #include <getopt.h> |
Ying Wang | cf86e2f | 2014-05-15 20:06:40 -0700 | [diff] [blame] | 35 | #include <inttypes.h> |
Mark Salyzyn | 5957c1f | 2014-04-30 14:05:28 -0700 | [diff] [blame] | 36 | #include <limits.h> |
Mark Salyzyn | 5957c1f | 2014-04-30 14:05:28 -0700 | [diff] [blame] | 37 | #include <stdint.h> |
| 38 | #include <stdio.h> |
| 39 | #include <stdlib.h> |
| 40 | #include <string.h> |
| 41 | #include <sys/stat.h> |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 42 | #include <sys/time.h> |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 43 | #include <sys/types.h> |
Mark Salyzyn | 5957c1f | 2014-04-30 14:05:28 -0700 | [diff] [blame] | 44 | #include <unistd.h> |
David Pursell | 2ec418a | 2016-01-20 08:32:08 -0800 | [diff] [blame] | 45 | |
Elliott Hughes | 290a228 | 2016-11-14 17:08:47 -0800 | [diff] [blame] | 46 | #include <chrono> |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 47 | #include <functional> |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 48 | #include <regex> |
David Anderson | 0c73234 | 2018-11-28 17:10:42 -0800 | [diff] [blame] | 49 | #include <string> |
Elliott Hughes | 290a228 | 2016-11-14 17:08:47 -0800 | [diff] [blame] | 50 | #include <thread> |
Josh Gao | 9da9ac5 | 2016-01-19 14:50:18 -0800 | [diff] [blame] | 51 | #include <utility> |
| 52 | #include <vector> |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 53 | |
Chin-Ting Kuo | df6a780 | 2019-09-16 11:23:55 +0800 | [diff] [blame] | 54 | #include <android-base/endian.h> |
Elliott Hughes | 82ff315 | 2016-08-31 15:07:18 -0700 | [diff] [blame] | 55 | #include <android-base/file.h> |
Elliott Hughes | 749ae2d | 2016-06-28 14:48:45 -0700 | [diff] [blame] | 56 | #include <android-base/macros.h> |
Elliott Hughes | 4f71319 | 2015-12-04 22:00:26 -0800 | [diff] [blame] | 57 | #include <android-base/parseint.h> |
David Pursell | 2ec418a | 2016-01-20 08:32:08 -0800 | [diff] [blame] | 58 | #include <android-base/parsenetaddress.h> |
Elliott Hughes | 2810d00 | 2016-04-25 14:31:18 -0700 | [diff] [blame] | 59 | #include <android-base/stringprintf.h> |
Elliott Hughes | 4f71319 | 2015-12-04 22:00:26 -0800 | [diff] [blame] | 60 | #include <android-base/strings.h> |
Chris Fries | 0ea946c | 2017-04-12 10:25:57 -0500 | [diff] [blame] | 61 | #include <android-base/unique_fd.h> |
Dan Willemsen | ab971b5 | 2018-08-29 14:58:02 -0700 | [diff] [blame] | 62 | #include <build/version.h> |
Chin-Ting Kuo | df6a780 | 2019-09-16 11:23:55 +0800 | [diff] [blame] | 63 | #include <libavb/libavb.h> |
David Anderson | 8956964 | 2018-11-16 15:53:35 -0800 | [diff] [blame] | 64 | #include <liblp/liblp.h> |
Dan Willemsen | ab971b5 | 2018-08-29 14:58:02 -0700 | [diff] [blame] | 65 | #include <platform_tools_version.h> |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 66 | #include <sparse/sparse.h> |
Elliott Hughes | d30ad8a | 2015-03-18 23:12:44 -0700 | [diff] [blame] | 67 | #include <ziparchive/zip_archive.h> |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 68 | |
Elliott Hughes | 253c18d | 2015-03-18 22:47:09 -0700 | [diff] [blame] | 69 | #include "bootimg_utils.h" |
Mark Salyzyn | 8e7e9cb | 2018-08-29 10:44:33 -0700 | [diff] [blame] | 70 | #include "constants.h" |
Elliott Hughes | 1b708d3 | 2015-12-11 19:07:01 -0800 | [diff] [blame] | 71 | #include "diagnose_usb.h" |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 72 | #include "fastboot_driver.h" |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 73 | #include "fs.h" |
David Pursell | 2ec418a | 2016-01-20 08:32:08 -0800 | [diff] [blame] | 74 | #include "tcp.h" |
David Pursell | 0b15663 | 2015-10-30 11:22:01 -0700 | [diff] [blame] | 75 | #include "transport.h" |
David Pursell | 4601c97 | 2016-02-05 15:35:09 -0800 | [diff] [blame] | 76 | #include "udp.h" |
David Pursell | 0b15663 | 2015-10-30 11:22:01 -0700 | [diff] [blame] | 77 | #include "usb.h" |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 78 | #include "util.h" |
Yifan Hong | e71fe24 | 2021-02-22 15:00:15 -0800 | [diff] [blame] | 79 | #include "vendor_boot_img_utils.h" |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 80 | |
Yifan Hong | bcd2770 | 2021-02-16 19:37:32 -0800 | [diff] [blame] | 81 | using android::base::borrowed_fd; |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 82 | using android::base::ReadFully; |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 83 | using android::base::Split; |
| 84 | using android::base::Trim; |
Chris Fries | 0ea946c | 2017-04-12 10:25:57 -0500 | [diff] [blame] | 85 | using android::base::unique_fd; |
David Anderson | 0c73234 | 2018-11-28 17:10:42 -0800 | [diff] [blame] | 86 | using namespace std::string_literals; |
Yifan Hong | bcd2770 | 2021-02-16 19:37:32 -0800 | [diff] [blame] | 87 | using namespace std::placeholders; |
Chris Fries | 0ea946c | 2017-04-12 10:25:57 -0500 | [diff] [blame] | 88 | |
David Pursell | 2ec418a | 2016-01-20 08:32:08 -0800 | [diff] [blame] | 89 | static const char* serial = nullptr; |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 90 | |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 91 | static bool g_long_listing = false; |
Chris Fries | 6a99971 | 2017-04-04 09:52:47 -0500 | [diff] [blame] | 92 | // Don't resparse files in too-big chunks. |
| 93 | // libsparse will support INT_MAX, but this results in large allocations, so |
| 94 | // let's keep it at 1GB to avoid memory pressure on the host. |
| 95 | static constexpr int64_t RESPARSE_LIMIT = 1 * 1024 * 1024 * 1024; |
Elliott Hughes | 542370d | 2018-04-19 19:49:44 -0700 | [diff] [blame] | 96 | static uint64_t sparse_limit = 0; |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 97 | static int64_t target_sparse_limit = -1; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 98 | |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 99 | static unsigned g_base_addr = 0x10000000; |
Hridya Valsaraju | 6c8fca6 | 2019-01-24 12:47:08 -0800 | [diff] [blame] | 100 | static boot_img_hdr_v2 g_boot_img_hdr = {}; |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 101 | static std::string g_cmdline; |
Hridya Valsaraju | 6c8fca6 | 2019-01-24 12:47:08 -0800 | [diff] [blame] | 102 | static std::string g_dtb_path; |
JP Abgrall | 7b8970c | 2013-03-07 17:06:41 -0800 | [diff] [blame] | 103 | |
David Zeuthen | b6ea435 | 2017-08-07 14:29:26 -0400 | [diff] [blame] | 104 | static bool g_disable_verity = false; |
| 105 | static bool g_disable_verification = false; |
| 106 | |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 107 | fastboot::FastBootDriver* fb = nullptr; |
| 108 | |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 109 | enum fb_buffer_type { |
Chris Fries | 0ea946c | 2017-04-12 10:25:57 -0500 | [diff] [blame] | 110 | FB_BUFFER_FD, |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 111 | FB_BUFFER_SPARSE, |
| 112 | }; |
| 113 | |
| 114 | struct fastboot_buffer { |
| 115 | enum fb_buffer_type type; |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 116 | void* data; |
| 117 | int64_t sz; |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 118 | unique_fd fd; |
David Anderson | 32e376f | 2018-08-16 13:43:11 -0700 | [diff] [blame] | 119 | int64_t image_size; |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 120 | }; |
| 121 | |
David Anderson | 0debda0 | 2018-08-28 13:54:03 -0700 | [diff] [blame] | 122 | enum class ImageType { |
| 123 | // Must be flashed for device to boot into the kernel. |
| 124 | BootCritical, |
| 125 | // Normal partition to be flashed during "flashall". |
| 126 | Normal, |
| 127 | // Partition that is never flashed during "flashall". |
| 128 | Extra |
| 129 | }; |
| 130 | |
David Anderson | 32e376f | 2018-08-16 13:43:11 -0700 | [diff] [blame] | 131 | struct Image { |
Elliott Hughes | 45964a8 | 2017-05-03 22:43:23 -0700 | [diff] [blame] | 132 | const char* nickname; |
| 133 | const char* img_name; |
| 134 | const char* sig_name; |
| 135 | const char* part_name; |
Hridya Valsaraju | f1f0a9c | 2018-08-02 10:46:21 -0700 | [diff] [blame] | 136 | bool optional_if_no_image; |
David Anderson | 0debda0 | 2018-08-28 13:54:03 -0700 | [diff] [blame] | 137 | ImageType type; |
Hridya Valsaraju | f1f0a9c | 2018-08-02 10:46:21 -0700 | [diff] [blame] | 138 | bool IsSecondary() const { return nickname == nullptr; } |
David Anderson | 32e376f | 2018-08-16 13:43:11 -0700 | [diff] [blame] | 139 | }; |
| 140 | |
| 141 | static Image images[] = { |
Dario Freni | c7ea1af | 2018-05-25 16:07:19 +0100 | [diff] [blame] | 142 | // clang-format off |
David Anderson | 0debda0 | 2018-08-28 13:54:03 -0700 | [diff] [blame] | 143 | { "boot", "boot.img", "boot.sig", "boot", false, ImageType::BootCritical }, |
Devin Moore | dd1eb87 | 2022-01-05 00:20:15 +0000 | [diff] [blame] | 144 | { "init_boot", |
| 145 | "init_boot.img", "init_boot.sig", |
| 146 | "init_boot", |
Devin Moore | 60bd33f | 2022-01-11 02:01:26 +0000 | [diff] [blame] | 147 | true, ImageType::BootCritical }, |
David Anderson | 0debda0 | 2018-08-28 13:54:03 -0700 | [diff] [blame] | 148 | { nullptr, "boot_other.img", "boot.sig", "boot", true, ImageType::Normal }, |
| 149 | { "cache", "cache.img", "cache.sig", "cache", true, ImageType::Extra }, |
| 150 | { "dtbo", "dtbo.img", "dtbo.sig", "dtbo", true, ImageType::BootCritical }, |
| 151 | { "dts", "dt.img", "dt.sig", "dts", true, ImageType::BootCritical }, |
| 152 | { "odm", "odm.img", "odm.sig", "odm", true, ImageType::Normal }, |
Yifan Hong | be78bb6 | 2020-07-15 17:07:11 -0700 | [diff] [blame] | 153 | { "odm_dlkm", "odm_dlkm.img", "odm_dlkm.sig", "odm_dlkm", true, ImageType::Normal }, |
David Anderson | 0debda0 | 2018-08-28 13:54:03 -0700 | [diff] [blame] | 154 | { "product", "product.img", "product.sig", "product", true, ImageType::Normal }, |
Andrew Scull | be823d7 | 2021-01-15 14:37:15 +0000 | [diff] [blame] | 155 | { "pvmfw", "pvmfw.img", "pvmfw.sig", "pvmfw", true, ImageType::BootCritical }, |
David Anderson | 0debda0 | 2018-08-28 13:54:03 -0700 | [diff] [blame] | 156 | { "recovery", "recovery.img", "recovery.sig", "recovery", true, ImageType::BootCritical }, |
| 157 | { "super", "super.img", "super.sig", "super", true, ImageType::Extra }, |
| 158 | { "system", "system.img", "system.sig", "system", false, ImageType::Normal }, |
Ramji Jiyani | b3ddb53 | 2021-12-06 02:28:28 +0000 | [diff] [blame] | 159 | { "system_dlkm", |
| 160 | "system_dlkm.img", "system_dlkm.sig", |
| 161 | "system_dlkm", |
| 162 | true, ImageType::Normal }, |
Justin Yun | 5d0ac62 | 2019-06-26 09:18:03 +0900 | [diff] [blame] | 163 | { "system_ext", |
| 164 | "system_ext.img", "system_ext.sig", |
| 165 | "system_ext", |
| 166 | true, ImageType::Normal }, |
David Anderson | 0debda0 | 2018-08-28 13:54:03 -0700 | [diff] [blame] | 167 | { nullptr, "system_other.img", "system.sig", "system", true, ImageType::Normal }, |
| 168 | { "userdata", "userdata.img", "userdata.sig", "userdata", true, ImageType::Extra }, |
| 169 | { "vbmeta", "vbmeta.img", "vbmeta.sig", "vbmeta", true, ImageType::BootCritical }, |
David Anderson | 166bfef | 2018-10-15 14:46:59 -0700 | [diff] [blame] | 170 | { "vbmeta_system", |
| 171 | "vbmeta_system.img", |
| 172 | "vbmeta_system.sig", |
| 173 | "vbmeta_system", |
David Anderson | 1109c92 | 2018-09-17 17:32:54 -0700 | [diff] [blame] | 174 | true, ImageType::BootCritical }, |
Bowgo Tsai | a48a783 | 2021-06-03 14:39:34 +0800 | [diff] [blame] | 175 | { "vbmeta_vendor", |
| 176 | "vbmeta_vendor.img", |
| 177 | "vbmeta_vendor.sig", |
| 178 | "vbmeta_vendor", |
| 179 | true, ImageType::BootCritical }, |
David Anderson | 0debda0 | 2018-08-28 13:54:03 -0700 | [diff] [blame] | 180 | { "vendor", "vendor.img", "vendor.sig", "vendor", true, ImageType::Normal }, |
Steve Muckle | 3611243 | 2019-08-21 11:16:14 -0700 | [diff] [blame] | 181 | { "vendor_boot", |
| 182 | "vendor_boot.img", "vendor_boot.sig", |
| 183 | "vendor_boot", |
| 184 | true, ImageType::BootCritical }, |
Yifan Hong | 6b1c15c | 2020-05-12 10:38:53 -0700 | [diff] [blame] | 185 | { "vendor_dlkm", |
| 186 | "vendor_dlkm.img", "vendor_dlkm.sig", |
| 187 | "vendor_dlkm", |
| 188 | true, ImageType::Normal }, |
David Anderson | 0debda0 | 2018-08-28 13:54:03 -0700 | [diff] [blame] | 189 | { nullptr, "vendor_other.img", "vendor.sig", "vendor", true, ImageType::Normal }, |
Dario Freni | c7ea1af | 2018-05-25 16:07:19 +0100 | [diff] [blame] | 190 | // clang-format on |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 191 | }; |
Brian Swetland | 2a63bb7 | 2009-04-28 16:05:07 -0700 | [diff] [blame] | 192 | |
David Anderson | e0e693c | 2018-11-27 20:19:26 -0800 | [diff] [blame] | 193 | static char* get_android_product_out() { |
Elliott Hughes | 45964a8 | 2017-05-03 22:43:23 -0700 | [diff] [blame] | 194 | char* dir = getenv("ANDROID_PRODUCT_OUT"); |
Alex Light | bb9b8a5 | 2016-06-29 09:26:44 -0700 | [diff] [blame] | 195 | if (dir == nullptr || dir[0] == '\0') { |
David Anderson | e0e693c | 2018-11-27 20:19:26 -0800 | [diff] [blame] | 196 | return nullptr; |
| 197 | } |
| 198 | return dir; |
| 199 | } |
| 200 | |
| 201 | static std::string find_item_given_name(const std::string& img_name) { |
| 202 | char* dir = get_android_product_out(); |
| 203 | if (!dir) { |
Elliott Hughes | 45964a8 | 2017-05-03 22:43:23 -0700 | [diff] [blame] | 204 | die("ANDROID_PRODUCT_OUT not set"); |
Alex Light | bb9b8a5 | 2016-06-29 09:26:44 -0700 | [diff] [blame] | 205 | } |
David Anderson | 0debda0 | 2018-08-28 13:54:03 -0700 | [diff] [blame] | 206 | return std::string(dir) + "/" + img_name; |
Alex Light | bb9b8a5 | 2016-06-29 09:26:44 -0700 | [diff] [blame] | 207 | } |
| 208 | |
Elliott Hughes | 29d5d7d | 2017-05-11 15:05:13 -0700 | [diff] [blame] | 209 | static std::string find_item(const std::string& item) { |
Elliott Hughes | 45964a8 | 2017-05-03 22:43:23 -0700 | [diff] [blame] | 210 | for (size_t i = 0; i < arraysize(images); ++i) { |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 211 | if (images[i].nickname && item == images[i].nickname) { |
Elliott Hughes | 45964a8 | 2017-05-03 22:43:23 -0700 | [diff] [blame] | 212 | return find_item_given_name(images[i].img_name); |
| 213 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 214 | } |
| 215 | |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 216 | fprintf(stderr, "unknown partition '%s'\n", item.c_str()); |
Elliott Hughes | 45964a8 | 2017-05-03 22:43:23 -0700 | [diff] [blame] | 217 | return ""; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 218 | } |
| 219 | |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 220 | double last_start_time; |
| 221 | |
| 222 | static void Status(const std::string& message) { |
Tom Cherry | 2217c50 | 2020-06-10 09:29:25 -0700 | [diff] [blame] | 223 | if (!message.empty()) { |
| 224 | static constexpr char kStatusFormat[] = "%-50s "; |
| 225 | fprintf(stderr, kStatusFormat, message.c_str()); |
| 226 | } |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 227 | last_start_time = now(); |
| 228 | } |
| 229 | |
| 230 | static void Epilog(int status) { |
| 231 | if (status) { |
| 232 | fprintf(stderr, "FAILED (%s)\n", fb->Error().c_str()); |
| 233 | die("Command failed"); |
| 234 | } else { |
| 235 | double split = now(); |
| 236 | fprintf(stderr, "OKAY [%7.3fs]\n", (split - last_start_time)); |
| 237 | } |
| 238 | } |
| 239 | |
| 240 | static void InfoMessage(const std::string& info) { |
| 241 | fprintf(stderr, "(bootloader) %s\n", info.c_str()); |
| 242 | } |
| 243 | |
Yifan Hong | 58532df | 2021-03-22 16:39:13 -0700 | [diff] [blame] | 244 | static int64_t get_file_size(borrowed_fd fd) { |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 245 | struct stat sb; |
Yifan Hong | 58532df | 2021-03-22 16:39:13 -0700 | [diff] [blame] | 246 | if (fstat(fd.get(), &sb) == -1) { |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 247 | die("could not get file size"); |
| 248 | } |
| 249 | return sb.st_size; |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 250 | } |
| 251 | |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 252 | bool ReadFileToVector(const std::string& file, std::vector<char>* out) { |
| 253 | out->clear(); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 254 | |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 255 | unique_fd fd(TEMP_FAILURE_RETRY(open(file.c_str(), O_RDONLY | O_CLOEXEC | O_BINARY))); |
| 256 | if (fd == -1) { |
| 257 | return false; |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 258 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 259 | |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 260 | out->resize(get_file_size(fd)); |
| 261 | return ReadFully(fd, out->data(), out->size()); |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 262 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 263 | |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 264 | static int match_fastboot_with_serial(usb_ifc_info* info, const char* local_serial) { |
Elliott Hughes | e1746fd | 2015-08-10 15:30:54 -0700 | [diff] [blame] | 265 | if (info->ifc_class != 0xff || info->ifc_subclass != 0x42 || info->ifc_protocol != 0x03) { |
| 266 | return -1; |
| 267 | } |
| 268 | |
Scott Anderson | 13081c6 | 2012-04-06 12:39:30 -0700 | [diff] [blame] | 269 | // require matching serial number or device path if requested |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 270 | // at the command line with the -s option. |
JP Abgrall | a032ded | 2012-06-06 11:53:33 -0700 | [diff] [blame] | 271 | if (local_serial && (strcmp(local_serial, info->serial_number) != 0 && |
| 272 | strcmp(local_serial, info->device_path) != 0)) return -1; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 273 | return 0; |
| 274 | } |
| 275 | |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 276 | static int match_fastboot(usb_ifc_info* info) { |
JP Abgrall | 7b8970c | 2013-03-07 17:06:41 -0800 | [diff] [blame] | 277 | return match_fastboot_with_serial(info, serial); |
| 278 | } |
| 279 | |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 280 | static int list_devices_callback(usb_ifc_info* info) { |
| 281 | if (match_fastboot_with_serial(info, nullptr) == 0) { |
Elliott Hughes | 1b708d3 | 2015-12-11 19:07:01 -0800 | [diff] [blame] | 282 | std::string serial = info->serial_number; |
David Anderson | 4e058ca | 2020-05-28 04:39:37 +0000 | [diff] [blame] | 283 | std::string interface = info->interface; |
| 284 | if (interface.empty()) { |
| 285 | interface = "fastboot"; |
| 286 | } |
Elliott Hughes | b4add9b | 2009-10-06 18:07:49 -0700 | [diff] [blame] | 287 | if (!info->writable) { |
Elliott Hughes | 1b708d3 | 2015-12-11 19:07:01 -0800 | [diff] [blame] | 288 | serial = UsbNoPermissionsShortHelpText(); |
Elliott Hughes | b4add9b | 2009-10-06 18:07:49 -0700 | [diff] [blame] | 289 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 290 | if (!serial[0]) { |
| 291 | serial = "????????????"; |
| 292 | } |
Scott Anderson | 866b1bd | 2012-06-04 20:29:11 -0700 | [diff] [blame] | 293 | // output compatible with "adb devices" |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 294 | if (!g_long_listing) { |
David Anderson | 4e058ca | 2020-05-28 04:39:37 +0000 | [diff] [blame] | 295 | printf("%s\t%s", serial.c_str(), interface.c_str()); |
Scott Anderson | 13081c6 | 2012-04-06 12:39:30 -0700 | [diff] [blame] | 296 | } else { |
David Anderson | 4e058ca | 2020-05-28 04:39:37 +0000 | [diff] [blame] | 297 | printf("%-22s %s", serial.c_str(), interface.c_str()); |
Elliott Hughes | 1b708d3 | 2015-12-11 19:07:01 -0800 | [diff] [blame] | 298 | if (strlen(info->device_path) > 0) printf(" %s", info->device_path); |
Scott Anderson | 13081c6 | 2012-04-06 12:39:30 -0700 | [diff] [blame] | 299 | } |
Elliott Hughes | 1b708d3 | 2015-12-11 19:07:01 -0800 | [diff] [blame] | 300 | putchar('\n'); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 301 | } |
| 302 | |
| 303 | return -1; |
| 304 | } |
| 305 | |
David Pursell | 2ec418a | 2016-01-20 08:32:08 -0800 | [diff] [blame] | 306 | // Opens a new Transport connected to a device. If |serial| is non-null it will be used to identify |
| 307 | // a specific device, otherwise the first USB device found will be used. |
| 308 | // |
Elliott Hughes | 855cdf8 | 2018-04-02 14:24:03 -0700 | [diff] [blame] | 309 | // If |serial| is non-null but invalid, this exits. |
David Pursell | 2ec418a | 2016-01-20 08:32:08 -0800 | [diff] [blame] | 310 | // Otherwise it blocks until the target is available. |
| 311 | // |
| 312 | // The returned Transport is a singleton, so multiple calls to this function will return the same |
| 313 | // object, and the caller should not attempt to delete the returned Transport. |
David Pursell | 0b15663 | 2015-10-30 11:22:01 -0700 | [diff] [blame] | 314 | static Transport* open_device() { |
David Pursell | 2ec418a | 2016-01-20 08:32:08 -0800 | [diff] [blame] | 315 | bool announce = true; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 316 | |
David Pursell | 4601c97 | 2016-02-05 15:35:09 -0800 | [diff] [blame] | 317 | Socket::Protocol protocol = Socket::Protocol::kTcp; |
David Pursell | 2ec418a | 2016-01-20 08:32:08 -0800 | [diff] [blame] | 318 | std::string host; |
David Pursell | 4601c97 | 2016-02-05 15:35:09 -0800 | [diff] [blame] | 319 | int port = 0; |
| 320 | if (serial != nullptr) { |
| 321 | const char* net_address = nullptr; |
David Pursell | 2ec418a | 2016-01-20 08:32:08 -0800 | [diff] [blame] | 322 | |
David Pursell | 4601c97 | 2016-02-05 15:35:09 -0800 | [diff] [blame] | 323 | if (android::base::StartsWith(serial, "tcp:")) { |
| 324 | protocol = Socket::Protocol::kTcp; |
| 325 | port = tcp::kDefaultPort; |
| 326 | net_address = serial + strlen("tcp:"); |
| 327 | } else if (android::base::StartsWith(serial, "udp:")) { |
| 328 | protocol = Socket::Protocol::kUdp; |
| 329 | port = udp::kDefaultPort; |
| 330 | net_address = serial + strlen("udp:"); |
| 331 | } |
| 332 | |
| 333 | if (net_address != nullptr) { |
| 334 | std::string error; |
| 335 | if (!android::base::ParseNetAddress(net_address, &host, &port, nullptr, &error)) { |
Elliott Hughes | 855cdf8 | 2018-04-02 14:24:03 -0700 | [diff] [blame] | 336 | die("invalid network address '%s': %s\n", net_address, error.c_str()); |
David Pursell | 4601c97 | 2016-02-05 15:35:09 -0800 | [diff] [blame] | 337 | } |
David Pursell | 2ec418a | 2016-01-20 08:32:08 -0800 | [diff] [blame] | 338 | } |
| 339 | } |
| 340 | |
David Anderson | 1d88743 | 2018-08-27 16:47:32 -0700 | [diff] [blame] | 341 | Transport* transport = nullptr; |
David Pursell | 2ec418a | 2016-01-20 08:32:08 -0800 | [diff] [blame] | 342 | while (true) { |
| 343 | if (!host.empty()) { |
| 344 | std::string error; |
David Pursell | 4601c97 | 2016-02-05 15:35:09 -0800 | [diff] [blame] | 345 | if (protocol == Socket::Protocol::kTcp) { |
| 346 | transport = tcp::Connect(host, port, &error).release(); |
| 347 | } else if (protocol == Socket::Protocol::kUdp) { |
| 348 | transport = udp::Connect(host, port, &error).release(); |
| 349 | } |
| 350 | |
David Pursell | 2ec418a | 2016-01-20 08:32:08 -0800 | [diff] [blame] | 351 | if (transport == nullptr && announce) { |
| 352 | fprintf(stderr, "error: %s\n", error.c_str()); |
| 353 | } |
| 354 | } else { |
| 355 | transport = usb_open(match_fastboot); |
| 356 | } |
| 357 | |
| 358 | if (transport != nullptr) { |
| 359 | return transport; |
| 360 | } |
| 361 | |
David Pursell | 0b15663 | 2015-10-30 11:22:01 -0700 | [diff] [blame] | 362 | if (announce) { |
David Pursell | 2ec418a | 2016-01-20 08:32:08 -0800 | [diff] [blame] | 363 | announce = false; |
Elliott Hughes | b46964f | 2015-08-19 17:49:45 -0700 | [diff] [blame] | 364 | fprintf(stderr, "< waiting for %s >\n", serial ? serial : "any device"); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 365 | } |
Elliott Hughes | 290a228 | 2016-11-14 17:08:47 -0800 | [diff] [blame] | 366 | std::this_thread::sleep_for(std::chrono::milliseconds(1)); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 367 | } |
| 368 | } |
| 369 | |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 370 | static void list_devices() { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 371 | // We don't actually open a USB device here, |
| 372 | // just getting our callback called so we can |
| 373 | // list all the connected devices. |
| 374 | usb_open(list_devices_callback); |
| 375 | } |
| 376 | |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 377 | static void syntax_error(const char* fmt, ...) { |
| 378 | fprintf(stderr, "fastboot: usage: "); |
| 379 | |
| 380 | va_list ap; |
| 381 | va_start(ap, fmt); |
| 382 | vfprintf(stderr, fmt, ap); |
| 383 | va_end(ap); |
| 384 | |
| 385 | fprintf(stderr, "\n"); |
| 386 | exit(1); |
| 387 | } |
| 388 | |
| 389 | static int show_help() { |
| 390 | // clang-format off |
| 391 | fprintf(stdout, |
Elliott Hughes | 07fc682 | 2018-05-24 16:36:05 -0700 | [diff] [blame] | 392 | // 1 2 3 4 5 6 7 8 |
| 393 | // 12345678901234567890123456789012345678901234567890123456789012345678901234567890 |
Elliott Hughes | b76188f | 2018-04-03 13:30:18 -0700 | [diff] [blame] | 394 | "usage: fastboot [OPTION...] COMMAND...\n" |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 395 | "\n" |
Elliott Hughes | b76188f | 2018-04-03 13:30:18 -0700 | [diff] [blame] | 396 | "flashing:\n" |
| 397 | " update ZIP Flash all partitions from an update.zip package.\n" |
| 398 | " flashall Flash all partitions from $ANDROID_PRODUCT_OUT.\n" |
| 399 | " On A/B devices, flashed slot is set as active.\n" |
| 400 | " Secondary images may be flashed to inactive slot.\n" |
Elliott Hughes | 07fc682 | 2018-05-24 16:36:05 -0700 | [diff] [blame] | 401 | " flash PARTITION [FILENAME] Flash given partition, using the image from\n" |
| 402 | " $ANDROID_PRODUCT_OUT if no filename is given.\n" |
Elliott Hughes | b76188f | 2018-04-03 13:30:18 -0700 | [diff] [blame] | 403 | "\n" |
| 404 | "basics:\n" |
| 405 | " devices [-l] List devices in bootloader (-l: with device paths).\n" |
| 406 | " getvar NAME Display given bootloader variable.\n" |
| 407 | " reboot [bootloader] Reboot device.\n" |
| 408 | "\n" |
| 409 | "locking/unlocking:\n" |
| 410 | " flashing lock|unlock Lock/unlock partitions for flashing\n" |
| 411 | " flashing lock_critical|unlock_critical\n" |
| 412 | " Lock/unlock 'critical' bootloader partitions.\n" |
| 413 | " flashing get_unlock_ability\n" |
| 414 | " Check whether unlocking is allowed (1) or not(0).\n" |
| 415 | "\n" |
| 416 | "advanced:\n" |
| 417 | " erase PARTITION Erase a flash partition.\n" |
| 418 | " format[:FS_TYPE[:SIZE]] PARTITION\n" |
| 419 | " Format a flash partition.\n" |
| 420 | " set_active SLOT Set the active slot.\n" |
| 421 | " oem [COMMAND...] Execute OEM-specific command.\n" |
David Anderson | 1d504e3 | 2019-01-15 14:38:20 -0800 | [diff] [blame] | 422 | " gsi wipe|disable Wipe or disable a GSI installation (fastbootd only).\n" |
David Anderson | 7c84b9f | 2019-06-27 22:15:29 -0700 | [diff] [blame] | 423 | " wipe-super [SUPER_EMPTY] Wipe the super partition. This will reset it to\n" |
| 424 | " contain an empty set of default dynamic partitions.\n" |
Luca Stefani | 173667b | 2021-04-12 19:16:43 +0200 | [diff] [blame] | 425 | " create-logical-partition NAME SIZE\n" |
| 426 | " Create a logical partition with the given name and\n" |
| 427 | " size, in the super partition.\n" |
| 428 | " delete-logical-partition NAME\n" |
| 429 | " Delete a logical partition with the given name.\n" |
| 430 | " resize-logical-partition NAME SIZE\n" |
| 431 | " Change the size of the named logical partition.\n" |
David Anderson | ab8f466 | 2019-10-21 16:45:59 -0700 | [diff] [blame] | 432 | " snapshot-update cancel On devices that support snapshot-based updates, cancel\n" |
| 433 | " an in-progress update. This may make the device\n" |
| 434 | " unbootable until it is reflashed.\n" |
David Anderson | 220ddb1 | 2019-10-31 18:02:41 -0700 | [diff] [blame] | 435 | " snapshot-update merge On devices that support snapshot-based updates, finish\n" |
| 436 | " an in-progress update if it is in the \"merging\"\n" |
| 437 | " phase.\n" |
Pierre-Clément Tosi | 96941a0 | 2021-06-14 12:16:06 +0000 | [diff] [blame] | 438 | " fetch PARTITION OUT_FILE Fetch a partition image from the device." |
Elliott Hughes | b76188f | 2018-04-03 13:30:18 -0700 | [diff] [blame] | 439 | "\n" |
| 440 | "boot image:\n" |
| 441 | " boot KERNEL [RAMDISK [SECOND]]\n" |
| 442 | " Download and boot kernel from RAM.\n" |
| 443 | " flash:raw PARTITION KERNEL [RAMDISK [SECOND]]\n" |
| 444 | " Create boot image and flash it.\n" |
Hridya Valsaraju | 6c8fca6 | 2019-01-24 12:47:08 -0800 | [diff] [blame] | 445 | " --dtb DTB Specify path to DTB for boot image header version 2.\n" |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 446 | " --cmdline CMDLINE Override kernel command line.\n" |
Elliott Hughes | b76188f | 2018-04-03 13:30:18 -0700 | [diff] [blame] | 447 | " --base ADDRESS Set kernel base address (default: 0x10000000).\n" |
| 448 | " --kernel-offset Set kernel offset (default: 0x00008000).\n" |
| 449 | " --ramdisk-offset Set ramdisk offset (default: 0x01000000).\n" |
| 450 | " --tags-offset Set tags offset (default: 0x00000100).\n" |
Hridya Valsaraju | 6c8fca6 | 2019-01-24 12:47:08 -0800 | [diff] [blame] | 451 | " --dtb-offset Set dtb offset (default: 0x01100000).\n" |
Elliott Hughes | b76188f | 2018-04-03 13:30:18 -0700 | [diff] [blame] | 452 | " --page-size BYTES Set flash page size (default: 2048).\n" |
| 453 | " --header-version VERSION Set boot image header version.\n" |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 454 | " --os-version MAJOR[.MINOR[.PATCH]]\n" |
| 455 | " Set boot image OS version (default: 0.0.0).\n" |
| 456 | " --os-patch-level YYYY-MM-DD\n" |
| 457 | " Set boot image OS security patch level.\n" |
| 458 | // TODO: still missing: `second_addr`, `name`, `id`, `recovery_dtbo_*`. |
Elliott Hughes | b76188f | 2018-04-03 13:30:18 -0700 | [diff] [blame] | 459 | "\n" |
Elliott Hughes | 2e9b779 | 2018-04-04 13:36:44 -0700 | [diff] [blame] | 460 | // TODO: what device(s) used this? is there any documentation? |
Elliott Hughes | b76188f | 2018-04-03 13:30:18 -0700 | [diff] [blame] | 461 | //" continue Continue with autoboot.\n" |
| 462 | //"\n" |
| 463 | "Android Things:\n" |
| 464 | " stage IN_FILE Sends given file to stage for the next command.\n" |
| 465 | " get_staged OUT_FILE Writes data staged by the last command to a file.\n" |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 466 | "\n" |
| 467 | "options:\n" |
Elliott Hughes | b76188f | 2018-04-03 13:30:18 -0700 | [diff] [blame] | 468 | " -w Wipe userdata.\n" |
Elliott Hughes | b76188f | 2018-04-03 13:30:18 -0700 | [diff] [blame] | 469 | " -s SERIAL Specify a USB device.\n" |
| 470 | " -s tcp|udp:HOST[:PORT] Specify a network device.\n" |
Elliott Hughes | 542370d | 2018-04-19 19:49:44 -0700 | [diff] [blame] | 471 | " -S SIZE[K|M|G] Break into sparse files no larger than SIZE.\n" |
David Anderson | 8956964 | 2018-11-16 15:53:35 -0800 | [diff] [blame] | 472 | " --force Force a flash operation that may be unsafe.\n" |
Elliott Hughes | b76188f | 2018-04-03 13:30:18 -0700 | [diff] [blame] | 473 | " --slot SLOT Use SLOT; 'all' for both slots, 'other' for\n" |
| 474 | " non-current slot (default: current active slot).\n" |
| 475 | " --set-active[=SLOT] Sets the active slot before rebooting.\n" |
| 476 | " --skip-secondary Don't flash secondary slots in flashall/update.\n" |
| 477 | " --skip-reboot Don't reboot device after flashing.\n" |
| 478 | " --disable-verity Sets disable-verity when flashing vbmeta.\n" |
| 479 | " --disable-verification Sets disable-verification when flashing vbmeta.\n" |
Jaegeuk Kim | 638d05e | 2020-11-09 08:54:13 -0800 | [diff] [blame] | 480 | " --fs-options=OPTION[,OPTION]\n" |
| 481 | " Enable filesystem features. OPTION supports casefold, projid, compress\n" |
Elliott Hughes | b76188f | 2018-04-03 13:30:18 -0700 | [diff] [blame] | 482 | // TODO: remove --unbuffered? |
| 483 | " --unbuffered Don't buffer input or output.\n" |
| 484 | " --verbose, -v Verbose output.\n" |
| 485 | " --version Display version.\n" |
| 486 | " --help, -h Show this message.\n" |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 487 | ); |
Yifan Hong | bcd2770 | 2021-02-16 19:37:32 -0800 | [diff] [blame] | 488 | // clang-format on |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 489 | return 0; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 490 | } |
Paul Crowley | 8f7f56e | 2015-11-27 09:29:37 +0000 | [diff] [blame] | 491 | |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 492 | static std::vector<char> LoadBootableImage(const std::string& kernel, const std::string& ramdisk, |
| 493 | const std::string& second_stage) { |
| 494 | std::vector<char> kernel_data; |
| 495 | if (!ReadFileToVector(kernel, &kernel_data)) { |
| 496 | die("cannot load '%s': %s", kernel.c_str(), strerror(errno)); |
| 497 | } |
Tsu Chiang Chuang | ee52055 | 2011-02-25 18:38:53 -0800 | [diff] [blame] | 498 | |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 499 | // Is this actually a boot image? |
Steve Muckle | 15303f2 | 2020-03-18 14:55:06 -0700 | [diff] [blame] | 500 | if (kernel_data.size() < sizeof(boot_img_hdr_v3)) { |
Elliott Hughes | aaa3b6b | 2018-01-18 16:08:24 -0800 | [diff] [blame] | 501 | die("cannot load '%s': too short", kernel.c_str()); |
| 502 | } |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 503 | if (!memcmp(kernel_data.data(), BOOT_MAGIC, BOOT_MAGIC_SIZE)) { |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 504 | if (!g_cmdline.empty()) { |
Hridya Valsaraju | 6c8fca6 | 2019-01-24 12:47:08 -0800 | [diff] [blame] | 505 | bootimg_set_cmdline(reinterpret_cast<boot_img_hdr_v2*>(kernel_data.data()), g_cmdline); |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 506 | } |
Tsu Chiang Chuang | ee52055 | 2011-02-25 18:38:53 -0800 | [diff] [blame] | 507 | |
Elliott Hughes | 4089d34 | 2017-10-27 14:21:12 -0700 | [diff] [blame] | 508 | if (!ramdisk.empty()) die("cannot boot a boot.img *and* ramdisk"); |
Tsu Chiang Chuang | ee52055 | 2011-02-25 18:38:53 -0800 | [diff] [blame] | 509 | |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 510 | return kernel_data; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 511 | } |
| 512 | |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 513 | std::vector<char> ramdisk_data; |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 514 | if (!ramdisk.empty()) { |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 515 | if (!ReadFileToVector(ramdisk, &ramdisk_data)) { |
| 516 | die("cannot load '%s': %s", ramdisk.c_str(), strerror(errno)); |
| 517 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 518 | } |
| 519 | |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 520 | std::vector<char> second_stage_data; |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 521 | if (!second_stage.empty()) { |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 522 | if (!ReadFileToVector(second_stage, &second_stage_data)) { |
| 523 | die("cannot load '%s': %s", second_stage.c_str(), strerror(errno)); |
| 524 | } |
Jeremy Compostella | a42adff | 2014-07-17 17:17:54 +0200 | [diff] [blame] | 525 | } |
Hridya Valsaraju | 6c8fca6 | 2019-01-24 12:47:08 -0800 | [diff] [blame] | 526 | |
| 527 | std::vector<char> dtb_data; |
| 528 | if (!g_dtb_path.empty()) { |
Steve Muckle | 15303f2 | 2020-03-18 14:55:06 -0700 | [diff] [blame] | 529 | if (g_boot_img_hdr.header_version != 2) { |
Hridya Valsaraju | 6c8fca6 | 2019-01-24 12:47:08 -0800 | [diff] [blame] | 530 | die("Argument dtb not supported for boot image header version %d\n", |
| 531 | g_boot_img_hdr.header_version); |
| 532 | } |
| 533 | if (!ReadFileToVector(g_dtb_path, &dtb_data)) { |
| 534 | die("cannot load '%s': %s", g_dtb_path.c_str(), strerror(errno)); |
| 535 | } |
| 536 | } |
| 537 | |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 538 | fprintf(stderr,"creating boot image...\n"); |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 539 | |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 540 | std::vector<char> out; |
Yi-Yo Chiang | ac4a136 | 2021-03-25 01:14:52 +0800 | [diff] [blame] | 541 | mkbootimg(kernel_data, ramdisk_data, second_stage_data, dtb_data, g_base_addr, g_boot_img_hdr, |
| 542 | &out); |
Tsu Chiang Chuang | ee52055 | 2011-02-25 18:38:53 -0800 | [diff] [blame] | 543 | |
Yi-Yo Chiang | ac4a136 | 2021-03-25 01:14:52 +0800 | [diff] [blame] | 544 | if (!g_cmdline.empty()) { |
| 545 | bootimg_set_cmdline(reinterpret_cast<boot_img_hdr_v2*>(out.data()), g_cmdline); |
| 546 | } |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 547 | fprintf(stderr, "creating boot image - %zu bytes\n", out.size()); |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 548 | return out; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 549 | } |
| 550 | |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 551 | static bool UnzipToMemory(ZipArchiveHandle zip, const std::string& entry_name, |
| 552 | std::vector<char>* out) { |
Elliott Hughes | b407414 | 2020-09-15 14:26:17 -0700 | [diff] [blame] | 553 | ZipEntry64 zip_entry; |
Elliott Hughes | b17bf52 | 2019-05-03 22:38:44 -0700 | [diff] [blame] | 554 | if (FindEntry(zip, entry_name, &zip_entry) != 0) { |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 555 | fprintf(stderr, "archive does not contain '%s'\n", entry_name.c_str()); |
| 556 | return false; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 557 | } |
| 558 | |
Elliott Hughes | b407414 | 2020-09-15 14:26:17 -0700 | [diff] [blame] | 559 | if (zip_entry.uncompressed_length > std::numeric_limits<size_t>::max()) { |
| 560 | die("entry '%s' is too large: %" PRIu64, entry_name.c_str(), zip_entry.uncompressed_length); |
| 561 | } |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 562 | out->resize(zip_entry.uncompressed_length); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 563 | |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 564 | fprintf(stderr, "extracting %s (%zu MB) to RAM...\n", entry_name.c_str(), |
| 565 | out->size() / 1024 / 1024); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 566 | |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 567 | int error = ExtractToMemory(zip, &zip_entry, reinterpret_cast<uint8_t*>(out->data()), |
| 568 | out->size()); |
| 569 | if (error != 0) die("failed to extract '%s': %s", entry_name.c_str(), ErrorCodeString(error)); |
Alexander Levitskiy | 8d7ddb3 | 2014-05-07 23:31:59 +0000 | [diff] [blame] | 570 | |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 571 | return true; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 572 | } |
| 573 | |
Elliott Hughes | a26fbee | 2015-06-03 15:22:11 -0700 | [diff] [blame] | 574 | #if defined(_WIN32) |
| 575 | |
| 576 | // TODO: move this to somewhere it can be shared. |
| 577 | |
| 578 | #include <windows.h> |
| 579 | |
| 580 | // Windows' tmpfile(3) requires administrator rights because |
| 581 | // it creates temporary files in the root directory. |
| 582 | static FILE* win32_tmpfile() { |
| 583 | char temp_path[PATH_MAX]; |
| 584 | DWORD nchars = GetTempPath(sizeof(temp_path), temp_path); |
| 585 | if (nchars == 0 || nchars >= sizeof(temp_path)) { |
Elliott Hughes | 4089d34 | 2017-10-27 14:21:12 -0700 | [diff] [blame] | 586 | die("GetTempPath failed, error %ld", GetLastError()); |
Elliott Hughes | a26fbee | 2015-06-03 15:22:11 -0700 | [diff] [blame] | 587 | } |
| 588 | |
| 589 | char filename[PATH_MAX]; |
| 590 | if (GetTempFileName(temp_path, "fastboot", 0, filename) == 0) { |
Elliott Hughes | 4089d34 | 2017-10-27 14:21:12 -0700 | [diff] [blame] | 591 | die("GetTempFileName failed, error %ld", GetLastError()); |
Elliott Hughes | a26fbee | 2015-06-03 15:22:11 -0700 | [diff] [blame] | 592 | } |
| 593 | |
| 594 | return fopen(filename, "w+bTD"); |
| 595 | } |
| 596 | |
| 597 | #define tmpfile win32_tmpfile |
| 598 | |
Elliott Hughes | 855cdf8 | 2018-04-02 14:24:03 -0700 | [diff] [blame] | 599 | static int make_temporary_fd(const char* /*what*/) { |
Elliott Hughes | bbfc281 | 2017-04-25 18:33:09 -0700 | [diff] [blame] | 600 | // TODO: reimplement to avoid leaking a FILE*. |
| 601 | return fileno(tmpfile()); |
| 602 | } |
| 603 | |
Paul Crowley | 8f7f56e | 2015-11-27 09:29:37 +0000 | [diff] [blame] | 604 | #else |
| 605 | |
Elliott Hughes | bbfc281 | 2017-04-25 18:33:09 -0700 | [diff] [blame] | 606 | static std::string make_temporary_template() { |
| 607 | const char* tmpdir = getenv("TMPDIR"); |
| 608 | if (tmpdir == nullptr) tmpdir = P_tmpdir; |
| 609 | return std::string(tmpdir) + "/fastboot_userdata_XXXXXX"; |
| 610 | } |
| 611 | |
Elliott Hughes | 855cdf8 | 2018-04-02 14:24:03 -0700 | [diff] [blame] | 612 | static int make_temporary_fd(const char* what) { |
Elliott Hughes | bbfc281 | 2017-04-25 18:33:09 -0700 | [diff] [blame] | 613 | std::string path_template(make_temporary_template()); |
| 614 | int fd = mkstemp(&path_template[0]); |
| 615 | if (fd == -1) { |
Elliott Hughes | da1dbd6 | 2018-05-21 23:02:26 -0700 | [diff] [blame] | 616 | die("failed to create temporary file for %s with template %s: %s\n", |
| 617 | path_template.c_str(), what, strerror(errno)); |
Elliott Hughes | bbfc281 | 2017-04-25 18:33:09 -0700 | [diff] [blame] | 618 | } |
| 619 | unlink(path_template.c_str()); |
| 620 | return fd; |
| 621 | } |
| 622 | |
Elliott Hughes | a26fbee | 2015-06-03 15:22:11 -0700 | [diff] [blame] | 623 | #endif |
| 624 | |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 625 | static unique_fd unzip_to_file(ZipArchiveHandle zip, const char* entry_name) { |
Elliott Hughes | 855cdf8 | 2018-04-02 14:24:03 -0700 | [diff] [blame] | 626 | unique_fd fd(make_temporary_fd(entry_name)); |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 627 | |
Elliott Hughes | b407414 | 2020-09-15 14:26:17 -0700 | [diff] [blame] | 628 | ZipEntry64 zip_entry; |
Elliott Hughes | b17bf52 | 2019-05-03 22:38:44 -0700 | [diff] [blame] | 629 | if (FindEntry(zip, entry_name, &zip_entry) != 0) { |
Elliott Hughes | a82c89d | 2015-03-19 11:44:32 -0700 | [diff] [blame] | 630 | fprintf(stderr, "archive does not contain '%s'\n", entry_name); |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 631 | errno = ENOENT; |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 632 | return unique_fd(); |
Alexander Levitskiy | 8d7ddb3 | 2014-05-07 23:31:59 +0000 | [diff] [blame] | 633 | } |
| 634 | |
Elliott Hughes | b407414 | 2020-09-15 14:26:17 -0700 | [diff] [blame] | 635 | fprintf(stderr, "extracting %s (%" PRIu64 " MB) to disk...", entry_name, |
Elliott Hughes | bbfc281 | 2017-04-25 18:33:09 -0700 | [diff] [blame] | 636 | zip_entry.uncompressed_length / 1024 / 1024); |
Elliott Hughes | 23af112 | 2017-11-10 08:42:17 -0800 | [diff] [blame] | 637 | double start = now(); |
Yifan Hong | 58532df | 2021-03-22 16:39:13 -0700 | [diff] [blame] | 638 | int error = ExtractEntryToFile(zip, &zip_entry, fd.get()); |
Elliott Hughes | a82c89d | 2015-03-19 11:44:32 -0700 | [diff] [blame] | 639 | if (error != 0) { |
Elliott Hughes | 23af112 | 2017-11-10 08:42:17 -0800 | [diff] [blame] | 640 | die("\nfailed to extract '%s': %s", entry_name, ErrorCodeString(error)); |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 641 | } |
| 642 | |
Yifan Hong | 58532df | 2021-03-22 16:39:13 -0700 | [diff] [blame] | 643 | if (lseek(fd.get(), 0, SEEK_SET) != 0) { |
Elliott Hughes | 23af112 | 2017-11-10 08:42:17 -0800 | [diff] [blame] | 644 | die("\nlseek on extracted file '%s' failed: %s", entry_name, strerror(errno)); |
Elliott Hughes | 4089d34 | 2017-10-27 14:21:12 -0700 | [diff] [blame] | 645 | } |
| 646 | |
Elliott Hughes | 23af112 | 2017-11-10 08:42:17 -0800 | [diff] [blame] | 647 | fprintf(stderr, " took %.3fs\n", now() - start); |
| 648 | |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 649 | return fd; |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 650 | } |
| 651 | |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 652 | static bool CheckRequirement(const std::string& cur_product, const std::string& var, |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 653 | const std::string& product, bool invert, |
| 654 | const std::vector<std::string>& options) { |
| 655 | Status("Checking '" + var + "'"); |
Elliott Hughes | 5620d22 | 2018-03-28 08:20:00 -0700 | [diff] [blame] | 656 | |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 657 | double start = now(); |
| 658 | |
| 659 | if (!product.empty()) { |
| 660 | if (product != cur_product) { |
| 661 | double split = now(); |
| 662 | fprintf(stderr, "IGNORE, product is %s required only for %s [%7.3fs]\n", |
| 663 | cur_product.c_str(), product.c_str(), (split - start)); |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 664 | return true; |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 665 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 666 | } |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 667 | |
| 668 | std::string var_value; |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 669 | if (fb->GetVar(var, &var_value) != fastboot::SUCCESS) { |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 670 | fprintf(stderr, "FAILED\n\n"); |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 671 | fprintf(stderr, "Could not getvar for '%s' (%s)\n\n", var.c_str(), |
| 672 | fb->Error().c_str()); |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 673 | return false; |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 674 | } |
| 675 | |
| 676 | bool match = false; |
| 677 | for (const auto& option : options) { |
| 678 | if (option == var_value || (option.back() == '*' && |
| 679 | !var_value.compare(0, option.length() - 1, option, 0, |
| 680 | option.length() - 1))) { |
| 681 | match = true; |
| 682 | break; |
| 683 | } |
| 684 | } |
| 685 | |
| 686 | if (invert) { |
| 687 | match = !match; |
| 688 | } |
| 689 | |
| 690 | if (match) { |
| 691 | double split = now(); |
| 692 | fprintf(stderr, "OKAY [%7.3fs]\n", (split - start)); |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 693 | return true; |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 694 | } |
| 695 | |
| 696 | fprintf(stderr, "FAILED\n\n"); |
| 697 | fprintf(stderr, "Device %s is '%s'.\n", var.c_str(), var_value.c_str()); |
| 698 | fprintf(stderr, "Update %s '%s'", invert ? "rejects" : "requires", options[0].c_str()); |
| 699 | for (auto it = std::next(options.begin()); it != options.end(); ++it) { |
| 700 | fprintf(stderr, " or '%s'", it->c_str()); |
| 701 | } |
| 702 | fprintf(stderr, ".\n\n"); |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 703 | return false; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 704 | } |
| 705 | |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 706 | bool ParseRequirementLine(const std::string& line, std::string* name, std::string* product, |
| 707 | bool* invert, std::vector<std::string>* options) { |
Elliott Hughes | 5620d22 | 2018-03-28 08:20:00 -0700 | [diff] [blame] | 708 | // "require product=alpha|beta|gamma" |
| 709 | // "require version-bootloader=1234" |
| 710 | // "require-for-product:gamma version-bootloader=istanbul|constantinople" |
| 711 | // "require partition-exists=vendor" |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 712 | *product = ""; |
| 713 | *invert = false; |
Elliott Hughes | 5620d22 | 2018-03-28 08:20:00 -0700 | [diff] [blame] | 714 | |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 715 | auto require_reject_regex = std::regex{"(require\\s+|reject\\s+)?\\s*(\\S+)\\s*=\\s*(.*)"}; |
| 716 | auto require_product_regex = |
| 717 | std::regex{"require-for-product:\\s*(\\S+)\\s+(\\S+)\\s*=\\s*(.*)"}; |
| 718 | std::smatch match_results; |
| 719 | |
| 720 | if (std::regex_match(line, match_results, require_reject_regex)) { |
| 721 | *invert = Trim(match_results[1]) == "reject"; |
| 722 | } else if (std::regex_match(line, match_results, require_product_regex)) { |
| 723 | *product = match_results[1]; |
| 724 | } else { |
| 725 | return false; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 726 | } |
| 727 | |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 728 | *name = match_results[2]; |
Elliott Hughes | 253c18d | 2015-03-18 22:47:09 -0700 | [diff] [blame] | 729 | // Work around an unfortunate name mismatch. |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 730 | if (*name == "board") { |
| 731 | *name = "product"; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 732 | } |
| 733 | |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 734 | auto raw_options = Split(match_results[3], "|"); |
| 735 | for (const auto& option : raw_options) { |
| 736 | auto trimmed_option = Trim(option); |
| 737 | options->emplace_back(trimmed_option); |
| 738 | } |
| 739 | |
| 740 | return true; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 741 | } |
| 742 | |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 743 | // "require partition-exists=x" is a special case, added because of the trouble we had when |
| 744 | // Pixel 2 shipped with new partitions and users used old versions of fastboot to flash them, |
| 745 | // missing out new partitions. A device with new partitions can use "partition-exists" to |
| 746 | // override the fields `optional_if_no_image` in the `images` array. |
| 747 | static void HandlePartitionExists(const std::vector<std::string>& options) { |
| 748 | const std::string& partition_name = options[0]; |
| 749 | std::string has_slot; |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 750 | if (fb->GetVar("has-slot:" + partition_name, &has_slot) != fastboot::SUCCESS || |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 751 | (has_slot != "yes" && has_slot != "no")) { |
| 752 | die("device doesn't have required partition %s!", partition_name.c_str()); |
| 753 | } |
| 754 | bool known_partition = false; |
| 755 | for (size_t i = 0; i < arraysize(images); ++i) { |
| 756 | if (images[i].nickname && images[i].nickname == partition_name) { |
| 757 | images[i].optional_if_no_image = false; |
| 758 | known_partition = true; |
| 759 | } |
| 760 | } |
| 761 | if (!known_partition) { |
| 762 | die("device requires partition %s which is not known to this version of fastboot", |
| 763 | partition_name.c_str()); |
| 764 | } |
| 765 | } |
| 766 | |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 767 | static void CheckRequirements(const std::string& data, bool force_flash) { |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 768 | std::string cur_product; |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 769 | if (fb->GetVar("product", &cur_product) != fastboot::SUCCESS) { |
| 770 | fprintf(stderr, "getvar:product FAILED (%s)\n", fb->Error().c_str()); |
Tom Cherry | 4aa60b3 | 2018-09-05 15:11:44 -0700 | [diff] [blame] | 771 | } |
| 772 | |
| 773 | auto lines = Split(data, "\n"); |
| 774 | for (const auto& line : lines) { |
| 775 | if (line.empty()) { |
| 776 | continue; |
| 777 | } |
| 778 | |
| 779 | std::string name; |
| 780 | std::string product; |
| 781 | bool invert; |
| 782 | std::vector<std::string> options; |
| 783 | |
| 784 | if (!ParseRequirementLine(line, &name, &product, &invert, &options)) { |
| 785 | fprintf(stderr, "android-info.txt syntax error: %s\n", line.c_str()); |
| 786 | continue; |
| 787 | } |
| 788 | if (name == "partition-exists") { |
| 789 | HandlePartitionExists(options); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 790 | } else { |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 791 | bool met = CheckRequirement(cur_product, name, product, invert, options); |
| 792 | if (!met) { |
| 793 | if (!force_flash) { |
| 794 | die("requirements not met!"); |
| 795 | } else { |
| 796 | fprintf(stderr, "requirements not met! but proceeding due to --force\n"); |
| 797 | } |
| 798 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 799 | } |
| 800 | } |
| 801 | } |
| 802 | |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 803 | static void DisplayVarOrError(const std::string& label, const std::string& var) { |
| 804 | std::string value; |
| 805 | |
| 806 | if (fb->GetVar(var, &value) != fastboot::SUCCESS) { |
| 807 | Status("getvar:" + var); |
| 808 | fprintf(stderr, "FAILED (%s)\n", fb->Error().c_str()); |
| 809 | return; |
| 810 | } |
| 811 | fprintf(stderr, "%s: %s\n", label.c_str(), value.c_str()); |
| 812 | } |
| 813 | |
| 814 | static void DumpInfo() { |
| 815 | fprintf(stderr, "--------------------------------------------\n"); |
| 816 | DisplayVarOrError("Bootloader Version...", "version-bootloader"); |
| 817 | DisplayVarOrError("Baseband Version.....", "version-baseband"); |
| 818 | DisplayVarOrError("Serial Number........", "serialno"); |
| 819 | fprintf(stderr, "--------------------------------------------\n"); |
| 820 | |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 821 | } |
| 822 | |
Tao Bao | 41cf35f | 2018-04-24 10:54:21 -0700 | [diff] [blame] | 823 | static struct sparse_file** load_sparse_files(int fd, int64_t max_size) { |
Mohamad Ayyash | 80cc1f6 | 2015-03-31 12:09:29 -0700 | [diff] [blame] | 824 | struct sparse_file* s = sparse_file_import_auto(fd, false, true); |
Elliott Hughes | 4089d34 | 2017-10-27 14:21:12 -0700 | [diff] [blame] | 825 | if (!s) die("cannot sparse read file"); |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 826 | |
Tao Bao | 41cf35f | 2018-04-24 10:54:21 -0700 | [diff] [blame] | 827 | if (max_size <= 0 || max_size > std::numeric_limits<uint32_t>::max()) { |
| 828 | die("invalid max size %" PRId64, max_size); |
| 829 | } |
| 830 | |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 831 | int files = sparse_file_resparse(s, max_size, nullptr, 0); |
Elliott Hughes | 4089d34 | 2017-10-27 14:21:12 -0700 | [diff] [blame] | 832 | if (files < 0) die("Failed to resparse"); |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 833 | |
Elliott Hughes | 253c18d | 2015-03-18 22:47:09 -0700 | [diff] [blame] | 834 | sparse_file** out_s = reinterpret_cast<sparse_file**>(calloc(sizeof(struct sparse_file *), files + 1)); |
Elliott Hughes | 4089d34 | 2017-10-27 14:21:12 -0700 | [diff] [blame] | 835 | if (!out_s) die("Failed to allocate sparse file array"); |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 836 | |
| 837 | files = sparse_file_resparse(s, max_size, out_s, files); |
Elliott Hughes | 4089d34 | 2017-10-27 14:21:12 -0700 | [diff] [blame] | 838 | if (files < 0) die("Failed to resparse"); |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 839 | |
| 840 | return out_s; |
| 841 | } |
| 842 | |
Yifan Hong | bcd2770 | 2021-02-16 19:37:32 -0800 | [diff] [blame] | 843 | static uint64_t get_uint_var(const char* var_name) { |
| 844 | std::string value_str; |
| 845 | if (fb->GetVar(var_name, &value_str) != fastboot::SUCCESS || value_str.empty()) { |
| 846 | verbose("target didn't report %s", var_name); |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 847 | return 0; |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 848 | } |
| 849 | |
Elliott Hughes | 77c0e66 | 2015-11-02 15:51:12 -0800 | [diff] [blame] | 850 | // Some bootloaders (angler, for example) send spurious whitespace too. |
Yifan Hong | bcd2770 | 2021-02-16 19:37:32 -0800 | [diff] [blame] | 851 | value_str = android::base::Trim(value_str); |
Elliott Hughes | 77c0e66 | 2015-11-02 15:51:12 -0800 | [diff] [blame] | 852 | |
Yifan Hong | bcd2770 | 2021-02-16 19:37:32 -0800 | [diff] [blame] | 853 | uint64_t value; |
| 854 | if (!android::base::ParseUint(value_str, &value)) { |
| 855 | fprintf(stderr, "couldn't parse %s '%s'\n", var_name, value_str.c_str()); |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 856 | return 0; |
| 857 | } |
Yifan Hong | bcd2770 | 2021-02-16 19:37:32 -0800 | [diff] [blame] | 858 | if (value > 0) verbose("target reported %s of %" PRId64 " bytes", var_name, value); |
| 859 | return value; |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 860 | } |
| 861 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 862 | static int64_t get_sparse_limit(int64_t size) { |
Elliott Hughes | 542370d | 2018-04-19 19:49:44 -0700 | [diff] [blame] | 863 | int64_t limit = sparse_limit; |
| 864 | if (limit == 0) { |
| 865 | // Unlimited, so see what the target device's limit is. |
| 866 | // TODO: shouldn't we apply this limit even if you've used -S? |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 867 | if (target_sparse_limit == -1) { |
Yifan Hong | bcd2770 | 2021-02-16 19:37:32 -0800 | [diff] [blame] | 868 | target_sparse_limit = static_cast<int64_t>(get_uint_var("max-download-size")); |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 869 | } |
| 870 | if (target_sparse_limit > 0) { |
| 871 | limit = target_sparse_limit; |
| 872 | } else { |
Colin Cross | 0bbfb39 | 2012-07-24 18:05:21 -0700 | [diff] [blame] | 873 | return 0; |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 874 | } |
| 875 | } |
| 876 | |
| 877 | if (size > limit) { |
Chris Fries | 6a99971 | 2017-04-04 09:52:47 -0500 | [diff] [blame] | 878 | return std::min(limit, RESPARSE_LIMIT); |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 879 | } |
| 880 | |
| 881 | return 0; |
| 882 | } |
| 883 | |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 884 | static bool load_buf_fd(unique_fd fd, struct fastboot_buffer* buf) { |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 885 | int64_t sz = get_file_size(fd); |
| 886 | if (sz == -1) { |
Elliott Hughes | 53ec495 | 2016-05-11 12:39:27 -0700 | [diff] [blame] | 887 | return false; |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 888 | } |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 889 | |
Yifan Hong | 58532df | 2021-03-22 16:39:13 -0700 | [diff] [blame] | 890 | if (sparse_file* s = sparse_file_import(fd.get(), false, false)) { |
David Anderson | 32e376f | 2018-08-16 13:43:11 -0700 | [diff] [blame] | 891 | buf->image_size = sparse_file_len(s, false, false); |
| 892 | sparse_file_destroy(s); |
| 893 | } else { |
| 894 | buf->image_size = sz; |
| 895 | } |
| 896 | |
Yifan Hong | 58532df | 2021-03-22 16:39:13 -0700 | [diff] [blame] | 897 | lseek(fd.get(), 0, SEEK_SET); |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 898 | int64_t limit = get_sparse_limit(sz); |
Yifan Hong | e9f067b | 2021-03-22 16:55:39 -0700 | [diff] [blame] | 899 | buf->fd = std::move(fd); |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 900 | if (limit) { |
Yifan Hong | e9f067b | 2021-03-22 16:55:39 -0700 | [diff] [blame] | 901 | sparse_file** s = load_sparse_files(buf->fd.get(), limit); |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 902 | if (s == nullptr) { |
Elliott Hughes | 53ec495 | 2016-05-11 12:39:27 -0700 | [diff] [blame] | 903 | return false; |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 904 | } |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 905 | buf->type = FB_BUFFER_SPARSE; |
| 906 | buf->data = s; |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 907 | } else { |
Chris Fries | 0ea946c | 2017-04-12 10:25:57 -0500 | [diff] [blame] | 908 | buf->type = FB_BUFFER_FD; |
| 909 | buf->data = nullptr; |
Alexander Levitskiy | 8d7ddb3 | 2014-05-07 23:31:59 +0000 | [diff] [blame] | 910 | buf->sz = sz; |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 911 | } |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 912 | |
Elliott Hughes | 53ec495 | 2016-05-11 12:39:27 -0700 | [diff] [blame] | 913 | return true; |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 914 | } |
| 915 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 916 | static bool load_buf(const char* fname, struct fastboot_buffer* buf) { |
Chris Fries | 0ea946c | 2017-04-12 10:25:57 -0500 | [diff] [blame] | 917 | unique_fd fd(TEMP_FAILURE_RETRY(open(fname, O_RDONLY | O_BINARY))); |
| 918 | |
Elliott Hughes | 53ec495 | 2016-05-11 12:39:27 -0700 | [diff] [blame] | 919 | if (fd == -1) { |
| 920 | return false; |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 921 | } |
Chris Fries | 0ea946c | 2017-04-12 10:25:57 -0500 | [diff] [blame] | 922 | |
| 923 | struct stat s; |
Yifan Hong | 58532df | 2021-03-22 16:39:13 -0700 | [diff] [blame] | 924 | if (fstat(fd.get(), &s)) { |
Chris Fries | 0ea946c | 2017-04-12 10:25:57 -0500 | [diff] [blame] | 925 | return false; |
| 926 | } |
| 927 | if (!S_ISREG(s.st_mode)) { |
| 928 | errno = S_ISDIR(s.st_mode) ? EISDIR : EINVAL; |
| 929 | return false; |
| 930 | } |
| 931 | |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 932 | return load_buf_fd(std::move(fd), buf); |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 933 | } |
| 934 | |
Chin-Ting Kuo | df6a780 | 2019-09-16 11:23:55 +0800 | [diff] [blame] | 935 | static void rewrite_vbmeta_buffer(struct fastboot_buffer* buf, bool vbmeta_in_boot) { |
David Zeuthen | b6ea435 | 2017-08-07 14:29:26 -0400 | [diff] [blame] | 936 | // Buffer needs to be at least the size of the VBMeta struct which |
| 937 | // is 256 bytes. |
| 938 | if (buf->sz < 256) { |
| 939 | return; |
| 940 | } |
| 941 | |
David Zeuthen | b6ea435 | 2017-08-07 14:29:26 -0400 | [diff] [blame] | 942 | std::string data; |
| 943 | if (!android::base::ReadFdToString(buf->fd, &data)) { |
| 944 | die("Failed reading from vbmeta"); |
| 945 | } |
| 946 | |
Chin-Ting Kuo | df6a780 | 2019-09-16 11:23:55 +0800 | [diff] [blame] | 947 | uint64_t vbmeta_offset = 0; |
| 948 | if (vbmeta_in_boot) { |
| 949 | // Tries to locate top-level vbmeta from boot.img footer. |
| 950 | uint64_t footer_offset = buf->sz - AVB_FOOTER_SIZE; |
| 951 | if (0 != data.compare(footer_offset, AVB_FOOTER_MAGIC_LEN, AVB_FOOTER_MAGIC)) { |
Bowgo Tsai | 671249a | 2021-08-10 16:32:37 +0800 | [diff] [blame] | 952 | die("Failed to find AVB_FOOTER at offset: %" PRId64 ", is BOARD_AVB_ENABLE true?", |
| 953 | footer_offset); |
Chin-Ting Kuo | df6a780 | 2019-09-16 11:23:55 +0800 | [diff] [blame] | 954 | } |
| 955 | const AvbFooter* footer = reinterpret_cast<const AvbFooter*>(data.c_str() + footer_offset); |
| 956 | vbmeta_offset = be64toh(footer->vbmeta_offset); |
| 957 | } |
| 958 | // Ensures there is AVB_MAGIC at vbmeta_offset. |
| 959 | if (0 != data.compare(vbmeta_offset, AVB_MAGIC_LEN, AVB_MAGIC)) { |
| 960 | die("Failed to find AVB_MAGIC at offset: %" PRId64, vbmeta_offset); |
| 961 | } |
| 962 | |
| 963 | fprintf(stderr, "Rewriting vbmeta struct at offset: %" PRId64 "\n", vbmeta_offset); |
| 964 | |
David Zeuthen | b6ea435 | 2017-08-07 14:29:26 -0400 | [diff] [blame] | 965 | // There's a 32-bit big endian |flags| field at offset 120 where |
| 966 | // bit 0 corresponds to disable-verity and bit 1 corresponds to |
| 967 | // disable-verification. |
| 968 | // |
| 969 | // See external/avb/libavb/avb_vbmeta_image.h for the layout of |
| 970 | // the VBMeta struct. |
Chin-Ting Kuo | df6a780 | 2019-09-16 11:23:55 +0800 | [diff] [blame] | 971 | uint64_t flags_offset = 123 + vbmeta_offset; |
David Zeuthen | b6ea435 | 2017-08-07 14:29:26 -0400 | [diff] [blame] | 972 | if (g_disable_verity) { |
Chin-Ting Kuo | df6a780 | 2019-09-16 11:23:55 +0800 | [diff] [blame] | 973 | data[flags_offset] |= 0x01; |
David Zeuthen | b6ea435 | 2017-08-07 14:29:26 -0400 | [diff] [blame] | 974 | } |
| 975 | if (g_disable_verification) { |
Chin-Ting Kuo | df6a780 | 2019-09-16 11:23:55 +0800 | [diff] [blame] | 976 | data[flags_offset] |= 0x02; |
David Zeuthen | b6ea435 | 2017-08-07 14:29:26 -0400 | [diff] [blame] | 977 | } |
| 978 | |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 979 | unique_fd fd(make_temporary_fd("vbmeta rewriting")); |
David Zeuthen | b6ea435 | 2017-08-07 14:29:26 -0400 | [diff] [blame] | 980 | if (!android::base::WriteStringToFd(data, fd)) { |
| 981 | die("Failed writing to modified vbmeta"); |
| 982 | } |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 983 | buf->fd = std::move(fd); |
Yifan Hong | 58532df | 2021-03-22 16:39:13 -0700 | [diff] [blame] | 984 | lseek(buf->fd.get(), 0, SEEK_SET); |
David Zeuthen | b6ea435 | 2017-08-07 14:29:26 -0400 | [diff] [blame] | 985 | } |
| 986 | |
Chin-Ting Kuo | df6a780 | 2019-09-16 11:23:55 +0800 | [diff] [blame] | 987 | static bool has_vbmeta_partition() { |
| 988 | std::string partition_type; |
| 989 | return fb->GetVar("partition-type:vbmeta", &partition_type) == fastboot::SUCCESS || |
| 990 | fb->GetVar("partition-type:vbmeta_a", &partition_type) == fastboot::SUCCESS || |
| 991 | fb->GetVar("partition-type:vbmeta_b", &partition_type) == fastboot::SUCCESS; |
| 992 | } |
| 993 | |
Michael Bestas | a495be7 | 2020-11-06 17:58:28 +0200 | [diff] [blame] | 994 | static bool is_logical(const std::string& partition) { |
| 995 | std::string value; |
| 996 | return fb->GetVar("is-logical:" + partition, &value) == fastboot::SUCCESS && value == "yes"; |
| 997 | } |
| 998 | |
Steve Muckle | 3af575b | 2020-06-18 17:02:15 -0700 | [diff] [blame] | 999 | static std::string fb_fix_numeric_var(std::string var) { |
| 1000 | // Some bootloaders (angler, for example), send spurious leading whitespace. |
| 1001 | var = android::base::Trim(var); |
| 1002 | // Some bootloaders (hammerhead, for example) use implicit hex. |
| 1003 | // This code used to use strtol with base 16. |
| 1004 | if (!android::base::StartsWith(var, "0x")) var = "0x" + var; |
| 1005 | return var; |
| 1006 | } |
| 1007 | |
Yifan Hong | bcd2770 | 2021-02-16 19:37:32 -0800 | [diff] [blame] | 1008 | static uint64_t get_partition_size(const std::string& partition) { |
Steve Muckle | 3af575b | 2020-06-18 17:02:15 -0700 | [diff] [blame] | 1009 | std::string partition_size_str; |
| 1010 | if (fb->GetVar("partition-size:" + partition, &partition_size_str) != fastboot::SUCCESS) { |
Michael Bestas | a495be7 | 2020-11-06 17:58:28 +0200 | [diff] [blame] | 1011 | if (!is_logical(partition)) { |
| 1012 | return 0; |
| 1013 | } |
Yifan Hong | 60de969 | 2021-02-17 13:51:54 -0800 | [diff] [blame] | 1014 | die("cannot get partition size for %s", partition.c_str()); |
Steve Muckle | 3af575b | 2020-06-18 17:02:15 -0700 | [diff] [blame] | 1015 | } |
| 1016 | |
| 1017 | partition_size_str = fb_fix_numeric_var(partition_size_str); |
Yifan Hong | bcd2770 | 2021-02-16 19:37:32 -0800 | [diff] [blame] | 1018 | uint64_t partition_size; |
| 1019 | if (!android::base::ParseUint(partition_size_str, &partition_size)) { |
Michael Bestas | a495be7 | 2020-11-06 17:58:28 +0200 | [diff] [blame] | 1020 | if (!is_logical(partition)) { |
| 1021 | return 0; |
| 1022 | } |
Steve Muckle | 3af575b | 2020-06-18 17:02:15 -0700 | [diff] [blame] | 1023 | die("Couldn't parse partition size '%s'.", partition_size_str.c_str()); |
| 1024 | } |
Yifan Hong | bcd2770 | 2021-02-16 19:37:32 -0800 | [diff] [blame] | 1025 | return partition_size; |
| 1026 | } |
| 1027 | |
Devin Moore | cb5098f | 2022-01-07 16:33:46 +0000 | [diff] [blame] | 1028 | static void copy_avb_footer(const std::string& partition, struct fastboot_buffer* buf) { |
Yifan Hong | bcd2770 | 2021-02-16 19:37:32 -0800 | [diff] [blame] | 1029 | if (buf->sz < AVB_FOOTER_SIZE) { |
| 1030 | return; |
| 1031 | } |
| 1032 | |
Bowgo Tsai | 671249a | 2021-08-10 16:32:37 +0800 | [diff] [blame] | 1033 | // If overflows and negative, it should be < buf->sz. |
| 1034 | int64_t partition_size = static_cast<int64_t>(get_partition_size(partition)); |
| 1035 | |
| 1036 | if (partition_size == buf->sz) { |
| 1037 | return; |
| 1038 | } |
| 1039 | // Some device bootloaders might not implement `fastboot getvar partition-size:boot[_a|_b]`. |
| 1040 | // In this case, partition_size will be zero. |
| 1041 | if (partition_size < buf->sz) { |
| 1042 | fprintf(stderr, |
Devin Moore | cb5098f | 2022-01-07 16:33:46 +0000 | [diff] [blame] | 1043 | "Warning: skip copying %s image avb footer" |
| 1044 | " (%s partition size: %" PRId64 ", %s image size: %" PRId64 ").\n", |
| 1045 | partition.c_str(), partition.c_str(), partition_size, partition.c_str(), buf->sz); |
Bowgo Tsai | 671249a | 2021-08-10 16:32:37 +0800 | [diff] [blame] | 1046 | return; |
| 1047 | } |
| 1048 | |
| 1049 | // IMPORTANT: after the following read, we need to reset buf->fd before return (if not die). |
| 1050 | // Because buf->fd will still be used afterwards. |
Steve Muckle | 3af575b | 2020-06-18 17:02:15 -0700 | [diff] [blame] | 1051 | std::string data; |
| 1052 | if (!android::base::ReadFdToString(buf->fd, &data)) { |
Devin Moore | cb5098f | 2022-01-07 16:33:46 +0000 | [diff] [blame] | 1053 | die("Failed reading from %s", partition.c_str()); |
Steve Muckle | 3af575b | 2020-06-18 17:02:15 -0700 | [diff] [blame] | 1054 | } |
| 1055 | |
| 1056 | uint64_t footer_offset = buf->sz - AVB_FOOTER_SIZE; |
| 1057 | if (0 != data.compare(footer_offset, AVB_FOOTER_MAGIC_LEN, AVB_FOOTER_MAGIC)) { |
Bowgo Tsai | 671249a | 2021-08-10 16:32:37 +0800 | [diff] [blame] | 1058 | lseek(buf->fd.get(), 0, SEEK_SET); // IMPORTANT: resets buf->fd before return. |
Steve Muckle | 3af575b | 2020-06-18 17:02:15 -0700 | [diff] [blame] | 1059 | return; |
| 1060 | } |
| 1061 | |
Devin Moore | cb5098f | 2022-01-07 16:33:46 +0000 | [diff] [blame] | 1062 | const std::string tmp_fd_template = partition + " rewriting"; |
| 1063 | unique_fd fd(make_temporary_fd(tmp_fd_template.c_str())); |
Steve Muckle | 3af575b | 2020-06-18 17:02:15 -0700 | [diff] [blame] | 1064 | if (!android::base::WriteStringToFd(data, fd)) { |
Devin Moore | cb5098f | 2022-01-07 16:33:46 +0000 | [diff] [blame] | 1065 | die("Failed writing to modified %s", partition.c_str()); |
Steve Muckle | 3af575b | 2020-06-18 17:02:15 -0700 | [diff] [blame] | 1066 | } |
Yifan Hong | 58532df | 2021-03-22 16:39:13 -0700 | [diff] [blame] | 1067 | lseek(fd.get(), partition_size - AVB_FOOTER_SIZE, SEEK_SET); |
Steve Muckle | 3af575b | 2020-06-18 17:02:15 -0700 | [diff] [blame] | 1068 | if (!android::base::WriteStringToFd(data.substr(footer_offset), fd)) { |
Devin Moore | cb5098f | 2022-01-07 16:33:46 +0000 | [diff] [blame] | 1069 | die("Failed copying AVB footer in %s", partition.c_str()); |
Steve Muckle | 3af575b | 2020-06-18 17:02:15 -0700 | [diff] [blame] | 1070 | } |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 1071 | buf->fd = std::move(fd); |
Steve Muckle | 3af575b | 2020-06-18 17:02:15 -0700 | [diff] [blame] | 1072 | buf->sz = partition_size; |
Yifan Hong | 58532df | 2021-03-22 16:39:13 -0700 | [diff] [blame] | 1073 | lseek(buf->fd.get(), 0, SEEK_SET); |
Steve Muckle | 3af575b | 2020-06-18 17:02:15 -0700 | [diff] [blame] | 1074 | } |
| 1075 | |
Elliott Hughes | 5620d22 | 2018-03-28 08:20:00 -0700 | [diff] [blame] | 1076 | static void flash_buf(const std::string& partition, struct fastboot_buffer *buf) |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 1077 | { |
Elliott Hughes | 253c18d | 2015-03-18 22:47:09 -0700 | [diff] [blame] | 1078 | sparse_file** s; |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 1079 | |
Devin Moore | 1af1202 | 2022-01-06 01:11:23 +0000 | [diff] [blame] | 1080 | if (partition == "boot" || partition == "boot_a" || partition == "boot_b" || |
| 1081 | partition == "init_boot" || partition == "init_boot_a" || partition == "init_boot_b") { |
Devin Moore | cb5098f | 2022-01-07 16:33:46 +0000 | [diff] [blame] | 1082 | copy_avb_footer(partition, buf); |
Steve Muckle | 3af575b | 2020-06-18 17:02:15 -0700 | [diff] [blame] | 1083 | } |
| 1084 | |
David Zeuthen | b6ea435 | 2017-08-07 14:29:26 -0400 | [diff] [blame] | 1085 | // Rewrite vbmeta if that's what we're flashing and modification has been requested. |
Chin-Ting Kuo | df6a780 | 2019-09-16 11:23:55 +0800 | [diff] [blame] | 1086 | if (g_disable_verity || g_disable_verification) { |
Paweł Grabas | ff9cfac | 2021-03-04 13:11:25 +0100 | [diff] [blame] | 1087 | // The vbmeta partition might have additional prefix if running in virtual machine |
| 1088 | // e.g., guest_vbmeta_a. |
| 1089 | if (android::base::EndsWith(partition, "vbmeta") || |
| 1090 | android::base::EndsWith(partition, "vbmeta_a") || |
| 1091 | android::base::EndsWith(partition, "vbmeta_b")) { |
Chin-Ting Kuo | df6a780 | 2019-09-16 11:23:55 +0800 | [diff] [blame] | 1092 | rewrite_vbmeta_buffer(buf, false /* vbmeta_in_boot */); |
| 1093 | } else if (!has_vbmeta_partition() && |
| 1094 | (partition == "boot" || partition == "boot_a" || partition == "boot_b")) { |
| 1095 | rewrite_vbmeta_buffer(buf, true /* vbmeta_in_boot */ ); |
| 1096 | } |
David Zeuthen | b6ea435 | 2017-08-07 14:29:26 -0400 | [diff] [blame] | 1097 | } |
| 1098 | |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 1099 | switch (buf->type) { |
Josh Gao | 9da9ac5 | 2016-01-19 14:50:18 -0800 | [diff] [blame] | 1100 | case FB_BUFFER_SPARSE: { |
| 1101 | std::vector<std::pair<sparse_file*, int64_t>> sparse_files; |
Elliott Hughes | 253c18d | 2015-03-18 22:47:09 -0700 | [diff] [blame] | 1102 | s = reinterpret_cast<sparse_file**>(buf->data); |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 1103 | while (*s) { |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 1104 | int64_t sz = sparse_file_len(*s, true, false); |
Josh Gao | 9da9ac5 | 2016-01-19 14:50:18 -0800 | [diff] [blame] | 1105 | sparse_files.emplace_back(*s, sz); |
| 1106 | ++s; |
| 1107 | } |
| 1108 | |
| 1109 | for (size_t i = 0; i < sparse_files.size(); ++i) { |
| 1110 | const auto& pair = sparse_files[i]; |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1111 | fb->FlashPartition(partition, pair.first, pair.second, i + 1, sparse_files.size()); |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 1112 | } |
| 1113 | break; |
Josh Gao | 9da9ac5 | 2016-01-19 14:50:18 -0800 | [diff] [blame] | 1114 | } |
Chris Fries | 0ea946c | 2017-04-12 10:25:57 -0500 | [diff] [blame] | 1115 | case FB_BUFFER_FD: |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1116 | fb->FlashPartition(partition, buf->fd, buf->sz); |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 1117 | break; |
| 1118 | default: |
| 1119 | die("unknown buffer type: %d", buf->type); |
| 1120 | } |
| 1121 | } |
| 1122 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1123 | static std::string get_current_slot() { |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1124 | std::string current_slot; |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1125 | if (fb->GetVar("current-slot", ¤t_slot) != fastboot::SUCCESS) return ""; |
LuK1337 | dae48ef | 2020-04-06 14:38:58 +0200 | [diff] [blame] | 1126 | if (current_slot[0] == '_') current_slot.erase(0, 1); |
Elliott Hughes | 42b18a5 | 2018-04-10 15:32:21 -0700 | [diff] [blame] | 1127 | return current_slot; |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1128 | } |
| 1129 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1130 | static int get_slot_count() { |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1131 | std::string var; |
Elliott Hughes | 42b18a5 | 2018-04-10 15:32:21 -0700 | [diff] [blame] | 1132 | int count = 0; |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1133 | if (fb->GetVar("slot-count", &var) != fastboot::SUCCESS || |
| 1134 | !android::base::ParseInt(var, &count)) { |
Elliott Hughes | 42b18a5 | 2018-04-10 15:32:21 -0700 | [diff] [blame] | 1135 | return 0; |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1136 | } |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1137 | return count; |
| 1138 | } |
| 1139 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1140 | static bool supports_AB() { |
| 1141 | return get_slot_count() >= 2; |
Alex Light | bb9b8a5 | 2016-06-29 09:26:44 -0700 | [diff] [blame] | 1142 | } |
| 1143 | |
Daniel Rosenberg | ad3d3c1 | 2016-06-27 23:03:48 -0700 | [diff] [blame] | 1144 | // Given a current slot, this returns what the 'other' slot is. |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1145 | static std::string get_other_slot(const std::string& current_slot, int count) { |
| 1146 | if (count == 0) return ""; |
Daniel Rosenberg | ad3d3c1 | 2016-06-27 23:03:48 -0700 | [diff] [blame] | 1147 | |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1148 | char next = (current_slot[0] - 'a' + 1)%count + 'a'; |
| 1149 | return std::string(1, next); |
| 1150 | } |
| 1151 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1152 | static std::string get_other_slot(const std::string& current_slot) { |
| 1153 | return get_other_slot(current_slot, get_slot_count()); |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1154 | } |
| 1155 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1156 | static std::string get_other_slot(int count) { |
| 1157 | return get_other_slot(get_current_slot(), count); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1158 | } |
| 1159 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1160 | static std::string get_other_slot() { |
| 1161 | return get_other_slot(get_current_slot(), get_slot_count()); |
Alex Light | bb9b8a5 | 2016-06-29 09:26:44 -0700 | [diff] [blame] | 1162 | } |
| 1163 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1164 | static std::string verify_slot(const std::string& slot_name, bool allow_all) { |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1165 | std::string slot = slot_name; |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1166 | if (slot == "all") { |
Daniel Rosenberg | 9b43205 | 2015-11-25 15:17:10 -0800 | [diff] [blame] | 1167 | if (allow_all) { |
| 1168 | return "all"; |
| 1169 | } else { |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1170 | int count = get_slot_count(); |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1171 | if (count > 0) { |
| 1172 | return "a"; |
Daniel Rosenberg | 9b43205 | 2015-11-25 15:17:10 -0800 | [diff] [blame] | 1173 | } else { |
Elliott Hughes | 4089d34 | 2017-10-27 14:21:12 -0700 | [diff] [blame] | 1174 | die("No known slots"); |
Daniel Rosenberg | 9b43205 | 2015-11-25 15:17:10 -0800 | [diff] [blame] | 1175 | } |
| 1176 | } |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1177 | } |
Daniel Rosenberg | c1743ba | 2016-01-05 16:54:40 -0800 | [diff] [blame] | 1178 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1179 | int count = get_slot_count(); |
Elliott Hughes | 4089d34 | 2017-10-27 14:21:12 -0700 | [diff] [blame] | 1180 | if (count == 0) die("Device does not support slots"); |
Daniel Rosenberg | c1743ba | 2016-01-05 16:54:40 -0800 | [diff] [blame] | 1181 | |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1182 | if (slot == "other") { |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1183 | std::string other = get_other_slot( count); |
Daniel Rosenberg | ad3d3c1 | 2016-06-27 23:03:48 -0700 | [diff] [blame] | 1184 | if (other == "") { |
Elliott Hughes | 4089d34 | 2017-10-27 14:21:12 -0700 | [diff] [blame] | 1185 | die("No known slots"); |
Daniel Rosenberg | c1743ba | 2016-01-05 16:54:40 -0800 | [diff] [blame] | 1186 | } |
Daniel Rosenberg | ad3d3c1 | 2016-06-27 23:03:48 -0700 | [diff] [blame] | 1187 | return other; |
Daniel Rosenberg | c1743ba | 2016-01-05 16:54:40 -0800 | [diff] [blame] | 1188 | } |
| 1189 | |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1190 | if (slot.size() == 1 && (slot[0]-'a' >= 0 && slot[0]-'a' < count)) return slot; |
| 1191 | |
| 1192 | fprintf(stderr, "Slot %s does not exist. supported slots are:\n", slot.c_str()); |
| 1193 | for (int i=0; i<count; i++) { |
| 1194 | fprintf(stderr, "%c\n", (char)(i + 'a')); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1195 | } |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1196 | |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1197 | exit(1); |
| 1198 | } |
| 1199 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1200 | static std::string verify_slot(const std::string& slot) { |
| 1201 | return verify_slot(slot, true); |
Daniel Rosenberg | 9b43205 | 2015-11-25 15:17:10 -0800 | [diff] [blame] | 1202 | } |
| 1203 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1204 | static void do_for_partition(const std::string& part, const std::string& slot, |
Chih-Hung Hsieh | 8f7b9e3 | 2016-07-27 16:25:51 -0700 | [diff] [blame] | 1205 | const std::function<void(const std::string&)>& func, bool force_slot) { |
Daniel Rosenberg | a797479 | 2015-11-11 16:13:13 -0800 | [diff] [blame] | 1206 | std::string has_slot; |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1207 | std::string current_slot; |
Yifan Hong | 6d7da63 | 2021-02-23 12:15:51 -0800 | [diff] [blame] | 1208 | // |part| can be vendor_boot:default. Append slot to the first token. |
| 1209 | auto part_tokens = android::base::Split(part, ":"); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1210 | |
Yifan Hong | 6d7da63 | 2021-02-23 12:15:51 -0800 | [diff] [blame] | 1211 | if (fb->GetVar("has-slot:" + part_tokens[0], &has_slot) != fastboot::SUCCESS) { |
Daniel Rosenberg | a797479 | 2015-11-11 16:13:13 -0800 | [diff] [blame] | 1212 | /* If has-slot is not supported, the answer is no. */ |
| 1213 | has_slot = "no"; |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1214 | } |
Daniel Rosenberg | a797479 | 2015-11-11 16:13:13 -0800 | [diff] [blame] | 1215 | if (has_slot == "yes") { |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1216 | if (slot == "") { |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1217 | current_slot = get_current_slot(); |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1218 | if (current_slot == "") { |
Elliott Hughes | 4089d34 | 2017-10-27 14:21:12 -0700 | [diff] [blame] | 1219 | die("Failed to identify current slot"); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1220 | } |
Yifan Hong | 6d7da63 | 2021-02-23 12:15:51 -0800 | [diff] [blame] | 1221 | part_tokens[0] += "_" + current_slot; |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1222 | } else { |
Yifan Hong | 6d7da63 | 2021-02-23 12:15:51 -0800 | [diff] [blame] | 1223 | part_tokens[0] += "_" + slot; |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1224 | } |
Yifan Hong | 6d7da63 | 2021-02-23 12:15:51 -0800 | [diff] [blame] | 1225 | func(android::base::Join(part_tokens, ":")); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1226 | } else { |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1227 | if (force_slot && slot != "") { |
Yifan Hong | 6d7da63 | 2021-02-23 12:15:51 -0800 | [diff] [blame] | 1228 | fprintf(stderr, "Warning: %s does not support slots, and slot %s was requested.\n", |
| 1229 | part_tokens[0].c_str(), slot.c_str()); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1230 | } |
| 1231 | func(part); |
| 1232 | } |
| 1233 | } |
| 1234 | |
David Pursell | 0b15663 | 2015-10-30 11:22:01 -0700 | [diff] [blame] | 1235 | /* This function will find the real partition name given a base name, and a slot. If slot is NULL or |
| 1236 | * empty, it will use the current slot. If slot is "all", it will return a list of all possible |
| 1237 | * partition names. If force_slot is true, it will fail if a slot is specified, and the given |
| 1238 | * partition does not support slots. |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1239 | */ |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1240 | static void do_for_partitions(const std::string& part, const std::string& slot, |
Chih-Hung Hsieh | 8f7b9e3 | 2016-07-27 16:25:51 -0700 | [diff] [blame] | 1241 | const std::function<void(const std::string&)>& func, bool force_slot) { |
Daniel Rosenberg | a797479 | 2015-11-11 16:13:13 -0800 | [diff] [blame] | 1242 | std::string has_slot; |
Yifan Hong | 6d7da63 | 2021-02-23 12:15:51 -0800 | [diff] [blame] | 1243 | // |part| can be vendor_boot:default. Query has-slot on the first token only. |
| 1244 | auto part_tokens = android::base::Split(part, ":"); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1245 | |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1246 | if (slot == "all") { |
Yifan Hong | 6d7da63 | 2021-02-23 12:15:51 -0800 | [diff] [blame] | 1247 | if (fb->GetVar("has-slot:" + part_tokens[0], &has_slot) != fastboot::SUCCESS) { |
| 1248 | die("Could not check if partition %s has slot %s", part_tokens[0].c_str(), |
| 1249 | slot.c_str()); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1250 | } |
Daniel Rosenberg | a797479 | 2015-11-11 16:13:13 -0800 | [diff] [blame] | 1251 | if (has_slot == "yes") { |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1252 | for (int i=0; i < get_slot_count(); i++) { |
| 1253 | do_for_partition(part, std::string(1, (char)(i + 'a')), func, force_slot); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1254 | } |
| 1255 | } else { |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1256 | do_for_partition(part, "", func, force_slot); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1257 | } |
| 1258 | } else { |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1259 | do_for_partition(part, slot, func, force_slot); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1260 | } |
| 1261 | } |
| 1262 | |
David Anderson | 0c73234 | 2018-11-28 17:10:42 -0800 | [diff] [blame] | 1263 | static bool is_retrofit_device() { |
| 1264 | std::string value; |
| 1265 | if (fb->GetVar("super-partition-name", &value) != fastboot::SUCCESS) { |
| 1266 | return false; |
| 1267 | } |
| 1268 | return android::base::StartsWith(value, "system_"); |
| 1269 | } |
| 1270 | |
Yifan Hong | bcd2770 | 2021-02-16 19:37:32 -0800 | [diff] [blame] | 1271 | // Fetch a partition from the device to a given fd. This is a wrapper over FetchToFd to fetch |
| 1272 | // the full image. |
| 1273 | static uint64_t fetch_partition(const std::string& partition, borrowed_fd fd) { |
| 1274 | uint64_t fetch_size = get_uint_var(FB_VAR_MAX_FETCH_SIZE); |
| 1275 | if (fetch_size == 0) { |
| 1276 | die("Unable to get %s. Device does not support fetch command.", FB_VAR_MAX_FETCH_SIZE); |
| 1277 | } |
| 1278 | uint64_t partition_size = get_partition_size(partition); |
| 1279 | if (partition_size <= 0) { |
| 1280 | die("Invalid partition size for partition %s: %" PRId64, partition.c_str(), partition_size); |
| 1281 | } |
| 1282 | |
| 1283 | uint64_t offset = 0; |
| 1284 | while (offset < partition_size) { |
| 1285 | uint64_t chunk_size = std::min(fetch_size, partition_size - offset); |
| 1286 | if (fb->FetchToFd(partition, fd, offset, chunk_size) != fastboot::RetCode::SUCCESS) { |
| 1287 | die("Unable to fetch %s (offset=%" PRIx64 ", size=%" PRIx64 ")", partition.c_str(), |
| 1288 | offset, chunk_size); |
| 1289 | } |
| 1290 | offset += chunk_size; |
| 1291 | } |
| 1292 | return partition_size; |
| 1293 | } |
| 1294 | |
| 1295 | static void do_fetch(const std::string& partition, const std::string& slot_override, |
| 1296 | const std::string& outfile) { |
| 1297 | unique_fd fd(TEMP_FAILURE_RETRY( |
| 1298 | open(outfile.c_str(), O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_BINARY, 0644))); |
| 1299 | auto fetch = std::bind(fetch_partition, _1, borrowed_fd(fd)); |
| 1300 | do_for_partitions(partition, slot_override, fetch, false /* force slot */); |
| 1301 | } |
| 1302 | |
Yifan Hong | e71fe24 | 2021-02-22 15:00:15 -0800 | [diff] [blame] | 1303 | // Return immediately if not flashing a vendor boot image. If flashing a vendor boot image, |
| 1304 | // repack vendor_boot image with an updated ramdisk. After execution, buf is set |
| 1305 | // to the new image to flash, and return value is the real partition name to flash. |
| 1306 | static std::string repack_ramdisk(const char* pname, struct fastboot_buffer* buf) { |
| 1307 | std::string_view pname_sv{pname}; |
| 1308 | |
| 1309 | if (!android::base::StartsWith(pname_sv, "vendor_boot:") && |
| 1310 | !android::base::StartsWith(pname_sv, "vendor_boot_a:") && |
| 1311 | !android::base::StartsWith(pname_sv, "vendor_boot_b:")) { |
| 1312 | return std::string(pname_sv); |
| 1313 | } |
| 1314 | if (buf->type != FB_BUFFER_FD) { |
| 1315 | die("Flashing sparse vendor ramdisk image is not supported."); |
| 1316 | } |
| 1317 | if (buf->sz <= 0) { |
| 1318 | die("repack_ramdisk() sees negative size: %" PRId64, buf->sz); |
| 1319 | } |
| 1320 | std::string partition(pname_sv.substr(0, pname_sv.find(':'))); |
| 1321 | std::string ramdisk(pname_sv.substr(pname_sv.find(':') + 1)); |
| 1322 | |
| 1323 | unique_fd vendor_boot(make_temporary_fd("vendor boot repack")); |
| 1324 | uint64_t vendor_boot_size = fetch_partition(partition, vendor_boot); |
| 1325 | auto repack_res = replace_vendor_ramdisk(vendor_boot, vendor_boot_size, ramdisk, buf->fd, |
| 1326 | static_cast<uint64_t>(buf->sz)); |
| 1327 | if (!repack_res.ok()) { |
| 1328 | die("%s", repack_res.error().message().c_str()); |
| 1329 | } |
| 1330 | |
| 1331 | buf->fd = std::move(vendor_boot); |
| 1332 | buf->sz = vendor_boot_size; |
| 1333 | buf->image_size = vendor_boot_size; |
| 1334 | return partition; |
| 1335 | } |
| 1336 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1337 | static void do_flash(const char* pname, const char* fname) { |
Yifan Hong | 6d7da63 | 2021-02-23 12:15:51 -0800 | [diff] [blame] | 1338 | verbose("Do flash %s %s", pname, fname); |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 1339 | struct fastboot_buffer buf; |
| 1340 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1341 | if (!load_buf(fname, &buf)) { |
Elliott Hughes | 53ec495 | 2016-05-11 12:39:27 -0700 | [diff] [blame] | 1342 | die("cannot load '%s': %s", fname, strerror(errno)); |
Rom Lemarchand | 622810c | 2013-06-28 09:54:59 -0700 | [diff] [blame] | 1343 | } |
David Anderson | 629e51c | 2018-10-25 12:51:25 -0700 | [diff] [blame] | 1344 | if (is_logical(pname)) { |
| 1345 | fb->ResizePartition(pname, std::to_string(buf.image_size)); |
| 1346 | } |
Yifan Hong | e71fe24 | 2021-02-22 15:00:15 -0800 | [diff] [blame] | 1347 | std::string flash_pname = repack_ramdisk(pname, &buf); |
| 1348 | flash_buf(flash_pname, &buf); |
Colin Cross | f838788 | 2012-05-24 17:18:41 -0700 | [diff] [blame] | 1349 | } |
| 1350 | |
Daniel Rosenberg | 1345409 | 2016-06-27 19:43:11 -0700 | [diff] [blame] | 1351 | // Sets slot_override as the active slot. If slot_override is blank, |
| 1352 | // set current slot as active instead. This clears slot-unbootable. |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1353 | static void set_active(const std::string& slot_override) { |
| 1354 | if (!supports_AB()) return; |
Elliott Hughes | 42b18a5 | 2018-04-10 15:32:21 -0700 | [diff] [blame] | 1355 | |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1356 | if (slot_override != "") { |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1357 | fb->SetActive(slot_override); |
Daniel Rosenberg | 1345409 | 2016-06-27 19:43:11 -0700 | [diff] [blame] | 1358 | } else { |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1359 | std::string current_slot = get_current_slot(); |
Daniel Rosenberg | 8091947 | 2016-06-30 19:25:31 -0700 | [diff] [blame] | 1360 | if (current_slot != "") { |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1361 | fb->SetActive(current_slot); |
Daniel Rosenberg | 1345409 | 2016-06-27 19:43:11 -0700 | [diff] [blame] | 1362 | } |
| 1363 | } |
| 1364 | } |
| 1365 | |
David Anderson | 32e376f | 2018-08-16 13:43:11 -0700 | [diff] [blame] | 1366 | static bool is_userspace_fastboot() { |
| 1367 | std::string value; |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1368 | return fb->GetVar("is-userspace", &value) == fastboot::SUCCESS && value == "yes"; |
David Anderson | 32e376f | 2018-08-16 13:43:11 -0700 | [diff] [blame] | 1369 | } |
| 1370 | |
David Anderson | 1d88743 | 2018-08-27 16:47:32 -0700 | [diff] [blame] | 1371 | static void reboot_to_userspace_fastboot() { |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1372 | fb->RebootTo("fastboot"); |
| 1373 | |
| 1374 | auto* old_transport = fb->set_transport(nullptr); |
| 1375 | delete old_transport; |
David Anderson | 1d88743 | 2018-08-27 16:47:32 -0700 | [diff] [blame] | 1376 | |
| 1377 | // Give the current connection time to close. |
| 1378 | std::this_thread::sleep_for(std::chrono::milliseconds(1000)); |
| 1379 | |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1380 | fb->set_transport(open_device()); |
David Anderson | 11d6d27 | 2018-12-07 16:39:07 -0800 | [diff] [blame] | 1381 | |
| 1382 | if (!is_userspace_fastboot()) { |
| 1383 | die("Failed to boot into userspace fastboot; one or more components might be unbootable."); |
| 1384 | } |
Hridya Valsaraju | 83d856e | 2019-05-17 14:24:19 -0700 | [diff] [blame] | 1385 | |
| 1386 | // Reset target_sparse_limit after reboot to userspace fastboot. Max |
| 1387 | // download sizes may differ in bootloader and fastbootd. |
| 1388 | target_sparse_limit = -1; |
David Anderson | 1d88743 | 2018-08-27 16:47:32 -0700 | [diff] [blame] | 1389 | } |
| 1390 | |
David Anderson | ab8f466 | 2019-10-21 16:45:59 -0700 | [diff] [blame] | 1391 | static void CancelSnapshotIfNeeded() { |
| 1392 | std::string merge_status = "none"; |
| 1393 | if (fb->GetVar(FB_VAR_SNAPSHOT_UPDATE_STATUS, &merge_status) == fastboot::SUCCESS && |
Elliott Hughes | 6a7ff58 | 2020-06-05 14:06:15 -0700 | [diff] [blame] | 1394 | !merge_status.empty() && merge_status != "none") { |
Yifan Hong | 712c32b | 2019-12-10 18:11:13 -0800 | [diff] [blame] | 1395 | fb->SnapshotUpdateCommand("cancel"); |
David Anderson | ab8f466 | 2019-10-21 16:45:59 -0700 | [diff] [blame] | 1396 | } |
| 1397 | } |
| 1398 | |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1399 | class ImageSource { |
| 1400 | public: |
Yifan Hong | d2e8cb5 | 2021-03-19 11:46:42 -0700 | [diff] [blame] | 1401 | virtual ~ImageSource() {}; |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 1402 | virtual bool ReadFile(const std::string& name, std::vector<char>* out) const = 0; |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 1403 | virtual unique_fd OpenFile(const std::string& name) const = 0; |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1404 | }; |
David Anderson | 32e376f | 2018-08-16 13:43:11 -0700 | [diff] [blame] | 1405 | |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1406 | class FlashAllTool { |
| 1407 | public: |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 1408 | FlashAllTool(const ImageSource& source, const std::string& slot_override, bool skip_secondary, |
| 1409 | bool wipe, bool force_flash); |
David Anderson | 32e376f | 2018-08-16 13:43:11 -0700 | [diff] [blame] | 1410 | |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1411 | void Flash(); |
David Anderson | 32e376f | 2018-08-16 13:43:11 -0700 | [diff] [blame] | 1412 | |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1413 | private: |
| 1414 | void CheckRequirements(); |
| 1415 | void DetermineSecondarySlot(); |
| 1416 | void CollectImages(); |
| 1417 | void FlashImages(const std::vector<std::pair<const Image*, std::string>>& images); |
| 1418 | void FlashImage(const Image& image, const std::string& slot, fastboot_buffer* buf); |
| 1419 | void UpdateSuperPartition(); |
David Anderson | 32e376f | 2018-08-16 13:43:11 -0700 | [diff] [blame] | 1420 | |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1421 | const ImageSource& source_; |
| 1422 | std::string slot_override_; |
| 1423 | bool skip_secondary_; |
| 1424 | bool wipe_; |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 1425 | bool force_flash_; |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1426 | std::string secondary_slot_; |
| 1427 | std::vector<std::pair<const Image*, std::string>> boot_images_; |
| 1428 | std::vector<std::pair<const Image*, std::string>> os_images_; |
| 1429 | }; |
| 1430 | |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 1431 | FlashAllTool::FlashAllTool(const ImageSource& source, const std::string& slot_override, |
| 1432 | bool skip_secondary, bool wipe, bool force_flash) |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1433 | : source_(source), |
| 1434 | slot_override_(slot_override), |
| 1435 | skip_secondary_(skip_secondary), |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 1436 | wipe_(wipe), |
| 1437 | force_flash_(force_flash) |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1438 | { |
David Anderson | 32e376f | 2018-08-16 13:43:11 -0700 | [diff] [blame] | 1439 | } |
| 1440 | |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1441 | void FlashAllTool::Flash() { |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1442 | DumpInfo(); |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1443 | CheckRequirements(); |
David Anderson | 96a9fd4 | 2018-11-05 15:21:44 -0800 | [diff] [blame] | 1444 | |
| 1445 | // Change the slot first, so we boot into the correct recovery image when |
| 1446 | // using fastbootd. |
| 1447 | if (slot_override_ == "all") { |
| 1448 | set_active("a"); |
| 1449 | } else { |
| 1450 | set_active(slot_override_); |
| 1451 | } |
| 1452 | |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1453 | DetermineSecondarySlot(); |
| 1454 | CollectImages(); |
David Anderson | 32e376f | 2018-08-16 13:43:11 -0700 | [diff] [blame] | 1455 | |
David Anderson | ab8f466 | 2019-10-21 16:45:59 -0700 | [diff] [blame] | 1456 | CancelSnapshotIfNeeded(); |
| 1457 | |
David Anderson | 95d4093 | 2018-08-28 12:14:33 -0700 | [diff] [blame] | 1458 | // First flash boot partitions. We allow this to happen either in userspace |
| 1459 | // or in bootloader fastboot. |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1460 | FlashImages(boot_images_); |
David Anderson | 95d4093 | 2018-08-28 12:14:33 -0700 | [diff] [blame] | 1461 | |
| 1462 | // Sync the super partition. This will reboot to userspace fastboot if needed. |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1463 | UpdateSuperPartition(); |
David Anderson | 95d4093 | 2018-08-28 12:14:33 -0700 | [diff] [blame] | 1464 | |
| 1465 | // Resize any logical partition to 0, so each partition is reset to 0 |
| 1466 | // extents, and will achieve more optimal allocation. |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1467 | for (const auto& [image, slot] : os_images_) { |
David Anderson | 32e376f | 2018-08-16 13:43:11 -0700 | [diff] [blame] | 1468 | auto resize_partition = [](const std::string& partition) -> void { |
| 1469 | if (is_logical(partition)) { |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1470 | fb->ResizePartition(partition, "0"); |
David Anderson | 32e376f | 2018-08-16 13:43:11 -0700 | [diff] [blame] | 1471 | } |
| 1472 | }; |
David Anderson | 95d4093 | 2018-08-28 12:14:33 -0700 | [diff] [blame] | 1473 | do_for_partitions(image->part_name, slot, resize_partition, false); |
David Anderson | 32e376f | 2018-08-16 13:43:11 -0700 | [diff] [blame] | 1474 | } |
| 1475 | |
David Anderson | 95d4093 | 2018-08-28 12:14:33 -0700 | [diff] [blame] | 1476 | // Flash OS images, resizing logical partitions as needed. |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1477 | FlashImages(os_images_); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 1478 | } |
| 1479 | |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1480 | void FlashAllTool::CheckRequirements() { |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 1481 | std::vector<char> contents; |
| 1482 | if (!source_.ReadFile("android-info.txt", &contents)) { |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1483 | die("could not read android-info.txt"); |
| 1484 | } |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 1485 | ::CheckRequirements({contents.data(), contents.size()}, force_flash_); |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1486 | } |
| 1487 | |
| 1488 | void FlashAllTool::DetermineSecondarySlot() { |
| 1489 | if (skip_secondary_) { |
| 1490 | return; |
| 1491 | } |
David Anderson | 96a9fd4 | 2018-11-05 15:21:44 -0800 | [diff] [blame] | 1492 | if (slot_override_ != "" && slot_override_ != "all") { |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1493 | secondary_slot_ = get_other_slot(slot_override_); |
| 1494 | } else { |
| 1495 | secondary_slot_ = get_other_slot(); |
| 1496 | } |
| 1497 | if (secondary_slot_ == "") { |
| 1498 | if (supports_AB()) { |
| 1499 | fprintf(stderr, "Warning: Could not determine slot for secondary images. Ignoring.\n"); |
| 1500 | } |
| 1501 | skip_secondary_ = true; |
| 1502 | } |
| 1503 | } |
| 1504 | |
| 1505 | void FlashAllTool::CollectImages() { |
| 1506 | for (size_t i = 0; i < arraysize(images); ++i) { |
| 1507 | std::string slot = slot_override_; |
| 1508 | if (images[i].IsSecondary()) { |
| 1509 | if (skip_secondary_) { |
| 1510 | continue; |
| 1511 | } |
| 1512 | slot = secondary_slot_; |
| 1513 | } |
| 1514 | if (images[i].type == ImageType::BootCritical) { |
| 1515 | boot_images_.emplace_back(&images[i], slot); |
| 1516 | } else if (images[i].type == ImageType::Normal) { |
| 1517 | os_images_.emplace_back(&images[i], slot); |
| 1518 | } |
| 1519 | } |
| 1520 | } |
| 1521 | |
| 1522 | void FlashAllTool::FlashImages(const std::vector<std::pair<const Image*, std::string>>& images) { |
| 1523 | for (const auto& [image, slot] : images) { |
| 1524 | fastboot_buffer buf; |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 1525 | unique_fd fd = source_.OpenFile(image->img_name); |
| 1526 | if (fd < 0 || !load_buf_fd(std::move(fd), &buf)) { |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1527 | if (image->optional_if_no_image) { |
| 1528 | continue; |
| 1529 | } |
| 1530 | die("could not load '%s': %s", image->img_name, strerror(errno)); |
| 1531 | } |
| 1532 | FlashImage(*image, slot, &buf); |
| 1533 | } |
| 1534 | } |
| 1535 | |
| 1536 | void FlashAllTool::FlashImage(const Image& image, const std::string& slot, fastboot_buffer* buf) { |
| 1537 | auto flash = [&, this](const std::string& partition_name) { |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 1538 | std::vector<char> signature_data; |
| 1539 | if (source_.ReadFile(image.sig_name, &signature_data)) { |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1540 | fb->Download("signature", signature_data); |
| 1541 | fb->RawCommand("signature", "installing signature"); |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1542 | } |
| 1543 | |
| 1544 | if (is_logical(partition_name)) { |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1545 | fb->ResizePartition(partition_name, std::to_string(buf->image_size)); |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1546 | } |
| 1547 | flash_buf(partition_name.c_str(), buf); |
| 1548 | }; |
| 1549 | do_for_partitions(image.part_name, slot, flash, false); |
| 1550 | } |
| 1551 | |
| 1552 | void FlashAllTool::UpdateSuperPartition() { |
Yifan Hong | 58532df | 2021-03-22 16:39:13 -0700 | [diff] [blame] | 1553 | unique_fd fd = source_.OpenFile("super_empty.img"); |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1554 | if (fd < 0) { |
| 1555 | return; |
| 1556 | } |
| 1557 | if (!is_userspace_fastboot()) { |
| 1558 | reboot_to_userspace_fastboot(); |
| 1559 | } |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1560 | |
David Anderson | 90fe0a4 | 2018-11-05 18:01:32 -0800 | [diff] [blame] | 1561 | std::string super_name; |
| 1562 | if (fb->GetVar("super-partition-name", &super_name) != fastboot::RetCode::SUCCESS) { |
| 1563 | super_name = "super"; |
| 1564 | } |
| 1565 | fb->Download(super_name, fd, get_file_size(fd)); |
| 1566 | |
| 1567 | std::string command = "update-super:" + super_name; |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1568 | if (wipe_) { |
| 1569 | command += ":wipe"; |
| 1570 | } |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1571 | fb->RawCommand(command, "Updating super partition"); |
David Anderson | 0c73234 | 2018-11-28 17:10:42 -0800 | [diff] [blame] | 1572 | |
| 1573 | // Retrofit devices have two super partitions, named super_a and super_b. |
| 1574 | // On these devices, secondary slots must be flashed as physical |
| 1575 | // partitions (otherwise they would not mount on first boot). To enforce |
| 1576 | // this, we delete any logical partitions for the "other" slot. |
| 1577 | if (is_retrofit_device()) { |
| 1578 | for (const auto& [image, slot] : os_images_) { |
| 1579 | std::string partition_name = image->part_name + "_"s + slot; |
| 1580 | if (image->IsSecondary() && is_logical(partition_name)) { |
| 1581 | fb->DeletePartition(partition_name); |
| 1582 | } |
| 1583 | } |
| 1584 | } |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1585 | } |
| 1586 | |
| 1587 | class ZipImageSource final : public ImageSource { |
| 1588 | public: |
| 1589 | explicit ZipImageSource(ZipArchiveHandle zip) : zip_(zip) {} |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 1590 | bool ReadFile(const std::string& name, std::vector<char>* out) const override; |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 1591 | unique_fd OpenFile(const std::string& name) const override; |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1592 | |
| 1593 | private: |
| 1594 | ZipArchiveHandle zip_; |
| 1595 | }; |
| 1596 | |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 1597 | bool ZipImageSource::ReadFile(const std::string& name, std::vector<char>* out) const { |
| 1598 | return UnzipToMemory(zip_, name, out); |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1599 | } |
| 1600 | |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 1601 | unique_fd ZipImageSource::OpenFile(const std::string& name) const { |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1602 | return unzip_to_file(zip_, name.c_str()); |
| 1603 | } |
| 1604 | |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 1605 | static void do_update(const char* filename, const std::string& slot_override, bool skip_secondary, |
| 1606 | bool force_flash) { |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1607 | ZipArchiveHandle zip; |
| 1608 | int error = OpenArchive(filename, &zip); |
| 1609 | if (error != 0) { |
| 1610 | die("failed to open zip file '%s': %s", filename, ErrorCodeString(error)); |
| 1611 | } |
| 1612 | |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 1613 | FlashAllTool tool(ZipImageSource(zip), slot_override, skip_secondary, false, force_flash); |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1614 | tool.Flash(); |
| 1615 | |
| 1616 | CloseArchive(zip); |
| 1617 | } |
| 1618 | |
| 1619 | class LocalImageSource final : public ImageSource { |
| 1620 | public: |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 1621 | bool ReadFile(const std::string& name, std::vector<char>* out) const override; |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 1622 | unique_fd OpenFile(const std::string& name) const override; |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1623 | }; |
| 1624 | |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 1625 | bool LocalImageSource::ReadFile(const std::string& name, std::vector<char>* out) const { |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1626 | auto path = find_item_given_name(name); |
| 1627 | if (path.empty()) { |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 1628 | return false; |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1629 | } |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 1630 | return ReadFileToVector(path, out); |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1631 | } |
| 1632 | |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 1633 | unique_fd LocalImageSource::OpenFile(const std::string& name) const { |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1634 | auto path = find_item_given_name(name); |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 1635 | return unique_fd(TEMP_FAILURE_RETRY(open(path.c_str(), O_RDONLY | O_BINARY))); |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1636 | } |
| 1637 | |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 1638 | static void do_flashall(const std::string& slot_override, bool skip_secondary, bool wipe, |
| 1639 | bool force_flash) { |
| 1640 | FlashAllTool tool(LocalImageSource(), slot_override, skip_secondary, wipe, force_flash); |
David Anderson | cf444f3 | 2018-08-29 14:15:49 -0700 | [diff] [blame] | 1641 | tool.Flash(); |
| 1642 | } |
| 1643 | |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 1644 | static std::string next_arg(std::vector<std::string>* args) { |
| 1645 | if (args->empty()) syntax_error("expected argument"); |
| 1646 | std::string result = args->front(); |
| 1647 | args->erase(args->begin()); |
| 1648 | return result; |
Patrick Tjin | 51e8b03 | 2015-09-01 08:15:23 -0700 | [diff] [blame] | 1649 | } |
| 1650 | |
Elliott Hughes | 1eec97a | 2017-05-15 16:53:53 -0700 | [diff] [blame] | 1651 | static void do_oem_command(const std::string& cmd, std::vector<std::string>* args) { |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 1652 | if (args->empty()) syntax_error("empty oem command"); |
Tsu Chiang Chuang | ee52055 | 2011-02-25 18:38:53 -0800 | [diff] [blame] | 1653 | |
Elliott Hughes | 1eec97a | 2017-05-15 16:53:53 -0700 | [diff] [blame] | 1654 | std::string command(cmd); |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 1655 | while (!args->empty()) { |
Elliott Hughes | 29d5d7d | 2017-05-11 15:05:13 -0700 | [diff] [blame] | 1656 | command += " " + next_arg(args); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 1657 | } |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1658 | fb->RawCommand(command, ""); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 1659 | } |
| 1660 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1661 | static unsigned fb_get_flash_block_size(std::string name) { |
Connor O'Brien | ce16a8a | 2017-02-06 14:39:31 -0800 | [diff] [blame] | 1662 | std::string sizeString; |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1663 | if (fb->GetVar(name, &sizeString) != fastboot::SUCCESS || sizeString.empty()) { |
Elliott Hughes | 5620d22 | 2018-03-28 08:20:00 -0700 | [diff] [blame] | 1664 | // This device does not report flash block sizes, so return 0. |
Connor O'Brien | ce16a8a | 2017-02-06 14:39:31 -0800 | [diff] [blame] | 1665 | return 0; |
| 1666 | } |
| 1667 | sizeString = fb_fix_numeric_var(sizeString); |
| 1668 | |
| 1669 | unsigned size; |
| 1670 | if (!android::base::ParseUint(sizeString, &size)) { |
| 1671 | fprintf(stderr, "Couldn't parse %s '%s'.\n", name.c_str(), sizeString.c_str()); |
| 1672 | return 0; |
| 1673 | } |
Connor O'Brien | 6ef5c24 | 2017-11-01 17:37:32 -0700 | [diff] [blame] | 1674 | if ((size & (size - 1)) != 0) { |
| 1675 | fprintf(stderr, "Invalid %s %u: must be a power of 2.\n", name.c_str(), size); |
Connor O'Brien | ce16a8a | 2017-02-06 14:39:31 -0800 | [diff] [blame] | 1676 | return 0; |
| 1677 | } |
| 1678 | return size; |
| 1679 | } |
| 1680 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1681 | static void fb_perform_format( |
Elliott Hughes | 5620d22 | 2018-03-28 08:20:00 -0700 | [diff] [blame] | 1682 | const std::string& partition, int skip_if_not_supported, |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 1683 | const std::string& type_override, const std::string& size_override, |
Jaegeuk Kim | 638d05e | 2020-11-09 08:54:13 -0800 | [diff] [blame] | 1684 | const std::string& initial_dir, const unsigned fs_options) { |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 1685 | std::string partition_type, partition_size; |
| 1686 | |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1687 | struct fastboot_buffer buf; |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 1688 | const char* errMsg = nullptr; |
| 1689 | const struct fs_generator* gen = nullptr; |
Jin Qian | 4a33582 | 2017-04-18 16:23:18 -0700 | [diff] [blame] | 1690 | TemporaryFile output; |
| 1691 | unique_fd fd; |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1692 | |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 1693 | unsigned int limit = INT_MAX; |
| 1694 | if (target_sparse_limit > 0 && target_sparse_limit < limit) { |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1695 | limit = target_sparse_limit; |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 1696 | } |
| 1697 | if (sparse_limit > 0 && sparse_limit < limit) { |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1698 | limit = sparse_limit; |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 1699 | } |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1700 | |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1701 | if (fb->GetVar("partition-type:" + partition, &partition_type) != fastboot::SUCCESS) { |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1702 | errMsg = "Can't determine partition type.\n"; |
| 1703 | goto failed; |
| 1704 | } |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 1705 | if (!type_override.empty()) { |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 1706 | if (partition_type != type_override) { |
| 1707 | fprintf(stderr, "Warning: %s type is %s, but %s was requested for formatting.\n", |
Elliott Hughes | 5620d22 | 2018-03-28 08:20:00 -0700 | [diff] [blame] | 1708 | partition.c_str(), partition_type.c_str(), type_override.c_str()); |
JP Abgrall | 7e85974 | 2014-05-06 15:14:15 -0700 | [diff] [blame] | 1709 | } |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 1710 | partition_type = type_override; |
JP Abgrall | 7e85974 | 2014-05-06 15:14:15 -0700 | [diff] [blame] | 1711 | } |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1712 | |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1713 | if (fb->GetVar("partition-size:" + partition, &partition_size) != fastboot::SUCCESS) { |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1714 | errMsg = "Unable to get partition size\n"; |
| 1715 | goto failed; |
| 1716 | } |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 1717 | if (!size_override.empty()) { |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 1718 | if (partition_size != size_override) { |
| 1719 | fprintf(stderr, "Warning: %s size is %s, but %s was requested for formatting.\n", |
Elliott Hughes | 5620d22 | 2018-03-28 08:20:00 -0700 | [diff] [blame] | 1720 | partition.c_str(), partition_size.c_str(), size_override.c_str()); |
JP Abgrall | 7e85974 | 2014-05-06 15:14:15 -0700 | [diff] [blame] | 1721 | } |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 1722 | partition_size = size_override; |
JP Abgrall | 7e85974 | 2014-05-06 15:14:15 -0700 | [diff] [blame] | 1723 | } |
Connor O'Brien | ce16a8a | 2017-02-06 14:39:31 -0800 | [diff] [blame] | 1724 | partition_size = fb_fix_numeric_var(partition_size); |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1725 | |
Elliott Hughes | 8ab9a32 | 2015-11-02 14:05:57 -0800 | [diff] [blame] | 1726 | gen = fs_get_generator(partition_type); |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1727 | if (!gen) { |
| 1728 | if (skip_if_not_supported) { |
| 1729 | fprintf(stderr, "Erase successful, but not automatically formatting.\n"); |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 1730 | fprintf(stderr, "File system type %s not supported.\n", partition_type.c_str()); |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1731 | return; |
| 1732 | } |
Mark Salyzyn | a30b696 | 2018-11-20 11:04:15 -0800 | [diff] [blame] | 1733 | die("Formatting is not supported for file system with type '%s'.", |
| 1734 | partition_type.c_str()); |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1735 | } |
| 1736 | |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 1737 | int64_t size; |
Elliott Hughes | da46b39 | 2016-10-11 17:09:00 -0700 | [diff] [blame] | 1738 | if (!android::base::ParseInt(partition_size, &size)) { |
Mark Salyzyn | a30b696 | 2018-11-20 11:04:15 -0800 | [diff] [blame] | 1739 | die("Couldn't parse partition size '%s'.", partition_size.c_str()); |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 1740 | } |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1741 | |
Connor O'Brien | ce16a8a | 2017-02-06 14:39:31 -0800 | [diff] [blame] | 1742 | unsigned eraseBlkSize, logicalBlkSize; |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1743 | eraseBlkSize = fb_get_flash_block_size("erase-block-size"); |
| 1744 | logicalBlkSize = fb_get_flash_block_size("logical-block-size"); |
Connor O'Brien | ce16a8a | 2017-02-06 14:39:31 -0800 | [diff] [blame] | 1745 | |
Jin Qian | 4a33582 | 2017-04-18 16:23:18 -0700 | [diff] [blame] | 1746 | if (fs_generator_generate(gen, output.path, size, initial_dir, |
Jaegeuk Kim | 638d05e | 2020-11-09 08:54:13 -0800 | [diff] [blame] | 1747 | eraseBlkSize, logicalBlkSize, fs_options)) { |
Elliott Hughes | 5620d22 | 2018-03-28 08:20:00 -0700 | [diff] [blame] | 1748 | die("Cannot generate image for %s", partition.c_str()); |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1749 | } |
| 1750 | |
Jin Qian | 4a33582 | 2017-04-18 16:23:18 -0700 | [diff] [blame] | 1751 | fd.reset(open(output.path, O_RDONLY)); |
| 1752 | if (fd == -1) { |
Mark Salyzyn | a30b696 | 2018-11-20 11:04:15 -0800 | [diff] [blame] | 1753 | die("Cannot open generated image: %s", strerror(errno)); |
Jin Qian | 4a33582 | 2017-04-18 16:23:18 -0700 | [diff] [blame] | 1754 | } |
Yifan Hong | b10d067 | 2021-02-22 15:06:27 -0800 | [diff] [blame] | 1755 | if (!load_buf_fd(std::move(fd), &buf)) { |
Mark Salyzyn | a30b696 | 2018-11-20 11:04:15 -0800 | [diff] [blame] | 1756 | die("Cannot read image: %s", strerror(errno)); |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1757 | } |
| 1758 | flash_buf(partition, &buf); |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1759 | return; |
| 1760 | |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1761 | failed: |
| 1762 | if (skip_if_not_supported) { |
| 1763 | fprintf(stderr, "Erase successful, but not automatically formatting.\n"); |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 1764 | if (errMsg) fprintf(stderr, "%s", errMsg); |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1765 | } |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 1766 | fprintf(stderr, "FAILED (%s)\n", fb->Error().c_str()); |
Mark Salyzyn | a30b696 | 2018-11-20 11:04:15 -0800 | [diff] [blame] | 1767 | if (!skip_if_not_supported) { |
| 1768 | die("Command failed"); |
| 1769 | } |
Dmitry Grinberg | e6f3e9b | 2014-03-11 18:28:15 -0700 | [diff] [blame] | 1770 | } |
| 1771 | |
David Anderson | 8956964 | 2018-11-16 15:53:35 -0800 | [diff] [blame] | 1772 | static bool should_flash_in_userspace(const std::string& partition_name) { |
David Anderson | e0e693c | 2018-11-27 20:19:26 -0800 | [diff] [blame] | 1773 | if (!get_android_product_out()) { |
| 1774 | return false; |
| 1775 | } |
David Anderson | 8956964 | 2018-11-16 15:53:35 -0800 | [diff] [blame] | 1776 | auto path = find_item_given_name("super_empty.img"); |
David Anderson | 0047580 | 2018-12-04 17:05:47 -0800 | [diff] [blame] | 1777 | if (path.empty() || access(path.c_str(), R_OK)) { |
David Anderson | 8956964 | 2018-11-16 15:53:35 -0800 | [diff] [blame] | 1778 | return false; |
| 1779 | } |
| 1780 | auto metadata = android::fs_mgr::ReadFromImageFile(path); |
| 1781 | if (!metadata) { |
| 1782 | return false; |
| 1783 | } |
| 1784 | for (const auto& partition : metadata->partitions) { |
| 1785 | auto candidate = android::fs_mgr::GetPartitionName(partition); |
| 1786 | if (partition.attributes & LP_PARTITION_ATTR_SLOT_SUFFIXED) { |
| 1787 | // On retrofit devices, we don't know if, or whether, the A or B |
| 1788 | // slot has been flashed for dynamic partitions. Instead we add |
| 1789 | // both names to the list as a conservative guess. |
| 1790 | if (candidate + "_a" == partition_name || candidate + "_b" == partition_name) { |
| 1791 | return true; |
| 1792 | } |
| 1793 | } else if (candidate == partition_name) { |
| 1794 | return true; |
| 1795 | } |
| 1796 | } |
| 1797 | return false; |
| 1798 | } |
| 1799 | |
David Anderson | 7c84b9f | 2019-06-27 22:15:29 -0700 | [diff] [blame] | 1800 | static bool wipe_super(const android::fs_mgr::LpMetadata& metadata, const std::string& slot, |
| 1801 | std::string* message) { |
| 1802 | auto super_device = GetMetadataSuperBlockDevice(metadata); |
| 1803 | auto block_size = metadata.geometry.logical_block_size; |
| 1804 | auto super_bdev_name = android::fs_mgr::GetBlockDevicePartitionName(*super_device); |
| 1805 | |
| 1806 | if (super_bdev_name != "super") { |
| 1807 | // retrofit devices do not allow flashing to the retrofit partitions, |
| 1808 | // so enable it if we can. |
| 1809 | fb->RawCommand("oem allow-flash-super"); |
| 1810 | } |
| 1811 | |
| 1812 | // Note: do not use die() in here, since we want TemporaryDir's destructor |
| 1813 | // to be called. |
| 1814 | TemporaryDir temp_dir; |
| 1815 | |
| 1816 | bool ok; |
| 1817 | if (metadata.block_devices.size() > 1) { |
| 1818 | ok = WriteSplitImageFiles(temp_dir.path, metadata, block_size, {}, true); |
| 1819 | } else { |
| 1820 | auto image_path = temp_dir.path + "/"s + super_bdev_name + ".img"; |
| 1821 | ok = WriteToImageFile(image_path, metadata, block_size, {}, true); |
| 1822 | } |
| 1823 | if (!ok) { |
| 1824 | *message = "Could not generate a flashable super image file"; |
| 1825 | return false; |
| 1826 | } |
| 1827 | |
| 1828 | for (const auto& block_device : metadata.block_devices) { |
| 1829 | auto partition = android::fs_mgr::GetBlockDevicePartitionName(block_device); |
| 1830 | bool force_slot = !!(block_device.flags & LP_BLOCK_DEVICE_SLOT_SUFFIXED); |
| 1831 | |
| 1832 | std::string image_name; |
| 1833 | if (metadata.block_devices.size() > 1) { |
| 1834 | image_name = "super_" + partition + ".img"; |
| 1835 | } else { |
| 1836 | image_name = partition + ".img"; |
| 1837 | } |
| 1838 | |
| 1839 | auto image_path = temp_dir.path + "/"s + image_name; |
| 1840 | auto flash = [&](const std::string& partition_name) { |
| 1841 | do_flash(partition_name.c_str(), image_path.c_str()); |
| 1842 | }; |
| 1843 | do_for_partitions(partition, slot, flash, force_slot); |
| 1844 | |
| 1845 | unlink(image_path.c_str()); |
| 1846 | } |
| 1847 | return true; |
| 1848 | } |
| 1849 | |
| 1850 | static void do_wipe_super(const std::string& image, const std::string& slot_override) { |
| 1851 | if (access(image.c_str(), R_OK) != 0) { |
| 1852 | die("Could not read image: %s", image.c_str()); |
| 1853 | } |
| 1854 | auto metadata = android::fs_mgr::ReadFromImageFile(image); |
| 1855 | if (!metadata) { |
| 1856 | die("Could not parse image: %s", image.c_str()); |
| 1857 | } |
| 1858 | |
| 1859 | auto slot = slot_override; |
| 1860 | if (slot.empty()) { |
| 1861 | slot = get_current_slot(); |
| 1862 | } |
| 1863 | |
| 1864 | std::string message; |
| 1865 | if (!wipe_super(*metadata.get(), slot, &message)) { |
| 1866 | die(message); |
| 1867 | } |
| 1868 | } |
| 1869 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 1870 | int FastBootTool::Main(int argc, char* argv[]) { |
Daniel Rosenberg | 0d08856 | 2015-11-11 16:15:30 -0800 | [diff] [blame] | 1871 | bool wants_wipe = false; |
| 1872 | bool wants_reboot = false; |
| 1873 | bool wants_reboot_bootloader = false; |
Hridya Valsaraju | dea91b4 | 2018-07-17 11:14:01 -0700 | [diff] [blame] | 1874 | bool wants_reboot_recovery = false; |
| 1875 | bool wants_reboot_fastboot = false; |
Mitchell Wills | 31dce30 | 2016-09-26 10:26:21 -0700 | [diff] [blame] | 1876 | bool skip_reboot = false; |
Daniel Rosenberg | 0d08856 | 2015-11-11 16:15:30 -0800 | [diff] [blame] | 1877 | bool wants_set_active = false; |
Daniel Rosenberg | 92b4476 | 2016-07-13 20:03:25 -0700 | [diff] [blame] | 1878 | bool skip_secondary = false; |
David Anderson | 8956964 | 2018-11-16 15:53:35 -0800 | [diff] [blame] | 1879 | bool force_flash = false; |
Jaegeuk Kim | 638d05e | 2020-11-09 08:54:13 -0800 | [diff] [blame] | 1880 | unsigned fs_options = 0; |
Florian Bäuerle | 27ded48 | 2014-11-24 11:29:34 +0100 | [diff] [blame] | 1881 | int longindex; |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 1882 | std::string slot_override; |
Daniel Rosenberg | 0d08856 | 2015-11-11 16:15:30 -0800 | [diff] [blame] | 1883 | std::string next_active; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 1884 | |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1885 | g_boot_img_hdr.kernel_addr = 0x00008000; |
| 1886 | g_boot_img_hdr.ramdisk_addr = 0x01000000; |
| 1887 | g_boot_img_hdr.second_addr = 0x00f00000; |
| 1888 | g_boot_img_hdr.tags_addr = 0x00000100; |
| 1889 | g_boot_img_hdr.page_size = 2048; |
Hridya Valsaraju | 6c8fca6 | 2019-01-24 12:47:08 -0800 | [diff] [blame] | 1890 | g_boot_img_hdr.dtb_addr = 0x01100000; |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1891 | |
JP Abgrall | 7b8970c | 2013-03-07 17:06:41 -0800 | [diff] [blame] | 1892 | const struct option longopts[] = { |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1893 | {"base", required_argument, 0, 0}, |
| 1894 | {"cmdline", required_argument, 0, 0}, |
| 1895 | {"disable-verification", no_argument, 0, 0}, |
| 1896 | {"disable-verity", no_argument, 0, 0}, |
David Anderson | 8956964 | 2018-11-16 15:53:35 -0800 | [diff] [blame] | 1897 | {"force", no_argument, 0, 0}, |
Jaegeuk Kim | 638d05e | 2020-11-09 08:54:13 -0800 | [diff] [blame] | 1898 | {"fs-options", required_argument, 0, 0}, |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1899 | {"header-version", required_argument, 0, 0}, |
Elliott Hughes | 379646b | 2015-06-02 13:50:00 -0700 | [diff] [blame] | 1900 | {"help", no_argument, 0, 'h'}, |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1901 | {"kernel-offset", required_argument, 0, 0}, |
| 1902 | {"os-patch-level", required_argument, 0, 0}, |
| 1903 | {"os-version", required_argument, 0, 0}, |
| 1904 | {"page-size", required_argument, 0, 0}, |
| 1905 | {"ramdisk-offset", required_argument, 0, 0}, |
Daniel Rosenberg | 7aa38bc | 2015-11-11 17:29:37 -0800 | [diff] [blame] | 1906 | {"set-active", optional_argument, 0, 'a'}, |
Mitchell Wills | 31dce30 | 2016-09-26 10:26:21 -0700 | [diff] [blame] | 1907 | {"skip-reboot", no_argument, 0, 0}, |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1908 | {"skip-secondary", no_argument, 0, 0}, |
| 1909 | {"slot", required_argument, 0, 0}, |
| 1910 | {"tags-offset", required_argument, 0, 0}, |
Hridya Valsaraju | 6c8fca6 | 2019-01-24 12:47:08 -0800 | [diff] [blame] | 1911 | {"dtb", required_argument, 0, 0}, |
| 1912 | {"dtb-offset", required_argument, 0, 0}, |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1913 | {"unbuffered", no_argument, 0, 0}, |
Elliott Hughes | f238d87 | 2018-03-29 14:46:29 -0700 | [diff] [blame] | 1914 | {"verbose", no_argument, 0, 'v'}, |
| 1915 | {"version", no_argument, 0, 0}, |
JP Abgrall | 7b8970c | 2013-03-07 17:06:41 -0800 | [diff] [blame] | 1916 | {0, 0, 0, 0} |
| 1917 | }; |
Colin Cross | 8879f98 | 2012-05-22 17:53:34 -0700 | [diff] [blame] | 1918 | |
| 1919 | serial = getenv("ANDROID_SERIAL"); |
| 1920 | |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1921 | int c; |
Elliott Hughes | f3192bd | 2018-04-10 15:38:08 -0700 | [diff] [blame] | 1922 | while ((c = getopt_long(argc, argv, "a::hls:S:vw", longopts, &longindex)) != -1) { |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1923 | if (c == 0) { |
| 1924 | std::string name{longopts[longindex].name}; |
| 1925 | if (name == "base") { |
| 1926 | g_base_addr = strtoul(optarg, 0, 16); |
| 1927 | } else if (name == "cmdline") { |
| 1928 | g_cmdline = optarg; |
| 1929 | } else if (name == "disable-verification") { |
| 1930 | g_disable_verification = true; |
| 1931 | } else if (name == "disable-verity") { |
| 1932 | g_disable_verity = true; |
David Anderson | 8956964 | 2018-11-16 15:53:35 -0800 | [diff] [blame] | 1933 | } else if (name == "force") { |
| 1934 | force_flash = true; |
Jaegeuk Kim | 638d05e | 2020-11-09 08:54:13 -0800 | [diff] [blame] | 1935 | } else if (name == "fs-options") { |
| 1936 | fs_options = ParseFsOption(optarg); |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1937 | } else if (name == "header-version") { |
| 1938 | g_boot_img_hdr.header_version = strtoul(optarg, nullptr, 0); |
Hridya Valsaraju | 6c8fca6 | 2019-01-24 12:47:08 -0800 | [diff] [blame] | 1939 | } else if (name == "dtb") { |
| 1940 | g_dtb_path = optarg; |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1941 | } else if (name == "kernel-offset") { |
| 1942 | g_boot_img_hdr.kernel_addr = strtoul(optarg, 0, 16); |
| 1943 | } else if (name == "os-patch-level") { |
Elliott Hughes | 6ebec93 | 2018-04-10 14:22:13 -0700 | [diff] [blame] | 1944 | ParseOsPatchLevel(&g_boot_img_hdr, optarg); |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1945 | } else if (name == "os-version") { |
Elliott Hughes | 6ebec93 | 2018-04-10 14:22:13 -0700 | [diff] [blame] | 1946 | ParseOsVersion(&g_boot_img_hdr, optarg); |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1947 | } else if (name == "page-size") { |
| 1948 | g_boot_img_hdr.page_size = strtoul(optarg, nullptr, 0); |
| 1949 | if (g_boot_img_hdr.page_size == 0) die("invalid page size"); |
| 1950 | } else if (name == "ramdisk-offset") { |
| 1951 | g_boot_img_hdr.ramdisk_addr = strtoul(optarg, 0, 16); |
| 1952 | } else if (name == "skip-reboot") { |
| 1953 | skip_reboot = true; |
| 1954 | } else if (name == "skip-secondary") { |
| 1955 | skip_secondary = true; |
| 1956 | } else if (name == "slot") { |
| 1957 | slot_override = optarg; |
Hridya Valsaraju | 6c8fca6 | 2019-01-24 12:47:08 -0800 | [diff] [blame] | 1958 | } else if (name == "dtb-offset") { |
| 1959 | g_boot_img_hdr.dtb_addr = strtoul(optarg, 0, 16); |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1960 | } else if (name == "tags-offset") { |
| 1961 | g_boot_img_hdr.tags_addr = strtoul(optarg, 0, 16); |
| 1962 | } else if (name == "unbuffered") { |
Elliott Hughes | fc79767 | 2015-04-07 20:12:50 -0700 | [diff] [blame] | 1963 | setvbuf(stdout, nullptr, _IONBF, 0); |
| 1964 | setvbuf(stderr, nullptr, _IONBF, 0); |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1965 | } else if (name == "version") { |
Dan Willemsen | ab971b5 | 2018-08-29 14:58:02 -0700 | [diff] [blame] | 1966 | fprintf(stdout, "fastboot version %s-%s\n", PLATFORM_TOOLS_VERSION, android::build::GetBuildNumber().c_str()); |
Elliott Hughes | 1fd46df | 2017-03-30 15:08:28 -0700 | [diff] [blame] | 1967 | fprintf(stdout, "Installed as %s\n", android::base::GetExecutablePath().c_str()); |
Elliott Hughes | 379646b | 2015-06-02 13:50:00 -0700 | [diff] [blame] | 1968 | return 0; |
Paul Crowley | 8f7f56e | 2015-11-27 09:29:37 +0000 | [diff] [blame] | 1969 | } else { |
Elliott Hughes | 855cdf8 | 2018-04-02 14:24:03 -0700 | [diff] [blame] | 1970 | die("unknown option %s", longopts[longindex].name); |
Florian Bäuerle | 27ded48 | 2014-11-24 11:29:34 +0100 | [diff] [blame] | 1971 | } |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1972 | } else { |
| 1973 | switch (c) { |
| 1974 | case 'a': |
| 1975 | wants_set_active = true; |
| 1976 | if (optarg) next_active = optarg; |
| 1977 | break; |
| 1978 | case 'h': |
| 1979 | return show_help(); |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1980 | case 'l': |
| 1981 | g_long_listing = true; |
| 1982 | break; |
| 1983 | case 's': |
| 1984 | serial = optarg; |
| 1985 | break; |
| 1986 | case 'S': |
Elliott Hughes | 542370d | 2018-04-19 19:49:44 -0700 | [diff] [blame] | 1987 | if (!android::base::ParseByteCount(optarg, &sparse_limit)) { |
| 1988 | die("invalid sparse limit %s", optarg); |
| 1989 | } |
Elliott Hughes | 577e8b4 | 2018-04-05 16:12:47 -0700 | [diff] [blame] | 1990 | break; |
| 1991 | case 'v': |
| 1992 | set_verbose(); |
| 1993 | break; |
| 1994 | case 'w': |
| 1995 | wants_wipe = true; |
| 1996 | break; |
| 1997 | case '?': |
| 1998 | return 1; |
| 1999 | default: |
| 2000 | abort(); |
| 2001 | } |
Colin Cross | 8879f98 | 2012-05-22 17:53:34 -0700 | [diff] [blame] | 2002 | } |
| 2003 | } |
| 2004 | |
| 2005 | argc -= optind; |
| 2006 | argv += optind; |
| 2007 | |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2008 | if (argc == 0 && !wants_wipe && !wants_set_active) syntax_error("no command"); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 2009 | |
Colin Cross | 8fb6e06 | 2012-07-24 16:36:41 -0700 | [diff] [blame] | 2010 | if (argc > 0 && !strcmp(*argv, "devices")) { |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 2011 | list_devices(); |
Tsu Chiang Chuang | ee52055 | 2011-02-25 18:38:53 -0800 | [diff] [blame] | 2012 | return 0; |
| 2013 | } |
| 2014 | |
Colin Cross | c7b75dc | 2012-08-29 18:17:06 -0700 | [diff] [blame] | 2015 | if (argc > 0 && !strcmp(*argv, "help")) { |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2016 | return show_help(); |
Colin Cross | c7b75dc | 2012-08-29 18:17:06 -0700 | [diff] [blame] | 2017 | } |
| 2018 | |
David Pursell | 0b15663 | 2015-10-30 11:22:01 -0700 | [diff] [blame] | 2019 | Transport* transport = open_device(); |
David Pursell | 2ec418a | 2016-01-20 08:32:08 -0800 | [diff] [blame] | 2020 | if (transport == nullptr) { |
| 2021 | return 1; |
| 2022 | } |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2023 | fastboot::DriverCallbacks driver_callbacks = { |
| 2024 | .prolog = Status, |
| 2025 | .epilog = Epilog, |
| 2026 | .info = InfoMessage, |
| 2027 | }; |
| 2028 | fastboot::FastBootDriver fastboot_driver(transport, driver_callbacks, false); |
| 2029 | fb = &fastboot_driver; |
David Pursell | 2ec418a | 2016-01-20 08:32:08 -0800 | [diff] [blame] | 2030 | |
Elliott Hughes | 5620d22 | 2018-03-28 08:20:00 -0700 | [diff] [blame] | 2031 | const double start = now(); |
| 2032 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 2033 | if (slot_override != "") slot_override = verify_slot(slot_override); |
| 2034 | if (next_active != "") next_active = verify_slot(next_active, false); |
Daniel Rosenberg | 0d08856 | 2015-11-11 16:15:30 -0800 | [diff] [blame] | 2035 | |
| 2036 | if (wants_set_active) { |
| 2037 | if (next_active == "") { |
| 2038 | if (slot_override == "") { |
Daniel Rosenberg | 1345409 | 2016-06-27 19:43:11 -0700 | [diff] [blame] | 2039 | std::string current_slot; |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2040 | if (fb->GetVar("current-slot", ¤t_slot) == fastboot::SUCCESS) { |
LuK1337 | dae48ef | 2020-04-06 14:38:58 +0200 | [diff] [blame] | 2041 | if (current_slot[0] == '_') current_slot.erase(0, 1); |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 2042 | next_active = verify_slot(current_slot, false); |
Daniel Rosenberg | 1345409 | 2016-06-27 19:43:11 -0700 | [diff] [blame] | 2043 | } else { |
| 2044 | wants_set_active = false; |
| 2045 | } |
Daniel Rosenberg | 0d08856 | 2015-11-11 16:15:30 -0800 | [diff] [blame] | 2046 | } else { |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 2047 | next_active = verify_slot(slot_override, false); |
Daniel Rosenberg | 0d08856 | 2015-11-11 16:15:30 -0800 | [diff] [blame] | 2048 | } |
| 2049 | } |
| 2050 | } |
Elliott Hughes | 31dbed7 | 2009-10-07 15:38:53 -0700 | [diff] [blame] | 2051 | |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2052 | std::vector<std::string> args(argv, argv + argc); |
| 2053 | while (!args.empty()) { |
| 2054 | std::string command = next_arg(&args); |
Ken Sumrall | 5ee5d38 | 2012-09-29 14:46:25 -0700 | [diff] [blame] | 2055 | |
Mark Salyzyn | 8e7e9cb | 2018-08-29 10:44:33 -0700 | [diff] [blame] | 2056 | if (command == FB_CMD_GETVAR) { |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2057 | std::string variable = next_arg(&args); |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2058 | DisplayVarOrError(variable, variable); |
Mark Salyzyn | 8e7e9cb | 2018-08-29 10:44:33 -0700 | [diff] [blame] | 2059 | } else if (command == FB_CMD_ERASE) { |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2060 | std::string partition = next_arg(&args); |
| 2061 | auto erase = [&](const std::string& partition) { |
David Pursell | 0b15663 | 2015-10-30 11:22:01 -0700 | [diff] [blame] | 2062 | std::string partition_type; |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2063 | if (fb->GetVar("partition-type:" + partition, &partition_type) == fastboot::SUCCESS && |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 2064 | fs_get_generator(partition_type) != nullptr) { |
| 2065 | fprintf(stderr, "******** Did you mean to fastboot format this %s partition?\n", |
| 2066 | partition_type.c_str()); |
| 2067 | } |
Ken Sumrall | 5ee5d38 | 2012-09-29 14:46:25 -0700 | [diff] [blame] | 2068 | |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2069 | fb->Erase(partition); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 2070 | }; |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 2071 | do_for_partitions(partition, slot_override, erase, true); |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2072 | } else if (android::base::StartsWith(command, "format")) { |
| 2073 | // Parsing for: "format[:[type][:[size]]]" |
| 2074 | // Some valid things: |
| 2075 | // - select only the size, and leave default fs type: |
| 2076 | // format::0x4000000 userdata |
| 2077 | // - default fs type and size: |
| 2078 | // format userdata |
| 2079 | // format:: userdata |
| 2080 | std::vector<std::string> pieces = android::base::Split(command, ":"); |
| 2081 | std::string type_override; |
| 2082 | if (pieces.size() > 1) type_override = pieces[1].c_str(); |
| 2083 | std::string size_override; |
| 2084 | if (pieces.size() > 2) size_override = pieces[2].c_str(); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 2085 | |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2086 | std::string partition = next_arg(&args); |
| 2087 | |
| 2088 | auto format = [&](const std::string& partition) { |
Jaegeuk Kim | 638d05e | 2020-11-09 08:54:13 -0800 | [diff] [blame] | 2089 | fb_perform_format(partition, 0, type_override, size_override, "", fs_options); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 2090 | }; |
Greg Kaiser | b49d9e1 | 2019-03-26 12:04:05 -0700 | [diff] [blame] | 2091 | do_for_partitions(partition, slot_override, format, true); |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2092 | } else if (command == "signature") { |
| 2093 | std::string filename = next_arg(&args); |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 2094 | std::vector<char> data; |
| 2095 | if (!ReadFileToVector(filename, &data)) { |
| 2096 | die("could not load '%s': %s", filename.c_str(), strerror(errno)); |
| 2097 | } |
| 2098 | if (data.size() != 256) die("signature must be 256 bytes (got %zu)", data.size()); |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2099 | fb->Download("signature", data); |
| 2100 | fb->RawCommand("signature", "installing signature"); |
Mark Salyzyn | 8e7e9cb | 2018-08-29 10:44:33 -0700 | [diff] [blame] | 2101 | } else if (command == FB_CMD_REBOOT) { |
Daniel Rosenberg | 0d08856 | 2015-11-11 16:15:30 -0800 | [diff] [blame] | 2102 | wants_reboot = true; |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2103 | |
| 2104 | if (args.size() == 1) { |
| 2105 | std::string what = next_arg(&args); |
| 2106 | if (what == "bootloader") { |
Daniel Rosenberg | 0d08856 | 2015-11-11 16:15:30 -0800 | [diff] [blame] | 2107 | wants_reboot = false; |
| 2108 | wants_reboot_bootloader = true; |
Hridya Valsaraju | dea91b4 | 2018-07-17 11:14:01 -0700 | [diff] [blame] | 2109 | } else if (what == "recovery") { |
| 2110 | wants_reboot = false; |
| 2111 | wants_reboot_recovery = true; |
| 2112 | } else if (what == "fastboot") { |
| 2113 | wants_reboot = false; |
| 2114 | wants_reboot_fastboot = true; |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2115 | } else { |
| 2116 | syntax_error("unknown reboot target %s", what.c_str()); |
Alexey Polyudov | e0bfb75 | 2017-01-03 19:39:13 -0800 | [diff] [blame] | 2117 | } |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2118 | |
Elliott Hughes | ca85df0 | 2015-02-25 10:02:00 -0800 | [diff] [blame] | 2119 | } |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2120 | if (!args.empty()) syntax_error("junk after reboot command"); |
Mark Salyzyn | 8e7e9cb | 2018-08-29 10:44:33 -0700 | [diff] [blame] | 2121 | } else if (command == FB_CMD_REBOOT_BOOTLOADER) { |
Daniel Rosenberg | 0d08856 | 2015-11-11 16:15:30 -0800 | [diff] [blame] | 2122 | wants_reboot_bootloader = true; |
Mark Salyzyn | 8e7e9cb | 2018-08-29 10:44:33 -0700 | [diff] [blame] | 2123 | } else if (command == FB_CMD_REBOOT_RECOVERY) { |
Hridya Valsaraju | dea91b4 | 2018-07-17 11:14:01 -0700 | [diff] [blame] | 2124 | wants_reboot_recovery = true; |
Mark Salyzyn | 8e7e9cb | 2018-08-29 10:44:33 -0700 | [diff] [blame] | 2125 | } else if (command == FB_CMD_REBOOT_FASTBOOT) { |
Hridya Valsaraju | dea91b4 | 2018-07-17 11:14:01 -0700 | [diff] [blame] | 2126 | wants_reboot_fastboot = true; |
Mark Salyzyn | 8e7e9cb | 2018-08-29 10:44:33 -0700 | [diff] [blame] | 2127 | } else if (command == FB_CMD_CONTINUE) { |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2128 | fb->Continue(); |
Mark Salyzyn | 8e7e9cb | 2018-08-29 10:44:33 -0700 | [diff] [blame] | 2129 | } else if (command == FB_CMD_BOOT) { |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2130 | std::string kernel = next_arg(&args); |
| 2131 | std::string ramdisk; |
| 2132 | if (!args.empty()) ramdisk = next_arg(&args); |
| 2133 | std::string second_stage; |
| 2134 | if (!args.empty()) second_stage = next_arg(&args); |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 2135 | auto data = LoadBootableImage(kernel, ramdisk, second_stage); |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2136 | fb->Download("boot.img", data); |
| 2137 | fb->Boot(); |
Mark Salyzyn | 8e7e9cb | 2018-08-29 10:44:33 -0700 | [diff] [blame] | 2138 | } else if (command == FB_CMD_FLASH) { |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2139 | std::string pname = next_arg(&args); |
| 2140 | |
Elliott Hughes | 2810d00 | 2016-04-25 14:31:18 -0700 | [diff] [blame] | 2141 | std::string fname; |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2142 | if (!args.empty()) { |
| 2143 | fname = next_arg(&args); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 2144 | } else { |
Elliott Hughes | 45964a8 | 2017-05-03 22:43:23 -0700 | [diff] [blame] | 2145 | fname = find_item(pname); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 2146 | } |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2147 | if (fname.empty()) die("cannot determine image filename for '%s'", pname.c_str()); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 2148 | |
| 2149 | auto flash = [&](const std::string &partition) { |
David Anderson | 8956964 | 2018-11-16 15:53:35 -0800 | [diff] [blame] | 2150 | if (should_flash_in_userspace(partition) && !is_userspace_fastboot() && |
| 2151 | !force_flash) { |
| 2152 | die("The partition you are trying to flash is dynamic, and " |
| 2153 | "should be flashed via fastbootd. Please run:\n" |
| 2154 | "\n" |
| 2155 | " fastboot reboot fastboot\n" |
| 2156 | "\n" |
| 2157 | "And try again. If you are intentionally trying to " |
| 2158 | "overwrite a fixed partition, use --force."); |
| 2159 | } |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 2160 | do_flash(partition.c_str(), fname.c_str()); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 2161 | }; |
Greg Kaiser | b49d9e1 | 2019-03-26 12:04:05 -0700 | [diff] [blame] | 2162 | do_for_partitions(pname, slot_override, flash, true); |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2163 | } else if (command == "flash:raw") { |
| 2164 | std::string partition = next_arg(&args); |
| 2165 | std::string kernel = next_arg(&args); |
| 2166 | std::string ramdisk; |
| 2167 | if (!args.empty()) ramdisk = next_arg(&args); |
| 2168 | std::string second_stage; |
| 2169 | if (!args.empty()) second_stage = next_arg(&args); |
| 2170 | |
Tom Cherry | dfd85df | 2018-09-20 14:45:05 -0700 | [diff] [blame] | 2171 | auto data = LoadBootableImage(kernel, ramdisk, second_stage); |
| 2172 | auto flashraw = [&data](const std::string& partition) { |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2173 | fb->FlashPartition(partition, data); |
Daniel Rosenberg | b7bd4ae | 2015-09-14 21:05:41 -0700 | [diff] [blame] | 2174 | }; |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 2175 | do_for_partitions(partition, slot_override, flashraw, true); |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2176 | } else if (command == "flashall") { |
Alex Light | bb9b8a5 | 2016-06-29 09:26:44 -0700 | [diff] [blame] | 2177 | if (slot_override == "all") { |
Daniel Rosenberg | 92b4476 | 2016-07-13 20:03:25 -0700 | [diff] [blame] | 2178 | fprintf(stderr, "Warning: slot set to 'all'. Secondary slots will not be flashed.\n"); |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 2179 | do_flashall(slot_override, true, wants_wipe, force_flash); |
Alex Light | bb9b8a5 | 2016-06-29 09:26:44 -0700 | [diff] [blame] | 2180 | } else { |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 2181 | do_flashall(slot_override, skip_secondary, wants_wipe, force_flash); |
Alex Light | bb9b8a5 | 2016-06-29 09:26:44 -0700 | [diff] [blame] | 2182 | } |
Daniel Rosenberg | 0d08856 | 2015-11-11 16:15:30 -0800 | [diff] [blame] | 2183 | wants_reboot = true; |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2184 | } else if (command == "update") { |
Daniel Rosenberg | 92b4476 | 2016-07-13 20:03:25 -0700 | [diff] [blame] | 2185 | bool slot_all = (slot_override == "all"); |
| 2186 | if (slot_all) { |
| 2187 | fprintf(stderr, "Warning: slot set to 'all'. Secondary slots will not be flashed.\n"); |
| 2188 | } |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2189 | std::string filename = "update.zip"; |
| 2190 | if (!args.empty()) { |
| 2191 | filename = next_arg(&args); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 2192 | } |
Andrew Chant | d64b988 | 2021-04-06 12:48:27 -0700 | [diff] [blame] | 2193 | do_update(filename.c_str(), slot_override, skip_secondary || slot_all, force_flash); |
Mitchell Wills | 31dce30 | 2016-09-26 10:26:21 -0700 | [diff] [blame] | 2194 | wants_reboot = true; |
Mark Salyzyn | 8e7e9cb | 2018-08-29 10:44:33 -0700 | [diff] [blame] | 2195 | } else if (command == FB_CMD_SET_ACTIVE) { |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 2196 | std::string slot = verify_slot(next_arg(&args), false); |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2197 | fb->SetActive(slot); |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2198 | } else if (command == "stage") { |
| 2199 | std::string filename = next_arg(&args); |
| 2200 | |
Jocelyn Bohr | 98cc283 | 2017-01-26 19:20:53 -0800 | [diff] [blame] | 2201 | struct fastboot_buffer buf; |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 2202 | if (!load_buf(filename.c_str(), &buf) || buf.type != FB_BUFFER_FD) { |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2203 | die("cannot load '%s'", filename.c_str()); |
Jocelyn Bohr | 98cc283 | 2017-01-26 19:20:53 -0800 | [diff] [blame] | 2204 | } |
Yifan Hong | 58532df | 2021-03-22 16:39:13 -0700 | [diff] [blame] | 2205 | fb->Download(filename, buf.fd.get(), buf.sz); |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2206 | } else if (command == "get_staged") { |
| 2207 | std::string filename = next_arg(&args); |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2208 | fb->Upload(filename); |
Mark Salyzyn | 8e7e9cb | 2018-08-29 10:44:33 -0700 | [diff] [blame] | 2209 | } else if (command == FB_CMD_OEM) { |
| 2210 | do_oem_command(FB_CMD_OEM, &args); |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2211 | } else if (command == "flashing") { |
| 2212 | if (args.empty()) { |
| 2213 | syntax_error("missing 'flashing' command"); |
| 2214 | } else if (args.size() == 1 && (args[0] == "unlock" || args[0] == "lock" || |
| 2215 | args[0] == "unlock_critical" || |
| 2216 | args[0] == "lock_critical" || |
Elliott Hughes | 2e9b779 | 2018-04-04 13:36:44 -0700 | [diff] [blame] | 2217 | args[0] == "get_unlock_ability")) { |
Elliott Hughes | 1eec97a | 2017-05-15 16:53:53 -0700 | [diff] [blame] | 2218 | do_oem_command("flashing", &args); |
Badhri Jagan Sridharan | bf11095 | 2015-05-15 16:43:47 -0700 | [diff] [blame] | 2219 | } else { |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2220 | syntax_error("unknown 'flashing' command %s", args[0].c_str()); |
Badhri Jagan Sridharan | bf11095 | 2015-05-15 16:43:47 -0700 | [diff] [blame] | 2221 | } |
Mark Salyzyn | 8e7e9cb | 2018-08-29 10:44:33 -0700 | [diff] [blame] | 2222 | } else if (command == FB_CMD_CREATE_PARTITION) { |
David Anderson | 0d4277d | 2018-07-31 13:27:37 -0700 | [diff] [blame] | 2223 | std::string partition = next_arg(&args); |
| 2224 | std::string size = next_arg(&args); |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2225 | fb->CreatePartition(partition, size); |
Mark Salyzyn | 8e7e9cb | 2018-08-29 10:44:33 -0700 | [diff] [blame] | 2226 | } else if (command == FB_CMD_DELETE_PARTITION) { |
David Anderson | 0d4277d | 2018-07-31 13:27:37 -0700 | [diff] [blame] | 2227 | std::string partition = next_arg(&args); |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2228 | fb->DeletePartition(partition); |
Mark Salyzyn | 8e7e9cb | 2018-08-29 10:44:33 -0700 | [diff] [blame] | 2229 | } else if (command == FB_CMD_RESIZE_PARTITION) { |
David Anderson | 0d4277d | 2018-07-31 13:27:37 -0700 | [diff] [blame] | 2230 | std::string partition = next_arg(&args); |
| 2231 | std::string size = next_arg(&args); |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2232 | fb->ResizePartition(partition, size); |
David Anderson | 1d504e3 | 2019-01-15 14:38:20 -0800 | [diff] [blame] | 2233 | } else if (command == "gsi") { |
David Anderson | 3d782d5 | 2019-01-29 13:09:49 -0800 | [diff] [blame] | 2234 | std::string arg = next_arg(&args); |
| 2235 | if (arg == "wipe") { |
David Anderson | 1d504e3 | 2019-01-15 14:38:20 -0800 | [diff] [blame] | 2236 | fb->RawCommand("gsi:wipe", "wiping GSI"); |
David Anderson | 3d782d5 | 2019-01-29 13:09:49 -0800 | [diff] [blame] | 2237 | } else if (arg == "disable") { |
David Anderson | 1d504e3 | 2019-01-15 14:38:20 -0800 | [diff] [blame] | 2238 | fb->RawCommand("gsi:disable", "disabling GSI"); |
| 2239 | } else { |
| 2240 | syntax_error("expected 'wipe' or 'disable'"); |
| 2241 | } |
David Anderson | 7c84b9f | 2019-06-27 22:15:29 -0700 | [diff] [blame] | 2242 | } else if (command == "wipe-super") { |
| 2243 | std::string image; |
| 2244 | if (args.empty()) { |
| 2245 | image = find_item_given_name("super_empty.img"); |
| 2246 | } else { |
| 2247 | image = next_arg(&args); |
| 2248 | } |
| 2249 | do_wipe_super(image, slot_override); |
David Anderson | ab8f466 | 2019-10-21 16:45:59 -0700 | [diff] [blame] | 2250 | } else if (command == "snapshot-update") { |
| 2251 | std::string arg; |
| 2252 | if (!args.empty()) { |
| 2253 | arg = next_arg(&args); |
| 2254 | } |
David Anderson | 220ddb1 | 2019-10-31 18:02:41 -0700 | [diff] [blame] | 2255 | if (!arg.empty() && (arg != "cancel" && arg != "merge")) { |
| 2256 | syntax_error("expected: snapshot-update [cancel|merge]"); |
David Anderson | ab8f466 | 2019-10-21 16:45:59 -0700 | [diff] [blame] | 2257 | } |
| 2258 | fb->SnapshotUpdateCommand(arg); |
Yifan Hong | bcd2770 | 2021-02-16 19:37:32 -0800 | [diff] [blame] | 2259 | } else if (command == FB_CMD_FETCH) { |
| 2260 | std::string partition = next_arg(&args); |
| 2261 | std::string outfile = next_arg(&args); |
| 2262 | do_fetch(partition, slot_override, outfile); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 2263 | } else { |
Elliott Hughes | d6365a7 | 2017-05-08 18:04:49 -0700 | [diff] [blame] | 2264 | syntax_error("unknown command %s", command.c_str()); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 2265 | } |
| 2266 | } |
| 2267 | |
| 2268 | if (wants_wipe) { |
David Anderson | ab8f466 | 2019-10-21 16:45:59 -0700 | [diff] [blame] | 2269 | if (force_flash) { |
| 2270 | CancelSnapshotIfNeeded(); |
| 2271 | } |
Paul Crowley | 4d17006 | 2018-04-24 17:06:30 -0700 | [diff] [blame] | 2272 | std::vector<std::string> partitions = { "userdata", "cache", "metadata" }; |
| 2273 | for (const auto& partition : partitions) { |
| 2274 | std::string partition_type; |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2275 | if (fb->GetVar("partition-type:" + partition, &partition_type) != fastboot::SUCCESS) { |
| 2276 | continue; |
| 2277 | } |
Paul Crowley | 4d17006 | 2018-04-24 17:06:30 -0700 | [diff] [blame] | 2278 | if (partition_type.empty()) continue; |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2279 | fb->Erase(partition); |
Paul Crowley | 47770a1 | 2021-06-15 16:07:57 -0700 | [diff] [blame] | 2280 | fb_perform_format(partition, 1, partition_type, "", "", fs_options); |
Elliott Hughes | 2fd45a9 | 2015-10-30 11:49:47 -0700 | [diff] [blame] | 2281 | } |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 2282 | } |
Daniel Rosenberg | 0d08856 | 2015-11-11 16:15:30 -0800 | [diff] [blame] | 2283 | if (wants_set_active) { |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2284 | fb->SetActive(next_active); |
Daniel Rosenberg | 0d08856 | 2015-11-11 16:15:30 -0800 | [diff] [blame] | 2285 | } |
Mitchell Wills | 31dce30 | 2016-09-26 10:26:21 -0700 | [diff] [blame] | 2286 | if (wants_reboot && !skip_reboot) { |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2287 | fb->Reboot(); |
| 2288 | fb->WaitForDisconnect(); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 2289 | } else if (wants_reboot_bootloader) { |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2290 | fb->RebootTo("bootloader"); |
| 2291 | fb->WaitForDisconnect(); |
Hridya Valsaraju | dea91b4 | 2018-07-17 11:14:01 -0700 | [diff] [blame] | 2292 | } else if (wants_reboot_recovery) { |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2293 | fb->RebootTo("recovery"); |
| 2294 | fb->WaitForDisconnect(); |
Hridya Valsaraju | dea91b4 | 2018-07-17 11:14:01 -0700 | [diff] [blame] | 2295 | } else if (wants_reboot_fastboot) { |
David Anderson | 11d6d27 | 2018-12-07 16:39:07 -0800 | [diff] [blame] | 2296 | reboot_to_userspace_fastboot(); |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 2297 | } |
| 2298 | |
Elliott Hughes | 5620d22 | 2018-03-28 08:20:00 -0700 | [diff] [blame] | 2299 | fprintf(stderr, "Finished. Total time: %.3fs\n", (now() - start)); |
David Anderson | 03de645 | 2018-09-04 14:32:54 -0700 | [diff] [blame] | 2300 | |
Tom Cherry | 9027af0 | 2018-09-24 15:48:09 -0700 | [diff] [blame] | 2301 | auto* old_transport = fb->set_transport(nullptr); |
| 2302 | delete old_transport; |
| 2303 | |
Tom Cherry | 11f1209 | 2018-08-29 21:36:28 -0700 | [diff] [blame] | 2304 | return 0; |
The Android Open Source Project | dd7bc33 | 2009-03-03 19:32:55 -0800 | [diff] [blame] | 2305 | } |
Elliott Hughes | 6ebec93 | 2018-04-10 14:22:13 -0700 | [diff] [blame] | 2306 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 2307 | void FastBootTool::ParseOsPatchLevel(boot_img_hdr_v1* hdr, const char* arg) { |
Elliott Hughes | 6ebec93 | 2018-04-10 14:22:13 -0700 | [diff] [blame] | 2308 | unsigned year, month, day; |
| 2309 | if (sscanf(arg, "%u-%u-%u", &year, &month, &day) != 3) { |
| 2310 | syntax_error("OS patch level should be YYYY-MM-DD: %s", arg); |
| 2311 | } |
| 2312 | if (year < 2000 || year >= 2128) syntax_error("year out of range: %d", year); |
| 2313 | if (month < 1 || month > 12) syntax_error("month out of range: %d", month); |
| 2314 | hdr->SetOsPatchLevel(year, month); |
| 2315 | } |
| 2316 | |
Aaron Wisner | db51120 | 2018-06-26 15:38:35 -0500 | [diff] [blame] | 2317 | void FastBootTool::ParseOsVersion(boot_img_hdr_v1* hdr, const char* arg) { |
Elliott Hughes | 6ebec93 | 2018-04-10 14:22:13 -0700 | [diff] [blame] | 2318 | unsigned major = 0, minor = 0, patch = 0; |
| 2319 | std::vector<std::string> versions = android::base::Split(arg, "."); |
| 2320 | if (versions.size() < 1 || versions.size() > 3 || |
| 2321 | (versions.size() >= 1 && !android::base::ParseUint(versions[0], &major)) || |
| 2322 | (versions.size() >= 2 && !android::base::ParseUint(versions[1], &minor)) || |
| 2323 | (versions.size() == 3 && !android::base::ParseUint(versions[2], &patch)) || |
| 2324 | (major > 0x7f || minor > 0x7f || patch > 0x7f)) { |
| 2325 | syntax_error("bad OS version: %s", arg); |
| 2326 | } |
| 2327 | hdr->SetOsVersion(major, minor, patch); |
| 2328 | } |
Jaegeuk Kim | 638d05e | 2020-11-09 08:54:13 -0800 | [diff] [blame] | 2329 | |
| 2330 | unsigned FastBootTool::ParseFsOption(const char* arg) { |
| 2331 | unsigned fsOptions = 0; |
| 2332 | |
| 2333 | std::vector<std::string> options = android::base::Split(arg, ","); |
| 2334 | if (options.size() < 1) |
| 2335 | syntax_error("bad options: %s", arg); |
| 2336 | |
| 2337 | for (size_t i = 0; i < options.size(); ++i) { |
| 2338 | if (options[i] == "casefold") |
| 2339 | fsOptions |= (1 << FS_OPT_CASEFOLD); |
| 2340 | else if (options[i] == "projid") |
| 2341 | fsOptions |= (1 << FS_OPT_PROJID); |
| 2342 | else if (options[i] == "compress") |
| 2343 | fsOptions |= (1 << FS_OPT_COMPRESS); |
| 2344 | else |
| 2345 | syntax_error("unsupported options: %s", options[i].c_str()); |
| 2346 | } |
| 2347 | return fsOptions; |
| 2348 | } |