LwIP 之四 超时处理/定时器（timeouts.c/h）

  目前，网络上多数文章所使用的LwIP版本为1.4.1。最新版本为2.0.3。从1.4.1到2.0.3（貌似从2.0.0开始），LwIP的源码有了一定的变化，甚至于源码的文件结构也不一样，内部的一些实现源文件也被更新和替换了。

简介

  在LwIP中很多时候都要用到超时处理，超时处理的实现是 TCP/IP 协议栈中一个重要部分。LwIP为每个与外界网络连接的任务都有设定了 timeout 属性，即等待超时时间。超时处理的相关代码实现在timeouts.c/h中。
  在旧版本得LwIP中，超时处理被称之为定时器，但是，在最新版的LwIP中，原来的timer已经被删除，转而使用了timeouts来代替。实际的实现上也有一定的区别。
  在该文件中，针对有误操作系统（宏NO_SYS），对外提供的函数是不同的，下面看看这个文件的总结构。

/* 第一部分：定义LwIP内部使用使用的循环定时器 */
const struct lwip_cyclic_timer lwip_cyclic_timers[];
/* 第二部分：各函数 */
#if LWIP_TIMERS && !LWIP_TIMERS_CUSTOM   /* 使用 LwIP提供的定时器 */
/* 对外提供的第一个函数*/
void
tcp_timer_needed(void);

void sys_timeouts_init(void);	/* 初始化本模块 */

void
sys_timeout(u32_t msecs, sys_timeout_handler handler, void *arg) /* 注册函数 */

#else      /* 用户自定义定时器 */
void
tcp_timer_needed(void)		/* 必须由外部实现该函数 */
{
}
#endif

内部定时器

  在timeouts.c/h中，第一部分便是一个被称为lwip_cyclic_timer的结构。LwIP使用该结构存放了其内部使用的循环定时器。这些定时器在LwIP初始化时通过函数void sys_timeouts_init(void)调用定时器注册函数void sys_timeout(u32_t msecs, sys_timeout_handler handler, void *arg)注册进入超时管理链表中。在2.0.0之前的版本中，是没有该部分的。该部分被分开在了LwIP内部，现在进行了统一处理。lwip_cyclic_timer的结构如下：

/** Function prototype for a stack-internal timer function that has to be
 * called at a defined interval */
typedef void (* lwip_cyclic_timer_handler)(void);

/** This struct contains information about a stack-internal timer function
 that has to be called at a defined interval */
struct lwip_cyclic_timer {
  u32_t interval_ms;
  lwip_cyclic_timer_handler handler;
#if LWIP_DEBUG_TIMERNAMES
  const char* handler_name;
#endif /* LWIP_DEBUG_TIMERNAMES */
};

  在timeouts.c中，有如下全局变量，存放了LwIP内部使用的各定时器

/** This array contains all stack-internal cyclic timers. To get the number of
 * timers, use LWIP_ARRAYSIZE() */
const struct lwip_cyclic_timer lwip_cyclic_timers[] = {
#if LWIP_TCP
  /* The TCP timer is a special case: it does not have to run always and
     is triggered to start from TCP using tcp_timer_needed() */
  {TCP_TMR_INTERVAL, HANDLER(tcp_tmr)},
#endif /* LWIP_TCP */
#if LWIP_IPV4
#if IP_REASSEMBLY
  {IP_TMR_INTERVAL, HANDLER(ip_reass_tmr)},
#endif /* IP_REASSEMBLY */
#if LWIP_ARP
  {ARP_TMR_INTERVAL, HANDLER(etharp_tmr)},
#endif /* LWIP_ARP */
#if LWIP_DHCP
  {DHCP_COARSE_TIMER_MSECS, HANDLER(dhcp_coarse_tmr)},
  {DHCP_FINE_TIMER_MSECS, HANDLER(dhcp_fine_tmr)},
#endif /* LWIP_DHCP */
#if LWIP_AUTOIP
  {AUTOIP_TMR_INTERVAL, HANDLER(autoip_tmr)},
#endif /* LWIP_AUTOIP */
#if LWIP_IGMP
  {IGMP_TMR_INTERVAL, HANDLER(igmp_tmr)},
#endif /* LWIP_IGMP */
#endif /* LWIP_IPV4 */
#if LWIP_DNS
  {DNS_TMR_INTERVAL, HANDLER(dns_tmr)},
#endif /* LWIP_DNS */
#if LWIP_IPV6
  {ND6_TMR_INTERVAL, HANDLER(nd6_tmr)},
#if LWIP_IPV6_REASS
  {IP6_REASS_TMR_INTERVAL, HANDLER(ip6_reass_tmr)},
#endif /* LWIP_IPV6_REASS */
#if LWIP_IPV6_MLD
  {MLD6_TMR_INTERVAL, HANDLER(mld6_tmr)},
#endif /* LWIP_IPV6_MLD */
#endif /* LWIP_IPV6 */
};

该部分通关函数void sys_timeouts_init(void);将内部使用的延时定时器注册进入链表中，如下图：

超时处理链表

  超时定时器是按链表的形式进行组织的，且按时间长短进行排序，时间最短的永远在最前面。使用全局变量static struct sys_timeo *next_timeout;指示超时链表，该指针即为超时链表的头。超时链表需要通过函数void sys_timeout(u32_t msecs, sys_timeout_handler handler, void *arg)进行注册。链表的节点使用如下结构体表示：

/** Function prototype for a timeout callback function. Register such a function
 * using sys_timeout().
 *
 * @param arg Additional argument to pass to the function - set up by sys_timeout()
 */
typedef void (* sys_timeout_handler)(void *arg);

struct sys_timeo {
  struct sys_timeo *next;
  u32_t time;
  sys_timeout_handler h;
  void *arg;
#if LWIP_DEBUG_TIMERNAMES
  const char* handler_name;
#endif /* LWIP_DEBUG_TIMERNAMES */
};

超时定时器注册

  下面详细分析一下void sys_timeout(u32_t msecs, sys_timeout_handler handler, void *arg)是如何对超时函数进行注册的。源码很简单。

  u32_t now, diff;
	/* 1. 申请节点内存 */
  timeout = (struct sys_timeo *)memp_malloc(MEMP_SYS_TIMEOUT);
  if (timeout == NULL) {
    LWIP_ASSERT("sys_timeout: timeout != NULL, pool MEMP_SYS_TIMEOUT is empty", timeout != NULL);
    return;
  }
	/* 2.计算差值，至于为什么要额外搞个差值，暂时还没搞明白！！！ */
  now = sys_now();
  if (next_timeout == NULL) {
    diff = 0;
    timeouts_last_time = now;
  } else {
    diff = now - timeouts_last_time;
  }
	/* 3. 节点各变量赋值 */
  timeout->next = NULL;
  timeout->h = handler;
  timeout->arg = arg;
  timeout->time = msecs + diff;
#if LWIP_DEBUG_TIMERNAMES
  timeout->handler_name = handler_name;
  LWIP_DEBUGF(TIMERS_DEBUG, ("sys_timeout: %p msecs=%"U32_F" handler=%s arg=%p\n",
    (void *)timeout, msecs, handler_name, (void *)arg));
#endif /* LWIP_DEBUG_TIMERNAMES */
/* 4. 如果创建的是第一个定时器，则不用特殊处理，next_timeout是一个全局指针，指向定时器链表中第一个定时器 */
  if (next_timeout == NULL) {
    next_timeout = timeout;
    return;
  }
 /* 4. 从第二个定时器开始就要添加到链表中，添加原则是定时最短的定时器始终在前面。如果新添加的定时器时长小于当前链首定时器，则新添加的定时器成为链首，旧的链首定时器的定时值要减去新链首定时器定时值，
如果新添加的定时器大于等于当前链首定时器的时长，则要在整个链表里逐个比较，
最终插入到合适位置，当然其后定时器的定时值也要进行调整 */
  if (next_timeout->time > msecs) {
    next_timeout->time -= msecs;
    timeout->next = next_timeout;
    next_timeout = timeout;
  } else {
    for (t = next_timeout; t != NULL; t = t->next) {
      timeout->time -= t->time;
      if (t->next == NULL || t->next->time > timeout->time) {
        if (t->next != NULL) {
          t->next->time -= timeout->time;
        } else if (timeout->time > msecs) {
          /* If this is the case, 'timeouts_last_time' and 'now' differs too much.
             This can be due to sys_check_timeouts() not being called at the right
             times, but also when stopping in a breakpoint. Anyway, let's assume
             this is not wanted, so add the first timer's time instead of 'diff' */
          timeout->time = msecs + next_timeout->time;
        }
        timeout->next = t->next;
        t->next = timeout;
        break;
      }
    }
  }

下面举例说明（由于在处理链表时，仅time 有用，因此下面的的其他参数用字母代替）：

1. 插入第一个节点，参数为 time = 20, 其他两个参数用A、B表示
   
2. 插入第二个节点，参数为 time = 15, 其他两个参数用C、D表示，延时时间比之前的短
   
3. 插入第三个节点，参数为 time = 14, 其他两个参数用E、F表示，延时时间比之前的短。
   
4. 插入第四个节点，参数为 time = 30, 其他两个参数用G、H表示，延时时间比之前的长。
   
5. 插入第五个节点，参数为 time = 23, 其他两个参数用I、J表示，延时时间比之前的长。
   
     从上面的举例可以看出，如果新添加的定时器比头结点（next_timeout指向的第一个节点）的时间短，则直接往链表头插入，同时对头结点（next_timeout指向的第一个节点）的时间进行调整，后续节点的时间不动。
     如果新添加的定时器比头结点（next_timeout指向的第一个节点）的时间长，则需要遍历链表，查找合适位置（比其短的定时器之后，比其长的定时器之前）插入，其后定时器的定时值也要进行调整，其前的定时器无需调整。

超时定时器删除

  从超时链表中删除指定的定时器时通过函数void sys_untimeout(sys_timeout_handler handler, void *arg)来完成的。源码很简单。

void
sys_untimeout(sys_timeout_handler handler, void *arg)
{
  struct sys_timeo *prev_t, *t;
	/* 超时链表为空的判断 */
  if (next_timeout == NULL) {
    return;
  }
	/* 从链表头开始遍历这个链表 */
  for (t = next_timeout, prev_t = NULL; t != NULL; prev_t = t, t = t->next) {
    if ((t->h == handler) && (t->arg == arg)) {   /* 条件匹配 */
      /* We have a match */
      /* Unlink from previous in list */
      if (prev_t == NULL) {
        next_timeout = t->next;
      } else {
        prev_t->next = t->next;
      }
      /* If not the last one, add time of this one back to next */
      if (t->next != NULL) {
        t->next->time += t->time;
      }
      memp_free(MEMP_SYS_TIMEOUT, t);     /* 释放节点资源 */
      return;
    }
  }
  return;
}

超时定时器检查

  不管是否有os支持，超时定时器都可以使用。lwip中如下两个函数可以实现对超时的处理：

• void sys_check_timeouts(void)：裸机应用程序在外部周期性调用该函数，每次进来检查定时器链表上定时最短的定时器是否到期，如果没有到期，直接退出该函数，否则，执行该定时器回调函数，并从链表上删除该定时器，然后继续检查下一个定时器，直到没有一个定时器到期退出。
• void sys_timeouts_mbox_fetch(sys_mbox_t *mbox, void **msg)：这个函数可在os线程中循环调用，主要是等待mbox消息，并可阻塞，如果等待mbox时超时，则会同时执行超时事件处理，即调用定时器回调函数，如果一直没有mbox消息，则会永久性地循环将所有超时定时器检查一遍（内部调用了void sys_check_timeouts(void)），一举两得。
    LwIP中tcpip线程就是靠这种方法，即处理了上层及底层的mbox消息，同时处理了所有需要定时处理的事件。

在检查超时定时器链表时，对于已经超时的则进行删除，下面以添加时的例子说明一下检查函数：

• 第一次检查：
  
• 第二次检查：
  
• 第三次检查：
  

总结

还有部分没弄明白，后面更新！