android分区挂载fstab

SoC ： RK3288
Platform : Android 5.1

本文简述android启动后分区是如何挂载，简述fstab的作用。

一、fstab
Android 5.1分区挂载配置文件：fstab.xxxx.xxxx,不同于android4.4(vold.fstab),在5.1后分区配置文件发生了变化。fstab定义如下：

<src> <mount point>  <filesystem type> <mount flags parameters>     <fs_mgr_flags> 
/dev/.. /mnt/internal_sd  vfat               defaults         voldmanaged=internal_sd:14,nomulated

mount flags parameters文件系统的参数：
async/sync : 设置是否为同步方式运行
auto/noauto : 当下载mount -a 的命令时，此文件系统是否被主动挂载。默认为auto
rw/ro : 是否以以只读或者读写模式挂载
exec/noexec : 限制此文件系统内是否能够进行”执行”的操作
user/nouser : 是否允许用户使用mount命令挂载
suid/nosuid ： 是否允许SUID的存在
usrquota : 启动文件系统支持磁盘配额模式
grpquota : 启动文件系统对群组磁盘配额模式的支持
defaults ： 同时具有rw,suid,dev,exec,auto,nouser,async等默认参数的设置

fstab有何作用呢？
通过配置fstab，vold服务通过函数process_config调用fs_mgr_read_fstab来完成对分区文件的解析。
fs_mgr_read_fstab—>fs_mgr进程，该服务源码位于system/core/fs_mgr/fs_mgr_main.c，主要是解析分区文件，并完成挂载任务的最终工作者。
接下来，我们来看看fstab是如何被init获取的。

二、init
kernel加载完后第一个执行的就是init进程，init进程会根据init.rc的规则启动进程或者服务，init.rc通过
import /init.${ro.hardware}.rc导入平台的规则。device/rockchip/common/init.rk30board.rc中：

import init.${ro.hardware}.bootmode.{ro.bootmode}.rc    -----> init.rk30board.bootmode.emmc.rc

device/rockchip/common/init.rk30board.bootmode.emmc.rc中：

on fs
        mount_all  fstab.rk30board

mount_all是一条命令，fstab.rk30board是传入的参数，在system/core/init/keywords.h中，定义了mount_all命令：

KEYWORD(mount_all,   COMMAND, 1, do_mount_all)

从以上定义中看出，mount_all命令对应的是do_mount_all函数，fstab.rk30board是do_mount_all函数的参数。do_mount_all()位于system/core/init/builtins.c中：

/*
 * 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;
    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 */
        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]);     //解析分区文件fstab
        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;
}

上述函数最终调用fs_mgr_read_fstab(args[1])加载分区挂载文件的内容到fstab结构体中，最后通过 fs_mgr_mount_all(fstab)挂载分区。args[1]就是传给do_mount_all的参数fstab.rk30board

这里又产生一个疑问？传入的参数是fstab.rk30board，为什么不是fstab.rk30board.bootmode.emmc呢？
在out/target/product/rk3288_box/root/下没有发现fstab.rk30board文件，但是在系统启动后，adb shell下根目录中可以看到有fstab.rk30board文件，该文件和fstab.rk30board.bootmode.emmc文件的内容相同。因此do_mount_all打开文件fstab.rk30board是OK的。那么，fstab.rk30board文件是何时被创建的呢？在adb shell下输入：

ls -l fstab.rk30board
lrwxrwxrwx root     root     2016-11-28 07:22 fstab.rk30board -> /fstab.rk30board.bootmode.emmc

fstab.rk30board是链接到fstab.rk30board.bootmode.emmc的。搜索源码，最终在init.c中找到，简单分析下init，在main()中，调用process_kernel_cmdline()函数，获取/proc/cmdline

static void process_kernel_cmdline(void)
{
    /* don't expose the raw commandline to nonpriv processes */
    chmod("/proc/cmdline", 0440);

    /* first pass does the common stuff, and finds if we are in qemu.
     * second pass is only necessary for qemu to export all kernel params
     * as props.
     */
    import_kernel_cmdline(0, import_kernel_nv);
    if (qemu[0])
        import_kernel_cmdline(1, import_kernel_nv);

    /* now propogate the info given on command line to internal variables
     * used by init as well as the current required properties
     */
    export_kernel_boot_props();
}

这里的/proc/cmdline参数和parameters中的并不相同，只是在parameters内容的后面加了一部分参数，其中就包括androidboot.mode=emmc，指定了bootmode=emmc，后续讲述。调用export_kernel_boot_props()函数

static void export_kernel_boot_props(void)
{
    char tmp[PROP_VALUE_MAX];
    int ret;
    unsigned i;
    struct {
        const char *src_prop;
        const char *dest_prop;
        const char *def_val;
    } prop_map[] = {
#ifdef TARGET_BOARD_PLATFORM_SOFIA3GR
        { "ro.boot.serialno", "ro.serialno", "", },
#endif
        { "ro.boot.mode", "ro.bootmode", "unknown", },
        { "ro.boot.baseband", "ro.baseband", "unknown", },
        { "ro.boot.bootloader", "ro.bootloader", "unknown", },
    };

    for (i = 0; i < ARRAY_SIZE(prop_map); i++) {
        ret = property_get(prop_map[i].src_prop, tmp);
        if (ret > 0)
            property_set(prop_map[i].dest_prop, tmp);
        else
            property_set(prop_map[i].dest_prop, prop_map[i].def_val);
    }

    ret = property_get("ro.boot.console", tmp);
    if (ret)
        strlcpy(console, tmp, sizeof(console));

    /* save a copy for init's usage during boot */
    property_get("ro.bootmode", tmp);
    strlcpy(bootmode, tmp, sizeof(bootmode));

    /* if this was given on kernel command line, override what we read
     * before (e.g. from /proc/cpuinfo), if anything */
    ret = property_get("ro.boot.hardware", tmp);
    if (ret)
        strlcpy(hardware, tmp, sizeof(hardware));
    property_set("ro.hardware", hardware);

    snprintf(tmp, PROP_VALUE_MAX, "%d", revision);
    property_set("ro.revision", tmp);

    /* TODO: these are obsolete. We should delete them */
    if (!strcmp(bootmode,"factory"))
        property_set("ro.factorytest", "1");
    else if (!strcmp(bootmode,"factory2"))
        property_set("ro.factorytest", "2");
    else
        property_set("ro.factorytest", "0");
    #ifdef NAND_EMMC
    sysmlink_nand_emmc_fstab();
    #endif
    symlink_fstab();
}

再调用symlink_fstab()函数

static void symlink_fstab()
{
    char fstab_path[255] = "/fstab.";
    char fstab_default_path[50] = "/fstab.";
    int ret = -1;

    // fstab.rk30board.bootmode.unknown
    strcat(fstab_path, hardware);                 //fstab.rk30board
    strcat(fstab_path, ".bootmode.");             //fstab.rk30board.bootmode.
    strcat(fstab_path, bootmode);                 //fstab.rk30board.bootmode.emmc

    strcat(fstab_default_path, hardware);        //fstab.rk30board

    //symlink  /fstab.rk30board.bootmode.emmc  /fstab.rk30board
    ret = symlink(fstab_path, fstab_default_path);  
    if (ret < 0) {
        ERROR("%s : failed", __func__);
    }
}

因此，就是在这里将fstab.rk30board.bootmode.emmc软链接到fstab.rk30board，在后面调用do_mount_all时打开fstab.rk30board解析分区内容。
有关解析分区文件并挂载的fs_mgr源码，有待分析。

三、bootmode
前文讲述到在/proc/cmdline中加入了参数androidboot.mode=emmc，build.prop重没有ro.bootmode，又是如何获取到androidboot.mode并添加的呢？
其实ro.bootmode的属性是通过ro.boot.mode来设置的，而ro.boot.mode这个属性是读取/proc/cmdlinec参数，最终在import_kernel_nv函数中设置的，init.c中：

static void import_kernel_nv(char *name, int for_emulator)
{
    char *value = strchr(name, '=');
    int name_len = strlen(name);

    if (value == 0) return;
    *value++ = 0;
    if (name_len == 0) return;

    if (for_emulator) {
        /* in the emulator, export any kernel option with the
         * ro.kernel. prefix */
        char buff[PROP_NAME_MAX];
        int len = snprintf( buff, sizeof(buff), "ro.kernel.%s", name );

        if (len < (int)sizeof(buff))
            property_set( buff, value );
        return;
    }

    if (!strcmp(name,"qemu")) {
        strlcpy(qemu, value, sizeof(qemu));
    } else if (!strncmp(name, "androidboot.", 12) && name_len > 12) {  
      //androidboot.mode=emmc  --->androidboot.是12字节
        const char *boot_prop_name = name + 12;   // boot_prop_name指向mode位置处
        char prop[PROP_NAME_MAX];
        int cnt;

        cnt = snprintf(prop, sizeof(prop), "ro.boot.%s", boot_prop_name);
        if (cnt < PROP_NAME_MAX)
            property_set(prop, value);
    }
}

同样的，ro.boot.hardware和ro.boot.serialno也是在/proc/cmdline中设置通过调用import_kernel_nv函数设置的:

cat  /proc/cmdline
vmalloc=496M console=ttyFIQ0 androidboot.hardware=rk30board androidboot.console=ttyFIQ0 board.ap_has_alsa=0 init=/init 
mtdparts=rk29xxnand:0x00002000@0x00002000(uboot),0x00002000@0x00004000(misc),0x00008000@0x00006000(resource),0x00008000@0x0000e000(kernel),
0x00010000@0x00016000(boot),0x00010000@0x00026000(recovery),0x0001a000@0x00036000(backup),0x00040000@0x00050000(cache),0x00002000@0x00090000(kpanic),
0x00100000@0x00092000(system),0x00002000@0x00192000(metadata),0x00200000@0x00194000(userdata),0x00020000@0x00394000(radical_update), 
-@0x003B4000(user) storagemedia=emmc uboot_logo=0x02000000@0x7dc00000 loader.timestamp=2015-07-17_14:37:15 androidboot.serialno=11112222333344445555 <NULL> 
androidboot.mode=emmc

实际上/proc/cmdline所显示的androidboot.mode=emmc并不是parameter参数传递的，而是在kernel中指定的,这就是前文所述。位于kernel/block/partitions/rk.c文件中：

static void rkpart_bootmode_fixup(void)
{
    const char mode[] = " androidboot.mode=emmc";
    const char charger[] = " androidboot.charger.emmc=1";
    char *new_command_line;
    size_t saved_command_line_len = strlen(saved_command_line);

    if (strstr(saved_command_line, "androidboot.mode=charger")) {
        new_command_line = kzalloc(saved_command_line_len + strlen(charger) + 1, GFP_KERNEL);
        sprintf(new_command_line, "%s%s", saved_command_line, charger);
    } else {
        new_command_line = kzalloc(saved_command_line_len + strlen(mode) + 1, GFP_KERNEL);
        sprintf(new_command_line, "%s%s", saved_command_line, mode);
    }
    saved_command_line = new_command_line;
}

这里的androidboot.mode=charger是充电图标显示的模式。

本文只是简单讲述fstab,bootmode等的来龙去脉，更深层次的知识有待研究。