1 // SPDX-License-Identifier: GPL-2.0-only 1 // SPDX-License-Identifier: GPL-2.0-only
2 /* 2 /*
3 * Copyright (c) 2007-2014 Nicira, Inc. 3 * Copyright (c) 2007-2014 Nicira, Inc.
4 */ 4 */
5 5
6 #include <linux/uaccess.h> 6 #include <linux/uaccess.h>
7 #include <linux/netdevice.h> 7 #include <linux/netdevice.h>
8 #include <linux/etherdevice.h> 8 #include <linux/etherdevice.h>
9 #include <linux/if_ether.h> 9 #include <linux/if_ether.h>
10 #include <linux/if_vlan.h> 10 #include <linux/if_vlan.h>
11 #include <net/llc_pdu.h> 11 #include <net/llc_pdu.h>
12 #include <linux/kernel.h> 12 #include <linux/kernel.h>
13 #include <linux/jhash.h> 13 #include <linux/jhash.h>
14 #include <linux/jiffies.h> 14 #include <linux/jiffies.h>
15 #include <linux/llc.h> 15 #include <linux/llc.h>
16 #include <linux/module.h> 16 #include <linux/module.h>
17 #include <linux/in.h> 17 #include <linux/in.h>
18 #include <linux/rcupdate.h> 18 #include <linux/rcupdate.h>
19 #include <linux/cpumask.h> 19 #include <linux/cpumask.h>
20 #include <linux/if_arp.h> 20 #include <linux/if_arp.h>
21 #include <linux/ip.h> 21 #include <linux/ip.h>
22 #include <linux/ipv6.h> 22 #include <linux/ipv6.h>
23 #include <linux/mpls.h> 23 #include <linux/mpls.h>
24 #include <linux/sctp.h> 24 #include <linux/sctp.h>
25 #include <linux/smp.h> 25 #include <linux/smp.h>
26 #include <linux/tcp.h> 26 #include <linux/tcp.h>
27 #include <linux/udp.h> 27 #include <linux/udp.h>
28 #include <linux/icmp.h> 28 #include <linux/icmp.h>
29 #include <linux/icmpv6.h> 29 #include <linux/icmpv6.h>
30 #include <linux/rculist.h> 30 #include <linux/rculist.h>
31 #include <net/ip.h> 31 #include <net/ip.h>
32 #include <net/ip_tunnels.h> 32 #include <net/ip_tunnels.h>
33 #include <net/ipv6.h> 33 #include <net/ipv6.h>
34 #include <net/mpls.h> 34 #include <net/mpls.h>
35 #include <net/ndisc.h> 35 #include <net/ndisc.h>
36 #include <net/nsh.h> 36 #include <net/nsh.h>
37 #include <net/pkt_cls.h> <<
38 #include <net/netfilter/nf_conntrack_zones.h> <<
39 37
40 #include "conntrack.h" 38 #include "conntrack.h"
41 #include "datapath.h" 39 #include "datapath.h"
42 #include "flow.h" 40 #include "flow.h"
43 #include "flow_netlink.h" 41 #include "flow_netlink.h"
44 #include "vport.h" 42 #include "vport.h"
45 43
46 u64 ovs_flow_used_time(unsigned long flow_jiff 44 u64 ovs_flow_used_time(unsigned long flow_jiffies)
47 { 45 {
48 struct timespec64 cur_ts; 46 struct timespec64 cur_ts;
49 u64 cur_ms, idle_ms; 47 u64 cur_ms, idle_ms;
50 48
51 ktime_get_ts64(&cur_ts); 49 ktime_get_ts64(&cur_ts);
52 idle_ms = jiffies_to_msecs(jiffies - f 50 idle_ms = jiffies_to_msecs(jiffies - flow_jiffies);
53 cur_ms = (u64)(u32)cur_ts.tv_sec * MSE 51 cur_ms = (u64)(u32)cur_ts.tv_sec * MSEC_PER_SEC +
54 cur_ts.tv_nsec / NSEC_PER_MSE 52 cur_ts.tv_nsec / NSEC_PER_MSEC;
55 53
56 return cur_ms - idle_ms; 54 return cur_ms - idle_ms;
57 } 55 }
58 56
59 #define TCP_FLAGS_BE16(tp) (*(__be16 *)&tcp_fl 57 #define TCP_FLAGS_BE16(tp) (*(__be16 *)&tcp_flag_word(tp) & htons(0x0FFF))
60 58
61 void ovs_flow_stats_update(struct sw_flow *flo 59 void ovs_flow_stats_update(struct sw_flow *flow, __be16 tcp_flags,
62 const struct sk_buf 60 const struct sk_buff *skb)
63 { 61 {
64 struct sw_flow_stats *stats; 62 struct sw_flow_stats *stats;
65 unsigned int cpu = smp_processor_id(); 63 unsigned int cpu = smp_processor_id();
66 int len = skb->len + (skb_vlan_tag_pre 64 int len = skb->len + (skb_vlan_tag_present(skb) ? VLAN_HLEN : 0);
67 65
68 stats = rcu_dereference(flow->stats[cp 66 stats = rcu_dereference(flow->stats[cpu]);
69 67
70 /* Check if already have CPU-specific 68 /* Check if already have CPU-specific stats. */
71 if (likely(stats)) { 69 if (likely(stats)) {
72 spin_lock(&stats->lock); 70 spin_lock(&stats->lock);
73 /* Mark if we write on the pre 71 /* Mark if we write on the pre-allocated stats. */
74 if (cpu == 0 && unlikely(flow- 72 if (cpu == 0 && unlikely(flow->stats_last_writer != cpu))
75 flow->stats_last_write 73 flow->stats_last_writer = cpu;
76 } else { 74 } else {
77 stats = rcu_dereference(flow-> 75 stats = rcu_dereference(flow->stats[0]); /* Pre-allocated. */
78 spin_lock(&stats->lock); 76 spin_lock(&stats->lock);
79 77
80 /* If the current CPU is the o 78 /* If the current CPU is the only writer on the
81 * pre-allocated stats keep us 79 * pre-allocated stats keep using them.
82 */ 80 */
83 if (unlikely(flow->stats_last_ 81 if (unlikely(flow->stats_last_writer != cpu)) {
84 /* A previous locker m 82 /* A previous locker may have already allocated the
85 * stats, so we need t 83 * stats, so we need to check again. If CPU-specific
86 * stats were already 84 * stats were already allocated, we update the pre-
87 * allocated stats as 85 * allocated stats as we have already locked them.
88 */ 86 */
89 if (likely(flow->stats 87 if (likely(flow->stats_last_writer != -1) &&
90 likely(!rcu_access 88 likely(!rcu_access_pointer(flow->stats[cpu]))) {
91 /* Try to allo 89 /* Try to allocate CPU-specific stats. */
92 struct sw_flow 90 struct sw_flow_stats *new_stats;
93 91
94 new_stats = 92 new_stats =
95 kmem_c 93 kmem_cache_alloc_node(flow_stats_cache,
96 94 GFP_NOWAIT |
97 95 __GFP_THISNODE |
98 96 __GFP_NOWARN |
99 97 __GFP_NOMEMALLOC,
100 98 numa_node_id());
101 if (likely(new 99 if (likely(new_stats)) {
102 new_st 100 new_stats->used = jiffies;
103 new_st 101 new_stats->packet_count = 1;
104 new_st 102 new_stats->byte_count = len;
105 new_st 103 new_stats->tcp_flags = tcp_flags;
106 spin_l 104 spin_lock_init(&new_stats->lock);
107 105
108 rcu_as 106 rcu_assign_pointer(flow->stats[cpu],
109 107 new_stats);
110 cpumas !! 108 cpumask_set_cpu(cpu, &flow->cpu_used_mask);
111 <<
112 goto u 109 goto unlock;
113 } 110 }
114 } 111 }
115 flow->stats_last_write 112 flow->stats_last_writer = cpu;
116 } 113 }
117 } 114 }
118 115
119 stats->used = jiffies; 116 stats->used = jiffies;
120 stats->packet_count++; 117 stats->packet_count++;
121 stats->byte_count += len; 118 stats->byte_count += len;
122 stats->tcp_flags |= tcp_flags; 119 stats->tcp_flags |= tcp_flags;
123 unlock: 120 unlock:
124 spin_unlock(&stats->lock); 121 spin_unlock(&stats->lock);
125 } 122 }
126 123
127 /* Must be called with rcu_read_lock or ovs_mu 124 /* Must be called with rcu_read_lock or ovs_mutex. */
128 void ovs_flow_stats_get(const struct sw_flow * 125 void ovs_flow_stats_get(const struct sw_flow *flow,
129 struct ovs_flow_stats 126 struct ovs_flow_stats *ovs_stats,
130 unsigned long *used, _ 127 unsigned long *used, __be16 *tcp_flags)
131 { 128 {
132 int cpu; 129 int cpu;
133 130
134 *used = 0; 131 *used = 0;
135 *tcp_flags = 0; 132 *tcp_flags = 0;
136 memset(ovs_stats, 0, sizeof(*ovs_stats 133 memset(ovs_stats, 0, sizeof(*ovs_stats));
137 134
138 /* We open code this to make sure cpu 135 /* We open code this to make sure cpu 0 is always considered */
139 for (cpu = 0; cpu < nr_cpu_ids; !! 136 for (cpu = 0; cpu < nr_cpu_ids; cpu = cpumask_next(cpu, &flow->cpu_used_mask)) {
140 cpu = cpumask_next(cpu, flow->cpu <<
141 struct sw_flow_stats *stats = 137 struct sw_flow_stats *stats = rcu_dereference_ovsl(flow->stats[cpu]);
142 138
143 if (stats) { 139 if (stats) {
144 /* Local CPU may write 140 /* Local CPU may write on non-local stats, so we must
145 * block bottom-halves 141 * block bottom-halves here.
146 */ 142 */
147 spin_lock_bh(&stats->l 143 spin_lock_bh(&stats->lock);
148 if (!*used || time_aft 144 if (!*used || time_after(stats->used, *used))
149 *used = stats- 145 *used = stats->used;
150 *tcp_flags |= stats->t 146 *tcp_flags |= stats->tcp_flags;
151 ovs_stats->n_packets + 147 ovs_stats->n_packets += stats->packet_count;
152 ovs_stats->n_bytes += 148 ovs_stats->n_bytes += stats->byte_count;
153 spin_unlock_bh(&stats- 149 spin_unlock_bh(&stats->lock);
154 } 150 }
155 } 151 }
156 } 152 }
157 153
158 /* Called with ovs_mutex. */ 154 /* Called with ovs_mutex. */
159 void ovs_flow_stats_clear(struct sw_flow *flow 155 void ovs_flow_stats_clear(struct sw_flow *flow)
160 { 156 {
161 int cpu; 157 int cpu;
162 158
163 /* We open code this to make sure cpu 159 /* We open code this to make sure cpu 0 is always considered */
164 for (cpu = 0; cpu < nr_cpu_ids; !! 160 for (cpu = 0; cpu < nr_cpu_ids; cpu = cpumask_next(cpu, &flow->cpu_used_mask)) {
165 cpu = cpumask_next(cpu, flow->cpu <<
166 struct sw_flow_stats *stats = 161 struct sw_flow_stats *stats = ovsl_dereference(flow->stats[cpu]);
167 162
168 if (stats) { 163 if (stats) {
169 spin_lock_bh(&stats->l 164 spin_lock_bh(&stats->lock);
170 stats->used = 0; 165 stats->used = 0;
171 stats->packet_count = 166 stats->packet_count = 0;
172 stats->byte_count = 0; 167 stats->byte_count = 0;
173 stats->tcp_flags = 0; 168 stats->tcp_flags = 0;
174 spin_unlock_bh(&stats- 169 spin_unlock_bh(&stats->lock);
175 } 170 }
176 } 171 }
177 } 172 }
178 173
179 static int check_header(struct sk_buff *skb, i 174 static int check_header(struct sk_buff *skb, int len)
180 { 175 {
181 if (unlikely(skb->len < len)) 176 if (unlikely(skb->len < len))
182 return -EINVAL; 177 return -EINVAL;
183 if (unlikely(!pskb_may_pull(skb, len)) 178 if (unlikely(!pskb_may_pull(skb, len)))
184 return -ENOMEM; 179 return -ENOMEM;
185 return 0; 180 return 0;
186 } 181 }
187 182
188 static bool arphdr_ok(struct sk_buff *skb) 183 static bool arphdr_ok(struct sk_buff *skb)
189 { 184 {
190 return pskb_may_pull(skb, skb_network_ 185 return pskb_may_pull(skb, skb_network_offset(skb) +
191 sizeof(struc 186 sizeof(struct arp_eth_header));
192 } 187 }
193 188
194 static int check_iphdr(struct sk_buff *skb) 189 static int check_iphdr(struct sk_buff *skb)
195 { 190 {
196 unsigned int nh_ofs = skb_network_offs 191 unsigned int nh_ofs = skb_network_offset(skb);
197 unsigned int ip_len; 192 unsigned int ip_len;
198 int err; 193 int err;
199 194
200 err = check_header(skb, nh_ofs + sizeo 195 err = check_header(skb, nh_ofs + sizeof(struct iphdr));
201 if (unlikely(err)) 196 if (unlikely(err))
202 return err; 197 return err;
203 198
204 ip_len = ip_hdrlen(skb); 199 ip_len = ip_hdrlen(skb);
205 if (unlikely(ip_len < sizeof(struct ip 200 if (unlikely(ip_len < sizeof(struct iphdr) ||
206 skb->len < nh_ofs + ip_le 201 skb->len < nh_ofs + ip_len))
207 return -EINVAL; 202 return -EINVAL;
208 203
209 skb_set_transport_header(skb, nh_ofs + 204 skb_set_transport_header(skb, nh_ofs + ip_len);
210 return 0; 205 return 0;
211 } 206 }
212 207
213 static bool tcphdr_ok(struct sk_buff *skb) 208 static bool tcphdr_ok(struct sk_buff *skb)
214 { 209 {
215 int th_ofs = skb_transport_offset(skb) 210 int th_ofs = skb_transport_offset(skb);
216 int tcp_len; 211 int tcp_len;
217 212
218 if (unlikely(!pskb_may_pull(skb, th_of 213 if (unlikely(!pskb_may_pull(skb, th_ofs + sizeof(struct tcphdr))))
219 return false; 214 return false;
220 215
221 tcp_len = tcp_hdrlen(skb); 216 tcp_len = tcp_hdrlen(skb);
222 if (unlikely(tcp_len < sizeof(struct t 217 if (unlikely(tcp_len < sizeof(struct tcphdr) ||
223 skb->len < th_ofs + tcp_l 218 skb->len < th_ofs + tcp_len))
224 return false; 219 return false;
225 220
226 return true; 221 return true;
227 } 222 }
228 223
229 static bool udphdr_ok(struct sk_buff *skb) 224 static bool udphdr_ok(struct sk_buff *skb)
230 { 225 {
231 return pskb_may_pull(skb, skb_transpor 226 return pskb_may_pull(skb, skb_transport_offset(skb) +
232 sizeof(struc 227 sizeof(struct udphdr));
233 } 228 }
234 229
235 static bool sctphdr_ok(struct sk_buff *skb) 230 static bool sctphdr_ok(struct sk_buff *skb)
236 { 231 {
237 return pskb_may_pull(skb, skb_transpor 232 return pskb_may_pull(skb, skb_transport_offset(skb) +
238 sizeof(struc 233 sizeof(struct sctphdr));
239 } 234 }
240 235
241 static bool icmphdr_ok(struct sk_buff *skb) 236 static bool icmphdr_ok(struct sk_buff *skb)
242 { 237 {
243 return pskb_may_pull(skb, skb_transpor 238 return pskb_may_pull(skb, skb_transport_offset(skb) +
244 sizeof(struc 239 sizeof(struct icmphdr));
245 } 240 }
246 241
247 /** <<
248 * get_ipv6_ext_hdrs() - Parses packet and set <<
249 * <<
250 * @skb: buffer where extension header data st <<
251 * @nh: ipv6 header <<
252 * @ext_hdrs: flags are stored here <<
253 * <<
254 * OFPIEH12_UNREP is set if more than one of a <<
255 * is unexpectedly encountered. (Two destinati <<
256 * expected and would not cause this bit to be <<
257 * <<
258 * OFPIEH12_UNSEQ is set if IPv6 extension hea <<
259 * preferred (but not required) by RFC 2460: <<
260 * <<
261 * When more than one extension header is used <<
262 * recommended that those headers appear in th <<
263 * IPv6 header <<
264 * Hop-by-Hop Options header <<
265 * Destination Options header <<
266 * Routing header <<
267 * Fragment header <<
268 * Authentication header <<
269 * Encapsulating Security Payload header <<
270 * Destination Options header <<
271 * upper-layer header <<
272 */ <<
273 static void get_ipv6_ext_hdrs(struct sk_buff * <<
274 u16 *ext_hdrs) <<
275 { <<
276 u8 next_type = nh->nexthdr; <<
277 unsigned int start = skb_network_offse <<
278 int dest_options_header_count = 0; <<
279 <<
280 *ext_hdrs = 0; <<
281 <<
282 while (ipv6_ext_hdr(next_type)) { <<
283 struct ipv6_opt_hdr _hdr, *hp; <<
284 <<
285 switch (next_type) { <<
286 case IPPROTO_NONE: <<
287 *ext_hdrs |= OFPIEH12_ <<
288 /* stop parsing */ <<
289 return; <<
290 <<
291 case IPPROTO_ESP: <<
292 if (*ext_hdrs & OFPIEH <<
293 *ext_hdrs |= O <<
294 if ((*ext_hdrs & ~(OFP <<
295 OFP <<
296 OFP <<
297 dest_options_heade <<
298 *ext_hdrs |= O <<
299 } <<
300 *ext_hdrs |= OFPIEH12_ <<
301 break; <<
302 <<
303 case IPPROTO_AH: <<
304 if (*ext_hdrs & OFPIEH <<
305 *ext_hdrs |= O <<
306 if ((*ext_hdrs & <<
307 ~(OFPIEH12_HOP | <<
308 IPPROTO_FRAGMEN <<
309 dest_options_heade <<
310 *ext_hdrs |= O <<
311 } <<
312 *ext_hdrs |= OFPIEH12_ <<
313 break; <<
314 <<
315 case IPPROTO_DSTOPTS: <<
316 if (dest_options_heade <<
317 if (*ext_hdrs <<
318 ~(OFPIEH12 <<
319 *ext_h <<
320 *ext_hdrs |= O <<
321 } else if (dest_option <<
322 if (*ext_hdrs <<
323 ~(OFPIEH12 <<
324 OFPIEH12 <<
325 OFPIEH12 <<
326 OFPIEH12 <<
327 *ext_h <<
328 } <<
329 } else { <<
330 *ext_hdrs |= O <<
331 } <<
332 dest_options_header_co <<
333 break; <<
334 <<
335 case IPPROTO_FRAGMENT: <<
336 if (*ext_hdrs & OFPIEH <<
337 *ext_hdrs |= O <<
338 if ((*ext_hdrs & ~(OFP <<
339 OFP <<
340 OFP <<
341 OFP <<
342 dest_options_heade <<
343 *ext_hdrs |= O <<
344 } <<
345 *ext_hdrs |= OFPIEH12_ <<
346 break; <<
347 <<
348 case IPPROTO_ROUTING: <<
349 if (*ext_hdrs & OFPIEH <<
350 *ext_hdrs |= O <<
351 if ((*ext_hdrs & ~(OFP <<
352 OFP <<
353 OFP <<
354 dest_options_heade <<
355 *ext_hdrs |= O <<
356 } <<
357 *ext_hdrs |= OFPIEH12_ <<
358 break; <<
359 <<
360 case IPPROTO_HOPOPTS: <<
361 if (*ext_hdrs & OFPIEH <<
362 *ext_hdrs |= O <<
363 /* OFPIEH12_HOP is set <<
364 * extension header is <<
365 * extension header in <<
366 */ <<
367 if (*ext_hdrs == 0) <<
368 *ext_hdrs |= O <<
369 else <<
370 *ext_hdrs |= O <<
371 break; <<
372 <<
373 default: <<
374 return; <<
375 } <<
376 <<
377 hp = skb_header_pointer(skb, s <<
378 if (!hp) <<
379 break; <<
380 next_type = hp->nexthdr; <<
381 start += ipv6_optlen(hp); <<
382 } <<
383 } <<
384 <<
385 static int parse_ipv6hdr(struct sk_buff *skb, 242 static int parse_ipv6hdr(struct sk_buff *skb, struct sw_flow_key *key)
386 { 243 {
387 unsigned short frag_off; 244 unsigned short frag_off;
388 unsigned int payload_ofs = 0; 245 unsigned int payload_ofs = 0;
389 unsigned int nh_ofs = skb_network_offs 246 unsigned int nh_ofs = skb_network_offset(skb);
390 unsigned int nh_len; 247 unsigned int nh_len;
391 struct ipv6hdr *nh; 248 struct ipv6hdr *nh;
392 int err, nexthdr, flags = 0; 249 int err, nexthdr, flags = 0;
393 250
394 err = check_header(skb, nh_ofs + sizeo 251 err = check_header(skb, nh_ofs + sizeof(*nh));
395 if (unlikely(err)) 252 if (unlikely(err))
396 return err; 253 return err;
397 254
398 nh = ipv6_hdr(skb); 255 nh = ipv6_hdr(skb);
399 256
400 get_ipv6_ext_hdrs(skb, nh, &key->ipv6. <<
401 <<
402 key->ip.proto = NEXTHDR_NONE; 257 key->ip.proto = NEXTHDR_NONE;
403 key->ip.tos = ipv6_get_dsfield(nh); 258 key->ip.tos = ipv6_get_dsfield(nh);
404 key->ip.ttl = nh->hop_limit; 259 key->ip.ttl = nh->hop_limit;
405 key->ipv6.label = *(__be32 *)nh & hton 260 key->ipv6.label = *(__be32 *)nh & htonl(IPV6_FLOWINFO_FLOWLABEL);
406 key->ipv6.addr.src = nh->saddr; 261 key->ipv6.addr.src = nh->saddr;
407 key->ipv6.addr.dst = nh->daddr; 262 key->ipv6.addr.dst = nh->daddr;
408 263
409 nexthdr = ipv6_find_hdr(skb, &payload_ 264 nexthdr = ipv6_find_hdr(skb, &payload_ofs, -1, &frag_off, &flags);
410 if (flags & IP6_FH_F_FRAG) { 265 if (flags & IP6_FH_F_FRAG) {
411 if (frag_off) { 266 if (frag_off) {
412 key->ip.frag = OVS_FRA 267 key->ip.frag = OVS_FRAG_TYPE_LATER;
413 key->ip.proto = NEXTHD 268 key->ip.proto = NEXTHDR_FRAGMENT;
414 return 0; 269 return 0;
415 } 270 }
416 key->ip.frag = OVS_FRAG_TYPE_F 271 key->ip.frag = OVS_FRAG_TYPE_FIRST;
417 } else { 272 } else {
418 key->ip.frag = OVS_FRAG_TYPE_N 273 key->ip.frag = OVS_FRAG_TYPE_NONE;
419 } 274 }
420 275
421 /* Delayed handling of error in ipv6_f 276 /* Delayed handling of error in ipv6_find_hdr() as it
422 * always sets flags and frag_off to a 277 * always sets flags and frag_off to a valid value which may be
423 * used to set key->ip.frag above. 278 * used to set key->ip.frag above.
424 */ 279 */
425 if (unlikely(nexthdr < 0)) 280 if (unlikely(nexthdr < 0))
426 return -EPROTO; 281 return -EPROTO;
427 282
428 nh_len = payload_ofs - nh_ofs; 283 nh_len = payload_ofs - nh_ofs;
429 skb_set_transport_header(skb, nh_ofs + 284 skb_set_transport_header(skb, nh_ofs + nh_len);
430 key->ip.proto = nexthdr; 285 key->ip.proto = nexthdr;
431 return nh_len; 286 return nh_len;
432 } 287 }
433 288
434 static bool icmp6hdr_ok(struct sk_buff *skb) 289 static bool icmp6hdr_ok(struct sk_buff *skb)
435 { 290 {
436 return pskb_may_pull(skb, skb_transpor 291 return pskb_may_pull(skb, skb_transport_offset(skb) +
437 sizeof(struc 292 sizeof(struct icmp6hdr));
438 } 293 }
439 294
440 /** 295 /**
441 * parse_vlan_tag - Parse vlan tag from vlan h !! 296 * Parse vlan tag from vlan header.
442 * @skb: skb containing frame to parse !! 297 * Returns ERROR on memory error.
443 * @key_vh: pointer to parsed vlan tag !! 298 * Returns 0 if it encounters a non-vlan or incomplete packet.
444 * @untag_vlan: should the vlan header be remo !! 299 * Returns 1 after successfully parsing vlan tag.
445 * <<
446 * Return: ERROR on memory error. <<
447 * %0 if it encounters a non-vlan or incomplet <<
448 * %1 after successfully parsing vlan tag. <<
449 */ 300 */
450 static int parse_vlan_tag(struct sk_buff *skb, 301 static int parse_vlan_tag(struct sk_buff *skb, struct vlan_head *key_vh,
451 bool untag_vlan) 302 bool untag_vlan)
452 { 303 {
453 struct vlan_head *vh = (struct vlan_he 304 struct vlan_head *vh = (struct vlan_head *)skb->data;
454 305
455 if (likely(!eth_type_vlan(vh->tpid))) 306 if (likely(!eth_type_vlan(vh->tpid)))
456 return 0; 307 return 0;
457 308
458 if (unlikely(skb->len < sizeof(struct 309 if (unlikely(skb->len < sizeof(struct vlan_head) + sizeof(__be16)))
459 return 0; 310 return 0;
460 311
461 if (unlikely(!pskb_may_pull(skb, sizeo 312 if (unlikely(!pskb_may_pull(skb, sizeof(struct vlan_head) +
462 sizeof(__be16 313 sizeof(__be16))))
463 return -ENOMEM; 314 return -ENOMEM;
464 315
465 vh = (struct vlan_head *)skb->data; 316 vh = (struct vlan_head *)skb->data;
466 key_vh->tci = vh->tci | htons(VLAN_CFI 317 key_vh->tci = vh->tci | htons(VLAN_CFI_MASK);
467 key_vh->tpid = vh->tpid; 318 key_vh->tpid = vh->tpid;
468 319
469 if (unlikely(untag_vlan)) { 320 if (unlikely(untag_vlan)) {
470 int offset = skb->data - skb_m 321 int offset = skb->data - skb_mac_header(skb);
471 u16 tci; 322 u16 tci;
472 int err; 323 int err;
473 324
474 __skb_push(skb, offset); 325 __skb_push(skb, offset);
475 err = __skb_vlan_pop(skb, &tci 326 err = __skb_vlan_pop(skb, &tci);
476 __skb_pull(skb, offset); 327 __skb_pull(skb, offset);
477 if (err) 328 if (err)
478 return err; 329 return err;
479 __vlan_hwaccel_put_tag(skb, ke 330 __vlan_hwaccel_put_tag(skb, key_vh->tpid, tci);
480 } else { 331 } else {
481 __skb_pull(skb, sizeof(struct 332 __skb_pull(skb, sizeof(struct vlan_head));
482 } 333 }
483 return 1; 334 return 1;
484 } 335 }
485 336
486 static void clear_vlan(struct sw_flow_key *key 337 static void clear_vlan(struct sw_flow_key *key)
487 { 338 {
488 key->eth.vlan.tci = 0; 339 key->eth.vlan.tci = 0;
489 key->eth.vlan.tpid = 0; 340 key->eth.vlan.tpid = 0;
490 key->eth.cvlan.tci = 0; 341 key->eth.cvlan.tci = 0;
491 key->eth.cvlan.tpid = 0; 342 key->eth.cvlan.tpid = 0;
492 } 343 }
493 344
494 static int parse_vlan(struct sk_buff *skb, str 345 static int parse_vlan(struct sk_buff *skb, struct sw_flow_key *key)
495 { 346 {
496 int res; 347 int res;
497 348
498 if (skb_vlan_tag_present(skb)) { 349 if (skb_vlan_tag_present(skb)) {
499 key->eth.vlan.tci = htons(skb- 350 key->eth.vlan.tci = htons(skb->vlan_tci) | htons(VLAN_CFI_MASK);
500 key->eth.vlan.tpid = skb->vlan 351 key->eth.vlan.tpid = skb->vlan_proto;
501 } else { 352 } else {
502 /* Parse outer vlan tag in the 353 /* Parse outer vlan tag in the non-accelerated case. */
503 res = parse_vlan_tag(skb, &key 354 res = parse_vlan_tag(skb, &key->eth.vlan, true);
504 if (res <= 0) 355 if (res <= 0)
505 return res; 356 return res;
506 } 357 }
507 358
508 /* Parse inner vlan tag. */ 359 /* Parse inner vlan tag. */
509 res = parse_vlan_tag(skb, &key->eth.cv 360 res = parse_vlan_tag(skb, &key->eth.cvlan, false);
510 if (res <= 0) 361 if (res <= 0)
511 return res; 362 return res;
512 363
513 return 0; 364 return 0;
514 } 365 }
515 366
516 static __be16 parse_ethertype(struct sk_buff * 367 static __be16 parse_ethertype(struct sk_buff *skb)
517 { 368 {
518 struct llc_snap_hdr { 369 struct llc_snap_hdr {
519 u8 dsap; /* Always 0xAA */ 370 u8 dsap; /* Always 0xAA */
520 u8 ssap; /* Always 0xAA */ 371 u8 ssap; /* Always 0xAA */
521 u8 ctrl; 372 u8 ctrl;
522 u8 oui[3]; 373 u8 oui[3];
523 __be16 ethertype; 374 __be16 ethertype;
524 }; 375 };
525 struct llc_snap_hdr *llc; 376 struct llc_snap_hdr *llc;
526 __be16 proto; 377 __be16 proto;
527 378
528 proto = *(__be16 *) skb->data; 379 proto = *(__be16 *) skb->data;
529 __skb_pull(skb, sizeof(__be16)); 380 __skb_pull(skb, sizeof(__be16));
530 381
531 if (eth_proto_is_802_3(proto)) 382 if (eth_proto_is_802_3(proto))
532 return proto; 383 return proto;
533 384
534 if (skb->len < sizeof(struct llc_snap_ 385 if (skb->len < sizeof(struct llc_snap_hdr))
535 return htons(ETH_P_802_2); 386 return htons(ETH_P_802_2);
536 387
537 if (unlikely(!pskb_may_pull(skb, sizeo 388 if (unlikely(!pskb_may_pull(skb, sizeof(struct llc_snap_hdr))))
538 return htons(0); 389 return htons(0);
539 390
540 llc = (struct llc_snap_hdr *) skb->dat 391 llc = (struct llc_snap_hdr *) skb->data;
541 if (llc->dsap != LLC_SAP_SNAP || 392 if (llc->dsap != LLC_SAP_SNAP ||
542 llc->ssap != LLC_SAP_SNAP || 393 llc->ssap != LLC_SAP_SNAP ||
543 (llc->oui[0] | llc->oui[1] | llc-> 394 (llc->oui[0] | llc->oui[1] | llc->oui[2]) != 0)
544 return htons(ETH_P_802_2); 395 return htons(ETH_P_802_2);
545 396
546 __skb_pull(skb, sizeof(struct llc_snap 397 __skb_pull(skb, sizeof(struct llc_snap_hdr));
547 398
548 if (eth_proto_is_802_3(llc->ethertype) 399 if (eth_proto_is_802_3(llc->ethertype))
549 return llc->ethertype; 400 return llc->ethertype;
550 401
551 return htons(ETH_P_802_2); 402 return htons(ETH_P_802_2);
552 } 403 }
553 404
554 static int parse_icmpv6(struct sk_buff *skb, s 405 static int parse_icmpv6(struct sk_buff *skb, struct sw_flow_key *key,
555 int nh_len) 406 int nh_len)
556 { 407 {
557 struct icmp6hdr *icmp = icmp6_hdr(skb) 408 struct icmp6hdr *icmp = icmp6_hdr(skb);
558 409
559 /* The ICMPv6 type and code fields use 410 /* The ICMPv6 type and code fields use the 16-bit transport port
560 * fields, so we need to store them in 411 * fields, so we need to store them in 16-bit network byte order.
561 */ 412 */
562 key->tp.src = htons(icmp->icmp6_type); 413 key->tp.src = htons(icmp->icmp6_type);
563 key->tp.dst = htons(icmp->icmp6_code); 414 key->tp.dst = htons(icmp->icmp6_code);
564 415
565 if (icmp->icmp6_code == 0 && 416 if (icmp->icmp6_code == 0 &&
566 (icmp->icmp6_type == NDISC_NEIGHBO 417 (icmp->icmp6_type == NDISC_NEIGHBOUR_SOLICITATION ||
567 icmp->icmp6_type == NDISC_NEIGHBO 418 icmp->icmp6_type == NDISC_NEIGHBOUR_ADVERTISEMENT)) {
568 int icmp_len = skb->len - skb_ 419 int icmp_len = skb->len - skb_transport_offset(skb);
569 struct nd_msg *nd; 420 struct nd_msg *nd;
570 int offset; 421 int offset;
571 422
572 memset(&key->ipv6.nd, 0, sizeo 423 memset(&key->ipv6.nd, 0, sizeof(key->ipv6.nd));
573 424
574 /* In order to process neighbo 425 /* In order to process neighbor discovery options, we need the
575 * entire packet. 426 * entire packet.
576 */ 427 */
577 if (unlikely(icmp_len < sizeof 428 if (unlikely(icmp_len < sizeof(*nd)))
578 return 0; 429 return 0;
579 430
580 if (unlikely(skb_linearize(skb 431 if (unlikely(skb_linearize(skb)))
581 return -ENOMEM; 432 return -ENOMEM;
582 433
583 nd = (struct nd_msg *)skb_tran 434 nd = (struct nd_msg *)skb_transport_header(skb);
584 key->ipv6.nd.target = nd->targ 435 key->ipv6.nd.target = nd->target;
585 436
586 icmp_len -= sizeof(*nd); 437 icmp_len -= sizeof(*nd);
587 offset = 0; 438 offset = 0;
588 while (icmp_len >= 8) { 439 while (icmp_len >= 8) {
589 struct nd_opt_hdr *nd_ 440 struct nd_opt_hdr *nd_opt =
590 (struct nd_op 441 (struct nd_opt_hdr *)(nd->opt + offset);
591 int opt_len = nd_opt-> 442 int opt_len = nd_opt->nd_opt_len * 8;
592 443
593 if (unlikely(!opt_len 444 if (unlikely(!opt_len || opt_len > icmp_len))
594 return 0; 445 return 0;
595 446
596 /* Store the link laye 447 /* Store the link layer address if the appropriate
597 * option is provided. 448 * option is provided. It is considered an error if
598 * the same link layer 449 * the same link layer option is specified twice.
599 */ 450 */
600 if (nd_opt->nd_opt_typ 451 if (nd_opt->nd_opt_type == ND_OPT_SOURCE_LL_ADDR
601 && opt_len == 8) { 452 && opt_len == 8) {
602 if (unlikely(! 453 if (unlikely(!is_zero_ether_addr(key->ipv6.nd.sll)))
603 goto i 454 goto invalid;
604 ether_addr_cop 455 ether_addr_copy(key->ipv6.nd.sll,
605 456 &nd->opt[offset+sizeof(*nd_opt)]);
606 } else if (nd_opt->nd_ 457 } else if (nd_opt->nd_opt_type == ND_OPT_TARGET_LL_ADDR
607 && opt_len 458 && opt_len == 8) {
608 if (unlikely(! 459 if (unlikely(!is_zero_ether_addr(key->ipv6.nd.tll)))
609 goto i 460 goto invalid;
610 ether_addr_cop 461 ether_addr_copy(key->ipv6.nd.tll,
611 462 &nd->opt[offset+sizeof(*nd_opt)]);
612 } 463 }
613 464
614 icmp_len -= opt_len; 465 icmp_len -= opt_len;
615 offset += opt_len; 466 offset += opt_len;
616 } 467 }
617 } 468 }
618 469
619 return 0; 470 return 0;
620 471
621 invalid: 472 invalid:
622 memset(&key->ipv6.nd.target, 0, sizeof 473 memset(&key->ipv6.nd.target, 0, sizeof(key->ipv6.nd.target));
623 memset(key->ipv6.nd.sll, 0, sizeof(key 474 memset(key->ipv6.nd.sll, 0, sizeof(key->ipv6.nd.sll));
624 memset(key->ipv6.nd.tll, 0, sizeof(key 475 memset(key->ipv6.nd.tll, 0, sizeof(key->ipv6.nd.tll));
625 476
626 return 0; 477 return 0;
627 } 478 }
628 479
629 static int parse_nsh(struct sk_buff *skb, stru 480 static int parse_nsh(struct sk_buff *skb, struct sw_flow_key *key)
630 { 481 {
631 struct nshhdr *nh; 482 struct nshhdr *nh;
632 unsigned int nh_ofs = skb_network_offs 483 unsigned int nh_ofs = skb_network_offset(skb);
633 u8 version, length; 484 u8 version, length;
634 int err; 485 int err;
635 486
636 err = check_header(skb, nh_ofs + NSH_B 487 err = check_header(skb, nh_ofs + NSH_BASE_HDR_LEN);
637 if (unlikely(err)) 488 if (unlikely(err))
638 return err; 489 return err;
639 490
640 nh = nsh_hdr(skb); 491 nh = nsh_hdr(skb);
641 version = nsh_get_ver(nh); 492 version = nsh_get_ver(nh);
642 length = nsh_hdr_len(nh); 493 length = nsh_hdr_len(nh);
643 494
644 if (version != 0) 495 if (version != 0)
645 return -EINVAL; 496 return -EINVAL;
646 497
647 err = check_header(skb, nh_ofs + lengt 498 err = check_header(skb, nh_ofs + length);
648 if (unlikely(err)) 499 if (unlikely(err))
649 return err; 500 return err;
650 501
651 nh = nsh_hdr(skb); 502 nh = nsh_hdr(skb);
652 key->nsh.base.flags = nsh_get_flags(nh 503 key->nsh.base.flags = nsh_get_flags(nh);
653 key->nsh.base.ttl = nsh_get_ttl(nh); 504 key->nsh.base.ttl = nsh_get_ttl(nh);
654 key->nsh.base.mdtype = nh->mdtype; 505 key->nsh.base.mdtype = nh->mdtype;
655 key->nsh.base.np = nh->np; 506 key->nsh.base.np = nh->np;
656 key->nsh.base.path_hdr = nh->path_hdr; 507 key->nsh.base.path_hdr = nh->path_hdr;
657 switch (key->nsh.base.mdtype) { 508 switch (key->nsh.base.mdtype) {
658 case NSH_M_TYPE1: 509 case NSH_M_TYPE1:
659 if (length != NSH_M_TYPE1_LEN) 510 if (length != NSH_M_TYPE1_LEN)
660 return -EINVAL; 511 return -EINVAL;
661 memcpy(key->nsh.context, nh->m 512 memcpy(key->nsh.context, nh->md1.context,
662 sizeof(nh->md1)); 513 sizeof(nh->md1));
663 break; 514 break;
664 case NSH_M_TYPE2: 515 case NSH_M_TYPE2:
665 memset(key->nsh.context, 0, 516 memset(key->nsh.context, 0,
666 sizeof(nh->md1)); 517 sizeof(nh->md1));
667 break; 518 break;
668 default: 519 default:
669 return -EINVAL; 520 return -EINVAL;
670 } 521 }
671 522
672 return 0; 523 return 0;
673 } 524 }
674 525
675 /** 526 /**
676 * key_extract_l3l4 - extracts L3/L4 header in 527 * key_extract_l3l4 - extracts L3/L4 header information.
677 * @skb: sk_buff that contains the frame, with 528 * @skb: sk_buff that contains the frame, with skb->data pointing to the
678 * L3 header 529 * L3 header
679 * @key: output flow key 530 * @key: output flow key
680 * 531 *
681 * Return: %0 if successful, otherwise a negat <<
682 */ 532 */
683 static int key_extract_l3l4(struct sk_buff *sk 533 static int key_extract_l3l4(struct sk_buff *skb, struct sw_flow_key *key)
684 { 534 {
685 int error; 535 int error;
686 536
687 /* Network layer. */ 537 /* Network layer. */
688 if (key->eth.type == htons(ETH_P_IP)) 538 if (key->eth.type == htons(ETH_P_IP)) {
689 struct iphdr *nh; 539 struct iphdr *nh;
690 __be16 offset; 540 __be16 offset;
691 541
692 error = check_iphdr(skb); 542 error = check_iphdr(skb);
693 if (unlikely(error)) { 543 if (unlikely(error)) {
694 memset(&key->ip, 0, si 544 memset(&key->ip, 0, sizeof(key->ip));
695 memset(&key->ipv4, 0, 545 memset(&key->ipv4, 0, sizeof(key->ipv4));
696 if (error == -EINVAL) 546 if (error == -EINVAL) {
697 skb->transport 547 skb->transport_header = skb->network_header;
698 error = 0; 548 error = 0;
699 } 549 }
700 return error; 550 return error;
701 } 551 }
702 552
703 nh = ip_hdr(skb); 553 nh = ip_hdr(skb);
704 key->ipv4.addr.src = nh->saddr 554 key->ipv4.addr.src = nh->saddr;
705 key->ipv4.addr.dst = nh->daddr 555 key->ipv4.addr.dst = nh->daddr;
706 556
707 key->ip.proto = nh->protocol; 557 key->ip.proto = nh->protocol;
708 key->ip.tos = nh->tos; 558 key->ip.tos = nh->tos;
709 key->ip.ttl = nh->ttl; 559 key->ip.ttl = nh->ttl;
710 560
711 offset = nh->frag_off & htons( 561 offset = nh->frag_off & htons(IP_OFFSET);
712 if (offset) { 562 if (offset) {
713 key->ip.frag = OVS_FRA 563 key->ip.frag = OVS_FRAG_TYPE_LATER;
714 memset(&key->tp, 0, si 564 memset(&key->tp, 0, sizeof(key->tp));
715 return 0; 565 return 0;
716 } 566 }
717 if (nh->frag_off & htons(IP_MF 567 if (nh->frag_off & htons(IP_MF) ||
718 skb_shinfo(skb)->gso_t 568 skb_shinfo(skb)->gso_type & SKB_GSO_UDP)
719 key->ip.frag = OVS_FRA 569 key->ip.frag = OVS_FRAG_TYPE_FIRST;
720 else 570 else
721 key->ip.frag = OVS_FRA 571 key->ip.frag = OVS_FRAG_TYPE_NONE;
722 572
723 /* Transport layer. */ 573 /* Transport layer. */
724 if (key->ip.proto == IPPROTO_T 574 if (key->ip.proto == IPPROTO_TCP) {
725 if (tcphdr_ok(skb)) { 575 if (tcphdr_ok(skb)) {
726 struct tcphdr 576 struct tcphdr *tcp = tcp_hdr(skb);
727 key->tp.src = 577 key->tp.src = tcp->source;
728 key->tp.dst = 578 key->tp.dst = tcp->dest;
729 key->tp.flags 579 key->tp.flags = TCP_FLAGS_BE16(tcp);
730 } else { 580 } else {
731 memset(&key->t 581 memset(&key->tp, 0, sizeof(key->tp));
732 } 582 }
733 583
734 } else if (key->ip.proto == IP 584 } else if (key->ip.proto == IPPROTO_UDP) {
735 if (udphdr_ok(skb)) { 585 if (udphdr_ok(skb)) {
736 struct udphdr 586 struct udphdr *udp = udp_hdr(skb);
737 key->tp.src = 587 key->tp.src = udp->source;
738 key->tp.dst = 588 key->tp.dst = udp->dest;
739 } else { 589 } else {
740 memset(&key->t 590 memset(&key->tp, 0, sizeof(key->tp));
741 } 591 }
742 } else if (key->ip.proto == IP 592 } else if (key->ip.proto == IPPROTO_SCTP) {
743 if (sctphdr_ok(skb)) { 593 if (sctphdr_ok(skb)) {
744 struct sctphdr 594 struct sctphdr *sctp = sctp_hdr(skb);
745 key->tp.src = 595 key->tp.src = sctp->source;
746 key->tp.dst = 596 key->tp.dst = sctp->dest;
747 } else { 597 } else {
748 memset(&key->t 598 memset(&key->tp, 0, sizeof(key->tp));
749 } 599 }
750 } else if (key->ip.proto == IP 600 } else if (key->ip.proto == IPPROTO_ICMP) {
751 if (icmphdr_ok(skb)) { 601 if (icmphdr_ok(skb)) {
752 struct icmphdr 602 struct icmphdr *icmp = icmp_hdr(skb);
753 /* The ICMP ty 603 /* The ICMP type and code fields use the 16-bit
754 * transport p 604 * transport port fields, so we need to store
755 * them in 16- 605 * them in 16-bit network byte order. */
756 key->tp.src = 606 key->tp.src = htons(icmp->type);
757 key->tp.dst = 607 key->tp.dst = htons(icmp->code);
758 } else { 608 } else {
759 memset(&key->t 609 memset(&key->tp, 0, sizeof(key->tp));
760 } 610 }
761 } 611 }
762 612
763 } else if (key->eth.type == htons(ETH_ 613 } else if (key->eth.type == htons(ETH_P_ARP) ||
764 key->eth.type == htons(ETH_ 614 key->eth.type == htons(ETH_P_RARP)) {
765 struct arp_eth_header *arp; 615 struct arp_eth_header *arp;
766 bool arp_available = arphdr_ok 616 bool arp_available = arphdr_ok(skb);
767 617
768 arp = (struct arp_eth_header * 618 arp = (struct arp_eth_header *)skb_network_header(skb);
769 619
770 if (arp_available && 620 if (arp_available &&
771 arp->ar_hrd == htons(ARPHR 621 arp->ar_hrd == htons(ARPHRD_ETHER) &&
772 arp->ar_pro == htons(ETH_P 622 arp->ar_pro == htons(ETH_P_IP) &&
773 arp->ar_hln == ETH_ALEN && 623 arp->ar_hln == ETH_ALEN &&
774 arp->ar_pln == 4) { 624 arp->ar_pln == 4) {
775 625
776 /* We only match on th 626 /* We only match on the lower 8 bits of the opcode. */
777 if (ntohs(arp->ar_op) 627 if (ntohs(arp->ar_op) <= 0xff)
778 key->ip.proto 628 key->ip.proto = ntohs(arp->ar_op);
779 else 629 else
780 key->ip.proto 630 key->ip.proto = 0;
781 631
782 memcpy(&key->ipv4.addr 632 memcpy(&key->ipv4.addr.src, arp->ar_sip, sizeof(key->ipv4.addr.src));
783 memcpy(&key->ipv4.addr 633 memcpy(&key->ipv4.addr.dst, arp->ar_tip, sizeof(key->ipv4.addr.dst));
784 ether_addr_copy(key->i 634 ether_addr_copy(key->ipv4.arp.sha, arp->ar_sha);
785 ether_addr_copy(key->i 635 ether_addr_copy(key->ipv4.arp.tha, arp->ar_tha);
786 } else { 636 } else {
787 memset(&key->ip, 0, si 637 memset(&key->ip, 0, sizeof(key->ip));
788 memset(&key->ipv4, 0, 638 memset(&key->ipv4, 0, sizeof(key->ipv4));
789 } 639 }
790 } else if (eth_p_mpls(key->eth.type)) 640 } else if (eth_p_mpls(key->eth.type)) {
791 u8 label_count = 1; !! 641 size_t stack_len = MPLS_HLEN;
792 642
793 memset(&key->mpls, 0, sizeof(k <<
794 skb_set_inner_network_header(s 643 skb_set_inner_network_header(skb, skb->mac_len);
795 while (1) { 644 while (1) {
796 __be32 lse; 645 __be32 lse;
797 646
798 error = check_header(s !! 647 error = check_header(skb, skb->mac_len + stack_len);
799 l <<
800 if (unlikely(error)) 648 if (unlikely(error))
801 return 0; 649 return 0;
802 650
803 memcpy(&lse, skb_inner 651 memcpy(&lse, skb_inner_network_header(skb), MPLS_HLEN);
804 652
805 if (label_count <= MPL !! 653 if (stack_len == MPLS_HLEN)
806 memcpy(&key->m !! 654 memcpy(&key->mpls.top_lse, &lse, MPLS_HLEN);
807 MPLS_HL <<
808 655
809 skb_set_inner_network_ !! 656 skb_set_inner_network_header(skb, skb->mac_len + stack_len);
810 <<
811 if (lse & htonl(MPLS_L 657 if (lse & htonl(MPLS_LS_S_MASK))
812 break; 658 break;
813 659
814 label_count++; !! 660 stack_len += MPLS_HLEN;
815 } 661 }
816 if (label_count > MPLS_LABEL_D <<
817 label_count = MPLS_LAB <<
818 <<
819 key->mpls.num_labels_mask = GE <<
820 } else if (key->eth.type == htons(ETH_ 662 } else if (key->eth.type == htons(ETH_P_IPV6)) {
821 int nh_len; /* IPv 663 int nh_len; /* IPv6 Header + Extensions */
822 664
823 nh_len = parse_ipv6hdr(skb, ke 665 nh_len = parse_ipv6hdr(skb, key);
824 if (unlikely(nh_len < 0)) { 666 if (unlikely(nh_len < 0)) {
825 switch (nh_len) { 667 switch (nh_len) {
826 case -EINVAL: 668 case -EINVAL:
827 memset(&key->i 669 memset(&key->ip, 0, sizeof(key->ip));
828 memset(&key->i 670 memset(&key->ipv6.addr, 0, sizeof(key->ipv6.addr));
829 fallthrough; !! 671 /* fall-through */
830 case -EPROTO: 672 case -EPROTO:
831 skb->transport 673 skb->transport_header = skb->network_header;
832 error = 0; 674 error = 0;
833 break; 675 break;
834 default: 676 default:
835 error = nh_len 677 error = nh_len;
836 } 678 }
837 return error; 679 return error;
838 } 680 }
839 681
840 if (key->ip.frag == OVS_FRAG_T 682 if (key->ip.frag == OVS_FRAG_TYPE_LATER) {
841 memset(&key->tp, 0, si 683 memset(&key->tp, 0, sizeof(key->tp));
842 return 0; 684 return 0;
843 } 685 }
844 if (skb_shinfo(skb)->gso_type 686 if (skb_shinfo(skb)->gso_type & SKB_GSO_UDP)
845 key->ip.frag = OVS_FRA 687 key->ip.frag = OVS_FRAG_TYPE_FIRST;
846 688
847 /* Transport layer. */ 689 /* Transport layer. */
848 if (key->ip.proto == NEXTHDR_T 690 if (key->ip.proto == NEXTHDR_TCP) {
849 if (tcphdr_ok(skb)) { 691 if (tcphdr_ok(skb)) {
850 struct tcphdr 692 struct tcphdr *tcp = tcp_hdr(skb);
851 key->tp.src = 693 key->tp.src = tcp->source;
852 key->tp.dst = 694 key->tp.dst = tcp->dest;
853 key->tp.flags 695 key->tp.flags = TCP_FLAGS_BE16(tcp);
854 } else { 696 } else {
855 memset(&key->t 697 memset(&key->tp, 0, sizeof(key->tp));
856 } 698 }
857 } else if (key->ip.proto == NE 699 } else if (key->ip.proto == NEXTHDR_UDP) {
858 if (udphdr_ok(skb)) { 700 if (udphdr_ok(skb)) {
859 struct udphdr 701 struct udphdr *udp = udp_hdr(skb);
860 key->tp.src = 702 key->tp.src = udp->source;
861 key->tp.dst = 703 key->tp.dst = udp->dest;
862 } else { 704 } else {
863 memset(&key->t 705 memset(&key->tp, 0, sizeof(key->tp));
864 } 706 }
865 } else if (key->ip.proto == NE 707 } else if (key->ip.proto == NEXTHDR_SCTP) {
866 if (sctphdr_ok(skb)) { 708 if (sctphdr_ok(skb)) {
867 struct sctphdr 709 struct sctphdr *sctp = sctp_hdr(skb);
868 key->tp.src = 710 key->tp.src = sctp->source;
869 key->tp.dst = 711 key->tp.dst = sctp->dest;
870 } else { 712 } else {
871 memset(&key->t 713 memset(&key->tp, 0, sizeof(key->tp));
872 } 714 }
873 } else if (key->ip.proto == NE 715 } else if (key->ip.proto == NEXTHDR_ICMP) {
874 if (icmp6hdr_ok(skb)) 716 if (icmp6hdr_ok(skb)) {
875 error = parse_ 717 error = parse_icmpv6(skb, key, nh_len);
876 if (error) 718 if (error)
877 return 719 return error;
878 } else { 720 } else {
879 memset(&key->t 721 memset(&key->tp, 0, sizeof(key->tp));
880 } 722 }
881 } 723 }
882 } else if (key->eth.type == htons(ETH_ 724 } else if (key->eth.type == htons(ETH_P_NSH)) {
883 error = parse_nsh(skb, key); 725 error = parse_nsh(skb, key);
884 if (error) 726 if (error)
885 return error; 727 return error;
886 } 728 }
887 return 0; 729 return 0;
888 } 730 }
889 731
890 /** 732 /**
891 * key_extract - extracts a flow key from an E 733 * key_extract - extracts a flow key from an Ethernet frame.
892 * @skb: sk_buff that contains the frame, with 734 * @skb: sk_buff that contains the frame, with skb->data pointing to the
893 * Ethernet header 735 * Ethernet header
894 * @key: output flow key 736 * @key: output flow key
895 * 737 *
896 * The caller must ensure that skb->len >= ETH 738 * The caller must ensure that skb->len >= ETH_HLEN.
897 * 739 *
>> 740 * Returns 0 if successful, otherwise a negative errno value.
>> 741 *
898 * Initializes @skb header fields as follows: 742 * Initializes @skb header fields as follows:
899 * 743 *
900 * - skb->mac_header: the L2 header. 744 * - skb->mac_header: the L2 header.
901 * 745 *
902 * - skb->network_header: just past the L2 746 * - skb->network_header: just past the L2 header, or just past the
903 * VLAN header, to the first byte of the 747 * VLAN header, to the first byte of the L2 payload.
904 * 748 *
905 * - skb->transport_header: If key->eth.typ 749 * - skb->transport_header: If key->eth.type is ETH_P_IP or ETH_P_IPV6
906 * on output, then just past the IP heade 750 * on output, then just past the IP header, if one is present and
907 * of a correct length, otherwise the sam 751 * of a correct length, otherwise the same as skb->network_header.
908 * For other key->eth.type values it is l 752 * For other key->eth.type values it is left untouched.
909 * 753 *
910 * - skb->protocol: the type of the data st 754 * - skb->protocol: the type of the data starting at skb->network_header.
911 * Equals to key->eth.type. 755 * Equals to key->eth.type.
912 * <<
913 * Return: %0 if successful, otherwise a negat <<
914 */ 756 */
915 static int key_extract(struct sk_buff *skb, st 757 static int key_extract(struct sk_buff *skb, struct sw_flow_key *key)
916 { 758 {
917 struct ethhdr *eth; 759 struct ethhdr *eth;
918 760
919 /* Flags are always used as part of st 761 /* Flags are always used as part of stats */
920 key->tp.flags = 0; 762 key->tp.flags = 0;
921 763
922 skb_reset_mac_header(skb); 764 skb_reset_mac_header(skb);
923 765
924 /* Link layer. */ 766 /* Link layer. */
925 clear_vlan(key); 767 clear_vlan(key);
926 if (ovs_key_mac_proto(key) == MAC_PROT 768 if (ovs_key_mac_proto(key) == MAC_PROTO_NONE) {
927 if (unlikely(eth_type_vlan(skb 769 if (unlikely(eth_type_vlan(skb->protocol)))
928 return -EINVAL; 770 return -EINVAL;
929 771
930 skb_reset_network_header(skb); 772 skb_reset_network_header(skb);
931 key->eth.type = skb->protocol; 773 key->eth.type = skb->protocol;
932 } else { 774 } else {
933 eth = eth_hdr(skb); 775 eth = eth_hdr(skb);
934 ether_addr_copy(key->eth.src, 776 ether_addr_copy(key->eth.src, eth->h_source);
935 ether_addr_copy(key->eth.dst, 777 ether_addr_copy(key->eth.dst, eth->h_dest);
936 778
937 __skb_pull(skb, 2 * ETH_ALEN); 779 __skb_pull(skb, 2 * ETH_ALEN);
938 /* We are going to push all he 780 /* We are going to push all headers that we pull, so no need to
939 * update skb->csum here. 781 * update skb->csum here.
940 */ 782 */
941 783
942 if (unlikely(parse_vlan(skb, k 784 if (unlikely(parse_vlan(skb, key)))
943 return -ENOMEM; 785 return -ENOMEM;
944 786
945 key->eth.type = parse_ethertyp 787 key->eth.type = parse_ethertype(skb);
946 if (unlikely(key->eth.type == 788 if (unlikely(key->eth.type == htons(0)))
947 return -ENOMEM; 789 return -ENOMEM;
948 790
949 /* Multiple tagged packets nee 791 /* Multiple tagged packets need to retain TPID to satisfy
950 * skb_vlan_pop(), which will 792 * skb_vlan_pop(), which will later shift the ethertype into
951 * skb->protocol. 793 * skb->protocol.
952 */ 794 */
953 if (key->eth.cvlan.tci & htons 795 if (key->eth.cvlan.tci & htons(VLAN_CFI_MASK))
954 skb->protocol = key->e 796 skb->protocol = key->eth.cvlan.tpid;
955 else 797 else
956 skb->protocol = key->e 798 skb->protocol = key->eth.type;
957 799
958 skb_reset_network_header(skb); 800 skb_reset_network_header(skb);
959 __skb_push(skb, skb->data - sk 801 __skb_push(skb, skb->data - skb_mac_header(skb));
960 } 802 }
961 803
962 skb_reset_mac_len(skb); 804 skb_reset_mac_len(skb);
963 805
964 /* Fill out L3/L4 key info, if any */ 806 /* Fill out L3/L4 key info, if any */
965 return key_extract_l3l4(skb, key); 807 return key_extract_l3l4(skb, key);
966 } 808 }
967 809
968 /* In the case of conntrack fragment handling 810 /* In the case of conntrack fragment handling it expects L3 headers,
969 * add a helper. 811 * add a helper.
970 */ 812 */
971 int ovs_flow_key_update_l3l4(struct sk_buff *s 813 int ovs_flow_key_update_l3l4(struct sk_buff *skb, struct sw_flow_key *key)
972 { 814 {
973 return key_extract_l3l4(skb, key); 815 return key_extract_l3l4(skb, key);
974 } 816 }
975 817
976 int ovs_flow_key_update(struct sk_buff *skb, s 818 int ovs_flow_key_update(struct sk_buff *skb, struct sw_flow_key *key)
977 { 819 {
978 int res; 820 int res;
979 821
980 res = key_extract(skb, key); 822 res = key_extract(skb, key);
981 if (!res) 823 if (!res)
982 key->mac_proto &= ~SW_FLOW_KEY 824 key->mac_proto &= ~SW_FLOW_KEY_INVALID;
983 825
984 return res; 826 return res;
985 } 827 }
986 828
987 static int key_extract_mac_proto(struct sk_buf 829 static int key_extract_mac_proto(struct sk_buff *skb)
988 { 830 {
989 switch (skb->dev->type) { 831 switch (skb->dev->type) {
990 case ARPHRD_ETHER: 832 case ARPHRD_ETHER:
991 return MAC_PROTO_ETHERNET; 833 return MAC_PROTO_ETHERNET;
992 case ARPHRD_NONE: 834 case ARPHRD_NONE:
993 if (skb->protocol == htons(ETH 835 if (skb->protocol == htons(ETH_P_TEB))
994 return MAC_PROTO_ETHER 836 return MAC_PROTO_ETHERNET;
995 return MAC_PROTO_NONE; 837 return MAC_PROTO_NONE;
996 } 838 }
997 WARN_ON_ONCE(1); 839 WARN_ON_ONCE(1);
998 return -EINVAL; 840 return -EINVAL;
999 } 841 }
1000 842
1001 int ovs_flow_key_extract(const struct ip_tunn 843 int ovs_flow_key_extract(const struct ip_tunnel_info *tun_info,
1002 struct sk_buff *skb, 844 struct sk_buff *skb, struct sw_flow_key *key)
1003 { 845 {
1004 #if IS_ENABLED(CONFIG_NET_TC_SKB_EXT) 846 #if IS_ENABLED(CONFIG_NET_TC_SKB_EXT)
1005 struct tc_skb_ext *tc_ext; 847 struct tc_skb_ext *tc_ext;
1006 #endif 848 #endif
1007 bool post_ct = false, post_ct_snat = <<
1008 int res, err; 849 int res, err;
1009 u16 zone = 0; <<
1010 850
1011 /* Extract metadata from packet. */ 851 /* Extract metadata from packet. */
1012 if (tun_info) { 852 if (tun_info) {
1013 key->tun_proto = ip_tunnel_in 853 key->tun_proto = ip_tunnel_info_af(tun_info);
1014 memcpy(&key->tun_key, &tun_in 854 memcpy(&key->tun_key, &tun_info->key, sizeof(key->tun_key));
1015 855
1016 if (tun_info->options_len) { 856 if (tun_info->options_len) {
1017 BUILD_BUG_ON((1 << (s 857 BUILD_BUG_ON((1 << (sizeof(tun_info->options_len) *
1018 858 8)) - 1
1019 > siz 859 > sizeof(key->tun_opts));
1020 860
1021 ip_tunnel_info_opts_g 861 ip_tunnel_info_opts_get(TUN_METADATA_OPTS(key, tun_info->options_len),
1022 862 tun_info);
1023 key->tun_opts_len = t 863 key->tun_opts_len = tun_info->options_len;
1024 } else { 864 } else {
1025 key->tun_opts_len = 0 865 key->tun_opts_len = 0;
1026 } 866 }
1027 } else { 867 } else {
1028 key->tun_proto = 0; 868 key->tun_proto = 0;
1029 key->tun_opts_len = 0; 869 key->tun_opts_len = 0;
1030 memset(&key->tun_key, 0, size 870 memset(&key->tun_key, 0, sizeof(key->tun_key));
1031 } 871 }
1032 872
1033 key->phy.priority = skb->priority; 873 key->phy.priority = skb->priority;
1034 key->phy.in_port = OVS_CB(skb)->input 874 key->phy.in_port = OVS_CB(skb)->input_vport->port_no;
1035 key->phy.skb_mark = skb->mark; 875 key->phy.skb_mark = skb->mark;
1036 key->ovs_flow_hash = 0; 876 key->ovs_flow_hash = 0;
1037 res = key_extract_mac_proto(skb); 877 res = key_extract_mac_proto(skb);
1038 if (res < 0) 878 if (res < 0)
1039 return res; 879 return res;
1040 key->mac_proto = res; 880 key->mac_proto = res;
1041 881
1042 #if IS_ENABLED(CONFIG_NET_TC_SKB_EXT) 882 #if IS_ENABLED(CONFIG_NET_TC_SKB_EXT)
1043 if (tc_skb_ext_tc_enabled()) { !! 883 if (static_branch_unlikely(&tc_recirc_sharing_support)) {
1044 tc_ext = skb_ext_find(skb, TC 884 tc_ext = skb_ext_find(skb, TC_SKB_EXT);
1045 key->recirc_id = tc_ext && !t !! 885 key->recirc_id = tc_ext ? tc_ext->chain : 0;
1046 tc_ext->chai <<
1047 OVS_CB(skb)->mru = tc_ext ? t <<
1048 post_ct = tc_ext ? tc_ext->po <<
1049 post_ct_snat = post_ct ? tc_e <<
1050 post_ct_dnat = post_ct ? tc_e <<
1051 zone = post_ct ? tc_ext->zone <<
1052 } else { 886 } else {
1053 key->recirc_id = 0; 887 key->recirc_id = 0;
1054 } 888 }
1055 #else 889 #else
1056 key->recirc_id = 0; 890 key->recirc_id = 0;
1057 #endif 891 #endif
1058 892
1059 err = key_extract(skb, key); 893 err = key_extract(skb, key);
1060 if (!err) { !! 894 if (!err)
1061 ovs_ct_fill_key(skb, key, pos !! 895 ovs_ct_fill_key(skb, key); /* Must be after key_extract(). */
1062 if (post_ct) { <<
1063 if (!skb_get_nfct(skb <<
1064 key->ct_zone <<
1065 } else { <<
1066 if (!post_ct_ <<
1067 key-> <<
1068 if (!post_ct_ <<
1069 key-> <<
1070 } <<
1071 } <<
1072 } <<
1073 return err; 896 return err;
1074 } 897 }
1075 898
1076 int ovs_flow_key_extract_userspace(struct net 899 int ovs_flow_key_extract_userspace(struct net *net, const struct nlattr *attr,
1077 struct sk_ 900 struct sk_buff *skb,
1078 struct sw_ 901 struct sw_flow_key *key, bool log)
1079 { 902 {
1080 const struct nlattr *a[OVS_KEY_ATTR_M 903 const struct nlattr *a[OVS_KEY_ATTR_MAX + 1];
1081 u64 attrs = 0; 904 u64 attrs = 0;
1082 int err; 905 int err;
1083 906
1084 err = parse_flow_nlattrs(attr, a, &at 907 err = parse_flow_nlattrs(attr, a, &attrs, log);
1085 if (err) 908 if (err)
1086 return -EINVAL; 909 return -EINVAL;
1087 910
1088 /* Extract metadata from netlink attr 911 /* Extract metadata from netlink attributes. */
1089 err = ovs_nla_get_flow_metadata(net, 912 err = ovs_nla_get_flow_metadata(net, a, attrs, key, log);
1090 if (err) 913 if (err)
1091 return err; 914 return err;
1092 915
1093 /* key_extract assumes that skb->prot 916 /* key_extract assumes that skb->protocol is set-up for
1094 * layer 3 packets which is the case 917 * layer 3 packets which is the case for other callers,
1095 * in particular packets received fro 918 * in particular packets received from the network stack.
1096 * Here the correct value can be set 919 * Here the correct value can be set from the metadata
1097 * extracted above. 920 * extracted above.
1098 * For L2 packet key eth type would b 921 * For L2 packet key eth type would be zero. skb protocol
1099 * would be set to correct value late 922 * would be set to correct value later during key-extact.
1100 */ 923 */
1101 924
1102 skb->protocol = key->eth.type; 925 skb->protocol = key->eth.type;
1103 err = key_extract(skb, key); 926 err = key_extract(skb, key);
1104 if (err) 927 if (err)
1105 return err; 928 return err;
1106 929
1107 /* Check that we have conntrack origi 930 /* Check that we have conntrack original direction tuple metadata only
1108 * for packets for which it makes sen 931 * for packets for which it makes sense. Otherwise the key may be
1109 * corrupted due to overlapping key f 932 * corrupted due to overlapping key fields.
1110 */ 933 */
1111 if (attrs & (1 << OVS_KEY_ATTR_CT_ORI 934 if (attrs & (1 << OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4) &&
1112 key->eth.type != htons(ETH_P_IP)) 935 key->eth.type != htons(ETH_P_IP))
1113 return -EINVAL; 936 return -EINVAL;
1114 if (attrs & (1 << OVS_KEY_ATTR_CT_ORI 937 if (attrs & (1 << OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6) &&
1115 (key->eth.type != htons(ETH_P_IPV 938 (key->eth.type != htons(ETH_P_IPV6) ||
1116 sw_flow_key_is_nd(key))) 939 sw_flow_key_is_nd(key)))
1117 return -EINVAL; 940 return -EINVAL;
1118 941
1119 return 0; 942 return 0;
1120 } 943 }
1121 944
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.