static int nft_verdict_init(const struct nft_ctx *ctx, struct nft_data *data,
                            struct nft_data_desc *desc, const struct nlattr *nla)
{
    u8 genmask = nft_genmask_next(ctx->net);
    struct nlattr *tb[NFTA_VERDICT_MAX + 1];
    struct nft_chain *chain;
    int err;

    /* 解析嵌套的 verdict 属性 */
    err = nla_parse_nested_deprecated(tb, NFTA_VERDICT_MAX, nla,
                                      nft_verdict_policy, NULL);
    if (err < 0)
        return err;

    /* 必须提供 verdict 码属性 */
    if (!tb[NFTA_VERDICT_CODE])
        return -EINVAL;

    /* 将数据区清零，便于后续 memcmp 比较 */
    memset(data, 0, sizeof(*data));
    /* 从 netlink 属性读取 32 位 verdict 码，直接赋值给 data->verdict.code */
    data->verdict.code = ntohl(nla_get_be32(tb[NFTA_VERDICT_CODE]));

    switch (data->verdict.code) {
    default:
        /* 精确匹配失败后，进入 default 分支，检查低 8 位是否匹配基础 verdict */
        switch (data->verdict.code & NF_VERDICT_MASK) {
        case NF_ACCEPT:
        case NF_DROP:
        case NF_QUEUE:
            break;              /* 低 8 位匹配，接受该 verdict */
        default:
            return -EINVAL;     /* 低 8 位不匹配，拒绝 */
        }
        fallthrough;            /* 跳转到内部 verdict 分支，最终接受 */
    case NFT_CONTINUE:
    case NFT_BREAK:
    case NFT_RETURN:
        break;                  /* 这些是 nftables 内部 verdict，直接接受 */
    case NFT_JUMP:
    case NFT_GOTO:
        /* 处理跳转类 verdict，需要查找并绑定目标链 */
        if (tb[NFTA_VERDICT_CHAIN]) {
            chain = nft_chain_lookup(ctx->net, ctx->table,
                                     tb[NFTA_VERDICT_CHAIN],
                                     genmask);
        } else if (tb[NFTA_VERDICT_CHAIN_ID]) {
            chain = nft_chain_lookup_byid(ctx->net, ctx->table,
                                          tb[NFTA_VERDICT_CHAIN_ID],
                                          genmask);
            if (IS_ERR(chain))
                return PTR_ERR(chain);
        } else {
            return -EINVAL;
        }

        if (IS_ERR(chain))
            return PTR_ERR(chain);
        /* 基础链不允许作为跳转目标 */
        if (nft_is_base_chain(chain))
            return -EOPNOTSUPP;
        if (nft_chain_is_bound(chain))
            return -EINVAL;
        if (desc->flags & NFT_DATA_DESC_SETELEM &&
            chain->flags & NFT_CHAIN_BINDING)
            return -EINVAL;
        if (!nft_use_inc(&chain->use))
            return -EMFILE;

        data->verdict.chain = chain;
        break;
    }

    desc->len = sizeof(data->verdict);

    return 0;
}

/* 若调用者需要执行 okfn() 则返回 1，NF_DROP 返回 -EPERM，否则返回 0。调用者必须持有 rcu_read_lock。 */
int nf_hook_slow(struct sk_buff *skb, struct nf_hook_state *state,
                 const struct nf_hook_entries *e, unsigned int s)
{
    unsigned int verdict;
    int ret;

    for (; s < e->num_hook_entries; s++) {
        /* 执行当前 hook 函数，获得 verdict 值 */
        verdict = nf_hook_entry_hookfn(&e->hooks[s], skb, state);
        switch (verdict & NF_VERDICT_MASK) {   /* 仅取低 8 位进行判断（NF_VERDICT_MASK = 0x000000ff） */
        case NF_ACCEPT:                        /* 1：接受数据包，继续处理 */
            break;
        case NF_DROP:                          /* 0：丢弃数据包 */
            kfree_skb_reason(skb,
                             SKB_DROP_REASON_NETFILTER_DROP);  /* 释放 skb（第一次释放） */
            ret = NF_DROP_GETERR(verdict);     /* 从 verdict 高 16 位提取 drop error */
            if (ret == 0)
                ret = -EPERM;                  /* drop error 为 0 时，返回 -EPERM */
            return ret;                        /* 若 drop error 为正值（如 1），直接返回该正值 */
        case NF_QUEUE:                         /* 3：将数据包排队 */
            ret = nf_queue(skb, state, s, verdict);
            if (ret == 1)
                continue;
            return ret;
        default:
            /* 隐式处理 NF_STOLEN 以及其他非常规 verdict。 */
            return 0;
        }
    }

    return 1;
}

static inline int NF_DROP_GETERR(int verdict)
{
    /* NF_VERDICT_QBITS = 16，将 verdict 算术右移 16 位后取负 */
    return -(verdict >> NF_VERDICT_QBITS);
}

struct nftables_pernet {
    struct list_head tables;          // 表链表
    struct list_head commit_list;     // 提交链表
    struct list_head binding_list;    // 绑定链表
    struct list_head module_list;     // 模块链表
    struct list_head notify_list;     // 通知链表
    struct mutex commit_mutex;        // 提交互斥锁
    u64 table_handle;                 // 表句柄
    unsigned int base_seq;            // 基序列号
    unsigned int gc_seq;              // GC 序列号
    u8 validate_state;                // 校验状态
};

struct netlink_ext_ack {
    const char *_msg;                 // 错误消息
    const struct nlattr *bad_attr;    // 坏属性
    const struct nla_policy *policy;  // 策略
    const struct nlattr *miss_nest;   // 缺失嵌套
    u16 miss_type;                    // 缺失类型
    u8 cookie[20];                    // cookie
    u8 cookie_len;                    // cookie 长度
    char _msg_buf[80];                // 消息缓冲区
};

struct nfnl_info {
    struct net *net;                  // 网络命名空间
    struct sock *sk;                  // 套接字
    const struct nlmsghdr *nlh;       // netlink 消息头
    const struct nfgenmsg *nfmsg;     // nfgenmsg
    struct netlink_ext_ack *extack;   // 扩展确认
};

struct nlattr {
    __u16 nla_len;                    // 属性长度
    __u16 nla_type;                   // 属性类型
};

struct nft_rule {
    struct list_head list;            // 规则链表节点
    u64 handle : 42;                  // 句柄
    u64 genmask : 2;                  // 生成掩码
    u64 dlen : 12;                    // 数据长度
    u64 udata : 1;                    // 用户数据标志
    unsigned char data[];             // 柔性数据
};

struct nft_expr_info {
    const struct nft_expr_ops *ops;   // 表达式操作
    const struct nlattr *attr;        // 属性
    struct nlattr *tb[17];            // 属性表
};

struct nft_flow_rule {
    __be16 proto;                     // 协议
    struct nft_flow_match {
        struct flow_dissector {
            unsigned long long used_keys;       // 已用键
            unsigned short offset[33];          // 偏移数组
        } dissector;
        struct nft_flow_key {
            struct flow_dissector_key_basic {
                __be16 n_proto;                 // 网络协议
                u8 ip_proto;                    // IP 协议
                u8 padding;                     // 填充
            } basic;
            struct flow_dissector_key_control {
                u16 thoff;                      // 传输头偏移
                u16 addr_type;                  // 地址类型
                u32 flags;                      // 标志
            } control;
            union {
                struct flow_dissector_key_ipv4_addrs {
                    __be32 src;                 // 源地址
                    __be32 dst;                 // 目的地址
                } ipv4;
                struct flow_dissector_key_ipv6_addrs {
                    struct in6_addr {
                        union {
                            __u8 u6_addr8[16];  // 8 位数组
                            __be16 u6_addr16[8]; // 16 位数组
                            __be32 u6_addr32[4]; // 32 位数组
                        } in6_u;
                    } src;
                    struct in6_addr {
                        union {
                            __u8 u6_addr8[16];  // 8 位数组
                            __be16 u6_addr16[8]; // 16 位数组
                            __be32 u6_addr32[4]; // 32 位数组
                        } in6_u;
                    } dst;
                } ipv6;
            };
            struct flow_dissector_key_ports {
                union {
                    __be32 ports;               // 端口
                    struct {
                        __be16 src;             // 源端口
                        __be16 dst;             // 目的端口
                    };
                };
            } tp;
            struct flow_dissector_key_ip {
                __u8 tos;                       // TOS
                __u8 ttl;                       // TTL
            } ip;
            struct flow_dissector_key_vlan {
                union {
                    struct {
                        u16 vlan_id : 12;       // VLAN ID
                        u16 vlan_dei : 1;       // VLAN DEI
                        u16 vlan_priority : 3;  // VLAN 优先级
                    };
                    __be16 vlan_tci;            // VLAN TCI
                };
                __be16 vlan_tpid;               // VLAN TPID
                __be16 vlan_eth_type;           // VLAN 以太类型
                u16 padding;                    // 填充
            } vlan;
            struct flow_dissector_key_vlan {
                union {
                    struct {
                        u16 vlan_id : 12;       // VLAN ID
                        u16 vlan_dei : 1;       // VLAN DEI
                        u16 vlan_priority : 3;  // VLAN 优先级
                    };
                    __be16 vlan_tci;            // VLAN TCI
                };
                __be16 vlan_tpid;               // VLAN TPID
                __be16 vlan_eth_type;           // VLAN 以太类型
                u16 padding;                    // 填充
            } cvlan;
            struct flow_dissector_key_eth_addrs {
                unsigned char dst[6];           // 目的 MAC
                unsigned char src[6];           // 源 MAC
            } eth_addrs;
            struct flow_dissector_key_meta {
                int ingress_ifindex;            // 入口接口索引
                u16 ingress_iftype;             // 入口接口类型
                u8 l2_miss;                     // L2 缺失
            } meta;
        } key;
        struct nft_flow_key {
            struct flow_dissector_key_basic {
                __be16 n_proto;                 // 网络协议
                u8 ip_proto;                    // IP 协议
                u8 padding;                     // 填充
            } basic;
            struct flow_dissector_key_control {
                u16 thoff;                      // 传输头偏移
                u16 addr_type;                  // 地址类型
                u32 flags;                      // 标志
            } control;
            union {
                struct flow_dissector_key_ipv4_addrs {
                    __be32 src;                 // 源地址
                    __be32 dst;                 // 目的地址
                } ipv4;
                struct flow_dissector_key_ipv6_addrs {
                    struct in6_addr {
                        union {
                            __u8 u6_addr8[16];  // 8 位数组
                            __be16 u6_addr16[8]; // 16 位数组
                            __be32 u6_addr32[4]; // 32 位数组
                        } in6_u;
                    } src;
                    struct in6_addr {
                        union {
                            __u8 u6_addr8[16];  // 8 位数组
                            __be16 u6_addr16[8]; // 16 位数组
                            __be32 u6_addr32[4]; // 32 位数组
                        } in6_u;
                    } dst;
                } ipv6;
            };
            struct flow_dissector_key_ports {
                union {
                    __be32 ports;               // 端口
                    struct {
                        __be16 src;             // 源端口
                        __be16 dst;             // 目的端口
                    };
                };
            } tp;
            struct flow_dissector_key_ip {
                __u8 tos;                       // TOS
                __u8 ttl;                       // TTL
            } ip;
            struct flow_dissector_key_vlan {
                union {
                    struct {
                        u16 vlan_id : 12;       // VLAN ID
                        u16 vlan_dei : 1;       // VLAN DEI
                        u16 vlan_priority : 3;  // VLAN 优先级
                    };
                    __be16 vlan_tci;            // VLAN TCI
                };
                __be16 vlan_tpid;               // VLAN TPID
                __be16 vlan_eth_type;           // VLAN 以太类型
                u16 padding;                    // 填充
            } vlan;
            struct flow_dissector_key_vlan {
                union {
                    struct {
                        u16 vlan_id : 12;       // VLAN ID
                        u16 vlan_dei : 1;       // VLAN DEI
                        u16 vlan_priority : 3;  // VLAN 优先级
                    };
                    __be16 vlan_tci;            // VLAN TCI
                };
                __be16 vlan_tpid;               // VLAN TPID
                __be16 vlan_eth_type;           // VLAN 以太类型
                u16 padding;                    // 填充
            } cvlan;
            struct flow_dissector_key_eth_addrs {
                unsigned char dst[6];           // 目的 MAC
                unsigned char src[6];           // 源 MAC
            } eth_addrs;
            struct flow_dissector_key_meta {
                int ingress_ifindex;            // 入口接口索引
                u16 ingress_iftype;             // 入口接口类型
                u8 l2_miss;                     // L2 缺失
            } meta;
        } mask;
    } match;
    struct flow_rule *rule;           // 流规则
};

struct nft_expr {
    const struct nft_expr_ops *ops;   // 操作
    unsigned char data[];             // 柔性数据
};

struct nft_table {
    struct list_head list;            // 表链表
    struct rhltable {
        struct rhashtable {
            struct bucket_table *tbl;   // 桶表
            unsigned int key_len;       // 键长度
            unsigned int max_elems;     // 最大元素
            struct rhashtable_params {
                u16 nelem_hint;         // 元素数提示
                u16 key_len;            // 键长度
                u16 key_offset;         // 键偏移
                u16 head_offset;        // 头偏移
                unsigned int max_size;  // 最大大小
                u16 min_size;           // 最小大小
                bool automatic_shrinking; // 自动收缩
                rht_hashfn_t hashfn;    // 哈希函数
                rht_obj_hashfn_t obj_hashfn; // 对象哈希函数
                rht_obj_cmpfn_t obj_cmpfn;   // 对象比较函数
            } p;
            bool rhlist;                // rhlist 标志
            struct work_struct {
                atomic_long_t data;     // 数据
                struct list_head {
                    struct list_head *next; // 下一个
                    struct list_head *prev; // 上一个
                } entry;
                work_func_t func;       // 函数
            } run_work;
            struct mutex {
                atomic_long_t owner;    // 所有者
                raw_spinlock_t wait_lock; // 等待锁
                struct optimistic_spin_queue {
                    atomic_t tail;      // 尾部
                } osq;
                struct list_head {
                    struct list_head *next; // 下一个
                    struct list_head *prev; // 上一个
                } wait_list;
            } mutex;
            spinlock_t lock;            // 锁
            atomic_t nelems;            // 元素数
        } ht;
    } chains_ht;
    struct list_head chains;          // 链链表
    struct list_head sets;            // 集合链表
    struct list_head objects;         // 对象链表
    struct list_head flowtables;      // 流表链表
    u64 hgenerator;                   // 句柄生成器
    u64 handle;                       // 句柄
    u32 use;                          // 使用计数
    u16 family : 6;                   // 协议族
    u16 flags : 8;                    // 标志
    u16 genmask : 2;                  // 生成掩码
    u32 nlpid;                        // netlink 端口 ID
    char *name;                       // 名称
    u16 udlen;                        // 用户数据长度
    u8 *udata;                        // 用户数据
    u8 validate_state;                // 校验状态
};

struct nft_chain {
    struct nft_rule_blob *blob_gen_0; // 规则 blob 0
    struct nft_rule_blob *blob_gen_1; // 规则 blob 1
    struct list_head rules;           // 规则链表
    struct list_head list;            // 链表节点
    struct rhlist_head rhlhead;       // 哈希节点
    struct nft_table *table;          // 所属表
    u64 handle;                       // 句柄
    u32 use;                          // 使用计数
    u8 flags : 5;                     // 标志
    u8 bound : 1;                     // 绑定标志
    u8 genmask : 2;                   // 生成掩码
    char *name;                       // 名称
    u16 udlen;                        // 用户数据长度
    u8 *udata;                        // 用户数据
    struct nft_rule_blob *blob_next;  // 下一个 blob
};

struct nft_trans {
    struct list_head list;            // 链表节点
    struct list_head binding_list;    // 绑定链表
    int msg_type;                     // 消息类型
    bool put_net;                     // put_net 标志
    struct nft_ctx ctx;               // 上下文
    char data[];                      // 柔性数据
};

struct nft_ctx {
    struct net *net;                  // 网络
    struct nft_table *table;          // 表
    struct nft_chain *chain;          // 链
    const struct nlattr * const *nla; // 属性数组
    u32 portid;                       // 端口 ID
    u32 seq;                          // 序列号
    u16 flags;                        // 标志
    u8 family;                        // 协议族
    u8 level;                         // 层级
    bool report;                      // 报告标志
};

struct nft_userdata {
    u8 len;                           // 长度
    unsigned char data[];             // 柔性数据
};

struct nft_immediate_expr {
    struct nft_data data;             // 数据
    u8 dreg;                          // 目标寄存器
    u8 dlen;                          // 数据长度
};

struct nft_data {
    union {
        u32 data[4];                  // 普通数据
        struct nft_verdict verdict;   // verdict
    };
};

struct nft_data_desc {
    enum nft_data_types type;         // 类型
    unsigned int size;                // 大小
    unsigned int len;                 // 长度
    unsigned int flags;               // 标志
};

struct nft_verdict {
    u32 code;                         // verdict 码
    struct nft_chain *chain;          // 目标链
};

struct nft_expr_ops {
    void (*eval)(const struct nft_expr *, struct nft_regs *, const struct nft_pktinfo *); // 求值
    int (*clone)(struct nft_expr *, const struct nft_expr *); // 克隆
    unsigned int size;                // 大小
    int (*init)(const struct nft_ctx *, const struct nft_expr *, const struct nlattr * const *); // 初始化
    void (*activate)(const struct nft_ctx *, const struct nft_expr *); // 激活
    void (*deactivate)(const struct nft_ctx *, const struct nft_expr *, enum nft_trans_phase); // 去激活
    void (*destroy)(const struct nft_ctx *, const struct nft_expr *); // 销毁
    void (*destroy_clone)(const struct nft_ctx *, const struct nft_expr *); // 销毁克隆
    int (*dump)(struct sk_buff *, const struct nft_expr *, bool); // 转储
    int (*validate)(const struct nft_ctx *, const struct nft_expr *, const struct nft_data **); // 校验
    bool (*reduce)(const struct nft_regs_track *, const struct nft_expr *); // 归约
    bool (*gc)(struct net *, const struct nft_expr *); // GC
    int (*offload)(struct nft_offload_ctx *, struct nft_flow_rule *, const struct nft_expr *); // 卸载
    bool (*offload_action)(const struct nft_expr *); // 卸载动作
    void (*offload_stats)(struct nft_expr *, const struct flow_stats *); // 卸载统计
    const struct nft_expr_type *type; // 类型
    void *data;                       // 数据
};

struct sk_buff {
    union {
        struct {
            struct sk_buff *next;     // 下一个
            struct sk_buff *prev;     // 上一个
            union {
                struct net_device *dev; // 设备
                unsigned long dev_scratch; // 设备暂存
            };
        };
        struct rb_node {
            unsigned long __rb_parent_color; // 父颜色
            struct rb_node *rb_right;        // 右子节点
            struct rb_node *rb_left;         // 左子节点
        } rbnode;
        struct list_head {
            struct list_head *next;   // 下一个
            struct list_head *prev;   // 上一个
        } list;
        struct llist_node {
            struct llist_node *next;  // 下一个
        } ll_node;
    };
    union {
        struct sock *sk;              // 套接字
        int ip_defrag_offset;         // IP 分片偏移
    };
    union {
        ktime_t tstamp;               // 时间戳
        u64 skb_mstamp_ns;            // 单调时间戳
    };
    char cb[48];                      // 控制缓冲区
    union {
        struct {
            unsigned long _skb_refdst; // 引用目标
            void (*destructor)(struct sk_buff *); // 析构函数
        };
        struct list_head {
            struct list_head *next;   // 下一个
            struct list_head *prev;   // 上一个
        } tcp_tsorted_anchor;
        unsigned long _sk_redir;      // 重定向
    };
    unsigned long _nfct;              // netfilter 连接跟踪
    unsigned int len;                 // 长度
    unsigned int data_len;            // 数据长度
    __u16 mac_len;                    // MAC 长度
    __u16 hdr_len;                    // 头长度
    __u16 queue_mapping;              // 队列映射
    __u8 cloned : 1;                  // 克隆标志
    __u8 nohdr : 1;                   // 无头标志
    __u8 fclone : 2;                  // 快速克隆
    __u8 peeked : 1;                  // 窥视标志
    __u8 head_frag : 1;               // 头部来自分片
    __u8 pfmemalloc : 1;              // PFMEMALLOC
    __u8 pp_recycle : 1;              // 页池回收
    __u8 active_extensions;           // 活动扩展
    union {
        struct {
            __u8 pkt_type : 3;        // 包类型
            __u8 ignore_df : 1;       // 忽略 DF
            __u8 dst_pending_confirm : 1; // 目标待确认
            __u8 ip_summed : 2;       // IP 校验
            __u8 ooo_okay : 1;        // 乱序允许
            __u8 mono_delivery_time : 1; // 单调交付时间
            __u8 tc_at_ingress : 1;   // TC 入口
            __u8 tc_skip_classify : 1; // TC 跳过分类
            __u8 remcsum_offload : 1; // 远程校验卸载
            __u8 csum_complete_sw : 1; // 软件校验完成
            __u8 csum_level : 2;      // 校验级别
            __u8 inner_protocol_type : 1; // 内部协议类型
            __u8 l4_hash : 1;         // L4 哈希
            __u8 sw_hash : 1;         // 软件哈希
            __u8 wifi_acked_valid : 1; // WiFi 确认有效
            __u8 wifi_acked : 1;      // WiFi 确认
            __u8 no_fcs : 1;          // 无 FCS
            __u8 encapsulation : 1;   // 封装
            __u8 encap_hdr_csum : 1;  // 封装头校验
            __u8 csum_valid : 1;      // 校验有效
            __u8 ndisc_nodetype : 2;  // NDISC 节点类型
            __u8 ipvs_property : 1;   // IPVS 属性
            __u8 nf_trace : 1;        // netfilter 跟踪
            __u8 offload_fwd_mark : 1; // 卸载转发标记
            __u8 offload_l3_fwd_mark : 1; // 卸载 L3 转发标记
            __u8 redirected : 1;      // 重定向
            __u8 from_ingress : 1;    // 来自入口
            __u8 nf_skip_egress : 1;  // 跳过出口
            __u8 decrypted : 1;       // 已解密
            __u8 slow_gro : 1;        // 慢 GRO
            __u8 csum_not_inet : 1;   // 非 INET 校验
            __u16 tc_index;           // TC 索引
            u16 alloc_cpu;            // 分配 CPU
            union {
                __wsum csum;          // 校验和
                struct {
                    __u16 csum_start; // 校验起始
                    __u16 csum_offset; // 校验偏移
                };
            };
            __u32 priority;           // 优先级
            int skb_iif;              // 入接口索引
            __u32 hash;               // 哈希
            union {
                u32 vlan_all;         // VLAN 全部
                struct {
                    __be16 vlan_proto; // VLAN 协议
                    __u16 vlan_tci;    // VLAN TCI
                };
            };
            union {
                unsigned int napi_id; // NAPI ID
                unsigned int sender_cpu; // 发送 CPU
            };
            __u32 secmark;            // 安全标记
            union {
                __u32 mark;           // 标记
                __u32 reserved_tailroom; // 保留尾部空间
            };
            union {
                __be16 inner_protocol; // 内部协议
                __u8 inner_ipproto;    // 内部 IP 协议
            };
            __u16 inner_transport_header; // 内部传输头
            __u16 inner_network_header;   // 内部网络头
            __u16 inner_mac_header;       // 内部 MAC 头
            __be16 protocol;              // 协议
            __u16 transport_header;       // 传输头
            __u16 network_header;         // 网络头
            __u16 mac_header;             // MAC 头
        } headers;
    };
    sk_buff_data_t tail;              // 尾部
    sk_buff_data_t end;               // 结束
    unsigned char *head;              // 头指针
    unsigned char *data;              // 数据指针
    unsigned int truesize;            // 真实大小
    refcount_t users;                 // 用户引用计数
    struct skb_ext *extensions;       // 扩展
};

struct skb_shared_info {
    __u8 flags;                       // 标志
    __u8 meta_len;                    // 元数据长度
    __u8 nr_frags;                    // 分片数量
    __u8 tx_flags;                    // 发送标志
    unsigned short gso_size;          // GSO 大小
    unsigned short gso_segs;          // GSO 分段
    struct sk_buff *frag_list;        // 分片链表
    struct skb_shared_hwtstamps {
        union {
            ktime_t hwtstamp;         // 硬件时间戳
            void *netdev_data;        // 网络设备数据
        };
    } hwtstamps;
    unsigned int gso_type;            // GSO 类型
    u32 tskey;                        // 时间戳键
    atomic_t dataref;                 // 数据引用计数
    unsigned int xdp_frags_size;      // XDP 分片大小
    void *destructor_arg;             // 析构参数
    skb_frag_t frags[17];             // 分片数组
};

struct napi_struct {
    struct list_head {
        struct list_head *next;       // 下一个
        struct list_head *prev;       // 上一个
    } poll_list;
    unsigned long state;              // 状态
    int weight;                       // 权重
    int defer_hard_irqs_count;        // 延迟硬中断计数
    unsigned long gro_bitmask;        // GRO 位掩码
    int (*poll)(struct napi_struct *, int); // 轮询函数
    int poll_owner;                   // 轮询所有者
    int list_owner;                   // 链表所有者
    struct net_device *dev;           // 设备
    struct gro_list gro_hash[8];      // GRO 哈希
    struct sk_buff *skb;              // skb
    struct list_head {
        struct list_head *next;       // 下一个
        struct list_head *prev;       // 上一个
    } rx_list;
    int rx_count;                     // 接收计数
    unsigned int napi_id;             // NAPI ID
    struct hrtimer {
        struct timerqueue_node {
            struct rb_node {
                unsigned long __rb_parent_color; // 父颜色
                struct rb_node *rb_right;        // 右子节点
                struct rb_node *rb_left;         // 左子节点
            } node;
            ktime_t expires;          // 过期时间
        } node;
        ktime_t _softexpires;         // 软过期时间
        enum hrtimer_restart (*function)(struct hrtimer *); // 函数
        struct hrtimer_clock_base *base; // 时钟基
        u8 state;                     // 状态
        u8 is_rel;                    // 相对
        u8 is_soft;                   // 软
        u8 is_hard;                   // 硬
    } timer;
    struct task_struct *thread;       // 线程
    struct list_head {
        struct list_head *next;       // 下一个
        struct list_head *prev;       // 上一个
    } dev_list;
    struct hlist_node {
        struct hlist_node *next;      // 下一个
        struct hlist_node **pprev;    // 前一个的指针
    } napi_hash_node;
};

struct softnet_data {
    struct list_head {
        struct list_head *next;       // 下一个
        struct list_head *prev;       // 上一个
    } poll_list;
    struct sk_buff_head {
        union {
            struct {
                struct sk_buff *next; // 下一个
                struct sk_buff *prev; // 上一个
            };
            struct sk_buff_list {
                struct sk_buff *next; // 下一个
                struct sk_buff *prev; // 上一个
            } list;
        };
        __u32 qlen;                   // 队列长度
        spinlock_t lock;              // 锁
    } process_queue;
    unsigned int processed;           // 已处理
    unsigned int time_squeeze;        // 时间挤压
    struct softnet_data *rps_ipi_list; // RPS IPI 链表
    bool in_net_rx_action;            // 在 net_rx_action 中
    bool in_napi_threaded_poll;       // 在 NAPI 线程轮询中
    struct sd_flow_limit *flow_limit; // 流限制
    struct Qdisc *output_queue;       // 输出队列
    struct Qdisc **output_queue_tailp; // 输出队列尾
    struct sk_buff *completion_queue; // 完成队列
    struct sk_buff_head {
        union {
            struct {
                struct sk_buff *next; // 下一个
                struct sk_buff *prev; // 上一个
            };
            struct sk_buff_list {
                struct sk_buff *next; // 下一个
                struct sk_buff *prev; // 上一个
            } list;
        };
        __u32 qlen;                   // 队列长度
        spinlock_t lock;              // 锁
    } xfrm_backlog;
    struct {
        u16 recursion;                // 递归
        u8 more;                      // 更多
        u8 skip_txqueue;              // 跳过发送队列
    } xmit;
    unsigned int input_queue_head;    // 输入队列头
    call_single_data_t csd;           // CSD
    struct softnet_data *rps_ipi_next; // RPS IPI 下一个
    unsigned int cpu;                 // CPU
    unsigned int input_queue_tail;    // 输入队列尾
    unsigned int received_rps;        // 接收 RPS
    unsigned int dropped;             // 丢弃
    struct sk_buff_head {
        union {
            struct {
                struct sk_buff *next; // 下一个
                struct sk_buff *prev; // 上一个
            };
            struct sk_buff_list {
                struct sk_buff *next; // 下一个
                struct sk_buff *prev; // 上一个
            } list;
        };
        __u32 qlen;                   // 队列长度
        spinlock_t lock;              // 锁
    } input_pkt_queue;
    struct napi_struct {
        struct list_head {
            struct list_head *next;   // 下一个
            struct list_head *prev;   // 上一个
        } poll_list;
        unsigned long state;          // 状态
        int weight;                   // 权重
        int defer_hard_irqs_count;    // 延迟硬中断计数
        unsigned long gro_bitmask;    // GRO 位掩码
        int (*poll)(struct napi_struct *, int); // 轮询函数
        int poll_owner;               // 轮询所有者
        int list_owner;               // 链表所有者
        struct net_device *dev;       // 设备
        struct gro_list gro_hash[8];  // GRO 哈希
        struct sk_buff *skb;          // skb
        struct list_head {
            struct list_head *next;   // 下一个
            struct list_head *prev;   // 上一个
        } rx_list;
        int rx_count;                 // 接收计数
        unsigned int napi_id;         // NAPI ID
        struct hrtimer {
            struct timerqueue_node {
                struct rb_node {
                    unsigned long __rb_parent_color; // 父颜色
                    struct rb_node *rb_right;        // 右子节点
                    struct rb_node *rb_left;         // 左子节点
                } node;
                ktime_t expires;      // 过期时间
            } node;
            ktime_t _softexpires;     // 软过期时间
            enum hrtimer_restart (*function)(struct hrtimer *); // 函数
            struct hrtimer_clock_base *base; // 时钟基
            u8 state;                 // 状态
            u8 is_rel;                // 相对
            u8 is_soft;               // 软
            u8 is_hard;               // 硬
        } timer;
        struct task_struct *thread;   // 线程
        struct list_head {
            struct list_head *next;   // 下一个
            struct list_head *prev;   // 上一个
        } dev_list;
        struct hlist_node {
            struct hlist_node *next;  // 下一个
            struct hlist_node **pprev; // 前一个的指针
        } napi_hash_node;
    } backlog;
    spinlock_t defer_lock;            // 延迟锁
    int defer_count;                  // 延迟计数
    int defer_ipi_scheduled;          // 延迟 IPI 调度
    struct sk_buff *defer_list;       // 延迟链表
    call_single_data_t defer_csd;     // 延迟 CSD
};

struct packet_type {
    __be16 type;                      // 类型
    bool ignore_outgoing;             // 忽略发出
    struct net_device *dev;           // 设备
    int (*func)(struct sk_buff *, struct net_device *, struct packet_type *, struct net_device *); // 处理函数
    void (*list_func)(struct list_head *, struct packet_type *, struct net_device *); // 链表函数
    bool (*id_match)(struct packet_type *, struct sock *); // ID 匹配
    struct net *af_packet_net;        // AF_PACKET 网络
    void *af_packet_priv;             // AF_PACKET 私有
    struct list_head {
        struct list_head *next;       // 下一个
        struct list_head *prev;       // 上一个
    } list;
};

struct sock {
    struct sock_common __sk_common;   // 公共部分，内部字段省略
    struct dst_entry *sk_rx_dst;      // 接收目标
    int sk_rx_dst_ifindex;            // 接收目标接口索引
    u32 sk_rx_dst_cookie;             // 接收目标 cookie
    socket_lock_t sk_lock;            // 套接字锁
    atomic_t sk_drops;                // 丢弃计数
    int sk_rcvlowat;                  // 接收低水位
    struct sk_buff_head sk_error_queue; // 错误队列
    struct sk_buff_head sk_receive_queue; // 接收队列
    struct {
        atomic_t rmem_alloc;          // 接收内存分配
        int len;                      // 长度
        struct sk_buff *head;         // 头
        struct sk_buff *tail;         // 尾
    } sk_backlog;
    int sk_forward_alloc;             // 前向分配
    u32 sk_reserved_mem;              // 保留内存
    unsigned int sk_ll_usec;          // 低延迟使用
    unsigned int sk_napi_id;          // NAPI ID
    int sk_rcvbuf;                    // 接收缓冲区
    int sk_disconnects;               // 断开连接
    struct sk_filter *sk_filter;      // 过滤器
    union {
        struct socket_wq *sk_wq;      // 等待队列
        struct socket_wq *sk_wq_raw;  // 原始等待队列
    };
    struct xfrm_policy *sk_policy[2]; // 策略
    struct dst_entry *sk_dst_cache;   // 目标缓存
    atomic_t sk_omem_alloc;           // 其他内存分配
    int sk_sndbuf;                    // 发送缓冲区
    int sk_wmem_queued;               // 写内存队列
    refcount_t sk_wmem_alloc;         // 写内存分配
    unsigned long sk_tsq_flags;       // TSQ 标志
    union {
        struct sk_buff *sk_send_head; // 发送头
        struct rb_root {
            struct rb_node *rb_node;  // 红黑树节点
        } tcp_rtx_queue;
    };
    struct sk_buff_head sk_write_queue; // 写队列
    __s32 sk_peek_off;                // 窥视偏移
    int sk_write_pending;             // 写挂起
    __u32 sk_dst_pending_confirm;     // 目标待确认
    u32 sk_pacing_status;             // 节奏状态
    long sk_sndtimeo;                 // 发送超时
    struct timer_list {
        struct hlist_node {
            struct hlist_node *next;  // 下一个
            struct hlist_node **pprev; // 前一个的指针
        } entry;
        unsigned long expires;        // 过期时间
        void (*function)(struct timer_list *); // 函数
        u32 flags;                    // 标志
    } sk_timer;
    __u32 sk_priority;                // 优先级
    __u32 sk_mark;                    // 标记
    unsigned long sk_pacing_rate;     // 节奏速率
    unsigned long sk_max_pacing_rate; // 最大节奏速率
    struct page_frag {
        struct page *page;            // 页
        __u32 offset;                 // 偏移
        __u32 size;                   // 大小
    } sk_frag;
    netdev_features_t sk_route_caps;  // 路由能力
    int sk_gso_type;                  // GSO 类型
    unsigned int sk_gso_max_size;     // GSO 最大大小
    gfp_t sk_allocation;              // 分配标志
    __u32 sk_txhash;                  // 发送哈希
    u8 sk_gso_disabled : 1;           // GSO 禁用
    u8 sk_kern_sock : 1;              // 内核套接字
    u8 sk_no_check_tx : 1;            // 无校验发送
    u8 sk_no_check_rx : 1;            // 无校验接收
    u8 sk_userlocks : 4;              // 用户锁
    u8 sk_pacing_shift;               // 节奏偏移
    u16 sk_type;                      // 类型
    u16 sk_protocol;                  // 协议
    u16 sk_gso_max_segs;              // GSO 最大分段
    unsigned long sk_lingertime;      // 延迟时间
    struct proto *sk_prot_creator;    // 协议创建者
    rwlock_t sk_callback_lock;        // 回调锁
    int sk_err;                       // 错误
    int sk_err_soft;                  // 软错误
    u32 sk_ack_backlog;               // 确认 backlog
    u32 sk_max_ack_backlog;           // 最大确认 backlog
    kuid_t sk_uid;                    // UID
    u8 sk_txrehash;                   // 发送重哈希
    u8 sk_prefer_busy_poll;           // 偏好忙轮询
    u16 sk_busy_poll_budget;          // 忙轮询预算
    spinlock_t sk_peer_lock;          // 对等锁
    int sk_bind_phc;                  // 绑定 PHC
    struct pid *sk_peer_pid;          // 对等 PID
    const struct cred *sk_peer_cred;  // 对等凭证
    long sk_rcvtimeo;                 // 接收超时
    ktime_t sk_stamp;                 // 时间戳
    atomic_t sk_tskey;                // 时间戳键
    atomic_t sk_zckey;                // 零拷贝键
    u32 sk_tsflags;                   // 时间戳标志
    u8 sk_shutdown;                   // 关闭
    u8 sk_clockid;                    // 时钟 ID
    u8 sk_txtime_deadline_mode : 1;   // TXTIME 截止模式
    u8 sk_txtime_report_errors : 1;   // TXTIME 报告错误
    u8 sk_txtime_unused : 6;          // TXTIME 未使用
    bool sk_use_task_frag;            // 使用任务分片
    struct socket *sk_socket;         // 套接字
    void *sk_user_data;               // 用户数据
    void *sk_security;                // 安全
    struct sock_cgroup_data {
        struct cgroup *cgroup;        // cgroup
        u32 classid;                  // 类 ID
        u16 prioidx;                  // 优先级索引
    } sk_cgrp_data;
    struct mem_cgroup *sk_memcg;      // memcg
    void (*sk_state_change)(struct sock *); // 状态改变
    void (*sk_data_ready)(struct sock *);   // 数据就绪
    void (*sk_write_space)(struct sock *);  // 写空间
    void (*sk_error_report)(struct sock *); // 错误报告
    int (*sk_backlog_rcv)(struct sock *, struct sk_buff *); // backlog 接收
    struct sk_buff *(*sk_validate_xmit_skb)(struct sock *, struct net_device *, struct sk_buff *); // 验证发送 skb
    void (*sk_destruct)(struct sock *); // 析构
    struct sock_reuseport *sk_reuseport_cb; // 重用端口 cb
    struct bpf_local_storage *sk_bpf_storage; // BPF 本地存储
    struct callback_head {
        struct callback_head *next;   // 下一个
        void (*func)(struct callback_head *); // 函数
    } sk_rcu;
    struct hlist_node {
        struct hlist_node *next;      // 下一个
        struct hlist_node **pprev;    // 前一个的指针
    } sk_bind2_node;
};

struct socket {
    socket_state state;               // 状态
    short type;                       // 类型
    unsigned long flags;              // 标志
    struct file *file;                // 文件
    struct sock *sk;                  // 套接字
    const struct proto_ops *ops;      // 操作
    struct socket_wq {
        wait_queue_head_t wait;       // 等待队列头
        struct fasync_struct *fasync_list; // 异步链表
        unsigned long flags;          // 标志
        struct callback_head {
            struct callback_head *next; // 下一个
            void (*func)(struct callback_head *); // 函数
        } rcu;
    } wq;
};

struct nf_hook_entries {
    u16 num_hook_entries;             // 钩子数量
    struct nf_hook_entry hooks[];     // 钩子数组
};

struct nf_hook_state {
    u8 hook;                          // 钩子
    u8 pf;                            // 协议族
    struct net_device *in;            // 输入设备
    struct net_device *out;           // 输出设备
    struct sock *sk;                  // 套接字
    struct net *net;                  // 网络
    int (*okfn)(struct net *, struct sock *, struct sk_buff *); // okfn
};

struct ipq {
    struct inet_frag_queue {
        struct rhash_head {
            struct rhash_head *next;  // 下一个
        } node;
        union {
            struct frag_v4_compare_key {
                __be32 saddr;         // 源地址
                __be32 daddr;         // 目的地址
                u32 user;             // 用户
                u32 vif;              // 虚拟接口
                __be16 id;            // ID
                u16 protocol;         // 协议
            } v4;
            struct frag_v6_compare_key {
                struct in6_addr {
                    union {
                        __u8 u6_addr8[16]; // 8 位数组
                        __be16 u6_addr16[8]; // 16 位数组
                        __be32 u6_addr32[4]; // 32 位数组
                    } in6_u;
                } saddr;
                struct in6_addr {
                    union {
                        __u8 u6_addr8[16]; // 8 位数组
                        __be16 u6_addr16[8]; // 16 位数组
                        __be32 u6_addr32[4]; // 32 位数组
                    } in6_u;
                } daddr;
                u32 user;             // 用户
                __be32 id;            // ID
                u32 iif;              // 入接口索引
            } v6;
        } key;
        struct timer_list {
            struct hlist_node {
                struct hlist_node *next; // 下一个
                struct hlist_node **pprev; // 前一个的指针
            } entry;
            unsigned long expires;    // 过期时间
            void (*function)(struct timer_list *); // 函数
            u32 flags;                // 标志
        } timer;
        spinlock_t lock;              // 锁
        refcount_t refcnt;            // 引用计数
        struct rb_root {
            struct rb_node *rb_node;  // 红黑树节点
        } rb_fragments;
        struct sk_buff *fragments_tail; // 分片尾
        struct sk_buff *last_run_head;  // 最后运行头
        ktime_t stamp;                // 时间戳
        int len;                      // 长度
        int meat;                     // 肉
        u8 mono_delivery_time;        // 单调交付时间
        __u8 flags;                   // 标志
        u16 max_size;                 // 最大大小
        struct fqdir *fqdir;          // 分片目录
        struct callback_head {
            struct callback_head *next; // 下一个
            void (*func)(struct callback_head *); // 函数
        } rcu;
    } q;
    u8 ecn;                           // ECN
    u16 max_df_size;                  // 最大 DF 大小
    int iif;                          // 入接口索引
    unsigned int rid;                 // 随机 ID
    struct inet_peer *peer;           // 对等节点
};

struct inet_frag_queue {
    struct rhash_head {
        struct rhash_head *next;      // 下一个
    } node;
    union {
        struct frag_v4_compare_key {
            __be32 saddr;             // 源地址
            __be32 daddr;             // 目的地址
            u32 user;                 // 用户
            u32 vif;                  // 虚拟接口
            __be16 id;                // ID
            u16 protocol;             // 协议
        } v4;
        struct frag_v6_compare_key {
            struct in6_addr {
                union {
                    __u8 u6_addr8[16]; // 8 位数组
                    __be16 u6_addr16[8]; // 16 位数组
                    __be32 u6_addr32[4]; // 32 位数组
                } in6_u;
            } saddr;
            struct in6_addr {
                union {
                    __u8 u6_addr8[16]; // 8 位数组
                    __be16 u6_addr16[8]; // 16 位数组
                    __be32 u6_addr32[4]; // 32 位数组
                } in6_u;
            } daddr;
            u32 user;                 // 用户
            __be32 id;                // ID
            u32 iif;                  // 入接口索引
        } v6;
    } key;
    struct timer_list {
        struct hlist_node {
            struct hlist_node *next;  // 下一个
            struct hlist_node **pprev; // 前一个的指针
        } entry;
        unsigned long expires;        // 过期时间
        void (*function)(struct timer_list *); // 函数
        u32 flags;                    // 标志
    } timer;
    spinlock_t lock;                  // 锁
    refcount_t refcnt;                // 引用计数
    struct rb_root {
        struct rb_node *rb_node;      // 红黑树节点
    } rb_fragments;
    struct sk_buff *fragments_tail;   // 分片尾
    struct sk_buff *last_run_head;    // 最后运行头
    ktime_t stamp;                    // 时间戳
    int len;                          // 长度
    int meat;                         // 肉
    u8 mono_delivery_time;            // 单调交付时间
    __u8 flags;                       // 标志
    u16 max_size;                     // 最大大小
    struct fqdir *fqdir;              // 分片目录
    struct callback_head {
        struct callback_head *next;   // 下一个
        void (*func)(struct callback_head *); // 函数
    } rcu;
};

struct inet_frags {
    unsigned int qsize;               // 队列大小
    void (*constructor)(struct inet_frag_queue *, const void *); // 构造函数
    void (*destructor)(struct inet_frag_queue *); // 析构函数
    void (*frag_expire)(struct timer_list *); // 分片过期
    struct kmem_cache *frags_cachep;  // 分片缓存
    const char *frags_cache_name;     // 分片缓存名
    struct rhashtable_params {
        u16 nelem_hint;               // 元素数提示
        u16 key_len;                  // 键长度
        u16 key_offset;               // 键偏移
        u16 head_offset;              // 头偏移
        unsigned int max_size;        // 最大大小
        u16 min_size;                 // 最小大小
        bool automatic_shrinking;     // 自动收缩
        rht_hashfn_t hashfn;          // 哈希函数
        rht_obj_hashfn_t obj_hashfn;  // 对象哈希函数
        rht_obj_cmpfn_t obj_cmpfn;    // 对象比较函数
    } rhash_params;
    refcount_t refcnt;                // 引用计数
    struct completion {
        unsigned int done;            // 完成
        struct swait_queue_head {
            raw_spinlock_t lock;      // 锁
            struct list_head {
                struct list_head *next; // 下一个
                struct list_head *prev; // 上一个
            } task_list;
        } wait;
    } completion;
};

struct fqdir {
    long high_thresh;                 // 高阈值
    long low_thresh;                  // 低阈值
    int timeout;                      // 超时
    int max_dist;                     // 最大距离
    struct inet_frags *f;             // 分片操作
    struct net *net;                  // 网络
    bool dead;                        // 死亡标志
    struct rhashtable {
        struct bucket_table *tbl;     // 桶表
        unsigned int key_len;         // 键长度
        unsigned int max_elems;       // 最大元素
        struct rhashtable_params {
            u16 nelem_hint;           // 元素数提示
            u16 key_len;              // 键长度
            u16 key_offset;           // 键偏移
            u16 head_offset;          // 头偏移
            unsigned int max_size;    // 最大大小
            u16 min_size;             // 最小大小
            bool automatic_shrinking; // 自动收缩
            rht_hashfn_t hashfn;      // 哈希函数
            rht_obj_hashfn_t obj_hashfn; // 对象哈希函数
            rht_obj_cmpfn_t obj_cmpfn;   // 对象比较函数
        } p;
        bool rhlist;                  // rhlist 标志
        struct work_struct {
            atomic_long_t data;       // 数据
            struct list_head {
                struct list_head *next; // 下一个
                struct list_head *prev; // 上一个
            } entry;
            work_func_t func;         // 函数
        } run_work;
        struct mutex {
            atomic_long_t owner;      // 所有者
            raw_spinlock_t wait_lock; // 等待锁
            struct optimistic_spin_queue {
                atomic_t tail;        // 尾部
            } osq;
            struct list_head {
                struct list_head *next; // 下一个
                struct list_head *prev; // 上一个
            } wait_list;
        } mutex;
        spinlock_t lock;              // 锁
        atomic_t nelems;              // 元素数
    } rhashtable;
    atomic_long_t mem;                // 内存
    struct work_struct {
        atomic_long_t data;           // 数据
        struct list_head {
            struct list_head *next;   // 下一个
            struct list_head *prev;   // 上一个
        } entry;
        work_func_t func;             // 函数
    } destroy_work;
    struct llist_node {
        struct llist_node *next;      // 下一个
    } free_list;
};

struct rb_root {
    struct rb_node *rb_node;          // 红黑树节点
};

struct rb_node {
    unsigned long __rb_parent_color;  // 父颜色
    struct rb_node *rb_right;         // 右子节点
    struct rb_node *rb_left;          // 左子节点
};

struct page {
    unsigned long flags;              // 标志
    union {
        struct {
            union {
                struct list_head {
                    struct list_head *next; // 下一个
                    struct list_head *prev; // 上一个
                } lru;
                struct {
                    void *__filler;   // 填充
                    unsigned int mlock_count; // 锁定计数
                };
                struct list_head {
                    struct list_head *next; // 下一个
                    struct list_head *prev; // 上一个
                } buddy_list;
                struct list_head {
                    struct list_head *next; // 下一个
                    struct list_head *prev; // 上一个
                } pcp_list;
            };
            struct address_space *mapping; // 映射
            union {
                unsigned long index; // 索引
                unsigned long share; // 共享
            };
            unsigned long private; // 私有
        };
        struct {
            unsigned long pp_magic; // 页池魔数
            struct page_pool *pp;   // 页池
            unsigned long _pp_mapping_pad; // 页池映射填充
            unsigned long dma_addr; // DMA 地址
            union {
                unsigned long dma_addr_upper; // DMA 地址高位
                atomic_long_t pp_frag_count;  // 页池分片计数
            };
        };
        struct {
            unsigned long compound_head; // 复合头
        };
        struct {
            struct dev_pagemap *pgmap; // 设备页映射
            void *zone_device_data;    // 区域设备数据
        };
        struct callback_head {
            struct callback_head *next; // 下一个
            void (*func)(struct callback_head *); // 函数
        } callback_head;
    };
    union {
        atomic_t _mapcount;           // 映射计数
        unsigned int page_type;       // 页类型
    };
    atomic_t _refcount;               // 引用计数
    unsigned long memcg_data;         // memcg 数据
};

struct folio {
    union {
        struct {
            unsigned long flags;      // 标志
            union {
                struct list_head {
                    struct list_head *next; // 下一个
                    struct list_head *prev; // 上一个
                } lru;
                struct {
                    void *__filler;   // 填充
                    unsigned int mlock_count; // 锁定计数
                };
            };
            struct address_space *mapping; // 映射
            unsigned long index;      // 索引
            union {
                void *private;        // 私有
                swp_entry_t swap;     // 交换项
            };
            atomic_t _mapcount;       // 映射计数
            atomic_t _refcount;       // 引用计数
            unsigned long memcg_data; // memcg 数据
        };
        struct page {
            unsigned long flags;      // 标志
            union {
                struct {
                    union {
                        struct list_head {
                            struct list_head *next; // 下一个
                            struct list_head *prev; // 上一个
                        } lru;
                        struct {
                            void *__filler; // 填充
                            unsigned int mlock_count; // 锁定计数
                        };
                        struct list_head {
                            struct list_head *next; // 下一个
                            struct list_head *prev; // 上一个
                        } buddy_list;
                        struct list_head {
                            struct list_head *next; // 下一个
                            struct list_head *prev; // 上一个
                        } pcp_list;
                    };
                    struct address_space *mapping; // 映射
                    union {
                        unsigned long index; // 索引
                        unsigned long share; // 共享
                    };
                    unsigned long private; // 私有
                };
                struct {
                    unsigned long pp_magic; // 页池魔数
                    struct page_pool *pp;   // 页池
                    unsigned long _pp_mapping_pad; // 页池映射填充
                    unsigned long dma_addr; // DMA 地址
                    union {
                        unsigned long dma_addr_upper; // DMA 地址高位
                        atomic_long_t pp_frag_count;  // 页池分片计数
                    };
                };
                struct {
                    unsigned long compound_head; // 复合头
                };
                struct {
                    struct dev_pagemap *pgmap; // 设备页映射
                    void *zone_device_data;    // 区域设备数据
                };
                struct callback_head {
                    struct callback_head *next; // 下一个
                    void (*func)(struct callback_head *); // 函数
                } callback_head;
            };
            union {
                atomic_t _mapcount;   // 映射计数
                unsigned int page_type; // 页类型
            };
            atomic_t _refcount;       // 引用计数
            unsigned long memcg_data; // memcg 数据
        } page;
    };
    union {
        struct {
            unsigned long _flags_1;   // 标志1
            unsigned long _head_1;    // 头1
            unsigned long _folio_avail; // folio 可用
            atomic_t _entire_mapcount; // 整体映射计数
            atomic_t _nr_pages_mapped; // 映射页数
            atomic_t _pincount;       // 固定计数
            unsigned int _folio_nr_pages; // folio 页数
        };
        struct page {
            unsigned long flags;      // 标志
            union {
                struct {
                    union {
                        struct list_head {
                            struct list_head *next; // 下一个
                            struct list_head *prev; // 上一个
                        } lru;
                        struct {
                            void *__filler; // 填充
                            unsigned int mlock_count; // 锁定计数
                        };
                        struct list_head {
                            struct list_head *next; // 下一个
                            struct list_head *prev; // 上一个
                        } buddy_list;
                        struct list_head {
                            struct list_head *next; // 下一个
                            struct list_head *prev; // 上一个
                        } pcp_list;
                    };
                    struct address_space *mapping; // 映射
                    union {
                        unsigned long index; // 索引
                        unsigned long share; // 共享
                    };
                    unsigned long private; // 私有
                };
                struct {
                    unsigned long pp_magic; // 页池魔数
                    struct page_pool *pp;   // 页池
                    unsigned long _pp_mapping_pad; // 页池映射填充
                    unsigned long dma_addr; // DMA 地址
                    union {
                        unsigned long dma_addr_upper; // DMA 地址高位
                        atomic_long_t pp_frag_count;  // 页池分片计数
                    };
                };
                struct {
                    unsigned long compound_head; // 复合头
                };
                struct {
                    struct dev_pagemap *pgmap; // 设备页映射
                    void *zone_device_data;    // 区域设备数据
                };
                struct callback_head {
                    struct callback_head *next; // 下一个
                    void (*func)(struct callback_head *); // 函数
                } callback_head;
            };
            union {
                atomic_t _mapcount;   // 映射计数
                unsigned int page_type; // 页类型
            };
            atomic_t _refcount;       // 引用计数
            unsigned long memcg_data; // memcg 数据
        } __page_1;
    };
    union {
        struct {
            unsigned long _flags_2;   // 标志2
            unsigned long _head_2;    // 头2
            void *_hugetlb_subpool;   // 大页子池
            void *_hugetlb_cgroup;    // 大页 cgroup
            void *_hugetlb_cgroup_rsvd; // 大页 cgroup 保留
            void *_hugetlb_hwpoison;  // 大页硬件毒化
        };
        struct {
            unsigned long _flags_2a;  // 标志2a
            unsigned long _head_2a;   // 头2a
            struct list_head {
                struct list_head *next; // 下一个
                struct list_head *prev; // 上一个
            } _deferred_list;
        };
        struct page {
            unsigned long flags;      // 标志
            union {
                struct {
                    union {
                        struct list_head {
                            struct list_head *next; // 下一个
                            struct list_head *prev; // 上一个
                        } lru;
                        struct {
                            void *__filler; // 填充
                            unsigned int mlock_count; // 锁定计数
                        };
                        struct list_head {
                            struct list_head *next; // 下一个
                            struct list_head *prev; // 上一个
                        } buddy_list;
                        struct list_head {
                            struct list_head *next; // 下一个
                            struct list_head *prev; // 上一个
                        } pcp_list;
                    };
                    struct address_space *mapping; // 映射
                    union {
                        unsigned long index; // 索引
                        unsigned long share; // 共享
                    };
                    unsigned long private; // 私有
                };
                struct {
                    unsigned long pp_magic; // 页池魔数
                    struct page_pool *pp;   // 页池
                    unsigned long _pp_mapping_pad; // 页池映射填充
                    unsigned long dma_addr; // DMA 地址
                    union {
                        unsigned long dma_addr_upper; // DMA 地址高位
                        atomic_long_t pp_frag_count;  // 页池分片计数
                    };
                };
                struct {
                    unsigned long compound_head; // 复合头
                };
                struct {
                    struct dev_pagemap *pgmap; // 设备页映射
                    void *zone_device_data;    // 区域设备数据
                };
                struct callback_head {
                    struct callback_head *next; // 下一个
                    void (*func)(struct callback_head *); // 函数
                } callback_head;
            };
            union {
                atomic_t _mapcount;   // 映射计数
                unsigned int page_type; // 页类型
            };
            atomic_t _refcount;       // 引用计数
            unsigned long memcg_data; // memcg 数据
        } __page_2;
    };
};

struct mm_struct {
    struct maple_tree mm_mt;          // Maple 树
    unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long); // 获取未映射区域
    unsigned long mmap_base;          // mmap 基址
    unsigned long mmap_legacy_base;   // mmap 传统基址
    unsigned long mmap_compat_base;   // mmap 兼容基址
    unsigned long mmap_compat_legacy_base; // mmap 兼容传统基址
    unsigned long task_size;          // 任务大小
    pgd_t *pgd;                       // PGD
    atomic_t membarrier_state;        // 内存屏障状态
    atomic_t mm_users;                // 用户计数
    struct mm_cid *pcpu_cid;          // 每 CPU CID
    unsigned long mm_cid_next_scan;   // CID 下次扫描
    atomic_long_t pgtables_bytes;     // 页表字节数
    int map_count;                    // 映射计数
    spinlock_t page_table_lock;       // 页表锁
    struct rw_semaphore mmap_lock;    // mmap 锁
    struct list_head {
        struct list_head *next;       // 下一个
        struct list_head *prev;       // 上一个
    } mmlist;
    int mm_lock_seq;                  // 锁序列
    unsigned long hiwater_rss;        // 高水位 RSS
    unsigned long hiwater_vm;         // 高水位 VM
    unsigned long total_vm;           // 总 VM
    unsigned long locked_vm;          // 锁定 VM
    atomic64_t pinned_vm;             // 固定 VM
    unsigned long data_vm;            // 数据 VM
    unsigned long exec_vm;            // 执行 VM
    unsigned long stack_vm;           // 栈 VM
    unsigned long def_flags;          // 默认标志
    seqcount_t write_protect_seq;     // 写保护序列
    spinlock_t arg_lock;              // 参数锁
    unsigned long start_code;         // 代码起始
    unsigned long end_code;           // 代码结束
    unsigned long start_data;         // 数据起始
    unsigned long end_data;           // 数据结束
    unsigned long start_brk;          // brk 起始
    unsigned long brk;                // brk
    unsigned long start_stack;        // 栈起始
    unsigned long arg_start;          // 参数起始
    unsigned long arg_end;            // 参数结束
    unsigned long env_start;          // 环境起始
    unsigned long env_end;            // 环境结束
    unsigned long saved_auxv[52];     // 保存的 auxv
    struct percpu_counter rss_stat[4]; // RSS 统计
    struct linux_binfmt *binfmt;      // 二进制格式
    mm_context_t context;             // 上下文
    unsigned long flags;              // 标志
    spinlock_t ioctx_lock;            // ioctx 锁
    struct kioctx_table *ioctx_table; // ioctx 表
    struct task_struct *owner;        // 所有者
    struct user_namespace *user_ns;   // 用户命名空间
    struct file *exe_file;            // 可执行文件
    struct mmu_notifier_subscriptions *notifier_subscriptions; // MMU 通知订阅
    unsigned long numa_next_scan;     // NUMA 下次扫描
    unsigned long numa_scan_offset;   // NUMA 扫描偏移
    int numa_scan_seq;                // NUMA 扫描序列
    atomic_t tlb_flush_pending;       // TLB 刷新挂起
    atomic_t tlb_flush_batched;       // TLB 刷新批处理
    struct uprobes_state uprobes_state; // Uprobes 状态
    atomic_long_t hugetlb_usage;      // 大页使用
    struct work_struct {
        atomic_long_t data;           // 数据
        struct list_head {
            struct list_head *next;   // 下一个
            struct list_head *prev;   // 上一个
        } entry;
        work_func_t func;             // 函数
    } async_put_work;
    u32 pasid;                        // PASID
    unsigned long ksm_merging_pages;  // KSM 合并页
    unsigned long ksm_rmap_items;     // KSM rmap 项
    unsigned long ksm_zero_pages;     // KSM 零页
    struct {
        // LRU 生成，内部字段省略
    } lru_gen;
    unsigned long cpu_bitmap[];       // CPU 位图
};

struct vm_area_struct {
    union {
        struct {
            unsigned long vm_start;   // 起始
            unsigned long vm_end;     // 结束
        };
        struct callback_head {
            struct callback_head *next; // 下一个
            void (*func)(struct callback_head *); // 函数
        } vm_rcu;
    };
    struct mm_struct *vm_mm;          // mm
    pgprot_t vm_page_prot;            // 页保护
    union {
        const vm_flags_t vm_flags;    // 标志
        vm_flags_t __vm_flags;        // 标志
    };
    int vm_lock_seq;                  // 锁序列
    struct vma_lock *vm_lock;         // 锁
    bool detached;                    // 分离
    struct {
        struct rb_node {
            unsigned long __rb_parent_color; // 父颜色
            struct rb_node *rb_right;        // 右子节点
            struct rb_node *rb_left;         // 左子节点
        } rb;
        unsigned long rb_subtree_last; // 子树最后
    } shared;
    struct list_head {
        struct list_head *next;       // 下一个
        struct list_head *prev;       // 上一个
    } anon_vma_chain;
    struct anon_vma *anon_vma;        // anon_vma
    const struct vm_operations_struct *vm_ops; // 操作
    unsigned long vm_pgoff;           // 页偏移
    struct file *vm_file;             // 文件
    void *vm_private_data;            // 私有数据
    struct anon_vma_name *anon_name;  // anon 名称
    atomic_long_t swap_readahead_info; // 交换预读信息
    struct mempolicy *vm_policy;      // 内存策略
    struct vma_numab_state *numab_state; // NUMA 平衡状态
    struct vm_userfaultfd_ctx {
        struct userfaultfd_ctx *ctx;  // 上下文
    } vm_userfaultfd_ctx;
};

struct zone {
    unsigned long _watermark[4];      // 水位
    unsigned long watermark_boost;    // 水位提升
    unsigned long nr_reserved_highatomic; // 保留高原子
    long lowmem_reserve[5];           // 低内存保留
    int node;                         // 节点
    struct pglist_data *zone_pgdat;   // 区域 pgdat
    struct per_cpu_pages *per_cpu_pageset; // 每 CPU 页集
    struct per_cpu_zonestat *per_cpu_zonestats; // 每 CPU 区域统计
    int pageset_high;                 // 页集高
    int pageset_batch;                // 页集批
    unsigned long zone_start_pfn;     // 区域起始 PFN
    atomic_long_t managed_pages;      // 管理页
    unsigned long spanned_pages;      // 跨越页
    unsigned long present_pages;      // 存在页
    unsigned long present_early_pages; // 早期存在页
    const char *name;                 // 名称
    unsigned long nr_isolate_pageblock; // 隔离页块
    seqlock_t span_seqlock;           // 跨度序列锁
    int initialized;                  // 初始化
    struct free_area {
        struct list_head {
            struct list_head *next;   // 下一个
            struct list_head *prev;   // 上一个
        } free_list[5];
        unsigned long nr_free;        // 空闲数量
    } free_area[11];
    struct list_head {
        struct list_head *next;       // 下一个
        struct list_head *prev;       // 上一个
    } unaccepted_pages;
    unsigned long flags;              // 标志
    spinlock_t lock;                  // 锁
    unsigned long percpu_drift_mark;  // 每 CPU 漂移标记
    unsigned long compact_cached_free_pfn; // 压缩缓存空闲 PFN
    unsigned long compact_cached_migrate_pfn[2]; // 压缩缓存迁移 PFN
    unsigned long compact_init_migrate_pfn; // 压缩初始迁移 PFN
    unsigned long compact_init_free_pfn; // 压缩初始空闲 PFN
    unsigned int compact_considered;  // 压缩考虑
    unsigned int compact_defer_shift; // 压缩延迟偏移
    int compact_order_failed;         // 压缩阶失败
    bool compact_blockskip_flush;     // 压缩块跳过刷新
    bool contiguous;                  // 连续
    atomic_long_t vm_stat[12];        // VM 统计
    atomic_long_t vm_numa_event[6];   // VM NUMA 事件
};

struct per_cpu_pages {
    spinlock_t lock;                  // 锁
    int count;                        // 计数
    int high;                         // 高水位
    int batch;                        // 批处理
    short free_factor;                // 空闲因子
    short expire;                     // 过期
    struct list_head {
        struct list_head *next;       // 下一个
        struct list_head *prev;       // 上一个
    } lists[13];
};

struct free_area {
    struct list_head {
        struct list_head *next;       // 下一个
        struct list_head *prev;       // 上一个
    } free_list[5];
    unsigned long nr_free;            // 空闲数量
};

typedef struct { pgdval_t pgd; } pgd_t; // PGD
typedef struct { p4dval_t p4d; } p4d_t; // P4D
typedef struct { pudval_t pud; } pud_t; // PUD
typedef struct { pmdval_t pmd; } pmd_t; // PMD
typedef struct { pteval_t pte; } pte_t; // PTE

struct pipe_inode_info {
    struct mutex {
        atomic_long_t owner;          // 所有者
        raw_spinlock_t wait_lock;     // 等待锁
        struct optimistic_spin_queue {
            atomic_t tail;            // 尾部
        } osq;
        struct list_head {
            struct list_head *next;   // 下一个
            struct list_head *prev;   // 上一个
        } wait_list;
    } mutex;
    wait_queue_head_t rd_wait;        // 读等待队列
    wait_queue_head_t wr_wait;        // 写等待队列
    unsigned int head;                // 头
    unsigned int tail;                // 尾
    unsigned int max_usage;           // 最大使用
    unsigned int ring_size;           // 环大小
    bool note_loss;                   // 丢失标志
    unsigned int nr_accounted;        // 记账计数
    unsigned int readers;             // 读者
    unsigned int writers;             // 写者
    unsigned int files;               // 文件
    unsigned int r_counter;           // 读计数器
    unsigned int w_counter;           // 写计数器
    bool poll_usage;                  // 轮询使用
    struct page *tmp_page;            // 临时页
    struct fasync_struct *fasync_readers; // 异步读者
    struct fasync_struct *fasync_writers; // 异步写者
    struct pipe_buffer *bufs;         // 缓冲区
    struct user_struct *user;         // 用户
    struct watch_queue *watch_queue;  // 监视队列
};

struct pipe_buffer {
    struct page *page;                // 页
    unsigned int offset;              // 偏移
    unsigned int len;                 // 长度
    const struct pipe_buf_operations *ops; // 操作
    unsigned int flags;               // 标志
    unsigned long private;            // 私有
};