网络子系统71_路由缓存垃圾回收

//	同步回收机制
//	返回值：
//		0，达到回收目标
//		1，没有达到回收目标

//	注：ip_rt_gc_min_interval = HZ/2
//		ip_rt_gc_timeout = RT_GC_TIMEOUT = 300HZ
//		ip_rt_gc_elasticity = 8*(rt_hash_mask+1)(正常情况下)
//		ip_rt_gc_elasticity = 1(当绑定缓存到邻居子系统失败时)


//	平衡点，gc目标数的动态调整：
//		1.当前缓存个数 < 安全阈值(安全范围，试图gc少缓存)
//			1.1 当前缓存个数 > 上次gc的平衡点(安全范围内允许缓存增多)
//				1.1.1 新平衡点+=min((当前缓存个数-上次平衡点)/2 , buckets)
//				1.2.1 gc目标数=当前缓存个数-新平衡点
//					1.2.1.1 gc目标数 < 0
//						1.2.1.1.1 新平衡点+=gc目标数

//		2. 当前缓存个数 > 安全阈值(危险范围，试图gc多缓存)
//			2.1 gc目标数 = max((当前缓存个数-安全阈值)/2, buckets)(超过安全阈值的缓存一半将被gc)
//			2.2 新平衡点=当前缓存个数-gc目标数
//		3. gc目标数>0时，进行垃圾回收
//	注，安全阈值，每个bucket的冲突链中有8个bucket


//	回收过程：
//		1.令，遍历所有bucket = 一个回收单位
//		2.如果一个回收单位释放了gc目标数，调整expire
//			2.1 expire+=HZ/2，放宽到期时限
//		3.如果一个回收单位没有释放gc目标数
//			3.1 如果当前缓存个数 < 缓存允许的最小值，退出，下一次使用当前的expire作为时限
//			3.2 否则，只有在用户态，并且耗时<1 jiffes时，继续回收。

//	回收时限确定：
//		1.expire, 回收单位的起始到期时限，每个bucket使用该时限作为起始时限
//			当前回收单位没有完成gc目标数，下一个回收单位折半expire。
//		5.tmo，每个冲突链起始设置tmo=expire，当冲突链的一个节点不能被删除时，
//			tmo折半。

1.1 static int rt_garbage_collect(void)
{
	//静态变量
	static unsigned long expire = RT_GC_TIMEOUT;
	static unsigned long last_gc;
	static int rover;
	static int equilibrium;
	struct rtable *rth, **rthp;
	unsigned long now = jiffies;
	int goal;

	//回收速率限制
	//	在ip_rt_gc_min_interval时间范围内，如果缓存数量没有超过最大值，则放弃回收
	if (now - last_gc < ip_rt_gc_min_interval &&
	    atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size) {
		RT_CACHE_STAT_INC(gc_ignored);
		goto out;
	}

	//ipv4_dst_ops.entries保存当前缓存的个数
	goal = atomic_read(&ipv4_dst_ops.entries) -
		(ip_rt_gc_elasticity << rt_hash_log);//平均长度下，所有bucket的缓存个数

	//当前缓存的个数没有达到平均缓存个数
	if (goal <= 0) {
		if (equilibrium < ipv4_dst_ops.gc_thresh)
			equilibrium = ipv4_dst_ops.gc_thresh;
		//当前缓存的个数相对于上次平衡点的增长个数
		goal = atomic_read(&ipv4_dst_ops.entries) - equilibrium;
		//缓存个数增加
		if (goal > 0) {
			//在平均水平下，平衡点随着缓存个数的增加而增加
			equilibrium += min_t(unsigned int, goal / 2, rt_hash_mask + 1);
			//新平衡点为剩余缓存个数
			goal = atomic_read(&ipv4_dst_ops.entries) - equilibrium;
		}
	//当前缓存个数超过平均缓存个数
	} else {
		//至少回收 number of buckets
		goal = max_t(unsigned int, goal / 2, rt_hash_mask + 1);
		//新平衡点为剩余缓存个数
		equilibrium = atomic_read(&ipv4_dst_ops.entries) - goal;
	}

	if (now - last_gc >= ip_rt_gc_min_interval)
		last_gc = now;
	//当前缓存总数小于平均值时，并且小于上次的平衡点
	//	说明缓存个数开始递减，则降低平衡点，不进行回收
	if (goal <= 0) {
		equilibrium += goal;
		goto work_done;
	}

	do {
		int i, k;
		//rover记录上次遍历的bucket
		for (i = rt_hash_mask, k = rover; i >= 0; i--) {
			//tmo，bucket冲突链表内部使用的起始到期时限
			//expire, bucket之间使用的起始到期时限
			unsigned long tmo = expire;

			k = (k + 1) & rt_hash_mask;
			//这次应该遍历的bucket
			rthp = &rt_hash_table[k].chain;
			spin_lock_bh(&rt_hash_table[k].lock);
			while ((rth = *rthp) != NULL) {
				//检查缓存到期
				if (!rt_may_expire(rth, tmo, expire)) {
					//到期时间折半，使回收更加严格
					tmo >>= 1;
					rthp = &rth->u.rt_next;
					continue;
				}
				*rthp = rth->u.rt_next;
				rt_free(rth);
				goal--;
			}
			spin_unlock_bh(&rt_hash_table[k].lock);
			if (goal <= 0)
				break;
		}
		rover = k;

		if (goal <= 0)
			goto work_done;
		//到期时间已经足够严格，依然没有达到目标，放弃回收
		if (expire == 0)
			break;
		//下一轮遍历的到期时间折半，使到期时间更加严格
		expire >>= 1;


		if (atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size)
			goto out;
	} while (!in_softirq() && time_before_eq(jiffies, now));

	if (atomic_read(&ipv4_dst_ops.entries) < ip_rt_max_size)
		goto out;
	return 1;

work_done:
	expire += ip_rt_gc_min_interval;
	if (expire > ip_rt_gc_timeout ||
	    atomic_read(&ipv4_dst_ops.entries) < ipv4_dst_ops.gc_thresh)
		expire = ip_rt_gc_timeout;

out:	return 0;
}


//	异步垃圾回收
//		垃圾回收定时器函数

//	函数主要任务：
//		1.计算此次gc处理的bucket数
//		2.从上次遍历到的下一个bucket开始
//			2.1 如果dst到期时间为0，可以被释放，从冲突链取下节点，释放
//			2.2 该dst没有到期，调整gc时限更加严格
//		3.重新激活gc定时器


//	注：ip_rt_gc_interval=60HZ

//	注：ip_rt_gc_timeout，ip_rt_gc_interval的关系
//		1.一个bucket至少在ip_rt_gc_timeout间隔gc一次
//		2.两次异步gc的间隔为ip_rt_gc_interval(即定时器的到期间隔)
//		3.此次gc处理的bucket个数=(ip_rt_gc_interval*(rt_hash_mask+1))/ip_rt_gc_timeout

//	使路由缓存到期的事件：
//		1.主机接收到 ICMP UNREACHABLE 或 ICMP FRAGMENTATION NEEDED，设置为一段时间后(10min)过期。
//		2.邻居项无法解析l3到l2的映射，目的ip不可达时，设置为立即过期。

//	dst_entry->expires
//		默认情况下，路由缓存表项永远不会过期，因此dst_entry->expires设置为0，当发生使路由缓存过期的事件时
//		，更新dst_entry->expires为缓存到期的时间戳。

2.1 static void rt_check_expire(unsigned long dummy)
{
	static int rover;
	int i = rover, t;
	struct rtable *rth, **rthp;
	unsigned long now = jiffies;
	//计算可gc的bucket个数
	for (t = ip_rt_gc_interval << rt_hash_log; t >= 0;
		//gc定时器到期时间ip_rt_gc_timeout
	     t -= ip_rt_gc_timeout) {
		unsigned long tmo = ip_rt_gc_timeout;
		//rover记录上次gc的bucket
		i = (i + 1) & rt_hash_mask;
		rthp = &rt_hash_table[i].chain;

		spin_lock(&rt_hash_table[i].lock);
		while ((rth = *rthp) != NULL) {
			//dst->expires该dst将过期的时间戳
			if (rth->u.dst.expires) {
				//表示指定的过期还没到
				if (time_before_eq(now, rth->u.dst.expires)) {
					//过期时限折半
					tmo >>= 1;
					rthp = &rth->u.rt_next;
					continue;
				}
			//该dst还不能被释放
			} else if (!rt_may_expire(rth, tmo, ip_rt_gc_timeout)) {
				tmo >>= 1;
				rthp = &rth->u.rt_next;
				continue;
			}

			//从bucket的冲突链取下，释放
			*rthp = rth->u.rt_next;
			rt_free(rth);
		}
		spin_unlock(&rt_hash_table[i].lock);
		//一步回收不超过1 jiffies
		if (time_after(jiffies, now))
			break;
	}
	rover = i;
	//下次到期的时间
	mod_timer(&rt_periodic_timer, now + ip_rt_gc_interval);
}

//	判断缓存是否可以释放
//	参数：
//		tmo1，可快速清理的缓存使用的到期时限
//		tmo2，高代价创建的缓存使用的到期时限
//		tmo2 > tmo1

//	缓存释放的条件：
//		1.引用计数=0
//		2.如果，缓存指定了到期时间，并且达到了到期时间，可清理
//		3.否则，可以快速清理，并且清理代价较低

//	可以快速清理的缓存项：
//		1.广播多播地址
//		2.入口路由
//		3.冲突链表中，其后有缓存项

//	清理代价较高的缓存项：
//		1.重定向的的缓存项
3.1 static int rt_may_expire(struct rtable *rth, unsigned long tmo1, unsigned long tmo2)
{
	unsigned long age;
	int ret = 0;

	if (atomic_read(&rth->u.dst.__refcnt))
		goto out;

	ret = 1;
	if (rth->u.dst.expires &&
	    time_after_eq(jiffies, rth->u.dst.expires))
		goto out;

	age = jiffies - rth->u.dst.lastuse;
	ret = 0;
	if ((age <= tmo1 && !rt_fast_clean(rth)) ||
	    (age <= tmo2 && rt_valuable(rth)))
		goto out;
	ret = 1;
out:	return ret;
}