The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2007 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 | |
Jerry Zhang | 6a64804 | 2018-05-04 11:24:10 -0700 | [diff] [blame] | 17 | #include "recovery.h" |
Tao Bao | 2ac56af | 2018-04-25 16:47:04 -0700 | [diff] [blame] | 18 | |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 19 | #include <ctype.h> |
| 20 | #include <errno.h> |
| 21 | #include <fcntl.h> |
| 22 | #include <getopt.h> |
Tao Bao | 862a4c1 | 2016-06-02 11:16:50 -0700 | [diff] [blame] | 23 | #include <inttypes.h> |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 24 | #include <limits.h> |
Tao Bao | 862a4c1 | 2016-06-02 11:16:50 -0700 | [diff] [blame] | 25 | #include <linux/fs.h> |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 26 | #include <linux/input.h> |
| 27 | #include <stdio.h> |
| 28 | #include <stdlib.h> |
| 29 | #include <string.h> |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 30 | #include <sys/types.h> |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 31 | #include <unistd.h> |
| 32 | |
Tao Bao | c4a18ef | 2017-02-10 00:13:30 -0800 | [diff] [blame] | 33 | #include <algorithm> |
Tao Bao | 3aec696 | 2018-04-20 09:24:58 -0700 | [diff] [blame] | 34 | #include <functional> |
Tao Bao | c4a18ef | 2017-02-10 00:13:30 -0800 | [diff] [blame] | 35 | #include <memory> |
Tao Bao | 862a4c1 | 2016-06-02 11:16:50 -0700 | [diff] [blame] | 36 | #include <string> |
| 37 | #include <vector> |
Tao Bao | 04ca426 | 2015-09-10 15:32:24 -0700 | [diff] [blame] | 38 | |
Elliott Hughes | 4b166f0 | 2015-12-04 15:30:20 -0800 | [diff] [blame] | 39 | #include <android-base/file.h> |
Tianjie Xu | 7b0ad9c | 2016-08-05 18:00:04 -0700 | [diff] [blame] | 40 | #include <android-base/logging.h> |
Tianjie Xu | 3c62b67 | 2016-02-05 18:25:58 -0800 | [diff] [blame] | 41 | #include <android-base/parseint.h> |
Elliott Hughes | cb22040 | 2016-09-23 15:30:55 -0700 | [diff] [blame] | 42 | #include <android-base/properties.h> |
Elliott Hughes | 4b166f0 | 2015-12-04 15:30:20 -0800 | [diff] [blame] | 43 | #include <android-base/stringprintf.h> |
Tao Bao | 862a4c1 | 2016-06-02 11:16:50 -0700 | [diff] [blame] | 44 | #include <android-base/strings.h> |
| 45 | #include <android-base/unique_fd.h> |
Yabin Cui | 8b309f6 | 2016-06-24 18:22:02 -0700 | [diff] [blame] | 46 | #include <bootloader_message/bootloader_message.h> |
Elliott Hughes | cb22040 | 2016-09-23 15:30:55 -0700 | [diff] [blame] | 47 | #include <cutils/properties.h> /* for property_list */ |
Yifan Hong | 056538c | 2018-07-11 17:04:12 -0700 | [diff] [blame] | 48 | #include <healthhalutils/HealthHalUtils.h> |
Tianjie Xu | 8cf5c8f | 2016-09-08 20:10:11 -0700 | [diff] [blame] | 49 | #include <ziparchive/zip_archive.h> |
Yabin Cui | 99281df | 2016-02-17 12:21:52 -0800 | [diff] [blame] | 50 | |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 51 | #include "common.h" |
David Anderson | edee836 | 2018-05-16 13:43:22 -0700 | [diff] [blame] | 52 | #include "fsck_unshare_blocks.h" |
xunchang | 2478885 | 2019-03-22 16:08:52 -0700 | [diff] [blame] | 53 | #include "install/adb_install.h" |
| 54 | #include "install/fuse_sdcard_install.h" |
| 55 | #include "install/install.h" |
| 56 | #include "install/package.h" |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 57 | #include "install/wipe_data.h" |
Tao Bao | 1fc5bf3 | 2017-10-06 07:43:41 -0700 | [diff] [blame] | 58 | #include "otautil/error_code.h" |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 59 | #include "otautil/logging.h" |
Tao Bao | 641fa97 | 2018-04-25 18:59:40 -0700 | [diff] [blame] | 60 | #include "otautil/paths.h" |
xunchang | 2478885 | 2019-03-22 16:08:52 -0700 | [diff] [blame] | 61 | #include "otautil/roots.h" |
Tao Bao | 2c52639 | 2018-05-03 23:01:13 -0700 | [diff] [blame] | 62 | #include "otautil/sysutil.h" |
Tianjie Xu | 8f39730 | 2018-08-20 13:40:47 -0700 | [diff] [blame] | 63 | #include "recovery_ui/screen_ui.h" |
| 64 | #include "recovery_ui/ui.h" |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 65 | |
Tao Bao | aac9d9f | 2018-04-29 23:38:59 -0700 | [diff] [blame] | 66 | static constexpr const char* COMMAND_FILE = "/cache/recovery/command"; |
Tao Bao | aac9d9f | 2018-04-29 23:38:59 -0700 | [diff] [blame] | 67 | static constexpr const char* LAST_KMSG_FILE = "/cache/recovery/last_kmsg"; |
| 68 | static constexpr const char* LAST_LOG_FILE = "/cache/recovery/last_log"; |
| 69 | static constexpr const char* LOCALE_FILE = "/cache/recovery/last_locale"; |
Tianjie Xu | 06e57ac | 2016-07-11 14:04:08 -0700 | [diff] [blame] | 70 | |
Tao Bao | aac9d9f | 2018-04-29 23:38:59 -0700 | [diff] [blame] | 71 | static constexpr const char* CACHE_ROOT = "/cache"; |
Nick Kralevich | a9ad032 | 2014-10-22 18:38:48 -0700 | [diff] [blame] | 72 | |
Tao Bao | bd0ddcd | 2017-05-04 13:03:18 -0700 | [diff] [blame] | 73 | // We define RECOVERY_API_VERSION in Android.mk, which will be picked up by build system and packed |
| 74 | // into target_files.zip. Assert the version defined in code and in Android.mk are consistent. |
| 75 | static_assert(kRecoveryApiVersion == RECOVERY_API_VERSION, "Mismatching recovery API versions."); |
| 76 | |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 77 | static bool save_current_log = false; |
Tao Bao | a8d72bc | 2016-12-25 18:46:50 -0800 | [diff] [blame] | 78 | std::string stage; |
Tao Bao | ac9d94d | 2016-11-03 11:37:15 -0700 | [diff] [blame] | 79 | const char* reason = nullptr; |
Tao Bao | ac9d94d | 2016-11-03 11:37:15 -0700 | [diff] [blame] | 80 | |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 81 | /* |
| 82 | * The recovery tool communicates with the main system through /cache files. |
| 83 | * /cache/recovery/command - INPUT - command line for tool, one arg per line |
| 84 | * /cache/recovery/log - OUTPUT - combined log file from recovery run(s) |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 85 | * |
| 86 | * The arguments which may be supplied in the recovery.command file: |
Doug Zongker | d4208f9 | 2010-09-20 12:16:13 -0700 | [diff] [blame] | 87 | * --update_package=path - verify install an OTA package file |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 88 | * --wipe_data - erase user data (and cache), then reboot |
Tao Bao | f9f1734 | 2018-04-27 10:44:04 -0700 | [diff] [blame] | 89 | * --prompt_and_wipe_data - prompt the user that data is corrupt, with their consent erase user |
| 90 | * data (and cache), then reboot |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 91 | * --wipe_cache - wipe cache (but not user data), then reboot |
Tao Bao | f9f1734 | 2018-04-27 10:44:04 -0700 | [diff] [blame] | 92 | * --show_text - show the recovery text menu, used by some bootloader (e.g. http://b/36872519). |
Oscar Montemayor | 0523156 | 2009-11-30 08:40:57 -0800 | [diff] [blame] | 93 | * --set_encrypted_filesystem=on|off - enables / diasables encrypted fs |
Doug Zongker | e5d5ac7 | 2012-04-12 11:01:22 -0700 | [diff] [blame] | 94 | * --just_exit - do nothing; exit and reboot |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 95 | * |
| 96 | * After completing, we remove /cache/recovery/command and reboot. |
| 97 | * Arguments may also be supplied in the bootloader control block (BCB). |
| 98 | * These important scenarios must be safely restartable at any point: |
| 99 | * |
| 100 | * FACTORY RESET |
| 101 | * 1. user selects "factory reset" |
| 102 | * 2. main system writes "--wipe_data" to /cache/recovery/command |
| 103 | * 3. main system reboots into recovery |
| 104 | * 4. get_args() writes BCB with "boot-recovery" and "--wipe_data" |
| 105 | * -- after this, rebooting will restart the erase -- |
Doug Zongker | d4208f9 | 2010-09-20 12:16:13 -0700 | [diff] [blame] | 106 | * 5. erase_volume() reformats /data |
| 107 | * 6. erase_volume() reformats /cache |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 108 | * 7. finish_recovery() erases BCB |
| 109 | * -- after this, rebooting will restart the main system -- |
| 110 | * 8. main() calls reboot() to boot main system |
| 111 | * |
| 112 | * OTA INSTALL |
| 113 | * 1. main system downloads OTA package to /cache/some-filename.zip |
Doug Zongker | 9b125b0 | 2010-09-22 12:01:37 -0700 | [diff] [blame] | 114 | * 2. main system writes "--update_package=/cache/some-filename.zip" |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 115 | * 3. main system reboots into recovery |
| 116 | * 4. get_args() writes BCB with "boot-recovery" and "--update_package=..." |
| 117 | * -- after this, rebooting will attempt to reinstall the update -- |
| 118 | * 5. install_package() attempts to install the update |
| 119 | * NOTE: the package install must itself be restartable from any point |
| 120 | * 6. finish_recovery() erases BCB |
| 121 | * -- after this, rebooting will (try to) restart the main system -- |
| 122 | * 7. ** if install failed ** |
| 123 | * 7a. prompt_and_wait() shows an error icon and waits for the user |
Tao Bao | c033639 | 2016-12-13 22:29:49 -0800 | [diff] [blame] | 124 | * 7b. the user reboots (pulling the battery, etc) into the main system |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 125 | */ |
| 126 | |
Elliott Hughes | f14af80 | 2015-02-10 14:46:14 -0800 | [diff] [blame] | 127 | bool is_ro_debuggable() { |
Elliott Hughes | cb22040 | 2016-09-23 15:30:55 -0700 | [diff] [blame] | 128 | return android::base::GetBoolProperty("ro.debuggable", false); |
Elliott Hughes | f14af80 | 2015-02-10 14:46:14 -0800 | [diff] [blame] | 129 | } |
| 130 | |
Tao Bao | ec57903 | 2017-07-21 12:13:15 -0700 | [diff] [blame] | 131 | // Clear the recovery command and prepare to boot a (hopefully working) system, |
Tianjie Xu | c14d95d | 2016-03-24 11:50:34 -0700 | [diff] [blame] | 132 | // copy our log file to cache as well (for the system to read). This function is |
| 133 | // idempotent: call it as many times as you like. |
Tao Bao | 551d2c3 | 2018-05-09 20:53:13 -0700 | [diff] [blame] | 134 | static void finish_recovery() { |
| 135 | std::string locale = ui->GetLocale(); |
Tao Bao | ec57903 | 2017-07-21 12:13:15 -0700 | [diff] [blame] | 136 | // Save the locale to cache, so if recovery is next started up without a '--locale' argument |
| 137 | // (e.g., directly from the bootloader) it will use the last-known locale. |
| 138 | if (!locale.empty() && has_cache) { |
| 139 | LOG(INFO) << "Saving locale \"" << locale << "\""; |
| 140 | if (ensure_path_mounted(LOCALE_FILE) != 0) { |
| 141 | LOG(ERROR) << "Failed to mount " << LOCALE_FILE; |
| 142 | } else if (!android::base::WriteStringToFile(locale, LOCALE_FILE)) { |
| 143 | PLOG(ERROR) << "Failed to save locale to " << LOCALE_FILE; |
Doug Zongker | 4f33e55 | 2012-08-23 13:16:12 -0700 | [diff] [blame] | 144 | } |
Tao Bao | ec57903 | 2017-07-21 12:13:15 -0700 | [diff] [blame] | 145 | } |
Doug Zongker | 4f33e55 | 2012-08-23 13:16:12 -0700 | [diff] [blame] | 146 | |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 147 | copy_logs(save_current_log, has_cache, sehandle); |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 148 | |
Tao Bao | ec57903 | 2017-07-21 12:13:15 -0700 | [diff] [blame] | 149 | // Reset to normal system boot so recovery won't cycle indefinitely. |
| 150 | std::string err; |
| 151 | if (!clear_bootloader_message(&err)) { |
| 152 | LOG(ERROR) << "Failed to clear BCB message: " << err; |
| 153 | } |
| 154 | |
| 155 | // Remove the command file, so recovery won't repeat indefinitely. |
| 156 | if (has_cache) { |
| 157 | if (ensure_path_mounted(COMMAND_FILE) != 0 || (unlink(COMMAND_FILE) && errno != ENOENT)) { |
| 158 | LOG(WARNING) << "Can't unlink " << COMMAND_FILE; |
Yabin Cui | 8b309f6 | 2016-06-24 18:22:02 -0700 | [diff] [blame] | 159 | } |
Tao Bao | ec57903 | 2017-07-21 12:13:15 -0700 | [diff] [blame] | 160 | ensure_path_unmounted(CACHE_ROOT); |
| 161 | } |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 162 | |
Tao Bao | ec57903 | 2017-07-21 12:13:15 -0700 | [diff] [blame] | 163 | sync(); // For good measure. |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 164 | } |
| 165 | |
Elliott Hughes | 30694c9 | 2015-03-25 15:16:51 -0700 | [diff] [blame] | 166 | static bool yes_no(Device* device, const char* question1, const char* question2) { |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 167 | std::vector<std::string> headers{ question1, question2 }; |
| 168 | std::vector<std::string> items{ " No", " Yes" }; |
Doug Zongker | ddd6a28 | 2009-06-09 12:22:33 -0700 | [diff] [blame] | 169 | |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 170 | size_t chosen_item = ui->ShowMenu( |
Tao Bao | 3aec696 | 2018-04-20 09:24:58 -0700 | [diff] [blame] | 171 | headers, items, 0, true, |
| 172 | std::bind(&Device::HandleMenuKey, device, std::placeholders::_1, std::placeholders::_2)); |
| 173 | return (chosen_item == 1); |
Elliott Hughes | 30694c9 | 2015-03-25 15:16:51 -0700 | [diff] [blame] | 174 | } |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 175 | |
Paul Crowley | 08404b4 | 2016-12-19 13:04:23 -0800 | [diff] [blame] | 176 | static bool ask_to_wipe_data(Device* device) { |
Tianjie Xu | 1a0a30a | 2018-10-25 15:22:07 -0700 | [diff] [blame] | 177 | std::vector<std::string> headers{ "Wipe all user data?", " THIS CAN NOT BE UNDONE!" }; |
| 178 | std::vector<std::string> items{ " Cancel", " Factory data reset" }; |
| 179 | |
| 180 | size_t chosen_item = ui->ShowPromptWipeDataConfirmationMenu( |
| 181 | headers, items, |
| 182 | std::bind(&Device::HandleMenuKey, device, std::placeholders::_1, std::placeholders::_2)); |
| 183 | |
| 184 | return (chosen_item == 1); |
Paul Crowley | 08404b4 | 2016-12-19 13:04:23 -0800 | [diff] [blame] | 185 | } |
Doug Zongker | 1066d2c | 2009-04-01 13:57:40 -0700 | [diff] [blame] | 186 | |
Hridya Valsaraju | eb6f13a | 2018-09-12 10:25:01 -0700 | [diff] [blame] | 187 | static InstallResult prompt_and_wipe_data(Device* device) { |
Tao Bao | 2bbc6d6 | 2017-08-13 23:48:55 -0700 | [diff] [blame] | 188 | // Use a single string and let ScreenRecoveryUI handles the wrapping. |
Tianjie Xu | b99e606 | 2018-10-16 15:13:09 -0700 | [diff] [blame] | 189 | std::vector<std::string> wipe_data_menu_headers{ |
Tao Bao | 2bbc6d6 | 2017-08-13 23:48:55 -0700 | [diff] [blame] | 190 | "Can't load Android system. Your data may be corrupt. " |
| 191 | "If you continue to get this message, you may need to " |
| 192 | "perform a factory data reset and erase all user data " |
Paul Crowley | 31ac0c6 | 2017-03-23 12:32:40 -0700 | [diff] [blame] | 193 | "stored on this device.", |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 194 | }; |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 195 | // clang-format off |
Tianjie Xu | b99e606 | 2018-10-16 15:13:09 -0700 | [diff] [blame] | 196 | std::vector<std::string> wipe_data_menu_items { |
Paul Crowley | 31ac0c6 | 2017-03-23 12:32:40 -0700 | [diff] [blame] | 197 | "Try again", |
| 198 | "Factory data reset", |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 199 | }; |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 200 | // clang-format on |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 201 | for (;;) { |
Tianjie Xu | b99e606 | 2018-10-16 15:13:09 -0700 | [diff] [blame] | 202 | size_t chosen_item = ui->ShowPromptWipeDataMenu( |
| 203 | wipe_data_menu_headers, wipe_data_menu_items, |
Tao Bao | 3aec696 | 2018-04-20 09:24:58 -0700 | [diff] [blame] | 204 | std::bind(&Device::HandleMenuKey, device, std::placeholders::_1, std::placeholders::_2)); |
Jerry Zhang | b76af93 | 2018-05-22 12:08:35 -0700 | [diff] [blame] | 205 | // If ShowMenu() returned RecoveryUI::KeyError::INTERRUPTED, WaitKey() was interrupted. |
| 206 | if (chosen_item == static_cast<size_t>(RecoveryUI::KeyError::INTERRUPTED)) { |
Hridya Valsaraju | eb6f13a | 2018-09-12 10:25:01 -0700 | [diff] [blame] | 207 | return INSTALL_KEY_INTERRUPTED; |
Jerry Zhang | b76af93 | 2018-05-22 12:08:35 -0700 | [diff] [blame] | 208 | } |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 209 | if (chosen_item != 1) { |
Hridya Valsaraju | eb6f13a | 2018-09-12 10:25:01 -0700 | [diff] [blame] | 210 | return INSTALL_SUCCESS; // Just reboot, no wipe; not a failure, user asked for it |
Paul Crowley | 08404b4 | 2016-12-19 13:04:23 -0800 | [diff] [blame] | 211 | } |
Tianjie Xu | b99e606 | 2018-10-16 15:13:09 -0700 | [diff] [blame] | 212 | |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 213 | if (ask_to_wipe_data(device)) { |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 214 | bool convert_fbe = reason && strcmp(reason, "convert_fbe") == 0; |
| 215 | if (WipeData(device, convert_fbe)) { |
Hridya Valsaraju | eb6f13a | 2018-09-12 10:25:01 -0700 | [diff] [blame] | 216 | return INSTALL_SUCCESS; |
| 217 | } else { |
| 218 | return INSTALL_ERROR; |
| 219 | } |
Tao Bao | fc5499f | 2017-02-23 19:06:53 -0800 | [diff] [blame] | 220 | } |
| 221 | } |
Paul Crowley | 08404b4 | 2016-12-19 13:04:23 -0800 | [diff] [blame] | 222 | } |
| 223 | |
Tao Bao | 1b2a98b | 2017-03-24 10:45:34 -0700 | [diff] [blame] | 224 | // Secure-wipe a given partition. It uses BLKSECDISCARD, if supported. Otherwise, it goes with |
| 225 | // BLKDISCARD (if device supports BLKDISCARDZEROES) or BLKZEROOUT. |
Tao Bao | 862a4c1 | 2016-06-02 11:16:50 -0700 | [diff] [blame] | 226 | static bool secure_wipe_partition(const std::string& partition) { |
Tao Bao | 1b2a98b | 2017-03-24 10:45:34 -0700 | [diff] [blame] | 227 | android::base::unique_fd fd(TEMP_FAILURE_RETRY(open(partition.c_str(), O_WRONLY))); |
| 228 | if (fd == -1) { |
| 229 | PLOG(ERROR) << "Failed to open \"" << partition << "\""; |
| 230 | return false; |
| 231 | } |
| 232 | |
| 233 | uint64_t range[2] = { 0, 0 }; |
| 234 | if (ioctl(fd, BLKGETSIZE64, &range[1]) == -1 || range[1] == 0) { |
| 235 | PLOG(ERROR) << "Failed to get partition size"; |
| 236 | return false; |
| 237 | } |
| 238 | LOG(INFO) << "Secure-wiping \"" << partition << "\" from " << range[0] << " to " << range[1]; |
| 239 | |
| 240 | LOG(INFO) << " Trying BLKSECDISCARD..."; |
| 241 | if (ioctl(fd, BLKSECDISCARD, &range) == -1) { |
| 242 | PLOG(WARNING) << " Failed"; |
| 243 | |
| 244 | // Use BLKDISCARD if it zeroes out blocks, otherwise use BLKZEROOUT. |
| 245 | unsigned int zeroes; |
| 246 | if (ioctl(fd, BLKDISCARDZEROES, &zeroes) == 0 && zeroes != 0) { |
| 247 | LOG(INFO) << " Trying BLKDISCARD..."; |
| 248 | if (ioctl(fd, BLKDISCARD, &range) == -1) { |
| 249 | PLOG(ERROR) << " Failed"; |
Tao Bao | 862a4c1 | 2016-06-02 11:16:50 -0700 | [diff] [blame] | 250 | return false; |
Tao Bao | 1b2a98b | 2017-03-24 10:45:34 -0700 | [diff] [blame] | 251 | } |
| 252 | } else { |
| 253 | LOG(INFO) << " Trying BLKZEROOUT..."; |
| 254 | if (ioctl(fd, BLKZEROOUT, &range) == -1) { |
| 255 | PLOG(ERROR) << " Failed"; |
Tao Bao | 862a4c1 | 2016-06-02 11:16:50 -0700 | [diff] [blame] | 256 | return false; |
Tao Bao | 1b2a98b | 2017-03-24 10:45:34 -0700 | [diff] [blame] | 257 | } |
Tao Bao | 862a4c1 | 2016-06-02 11:16:50 -0700 | [diff] [blame] | 258 | } |
Tao Bao | 1b2a98b | 2017-03-24 10:45:34 -0700 | [diff] [blame] | 259 | } |
Tao Bao | 862a4c1 | 2016-06-02 11:16:50 -0700 | [diff] [blame] | 260 | |
Tao Bao | 1b2a98b | 2017-03-24 10:45:34 -0700 | [diff] [blame] | 261 | LOG(INFO) << " Done"; |
| 262 | return true; |
Tao Bao | 862a4c1 | 2016-06-02 11:16:50 -0700 | [diff] [blame] | 263 | } |
| 264 | |
xunchang | 55e3d22 | 2019-03-11 11:28:41 -0700 | [diff] [blame] | 265 | static std::unique_ptr<Package> ReadWipePackage(size_t wipe_package_size) { |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 266 | if (wipe_package_size == 0) { |
| 267 | LOG(ERROR) << "wipe_package_size is zero"; |
xunchang | 55e3d22 | 2019-03-11 11:28:41 -0700 | [diff] [blame] | 268 | return nullptr; |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 269 | } |
| 270 | |
| 271 | std::string wipe_package; |
| 272 | std::string err_str; |
| 273 | if (!read_wipe_package(&wipe_package, wipe_package_size, &err_str)) { |
| 274 | PLOG(ERROR) << "Failed to read wipe package" << err_str; |
xunchang | 55e3d22 | 2019-03-11 11:28:41 -0700 | [diff] [blame] | 275 | return nullptr; |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 276 | } |
xunchang | 55e3d22 | 2019-03-11 11:28:41 -0700 | [diff] [blame] | 277 | |
| 278 | return Package::CreateMemoryPackage( |
| 279 | std::vector<uint8_t>(wipe_package.begin(), wipe_package.end()), nullptr); |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 280 | } |
| 281 | |
| 282 | // Checks if the wipe package matches expectation. If the check passes, reads the list of |
| 283 | // partitions to wipe from the package. Checks include |
Yabin Cui | fd99a31 | 2016-06-09 14:09:39 -0700 | [diff] [blame] | 284 | // 1. verify the package. |
| 285 | // 2. check metadata (ota-type, pre-device and serial number if having one). |
xunchang | 55e3d22 | 2019-03-11 11:28:41 -0700 | [diff] [blame] | 286 | static bool CheckWipePackage(Package* wipe_package) { |
xunchang | 2478885 | 2019-03-22 16:08:52 -0700 | [diff] [blame] | 287 | if (!verify_package(wipe_package, ui)) { |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 288 | LOG(ERROR) << "Failed to verify package"; |
| 289 | return false; |
| 290 | } |
Yabin Cui | fd99a31 | 2016-06-09 14:09:39 -0700 | [diff] [blame] | 291 | |
xunchang | 55e3d22 | 2019-03-11 11:28:41 -0700 | [diff] [blame] | 292 | ZipArchiveHandle zip = wipe_package->GetZipArchiveHandle(); |
| 293 | if (!zip) { |
| 294 | LOG(ERROR) << "Failed to get ZipArchiveHandle"; |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 295 | return false; |
| 296 | } |
| 297 | |
| 298 | std::map<std::string, std::string> metadata; |
| 299 | if (!ReadMetadataFromPackage(zip, &metadata)) { |
| 300 | LOG(ERROR) << "Failed to parse metadata in the zip file"; |
| 301 | return false; |
| 302 | } |
| 303 | |
xunchang | 55e3d22 | 2019-03-11 11:28:41 -0700 | [diff] [blame] | 304 | return CheckPackageMetadata(metadata, OtaType::BRICK) == 0; |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 305 | } |
| 306 | |
xunchang | 55e3d22 | 2019-03-11 11:28:41 -0700 | [diff] [blame] | 307 | std::vector<std::string> GetWipePartitionList(Package* wipe_package) { |
| 308 | ZipArchiveHandle zip = wipe_package->GetZipArchiveHandle(); |
| 309 | if (!zip) { |
| 310 | LOG(ERROR) << "Failed to get ZipArchiveHandle"; |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 311 | return {}; |
| 312 | } |
| 313 | |
| 314 | static constexpr const char* RECOVERY_WIPE_ENTRY_NAME = "recovery.wipe"; |
| 315 | |
| 316 | std::string partition_list_content; |
| 317 | ZipString path(RECOVERY_WIPE_ENTRY_NAME); |
| 318 | ZipEntry entry; |
| 319 | if (FindEntry(zip, path, &entry) == 0) { |
| 320 | uint32_t length = entry.uncompressed_length; |
| 321 | partition_list_content = std::string(length, '\0'); |
| 322 | if (auto err = ExtractToMemory( |
| 323 | zip, &entry, reinterpret_cast<uint8_t*>(partition_list_content.data()), length); |
| 324 | err != 0) { |
| 325 | LOG(ERROR) << "Failed to extract " << RECOVERY_WIPE_ENTRY_NAME << ": " |
| 326 | << ErrorCodeString(err); |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 327 | return {}; |
Yabin Cui | fd99a31 | 2016-06-09 14:09:39 -0700 | [diff] [blame] | 328 | } |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 329 | } else { |
| 330 | LOG(INFO) << "Failed to find " << RECOVERY_WIPE_ENTRY_NAME |
| 331 | << ", falling back to use the partition list on device."; |
Tianjie Xu | 93b5bf2 | 2018-10-25 10:39:01 -0700 | [diff] [blame] | 332 | |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 333 | static constexpr const char* RECOVERY_WIPE_ON_DEVICE = "/etc/recovery.wipe"; |
| 334 | if (!android::base::ReadFileToString(RECOVERY_WIPE_ON_DEVICE, &partition_list_content)) { |
| 335 | PLOG(ERROR) << "failed to read \"" << RECOVERY_WIPE_ON_DEVICE << "\""; |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 336 | return {}; |
Yabin Cui | fd99a31 | 2016-06-09 14:09:39 -0700 | [diff] [blame] | 337 | } |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 338 | } |
Tianjie Xu | 93b5bf2 | 2018-10-25 10:39:01 -0700 | [diff] [blame] | 339 | |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 340 | std::vector<std::string> result; |
| 341 | std::vector<std::string> lines = android::base::Split(partition_list_content, "\n"); |
| 342 | for (const std::string& line : lines) { |
| 343 | std::string partition = android::base::Trim(line); |
| 344 | // Ignore '#' comment or empty lines. |
| 345 | if (android::base::StartsWith(partition, "#") || partition.empty()) { |
| 346 | continue; |
| 347 | } |
| 348 | result.push_back(line); |
| 349 | } |
Yabin Cui | fd99a31 | 2016-06-09 14:09:39 -0700 | [diff] [blame] | 350 | |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 351 | return result; |
Yabin Cui | fd99a31 | 2016-06-09 14:09:39 -0700 | [diff] [blame] | 352 | } |
| 353 | |
Tao Bao | aac9d9f | 2018-04-29 23:38:59 -0700 | [diff] [blame] | 354 | // Wipes the current A/B device, with a secure wipe of all the partitions in RECOVERY_WIPE. |
Yabin Cui | fd99a31 | 2016-06-09 14:09:39 -0700 | [diff] [blame] | 355 | static bool wipe_ab_device(size_t wipe_package_size) { |
Tao Bao | aac9d9f | 2018-04-29 23:38:59 -0700 | [diff] [blame] | 356 | ui->SetBackground(RecoveryUI::ERASING); |
| 357 | ui->SetProgressType(RecoveryUI::INDETERMINATE); |
Tao Bao | 862a4c1 | 2016-06-02 11:16:50 -0700 | [diff] [blame] | 358 | |
xunchang | 55e3d22 | 2019-03-11 11:28:41 -0700 | [diff] [blame] | 359 | auto wipe_package = ReadWipePackage(wipe_package_size); |
| 360 | if (!wipe_package) { |
| 361 | LOG(ERROR) << "Failed to open wipe package"; |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 362 | return false; |
| 363 | } |
| 364 | |
xunchang | 55e3d22 | 2019-03-11 11:28:41 -0700 | [diff] [blame] | 365 | if (!CheckWipePackage(wipe_package.get())) { |
Tao Bao | aac9d9f | 2018-04-29 23:38:59 -0700 | [diff] [blame] | 366 | LOG(ERROR) << "Failed to verify wipe package"; |
| 367 | return false; |
| 368 | } |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 369 | |
xunchang | 55e3d22 | 2019-03-11 11:28:41 -0700 | [diff] [blame] | 370 | auto partition_list = GetWipePartitionList(wipe_package.get()); |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 371 | if (partition_list.empty()) { |
| 372 | LOG(ERROR) << "Empty wipe ab partition list"; |
Tao Bao | aac9d9f | 2018-04-29 23:38:59 -0700 | [diff] [blame] | 373 | return false; |
| 374 | } |
| 375 | |
xunchang | e0d991c | 2019-03-05 14:50:51 -0800 | [diff] [blame] | 376 | for (const auto& partition : partition_list) { |
Tao Bao | aac9d9f | 2018-04-29 23:38:59 -0700 | [diff] [blame] | 377 | // Proceed anyway even if it fails to wipe some partition. |
| 378 | secure_wipe_partition(partition); |
| 379 | } |
| 380 | return true; |
Tao Bao | 862a4c1 | 2016-06-02 11:16:50 -0700 | [diff] [blame] | 381 | } |
| 382 | |
Nick Kralevich | a9ad032 | 2014-10-22 18:38:48 -0700 | [diff] [blame] | 383 | static void choose_recovery_file(Device* device) { |
Tao Bao | 08fc6be | 2017-03-07 00:56:27 -0800 | [diff] [blame] | 384 | std::vector<std::string> entries; |
| 385 | if (has_cache) { |
| 386 | for (int i = 0; i < KEEP_LOG_COUNT; i++) { |
| 387 | auto add_to_entries = [&](const char* filename) { |
| 388 | std::string log_file(filename); |
| 389 | if (i > 0) { |
| 390 | log_file += "." + std::to_string(i); |
Tao Bao | bef3971 | 2015-05-04 18:50:27 -0700 | [diff] [blame] | 391 | } |
Tao Bao | 08fc6be | 2017-03-07 00:56:27 -0800 | [diff] [blame] | 392 | |
Yifan Hong | d81b8e3 | 2018-12-17 14:29:06 -0800 | [diff] [blame] | 393 | if (ensure_path_mounted(log_file) == 0 && access(log_file.c_str(), R_OK) == 0) { |
Tao Bao | 08fc6be | 2017-03-07 00:56:27 -0800 | [diff] [blame] | 394 | entries.push_back(std::move(log_file)); |
| 395 | } |
| 396 | }; |
| 397 | |
| 398 | // Add LAST_LOG_FILE + LAST_LOG_FILE.x |
| 399 | add_to_entries(LAST_LOG_FILE); |
| 400 | |
| 401 | // Add LAST_KMSG_FILE + LAST_KMSG_FILE.x |
| 402 | add_to_entries(LAST_KMSG_FILE); |
| 403 | } |
| 404 | } else { |
| 405 | // If cache partition is not found, view /tmp/recovery.log instead. |
Tao Bao | 641fa97 | 2018-04-25 18:59:40 -0700 | [diff] [blame] | 406 | if (access(Paths::Get().temporary_log_file().c_str(), R_OK) == -1) { |
Tao Bao | 08fc6be | 2017-03-07 00:56:27 -0800 | [diff] [blame] | 407 | return; |
Tianjie Xu | a54f75e | 2016-08-17 12:02:46 -0700 | [diff] [blame] | 408 | } else { |
Tao Bao | 641fa97 | 2018-04-25 18:59:40 -0700 | [diff] [blame] | 409 | entries.push_back(Paths::Get().temporary_log_file()); |
Nick Kralevich | a9ad032 | 2014-10-22 18:38:48 -0700 | [diff] [blame] | 410 | } |
Tao Bao | 08fc6be | 2017-03-07 00:56:27 -0800 | [diff] [blame] | 411 | } |
Nick Kralevich | a9ad032 | 2014-10-22 18:38:48 -0700 | [diff] [blame] | 412 | |
Tao Bao | 08fc6be | 2017-03-07 00:56:27 -0800 | [diff] [blame] | 413 | entries.push_back("Back"); |
Elliott Hughes | c049163 | 2015-05-06 12:40:05 -0700 | [diff] [blame] | 414 | |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 415 | std::vector<std::string> headers{ "Select file to view" }; |
Nick Kralevich | a9ad032 | 2014-10-22 18:38:48 -0700 | [diff] [blame] | 416 | |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 417 | size_t chosen_item = 0; |
Tao Bao | 08fc6be | 2017-03-07 00:56:27 -0800 | [diff] [blame] | 418 | while (true) { |
Tao Bao | 3aec696 | 2018-04-20 09:24:58 -0700 | [diff] [blame] | 419 | chosen_item = ui->ShowMenu( |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 420 | headers, entries, chosen_item, true, |
Tao Bao | 3aec696 | 2018-04-20 09:24:58 -0700 | [diff] [blame] | 421 | std::bind(&Device::HandleMenuKey, device, std::placeholders::_1, std::placeholders::_2)); |
Jerry Zhang | b76af93 | 2018-05-22 12:08:35 -0700 | [diff] [blame] | 422 | |
| 423 | // Handle WaitKey() interrupt. |
| 424 | if (chosen_item == static_cast<size_t>(RecoveryUI::KeyError::INTERRUPTED)) { |
| 425 | break; |
| 426 | } |
Tao Bao | 08fc6be | 2017-03-07 00:56:27 -0800 | [diff] [blame] | 427 | if (entries[chosen_item] == "Back") break; |
Nick Kralevich | a9ad032 | 2014-10-22 18:38:48 -0700 | [diff] [blame] | 428 | |
Tao Bao | 1d156b9 | 2018-05-02 12:43:18 -0700 | [diff] [blame] | 429 | ui->ShowFile(entries[chosen_item]); |
Tao Bao | 08fc6be | 2017-03-07 00:56:27 -0800 | [diff] [blame] | 430 | } |
Nick Kralevich | a9ad032 | 2014-10-22 18:38:48 -0700 | [diff] [blame] | 431 | } |
| 432 | |
Tao Bao | db7e898 | 2017-03-06 23:53:16 -0800 | [diff] [blame] | 433 | static void run_graphics_test() { |
| 434 | // Switch to graphics screen. |
| 435 | ui->ShowText(false); |
Elliott Hughes | 498cda6 | 2016-04-14 16:49:04 -0700 | [diff] [blame] | 436 | |
Tao Bao | db7e898 | 2017-03-06 23:53:16 -0800 | [diff] [blame] | 437 | ui->SetProgressType(RecoveryUI::INDETERMINATE); |
| 438 | ui->SetBackground(RecoveryUI::INSTALLING_UPDATE); |
| 439 | sleep(1); |
Elliott Hughes | 498cda6 | 2016-04-14 16:49:04 -0700 | [diff] [blame] | 440 | |
Tao Bao | db7e898 | 2017-03-06 23:53:16 -0800 | [diff] [blame] | 441 | ui->SetBackground(RecoveryUI::ERROR); |
| 442 | sleep(1); |
Elliott Hughes | 498cda6 | 2016-04-14 16:49:04 -0700 | [diff] [blame] | 443 | |
Tao Bao | db7e898 | 2017-03-06 23:53:16 -0800 | [diff] [blame] | 444 | ui->SetBackground(RecoveryUI::NO_COMMAND); |
| 445 | sleep(1); |
Elliott Hughes | 498cda6 | 2016-04-14 16:49:04 -0700 | [diff] [blame] | 446 | |
Tao Bao | db7e898 | 2017-03-06 23:53:16 -0800 | [diff] [blame] | 447 | ui->SetBackground(RecoveryUI::ERASING); |
| 448 | sleep(1); |
Elliott Hughes | 498cda6 | 2016-04-14 16:49:04 -0700 | [diff] [blame] | 449 | |
Tao Bao | db7e898 | 2017-03-06 23:53:16 -0800 | [diff] [blame] | 450 | // Calling SetBackground() after SetStage() to trigger a redraw. |
| 451 | ui->SetStage(1, 3); |
| 452 | ui->SetBackground(RecoveryUI::INSTALLING_UPDATE); |
| 453 | sleep(1); |
| 454 | ui->SetStage(2, 3); |
| 455 | ui->SetBackground(RecoveryUI::INSTALLING_UPDATE); |
| 456 | sleep(1); |
| 457 | ui->SetStage(3, 3); |
| 458 | ui->SetBackground(RecoveryUI::INSTALLING_UPDATE); |
| 459 | sleep(1); |
Elliott Hughes | 498cda6 | 2016-04-14 16:49:04 -0700 | [diff] [blame] | 460 | |
Tao Bao | db7e898 | 2017-03-06 23:53:16 -0800 | [diff] [blame] | 461 | ui->SetStage(-1, -1); |
| 462 | ui->SetBackground(RecoveryUI::INSTALLING_UPDATE); |
Elliott Hughes | 498cda6 | 2016-04-14 16:49:04 -0700 | [diff] [blame] | 463 | |
Tao Bao | db7e898 | 2017-03-06 23:53:16 -0800 | [diff] [blame] | 464 | ui->SetProgressType(RecoveryUI::DETERMINATE); |
| 465 | ui->ShowProgress(1.0, 10.0); |
| 466 | float fraction = 0.0; |
| 467 | for (size_t i = 0; i < 100; ++i) { |
| 468 | fraction += .01; |
| 469 | ui->SetProgress(fraction); |
| 470 | usleep(100000); |
| 471 | } |
| 472 | |
| 473 | ui->ShowText(true); |
Elliott Hughes | 498cda6 | 2016-04-14 16:49:04 -0700 | [diff] [blame] | 474 | } |
| 475 | |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 476 | // Returns REBOOT, SHUTDOWN, or REBOOT_BOOTLOADER. Returning NO_ACTION means to take the default, |
| 477 | // which is to reboot or shutdown depending on if the --shutdown_after flag was passed to recovery. |
| 478 | static Device::BuiltinAction prompt_and_wait(Device* device, int status) { |
| 479 | for (;;) { |
Tao Bao | 551d2c3 | 2018-05-09 20:53:13 -0700 | [diff] [blame] | 480 | finish_recovery(); |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 481 | switch (status) { |
| 482 | case INSTALL_SUCCESS: |
| 483 | case INSTALL_NONE: |
| 484 | ui->SetBackground(RecoveryUI::NO_COMMAND); |
| 485 | break; |
Doug Zongker | 6c8553d | 2012-09-24 10:40:47 -0700 | [diff] [blame] | 486 | |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 487 | case INSTALL_ERROR: |
| 488 | case INSTALL_CORRUPT: |
| 489 | ui->SetBackground(RecoveryUI::ERROR); |
| 490 | break; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 491 | } |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 492 | ui->SetProgressType(RecoveryUI::EMPTY); |
| 493 | |
Tao Bao | 1fe1afe | 2018-05-01 15:56:05 -0700 | [diff] [blame] | 494 | size_t chosen_item = ui->ShowMenu( |
| 495 | {}, device->GetMenuItems(), 0, false, |
Tao Bao | 3aec696 | 2018-04-20 09:24:58 -0700 | [diff] [blame] | 496 | std::bind(&Device::HandleMenuKey, device, std::placeholders::_1, std::placeholders::_2)); |
Jerry Zhang | b76af93 | 2018-05-22 12:08:35 -0700 | [diff] [blame] | 497 | // Handle Interrupt key |
| 498 | if (chosen_item == static_cast<size_t>(RecoveryUI::KeyError::INTERRUPTED)) { |
| 499 | return Device::KEY_INTERRUPTED; |
| 500 | } |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 501 | // Device-specific code may take some action here. It may return one of the core actions |
| 502 | // handled in the switch statement below. |
Jerry Zhang | b76af93 | 2018-05-22 12:08:35 -0700 | [diff] [blame] | 503 | Device::BuiltinAction chosen_action = |
| 504 | (chosen_item == static_cast<size_t>(RecoveryUI::KeyError::TIMED_OUT)) |
| 505 | ? Device::REBOOT |
| 506 | : device->InvokeMenuItem(chosen_item); |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 507 | |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 508 | switch (chosen_action) { |
| 509 | case Device::NO_ACTION: |
| 510 | break; |
| 511 | |
| 512 | case Device::REBOOT: |
| 513 | case Device::SHUTDOWN: |
| 514 | case Device::REBOOT_BOOTLOADER: |
Hridya Valsaraju | 20c81b3 | 2018-07-27 22:09:12 -0700 | [diff] [blame] | 515 | case Device::ENTER_FASTBOOT: |
| 516 | case Device::ENTER_RECOVERY: |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 517 | return chosen_action; |
| 518 | |
| 519 | case Device::WIPE_DATA: |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 520 | save_current_log = true; |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 521 | if (ui->IsTextVisible()) { |
| 522 | if (ask_to_wipe_data(device)) { |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 523 | WipeData(device, false); |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 524 | } |
| 525 | } else { |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 526 | WipeData(device, false); |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 527 | return Device::NO_ACTION; |
| 528 | } |
| 529 | break; |
| 530 | |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 531 | case Device::WIPE_CACHE: { |
| 532 | save_current_log = true; |
| 533 | std::function<bool()> confirm_func = [&device]() { |
| 534 | return yes_no(device, "Wipe cache?", " THIS CAN NOT BE UNDONE!"); |
| 535 | }; |
| 536 | WipeCache(ui, ui->IsTextVisible() ? confirm_func : nullptr); |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 537 | if (!ui->IsTextVisible()) return Device::NO_ACTION; |
| 538 | break; |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 539 | } |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 540 | case Device::APPLY_ADB_SIDELOAD: |
Tao Bao | 378bfbf | 2019-04-16 14:22:25 -0700 | [diff] [blame] | 541 | case Device::APPLY_SDCARD: |
| 542 | case Device::ENTER_RESCUE: { |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 543 | save_current_log = true; |
Tao Bao | 378bfbf | 2019-04-16 14:22:25 -0700 | [diff] [blame] | 544 | |
| 545 | bool adb = true; |
| 546 | if (chosen_action == Device::ENTER_RESCUE) { |
| 547 | // Switch to graphics screen. |
| 548 | ui->ShowText(false); |
| 549 | status = ApplyFromAdb(ui, true /* rescue_mode */); |
| 550 | ui->ShowText(true); |
| 551 | } else if (chosen_action == Device::APPLY_ADB_SIDELOAD) { |
| 552 | status = ApplyFromAdb(ui, false /* rescue_mode */); |
xunchang | 3cc23d5 | 2019-03-18 15:03:33 -0700 | [diff] [blame] | 553 | } else { |
Tao Bao | 378bfbf | 2019-04-16 14:22:25 -0700 | [diff] [blame] | 554 | adb = false; |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 555 | status = ApplyFromSdcard(device, ui); |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 556 | } |
xunchang | 3cc23d5 | 2019-03-18 15:03:33 -0700 | [diff] [blame] | 557 | |
| 558 | if (status != INSTALL_SUCCESS) { |
| 559 | ui->SetBackground(RecoveryUI::ERROR); |
| 560 | ui->Print("Installation aborted.\n"); |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 561 | copy_logs(save_current_log, has_cache, sehandle); |
xunchang | 3cc23d5 | 2019-03-18 15:03:33 -0700 | [diff] [blame] | 562 | } else if (!ui->IsTextVisible()) { |
| 563 | return Device::NO_ACTION; // reboot if logs aren't visible |
| 564 | } else { |
| 565 | ui->Print("\nInstall from %s complete.\n", adb ? "ADB" : "SD card"); |
| 566 | } |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 567 | break; |
xunchang | 3cc23d5 | 2019-03-18 15:03:33 -0700 | [diff] [blame] | 568 | } |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 569 | |
| 570 | case Device::VIEW_RECOVERY_LOGS: |
| 571 | choose_recovery_file(device); |
| 572 | break; |
| 573 | |
| 574 | case Device::RUN_GRAPHICS_TEST: |
| 575 | run_graphics_test(); |
| 576 | break; |
| 577 | |
Tianjie Xu | 29d5575 | 2017-09-20 17:53:46 -0700 | [diff] [blame] | 578 | case Device::RUN_LOCALE_TEST: { |
| 579 | ScreenRecoveryUI* screen_ui = static_cast<ScreenRecoveryUI*>(ui); |
Tao Bao | 39c4918 | 2018-05-07 22:50:33 -0700 | [diff] [blame] | 580 | screen_ui->CheckBackgroundTextImages(); |
Tianjie Xu | 29d5575 | 2017-09-20 17:53:46 -0700 | [diff] [blame] | 581 | break; |
| 582 | } |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 583 | case Device::MOUNT_SYSTEM: |
Jiyong Park | 8b7af4c | 2018-06-01 11:58:54 +0900 | [diff] [blame] | 584 | // the system partition is mounted at /mnt/system |
Yifan Hong | d81b8e3 | 2018-12-17 14:29:06 -0800 | [diff] [blame] | 585 | if (ensure_path_mounted_at(get_system_root(), "/mnt/system") != -1) { |
Yifan Hong | 4932780 | 2018-11-26 14:59:09 -0800 | [diff] [blame] | 586 | ui->Print("Mounted /system.\n"); |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 587 | } |
| 588 | break; |
Jerry Zhang | b76af93 | 2018-05-22 12:08:35 -0700 | [diff] [blame] | 589 | |
| 590 | case Device::KEY_INTERRUPTED: |
| 591 | return Device::KEY_INTERRUPTED; |
Tao Bao | 50dd532 | 2017-03-07 14:57:04 -0800 | [diff] [blame] | 592 | } |
| 593 | } |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 594 | } |
| 595 | |
Tao Bao | 99f0d9e | 2016-10-13 12:46:38 -0700 | [diff] [blame] | 596 | static void print_property(const char* key, const char* name, void* /* cookie */) { |
| 597 | printf("%s=%s\n", key, name); |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 598 | } |
| 599 | |
Tao Bao | 6d90a9d | 2018-04-26 10:40:36 -0700 | [diff] [blame] | 600 | static bool is_battery_ok(int* required_battery_level) { |
Yifan Hong | e8e4c40 | 2017-11-08 14:56:03 -0800 | [diff] [blame] | 601 | using android::hardware::health::V1_0::BatteryStatus; |
Yifan Hong | 056538c | 2018-07-11 17:04:12 -0700 | [diff] [blame] | 602 | using android::hardware::health::V2_0::get_health_service; |
| 603 | using android::hardware::health::V2_0::IHealth; |
Yifan Hong | e8e4c40 | 2017-11-08 14:56:03 -0800 | [diff] [blame] | 604 | using android::hardware::health::V2_0::Result; |
| 605 | using android::hardware::health::V2_0::toString; |
Yabin Cui | 99281df | 2016-02-17 12:21:52 -0800 | [diff] [blame] | 606 | |
Yifan Hong | 056538c | 2018-07-11 17:04:12 -0700 | [diff] [blame] | 607 | android::sp<IHealth> health = get_health_service(); |
Yifan Hong | e8e4c40 | 2017-11-08 14:56:03 -0800 | [diff] [blame] | 608 | |
Tao Bao | 6d90a9d | 2018-04-26 10:40:36 -0700 | [diff] [blame] | 609 | static constexpr int BATTERY_READ_TIMEOUT_IN_SEC = 10; |
Yifan Hong | e8e4c40 | 2017-11-08 14:56:03 -0800 | [diff] [blame] | 610 | int wait_second = 0; |
| 611 | while (true) { |
| 612 | auto charge_status = BatteryStatus::UNKNOWN; |
Yifan Hong | 056538c | 2018-07-11 17:04:12 -0700 | [diff] [blame] | 613 | |
| 614 | if (health == nullptr) { |
| 615 | LOG(WARNING) << "no health implementation is found, assuming defaults"; |
| 616 | } else { |
| 617 | health |
| 618 | ->getChargeStatus([&charge_status](auto res, auto out_status) { |
| 619 | if (res == Result::SUCCESS) { |
| 620 | charge_status = out_status; |
| 621 | } |
| 622 | }) |
| 623 | .isOk(); // should not have transport error |
| 624 | } |
Yifan Hong | e8e4c40 | 2017-11-08 14:56:03 -0800 | [diff] [blame] | 625 | |
| 626 | // Treat unknown status as charged. |
| 627 | bool charged = (charge_status != BatteryStatus::DISCHARGING && |
| 628 | charge_status != BatteryStatus::NOT_CHARGING); |
| 629 | |
| 630 | Result res = Result::UNKNOWN; |
| 631 | int32_t capacity = INT32_MIN; |
Yifan Hong | 056538c | 2018-07-11 17:04:12 -0700 | [diff] [blame] | 632 | if (health != nullptr) { |
| 633 | health |
| 634 | ->getCapacity([&res, &capacity](auto out_res, auto out_capacity) { |
| 635 | res = out_res; |
| 636 | capacity = out_capacity; |
| 637 | }) |
| 638 | .isOk(); // should not have transport error |
| 639 | } |
Yifan Hong | e8e4c40 | 2017-11-08 14:56:03 -0800 | [diff] [blame] | 640 | |
Yifan Hong | 056538c | 2018-07-11 17:04:12 -0700 | [diff] [blame] | 641 | LOG(INFO) << "charge_status " << toString(charge_status) << ", charged " << charged |
| 642 | << ", status " << toString(res) << ", capacity " << capacity; |
Yifan Hong | e8e4c40 | 2017-11-08 14:56:03 -0800 | [diff] [blame] | 643 | // At startup, the battery drivers in devices like N5X/N6P take some time to load |
| 644 | // the battery profile. Before the load finishes, it reports value 50 as a fake |
| 645 | // capacity. BATTERY_READ_TIMEOUT_IN_SEC is set that the battery drivers are expected |
| 646 | // to finish loading the battery profile earlier than 10 seconds after kernel startup. |
| 647 | if (res == Result::SUCCESS && capacity == 50) { |
| 648 | if (wait_second < BATTERY_READ_TIMEOUT_IN_SEC) { |
| 649 | sleep(1); |
| 650 | wait_second++; |
| 651 | continue; |
| 652 | } |
| 653 | } |
| 654 | // If we can't read battery percentage, it may be a device without battery. In this |
| 655 | // situation, use 100 as a fake battery percentage. |
| 656 | if (res != Result::SUCCESS) { |
| 657 | capacity = 100; |
| 658 | } |
Tao Bao | 6d90a9d | 2018-04-26 10:40:36 -0700 | [diff] [blame] | 659 | |
| 660 | // GmsCore enters recovery mode to install package when having enough battery percentage. |
| 661 | // Normally, the threshold is 40% without charger and 20% with charger. So we should check |
| 662 | // battery with a slightly lower limitation. |
| 663 | static constexpr int BATTERY_OK_PERCENTAGE = 20; |
| 664 | static constexpr int BATTERY_WITH_CHARGER_OK_PERCENTAGE = 15; |
| 665 | *required_battery_level = charged ? BATTERY_WITH_CHARGER_OK_PERCENTAGE : BATTERY_OK_PERCENTAGE; |
| 666 | return capacity >= *required_battery_level; |
| 667 | } |
Yabin Cui | 99281df | 2016-02-17 12:21:52 -0800 | [diff] [blame] | 668 | } |
| 669 | |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 670 | // Set the retry count to |retry_count| in BCB. |
Tianjie Xu | 72449c9 | 2017-05-16 18:07:31 -0700 | [diff] [blame] | 671 | static void set_retry_bootloader_message(int retry_count, const std::vector<std::string>& args) { |
| 672 | std::vector<std::string> options; |
| 673 | for (const auto& arg : args) { |
| 674 | if (!android::base::StartsWith(arg, "--retry_count")) { |
| 675 | options.push_back(arg); |
Tianjie Xu | 3c62b67 | 2016-02-05 18:25:58 -0800 | [diff] [blame] | 676 | } |
Tianjie Xu | 72449c9 | 2017-05-16 18:07:31 -0700 | [diff] [blame] | 677 | } |
Tianjie Xu | 3c62b67 | 2016-02-05 18:25:58 -0800 | [diff] [blame] | 678 | |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 679 | // Update the retry counter in BCB. |
| 680 | options.push_back(android::base::StringPrintf("--retry_count=%d", retry_count)); |
Tianjie Xu | 72449c9 | 2017-05-16 18:07:31 -0700 | [diff] [blame] | 681 | std::string err; |
| 682 | if (!update_bootloader_message(options, &err)) { |
| 683 | LOG(ERROR) << err; |
| 684 | } |
Tianjie Xu | 3c62b67 | 2016-02-05 18:25:58 -0800 | [diff] [blame] | 685 | } |
| 686 | |
Tianjie Xu | 06e57ac | 2016-07-11 14:04:08 -0700 | [diff] [blame] | 687 | static bool bootreason_in_blacklist() { |
Tao Bao | efc3559 | 2017-01-08 22:45:47 -0800 | [diff] [blame] | 688 | std::string bootreason = android::base::GetProperty("ro.boot.bootreason", ""); |
| 689 | if (!bootreason.empty()) { |
Tao Bao | aac9d9f | 2018-04-29 23:38:59 -0700 | [diff] [blame] | 690 | // More bootreasons can be found in "system/core/bootstat/bootstat.cpp". |
| 691 | static const std::vector<std::string> kBootreasonBlacklist{ |
| 692 | "kernel_panic", |
| 693 | "Panic", |
| 694 | }; |
| 695 | for (const auto& str : kBootreasonBlacklist) { |
| 696 | if (android::base::EqualsIgnoreCase(str, bootreason)) return true; |
Tianjie Xu | 06e57ac | 2016-07-11 14:04:08 -0700 | [diff] [blame] | 697 | } |
Tao Bao | efc3559 | 2017-01-08 22:45:47 -0800 | [diff] [blame] | 698 | } |
| 699 | return false; |
Tianjie Xu | 06e57ac | 2016-07-11 14:04:08 -0700 | [diff] [blame] | 700 | } |
| 701 | |
Tao Bao | 641fa97 | 2018-04-25 18:59:40 -0700 | [diff] [blame] | 702 | static void log_failure_code(ErrorCode code, const std::string& update_package) { |
| 703 | std::vector<std::string> log_buffer = { |
| 704 | update_package, |
| 705 | "0", // install result |
| 706 | "error: " + std::to_string(code), |
| 707 | }; |
| 708 | std::string log_content = android::base::Join(log_buffer, "\n"); |
| 709 | const std::string& install_file = Paths::Get().temporary_install_file(); |
| 710 | if (!android::base::WriteStringToFile(log_content, install_file)) { |
| 711 | PLOG(ERROR) << "Failed to write " << install_file; |
| 712 | } |
Tianjie Xu | 06e57ac | 2016-07-11 14:04:08 -0700 | [diff] [blame] | 713 | |
Tao Bao | 641fa97 | 2018-04-25 18:59:40 -0700 | [diff] [blame] | 714 | // Also write the info into last_log. |
| 715 | LOG(INFO) << log_content; |
Tianjie Xu | 06e57ac | 2016-07-11 14:04:08 -0700 | [diff] [blame] | 716 | } |
| 717 | |
Jerry Zhang | 6a64804 | 2018-05-04 11:24:10 -0700 | [diff] [blame] | 718 | Device::BuiltinAction start_recovery(Device* device, const std::vector<std::string>& args) { |
Tao Bao | f9f1734 | 2018-04-27 10:44:04 -0700 | [diff] [blame] | 719 | static constexpr struct option OPTIONS[] = { |
Hridya Valsaraju | 20c81b3 | 2018-07-27 22:09:12 -0700 | [diff] [blame] | 720 | { "fastboot", no_argument, nullptr, 0 }, |
David Anderson | edee836 | 2018-05-16 13:43:22 -0700 | [diff] [blame] | 721 | { "fsck_unshare_blocks", no_argument, nullptr, 0 }, |
Tao Bao | f9f1734 | 2018-04-27 10:44:04 -0700 | [diff] [blame] | 722 | { "just_exit", no_argument, nullptr, 'x' }, |
| 723 | { "locale", required_argument, nullptr, 0 }, |
| 724 | { "prompt_and_wipe_data", no_argument, nullptr, 0 }, |
| 725 | { "reason", required_argument, nullptr, 0 }, |
| 726 | { "retry_count", required_argument, nullptr, 0 }, |
| 727 | { "security", no_argument, nullptr, 0 }, |
| 728 | { "show_text", no_argument, nullptr, 't' }, |
| 729 | { "shutdown_after", no_argument, nullptr, 0 }, |
| 730 | { "sideload", no_argument, nullptr, 0 }, |
| 731 | { "sideload_auto_reboot", no_argument, nullptr, 0 }, |
| 732 | { "update_package", required_argument, nullptr, 0 }, |
| 733 | { "wipe_ab", no_argument, nullptr, 0 }, |
| 734 | { "wipe_cache", no_argument, nullptr, 0 }, |
| 735 | { "wipe_data", no_argument, nullptr, 0 }, |
| 736 | { "wipe_package_size", required_argument, nullptr, 0 }, |
| 737 | { nullptr, 0, nullptr, 0 }, |
| 738 | }; |
| 739 | |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 740 | const char* update_package = nullptr; |
| 741 | bool should_wipe_data = false; |
| 742 | bool should_prompt_and_wipe_data = false; |
| 743 | bool should_wipe_cache = false; |
| 744 | bool should_wipe_ab = false; |
| 745 | size_t wipe_package_size = 0; |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 746 | bool sideload = false; |
| 747 | bool sideload_auto_reboot = false; |
| 748 | bool just_exit = false; |
| 749 | bool shutdown_after = false; |
David Anderson | edee836 | 2018-05-16 13:43:22 -0700 | [diff] [blame] | 750 | bool fsck_unshare_blocks = false; |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 751 | int retry_count = 0; |
| 752 | bool security_update = false; |
Jerry Zhang | 2dea53e | 2018-05-02 17:15:03 -0700 | [diff] [blame] | 753 | std::string locale; |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 754 | |
Tao Bao | 1700cc4 | 2018-07-16 22:09:59 -0700 | [diff] [blame] | 755 | auto args_to_parse = StringVectorToNullTerminatedArray(args); |
| 756 | |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 757 | int arg; |
| 758 | int option_index; |
Tao Bao | 1700cc4 | 2018-07-16 22:09:59 -0700 | [diff] [blame] | 759 | // Parse everything before the last element (which must be a nullptr). getopt_long(3) expects a |
| 760 | // null-terminated char* array, but without counting null as an arg (i.e. argv[argc] should be |
| 761 | // nullptr). |
| 762 | while ((arg = getopt_long(args_to_parse.size() - 1, args_to_parse.data(), "", OPTIONS, |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 763 | &option_index)) != -1) { |
| 764 | switch (arg) { |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 765 | case 't': |
Jerry Zhang | 6a64804 | 2018-05-04 11:24:10 -0700 | [diff] [blame] | 766 | // Handled in recovery_main.cpp |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 767 | break; |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 768 | case 'x': |
| 769 | just_exit = true; |
| 770 | break; |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 771 | case 0: { |
| 772 | std::string option = OPTIONS[option_index].name; |
David Anderson | edee836 | 2018-05-16 13:43:22 -0700 | [diff] [blame] | 773 | if (option == "fsck_unshare_blocks") { |
| 774 | fsck_unshare_blocks = true; |
Hridya Valsaraju | 20c81b3 | 2018-07-27 22:09:12 -0700 | [diff] [blame] | 775 | } else if (option == "locale" || option == "fastboot") { |
Jerry Zhang | 6a64804 | 2018-05-04 11:24:10 -0700 | [diff] [blame] | 776 | // Handled in recovery_main.cpp |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 777 | } else if (option == "prompt_and_wipe_data") { |
| 778 | should_prompt_and_wipe_data = true; |
Tao Bao | f9f1734 | 2018-04-27 10:44:04 -0700 | [diff] [blame] | 779 | } else if (option == "reason") { |
| 780 | reason = optarg; |
| 781 | } else if (option == "retry_count") { |
| 782 | android::base::ParseInt(optarg, &retry_count, 0); |
| 783 | } else if (option == "security") { |
| 784 | security_update = true; |
| 785 | } else if (option == "sideload") { |
| 786 | sideload = true; |
| 787 | } else if (option == "sideload_auto_reboot") { |
| 788 | sideload = true; |
| 789 | sideload_auto_reboot = true; |
| 790 | } else if (option == "shutdown_after") { |
| 791 | shutdown_after = true; |
| 792 | } else if (option == "update_package") { |
| 793 | update_package = optarg; |
| 794 | } else if (option == "wipe_ab") { |
| 795 | should_wipe_ab = true; |
| 796 | } else if (option == "wipe_cache") { |
| 797 | should_wipe_cache = true; |
| 798 | } else if (option == "wipe_data") { |
| 799 | should_wipe_data = true; |
| 800 | } else if (option == "wipe_package_size") { |
| 801 | android::base::ParseUint(optarg, &wipe_package_size); |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 802 | } |
| 803 | break; |
| 804 | } |
| 805 | case '?': |
| 806 | LOG(ERROR) << "Invalid command argument"; |
| 807 | continue; |
Doug Zongker | 9270a20 | 2012-01-09 15:16:13 -0800 | [diff] [blame] | 808 | } |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 809 | } |
Jerry Zhang | 49fd5d2 | 2018-05-17 12:54:41 -0700 | [diff] [blame] | 810 | optind = 1; |
Doug Zongker | 9270a20 | 2012-01-09 15:16:13 -0800 | [diff] [blame] | 811 | |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 812 | printf("stage is [%s]\n", stage.c_str()); |
| 813 | printf("reason is [%s]\n", reason); |
Doug Zongker | 02ec6b8 | 2012-08-22 17:26:40 -0700 | [diff] [blame] | 814 | |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 815 | // Set background string to "installing security update" for security update, |
| 816 | // otherwise set it to "installing system update". |
| 817 | ui->SetSystemUpdateText(security_update); |
| 818 | |
| 819 | int st_cur, st_max; |
| 820 | if (!stage.empty() && sscanf(stage.c_str(), "%d/%d", &st_cur, &st_max) == 2) { |
| 821 | ui->SetStage(st_cur, st_max); |
| 822 | } |
| 823 | |
Jerry Zhang | 0e577ee | 2018-05-07 11:21:10 -0700 | [diff] [blame] | 824 | std::vector<std::string> title_lines = |
| 825 | android::base::Split(android::base::GetProperty("ro.bootimage.build.fingerprint", ""), ":"); |
| 826 | title_lines.insert(std::begin(title_lines), "Android Recovery"); |
| 827 | ui->SetTitle(title_lines); |
| 828 | |
Jerry Zhang | b76af93 | 2018-05-22 12:08:35 -0700 | [diff] [blame] | 829 | ui->ResetKeyInterruptStatus(); |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 830 | device->StartRecovery(); |
| 831 | |
| 832 | printf("Command:"); |
| 833 | for (const auto& arg : args) { |
| 834 | printf(" \"%s\"", arg.c_str()); |
| 835 | } |
| 836 | printf("\n\n"); |
| 837 | |
| 838 | property_list(print_property, nullptr); |
| 839 | printf("\n"); |
| 840 | |
| 841 | ui->Print("Supported API: %d\n", kRecoveryApiVersion); |
| 842 | |
| 843 | int status = INSTALL_SUCCESS; |
| 844 | |
| 845 | if (update_package != nullptr) { |
| 846 | // It's not entirely true that we will modify the flash. But we want |
| 847 | // to log the update attempt since update_package is non-NULL. |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 848 | save_current_log = true; |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 849 | |
Tao Bao | 6d90a9d | 2018-04-26 10:40:36 -0700 | [diff] [blame] | 850 | int required_battery_level; |
| 851 | if (retry_count == 0 && !is_battery_ok(&required_battery_level)) { |
| 852 | ui->Print("battery capacity is not enough for installing package: %d%% needed\n", |
| 853 | required_battery_level); |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 854 | // Log the error code to last_install when installation skips due to |
| 855 | // low battery. |
| 856 | log_failure_code(kLowBattery, update_package); |
| 857 | status = INSTALL_SKIPPED; |
Tianjie Xu | a6f49bd | 2018-03-26 14:32:11 -0700 | [diff] [blame] | 858 | } else if (retry_count == 0 && bootreason_in_blacklist()) { |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 859 | // Skip update-on-reboot when bootreason is kernel_panic or similar |
| 860 | ui->Print("bootreason is in the blacklist; skip OTA installation\n"); |
| 861 | log_failure_code(kBootreasonInBlacklist, update_package); |
| 862 | status = INSTALL_SKIPPED; |
Dmitri Plotnikov | 8706a98 | 2017-04-18 08:28:26 -0700 | [diff] [blame] | 863 | } else { |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 864 | // It's a fresh update. Initialize the retry_count in the BCB to 1; therefore we can later |
| 865 | // identify the interrupted update due to unexpected reboots. |
| 866 | if (retry_count == 0) { |
| 867 | set_retry_bootloader_message(retry_count + 1, args); |
Tao Bao | 7022f33 | 2017-07-25 09:52:36 -0700 | [diff] [blame] | 868 | } |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 869 | |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 870 | status = install_package(update_package, should_wipe_cache, true, retry_count, ui); |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 871 | if (status != INSTALL_SUCCESS) { |
| 872 | ui->Print("Installation aborted.\n"); |
Tao Bao | aac9d9f | 2018-04-29 23:38:59 -0700 | [diff] [blame] | 873 | |
| 874 | // When I/O error or bspatch/imgpatch error happens, reboot and retry installation |
| 875 | // RETRY_LIMIT times before we abandon this OTA update. |
| 876 | static constexpr int RETRY_LIMIT = 4; |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 877 | if (status == INSTALL_RETRY && retry_count < RETRY_LIMIT) { |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 878 | copy_logs(save_current_log, has_cache, sehandle); |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 879 | retry_count += 1; |
| 880 | set_retry_bootloader_message(retry_count, args); |
| 881 | // Print retry count on screen. |
| 882 | ui->Print("Retry attempt %d\n", retry_count); |
| 883 | |
| 884 | // Reboot and retry the update |
| 885 | if (!reboot("reboot,recovery")) { |
| 886 | ui->Print("Reboot failed\n"); |
| 887 | } else { |
| 888 | while (true) { |
| 889 | pause(); |
| 890 | } |
| 891 | } |
Tianjie Xu | d9d1629 | 2017-04-20 18:08:21 -0700 | [diff] [blame] | 892 | } |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 893 | // If this is an eng or userdebug build, then automatically |
| 894 | // turn the text display on if the script fails so the error |
| 895 | // message is visible. |
| 896 | if (is_ro_debuggable()) { |
| 897 | ui->ShowText(true); |
Tao Bao | c679f93 | 2015-03-30 09:43:49 -0700 | [diff] [blame] | 898 | } |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 899 | } |
Doug Zongker | 8674a72 | 2010-09-15 11:08:23 -0700 | [diff] [blame] | 900 | } |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 901 | } else if (should_wipe_data) { |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 902 | save_current_log = true; |
| 903 | bool convert_fbe = reason && strcmp(reason, "convert_fbe") == 0; |
| 904 | if (!WipeData(device, convert_fbe)) { |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 905 | status = INSTALL_ERROR; |
Doug Zongker | b1d1263 | 2014-03-18 10:32:12 -0700 | [diff] [blame] | 906 | } |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 907 | } else if (should_prompt_and_wipe_data) { |
Tao Bao | a5bbcb9 | 2018-09-17 14:32:47 -0700 | [diff] [blame] | 908 | // Trigger the logging to capture the cause, even if user chooses to not wipe data. |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 909 | save_current_log = true; |
Tao Bao | a5bbcb9 | 2018-09-17 14:32:47 -0700 | [diff] [blame] | 910 | |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 911 | ui->ShowText(true); |
| 912 | ui->SetBackground(RecoveryUI::ERROR); |
Hridya Valsaraju | eb6f13a | 2018-09-12 10:25:01 -0700 | [diff] [blame] | 913 | status = prompt_and_wipe_data(device); |
| 914 | if (status != INSTALL_KEY_INTERRUPTED) { |
| 915 | ui->ShowText(false); |
Tao Bao | 7523863 | 2015-05-27 14:46:17 -0700 | [diff] [blame] | 916 | } |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 917 | } else if (should_wipe_cache) { |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 918 | save_current_log = true; |
| 919 | if (!WipeCache(ui, nullptr)) { |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 920 | status = INSTALL_ERROR; |
| 921 | } |
| 922 | } else if (should_wipe_ab) { |
| 923 | if (!wipe_ab_device(wipe_package_size)) { |
| 924 | status = INSTALL_ERROR; |
| 925 | } |
| 926 | } else if (sideload) { |
| 927 | // 'adb reboot sideload' acts the same as user presses key combinations |
| 928 | // to enter the sideload mode. When 'sideload-auto-reboot' is used, text |
| 929 | // display will NOT be turned on by default. And it will reboot after |
| 930 | // sideload finishes even if there are errors. Unless one turns on the |
| 931 | // text display during the installation. This is to enable automated |
| 932 | // testing. |
xunchang | 388d253 | 2019-04-12 16:22:15 -0700 | [diff] [blame] | 933 | save_current_log = true; |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 934 | if (!sideload_auto_reboot) { |
| 935 | ui->ShowText(true); |
| 936 | } |
Tao Bao | 378bfbf | 2019-04-16 14:22:25 -0700 | [diff] [blame] | 937 | status = ApplyFromAdb(ui, false /* rescue_mode */); |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 938 | ui->Print("\nInstall from ADB complete (status: %d).\n", status); |
| 939 | if (sideload_auto_reboot) { |
| 940 | ui->Print("Rebooting automatically.\n"); |
| 941 | } |
David Anderson | edee836 | 2018-05-16 13:43:22 -0700 | [diff] [blame] | 942 | } else if (fsck_unshare_blocks) { |
| 943 | if (!do_fsck_unshare_blocks()) { |
| 944 | status = INSTALL_ERROR; |
| 945 | } |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 946 | } else if (!just_exit) { |
| 947 | // If this is an eng or userdebug build, automatically turn on the text display if no command |
| 948 | // is specified. Note that this should be called before setting the background to avoid |
| 949 | // flickering the background image. |
| 950 | if (is_ro_debuggable()) { |
| 951 | ui->ShowText(true); |
| 952 | } |
| 953 | status = INSTALL_NONE; // No command specified |
| 954 | ui->SetBackground(RecoveryUI::NO_COMMAND); |
| 955 | } |
| 956 | |
| 957 | if (status == INSTALL_ERROR || status == INSTALL_CORRUPT) { |
| 958 | ui->SetBackground(RecoveryUI::ERROR); |
| 959 | if (!ui->IsTextVisible()) { |
| 960 | sleep(5); |
| 961 | } |
| 962 | } |
| 963 | |
| 964 | Device::BuiltinAction after = shutdown_after ? Device::SHUTDOWN : Device::REBOOT; |
| 965 | // 1. If the recovery menu is visible, prompt and wait for commands. |
| 966 | // 2. If the state is INSTALL_NONE, wait for commands. (i.e. In user build, manually reboot into |
| 967 | // recovery to sideload a package.) |
| 968 | // 3. sideload_auto_reboot is an option only available in user-debug build, reboot the device |
| 969 | // without waiting. |
| 970 | // 4. In all other cases, reboot the device. Therefore, normal users will observe the device |
| 971 | // reboot after it shows the "error" screen for 5s. |
| 972 | if ((status == INSTALL_NONE && !sideload_auto_reboot) || ui->IsTextVisible()) { |
| 973 | Device::BuiltinAction temp = prompt_and_wait(device, status); |
| 974 | if (temp != Device::NO_ACTION) { |
| 975 | after = temp; |
| 976 | } |
| 977 | } |
| 978 | |
| 979 | // Save logs and clean up before rebooting or shutting down. |
Tao Bao | 551d2c3 | 2018-05-09 20:53:13 -0700 | [diff] [blame] | 980 | finish_recovery(); |
Tianjie Xu | 99b73be | 2017-11-28 17:23:06 -0800 | [diff] [blame] | 981 | |
Jerry Zhang | 6a64804 | 2018-05-04 11:24:10 -0700 | [diff] [blame] | 982 | return after; |
The Android Open Source Project | c24a8e6 | 2009-03-03 19:28:42 -0800 | [diff] [blame] | 983 | } |