网络子系统14_邻居子系统通用接口

//创建一个新的邻居项
//参考 深入理解linux网络技术内幕
//	1.邻居子系统为具体的邻居协议，提供通用的功能接口
//	2.系统中所有的邻居协议被链接在neigh_tables链表中
//	3.neigh_table代表一个具体的邻居协议
//	4.具体邻居协议在运行时的行为，可以通过struct neigh_parms调节，
//	neigh_params与设备关联，每个邻居协议neigh_table提供一个默认的neigh_params。


//注册一个邻居协议到系统中
//	1.与邻居协议neigh_table有关的定时器：垃圾回收定时器gc_timer，代理定时器proxy_timer
1.1 void neigh_table_init(struct neigh_table *tbl)
{
	unsigned long now = jiffies;
	unsigned long phsize;
	//设置引用计数为1
	atomic_set(&tbl->parms.refcnt, 1);
	//tbl->parms 的类型为 struct neigh_parms，用于调整邻居协议的行为
	INIT_RCU_HEAD(&tbl->parms.rcu_head);
	//reachable_time表示一个时间间隔，从上一次收到可到达性认证时间t到t+reachable_time之间，都认为邻居可达
	//reachable_time = base_reachable_time/2 + rand(0,base_reachable_time)
	tbl->parms.reachable_time =
			  neigh_rand_reach_time(tbl->parms.base_reachable_time);//

	//每个邻居协议私有的neighbour缓存
	if (!tbl->kmem_cachep)
		tbl->kmem_cachep = kmem_cache_create(tbl->id,
						     tbl->entry_size,
						     0, SLAB_HWCACHE_ALIGN,
						     NULL, NULL);

	if (!tbl->kmem_cachep)
		panic("cannot create neighbour cache");

	//per-cpu统计变量
	tbl->stats = alloc_percpu(struct neigh_statistics);
	if (!tbl->stats)
		panic("cannot create neighbour cache statistics");
	
	//1.邻居项和代理项的hash_buckets以链表指针的形式组织
	//2.每一个bucket的链表头为struct neighbour的指针
	//3.neighbour通过next域链接在同一个bucket

	//邻居项hash表，2个bucket
	tbl->hash_mask = 1;
	//hash_buckets组织成指针数组的形式，每一个struct neighbour通过next域进行链接
	tbl->hash_buckets = neigh_hash_alloc(tbl->hash_mask + 1);

	//代理
	phsize = (PNEIGH_HASHMASK + 1) * sizeof(struct pneigh_entry *);	
	tbl->phash_buckets = kmalloc(phsize, GFP_KERNEL);		
									
	if (!tbl->hash_buckets || !tbl->phash_buckets)
		panic("cannot allocate neighbour cache hashes");

	memset(tbl->phash_buckets, 0, phsize);

	//hash函数的随机性
	get_random_bytes(&tbl->hash_rnd, sizeof(tbl->hash_rnd));

	//初始化协议垃圾回收定时器
	rwlock_init(&tbl->lock);
	init_timer(&tbl->gc_timer);
	tbl->gc_timer.data     = (unsigned long)tbl;
	tbl->gc_timer.function = neigh_periodic_timer;//异步回收函数
	tbl->gc_timer.expires  = now + 1;
	add_timer(&tbl->gc_timer);

	//代理相关的定时器
	init_timer(&tbl->proxy_timer);
	tbl->proxy_timer.data	  = (unsigned long)tbl;
	tbl->proxy_timer.function = neigh_proxy_process;
	skb_queue_head_init(&tbl->proxy_queue);

	tbl->last_flush = now;//neigh_forced_gc最近执行一次的时间
	tbl->last_rand	= now + tbl->parms.reachable_time * 20;
	write_lock(&neigh_tbl_lock);
	tbl->next	= neigh_tables;//将协议挂接到neigh_tables头部，所有的邻居协议通过neigh_tables列表链接起来
	neigh_tables	= tbl;
	write_unlock(&neigh_tbl_lock);
}
//为邻居协议分配hash表
1.2 static struct neighbour **neigh_hash_alloc(unsigned int entries)
{
	unsigned long size = entries * sizeof(struct neighbour *);
	struct neighbour **ret;

	//大小少于一页
	if (size <= PAGE_SIZE) {
		ret = kmalloc(size, GFP_ATOMIC);
	} else {
		//多于一页，分配连续的物理页
		ret = (struct neighbour **)
			__get_free_pages(GFP_ATOMIC, get_order(size));
	}
	if (ret)
		memset(ret, 0, size);

	return ret;
}

//邻居项的创建是由事件驱动的，当系统需要一个邻居项，并且缓存不命中时，就创建一个邻居项
//	创建新邻居项的时机：
//		1.传输请求，当有一个向一台l2地址未知的主机传输请求时，就需要对该地址进行解析，
//		当目的主机不是与发送方直连时，解析的l2地址就是下一条网关的地址
//		2.收到solicitation请求，由于发送请求的主机在请求封包中有自己的识别信息，收到该
//		请求的主机会假定即将有两个系统之间的通信
//		3.手工添加，ip neigh add命令创建一个邻居项
//	创建新邻居项的过程：
//		1.通过slab缓存分配struct neighbour结构
//		2.通过neigh_table->constructor协议提供的初始化函数，初始化新邻居项
//		3.在neigh_table->constructor会设置neighbour->params，使用协议默认提供，或者驱动
//		提供的协议调整参数(neigh_params)，通过neighbour->params->setup更新邻居项行为。
//		4.更新邻居项可到达性确认时间戳，使新邻居项比正常邻居项提前半个base_reachable_time到期
//		，从而对该邻居项进行一次主动的可到达性确认
//		5.添加到neigh_table->hash_buckets中，可能会引起hash表的扩容。
2.1 struct neighbour *neigh_create(struct neigh_table *tbl, const void *pkey,
			       struct net_device *dev)
{
	u32 hash_val;
	int key_len = tbl->key_len;
	int error;
	//从邻居协议的neighbour缓存中分配一个邻居项
	struct neighbour *n1, *rc, *n = neigh_alloc(tbl);

	if (!n) {
		rc = ERR_PTR(-ENOBUFS);
		goto out;
	}
	//拷贝hash的key到邻居项中，arp为ip地址
	memcpy(n->primary_key, pkey, key_len);
	n->dev = dev;//到达该邻居项使用的接口
	dev_hold(dev);//增加该接口的引用计数

	//如果邻居协议提供了邻居项的初始化函数，则调用
	if (tbl->constructor &&	(error = tbl->constructor(n)) < 0) {
		rc = ERR_PTR(error);
		goto out_neigh_release;
	}
	//如果设备驱动提供了初始化邻居项的回调函数，则调用
	if (n->parms->neigh_setup &&
	    (error = n->parms->neigh_setup(n)) < 0) {
		rc = ERR_PTR(error);
		goto out_neigh_release;
	}
	//邻居项可到达性确认的时间戳
	//当前时间-base_reachable_time/2，已保证新邻居项比正常邻居项提前base_reachable_time/2时间到期，执行可到达性检测
	n->confirmed = jiffies - (n->parms->base_reachable_time << 1);

	write_lock_bh(&tbl->lock);
	//如果协议表中的邻居数大于协议表hash表的长度
	if (atomic_read(&tbl->entries) > (tbl->hash_mask + 1))
		neigh_hash_grow(tbl, (tbl->hash_mask + 1) << 1);//hash表增加一半当前大小

	//使用协议提供的hash函数，对key，dev做hash
	hash_val = tbl->hash(pkey, dev) & tbl->hash_mask;//保证最终范围在hash表大小内

	if (n->parms->dead) {//如果此邻居项的配置信息标记为不在使用
		rc = ERR_PTR(-EINVAL);
		goto out_tbl_unlock;//则不添加新邻居项
	}

	//遍历hash表中的bucket链表
	for (n1 = tbl->hash_buckets[hash_val]; n1; n1 = n1->next) {
		//是否已存在该邻居
		if (dev == n1->dev && !memcmp(n1->primary_key, pkey, key_len)) {
			neigh_hold(n1);//增加已有邻居的引用计数
			rc = n1;
			goto out_tbl_unlock;
		}
	}
	//将邻居添加到bucket的list中
	n->next = tbl->hash_buckets[hash_val];
	tbl->hash_buckets[hash_val] = n;
	n->dead = 0;//标记此neighbour为可使用
	neigh_hold(n);//增加neighbour的引用计数
	write_unlock_bh(&tbl->lock);
	NEIGH_PRINTK2("neigh %p is created.\n", n);
	rc = n;
out:
	return rc;
out_tbl_unlock:
	write_unlock_bh(&tbl->lock);
out_neigh_release:
	neigh_release(n);
	goto out;
}


//删除邻居项
//	邻居项被删除的原因:
//		1.内核企图向一个不可到达的主机发送封包，当邻居子系统察觉到传输不成功，
//		就将neighbour标记为NUD_FAILED状态，可以是异步垃圾回收机制清除该neighbour.
//		2.与该邻居结构关联的主机的l2地址改变了，但它的l3地址还是原来的，一个
//		过时的邻居项必须进入NUD_FAILED态，然后重新创建一个新邻居项.

//	邻居项被删除的过程：
//		1.停用与邻居项有关的定时器
//		2.更新与邻居项有关的l2帧头缓存，设置器hh_cache->output为blackhole函数，
//		丢弃通过此l2帧头缓存发送的数据帧，递减hh_cache的引用计数，如果为0，则释放
//		3.调用邻居项提供的删除回调函数,在neigh_table->constructor或者neigh_table->params->setup中
//		被设置。
//		4.清空该邻居项的arp_queue，此队列中缓存的skb为与此邻居相关的，l2地址待解析的skb。
//		5.更新邻居协议的邻居项个数。
3.1 void neigh_destroy(struct neighbour *neigh)
{
	struct hh_cache *hh;
	//增加协议统计信息，邻居项被删除的次数
	NEIGH_CACHE_STAT_INC(neigh->tbl, destroys);
	//邻居项没有被标记为不在使用，则说明内核有错BUG()
	if (!neigh->dead) {
		printk(KERN_WARNING
		       "Destroying alive neighbour %p\n", neigh);
		dump_stack();
		return;
	}
	//删除邻居项的定时器
	if (neigh_del_timer(neigh))
		printk(KERN_WARNING "Impossible event.\n");

	//该邻居项缓存的l2帧头链表
	//从一台主机发往另一台主机的所有封包的l2帧头都是相同的，当向一个目的地发送第一个封包后，
	//驱动程序就将其l2帧头保存在hh_cache的结构中，如果下一次有相同的封包发往
	//同一个邻居，则只需从缓存中拷贝一个帧头即可，每个邻居项可以缓存多个帧头，但通常只缓存一个。
	while ((hh = neigh->hh) != NULL) {
		neigh->hh = hh->hh_next;
		//将l2地址缓存从列表上摘下来
		hh->hh_next = NULL;
		write_lock_bh(&hh->hh_lock);
		//替换此l2地址的输出函数为neigh_blackhole，以丢弃发往此目的l2地址的所有skb
		hh->hh_output = neigh_blackhole;
		write_unlock_bh(&hh->hh_lock);
		if (atomic_dec_and_test(&hh->hh_refcnt))
			kfree(hh);
	}
	//邻居项提供了删除函数
	if (neigh->ops && neigh->ops->destructor)
		(neigh->ops->destructor)(neigh);

	//清空该邻居项的arp缓存队列
	skb_queue_purge(&neigh->arp_queue);
	//释放对dev的引用
	dev_put(neigh->dev);
	//释放对协议调整参数的引用
	neigh_parms_put(neigh->parms);

	NEIGH_PRINTK2("neigh %p is destroyed.\n", neigh);
	//递减协议中邻居项的个数
	atomic_dec(&neigh->tbl->entries);
	//释放缓存
	kmem_cache_free(neigh->tbl->kmem_cachep, neigh);
}
//	查询l3地址对应的邻居项
//	参数：
//		tbl，被查询的协议表，arp为arp_tbl
//		pkey，查询的key，arp为ip
//		dev，到达此邻居项使用的出口设备
4.1 struct neighbour *neigh_lookup(struct neigh_table *tbl, const void *pkey,
			       struct net_device *dev)
{
	struct neighbour *n;
	int key_len = tbl->key_len;
	//hash pkey
	u32 hash_val = tbl->hash(pkey, dev) & tbl->hash_mask;
	//更新统计信息，递增查询个数
	NEIGH_CACHE_STAT_INC(tbl, lookups);

	read_lock_bh(&tbl->lock);
	//找到对应的bucket头链表
	for (n = tbl->hash_buckets[hash_val]; n; n = n->next) {
		//遍历链表中的每个元素
		if (dev == n->dev && !memcmp(n->primary_key, pkey, key_len)) {
			//增加邻居项的引用计数
			neigh_hold(n);
			//更新统计信息，递增命中率
			NEIGH_CACHE_STAT_INC(tbl, hits);
			break;
		}
	}
	read_unlock_bh(&tbl->lock);
	return n;
}

//用于更新一个邻居项 
/* Generic update routine.
   -- lladdr is new lladdr or NULL, if it is not supplied.
   -- new    is new state.
   -- flags
	NEIGH_UPDATE_F_OVERRIDE allows to override existing lladdr,
				if it is different.
	NEIGH_UPDATE_F_WEAK_OVERRIDE will suspect existing "connected"
				lladdr instead of overriding it 
				if it is different.
				It also allows to retain current state
				if lladdr is unchanged.
	NEIGH_UPDATE_F_ADMIN	means that the change is administrative.

	NEIGH_UPDATE_F_OVERRIDE_ISROUTER allows to override existing 
				NTF_ROUTER flag.
	NEIGH_UPDATE_F_ISROUTER	indicates if the neighbour is known as
				a router.

   Caller MUST hold reference count on the entry.
 */

//可能的更新策略：
//1.新状态没有可用的l2地址，删除定时器，怀疑邻居项，退出
//2.新状态有可用的l2地址：
//   2.1旧状态有可用l2地址，
//  	2.1.1新地址与旧地址不同并且没提供更新标志
//   		2.1.1.1 但允许怀疑邻居项并且就状态可达，仍然使用旧地址，标示邻居项需要进行可达性确认
//			2.1.1.2 不允许怀疑邻居项并且就状态不可达，退出
//   2.2新旧地址相同，并且新状态为进行可到达性确认，允许去怀疑或者就状态为可到达，依然保持就状态
//3.新旧状态不同，删除定时器，如果新状态需要定时器，更新定时器。更新邻居状态
//4.新地址与旧地址不同，拷贝新l2地址到邻居项的ha字段，更新l2缓存
//5.如果新旧状态相同，退出
//6.更新邻居项的输出回调函数
//7.如果旧状态没有可用的l2地址
//	 7.1 当前状态有可用的l2地址，将arp_queue中的所有skb发送
//	 7.2 否则，清空arp_queue

5.1 int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new,
		 u32 flags)
{
	u8 old;
	int err;
	...
	struct net_device *dev;
	int update_isrouter = 0;
	//获取此邻居项的锁
	write_lock_bh(&neigh->lock);
	//此邻居项的状态
	dev    = neigh->dev;
	old    = neigh->nud_state;
	err    = -EPERM;
	//如果没有admin，并且就状态为手动设置
	if (!(flags & NEIGH_UPDATE_F_ADMIN) && 
	    (old & (NUD_NOARP | NUD_PERMANENT)))
		goto out;//退出
	//新状态没有可用的l2地址
	if (!(new & NUD_VALID)) {
		neigh_del_timer(neigh);//删除邻居项的定时器
		if (old & NUD_CONNECTED)//旧状态为可达的
			neigh_suspect(neigh);//怀疑邻居项
		neigh->nud_state = new;//更新状态为新状态
		err = 0;

		goto out;
	}

	//运行到此处，说明有新状态有可用的l2地址，开始检查此地址
	//设备没有提供l2地址
	if (!dev->addr_len) {
		//设置提供的l2地址为邻居项的l2地址
		lladdr = neigh->ha;
	} else if (lladdr) {//提供了l2地址
		//如果旧状态有l2地址
		if ((old & NUD_VALID) && 
		    !memcmp(lladdr, neigh->ha, dev->addr_len))//比较新旧地址
			lladdr = neigh->ha;//如果一样的话，lladdr指向邻居的l2的地址
	} else {
		err = -EINVAL;//没有提供地址
		if (!(old & NUD_VALID))//并且旧状态没有可用的l2地址
			goto out;//返回错误
		lladdr = neigh->ha;
	}	
	//新状态为可达状态
	if (new & NUD_CONNECTED)
		neigh->confirmed = jiffies;//更新邻居项上一次被确认的时间为当前
	neigh->updated = jiffies;//上一次更新时间为当前

	err = 0;
	update_isrouter = flags & NEIGH_UPDATE_F_OVERRIDE_ISROUTER;//是否允许去更新NTF_ROUTER
	if (old & NUD_VALID) {//旧状态有l2地址
		if (lladdr != neigh->ha && !(flags & NEIGH_UPDATE_F_OVERRIDE)) {//(设备具有l2地址，或者新地址与旧地址不相同) && 没有提供更新地址的指示标志
			update_isrouter = 0;
			if ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) &&//允许怀疑
			    (old & NUD_CONNECTED)) {//旧状态可达
				lladdr = neigh->ha;//改变提供的地址为邻居项的旧地址
				new = NUD_STALE;//指示邻居项需要进行可达性确认
			} else//新旧地址不同，但是不允许更新，则直接退出
				goto out;
		} else {
			if (lladdr == neigh->ha && new == NUD_STALE &&//新地址等于旧地址，并且新状态要求进行可达性确认
			    ((flags & NEIGH_UPDATE_F_WEAK_OVERRIDE) ||//允许去怀疑就状态
			     (old & NUD_CONNECTED))//旧状态为可达的
			    )
				new = old;//新状态改变为旧状态
		}
	}

	if (new != old) {//如果新旧状态不同
		neigh_del_timer(neigh);//删除定时器
		if (new & NUD_IN_TIMER) {
			neigh_hold(neigh);//添加新的定时器
			neigh->timer.expires = jiffies + 
						((new & NUD_REACHABLE) ? 
						 neigh->parms->reachable_time : 0);
			add_timer(&neigh->timer);
		}
		neigh->nud_state = new;
	}

	if (lladdr != neigh->ha) {//新地址与旧地址不同
		memcpy(&neigh->ha, lladdr, dev->addr_len);//拷贝新l2地址到邻居项的ha字段
		neigh_update_hhs(neigh);//更新l2地址缓存
		if (!(new & NUD_CONNECTED))
			neigh->confirmed = jiffies -
				      (neigh->parms->base_reachable_time << 1);

	}
	if (new == old)//如果新旧状态相同
		goto out;
	if (new & NUD_CONNECTED)//新状态表示邻居可达
		neigh_connect(neigh);//
	else
		neigh_suspect(neigh);//否则怀疑邻居项
	if (!(old & NUD_VALID)) {//如果旧状态没有可用的l2地址
		struct sk_buff *skb;


		while (neigh->nud_state & NUD_VALID &&//并且新地址为有可用的l2地址
		       (skb = __skb_dequeue(&neigh->arp_queue)) != NULL) {//从arp_queue中取出所有等待l2地址解析的skb
			struct neighbour *n1 = neigh;
			write_unlock_bh(&neigh->lock);
			if (skb->dst && skb->dst->neighbour)//如果skb有路由缓存
				n1 = skb->dst->neighbour;
			n1->output(skb);//则通过邻居项提供的output完成传输
			write_lock_bh(&neigh->lock);
		}
		skb_queue_purge(&neigh->arp_queue);//否则清空所有待解析l2地址的skb
	}
out:
	if (update_isrouter) {
		neigh->flags = (flags & NEIGH_UPDATE_F_ISROUTER) ?
			(neigh->flags | NTF_ROUTER) :
			(neigh->flags & ~NTF_ROUTER);
	}
	write_unlock_bh(&neigh->lock);
#ifdef CONFIG_ARPD
	if (notify && neigh->parms->app_probes)
		neigh_app_notify(neigh);
#endif
	return err;
}

//邻居状态为怀疑状态，即需要可达性确认
5.2 static void neigh_suspect(struct neighbour *neigh)
{
	struct hh_cache *hh;

	NEIGH_PRINTK2("neigh %p is suspected.\n", neigh);
	//更新邻居的输出函数为最通用的输出函数
	neigh->output = neigh->ops->output;
	//更新所有l2缓存的输出函数为最通用的输出函数
	for (hh = neigh->hh; hh; hh = hh->hh_next)
		hh->hh_output = neigh->ops->output;
}

//邻居状态为可达状态
5.3 static void neigh_connect(struct neighbour *neigh)
{
	struct hh_cache *hh;

	NEIGH_PRINTK2("neigh %p is connected.\n", neigh);
	//使用设备驱动程序填充l2头的输出方式
	neigh->output = neigh->ops->connected_output;
	//使用帧头缓存的方式，快速发送报文
	for (hh = neigh->hh; hh; hh = hh->hh_next)
		hh->hh_output = neigh->ops->hh_output;
}

//当设备的硬件地址发生改变时，调用此函数
//标记使用此设备的邻居项不在使用，并且停用此邻居项的所有定时器
6.1 void neigh_changeaddr(struct neigh_table *tbl, struct net_device *dev)
{
	int i;

	write_lock_bh(&tbl->lock);
	//邻居协议表hash表的长度
	for (i=0; i <= tbl->hash_mask; i++) {
		struct neighbour *n, **np;
		//遍历每一个bucket
		np = &tbl->hash_buckets[i];
		while ((n = *np) != NULL) {
			//遍历直到传入设备等于邻居协议所在的设备
			if (dev && n->dev != dev) {
				np = &n->next;
				continue;
			}
			*np = n->next;
			write_lock_bh(&n->lock);
			//将邻居标记为dead
			n->dead = 1;
			//删除邻居的定时器
			neigh_del_timer(n);//垃圾回收进程负责处理停用项
			write_unlock_bh(&n->lock);
			//递减引用计数
			neigh_release(n);
		}
	}
        write_unlock_bh(&tbl->lock);
}

//查找代理地址数据库
//pkey为目的ip
//dev为用于代理ip的设备
//creat指示在查找失败时，是否创建
7.1 struct pneigh_entry * pneigh_lookup(struct neigh_table *tbl, const void *pkey,
				    struct net_device *dev, int creat)
{
	struct pneigh_entry *n;
	int key_len = tbl->key_len;
	u32 hash_val = *(u32 *)(pkey + key_len - 4);//通用性，对于arp，hash_val=ip
	//hash计算
	hash_val ^= (hash_val >> 16);
	hash_val ^= hash_val >> 8;
	hash_val ^= hash_val >> 4;
	hash_val &= PNEIGH_HASHMASK;

	read_lock_bh(&tbl->lock);
	//代理hash表
	for (n = tbl->phash_buckets[hash_val]; n; n = n->next) {
		//被代理的邻居的l3地址和提供的目标l3地址相同
		if (!memcmp(n->key, pkey, key_len) &&
		    (n->dev == dev || !n->dev)) {//当邻居项放在表示代理hash表中，neighbour->dev的语义就发生了变化
			read_unlock_bh(&tbl->lock);//在一般情况下，其表示通过此设备可以访问到这个邻居，转义后，表示，由哪个设备代理此目的ip，到达此目的
			goto out;//ip的设备，通过路由表查找得到
		}
	}
	read_unlock_bh(&tbl->lock);
	n = NULL;
	//没有找到代理邻居项
	if (!creat)
		goto out;

	n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
	if (!n)
		goto out;
	//创建邻居项，并添加到hash表中
	memcpy(n->key, pkey, key_len);
	n->dev = dev;
	if (dev)
		dev_hold(dev);

	if (tbl->pconstructor && tbl->pconstructor(n)) {
		if (dev)
			dev_put(dev);
		kfree(n);
		n = NULL;
		goto out;
	}

	write_lock_bh(&tbl->lock);
	n->next = tbl->phash_buckets[hash_val];
	tbl->phash_buckets[hash_val] = n;
	write_unlock_bh(&tbl->lock);
out:
	return n;
}

//将代理的solicitation放入延迟队列，延迟处理
8.1 void pneigh_enqueue(struct neigh_table *tbl, struct neigh_parms *p,
		    struct sk_buff *skb)
{
	unsigned long now = jiffies;
	unsigned long sched_next = now + (net_random() % p->proxy_delay);//延时时间

	if (tbl->proxy_queue.qlen > p->proxy_qlen) {//延迟队列超过限制
		kfree_skb(skb);//直接丢弃封包
		return;
	}
	skb->stamp.tv_sec  = LOCALLY_ENQUEUED;//标示入队时间，在出队后，通过此字段可以判断出此skb是否曾经被入过队，防止循环入队
	skb->stamp.tv_usec = sched_next;

	spin_lock(&tbl->proxy_queue.lock);
	if (del_timer(&tbl->proxy_timer)) {//
		if (time_before(tbl->proxy_timer.expires, sched_next))
			sched_next = tbl->proxy_timer.expires;//设置定时器的到期时间为需要最早被处理solicitation的时间,因此通过一个定时器就可以管理整个队列
	}
	dst_release(skb->dst);
	skb->dst = NULL;
	dev_hold(skb->dev);
	__skb_queue_tail(&tbl->proxy_queue, skb);//放入tbl->proxy_queue中
	mod_timer(&tbl->proxy_timer, sched_next);
	spin_unlock(&tbl->proxy_queue.lock);
}

//被动学习
//接收到ARP_REQUEST封包的目的主机从请求封包中也知道了发送方的地址
//该函数会负责检查是否有一个邻居项和请求者关联，然后就会更新这个存在的邻居项，如果不存在，则创建一个新的邻居项
9.1 struct neighbour *neigh_event_ns(struct neigh_table *tbl,
				 u8 *lladdr, void *saddr,
				 struct net_device *dev)
{
	//查找邻居项
	struct neighbour *neigh = __neigh_lookup(tbl, saddr, dev,
						 lladdr || !dev->addr_len);
	//如果存在，则更新为NUD_STALE状态，表示有l2地址可用
	if (neigh)
		neigh_update(neigh, lladdr, NUD_STALE, 
			     NEIGH_UPDATE_F_OVERRIDE);
	return neigh;
}