ADROID 2.1 架构解析 9 SD/USB

9 SD/USB

9.1 主流程

文件：system/core/vold/Vold.c

int main(int argc, char **argv)

{

       ...

mkdir("/dev/block/vold", 0755);

       ...

        /*

     * Bootstrap

     */

 

    bootstrap = 1;

    // Volume Manager

    volmgr_bootstrap();

 

    // SD Card system

    mmc_bootstrap();

 

       ...

    // Switch

    switch_bootstrap();

 

    bootstrap = 0;

       ...

}

volmgr_bootstrap : 加载配置文件

mmc_bootstrap    : 挂载mmc/sdcard

switch_bootstrap   : 连接usb

9.2 加载配置文件

文件：system/core/vold/Volmgr.c

int volmgr_bootstrap(void)

{

    int rc;

 

    if ((rc = volmgr_readconfig("/system/etc/vold.conf")) < 0) {

        LOGE("Unable to process config");

        return rc;

    }

 

    /*

     * Check to see if any of our volumes is mounted

     */

    volume_t *v = vol_root;

    while (v) {

        if (_mountpoint_mounted(v->mount_point)) {

            LOGW("Volume '%s' already mounted at startup", v->mount_point);

            v->state = volstate_mounted;

        }

        v = v->next;

    }

 

    return 0;

}

 

两部分功能：

1 读取配置文件：/system/etc/vold.conf

2 用_mountpoint_mounted检查设备是否挂载，若挂载则状态改为volstate_mounted

 

static int volmgr_readconfig(char *cfg_path)

{

    cnode *root = config_node("", "");

    cnode *node;

 

    config_load_file(root, cfg_path);

    node = root->first_child;

 

    while (node) {

        if (!strncmp(node->name, "volume_", 7))

            volmgr_config_volume(node);

        else

            LOGE("Skipping unknown configuration node '%s'", node->name);

        node = node->next;

    }

    return 0;

}

9.2.1 读取配置文件

config_load_file的功能是将配置文件的信息读出来，然后以cnode链表结构的方式保存。

cnode 结构如下：

struct cnode

{

    cnode *next;

    cnode *first_child;

    cnode *last_child;

    const char *name;

    const char *value;

};

如配置文件：/system/etc/vold.conf

volume_sdcard {

    ## This is the direct uevent device path to the SD slot on the device

    media_path     /devices/platform/msm_sdcc.2/mmc_host/mmc1

    emu_media_path /devices/platform/goldfish_mmc.0/mmc_host/mmc0

 

    media_type     mmc

    mount_point    /sdcard

    ums_path       /devices/platform/usb_mass_storage/lun0

}

读到链表后的形式是：

Root ---- first_child ---- name = volume_sdcard

                |--- next ---- name = media_path

                                      |--- value = /devices/platform/msm_sdcc.2/mmc_host/mmc1

                                      |--- next ---- name = emu_media_path

                                                |--- value = /devices/platform/goldfish_mmc.0 ...

                                                   |--- next ---- ...

按照这样的格式保存配置文件的信息。

9.2.2 分析配置文件

volmgr_config_volume 的功能是将root链表结构的信息存储到vol_root链表结构对应的项里。

vol_root结构如下：

typedef struct volume {

    char            *media_paths[VOLMGR_MAX_MEDIAPATHS_PER_VOLUME];

 

    media_type_t      media_type;

    char              *mount_point;

    char              *ums_path;

    struct devmapping *dm;

 

    pthread_mutex_t          lock;

    volume_state_t           state;

    blkdev_t                 *dev;

    pid_t                    worker_pid;

    pthread_t                worker_thread;

    union {

        struct volmgr_start_args  start_args;

        struct volmgr_reaper_args reaper_args;

    } worker_args;

    boolean                  worker_running;

    pthread_mutex_t          worker_sem;

 

    struct volmgr_fstable_entry *fs;

 

    struct volume            *next;

} volume_t;

也就是说用media_paths、media_type、media_type、mount_point、ums_path等来存储配置文件里对应的值。

9.3挂载mmc/sdcard

文件：system/core/vold/Mmc.c

#define SYSFS_CLASS_MMC_PATH "/sys/class/mmc_host"

int mmc_bootstrap()

{

    DIR *d;

    struct dirent *de;

 

    if (!(d = opendir(SYSFS_CLASS_MMC_PATH))) {

        LOG_ERROR("Unable to open '%s' (%s)", SYSFS_CLASS_MMC_PATH,

                  strerror(errno));

        return -errno;

    }

 

    while ((de = readdir(d))) {

        char tmp[255];

 

        if (de->d_name[0] == '.')

            continue;

 

        sprintf(tmp, "%s/%s", SYSFS_CLASS_MMC_PATH, de->d_name);

        if (mmc_bootstrap_controller(tmp)) {

            LOG_ERROR("Error bootstrapping controller '%s' (%s)", tmp,

                      strerror(errno));

        }

    }

 

    closedir(d);

 

    return 0;

}

 

以下面/sys/class/mmc_host目录为例加以解说。

例子：

/sys/class/mmc_host/: mmc0 mmc1

/sys/class/mmc_host/mmc0/: uevent subsystem device power mmc0:e624

Mmc0:e624是一个链接目录，其真实路径是：

/sys/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624

/sys/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624/name: SR016

/sys/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624/type:SD

/sys/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624/block/:mmcblk0

/sys/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624/block/mmcblk0/:

uevent  dev  subsystem  device  range  ext_range  removable  ro  size  capability

stat  power  holders  slaves  mmcblk0p1  queue  bdi

 

上面代码实现的功能是：扫描/sys/class/mmc_hos目录下的所有文件和文件夹，然后一个一个的将它的路径传入mmc_bootstrap_controller, 如下，以例子路径来说，则会先把/sys/class/mmc_host/mmc0传给下面函数：

static int mmc_bootstrap_controller(char *sysfs_path)

{

    DIR *d;

    struct dirent *de;

 

#if DEBUG_BOOTSTRAP

    LOG_VOL("bootstrap_controller(%s):", sysfs_path);

#endif

    if (!(d = opendir(sysfs_path))) {

        LOG_ERROR("Unable to open '%s' (%s)", sysfs_path, strerror(errno));

        return -errno;

    }

 

    while ((de = readdir(d))) {

        char tmp[255];

 

        if (de->d_name[0] == '.')

            continue;

 

        if ((!strcmp(de->d_name, "uevent")) ||

            (!strcmp(de->d_name, "subsystem")) ||

            (!strcmp(de->d_name, "device")) ||

            (!strcmp(de->d_name, "power"))) {

            continue;

        }

 

        sprintf(tmp, "%s/%s", sysfs_path, de->d_name);

 

        if (mmc_bootstrap_card(tmp) < 0)

            LOG_ERROR("Error bootstrapping card '%s' (%s)", tmp, strerror(errno));

    } // while

 

    closedir(d);

return 0;  

}

继续扫描传进来的路径，将文件名不在{uevent,subsystem,device,power}内的文件或文件夹传给mmc_bootstrap_card，如下，以例子路径来说，则会先把/sys/class/mmc_host/mmc0/ mmc0:e624传给下面函数

static int mmc_bootstrap_card(char *sysfs_path)

{

    char saved_cwd[255];

    char new_cwd[255];

    char *devpath;

    char *uevent_params[4];

    char *p;

    char filename[255];

    char tmp[255];

    ssize_t sz;

 

#if DEBUG_BOOTSTRAP

    LOG_VOL("bootstrap_card(%s):", sysfs_path);

#endif

 

    /*

     * sysfs_path is based on /sys/class, but we want the actual device class

     */

    if (!getcwd(saved_cwd, sizeof(saved_cwd))) {

        LOGE("Error getting working dir path");

        return -errno;

    }

   

    if (chdir(sysfs_path) < 0) {

        LOGE("Unable to chdir to %s (%s)", sysfs_path, strerror(errno));

        return -errno;

    }

 

    if (!getcwd(new_cwd, sizeof(new_cwd))) {

        LOGE("Buffer too small for device path");

        return -errno;

    }

 

    if (chdir(saved_cwd) < 0) {

        LOGE("Unable to restore working dir");

        return -errno;

    }

 

    devpath = &new_cwd[4]; // Skip over '/sys'

 

    /*

     * Collect parameters so we can simulate a UEVENT

     */

    sprintf(tmp, "DEVPATH=%s", devpath);

    uevent_params[0] = (char *) strdup(tmp);

 

    sprintf(filename, "/sys%s/type", devpath);

    p = read_file(filename, &sz);

    p[strlen(p) - 1] = '/0';

    sprintf(tmp, "MMC_TYPE=%s", p);

    free(p);

    uevent_params[1] = (char *) strdup(tmp);

 

    sprintf(filename, "/sys%s/name", devpath);

    p = read_file(filename, &sz);

    p[strlen(p) - 1] = '/0';

    sprintf(tmp, "MMC_NAME=%s", p);

    free(p);

    uevent_params[2] = (char *) strdup(tmp);

 

    uevent_params[3] = (char *) NULL;

 

    if (simulate_uevent("mmc", devpath, "add", uevent_params) < 0) {

        LOGE("Error simulating uevent (%s)", strerror(errno));

        return -errno;

    }

 

    /*

     *  Check for block drivers

     */

    char block_devpath[255];

    sprintf(tmp, "%s/block", devpath);

    sprintf(filename, "/sys%s/block", devpath);

    if (!access(filename, F_OK)) {

        if (mmc_bootstrap_block(tmp)) {

            LOGE("Error bootstrapping block @ %s", tmp);

        }

    }

 

    return 0;

}

Getcwd 获取当前路径

Chdir 更改路径

由于sysfs_path是一个链接路径，所以需要用Chdir和Getcwd来获取它的真实路径。以例子路径来说，获得的真实路径是：

/sys/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624

所以DEVPATH = /devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624，而这个也就是在配置文件vold.conf里media_path的路径，media_path的路径要与DEVPATH相同，否则不会加载SD卡，这个<<9.5.1.3处理uevent 事件>>说明。

DEVPATH = /devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624

MMC_TYPE=SD

MMC_NAME= SR016

以上三个参数作uevent的参数，虚拟产生一个add事件：

simulate_uevent("mmc", devpath, "add", uevent_params);

然后将路径 /devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624/block

传给mmc_bootstrap_block，如下

static int mmc_bootstrap_block(char *devpath)

{

    char blockdir_path[255];

    DIR *d;

    struct dirent *de;

 

#if DEBUG_BOOTSTRAP

    LOG_VOL("mmc_bootstrap_block(%s):", devpath);

#endif

 

    sprintf(blockdir_path, "/sys%s", devpath);

 

    if (!(d = opendir(blockdir_path))) {

        LOGE("Failed to opendir %s", devpath);

        return -errno;

    }

 

    while ((de = readdir(d))) {

        char tmp[255];

 

        if (de->d_name[0] == '.')

            continue;

        sprintf(tmp, "%s/%s", devpath, de->d_name);

        if (mmc_bootstrap_mmcblk(tmp))

            LOGE("Error bootstraping mmcblk @ %s", tmp);

    }

    closedir(d);

    return 0;

}

会扫描所有文件或目录，将路径传给mmc_bootstrap_mmcblk，以例子路径来说，则会把/sys/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624/block/mmcblk0/传给下面函数

static int mmc_bootstrap_mmcblk(char *devpath)

{

    char *mmcblk_devname;

    int part_no;

    int rc;

 

#if DEBUG_BOOTSTRAP

    LOG_VOL("mmc_bootstrap_mmcblk(%s):", devpath);

#endif

 

    if ((rc = mmc_bootstrap_mmcblk_partition(devpath))) {

        LOGE("Error bootstrapping mmcblk partition '%s'", devpath);

        return rc;

    }

 

    for (mmcblk_devname = &devpath[strlen(devpath)];

         *mmcblk_devname != '/'; mmcblk_devname--);

    mmcblk_devname++;

 

    for (part_no = 0; part_no < 4; part_no++) {

        char part_file[255];

        sprintf(part_file, "/sys%s/%sp%d", devpath, mmcblk_devname, part_no);

        if (!access(part_file, F_OK)) {

            char part_devpath[255];

 

            sprintf(part_devpath, "%s/%sp%d", devpath, mmcblk_devname, part_no);

            if (mmc_bootstrap_mmcblk_partition(part_devpath))

                LOGE("Error bootstrapping mmcblk partition '%s'", part_devpath);

        }

    }

 

    return 0;

}

mmc_bootstrap_mmcblk_partition的功能是读取当前路径下的uevent文件里的四个参数：

DEVPATH,DEVTYPE、MAJOR、MINOR，然后将这四个参数作为uevent参数，产生一个uevent事件：

simulate_uevent("block", devpath, "add", uevent_params)；

所以上面代码的功能是：

1 用/sys/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624/block/mmcblk0/uevent里的参数产生一个uevent事件

2 /sys/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624/block/mmcblk0/mmcblk0p0

 /sys/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624/block/mmcblk0/mmcblk0p1

 /sys/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624/block/mmcblk0/mmcblk0p2

 /sys/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624/block/mmcblk0/mmcblk0p3

以上路径如存在,则读取目录下的uevent文件,产生一个uevent事件.

 

所以,加载这部分的功能就是产生三个事件:

devpath=/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624

simulate_uevent("mmc", devpath, "add", uevent_params);

 

devpath=/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624/block/mmcblk0/

simulate_uevent("block", devpath, "add", uevent_params)；

 

devpath=/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624/block/mmcblk0/mmcblk0p1

simulate_uevent("block", devpath, "add", uevent_params)；

9.4连接usb

文件:system/core/vold/Switch.c

#define SYSFS_CLASS_SWITCH_PATH "/sys/class/switch"

int switch_bootstrap()

{

    DIR *d;

    struct dirent *de;

 

    if (!(d = opendir(SYSFS_CLASS_SWITCH_PATH))) {

        LOG_ERROR("Unable to open '%s' (%s)", SYSFS_CLASS_SWITCH_PATH,

                   strerror(errno));

        return -errno;

    }

 

    while ((de = readdir(d))) {

        char tmp[255];

 

        if (de->d_name[0] == '.')

            continue;

 

        sprintf(tmp, "%s/%s", SYSFS_CLASS_SWITCH_PATH, de->d_name);

        if (mmc_bootstrap_switch(tmp)) {

            LOG_ERROR("Error bootstrapping switch '%s' (%s)", tmp,

                      strerror(errno));

        }

    }

 

    closedir(d);

 

    return 0;

}

扫描路径/sys/class/switch下的文件和目录,并将路径传给函数mmc_bootstrap_switch.

以下/sys/class/switch目录为例,来说明这个过程.

 

例子:

/sys/class/switch/

micco_hsdetect                                                                 

usb_mass_storage

 

/sys/class/switch/ usb_mass_storage/

uevent                                                                         

subsystem                                                                       

power                                                                          

state                                                                          

name

/sys/class/switch/ usb_mass_storage/name:usb_mass_storage

 

/sys/devices/virtual/switch/

micco_hsdetect                                                                 

usb_mass_storage

 

/sys/devices/virtual/switch/usb_mass_storage

uevent                                                                          

subsystem                                                                      

power                                                                          

state                                                                           

name

/sys/devices/virtual/switch/usb_mass_storage/state:online

 

以上代码实现的功能是分别将

/sys/class/switch/micco_hsdetect

/sys/class/switch/usb_mass_storage

两个路径传给函数mmc_bootstrap_switch

static int mmc_bootstrap_switch(char *sysfs_path)

{

#if DEBUG_BOOTSTRAP

    LOG_VOL("bootstrap_switch(%s):", sysfs_path);

#endif

 

    char filename[255];

    char name[255];

    char state[255];

    char tmp[255];

    char *uevent_params[3];

    char devpath[255];

    FILE *fp;

 

    /*

     * Read switch name

     */

    sprintf(filename, "%s/name", sysfs_path);

    if (!(fp = fopen(filename, "r"))) {

        LOGE("Error opening switch name path '%s' (%s)",

             sysfs_path, strerror(errno));

       return -errno;

    }

    if (!fgets(name, sizeof(name), fp)) {

        LOGE("Unable to read switch name");

        fclose(fp);

        return -EIO;

    }

    fclose(fp);

 

    name[strlen(name) -1] = '/0';

    sprintf(devpath, "/devices/virtual/switch/%s", name);

    sprintf(tmp, "SWITCH_NAME=%s", name);

    uevent_params[0] = (char *) strdup(tmp);

 

    /*

     * Read switch state

     */

    sprintf(filename, "%s/state", sysfs_path);

    if (!(fp = fopen(filename, "r"))) {

        LOGE("Error opening switch state path '%s' (%s)",

             sysfs_path, strerror(errno));

       return -errno;

    }

    if (!fgets(state, sizeof(state), fp)) {

        LOGE("Unable to read switch state");

        fclose(fp);

        return -EIO;

    }

    fclose(fp);

 

    state[strlen(state) -1] = '/0';

    sprintf(tmp, "SWITCH_STATE=%s", state);

    uevent_params[1] = (char *) strdup(tmp);

 

    uevent_params[2] = (char *) NULL;

 

    if (simulate_uevent("switch", devpath, "add", uevent_params) < 0) {

        LOGE("Error simulating uevent (%s)", strerror(errno));

        return -errno;

    }

 

    return 0;  

}

 

转到/sys/class/switch/usb_mass_storage下，获取state的值，再作为uevent的参数，产生switch 的uevent事件。

SWITCH_NAME=usb_mass_storage

SWITCH_STATE=online

devpath=/devices/virtual/switch/usb_mass_storage

9.5 通信机制

9.5.1 uevent

文件：system/core/vold/Uevent.c

9.5.1.1 产生uevent事件

int simulate_uevent(char *subsys, char *path, char *action, char **params)

{

    struct uevent *event;

    char tmp[255];

    int i, rc;

 

    if (!(event = malloc(sizeof(struct uevent)))) {

        LOGE("Error allocating memory (%s)", strerror(errno));

        return -errno;

    }

 

    memset(event, 0, sizeof(struct uevent));

 

    event->subsystem = strdup(subsys);

 

    if (!strcmp(action, "add"))

        event->action = action_add;

    else if (!strcmp(action, "change"))

        event->action = action_change;

    else if (!strcmp(action, "remove"))

        event->action = action_remove;

    else {

        LOGE("Invalid action '%s'", action);

        return -1;

    }

 

    event->path = strdup(path);

 

    for (i = 0; i < UEVENT_PARAMS_MAX; i++) {

        if (!params[i])

            break;

        event->param[i] = strdup(params[i]);

    }

 

    rc = dispatch_uevent(event);

    free_uevent(event);

    return rc;

}

如：

devpath = “/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624”

uevent_params [0] = “MMC_TYPE=SD”

uevent_params [1] = “MMC_NAME= SR016”

simulate_uevent("mmc", devpath, "add", uevent_params);

则经过simulate_uevent后，打包成：

event->subsystem        =  “mmc”

event->action              =  action_add;

event->path                  =  “/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624”

event->param[0]           =  “MMC_TYPE=SD”

event->param[1]           =  “MMC_NAME=SR016”

然后发给dispatch_uevent。

9.5.1.2 分配uevent事件

static struct uevent_dispatch dispatch_table[] = {

    { "switch", handle_switch_event },

    { "battery", handle_battery_event },

    { "mmc", handle_mmc_event },

    { "block", handle_block_event },

    { "bdi", handle_bdi_event },

    { "power_supply", handle_powersupply_event },

    { NULL, NULL }

};

static int dispatch_uevent(struct uevent *event)

{

    int i;

 

#if DEBUG_UEVENT

    dump_uevent(event);

#endif

    for (i = 0; dispatch_table[i].subsystem != NULL; i++) {

        if (!strcmp(dispatch_table[i].subsystem, event->subsystem))

            return dispatch_table[i].dispatch(event);

    }

 

#if DEBUG_UEVENT

    LOG_VOL("No uevent handlers registered for '%s' subsystem", event->subsystem);

#endif

    return 0;

}

根据subsystem的类型来分配，event->subsystem         =  “mmc”，则分配到handle_mmc_event进行处理

9.5.1.3处理uevent 事件

以mmc加载事件为例：

处理  << 9.3挂载mmc/sdcard>>的    simulate_uevent("mmc", devpath, "add", uevent_params);

文件：system/core/vold/uevent.c

static int handle_mmc_event(struct uevent *event)

{

    if (event->action == action_add) {

        media_t *media;

        char serial[80];

        char *type;

 

        /*

         * Pull card information from sysfs

         */

        type = get_uevent_param(event, "MMC_TYPE");

        if (strcmp(type, "SD") && strcmp(type, "MMC"))

            return 0;

       

        read_sysfs_var(serial, sizeof(serial), event->path, "serial");

        if (!(media = media_create(event->path,

                                   get_uevent_param(event, "MMC_NAME"),

                                   serial,

                                   media_mmc))) {

            LOGE("Unable to allocate new media (%s)", strerror(errno));

            return -1;

        }

        LOGI("New MMC card '%s' (serial %u) added @ %s", media->name,

                  media->serial, media->devpath);

}

...

    }

 

    return 0;

}

文件：system/core/vold/Media.c

media_t *media_create(char *devpath, char *name, char *serial, media_type_t type)

{

    media_list_t *list_entry;

    media_t *new;

 

    if (!(new = malloc(sizeof(media_t))))

        return NULL;

 

    memset(new, 0, sizeof(media_t));

 

    if (!(list_entry = malloc(sizeof(media_list_t)))) {

        free(new);

        return NULL;

    }

    list_entry->media = new;

    list_entry->next = NULL;

 

    if (!list_root)

        list_root = list_entry;

    else {

        media_list_t *list_scan = list_root;

        while(list_scan->next)

            list_scan = list_scan->next;

        list_scan->next = list_entry;

    }

    

    new->devpath = strdup(devpath);

    new->name = strdup(name);

    if (!serial)

        new->serial = 0;

    else

        new->serial = strtoul(serial, NULL, 0);

 

    new->media_type = type;

 

    return new;

}

将devpath, name, serial, media_type等信息以media结构打包放到list_root链表里去。

处理<< 9.3挂载mmc/sdcard>>的simulate_uevent("block", devpath, "add", uevent_params)；其中有两个block的事件，对应两个目录，所以有 disk,partition两个参数，处理如下：

文件：system/core/vold/uevent.c

static int handle_block_event(struct uevent *event)

{

    char mediapath[255];

    media_t *media;

    int n;

    int maj, min;

    blkdev_t *blkdev;

    char *mmcblk_devname;

    /*

     * Look for backing media for this block device

     */

    if (!strncmp(get_uevent_param(event, "DEVPATH"),

                 "/devices/virtual/",

                 strlen("/devices/virtual/"))) {

        n = 0;

    } else if (!strcmp(get_uevent_param(event, "DEVTYPE"), "disk"))

        n = 2;

    else if (!strcmp(get_uevent_param(event, "DEVTYPE"), "partition"))

        n = 3;

    else {

        LOGE("Bad blockdev type '%s'", get_uevent_param(event, "DEVTYPE"));

        return -EINVAL;

    }

  

    truncate_sysfs_path(event->path, n, mediapath, sizeof(mediapath));

 

    LOGE("PATH=  '%s' ,n=%d,mediapth = %s",event->path, n, mediapath);

 

    if (!(media = media_lookup_by_path(mediapath, false))) {

#if DEBUG_UEVENT

        LOG_VOL("No backend media found @ device path '%s'", mediapath);

#endif

        return 0;

    }

 

    maj = atoi(get_uevent_param(event, "MAJOR"));

    min = atoi(get_uevent_param(event, "MINOR"));

 

    if (event->action == action_add) {

        blkdev_t *disk;

 

        /*

         * If there isn't a disk already its because *we*

         * are the disk

         */

        if (media->media_type == media_mmc)

            disk = blkdev_lookup_by_devno(maj, ALIGN_MMC_MINOR(min));

        else

            disk = blkdev_lookup_by_devno(maj, 0);

 

        if (!(blkdev = blkdev_create(disk,

                                     event->path,

                                     maj,

                                     min,

                                     media,

                                     get_uevent_param(event, "DEVTYPE")))) {

            LOGE("Unable to allocate new blkdev (%s)", strerror(errno));

            return -1;

        }

 

        blkdev_refresh(blkdev);

 

        /*

         * Add the blkdev to media

         */

        int rc;

        if ((rc = media_add_blkdev(media, blkdev)) < 0) {

            LOGE("Unable to add blkdev to card (%d)", rc);

            return rc;

        }

 

        LOGI("New blkdev %d.%d on media %s, media path %s, Dpp %d",

                blkdev->major, blkdev->minor, media->name, mediapath,

                blkdev_get_num_pending_partitions(blkdev->disk));

 

        if (blkdev_get_num_pending_partitions(blkdev->disk) == 0) {

            if ((rc = volmgr_consider_disk(blkdev->disk)) < 0) {

                if (rc == -EBUSY) {

                    LOGI("Volmgr not ready to handle device");

                } else {

                    LOGE("Volmgr failed to handle device (%d)", rc);

                    return rc;

                }

            }

        }

}

...

    return 0;

}

truncate_sysfs_path 的功能是后通n个目录，为了最终获得路径：

/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624          

blkdev_create 的功能是将major,minor,media等参数组成一个blkdev然后返回blkdev。

media_add_blkdev 的功能是将blkdev添加到list_root列表去

media_lookup_by_path的功能是与media_create创建后的media_path行比较，确定是否一致。

volmgr_consider_disk的功能是list_root的media_path与vol_root的media_path行比较，确定是否一致。

 

文件：system/core/vold/volmgr.c

int volmgr_consider_disk(blkdev_t *dev)

{

    volume_t *vol;

 

    if (!(vol = volmgr_lookup_volume_by_mediapath(dev->media->devpath, true)))

{

LOGE("volmgr_consider_disk:LOOKUP FAILED");

        return 0;

    }

   ...

}

static volume_t *volmgr_lookup_volume_by_mediapath(char *media_path, boolean fuzzy)

{

    volume_t *scan = vol_root;

    int i;

 

    while (scan) {

 

        for (i = 0; i < VOLMGR_MAX_MEDIAPATHS_PER_VOLUME; i++) {

            if (!scan->media_paths[i])

                continue;

 

            if (fuzzy && !strncmp(media_path, scan->media_paths[i], strlen(scan->media_paths[i])))

                return scan;

            else if (!fuzzy && !strcmp(media_path, scan->media_paths[i]))

                return scan;

        }

 

        scan = scan->next;

    }

    return NULL;

}

如上代码，会比较strncmp(media_path, scan->media_paths[i], strlen(scan->media_paths[i])，会以vol_root的media_path的长度来比较media_path的路径是否与devpath一致。

比如，media_path = /devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624

则，vold.conf文件里的media_path路径可以设成

/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/mmc0:e624

/devices/platform/pxa2xx-mci.0/mmc_host/mmc0/

/devices/platform/pxa2xx-mci.0/mmc_host/

/devices/platform/pxa2xx-mci.0/

/devices/platform/

/devices/

都行

9.5.2 命令

9.5.2.1 发送命令

文件：system/core/vold/Vold.c

int send_msg(char* message)

{

    int result = -1;

 

    pthread_mutex_lock(&write_mutex);

 

//    LOG_VOL("send_msg(%s):", message);

 

    if (fw_sock >= 0)

        result = write(fw_sock, message, strlen(message) + 1);

 

    pthread_mutex_unlock(&write_mutex);

 

    return result;

}

 

int send_msg_with_data(char *message, char *data)

{

    int result = -1;

 

    char* buffer = (char *)alloca(strlen(message) + strlen(data) + 1);

    if (!buffer) {

        LOGE("alloca failed in send_msg_with_data");

        return -1;

    }

 

    strcpy(buffer, message);

    strcat(buffer, data);

    return send_msg(buffer);

}

将消息写到sock文件

9.5.2.2 接收命令

文件：system/core/vold/Cmd_dispatch.c

int process_framework_command(int socket)

{

    int rc;

    char buffer[101];

 

    if ((rc = read(socket, buffer, sizeof(buffer) -1)) < 0) {

        LOGE("Unable to read framework command (%s)", strerror(errno));

        return -errno;

    } else if (!rc)

        return -ECONNRESET;

 

    int start = 0;

    int i;

 

    buffer[rc] = 0;

 

    for (i = 0; i < rc; i++) {

        if (buffer[i] == 0) {

            dispatch_cmd(buffer + start);

            start = i + 1;

        }

    }

    return 0;

}

读出socket文件的数据，然后对数据所代表的命令进行分配。

9.5.2.3 分配命令

文件：system/core/vold/Cmd_dispatch.c

// These must match the strings in java/android/android/os/UsbListener.java

#define VOLD_CMD_ENABLE_UMS         "enable_ums"

#define VOLD_CMD_DISABLE_UMS        "disable_ums"

#define VOLD_CMD_SEND_UMS_STATUS    "send_ums_status"

 

// these commands should contain a volume mount point after the colon

#define VOLD_CMD_MOUNT_VOLUME       "mount_volume:"

#define VOLD_CMD_EJECT_MEDIA        "eject_media:"

#define VOLD_CMD_FORMAT_MEDIA       "format_media:"

 

static struct cmd_dispatch dispatch_table[] = {

    { VOLD_CMD_ENABLE_UMS,      do_set_ums_enable },

    { VOLD_CMD_DISABLE_UMS,     do_set_ums_enable },

    { VOLD_CMD_SEND_UMS_STATUS, do_send_ums_status },

    { VOLD_CMD_MOUNT_VOLUME,    do_mount_volume },

    { VOLD_CMD_EJECT_MEDIA,     do_eject_media },

    { VOLD_CMD_FORMAT_MEDIA,    do_format_media },

    { NULL, NULL }

};

static void dispatch_cmd(char *cmd)

{

    struct cmd_dispatch *c;

 

    LOG_VOL("dispatch_cmd(%s):", cmd);

 

    for (c = dispatch_table; c->cmd != NULL; c++) {

        if (!strncmp(c->cmd, cmd, strlen(c->cmd))) {

            c->dispatch(cmd);

            return;

        }

    }

 

    LOGE("No cmd handlers defined for '%s'", cmd);

}

命令格式：mount_volume:/sdcard ，将mount_volume分配表dispatch_table中的命令字进行匹配，合适的进行处理。

9.5.2.4 处理命令

文件：system/core/vold/Cmd_dispatch.c

static int do_mount_volume(char *cmd)

{

    return volmgr_start_volume_by_mountpoint(&cmd[strlen("mount_volume:")]);

}

过滤掉命令字，将其后的参数传递给相应的处理函数。

9.5.3 socket

9.5.3.1 socket的服务程序

文件：system/core/vold/Vold.c

#define VOLD_SOCKET "vold"

nt main(int argc, char **argv)

{

    int door_sock = -1;

    int uevent_sock = -1;

    struct sockaddr_nl nladdr;

    int uevent_sz = 64 * 1024;

 

    LOGI("Android Volume Daemon version %d.%d", ver_major, ver_minor);

 

    /*

     * Create all the various sockets we'll need

     */

 

    // Socket to listen on for incomming framework connections

    if ((door_sock = android_get_control_socket(VOLD_SOCKET)) < 0) {

        LOGE("Obtaining file descriptor socket '%s' failed: %s",

             VOLD_SOCKET, strerror(errno));

        exit(1);

    }

 

    if (listen(door_sock, 4) < 0) {

        LOGE("Unable to listen on fd '%d' for socket '%s': %s",

             door_sock, VOLD_SOCKET, strerror(errno));

        exit(1);

    }

    ...

    // Socket to listen on for uevent changes

    memset(&nladdr, 0, sizeof(nladdr));

    nladdr.nl_family = AF_NETLINK;

    nladdr.nl_pid = getpid();

    nladdr.nl_groups = 0xffffffff;

 

    if ((uevent_sock = socket(PF_NETLINK,

                             SOCK_DGRAM,NETLINK_KOBJECT_UEVENT)) < 0) {

        LOGE("Unable to create uevent socket: %s", strerror(errno));

        exit(1);

    }

 

    if (setsockopt(uevent_sock, SOL_SOCKET, SO_RCVBUFFORCE, &uevent_sz,

                   sizeof(uevent_sz)) < 0) {

        LOGE("Unable to set uevent socket options: %s", strerror(errno));

        exit(1);

    }

 

    if (bind(uevent_sock, (struct sockaddr *) &nladdr, sizeof(nladdr)) < 0) {

        LOGE("Unable to bind uevent socket: %s", strerror(errno));

        exit(1);

    }

...

    while(1) {

        fd_set read_fds;

        struct timeval to;

        int max = 0;

        int rc = 0;

 

        to.tv_sec = (60 * 60);

        to.tv_usec = 0;

 

        FD_ZERO(&read_fds);

        FD_SET(door_sock, &read_fds);

        if (door_sock > max)

            max = door_sock;

        FD_SET(uevent_sock, &read_fds);

        if (uevent_sock > max)

            max = uevent_sock;

 

        if (fw_sock != -1) {

            FD_SET(fw_sock, &read_fds);

            if (fw_sock > max)

                max = fw_sock;

        }

 

        if ((rc = select(max + 1, &read_fds, NULL, NULL, &to)) < 0) {

            LOGE("select() failed (%s)", strerror(errno));

            sleep(1);

            continue;

        }

 

        if (!rc) {

            continue;

        }

 

        if (FD_ISSET(door_sock, &read_fds)) {

            struct sockaddr addr;

            socklen_t alen;

 

            alen = sizeof(addr);

 

            if (fw_sock != -1) {

                LOGE("Dropping duplicate framework connection");

                int tmp = accept(door_sock, &addr, &alen);

                close(tmp);

                continue;

            }

 

            if ((fw_sock = accept(door_sock, &addr, &alen)) < 0) {

                LOGE("Unable to accept framework connection (%s)",

                     strerror(errno));

            }

            LOG_VOL("Accepted connection from framework");

            if ((rc = volmgr_send_states()) < 0) {

                LOGE("Unable to send volmgr status to framework (%d)", rc);

            }

        }

 

        if (FD_ISSET(fw_sock, &read_fds)) {

            if ((rc = process_framework_command(fw_sock)) < 0) {

                if (rc == -ECONNRESET) {

                    LOGE("Framework disconnected");

                    close(fw_sock);

                    fw_sock = -1;

                } else {

                    LOGE("Error processing framework command (%s)",

                         strerror(errno));

                }

            }

        }

 

        if (FD_ISSET(uevent_sock, &read_fds)) {

            if ((rc = process_uevent_message(uevent_sock)) < 0) {

                LOGE("Error processing uevent msg (%s)", strerror(errno));

            }

        }

    } // while

 

}

以上代码有两个socket，一个是”vold” socket，负责接收和处理vold命令；一个是uevent socket 负责接收和处理uevent事件。

9.5.3.2 “vold” socket 客户程序

文件：frameworks/base/services/java/com/android/server/MountListener.java

private void listenToSocket() {

       LocalSocket socket = null;

 

        try {

            socket = new LocalSocket();

            LocalSocketAddress address = new LocalSocketAddress(VOLD_SOCKET,

                    LocalSocketAddress.Namespace.RESERVED);

 

            socket.connect(address);

       ...

 

9.6 mount SDCARD

MountListener.java 启动后会去挂载SDCARD.

文件：frameworks/base/services/java/com/android/server/MountListener.java

private static final String VOLD_CMD_SEND_UMS_STATUS = "send_ums_status";

private static final String VOLD_CMD_MOUNT_VOLUME = "mount_volume:";

private void listenToSocket() {

       LocalSocket socket = null;

 

        try {

            socket = new LocalSocket();

            LocalSocketAddress address = new LocalSocketAddress(VOLD_SOCKET,

                    LocalSocketAddress.Namespace.RESERVED);

 

            socket.connect(address);

                     writeCommand(VOLD_CMD_SEND_UMS_STATUS);

            mountMedia(Environment.getExternalStorageDirectory().getAbsolutePath());

                     ...

}

 

注：ExternalStorageDirectory的定义在：

文件：frameworks/base/core/java/android/os/Environment.java

private static final File EXTERNAL_STORAGE_DIRECTORY

            = getDirectory("EXTERNAL_STORAGE", "/sdcard");

 

public void mountMedia(String mountPoint) {

        writeCommand2(VOLD_CMD_MOUNT_VOLUME, mountPoint);

}

 

mountPoint = /sdcard

由此向”vold” socket发送一个VOLD_CMD_MOUNT_VOLUME命令，该命令处理如下：

文件：system/core/vold/Cmd_dispatch.c

static struct cmd_dispatch dispatch_table[] = {

    ...

    { VOLD_CMD_SEND_UMS_STATUS, do_send_ums_status },

{ VOLD_CMD_MOUNT_VOLUME,    do_mount_volume },

...

};

static int do_mount_volume(char *cmd)

{

    return volmgr_start_volume_by_mountpoint(&cmd[strlen("mount_volume:")]);

}

文件：system/core/vold/Volmgr.c

int volmgr_start_volume_by_mountpoint(char *mount_point)

{

       volume_t *v;

 

    v = volmgr_lookup_volume_by_mountpoint(mount_point, true);

    ...

 

        if (_volmgr_consider_disk_and_vol(v, v->dev->disk) < 0) {

            LOGE("volmgr failed to start volume '%s'", v->mount_point);

        }

    ...

    return 0;

}

static volume_t *volmgr_lookup_volume_by_mountpoint(char *mount_point, boolean leave_locked)

{

    volume_t *v = vol_root;

 

    while(v) {

        pthread_mutex_lock(&v->lock);

        if (!strcmp(v->mount_point, mount_point)) {

            if (!leave_locked)

                pthread_mutex_unlock(&v->lock);

            return v;

        }

        pthread_mutex_unlock(&v->lock);

        v = v->next;

    }

    return NULL;

}

在vol_root链表里找到对应的结点。

static int _volmgr_consider_disk_and_vol(volume_t *vol, blkdev_t *dev)

{

    ...

            part = blkdev_lookup_by_devno(dev->major, ALIGN_MMC_MINOR(dev->minor) + 1);

        ...

            rc = _volmgr_start(vol, part);

    return rc;

}

 

struct volmgr_fstable_entry {

    char *name;

    int     (*identify_fn) (blkdev_t *dev);

    int     (*check_fn) (blkdev_t *dev);

    int     (*mount_fn) (blkdev_t *dev, struct volume *vol, boolean safe_mode);

    boolean case_sensitive_paths;

};

static struct volmgr_fstable_entry fs_table[] = {

//    { "ext3", ext_identify, ext_check, ext_mount , true },

    { "vfat", vfat_identify, vfat_check, vfat_mount , false },

    { NULL, NULL, NULL, NULL , false}

};

 

static int _volmgr_start(volume_t *vol, blkdev_t *dev)

{

...

for (fs = fs_table; fs->name; fs++) {

        if (!fs->identify_fn(dev))

            break;

    }

...

    return volmgr_start_fs(fs, vol, dev);

}

static int volmgr_start_fs(struct volmgr_fstable_entry *fs, volume_t *vol, blkdev_t *dev)

{

    ...

 

    pthread_create(&vol->worker_thread, &attr, volmgr_start_fs_thread, vol);

 

    return 0;

}

static void *volmgr_start_fs_thread(void *arg)

{

    ...

 

    rc = fs->mount_fn(dev, vol, safe_mode);

   ...

}

由此mount_fn转向vfat_mount。

文件：system/core/vold/Volmgr_vfat.c

int vfat_mount(blkdev_t *dev, volume_t *vol, boolean safe_mode)

{

    int flags, rc;

    char *devpath;

 

    devpath = blkdev_get_devpath(dev);

 

#if VFAT_DEBUG

    LOG_VOL("vfat_mount(%d:%d, %s, %d):", dev->major, dev->minor, vol->mount_point, safe_mode);

#endif

 

    flags = MS_NODEV | MS_NOEXEC | MS_NOSUID | MS_DIRSYNC;

 

    if (vol->state == volstate_mounted) {

        LOG_VOL("Remounting %d:%d on %s, safe mode %d", dev->major,

                dev->minor, vol->mount_point, safe_mode);

        flags |= MS_REMOUNT;

    }

 

    /*

     * Note: This is a temporary hack. If the sampling profiler is enabled,

     * we make the SD card world-writable so any process can write snapshots.

     *

     * TODO: Remove this code once we have a drop box in system_server.

     */

    char value[PROPERTY_VALUE_MAX];

    property_get("persist.sampling_profiler", value, "");

    if (value[0] == '1') {

        LOGW("The SD card is world-writable because the"

            " 'persist.sampling_profiler' system property is set to '1'.");

        rc = mount(devpath, vol->mount_point, "vfat", flags,

                "utf8,uid=1000,gid=1015,fmask=000,dmask=000,shortname=mixed");

    } else {

        /*

         * The mount masks restrict access so that:

         * 1. The 'system' user cannot access the SD card at all -

         *    (protects system_server from grabbing file references)

         * 2. Group users can RWX

         * 3. Others can only RX

         */

        rc = mount(devpath, vol->mount_point, "vfat", flags,

                "utf8,uid=1000,gid=1015,fmask=702,dmask=702,shortname=mixed");

    }

 

    if (rc && errno == EROFS) {

        LOGE("vfat_mount(%d:%d, %s): Read only filesystem - retrying mount RO",

             dev->major, dev->minor, vol->mount_point);

        flags |= MS_RDONLY;

        rc = mount(devpath, vol->mount_point, "vfat", flags,

                   "utf8,uid=1000,gid=1015,fmask=702,dmask=702,shortname=mixed");

    }

 

    if (rc == 0) {

        char *lost_path;

        asprintf(&lost_path, "%s/LOST.DIR", vol->mount_point);

        if (access(lost_path, F_OK)) {

            /*

             * Create a LOST.DIR in the root so we have somewhere to put

             * lost cluster chains (fsck_msdos doesn't currently do this)

             */

            if (mkdir(lost_path, 0755)) {

                LOGE("Unable to create LOST.DIR (%s)", strerror(errno));

            }

        }

        free(lost_path);

    }

 

#if VFAT_DEBUG

    LOG_VOL("vfat_mount(%s, %d:%d): mount rc = %d", dev->major,k dev->minor,

            vol->mount_point, rc);

#endif

    free (devpath);

    return rc;

}

至此，SDCARD才真正被挂载。

9.7 switch USB

<<9.4挂载usb>>提到的simulate_uevent("switch", devpath, "add", uevent_params)产生add事件后，会在文件：system/core/vold/Cmd_dispatch.c里分配一个处理，如下：

static int handle_switch_event(struct uevent *event)

{

    char *name = get_uevent_param(event, "SWITCH_NAME");

    char *state = get_uevent_param(event, "SWITCH_STATE");

 

 

    if (!strcmp(name, "usb_mass_storage")) {

        if (!strcmp(state, "online")) {

            ums_hostconnected_set(true);

        } else {

            ums_hostconnected_set(false);

            volmgr_enable_ums(false);

        }

}

...

}

文件：system/core/vold/Ums.c

void ums_hostconnected_set(boolean connected)

{

    ...

    send_msg(connected ? VOLD_EVT_UMS_CONNECTED : VOLD_EVT_UMS_DISCONNECTED);

}

在这里向“vold”socket发送一个VOLD_EVT_UMS_CONNECTED消息。

该消息在如下文件得到处理：

文件：frameworks/base/services/java/com/android/server/MountListener.java

    // vold commands

    private static final String VOLD_CMD_ENABLE_UMS = "enable_ums";

    private static final String VOLD_CMD_DISABLE_UMS = "disable_ums";

    private static final String VOLD_CMD_SEND_UMS_STATUS = "send_ums_status";

    ...

    // vold events

    private static final String VOLD_EVT_UMS_ENABLED = "ums_enabled";

    private static final String VOLD_EVT_UMS_DISABLED = "ums_disabled";

    private static final String VOLD_EVT_UMS_CONNECTED = "ums_connected";

private static final String VOLD_EVT_UMS_DISCONNECTED = "ums_disconnected";

private void listenToSocket() {

       LocalSocket socket = null;

 

        try {

            socket = new LocalSocket();

            LocalSocketAddress address = new LocalSocketAddress(VOLD_SOCKET,

                    LocalSocketAddress.Namespace.RESERVED);

 

            socket.connect(address);

 

            InputStream inputStream = socket.getInputStream();

            mOutputStream = socket.getOutputStream();

...

           

            while (true) {

                int count = inputStream.read(buffer);

                if (count < 0) break;

 

                int start = 0;

                for (int i = 0; i < count; i++) {

                    if (buffer[i] == 0) {

                        String event = new String(buffer, start, i - start);

                        handleEvent(event);

                        start = i + 1;

                    }                  

                }

            }               

        }

...

}

private void handleEvent(String event) {

        if (Config.LOGD) Log.d(TAG, "handleEvent " + event);

   

        int colonIndex = event.indexOf(':');

        String path = (colonIndex > 0 ? event.substring(colonIndex + 1) : null);

       

        ...

}else if (event.equals(VOLD_EVT_UMS_CONNECTED)) {

            mUmsConnected = true;

            mService.notifyUmsConnected();

        } ...

}

经mService(mount service) 的notifyUmsConnected() 广播一下状态，再绕回MountListenser调用如下函数发送一个连接USB的命令：

void setMassStorageEnabled(boolean enable) {

        writeCommand(enable ? VOLD_CMD_ENABLE_UMS : VOLD_CMD_DISABLE_UMS);

    }

文件：frameworks/base/services/java/com/android/server/MountService.java

void notifyUmsConnected() {

       ...

setMassStorageEnabled(true);

       ...

    }

public void setMassStorageEnabled(boolean enable) throws RemoteException {

        mListener.setMassStorageEnabled(enable);

    }

由此向”vold” socket 发送一个VOLD_CMD_ENABLE_UMS 的命令，该命令处理如下：

{ VOLD_CMD_ENABLE_UMS,      do_set_ums_enable },

文件：system/core/vold/Cmd_dispatch.c

static struct cmd_dispatch dispatch_table[] = {

    { VOLD_CMD_ENABLE_UMS,      do_set_ums_enable },

{ VOLD_CMD_DISABLE_UMS,     do_set_ums_enable },

...

static int do_set_ums_enable(char *cmd)

{

    if (!strcmp(cmd, VOLD_CMD_ENABLE_UMS))

        return volmgr_enable_ums(true);

 

    return volmgr_enable_ums(false);

}

转向文件：system/core/vold/Volmgr.c

int volmgr_enable_ums(boolean enable)

{

    volume_t *v = vol_root;

 

    while(v) {

        if (v->ums_path) {

            int rc;

 

            if (enable) {

                pthread_mutex_lock(&v->lock);

                            if (v->state == volstate_mounted)

                    volmgr_send_eject_request(v);

                ...

 

                // Stop the volume, and enable UMS in the callback

                rc = volmgr_shutdown_volume(v, _cb_volstopped_for_ums_enable, false);

                ...

                     }

        }

 next_vol:

        v = v->next;

    }

    return 0;

}

static void _cb_volstopped_for_ums_enable(volume_t *v, void *arg)

{

    ...

 

if ((rc = ums_enable(devdir_path, v->ums_path)) < 0)

...

}

再转向文件：system/core/vold/Ums.c

int ums_enable(char *dev_fspath, char *lun_syspath)

{

    LOG_VOL("ums_enable(%s, %s):", dev_fspath, lun_syspath);

 

    int fd;

    char filename[255];

 

    sprintf(filename, "/sys/%s/file", lun_syspath);

    if ((fd = open(filename, O_WRONLY)) < 0) {

        LOGE("Unable to open '%s' (%s)", filename, strerror(errno));

        return -errno;

    }

 

    if (write(fd, dev_fspath, strlen(dev_fspath)) < 0) {

        LOGE("Unable to write to ums lunfile (%s)", strerror(errno));

        close(fd);

        return -errno;

    }

   

    close(fd);

    return 0;

}

9.8 总结

vold.conf 配置了SDCARD和USB的系统设备路径。

volume_sdcard {

    ## This is the direct uevent device path to the SD slot on the device

    media_path     /devices/platform/msm_sdcc.2/mmc_host/mmc1

    emu_media_path /devices/platform/goldfish_mmc.0/mmc_host/mmc0

 

    media_type     mmc

    mount_point    /sdcard

    ums_path       /devices/platform/usb_mass_storage/lun0

}

vold程序启动后会加载SDCARD卡到 /sdcard 目录下；media_path的路径是cd /sys/class/mmc_host/mmc?/ 后使用pwd所获得的真实路径。

当有USB连接时，被要求使用MASS STORAGE模式时，则会停止SDCARD作为内部，而作为USB存储器。