Android-vold源码分析之runCommand

只讲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 plaincopy

1. intCommandListener::VolumeCmd::runCommand(SocketClient*cli,
2. intargc,char**argv){
3. dumpArgs(argc,argv,-1);
5. if(argc<2){
6. cli->sendMsg(ResponseCode::CommandSyntaxError,"MissingArgument",false);
7. return0;
8. }
10. VolumeManager*vm=VolumeManager::Instance();
11. intrc=0;
13. if(!strcmp(argv[1],"list")){
14. returnvm->listVolumes(cli);
15. }elseif(!strcmp(argv[1],"debug")){
16. if(argc!=3||(argc==3&&(strcmp(argv[2],"off")&&strcmp(argv[2],"on")))){
17. cli->sendMsg(ResponseCode::CommandSyntaxError,"Usage:volumedebug<off/on>",false);
18. return0;
19. }
20. vm->setDebug(!strcmp(argv[2],"on")?true:false);
21. }elseif(!strcmp(argv[1],"mount")){
22. if(argc!=3){
23. cli->sendMsg(ResponseCode::CommandSyntaxError,"Usage:volumemount<path>",false);
24. return0;
25. }
26. rc=vm->mountVolume(argv[2]);
27. }elseif(!strcmp(argv[1],"unmount")){
28. if(argc<3||argc>4||(argc==4&&strcmp(argv[3],"force"))){
29. cli->sendMsg(ResponseCode::CommandSyntaxError,"Usage:volumeunmount<path>[force]",false);
30. return0;
31. }
33. boolforce=false;
34. if(argc>=4&&!strcmp(argv[3],"force")){
35. force=true;
36. }
37. rc=vm->unmountVolume(argv[2],force);
38. }elseif(!strcmp(argv[1],"format")){
39. if(argc!=3){
40. cli->sendMsg(ResponseCode::CommandSyntaxError,"Usage:volumeformat<path>",false);
41. return0;
42. }
43. rc=vm->formatVolume(argv[2]);
44. }elseif(!strcmp(argv[1],"share")){
45. if(argc!=4){
46. cli->sendMsg(ResponseCode::CommandSyntaxError,
47. "Usage:volumeshare<path><method>",false);
48. return0;
49. }
50. rc=vm->shareVolume(argv[2],argv[3]);
51. }elseif(!strcmp(argv[1],"unshare")){
52. if(argc!=4){
53. cli->sendMsg(ResponseCode::CommandSyntaxError,
54. "Usage:volumeunshare<path><method>",false);
55. return0;
56. }
57. rc=vm->unshareVolume(argv[2],argv[3]);
58. }elseif(!strcmp(argv[1],"shared")){
59. boolenabled=false;
60. if(argc!=4){
61. cli->sendMsg(ResponseCode::CommandSyntaxError,
62. "Usage:volumeshared<path><method>",false);
63. return0;
64. }
66. if(vm->shareEnabled(argv[2],argv[3],&enabled)){
67. cli->sendMsg(
68. ResponseCode::OperationFailed,"Failedtodetermineshareenablestate",true);
69. }else{
70. cli->sendMsg(ResponseCode::ShareEnabledResult,
71. (enabled?"Shareenabled":"Sharedisabled"),false);
72. }
73. return0;
74. }else{
75. cli->sendMsg(ResponseCode::CommandSyntaxError,"Unknownvolumecmd",false);
76. }
78. if(!rc){
79. cli->sendMsg(ResponseCode::CommandOkay,"volumeoperationsucceeded",false);
80. }else{
81. interno=errno;
82. rc=ResponseCode::convertFromErrno();
83. cli->sendMsg(rc,"volumeoperationfailed",true);
84. }
86. return0;
87. }

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

[cpp]view plaincopy

1. intVolumeManager::listVolumes(SocketClient*cli){
2. VolumeCollection::iteratori;
4. for(i=mVolumes->begin();i!=mVolumes->end();++i){
5. char*buffer;
6. asprintf(&buffer,"%s%s%d",
7. (*i)->getLabel(),(*i)->getMountpoint(),
8. (*i)->getState());
9. cli->sendMsg(ResponseCode::VolumeListResult,buffer,false);
10. free(buffer);
11. }
12. cli->sendMsg(ResponseCode::CommandOkay,"Volumeslisted.",false);
13. return0;
14. }

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

[cpp]view plaincopy

1. voidVolumeManager::setDebug(boolenable){
2. mDebug=enable;
3. VolumeCollection::iteratorit;
4. for(it=mVolumes->begin();it!=mVolumes->end();++it){
5. (*it)->setDebug(enable);
6. }
7. }

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

[cpp]view plaincopy

1. voidVolume::setDebug(boolenable){
2. mDebug=enable;
3. }

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

   [cpp]view plaincopy

   1. intVolumeManager::mountVolume(constchar*label){
   2. Volume*v=lookupVolume(label);
   4. if(!v){
   5. errno=ENOENT;
   6. return-1;
   7. }
   9. returnv->mountVol();
   10. }
   
   lookupVolume函数寻找与label匹配的对象：
   
   [cpp]view plaincopy

   1. Volume*VolumeManager::lookupVolume(constchar*label){
   2. VolumeCollection::iteratori;
   4. for(i=mVolumes->begin();i!=mVolumes->end();++i){
   5. if(label[0]=='/'){
   6. if(!strcmp(label,(*i)->getMountpoint()))
   7. return(*i);
   8. }else{
   9. if(!strcmp(label,(*i)->getLabel()))
   10. return(*i);
   11. }
   12. }
   13. returnNULL;
   14. }
   
   如果找到，直接返回磁盘对象Volume*，挂载操作在mountVol函数里面，该函数内容有点多，贴源码:
   
   [cpp]view plaincopy

   1. intVolume::mountVol(){
   2. dev_tdeviceNodes[4];
   3. intn,i,rc=0;
   4. charerrmsg[255];
   6. if(getState()==Volume::State_NoMedia){
   7. snprintf(errmsg,sizeof(errmsg),
   8. "Volume%s%smountfailed-nomedia",
   9. getLabel(),getMountpoint());
   10. mVm->getBroadcaster()->sendBroadcast(
   11. ResponseCode::VolumeMountFailedNoMedia,
   12. errmsg,false);
   13. errno=ENODEV;
   14. return-1;
   15. }elseif(getState()!=Volume::State_Idle){
   16. errno=EBUSY;
   17. return-1;
   18. }
   19. /*判断该挂载点是否已经挂载，若已经挂载，则直接返回。*/
   20. if(isMountpointMounted(getMountpoint())){
   21. SLOGW("Volumeisidlebutappearstobemounted-fixing");
   22. /*这里的setState函数用得很频繁，这函数就是将状态通知给framework*/
   23. setState(Volume::State_Mounted);
   24. //mCurrentlyMountedKdev=XXX
   25. return0;
   26. }
   27. /*获取磁盘的设备号与分区数量,在下面说明*/
   28. n=getDeviceNodes((dev_t*)&deviceNodes,4);
   29. if(!n){
   30. SLOGE("Failedtogetdevicenodes(%s)\n",strerror(errno));
   31. return-1;
   32. }
   33. /*将循环挂载n个分区，但从代码上看，只适用于挂载一个分区*/
   34. for(i=0;i<n;i++){
   35. chardevicePath[255];
   36. /*这里看到了吧，用这种方式来使用磁盘的设备节点很方便，直接用主次设备号来命令*/
   37. sprintf(devicePath,"/dev/block/vold/%d:%d",MAJOR(deviceNodes[i]),
   38. MINOR(deviceNodes[i]));
   40. SLOGI("%sbeingconsideredforvolume%s\n",devicePath,getLabel());
   42. errno=0;
   43. setState(Volume::State_Checking);
   44. /*挂载之前先检测一下该分区是否是fat分区，如果不是fat格式，返回-1*/
   45. if(Fat::check(devicePath)){
   46. if(errno==ENODATA){
   47. SLOGW("%sdoesnotcontainaFATfilesystem\n",devicePath);
   48. continue;
   49. }
   50. errno=EIO;
   51. /*Badness-abortthemount*/
   52. SLOGE("%sfailedFSchecks(%s)",devicePath,strerror(errno));
   53. setState(Volume::State_Idle);
   54. return-1;
   55. }
   57. /*
   58. *Mountthedeviceonourinternalstagingmountpointsowecan
   59. *muckwithitbeforeexposingittononpriviledgedusers.
   60. */
   61. errno=0;
   62. /*将设备节点挂载在/mnt/secure/staging目录*/
   63. if(Fat::doMount(devicePath,"/mnt/secure/staging",false,false,1000,1015,0702,true)){
   64. SLOGE("%sfailedtomountviaVFAT(%s)\n",devicePath,strerror(errno));
   65. continue;
   66. }
   68. SLOGI("Device%s,target%smounted@/mnt/secure/staging",devicePath,getMountpoint());
   70. protectFromAutorunStupidity();
   71. /*挂载一个只有root用户能够访问的目录，这函数挂载了两次
   72. 将/mnt/secure/staging/.android_secure挂载在/mnt/secure/asec，
   73. 将tmpfs挂载在/mnt/secure/staging/.android_secure*/
   74. if(createBindMounts()){
   75. SLOGE("Failedtocreatebindmounts(%s)",strerror(errno));
   76. umount("/mnt/secure/staging");
   77. setState(Volume::State_Idle);
   78. return-1;
   79. }
   81. /*
   82. *Nowthatthebindmounttrickeryisdone,atomicallymovethe
   83. *wholesubtreetoexposeittononpriviledgedusers.
   84. */
   85. /*将挂载点挂载的目录再挂载到最终的目录/mnt/sdcard*/
   86. if(doMoveMount("/mnt/secure/staging",getMountpoint(),false)){
   87. SLOGE("Failedtomovemount(%s)",strerror(errno));
   88. umount("/mnt/secure/staging");
   89. setState(Volume::State_Idle);
   90. return-1;
   91. }
   92. setState(Volume::State_Mounted);
   93. mLastMountedKdev=mCurrentlyMountedKdev=deviceNodes[i];
   94. return0;
   95. }
   97. SLOGE("Volume%sfoundnosuitabledevicesformounting:(\n",getLabel());
   98. setState(Volume::State_Idle);
   100. return-1;
   101. }
   
   这个挂载函数看起来，会发现很繁琐，好几个目录的挂载关系，有以下挂载目录：
   /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 plaincopy

   1. intDirectVolume::getDeviceNodes(dev_t*devs,intmax){
   2. if(mPartIdx==-1){
   3. //Ifthediskhasnopartitions,trythediskitself
   4. if(!mDiskNumParts){
   5. devs[0]=MKDEV(mDiskMajor,mDiskMinor);
   6. return1;
   7. }
   9. inti;
   10. for(i=0;i<mDiskNumParts;i++){
   11. if(i==max)
   12. break;
   13. devs[i]=MKDEV(mDiskMajor,mPartMinors[i]);
   14. }
   15. returnmDiskNumParts;
   16. }
   17. devs[0]=MKDEV(mDiskMajor,mPartMinors[mPartIdx-1]);
   18. return1;
   19. }
   
   下面贴一些mountVol里面挂载的源码：
   
   [cpp]view plaincopy

   1. intFat::doMount(constchar*fsPath,constchar*mountPoint,
   2. boolro,boolremount,intownerUid,intownerGid,
   3. intpermMask,boolcreateLost){
   4. intrc;
   5. unsignedlongflags;
   6. charmountData[255];
   8. flags=MS_NODEV|MS_NOEXEC|MS_NOSUID|MS_DIRSYNC;
   10. flags|=(ro?MS_RDONLY:0);
   11. flags|=(remount?MS_REMOUNT:0);
   13. /*
   14. *Note:Thisisatemporaryhack.Ifthesamplingprofilerisenabled,
   15. *wemaketheSDcardworld-writablesoanyprocesscanwritesnapshots.
   16. *
   17. *TODO:Removethiscodeoncewehaveadropboxinsystem_server.
   18. */
   19. charvalue[PROPERTY_VALUE_MAX];
   20. property_get("persist.sampling_profiler",value,"");
   21. if(value[0]=='1'){
   22. SLOGW("TheSDcardisworld-writablebecausethe"
   23. "'persist.sampling_profiler'systempropertyissetto'1'.");
   24. permMask=0;
   25. }
   27. sprintf(mountData,
   28. "utf8,uid=%d,gid=%d,fmask=%o,dmask=%o,shortname=mixed",
   29. ownerUid,ownerGid,permMask,permMask);
   31. rc=mount(fsPath,mountPoint,"vfat",flags,mountData);
   33. if(rc&&errno==EROFS){
   34. SLOGE("%sappearstobeareadonlyfilesystem-retryingmountRO",fsPath);
   35. flags|=MS_RDONLY;
   36. rc=mount(fsPath,mountPoint,"vfat",flags,mountData);
   37. }
   39. if(rc==0&&createLost){
   40. char*lost_path;
   41. asprintf(&lost_path,"%s/LOST.DIR",mountPoint);
   42. if(access(lost_path,F_OK)){
   43. /*
   44. *CreateaLOST.DIRintherootsowehavesomewheretoput
   45. *lostclusterchains(fsck_msdosdoesn'tcurrentlydothis)
   46. */
   47. if(mkdir(lost_path,0755)){
   48. SLOGE("UnabletocreateLOST.DIR(%s)",strerror(errno));
   49. }
   50. }
   51. free(lost_path);
   52. }
   54. returnrc;
   55. }
   57. intVolume::createBindMounts(){
   58. unsignedlongflags;
   60. /*
   61. *Renameold/android_secure->/.android_secure
   62. */
   63. if(!access("/mnt/secure/staging/android_secure",R_OK|X_OK)&&
   64. access(SEC_STG_SECIMGDIR,R_OK|X_OK)){
   65. if(rename("/mnt/secure/staging/android_secure",SEC_STG_SECIMGDIR)){
   66. SLOGE("Failedtorenamelegacyasecdir(%s)",strerror(errno));
   67. }
   68. }
   70. /*
   71. *Ensurethat/android_secureexistsandisadirectory
   72. */
   73. if(access(SEC_STG_SECIMGDIR,R_OK|X_OK)){
   74. if(errno==ENOENT){
   75. if(mkdir(SEC_STG_SECIMGDIR,0777)){
   76. SLOGE("Failedtocreate%s(%s)",SEC_STG_SECIMGDIR,strerror(errno));
   77. return-1;
   78. }
   79. }else{
   80. SLOGE("Failedtoaccess%s(%s)",SEC_STG_SECIMGDIR,strerror(errno));
   81. return-1;
   82. }
   83. }else{
   84. structstatsbuf;
   86. if(stat(SEC_STG_SECIMGDIR,&sbuf)){
   87. SLOGE("Failedtostat%s(%s)",SEC_STG_SECIMGDIR,strerror(errno));
   88. return-1;
   89. }
   90. if(!S_ISDIR(sbuf.st_mode)){
   91. SLOGE("%sisnotadirectory",SEC_STG_SECIMGDIR);
   92. errno=ENOTDIR;
   93. return-1;
   94. }
   95. }
   97. /*
   98. *Bindmount/mnt/secure/staging/android_secure->/mnt/secure/asecsowe'll
   99. *havearootonlyaccessablemountpointforit.
   100. */
   101. if(mount(SEC_STG_SECIMGDIR,SEC_ASECDIR,"",MS_BIND,NULL)){
   102. SLOGE("Failedtobindmountpoints%s->%s(%s)",
   103. SEC_STG_SECIMGDIR,SEC_ASECDIR,strerror(errno));
   104. return-1;
   105. }
   107. /*
   108. *Mountaread-only,zero-sizedtmpfson<mountpoint>/android_secureto
   109. *obscuretheunderlyingdirectoryfromeverybody-sneakyeh?;)
   110. */
   111. if(mount("tmpfs",SEC_STG_SECIMGDIR,"tmpfs",MS_RDONLY,"size=0,mode=000,uid=0,gid=0")){
   112. SLOGE("Failedtoobscure%s(%s)",SEC_STG_SECIMGDIR,strerror(errno));
   113. umount("/mnt/asec_secure");
   114. return-1;
   115. }
   117. return0;
   118. }
   120. intVolume::doMoveMount(constchar*src,constchar*dst,boolforce){
   121. unsignedintflags=MS_MOVE;
   122. intretries=5;
   124. while(retries--){
   125. if(!mount(src,dst,"",flags,NULL)){
   126. if(mDebug){
   127. SLOGD("Movedmount%s->%ssucessfully",src,dst);
   128. }
   129. return0;
   130. }elseif(errno!=EBUSY){
   131. SLOGE("Failedtomovemount%s->%s(%s)",src,dst,strerror(errno));
   132. return-1;
   133. }
   134. intaction=0;
   136. if(force){
   137. if(retries==1){
   138. action=2;//SIGKILL
   139. }elseif(retries==2){
   140. action=1;//SIGHUP
   141. }
   142. }
   143. SLOGW("Failedtomove%s->%s(%s,retries%d,action%d)",
   144. src,dst,strerror(errno),retries,action);
   145. Process::killProcessesWithOpenFiles(src,action);
   146. usleep(1000*250);
   147. }
   149. errno=EBUSY;
   150. SLOGE("Givinguponmove%s->%s(%s)",src,dst,strerror(errno));
   151. return-1;
   152. }
   
   篇幅有点长了，挂载点也挂载了好几个，mountVol处理的事情最多的，也最繁琐，但都是简单的，主要是有点摸不着头脑，
   
5. 提供了挂载，卸载与格式化的功能。在这里，我们可以回忆一下，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 plaincopy

   1. elseif(!strcmp(argv[1],"unmount")){
   2. if(argc<3||argc>4||(argc==4&&strcmp(argv[3],"force"))){
   3. cli->sendMsg(ResponseCode::CommandSyntaxError,"Usage:volumeunmount<path>[force]",false);
   4. return0;
   5. }
   7. boolforce=false;
   8. if(argc>=4&&!strcmp(argv[3],"force")){
   9. force=true;
   10. }
   11. rc=vm->unmountVolume(argv[2],force);
   12. }
   这条卸载命令的格式是：volume unmount sdcard true/false.
   这里有一个强制卸载的标志，也就是force参数，如果命令包含“force”字符串，那么就强制
   卸载sd卡，接下来看unmountVolume卸载函数：
   [cpp]view plaincopy

   1. intVolumeManager::unmountVolume(constchar*label,boolforce){
   2. Volume*v=lookupVolume(label);
   3. ......
   4. /*这函数清理了/mnt/asec目录的一些内容，其实看不见*/
   5. cleanupAsec(v,force);
   7. returnv->unmountVol(force);
   8. }
   
   开始看卸载函数，以下函数均做简化，不再贴出大量源码，Android系统的源码实在太多：
   [cpp]view plaincopy

   1. intVolume::unmountVol(boolforce){
   2. /*广播sd卡正在卸载的状态*/
   3. setState(Volume::State_Unmounting);
   5. if(doMoveMount(getMountpoint(),SEC_STGDIR,force)){
   6. SLOGE("Failedtomovemount%s=>%s(%s)",getMountpoint(),SEC_STGDIR,strerror(errno));
   7. setState(Volume::State_Mounted);
   8. return-1;
   9. }
   11. if(doUnmount(Volume::SEC_STG_SECIMGDIR,force)){
   12. SLOGE("Failedtounmounttmpfson%s(%s)",SEC_STG_SECIMGDIR,strerror(errno));
   13. gotofail_republish;
   14. }
   16. if(doUnmount(Volume::SEC_ASECDIR,force)){
   17. SLOGE("Failedtoremovebindmounton%s(%s)",SEC_ASECDIR,strerror(errno));
   18. gotofail_remount_tmpfs;
   19. }
   20. if(doUnmount(Volume::SEC_STGDIR,force)){
   21. SLOGE("Failedtounmount%s(%s)",SEC_STGDIR,strerror(errno));
   22. gotofail_recreate_bindmount;
   23. }
   24. /*以上doMoveMount,doUnmount等函数做些清理工作，就是之前挂载到系统的目录
   25. 清理干净*/
   26. /*卸载工作做完，告诉framework，该磁盘处于空闲状态*/
   27. setState(Volume::State_Idle);
   28. /*用来保存正在挂载的设备号的全局变量，现在赋为-1*/
   29. mCurrentlyMountedKdev=-1;
   30. return0;
   31. }

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

   [cpp]view plaincopy

   1. voidDirectVolume::handlePartitionRemoved(constchar*devpath,NetlinkEvent*evt){
   2. intmajor=atoi(evt->findParam("MAJOR"));
   3. intminor=atoi(evt->findParam("MINOR"));
   4. charmsg[255];
   5. intstate;
   7. SLOGD("Volume%s%spartition%d:%dremoved\n",getLabel(),getMountpoint(),major,minor);
   9. /*
   10. *Theframeworkdoesn'tneedtogetnotifiedof
   11. *partitionremovalunlessit'smounted.Otherwise
   12. *theremovalnotificationwillbesentontheDisk
   13. *itself
   14. */
   15. state=getState();
   16. if(state!=Volume::State_Mounted&&state!=Volume::State_Shared){
   17. return;
   18. }
   19. /*判断，如果移除事件的设备号与正在挂载系统的设备号相等，
   20. 说明此时是没有安全删除，所以下面会广播VolumeBadRemoval反馈码*/
   21. if((dev_t)MKDEV(major,minor)==mCurrentlyMountedKdev){
   22. /*
   23. *Yikes,ourmountedpartitionisgoingaway!
   24. */
   26. snprintf(msg,sizeof(msg),"Volume%s%sbadremoval(%d:%d)",
   27. getLabel(),getMountpoint(),major,minor);
   28. mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeBadRemoval,
   29. msg,false);
   30. /*清理asec目录*/
   31. if(mVm->cleanupAsec(this,true)){
   32. SLOGE("FailedtocleanupASEC-unmountwillprobablyfail!");
   33. }
   34. /*在这里调用了卸载函数，跟framework下发命令卸载一样。*/
   35. if(Volume::unmountVol(true)){
   36. SLOGE("Failedtounmountvolumeonbadremoval(%s)",
   37. strerror(errno));
   38. //XXX:Atthispointwe'rescrewedfornow
   39. }else{
   40. SLOGD("Crisisaverted");
   41. }
   42. }elseif(state==Volume::State_Shared){
   43. /*这里的判断是，如果此时手机与电脑正在连接着使用时，移除事件的情况*/
   44. /*removedduringmassstorage*/
   45. snprintf(msg,sizeof(msg),"Volume%sbadremoval(%d:%d)",
   46. getLabel(),major,minor);
   47. mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeBadRemoval,
   48. msg,false);
   49. /*卸载大容量存储*/
   50. if(mVm->unshareVolume(getLabel(),"ums")){
   51. SLOGE("Failedtounsharevolumeonbadremoval(%s)",
   52. strerror(errno));
   53. }else{
   54. SLOGD("Crisisaverted");
   55. }
   56. }
   57. }
   
   
   
6. 操作有这几步：
   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 plaincopy

   1. intVolume::formatVol(){
   2. if(getState()==Volume::State_NoMedia){
   3. errno=ENODEV;
   4. return-1;
   5. }elseif(getState()!=Volume::State_Idle){
   6. errno=EBUSY;
   7. return-1;
   8. }
   9. /*如果该分区为卸载，那么格式化失败，返回错误*/
   10. if(isMountpointMounted(getMountpoint())){
   11. SLOGW("Volumeisidlebutappearstobemounted-fixing");
   12. setState(Volume::State_Mounted);
   13. //mCurrentlyMountedKdev=XXX
   14. errno=EBUSY;
   15. return-1;
   16. }
   18. chardevicePath[255];
   19. dev_tdiskNode=getDiskDevice();
   20. dev_tpartNode;
   22. if(mDebug){
   23. SLOGI("Formattingvolume%s(%s)",getLabel(),devicePath);
   24. }
   25. setState(Volume::State_Formatting);
   27. if(!mLastMountedKdev){
   28. dev_tdeviceNodes[2];
   29. intn=getDeviceNodes(deviceNodes,2);
   30. //initializeMBRifnopartition,orhasmultiplepartitions
   31. //butnoneisselected
   32. if((diskNode==deviceNodes[0])||(n>1)){
   33. sprintf(devicePath,"/dev/block/vold/%d:%d",
   34. MAJOR(diskNode),MINOR(diskNode));
   35. if(initializeMbr(devicePath)){
   36. SLOGE("FailedtoinitializeMBR(%s)",strerror(errno));
   37. partNode=diskNode;//trytousewholedisk
   38. }else{
   39. partNode=MKDEV(MAJOR(diskNode),MINOR(diskNode)+1);
   40. }
   41. }else{
   42. partNode=deviceNodes[0];
   43. }
   44. }else{
   45. partNode=mLastMountedKdev;
   46. }
   48. sprintf(devicePath,"/dev/block/vold/%d:%d",
   49. MAJOR(partNode),MINOR(partNode));
   51. intret=Fat::format(devicePath,0);
   52. SLOGE_IF(ret,"Failedtoformat(%s)",strerror(errno));
   54. setState(Volume::State_Idle);
   55. returnret;
   56. }
   
   格式化函数两个主要工作交给了initializeMbr和Fat::format函数：
   1.initializeMbr函数负责初始化MBR；
   2.Fat::format函数负责格式化分区。
   先来看initializeMbr函数的初始化工作：
   
   [cpp]view plaincopy

   1. intVolume::initializeMbr(constchar*deviceNode){
   2. structdisk_infodinfo;
   4. memset(&dinfo,0,sizeof(dinfo));
   6. if(!(dinfo.part_lst=(structpart_info*)malloc(MAX_NUM_PARTS*sizeof(structpart_info)))){
   7. SLOGE("Failedtomallocprt_lst");
   8. return-1;
   9. }
   11. memset(dinfo.part_lst,0,MAX_NUM_PARTS*sizeof(structpart_info));
   12. dinfo.device=strdup(deviceNode);
   13. dinfo.scheme=PART_SCHEME_MBR;
   14. dinfo.sect_size=512;
   15. dinfo.skip_lba=2048;
   16. dinfo.num_lba=0;
   17. dinfo.num_parts=1;
   19. structpart_info*pinfo=&dinfo.part_lst[0];
   21. pinfo->name=strdup("android_sdcard");
   22. pinfo->flags|=PART_ACTIVE_FLAG;
   23. pinfo->type=PC_PART_TYPE_FAT32;
   24. pinfo->len_kb=-1;
   26. intrc=apply_disk_config(&dinfo,0);
   28. if(rc){
   29. SLOGE("Failedtoapplydiskconfiguration(%d)",rc);
   30. gotoout;
   31. }
   33. out:
   34. free(pinfo->name);
   35. free(dinfo.device);
   36. free(dinfo.part_lst);
   38. returnrc;
   39. }
   
   这里贴出一些重要的结构体：
   
   [cpp]view plaincopy

   1. structpart_info{
   2. char*name;
   3. uint8_tflags;
   4. uint8_ttype;
   5. uint32_tlen_kb;/*in1K-bytes*/
   6. uint32_tstart_lba;/*theLBAwherethispartitionbegins*/
   7. };
   8. structdisk_info{
   9. char*device;
   10. uint8_tscheme;
   11. intsect_size;/*expectedsectorsizeinbytes.MUSTBEPOWEROF2*/
   12. uint32_tskip_lba;/*insectors(1unitofLBA)*/
   13. uint32_tnum_lba;/*thesizeofthediskinLBAunits*/
   14. structpart_info*part_lst;
   15. intnum_parts;
   16. };
   
   初始化完成后，将该结构体变量pinfo通过apply_disk_config函数进行设置：
   
   [cpp]view plaincopy

   1. intapply_disk_config(structdisk_info*dinfo,inttest)
   2. {
   3. intfd;
   4. structwrite_list*wr_lst=NULL;
   5. intrv;
   7. if(validate_and_config(dinfo,&fd,&wr_lst)!=0){
   8. LOGE("Configurationisinvalid.");
   9. gotofail;
   10. }
   12. if((rv=wlist_commit(fd,wr_lst,test))>=0)
   13. rv=test?0:sync_ptable(fd);
   15. close(fd);
   16. wlist_free(wr_lst);
   17. returnrv;
   19. fail:
   20. close(fd);
   21. if(wr_lst)
   22. wlist_free(wr_lst);
   23. return1;
   24. }
   
   该函数先打开sd卡的设备节点，然后将MBR的初始化信息写到第一个block(512B)中，
   这里涉及到非常多函数，不在vold的讨论范围。
   写完MBR后，就要对分区进行格式化，要格式化成FAT32格式，Fat::format函数直接调用
   系统命令newfs_msdos来格式化新分区，检测磁盘是，Fat::check函数直接调用系统命令
   fsck_msdos来检测分区。
   
   最后格式化完成功，通知Framework，sd卡处于空闲状态：
   
   [cpp]view plaincopy

   1. setState(Volume::State_Idle);
   
   然后，Framework又要重复挂载和卸载的操作了。