This source file includes following definitions.
- clone_key
- action_fifo_init
- action_fifo_is_empty
- action_fifo_get
- action_fifo_put
- add_deferred_actions
- invalidate_flow_key
- is_flow_key_valid
- push_mpls
- pop_mpls
- set_mpls
- pop_vlan
- push_vlan
- ether_addr_copy_masked
- set_eth_addr
- pop_eth
- push_eth
- push_nsh
- pop_nsh
- update_ip_l4_checksum
- set_ip_addr
- update_ipv6_checksum
- mask_ipv6_addr
- set_ipv6_addr
- set_ipv6_fl
- set_ip_ttl
- set_ipv4
- is_ipv6_mask_nonzero
- set_ipv6
- set_nsh
- set_tp_port
- set_udp
- set_tcp
- set_sctp
- ovs_vport_output
- ovs_dst_get_mtu
- prepare_frag
- ovs_fragment
- do_output
- output_userspace
- sample
- clone
- execute_hash
- execute_set_action
- execute_masked_set_action
- execute_recirc
- execute_check_pkt_len
- do_execute_actions
- clone_execute
- process_deferred_actions
- ovs_execute_actions
- action_fifos_init
- action_fifos_exit
1
2
3
4
5
6 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
7
8 #include <linux/skbuff.h>
9 #include <linux/in.h>
10 #include <linux/ip.h>
11 #include <linux/openvswitch.h>
12 #include <linux/netfilter_ipv6.h>
13 #include <linux/sctp.h>
14 #include <linux/tcp.h>
15 #include <linux/udp.h>
16 #include <linux/in6.h>
17 #include <linux/if_arp.h>
18 #include <linux/if_vlan.h>
19
20 #include <net/dst.h>
21 #include <net/ip.h>
22 #include <net/ipv6.h>
23 #include <net/ip6_fib.h>
24 #include <net/checksum.h>
25 #include <net/dsfield.h>
26 #include <net/mpls.h>
27 #include <net/sctp/checksum.h>
28
29 #include "datapath.h"
30 #include "flow.h"
31 #include "conntrack.h"
32 #include "vport.h"
33 #include "flow_netlink.h"
34
35 struct deferred_action {
36 struct sk_buff *skb;
37 const struct nlattr *actions;
38 int actions_len;
39
40
41 struct sw_flow_key pkt_key;
42 };
43
44 #define MAX_L2_LEN (VLAN_ETH_HLEN + 3 * MPLS_HLEN)
45 struct ovs_frag_data {
46 unsigned long dst;
47 struct vport *vport;
48 struct ovs_skb_cb cb;
49 __be16 inner_protocol;
50 u16 network_offset;
51 u16 vlan_tci;
52 __be16 vlan_proto;
53 unsigned int l2_len;
54 u8 mac_proto;
55 u8 l2_data[MAX_L2_LEN];
56 };
57
58 static DEFINE_PER_CPU(struct ovs_frag_data, ovs_frag_data_storage);
59
60 #define DEFERRED_ACTION_FIFO_SIZE 10
61 #define OVS_RECURSION_LIMIT 5
62 #define OVS_DEFERRED_ACTION_THRESHOLD (OVS_RECURSION_LIMIT - 2)
63 struct action_fifo {
64 int head;
65 int tail;
66
67 struct deferred_action fifo[DEFERRED_ACTION_FIFO_SIZE];
68 };
69
70 struct action_flow_keys {
71 struct sw_flow_key key[OVS_DEFERRED_ACTION_THRESHOLD];
72 };
73
74 static struct action_fifo __percpu *action_fifos;
75 static struct action_flow_keys __percpu *flow_keys;
76 static DEFINE_PER_CPU(int, exec_actions_level);
77
78
79
80
81 static struct sw_flow_key *clone_key(const struct sw_flow_key *key_)
82 {
83 struct action_flow_keys *keys = this_cpu_ptr(flow_keys);
84 int level = this_cpu_read(exec_actions_level);
85 struct sw_flow_key *key = NULL;
86
87 if (level <= OVS_DEFERRED_ACTION_THRESHOLD) {
88 key = &keys->key[level - 1];
89 *key = *key_;
90 }
91
92 return key;
93 }
94
95 static void action_fifo_init(struct action_fifo *fifo)
96 {
97 fifo->head = 0;
98 fifo->tail = 0;
99 }
100
101 static bool action_fifo_is_empty(const struct action_fifo *fifo)
102 {
103 return (fifo->head == fifo->tail);
104 }
105
106 static struct deferred_action *action_fifo_get(struct action_fifo *fifo)
107 {
108 if (action_fifo_is_empty(fifo))
109 return NULL;
110
111 return &fifo->fifo[fifo->tail++];
112 }
113
114 static struct deferred_action *action_fifo_put(struct action_fifo *fifo)
115 {
116 if (fifo->head >= DEFERRED_ACTION_FIFO_SIZE - 1)
117 return NULL;
118
119 return &fifo->fifo[fifo->head++];
120 }
121
122
123 static struct deferred_action *add_deferred_actions(struct sk_buff *skb,
124 const struct sw_flow_key *key,
125 const struct nlattr *actions,
126 const int actions_len)
127 {
128 struct action_fifo *fifo;
129 struct deferred_action *da;
130
131 fifo = this_cpu_ptr(action_fifos);
132 da = action_fifo_put(fifo);
133 if (da) {
134 da->skb = skb;
135 da->actions = actions;
136 da->actions_len = actions_len;
137 da->pkt_key = *key;
138 }
139
140 return da;
141 }
142
143 static void invalidate_flow_key(struct sw_flow_key *key)
144 {
145 key->mac_proto |= SW_FLOW_KEY_INVALID;
146 }
147
148 static bool is_flow_key_valid(const struct sw_flow_key *key)
149 {
150 return !(key->mac_proto & SW_FLOW_KEY_INVALID);
151 }
152
153 static int clone_execute(struct datapath *dp, struct sk_buff *skb,
154 struct sw_flow_key *key,
155 u32 recirc_id,
156 const struct nlattr *actions, int len,
157 bool last, bool clone_flow_key);
158
159 static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
160 struct sw_flow_key *key,
161 const struct nlattr *attr, int len);
162
163 static int push_mpls(struct sk_buff *skb, struct sw_flow_key *key,
164 const struct ovs_action_push_mpls *mpls)
165 {
166 int err;
167
168 err = skb_mpls_push(skb, mpls->mpls_lse, mpls->mpls_ethertype,
169 skb->mac_len,
170 ovs_key_mac_proto(key) == MAC_PROTO_ETHERNET);
171 if (err)
172 return err;
173
174 invalidate_flow_key(key);
175 return 0;
176 }
177
178 static int pop_mpls(struct sk_buff *skb, struct sw_flow_key *key,
179 const __be16 ethertype)
180 {
181 int err;
182
183 err = skb_mpls_pop(skb, ethertype, skb->mac_len,
184 ovs_key_mac_proto(key) == MAC_PROTO_ETHERNET);
185 if (err)
186 return err;
187
188 invalidate_flow_key(key);
189 return 0;
190 }
191
192 static int set_mpls(struct sk_buff *skb, struct sw_flow_key *flow_key,
193 const __be32 *mpls_lse, const __be32 *mask)
194 {
195 struct mpls_shim_hdr *stack;
196 __be32 lse;
197 int err;
198
199 stack = mpls_hdr(skb);
200 lse = OVS_MASKED(stack->label_stack_entry, *mpls_lse, *mask);
201 err = skb_mpls_update_lse(skb, lse);
202 if (err)
203 return err;
204
205 flow_key->mpls.top_lse = lse;
206 return 0;
207 }
208
209 static int pop_vlan(struct sk_buff *skb, struct sw_flow_key *key)
210 {
211 int err;
212
213 err = skb_vlan_pop(skb);
214 if (skb_vlan_tag_present(skb)) {
215 invalidate_flow_key(key);
216 } else {
217 key->eth.vlan.tci = 0;
218 key->eth.vlan.tpid = 0;
219 }
220 return err;
221 }
222
223 static int push_vlan(struct sk_buff *skb, struct sw_flow_key *key,
224 const struct ovs_action_push_vlan *vlan)
225 {
226 if (skb_vlan_tag_present(skb)) {
227 invalidate_flow_key(key);
228 } else {
229 key->eth.vlan.tci = vlan->vlan_tci;
230 key->eth.vlan.tpid = vlan->vlan_tpid;
231 }
232 return skb_vlan_push(skb, vlan->vlan_tpid,
233 ntohs(vlan->vlan_tci) & ~VLAN_CFI_MASK);
234 }
235
236
237 static void ether_addr_copy_masked(u8 *dst_, const u8 *src_, const u8 *mask_)
238 {
239 u16 *dst = (u16 *)dst_;
240 const u16 *src = (const u16 *)src_;
241 const u16 *mask = (const u16 *)mask_;
242
243 OVS_SET_MASKED(dst[0], src[0], mask[0]);
244 OVS_SET_MASKED(dst[1], src[1], mask[1]);
245 OVS_SET_MASKED(dst[2], src[2], mask[2]);
246 }
247
248 static int set_eth_addr(struct sk_buff *skb, struct sw_flow_key *flow_key,
249 const struct ovs_key_ethernet *key,
250 const struct ovs_key_ethernet *mask)
251 {
252 int err;
253
254 err = skb_ensure_writable(skb, ETH_HLEN);
255 if (unlikely(err))
256 return err;
257
258 skb_postpull_rcsum(skb, eth_hdr(skb), ETH_ALEN * 2);
259
260 ether_addr_copy_masked(eth_hdr(skb)->h_source, key->eth_src,
261 mask->eth_src);
262 ether_addr_copy_masked(eth_hdr(skb)->h_dest, key->eth_dst,
263 mask->eth_dst);
264
265 skb_postpush_rcsum(skb, eth_hdr(skb), ETH_ALEN * 2);
266
267 ether_addr_copy(flow_key->eth.src, eth_hdr(skb)->h_source);
268 ether_addr_copy(flow_key->eth.dst, eth_hdr(skb)->h_dest);
269 return 0;
270 }
271
272
273
274
275 static int pop_eth(struct sk_buff *skb, struct sw_flow_key *key)
276 {
277 skb_pull_rcsum(skb, ETH_HLEN);
278 skb_reset_mac_header(skb);
279 skb_reset_mac_len(skb);
280
281
282 key->mac_proto = MAC_PROTO_NONE;
283 invalidate_flow_key(key);
284 return 0;
285 }
286
287 static int push_eth(struct sk_buff *skb, struct sw_flow_key *key,
288 const struct ovs_action_push_eth *ethh)
289 {
290 struct ethhdr *hdr;
291
292
293 if (skb_cow_head(skb, ETH_HLEN) < 0)
294 return -ENOMEM;
295
296 skb_push(skb, ETH_HLEN);
297 skb_reset_mac_header(skb);
298 skb_reset_mac_len(skb);
299
300 hdr = eth_hdr(skb);
301 ether_addr_copy(hdr->h_source, ethh->addresses.eth_src);
302 ether_addr_copy(hdr->h_dest, ethh->addresses.eth_dst);
303 hdr->h_proto = skb->protocol;
304
305 skb_postpush_rcsum(skb, hdr, ETH_HLEN);
306
307
308 key->mac_proto = MAC_PROTO_ETHERNET;
309 invalidate_flow_key(key);
310 return 0;
311 }
312
313 static int push_nsh(struct sk_buff *skb, struct sw_flow_key *key,
314 const struct nshhdr *nh)
315 {
316 int err;
317
318 err = nsh_push(skb, nh);
319 if (err)
320 return err;
321
322
323 key->mac_proto = MAC_PROTO_NONE;
324 invalidate_flow_key(key);
325 return 0;
326 }
327
328 static int pop_nsh(struct sk_buff *skb, struct sw_flow_key *key)
329 {
330 int err;
331
332 err = nsh_pop(skb);
333 if (err)
334 return err;
335
336
337 if (skb->protocol == htons(ETH_P_TEB))
338 key->mac_proto = MAC_PROTO_ETHERNET;
339 else
340 key->mac_proto = MAC_PROTO_NONE;
341 invalidate_flow_key(key);
342 return 0;
343 }
344
345 static void update_ip_l4_checksum(struct sk_buff *skb, struct iphdr *nh,
346 __be32 addr, __be32 new_addr)
347 {
348 int transport_len = skb->len - skb_transport_offset(skb);
349
350 if (nh->frag_off & htons(IP_OFFSET))
351 return;
352
353 if (nh->protocol == IPPROTO_TCP) {
354 if (likely(transport_len >= sizeof(struct tcphdr)))
355 inet_proto_csum_replace4(&tcp_hdr(skb)->check, skb,
356 addr, new_addr, true);
357 } else if (nh->protocol == IPPROTO_UDP) {
358 if (likely(transport_len >= sizeof(struct udphdr))) {
359 struct udphdr *uh = udp_hdr(skb);
360
361 if (uh->check || skb->ip_summed == CHECKSUM_PARTIAL) {
362 inet_proto_csum_replace4(&uh->check, skb,
363 addr, new_addr, true);
364 if (!uh->check)
365 uh->check = CSUM_MANGLED_0;
366 }
367 }
368 }
369 }
370
371 static void set_ip_addr(struct sk_buff *skb, struct iphdr *nh,
372 __be32 *addr, __be32 new_addr)
373 {
374 update_ip_l4_checksum(skb, nh, *addr, new_addr);
375 csum_replace4(&nh->check, *addr, new_addr);
376 skb_clear_hash(skb);
377 *addr = new_addr;
378 }
379
380 static void update_ipv6_checksum(struct sk_buff *skb, u8 l4_proto,
381 __be32 addr[4], const __be32 new_addr[4])
382 {
383 int transport_len = skb->len - skb_transport_offset(skb);
384
385 if (l4_proto == NEXTHDR_TCP) {
386 if (likely(transport_len >= sizeof(struct tcphdr)))
387 inet_proto_csum_replace16(&tcp_hdr(skb)->check, skb,
388 addr, new_addr, true);
389 } else if (l4_proto == NEXTHDR_UDP) {
390 if (likely(transport_len >= sizeof(struct udphdr))) {
391 struct udphdr *uh = udp_hdr(skb);
392
393 if (uh->check || skb->ip_summed == CHECKSUM_PARTIAL) {
394 inet_proto_csum_replace16(&uh->check, skb,
395 addr, new_addr, true);
396 if (!uh->check)
397 uh->check = CSUM_MANGLED_0;
398 }
399 }
400 } else if (l4_proto == NEXTHDR_ICMP) {
401 if (likely(transport_len >= sizeof(struct icmp6hdr)))
402 inet_proto_csum_replace16(&icmp6_hdr(skb)->icmp6_cksum,
403 skb, addr, new_addr, true);
404 }
405 }
406
407 static void mask_ipv6_addr(const __be32 old[4], const __be32 addr[4],
408 const __be32 mask[4], __be32 masked[4])
409 {
410 masked[0] = OVS_MASKED(old[0], addr[0], mask[0]);
411 masked[1] = OVS_MASKED(old[1], addr[1], mask[1]);
412 masked[2] = OVS_MASKED(old[2], addr[2], mask[2]);
413 masked[3] = OVS_MASKED(old[3], addr[3], mask[3]);
414 }
415
416 static void set_ipv6_addr(struct sk_buff *skb, u8 l4_proto,
417 __be32 addr[4], const __be32 new_addr[4],
418 bool recalculate_csum)
419 {
420 if (recalculate_csum)
421 update_ipv6_checksum(skb, l4_proto, addr, new_addr);
422
423 skb_clear_hash(skb);
424 memcpy(addr, new_addr, sizeof(__be32[4]));
425 }
426
427 static void set_ipv6_fl(struct ipv6hdr *nh, u32 fl, u32 mask)
428 {
429
430 OVS_SET_MASKED(nh->flow_lbl[0], (u8)(fl >> 16), (u8)(mask >> 16));
431 OVS_SET_MASKED(nh->flow_lbl[1], (u8)(fl >> 8), (u8)(mask >> 8));
432 OVS_SET_MASKED(nh->flow_lbl[2], (u8)fl, (u8)mask);
433 }
434
435 static void set_ip_ttl(struct sk_buff *skb, struct iphdr *nh, u8 new_ttl,
436 u8 mask)
437 {
438 new_ttl = OVS_MASKED(nh->ttl, new_ttl, mask);
439
440 csum_replace2(&nh->check, htons(nh->ttl << 8), htons(new_ttl << 8));
441 nh->ttl = new_ttl;
442 }
443
444 static int set_ipv4(struct sk_buff *skb, struct sw_flow_key *flow_key,
445 const struct ovs_key_ipv4 *key,
446 const struct ovs_key_ipv4 *mask)
447 {
448 struct iphdr *nh;
449 __be32 new_addr;
450 int err;
451
452 err = skb_ensure_writable(skb, skb_network_offset(skb) +
453 sizeof(struct iphdr));
454 if (unlikely(err))
455 return err;
456
457 nh = ip_hdr(skb);
458
459
460
461
462
463 if (mask->ipv4_src) {
464 new_addr = OVS_MASKED(nh->saddr, key->ipv4_src, mask->ipv4_src);
465
466 if (unlikely(new_addr != nh->saddr)) {
467 set_ip_addr(skb, nh, &nh->saddr, new_addr);
468 flow_key->ipv4.addr.src = new_addr;
469 }
470 }
471 if (mask->ipv4_dst) {
472 new_addr = OVS_MASKED(nh->daddr, key->ipv4_dst, mask->ipv4_dst);
473
474 if (unlikely(new_addr != nh->daddr)) {
475 set_ip_addr(skb, nh, &nh->daddr, new_addr);
476 flow_key->ipv4.addr.dst = new_addr;
477 }
478 }
479 if (mask->ipv4_tos) {
480 ipv4_change_dsfield(nh, ~mask->ipv4_tos, key->ipv4_tos);
481 flow_key->ip.tos = nh->tos;
482 }
483 if (mask->ipv4_ttl) {
484 set_ip_ttl(skb, nh, key->ipv4_ttl, mask->ipv4_ttl);
485 flow_key->ip.ttl = nh->ttl;
486 }
487
488 return 0;
489 }
490
491 static bool is_ipv6_mask_nonzero(const __be32 addr[4])
492 {
493 return !!(addr[0] | addr[1] | addr[2] | addr[3]);
494 }
495
496 static int set_ipv6(struct sk_buff *skb, struct sw_flow_key *flow_key,
497 const struct ovs_key_ipv6 *key,
498 const struct ovs_key_ipv6 *mask)
499 {
500 struct ipv6hdr *nh;
501 int err;
502
503 err = skb_ensure_writable(skb, skb_network_offset(skb) +
504 sizeof(struct ipv6hdr));
505 if (unlikely(err))
506 return err;
507
508 nh = ipv6_hdr(skb);
509
510
511
512
513
514 if (is_ipv6_mask_nonzero(mask->ipv6_src)) {
515 __be32 *saddr = (__be32 *)&nh->saddr;
516 __be32 masked[4];
517
518 mask_ipv6_addr(saddr, key->ipv6_src, mask->ipv6_src, masked);
519
520 if (unlikely(memcmp(saddr, masked, sizeof(masked)))) {
521 set_ipv6_addr(skb, flow_key->ip.proto, saddr, masked,
522 true);
523 memcpy(&flow_key->ipv6.addr.src, masked,
524 sizeof(flow_key->ipv6.addr.src));
525 }
526 }
527 if (is_ipv6_mask_nonzero(mask->ipv6_dst)) {
528 unsigned int offset = 0;
529 int flags = IP6_FH_F_SKIP_RH;
530 bool recalc_csum = true;
531 __be32 *daddr = (__be32 *)&nh->daddr;
532 __be32 masked[4];
533
534 mask_ipv6_addr(daddr, key->ipv6_dst, mask->ipv6_dst, masked);
535
536 if (unlikely(memcmp(daddr, masked, sizeof(masked)))) {
537 if (ipv6_ext_hdr(nh->nexthdr))
538 recalc_csum = (ipv6_find_hdr(skb, &offset,
539 NEXTHDR_ROUTING,
540 NULL, &flags)
541 != NEXTHDR_ROUTING);
542
543 set_ipv6_addr(skb, flow_key->ip.proto, daddr, masked,
544 recalc_csum);
545 memcpy(&flow_key->ipv6.addr.dst, masked,
546 sizeof(flow_key->ipv6.addr.dst));
547 }
548 }
549 if (mask->ipv6_tclass) {
550 ipv6_change_dsfield(nh, ~mask->ipv6_tclass, key->ipv6_tclass);
551 flow_key->ip.tos = ipv6_get_dsfield(nh);
552 }
553 if (mask->ipv6_label) {
554 set_ipv6_fl(nh, ntohl(key->ipv6_label),
555 ntohl(mask->ipv6_label));
556 flow_key->ipv6.label =
557 *(__be32 *)nh & htonl(IPV6_FLOWINFO_FLOWLABEL);
558 }
559 if (mask->ipv6_hlimit) {
560 OVS_SET_MASKED(nh->hop_limit, key->ipv6_hlimit,
561 mask->ipv6_hlimit);
562 flow_key->ip.ttl = nh->hop_limit;
563 }
564 return 0;
565 }
566
567 static int set_nsh(struct sk_buff *skb, struct sw_flow_key *flow_key,
568 const struct nlattr *a)
569 {
570 struct nshhdr *nh;
571 size_t length;
572 int err;
573 u8 flags;
574 u8 ttl;
575 int i;
576
577 struct ovs_key_nsh key;
578 struct ovs_key_nsh mask;
579
580 err = nsh_key_from_nlattr(a, &key, &mask);
581 if (err)
582 return err;
583
584
585 if (!pskb_may_pull(skb, skb_network_offset(skb) + NSH_BASE_HDR_LEN))
586 return -ENOMEM;
587
588 nh = nsh_hdr(skb);
589 length = nsh_hdr_len(nh);
590
591
592 err = skb_ensure_writable(skb, skb_network_offset(skb) +
593 length);
594 if (unlikely(err))
595 return err;
596
597 nh = nsh_hdr(skb);
598 skb_postpull_rcsum(skb, nh, length);
599 flags = nsh_get_flags(nh);
600 flags = OVS_MASKED(flags, key.base.flags, mask.base.flags);
601 flow_key->nsh.base.flags = flags;
602 ttl = nsh_get_ttl(nh);
603 ttl = OVS_MASKED(ttl, key.base.ttl, mask.base.ttl);
604 flow_key->nsh.base.ttl = ttl;
605 nsh_set_flags_and_ttl(nh, flags, ttl);
606 nh->path_hdr = OVS_MASKED(nh->path_hdr, key.base.path_hdr,
607 mask.base.path_hdr);
608 flow_key->nsh.base.path_hdr = nh->path_hdr;
609 switch (nh->mdtype) {
610 case NSH_M_TYPE1:
611 for (i = 0; i < NSH_MD1_CONTEXT_SIZE; i++) {
612 nh->md1.context[i] =
613 OVS_MASKED(nh->md1.context[i], key.context[i],
614 mask.context[i]);
615 }
616 memcpy(flow_key->nsh.context, nh->md1.context,
617 sizeof(nh->md1.context));
618 break;
619 case NSH_M_TYPE2:
620 memset(flow_key->nsh.context, 0,
621 sizeof(flow_key->nsh.context));
622 break;
623 default:
624 return -EINVAL;
625 }
626 skb_postpush_rcsum(skb, nh, length);
627 return 0;
628 }
629
630
631 static void set_tp_port(struct sk_buff *skb, __be16 *port,
632 __be16 new_port, __sum16 *check)
633 {
634 inet_proto_csum_replace2(check, skb, *port, new_port, false);
635 *port = new_port;
636 }
637
638 static int set_udp(struct sk_buff *skb, struct sw_flow_key *flow_key,
639 const struct ovs_key_udp *key,
640 const struct ovs_key_udp *mask)
641 {
642 struct udphdr *uh;
643 __be16 src, dst;
644 int err;
645
646 err = skb_ensure_writable(skb, skb_transport_offset(skb) +
647 sizeof(struct udphdr));
648 if (unlikely(err))
649 return err;
650
651 uh = udp_hdr(skb);
652
653 src = OVS_MASKED(uh->source, key->udp_src, mask->udp_src);
654 dst = OVS_MASKED(uh->dest, key->udp_dst, mask->udp_dst);
655
656 if (uh->check && skb->ip_summed != CHECKSUM_PARTIAL) {
657 if (likely(src != uh->source)) {
658 set_tp_port(skb, &uh->source, src, &uh->check);
659 flow_key->tp.src = src;
660 }
661 if (likely(dst != uh->dest)) {
662 set_tp_port(skb, &uh->dest, dst, &uh->check);
663 flow_key->tp.dst = dst;
664 }
665
666 if (unlikely(!uh->check))
667 uh->check = CSUM_MANGLED_0;
668 } else {
669 uh->source = src;
670 uh->dest = dst;
671 flow_key->tp.src = src;
672 flow_key->tp.dst = dst;
673 }
674
675 skb_clear_hash(skb);
676
677 return 0;
678 }
679
680 static int set_tcp(struct sk_buff *skb, struct sw_flow_key *flow_key,
681 const struct ovs_key_tcp *key,
682 const struct ovs_key_tcp *mask)
683 {
684 struct tcphdr *th;
685 __be16 src, dst;
686 int err;
687
688 err = skb_ensure_writable(skb, skb_transport_offset(skb) +
689 sizeof(struct tcphdr));
690 if (unlikely(err))
691 return err;
692
693 th = tcp_hdr(skb);
694 src = OVS_MASKED(th->source, key->tcp_src, mask->tcp_src);
695 if (likely(src != th->source)) {
696 set_tp_port(skb, &th->source, src, &th->check);
697 flow_key->tp.src = src;
698 }
699 dst = OVS_MASKED(th->dest, key->tcp_dst, mask->tcp_dst);
700 if (likely(dst != th->dest)) {
701 set_tp_port(skb, &th->dest, dst, &th->check);
702 flow_key->tp.dst = dst;
703 }
704 skb_clear_hash(skb);
705
706 return 0;
707 }
708
709 static int set_sctp(struct sk_buff *skb, struct sw_flow_key *flow_key,
710 const struct ovs_key_sctp *key,
711 const struct ovs_key_sctp *mask)
712 {
713 unsigned int sctphoff = skb_transport_offset(skb);
714 struct sctphdr *sh;
715 __le32 old_correct_csum, new_csum, old_csum;
716 int err;
717
718 err = skb_ensure_writable(skb, sctphoff + sizeof(struct sctphdr));
719 if (unlikely(err))
720 return err;
721
722 sh = sctp_hdr(skb);
723 old_csum = sh->checksum;
724 old_correct_csum = sctp_compute_cksum(skb, sctphoff);
725
726 sh->source = OVS_MASKED(sh->source, key->sctp_src, mask->sctp_src);
727 sh->dest = OVS_MASKED(sh->dest, key->sctp_dst, mask->sctp_dst);
728
729 new_csum = sctp_compute_cksum(skb, sctphoff);
730
731
732 sh->checksum = old_csum ^ old_correct_csum ^ new_csum;
733
734 skb_clear_hash(skb);
735 flow_key->tp.src = sh->source;
736 flow_key->tp.dst = sh->dest;
737
738 return 0;
739 }
740
741 static int ovs_vport_output(struct net *net, struct sock *sk, struct sk_buff *skb)
742 {
743 struct ovs_frag_data *data = this_cpu_ptr(&ovs_frag_data_storage);
744 struct vport *vport = data->vport;
745
746 if (skb_cow_head(skb, data->l2_len) < 0) {
747 kfree_skb(skb);
748 return -ENOMEM;
749 }
750
751 __skb_dst_copy(skb, data->dst);
752 *OVS_CB(skb) = data->cb;
753 skb->inner_protocol = data->inner_protocol;
754 if (data->vlan_tci & VLAN_CFI_MASK)
755 __vlan_hwaccel_put_tag(skb, data->vlan_proto, data->vlan_tci & ~VLAN_CFI_MASK);
756 else
757 __vlan_hwaccel_clear_tag(skb);
758
759
760 skb_push(skb, data->l2_len);
761 memcpy(skb->data, &data->l2_data, data->l2_len);
762 skb_postpush_rcsum(skb, skb->data, data->l2_len);
763 skb_reset_mac_header(skb);
764
765 if (eth_p_mpls(skb->protocol)) {
766 skb->inner_network_header = skb->network_header;
767 skb_set_network_header(skb, data->network_offset);
768 skb_reset_mac_len(skb);
769 }
770
771 ovs_vport_send(vport, skb, data->mac_proto);
772 return 0;
773 }
774
775 static unsigned int
776 ovs_dst_get_mtu(const struct dst_entry *dst)
777 {
778 return dst->dev->mtu;
779 }
780
781 static struct dst_ops ovs_dst_ops = {
782 .family = AF_UNSPEC,
783 .mtu = ovs_dst_get_mtu,
784 };
785
786
787
788
789 static void prepare_frag(struct vport *vport, struct sk_buff *skb,
790 u16 orig_network_offset, u8 mac_proto)
791 {
792 unsigned int hlen = skb_network_offset(skb);
793 struct ovs_frag_data *data;
794
795 data = this_cpu_ptr(&ovs_frag_data_storage);
796 data->dst = skb->_skb_refdst;
797 data->vport = vport;
798 data->cb = *OVS_CB(skb);
799 data->inner_protocol = skb->inner_protocol;
800 data->network_offset = orig_network_offset;
801 if (skb_vlan_tag_present(skb))
802 data->vlan_tci = skb_vlan_tag_get(skb) | VLAN_CFI_MASK;
803 else
804 data->vlan_tci = 0;
805 data->vlan_proto = skb->vlan_proto;
806 data->mac_proto = mac_proto;
807 data->l2_len = hlen;
808 memcpy(&data->l2_data, skb->data, hlen);
809
810 memset(IPCB(skb), 0, sizeof(struct inet_skb_parm));
811 skb_pull(skb, hlen);
812 }
813
814 static void ovs_fragment(struct net *net, struct vport *vport,
815 struct sk_buff *skb, u16 mru,
816 struct sw_flow_key *key)
817 {
818 u16 orig_network_offset = 0;
819
820 if (eth_p_mpls(skb->protocol)) {
821 orig_network_offset = skb_network_offset(skb);
822 skb->network_header = skb->inner_network_header;
823 }
824
825 if (skb_network_offset(skb) > MAX_L2_LEN) {
826 OVS_NLERR(1, "L2 header too long to fragment");
827 goto err;
828 }
829
830 if (key->eth.type == htons(ETH_P_IP)) {
831 struct dst_entry ovs_dst;
832 unsigned long orig_dst;
833
834 prepare_frag(vport, skb, orig_network_offset,
835 ovs_key_mac_proto(key));
836 dst_init(&ovs_dst, &ovs_dst_ops, NULL, 1,
837 DST_OBSOLETE_NONE, DST_NOCOUNT);
838 ovs_dst.dev = vport->dev;
839
840 orig_dst = skb->_skb_refdst;
841 skb_dst_set_noref(skb, &ovs_dst);
842 IPCB(skb)->frag_max_size = mru;
843
844 ip_do_fragment(net, skb->sk, skb, ovs_vport_output);
845 refdst_drop(orig_dst);
846 } else if (key->eth.type == htons(ETH_P_IPV6)) {
847 const struct nf_ipv6_ops *v6ops = nf_get_ipv6_ops();
848 unsigned long orig_dst;
849 struct rt6_info ovs_rt;
850
851 if (!v6ops)
852 goto err;
853
854 prepare_frag(vport, skb, orig_network_offset,
855 ovs_key_mac_proto(key));
856 memset(&ovs_rt, 0, sizeof(ovs_rt));
857 dst_init(&ovs_rt.dst, &ovs_dst_ops, NULL, 1,
858 DST_OBSOLETE_NONE, DST_NOCOUNT);
859 ovs_rt.dst.dev = vport->dev;
860
861 orig_dst = skb->_skb_refdst;
862 skb_dst_set_noref(skb, &ovs_rt.dst);
863 IP6CB(skb)->frag_max_size = mru;
864
865 v6ops->fragment(net, skb->sk, skb, ovs_vport_output);
866 refdst_drop(orig_dst);
867 } else {
868 WARN_ONCE(1, "Failed fragment ->%s: eth=%04x, MRU=%d, MTU=%d.",
869 ovs_vport_name(vport), ntohs(key->eth.type), mru,
870 vport->dev->mtu);
871 goto err;
872 }
873
874 return;
875 err:
876 kfree_skb(skb);
877 }
878
879 static void do_output(struct datapath *dp, struct sk_buff *skb, int out_port,
880 struct sw_flow_key *key)
881 {
882 struct vport *vport = ovs_vport_rcu(dp, out_port);
883
884 if (likely(vport)) {
885 u16 mru = OVS_CB(skb)->mru;
886 u32 cutlen = OVS_CB(skb)->cutlen;
887
888 if (unlikely(cutlen > 0)) {
889 if (skb->len - cutlen > ovs_mac_header_len(key))
890 pskb_trim(skb, skb->len - cutlen);
891 else
892 pskb_trim(skb, ovs_mac_header_len(key));
893 }
894
895 if (likely(!mru ||
896 (skb->len <= mru + vport->dev->hard_header_len))) {
897 ovs_vport_send(vport, skb, ovs_key_mac_proto(key));
898 } else if (mru <= vport->dev->mtu) {
899 struct net *net = read_pnet(&dp->net);
900
901 ovs_fragment(net, vport, skb, mru, key);
902 } else {
903 kfree_skb(skb);
904 }
905 } else {
906 kfree_skb(skb);
907 }
908 }
909
910 static int output_userspace(struct datapath *dp, struct sk_buff *skb,
911 struct sw_flow_key *key, const struct nlattr *attr,
912 const struct nlattr *actions, int actions_len,
913 uint32_t cutlen)
914 {
915 struct dp_upcall_info upcall;
916 const struct nlattr *a;
917 int rem;
918
919 memset(&upcall, 0, sizeof(upcall));
920 upcall.cmd = OVS_PACKET_CMD_ACTION;
921 upcall.mru = OVS_CB(skb)->mru;
922
923 for (a = nla_data(attr), rem = nla_len(attr); rem > 0;
924 a = nla_next(a, &rem)) {
925 switch (nla_type(a)) {
926 case OVS_USERSPACE_ATTR_USERDATA:
927 upcall.userdata = a;
928 break;
929
930 case OVS_USERSPACE_ATTR_PID:
931 upcall.portid = nla_get_u32(a);
932 break;
933
934 case OVS_USERSPACE_ATTR_EGRESS_TUN_PORT: {
935
936 struct vport *vport;
937
938 vport = ovs_vport_rcu(dp, nla_get_u32(a));
939 if (vport) {
940 int err;
941
942 err = dev_fill_metadata_dst(vport->dev, skb);
943 if (!err)
944 upcall.egress_tun_info = skb_tunnel_info(skb);
945 }
946
947 break;
948 }
949
950 case OVS_USERSPACE_ATTR_ACTIONS: {
951
952 upcall.actions = actions;
953 upcall.actions_len = actions_len;
954 break;
955 }
956
957 }
958 }
959
960 return ovs_dp_upcall(dp, skb, key, &upcall, cutlen);
961 }
962
963
964
965
966
967 static int sample(struct datapath *dp, struct sk_buff *skb,
968 struct sw_flow_key *key, const struct nlattr *attr,
969 bool last)
970 {
971 struct nlattr *actions;
972 struct nlattr *sample_arg;
973 int rem = nla_len(attr);
974 const struct sample_arg *arg;
975 bool clone_flow_key;
976
977
978 sample_arg = nla_data(attr);
979 arg = nla_data(sample_arg);
980 actions = nla_next(sample_arg, &rem);
981
982 if ((arg->probability != U32_MAX) &&
983 (!arg->probability || prandom_u32() > arg->probability)) {
984 if (last)
985 consume_skb(skb);
986 return 0;
987 }
988
989 clone_flow_key = !arg->exec;
990 return clone_execute(dp, skb, key, 0, actions, rem, last,
991 clone_flow_key);
992 }
993
994
995
996
997
998 static int clone(struct datapath *dp, struct sk_buff *skb,
999 struct sw_flow_key *key, const struct nlattr *attr,
1000 bool last)
1001 {
1002 struct nlattr *actions;
1003 struct nlattr *clone_arg;
1004 int rem = nla_len(attr);
1005 bool dont_clone_flow_key;
1006
1007
1008 clone_arg = nla_data(attr);
1009 dont_clone_flow_key = nla_get_u32(clone_arg);
1010 actions = nla_next(clone_arg, &rem);
1011
1012 return clone_execute(dp, skb, key, 0, actions, rem, last,
1013 !dont_clone_flow_key);
1014 }
1015
1016 static void execute_hash(struct sk_buff *skb, struct sw_flow_key *key,
1017 const struct nlattr *attr)
1018 {
1019 struct ovs_action_hash *hash_act = nla_data(attr);
1020 u32 hash = 0;
1021
1022
1023 hash = skb_get_hash(skb);
1024 hash = jhash_1word(hash, hash_act->hash_basis);
1025 if (!hash)
1026 hash = 0x1;
1027
1028 key->ovs_flow_hash = hash;
1029 }
1030
1031 static int execute_set_action(struct sk_buff *skb,
1032 struct sw_flow_key *flow_key,
1033 const struct nlattr *a)
1034 {
1035
1036 if (nla_type(a) == OVS_KEY_ATTR_TUNNEL_INFO) {
1037 struct ovs_tunnel_info *tun = nla_data(a);
1038
1039 skb_dst_drop(skb);
1040 dst_hold((struct dst_entry *)tun->tun_dst);
1041 skb_dst_set(skb, (struct dst_entry *)tun->tun_dst);
1042 return 0;
1043 }
1044
1045 return -EINVAL;
1046 }
1047
1048
1049 #define get_mask(a, type) ((const type)nla_data(a) + 1)
1050
1051 static int execute_masked_set_action(struct sk_buff *skb,
1052 struct sw_flow_key *flow_key,
1053 const struct nlattr *a)
1054 {
1055 int err = 0;
1056
1057 switch (nla_type(a)) {
1058 case OVS_KEY_ATTR_PRIORITY:
1059 OVS_SET_MASKED(skb->priority, nla_get_u32(a),
1060 *get_mask(a, u32 *));
1061 flow_key->phy.priority = skb->priority;
1062 break;
1063
1064 case OVS_KEY_ATTR_SKB_MARK:
1065 OVS_SET_MASKED(skb->mark, nla_get_u32(a), *get_mask(a, u32 *));
1066 flow_key->phy.skb_mark = skb->mark;
1067 break;
1068
1069 case OVS_KEY_ATTR_TUNNEL_INFO:
1070
1071 err = -EINVAL;
1072 break;
1073
1074 case OVS_KEY_ATTR_ETHERNET:
1075 err = set_eth_addr(skb, flow_key, nla_data(a),
1076 get_mask(a, struct ovs_key_ethernet *));
1077 break;
1078
1079 case OVS_KEY_ATTR_NSH:
1080 err = set_nsh(skb, flow_key, a);
1081 break;
1082
1083 case OVS_KEY_ATTR_IPV4:
1084 err = set_ipv4(skb, flow_key, nla_data(a),
1085 get_mask(a, struct ovs_key_ipv4 *));
1086 break;
1087
1088 case OVS_KEY_ATTR_IPV6:
1089 err = set_ipv6(skb, flow_key, nla_data(a),
1090 get_mask(a, struct ovs_key_ipv6 *));
1091 break;
1092
1093 case OVS_KEY_ATTR_TCP:
1094 err = set_tcp(skb, flow_key, nla_data(a),
1095 get_mask(a, struct ovs_key_tcp *));
1096 break;
1097
1098 case OVS_KEY_ATTR_UDP:
1099 err = set_udp(skb, flow_key, nla_data(a),
1100 get_mask(a, struct ovs_key_udp *));
1101 break;
1102
1103 case OVS_KEY_ATTR_SCTP:
1104 err = set_sctp(skb, flow_key, nla_data(a),
1105 get_mask(a, struct ovs_key_sctp *));
1106 break;
1107
1108 case OVS_KEY_ATTR_MPLS:
1109 err = set_mpls(skb, flow_key, nla_data(a), get_mask(a,
1110 __be32 *));
1111 break;
1112
1113 case OVS_KEY_ATTR_CT_STATE:
1114 case OVS_KEY_ATTR_CT_ZONE:
1115 case OVS_KEY_ATTR_CT_MARK:
1116 case OVS_KEY_ATTR_CT_LABELS:
1117 case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4:
1118 case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6:
1119 err = -EINVAL;
1120 break;
1121 }
1122
1123 return err;
1124 }
1125
1126 static int execute_recirc(struct datapath *dp, struct sk_buff *skb,
1127 struct sw_flow_key *key,
1128 const struct nlattr *a, bool last)
1129 {
1130 u32 recirc_id;
1131
1132 if (!is_flow_key_valid(key)) {
1133 int err;
1134
1135 err = ovs_flow_key_update(skb, key);
1136 if (err)
1137 return err;
1138 }
1139 BUG_ON(!is_flow_key_valid(key));
1140
1141 recirc_id = nla_get_u32(a);
1142 return clone_execute(dp, skb, key, recirc_id, NULL, 0, last, true);
1143 }
1144
1145 static int execute_check_pkt_len(struct datapath *dp, struct sk_buff *skb,
1146 struct sw_flow_key *key,
1147 const struct nlattr *attr, bool last)
1148 {
1149 const struct nlattr *actions, *cpl_arg;
1150 const struct check_pkt_len_arg *arg;
1151 int rem = nla_len(attr);
1152 bool clone_flow_key;
1153
1154
1155
1156
1157 cpl_arg = nla_data(attr);
1158 arg = nla_data(cpl_arg);
1159
1160 if (skb->len <= arg->pkt_len) {
1161
1162
1163
1164 actions = nla_next(cpl_arg, &rem);
1165 clone_flow_key = !arg->exec_for_lesser_equal;
1166 } else {
1167
1168
1169
1170 actions = nla_next(cpl_arg, &rem);
1171 actions = nla_next(actions, &rem);
1172 clone_flow_key = !arg->exec_for_greater;
1173 }
1174
1175 return clone_execute(dp, skb, key, 0, nla_data(actions),
1176 nla_len(actions), last, clone_flow_key);
1177 }
1178
1179
1180 static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
1181 struct sw_flow_key *key,
1182 const struct nlattr *attr, int len)
1183 {
1184 const struct nlattr *a;
1185 int rem;
1186
1187 for (a = attr, rem = len; rem > 0;
1188 a = nla_next(a, &rem)) {
1189 int err = 0;
1190
1191 switch (nla_type(a)) {
1192 case OVS_ACTION_ATTR_OUTPUT: {
1193 int port = nla_get_u32(a);
1194 struct sk_buff *clone;
1195
1196
1197
1198
1199
1200 if (nla_is_last(a, rem)) {
1201 do_output(dp, skb, port, key);
1202
1203
1204 return 0;
1205 }
1206
1207 clone = skb_clone(skb, GFP_ATOMIC);
1208 if (clone)
1209 do_output(dp, clone, port, key);
1210 OVS_CB(skb)->cutlen = 0;
1211 break;
1212 }
1213
1214 case OVS_ACTION_ATTR_TRUNC: {
1215 struct ovs_action_trunc *trunc = nla_data(a);
1216
1217 if (skb->len > trunc->max_len)
1218 OVS_CB(skb)->cutlen = skb->len - trunc->max_len;
1219 break;
1220 }
1221
1222 case OVS_ACTION_ATTR_USERSPACE:
1223 output_userspace(dp, skb, key, a, attr,
1224 len, OVS_CB(skb)->cutlen);
1225 OVS_CB(skb)->cutlen = 0;
1226 break;
1227
1228 case OVS_ACTION_ATTR_HASH:
1229 execute_hash(skb, key, a);
1230 break;
1231
1232 case OVS_ACTION_ATTR_PUSH_MPLS:
1233 err = push_mpls(skb, key, nla_data(a));
1234 break;
1235
1236 case OVS_ACTION_ATTR_POP_MPLS:
1237 err = pop_mpls(skb, key, nla_get_be16(a));
1238 break;
1239
1240 case OVS_ACTION_ATTR_PUSH_VLAN:
1241 err = push_vlan(skb, key, nla_data(a));
1242 break;
1243
1244 case OVS_ACTION_ATTR_POP_VLAN:
1245 err = pop_vlan(skb, key);
1246 break;
1247
1248 case OVS_ACTION_ATTR_RECIRC: {
1249 bool last = nla_is_last(a, rem);
1250
1251 err = execute_recirc(dp, skb, key, a, last);
1252 if (last) {
1253
1254
1255
1256
1257 return err;
1258 }
1259 break;
1260 }
1261
1262 case OVS_ACTION_ATTR_SET:
1263 err = execute_set_action(skb, key, nla_data(a));
1264 break;
1265
1266 case OVS_ACTION_ATTR_SET_MASKED:
1267 case OVS_ACTION_ATTR_SET_TO_MASKED:
1268 err = execute_masked_set_action(skb, key, nla_data(a));
1269 break;
1270
1271 case OVS_ACTION_ATTR_SAMPLE: {
1272 bool last = nla_is_last(a, rem);
1273
1274 err = sample(dp, skb, key, a, last);
1275 if (last)
1276 return err;
1277
1278 break;
1279 }
1280
1281 case OVS_ACTION_ATTR_CT:
1282 if (!is_flow_key_valid(key)) {
1283 err = ovs_flow_key_update(skb, key);
1284 if (err)
1285 return err;
1286 }
1287
1288 err = ovs_ct_execute(ovs_dp_get_net(dp), skb, key,
1289 nla_data(a));
1290
1291
1292 if (err)
1293 return err == -EINPROGRESS ? 0 : err;
1294 break;
1295
1296 case OVS_ACTION_ATTR_CT_CLEAR:
1297 err = ovs_ct_clear(skb, key);
1298 break;
1299
1300 case OVS_ACTION_ATTR_PUSH_ETH:
1301 err = push_eth(skb, key, nla_data(a));
1302 break;
1303
1304 case OVS_ACTION_ATTR_POP_ETH:
1305 err = pop_eth(skb, key);
1306 break;
1307
1308 case OVS_ACTION_ATTR_PUSH_NSH: {
1309 u8 buffer[NSH_HDR_MAX_LEN];
1310 struct nshhdr *nh = (struct nshhdr *)buffer;
1311
1312 err = nsh_hdr_from_nlattr(nla_data(a), nh,
1313 NSH_HDR_MAX_LEN);
1314 if (unlikely(err))
1315 break;
1316 err = push_nsh(skb, key, nh);
1317 break;
1318 }
1319
1320 case OVS_ACTION_ATTR_POP_NSH:
1321 err = pop_nsh(skb, key);
1322 break;
1323
1324 case OVS_ACTION_ATTR_METER:
1325 if (ovs_meter_execute(dp, skb, key, nla_get_u32(a))) {
1326 consume_skb(skb);
1327 return 0;
1328 }
1329 break;
1330
1331 case OVS_ACTION_ATTR_CLONE: {
1332 bool last = nla_is_last(a, rem);
1333
1334 err = clone(dp, skb, key, a, last);
1335 if (last)
1336 return err;
1337
1338 break;
1339 }
1340
1341 case OVS_ACTION_ATTR_CHECK_PKT_LEN: {
1342 bool last = nla_is_last(a, rem);
1343
1344 err = execute_check_pkt_len(dp, skb, key, a, last);
1345 if (last)
1346 return err;
1347
1348 break;
1349 }
1350 }
1351
1352 if (unlikely(err)) {
1353 kfree_skb(skb);
1354 return err;
1355 }
1356 }
1357
1358 consume_skb(skb);
1359 return 0;
1360 }
1361
1362
1363
1364
1365
1366
1367
1368 static int clone_execute(struct datapath *dp, struct sk_buff *skb,
1369 struct sw_flow_key *key, u32 recirc_id,
1370 const struct nlattr *actions, int len,
1371 bool last, bool clone_flow_key)
1372 {
1373 struct deferred_action *da;
1374 struct sw_flow_key *clone;
1375
1376 skb = last ? skb : skb_clone(skb, GFP_ATOMIC);
1377 if (!skb) {
1378
1379
1380 return 0;
1381 }
1382
1383
1384
1385
1386
1387
1388
1389 clone = clone_flow_key ? clone_key(key) : key;
1390 if (clone) {
1391 int err = 0;
1392
1393 if (actions) {
1394 if (clone_flow_key)
1395 __this_cpu_inc(exec_actions_level);
1396
1397 err = do_execute_actions(dp, skb, clone,
1398 actions, len);
1399
1400 if (clone_flow_key)
1401 __this_cpu_dec(exec_actions_level);
1402 } else {
1403 clone->recirc_id = recirc_id;
1404 ovs_dp_process_packet(skb, clone);
1405 }
1406 return err;
1407 }
1408
1409
1410 da = add_deferred_actions(skb, key, actions, len);
1411 if (da) {
1412 if (!actions) {
1413 key = &da->pkt_key;
1414 key->recirc_id = recirc_id;
1415 }
1416 } else {
1417
1418
1419
1420 kfree_skb(skb);
1421
1422 if (net_ratelimit()) {
1423 if (actions) {
1424 pr_warn("%s: deferred action limit reached, drop sample action\n",
1425 ovs_dp_name(dp));
1426 } else {
1427 pr_warn("%s: deferred action limit reached, drop recirc action\n",
1428 ovs_dp_name(dp));
1429 }
1430 }
1431 }
1432 return 0;
1433 }
1434
1435 static void process_deferred_actions(struct datapath *dp)
1436 {
1437 struct action_fifo *fifo = this_cpu_ptr(action_fifos);
1438
1439
1440 if (action_fifo_is_empty(fifo))
1441 return;
1442
1443
1444 do {
1445 struct deferred_action *da = action_fifo_get(fifo);
1446 struct sk_buff *skb = da->skb;
1447 struct sw_flow_key *key = &da->pkt_key;
1448 const struct nlattr *actions = da->actions;
1449 int actions_len = da->actions_len;
1450
1451 if (actions)
1452 do_execute_actions(dp, skb, key, actions, actions_len);
1453 else
1454 ovs_dp_process_packet(skb, key);
1455 } while (!action_fifo_is_empty(fifo));
1456
1457
1458 action_fifo_init(fifo);
1459 }
1460
1461
1462 int ovs_execute_actions(struct datapath *dp, struct sk_buff *skb,
1463 const struct sw_flow_actions *acts,
1464 struct sw_flow_key *key)
1465 {
1466 int err, level;
1467
1468 level = __this_cpu_inc_return(exec_actions_level);
1469 if (unlikely(level > OVS_RECURSION_LIMIT)) {
1470 net_crit_ratelimited("ovs: recursion limit reached on datapath %s, probable configuration error\n",
1471 ovs_dp_name(dp));
1472 kfree_skb(skb);
1473 err = -ENETDOWN;
1474 goto out;
1475 }
1476
1477 OVS_CB(skb)->acts_origlen = acts->orig_len;
1478 err = do_execute_actions(dp, skb, key,
1479 acts->actions, acts->actions_len);
1480
1481 if (level == 1)
1482 process_deferred_actions(dp);
1483
1484 out:
1485 __this_cpu_dec(exec_actions_level);
1486 return err;
1487 }
1488
1489 int action_fifos_init(void)
1490 {
1491 action_fifos = alloc_percpu(struct action_fifo);
1492 if (!action_fifos)
1493 return -ENOMEM;
1494
1495 flow_keys = alloc_percpu(struct action_flow_keys);
1496 if (!flow_keys) {
1497 free_percpu(action_fifos);
1498 return -ENOMEM;
1499 }
1500
1501 return 0;
1502 }
1503
1504 void action_fifos_exit(void)
1505 {
1506 free_percpu(action_fifos);
1507 free_percpu(flow_keys);
1508 }