libubox组件（3）——uloop

一：uloop概述

• uloop有三个功能： 文件描述符触发事件的监控，  timeout定时器处理， 当前进程的子进程的维护

二： uloop的整体框架

/**
 * 初始化事件循环
 *主要工作是poll_fd = epoll_create(32);/* 创建一个epoll的文件描述符监控句柄。最多监控32个文件描述符
 **/
int uloop_init(void)
{
    if (poll_fd >= 0)
        return 0;

    poll_fd = epoll_create(32);/* 创建一个epoll的句柄。最多监控32个文件描述符 */
    if (poll_fd < 0)
        return -1;

    fcntl(poll_fd, F_SETFD, fcntl(poll_fd, F_GETFD) | FD_CLOEXEC); /* fd_cloexecs */
    return 0;
}


/**
 * 事件循环主处理入口
 *1.当某一个进程第一次调用uloop_run时，注册sigchld和sigint信号
 *2.循环获取当前时间，把超时的timeout处理掉，有一条timeout链表在维护
 *3.循环检测是否收到一个sigchld信号，如果收到，删除对应的子进程，有一条process子进程链表在维护
 *4.循环调用epoll_wait 监相应的触发事件文件描述符fd
 **/
void uloop_run(void)
{
    static int recursive_calls = 0; /* static value */
    struct timeval tv;

    /*
     * Handlers are only updated for the first call to uloop_run() (and restored
     * when this call is done).
     */
    if (!recursive_calls++) /* 第一次运行uloop_run时调用, 注册信号处理函数 */
        uloop_setup_signals(true);

    uloop_cancelled = false;
    while(!uloop_cancelled)
    {
        uloop_gettime(&tv); /* 获取当前时间 */
        uloop_process_timeouts(&tv); /* 把超时的timeout清理掉 */
        if (uloop_cancelled)
            break;

        if (do_sigchld) /*  收到一个sigchld的信号 */
            uloop_handle_processes(); /* 销毁该进程的uloop_process */
        uloop_gettime(&tv);
        uloop_run_events(uloop_get_next_timeout(&tv));/* 处理相应的触发事件fd */
    }

    if (!--recursive_calls)
        uloop_setup_signals(false);
}


/**
 * 销毁事件循环
 * 关闭epoll描述符
 * 销毁子进程链表
 * 销毁timeout链表
**/
void uloop_done(void)
{
    if (poll_fd < 0)
        return;

    close(poll_fd);
    poll_fd = -1;

    uloop_clear_timeouts();
    uloop_clear_processes();
}

三：uloop文件描述符触发事件的监控

#define ULOOP_READ        (1 << 0)
#define ULOOP_WRITE        (1 << 1)
#define ULOOP_EDGE_TRIGGER    (1 << 2)
#define ULOOP_BLOCKING        (1 << 3)

#define ULOOP_EVENT_MASK    (ULOOP_READ | ULOOP_WRITE)
/* internal flags */
#define ULOOP_EVENT_BUFFERED    (1 << 4)
#define ULOOP_ERROR_CB        (1 << 6)
struct uloop_fd
{
    uloop_fd_handler cb; /* 文件描述符对应的处理函数 */
    int fd;                         /*文件描述符*/
    bool eof;                    /*EOF*/
    bool error;                 /*出错*/
    bool registered;        /*是否已经添加到epoll的监控队列*/
    uint8_t flags;           /*ULOOP_READ | ULOOP_WRITE | ULOOP_BLOCKING等*/
};

/**
 * 注册一个新描述符到事件处理循环
 */
int uloop_fd_add(struct uloop_fd *sock, unsigned int flags)

/**
 * 从事件处理循环中销毁指定描述符
 */
int uloop_fd_delete(struct uloop_fd *sock)

 

例子：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <libubox/usock.h>
#include <libubox/uloop.h>
static void recv_string(struct uloop_fd *u, unsigned int events)
{
    char buf[1024] = {0};
    if (events & ULOOP_READ) {
        if ( recv(u->fd, buf, 1024, 0) > 0) {
            printf("recv_buf: %s
", buf);
            send(u->fd, "helloworld from server", strlen("helloworld from server"), 0);
        }
    }
}

static void read_std(struct uloop_fd *u, unsigned int events)
{
    char buf[1024] = {0};
    if (events & ULOOP_READ) {
        if ( read(u->fd, buf, 1024) > 0) {
            printf("read_std: %s
", buf);
        }
    }
}

int main()
{
    struct sockaddr_in cli_addr;
    socklen_t len = sizeof(struct sockaddr);
    int type = USOCK_TCP | USOCK_SERVER  | USOCK_NOCLOEXEC | USOCK_IPV4ONLY;
    const char *host = "CarRadio";
    const char *service = "8000";
    char recv_buf[1024] = {0};
    int connect_fd, u_fd = usock(type, host, service);
    if (u_fd < 0) {
        perror("usock");
        return -1;
    }

    connect_fd = accept(u_fd, (struct sockaddr *)(&cli_addr), &len);
    if (connect_fd < 0) {
        perror("accept");
        return -1;
    }
    struct uloop_fd fd[2] = {
        {
            .cb = recv_string,
            .fd = connect_fd,
            .registered = false,
            .flags = ULOOP_READ,
        },
        {
            .cb = read_std,
            .fd = STDIN_FILENO,
            .registered = false,
            .flags = ULOOP_READ,
        }
    };
    uloop_init();
    /*添加uloop_fd*/
    uloop_fd_add(&fd[0], ULOOP_READ);
    uloop_fd_add(&fd[1], ULOOP_READ);
    uloop_run();

    uloop_fd_delete(&fd[0]);
    uloop_done();

    return 0;
}

四：timeout定时器处理

建立一条链表管理所有的timeout节点

   1:  struct uloop_timeout

   2:  {

   3:      struct list_head list;  //链表节点

   4:      bool pending;           //添加一个新的timeout pending是true， false删除该节点timeout

   5:   

   6:      uloop_timeout_handler cb; //超时处理函数

   7:      struct timeval time;       //超时时间

   8:  };

   9:   

  10:  /**

  11:   * 注册一个新定时器

  12:   */

  13:  int uloop_timeout_add(struct uloop_timeout *timeout)；

  14:   

  15:  /**

  16:   * 设置定时器超时时间(毫秒)，并添加

  17:   */

  18:  int uloop_timeout_set(struct uloop_timeout *timeout, int msecs)；

  19:   

  20:  /**

  21:   * 销毁指定定时器

  22:   */

  23:  int uloop_timeout_cancel(struct uloop_timeout *timeout)；

  24:   

  25:  /**

  26:   * 获取定时器还剩多长时间超时

  27:   */

  28:  int uloop_timeout_remaining(struct uloop_timeout *timeout)；

例子：

   1:  #include <stdio.h>

   2:  #include <stdlib.h>

   3:  #include <string.h>

   4:  #include <sys/types.h>          /* See NOTES */

   5:  #include <sys/socket.h>

   6:  #include <libubox/usock.h>

   7:  #include <libubox/uloop.h>

   8:  int g_fd = -1;

   9:  void send_sock(struct uloop_timeout *t);

  10:   

  11:  struct uloop_timeout tm = {

  12:          .cb = send_sock,

  13:  };

  14:  void send_sock(struct uloop_timeout *t)

  15:  {

  16:      char buf[1024] = {0};

  17:      send(g_fd, "hello world from cilent", strlen("hello world from cilent"), 0);

  18:      if ( recv(g_fd, buf, 1024, 0) > 0) {

  19:              printf("
recv_buf: %s
", buf);

  20:      }

  21:      /* 添加uloop_timeout 实现循环定时 */

  22:      uloop_timeout_set(&tm, 5000);

  23:  }

  24:  int main()

  25:  {

  26:      struct sockaddr cli_addr;

  27:      socklen_t len = sizeof(struct sockaddr);

  28:      int type = USOCK_TCP  | USOCK_NOCLOEXEC | USOCK_IPV4ONLY;

  29:      const char *host = "CarRadio";

  30:      const char *service = "8000";

  31:      char recv_buf[1024] = {0};

  32:      g_fd = usock(type, host, service);    /* create a linker socket*/

  33:      if (g_fd < 0) {

  34:          perror("usock");

  35:          return -1;

  36:      }

  37:      uloop_init();

  38:      /*添加uloop_timeout*/

  39:      uloop_timeout_set(&tm, 5000);

  40:      uloop_run();

  41:      uloop_done();

  42:      

  43:      close(g_fd);

  44:      return 0;

  45:  }

  46:   

五：当前进程的子进程的维护建立一条process链表管理所有的进程id

   1:  struct uloop_process {

   2:      struct list_head list;              

   3:      bool pending;                   

   4:      uloop_process_handler cb;       /** 文件描述符， 调用者初始化 */

   5:      pid_t pid;                                 /** 文件描述符， 调用者初始化 */

   6:  };

   7:  /* 进程退出时回调函数 */

   8:  typedef void (*uloop_process_handler)(struct uloop_process *c, int ret) ；

   9:  /**

  10:   * 注册新进程到事件处理循环

  11:   */

  12:  int uloop_process_add(struct uloop_process *p)；

  13:   

  14:  /**

  15:   * 从事件处理循环中销毁指定进程

  16:   */

  17:  int uloop_process_delete(struct uloop_process *p)；

例子：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>          /* See NOTES */
#include <unistd.h>
#include <libubox/uloop.h>

struct uloop_process *u_process = NULL;
/*c: 代表推出的进程, ret:代表推出的状态*/
void process_exit(struct uloop_process *c, int ret)
{
    printf("child process exit id[%d], status[%#x]
", c->pid, ret);
    free(c);
}

void child_process(int t)
{
    printf(" process pid: %d is runing
", getpid());
    if (t > 0)
        sleep(t);
    printf("process id[%d] will exit...
", getpid());

    exit(t);
}

int main()
{
    int i;
    pid_t pid;
    uloop_init();
    for (i = 0 ; i < 10; i++) {
        usleep(500);
        pid = fork();
        if (pid == 0) {//子进程
            child_process( (i+1)*10 ); //子进程休眠(i+1)*10s
        }
        else {
            u_process =
            (struct uloop_process *)malloc(sizeof(struct uloop_process));
            if (NULL == u_process) {
                perror("malloc");
                exit(-1);
            }
            u_process->pid = pid;
            u_process->cb = process_exit;
            u_process->pending = false;
            if (uloop_process_add(u_process) < 0) {
                printf("uloop_process_add failed...
");
            }
            printf("success create process pid: %d
", pid);
        }
    }
    printf("uloop_runing....
");
    uloop_run();
    uloop_done();

    return 0;
}