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