原帖地址：http://blog.csdn.net/shichaog/article/details/44658205#t1

下载地址《http://download.csdn.net/detail/shichaog/8620701》

路由表的构建途径：

通过用户命令[route(ioctl) 、ip route(netlink)]静态配置

通过路由协议动态配置，这些协议是BGP（Border Gateway Protocol）、EGP（Exterior Gateway Protocol）以及OSPF（Open Shortest Path First）

这一章的内容基于route方法，其它的配置路由的方法不在这章中，但是上面的方法区别在于配置方法，而对应调用的路由核心函数以及操作的核心路由数据结构是一样的，这章的主要内容就是关于这些和核心函数和核心数据结构的。

路由相关数据结构在include/net/route.h

struct ip_rt_acct {
__u32 o_bytes;  //发送数据的字节数
__u32 o_packets;
__u32 i_bytes;
__u32 i_packets;
};

这个结构体在ip_rcv_finish中被使用到，由于网络数据包的统计，分别按照byte和packet两种方法计数，ip_rcv_finish在网络层接收中分析过，这里会再一次看到在网络层被跳过的关于路由相关的代码，下面的代码片段就是上面统计信息被赋值的一个地方：

static int ip_rcv_finish(struct sk_buff *skb)
{
#ifdef CONFIG_IP_ROUTE_CLASSID
if (unlikely(skb_dst(skb)->tclassid)) {
struct ip_rt_acct *st = this_cpu_ptr(ip_rt_acct);
u32 idx = skb_dst(skb)->tclassid;
st[idx&0xFF].o_packets++;
st[idx&0xFF].o_bytes += skb->len;
st[(idx>>16)&0xFF].i_packets++;
st[(idx>>16)&0xFF].i_bytes += skb->len;
}
#endif
}

由上面的使用可以知道，定义了基于路由的分类器就会使用该字段。该字段根据idx索引可构成具有256个成员的数组。其初始化在ip_rt_init中完成。

rt_cache_stat

路由表缓存的统计信息，除了输入输出路由信息统计，还有垃圾回收信息。

fib_result

查找路由表会得到此结构。

struct fib_result {
unsigned char  prefixlen;
unsigned char  nh_sel;
unsigned char  type;
unsigned char  scope;
u32 tclassid;
struct fib_info *fi;
struct fib_table *table;
struct list_head *fa_head;
};

struct fib_rule

策略路由使用的结构。

struct fib_rule {
struct list_headlist;
atomic_t  refcnt;
int iifindex;
int oifindex;
u32 mark;
u32 mark_mask;
u32 pref;
u32 flags;
u32 table;
u8 action;
u32 target;
struct fib_rule __rcu*ctarget;
char iifname[IFNAMSIZ];
char oifname[IFNAMSIZ];
struct rcu_headrcu;
struct net *  fr_net;
};

struct flowi

流量控制，作为路由表查找的键值。

struct flowi {
union {
struct flowi_common__fl_common;
struct flowi4  ip4;
struct flowi6  ip6;
struct flowidndn;
} u;
#define flowi_oif u.__fl_common.flowic_oif
#define flowi_iif u.__fl_common.flowic_iif
#define flowi_mark u.__fl_common.flowic_mark
#define flowi_tos u.__fl_common.flowic_tos
#define flowi_scope u.__fl_common.flowic_scope
#define flowi_proto u.__fl_common.flowic_proto
#define flowi_flags u.__fl_common.flowic_flags
#define flowi_secid u.__fl_common.flowic_secid
} __attribute__((__aligned__(BITS_PER_LONG/8)));

fib_table

路由表在内核中的表示为fib_table的一个结构体，其定义位于include/net/ip_fib.h文件。

struct fib_table {
struct hlist_nodetb_hlist;
u32 tb_id;
int tb_default;
int tb_num_default;
unsigned long  tb_data[0];
};

tb_id用于标识路由表所属，其可选字段在include/uapi/linux/rtnetlink.h文件中;

enum rt_class_t {RT_TABLE_UNSPEC=0,
/* User defined values */RT_TABLE_COMPAT=252, RT_TABLE_DEFAULT=253, RT_TABLE_MAIN=254, RT_TABLE_LOCAL=255, RT_TABLE_MAX=0xFFFFFFFF
};

从枚举类型名称，如果没有使用策略路由，那么只有RT_TABLE_MAIN和RT_TABLE_LOCAL两种类型的路由表存在。

struct fib_info

多个路由项共享该一些字段：

struct fib_info {
struct hlist_nodefib_hash;
struct hlist_nodefib_lhash;
struct net  *fib_net;
int fib_treeref;
atomic_t  fib_clntref;
unsigned int  fib_flags;
unsigned char  fib_dead;
unsigned char  fib_protocol;
unsigned char  fib_scope;
unsigned char  fib_type;
__be32  fib_prefsrc;
u32 fib_priority;
u32 *fib_metrics;
#define fib_mtu fib_metrics[RTAX_MTU-1]
#define fib_window fib_metrics[RTAX_WINDOW-1]
#define fib_rtt fib_metrics[RTAX_RTT-1]
#define fib_advmss fib_metrics[RTAX_ADVMSS-1]
int fib_nhs;
#ifdef CONFIG_IP_ROUTE_MULTIPATH
int fib_power;
#endif
struct rcu_headrcu;
struct fib_nh  fib_nh[0];
#define fib_dev fib_nh[0].nh_dev
};

路由项别名：

struct fib_alias {
struct list_headfa_list;
struct fib_info*fa_info;
u8 fa_tos;
u8 fa_type;
u8 fa_state;
struct rcu_headrcu;
};

下一跳，使用route或者ip route 可以添加。

struct fib_nh {
struct net_device*nh_dev;
struct hlist_nodenh_hash;
struct fib_info*nh_parent;
unsigned int  nh_flags;
unsigned char  nh_scope;
#ifdef CONFIG_IP_ROUTE_MULTIPATH
int nh_weight;
int nh_power;
#endif
#ifdef CONFIG_IP_ROUTE_CLASSID
__u32 nh_tclassid;
#endif
int nh_oif;
__be32  nh_gw;
__be32  nh_saddr;
int nh_saddr_genid;
struct rtable __rcu * __percpu *nh_pcpu_rth_output;
struct rtable __rcu*nh_rth_input;
struct fnhe_hash_bucket*nh_exceptions;
};

struct dst_entry路由表入口项

struct dst_ops 路由入口项的操作函数集，如垃圾回收函数就在这里。

struct rtable  路由表

路由三大块：路由缓存、路由表、路由信息查找，这三大块依赖的重要数据数据结构在路由子系统初始化时完成。

路由子系统初始化：

2655 int __init ip_rt_init(void)
2656 {
/*ip_rt_acct 字段的意义在前面*/
2659 #ifdef CONFIG_IP_ROUTE_CLASSID
2660     ip_rt_acct = __alloc_percpu(256 * sizeof(struct ip_rt_acct), __alignof__(struct ip_rt_acct));
2661     if (!ip_rt_acct)
2662         panic("IP: failed to allocate ip_rt_acct\n");
2663 #endif
//创建rtalble大小的路由表缓存，这是上述路由三大块中的路由缓存使用的，没有使用malloc的原因是加速网络数据包的传递
2665     ipv4_dst_ops.kmem_cachep =
2666         kmem_cache_create("ip_dst_cache", sizeof(struct rtable), 0,
2667                   SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
2668
2669     ipv4_dst_blackhole_ops.kmem_cachep = ipv4_dst_ops.kmem_cachep;
/*路由项垃圾回收门限，对无效的路由项回收其占用内存的门限，初始设置门限为最大值*/
2677     ipv4_dst_ops.gc_thresh = ~0;
/*路由表膨胀的最大尺寸，#define INT_MAX ((int)(~0U>>1))*/
2678     ip_rt_max_size = INT_MAX;
/*****************************
注册两种类型的内核通知链，netdev_chain和inetaddr_chain，这两种通知链对应的回调函数是inetdev_event和fib_inetaddr_event，设备的状态的改变（up、down、register和unregistere）会调用回调函数：
devinet_init---向--netdev_chain---添加--inetdev_event回调函数；  回调函数完成设备的初始化、删除等操作
ip_fib_init---向--netdev_chain---添加--fib_netdev_event回调函数；回调函数完成该设备相关路由表的使能、禁止、刷新等操作。-向--inetaddr_chain---添加--fib_inetaddr_event回调函数；回调函数完成该设备相关路由表路由项的添加和删除操作。
***************************/
2680     devinet_init();
2681     ip_fib_init();
2696     return rc;
2697 }

12.2 LC-trie（字典树、单词查找树）

现在内核采用的是trie算法组织路由表，这里的trie其实就是tree的意思。本章会以ifconfig和route两个命令作为引子，以这两个例子详细看一下trie路由算法在Linux下的实现，本节是现在内核默认trie路由算法的一个简单的算法简介，并将trie路由算法的节点、叶子和Linux内核下具体的数据结构对应起来。至于早期的哈希算法，这里就丝毫没有涉及了。

先从一个引子说起，如果让你使用百度词典查找apple这个单词，会发现在你输入一个字母后，其下拉栏会显示若干的备选单词。如图12.2.1显示的，会有appliance、apple等提示单词，问题来了，百度是按照什么规则给出的提示的呢？

1、首先这些单词必须遵循字母顺序，不能用户输入a，下来栏中出现个b打头的单词。

2、首先这些词在字典里必须是存在的，或者是一些组织机构的，总而言之就是这个词目前是存在的。

3、这些词并没有按照26个字母表的顺序给出，图中很明显，ace比and要排在前面，这里加入了词频（概率）权重因子。

图12.2.1 apple字典提示

路由的算法就有点类似上面下拉栏的实现算法。但是上述频率的概念没有在路由算法本身体现，所以这里也就略过。下面还是以单词为例来看看LC-trie是如何组织的。图12.2.1中蓝色一栏就是我们要找的单词。

图12.1.2是对要查找的单词构建的一颗字典树，虚线左右两边都对应这个树，它们的不同在于深度。我们以左边的示例来说明字典树是如何组织的，对于apple这个单词，

1、树的根为空，NULL

2、最后一个字符是e，e被称为叶子

3、中间的字符，如a、p、l等，被称为节点。

4、尽量利用前缀节点，比如approve和apple有相同的前缀app，黄色那个支路就是用来表示approve的。

图12.2.2 apple字典树拓扑

图12.2.2中左右两幅图是用来说明rebalance这个概念的，这棵树不能太瘦也不能太胖，也即其广度和深度要在一个合理的比率上。所以当我们觉得这棵树太瘦时，可以进行压缩，比如将app压缩成一个节点，这就意味着先前复用a、ap的节点会被创建，因为这时没有a、ap节点了。如果太胖，那就拉长，就是上述过程的逆过程。

上述的过程虽然和内核管理路由表的方法有点差别，但思想是一样的，图12.1.3是具有10.12.39.0和192.168.0.10两项的路由表。这个10.12.39.0并不是使用route add 192.168.0.10 eth0 命令分配的，而是使用ifconfig eth0 10.12.39.221 netmask255.255.255.0 配置本机IP地址时设置的。至于为什么配置本机IP地址的ifconfig会设置这么一个路由项，主要原因是规范中要求：主机号全零的用于标识一个网段，这个地址会被用作路由项，不能被分配给主机使用，Linux默认在设置主机IP时，都会配置一个主机号全零的IP作为路由项。这个内容在12.2节中会看到代码的实现。

图12.2.4是在图12.2.3的基础之上使用route命令添加一项组成的路由表拓扑图，需要说明的是这两幅图是路由项组织的核心结构，这里略去了其和路由缓存、arp缓存、网络命名空间等之间的交互。图中黄色部分是数据结构，淡蓝色部分是对应数据结构的成员，成员的等号右边是其具有的值。

Struct fib_table：代表一个路由表，

tb_hlist，对于ipv4是&net->ipv4.fib_table_hash[TABLE_MAIN_INDEX]指向的哈希表，用于索引该路由项，对于本机IP地址由&net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX]哈希表来指向。

tb_id用于标识表的ID号，对于路由出去的表id是254，本地IP表则id是255。

tb_data[0]零长数组，这个数组用于指向struct trie结构体，这个结构体就是对

struct rt_trie_node结构体的封装，该结构体只有parent和key两个成员，红色框已经表明它们的所属关系。

struct tnode结构体的前两项也是parent 和key，这就意味着可以使用强制类型转换方法和struct rt_tire_node互换使用。内核经常使用这个技巧。tnode自身是trie node的意思，就是字典树的节点的意义，对应图12.1.1的蓝色节点，tnode的最后一个成员是*child[0]，这是又是一个零长数组，图中画出了0和1两个成员，实际上可能还有2…，full_children与empty_children之和等于零长数组成员的个数。

Pos：比较起始位置

Bits：比较的位数。

这两成员算是trie路由算法的核心成员，pos指定了一个32位ipv4地址比较的起始位置，bits指定了比较的比特数，因为IPV4的地址是32位的，pos和bits是0~31之间的数值。

由于10.12.39.0路由项先于192.168.0.10路由项存在这张路由表中，当插入192.168.0.10时，它会和根节点开始查找，192和10的二进制比较结果就是，它们的第一个bit不同，192的第一个bit是1，而10的四位二进制的第一个bit是0，23bit的IPv4地址使用0~31标记，这就是tnode中pos等于0，bits等于1的由来。

leaf对应图12.2.3中的黄色节点，用于标记叶子节点。

图12.2.3 具有10.12.39.0和192.168.0.10两项的路由表

在插入192.168.0.100时，很明显，首先遍历tnode，找到pos是0，bits1是1的一个节点（实际上只有这么一个节点），tnode的children，发现有相同的前缀192.168.0项，即192.168.0.100和192.168.0.10从第25个bit不同，并且不同的那个bit的值是1，这里会创建一个tnode，并将children赋值成适当的叶子。这一过程参看图12.1.4，和图12.1.3对比可以使这一过程更加明晰。当这棵树添加完成了以后，最后会去判断这棵树是否需要rebalance。

图12.2.4 10.12.39.0/192.168.0.10/192.168.0.100三项路由表项

对路由项的核心算法以及路由表项的组织有了一个了解以后，下面就正式进入源码及的剖析，由于代码的分支情况及其繁多，所以会以一个主线分析代码，即使主线不包括的代码也会注释它们的功能。

最后为了加深对pos和bits的奥妙了理解，这里给出3个IP地址分别是10.12.39.0,192.168.0.10和192.168.0.100这三项，这三项和图12.1.4是对应的。插入的顺序是10.12.39.0、192.168.0.10和192.169.0.100，插入192.168.0.10时，其发现和10.12.39.0的第0个比特不同，所以这时会将先前的10.12.39.0作为一个tnode，tnode的pos设置为0，bits设置成1，黄色的那里只有一列，在插入192.168.0.100时，其和192.168.0.10有相同的前缀，所以192.168.0.10赋值到一个tnode，其pos设置为25，bits设置为1。查找时先遍历tnode，在遍历leaf，这个过程会在后面结合具体代码来看。图中虚线右边是rebalance的一个示例。

图12.2.5 10.12.39.0/192.168.0.10/192.168.0.100三项路由表的pos和bits

12.3 ifconfig下trie路由跟新

12.3.1 路由下路由信息

在/proc/net/目录下fib_trie和fib_triestat这两个文件，这两文件包含了一些trie路由的信息。fib_trie用于显示路由表的树状图，fib_ritestat是trie树的一些统计信息。

没有分配IP地址时的路由信息：

# cat /proc/net/fib_trie
# cat /proc/net/fib_triestat
Basic info: size of leaf: 20 bytes, size of tnode: 28 bytes.
Local: Aver depth:     0.00Max depth:      0Leaves:         0Prefixes:       0Internal nodes: 0Pointers: 0
Null ptrs: 0
Total size: 0  kB
Main: Aver depth:     0.00Max depth:      0Leaves:         0Prefixes:       0Internal nodes: 0Pointers: 0
Null ptrs: 0
Total size: 0  kB

没有分配IP地址时的路由信息都是空的，这很合逻辑， 在使用ifconfig eth0 10.12.39.221 netmask255.255.255.0配置本机IP时，路由信息的内容非常的多。在fib_trie中可以看到有Local和Main这两个字段，这两个字段分别对应于两张表，Local用于表示自己的IP地址，而Main用于路由出去的IP地址。

在配置10.12.39.221时，LOCAL表中包含了主机号全零和主机号全一的IP地址，这都是协议上规定的特殊地址。

第3行10.12.39.0/24，这里的24对应于12.2节中trie字段的pos，这里10.12.39.0和10.12.192的第一个不同的比特就是第24个（从0位置计）比特。同样第6行中的26也是根据10.12.39.221和10.12.39.255之间的差别。有“+”的行，表明其是一个tnode（节点），“|”则表明了其是一个leaf（叶子）。每个叶子下面“/”的标记了该叶子的属性，host、LOCAL以及BROADCAST是表的类型，每对应这么一项，意味着插入了一次，比如这里的叶子10.12.39.0既属于link类型又属于BROADCAST类型，这两种类型的表项会对应于两次插入路由表的动作。

fib_triestat统计了树的一些统计信息，在12.2节中所述的rebalance操作就是依赖这些统计信息对树进行均衡的。

1# cat /proc/net/fib_trie
2Local:
3  +-- 10.12.39.0/24 1 0 0
4    |-- 10.12.39.0
5        /32 link BROADCAST
6     +-- 10.12.39.192/26 1 0 0
7        |-- 10.12.39.221
8           /32 host LOCAL
9        |-- 10.12.39.255
10           /32 link BROADCAST
11Main:
12  |-- 10.12.39.0
13     /24 link UNICAST15# cat /proc/net/fib_triestat
16Basic info: size of leaf: 20 bytes, size of tnode: 28 bytes.
17Local:
18  Aver depth:     1.66
19  Max depth:      2
20  Leaves:         3
21  Prefixes:       3
22  Internal nodes: 2
23    1: 2
24  Pointers: 4
25Null ptrs: 0
26Total size: 1  kB
27Main:
28  Aver depth:     0.00
29  Max depth:      0
30  Leaves:         1
31  Prefixes:       1
32  Internal nodes: 0
33
34  Pointers: 0
35Null ptrs: 0
36Total size: 1  kB

12.3.2  路由通知链函数的注册

前面已经见到过ip_fib_init函数，这个函数在net/ipv4/fib_frontend.c文件中，并且在初始化时会被调用。

1075 static struct notifier_block fib_inetaddr_notifier = {
1076     .notifier_call = fib_inetaddr_event,
1077 };
1168 void __init ip_fib_init(void)
1169 {
1170     rtnl_register(PF_INET, RTM_NEWROUTE, inet_rtm_newroute, NULL, NULL);
1171     rtnl_register(PF_INET, RTM_DELROUTE, inet_rtm_delroute, NULL, NULL);
1172     rtnl_register(PF_INET, RTM_GETROUTE, NULL, inet_dump_fib, NULL);
1173
1174     register_pernet_subsys(&fib_net_ops);
1175     register_netdevice_notifier(&fib_netdev_notifier);
1176     register_inetaddr_notifier(&fib_inetaddr_notifier);
1177
1178     fib_trie_init();
1179 }

其1176行注册的结构体在1075行，这节就以注册的fib_inetaddr_event函数开始，当使用ifconfig eth0 10.12.39.221 netmask255.255.255.0 设置设备IP地址时，这个函数就会被触发调用。1175行的fib_netdev_notifier函数也会在该设备获得地址的时候出发调用，进而会配置12.3.1节中那些未指定IP地址。

12.3.3  ifconfig调用流程

ifconfig配置IP地址的函数调用，第一个内核里被调用到的函数是inet_ioctl()，经过devinet_ioctl函数会调用fib_inetaddr_event():

net/ipv4/af_inet.c inet_ioctl()

net/ipv4/devinet.c devinet_ioctl()

fib_inetaddr_event()这个函数是在上一节注册的通知链函数，从这个函数的命名（fib forward information base）就可以看出其和路由是有直接关系关系的，这节就从这个函数开始。

好了从现在开始就要正式接触Linux内核网络路由代码细节了。由12.3.1节可知，一个ifconfig命令会在Local表中配置三项路由项，在Main表中配置一项路由项，本节所述内容是ifconfig在Local表创建路由项所经历的代码片段，当然在操作Main表时用的都是同一套代码。

图12.3.1给出是的ifconfig在创建一个本地IPv4地址时所调用的函数，在后面继续创建路由项时同样调用这些函数，只是执行的逻辑分支会不一样，为了让脉络更加清晰，图12.3.1是添加10.12.39.221这一项路由项的函数调用流程。

首先在fib_inetaddr_event检测导师是NETDEV_UP事件发生，其会调用fib_add_ifaddr函数处理设备UP事件，fib_add_ifaddr的源码如下：

net/ipv4/fib_frontend.c

 734 void fib_add_ifaddr(struct in_ifaddr *ifa)735 {736     struct in_device *in_dev = ifa->ifa_dev;737     struct net_device *dev = in_dev->dev;738     struct in_ifaddr *prim = ifa;739     __be32 mask = ifa->ifa_mask;740     __be32 addr = ifa->ifa_local;741     __be32 prefix = ifa->ifa_address & mask;742 743     if (ifa->ifa_flags & IFA_F_SECONDARY) {744         prim = inet_ifa_byprefix(in_dev, prefix, mask);745         if (prim == NULL) {746             pr_warn("%s: bug: prim == NULL\n", __func__);747             return;748         }749     }750 751     fib_magic(RTM_NEWROUTE, RTN_LOCAL, addr, 32, prim);752 753     if (!(dev->flags & IFF_UP))754         return;755 756     /* Add broadcast address, if it is explicitly assigned. */757     if (ifa->ifa_broadcast && ifa->ifa_broadcast != htonl(0xFFFFFFFF))758         fib_magic(RTM_NEWROUTE, RTN_BROADCAST, ifa->ifa_broadcast, 32, prim);759 760     if (!ipv4_is_zeronet(prefix) && !(ifa->ifa_flags & IFA_F_SECONDARY) &&761         (prefix != addr || ifa->ifa_prefixlen < 32)) {762         fib_magic(RTM_NEWROUTE,763               dev->flags & IFF_LOOPBACK ? RTN_LOCAL : RTN_UNICAST,764               prefix, ifa->ifa_prefixlen, prim);765 766         /* Add network specific broadcasts, when it takes a sense */767         if (ifa->ifa_prefixlen < 31) {768             fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix, 32, prim);769             fib_magic(RTM_NEWROUTE, RTN_BROADCAST, prefix | ~mask,770                   32, prim);771         }772     }773 }

743~749 如果flag参数指定了配置IP对象为从属设备或者临时设备，但是根据索引找不到该设备，返回错误。

751行，在ID等于255的表中，插入IP地址类型为2的IP地址dd270c0a。ID等于255的表示是LOCAL表，即该表中的所有IP项的目的地址均是本机。类型见IP地址类型。

760~770处理广播包的路由项。主机号全为1和主机号全为0，实际的过程比较复杂，这里就不展开了，这里以751行添加的过程来说明路由表项是如何添加的。

IP地址的类型如下

include/uapi/linux/ rtnetlink.h

191 enum {
192     RTN_UNSPEC,//未定义
193     RTN_UNICAST, //单播，网关或者直接路由
194     RTN_LOCAL, //host地址，目的地址是本机
195     RTN_BROADCAST,    广播地址，广播收广播发
197     RTN_ANYCAST,   //广播接收数据，单播发送数据，IPV6协议规定的地址类型
199     RTN_MULTICAST,   多播
200     RTN_BLACKHOLE,   丢弃
201     RTN_UNREACHABLE,  目的不可达
202     RTN_PROHIBIT,   管理员禁止IP地址
203     RTN_THROW,     /* Not in this table        */
204     RTN_NAT,      需要进行网络地址转换
205     RTN_XRESOLVE,    外部解析
206     __RTN_MAX
207 };

图12.3.1 ifconfig 配置IP地址调用流程

路由项的管理集中在fib_frontend.c、fib_semantics.c和fib_trie.c这三个文件，后面的代码也集中在这三个文件中。接着fib_magic函数的调用。这个函数的三个参数：

Cmd：ioctl传递的命令参数，这里是RTM_NEWROUTE，对应添加路由项，此外前面提到的netfilter也是在这个magic函数里处理的。

Type：这个参数是路由项的类型，前面已经介绍过了，这里传递的参数是RTN_LOCAL，配置的IP地址的目的端就是本机。

Dst：是一个32bit的IP地址，是要添加到路由表项，ifa是一些附属配置信息。

net/ipv4/fib_frontend.c

 696 static void fib_magic(int cmd, int type, __be32 dst, int dst_len, struct in_ifaddr *ifa)697 {698     struct net *net = dev_net(ifa->ifa_dev->dev);699     struct fib_table *tb;700     struct fib_config cfg = {701         .fc_protocol = RTPROT_KERNEL,702         .fc_type = type,703         .fc_dst = dst,704         .fc_dst_len = dst_len,705         .fc_prefsrc = ifa->ifa_local,706         .fc_oif = ifa->ifa_dev->dev->ifindex,707         .fc_nlflags = NLM_F_CREATE | NLM_F_APPEND,708         .fc_nlinfo = {709             .nl_net = net,710         },711     };712 713     if (type == RTN_UNICAST)714         tb = fib_new_table(net, RT_TABLE_MAIN);715     else716         tb = fib_new_table(net, RT_TABLE_LOCAL);717 718     if (tb == NULL)719         return;720 721     cfg.fc_table = tb->tb_id;722 723     if (type != RTN_LOCAL)724         cfg.fc_scope = RT_SCOPE_LINK;725     else726         cfg.fc_scope = RT_SCOPE_HOST;727 728     if (cmd == RTM_NEWROUTE)729         fib_table_insert(tb, &cfg);730     else731         fib_table_delete(tb, &cfg);732 }

700~710行，将用户传递的配置参数使用内核下的数据结构保护起来。

713~716通过类型，索引要添加到的表。

include/net/ip_fib.h

204 staticinline struct fib_table *fib_get_table(struct net *net, u32 id)
205 {
206     struct hlist_head *ptr;
207
208     ptr = id == RT_TABLE_LOCAL ?
209        &net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX] :
210        &net->ipv4.fib_table_hash[TABLE_MAIN_INDEX];
211     return hlist_entry(ptr->first, structfib_table, tb_hlist);
212 }
213
214 staticinline struct fib_table *fib_new_table(struct net *net, u32 id)
215 {
216     return fib_get_table(net, id);
217 }

这个函数的第一个参数是一个net，代表了一个网络，其附属于一个网络命名空间，第二个参数是716行的RT_TABLE_LOCAL。索引返回的类型是fib_table，在路由表核心数据结构时，介绍过fib_table代表的是路由表的大类，这些路由表可以多打256张，这么多张的表使用哈希法索引。

fib_get_table的209行就是返回ipv4的路由项，&net->ipv4.fib_table_hash[TABLE_LOCAL_INDEX]。

718~719判断是否得到了该表项，依据就是这个表的地址非NULL，实际上在初始化时这个表已经得到了存储表项的空间。

721~726将参数保存在cfg结构体内。

728~729将cfg中保存的配置路由项的信息，插入到由fib_get_table获得的表中。

路由项的插入工作就是在fib_table_insert这个函数中完成的，这个函数大体分为四个部分：

1、路由信息获取，每一个路由项都会对应一个路由信息，并且一个路由信息可以对应多个路由项。获取含义是先查找，如果找不到路由信息则根据传递的参数创建路由信息。

2、Trie树节点tnode。存在多个路由项，并且他们有共同的前缀时，共同的前缀会被设定为tnode。

3、Trie树叶子leaf，如果一个路由项不在路由表中，但是其和其它已经在路由表中的项具有相同的前缀，则会创建对应的叶子，在rebalance操作时，tnode和leaf因深度和广度原因都可能被调整。

4、插入操作，就是将新创建的叶子插入到trie树上去，也就对应创建了一个路由项。

net/ipv4/fib_frontend.c

1172 int fib_table_insert(struct fib_table*tb, struct fib_config *cfg)
1173 {
1174    struct trie *t = (struct trie *) tb->tb_data;
1175    struct fib_alias *fa, *new_fa;
1176    struct list_head *fa_head = NULL;
1177    struct fib_info *fi;
1178    int plen = cfg->fc_dst_len;
1179    u8 tos = cfg->fc_tos;
1180    u32 key, mask;
1181    int err;
1182    struct leaf *l;
//图12.1.2中plen值等于32。下面的判断条件满足。
1184    if (plen > 32)
1185        return -EINVAL;
//图12.3.1中，fc_dst是0a0c27dd，即10.12.39.221，用户空间配置的路由地址
1187    key = ntohl(cfg->fc_dst);
//mask 等于~0
1191    mask = ntohl(inet_make_mask(plen));
//验证key（目的地址）和目的地址掩码的正确性。
1193    if (key & ~mask)
1194        return -EINVAL;
//经过掩码匹配，得到真正的键值key等于10.12.39.221
1196    key = key & mask;
//对应于四个部分中的第一个部分，路由信息获取，见后文
1198    fi = fib_create_info(cfg);
1199    if (IS_ERR(fi)) {
1200        err = PTR_ERR(fi);
1201        goto err;
1202    }
//对应于四个部分的第二、三两个部分，遍历tnode获取，获取叶子leaf，见后文。
1204    l = fib_find_node(t, key);
1205    fa = NULL;
//在使用ifconfig向LOCAL表插入10.12.39.221前，路由表时空的，所以这里不可能找到对应的fib_table 和leaf信息。所以这里fi返回值是新创建的路由信息记录项，I==NULL，fa==NULL，直接跳至1293行，对于如果有相同前缀的路由IP项，fib_find_node返回的是一个tnode。
1207    if (l) {
//get_fa_head根据leaf信息，获得fib_alias链表的头指针。
1208        fa_head = get_fa_head(l, plen);
//遍历上述链表，找到合适的服务类型和优先级，合适的意义是优先级要高于这里传递的参数
1209        fa = fib_find_alias(fa_head, tos, fi->fib_priority);
1210    }
//fa在首次配置IP地址时为空，第一遍先跳过下面对这个if语句的注释吧，第二遍再来看。
1223    if (fa && fa->fa_tos == tos &&
1224        fa->fa_info->fib_priority == fi->fib_priority) {
1225        struct fib_alias *fa_first, *fa_match;
1226
1227        err = -EEXIST;
1228        if (cfg->fc_nlflags & NLM_F_EXCL)
1229             goto out;
1230
1231        /* We have 2 goals:
1232         * 1. Find exact match for type, scope, fib_info to avoid
1233         * duplicate routes
1234         * 2. Find next 'fa' (or head), NLM_F_APPEND inserts before it
1235         */
1236        fa_match = NULL;
1237        fa_first = fa;
1238        fa = list_entry(fa->fa_list.prev, struct fib_alias, fa_list);
1239        list_for_each_entry_continue(fa, fa_head, fa_list) {
1240             if (fa->fa_tos != tos)
1241                 break;
1242             if(fa->fa_info->fib_priority != fi->fib_priority)
1243                 break;
1244             if (fa->fa_type ==cfg->fc_type &&
1245                 fa->fa_info == fi) {
1246                 fa_match = fa;
1247                 break;
1248             }
1249        }
1250
1251        if (cfg->fc_nlflags & NLM_F_REPLACE) {
1252             struct fib_info *fi_drop;
1253             u8 state;
1254
1255             fa = fa_first;
1256             if (fa_match) {
1257                 if (fa == fa_match)
1258                     err = 0;
1259                goto out;
1260             }
1261             err = -ENOBUFS;
//上面的代码已然没有找到fib alias，所以这里创建新的fib alias。并在1266~1273行对其成员进行初始化。
1262             new_fa =kmem_cache_alloc(fn_alias_kmem, GFP_KERNEL);
1263             if (new_fa == NULL)
1264                 goto out;
1265
1266             fi_drop = fa->fa_info;
1267             new_fa->fa_tos = fa->fa_tos;
1268             new_fa->fa_info = fi;
1269             new_fa->fa_type =cfg->fc_type;
1270             state = fa->fa_state;
1271             new_fa->fa_state = state &~FA_S_ACCESSED;
1272
1273             list_replace_rcu(&fa->fa_list,&new_fa->fa_list);
1274             alias_free_mem_rcu(fa);
1275
1276             fib_release_info(fi_drop);
1277             if (state & FA_S_ACCESSED)
1278                rt_cache_flush(cfg->fc_nlinfo.nl_net);
1279            rtmsg_fib(RTM_NEWROUTE,htonl(key), new_fa, plen,
1280                 tb->tb_id,&cfg->fc_nlinfo, NLM_F_REPLACE);
1281
1282             goto succeeded;
1283        }
1284        /* Error if we find a perfect match which
1285         * uses the same scope, type, and nexthop
1286         * information.
1287         */
1288        if (fa_match)
1289             goto out;
1290
1291        if (!(cfg->fc_nlflags & NLM_F_APPEND))
1292             fa = fa_first;
1293    }
1294    err = -ENOENT;
//由图12.3.1可以知道fc_nlflags的值等于1024，就是0x400，正好等于这里的（NLM_F_CREATE），所以还要接着1297行看。
1295    if (!(cfg->fc_nlflags & NLM_F_CREATE))1296         goto out;
1297
1298    err = -ENOBUFS;
//从fn_alias_kmem上分配一块cache，这个cache用于flash别名系统
1299    new_fa = kmem_cache_alloc(fn_alias_kmem, GFP_KERNEL);
1300    if (new_fa == NULL)
1301        goto out;
//向fib_alias中插入相关的路由信息，并将其成员fa_info指向前面的fib_ info结构体。
1303    new_fa->fa_info = fi;
1304    new_fa->fa_tos = tos;
1305    new_fa->fa_type = cfg->fc_type;
1306    new_fa->fa_state = 0;
1307    /*
1308     * Insert new entry to the list.
1309     */
//fa_head在1208行没有得到复制，这里fa_head == NULL， fib_insert_node对应于第四个部分，插入操作，见后文
1311    if (!fa_head) {
1312        fa_head = fib_insert_node(t, key, plen);
1313        if (unlikely(!fa_head)) {
1314             err = -ENOMEM;
1315             goto out_free_new_fa;
1316        }
1317    }
1318
//跟新tb_num_default字段
1319    if (!plen)
1320        tb->tb_num_default++;
//处理fa_list链表
1322    list_add_tail_rcu(&new_fa->fa_list,
1323               (fa ? &fa->fa_list :fa_head));
1324
1325    rt_cache_flush(cfg->fc_nlinfo.nl_net);
发送netlink消息
1326    rtmsg_fib(RTM_NEWROUTE, htonl(key), new_fa, plen, tb->tb_id,
1327           &cfg->fc_nlinfo, 0);
1328 succeeded:
1329    return 0;
//差错处理
1331 out_free_new_fa:
1332    kmem_cache_free(fn_alias_kmem, new_fa);
1333 out:
1334    fib_release_info(fi);
1335 err:
1336    return err;
1337 }

1198行fib_create_info获得一个路由信息记录结构体，当要获得的对象不存在时，会创建一个新的路由信息结构体fib_info。

net/ipv4/fib_semantics.c

773 struct fib_info*fib_create_info(structfib_config *cfg)774 {775    interr;776    structfib_info *fi = NULL;777    structfib_info *ofi;778    int nhs= 1;779    structnet *net = cfg->fc_nlinfo.nl_net;
//用户空间传递进来的tc_type值是2，所以这里的检查类型的有效性通过。781    if(cfg->fc_type > RTN_MAX)782        gotoerr_inval;
//本地地址LOCAL的值是RT_SCOPE_HOST，254，用户传递进来的fc_scope等于254（图13.3.1），这里检查也通过。784    /* Fastcheck to catch the most weird cases */785    if(fib_props[cfg->fc_type].scope > cfg->fc_scope)786        gotoerr_inval;
796    err =-ENOBUFS;
// 对于由于前表项为空，所以统计路由信息技术变量fib_info_cnt的值等于0，索引路由信息的哈希数组大小变量//fib_info_hash_size值等于0.797    if(fib_info_cnt >= fib_info_hash_size) {798        unsignedint new_size = fib_info_hash_size << 1;799        structhlist_head *new_info_hash;800        structhlist_head *new_laddrhash;801        unsignedint bytes;
//由于fib_info_hash_size确实为0，所以这里的new_size将被赋值成16。803        if(!new_size)804            new_size= 16;805        bytes= new_size * sizeof(struct hlist_head *);
//为哈希信息和哈希地址存储分配内存，如果小于一个页使用kzalloc，大于一个页使用__get_free_pages。806        new_info_hash= fib_info_hash_alloc(bytes);807        new_laddrhash= fib_info_hash_alloc(bytes);
//分配失败的处理，如果没有失败，调用fib_info_hash_move进行处理。808        if (!new_info_hash || !new_laddrhash){809            fib_info_hash_free(new_info_hash,bytes);810            fib_info_hash_free(new_laddrhash,bytes);811        }else
//根据先前申请到的内存，设置fib_info_hash和fib_info_laddrhash这两个fib_semantics.c文件内的全局变量。这两变量用于链接所有的fib_info结构体。812            fib_info_hash_move(new_info_hash,new_laddrhash, new_size);813814        if(!fib_info_hash_size)815            gotofailure;816    }
//申请路由信息空间，注意零长数组指向了下一跳fib_nh(nh—next hop)。
818    fi =kzalloc(sizeof(*fi)+nhs*sizeof(struct fib_nh), GFP_KERNEL);819    if (fi== NULL)820        gotofailure;
/*用户空间没有配置metric，metirc用于配置下一跳的个数，不指定的情况下赋值如下。
*const u32 dst_default_metrics[RTAX_MAX+ 1]= {
*           [RTAX_MAX]= 0xdeadbeef,
*};
*/821    if(cfg->fc_mx) {822        fi->fib_metrics= kzalloc(sizeof(u32) * RTAX_MAX, GFP_KERNEL);823        if(!fi->fib_metrics)824            gotofailure;825    } else826        fi->fib_metrics= (u32 *) dst_default_metrics;
//fib_info_cnt用于计数有意义的fib_info 个数。827    fib_info_cnt++;
//下面的赋值，见图12.3.2，fib_info结构体赋值，值来源于用户配置。829    fi->fib_net= hold_net(net);830    fi->fib_protocol= cfg->fc_protocol;831    fi->fib_scope= cfg->fc_scope;832    fi->fib_flags= cfg->fc_flags;833    fi->fib_priority= cfg->fc_priority;834    fi->fib_prefsrc= cfg->fc_prefsrc;835    fi->fib_type= cfg->fc_type;
//初始化下一跳的成员，对于没有配置等价路由的，这个循环只会执行一次，对于等价路由，有几个等价的路由项就会执行几
//次。将下一跳的nh_parent指向fib_info字段。分配一个percpu变量，这会为每个核创建一个对应的rtable，rtable是路由缓//存部分的，其将加速路由项的查找，路由缓存参考11.5节。837    fi->fib_nhs= nhs;838    change_nexthops(fi){839        nexthop_nh->nh_parent= fi;840        nexthop_nh->nh_pcpu_rth_output= alloc_percpu(struct rtable __rcu *);841        if(!nexthop_nh->nh_pcpu_rth_output)842            gotofailure;843    }endfor_nexthops(fi)
//用户空间没有传递metric，跳过。845    if(cfg->fc_mx) {846        structnlattr *nla;847        intremaining;848849        nla_for_each_attr(nla,cfg->fc_mx, cfg->fc_mx_len, remaining) {850            inttype = nla_type(nla);851852            if(type) {853                u32 val;854855                if (type > RTAX_MAX)856                    goto err_inval;857                val = nla_get_u32(nla);858                if (type == RTAX_ADVMSS&& val > 65535 - 40)859                    val = 65535 - 40;860                if (type == RTAX_MTU&& val > 65535 - 15)861                    val = 65535 - 15;862                fi->fib_metrics[type - 1] =val;
863            }864        }865    }
//用户空间也没有配置等价路由，执行else语句。867    if(cfg->fc_mp) {868#ifdefCONFIG_IP_ROUTE_MULTIPATH869        err= fib_get_nhs(fi, cfg->fc_mp, cfg->fc_mp_len, cfg);870        if(err != 0)871            gotofailure;872        if(cfg->fc_oif && fi->fib_nh->nh_oif !=cfg->fc_oif)873            gotoerr_inval;874        if(cfg->fc_gw && fi->fib_nh->nh_gw != cfg->fc_gw)875            gotoerr_inval;876#ifdef CONFIG_IP_ROUTE_CLASSID877        if(cfg->fc_flow && fi->fib_nh->nh_tclassid !=cfg->fc_flow)878            gotoerr_inval;879#endif880#else881        gotoerr_inval;882#endif883     } else{
//对下一跳的赋值，见图12.3.2。赋值的来源同样是用户空间。884        structfib_nh *nh = fi->fib_nh;885886        nh->nh_oif= cfg->fc_oif;887        nh->nh_gw= cfg->fc_gw;888        nh->nh_flags= cfg->fc_flags;889#ifdef CONFIG_IP_ROUTE_CLASSID890        nh->nh_tclassid= cfg->fc_flow;891        if(nh->nh_tclassid)892            fi->fib_net->ipv4.fib_num_tclassid_users++;893#endif894#ifdefCONFIG_IP_ROUTE_MULTIPATH895        nh->nh_weight= 1;896#endif897    }
//fc_type类型是2，即单播，该类型的error成员值是0，执行else语句。else语句判断type字段是否合法。899    if(fib_props[cfg->fc_type].error) {900        if(cfg->fc_gw || cfg->fc_oif || cfg->fc_mp)901            gotoerr_inval;902        gotolink_it;903    } else{904        switch(cfg->fc_type) {905        caseRTN_UNICAST:906        case RTN_LOCAL:907        caseRTN_BROADCAST:908        case RTN_ANYCAST:909        caseRTN_MULTICAST:910            break;911        default:912            gotoerr_inval;913        }914    }
//范围大于RT_SCOPE_HOST（253）就出错了。用于限定路由的范围。916    if(cfg->fc_scope > RT_SCOPE_HOST)917        gotoerr_inval;
//fc_scope的值等于254，执行if语句里的内容，当使用route命令配置一个（RT_SCOPE_LINK）范围地址，执行else语句919    if(cfg->fc_scope == RT_SCOPE_HOST) {
//fi是在818行创建的指向fib_info的结构体，该结构体的部分程员在821~843被赋值，这里是处理其nh（next hop）字段。920        structfib_nh *nh = fi->fib_nh;921922        /*Local address is added. */923        if(nhs != 1 || nh->nh_gw)924            gotoerr_inval;
//目的地址是本机，所以scope赋值成RT_SCOPE_NOWHERE,该scope范围不会向外发送数据包。925        nh->nh_scope= RT_SCOPE_NOWHERE;
//根据索引号获得net_device结构体，net_device结构体用于标记网卡，其实就是“eth0”结构体，该网卡用来发送数据。926        nh->nh_dev= dev_get_by_index(net, fi->fib_nh->nh_oif);927        err= -ENODEV;928        if(nh->nh_dev == NULL)929            gotofailure;930    } else{931        change_nexthops(fi){
//fib_check_nh检查下一跳语义的正确性，932            err= fib_check_nh(cfg, fi, nexthop_nh);933            if(err != 0)934                goto failure;935        }endfor_nexthops(fi)936    }
// prefsrc是dd270c0a，并且检查也通过。938     if(fi->fib_prefsrc) {939        if(cfg->fc_type != RTN_LOCAL || !cfg->fc_dst ||940            fi->fib_prefsrc!= cfg->fc_dst)941            if(inet_addr_type(net, fi->fib_prefsrc) != RTN_LOCAL)942                goto err_inval;943    }
//获得对应接口的源地址信息，将这些信息存放在下一跳nexthop_nh中。945    change_nexthops(fi){946        fib_info_update_nh_saddr(net,nexthop_nh);947    }endfor_nexthops(fi)
//在fib_info_hash所标示的哈希表中，见图12.3.2左上角，紫色部分；看看要插入的路由项是否已经存在了，如果存在，则//955行直接返回，由于用户空间的配置路由项原本内核路由表中没有，所以接着958行继续。949link_it:950    ofi = fib_find_info(fi);951    if(ofi) {952        fi->fib_dead= 1;
953        free_fib_info(fi);954        ofi->fib_treeref++;955        returnofi;956    }
//路由树引用计数++958    fi->fib_treeref++;959    atomic_inc(&fi->fib_clntref);
//获得保护该路由信息记录项的锁。这个fib_info_hash表是局部全局的。以安全将上面创建的fi添加到fib_info_hash链表上。960    spin_lock_bh(&fib_info_lock);
//将这个新的fib_info，添加到管理这个结构的全局哈希表上。961    hlist_add_head(&fi->fib_hash,962               &fib_info_hash[fib_info_hashfn(fi)]);
969    change_nexthops(fi){970        structhlist_head *head;971        unsignedint hash;972973        if(!nexthop_nh->nh_dev)974            continue;
//ifindex的值等于2,对应于eth0。975        hash= fib_devindex_hashfn(nexthop_nh->nh_dev->ifindex);976        head= &fib_info_devhash[hash];
// fib_info_devhash是存储设备的哈希表，将nexthop指向设备的哈希元素添加到fib_info_devhash链表上。977        hlist_add_head(&nexthop_nh->nh_hash,head);978    }endfor_nexthops(fi)979    spin_unlock_bh(&fib_info_lock);
//最后这里返回已经添加到相应管理链表上的fib_info的结构体信息fi。980    returnfi;
992 }

图12.3.2 ifconfig使用到的数据结构

fib_find_info参数值是前面创建的fib_info结构体，这个函数就是在管理fib_info的哈希链表fib_info_hash查找先前创建的fib_info信息是否已经存在这张链表了，如果存在，那么说明fib_info没有必要在创建了，直接重复利用就好了。

298 static struct fib_info *fib_find_info(const struct fib_info *nfi)299 {300     struct hlist_head *head;301     struct fib_info *fi;302     unsigned int hash;
//计算fib_info的哈希索引值，该哈希值依赖于fib_protocol、fib_scope、fib_prefsrc、fib_priority以及设备index。304     hash = fib_info_hashfn(nfi);
//直接得到传递进来了fib_info所对应的哈希表头，如果在这个表中能够找到就直接返回，如果找不到返回NULL，返回去以后
//的函数查看返回值，是NULL的话，说明这项并不存在，就会将这个fib_info添加到fib_info_hash链表上。305     head = &fib_info_hash[hash];
//遍历哈希表，依次对比哈希表的每一个成员的下列字段和传递进来要找的fib_info是否相同。 307     hlist_for_each_entry(fi, head, fib_hash) {308         if (!net_eq(fi->fib_net, nfi->fib_net))309             continue;310         if (fi->fib_nhs != nfi->fib_nhs)311             continue;312         if (nfi->fib_protocol == fi->fib_protocol &&313             nfi->fib_scope == fi->fib_scope &&314             nfi->fib_prefsrc == fi->fib_prefsrc &&315             nfi->fib_priority == fi->fib_priority &&316             nfi->fib_type == fi->fib_type &&317             memcmp(nfi->fib_metrics, fi->fib_metrics,318                sizeof(u32) * RTAX_MAX) == 0 &&319             ((nfi->fib_flags ^ fi->fib_flags) & ~RTNH_F_DEAD) == 0 &&320             (nfi->fib_nhs == 0 || nh_comp(fi, nfi) == 0))321             return fi;322     }323 324     return NULL;325 }

继续回到fib_table_insert 的1204行fib_find_node，该函数用于查找叶子节点。页叶子节点和tnode都是用来表示字典树节点，它们处在这棵树的位置不一样，两者并不完全相同，但是前两个成员是一样的，两者之间的互相转换的技巧前面已经遇到过了。这个函数的参数，key就是要添加的192.168.0.10 IP地址，第一个参数见图12.3.2路由表拓扑的底部。这个函数查找的过程是这样的：首先遍历tnode，然后是遍历leaf，这个过程还是很容易理解的。

955 static struct leaf *956fib_find_node(struct trie *t, u32 key)957 {958    int pos;959    struct tnode *tn;960    struct rt_trie_node *n;961962    pos = 0;
//将传递进来的trie节点转换成tnode类型。963    n = rcu_dereference_rtnl(t->trie);
/*************************************************************************************************
//在插入唯一一项10.12.39.0时，这一项就是一个leaf。
//在添加192.168.0.10时，由于n指向10.12.39.0的rt_trie_node类结构体，并不是NULL。
// n->parent:00000001, n->key:0a0c2700。
//而在添加192.168.0.10时，
// n->parent:00000000, n->key:0a0c2700
n->parent用于存放其父节点的地址，这个父节点是tnode，如果不存在则是NULL（0000000*）。该成员的最低bit用于标识这个节点是tnode还是leaf。如果是tnode则最低一个bit是0，如果是leaf则最低一个bit是1。
//#define T_TNODE 0
//#define T_LEAF  1
在插入192.168.0.10时，由于10.12.39.0是个leaf，所以这个循环被跳过了。而插入192.168.0.100时，由于有tnode存在，所以这里while循环就不会被跳过了，这个tnode是图12.3.2的上面两行产生了，至于pos为25的则是192.168.0.100插入之后才会存在的tnode。
***************************************************************************************************/965    while (n != NULL && NODE_TYPE(n) == T_TNODE) {966        tn = (struct tnode *) n;967968        check_tnode(tn);
//970~977非常经典的几行代码，就这么短短的几行代码能够处理更正情况下与要查找的key最接近的tnode。970        if (tkey_sub_equals(tn->key, pos, tn->pos-pos, key)) {971            pos = tn->pos + tn->bits;972            n = tnode_get_child_rcu(tn,973                         tkey_extract_bits(key,974                                   tn->pos,975                                  tn->bits));976        } else977            break;978    }//如果这个if语句满足，说明我们要插入的项已经存在这个路由表了，这是一次重复插入操作。981    if (n != NULL && IS_LEAF(n) && tkey_equals(key,n->key))982        return (struct leaf *)n;983984    return NULL;985 }

为了说明遍历tnode的过程，看图12.3.2，如果根据该图张图不能想象出trie的拓扑结构，参考图12.2.4，它们是一样的拓扑结构。在这个基础上，这里在次插入192.168.0.11这个项。

图12.3.2 路由项查找实例

Key值就是192.168.0.11，t参数指向10.12.39.0这个tnode。

遍历过程如下：

1、遍历第一个tnode，if语句因tn->pos-pos的等于零成立。遍历trie树第一个tnode。

tkey_extract_bits提取key（192.168.0.11）的pos位置开始的bits位的值，这里就是1。tnode_get_child_rcu转变成tnode_get_child_rcu(tn,1)，这个函数获得tnode的child成员，这里就是child[1],

2、再一次遍历tnode的第二个节点。这个tn->pos是25，tn->bits是1。971行的pos将变成26，这就意味着从第26个bit开始比较。然后比较的bits数是1。这时得到是child[0]，参考图12.2.4，该节点挂载的是192.168.0.10,。

3、该函数返回以后会，外部函数会将这个child指向的leaf节点，变成指向一个tnode节点，tnode的孩子节点分别指向192.168.0.10和192.168.0.11。

1312行是核心的插入操作，为了使这一过程更具代表性，这里结合图12.2.4以插入192.168.0.100为例进行源码分析，在插入192.168.0.100之前的状态见图12.2.3，只存在key等于10.12.39.0的tnode，和child[0]指向key等于10.12.39.0的leaf和child[1]指向key值等于192.168.0.10的leaf节点。在插入192.168.0.100时，fib_inset_node d的参数意义如下：

1、t指向key等于10.12.39.0的tnode；

2、key是需要插入的目的IP 192.168.0.100

3、plen是前缀长度，这里是32。

1023 static struct list_head *fib_insert_node(struct trie *t, u32 key, int plen)
1024 {
1025     int pos, newpos;
1026     struct tnode *tp = NULL, *tn = NULL;
1027     struct rt_trie_node *n;
1028     struct leaf *l;
1029     int missbit;
1030     struct list_head *fa_head = NULL;
1031     struct leaf_info *li;
1032     t_key cindex;
1033
1034     pos = 0;
//rcu类型变量引用。
1035     n = rtnl_dereference(t->trie);
//由于t->trie是key等于10.12.39.0的tnode，所以这个while的语句判断第一次是满足的。
1055     while (n != NULL &&  NODE_TYPE(n) == T_TNODE) {
//从类型rt_trie_node到tnode强制类型转换，内核常用技巧
1056         tn = (struct tnode *) n;
//tnode验证，tnode ！= NULL，并且该tnode的pos和bits成员之和需要小于32。
1058         check_tnode(tn);
//下面这段代码和fib_find_node一样。
1060         if (tkey_sub_equals(tn->key, pos, tn->pos-pos, key)) {
1061             tp = tn; //图12.2.4中的copy来自这行代码。
1062             pos = tn->pos + tn->bits; //获得比较的起始位置
//返回tnode下合适的孩子，这个孩子可能是tnode也可能是leaf，对于这里情况返回192.168.0.10 leaf。
1063             n = tnode_get_child(tn,
1064                         tkey_extract_bits(key, //根据传递进来的key，查tnode处不同的bits。
1065                                   tn->pos,
1066                                   tn->bits));
1067
1068             BUG_ON(n && node_parent(n) != tn);
1069         } else
1070             break;
1071     }
1072
//这里两个条件满足，但是第三个条件不满足，实际上如果第三个条件满足，这就说明该路由项已经在该路由表中了，没有必
//要再次添加该路由项。
1083     if (n != NULL && IS_LEAF(n) && tkey_equals(key, n->key)) {
1084         l = (struct leaf *) n;
1085         li = leaf_info_new(plen);
1086
1087         if (!li)
1088             return NULL;
//将leaf串接成一个链表，leaf_info结构体的falh成员完成这一工作。
1090         fa_head = &li->falh;
1091         insert_leaf_info(&l->list, li);
1092         goto done;
1093     }
//如果1083行if语句不满足，说明路由表中不存在这么一项，创建一个新的leaf，该leaf用于插入项的索引。
1094     l = leaf_new();
//申请内存失败处理
1096     if (!l)
1097         return NULL;
//这里将192,168.0.100作为key值传递给leaf，并根据前缀长度创建一个记录leaf信息的li（leaf_info结构体）
1099     l->key = key;
1100     li = leaf_info_new(plen);
//记录leaf信息的结构体内存申请失败的处理。
1102     if (!li) {
1103         free_leaf(l);
1104         return NULL;
1105     }
//将leaf_info和leaf建立关系，即将leaf_info的falh成员指向leaf的list。
1107     fa_head = &li->falh;
1108     insert_leaf_info(&l->list, li);
//上面已经看到n显然不等于NULL。
1110     if (t->trie && n == NULL) {
1111         /* Case 2: n is NULL, and will just insert a new leaf */
1112
1113         node_set_parent((struct rt_trie_node *)l, tp);
1114
1115         cindex = tkey_extract_bits(key, tp->pos, tp->bits);
1116         put_child(tp, cindex, (struct rt_trie_node *)l);
1117     } else {
//tp在前面得到赋值(copy)，tp->pos+tp->bits将等于1，这就意味着key等于192.168.0.100的插入项从第一个比特开始比较。
1124         if (tp)
1125             pos = tp->pos+tp->bits;
1126         else
1127             pos = 0;
1128
1129         if (n) {
/***************************************************************************************************************
265 static inline int tkey_mismatch(t_key a, int offset, t_key b)266 {267     t_key diff = a ^ b;268     int i = offset;269 270     if (!diff)271         return 0;272     while ((diff << i) >> (KEYLENGTH-1) == 0)273         i++;274     return i;275 }
///key:c0a80064,pos:1,n->key:0a0c2700
将这三个参数带入上面的函数，KEYLENGTH值是32，可得25，源于192.168.0.100和192.168.0.10二进制不同的起始比特
**************************************************************************************************************/
1130             newpos = tkey_mismatch(key, pos, n->key);
//根据n->key和newpos创建一个tnode，这对应于图12.2.4中的key等于192.168.0.10的tnode。
1131             tn = tnode_new(n->key, newpos, 1);
1132         } else {
//首次需要创建tnode的情况，这是一个特殊情况，一个路由表，只会调用一次这里的函数。
1133             newpos = 0;
1134             tn = tnode_new(key, newpos, 1); /* First tnode */
1135         }
//tn创建失败的处理
1137         if (!tn) {
1138             free_leaf_info(li);
1139             free_leaf(l);
1140             return NULL;
1141         }
//这个函数就是设置这里创建的tn（tree node）的父节点。注意看图12.2.4中的ADD开始字符串，这里的赋值使用就是ADD
//冒号后字符串,实际上是地址，注意图中它们的赋值关系。
1143         node_set_parent((struct rt_trie_node *)tn, tp);
//从第25个比特比起，它们不同的第一个比特是1，
1145         missbit = tkey_extract_bits(key, newpos, 1);
//在tnode的child[1]，插入key值等于192.168.0.100的leaf。见12.3.4小节。
//在tnode的child[0]，插入key值等于192.168.0.10的leaf。
1146         put_child(tn, missbit, (struct rt_trie_node *)l);
1147         put_child(tn, 1-missbit, n);
//1061行，如果有copy，那么需要跟新原来tnode的child，其child[1]变成了一个具有两个leaf的tnode。
1149         if (tp) {
//这里找到tnode插入的起始位置。
1150             cindex = tkey_extract_bits(key, tp->pos, tp->bits);
//put_child为插入操作。
1151             put_child(tp, cindex, (struct rt_trie_node *)tn);
1152         } else {
1153             rcu_assign_pointer(t->trie, (struct rt_trie_node *)tn);
1154             tp = tn;
1155         }
1156     }
//设置后的参数合理性检查，温和的使用了warn。
1158     if (tp && tp->pos + tp->bits > 32)
1159         pr_warn("fib_trie tp=%p pos=%d, bits=%d, key=%0x plen=%d\n",
1160             tp, tp->pos, tp->bits, key, plen);
1161
1162     /* Rebalance the trie */
//提到过好多次的rebalance操作。图12.3.2中黄色的列，bits值在前面的操作都是一个比特，在rebalance中可能会变成多个
//比特。
1164     trie_rebalance(t, tp);
1165 done:
1166     return fa_head;
1167 }

后面是发送一个消息，网卡接收到消息后，执行函数fib_netdev_event()函数，这个函数会再次调用fib_inetaddr_event，这个函数这次会按顺序添加子网号全1、全0以及主机号为全1（10.12.39.255广播地址，10.12.39.221也是要接收发往这个地址的数据的）。其过程和上面的类似，插入的节点hash值也是相同的（图中表ifconfig的数组索引）。

图12.3.3由ifconfig引发的前三次路由表更新过程

12.3.4 put_child

12.3.3小节可以知道核心的插入函数时put_child，所以这里单独一个小节来看一下插入的过程是如何完成的。这节的情况还是继续12.3.3小节。但是只打算分析1164行，其它的读者自行完成。

475 static inline int tnode_full(const struct tnode *tn, const struct rt_trie_node *n)476 {
//对于NULL和leaf情况，返回值一定是0，用于更新full_children计数器。477     if (n == NULL || IS_LEAF(n))478         return 0;
//对于tnode情况的判断方法。
480     return ((struct tnode *) n)->pos == tn->pos + tn->bits;481 }
483 static inline void put_child(struct tnode *tn, int i,484                  struct rt_trie_node *n)485 {486     tnode_put_child_reorg(tn, i, n, -1);487 }488 489  /*490   * Add a child at position i overwriting the old value.491   * Update the value of full_children and empty_children.492   */493 494 static void tnode_put_child_reorg(struct tnode *tn, int i, struct rt_trie_node *n,495                   int wasfull)496 {497     struct rt_trie_node *chi = rtnl_dereference(tn->child[i]);498     int isfull;499
//传递进来的n非空，chi这是还没有获得有效值，所以会执行505行的else语句。对于插入操作，基本都是对
//empty_children减一操作502     /* update emptyChildren */503     if (n == NULL && chi != NULL)504         tn->empty_children++;505     else if (n != NULL && chi == NULL)506         tn->empty_children--;507
//对于添加路由项，传递进来的值都是-1509     if (wasfull == -1)510         wasfull = tnode_full(tn, chi);511 512     isfull = tnode_full(tn, n);513     if (wasfull && !isfull)514         tn->full_children--;515     else if (!wasfull && isfull)516         tn->full_children++;517
/*******************************************************************************************************
最低一个bit设置node的类型，要么tnode，要么leaf，高位存放地址（ADD）
208 static inline void node_set_parent(struct rt_trie_node *node, struct tnode *ptr)209 {210     smp_wmb();211     node->parent = (unsigned long)ptr | NODE_TYPE(node);212 }
********************************************************************************************************/518     if (n)519         node_set_parent(n, tn);520
//添加的操作实际上非常的简单，就是一个rcu变量的赋值，将tnode的child成员赋值成适当的值就好了。521     rcu_assign_pointer(tn->child[i], n);
522 }

483参数：

tn是key值为0a0c2700的tnode，

i值是1

l是key等于192.168.0.100的leaf，（先前已经创建并初始化好了）。

该函数调用了，486 tnode_put_child_reorg，完成添加工作。

479行原来tnode的child[1]是指向key值等于192.168.0.10的leaf。

502~506跟新孩子计数器。

509行，判断chi是否“满”，由于这里的chi是键值为192.168.0.10的leaf，所以其返回值是0，

512行，判断插入leaf，192.168.0.100是否满，显然返回值是0。

12.4 route添加路由项

路由这章的介绍和前面的章节分开，从工具说起，在Linux下经常使用route工具配置路由项和网关。下面的这段代码来自配置网关的用户空间程序的代码片段，从这个函数可以看出，创建一个套接字，并调用ioctl方法完成网关的设置。

memcpy(ifr.ifr_name, interface_name, sizeof(ifr.ifr_name)); (void)ioctl(sockfd, SIOGIFINDEX, &ifr); v4_rt.rtmsg_ifindex = ifr.ifr_ifindex; memcpy(&v4_rt.rtmsg_gateway, gateway, sizeof(struct in_addr)); /*添加路由*/if (ioctl(sockfd, SIOCADDRT, &v4_rt) < 0) {SAFE_CLOSE(sockfd); BASEFUN_DBG(RT_ERROR, "add route ioctl error and errno=%d\n", errno); return -1; }  SAFE_CLOSE(sockfd);

这个ioctl函数对应到内核下最终的路由配置函数是ip_rt_ioctl，该函数位于net/ipv4/fib_front.c文件。Linux源码中路由的表示结构体是fib*，FIB（forward information base），所以后面会出现好多以fib开始的程序片段。

480 int ip_rt_ioctl(struct net *net, unsigned int cmd, void __user *arg)481 {482     struct fib_config cfg;483     struct rtentry rt;484     int err;485 486     switch (cmd) {487     case SIOCADDRT:     /* Add a route */488     case SIOCDELRT:     /* Delete a route */489         if (!ns_capable(net->user_ns, CAP_NET_ADMIN))490             return -EPERM;491 492         if (copy_from_user(&rt, arg, sizeof(rt)))493             return -EFAULT;494 495         rtnl_lock();496         err = rtentry_to_fib_config(net, cmd, &rt, &cfg);497         if (err == 0) {498             struct fib_table *tb;499 500             if (cmd == SIOCDELRT) {501                 tb = fib_get_table(net, cfg.fc_table);502                 if (tb)503                     err = fib_table_delete(tb, &cfg);504                 else505                     err = -ESRCH;506             } else {507                 tb = fib_new_table(net, cfg.fc_table);508                 if (tb)509                     err = fib_table_insert(tb, &cfg);510                 else511                     err = -ENOBUFS;512             }513 514             /* allocated by rtentry_to_fib_config() */515             kfree(cfg.fc_mx);516         }517         rtnl_unlock();518         return err;519     }520     return -EINVAL;521 }

根据cmd参数SIOCADDRT可以跟踪到switch内执行的程序代码段，496行rtentry_to_fib_config用于将用户空间的路由配置信息转变到内核记录配置信息的结构体cfg中，在图12.4.2中等号右边的信息就是来自用户空间的配置信息。

图12.4.1是使用route命令添加了一个路由项、一个网关和导出路由项，内核下保存配置信息的成员cfg是struct fib_config类型的一个结构体，该结构体的成员值在图12.4.1中列了出来。

include/net/ip_fib.h

26 struct fib_config {27     u8          fc_dst_len;28     u8          fc_tos;29     u8          fc_protocol;30     u8          fc_scope;31     u8          fc_type;32     /* 3 bytes unused */33     u32         fc_table;34     __be32          fc_dst;35     __be32          fc_gw;36     int         fc_oif;37     u32         fc_flags;38     u32         fc_priority;39     __be32          fc_prefsrc;40     struct nlattr       *fc_mx;41     struct rtnexthop    *fc_mp;42     int         fc_mx_len;43     int         fc_mp_len;44     u32         fc_flow;45     u32         fc_nlflags;46     struct nl_info      fc_nlinfo;47  };

图12.4.1 route命令配置路由信息

根据上面信息，将各项内容表述在如下图形中：

图12.4.2 cfg信息

由于应用空间传递的命令是SIOCADDRT（代码片段一），所以执行507~511行的代码。fib_new_table用于获得一个和用户匹配类型的路由表，如果在现有的路由表中没有要找的类型，则会创建这个类型的路由表。

 75 struct fib_table *fib_new_table(struct net *net, u32 id)76 {77     struct fib_table *tb;78     unsigned int h;79 80     if (id == 0)81         id = RT_TABLE_MAIN;82     tb = fib_get_table(net, id);83     if (tb)84         return tb;85 86     tb = fib_trie_table(id);87     if (!tb)88         return NULL;89 90     switch (id) {91     case RT_TABLE_LOCAL:92         net->ipv4.fib_local = tb;93         break;94 95     case RT_TABLE_MAIN:96         net->ipv4.fib_main = tb;97         break;98 99     case RT_TABLE_DEFAULT:100         net->ipv4.fib_default = tb;101         break;102 103     default:104         break;105     }106 107     h = id & (FIB_TABLE_HASHSZ - 1);108     hlist_add_head_rcu(&tb->tb_hlist, &net->ipv4.fib_table_hash[h]);109     return tb;110 }
112 struct fib_table *fib_get_table(struct net *net, u32 id)113 {114     struct fib_table *tb;115     struct hlist_head *head;116     unsigned int h;117 118     if (id == 0)119         id = RT_TABLE_MAIN;120     h = id & (FIB_TABLE_HASHSZ - 1);121 122     rcu_read_lock();123     head = &net->ipv4.fib_table_hash[h];124     hlist_for_each_entry_rcu(tb, head, tb_hlist) {125         if (tb->tb_id == id) {126             rcu_read_unlock();127             return tb;128         }129     }130     rcu_read_unlock();131     return NULL;132 }

82行fib_get_table用户查找现有的路由表，路由表的类型定义在include/uapi/linux/rtnetlink.h文件中：

enum rt_class_t {RT_TABLE_UNSPEC=0,
/* User defined values */RT_TABLE_COMPAT=252,RT_TABLE_DEFAULT=253,RT_TABLE_MAIN=254,RT_TABLE_LOCAL=255,RT_TABLE_MAX=0xFFFFFFFF
};

虽然这里最大路由项的定义值是RT_TABLE_MAX，但是其实在不启动等价路由【Equal-cost multi-path routing(ECMP)（CONFIG_IP_ROUTE_MULTIPATH）】时，配置CONFIG_IP_MULTIPLE_TABLES时有256张路由表。启用等价路由时只会有两张路由表，在存在多条网络路径的网络节点会配置使能。

图12.4.3的路由表拓扑结构中， net代表了一个网络命名空间，其指针成员ipv4指向inet协议字段，ipv4的fib_table_hash是一个数组，其指向是哈希链表，该表表映射的就是具体路由表的类型，路由表的类型从0开始一直到255，图中第一行的RT_TABLE_DEFAULT就等于253依次类推，所以在查找路由表时，只需要记得你找的是MAIN表还是LOCAL，而不需要关心是254还是255之类的数值了，这很类似于域名概念。每一个路由表由struct fib_table类型表示。命名空间中的哈希字段指向具体路由表的tb_list字段，并且处在同一个类型的路由表之间也是通过这个字段联系在一起的。

图12.4.3路由表拓扑

fc_table项指示的选择哪一张表插入用户配置的路由项，fib_new_table的82行fib_get_table根据路由表的id(根据图12.1.2其传递进来的值等于0)字段查询指定类型的路由表。81行将id赋值为RT_TABLE_MAIN。

120行得到h等于 RT_TABLE_MAIN。

将123行结合图12.1.3就可以看出其找到main表。

124~128根据路由表的tb_list字段遍历路由表，寻找路由表的tb_id等于RT_TABLE_MAIN的表。找到就返回该表，没找到就返回NULL，让其创建该表项。

83~84，如果fib_get_table找到了指定的表，则就是向这个表插入一个路由项，如果没有找到，说明需要创建一个这个表，接着向下86行即用于创建一个表。创建路由表的函数位于fib_trie.c文件，在2.6.38及以前Linux默认使用的是hash方法管理路由表和路由项，到Linux3.10，内核默认使用LC-trie方法，中文里常把这个算法称为字典或者单词查找树，路由使用的关于单词查找树的代码都在fib_trie.c。这个算法在分析代码时遇到了再说。

net/ipv4/fib_trie.c

1970 struct fib_table *fib_trie_table(u32 id)
1971 {
1972     struct fib_table *tb;
1973     struct trie *t;
1974
1975     tb = kmalloc(sizeof(struct fib_table) + sizeof(struct trie),
1976              GFP_KERNEL);
1977     if (tb == NULL)
1978         return NULL;
1979
1980     tb->tb_id = id;
1981     tb->tb_default = -1;
1982     tb->tb_num_default = 0;
1983
1984     t = (struct trie *) tb->tb_data;
1985     memset(t, 0, sizeof(*t));
1986
1987     return tb;
1988 }

1975行创建一个路由表，路由表的定义如下，这里的内存申请将零长数组tb_data初始化为struct trie成员。1980~1985初始化该路由表的各个字段。

struct fib_table {struct hlist_node tb_hlist;u32            tb_id;int           tb_default;int          tb_num_default;unsigned long        tb_data[0];
};

fib_new_table的90~105行将网络命名空间的fib_main字段指向这里创建的MAIN表。108行再将MAIN表放到数组fib_table_hash里，以便后续的索引。

再回退到ip_rt_ioctl的509行，fib_table_insert用于向路由表中插入一个路由项了。可以知道插入操作是基于trie方法的。其插入文件位于net/ipv4/fib_trie.c文件。这个函数有点长，但是还是要一行一行的过。

其参数是上面找到的或者创建的路由表，配置项就是前面用户空间配置的信息，该信息见图12.4.2。

12.6 路由查找

在12.2和12.3节，主要关注的是trie树的构建和管理，并不涉及路由查找的内容，由于管理和维护一个trie树本身是一件复杂的事，所以内核没有将查找路由表需要的信息也放在trie树中存储，而是使用了其它的一些数据结构来辅助查找过程，这节先引入这些数据结构，然后剖析查找过程，查找的总体思想是首先检查参数的合法性，查找trie（tnode ，leaf）树，trie树本身存储的是key值，没有其它 过多的信息，这些信息包括tos，也即流控，所以需要查找一些辅助数据结构，查找到了以后，如果对应的路由项没有缓存，会创建一个路由缓存。

12.6.1 相关数据结构

本节所述的数据结构指的是辅助数据结构，并没有将使用到的trie树相关数据结构罗列出来。关于这几个数据结构间的关系见图12.3.3。

fib_result

fib_result用于存放路由查找的结果

include/net/ip_fib.h

struct fib_result {
unsigned char   prefixlen; //前缀长度
unsigned char   nh_sel; //nexthop 索引
unsigned char   type; //type和scope是类型和范围
unsigned char   scope;
u32     tclassid;
struct fib_info *fi; //路由项对应的信息
struct fib_table *table; //该结果源于的表项
struct list_head *fa_head; //fib alias链表指针。
};

fib_info

struct fib_info {struct hlist_node    fib_hash; //fib_info信息索引，局部全局数组fib_info_hash使用struct hlist_node  fib_lhash;//同样是局部全局数组fib_info_laddrhash索引struct net     *fib_net;//对应设备所在网络命名空间中的一些信息。int           fib_treeref;//trie树引用计数atomic_t     fib_clntref;unsigned int        fib_flags;
//标记该fib_info是否可用，当值是1时，标志该路由项失效，查找时将不会参考该值。unsigned char      fib_dead;
unsigned char       fib_protocol; //支持的协议unsigned char      fib_scope; //范围unsigned char        fib_type;//类型__be32         fib_prefsrc; //前缀u32            fib_priority; //优先级u32          *fib_metrics; //metrics相关内容
#define fib_mtu fib_metrics[RTAX_MTU-1]
#define fib_window fib_metrics[RTAX_WINDOW-1]
#define fib_rtt fib_metrics[RTAX_RTT-1]
#define fib_advmss fib_metrics[RTAX_ADVMSS-1]int            fib_nhs; //记录fib_nh[0]零长数组具有的下一跳的个数。
#ifdef CONFIG_IP_ROUTE_MULTIPATHint         fib_power;
#endifstruct rcu_head       rcu;struct fib_nh       fib_nh[0];
#define fib_dev     fib_nh[0].nh_dev
};

该数据结构元素的初始化实例可以参考图12.3.3，图中的fi、fi-2、fi-3分别对应于三种路由项情况。

fib_alias

虽然套接字数据包路由项key可能不同，例如路由到192.168.0.10和路由到192.168.0.100的两项，但是不同套接字数据包的type或者tos是相同的，对于一个大规模的路由而言，的类型不同套接字数据包的type和tos相同的概率还是比较大的，为了节约空间和时间，就将这些字段抽象出来了，tos和type组合的类型有限，这样可以使这个有限的组合应对无限多路由项。fa_list用于串接所有的fib_alias类型的结构体，以便于管理fa_alias结构体。

struct fib_alias {struct list_head   fa_list;struct fib_info     *fa_info; //见上u8            fa_tos;u8           fa_type;// UNICAST、LOCAL、BROADCASTu8            fa_state;struct rcu_head        rcu;
};

fib_flowi4

该数据结构在图12.3.3中并未显示出来，路由查找过程中会使用到该数据结构，该数据结构根据输入输出网络设备、ip层和tcp层一些字段对流量进行分类。flowi4（flow inet 4）是Internet 4协议的流控之意。对应的还有flowi6的流控，其实该结构体就是对flowi_common的封装，这么做的好处是不言而喻的，提高代码复用率的同时增加了代码维护的灵活性。

struct flowi4 {struct flowi_common   __fl_common;
#define flowi4_oif      __fl_common.flowic_oif //output Interface
#define flowi4_iif      __fl_common.flowic_iif //input interface
#define flowi4_mark     __fl_common.flowic_mark
#define flowi4_tos      __fl_common.flowic_tos
#define flowi4_scope        __fl_common.flowic_scope
#define flowi4_proto        __fl_common.flowic_proto
#define flowi4_flags        __fl_common.flowic_flags
#define flowi4_secid        __fl_common.flowic_secid/* (saddr,daddr) must be grouped, same order as in IP header */__be32           saddr; //源地址__be32          daddr;//目的地址union flowi_uli     uli;
#define fl4_sport       uli.ports.sport //tcp层源端口号
#define fl4_dport       uli.ports.dport//tcp层目的端口号
#define fl4_icmp_type       uli.icmpt.type
#define fl4_icmp_code       uli.icmpt.code
#define fl4_ipsec_spi       uli.spi
#define fl4_mh_type     uli.mht.type
#define fl4_gre_key     uli.gre_key
} __attribute__((__aligned__(BITS_PER_LONG/8)));

fib_ common

struct flowi_common {int    flowic_oif;int  flowic_iif;__u32    flowic_mark;__u8    flowic_tos;__u8 flowic_scope;__u8   flowic_proto;__u8   flowic_flags;
#define FLOWI_FLAG_ANYSRC       0x01
#define FLOWI_FLAG_CAN_SLEEP        0x02
#define FLOWI_FLAG_KNOWN_NH     0x04__u32   flowic_secid;
};

rtable

套接字将会绑定该结构体。

struct rtable {struct dst_entry  dst;int         rt_genid;unsigned int       rt_flags;__u16          rt_type;__u8            rt_is_input;__u8            rt_uses_gateway;int         rt_iif;/* Info on neighbour */__be32            rt_gateway;/* Miscellaneous cached information */u32            rt_pmtu;struct list_head    rt_uncached;
};

dst_entry

struct dst_entry {struct rcu_head       rcu_head;struct dst_entry   *child;struct net_device       *dev;struct  dst_ops         *ops;unsigned long      _metrics;unsigned long           expires;struct dst_entry   *path;struct dst_entry  *from;
#ifdef CONFIG_XFRMstruct xfrm_state *xfrm;
#elsevoid           *__pad1;
#endifint           (*input)(struct sk_buff *);int          (*output)(struct sk_buff *);unsigned short      flags;
#define DST_HOST        0x0001
#define DST_NOXFRM      0x0002
#define DST_NOPOLICY        0x0004
#define DST_NOHASH      0x0008
#define DST_NOCACHE     0x0010
#define DST_NOCOUNT     0x0020
#define DST_NOPEER      0x0040
#define DST_FAKE_RTABLE     0x0080
#define DST_XFRM_TUNNEL     0x0100
#define DST_XFRM_QUEUE      0x0200unsigned short        pending_confirm;short           error;/* A non-zero value of dst->obsolete forces by-hand validation* of the route entry.  Positive values are set by the generic* dst layer to indicate that the entry has been forcefully* destroyed.** Negative values are used by the implementation layer code to* force invocation of the dst_ops->check() method.*/short           obsolete;
#define DST_OBSOLETE_NONE   0
#define DST_OBSOLETE_DEAD   2
#define DST_OBSOLETE_FORCE_CHK  -1
#define DST_OBSOLETE_KILL   -2unsigned short        header_len; /* more space at head required */unsigned short     trailer_len;    /* space to reserve at tail */
#ifdef CONFIG_IP_ROUTE_CLASSID__u32         tclassid;
#else__u32          __pad2;
#endif/** Align __refcnt to a 64 bytes alignment* (L1_CACHE_SIZE would be too much)*/
#ifdef CONFIG_64BITlong         __pad_to_align_refcnt[2];
#endif/** __refcnt wants to be on a different cache line from* input/output/ops or performance tanks badly*/atomic_t        __refcnt;   /* client references    */int           __use;unsigned long     lastuse;union {struct dst_entry *next;struct rtable __rcu   *rt_next;struct rt6_info        *rt6_next;struct dn_route __rcu *dn_next;};
};

12.6.2 接收包路由项查找

在ip_input.c文件中，ip_rcv_finish()函数用于处理接收到的数据包，这里将重心倾向于路由这块。 skb中没有找到路由项，即缓存中寻找路由项失败，需要调用ip_route_input_noref到路由表中查找，如果是回环包，则skb的路由缓存有路由项，即路由cache命中。

*多播地址寻找路由项函数：ip_route_input_mc

*单播地址寻找路由项函数：ip_route_input_slow

314 static int ip_rcv_finish(struct sk_buff *skb)
315 {
//根据套接字获得ip头
316         const struct iphdr *iph = ip_hdr(skb);
317         struct rtable *rt;
/ sysctl_ip_early_demux 是二进制值，该值用于对发往本地数据包的优化。当前仅对建立连接的套接字起作用。
319         if (sysctl_ip_early_demux && !skb_dst(skb)) {
320                 const struct net_protocol *ipprot;
321                 int protocol = iph->protocol;
322
323                 ipprot = rcu_dereference(inet_protos[protocol]);
324                 if (ipprot && ipprot->early_demux) {
325                         ipprot->early_demux(skb);
326                         /* must reload iph, skb->head might have changed */
327                         iph = ip_hdr(skb);
328                 }
329         }
330
//如果套接字的dst字段没有指向一个路由项，如果没有则调用ip_route_input_noref进行查找。
335         if (!skb_dst(skb)) {
336                 int err = ip_route_input_noref(skb, iph->daddr, iph->saddr,
337                                                iph->tos, skb->dev);
338                 if (unlikely(err)) {
339                         if (err == -EXDEV)
//更新基于tcp/ip因特网的MIB（management information base）信息，RFC1213
340                                 NET_INC_STATS_BH(dev_net(skb->dev),
341                                                  LINUX_MIB_IPRPFILTER);
342                         goto drop;
343                 }
344         }
345
//对套接字可选字段的处理。ip_rcv_options(skb)会调用ip_options_rcv_srr(skb)
357         if (iph->ihl > 5 && ip_rcv_options(skb))
358                 goto drop;
//获得路由表
360         rt = skb_rtable(skb);
//多播和广播时的信息传递。
361         if (rt->rt_type == RTN_MULTICAST) {
362                 IP_UPD_PO_STATS_BH(dev_net(rt->dst.dev), IPSTATS_MIB_INMCAST,
363                                 skb->len);
364         } else if (rt->rt_type == RTN_BROADCAST)
365                 IP_UPD_PO_STATS_BH(dev_net(rt->dst.dev), IPSTATS_MIB_INBCAST,
366                                 skb->len);
/*向tcp层传递packet*/
368         return dst_input(skb);
373 }

336行ip_route_input_noref对于tcp/ip接收数据包进行路由寻址。

net/ipv4/route.c
/*参数的意义
skb：传递进来的skb_buff，
dst：目的地址
src： 源地址
tos：type of service，ip头中的服务类型
devin：网卡设备
*/
int ip_route_input_noref(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1763                          u8 tos, struct net_device *dev)
1764 {
1765         int res;
1766
1767         rcu_read_lock();
1768
//多播的处理
1780         if (ipv4_is_multicast(daddr)) {
1781                 struct in_device *in_dev = __in_dev_get_rcu(dev);
1782
1783                 if (in_dev) {
1784                         int our = ip_check_mc_rcu(in_dev, daddr, saddr,
1785                                                   ip_hdr(skb)->protocol);
1786                         if (our
1792                            ) {
1793                                 int res = ip_route_input_mc(skb, daddr, saddr,
1794                                                             tos, dev, our);
1795                                 rcu_read_unlock();
1796                                 return res;
1797                         }
1798                 }
1799                 rcu_read_unlock();
1800                 return -EINVAL;
1801         }
//除多播以外情况的处理。
1802         res = ip_route_input_slow(skb, daddr, saddr, tos, dev);
1803         rcu_read_unlock();
1804         return res;
1805 }

1793行是多播地址寻找路由项函数ip_route_input_mc。

1373 static int ip_route_input_mc(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1374                                 u8 tos, struct net_device *dev, int our)
1375 {
/申请并初始化dst_entry，由于rtable的第一个成员就是dst_entry，多以这里直接进行赋值，没有使用策略路由
1403         rth = rt_dst_alloc(dev_net(dev)->loopback_dev,
1404                            IN_DEV_CONF_GET(in_dev, NOPOLICY), false, false);
1405         if (!rth)
1406                 goto e_nobufs;
1407
//初始化rtable字段的其它项。
1411         rth->dst.output = ip_rt_bug;
1412
1413         rth->rt_genid   = rt_genid(dev_net(dev));
1414         rth->rt_flags   = RTCF_MULTICAST;
1415         rth->rt_type    = RTN_MULTICAST;
1416         rth->rt_is_input= 1;
1417         rth->rt_iif     = 0;
1418         rth->rt_pmtu    = 0;
1419         rth->rt_gateway = 0;
1420         rth->rt_uses_gateway = 0;
1421         INIT_LIST_HEAD(&rth->rt_uncached);
1422         if (our) {
1423                 rth->dst.input= ip_local_deliver;
1424                 rth->rt_flags |= RTCF_LOCAL;
1425         }
//将rtable的dst成员地址赋值给skb。
1433         skb_dst_set(skb, &rth->dst);
1434         return 0;
1442 }

ip_route_input_noref根据传递进来的目的地址判断是多播还是单播，多播使用ip_route_input_mc(skb, daddr,saddr, tos, dev, our)处理，单播使用 ip_route_input_slow(skb, daddr, saddr,tos, dev)。为了使函数的脉络看起来更为清晰，这里省去函数变量的定义、路由地址的合法性检查以及一些错误处理代码，只保留了正常情况下路由处理相关代码。

1585 static int ip_route_input_slow(struct sk_buff *skb, __be32 daddr, __be32 saddr,
1586                                u8 tos, struct net_device *dev)
1587 {
//上面之所以要检查源和目的地址，是因为路由会使用该信息。
//流量分类信息初始化，也是流控
1637         fl4.flowi4_oif = 0;
1638         fl4.flowi4_iif = dev->ifindex;
1639         fl4.flowi4_mark = skb->mark;
1640         fl4.flowi4_tos = tos;
1641         fl4.flowi4_scope = RT_SCOPE_UNIVERSE;
1642         fl4.daddr = daddr;
1643         fl4.saddr = saddr;
//路由查找路由查找的结果存放在res（results）里。
1644         err = fib_lookup(net, &fl4, &res);
1645         if (err != 0)
1646                 goto no_route;
//根据路由查找结果，创建一个路由缓存项。
1667         err = ip_mkroute_input(skb, &res, &fl4, in_dev, daddr, saddr, tos);
1668 out:    return err;
1669
1760 }

1644行路由查找函数

include/net/ip_fib.h
219 static inline int fib_lookup(struct net *net, const struct flowi4 *flp,
220                              struct fib_result *res)
221 {
222         struct fib_table *table;
//获得id等于LOCAL的路由，见12.3节。并查找其中的路由项， 查找过程见后面。
224         table = fib_get_table(net, RT_TABLE_LOCAL);
225         if (!fib_table_lookup(table, flp, res, FIB_LOOKUP_NOREF))
226                 return 0;
//获得id等于MAIN的路由，见12.3节。并查找其中的路由项， 查找过程见后面。
228         table = fib_get_table(net, RT_TABLE_MAIN);
229         if (!fib_table_lookup(table, flp, res, FIB_LOOKUP_NOREF))
230                 return 0;
231         return -ENETUNREACH;
232 }

225行和229行的函数和12.3节提到的大多数函数一样，也位于fib_trie.c函数里。它是路由查找的核心函数，由于这个函数有些部分直接或者间接在12.3节有过叙述，该函数看起来也稍微容易些。这个函数先查找tnode然后查找leaf，查询的结果

1405 int fib_table_lookup(struct fib_table *tb, const struct flowi4 *flp,
1406                      struct fib_result *res, int fib_flags)
1407 {
1408         struct trie *t = (struct trie *) tb->tb_data;
1409         int ret;
1410         struct rt_trie_node *n;
1411         struct tnode *pn;
1412         unsigned int pos, bits;
1413         t_key key = ntohl(flp->daddr);
1414         unsigned int chopped_off;
1415         t_key cindex = 0;
1416         unsigned int current_prefix_length = KEYLENGTH;
1417         struct tnode *cn;
1418         t_key pref_mismatch;
1419
1420         rcu_read_lock();
1421
1422         n = rcu_dereference(t->trie);
1423         if (!n)
1424                 goto failed;
//首先查看fib_table指向的是否仅仅是leaf，而没有tnode，对于fib_table只有一个leaf的情况下，直接调用check_leaf进行
//验证
1430         /* Just a leaf? */
1431         if (IS_LEAF(n)) {
1432                 ret = check_leaf(tb, t, (struct leaf *)n, key, flp, res, fib_flags);
1433                 goto found;
1434         }
//对于是tnode的情况的处理
1436         pn = (struct tnode *) n;
//该变量用于记录已经匹配到的比特数。
1437         chopped_off = 0;
1438
1439         while (pn) {
1440                 pos = pn->pos;
1441                 bits = pn->bits;
1443                 if (!chopped_off)
//找到不同的bit，这是为了获得孩子节点。
1444                         cindex = tkey_extract_bits(mask_pfx(key, current_prefix_length),
1445                                                    pos, bits);
//获得孩子节点，这个孩子节点可能是tnode也可能是leaf
1447                 n = tnode_get_child_rcu(pn, cindex);
//
1449                 if (n == NULL) {
1453                         goto backtrace;
1454                 }
//如果孩子节点是一个leaf节点，则调用check_leaf检查是否是需要的路由项，并将结果存放在res中。
1456                 if (IS_LEAF(n)) {
1457                         ret = check_leaf(tb, t, (struct leaf *)n, key, flp, res, fib_flags);
1458                         if (ret > 0)
1459                                 goto backtrace;
1460                         goto found;
1461                 }
//如果孩子节点是一个tnode，则需要进行迭代到其孩子进行上述查找过程。
1463                 cn = (struct tnode *)n;
//第一次进入该函数这里的current_prefix_length的长度是不会小于pos+bits的。
1494                 if (current_prefix_length < pos+bits) {
1495                         if (tkey_extract_bits(cn->key, current_prefix_length,
1496                                                 cn->pos - current_prefix_length)
1497                             || !(cn->child[0]))
1498                                 goto backtrace;
1499                 }
1532
1533                 pref_mismatch = mask_pfx(cn->key ^ key, cn->pos);
//当根据pos和bits值没有找到搜索的key的话，进入前缀匹配模式。
/************************************************************************************************
***该模式存在意义如下：
***对于ipv4路由表有如下两项：
***192.168.20.16/28
***192.168.0.0/16
***如果需要查找192.168.20.19则上面两个都是匹配的，但是取哪个好呢？内核使用最常匹配原则，即认为192.168.20.16
***（子网掩码长度是28）这一项是匹配的，通常default 项的前缀是最短的，其作用是在其他路由项均不能匹配时会使用***default项*[摘自维基百科，longest prefix match]，这个函数的chopped_off就是忽略prefix的长度，这样匹配成功的概率会***变大。对于图12.2.4的情况的trie树，查找192.168.0.100路由项的情况是不会进入backtrace标号开始的语句的。
**********************************************************************************************/
1540                 if (pref_mismatch) {
1541                         /* fls(x) = __fls(x) + 1 */
1542                         int mp = KEYLENGTH - __fls(pref_mismatch) - 1;
1543
1544                         if (tkey_extract_bits(cn->key, mp, cn->pos - mp) != 0)
1545                                 goto backtrace;
1546
1547                         if (current_prefix_length >= cn->pos)
1548                                 current_prefix_length = mp;
1549                 }
1550
1551                 pn = (struct tnode *)n; /* Descend */
1552                 chopped_off = 0;
1553                 continue;
1554
1555 backtrace:
1556                 chopped_off++;
1557
1558                 /* As zero don't change the child key (cindex) */
1559                 while ((chopped_off <= pn->bits)
1560                        && !(cindex & (1<<(chopped_off-1))))
1561                         chopped_off++;
1562
1563                 /* Decrease current_... with bits chopped off */
1564                 if (current_prefix_length > pn->pos + pn->bits - chopped_off)
1565                         current_prefix_length = pn->pos + pn->bits
1566                                 - chopped_off;
1567
1568                 /*
1569                  * Either we do the actual chop off according or if we have
1570                  * chopped off all bits in this tnode walk up to our parent.
1571                  */
1572
1573                 if (chopped_off <= pn->bits) {
1574                         cindex &= ~(1 << (chopped_off-1));
1575                 } else {
1576                         struct tnode *parent = node_parent_rcu((struct rt_trie_node *) pn);
1577                         if (!parent)
1578                                 goto failed;
1579
1580                         /* Get Child's index */
1581                         cindex = tkey_extract_bits(pn->key, parent->pos, parent->bits);
1582                         pn = parent;
1583                         chopped_off = 0;
1593 found:
1594         rcu_read_unlock();
1595         return ret;
1596 }

回到ip_route_input_slow的1667行，在没有使用多路路由技术的情况下，只是对__mkroute_input()函数的封装。该函数用于为接收到的套接字数据创建路由项缓存。该函数的第二个参数res是前面查找的结果。

net/ipv4/route.c