David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 1 | // |
| 2 | // Copyright (C) 2019 The Android Open Source Project |
| 3 | // |
| 4 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | // you may not use this file except in compliance with the License. |
| 6 | // You may obtain a copy of the License at |
| 7 | // |
| 8 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | // |
| 10 | // Unless required by applicable law or agreed to in writing, software |
| 11 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | // See the License for the specific language governing permissions and |
| 14 | // limitations under the License. |
| 15 | // |
| 16 | |
| 17 | #include <getopt.h> |
| 18 | #include <stdio.h> |
| 19 | #include <sysexits.h> |
Howard Chen | 3f6d5a6 | 2019-08-22 15:26:33 +0800 | [diff] [blame] | 20 | #include <unistd.h> |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 21 | |
David Anderson | c053b3b | 2019-01-08 18:22:07 -0800 | [diff] [blame] | 22 | #include <chrono> |
David Anderson | 6a5b8a7 | 2019-01-16 16:24:48 -0800 | [diff] [blame] | 23 | #include <condition_variable> |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 24 | #include <functional> |
| 25 | #include <iostream> |
| 26 | #include <map> |
David Anderson | 6a5b8a7 | 2019-01-16 16:24:48 -0800 | [diff] [blame] | 27 | #include <mutex> |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 28 | #include <string> |
David Anderson | 6a5b8a7 | 2019-01-16 16:24:48 -0800 | [diff] [blame] | 29 | #include <thread> |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 30 | |
David Anderson | 83fdeca | 2019-09-09 17:56:22 -0700 | [diff] [blame] | 31 | #include <android-base/logging.h> |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 32 | #include <android-base/parseint.h> |
David Anderson | c053b3b | 2019-01-08 18:22:07 -0800 | [diff] [blame] | 33 | #include <android-base/properties.h> |
Yo Chiang | 53bed1c | 2020-01-01 16:25:19 +0800 | [diff] [blame] | 34 | #include <android-base/stringprintf.h> |
Howard Chen | 4663de6 | 2019-11-05 20:46:20 +0800 | [diff] [blame] | 35 | #include <android-base/strings.h> |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 36 | #include <android-base/unique_fd.h> |
David Anderson | c053b3b | 2019-01-08 18:22:07 -0800 | [diff] [blame] | 37 | #include <android/gsi/IGsiService.h> |
David Anderson | 4c75673 | 2019-07-12 14:18:37 -0700 | [diff] [blame] | 38 | #include <android/gsi/IGsid.h> |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 39 | #include <binder/IServiceManager.h> |
David Anderson | b33f2b1 | 2019-01-22 14:14:10 -0800 | [diff] [blame] | 40 | #include <cutils/android_reboot.h> |
David Anderson | c053b3b | 2019-01-08 18:22:07 -0800 | [diff] [blame] | 41 | #include <libgsi/libgsi.h> |
David Anderson | 83fdeca | 2019-09-09 17:56:22 -0700 | [diff] [blame] | 42 | #include <libgsi/libgsid.h> |
David Anderson | c053b3b | 2019-01-08 18:22:07 -0800 | [diff] [blame] | 43 | |
| 44 | using namespace android::gsi; |
| 45 | using namespace std::chrono_literals; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 46 | |
| 47 | using android::sp; |
Howard Chen | 4663de6 | 2019-11-05 20:46:20 +0800 | [diff] [blame] | 48 | using android::base::Split; |
Yo Chiang | 53bed1c | 2020-01-01 16:25:19 +0800 | [diff] [blame] | 49 | using android::base::StringPrintf; |
David Anderson | c053b3b | 2019-01-08 18:22:07 -0800 | [diff] [blame] | 50 | using CommandCallback = std::function<int(sp<IGsiService>, int, char**)>; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 51 | |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 52 | static int Disable(sp<IGsiService> gsid, int argc, char** argv); |
| 53 | static int Enable(sp<IGsiService> gsid, int argc, char** argv); |
David Anderson | c053b3b | 2019-01-08 18:22:07 -0800 | [diff] [blame] | 54 | static int Install(sp<IGsiService> gsid, int argc, char** argv); |
| 55 | static int Wipe(sp<IGsiService> gsid, int argc, char** argv); |
David Anderson | 8bdf625 | 2019-06-11 16:43:24 -0700 | [diff] [blame] | 56 | static int WipeData(sp<IGsiService> gsid, int argc, char** argv); |
Howard Chen | f08428e | 2019-01-23 14:54:51 +0800 | [diff] [blame] | 57 | static int Status(sp<IGsiService> gsid, int argc, char** argv); |
Howard Chen | ecbc019 | 2019-02-25 18:51:26 +0800 | [diff] [blame] | 58 | static int Cancel(sp<IGsiService> gsid, int argc, char** argv); |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 59 | |
| 60 | static const std::map<std::string, CommandCallback> kCommandMap = { |
David Anderson | 5cc440c | 2019-04-16 14:34:27 -0700 | [diff] [blame] | 61 | // clang-format off |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 62 | {"disable", Disable}, |
| 63 | {"enable", Enable}, |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 64 | {"install", Install}, |
| 65 | {"wipe", Wipe}, |
David Anderson | 8bdf625 | 2019-06-11 16:43:24 -0700 | [diff] [blame] | 66 | {"wipe-data", WipeData}, |
Howard Chen | f08428e | 2019-01-23 14:54:51 +0800 | [diff] [blame] | 67 | {"status", Status}, |
Howard Chen | ecbc019 | 2019-02-25 18:51:26 +0800 | [diff] [blame] | 68 | {"cancel", Cancel}, |
David Anderson | 5cc440c | 2019-04-16 14:34:27 -0700 | [diff] [blame] | 69 | // clang-format on |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 70 | }; |
| 71 | |
David Anderson | 5cc440c | 2019-04-16 14:34:27 -0700 | [diff] [blame] | 72 | static std::string ErrorMessage(const android::binder::Status& status, |
| 73 | int error_code = IGsiService::INSTALL_ERROR_GENERIC) { |
David Anderson | 646b4b2 | 2019-02-27 18:26:54 -0800 | [diff] [blame] | 74 | if (!status.isOk()) { |
| 75 | return status.exceptionMessage().string(); |
| 76 | } |
| 77 | return "error code " + std::to_string(error_code); |
| 78 | } |
| 79 | |
David Anderson | 6a5b8a7 | 2019-01-16 16:24:48 -0800 | [diff] [blame] | 80 | class ProgressBar { |
| 81 | public: |
| 82 | explicit ProgressBar(sp<IGsiService> gsid) : gsid_(gsid) {} |
| 83 | |
| 84 | ~ProgressBar() { Stop(); } |
| 85 | |
| 86 | void Display() { |
David Anderson | b0f3c82 | 2019-01-31 19:19:02 -0800 | [diff] [blame] | 87 | Finish(); |
David Anderson | 6a5b8a7 | 2019-01-16 16:24:48 -0800 | [diff] [blame] | 88 | done_ = false; |
| 89 | last_update_ = {}; |
| 90 | worker_ = std::make_unique<std::thread>([this]() { Worker(); }); |
| 91 | } |
| 92 | |
| 93 | void Stop() { |
| 94 | if (!worker_) { |
| 95 | return; |
| 96 | } |
| 97 | SignalDone(); |
| 98 | worker_->join(); |
| 99 | worker_ = nullptr; |
| 100 | } |
| 101 | |
| 102 | void Finish() { |
David Anderson | b0f3c82 | 2019-01-31 19:19:02 -0800 | [diff] [blame] | 103 | if (!worker_) { |
| 104 | return; |
| 105 | } |
David Anderson | 6a5b8a7 | 2019-01-16 16:24:48 -0800 | [diff] [blame] | 106 | Stop(); |
| 107 | FinishLastBar(); |
| 108 | } |
| 109 | |
| 110 | private: |
| 111 | void Worker() { |
| 112 | std::unique_lock<std::mutex> lock(mutex_); |
| 113 | while (!done_) { |
| 114 | if (!UpdateProgress()) { |
| 115 | return; |
| 116 | } |
| 117 | cv_.wait_for(lock, 500ms, [this] { return done_; }); |
| 118 | } |
| 119 | } |
| 120 | |
| 121 | bool UpdateProgress() { |
| 122 | GsiProgress latest; |
| 123 | auto status = gsid_->getInstallProgress(&latest); |
| 124 | if (!status.isOk()) { |
| 125 | std::cout << std::endl; |
| 126 | return false; |
| 127 | } |
| 128 | if (latest.status == IGsiService::STATUS_NO_OPERATION) { |
| 129 | return true; |
| 130 | } |
| 131 | if (last_update_.step != latest.step) { |
| 132 | FinishLastBar(); |
| 133 | } |
| 134 | Display(latest); |
| 135 | return true; |
| 136 | } |
| 137 | |
| 138 | void FinishLastBar() { |
David Anderson | b0f3c82 | 2019-01-31 19:19:02 -0800 | [diff] [blame] | 139 | // If no bar was in progress, don't do anything. |
| 140 | if (last_update_.total_bytes == 0) { |
| 141 | return; |
| 142 | } |
David Anderson | 6a5b8a7 | 2019-01-16 16:24:48 -0800 | [diff] [blame] | 143 | // Ensure we finish the display at 100%. |
| 144 | last_update_.bytes_processed = last_update_.total_bytes; |
| 145 | Display(last_update_); |
| 146 | std::cout << std::endl; |
| 147 | } |
| 148 | |
| 149 | void Display(const GsiProgress& progress) { |
| 150 | if (progress.total_bytes == 0) { |
| 151 | return; |
| 152 | } |
| 153 | |
| 154 | static constexpr int kColumns = 80; |
| 155 | static constexpr char kRedColor[] = "\x1b[31m"; |
| 156 | static constexpr char kGreenColor[] = "\x1b[32m"; |
| 157 | static constexpr char kResetColor[] = "\x1b[0m"; |
| 158 | |
| 159 | int percentage = (progress.bytes_processed * 100) / progress.total_bytes; |
| 160 | int64_t bytes_per_col = progress.total_bytes / kColumns; |
| 161 | uint32_t fill_count = progress.bytes_processed / bytes_per_col; |
| 162 | uint32_t dash_count = kColumns - fill_count; |
| 163 | std::string fills = std::string(fill_count, '='); |
| 164 | std::string dashes = std::string(dash_count, '-'); |
| 165 | |
| 166 | // Give the end of the bar some flare. |
| 167 | if (!fills.empty() && !dashes.empty()) { |
| 168 | fills[fills.size() - 1] = '>'; |
| 169 | } |
| 170 | |
| 171 | fprintf(stdout, "\r%-15s%6d%% ", progress.step.c_str(), percentage); |
| 172 | fprintf(stdout, "%s[%s%s%s", kGreenColor, fills.c_str(), kRedColor, dashes.c_str()); |
| 173 | fprintf(stdout, "%s]%s", kGreenColor, kResetColor); |
| 174 | fflush(stdout); |
| 175 | |
| 176 | last_update_ = progress; |
| 177 | } |
| 178 | |
| 179 | void SignalDone() { |
| 180 | std::lock_guard<std::mutex> guard(mutex_); |
| 181 | done_ = true; |
| 182 | cv_.notify_all(); |
| 183 | } |
| 184 | |
| 185 | private: |
| 186 | sp<IGsiService> gsid_; |
| 187 | std::unique_ptr<std::thread> worker_; |
| 188 | std::condition_variable cv_; |
| 189 | std::mutex mutex_; |
| 190 | GsiProgress last_update_; |
| 191 | bool done_ = false; |
| 192 | }; |
| 193 | |
David Anderson | c053b3b | 2019-01-08 18:22:07 -0800 | [diff] [blame] | 194 | static int Install(sp<IGsiService> gsid, int argc, char** argv) { |
Howard Chen | 18109b1 | 2019-08-13 17:00:44 +0800 | [diff] [blame] | 195 | constexpr const char* kDefaultPartition = "system"; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 196 | struct option options[] = { |
David Anderson | eb30ac2 | 2019-03-12 15:24:53 -0700 | [diff] [blame] | 197 | {"install-dir", required_argument, nullptr, 'i'}, |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 198 | {"gsi-size", required_argument, nullptr, 's'}, |
David Anderson | b33f2b1 | 2019-01-22 14:14:10 -0800 | [diff] [blame] | 199 | {"no-reboot", no_argument, nullptr, 'n'}, |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 200 | {"userdata-size", required_argument, nullptr, 'u'}, |
Howard Chen | 18109b1 | 2019-08-13 17:00:44 +0800 | [diff] [blame] | 201 | {"partition-name", required_argument, nullptr, 'p'}, |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 202 | {"wipe", no_argument, nullptr, 'w'}, |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 203 | {nullptr, 0, nullptr, 0}, |
| 204 | }; |
| 205 | |
Paul Trautrim | 3c23df2 | 2019-12-11 16:18:22 +0900 | [diff] [blame] | 206 | int64_t gsiSize = 0; |
| 207 | int64_t userdataSize = 0; |
Howard Chen | 18109b1 | 2019-08-13 17:00:44 +0800 | [diff] [blame] | 208 | bool wipeUserdata = false; |
David Anderson | b33f2b1 | 2019-01-22 14:14:10 -0800 | [diff] [blame] | 209 | bool reboot = true; |
Howard Chen | 18109b1 | 2019-08-13 17:00:44 +0800 | [diff] [blame] | 210 | std::string installDir = ""; |
| 211 | std::string partition = kDefaultPartition; |
David Anderson | b5f44b3 | 2019-02-20 18:04:37 -0800 | [diff] [blame] | 212 | if (getuid() != 0) { |
| 213 | std::cerr << "must be root to install a GSI" << std::endl; |
| 214 | return EX_NOPERM; |
| 215 | } |
| 216 | |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 217 | int rv, index; |
| 218 | while ((rv = getopt_long_only(argc, argv, "", options, &index)) != -1) { |
| 219 | switch (rv) { |
Howard Chen | 18109b1 | 2019-08-13 17:00:44 +0800 | [diff] [blame] | 220 | case 'p': |
| 221 | partition = optarg; |
| 222 | break; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 223 | case 's': |
Howard Chen | 18109b1 | 2019-08-13 17:00:44 +0800 | [diff] [blame] | 224 | if (!android::base::ParseInt(optarg, &gsiSize) || gsiSize <= 0) { |
David Anderson | 550253b | 2019-02-08 17:55:27 -0800 | [diff] [blame] | 225 | std::cerr << "Could not parse image size: " << optarg << std::endl; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 226 | return EX_USAGE; |
| 227 | } |
| 228 | break; |
| 229 | case 'u': |
Howard Chen | 18109b1 | 2019-08-13 17:00:44 +0800 | [diff] [blame] | 230 | if (!android::base::ParseInt(optarg, &userdataSize) || userdataSize < 0) { |
David Anderson | 550253b | 2019-02-08 17:55:27 -0800 | [diff] [blame] | 231 | std::cerr << "Could not parse image size: " << optarg << std::endl; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 232 | return EX_USAGE; |
| 233 | } |
| 234 | break; |
David Anderson | eb30ac2 | 2019-03-12 15:24:53 -0700 | [diff] [blame] | 235 | case 'i': |
Howard Chen | 18109b1 | 2019-08-13 17:00:44 +0800 | [diff] [blame] | 236 | installDir = optarg; |
David Anderson | eb30ac2 | 2019-03-12 15:24:53 -0700 | [diff] [blame] | 237 | break; |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 238 | case 'w': |
Howard Chen | 18109b1 | 2019-08-13 17:00:44 +0800 | [diff] [blame] | 239 | wipeUserdata = true; |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 240 | break; |
David Anderson | b33f2b1 | 2019-01-22 14:14:10 -0800 | [diff] [blame] | 241 | case 'n': |
| 242 | reboot = false; |
| 243 | break; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 244 | } |
| 245 | } |
| 246 | |
Howard Chen | 18109b1 | 2019-08-13 17:00:44 +0800 | [diff] [blame] | 247 | if (gsiSize <= 0) { |
David Anderson | 550253b | 2019-02-08 17:55:27 -0800 | [diff] [blame] | 248 | std::cerr << "Must specify --gsi-size." << std::endl; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 249 | return EX_USAGE; |
| 250 | } |
| 251 | |
David Anderson | a78f811 | 2019-01-17 11:50:50 -0800 | [diff] [blame] | 252 | bool running_gsi = false; |
| 253 | gsid->isGsiRunning(&running_gsi); |
| 254 | if (running_gsi) { |
David Anderson | 550253b | 2019-02-08 17:55:27 -0800 | [diff] [blame] | 255 | std::cerr << "Cannot install a GSI within a live GSI." << std::endl; |
| 256 | std::cerr << "Use gsi_tool disable or wipe and reboot first." << std::endl; |
David Anderson | a78f811 | 2019-01-17 11:50:50 -0800 | [diff] [blame] | 257 | return EX_SOFTWARE; |
| 258 | } |
| 259 | |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 260 | android::base::unique_fd input(dup(1)); |
| 261 | if (input < 0) { |
David Anderson | 550253b | 2019-02-08 17:55:27 -0800 | [diff] [blame] | 262 | std::cerr << "Error duplicating descriptor: " << strerror(errno) << std::endl; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 263 | return EX_SOFTWARE; |
| 264 | } |
David Anderson | 6a5b8a7 | 2019-01-16 16:24:48 -0800 | [diff] [blame] | 265 | // Note: the progress bar needs to be re-started in between each call. |
| 266 | ProgressBar progress(gsid); |
David Anderson | 6a5b8a7 | 2019-01-16 16:24:48 -0800 | [diff] [blame] | 267 | progress.Display(); |
David Anderson | 868dea5 | 2019-01-17 13:34:38 -0800 | [diff] [blame] | 268 | int error; |
Howard Chen | 4663de6 | 2019-11-05 20:46:20 +0800 | [diff] [blame] | 269 | auto status = gsid->openInstall(installDir, &error); |
| 270 | if (!status.isOk() || error != IGsiService::INSTALL_OK) { |
Yo Chiang | 99b12d0 | 2019-12-02 15:47:57 +0800 | [diff] [blame] | 271 | std::cerr << "Could not open DSU installation: " << ErrorMessage(status, error) << "\n"; |
Howard Chen | 4663de6 | 2019-11-05 20:46:20 +0800 | [diff] [blame] | 272 | return EX_SOFTWARE; |
| 273 | } |
Howard Chen | 18109b1 | 2019-08-13 17:00:44 +0800 | [diff] [blame] | 274 | if (partition == kDefaultPartition) { |
Howard Chen | 4663de6 | 2019-11-05 20:46:20 +0800 | [diff] [blame] | 275 | auto status = gsid->createPartition("userdata", userdataSize, false, &error); |
Howard Chen | 18109b1 | 2019-08-13 17:00:44 +0800 | [diff] [blame] | 276 | if (!status.isOk() || error != IGsiService::INSTALL_OK) { |
| 277 | std::cerr << "Could not start live image install: " << ErrorMessage(status, error) |
| 278 | << "\n"; |
| 279 | return EX_SOFTWARE; |
| 280 | } |
| 281 | } |
Howard Chen | 18109b1 | 2019-08-13 17:00:44 +0800 | [diff] [blame] | 282 | |
Howard Chen | 4663de6 | 2019-11-05 20:46:20 +0800 | [diff] [blame] | 283 | status = gsid->createPartition(partition, gsiSize, true, &error); |
David Anderson | 868dea5 | 2019-01-17 13:34:38 -0800 | [diff] [blame] | 284 | if (!status.isOk() || error != IGsiService::INSTALL_OK) { |
David Anderson | 646b4b2 | 2019-02-27 18:26:54 -0800 | [diff] [blame] | 285 | std::cerr << "Could not start live image install: " << ErrorMessage(status, error) << "\n"; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 286 | return EX_SOFTWARE; |
| 287 | } |
David Anderson | 1d94d26 | 2019-01-11 20:39:51 -0800 | [diff] [blame] | 288 | android::os::ParcelFileDescriptor stream(std::move(input)); |
| 289 | |
David Anderson | 868dea5 | 2019-01-17 13:34:38 -0800 | [diff] [blame] | 290 | bool ok = false; |
David Anderson | 6a5b8a7 | 2019-01-16 16:24:48 -0800 | [diff] [blame] | 291 | progress.Display(); |
Howard Chen | 4663de6 | 2019-11-05 20:46:20 +0800 | [diff] [blame] | 292 | status = gsid->commitGsiChunkFromStream(stream, gsiSize, &ok); |
David Anderson | 6a5b8a7 | 2019-01-16 16:24:48 -0800 | [diff] [blame] | 293 | if (!ok) { |
David Anderson | 646b4b2 | 2019-02-27 18:26:54 -0800 | [diff] [blame] | 294 | std::cerr << "Could not commit live image data: " << ErrorMessage(status) << "\n"; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 295 | return EX_SOFTWARE; |
| 296 | } |
| 297 | |
Howard Chen | 4663de6 | 2019-11-05 20:46:20 +0800 | [diff] [blame] | 298 | status = gsid->closeInstall(&error); |
| 299 | if (!status.isOk() || error != IGsiService::INSTALL_OK) { |
| 300 | std::cerr << "Could not close DSU installation: " << ErrorMessage(status, error) << "\n"; |
| 301 | return EX_SOFTWARE; |
| 302 | } |
David Anderson | 6a5b8a7 | 2019-01-16 16:24:48 -0800 | [diff] [blame] | 303 | progress.Finish(); |
Howard Chen | ee5c2b1 | 2019-11-08 11:57:47 +0800 | [diff] [blame] | 304 | std::string dsuSlot; |
| 305 | status = gsid->getActiveDsuSlot(&dsuSlot); |
| 306 | if (!status.isOk()) { |
| 307 | std::cerr << "Could not get the active DSU slot: " << ErrorMessage(status) << "\n"; |
| 308 | return EX_SOFTWARE; |
| 309 | } |
| 310 | status = gsid->enableGsi(true, dsuSlot, &error); |
David Anderson | 868dea5 | 2019-01-17 13:34:38 -0800 | [diff] [blame] | 311 | if (!status.isOk() || error != IGsiService::INSTALL_OK) { |
David Anderson | 646b4b2 | 2019-02-27 18:26:54 -0800 | [diff] [blame] | 312 | std::cerr << "Could not make live image bootable: " << ErrorMessage(status, error) << "\n"; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 313 | return EX_SOFTWARE; |
| 314 | } |
David Anderson | b33f2b1 | 2019-01-22 14:14:10 -0800 | [diff] [blame] | 315 | |
| 316 | if (reboot) { |
| 317 | if (!android::base::SetProperty(ANDROID_RB_PROPERTY, "reboot,adb")) { |
David Anderson | 550253b | 2019-02-08 17:55:27 -0800 | [diff] [blame] | 318 | std::cerr << "Failed to reboot automatically" << std::endl; |
David Anderson | b33f2b1 | 2019-01-22 14:14:10 -0800 | [diff] [blame] | 319 | return EX_SOFTWARE; |
| 320 | } |
| 321 | } else { |
| 322 | std::cout << "Please reboot to use the GSI." << std::endl; |
| 323 | } |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 324 | return 0; |
| 325 | } |
| 326 | |
David Anderson | c053b3b | 2019-01-08 18:22:07 -0800 | [diff] [blame] | 327 | static int Wipe(sp<IGsiService> gsid, int argc, char** /* argv */) { |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 328 | if (argc > 1) { |
David Anderson | 550253b | 2019-02-08 17:55:27 -0800 | [diff] [blame] | 329 | std::cerr << "Unrecognized arguments to wipe." << std::endl; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 330 | return EX_USAGE; |
| 331 | } |
David Anderson | c053b3b | 2019-01-08 18:22:07 -0800 | [diff] [blame] | 332 | bool ok; |
Howard Chen | 25b18cc | 2019-08-02 11:21:58 +0800 | [diff] [blame] | 333 | auto status = gsid->removeGsi(&ok); |
David Anderson | c053b3b | 2019-01-08 18:22:07 -0800 | [diff] [blame] | 334 | if (!status.isOk() || !ok) { |
David Anderson | 646b4b2 | 2019-02-27 18:26:54 -0800 | [diff] [blame] | 335 | std::cerr << "Could not remove GSI install: " << ErrorMessage(status) << "\n"; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 336 | return EX_SOFTWARE; |
| 337 | } |
David Anderson | 5f80591 | 2019-03-07 12:41:15 -0800 | [diff] [blame] | 338 | |
| 339 | bool running = false; |
| 340 | if (gsid->isGsiRunning(&running).isOk() && running) { |
| 341 | std::cout << "Live image install will be removed next reboot." << std::endl; |
| 342 | } else { |
| 343 | std::cout << "Live image install successfully removed." << std::endl; |
| 344 | } |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 345 | return 0; |
| 346 | } |
| 347 | |
David Anderson | 8bdf625 | 2019-06-11 16:43:24 -0700 | [diff] [blame] | 348 | static int WipeData(sp<IGsiService> gsid, int argc, char** /* argv */) { |
| 349 | if (argc > 1) { |
| 350 | std::cerr << "Unrecognized arguments to wipe-data.\n"; |
| 351 | return EX_USAGE; |
| 352 | } |
| 353 | |
| 354 | bool running; |
| 355 | auto status = gsid->isGsiRunning(&running); |
| 356 | if (!status.isOk()) { |
| 357 | std::cerr << "error: " << status.exceptionMessage().string() << std::endl; |
| 358 | return EX_SOFTWARE; |
| 359 | } |
| 360 | if (running) { |
| 361 | std::cerr << "Cannot wipe GSI userdata while running a GSI.\n"; |
| 362 | return EX_USAGE; |
| 363 | } |
| 364 | |
| 365 | bool installed; |
| 366 | status = gsid->isGsiInstalled(&installed); |
| 367 | if (!status.isOk()) { |
| 368 | std::cerr << "error: " << status.exceptionMessage().string() << std::endl; |
| 369 | return EX_SOFTWARE; |
| 370 | } |
| 371 | if (!installed) { |
| 372 | std::cerr << "No GSI is installed.\n"; |
| 373 | return EX_USAGE; |
| 374 | } |
| 375 | |
| 376 | int error; |
Howard Chen | 423129b | 2020-03-03 13:28:37 +0800 | [diff] [blame^] | 377 | status = gsid->zeroPartition("userdata" + std::string(kDsuPostfix), &error); |
David Anderson | 8bdf625 | 2019-06-11 16:43:24 -0700 | [diff] [blame] | 378 | if (!status.isOk() || error) { |
| 379 | std::cerr << "Could not wipe GSI userdata: " << ErrorMessage(status, error) << "\n"; |
| 380 | return EX_SOFTWARE; |
| 381 | } |
| 382 | return 0; |
| 383 | } |
| 384 | |
Howard Chen | f08428e | 2019-01-23 14:54:51 +0800 | [diff] [blame] | 385 | static int Status(sp<IGsiService> gsid, int argc, char** /* argv */) { |
| 386 | if (argc > 1) { |
David Anderson | 550253b | 2019-02-08 17:55:27 -0800 | [diff] [blame] | 387 | std::cerr << "Unrecognized arguments to status." << std::endl; |
Howard Chen | f08428e | 2019-01-23 14:54:51 +0800 | [diff] [blame] | 388 | return EX_USAGE; |
| 389 | } |
| 390 | bool running; |
| 391 | auto status = gsid->isGsiRunning(&running); |
| 392 | if (!status.isOk()) { |
David Anderson | 646b4b2 | 2019-02-27 18:26:54 -0800 | [diff] [blame] | 393 | std::cerr << "error: " << status.exceptionMessage().string() << std::endl; |
Howard Chen | f08428e | 2019-01-23 14:54:51 +0800 | [diff] [blame] | 394 | return EX_SOFTWARE; |
| 395 | } else if (running) { |
| 396 | std::cout << "running" << std::endl; |
Howard Chen | f08428e | 2019-01-23 14:54:51 +0800 | [diff] [blame] | 397 | } |
| 398 | bool installed; |
| 399 | status = gsid->isGsiInstalled(&installed); |
| 400 | if (!status.isOk()) { |
David Anderson | 646b4b2 | 2019-02-27 18:26:54 -0800 | [diff] [blame] | 401 | std::cerr << "error: " << status.exceptionMessage().string() << std::endl; |
Howard Chen | f08428e | 2019-01-23 14:54:51 +0800 | [diff] [blame] | 402 | return EX_SOFTWARE; |
| 403 | } else if (installed) { |
| 404 | std::cout << "installed" << std::endl; |
Howard Chen | f08428e | 2019-01-23 14:54:51 +0800 | [diff] [blame] | 405 | } |
Howard Chen | 670b306 | 2019-02-26 18:14:47 +0800 | [diff] [blame] | 406 | bool enabled; |
| 407 | status = gsid->isGsiEnabled(&enabled); |
| 408 | if (!status.isOk()) { |
| 409 | std::cerr << status.exceptionMessage().string() << std::endl; |
| 410 | return EX_SOFTWARE; |
| 411 | } else if (running || installed) { |
| 412 | std::cout << (enabled ? "enabled" : "disabled") << std::endl; |
| 413 | } else { |
| 414 | std::cout << "normal" << std::endl; |
| 415 | } |
Howard Chen | 96c31fd | 2019-08-23 17:38:51 +0800 | [diff] [blame] | 416 | if (getuid() != 0) { |
| 417 | return 0; |
| 418 | } |
Howard Chen | 96c31fd | 2019-08-23 17:38:51 +0800 | [diff] [blame] | 419 | |
Howard Chen | ee5c2b1 | 2019-11-08 11:57:47 +0800 | [diff] [blame] | 420 | std::vector<std::string> dsu_slots; |
| 421 | status = gsid->getInstalledDsuSlots(&dsu_slots); |
| 422 | if (!status.isOk()) { |
| 423 | std::cerr << status.exceptionMessage().string() << std::endl; |
| 424 | return EX_SOFTWARE; |
| 425 | } |
| 426 | int n = 0; |
| 427 | for (auto&& dsu_slot : dsu_slots) { |
| 428 | std::cout << "[" << n++ << "] " << dsu_slot << std::endl; |
| 429 | sp<IImageService> image_service = nullptr; |
| 430 | status = gsid->openImageService("dsu/" + dsu_slot + "/", &image_service); |
| 431 | if (!status.isOk()) { |
| 432 | std::cerr << "error: " << status.exceptionMessage().string() << std::endl; |
| 433 | return EX_SOFTWARE; |
| 434 | } |
| 435 | std::vector<std::string> images; |
| 436 | status = image_service->getAllBackingImages(&images); |
| 437 | if (!status.isOk()) { |
| 438 | std::cerr << "error: " << status.exceptionMessage().string() << std::endl; |
| 439 | return EX_SOFTWARE; |
| 440 | } |
| 441 | for (auto&& image : images) { |
| 442 | std::cout << "installed: " << image << std::endl; |
Yo Chiang | 53bed1c | 2020-01-01 16:25:19 +0800 | [diff] [blame] | 443 | AvbPublicKey public_key; |
| 444 | int err = 0; |
| 445 | status = image_service->getAvbPublicKey(image, &public_key, &err); |
| 446 | std::cout << "AVB public key (sha1): "; |
| 447 | if (!public_key.bytes.empty()) { |
| 448 | for (auto b : public_key.sha1) { |
| 449 | std::cout << StringPrintf("%02x", b & 255); |
| 450 | } |
| 451 | std::cout << std::endl; |
| 452 | } else { |
| 453 | std::cout << "[NONE]" << std::endl; |
| 454 | } |
Howard Chen | ee5c2b1 | 2019-11-08 11:57:47 +0800 | [diff] [blame] | 455 | } |
Howard Chen | 96c31fd | 2019-08-23 17:38:51 +0800 | [diff] [blame] | 456 | } |
Howard Chen | f08428e | 2019-01-23 14:54:51 +0800 | [diff] [blame] | 457 | return 0; |
| 458 | } |
| 459 | |
Howard Chen | ecbc019 | 2019-02-25 18:51:26 +0800 | [diff] [blame] | 460 | static int Cancel(sp<IGsiService> gsid, int /* argc */, char** /* argv */) { |
| 461 | bool cancelled = false; |
| 462 | auto status = gsid->cancelGsiInstall(&cancelled); |
| 463 | if (!status.isOk()) { |
| 464 | std::cerr << status.exceptionMessage().string() << std::endl; |
| 465 | return EX_SOFTWARE; |
| 466 | } |
| 467 | if (!cancelled) { |
| 468 | std::cout << "Fail to cancel the installation." << std::endl; |
| 469 | return EX_SOFTWARE; |
| 470 | } |
| 471 | return 0; |
| 472 | } |
| 473 | |
David Anderson | 564a04c | 2019-02-27 13:33:44 -0800 | [diff] [blame] | 474 | static int Enable(sp<IGsiService> gsid, int argc, char** argv) { |
| 475 | bool one_shot = false; |
Howard Chen | ee5c2b1 | 2019-11-08 11:57:47 +0800 | [diff] [blame] | 476 | std::string dsuSlot = {}; |
David Anderson | 564a04c | 2019-02-27 13:33:44 -0800 | [diff] [blame] | 477 | struct option options[] = { |
| 478 | {"single-boot", no_argument, nullptr, 's'}, |
Howard Chen | ee5c2b1 | 2019-11-08 11:57:47 +0800 | [diff] [blame] | 479 | {"dsuslot", required_argument, nullptr, 'd'}, |
David Anderson | 564a04c | 2019-02-27 13:33:44 -0800 | [diff] [blame] | 480 | {nullptr, 0, nullptr, 0}, |
| 481 | }; |
| 482 | int rv, index; |
| 483 | while ((rv = getopt_long_only(argc, argv, "", options, &index)) != -1) { |
| 484 | switch (rv) { |
| 485 | case 's': |
| 486 | one_shot = true; |
| 487 | break; |
Howard Chen | ee5c2b1 | 2019-11-08 11:57:47 +0800 | [diff] [blame] | 488 | case 'd': |
| 489 | dsuSlot = optarg; |
| 490 | break; |
David Anderson | 564a04c | 2019-02-27 13:33:44 -0800 | [diff] [blame] | 491 | default: |
| 492 | std::cerr << "Unrecognized argument to enable\n"; |
| 493 | return EX_USAGE; |
| 494 | } |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 495 | } |
| 496 | |
| 497 | bool installed = false; |
| 498 | gsid->isGsiInstalled(&installed); |
| 499 | if (!installed) { |
David Anderson | 550253b | 2019-02-08 17:55:27 -0800 | [diff] [blame] | 500 | std::cerr << "Could not find GSI install to re-enable" << std::endl; |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 501 | return EX_SOFTWARE; |
| 502 | } |
| 503 | |
| 504 | bool installing = false; |
| 505 | gsid->isGsiInstallInProgress(&installing); |
| 506 | if (installing) { |
David Anderson | 550253b | 2019-02-08 17:55:27 -0800 | [diff] [blame] | 507 | std::cerr << "Cannot enable or disable while an installation is in progress." << std::endl; |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 508 | return EX_SOFTWARE; |
| 509 | } |
Howard Chen | ee5c2b1 | 2019-11-08 11:57:47 +0800 | [diff] [blame] | 510 | if (dsuSlot.empty()) { |
| 511 | auto status = gsid->getActiveDsuSlot(&dsuSlot); |
| 512 | if (!status.isOk()) { |
| 513 | std::cerr << "Could not get the active DSU slot: " << ErrorMessage(status) << "\n"; |
| 514 | return EX_SOFTWARE; |
| 515 | } |
| 516 | } |
David Anderson | 868dea5 | 2019-01-17 13:34:38 -0800 | [diff] [blame] | 517 | int error; |
Howard Chen | ee5c2b1 | 2019-11-08 11:57:47 +0800 | [diff] [blame] | 518 | auto status = gsid->enableGsi(one_shot, dsuSlot, &error); |
David Anderson | 868dea5 | 2019-01-17 13:34:38 -0800 | [diff] [blame] | 519 | if (!status.isOk() || error != IGsiService::INSTALL_OK) { |
David Anderson | 646b4b2 | 2019-02-27 18:26:54 -0800 | [diff] [blame] | 520 | std::cerr << "Error re-enabling GSI: " << ErrorMessage(status, error) << "\n"; |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 521 | return EX_SOFTWARE; |
| 522 | } |
| 523 | std::cout << "Live image install successfully enabled." << std::endl; |
| 524 | return 0; |
| 525 | } |
| 526 | |
| 527 | static int Disable(sp<IGsiService> gsid, int argc, char** /* argv */) { |
| 528 | if (argc > 1) { |
David Anderson | 550253b | 2019-02-08 17:55:27 -0800 | [diff] [blame] | 529 | std::cerr << "Unrecognized arguments to disable." << std::endl; |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 530 | return EX_USAGE; |
| 531 | } |
| 532 | |
| 533 | bool installing = false; |
| 534 | gsid->isGsiInstallInProgress(&installing); |
| 535 | if (installing) { |
David Anderson | 550253b | 2019-02-08 17:55:27 -0800 | [diff] [blame] | 536 | std::cerr << "Cannot enable or disable while an installation is in progress." << std::endl; |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 537 | return EX_SOFTWARE; |
| 538 | } |
| 539 | |
| 540 | bool ok = false; |
Howard Chen | 25b18cc | 2019-08-02 11:21:58 +0800 | [diff] [blame] | 541 | gsid->disableGsi(&ok); |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 542 | if (!ok) { |
David Anderson | 550253b | 2019-02-08 17:55:27 -0800 | [diff] [blame] | 543 | std::cerr << "Error disabling GSI" << std::endl; |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 544 | return EX_SOFTWARE; |
| 545 | } |
| 546 | std::cout << "Live image install successfully disabled." << std::endl; |
| 547 | return 0; |
| 548 | } |
| 549 | |
| 550 | static int usage(int /* argc */, char* argv[]) { |
| 551 | fprintf(stderr, |
| 552 | "%s - command-line tool for installing GSI images.\n" |
| 553 | "\n" |
| 554 | "Usage:\n" |
Howard Chen | f08428e | 2019-01-23 14:54:51 +0800 | [diff] [blame] | 555 | " %s <disable|install|wipe|status> [options]\n" |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 556 | "\n" |
| 557 | " disable Disable the currently installed GSI.\n" |
Howard Chen | ee5c2b1 | 2019-11-08 11:57:47 +0800 | [diff] [blame] | 558 | " enable [-s, --single-boot]\n" |
| 559 | " [-d, --dsuslot slotname]\n" |
David Anderson | 564a04c | 2019-02-27 13:33:44 -0800 | [diff] [blame] | 560 | " Enable a previously disabled GSI.\n" |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 561 | " install Install a new GSI. Specify the image size with\n" |
| 562 | " --gsi-size and the desired userdata size with\n" |
| 563 | " --userdata-size (the latter defaults to 8GiB)\n" |
| 564 | " --wipe (remove old gsi userdata first)\n" |
Howard Chen | f08428e | 2019-01-23 14:54:51 +0800 | [diff] [blame] | 565 | " wipe Completely remove a GSI and its associated data\n" |
David Anderson | 8bdf625 | 2019-06-11 16:43:24 -0700 | [diff] [blame] | 566 | " wipe-data Ensure the GSI's userdata will be formatted\n" |
Howard Chen | ecbc019 | 2019-02-25 18:51:26 +0800 | [diff] [blame] | 567 | " cancel Cancel the installation\n" |
| 568 | " status Show status\n", |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 569 | argv[0], argv[0]); |
| 570 | return EX_USAGE; |
| 571 | } |
| 572 | |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 573 | int main(int argc, char** argv) { |
David Anderson | 83fdeca | 2019-09-09 17:56:22 -0700 | [diff] [blame] | 574 | android::base::InitLogging(argv, android::base::StdioLogger, android::base::DefaultAborter); |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 575 | |
David Anderson | 83fdeca | 2019-09-09 17:56:22 -0700 | [diff] [blame] | 576 | android::sp<IGsiService> service = GetGsiService(); |
| 577 | if (!service) { |
David Anderson | 4c75673 | 2019-07-12 14:18:37 -0700 | [diff] [blame] | 578 | return EX_SOFTWARE; |
| 579 | } |
| 580 | |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 581 | if (1 >= argc) { |
David Anderson | 550253b | 2019-02-08 17:55:27 -0800 | [diff] [blame] | 582 | std::cerr << "Expected command." << std::endl; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 583 | return EX_USAGE; |
| 584 | } |
| 585 | |
| 586 | std::string command = argv[1]; |
David Anderson | 34502be | 2019-02-01 18:06:20 -0800 | [diff] [blame] | 587 | |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 588 | auto iter = kCommandMap.find(command); |
| 589 | if (iter == kCommandMap.end()) { |
David Anderson | 550253b | 2019-02-08 17:55:27 -0800 | [diff] [blame] | 590 | std::cerr << "Unrecognized command: " << command << std::endl; |
David Anderson | a141ba8 | 2019-01-14 19:09:27 -0800 | [diff] [blame] | 591 | return usage(argc, argv); |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 592 | } |
David Anderson | c053b3b | 2019-01-08 18:22:07 -0800 | [diff] [blame] | 593 | |
David Anderson | 4c75673 | 2019-07-12 14:18:37 -0700 | [diff] [blame] | 594 | int rc = iter->second(service, argc - 1, argv + 1); |
David Anderson | c053b3b | 2019-01-08 18:22:07 -0800 | [diff] [blame] | 595 | return rc; |
David Anderson | ee84d74 | 2019-01-07 18:10:29 -0800 | [diff] [blame] | 596 | } |