URL https://opencores.org/ocsvn/hf-risc/hf-risc/trunk

Subversion Repositories hf-risc

[/] [hf-risc/] [trunk/] [tools/] [riscv-gnu-toolchain-master/] [linux-headers/] [include/] [linux/] [pkt_cls.h] - Blame information for rev 13

Details | Compare with Previous | View Log


#ifndef __LINUX_PKT_CLS_H
#define __LINUX_PKT_CLS_H
 
#include <linux/types.h>
#include <linux/pkt_sched.h>
 
/* I think i could have done better macros ; for now this is stolen from
 * some arch/mips code - jhs
*/
#define _TC_MAKE32(x) ((x))
 
#define _TC_MAKEMASK1(n) (_TC_MAKE32(1) << _TC_MAKE32(n))
#define _TC_MAKEMASK(v,n) (_TC_MAKE32((_TC_MAKE32(1)<<(v))-1) << _TC_MAKE32(n))
#define _TC_MAKEVALUE(v,n) (_TC_MAKE32(v) << _TC_MAKE32(n))
#define _TC_GETVALUE(v,n,m) ((_TC_MAKE32(v) & _TC_MAKE32(m)) >> _TC_MAKE32(n))
 
/* verdict bit breakdown
 *
bit 0: when set -> this packet has been munged already
 
bit 1: when set -> It is ok to munge this packet
 
bit 2,3,4,5: Reclassify counter - sort of reverse TTL - if exceeded
assume loop
 
bit 6,7: Where this packet was last seen
0: Above the transmit example at the socket level
1: on the Ingress
2: on the Egress
 
bit 8: when set --> Request not to classify on ingress.
 
bits 9,10,11: redirect counter -  redirect TTL. Loop avoidance
 
 *
 * */
 
#define TC_MUNGED          _TC_MAKEMASK1(0)
#define SET_TC_MUNGED(v)   ( TC_MUNGED | (v & ~TC_MUNGED))
#define CLR_TC_MUNGED(v)   ( v & ~TC_MUNGED)
 
#define TC_OK2MUNGE        _TC_MAKEMASK1(1)
#define SET_TC_OK2MUNGE(v)   ( TC_OK2MUNGE | (v & ~TC_OK2MUNGE))
#define CLR_TC_OK2MUNGE(v)   ( v & ~TC_OK2MUNGE)
 
#define S_TC_VERD          _TC_MAKE32(2)
#define M_TC_VERD          _TC_MAKEMASK(4,S_TC_VERD)
#define G_TC_VERD(x)       _TC_GETVALUE(x,S_TC_VERD,M_TC_VERD)
#define V_TC_VERD(x)       _TC_MAKEVALUE(x,S_TC_VERD)
#define SET_TC_VERD(v,n)   ((V_TC_VERD(n)) | (v & ~M_TC_VERD))
 
#define S_TC_FROM          _TC_MAKE32(6)
#define M_TC_FROM          _TC_MAKEMASK(2,S_TC_FROM)
#define G_TC_FROM(x)       _TC_GETVALUE(x,S_TC_FROM,M_TC_FROM)
#define V_TC_FROM(x)       _TC_MAKEVALUE(x,S_TC_FROM)
#define SET_TC_FROM(v,n)   ((V_TC_FROM(n)) | (v & ~M_TC_FROM))
#define AT_STACK        0x0
#define AT_INGRESS      0x1
#define AT_EGRESS       0x2
 
#define TC_NCLS          _TC_MAKEMASK1(8)
#define SET_TC_NCLS(v)   ( TC_NCLS | (v & ~TC_NCLS))
#define CLR_TC_NCLS(v)   ( v & ~TC_NCLS)
 
#define S_TC_RTTL          _TC_MAKE32(9)
#define M_TC_RTTL          _TC_MAKEMASK(3,S_TC_RTTL)
#define G_TC_RTTL(x)       _TC_GETVALUE(x,S_TC_RTTL,M_TC_RTTL)
#define V_TC_RTTL(x)       _TC_MAKEVALUE(x,S_TC_RTTL)
#define SET_TC_RTTL(v,n)   ((V_TC_RTTL(n)) | (v & ~M_TC_RTTL))
 
#define S_TC_AT          _TC_MAKE32(12)
#define M_TC_AT          _TC_MAKEMASK(2,S_TC_AT)
#define G_TC_AT(x)       _TC_GETVALUE(x,S_TC_AT,M_TC_AT)
#define V_TC_AT(x)       _TC_MAKEVALUE(x,S_TC_AT)
#define SET_TC_AT(v,n)   ((V_TC_AT(n)) | (v & ~M_TC_AT))
 
/* Action attributes */
enum {
        TCA_ACT_UNSPEC,
        TCA_ACT_KIND,
        TCA_ACT_OPTIONS,
        TCA_ACT_INDEX,
        TCA_ACT_STATS,
        __TCA_ACT_MAX
};
 
#define TCA_ACT_MAX __TCA_ACT_MAX
#define TCA_OLD_COMPAT (TCA_ACT_MAX+1)
#define TCA_ACT_MAX_PRIO 32
#define TCA_ACT_BIND    1
#define TCA_ACT_NOBIND  0
#define TCA_ACT_UNBIND  1
#define TCA_ACT_NOUNBIND        0
#define TCA_ACT_REPLACE         1
#define TCA_ACT_NOREPLACE       0
#define MAX_REC_LOOP 4
#define MAX_RED_LOOP 4
 
#define TC_ACT_UNSPEC   (-1)
#define TC_ACT_OK               0
#define TC_ACT_RECLASSIFY       1
#define TC_ACT_SHOT             2
#define TC_ACT_PIPE             3
#define TC_ACT_STOLEN           4
#define TC_ACT_QUEUED           5
#define TC_ACT_REPEAT           6
#define TC_ACT_JUMP             0x10000000
 
/* Action type identifiers*/
enum {
        TCA_ID_UNSPEC=0,
        TCA_ID_POLICE=1,
        /* other actions go here */
        __TCA_ID_MAX=255
};
 
#define TCA_ID_MAX __TCA_ID_MAX
 
struct tc_police {
        __u32                   index;
        int                     action;
#define TC_POLICE_UNSPEC        TC_ACT_UNSPEC
#define TC_POLICE_OK            TC_ACT_OK
#define TC_POLICE_RECLASSIFY    TC_ACT_RECLASSIFY
#define TC_POLICE_SHOT          TC_ACT_SHOT
#define TC_POLICE_PIPE          TC_ACT_PIPE
 
        __u32                   limit;
        __u32                   burst;
        __u32                   mtu;
        struct tc_ratespec      rate;
        struct tc_ratespec      peakrate;
        int                     refcnt;
        int                     bindcnt;
        __u32                   capab;
};
 
struct tcf_t {
        __u64   install;
        __u64   lastuse;
        __u64   expires;
};
 
struct tc_cnt {
        int                   refcnt;
        int                   bindcnt;
};
 
#define tc_gen \
        __u32                 index; \
        __u32                 capab; \
        int                   action; \
        int                   refcnt; \
        int                   bindcnt
 
enum {
        TCA_POLICE_UNSPEC,
        TCA_POLICE_TBF,
        TCA_POLICE_RATE,
        TCA_POLICE_PEAKRATE,
        TCA_POLICE_AVRATE,
        TCA_POLICE_RESULT,
        __TCA_POLICE_MAX
#define TCA_POLICE_RESULT TCA_POLICE_RESULT
};
 
#define TCA_POLICE_MAX (__TCA_POLICE_MAX - 1)
 
/* U32 filters */
 
#define TC_U32_HTID(h) ((h)&0xFFF00000)
#define TC_U32_USERHTID(h) (TC_U32_HTID(h)>>20)
#define TC_U32_HASH(h) (((h)>>12)&0xFF)
#define TC_U32_NODE(h) ((h)&0xFFF)
#define TC_U32_KEY(h) ((h)&0xFFFFF)
#define TC_U32_UNSPEC   0
#define TC_U32_ROOT     (0xFFF00000)
 
enum {
        TCA_U32_UNSPEC,
        TCA_U32_CLASSID,
        TCA_U32_HASH,
        TCA_U32_LINK,
        TCA_U32_DIVISOR,
        TCA_U32_SEL,
        TCA_U32_POLICE,
        TCA_U32_ACT,
        TCA_U32_INDEV,
        TCA_U32_PCNT,
        TCA_U32_MARK,
        __TCA_U32_MAX
};
 
#define TCA_U32_MAX (__TCA_U32_MAX - 1)
 
struct tc_u32_key {
        __be32          mask;
        __be32          val;
        int             off;
        int             offmask;
};
 
struct tc_u32_sel {
        unsigned char           flags;
        unsigned char           offshift;
        unsigned char           nkeys;
 
        __be16                  offmask;
        __u16                   off;
        short                   offoff;
 
        short                   hoff;
        __be32                  hmask;
        struct tc_u32_key       keys[0];
};
 
struct tc_u32_mark {
        __u32           val;
        __u32           mask;
        __u32           success;
};
 
struct tc_u32_pcnt {
        __u64 rcnt;
        __u64 rhit;
        __u64 kcnts[0];
};
 
/* Flags */
 
#define TC_U32_TERMINAL         1
#define TC_U32_OFFSET           2
#define TC_U32_VAROFFSET        4
#define TC_U32_EAT              8
 
#define TC_U32_MAXDEPTH 8
 
 
/* RSVP filter */
 
enum {
        TCA_RSVP_UNSPEC,
        TCA_RSVP_CLASSID,
        TCA_RSVP_DST,
        TCA_RSVP_SRC,
        TCA_RSVP_PINFO,
        TCA_RSVP_POLICE,
        TCA_RSVP_ACT,
        __TCA_RSVP_MAX
};
 
#define TCA_RSVP_MAX (__TCA_RSVP_MAX - 1 )
 
struct tc_rsvp_gpi {
        __u32   key;
        __u32   mask;
        int     offset;
};
 
struct tc_rsvp_pinfo {
        struct tc_rsvp_gpi dpi;
        struct tc_rsvp_gpi spi;
        __u8    protocol;
        __u8    tunnelid;
        __u8    tunnelhdr;
        __u8    pad;
};
 
/* ROUTE filter */
 
enum {
        TCA_ROUTE4_UNSPEC,
        TCA_ROUTE4_CLASSID,
        TCA_ROUTE4_TO,
        TCA_ROUTE4_FROM,
        TCA_ROUTE4_IIF,
        TCA_ROUTE4_POLICE,
        TCA_ROUTE4_ACT,
        __TCA_ROUTE4_MAX
};
 
#define TCA_ROUTE4_MAX (__TCA_ROUTE4_MAX - 1)
 
 
/* FW filter */
 
enum {
        TCA_FW_UNSPEC,
        TCA_FW_CLASSID,
        TCA_FW_POLICE,
        TCA_FW_INDEV, /*  used by CONFIG_NET_CLS_IND */
        TCA_FW_ACT, /* used by CONFIG_NET_CLS_ACT */
        TCA_FW_MASK,
        __TCA_FW_MAX
};
 
#define TCA_FW_MAX (__TCA_FW_MAX - 1)
 
/* TC index filter */
 
enum {
        TCA_TCINDEX_UNSPEC,
        TCA_TCINDEX_HASH,
        TCA_TCINDEX_MASK,
        TCA_TCINDEX_SHIFT,
        TCA_TCINDEX_FALL_THROUGH,
        TCA_TCINDEX_CLASSID,
        TCA_TCINDEX_POLICE,
        TCA_TCINDEX_ACT,
        __TCA_TCINDEX_MAX
};
 
#define TCA_TCINDEX_MAX     (__TCA_TCINDEX_MAX - 1)
 
/* Flow filter */
 
enum {
        FLOW_KEY_SRC,
        FLOW_KEY_DST,
        FLOW_KEY_PROTO,
        FLOW_KEY_PROTO_SRC,
        FLOW_KEY_PROTO_DST,
        FLOW_KEY_IIF,
        FLOW_KEY_PRIORITY,
        FLOW_KEY_MARK,
        FLOW_KEY_NFCT,
        FLOW_KEY_NFCT_SRC,
        FLOW_KEY_NFCT_DST,
        FLOW_KEY_NFCT_PROTO_SRC,
        FLOW_KEY_NFCT_PROTO_DST,
        FLOW_KEY_RTCLASSID,
        FLOW_KEY_SKUID,
        FLOW_KEY_SKGID,
        FLOW_KEY_VLAN_TAG,
        FLOW_KEY_RXHASH,
        __FLOW_KEY_MAX,
};
 
#define FLOW_KEY_MAX    (__FLOW_KEY_MAX - 1)
 
enum {
        FLOW_MODE_MAP,
        FLOW_MODE_HASH,
};
 
enum {
        TCA_FLOW_UNSPEC,
        TCA_FLOW_KEYS,
        TCA_FLOW_MODE,
        TCA_FLOW_BASECLASS,
        TCA_FLOW_RSHIFT,
        TCA_FLOW_ADDEND,
        TCA_FLOW_MASK,
        TCA_FLOW_XOR,
        TCA_FLOW_DIVISOR,
        TCA_FLOW_ACT,
        TCA_FLOW_POLICE,
        TCA_FLOW_EMATCHES,
        TCA_FLOW_PERTURB,
        __TCA_FLOW_MAX
};
 
#define TCA_FLOW_MAX    (__TCA_FLOW_MAX - 1)
 
/* Basic filter */
 
enum {
        TCA_BASIC_UNSPEC,
        TCA_BASIC_CLASSID,
        TCA_BASIC_EMATCHES,
        TCA_BASIC_ACT,
        TCA_BASIC_POLICE,
        __TCA_BASIC_MAX
};
 
#define TCA_BASIC_MAX (__TCA_BASIC_MAX - 1)
 
 
/* Cgroup classifier */
 
enum {
        TCA_CGROUP_UNSPEC,
        TCA_CGROUP_ACT,
        TCA_CGROUP_POLICE,
        TCA_CGROUP_EMATCHES,
        __TCA_CGROUP_MAX,
};
 
#define TCA_CGROUP_MAX (__TCA_CGROUP_MAX - 1)
 
/* BPF classifier */
 
enum {
        TCA_BPF_UNSPEC,
        TCA_BPF_ACT,
        TCA_BPF_POLICE,
        TCA_BPF_CLASSID,
        TCA_BPF_OPS_LEN,
        TCA_BPF_OPS,
        __TCA_BPF_MAX,
};
 
#define TCA_BPF_MAX (__TCA_BPF_MAX - 1)
 
/* Extended Matches */
 
struct tcf_ematch_tree_hdr {
        __u16           nmatches;
        __u16           progid;
};
 
enum {
        TCA_EMATCH_TREE_UNSPEC,
        TCA_EMATCH_TREE_HDR,
        TCA_EMATCH_TREE_LIST,
        __TCA_EMATCH_TREE_MAX
};
#define TCA_EMATCH_TREE_MAX (__TCA_EMATCH_TREE_MAX - 1)
 
struct tcf_ematch_hdr {
        __u16           matchid;
        __u16           kind;
        __u16           flags;
        __u16           pad; /* currently unused */
};
 
/*  0                   1
 *  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5
 * +-----------------------+-+-+---+
 * |         Unused        |S|I| R |
 * +-----------------------+-+-+---+
 *
 * R(2) ::= relation to next ematch
 *          where: 0 0 END (last ematch)
 *                 0 1 AND
 *                 1 0 OR
 *                 1 1 Unused (invalid)
 * I(1) ::= invert result
 * S(1) ::= simple payload
 */
#define TCF_EM_REL_END  0
#define TCF_EM_REL_AND  (1<<0)
#define TCF_EM_REL_OR   (1<<1)
#define TCF_EM_INVERT   (1<<2)
#define TCF_EM_SIMPLE   (1<<3)
 
#define TCF_EM_REL_MASK 3
#define TCF_EM_REL_VALID(v) (((v) & TCF_EM_REL_MASK) != TCF_EM_REL_MASK)
 
enum {
        TCF_LAYER_LINK,
        TCF_LAYER_NETWORK,
        TCF_LAYER_TRANSPORT,
        __TCF_LAYER_MAX
};
#define TCF_LAYER_MAX (__TCF_LAYER_MAX - 1)
 
/* Ematch type assignments
 *   1..32767           Reserved for ematches inside kernel tree
 *   32768..65535       Free to use, not reliable
 */
#define TCF_EM_CONTAINER        0
#define TCF_EM_CMP              1
#define TCF_EM_NBYTE            2
#define TCF_EM_U32              3
#define TCF_EM_META             4
#define TCF_EM_TEXT             5
#define TCF_EM_VLAN             6
#define TCF_EM_CANID            7
#define TCF_EM_IPSET            8
#define TCF_EM_MAX              8
 
enum {
        TCF_EM_PROG_TC
};
 
enum {
        TCF_EM_OPND_EQ,
        TCF_EM_OPND_GT,
        TCF_EM_OPND_LT
};
 
#endif

Browse

Tools

Subversion Repositories hf-risc

[/] [hf-risc/] [trunk/] [tools/] [riscv-gnu-toolchain-master/] [linux-headers/] [include/] [linux/] [pkt_cls.h] - Blame information for rev 13

Line No.	Rev	Author	Line
1	13	serginhofr	`#ifndef __LINUX_PKT_CLS_H`
2			`#define __LINUX_PKT_CLS_H`
3
4			`#include <linux/types.h>`
5			`#include <linux/pkt_sched.h>`
6
7			`/* I think i could have done better macros ; for now this is stolen from`
8			`* some arch/mips code - jhs`
9			`*/`
10			`#define _TC_MAKE32(x) ((x))`
11
12			`#define _TC_MAKEMASK1(n) (_TC_MAKE32(1) << _TC_MAKE32(n))`
13			`#define _TC_MAKEMASK(v,n) (_TC_MAKE32((_TC_MAKE32(1)<<(v))-1) << _TC_MAKE32(n))`
14			`#define _TC_MAKEVALUE(v,n) (_TC_MAKE32(v) << _TC_MAKE32(n))`
15			`#define _TC_GETVALUE(v,n,m) ((_TC_MAKE32(v) & _TC_MAKE32(m)) >> _TC_MAKE32(n))`
16
17			`/* verdict bit breakdown`
18			`*`
19			`bit 0: when set -> this packet has been munged already`
20
21			`bit 1: when set -> It is ok to munge this packet`
22
23			`bit 2,3,4,5: Reclassify counter - sort of reverse TTL - if exceeded`
24			`assume loop`
25
26			`bit 6,7: Where this packet was last seen`
27			`0: Above the transmit example at the socket level`
28			`1: on the Ingress`
29			`2: on the Egress`
30
31			`bit 8: when set --> Request not to classify on ingress.`
32
33			`bits 9,10,11: redirect counter - redirect TTL. Loop avoidance`
34
35			`*`
36			`* */`
37
38			`#define TC_MUNGED _TC_MAKEMASK1(0)`
39			`#define SET_TC_MUNGED(v) ( TC_MUNGED \| (v & ~TC_MUNGED))`
40			`#define CLR_TC_MUNGED(v) ( v & ~TC_MUNGED)`
41
42			`#define TC_OK2MUNGE _TC_MAKEMASK1(1)`
43			`#define SET_TC_OK2MUNGE(v) ( TC_OK2MUNGE \| (v & ~TC_OK2MUNGE))`
44			`#define CLR_TC_OK2MUNGE(v) ( v & ~TC_OK2MUNGE)`
45
46			`#define S_TC_VERD _TC_MAKE32(2)`
47			`#define M_TC_VERD _TC_MAKEMASK(4,S_TC_VERD)`
48			`#define G_TC_VERD(x) _TC_GETVALUE(x,S_TC_VERD,M_TC_VERD)`
49			`#define V_TC_VERD(x) _TC_MAKEVALUE(x,S_TC_VERD)`
50			`#define SET_TC_VERD(v,n) ((V_TC_VERD(n)) \| (v & ~M_TC_VERD))`
51
52			`#define S_TC_FROM _TC_MAKE32(6)`
53			`#define M_TC_FROM _TC_MAKEMASK(2,S_TC_FROM)`
54			`#define G_TC_FROM(x) _TC_GETVALUE(x,S_TC_FROM,M_TC_FROM)`
55			`#define V_TC_FROM(x) _TC_MAKEVALUE(x,S_TC_FROM)`
56			`#define SET_TC_FROM(v,n) ((V_TC_FROM(n)) \| (v & ~M_TC_FROM))`
57			`#define AT_STACK 0x0`
58			`#define AT_INGRESS 0x1`
59			`#define AT_EGRESS 0x2`
60
61			`#define TC_NCLS _TC_MAKEMASK1(8)`
62			`#define SET_TC_NCLS(v) ( TC_NCLS \| (v & ~TC_NCLS))`
63			`#define CLR_TC_NCLS(v) ( v & ~TC_NCLS)`
64
65			`#define S_TC_RTTL _TC_MAKE32(9)`
66			`#define M_TC_RTTL _TC_MAKEMASK(3,S_TC_RTTL)`
67			`#define G_TC_RTTL(x) _TC_GETVALUE(x,S_TC_RTTL,M_TC_RTTL)`
68			`#define V_TC_RTTL(x) _TC_MAKEVALUE(x,S_TC_RTTL)`
69			`#define SET_TC_RTTL(v,n) ((V_TC_RTTL(n)) \| (v & ~M_TC_RTTL))`
70
71			`#define S_TC_AT _TC_MAKE32(12)`
72			`#define M_TC_AT _TC_MAKEMASK(2,S_TC_AT)`
73			`#define G_TC_AT(x) _TC_GETVALUE(x,S_TC_AT,M_TC_AT)`
74			`#define V_TC_AT(x) _TC_MAKEVALUE(x,S_TC_AT)`
75			`#define SET_TC_AT(v,n) ((V_TC_AT(n)) \| (v & ~M_TC_AT))`
76
77			`/* Action attributes */`
78			`enum {`
79			`TCA_ACT_UNSPEC,`
80			`TCA_ACT_KIND,`
81			`TCA_ACT_OPTIONS,`
82			`TCA_ACT_INDEX,`
83			`TCA_ACT_STATS,`
84			`__TCA_ACT_MAX`
85			`};`
86
87			`#define TCA_ACT_MAX __TCA_ACT_MAX`
88			`#define TCA_OLD_COMPAT (TCA_ACT_MAX+1)`
89			`#define TCA_ACT_MAX_PRIO 32`
90			`#define TCA_ACT_BIND 1`
91			`#define TCA_ACT_NOBIND 0`
92			`#define TCA_ACT_UNBIND 1`
93			`#define TCA_ACT_NOUNBIND 0`
94			`#define TCA_ACT_REPLACE 1`
95			`#define TCA_ACT_NOREPLACE 0`
96			`#define MAX_REC_LOOP 4`
97			`#define MAX_RED_LOOP 4`
98
99			`#define TC_ACT_UNSPEC (-1)`
100			`#define TC_ACT_OK 0`
101			`#define TC_ACT_RECLASSIFY 1`
102			`#define TC_ACT_SHOT 2`
103			`#define TC_ACT_PIPE 3`
104			`#define TC_ACT_STOLEN 4`
105			`#define TC_ACT_QUEUED 5`
106			`#define TC_ACT_REPEAT 6`
107			`#define TC_ACT_JUMP 0x10000000`
108
109			`/* Action type identifiers*/`
110			`enum {`
111			`TCA_ID_UNSPEC=0,`
112			`TCA_ID_POLICE=1,`
113			`/* other actions go here */`
114			`__TCA_ID_MAX=255`
115			`};`
116
117			`#define TCA_ID_MAX __TCA_ID_MAX`
118
119			`struct tc_police {`
120			`__u32 index;`
121			`int action;`
122			`#define TC_POLICE_UNSPEC TC_ACT_UNSPEC`
123			`#define TC_POLICE_OK TC_ACT_OK`
124			`#define TC_POLICE_RECLASSIFY TC_ACT_RECLASSIFY`
125			`#define TC_POLICE_SHOT TC_ACT_SHOT`
126			`#define TC_POLICE_PIPE TC_ACT_PIPE`
127
128			`__u32 limit;`
129			`__u32 burst;`
130			`__u32 mtu;`
131			`struct tc_ratespec rate;`
132			`struct tc_ratespec peakrate;`
133			`int refcnt;`
134			`int bindcnt;`
135			`__u32 capab;`
136			`};`
137
138			`struct tcf_t {`
139			`__u64 install;`
140			`__u64 lastuse;`
141			`__u64 expires;`
142			`};`
143
144			`struct tc_cnt {`
145			`int refcnt;`
146			`int bindcnt;`
147			`};`
148
149			`#define tc_gen \`
150			`__u32 index; \`
151			`__u32 capab; \`
152			`int action; \`
153			`int refcnt; \`
154			`int bindcnt`
155
156			`enum {`
157			`TCA_POLICE_UNSPEC,`
158			`TCA_POLICE_TBF,`
159			`TCA_POLICE_RATE,`
160			`TCA_POLICE_PEAKRATE,`
161			`TCA_POLICE_AVRATE,`
162			`TCA_POLICE_RESULT,`
163			`__TCA_POLICE_MAX`
164			`#define TCA_POLICE_RESULT TCA_POLICE_RESULT`
165			`};`
166
167			`#define TCA_POLICE_MAX (__TCA_POLICE_MAX - 1)`
168
169			`/* U32 filters */`
170
171			`#define TC_U32_HTID(h) ((h)&0xFFF00000)`
172			`#define TC_U32_USERHTID(h) (TC_U32_HTID(h)>>20)`
173			`#define TC_U32_HASH(h) (((h)>>12)&0xFF)`
174			`#define TC_U32_NODE(h) ((h)&0xFFF)`
175			`#define TC_U32_KEY(h) ((h)&0xFFFFF)`
176			`#define TC_U32_UNSPEC 0`
177			`#define TC_U32_ROOT (0xFFF00000)`
178
179			`enum {`
180			`TCA_U32_UNSPEC,`
181			`TCA_U32_CLASSID,`
182			`TCA_U32_HASH,`
183			`TCA_U32_LINK,`
184			`TCA_U32_DIVISOR,`
185			`TCA_U32_SEL,`
186			`TCA_U32_POLICE,`
187			`TCA_U32_ACT,`
188			`TCA_U32_INDEV,`
189			`TCA_U32_PCNT,`
190			`TCA_U32_MARK,`
191			`__TCA_U32_MAX`
192			`};`
193
194			`#define TCA_U32_MAX (__TCA_U32_MAX - 1)`
195
196			`struct tc_u32_key {`
197			`__be32 mask;`
198			`__be32 val;`
199			`int off;`
200			`int offmask;`
201			`};`
202
203			`struct tc_u32_sel {`
204			`unsigned char flags;`
205			`unsigned char offshift;`
206			`unsigned char nkeys;`
207
208			`__be16 offmask;`
209			`__u16 off;`
210			`short offoff;`
211
212			`short hoff;`
213			`__be32 hmask;`
214			`struct tc_u32_key keys[0];`
215			`};`
216
217			`struct tc_u32_mark {`
218			`__u32 val;`
219			`__u32 mask;`
220			`__u32 success;`
221			`};`
222
223			`struct tc_u32_pcnt {`
224			`__u64 rcnt;`
225			`__u64 rhit;`
226			`__u64 kcnts[0];`
227			`};`
228
229			`/* Flags */`
230
231			`#define TC_U32_TERMINAL 1`
232			`#define TC_U32_OFFSET 2`
233			`#define TC_U32_VAROFFSET 4`
234			`#define TC_U32_EAT 8`
235
236			`#define TC_U32_MAXDEPTH 8`
237
238
239			`/* RSVP filter */`
240
241			`enum {`
242			`TCA_RSVP_UNSPEC,`
243			`TCA_RSVP_CLASSID,`
244			`TCA_RSVP_DST,`
245			`TCA_RSVP_SRC,`
246			`TCA_RSVP_PINFO,`
247			`TCA_RSVP_POLICE,`
248			`TCA_RSVP_ACT,`
249			`__TCA_RSVP_MAX`
250			`};`
251
252			`#define TCA_RSVP_MAX (__TCA_RSVP_MAX - 1 )`
253
254			`struct tc_rsvp_gpi {`
255			`__u32 key;`
256			`__u32 mask;`
257			`int offset;`
258			`};`
259
260			`struct tc_rsvp_pinfo {`
261			`struct tc_rsvp_gpi dpi;`
262			`struct tc_rsvp_gpi spi;`
263			`__u8 protocol;`
264			`__u8 tunnelid;`
265			`__u8 tunnelhdr;`
266			`__u8 pad;`
267			`};`
268
269			`/* ROUTE filter */`
270
271			`enum {`
272			`TCA_ROUTE4_UNSPEC,`
273			`TCA_ROUTE4_CLASSID,`
274			`TCA_ROUTE4_TO,`
275			`TCA_ROUTE4_FROM,`
276			`TCA_ROUTE4_IIF,`
277			`TCA_ROUTE4_POLICE,`
278			`TCA_ROUTE4_ACT,`
279			`__TCA_ROUTE4_MAX`
280			`};`
281
282			`#define TCA_ROUTE4_MAX (__TCA_ROUTE4_MAX - 1)`
283
284
285			`/* FW filter */`
286
287			`enum {`
288			`TCA_FW_UNSPEC,`
289			`TCA_FW_CLASSID,`
290			`TCA_FW_POLICE,`
291			`TCA_FW_INDEV, /* used by CONFIG_NET_CLS_IND */`
292			`TCA_FW_ACT, /* used by CONFIG_NET_CLS_ACT */`
293			`TCA_FW_MASK,`
294			`__TCA_FW_MAX`
295			`};`
296
297			`#define TCA_FW_MAX (__TCA_FW_MAX - 1)`
298
299			`/* TC index filter */`
300
301			`enum {`
302			`TCA_TCINDEX_UNSPEC,`
303			`TCA_TCINDEX_HASH,`
304			`TCA_TCINDEX_MASK,`
305			`TCA_TCINDEX_SHIFT,`
306			`TCA_TCINDEX_FALL_THROUGH,`
307			`TCA_TCINDEX_CLASSID,`
308			`TCA_TCINDEX_POLICE,`
309			`TCA_TCINDEX_ACT,`
310			`__TCA_TCINDEX_MAX`
311			`};`
312
313			`#define TCA_TCINDEX_MAX (__TCA_TCINDEX_MAX - 1)`
314
315			`/* Flow filter */`
316
317			`enum {`
318			`FLOW_KEY_SRC,`
319			`FLOW_KEY_DST,`
320			`FLOW_KEY_PROTO,`
321			`FLOW_KEY_PROTO_SRC,`
322			`FLOW_KEY_PROTO_DST,`
323			`FLOW_KEY_IIF,`
324			`FLOW_KEY_PRIORITY,`
325			`FLOW_KEY_MARK,`
326			`FLOW_KEY_NFCT,`
327			`FLOW_KEY_NFCT_SRC,`
328			`FLOW_KEY_NFCT_DST,`
329			`FLOW_KEY_NFCT_PROTO_SRC,`
330			`FLOW_KEY_NFCT_PROTO_DST,`
331			`FLOW_KEY_RTCLASSID,`
332			`FLOW_KEY_SKUID,`
333			`FLOW_KEY_SKGID,`
334			`FLOW_KEY_VLAN_TAG,`
335			`FLOW_KEY_RXHASH,`
336			`__FLOW_KEY_MAX,`
337			`};`
338
339			`#define FLOW_KEY_MAX (__FLOW_KEY_MAX - 1)`
340
341			`enum {`
342			`FLOW_MODE_MAP,`
343			`FLOW_MODE_HASH,`
344			`};`
345
346			`enum {`
347			`TCA_FLOW_UNSPEC,`
348			`TCA_FLOW_KEYS,`
349			`TCA_FLOW_MODE,`
350			`TCA_FLOW_BASECLASS,`
351			`TCA_FLOW_RSHIFT,`
352			`TCA_FLOW_ADDEND,`
353			`TCA_FLOW_MASK,`
354			`TCA_FLOW_XOR,`
355			`TCA_FLOW_DIVISOR,`
356			`TCA_FLOW_ACT,`
357			`TCA_FLOW_POLICE,`
358			`TCA_FLOW_EMATCHES,`
359			`TCA_FLOW_PERTURB,`
360			`__TCA_FLOW_MAX`
361			`};`
362
363			`#define TCA_FLOW_MAX (__TCA_FLOW_MAX - 1)`
364
365			`/* Basic filter */`
366
367			`enum {`
368			`TCA_BASIC_UNSPEC,`
369			`TCA_BASIC_CLASSID,`
370			`TCA_BASIC_EMATCHES,`
371			`TCA_BASIC_ACT,`
372			`TCA_BASIC_POLICE,`
373			`__TCA_BASIC_MAX`
374			`};`
375
376			`#define TCA_BASIC_MAX (__TCA_BASIC_MAX - 1)`
377
378
379			`/* Cgroup classifier */`
380
381			`enum {`
382			`TCA_CGROUP_UNSPEC,`
383			`TCA_CGROUP_ACT,`
384			`TCA_CGROUP_POLICE,`
385			`TCA_CGROUP_EMATCHES,`
386			`__TCA_CGROUP_MAX,`
387			`};`
388
389			`#define TCA_CGROUP_MAX (__TCA_CGROUP_MAX - 1)`
390
391			`/* BPF classifier */`
392
393			`enum {`
394			`TCA_BPF_UNSPEC,`
395			`TCA_BPF_ACT,`
396			`TCA_BPF_POLICE,`
397			`TCA_BPF_CLASSID,`
398			`TCA_BPF_OPS_LEN,`
399			`TCA_BPF_OPS,`
400			`__TCA_BPF_MAX,`
401			`};`
402
403			`#define TCA_BPF_MAX (__TCA_BPF_MAX - 1)`
404
405			`/* Extended Matches */`
406
407			`struct tcf_ematch_tree_hdr {`
408			`__u16 nmatches;`
409			`__u16 progid;`
410			`};`
411
412			`enum {`
413			`TCA_EMATCH_TREE_UNSPEC,`
414			`TCA_EMATCH_TREE_HDR,`
415			`TCA_EMATCH_TREE_LIST,`
416			`__TCA_EMATCH_TREE_MAX`
417			`};`
418			`#define TCA_EMATCH_TREE_MAX (__TCA_EMATCH_TREE_MAX - 1)`
419
420			`struct tcf_ematch_hdr {`
421			`__u16 matchid;`
422			`__u16 kind;`
423			`__u16 flags;`
424			`__u16 pad; /* currently unused */`
425			`};`
426
427			`/* 0 1`
428			`* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5`
429			`* +-----------------------+-+-+---+`
430			`* \| Unused \|S\|I\| R \|`
431			`* +-----------------------+-+-+---+`
432			`*`
433			`* R(2) ::= relation to next ematch`
434			`* where: 0 0 END (last ematch)`
435			`* 0 1 AND`
436			`* 1 0 OR`
437			`* 1 1 Unused (invalid)`
438			`* I(1) ::= invert result`
439			`* S(1) ::= simple payload`
440			`*/`
441			`#define TCF_EM_REL_END 0`
442			`#define TCF_EM_REL_AND (1<<0)`
443			`#define TCF_EM_REL_OR (1<<1)`
444			`#define TCF_EM_INVERT (1<<2)`
445			`#define TCF_EM_SIMPLE (1<<3)`
446
447			`#define TCF_EM_REL_MASK 3`
448			`#define TCF_EM_REL_VALID(v) (((v) & TCF_EM_REL_MASK) != TCF_EM_REL_MASK)`
449
450			`enum {`
451			`TCF_LAYER_LINK,`
452			`TCF_LAYER_NETWORK,`
453			`TCF_LAYER_TRANSPORT,`
454			`__TCF_LAYER_MAX`
455			`};`
456			`#define TCF_LAYER_MAX (__TCF_LAYER_MAX - 1)`
457
458			`/* Ematch type assignments`
459			`* 1..32767 Reserved for ematches inside kernel tree`
460			`* 32768..65535 Free to use, not reliable`
461			`*/`
462			`#define TCF_EM_CONTAINER 0`
463			`#define TCF_EM_CMP 1`
464			`#define TCF_EM_NBYTE 2`
465			`#define TCF_EM_U32 3`
466			`#define TCF_EM_META 4`
467			`#define TCF_EM_TEXT 5`
468			`#define TCF_EM_VLAN 6`
469			`#define TCF_EM_CANID 7`
470			`#define TCF_EM_IPSET 8`
471			`#define TCF_EM_MAX 8`
472
473			`enum {`
474			`TCF_EM_PROG_TC`
475			`};`
476
477			`enum {`
478			`TCF_EM_OPND_EQ,`
479			`TCF_EM_OPND_GT,`
480			`TCF_EM_OPND_LT`
481			`};`
482
483			`#endif`