首页  流程图  详情

Android6.0 sdcard流程

2024-01-08 16:31:03   0  举报





仅支持查看

文件系统完成流程图

文件系统架构流程

作者其他创作

大纲/内容

case 'u':

android\\system\\vold\\Disk.cpp

创建工作线程，线程运行函数threadStart

vm = VolumeManager::Instance()

vol->create();

system/vold/CommandListener.cpp

创建匿名管道

PublicVolume::doMount()

else

nm->setBroadcaster((SocketListener *) cl);

mDiskSources.push_back(diskSource);

通过inotify机制观察/data/system/packages.list文件变化

NativeDaemonConnector.java

watch_package_list(&global)

cryptfs_revert_ext_volume(getId().c_str());

doUnmount()

//创建event socket

1. 设置挂载路径

Vold的service定义如下

readMetadata();

HandlerThread hthread = new HandlerThread(TAG);hthread.start();

创建单例对象NetlinkManager

android\\system\\vold\\VolumeBase.cpp

ForceUnmount(mFuseDefault);

mInternalEmulated->create()

if (cmd == \"shutdown\

建立连接后，回调MS.onDaemonConnected

PrivateVolume使用外置存储来模拟内置存储，需要挂载mDmDevPath作为存储设备（需要对数据进行加密/解密），然后对为该设备的media节点创建一个EmulatedVolume，来模拟外置存储使用。这里总结下EmulatedVolume， /data分区作为一个内置存储，如果使用模拟分区作为主存储则会创建一个EmulatedVolume来模拟外置存储，目录为/data/media。其他的PrivateVolume下再这里创建一个EmulatedVolume，会通过MountService有模拟分区创建，如果该模拟分区是主存储分区，则会挂载该模拟分区，如果不是主分区，则不会挂载该模拟分区，为PrivateVolume创建EmulatedVolume，并不一定会被挂载，只有模拟的主分区才会被挂载。读者可以回过头来看看MountService中处理新家卷的时候对EmulatedVolume的处理，如果系统设置了使用PrivateVolume作为主存储的话，可以将主存储建迁移PrivateVolume对应的EmulatedVolume，我们在存储格式化的文章中将会看到这一点

mCommands->push_back(cmd);

fstab = fs_mgr_read_fstab(path.c_str());

EmulatedVolmue创建

else if (cmd == \"mount\" && argc > 2)

found.responses.put(response);

android::vold::ForceUnmount(path);

1023

3 创建相关的文件夹

while(1) { sleep(1000);}

NetlinkManager.cpp

PublicVolume::doCreate()

FrameworkListener::onDataAvailable(SocketClient *c)

mLabel = tmp;

if (mSystemReady && mDaemonConnected)

if (getMountFlags() & MountFlags::kPrimary)

new DiskSource对象，添加到mDiskSources中

this->startListener()

设置uevent的SO_PASSCRED选项

handleBlockEvent的逻辑实际上是比较简单的，从NetlinkEvent中获取主，次设备号，和ueventuevent对应的设备文件的/sys/block路径。对于add消息，根据主设备号确定设备的类型是usb还是sd卡。从NetlinkEvent中获取uevent对应的设备文件的/sys/block路径，然后和DiskSource做比较，确定是不是对应voldmanaged标志的设备，如果是voldmanaged的设备就会创建Disk数据结构，再调用Disk.create()函数执行初始化。将初始化好的Disk数据结构保存起来。对于change消息，则重新读取设备的meta信息和分区信息。remove消息则调用Disk.destory()函数，从mDisks中移除Disk数据结构。

通知VolumeCreated事件

将新建的CommandListener对象赋值给mBroadcaster

ForceUnmount(mFuseWrite);

android\\system\\core\\sdcard\\sdcard.c

/dev下的设备路径

mCtrlPipe是匿名管道，这是一个二元数组，mCtrlPipe[0]从管道读数据，mCtrlPipe[1]从管道写数据。

？？实际测试改目录没有任何文件

f (table == Table::kUnknown || !foundParts)

public void onStart()

PublicVolume.cpp

case 'm':

int NetlinkManager::start()

class CommandListener : public FrameworkListenerclass FrameworkListener : public SocketListener

android\\frameworks\\base\\services\\core\\java\\com\\android\\server\\MountService.java

if (mJustPartitioned)

FrameworkListener.cpp

if (cmd == \"mount\

PublicVolume : public VolumeBase

if (devType != \"disk\") return;

4 设置gid，保证拥有source_path的读写权限

通过socket向MountService发送创建volume的命令(650)

PublicVolume作为外置存储，先通过mount进行挂载，然后为了实现外置存储的读写权限，使用fuse来进行挂载。另外如果设备要对用户可见，就将/storage/${stable} 作为对外使用的路径，我们分析外置存储的时候会对这个路径加以说明。如果这个PublicVolume作为主存储，需要使用fuse的fullwrite模式，否则不使用该模式。

cl = new CommandListener();

main.cpp

转mountService的onEvent

publishBinderService(\"mount\

2 挂载对应的fuse目录

等待mConnectedSignal计数锁达到零

1 解析参数配置相应的变量值

readPartitions()

处理文件操作请求

coldboot(\"/sys/block\");

/解析socket服务端发送的event

？？？？？读取分区信息

source_path = arg;

me->runListener();

分发MountService读取到的命令

warnOnNotMounted();

mRawPath = StringPrintf(\"/mnt/media_rw/%s\

status_t VolumeBase::mount()

setBroadcaster(SocketListener *sl)

创建这些对象 DumpCmd，VolumeCmd，AsecCmd，ObbCmd，StorageCmd，FstrimCmd，并都加入到mCommands队列

VolumeManager *VolumeManager::Instance()

卸载外部存储

if (cmd == \"\"partition\" && argc > 3\

Disk创建

用于监听Kernel发送过程的uevent事件

//调用PMS来加载ASECs

int VolumeManager::start()

//解析fstab.sun8w11p1内容

for (auto source : mDiskSources)

NetlinkHandler.cpp

Aciton：kAdd，这个函数先创建了设备，根据major和minor。从mDiskSources看是否有满足的DiskSource，然后获取其flags，然后新建Disk，调用create函数

getMountService().getSecureContainerList();

mFuseDefault = StringPrintf(\"/mnt/runtime/default/%s\

解析Fstab

PrivateVolume::doMount()

类型为CountDownLatch，用于多线程同步，阻塞await()直到计数器为零

这是用于分发从MountService发送过来的命令，针对不同的命令调用不同的类，总共有以下6类：DumpCmdVolumeCmdAsecCmdObbCmdStorageCmdFstrimCmd另外，在处理过程中遇到下面情况，则会直接发送响应吗500的应答消息给MountService，当无法找到匹配的类，则会直接向MountService返回响应码500，内容”Command not recognized”的应答消息；命令参数过长导致socket管道溢出，则会发送响应码500，内容”Command too long”的应答消息。

registerCmd(new DumpCmd());registerCmd(new VolumeCmd());registerCmd(new AsecCmd());registerCmd(new ObbCmd());registerCmd(new StorageCmd());registerCmd(new FstrimCmd());

启动响应命令的SocketListener监听器

if (source->matches(eventPath))

创建了一个DiskInfo数据结构

vol->setDiskId(getId());

FrameworkListener::registerCmd(FrameworkCommand *cmd)

创建CommandListener对象

disk->unmountAll();

Vold成为监听线程

sInstance = new VolumeManager();

handleDaemonConnected()

mSystemServiceManager.startService(MOUNT_SERVICE_CLASS); mountService = IMountService.Stub.asInterface( ServiceManager.getService(\"mount\"));

KillProcessesUsingPath(getPath());

Android存储系统之架构篇

1 准备fuse相关的文件夹

如果一个EmulatedVolume被挂载，它一定是一个主分区，没啥可说对mRawPath目录做fuse模拟。

cl.startListener

由继承关系可知，onDataAvaliable会回调到NetlinkListener和FrameworkListener的onDataAvailable方法

setuid(uid)

init.rc

sdcard.c

设备的唯一id，默认disk:${主设备号}😒{次设备号}

Disk::createPublicVolume(dev_t device)

coldboot实现的功能就是遍历path下所有的uevent文件，然后写入”add\“四个字节到uevent文件（175行）。uevent主要是udev协议的一部分，当设备进行热插拔的时候，上层应用程序可以通过netlink收到相应的add，remove，change等消息，这样就可以调用mknod在/dev/目录下创建对应的驱动设备文件，这样才可以使用设备文件来操作设备。在vold的启动过程中，由于块设备早就准备好了，不会收到设备插拔的消息，没有办法对固有的设备来创建对应的Disk和Volume结构。好在udev提供了一套机制，就是可以通过写uevent来触发热插拔事件，这里写入add就代表触发一个设备插入事件。前面我们已经启动了NetlinkManager来监听netlink事件，这里来触发uevent的设备插入事件，VolumeManager就可以创建相应的Disk和Volume数据结构了。

status_t Disk::create()

android\\system\\vold\\NetlinkManager.cpp

kPackagesListFile = \"/data/system/packages.list\":使用inotify观察/data/system/packages.list文件删除事件，当安装或者卸载应用后，该文件就会重建

status_t VolumeBase::create()

mDevPath = StringPrintf(\"/dev/block/vold/%s\

强制卸载“/proc/mounts”中目录包含mnt或者storage的路径

onEvent(evt);

case 0x06:....

mbr分区表直接创建PublicVolume

mConnector.execute(\"volume\

case 'w':

auto vol = std::shared_ptr<VolumeBase>(new PublicVolume(device));

Disk.cpp

读取socket内容

mDevPath = StringPrintf(\"/dev/block/vold/%s\

(mount(\"/dev/fuse\

mHandler.obtainMessage(H_SYSTEM_READY).sendToTarget();

frameworks\\base\\services\\core\\java\\com\\android\\server\\pm\\PackageManagerService.java

android\\system\\vold\\NetlinkHandler.cpp

创建线程名为\"VoldConnector\"的线程，用于跟vold通信

创建Emulated内部存储

采用poll轮询方式等待底层上报该事件，直到1分钟超时（ReentrantLock和synchronized区别）

struct fuse_handler* handler = data;

android\\system\\core\\libsysutils\\src\\NetlinkListener.cpp

socket.connect(address);

int res = vol->mount();

setPath(StringPrintf(\"/storage/%s\

MountService 和vold 对外置存储的管理（2）

on post-fs-datastart vold //启动vold服务

VolumeBase.cpp

PublicVolume的创建首先创建一个PublicVolume实例，然后如果Disk刚刚进行分区，要先进行格式化。mJustPartitioned为true的情况进行格式化，这不是我们关注的重点。创建完PublicVolume实例后最重要的是调用create函数来创建

onVolumeCreatedLocked(vol);

mActivityManagerService.systemReady(new Runnable() { public void run() {mSystemServiceManager.startBootPhase( SystemService.PHASE_ACTIVITY_MANAGER_READY); }}

case kMajorBlockScsiA:.......

mVolumes.push_back(vol);

while (true) {listenToSocket();}

用于通知ASEC扫描已完成

NetlinkHandler::onEvent(NetlinkEvent *evt)

转VolumeManager::handleBlockEvent

case FUSE_OPEN:

const char* cpath = path.c_str();

socket = new LocalSocket();

int NetlinkHandler::start()

std::shared_ptr<android::vold::VolumeBase> VolumeManager::findVolume(const std::string& id)

创建单例对象VolumeManager

public void run()

handle_fuse_requests(struct fuse_handler* handler)

对于add消息，根据主设备号确定设备的类型是usb还是sd卡。从NetlinkEvent中获取uevent对应的设备文件的/sys/block路径，然后和DiskSource做比较，确定是不是对应voldmanaged标志的设备，如果是voldmanaged的设备就会创建Disk数据结构，再调用Disk.create()函数执行初始化。将初始化好的Disk数据结构保存起来。对于change消息，则重新读取设备的meta信息和分区信息。remove消息则调用Disk.destory()函数，从mDisks中移除Disk数据结构。

vol->setSilent(true);vol->create();vol->format(\"auto\");vol->destroy();vol->setSilent(false);

std::string path(mSysPath + \"/device/manfid\");

EmulatedVolume::doUnmount()

int SocketListener::startListener()

mInternalEmulated的据类型为EmulatedVolume，设备路径为/data/media，id和label为“emulated”，mMountFlags=0。EmulatedVolume继承于VolumeBase

调用mknod 创建dev设备文件，目录为/dev/block/vold/。相当于vold实现了部分udev的功能

//通过getprop ro.hardware获取Fstab路径：./fstab.sun8iw11p1

frameworks\\base\\services\\java\\com\\android\\server\\SystemServer.java

mCommands = new FrameworkCommandCollection();

SocketListener *me = reinterpret_cast<SocketListener *>(obj);

label = \"emulated\"

mFuseRead = StringPrintf(\"/mnt/runtime/read/%s\

NetlinkManager的start方法

android\\system\\vold\\EmulatedVolume.cpp

2 将消息转成fuse_in_header + data 两部分

unmountAll();

if (!(mFusePid = fork()))

mOutputStream.write(rawCmd.getBytes(StandardCharsets.UTF_8));

cmd.push_back(kSgdiskPath);//\"/system/bin/sgdisk\";

mSock = socketFd;

setId(StringPrintf(\"public:%u:%u\

// 有写外置存储权限，只有在全写模式下树主才有写权限，否则只有读权限

mEventPath = eventPath;

waitForReady();

FgThread线程名为“\"android.fg\"，创建IMountServiceListener回调方法

for (it = mClients->begin(); it != mClients->end(); ++it) {SocketClient* c = *it;pendingList.push_back(c);}

内部私有volume的路径为/data，该volume通过dumpsys mount是不会显示的

if (type == \"private\

case FUSE_WRITE:

uevent文件路径

for (auto line : output)

handleMessage(Message msg)

addInternalVolume();

根据命令找到对应卷，然后调用VolumeBase的mount方法进行挂载

PrivateVolume::doCreate()

std::string path(android::vold::DefaultFstabPath());

status_t res = doMount();

mObbActionHandler = new ObbActionHandler(IoThread.get().getLooper());

process_config(vm)

mInternalEmulated = std::shared_ptr<android::vold::VolumeBase>( new android::vold::EmulatedVolume(\"/data/media\"));

final String[] list = PackageHelper.getSecureContainerList();

卸载内部存储

。。。。。

destroyAllVolumes();

MountServiceHandler::handleMessage(Message msg)

android\\system\\vold\\Utils.cpp

mFuseWrite = StringPrintf(\"/mnt/runtime/write/%s\

分区类型为Android扩展，创建一个私有分区

status_t VolumeBase::unmount()

frameworks\\base\\services\\core\\java\\com\\android\\server\\SystemServiceManager.java

创建dev设备

1 读取卷的信息

VolumeManager::handleBlockEvent(NetlinkEvent *evt)

分区类型为基础数据分区，代表一个PublicVolume

mPms.scanAvailableAsecs();

public void onBootPhase(int phase)

android\\system\\vold\\PrivateVolume.cpp

创建用于VoldConnector的NDC对象

NetlinkHandler继承于NetlinkListener，NetlinkListener继承于SocketListener。new NetlinkHandler(mSock)中参数mSock是用于与Kernel进行通信的socket对象。

private void listenToSocket()

卸载所有卷

read_package_list(global)

5 fork新进程启动sdcard

NetlinkEvent *evt = new NetlinkEvent()

mPath = StringPrintf(\"/mnt/expand/%s\

setState(State::kUnmounted);

public void onDaemonConnected()

nladdr.nl_pid = getpid();

case VoldResponseCode.DISK_CREATED:

Android存储系统-MountService 和vold 对外置存储的管理

CommandListener.cpp

class NetlinkHandler: public NetlinkListener

public String[] getSecureContainerList()

//有读外置存储权限。默认支持属主读权限和数组读写权限

监听vold的socket

mSequenceNumber初始化值为0，每执行一次该方法则进行加1操作

nm->start()

resetIfReadyAndConnectedLocked()

vm->setBroadcaster((SocketListener *) cl)

读取新的/data/system/packages.list文件

status_t res = doCreate();

PrivateVolume.cpp

mDisks.push_back(std::shared_ptr<android::vold::Disk>(disk));

return NativeDaemonEvent.filterMessageList(mConnector.executeForList(\"asec\

4 准备media目录，生成模拟卷，模拟media目录

3 准备目录

android\\system\\core\\libsysutils\\src\\SocketListener.cpp

handle_fuse_requests(handler);

创建CryptCommandListener对象

没有找到则创建相应的PendingCmd

创建socket通信的client端

table = Table::kGpt;

killMediaProvider();mDisks.clear();mVolumes.clear();

NetLinkManager主要设置套接字，然后传递给NetlinkHanler，调用NetllinkHandler来进行监听。关于netlink主要就是通过套接字的形式和内核建立起链接，来接收内核发送上来的事件。对于Netlink事件的监听，在Android系统的libsysutils库里面提供了一套基础的实现，这个实现不是我们关注的重点，我们只简单进行介绍。最关键的类为NetlinkListener类，这个类启动后监听netlink套接字，收到数据后会将数据解析封装成数据结构NetlinkEvent，然后调用该类下的虚函数 virtual void onEvent(NetlinkEvent *evt)来对事件进行处理。vold的NetlinkManager创建的NetlinkHandler就是NetlinkListener的子类，它实现了onEvent函数，我们来看下它的实现。

MountService和Vold的整体流程与架构设计

service.onBootPhase(mCurrentPhase);

static void* start_handler(void* data)

android 6.0sd卡内部存储 & 外部存储

Disk::readPartitions()

startOtherServices()

MountService.java

android\\system\\vold\\PublicVolume.cpp

5 设置uid，保证拥有source_path的读写权限

mHandler = new MountServiceHandler(hthread.getLooper());

char* arg = argv[i];

frameworks\\base\\services\\core\\java\\com\\android\\server\\NativeDaemonConnector.java

2 利用传参，调用run函数

final NativeDaemonEvent event = NativeDaemonEvent.parseRawEvent(rawEvent);

创建线程名为\"CryptdConnector\"的线程，用于加密

设置为非挂载状态

当没有挂载Primary卷设备，则弹出警告

auto vol = vm->findVolume(id);

flags |= android::vold::Disk::Flags::kSd;

3 处理请求

mInternalEmulated->unmount();

int flags = source->getFlags();//从source获取flags

该方法的主要功能是创建下面4个对象并启动：VolumeManagerNetlinkManager （NetlinkHandler）CommandListenerCryptCommandListener

mHandler->start()

创建NetlinkHandler

auto disk = vm->findDisk(id);

case FUSE_MKDIR:

用于读取分区创建Volume数据结构。是磁盘挂载的最重要步骤

NetlinkManager *NetlinkManager::Instance()

switch (evt->getAction())

mCallbacks.onDaemonConnected();

(vm->start()

else if (mFsType == \"f2fs\")

android\\system\\vold\\main.cpp

mId = StringPrintf(\"disk:%u:%u\

PackageManagerService.java

full_write = true;

如上图所示，Android的sdcard进程中有四个线程，其中main线程在创建了其他三个线程后调用watch_package_list()函数，来读取/data/system/packages_list.xml文件的内容。sdcard进程通过读取/data/system/packages_list.xml的内容，来维护程序包名和uid的关系，针对外置存储下 ${user_id}/Android 目录的动态权限做处理，基本思路就是当应用程序读写${user_id}/Android/media|obb|data/${package_name} 下文件的时候，把该目录下的文件属主都改成应用程序的uid，作为文件的属主基本上就获得了文件的读写权限，这样应用程序就可以不需要获取外置存储读写权限来读写${user_id}/Android/media|obb|data/${package_name} 下的文件了（因为应用程序就是属主）。

case H_VOLUME_MOUNT:

service vold /system/bin/vold

绑定uevent socket

std::string path(mSysPath + \"/device/vendor\");

else if (table == Table::kGpt)

根据gpt分区表设置分区信息

if (mFsType == \"ext4\")

其中DEFAULT_TIMEOUT=1min，即命令执行超时时长为1分钟

pipe(mCtrlPipe)

if (major == kMajorBlockMmc) {

FILE* fp = setmntent(\"/proc/mounts\

SystemServer.java

case 'g':

void scanAvailableAsecs()

frameworks\\base\\services\\core\\java\\com\\android\\server\\MountService.java

VolumeManager.cpp

for (;;) {

将MountServiceInternalImpl登记到sLocalServiceObjects

const void *data = handler->request_buffer + sizeof(struct fuse_in_header);

执行VolumeManager的start方法

对于其他的响应码则添加到mResponseQueue队列

if (!mListen)

启动NetlinkHandler

case H_SYSTEM_READY:handleSystemReady()

auto vol = disk->findVolume(id);

mMountService.systemReady();

MountService线程通过socket发送cmd事件给vold，对于vold守护进程在启动的过程，初始化CommandListener时通过pthread_create创建子线程vold来专门监听MountService发送过来的消息，当该线程接收到socket消息时，便会调用onDataAvailable()方法

std::string devType(evt->findParam(\"DEVTYPE\"))

Disk::readMetadata()

NetlinkListener.cpp

//建立与\"/dev/socket/vold\"的socket连接

android\\system\\core\\libsysutils\\src\\FrameworkListener.cpp

根据代码我们可以得出启动FUSE file-system daemon 的命令为:/system/bin/sdcard -u 1023 -g 1023 -m -w ${mRawPath} ${label} 这里-u 参数指定uid 为1023 是media账号的uid， -g指定gid是media组的gid， -m表示支持多用户， -w表示全写模式， mRawPath就是外置存储的目标目录，比如/data/media 。 ${label} 用于区分fuse 目录，比如/dev/fuse 会挂载到/mnt/runtime/write/${label}，用于 ${mRawPath} 的写访问路径。知道这些我们就来看看sdcard的代码吧，它是FUSE file-system daemon 的实现。

android\\system\\core\\logd\\CommandListener.cpp

switch (hdr->opcode)

mode_t mode = 0660 | S_IFBLK;

无外置存储权限，默认只支持执行权限

mClients = new SocketClientCollection();

createPublicVolume(partDevice);

mConnectedSignal.countDown();if (mConnectedSignal.getCount() != 0) {return;}

case NetlinkEvent::Action::kAdd:

记录当前进程的pid

setgid(gid)

/注册监听用户添加、删除的广播

table = Table::kMbr;

flags |= android::vold::Disk::Flags::kUsb

if (event.isClassUnsolicited()) {mCallbacks.onCheckHoldWakeLock(event.getCode())}

createPublicVolume(mDevice);

将/data为路径的private volume添加到mVolumes

转NativeDaemonConnector.java中的excuteForList

ccl = new CryptCommandListener();

fuse->fd = open(\"/dev/fuse\

case FUSE_LOOKUP:

mAsecsScanned.countDown();

mMountService = new MountService(getContext());

4 fork新进程启动sdcard

MountService(Context context)

创建用于CryptdConnector工作的NDC对象

mBroadcaster = sl;

SocketListener::runListener()

addVolume(vol);

if (phase == SystemService.PHASE_ACTIVITY_MANAGER_READY)

void watch_package_list(struct fuse_global* global)

这里一个至关重要的参数fuse->fd是通过打开/dev/fuse得到的，它的作用类似一个上下文，绑定该目录到这个文件描述后，以后fuse 内核驱动上来的文件操作请求都会写入fuse->fd，只要读取fuse->fd就能获得fuse 内核驱动上来的文件操作请求

VolumeInfo vol = (VolumeInfo) msg.obj;

NativeDaemonConnector.java：class ResponseQueue

4挂载设备

VolumeBase::create()

7 启动三个线程用于处理三个fuse目录的文件操作请求

vol->mount();

public void startBootPhase(final int phase)

VolumeManager *vm = VolumeManager::Instance();

2 挂载设备

当系统启动到阶段550，并且已经与vold守护进程建立连接，则执行reset

while((de = readdir(d)))

if (vol.type == VolumeInfo.TYPE_EMULATED)

while (1)

6 创建obb共享文件夹

android\\system\\core\ootdir\\init.rc

EmulatedVolume.cpp

设置uevent的SO_RCVBUFFORCE选项

向vold进程发送asec list命令

cl->startListener()

关于代码，我们可以知道readPartitions函数通过读取mbr或者gpt分区表，还获取分区的信息，创建相应的卷。对于mbr分区，全都调用createPublicVolume函数来创建PublicVolume分区。对于gpt分区，要根据分区的typeGuid来创建Volume，如果typeGuid为kGptBasicData表示这是一个基础数据分区，所以并非一个Android特有的卷，使用createPublicVolume来创建PublicVolume。对于typeGuid为kGptAndroidExpand的卷则表示这个卷为一个Android扩展的卷，在其他系统上是无法处理的，这对应一个vold的PrivateVolume，使用createPrivateVolume函数来创建。

d2 = fdopendir(fd);

disk->create();

mConnector.executeForList(\"asec\

if (PrepareDir(mPath + \"/app\

if (type == \"public\

IoThread线程名为\"android.io\"，创建OBB操作的handler

创建“MountService”线程

3 // 取消特权组，只保留AID_PACKAGE_INFO组

将新创建的CommandListener对象sl赋值给vm对象的成员变量mBroadcaster

android\\system\\vold\\VolumeManager.cpp

调用/system/bin/sgdisk --android-dump /dev/block/vold/${disk_id}读取分区信息

switch (major(mDevice))

SocketListener.cpp

Android存储系统-使用fuse来管理外置存储

startListener(4)

static int process_config(VolumeManager *vm)

final int sequenceNumber = mSequenceNumber.incrementAndGet();

通过ioctl函数获取磁盘的大小，保存到mSize变量中，然后根据设备vendor或者manfid 获取Disk的mLabel

sInstance = new NetlinkManager();

//获取分区设备号。

CommandListener::CommandListener() :FrameworkListener(\"vold\

????跳转到mountService哪里

Linux Kernel：通过uevent向Vold的NetlinkManager发送Uevent事件；NetlinkManager：接收来自Kernel的Uevent事件，再转发给VolumeManager；VolumeManager：接收来自NetlinkManager的事件，再转发给CommandListener进行处理；CommandListener：接收来自VolumeManager的事件，通过socket通信方式发送给MountService；MountService：接收来自CommandListener的事件

setInternalPath(mRawPath);

2 设置路径

卸载所有设备，以提供最干净的环境

for (i = optind; i < argc; i++)

std::string mediaPath(mPath + \"/media\");

1 监听 fuse driver 发上来的请求，写入handler->request_buffer

FUSE_INIT

bool NetlinkListener::onDataAvailable(SocketClient *cli)

multi_user = true;

通过文件path来查看其所在进程，并杀掉相应进程

if (table == Table::kMbr)

mHandler = new NetlinkHandler(mSock)