int ensure_path_unmounted(const char* path) {
// if we are using /data/media, do not ever unmount volumes /data or /sdcard
if (strstr(path, "/data") == path && is_data_media()) {
return 0;
}
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)) {
return ensure_path_unmounted("/data");
}
if (strcmp(v->fs_type, "ramdisk") == 0) {
// the ramdisk is always mounted; you can't unmount it.
return -1;
}
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 == NULL) {
// volume is already unmounted
return 0;
}
return unmount_mounted_volume(mv);
}
void setup_legacy_storage_paths() {
char* primary_path = get_primary_storage_path();
if (!is_data_media_volume_path(primary_path)) {
rmdir("/sdcard");
symlink(primary_path, "/sdcard");
}
}
int nandroid_restore_datamedia(const char* backup_path) {
char tmp[PATH_MAX];
ui_print("\n>> Restoring /data/media...\n");
if (is_data_media_volume_path(backup_path)) {
// non fatal failure
LOGE(" - can't restore folder to its self, skipping...\n");
return 0;
}
Volume *v = volume_for_path("/data");
if (v == NULL)
return -1;
sprintf(tmp, "%s/%s", get_primary_storage_path(), NANDROID_HIDE_PROGRESS_FILE);
ensure_path_mounted(tmp);
int callback = !file_found(tmp);
struct stat s;
char backup_file_image[PATH_MAX];
const char *filesystems[] = { "yaffs2", "ext2", "ext3", "ext4", "vfat", "exfat", "rfs", "f2fs", "auto", NULL };
const char *filesystem;
int i = 0;
nandroid_restore_handler restore_handler = NULL;
while ((filesystem = filesystems[i]) != NULL) {
sprintf(backup_file_image, "%s/datamedia.%s.tar", backup_path, filesystem);
if (0 == stat(backup_file_image, &s)) {
restore_handler = tar_extract_wrapper;
sprintf(tmp, "cd / ; set -o pipefail ; cat %s* | tar -xpv ; exit $?", backup_file_image);
break;
}
sprintf(backup_file_image, "%s/datamedia.%s.tar.gz", backup_path, filesystem);
if (0 == stat(backup_file_image, &s)) {
restore_handler = tar_gzip_extract_wrapper;
sprintf(tmp, "cd / ; set -o pipefail ; cat %s* | pigz -d -c | tar -xpv ; exit $?", backup_file_image);
break;
}
i++;
}
if (filesystem == NULL || restore_handler == NULL) {
LOGE("No backup found, skipping...\n");
return 0;
}
if (0 != format_unknown_device(NULL, "/data/media", NULL))
return print_and_error("Error while erasing /data/media\n", NANDROID_ERROR_GENERAL);
// data can be unmounted by format_unknown_device()
if (0 != ensure_path_mounted("/data"))
return -1;
if (0 != do_tar_extract(tmp, backup_file_image, "/data", callback))
return print_and_error("Failed to restore /data/media!\n", NANDROID_ERROR_GENERAL);
ui_print("Restore of /data/media completed.\n");
return 0;
}
// backup /data/media support
// we reach here only if backup_data_media == 1
// backup_data_media can be set to 1 only in "custom backup and restore" menu AND if is_data_media() && !twrp_backup_mode.value
int nandroid_backup_datamedia(const char* backup_path) {
char tmp[PATH_MAX];
ui_print("\n>> Backing up /data/media...\n");
if (is_data_media_volume_path(backup_path)) {
// non fatal failure
LOGE(" - can't backup folder to its self, skipping...\n");
return 0;
}
if (0 != ensure_path_mounted("/data"))
return -1;
sprintf(tmp, "%s/%s", get_primary_storage_path(), NANDROID_HIDE_PROGRESS_FILE);
ensure_path_mounted(tmp);
int callback = !file_found(tmp);
compute_directory_stats("/data/media");
Volume *v = volume_for_path("/data");
if (v == NULL)
return -1;
char backup_file_image[PATH_MAX];
sprintf(backup_file_image, "%s/datamedia.%s", backup_path, v->fs_type == NULL ? "auto" : v->fs_type);
int fmt;
fmt = nandroid_get_default_backup_format();
if (fmt == NANDROID_BACKUP_FORMAT_TAR) {
sprintf(tmp, "cd / ; touch %s.tar ; set -o pipefail ; (tar -cpv data/media | split -a 1 -b 1000000000 /proc/self/fd/0 %s.tar.) 2> /proc/self/fd/1 ; exit $?",
backup_file_image, backup_file_image);
} else if (fmt == NANDROID_BACKUP_FORMAT_TGZ) {
sprintf(tmp, "cd / ; touch %s.tar.gz ; set -o pipefail ; (tar -cpv data/media | pigz -c -%d | split -a 1 -b 1000000000 /proc/self/fd/0 %s.tar.gz.) 2> /proc/self/fd/1 ; exit $?",
backup_file_image, compression_value.value, backup_file_image);
} else {
// non fatal failure
LOGE(" - backup format must be tar(.gz), skipping...\n");
return 0;
}
int ret;
ret = do_tar_compress(tmp, callback, backup_file_image);
ensure_path_unmounted("/data");
if (0 != ret)
return print_and_error("Failed to backup /data/media!\n", ret);
ui_print("Backup of /data/media completed.\n");
return 0;
}
int format_device(const char *device, const char *path, const char *fs_type) {
Volume* v = volume_for_path(path);
if (v == NULL) {
// silent failure for sd-ext
if (strcmp(path, "/sd-ext") == 0)
return -1;
LOGE("unknown volume \"%s\"\n", path);
return -1;
}
if (is_data_media_volume_path(path)) {
return format_unknown_device(NULL, path, NULL);
}
if (strstr(path, "/data") == path && is_data_media()) {
return format_unknown_device(NULL, path, NULL);
}
if (strcmp(fs_type, "ramdisk") == 0) {
// you can't format the ramdisk.
LOGE("can't format_volume \"%s\"", path);
return -1;
}
if (strcmp(fs_type, "rfs") == 0) {
if (ensure_path_unmounted(path) != 0) {
LOGE("format_volume failed to unmount \"%s\"\n", v->mount_point);
return -1;
}
if (0 != format_rfs_device(device, path)) {
LOGE("format_volume: format_rfs_device failed on %s\n", device);
return -1;
}
return 0;
}
if (strcmp(v->mount_point, path) != 0) {
return format_unknown_device(v->device, path, NULL);
}
if (ensure_path_unmounted(path) != 0) {
LOGE("format_volume failed to unmount \"%s\"\n", v->mount_point);
return -1;
}
if (strcmp(fs_type, "yaffs2") == 0 || strcmp(fs_type, "mtd") == 0) {
mtd_scan_partitions();
const MtdPartition* partition = mtd_find_partition_by_name(device);
if (partition == NULL) {
LOGE("format_volume: no MTD partition \"%s\"\n", device);
return -1;
}
MtdWriteContext *write = mtd_write_partition(partition);
if (write == NULL) {
LOGW("format_volume: can't open MTD \"%s\"\n", device);
return -1;
} else if (mtd_erase_blocks(write, -1) == (off_t) -1) {
LOGW("format_volume: can't erase MTD \"%s\"\n", device);
mtd_write_close(write);
return -1;
} else if (mtd_write_close(write)) {
LOGW("format_volume: can't close MTD \"%s\"\n",device);
return -1;
}
return 0;
}
if (strcmp(fs_type, "ext4") == 0) {
int length = 0;
if (strcmp(v->fs_type, "ext4") == 0) {
// Our desired filesystem matches the one in fstab, respect v->length
length = v->length;
}
reset_ext4fs_info();
int result = make_ext4fs(device, length, v->mount_point, sehandle);
if (result != 0) {
LOGE("format_volume: make_extf4fs failed on %s\n", device);
return -1;
}
return 0;
}
return format_unknown_device(device, path, fs_type);
}
int nandroid_backup(const char* backup_path)
{
nandroid_backup_bitfield = 0;
ui_set_background(BACKGROUND_ICON_INSTALLING);
refresh_default_backup_handler();
if (ensure_path_mounted(backup_path) != 0) {
return print_and_error("Can't mount backup path.\n");
}
Volume* volume = volume_for_path(backup_path);
if (NULL == volume)
return print_and_error("Unable to find volume for backup path.\n");
if (is_data_media_volume_path(volume->mount_point))
volume = volume_for_path("/data");
int ret;
struct statfs s;
if (NULL != volume) {
if (0 != (ret = statfs(volume->mount_point, &s)))
return print_and_error("Unable to stat backup path.\n");
uint64_t bavail = s.f_bavail;
uint64_t bsize = s.f_bsize;
uint64_t sdcard_free = bavail * bsize;
uint64_t sdcard_free_mb = sdcard_free / (uint64_t)(1024 * 1024);
ui_print("SD Card space free: %lluMB\n", sdcard_free_mb);
if (sdcard_free_mb < 150)
ui_print("There may not be enough free space to complete backup... continuing...\n");
}
char tmp[PATH_MAX];
ensure_directory(backup_path);
if (backup_boot && 0 != (ret = nandroid_backup_partition(backup_path, "/boot")))
return ret;
if (backup_recovery && 0 != (ret = nandroid_backup_partition(backup_path, "/recovery")))
return ret;
Volume *vol = volume_for_path("/wimax");
if (backup_wimax && vol != NULL && 0 == stat(vol->device, &s))
{
char serialno[PROPERTY_VALUE_MAX];
ui_print("Backing up WiMAX...\n");
serialno[0] = 0;
property_get("ro.serialno", serialno, "");
sprintf(tmp, "%s/wimax.%s.img", backup_path, serialno);
ret = backup_raw_partition(vol->fs_type, vol->device, tmp);
if (0 != ret)
return print_and_error("Error while dumping WiMAX image!\n");
}
//2 copies of efs are made: tarball and raw backup
if (backup_efs) {
//first backup in raw format, returns 0 on success (or if skipped), else 1
if (0 != custom_backup_raw_handler(backup_path, "/efs")) {
ui_print("EFS raw image backup failed! Trying tar backup...\n");
}
//second backup in tar format
sprintf(tmp, "%s/efs_tar", backup_path);
ensure_directory(tmp);
if (0 != (ret = nandroid_backup_partition(tmp, "/efs")))
return ret;
}
if (backup_modem) {
if (0 != (ret = nandroid_backup_partition(backup_path, "/modem")))
return ret;
}
if (backup_system && 0 != (ret = nandroid_backup_partition(backup_path, "/system")))
return ret;
if (is_custom_backup && backup_preload) {
if (0 != (ret = nandroid_backup_partition(backup_path, "/preload"))) {
ui_print("Failed to backup /preload!\n");
return ret;
}
}
else if (!is_custom_backup
#ifdef PHILZ_TOUCH_RECOVERY
&& nandroid_add_preload
#endif
)
{
if (0 != (ret = nandroid_backup_partition(backup_path, "/preload"))) {
ui_print("Failed to backup preload! Try to disable it.\n");
ui_print("Skipping /preload...\n");
//return ret;
}
}
if (backup_data && 0 != (ret = nandroid_backup_partition(backup_path, "/data")))
return ret;
if (has_datadata()) {
if (backup_data && 0 != (ret = nandroid_backup_partition(backup_path, "/datadata")))
return ret;
}
if (is_data_media() || 0 != stat("/sdcard/.android_secure", &s)) {
ui_print("No /sdcard/.android_secure found. Skipping backup of applications on external storage.\n");
}
else {
if (backup_data && 0 != (ret = nandroid_backup_partition_extended(backup_path, "/sdcard/.android_secure", 0)))
return ret;
}
if (backup_cache && 0 != (ret = nandroid_backup_partition_extended(backup_path, "/cache", 0)))
return ret;
if (backup_sdext) {
vol = volume_for_path("/sd-ext");
if (vol == NULL || 0 != stat(vol->device, &s))
{
ui_print("No sd-ext found. Skipping backup of sd-ext.\n");
}
else
{
if (0 != ensure_path_mounted("/sd-ext"))
ui_print("Could not mount sd-ext. sd-ext backup may not be supported on this device. Skipping backup of sd-ext.\n");
else if (0 != (ret = nandroid_backup_partition(backup_path, "/sd-ext")))
return ret;
}
}
#ifdef PHILZ_TOUCH_RECOVERY
if (enable_md5sum)
#endif
{
ui_print("Generating md5 sum...\n");
sprintf(tmp, "nandroid-md5.sh %s", backup_path);
if (0 != (ret = __system(tmp))) {
ui_print("Error while generating md5 sum!\n");
return ret;
}
}
sprintf(tmp, "chmod -R 777 %s ; chmod -R u+r,u+w,g+r,g+w,o+r,o+w /sdcard/clockworkmod ; chmod u+x,g+x,o+x /sdcard/clockworkmod/backup ; chmod u+x,g+x,o+x /sdcard/clockworkmod/blobs", backup_path);
__system(tmp);
sync();
ui_set_background(BACKGROUND_ICON_NONE);
ui_reset_progress();
ui_print("\nBackup complete!\n");
return 0;
}
int nandroid_backup(const char* backup_path)
{
nandroid_backup_bitfield = 0;
ui_set_background(BACKGROUND_ICON_INSTALLING);
refresh_default_backup_handler();
if (ensure_path_mounted(backup_path) != 0) {
return print_and_error("无法挂载备份时需要的存储器.\n");
}
Volume* volume = volume_for_path(backup_path);
if (NULL == volume)
return print_and_error("找不到备份需要的存储器.\n");
if (is_data_media_volume_path(volume->mount_point))
volume = volume_for_path("/data");
int ret;
struct statfs s;
if (NULL != volume) {
if (0 != (ret = statfs(volume->mount_point, &s)))
return print_and_error("找不到备份路径，因此无法开始.\n");
uint64_t bavail = s.f_bavail;
uint64_t bsize = s.f_bsize;
uint64_t sdcard_free = bavail * bsize;
uint64_t sdcard_free_mb = sdcard_free / (uint64_t)(1024 * 1024);
ui_print("SD Card space free: %lluMB\n", sdcard_free_mb);
if (sdcard_free_mb < 150)
ui_print("可能是你的机器空间不足了，继续中...\n");
}
char tmp[PATH_MAX];
ensure_directory(backup_path);
if (0 != (ret = nandroid_backup_partition(backup_path, "/boot")))
return ret;
if (0 != (ret = nandroid_backup_partition(backup_path, "/uboot")))
return ret;
if (0 != (ret = nandroid_backup_partition(backup_path, "/recovery")))
return ret;
Volume *vol = volume_for_path("/wimax");
if (vol != NULL && 0 == stat(vol->device, &s))
{
char serialno[PROPERTY_VALUE_MAX];
ui_print("正在备份WiMAX...\n");
serialno[0] = 0;
property_get("ro.serialno", serialno, "");
sprintf(tmp, "%s/wimax.%s.img", backup_path, serialno);
ret = backup_raw_partition(vol->fs_type, vol->device, tmp);
if (0 != ret)
return print_and_error("打包或生成WiMAX镜像失败\n");
}
if (0 != (ret = nandroid_backup_partition(backup_path, "/system")))
return ret;
if (0 != (ret = nandroid_backup_partition(backup_path, "/data")))
return ret;
if (has_datadata()) {
if (0 != (ret = nandroid_backup_partition(backup_path, "/datadata")))
return ret;
}
if (is_data_media() || 0 != stat("/sdcard/.android_secure", &s)) {
ui_print("没找到 /sdcard/.android_secure. 跳过外部程序备份.\n");
}
else {
if (0 != (ret = nandroid_backup_partition_extended(backup_path, "/sdcard/.android_secure", 0)))
return ret;
}
if (0 != (ret = nandroid_backup_partition_extended(backup_path, "/cache", 0)))
return ret;
vol = volume_for_path("/sd-ext");
if (vol == NULL || 0 != stat(vol->device, &s))
{
ui_print("没找到SD-EXT，因此跳过该处备份.\n");
}
else
{
if (0 != ensure_path_mounted("/sd-ext"))
ui_print("没法挂载SD-EXT，可能是你的机器不支持该选项，跳过该部分的备份\n");
else if (0 != (ret = nandroid_backup_partition(backup_path, "/sd-ext")))
return ret;
}
ui_print("生成md5 校验值...\n");
sprintf(tmp, "nandroid-md5.sh %s", backup_path);
if (0 != (ret = __system(tmp))) {
ui_print("MD5校验值生成失败\n");
return ret;
}
sprintf(tmp, "cp /tmp/recovery.log %s/recovery.log", backup_path);
__system(tmp);
sprintf(tmp, "chmod -R 777 %s ; chmod -R u+r,u+w,g+r,g+w,o+r,o+w /sdcard/clockworkmod ; chmod u+x,g+x,o+x /sdcard/clockworkmod/backup ; chmod u+x,g+x,o+x /sdcard/clockworkmod/blobs", backup_path);
__system(tmp);
sync();
ui_set_background(BACKGROUND_ICON_NONE);
ui_reset_progress();
ui_print("\n备份完成!\n");
return 0;
}
int nandroid_backup(const char* backup_path)
{
nandroid_backup_bitfield = 0;
ui_set_background(BACKGROUND_ICON_INSTALLING);
refresh_default_backup_handler();
if (ensure_path_mounted(backup_path) != 0) {
return print_and_error("Can't mount backup path.\n");
}
Volume* volume = volume_for_path(backup_path);
if (NULL == volume)
return print_and_error("Unable to find volume for backup path.\n");
if (is_data_media_volume_path(volume->mount_point))
volume = volume_for_path("/data");
int ret;
struct statfs s;
if (NULL != volume) {
if (0 != (ret = statfs(volume->mount_point, &s)))
return print_and_error("Unable to stat backup path.\n");
uint64_t bavail = s.f_bavail;
uint64_t bsize = s.f_bsize;
uint64_t sdcard_free = bavail * bsize;
uint64_t sdcard_free_mb = sdcard_free / (uint64_t)(1024 * 1024);
ui_print("SD Card space free: %lluMB\n", sdcard_free_mb);
if (sdcard_free_mb < 150)
ui_print("There may not be enough free space to complete backup... continuing...\n");
}
char tmp[PATH_MAX];
ensure_directory(backup_path);
if (0 != (ret = nandroid_backup_partition(backup_path, "/boot")))
return ret;
if (0 != (ret = nandroid_backup_partition(backup_path, "/recovery")))
return ret;
Volume *vol = volume_for_path("/wimax");
if (vol != NULL && 0 == stat(vol->device, &s))
{
char serialno[PROPERTY_VALUE_MAX];
ui_print("Backing up WiMAX...\n");
serialno[0] = 0;
property_get("ro.serialno", serialno, "");
sprintf(tmp, "%s/wimax.%s.img", backup_path, serialno);
ret = backup_raw_partition(vol->fs_type, vol->device, tmp);
if (0 != ret)
return print_and_error("Error while dumping WiMAX image!\n");
}
if (0 != (ret = nandroid_backup_partition(backup_path, "/system")))
return ret;
if (0 != (ret = nandroid_backup_partition(backup_path, "/preload")))
return ret;
if (0 != (ret = nandroid_backup_partition(backup_path, "/data")))
return ret;
if (has_datadata()) {
if (0 != (ret = nandroid_backup_partition(backup_path, "/datadata")))
return ret;
}
if (is_data_media() || 0 != stat("/sdcard/.android_secure", &s)) {
ui_print("No /sdcard/.android_secure found. Skipping backup of applications on external storage.\n");
}
else {
if (0 != (ret = nandroid_backup_partition_extended(backup_path, "/sdcard/.android_secure", 0)))
return ret;
}
if (0 != (ret = nandroid_backup_partition_extended(backup_path, "/cache", 0)))
return ret;
vol = volume_for_path("/sd-ext");
if (vol == NULL || 0 != stat(vol->device, &s))
{
ui_print("No sd-ext found. Skipping backup of sd-ext.\n");
}
else
{
if (0 != ensure_path_mounted("/sd-ext"))
ui_print("Could not mount sd-ext. sd-ext backup may not be supported on this device. Skipping backup of sd-ext.\n");
else if (0 != (ret = nandroid_backup_partition(backup_path, "/sd-ext")))
return ret;
}
ui_print("Generating md5 sum...\n");
sprintf(tmp, "nandroid-md5.sh %s", backup_path);
if (0 != (ret = __system(tmp))) {
ui_print("Error while generating md5 sum!\n");
return ret;
}
sprintf(tmp, "chmod -R 777 %s ; chmod -R u+r,u+w,g+r,g+w,o+r,o+w /sdcard/clockworkmod ; chmod u+x,g+x,o+x /sdcard/clockworkmod/backup ; chmod u+x,g+x,o+x /sdcard/clockworkmod/blobs", backup_path);
__system(tmp);
sync();
ui_set_background(BACKGROUND_ICON_NONE);
ui_reset_progress();
ui_print("\nBackup complete!\n");
return 0;
}
int format_volume(const char* volume) {
Volume* v = volume_for_path(volume);
if (v == NULL) {
// silent failure for sd-ext
if (strcmp(volume, "/sd-ext") == 0)
return -1;
LOGE("unknown volume \"%s\"\n", volume);
return -1;
}
if (is_data_media_volume_path(volume)) {
return format_unknown_device(NULL, volume, NULL);
}
// check to see if /data is being formatted, and if it is /data/media
// Note: the /sdcard check is redundant probably, just being safe.
if (strstr(volume, "/data") == volume && is_data_media() && !handle_data_media) {
return format_unknown_device(NULL, volume, NULL);
}
if (strcmp(v->fs_type, "ramdisk") == 0) {
// you can't format the ramdisk.
LOGE("can't format_volume \"%s\"", volume);
return -1;
}
if (strcmp(v->mount_point, volume) != 0) {
#if 0
LOGE("can't give path \"%s\" to format_volume\n", volume);
return -1;
#endif
return format_unknown_device(v->device, volume, NULL);
}
if (ensure_path_unmounted(volume) != 0) {
LOGE("format_volume failed to unmount \"%s\"\n", v->mount_point);
return -1;
}
if (strcmp(v->fs_type, "yaffs2") == 0 || strcmp(v->fs_type, "mtd") == 0) {
mtd_scan_partitions();
const MtdPartition* partition = mtd_find_partition_by_name(v->device);
if (partition == NULL) {
LOGE("format_volume: no MTD partition \"%s\"\n", v->device);
return -1;
}
MtdWriteContext *write = mtd_write_partition(partition);
if (write == NULL) {
LOGW("format_volume: can't open MTD \"%s\"\n", v->device);
return -1;
} else if (mtd_erase_blocks(write, -1) == (off_t) -1) {
LOGW("format_volume: can't erase MTD \"%s\"\n", v->device);
mtd_write_close(write);
return -1;
} else if (mtd_write_close(write)) {
LOGW("format_volume: can't close MTD \"%s\"\n", v->device);
return -1;
}
return 0;
}
if (strcmp(v->fs_type, "ext4") == 0) {
int result = make_ext4fs(v->device, v->length, volume, sehandle);
if (result != 0) {
LOGE("format_volume: make_extf4fs failed on %s\n", v->device);
return -1;
}
return 0;
}
#if 0
LOGE("format_volume: fs_type \"%s\" unsupported\n", v->fs_type);
return -1;
#endif
return format_unknown_device(v->device, volume, v->fs_type);
}
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;
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;
}
int nandroid_backup(const char* backup_path) {
nandroid_backup_bitfield = 0;
ui_set_background(BACKGROUND_ICON_INSTALLING);
refresh_default_backup_handler();
if (ensure_path_mounted(backup_path) != 0) {
#ifndef USE_CHINESE_FONT
return print_and_error("Can't mount backup path.\n");
#else
return print_and_error("无法挂载备份路径。\n");
#endif
}
Volume* volume;
if (is_data_media_volume_path(backup_path))
volume = volume_for_path("/data");
else
volume = volume_for_path(backup_path);
if (NULL == volume)
#ifndef USE_CHINESE_FONT
return print_and_error("Unable to find volume for backup path.\n");
#else
return print_and_error("无法找到备份路径所在卷。\n");
#endif
int ret;
struct statfs sfs;
struct stat s;
if (NULL != volume) {
if (0 != (ret = statfs(volume->mount_point, &sfs)))
#ifndef USE_CHINESE_FONT
return print_and_error("Unable to stat backup path.\n");
#else
return print_and_error("无法统计备份路径。\n");
#endif
uint64_t bavail = sfs.f_bavail;
uint64_t bsize = sfs.f_bsize;
uint64_t sdcard_free = bavail * bsize;
uint64_t sdcard_free_mb = sdcard_free / (uint64_t)(1024 * 1024);
#ifndef USE_CHINESE_FONT
ui_print("SD Card space free: %lluMB\n", sdcard_free_mb);
#else
ui_print("SD 卡剩余空间: %lluMB\n", sdcard_free_mb);
#endif
if (sdcard_free_mb < 150)
#ifndef USE_CHINESE_FONT
ui_print("There may not be enough free space to complete backup... continuing...\n");
#else
ui_print("可能没有足够的空间完成备份... 继续...\n");
#endif
}
char tmp[PATH_MAX];
ensure_directory(backup_path);
if (0 != (ret = nandroid_backup_partition(backup_path, "/boot")))
return ret;
if (0 != (ret = nandroid_backup_partition(backup_path, "/recovery")))
return ret;
Volume *vol = volume_for_path("/wimax");
if (vol != NULL && 0 == stat(vol->blk_device, &s)) {
char serialno[PROPERTY_VALUE_MAX];
#ifndef USE_CHINESE_FONT
ui_print("Backing up WiMAX...\n");
#else
ui_print("正在备份 WiMAX...\n");
#endif
serialno[0] = 0;
property_get("ro.serialno", serialno, "");
sprintf(tmp, "%s/wimax.%s.img", backup_path, serialno);
ret = backup_raw_partition(vol->fs_type, vol->blk_device, tmp);
if (0 != ret)
#ifndef USE_CHINESE_FONT
return print_and_error("Error while dumping WiMAX image!\n");
#else
return print_and_error("导出 WiMAX 镜像时出错！\n");
#endif
}
if (0 != (ret = nandroid_backup_partition(backup_path, "/system")))
return ret;
if (0 != (ret = nandroid_backup_partition(backup_path, "/data")))
return ret;
if (has_datadata()) {
if (0 != (ret = nandroid_backup_partition(backup_path, "/datadata")))
return ret;
}
if (is_data_media() || 0 != stat(get_android_secure_path(), &s)) {
#ifndef USE_CHINESE_FONT
ui_print("No .android_secure found. Skipping backup of applications on external storage.\n");
#else
ui_print("未找到 .android_secure。跳过备份安装在外置存储卡上的应用程序。\n");
#endif
} else {
if (0 != (ret = nandroid_backup_partition_extended(backup_path, get_android_secure_path(), 0)))
return ret;
}
if (0 != (ret = nandroid_backup_partition_extended(backup_path, "/cache", 0)))
return ret;
vol = volume_for_path("/sd-ext");
if (vol == NULL || 0 != stat(vol->blk_device, &s)) {
#ifndef USE_CHINESE_FONT
LOGI("No sd-ext found. Skipping backup of sd-ext.\n");
#else
LOGI("未找到 sd-ext。跳过对 sd-ext 的备份。\n");
#endif
} else {
if (0 != ensure_path_mounted("/sd-ext"))
#ifndef USE_CHINESE_FONT
LOGI("Could not mount sd-ext. sd-ext backup may not be supported on this device. Skipping backup of sd-ext.\n");
#else
LOGI("无法挂载 sd-ext。此设备可能不支持对 sd-ext 进行备份，跳过对sd-ext的备份。\n");
#endif
else if (0 != (ret = nandroid_backup_partition(backup_path, "/sd-ext")))
return ret;
}
int format_volume(const char* volume) {
if (is_data_media_volume_path(volume)) {
return format_unknown_device(NULL, volume, NULL);
}
// check to see if /data is being formatted, and if it is /data/media
// Note: the /sdcard check is redundant probably, just being safe.
if (strstr(volume, "/data") == volume && is_data_media() && !ignore_data_media) {
return format_unknown_device(NULL, volume, NULL);
}
Volume* v = volume_for_path(volume);
if (v == NULL) {
// silent failure for sd-ext
if (strcmp(volume, "/sd-ext") != 0)
LOGE("unknown volume '%s'\n", volume);
return -1;
}
// silent failure to format non existing sd-ext when defined in recovery.fstab
if (strcmp(volume, "/sd-ext") == 0) {
struct stat s;
if (0 != stat(v->blk_device, &s)) {
LOGI("Skipping format of sd-ext\n");
return -1;
}
}
// Only use vold format for exact matches otherwise /sdcard will be
// formatted instead of /storage/sdcard0/.android_secure
if (fs_mgr_is_voldmanaged(v) && strcmp(volume, v->mount_point) == 0) {
if (ensure_path_unmounted(volume) != 0) {
LOGE("format_volume failed to unmount %s", v->mount_point);
}
return vold_format_volume(v->mount_point, 1) == CommandOkay ? 0 : -1;
}
if (strcmp(v->fs_type, "ramdisk") == 0) {
// you can't format the ramdisk.
LOGE("can't format_volume \"%s\"", volume);
return -1;
}
if (strcmp(v->mount_point, volume) != 0) {
#if 0
LOGE("can't give path \"%s\" to format_volume\n", volume);
return -1;
#endif
return format_unknown_device(v->blk_device, volume, NULL);
}
if (ensure_path_unmounted(volume) != 0) {
LOGE("format_volume failed to unmount \"%s\"\n", v->mount_point);
return -1;
}
if (strcmp(v->fs_type, "yaffs2") == 0 || strcmp(v->fs_type, "mtd") == 0) {
mtd_scan_partitions();
const MtdPartition* partition = mtd_find_partition_by_name(v->blk_device);
if (partition == NULL) {
LOGE("format_volume: no MTD partition \"%s\"\n", v->blk_device);
return -1;
}
MtdWriteContext *write = mtd_write_partition(partition);
if (write == NULL) {
LOGW("format_volume: can't open MTD \"%s\"\n", v->blk_device);
return -1;
} else if (mtd_erase_blocks(write, -1) == (off_t) -1) {
LOGW("format_volume: can't erase MTD \"%s\"\n", v->blk_device);
mtd_write_close(write);
return -1;
} else if (mtd_write_close(write)) {
LOGW("format_volume: can't close MTD \"%s\"\n", v->blk_device);
return -1;
}
return 0;
}
if (strcmp(v->fs_type, "ext4") == 0) {
int result = make_ext4fs(v->blk_device, v->length, volume, sehandle);
if (result != 0) {
LOGE("format_volume: make_extf4fs failed on %s\n", v->blk_device);
return -1;
}
return 0;
}
#ifdef USE_F2FS
if (strcmp(v->fs_type, "f2fs") == 0) {
int result = make_f2fs_main(v->blk_device, v->mount_point);
if (result != 0) {
LOGE("format_volume: mkfs.f2f2 failed on %s\n", v->blk_device);
return -1;
}
return 0;
}
#endif
#if 0
LOGE("format_volume: fs_type \"%s\" unsupported\n", v->fs_type);
return -1;
#endif
return format_unknown_device(v->blk_device, volume, v->fs_type);
}
int check_backup_size(const char* backup_path) {
// these are the size stats for backup_path we previously refreshed by calling Get_Size_Via_statfs()
int total_mb = (int)(Total_Size / 1048576LLU);
int used_mb = (int)(Used_Size / 1048576LLU);
int free_mb = (int)(Free_Size / 1048576LLU);
int free_percent = free_mb * 100 / total_mb;
Before_Used_Size = Used_Size; // save Used_Size to refresh data written stats later
Backup_Size = 0;
// supported nandroid partitions
char* Base_Partitions_List[BASE_PARTITIONS_NUM] = {
"/recovery",
BOOT_PARTITION_MOUNT_POINT,
"/wimax",
"/modem",
"/radio",
"/efs",
"/misc",
"/system",
"/preload",
"/data",
"/datadata",
"/cache",
"/sd-ext"
};
int items_num = BASE_PARTITIONS_NUM + MAX_EXTRA_NANDROID_PARTITIONS + 1;
char* Partitions_List[items_num];
int i;
for (i = 0; i < BASE_PARTITIONS_NUM; ++i) {
Partitions_List[i] = Base_Partitions_List[i];
}
int extra_partitions_num = get_extra_partitions_state();
for (i = 0; i < extra_partitions_num; ++i) {
Partitions_List[BASE_PARTITIONS_NUM + i] = extra_partition[i].mount_point;
}
Partitions_List[BASE_PARTITIONS_NUM + extra_partitions_num] = NULL;
int preload_status = 0;
if ((is_custom_backup && backup_preload) || (!is_custom_backup && nandroid_add_preload.value))
preload_status = 1;
int Base_Partitions_Backup_Status[] = {
backup_recovery,
backup_boot,
backup_wimax,
backup_modem,
backup_radio,
backup_efs,
backup_misc,
backup_system,
preload_status,
backup_data,
backup_data,
backup_cache,
backup_sdext,
};
LOGI("Checking needed space for backup '%s'\n", backup_path);
// calculate needed space for backup
// assume recovery and wimax always use a raw backup mode (Is_Image() = 0)
char skipped_parts[1024] = "";
int ret = 0;
Volume* vol;
for (i = 0; Partitions_List[i] != NULL; ++i) {
if (i >= BASE_PARTITIONS_NUM) {
if (!extra_partition[i - BASE_PARTITIONS_NUM].backup_state)
continue;
} else if (!Base_Partitions_Backup_Status[i]) {
continue;
}
// size of /data will be calculated later for /data/media devices to subtract sdcard size from it
if (strcmp(Partitions_List[i], "/data") == 0 && is_data_media())
continue;
// redundant but keep for compatibility:
// has_datadata() does a volume_for_path() != NULL check
if (strcmp(Partitions_List[i], "/datadata") == 0 && !has_datadata())
continue;
vol = volume_for_path(Partitions_List[i]);
if (vol == NULL) continue;
if (Is_Image(Partitions_List[i]) == 0) {
if (Find_Partition_Size(Partitions_List[i]) == 0) {
Backup_Size += Total_Size;
LOGI("%s backup size (/proc)=%lluMb\n", Partitions_List[i], Total_Size / 1048576LLU); // debug
} else {
ret++;
strcat(skipped_parts, " - ");
strcat(skipped_parts, Partitions_List[i]);
}
} else if (Is_File_System(Partitions_List[i]) == 0) {
// Get_Size_Via_statfs() will ensure vol->mount_point != NULL
if (0 == ensure_path_mounted(vol->mount_point) && 0 == Get_Size_Via_statfs(vol->mount_point)) {
Backup_Size += Used_Size;
LOGI("%s backup size (stat)=%lluMb\n", Partitions_List[i], Used_Size / 1048576LLU); // debug
} else {
ret++;
strcat(skipped_parts, " - ");
strcat(skipped_parts, Partitions_List[i]);
}
} else {
ret++;
strcat(skipped_parts, " - Unknown file system: ");
strcat(skipped_parts, Partitions_List[i]);
}
}
// handle special partitions and folders:
// handle /data and /data/media partitions size for /data/media devices
unsigned long long data_backup_size = 0;
unsigned long long data_used_bytes = 0;
unsigned long long data_media_size = 0;
if (is_data_media() && (backup_data || backup_data_media)) {
if (0 == ensure_path_mounted("/data") && 0 == Get_Size_Via_statfs("/data")) {
data_media_size = Get_Folder_Size("/data/media");
data_used_bytes = Get_Folder_Size("/data");
data_backup_size = data_used_bytes - data_media_size;
LOGI("/data: tot size=%lluMb, free=%lluMb, backup size=%lluMb, used=%lluMb, media=%lluMb\n",
Total_Size/1048576LLU, Free_Size/1048576LLU, data_backup_size/1048576LLU,
data_used_bytes/1048576LLU, data_media_size/1048576LLU);
} else {
if (backup_data) {
strcat(skipped_parts, " - /data");
ret++;
}
if (backup_data_media) {
strcat(skipped_parts, " - /data/media");
ret++;
}
}
}
if (backup_data)
Backup_Size += data_backup_size;
// check if we are also backing up /data/media
// if backup_path is same as /data/media, ignore this as it will not be processed by nandroid_backup_datamedia()
if (backup_data_media && !is_data_media_volume_path(backup_path)) {
Backup_Size += data_media_size;
LOGI("included /data/media size\n"); // debug
}
// .android_secure size calculation
// set_android_secure_path() will mount tmp so no need to remount before calling Get_Folder_Size(tmp)
char tmp[PATH_MAX];
set_android_secure_path(tmp);
if (backup_data && android_secure_ext) {
unsigned long long andsec_size;
andsec_size = Get_Folder_Size(tmp);
Backup_Size += andsec_size;
LOGI("%s backup size=%lluMb\n", tmp, andsec_size / 1048576LLU); // debug
}
// check if we have the needed space
int backup_size_mb = (int)(Backup_Size / 1048576LLU);
ui_print("\n>> Free space: %dMb (%d%%)\n", free_mb, free_percent);
ui_print(">> Needed space: %dMb\n", backup_size_mb);
if (ret)
ui_print(">> Unknown partitions size (%d):%s\n", ret, skipped_parts);
// dedupe wrapper needs less space than actual backup size (incremental backups)
// only check free space in Mb if we use tar or tar.gz as a default format
// also, add extra 50 Mb for security measures
if (free_percent < 3 || (default_backup_handler != dedupe_compress_wrapper && free_mb < backup_size_mb + 50)) {
LOGW("Low space for backup!\n");
if (!ui_is_initialized()) {
// do not prompt when it is an "adb shell nandroid backup" command
LOGW("\n>>> Backup could fail with I/O error!! <<<\n\n");
} else if (nand_prompt_on_low_space.value && !confirm_selection("Low free space! Continue anyway?", "Yes - Continue Nandroid Job"))
return -1;
}
return 0;
}
