[linux-2.6-block.git] / include / net / flow_dissector.h

#ifndef _NET_FLOW_DISSECTOR_H
#define _NET_FLOW_DISSECTOR_H

#include <linux/types.h>
#include <linux/skbuff.h>
#include <linux/in6.h>
#include <uapi/linux/if_ether.h>

/**
 * struct flow_dissector_key_control:
 * @thoff: Transport header offset
 */
struct flow_dissector_key_control {
	u16	thoff;
	u16	addr_type;
};

/**
 * struct flow_dissector_key_basic:
 * @thoff: Transport header offset
 * @n_proto: Network header protocol (eg. IPv4/IPv6)
 * @ip_proto: Transport header protocol (eg. TCP/UDP)
 */
struct flow_dissector_key_basic {
	__be16	n_proto;
	u8	ip_proto;
	u8	padding;
};

struct flow_dissector_key_tags {
	u32	vlan_id:12,
		flow_label:20;
};

struct flow_dissector_key_keyid {
	__be32	keyid;
};

/**
 * struct flow_dissector_key_ipv4_addrs:
 * @src: source ip address
 * @dst: destination ip address
 */
struct flow_dissector_key_ipv4_addrs {
	/* (src,dst) must be grouped, in the same way than in IP header */
	__be32 src;
	__be32 dst;
};

/**
 * struct flow_dissector_key_ipv6_addrs:
 * @src: source ip address
 * @dst: destination ip address
 */
struct flow_dissector_key_ipv6_addrs {
	/* (src,dst) must be grouped, in the same way than in IP header */
	struct in6_addr src;
	struct in6_addr dst;
};

/**
 * struct flow_dissector_key_tipc_addrs:
 * @srcnode: source node address
 */
struct flow_dissector_key_tipc_addrs {
	__be32 srcnode;
};

/**
 * struct flow_dissector_key_addrs:
 * @v4addrs: IPv4 addresses
 * @v6addrs: IPv6 addresses
 */
struct flow_dissector_key_addrs {
	union {
		struct flow_dissector_key_ipv4_addrs v4addrs;
		struct flow_dissector_key_ipv6_addrs v6addrs;
		struct flow_dissector_key_tipc_addrs tipcaddrs;
	};
};

/**
 * flow_dissector_key_tp_ports:
 *	@ports: port numbers of Transport header
 *		src: source port number
 *		dst: destination port number
 */
struct flow_dissector_key_ports {
	union {
		__be32 ports;
		struct {
			__be16 src;
			__be16 dst;
		};
	};
};


/**
 * struct flow_dissector_key_eth_addrs:
 * @src: source Ethernet address
 * @dst: destination Ethernet address
 */
struct flow_dissector_key_eth_addrs {
	/* (dst,src) must be grouped, in the same way than in ETH header */
	unsigned char dst[ETH_ALEN];
	unsigned char src[ETH_ALEN];
};

enum flow_dissector_key_id {
	FLOW_DISSECTOR_KEY_CONTROL, /* struct flow_dissector_key_control */
	FLOW_DISSECTOR_KEY_BASIC, /* struct flow_dissector_key_basic */
	FLOW_DISSECTOR_KEY_IPV4_ADDRS, /* struct flow_dissector_key_ipv4_addrs */
	FLOW_DISSECTOR_KEY_IPV6_ADDRS, /* struct flow_dissector_key_ipv6_addrs */
	FLOW_DISSECTOR_KEY_PORTS, /* struct flow_dissector_key_ports */
	FLOW_DISSECTOR_KEY_ETH_ADDRS, /* struct flow_dissector_key_eth_addrs */
	FLOW_DISSECTOR_KEY_TIPC_ADDRS, /* struct flow_dissector_key_tipc_addrs */
	FLOW_DISSECTOR_KEY_VLANID, /* struct flow_dissector_key_flow_tags */
	FLOW_DISSECTOR_KEY_FLOW_LABEL, /* struct flow_dissector_key_flow_tags */
	FLOW_DISSECTOR_KEY_GRE_KEYID, /* struct flow_dissector_key_keyid */
	FLOW_DISSECTOR_KEY_MPLS_ENTROPY, /* struct flow_dissector_key_keyid */

	FLOW_DISSECTOR_KEY_MAX,
};

struct flow_dissector_key {
	enum flow_dissector_key_id key_id;
	size_t offset; /* offset of struct flow_dissector_key_*
			  in target the struct */
};

struct flow_dissector {
	unsigned int used_keys; /* each bit repesents presence of one key id */
	unsigned short int offset[FLOW_DISSECTOR_KEY_MAX];
};

void skb_flow_dissector_init(struct flow_dissector *flow_dissector,
			     const struct flow_dissector_key *key,
			     unsigned int key_count);

bool __skb_flow_dissect(const struct sk_buff *skb,
			struct flow_dissector *flow_dissector,
			void *target_container,
			void *data, __be16 proto, int nhoff, int hlen);

static inline bool skb_flow_dissect(const struct sk_buff *skb,
				    struct flow_dissector *flow_dissector,
				    void *target_container)
{
	return __skb_flow_dissect(skb, flow_dissector, target_container,
				  NULL, 0, 0, 0);
}

struct flow_keys {
	struct flow_dissector_key_control control;
#define FLOW_KEYS_HASH_START_FIELD basic
	struct flow_dissector_key_basic basic;
	struct flow_dissector_key_tags tags;
	struct flow_dissector_key_keyid keyid;
	struct flow_dissector_key_ports ports;
	struct flow_dissector_key_addrs addrs;
};

#define FLOW_KEYS_HASH_OFFSET		\
	offsetof(struct flow_keys, FLOW_KEYS_HASH_START_FIELD)

__be32 flow_get_u32_src(const struct flow_keys *flow);
__be32 flow_get_u32_dst(const struct flow_keys *flow);

extern struct flow_dissector flow_keys_dissector;
extern struct flow_dissector flow_keys_buf_dissector;

static inline bool skb_flow_dissect_flow_keys(const struct sk_buff *skb,
					      struct flow_keys *flow)
{
	memset(flow, 0, sizeof(*flow));
	return __skb_flow_dissect(skb, &flow_keys_dissector, flow,
				  NULL, 0, 0, 0);
}

static inline bool skb_flow_dissect_flow_keys_buf(struct flow_keys *flow,
						  void *data, __be16 proto,
						  int nhoff, int hlen)
{
	memset(flow, 0, sizeof(*flow));
	return __skb_flow_dissect(NULL, &flow_keys_buf_dissector, flow,
				  data, proto, nhoff, hlen);
}

__be32 __skb_flow_get_ports(const struct sk_buff *skb, int thoff, u8 ip_proto,
			    void *data, int hlen_proto);

static inline __be32 skb_flow_get_ports(const struct sk_buff *skb,
					int thoff, u8 ip_proto)
{
	return __skb_flow_get_ports(skb, thoff, ip_proto, NULL, 0);
}

u32 flow_hash_from_keys(struct flow_keys *keys);
void __skb_get_hash(struct sk_buff *skb);
u32 skb_get_poff(const struct sk_buff *skb);
u32 __skb_get_poff(const struct sk_buff *skb, void *data,
		   const struct flow_keys *keys, int hlen);

/* struct flow_keys_digest:
 *
 * This structure is used to hold a digest of the full flow keys. This is a
 * larger "hash" of a flow to allow definitively matching specific flows where
 * the 32 bit skb->hash is not large enough. The size is limited to 16 bytes so
 * that it can by used in CB of skb (see sch_choke for an example).
 */
#define FLOW_KEYS_DIGEST_LEN	16
struct flow_keys_digest {
	u8	data[FLOW_KEYS_DIGEST_LEN];
};

void make_flow_keys_digest(struct flow_keys_digest *digest,
			   const struct flow_keys *flow);

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