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

int main() 
{VolumeManager *vm;CommandListener *cl;NetlinkManager *nm;//创建vold设备文件夹mkdir("/dev/block/vold", 0755);//初始化Vold相关的类实例 singlevm = VolumeManager::Instance();nm = NetlinkManager::Instance();//CommandListener 创建vold socket监听上层消息cl = new CommandListener();vm->setBroadcaster((SocketListener *) cl);nm->setBroadcaster((SocketListener *) cl);//启动VolumeManager vm->start();//根据配置文件/etc/vold.fstab 初始化VolumeManager process_config(vm);//启动NetlinkManager socket监听内核发送ueventnm->start();//向/sys/block/目录下所有设备uevent文件写入“add\n”,//触发内核sysfs发送uevent消息coldboot("/sys/block");//启动CommandListener监听vold socketcl->startListener();// Eventually we'll become the monitoring threadwhile(1) {sleep(1000);}exit(0);
}

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

<span style="background-color:#fefef2">#######################
## Regular device mount
##
## Format: dev_mount <label> <mount_point> <part> <sysfs_path1...>
## label        - Label for the volume
## mount_point  - Where the volume will be mounted
## part         - Partition # (1 based), or 'auto' for first usable partition.
## <sysfs_path> - List of sysfs paths to source devices
####################### Mounts the first usable partition of the specified device
#dev_mount sdcard /mnt/sdcard auto /block/mmcblk0
dev_mount internal /mnt/sdcard 19 /devices/platform/sprd-sdhci.3/mmc_host/mmc3
dev_mount sdcard /mnt/sdcard/external auto /devices/platform/sprd-sdhci.0/mmc_host/mmc0</span>

process_config解析vold.fstab文件：

static int process_config(VolumeManager *vm) {//打开vold.fstab的配置文件fp = fopen("/etc/vold.fstab", "r")//解析vold.fstab 配置存储设备的挂载点while(fgets(line, sizeof(line), fp)) {const char *delim = " \t";char *type, *label, *mount_point, *part, *mount_flags, *sysfs_path;type = strtok_r(line, delim, &save_ptr)label = strtok_r(NULL, delim, &save_ptr)mount_point = strtok_r(NULL, delim, &save_ptr)//判断分区 auto没有分区part = strtok_r(NULL, delim, &save_ptr)if (!strcmp(part, "auto")) {//创建DirectVolume对象 相关的挂载点设备的操作dv = new DirectVolume(vm, label, mount_point, -1);} else {dv = new DirectVolume(vm, label, mount_point, atoi(part));}//添加挂载点设备路径while ((sysfs_path = strtok_r(NULL, delim, &save_ptr))) {dv->addPath(sysfs_path)}//将DirectVolume 添加到VolumeManager管理vm->addVolume(dv);}fclose(fp);return 0;
}

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实例

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

启动NetlinkManager

int NetlinkManager::start() {//netlink使用的socket结构struct sockaddr_nl nladdr;//初始化socket数据结构memset(&nladdr, 0, sizeof(nladdr));nladdr.nl_family = AF_NETLINK;nladdr.nl_pid = getpid();nladdr.nl_groups = 0xffffffff;//创建socket PF_NETLINK类型mSock = socket(PF_NETLINK,SOCK_DGRAM,NETLINK_KOBJECT_UEVENT);//配置socket 大小setsockopt(mSock, SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz);setsockopt(mSock, SOL_SOCKET, SO_PASSCRED, &on, sizeof(on);//bindsocket地址bind(mSock, (struct sockaddr *) &nladdr, sizeof(nladdr);//创建NetlinkHandler 传递socket标识，并启动mHandler = new NetlinkHandler(mSock);mHandler->start();return 0;
}

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

SocketListener::SocketListener(int socketFd, bool listen) {init(NULL, socketFd, listen, false);
}

void SocketListener::init(const char *socketName, int socketFd, bool listen, bool useCmdNum) {mListen = listen;mSocketName = socketName;mSock = socketFd;mUseCmdNum = useCmdNum;pthread_mutex_init(&mClientsLock, NULL);mClients = new SocketClientCollection();
}

NetlinkListener构造函数：

NetlinkListener::NetlinkListener(int socket) :SocketListener(socket, false) {mFormat = NETLINK_FORMAT_ASCII;
}

NetlinkHandler构造函数：

NetlinkHandler::NetlinkHandler(int listenerSocket) :NetlinkListener(listenerSocket) {
}

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

NetlinkHandler start：

int NetlinkHandler::start() {//父类startListenerreturn this->startListener();
}

SocketListener start：

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

uevent消息监听线程

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

void *SocketListener::threadStart(void *obj) {//参数转换SocketListener *me = reinterpret_cast<SocketListener *>(obj);me->runListener();pthread_exit(NULL);return NULL;}

SocketListener 线程消息循环：

void SocketListener::runListener() {//SocketClient ListSocketClientCollection *pendingList = new SocketClientCollection();while(1) {fd_set read_fds;//mListen 为falseif (mListen) {max = mSock;FD_SET(mSock, &read_fds);}//加入一组文件描述符集合 选择fd最大的maxFD_SET(mCtrlPipe[0], &read_fds);pthread_mutex_lock(&mClientsLock);for (it = mClients->begin(); it != mClients->end(); ++it) {int fd = (*it)->getSocket();FD_SET(fd, &read_fds);if (fd > max)max = fd;}pthread_mutex_unlock(&mClientsLock);//监听文件描述符是否变化rc = select(max + 1, &read_fds, NULL, NULL, NULL);//匿名管道被写，退出线程if (FD_ISSET(mCtrlPipe[0], &read_fds))break;//mListen 为falseif (mListen && FD_ISSET(mSock, &read_fds)) {//mListen 为ture 表示正常监听socketstruct sockaddr addr;do {//接收客户端连接c = accept(mSock, &addr, &alen);} while (c < 0 && errno == EINTR);//此处创建一个客户端SocketClient加入mClients列表中，异步延迟处理pthread_mutex_lock(&mClientsLock);mClients->push_back(new SocketClient(c, true, mUseCmdNum));pthread_mutex_unlock(&mClientsLock);}/* Add all active clients to the pending list first */pendingList->clear();//将所有有消息的Client加入到pendingList中pthread_mutex_lock(&mClientsLock);for (it = mClients->begin(); it != mClients->end(); ++it) {int fd = (*it)->getSocket();if (FD_ISSET(fd, &read_fds)) {pendingList->push_back(*it);}}pthread_mutex_unlock(&mClientsLock);//处理所有消息while (!pendingList->empty()) {it = pendingList->begin();SocketClient* c = *it;pendingList->erase(it);//处理有数据发送的socket 虚函数if (!onDataAvailable(c) && mListen) {//mListen为false}}}
}

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

bool NetlinkListener::onDataAvailable(SocketClient *cli)
{//获取socket idint socket = cli->getSocket();//接收netlink uevent消息count = TEMP_FAILURE_RETRY(uevent_kernel_multicast_uid_recv(socket, mBuffer, sizeof(mBuffer), &uid));//解析uevent消息为NetlinkEvent消息NetlinkEvent *evt = new NetlinkEvent();evt->decode(mBuffer, count, mFormat);//处理NetlinkEvent onEvent虚函数onEvent(evt);
}

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

void NetlinkHandler::onEvent(NetlinkEvent *evt) {//获取VolumeManager实例VolumeManager *vm = VolumeManager::Instance();//设备类型const char *subsys = evt->getSubsystem();//将消息传递给VolumeManager处理if (!strcmp(subsys, "block")) {vm->handleBlockEvent(evt);}
}

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对象

VolumeManager *VolumeManager::Instance() {if (!sInstance)sInstance = new VolumeManager();return sInstance;
}VolumeManager::VolumeManager() {mDebug = false;mVolumes = new VolumeCollection();mActiveContainers = new AsecIdCollection();mBroadcaster = NULL;mUmsSharingCount = 0;mSavedDirtyRatio = -1;// set dirty ratio to 20 when UMS is activemUmsDirtyRatio = 20;mVolManagerDisabled = 0;
}

2.启动VolumeManager

int VolumeManager::start() {return 0;
}

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

3.uevent事件处理

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

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

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

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

int DirectVolume::handleBlockEvent(NetlinkEvent *evt) {//从NetlinkEvent消息中取出有状态变化设备路径const char *dp = evt->findParam("DEVPATH");PathCollection::iterator  it;//遍历所有的存储设备for (it = mPaths->begin(); it != mPaths->end(); ++it) {//根据存储设备路径进行匹配if (!strncmp(dp, *it, strlen(*it))) {/* 从NetlinkEvent消息中取出设备变化的动作 */int action = evt->getAction();/* 从NetlinkEvent消息中取出设备类型 */const char *devtype = evt->findParam("DEVTYPE");SLOGE("DirectVolume::handleBlockEvent() evt's DEVPATH= %s DEVTYPE= %s action= %d",dp, devtype, action);    //设备插入if (action == NetlinkEvent::NlActionAdd) {int major = atoi(evt->findParam("MAJOR"));int minor = atoi(evt->findParam("MINOR"));char nodepath[255];snprintf(nodepath,sizeof(nodepath), "/dev/block/vold/%d:%d",major, minor);SLOGE("DirectVolume::handleBlockEvent() NlActionAdd - /dev/block/vold/%d:%d\n", major, minor);if (createDeviceNode(nodepath, major, minor)) {SLOGE("Error making device node '%s' (%s)", nodepath,strerror(errno));}//新增磁盘if (!strcmp(devtype, "disk")) {handleDiskAdded(dp, evt);//新增分区} else {handlePartitionAdded(dp, evt);}//设备移除} else if (action == NetlinkEvent::NlActionRemove) {SLOGE("Volume  partition %d:%d removed",  atoi(evt->findParam("MAJOR")), atoi(evt->findParam("MINOR")));//删除磁盘if (!strcmp(devtype, "disk")) {handleDiskRemoved(dp, evt);//删除分区} else {handlePartitionRemoved(dp, evt);}//设备改变} else if (action == NetlinkEvent::NlActionChange) {//磁盘变化if (!strcmp(devtype, "disk")) {handleDiskChanged(dp, evt);//分区变化} else {handlePartitionChanged(dp, evt);}} else {SLOGW("Ignoring non add/remove/change event");}return 0;}}errno = ENODEV;return -1;
}

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

void DirectVolume::handleDiskAdded(const char *devpath, NetlinkEvent *evt) {//主次设备号mDiskMajor = atoi(evt->findParam("MAJOR"));mDiskMinor = atoi(evt->findParam("MINOR"));//设备分区情况const char *tmp = evt->findParam("NPARTS");mDiskNumParts = atoi(tmp);if (mDiskNumParts == 0) {//没有分区，Volume状态为IdlesetState(Volume::State_Idle);} else {//有分区未加载，设置Volume状态PendingsetState(Volume::State_Pending);}//格式化通知msg："Volume sdcard /mnt/sdcard disk inserted (179:0)"char msg[255];snprintf(msg, sizeof(msg), "Volume %s %s disk inserted (%d:%d)",getLabel(), getMountpoint(), mDiskMajor, mDiskMinor);//调用VolumeManager中的Broadcaster——>CommandListener 发送此msgmVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskInserted,msg, false);
}

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

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

3.CommandListener模块

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

1.构造CommandListener对象

CommandListener::CommandListener() :FrameworkListener("vold", true) {//注册Framework发送的相关命令 Command模式registerCmd(new DumpCmd());registerCmd(new VolumeCmd());registerCmd(new AsecCmd());registerCmd(new ObbCmd());registerCmd(new StorageCmd());registerCmd(new XwarpCmd());registerCmd(new CryptfsCmd());}

父类FrameworkListener构造：

FrameworkListener::FrameworkListener(const char *socketName, bool withSeq) :SocketListener(socketName, true, withSeq) {init(socketName, withSeq);
}

直接调用init函数；

void FrameworkListener::init(const char *socketName, bool withSeq) {mCommands = new FrameworkCommandCollection();errorRate = 0;mCommandCount = 0;mWithSeq = withSeq;
}

SocketListener的构造函数：

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

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

void SocketListener::init(const char *socketName, int socketFd, bool listen, bool useCmdNum) {mListen = listen;mSocketName = socketName;mSock = socketFd;mUseCmdNum = useCmdNum;pthread_mutex_init(&mClientsLock, NULL);mClients = new SocketClientCollection();
}

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

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

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

2.启动CommandListener监听

int SocketListener::startListener() {//mSocketName = “Vold”mSock = android_get_control_socket(mSocketName);//NetlinkHandler mListen为true 监听socketif (mListen && < 0) {return -1;} else if (!mListen){mClients->push_back(new SocketClient(mSock, false, mUseCmdNum));}//创建匿名管道pipe(mCtrlPipe);//创建线程执行函数threadStart 参数thispthread_create(&mThread, NULL, SocketListener::threadStart, this);
}void *SocketListener::threadStart(void *obj) {SocketListener *me = reinterpret_cast<SocketListener *>(obj);me->runListener();
}void SocketListener::runListener() {//SocketClient ListSocketClientCollection *pendingList = new SocketClientCollection();while(1) {fd_set read_fds;//mListen 为trueif (mListen) {max = mSock;FD_SET(mSock, &read_fds);}//加入一组文件描述符集合 选择fd最大的max select有关FD_SET(mCtrlPipe[0], &read_fds);pthread_mutex_lock(&mClientsLock);for (it = mClients->begin(); it != mClients->end(); ++it) {int fd = (*it)->getSocket();FD_SET(fd, &read_fds);if (fd > max)max = fd;}pthread_mutex_unlock(&mClientsLock);//监听文件描述符是否变化rc = select(max + 1, &read_fds, NULL, NULL, NULL);//匿名管道被写，退出线程if (FD_ISSET(mCtrlPipe[0], &read_fds))break;//mListen 为trueif (mListen && FD_ISSET(mSock, &read_fds)) {//mListen 为ture 表示正常监听socketstruct sockaddr addr;do {c = accept(mSock, &addr, &alen);} while (c < 0 && errno == EINTR);//创建一个客户端SocketClient，加入mClients列表中 到异步延迟处理pthread_mutex_lock(&mClientsLock);mClients->push_back(new SocketClient(c, true, mUseCmdNum));pthread_mutex_unlock(&mClientsLock);}/* Add all active clients to the pending list first */pendingList->clear();//将所有有消息的Client加入到pendingList中pthread_mutex_lock(&mClientsLock);for (it = mClients->begin(); it != mClients->end(); ++it) {int fd = (*it)->getSocket();if (FD_ISSET(fd, &read_fds)) {pendingList->push_back(*it);}}pthread_mutex_unlock(&mClientsLock);/* Process the pending list, since it is owned by the thread,*/while (!pendingList->empty()) {it = pendingList->begin();SocketClient* c = *it;//处理有数据发送的socket if (!onDataAvailable(c) && mListen) {//mListen为true……}}}
}

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

3.消息处理

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

bool FrameworkListener::onDataAvailable(SocketClient *c) {char buffer[255];//读取socket消息len = TEMP_FAILURE_RETRY(read(c->getSocket(), buffer, sizeof(buffer)));for (i = 0; i < len; i++) {if (buffer[i] == '\0') {//根据消息内容 派发命令dispatchCommand(c, buffer + offset);offset = i + 1;}}return true;
}void FrameworkListener::dispatchCommand(SocketClient *cli, char *data) {char *argv[FrameworkListener::CMD_ARGS_MAX];//解析消息内容 命令 参数……//执行对应的消息for (i = mCommands->begin(); i != mCommands->end(); ++i) {FrameworkCommand *c = *i;//匹配命令if (!strcmp(argv[0], c->getCommand())) {//执行命令c->runCommand(cli, argc, argv);goto out;}}
out:return;
}

对于VolumeCommand，其runCommand函数为：

int CommandListener::VolumeCmd::runCommand(SocketClient *cli,int argc, char **argv) {dumpArgs(argc, argv, -1);if (argc < 2) {cli->sendMsg(ResponseCode::CommandSyntaxError, "Missing Argument", false);return 0;}VolumeManager *vm = VolumeManager::Instance();int rc = 0;//查看存储设备if (!strcmp(argv[1], "list")) {return vm->listVolumes(cli);} else if (!strcmp(argv[1], "debug")) {if (argc != 3 || (argc == 3 && (strcmp(argv[2], "off") && strcmp(argv[2], "on")))) {cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: volume debug <off/on>", false);return 0;}vm->setDebug(!strcmp(argv[2], "on") ? true : false);//挂载存储设备} else if (!strcmp(argv[1], "mount")) {if (argc != 3) {cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: volume mount <path>", false);return 0;}rc = vm->mountVolume(argv[2]);//卸载存储设备} else if (!strcmp(argv[1], "unmount")) {if (argc < 3 || argc > 4 ||((argc == 4 && strcmp(argv[3], "force")) &&(argc == 4 && strcmp(argv[3], "force_and_revert")))) {cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: volume unmount <path> [force|force_and_revert]", false);return 0;}bool force = false;bool revert = false;if (argc >= 4 && !strcmp(argv[3], "force")) {force = true;} else if (argc >= 4 && !strcmp(argv[3], "force_and_revert")) {force = true;revert = true;}rc = vm->unmountVolume(argv[2], force, revert);//格式化存储设备} else if (!strcmp(argv[1], "format")) {if (argc != 3) {cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: volume format <path>", false);return 0;}rc = vm->formatVolume(argv[2]);//共享存储设备} else if (!strcmp(argv[1], "share")) {if (argc != 4) {cli->sendMsg(ResponseCode::CommandSyntaxError,"Usage: volume share <path> <method>", false);return 0;}rc = vm->shareVolume(argv[2], argv[3]);} else if (!strcmp(argv[1], "unshare")) {if (argc != 4) {cli->sendMsg(ResponseCode::CommandSyntaxError,"Usage: volume unshare <path> <method>", false);return 0;}rc = vm->unshareVolume(argv[2], argv[3]);} else if (!strcmp(argv[1], "shared")) {bool enabled = false;if (argc != 4) {cli->sendMsg(ResponseCode::CommandSyntaxError,"Usage: volume shared <path> <method>", false);return 0;}if (vm->shareEnabled(argv[2], argv[3], &enabled)) {cli->sendMsg(ResponseCode::OperationFailed, "Failed to determine share enable state", true);} else {cli->sendMsg(ResponseCode::ShareEnabledResult,(enabled ? "Share enabled" : "Share disabled"), false);}return 0;} else {cli->sendMsg(ResponseCode::CommandSyntaxError, "Unknown volume cmd", false);}if (!rc) {cli->sendMsg(ResponseCode::CommandOkay, "volume operation succeeded", false);} else {int erno = errno;rc = ResponseCode::convertFromErrno();cli->sendMsg(rc, "volume operation failed", true);}return 0;
}

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

int VolumeManager::mountVolume(const char *label) {//根据卷标查找VolumeVolume *v = lookupVolume(label);if (!v) {errno = ENOENT;return -1;}return v->mountVol();
}

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