Android 9.0 Vold 挂载流程分析

在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(android::base::SYSTEM));

    LOG(INFO) << "Vold 3.0 (the awakening) firing up";

    ATRACE_BEGIN("main");


    LOG(VERBOSE) << "Detected support for:"
            << (android::vold::IsFilesystemSupported("ext4") ? " ext4" : "")
            << (android::vold::IsFilesystemSupported("f2fs") ? " f2fs" : "")
            << (android::vold::IsFilesystemSupported("vfat") ? " vfat" : "");

    VolumeManager *vm;
    NetlinkManager *nm;

    parse_args(argc, argv);

    sehandle = selinux_android_file_context_handle();
    if (sehandle) {
        selinux_android_set_sehandle(sehandle);
    }

    mkdir("/dev/block/vold", 0755);

    /* For when cryptfs checks and mounts an encrypted filesystem */
    klog_set_level(6);

    /* Create our singleton managers */
    if (!(vm = VolumeManager::Instance())) {
        LOG(ERROR) << "Unable to create VolumeManager";
        exit(1);
    }

    if (!(nm = NetlinkManager::Instance())) {
        LOG(ERROR) << "Unable to create NetlinkManager";
        exit(1);
    }

    if (android::base::GetBoolProperty("vold.debug", false)) {
        vm->setDebug(true);
    }

    if (vm->start()) {
        PLOG(ERROR) << "Unable to start VolumeManager";
        exit(1);
    }

    bool has_adoptable;
    bool has_quota;
    bool has_reserved;

    //解析fstab 文件
    if (process_config(vm, &has_adoptable, &has_quota, &has_reserved)) {
        PLOG(ERROR) << "Error reading configuration... continuing anyways";
    }

    ATRACE_BEGIN("VoldNativeService::start");
    if (android::vold::VoldNativeService::start() != android::OK) {
        LOG(ERROR) << "Unable to start VoldNativeService";
        exit(1);
    }
    ATRACE_END();

    LOG(DEBUG) << "VoldNativeService::start() completed OK";

    ATRACE_BEGIN("NetlinkManager::start");
    if (nm->start()) {
        PLOG(ERROR) << "Unable to start NetlinkManager";
        exit(1);
    }
    ATRACE_END();

    // This call should go after listeners are started to avoid
    // a deadlock between vold and init (see b/34278978 for details)
    android::base::SetProperty("vold.has_adoptable", has_adoptable ? "1" : "0");
    android::base::SetProperty("vold.has_quota", has_quota ? "1" : "0");
    android::base::SetProperty("vold.has_reserved", has_reserved ? "1" : "0");

    // Do coldboot here so it won't block booting,
    // also the cold boot is needed in case we have flash drive
    // connected before Vold launched
    coldboot("/sys/block");

    ATRACE_END();

    android::IPCThreadState::self()->joinThreadPool();
    LOG(INFO) << "vold shutting down";

    exit(0);
}

main 函数里面 做以下几件事：
1、创建NetLinkManager对象
2、创建VolumeManager对象
3、process_config 函数里面解析 fstab 文件

二、NetLinkManager

NetLinkManager 是接受Uevent 事件的上报，最终干活的是NetlinkHandler。

三、VolumeManager

Voulemanager 是处理所有挂载事件的，统一在这里根据事件的类型进行分发。

四、解析fstab 文件

4.1、fstab 文件是存放的是系统中的文件系统信息的，一般位于源码中device 目录下面，在设备的vendor/etc/fstab.xxx 下。如下截图的这两行是usb 设备的挂载信息。
src 表示 待挂载的设备节点路径
mount point表示 挂载点，即 被挂载的目录
filesystem type表示 所挂载磁盘的文件系统类型
mount flags parameters表示 指定所挂载的文件系统的一些参数，如下

#<src>   <mnt_point>    <type>    <mnt_flags and options>   <fs_mgr_flags>
/devices/platform/passthrough/5b0d0000.usb/ci_hdrc.0/* auto  auto  defaults  voldmanaged=usb:auto
/devices/platform/5b0d0000.usb/ci_hdrc.0/* auto  auto  defaults  voldmanaged=usb:auto

4.2、当插入 USB 设备后会在/sys/devices/platform/5b0d0000.usb/ci_hdrc.0 下面生成对应的usb 设备节点。接下来看看process_config解析 函数

static int process_config(VolumeManager* vm, bool* has_adoptable, bool* has_quota,
                          bool* has_reserved) {
    ATRACE_NAME("process_config");

    fstab_default = fs_mgr_read_fstab_default();
    if (!fstab_default) {
        PLOG(ERROR) << "Failed to open default fstab";
        return -1;
    }

    /* Loop through entries looking for ones that vold manages */
    *has_adoptable = false;
    *has_quota = false;
    *has_reserved = false;
    for (int i = 0; i < fstab_default->num_entries; i++) {
        auto rec = &fstab_default->recs[i];
        if (fs_mgr_is_quota(rec)) {
            *has_quota = true;
        }
        if (rec->reserved_size > 0) {
            *has_reserved = true;
        }

        if (fs_mgr_is_voldmanaged(rec)) {
            if (fs_mgr_is_nonremovable(rec)) {
                LOG(WARNING) << "nonremovable no longer supported; ignoring volume";
                continue;
            }

            std::string sysPattern(rec->blk_device);
            std::string nickname(rec->label);
            int flags = 0;

            if (fs_mgr_is_encryptable(rec)) {
                flags |= android::vold::Disk::Flags::kAdoptable;
                *has_adoptable = true;
            }
            if (fs_mgr_is_noemulatedsd(rec)
                    || android::base::GetBoolProperty("vold.debug.default_primary", false)) {
                flags |= android::vold::Disk::Flags::kDefaultPrimary;
            }

            vm->addDiskSource(std::shared_ptr<VolumeManager::DiskSource>(
                    new VolumeManager::DiskSource(sysPattern, nickname, flags)));
        }
    }
    return 0;
}

4.3、跟踪fs_mgr_read_fstab_default() 函数可以看到 解析的fstab 文件的路径是："/etc/recovery.fstab"

-->system/core/fs_mgr/fs_mgr_fstab.cpp
struct fstab *fs_mgr_read_fstab_default()
{
    std::string default_fstab;

    // Use different fstab paths for normal boot and recovery boot, respectively
    if (access("/sbin/recovery", F_OK) == 0) {
        default_fstab = "/etc/recovery.fstab";
    } else {  // normal boot
        default_fstab = get_fstab_path();
    }
 
    ...
    get_fstab_path 函数：
    static std::string get_fstab_path()
{
    for (const char* prop : {"hardware", "hardware.platform"}) {
        std::string hw;

        if (!fs_mgr_get_boot_config(prop, &hw)) continue;

        for (const char* prefix : {"/odm/etc/fstab.", "/vendor/etc/fstab.", "/fstab."}) {
            std::string fstab_path = prefix + hw;
            if (access(fstab_path.c_str(), F_OK) == 0) {
                return fstab_path;
            }
        }
    }

    return std::string();
}  

4.4、接着回到解析函数 process_config，这里判断voldmanaged 属性

    if (fs_mgr_is_voldmanaged(rec)) {
            if (fs_mgr_is_nonremovable(rec)) {
                LOG(WARNING) << "nonremovable no longer supported; ignoring volume";
                continue;
            }

            std::string sysPattern(rec->blk_device);
            std::string nickname(rec->label);
            //这里加个log打印出fastab 文件每行的属性标签
            LOG(DEBUG) << "sysPattern="<<rec->blk_device<<",nickname="<<rec->label<<",mountPoint="<<rec->mount_point;
            int flags = 0;

            if (fs_mgr_is_encryptable(rec)) {
                flags |= android::vold::Disk::Flags::kAdoptable;
                *has_adoptable = true;
            }
            if (fs_mgr_is_noemulatedsd(rec)
                    || android::base::GetBoolProperty("vold.debug.default_primary", false)) {
                flags |= android::vold::Disk::Flags::kDefaultPrimary;
            }

            vm->addDiskSource(std::shared_ptr<VolumeManager::DiskSource>(
                    new VolumeManager::DiskSource(sysPattern, nickname, flags)));
        }

打印的log如下，可以看到nickname 对应的fastab文件中的voldmanaged=usb就是设备类型了，这里是usb ,有的还有usbotg类型，vold里面会区分不同处理。

04-23 16:03:26.405  1582  1582 D vold    ：sysPattern=/devices/platform/passthrough/5b0d0000.usb/ci_hdrc.0/*,nickname=usb,mountPoint=auto
04-23 16:03:26.405  1582  1582 D vold    : sysPattern=/devices/platform/5b0d0000.usb/ci_hdrc.0/*,nickname=usb,mountPoint=auto
04-23 16:03:26.405  1582  1582 D vold    : sysPattern=/devices/platform/5b110000.usb3/xhci-cdns3/usb1/1-1/1-1.1/*,nickname=usb,mountPoint=auto

解析完了之后接下来把每一条设备挂载信息作为DiskSource都通过addDiskSource添加到volumemanager 的list 数组中，接下来任何uevent事件都会在这里里面查询处理。

五、U盘插拔事件的流程分析

5.1、接下来以U盘插入和拔出事件为例分析下两次事件的流程。
vold和kernel 的通信是通过NetLink方式的，NetLink本质上使用的也是socket 的方式，这里 网络模块的netd 和kernel 通信亦是如此。

还记得前面main 函数里面NetLinkManager的初始化吗，这里面实际上是开启了一个socket 线程去监听kerne 传来的uevent 事件。调用流程如下：

NetlinkManager::start() -> NetlinkHandler.start()->SocketListener.startListener()
->pthread_create->runListener()

5.2、pthread_create中开启一个线程去循环监听socket 也就是kernel 的事件上报，最后给onDataAvailable 处理

void SocketListener::runListener() {

    SocketClientCollection pendingList;

    while(1) {
        SocketClientCollection::iterator it;
        fd_set read_fds;
        int rc = 0;
        int max = -1;

        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) {
            // NB: calling out to an other object with mClientsLock held (safe)
            int fd = (*it)->getSocket();
            FD_SET(fd, &read_fds);
            if (fd > max) {
                max = fd;
            }
        }
        pthread_mutex_unlock(&mClientsLock);
        SLOGV("mListen=%d, max=%d, mSocketName=%s", mListen, max, mSocketName);
        if ((rc = select(max + 1, &read_fds, NULL, NULL, NULL)) < 0) {
            if (errno == EINTR)
                continue;
            SLOGE("select failed (%s) mListen=%d, max=%d", strerror(errno), mListen, max);
            sleep(1);
            continue;
        } else if (!rc)
            continue;

        if (FD_ISSET(mCtrlPipe[0], &read_fds)) {
            char c = CtrlPipe_Shutdown;
            TEMP_FAILURE_RETRY(read(mCtrlPipe[0], &c, 1));
            if (c == CtrlPipe_Shutdown) {
                break;
            }
            continue;
        }
        if (mListen && FD_ISSET(mSock, &read_fds)) {
            int c = TEMP_FAILURE_RETRY(accept4(mSock, nullptr, nullptr, SOCK_CLOEXEC));
            if (c < 0) {
                SLOGE("accept failed (%s)", strerror(errno));
                sleep(1);
                continue;
            }
            pthread_mutex_lock(&mClientsLock);
            mClients->push_back(new SocketClient(c, true, mUseCmdNum));
            pthread_mutex_unlock(&mClientsLock);
        }

        /* Add all active clients to the pending list first */
        pendingList.clear();
        pthread_mutex_lock(&mClientsLock);
        for (it = mClients->begin(); it != mClients->end(); ++it) {
            SocketClient* c = *it;
            // NB: calling out to an other object with mClientsLock held (safe)
            int fd = c->getSocket();
            if (FD_ISSET(fd, &read_fds)) {
                pendingList.push_back(c);
                c->incRef();
            }
        }
        pthread_mutex_unlock(&mClientsLock);

        /* Process the pending list, since it is owned by the thread,
         * there is no need to lock it */
        while (!pendingList.empty()) {
            /* Pop the first item from the list */
            it = pendingList.begin();
            SocketClient* c = *it;
            pendingList.erase(it);
            /* Process it, if false is returned, remove from list */
            if (!onDataAvailable(c)) {
                release(c, false);
            }
            c->decRef();
        }
    }
}

5.3、SocketListener 的父类NetlinkListener 会重写onDataAvailable 处理uevent 事件，这里会封装成NetlinkEvent 对象，通过decode 方法解析完该事件的类型之后，调用NetlinkListener 的父类 NetlinkHandler onEvent 继续处理
bool NetlinkListener::onDataAvailable(SocketClient *cli)
{
int socket = cli->getSocket();
ssize_t count;
uid_t uid = -1;

bool require_group = true;
if (mFormat == NETLINK_FORMAT_BINARY_UNICAST) {
    require_group = false;
}

count = TEMP_FAILURE_RETRY(uevent_kernel_recv(socket,
        mBuffer, sizeof(mBuffer), require_group, &uid));
if (count < 0) {
    SLOGE("recvmsg failed (%s)", strerror(errno));
    return false;
}

NetlinkEvent *evt = new NetlinkEvent();
if (evt->decode(mBuffer, count, mFormat)) {
    onEvent(evt);
} else if (mFormat != NETLINK_FORMAT_BINARY) {
    // Don't complain if parseBinaryNetlinkMessage returns false. That can
    // just mean that the buffer contained no messages we're interested in.
    SLOGE("Error decoding NetlinkEvent");
}

delete evt;
return true;

}

5.4、NetlinkHandler 的onEvent 处理实际上是传递给VolumeManager 的 handleBlockEvent 处理，这里也说明了VolumeManager 的角色，不管什么事件都到它这里统一分发到各个volume 处理。

void NetlinkHandler::onEvent(NetlinkEvent *evt) {
    VolumeManager *vm = VolumeManager::Instance();
    const char *subsys = evt->getSubsystem();

    if (!subsys) {
        LOG(WARNING) << "No subsystem found in netlink event";
        return;
    }

    if (std::string(subsys) == "block") {
        vm->handleBlockEvent(evt);
    }

5.5、VolumeManager 根据NetlinkEvent 的事件不同action 类型去做不同的处理，这里U盘插入事件action 值是1，U盘拔出 action 事件是2 。同时可以从NetlinkEvent 中获取设备类型和设备路径。主从设备号major minor 可以唯一标识一个设备，这里根据这个信息去区分是U盘设备还是sdcard 设备，进而设置flags 值。这里我们分析U盘插入事件handleDiskAdded

void VolumeManager::handleBlockEvent(NetlinkEvent *evt) {
    std::lock_guard<std::mutex> lock(mLock);

    if (mDebug) {
        LOG(VERBOSE) << "----------------";
        LOG(VERBOSE) << "handleBlockEvent with action " << (int) evt->getAction();
        evt->dump();
    }

    std::string eventPath(evt->findParam("DEVPATH")?evt->findParam("DEVPATH"):"");
    std::string devType(evt->findParam("DEVTYPE")?evt->findParam("DEVTYPE"):"");

    if (devType != "disk") return;

    int major = std::stoi(evt->findParam("MAJOR"));
    int minor = std::stoi(evt->findParam("MINOR"));
    dev_t device = makedev(major, minor);

    switch (evt->getAction()) {
    case NetlinkEvent::Action::kAdd: {
        for (const auto& source : mDiskSources) {
            if (source->matches(eventPath)) {
                // For now, assume that MMC and virtio-blk (the latter is
                // emulator-specific; see Disk.cpp for details) devices are SD,
                // and that everything else is USB
                int flags = source->getFlags();
                if (major == kMajorBlockMmc
                    || (android::vold::IsRunningInEmulator()
                    && major >= (int) kMajorBlockExperimentalMin
                    && major <= (int) kMajorBlockExperimentalMax)) {
                    flags |= android::vold::Disk::Flags::kSd;
                } else {
                    flags |= android::vold::Disk::Flags::kUsb;
                }

                auto disk = new android::vold::Disk(eventPath, device,
                        source->getNickname(), flags);
				LOG(DEBUG) << "VolumeManager::handleBlockEvent="<<eventPath<<", nickname="<<source->getNickname();
                handleDiskAdded(std::shared_ptr<android::vold::Disk>(disk));
                break;
            }
        }
        break;
    }
    case NetlinkEvent::Action::kChange: {
        LOG(DEBUG) << "Disk at " << major << ":" << minor << " changed";
        handleDiskChanged(device);
        break;
    }
    case NetlinkEvent::Action::kRemove: {
        handleDiskRemoved(device);
        break;
    }
    default: {
        LOG(WARNING) << "Unexpected block event action " << (int) evt->getAction();
        break;
    }
    }
}

5.6、VolumeManager 的handleBlockEvent 在处理U盘插入事件时会创建一个disk 对象，通过该对象readMetadata 和readPartitions去读取U盘中 数据和分析信息。最后会创建PublicVolume 对象去处理U盘的 具体业务逻辑，包括和StorageManagerService 的通信。

void VolumeManager::handleDiskAdded(const std::shared_ptr<android::vold::Disk>& disk) {
    // For security reasons, if secure keyguard is showing, wait
    // until the user unlocks the device to actually touch it
    if (mSecureKeyguardShowing) {
        LOG(INFO) << "Found disk at " << disk->getEventPath()
                << " but delaying scan due to secure keyguard";
        mPendingDisks.push_back(disk);
    } else {
        disk->create();
        mDisks.push_back(disk);
    }
}

-->system/vold/model/Disk.cpp
status_t Disk::create() {
	LOG(DEBUG) << "Disk::create";
    CHECK(!mCreated);
    mCreated = true;

    auto listener = VolumeManager::Instance()->getListener();
    if (listener) listener->onDiskCreated(getId(), mFlags);

    readMetadata();
    readPartitions();
    return OK;
}


....
判断该U盘的文件系统格式是否支持，进入创建 PublicVolume
switch (type) {
   case 0x06:  // FAT16
   case 0x07:  // HPFS/NTFS/exFAT
   case 0x0b:  // W95 FAT32 (LBA)
   case 0x0c:  // W95 FAT32 (LBA)
   case 0x0e:  // W95 FAT16 (LBA)
              createPublicVolume(partDevice);
    break;
}

5.7、PublicVolume 就是具体处理U盘 挂载，卸载，格式化这些具体业务并且和framework 层的StorageManagerService 进行通信，这里是通过Bind跨进程实现的。之前做一个一个区分双U盘的问题。可以根据NetlinkEvent 时间的设备路径去进行区分，设备路径是唯一区分不同设备的方式。

六、结语

本篇博客到这里就结束了，下次画个时序图加上。后续会继续分析 framework 层的StorageManagerSevice 的处理逻辑。