sloop公共程序之初始过程及启动

1：sloop_init（）

　　初始化主要是初始化静态sloop_*** 结构体和填充struct sloop_data 结构体中的成员。

 //初始化静态存储区给sloop_***结构体
 static struct sloop_socket  _sloop_sockets[MAX_SLOOP_SOCKET];
 static struct sloop_timeout _sloop_timeout[MAX_SLOOP_TIMEOUT];
 static struct sloop_signal  _sloop_signals[MAX_SLOOP_SIGNAL];

 /* sloop module initialization */
 void sloop_init(void * sloop_data)
 {
     memset(&sloop, , sizeof(sloop));
     INIT_DLIST_HEAD(&sloop.readers);
     INIT_DLIST_HEAD(&sloop.writers);
     INIT_DLIST_HEAD(&sloop.signals);
     INIT_DLIST_HEAD(&sloop.timeout);
     INIT_DLIST_HEAD(&sloop.free_sockets);
     INIT_DLIST_HEAD(&sloop.free_timeout);
     INIT_DLIST_HEAD(&sloop.free_signals);
     init_list_pools();
     pipe(sloop.signal_pipe);
     sloop.sloop_data = sloop_data;
 }

 /* initialize list pools */
 static void init_list_pools(void)
 {
     int i;
     memset(_sloop_sockets, , sizeof(_sloop_sockets));
     memset(_sloop_timeout, , sizeof(_sloop_timeout));
     memset(_sloop_signals, , sizeof(_sloop_signals));
     for (i=; i<MAX_SLOOP_SOCKET; i++) dlist_add(&_sloop_sockets[i].list, &sloop.free_sockets);
     for (i=; i<MAX_SLOOP_TIMEOUT;i++) dlist_add(&_sloop_timeout[i].list, &sloop.free_timeout);
     for (i=; i<MAX_SLOOP_SIGNAL; i++) dlist_add(&_sloop_signals[i].list, &sloop.free_signals);
 }

　　执行完sloop_init函数之后，静态数组_sloop_sockets、_sloop_signals、_sloop_timeout中的所有成员都被挂载到了sloop.free_sockets、sloop.free_timeout、sloop.free_signals这三个双链表中，表示可使用的链表，等待调用者。

2：sloop_run（）

　　此函数启动循环进行监听，监听是sloop.terminate全局变量控制，这个变量由信号控制。

 void sloop_run(void)
 {
     fd_set rfds;
     fd_set wfds;
     struct timeval tv, now;
     struct sloop_timeout * entry_timeout = NULL;
     struct sloop_socket * entry_socket;
     struct sloop_signal * entry_signal;
     struct dlist_head * entry;
     int max_sock;
     int res;
     int sig;
     // 开始循环
     while (!sloop.terminate) {
         /* 是否有定时器加入 */
         if (!dlist_empty(&sloop.timeout)) {
             entry = sloop.timeout.next;
             entry_timeout = dlist_entry(entry, struct sloop_timeout, list);
         } else {
             entry_timeout = NULL;
         }
         /* 有定时器 */
         if (entry_timeout) {
             /* 获取当前时间 */
             gettimeofday(&now, NULL);
             /* 当前时间>=定时器表示应该执行定时器的回调函数了 */
             if (timercmp(&now, &entry_timeout->time, >= ))
                 tv.tv_sec = tv.tv_usec = ;/* tv是select函数的timeout，直接置0表示不阻塞 */
             else
                 timersub(&entry_timeout->time, &now, &tv);/* 否则阻塞 '当前时间-到期时间' */
         }

         /* 清空读写描述符集合 */
         FD_ZERO(&rfds);
         FD_ZERO(&wfds);
         max_sock = ;

         /* 添加信号可读转状态 */
         FD_SET(sloop.signal_pipe[], &rfds);
         if (max_sock < sloop.signal_pipe[]) max_sock = sloop.signal_pipe[];

         /* 添加套接字可读转状态 */
         for (entry = sloop.readers.next; entry != &sloop.readers; entry = entry->next) {
             entry_socket = dlist_entry(entry, struct sloop_socket, list);
             FD_SET(entry_socket->sock, &rfds);
             if (max_sock < entry_socket->sock) max_sock = entry_socket->sock;
         }
         /* 添加套接字可写转状态 */
         for (entry = sloop.writers.next; entry != &sloop.writers; entry = entry->next) {
             entry_socket = dlist_entry(entry, struct sloop_socket, list);
             FD_SET(entry_socket->sock, &wfds);
             if (max_sock < entry_socket->sock) max_sock = entry_socket->sock;
         }

         d_dbg("sloop: >>> enter select sloop !!\n");
         res = select(max_sock + , &rfds, &wfds, NULL, entry_timeout ? &tv : NULL);

         if (res < ) {
             /* 意外被中断 */
             if (errno == EINTR) {
                 d_info("sloop: sloop_run(): EINTR!\n");
                 continue;
             } else {
                 d_error("sloop: sloop_run(): select error (%s)!\n", strerror(errno));
                 break;
             }
         }

         /* 先检查信号 */
         if (res >  && FD_ISSET(sloop.signal_pipe[], &rfds)) {
             if (read(sloop.signal_pipe[], &sig, sizeof(sig)) < ) {
                 /* probabaly just EINTR */
                 d_error("sloop: sloop_run(): Could not read signal: %s\n", strerror(errno));
             } else if (sig == ) {
                 d_info("sloop: get myself signal !!\n");
             } else if (!dlist_empty(&sloop.signals)) {
                 for (entry = sloop.signals.next; entry != &sloop.signals; entry = entry->next) {
                     entry_signal = dlist_entry(entry, struct sloop_signal, list);
                     /* 通过信号值找到登记的信号结构体并执行回调函数 */
                     if (entry_signal->sig == sig) {
                         if (entry_signal->handler(entry_signal->sig, entry_signal->param, sloop.sloop_data) < ) {
                             dlist_del(entry);
                             free_signal(entry_signal);
                         }
                         break;
                     }
                 }
                 if (sloop.terminate) break;
             } else {
                 SLOOPDBG(d_info("sloop: should not be here !!\n"));
             }
         }

         /* 检查定时器 */
         if (entry_timeout) {
             if (sloop.timeout.next == &entry_timeout->list) {
                 gettimeofday(&now, NULL);
                 if (res ==  || timercmp(&now, &entry_timeout->time, >= )) {
                     /* 当前时间>=到期时间就调用回调函数 */
                     if (entry_timeout->handler)
                         entry_timeout->handler(entry_timeout->param, sloop.sloop_data);
                     dlist_del(&entry_timeout->list);//删除了定时器
                     free_timeout(entry_timeout);//将此定时器又归还给free_timeout双链表
                 }
             } else {
                 SLOOPDBG(d_info("sloop: timeout (0x%x) is gone, should be canceled !!!\n", entry_timeout));
             }
         }

         /* 检查可读状态 */
         if (!dlist_empty(&sloop.readers)) {
             entry = sloop.readers.next;
             while (entry != &sloop.readers) {
                 /* dlist_entry函数通过list指针获得指向list所在结构体的指针 */
                 entry_socket = dlist_entry(entry, struct sloop_socket, list);
                 if (FD_ISSET(entry_socket->sock, &rfds))/* 读状态就绪执行回调函数 */
                     res = entry_socket->handler(entry_socket->sock, entry_socket->param, sloop.sloop_data);
                 else
                     res = ;
                 entry = entry->next;

                 /* 不同于定时器，只有回调函数返回错误才将此结构归还给free_readers，否则一直会监听此描述符 */
                 if (res < ) {
                     dlist_del(&entry_socket->list);
                     free_socket(entry_socket);
                 }
             }
         }

         /* 检查可写状态 */
         if (!dlist_empty(&sloop.writers)) {
             entry = sloop.writers.next;
             while (entry != &sloop.writers) {
                 entry_socket = dlist_entry(entry, struct sloop_socket, list);
                 if (FD_ISSET(entry_socket->sock, &wfds))
                     res = entry_socket->handler(entry_socket->sock, entry_socket->param, sloop.sloop_data);
                 else
                     res = ;
                 entry = entry->next;

                 if (res < ) {
                     dlist_del(&entry_socket->list);
                     free_socket(entry_socket);
                 }
             }
         }
     }
     /* 在退出循环时要将所有的都归还给free_***结构体 */
     sloop_cancel_signal(NULL);
     sloop_cancel_timeout(NULL);
     sloop_cancel_read_sock(NULL);
     sloop_cancel_write_sock(NULL);
 }

　　目前来讲，在sloop_data结构体中，struct dlist_head readers，struct dlist_head writers，struct dlist_head signals，struct dlist_head timeout，等链表都是空的，所以sloop_run其实没有做任何工作，要想真正起作用就需要将需要监听的套接字、定时器、信号等加入上上面三个链表中来。下一篇：sloop公共函数之添加信号，定时器及socket。