Android之vold进程启动源码分析

转自http://blog.csdn.net/yangwen123/article/details/8919503

2013-05-13 19:30  2529人阅读  评论(0)  收藏  举报

目录(?)[-]

1. Vold Volume Daemon介绍
2. Vold 框架设计
   1. Netlink介绍
   2. Uevent介绍
3. Vold 源码分析
4. Vold各模块分析
   1. NetlinkManager模块
      1. 构造NetlinkManager实例
      2. 启动NetlinkManager
      4. uevent消息监听线程
   2. VolumeManager模块
      1. 构造VolumeManager对象
      2. 启动VolumeManager
      3. uevent事件处理
   3. CommandListener模块
      1. 构造CommandListener对象
      2. 启动CommandListener监听
      3. 消息处理

1.Vold （Volume Daemon）介绍

vold进程接收来自内核的外部设备消息，用于管理和控制Android平台外部存储设备，包括SD插拨、挂载、卸载、格式化等；当外部设备发生变化时，内核通过Netlink发送uEvent格式的消息给用户空间程序，Netlink 是一种基于异步通信机制，在内核与用户应用间进行双向数据传输的特殊 socket，用户态应用使用标准的socket API 就可以使用 netlink 提供的强大功能；

2.Vold 框架设计

Vold是native程序，用于管理和控制Android平台外部存储设备的管控中心，是一个后台运行的进程。它与Java层的MountService交互，Vold接收来自kernel的uevent消息，然后向上层转发，MountService接收来自vold的消息，同时也可以向vold发送控制命令。从以上Vold设计框架图中可以看到，Vold有三个模块，分别为NetlinkManager，VolumeManager，CommandListener。

NetlinkManager模块专门接收来自Linux内核uevent消息，并将消息转发给VolumeManager处理，VolumeManager模块接着又把相关信息通过CommandListener发送给MountService，MountService根据收到的消息会发送相应的处理命令给VolumeManager，VolumeManager接收到命令后直接对外部存储设备进行操作。

CommandListener模块内部封装良一个Socket用于跨进程通信，Java层的客户端MountService就是通过该Socket和服务端Vold进行通信的。

1.Netlink介绍

Netlink是Linux系统中用户空间进程和Kernel进行通信的一种机制，用户空间进程可以接收来自Kernel的消息，同时也可以向Kernel发送一些控制命令。 LINUX netlink机制一文中详细介绍了Netlink的用法。

2.Uevent介绍

uevent和Linux的设备文件系统及设备模型有关，是sysfs向用户空间发送的消息。消息格式实际上是一串字符串。当外部设备发生变化时，会引起Kernel发送Uevent消息；一般设备在/sys对应的目录下有个叫uevent的文件，往该文件里写入指定数据，也会触发Kernel发送和该设备相关的uevent消息，内核通过uevent告知外部存储系统发生的变化。

3.Vold 源码分析

 \system\vold\main.cpp

[cpp]  view plain copy

1. int main()   
2. {  
3.         VolumeManager *vm;  
4.         CommandListener *cl;  
5.         NetlinkManager *nm;  
6.         //创建vold设备文件夹  
7.         mkdir("/dev/block/vold", 0755);  
8.           
9.         //初始化Vold相关的类实例 single  
10.         vm = VolumeManager::Instance();  
11.         nm = NetlinkManager::Instance();  
12.           
13.         //CommandListener 创建vold socket监听上层消息  
14.         cl = new CommandListener();  
15.         vm->setBroadcaster((SocketListener *) cl);  
16.         nm->setBroadcaster((SocketListener *) cl);  
17.           
18.         //启动VolumeManager   
19.         vm->start();  
20.           
21.         //根据配置文件/etc/vold.fstab 初始化VolumeManager   
22.         process_config(vm);  
23.           
24.         //启动NetlinkManager socket监听内核发送uevent  
25.         nm->start();  
26.           
27.         //向/sys/block/目录下所有设备uevent文件写入“add\n”,  
28.         //触发内核sysfs发送uevent消息  
29.         coldboot("/sys/block");  
30.           
31.         //启动CommandListener监听vold socket  
32.         cl->startListener();  
33.           
34.         // Eventually we'll become the monitoring thread  
35.         while(1) {  
36.             sleep(1000);  
37.         }  
38.           
39.         exit(0);  
40. }  

/etc/vold.fstab的内容如下：

[plain]  view plain copy

1. <span style="font-family:Verdana, Arial, Helvetica, sans-serif;font-size:18px;"><span style="line-height: 24px; background-color: rgb(254, 254, 242);">#######################  
2. ## Regular device mount  
3. ##  
4. ## Format: dev_mount <label> <mount_point> <part> <sysfs_path1...>  
5. ## label        - Label for the volume  
6. ## mount_point  - Where the volume will be mounted  
7. ## part         - Partition # (1 based), or 'auto' for first usable partition.  
8. ## <sysfs_path> - List of sysfs paths to source devices  
9. ######################  
10.   
11. # Mounts the first usable partition of the specified device  
12. #dev_mount sdcard /mnt/sdcard auto /block/mmcblk0  
13. dev_mount internal /mnt/sdcard 19 /devices/platform/sprd-sdhci.3/mmc_host/mmc3  
14. dev_mount sdcard /mnt/sdcard/external auto /devices/platform/sprd-sdhci.0/mmc_host/mmc0</span></span>  

process_config解析vold.fstab文件：

[cpp]  view plain copy

1. static int process_config(VolumeManager *vm) {  
2.         //打开vold.fstab的配置文件  
3.         fp = fopen("/etc/vold.fstab", "r")  
4.         //解析vold.fstab 配置存储设备的挂载点  
5.     while(fgets(line, sizeof(line), fp)) {  
6.         const char *delim = " \t";  
7.         char *type, *label, *mount_point, *part, *mount_flags, *sysfs_path;  
8.   
9.         type = strtok_r(line, delim, &save_ptr)  
10.         label = strtok_r(NULL, delim, &save_ptr)  
11.         mount_point = strtok_r(NULL, delim, &save_ptr)  
12.               //判断分区 auto没有分区  
13.         part = strtok_r(NULL, delim, &save_ptr)  
14.         if (!strcmp(part, "auto")) {  
15.              //创建DirectVolume对象 相关的挂载点设备的操作  
16.            dv = new DirectVolume(vm, label, mount_point, -1);  
17.         } else {  
18.            dv = new DirectVolume(vm, label, mount_point, atoi(part));  
19.         }  
20.                 //添加挂载点设备路径  
21.         while ((sysfs_path = strtok_r(NULL, delim, &save_ptr))) {  
22.             dv->addPath(sysfs_path)  
23.         }  
24.               //将DirectVolume 添加到VolumeManager管理  
25.               vm->addVolume(dv);  
26.     }  
27.   
28.     fclose(fp);  
29.     return 0;  
30. }  

4.Vold各模块分析

前面介绍了Vold包含NetlinkManager，VolumeManager，CommandListener三大模块，他们之间的关系如下：

接下来就分别针对每个模块进行详细分析。

1.NetlinkManager模块

NetlinkManager模块接收从Kernel发送的Uevent消息，解析转换成NetlinkEvent对象；再将此NetlinkEvent对象传递给VolumeManager处理。

启动流程
1）构造NetlinkManager实例：nm = NetlinkManager::Instance()
2）设置事件广播监听：nm->setBroadcaster((SocketListener *) cl)
3）启动NetlinkManager：nm->start()

构造NetlinkManager实例

[cpp]  view plain copy

1. NetlinkManager *NetlinkManager::Instance() {  
2.     if (!sInstance) //采用单例模式创建NetlinkManager实例  
3.         sInstance = new NetlinkManager();  
4.     return sInstance;  
5. }  

 

启动NetlinkManager

[cpp]  view plain copy

1. int NetlinkManager::start() {  
2.     //netlink使用的socket结构  
3.     struct sockaddr_nl nladdr;  
4.           
5.     //初始化socket数据结构  
6.     memset(&nladdr, 0, sizeof(nladdr));  
7.     nladdr.nl_family = AF_NETLINK;  
8.     nladdr.nl_pid = getpid();  
9.     nladdr.nl_groups = 0xffffffff;  
10.     //创建socket PF_NETLINK类型  
11.     mSock = socket(PF_NETLINK,SOCK_DGRAM,NETLINK_KOBJECT_UEVENT);  
12.     //配置socket 大小  
13.     setsockopt(mSock, SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz);  
14.     setsockopt(mSock, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on);  
15.     //bindsocket地址  
16.     bind(mSock, (struct sockaddr *) &nladdr, sizeof(nladdr);  
17.           
18.     //创建NetlinkHandler 传递socket标识，并启动  
19.     mHandler = new NetlinkHandler(mSock);  
20.     mHandler->start();  
21.     return 0;  
22. }  

在启动NetlinkManager时，初始化socket用于创建NetlinkManager的属性变量mHandle实例，并启动NetlinkHandler，NetlinkHandler继承于NetlinkListener，NetlinkListener又继承于SocketListener，因此在构造NetlinkHandler实例时首先构造SocketListener及NetlinkListener，构造NetlinkListener对象的父类对象SocketListener：

[cpp]  view plain copy

1. SocketListener::SocketListener(int socketFd, bool listen) {  
2.     init(NULL, socketFd, listen, false);  
3. }  

[cpp]  view plain copy

1. void SocketListener::init(const char *socketName, int socketFd, bool listen, bool useCmdNum) {  
2.     mListen = listen;  
3.     mSocketName = socketName;  
4.     mSock = socketFd;  
5.     mUseCmdNum = useCmdNum;  
6.     pthread_mutex_init(&mClientsLock, NULL);  
7.     mClients = new SocketClientCollection();  
8. }  

NetlinkListener构造函数：

[cpp]  view plain copy

1. NetlinkListener::NetlinkListener(int socket) :  
2.                             SocketListener(socket, false) {  
3.     mFormat = NETLINK_FORMAT_ASCII;  
4. }  

NetlinkHandler构造函数：

[cpp]  view plain copy

1. NetlinkHandler::NetlinkHandler(int listenerSocket) :  
2.                 NetlinkListener(listenerSocket) {  
3. }  

因此构造NetlinkHandler实例过程仅仅创建良一个socket客户端连接。

NetlinkHandler start：

[cpp]  view plain copy

1. int NetlinkHandler::start() {  
2. 　　　　//父类startListener  
3. 　　　　return this->startListener();  
4. }  

SocketListener  start：

[cpp]  view plain copy

1. int SocketListener::startListener() {  
2. 　　 //NetlinkHandler mListen为false   
3.     if (mListen && listen(mSock, 4) < 0) {  
4.         return -1;  
5.     } else if (!mListen){  
6.         //mListen为false 用于netlink消息监听  
7.         //创建SocketClient作为SocketListener 的客户端   
8.         mClients->push_back(new SocketClient(mSock, false, mUseCmdNum));  
9.     }  
10.   
11.     //创建匿名管道  
12.     pipe(mCtrlPipe);  
13.     //创建线程执行函数threadStart    参this  
14.     pthread_create(&mThread, NULL, SocketListener::threadStart, this);  
15. }  

uevent消息监听线程

启动NetlinkHandler过程通过创建一个SocketListener工作线程来 监听Kernel netlink发送的UEvent消息，该线程完成的工作：

[cpp]  view plain copy

1. void *SocketListener::threadStart(void *obj) {  
2.   
3.     //参数转换  
4.     SocketListener *me = reinterpret_cast<SocketListener *>(obj);  
5.   
6.     me->runListener();  
7.   
8.     pthread_exit(NULL);  
9.   
10.     return NULL;  
11.   
12. }  

SocketListener 线程消息循环：

[cpp]  view plain copy

1. void SocketListener::runListener() {  
2.         //SocketClient List  
3.     SocketClientCollection *pendingList = new SocketClientCollection();  
4.   
5.     while(1) {  
6.         fd_set read_fds;  
7.         //mListen 为false  
8.         if (mListen) {  
9.             max = mSock;  
10.             FD_SET(mSock, &read_fds);  
11.         }  
12.         //加入一组文件描述符集合 选择fd最大的max  
13.         FD_SET(mCtrlPipe[0], &read_fds);  
14.         pthread_mutex_lock(&mClientsLock);  
15.         for (it = mClients->begin(); it != mClients->end(); ++it) {  
16.             int fd = (*it)->getSocket();  
17.             FD_SET(fd, &read_fds);  
18.             if (fd > max)  
19.                 max = fd;  
20.         }  
21.         pthread_mutex_unlock(&mClientsLock);  
22.           
23.         //监听文件描述符是否变化  
24.         rc = select(max + 1, &read_fds, NULL, NULL, NULL);  
25.         //匿名管道被写，退出线程  
26.         if (FD_ISSET(mCtrlPipe[0], &read_fds))  
27.             break;  
28.         //mListen 为false  
29.         if (mListen && FD_ISSET(mSock, &read_fds)) {  
30.                 //mListen 为ture 表示正常监听socket  
31.             struct sockaddr addr;  
32.             do {  
33.                 //接收客户端连接  
34.                 c = accept(mSock, &addr, &alen);  
35.             } while (c < 0 && errno == EINTR);  
36.               
37.             //此处创建一个客户端SocketClient加入mClients列表中，异步延迟处理  
38.             pthread_mutex_lock(&mClientsLock);  
39.             mClients->push_back(new SocketClient(c, true, mUseCmdNum));  
40.             pthread_mutex_unlock(&mClientsLock);  
41.         }  
42.   
43.         /* Add all active clients to the pending list first */  
44.         pendingList->clear();  
45.         //将所有有消息的Client加入到pendingList中  
46.         pthread_mutex_lock(&mClientsLock);  
47.         for (it = mClients->begin(); it != mClients->end(); ++it) {  
48.             int fd = (*it)->getSocket();  
49.             if (FD_ISSET(fd, &read_fds)) {  
50.                 pendingList->push_back(*it);  
51.             }  
52.         }  
53.         pthread_mutex_unlock(&mClientsLock);  
54.   
55.         //处理所有消息  
56.         while (!pendingList->empty()) {  
57.             it = pendingList->begin();  
58.             SocketClient* c = *it;  
59.             pendingList->erase(it);  
60.                //处理有数据发送的socket 虚函数  
61.             if (!onDataAvailable(c) && mListen) {  
62.                //mListen为false  
63.             }  
64.         }  
65.     }  
66. }  

在消息循环中调用onDataAvailable处理消息，onDataAvailable是个虚函数，NetlinkListener重写了此函数。

[cpp]  view plain copy

1. bool NetlinkListener::onDataAvailable(SocketClient *cli)  
2. {  
3.     //获取socket id  
4.     int socket = cli->getSocket();  
5.     //接收netlink uevent消息  
6.     count = TEMP_FAILURE_RETRY(uevent_kernel_multicast_uid_recv(  
7.                                  socket, mBuffer, sizeof(mBuffer), &uid));  
8.     //解析uevent消息为NetlinkEvent消息  
9.     NetlinkEvent *evt = new NetlinkEvent();  
10.     evt->decode(mBuffer, count, mFormat);  
11.       
12.     //处理NetlinkEvent onEvent虚函数  
13.     onEvent(evt);  
14. }  

将接收的Uevent数据转化成NetlinkEvent数据，调用onEvent处理，NetlinkListener子类NetlinkHandler重写了此函数。

[cpp]  view plain copy

1. void NetlinkHandler::onEvent(NetlinkEvent *evt) {  
2.   
3.     //获取VolumeManager实例  
4.     VolumeManager *vm = VolumeManager::Instance();  
5.   
6.     //设备类型  
7.     const char *subsys = evt->getSubsystem();  
8.                    
9.     //将消息传递给VolumeManager处理  
10.     if (!strcmp(subsys, "block")) {  
11.         vm->handleBlockEvent(evt);  
12.   
13.     }  
14. }  

NetlinkManager通过NetlinkHandler将接收到Kernel内核发送的Uenvet消息，转化成了NetlinkEvent结构数据传递给VolumeManager处理，uevent消息的上传流程：

2.VolumeManager模块

启动流程
1）构造VolumeManager对象实例
2）设置事件广播监听
3）启动VolumeManager
4）配置VolumeManager

VolumeManager类关系图：

DirectVolume是一个实体存储设备的抽象，通过系统调用直接操作存储设备。VolumeManager的SocketListenner与NetlinkManager的SocketListenner有所不同的：

NetlinkManager构造的SocketListenner：Kernel与Vold通信；

VolumeManager构造的SocketListenner：Native Vold与Framework MountService 通信；

NetlinkManager与VolumeManager交互流程图：

1.构造VolumeManager对象

[cpp]  view plain copy

1. VolumeManager *VolumeManager::Instance() {  
2.     if (!sInstance)  
3.         sInstance = new VolumeManager();  
4.     return sInstance;  
5. }  
6.   
7. VolumeManager::VolumeManager() {  
8.     mDebug = false;  
9.     mVolumes = new VolumeCollection();  
10.     mActiveContainers = new AsecIdCollection();  
11.     mBroadcaster = NULL;  
12.     mUmsSharingCount = 0;  
13.     mSavedDirtyRatio = -1;  
14.     // set dirty ratio to 20 when UMS is active  
15.     mUmsDirtyRatio = 20;  
16.     mVolManagerDisabled = 0;  
17. }  

2.启动VolumeManager

[cpp]  view plain copy

1. int VolumeManager::start() {  
2.     return 0;  
3. }  

VolumeManager启动过程什么都没有做。

3.uevent事件处理

前面NetlinkManager模块中介绍到，NetlinkHandler在onEvent函数中，将NetlinkEvent事件转交给VolumeManager处理：

[cpp]  view plain copy

1. void NetlinkHandler::onEvent(NetlinkEvent *evt) {  
2.         ……  
3.             //将消息传递给VolumeManager处理  
4.         if (!strcmp(subsys, "block")) {  
5.             vm->handleBlockEvent(evt);  
6.         }  
7. }  

[cpp]  view plain copy

1. void VolumeManager::handleBlockEvent(NetlinkEvent *evt) {  
2.     //有状态变化设备路径  
3. 　　const char *devpath = evt->findParam("DEVPATH");  
4.   
5. 　　//遍历VolumeManager中所管理Volume对象（各存储设备代码抽象）  
6. 　　for (it = mVolumes->begin(); it != mVolumes->end(); ++it) {  
7.     　　if (!(*it)->handleBlockEvent(evt)) {  
8.         　　hit = true;  
9.        　　 break;  
10.     　　}  
11. }  

VolumeManager将消息交给各个DirectVolume对象处理：

[cpp]  view plain copy

1. int DirectVolume::handleBlockEvent(NetlinkEvent *evt) {  
2.     //从NetlinkEvent消息中取出有状态变化设备路径  
3.     const char *dp = evt->findParam("DEVPATH");  
4.   
5.     PathCollection::iterator  it;  
6.     //遍历所有的存储设备  
7.     for (it = mPaths->begin(); it != mPaths->end(); ++it) {  
8.         //根据存储设备路径进行匹配  
9.         if (!strncmp(dp, *it, strlen(*it))) {  
10.             /* 从NetlinkEvent消息中取出设备变化的动作 */  
11.             int action = evt->getAction();  
12.             /* 从NetlinkEvent消息中取出设备类型 */  
13.             const char *devtype = evt->findParam("DEVTYPE");  
14.             SLOGE("DirectVolume::handleBlockEvent() evt's DEVPATH= %s DEVTYPE= %s action= %d",dp, devtype, action);    //设备插入  
15.             if (action == NetlinkEvent::NlActionAdd) {  
16.                 int major = atoi(evt->findParam("MAJOR"));  
17.                 int minor = atoi(evt->findParam("MINOR"));  
18.                 char nodepath[255];  
19.   
20.                 snprintf(nodepath,sizeof(nodepath), "/dev/block/vold/%d:%d",major, minor);  
21.                 SLOGE("DirectVolume::handleBlockEvent() NlActionAdd - /dev/block/vold/%d:%d\n", major, minor);  
22.                 if (createDeviceNode(nodepath, major, minor)) {  
23.                     SLOGE("Error making device node '%s' (%s)", nodepath,strerror(errno));  
24.                 }  
25.                 //新增磁盘  
26.                 if (!strcmp(devtype, "disk")) {  
27.                     handleDiskAdded(dp, evt);  
28.                 //新增分区  
29.                 } else {  
30.                     handlePartitionAdded(dp, evt);  
31.                 }  
32.             //设备移除  
33.             } else if (action == NetlinkEvent::NlActionRemove) {  
34.                 SLOGE("Volume  partition %d:%d removed",  atoi(evt->findParam("MAJOR")), atoi(evt->findParam("MINOR")));  
35.                 //删除磁盘  
36.                 if (!strcmp(devtype, "disk")) {  
37.                     handleDiskRemoved(dp, evt);  
38.                 //删除分区  
39.                 } else {  
40.                     handlePartitionRemoved(dp, evt);  
41.                 }  
42.             //设备改变  
43.             } else if (action == NetlinkEvent::NlActionChange) {  
44.                 //磁盘变化  
45.                 if (!strcmp(devtype, "disk")) {  
46.                     handleDiskChanged(dp, evt);  
47.                 //分区变化  
48.                 } else {  
49.                     handlePartitionChanged(dp, evt);  
50.                 }  
51.             } else {  
52.                     SLOGW("Ignoring non add/remove/change event");  
53.             }  
54.   
55.             return 0;  
56.         }  
57.     }  
58.     errno = ENODEV;  
59.     return -1;  
60. }  

每一个Volume可能对应多个Path；即一个挂载点对应多个物理设备，因此VolumeManager中的每一个Volume对象都需要处理SD状态变换消息，当新增一个disk时：

[cpp]  view plain copy

1. void DirectVolume::handleDiskAdded(const char *devpath, NetlinkEvent *evt) {  
2.     //主次设备号  
3.     mDiskMajor = atoi(evt->findParam("MAJOR"));  
4.     mDiskMinor = atoi(evt->findParam("MINOR"));  
5.           
6.     //设备分区情况  
7.     const char *tmp = evt->findParam("NPARTS");  
8. 　　mDiskNumParts = atoi(tmp);  
9.       
10.     if (mDiskNumParts == 0) {  
11.         //没有分区，Volume状态为Idle  
12.         setState(Volume::State_Idle);  
13.     } else {  
14.         //有分区未加载，设置Volume状态Pending  
15.         setState(Volume::State_Pending);  
16.     }  
17.     //格式化通知msg："Volume sdcard /mnt/sdcard disk inserted (179:0)"  
18.     char msg[255];  
19.     snprintf(msg, sizeof(msg), "Volume %s %s disk inserted (%d:%d)",getLabel(), getMountpoint(), mDiskMajor, mDiskMinor);  
20.     //调用VolumeManager中的Broadcaster——>CommandListener 发送此msg  
21.     mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskInserted,msg, false);  
22. }  

将新增一个disk以消息的方式通过CommandListener向MountService发送，由于CommandListener继承于FrameworkListener，而FrameworkListener又继承于SocketListener，CommandListener和FrameworkListener都没用重写父类的sendBroadcast方法，因此消息是通过 SocketListener的sendBroadcast函数向上层发送的，VolumeManager通知上层的消息流程图：

[cpp]  view plain copy

1. void SocketListener::sendBroadcast(int code, const char *msg, bool addErrno)   
2. {  
3.     pthread_mutex_lock(&mClientsLock);  
4.     //遍历所有的消息接收时创建的Client SocketClient  
5.     // SocketClient将消息通过socket（“vold”）通信  
6.     for (i = mClients->begin(); i != mClients->end(); ++i) {  
7.         (*i)->sendMsg(code, msg, addErrno, false);  
8.     }  
9.     pthread_mutex_unlock(&mClientsLock);  
10. }  

3.CommandListener模块

1）构造CommandListener对象实例
2）调用startListener函数启动监听

1.构造CommandListener对象

[cpp]  view plain copy

1. CommandListener::CommandListener() :  
2.                 FrameworkListener("vold", true) {  
3.   
4.     //注册Framework发送的相关命令 Command模式  
5.   
6.     registerCmd(new DumpCmd());  
7.   
8.     registerCmd(new VolumeCmd());  
9.   
10.     registerCmd(new AsecCmd());  
11.   
12.     registerCmd(new ObbCmd());  
13.   
14.     registerCmd(new StorageCmd());  
15.   
16.     registerCmd(new XwarpCmd());  
17.   
18.     registerCmd(new CryptfsCmd());  
19.   
20. }  

父类FrameworkListener构造：

[cpp]  view plain copy

1. FrameworkListener::FrameworkListener(const char *socketName, bool withSeq) :  
2.                             SocketListener(socketName, true, withSeq) {  
3.     init(socketName, withSeq);  
4. }  

直接调用init函数；

[cpp]  view plain copy

1. void FrameworkListener::init(const char *socketName, bool withSeq) {  
2.     mCommands = new FrameworkCommandCollection();  
3.     errorRate = 0;  
4.     mCommandCount = 0;  
5.     mWithSeq = withSeq;  
6. }  

SocketListener的构造函数：

[cpp]  view plain copy

1. SocketListener::SocketListener(const char *socketName, bool listen, bool useCmdNum) {  
2.     init(socketName, -1, listen, useCmdNum);  
3. }  

同样调用init函数进行初始化：

[cpp]  view plain copy

1. void SocketListener::init(const char *socketName, int socketFd, bool listen, bool useCmdNum) {  
2.     mListen = listen;  
3.     mSocketName = socketName;  
4.     mSock = socketFd;  
5.     mUseCmdNum = useCmdNum;  
6.     pthread_mutex_init(&mClientsLock, NULL);  
7.     mClients = new SocketClientCollection();  
8. }  

构造CommandListener对象过程中，首先注册了各种命令，并创建良一个socket客户端连接。命令注册过程：

[cpp]  view plain copy

1. void FrameworkListener::registerCmd(FrameworkCommand *cmd) {  
2.     mCommands->push_back(cmd);  
3. }  

将各种命令存放到mCommand列表中。

2.启动CommandListener监听

[cpp]  view plain copy

1. int SocketListener::startListener() {  
2.     //mSocketName = “Vold”  
3.     mSock = android_get_control_socket(mSocketName);  
4.           
5.     //NetlinkHandler mListen为true 监听socket  
6.     if (mListen && < 0) {  
7.         return -1;  
8.     } else if (!mListen){  
9.         mClients->push_back(new SocketClient(mSock, false, mUseCmdNum));  
10.     }  
11.           
12.     //创建匿名管道  
13.     pipe(mCtrlPipe);  
14.     //创建线程执行函数threadStart 参数this  
15.     pthread_create(&mThread, NULL, SocketListener::threadStart, this);  
16. }  
17.   
18. void *SocketListener::threadStart(void *obj) {  
19.     SocketListener *me = reinterpret_cast<SocketListener *>(obj);  
20.     me->runListener();  
21. }  
22.   
23. void SocketListener::runListener() {  
24.     //SocketClient List  
25.     SocketClientCollection *pendingList = new SocketClientCollection();  
26.   
27.     while(1) {  
28.         fd_set read_fds;  
29.                 //mListen 为true  
30.         if (mListen) {  
31.             max = mSock;  
32.             FD_SET(mSock, &read_fds);  
33.         }  
34.                 //加入一组文件描述符集合 选择fd最大的max select有关  
35.         FD_SET(mCtrlPipe[0], &read_fds);  
36.         pthread_mutex_lock(&mClientsLock);  
37.         for (it = mClients->begin(); it != mClients->end(); ++it) {  
38.             int fd = (*it)->getSocket();  
39.             FD_SET(fd, &read_fds);  
40.             if (fd > max)  
41.                 max = fd;  
42.         }  
43.         pthread_mutex_unlock(&mClientsLock);  
44.           
45.         //监听文件描述符是否变化  
46.         rc = select(max + 1, &read_fds, NULL, NULL, NULL);  
47.         //匿名管道被写，退出线程  
48.         if (FD_ISSET(mCtrlPipe[0], &read_fds))  
49.             break;  
50.   
51.         //mListen 为true  
52.         if (mListen && FD_ISSET(mSock, &read_fds)) {  
53.             //mListen 为ture 表示正常监听socket  
54.             struct sockaddr addr;  
55.             do {  
56.                 c = accept(mSock, &addr, &alen);  
57.             } while (c < 0 && errno == EINTR);  
58.               
59.             //创建一个客户端SocketClient，加入mClients列表中 到异步延迟处理  
60.             pthread_mutex_lock(&mClientsLock);  
61.             mClients->push_back(new SocketClient(c, true, mUseCmdNum));  
62.             pthread_mutex_unlock(&mClientsLock);  
63.         }  
64.   
65.         /* Add all active clients to the pending list first */  
66.         pendingList->clear();  
67.         //将所有有消息的Client加入到pendingList中  
68.         pthread_mutex_lock(&mClientsLock);  
69.         for (it = mClients->begin(); it != mClients->end(); ++it) {  
70.             int fd = (*it)->getSocket();  
71.             if (FD_ISSET(fd, &read_fds)) {  
72.                 pendingList->push_back(*it);  
73.             }  
74.         }  
75.         pthread_mutex_unlock(&mClientsLock);  
76.   
77.         /* Process the pending list, since it is owned by the thread,*/  
78.         while (!pendingList->empty()) {  
79.             it = pendingList->begin();  
80.             SocketClient* c = *it;  
81.                //处理有数据发送的socket   
82.             if (!onDataAvailable(c) && mListen) {  
83.                //mListen为true  
84.                ……  
85.             }  
86.         }  
87.     }  
88. }  

启动CommandListener监听过程其实就是创建一个监听的工作线程，用于监听客户端即MountService发过来的命令。

3.消息处理

当接收到MountService发送的消息时，将回调onDataAvailable函数进行处理。CommandListener父类FrameworkCommand重写了消息处理onDataAvailable函数。

[cpp]  view plain copy

1. bool FrameworkListener::onDataAvailable(SocketClient *c) {  
2.     char buffer[255];  
3.     //读取socket消息  
4.     len = TEMP_FAILURE_RETRY(read(c->getSocket(), buffer, sizeof(buffer)));  
5.     for (i = 0; i < len; i++) {  
6.         if (buffer[i] == '\0') {  
7.             //根据消息内容 派发命令  
8.             dispatchCommand(c, buffer + offset);  
9.             offset = i + 1;  
10.         }  
11.     }  
12.     return true;  
13. }  
14.   
15. void FrameworkListener::dispatchCommand(SocketClient *cli, char *data) {  
16.    char *argv[FrameworkListener::CMD_ARGS_MAX];  
17.     //解析消息内容 命令 参数  
18.     ……  
19.       
20.     //执行对应的消息  
21.     for (i = mCommands->begin(); i != mCommands->end(); ++i) {  
22.         FrameworkCommand *c = *i;  
23.         //匹配命令  
24.         if (!strcmp(argv[0], c->getCommand())) {  
25.             //执行命令  
26.             c->runCommand(cli, argc, argv);  
27.             goto out;  
28.         }  
29.     }  
30. out:  
31.         return;  
32. }  

对于 VolumeCommand，其runCommand函数为：

[cpp]  view plain copy

1. int CommandListener::VolumeCmd::runCommand(SocketClient *cli,int argc, char **argv) {  
2.     dumpArgs(argc, argv, -1);  
3.     if (argc < 2) {  
4.         cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false);  
5.         return 0;  
6.     }  
7.     VolumeManager *vm = VolumeManager::Instance();  
8.     int rc = 0;  
9.     //查看存储设备  
10.     if (!strcmp(argv[1], "list")) {  
11.         return vm->listVolumes(cli);  
12.     } else if (!strcmp(argv[1], "debug")) {  
13.         if (argc != 3 || (argc == 3 && (strcmp(argv[2], "off") && strcmp(argv[2], "on")))) {  
14.             cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: volume debug <off/on>", false);  
15.             return 0;  
16.         }  
17.         vm->setDebug(!strcmp(argv[2], "on") ? true : false);  
18.     //挂载存储设备  
19.     } else if (!strcmp(argv[1], "mount")) {  
20.         if (argc != 3) {  
21.             cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: volume mount <path>", false);  
22.             return 0;  
23.         }  
24.         rc = vm->mountVolume(argv[2]);  
25.     //卸载存储设备  
26.     } else if (!strcmp(argv[1], "unmount")) {  
27.         if (argc < 3 || argc > 4 ||  
28.            ((argc == 4 && strcmp(argv[3], "force")) &&  
29.             (argc == 4 && strcmp(argv[3], "force_and_revert")))) {  
30.             cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: volume unmount <path> [force|force_and_revert]", false);  
31.             return 0;  
32.         }  
33.   
34.         bool force = false;  
35.         bool revert = false;  
36.         if (argc >= 4 && !strcmp(argv[3], "force")) {  
37.             force = true;  
38.         } else if (argc >= 4 && !strcmp(argv[3], "force_and_revert")) {  
39.             force = true;  
40.             revert = true;  
41.         }  
42.         rc = vm->unmountVolume(argv[2], force, revert);  
43.     //格式化存储设备  
44.     } else if (!strcmp(argv[1], "format")) {  
45.         if (argc != 3) {  
46.             cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: volume format <path>", false);  
47.             return 0;  
48.         }  
49.         rc = vm->formatVolume(argv[2]);  
50.     //共享存储设备  
51.     } else if (!strcmp(argv[1], "share")) {  
52.         if (argc != 4) {  
53.             cli->sendMsg(ResponseCode::CommandSyntaxError,  
54.                     "Usage: volume share <path> <method>", false);  
55.             return 0;  
56.         }  
57.         rc = vm->shareVolume(argv[2], argv[3]);  
58.     } else if (!strcmp(argv[1], "unshare")) {  
59.         if (argc != 4) {  
60.             cli->sendMsg(ResponseCode::CommandSyntaxError,  
61.                     "Usage: volume unshare <path> <method>", false);  
62.             return 0;  
63.         }  
64.         rc = vm->unshareVolume(argv[2], argv[3]);  
65.     } else if (!strcmp(argv[1], "shared")) {  
66.         bool enabled = false;  
67.         if (argc != 4) {  
68.             cli->sendMsg(ResponseCode::CommandSyntaxError,  
69.                     "Usage: volume shared <path> <method>", false);  
70.             return 0;  
71.         }  
72.   
73.         if (vm->shareEnabled(argv[2], argv[3], &enabled)) {  
74.             cli->sendMsg(  
75.                     ResponseCode::OperationFailed, "Failed to determine share enable state", true);  
76.         } else {  
77.             cli->sendMsg(ResponseCode::ShareEnabledResult,  
78.                     (enabled ? "Share enabled" : "Share disabled"), false);  
79.         }  
80.         return 0;  
81.     } else {  
82.         cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown volume cmd", false);  
83.     }  
84.   
85.     if (!rc) {  
86.         cli->sendMsg(ResponseCode::CommandOkay, "volume operation succeeded", false);  
87.     } else {  
88.         int erno = errno;  
89.         rc = ResponseCode::convertFromErrno();  
90.         cli->sendMsg(rc, "volume operation failed", true);  
91.     }  
92.     return 0;  
93. }  

针对不同的命令，调用VolumeManager的不同函数对存储设备进行操作，如挂载磁盘命令，则调用mountVolume函数：

[cpp]  view plain copy

1. int VolumeManager::mountVolume(const char *label) {  
2.     //根据卷标查找Volume  
3.     Volume *v = lookupVolume(label);  
4.     if (!v) {  
5.         errno = ENOENT;  
6.         return -1;  
7.     }  
8.     return v->mountVol();  
9. }  

调用Volume的mountVol函数来挂载设备。MountServcie发送命令的流程图：

整个Vold处理过程框架图如下：