SD卡挂载分析Framework

最新推荐文章于 2023-02-11 09:16:34 发布

趟石过河

最新推荐文章于 2023-02-11 09:16:34 发布

阅读量4.6k

点赞数

分类专栏： SD card 文章标签：磁盘 android 存储 linux内核 filesystems action

SD card 专栏收录该内容

29 篇文章 2 订阅

订阅专栏

http://blog.csdn.net/gzshun/article/details/7172389

本系列主要走了一下Android挂载SD卡的流程，从Vold到Framework，再从Framework到UI。也熟悉了谷歌写的C/C++源代码，提高一下自己的类的设计与代码的技巧，很感谢谷歌提供这么一个手机的开源操作系统Android，让鄙人也有机会来了解一下智能终端系统的实现原理。

只要有C/C++的基础，就能够很流畅地分析完这一块代码，比较重要的还是Android的实现架构，代码倒没什么难题。
Android系统也出来好几年，这系列文章讲解的是Android-2.2源码，那时候还没有足够的成熟，通过这种没有足够的成熟
的系统，分析起来也相对容易一些，一个系统都会慢慢地发展，越来越规范，代码质量越高，但分析起来可能越吃力。

Android磁盘管理-系统源码分析(1)

作者：gzshun. 原创作品，转载请标明出处！

本系列文章，将会详细讲解Android系统的磁盘管理部分，可以通过这个突破口，熟悉整个Android的系统架构与实现原理。

Android磁盘管理总共涉及到四大部分源码：
1.Linux kernel： Android建立在Linux内核的基础上，最底层的部分是由Linux kernel来负责的，用于检测热插拔事件；
2.Vold：Android没有使用Linux平台下的udev来处理，于是Google写了一个类似udev功能的vold，充当了kernel与framework之间的桥梁；
3.Framework：Android的核心框架，(仅仅磁盘管理这部分)负责操作vold，给vold下发操作命令；
4.UI：Androidd的系统应用，与Framework进行交互，用于挂载/卸载SD卡。

Android挂载SD卡，流程如下：
1.用户在“设置”页面的“SD卡和手机内存”中，点击“挂载”；
2.UI从Framework获取操作磁盘的函数(向Framework注册，才能使用的函数)，然后调用挂载的处理函数；
3.该处理函数通过广播机制发送挂载命令“volume mount sdcard”，vold接受命令并挂载SD卡后，用广播通知Framework；
4.Framework收到挂载SD卡的回复，通知UI的处理结果；
5.界面显示挂载成功/挂载失败。

从这里可以看出，Android的磁盘管理涉及到整个系统框架，这是Android系统很重要的一个子系统，通过磁盘管理的子系统来熟悉Android系统架构，能够了解到Android的多方面知识。从SD卡的挂载流程可以看出，Android系统大量地使用IPC，从而做到了模块独立的效果。从磁盘管理的那四大部分来看，四个部分之间的相互联系均是使用socket进行通信，没有使用到传统的API调用，整个系统就显得非常的独立。

源码的位置：
Vold:system/vold
Framework: frameworks/base/services/java/com/android/server

UI: android-2.2r2/packages/apps/Settings/src/com/android/settings/deviceinfo/

Android磁盘管理-之vold源码分析(2)

Vold是Android系统处理磁盘的核心部分，取代了原来Linux系统中的udev，主要用来处理Android系统的热插拔存储设备。在Android2.2以后的系统中，vold源码已经移到了system目录下，vold目录包含以下源码：
├── Android.mk
├── Asec.h
├── CleanSpec.mk
├── CommandListener.cpp
├── CommandListener.h
├── Devmapper.cpp
├── Devmapper.h
├── DirectVolume.cpp
├── DirectVolume.h
├── Fat.cpp
├── Fat.h
├── hash.h
├── logwrapper.c
├── Loop.cpp
├── Loop.h
├── main.cpp
├── NetlinkHandler.cpp
├── NetlinkHandler.h
├── NetlinkManager.cpp
├── NetlinkManager.h
├── Process.cpp
├── Process.h
├── ResponseCode.cpp
├── ResponseCode.h
├── vdc.c
├── VoldCommand.cpp
├── VoldCommand.h
├── Volume.cpp
├── Volume.h
├── VolumeManager.cpp
├── VolumeManager.h
├── Xwarp.cpp
└── Xwarp.h

先简要说明一下类的继承关系，vold中比较重要的有以下几个类：
三大管理类：VolumeManager,CommandListener,NetlinkManager
其他处理类：Volume,DirectVolume,NetlinkHandler,Fat,ResponseCode
其他相关的类：NetlinkListener,SocketListener

1.VolumeManager管理Volume类；
2.DirectVolume类继承于Volume类，保存着磁盘信息与操作函数；
3.NetlinkManager类负责与内核uevent事件通信，期间，使用到了NetlinkListener和SocketListener类的函数；
4.Fat是格式化sd卡的函数；
5.ResponseCode保存着vold向framework反馈的值。

本文讲解main.cpp文件的源代码：

[cpp] view plain copy

int main() {
/**********************************************************************************
**以下三个类声明三个指针对象：
**VolumeManager :管理所有存储设备(volume对象)；
**CommandListener :监听Framework下发的消息，并分析命令，调用响应的操作函数；
**NetlinkManager :监听Linux内核的热插拔事件，uevent事件
**********************************************************************************/
VolumeManager *vm;
CommandListener *cl;
NetlinkManager *nm;
SLOGI("Vold 2.1 (the revenge) firing up");
/**********************************************************************************
**在Linux系统，如scsi硬盘，U盘的设备节点默认生成在/dev/目录下，Android把这些设备
**节点改到了/dev/block/目录下。但随着热插拔事件的产生，设备节点(如sda,sdb)经常变换，
**对于vold来说，可能有点麻烦，所以在/dev/block/下新建了一个名为vold的目录，存放sda,
**sdb对应的设备节点，形如"8:0"。
**eg:sda 的主次设备号分别为8,0,于是vold就会在vold目录下创建名为"8:0"的节点，基于主次设备号
**命名，便于程序操作，增加了灵活性。
**********************************************************************************/
mkdir("/dev/block/vold", 0755);
/**********************************************************************************
**实例化vm对象，VolumeManager类调用自身的Instance函数，new了一个对象给vm。
**源码：
VolumeManager *VolumeManager::Instance() {
if (!sInstance)
sInstance = new VolumeManager();
return sInstance;
}
**********************************************************************************/
if (!(vm = VolumeManager::Instance())) {
SLOGE("Unable to create VolumeManager");
exit(1);
};
/**********************************************************************************
**实例化nm对象，NetlinkManager类调用自身的Instance函数，new了一个对象给nm。
**源码：
NetlinkManager *NetlinkManager::Instance() {
if (!sInstance)
sInstance = new NetlinkManager();
return sInstance;
}
**********************************************************************************/
if (!(nm = NetlinkManager::Instance())) {
SLOGE("Unable to create NetlinkManager");
exit(1);
};
/**********************************************************************************
**实例化cl对象；
**vm->setBroadcaster((SocketListener *) cl);
**setBroadcaster函数将VolumeManager的成员变量mBroadcaster设置成cl，这两个变量都是
**SocketListener的指针类型，命令执行状态广播函数就会调用这个SocketListener指针来调用
**SocketListener类的广播函数；
**为什么SocketListener类能强制转换CommandListener类呢？
**原因：继承关系：CommandListener(子类) --> FrameworkListener(子类) --> SocketListener(父类)
**将子类强制转换为父类是没错的。
**********************************************************************************/
cl = new CommandListener();
vm->setBroadcaster((SocketListener *) cl);
nm->setBroadcaster((SocketListener *) cl);
/**********************************************************************************
**调用start函数启动存储设备的管理类，看了源码，这函数没干什么事，估计去哪打酱油了。
**源码：
int VolumeManager::start() {
return 0;
}
**********************************************************************************/
if (vm->start()) {
SLOGE("Unable to start VolumeManager (%s)", strerror(errno));
exit(1);
}
/**********************************************************************************
**process_config函数用来解析/etc/vold.fstab的配置文件，从代码可以看出，配置文件的参数
**以空格和制表格(Tab键)分隔；系统启动起来，分析该配置文件，挂载相应的分区，相当于
**Linux系统的/etc/fstab文件。
**********************************************************************************/
if (process_config(vm)) {
SLOGE("Error reading configuration (%s)... continuing anyways", strerror(errno));
}
/**********************************************************************************
**nm对象调用start函数开启了一个线程，用来监听底层的uevent事件；这start函数干的事就
**多了，主要是打开一个udp套接字，循环监听底层事件。线程里面使用了Select函数来处理
**套接字，这设计到fd_set结构体等等的使用；
**当捕获到uevent事件，vold会将该事件通知给Framework层，Framework进行判断，然后再
**下发操作命令。
**********************************************************************************/
if (nm->start()) {
SLOGE("Unable to start NetlinkManager (%s)", strerror(errno));
exit(1);
}
coldboot("/sys/block");
/**********************************************************************************
**下面是判断Android系统是否处于ums状态，ums是大容量存储的意思，这是Android系统
**的OTG功能。OTG是on-the-go的简称，主要提供与pc机的连接；
**notifyUmsConnected函数将ums的状态通知给Framework层，于是Framework与UI配合，弹出
**一个与pc机连接的交互界面。
**********************************************************************************/
{
FILE *fp;
char state[255];
if ((fp = fopen("/sys/devices/virtual/switch/usb_mass_storage/state","r"))) {
if (fgets(state, sizeof(state), fp)) {
if (!strncmp(state, "online", 6)) {
vm->notifyUmsConnected(true);
} else {
vm->notifyUmsConnected(false);
}
} else {
SLOGE("Failed to read switch state (%s)", strerror(errno));
}
fclose(fp);
} else {
SLOGW("No UMS switch available");
}
}
/**********************************************************************************
**上面的准备工作已做完，现在是vold比较重要的一个处理线程；
**startListener是CommandListener类的父类的函数，该函数用于开启监听线程，监听
**Framework层下发给vold的命令，然后调用相应的命令操作存储设备。
**********************************************************************************/
if (cl->startListener()) {
SLOGE("Unable to start CommandListener (%s)", strerror(errno));
exit(1);
}
/**********************************************************************************
**进入一个循环，让vold保持守护进程的状态；
**vold的主要工作是由：nm->start()和cl->startListener()两个线程共同完成；这两个处理线程
**中间需要Framework来充当桥梁与boss的身份，Framework是管理这些磁盘的boss。
**********************************************************************************/
while(1) {
sleep(1000);
}
SLOGI("Vold exiting");
exit(0);
}
/**********************************************************************************
**以下这两个函数不重要，也就是打开/sys/block目录处理一些事情；这俩函数用来给vold打杂，
**社会阶级比较低，o(∩_∩)o 哈哈。
**里面有几个函数是bionic库提供的，用得比较少。
**********************************************************************************/
static void do_coldboot(DIR *d, int lvl)
{
struct dirent *de;
int dfd, fd;
dfd = dirfd(d);
fd = openat(dfd, "uevent", O_WRONLY);
if(fd >= 0) {
write(fd, "add\n", 4);
close(fd);
}
while((de = readdir(d))) {
DIR *d2;
if (de->d_name[0] == '.')
continue;
if (de->d_type != DT_DIR && lvl > 0)
continue;
fd = openat(dfd, de->d_name, O_RDONLY | O_DIRECTORY);
if(fd < 0)
continue;
d2 = fdopendir(fd);
if(d2 == 0)
close(fd);
else {
do_coldboot(d2, lvl + 1);
closedir(d2);
}
}
}
static void coldboot(const char *path)
{
DIR *d = opendir(path);
if(d) {
do_coldboot(d, 0);
closedir(d);
}
}
/**********************************************************************************
**该函数用来解析/etc/vold.fstab配置文件，文本的处理；
**可能不同的源码版本，有点差异；
**strsep是字符串的分割函数，可以看出该函数是以" \t"来分割(\t前面有一空格)，分割空格
**或制表格，所以配置文件里面空格与tab键来分割都行；
**strsep不是ANSI C的函数，但它用来取代strtok函数，strtok是线程不安全的函数。
**********************************************************************************/
static int process_config(VolumeManager *vm) {
FILE *fp;
int n = 0;
char line[255];
if (!(fp = fopen("/etc/vold.fstab", "r"))) {
return -1;
}
while(fgets(line, sizeof(line), fp)) {
char *next = line;
char *type, *label, *mount_point;
n++;
line[strlen(line)-1] = '\0';
if (line[0] == '#' || line[0] == '\0')
continue;
if (!(type = strsep(&next, " \t"))) {
SLOGE("Error parsing type");
goto out_syntax;
}
if (!(label = strsep(&next, " \t"))) {
SLOGE("Error parsing label");
goto out_syntax;
}
if (!(mount_point = strsep(&next, " \t"))) {
SLOGE("Error parsing mount point");
goto out_syntax;
}
if (!strcmp(type, "dev_mount")) {
DirectVolume *dv = NULL;
char *part, *sysfs_path;
if (!(part = strsep(&next, " \t"))) {
SLOGE("Error parsing partition");
goto out_syntax;
}
if (strcmp(part, "auto") && atoi(part) == 0) {
SLOGE("Partition must either be 'auto' or 1 based index instead of '%s'", part);
goto out_syntax;
}
/**********************************************************************************
**如果配置文件指定为auto，则为自动挂载存储设备，在实例化DirectVolume的对象，传递-1
**进去，否则将分区序数part传进去；
**********************************************************************************/
if (!strcmp(part, "auto")) {
dv = new DirectVolume(vm, label, mount_point, -1);
} else {
dv = new DirectVolume(vm, label, mount_point, atoi(part));
}
while((sysfs_path = strsep(&next, " \t"))) {
/**********************************************************************************
**将存储设备在/sys/对应的路径添加进PathCollection容器，该容器为“char *”类型；
**在/sys/里面可以获取到存储设备的热插拔事件，所以DirectVolume类的主要工作就是针对
**这里去获取uevent事件的；
**DirectVolume::handleBlockEvent(NetlinkEvent *evt)函数去得到这些事件，主要还是
**NetlinkListener类从内核捕获到的。
**********************************************************************************/
if (dv->addPath(sysfs_path)) {
SLOGE("Failed to add devpath %s to volume %s", sysfs_path,
label);
goto out_fail;
}
}
/**********************************************************************************
**如果在配置文件有找到正确的挂载参数，那么就会将DirectVolume的对象添加到VolumeCollection
**容器中，该容器存放着Volume*类型的数据，VolumeManager的对象vm是用来管理这些存储设备的；
**一块存储设备就会实例化一个Volume对象，但对于手机来说，一般只能识别到一张SD卡。
**********************************************************************************/
vm->addVolume(dv);
} else if (!strcmp(type, "map_mount")) {
} else {
SLOGE("Unknown type '%s'", type);
goto out_syntax;
}
}
fclose(fp);
return 0;
/**********************************************************************************
**从这个main函数的出错处理可以看出，系统源码经常使用到这种高效性的goto技巧，goto在
**系统中的出错处理用得很频繁，可以说几乎每个文件都使用到了goto跳转函数；
**很多文章或者教材，经常反面性的批判goto的不规则，但从这些外国的开源代码可以看出，
**那些牛人都很喜欢用goto，利用了goto来处理出错情况的技巧，显得很漂亮；
**我觉得，要从实用性的角度来评论这些语言的优缺点，并不能用否认的说法来解释，这样才能
**不断地进步；
**所以，如果在出错处理非常多的情况下，使用goto是使代码更可读，减少重复的出错判断的
**代码量。
**********************************************************************************/
out_syntax:
SLOGE("Syntax error on config line %d", n);
errno = -EINVAL;
out_fail:
fclose(fp);
return -1;
}

Android磁盘管理-之vold源码分析(3)

NetlinkManager类负责管理捕获内核的uevent事件，这里使用了Netlink套接字。

Netlink的概念：
Netlink套接字是用以实现用户进程与内核进程通信的一种特殊的进程间通信(IPC) ,也是网络应用程序与内核通信的最常用的接口。Netlink套接字可以使用标准的套接字APIs来创建。socket(), bind(), sendmsg(), recvmsg() 和 close()很容易地应用到 netlink socket。netlink包含于头文件linux/netlink.h中。
平时的应用层一般都不会用到Netlink这个套接字，了解就行。

在Main.cpp文件中的main函数里面，有一个准备工作是用来开启监听内核uevent事件的线程，源码如下：

[cpp] view plain copy

if (nm->start()) {
SLOGE("Unable to start NetlinkManager (%s)", strerror(errno));
exit(1);
}

nm是NetlinkManager类实例化的一个对象，以下是start()函数的源码：

[cpp] view plain copy

/**********************************************************************************
**file:system/vold/NetlinkManager.cpp
**以下一些socket的初始化，跟linux的应用层的tcp/udp使用差不多。
**********************************************************************************/
int NetlinkManager::start() {
struct sockaddr_nl nladdr;
int sz = 64 * 1024;
memset(&nladdr, 0, sizeof(nladdr));
nladdr.nl_family = AF_NETLINK;
nladdr.nl_pid = getpid();
nladdr.nl_groups = 0xffffffff;
if ((mSock = socket(PF_NETLINK, SOCK_DGRAM,NETLINK_KOBJECT_UEVENT)) < 0) {
SLOGE("Unable to create uevent socket: %s", strerror(errno));
return -1;
}
if (setsockopt(mSock, SOL_SOCKET, SO_RCVBUFFORCE, &sz, sizeof(sz)) < 0) {
SLOGE("Unable to set uevent socket options: %s", strerror(errno));
return -1;
}
if (bind(mSock, (struct sockaddr *) &nladdr, sizeof(nladdr)) < 0) {
SLOGE("Unable to bind uevent socket: %s", strerror(errno));
return -1;
}
/**********************************************************************************
**这里先说明NetlinkHandler类的继承关系：
**NetlinkHandler --> NetlinkListener --> SocketListener(父类)
**NetlinkHandler类的start()函数调用了SocketListener::startListener()函数，源码如下。
**********************************************************************************/
mHandler = new NetlinkHandler(mSock);
if (mHandler->start()) {
SLOGE("Unable to start NetlinkHandler: %s", strerror(errno));
return -1;
}
return 0;
}
/**********************************************************************************
**file:system/vold/NetlinkHandler.cpp
**该函数使用this指针调用自身的startListener函数，可以发现，在NetlinkHandler没有
**startListener()这个函数，这函数是它的父类的函数SocketListener::startListener；
**********************************************************************************/
int NetlinkHandler::start() {
return this->startListener();
}
/**********************************************************************************
**file:system/core/libsysutils/src/SocketListener.cpp
**以下这个函数就涉及到其他方面的内容了，不在vold部分。
**********************************************************************************/
int SocketListener::startListener() {
if (!mSocketName && mSock == -1) {
SLOGE("Failed to start unbound listener");
errno = EINVAL;
return -1;
} else if (mSocketName) {
if ((mSock = android_get_control_socket(mSocketName)) < 0) {
SLOGE("Obtaining file descriptor socket '%s' failed: %s",
mSocketName, strerror(errno));
return -1;
}
}
if (mListen && listen(mSock, 4) < 0) {
SLOGE("Unable to listen on socket (%s)", strerror(errno));
return -1;
} else if (!mListen)
mClients->push_back(new SocketClient(mSock));
if (pipe(mCtrlPipe)) {
SLOGE("pipe failed (%s)", strerror(errno));
return -1;
}
/**********************************************************************************
**该函数开启了一个监听线程。
**********************************************************************************/
if (pthread_create(&mThread, NULL, SocketListener::threadStart, this)) {
SLOGE("pthread_create (%s)", strerror(errno));
return -1;
}
return 0;
}
/**********************************************************************************
**该线程函数在类里面声明为静态函数：static void *threadStart(void *obj);
**所以不能调用this指针来指向自身的函数，所以通过pthread_create线程的创建函数来传递
**一个参数，将this指针传递给它；
**这里使用reinterpret_cast运算符是用来处理无关类型之间的转换，
**它会产生一个新的值，这个值会有与原始参数（expressoin）有完全相同的比特位。
**********************************************************************************/
void *SocketListener::threadStart(void *obj) {
SocketListener *me = reinterpret_cast<SocketListener *>(obj);
me->runListener();
pthread_exit(NULL);
return NULL;
}
/**********************************************************************************
**该函数才是真正的处理函数了，使用select集合，结合fd_set结构体，可以判断套接字有无
**信息可读，如果没有，立即返回，不阻塞；
**还使用了管道，仅仅判断该套接字的读端是否有数据可读。
**********************************************************************************/
void SocketListener::runListener() {
while(1) {
SocketClientCollection::iterator it;
fd_set read_fds;
int rc = 0;
int max = 0;
FD_ZERO(&read_fds);
if (mListen) {
max = mSock;
FD_SET(mSock, &read_fds);
}
FD_SET(mCtrlPipe[0], &read_fds);
if (mCtrlPipe[0] > max)
max = mCtrlPipe[0];
pthread_mutex_lock(&mClientsLock);
for (it = mClients->begin(); it != mClients->end(); ++it) {
FD_SET((*it)->getSocket(), &read_fds);
if ((*it)->getSocket() > max)
max = (*it)->getSocket();
}
pthread_mutex_unlock(&mClientsLock);
if ((rc = select(max + 1, &read_fds, NULL, NULL, NULL)) < 0) {
SLOGE("select failed (%s)", strerror(errno));
sleep(1);
continue;
} else if (!rc)
continue;
if (FD_ISSET(mCtrlPipe[0], &read_fds))
break;
if (mListen && FD_ISSET(mSock, &read_fds)) {
struct sockaddr addr;
socklen_t alen = sizeof(addr);
int c;
if ((c = accept(mSock, &addr, &alen)) < 0) {
SLOGE("accept failed (%s)", strerror(errno));
sleep(1);
continue;
}
pthread_mutex_lock(&mClientsLock);
mClients->push_back(new SocketClient(c));
pthread_mutex_unlock(&mClientsLock);
}
do {
pthread_mutex_lock(&mClientsLock);
for (it = mClients->begin(); it != mClients->end(); ++it) {
int fd = (*it)->getSocket();
if (FD_ISSET(fd, &read_fds)) {
pthread_mutex_unlock(&mClientsLock);
/**********************************************************************************
**onDataAvailable是SocketListener类声明的一个纯虚函数,在其子类NetlinkListener实现
**onDataAvailable函数，函数里面调用了NetlinkHandler类的onEvent函数，该函数是
**在NetlinkListener类中定义的纯虚函数，在vold中的NetlinkHandler类中实现。
**********************************************************************************/
if (!onDataAvailable(*it)) {
close(fd);
pthread_mutex_lock(&mClientsLock);
delete *it;
it = mClients->erase(it);
pthread_mutex_unlock(&mClientsLock);
}
FD_CLR(fd, &read_fds);
continue;
}
}
pthread_mutex_unlock(&mClientsLock);
} while (0);
}
}
/**********************************************************************************
**file:system/core/libsysutils/src/NetlinkListener.cpp
**该函数用来处理内核的uevent事件，然后调用onEvent函数，让onEvent函数去捕获这些事件
**的信息。
**********************************************************************************/
bool NetlinkListener::onDataAvailable(SocketClient *cli)
{
int socket = cli->getSocket();
int count;
if ((count = recv(socket, mBuffer, sizeof(mBuffer), 0)) < 0) {
SLOGE("recv failed (%s)", strerror(errno));
return false;
}
NetlinkEvent *evt = new NetlinkEvent();
if (!evt->decode(mBuffer, count)) {
SLOGE("Error decoding NetlinkEvent");
goto out;
}
/*下一篇文章介绍该函数*/
onEvent(evt);
out:
delete evt;
return true;
}

Android磁盘管理-之vold源码分析(4)

上篇文章分析到了NetlinkHandler类中的onEvent函数，该函数由NetlinkListener::onDataAvailable函数调用，当SocketListener类监听到内核的uevent事件，调用该函数，之后的事情交给onEvent来负责。

file：system/vold/NetlinkHandler.cpp
现在来说onEvent函数，在vold中，磁盘的热插拔事件都是通过上述那些间接的过程来调用到
该函数，该函数再调用vold中的处理事件的函数，这样vold就能得到最新的磁盘热插拔事件；

[cpp] view plain copy

void NetlinkHandler::onEvent(NetlinkEvent *evt) {
VolumeManager *vm = VolumeManager::Instance();
const char *subsys = evt->getSubsystem();
if (!subsys) {
SLOGW("No subsystem found in netlink event");
return;
}
if (!strcmp(subsys, "block")) {
vm->handleBlockEvent(evt);
} else if (!strcmp(subsys, "switch")) {
vm->handleSwitchEvent(evt);
} else if (!strcmp(subsys, "battery")) {
} else if (!strcmp(subsys, "power_supply")) {
}
}

file：system/vold/VolumeManager.cpp
vm->handleSwitchEvent(evt)函数涉及的比较少，先来分析；
该函数是用来处理大容量存储设备，也就是otg功能，NetlinkEvent类提供的findParam函数
可以获取到该事件的具体信息，比如设备路径，设备名称，状态，分区数量等等。。
如果判断是“online”状态，那么就向framework发送状态消息。使用notifyUmsConnected函数
进行广播。

[cpp] view plain copy

void VolumeManager::handleSwitchEvent(NetlinkEvent *evt) {
const char *devpath = evt->findParam("DEVPATH");
const char *name = evt->findParam("SWITCH_NAME");
const char *state = evt->findParam("SWITCH_STATE");
if (!name || !state) {
SLOGW("Switch %s event missing name/state info", devpath);
return;
}
if (!strcmp(name, "usb_mass_storage")) {
if (!strcmp(state, "online")) {
notifyUmsConnected(true);
} else {
notifyUmsConnected(false);
}
} else {
SLOGW("Ignoring unknown switch '%s'", name);
}
}

notifyUmsConnected函数将otg的状态发送给framework,
命令为：Share method ums now available/unavailable;
getBroadcaster()->sendBroadcast()广播函数，这在main函数分析中就涉及到了，
源码：
cl = new CommandListener();
vm->setBroadcaster((SocketListener *) cl);
nm->setBroadcaster((SocketListener *) cl);
将CommandListener对象强制转换成SocketListener类型，这样cl对象就能够调用SocketListener
类的setBroadcaster广播函数；
getBroadcaster()的源码：
SocketListener *getBroadcaster() { return mBroadcaster; }
直接将刚才被强制转换成SocketListener类型返回，相当于如下：
(SocketListener *)cl->sendBroadcast(xxx);

[cpp] view plain copy

void VolumeManager::notifyUmsConnected(bool connected) {
char msg[255];
if (connected) {
mUsbMassStorageConnected = true;
} else {
mUsbMassStorageConnected = false;
}
snprintf(msg, sizeof(msg), "Share method ums now %s", (connected ? "available" : "unavailable"));
getBroadcaster()->sendBroadcast(ResponseCode::ShareAvailabilityChange, msg, false);
}

file：system/vold/ResponseCode.cpp
该类没做什么事，也就是提供一些出错标志，下面将写出出错原因；
这些标志都会在不同的操作(命令)反馈不同的值。

[cpp] view plain copy

class ResponseCode {
public:
// 100 series - Requestion action was initiated; expect another reply
// before proceeding with a new command.
static const int ActionInitiated = 100;
static const int VolumeListResult = 110;
static const int AsecListResult = 111;
static const int StorageUsersListResult = 112;
// 200 series - Requested action has been successfully completed
static const int CommandOkay = 200;
static const int ShareStatusResult = 210;
static const int AsecPathResult = 211;
static const int ShareEnabledResult = 212;
static const int XwarpStatusResult = 213;
// 400 series - The command was accepted but the requested action
// did not take place.//这几个标志有点重复性，其实vold里面也没有这几个标志。
static const int OperationFailed = 400;
static const int OpFailedNoMedia = 401;
static const int OpFailedMediaBlank = 402;
static const int OpFailedMediaCorrupt = 403;
static const int OpFailedVolNotMounted = 404;
static const int OpFailedStorageBusy = 405;
static const int OpFailedStorageNotFound = 406;
// 500 series - The command was not accepted and the requested
// action did not take place.
static const int CommandSyntaxError = 500;//
static const int CommandParameterError = 501;//
// 600 series - Unsolicited broadcasts
static const int UnsolicitedInformational = 600;
static const int VolumeStateChange = 605;
static const int VolumeMountFailedBlank = 610;
static const int VolumeMountFailedDamaged = 611;
static const int VolumeMountFailedNoMedia = 612;
static const int ShareAvailabilityChange = 620;
static const int VolumeDiskInserted = 630;
static const int VolumeDiskRemoved = 631;
static const int VolumeBadRemoval = 632;
static int convertFromErrno();
};

file：system/vold/VolumeManager.cpp
该函数用来捕获磁盘的热插拔事件信息。

[cpp] view plain copy

void VolumeManager::handleBlockEvent(NetlinkEvent *evt) {
const char *devpath = evt->findParam("DEVPATH");
VolumeCollection::iterator it;
bool hit = false;
/**********************************************************************************
**mVolumes是一个存放volume*的容器，类型如下：
**typedef android::List<Volume *> VolumeCollection;
**mVolumes是在main函数中添加进磁盘的，在mian函数中，使用process_config函数分析
**/etc/vold.fstab配置文件，然后将磁盘的信息添加进该容器，以便后续的操作。
**********************************************************************************/
for (it = mVolumes->begin(); it != mVolumes->end(); ++it) {
if (!(*it)->handleBlockEvent(evt)) {
#ifdef NETLINK_DEBUG
SLOGD("Device '%s' event handled by volume %s\n", devpath, (*it)->getLabel());
#endif
hit = true;
break;
}
}
if (!hit) {
#ifdef NETLINK_DEBUG
SLOGW("No volumes handled block event for '%s'", devpath);
#endif
}
}

这里使用(*it)调用handleBlockEvent函数，可以看出handleBlockEvent在Volume类对象实现，
源码在system/vold/Volume.cpp
可以发现，该函数并没有做什么事情，其实handleBlockEvent函数在Volume的子类DirectVolume
中重写了。

[cpp] view plain copy

int Volume::handleBlockEvent(NetlinkEvent *evt) {
errno = ENOSYS;
return -1;
}

file:system/vold/DirectVolume.cpp
这函数是处理热插拔事件最重要的函数，Volume若要操作磁盘，肯定先要从这个函数获取到
磁盘事件和信息。

[cpp] view plain copy

int DirectVolume::handleBlockEvent(NetlinkEvent *evt) {
const char *dp = evt->findParam("DEVPATH");
PathCollection::iterator it;
for (it = mPaths->begin(); it != mPaths->end(); ++it) {
size_t len = strlen(*it);
if (!strncmp(dp, *it, len) && (dp[len] == '\0' || dp[len] == '/')) {
/* We can handle this disk */
int action = evt->getAction();
const char *devtype = evt->findParam("DEVTYPE");
/**********************************************************************************
**NetlinkEvent提供4个uevent状态，代码：
**const int NetlinkEvent::NlActionUnknown = 0;
const int NetlinkEvent::NlActionAdd = 1; //增加硬盘或分区的事件
const int NetlinkEvent::NlActionRemove = 2;//移除硬盘或分区的事件
const int NetlinkEvent::NlActionChange = 3;//改变硬盘或分区的事件
**这里的事件是增加存储设备
**********************************************************************************/
if (action == NetlinkEvent::NlActionAdd) {
/*从这里获取到主次设备号*/
int major = atoi(evt->findParam("MAJOR"));
int minor = atoi(evt->findParam("MINOR"));
char nodepath[255];
/**********************************************************************************
**之前有提到过，vold在/dev/block/vold创建了相应的设备节点，诸如8:0形式的节点，这里
**就是创建节点的位置，createDeviceNode函数。
**********************************************************************************/
snprintf(nodepath, sizeof(nodepath), "/dev/block/vold/%d:%d", 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) {
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;
}

该函数主要对存储设备或分区处理，每个存储设备或分区都有增加、删除和改变的事件，下一篇文章介绍
每个不同事件和函数的处理，有以下6个函数：

[cpp] view plain copy

void handleDiskAdded(const char *devpath, NetlinkEvent *evt);
void handleDiskRemoved(const char *devpath, NetlinkEvent *evt);
void handleDiskChanged(const char *devpath, NetlinkEvent *evt);
void handlePartitionAdded(const char *devpath, NetlinkEvent *evt);
void handlePartitionRemoved(const char *devpath, NetlinkEvent *evt);
void handlePartitionChanged(const char *devpath, NetlinkEvent *evt);

下一篇文章继续。。。

Android-vold源码分析之handleBlockEvent(5)

上篇文章分析到了handleBlockEvent函数，该函数包含了以下6个处理函数：

[cpp] view plain copy

void handleDiskAdded(const char *devpath, NetlinkEvent *evt);
void handleDiskRemoved(const char *devpath, NetlinkEvent *evt);
void handleDiskChanged(const char *devpath, NetlinkEvent *evt);
void handlePartitionAdded(const char *devpath, NetlinkEvent *evt);
void handlePartitionRemoved(const char *devpath, NetlinkEvent *evt);
void handlePartitionChanged(const char *devpath, NetlinkEvent *evt);

以下是精简版的handleBlockEvent函数：

[cpp] view plain copy

if (action == NetlinkEvent::NlActionAdd) {
...
if (!strcmp(devtype, "disk")) {
handleDiskAdded(dp, evt);
} else {
handlePartitionAdded(dp, evt);
}
}
else if (action == NetlinkEvent::NlActionRemove) {
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);
}
}

这样看起来就比较清楚每个函数的作用了，贴源码其实是比较直接的方法，程序员对代码都比较敏感，一看就明白意思，好，开始分析。

[cpp] view plain copy

void DirectVolume::handleDiskAdded(const char *devpath, NetlinkEvent *evt) {
mDiskMajor = atoi(evt->findParam("MAJOR"));
mDiskMinor = atoi(evt->findParam("MINOR"));
const char *tmp = evt->findParam("NPARTS");
if (tmp) {
mDiskNumParts = atoi(tmp);
} else {
SLOGW("Kernel block uevent missing 'NPARTS'");
mDiskNumParts = 0;
}
/**********************************************************************************
**mPendingPartsCount是一个全局变量，用来保存该存储设备的分区数量；这里需要说明一个
**存储设备识别的顺序：
**当插入一块5个分区的硬盘，首先会调用handleDiskAdded函数获取该存储设备的事件信息，
**随后会调用若干次handlePartitionAdded函数来识别该存储设备的多个分区的事件信息，
**当然，一般5个分区的硬盘肯定有一个扩展节点(因为mbr最多支持4个主分区)；
**调用顺序是这样：
**handleDiskAdded函数调用1次；
**handlePartitionAdded函数调用6次；
**该变量的作用是这样：插入一块硬盘，此时mPendingPartsCount变量为分区数量，
**开始用handlePartitionAdded函数识别分区，每识别一个分区，
**mPendingPartsCount自减一次，当mPendingPartsCount==0时，结束该存储设备事件的捕获。
**********************************************************************************/
mPendingPartsCount = mDiskNumParts;
if (mDiskNumParts == 0) {
/**********************************************************************************
**broadcastDiskAdded函数的作用是通知framework，系统插入一块存储设备，源码如下：
void DirectVolume::broadcastDiskAdded()
{
setState(Volume::State_Idle);
char msg[255];
snprintf(msg, sizeof(msg), "Volume %s %s disk inserted (%d:%d)",
getLabel(), getMountpoint(), mDiskMajor, mDiskMinor);
mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskInserted, msg, false);
}
**********************************************************************************/
broadcastDiskAdded();
} else {
/**********************************************************************************
**setState函数起到的作用很大，相当于一只信鸽，每次sd卡发现状态改变，该函数马上就将
**最新的状态广播给framework，后面会详细介绍该函数与framework的通信。
**********************************************************************************/
setState(Volume::State_Pending);
}
}

随后就是handlePartitionAdded函数了，这个函数要识别插入的设备的所有分区，源码如下：

[cpp] view plain copy

void DirectVolume::handlePartitionAdded(const char *devpath, NetlinkEvent *evt) {
int major = atoi(evt->findParam("MAJOR"));
int minor = atoi(evt->findParam("MINOR"));
int part_num;
const char *tmp = evt->findParam("PARTN");
if (tmp) {
part_num = atoi(tmp);
} else {
SLOGW("Kernel block uevent missing 'PARTN'");
part_num = 1;
}
if (part_num > mDiskNumParts) {
mDiskNumParts = part_num;
}
if (major != mDiskMajor) {
SLOGE("Partition '%s' has a different major than its disk!", devpath);
return;
}
/**********************************************************************************
**上面就是做一下其他的判断，不重要；
**MAX_PARTITIONS定义在system/vold/DirectVolume.h文件中，声明如下：
static const int MAX_PARTITIONS = 4;
Android系统支持太有限，谷歌太懒，呵呵，最多就识别4个分区，当然如果有些厂商想多实现
**分区的识别数量，需要修改源码；
**我觉得，Android系统是做得不错，但磁盘管理方面不太完善，自从分析修改了vold源码，
**vold支持得太少，也许谷歌以前只想到应用于手机，要是哥想识别一块10个分区的硬盘，
**咋办？修改源码咯。。。
**********************************************************************************/
if (part_num > MAX_PARTITIONS) {
SLOGE("Dv:partAdd: ignoring part_num = %d (max: %d)\n", part_num, MAX_PARTITIONS);
} else {
/*全局数组，用来存放磁盘分区的此设备号*/
mPartMinors[part_num -1] = minor;
}
/*看到了吧，上面那个函数说到mPendingPartsCount每识别一个分区要自减一次，就在这里*/
--mPendingPartsCount;
/*这里就在判断mPendingPartsCount变量了，如果mPendingPartsCount==0时，再向framework广播
一次该设备的插入，所以framework总共需要收到磁盘的插入广播2次，才会下发操作命令。*/
if (!mPendingPartsCount) {
/*判断了磁盘的状态，如果正在格式化，将不做操作*/
if (getState() != Volume::State_Formatting) {
broadcastDiskAdded();
}
} else {
}
}

磁盘在被系统识别完后，可能发生改变，这种改变的例子如下：
在Linux系统，大家格式化硬盘就会使用到了，就是fdisk命令，该命令会修改磁盘的一些分区参数，
当然，fdisk只是把分区信息写到存储设备的第一个设备节点或扩展节点。
fdisk里面有一个操作是修改分区类型id，按“t”就能修改，当修改完成后，保存退出fdisk，磁盘的设备节点
将会重新生成。
这里是Android系统，也可能遇到这种情况，以下是源码：

[cpp] view plain copy

void DirectVolume::handleDiskChanged(const char *devpath, NetlinkEvent *evt) {
int major = atoi(evt->findParam("MAJOR"));
int minor = atoi(evt->findParam("MINOR"));
if ((major != mDiskMajor) || (minor != mDiskMinor)) {
return;
}
SLOGI("Volume %s disk has changed", getLabel());
const char *tmp = evt->findParam("NPARTS");
if (tmp) {
mDiskNumParts = atoi(tmp);
} else {
SLOGW("Kernel block uevent missing 'NPARTS'");
mDiskNumParts = 0;
}
mPendingPartsCount = mDiskNumParts;
if (getState() != Volume::State_Formatting) {
if (mDiskNumParts == 0) {
/*这里类似于fdisk将删除存储设备的所有分区，这样存储设备的分区数量mDiskNumParts
就等于0，此时广播磁盘的空闲状态*/
setState(Volume::State_Idle);
} else {
setState(Volume::State_Pending);
}
}
}

分区的改变：

[cpp] view plain copy

void DirectVolume::handlePartitionChanged(const char *devpath, NetlinkEvent *evt) {
int major = atoi(evt->findParam("MAJOR"));
int minor = atoi(evt->findParam("MINOR"));
SLOGD("Volume %s %s partition %d:%d changed\n", getLabel(), getMountpoint(), major, minor);
}

以上两个参数基本没涉及到什么重要的内容，看下源码就行。
刚才上面分析了handleDiskAdded和handlePartitionAdded，这两个增加磁盘或分区的函数，当然也需要
对应移除磁盘或分区的函数，是handleDiskRemoved和handlePartitionRemoved函数。

[cpp] view plain copy

void DirectVolume::handleDiskRemoved(const char *devpath, NetlinkEvent *evt) {
int major = atoi(evt->findParam("MAJOR"));
int minor = atoi(evt->findParam("MINOR"));
char msg[255];
SLOGD("Volume %s %s disk %d:%d removed\n", getLabel(), getMountpoint(), major, minor);
snprintf(msg, sizeof(msg), "Volume %s %s disk removed (%d:%d)",
getLabel(), getMountpoint(), major, minor);
mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskRemoved, msg, false);
/*设备移除后，广播通知framework*/
setState(Volume::State_NoMedia);
}

移除一块存储设备比较方便，当移除分区涉及的比较多，移除分区需要卸载分区，并且删除设备节点，以下是删除分区的源码：

[cpp] view plain copy

void DirectVolume::handlePartitionRemoved(const char *devpath, NetlinkEvent *evt) {
int major = atoi(evt->findParam("MAJOR"));
int minor = atoi(evt->findParam("MINOR"));
char msg[255];
int state;
SLOGD("Volume %s %s partition %d:%d removed\n", getLabel(), getMountpoint(), major, minor);
state = getState();
if (state != Volume::State_Mounted && state != Volume::State_Shared) {
return;
}
if ((dev_t) MKDEV(major, minor) == mCurrentlyMountedKdev) {
snprintf(msg, sizeof(msg), "Volume %s %s bad removal (%d:%d)",
getLabel(), getMountpoint(), major, minor);
/*mCurrentlyMountedKdev变量保存着目前正挂载在系统的存储设备的设备号，
这里的判断是这样：如果目前正在移除的分区等于挂载的存储设备的设备号，说明
该存储设备没有被安全删除，也就是没有先卸载后移除*/
mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeBadRemoval, msg, false);
/*卸载挂载在asec目录的分区*/
if (mVm->cleanupAsec(this, true)) {
SLOGE("Failed to cleanup ASEC - unmount will probably fail!");
}
/*卸载该分区挂载的所有挂载点，这里为什么用所有来形容了，因为Android
系统挂载一个分区的期间，重复挂载在好几个目录，将分区挂载在/mnt/asec目录，也挂载
在/mnt/secure/asec目录,也挂载在/mnt/sdcard目录下，总共三次挂载，谷歌不知为什么搞这么复杂？
待深究。。*/
if (Volume::unmountVol(true)) {
SLOGE("Failed to unmount volume on bad removal (%s)",
strerror(errno));
} else {
SLOGD("Crisis averted");
}
} else if (state == Volume::State_Shared) {
snprintf(msg, sizeof(msg), "Volume %s bad removal (%d:%d)",
getLabel(), major, minor);
mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeBadRemoval, msg, false);
/*这种情况是这样：如果手机跟电脑连接在一起，电脑正在使用sd卡，你把sd卡取出，
就会广播该错误信息给framework*/
if (mVm->unshareVolume(getLabel(), "ums")) {
SLOGE("Failed to unshare volume on bad removal (%s)",
strerror(errno));
} else {
SLOGD("Crisis averted");
}
}
}

这几章介绍了磁盘事件的处理，总算可以告一段落，这些工作就是在main函数中的nm->start()函数负责的，下一篇文章可以分析其他处理函数了，但这些事件的处理起着至关重要的作用，如果没有做这些工作，framework也就根本不理会也不知道底层发生了什么事情。
下一篇继续磁盘操作部分。。

Android-vold源码分析之startListener(6)

vold处理完磁盘事件，就要开始接受framework的操作命令，在main函数里面，开启了一个线程来监听framework的信息，当收到操作命令，vold进行解析，分析出命令，然后调用相应的磁盘操作函数，待操作完成后，再将操作结果的状态值反馈给framework，中间均使用了广播机制，使用了UDP协议。

在main函数中，有以下函数的调用：

[cpp] view plain copy

if (cl->startListener()) {
SLOGE("Unable to start CommandListener (%s)", strerror(errno));
exit(1);
}

cl是CommandListener类实例化的一个对象，该对象专门负责与framework的通信，首先说明与CommandListener类相关的一些继承关系。
CommandListener --> FrameworkListener --> SocketListener(父类)
在CommandListener类中，声明了6个类，这6个类继承了VoldCommand类，VoldCommand类继承了FrameworkCommand，关系如下：
VoldCommand --> FrameworkCommand(父类)
以下是CommandListener类的声明：

[cpp] view plain copy

class CommandListener : public FrameworkListener {
public:
CommandListener();
virtual ~CommandListener() {}
private:
static void dumpArgs(int argc, char **argv, int argObscure);
class DumpCmd : public VoldCommand {
public:
DumpCmd();
virtual ~DumpCmd() {}
int runCommand(SocketClient *c, int argc, char ** argv);
};
class VolumeCmd : public VoldCommand {
public:
VolumeCmd();
virtual ~VolumeCmd() {}
int runCommand(SocketClient *c, int argc, char ** argv);
};
class ShareCmd : public VoldCommand {
public:
ShareCmd();
virtual ~ShareCmd() {}
int runCommand(SocketClient *c, int argc, char ** argv);
};
class AsecCmd : public VoldCommand {
public:
AsecCmd();
virtual ~AsecCmd() {}
int runCommand(SocketClient *c, int argc, char ** argv);
};
class StorageCmd : public VoldCommand {
public:
StorageCmd();
virtual ~StorageCmd() {}
int runCommand(SocketClient *c, int argc, char ** argv);
};
class XwarpCmd : public VoldCommand {
public:
XwarpCmd();
virtual ~XwarpCmd() {}
int runCommand(SocketClient *c, int argc, char ** argv);
};
};

在这个类中，VoldCommand主要写了一个纯虚函数runCommand，声明如下：
virtual int runCommand(SocketClient *c, int argc, char **argv) = 0;
为了就是在CommandListener类中的实现，这里总共实现了6个版本的runCommand函数，下一篇文章只讨论其中一个比较重要的VolumeCmd类的实现，其余的跟这个类的实现差不多。
开始深入startListener线程：
进入startListener函数，创建了以下线程：

[cpp] view plain copy

if (pthread_create(&mThread, NULL, SocketListener::threadStart, this)) {
SLOGE("pthread_create (%s)", strerror(errno));
return -1;
}

这里跟前几章线程的创建几乎一样，

[cpp] view plain copy

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

线程真正实现的函数在这里：

[cpp] view plain copy

void SocketListener::runListener() {
while(1) {
SocketClientCollection::iterator it;
fd_set read_fds;
int rc = 0;
int max = 0;
FD_ZERO(&read_fds);
if (mListen) {
max = mSock;
FD_SET(mSock, &read_fds);
}
FD_SET(mCtrlPipe[0], &read_fds);
if (mCtrlPipe[0] > max)
max = mCtrlPipe[0];
pthread_mutex_lock(&mClientsLock);
for (it = mClients->begin(); it != mClients->end(); ++it) {
FD_SET((*it)->getSocket(), &read_fds);
if ((*it)->getSocket() > max)
max = (*it)->getSocket();
}
pthread_mutex_unlock(&mClientsLock);
if ((rc = select(max + 1, &read_fds, NULL, NULL, NULL)) < 0) {
SLOGE("select failed (%s)", strerror(errno));
sleep(1);
continue;
} else if (!rc)
continue;
if (FD_ISSET(mCtrlPipe[0], &read_fds))
break;
if (mListen && FD_ISSET(mSock, &read_fds)) {
struct sockaddr addr;
socklen_t alen = sizeof(addr);
int c;
if ((c = accept(mSock, &addr, &alen)) < 0) {
SLOGE("accept failed (%s)", strerror(errno));
sleep(1);
continue;
}
pthread_mutex_lock(&mClientsLock);
mClients->push_back(new SocketClient(c));
pthread_mutex_unlock(&mClientsLock);
}
do {
pthread_mutex_lock(&mClientsLock);
for (it = mClients->begin(); it != mClients->end(); ++it) {
int fd = (*it)->getSocket();
if (FD_ISSET(fd, &read_fds)) {
pthread_mutex_unlock(&mClientsLock);
/*当收到framework的操作命令，执行该函数*/
if (!onDataAvailable(*it)) {
close(fd);
pthread_mutex_lock(&mClientsLock);
delete *it;
it = mClients->erase(it);
pthread_mutex_unlock(&mClientsLock);
}
FD_CLR(fd, &read_fds);
continue;
}
}
pthread_mutex_unlock(&mClientsLock);
} while (0);
}
}

将收到的命令交给onDataAvailable函数来处理，onDataAvailable函数是类的纯虚函数，在FrameworkListener类实现了该函数：

[cpp] view plain copy

bool FrameworkListener::onDataAvailable(SocketClient *c) {
char buffer[255];
int len;
if ((len = read(c->getSocket(), buffer, sizeof(buffer) -1)) < 0) {
SLOGE("read() failed (%s)", strerror(errno));
return errno;
} else if (!len)
return false;
int offset = 0;
int i;
for (i = 0; i < len; i++) {
if (buffer[i] == '\0') {
/*命令的处理函数*/
dispatchCommand(c, buffer + offset);
offset = i + 1;
}
}
return true;
}

dispatchCommand函数用来选择不同的分支函数，因为在类有6个分支的实现版本，包括DumpCmd，VolumeCmd，ShareCmd，AsecCmd，StorageCmd和XwarpCmd。以下是dispatchCommand函数的源码：

[cpp] view plain copy

void FrameworkListener::dispatchCommand(SocketClient *cli, char *data) {
FrameworkCommandCollection::iterator i;
int argc = 0;
/*static const int CMD_ARGS_MAX = 16;
说明framework发送的命令最多只能容纳16个子串*/
char *argv[FrameworkListener::CMD_ARGS_MAX];
/*中间省略了字符串的处理部分,将每个子串保存到了argv数组中，
所以在out标记的位置，对argv[i]的数组进行释放，
因为使用了strdup函数复制字符串*/
/*下面这个循环用来循环选择不同的分支实现函数，
mCommands容器保存着6个新声明的类对象*/
for (i = mCommands->begin(); i != mCommands->end(); ++i) {
FrameworkCommand *c = *i;
/*当第一个参数与FrameworkCommand类中的mCommand参数相等时，
才去调用该对象新实现的runCommand函数*/
if (!strcmp(argv[0], c->getCommand())) {
if (c->runCommand(cli, argc, argv)) {
SLOGW("Handler '%s' error (%s)", c->getCommand(), strerror(errno));
}
goto out;
}
}
cli->sendMsg(500, "Command not recognized", false);
out:
int j;
for (j = 0; j < argc; j++)
free(argv[j]);
return;
}

这里从代码可能有点疑问，这个循环为什么可以选择不同的分支新实现的函数呢？
仔细看下代码会发现，在FrameworkListener中有一个注册函数，将新的派生类的名字注册到mCommands容器中，每个类的mCommand参数各代表一个派生类的名字。

[cpp] view plain copy

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

在CommandListener类的构造函数中，分别对6个分支的派生类进行了注册，每次注册都实例化了一个新的对象存放到mCommands容器中。

[cpp] view plain copy

CommandListener::CommandListener() :
FrameworkListener("vold") {
registerCmd(new DumpCmd());
registerCmd(new VolumeCmd());
registerCmd(new AsecCmd());
registerCmd(new ShareCmd());
registerCmd(new StorageCmd());
registerCmd(new XwarpCmd());
}

那这6个派生类的名称保存在FrameworkCommand类的一个私有变量mCommand中，该类的构造函数就是给mCommand赋值，源码：

[cpp] view plain copy

FrameworkCommand::FrameworkCommand(const char *cmd) {
mCommand = cmd;
}

在刚才的FrameworkListener::dispatchCommand函数里，有这么一个比较：

[cpp] view plain copy

if (!strcmp(argv[0], c->getCommand())){}

getCommand函数的源码：

[cpp] view plain copy

const char *getCommand() { return mCommand; }

这里来看mCommand的赋值，我们知道以下关系：
DumpCmd --> VoldCommand --> FrameworkCommand
VolumeCmd --> VoldCommand --> FrameworkCommand
ShareCmd --> VoldCommand --> FrameworkCommand
AsecCmd --> VoldCommand --> FrameworkCommand
StorageCmd --> VoldCommand --> FrameworkCommand
XwarpCmd --> VoldCommand --> FrameworkCommand
所以在CommandListener类中的6个派生类中的构造函数中，必须初始化const char *cmd这个参数，以下是初始化代码：

[cpp] view plain copy

CommandListener::DumpCmd::DumpCmd() :
VoldCommand("dump") {
}
CommandListener::VolumeCmd::VolumeCmd() :
VoldCommand("volume") {
}
CommandListener::ShareCmd::ShareCmd() :
VoldCommand("share") {
}
CommandListener::StorageCmd::StorageCmd() :
VoldCommand("storage") {
}
CommandListener::AsecCmd::AsecCmd() :
VoldCommand("asec") {
}
CommandListener::XwarpCmd::XwarpCmd() :
VoldCommand("xwarp") {
}

6个构造函数均初始化不同的cmd参数，分别为dump,volume,share,storage,asec,xwarp。
在VoldCommand类的构造函数中，将cmd的值初始化FrameworkCommand类的构造函数。

[cpp] view plain copy

VoldCommand::VoldCommand(const char *cmd) :
FrameworkCommand(cmd) {
}

所以这个比较，就是将framework发下来的命令的第一个参数与mCommands容器中的6个对象的mCommand参数进行了比较，从而选择正确的处理分支函数。

以上的内容涉及到好几个类，谷歌真是花了很大的力气啊。。

现在流程就走到了runCommand函数，该函数就声明在最上面那个CommandListener类里面，下一篇文章将介绍runCommand函数的实现。

Android-vold源码分析之runCommand(7)

说了这么多，该到执行命令的函数了，要不黄花菜都凉了。上一篇文章讲了vold如何开启接收framework下发命令的线程，最终到了runCommand函数的实现，总共有6个版本，由于重复性大，只讲VolumeCmd类的runCommand函数的实现。
VolumeCmd可以说是最重要的，该类的实现处理了list,debug,mount,unmount,format,unshare,shared等等操作，详细说明：
list: 在启动vold之后，接收的第一条命令就是list，这里是获取系统的所有磁盘对象，一般只有sd卡。
debug: 设置USB的调试模式
mount: 挂载磁盘
unmount: 卸载磁盘
format: 格式化磁盘
unshare: 关闭USB的大容量存储模式，相当于断开手机与电脑的连接
shared: 开启USB的大容量存储模式，相当于手机与电脑连接，并挂载在电脑

下面把该函数的源码贴出来，一目了然，程序员，代码说话：

[cpp] view plain copy

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"))) {
cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: volume unmount <path> [force]", false);
return 0;
}
bool force = false;
if (argc >= 4 && !strcmp(argv[3], "force")) {
force = true;
}
rc = vm->unmountVolume(argv[2], force);
} 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;
}

每次操作完成后，都要将操作结果汇报给framework，阶级负责工作，一定要把工作结果汇报给领导，这里使用了sendMsg函数。
1.搜索需要挂载的磁盘对象信息列表。先从listVolumes函数开始，贴源码：

[cpp] view plain copy

int VolumeManager::listVolumes(SocketClient *cli) {
VolumeCollection::iterator i;
for (i = mVolumes->begin(); i != mVolumes->end(); ++i) {
char *buffer;
asprintf(&buffer, "%s %s %d",
(*i)->getLabel(), (*i)->getMountpoint(),
(*i)->getState());
cli->sendMsg(ResponseCode::VolumeListResult, buffer, false);
free(buffer);
}
cli->sendMsg(ResponseCode::CommandOkay, "Volumes listed.", false);
return 0;
}

这函数扫描了mVolumes容器，里面保存着从配置文件/etc/vold.fstab解析出来的磁盘。
该容器是在main函数中添加的：vm->addVolume(dv);
这函数先将每个磁盘的标签，挂载点，状态汇报给framework，然后再循环工作结束后，再次向领导汇报工作结束。
2.设置调试模式。贴源码：

[cpp] view plain copy

void VolumeManager::setDebug(bool enable) {
mDebug = enable;
VolumeCollection::iterator it;
for (it = mVolumes->begin(); it != mVolumes->end(); ++it) {
(*it)->setDebug(enable);
}
}

每个Volume对象都有一个setDebug函数设置调试状态：

[cpp] view plain copy

void Volume::setDebug(bool enable) {
mDebug = enable;
}

挂载磁盘涉及到很多内容和源码，将在下一篇文章继续说明，待续。。。

Android-vold源码分析之挂载SD卡(8)

这里续上一篇文章，讲解挂载磁盘的操作：

3.挂载磁盘。这里都有一个const char *类型的参数，这参数保存着每个磁盘的标签信息，比如sd卡的label是sdcard。

[cpp] view plain copy

int VolumeManager::mountVolume(const char *label) {
Volume *v = lookupVolume(label);
if (!v) {
errno = ENOENT;
return -1;
}
return v->mountVol();
}

lookupVolume函数寻找与label匹配的对象：

[cpp] view plain copy

Volume *VolumeManager::lookupVolume(const char *label) {
VolumeCollection::iterator i;
for (i = mVolumes->begin(); i != mVolumes->end(); ++i) {
if (label[0] == '/') {
if (!strcmp(label, (*i)->getMountpoint()))
return (*i);
} else {
if (!strcmp(label, (*i)->getLabel()))
return (*i);
}
}
return NULL;
}

如果找到，直接返回磁盘对象Volume*，挂载操作在mountVol函数里面，该函数内容有点多，贴源码:

[cpp] view plain copy

int Volume::mountVol() {
dev_t deviceNodes[4];
int n, i, rc = 0;
char errmsg[255];
if (getState() == Volume::State_NoMedia) {
snprintf(errmsg, sizeof(errmsg),
"Volume %s %s mount failed - no media",
getLabel(), getMountpoint());
mVm->getBroadcaster()->sendBroadcast(
ResponseCode::VolumeMountFailedNoMedia,
errmsg, false);
errno = ENODEV;
return -1;
} else if (getState() != Volume::State_Idle) {
errno = EBUSY;
return -1;
}
/*判断该挂载点是否已经挂载，若已经挂载，则直接返回。*/
if (isMountpointMounted(getMountpoint())) {
SLOGW("Volume is idle but appears to be mounted - fixing");
/*这里的setState函数用得很频繁，这函数就是将状态通知给framework*/
setState(Volume::State_Mounted);
// mCurrentlyMountedKdev = XXX
return 0;
}
/*获取磁盘的设备号与分区数量,在下面说明*/
n = getDeviceNodes((dev_t *) &deviceNodes, 4);
if (!n) {
SLOGE("Failed to get device nodes (%s)\n", strerror(errno));
return -1;
}
/*将循环挂载n个分区，但从代码上看，只适用于挂载一个分区*/
for (i = 0; i < n; i++) {
char devicePath[255];
/*这里看到了吧，用这种方式来使用磁盘的设备节点很方便，直接用主次设备号来命令*/
sprintf(devicePath, "/dev/block/vold/%d:%d", MAJOR(deviceNodes[i]),
MINOR(deviceNodes[i]));
SLOGI("%s being considered for volume %s\n", devicePath, getLabel());
errno = 0;
setState(Volume::State_Checking);
/*挂载之前先检测一下该分区是否是fat分区，如果不是fat格式，返回-1*/
if (Fat::check(devicePath)) {
if (errno == ENODATA) {
SLOGW("%s does not contain a FAT filesystem\n", devicePath);
continue;
}
errno = EIO;
/* Badness - abort the mount */
SLOGE("%s failed FS checks (%s)", devicePath, strerror(errno));
setState(Volume::State_Idle);
return -1;
}
/*
* Mount the device on our internal staging mountpoint so we can
* muck with it before exposing it to non priviledged users.
*/
errno = 0;
/*将设备节点挂载在/mnt/secure/staging目录*/
if (Fat::doMount(devicePath, "/mnt/secure/staging", false, false, 1000, 1015, 0702, true)) {
SLOGE("%s failed to mount via VFAT (%s)\n", devicePath, strerror(errno));
continue;
}
SLOGI("Device %s, target %s mounted @ /mnt/secure/staging", devicePath, getMountpoint());
protectFromAutorunStupidity();
/*挂载一个只有root用户能够访问的目录，这函数挂载了两次
将/mnt/secure/staging/.android_secure 挂载在 /mnt/secure/asec，
将tmpfs 挂载在 /mnt/secure/staging/.android_secure*/
if (createBindMounts()) {
SLOGE("Failed to create bindmounts (%s)", strerror(errno));
umount("/mnt/secure/staging");
setState(Volume::State_Idle);
return -1;
}
/*
* Now that the bindmount trickery is done, atomically move the
* whole subtree to expose it to non priviledged users.
*/
/*将挂载点挂载的目录再挂载到最终的目录/mnt/sdcard*/
if (doMoveMount("/mnt/secure/staging", getMountpoint(), false)) {
SLOGE("Failed to move mount (%s)", strerror(errno));
umount("/mnt/secure/staging");
setState(Volume::State_Idle);
return -1;
}
setState(Volume::State_Mounted);
mLastMountedKdev = mCurrentlyMountedKdev = deviceNodes[i];
return 0;
}
SLOGE("Volume %s found no suitable devices for mounting :(\n", getLabel());
setState(Volume::State_Idle);
return -1;
}

这个挂载函数看起来，会发现很繁琐，好几个目录的挂载关系，有以下挂载目录：
/dev/block/vold/8:1 挂载在-> /mnt/secure/staging
/mnt/secure/staging/.android_secure 挂载在-> /mnt/secure/asec
tmpfs 挂载在-> /mnt/secure/staging/.android_secure
/mnt/secure/staging 挂载在-> /mnt/sdcard
从程序的注释看，这样的目的是挂载一个只有root用户能查看的目录，具体还是没搞清楚谷歌为什么要这样挂载，
还是有疑问，希望有清楚的高手指点一下。
sd卡的挂载比较清楚，中间多了一个中介，将设备节点8:1挂载在/mnt/secure/staging,最后又将该目录挂载在/mnt/sdcard，
这目录就是最终用户能够看到文件的目录。
函数里面涉及到几个函数：
getDeviceNodes函数获取挂载设备的设备号与分区数量，是Volume类的一个纯虚函数，在子类DirectVolume中实现，源码：

[cpp] view plain copy

int DirectVolume::getDeviceNodes(dev_t *devs, int max) {
if (mPartIdx == -1) {
// If the disk has no partitions, try the disk itself
if (!mDiskNumParts) {
devs[0] = MKDEV(mDiskMajor, mDiskMinor);
return 1;
}
int i;
for (i = 0; i < mDiskNumParts; i++) {
if (i == max)
break;
devs[i] = MKDEV(mDiskMajor, mPartMinors[i]);
}
return mDiskNumParts;
}
devs[0] = MKDEV(mDiskMajor, mPartMinors[mPartIdx -1]);
return 1;
}

下面贴一些mountVol里面挂载的源码：

[cpp] view plain copy

int Fat::doMount(const char *fsPath, const char *mountPoint,
bool ro, bool remount, int ownerUid, int ownerGid,
int permMask, bool createLost) {
int rc;
unsigned long flags;
char mountData[255];
flags = MS_NODEV | MS_NOEXEC | MS_NOSUID | MS_DIRSYNC;
flags |= (ro ? MS_RDONLY : 0);
flags |= (remount ? MS_REMOUNT : 0);
/*
* 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') {
SLOGW("The SD card is world-writable because the"
" 'persist.sampling_profiler' system property is set to '1'.");
permMask = 0;
}
sprintf(mountData,
"utf8,uid=%d,gid=%d,fmask=%o,dmask=%o,shortname=mixed",
ownerUid, ownerGid, permMask, permMask);
rc = mount(fsPath, mountPoint, "vfat", flags, mountData);
if (rc && errno == EROFS) {
SLOGE("%s appears to be a read only filesystem - retrying mount RO", fsPath);
flags |= MS_RDONLY;
rc = mount(fsPath, mountPoint, "vfat", flags, mountData);
}
if (rc == 0 && createLost) {
char *lost_path;
asprintf(&lost_path, "%s/LOST.DIR", mountPoint);
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)) {
SLOGE("Unable to create LOST.DIR (%s)", strerror(errno));
}
}
free(lost_path);
}
return rc;
}
int Volume::createBindMounts() {
unsigned long flags;
/*
* Rename old /android_secure -> /.android_secure
*/
if (!access("/mnt/secure/staging/android_secure", R_OK | X_OK) &&
access(SEC_STG_SECIMGDIR, R_OK | X_OK)) {
if (rename("/mnt/secure/staging/android_secure", SEC_STG_SECIMGDIR)) {
SLOGE("Failed to rename legacy asec dir (%s)", strerror(errno));
}
}
/*
* Ensure that /android_secure exists and is a directory
*/
if (access(SEC_STG_SECIMGDIR, R_OK | X_OK)) {
if (errno == ENOENT) {
if (mkdir(SEC_STG_SECIMGDIR, 0777)) {
SLOGE("Failed to create %s (%s)", SEC_STG_SECIMGDIR, strerror(errno));
return -1;
}
} else {
SLOGE("Failed to access %s (%s)", SEC_STG_SECIMGDIR, strerror(errno));
return -1;
}
} else {
struct stat sbuf;
if (stat(SEC_STG_SECIMGDIR, &sbuf)) {
SLOGE("Failed to stat %s (%s)", SEC_STG_SECIMGDIR, strerror(errno));
return -1;
}
if (!S_ISDIR(sbuf.st_mode)) {
SLOGE("%s is not a directory", SEC_STG_SECIMGDIR);
errno = ENOTDIR;
return -1;
}
}
/*
* Bind mount /mnt/secure/staging/android_secure -> /mnt/secure/asec so we'll
* have a root only accessable mountpoint for it.
*/
if (mount(SEC_STG_SECIMGDIR, SEC_ASECDIR, "", MS_BIND, NULL)) {
SLOGE("Failed to bind mount points %s -> %s (%s)",
SEC_STG_SECIMGDIR, SEC_ASECDIR, strerror(errno));
return -1;
}
/*
* Mount a read-only, zero-sized tmpfs on <mountpoint>/android_secure to
* obscure the underlying directory from everybody - sneaky eh? ;)
*/
if (mount("tmpfs", SEC_STG_SECIMGDIR, "tmpfs", MS_RDONLY, "size=0,mode=000,uid=0,gid=0")) {
SLOGE("Failed to obscure %s (%s)", SEC_STG_SECIMGDIR, strerror(errno));
umount("/mnt/asec_secure");
return -1;
}
return 0;
}
int Volume::doMoveMount(const char *src, const char *dst, bool force) {
unsigned int flags = MS_MOVE;
int retries = 5;
while(retries--) {
if (!mount(src, dst, "", flags, NULL)) {
if (mDebug) {
SLOGD("Moved mount %s -> %s sucessfully", src, dst);
}
return 0;
} else if (errno != EBUSY) {
SLOGE("Failed to move mount %s -> %s (%s)", src, dst, strerror(errno));
return -1;
}
int action = 0;
if (force) {
if (retries == 1) {
action = 2; // SIGKILL
} else if (retries == 2) {
action = 1; // SIGHUP
}
}
SLOGW("Failed to move %s -> %s (%s, retries %d, action %d)",
src, dst, strerror(errno), retries, action);
Process::killProcessesWithOpenFiles(src, action);
usleep(1000*250);
}
errno = EBUSY;
SLOGE("Giving up on move %s -> %s (%s)", src, dst, strerror(errno));
return -1;
}

篇幅有点长了，挂载点也挂载了好几个，mountVol处理的事情最多的，也最繁琐，但都是简单的，主要是有点摸不着头脑，
谷歌为啥要这样挂载，也许自己太菜了。。
下一篇文章继续。。

Android-vold源码分析之卸载SD卡(9)

本文分析卸载sd卡的源码，这些涉及的内容比较少，走过就行。在Android系统，系统设置里面，
提供了挂载，卸载与格式化的功能。在这里，我们可以回忆一下，Android在挂载sd卡有几个途径，
卸载又是有几种方法？
一、挂载sd卡，有2种方式：
1.用户自己挂载sd卡；
2.自动挂载sd卡，这时候是在Android系统启动完成后挂载的，所以可以看成是自动挂载；

二、卸载sd卡，有2种方式：
1.用户自己卸载sd卡；
2.用户移除sd卡；
卸载sd卡，1和2看起来有点矛盾，但这相当于平时我们在电脑使用U盘一样，
一种是先安全删除再移除U盘；
一种是不安全删除直接移除U盘；
所以在Android系统中，卸载sd卡有两个途径：
1.Framework下发卸载命令(volume unmount sdcard force)，卸载sd卡；
2.vold捕获到移除事件，如果是非安全删除sd卡，那么就卸载sd卡。

所以挂载与卸载sd卡的两种方法不同，挂载sd卡都是由Framework下发命令，而卸载sd卡则不同。

一、先来分析Framework下发卸载命令：

截取CommandListener类其中的源码：

[cpp] view plain copy

else if (!strcmp(argv[1], "unmount")) {
if (argc < 3 || argc > 4 || (argc == 4 && strcmp(argv[3], "force"))) {
cli->sendMsg(ResponseCode::CommandSyntaxError, "Usage: volume unmount <path> [force]", false);
return 0;
}
bool force = false;
if (argc >= 4 && !strcmp(argv[3], "force")) {
force = true;
}
rc = vm->unmountVolume(argv[2], force);
}

这条卸载命令的格式是：volume unmount sdcard true/false.
这里有一个强制卸载的标志，也就是force参数，如果命令包含“force”字符串，那么就强制
卸载sd卡，接下来看unmountVolume卸载函数：

[cpp] view plain copy

int VolumeManager::unmountVolume(const char *label, bool force) {
Volume *v = lookupVolume(label);
......
/*这函数清理了/mnt/asec目录的一些内容，其实看不见*/
cleanupAsec(v, force);
return v->unmountVol(force);
}

开始看卸载函数，以下函数均做简化，不再贴出大量源码，Android系统的源码实在太多：

[cpp] view plain copy

int Volume::unmountVol(bool force) {
/*广播sd卡正在卸载的状态*/
setState(Volume::State_Unmounting);
if (doMoveMount(getMountpoint(), SEC_STGDIR, force)) {
SLOGE("Failed to move mount %s => %s (%s)", getMountpoint(), SEC_STGDIR, strerror(errno));
setState(Volume::State_Mounted);
return -1;
}
if (doUnmount(Volume::SEC_STG_SECIMGDIR, force)) {
SLOGE("Failed to unmount tmpfs on %s (%s)", SEC_STG_SECIMGDIR, strerror(errno));
goto fail_republish;
}
if (doUnmount(Volume::SEC_ASECDIR, force)) {
SLOGE("Failed to remove bindmount on %s (%s)", SEC_ASECDIR, strerror(errno));
goto fail_remount_tmpfs;
}
if (doUnmount(Volume::SEC_STGDIR, force)) {
SLOGE("Failed to unmount %s (%s)", SEC_STGDIR, strerror(errno));
goto fail_recreate_bindmount;
}
/*以上doMoveMount, doUnmount等函数做些清理工作，就是之前挂载到系统的目录
清理干净*/
/*卸载工作做完，告诉framework，该磁盘处于空闲状态*/
setState(Volume::State_Idle);
/*用来保存正在挂载的设备号的全局变量，现在赋为-1*/
mCurrentlyMountedKdev = -1;
return 0;
}

二、vold捕获移除事件，调用卸载函数:

[cpp] view plain copy

void DirectVolume::handlePartitionRemoved(const char *devpath, NetlinkEvent *evt) {
int major = atoi(evt->findParam("MAJOR"));
int minor = atoi(evt->findParam("MINOR"));
char msg[255];
int state;
SLOGD("Volume %s %s partition %d:%d removed\n", getLabel(), getMountpoint(), major, minor);
/*
* The framework doesn't need to get notified of
* partition removal unless it's mounted. Otherwise
* the removal notification will be sent on the Disk
* itself
*/
state = getState();
if (state != Volume::State_Mounted && state != Volume::State_Shared) {
return;
}
/*判断，如果移除事件的设备号与正在挂载系统的设备号相等，
说明此时是没有安全删除，所以下面会广播VolumeBadRemoval反馈码*/
if ((dev_t) MKDEV(major, minor) == mCurrentlyMountedKdev) {
/*
* Yikes, our mounted partition is going away!
*/
snprintf(msg, sizeof(msg), "Volume %s %s bad removal (%d:%d)",
getLabel(), getMountpoint(), major, minor);
mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeBadRemoval,
msg, false);
/*清理asec目录*/
if (mVm->cleanupAsec(this, true)) {
SLOGE("Failed to cleanup ASEC - unmount will probably fail!");
}
/*在这里调用了卸载函数，跟framework下发命令卸载一样。*/
if (Volume::unmountVol(true)) {
SLOGE("Failed to unmount volume on bad removal (%s)",
strerror(errno));
// XXX: At this point we're screwed for now
} else {
SLOGD("Crisis averted");
}
} else if (state == Volume::State_Shared) {
/*这里的判断是，如果此时手机与电脑正在连接着使用时，移除事件的情况*/
/* removed during mass storage */
snprintf(msg, sizeof(msg), "Volume %s bad removal (%d:%d)",
getLabel(), major, minor);
mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeBadRemoval,
msg, false);
/*卸载大容量存储*/
if (mVm->unshareVolume(getLabel(), "ums")) {
SLOGE("Failed to unshare volume on bad removal (%s)",
strerror(errno));
} else {
SLOGD("Crisis averted");
}
}
}

卸载函数基本就这些，下一篇文章继续，格式化sd卡。。。

Android-vold源码分析之格式化SD卡(10)

本文开始讨论sd卡的格式化功能，平时使用windows操作系统，也经常格式化磁盘。涉及到的
操作有这几步：
1.将分区信息写到硬盘的第一个设备节点的MBR结构中的分区表；
2.格式化分区到指定的文件系统类型。

MBR中存放分区表的位置在446-509，占用了64字节，MBR结构只支持4个主分区，所以

有4个16字节的区域，先简要说明一下MBR的分区表的结构：

从这个表格可以看出，相对于446-509的分区表区域，每个主分区的第5个字节存放的是文件
系统标志位，用来识别什么分区，用fdisk工具查看一下，有如下文件系统对应的十六进制标志：

若需要读取这些文件系统标志，只需读取MBR的450个位置，占用一个字节大小。

扯得太远了，回到正题，本文是要分析Android格式化sd卡的功能，在格式化部分，涉及到
了系统的一些函数，与vold无关，简单的说明一下即可。
Android系统在格式化sd卡的时候，首先会判断sd卡是否存在分区，如果sd卡不存在分区，
那么需要重新初始化MBR区域，所以上面简要的介绍了MBR结构中分区表的区域。

[cpp] view plain copy

int Volume::formatVol() {
if (getState() == Volume::State_NoMedia) {
errno = ENODEV;
return -1;
} else if (getState() != Volume::State_Idle) {
errno = EBUSY;
return -1;
}
/*如果该分区为卸载，那么格式化失败，返回错误*/
if (isMountpointMounted(getMountpoint())) {
SLOGW("Volume is idle but appears to be mounted - fixing");
setState(Volume::State_Mounted);
// mCurrentlyMountedKdev = XXX
errno = EBUSY;
return -1;
}
char devicePath[255];
dev_t diskNode = getDiskDevice();
dev_t partNode;
if (mDebug) {
SLOGI("Formatting volume %s (%s)", getLabel(), devicePath);
}
setState(Volume::State_Formatting);
if (!mLastMountedKdev) {
dev_t deviceNodes[2];
int n = getDeviceNodes(deviceNodes, 2);
// initialize MBR if no partition, or has multiple partitions
// but none is selected
if ((diskNode == deviceNodes[0]) || (n > 1)) {
sprintf(devicePath, "/dev/block/vold/%d:%d",
MAJOR(diskNode), MINOR(diskNode));
if (initializeMbr(devicePath)) {
SLOGE("Failed to initialize MBR (%s)", strerror(errno));
partNode = diskNode; // try to use whole disk
} else {
partNode = MKDEV(MAJOR(diskNode), MINOR(diskNode) + 1);
}
} else {
partNode = deviceNodes[0];
}
} else {
partNode = mLastMountedKdev;
}
sprintf(devicePath, "/dev/block/vold/%d:%d",
MAJOR(partNode), MINOR(partNode));
int ret = Fat::format(devicePath, 0);
SLOGE_IF(ret, "Failed to format (%s)", strerror(errno));
setState(Volume::State_Idle);
return ret;
}

格式化函数两个主要工作交给了initializeMbr和Fat::format函数：
1.initializeMbr函数负责初始化MBR；
2.Fat::format函数负责格式化分区。
先来看initializeMbr函数的初始化工作：

[cpp] view plain copy

int Volume::initializeMbr(const char *deviceNode) {
struct disk_info dinfo;
memset(&dinfo, 0, sizeof(dinfo));
if (!(dinfo.part_lst = (struct part_info *) malloc(MAX_NUM_PARTS * sizeof(struct part_info)))) {
SLOGE("Failed to malloc prt_lst");
return -1;
}
memset(dinfo.part_lst, 0, MAX_NUM_PARTS * sizeof(struct part_info));
dinfo.device = strdup(deviceNode);
dinfo.scheme = PART_SCHEME_MBR;
dinfo.sect_size = 512;
dinfo.skip_lba = 2048;
dinfo.num_lba = 0;
dinfo.num_parts = 1;
struct part_info *pinfo = &dinfo.part_lst[0];
pinfo->name = strdup("android_sdcard");
pinfo->flags |= PART_ACTIVE_FLAG;
pinfo->type = PC_PART_TYPE_FAT32;
pinfo->len_kb = -1;
int rc = apply_disk_config(&dinfo, 0);
if (rc) {
SLOGE("Failed to apply disk configuration (%d)", rc);
goto out;
}
out:
free(pinfo->name);
free(dinfo.device);
free(dinfo.part_lst);
return rc;
}

这里贴出一些重要的结构体：

[cpp] view plain copy

struct part_info {
char *name;
uint8_t flags;
uint8_t type;
uint32_t len_kb; /* in 1K-bytes */
uint32_t start_lba; /* the LBA where this partition begins */
};
struct disk_info {
char *device;
uint8_t scheme;
int sect_size; /* expected sector size in bytes. MUST BE POWER OF 2 */
uint32_t skip_lba; /* in sectors (1 unit of LBA) */
uint32_t num_lba; /* the size of the disk in LBA units */
struct part_info *part_lst;
int num_parts;
};

初始化完成后，将该结构体变量pinfo通过apply_disk_config函数进行设置：

[cpp] view plain copy

int apply_disk_config(struct disk_info *dinfo, int test)
{
int fd;
struct write_list *wr_lst = NULL;
int rv;
if (validate_and_config(dinfo, &fd, &wr_lst) != 0) {
LOGE("Configuration is invalid.");
goto fail;
}
if ((rv = wlist_commit(fd, wr_lst, test)) >= 0)
rv = test ? 0 : sync_ptable(fd);
close(fd);
wlist_free(wr_lst);
return rv;
fail:
close(fd);
if (wr_lst)
wlist_free(wr_lst);
return 1;
}

该函数先打开sd卡的设备节点，然后将MBR的初始化信息写到第一个block(512B)中，
这里涉及到非常多函数，不在vold的讨论范围。
写完MBR后，就要对分区进行格式化，要格式化成FAT32格式，Fat::format函数直接调用
系统命令newfs_msdos来格式化新分区，检测磁盘是，Fat::check函数直接调用系统命令
fsck_msdos来检测分区。

最后格式化完成功，通知Framework，sd卡处于空闲状态：

[cpp] view plain copy

setState(Volume::State_Idle);

然后，Framework又要重复挂载和卸载的操作了。
下篇文章介绍Android系统与电脑的连接，OTG功能，全称on-the-go。
待续。。

Android-vold源码分析之连接电脑OTG(11)

OTG是on-the-go的简称，是2001年由USB Implementers Forum公布，主要应用于各种不同的设备或移动设备间的联接，进行数据交换。特别是PDA、移动电话、消费类设备。改变如数码照相机、摄像机、打印机等设备间多种不同制式连接器，多达7种制式的存储卡间数据交换的不便。
对OTG介绍比较详细的在USB的官网，详细请见英文文档： http://www.usb.org/developers/onthego/。以下是官网的一个简要的介绍，贴出来看看：
USB On-The-Go and Embedded Host

Virtually every portable device now uses USB for PC connectivity. As these products increase in popularity, there is a growing need for them to communicate both with USB peripherals and directly with each other when a PC is not available. There is also an increase in the number of other, non-PC hosts (Embedded Hosts) which support USB in order to connect to USB peripherals.

The USB On-The-Go and Embedded Host Supplements addresses these scenarios by allowing portable devices and non-PC hosts to have the following enhancements:

Targeted host capability to communicate with selected other USB peripherals
Support for direct connections between OTG devices
Power saving features to preserve battery life
Revision 2.0 of the USB On-The-Go and Embedded Host Supplement to the USB 2.0 Specification applies to products operating at low-speed, full-speed and high-speed and is released, including applicable ECNs and errata, as part of the USB 2.0 Specification package. The corresponding OTG Adopters Agreement is also available.

Revision 1.0 of the USB On-The-Go and Embedded Host Supplement to the USB 3.0 Specification enhances these scenarios by adding SuperSpeed capability to USB On-The-Go and is released as part of the USB 3.0 Specification package. The corresponding Adopters Agreement for USB OTG 3.0 is the USB 3.0 Adopters Agreement.
这里写得很清楚，OTG主要是实现可移动设备点对点的数据共享，不需要再依赖于PC机第三方的识别或者操作。平时经常从电脑下载MP3格式的音乐到phone or Pad，都是经过USB线来连接电脑，电脑可以识别到设备里面的存储设备，或者手机与手机的连接，这就是OTG功能。

这是一个在线浏览Linux内核源码的网站：http://lxr.linux.no/。

Linux内核早就提供了OTG的驱动，在http://lxr.linux.no/linux+v3.1.6/drivers/usb/gadget/目录下，Linux将usb与otg两个功能模块给独立开了，主要的驱动是file_storage.c，该驱动主要负责终端设备的存储设备节点的操作，比如，从电脑，在该终端的磁盘上面创建文件，都会通过这个驱动来完成存储任务。另外一个驱动主要是负责USB通信的，是结尾为"_udc.c"的驱动源码，该目录下有好几个以"_udc.c"结尾的文件，这是针对不同型号的处理器而增加的，不同厂家提供不同的驱动。

这里只是简单的介绍，Android在vold中处理otg，就是将要共享的磁盘设备写到一个标志文件里面，再广播一下大容量存储连接的状态。

一、连接电脑；先来看看源码:

[cpp] view plain copy

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]);
}

进入shareVolume函数中，该函数判断一下sd卡的状态，如果不存在设备，或者sd卡不是出于空闲状态，那么就返回失败。

[cpp] view plain copy

int VolumeManager::shareVolume(const char *label, const char *method) {
Volume *v = lookupVolume(label);
if (!v) {
errno = ENOENT;
return -1;
}
/*
* Eventually, we'll want to support additional share back-ends,
* some of which may work while the media is mounted. For now,
* we just support UMS
*/
if (strcmp(method, "ums")) {
errno = ENOSYS;
return -1;
}
if (v->getState() == Volume::State_NoMedia) {
errno = ENODEV;
return -1;
}
if (v->getState() != Volume::State_Idle) {
// You need to unmount manually befoe sharing
errno = EBUSY;
return -1;
}
/*getDiskDevice函数直接返回sd卡的设备号。*/
dev_t d = v->getDiskDevice();
if ((MAJOR(d) == 0) && (MINOR(d) == 0)) {
// This volume does not support raw disk access
errno = EINVAL;
return -1;
}
int fd;
char nodepath[255];
snprintf(nodepath,
sizeof(nodepath), "/dev/block/vold/%d:%d",
MAJOR(d), MINOR(d));
/*比较重要的在这里，想要实现让电脑识别到Android系统中的sd卡，
那么就必须将sd卡的设备节点路径写到以下文件中去，这样才能打开
大容量存储的功能，也就是OTG*/
if ((fd = open("/sys/devices/platform/usb_mass_storage/lun0/file",
O_WRONLY)) < 0) {
SLOGE("Unable to open ums lunfile (%s)", strerror(errno));
return -1;
}
if (write(fd, nodepath, strlen(nodepath)) < 0) {
SLOGE("Unable to write to ums lunfile (%s)", strerror(errno));
close(fd);
return -1;
}
close(fd);
/*handleVolumeShared函数在Volume中，是一个虚函数，在子类DirectVolume中
实现，也就是广播一些ums的状态。*/
v->handleVolumeShared();
return 0;
}

如果有Android手机的用户，可以看到系统中存在/sys/devices/platform/usb_mass_storage/lun0/file这么一个文件，Java层可能没有权限访问该文件。最近发现，Java想要访问系统的文件，或者操作命令都要赋以最高权限(0777)才能访问或执行，真是麻烦。

[cpp] view plain copy

void DirectVolume::handleVolumeShared() {
setState(Volume::State_Shared);
}

二、断开连接；

[cpp] view plain copy

int VolumeManager::unshareVolume(const char *label, const char *method) {
Volume *v = lookupVolume(label);
if (!v) {
errno = ENOENT;
return -1;
}
if (strcmp(method, "ums")) {
errno = ENOSYS;
return -1;
}
if (v->getState() != Volume::State_Shared) {
errno = EINVAL;
return -1;
}
int fd;
if ((fd = open("/sys/devices/platform/usb_mass_storage/lun0/file", O_WRONLY)) < 0) {
SLOGE("Unable to open ums lunfile (%s)", strerror(errno));
return -1;
}
char ch = 0;
/*如果要断开连接，可以在电脑安全删除，然后Android系统会提示用户点击挂载sd卡，因为
在电脑使用sd卡的情况下，手机是不能对sd卡操作的，多处操作磁盘，会造成数据同步错误。
就在断开电脑，进入手机使用模式时，将/sys/devices/platform/usb_mass_storage/lun0/file
写为空了*/
if (write(fd, &ch, 1) < 0) {
SLOGE("Unable to write to ums lunfile (%s)", strerror(errno));
close(fd);
return -1;
}
close(fd);
/*再广播otg断开状态*/
v->handleVolumeUnshared();
return 0;
}
void DirectVolume::handleVolumeUnshared() {
setState(Volume::State_Idle);
}

这里已经分析完在CommandListener::VolumeCmd::runCommand函数的实现的所有操作了，然后程序将命令的执行结果通知Framework，源码：

[cpp] view plain copy

if (!rc) {
cli->sendMsg(ResponseCode::CommandOkay, "volume operation succeeded", false);
} else {
int erno = errno;
rc = ResponseCode::convertFromErrno();
cli->sendMsg(rc, "volume operation failed", true);
}

磁盘操作的命令圆满结束，下一篇文章继续分析Framework与vold的通信。待续。

Android-Vold, Framework和UI的通信-大结局(12)

写了好几篇文章，花儿都快谢了，终于轮到Framework发挥领导的身份了，Framework作为界面与vold之间的桥梁，用户是Framework的大爷，那么Framework就是Vold的大哥大，Framework发出一个命令，Vold不敢不遵从，只能照着Framework的意思照办，千万不能出差错，不然Android就要丢大脸了，登不上三国争霸的舞台，iOS VS Android VS WP7？
在Framework里面，有一个目录是用来存放一些Java的系统服务，这些都在后台跑着，在：/android-2.2r2/frameworks/base/services/java/com/android/server目录下，比较重要的是这两个源文件：MountService.java和NativeDaemonConnector.java。
这里先列出在Vold中，VolumeCmd类处理的一些磁盘操作命令，这些命令均是有Framework下发的：
1.volume list：Framework先得到系统目前存在几个Volume对象，需要获取到这些对象的标签；
2.volume debug：设置USB调试模式
3.volume mount sdcard：挂载SD卡
4.volume unmount force：卸载SD卡
5.volume format sdcard：格式化SD卡
6.volume share sdcard ums：开启SD卡的OTG功能(大容量存储)，也就是连接电脑
7.volume unshare sdcard ums：关闭SD卡的OTG功能(大容量存储)
8.volume shared sdcard ums：获取目前OTG的开启状态，就是是否连接电脑的状态。
以下分别列出每个命令的下发函数，对Java不熟，但看得懂程序的流程，真是惭愧啊。

一、Framework磁盘管理服务的开启？

在NativeDaemonConnector服务里面，开始监听底层Vold发送过来的磁盘热插拔事件的状态信息，当收到底层广播上来的状态，调用MountService服务中的onDaemonConnected函数进行处理，当然这是开机第一次去获取信息的，也就是下发"volume list"命令。

[cpp] view plain copy

public void run() {
while (true) {
try {
/*开始监听底层广播信息*/
listenToSocket();
} catch (Exception e) {
Slog.e(TAG, "Error in NativeDaemonConnector", e);
SystemClock.sleep(5000);
}
}
}
private void listenToSocket() throws IOException {
/*函数太长，以下是执行顺序*/
//连接SOCKET
socket.connect(address);
->
/*调用该函数来处理下发"volume list"命令的反馈结果*/
mCallbacks.onDaemonConnected();
->
/*处理磁盘的状态*/
mCallbacks.onEvent(code, event, tokens);
}

以上两个比较重要的函数在MountService当中，处理相当多的内容，源码太长。
下发volume list命令，Framework收到反馈值，将调用onDaemonConnected函数获取到了磁盘的标签，挂载点与状态，然后调用doGetShareMethodAvailable函数判断现在是否连接OTG，若连接OTG，那么调用doShareUnshareVolume函数下发otg连接命令(volume share sdcard ums)。

二、Vold与Framework如何通信？
onEvent主要是处理状态信息的解析，将每一种状态进行判断，并调用相应的操作函数。比如此时vold发送一个VolumeDiskInserted状态，意味着系统插入一个磁盘，于是onEvent就调用doMountVolume挂载函数进行下发命令(volume mount sdcard)。
在系统使用当中，用户可能会插入，移除，挂载，卸载，格式化磁盘，那么这儿多状态如何告诉Framework呢？之前已经说过，vold使用了setState函数来广播磁盘的状态消息，使得Framework能够及时地判断下发什么命令与操作。该函数在Volume.cpp源文件中，先贴出setState源码看看：

[cpp] view plain copy

void Volume::setState(int state) {
char msg[255];
int oldState = mState;
if (oldState == state) {
SLOGW("Duplicate state (%d)\n", state);
return;
}
mState = state;
SLOGD("Volume %s state changing %d (%s) -> %d (%s)", mLabel,
oldState, stateToStr(oldState), mState, stateToStr(mState));
snprintf(msg, sizeof(msg),
"Volume %s %s state changed from %d (%s) to %d (%s)", getLabel(),
getMountpoint(), oldState, stateToStr(oldState), mState,
stateToStr(mState));
mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeStateChange,
msg, false);
}

可以看到，setState函数将磁盘的label，mountpoint，oldstate，statestr，newstate，statestr消息通知给Framework，这样Framework就知道vold中SD卡的新旧状态。然后调用通过SocketListener类继承下来的sendBroadcast函数广播消息，反馈码是ResponseCode::VolumeStateChange，代表状态改变的消息。
这里可能有个疑问，vold广播这么多消息，Framework是如何分清哪条消息是代表哪一类的反馈消息呢？
广播消息在开头使用了ResponseCode类提供的一些状态反馈码，每一类消息都用一个反馈码，这样Framework的MountService服务能够很快的判断出类型。之前的文章说过了，这里列出几个重要的反馈码：

[cpp] view plain copy

static const int VolumeStateChange = 605;//磁盘状态改变的反馈码
static const int ShareAvailabilityChange = 620;//OTG状态改变的反馈码
static const int VolumeDiskInserted = 630;//插入磁盘的反馈码
static const int VolumeDiskRemoved = 631;//移除磁盘的反馈码
static const int VolumeBadRemoval = 632;//没有安全删除地移除磁盘的反馈码。

setState函数只负责磁盘状态改变的广播，其他插入磁盘或者移除磁盘的都是直接调用sendBroadcast函数来广播，这里贴出插拔事件的广播函数：

[cpp] view plain copy

void DirectVolume::broadcastDiskAdded()
{
setState(Volume::State_Idle);
char msg[255];
snprintf(msg, sizeof(msg), "Volume %s %s disk inserted (%d:%d)",
getLabel(), getMountpoint(), mDiskMajor, mDiskMinor);
mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskInserted, msg, false);
}

三、下发操作命令？

volume mount sdcard:

[cpp] view plain copy

public int mountVolume(String path) {
validatePermission(android.Manifest.permission.MOUNT_UNMOUNT_FILESYSTEMS);
waitForReady();
return doMountVolume(path);
}

volume unmount force:

[cpp] view plain copy

public void unmountVolume(String path, boolean force) {
validatePermission(android.Manifest.permission.MOUNT_UNMOUNT_FILESYSTEMS);
waitForReady();
String volState = getVolumeState(path);
if (DEBUG_UNMOUNT) Slog.i(TAG, "Unmounting " + path + " force = " + force);
if (Environment.MEDIA_UNMOUNTED.equals(volState) ||
Environment.MEDIA_REMOVED.equals(volState) ||
Environment.MEDIA_SHARED.equals(volState) ||
Environment.MEDIA_UNMOUNTABLE.equals(volState)) {
// Media already unmounted or cannot be unmounted.
// TODO return valid return code when adding observer call back.
return;
}
UnmountCallBack ucb = new UnmountCallBack(path, force);
mHandler.sendMessage(mHandler.obtainMessage(H_UNMOUNT_PM_UPDATE, ucb));
}

volume format sdcard:

[cpp] view plain copy

public int formatVolume(String path) {
validatePermission(android.Manifest.permission.MOUNT_FORMAT_FILESYSTEMS);
waitForReady();
return doFormatVolume(path);
}

volume share sdcard ums
volume unshare sdcard ums:

[cpp] view plain copy

private void doShareUnshareVolume(String path, String method, boolean enable) {
// TODO: Add support for multiple share methods
if (!method.equals("ums")) {
throw new IllegalArgumentException(String.format("Method %s not supported", method));
}
try {
mConnector.doCommand(String.format(
"volume %sshare %s %s", (enable ? "" : "un"), path, method));
} catch (NativeDaemonConnectorException e) {
Slog.e(TAG, "Failed to share/unshare", e);
}
}

volume shared sdcard ums:

[cpp] view plain copy

private boolean doGetVolumeShared(String path, String method) {
String cmd = String.format("volume shared %s %s", path, method);
ArrayList<String> rsp;
try {
rsp = mConnector.doCommand(cmd);
} catch (NativeDaemonConnectorException ex) {
Slog.e(TAG, "Failed to read response to volume shared " + path + " " + method);
return false;
}
for (String line : rsp) {
String[] tok = line.split(" ");
if (tok.length < 3) {
Slog.e(TAG, "Malformed response to volume shared " + path + " " + method + " command");
return false;
}
int code;
try {
code = Integer.parseInt(tok[0]);
} catch (NumberFormatException nfe) {
Slog.e(TAG, String.format("Error parsing code %s", tok[0]));
return false;
}
if (code == VoldResponseCode.ShareEnabledResult) {
return "enabled".equals(tok[2]);
} else {
Slog.e(TAG, String.format("Unexpected response code %d", code));
return false;
}
}
Slog.e(TAG, "Got an empty response");
return false;
}

在Framework中的磁盘管理部分，也涉及到很多代码，源码太多，只贴出比较重要的功能模块代码。

四、UI的处理
从vold走到了Framework，最后一层就是UI，是用户操作磁盘的界面。有Android手机的哥们儿都知道，在设置里面可以挂载，卸载与格式化SD卡。当然这图形界面不是咱擅长的，需要Java的功底与XML，那边主要就是界面的实现。
UI的源码路径是：/android-2.2r2/packages/apps/Settings/src/com/android/settings/deviceinfo/Memory.java
我们可以发现，在Android手机的设置界面，或者主页面，只要插入SD卡或者移除SD卡，都会有相应的提示，

1.这些磁盘状态是如何与UI通信的呢？
在MountService服务中，每次改变状态，都会调用updatePublicVolumeState函数，从意思上看，可以理解成：更新一个公用的磁盘状态。这个函数就是起到了这么一个作用，这会设置到Environment类中的一个变量中，这样UI就能够取到磁盘的状态。

2.UI是如何调用Framework中的函数的？
前面有提到过，UI想要调用Framework中的MountService服务中的函数，比如以注册的方式来得到调用操作磁盘函数的权限。以下贴出UI中，Memory.java源码中注册MountService磁盘操作函数的方法：

[cpp] view plain copy

private synchronized IMountService getMountService() {
if (mMountService == null) {
/*调用了getService函数来注册"mount"服务的操作权限*/
IBinder service = ServiceManager.getService("mount");
if (service != null) {
mMountService = IMountService.Stub.asInterface(service);
} else {
Log.e(TAG, "Can't get mount service");
}
}
return mMountService;
}

来看一个挂载SD卡的操作函数，就知道如何来调用Framework系统服务的函数：

[cpp] view plain copy

private void mount() {
/*先注册*/
IMountService mountService = getMountService();
try {
if (mountService != null) {
/*挂载SD卡*/
mountService.mountVolume(Environment.getExternalStorageDirectory().toString());
} else {
Log.e(TAG, "Mount service is null, can't mount");
}
} catch (RemoteException ex) {
}
}

3.UI获取SD卡的当前状态
在第一点已经解释过了，这里再仔细的说明下：
SD卡的状态是这样获取到的：
Vold (setState)-->
MountService (onEvent)-->
MountService (updatePublicVolumeState)-->
UI (getExternalStorageState)

Vold调用setState函数广播SD卡的状态，Framework的MountService服务通过onEvent函数收到该状态消息，调用updatePublicVolumeState函数设置到Environment中的一个变量中，UI再通过Environment.getExternalStorageState函数获取到最新状态，于是UI调用updateMemoryStatus函数将最新状态设置到界面，这样用户就能看到状态的改变。
(用户都会发现，挂载或卸载SD卡，状态由挂载变为卸载需要一小段时间，这中间就是经过这些处理来得到的，包括上层发送命令->底层解析命令调用相应函数->操作完成后发送操作结果->最后将SD卡的最新状态广播给Framework，并设置到UI。这中间涉及到很多东西，再加上Java虚拟机的速度，于是界面就有一个停顿的时间)。
以下贴出UI状态的更新代码：

[cpp] view plain copy

private void updateMemoryStatus() {
String status = Environment.getExternalStorageState();
String readOnly = "";
if (status.equals(Environment.MEDIA_MOUNTED_READ_ONLY)) {
status = Environment.MEDIA_MOUNTED;
readOnly = mRes.getString(R.string.read_only);
}
mSdFormat.setEnabled(false);
if (status.equals(Environment.MEDIA_MOUNTED)) {
try {
File path = Environment.getExternalStorageDirectory();
StatFs stat = new StatFs(path.getPath());
long blockSize = stat.getBlockSize();
long totalBlocks = stat.getBlockCount();
long availableBlocks = stat.getAvailableBlocks();
mSdSize.setSummary(formatSize(totalBlocks * blockSize));
mSdAvail.setSummary(formatSize(availableBlocks * blockSize) + readOnly);
mSdMountToggle.setEnabled(true);
mSdMountToggle.setTitle(mRes.getString(R.string.sd_eject));
mSdMountToggle.setSummary(mRes.getString(R.string.sd_eject_summary));
} catch (IllegalArgumentException e) {
// this can occur if the SD card is removed, but we haven't received the
// ACTION_MEDIA_REMOVED Intent yet.
status = Environment.MEDIA_REMOVED;
}
} else {
mSdSize.setSummary(mRes.getString(R.string.sd_unavailable));
mSdAvail.setSummary(mRes.getString(R.string.sd_unavailable));
if (status.equals(Environment.MEDIA_UNMOUNTED) ||
status.equals(Environment.MEDIA_NOFS) ||
status.equals(Environment.MEDIA_UNMOUNTABLE) ) {
mSdFormat.setEnabled(true);
mSdMountToggle.setEnabled(true);
mSdMountToggle.setTitle(mRes.getString(R.string.sd_mount));
mSdMountToggle.setSummary(mRes.getString(R.string.sd_mount_summary));
} else {
mSdMountToggle.setEnabled(false);
mSdMountToggle.setTitle(mRes.getString(R.string.sd_mount));
mSdMountToggle.setSummary(mRes.getString(R.string.sd_insert_summary));
}
}
File path = Environment.getDataDirectory();
StatFs stat = new StatFs(path.getPath());
long blockSize = stat.getBlockSize();
long availableBlocks = stat.getAvailableBlocks();
findPreference("memory_internal_avail").setSummary(formatSize(availableBlocks * blockSize));
}

五、好聚好散
终于将Android系统磁盘管理的这部分给over了，现在我深深地敬佩系统设计人员，他们都是非凡的人才，再次感谢谷歌对Android社区的贡献。先不说谷歌有没有对Android的开源，或者一些专利的事，但在我眼里，Google是非常强大的公司，向他学习，没错的。
三争IT天下： Google VS Microsoft VS Apple.
三分智能领域：Android VS WP7 VS iOS.