1#ifndef _NET_FLOW_DISSECTOR_H
  2#define _NET_FLOW_DISSECTOR_H
  3
  4#include <linux/types.h>
  5#include <linux/in6.h>
  6#include <uapi/linux/if_ether.h>
  7
  8/**
  9 * struct flow_dissector_key_control:
 10 * @thoff: Transport header offset
 11 */
 12struct flow_dissector_key_control {
 13	u16	thoff;
 14	u16	addr_type;
 15	u32	flags;
 16};
 17
 18#define FLOW_DIS_IS_FRAGMENT	BIT(0)
 19#define FLOW_DIS_FIRST_FRAG	BIT(1)
 20#define FLOW_DIS_ENCAPSULATION	BIT(2)
 21
 22/**
 23 * struct flow_dissector_key_basic:
 24 * @thoff: Transport header offset
 25 * @n_proto: Network header protocol (eg. IPv4/IPv6)
 26 * @ip_proto: Transport header protocol (eg. TCP/UDP)
 27 */
 28struct flow_dissector_key_basic {
 29	__be16	n_proto;
 30	u8	ip_proto;
 31	u8	padding;
 32};
 33
 34struct flow_dissector_key_tags {
 35	u32	vlan_id:12,
 36		flow_label:20;
 
 
 
 
 
 37};
 38
 39struct flow_dissector_key_keyid {
 40	__be32	keyid;
 41};
 42
 43/**
 44 * struct flow_dissector_key_ipv4_addrs:
 45 * @src: source ip address
 46 * @dst: destination ip address
 47 */
 48struct flow_dissector_key_ipv4_addrs {
 49	/* (src,dst) must be grouped, in the same way than in IP header */
 50	__be32 src;
 51	__be32 dst;
 52};
 53
 54/**
 55 * struct flow_dissector_key_ipv6_addrs:
 56 * @src: source ip address
 57 * @dst: destination ip address
 58 */
 59struct flow_dissector_key_ipv6_addrs {
 60	/* (src,dst) must be grouped, in the same way than in IP header */
 61	struct in6_addr src;
 62	struct in6_addr dst;
 63};
 64
 65/**
 66 * struct flow_dissector_key_tipc_addrs:
 67 * @srcnode: source node address
 68 */
 69struct flow_dissector_key_tipc_addrs {
 70	__be32 srcnode;
 71};
 72
 73/**
 74 * struct flow_dissector_key_addrs:
 75 * @v4addrs: IPv4 addresses
 76 * @v6addrs: IPv6 addresses
 77 */
 78struct flow_dissector_key_addrs {
 79	union {
 80		struct flow_dissector_key_ipv4_addrs v4addrs;
 81		struct flow_dissector_key_ipv6_addrs v6addrs;
 82		struct flow_dissector_key_tipc_addrs tipcaddrs;
 83	};
 84};
 85
 86/**
 87 * flow_dissector_key_tp_ports:
 88 *	@ports: port numbers of Transport header
 89 *		src: source port number
 90 *		dst: destination port number
 91 */
 92struct flow_dissector_key_ports {
 93	union {
 94		__be32 ports;
 95		struct {
 96			__be16 src;
 97			__be16 dst;
 98		};
 99	};
100};
101
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
102
103/**
104 * struct flow_dissector_key_eth_addrs:
105 * @src: source Ethernet address
106 * @dst: destination Ethernet address
107 */
108struct flow_dissector_key_eth_addrs {
109	/* (dst,src) must be grouped, in the same way than in ETH header */
110	unsigned char dst[ETH_ALEN];
111	unsigned char src[ETH_ALEN];
112};
113
114enum flow_dissector_key_id {
115	FLOW_DISSECTOR_KEY_CONTROL, /* struct flow_dissector_key_control */
116	FLOW_DISSECTOR_KEY_BASIC, /* struct flow_dissector_key_basic */
117	FLOW_DISSECTOR_KEY_IPV4_ADDRS, /* struct flow_dissector_key_ipv4_addrs */
118	FLOW_DISSECTOR_KEY_IPV6_ADDRS, /* struct flow_dissector_key_ipv6_addrs */
119	FLOW_DISSECTOR_KEY_PORTS, /* struct flow_dissector_key_ports */
 
120	FLOW_DISSECTOR_KEY_ETH_ADDRS, /* struct flow_dissector_key_eth_addrs */
121	FLOW_DISSECTOR_KEY_TIPC_ADDRS, /* struct flow_dissector_key_tipc_addrs */
122	FLOW_DISSECTOR_KEY_VLANID, /* struct flow_dissector_key_flow_tags */
123	FLOW_DISSECTOR_KEY_FLOW_LABEL, /* struct flow_dissector_key_flow_tags */
124	FLOW_DISSECTOR_KEY_GRE_KEYID, /* struct flow_dissector_key_keyid */
125	FLOW_DISSECTOR_KEY_MPLS_ENTROPY, /* struct flow_dissector_key_keyid */
 
 
 
 
 
126
127	FLOW_DISSECTOR_KEY_MAX,
128};
129
130#define FLOW_DISSECTOR_F_PARSE_1ST_FRAG		BIT(0)
131#define FLOW_DISSECTOR_F_STOP_AT_L3		BIT(1)
132#define FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL	BIT(2)
133#define FLOW_DISSECTOR_F_STOP_AT_ENCAP		BIT(3)
134
135struct flow_dissector_key {
136	enum flow_dissector_key_id key_id;
137	size_t offset; /* offset of struct flow_dissector_key_*
138			  in target the struct */
139};
140
141struct flow_dissector {
142	unsigned int used_keys; /* each bit repesents presence of one key id */
143	unsigned short int offset[FLOW_DISSECTOR_KEY_MAX];
144};
145
146struct flow_keys {
147	struct flow_dissector_key_control control;
148#define FLOW_KEYS_HASH_START_FIELD basic
149	struct flow_dissector_key_basic basic;
150	struct flow_dissector_key_tags tags;
 
151	struct flow_dissector_key_keyid keyid;
152	struct flow_dissector_key_ports ports;
153	struct flow_dissector_key_addrs addrs;
154};
155
156#define FLOW_KEYS_HASH_OFFSET		\
157	offsetof(struct flow_keys, FLOW_KEYS_HASH_START_FIELD)
158
159__be32 flow_get_u32_src(const struct flow_keys *flow);
160__be32 flow_get_u32_dst(const struct flow_keys *flow);
161
162extern struct flow_dissector flow_keys_dissector;
163extern struct flow_dissector flow_keys_buf_dissector;
164
165/* struct flow_keys_digest:
166 *
167 * This structure is used to hold a digest of the full flow keys. This is a
168 * larger "hash" of a flow to allow definitively matching specific flows where
169 * the 32 bit skb->hash is not large enough. The size is limited to 16 bytes so
170 * that it can by used in CB of skb (see sch_choke for an example).
171 */
172#define FLOW_KEYS_DIGEST_LEN	16
173struct flow_keys_digest {
174	u8	data[FLOW_KEYS_DIGEST_LEN];
175};
176
177void make_flow_keys_digest(struct flow_keys_digest *digest,
178			   const struct flow_keys *flow);
179
180static inline bool flow_keys_have_l4(struct flow_keys *keys)
181{
182	return (keys->ports.ports || keys->tags.flow_label);
183}
184
185u32 flow_hash_from_keys(struct flow_keys *keys);
186
187static inline bool dissector_uses_key(const struct flow_dissector *flow_dissector,
188				      enum flow_dissector_key_id key_id)
189{
190	return flow_dissector->used_keys & (1 << key_id);
191}
192
193static inline void *skb_flow_dissector_target(struct flow_dissector *flow_dissector,
194					      enum flow_dissector_key_id key_id,
195					      void *target_container)
196{
197	return ((char *)target_container) + flow_dissector->offset[key_id];
198}
199
200#endif

  1#ifndef _NET_FLOW_DISSECTOR_H
  2#define _NET_FLOW_DISSECTOR_H
  3
  4#include <linux/types.h>
  5#include <linux/in6.h>
  6#include <uapi/linux/if_ether.h>
  7
  8/**
  9 * struct flow_dissector_key_control:
 10 * @thoff: Transport header offset
 11 */
 12struct flow_dissector_key_control {
 13	u16	thoff;
 14	u16	addr_type;
 15	u32	flags;
 16};
 17
 18#define FLOW_DIS_IS_FRAGMENT	BIT(0)
 19#define FLOW_DIS_FIRST_FRAG	BIT(1)
 20#define FLOW_DIS_ENCAPSULATION	BIT(2)
 21
 22/**
 23 * struct flow_dissector_key_basic:
 24 * @thoff: Transport header offset
 25 * @n_proto: Network header protocol (eg. IPv4/IPv6)
 26 * @ip_proto: Transport header protocol (eg. TCP/UDP)
 27 */
 28struct flow_dissector_key_basic {
 29	__be16	n_proto;
 30	u8	ip_proto;
 31	u8	padding;
 32};
 33
 34struct flow_dissector_key_tags {
 35	u32	flow_label;
 36};
 37
 38struct flow_dissector_key_vlan {
 39	u16	vlan_id:12,
 40		vlan_priority:3;
 41	u16	padding;
 42};
 43
 44struct flow_dissector_key_keyid {
 45	__be32	keyid;
 46};
 47
 48/**
 49 * struct flow_dissector_key_ipv4_addrs:
 50 * @src: source ip address
 51 * @dst: destination ip address
 52 */
 53struct flow_dissector_key_ipv4_addrs {
 54	/* (src,dst) must be grouped, in the same way than in IP header */
 55	__be32 src;
 56	__be32 dst;
 57};
 58
 59/**
 60 * struct flow_dissector_key_ipv6_addrs:
 61 * @src: source ip address
 62 * @dst: destination ip address
 63 */
 64struct flow_dissector_key_ipv6_addrs {
 65	/* (src,dst) must be grouped, in the same way than in IP header */
 66	struct in6_addr src;
 67	struct in6_addr dst;
 68};
 69
 70/**
 71 * struct flow_dissector_key_tipc_addrs:
 72 * @srcnode: source node address
 73 */
 74struct flow_dissector_key_tipc_addrs {
 75	__be32 srcnode;
 76};
 77
 78/**
 79 * struct flow_dissector_key_addrs:
 80 * @v4addrs: IPv4 addresses
 81 * @v6addrs: IPv6 addresses
 82 */
 83struct flow_dissector_key_addrs {
 84	union {
 85		struct flow_dissector_key_ipv4_addrs v4addrs;
 86		struct flow_dissector_key_ipv6_addrs v6addrs;
 87		struct flow_dissector_key_tipc_addrs tipcaddrs;
 88	};
 89};
 90
 91/**
 92 * flow_dissector_key_tp_ports:
 93 *	@ports: port numbers of Transport header
 94 *		src: source port number
 95 *		dst: destination port number
 96 */
 97struct flow_dissector_key_ports {
 98	union {
 99		__be32 ports;
100		struct {
101			__be16 src;
102			__be16 dst;
103		};
104	};
105};
106
107/**
108 * flow_dissector_key_icmp:
109 *	@ports: type and code of ICMP header
110 *		icmp: ICMP type (high) and code (low)
111 *		type: ICMP type
112 *		code: ICMP code
113 */
114struct flow_dissector_key_icmp {
115	union {
116		__be16 icmp;
117		struct {
118			u8 type;
119			u8 code;
120		};
121	};
122};
123
124/**
125 * struct flow_dissector_key_eth_addrs:
126 * @src: source Ethernet address
127 * @dst: destination Ethernet address
128 */
129struct flow_dissector_key_eth_addrs {
130	/* (dst,src) must be grouped, in the same way than in ETH header */
131	unsigned char dst[ETH_ALEN];
132	unsigned char src[ETH_ALEN];
133};
134
135enum flow_dissector_key_id {
136	FLOW_DISSECTOR_KEY_CONTROL, /* struct flow_dissector_key_control */
137	FLOW_DISSECTOR_KEY_BASIC, /* struct flow_dissector_key_basic */
138	FLOW_DISSECTOR_KEY_IPV4_ADDRS, /* struct flow_dissector_key_ipv4_addrs */
139	FLOW_DISSECTOR_KEY_IPV6_ADDRS, /* struct flow_dissector_key_ipv6_addrs */
140	FLOW_DISSECTOR_KEY_PORTS, /* struct flow_dissector_key_ports */
141	FLOW_DISSECTOR_KEY_ICMP, /* struct flow_dissector_key_icmp */
142	FLOW_DISSECTOR_KEY_ETH_ADDRS, /* struct flow_dissector_key_eth_addrs */
143	FLOW_DISSECTOR_KEY_TIPC_ADDRS, /* struct flow_dissector_key_tipc_addrs */
144	FLOW_DISSECTOR_KEY_VLAN, /* struct flow_dissector_key_flow_vlan */
145	FLOW_DISSECTOR_KEY_FLOW_LABEL, /* struct flow_dissector_key_flow_tags */
146	FLOW_DISSECTOR_KEY_GRE_KEYID, /* struct flow_dissector_key_keyid */
147	FLOW_DISSECTOR_KEY_MPLS_ENTROPY, /* struct flow_dissector_key_keyid */
148	FLOW_DISSECTOR_KEY_ENC_KEYID, /* struct flow_dissector_key_keyid */
149	FLOW_DISSECTOR_KEY_ENC_IPV4_ADDRS, /* struct flow_dissector_key_ipv4_addrs */
150	FLOW_DISSECTOR_KEY_ENC_IPV6_ADDRS, /* struct flow_dissector_key_ipv6_addrs */
151	FLOW_DISSECTOR_KEY_ENC_CONTROL, /* struct flow_dissector_key_control */
152	FLOW_DISSECTOR_KEY_ENC_PORTS, /* struct flow_dissector_key_ports */
153
154	FLOW_DISSECTOR_KEY_MAX,
155};
156
157#define FLOW_DISSECTOR_F_PARSE_1ST_FRAG		BIT(0)
158#define FLOW_DISSECTOR_F_STOP_AT_L3		BIT(1)
159#define FLOW_DISSECTOR_F_STOP_AT_FLOW_LABEL	BIT(2)
160#define FLOW_DISSECTOR_F_STOP_AT_ENCAP		BIT(3)
161
162struct flow_dissector_key {
163	enum flow_dissector_key_id key_id;
164	size_t offset; /* offset of struct flow_dissector_key_*
165			  in target the struct */
166};
167
168struct flow_dissector {
169	unsigned int used_keys; /* each bit repesents presence of one key id */
170	unsigned short int offset[FLOW_DISSECTOR_KEY_MAX];
171};
172
173struct flow_keys {
174	struct flow_dissector_key_control control;
175#define FLOW_KEYS_HASH_START_FIELD basic
176	struct flow_dissector_key_basic basic;
177	struct flow_dissector_key_tags tags;
178	struct flow_dissector_key_vlan vlan;
179	struct flow_dissector_key_keyid keyid;
180	struct flow_dissector_key_ports ports;
181	struct flow_dissector_key_addrs addrs;
182};
183
184#define FLOW_KEYS_HASH_OFFSET		\
185	offsetof(struct flow_keys, FLOW_KEYS_HASH_START_FIELD)
186
187__be32 flow_get_u32_src(const struct flow_keys *flow);
188__be32 flow_get_u32_dst(const struct flow_keys *flow);
189
190extern struct flow_dissector flow_keys_dissector;
191extern struct flow_dissector flow_keys_buf_dissector;
192
193/* struct flow_keys_digest:
194 *
195 * This structure is used to hold a digest of the full flow keys. This is a
196 * larger "hash" of a flow to allow definitively matching specific flows where
197 * the 32 bit skb->hash is not large enough. The size is limited to 16 bytes so
198 * that it can by used in CB of skb (see sch_choke for an example).
199 */
200#define FLOW_KEYS_DIGEST_LEN	16
201struct flow_keys_digest {
202	u8	data[FLOW_KEYS_DIGEST_LEN];
203};
204
205void make_flow_keys_digest(struct flow_keys_digest *digest,
206			   const struct flow_keys *flow);
207
208static inline bool flow_keys_have_l4(const struct flow_keys *keys)
209{
210	return (keys->ports.ports || keys->tags.flow_label);
211}
212
213u32 flow_hash_from_keys(struct flow_keys *keys);
214
215static inline bool dissector_uses_key(const struct flow_dissector *flow_dissector,
216				      enum flow_dissector_key_id key_id)
217{
218	return flow_dissector->used_keys & (1 << key_id);
219}
220
221static inline void *skb_flow_dissector_target(struct flow_dissector *flow_dissector,
222					      enum flow_dissector_key_id key_id,
223					      void *target_container)
224{
225	return ((char *)target_container) + flow_dissector->offset[key_id];
226}
227
228#endif