android 6.0 修改vold check sd卡同步改成异步机制

android原生在vold中检查到kernel上报的event信息(sd卡）会发给MountService，然后MountService通过localSocket发给vold，让vold去mount这张sd卡。在vold中这个通信机制，在在一个死循环，select函数中执行，也就是vold处理MountService发给来的信息是顺序的，如果线程卡住了，select函数也执行不下去，整个MountService给vold发信息，都会卡住等待。

一、问题原因，现象

好了问题出在哪呢，当vold去mount的时候先要check sd卡：

status_t PublicVolume::doMount() {
    // TODO: expand to support mounting other filesystems
    readMetadata();

    if (mFsType != "vfat") {
        LOG(ERROR) << getId() << " unsupported filesystem " << mFsType;
        return -EIO;
    }
    if (vfat::Check(mDevPath)) {
        LOG(ERROR) << getId() << " failed filesystem check";
        return -EIO;
    }

只有check过了，才会去mount。

而这个check是开了一个进程去执行一个linux原始的工具，而我们需要等待这个进程的一个结果。下面我们来看下代码：

status_t Check(const std::string& source) {
    if (access(kFsckPath, X_OK)) {//检查这个进程是否有执行权限，没有直接不检查了
        SLOGW("Skipping fs checks\n");
        return 0;
    }

    int pass = 1;
    int rc = 0;

    do {
        std::vector<std::string> cmd;
        cmd.push_back(kFsckPath);
        cmd.push_back("-p");
        cmd.push_back("-f");
        cmd.push_back(source);


        // Fat devices are currently always untrusted
        rc = ForkExecvp(cmd, sFsckUntrustedContext);//这里会一直等待进程返回结果


        if (rc < 0) {
            SLOGE("Filesystem check failed due to logwrap error");
            errno = EIO;
            return -1;
        }

        switch(rc) {
        case 0:
            SLOGI("Filesystem check completed OK");
            return 0;

        case 2:
            SLOGE("Filesystem check failed (not a FAT filesystem)");
            errno = ENODATA;
            return -1;

        case 4:
            if (pass++ <= 3) {
                SLOGE("Filesystem modified - rechecking (pass %d)",
                        pass);
                continue;
            }
            SLOGE("Failing check after too many rechecks");
            errno = EIO;
            return -1;

        default:
            SLOGE("Filesystem check failed (unknown exit code %d)", rc);
            errno = EIO;
            return -1;
        }
    } while (0);

    return 0;
}

check函数会fork一个子进程，然后一直等待其结果：

static const char* kFsckPath = "/system/bin/fsck_msdos";

当有的坏卡会一直卡住，造成主线程一直等待，以至于vold和MountService的通信坏了。

二、解决方法

因此我们需要把这个fork一个进程等待结果，改成异步的：

class CheckThread : public Thread {//check线程
public:
    CheckThread(std::vector<std::string> cmd, int fd):
            mCmd(cmd),mFd(fd) {
    }

    virtual ~CheckThread() {
    }

    virtual bool threadLoop() {
        int rc = ForkExecvp(mCmd, sFsckUntrustedContext);//fork进程，check卡等待结果
        write(mFd, &rc, sizeof(int));//把结果写入管道
        return false;//返回false,不循环了
    }

private:
    std::vector<std::string> mCmd;
    int mFd;
};



status_t Check(const std::string& source) {
    if (access(kFsckPath, X_OK)) {
        SLOGW("Skipping fs checks\n");
        return 0;
    }

    int pass = 1;
    int rc = 3;//注意原来是0，改成3

    do {
        std::vector<std::string> cmd;
        cmd.push_back(kFsckPath);
        cmd.push_back("-p");
        cmd.push_back("-f");
        cmd.push_back(source);

        int pipefd[2];
        if (pipe(pipefd) < 0) { //管道
            SLOGE("pipe failed");
            return -1;
        }
        CheckThread* thread = new CheckThread(cmd, pipefd[1]);
        thread->run();//开启线程，执行fork进程，等待结果，同时把管道一端给它

        int mEpollFd = epoll_create(2);

        struct epoll_event eventItem;
        memset(& eventItem, 0, sizeof(epoll_event));
        // zero out unused members of data field union
        eventItem.events = EPOLLIN;
        eventItem.data.fd = pipefd[0];
        epoll_ctl(mEpollFd, EPOLL_CTL_ADD, pipefd[0], & eventItem);
        struct epoll_event eventItems[2];
        int eventCount = epoll_wait(mEpollFd, eventItems, 2, 10000);//使用epoll机制，设置timeout为10秒
        for (int i = 0; i < eventCount; i++) {
            int fd = eventItems[i].data.fd;//有管道数据，说明check好了，返回结果就在管道中
            uint32_t epollEvents = eventItems[i].events;
            if (fd == pipefd[0]) {
                if (epollEvents & EPOLLIN) {
                    read(fd, &rc, sizeof(int));
                }
            }
        }//直接timeout了，说明10秒还没有check完
        close(mEpollFd);
        close(pipefd[0]);//关闭fd
        close(pipefd[1]);

        // Fat devices are currently always untrusted
        //rc = ForkExecvp(cmd, sFsckUntrustedContext);


        if (rc < 0) {
            SLOGE("Filesystem check failed due to logwrap error");
            errno = EIO;
            return -1;
        }

        switch(rc) {
        case 0:
            SLOGI("Filesystem check completed OK");
            return 0;

        case 2:
            SLOGE("Filesystem check failed (not a FAT filesystem)");
            errno = ENODATA;
            return -1;

        case 3://3说明check超时了
            SLOGE("Filesystem check outime");
            errno = ENODATA;
            return -1;

        case 4:
            if (pass++ <= 3) {
                SLOGE("Filesystem modified - rechecking (pass %d)",
                        pass);
                continue;
            }
            SLOGE("Failing check after too many rechecks");
            errno = EIO;
            return -1;

        default:
            SLOGE("Filesystem check failed (unknown exit code %d)", rc);
            errno = EIO;
            return -1;
        }
    } while (0);

    return 0;
}

我们使用了管道+epoll机制，利用了epoll的timeout来完成我们的异步功能。

三、总结

其实我们一开始的思路是开一个线程执行，然后主线程waitRelative 10秒，如果子线程check完，broadcast把主线程唤醒。但是不知道为什么使用android原生的Condition不成功。所以才用了epoll机制。

后续可以再研究下，或者使用linux的pthread_cond_timedwait等再试下，因为android的Condition也是封装的这个。