blob: 5ccd38f2cf442db34b38e0142000746a6b71ba7c [file] [log] [blame]
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -08001/*
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
17#include <ctype.h>
18#include <errno.h>
19#include <fcntl.h>
20#include <getopt.h>
21#include <limits.h>
22#include <linux/input.h>
23#include <stdio.h>
24#include <stdlib.h>
25#include <string.h>
26#include <sys/reboot.h>
27#include <sys/types.h>
28#include <time.h>
29#include <unistd.h>
30
31#include "bootloader.h"
32#include "commands.h"
33#include "common.h"
34#include "cutils/properties.h"
35#include "firmware.h"
36#include "install.h"
37#include "minui/minui.h"
38#include "minzip/DirUtil.h"
39#include "roots.h"
40
41static const struct option OPTIONS[] = {
42 { "send_intent", required_argument, NULL, 's' },
43 { "update_package", required_argument, NULL, 'u' },
44 { "wipe_data", no_argument, NULL, 'w' },
45 { "wipe_cache", no_argument, NULL, 'c' },
46};
47
48static const char *COMMAND_FILE = "CACHE:recovery/command";
49static const char *INTENT_FILE = "CACHE:recovery/intent";
50static const char *LOG_FILE = "CACHE:recovery/log";
51static const char *SDCARD_PACKAGE_FILE = "SDCARD:update.zip";
52static const char *TEMPORARY_LOG_FILE = "/tmp/recovery.log";
53
54/*
55 * The recovery tool communicates with the main system through /cache files.
56 * /cache/recovery/command - INPUT - command line for tool, one arg per line
57 * /cache/recovery/log - OUTPUT - combined log file from recovery run(s)
58 * /cache/recovery/intent - OUTPUT - intent that was passed in
59 *
60 * The arguments which may be supplied in the recovery.command file:
61 * --send_intent=anystring - write the text out to recovery.intent
62 * --update_package=root:path - verify install an OTA package file
63 * --wipe_data - erase user data (and cache), then reboot
64 * --wipe_cache - wipe cache (but not user data), then reboot
65 *
66 * After completing, we remove /cache/recovery/command and reboot.
67 * Arguments may also be supplied in the bootloader control block (BCB).
68 * These important scenarios must be safely restartable at any point:
69 *
70 * FACTORY RESET
71 * 1. user selects "factory reset"
72 * 2. main system writes "--wipe_data" to /cache/recovery/command
73 * 3. main system reboots into recovery
74 * 4. get_args() writes BCB with "boot-recovery" and "--wipe_data"
75 * -- after this, rebooting will restart the erase --
76 * 5. erase_root() reformats /data
77 * 6. erase_root() reformats /cache
78 * 7. finish_recovery() erases BCB
79 * -- after this, rebooting will restart the main system --
80 * 8. main() calls reboot() to boot main system
81 *
82 * OTA INSTALL
83 * 1. main system downloads OTA package to /cache/some-filename.zip
84 * 2. main system writes "--update_package=CACHE:some-filename.zip"
85 * 3. main system reboots into recovery
86 * 4. get_args() writes BCB with "boot-recovery" and "--update_package=..."
87 * -- after this, rebooting will attempt to reinstall the update --
88 * 5. install_package() attempts to install the update
89 * NOTE: the package install must itself be restartable from any point
90 * 6. finish_recovery() erases BCB
91 * -- after this, rebooting will (try to) restart the main system --
92 * 7. ** if install failed **
93 * 7a. prompt_and_wait() shows an error icon and waits for the user
94 * 7b; the user reboots (pulling the battery, etc) into the main system
95 * 8. main() calls maybe_install_firmware_update()
96 * ** if the update contained radio/hboot firmware **:
97 * 8a. m_i_f_u() writes BCB with "boot-recovery" and "--wipe_cache"
98 * -- after this, rebooting will reformat cache & restart main system --
99 * 8b. m_i_f_u() writes firmware image into raw cache partition
100 * 8c. m_i_f_u() writes BCB with "update-radio/hboot" and "--wipe_cache"
101 * -- after this, rebooting will attempt to reinstall firmware --
102 * 8d. bootloader tries to flash firmware
103 * 8e. bootloader writes BCB with "boot-recovery" (keeping "--wipe_cache")
104 * -- after this, rebooting will reformat cache & restart main system --
105 * 8f. erase_root() reformats /cache
106 * 8g. finish_recovery() erases BCB
107 * -- after this, rebooting will (try to) restart the main system --
108 * 9. main() calls reboot() to boot main system
109 */
110
111static const int MAX_ARG_LENGTH = 4096;
112static const int MAX_ARGS = 100;
113
114// open a file given in root:path format, mounting partitions as necessary
115static FILE*
116fopen_root_path(const char *root_path, const char *mode) {
117 if (ensure_root_path_mounted(root_path) != 0) {
118 LOGE("Can't mount %s\n", root_path);
119 return NULL;
120 }
121
122 char path[PATH_MAX] = "";
123 if (translate_root_path(root_path, path, sizeof(path)) == NULL) {
124 LOGE("Bad path %s\n", root_path);
125 return NULL;
126 }
127
128 // When writing, try to create the containing directory, if necessary.
129 // Use generous permissions, the system (init.rc) will reset them.
130 if (strchr("wa", mode[0])) dirCreateHierarchy(path, 0777, NULL, 1);
131
132 FILE *fp = fopen(path, mode);
133 if (fp == NULL) LOGE("Can't open %s\n", path);
134 return fp;
135}
136
137// close a file, log an error if the error indicator is set
138static void
139check_and_fclose(FILE *fp, const char *name) {
140 fflush(fp);
141 if (ferror(fp)) LOGE("Error in %s\n(%s)\n", name, strerror(errno));
142 fclose(fp);
143}
144
145// command line args come from, in decreasing precedence:
146// - the actual command line
147// - the bootloader control block (one per line, after "recovery")
148// - the contents of COMMAND_FILE (one per line)
149static void
150get_args(int *argc, char ***argv) {
151 struct bootloader_message boot;
152 memset(&boot, 0, sizeof(boot));
153 get_bootloader_message(&boot); // this may fail, leaving a zeroed structure
154
155 if (boot.command[0] != 0 && boot.command[0] != 255) {
156 LOGI("Boot command: %.*s\n", sizeof(boot.command), boot.command);
157 }
158
159 if (boot.status[0] != 0 && boot.status[0] != 255) {
160 LOGI("Boot status: %.*s\n", sizeof(boot.status), boot.status);
161 }
162
163 // --- if arguments weren't supplied, look in the bootloader control block
164 if (*argc <= 1) {
165 boot.recovery[sizeof(boot.recovery) - 1] = '\0'; // Ensure termination
166 const char *arg = strtok(boot.recovery, "\n");
167 if (arg != NULL && !strcmp(arg, "recovery")) {
168 *argv = (char **) malloc(sizeof(char *) * MAX_ARGS);
169 (*argv)[0] = strdup(arg);
170 for (*argc = 1; *argc < MAX_ARGS; ++*argc) {
171 if ((arg = strtok(NULL, "\n")) == NULL) break;
172 (*argv)[*argc] = strdup(arg);
173 }
174 LOGI("Got arguments from boot message\n");
175 } else if (boot.recovery[0] != 0 && boot.recovery[0] != 255) {
176 LOGE("Bad boot message\n\"%.20s\"\n", boot.recovery);
177 }
178 }
179
180 // --- if that doesn't work, try the command file
181 if (*argc <= 1) {
182 FILE *fp = fopen_root_path(COMMAND_FILE, "r");
183 if (fp != NULL) {
184 char *argv0 = (*argv)[0];
185 *argv = (char **) malloc(sizeof(char *) * MAX_ARGS);
186 (*argv)[0] = argv0; // use the same program name
187
188 char buf[MAX_ARG_LENGTH];
189 for (*argc = 1; *argc < MAX_ARGS; ++*argc) {
190 if (!fgets(buf, sizeof(buf), fp)) break;
191 (*argv)[*argc] = strdup(strtok(buf, "\r\n")); // Strip newline.
192 }
193
194 check_and_fclose(fp, COMMAND_FILE);
195 LOGI("Got arguments from %s\n", COMMAND_FILE);
196 }
197 }
198
199 // --> write the arguments we have back into the bootloader control block
200 // always boot into recovery after this (until finish_recovery() is called)
201 strlcpy(boot.command, "boot-recovery", sizeof(boot.command));
202 strlcpy(boot.recovery, "recovery\n", sizeof(boot.recovery));
203 int i;
204 for (i = 1; i < *argc; ++i) {
205 strlcat(boot.recovery, (*argv)[i], sizeof(boot.recovery));
206 strlcat(boot.recovery, "\n", sizeof(boot.recovery));
207 }
208 set_bootloader_message(&boot);
209}
210
211
212// clear the recovery command and prepare to boot a (hopefully working) system,
213// copy our log file to cache as well (for the system to read), and
214// record any intent we were asked to communicate back to the system.
215// this function is idempotent: call it as many times as you like.
216static void
217finish_recovery(const char *send_intent)
218{
219 // By this point, we're ready to return to the main system...
220 if (send_intent != NULL) {
221 FILE *fp = fopen_root_path(INTENT_FILE, "w");
222 if (fp != NULL) {
223 fputs(send_intent, fp);
224 check_and_fclose(fp, INTENT_FILE);
225 }
226 }
227
228 // Copy logs to cache so the system can find out what happened.
229 FILE *log = fopen_root_path(LOG_FILE, "a");
230 if (log != NULL) {
231 FILE *tmplog = fopen(TEMPORARY_LOG_FILE, "r");
232 if (tmplog == NULL) {
233 LOGE("Can't open %s\n", TEMPORARY_LOG_FILE);
234 } else {
235 static long tmplog_offset = 0;
236 fseek(tmplog, tmplog_offset, SEEK_SET); // Since last write
237 char buf[4096];
238 while (fgets(buf, sizeof(buf), tmplog)) fputs(buf, log);
239 tmplog_offset = ftell(tmplog);
240 check_and_fclose(tmplog, TEMPORARY_LOG_FILE);
241 }
242 check_and_fclose(log, LOG_FILE);
243 }
244
245 // Reset the bootloader message to revert to a normal main system boot.
246 struct bootloader_message boot;
247 memset(&boot, 0, sizeof(boot));
248 set_bootloader_message(&boot);
249
250 // Remove the command file, so recovery won't repeat indefinitely.
251 char path[PATH_MAX] = "";
252 if (ensure_root_path_mounted(COMMAND_FILE) != 0 ||
253 translate_root_path(COMMAND_FILE, path, sizeof(path)) == NULL ||
254 (unlink(path) && errno != ENOENT)) {
255 LOGW("Can't unlink %s\n", COMMAND_FILE);
256 }
257
258 sync(); // For good measure.
259}
260
261#define TEST_AMEND 0
262#if TEST_AMEND
263static void
264test_amend()
265{
266 extern int test_symtab(void);
267 extern int test_cmd_fn(void);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800268 int ret;
269 LOGD("Testing symtab...\n");
270 ret = test_symtab();
271 LOGD(" returned %d\n", ret);
272 LOGD("Testing cmd_fn...\n");
273 ret = test_cmd_fn();
274 LOGD(" returned %d\n", ret);
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800275}
276#endif // TEST_AMEND
277
278static int
279erase_root(const char *root)
280{
281 ui_set_background(BACKGROUND_ICON_INSTALLING);
282 ui_show_indeterminate_progress();
283 ui_print("Formatting %s...\n", root);
284 return format_root_device(root);
285}
286
287static void
288prompt_and_wait()
289{
Doug Zongkerfb2e3af2009-06-17 17:29:40 -0700290 char* headers[] = { "Android system recovery <"
291 EXPAND(RECOVERY_API_VERSION) ">",
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800292 "",
293 "Use trackball to highlight;",
294 "click to select.",
295 "",
296 NULL };
297
298 // these constants correspond to elements of the items[] list.
299#define ITEM_REBOOT 0
300#define ITEM_APPLY_SDCARD 1
301#define ITEM_WIPE_DATA 2
Doug Zongker1066d2c2009-04-01 13:57:40 -0700302#define ITEM_WIPE_CACHE 3
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800303 char* items[] = { "reboot system now [Home+Back]",
304 "apply sdcard:update.zip [Alt+S]",
305 "wipe data/factory reset [Alt+W]",
Doug Zongker1066d2c2009-04-01 13:57:40 -0700306 "wipe cache partition",
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800307 NULL };
308
309 ui_start_menu(headers, items);
310 int selected = 0;
311 int chosen_item = -1;
312
313 finish_recovery(NULL);
314 ui_reset_progress();
315 for (;;) {
316 int key = ui_wait_key();
317 int alt = ui_key_pressed(KEY_LEFTALT) || ui_key_pressed(KEY_RIGHTALT);
318 int visible = ui_text_visible();
319
320 if (key == KEY_DREAM_BACK && ui_key_pressed(KEY_DREAM_HOME)) {
321 // Wait for the keys to be released, to avoid triggering
322 // special boot modes (like coming back into recovery!).
323 while (ui_key_pressed(KEY_DREAM_BACK) ||
324 ui_key_pressed(KEY_DREAM_HOME)) {
325 usleep(1000);
326 }
327 chosen_item = ITEM_REBOOT;
328 } else if (alt && key == KEY_W) {
329 chosen_item = ITEM_WIPE_DATA;
330 } else if (alt && key == KEY_S) {
331 chosen_item = ITEM_APPLY_SDCARD;
332 } else if ((key == KEY_DOWN || key == KEY_VOLUMEDOWN) && visible) {
333 ++selected;
334 selected = ui_menu_select(selected);
335 } else if ((key == KEY_UP || key == KEY_VOLUMEUP) && visible) {
336 --selected;
337 selected = ui_menu_select(selected);
338 } else if (key == BTN_MOUSE && visible) {
339 chosen_item = selected;
340 }
341
342 if (chosen_item >= 0) {
343 // turn off the menu, letting ui_print() to scroll output
344 // on the screen.
345 ui_end_menu();
346
347 switch (chosen_item) {
348 case ITEM_REBOOT:
349 return;
350
351 case ITEM_WIPE_DATA:
352 ui_print("\n-- Wiping data...\n");
353 erase_root("DATA:");
354 erase_root("CACHE:");
355 ui_print("Data wipe complete.\n");
356 if (!ui_text_visible()) return;
357 break;
358
Doug Zongker1066d2c2009-04-01 13:57:40 -0700359 case ITEM_WIPE_CACHE:
360 ui_print("\n-- Wiping cache...\n");
361 erase_root("CACHE:");
362 ui_print("Cache wipe complete.\n");
363 if (!ui_text_visible()) return;
364 break;
365
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800366 case ITEM_APPLY_SDCARD:
367 ui_print("\n-- Install from sdcard...\n");
368 int status = install_package(SDCARD_PACKAGE_FILE);
369 if (status != INSTALL_SUCCESS) {
370 ui_set_background(BACKGROUND_ICON_ERROR);
371 ui_print("Installation aborted.\n");
372 } else if (!ui_text_visible()) {
373 return; // reboot if logs aren't visible
374 } else {
Doug Zongker07e1dca2009-05-28 19:02:45 -0700375 if (firmware_update_pending()) {
376 ui_print("\nReboot via home+back or menu\n"
377 "to complete installation.\n");
378 } else {
379 ui_print("\nInstall from sdcard complete.\n");
380 }
The Android Open Source Projectc24a8e62009-03-03 19:28:42 -0800381 }
382 break;
383 }
384
385 // if we didn't return from this function to reboot, show
386 // the menu again.
387 ui_start_menu(headers, items);
388 selected = 0;
389 chosen_item = -1;
390
391 finish_recovery(NULL);
392 ui_reset_progress();
393
394 // throw away keys pressed while the command was running,
395 // so user doesn't accidentally trigger menu items.
396 ui_clear_key_queue();
397 }
398 }
399}
400
401static void
402print_property(const char *key, const char *name, void *cookie)
403{
404 fprintf(stderr, "%s=%s\n", key, name);
405}
406
407int
408main(int argc, char **argv)
409{
410 time_t start = time(NULL);
411
412 // If these fail, there's not really anywhere to complain...
413 freopen(TEMPORARY_LOG_FILE, "a", stdout); setbuf(stdout, NULL);
414 freopen(TEMPORARY_LOG_FILE, "a", stderr); setbuf(stderr, NULL);
415 fprintf(stderr, "Starting recovery on %s", ctime(&start));
416
417 ui_init();
418 get_args(&argc, &argv);
419
420 int previous_runs = 0;
421 const char *send_intent = NULL;
422 const char *update_package = NULL;
423 int wipe_data = 0, wipe_cache = 0;
424
425 int arg;
426 while ((arg = getopt_long(argc, argv, "", OPTIONS, NULL)) != -1) {
427 switch (arg) {
428 case 'p': previous_runs = atoi(optarg); break;
429 case 's': send_intent = optarg; break;
430 case 'u': update_package = optarg; break;
431 case 'w': wipe_data = wipe_cache = 1; break;
432 case 'c': wipe_cache = 1; break;
433 case '?':
434 LOGE("Invalid command argument\n");
435 continue;
436 }
437 }
438
439 fprintf(stderr, "Command:");
440 for (arg = 0; arg < argc; arg++) {
441 fprintf(stderr, " \"%s\"", argv[arg]);
442 }
443 fprintf(stderr, "\n\n");
444
445 property_list(print_property, NULL);
446 fprintf(stderr, "\n");
447
448#if TEST_AMEND
449 test_amend();
450#endif
451
452 RecoveryCommandContext ctx = { NULL };
453 if (register_update_commands(&ctx)) {
454 LOGE("Can't install update commands\n");
455 }
456
457 int status = INSTALL_SUCCESS;
458
459 if (update_package != NULL) {
460 status = install_package(update_package);
461 if (status != INSTALL_SUCCESS) ui_print("Installation aborted.\n");
462 } else if (wipe_data || wipe_cache) {
463 if (wipe_data && erase_root("DATA:")) status = INSTALL_ERROR;
464 if (wipe_cache && erase_root("CACHE:")) status = INSTALL_ERROR;
465 if (status != INSTALL_SUCCESS) ui_print("Data wipe failed.\n");
466 } else {
467 status = INSTALL_ERROR; // No command specified
468 }
469
470 if (status != INSTALL_SUCCESS) ui_set_background(BACKGROUND_ICON_ERROR);
471 if (status != INSTALL_SUCCESS || ui_text_visible()) prompt_and_wait();
472
473 // If there is a radio image pending, reboot now to install it.
474 maybe_install_firmware_update(send_intent);
475
476 // Otherwise, get ready to boot the main system...
477 finish_recovery(send_intent);
478 ui_print("Rebooting...\n");
479 sync();
480 reboot(RB_AUTOBOOT);
481 return EXIT_SUCCESS;
482}