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。