// Open the appropriate fstab file and fallback to /fstab.device if
// that's what's being used.
static struct fstab *open_fstab(void)
{
char propbuf[PROPERTY_VALUE_MAX];
char fstab_name[PROPERTY_VALUE_MAX + 32];
struct fstab *fstab;
property_get("ro.hardware", propbuf, "");
snprintf(fstab_name, sizeof(fstab_name), "/fstab.%s", propbuf);
fstab = fs_mgr_read_fstab(fstab_name);
if (fstab != NULL)
return fstab;
fstab = fs_mgr_read_fstab("/fstab.device");
return fstab;
}
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");
if (ret < 0 ) {
LOGE("failed to add /tmp entry to fstab\n");
fs_mgr_free_fstab(fstab);
fstab = NULL;
return;
}
printf("recovery filesystem table\n");
printf("=========================\n");
for (i = 0; i < fstab->num_entries; ++i) {
Volume* v = &fstab->recs[i];
printf(" %d %s %s %s %lld\n", i, v->mount_point, v->fs_type,
v->blk_device, v->length);
}
printf("\n");
}
int main(int argc, char *argv[])
{
int a_flag=0;
int u_flag=0;
int n_flag=0;
char *n_name=NULL;
char *n_blk_dev=NULL;
char *fstab_file=NULL;
struct fstab *fstab=NULL;
klog_set_level(6);
parse_options(argc, argv, &a_flag, &u_flag, &n_flag, &n_name, &n_blk_dev);
/* The name of the fstab file is last, after the option */
fstab_file = argv[argc - 1];
fstab = fs_mgr_read_fstab(fstab_file);
if (a_flag) {
return fs_mgr_mount_all(fstab);
} else if (n_flag) {
return fs_mgr_do_mount(fstab, n_name, n_blk_dev, 0);
} else if (u_flag) {
return fs_mgr_unmount_all(fstab);
} else {
ERROR("%s: Internal error, unknown option\n", me);
exit(1);
}
fs_mgr_free_fstab(fstab);
/* Should not get here */
exit(1);
}
void TrimTask::addFromFstab() {
struct fstab *fstab;
struct fstab_rec *prev_rec = NULL;
fstab = fs_mgr_read_fstab(android::vold::DefaultFstabPath().c_str());
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];
}
fs_mgr_free_fstab(fstab);
}
// Returns the device used to mount a directory in the fstab.
static std::string find_fstab_mount(const char* dir) {
std::string fstab_filename = "/fstab." + android::base::GetProperty("ro.hardware", "");
struct fstab* fstab = fs_mgr_read_fstab(fstab_filename.c_str());
struct fstab_rec* rec = fs_mgr_get_entry_for_mount_point(fstab, dir);
std::string dev = rec ? std::string(rec->blk_device) : "";
fs_mgr_free_fstab(fstab);
return dev;
}
int do_mount_all(int nargs, char **args)
{
pid_t pid;
int ret = -1;
int child_ret = -1;
int status;
const char *prop;
struct fstab *fstab;
if (nargs != 2) {
return -1;
}
/*
* Call fs_mgr_mount_all() to mount all filesystems. We fork(2) and
* do the call in the child to provide protection to the main init
* process if anything goes wrong (crash or memory leak), and wait for
* the child to finish in the parent.
*/
pid = fork();
if (pid > 0) {
/* Parent. Wait for the child to return */
waitpid(pid, &status, 0);
if (WIFEXITED(status)) {
ret = WEXITSTATUS(status);
} else {
ret = -1;
}
} else if (pid == 0) {
/* child, call fs_mgr_mount_all() */
klog_set_level(6); /* So we can see what fs_mgr_mount_all() does */
fstab = fs_mgr_read_fstab(args[1]);
child_ret = fs_mgr_mount_all(fstab);
fs_mgr_free_fstab(fstab);
if (child_ret == -1) {
ERROR("fs_mgr_mount_all returned an error\n");
}
exit(child_ret);
} else {
/* fork failed, return an error */
return -1;
}
/* ret is 1 if the device is encrypted, 0 if not, and -1 on error */
if (ret == 1) {
property_set("ro.crypto.state", "encrypted");
property_set("vold.decrypt", "1");
} else if (ret == 0) {
property_set("ro.crypto.state", "unencrypted");
/* If fs_mgr determined this is an unencrypted device, then trigger
* that action.
*/
action_for_each_trigger("nonencrypted", action_add_queue_tail);
}
return ret;
}
void set_verity_enabled_state_service(int fd, void* cookie)
{
bool enable = (cookie != NULL);
if (kAllowDisableVerity) {
char fstab_filename[PROPERTY_VALUE_MAX + sizeof(FSTAB_PREFIX)];
char propbuf[PROPERTY_VALUE_MAX];
int i;
bool any_changed = false;
property_get("ro.secure", propbuf, "0");
if (strcmp(propbuf, "1")) {
write_console(fd, "verity not enabled - ENG build\n");
goto errout;
}
property_get("ro.debuggable", propbuf, "0");
if (strcmp(propbuf, "1")) {
write_console(
fd, "verity cannot be disabled/enabled - USER build\n");
goto errout;
}
property_get("ro.hardware", propbuf, "");
snprintf(fstab_filename, sizeof(fstab_filename), FSTAB_PREFIX"%s",
propbuf);
fstab = fs_mgr_read_fstab(fstab_filename);
if (!fstab) {
write_console(fd, "Failed to open %s\nMaybe run adb root?\n",
fstab_filename);
goto errout;
}
/* Loop through entries looking for ones that vold manages */
for (i = 0; i < fstab->num_entries; i++) {
if(fs_mgr_is_verified(&fstab->recs[i])) {
if (!set_verity_enabled_state(fd, fstab->recs[i].blk_device,
fstab->recs[i].mount_point,
enable)) {
any_changed = true;
}
}
}
if (any_changed) {
write_console(
fd, "Now reboot your device for settings to take effect\n");
}
} else {
write_console(fd, "%s-verity only works for userdebug builds\n",
enable ? "enable" : "disable");
}
errout:
adb_close(fd);
}
static int do_swapon_all(const std::vector<std::string>& args) {
struct fstab *fstab;
int ret;
fstab = fs_mgr_read_fstab(args[1].c_str());
ret = fs_mgr_swapon_all(fstab);
fs_mgr_free_fstab(fstab);
return ret;
}
int do_swapon_all(int nargs, char **args)
{
struct fstab *fstab;
int ret;
fstab = fs_mgr_read_fstab(args[1]);
ret = fs_mgr_swapon_all(fstab);
fs_mgr_free_fstab(fstab);
return ret;
}
// Returns the device used to mount a directory in the fstab.
static std::string find_fstab_mount(const char* dir) {
char propbuf[PROPERTY_VALUE_MAX];
property_get("ro.hardware", propbuf, "");
std::string fstab_filename = kFstab_Prefix + propbuf;
struct fstab* fstab = fs_mgr_read_fstab(fstab_filename.c_str());
struct fstab_rec* rec = fs_mgr_get_entry_for_mount_point(fstab, dir);
std::string dev = rec ? std::string(rec->blk_device) : "";
fs_mgr_free_fstab(fstab);
return dev;
}
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");
if (ret < 0 ) {
LOGE("failed to add /tmp entry to fstab\n");
fs_mgr_free_fstab(fstab);
fstab = NULL;
return;
}
// Create a boring /etc/fstab so tools like Busybox work
FILE *file = fopen("/etc/fstab", "w");
if (file == NULL) {
LOGW("Unable to create /etc/fstab!\n");
return;
}
is_datamedia = 1;
printf("recovery filesystem table\n");
printf("=========================\n");
for (i = 0; i < fstab->num_entries; ++i) {
fstab_rec* v = &fstab->recs[i];
printf(" %d %s %s %s %lld\n", i, v->mount_point, v->fs_type,
v->blk_device, v->length);
write_fstab_entry(v, file);
if (is_volume_primary_storage(v)) {
is_datamedia = 0;
}
}
fclose(file);
printf("\n");
}
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");
LOGE("try read other fstab\n");
fstab = mt_read_fstab();
if (!fstab) {
LOGE("failed to read fstab\n");
return;
}
}
ret = fs_mgr_add_entry(fstab, "/tmp", "ramdisk", "ramdisk");
if (ret < 0 ) {
LOGE("failed to add /tmp entry to fstab\n");
fs_mgr_free_fstab(fstab);
fstab = NULL;
return;
}
ret = mt_load_volume_table(fstab);
if (ret < 0 ) {
LOGE("mt_load_volume_table fail to add entry to fstab\n");
fs_mgr_free_fstab(fstab);
fstab = NULL;
return;
}
mt_ensure_dev_ready("/misc");
mt_ensure_dev_ready("/cache");
mt_fstab_translation_NAND(fstab);
printf("recovery filesystem table\n");
printf("=========================\n");
for (i = 0; i < fstab->num_entries; ++i) {
Volume* v = &fstab->recs[i];
printf(" %d %s %s %s %lld\n", i, v->mount_point, v->fs_type,
v->blk_device, v->length);
}
printf("\n");
}
static struct fstab* read_fstab() {
fstab = NULL;
// The fstab path is always "/fstab.${ro.hardware}".
char fstab_path[PATH_MAX+1] = "/fstab.";
if (!property_get("ro.hardware", fstab_path+strlen(fstab_path), "")) {
ALOGE("failed to get ro.hardware");
return NULL;
}
fstab = fs_mgr_read_fstab(fstab_path);
if (!fstab) {
ALOGE("failed to read %s", fstab_path);
return NULL;
}
return fstab;
}
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");
}
void load_recovery_id_prop() {
char fstab_filename[PROP_VALUE_MAX + sizeof(FSTAB_PREFIX)];
char propbuf[PROP_VALUE_MAX];
int ret = property_get("ro.hardware", propbuf);
if (!ret) {
ERROR("ro.hardware not set - unable to load recovery id\n");
return;
}
snprintf(fstab_filename, sizeof(fstab_filename), FSTAB_PREFIX "%s", propbuf);
std::unique_ptr<fstab, void(*)(fstab*)> tab(fs_mgr_read_fstab(fstab_filename),
fs_mgr_free_fstab);
if (!tab) {
ERROR("unable to read fstab %s: %s\n", fstab_filename, strerror(errno));
return;
}
fstab_rec* rec = fs_mgr_get_entry_for_mount_point(tab.get(), RECOVERY_MOUNT_POINT);
if (rec == NULL) {
ERROR("/recovery not specified in fstab\n");
return;
}
int fd = open(rec->blk_device, O_RDONLY);
if (fd == -1) {
ERROR("error opening block device %s: %s\n", rec->blk_device, strerror(errno));
return;
}
boot_img_hdr hdr;
if (android::base::ReadFully(fd, &hdr, sizeof(hdr))) {
std::string hex = bytes_to_hex(reinterpret_cast<uint8_t*>(hdr.id), sizeof(hdr.id));
property_set("ro.recovery_id", hex.c_str());
} else {
ERROR("error reading /recovery: %s\n", strerror(errno));
}
close(fd);
}
void load_recovery_id_prop() {
std::string ro_hardware = property_get("ro.hardware");
if (ro_hardware.empty()) {
LOG(ERROR) << "ro.hardware not set - unable to load recovery id";
return;
}
std::string fstab_filename = FSTAB_PREFIX + ro_hardware;
std::unique_ptr<fstab, void(*)(fstab*)> tab(fs_mgr_read_fstab(fstab_filename.c_str()),
fs_mgr_free_fstab);
if (!tab) {
PLOG(ERROR) << "unable to read fstab " << fstab_filename;
return;
}
fstab_rec* rec = fs_mgr_get_entry_for_mount_point(tab.get(), RECOVERY_MOUNT_POINT);
if (rec == NULL) {
LOG(ERROR) << "/recovery not specified in fstab";
return;
}
int fd = open(rec->blk_device, O_RDONLY);
if (fd == -1) {
PLOG(ERROR) << "error opening block device " << rec->blk_device;
return;
}
boot_img_hdr hdr;
if (android::base::ReadFully(fd, &hdr, sizeof(hdr))) {
std::string hex = bytes_to_hex(reinterpret_cast<uint8_t*>(hdr.id), sizeof(hdr.id));
property_set("ro.recovery_id", hex.c_str());
} else {
PLOG(ERROR) << "error reading /recovery";
}
close(fd);
}
/*
* This function might request a reboot, in which case it will
* not return.
*/
int do_mount_all(int nargs, char **args)
{
pid_t pid;
int ret = -1;
int child_ret = -1;
int status;
char boot_mode[PROP_VALUE_MAX] = {0};
struct fstab *fstab;
if (nargs != 2) {
return -1;
}
/*
* Call fs_mgr_mount_all() to mount all filesystems. We fork(2) and
* do the call in the child to provide protection to the main init
* process if anything goes wrong (crash or memory leak), and wait for
* the child to finish in the parent.
*/
pid = fork();
if (pid > 0) {
/* Parent. Wait for the child to return */
int wp_ret = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
if (wp_ret < 0) {
/* Unexpected error code. We will continue anyway. */
NOTICE("waitpid failed rc=%d: %s\n", wp_ret, strerror(errno));
}
if (WIFEXITED(status)) {
ret = WEXITSTATUS(status);
} else {
ret = -1;
}
} else if (pid == 0) {
/* child, call fs_mgr_mount_all() */
klog_set_level(6); /* So we can see what fs_mgr_mount_all() does */
fstab = fs_mgr_read_fstab(args[1]);
child_ret = fs_mgr_mount_all(fstab);
fs_mgr_free_fstab(fstab);
if (child_ret == -1) {
ERROR("fs_mgr_mount_all returned an error\n");
}
_exit(child_ret);
} else {
/* fork failed, return an error */
return -1;
}
if (ret == FS_MGR_MNTALL_DEV_NEEDS_ENCRYPTION) {
property_set("vold.decrypt", "trigger_encryption");
} else if (ret == FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED) {
property_set("ro.crypto.state", "encrypted");
property_set("ro.crypto.type", "block");
property_set("vold.decrypt", "trigger_default_encryption");
} else if (ret == FS_MGR_MNTALL_DEV_NOT_ENCRYPTED) {
property_set("ro.crypto.state", "unencrypted");
/* If fs_mgr determined this is an unencrypted device and we are
* not booting into ffbm(fast factory boot mode),then trigger
* that action.
*/
property_get("ro.bootmode", boot_mode);
if (strncmp(boot_mode, "ffbm", 4))
action_for_each_trigger("nonencrypted", action_add_queue_tail);
} else if (ret == FS_MGR_MNTALL_DEV_NEEDS_RECOVERY) {
/* Setup a wipe via recovery, and reboot into recovery */
ERROR("fs_mgr_mount_all suggested recovery, so wiping data via recovery.\n");
ret = wipe_data_via_recovery();
/* If reboot worked, there is no return. */
} else if (ret == FS_MGR_MNTALL_DEV_DEFAULT_FILE_ENCRYPTED) {
if (e4crypt_install_keyring()) {
return -1;
}
property_set("ro.crypto.state", "encrypted");
property_set("ro.crypto.type", "file");
// Although encrypted, we have device key, so we do not need to
// do anything different from the nonencrypted case.
property_get("ro.bootmode", boot_mode);
if (strncmp(boot_mode, "ffbm", 4))
action_for_each_trigger("nonencrypted", action_add_queue_tail);
} else if (ret == FS_MGR_MNTALL_DEV_NON_DEFAULT_FILE_ENCRYPTED) {
if (e4crypt_install_keyring()) {
return -1;
}
property_set("ro.crypto.state", "encrypted");
property_set("ro.crypto.type", "file");
property_set("vold.decrypt", "trigger_restart_min_framework");
} else if (ret > 0) {
ERROR("fs_mgr_mount_all returned unexpected error %d\n", ret);
}
/* else ... < 0: error */
return ret;
}
/*
* This function might request a reboot, in which case it will
* not return.
*/
int do_mount_all(int nargs, char **args)
{
pid_t pid;
int ret = -1;
int child_ret = -1;
int status;
struct fstab *fstab;
if (nargs != 2) {
return -1;
}
/*
* Call fs_mgr_mount_all() to mount all filesystems. We fork(2) and
* do the call in the child to provide protection to the main init
* process if anything goes wrong (crash or memory leak), and wait for
* the child to finish in the parent.
*/
pid = fork();
if (pid > 0) {
/* Parent. Wait for the child to return */
int wp_ret = TEMP_FAILURE_RETRY(waitpid(pid, &status, 0));
if (wp_ret < 0) {
/* Unexpected error code. We will continue anyway. */
NOTICE("waitpid failed rc=%d, errno=%d\n", wp_ret, errno);
}
if (WIFEXITED(status)) {
ret = WEXITSTATUS(status);
} else {
ret = -1;
}
} else if (pid == 0) {
/* child, call fs_mgr_mount_all() */
klog_set_level(6); /* So we can see what fs_mgr_mount_all() does */
fstab = fs_mgr_read_fstab(args[1]);
child_ret = fs_mgr_mount_all(fstab);
fs_mgr_free_fstab(fstab);
if (child_ret == -1) {
ERROR("fs_mgr_mount_all returned an error\n");
}
_exit(child_ret);
} else {
/* fork failed, return an error */
return -1;
}
if (ret == FS_MGR_MNTALL_DEV_NEEDS_ENCRYPTION) {
property_set("vold.decrypt", "trigger_encryption");
} else if (ret == FS_MGR_MNTALL_DEV_MIGHT_BE_ENCRYPTED) {
property_set("ro.crypto.state", "encrypted");
property_set("vold.decrypt", "trigger_default_encryption");
} else if (ret == FS_MGR_MNTALL_DEV_NOT_ENCRYPTED) {
property_set("ro.crypto.state", "unencrypted");
/* If fs_mgr determined this is an unencrypted device, then trigger
* that action.
*/
action_for_each_trigger("nonencrypted", action_add_queue_tail);
} else if (ret == FS_MGR_MNTALL_DEV_NEEDS_RECOVERY) {
/* Setup a wipe via recovery, and reboot into recovery */
ERROR("fs_mgr_mount_all suggested recovery, so wiping data via recovery.\n");
ret = wipe_data_via_recovery();
/* If reboot worked, there is no return. */
} else if (ret > 0) {
ERROR("fs_mgr_mount_all returned unexpected error %d\n", ret);
}
/* else ... < 0: error */
return ret;
}
int main(void)
{
char key_loc[PROPERTY_VALUE_MAX];
char blk_dev[PROPERTY_VALUE_MAX];
char fstab_filename[PROPERTY_VALUE_MAX + sizeof(FSTAB_PREFIX)];
struct stat st;
struct crypt_mnt_ftr crypt_ftr;
int fdout;
printf("This tool comes with no warranties whatsoever.\n");
printf("http://teamw.in\n\n");
strcpy(fstab_filename, FSTAB_PREFIX);
property_get("ro.hardware", fstab_filename + sizeof(FSTAB_PREFIX) - 1, "");
if (stat(fstab_filename, &st) != 0) {
printf("Cannot locate fstab file '%s'\n", fstab_filename);
return -1;
}
fstab = fs_mgr_read_fstab(fstab_filename);
if (!fstab) {
printf("failed to open %s\n", fstab_filename);
return -1;
}
fs_mgr_get_crypt_info(fstab, key_loc, blk_dev, sizeof(blk_dev));
if (get_crypt_ftr_and_key(&crypt_ftr)) {
printf("Error getting crypt footer and key\n");
return -1;
}
if ( (fdout = open("/footerfile", O_WRONLY | O_CREAT, 0644)) < 0) {
printf("Cannot open output file /footerfile\n");
return -1;
}
if (write(fdout, (void*) &crypt_ftr, sizeof(struct crypt_mnt_ftr)) != sizeof(struct crypt_mnt_ftr)) {
printf("Failed to write footer.\n");
}
close(fdout);
if (!strcmp(key_loc, KEY_IN_FOOTER)) {
unsigned int nr_sec, cnt;
off64_t off = 0;
char buffer[CRYPT_FOOTER_OFFSET];
int fd;
printf("\n\nDumping footer from '%s'...\n", blk_dev);
if ( (fd = open(blk_dev, O_RDONLY)) < 0) {
printf("Cannot open real block device %s\n", blk_dev);
return -1;
}
if ((nr_sec = get_blkdev_size(fd))) {
off = ((off64_t)nr_sec * 512) - CRYPT_FOOTER_OFFSET;
} else {
printf("Cannot get size of block device %s\n", blk_dev);
close(fd);
return -1;
}
printf("Size is %llu, offset is %llu\n", ((off64_t)nr_sec * 512), off);
if (lseek64(fd, off, SEEK_SET) == -1) {
printf("Cannot seek to real block device footer\n");
close(fd);
return -1;
}
if ( (cnt = read(fd, buffer, sizeof(buffer))) != sizeof(buffer)) {
printf("Cannot read real block device footer\n");
close(fd);
return -1;
}
close(fd);
if ( (fdout = open("/footerdump", O_WRONLY | O_CREAT, 0644)) < 0) {
printf("Cannot open output file /footerdump\n");
return -1;
}
if (write(fdout, buffer, sizeof(buffer)) != sizeof(buffer)) {
printf("Failed to write footer.\n");
}
close(fdout);
}
return 0;
}
int main(int argc, char **argv)
{
struct fstab *fstab;
int ret=0, syspart, i, status;
char filenamePatched[PATH_MAX], filenameSystem[PATH_MAX];
// check arguments
if(argc!=2) {
ERROR("Invalid Arguments");
return -EINVAL;
}
// get syspart from cmdline
syspart = getDualbootSyspart();
if(syspart<0) {
ERROR("Cannot read system number");
return -EINVAL;
}
// patch fstab
sprintf(filenamePatched, "%s.patched", argv[1]);
sprintf(filenameSystem, "%s.system", argv[1]);
patch_fstab(argv[1], filenamePatched, filenameSystem, syspart);
// mount system
fstab = fs_mgr_read_fstab(filenameSystem);
ret = fs_mgr_mount_all(fstab);
fs_mgr_free_fstab(fstab);
if (ret == -1) {
ERROR("fs_mgr_mount_all returned an error\n");
}
// mount data
fstab = fs_mgr_read_fstab(argv[1]);
for (i = 0; i < fstab->num_entries; ++i) {
struct fstab_rec* v = &fstab->recs[i];
if(strcmp(PARTITION_USERDATA, v->blk_device))
continue;
if (v->fs_mgr_flags & MF_WAIT) {
wait_for_file(v->blk_device, WAIT_TIMEOUT);
}
if (v->fs_mgr_flags & MF_CHECK) {
check_fs(v->blk_device, v->fs_type, v->mount_point);
}
if(mountScriptExists()) {
char *e2fsck_argv[] = {
"/system/bin/mount_ext4.sh",
v->blk_device,
v->mount_point
};
ret = android_fork_execvp_ext(ARRAY_SIZE(e2fsck_argv), e2fsck_argv, &status, true, LOG_KLOG, true, NULL);
}
else {
ret = mount(v->blk_device, v->mount_point, v->fs_type, v->flags, v->fs_options);
}
}
fs_mgr_free_fstab(fstab);
if (ret == -1) {
ERROR("error mounting userdata\n");
}
return ret;
}
