blob: d753f0f822815ba444c5e3284c3d0a31539bc3dd [file] [log] [blame]
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001/*
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 Chuangee520552011-02-25 18:38:53 -080012 * the documentation and/or other materials provided with the
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080013 * 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 Chuangee520552011-02-25 18:38:53 -080022 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080023 * 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 Cherry9027af02018-09-24 15:48:09 -070029#include "fastboot.h"
30
Mark Salyzyn5957c1f2014-04-30 14:05:28 -070031#include <ctype.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080032#include <errno.h>
33#include <fcntl.h>
Colin Cross8879f982012-05-22 17:53:34 -070034#include <getopt.h>
Ying Wangcf86e2f2014-05-15 20:06:40 -070035#include <inttypes.h>
Mark Salyzyn5957c1f2014-04-30 14:05:28 -070036#include <limits.h>
Mark Salyzyn5957c1f2014-04-30 14:05:28 -070037#include <stdint.h>
38#include <stdio.h>
39#include <stdlib.h>
40#include <string.h>
41#include <sys/stat.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080042#include <sys/time.h>
Colin Crossf8387882012-05-24 17:18:41 -070043#include <sys/types.h>
Mark Salyzyn5957c1f2014-04-30 14:05:28 -070044#include <unistd.h>
David Pursell2ec418a2016-01-20 08:32:08 -080045
Elliott Hughes290a2282016-11-14 17:08:47 -080046#include <chrono>
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -070047#include <functional>
Tom Cherry4aa60b32018-09-05 15:11:44 -070048#include <regex>
David Anderson0c732342018-11-28 17:10:42 -080049#include <string>
Elliott Hughes290a2282016-11-14 17:08:47 -080050#include <thread>
Josh Gao9da9ac52016-01-19 14:50:18 -080051#include <utility>
52#include <vector>
Colin Crossf8387882012-05-24 17:18:41 -070053
Elliott Hughes82ff3152016-08-31 15:07:18 -070054#include <android-base/file.h>
Elliott Hughes749ae2d2016-06-28 14:48:45 -070055#include <android-base/macros.h>
Elliott Hughes4f713192015-12-04 22:00:26 -080056#include <android-base/parseint.h>
David Pursell2ec418a2016-01-20 08:32:08 -080057#include <android-base/parsenetaddress.h>
Elliott Hughes2810d002016-04-25 14:31:18 -070058#include <android-base/stringprintf.h>
Elliott Hughes4f713192015-12-04 22:00:26 -080059#include <android-base/strings.h>
Chris Fries0ea946c2017-04-12 10:25:57 -050060#include <android-base/unique_fd.h>
Dan Willemsenab971b52018-08-29 14:58:02 -070061#include <build/version.h>
David Anderson89569642018-11-16 15:53:35 -080062#include <liblp/liblp.h>
Dan Willemsenab971b52018-08-29 14:58:02 -070063#include <platform_tools_version.h>
Colin Crossf8387882012-05-24 17:18:41 -070064#include <sparse/sparse.h>
Elliott Hughesd30ad8a2015-03-18 23:12:44 -070065#include <ziparchive/zip_archive.h>
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080066
Elliott Hughes253c18d2015-03-18 22:47:09 -070067#include "bootimg_utils.h"
Mark Salyzyn8e7e9cb2018-08-29 10:44:33 -070068#include "constants.h"
Elliott Hughes1b708d32015-12-11 19:07:01 -080069#include "diagnose_usb.h"
Tom Cherry9027af02018-09-24 15:48:09 -070070#include "fastboot_driver.h"
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -070071#include "fs.h"
David Pursell2ec418a2016-01-20 08:32:08 -080072#include "tcp.h"
David Pursell0b156632015-10-30 11:22:01 -070073#include "transport.h"
David Pursell4601c972016-02-05 15:35:09 -080074#include "udp.h"
David Pursell0b156632015-10-30 11:22:01 -070075#include "usb.h"
Tom Cherry9027af02018-09-24 15:48:09 -070076#include "util.h"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080077
Tom Cherrydfd85df2018-09-20 14:45:05 -070078using android::base::ReadFully;
Tom Cherry4aa60b32018-09-05 15:11:44 -070079using android::base::Split;
80using android::base::Trim;
Chris Fries0ea946c2017-04-12 10:25:57 -050081using android::base::unique_fd;
David Anderson0c732342018-11-28 17:10:42 -080082using namespace std::string_literals;
Chris Fries0ea946c2017-04-12 10:25:57 -050083
David Pursell2ec418a2016-01-20 08:32:08 -080084static const char* serial = nullptr;
Elliott Hughes577e8b42018-04-05 16:12:47 -070085
Elliott Hughes577e8b42018-04-05 16:12:47 -070086static bool g_long_listing = false;
Chris Fries6a999712017-04-04 09:52:47 -050087// Don't resparse files in too-big chunks.
88// libsparse will support INT_MAX, but this results in large allocations, so
89// let's keep it at 1GB to avoid memory pressure on the host.
90static constexpr int64_t RESPARSE_LIMIT = 1 * 1024 * 1024 * 1024;
Elliott Hughes542370d2018-04-19 19:49:44 -070091static uint64_t sparse_limit = 0;
Colin Crossf8387882012-05-24 17:18:41 -070092static int64_t target_sparse_limit = -1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -080093
Elliott Hughes577e8b42018-04-05 16:12:47 -070094static unsigned g_base_addr = 0x10000000;
95static boot_img_hdr_v1 g_boot_img_hdr = {};
96static std::string g_cmdline;
JP Abgrall7b8970c2013-03-07 17:06:41 -080097
David Zeuthenb6ea4352017-08-07 14:29:26 -040098static bool g_disable_verity = false;
99static bool g_disable_verification = false;
100
Paul Crowley8f7f56e2015-11-27 09:29:37 +0000101static const std::string convert_fbe_marker_filename("convert_fbe");
102
Tom Cherry9027af02018-09-24 15:48:09 -0700103fastboot::FastBootDriver* fb = nullptr;
104
Rom Lemarchand622810c2013-06-28 09:54:59 -0700105enum fb_buffer_type {
Chris Fries0ea946c2017-04-12 10:25:57 -0500106 FB_BUFFER_FD,
Rom Lemarchand622810c2013-06-28 09:54:59 -0700107 FB_BUFFER_SPARSE,
108};
109
110struct fastboot_buffer {
111 enum fb_buffer_type type;
Elliott Hughesfc797672015-04-07 20:12:50 -0700112 void* data;
113 int64_t sz;
Chris Fries0ea946c2017-04-12 10:25:57 -0500114 int fd;
David Anderson32e376f2018-08-16 13:43:11 -0700115 int64_t image_size;
Rom Lemarchand622810c2013-06-28 09:54:59 -0700116};
117
David Anderson0debda02018-08-28 13:54:03 -0700118enum class ImageType {
119 // Must be flashed for device to boot into the kernel.
120 BootCritical,
121 // Normal partition to be flashed during "flashall".
122 Normal,
123 // Partition that is never flashed during "flashall".
124 Extra
125};
126
David Anderson32e376f2018-08-16 13:43:11 -0700127struct Image {
Elliott Hughes45964a82017-05-03 22:43:23 -0700128 const char* nickname;
129 const char* img_name;
130 const char* sig_name;
131 const char* part_name;
Hridya Valsarajuf1f0a9c2018-08-02 10:46:21 -0700132 bool optional_if_no_image;
David Anderson0debda02018-08-28 13:54:03 -0700133 ImageType type;
Hridya Valsarajuf1f0a9c2018-08-02 10:46:21 -0700134 bool IsSecondary() const { return nickname == nullptr; }
David Anderson32e376f2018-08-16 13:43:11 -0700135};
136
137static Image images[] = {
Dario Frenic7ea1af2018-05-25 16:07:19 +0100138 // clang-format off
David Anderson0debda02018-08-28 13:54:03 -0700139 { "boot", "boot.img", "boot.sig", "boot", false, ImageType::BootCritical },
140 { nullptr, "boot_other.img", "boot.sig", "boot", true, ImageType::Normal },
141 { "cache", "cache.img", "cache.sig", "cache", true, ImageType::Extra },
142 { "dtbo", "dtbo.img", "dtbo.sig", "dtbo", true, ImageType::BootCritical },
143 { "dts", "dt.img", "dt.sig", "dts", true, ImageType::BootCritical },
144 { "odm", "odm.img", "odm.sig", "odm", true, ImageType::Normal },
145 { "product", "product.img", "product.sig", "product", true, ImageType::Normal },
Dario Freniab5583b2018-08-17 01:01:25 +0100146 { "product_services",
147 "product_services.img",
148 "product_services.sig",
David Anderson8cdea7f2018-08-06 15:36:00 -0700149 "product_services",
David Anderson0debda02018-08-28 13:54:03 -0700150 true, ImageType::Normal },
151 { "recovery", "recovery.img", "recovery.sig", "recovery", true, ImageType::BootCritical },
152 { "super", "super.img", "super.sig", "super", true, ImageType::Extra },
153 { "system", "system.img", "system.sig", "system", false, ImageType::Normal },
154 { nullptr, "system_other.img", "system.sig", "system", true, ImageType::Normal },
155 { "userdata", "userdata.img", "userdata.sig", "userdata", true, ImageType::Extra },
156 { "vbmeta", "vbmeta.img", "vbmeta.sig", "vbmeta", true, ImageType::BootCritical },
David Anderson166bfef2018-10-15 14:46:59 -0700157 { "vbmeta_system",
158 "vbmeta_system.img",
159 "vbmeta_system.sig",
160 "vbmeta_system",
David Anderson1109c922018-09-17 17:32:54 -0700161 true, ImageType::BootCritical },
David Anderson0debda02018-08-28 13:54:03 -0700162 { "vendor", "vendor.img", "vendor.sig", "vendor", true, ImageType::Normal },
163 { nullptr, "vendor_other.img", "vendor.sig", "vendor", true, ImageType::Normal },
Dario Frenic7ea1af2018-05-25 16:07:19 +0100164 // clang-format on
Rom Lemarchand622810c2013-06-28 09:54:59 -0700165};
Brian Swetland2a63bb72009-04-28 16:05:07 -0700166
David Andersone0e693c2018-11-27 20:19:26 -0800167static char* get_android_product_out() {
Elliott Hughes45964a82017-05-03 22:43:23 -0700168 char* dir = getenv("ANDROID_PRODUCT_OUT");
Alex Lightbb9b8a52016-06-29 09:26:44 -0700169 if (dir == nullptr || dir[0] == '\0') {
David Andersone0e693c2018-11-27 20:19:26 -0800170 return nullptr;
171 }
172 return dir;
173}
174
175static std::string find_item_given_name(const std::string& img_name) {
176 char* dir = get_android_product_out();
177 if (!dir) {
Elliott Hughes45964a82017-05-03 22:43:23 -0700178 die("ANDROID_PRODUCT_OUT not set");
Alex Lightbb9b8a52016-06-29 09:26:44 -0700179 }
David Anderson0debda02018-08-28 13:54:03 -0700180 return std::string(dir) + "/" + img_name;
Alex Lightbb9b8a52016-06-29 09:26:44 -0700181}
182
Elliott Hughes29d5d7d2017-05-11 15:05:13 -0700183static std::string find_item(const std::string& item) {
Elliott Hughes45964a82017-05-03 22:43:23 -0700184 for (size_t i = 0; i < arraysize(images); ++i) {
Elliott Hughesd6365a72017-05-08 18:04:49 -0700185 if (images[i].nickname && item == images[i].nickname) {
Elliott Hughes45964a82017-05-03 22:43:23 -0700186 return find_item_given_name(images[i].img_name);
187 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800188 }
189
Elliott Hughesd6365a72017-05-08 18:04:49 -0700190 fprintf(stderr, "unknown partition '%s'\n", item.c_str());
Elliott Hughes45964a82017-05-03 22:43:23 -0700191 return "";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800192}
193
Tom Cherry9027af02018-09-24 15:48:09 -0700194double last_start_time;
195
196static void Status(const std::string& message) {
197 static constexpr char kStatusFormat[] = "%-50s ";
198 fprintf(stderr, kStatusFormat, message.c_str());
199 last_start_time = now();
200}
201
202static void Epilog(int status) {
203 if (status) {
204 fprintf(stderr, "FAILED (%s)\n", fb->Error().c_str());
205 die("Command failed");
206 } else {
207 double split = now();
208 fprintf(stderr, "OKAY [%7.3fs]\n", (split - last_start_time));
209 }
210}
211
212static void InfoMessage(const std::string& info) {
213 fprintf(stderr, "(bootloader) %s\n", info.c_str());
214}
215
Elliott Hughesfc797672015-04-07 20:12:50 -0700216static int64_t get_file_size(int fd) {
217 struct stat sb;
Tom Cherrydfd85df2018-09-20 14:45:05 -0700218 if (fstat(fd, &sb) == -1) {
219 die("could not get file size");
220 }
221 return sb.st_size;
Colin Crossf8387882012-05-24 17:18:41 -0700222}
223
Tom Cherrydfd85df2018-09-20 14:45:05 -0700224bool ReadFileToVector(const std::string& file, std::vector<char>* out) {
225 out->clear();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800226
Tom Cherrydfd85df2018-09-20 14:45:05 -0700227 unique_fd fd(TEMP_FAILURE_RETRY(open(file.c_str(), O_RDONLY | O_CLOEXEC | O_BINARY)));
228 if (fd == -1) {
229 return false;
Rom Lemarchand622810c2013-06-28 09:54:59 -0700230 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800231
Tom Cherrydfd85df2018-09-20 14:45:05 -0700232 out->resize(get_file_size(fd));
233 return ReadFully(fd, out->data(), out->size());
Rom Lemarchand622810c2013-06-28 09:54:59 -0700234}
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800235
Elliott Hughesfc797672015-04-07 20:12:50 -0700236static int match_fastboot_with_serial(usb_ifc_info* info, const char* local_serial) {
Elliott Hughese1746fd2015-08-10 15:30:54 -0700237 if (info->ifc_class != 0xff || info->ifc_subclass != 0x42 || info->ifc_protocol != 0x03) {
238 return -1;
239 }
240
Scott Anderson13081c62012-04-06 12:39:30 -0700241 // require matching serial number or device path if requested
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800242 // at the command line with the -s option.
JP Abgralla032ded2012-06-06 11:53:33 -0700243 if (local_serial && (strcmp(local_serial, info->serial_number) != 0 &&
244 strcmp(local_serial, info->device_path) != 0)) return -1;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800245 return 0;
246}
247
Elliott Hughesfc797672015-04-07 20:12:50 -0700248static int match_fastboot(usb_ifc_info* info) {
JP Abgrall7b8970c2013-03-07 17:06:41 -0800249 return match_fastboot_with_serial(info, serial);
250}
251
Elliott Hughesfc797672015-04-07 20:12:50 -0700252static int list_devices_callback(usb_ifc_info* info) {
253 if (match_fastboot_with_serial(info, nullptr) == 0) {
Elliott Hughes1b708d32015-12-11 19:07:01 -0800254 std::string serial = info->serial_number;
Elliott Hughesb4add9b2009-10-06 18:07:49 -0700255 if (!info->writable) {
Elliott Hughes1b708d32015-12-11 19:07:01 -0800256 serial = UsbNoPermissionsShortHelpText();
Elliott Hughesb4add9b2009-10-06 18:07:49 -0700257 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800258 if (!serial[0]) {
259 serial = "????????????";
260 }
Scott Anderson866b1bd2012-06-04 20:29:11 -0700261 // output compatible with "adb devices"
Elliott Hughes577e8b42018-04-05 16:12:47 -0700262 if (!g_long_listing) {
Elliott Hughes1b708d32015-12-11 19:07:01 -0800263 printf("%s\tfastboot", serial.c_str());
Scott Anderson13081c62012-04-06 12:39:30 -0700264 } else {
Elliott Hughes1b708d32015-12-11 19:07:01 -0800265 printf("%-22s fastboot", serial.c_str());
266 if (strlen(info->device_path) > 0) printf(" %s", info->device_path);
Scott Anderson13081c62012-04-06 12:39:30 -0700267 }
Elliott Hughes1b708d32015-12-11 19:07:01 -0800268 putchar('\n');
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800269 }
270
271 return -1;
272}
273
David Pursell2ec418a2016-01-20 08:32:08 -0800274// Opens a new Transport connected to a device. If |serial| is non-null it will be used to identify
275// a specific device, otherwise the first USB device found will be used.
276//
Elliott Hughes855cdf82018-04-02 14:24:03 -0700277// If |serial| is non-null but invalid, this exits.
David Pursell2ec418a2016-01-20 08:32:08 -0800278// Otherwise it blocks until the target is available.
279//
280// The returned Transport is a singleton, so multiple calls to this function will return the same
281// object, and the caller should not attempt to delete the returned Transport.
David Pursell0b156632015-10-30 11:22:01 -0700282static Transport* open_device() {
David Pursell2ec418a2016-01-20 08:32:08 -0800283 bool announce = true;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800284
David Pursell4601c972016-02-05 15:35:09 -0800285 Socket::Protocol protocol = Socket::Protocol::kTcp;
David Pursell2ec418a2016-01-20 08:32:08 -0800286 std::string host;
David Pursell4601c972016-02-05 15:35:09 -0800287 int port = 0;
288 if (serial != nullptr) {
289 const char* net_address = nullptr;
David Pursell2ec418a2016-01-20 08:32:08 -0800290
David Pursell4601c972016-02-05 15:35:09 -0800291 if (android::base::StartsWith(serial, "tcp:")) {
292 protocol = Socket::Protocol::kTcp;
293 port = tcp::kDefaultPort;
294 net_address = serial + strlen("tcp:");
295 } else if (android::base::StartsWith(serial, "udp:")) {
296 protocol = Socket::Protocol::kUdp;
297 port = udp::kDefaultPort;
298 net_address = serial + strlen("udp:");
299 }
300
301 if (net_address != nullptr) {
302 std::string error;
303 if (!android::base::ParseNetAddress(net_address, &host, &port, nullptr, &error)) {
Elliott Hughes855cdf82018-04-02 14:24:03 -0700304 die("invalid network address '%s': %s\n", net_address, error.c_str());
David Pursell4601c972016-02-05 15:35:09 -0800305 }
David Pursell2ec418a2016-01-20 08:32:08 -0800306 }
307 }
308
David Anderson1d887432018-08-27 16:47:32 -0700309 Transport* transport = nullptr;
David Pursell2ec418a2016-01-20 08:32:08 -0800310 while (true) {
311 if (!host.empty()) {
312 std::string error;
David Pursell4601c972016-02-05 15:35:09 -0800313 if (protocol == Socket::Protocol::kTcp) {
314 transport = tcp::Connect(host, port, &error).release();
315 } else if (protocol == Socket::Protocol::kUdp) {
316 transport = udp::Connect(host, port, &error).release();
317 }
318
David Pursell2ec418a2016-01-20 08:32:08 -0800319 if (transport == nullptr && announce) {
320 fprintf(stderr, "error: %s\n", error.c_str());
321 }
322 } else {
323 transport = usb_open(match_fastboot);
324 }
325
326 if (transport != nullptr) {
327 return transport;
328 }
329
David Pursell0b156632015-10-30 11:22:01 -0700330 if (announce) {
David Pursell2ec418a2016-01-20 08:32:08 -0800331 announce = false;
Elliott Hughesb46964f2015-08-19 17:49:45 -0700332 fprintf(stderr, "< waiting for %s >\n", serial ? serial : "any device");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800333 }
Elliott Hughes290a2282016-11-14 17:08:47 -0800334 std::this_thread::sleep_for(std::chrono::milliseconds(1));
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800335 }
336}
337
Elliott Hughesfc797672015-04-07 20:12:50 -0700338static void list_devices() {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800339 // We don't actually open a USB device here,
340 // just getting our callback called so we can
341 // list all the connected devices.
342 usb_open(list_devices_callback);
343}
344
Elliott Hughesd6365a72017-05-08 18:04:49 -0700345static void syntax_error(const char* fmt, ...) {
346 fprintf(stderr, "fastboot: usage: ");
347
348 va_list ap;
349 va_start(ap, fmt);
350 vfprintf(stderr, fmt, ap);
351 va_end(ap);
352
353 fprintf(stderr, "\n");
354 exit(1);
355}
356
357static int show_help() {
358 // clang-format off
359 fprintf(stdout,
Elliott Hughes07fc6822018-05-24 16:36:05 -0700360// 1 2 3 4 5 6 7 8
361// 12345678901234567890123456789012345678901234567890123456789012345678901234567890
Elliott Hughesb76188f2018-04-03 13:30:18 -0700362 "usage: fastboot [OPTION...] COMMAND...\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800363 "\n"
Elliott Hughesb76188f2018-04-03 13:30:18 -0700364 "flashing:\n"
365 " update ZIP Flash all partitions from an update.zip package.\n"
366 " flashall Flash all partitions from $ANDROID_PRODUCT_OUT.\n"
367 " On A/B devices, flashed slot is set as active.\n"
368 " Secondary images may be flashed to inactive slot.\n"
Elliott Hughes07fc6822018-05-24 16:36:05 -0700369 " flash PARTITION [FILENAME] Flash given partition, using the image from\n"
370 " $ANDROID_PRODUCT_OUT if no filename is given.\n"
Elliott Hughesb76188f2018-04-03 13:30:18 -0700371 "\n"
372 "basics:\n"
373 " devices [-l] List devices in bootloader (-l: with device paths).\n"
374 " getvar NAME Display given bootloader variable.\n"
375 " reboot [bootloader] Reboot device.\n"
376 "\n"
377 "locking/unlocking:\n"
378 " flashing lock|unlock Lock/unlock partitions for flashing\n"
379 " flashing lock_critical|unlock_critical\n"
380 " Lock/unlock 'critical' bootloader partitions.\n"
381 " flashing get_unlock_ability\n"
382 " Check whether unlocking is allowed (1) or not(0).\n"
383 "\n"
384 "advanced:\n"
385 " erase PARTITION Erase a flash partition.\n"
386 " format[:FS_TYPE[:SIZE]] PARTITION\n"
387 " Format a flash partition.\n"
388 " set_active SLOT Set the active slot.\n"
389 " oem [COMMAND...] Execute OEM-specific command.\n"
David Anderson1d504e32019-01-15 14:38:20 -0800390 " gsi wipe|disable Wipe or disable a GSI installation (fastbootd only).\n"
Elliott Hughesb76188f2018-04-03 13:30:18 -0700391 "\n"
392 "boot image:\n"
393 " boot KERNEL [RAMDISK [SECOND]]\n"
394 " Download and boot kernel from RAM.\n"
395 " flash:raw PARTITION KERNEL [RAMDISK [SECOND]]\n"
396 " Create boot image and flash it.\n"
Elliott Hughes577e8b42018-04-05 16:12:47 -0700397 " --cmdline CMDLINE Override kernel command line.\n"
Elliott Hughesb76188f2018-04-03 13:30:18 -0700398 " --base ADDRESS Set kernel base address (default: 0x10000000).\n"
399 " --kernel-offset Set kernel offset (default: 0x00008000).\n"
400 " --ramdisk-offset Set ramdisk offset (default: 0x01000000).\n"
401 " --tags-offset Set tags offset (default: 0x00000100).\n"
402 " --page-size BYTES Set flash page size (default: 2048).\n"
403 " --header-version VERSION Set boot image header version.\n"
Elliott Hughes577e8b42018-04-05 16:12:47 -0700404 " --os-version MAJOR[.MINOR[.PATCH]]\n"
405 " Set boot image OS version (default: 0.0.0).\n"
406 " --os-patch-level YYYY-MM-DD\n"
407 " Set boot image OS security patch level.\n"
408 // TODO: still missing: `second_addr`, `name`, `id`, `recovery_dtbo_*`.
Elliott Hughesb76188f2018-04-03 13:30:18 -0700409 "\n"
Elliott Hughes2e9b7792018-04-04 13:36:44 -0700410 // TODO: what device(s) used this? is there any documentation?
Elliott Hughesb76188f2018-04-03 13:30:18 -0700411 //" continue Continue with autoboot.\n"
412 //"\n"
413 "Android Things:\n"
414 " stage IN_FILE Sends given file to stage for the next command.\n"
415 " get_staged OUT_FILE Writes data staged by the last command to a file.\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800416 "\n"
417 "options:\n"
Elliott Hughesb76188f2018-04-03 13:30:18 -0700418 " -w Wipe userdata.\n"
Elliott Hughesb76188f2018-04-03 13:30:18 -0700419 " -s SERIAL Specify a USB device.\n"
420 " -s tcp|udp:HOST[:PORT] Specify a network device.\n"
Elliott Hughes542370d2018-04-19 19:49:44 -0700421 " -S SIZE[K|M|G] Break into sparse files no larger than SIZE.\n"
David Anderson89569642018-11-16 15:53:35 -0800422 " --force Force a flash operation that may be unsafe.\n"
Elliott Hughesb76188f2018-04-03 13:30:18 -0700423 " --slot SLOT Use SLOT; 'all' for both slots, 'other' for\n"
424 " non-current slot (default: current active slot).\n"
425 " --set-active[=SLOT] Sets the active slot before rebooting.\n"
426 " --skip-secondary Don't flash secondary slots in flashall/update.\n"
427 " --skip-reboot Don't reboot device after flashing.\n"
428 " --disable-verity Sets disable-verity when flashing vbmeta.\n"
429 " --disable-verification Sets disable-verification when flashing vbmeta.\n"
Paul Crowley8f7f56e2015-11-27 09:29:37 +0000430#if !defined(_WIN32)
Elliott Hughesb76188f2018-04-03 13:30:18 -0700431 " --wipe-and-use-fbe Enable file-based encryption, wiping userdata.\n"
Paul Crowley8f7f56e2015-11-27 09:29:37 +0000432#endif
Elliott Hughesb76188f2018-04-03 13:30:18 -0700433 // TODO: remove --unbuffered?
434 " --unbuffered Don't buffer input or output.\n"
435 " --verbose, -v Verbose output.\n"
436 " --version Display version.\n"
437 " --help, -h Show this message.\n"
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800438 );
Elliott Hughesd6365a72017-05-08 18:04:49 -0700439 // clang-format off
440 return 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800441}
Paul Crowley8f7f56e2015-11-27 09:29:37 +0000442
Tom Cherrydfd85df2018-09-20 14:45:05 -0700443static std::vector<char> LoadBootableImage(const std::string& kernel, const std::string& ramdisk,
444 const std::string& second_stage) {
445 std::vector<char> kernel_data;
446 if (!ReadFileToVector(kernel, &kernel_data)) {
447 die("cannot load '%s': %s", kernel.c_str(), strerror(errno));
448 }
Tsu Chiang Chuangee520552011-02-25 18:38:53 -0800449
Elliott Hughesfc797672015-04-07 20:12:50 -0700450 // Is this actually a boot image?
Tom Cherrydfd85df2018-09-20 14:45:05 -0700451 if (kernel_data.size() < sizeof(boot_img_hdr_v1)) {
Elliott Hughesaaa3b6b2018-01-18 16:08:24 -0800452 die("cannot load '%s': too short", kernel.c_str());
453 }
Tom Cherrydfd85df2018-09-20 14:45:05 -0700454 if (!memcmp(kernel_data.data(), BOOT_MAGIC, BOOT_MAGIC_SIZE)) {
Elliott Hughes577e8b42018-04-05 16:12:47 -0700455 if (!g_cmdline.empty()) {
Tom Cherrydfd85df2018-09-20 14:45:05 -0700456 bootimg_set_cmdline(reinterpret_cast<boot_img_hdr_v1*>(kernel_data.data()), g_cmdline);
Elliott Hughes577e8b42018-04-05 16:12:47 -0700457 }
Tsu Chiang Chuangee520552011-02-25 18:38:53 -0800458
Elliott Hughes4089d342017-10-27 14:21:12 -0700459 if (!ramdisk.empty()) die("cannot boot a boot.img *and* ramdisk");
Tsu Chiang Chuangee520552011-02-25 18:38:53 -0800460
Tom Cherrydfd85df2018-09-20 14:45:05 -0700461 return kernel_data;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800462 }
463
Tom Cherrydfd85df2018-09-20 14:45:05 -0700464 std::vector<char> ramdisk_data;
Elliott Hughesd6365a72017-05-08 18:04:49 -0700465 if (!ramdisk.empty()) {
Tom Cherrydfd85df2018-09-20 14:45:05 -0700466 if (!ReadFileToVector(ramdisk, &ramdisk_data)) {
467 die("cannot load '%s': %s", ramdisk.c_str(), strerror(errno));
468 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800469 }
470
Tom Cherrydfd85df2018-09-20 14:45:05 -0700471 std::vector<char> second_stage_data;
Elliott Hughesd6365a72017-05-08 18:04:49 -0700472 if (!second_stage.empty()) {
Tom Cherrydfd85df2018-09-20 14:45:05 -0700473 if (!ReadFileToVector(second_stage, &second_stage_data)) {
474 die("cannot load '%s': %s", second_stage.c_str(), strerror(errno));
475 }
Jeremy Compostellaa42adff2014-07-17 17:17:54 +0200476 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800477 fprintf(stderr,"creating boot image...\n");
Elliott Hughesd6365a72017-05-08 18:04:49 -0700478
Tom Cherrydfd85df2018-09-20 14:45:05 -0700479 std::vector<char> out;
480 boot_img_hdr_v1* boot_image_data = mkbootimg(kernel_data, ramdisk_data, second_stage_data,
481 g_base_addr, g_boot_img_hdr, &out);
Tsu Chiang Chuangee520552011-02-25 18:38:53 -0800482
Tom Cherrydfd85df2018-09-20 14:45:05 -0700483 if (!g_cmdline.empty()) bootimg_set_cmdline(boot_image_data, g_cmdline);
484 fprintf(stderr, "creating boot image - %zu bytes\n", out.size());
485
486 return out;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800487}
488
Tom Cherrydfd85df2018-09-20 14:45:05 -0700489static bool UnzipToMemory(ZipArchiveHandle zip, const std::string& entry_name,
490 std::vector<char>* out) {
491 ZipString zip_entry_name(entry_name.c_str());
Elliott Hughesd30ad8a2015-03-18 23:12:44 -0700492 ZipEntry zip_entry;
493 if (FindEntry(zip, zip_entry_name, &zip_entry) != 0) {
Tom Cherrydfd85df2018-09-20 14:45:05 -0700494 fprintf(stderr, "archive does not contain '%s'\n", entry_name.c_str());
495 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800496 }
497
Tom Cherrydfd85df2018-09-20 14:45:05 -0700498 out->resize(zip_entry.uncompressed_length);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800499
Tom Cherrydfd85df2018-09-20 14:45:05 -0700500 fprintf(stderr, "extracting %s (%zu MB) to RAM...\n", entry_name.c_str(),
501 out->size() / 1024 / 1024);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800502
Tom Cherrydfd85df2018-09-20 14:45:05 -0700503 int error = ExtractToMemory(zip, &zip_entry, reinterpret_cast<uint8_t*>(out->data()),
504 out->size());
505 if (error != 0) die("failed to extract '%s': %s", entry_name.c_str(), ErrorCodeString(error));
Alexander Levitskiy8d7ddb32014-05-07 23:31:59 +0000506
Tom Cherrydfd85df2018-09-20 14:45:05 -0700507 return true;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800508}
509
Elliott Hughesa26fbee2015-06-03 15:22:11 -0700510#if defined(_WIN32)
511
512// TODO: move this to somewhere it can be shared.
513
514#include <windows.h>
515
516// Windows' tmpfile(3) requires administrator rights because
517// it creates temporary files in the root directory.
518static FILE* win32_tmpfile() {
519 char temp_path[PATH_MAX];
520 DWORD nchars = GetTempPath(sizeof(temp_path), temp_path);
521 if (nchars == 0 || nchars >= sizeof(temp_path)) {
Elliott Hughes4089d342017-10-27 14:21:12 -0700522 die("GetTempPath failed, error %ld", GetLastError());
Elliott Hughesa26fbee2015-06-03 15:22:11 -0700523 }
524
525 char filename[PATH_MAX];
526 if (GetTempFileName(temp_path, "fastboot", 0, filename) == 0) {
Elliott Hughes4089d342017-10-27 14:21:12 -0700527 die("GetTempFileName failed, error %ld", GetLastError());
Elliott Hughesa26fbee2015-06-03 15:22:11 -0700528 }
529
530 return fopen(filename, "w+bTD");
531}
532
533#define tmpfile win32_tmpfile
534
Paul Crowley8f7f56e2015-11-27 09:29:37 +0000535static std::string make_temporary_directory() {
Elliott Hughes4089d342017-10-27 14:21:12 -0700536 die("make_temporary_directory not supported under Windows, sorry!");
Paul Crowley8f7f56e2015-11-27 09:29:37 +0000537}
538
Elliott Hughes855cdf82018-04-02 14:24:03 -0700539static int make_temporary_fd(const char* /*what*/) {
Elliott Hughesbbfc2812017-04-25 18:33:09 -0700540 // TODO: reimplement to avoid leaking a FILE*.
541 return fileno(tmpfile());
542}
543
Paul Crowley8f7f56e2015-11-27 09:29:37 +0000544#else
545
Elliott Hughesbbfc2812017-04-25 18:33:09 -0700546static std::string make_temporary_template() {
547 const char* tmpdir = getenv("TMPDIR");
548 if (tmpdir == nullptr) tmpdir = P_tmpdir;
549 return std::string(tmpdir) + "/fastboot_userdata_XXXXXX";
550}
551
Paul Crowley8f7f56e2015-11-27 09:29:37 +0000552static std::string make_temporary_directory() {
Elliott Hughesbbfc2812017-04-25 18:33:09 -0700553 std::string result(make_temporary_template());
554 if (mkdtemp(&result[0]) == nullptr) {
Elliott Hughesda1dbd62018-05-21 23:02:26 -0700555 die("unable to create temporary directory with template %s: %s",
556 result.c_str(), strerror(errno));
Paul Crowley8f7f56e2015-11-27 09:29:37 +0000557 }
558 return result;
559}
560
Elliott Hughes855cdf82018-04-02 14:24:03 -0700561static int make_temporary_fd(const char* what) {
Elliott Hughesbbfc2812017-04-25 18:33:09 -0700562 std::string path_template(make_temporary_template());
563 int fd = mkstemp(&path_template[0]);
564 if (fd == -1) {
Elliott Hughesda1dbd62018-05-21 23:02:26 -0700565 die("failed to create temporary file for %s with template %s: %s\n",
566 path_template.c_str(), what, strerror(errno));
Elliott Hughesbbfc2812017-04-25 18:33:09 -0700567 }
568 unlink(path_template.c_str());
569 return fd;
570}
571
Elliott Hughesa26fbee2015-06-03 15:22:11 -0700572#endif
573
Paul Crowley8f7f56e2015-11-27 09:29:37 +0000574static std::string create_fbemarker_tmpdir() {
575 std::string dir = make_temporary_directory();
Paul Crowley8f7f56e2015-11-27 09:29:37 +0000576 std::string marker_file = dir + "/" + convert_fbe_marker_filename;
577 int fd = open(marker_file.c_str(), O_CREAT | O_WRONLY | O_CLOEXEC, 0666);
578 if (fd == -1) {
Elliott Hughes855cdf82018-04-02 14:24:03 -0700579 die("unable to create FBE marker file %s locally: %s",
580 marker_file.c_str(), strerror(errno));
Paul Crowley8f7f56e2015-11-27 09:29:37 +0000581 }
582 close(fd);
583 return dir;
584}
585
586static void delete_fbemarker_tmpdir(const std::string& dir) {
587 std::string marker_file = dir + "/" + convert_fbe_marker_filename;
588 if (unlink(marker_file.c_str()) == -1) {
589 fprintf(stderr, "Unable to delete FBE marker file %s locally: %d, %s\n",
590 marker_file.c_str(), errno, strerror(errno));
591 return;
592 }
593 if (rmdir(dir.c_str()) == -1) {
594 fprintf(stderr, "Unable to delete FBE marker directory %s locally: %d, %s\n",
595 dir.c_str(), errno, strerror(errno));
596 return;
597 }
598}
599
Elliott Hughes45964a82017-05-03 22:43:23 -0700600static int unzip_to_file(ZipArchiveHandle zip, const char* entry_name) {
Elliott Hughes855cdf82018-04-02 14:24:03 -0700601 unique_fd fd(make_temporary_fd(entry_name));
Rom Lemarchand622810c2013-06-28 09:54:59 -0700602
Yusuke Sato07447542015-06-25 14:39:19 -0700603 ZipString zip_entry_name(entry_name);
Elliott Hughesa82c89d2015-03-19 11:44:32 -0700604 ZipEntry zip_entry;
605 if (FindEntry(zip, zip_entry_name, &zip_entry) != 0) {
606 fprintf(stderr, "archive does not contain '%s'\n", entry_name);
David Andersoncf444f32018-08-29 14:15:49 -0700607 errno = ENOENT;
Alexander Levitskiy8d7ddb32014-05-07 23:31:59 +0000608 return -1;
609 }
610
Elliott Hughes23af1122017-11-10 08:42:17 -0800611 fprintf(stderr, "extracting %s (%" PRIu32 " MB) to disk...", entry_name,
Elliott Hughesbbfc2812017-04-25 18:33:09 -0700612 zip_entry.uncompressed_length / 1024 / 1024);
Elliott Hughes23af1122017-11-10 08:42:17 -0800613 double start = now();
Elliott Hughesa82c89d2015-03-19 11:44:32 -0700614 int error = ExtractEntryToFile(zip, &zip_entry, fd);
615 if (error != 0) {
Elliott Hughes23af1122017-11-10 08:42:17 -0800616 die("\nfailed to extract '%s': %s", entry_name, ErrorCodeString(error));
Rom Lemarchand622810c2013-06-28 09:54:59 -0700617 }
618
Elliott Hughes4089d342017-10-27 14:21:12 -0700619 if (lseek(fd, 0, SEEK_SET) != 0) {
Elliott Hughes23af1122017-11-10 08:42:17 -0800620 die("\nlseek on extracted file '%s' failed: %s", entry_name, strerror(errno));
Elliott Hughes4089d342017-10-27 14:21:12 -0700621 }
622
Elliott Hughes23af1122017-11-10 08:42:17 -0800623 fprintf(stderr, " took %.3fs\n", now() - start);
624
Elliott Hughesbbfc2812017-04-25 18:33:09 -0700625 return fd.release();
Rom Lemarchand622810c2013-06-28 09:54:59 -0700626}
627
Tom Cherry4aa60b32018-09-05 15:11:44 -0700628static void CheckRequirement(const std::string& cur_product, const std::string& var,
629 const std::string& product, bool invert,
630 const std::vector<std::string>& options) {
631 Status("Checking '" + var + "'");
Elliott Hughes5620d222018-03-28 08:20:00 -0700632
Tom Cherry4aa60b32018-09-05 15:11:44 -0700633 double start = now();
634
635 if (!product.empty()) {
636 if (product != cur_product) {
637 double split = now();
638 fprintf(stderr, "IGNORE, product is %s required only for %s [%7.3fs]\n",
639 cur_product.c_str(), product.c_str(), (split - start));
640 return;
641 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800642 }
Tom Cherry4aa60b32018-09-05 15:11:44 -0700643
644 std::string var_value;
Tom Cherry9027af02018-09-24 15:48:09 -0700645 if (fb->GetVar(var, &var_value) != fastboot::SUCCESS) {
Tom Cherry4aa60b32018-09-05 15:11:44 -0700646 fprintf(stderr, "FAILED\n\n");
Tom Cherry9027af02018-09-24 15:48:09 -0700647 fprintf(stderr, "Could not getvar for '%s' (%s)\n\n", var.c_str(),
648 fb->Error().c_str());
Tom Cherry4aa60b32018-09-05 15:11:44 -0700649 die("requirements not met!");
650 }
651
652 bool match = false;
653 for (const auto& option : options) {
654 if (option == var_value || (option.back() == '*' &&
655 !var_value.compare(0, option.length() - 1, option, 0,
656 option.length() - 1))) {
657 match = true;
658 break;
659 }
660 }
661
662 if (invert) {
663 match = !match;
664 }
665
666 if (match) {
667 double split = now();
668 fprintf(stderr, "OKAY [%7.3fs]\n", (split - start));
669 return;
670 }
671
672 fprintf(stderr, "FAILED\n\n");
673 fprintf(stderr, "Device %s is '%s'.\n", var.c_str(), var_value.c_str());
674 fprintf(stderr, "Update %s '%s'", invert ? "rejects" : "requires", options[0].c_str());
675 for (auto it = std::next(options.begin()); it != options.end(); ++it) {
676 fprintf(stderr, " or '%s'", it->c_str());
677 }
678 fprintf(stderr, ".\n\n");
679 die("requirements not met!");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800680}
681
Tom Cherry4aa60b32018-09-05 15:11:44 -0700682bool ParseRequirementLine(const std::string& line, std::string* name, std::string* product,
683 bool* invert, std::vector<std::string>* options) {
Elliott Hughes5620d222018-03-28 08:20:00 -0700684 // "require product=alpha|beta|gamma"
685 // "require version-bootloader=1234"
686 // "require-for-product:gamma version-bootloader=istanbul|constantinople"
687 // "require partition-exists=vendor"
Tom Cherry4aa60b32018-09-05 15:11:44 -0700688 *product = "";
689 *invert = false;
Elliott Hughes5620d222018-03-28 08:20:00 -0700690
Tom Cherry4aa60b32018-09-05 15:11:44 -0700691 auto require_reject_regex = std::regex{"(require\\s+|reject\\s+)?\\s*(\\S+)\\s*=\\s*(.*)"};
692 auto require_product_regex =
693 std::regex{"require-for-product:\\s*(\\S+)\\s+(\\S+)\\s*=\\s*(.*)"};
694 std::smatch match_results;
695
696 if (std::regex_match(line, match_results, require_reject_regex)) {
697 *invert = Trim(match_results[1]) == "reject";
698 } else if (std::regex_match(line, match_results, require_product_regex)) {
699 *product = match_results[1];
700 } else {
701 return false;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800702 }
703
Tom Cherry4aa60b32018-09-05 15:11:44 -0700704 *name = match_results[2];
Elliott Hughes253c18d2015-03-18 22:47:09 -0700705 // Work around an unfortunate name mismatch.
Tom Cherry4aa60b32018-09-05 15:11:44 -0700706 if (*name == "board") {
707 *name = "product";
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800708 }
709
Tom Cherry4aa60b32018-09-05 15:11:44 -0700710 auto raw_options = Split(match_results[3], "|");
711 for (const auto& option : raw_options) {
712 auto trimmed_option = Trim(option);
713 options->emplace_back(trimmed_option);
714 }
715
716 return true;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800717}
718
Tom Cherry4aa60b32018-09-05 15:11:44 -0700719// "require partition-exists=x" is a special case, added because of the trouble we had when
720// Pixel 2 shipped with new partitions and users used old versions of fastboot to flash them,
721// missing out new partitions. A device with new partitions can use "partition-exists" to
722// override the fields `optional_if_no_image` in the `images` array.
723static void HandlePartitionExists(const std::vector<std::string>& options) {
724 const std::string& partition_name = options[0];
725 std::string has_slot;
Tom Cherry9027af02018-09-24 15:48:09 -0700726 if (fb->GetVar("has-slot:" + partition_name, &has_slot) != fastboot::SUCCESS ||
Tom Cherry4aa60b32018-09-05 15:11:44 -0700727 (has_slot != "yes" && has_slot != "no")) {
728 die("device doesn't have required partition %s!", partition_name.c_str());
729 }
730 bool known_partition = false;
731 for (size_t i = 0; i < arraysize(images); ++i) {
732 if (images[i].nickname && images[i].nickname == partition_name) {
733 images[i].optional_if_no_image = false;
734 known_partition = true;
735 }
736 }
737 if (!known_partition) {
738 die("device requires partition %s which is not known to this version of fastboot",
739 partition_name.c_str());
740 }
741}
742
743static void CheckRequirements(const std::string& data) {
744 std::string cur_product;
Tom Cherry9027af02018-09-24 15:48:09 -0700745 if (fb->GetVar("product", &cur_product) != fastboot::SUCCESS) {
746 fprintf(stderr, "getvar:product FAILED (%s)\n", fb->Error().c_str());
Tom Cherry4aa60b32018-09-05 15:11:44 -0700747 }
748
749 auto lines = Split(data, "\n");
750 for (const auto& line : lines) {
751 if (line.empty()) {
752 continue;
753 }
754
755 std::string name;
756 std::string product;
757 bool invert;
758 std::vector<std::string> options;
759
760 if (!ParseRequirementLine(line, &name, &product, &invert, &options)) {
761 fprintf(stderr, "android-info.txt syntax error: %s\n", line.c_str());
762 continue;
763 }
764 if (name == "partition-exists") {
765 HandlePartitionExists(options);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800766 } else {
Tom Cherry4aa60b32018-09-05 15:11:44 -0700767 CheckRequirement(cur_product, name, product, invert, options);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800768 }
769 }
770}
771
Tom Cherry9027af02018-09-24 15:48:09 -0700772static void DisplayVarOrError(const std::string& label, const std::string& var) {
773 std::string value;
774
775 if (fb->GetVar(var, &value) != fastboot::SUCCESS) {
776 Status("getvar:" + var);
777 fprintf(stderr, "FAILED (%s)\n", fb->Error().c_str());
778 return;
779 }
780 fprintf(stderr, "%s: %s\n", label.c_str(), value.c_str());
781}
782
783static void DumpInfo() {
784 fprintf(stderr, "--------------------------------------------\n");
785 DisplayVarOrError("Bootloader Version...", "version-bootloader");
786 DisplayVarOrError("Baseband Version.....", "version-baseband");
787 DisplayVarOrError("Serial Number........", "serialno");
788 fprintf(stderr, "--------------------------------------------\n");
789
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -0800790}
791
Tao Bao41cf35f2018-04-24 10:54:21 -0700792static struct sparse_file** load_sparse_files(int fd, int64_t max_size) {
Mohamad Ayyash80cc1f62015-03-31 12:09:29 -0700793 struct sparse_file* s = sparse_file_import_auto(fd, false, true);
Elliott Hughes4089d342017-10-27 14:21:12 -0700794 if (!s) die("cannot sparse read file");
Colin Crossf8387882012-05-24 17:18:41 -0700795
Tao Bao41cf35f2018-04-24 10:54:21 -0700796 if (max_size <= 0 || max_size > std::numeric_limits<uint32_t>::max()) {
797 die("invalid max size %" PRId64, max_size);
798 }
799
Elliott Hughesfc797672015-04-07 20:12:50 -0700800 int files = sparse_file_resparse(s, max_size, nullptr, 0);
Elliott Hughes4089d342017-10-27 14:21:12 -0700801 if (files < 0) die("Failed to resparse");
Colin Crossf8387882012-05-24 17:18:41 -0700802
Elliott Hughes253c18d2015-03-18 22:47:09 -0700803 sparse_file** out_s = reinterpret_cast<sparse_file**>(calloc(sizeof(struct sparse_file *), files + 1));
Elliott Hughes4089d342017-10-27 14:21:12 -0700804 if (!out_s) die("Failed to allocate sparse file array");
Colin Crossf8387882012-05-24 17:18:41 -0700805
806 files = sparse_file_resparse(s, max_size, out_s, files);
Elliott Hughes4089d342017-10-27 14:21:12 -0700807 if (files < 0) die("Failed to resparse");
Colin Crossf8387882012-05-24 17:18:41 -0700808
809 return out_s;
810}
811
Aaron Wisnerdb511202018-06-26 15:38:35 -0500812static int64_t get_target_sparse_limit() {
Elliott Hughes2fd45a92015-10-30 11:49:47 -0700813 std::string max_download_size;
Tom Cherry9027af02018-09-24 15:48:09 -0700814 if (fb->GetVar("max-download-size", &max_download_size) != fastboot::SUCCESS ||
Elliott Hughes855cdf82018-04-02 14:24:03 -0700815 max_download_size.empty()) {
816 verbose("target didn't report max-download-size");
Elliott Hughes2fd45a92015-10-30 11:49:47 -0700817 return 0;
Colin Crossf8387882012-05-24 17:18:41 -0700818 }
819
Elliott Hughes77c0e662015-11-02 15:51:12 -0800820 // Some bootloaders (angler, for example) send spurious whitespace too.
821 max_download_size = android::base::Trim(max_download_size);
822
Elliott Hughes2fd45a92015-10-30 11:49:47 -0700823 uint64_t limit;
Elliott Hughesda46b392016-10-11 17:09:00 -0700824 if (!android::base::ParseUint(max_download_size, &limit)) {
Elliott Hughes3ab05862015-11-02 09:01:53 -0800825 fprintf(stderr, "couldn't parse max-download-size '%s'\n", max_download_size.c_str());
Elliott Hughes2fd45a92015-10-30 11:49:47 -0700826 return 0;
827 }
Elliott Hughes855cdf82018-04-02 14:24:03 -0700828 if (limit > 0) verbose("target reported max download size of %" PRId64 " bytes", limit);
Colin Crossf8387882012-05-24 17:18:41 -0700829 return limit;
830}
831
Aaron Wisnerdb511202018-06-26 15:38:35 -0500832static int64_t get_sparse_limit(int64_t size) {
Elliott Hughes542370d2018-04-19 19:49:44 -0700833 int64_t limit = sparse_limit;
834 if (limit == 0) {
835 // Unlimited, so see what the target device's limit is.
836 // TODO: shouldn't we apply this limit even if you've used -S?
Colin Crossf8387882012-05-24 17:18:41 -0700837 if (target_sparse_limit == -1) {
Aaron Wisnerdb511202018-06-26 15:38:35 -0500838 target_sparse_limit = get_target_sparse_limit();
Colin Crossf8387882012-05-24 17:18:41 -0700839 }
840 if (target_sparse_limit > 0) {
841 limit = target_sparse_limit;
842 } else {
Colin Cross0bbfb392012-07-24 18:05:21 -0700843 return 0;
Colin Crossf8387882012-05-24 17:18:41 -0700844 }
845 }
846
847 if (size > limit) {
Chris Fries6a999712017-04-04 09:52:47 -0500848 return std::min(limit, RESPARSE_LIMIT);
Colin Crossf8387882012-05-24 17:18:41 -0700849 }
850
851 return 0;
852}
853
Aaron Wisnerdb511202018-06-26 15:38:35 -0500854static bool load_buf_fd(int fd, struct fastboot_buffer* buf) {
Elliott Hughesfc797672015-04-07 20:12:50 -0700855 int64_t sz = get_file_size(fd);
856 if (sz == -1) {
Elliott Hughes53ec4952016-05-11 12:39:27 -0700857 return false;
Rom Lemarchand622810c2013-06-28 09:54:59 -0700858 }
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -0700859
David Anderson32e376f2018-08-16 13:43:11 -0700860 if (sparse_file* s = sparse_file_import_auto(fd, false, false)) {
861 buf->image_size = sparse_file_len(s, false, false);
862 sparse_file_destroy(s);
863 } else {
864 buf->image_size = sz;
865 }
866
Elliott Hughesa56a7292018-10-26 10:34:53 -0700867 lseek(fd, 0, SEEK_SET);
Aaron Wisnerdb511202018-06-26 15:38:35 -0500868 int64_t limit = get_sparse_limit(sz);
Colin Crossf8387882012-05-24 17:18:41 -0700869 if (limit) {
Elliott Hughesfc797672015-04-07 20:12:50 -0700870 sparse_file** s = load_sparse_files(fd, limit);
871 if (s == nullptr) {
Elliott Hughes53ec4952016-05-11 12:39:27 -0700872 return false;
Colin Crossf8387882012-05-24 17:18:41 -0700873 }
Rom Lemarchand622810c2013-06-28 09:54:59 -0700874 buf->type = FB_BUFFER_SPARSE;
875 buf->data = s;
Colin Crossf8387882012-05-24 17:18:41 -0700876 } else {
Chris Fries0ea946c2017-04-12 10:25:57 -0500877 buf->type = FB_BUFFER_FD;
878 buf->data = nullptr;
879 buf->fd = fd;
Alexander Levitskiy8d7ddb32014-05-07 23:31:59 +0000880 buf->sz = sz;
Colin Crossf8387882012-05-24 17:18:41 -0700881 }
Rom Lemarchand622810c2013-06-28 09:54:59 -0700882
Elliott Hughes53ec4952016-05-11 12:39:27 -0700883 return true;
Rom Lemarchand622810c2013-06-28 09:54:59 -0700884}
885
Aaron Wisnerdb511202018-06-26 15:38:35 -0500886static bool load_buf(const char* fname, struct fastboot_buffer* buf) {
Chris Fries0ea946c2017-04-12 10:25:57 -0500887 unique_fd fd(TEMP_FAILURE_RETRY(open(fname, O_RDONLY | O_BINARY)));
888
Elliott Hughes53ec4952016-05-11 12:39:27 -0700889 if (fd == -1) {
890 return false;
Rom Lemarchand622810c2013-06-28 09:54:59 -0700891 }
Chris Fries0ea946c2017-04-12 10:25:57 -0500892
893 struct stat s;
894 if (fstat(fd, &s)) {
895 return false;
896 }
897 if (!S_ISREG(s.st_mode)) {
898 errno = S_ISDIR(s.st_mode) ? EISDIR : EINVAL;
899 return false;
900 }
901
Aaron Wisnerdb511202018-06-26 15:38:35 -0500902 return load_buf_fd(fd.release(), buf);
Rom Lemarchand622810c2013-06-28 09:54:59 -0700903}
904
David Zeuthenb6ea4352017-08-07 14:29:26 -0400905static void rewrite_vbmeta_buffer(struct fastboot_buffer* buf) {
906 // Buffer needs to be at least the size of the VBMeta struct which
907 // is 256 bytes.
908 if (buf->sz < 256) {
909 return;
910 }
911
Elliott Hughes855cdf82018-04-02 14:24:03 -0700912 int fd = make_temporary_fd("vbmeta rewriting");
David Zeuthenb6ea4352017-08-07 14:29:26 -0400913
914 std::string data;
915 if (!android::base::ReadFdToString(buf->fd, &data)) {
916 die("Failed reading from vbmeta");
917 }
918
919 // There's a 32-bit big endian |flags| field at offset 120 where
920 // bit 0 corresponds to disable-verity and bit 1 corresponds to
921 // disable-verification.
922 //
923 // See external/avb/libavb/avb_vbmeta_image.h for the layout of
924 // the VBMeta struct.
925 if (g_disable_verity) {
926 data[123] |= 0x01;
927 }
928 if (g_disable_verification) {
929 data[123] |= 0x02;
930 }
931
932 if (!android::base::WriteStringToFd(data, fd)) {
933 die("Failed writing to modified vbmeta");
934 }
935 close(buf->fd);
936 buf->fd = fd;
937 lseek(fd, 0, SEEK_SET);
938}
939
Elliott Hughes5620d222018-03-28 08:20:00 -0700940static void flash_buf(const std::string& partition, struct fastboot_buffer *buf)
Rom Lemarchand622810c2013-06-28 09:54:59 -0700941{
Elliott Hughes253c18d2015-03-18 22:47:09 -0700942 sparse_file** s;
Rom Lemarchand622810c2013-06-28 09:54:59 -0700943
David Zeuthenb6ea4352017-08-07 14:29:26 -0400944 // Rewrite vbmeta if that's what we're flashing and modification has been requested.
945 if ((g_disable_verity || g_disable_verification) &&
Elliott Hughes5620d222018-03-28 08:20:00 -0700946 (partition == "vbmeta" || partition == "vbmeta_a" || partition == "vbmeta_b")) {
David Zeuthenb6ea4352017-08-07 14:29:26 -0400947 rewrite_vbmeta_buffer(buf);
948 }
949
Rom Lemarchand622810c2013-06-28 09:54:59 -0700950 switch (buf->type) {
Josh Gao9da9ac52016-01-19 14:50:18 -0800951 case FB_BUFFER_SPARSE: {
952 std::vector<std::pair<sparse_file*, int64_t>> sparse_files;
Elliott Hughes253c18d2015-03-18 22:47:09 -0700953 s = reinterpret_cast<sparse_file**>(buf->data);
Rom Lemarchand622810c2013-06-28 09:54:59 -0700954 while (*s) {
Elliott Hughesfc797672015-04-07 20:12:50 -0700955 int64_t sz = sparse_file_len(*s, true, false);
Josh Gao9da9ac52016-01-19 14:50:18 -0800956 sparse_files.emplace_back(*s, sz);
957 ++s;
958 }
959
960 for (size_t i = 0; i < sparse_files.size(); ++i) {
961 const auto& pair = sparse_files[i];
Tom Cherry9027af02018-09-24 15:48:09 -0700962 fb->FlashPartition(partition, pair.first, pair.second, i + 1, sparse_files.size());
Rom Lemarchand622810c2013-06-28 09:54:59 -0700963 }
964 break;
Josh Gao9da9ac52016-01-19 14:50:18 -0800965 }
Chris Fries0ea946c2017-04-12 10:25:57 -0500966 case FB_BUFFER_FD:
Tom Cherry9027af02018-09-24 15:48:09 -0700967 fb->FlashPartition(partition, buf->fd, buf->sz);
Rom Lemarchand622810c2013-06-28 09:54:59 -0700968 break;
969 default:
970 die("unknown buffer type: %d", buf->type);
971 }
972}
973
Aaron Wisnerdb511202018-06-26 15:38:35 -0500974static std::string get_current_slot() {
Daniel Rosenberg80919472016-06-30 19:25:31 -0700975 std::string current_slot;
Tom Cherry9027af02018-09-24 15:48:09 -0700976 if (fb->GetVar("current-slot", &current_slot) != fastboot::SUCCESS) return "";
Elliott Hughes42b18a52018-04-10 15:32:21 -0700977 return current_slot;
Daniel Rosenberg80919472016-06-30 19:25:31 -0700978}
979
Aaron Wisnerdb511202018-06-26 15:38:35 -0500980static int get_slot_count() {
Daniel Rosenberg80919472016-06-30 19:25:31 -0700981 std::string var;
Elliott Hughes42b18a52018-04-10 15:32:21 -0700982 int count = 0;
Tom Cherry9027af02018-09-24 15:48:09 -0700983 if (fb->GetVar("slot-count", &var) != fastboot::SUCCESS ||
984 !android::base::ParseInt(var, &count)) {
Elliott Hughes42b18a52018-04-10 15:32:21 -0700985 return 0;
Daniel Rosenberg80919472016-06-30 19:25:31 -0700986 }
Daniel Rosenberg80919472016-06-30 19:25:31 -0700987 return count;
988}
989
Aaron Wisnerdb511202018-06-26 15:38:35 -0500990static bool supports_AB() {
991 return get_slot_count() >= 2;
Alex Lightbb9b8a52016-06-29 09:26:44 -0700992}
993
Daniel Rosenbergad3d3c12016-06-27 23:03:48 -0700994// Given a current slot, this returns what the 'other' slot is.
Daniel Rosenberg80919472016-06-30 19:25:31 -0700995static std::string get_other_slot(const std::string& current_slot, int count) {
996 if (count == 0) return "";
Daniel Rosenbergad3d3c12016-06-27 23:03:48 -0700997
Daniel Rosenberg80919472016-06-30 19:25:31 -0700998 char next = (current_slot[0] - 'a' + 1)%count + 'a';
999 return std::string(1, next);
1000}
1001
Aaron Wisnerdb511202018-06-26 15:38:35 -05001002static std::string get_other_slot(const std::string& current_slot) {
1003 return get_other_slot(current_slot, get_slot_count());
Daniel Rosenberg80919472016-06-30 19:25:31 -07001004}
1005
Aaron Wisnerdb511202018-06-26 15:38:35 -05001006static std::string get_other_slot(int count) {
1007 return get_other_slot(get_current_slot(), count);
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001008}
1009
Aaron Wisnerdb511202018-06-26 15:38:35 -05001010static std::string get_other_slot() {
1011 return get_other_slot(get_current_slot(), get_slot_count());
Alex Lightbb9b8a52016-06-29 09:26:44 -07001012}
1013
Aaron Wisnerdb511202018-06-26 15:38:35 -05001014static std::string verify_slot(const std::string& slot_name, bool allow_all) {
Daniel Rosenberg80919472016-06-30 19:25:31 -07001015 std::string slot = slot_name;
Daniel Rosenberg80919472016-06-30 19:25:31 -07001016 if (slot == "all") {
Daniel Rosenberg9b432052015-11-25 15:17:10 -08001017 if (allow_all) {
1018 return "all";
1019 } else {
Aaron Wisnerdb511202018-06-26 15:38:35 -05001020 int count = get_slot_count();
Daniel Rosenberg80919472016-06-30 19:25:31 -07001021 if (count > 0) {
1022 return "a";
Daniel Rosenberg9b432052015-11-25 15:17:10 -08001023 } else {
Elliott Hughes4089d342017-10-27 14:21:12 -07001024 die("No known slots");
Daniel Rosenberg9b432052015-11-25 15:17:10 -08001025 }
1026 }
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001027 }
Daniel Rosenbergc1743ba2016-01-05 16:54:40 -08001028
Aaron Wisnerdb511202018-06-26 15:38:35 -05001029 int count = get_slot_count();
Elliott Hughes4089d342017-10-27 14:21:12 -07001030 if (count == 0) die("Device does not support slots");
Daniel Rosenbergc1743ba2016-01-05 16:54:40 -08001031
Daniel Rosenberg80919472016-06-30 19:25:31 -07001032 if (slot == "other") {
Aaron Wisnerdb511202018-06-26 15:38:35 -05001033 std::string other = get_other_slot( count);
Daniel Rosenbergad3d3c12016-06-27 23:03:48 -07001034 if (other == "") {
Elliott Hughes4089d342017-10-27 14:21:12 -07001035 die("No known slots");
Daniel Rosenbergc1743ba2016-01-05 16:54:40 -08001036 }
Daniel Rosenbergad3d3c12016-06-27 23:03:48 -07001037 return other;
Daniel Rosenbergc1743ba2016-01-05 16:54:40 -08001038 }
1039
Daniel Rosenberg80919472016-06-30 19:25:31 -07001040 if (slot.size() == 1 && (slot[0]-'a' >= 0 && slot[0]-'a' < count)) return slot;
1041
1042 fprintf(stderr, "Slot %s does not exist. supported slots are:\n", slot.c_str());
1043 for (int i=0; i<count; i++) {
1044 fprintf(stderr, "%c\n", (char)(i + 'a'));
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001045 }
Daniel Rosenberg80919472016-06-30 19:25:31 -07001046
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001047 exit(1);
1048}
1049
Aaron Wisnerdb511202018-06-26 15:38:35 -05001050static std::string verify_slot(const std::string& slot) {
1051 return verify_slot(slot, true);
Daniel Rosenberg9b432052015-11-25 15:17:10 -08001052}
1053
Aaron Wisnerdb511202018-06-26 15:38:35 -05001054static void do_for_partition(const std::string& part, const std::string& slot,
Chih-Hung Hsieh8f7b9e32016-07-27 16:25:51 -07001055 const std::function<void(const std::string&)>& func, bool force_slot) {
Daniel Rosenberga7974792015-11-11 16:13:13 -08001056 std::string has_slot;
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001057 std::string current_slot;
1058
Tom Cherry9027af02018-09-24 15:48:09 -07001059 if (fb->GetVar("has-slot:" + part, &has_slot) != fastboot::SUCCESS) {
Daniel Rosenberga7974792015-11-11 16:13:13 -08001060 /* If has-slot is not supported, the answer is no. */
1061 has_slot = "no";
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001062 }
Daniel Rosenberga7974792015-11-11 16:13:13 -08001063 if (has_slot == "yes") {
Daniel Rosenberg80919472016-06-30 19:25:31 -07001064 if (slot == "") {
Aaron Wisnerdb511202018-06-26 15:38:35 -05001065 current_slot = get_current_slot();
Daniel Rosenberg80919472016-06-30 19:25:31 -07001066 if (current_slot == "") {
Elliott Hughes4089d342017-10-27 14:21:12 -07001067 die("Failed to identify current slot");
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001068 }
Daniel Rosenberg80919472016-06-30 19:25:31 -07001069 func(part + "_" + current_slot);
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001070 } else {
Daniel Rosenberg80919472016-06-30 19:25:31 -07001071 func(part + '_' + slot);
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001072 }
1073 } else {
Daniel Rosenberg80919472016-06-30 19:25:31 -07001074 if (force_slot && slot != "") {
David Pursell0b156632015-10-30 11:22:01 -07001075 fprintf(stderr, "Warning: %s does not support slots, and slot %s was requested.\n",
Daniel Rosenberg80919472016-06-30 19:25:31 -07001076 part.c_str(), slot.c_str());
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001077 }
1078 func(part);
1079 }
1080}
1081
David Pursell0b156632015-10-30 11:22:01 -07001082/* This function will find the real partition name given a base name, and a slot. If slot is NULL or
1083 * empty, it will use the current slot. If slot is "all", it will return a list of all possible
1084 * partition names. If force_slot is true, it will fail if a slot is specified, and the given
1085 * partition does not support slots.
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001086 */
Aaron Wisnerdb511202018-06-26 15:38:35 -05001087static void do_for_partitions(const std::string& part, const std::string& slot,
Chih-Hung Hsieh8f7b9e32016-07-27 16:25:51 -07001088 const std::function<void(const std::string&)>& func, bool force_slot) {
Daniel Rosenberga7974792015-11-11 16:13:13 -08001089 std::string has_slot;
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001090
Daniel Rosenberg80919472016-06-30 19:25:31 -07001091 if (slot == "all") {
Tom Cherry9027af02018-09-24 15:48:09 -07001092 if (fb->GetVar("has-slot:" + part, &has_slot) != fastboot::SUCCESS) {
Elliott Hughes4089d342017-10-27 14:21:12 -07001093 die("Could not check if partition %s has slot %s", part.c_str(), slot.c_str());
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001094 }
Daniel Rosenberga7974792015-11-11 16:13:13 -08001095 if (has_slot == "yes") {
Aaron Wisnerdb511202018-06-26 15:38:35 -05001096 for (int i=0; i < get_slot_count(); i++) {
1097 do_for_partition(part, std::string(1, (char)(i + 'a')), func, force_slot);
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001098 }
1099 } else {
Aaron Wisnerdb511202018-06-26 15:38:35 -05001100 do_for_partition(part, "", func, force_slot);
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001101 }
1102 } else {
Aaron Wisnerdb511202018-06-26 15:38:35 -05001103 do_for_partition(part, slot, func, force_slot);
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001104 }
1105}
1106
David Anderson629e51c2018-10-25 12:51:25 -07001107static bool is_logical(const std::string& partition) {
1108 std::string value;
1109 return fb->GetVar("is-logical:" + partition, &value) == fastboot::SUCCESS && value == "yes";
1110}
1111
David Anderson0c732342018-11-28 17:10:42 -08001112static bool is_retrofit_device() {
1113 std::string value;
1114 if (fb->GetVar("super-partition-name", &value) != fastboot::SUCCESS) {
1115 return false;
1116 }
1117 return android::base::StartsWith(value, "system_");
1118}
1119
Aaron Wisnerdb511202018-06-26 15:38:35 -05001120static void do_flash(const char* pname, const char* fname) {
Rom Lemarchand622810c2013-06-28 09:54:59 -07001121 struct fastboot_buffer buf;
1122
Aaron Wisnerdb511202018-06-26 15:38:35 -05001123 if (!load_buf(fname, &buf)) {
Elliott Hughes53ec4952016-05-11 12:39:27 -07001124 die("cannot load '%s': %s", fname, strerror(errno));
Rom Lemarchand622810c2013-06-28 09:54:59 -07001125 }
David Anderson629e51c2018-10-25 12:51:25 -07001126 if (is_logical(pname)) {
1127 fb->ResizePartition(pname, std::to_string(buf.image_size));
1128 }
Rom Lemarchand622810c2013-06-28 09:54:59 -07001129 flash_buf(pname, &buf);
Colin Crossf8387882012-05-24 17:18:41 -07001130}
1131
Daniel Rosenberg13454092016-06-27 19:43:11 -07001132// Sets slot_override as the active slot. If slot_override is blank,
1133// set current slot as active instead. This clears slot-unbootable.
Aaron Wisnerdb511202018-06-26 15:38:35 -05001134static void set_active(const std::string& slot_override) {
1135 if (!supports_AB()) return;
Elliott Hughes42b18a52018-04-10 15:32:21 -07001136
Daniel Rosenberg80919472016-06-30 19:25:31 -07001137 if (slot_override != "") {
Tom Cherry9027af02018-09-24 15:48:09 -07001138 fb->SetActive(slot_override);
Daniel Rosenberg13454092016-06-27 19:43:11 -07001139 } else {
Aaron Wisnerdb511202018-06-26 15:38:35 -05001140 std::string current_slot = get_current_slot();
Daniel Rosenberg80919472016-06-30 19:25:31 -07001141 if (current_slot != "") {
Tom Cherry9027af02018-09-24 15:48:09 -07001142 fb->SetActive(current_slot);
Daniel Rosenberg13454092016-06-27 19:43:11 -07001143 }
1144 }
1145}
1146
David Anderson32e376f2018-08-16 13:43:11 -07001147static bool is_userspace_fastboot() {
1148 std::string value;
Tom Cherry9027af02018-09-24 15:48:09 -07001149 return fb->GetVar("is-userspace", &value) == fastboot::SUCCESS && value == "yes";
David Anderson32e376f2018-08-16 13:43:11 -07001150}
1151
David Anderson1d887432018-08-27 16:47:32 -07001152static void reboot_to_userspace_fastboot() {
Tom Cherry9027af02018-09-24 15:48:09 -07001153 fb->RebootTo("fastboot");
1154
1155 auto* old_transport = fb->set_transport(nullptr);
1156 delete old_transport;
David Anderson1d887432018-08-27 16:47:32 -07001157
1158 // Give the current connection time to close.
1159 std::this_thread::sleep_for(std::chrono::milliseconds(1000));
1160
Tom Cherry9027af02018-09-24 15:48:09 -07001161 fb->set_transport(open_device());
David Anderson11d6d272018-12-07 16:39:07 -08001162
1163 if (!is_userspace_fastboot()) {
1164 die("Failed to boot into userspace fastboot; one or more components might be unbootable.");
1165 }
David Anderson1d887432018-08-27 16:47:32 -07001166}
1167
David Andersoncf444f32018-08-29 14:15:49 -07001168class ImageSource {
1169 public:
Tom Cherrydfd85df2018-09-20 14:45:05 -07001170 virtual bool ReadFile(const std::string& name, std::vector<char>* out) const = 0;
David Andersoncf444f32018-08-29 14:15:49 -07001171 virtual int OpenFile(const std::string& name) const = 0;
1172};
David Anderson32e376f2018-08-16 13:43:11 -07001173
David Andersoncf444f32018-08-29 14:15:49 -07001174class FlashAllTool {
1175 public:
1176 FlashAllTool(const ImageSource& source, const std::string& slot_override, bool skip_secondary, bool wipe);
David Anderson32e376f2018-08-16 13:43:11 -07001177
David Andersoncf444f32018-08-29 14:15:49 -07001178 void Flash();
David Anderson32e376f2018-08-16 13:43:11 -07001179
David Andersoncf444f32018-08-29 14:15:49 -07001180 private:
1181 void CheckRequirements();
1182 void DetermineSecondarySlot();
1183 void CollectImages();
1184 void FlashImages(const std::vector<std::pair<const Image*, std::string>>& images);
1185 void FlashImage(const Image& image, const std::string& slot, fastboot_buffer* buf);
1186 void UpdateSuperPartition();
David Anderson32e376f2018-08-16 13:43:11 -07001187
David Andersoncf444f32018-08-29 14:15:49 -07001188 const ImageSource& source_;
1189 std::string slot_override_;
1190 bool skip_secondary_;
1191 bool wipe_;
1192 std::string secondary_slot_;
1193 std::vector<std::pair<const Image*, std::string>> boot_images_;
1194 std::vector<std::pair<const Image*, std::string>> os_images_;
1195};
1196
1197FlashAllTool::FlashAllTool(const ImageSource& source, const std::string& slot_override, bool skip_secondary, bool wipe)
1198 : source_(source),
1199 slot_override_(slot_override),
1200 skip_secondary_(skip_secondary),
1201 wipe_(wipe)
1202{
David Anderson32e376f2018-08-16 13:43:11 -07001203}
1204
David Andersoncf444f32018-08-29 14:15:49 -07001205void FlashAllTool::Flash() {
Tom Cherry9027af02018-09-24 15:48:09 -07001206 DumpInfo();
David Andersoncf444f32018-08-29 14:15:49 -07001207 CheckRequirements();
David Anderson96a9fd42018-11-05 15:21:44 -08001208
1209 // Change the slot first, so we boot into the correct recovery image when
1210 // using fastbootd.
1211 if (slot_override_ == "all") {
1212 set_active("a");
1213 } else {
1214 set_active(slot_override_);
1215 }
1216
David Andersoncf444f32018-08-29 14:15:49 -07001217 DetermineSecondarySlot();
1218 CollectImages();
David Anderson32e376f2018-08-16 13:43:11 -07001219
David Anderson95d40932018-08-28 12:14:33 -07001220 // First flash boot partitions. We allow this to happen either in userspace
1221 // or in bootloader fastboot.
David Andersoncf444f32018-08-29 14:15:49 -07001222 FlashImages(boot_images_);
David Anderson95d40932018-08-28 12:14:33 -07001223
1224 // Sync the super partition. This will reboot to userspace fastboot if needed.
David Andersoncf444f32018-08-29 14:15:49 -07001225 UpdateSuperPartition();
David Anderson95d40932018-08-28 12:14:33 -07001226
1227 // Resize any logical partition to 0, so each partition is reset to 0
1228 // extents, and will achieve more optimal allocation.
David Andersoncf444f32018-08-29 14:15:49 -07001229 for (const auto& [image, slot] : os_images_) {
David Anderson32e376f2018-08-16 13:43:11 -07001230 auto resize_partition = [](const std::string& partition) -> void {
1231 if (is_logical(partition)) {
Tom Cherry9027af02018-09-24 15:48:09 -07001232 fb->ResizePartition(partition, "0");
David Anderson32e376f2018-08-16 13:43:11 -07001233 }
1234 };
David Anderson95d40932018-08-28 12:14:33 -07001235 do_for_partitions(image->part_name, slot, resize_partition, false);
David Anderson32e376f2018-08-16 13:43:11 -07001236 }
1237
David Anderson95d40932018-08-28 12:14:33 -07001238 // Flash OS images, resizing logical partitions as needed.
David Andersoncf444f32018-08-29 14:15:49 -07001239 FlashImages(os_images_);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001240}
1241
David Andersoncf444f32018-08-29 14:15:49 -07001242void FlashAllTool::CheckRequirements() {
Tom Cherrydfd85df2018-09-20 14:45:05 -07001243 std::vector<char> contents;
1244 if (!source_.ReadFile("android-info.txt", &contents)) {
David Andersoncf444f32018-08-29 14:15:49 -07001245 die("could not read android-info.txt");
1246 }
Tom Cherry4aa60b32018-09-05 15:11:44 -07001247 ::CheckRequirements({contents.data(), contents.size()});
David Andersoncf444f32018-08-29 14:15:49 -07001248}
1249
1250void FlashAllTool::DetermineSecondarySlot() {
1251 if (skip_secondary_) {
1252 return;
1253 }
David Anderson96a9fd42018-11-05 15:21:44 -08001254 if (slot_override_ != "" && slot_override_ != "all") {
David Andersoncf444f32018-08-29 14:15:49 -07001255 secondary_slot_ = get_other_slot(slot_override_);
1256 } else {
1257 secondary_slot_ = get_other_slot();
1258 }
1259 if (secondary_slot_ == "") {
1260 if (supports_AB()) {
1261 fprintf(stderr, "Warning: Could not determine slot for secondary images. Ignoring.\n");
1262 }
1263 skip_secondary_ = true;
1264 }
1265}
1266
1267void FlashAllTool::CollectImages() {
1268 for (size_t i = 0; i < arraysize(images); ++i) {
1269 std::string slot = slot_override_;
1270 if (images[i].IsSecondary()) {
1271 if (skip_secondary_) {
1272 continue;
1273 }
1274 slot = secondary_slot_;
1275 }
1276 if (images[i].type == ImageType::BootCritical) {
1277 boot_images_.emplace_back(&images[i], slot);
1278 } else if (images[i].type == ImageType::Normal) {
1279 os_images_.emplace_back(&images[i], slot);
1280 }
1281 }
1282}
1283
1284void FlashAllTool::FlashImages(const std::vector<std::pair<const Image*, std::string>>& images) {
1285 for (const auto& [image, slot] : images) {
1286 fastboot_buffer buf;
1287 int fd = source_.OpenFile(image->img_name);
1288 if (fd < 0 || !load_buf_fd(fd, &buf)) {
1289 if (image->optional_if_no_image) {
1290 continue;
1291 }
1292 die("could not load '%s': %s", image->img_name, strerror(errno));
1293 }
1294 FlashImage(*image, slot, &buf);
1295 }
1296}
1297
1298void FlashAllTool::FlashImage(const Image& image, const std::string& slot, fastboot_buffer* buf) {
1299 auto flash = [&, this](const std::string& partition_name) {
Tom Cherrydfd85df2018-09-20 14:45:05 -07001300 std::vector<char> signature_data;
1301 if (source_.ReadFile(image.sig_name, &signature_data)) {
Tom Cherry9027af02018-09-24 15:48:09 -07001302 fb->Download("signature", signature_data);
1303 fb->RawCommand("signature", "installing signature");
David Andersoncf444f32018-08-29 14:15:49 -07001304 }
1305
1306 if (is_logical(partition_name)) {
Tom Cherry9027af02018-09-24 15:48:09 -07001307 fb->ResizePartition(partition_name, std::to_string(buf->image_size));
David Andersoncf444f32018-08-29 14:15:49 -07001308 }
1309 flash_buf(partition_name.c_str(), buf);
1310 };
1311 do_for_partitions(image.part_name, slot, flash, false);
1312}
1313
1314void FlashAllTool::UpdateSuperPartition() {
David Andersoncf444f32018-08-29 14:15:49 -07001315 int fd = source_.OpenFile("super_empty.img");
1316 if (fd < 0) {
1317 return;
1318 }
1319 if (!is_userspace_fastboot()) {
1320 reboot_to_userspace_fastboot();
1321 }
David Andersoncf444f32018-08-29 14:15:49 -07001322
David Anderson90fe0a42018-11-05 18:01:32 -08001323 std::string super_name;
1324 if (fb->GetVar("super-partition-name", &super_name) != fastboot::RetCode::SUCCESS) {
1325 super_name = "super";
1326 }
1327 fb->Download(super_name, fd, get_file_size(fd));
1328
1329 std::string command = "update-super:" + super_name;
David Andersoncf444f32018-08-29 14:15:49 -07001330 if (wipe_) {
1331 command += ":wipe";
1332 }
Tom Cherry9027af02018-09-24 15:48:09 -07001333 fb->RawCommand(command, "Updating super partition");
David Anderson0c732342018-11-28 17:10:42 -08001334
1335 // Retrofit devices have two super partitions, named super_a and super_b.
1336 // On these devices, secondary slots must be flashed as physical
1337 // partitions (otherwise they would not mount on first boot). To enforce
1338 // this, we delete any logical partitions for the "other" slot.
1339 if (is_retrofit_device()) {
1340 for (const auto& [image, slot] : os_images_) {
1341 std::string partition_name = image->part_name + "_"s + slot;
1342 if (image->IsSecondary() && is_logical(partition_name)) {
1343 fb->DeletePartition(partition_name);
1344 }
1345 }
1346 }
David Andersoncf444f32018-08-29 14:15:49 -07001347}
1348
1349class ZipImageSource final : public ImageSource {
1350 public:
1351 explicit ZipImageSource(ZipArchiveHandle zip) : zip_(zip) {}
Tom Cherrydfd85df2018-09-20 14:45:05 -07001352 bool ReadFile(const std::string& name, std::vector<char>* out) const override;
David Andersoncf444f32018-08-29 14:15:49 -07001353 int OpenFile(const std::string& name) const override;
1354
1355 private:
1356 ZipArchiveHandle zip_;
1357};
1358
Tom Cherrydfd85df2018-09-20 14:45:05 -07001359bool ZipImageSource::ReadFile(const std::string& name, std::vector<char>* out) const {
1360 return UnzipToMemory(zip_, name, out);
David Andersoncf444f32018-08-29 14:15:49 -07001361}
1362
1363int ZipImageSource::OpenFile(const std::string& name) const {
1364 return unzip_to_file(zip_, name.c_str());
1365}
1366
1367static void do_update(const char* filename, const std::string& slot_override, bool skip_secondary) {
David Andersoncf444f32018-08-29 14:15:49 -07001368 ZipArchiveHandle zip;
1369 int error = OpenArchive(filename, &zip);
1370 if (error != 0) {
1371 die("failed to open zip file '%s': %s", filename, ErrorCodeString(error));
1372 }
1373
1374 FlashAllTool tool(ZipImageSource(zip), slot_override, skip_secondary, false);
1375 tool.Flash();
1376
1377 CloseArchive(zip);
1378}
1379
1380class LocalImageSource final : public ImageSource {
1381 public:
Tom Cherrydfd85df2018-09-20 14:45:05 -07001382 bool ReadFile(const std::string& name, std::vector<char>* out) const override;
David Andersoncf444f32018-08-29 14:15:49 -07001383 int OpenFile(const std::string& name) const override;
1384};
1385
Tom Cherrydfd85df2018-09-20 14:45:05 -07001386bool LocalImageSource::ReadFile(const std::string& name, std::vector<char>* out) const {
David Andersoncf444f32018-08-29 14:15:49 -07001387 auto path = find_item_given_name(name);
1388 if (path.empty()) {
Tom Cherrydfd85df2018-09-20 14:45:05 -07001389 return false;
David Andersoncf444f32018-08-29 14:15:49 -07001390 }
Tom Cherrydfd85df2018-09-20 14:45:05 -07001391 return ReadFileToVector(path, out);
David Andersoncf444f32018-08-29 14:15:49 -07001392}
1393
1394int LocalImageSource::OpenFile(const std::string& name) const {
1395 auto path = find_item_given_name(name);
1396 return open(path.c_str(), O_RDONLY);
1397}
1398
1399static void do_flashall(const std::string& slot_override, bool skip_secondary, bool wipe) {
David Andersoncf444f32018-08-29 14:15:49 -07001400 FlashAllTool tool(LocalImageSource(), slot_override, skip_secondary, wipe);
1401 tool.Flash();
1402}
1403
Elliott Hughesd6365a72017-05-08 18:04:49 -07001404static std::string next_arg(std::vector<std::string>* args) {
1405 if (args->empty()) syntax_error("expected argument");
1406 std::string result = args->front();
1407 args->erase(args->begin());
1408 return result;
Patrick Tjin51e8b032015-09-01 08:15:23 -07001409}
1410
Elliott Hughes1eec97a2017-05-15 16:53:53 -07001411static void do_oem_command(const std::string& cmd, std::vector<std::string>* args) {
Elliott Hughesd6365a72017-05-08 18:04:49 -07001412 if (args->empty()) syntax_error("empty oem command");
Tsu Chiang Chuangee520552011-02-25 18:38:53 -08001413
Elliott Hughes1eec97a2017-05-15 16:53:53 -07001414 std::string command(cmd);
Elliott Hughesd6365a72017-05-08 18:04:49 -07001415 while (!args->empty()) {
Elliott Hughes29d5d7d2017-05-11 15:05:13 -07001416 command += " " + next_arg(args);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001417 }
Tom Cherry9027af02018-09-24 15:48:09 -07001418 fb->RawCommand(command, "");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001419}
1420
Connor O'Brience16a8a2017-02-06 14:39:31 -08001421static std::string fb_fix_numeric_var(std::string var) {
1422 // Some bootloaders (angler, for example), send spurious leading whitespace.
1423 var = android::base::Trim(var);
1424 // Some bootloaders (hammerhead, for example) use implicit hex.
1425 // This code used to use strtol with base 16.
1426 if (!android::base::StartsWith(var, "0x")) var = "0x" + var;
1427 return var;
1428}
1429
Aaron Wisnerdb511202018-06-26 15:38:35 -05001430static unsigned fb_get_flash_block_size(std::string name) {
Connor O'Brience16a8a2017-02-06 14:39:31 -08001431 std::string sizeString;
Tom Cherry9027af02018-09-24 15:48:09 -07001432 if (fb->GetVar(name, &sizeString) != fastboot::SUCCESS || sizeString.empty()) {
Elliott Hughes5620d222018-03-28 08:20:00 -07001433 // This device does not report flash block sizes, so return 0.
Connor O'Brience16a8a2017-02-06 14:39:31 -08001434 return 0;
1435 }
1436 sizeString = fb_fix_numeric_var(sizeString);
1437
1438 unsigned size;
1439 if (!android::base::ParseUint(sizeString, &size)) {
1440 fprintf(stderr, "Couldn't parse %s '%s'.\n", name.c_str(), sizeString.c_str());
1441 return 0;
1442 }
Connor O'Brien6ef5c242017-11-01 17:37:32 -07001443 if ((size & (size - 1)) != 0) {
1444 fprintf(stderr, "Invalid %s %u: must be a power of 2.\n", name.c_str(), size);
Connor O'Brience16a8a2017-02-06 14:39:31 -08001445 return 0;
1446 }
1447 return size;
1448}
1449
Aaron Wisnerdb511202018-06-26 15:38:35 -05001450static void fb_perform_format(
Elliott Hughes5620d222018-03-28 08:20:00 -07001451 const std::string& partition, int skip_if_not_supported,
Elliott Hughesd6365a72017-05-08 18:04:49 -07001452 const std::string& type_override, const std::string& size_override,
Paul Crowley8f7f56e2015-11-27 09:29:37 +00001453 const std::string& initial_dir) {
Elliott Hughes2fd45a92015-10-30 11:49:47 -07001454 std::string partition_type, partition_size;
1455
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001456 struct fastboot_buffer buf;
Elliott Hughes2fd45a92015-10-30 11:49:47 -07001457 const char* errMsg = nullptr;
1458 const struct fs_generator* gen = nullptr;
Jin Qian4a335822017-04-18 16:23:18 -07001459 TemporaryFile output;
1460 unique_fd fd;
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001461
Elliott Hughes2fd45a92015-10-30 11:49:47 -07001462 unsigned int limit = INT_MAX;
1463 if (target_sparse_limit > 0 && target_sparse_limit < limit) {
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001464 limit = target_sparse_limit;
Elliott Hughes2fd45a92015-10-30 11:49:47 -07001465 }
1466 if (sparse_limit > 0 && sparse_limit < limit) {
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001467 limit = sparse_limit;
Elliott Hughes2fd45a92015-10-30 11:49:47 -07001468 }
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001469
Tom Cherry9027af02018-09-24 15:48:09 -07001470 if (fb->GetVar("partition-type:" + partition, &partition_type) != fastboot::SUCCESS) {
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001471 errMsg = "Can't determine partition type.\n";
1472 goto failed;
1473 }
Elliott Hughesd6365a72017-05-08 18:04:49 -07001474 if (!type_override.empty()) {
Elliott Hughes2fd45a92015-10-30 11:49:47 -07001475 if (partition_type != type_override) {
1476 fprintf(stderr, "Warning: %s type is %s, but %s was requested for formatting.\n",
Elliott Hughes5620d222018-03-28 08:20:00 -07001477 partition.c_str(), partition_type.c_str(), type_override.c_str());
JP Abgrall7e859742014-05-06 15:14:15 -07001478 }
Elliott Hughes2fd45a92015-10-30 11:49:47 -07001479 partition_type = type_override;
JP Abgrall7e859742014-05-06 15:14:15 -07001480 }
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001481
Tom Cherry9027af02018-09-24 15:48:09 -07001482 if (fb->GetVar("partition-size:" + partition, &partition_size) != fastboot::SUCCESS) {
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001483 errMsg = "Unable to get partition size\n";
1484 goto failed;
1485 }
Elliott Hughesd6365a72017-05-08 18:04:49 -07001486 if (!size_override.empty()) {
Elliott Hughes2fd45a92015-10-30 11:49:47 -07001487 if (partition_size != size_override) {
1488 fprintf(stderr, "Warning: %s size is %s, but %s was requested for formatting.\n",
Elliott Hughes5620d222018-03-28 08:20:00 -07001489 partition.c_str(), partition_size.c_str(), size_override.c_str());
JP Abgrall7e859742014-05-06 15:14:15 -07001490 }
Elliott Hughes2fd45a92015-10-30 11:49:47 -07001491 partition_size = size_override;
JP Abgrall7e859742014-05-06 15:14:15 -07001492 }
Connor O'Brience16a8a2017-02-06 14:39:31 -08001493 partition_size = fb_fix_numeric_var(partition_size);
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001494
Elliott Hughes8ab9a322015-11-02 14:05:57 -08001495 gen = fs_get_generator(partition_type);
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001496 if (!gen) {
1497 if (skip_if_not_supported) {
1498 fprintf(stderr, "Erase successful, but not automatically formatting.\n");
Elliott Hughes2fd45a92015-10-30 11:49:47 -07001499 fprintf(stderr, "File system type %s not supported.\n", partition_type.c_str());
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001500 return;
1501 }
Mark Salyzyna30b6962018-11-20 11:04:15 -08001502 die("Formatting is not supported for file system with type '%s'.",
1503 partition_type.c_str());
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001504 }
1505
Elliott Hughes2fd45a92015-10-30 11:49:47 -07001506 int64_t size;
Elliott Hughesda46b392016-10-11 17:09:00 -07001507 if (!android::base::ParseInt(partition_size, &size)) {
Mark Salyzyna30b6962018-11-20 11:04:15 -08001508 die("Couldn't parse partition size '%s'.", partition_size.c_str());
Elliott Hughes2fd45a92015-10-30 11:49:47 -07001509 }
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001510
Connor O'Brience16a8a2017-02-06 14:39:31 -08001511 unsigned eraseBlkSize, logicalBlkSize;
Aaron Wisnerdb511202018-06-26 15:38:35 -05001512 eraseBlkSize = fb_get_flash_block_size("erase-block-size");
1513 logicalBlkSize = fb_get_flash_block_size("logical-block-size");
Connor O'Brience16a8a2017-02-06 14:39:31 -08001514
Jin Qian4a335822017-04-18 16:23:18 -07001515 if (fs_generator_generate(gen, output.path, size, initial_dir,
1516 eraseBlkSize, logicalBlkSize)) {
Elliott Hughes5620d222018-03-28 08:20:00 -07001517 die("Cannot generate image for %s", partition.c_str());
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001518 }
1519
Jin Qian4a335822017-04-18 16:23:18 -07001520 fd.reset(open(output.path, O_RDONLY));
1521 if (fd == -1) {
Mark Salyzyna30b6962018-11-20 11:04:15 -08001522 die("Cannot open generated image: %s", strerror(errno));
Jin Qian4a335822017-04-18 16:23:18 -07001523 }
Aaron Wisnerdb511202018-06-26 15:38:35 -05001524 if (!load_buf_fd(fd.release(), &buf)) {
Mark Salyzyna30b6962018-11-20 11:04:15 -08001525 die("Cannot read image: %s", strerror(errno));
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001526 }
1527 flash_buf(partition, &buf);
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001528 return;
1529
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001530failed:
1531 if (skip_if_not_supported) {
1532 fprintf(stderr, "Erase successful, but not automatically formatting.\n");
Elliott Hughes2fd45a92015-10-30 11:49:47 -07001533 if (errMsg) fprintf(stderr, "%s", errMsg);
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001534 }
Tom Cherry9027af02018-09-24 15:48:09 -07001535 fprintf(stderr, "FAILED (%s)\n", fb->Error().c_str());
Mark Salyzyna30b6962018-11-20 11:04:15 -08001536 if (!skip_if_not_supported) {
1537 die("Command failed");
1538 }
Dmitry Grinberge6f3e9b2014-03-11 18:28:15 -07001539}
1540
David Anderson89569642018-11-16 15:53:35 -08001541static bool should_flash_in_userspace(const std::string& partition_name) {
David Andersone0e693c2018-11-27 20:19:26 -08001542 if (!get_android_product_out()) {
1543 return false;
1544 }
David Anderson89569642018-11-16 15:53:35 -08001545 auto path = find_item_given_name("super_empty.img");
David Anderson00475802018-12-04 17:05:47 -08001546 if (path.empty() || access(path.c_str(), R_OK)) {
David Anderson89569642018-11-16 15:53:35 -08001547 return false;
1548 }
1549 auto metadata = android::fs_mgr::ReadFromImageFile(path);
1550 if (!metadata) {
1551 return false;
1552 }
1553 for (const auto& partition : metadata->partitions) {
1554 auto candidate = android::fs_mgr::GetPartitionName(partition);
1555 if (partition.attributes & LP_PARTITION_ATTR_SLOT_SUFFIXED) {
1556 // On retrofit devices, we don't know if, or whether, the A or B
1557 // slot has been flashed for dynamic partitions. Instead we add
1558 // both names to the list as a conservative guess.
1559 if (candidate + "_a" == partition_name || candidate + "_b" == partition_name) {
1560 return true;
1561 }
1562 } else if (candidate == partition_name) {
1563 return true;
1564 }
1565 }
1566 return false;
1567}
1568
Aaron Wisnerdb511202018-06-26 15:38:35 -05001569int FastBootTool::Main(int argc, char* argv[]) {
Daniel Rosenberg0d088562015-11-11 16:15:30 -08001570 bool wants_wipe = false;
1571 bool wants_reboot = false;
1572 bool wants_reboot_bootloader = false;
Hridya Valsarajudea91b42018-07-17 11:14:01 -07001573 bool wants_reboot_recovery = false;
1574 bool wants_reboot_fastboot = false;
Mitchell Wills31dce302016-09-26 10:26:21 -07001575 bool skip_reboot = false;
Daniel Rosenberg0d088562015-11-11 16:15:30 -08001576 bool wants_set_active = false;
Daniel Rosenberg92b44762016-07-13 20:03:25 -07001577 bool skip_secondary = false;
Paul Crowley8f7f56e2015-11-27 09:29:37 +00001578 bool set_fbe_marker = false;
David Anderson89569642018-11-16 15:53:35 -08001579 bool force_flash = false;
Florian Bäuerle27ded482014-11-24 11:29:34 +01001580 int longindex;
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001581 std::string slot_override;
Daniel Rosenberg0d088562015-11-11 16:15:30 -08001582 std::string next_active;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001583
Elliott Hughes577e8b42018-04-05 16:12:47 -07001584 g_boot_img_hdr.kernel_addr = 0x00008000;
1585 g_boot_img_hdr.ramdisk_addr = 0x01000000;
1586 g_boot_img_hdr.second_addr = 0x00f00000;
1587 g_boot_img_hdr.tags_addr = 0x00000100;
1588 g_boot_img_hdr.page_size = 2048;
1589
JP Abgrall7b8970c2013-03-07 17:06:41 -08001590 const struct option longopts[] = {
Elliott Hughes577e8b42018-04-05 16:12:47 -07001591 {"base", required_argument, 0, 0},
1592 {"cmdline", required_argument, 0, 0},
1593 {"disable-verification", no_argument, 0, 0},
1594 {"disable-verity", no_argument, 0, 0},
David Anderson89569642018-11-16 15:53:35 -08001595 {"force", no_argument, 0, 0},
Elliott Hughes577e8b42018-04-05 16:12:47 -07001596 {"header-version", required_argument, 0, 0},
Elliott Hughes379646b2015-06-02 13:50:00 -07001597 {"help", no_argument, 0, 'h'},
Elliott Hughes577e8b42018-04-05 16:12:47 -07001598 {"kernel-offset", required_argument, 0, 0},
1599 {"os-patch-level", required_argument, 0, 0},
1600 {"os-version", required_argument, 0, 0},
1601 {"page-size", required_argument, 0, 0},
1602 {"ramdisk-offset", required_argument, 0, 0},
Daniel Rosenberg7aa38bc2015-11-11 17:29:37 -08001603 {"set-active", optional_argument, 0, 'a'},
Mitchell Wills31dce302016-09-26 10:26:21 -07001604 {"skip-reboot", no_argument, 0, 0},
Elliott Hughes577e8b42018-04-05 16:12:47 -07001605 {"skip-secondary", no_argument, 0, 0},
1606 {"slot", required_argument, 0, 0},
1607 {"tags-offset", required_argument, 0, 0},
1608 {"unbuffered", no_argument, 0, 0},
Elliott Hughesf238d872018-03-29 14:46:29 -07001609 {"verbose", no_argument, 0, 'v'},
1610 {"version", no_argument, 0, 0},
Paul Crowley8f7f56e2015-11-27 09:29:37 +00001611#if !defined(_WIN32)
1612 {"wipe-and-use-fbe", no_argument, 0, 0},
1613#endif
JP Abgrall7b8970c2013-03-07 17:06:41 -08001614 {0, 0, 0, 0}
1615 };
Colin Cross8879f982012-05-22 17:53:34 -07001616
1617 serial = getenv("ANDROID_SERIAL");
1618
Elliott Hughes577e8b42018-04-05 16:12:47 -07001619 int c;
Elliott Hughesf3192bd2018-04-10 15:38:08 -07001620 while ((c = getopt_long(argc, argv, "a::hls:S:vw", longopts, &longindex)) != -1) {
Elliott Hughes577e8b42018-04-05 16:12:47 -07001621 if (c == 0) {
1622 std::string name{longopts[longindex].name};
1623 if (name == "base") {
1624 g_base_addr = strtoul(optarg, 0, 16);
1625 } else if (name == "cmdline") {
1626 g_cmdline = optarg;
1627 } else if (name == "disable-verification") {
1628 g_disable_verification = true;
1629 } else if (name == "disable-verity") {
1630 g_disable_verity = true;
David Anderson89569642018-11-16 15:53:35 -08001631 } else if (name == "force") {
1632 force_flash = true;
Elliott Hughes577e8b42018-04-05 16:12:47 -07001633 } else if (name == "header-version") {
1634 g_boot_img_hdr.header_version = strtoul(optarg, nullptr, 0);
1635 } else if (name == "kernel-offset") {
1636 g_boot_img_hdr.kernel_addr = strtoul(optarg, 0, 16);
1637 } else if (name == "os-patch-level") {
Elliott Hughes6ebec932018-04-10 14:22:13 -07001638 ParseOsPatchLevel(&g_boot_img_hdr, optarg);
Elliott Hughes577e8b42018-04-05 16:12:47 -07001639 } else if (name == "os-version") {
Elliott Hughes6ebec932018-04-10 14:22:13 -07001640 ParseOsVersion(&g_boot_img_hdr, optarg);
Elliott Hughes577e8b42018-04-05 16:12:47 -07001641 } else if (name == "page-size") {
1642 g_boot_img_hdr.page_size = strtoul(optarg, nullptr, 0);
1643 if (g_boot_img_hdr.page_size == 0) die("invalid page size");
1644 } else if (name == "ramdisk-offset") {
1645 g_boot_img_hdr.ramdisk_addr = strtoul(optarg, 0, 16);
1646 } else if (name == "skip-reboot") {
1647 skip_reboot = true;
1648 } else if (name == "skip-secondary") {
1649 skip_secondary = true;
1650 } else if (name == "slot") {
1651 slot_override = optarg;
1652 } else if (name == "tags-offset") {
1653 g_boot_img_hdr.tags_addr = strtoul(optarg, 0, 16);
1654 } else if (name == "unbuffered") {
Elliott Hughesfc797672015-04-07 20:12:50 -07001655 setvbuf(stdout, nullptr, _IONBF, 0);
1656 setvbuf(stderr, nullptr, _IONBF, 0);
Elliott Hughes577e8b42018-04-05 16:12:47 -07001657 } else if (name == "version") {
Dan Willemsenab971b52018-08-29 14:58:02 -07001658 fprintf(stdout, "fastboot version %s-%s\n", PLATFORM_TOOLS_VERSION, android::build::GetBuildNumber().c_str());
Elliott Hughes1fd46df2017-03-30 15:08:28 -07001659 fprintf(stdout, "Installed as %s\n", android::base::GetExecutablePath().c_str());
Elliott Hughes379646b2015-06-02 13:50:00 -07001660 return 0;
Paul Crowley8f7f56e2015-11-27 09:29:37 +00001661#if !defined(_WIN32)
Elliott Hughes577e8b42018-04-05 16:12:47 -07001662 } else if (name == "wipe-and-use-fbe") {
Paul Crowley8f7f56e2015-11-27 09:29:37 +00001663 wants_wipe = true;
1664 set_fbe_marker = true;
1665#endif
1666 } else {
Elliott Hughes855cdf82018-04-02 14:24:03 -07001667 die("unknown option %s", longopts[longindex].name);
Florian Bäuerle27ded482014-11-24 11:29:34 +01001668 }
Elliott Hughes577e8b42018-04-05 16:12:47 -07001669 } else {
1670 switch (c) {
1671 case 'a':
1672 wants_set_active = true;
1673 if (optarg) next_active = optarg;
1674 break;
1675 case 'h':
1676 return show_help();
Elliott Hughes577e8b42018-04-05 16:12:47 -07001677 case 'l':
1678 g_long_listing = true;
1679 break;
1680 case 's':
1681 serial = optarg;
1682 break;
1683 case 'S':
Elliott Hughes542370d2018-04-19 19:49:44 -07001684 if (!android::base::ParseByteCount(optarg, &sparse_limit)) {
1685 die("invalid sparse limit %s", optarg);
1686 }
Elliott Hughes577e8b42018-04-05 16:12:47 -07001687 break;
1688 case 'v':
1689 set_verbose();
1690 break;
1691 case 'w':
1692 wants_wipe = true;
1693 break;
1694 case '?':
1695 return 1;
1696 default:
1697 abort();
1698 }
Colin Cross8879f982012-05-22 17:53:34 -07001699 }
1700 }
1701
1702 argc -= optind;
1703 argv += optind;
1704
Elliott Hughesd6365a72017-05-08 18:04:49 -07001705 if (argc == 0 && !wants_wipe && !wants_set_active) syntax_error("no command");
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001706
Colin Cross8fb6e062012-07-24 16:36:41 -07001707 if (argc > 0 && !strcmp(*argv, "devices")) {
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001708 list_devices();
Tsu Chiang Chuangee520552011-02-25 18:38:53 -08001709 return 0;
1710 }
1711
Colin Crossc7b75dc2012-08-29 18:17:06 -07001712 if (argc > 0 && !strcmp(*argv, "help")) {
Elliott Hughesd6365a72017-05-08 18:04:49 -07001713 return show_help();
Colin Crossc7b75dc2012-08-29 18:17:06 -07001714 }
1715
David Pursell0b156632015-10-30 11:22:01 -07001716 Transport* transport = open_device();
David Pursell2ec418a2016-01-20 08:32:08 -08001717 if (transport == nullptr) {
1718 return 1;
1719 }
Tom Cherry9027af02018-09-24 15:48:09 -07001720 fastboot::DriverCallbacks driver_callbacks = {
1721 .prolog = Status,
1722 .epilog = Epilog,
1723 .info = InfoMessage,
1724 };
1725 fastboot::FastBootDriver fastboot_driver(transport, driver_callbacks, false);
1726 fb = &fastboot_driver;
David Pursell2ec418a2016-01-20 08:32:08 -08001727
Elliott Hughes5620d222018-03-28 08:20:00 -07001728 const double start = now();
1729
Aaron Wisnerdb511202018-06-26 15:38:35 -05001730 if (slot_override != "") slot_override = verify_slot(slot_override);
1731 if (next_active != "") next_active = verify_slot(next_active, false);
Daniel Rosenberg0d088562015-11-11 16:15:30 -08001732
1733 if (wants_set_active) {
1734 if (next_active == "") {
1735 if (slot_override == "") {
Daniel Rosenberg13454092016-06-27 19:43:11 -07001736 std::string current_slot;
Tom Cherry9027af02018-09-24 15:48:09 -07001737 if (fb->GetVar("current-slot", &current_slot) == fastboot::SUCCESS) {
Aaron Wisnerdb511202018-06-26 15:38:35 -05001738 next_active = verify_slot(current_slot, false);
Daniel Rosenberg13454092016-06-27 19:43:11 -07001739 } else {
1740 wants_set_active = false;
1741 }
Daniel Rosenberg0d088562015-11-11 16:15:30 -08001742 } else {
Aaron Wisnerdb511202018-06-26 15:38:35 -05001743 next_active = verify_slot(slot_override, false);
Daniel Rosenberg0d088562015-11-11 16:15:30 -08001744 }
1745 }
1746 }
Elliott Hughes31dbed72009-10-07 15:38:53 -07001747
Elliott Hughesd6365a72017-05-08 18:04:49 -07001748 std::vector<std::string> args(argv, argv + argc);
1749 while (!args.empty()) {
1750 std::string command = next_arg(&args);
Ken Sumrall5ee5d382012-09-29 14:46:25 -07001751
Mark Salyzyn8e7e9cb2018-08-29 10:44:33 -07001752 if (command == FB_CMD_GETVAR) {
Elliott Hughesd6365a72017-05-08 18:04:49 -07001753 std::string variable = next_arg(&args);
Tom Cherry9027af02018-09-24 15:48:09 -07001754 DisplayVarOrError(variable, variable);
Mark Salyzyn8e7e9cb2018-08-29 10:44:33 -07001755 } else if (command == FB_CMD_ERASE) {
Elliott Hughesd6365a72017-05-08 18:04:49 -07001756 std::string partition = next_arg(&args);
1757 auto erase = [&](const std::string& partition) {
David Pursell0b156632015-10-30 11:22:01 -07001758 std::string partition_type;
Tom Cherry9027af02018-09-24 15:48:09 -07001759 if (fb->GetVar("partition-type:" + partition, &partition_type) == fastboot::SUCCESS &&
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001760 fs_get_generator(partition_type) != nullptr) {
1761 fprintf(stderr, "******** Did you mean to fastboot format this %s partition?\n",
1762 partition_type.c_str());
1763 }
Ken Sumrall5ee5d382012-09-29 14:46:25 -07001764
Tom Cherry9027af02018-09-24 15:48:09 -07001765 fb->Erase(partition);
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001766 };
Aaron Wisnerdb511202018-06-26 15:38:35 -05001767 do_for_partitions(partition, slot_override, erase, true);
Elliott Hughesd6365a72017-05-08 18:04:49 -07001768 } else if (android::base::StartsWith(command, "format")) {
1769 // Parsing for: "format[:[type][:[size]]]"
1770 // Some valid things:
1771 // - select only the size, and leave default fs type:
1772 // format::0x4000000 userdata
1773 // - default fs type and size:
1774 // format userdata
1775 // format:: userdata
1776 std::vector<std::string> pieces = android::base::Split(command, ":");
1777 std::string type_override;
1778 if (pieces.size() > 1) type_override = pieces[1].c_str();
1779 std::string size_override;
1780 if (pieces.size() > 2) size_override = pieces[2].c_str();
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001781
Elliott Hughesd6365a72017-05-08 18:04:49 -07001782 std::string partition = next_arg(&args);
1783
1784 auto format = [&](const std::string& partition) {
Aaron Wisnerdb511202018-06-26 15:38:35 -05001785 fb_perform_format(partition, 0, type_override, size_override, "");
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001786 };
Aaron Wisnerdb511202018-06-26 15:38:35 -05001787 do_for_partitions(partition.c_str(), slot_override, format, true);
Elliott Hughesd6365a72017-05-08 18:04:49 -07001788 } else if (command == "signature") {
1789 std::string filename = next_arg(&args);
Tom Cherrydfd85df2018-09-20 14:45:05 -07001790 std::vector<char> data;
1791 if (!ReadFileToVector(filename, &data)) {
1792 die("could not load '%s': %s", filename.c_str(), strerror(errno));
1793 }
1794 if (data.size() != 256) die("signature must be 256 bytes (got %zu)", data.size());
Tom Cherry9027af02018-09-24 15:48:09 -07001795 fb->Download("signature", data);
1796 fb->RawCommand("signature", "installing signature");
Mark Salyzyn8e7e9cb2018-08-29 10:44:33 -07001797 } else if (command == FB_CMD_REBOOT) {
Daniel Rosenberg0d088562015-11-11 16:15:30 -08001798 wants_reboot = true;
Elliott Hughesd6365a72017-05-08 18:04:49 -07001799
1800 if (args.size() == 1) {
1801 std::string what = next_arg(&args);
1802 if (what == "bootloader") {
Daniel Rosenberg0d088562015-11-11 16:15:30 -08001803 wants_reboot = false;
1804 wants_reboot_bootloader = true;
Hridya Valsarajudea91b42018-07-17 11:14:01 -07001805 } else if (what == "recovery") {
1806 wants_reboot = false;
1807 wants_reboot_recovery = true;
1808 } else if (what == "fastboot") {
1809 wants_reboot = false;
1810 wants_reboot_fastboot = true;
Elliott Hughesd6365a72017-05-08 18:04:49 -07001811 } else {
1812 syntax_error("unknown reboot target %s", what.c_str());
Alexey Polyudove0bfb752017-01-03 19:39:13 -08001813 }
Elliott Hughesd6365a72017-05-08 18:04:49 -07001814
Elliott Hughesca85df02015-02-25 10:02:00 -08001815 }
Elliott Hughesd6365a72017-05-08 18:04:49 -07001816 if (!args.empty()) syntax_error("junk after reboot command");
Mark Salyzyn8e7e9cb2018-08-29 10:44:33 -07001817 } else if (command == FB_CMD_REBOOT_BOOTLOADER) {
Daniel Rosenberg0d088562015-11-11 16:15:30 -08001818 wants_reboot_bootloader = true;
Mark Salyzyn8e7e9cb2018-08-29 10:44:33 -07001819 } else if (command == FB_CMD_REBOOT_RECOVERY) {
Hridya Valsarajudea91b42018-07-17 11:14:01 -07001820 wants_reboot_recovery = true;
Mark Salyzyn8e7e9cb2018-08-29 10:44:33 -07001821 } else if (command == FB_CMD_REBOOT_FASTBOOT) {
Hridya Valsarajudea91b42018-07-17 11:14:01 -07001822 wants_reboot_fastboot = true;
Mark Salyzyn8e7e9cb2018-08-29 10:44:33 -07001823 } else if (command == FB_CMD_CONTINUE) {
Tom Cherry9027af02018-09-24 15:48:09 -07001824 fb->Continue();
Mark Salyzyn8e7e9cb2018-08-29 10:44:33 -07001825 } else if (command == FB_CMD_BOOT) {
Elliott Hughesd6365a72017-05-08 18:04:49 -07001826 std::string kernel = next_arg(&args);
1827 std::string ramdisk;
1828 if (!args.empty()) ramdisk = next_arg(&args);
1829 std::string second_stage;
1830 if (!args.empty()) second_stage = next_arg(&args);
1831
Tom Cherrydfd85df2018-09-20 14:45:05 -07001832 auto data = LoadBootableImage(kernel, ramdisk, second_stage);
Tom Cherry9027af02018-09-24 15:48:09 -07001833 fb->Download("boot.img", data);
1834 fb->Boot();
Mark Salyzyn8e7e9cb2018-08-29 10:44:33 -07001835 } else if (command == FB_CMD_FLASH) {
Elliott Hughesd6365a72017-05-08 18:04:49 -07001836 std::string pname = next_arg(&args);
1837
Elliott Hughes2810d002016-04-25 14:31:18 -07001838 std::string fname;
Elliott Hughesd6365a72017-05-08 18:04:49 -07001839 if (!args.empty()) {
1840 fname = next_arg(&args);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001841 } else {
Elliott Hughes45964a82017-05-03 22:43:23 -07001842 fname = find_item(pname);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001843 }
Elliott Hughesd6365a72017-05-08 18:04:49 -07001844 if (fname.empty()) die("cannot determine image filename for '%s'", pname.c_str());
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001845
1846 auto flash = [&](const std::string &partition) {
David Anderson89569642018-11-16 15:53:35 -08001847 if (should_flash_in_userspace(partition) && !is_userspace_fastboot() &&
1848 !force_flash) {
1849 die("The partition you are trying to flash is dynamic, and "
1850 "should be flashed via fastbootd. Please run:\n"
1851 "\n"
1852 " fastboot reboot fastboot\n"
1853 "\n"
1854 "And try again. If you are intentionally trying to "
1855 "overwrite a fixed partition, use --force.");
1856 }
Aaron Wisnerdb511202018-06-26 15:38:35 -05001857 do_flash(partition.c_str(), fname.c_str());
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001858 };
Aaron Wisnerdb511202018-06-26 15:38:35 -05001859 do_for_partitions(pname.c_str(), slot_override, flash, true);
Elliott Hughesd6365a72017-05-08 18:04:49 -07001860 } else if (command == "flash:raw") {
1861 std::string partition = next_arg(&args);
1862 std::string kernel = next_arg(&args);
1863 std::string ramdisk;
1864 if (!args.empty()) ramdisk = next_arg(&args);
1865 std::string second_stage;
1866 if (!args.empty()) second_stage = next_arg(&args);
1867
Tom Cherrydfd85df2018-09-20 14:45:05 -07001868 auto data = LoadBootableImage(kernel, ramdisk, second_stage);
1869 auto flashraw = [&data](const std::string& partition) {
Tom Cherry9027af02018-09-24 15:48:09 -07001870 fb->FlashPartition(partition, data);
Daniel Rosenbergb7bd4ae2015-09-14 21:05:41 -07001871 };
Aaron Wisnerdb511202018-06-26 15:38:35 -05001872 do_for_partitions(partition, slot_override, flashraw, true);
Elliott Hughesd6365a72017-05-08 18:04:49 -07001873 } else if (command == "flashall") {
Alex Lightbb9b8a52016-06-29 09:26:44 -07001874 if (slot_override == "all") {
Daniel Rosenberg92b44762016-07-13 20:03:25 -07001875 fprintf(stderr, "Warning: slot set to 'all'. Secondary slots will not be flashed.\n");
David Anderson32e376f2018-08-16 13:43:11 -07001876 do_flashall(slot_override, true, wants_wipe);
Alex Lightbb9b8a52016-06-29 09:26:44 -07001877 } else {
David Anderson32e376f2018-08-16 13:43:11 -07001878 do_flashall(slot_override, skip_secondary, wants_wipe);
Alex Lightbb9b8a52016-06-29 09:26:44 -07001879 }
Daniel Rosenberg0d088562015-11-11 16:15:30 -08001880 wants_reboot = true;
Elliott Hughesd6365a72017-05-08 18:04:49 -07001881 } else if (command == "update") {
Daniel Rosenberg92b44762016-07-13 20:03:25 -07001882 bool slot_all = (slot_override == "all");
1883 if (slot_all) {
1884 fprintf(stderr, "Warning: slot set to 'all'. Secondary slots will not be flashed.\n");
1885 }
Elliott Hughesd6365a72017-05-08 18:04:49 -07001886 std::string filename = "update.zip";
1887 if (!args.empty()) {
1888 filename = next_arg(&args);
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001889 }
Aaron Wisnerdb511202018-06-26 15:38:35 -05001890 do_update(filename.c_str(), slot_override, skip_secondary || slot_all);
Mitchell Wills31dce302016-09-26 10:26:21 -07001891 wants_reboot = true;
Mark Salyzyn8e7e9cb2018-08-29 10:44:33 -07001892 } else if (command == FB_CMD_SET_ACTIVE) {
Aaron Wisnerdb511202018-06-26 15:38:35 -05001893 std::string slot = verify_slot(next_arg(&args), false);
Tom Cherry9027af02018-09-24 15:48:09 -07001894 fb->SetActive(slot);
Elliott Hughesd6365a72017-05-08 18:04:49 -07001895 } else if (command == "stage") {
1896 std::string filename = next_arg(&args);
1897
Jocelyn Bohr98cc2832017-01-26 19:20:53 -08001898 struct fastboot_buffer buf;
Aaron Wisnerdb511202018-06-26 15:38:35 -05001899 if (!load_buf(filename.c_str(), &buf) || buf.type != FB_BUFFER_FD) {
Elliott Hughesd6365a72017-05-08 18:04:49 -07001900 die("cannot load '%s'", filename.c_str());
Jocelyn Bohr98cc2832017-01-26 19:20:53 -08001901 }
Tom Cherry9027af02018-09-24 15:48:09 -07001902 fb->Download(filename, buf.fd, buf.sz);
Elliott Hughesd6365a72017-05-08 18:04:49 -07001903 } else if (command == "get_staged") {
1904 std::string filename = next_arg(&args);
Tom Cherry9027af02018-09-24 15:48:09 -07001905 fb->Upload(filename);
Mark Salyzyn8e7e9cb2018-08-29 10:44:33 -07001906 } else if (command == FB_CMD_OEM) {
1907 do_oem_command(FB_CMD_OEM, &args);
Elliott Hughesd6365a72017-05-08 18:04:49 -07001908 } else if (command == "flashing") {
1909 if (args.empty()) {
1910 syntax_error("missing 'flashing' command");
1911 } else if (args.size() == 1 && (args[0] == "unlock" || args[0] == "lock" ||
1912 args[0] == "unlock_critical" ||
1913 args[0] == "lock_critical" ||
Elliott Hughes2e9b7792018-04-04 13:36:44 -07001914 args[0] == "get_unlock_ability")) {
Elliott Hughes1eec97a2017-05-15 16:53:53 -07001915 do_oem_command("flashing", &args);
Badhri Jagan Sridharanbf110952015-05-15 16:43:47 -07001916 } else {
Elliott Hughesd6365a72017-05-08 18:04:49 -07001917 syntax_error("unknown 'flashing' command %s", args[0].c_str());
Badhri Jagan Sridharanbf110952015-05-15 16:43:47 -07001918 }
Mark Salyzyn8e7e9cb2018-08-29 10:44:33 -07001919 } else if (command == FB_CMD_CREATE_PARTITION) {
David Anderson0d4277d2018-07-31 13:27:37 -07001920 std::string partition = next_arg(&args);
1921 std::string size = next_arg(&args);
Tom Cherry9027af02018-09-24 15:48:09 -07001922 fb->CreatePartition(partition, size);
Mark Salyzyn8e7e9cb2018-08-29 10:44:33 -07001923 } else if (command == FB_CMD_DELETE_PARTITION) {
David Anderson0d4277d2018-07-31 13:27:37 -07001924 std::string partition = next_arg(&args);
Tom Cherry9027af02018-09-24 15:48:09 -07001925 fb->DeletePartition(partition);
Mark Salyzyn8e7e9cb2018-08-29 10:44:33 -07001926 } else if (command == FB_CMD_RESIZE_PARTITION) {
David Anderson0d4277d2018-07-31 13:27:37 -07001927 std::string partition = next_arg(&args);
1928 std::string size = next_arg(&args);
Tom Cherry9027af02018-09-24 15:48:09 -07001929 fb->ResizePartition(partition, size);
David Anderson1d504e32019-01-15 14:38:20 -08001930 } else if (command == "gsi") {
1931 if (args.empty()) {
1932 syntax_error("missing 'wipe' or 'disable' argument");
1933 } else if (args.size() == 1 && args[0] == "wipe") {
1934 fb->RawCommand("gsi:wipe", "wiping GSI");
1935 } else if (args.size() == 1 && args[0] == "disable") {
1936 fb->RawCommand("gsi:disable", "disabling GSI");
1937 } else {
1938 syntax_error("expected 'wipe' or 'disable'");
1939 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001940 } else {
Elliott Hughesd6365a72017-05-08 18:04:49 -07001941 syntax_error("unknown command %s", command.c_str());
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001942 }
1943 }
1944
1945 if (wants_wipe) {
Paul Crowley4d170062018-04-24 17:06:30 -07001946 std::vector<std::string> partitions = { "userdata", "cache", "metadata" };
1947 for (const auto& partition : partitions) {
1948 std::string partition_type;
Tom Cherry9027af02018-09-24 15:48:09 -07001949 if (fb->GetVar("partition-type:" + partition, &partition_type) != fastboot::SUCCESS) {
1950 continue;
1951 }
Paul Crowley4d170062018-04-24 17:06:30 -07001952 if (partition_type.empty()) continue;
Tom Cherry9027af02018-09-24 15:48:09 -07001953 fb->Erase(partition);
Paul Crowley4d170062018-04-24 17:06:30 -07001954 if (partition == "userdata" && set_fbe_marker) {
1955 fprintf(stderr, "setting FBE marker on initial userdata...\n");
1956 std::string initial_userdata_dir = create_fbemarker_tmpdir();
Aaron Wisnerdb511202018-06-26 15:38:35 -05001957 fb_perform_format(partition, 1, "", "", initial_userdata_dir);
Paul Crowley4d170062018-04-24 17:06:30 -07001958 delete_fbemarker_tmpdir(initial_userdata_dir);
1959 } else {
Aaron Wisnerdb511202018-06-26 15:38:35 -05001960 fb_perform_format(partition, 1, "", "", "");
Paul Crowley4d170062018-04-24 17:06:30 -07001961 }
Elliott Hughes2fd45a92015-10-30 11:49:47 -07001962 }
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001963 }
Daniel Rosenberg0d088562015-11-11 16:15:30 -08001964 if (wants_set_active) {
Tom Cherry9027af02018-09-24 15:48:09 -07001965 fb->SetActive(next_active);
Daniel Rosenberg0d088562015-11-11 16:15:30 -08001966 }
Mitchell Wills31dce302016-09-26 10:26:21 -07001967 if (wants_reboot && !skip_reboot) {
Tom Cherry9027af02018-09-24 15:48:09 -07001968 fb->Reboot();
1969 fb->WaitForDisconnect();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001970 } else if (wants_reboot_bootloader) {
Tom Cherry9027af02018-09-24 15:48:09 -07001971 fb->RebootTo("bootloader");
1972 fb->WaitForDisconnect();
Hridya Valsarajudea91b42018-07-17 11:14:01 -07001973 } else if (wants_reboot_recovery) {
Tom Cherry9027af02018-09-24 15:48:09 -07001974 fb->RebootTo("recovery");
1975 fb->WaitForDisconnect();
Hridya Valsarajudea91b42018-07-17 11:14:01 -07001976 } else if (wants_reboot_fastboot) {
David Anderson11d6d272018-12-07 16:39:07 -08001977 reboot_to_userspace_fastboot();
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001978 }
1979
Elliott Hughes5620d222018-03-28 08:20:00 -07001980 fprintf(stderr, "Finished. Total time: %.3fs\n", (now() - start));
David Anderson03de6452018-09-04 14:32:54 -07001981
Tom Cherry9027af02018-09-24 15:48:09 -07001982 auto* old_transport = fb->set_transport(nullptr);
1983 delete old_transport;
1984
Tom Cherry11f12092018-08-29 21:36:28 -07001985 return 0;
The Android Open Source Projectdd7bc332009-03-03 19:32:55 -08001986}
Elliott Hughes6ebec932018-04-10 14:22:13 -07001987
Aaron Wisnerdb511202018-06-26 15:38:35 -05001988void FastBootTool::ParseOsPatchLevel(boot_img_hdr_v1* hdr, const char* arg) {
Elliott Hughes6ebec932018-04-10 14:22:13 -07001989 unsigned year, month, day;
1990 if (sscanf(arg, "%u-%u-%u", &year, &month, &day) != 3) {
1991 syntax_error("OS patch level should be YYYY-MM-DD: %s", arg);
1992 }
1993 if (year < 2000 || year >= 2128) syntax_error("year out of range: %d", year);
1994 if (month < 1 || month > 12) syntax_error("month out of range: %d", month);
1995 hdr->SetOsPatchLevel(year, month);
1996}
1997
Aaron Wisnerdb511202018-06-26 15:38:35 -05001998void FastBootTool::ParseOsVersion(boot_img_hdr_v1* hdr, const char* arg) {
Elliott Hughes6ebec932018-04-10 14:22:13 -07001999 unsigned major = 0, minor = 0, patch = 0;
2000 std::vector<std::string> versions = android::base::Split(arg, ".");
2001 if (versions.size() < 1 || versions.size() > 3 ||
2002 (versions.size() >= 1 && !android::base::ParseUint(versions[0], &major)) ||
2003 (versions.size() >= 2 && !android::base::ParseUint(versions[1], &minor)) ||
2004 (versions.size() == 3 && !android::base::ParseUint(versions[2], &patch)) ||
2005 (major > 0x7f || minor > 0x7f || patch > 0x7f)) {
2006 syntax_error("bad OS version: %s", arg);
2007 }
2008 hdr->SetOsVersion(major, minor, patch);
2009}