Binder机制之Server端—ProcessState::self()

MediaPlayerService的代码位于frameworks/base/media/mediaserver/main_mediaserver.cpp文件中：

只关心下面的5行代码， 下面一一对这个5行代码分析

int main(int argc, char** argv)  
{  
    sp<ProcessState> proc(ProcessState::self());  
    sp<IServiceManager> sm = defaultServiceManager();  
    MediaPlayerService::instantiate();  
    ProcessState::self()->startThreadPool();  
    IPCThreadState::self()->joinThreadPool();  
}  

分析sp<ProcessState> proc(ProcessState::self()); 

ProcessState类的在frameworks/base/include/binder/ProcessState.h中定义：

class ProcessState : public virtual RefBase
{
public:
    static  sp<ProcessState>    self();
    void   setContextObject(const sp<IBinder>& object);
    sp<IBinder>  getContextObject(const sp<IBinder>& caller);       
    void   setContextObject(const sp<IBinder>& object, const String16& name);
    sp<IBinder> getContextObject(const String16& name,const sp<IBinder>& caller);

    void                startThreadPool();
                        
  typedef bool (*context_check_func)(const String16& name,const sp<IBinder>& caller,void* userData);
        
     bool                isContextManager(void) const;
     bool                becomeContextManager(context_check_func checkFunc, void* userData);

    sp<IBinder>         getStrongProxyForHandle(int32_t handle);
    wp<IBinder>         getWeakProxyForHandle(int32_t handle);
     void                expungeHandle(int32_t handle, IBinder* binder);
     .....
     void                spawnPooledThread(bool isMain);
            
private:
    friend class IPCThreadState;//IPCThreadState是它的友元类，所以IPCThreadState可以调用它的相关函数
    
     ProcessState();
      ~ProcessState();
     ProcessState(const ProcessState& o);
      struct handle_entry {IBinder* binder; RefBase::weakref_type* refs;};
            
      handle_entry*       lookupHandleLocked(int32_t handle);

      int                 mDriverFD;//binder驱动的文件描述符
      void*               mVMStart; //映射的内存指针
            
      mutable Mutex               mLock;  // protects everything below.
            
      Vector<handle_entry>mHandleToObject;

      bool                mManagesContexts;
      context_check_func  mBinderContextCheckFunc;
      void*               mBinderContextUserData;          
      KeyedVector<String16, sp<IBinder> > mContexts;
      String8             mRootDir;
      bool                mThreadPoolStarted;
      volatile int32_t    mThreadPoolSeq;
};

sp<ProcessState> proc(ProcessState::self()):是通过ProcessState::self()调用创建一个ProcessState实例。ProcessState::self()是ProcessState类的一个静态成员变量，定义在frameworks/base/libs/binder/ProcessState.cpp文件中：     

sp<ProcessState> ProcessState::self()
{
   //gProcess：全局对象指针，如果这个指针已被赋值则返回它
   //gProcess在Static.cpp中定义 ：sp<ProcessState> gProcess;
   if (gProcess != NULL) return gProcess;
    
    AutoMutex _l(gProcessMutex);
   
    //否则的话，则构造ProcessState对象，并付给gProcess
    if (gProcess == NULL) gProcess = new ProcessState;
    return gProcess;
}

new ProcessState，则调用它的构造函数，构造函数的简化形式如下：

ProcessState::ProcessState()
    : mDriverFD(open_driver())
    , mVMStart(MAP_FAILED)
    , mManagesContexts(false)
    , mBinderContextCheckFunc(NULL)
    , mBinderContextUserData(NULL)
    , mThreadPoolStarted(false)
    , mThreadPoolSeq(1)
{
    if (mDriverFD >= 0)
   {
        
      mVMStart = mmap(0, BINDER_VM_SIZE, PROT_READ, MAP_PRIVATE | MAP_NORESERVE, mDriverFD, 0);
       
   }
}

说明：构造函数主要做一下内容，先对成员变量进行处理，其中最重要的一个就是，打开binder驱动，并对驱动的文件描述符付给mDriverFD.

            然后，通过mmap函数，映射出binder驱动对应的映射内存缓冲区付给mVMStart.

看open_driver函数的实现：

static int open_driver()
{
    int fd = open("/dev/binder", O_RDWR);//打开binder驱动
    if (fd >= 0) 
    {  
        fcntl(fd, F_SETFD, FD_CLOEXEC);//设置文件操作的一些属性
       
        //通过ioctl+BINDER_VERSION命令，获取binder驱动的版本
        int vers;
        status_t result = ioctl(fd, BINDER_VERSION, &vers);
        
        //通过ioctl+BINDER_SET_MAX_THREADS命令，告诉binder驱动最大线程数
        size_t maxThreads = 15;
        result = ioctl(fd, BINDER_SET_MAX_THREADS, &maxThreads);
        
    } 
    return fd;
}

这个函数做了一下工作：

1、同binder驱动建立链接

2、获得驱动的版本。

3、通知驱动，我最多可同时启动15个线程来处理Client端的请求

我们来看一下ioctl文件操作函数执行BINDER_VERSION和BINDER_SET_MAX_THREADS命令的过程，这个函数调用最终进入到Binder驱动程序的binder_ioctl函数中，我们只关注相关的部分逻辑：

static long binder_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	int ret;
        //每open一个binder驱动，都会有一个专门的binder_proc管理当前进程的信息，包括进程的ID，当前进程由mmap所映射出的buffer信息
        //以及当前进程所允许的最大线程量，binder_proc会加入到系统的全局链表binder_procs中去
	struct binder_proc *proc = filp->private_data;
	
       //打开binder驱动的进程可以存在多线程，因此binder驱动使用binder_thread来管理对应的线程信息，主要包括线程所属的binder_proc
       //当前状态looper以及一个transaction_stack(我的理解是负责着实际进程间通信交互的源头和目的地） 
       struct binder_thread *thread;
	unsigned int size = _IOC_SIZE(cmd);
	void __user *ubuf = (void __user *)arg;
	
	ret = wait_event_interruptible(binder_user_error_wait, binder_stop_on_user_error < 2);
	
	mutex_lock(&binder_lock);
        
        //第一次时，会创建一个binder_thread结构保存线程信息，保存到对应的进程binder_proc->threads红黑树中
        //第二次时，根据proc里的线程信息去到该进程binder_proc->threads红黑树中去查询，如果有则返回这个结构指针
	thread = binder_get_thread(proc);
	
	switch (cmd) {
  
         //获取版本命令
         case BINDER_VERSION:
                //将BINDER_CURRENT_PROTOCOL_VERSION写入到传入的参数arg指向的用户缓冲区中去就返回了
		if (put_user(BINDER_CURRENT_PROTOCOL_VERSION, &((struct binder_version *)ubuf)->protocol_version)) {
			ret = -EINVAL;
			goto err;
		}
		break;
	 //设置最大线程数命令
	 case BINDER_SET_MAX_THREADS:
                //把该进程的最大线程数写入该进程的binder_proc结构里
		if (copy_from_user(&proc->max_threads, ubuf, sizeof(proc->max_threads))) {
			ret = -EINVAL;
			goto err;
		}
		break;	
	default:
		ret = -EINVAL;
		goto err;
	}
	ret = 0;

	return ret;
}

总结：这句代码按顺序主要做了下面的工作：

1、构建ProcessState全局对象gProcess.

2、打开binder驱动，建立链接。

3、在驱动内部创建该进程的binder_proc、binder_thread结构，保存该进程的进程信息和线程信息。并加入到系统的红黑树。

4、获得驱动的版本信息。

5、把该进程最到可同时启动的线程数告诉驱动，并保存到该进程的binder_proc结构中。

6、把设备文件/dev/binder映射到内存中