NK-6A13 IO config

hc

2024-08-09 d3d58fa5ee2428cd2dde78fd8eeeeabe916b3835

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
#ifndef _NET_NF_TABLES_OFFLOAD_H
#define _NET_NF_TABLES_OFFLOAD_H
 
#include <net/flow_offload.h>
#include <net/netfilter/nf_tables.h>
 
enum nft_offload_reg_flags {
    NFT_OFFLOAD_F_NETWORK2HOST    = (1 << 0),
};
 
struct nft_offload_reg {
    u32        key;
    u32        len;
    u32        base_offset;
    u32        offset;
    u32        flags;
    struct nft_data data;
    struct nft_data    mask;
};
 
enum nft_offload_dep_type {
    NFT_OFFLOAD_DEP_UNSPEC    = 0,
    NFT_OFFLOAD_DEP_NETWORK,
    NFT_OFFLOAD_DEP_TRANSPORT,
};
 
struct nft_offload_ctx {
    struct {
        enum nft_offload_dep_type    type;
        __be16                l3num;
        u8                protonum;
    } dep;
    unsigned int                num_actions;
    struct net                *net;
    struct nft_offload_reg            regs[NFT_REG32_15 + 1];
};
 
void nft_offload_set_dependency(struct nft_offload_ctx *ctx,
                enum nft_offload_dep_type type);
void nft_offload_update_dependency(struct nft_offload_ctx *ctx,
                   const void *data, u32 len);
 
struct nft_flow_key {
    struct flow_dissector_key_basic            basic;
    struct flow_dissector_key_control        control;
    union {
        struct flow_dissector_key_ipv4_addrs    ipv4;
        struct flow_dissector_key_ipv6_addrs    ipv6;
    };
    struct flow_dissector_key_ports            tp;
    struct flow_dissector_key_ip            ip;
    struct flow_dissector_key_vlan            vlan;
    struct flow_dissector_key_vlan            cvlan;
    struct flow_dissector_key_eth_addrs        eth_addrs;
    struct flow_dissector_key_meta            meta;
} __aligned(BITS_PER_LONG / 8); /* Ensure that we can do comparisons as longs. */
 
struct nft_flow_match {
    struct flow_dissector    dissector;
    struct nft_flow_key    key;
    struct nft_flow_key    mask;
};
 
struct nft_flow_rule {
    __be16            proto;
    struct nft_flow_match    match;
    struct flow_rule    *rule;
};
 
void nft_flow_rule_set_addr_type(struct nft_flow_rule *flow,
                 enum flow_dissector_key_id addr_type);
 
struct nft_rule;
struct nft_flow_rule *nft_flow_rule_create(struct net *net, const struct nft_rule *rule);
void nft_flow_rule_destroy(struct nft_flow_rule *flow);
int nft_flow_rule_offload_commit(struct net *net);
 
#define NFT_OFFLOAD_MATCH_FLAGS(__key, __base, __field, __len, __reg, __flags)    \
    (__reg)->base_offset    =                    \
        offsetof(struct nft_flow_key, __base);            \
    (__reg)->offset        =                    \
        offsetof(struct nft_flow_key, __base.__field);        \
    (__reg)->len        = __len;                \
    (__reg)->key        = __key;                \
    (__reg)->flags        = __flags;
 
#define NFT_OFFLOAD_MATCH(__key, __base, __field, __len, __reg)        \
    NFT_OFFLOAD_MATCH_FLAGS(__key, __base, __field, __len, __reg, 0)
 
#define NFT_OFFLOAD_MATCH_EXACT(__key, __base, __field, __len, __reg)    \
    NFT_OFFLOAD_MATCH(__key, __base, __field, __len, __reg)        \
    memset(&(__reg)->mask, 0xff, (__reg)->len);
 
bool nft_chain_offload_support(const struct nft_base_chain *basechain);
 
int nft_offload_init(void);
void nft_offload_exit(void);
 
#endif