Android—— 4.2 Vold挂载管理_mmcblk内置-双sdcard (八)

标签：sdcard   mount   mmcblock   fatext4   uuid   

      Vold的学习过了一段时间了，才想着把mmcblock内置成sdcard的方法记录一下。

当初就是因为要做这个功能才去学习Vold机制，贴出之前的博客：

Android—— 4.2 Vold挂载管理_主体构建main (一)

Android—— 4.2 Vold挂载管理_CommandListener (二)

Android—— 4.2 Vold挂载管理_VolumeManager (三)

Android—— 4.2 Vold挂载管理_NetlinkManager (四)

Android—— 4.2 Vold挂载管理_DirectVolume/Volume (五)

Android—— 4.2 Vold挂载管理_MountService (六) 

Android—— 4.2 Vold挂载管理_Kernel_USB_Uevent (七) 

个人认为把上面的脉络理清了，Vold应该算是基本掌握了，其中的细节部分就需要另行研究了。

                                                 撰写不易,转载请注明出处：http://blog.csdn.net/jscese/article/details/39692953

一.准备：

   不同平台的mmc分区方案和烧写emmc方式不一样，总之划分一块区域用来当sdcard挂载，并且记住block序号，android的分区类型在linux下制作一般都是ext4格式。

可在BoardCondif.mk中添加宏控制：

BOARD_MMCBLK_AS_SDCARD := 13
#jscese open mmcblk0p13 as sdcard to mount 140724#

并且在/system/vold/Android.mk 中添加编译选项：

ifneq ($(BOARD_MMCBLK_AS_SDCARD),)
  common_cflags := -DMMCBLK_AS_SDCARD=$(BOARD_MMCBLK_AS_SDCARD)
endif

LOCAL_CFLAGS := $(common_cflags)

二.Vold挂载：

在/system/vold/VolumeManager.cpp 中的 handleBlockEvent 中添加特殊处理。

核心添加如下：

    const char *devtype = evt->findParam("DEVTYPE");
    const char *dn = evt->findParam("DEVNAME");

    int major = -1;
    int minor = -1;

    bool isRawDisk = false;
    bool isPartition = false;

    int partIdx = -1;
    bool isSDCard = false;

    major = atoi(evt->findParam("MAJOR"));
    minor = atoi(evt->findParam("MINOR"));

 if (major == 179) {

        if (strncmp(dn,"mmcblk0",7) == 0) {//判断是否为mmc的block
#ifndef MMCBLK_AS_SDCARD
            return;
#endif
        }
       if (strcmp(dn,"mmcblk0p13") == 0)
        SLOGD("jscese display in vm - handle-isSDCard = true\n");
        isSDCard = true;
    }

    snprintf(device,255,"/dev/block/vold/%d:%d",major,minor);

  if (strcmp(devtype,"disk") == 0) { //根据设备类型就行判断
        const char *nparts = evt->findParam("NPARTS");
        if (nparts) {


            int diskNumParts = atoi(nparts);
            isRawDisk = (diskNumParts == 0);
        } else {
            return ;
        }
    } else {
        const char *tmp = evt->findParam("PARTN");
        if (tmp == NULL) {
            return;
        }



        partIdx = atoi(tmp);
//        if (strcmp(dn,"mmcblk0p14") == 0)
        SLOGD("jscese display in vm - handle- isPartition = true\n");
        isPartition = true;
    }

以上是对从kernel发过来的event信息进行一些筛选，下面就需要对device以及Volume进行特殊处理：

  if (isRawDisk || isPartition) {
        //first find uuid from cache
        UUIDCache::Entry *entry = uuidCache.searchEntry(device); /dev uuid缓存

        if (evt->getAction() == NetlinkEvent::NlActionAdd) {
            mode_t mode = 0660 | S_IFBLK;
            dev_t dev = (major << 8) | minor;

            //if device has been now added, not add again
            if (entry != NULL && entry->uuid != NULL) {
                return;
            }

            if (mknod(device, mode, dev) < 0) {//没有即创建节点
                if (errno != EEXIST) {
                    return ;
                }
            }
            if (!getVolumeUUID(device, uuid, 255)) {//获取uuid
        #ifdef NETLINK_DEBUG
                SLOGD("can not get the uuid of %s when device add",device);
        #endif

          return;

             }

      }

//Volume容器中添加处理，针对上面的uuid

        for (it = mVolumes->begin(); it != mVolumes->end(); ++it) {
            if (strcmp(uuid, (*it)->getLabel()) == 0) {

         (*it)->handleBlockEvent(evt);

          hit = true;

       if (evt->getAction() == NetlinkEvent::NlActionAdd) {
                    //if device was added at before, so cache its uuid and device path again
                    uuidCache.addEntry(device,uuid);
                    (*it)->setDevicePath(device);

                     }

         ...

       }

   }

 }

 if (!hit) {
        static char index = 'a'-1;
        char * mountPoint = NULL;
        const char *dp = NULL;
        DirectVolume * volume = NULL;

    #ifdef NETLINK_DEBUG

        SLOGW("No volumes handled block event for '%s'", devpath);
    #endif

        if (evt->getAction() != NetlinkEvent::NlActionAdd)
        {

          return;

         }


        dp = evt->findParam("DEVPATH");
        if (dp == NULL) {
            return;
        }

           SLOGD("jscese display in vm  for 1 mVolumes and isSDCard ==%d, isPartition+=%d \n",isSDCard,isPartition);
        /* Determine its mount point */
        if (isSDCard) {   //根据上面来的筛选
            if (isRawDisk) {
                asprintf(&mountPoint,"/mnt/sdcard_external");
            } else if (isPartition) {
#ifdef MMCBLK_AS_SDCARD
                if (partIdx == MMCBLK_AS_SDCARD) { //根据boardconfig中定义的block来设置挂载点
                    asprintf(&mountPoint,"/mnt/sdcard");
                    SLOGD("jscese display set mountpoint fuck mmcblock %d as sdcard\n",partIdx);
                }

#else
                if (partIdx == 1) { //外部的SD卡挂载点 改为 /mnt/sdcard_external
                    asprintf(&mountPoint,"/mnt/sdcard_external");
                } else {
                    asprintf(&mountPoint,"/mnt/usb/%s",dn);
                }
#endif
            }
        }

      volume = new DirectVolume(this,uuid,mountPoint,partIdx);
        //cache the device path of device
        volume->setDevicePath(device);
        free(mountPoint);

        mVolumesLock.lock();
        addVolume(volume);
        mVolumesLock.unlock();

        //cache the uuid of device
        uuidCache.addEntry(device, uuid);

        if ( volume->handleBlockEvent(evt) !=0 ) {
            SLOGD("New add volume fail to handle the event of %s",devpath);
        }

     }

UUID的cache接口如下：

static bool getVolumeUUID(const char* path, char* buf, int size) {
    blkid_cache cache = NULL;
    blkid_dev dev = NULL;
    blkid_tag_iterate iter = NULL;
    const char *type = NULL, *value = NULL;
    bool ret = false;

    if (path == NULL || buf == NULL || size < 0) {
        return false;
    }

    if (blkid_get_cache(&cache, NULL) < 0) {
        return false;
    }

    dev = blkid_get_dev(cache, path, BLKID_DEV_NORMAL);
    if (dev == NULL) {
        return false;
    }
    iter = blkid_tag_iterate_begin(dev);
    while (blkid_tag_next(iter, &type, &value) == 0) {
        if (strcmp(type,"UUID") == 0) {
            int n = strlen(value);
            if (n > size) {
                n = size;
            }
            ret = true;
            strncpy(buf,value,n);
            buf[n] = '\0';
        }
    }
    blkid_tag_iterate_end(iter);
    blkid_put_cache(cache);
    return ret;
}

class UUIDCache {
public:
    struct Entry {
        char *device;
        char *uuid;
    };

    UUIDCache() {
        uuidCache = new EntryCollection();
    }

    ~UUIDCache() {
        delete uuidCache;
    }

    void addEntry(const char *device, const char *uuid) {
        Entry *entry = NULL;
        if (device == NULL || uuid == NULL) {
            return;
        }

        entry = searchEntry(device);
        if (entry == NULL) {
            entry = new Entry();
            entry->device = strdup(device);
            uuidCache->push_back(entry);
        } else {
            if (entry->uuid != NULL) {
                free(entry->uuid);
            }
        }
        entry->uuid = strdup(uuid);
    }

    Entry *searchEntry(const char *device) {
        EntryCollection::iterator it;
        for (it = uuidCache->begin(); it != uuidCache->end(); ++it) {
            if ((*it)->device != NULL && strcmp((*it)->device, device) == 0) {
                return(*it);
            }
        }
        return NULL;
    }

private:
    typedef android::List<Entry *> EntryCollection;
    EntryCollection *uuidCache;
};

static UUIDCache uuidCache;

最后执行到挂载的Volume.cpp中的 mountVol 中。修改添加如下：

  if (primaryStorage) {
            // Special case the primary SD card.
            // For this we grant write access to the SDCARD_RW group.
            gid = AID_SDCARD_RW;
        } else {
            // For secondary external storage we keep things locked up.
            gid = AID_MEDIA_RW;
        }
        SLOGE("jscese display in Volume-mountVol devicepath==%s , gid ==%d \n",devicePath,gid);
        bool isFatFs = true;
        bool isNtfsFS = true;
        bool isExtFs = true;
        if(isFatFs) {
             SLOGE("jscese Fat::doMount \n");
        if (Fat::doMount(devicePath, "/mnt/secure/staging", false, false, false,
                    AID_SYSTEM, gid, 0002, true)) {
            SLOGE("%s failed to mount via VFAT (%s)\n", devicePath, strerror(errno));
                isFatFs = false;
            } else {
                isNtfsFS = false;
                isExtFs = false;
            }
        }
/*===jscese add for format mmcblock ext4_type to vfat_type as sdcard 140805=====*/
#ifdef MMCBLK_AS_SDCARD
        if(!isFatFs)
        {
            char checkmmcblokPath[255];
//            sprintf(devicePath, "/dev/block/vold/%d:%d", MAJOR(deviceNodes[i]), MINOR(deviceNodes[i]));
            sprintf(checkmmcblokPath, "/dev/block/vold/%d:%d", SD_MAJOR,MMCBLK_AS_SDCARD);
            SLOGE("jscese Volume::mountvol format checkmmcblockpath= %s,  devicepath==%s , mountpoint==%s\n",checkmmcblokPath,devicePath,getMountpoint());
            if(!strcmp("/mnt/sdcard",getMountpoint()))
            {
                if(!strcmp(checkmmcblokPath,devicePath))
                {
                    setState(Volume::State_Idle);
                    SLOGE("jscese Volume::mountvol format 1 label== %s\n",getLabel());
                    if(formatVol()==0)
                    {
                        setState(Volume::State_Checking);
                        SLOGE("jscese Volume::mountvol format over \n");
                        if (Fat::doMount(devicePath, "/mnt/secure/staging", false, false, false,
                                        AID_SYSTEM, gid, 0002, true))
                        {
                            SLOGE("%s failed to mount via VFAT 2 (%s)\n", devicePath, strerror(errno));
                            isFatFs = false;
                        }
                        else
                        {
                            isFatFs=true;
                            isNtfsFS = false;
                            isExtFs = false;
                        }

                    }
                }
            }
        }
#endif
/*===============end================*/

因为我发现，如果以ext4形式挂载的/mnt/sdcard  这时分区中文件的创建权限只有创建者 才能有可读写权限，并不是根据/mnt/sdcard来规定权限。

此时各个应用进程在/mnt/sdcard创建的文件夹，其它用户就无权访问了，失去了sdcard应有的价值！

所以这里要先格式化成FAT，之后的分区中的创建权限全又挂载点也就是/mnt/sdcard来规定！

上层框架不用改动，这样就可以实现mmc的一个block内置成sdcard供应用程序使用，同时外部插入的sdcard将被挂载到/mnt/sdcard_external下。

Android—— 4.2 Vold挂载管理_mmcblk内置-双sdcard (八)

标签：sdcard   mount   mmcblock   fatext4   uuid   

原文地址：http://blog.csdn.net/jscese/article/details/39692953