Android 2.3 SD卡挂载流程浅析(四)

最新推荐文章于 2024-07-13 16:04:16 发布
最新推荐文章于 2024-07-13 16:04:16 发布
阅读量8.6k 收藏 9
点赞数
分类专栏： Android 文章标签： android action iterator buffer disk path
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yihongyuelan/article/details/6965165
版权
前面的三篇博文《Android 2.3 SD卡挂载流程浅析(一)》、《Android 2.3 SD卡挂载流程浅析(二)》、《Android 2.3 SD卡挂载流程浅析(三)》的分析，知道了SD卡挂载的消息是如何从底层传递到上层的，在《Android 2.3 SD卡挂载流程浅析(三)》中，我们已经知道了最后是在updatePublicVolumeState()中调用onStorageStateChanged()，从而达到更新SD卡挂载信息的。在本文《Android 2.3 SD卡挂载流程浅析(四)》中，我会将前文提到的程序调用流程图画出来，并对代码进行简单的分析。

      首先，还是挂出这张老图(因为每次都用这张图0_0...)。

       就权当复习吧，这是SD卡的整个挂载流程，而程序的调用也是根据这个流程图来的。

       1.接收并处理uevent

       首先是接收因为插入SD卡被内核检测到而发出的Event；

       NetlinkHandler::onEvent(NetlinkEvent *evt)

//代码路径：AndroidSourcecode2.3/system/vold/NetlinkHandler.cpp

//该方法主要通过evt->getSubsystem();方法来获取系统的event

view plain print ?
  1. void NetlinkHandler::onEvent(NetlinkEvent *evt) {  
  2.     VolumeManager *vm = VolumeManager::Instance();  
  3.     const char *subsys = evt->getSubsystem();  
  4.   
  5.     if (!subsys) {  
  6.         SLOGW("No subsystem found in netlink event");  
  7.         return;  
  8.     }  
  9.   
  10.     if (!strcmp(subsys, "block")) {  
  11.         vm->handleBlockEvent(evt);  
  12.     } else if (!strcmp(subsys, "switch")) {  
  13.         vm->handleSwitchEvent(evt);  
  14.     } else if (!strcmp(subsys, "usb_composite")) {  
  15.         vm->handleUsbCompositeEvent(evt);  
  16.     } else if (!strcmp(subsys, "battery")) {  
  17.     } else if (!strcmp(subsys, "power_supply")) {  
  18.     }  
  19. }  
      2.对SD卡挂载事件开始处理

      void VolumeManager::handleBlockEvent(NetlinkEvent *evt)

//代码路径：AndroidSourcecode2.3/system/vold/VolumeManager.cpp

//该方法的主要作用是：
//第一，    遍历mPath容器，寻找与event对应的sysfs_path是否存在与mPath容器中。
//第二，    针对Event中的action有4种处理方式：Add,Removed,Change,Noaction。

view plain print ?
  1. void VolumeManager::handleBlockEvent(NetlinkEvent *evt) {  
  2.     const char *devpath = evt->findParam("DEVPATH");  
  3.   
  4.     /* Lookup a volume to handle this device */  
  5.     VolumeCollection::iterator it;  
  6.     bool hit = false;  
  7.     for (it = mVolumes->begin(); it != mVolumes->end(); ++it) {  
  8.         if (!(*it)->handleBlockEvent(evt)) {  
  9. #ifdef NETLINK_DEBUG  
  10.             SLOGD("Device '%s' event handled by volume %s\n", devpath, (*it)->getLabel());  
  11. #endif  
  12.             hit = true;  
  13.             break;  
  14.         }  
  15.     }  
  16.   
  17.     if (!hit) {  
  18. #ifdef NETLINK_DEBUG  
  19.         SLOGW("No volumes handled block event for '%s'", devpath);  
  20. #endif  
  21.     }  
  22. }  
     3.对Block挂载事件进行处理

     DirectVolume::handleBlockEvent(NetlinkEvent *evt)

//代码路径：AndroidSourcecode2.3/system/vold/DirectVolume.cpp

//在Add action中首先会创建设备节点，然后对disk和partion两种格式的设备分别进行处理。这里是disk格式。

view plain print ?
  1. int DirectVolume::handleBlockEvent(NetlinkEvent *evt) {  
  2.     const char *dp = evt->findParam("DEVPATH");  
  3.   
  4.     PathCollection::iterator  it;  
  5.     for (it = mPaths->begin(); it != mPaths->end(); ++it) {  
  6.         if (!strncmp(dp, *it, strlen(*it))) {  
  7.             /* We can handle this disk */  
  8.             int action = evt->getAction();  
  9.             const char *devtype = evt->findParam("DEVTYPE");  
  10.   
  11.             if (action == NetlinkEvent::NlActionAdd) {  
  12.                 int major = atoi(evt->findParam("MAJOR"));  
  13.                 int minor = atoi(evt->findParam("MINOR"));  
  14.                 char nodepath[255];  
  15.   
  16.                 snprintf(nodepath,  
  17.                          sizeof(nodepath), "/dev/block/vold/%d:%d",  
  18.                          major, minor);  
  19.                 if (createDeviceNode(nodepath, major, minor)) {  
  20.                     SLOGE("Error making device node '%s' (%s)", nodepath,  
  21.                                                                strerror(errno));  
  22.                 }  
  23.                 if (!strcmp(devtype, "disk")) {  
  24.                     <span style="color:#ff0000;">handleDiskAdded(dp, evt);<span style="color:#33cc00;">//SD卡插入是Add事件</span></span>  
  25.                 } else {  
  26.                     handlePartitionAdded(dp, evt);  
  27.                 }  
  28.             } else if (action == NetlinkEvent::NlActionRemove) {  
  29.                 if (!strcmp(devtype, "disk")) {  
  30.                     handleDiskRemoved(dp, evt);  
  31.                 } else {  
  32.                     handlePartitionRemoved(dp, evt);  
  33.                 }  
  34.             } else if (action == NetlinkEvent::NlActionChange) {  
  35.                 if (!strcmp(devtype, "disk")) {  
  36.                     handleDiskChanged(dp, evt);  
  37.                 } else {  
  38.                     handlePartitionChanged(dp, evt);  
  39.                 }  
  40.             } else {  
  41.                     SLOGW("Ignoring non add/remove/change event");  
  42.             }  
  43.   
  44.             return 0;  
  45.         }  
  46.     }  
  47.     errno = ENODEV;  
  48.     return -1;  
  49. }  
      4.处理DiskAdd事件

DirectVolume::handleDiskAdded(const char *devpath, NetlinkEvent *evt)

//代码路径：AndroidSourcecode2.3/system/vold/DirectVolume.cpp

//在该方法中广播disk insert的广播消息(这里的广播不同于Java中的广播，这里实际上是Socket)。

view plain print ?
  1. void DirectVolume::handleDiskAdded(const char *devpath, NetlinkEvent *evt) {  
  2.     mDiskMajor = atoi(evt->findParam("MAJOR"));  
  3.     mDiskMinor = atoi(evt->findParam("MINOR"));  
  4.   
  5.     const char *tmp = evt->findParam("NPARTS");  
  6.     if (tmp) {  
  7.         mDiskNumParts = atoi(tmp);  
  8.     } else {  
  9.         SLOGW("Kernel block uevent missing 'NPARTS'");  
  10.         mDiskNumParts = 1;  
  11.     }  
  12.   
  13.     char msg[255];  
  14.   
  15.     int partmask = 0;  
  16.     int i;  
  17.     for (i = 1; i <= mDiskNumParts; i++) {  
  18.         partmask |= (1 << i);  
  19.     }  
  20.     mPendingPartMap = partmask;  
  21.   
  22.     if (mDiskNumParts == 0) {  
  23. #ifdef PARTITION_DEBUG  
  24.         SLOGD("Dv::diskIns - No partitions - good to go son!");  
  25. #endif  
  26.         setState(Volume::State_Idle);  
  27.     } else {  
  28. #ifdef PARTITION_DEBUG  
  29.         SLOGD("Dv::diskIns - waiting for %d partitions (mask 0x%x)",  
  30.              mDiskNumParts, mPendingPartMap);  
  31. #endif  
  32.         setState(Volume::State_Pending);  
  33.     }  
  34.   
  35.     snprintf(msg, sizeof(msg), "Volume %s %s disk inserted (%d:%d)",  
  36.              getLabel(), getMountpoint(), mDiskMajor, mDiskMinor);  
  37.     <span style="color:#ff0000;">mVm->getBroadcaster()->sendBroadcast(ResponseCode::VolumeDiskInserted,  
  38.                                              msg, false);  
  39. </span>}  
      5.处理广播消息
       SocketListener::runListener()

//代码路径：AndroidSourcecode2.3/system/core/libsysutils/src/SocketListener.cpp

//完成对Socket的监听以及对数据的处理onDataAvailable(* it );

view plain print ?
  1. void SocketListener::runListener() {  
  2.   
  3.     while(1) {  
  4.         SocketClientCollection::iterator it;  
  5.         fd_set read_fds;  
  6.         int rc = 0;  
  7.         int max = 0;  
  8.   
  9.         FD_ZERO(&read_fds);  
  10.   
  11.         if (mListen) {  
  12.             max = mSock;  
  13.             FD_SET(mSock, &read_fds);  
  14.         }  
  15.   
  16.         FD_SET(mCtrlPipe[0], &read_fds);  
  17.         if (mCtrlPipe[0] > max)  
  18.             max = mCtrlPipe[0];  
  19.   
  20.         pthread_mutex_lock(&mClientsLock);  
  21.         for (it = mClients->begin(); it != mClients->end(); ++it) {  
  22.             FD_SET((*it)->getSocket(), &read_fds);  
  23.             if ((*it)->getSocket() > max)  
  24.                 max = (*it)->getSocket();  
  25.         }  
  26.         pthread_mutex_unlock(&mClientsLock);  
  27.   
  28.         if ((rc = select(max + 1, &read_fds, NULL, NULL, NULL)) < 0) {  
  29.             SLOGE("select failed (%s)", strerror(errno));  
  30.             sleep(1);  
  31.             continue;  
  32.         } else if (!rc)  
  33.             continue;  
  34.   
  35.         if (FD_ISSET(mCtrlPipe[0], &read_fds))  
  36.             break;  
  37.         if (mListen && FD_ISSET(mSock, &read_fds)) {  
  38.             struct sockaddr addr;  
  39.             socklen_t alen = sizeof(addr);  
  40.             int c;  
  41.   
  42.             if ((c = accept(mSock, &addr, &alen)) < 0) {  
  43.                 SLOGE("accept failed (%s)", strerror(errno));  
  44.                 sleep(1);  
  45.                 continue;  
  46.             }  
  47.             pthread_mutex_lock(&mClientsLock);  
  48.             mClients->push_back(new SocketClient(c));  
  49.             pthread_mutex_unlock(&mClientsLock);  
  50.         }  
  51.   
  52.         do {  
  53.             pthread_mutex_lock(&mClientsLock);  
  54.             for (it = mClients->begin(); it != mClients->end(); ++it) {  
  55.                 int fd = (*it)->getSocket();  
  56.                 if (FD_ISSET(fd, &read_fds)) {  
  57.                     pthread_mutex_unlock(&mClientsLock);  
  58.                     if (!<span style="color:#ff0000;">onDataAvailable(*it)</span>) {  
  59.                         close(fd);  
  60.                         pthread_mutex_lock(&mClientsLock);  
  61.                         delete *it;  
  62.                         it = mClients->erase(it);  
  63.                         pthread_mutex_unlock(&mClientsLock);  
  64.                     }  
  65.                     FD_CLR(fd, &read_fds);  
  66.                     pthread_mutex_lock(&mClientsLock);  
  67.                     continue;  
  68.                 }  
  69.             }  
  70.             pthread_mutex_unlock(&mClientsLock);  
  71.         } while (0);  
  72.     }  
  73. }  
      6.处理消息内容

      FrameworkListener::onDataAvailable(SocketClient *c)

//代码路径：AndroidSourcecode2.3/system/core/libsysutils/src/FrameworkListener.cpp

//对接收到的广播消息进行处理

view plain print ?
  1. bool FrameworkListener::onDataAvailable(SocketClient *c) {  
  2.     char buffer[255];  
  3.     int len;  
  4.   
  5.     if ((len = read(c->getSocket(), buffer, sizeof(buffer) -1)) < 0) {  
  6.         SLOGE("read() failed (%s)", strerror(errno));  
  7.         return false;  
  8.     } else if (!len)  
  9.         return false;  
  10.   
  11.     int offset = 0;  
  12.     int i;  
  13.   
  14.     for (i = 0; i < len; i++) {  
  15.         if (buffer[i] == '\0') {  
  16.             <span style="color:#ff0000;">dispatchCommand</span>(c, buffer + offset);  
  17.             offset = i + 1;  
  18.         }  
  19.     }  
  20.     return true;  
  21. }  
      7.分发指令

      FrameworkListener::dispatchCommand(SocketClient *cli, char *data)

//代码路径：AndroidSourcecode2.3/system/core/libsysutils/src/FrameworkListener.cpp

//分配指令：DumpCmd、VolumeCmd、AsecCmd、ShareCmd、StorageCmd、XwarpCmd

view plain print ?
  1. void FrameworkListener::dispatchCommand(SocketClient *cli, char *data) {  
  2.     FrameworkCommandCollection::iterator i;  
  3.     int argc = 0;  
  4.     char *argv[FrameworkListener::CMD_ARGS_MAX];  
  5.     char tmp[255];  
  6.     char *p = data;  
  7.     char *q = tmp;  
  8.     bool esc = false;  
  9.     bool quote = false;  
  10.     int k;  
  11.   
  12.     memset(argv, 0, sizeof(argv));  
  13.     memset(tmp, 0, sizeof(tmp));  
  14.     while(*p) {  
  15.         if (*p == '\\') {  
  16.             if (esc) {  
  17.                 *q++ = '\\';  
  18.                 esc = false;  
  19.             } else  
  20.                 esc = true;  
  21.             p++;  
  22.             continue;  
  23.         } else if (esc) {  
  24.             if (*p == '"')  
  25.                 *q++ = '"';  
  26.             else if (*p == '\\')  
  27.                 *q++ = '\\';  
  28.             else {  
  29.                 cli->sendMsg(500, "Unsupported escape sequence", false);  
  30.                 goto out;  
  31.             }  
  32.             p++;  
  33.             esc = false;  
  34.             continue;  
  35.         }  
  36.   
  37.         if (*p == '"') {  
  38.             if (quote)  
  39.                 quote = false;  
  40.             else  
  41.                 quote = true;  
  42.             p++;  
  43.             continue;  
  44.         }  
  45.   
  46.         *q = *p++;  
  47.         if (!quote && *q == ' ') {  
  48.             *q = '\0';  
  49.             argv[argc++] = strdup(tmp);  
  50.             memset(tmp, 0, sizeof(tmp));  
  51.             q = tmp;  
  52.             continue;  
  53.         }  
  54.         q++;  
  55.     }  
  56.   
  57.     argv[argc++] = strdup(tmp);  
  58. #if 0  
  59.     for (k = 0; k < argc; k++) {  
  60.         SLOGD("arg[%d] = '%s'", k, argv[k]);  
  61.     }  
  62. #endif  
  63.   
  64.     if (quote) {  
  65.         cli->sendMsg(500, "Unclosed quotes error", false);  
  66.         goto out;  
  67.     }  
  68.       
  69.     for (i = mCommands->begin(); i != mCommands->end(); ++i) {  
  70.         FrameworkCommand *c = *i;  
  71.   
  72.         if (!strcmp(argv[0], c->getCommand())) {  
  73.             if (c-><span style="color:#ff0000;">runCommand</span>(cli, argc, argv)) {  
  74.                 SLOGW("Handler '%s' error (%s)", c->getCommand(), strerror(errno));  
  75.             }  
  76.             goto out;  
  77.         }  
  78.     }  
  79.   
  80.     cli->sendMsg(500, "Command not recognized", false);  
  81. out:  
  82.     int j;  
  83.     for (j = 0; j < argc; j++)  
  84.         free(argv[j]);  
  85.     return;  
  86. }  
     8.开始执行挂载

     CommandListener::VolumeCmd::runCommand(SocketClient *cli,int argc, char **argv)

//代码路径：AndroidSourcecode2.3/system/vold/CommandListener.cpp

//rc = vm->mountVolume(argv[2]);

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

      VolumeManager::mountVolume(const char *label)

//代码路径：AndroidSourcecode2.3/system/vold/VolumeManager.cpp
//v->mountVol();

view plain print ?
  1. int VolumeManager::mountVolume(const char *label) {  
  2.     Volume *v = lookupVolume(label);  
  3.   
  4.     if (!v) {  
  5.         errno = ENOENT;  
  6.         return -1;  
  7.     }  
  8.   
  9.     return <span style="color:#ff0000;">v->mountVol();  
  10. </span>}  
    10.真正的挂载者

    Volume::mountVol()

//代码路径：AndroidSourcecode2.3/system/vold/Volume.cpp

//SD卡的挂载最终是在该方法中实现的，如果挂载有异常，也会在该方法的执行过程通过setState方法发出广播。

view plain print ?
  1. int Volume::mountVol() {  
  2.     dev_t deviceNodes[4];  
  3.     int n, i, rc = 0;  
  4.     char errmsg[255];  
  5.   
  6.     if (getState() == Volume::State_NoMedia) {  
  7.         snprintf(errmsg, sizeof(errmsg),  
  8.                  "Volume %s %s mount failed - no media",  
  9.                  getLabel(), getMountpoint());  
  10.         mVm->getBroadcaster()->sendBroadcast(  
  11.                                          ResponseCode::VolumeMountFailedNoMedia,  
  12.                                          errmsg, false);  
  13.         errno = ENODEV;  
  14.         return -1;  
  15.     } else if (getState() != Volume::State_Idle) {  
  16.         errno = EBUSY;  
  17.         return -1;  
  18.     }  
  19.   
  20.     if (isMountpointMounted(getMountpoint())) {  
  21.         SLOGW("Volume is idle but appears to be mounted - fixing");  
  22.         setState(Volume::State_Mounted);  
  23.         // mCurrentlyMountedKdev = XXX  
  24.         return 0;  
  25.     }  
  26.   
  27.     n = getDeviceNodes((dev_t *) &deviceNodes, 4);  
  28.     if (!n) {  
  29.         SLOGE("Failed to get device nodes (%s)\n", strerror(errno));  
  30.         return -1;  
  31.     }  
  32.   
  33.     for (i = 0; i < n; i++) {  
  34.         char devicePath[255];  
  35.   
  36.         sprintf(devicePath, "/dev/block/vold/%d:%d", MAJOR(deviceNodes[i]),  
  37.                 MINOR(deviceNodes[i]));  
  38.   
  39.         SLOGI("%s being considered for volume %s\n", devicePath, getLabel());  
  40.   
  41.         errno = 0;  
  42.         setState(Volume::State_Checking);  
  43.   
  44.         if (Fat::check(devicePath)) {//如果SD卡的格式不对是通不过这里的检测的  
  45.             if (errno == ENODATA) {  
  46.                 SLOGW("%s does not contain a FAT filesystem\n", devicePath);  
  47.                 continue;  
  48.             }  
  49.             errno = EIO;  
  50.             /* Badness - abort the mount */  
  51.             SLOGE("%s failed FS checks (%s)", devicePath, strerror(errno));  
  52.             setState(Volume::State_Idle);  
  53.             return -1;  
  54.         }  
  55.   
  56.         /* 
  57.          * Mount the device on our internal staging mountpoint so we can 
  58.          * muck with it before exposing it to non priviledged users. 
  59.          */  
  60.         errno = 0;  
  61.         if (Fat::doMount(devicePath, "/mnt/secure/staging", false, false, false,  
  62.                 1000, 1015, 0702, true)) {//真正的挂载方法doMount  
  63.             SLOGE("%s failed to mount via VFAT (%s)\n", devicePath, strerror(errno));  
  64.             continue;  
  65.         }  
  66.   
  67.         SLOGI("Device %s, target %s mounted @ /mnt/secure/staging", devicePath, getMountpoint());  
  68.   
  69.         protectFromAutorunStupidity();  
  70.   
  71.         if (createBindMounts()) {  
  72.             SLOGE("Failed to create bindmounts (%s)", strerror(errno));  
  73.             umount("/mnt/secure/staging");  
  74.             setState(Volume::State_Idle);  
  75.             return -1;  
  76.         }  
  77.   
  78.         /* 
  79.          * Now that the bindmount trickery is done, atomically move the 
  80.          * whole subtree to expose it to non priviledged users. 
  81.          */  
  82.         if (doMoveMount("/mnt/secure/staging", getMountpoint(), false)) {  
  83.             SLOGE("Failed to move mount (%s)", strerror(errno));  
  84.             umount("/mnt/secure/staging");  
  85.             setState(Volume::State_Idle);  
  86.             return -1;  
  87.         }  
  88.         setState(Volume::State_Mounted);  
  89.         mCurrentlyMountedKdev = deviceNodes[i];  
  90.         return 0;  
  91.     }  
  92.   
  93.     SLOGE("Volume %s found no suitable devices for mounting :(\n", getLabel());  
  94.     setState(Volume::State_Idle);  
  95.   
  96.     return -1;  
  97. }  


      到这里SD卡的挂载基本上已经完成，但是我们的目的是理清一条从底向上的路线,因此我会继续向上分析。我会将这一点在下一篇博文《Android 2.3 SD卡挂载流程浅析(五)》中继续分析。

     因为这些都是我个人的一些见解，因此不见得都正确，希望读者抱着怀疑的态度阅读。不过不是有句名言叫“大胆假设，小心求证”吗！如文中有错误，还恳请各位看官指正。



yihongyuelan
关注
专栏目录
Android 2.3 SD卡挂载流程浅析(一)
Keep Awake,Keep Studying,Keep Moving,Keep...
11-01 2万+
Android 2.3中关于SD卡挂载简介       在Android 2.3中，当SD卡插入系统之后，系统会自动挂载。Vold 就是负责挂载SD卡的，vold 的全称是volume daemon。实际上是负责完成系统的CDROM,USB 大容量存储，MMC 卡(后文有简介，具体请百度)等扩展存储的挂载任务自动完成的守护进程。它提供的主要特点是支持这些存储外设的热插拔。在Android上的这个
Android 2.3 SD卡挂载流程浅析(七)
Keep Awake,Keep Studying,Keep Moving,Keep...
11-25 7125
前面六篇文章：       《Android 2.3 SD卡挂载流程浅析(一)》       《Android 2.3 SD卡挂载流程浅析(二)》       《Android 2.3 SD卡挂载流程浅析(三)》       《Android 2.3 SD卡挂载流程浅析(四)》       《Android 2.3 SD卡挂载流程浅析(五)》
android sd 挂载流程_AndroidSD卡挂载流程浅析
weixin_39853892的博客
12-20 775
/devices/platform/msm_sdcc.2/mmc_host/mmc1##Exampleofadualcardsetup#dev_mountleft_sdcard/sdcard1auto/devices/platform/goldfish_mmc.0/devices/platform/msm_sdcc.2/mmc_host/mmc1#dev_mountright...
android sd 挂载流程_Android 2.3 SD卡挂载流程浅析
weixin_30768979的博客
01-12 397
前面的三篇《Android 2.3 SD卡挂载流程浅析(一) http://www.linuxidc.com/Linux/2011-11/47136.htm》、《Android 2.3 SD卡挂载流程浅析(二) http://www.linuxidc.com/Linux/2011-11/47136p2.htm》、《Android 2.3 SD卡挂载流程浅析(三) http://www.linuxi...
SD卡挂载
luojianbing1的专栏
04-12 4029
<br />在 s3c6410平台上移植android2.3 过程中SD卡总是不能自动挂载。 查阅相关资料，知道在android2.3中是 vold程序负责检查内核的 sysfs 文件系统，发现有SD卡插入后，自动挂载。 在文件系统目录 /system/etc/  下有一个vold.fstab 文件，该文件是系统与用户硬件平台的交互接口，用户根据自己的平台来配置这个文件，里面内容比较简单，只需要你指定sys下vold程序需要查询的文件夹 路径，当SD卡插入设备后，这个路径下会产生相应的文件，v
Android23SD卡挂载流程浅析.docx
04-20
### Android 2.3 SD卡挂载流程浅析 #### 一、概述 在Android 2.3系统中，对于外部存储设备如SD卡的管理采用了一种较为成熟且自动化的机制。当用户将SD卡插入设备时，系统能够自动识别并完成挂载操作，使用户可以...
Android 2.3 SD卡挂载流程浅析(六)
Keep Awake,Keep Studying,Keep Moving,Keep...
11-18 8721
前面五篇文章：      《Android 2.3 SD卡挂载流程浅析(一)》      《Android 2.3 SD卡挂载流程浅析(二)》      《Android 2.3 SD卡挂载流程浅析(三)》      《Android 2.3 SD卡挂载流程浅析(四)》      《Android 2.3 SD卡挂载流程浅析(五)》        在这五篇文章中，简单的分析了将SD卡插
Android 2.3 SD卡挂载流程浅析(五)
Keep Awake,Keep Studying,Keep Moving,Keep...
11-15 1万+
前面四篇博文：《Android 2.3 SD卡挂载流程浅析(一)》、《Android 2.3 SD卡挂载流程浅析(二)》、《Android 2.3 SD卡挂载流程浅析(三)》、《Android 2.3 SD卡挂载流程浅析(四)》主要是对SD卡的挂载流程从底到上的一个分析，本文将继续接着《Android 2.3 SD卡挂载流程浅析(四)》文章分析，前文主要分析了C/C++的一些代码，本文将主
Android 2.3 SD卡挂载流程浅析(三)
热门推荐
Keep Awake,Keep Studying,Keep Moving,Keep...
11-12 2万+
在前面两篇博文《Android 2.3 SD卡挂载流程浅析(一)》《Android 2.3 SD卡挂载流程浅析(二)》中，主要简单介绍了SD卡的挂载流程以及所涉及的关键文件。在《Android 2.3 SD卡挂载流程浅析(三)》中，将简要介绍Android 2.3中Vold的运行机制，并从接收内核uevent开始介绍程序调用流程。       1. Vold      Vold的全
android存储设备挂载流程
06-13
android存储设备挂载流程 TK挂载流程和android源码流程有细微差别，文档是MTK流程
android4.2 sd卡挂载流程图
10-22
本文档基于android4.2平台，sd卡热插拔在android层是如何传递消息
Android 9.0 Vold 挂载流程分析
01-21
在Android 系统中所有的热插拔设备都是通过Vold 进程挂载的。通过kernel–>vold–>StorageManagerService这样的架构去逐级上报热插拔事件。 一、Vold 入口 --> /system/vold/main.c int main(int argc, char** argv) { atrace_set_tracing_enabled(false); setenv(ANDROID_LOG_TAGS, *:v, 1); android::base::InitLogging(argv, android::base::LogdLogger
sd卡挂载软件
12-14
该软件仅供个人学习用，如需需要请前往Google play购买正版，下载24小时内请删除软件。
Android7.0 SD卡挂载流程
liu362732346的博客
06-19 6657
                            Android7.0 SD卡挂载流程序言：这是7.0时候的总结，8.0MountService改名成了StorageManageService，懒得再重新总结，直接把7.0的总结贴上这篇文章是对上层T卡挂载的流程总结，涉及到的主要类介绍：MountService：Android Binder服务，运行在system_server进程，用于跟V...
Android 2.3 SD卡挂载流程浅析
haima1998的专栏
11-13 1068
转自：http://blog.csdn.net/yihongyuelan/article/details/6930112 和转自：http://blog.csdn.net/ken_GL/article/details/6050168 NetlinkManager中通过socket来接收来自kernel的event，获取设备的插拔信息。  在上一篇博文《Androi
android volume挂载流程,Android SDCard UnMounted 流程分析（一）
weixin_34083972的博客
05-31 396
Android SDCard框架Android SDCard框架，我们修改一般涉及到四大模块Linux Kernel 用于检测热拔插，作为框架开发者来说，这者不用涉及Vold 作为Kernel 与 Framework 之间的桥梁Framework 操作Vold ,给Vold 下发操作命令UI　与Framework 交互，用于挂载/卸载SD卡框架涉及的源码位置Vold :System/vold为vo...
linux 挂载 SD 卡
苏轼圈
12-13 1万+
最近需要将板载 rootfs 镜像中的某个可执行文件提取到电脑上。利用 SD 卡可以做到。 下面的命令对 EMMC 也适用 主要思路是在 rootfs 起来之后通过 mount 命令去挂载 SD 卡的某分区到指定位置，然后复制需要的文件到这个指定位置。再使用 umount 命令解挂 SD 卡。这样，需要的东西就在 SD 卡里面了。 在挂载过程中，遇到很多问题，总结步骤如下： 1：确保 SD 卡插上后能识别，也就是终端有打印，否则，可能是硬件原因，也有可...
Ubuntu学习（一）——将 SD 卡挂载到 Ubuntu 的 home 目录
最新发布
nb32704160916的博客
07-13 567
【代码】Ubuntu学习（一）——将 SD 卡挂载到 Ubuntu 的 home 目录。
mount命令挂载sd卡
qq_41483419的博客
10-20 1216
mount
"分析Android23SD卡挂载流程及vold.fstab文件内容
Android23版本的SD卡挂载流程可以通过分析"Android23SD卡挂载流程浅析.doc"和"vold.fstab"文件中的内容来进行深入研究。在这篇总结中，将会详细介绍SD卡的挂载过程，并探讨vold.fstab文件中的相关内容，最终得出结论...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值