int ensure_path_mounted(const char* path) {
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;
}
const MountedVolume* mv =
find_mounted_volume_by_mount_point(v->mount_point);
if (mv) {
// volume is already mounted
return 0;
}
mkdir("/mnt", 0755); // in case it doesn't already exist
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, "vfat") == 0) {
result = mount(v->device, v->mount_point, v->fs_type,
MS_NOATIME | MS_NODEV | MS_NODIRATIME, "");
if (result == 0) return 0;
if (v->device2) {
LOGW("failed to mount %s (%s); trying %s\n",
v->device, strerror(errno), v->device2);
result = mount(v->device2, 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;
}
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;
}
// Mount the volume specified by path at the given mount_point.
int ensure_path_mounted_at(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 (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 (!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->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, "squashfs") == 0 ||
strcmp(v->fs_type, "vfat") == 0) {
result = mount(v->blk_device, mount_point, v->fs_type,
v->flags, v->fs_options);
if (result == 0) return 0;
LOGE("failed to mount %s (%s)\n", mount_point, strerror(errno));
return -1;
}
LOGE("unknown fs_type \"%s\" for %s\n", v->fs_type, mount_point);
return -1;
}
int cmd_mtd_mount_partition(const char *partition, const char *mount_point, const char *filesystem, int read_only)
{
mtd_scan_partitions();
const MtdPartition *p;
p = mtd_find_partition_by_name(partition);
if (p == NULL) {
return -1;
}
return mtd_mount_partition(p, mount_point, filesystem, read_only);
}
int
ensure_root_path_mounted(const char *root_path)
{
const RootInfo *info = get_root_info_for_path(root_path);
if (info == NULL) {
return -1;
}
int ret = internal_root_mounted(info);
if (ret >= 0) {
/* It's already mounted.
*/
return 0;
}
/* It's not mounted.
*/
if (info->device == g_mtd_device) {
if (info->partition_name == NULL) {
return -1;
}
//TODO: make the mtd stuff scan once when it needs to
mtd_scan_partitions();
const MtdPartition *partition;
partition = mtd_find_partition_by_name(info->partition_name);
if (partition == NULL) {
return -1;
}
return mtd_mount_partition(partition, info->mount_point,
info->filesystem, 0);
}
if (info->device == NULL || info->mount_point == NULL ||
info->filesystem == NULL ||
info->filesystem == g_raw ||
info->filesystem == g_package_file) {
return -1;
}
mkdir(info->mount_point, 0755); // in case it doesn't already exist
if (mount_internal(info->device, info->mount_point, info->filesystem, info->filesystem_options)) {
if (info->device2 == NULL) {
LOGE("Can't mount %s\n(%s)\n", info->device, strerror(errno));
return -1;
} else if (mount(info->device2, info->mount_point, info->filesystem,
MS_NOATIME | MS_NODEV | MS_NODIRATIME, "")) {
LOGE("Can't mount %s (or %s)\n(%s)\n",
info->device, info->device2, strerror(errno));
return -1;
}
}
return 0;
}
// mount(fs_type, partition_type, location, mount_point)
//
// fs_type="yaffs2" partition_type="MTD" location=partition
// fs_type="ext4" partition_type="EMMC" location=device
Value* MountFn(const char* name, State* state, int argc, Expr* argv[]) {
char* result = NULL;
if (argc != 4) {
return ErrorAbort(state, "%s() expects 4 args, got %d", name, argc);
}
char* fs_type;
char* partition_type;
char* location;
char* mount_point;
if (ReadArgs(state, argv, 4, &fs_type, &partition_type,
&location, &mount_point) < 0) {
return NULL;
}
if (strlen(fs_type) == 0) {
ErrorAbort(state, "fs_type argument to %s() can't be empty", name);
goto done;
}
if (strlen(partition_type) == 0) {
ErrorAbort(state, "partition_type argument to %s() can't be empty",
name);
goto done;
}
if (strlen(location) == 0) {
ErrorAbort(state, "location argument to %s() can't be empty", name);
goto done;
}
if (strlen(mount_point) == 0) {
ErrorAbort(state, "mount_point argument to %s() can't be empty", name);
goto done;
}
#ifdef HAVE_SELINUX
char *secontext = NULL;
if (sehandle) {
selabel_lookup(sehandle, &secontext, mount_point, 0755);
setfscreatecon(secontext);
}
#endif
mkdir(mount_point, 0755);
#ifdef HAVE_SELINUX
if (secontext) {
freecon(secontext);
setfscreatecon(NULL);
}
#endif
if (strcmp(partition_type, "MTD") == 0) {
mtd_scan_partitions();
const MtdPartition* mtd;
mtd = mtd_find_partition_by_name(location);
if (mtd == NULL) {
fprintf(stderr, "%s: no mtd partition named \"%s\"",
name, location);
result = strdup("");
goto done;
}
if (mtd_mount_partition(mtd, mount_point, fs_type, 0 /* rw */) != 0) {
fprintf(stderr, "mtd mount of %s failed: %s\n",
location, strerror(errno));
result = strdup("");
goto done;
}
result = mount_point;
} else {
if (mount(location, mount_point, fs_type,
MS_NOATIME | MS_NODEV | MS_NODIRATIME, "") < 0) {
fprintf(stderr, "%s: failed to mount %s at %s: %s\n",
name, location, mount_point, strerror(errno));
result = strdup("");
} else {
result = mount_point;
}
}
done:
free(fs_type);
free(partition_type);
free(location);
if (result != mount_point) free(mount_point);
return StringValue(result);
}
int ensure_path_mounted(const char* path) {
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;
}
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 1
if ((strcmp(v->mount_point, "/mnt/sdcard") == 0)||(strcmp(v->mount_point, "/mnt/usb") == 0))
{
int wait_count = 0;
FILE * fp;
char read_buf[1024];
char s_dev_name[128];
char s_dev_fullpath[128];
int mount_ok = -1;
int hasmounted = 0;
while (wait_count < 30)
{
memset(s_dev_name, 0, 128);
memset(s_dev_fullpath, 0, 128);
fp = fopen("/proc/diskstats", "r");
if (fp == NULL)
{
return -1;
}
while(!feof(fp))
{
if(!fgets(read_buf, 1023 , fp))
{
break;
}
sscanf(read_buf, "%*d %*d %32s %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u", s_dev_name);
hasmounted = 0; //mount_ok = -1;
printf("[Root] From /proc/diskstats %s %s\n", s_dev_name, v->mount_point);
/*Just look for sdX*/
if(strncmp("sd", s_dev_name, 2) == 0 && strcmp(v->mount_point, "/mnt/usb") == 0)
{
sprintf(s_dev_fullpath, "/dev/block/%s", s_dev_name);
mount_ok = mount(s_dev_fullpath, v->mount_point, v->fs_type, MS_NOATIME | MS_NODEV | MS_NODIRATIME, "");
if (mount_ok == 0)
{
//break;
printf("mount ok\n");
hasmounted = 1;
}
else
{
mount_ok = mount(s_dev_fullpath, v->mount_point, "ntfs", MS_NOATIME | MS_NODEV | MS_NODIRATIME, "");
printf("mount ok: %d\n", mount_ok);
if (mount_ok == 0)
{
// break;
hasmounted = 1;
}
}
}
else if (strncmp("mmcblk", s_dev_name, 6) == 0 && strcmp(v->mount_point, "/mnt/sdcard") == 0)
{
sprintf(s_dev_fullpath, "/dev/block/%s", s_dev_name);
mount_ok = mount(s_dev_fullpath, v->mount_point, v->fs_type, MS_NOATIME | MS_NODEV | MS_NODIRATIME, "");
if (mount_ok == 0)
{
//break;
hasmounted = 1;
}
else
{
mount_ok = mount(s_dev_fullpath, v->mount_point, "ntfs", MS_NOATIME | MS_NODEV | MS_NODIRATIME, "");
if (mount_ok == 0)
{
// break;
hasmounted = 1;
}
}
}
if (hasmounted == 1) {
if (access(path, R_OK) == 0)
{
printf("access error\n");
break;
}else{
umount2(v->mount_point, MNT_FORCE);
printf("umount2 here\n");
}
}
}
fclose(fp);
if (mount_ok == 0)
{
return 0;
}
usleep(800000);
wait_count ++;
}
return -1;
}
#endif
else if ( (strcmp(v->fs_type, "yaffs2") == 0) || (strcmp(v->fs_type, "ubifs") == 0)) {
// mount an MTD partition as a YAFFS2 filesystem.
mtd_scan_partitions();
const MtdPartition* partition;
partition = mtd_find_partition_by_name(&v->mount_point[1]);
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, "vfat") == 0) {
result = mount(v->device, v->mount_point, v->fs_type,
MS_NOATIME | MS_NODEV | MS_NODIRATIME, "");
if (result == 0) return 0;
if (v->device2) {
LOGW("failed to mount %s (%s); trying %s\n",
v->device, strerror(errno), v->device2);
result = mount(v->device2, 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;
}
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 ensure_path_mounted(const char* path) {
#ifdef RECOVERY_SDCARD_ON_DATA
//if (strcmp(path, "/sdcard") == 0) return 0;
#endif
if (strncmp(path, "/sdcard", 7) == 0) {
if (DataManager_GetIntValue(TW_HAS_DUAL_STORAGE) == 1) {
char mount_command[255], mount_point[255];
memset(mount_command, 0, sizeof(mount_command));
memset(mount_point, 0, sizeof(mount_point));
strcpy(mount_point, DataManager_GetCurrentStoragePath());
sprintf(mount_command, "mount %s /sdcard", mount_point);
LOGI("Mounting '%s'\n", mount_point);
if (ensure_path_mounted(mount_point) != 0) {
LOGI("Unable to mount '%s'\n", mount_point);
return -1;
}
LOGI("Mounting /sdcard using: '%s'\n", mount_command);
__system(mount_command);
return 0;
} else if (DataManager_GetIntValue(TW_HAS_DATA_MEDIA) == 1) {
if (ensure_path_mounted("/data")) {
LOGI("Unable to mount /data\n");
return -1;
}
LOGI("Mounting /sdcard using: 'mount /data/media /sdcard'\n");
__system("mount /data/media /sdcard");
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;
}
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, "ext2") == 0 ||
strcmp(v->fs_type, "vfat") == 0) {
result = mount(v->device, v->mount_point, v->fs_type,
MS_NOATIME | MS_NODEV | MS_NODIRATIME, "");
if (result == 0) return 0;
if (v->device2) {
LOGW("failed to mount %s (%s); trying %s\n",
v->device, strerror(errno), v->device2);
result = mount(v->device2, 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;
}
// mount(type, location, mount_point)
//
// what: type="MTD" location="<partition>" to mount a yaffs2 filesystem
// type="vfat" location="/dev/block/<whatever>" to mount a device
Value* MountFn(const char* name, State* state, int argc, Expr* argv[]) {
char* result = NULL;
if (argc != 3) {
return ErrorAbort(state, "%s() expects 3 args, got %d", name, argc);
}
char* type;
char* location;
char* mount_point;
if (ReadArgs(state, argv, 3, &type, &location, &mount_point) < 0) {
return NULL;
}
if (strlen(type) == 0) {
ErrorAbort(state, "type argument to %s() can't be empty", name);
goto done;
}
if (strlen(location) == 0) {
ErrorAbort(state, "location argument to %s() can't be empty", name);
goto done;
}
if (strlen(mount_point) == 0) {
ErrorAbort(state, "mount_point argument to %s() can't be empty", name);
goto done;
}
mkdir(mount_point, 0755);
if (strcmp(type, "MTD") == 0) {
mtd_scan_partitions();
const MtdPartition* mtd;
mtd = mtd_find_partition_by_name(location);
if (mtd == NULL) {
fprintf(stderr, "%s: no mtd partition named \"%s\"",
name, location);
result = strdup("");
goto done;
}
#if 0 // 0: rk
if (mtd_mount_partition(mtd, mount_point, "yaffs2", 0 /* rw */) != 0) {
fprintf(stderr, "mtd mount of %s failed: %s\n",
location, strerror(errno));
result = strdup("");
goto done;
}
result = mount_point;
#else
if (mtd_mount_partition(mtd, mount_point, "ext3", 0 /* rw */) != 0) {
fprintf(stderr, "mtd mount of %s failed: %s\n",
location, strerror(errno));
result = strdup("");
goto done;
}
result = mount_point;
#endif
} else {
if (mount(location, mount_point, type,
MS_NOATIME | MS_NODEV | MS_NODIRATIME, "") < 0) {
fprintf(stderr, "%s: failed to mount %s at %s: %s\n",
name, location, mount_point, strerror(errno));
result = strdup("");
} else {
result = mount_point;
}
}
done:
free(type);
free(location);
if (result != mount_point) free(mount_point);
return StringValue(result);
}
int ensure_path_mounted(const char* path) {
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;
}
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;
}
#if 0
return mtd_mount_partition(partition, v->mount_point, v->fs_type, 0);
#else
return mtd_mount_partition(partition, v->mount_point, v->fs_type, v->options);
#endif
} else if (strcmp(v->fs_type, "ext4") == 0 ||
strcmp(v->fs_type, "vfat") == 0) {
/***************************************************************************/
//add support for some sdcard can not get ready immediately
#define SLEEP_SDCARD 3
#define TRY_MOUNT_TIMES 8
int tryCount = 0;
char *dev_buf;
int path_length = 0;
struct stat s;
int i = 0;
dev_buf = strdup(v->device);
for(i = 1;i<6;){
sleep(SLEEP_SDCARD);
if(stat(dev_buf, &s)==0)
break;
else {
i++;
path_length = strlen(dev_buf);
sprintf(dev_buf + path_length -1, "%d\0", i);
}
}
if(i==6){
path_length = strlen(dev_buf);
dev_buf[path_length -2] = '\0';
}
#if 0
while(tryCount++ < TRY_MOUNT_TIMES){
if( mount(v->device, v->mount_point, v->fs_type, MS_NOATIME | MS_NODEV | MS_NODIRATIME, "") &&
(v->device2 ? mount(v->device2, v->mount_point, v->fs_type, MS_NOATIME | MS_NODEV | MS_NODIRATIME, "") : 1))
sleep(SLEEP_SDCARD);
else
return 0;
}
#else
while(tryCount++ < TRY_MOUNT_TIMES){
if(mount(dev_buf, v->mount_point, v->fs_type, MS_NOATIME | MS_NODEV | MS_NODIRATIME, v->options))
sleep(SLEEP_SDCARD);
else
return 0;
}
#endif
#undef SLEEP_SDCARD
#undef TRY_MOUNT_TIMES
/***************************************************************************/
#if 0
result = mount(v->device, v->mount_point, v->fs_type,
MS_NOATIME | MS_NODEV | MS_NODIRATIME, "");
#else
result = mount(v->device, v->mount_point, v->fs_type,
MS_NOATIME | MS_NODEV | MS_NODIRATIME, v->options);
#endif
if (result == 0) return 0;
#if 0
if (v->device2) {
LOGW("failed to mount %s (%s); trying %s\n",
v->device, strerror(errno), v->device2);
result = mount(v->device2, v->mount_point, v->fs_type,
MS_NOATIME | MS_NODEV | MS_NODIRATIME, "");
if (result == 0) return 0;
}
#endif
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;
}
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(const char* path) {
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;
}
const MountedVolume* mv =
find_mounted_volume_by_mount_point(v->mount_point);
if (mv) {
#if defined(CACHE_MERGE_SUPPORT)
if (strncmp(path, "/cache", 6) == 0) {
if (symlink(DATA_CACHE_ROOT, "/cache")) {
if (errno != EEXIST) {
LOGE("create symlink from %s to %s failed(%s)\n",
DATA_CACHE_ROOT, "/cache", strerror(errno));
return -1;
}
}
}
#endif
// volume is already mounted
return 0;
}
mkdir(v->mount_point, 0755); // in case it doesn't already exist
#if defined (UBIFS_SUPPORT)
if (strcmp(v->fs_type, "ubifs") == 0) {
printf("Trying to mount %s \n", v->mount_point);
//Attatch UBI device & Make UBI volum
int n = -1;
n = ubi_attach_mtd_user(v->mount_point);
if ((n != -1) && (n < 4)) {
printf("Try to attatch %s \n", v->blk_device);
printf("/dev/ubi%d_0 is attached \n", n);
} else {
LOGE("failed to attach %s\n", v->blk_device);
}
//Mount UBI volume
const unsigned long flags = MS_NOATIME | MS_NODEV | MS_NODIRATIME;
char tmp[64];
sprintf(tmp, "/dev/ubi%d_0", n);
wait_for_file(tmp, 5);
result = mount(tmp, v->mount_point, v->fs_type, flags, "");
if (result < 0) {
ubi_detach_dev(n);
return -1;
} else if (result == 0) {
goto mount_done; //Volume successfully mounted
}
}
#endif
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, "squashfs") == 0 ||
strcmp(v->fs_type, "vfat") == 0) {
mt_ensure_dev_ready(v->mount_point);
result = mount(v->blk_device, v->mount_point, v->fs_type,
v->flags, v->fs_options);
if (result == 0) {
goto mount_done;
} else {
result = mt_ensure_path_mounted(v);
if (result == 0)
goto mount_done;
}
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;
mount_done:
#if defined(CACHE_MERGE_SUPPORT)
if (strcmp(v->mount_point, "/data") == 0) {
if (mkdir(DATA_CACHE_ROOT, 0770)) {
if (errno != EEXIST) {
LOGE("mkdir %s error: %s\n", DATA_CACHE_ROOT, strerror(errno));
return -1;
} else if (need_clear_cache) {
LOGI("cache exists, clear it...\n");
if (remove_dir(DATA_CACHE_ROOT)) {
LOGE("remove_dir %s error: %s\n", DATA_CACHE_ROOT, strerror(errno));
return -1;
}
if (mkdir(DATA_CACHE_ROOT, 0770) != 0) {
LOGE("mkdir %s error: %s\n", DATA_CACHE_ROOT, strerror(errno));
return -1;
}
}
}
if (symlink(DATA_CACHE_ROOT, "/cache")) {
if (errno != EEXIST) {
LOGE("create symlink from %s to %s failed(%s)\n",
DATA_CACHE_ROOT, "/cache", strerror(errno));
return -1;
}
}
need_clear_cache = 0;
}
#endif
return 0;
}
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;
}
