【Linux 网络子系统深度拆解】IP 层内核实现：路由查找、分片与转发

int ip_rcv(struct sk_buff *skb, struct net_device *dev,
           struct packet_type *pt, struct net_device *orig_dev);

// net/ipv4/ip_input.c — ip_rcv() 简化
int ip_rcv(struct sk_buff *skb, ...)
{
    struct iphdr *iph;

    // 1. 只处理发给本机的包（pkt_type == PACKET_HOST 或 PACKET_BROADCAST 等）
    //    PACKET_OTHERHOST 的包在这里被丢弃
    if (skb->pkt_type == PACKET_OTHERHOST)
        goto drop;

    // 2. 确保 IP 头可读（可能需要 pskb_may_pull）
    if (!pskb_may_pull(skb, sizeof(struct iphdr)))
        goto inhdr_error;

    iph = ip_hdr(skb);

    // 3. 版本号必须是 4
    if (iph->version != 4)
        goto inhdr_error;

    // 4. 头长度至少 20 字节（ihl >= 5）
    if (iph->ihl < 5)
        goto inhdr_error;

    // 5. 校验和验证
    if (unlikely(ip_fast_csum((u8 *)iph, iph->ihl)))
        goto csum_error;

    // 6. 总长度合法性
    if (skb->len < ntohs(iph->tot_len))
        goto drop;

    // 统计计数
    __IP_INC_STATS(net, IPSTATS_MIB_INPKTS);

    // 7. 进入 Netfilter PRE_ROUTING 钩子
    return NF_HOOK(NFPROTO_IPV4, NF_INET_PRE_ROUTING,
                   net, NULL, skb, dev, NULL,
                   ip_rcv_finish);
}

static inline int
NF_HOOK(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
        struct sk_buff *skb, struct net_device *in, struct net_device *out,
        int (*okfn)(struct net *, struct sock *, struct sk_buff *))
{
    int ret = nf_hook(pf, hook, net, sk, skb, in, out, okfn);
    if (ret == 1)
        ret = okfn(net, sk, skb);  // 所有钩子都放行 → 调用 okfn
    return ret;
}

// net/ipv4/ip_input.c — ip_rcv_finish() 简化
static int ip_rcv_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
{
    struct iphdr *iph = ip_hdr(skb);

    // 1. Early Demux：已建立连接的包跳过路由查找
    if (net->ipv4.sysctl_ip_early_demux && !skb_dst(skb)) {
        // TCP: tcp_v4_early_demux()
        // UDP: udp_v4_early_demux()
        // 如果找到匹配的 socket，直接复用 socket 上缓存的 dst_entry
    }

    // 2. 如果 Early Demux 没命中，做完整路由查找
    if (!skb_dst(skb)) {
        int err = ip_route_input_noref(skb, iph->daddr, iph->saddr,
                                        iph->tos, skb->dev);
        if (err)
            goto drop;
    }

    // 3. IP 选项处理
    if (iph->ihl > 5) {
        // 处理 IP 选项（源路由、Record Route 等）
        if (ip_rcv_options(skb, net))
            goto drop;
    }

    // 4. 根据路由结果跳转
    //    dst->input 被设置为:
    //    - ip_local_deliver()  — 本地投递
    //    - ip_forward()        — 转发
    //    - ip_error()          — 错误（如目的不可达）
    return dst_input(skb);  // 等价于 skb_dst(skb)->input(skb)
}

# 在纯转发/路由器设备上关闭 Early Demux
sysctl -w net.ipv4.tcp_early_demux=0
sysctl -w net.ipv4.udp_early_demux=0

int ip_route_input_noref(struct sk_buff *skb, __be32 dst, __be32 src,
                         u8 tos, struct net_device *devin);

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;  // 指向 trie 根节点
    unsigned long     __data[];  // 内联数据
};

static inline int fib_lookup(struct net *net, const struct flowi4 *flp,
                             struct fib_result *res, unsigned int flags)
{
    struct fib_table *tb;

    // 快速路径：没有策略路由时直接查 local + main 表
    if (!net->ipv4.fib_has_custom_rules) {
        // 先查 local 表（本机地址最优先）
        tb = rcu_dereference(net->ipv4.fib_local);
        if (tb && !fib_table_lookup(tb, flp, res, flags | FIB_LOOKUP_NOREF))
            return 0;

        // 再查 main 表
        tb = rcu_dereference(net->ipv4.fib_main);
        if (tb && !fib_table_lookup(tb, flp, res, flags | FIB_LOOKUP_NOREF))
            return 0;

        return -ENETUNREACH;
    }

    // 慢速路径：策略路由 — 遍历 ip rule 规则链
    return __fib_lookup(net, flp, res, flags);
}

struct fib_result {
    __be32          prefix;      // 匹配的前缀
    unsigned char   prefixlen;   // 前缀长度
    unsigned char   nh_sel;      // 选中的下一跳索引（ECMP）
    unsigned char   type;        // 路由类型（RTN_LOCAL/RTN_UNICAST/...）
    unsigned char   scope;       // 范围（RT_SCOPE_HOST/LINK/UNIVERSE）
    u32             tclassid;    // TC 分类 ID
    dscp_t          dscp;        // DSCP 值
    struct fib_nh_common *nhc;   // 下一跳公共信息
    struct fib_info *fi;         // 路由信息
    struct fib_table *table;     // 匹配的 FIB 表
};

struct fib_nh {
    struct fib_nh_common nh_common;  // 通用字段：dev, gw, flags
    struct hlist_node    nh_hash;
    struct fib_info      *nh_parent;
    __be32               nh_saddr;   // 首选源地址
    int                  nh_saddr_genid;
};

$ ip rule show
0:      from all lookup local     # 优先级 0，查 local 表
32766:  from all lookup main      # 优先级 32766，查 main 表
32767:  from all lookup default   # 优先级 32767，查 default 表

struct fib_rule {
    // 匹配条件
    int             iifindex;       // 入接口
    int             oifindex;       // 出接口
    u32             mark;           // fwmark
    u32             mark_mask;      // fwmark 掩码
    u32             flags;
    u32             table;          // 目标 FIB 表
    u8              action;         // 动作（FR_ACT_TO_TBL/FR_ACT_UNREACHABLE/...）
    u8              l3mdev;
    u8              proto;
    u8              ip_proto;       // TCP/UDP/...
    char            iifname[IFNAMSIZ];
    char            oifname[IFNAMSIZ];
    struct fib_kuid_range uid_range;
    struct fib_rule_port_range sport_range;
    struct fib_rule_port_range dport_range;
    // ...
};

// net/ipv4/ip_input.c — ip_local_deliver() 简化
int ip_local_deliver(struct sk_buff *skb)
{
    struct iphdr *iph = ip_hdr(skb);

    // MF (More Fragments) 标志或 fragment offset 非零 → 这是一个分片
    if (ip_is_fragment(iph)) {
        // 送入分片重组队列
        if (ip_defrag(net, skb, IP_DEFRAG_LOCAL_DELIVER))
            return 0;  // 还没收齐，等待更多分片
        // ip_defrag 返回 0 = 重组完成，skb 现在是完整包
    }

    // 进入 Netfilter LOCAL_IN 钩子
    return NF_HOOK(NFPROTO_IPV4, NF_INET_LOCAL_IN,
                   net, NULL, skb, skb->dev, NULL,
                   ip_local_deliver_finish);
}

static int ip_local_deliver_finish(struct net *net, struct sock *sk,
                                   struct sk_buff *skb)
{
    skb_clear_delivery_time(skb);
    __skb_pull(skb, skb_network_header_len(skb));  // 移动指针跳过 IP 头

    rcu_read_lock();
    ip_protocol_deliver_rcu(net, skb, ip_hdr(skb)->protocol);
    rcu_read_unlock();
    return 0;
}

// net/ipv4/ip_forward.c — ip_forward() 简化
int ip_forward(struct sk_buff *skb)
{
    struct iphdr *iph = ip_hdr(skb);
    struct rtable *rt = skb_rtable(skb);

    // 1. TTL 检查
    if (iph->ttl <= 1) {
        // TTL 耗尽，发送 ICMP Time Exceeded
        icmp_send(skb, ICMP_TIME_EXCEEDED, ICMP_EXC_TTL, 0);
        __IP_INC_STATS(net, IPSTATS_MIB_INHDRERRORS);
        goto drop;
    }

    // 2. MTU 检查
    if (ip_exceeds_mtu(skb, mtu)) {
        if (iph->frag_off & htons(IP_DF)) {
            // DF 标志 + 包太大 → ICMP "Fragmentation Needed"
            icmp_send(skb, ICMP_DEST_UNREACH, ICMP_FRAG_NEEDED,
                      htonl(mtu));
            __IP_INC_STATS(net, IPSTATS_MIB_FRAGFAILS);
            goto drop;
        }
    }

    // 3. 严格源路由检查（rp_filter）
    if (net->ipv4.sysctl_ip_forward &&
        IN_DEV_RPFILTER(in_dev)) {
        // 反向路径过滤：检查源 IP 的路由是否指向入接口
    }

    // 4. TTL 减一
    ip_decrease_ttl(iph);

    // 5. Netfilter FORWARD 钩子
    return NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD,
                   net, NULL, skb, skb->dev, rt->dst.dev,
                   ip_forward_finish);
}

static int ip_forward_finish(struct net *net, struct sock *sk, struct sk_buff *skb)
{
    struct iphdr *iph = ip_hdr(skb);

    // 处理 IP options（如 Record Route、Timestamp）
    if (unlikely(iph->ihl > 5))
        ip_forward_options(skb);

    __IP_INC_STATS(net, IPSTATS_MIB_OUTFORWDATAGRAMS);

    // 进入发送路径
    return dst_output(net, sk, skb);
    // dst->output 指向 ip_output()
}

int ip_do_fragment(struct net *net, struct sock *sk, struct sk_buff *skb,
                   int (*output)(struct net *, struct sock *, struct sk_buff *));

struct ip_frag_state {
    bool     DF;            // Don't Fragment 标志
    unsigned int hlen;      // IP 头长度
    unsigned int ll_rs;     // 链路层预留空间
    unsigned int mtu;       // 出接口 MTU
    unsigned int left;      // 剩余数据长度
    int      offset;        // 当前分片偏移
    int      ptr;           // 当前分片数据指针
    __be16   not_last_frag; // MF 标志
};

int ip_defrag(struct net *net, struct sk_buff *skb, u32 user);

struct inet_frag_queue {
    spinlock_t    lock;        // 队列锁
    struct timer_list timer;   // 重组超时定时器
    struct hlist_node hash;    // 哈希表节点
    refcount_t    refcnt;
    struct rb_root rb_fragments; // 红黑树组织分片
    struct sk_buff *fragments_tail;
    ktime_t       stamp;       // 第一个分片到达时间
    int           len;         // 已收到的总长度
    int           meat;        // 已收到的数据长度
    u8            flags;
    // ...
};

# 分片重组超时（秒）
sysctl net.ipv4.ipfrag_time  # 默认 30 秒

# 分片队列内存上限
sysctl net.ipv4.ipfrag_high_thresh  # 默认 4MB
sysctl net.ipv4.ipfrag_low_thresh   # 默认 3MB
# 当总内存超过 high_thresh，开始丢弃最老的队列，直到降到 low_thresh

$ cat /proc/net/snmp | grep -A 1 Ip:
Ip: ... ReasmTimeout ReasmReqds ReasmOKs ReasmFails FragOKs FragFails FragCreates
Ip: ... 0            1234       1230     4          5678    0         11356

struct fib_nh_exception {
    struct fib_nh_exception __rcu *fnhe_next;
    int                          fnhe_genid;
    __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
    unsigned long                fnhe_stamp;     // 更新时间戳
};

struct dst_entry {
    struct net_device *dev;        // 出接口
    struct dst_ops    *ops;        // 操作函数表
    unsigned long     _metrics;    // 路径度量（MTU 等）
    unsigned long     expires;     // 过期时间
    int (*input)(struct sk_buff *);  // 收包处理函数
    int (*output)(struct net *, struct sock *, struct sk_buff *);  // 发包处理函数
    unsigned short    flags;
    short             obsolete;    // 是否过期
    rcuref_t          __rcuref;    // RCU 引用计数
    // ...
};

// include/uapi/linux/netfilter_ipv4.h
#define NF_IP_PRE_ROUTING    0   // ip_rcv() → ip_rcv_finish()
#define NF_IP_LOCAL_IN       1   // ip_local_deliver() → ip_local_deliver_finish()
#define NF_IP_FORWARD        2   // ip_forward() → ip_forward_finish()
#define NF_IP_LOCAL_OUT      3   // ip_local_out() → dst_output()
#define NF_IP_POST_ROUTING   4   // ip_output() → ip_finish_output()

# 对转发流量跳过 conntrack（使用 nftables）
nft add rule inet filter prerouting iif eth0 oif eth1 notrack

# 或使用 iptables -j NOTRACK（raw 表）
iptables -t raw -A PREROUTING -i eth0 -o eth1 -j NOTRACK

# SNMP 标准计数器
cat /proc/net/snmp | grep Ip:

# 扩展计数器
cat /proc/net/netstat | grep IpExt:

# 追踪 ip_route_input_noref 的延迟和结果
bpftrace -e '
kprobe:ip_route_input_noref {
    @start[tid] = nsecs;
}
kretprobe:ip_route_input_noref /@start[tid]/ {
    $lat = (nsecs - @start[tid]) / 1000;
    @route_lookup_us = hist($lat);
    @route_result = lhist(retval, -10, 10, 1);
    delete(@start[tid]);
}
'

# 追踪 ip_forward 的调用频率和 TTL
bpftrace -e '
kprobe:ip_forward {
    $skb = (struct sk_buff *)arg0;
    $iph = (struct iphdr *)($skb->head + $skb->network_header);
    @forward_ttl = lhist($iph->ttl, 0, 256, 8);
    @forward_count = count();
}
interval:s:1 {
    printf("--- %d forwards/sec ---\n", @forward_count);
    clear(@forward_count);
}
'

# 追踪 ip_defrag 调用和重组结果
bpftrace -e '
kprobe:ip_defrag {
    @defrag_calls = count();
}
kretprobe:ip_defrag {
    @defrag_result = lhist(retval, -10, 10, 1);
    // 返回 0 = 重组完成，-EINPROGRESS = 等待更多分片
}
interval:s:5 {
    printf("=== ip_defrag stats ===\n");
    print(@defrag_calls);
    print(@defrag_result);
    clear(@defrag_calls);
    clear(@defrag_result);
}
'

# 采集 IP 层相关函数的 CPU 热点
perf top -g -e cycles:k -s comm --filter='ip_rcv or ip_forward or \
    ip_local_deliver or fib_table_lookup or ip_output'

# 对比优化前后的 FIB 查找开销
perf stat -e cycles,instructions,cache-misses -a \
    -p $(pgrep -f "ip_forward") -- sleep 10

# 1. 开启转发
sysctl -w net.ipv4.ip_forward=1

# 2. 关闭 Early Demux（转发流量不需要）
sysctl -w net.ipv4.tcp_early_demux=0
sysctl -w net.ipv4.udp_early_demux=0

# 3. 关闭不需要的 Netfilter 模块
# 如果不需要 NAT，卸载 conntrack
modprobe -r nf_conntrack

# 4. 减少策略路由规则
# 用 VRF 替代大量 ip rule

# 5. 调整 rp_filter（宽松模式比严格模式快）
sysctl -w net.ipv4.conf.all.rp_filter=2

# 6. 确保 RSS/RPS 均匀分布（减少单 CPU 瓶颈）
ethtool -L eth0 combined $(nproc)