【Linux 网络子系统深度拆解】路由子系统深度拆解：FIB、策略路由与路由缓存

struct fib_table {
    struct hlist_node tb_hlist;     /* 哈希链中的节点 */
    u32              tb_id;         /* 表 ID：254=main, 255=local */
    int              tb_num_default;/* 默认路由计数 */
    struct rcu_head  rcu;
    unsigned long    *tb_data;      /* 指向 LC-trie 根节点 */
    unsigned long    __data[];      /* 内联 trie 数据 */
};

struct fib_info {
    struct hlist_node fib_hash;
    struct hlist_node fib_lhash;
    struct list_head  nh_list;
    struct net        *fib_net;
    refcount_t        fib_treeref;     /* trie 引用计数 */
    refcount_t        fib_clntref;     /* 客户端引用计数 */
    unsigned int      fib_flags;       /* RTNH_F_* */
    unsigned char     fib_dead;
    unsigned char     fib_protocol;    /* RTPROT_BOOT/STATIC/BIRD/... */
    unsigned char     fib_scope;       /* RT_SCOPE_UNIVERSE/LINK/HOST */
    unsigned char     fib_type;        /* RTN_UNICAST/LOCAL/BROADCAST/... */
    __be32            fib_prefsrc;     /* 首选源 IP */
    u32               fib_tb_id;       /* 所属表 ID */
    u32               fib_priority;    /* 度量值（metric） */
    struct dst_metrics *fib_metrics;   /* MTU, RTT 等度量 */
    int               fib_nhs;         /* 下一跳数量（ECMP） */
    struct nexthop    *nh;             /* 新式 nexthop 对象 */
    struct fib_nh     fib_nh[] __counted_by(fib_nhs); /* 柔性数组 */
};

struct fib_nh_common {
    struct net_device *nhc_dev;       /* 出接口 */
    int              nhc_oif;         /* 出接口 index */
    unsigned char    nhc_scope;       /* 路由范围 */
    u8               nhc_family;      /* AF_INET / AF_INET6 */
    u8               nhc_gw_family;   /* 网关地址族 */
    unsigned char    nhc_flags;       /* RTNH_F_DEAD/ONLINK/... */
    struct lwtunnel_state *nhc_lwtstate; /* 轻量级隧道状态 */
    union {
        __be32       ipv4;            /* IPv4 网关 */
        struct in6_addr ipv6;         /* IPv6 网关 */
    } nhc_gw;
    int              nhc_weight;      /* ECMP 权重 */
    atomic_t         nhc_upper_bound; /* 加权 ECMP 上界 */

    /* 路由缓存 */
    struct rtable __rcu * __percpu *nhc_pcpu_rth_output; /* per-CPU 输出缓存 */
    struct rtable __rcu           *nhc_rth_input;        /* 输入路由缓存 */
    struct fnhe_hash_bucket __rcu *nhc_exceptions;       /* FNHE 异常表 */
};

struct fib_result {
    __be32           prefix;          /* 匹配的网络前缀 */
    unsigned char    prefixlen;       /* 前缀长度 */
    unsigned char    nh_sel;          /* 选中的下一跳索引（ECMP） */
    unsigned char    type;            /* RTN_UNICAST/LOCAL/... */
    unsigned char    scope;           /* RT_SCOPE_* */
    u32              tclassid;        /* TC 分类 ID */
    dscp_t           dscp;
    struct fib_nh_common *nhc;        /* 选中的下一跳 */
    struct fib_info  *fi;             /* 路由信息 */
    struct fib_table *table;          /* 来源表 */
};

struct fib_rule {
    struct list_head list;
    int              iifindex;       /* 入接口匹配 */
    int              oifindex;       /* 出接口匹配 */
    u32              mark;           /* fwmark 匹配 */
    u32              mark_mask;      /* fwmark 掩码 */
    u32              table;          /* 目标表 ID */
    u8               action;         /* FR_ACT_TO_TBL/BLACKHOLE/... */
    u8               ip_proto;       /* 协议匹配 */
    u32              pref;           /* 优先级（数字越小越先匹配） */
    char             iifname[IFNAMSIZ];
    char             oifname[IFNAMSIZ];
    struct fib_kuid_range       uid_range;    /* UID 范围匹配 */
    struct fib_rule_port_range  sport_range;  /* 源端口范围 */
    struct fib_rule_port_range  dport_range;  /* 目的端口范围 */
};

$ ip rule list
0:      from all lookup local       # 优先级 0：先查 local 表
32766:  from all lookup main        # 优先级 32766：再查 main 表
32767:  from all lookup default     # 优先级 32767：最后查 default 表

/* 快路径：没有自定义规则 */
if (!net->ipv4.fib_has_custom_rules) {
    /* 直接查 local → main，跳过规则遍历 */
    tb = rcu_dereference(net->ipv4.fib_local);
    err = fib_table_lookup(tb, flp, res, flags);
    if (!err) goto out;
    tb = rcu_dereference(net->ipv4.fib_main);
    err = fib_table_lookup(tb, flp, res, flags);
    goto out;
}

/* 慢路径：遍历规则链 */
return __fib_lookup(net, flp, res, flags);
    → fib_rules_lookup(ops, flowi, flags, arg)
        for_each_rule(rule) {
            if (!fib_rule_match(rule, flowi))
                continue;
            switch (rule->action) {
            case FR_ACT_TO_TBL:
                err = fib_table_lookup(table, flp, res, flags);
                break;
            case FR_ACT_BLACKHOLE:
                return -EINVAL;
            ...
            }
        }

# 基于源 IP 选路：来自 10.0.1.0/24 的包走表 100
ip rule add from 10.0.1.0/24 table 100
ip route add default via 10.0.1.1 table 100

# 基于 fwmark 选路：标记为 0x1 的包走表 200
ip rule add fwmark 0x1 table 200
iptables -t mangle -A OUTPUT -p tcp --dport 443 -j MARK --set-mark 0x1

# 基于入接口选路
ip rule add iif eth1 table 300

# 哈希策略：0=L3, 1=L3+L4, 2=L3+L4+inner(隧道), 3=自定义
sysctl net.ipv4.fib_multipath_hash_policy

# 自定义哈希字段（policy=3 时生效）
sysctl net.ipv4.fib_multipath_hash_fields

#define FIB_MULTIPATH_HASH_FIELD_SRC_IP    BIT(0)
#define FIB_MULTIPATH_HASH_FIELD_DST_IP    BIT(1)
#define FIB_MULTIPATH_HASH_FIELD_IP_PROTO  BIT(2)
#define FIB_MULTIPATH_HASH_FIELD_SRC_PORT  BIT(4)
#define FIB_MULTIPATH_HASH_FIELD_DST_PORT  BIT(5)

struct nexthop {
    struct rb_node  rb_node;       /* 红黑树节点（按 ID 查找） */
    struct list_head fi_list;      /* 引用此 NH 的 IPv4 路由列表 */
    struct list_head f6i_list;     /* 引用此 NH 的 IPv6 路由列表 */
    struct net      *net;
    u32              id;           /* 唯一 ID（用户指定） */
    u8               protocol;     /* 管理此 NH 的应用 */
    u8               nh_flags;
    bool             is_group;     /* 是否为组 */
    union {
        struct nh_info __rcu  *nh_info;  /* 单个下一跳 */
        struct nh_group __rcu *nh_grp;   /* 下一跳组 */
    };
};

struct nh_group {
    struct nh_group *spare;        /* 原子替换用 */
    u16              num_nh;       /* 成员数量 */
    bool             is_multipath;
    bool             hash_threshold;  /* 哈希阈值模式 */
    bool             resilient;       /* 弹性哈希组 */
    struct nh_res_table __rcu *res_table;  /* 弹性哈希表 */
    struct nh_grp_entry nh_entries[];      /* 成员列表 */
};

# 创建弹性哈希组
ip nexthop add id 1 via 10.0.0.1 dev eth0
ip nexthop add id 2 via 10.0.0.2 dev eth0
ip nexthop add id 10 group 1/2 type resilient buckets 32

# 添加新成员——只影响 ~1/3 的桶
ip nexthop add id 3 via 10.0.0.3 dev eth0
ip nexthop replace id 10 group 1/2/3 type resilient buckets 32

# 创建 nexthop 对象
ip nexthop add id 100 via 10.0.0.1 dev eth0
ip nexthop add id 101 via 10.0.0.2 dev eth0

# 创建 nexthop 组（ECMP）
ip nexthop add id 200 group 100/101

# 路由引用 nexthop 对象
ip route add 192.168.0.0/24 nhid 200

# 修改下一跳——所有引用它的路由自动更新
ip nexthop replace id 100 via 10.0.0.3 dev eth0

/* 简化的查找逻辑 */
rth = rcu_dereference(*this_cpu_ptr(nhc->nhc_pcpu_rth_output));
if (rt_cache_valid(rth))
    return rth;  /* 命中 per-CPU 缓存 */

/* 未命中：构造新 rtable */
rth = rt_dst_alloc(dev, flags, type, ...);
rcu_assign_pointer(*this_cpu_ptr(nhc->nhc_pcpu_rth_output), rth);

struct fib_nh_exception {
    struct fib_nh_exception __rcu *fnhe_next;   /* 哈希链 */
    __be32           fnhe_daddr;     /* 目的 IP */
    u32              fnhe_pmtu;      /* 缓存的 PMTU */
    bool             fnhe_mtu_locked;/* MTU 锁定标志 */
    __be32           fnhe_gw;        /* 重定向网关 */
    unsigned long    fnhe_expires;   /* 过期时间 */
    struct rtable __rcu *fnhe_rth_input;   /* 输入 rtable */
    struct rtable __rcu *fnhe_rth_output;  /* 输出 rtable */
};

struct dst_entry {
    struct net_device *dev;         /* 出接口 */
    struct dst_ops    *ops;         /* 操作表 */
    unsigned long     _metrics;     /* 度量值 */
    unsigned long     expires;      /* 过期时间 */

    int (*input)(struct sk_buff *);                          /* 收包处理 */
    int (*output)(struct net *, struct sock *, struct sk_buff *); /* 发包处理 */

    unsigned short    flags;
    short             obsolete;
    unsigned short    header_len;   /* 封装头长度 */
    unsigned short    trailer_len;

    rcuref_t          __rcuref;     /* RCU 引用计数 */
    int               __use;        /* 使用计数 */
    unsigned long     lastuse;      /* 最后使用时间 */

    short             error;        /* 错误码 */
};

struct rtable {
    struct dst_entry dst;           /* 基类 */
    int              rt_genid;      /* 代际 ID（路由表变更时递增） */
    unsigned int     rt_flags;      /* RTCF_* 标志 */
    __u16            rt_type;       /* RTN_* */
    __u8             rt_is_input;   /* 1=输入路由, 0=输出路由 */
    __u8             rt_uses_gateway; /* 是否经过网关 */
    int              rt_iif;        /* 入接口 index */
    u8               rt_gw_family;
    union {
        __be32       rt_gw4;        /* IPv4 网关 */
        struct in6_addr rt_gw6;     /* IPv6 网关（IPv4-mapped） */
    };
    u32              rt_mtu_locked:1;
    u32              rt_pmtu:31;    /* 缓存的 PMTU */
};

struct fib6_table {
    struct hlist_node tb6_hlist;
    u32              tb6_id;
    spinlock_t       tb6_lock;     /* IPv6 路由表需要自旋锁 */
    struct fib6_node tb6_root;     /* 内嵌根节点 */
    unsigned int     fib_seq;      /* 序列号 */
};

struct fib6_node {
    struct fib6_node __rcu *parent, *left, *right;
    struct fib6_node __rcu *subtree;   /* 源地址子树（源路由） */
    struct fib6_info __rcu *leaf;      /* 叶子路由 */
    __u16            fn_bit;           /* 分叉比特位 */
    __u16            fn_flags;
    int              fn_sernum;
    struct fib6_info __rcu *rr_ptr;    /* 轮询指针 */
};

# 追踪 fib_table_lookup——每次路由查找的表和结果
bpftrace -e '
kretprobe:fib_table_lookup {
    printf("fib_table_lookup: ret=%d\n", retval);
}'

# 追踪策略路由命中——哪条规则匹配了
bpftrace -e '
kprobe:fib_rules_lookup {
    printf("fib_rules_lookup family=%d\n", arg2);
}'

# 统计每个下一跳被选中的次数
bpftrace -e '
kprobe:fib_select_multipath {
    @selected = lhist(arg1, 0, 8, 1);
}'

# 追踪 PMTU 更新——频繁更新说明路径 MTU 不稳定
bpftrace -e '
kprobe:__ip_rt_update_pmtu {
    $mtu = arg2;
    printf("pmtu_update: mtu=%u\n", $mtu);
    @pmtu_updates = count();
}'

# rt_genid 变化频率——频繁变化说明路由表不稳定
bpftrace -e '
kprobe:rt_genid_bump_ipv4 {
    printf("rt_genid bumped! time=%lu\n", nsecs);
    @genid_bumps = count();
}'

# 测量 fib_lookup 耗时
bpftrace -e '
kprobe:fib_lookup { @start[tid] = nsecs; }
kretprobe:fib_lookup /@start[tid]/ {
    @fib_lookup_ns = hist(nsecs - @start[tid]);
    delete(@start[tid]);
}'