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