int ensure_volume_mounted(fstab_rec* v) {
if (v == NULL) {
LOGE("cannot mount unknown volume\n");
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 (!fs_mgr_is_voldmanaged(v)) {
const MountedVolume* mv =
find_mounted_volume_by_mount_point(v->mount_point);
if (mv) {
// volume is already mounted
return 0;
}
}
mkdir_p(v->mount_point, 0755); // in case it doesn't already exist
if (fs_mgr_is_voldmanaged(v)) {
if (!strcmp(v->mount_point, "auto")) {
return vold_mount_auto_volume(v->label, 1);
}
return vold_mount_volume(v->mount_point, 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, 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, "f2fs") == 0 ||
strcmp(v->fs_type, "vfat") == 0) {
result = mount(v->blk_device, v->mount_point, v->fs_type,
MS_NOATIME | MS_NODEV | MS_NODIRATIME, "");
if (result == 0) return 0;
LOGE("failed to mount %s (%s)\n", v->mount_point, strerror(errno));
return -1;
}
LOGE("unknown fs_type \"%s\" for %s\n", v->fs_type, v->mount_point);
return -1;
}
void TrimTask::addFromFstab() {
std::unique_ptr<fstab, decltype(&fs_mgr_free_fstab)> fstab(fs_mgr_read_fstab_default(),
fs_mgr_free_fstab);
struct fstab_rec *prev_rec = NULL;
for (int i = 0; i < fstab->num_entries; i++) {
/* Skip raw partitions */
if (!strcmp(fstab->recs[i].fs_type, "emmc") ||
!strcmp(fstab->recs[i].fs_type, "mtd")) {
continue;
}
/* Skip read-only filesystems */
if (fstab->recs[i].flags & MS_RDONLY) {
continue;
}
if (fs_mgr_is_voldmanaged(&fstab->recs[i])) {
continue; /* Should we trim fat32 filesystems? */
}
if (fs_mgr_is_notrim(&fstab->recs[i])) {
continue;
}
/* Skip the multi-type partitions, which are required to be following each other.
* See fs_mgr.c's mount_with_alternatives().
*/
if (prev_rec && !strcmp(prev_rec->mount_point, fstab->recs[i].mount_point)) {
continue;
}
mPaths.push_back(fstab->recs[i].mount_point);
prev_rec = &fstab->recs[i];
}
}
static int is_volume_primary_storage(fstab_rec* v)
{
// Static mount point /sdcard is primary storage, except when it's
// declared as datamedia
if (strcmp(v->mount_point, "/sdcard") == 0) {
if (strcmp(v->fs_type, "datamedia") == 0) {
return 0;
}
return 1;
}
// Detect static and dynamic mount points named sdcard*
const char* endp = NULL;
if (strncmp(v->mount_point, "/mnt/media_rw/sdcard", 20) == 0) {
endp = &v->mount_point[20];
}
else if (fs_mgr_is_voldmanaged(v) && strncmp(v->label, "sdcard", 6) == 0) {
endp = &v->label[6];
}
if (endp) {
// If the name ends with a non-zero value, it's not primary
if (isdigit(*endp) && atoi(endp) != 0) {
return 0;
}
return 1;
}
return 0;
}
int setup_install_mounts() {
if (fstab == NULL) {
LOGE("can't set up install mounts: no fstab loaded\n");
return -1;
}
for (int i = 0; i < fstab->num_entries; ++i) {
fstab_rec* v = fstab->recs + i;
if (strcmp(v->mount_point, "/tmp") == 0 ||
strcmp(v->mount_point, "/cache") == 0) {
if (ensure_path_mounted(v->mount_point) != 0) {
LOGE("failed to mount %s\n", v->mount_point);
return -1;
}
} else {
// datamedia and anything managed by vold must be unmounted
// with the detach flag to ensure that FUSE works.
bool detach = false;
if (is_data_media() && strcmp(v->mount_point, "/data") == 0) {
detach = true;
}
if (fs_mgr_is_voldmanaged(v)) {
detach = true;
}
if (ensure_volume_unmounted(v, detach) != 0) {
LOGE("failed to unmount %s\n", v->mount_point);
return -1;
}
}
}
return 0;
}
int get_num_extra_volumes() {
int num = 0;
int i;
for (i = 0; i < get_num_volumes(); i++) {
Volume* v = get_device_volumes() + i;
if ((strcmp("/external_sd", v->mount_point) == 0) ||
((strcmp(get_primary_storage_path(), v->mount_point) != 0) &&
fs_mgr_is_voldmanaged(v) && vold_is_volume_available(v->mount_point)))
num++;
}
return num;
}
static void write_fstab_entry(fstab_rec *v, FILE *file)
{
if (NULL != v && strcmp(v->fs_type, "mtd") != 0 && strcmp(v->fs_type, "emmc") != 0
&& strcmp(v->fs_type, "bml") != 0 && !fs_mgr_is_voldmanaged(v)
&& strncmp(v->blk_device, "/", 1) == 0
&& strncmp(v->mount_point, "/", 1) == 0) {
fprintf(file, "%s ", v->blk_device);
fprintf(file, "%s ", v->mount_point);
fprintf(file, "%s defaults\n", v->fs_type);
}
}
int is_data_media() {
int i;
int has_sdcard = 0;
for (i = 0; i < get_num_volumes(); i++) {
Volume* vol = get_device_volumes() + i;
if (strcmp(vol->fs_type, "datamedia") == 0)
return 1;
if (strcmp(vol->mount_point, "/sdcard") == 0)
has_sdcard = 1;
if (fs_mgr_is_voldmanaged(vol) &&
(strcmp(vol->mount_point, "/storage/sdcard0") == 0))
has_sdcard = 1;
}
return !has_sdcard;
}
storage_item* get_storage_items() {
storage_item* items = (storage_item*)calloc(MAX_NUM_MANAGED_VOLUMES+1, sizeof(storage_item));
int i;
storage_item* item = items;
if (is_data_media()) {
item->vol = volume_for_path("/data");
item->label = strdup("internal storage");
item->path = strdup("/data/media");
++item;
}
for (i = 0; i < get_num_volumes(); i++) {
fstab_rec* v = get_device_volumes() + i;
// Internal storage was allocated above
if (strcmp(v->fs_type, "datamedia") == 0)
continue;
if (strcmp(v->mount_point, "/external_sd") == 0 ||
strncmp(v->mount_point, "/sdcard", 7) == 0) {
item->vol = v;
item->label = strdup(&v->mount_point[1]);
item->path = strdup(v->mount_point);
++item;
}
else if (strncmp(v->mount_point, "/mnt/media_rw/sdcard", 20) == 0) {
item->vol = v;
item->label = strdup(&v->mount_point[14]);
item->path = strdup(v->mount_point);
++item;
}
else if (fs_mgr_is_voldmanaged(v) && strncmp(v->label, "sdcard", 6) == 0) {
char* path = (char*)malloc(9+strlen(v->label)+1);
sprintf(path, "/storage/%s", v->label);
if (vold_is_volume_available(path)) {
item->vol = v;
item->label = strdup(v->label);
item->path = strdup(path);
++item;
}
free(path);
}
}
return items;
}
void load_volume_table() {
int i;
int ret;
fstab = fs_mgr_read_fstab("/etc/recovery.fstab");
if (!fstab) {
LOGE("failed to read /etc/recovery.fstab\n");
return;
}
ret = fs_mgr_add_entry(fstab, "/tmp", "ramdisk", "ramdisk", 0);
if (ret < 0 ) {
LOGE("failed to add /tmp entry to fstab\n");
fs_mgr_free_fstab(fstab);
fstab = NULL;
return;
}
// Process vold-managed volumes with mount point "auto"
for (i = 0; i < fstab->num_entries; ++i) {
Volume* v = &fstab->recs[i];
if (fs_mgr_is_voldmanaged(v) && strcmp(v->mount_point, "auto") == 0) {
char mount[PATH_MAX];
// Set the mount point to /storage/label which as used by vold
snprintf(mount, PATH_MAX, "/storage/%s", v->label);
free(v->mount_point);
v->mount_point = strdup(mount);
}
}
fprintf(stderr, "recovery filesystem table\n");
fprintf(stderr, "=========================\n");
for (i = 0; i < fstab->num_entries; ++i) {
Volume* v = &fstab->recs[i];
fprintf(stderr, " %d %s %s %s %lld\n", i, v->mount_point, v->fs_type,
v->blk_device, v->length);
}
fprintf(stderr, "\n");
}
int ensure_volume_unmounted(fstab_rec* v, bool detach) {
if (v == NULL) {
LOGE("cannot unmount unknown volume\n");
return -1;
}
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;
}
if (fs_mgr_is_voldmanaged(v)) {
if (!strcmp(v->mount_point, "auto")) {
return vold_unmount_auto_volume(v->label, 0, 1, detach);
}
return vold_unmount_volume(v->mount_point, 0, 1, detach);
}
const MountedVolume* mv =
find_mounted_volume_by_mount_point(v->mount_point);
if (mv == NULL) {
// volume is already unmounted
return 0;
}
if (detach) {
result = unmount_mounted_volume_detach(mv);
}
else {
result = unmount_mounted_volume(mv);
}
return result;
}
int ensure_path_unmounted(const char* path) {
// if we are using /data/media, do not ever unmount volumes /data or /sdcard
if (is_data_media_volume_path(path)) {
return ensure_path_unmounted("/data");
}
if (strstr(path, "/data") == path && is_data_media() && !ignore_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; 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;
}
if (fs_mgr_is_voldmanaged(volume_for_path(v->mount_point)))
return vold_unmount_volume(v->mount_point, 0, 1) == CommandOkay ? 0 : -1;
return unmount_mounted_volume(mv);
}
int is_primary_storage_voldmanaged() {
Volume* v;
v = volume_for_path("/storage/sdcard0");
return fs_mgr_is_voldmanaged(v);
}
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 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 format_volume(const char* volume, bool force) {
if (strcmp(volume, "media") == 0) {
if (!is_data_media()) {
return 0;
}
if (ensure_path_mounted("/data") != 0) {
LOGE("format_volume failed to mount /data\n");
return -1;
}
int rc = 0;
rc = rmtree_except("/data/media", NULL);
ensure_path_unmounted("/data");
return rc;
}
fstab_rec* v = volume_for_path(volume);
if (v == NULL) {
LOGE("unknown volume \"%s\"\n", volume);
return -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) {
LOGE("can't give path \"%s\" to format_volume\n", volume);
return -1;
}
if (strcmp(volume, "/data") == 0 && is_data_media() && !force) {
if (ensure_path_mounted("/data") == 0) {
// Preserve .layout_version to avoid "nesting bug"
LOGI("Preserving layout version\n");
unsigned char layout_buf[256];
ssize_t layout_buflen = -1;
int fd;
fd = open("/data/.layout_version", O_RDONLY);
if (fd != -1) {
layout_buflen = read(fd, layout_buf, sizeof(layout_buf));
close(fd);
}
int rc = rmtree_except("/data", "media");
// Restore .layout_version
if (layout_buflen > 0) {
LOGI("Restoring layout version\n");
fd = open("/data/.layout_version", O_WRONLY | O_CREAT | O_EXCL, 0600);
if (fd != -1) {
write(fd, layout_buf, layout_buflen);
close(fd);
}
}
ensure_path_unmounted(volume);
return rc;
}
LOGE("format_volume failed to mount /data, formatting instead\n");
}
if (ensure_path_unmounted(volume) != 0) {
LOGE("format_volume failed to unmount \"%s\"\n", v->mount_point);
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);
}
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 || strcmp(v->fs_type, "f2fs") == 0) {
// if there's a key_loc that looks like a path, it should be a
// block device for storing encryption metadata. wipe it too.
if (v->key_loc != NULL && v->key_loc[0] == '/') {
LOGI("wiping %s\n", v->key_loc);
int fd = open(v->key_loc, O_WRONLY | O_CREAT, 0644);
if (fd < 0) {
LOGE("format_volume: failed to open %s\n", v->key_loc);
return -1;
}
wipe_block_device(fd, get_file_size(fd));
close(fd);
}
ssize_t length = 0;
if (v->length != 0) {
length = v->length;
} else if (v->key_loc != NULL && strcmp(v->key_loc, "footer") == 0) {
length = -CRYPT_FOOTER_OFFSET;
}
int result;
if (strcmp(v->fs_type, "ext4") == 0) {
result = make_ext4fs(v->blk_device, length, volume, sehandle);
} else { /* Has to be f2fs because we checked earlier. */
char bytes_reserved[10] = {0};
if (v->key_loc != NULL && strcmp(v->key_loc, "footer") == 0) {
snprintf(bytes_reserved, sizeof(bytes_reserved), "%d", CRYPT_FOOTER_OFFSET);
}
char *num_sectors;
if (asprintf(&num_sectors, "%zd", length / 512) <= 0) {
LOGE("format_volume: failed to create %s command for %s\n", v->fs_type, v->blk_device);
return -1;
}
const char *f2fs_path = "/sbin/mkfs.f2fs";
const char* const f2fs_argv[] = {"mkfs.f2fs", "-t", "-d1", "-r",
bytes_reserved, v->blk_device, num_sectors, NULL};
result = exec_cmd(f2fs_path, (char* const*)f2fs_argv);
free(num_sectors);
}
if (result != 0) {
LOGE("format_volume: make %s failed on %s with %d(%s)\n", v->fs_type, v->blk_device, result, strerror(errno));
return -1;
}
return 0;
}
LOGE("format_volume: fs_type \"%s\" unsupported\n", v->fs_type);
return -1;
}