void process_volumes() {
create_fstab();
if (is_data_media()) {
setup_data_media();
}
return;
// dead code.
if (device_flash_type() != BML)
return;
ui_print("Checking for ext4 partitions...\n");
int ret = 0;
ret = bml_check_volume("/system");
ret |= bml_check_volume("/data");
if (has_datadata())
ret |= bml_check_volume("/datadata");
ret |= bml_check_volume("/cache");
if (ret == 0) {
ui_print("Done!\n");
return;
}
char backup_path[PATH_MAX];
//time_t t = time(NULL);
char backup_name[PATH_MAX];
struct timeval tp;
gettimeofday(&tp, NULL);
sprintf(backup_name, "before-ext4-convert-%d", tp.tv_sec);
if (target_sdcard == TARGET_INTERNAL_SDCARD) {
sprintf(backup_path, INTERNAL_SDCARD_PATH "/clockworkmod/backup/%s", backup_name);
} else {
sprintf(backup_path, EXTERNAL_SDCARD_PATH "/clockworkmod/backup/%s", backup_name);
}
ui_set_show_text(1);
ui_print("Filesystems need to be converted to ext4.\n");
ui_print("A backup and restore will now take place.\n");
ui_print("If anything goes wrong, your backup will be\n");
ui_print("named %s. Try restoring it\n", backup_name);
ui_print("in case of error.\n");
nandroid_backup(backup_path);
nandroid_restore(backup_path, 1, 1, 1, 1, 1, 0);
ui_set_show_text(0);
}
void process_volumes() {
create_fstab();
if (is_data_media()) {
setup_data_media();
}
return;
// dead code.
if (device_flash_type() != BML)
return;
ui_print("正在校验 EXT4 分区...\n");
int ret = 0;
ret = bml_check_volume("/system");
ret |= bml_check_volume("/data");
if (has_datadata())
ret |= bml_check_volume("/datadata");
ret |= bml_check_volume("/cache");
if (ret == 0) {
ui_print("校验完成!\n");
return;
}
char backup_path[PATH_MAX];
time_t t = time(NULL);
char backup_name[PATH_MAX];
struct timeval tp;
gettimeofday(&tp, NULL);
sprintf(backup_name, "before-ext4-convert-%d", tp.tv_sec);
sprintf(backup_path, "/sdcard/clockworkmod/backup/%s", backup_name);
ui_set_show_text(1);
ui_print("文件系统将会被转换为 EXT4格式.\n");
ui_print("将会进行备份和恢复操作.\n");
ui_print("如果出现错误你可以恢复\n");
ui_print("文件名为%s的备份\n", backup_name);
ui_print("在错误的情况下.\n");
nandroid_backup(backup_path);
nandroid_restore(backup_path, 1, 1, 1, 1, 1, 0);
ui_set_show_text(0);
}
int ensure_path_mounted(const char* path) {
Volume* v = volume_for_path(path);
if (v == NULL) {
// no /sdcard? let's assume /data/media
if (strstr(path, "/sdcard") == path && is_data_media()) {
LOGW("using /data/media, no /sdcard found.\n");
int ret;
if (0 != (ret = ensure_path_mounted("/data")))
return ret;
setup_data_media();
return 0;
}
LOGE("unknown volume for path [%s]\n", path);
return -1;
}
if (strcmp(v->fs_type, "ramdisk") == 0) {
// the ramdisk is always mounted.
return 0;
}
int result;
result = scan_mounted_volumes();
if (result < 0) {
LOGE("failed to scan mounted volumes\n");
return -1;
}
const MountedVolume* mv =
find_mounted_volume_by_mount_point(v->mount_point);
if (mv) {
// volume is already mounted
return 0;
}
mkdir(v->mount_point, 0755); // in case it doesn't already exist
if (strcmp(v->fs_type, "yaffs2") == 0) {
// mount an MTD partition as a YAFFS2 filesystem.
mtd_scan_partitions();
const MtdPartition* partition;
partition = mtd_find_partition_by_name(v->device);
if (partition == NULL) {
LOGE("failed to find \"%s\" partition to mount at \"%s\"\n",
v->device, v->mount_point);
return -1;
}
return mtd_mount_partition(partition, v->mount_point, v->fs_type, 0);
} else if (strcmp(v->fs_type, "ext4") == 0 ||
strcmp(v->fs_type, "ext3") == 0 ||
strcmp(v->fs_type, "rfs") == 0 ||
strcmp(v->fs_type, "vfat") == 0) {
if ((result = try_mount(v->device, v->mount_point, v->fs_type, v->fs_options)) == 0)
return 0;
if ((result = try_mount(v->device2, v->mount_point, v->fs_type, v->fs_options)) == 0)
return 0;
if ((result = try_mount(v->device, v->mount_point, v->fs_type2, v->fs_options2)) == 0)
return 0;
if ((result = try_mount(v->device2, v->mount_point, v->fs_type2, v->fs_options2)) == 0)
return 0;
return result;
} else {
// let's try mounting with the mount binary and hope for the best.
char mount_cmd[PATH_MAX];
sprintf(mount_cmd, "mount %s", path);
return __system(mount_cmd);
}
LOGE("unknown fs_type \"%s\" for %s\n", v->fs_type, v->mount_point);
return -1;
}
int
main(int argc, char **argv) {
time_t start = time(NULL);
// If this binary is started with the single argument "--adbd",
// instead of being the normal recovery binary, it turns into kind
// of a stripped-down version of adbd that only supports the
// 'sideload' command. Note this must be a real argument, not
// anything in the command file or bootloader control block; the
// only way recovery should be run with this argument is when it
// starts a copy of itself from the apply_from_adb() function.
if (argc == 2 && strcmp(argv[1], "--adbd") == 0) {
adb_main();
return 0;
}
// Handle alternative invocations
char* command = argv[0];
char* stripped = strrchr(argv[0], '/');
if (stripped)
command = stripped + 1;
if (strcmp(command, "recovery") != 0) {
struct recovery_cmd cmd = get_command(command);
if (cmd.name)
return cmd.main_func(argc, argv);
#ifdef BOARD_RECOVERY_HANDLES_MOUNT
if (!strcmp(command, "mount") && argc == 2)
{
load_volume_table();
return ensure_path_mounted(argv[1]);
}
#endif
if (!strcmp(command, "setup_adbd")) {
load_volume_table();
setup_adbd();
return 0;
}
if (strstr(argv[0], "start")) {
property_set("ctl.start", argv[1]);
return 0;
}
if (strstr(argv[0], "stop")) {
property_set("ctl.stop", argv[1]);
return 0;
}
return busybox_driver(argc, argv);
}
// devices can run specific tasks on recovery start
__system("/sbin/postrecoveryboot.sh");
// Clear umask for packages that copy files out to /tmp and then over
// to /system without properly setting all permissions (eg. gapps).
umask(0);
// If these fail, there's not really anywhere to complain...
freopen(TEMPORARY_LOG_FILE, "a", stdout); setbuf(stdout, NULL);
freopen(TEMPORARY_LOG_FILE, "a", stderr); setbuf(stderr, NULL);
printf("Starting recovery on %s", ctime(&start));
load_volume_table();
setup_data_media(1);
vold_client_start(&v_callbacks, 0);
vold_set_automount(1);
setup_legacy_storage_paths();
ensure_path_mounted(LAST_LOG_FILE);
rotate_last_logs(10);
get_args(&argc, &argv);
const char *send_intent = NULL;
const char *update_package = NULL;
int wipe_data = 0, wipe_cache = 0, wipe_media = 0, show_text = 0, sideload = 0;
bool just_exit = false;
bool shutdown_after = false;
printf("Checking arguments.\n");
int arg;
while ((arg = getopt_long(argc, argv, "", OPTIONS, NULL)) != -1) {
switch (arg) {
case 's': send_intent = optarg; break;
case 'u': update_package = optarg; break;
case 'w': wipe_data = wipe_cache = 1; break;
case 'm': wipe_media = 1; break;
case 'c': wipe_cache = 1; break;
case 't': show_text = 1; break;
case 'x': just_exit = true; break;
case 'a': sideload = 1; break;
case 'p': shutdown_after = true; break;
case 'g': {
if (stage == NULL || *stage == '\0') {
char buffer[20] = "1/";
strncat(buffer, optarg, sizeof(buffer)-3);
stage = strdup(buffer);
}
break;
}
case '?':
LOGE("Invalid command argument\n");
continue;
}
}
printf("stage is [%s]\n", stage);
device_ui_init(&ui_parameters);
ui_init();
ui_print(EXPAND(RECOVERY_MOD_VERSION_BUILD) "\n");
ui_print("ClockworkMod " EXPAND(CWM_BASE_VERSION) "\n");
LOGI("Device target: " EXPAND(TARGET_COMMON_NAME) "\n");
#ifdef PHILZ_TOUCH_RECOVERY
print_libtouch_version(0);
#endif
int st_cur, st_max;
if (stage != NULL && sscanf(stage, "%d/%d", &st_cur, &st_max) == 2) {
ui_SetStage(st_cur, st_max);
}
// ui_SetStage(5, 8); // debug
if (show_text) ui_ShowText(true);
struct selinux_opt seopts[] = {
{ SELABEL_OPT_PATH, "/file_contexts" }
};
sehandle = selabel_open(SELABEL_CTX_FILE, seopts, 1);
if (!sehandle) {
ui_print("Warning: No file_contexts\n");
}
LOGI("device_recovery_start()\n");
device_recovery_start();
printf("Command:");
for (arg = 0; arg < argc; arg++) {
printf(" \"%s\"", argv[arg]);
}
printf("\n");
if (update_package) {
// For backwards compatibility on the cache partition only, if
// we're given an old 'root' path "CACHE:foo", change it to
// "/cache/foo".
if (strncmp(update_package, "CACHE:", 6) == 0) {
int len = strlen(update_package) + 10;
char* modified_path = (char*)malloc(len);
strlcpy(modified_path, "/cache/", len);
strlcat(modified_path, update_package+6, len);
printf("(replacing path \"%s\" with \"%s\")\n",
update_package, modified_path);
update_package = modified_path;
}
}
printf("\n");
property_list(print_property, NULL);
printf("\n");
int status = INSTALL_SUCCESS;
if (update_package != NULL) {
status = install_package(update_package, &wipe_cache, TEMPORARY_INSTALL_FILE);
if (status == INSTALL_SUCCESS && wipe_cache) {
if (erase_volume("/cache")) {
LOGE("Cache wipe (requested by package) failed.\n");
}
}
if (status != INSTALL_SUCCESS) {
ui_print("Installation aborted.\n");
// If this is an eng or userdebug build, then automatically
// turn the text display on if the script fails so the error
// message is visible.
char buffer[PROPERTY_VALUE_MAX+1];
property_get("ro.build.fingerprint", buffer, "");
if (strstr(buffer, ":userdebug/") || strstr(buffer, ":eng/")) {
ui_ShowText(true);
}
}
} else if (wipe_data) {
if (device_wipe_data()) status = INSTALL_ERROR;
if (erase_volume("/data")) status = INSTALL_ERROR;
if (has_datadata() && erase_volume("/datadata")) status = INSTALL_ERROR;
if (wipe_cache && erase_volume("/cache")) status = INSTALL_ERROR;
if (status != INSTALL_SUCCESS) ui_print("Data wipe failed.\n");
} else if (wipe_cache) {
if (wipe_cache && erase_volume("/cache")) status = INSTALL_ERROR;
if (status != INSTALL_SUCCESS) ui_print("Cache wipe failed.\n");
} else if (wipe_media) {
if (is_data_media() && erase_volume("/data/media")) status = INSTALL_ERROR;
if (status != INSTALL_SUCCESS) ui_print("Media wipe failed.\n");
} else if (sideload) {
status = enter_sideload_mode(status);
} else if (!just_exit) {
// let's check recovery start up scripts (openrecoveryscript and ROM Manager extendedcommands)
status = INSTALL_NONE; // No command specified, it is a normal recovery boot unless we find a boot script to run
LOGI("Checking for extendedcommand & OpenRecoveryScript...\n");
// we need show_text to show boot scripts log
bool text_visible = ui_IsTextVisible();
ui_SetShowText(true);
if (0 == check_boot_script_file(EXTENDEDCOMMAND_SCRIPT)) {
LOGI("Running extendedcommand...\n");
status = INSTALL_ERROR;
if (0 == run_and_remove_extendedcommand())
status = INSTALL_SUCCESS;
}
if (0 == check_boot_script_file(ORS_BOOT_SCRIPT_FILE)) {
LOGI("Running openrecoveryscript....\n");
status = INSTALL_ERROR;
if (0 == run_ors_boot_script())
status = INSTALL_SUCCESS;
}
ui_SetShowText(text_visible);
}
if (status == INSTALL_ERROR || status == INSTALL_CORRUPT) {
copy_logs();
// ui_set_background(BACKGROUND_ICON_ERROR); // will be set in prompt_and_wait() after recovery lock check
handle_failure();
}
if (status != INSTALL_SUCCESS || ui_IsTextVisible()) {
ui_SetShowText(true);
#ifdef PHILZ_TOUCH_RECOVERY
check_recovery_lock();
#endif
prompt_and_wait(status);
}
// We reach here when in main menu we choose reboot main system or on success install of boot scripts and recovery commands
finish_recovery(send_intent);
if (shutdown_after) {
ui_print("Shutting down...\n");
reboot_main_system(ANDROID_RB_POWEROFF, 0, 0);
} else {
ui_print("Rebooting...\n");
reboot_main_system(ANDROID_RB_RESTART, 0, 0);
}
return EXIT_SUCCESS;
}
int ensure_path_mounted_at_mount_point(const char* path, const char* mount_point) {
if (is_data_media_volume_path(path)) {
if (ui_should_log_stdout()) {
LOGI("using /data/media for %s.\n", path);
}
int ret;
if (0 != (ret = ensure_path_mounted("/data")))
return ret;
setup_data_media();
return 0;
}
Volume* v = volume_for_path(path);
if (v == NULL) {
LOGE("unknown volume for path [%s]\n", path);
return -1;
}
if (strcmp(v->fs_type, "ramdisk") == 0) {
// the ramdisk is always mounted.
return 0;
}
int result;
result = scan_mounted_volumes();
if (result < 0) {
LOGE("failed to scan mounted volumes\n");
return -1;
}
if (NULL == mount_point)
mount_point = v->mount_point;
const MountedVolume* mv =
find_mounted_volume_by_mount_point(mount_point);
if (mv) {
// volume is already mounted
return 0;
}
mkdir(mount_point, 0755); // in case it doesn't already exist
if (fs_mgr_is_voldmanaged(v)) {
return vold_mount_volume(mount_point, 1) == CommandOkay ? 0 : -1;
} else if (strcmp(v->fs_type, "yaffs2") == 0) {
// mount an MTD partition as a YAFFS2 filesystem.
mtd_scan_partitions();
const MtdPartition* partition;
partition = mtd_find_partition_by_name(v->blk_device);
if (partition == NULL) {
LOGE("failed to find \"%s\" partition to mount at \"%s\"\n",
v->blk_device, mount_point);
return -1;
}
return mtd_mount_partition(partition, mount_point, v->fs_type, 0);
} else if (strcmp(v->fs_type, "ext4") == 0 ||
strcmp(v->fs_type, "ext3") == 0 ||
strcmp(v->fs_type, "rfs") == 0 ||
strcmp(v->fs_type, "vfat") == 0) {
if ((result = try_mount(v->blk_device, mount_point, v->fs_type, v->fs_options)) == 0)
return 0;
if ((result = try_mount(v->blk_device, mount_point, v->fs_type2, v->fs_options2)) == 0)
return 0;
if ((result = try_mount(v->blk_device2, mount_point, v->fs_type2, v->fs_options2)) == 0)
return 0;
return result;
} else {
// let's try mounting with the mount binary and hope for the best.
char mount_cmd[PATH_MAX];
sprintf(mount_cmd, "mount %s", mount_point);
return __system(mount_cmd);
}
return -1;
}
int ensure_path_mounted_at_mount_point(const char* path, const char* mount_point) {
Volume* v = volume_for_path(path);
if (v == NULL) {
LOGE("unknown volume for path [%s]\n", path);
return -1;
}
if (is_data_media_volume_path(path)) {
LOGI("using /data/media for %s.\n", path);
int ret;
if (0 != (ret = ensure_path_mounted("/data")))
return ret;
setup_data_media();
return 0;
}
if (strcmp(v->fs_type, "ramdisk") == 0) {
// the ramdisk is always mounted.
return 0;
}
int result;
result = scan_mounted_volumes();
if (result < 0) {
LOGE("failed to scan mounted volumes\n");
return -1;
}
if (NULL == mount_point)
mount_point = v->mount_point;
const MountedVolume* mv =
find_mounted_volume_by_mount_point(mount_point);
if (mv) {
// volume is already mounted
return 0;
}
mkdir(mount_point, 0755); // in case it doesn't already exist
if (strcmp(v->fs_type, "yaffs2") == 0) {
// mount an MTD partition as a YAFFS2 filesystem.
mtd_scan_partitions();
const MtdPartition* partition;
partition = mtd_find_partition_by_name(v->device);
if (partition == NULL) {
LOGE("failed to find \"%s\" partition to mount at \"%s\"\n",
v->device, mount_point);
return -1;
}
return mtd_mount_partition(partition, mount_point, v->fs_type, 0);
} else if (strcmp(v->fs_type, "ext4") == 0 ||
strcmp(v->fs_type, "ext3") == 0 ||
strcmp(v->fs_type, "rfs") == 0 ||
strcmp(v->fs_type, "vfat") == 0) {
if ((result = try_mount(v->device, mount_point, v->fs_type, v->fs_options)) == 0)
return 0;
if ((result = try_mount(v->device2, mount_point, v->fs_type, v->fs_options)) == 0)
return 0;
if ((result = try_mount(v->device, mount_point, v->fs_type2, v->fs_options2)) == 0)
return 0;
if ((result = try_mount(v->device2, mount_point, v->fs_type2, v->fs_options2)) == 0)
return 0;
#ifdef KYLE_TOUCH_RECOVERY
#include "/home/klaplante/recoverystuff/exfat2.c"
#endif
return result;
} else {
// let's try mounting with the mount binary and hope for the best.
char mount_cmd[PATH_MAX];
sprintf(mount_cmd, "mount %s", path);
return __system(mount_cmd);
}
LOGE("unknown fs_type \"%s\" for %s\n", v->fs_type, mount_point);
return -1;
}
