邻居子系统 之 状态定时器回调neigh_timer_handler

概述

在分配邻居子系统之后，会设置定时器来处理那些需要定时器处理的状态，定时器回调函数为neigh_timer_handler；函数会根据状态机变换规则对状态进行切换，切换状态后，如果需要更新输出函数则更新，并更新定时器下一次超时时间；其中NUD_INCOMPLETE | NUD_PROBE状态需要发送邻居请求，如果超过最大次数，则释放缓存中的数据包；

源码分析

 /* 邻居项各个状态的定时器处理回调 */
 static void neigh_timer_handler(unsigned long arg)
 {
     unsigned long now, next;
     struct neighbour *neigh = (struct neighbour *)arg;
     unsigned int state;
     int notify = ;

     write_lock(&neigh->lock);

     state = neigh->nud_state;
     now = jiffies;
     next = now + HZ;

     /* 无定时器状态 */
     if (!(state & NUD_IN_TIMER))
         goto out;

     /* REACHABLE状态 */
     if (state & NUD_REACHABLE) {
         /* 确认时间未超时，设置下次超时时间 */
         if (time_before_eq(now,
                    neigh->confirmed + neigh->parms->reachable_time)) {
             neigh_dbg(, "neigh %p is still alive\n", neigh);
             next = neigh->confirmed + neigh->parms->reachable_time;
         }
         /* 确认时间已经超时了，但是闲置时间未达到 */
         else if (time_before_eq(now,
                       neigh->used +
                       NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) {
             neigh_dbg(, "neigh %p is delayed\n", neigh);
             /* 进入DELAY状态 */
             neigh->nud_state = NUD_DELAY;
             neigh->updated = jiffies;

             /* 更新output函数 */
             neigh_suspect(neigh);
             next = now + NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME);
         }
         /* 确认时间和闲置时间都超时了 */
         else {
             neigh_dbg(, "neigh %p is suspected\n", neigh);
             /* 进入STALE状态 */
             neigh->nud_state = NUD_STALE;
             neigh->updated = jiffies;
             /* 更新输出函数 */
             neigh_suspect(neigh);
             notify = ;
         }
     }
     /* DELAY状态 */
     else if (state & NUD_DELAY) {
         /* 最后一次确认时间没达到超时时间 */
         if (time_before_eq(now,
                    neigh->confirmed +
                    NEIGH_VAR(neigh->parms, DELAY_PROBE_TIME))) {
             neigh_dbg(, "neigh %p is now reachable\n", neigh);

             /* 进入REACHABLE状态，更新输出函数 */
             neigh->nud_state = NUD_REACHABLE;
             neigh->updated = jiffies;
             neigh_connect(neigh);
             notify = ;
             next = neigh->confirmed + neigh->parms->reachable_time;
         }
         /* 最后确认时间已经达到了超时时间，进入PROBE状态 */
         else {
             neigh_dbg(, "neigh %p is probed\n", neigh);
             neigh->nud_state = NUD_PROBE;
             neigh->updated = jiffies;
             atomic_set(&neigh->probes, );
             notify = ;
             next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME);
         }
     }
     /* NUD_PROBE|NUD_INCOMPLETE */
     else {
         /* NUD_PROBE|NUD_INCOMPLETE */
         next = now + NEIGH_VAR(neigh->parms, RETRANS_TIME);
     }

     /* NUD_PROBE|NUD_INCOMPLETE状态，达到了最大尝试次数 */
     if ((neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) &&
         atomic_read(&neigh->probes) >= neigh_max_probes(neigh)) {
         /* 进入FAILED状态，清空缓存包队列 */
         neigh->nud_state = NUD_FAILED;
         notify = ;
         neigh_invalidate(neigh);
         goto out;
     }

     /* 定时器处理状态，则更新定时器 */
     if (neigh->nud_state & NUD_IN_TIMER) {
         if (time_before(next, jiffies + HZ/))
             next = jiffies + HZ/;
         if (!mod_timer(&neigh->timer, next))
             neigh_hold(neigh);
     }

     /* NUD_PROBE|NUD_INCOMPLETE状态，发送请求包 */
     if (neigh->nud_state & (NUD_INCOMPLETE | NUD_PROBE)) {
         neigh_probe(neigh);
     } else {
 out:
         write_unlock(&neigh->lock);
     }

     /* 通知关心的模块 */
     if (notify)
         neigh_update_notify(neigh, );

     neigh_release(neigh);
 }