内核将未缓存的IPv6路由项组成一个链表rt6_uncached_list，其为一个每处理器变量。
struct uncached_list {
spinlock_t lock;
struct list_head head;
};
static DEFINE_PER_CPU_ALIGNED(struct uncached_list, rt6_uncached_list);
在IPv6路由初始化函数中，初始化rt6_uncached_list链表头和自旋锁。
int __init ip6_route_init(void)
{
for_each_possible_cpu(cpu) {
struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
INIT_LIST_HEAD(&ul->head);
spin_lock_init(&ul->lock);
}
函数rt6_uncached_list_add和函数rt6_uncached_list_del分别用于将路由缓存rt添加到rt6_uncached_list链表上，或者从链表中删除。
void rt6_uncached_list_add(struct rt6_info *rt)
{
struct uncached_list *ul = raw_cpu_ptr(&rt6_uncached_list);
rt->rt6i_uncached_list = ul;
spin_lock_bh(&ul->lock);
list_add_tail(&rt->rt6i_uncached, &ul->head);
spin_unlock_bh(&ul->lock);
}
void rt6_uncached_list_del(struct rt6_info *rt)
{
if (!list_empty(&rt->rt6i_uncached)) {
struct uncached_list *ul = rt->rt6i_uncached_list;
struct net *net = dev_net(rt->dst.dev);
spin_lock_bh(&ul->lock);
list_del(&rt->rt6i_uncached);
atomic_dec(&net->ipv6.rt6_stats->fib_rt_uncache);
spin_unlock_bh(&ul->lock);
}
}
初始化
在IPv6路由缓存分配函数中，初始化其rt6i_uncached链表指针。
static void rt6_info_init(struct rt6_info *rt)
{
struct dst_entry *dst = &rt->dst;
memset(dst + 1, 0, sizeof(*rt) - sizeof(*dst));
INIT_LIST_HEAD(&rt->rt6i_uncached);
}
/* allocate dst with ip6_dst_ops */
struct rt6_info *ip6_dst_alloc(struct net *net, struct net_device *dev, int flags)
{
struct rt6_info *rt = dst_alloc(&net->ipv6.ip6_dst_ops, dev,
1, DST_OBSOLETE_FORCE_CHK, flags);
if (rt) {
rt6_info_init(rt);
atomic_inc(&net->ipv6.rt6_stats->fib_rt_alloc);
}
return rt;
}
路由查找
与IPv4不同，IPv6的出口路由和入口路由都使用函数ip6_pol_route实现，区别在于传入的接口索引参数不同。
INDIRECT_CALLABLE_SCOPE struct rt6_info *ip6_pol_route_input(struct net *net,
struct fib6_table *table,
struct flowi6 *fl6,
const struct sk_buff *skb,
int flags)
{
return ip6_pol_route(net, table, fl6->flowi6_iif, fl6, skb, flags);
}
INDIRECT_CALLABLE_SCOPE struct rt6_info *ip6_pol_route_output(struct net *net,
struct fib6_table *table,
struct flowi6 *fl6,
const struct sk_buff *skb,
int flags)
{
return ip6_pol_route(net, table, fl6->flowi6_oif, fl6, skb, flags);
}
首先，函数rt6_find_cached_rt在fib查询结果的exception表中查找缓存的路由，如果找到，则返回此值。
struct rt6_info *ip6_pol_route(struct net *net, struct fib6_table *table,
int oif, struct flowi6 *fl6, const struct sk_buff *skb, int flags)
{
struct fib6_result res = {};
struct rt6_info *rt = NULL;
WARN_ON_ONCE((flags & RT6_LOOKUP_F_DST_NOREF) && !rcu_read_lock_held());
strict |= flags & RT6_LOOKUP_F_IFACE;
strict |= flags & RT6_LOOKUP_F_IGNORE_LINKSTATE;
if (net->ipv6.devconf_all->forwarding == 0)
strict |= RT6_LOOKUP_F_REACHABLE;
rcu_read_lock();
fib6_table_lookup(net, table, oif, fl6, &res, strict);
if (res.f6i == net->ipv6.fib6_null_entry)
goto out;
fib6_select_path(net, &res, fl6, oif, false, skb, strict);
/*Search through exception table */
rt = rt6_find_cached_rt(&res, &fl6->daddr, &fl6->saddr);
否则，判断流结构flowi6是否设置了FLOWI_FLAG_KNOWN_NH，并且没有设置了下一跳网关的地址组，这种已知下一跳的前提下查找路由的情况不常见。而且，由于在fl6结构目的地址成员daddr使用的是下一跳地址，而不是skb报文中的目的地址，此时创建的路由缓存项不会缓存在fib6树种，将其添加到uncached_list链表。
} else if (unlikely((fl6->flowi6_flags & FLOWI_FLAG_KNOWN_NH) &&
!res.nh->fib_nh_gw_family)) {
/* Create a RTF_CACHE clone which will not be
* owned by the fib6 tree. It is for the special case where
* the daddr in the skb during the neighbor look-up is different
* from the fl6->daddr used to look-up route here.
*/
rt = ip6_rt_cache_alloc(&res, &fl6->daddr, NULL);
if (rt) {
/* 1 refcnt is taken during ip6_rt_cache_alloc().
* As rt6_uncached_list_add() does not consume refcnt,
* this refcnt is always returned to the caller even
* if caller sets RT6_LOOKUP_F_DST_NOREF flag.
*/
rt6_uncached_list_add(rt);
atomic_inc(&net->ipv6.rt6_stats->fib_rt_uncache);
rcu_read_unlock();
return rt;
}
如果以上两种情况都没有成立，分配每处理器路由缓存项，其过程中将缓存路由项，不必加到uncached_list链表。
} else {
/* Get a percpu copy */
local_bh_disable();
rt = rt6_get_pcpu_route(&res);
if (!rt)
rt = rt6_make_pcpu_route(net, &res);
local_bh_enable();
}
例如，对于SRv6，其中路由查询前，如果下一跳地址有效，流结构的目的地设置为下一跳地址，并且设置FLOWI_FLAG_KNOWN_NH标志。
static int seg6_lookup_any_nexthop(struct sk_buff *skb, struct in6_addr *nhaddr,
u32 tbl_id, bool local_delivery)
{
struct net *net = dev_net(skb->dev);
struct ipv6hdr *hdr = ipv6_hdr(skb);
int flags = RT6_LOOKUP_F_HAS_SADDR;
struct dst_entry *dst = NULL;
struct rt6_info *rt;
struct flowi6 fl6;
int dev_flags = 0;
fl6.flowi6_iif = skb->dev->ifindex;
fl6.daddr = nhaddr ? *nhaddr : hdr->daddr;
fl6.saddr = hdr->saddr;
fl6.flowlabel = ip6_flowinfo(hdr);
fl6.flowi6_mark = skb->mark;
fl6.flowi6_proto = hdr->nexthdr;
if (nhaddr)
fl6.flowi6_flags = FLOWI_FLAG_KNOWN_NH;
if (!tbl_id) {
dst = ip6_route_input_lookup(net, skb->dev, &fl6, skb, flags);
} else {
struct fib6_table *table;
table = fib6_get_table(net, tbl_id);
if (!table)
goto out;
rt = ip6_pol_route(net, table, 0, &fl6, skb, flags);
dst = &rt->dst;
ICMPv6
对于使用ICMPv6的IPv6邻居发现、IGMP和MLD协议，利用icmp6_dst_alloc分配路由缓存项。对于这类报文，仅限于本地网络，报文的下一跳地址和目的地址相同，这里不查询fib6表，直接分配缓存项，导致新分配的路由在fib树中没有缓存位置，所以将其添加到uncached_list链表。
struct dst_entry *icmp6_dst_alloc(struct net_device *dev, struct flowi6 *fl6)
{
struct dst_entry *dst;
struct rt6_info *rt;
struct inet6_dev *idev = in6_dev_get(dev);
struct net *net = dev_net(dev);
if (unlikely(!idev))
return ERR_PTR(-ENODEV);
rt = ip6_dst_alloc(net, dev, 0);
if (unlikely(!rt)) {
in6_dev_put(idev);
dst = ERR_PTR(-ENOMEM);
goto out;
}
rt->dst.input = ip6_input;
rt->dst.output = ip6_output;
rt->rt6i_gateway = fl6->daddr;
rt->rt6i_dst.addr = fl6->daddr;
rt->rt6i_dst.plen = 128;
rt->rt6i_idev = idev;
dst_metric_set(&rt->dst, RTAX_HOPLIMIT, 0);
/* Add this dst into uncached_list so that rt6_disable_ip() can
* do proper release of the net_device
*/
rt6_uncached_list_add(rt);
atomic_inc(&net->ipv6.rt6_stats->fib_rt_uncache);
uncached路由缓存清除
当接口被注销或者down时，由函数rt6_uncached_list_flush_dev清除设备相关的uncached路由缓存。
static int addrconf_ifdown(struct net_device *dev, bool unregister)
{
unsigned long event = unregister ? NETDEV_UNREGISTER : NETDEV_DOWN;
struct net *net = dev_net(dev);
struct inet6_dev *idev;
rt6_disable_ip(dev, event);
void rt6_disable_ip(struct net_device *dev, unsigned long event)
{
rt6_sync_down_dev(dev, event);
rt6_uncached_list_flush_dev(dev_net(dev), dev);
neigh_ifdown(&nd_tbl, dev);
}
遍历所有的rt6_uncached_list中的路由缓存，将其中与操作设备相等的缓存项的设备换成黑洞设备blackhole_netdev，并且将路由项的inet6_dev换成回环接口对应的inet6_dev。
可见，实际上并没有将路由缓存项从uncached_list链表中删除。
static void rt6_uncached_list_flush_dev(struct net *net, struct net_device *dev)
{
struct net_device *loopback_dev = net->loopback_dev;
if (dev == loopback_dev)
return;
for_each_possible_cpu(cpu) {
struct uncached_list *ul = per_cpu_ptr(&rt6_uncached_list, cpu);
struct rt6_info *rt;
spin_lock_bh(&ul->lock);
list_for_each_entry(rt, &ul->head, rt6i_uncached) {
struct inet6_dev *rt_idev = rt->rt6i_idev;
struct net_device *rt_dev = rt->dst.dev;
if (rt_idev->dev == dev) {
rt->rt6i_idev = in6_dev_get(loopback_dev);
in6_dev_put(rt_idev);
}
if (rt_dev == dev) {
rt->dst.dev = blackhole_netdev;
dev_hold(rt->dst.dev);
dev_put(rt_dev);
}
在销毁路由缓存时，由函数rt6_uncached_list_del检测其是否在uncached_list链表上，为真将其移除，并且递减net->ipv6.rt6_stats->fib_rt_uncache计数，这是在rt6_uncached_list_del内部完成。与此不同，此计数的递增是在rt6_uncached_list_add外部完成。
static void ip6_dst_destroy(struct dst_entry *dst)
{
struct rt6_info *rt = (struct rt6_info *)dst;
struct fib6_info *from;
struct inet6_dev *idev;
ip_dst_metrics_put(dst);
rt6_uncached_list_del(rt);
idev = rt->rt6i_idev;
if (idev) {
rt->rt6i_idev = NULL;
in6_dev_put(idev);
}
from = xchg((__force struct fib6_info **)&rt->from, NULL);
fib6_info_release(from);
}
uncached路由缓存项判断
对于出口路由查找，按照代码中的注释，如果路由缓存已经加入uncached_list链表，说明缓存引用计数已经递增。但是，uncached_list的添加并没有增加路由缓存引用计数，只有在初始分配时设置的引用计数1。
对于uncached的路由缓存，引用计数为1即可，在使用完成之后执行释放操作，这里不需要再次增加引用计数，感觉这个注释有问题，但是代码逻辑并没有问题。对于需要缓存的路由，执行dst_hold_safe增加引用计数，计数应当为2，这样在使用完之后，进行释放时，将计数减为1，并没有实际释放，路由缓存还在。
struct dst_entry *ip6_route_output_flags(struct net *net,
const struct sock *sk, struct flowi6 *fl6, int flags)
{
struct dst_entry *dst;
struct rt6_info *rt6;
rcu_read_lock();
dst = ip6_route_output_flags_noref(net, sk, fl6, flags);
rt6 = (struct rt6_info *)dst;
/* For dst cached in uncached_list, refcnt is already taken. */
if (list_empty(&rt6->rt6i_uncached) && !dst_hold_safe(dst)) {
dst = &net->ipv6.ip6_null_entry->dst;
dst_hold(dst);
}
以下路由合法性检测函数ip6_dst_check，如果路由缓存项具有RTF_PCPU标志，其可能在函数ip6_rt_pcpu_alloc中设置，在同时设置了缓存的from成员（fib6_info结构）时调用rt6_dst_from_check执行检查。另外，根据之前的介绍，有两种情况路将缓存加到了uncached_list链表上：一是ICMPv6报文发送时生成的缓存；二是已知下一跳地址的情况下创建的路由缓存，对于第一种情况，路由缓存直接生成，from成员为空，调用rt6_check进行检查；对于第二种情况调用rt6_dst_from_check检查。
static struct dst_entry *ip6_dst_check(struct dst_entry *dst, u32 cookie)
{
struct dst_entry *dst_ret;
struct fib6_info *from;
struct rt6_info *rt;
rt = container_of(dst, struct rt6_info, dst);
if (rt->sernum)
return rt6_is_valid(rt) ? dst : NULL;
rcu_read_lock();
/* All IPV6 dsts are created with ->obsolete set to the value
* DST_OBSOLETE_FORCE_CHK which forces validation calls down
* into this function always.
*/
from = rcu_dereference(rt->from);
if (from && (rt->rt6i_flags & RTF_PCPU ||
unlikely(!list_empty(&rt->rt6i_uncached))))
dst_ret = rt6_dst_from_check(rt, from, cookie);
else
dst_ret = rt6_check(rt, from, cookie);
rcu_read_unlock();
return dst_ret;
}
如果路由缓存没有设置RT6_LOOKUP_F_DST_NOREF标志，即其使用了引用计数，由函数ip6_rt_put递减计数。另外，如果缓存位于uncached_list链表上，表明不需要缓存此路由，也执行引用计数的递减。
/* Only conditionally release dst if flags indicates
* !RT6_LOOKUP_F_DST_NOREF or dst is in uncached_list.
*/
static inline void ip6_rt_put_flags(struct rt6_info *rt, int flags)
{
if (!(flags & RT6_LOOKUP_F_DST_NOREF) ||
!list_empty(&rt->rt6i_uncached))
ip6_rt_put(rt);
}
内核版本 5.10