邻居子系统 之 更新neigh_update

概述

neigh_update函数用来更新指定的邻居项，更新内容是硬件地址和状态，更新之后，会根据新状态设置其输出函数，CONNECTED状态则使用快速输出，否则使用慢速输出；如果是由原来的无效状态变为现在的有效状态，则需要将数据包缓存队列中的数据包发送出去；

该函数在邻居子系统中被频繁调用；arp模块再收到邻居应答，收到邻居的情况，转发单播代理请求后，会调用该函数更新地址和状态；netlink或者ioctl模块添加或者删除邻居项，也会调用该函数更新地址和状态；

源码分析

 /* 更新指定的邻居项，更新内容为硬件地址和状态，新状态有效，并且有缓存包，则发送 */
 int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
          u32 flags, u32 nlmsg_pid)
 {
     u8 old;
     int err;
     int notify = ;
     struct net_device *dev;
     int update_isrouter = ;

     write_lock_bh(&neigh->lock);

     dev    = neigh->dev;
     old    = neigh->nud_state;
     err    = -EPERM;

     /* 原状态是NOARP或者PERMANENT，必须要求是用户管理员发生的更新 */
     if (!(flags & NEIGH_UPDATE_F_ADMIN) &&
         (old & (NUD_NOARP | NUD_PERMANENT)))
         goto out;

     /* 已经在销毁状态 */
     if (neigh->dead)
         goto out;

     /* 新状态不是有效状态 */
     if (!(new & NUD_VALID)) {

         /* 删除定时器 */
         neigh_del_timer(neigh);

         /* 原状态是已连接状态，更新输出函数 */
         if (old & NUD_CONNECTED)
             neigh_suspect(neigh);
         /* 设置状态 */
         neigh->nud_state = new;
         err = ;
         notify = old & NUD_VALID;

         /* 原状态为INCOMPLETE或者PROBE，新状态为失败状态 */
         if ((old & (NUD_INCOMPLETE | NUD_PROBE)) &&
             (new & NUD_FAILED)) {
             /* 清空缓存包队列 */
             neigh_invalidate(neigh);
             notify = ;
         }
         goto out;
     }

     /* Compare new lladdr with cached one */
     if (!dev->addr_len) {
         /* First case: device needs no address. */
         lladdr = neigh->ha;
     } else if (lladdr) {
         /* The second case: if something is already cached
            and a new address is proposed:
            - compare new & old
            - if they are different, check override flag
          */
         if ((old & NUD_VALID) &&
             !memcmp(lladdr, neigh->ha, dev->addr_len))
             lladdr = neigh->ha;
     } else {
         /* No address is supplied; if we know something,
            use it, otherwise discard the request.
          */
         err = -EINVAL;
         if (!(old & NUD_VALID))
             goto out;
         lladdr = neigh->ha;
     }

     /* If entry was valid and address is not changed,
        do not change entry state, if new one is STALE.
      */
     err = ;
     update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;

     /* 原状态有效 */
     if (old & NUD_VALID) {
         /* 地址不同 && 无UPDATE_F_OVERRIDE标记 */
         if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {
             update_isrouter = ;
             /* 有UPDATE_F_WEAK_OVERRIDE状态 && 原状态是连接状态 */
             if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&
                 (old & NUD_CONNECTED)) {
                 /* 更新硬件地址为邻居项地址 */
                 lladdr = neigh->ha;
                 /* 更新状态为STALE */
                 new = NUD_STALE;
             } else
                 goto out;
         }
         /* 地址相同或者有UPDATE_F_OVERRIDE标记 */
         else {
             /* 地址相同&&新状态为STALE&&不是管理员更新，新状态设置为原状态 */
             if (lladdr == neigh->ha && new == NUD_STALE &&
                 !(flags & NEIGH_UPDATE_F_ADMIN))
                 new = old;
         }
     }

     /* Update timestamps only once we know we will make a change to the
      * neighbour entry. Otherwise we risk to move the locktime window with
      * noop updates and ignore relevant ARP updates.
      */
     /* 新旧状态不同或新旧地址不同 */
     if (new != old || lladdr != neigh->ha) {
         /* 新状态是连接状态，更新确认时间 */
         if (new & NUD_CONNECTED)
             neigh->confirmed = jiffies;
         /* 更新更新时间 */
         neigh->updated = jiffies;
     }

     /* 新旧状态不同 */
     if (new != old) {
         /* 删除定时器 */
         neigh_del_timer(neigh);

         /* 新状态为PROBE，设置未接受到应答计数为0 */
         if (new & NUD_PROBE)
             atomic_set(&neigh->probes, );

         /* 新状态需要定时器，则添加 */
         if (new & NUD_IN_TIMER)
             neigh_add_timer(neigh, (jiffies +
                         ((new & NUD_REACHABLE) ?
                          neigh->parms->reachable_time :
                          )));
         /* 设置新状态 */
         neigh->nud_state = new;
         notify = ;
     }

     /* 新旧地址不同 */
     if (lladdr != neigh->ha) {
         write_seqlock(&neigh->ha_lock);
         /* 拷贝新地址 */
         memcpy(&neigh->ha, lladdr, dev->addr_len);
         write_sequnlock(&neigh->ha_lock);
         /* 更新二层头缓存 */
         neigh_update_hhs(neigh);

         /* 新状态不是连接状态，更新确认时间 */
         if (!(new & NUD_CONNECTED))
             neigh->confirmed = jiffies -
                       (NEIGH_VAR(neigh->parms, BASE_REACHABLE_TIME) << );
         notify = ;
     }

     /* 新旧状态相同 */
     if (new == old)
         goto out;

     /* 新状态为CONNECTED，更新输出函数为connected_out */
     if (new & NUD_CONNECTED)
         neigh_connect(neigh);
     /* 否则，输出函数为output */
     else
         neigh_suspect(neigh);

     /* 原状态无效，新状态有效 */
     if (!(old & NUD_VALID)) {
         struct sk_buff *skb;

         /* Again: avoid dead loop if something went wrong */

         /* 新状态有效，缓存队列不为空 */
         while (neigh->nud_state & NUD_VALID &&
                (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {
             struct dst_entry *dst = skb_dst(skb);
             struct neighbour *n2, *n1 = neigh;
             write_unlock_bh(&neigh->lock);

             rcu_read_lock();

             /* Why not just use 'neigh' as-is?  The problem is that
              * things such as shaper, eql, and sch_teql can end up
              * using alternative, different, neigh objects to output
              * the packet in the output path.  So what we need to do
              * here is re-lookup the top-level neigh in the path so
              * we can reinject the packet there.
              */
             n2 = NULL;
             /* 有路由缓存，则根据路由缓存获取邻居项，有则替换 */
             if (dst) {
                 n2 = dst_neigh_lookup_skb(dst, skb);
                 if (n2)
                     n1 = n2;
             }

             /* 输出数据包 */
             n1->output(n1, skb);

             /* 是否引用的邻居项 */
             if (n2)
                 neigh_release(n2);
             rcu_read_unlock();

             write_lock_bh(&neigh->lock);
         }

         /* 清空数据包缓存队列 */
         __skb_queue_purge(&neigh->arp_queue);
         neigh->arp_queue_len_bytes = ;
     }
 out:
     if (update_isrouter) {
         neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ?
             (neigh->flags | NTF_ROUTER) :
             (neigh->flags & ~NTF_ROUTER);
     }
     write_unlock_bh(&neigh->lock);

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

     return err;
 }