Binder进程间通讯

原创

已于 2023-11-24 15:05:47 修改 · 837 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#binder

于 2023-02-24 00:26:15 首次发布

文章详细介绍了Android系统中Binder通讯机制的核心过程，包括ProcessState的创建，内核与用户空间的通讯，defaultServiceManager的获取，以及线程池的启动和加入。重点讲解了BpBinder的使用，以及如何通过ioctl与内核交互进行数据传输。

A. 建立通讯链路

以frameworks/av/media/mediaserver/main_mediaserver.cpp为例来说明Binder通讯机制；

int main(int argc __unused, char **argv __unused)
{
    // 省略部分代码；
    sp<ProcessState> proc(ProcessState::self());
    sp<IServiceManager> sm(defaultServiceManager());
    ALOGI("ServiceManager: %p", sm.get());

    // 省略部分代码；
    ::android::hardware::configureRpcThreadpool(16, false);
    ProcessState::self()->startThreadPool();
    IPCThreadState::self()->joinThreadPool();
    ::android::hardware::joinRpcThreadpool();
}

1. ProcessState

从代码中可以看出：

ProcessState::self()创建一个进程唯一的ProcessState实例，并且建立了内核与用户空间的通讯(mmap映射)。
Binder通讯的大小接近(小于)1M;
mThreadPoolSeq从1开始计数， mDriverFD保存“/dev/binder”句柄资源；

#ifdef __ANDROID_VNDK__
const char* kDefaultDriver = "/dev/vndbinder";
#else
const char* kDefaultDriver = "/dev/binder";
#endif

sp<ProcessState> ProcessState::self()
{
    return init(kDefaultDriver, false /*requireDefault*/);
}

sp<ProcessState> ProcessState::init(const char* driver, bool requireDefault) {
     // 省略部分代码；
    [[clang::no_destroy]] static std::once_flag gProcessOnce;
    std::call_once(gProcessOnce, [&](){
        // 省略部分代码；

        // we must install these before instantiating the gProcess object,
        // otherwise this would race with creating it, and there could be the
        // possibility of an invalid gProcess object forked by another thread
        // before these are installed
        int ret = pthread_atfork(ProcessState::onFork, ProcessState::parentPostFork,
                                 ProcessState::childPostFork);
        LOG_ALWAYS_FATAL_IF(ret != 0, "pthread_atfork error %s", strerror(ret));

        std::lock_guard<std::mutex> l(gProcessMutex);
        gProcess = sp<ProcessState>::make(driver);
    });

    // 省略部分代码；

    verifyNotForked(gProcess->mForked);
    return gProcess;
}

#define BINDER_VM_SIZE ((1 * 1024 * 1024) - sysconf(_SC_PAGE_SIZE) * 2)
#define DEFAULT_MAX_BINDER_THREADS 15
ProcessState::ProcessState(const char* driver)
      : mDriverName(String8(driver)),
        mDriverFD(-1),
        mVMStart(MAP_FAILED),
        mMaxThreads(DEFAULT_MAX_BINDER_THREADS),
        mThreadPoolSeq(1),
        mCallRestriction(CallRestriction::NONE) {
    base::unique_fd opened = open_driver(driver);

    if (opened.ok()) {

        mVMStart = mmap(nullptr, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE,
                        opened.get(), 0);
        // 省略部分代码；
    }

    // 省略部分代码；

    if (opened.ok()) {
        mDriverFD = opened.release();
    }
}

2. defaultServiceManager

这段代码位于：frameworks/native/libs/binder/IServiceManager.cpp，从代码上看返回一个IServiceManager接口实例，并且这个实例对于一个进程来说也是唯一的(gDefaultServiceManager)；但要关注下几个细节；

using AidlServiceManager = android::os::IServiceManager;
static sp<IServiceManager> gDefaultServiceManager;

sp<IServiceManager> defaultServiceManager()
{
    std::call_once(gSmOnce, []() {
#if defined(__BIONIC__) && !defined(__ANDROID_VNDK__)
        /* wait for service manager */ {
        // 省略部分代码；

        sp<AidlServiceManager> sm = nullptr;
        while (sm == nullptr) {
            ★ sm = interface_cast<AidlServiceManager>(ProcessState::self()->getContextObject(nullptr));
            if (sm == nullptr) {
                ALOGE("Waiting 1s on context object on %s.", ProcessState::self()->getDriverName().c_str());
                sleep(1);
            }
        }

        gDefaultServiceManager = sp<ServiceManagerShim>::make(sm);
    });

    return gDefaultServiceManager;
}

2.1 getContextObject

返回一个BpBinder实例；

sp<IBinder> ProcessState::getContextObject(const sp<IBinder>& /*caller*/)
{
    sp<IBinder> context = getStrongProxyForHandle(0);

    // 省略部分代码；

    return context;
}

ProcessState::handle_entry* ProcessState::lookupHandleLocked(int32_t handle)
{
    const size_t N=mHandleToObject.size();
    if (N <= (size_t)handle) {
        handle_entry e;
        e.binder = nullptr;
        e.refs = nullptr;
        status_t err = mHandleToObject.insertAt(e, N, handle+1-N);
        if (err < NO_ERROR) return nullptr;
    }