(本文独家发布在金蝶云社区上)

RIL 概览

RIL是“Radio Interface Layer”的缩写。在Android软件框架中，RIL子系统向下与BaseBand芯片通信，向上给Android框架提供电话相关服务，如Call，SMS等。它在Android软件栈中的位置如下图所示：

在更底层的软件子系统中，RIL通过Linux虚拟串口驱动程序与基带芯片通信，这篇文章我们不准备包含UART驱动程序与真实基带芯片之间交互的细节，所以在此文章中，这个串口基本代表了基带芯片。 在上层软件中，RIL通过套接字与Android Framework通信。Android Framework中的Java层也不是我们主要关注的内容，我们将要讨论的是上图中的绿色部分。

RIL的子模块

Google公司将RIL分为三部分，以保护OEM厂商的IP。这些部分是：RIL守护程序应用程序（RILD），libril.so和reference-ril.so。RILD和libril.so在静态链接中相互引用，它们的实现对用户是开放，但reference-ril.so是Google向OEM提供的参考实现。由于各种移动网络的多样性和复杂性，oem供应商在他们的基带芯片中有自己的私有代码来实现无线通信，他们可能不想公开自己的源代码，因此他们实现了自己的vendor-ril.so。为了降低私有模块和开源模块之间的耦合度，RILD使用动态加载方法与vendor-ril.so进行通信。 他们的源代码位于：

RILD--
    hardware/ril/rild

libril--
    hardware/ril/libril

此外，libril.so和reference-ril.so在RIL架构中具有不同的功能，libril.so用于通过socket通过Android Framework处理I / O消息。 但是reference-ril.so负责与串口通信。

从RILD开始

整个RIL系统是从shell调用RILD命令启动的，所以让我们从它开始。

rild.c中有一个静态结构对象：

static struct RIL_Env s_rilEnv = {
    RIL_onRequestComplete,
    RIL_onUnsolicitedResponse,
    RIL_requestTimedCallback,
};

它包括三个函数指针，它们的实现位于libril.so，它们将由供应商ril使用。 相反，在Ril.h中定义了另一个类似的结构：

typedef struct {
    int version;        /* set to RIL_VERSION */
    RIL_RequestFunc onRequest;
    RIL_RadioStateRequest onStateRequest;
    RIL_Supports supports;
    RIL_Cancel onCancel;
    RIL_GetVersion getVersion;
} RIL_RadioFunctions;

这个结构包括五个函数指针，它们的实现在供应商ril里，它们将由libril.so使用。 因此，供应商ril和libril.so调用彼此的功能来实现RIL系统。 顺便说一句，libril.so和rild通过静态链接连接。 但是android希望隐藏OEM供应商的实现，vendor-ril.so通过动态链接与rild连接。 那么让我们看一下reference-ril.so动态加载的代码片段：

dlHandle = dlopen(rilLibPath, RTLD_NOW);
if (dlHandle == NULL) {
    fprintf(stderr, "dlopen failed: %s\n", dlerror());
    exit(-1);
}

RIL_startEventLoop();
rilInit = (const RIL_RadioFunctions *(*)(const struct RIL_Env *, int, char **))dlsym(dlHandle, "RIL_Init");
if (rilInit == NULL) {
    fprintf(stderr, "RIL_Init not defined or exported in %s\n", rilLibPath);
    exit(-1);
}

正如代码片段向我们展示的那样，我们从配置文件中获取供应商ril的路径，然后调用RIL_startEventLoop，其具体实现在libril.so中，代码如下：

extern "C" void
RIL_startEventLoop(void) {
    int ret;
    pthread_attr_t attr;

    /* spin up eventLoop thread and wait for it to get started */
    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);

    if (ret < 0) {
        LOGE("Failed to create dispatch thread errno:%d", errno);
        return;
    }
}

我们将在下一节讨论这个函数的细节，所以让我们继续阅读RILD的main函数的例程，在调用RIL_startEventLoop之后，我们在vendor ril中得到“RIL_Init”的函数指针，然后在检查函数指针的有效性之后， 我们用main的输入参数调用它：

rilArgv[0] = argv[0];

funcs = rilInit(&s_rilEnv, argc, rilArgv);

LOGD("RIL_register %d", cardNum);
RIL_register(funcs,cardNum);

供应商ril中实现的RIL_Init将执行一些底层操作：

• 将RIL_RadioFunctions指针设置为vendor ril，因此vendor ril可以调用libril的函数。

• 启动mainLoop线程来处理硬件，包括初始化UART，从UART读取数据。

• 返回将在libril.so中使用的五个函数指针到RILD。

我们将在后面的部分中详细讨论它。最后调用的是RIL_register，我们通过这个函数将前面的函数指针传递给libril.so。在RIL_register内部，它连接套接字来和Framework通信，并启动listenCallback事件，就像引擎一样可以随时触发I / O操作。

有关rild例程的摘要，请参见下图：

RIL事件机制

正如最上一节向我们展示的那样，很明显RIL_startEventLoop创建了一个名为eventloop的线程，其代码如下所示：

    static void * eventLoop(void *param) {
        int ret;
        int filedes[2];

        if (signal(SIGPIPE, rilSignalHandler)== SIG_ERR) {
            LOGE ("register SIGPIPE handler fail!!!");
        }
        ril_event_init();

        pthread_mutex_lock(&s_startupMutex);

        s_started = 1;
        pthread_cond_broadcast(&s_startupCond);

        pthread_mutex_unlock(&s_startupMutex);

        ret = pipe(filedes);

        if (ret < 0) {
            LOGE("Error in pipe() errno:%d", errno);
            return NULL;
        }

        s_fdWakeupRead = filedes[0];
        s_fdWakeupWrite = filedes[1];

        fcntl(s_fdWakeupRead, F_SETFL, O_NONBLOCK);

        ril_event_set (&s_wakeupfd_event, s_fdWakeupRead, true,
                processWakeupCallback, NULL);

        rilEventAddWakeup (&s_wakeupfd_event);

        // Only returns on error
        ril_event_loop();
        LOGE ("error in event_loop_base errno:%d", errno);
        // kill self to restart on error
        kill(0, SIGKILL);

        return NULL;
    }

它调用ril_event_init来初始化两个ril_event结构对象：timer_list和pending_list：

    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_event结构指针数组归零，该数组有8个元素：watch_table。 我们稍后会知道这些对象。 那么让我们检查结构ril_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;
    };

我们可以看到ril_event是一个双向链表。我们使用ril_event_init初始化所有事件表，包括timer_list，pending_list和watch_table，它们的声明如下：

static struct ril_event * watch_table[MAX_FD_EVENTS];
static struct ril_event timer_list;
static struct ril_event pending_list;

我们用ril_event_set当作输入参数来填充ril_event对象。

    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;
        fcntl(fd, F_SETFL, O_NONBLOCK);
    }

fd可能是套接字的文件描述符，并通过调用fcntl将其设置为非阻塞状态。

我们还使用ril_event_add将新事件添加到watch_table，并将fd设置到fd_set中去。所以，如果来自这些fd的一些数据可用，可以调用ril_event的回调函数，有一个线程（eventloop）专门做这件事，我们稍后会讨论它。我们还使用了ril_event_del从watch_table中删除特定的ril_event对象。 并且我们还使用函数“ril_timer_add”将事件添加到timer_list，并使用超时时间的升序对其进行排序。

现在，我们将回到函数“eventloop”。在初始化ril_event表之后，定义了一个管道，然后将读取的fd和相关的信息放入一个ril-event，并将其添加到watch_table中，回调函数的实现如下：

static void processWakeupCallback(int fd, short flags, void *param) {
    char buff[16];
    int ret;

    LOGV("processWakeupCallback");

    /* empty our wakeup socket out */
    do {
        ret = read(s_fdWakeupRead, &buff, sizeof(buff));
    } while (ret > 0 || (ret < 0 && errno == EINTR));
}

我们可以写一些数据到管道的fd来唤醒线程，看起来似乎没有理由这样做。但有趣的是，每次添加新的ril_event对象时，都会调用触发器函数“triggerEvLoop”。 rilEventAddWakeup代码如下：

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

我猜测如果在另一个线程中调用rilEventAddWakeup，这个调用将激活eventloop线程。 triggerEvLoop函数将触发processWakeupCallback函数：

    static void triggerEvLoop() {
        int ret;
        if (!pthread_equal(pthread_self(), s_tid_dispatch)) {
            /* trigger event loop to wakeup. No reason to do this,
             * if we're in the event loop thread */
             do {
                ret = write (s_fdWakeupWrite, " ", 1);
             } while (ret < 0 && errno == EINTR);
        }
    }

eventloop的核心部分

eventloop最重要的部分是ril_event_loop，它使用select系统调用来管理一些文件描述符。 它还有一些细节需要分析。

    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));
            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);
            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();
        }
    }

这是一个死循环，但它仍然有一个专门处理错误的case来退出死循环。那么我们先从calcNextTimeout开始吧。

我们使用此函数来检查timer_list中是否有挂起的计时器。如果timer_list中没有元素，则该函数返回-1，并且select系统调用将无限期地阻塞自身。 我们应该进入这个函数看看究竟：

    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;
    }

如果我们有挂起的计时器事件，我们将比较第一个元素的超时值和当前时间（从系统启动开始）。 如果tev->timeout大于当前时间，则事件tev不会超时，因此将tev的超时值与当前时间之间的差值设置为tv。 反之亦然，如果tev->timeout小于当前时间，我们将tv设置为零。回到ril_event_loop，select系统调用可以从calcNextTimeout获取超时值。我想我们应该知道如何获得挂起的计时器，因此让我们来看一下ril_timer_add的细节：

    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);

            // keep list sorted
            while (timercmp(&list->timeout, &ev->timeout, < )
                && (list != &timer_list)) {
                list = list->next;
            }
            // list now points to the first event older than ev
            addToList(ev, list);
        }

        MUTEX_RELEASE();
        dlog("~~~~ -ril_timer_add ~~~~");
    }

正如之前的代码片段所示，timer_list由ril_event_init中的init_list初始化，因此如果timer_list中没有元素，则timer_list的next指针和prev指针都指向自身。 

我们将相对时间间隔添加到当前时间，然后将此总和设置到新的ril_event指针ev，然后找到链表中能够保持比较大的一个元素位于后面的位置，可以保证第一个事件是最早的事件。

之后，我们可以确认传递给select系统调用的超时值。如果调用select有错误，它将打破死循环，但相应的错误会被忽略。如果文件描述符中的数据可用，则将调用最后的3个函数：

• processTimeouts

• processReadReadies

• firePending

最后三个函数

If the data comes, we left three kicks. So let’s dive into the first kick: 
如果有数据来了，余下的就剩三个函数。我们先看第一个函数：

    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 ~~~~");
    }

解释起来很简单：我们遍历time_list以查找超时小于当前时间的事件，换句话说，我们要查找超时事件，并将其从timer_list中删除，然后添加到pending_list。

第二个函数：

    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);
    }

在此函数中，我们扫描watch_table以检查元素是否已准备好接收数据，然后将其添加到pending_list。 我们是否从watch_table中删除ready项取决于此项中的persist值。

最后一个函数：

    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 ~~~~");
    }

现在，pending_list包括所有准备读取的事件，因此我们遍历pending_list，触发所有这些事件，调用它们自己的回调函数。