2025-03-14

网口状态标志位解析: part1

`IP link`命令结果里的网口状态标志位

我们先来看几个场景里，不同状态的网口，输出的标志位有哪些不一样。

正常状态下物理网口eth0 的输出

命令行ip link show dev eth0会输出网口eth0的一些状态标志位。
这里注意一个现象, ‘ifconfig’命令显示的结果里有’RUNNING’标志位，但是’ip link’命令的结果里没有这个标志位。
图1: 正常网口的ip link 命令和ifconfig命令结果

场景2：拔掉物理口的网线后, 网口的状态变化。

网口状态标志位里有个明显变化，多了一个’NO-CARRIER’
图2: 拔掉网线后的网口输出结果

2025-03-14

网口状态标志位解析part2: 内核如何维护网卡carrier的状态

内核如何维护网卡设备的RUNNING 状态

流程概述

主要几个部分：

网卡驱动有个看门狗：不同网卡驱动实现可能不太一样，功能负责监控网卡硬件上网线的状态，当网线状态变换的时候，会激发内核的 carrier 处理函数。
内核两个通用的处理函数：netif_carrier_on和netif_carrier_off。这个函数会
- 设置或者清除netdev->state上的__LINK_STATE_NOCARRIER标志位。
- 发送事件消息给linkwatch，做后续处理.
- 如果是网线插好了状态，会启动一个通用的看门狗，这个看门狗是负责检测tx队列是否’HUNG’了，如果’HUNG’了就调用网卡对应的处理函数ndo_tx_timeout，做一些应急补救，比如对网卡队列复位等操作。这里的看门狗跟网卡驱动里的看门狗还不是同一个看门狗。具体差别待研究。
linkwath模块：linkwatch本身是个workqueue 队列，对接受到的消息按照，分为紧急和非紧急两类。紧急的决定立即处理，非紧急的则挂到一个链表里，等定时器超时后，再集中处理。所有事件处理，最终都交给linkwatch_do_dev(struct net_device *dev)函数进行处理。该函数更新netdev->operate标志位。同时调用通用的dev_activate或者dev_deactivate对网卡做网卡队列进行处理。我们这里重点关注跟网卡状态位有管的部分，忽略跟网卡队列的处理。
这里有两个重要函数rfc2863_policy和default_operstate 后面我们重点介绍。

carrier on 和 off 函数

netif_carrier_on和netif_carrier_off: 内核里的两个通用的处理函数，功能基本对称

carrier on详解

`netif_carrier_on`主要依次做下面三个操作
+ `__LINK_STATE_NOCARRIER`: 设置`netdev->state`上的`__LINK_STATE_NOCARRIER`标志位。这个标志位很关键，后续判断carrier 是否 OK，就看这个标志位。
如果是从无到有这个标志位，则执行下面两步，否则就跳过。
+ 增加网卡设备下的`dev->carrier_up_count`的计数次数。
+ 发送事件消息给linkwatch：让他做后续处理。激发动作有两部分
    + '__LINK_STATE_LINKWATCH_PENDING'：设置这个标志位
+ 如果是网线插好了状态， 会启动一个网卡的看门狗，这个看门狗是负责检测tx队列是否'HUNG'了， 如果'HUNG'了就调用网卡对应的处理函数`ndo_tx_timeout`， 做一些应急补救，比如对网卡队列复位等操作。

4390 static inline bool netif_carrier_ok(const struct net_device *dev)
4391 {
4392         return !test_bit(__LINK_STATE_NOCARRIER, &dev->state);
4393 }

581 void netif_carrier_on(struct net_device *dev)
582 {
583         if (test_and_clear_bit(__LINK_STATE_NOCARRIER, &dev->state)) {
584                 if (dev->reg_state == NETREG_UNINITIALIZED)
585                         return;
586                 atomic_inc(&dev->carrier_up_count);
587                 linkwatch_fire_event(dev);
588                 if (netif_running(dev))
589                         netdev_watchdog_up(dev);
590         }
591 }
592 EXPORT_SYMBOL(netif_carrier_on);

600 void netif_carrier_off(struct net_device *dev)
601 {
602         if (!test_and_set_bit(__LINK_STATE_NOCARRIER, &dev->state)) {
603                 if (dev->reg_state == NETREG_UNINITIALIZED)
604                         return;
605                 atomic_inc(&dev->carrier_down_count);
606                 linkwatch_fire_event(dev);
607         }
608 }
609 EXPORT_SYMBOL(netif_carrier_off);

link watch函数

入口函数

291 void linkwatch_fire_event(struct net_device *dev)
292 {
293         bool urgent = linkwatch_urgent_event(dev);
294
295         if (!test_and_set_bit(__LINK_STATE_LINKWATCH_PENDING, &dev->state)) {
296                 linkwatch_add_event(dev);
297         } else if (!urgent)
298                 return;
299
300         linkwatch_schedule_work(urgent);
301 }

将 netdev 增加到链表中

124 static void linkwatch_add_event(struct net_device *dev)
125 {
126         unsigned long flags;
127
128         spin_lock_irqsave(&lweventlist_lock, flags);
129         if (list_empty(&dev->link_watch_list)) {
130                 list_add_tail(&dev->link_watch_list, &lweventlist);
131                 netdev_hold(dev, &dev->linkwatch_dev_tracker, GFP_ATOMIC);
132         }
133         spin_unlock_irqrestore(&lweventlist_lock, flags);
134 }

workqueue 的处理函数，dev从链表上摘下来，逐个调用linkwatch_do_dev处理。

194 static void __linkwatch_run_queue(int urgent_only)
195 {
...
224         spin_lock_irq(&lweventlist_lock);
225         list_splice_init(&lweventlist, &wrk);
226
227         while (!list_empty(&wrk) && do_dev > 0) {
229
230                 dev = list_first_entry(&wrk, struct net_device, link_watch_list);
...
243                 linkwatch_do_dev(dev);
...
246         }
...
254 }

link watch

166 static void linkwatch_do_dev(struct net_device *dev)
167 {
...
177         clear_bit(__LINK_STATE_LINKWATCH_PENDING, &dev->state);
178
179         rfc2863_policy(dev);
180         if (dev->flags & IFF_UP) {
181                 if (netif_carrier_ok(dev))
182                         dev_activate(dev);
183                 else
184                         dev_deactivate(dev);
185
186                 netdev_state_change(dev);
187         }
...
192 }

两个状态维护函数

74 static void rfc2863_policy(struct net_device *dev)
75 {
76         unsigned int operstate = default_operstate(dev);
77
78         if (operstate == READ_ONCE(dev->operstate))
79                 return;
80
81         switch(dev->link_mode) {
82         case IF_LINK_MODE_TESTING:
83                 if (operstate == IF_OPER_UP)
84                         operstate = IF_OPER_TESTING;
85                 break;
86
87         case IF_LINK_MODE_DORMANT:
88                 if (operstate == IF_OPER_UP)
89                         operstate = IF_OPER_DORMANT;
90                 break;
91         case IF_LINK_MODE_DEFAULT:
92         default:
93                 break;
94         }
95
96         WRITE_ONCE(dev->operstate, operstate);
97 }

36 static unsigned int default_operstate(const struct net_device *dev)
37 {
38         if (netif_testing(dev))
39                 return IF_OPER_TESTING;
40
41         /* Some uppers (DSA) have additional sources for being down, so
42          * first check whether lower is indeed the source of its down state.
43          */
44         if (!netif_carrier_ok(dev)) {
45                 struct net_device *peer;
46                 int iflink;
47
48                 /* If called from netdev_run_todo()/linkwatch_sync_dev(),
49                  * dev_net(dev) can be already freed, and RTNL is not held.
50                  */
51                 if (dev->reg_state <= NETREG_REGISTERED)
52                         iflink = dev_get_iflink(dev);
53                 else
54                         iflink = dev->ifindex;
55
56                 if (iflink == dev->ifindex)
57                         return IF_OPER_DOWN;
58
59                 ASSERT_RTNL();
60                 peer = __dev_get_by_index(dev_net(dev), iflink);
61                 if (!peer)
62                         return IF_OPER_DOWN;
63
64                 return netif_carrier_ok(peer) ? IF_OPER_DOWN :
65                                                 IF_OPER_LOWERLAYERDOWN;
66         }
67
68         if (netif_dormant(dev))
69                 return IF_OPER_DORMANT;
70
71         return IF_OPER_UP;
72 }

回调函数 (待细看)

这部分代码要涉及到 netdev的callback链和 rtnetlin 消息通知。
是网卡设备状态变换后的消息通知和处理工作。

1530 void netdev_state_change(struct net_device *dev)
1531 {
1532         if (dev->flags & IFF_UP) {
1533                 struct netdev_notifier_change_info change_info = {
1534                         .info.dev = dev,
1535                 };
1536
1537                 call_netdevice_notifiers_info(NETDEV_CHANGE,
1538                                               &change_info.info);
1539                 rtmsg_ifinfo(RTM_NEWLINK, dev, 0, GFP_KERNEL, 0, NULL);
1540         }
1541 }
1542 EXPORT_SYMBOL(netdev_state_change);

2025-02-06

2025-02-06-epoll-frame-summary

epoll学习笔记

epoll 相关结构体
epoll 各个系统调用及内核实现

epoll相关结构体
epoll调用关联图

2025-02-06

tcpdump如何实现参数-报文抓取长度

用法

tcpdump -s len

原理

tcpdump会把这个长度值编译到ebpf代码中。 ebpf代码执行完后，如果filter成功，则作为返回值（return）返回给调用方（内核协议栈），内核协议栈根据返回值，修改 skb报文到指定的长度，并借助 af socket 返回给用户空间。

tcpdump命令解析

tcpdump snaplen参数: ebpf指令对比

2024-07-24

2024-07-24-struct-group

`__struct_group`

浏览IPv6代码时候，看到这样一个新玩法，
__struct_group

118 struct ipv6hdr {
...
132         __u8                    hop_limit;
133
134         __struct_group(/* no tag */, addrs, /* no attrs */,
135                 struct  in6_addr        saddr;
136                 struct  in6_addr        daddr;
137         );
138 };

###用法
再看一下用法：

 922 /* copy IPv6 saddr & daddr to flow_keys, possibly using 64bit load/store
 923  * Equivalent to :      flow->v6addrs.src = iph->saddr;
 924  *                      flow->v6addrs.dst = iph->daddr;
 925  */
 926 static inline void iph_to_flow_copy_v6addrs(struct flow_keys *flow,
 927                                             const struct ipv6hdr *iph)
 928 {
 ...
 932         memcpy(&flow->addrs.v6addrs, &iph->addrs, sizeof(flow->addrs.v6addrs));
 ...
 1
2
3

###


 11 /**
 12  * __struct_group() - Create a mirrored named and anonyomous struct
 13  *
 14  * @TAG: The tag name for the named sub-struct (usually empty)
 15  * @NAME: The identifier name of the mirrored sub-struct
 16  * @ATTRS: Any struct attributes (usually empty)
 17  * @MEMBERS: The member declarations for the mirrored structs
 18  *
 19  * Used to create an anonymous union of two structs with identical layout
 20  * and size: one anonymous and one named. The former's members can be used
 21  * normally without sub-struct naming, and the latter can be used to
 22  * reason about the start, end, and size of the group of struct members.
 23  * The named struct can also be explicitly tagged for layer reuse, as well
 24  * as both having struct attributes appended.
 25  */
 26 #define __struct_group(TAG, NAME, ATTRS, MEMBERS...) \
 27         union { \
 28                 struct { MEMBERS } ATTRS; \
 29                 struct TAG { MEMBERS } ATTRS NAME; \
 30         } ATTRS
```

2024-07-18

IPv6: how to support IPv6 ext header

概述

与IPv4的几点不同

IPv6在扩展头和协议处理上跟IPv4还有些不一样。

IPv6报文格式设计上，上层协议和扩展头都作为IPv6的nexthdr类型串联在一起，不像IPv4那样扩展头是单独的option，上层协议类型放到ip头里的proto字段。
IPv6的扩展头大部分采用tlv格式，大部分扩展头前几个字节会保存nexthdr，本扩展的长度这两个信息，然后跟本扩展头相关的一些数据。
我们无法像IPv4那样通过IP头里的字段就能简洁的判读出报文四层协议类型以及4层协议的offer和lenth等信息。必须逐个解析全部的扩展头。

原理

协议栈通过一个inet6_protocol类型的数组，保存IPv6所有的4层处理协议入口。

1 2	struct inet6_protocol __rcu *inet6_protos[MAX_INET_PROTOS] __read_mostly; EXPORT_SYMBOL(inet6_protos)

数组inet6_protos的下标对应的就是每个扩展协议在IPv6扩展头里的nexthdr值

`inet6_protocol`结构体

struct inet6_protocol结构体里的handler是扩展头的处理入口函数。
flags字段有两个标志位: INET6_PROTO_NOPOLICY和INET6_PROTO_FINAL

INET6_PROTO_FINAL: 这个扩展是否可以作为IPv6的最后一个扩展，比如
TCP可以，但是IPPROTO_DSTOPTS不可以。
INET6_PROTO_NOPOLICY: 这个要求必须有对应的IPsec/xfrm XFRM_POLICY_IN的规则
这里有个疑问， esp6和ah6 为什么也有这个标志位，我理解不应该有这个标志位，有esp和ah头的，必须要有xfrm规则才可。

53 struct inet6_protocol {
54         int     (*handler)(struct sk_buff *skb);
55
56         /* This returns an error if we weren't able to handle the error. */
57         int     (*err_handler)(struct sk_buff *skb,
58                                struct inet6_skb_parm *opt,
59                                u8 type, u8 code, int offset,
60                                __be32 info);
61
62         unsigned int    flags;  /* INET6_PROTO_xxx */
63         u32             secret;
64 };
65

1 2	66 #define INET6_PROTO_NOPOLICY 0x1 67 #define INET6_PROTO_FINAL 0x2

函数调用栈

==> ipv6_rcv
==> ==> ip6_rcv_finish
==> ==> ==> dst_input(skb); <== ip6_input
==> ==> ==> ==> ip6_input
==> ==> ==> ==> ==> ip6_input_finish
==> ==> ==> ==> ==> ==> ip6_protocol_deliver_rcu(net, skb, 0, false);
==> ==> ==> ==> ==> ==> ==> ipprot = rcu_dereference(inet6_protos[`nexthdr`]);

注册和注销

52 struct inet6_protocol {
53         int     (*handler)(struct sk_buff *skb);
54
55         /* This returns an error if we weren't able to handle the error. */
56         int     (*err_handler)(struct sk_buff *skb,
57                                struct inet6_skb_parm *opt,
58                                u8 type, u8 code, int offset,
59                                __be32 info);
60
61         unsigned int    flags;  /* INET6_PROTO_xxx */
62 };

28 int inet6_add_protocol(const struct inet6_protocol *prot, unsigned char protocol)
29 {
30         return !cmpxchg((const struct inet6_protocol **)&inet6_protos[protocol],
31                         NULL, prot) ? 0 : -1;
32 }

35 int inet6_del_protocol(const struct inet6_protocol *prot, unsigned char protocol)
36 {
37         int ret;
38
39         ret = (cmpxchg((const struct inet6_protocol **)&inet6_protos[protocol],
40                        prot, NULL) == prot) ? 0 : -1;
41
42         synchronize_net();
43
44         return ret;
45 }

内核总共支持的IPv6四层协议类型。

➜  linux git:(master) grep inet6_add_protocol net include -Rw
net/dccp/ipv6.c:	err = inet6_add_protocol(&dccp_v6_protocol, IPPROTO_DCCP);
net/l2tp/l2tp_ip6.c:	err = inet6_add_protocol(&l2tp_ip6_protocol, IPPROTO_L2TP);
net/sctp/ipv6.c:	if (inet6_add_protocol(&sctpv6_protocol, IPPROTO_SCTP) < 0)
net/ipv6/udplite.c:	ret = inet6_add_protocol(&udplitev6_protocol, IPPROTO_UDPLITE);
net/ipv6/xfrm6_protocol.c:		if (inet6_add_protocol(netproto(protocol), protocol)) {
net/ipv6/exthdrs.c:	ret = inet6_add_protocol(&rthdr_protocol, IPPROTO_ROUTING);
net/ipv6/exthdrs.c:	ret = inet6_add_protocol(&destopt_protocol, IPPROTO_DSTOPTS);
net/ipv6/exthdrs.c:	ret = inet6_add_protocol(&nodata_protocol, IPPROTO_NONE);
net/ipv6/ip6mr.c:	if (inet6_add_protocol(&pim6_protocol, IPPROTO_PIM) < 0) {
net/ipv6/udp.c:	ret = inet6_add_protocol(&net_hotdata.udpv6_protocol, IPPROTO_UDP);
net/ipv6/ip6_gre.c:	err = inet6_add_protocol(&ip6gre_protocol, IPPROTO_GRE);
net/ipv6/reassembly.c:	ret = inet6_add_protocol(&frag_protocol, IPPROTO_FRAGMENT);
net/ipv6/protocol.c:int inet6_add_protocol(const struct inet6_protocol *prot, unsigned char protocol)
net/ipv6/protocol.c:EXPORT_SYMBOL(inet6_add_protocol);
net/ipv6/tcp_ipv6.c:	ret = inet6_add_protocol(&net_hotdata.tcpv6_protocol, IPPROTO_TCP);
net/ipv6/icmp.c:	if (inet6_add_protocol(&icmpv6_protocol, IPPROTO_ICMPV6) < 0)
net/ipv6/tunnel6.c:	if (inet6_add_protocol(&tunnel6_protocol, IPPROTO_IPV6)) {
net/ipv6/tunnel6.c:	if (inet6_add_protocol(&tunnel46_protocol, IPPROTO_IPIP)) {
net/ipv6/tunnel6.c:	    inet6_add_protocol(&tunnelmpls6_protocol, IPPROTO_MPLS)) {
include/net/protocol.h:int inet6_add_protocol(const struct inet6_protocol *prot, unsigned char num);
➜  linux git:(master)

`IPPROTO_ROUTING` 字段处理

835 static const struct inet6_protocol rthdr_protocol = {
836         .handler        =       ipv6_rthdr_rcv,
837         .flags          =       INET6_PROTO_NOPOLICY,
838 };

1	ret = inet6_add_protocol(&rthdr_protocol, IPPROTO_ROUTING);

TCP协议处理

2406         net_hotdata.tcpv6_protocol = (struct inet6_protocol) {
2407                 .handler     = tcp_v6_rcv,
2408                 .err_handler = tcp_v6_err,
2409                 .flags       = INET6_PROTO_NOPOLICY | INET6_PROTO_FINAL,
2410         };
2411         ret = inet6_add_protocol(&net_hotdata.tcpv6_protocol, IPPROTO_TCP);

IPV6-in-IPv4 tunnel协议处理

239 static const struct inet6_protocol tunnel6_protocol = {
240         .handler        = tunnel6_rcv,
241         .err_handler    = tunnel6_err,
242         .flags          = INET6_PROTO_NOPOLICY|INET6_PROTO_FINAL,
243 };
...

257 static int __init tunnel6_init(void)
258 {
259         if (inet6_add_protocol(&tunnel6_protocol, IPPROTO_IPV6)) {
...

 52   IPPROTO_IPV6 = 41,            /* IPv6-in-IPv4 tunnelling              */

2023-10-27

ebpf如何访问skb 的fileds

加载:

转换：所有skb的fields都转换成相对skb结构体头部的偏移量
根据偏移量重新校验 bpf指令

报文运行：

Skb的地址在skb是作为ctx寄存器传递给bfp run函数的。

BPF CTX与SKB

这里以tcpdump(PF_PACKET)为例，结合函数调用关系说明，
skb是如何被当做ctx参数传递给bpf程序的

注：内核版本v6.6

函数调用关系

--> packet_rcv
--> --> run_filter(skb, sk, snaplen) 
--> --> --> bpf_prog_run_clear_cb
--> --> --> --> bpf_prog_run_pin_on_cpu(prog, skb); <== !!! skb作为第二个参数ctx传递
--> --> --> --> --> bpf_prog_run(prog, ctx);
--> --> --> --> --> --> __bpf_prog_run(prog, ctx, bpf_dispatcher_nop_func);
--> --> --> --> --> --> --> dfunc(ctx, prog->insnsi, prog->bpf_func);
		dfun是__bpf_prog_run被调用时候的参数，相当于
		bpf_dispatcher_nop_func(ctx, prog->insnsi, prog->bpf_func);
--> --> --> --> --> --> --> --> bpf_func(ctx, insnsi);
		bpf_func是bpf_dispatcher_nop_func被调用时候最后一个参数，相当于
		prog->bpf_func(ctx, prog->insnsi)

2023-10-27

协议栈是如何调用xdp程序处理报文的

函数调用栈

以xdp SKB模式为例，

--> bpf_prog_run_generic_xdp
--> --> bpf_prog_run_xdp
--> --> --> u32 act = __bpf_prog_run(prog, xdp, BPF_DISPATCHER_FUNC(xdp)); 
	展开BPF_DISPATCHER_FUNC(xdp)， 相当于
            u32 act = __bpf_prog_run(prog, xdp, bpf_dispatcher_xdp_func));
--> --> --> --> ret = dfunc(ctx, prog->insnsi, prog->bpf_func);
	这里的dfun是`__bpf_prog_run`的第三个参数，因此相当于
                ret = bpf_dispatcher_xdp_func(ctx, prog->insnsi, prog->bpf_func);  <== 这里的第三个函数就是我们之前提到的，当bpf程序被加载时候，在bpf_prog结构体保存的bpf_func。
--> --> --> --> --> return __BPF_DISPATCHER_CALL(name);   <== 根据bpf_dispatcher_xdp_func的定义
                展开__BPF_DISPATCHER_CALL，相当于
		bpf_func(ctx, insnsi)  <=== **这里很有意思**，bpf_fun, ctx, insnsi分别代表bpf_dispatcher_xdp_func的三个函数入口参数，
			根据顺序依次为 第三个，第一个，第二个，按照这个顺序展开
                prog->bpf_func(ctx, prog->insnsi); <== 至此，就把我们上面一节里总结的`prog->bpf_func`这个函数指针用上了。
			最终这个函数根据不同stacksize入口函数的包装，调用到
--> --> --> --> --> --> ___bpf_prog_run(ctx, prog->insnsi)

2023-10-27

bfp 在内核运行的核心入口函数及其变形

bpf prog内核运行核心入口函数

总结：`___bpf_prog_run`

bfp 在内核运行的核心入口函数:___bpf_prog_run
___bpf_prog_run是bfp的核心函数入口，该函数被多个不同stack size的函数调用。
函数指针数组interpreters这把上面的这些函数汇集到一起。
当bpf程序被加载到内核时候，内核创建为它一个bpf_prog结构体，根据prog的stacksize，选择对应的interpreters里的对应的
函数，并保存到bpf_prog里的bpf_func上。
这样后续hook点运行bpf_prog程序时候，就使用bpf_func运行。

2023-10-26

xdp 是如何加载到内核并运行的

XDP framework

xdp在内核里的有三个关键步骤:

load: 加载到内核
attach: 绑定到一个网口
run：网口收包时候，调用并执行bpf prog

`load`加载: 通过ebpf系统调用，把prog加载到内核

fd = sys_bpf(BPF_PROG_LOAD, attr, size);

在内核里创建一个bfp_prog结构体用以存储bpf prog。
通过bpf_check检查prog程序的安全性和合法性。
通过bpf_prog_select_runtime指定bpf prog对应的执行函数
这个函数指针保存在bpf_func这个字段里。这里的function最终指向通用的bfp run函数___bpf_prog_run。
关于___bpf_prog_run这个具体封装和实现见另外一篇文章。

`attach`绑定: 将prog程序绑定到一个特定的网口的`struct net_device`上

libpf函数do_attach将上一步加载在内核里的prog跟一个网口绑定，具体实现是通过下发netlink命令。
这是个generic类型的netlink命令，最终通过dev_change_xdp_fd将prog挂载到对应netdev下面。

IP link命令结果里的网口状态标志位

正常状态下物理网口eth0 的输出

场景2：拔掉物理口的网线后, 网口的状态变化。

流程概述

carrier on 和 off 函数

carrier on详解

link watch函数

两个状态维护函数

回调函数 (待细看)

epoll学习笔记

用法

原理

tcpdump命令解析

__struct_group

概述

与IPv4的几点不同

原理

inet6_protocol结构体

函数调用栈

注册和注销

内核总共支持的IPv6四层协议类型。

IPPROTO_ROUTING 字段处理

TCP协议处理

IPV6-in-IPv4 tunnel协议处理

ebpf如何访问skb 的fileds

BPF CTX与SKB

函数调用关系

函数调用栈

bpf prog内核运行核心入口函数

总结：___bpf_prog_run

XDP framework

load加载: 通过ebpf系统调用， 把prog加载到内核

attach绑定: 将prog程序绑定到一个特定的网口的struct net_device上

`IP link`命令结果里的网口状态标志位

`__struct_group`

`inet6_protocol`结构体

`IPPROTO_ROUTING` 字段处理

总结：`___bpf_prog_run`

`load`加载: 通过ebpf系统调用，把prog加载到内核

`attach`绑定: 将prog程序绑定到一个特定的网口的`struct net_device`上