Ril分析二——事件机制和客户端请求监听

客户端请求处理和Event事件处理机制

一 事件机制

//ril_event.cpp
event事件数据结构：
　　struct ril_event {
　　struct ril_event *next;
　　struct ril_event *prev;
　　int fd;     //事件对应的设备文件句柄
　　int index;
　　bool persist;    
　　struct timeval timeout;    //事件超时处理时间
　　ril_event_cb func;     //事件处理回调函数
　　void *param;     //回调函数参数
};

相关对象：
　　fd_set readFds; 　　　　所有事件队列中设备文件句柄的集合
　　int nfds = 0; 　　　　    所有事件设备句柄中最大值 + 1

　　ril_event * watch_table[MAX_FD_EVENTS]; 监测事件队列
　　ril_event timer_list; 　　　　 时间事件队列
　　ril_event pending_list;         事件触发 待处理的队列

 

过程如下：

　　

二 事件机制处理过程

在rild进程的main函数中：

int main(int argc, char **argv)
{
    //创建客户端事件监听线程
    RIL_startEventLoop();

    //处理客户端请求的模块reference-ril.c
    funcs_inst[0] = rilInit(&s_rilEnv, argc, s_argv);

    //注册客户端事件处理接口，并创建socket监听客户端事件
    for (i = 0; i < numClients; i++) {
        RIL_register(funcs_inst[i], i);
    }
}    

1 RIL_startEventLoop 创建线程事件循环处理

extern "C" void RIL_startEventLoop(void) 
{
　　//创建eventLoop线程，直到被启动并将s_started置为1返回
　　s_started = 0;
　　pthread_mutex_lock(&s_startupMutex);     //上锁

　　pthread_attr_init (&attr);
　　pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
　　ret = pthread_create(&s_tid_dispatch, &attr, eventLoop, NULL);

　　//线程未启动 休眠等待……
　　while (s_started == 0) {
　　　　pthread_cond_wait(&s_startupCond, &s_startupMutex);
　　}
　　pthread_mutex_unlock(&s_startupMutex);     //解锁
}

2 RIL_register 注册客户端请求处理接口 创建事件

extern "C" void RIL_register (const 
　　　　　　　　　　RIL_RadioFunctions *callbacks, int client_id) 
{
　　//注册事件处理接口
　　memcpy(&s_callbacks[client_id], callbacks, sizeof (RIL_RadioFunctions));
　　s_registerCalled++;

　　// Little self-check
　　//s_commands
　　//s_unsolResponses

　　//确保EventLoop启动
　　if (s_started == 0) {
　　　　RIL_startEventLoop();
　　}

　　// 创建rild的socket start listen socket
　　s_fdListen = android_get_control_socket(RIL_getRilSocketName());
　　ret = listen(s_fdListen, 4);

　　//创建事件s_listen_event 监听和处理客户端请求
　　ril_event_set (&s_listen_event, s_fdListen, true,
　　listenCallback, NULL);
　　//将s_listen_event事件加入到watch_table队列中 唤醒事件处理线程
　　rilEventAddWakeup (&s_listen_event);

　　//建立s_debug_event事件 监听和处理调试
　　ril_event_set (&s_debug_event, s_fdDebug, true,
　　debugCallback, NULL);
　　rilEventAddWakeup (&s_debug_event);
}

　　创建了s_listen_event s_debug_event事件，加入到watch_table事件列表中，

　　这些事件将何时，如何被执行呢？

3 EventLoop线程执行函数体

static void * eventLoop(void *param) 
{
　　int ret;
　　int filedes[2];
　　//初始化readFds timer_list pending_list watch_table
　　ril_event_init();
　　pthread_mutex_lock(&s_startupMutex);

　　s_started = 1;
　　pthread_mutex_unlock(&s_startupMutex);
　　//管道 
　　ret = pipe(filedes);
　　s_fdWakeupRead = filedes[0];
　　s_fdWakeupWrite = filedes[1];
　　fcntl(s_fdWakeupRead, F_SETFL, O_NONBLOCK);    //读写操作非阻塞

　　//建立s_wakeupfd_event事件
　　ril_event_set (&s_wakeupfd_event, s_fdWakeupRead, true,
　　processWakeupCallback, NULL);
　　rilEventAddWakeup (&s_wakeupfd_event);

　　//进入Event线程循环处理过程
　　ril_event_loop();
　　kill(0, SIGKILL);
　　return NULL;
}

　　看到这里使用pipe管道s_fdWakeupRead s_fdWakeupWrite是何用意呢？
　　管道的fd s_fdWakeupRead被加入到readFds集合中;
　　创建s_wakeupfd_event事件 使用管道fd作为其设备文件描述符

4 Event线程 ril_event_loop循环处理过程

void ril_event_loop()
{
　　for (;;) {
　　　　// make local copy of read fd_set
　　　　memcpy(&rfds, &readFds, sizeof(fd_set));
　　　　//计算
　　　　calcNextTimeout(&tv);

　　　　//从设备节点中读取有变化的值并返回
　　　　n = select(nfds, &rfds, NULL, NULL, ptv);

　　　　//处理timer_list中事件 将过时事件移到pending_list中
　　　　processTimeouts();

　　　　//处理watch_table中事件 将其移到pending_list中
　　　　processReadReadies(&rfds, n);

　　　　//处理pending_list中事件
　　　　firePending();
　　}
}

事件处理：

static void firePending()
{
　　struct ril_event * ev = pending_list.next;
　　while (ev != &pending_list) {
　　　　struct ril_event * next = ev->next;
　　　　removeFromList(ev);
　　　　//执行事件处理函数
　　　　ev->func(ev->fd, 0, ev->param);
　　　　ev = next;
　　}
}

　　这就是整个Event处理的大致流程。这里处理的事件不是外部而是来自内部自定义的事件。

5 pipe 与 select rilEventAddWakeup

这里需要关注的几个地方是：
　　pipe管道的使用
　　rilEventAddWakeup 如何唤醒线程
　　ril_event_loop 中select调用
　　这之间是什么关系呢？
定义了管道：
　　s_fdWakeupRead = filedes[0];
　　s_fdWakeupWrite = filedes[1];

rilEventAddWakeup函数：

　　static void rilEventAddWakeup(struct ril_event *ev) {
　　　　ril_event_add(ev);
　　　　triggerEvLoop();
　　}

ril_event_add函数：

void ril_event_add(struct ril_event * ev)
{
　　for (int i = 0; i < MAX_FD_EVENTS; i++) {
　　　　if (watch_table[i] == NULL) {
　　　　watch_table[i] = ev;
　　　　ev->index = i;

　　　　//将当前事件的设备节点文件描述符加入到集合readFds
　　　　FD_SET(ev->fd, &readFds);
　　　　if (ev->fd >= nfds) nfds = ev->fd+1;
　　　　　　break;
　　　　}
　　}
}

readFds定义：static fd_set readFds;
　　　　struct fd_set一个存放文件描述符(file descriptor)，即文件句柄的聚合管道文件句柄就是被加入到此集合当中。

　　这个文件句柄集合 就是用selecet函数进行监听，一旦文件句柄任一有变化，select就会读取相关变化的值，并返回。

　　select可以阻塞也可以是非阻塞，根据传递参数而定。
triggerEvLoop函数：

static void triggerEvLoop() {
int ret;
if (!pthread_equal(pthread_self(), s_tid_dispatch)) {
　　　do {
　　　　　　//若当前的执行进程不是s_tid_dispatch
　　　　　　//则向管道中写入数据，使readFds集合中文件描述符有变化 以触发线程
　　　　　　ret = write (s_fdWakeupWrite, " ", 1);
　　　　} while (ret < 0 && errno == EINTR);
　　}
}

ril_event_loop函数：

void ril_event_loop()
{
　　for (;;) {
　　　　n = select(nfds, &rfds, NULL, NULL, ptv);
　　　　……
　　}
}

　　select函数监听文件句柄集合，当句柄中任何一个数据变化时，就会读取它并返回。

否则为定时情况有可能会一直处于阻塞之中，事件得不到执行。

　　事件调度处理过程如上所述，事件的作用如何呢，通过这些事件做了些什么事情，客户端的请求是如何处理的，这些并不清楚。

三 事件处理

从前面可以看到创建了事件，事件在被移动到待执行列表pending_list后，将在线程循环结构中得到处理，

调用事件的回调处理函数，有如下事件：
　　ril_event s_wakeupfd_event; 　　 //清空用于唤醒管道数据
　　ril_event s_listen_event; 　　 　　 //接收客户端socket请求
　　ril_event s_debug_event; 　　 　 //用于调试
　　ril_event s_commands_event; 　 //执行客户端请求

 　　s_listen_event：监听rild端口的客户端连接，如果监听到有新的连接就会执行，使用fd = accept(s_fdListen,…)；

得到一个新的套接字文件描述符，用来和建立连接的客户端进行通信：接收和发送消息。

只有新客户端与Rild Sokcet建立连接时，才会触发s_listen_event事件。

　　s_commands_event：s_listen_event监听到客户端连接，使用accept并建立新的通信套接字fd后，

使用新建立的fd创建s_commands_event事件，从客户端接收消息和向客户端发送消息；

1 s_wakeupfd_event

　　processWakeupCallback：

static void processWakeupCallback(int fd, short flags, void *param) {
　　/* empty our wakeup socket out */
　　do {
　　　　ret = read(s_fdWakeupRead, &buff, sizeof(buff));
　　} while (ret > 0 || (ret < 0 && errno == EINTR));
}

　　Pipe管道的特性，分为读取端和写入端，读取之后会将其中所有数据清空。

2 s_listen_event

　　listenCallback：

static void listenCallback (int fd, short flags, void *param) {
　　int is_phone_socket = 0;
　　char *p_record;
　　RecordStreamInfo *p_rsInfo;
　　struct passwd *pwd = NULL;

　　//监听socket连接
　　fd = accept(s_fdListen, (sockaddr *) &peeraddr, &socklen);
　　//判断是否是PHONE_PROCESS 连接 否则返回
　　err = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds);
　　pwd = getpwuid(creds.uid);
　　if (strcmp(pwd->pw_name, PHONE_PROCESS) == 0) {
　　　　is_phone_socket = 1;
　　}

　　// 创建RecordStream数据结构record_stream.c
　　p_rsInfo = new RecordStreamInfo();
　　p_rsInfo->p_rs = record_stream_new(fd, MAX_COMMAND_BYTES);
　　p_record = (char *)malloc(sizeof(char) * SUB_DATA_LENGTH);

　　//从socket中读取数据
　　ret = read(fd, p_record, SUB_DATA_LENGTH);
　　s_fdCommand[p_rsInfo->client_id] = fd;

　　//创建事件s_commands_event 处理socket请求
　　ril_event_set (&s_commands_event[client_id], s_fdCommand[client_id], 1,
　　processCommandsCallback, p_rsInfo);
　　rilEventAddWakeup (&s_commands_event[p_rsInfo->client_id]);

　　//通知客户端已建立连接
　　onNewCommandConnect(p_rsInfo->client_id);
}

　　s_listen_event事件监听客户端连接，创建s_commands_event事件来处理请求。

3 s_commands_event processCommandsCallback:

static void processCommandsCallback(int fd, short flags, void *param) {
　　void *p_record;
　　RecordStreamInfo *p_rsInfo;

　　p_rsInfo = (RecordStreamInfo *)param;

　　for (;;) {
　　　　/* loop until EAGAIN/EINTR, end of stream, or other error */
　　　　ret = record_stream_get_next(p_rsInfo->p_rs, &p_record, &recordlen);
　　　　if (ret == 0 && p_record == NULL) {
　　　　/* end-of-stream */
　　　　break;
　　} else if (ret < 0) {
　　　　break;
　　} else if (ret == 0) { /* && p_record != NULL */
　　　　processCommandBuffer(p_record, recordlen, p_rsInfo->client_id);
　　}
　　}
}

static int processCommandBuffer(void *buffer, size_t buflen, int client_id) {
　　Parcel p;
　　status_t status;
　　int32_t request;
　　int32_t token;
　　RequestInfo *pRI;

　　//将数据转化成Parcel类型
　　p.setData((uint8_t *) buffer, buflen);

　　// 读取请求的标识
　　status = p.readInt32(&request);
　　status = p.readInt32 (&token);

　　//将数据请求转化成RequestInfo类型
　　pRI = (RequestInfo *)calloc(1, sizeof(RequestInfo));

　　//查询获取客户端请求处理接口 CommandInfo
　　pRI->pCI = &(s_commands[request]);
　　pRI->token = token;
　　pRI->client_id = client_id;
　　pRI->p_next = s_pendingRequests;
　　s_pendingRequests = pRI;

　　//调用请求对应的处理函数
　　pRI->pCI->dispatchFunction(p, pRI);
　　return 0;
}

 　　客户端传来的请求都对应着相应的请求标识号，通过该标识号查询每一个客户端请求RequestInfo对应着 处理和响应接口信息CommandInfo

查询是通过s_commands数组进行的。

四 客户端请求处理接口

将客户端通过socket发来请求转化成RequestInfo进行处理，然后查询对应请求的处理接口CommandInfo。

　　　　

 

typedef struct {
　　int requestNumber;
　　void (*dispatchFunction) (Parcel &p, struct RequestInfo *pRI);
　　int(*responseFunction) (Parcel &p, void *response, size_t responselen);
} CommandInfo;

static CommandInfo s_commands[] = {
　　#include "ril_commands.h"
};

ril_commands.h：

{RIL_REQUEST_GET_SIM_STATUS, dispatchVoid, responseSimStatus},
{RIL_REQUEST_ENTER_SIM_PIN, dispatchStrings, responseInts},
{RIL_REQUEST_ENTER_SIM_PUK, dispatchStrings, responseInts},
{RIL_REQUEST_ENTER_SIM_PIN2, dispatchStrings, responseInts},
{RIL_REQUEST_ENTER_SIM_PUK2, dispatchStrings, responseInts},
……

调用其处理函数：RequestInfo-> CommandInfo ->dispatchFunction(p, pRI);

　　dispatchFunction函数中调用s_callbacks中的请求处理函数onRequest
　　s_callbacks就是在rild的main函数中RIL_Init初始化（reference-ril.c），是所返回的接口，注册到EventLoop（Ril.cpp）中.
　　static const RIL_RadioFunctions s_callbacks = {
　　　　onRequest,
　　　　……
　　};

dispatchFunction——>onRequest：将客户端请求派发给reference-ril处理。