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);
    
    klog_set_level(6);
    
    if (!(vm = VolumeManager::Instance())) {
        LOG(ERROR) << "Unable to create VolumeManager";
        exit(1);
    }
    if (!(nm = NetlinkManager::Instance())) {
        LOG(ERROR) <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) <start()) {
        PLOG(ERROR) <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表示 指定所挂载的文件系统的一些参数，如下

#              
/devices/platfORM/passthrough/5b0d0000.usb/ci_hdrc.0
    *has_adoptable = false;
    *has_quota = false;
    *has_reserved = false;
    for (int i = 0; i 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) <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(
                    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) <blk_device);
            std::string nickname(rec->label);
            //这里加个log打印出fastab 文件每行的属性标签
            LOG(DEBUG) << "sysPattern="<blk_device<<",nickname="<label<<",mountPoint="<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(
                    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
        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);
        
        while (!pendingList.empty()) {
            
            it = pendingList.begin();
            SocketClient* c = *it;
            pendingList.erase(it);
            
            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 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) <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 lock(mLock);
    if (mDebug) {
        LOG(VERBOSE) << "----------------";
        LOG(VERBOSE) << "handleBlockEvent with action " <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 getNickname(), flags);
				LOG(DEBUG) << "VolumeManager::handleBlockEvent="<<eventPath<<", nickname="<getNickname();
                handleDiskAdded(std::shared_ptr(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 " <getAction();
        break;
    }
    }
}

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

void VolumeManager::handleDiskAdded(const std::shared_ptr& 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 " <getEventPath()
                <create();
        mDisks.push_back(disk);
    }
}

-->system/vold/model/Disk.cpp
status_t Disk::create() {
	LOG(DEBUG) <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 的处理逻辑。

作者：安时光Mrsongs