Android RIL源碼研究筆記 の ril_event

Android源碼目錄hardware/ril/libril目錄中總共包含5個C/CPP文件,它們分別是ril_commands.h、ril_unsol_commands.h、ril_event.h、ril_event.cpp和ril.cpp。這篇文章主要分析ril_event的相關代碼。
   ril_event主要處理電話模塊涉及的端口、modem等產生的事件,並將多個事件按時間順序進行組織,並保存在事件隊別中,主要使用瞭三個隊列,分別是:watch_table[],timer_list和pending_list。代碼是以C語言方式實現的,先來看頭文件ril_event.h:
 
[cpp]
// 每次監視的最大的文件描述符句柄數,可以根據需要自行修改 
#define MAX_FD_EVENTS 8 
 
// ril_event的回調函數 
typedef void (*ril_event_cb)(int fd, short events, void *userdata); 
 
struct ril_event { 
    // 用於將ril_event串成雙向鏈表的前向指針和後向指針 
    struct ril_event *next; 
    struct ril_event *prev; 
     
    //ril事件相關的文件描述符句柄(可以是文件、管道、Socket等) 
    int fd; 
     
    //這個事件在監控列表中的索引 
    int index; 
     
    //當一個事件處理完後(即從watch_table移到pending_list中等待處理), 
    //persist參數決定這個事件是否一直存在於監控列表watch_table[]中 
    bool persist; 
     
    //事件的超時時間 
    struct timeval timeout; 
     
    //回調函數及其傳入的參數 
    ril_event_cb func; 
    void *param; 
}; 
 
//以下是ril事件相關的一些操作函數 
// 初始化內部數據結構 
void ril_event_init(); 
 
// 初始化一個ril事件 
void ril_event_set(struct ril_event * ev, int fd, bool persist, ril_event_cb func, void * param); 
 
// 將事件添加到監控列表watch_table[]中 
void ril_event_add(struct ril_event * ev); 
 
// 增加一個timer事件到timer_list鏈表中 
void ril_timer_add(struct ril_event * ev, struct timeval * tv); 
 
// 將指定的事件從監控列表watch_table[]中移除 
void ril_event_del(struct ril_event * ev); 
 
// 事件循環 
void ril_event_loop(); 

接著分析ril_event .cpp文件:
 
[cpp]
#define LOG_TAG "RILC" 
 
#include <stdlib.h> 
#include <unistd.h> 
#include <errno.h> 
#include <fcntl.h> 
#include <utils/Log.h> 
#include <ril_event.h> 
#include <string.h> 
#include <sys/time.h> 
#include <time.h> 
 
#include <pthread.h> 
 
// 使用互斥量mutex進行線程同步,可參見《Linux程序設計》相關章節 
static pthread_mutex_t listMutex; 
#define MUTEX_ACQUIRE() pthread_mutex_lock(&listMutex) 
#define MUTEX_RELEASE() pthread_mutex_unlock(&listMutex) 
#define MUTEX_INIT() pthread_mutex_init(&listMutex, NULL) 
#define MUTEX_DESTROY() pthread_mutex_destroy(&listMutex) 
 
// 兩個timeval類型的值相加 
#ifndef timeradd 
#define timeradd(tvp, uvp, vvp)                     \ 
    do {                                \ 
        (vvp)->tv_sec = (tvp)->tv_sec + (uvp)->tv_sec;     \ 
        (vvp)->tv_usec = (tvp)->tv_usec + (uvp)->tv_usec;       \ 
        if ((vvp)->tv_usec >= 1000000) {          \ 
            (vvp)->tv_sec++;             \ 
            (vvp)->tv_usec -= 1000000;           \ 
        }                           \ 
    } while (0) 
#endif 
 
// 兩個timeval類型的值進行比較 
#ifndef timercmp 
#define timercmp(a, b, op)               \ 
        ((a)->tv_sec == (b)->tv_sec      \ 
        ? (a)->tv_usec op (b)->tv_usec   \ 
        : (a)->tv_sec op (b)->tv_sec) 
#endif 
 
// 兩個timeval類型的值相減 
#ifndef timersub 
#define timersub(a, b, res)                           \ 
    do {                                              \ 
        (res)->tv_sec = (a)->tv_sec – (b)->tv_sec;    \ 
        (res)->tv_usec = (a)->tv_usec – (b)->tv_usec; \ 
        if ((res)->tv_usec < 0) {                     \ 
            (res)->tv_usec += 1000000;                \ 
            (res)->tv_sec -= 1;                       \ 
        }                                             \ 
    } while(0); 
#endi 
 
// 保存Rild中所有設備文件句柄,便於使用select函數完成事件的監聽 
static fd_set readFds; 
// 記錄readFds中最大fd值+1 
static int nfds = 0; 
 
// 為瞭統一管理ril事件,Android提供如下三個隊列: 
// 監控事件列表,需要檢測的事件都需要先存入該列表中 
static struct ril_event * watch_table[MAX_FD_EVENTS]; 
 
// timer事件隊列,事件超時後即移入pending_list隊列中 
static struct ril_event timer_list; 
 
// 待處理的事件隊列,即事件已經觸發,後續需要調用事件的回調函數 
static struct ril_event pending_list; 
 
#define DEBUG 0 
 
#if DEBUG 
#define dlog(x…) LOGD( x ) 
static void dump_event(struct ril_event * ev) 

    dlog("~~~~ Event %x ~~~~", (unsigned int)ev); 
    dlog("     next    = %x", (unsigned int)ev->next); 
    dlog("     prev    = %x", (unsigned int)ev->prev); 
    dlog("     fd      = %d", ev->fd); 
    dlog("     pers    = %d", ev->persist); 
    dlog("     timeout = %ds + %dus", (int)ev->timeout.tv_sec, (int)ev->timeout.tv_usec); 
    dlog("     func    = %x", (unsigned int)ev->func); 
    dlog("     param   = %x", (unsigned int)ev->param); 
    dlog("~~~~~~~~~~~~~~~~~~"); 

#else 
#define dlog(x…) do {} while(0) 
#define dump_event(x) do {} while(0) 
#endif 
 
// 獲取此刻timeval值 
static void getNow(struct timeval * tv) 

#ifdef HAVE_POSIX_CLOCKS 
    struct timespec ts; 
    clock_gettime(CLOCK_MONOTONIC, &ts); 
    tv->tv_sec = ts.tv_sec; 
    tv->tv_usec = ts.tv_nsec/1000; 
#else 
    gettimeofday(tv, NULL); 
#endif 

 
// 初始化指定的ril_event鏈表 
static void init_list(struct ril_event * list) 

    memset(list, 0, sizeof(struct ril_event)); 
    list->next = list; 
    list->prev = list; 
    list->fd = -1; 

 
// 增加一個ril_event事件到ril_event隊列頭 
static void addToList(struct ril_event * ev, struct ril_event * list) 

    ev->next = list; 
    ev->prev = list->prev; 
    ev->prev->next = ev; 
    list->prev = ev; 
    dump_event(ev); 

 
// 從ril_event隊列中移除指定的ril_event 
static void removeFromList(struct ril_event * ev) 

    dlog("~~~~ Removing event ~~~~"); 
    dump_event(ev); 
 
    ev->next->prev = ev->prev; 
    ev->prev->next = ev->next; 
    ev->next = NULL; 
    ev->prev = NULL; 

 
// 從watch_table[]中移除指定索引的事件 
static void removeWatch(struct ril_event * ev, int index) 

    // 索引index對應的事件置為空,同時事件ev的索引設為無效值-1 
    watch_table[index] = NULL; 
    ev->index = -1; 
 
    // 將該事件對應的文件描述符句柄從readFds中清除 
    FD_CLR(ev->fd, &readFds); 
 
    if (ev->fd+1 == nfds) { 
        int n = 0; 
 
        for (int i = 0; i < MAX_FD_EVENTS; i++) { 
            struct ril_event * rev = watch_table[i]; 
 
            if ((rev != NULL) && (rev->fd > n)) { 
                n = rev->fd; 
            } 
        } 
        nfds = n + 1; 
        dlog("~~~~ nfds = %d ~~~~", nfds); 
    } 

 
// 遍歷timer_list隊列中的事件,當事件超時時間到時 
// 將事件移除,並添加到pending_list隊列中 
static void processTimeouts() 

    dlog("~~~~ +processTimeouts ~~~~"); 
    MUTEX_ACQUIRE(); 
    struct timeval now; 
    struct ril_event * tev = timer_list.next; 
    struct ril_event * next; 
 
    getNow(&now); 
    // walk list, see if now >= ev->timeout for any events 
 
    dlog("~~~~ Looking for timers <= %ds + %dus ~~~~", (int)now.tv_sec, (int)now.tv_usec); 
    while ((tev != &timer_list) && (timercmp(&now, &tev->timeout, >))) { 
        // Timer expired 
        dlog("~~~~ firing timer ~~~~"); 
        next = tev->next; 
        removeFromList(tev); 
        addToList(tev, &pending_list); 
        tev = next; 
    } 
    MUTEX_RELEASE(); 
    dlog("~~~~ -processTimeouts ~~~~"); 

 
// 遍歷監控列表watch_table[]中的事件,並將有數據可讀的事件 
// 添加到pending_list鏈表中,同時如果事件的persist不為true 
// 則將該事件從watch_table[]中移除 
static void processReadReadies(fd_set * rfds, int n) 

    dlog("~~~~ +processReadReadies (%d) ~~~~", n); 
    MUTEX_ACQUIRE(); 
 
    for (int i = 0; (i < MAX_FD_EVENTS) && (n > 0); i++) { 
        struct ril_event * rev = watch_table[i]; 
        if (rev != NULL && FD_ISSET(rev->fd, rfds)) { 
            addToList(rev, &pending_list); 
            if (rev->persist == false) { 
                removeWatch(rev, i); 
            } 
            n–; 
        } 
    } 
 
    MUTEX_RELEASE(); 
    dlog("~~~~ -processReadReadies (%d) ~~~~", n); 

 
// 依次調用待處理隊列pending_list中的事件的回調函數 
static void firePending() 

    dlog("~~~~ +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; 
    } 
    dlog("~~~~ -firePending ~~~~"); 

 
// 計算timer_list鏈表中下一個事件的新的超時時間 
static int calcNextTimeout(struct timeval * tv) 

    struct ril_event * tev = timer_list.next; 
    struct timeval now; 
 
    getNow(&now); 
 
    // Sorted list, so calc based on first node 
    if (tev == &timer_list) { 
        // no pending timers 
        return -1; 
    } 
 
    dlog("~~~~ now = %ds + %dus ~~~~", (int)now.tv_sec, (int)now.tv_usec); 
    dlog("~~~~ next = %ds + %dus ~~~~", 
            (int)tev->timeout.tv_sec, (int)tev->timeout.tv_usec); 
    if (timercmp(&tev->timeout, &now, >)) { 
        timersub(&tev->timeout, &now, tv); 
    } else { 
        // timer already expired. 
        tv->tv_sec = tv->tv_usec = 0; 
    } 
    return 0; 

 
// 初始化內部數據結構(互斥量、FD集合、三個事件隊列) 
void ril_event_init() 

    MUTEX_INIT(); 
 
    FD_ZERO(&readFds); 
    init_list(&timer_list); 
    init_list(&pending_list); 
    memset(watch_table, 0, sizeof(watch_table)); 

 
// 初始化一個ril事件 
void ril_event_set(struct ril_event * ev, int fd, bool persist, ril_event_cb func, void * param) 

    dlog("~~~~ ril_event_set %x ~~~~", (unsigned int)ev); 
    memset(ev, 0, sizeof(struct ril_event)); 
    ev->fd = fd; 
    ev->index = -1; 
    ev->persist = persist; 
    ev->func = func; 
    ev->param = param; 
     
    //linux的文件上鎖函數,給文件描述符fd上非阻塞的文件鎖 
    fcntl(fd, F_SETFL, O_NONBLOCK); 

 
// 將事件添加到監控列表watch_table[]中 
void ril_event_add(struct ril_event * ev) 

    dlog("~~~~ +ril_event_add ~~~~"); 
    MUTEX_ACQUIRE(); 
    for (int i = 0; i < MAX_FD_EVENTS; i++) { 
        if (watch_table[i] == NULL) { 
            watch_table[i] = ev; 
            ev->index = i; 
            dlog("~~~~ added at %d ~~~~", i); 
            dump_event(ev); 
            FD_SET(ev->fd, &readFds); 
            if (ev->fd >= nfds) nfds = ev->fd+1; 
            dlog("~~~~ nfds = %d ~~~~", nfds); 
            break; 
        } 
    } 
    MUTEX_RELEASE(); 
    dlog("~~~~ -ril_event_add ~~~~"); 

 
// 增加一個timer事件到timer_list鏈表中 
void ril_timer_add(struct ril_event * ev, struct timeval * tv) 

    dlog("~~~~ +ril_timer_add ~~~~"); 
    MUTEX_ACQUIRE(); 
 
    struct ril_event * list; 
    if (tv != NULL) { 
        // add to timer list 
        list = timer_list.next; 
        ev->fd = -1; // make sure fd is invalid 
 
        struct timeval now; 
        getNow(&now); 
        timeradd(&now, tv, &ev->timeout); 
 
        // 根據timeout值從小到大在鏈表中排序 
        while (timercmp(&list->timeout, &ev->timeout, < ) 
                && (list != &timer_list)) { 
            list = list->next; 
        } 
        // 循環結束後,list指向鏈表中第一個timeout值大於ev的事件 
    // 將新加入的事件ev加到list此刻指向的事件前面 
        addToList(ev, list); 
    } 
 
    MUTEX_RELEASE(); 
    dlog("~~~~ -ril_timer_add ~~~~"); 

 
// 將事件從watch_table[]中移除 
void ril_event_del(struct ril_event * ev) 

    dlog("~~~~ +ril_event_del ~~~~"); 
    MUTEX_ACQUIRE(); 
 
    if (ev->index < 0 || ev->index >= MAX_FD_EVENTS) { 
        MUTEX_RELEASE(); 
        return; 
    } 
 
    removeWatch(ev, ev->index); 
 
    MUTEX_RELEASE(); 
    dlog("~~~~ -ril_event_del ~~~~"); 

 
#if DEBUG 
// 打印監控列表中可用的事件 
static void printReadies(fd_set * rfds) 

    for (int i = 0; (i < MAX_FD_EVENTS); i++) { 
        struct ril_event * rev = watch_table[i]; 
        if (rev != NULL && FD_ISSET(rev->fd, rfds)) { 
          dlog("DON: fd=%d is ready", rev->fd); 
        } 
    } 

#else 
#define printReadies(rfds) do {} while(0) 
#endif 
 
void ril_event_loop() 

    int n; 
    fd_set rfds; 
    struct timeval tv; 
    struct timeval * ptv; 
 
    for (;;) { 
        // make local copy of read fd_set 
        memcpy(&rfds, &readFds, sizeof(fd_set)); 
    // 根據timer_list來計算select函數的等待時間 
    // timer_list之前已按事件的超時時間排好序瞭 
        if (-1 == calcNextTimeout(&tv)) { 
            // no pending timers; block indefinitely 
            dlog("~~~~ no timers; blocking indefinitely ~~~~"); 
            ptv = NULL; 
        } else { 
            dlog("~~~~ blocking for %ds + %dus ~~~~", (int)tv.tv_sec, (int)tv.tv_usec); 
            ptv = &tv; 
        } 
        printReadies(&rfds); 
    // 使用select函數實現多路IO復用 
        n = select(nfds, &rfds, NULL, NULL, ptv); 
        printReadies(&rfds); 
        dlog("~~~~ %d events fired ~~~~", n); 
        if (n < 0) { 
            if (errno == EINTR) continue; 
 
            LOGE("ril_event: select error (%d)", errno); 
            // bail? 
            return; 
        } 
 
        // Check for timeouts 
        processTimeouts(); 
        // Check for read-ready 
        processReadReadies(&rfds, n); 
        // Fire away 
        firePending(); 
    } 

摘自 ASCE1885的專欄

發佈留言