blob: 076774034bb960b16c04609cd120fd5118829538 [file] [log] [blame]
Thomas Gleixnerc9422992019-05-29 07:12:43 -07001// SPDX-License-Identifier: GPL-2.0-only
Jesse Grossccb13522011-10-25 19:26:31 -07002/*
andy zhou4572ef52017-03-20 16:32:28 -07003 * Copyright (c) 2007-2017 Nicira, Inc.
Jesse Grossccb13522011-10-25 19:26:31 -07004 */
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>
Joe Stringera175a722013-08-22 12:30:48 -070012#include <linux/sctp.h>
Jesse Grossccb13522011-10-25 19:26:31 -070013#include <linux/tcp.h>
14#include <linux/udp.h>
15#include <linux/in6.h>
16#include <linux/if_arp.h>
17#include <linux/if_vlan.h>
Simon Horman25cd9ba2014-10-06 05:05:13 -070018
Joe Stringer7f8a4362015-08-26 11:31:48 -070019#include <net/dst.h>
Jesse Grossccb13522011-10-25 19:26:31 -070020#include <net/ip.h>
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -080021#include <net/ipv6.h>
Joe Stringer7b85b4d2015-08-27 15:25:46 -070022#include <net/ip6_fib.h>
Jesse Grossccb13522011-10-25 19:26:31 -070023#include <net/checksum.h>
24#include <net/dsfield.h>
Simon Horman25cd9ba2014-10-06 05:05:13 -070025#include <net/mpls.h>
Joe Stringera175a722013-08-22 12:30:48 -070026#include <net/sctp/checksum.h>
Jesse Grossccb13522011-10-25 19:26:31 -070027
28#include "datapath.h"
Andy Zhou971427f32014-09-15 19:37:25 -070029#include "flow.h"
Joe Stringer7f8a4362015-08-26 11:31:48 -070030#include "conntrack.h"
Jesse Grossccb13522011-10-25 19:26:31 -070031#include "vport.h"
Yi Yangb2d0f5d2017-11-07 21:07:02 +080032#include "flow_netlink.h"
Aaron Conolec4ab7b52021-06-22 10:02:33 -040033#include "openvswitch_trace.h"
Jesse Grossccb13522011-10-25 19:26:31 -070034
Andy Zhou971427f32014-09-15 19:37:25 -070035struct deferred_action {
36 struct sk_buff *skb;
37 const struct nlattr *actions;
andy zhou47c697a2017-03-20 16:32:27 -070038 int actions_len;
Andy Zhou971427f32014-09-15 19:37:25 -070039
40 /* Store pkt_key clone when creating deferred action. */
41 struct sw_flow_key pkt_key;
42};
43
Joe Stringer7f8a4362015-08-26 11:31:48 -070044#define MAX_L2_LEN (VLAN_ETH_HLEN + 3 * MPLS_HLEN)
45struct ovs_frag_data {
46 unsigned long dst;
47 struct vport *vport;
48 struct ovs_skb_cb cb;
49 __be16 inner_protocol;
Jiri Bencc66549f2016-10-05 15:01:57 +020050 u16 network_offset; /* valid only for MPLS */
51 u16 vlan_tci;
Joe Stringer7f8a4362015-08-26 11:31:48 -070052 __be16 vlan_proto;
53 unsigned int l2_len;
Jiri Bence2d9d832016-11-10 16:28:19 +010054 u8 mac_proto;
Joe Stringer7f8a4362015-08-26 11:31:48 -070055 u8 l2_data[MAX_L2_LEN];
56};
57
58static DEFINE_PER_CPU(struct ovs_frag_data, ovs_frag_data_storage);
59
Andy Zhou971427f32014-09-15 19:37:25 -070060#define DEFERRED_ACTION_FIFO_SIZE 10
Lance Richardson2679d042016-09-13 10:08:54 -040061#define OVS_RECURSION_LIMIT 5
62#define OVS_DEFERRED_ACTION_THRESHOLD (OVS_RECURSION_LIMIT - 2)
Andy Zhou971427f32014-09-15 19:37:25 -070063struct action_fifo {
64 int head;
65 int tail;
66 /* Deferred action fifo queue storage. */
67 struct deferred_action fifo[DEFERRED_ACTION_FIFO_SIZE];
68};
69
andy zhou4572ef52017-03-20 16:32:28 -070070struct action_flow_keys {
Lance Richardson2679d042016-09-13 10:08:54 -040071 struct sw_flow_key key[OVS_DEFERRED_ACTION_THRESHOLD];
72};
73
Andy Zhou971427f32014-09-15 19:37:25 -070074static struct action_fifo __percpu *action_fifos;
andy zhou4572ef52017-03-20 16:32:28 -070075static struct action_flow_keys __percpu *flow_keys;
Andy Zhou971427f32014-09-15 19:37:25 -070076static DEFINE_PER_CPU(int, exec_actions_level);
77
andy zhou4572ef52017-03-20 16:32:28 -070078/* Make a clone of the 'key', using the pre-allocated percpu 'flow_keys'
79 * space. Return NULL if out of key spaces.
80 */
81static 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
Andy Zhou971427f32014-09-15 19:37:25 -070095static void action_fifo_init(struct action_fifo *fifo)
96{
97 fifo->head = 0;
98 fifo->tail = 0;
99}
100
Thomas Graf12eb18f2014-11-06 06:58:52 -0800101static bool action_fifo_is_empty(const struct action_fifo *fifo)
Andy Zhou971427f32014-09-15 19:37:25 -0700102{
103 return (fifo->head == fifo->tail);
104}
105
106static 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
114static 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/* Return true if fifo is not full */
123static struct deferred_action *add_deferred_actions(struct sk_buff *skb,
andy zhou47c697a2017-03-20 16:32:27 -0700124 const struct sw_flow_key *key,
125 const struct nlattr *actions,
126 const int actions_len)
Andy Zhou971427f32014-09-15 19:37:25 -0700127{
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;
andy zhou47c697a2017-03-20 16:32:27 -0700135 da->actions = actions;
136 da->actions_len = actions_len;
Andy Zhou971427f32014-09-15 19:37:25 -0700137 da->pkt_key = *key;
138 }
139
140 return da;
141}
142
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800143static void invalidate_flow_key(struct sw_flow_key *key)
144{
Jiri Benc329f45b2016-11-10 16:28:18 +0100145 key->mac_proto |= SW_FLOW_KEY_INVALID;
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800146}
147
148static bool is_flow_key_valid(const struct sw_flow_key *key)
149{
Jiri Benc329f45b2016-11-10 16:28:18 +0100150 return !(key->mac_proto & SW_FLOW_KEY_INVALID);
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800151}
152
andy zhoubef7f752017-03-20 16:32:30 -0700153static 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
Numan Siddique4d5ec892019-03-26 06:13:46 +0530159static 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
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800163static int push_mpls(struct sk_buff *skb, struct sw_flow_key *key,
Martin Varghesef66b53f2019-12-21 08:50:46 +0530164 __be32 mpls_lse, __be16 mpls_ethertype, __u16 mac_len)
Simon Horman25cd9ba2014-10-06 05:05:13 -0700165{
John Hurley8822e272019-07-07 15:01:54 +0100166 int err;
Simon Horman25cd9ba2014-10-06 05:05:13 -0700167
Martin Varghesef66b53f2019-12-21 08:50:46 +0530168 err = skb_mpls_push(skb, mpls_lse, mpls_ethertype, mac_len, !!mac_len);
John Hurley8822e272019-07-07 15:01:54 +0100169 if (err)
170 return err;
Simon Horman25cd9ba2014-10-06 05:05:13 -0700171
Martin Varghesef66b53f2019-12-21 08:50:46 +0530172 if (!mac_len)
173 key->mac_proto = MAC_PROTO_NONE;
174
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800175 invalidate_flow_key(key);
Simon Horman25cd9ba2014-10-06 05:05:13 -0700176 return 0;
177}
178
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800179static int pop_mpls(struct sk_buff *skb, struct sw_flow_key *key,
180 const __be16 ethertype)
Simon Horman25cd9ba2014-10-06 05:05:13 -0700181{
Simon Horman25cd9ba2014-10-06 05:05:13 -0700182 int err;
183
Martin Varghese040b5cf2019-12-02 10:49:51 +0530184 err = skb_mpls_pop(skb, ethertype, skb->mac_len,
185 ovs_key_mac_proto(key) == MAC_PROTO_ETHERNET);
John Hurleyed246ce2019-07-07 15:01:55 +0100186 if (err)
Simon Horman25cd9ba2014-10-06 05:05:13 -0700187 return err;
188
Martin Varghesef66b53f2019-12-21 08:50:46 +0530189 if (ethertype == htons(ETH_P_TEB))
190 key->mac_proto = MAC_PROTO_ETHERNET;
191
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800192 invalidate_flow_key(key);
Simon Horman25cd9ba2014-10-06 05:05:13 -0700193 return 0;
194}
195
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800196static int set_mpls(struct sk_buff *skb, struct sw_flow_key *flow_key,
197 const __be32 *mpls_lse, const __be32 *mask)
Simon Horman25cd9ba2014-10-06 05:05:13 -0700198{
Jiri Benc85de4a22016-09-30 19:08:07 +0200199 struct mpls_shim_hdr *stack;
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800200 __be32 lse;
Simon Horman25cd9ba2014-10-06 05:05:13 -0700201 int err;
202
Davide Caratti43c13602020-12-03 10:46:06 +0100203 if (!pskb_may_pull(skb, skb_network_offset(skb) + MPLS_HLEN))
204 return -ENOMEM;
205
Jiri Benc85de4a22016-09-30 19:08:07 +0200206 stack = mpls_hdr(skb);
207 lse = OVS_MASKED(stack->label_stack_entry, *mpls_lse, *mask);
John Hurleyd27cf5c2019-07-07 15:01:56 +0100208 err = skb_mpls_update_lse(skb, lse);
209 if (err)
210 return err;
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800211
Martin Varghesefbdcdd72019-11-04 07:27:44 +0530212 flow_key->mpls.lse[0] = lse;
Simon Horman25cd9ba2014-10-06 05:05:13 -0700213 return 0;
214}
215
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800216static int pop_vlan(struct sk_buff *skb, struct sw_flow_key *key)
Jesse Grossccb13522011-10-25 19:26:31 -0700217{
Jesse Grossccb13522011-10-25 19:26:31 -0700218 int err;
219
Jiri Pirko93515d52014-11-19 14:05:02 +0100220 err = skb_vlan_pop(skb);
Eric Garver018c1dd2016-09-07 12:56:59 -0400221 if (skb_vlan_tag_present(skb)) {
Jiri Pirko93515d52014-11-19 14:05:02 +0100222 invalidate_flow_key(key);
Eric Garver018c1dd2016-09-07 12:56:59 -0400223 } else {
224 key->eth.vlan.tci = 0;
225 key->eth.vlan.tpid = 0;
226 }
Jiri Pirko93515d52014-11-19 14:05:02 +0100227 return err;
Jesse Grossccb13522011-10-25 19:26:31 -0700228}
229
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800230static int push_vlan(struct sk_buff *skb, struct sw_flow_key *key,
231 const struct ovs_action_push_vlan *vlan)
Jesse Grossccb13522011-10-25 19:26:31 -0700232{
Eric Garver018c1dd2016-09-07 12:56:59 -0400233 if (skb_vlan_tag_present(skb)) {
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800234 invalidate_flow_key(key);
Eric Garver018c1dd2016-09-07 12:56:59 -0400235 } else {
236 key->eth.vlan.tci = vlan->vlan_tci;
237 key->eth.vlan.tpid = vlan->vlan_tpid;
238 }
Jiri Pirko93515d52014-11-19 14:05:02 +0100239 return skb_vlan_push(skb, vlan->vlan_tpid,
Michał Mirosław9df46ae2018-11-08 18:44:50 +0100240 ntohs(vlan->vlan_tci) & ~VLAN_CFI_MASK);
Jesse Grossccb13522011-10-25 19:26:31 -0700241}
242
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800243/* 'src' is already properly masked. */
244static void ether_addr_copy_masked(u8 *dst_, const u8 *src_, const u8 *mask_)
245{
246 u16 *dst = (u16 *)dst_;
247 const u16 *src = (const u16 *)src_;
248 const u16 *mask = (const u16 *)mask_;
249
Joe Stringerbe26b9a2015-08-26 11:31:45 -0700250 OVS_SET_MASKED(dst[0], src[0], mask[0]);
251 OVS_SET_MASKED(dst[1], src[1], mask[1]);
252 OVS_SET_MASKED(dst[2], src[2], mask[2]);
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800253}
254
255static int set_eth_addr(struct sk_buff *skb, struct sw_flow_key *flow_key,
256 const struct ovs_key_ethernet *key,
257 const struct ovs_key_ethernet *mask)
Jesse Grossccb13522011-10-25 19:26:31 -0700258{
259 int err;
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800260
Jiri Pirkoe2195122014-11-19 14:05:01 +0100261 err = skb_ensure_writable(skb, ETH_HLEN);
Jesse Grossccb13522011-10-25 19:26:31 -0700262 if (unlikely(err))
263 return err;
264
Pravin B Shelarb34df5e2013-06-13 11:11:44 -0700265 skb_postpull_rcsum(skb, eth_hdr(skb), ETH_ALEN * 2);
266
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800267 ether_addr_copy_masked(eth_hdr(skb)->h_source, key->eth_src,
268 mask->eth_src);
269 ether_addr_copy_masked(eth_hdr(skb)->h_dest, key->eth_dst,
270 mask->eth_dst);
Jesse Grossccb13522011-10-25 19:26:31 -0700271
Daniel Borkmann6b83d282016-02-20 00:29:30 +0100272 skb_postpush_rcsum(skb, eth_hdr(skb), ETH_ALEN * 2);
Pravin B Shelarb34df5e2013-06-13 11:11:44 -0700273
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800274 ether_addr_copy(flow_key->eth.src, eth_hdr(skb)->h_source);
275 ether_addr_copy(flow_key->eth.dst, eth_hdr(skb)->h_dest);
Jesse Grossccb13522011-10-25 19:26:31 -0700276 return 0;
277}
278
Jiri Benc91820da2016-11-10 16:28:23 +0100279/* pop_eth does not support VLAN packets as this action is never called
280 * for them.
281 */
282static int pop_eth(struct sk_buff *skb, struct sw_flow_key *key)
283{
Guillaume Nault19fbcb32020-10-03 00:44:28 +0200284 int err;
285
286 err = skb_eth_pop(skb);
287 if (err)
288 return err;
Jiri Benc91820da2016-11-10 16:28:23 +0100289
290 /* safe right before invalidate_flow_key */
291 key->mac_proto = MAC_PROTO_NONE;
292 invalidate_flow_key(key);
293 return 0;
294}
295
296static int push_eth(struct sk_buff *skb, struct sw_flow_key *key,
297 const struct ovs_action_push_eth *ethh)
298{
Guillaume Nault19fbcb32020-10-03 00:44:28 +0200299 int err;
Jiri Benc91820da2016-11-10 16:28:23 +0100300
Guillaume Nault19fbcb32020-10-03 00:44:28 +0200301 err = skb_eth_push(skb, ethh->addresses.eth_dst,
302 ethh->addresses.eth_src);
303 if (err)
304 return err;
Jiri Benc91820da2016-11-10 16:28:23 +0100305
306 /* safe right before invalidate_flow_key */
307 key->mac_proto = MAC_PROTO_ETHERNET;
308 invalidate_flow_key(key);
309 return 0;
310}
311
Yi Yangb2d0f5d2017-11-07 21:07:02 +0800312static int push_nsh(struct sk_buff *skb, struct sw_flow_key *key,
313 const struct nshhdr *nh)
314{
315 int err;
316
317 err = nsh_push(skb, nh);
318 if (err)
319 return err;
320
321 /* safe right before invalidate_flow_key */
322 key->mac_proto = MAC_PROTO_NONE;
323 invalidate_flow_key(key);
324 return 0;
325}
326
327static int pop_nsh(struct sk_buff *skb, struct sw_flow_key *key)
328{
329 int err;
330
331 err = nsh_pop(skb);
332 if (err)
333 return err;
334
335 /* safe right before invalidate_flow_key */
336 if (skb->protocol == htons(ETH_P_TEB))
337 key->mac_proto = MAC_PROTO_ETHERNET;
338 else
339 key->mac_proto = MAC_PROTO_NONE;
340 invalidate_flow_key(key);
341 return 0;
342}
343
Glenn Griffin3576fd72015-08-03 09:56:54 -0700344static void update_ip_l4_checksum(struct sk_buff *skb, struct iphdr *nh,
345 __be32 addr, __be32 new_addr)
Jesse Grossccb13522011-10-25 19:26:31 -0700346{
347 int transport_len = skb->len - skb_transport_offset(skb);
348
Glenn Griffin3576fd72015-08-03 09:56:54 -0700349 if (nh->frag_off & htons(IP_OFFSET))
350 return;
351
Jesse Grossccb13522011-10-25 19:26:31 -0700352 if (nh->protocol == IPPROTO_TCP) {
353 if (likely(transport_len >= sizeof(struct tcphdr)))
354 inet_proto_csum_replace4(&tcp_hdr(skb)->check, skb,
Tom Herbert4b048d62015-08-17 13:42:25 -0700355 addr, new_addr, true);
Jesse Grossccb13522011-10-25 19:26:31 -0700356 } else if (nh->protocol == IPPROTO_UDP) {
Jesse Gross81e5d412012-03-06 15:05:46 -0800357 if (likely(transport_len >= sizeof(struct udphdr))) {
358 struct udphdr *uh = udp_hdr(skb);
359
360 if (uh->check || skb->ip_summed == CHECKSUM_PARTIAL) {
361 inet_proto_csum_replace4(&uh->check, skb,
Tom Herbert4b048d62015-08-17 13:42:25 -0700362 addr, new_addr, true);
Jesse Gross81e5d412012-03-06 15:05:46 -0800363 if (!uh->check)
364 uh->check = CSUM_MANGLED_0;
365 }
366 }
Jesse Grossccb13522011-10-25 19:26:31 -0700367 }
Glenn Griffin3576fd72015-08-03 09:56:54 -0700368}
Jesse Grossccb13522011-10-25 19:26:31 -0700369
Glenn Griffin3576fd72015-08-03 09:56:54 -0700370static void set_ip_addr(struct sk_buff *skb, struct iphdr *nh,
371 __be32 *addr, __be32 new_addr)
372{
373 update_ip_l4_checksum(skb, nh, *addr, new_addr);
Jesse Grossccb13522011-10-25 19:26:31 -0700374 csum_replace4(&nh->check, *addr, new_addr);
Tom Herbert7539fad2013-12-15 22:12:18 -0800375 skb_clear_hash(skb);
Jesse Grossccb13522011-10-25 19:26:31 -0700376 *addr = new_addr;
377}
378
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800379static void update_ipv6_checksum(struct sk_buff *skb, u8 l4_proto,
380 __be32 addr[4], const __be32 new_addr[4])
381{
382 int transport_len = skb->len - skb_transport_offset(skb);
383
Jesse Gross856447d2014-11-11 14:32:20 -0800384 if (l4_proto == NEXTHDR_TCP) {
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800385 if (likely(transport_len >= sizeof(struct tcphdr)))
386 inet_proto_csum_replace16(&tcp_hdr(skb)->check, skb,
Tom Herbert4b048d62015-08-17 13:42:25 -0700387 addr, new_addr, true);
Jesse Gross856447d2014-11-11 14:32:20 -0800388 } else if (l4_proto == NEXTHDR_UDP) {
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800389 if (likely(transport_len >= sizeof(struct udphdr))) {
390 struct udphdr *uh = udp_hdr(skb);
391
392 if (uh->check || skb->ip_summed == CHECKSUM_PARTIAL) {
393 inet_proto_csum_replace16(&uh->check, skb,
Tom Herbert4b048d62015-08-17 13:42:25 -0700394 addr, new_addr, true);
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800395 if (!uh->check)
396 uh->check = CSUM_MANGLED_0;
397 }
398 }
Jesse Gross856447d2014-11-11 14:32:20 -0800399 } else if (l4_proto == NEXTHDR_ICMP) {
400 if (likely(transport_len >= sizeof(struct icmp6hdr)))
401 inet_proto_csum_replace16(&icmp6_hdr(skb)->icmp6_cksum,
Tom Herbert4b048d62015-08-17 13:42:25 -0700402 skb, addr, new_addr, true);
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800403 }
404}
405
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800406static void mask_ipv6_addr(const __be32 old[4], const __be32 addr[4],
407 const __be32 mask[4], __be32 masked[4])
408{
Joe Stringerbe26b9a2015-08-26 11:31:45 -0700409 masked[0] = OVS_MASKED(old[0], addr[0], mask[0]);
410 masked[1] = OVS_MASKED(old[1], addr[1], mask[1]);
411 masked[2] = OVS_MASKED(old[2], addr[2], mask[2]);
412 masked[3] = OVS_MASKED(old[3], addr[3], mask[3]);
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800413}
414
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800415static void set_ipv6_addr(struct sk_buff *skb, u8 l4_proto,
416 __be32 addr[4], const __be32 new_addr[4],
417 bool recalculate_csum)
418{
419 if (recalculate_csum)
420 update_ipv6_checksum(skb, l4_proto, addr, new_addr);
421
Tom Herbert7539fad2013-12-15 22:12:18 -0800422 skb_clear_hash(skb);
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800423 memcpy(addr, new_addr, sizeof(__be32[4]));
424}
425
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800426static void set_ipv6_fl(struct ipv6hdr *nh, u32 fl, u32 mask)
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800427{
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800428 /* Bits 21-24 are always unmasked, so this retains their values. */
Joe Stringerbe26b9a2015-08-26 11:31:45 -0700429 OVS_SET_MASKED(nh->flow_lbl[0], (u8)(fl >> 16), (u8)(mask >> 16));
430 OVS_SET_MASKED(nh->flow_lbl[1], (u8)(fl >> 8), (u8)(mask >> 8));
431 OVS_SET_MASKED(nh->flow_lbl[2], (u8)fl, (u8)mask);
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800432}
433
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800434static void set_ip_ttl(struct sk_buff *skb, struct iphdr *nh, u8 new_ttl,
435 u8 mask)
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800436{
Joe Stringerbe26b9a2015-08-26 11:31:45 -0700437 new_ttl = OVS_MASKED(nh->ttl, new_ttl, mask);
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800438
Jesse Grossccb13522011-10-25 19:26:31 -0700439 csum_replace2(&nh->check, htons(nh->ttl << 8), htons(new_ttl << 8));
440 nh->ttl = new_ttl;
441}
442
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800443static int set_ipv4(struct sk_buff *skb, struct sw_flow_key *flow_key,
444 const struct ovs_key_ipv4 *key,
445 const struct ovs_key_ipv4 *mask)
Jesse Grossccb13522011-10-25 19:26:31 -0700446{
447 struct iphdr *nh;
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800448 __be32 new_addr;
Jesse Grossccb13522011-10-25 19:26:31 -0700449 int err;
450
Jiri Pirkoe2195122014-11-19 14:05:01 +0100451 err = skb_ensure_writable(skb, skb_network_offset(skb) +
452 sizeof(struct iphdr));
Jesse Grossccb13522011-10-25 19:26:31 -0700453 if (unlikely(err))
454 return err;
455
456 nh = ip_hdr(skb);
457
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800458 /* Setting an IP addresses is typically only a side effect of
459 * matching on them in the current userspace implementation, so it
460 * makes sense to check if the value actually changed.
461 */
462 if (mask->ipv4_src) {
Joe Stringerbe26b9a2015-08-26 11:31:45 -0700463 new_addr = OVS_MASKED(nh->saddr, key->ipv4_src, mask->ipv4_src);
Jesse Grossccb13522011-10-25 19:26:31 -0700464
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800465 if (unlikely(new_addr != nh->saddr)) {
466 set_ip_addr(skb, nh, &nh->saddr, new_addr);
467 flow_key->ipv4.addr.src = new_addr;
468 }
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800469 }
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800470 if (mask->ipv4_dst) {
Joe Stringerbe26b9a2015-08-26 11:31:45 -0700471 new_addr = OVS_MASKED(nh->daddr, key->ipv4_dst, mask->ipv4_dst);
Jesse Grossccb13522011-10-25 19:26:31 -0700472
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800473 if (unlikely(new_addr != nh->daddr)) {
474 set_ip_addr(skb, nh, &nh->daddr, new_addr);
475 flow_key->ipv4.addr.dst = new_addr;
476 }
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800477 }
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800478 if (mask->ipv4_tos) {
479 ipv4_change_dsfield(nh, ~mask->ipv4_tos, key->ipv4_tos);
480 flow_key->ip.tos = nh->tos;
481 }
482 if (mask->ipv4_ttl) {
483 set_ip_ttl(skb, nh, key->ipv4_ttl, mask->ipv4_ttl);
484 flow_key->ip.ttl = nh->ttl;
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800485 }
Jesse Grossccb13522011-10-25 19:26:31 -0700486
487 return 0;
488}
489
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800490static bool is_ipv6_mask_nonzero(const __be32 addr[4])
491{
492 return !!(addr[0] | addr[1] | addr[2] | addr[3]);
493}
494
495static int set_ipv6(struct sk_buff *skb, struct sw_flow_key *flow_key,
496 const struct ovs_key_ipv6 *key,
497 const struct ovs_key_ipv6 *mask)
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800498{
499 struct ipv6hdr *nh;
500 int err;
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800501
Jiri Pirkoe2195122014-11-19 14:05:01 +0100502 err = skb_ensure_writable(skb, skb_network_offset(skb) +
503 sizeof(struct ipv6hdr));
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800504 if (unlikely(err))
505 return err;
506
507 nh = ipv6_hdr(skb);
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800508
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800509 /* Setting an IP addresses is typically only a side effect of
510 * matching on them in the current userspace implementation, so it
511 * makes sense to check if the value actually changed.
512 */
513 if (is_ipv6_mask_nonzero(mask->ipv6_src)) {
514 __be32 *saddr = (__be32 *)&nh->saddr;
515 __be32 masked[4];
516
517 mask_ipv6_addr(saddr, key->ipv6_src, mask->ipv6_src, masked);
518
519 if (unlikely(memcmp(saddr, masked, sizeof(masked)))) {
Simon Hormanb4f70522016-04-21 11:49:15 +1000520 set_ipv6_addr(skb, flow_key->ip.proto, saddr, masked,
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800521 true);
522 memcpy(&flow_key->ipv6.addr.src, masked,
523 sizeof(flow_key->ipv6.addr.src));
524 }
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800525 }
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800526 if (is_ipv6_mask_nonzero(mask->ipv6_dst)) {
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800527 unsigned int offset = 0;
528 int flags = IP6_FH_F_SKIP_RH;
529 bool recalc_csum = true;
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800530 __be32 *daddr = (__be32 *)&nh->daddr;
531 __be32 masked[4];
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800532
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800533 mask_ipv6_addr(daddr, key->ipv6_dst, mask->ipv6_dst, masked);
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800534
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800535 if (unlikely(memcmp(daddr, masked, sizeof(masked)))) {
536 if (ipv6_ext_hdr(nh->nexthdr))
537 recalc_csum = (ipv6_find_hdr(skb, &offset,
538 NEXTHDR_ROUTING,
539 NULL, &flags)
540 != NEXTHDR_ROUTING);
541
Simon Hormanb4f70522016-04-21 11:49:15 +1000542 set_ipv6_addr(skb, flow_key->ip.proto, daddr, masked,
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800543 recalc_csum);
544 memcpy(&flow_key->ipv6.addr.dst, masked,
545 sizeof(flow_key->ipv6.addr.dst));
546 }
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800547 }
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800548 if (mask->ipv6_tclass) {
549 ipv6_change_dsfield(nh, ~mask->ipv6_tclass, key->ipv6_tclass);
550 flow_key->ip.tos = ipv6_get_dsfield(nh);
551 }
552 if (mask->ipv6_label) {
553 set_ipv6_fl(nh, ntohl(key->ipv6_label),
554 ntohl(mask->ipv6_label));
555 flow_key->ipv6.label =
556 *(__be32 *)nh & htonl(IPV6_FLOWINFO_FLOWLABEL);
557 }
558 if (mask->ipv6_hlimit) {
Joe Stringerbe26b9a2015-08-26 11:31:45 -0700559 OVS_SET_MASKED(nh->hop_limit, key->ipv6_hlimit,
560 mask->ipv6_hlimit);
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800561 flow_key->ip.ttl = nh->hop_limit;
562 }
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -0800563 return 0;
564}
565
Yi Yangb2d0f5d2017-11-07 21:07:02 +0800566static int set_nsh(struct sk_buff *skb, struct sw_flow_key *flow_key,
567 const struct nlattr *a)
568{
569 struct nshhdr *nh;
570 size_t length;
571 int err;
572 u8 flags;
573 u8 ttl;
574 int i;
575
576 struct ovs_key_nsh key;
577 struct ovs_key_nsh mask;
578
579 err = nsh_key_from_nlattr(a, &key, &mask);
580 if (err)
581 return err;
582
583 /* Make sure the NSH base header is there */
584 if (!pskb_may_pull(skb, skb_network_offset(skb) + NSH_BASE_HDR_LEN))
585 return -ENOMEM;
586
587 nh = nsh_hdr(skb);
588 length = nsh_hdr_len(nh);
589
590 /* Make sure the whole NSH header is there */
591 err = skb_ensure_writable(skb, skb_network_offset(skb) +
592 length);
593 if (unlikely(err))
594 return err;
595
596 nh = nsh_hdr(skb);
597 skb_postpull_rcsum(skb, nh, length);
598 flags = nsh_get_flags(nh);
599 flags = OVS_MASKED(flags, key.base.flags, mask.base.flags);
600 flow_key->nsh.base.flags = flags;
601 ttl = nsh_get_ttl(nh);
602 ttl = OVS_MASKED(ttl, key.base.ttl, mask.base.ttl);
603 flow_key->nsh.base.ttl = ttl;
604 nsh_set_flags_and_ttl(nh, flags, ttl);
605 nh->path_hdr = OVS_MASKED(nh->path_hdr, key.base.path_hdr,
606 mask.base.path_hdr);
607 flow_key->nsh.base.path_hdr = nh->path_hdr;
608 switch (nh->mdtype) {
609 case NSH_M_TYPE1:
610 for (i = 0; i < NSH_MD1_CONTEXT_SIZE; i++) {
611 nh->md1.context[i] =
612 OVS_MASKED(nh->md1.context[i], key.context[i],
613 mask.context[i]);
614 }
615 memcpy(flow_key->nsh.context, nh->md1.context,
616 sizeof(nh->md1.context));
617 break;
618 case NSH_M_TYPE2:
619 memset(flow_key->nsh.context, 0,
620 sizeof(flow_key->nsh.context));
621 break;
622 default:
623 return -EINVAL;
624 }
625 skb_postpush_rcsum(skb, nh, length);
626 return 0;
627}
628
Jiri Pirkoe2195122014-11-19 14:05:01 +0100629/* Must follow skb_ensure_writable() since that can move the skb data. */
Jesse Grossccb13522011-10-25 19:26:31 -0700630static void set_tp_port(struct sk_buff *skb, __be16 *port,
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800631 __be16 new_port, __sum16 *check)
Jesse Grossccb13522011-10-25 19:26:31 -0700632{
Tom Herbert4b048d62015-08-17 13:42:25 -0700633 inet_proto_csum_replace2(check, skb, *port, new_port, false);
Jesse Grossccb13522011-10-25 19:26:31 -0700634 *port = new_port;
Jesse Grossccb13522011-10-25 19:26:31 -0700635}
636
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800637static int set_udp(struct sk_buff *skb, struct sw_flow_key *flow_key,
638 const struct ovs_key_udp *key,
639 const struct ovs_key_udp *mask)
Jesse Grossccb13522011-10-25 19:26:31 -0700640{
641 struct udphdr *uh;
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800642 __be16 src, dst;
Jesse Grossccb13522011-10-25 19:26:31 -0700643 int err;
644
Jiri Pirkoe2195122014-11-19 14:05:01 +0100645 err = skb_ensure_writable(skb, skb_transport_offset(skb) +
646 sizeof(struct udphdr));
Jesse Grossccb13522011-10-25 19:26:31 -0700647 if (unlikely(err))
648 return err;
649
650 uh = udp_hdr(skb);
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800651 /* Either of the masks is non-zero, so do not bother checking them. */
Joe Stringerbe26b9a2015-08-26 11:31:45 -0700652 src = OVS_MASKED(uh->source, key->udp_src, mask->udp_src);
653 dst = OVS_MASKED(uh->dest, key->udp_dst, mask->udp_dst);
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800654
655 if (uh->check && skb->ip_summed != CHECKSUM_PARTIAL) {
656 if (likely(src != uh->source)) {
657 set_tp_port(skb, &uh->source, src, &uh->check);
658 flow_key->tp.src = src;
659 }
660 if (likely(dst != uh->dest)) {
661 set_tp_port(skb, &uh->dest, dst, &uh->check);
662 flow_key->tp.dst = dst;
663 }
664
665 if (unlikely(!uh->check))
666 uh->check = CSUM_MANGLED_0;
667 } else {
668 uh->source = src;
669 uh->dest = dst;
670 flow_key->tp.src = src;
671 flow_key->tp.dst = dst;
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800672 }
Jesse Grossccb13522011-10-25 19:26:31 -0700673
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800674 skb_clear_hash(skb);
Jesse Grossccb13522011-10-25 19:26:31 -0700675
676 return 0;
677}
678
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800679static int set_tcp(struct sk_buff *skb, struct sw_flow_key *flow_key,
680 const struct ovs_key_tcp *key,
681 const struct ovs_key_tcp *mask)
Jesse Grossccb13522011-10-25 19:26:31 -0700682{
683 struct tcphdr *th;
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800684 __be16 src, dst;
Jesse Grossccb13522011-10-25 19:26:31 -0700685 int err;
686
Jiri Pirkoe2195122014-11-19 14:05:01 +0100687 err = skb_ensure_writable(skb, skb_transport_offset(skb) +
688 sizeof(struct tcphdr));
Jesse Grossccb13522011-10-25 19:26:31 -0700689 if (unlikely(err))
690 return err;
691
692 th = tcp_hdr(skb);
Joe Stringerbe26b9a2015-08-26 11:31:45 -0700693 src = OVS_MASKED(th->source, key->tcp_src, mask->tcp_src);
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800694 if (likely(src != th->source)) {
695 set_tp_port(skb, &th->source, src, &th->check);
696 flow_key->tp.src = src;
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800697 }
Joe Stringerbe26b9a2015-08-26 11:31:45 -0700698 dst = OVS_MASKED(th->dest, key->tcp_dst, mask->tcp_dst);
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800699 if (likely(dst != th->dest)) {
700 set_tp_port(skb, &th->dest, dst, &th->check);
701 flow_key->tp.dst = dst;
Pravin B Shelarfff06c32014-11-06 06:55:14 -0800702 }
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800703 skb_clear_hash(skb);
Jesse Grossccb13522011-10-25 19:26:31 -0700704
705 return 0;
706}
707
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800708static int set_sctp(struct sk_buff *skb, struct sw_flow_key *flow_key,
709 const struct ovs_key_sctp *key,
710 const struct ovs_key_sctp *mask)
Joe Stringera175a722013-08-22 12:30:48 -0700711{
Joe Stringera175a722013-08-22 12:30:48 -0700712 unsigned int sctphoff = skb_transport_offset(skb);
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800713 struct sctphdr *sh;
714 __le32 old_correct_csum, new_csum, old_csum;
715 int err;
Joe Stringera175a722013-08-22 12:30:48 -0700716
Jiri Pirkoe2195122014-11-19 14:05:01 +0100717 err = skb_ensure_writable(skb, sctphoff + sizeof(struct sctphdr));
Joe Stringera175a722013-08-22 12:30:48 -0700718 if (unlikely(err))
719 return err;
720
721 sh = sctp_hdr(skb);
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800722 old_csum = sh->checksum;
723 old_correct_csum = sctp_compute_cksum(skb, sctphoff);
Joe Stringera175a722013-08-22 12:30:48 -0700724
Joe Stringerbe26b9a2015-08-26 11:31:45 -0700725 sh->source = OVS_MASKED(sh->source, key->sctp_src, mask->sctp_src);
726 sh->dest = OVS_MASKED(sh->dest, key->sctp_dst, mask->sctp_dst);
Joe Stringera175a722013-08-22 12:30:48 -0700727
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800728 new_csum = sctp_compute_cksum(skb, sctphoff);
Joe Stringera175a722013-08-22 12:30:48 -0700729
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800730 /* Carry any checksum errors through. */
731 sh->checksum = old_csum ^ old_correct_csum ^ new_csum;
Joe Stringera175a722013-08-22 12:30:48 -0700732
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -0800733 skb_clear_hash(skb);
734 flow_key->tp.src = sh->source;
735 flow_key->tp.dst = sh->dest;
Joe Stringera175a722013-08-22 12:30:48 -0700736
737 return 0;
738}
739
Tonghao Zhangcf3266a2020-09-01 20:26:12 +0800740static int ovs_vport_output(struct net *net, struct sock *sk,
741 struct sk_buff *skb)
Joe Stringer7f8a4362015-08-26 11:31:48 -0700742{
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;
Michał Mirosław9df46ae2018-11-08 18:44:50 +0100754 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);
Joe Stringer7f8a4362015-08-26 11:31:48 -0700758
759 /* Reconstruct the MAC header. */
760 skb_push(skb, data->l2_len);
761 memcpy(skb->data, &data->l2_data, data->l2_len);
Daniel Borkmann6b83d282016-02-20 00:29:30 +0100762 skb_postpush_rcsum(skb, skb->data, data->l2_len);
Joe Stringer7f8a4362015-08-26 11:31:48 -0700763 skb_reset_mac_header(skb);
764
Jiri Bencc66549f2016-10-05 15:01:57 +0200765 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
Jiri Bence2d9d832016-11-10 16:28:19 +0100771 ovs_vport_send(vport, skb, data->mac_proto);
Joe Stringer7f8a4362015-08-26 11:31:48 -0700772 return 0;
773}
774
775static unsigned int
776ovs_dst_get_mtu(const struct dst_entry *dst)
777{
778 return dst->dev->mtu;
779}
780
781static struct dst_ops ovs_dst_ops = {
782 .family = AF_UNSPEC,
783 .mtu = ovs_dst_get_mtu,
784};
785
786/* prepare_frag() is called once per (larger-than-MTU) frame; its inverse is
787 * ovs_vport_output(), which is called once per fragmented packet.
788 */
Jiri Bencc66549f2016-10-05 15:01:57 +0200789static void prepare_frag(struct vport *vport, struct sk_buff *skb,
Jiri Bence2d9d832016-11-10 16:28:19 +0100790 u16 orig_network_offset, u8 mac_proto)
Joe Stringer7f8a4362015-08-26 11:31:48 -0700791{
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;
Jiri Bencc66549f2016-10-05 15:01:57 +0200800 data->network_offset = orig_network_offset;
Michał Mirosław9df46ae2018-11-08 18:44:50 +0100801 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;
Joe Stringer7f8a4362015-08-26 11:31:48 -0700805 data->vlan_proto = skb->vlan_proto;
Jiri Bence2d9d832016-11-10 16:28:19 +0100806 data->mac_proto = mac_proto;
Joe Stringer7f8a4362015-08-26 11:31:48 -0700807 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
Eric W. Biedermanc559cd32015-09-14 20:10:28 -0500814static void ovs_fragment(struct net *net, struct vport *vport,
Jiri Bence2d9d832016-11-10 16:28:19 +0100815 struct sk_buff *skb, u16 mru,
816 struct sw_flow_key *key)
Joe Stringer7f8a4362015-08-26 11:31:48 -0700817{
Jiri Bencc66549f2016-10-05 15:01:57 +0200818 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
Joe Stringer7f8a4362015-08-26 11:31:48 -0700825 if (skb_network_offset(skb) > MAX_L2_LEN) {
826 OVS_NLERR(1, "L2 header too long to fragment");
Joe Stringerb8f22572015-10-06 10:59:57 -0700827 goto err;
Joe Stringer7f8a4362015-08-26 11:31:48 -0700828 }
829
Jiri Bence2d9d832016-11-10 16:28:19 +0100830 if (key->eth.type == htons(ETH_P_IP)) {
Davide Caratti7c0ea592021-04-28 15:23:07 +0200831 struct rtable ovs_rt = { 0 };
Joe Stringer7f8a4362015-08-26 11:31:48 -0700832 unsigned long orig_dst;
833
Jiri Bence2d9d832016-11-10 16:28:19 +0100834 prepare_frag(vport, skb, orig_network_offset,
835 ovs_key_mac_proto(key));
Davide Caratti7c0ea592021-04-28 15:23:07 +0200836 dst_init(&ovs_rt.dst, &ovs_dst_ops, NULL, 1,
Joe Stringer7f8a4362015-08-26 11:31:48 -0700837 DST_OBSOLETE_NONE, DST_NOCOUNT);
Davide Caratti7c0ea592021-04-28 15:23:07 +0200838 ovs_rt.dst.dev = vport->dev;
Joe Stringer7f8a4362015-08-26 11:31:48 -0700839
840 orig_dst = skb->_skb_refdst;
Davide Caratti7c0ea592021-04-28 15:23:07 +0200841 skb_dst_set_noref(skb, &ovs_rt.dst);
Joe Stringer7f8a4362015-08-26 11:31:48 -0700842 IPCB(skb)->frag_max_size = mru;
843
Eric W. Biederman694869b2015-06-12 21:55:31 -0500844 ip_do_fragment(net, skb->sk, skb, ovs_vport_output);
Joe Stringer7f8a4362015-08-26 11:31:48 -0700845 refdst_drop(orig_dst);
Jiri Bence2d9d832016-11-10 16:28:19 +0100846 } else if (key->eth.type == htons(ETH_P_IPV6)) {
Joe Stringer7f8a4362015-08-26 11:31:48 -0700847 unsigned long orig_dst;
848 struct rt6_info ovs_rt;
849
Jiri Bence2d9d832016-11-10 16:28:19 +0100850 prepare_frag(vport, skb, orig_network_offset,
851 ovs_key_mac_proto(key));
Joe Stringer7f8a4362015-08-26 11:31:48 -0700852 memset(&ovs_rt, 0, sizeof(ovs_rt));
853 dst_init(&ovs_rt.dst, &ovs_dst_ops, NULL, 1,
854 DST_OBSOLETE_NONE, DST_NOCOUNT);
855 ovs_rt.dst.dev = vport->dev;
856
857 orig_dst = skb->_skb_refdst;
858 skb_dst_set_noref(skb, &ovs_rt.dst);
859 IP6CB(skb)->frag_max_size = mru;
860
wenxua7c978c2020-08-28 23:14:32 +0800861 ipv6_stub->ipv6_fragment(net, skb->sk, skb, ovs_vport_output);
Joe Stringer7f8a4362015-08-26 11:31:48 -0700862 refdst_drop(orig_dst);
863 } else {
864 WARN_ONCE(1, "Failed fragment ->%s: eth=%04x, MRU=%d, MTU=%d.",
Jiri Bence2d9d832016-11-10 16:28:19 +0100865 ovs_vport_name(vport), ntohs(key->eth.type), mru,
Joe Stringer7f8a4362015-08-26 11:31:48 -0700866 vport->dev->mtu);
Joe Stringerb8f22572015-10-06 10:59:57 -0700867 goto err;
Joe Stringer7f8a4362015-08-26 11:31:48 -0700868 }
Joe Stringerb8f22572015-10-06 10:59:57 -0700869
870 return;
871err:
872 kfree_skb(skb);
Joe Stringer7f8a4362015-08-26 11:31:48 -0700873}
874
875static void do_output(struct datapath *dp, struct sk_buff *skb, int out_port,
876 struct sw_flow_key *key)
Jesse Grossccb13522011-10-25 19:26:31 -0700877{
Andy Zhou738967b2014-09-08 00:35:02 -0700878 struct vport *vport = ovs_vport_rcu(dp, out_port);
Jesse Grossccb13522011-10-25 19:26:31 -0700879
Joe Stringer7f8a4362015-08-26 11:31:48 -0700880 if (likely(vport)) {
881 u16 mru = OVS_CB(skb)->mru;
William Tuf2a4d082016-06-10 11:49:33 -0700882 u32 cutlen = OVS_CB(skb)->cutlen;
883
884 if (unlikely(cutlen > 0)) {
Jiri Bence2d9d832016-11-10 16:28:19 +0100885 if (skb->len - cutlen > ovs_mac_header_len(key))
William Tuf2a4d082016-06-10 11:49:33 -0700886 pskb_trim(skb, skb->len - cutlen);
887 else
Jiri Bence2d9d832016-11-10 16:28:19 +0100888 pskb_trim(skb, ovs_mac_header_len(key));
William Tuf2a4d082016-06-10 11:49:33 -0700889 }
Joe Stringer7f8a4362015-08-26 11:31:48 -0700890
Jiri Benc738314a2016-11-10 16:28:17 +0100891 if (likely(!mru ||
892 (skb->len <= mru + vport->dev->hard_header_len))) {
Jiri Bence2d9d832016-11-10 16:28:19 +0100893 ovs_vport_send(vport, skb, ovs_key_mac_proto(key));
Joe Stringer7f8a4362015-08-26 11:31:48 -0700894 } else if (mru <= vport->dev->mtu) {
Eric W. Biedermanc559cd32015-09-14 20:10:28 -0500895 struct net *net = read_pnet(&dp->net);
Joe Stringer7f8a4362015-08-26 11:31:48 -0700896
Jiri Bence2d9d832016-11-10 16:28:19 +0100897 ovs_fragment(net, vport, skb, mru, key);
Joe Stringer7f8a4362015-08-26 11:31:48 -0700898 } else {
899 kfree_skb(skb);
900 }
901 } else {
Jesse Grossccb13522011-10-25 19:26:31 -0700902 kfree_skb(skb);
Joe Stringer7f8a4362015-08-26 11:31:48 -0700903 }
Jesse Grossccb13522011-10-25 19:26:31 -0700904}
905
906static int output_userspace(struct datapath *dp, struct sk_buff *skb,
Neil McKeeccea7442015-05-26 20:59:43 -0700907 struct sw_flow_key *key, const struct nlattr *attr,
William Tuf2a4d082016-06-10 11:49:33 -0700908 const struct nlattr *actions, int actions_len,
909 uint32_t cutlen)
Jesse Grossccb13522011-10-25 19:26:31 -0700910{
911 struct dp_upcall_info upcall;
912 const struct nlattr *a;
913 int rem;
914
Neil McKeeccea7442015-05-26 20:59:43 -0700915 memset(&upcall, 0, sizeof(upcall));
Jesse Grossccb13522011-10-25 19:26:31 -0700916 upcall.cmd = OVS_PACKET_CMD_ACTION;
Joe Stringer7f8a4362015-08-26 11:31:48 -0700917 upcall.mru = OVS_CB(skb)->mru;
Jesse Grossccb13522011-10-25 19:26:31 -0700918
919 for (a = nla_data(attr), rem = nla_len(attr); rem > 0;
Tonghao Zhangcf3266a2020-09-01 20:26:12 +0800920 a = nla_next(a, &rem)) {
Jesse Grossccb13522011-10-25 19:26:31 -0700921 switch (nla_type(a)) {
922 case OVS_USERSPACE_ATTR_USERDATA:
923 upcall.userdata = a;
924 break;
925
926 case OVS_USERSPACE_ATTR_PID:
Mark Gray784dcfa2021-07-23 10:24:13 -0400927 if (dp->user_features &
928 OVS_DP_F_DISPATCH_UPCALL_PER_CPU)
Mark Grayb83d23a2021-07-15 08:27:54 -0400929 upcall.portid =
Mark Gray784dcfa2021-07-23 10:24:13 -0400930 ovs_dp_get_upcall_portid(dp,
931 smp_processor_id());
Mark Grayb83d23a2021-07-15 08:27:54 -0400932 else
933 upcall.portid = nla_get_u32(a);
Jesse Grossccb13522011-10-25 19:26:31 -0700934 break;
Wenyu Zhang8f0aad62014-11-06 06:51:24 -0800935
936 case OVS_USERSPACE_ATTR_EGRESS_TUN_PORT: {
937 /* Get out tunnel info. */
938 struct vport *vport;
939
940 vport = ovs_vport_rcu(dp, nla_get_u32(a));
941 if (vport) {
942 int err;
943
Pravin B Shelarfc4099f2015-10-22 18:17:16 -0700944 err = dev_fill_metadata_dst(vport->dev, skb);
945 if (!err)
946 upcall.egress_tun_info = skb_tunnel_info(skb);
Wenyu Zhang8f0aad62014-11-06 06:51:24 -0800947 }
Pravin B Shelar4c222792015-08-30 18:09:38 -0700948
Wenyu Zhang8f0aad62014-11-06 06:51:24 -0800949 break;
Jesse Grossccb13522011-10-25 19:26:31 -0700950 }
Wenyu Zhang8f0aad62014-11-06 06:51:24 -0800951
Neil McKeeccea7442015-05-26 20:59:43 -0700952 case OVS_USERSPACE_ATTR_ACTIONS: {
953 /* Include actions. */
954 upcall.actions = actions;
955 upcall.actions_len = actions_len;
956 break;
957 }
958
Wenyu Zhang8f0aad62014-11-06 06:51:24 -0800959 } /* End of switch. */
Jesse Grossccb13522011-10-25 19:26:31 -0700960 }
961
William Tuf2a4d082016-06-10 11:49:33 -0700962 return ovs_dp_upcall(dp, skb, key, &upcall, cutlen);
Jesse Grossccb13522011-10-25 19:26:31 -0700963}
964
Matteo Croce744676e2020-02-15 14:20:56 +0100965static int dec_ttl_exception_handler(struct datapath *dp, struct sk_buff *skb,
966 struct sw_flow_key *key,
Eelco Chaudrona5317f32021-01-13 14:50:00 +0100967 const struct nlattr *attr)
Matteo Croce744676e2020-02-15 14:20:56 +0100968{
Eelco Chaudron09d62172020-12-07 05:08:39 -0500969 /* The first attribute is always 'OVS_DEC_TTL_ATTR_ACTION'. */
970 struct nlattr *actions = nla_data(attr);
Matteo Croce744676e2020-02-15 14:20:56 +0100971
Eelco Chaudron09d62172020-12-07 05:08:39 -0500972 if (nla_len(actions))
973 return clone_execute(dp, skb, key, 0, nla_data(actions),
Eelco Chaudrona5317f32021-01-13 14:50:00 +0100974 nla_len(actions), true, false);
Matteo Croce744676e2020-02-15 14:20:56 +0100975
Matteo Croce744676e2020-02-15 14:20:56 +0100976 consume_skb(skb);
977 return 0;
978}
979
andy zhou798c1662017-03-20 16:32:29 -0700980/* When 'last' is true, sample() should always consume the 'skb'.
981 * Otherwise, sample() should keep 'skb' intact regardless what
982 * actions are executed within sample().
983 */
Jesse Grossccb13522011-10-25 19:26:31 -0700984static int sample(struct datapath *dp, struct sk_buff *skb,
Neil McKeeccea7442015-05-26 20:59:43 -0700985 struct sw_flow_key *key, const struct nlattr *attr,
andy zhou798c1662017-03-20 16:32:29 -0700986 bool last)
Jesse Grossccb13522011-10-25 19:26:31 -0700987{
andy zhou798c1662017-03-20 16:32:29 -0700988 struct nlattr *actions;
989 struct nlattr *sample_arg;
andy zhou798c1662017-03-20 16:32:29 -0700990 int rem = nla_len(attr);
andy zhou798c1662017-03-20 16:32:29 -0700991 const struct sample_arg *arg;
andy zhoubef7f752017-03-20 16:32:30 -0700992 bool clone_flow_key;
Jesse Grossccb13522011-10-25 19:26:31 -0700993
andy zhou798c1662017-03-20 16:32:29 -0700994 /* The first action is always 'OVS_SAMPLE_ATTR_ARG'. */
995 sample_arg = nla_data(attr);
996 arg = nla_data(sample_arg);
997 actions = nla_next(sample_arg, &rem);
Wenyu Zhange05176a2015-08-05 00:30:47 -0700998
andy zhou798c1662017-03-20 16:32:29 -0700999 if ((arg->probability != U32_MAX) &&
1000 (!arg->probability || prandom_u32() > arg->probability)) {
1001 if (last)
1002 consume_skb(skb);
1003 return 0;
Jesse Grossccb13522011-10-25 19:26:31 -07001004 }
1005
andy zhoubef7f752017-03-20 16:32:30 -07001006 clone_flow_key = !arg->exec;
1007 return clone_execute(dp, skb, key, 0, actions, rem, last,
1008 clone_flow_key);
Andy Zhou971427f32014-09-15 19:37:25 -07001009}
1010
Yifeng Sunb2335042018-07-02 08:18:03 -07001011/* When 'last' is true, clone() should always consume the 'skb'.
1012 * Otherwise, clone() should keep 'skb' intact regardless what
1013 * actions are executed within clone().
1014 */
1015static int clone(struct datapath *dp, struct sk_buff *skb,
1016 struct sw_flow_key *key, const struct nlattr *attr,
1017 bool last)
1018{
1019 struct nlattr *actions;
1020 struct nlattr *clone_arg;
1021 int rem = nla_len(attr);
1022 bool dont_clone_flow_key;
1023
1024 /* The first action is always 'OVS_CLONE_ATTR_ARG'. */
1025 clone_arg = nla_data(attr);
1026 dont_clone_flow_key = nla_get_u32(clone_arg);
1027 actions = nla_next(clone_arg, &rem);
1028
1029 return clone_execute(dp, skb, key, 0, actions, rem, last,
1030 !dont_clone_flow_key);
1031}
1032
Andy Zhou971427f32014-09-15 19:37:25 -07001033static void execute_hash(struct sk_buff *skb, struct sw_flow_key *key,
1034 const struct nlattr *attr)
1035{
1036 struct ovs_action_hash *hash_act = nla_data(attr);
1037 u32 hash = 0;
1038
1039 /* OVS_HASH_ALG_L4 is the only possible hash algorithm. */
1040 hash = skb_get_hash(skb);
1041 hash = jhash_1word(hash, hash_act->hash_basis);
1042 if (!hash)
1043 hash = 0x1;
1044
1045 key->ovs_flow_hash = hash;
Jesse Grossccb13522011-10-25 19:26:31 -07001046}
1047
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -08001048static int execute_set_action(struct sk_buff *skb,
1049 struct sw_flow_key *flow_key,
1050 const struct nlattr *a)
1051{
1052 /* Only tunnel set execution is supported without a mask. */
1053 if (nla_type(a) == OVS_KEY_ATTR_TUNNEL_INFO) {
Thomas Graf34ae9322015-07-21 10:44:03 +02001054 struct ovs_tunnel_info *tun = nla_data(a);
1055
1056 skb_dst_drop(skb);
1057 dst_hold((struct dst_entry *)tun->tun_dst);
1058 skb_dst_set(skb, (struct dst_entry *)tun->tun_dst);
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -08001059 return 0;
1060 }
1061
1062 return -EINVAL;
1063}
1064
1065/* Mask is at the midpoint of the data. */
1066#define get_mask(a, type) ((const type)nla_data(a) + 1)
1067
1068static int execute_masked_set_action(struct sk_buff *skb,
1069 struct sw_flow_key *flow_key,
1070 const struct nlattr *a)
Jesse Grossccb13522011-10-25 19:26:31 -07001071{
1072 int err = 0;
1073
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -08001074 switch (nla_type(a)) {
Jesse Grossccb13522011-10-25 19:26:31 -07001075 case OVS_KEY_ATTR_PRIORITY:
Joe Stringerbe26b9a2015-08-26 11:31:45 -07001076 OVS_SET_MASKED(skb->priority, nla_get_u32(a),
1077 *get_mask(a, u32 *));
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -08001078 flow_key->phy.priority = skb->priority;
Jesse Grossccb13522011-10-25 19:26:31 -07001079 break;
1080
Ansis Atteka39c7caeb2012-11-26 11:24:11 -08001081 case OVS_KEY_ATTR_SKB_MARK:
Joe Stringerbe26b9a2015-08-26 11:31:45 -07001082 OVS_SET_MASKED(skb->mark, nla_get_u32(a), *get_mask(a, u32 *));
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -08001083 flow_key->phy.skb_mark = skb->mark;
Ansis Atteka39c7caeb2012-11-26 11:24:11 -08001084 break;
1085
Jesse Grossf0b128c2014-10-03 15:35:31 -07001086 case OVS_KEY_ATTR_TUNNEL_INFO:
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -08001087 /* Masked data not supported for tunnel. */
1088 err = -EINVAL;
Pravin B Shelar7d5437c2013-06-17 17:50:18 -07001089 break;
1090
Jesse Grossccb13522011-10-25 19:26:31 -07001091 case OVS_KEY_ATTR_ETHERNET:
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -08001092 err = set_eth_addr(skb, flow_key, nla_data(a),
1093 get_mask(a, struct ovs_key_ethernet *));
Jesse Grossccb13522011-10-25 19:26:31 -07001094 break;
1095
Yi Yangb2d0f5d2017-11-07 21:07:02 +08001096 case OVS_KEY_ATTR_NSH:
1097 err = set_nsh(skb, flow_key, a);
1098 break;
1099
Jesse Grossccb13522011-10-25 19:26:31 -07001100 case OVS_KEY_ATTR_IPV4:
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -08001101 err = set_ipv4(skb, flow_key, nla_data(a),
1102 get_mask(a, struct ovs_key_ipv4 *));
Jesse Grossccb13522011-10-25 19:26:31 -07001103 break;
1104
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -08001105 case OVS_KEY_ATTR_IPV6:
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -08001106 err = set_ipv6(skb, flow_key, nla_data(a),
1107 get_mask(a, struct ovs_key_ipv6 *));
Ansis Atteka3fdbd1c2012-11-13 15:44:14 -08001108 break;
1109
Jesse Grossccb13522011-10-25 19:26:31 -07001110 case OVS_KEY_ATTR_TCP:
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -08001111 err = set_tcp(skb, flow_key, nla_data(a),
1112 get_mask(a, struct ovs_key_tcp *));
Jesse Grossccb13522011-10-25 19:26:31 -07001113 break;
1114
1115 case OVS_KEY_ATTR_UDP:
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -08001116 err = set_udp(skb, flow_key, nla_data(a),
1117 get_mask(a, struct ovs_key_udp *));
Jesse Grossccb13522011-10-25 19:26:31 -07001118 break;
Joe Stringera175a722013-08-22 12:30:48 -07001119
1120 case OVS_KEY_ATTR_SCTP:
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -08001121 err = set_sctp(skb, flow_key, nla_data(a),
1122 get_mask(a, struct ovs_key_sctp *));
Joe Stringera175a722013-08-22 12:30:48 -07001123 break;
Simon Horman25cd9ba2014-10-06 05:05:13 -07001124
1125 case OVS_KEY_ATTR_MPLS:
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -08001126 err = set_mpls(skb, flow_key, nla_data(a), get_mask(a,
1127 __be32 *));
Simon Horman25cd9ba2014-10-06 05:05:13 -07001128 break;
Joe Stringer7f8a4362015-08-26 11:31:48 -07001129
1130 case OVS_KEY_ATTR_CT_STATE:
1131 case OVS_KEY_ATTR_CT_ZONE:
Joe Stringer182e3042015-08-26 11:31:49 -07001132 case OVS_KEY_ATTR_CT_MARK:
Joe Stringer33db4122015-10-01 15:00:37 -07001133 case OVS_KEY_ATTR_CT_LABELS:
Jarno Rajahalme9dd7f892017-02-09 11:21:59 -08001134 case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4:
1135 case OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6:
Joe Stringer7f8a4362015-08-26 11:31:48 -07001136 err = -EINVAL;
1137 break;
Jesse Grossccb13522011-10-25 19:26:31 -07001138 }
1139
1140 return err;
1141}
1142
Andy Zhou971427f32014-09-15 19:37:25 -07001143static int execute_recirc(struct datapath *dp, struct sk_buff *skb,
1144 struct sw_flow_key *key,
andy zhoubef7f752017-03-20 16:32:30 -07001145 const struct nlattr *a, bool last)
Andy Zhou971427f32014-09-15 19:37:25 -07001146{
andy zhoubef7f752017-03-20 16:32:30 -07001147 u32 recirc_id;
Andy Zhou971427f32014-09-15 19:37:25 -07001148
Pravin B Shelarfff06c32014-11-06 06:55:14 -08001149 if (!is_flow_key_valid(key)) {
1150 int err;
1151
1152 err = ovs_flow_key_update(skb, key);
1153 if (err)
1154 return err;
1155 }
1156 BUG_ON(!is_flow_key_valid(key));
Andy Zhou971427f32014-09-15 19:37:25 -07001157
andy zhoubef7f752017-03-20 16:32:30 -07001158 recirc_id = nla_get_u32(a);
1159 return clone_execute(dp, skb, key, recirc_id, NULL, 0, last, true);
Andy Zhou971427f32014-09-15 19:37:25 -07001160}
1161
Numan Siddique4d5ec892019-03-26 06:13:46 +05301162static int execute_check_pkt_len(struct datapath *dp, struct sk_buff *skb,
1163 struct sw_flow_key *key,
1164 const struct nlattr *attr, bool last)
1165{
Lorenzo Bianconi17843652020-06-23 18:33:15 +02001166 struct ovs_skb_cb *ovs_cb = OVS_CB(skb);
Numan Siddique4d5ec892019-03-26 06:13:46 +05301167 const struct nlattr *actions, *cpl_arg;
Lorenzo Bianconi17843652020-06-23 18:33:15 +02001168 int len, max_len, rem = nla_len(attr);
Numan Siddique4d5ec892019-03-26 06:13:46 +05301169 const struct check_pkt_len_arg *arg;
Numan Siddique4d5ec892019-03-26 06:13:46 +05301170 bool clone_flow_key;
1171
1172 /* The first netlink attribute in 'attr' is always
1173 * 'OVS_CHECK_PKT_LEN_ATTR_ARG'.
1174 */
1175 cpl_arg = nla_data(attr);
1176 arg = nla_data(cpl_arg);
1177
Lorenzo Bianconi17843652020-06-23 18:33:15 +02001178 len = ovs_cb->mru ? ovs_cb->mru + skb->mac_len : skb->len;
1179 max_len = arg->pkt_len;
1180
1181 if ((skb_is_gso(skb) && skb_gso_validate_mac_len(skb, max_len)) ||
1182 len <= max_len) {
Numan Siddique4d5ec892019-03-26 06:13:46 +05301183 /* Second netlink attribute in 'attr' is always
1184 * 'OVS_CHECK_PKT_LEN_ATTR_ACTIONS_IF_LESS_EQUAL'.
1185 */
1186 actions = nla_next(cpl_arg, &rem);
1187 clone_flow_key = !arg->exec_for_lesser_equal;
1188 } else {
1189 /* Third netlink attribute in 'attr' is always
1190 * 'OVS_CHECK_PKT_LEN_ATTR_ACTIONS_IF_GREATER'.
1191 */
1192 actions = nla_next(cpl_arg, &rem);
1193 actions = nla_next(actions, &rem);
1194 clone_flow_key = !arg->exec_for_greater;
1195 }
1196
1197 return clone_execute(dp, skb, key, 0, nla_data(actions),
1198 nla_len(actions), last, clone_flow_key);
1199}
1200
Matteo Croce744676e2020-02-15 14:20:56 +01001201static int execute_dec_ttl(struct sk_buff *skb, struct sw_flow_key *key)
1202{
1203 int err;
1204
1205 if (skb->protocol == htons(ETH_P_IPV6)) {
1206 struct ipv6hdr *nh;
1207
1208 err = skb_ensure_writable(skb, skb_network_offset(skb) +
1209 sizeof(*nh));
1210 if (unlikely(err))
1211 return err;
1212
1213 nh = ipv6_hdr(skb);
1214
1215 if (nh->hop_limit <= 1)
1216 return -EHOSTUNREACH;
1217
1218 key->ip.ttl = --nh->hop_limit;
Eelco Chaudron09d62172020-12-07 05:08:39 -05001219 } else if (skb->protocol == htons(ETH_P_IP)) {
Matteo Croce744676e2020-02-15 14:20:56 +01001220 struct iphdr *nh;
1221 u8 old_ttl;
1222
1223 err = skb_ensure_writable(skb, skb_network_offset(skb) +
1224 sizeof(*nh));
1225 if (unlikely(err))
1226 return err;
1227
1228 nh = ip_hdr(skb);
1229 if (nh->ttl <= 1)
1230 return -EHOSTUNREACH;
1231
1232 old_ttl = nh->ttl--;
1233 csum_replace2(&nh->check, htons(old_ttl << 8),
1234 htons(nh->ttl << 8));
1235 key->ip.ttl = nh->ttl;
1236 }
1237 return 0;
1238}
1239
Jesse Grossccb13522011-10-25 19:26:31 -07001240/* Execute a list of actions against 'skb'. */
1241static int do_execute_actions(struct datapath *dp, struct sk_buff *skb,
Pravin B Shelar2ff3e4e2014-09-15 19:15:28 -07001242 struct sw_flow_key *key,
Simon Horman651887b2014-07-21 15:12:34 -07001243 const struct nlattr *attr, int len)
Jesse Grossccb13522011-10-25 19:26:31 -07001244{
Jesse Grossccb13522011-10-25 19:26:31 -07001245 const struct nlattr *a;
1246 int rem;
1247
1248 for (a = attr, rem = len; rem > 0;
1249 a = nla_next(a, &rem)) {
1250 int err = 0;
1251
Aaron Conolec4ab7b52021-06-22 10:02:33 -04001252 if (trace_ovs_do_execute_action_enabled())
1253 trace_ovs_do_execute_action(dp, skb, key, a, rem);
1254
Jesse Grossccb13522011-10-25 19:26:31 -07001255 switch (nla_type(a)) {
andy zhou5b8784a2017-01-27 13:45:28 -08001256 case OVS_ACTION_ATTR_OUTPUT: {
1257 int port = nla_get_u32(a);
1258 struct sk_buff *clone;
1259
1260 /* Every output action needs a separate clone
1261 * of 'skb', In case the output action is the
1262 * last action, cloning can be avoided.
1263 */
1264 if (nla_is_last(a, rem)) {
1265 do_output(dp, skb, port, key);
1266 /* 'skb' has been used for output.
1267 */
1268 return 0;
1269 }
1270
1271 clone = skb_clone(skb, GFP_ATOMIC);
1272 if (clone)
1273 do_output(dp, clone, port, key);
1274 OVS_CB(skb)->cutlen = 0;
Jesse Grossccb13522011-10-25 19:26:31 -07001275 break;
andy zhou5b8784a2017-01-27 13:45:28 -08001276 }
Jesse Grossccb13522011-10-25 19:26:31 -07001277
William Tuf2a4d082016-06-10 11:49:33 -07001278 case OVS_ACTION_ATTR_TRUNC: {
1279 struct ovs_action_trunc *trunc = nla_data(a);
1280
1281 if (skb->len > trunc->max_len)
1282 OVS_CB(skb)->cutlen = skb->len - trunc->max_len;
1283 break;
1284 }
1285
Jesse Grossccb13522011-10-25 19:26:31 -07001286 case OVS_ACTION_ATTR_USERSPACE:
William Tuf2a4d082016-06-10 11:49:33 -07001287 output_userspace(dp, skb, key, a, attr,
1288 len, OVS_CB(skb)->cutlen);
1289 OVS_CB(skb)->cutlen = 0;
Jesse Grossccb13522011-10-25 19:26:31 -07001290 break;
1291
Andy Zhou971427f32014-09-15 19:37:25 -07001292 case OVS_ACTION_ATTR_HASH:
1293 execute_hash(skb, key, a);
1294 break;
1295
Martin Varghesef66b53f2019-12-21 08:50:46 +05301296 case OVS_ACTION_ATTR_PUSH_MPLS: {
1297 struct ovs_action_push_mpls *mpls = nla_data(a);
Simon Horman25cd9ba2014-10-06 05:05:13 -07001298
Martin Varghesef66b53f2019-12-21 08:50:46 +05301299 err = push_mpls(skb, key, mpls->mpls_lse,
1300 mpls->mpls_ethertype, skb->mac_len);
1301 break;
1302 }
1303 case OVS_ACTION_ATTR_ADD_MPLS: {
1304 struct ovs_action_add_mpls *mpls = nla_data(a);
1305 __u16 mac_len = 0;
1306
1307 if (mpls->tun_flags & OVS_MPLS_L3_TUNNEL_FLAG_MASK)
1308 mac_len = skb->mac_len;
1309
1310 err = push_mpls(skb, key, mpls->mpls_lse,
1311 mpls->mpls_ethertype, mac_len);
1312 break;
1313 }
Simon Horman25cd9ba2014-10-06 05:05:13 -07001314 case OVS_ACTION_ATTR_POP_MPLS:
Pravin B Shelarfff06c32014-11-06 06:55:14 -08001315 err = pop_mpls(skb, key, nla_get_be16(a));
Simon Horman25cd9ba2014-10-06 05:05:13 -07001316 break;
1317
Jesse Grossccb13522011-10-25 19:26:31 -07001318 case OVS_ACTION_ATTR_PUSH_VLAN:
Pravin B Shelarfff06c32014-11-06 06:55:14 -08001319 err = push_vlan(skb, key, nla_data(a));
Jesse Grossccb13522011-10-25 19:26:31 -07001320 break;
1321
1322 case OVS_ACTION_ATTR_POP_VLAN:
Pravin B Shelarfff06c32014-11-06 06:55:14 -08001323 err = pop_vlan(skb, key);
Jesse Grossccb13522011-10-25 19:26:31 -07001324 break;
1325
andy zhoubef7f752017-03-20 16:32:30 -07001326 case OVS_ACTION_ATTR_RECIRC: {
1327 bool last = nla_is_last(a, rem);
1328
1329 err = execute_recirc(dp, skb, key, a, last);
1330 if (last) {
Andy Zhou971427f32014-09-15 19:37:25 -07001331 /* If this is the last action, the skb has
1332 * been consumed or freed.
1333 * Return immediately.
1334 */
1335 return err;
1336 }
1337 break;
andy zhoubef7f752017-03-20 16:32:30 -07001338 }
Andy Zhou971427f32014-09-15 19:37:25 -07001339
Jesse Grossccb13522011-10-25 19:26:31 -07001340 case OVS_ACTION_ATTR_SET:
Pravin B Shelarfff06c32014-11-06 06:55:14 -08001341 err = execute_set_action(skb, key, nla_data(a));
Jesse Grossccb13522011-10-25 19:26:31 -07001342 break;
1343
Jarno Rajahalme83d2b9b2015-02-05 13:40:49 -08001344 case OVS_ACTION_ATTR_SET_MASKED:
1345 case OVS_ACTION_ATTR_SET_TO_MASKED:
1346 err = execute_masked_set_action(skb, key, nla_data(a));
1347 break;
1348
andy zhou798c1662017-03-20 16:32:29 -07001349 case OVS_ACTION_ATTR_SAMPLE: {
1350 bool last = nla_is_last(a, rem);
1351
1352 err = sample(dp, skb, key, a, last);
1353 if (last)
1354 return err;
1355
Jesse Grossccb13522011-10-25 19:26:31 -07001356 break;
andy zhou798c1662017-03-20 16:32:29 -07001357 }
Joe Stringer7f8a4362015-08-26 11:31:48 -07001358
1359 case OVS_ACTION_ATTR_CT:
Joe Stringerec0d0432015-10-06 10:59:58 -07001360 if (!is_flow_key_valid(key)) {
1361 err = ovs_flow_key_update(skb, key);
1362 if (err)
1363 return err;
1364 }
1365
Joe Stringer7f8a4362015-08-26 11:31:48 -07001366 err = ovs_ct_execute(ovs_dp_get_net(dp), skb, key,
1367 nla_data(a));
1368
1369 /* Hide stolen IP fragments from user space. */
Joe Stringer74c16612015-10-25 20:21:48 -07001370 if (err)
1371 return err == -EINPROGRESS ? 0 : err;
Joe Stringer7f8a4362015-08-26 11:31:48 -07001372 break;
Jiri Benc91820da2016-11-10 16:28:23 +01001373
Eric Garverb8226962017-10-10 16:54:44 -04001374 case OVS_ACTION_ATTR_CT_CLEAR:
1375 err = ovs_ct_clear(skb, key);
1376 break;
1377
Jiri Benc91820da2016-11-10 16:28:23 +01001378 case OVS_ACTION_ATTR_PUSH_ETH:
1379 err = push_eth(skb, key, nla_data(a));
1380 break;
1381
1382 case OVS_ACTION_ATTR_POP_ETH:
1383 err = pop_eth(skb, key);
1384 break;
Yi Yangb2d0f5d2017-11-07 21:07:02 +08001385
1386 case OVS_ACTION_ATTR_PUSH_NSH: {
1387 u8 buffer[NSH_HDR_MAX_LEN];
1388 struct nshhdr *nh = (struct nshhdr *)buffer;
1389
1390 err = nsh_hdr_from_nlattr(nla_data(a), nh,
1391 NSH_HDR_MAX_LEN);
1392 if (unlikely(err))
1393 break;
1394 err = push_nsh(skb, key, nh);
1395 break;
1396 }
1397
1398 case OVS_ACTION_ATTR_POP_NSH:
1399 err = pop_nsh(skb, key);
1400 break;
Andy Zhoucd8a6c32017-11-10 12:09:43 -08001401
1402 case OVS_ACTION_ATTR_METER:
1403 if (ovs_meter_execute(dp, skb, key, nla_get_u32(a))) {
1404 consume_skb(skb);
1405 return 0;
1406 }
Yifeng Sunb2335042018-07-02 08:18:03 -07001407 break;
1408
1409 case OVS_ACTION_ATTR_CLONE: {
1410 bool last = nla_is_last(a, rem);
1411
1412 err = clone(dp, skb, key, a, last);
1413 if (last)
1414 return err;
1415
1416 break;
1417 }
Numan Siddique4d5ec892019-03-26 06:13:46 +05301418
1419 case OVS_ACTION_ATTR_CHECK_PKT_LEN: {
1420 bool last = nla_is_last(a, rem);
1421
1422 err = execute_check_pkt_len(dp, skb, key, a, last);
1423 if (last)
1424 return err;
1425
1426 break;
1427 }
Matteo Croce744676e2020-02-15 14:20:56 +01001428
1429 case OVS_ACTION_ATTR_DEC_TTL:
1430 err = execute_dec_ttl(skb, key);
Eelco Chaudrona5317f32021-01-13 14:50:00 +01001431 if (err == -EHOSTUNREACH)
1432 return dec_ttl_exception_handler(dp, skb,
1433 key, a);
Matteo Croce744676e2020-02-15 14:20:56 +01001434 break;
Jesse Grossccb13522011-10-25 19:26:31 -07001435 }
1436
1437 if (unlikely(err)) {
1438 kfree_skb(skb);
1439 return err;
1440 }
1441 }
1442
andy zhou5b8784a2017-01-27 13:45:28 -08001443 consume_skb(skb);
Jesse Grossccb13522011-10-25 19:26:31 -07001444 return 0;
1445}
1446
andy zhoubef7f752017-03-20 16:32:30 -07001447/* Execute the actions on the clone of the packet. The effect of the
1448 * execution does not affect the original 'skb' nor the original 'key'.
1449 *
1450 * The execution may be deferred in case the actions can not be executed
1451 * immediately.
1452 */
1453static int clone_execute(struct datapath *dp, struct sk_buff *skb,
1454 struct sw_flow_key *key, u32 recirc_id,
1455 const struct nlattr *actions, int len,
1456 bool last, bool clone_flow_key)
1457{
1458 struct deferred_action *da;
1459 struct sw_flow_key *clone;
1460
1461 skb = last ? skb : skb_clone(skb, GFP_ATOMIC);
1462 if (!skb) {
1463 /* Out of memory, skip this action.
1464 */
1465 return 0;
1466 }
1467
1468 /* When clone_flow_key is false, the 'key' will not be change
1469 * by the actions, then the 'key' can be used directly.
1470 * Otherwise, try to clone key from the next recursion level of
1471 * 'flow_keys'. If clone is successful, execute the actions
1472 * without deferring.
1473 */
1474 clone = clone_flow_key ? clone_key(key) : key;
1475 if (clone) {
1476 int err = 0;
1477
1478 if (actions) { /* Sample action */
1479 if (clone_flow_key)
1480 __this_cpu_inc(exec_actions_level);
1481
1482 err = do_execute_actions(dp, skb, clone,
1483 actions, len);
1484
1485 if (clone_flow_key)
1486 __this_cpu_dec(exec_actions_level);
1487 } else { /* Recirc action */
1488 clone->recirc_id = recirc_id;
1489 ovs_dp_process_packet(skb, clone);
1490 }
1491 return err;
1492 }
1493
1494 /* Out of 'flow_keys' space. Defer actions */
1495 da = add_deferred_actions(skb, key, actions, len);
1496 if (da) {
1497 if (!actions) { /* Recirc action */
1498 key = &da->pkt_key;
1499 key->recirc_id = recirc_id;
1500 }
1501 } else {
1502 /* Out of per CPU action FIFO space. Drop the 'skb' and
1503 * log an error.
1504 */
1505 kfree_skb(skb);
1506
1507 if (net_ratelimit()) {
1508 if (actions) { /* Sample action */
1509 pr_warn("%s: deferred action limit reached, drop sample action\n",
1510 ovs_dp_name(dp));
1511 } else { /* Recirc action */
1512 pr_warn("%s: deferred action limit reached, drop recirc action\n",
1513 ovs_dp_name(dp));
1514 }
1515 }
1516 }
1517 return 0;
1518}
1519
Andy Zhou971427f32014-09-15 19:37:25 -07001520static void process_deferred_actions(struct datapath *dp)
1521{
1522 struct action_fifo *fifo = this_cpu_ptr(action_fifos);
1523
1524 /* Do not touch the FIFO in case there is no deferred actions. */
1525 if (action_fifo_is_empty(fifo))
1526 return;
1527
1528 /* Finishing executing all deferred actions. */
1529 do {
1530 struct deferred_action *da = action_fifo_get(fifo);
1531 struct sk_buff *skb = da->skb;
1532 struct sw_flow_key *key = &da->pkt_key;
1533 const struct nlattr *actions = da->actions;
andy zhou47c697a2017-03-20 16:32:27 -07001534 int actions_len = da->actions_len;
Andy Zhou971427f32014-09-15 19:37:25 -07001535
1536 if (actions)
andy zhou47c697a2017-03-20 16:32:27 -07001537 do_execute_actions(dp, skb, key, actions, actions_len);
Andy Zhou971427f32014-09-15 19:37:25 -07001538 else
1539 ovs_dp_process_packet(skb, key);
1540 } while (!action_fifo_is_empty(fifo));
1541
1542 /* Reset FIFO for the next packet. */
1543 action_fifo_init(fifo);
1544}
1545
Jesse Grossccb13522011-10-25 19:26:31 -07001546/* Execute a list of actions against 'skb'. */
Pravin B Shelar2ff3e4e2014-09-15 19:15:28 -07001547int ovs_execute_actions(struct datapath *dp, struct sk_buff *skb,
Thomas Graf12eb18f2014-11-06 06:58:52 -08001548 const struct sw_flow_actions *acts,
1549 struct sw_flow_key *key)
Jesse Grossccb13522011-10-25 19:26:31 -07001550{
Hannes Frederic Sowab064d0d2016-01-18 18:03:48 +01001551 int err, level;
Jesse Grossccb13522011-10-25 19:26:31 -07001552
Hannes Frederic Sowab064d0d2016-01-18 18:03:48 +01001553 level = __this_cpu_inc_return(exec_actions_level);
Lance Richardson2679d042016-09-13 10:08:54 -04001554 if (unlikely(level > OVS_RECURSION_LIMIT)) {
Hannes Frederic Sowab064d0d2016-01-18 18:03:48 +01001555 net_crit_ratelimited("ovs: recursion limit reached on datapath %s, probable configuration error\n",
1556 ovs_dp_name(dp));
1557 kfree_skb(skb);
1558 err = -ENETDOWN;
1559 goto out;
1560 }
1561
Liping Zhang494bea32017-08-16 13:30:07 +08001562 OVS_CB(skb)->acts_origlen = acts->orig_len;
Andy Zhou971427f32014-09-15 19:37:25 -07001563 err = do_execute_actions(dp, skb, key,
1564 acts->actions, acts->actions_len);
1565
Hannes Frederic Sowab064d0d2016-01-18 18:03:48 +01001566 if (level == 1)
Andy Zhou971427f32014-09-15 19:37:25 -07001567 process_deferred_actions(dp);
1568
Hannes Frederic Sowab064d0d2016-01-18 18:03:48 +01001569out:
1570 __this_cpu_dec(exec_actions_level);
Andy Zhou971427f32014-09-15 19:37:25 -07001571 return err;
1572}
1573
1574int action_fifos_init(void)
1575{
1576 action_fifos = alloc_percpu(struct action_fifo);
1577 if (!action_fifos)
1578 return -ENOMEM;
1579
andy zhou4572ef52017-03-20 16:32:28 -07001580 flow_keys = alloc_percpu(struct action_flow_keys);
1581 if (!flow_keys) {
Lance Richardson2679d042016-09-13 10:08:54 -04001582 free_percpu(action_fifos);
1583 return -ENOMEM;
1584 }
1585
Andy Zhou971427f32014-09-15 19:37:25 -07001586 return 0;
1587}
1588
1589void action_fifos_exit(void)
1590{
1591 free_percpu(action_fifos);
andy zhou4572ef52017-03-20 16:32:28 -07001592 free_percpu(flow_keys);
Jesse Grossccb13522011-10-25 19:26:31 -07001593}