net/openvswitch: Set the ipv6 source tunnel key address attribute correctly
[sfrench/cifs-2.6.git] / net / openvswitch / flow_netlink.c
1 /*
2  * Copyright (c) 2007-2014 Nicira, Inc.
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of version 2 of the GNU General Public
6  * License as published by the Free Software Foundation.
7  *
8  * This program is distributed in the hope that it will be useful, but
9  * WITHOUT ANY WARRANTY; without even the implied warranty of
10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11  * General Public License for more details.
12  *
13  * You should have received a copy of the GNU General Public License
14  * along with this program; if not, write to the Free Software
15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
16  * 02110-1301, USA
17  */
18
19 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
20
21 #include "flow.h"
22 #include "datapath.h"
23 #include <linux/uaccess.h>
24 #include <linux/netdevice.h>
25 #include <linux/etherdevice.h>
26 #include <linux/if_ether.h>
27 #include <linux/if_vlan.h>
28 #include <net/llc_pdu.h>
29 #include <linux/kernel.h>
30 #include <linux/jhash.h>
31 #include <linux/jiffies.h>
32 #include <linux/llc.h>
33 #include <linux/module.h>
34 #include <linux/in.h>
35 #include <linux/rcupdate.h>
36 #include <linux/if_arp.h>
37 #include <linux/ip.h>
38 #include <linux/ipv6.h>
39 #include <linux/sctp.h>
40 #include <linux/tcp.h>
41 #include <linux/udp.h>
42 #include <linux/icmp.h>
43 #include <linux/icmpv6.h>
44 #include <linux/rculist.h>
45 #include <net/geneve.h>
46 #include <net/ip.h>
47 #include <net/ipv6.h>
48 #include <net/ndisc.h>
49 #include <net/mpls.h>
50 #include <net/vxlan.h>
51
52 #include "flow_netlink.h"
53
54 struct ovs_len_tbl {
55         int len;
56         const struct ovs_len_tbl *next;
57 };
58
59 #define OVS_ATTR_NESTED -1
60 #define OVS_ATTR_VARIABLE -2
61
62 static void update_range(struct sw_flow_match *match,
63                          size_t offset, size_t size, bool is_mask)
64 {
65         struct sw_flow_key_range *range;
66         size_t start = rounddown(offset, sizeof(long));
67         size_t end = roundup(offset + size, sizeof(long));
68
69         if (!is_mask)
70                 range = &match->range;
71         else
72                 range = &match->mask->range;
73
74         if (range->start == range->end) {
75                 range->start = start;
76                 range->end = end;
77                 return;
78         }
79
80         if (range->start > start)
81                 range->start = start;
82
83         if (range->end < end)
84                 range->end = end;
85 }
86
87 #define SW_FLOW_KEY_PUT(match, field, value, is_mask) \
88         do { \
89                 update_range(match, offsetof(struct sw_flow_key, field),    \
90                              sizeof((match)->key->field), is_mask);         \
91                 if (is_mask)                                                \
92                         (match)->mask->key.field = value;                   \
93                 else                                                        \
94                         (match)->key->field = value;                        \
95         } while (0)
96
97 #define SW_FLOW_KEY_MEMCPY_OFFSET(match, offset, value_p, len, is_mask)     \
98         do {                                                                \
99                 update_range(match, offset, len, is_mask);                  \
100                 if (is_mask)                                                \
101                         memcpy((u8 *)&(match)->mask->key + offset, value_p, \
102                                len);                                       \
103                 else                                                        \
104                         memcpy((u8 *)(match)->key + offset, value_p, len);  \
105         } while (0)
106
107 #define SW_FLOW_KEY_MEMCPY(match, field, value_p, len, is_mask)               \
108         SW_FLOW_KEY_MEMCPY_OFFSET(match, offsetof(struct sw_flow_key, field), \
109                                   value_p, len, is_mask)
110
111 #define SW_FLOW_KEY_MEMSET_FIELD(match, field, value, is_mask)              \
112         do {                                                                \
113                 update_range(match, offsetof(struct sw_flow_key, field),    \
114                              sizeof((match)->key->field), is_mask);         \
115                 if (is_mask)                                                \
116                         memset((u8 *)&(match)->mask->key.field, value,      \
117                                sizeof((match)->mask->key.field));           \
118                 else                                                        \
119                         memset((u8 *)&(match)->key->field, value,           \
120                                sizeof((match)->key->field));                \
121         } while (0)
122
123 static bool match_validate(const struct sw_flow_match *match,
124                            u64 key_attrs, u64 mask_attrs, bool log)
125 {
126         u64 key_expected = 0;
127         u64 mask_allowed = key_attrs;  /* At most allow all key attributes */
128
129         /* The following mask attributes allowed only if they
130          * pass the validation tests. */
131         mask_allowed &= ~((1 << OVS_KEY_ATTR_IPV4)
132                         | (1 << OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4)
133                         | (1 << OVS_KEY_ATTR_IPV6)
134                         | (1 << OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6)
135                         | (1 << OVS_KEY_ATTR_TCP)
136                         | (1 << OVS_KEY_ATTR_TCP_FLAGS)
137                         | (1 << OVS_KEY_ATTR_UDP)
138                         | (1 << OVS_KEY_ATTR_SCTP)
139                         | (1 << OVS_KEY_ATTR_ICMP)
140                         | (1 << OVS_KEY_ATTR_ICMPV6)
141                         | (1 << OVS_KEY_ATTR_ARP)
142                         | (1 << OVS_KEY_ATTR_ND)
143                         | (1 << OVS_KEY_ATTR_MPLS));
144
145         /* Always allowed mask fields. */
146         mask_allowed |= ((1 << OVS_KEY_ATTR_TUNNEL)
147                        | (1 << OVS_KEY_ATTR_IN_PORT)
148                        | (1 << OVS_KEY_ATTR_ETHERTYPE));
149
150         /* Check key attributes. */
151         if (match->key->eth.type == htons(ETH_P_ARP)
152                         || match->key->eth.type == htons(ETH_P_RARP)) {
153                 key_expected |= 1 << OVS_KEY_ATTR_ARP;
154                 if (match->mask && (match->mask->key.eth.type == htons(0xffff)))
155                         mask_allowed |= 1 << OVS_KEY_ATTR_ARP;
156         }
157
158         if (eth_p_mpls(match->key->eth.type)) {
159                 key_expected |= 1 << OVS_KEY_ATTR_MPLS;
160                 if (match->mask && (match->mask->key.eth.type == htons(0xffff)))
161                         mask_allowed |= 1 << OVS_KEY_ATTR_MPLS;
162         }
163
164         if (match->key->eth.type == htons(ETH_P_IP)) {
165                 key_expected |= 1 << OVS_KEY_ATTR_IPV4;
166                 if (match->mask && match->mask->key.eth.type == htons(0xffff)) {
167                         mask_allowed |= 1 << OVS_KEY_ATTR_IPV4;
168                         mask_allowed |= 1 << OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4;
169                 }
170
171                 if (match->key->ip.frag != OVS_FRAG_TYPE_LATER) {
172                         if (match->key->ip.proto == IPPROTO_UDP) {
173                                 key_expected |= 1 << OVS_KEY_ATTR_UDP;
174                                 if (match->mask && (match->mask->key.ip.proto == 0xff))
175                                         mask_allowed |= 1 << OVS_KEY_ATTR_UDP;
176                         }
177
178                         if (match->key->ip.proto == IPPROTO_SCTP) {
179                                 key_expected |= 1 << OVS_KEY_ATTR_SCTP;
180                                 if (match->mask && (match->mask->key.ip.proto == 0xff))
181                                         mask_allowed |= 1 << OVS_KEY_ATTR_SCTP;
182                         }
183
184                         if (match->key->ip.proto == IPPROTO_TCP) {
185                                 key_expected |= 1 << OVS_KEY_ATTR_TCP;
186                                 key_expected |= 1 << OVS_KEY_ATTR_TCP_FLAGS;
187                                 if (match->mask && (match->mask->key.ip.proto == 0xff)) {
188                                         mask_allowed |= 1 << OVS_KEY_ATTR_TCP;
189                                         mask_allowed |= 1 << OVS_KEY_ATTR_TCP_FLAGS;
190                                 }
191                         }
192
193                         if (match->key->ip.proto == IPPROTO_ICMP) {
194                                 key_expected |= 1 << OVS_KEY_ATTR_ICMP;
195                                 if (match->mask && (match->mask->key.ip.proto == 0xff))
196                                         mask_allowed |= 1 << OVS_KEY_ATTR_ICMP;
197                         }
198                 }
199         }
200
201         if (match->key->eth.type == htons(ETH_P_IPV6)) {
202                 key_expected |= 1 << OVS_KEY_ATTR_IPV6;
203                 if (match->mask && match->mask->key.eth.type == htons(0xffff)) {
204                         mask_allowed |= 1 << OVS_KEY_ATTR_IPV6;
205                         mask_allowed |= 1 << OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6;
206                 }
207
208                 if (match->key->ip.frag != OVS_FRAG_TYPE_LATER) {
209                         if (match->key->ip.proto == IPPROTO_UDP) {
210                                 key_expected |= 1 << OVS_KEY_ATTR_UDP;
211                                 if (match->mask && (match->mask->key.ip.proto == 0xff))
212                                         mask_allowed |= 1 << OVS_KEY_ATTR_UDP;
213                         }
214
215                         if (match->key->ip.proto == IPPROTO_SCTP) {
216                                 key_expected |= 1 << OVS_KEY_ATTR_SCTP;
217                                 if (match->mask && (match->mask->key.ip.proto == 0xff))
218                                         mask_allowed |= 1 << OVS_KEY_ATTR_SCTP;
219                         }
220
221                         if (match->key->ip.proto == IPPROTO_TCP) {
222                                 key_expected |= 1 << OVS_KEY_ATTR_TCP;
223                                 key_expected |= 1 << OVS_KEY_ATTR_TCP_FLAGS;
224                                 if (match->mask && (match->mask->key.ip.proto == 0xff)) {
225                                         mask_allowed |= 1 << OVS_KEY_ATTR_TCP;
226                                         mask_allowed |= 1 << OVS_KEY_ATTR_TCP_FLAGS;
227                                 }
228                         }
229
230                         if (match->key->ip.proto == IPPROTO_ICMPV6) {
231                                 key_expected |= 1 << OVS_KEY_ATTR_ICMPV6;
232                                 if (match->mask && (match->mask->key.ip.proto == 0xff))
233                                         mask_allowed |= 1 << OVS_KEY_ATTR_ICMPV6;
234
235                                 if (match->key->tp.src ==
236                                                 htons(NDISC_NEIGHBOUR_SOLICITATION) ||
237                                     match->key->tp.src == htons(NDISC_NEIGHBOUR_ADVERTISEMENT)) {
238                                         key_expected |= 1 << OVS_KEY_ATTR_ND;
239                                         /* Original direction conntrack tuple
240                                          * uses the same space as the ND fields
241                                          * in the key, so both are not allowed
242                                          * at the same time.
243                                          */
244                                         mask_allowed &= ~(1ULL << OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6);
245                                         if (match->mask && (match->mask->key.tp.src == htons(0xff)))
246                                                 mask_allowed |= 1 << OVS_KEY_ATTR_ND;
247                                 }
248                         }
249                 }
250         }
251
252         if ((key_attrs & key_expected) != key_expected) {
253                 /* Key attributes check failed. */
254                 OVS_NLERR(log, "Missing key (keys=%llx, expected=%llx)",
255                           (unsigned long long)key_attrs,
256                           (unsigned long long)key_expected);
257                 return false;
258         }
259
260         if ((mask_attrs & mask_allowed) != mask_attrs) {
261                 /* Mask attributes check failed. */
262                 OVS_NLERR(log, "Unexpected mask (mask=%llx, allowed=%llx)",
263                           (unsigned long long)mask_attrs,
264                           (unsigned long long)mask_allowed);
265                 return false;
266         }
267
268         return true;
269 }
270
271 size_t ovs_tun_key_attr_size(void)
272 {
273         /* Whenever adding new OVS_TUNNEL_KEY_ FIELDS, we should consider
274          * updating this function.
275          */
276         return    nla_total_size_64bit(8) /* OVS_TUNNEL_KEY_ATTR_ID */
277                 + nla_total_size(16)   /* OVS_TUNNEL_KEY_ATTR_IPV[46]_SRC */
278                 + nla_total_size(16)   /* OVS_TUNNEL_KEY_ATTR_IPV[46]_DST */
279                 + nla_total_size(1)    /* OVS_TUNNEL_KEY_ATTR_TOS */
280                 + nla_total_size(1)    /* OVS_TUNNEL_KEY_ATTR_TTL */
281                 + nla_total_size(0)    /* OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT */
282                 + nla_total_size(0)    /* OVS_TUNNEL_KEY_ATTR_CSUM */
283                 + nla_total_size(0)    /* OVS_TUNNEL_KEY_ATTR_OAM */
284                 + nla_total_size(256)  /* OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS */
285                 /* OVS_TUNNEL_KEY_ATTR_VXLAN_OPTS is mutually exclusive with
286                  * OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS and covered by it.
287                  */
288                 + nla_total_size(2)    /* OVS_TUNNEL_KEY_ATTR_TP_SRC */
289                 + nla_total_size(2);   /* OVS_TUNNEL_KEY_ATTR_TP_DST */
290 }
291
292 size_t ovs_key_attr_size(void)
293 {
294         /* Whenever adding new OVS_KEY_ FIELDS, we should consider
295          * updating this function.
296          */
297         BUILD_BUG_ON(OVS_KEY_ATTR_TUNNEL_INFO != 28);
298
299         return    nla_total_size(4)   /* OVS_KEY_ATTR_PRIORITY */
300                 + nla_total_size(0)   /* OVS_KEY_ATTR_TUNNEL */
301                   + ovs_tun_key_attr_size()
302                 + nla_total_size(4)   /* OVS_KEY_ATTR_IN_PORT */
303                 + nla_total_size(4)   /* OVS_KEY_ATTR_SKB_MARK */
304                 + nla_total_size(4)   /* OVS_KEY_ATTR_DP_HASH */
305                 + nla_total_size(4)   /* OVS_KEY_ATTR_RECIRC_ID */
306                 + nla_total_size(4)   /* OVS_KEY_ATTR_CT_STATE */
307                 + nla_total_size(2)   /* OVS_KEY_ATTR_CT_ZONE */
308                 + nla_total_size(4)   /* OVS_KEY_ATTR_CT_MARK */
309                 + nla_total_size(16)  /* OVS_KEY_ATTR_CT_LABELS */
310                 + nla_total_size(40)  /* OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6 */
311                 + nla_total_size(12)  /* OVS_KEY_ATTR_ETHERNET */
312                 + nla_total_size(2)   /* OVS_KEY_ATTR_ETHERTYPE */
313                 + nla_total_size(4)   /* OVS_KEY_ATTR_VLAN */
314                 + nla_total_size(0)   /* OVS_KEY_ATTR_ENCAP */
315                 + nla_total_size(2)   /* OVS_KEY_ATTR_ETHERTYPE */
316                 + nla_total_size(40)  /* OVS_KEY_ATTR_IPV6 */
317                 + nla_total_size(2)   /* OVS_KEY_ATTR_ICMPV6 */
318                 + nla_total_size(28); /* OVS_KEY_ATTR_ND */
319 }
320
321 static const struct ovs_len_tbl ovs_vxlan_ext_key_lens[OVS_VXLAN_EXT_MAX + 1] = {
322         [OVS_VXLAN_EXT_GBP]         = { .len = sizeof(u32) },
323 };
324
325 static const struct ovs_len_tbl ovs_tunnel_key_lens[OVS_TUNNEL_KEY_ATTR_MAX + 1] = {
326         [OVS_TUNNEL_KEY_ATTR_ID]            = { .len = sizeof(u64) },
327         [OVS_TUNNEL_KEY_ATTR_IPV4_SRC]      = { .len = sizeof(u32) },
328         [OVS_TUNNEL_KEY_ATTR_IPV4_DST]      = { .len = sizeof(u32) },
329         [OVS_TUNNEL_KEY_ATTR_TOS]           = { .len = 1 },
330         [OVS_TUNNEL_KEY_ATTR_TTL]           = { .len = 1 },
331         [OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT] = { .len = 0 },
332         [OVS_TUNNEL_KEY_ATTR_CSUM]          = { .len = 0 },
333         [OVS_TUNNEL_KEY_ATTR_TP_SRC]        = { .len = sizeof(u16) },
334         [OVS_TUNNEL_KEY_ATTR_TP_DST]        = { .len = sizeof(u16) },
335         [OVS_TUNNEL_KEY_ATTR_OAM]           = { .len = 0 },
336         [OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS]   = { .len = OVS_ATTR_VARIABLE },
337         [OVS_TUNNEL_KEY_ATTR_VXLAN_OPTS]    = { .len = OVS_ATTR_NESTED,
338                                                 .next = ovs_vxlan_ext_key_lens },
339         [OVS_TUNNEL_KEY_ATTR_IPV6_SRC]      = { .len = sizeof(struct in6_addr) },
340         [OVS_TUNNEL_KEY_ATTR_IPV6_DST]      = { .len = sizeof(struct in6_addr) },
341 };
342
343 /* The size of the argument for each %OVS_KEY_ATTR_* Netlink attribute.  */
344 static const struct ovs_len_tbl ovs_key_lens[OVS_KEY_ATTR_MAX + 1] = {
345         [OVS_KEY_ATTR_ENCAP]     = { .len = OVS_ATTR_NESTED },
346         [OVS_KEY_ATTR_PRIORITY]  = { .len = sizeof(u32) },
347         [OVS_KEY_ATTR_IN_PORT]   = { .len = sizeof(u32) },
348         [OVS_KEY_ATTR_SKB_MARK]  = { .len = sizeof(u32) },
349         [OVS_KEY_ATTR_ETHERNET]  = { .len = sizeof(struct ovs_key_ethernet) },
350         [OVS_KEY_ATTR_VLAN]      = { .len = sizeof(__be16) },
351         [OVS_KEY_ATTR_ETHERTYPE] = { .len = sizeof(__be16) },
352         [OVS_KEY_ATTR_IPV4]      = { .len = sizeof(struct ovs_key_ipv4) },
353         [OVS_KEY_ATTR_IPV6]      = { .len = sizeof(struct ovs_key_ipv6) },
354         [OVS_KEY_ATTR_TCP]       = { .len = sizeof(struct ovs_key_tcp) },
355         [OVS_KEY_ATTR_TCP_FLAGS] = { .len = sizeof(__be16) },
356         [OVS_KEY_ATTR_UDP]       = { .len = sizeof(struct ovs_key_udp) },
357         [OVS_KEY_ATTR_SCTP]      = { .len = sizeof(struct ovs_key_sctp) },
358         [OVS_KEY_ATTR_ICMP]      = { .len = sizeof(struct ovs_key_icmp) },
359         [OVS_KEY_ATTR_ICMPV6]    = { .len = sizeof(struct ovs_key_icmpv6) },
360         [OVS_KEY_ATTR_ARP]       = { .len = sizeof(struct ovs_key_arp) },
361         [OVS_KEY_ATTR_ND]        = { .len = sizeof(struct ovs_key_nd) },
362         [OVS_KEY_ATTR_RECIRC_ID] = { .len = sizeof(u32) },
363         [OVS_KEY_ATTR_DP_HASH]   = { .len = sizeof(u32) },
364         [OVS_KEY_ATTR_TUNNEL]    = { .len = OVS_ATTR_NESTED,
365                                      .next = ovs_tunnel_key_lens, },
366         [OVS_KEY_ATTR_MPLS]      = { .len = sizeof(struct ovs_key_mpls) },
367         [OVS_KEY_ATTR_CT_STATE]  = { .len = sizeof(u32) },
368         [OVS_KEY_ATTR_CT_ZONE]   = { .len = sizeof(u16) },
369         [OVS_KEY_ATTR_CT_MARK]   = { .len = sizeof(u32) },
370         [OVS_KEY_ATTR_CT_LABELS] = { .len = sizeof(struct ovs_key_ct_labels) },
371         [OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4] = {
372                 .len = sizeof(struct ovs_key_ct_tuple_ipv4) },
373         [OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6] = {
374                 .len = sizeof(struct ovs_key_ct_tuple_ipv6) },
375 };
376
377 static bool check_attr_len(unsigned int attr_len, unsigned int expected_len)
378 {
379         return expected_len == attr_len ||
380                expected_len == OVS_ATTR_NESTED ||
381                expected_len == OVS_ATTR_VARIABLE;
382 }
383
384 static bool is_all_zero(const u8 *fp, size_t size)
385 {
386         int i;
387
388         if (!fp)
389                 return false;
390
391         for (i = 0; i < size; i++)
392                 if (fp[i])
393                         return false;
394
395         return true;
396 }
397
398 static int __parse_flow_nlattrs(const struct nlattr *attr,
399                                 const struct nlattr *a[],
400                                 u64 *attrsp, bool log, bool nz)
401 {
402         const struct nlattr *nla;
403         u64 attrs;
404         int rem;
405
406         attrs = *attrsp;
407         nla_for_each_nested(nla, attr, rem) {
408                 u16 type = nla_type(nla);
409                 int expected_len;
410
411                 if (type > OVS_KEY_ATTR_MAX) {
412                         OVS_NLERR(log, "Key type %d is out of range max %d",
413                                   type, OVS_KEY_ATTR_MAX);
414                         return -EINVAL;
415                 }
416
417                 if (attrs & (1 << type)) {
418                         OVS_NLERR(log, "Duplicate key (type %d).", type);
419                         return -EINVAL;
420                 }
421
422                 expected_len = ovs_key_lens[type].len;
423                 if (!check_attr_len(nla_len(nla), expected_len)) {
424                         OVS_NLERR(log, "Key %d has unexpected len %d expected %d",
425                                   type, nla_len(nla), expected_len);
426                         return -EINVAL;
427                 }
428
429                 if (!nz || !is_all_zero(nla_data(nla), expected_len)) {
430                         attrs |= 1 << type;
431                         a[type] = nla;
432                 }
433         }
434         if (rem) {
435                 OVS_NLERR(log, "Message has %d unknown bytes.", rem);
436                 return -EINVAL;
437         }
438
439         *attrsp = attrs;
440         return 0;
441 }
442
443 static int parse_flow_mask_nlattrs(const struct nlattr *attr,
444                                    const struct nlattr *a[], u64 *attrsp,
445                                    bool log)
446 {
447         return __parse_flow_nlattrs(attr, a, attrsp, log, true);
448 }
449
450 int parse_flow_nlattrs(const struct nlattr *attr, const struct nlattr *a[],
451                        u64 *attrsp, bool log)
452 {
453         return __parse_flow_nlattrs(attr, a, attrsp, log, false);
454 }
455
456 static int genev_tun_opt_from_nlattr(const struct nlattr *a,
457                                      struct sw_flow_match *match, bool is_mask,
458                                      bool log)
459 {
460         unsigned long opt_key_offset;
461
462         if (nla_len(a) > sizeof(match->key->tun_opts)) {
463                 OVS_NLERR(log, "Geneve option length err (len %d, max %zu).",
464                           nla_len(a), sizeof(match->key->tun_opts));
465                 return -EINVAL;
466         }
467
468         if (nla_len(a) % 4 != 0) {
469                 OVS_NLERR(log, "Geneve opt len %d is not a multiple of 4.",
470                           nla_len(a));
471                 return -EINVAL;
472         }
473
474         /* We need to record the length of the options passed
475          * down, otherwise packets with the same format but
476          * additional options will be silently matched.
477          */
478         if (!is_mask) {
479                 SW_FLOW_KEY_PUT(match, tun_opts_len, nla_len(a),
480                                 false);
481         } else {
482                 /* This is somewhat unusual because it looks at
483                  * both the key and mask while parsing the
484                  * attributes (and by extension assumes the key
485                  * is parsed first). Normally, we would verify
486                  * that each is the correct length and that the
487                  * attributes line up in the validate function.
488                  * However, that is difficult because this is
489                  * variable length and we won't have the
490                  * information later.
491                  */
492                 if (match->key->tun_opts_len != nla_len(a)) {
493                         OVS_NLERR(log, "Geneve option len %d != mask len %d",
494                                   match->key->tun_opts_len, nla_len(a));
495                         return -EINVAL;
496                 }
497
498                 SW_FLOW_KEY_PUT(match, tun_opts_len, 0xff, true);
499         }
500
501         opt_key_offset = TUN_METADATA_OFFSET(nla_len(a));
502         SW_FLOW_KEY_MEMCPY_OFFSET(match, opt_key_offset, nla_data(a),
503                                   nla_len(a), is_mask);
504         return 0;
505 }
506
507 static int vxlan_tun_opt_from_nlattr(const struct nlattr *attr,
508                                      struct sw_flow_match *match, bool is_mask,
509                                      bool log)
510 {
511         struct nlattr *a;
512         int rem;
513         unsigned long opt_key_offset;
514         struct vxlan_metadata opts;
515
516         BUILD_BUG_ON(sizeof(opts) > sizeof(match->key->tun_opts));
517
518         memset(&opts, 0, sizeof(opts));
519         nla_for_each_nested(a, attr, rem) {
520                 int type = nla_type(a);
521
522                 if (type > OVS_VXLAN_EXT_MAX) {
523                         OVS_NLERR(log, "VXLAN extension %d out of range max %d",
524                                   type, OVS_VXLAN_EXT_MAX);
525                         return -EINVAL;
526                 }
527
528                 if (!check_attr_len(nla_len(a),
529                                     ovs_vxlan_ext_key_lens[type].len)) {
530                         OVS_NLERR(log, "VXLAN extension %d has unexpected len %d expected %d",
531                                   type, nla_len(a),
532                                   ovs_vxlan_ext_key_lens[type].len);
533                         return -EINVAL;
534                 }
535
536                 switch (type) {
537                 case OVS_VXLAN_EXT_GBP:
538                         opts.gbp = nla_get_u32(a);
539                         break;
540                 default:
541                         OVS_NLERR(log, "Unknown VXLAN extension attribute %d",
542                                   type);
543                         return -EINVAL;
544                 }
545         }
546         if (rem) {
547                 OVS_NLERR(log, "VXLAN extension message has %d unknown bytes.",
548                           rem);
549                 return -EINVAL;
550         }
551
552         if (!is_mask)
553                 SW_FLOW_KEY_PUT(match, tun_opts_len, sizeof(opts), false);
554         else
555                 SW_FLOW_KEY_PUT(match, tun_opts_len, 0xff, true);
556
557         opt_key_offset = TUN_METADATA_OFFSET(sizeof(opts));
558         SW_FLOW_KEY_MEMCPY_OFFSET(match, opt_key_offset, &opts, sizeof(opts),
559                                   is_mask);
560         return 0;
561 }
562
563 static int ip_tun_from_nlattr(const struct nlattr *attr,
564                               struct sw_flow_match *match, bool is_mask,
565                               bool log)
566 {
567         bool ttl = false, ipv4 = false, ipv6 = false;
568         __be16 tun_flags = 0;
569         int opts_type = 0;
570         struct nlattr *a;
571         int rem;
572
573         nla_for_each_nested(a, attr, rem) {
574                 int type = nla_type(a);
575                 int err;
576
577                 if (type > OVS_TUNNEL_KEY_ATTR_MAX) {
578                         OVS_NLERR(log, "Tunnel attr %d out of range max %d",
579                                   type, OVS_TUNNEL_KEY_ATTR_MAX);
580                         return -EINVAL;
581                 }
582
583                 if (!check_attr_len(nla_len(a),
584                                     ovs_tunnel_key_lens[type].len)) {
585                         OVS_NLERR(log, "Tunnel attr %d has unexpected len %d expected %d",
586                                   type, nla_len(a), ovs_tunnel_key_lens[type].len);
587                         return -EINVAL;
588                 }
589
590                 switch (type) {
591                 case OVS_TUNNEL_KEY_ATTR_ID:
592                         SW_FLOW_KEY_PUT(match, tun_key.tun_id,
593                                         nla_get_be64(a), is_mask);
594                         tun_flags |= TUNNEL_KEY;
595                         break;
596                 case OVS_TUNNEL_KEY_ATTR_IPV4_SRC:
597                         SW_FLOW_KEY_PUT(match, tun_key.u.ipv4.src,
598                                         nla_get_in_addr(a), is_mask);
599                         ipv4 = true;
600                         break;
601                 case OVS_TUNNEL_KEY_ATTR_IPV4_DST:
602                         SW_FLOW_KEY_PUT(match, tun_key.u.ipv4.dst,
603                                         nla_get_in_addr(a), is_mask);
604                         ipv4 = true;
605                         break;
606                 case OVS_TUNNEL_KEY_ATTR_IPV6_SRC:
607                         SW_FLOW_KEY_PUT(match, tun_key.u.ipv6.src,
608                                         nla_get_in6_addr(a), is_mask);
609                         ipv6 = true;
610                         break;
611                 case OVS_TUNNEL_KEY_ATTR_IPV6_DST:
612                         SW_FLOW_KEY_PUT(match, tun_key.u.ipv6.dst,
613                                         nla_get_in6_addr(a), is_mask);
614                         ipv6 = true;
615                         break;
616                 case OVS_TUNNEL_KEY_ATTR_TOS:
617                         SW_FLOW_KEY_PUT(match, tun_key.tos,
618                                         nla_get_u8(a), is_mask);
619                         break;
620                 case OVS_TUNNEL_KEY_ATTR_TTL:
621                         SW_FLOW_KEY_PUT(match, tun_key.ttl,
622                                         nla_get_u8(a), is_mask);
623                         ttl = true;
624                         break;
625                 case OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT:
626                         tun_flags |= TUNNEL_DONT_FRAGMENT;
627                         break;
628                 case OVS_TUNNEL_KEY_ATTR_CSUM:
629                         tun_flags |= TUNNEL_CSUM;
630                         break;
631                 case OVS_TUNNEL_KEY_ATTR_TP_SRC:
632                         SW_FLOW_KEY_PUT(match, tun_key.tp_src,
633                                         nla_get_be16(a), is_mask);
634                         break;
635                 case OVS_TUNNEL_KEY_ATTR_TP_DST:
636                         SW_FLOW_KEY_PUT(match, tun_key.tp_dst,
637                                         nla_get_be16(a), is_mask);
638                         break;
639                 case OVS_TUNNEL_KEY_ATTR_OAM:
640                         tun_flags |= TUNNEL_OAM;
641                         break;
642                 case OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS:
643                         if (opts_type) {
644                                 OVS_NLERR(log, "Multiple metadata blocks provided");
645                                 return -EINVAL;
646                         }
647
648                         err = genev_tun_opt_from_nlattr(a, match, is_mask, log);
649                         if (err)
650                                 return err;
651
652                         tun_flags |= TUNNEL_GENEVE_OPT;
653                         opts_type = type;
654                         break;
655                 case OVS_TUNNEL_KEY_ATTR_VXLAN_OPTS:
656                         if (opts_type) {
657                                 OVS_NLERR(log, "Multiple metadata blocks provided");
658                                 return -EINVAL;
659                         }
660
661                         err = vxlan_tun_opt_from_nlattr(a, match, is_mask, log);
662                         if (err)
663                                 return err;
664
665                         tun_flags |= TUNNEL_VXLAN_OPT;
666                         opts_type = type;
667                         break;
668                 default:
669                         OVS_NLERR(log, "Unknown IP tunnel attribute %d",
670                                   type);
671                         return -EINVAL;
672                 }
673         }
674
675         SW_FLOW_KEY_PUT(match, tun_key.tun_flags, tun_flags, is_mask);
676         if (is_mask)
677                 SW_FLOW_KEY_MEMSET_FIELD(match, tun_proto, 0xff, true);
678         else
679                 SW_FLOW_KEY_PUT(match, tun_proto, ipv6 ? AF_INET6 : AF_INET,
680                                 false);
681
682         if (rem > 0) {
683                 OVS_NLERR(log, "IP tunnel attribute has %d unknown bytes.",
684                           rem);
685                 return -EINVAL;
686         }
687
688         if (ipv4 && ipv6) {
689                 OVS_NLERR(log, "Mixed IPv4 and IPv6 tunnel attributes");
690                 return -EINVAL;
691         }
692
693         if (!is_mask) {
694                 if (!ipv4 && !ipv6) {
695                         OVS_NLERR(log, "IP tunnel dst address not specified");
696                         return -EINVAL;
697                 }
698                 if (ipv4 && !match->key->tun_key.u.ipv4.dst) {
699                         OVS_NLERR(log, "IPv4 tunnel dst address is zero");
700                         return -EINVAL;
701                 }
702                 if (ipv6 && ipv6_addr_any(&match->key->tun_key.u.ipv6.dst)) {
703                         OVS_NLERR(log, "IPv6 tunnel dst address is zero");
704                         return -EINVAL;
705                 }
706
707                 if (!ttl) {
708                         OVS_NLERR(log, "IP tunnel TTL not specified.");
709                         return -EINVAL;
710                 }
711         }
712
713         return opts_type;
714 }
715
716 static int vxlan_opt_to_nlattr(struct sk_buff *skb,
717                                const void *tun_opts, int swkey_tun_opts_len)
718 {
719         const struct vxlan_metadata *opts = tun_opts;
720         struct nlattr *nla;
721
722         nla = nla_nest_start(skb, OVS_TUNNEL_KEY_ATTR_VXLAN_OPTS);
723         if (!nla)
724                 return -EMSGSIZE;
725
726         if (nla_put_u32(skb, OVS_VXLAN_EXT_GBP, opts->gbp) < 0)
727                 return -EMSGSIZE;
728
729         nla_nest_end(skb, nla);
730         return 0;
731 }
732
733 static int __ip_tun_to_nlattr(struct sk_buff *skb,
734                               const struct ip_tunnel_key *output,
735                               const void *tun_opts, int swkey_tun_opts_len,
736                               unsigned short tun_proto)
737 {
738         if (output->tun_flags & TUNNEL_KEY &&
739             nla_put_be64(skb, OVS_TUNNEL_KEY_ATTR_ID, output->tun_id,
740                          OVS_TUNNEL_KEY_ATTR_PAD))
741                 return -EMSGSIZE;
742         switch (tun_proto) {
743         case AF_INET:
744                 if (output->u.ipv4.src &&
745                     nla_put_in_addr(skb, OVS_TUNNEL_KEY_ATTR_IPV4_SRC,
746                                     output->u.ipv4.src))
747                         return -EMSGSIZE;
748                 if (output->u.ipv4.dst &&
749                     nla_put_in_addr(skb, OVS_TUNNEL_KEY_ATTR_IPV4_DST,
750                                     output->u.ipv4.dst))
751                         return -EMSGSIZE;
752                 break;
753         case AF_INET6:
754                 if (!ipv6_addr_any(&output->u.ipv6.src) &&
755                     nla_put_in6_addr(skb, OVS_TUNNEL_KEY_ATTR_IPV6_SRC,
756                                      &output->u.ipv6.src))
757                         return -EMSGSIZE;
758                 if (!ipv6_addr_any(&output->u.ipv6.dst) &&
759                     nla_put_in6_addr(skb, OVS_TUNNEL_KEY_ATTR_IPV6_DST,
760                                      &output->u.ipv6.dst))
761                         return -EMSGSIZE;
762                 break;
763         }
764         if (output->tos &&
765             nla_put_u8(skb, OVS_TUNNEL_KEY_ATTR_TOS, output->tos))
766                 return -EMSGSIZE;
767         if (nla_put_u8(skb, OVS_TUNNEL_KEY_ATTR_TTL, output->ttl))
768                 return -EMSGSIZE;
769         if ((output->tun_flags & TUNNEL_DONT_FRAGMENT) &&
770             nla_put_flag(skb, OVS_TUNNEL_KEY_ATTR_DONT_FRAGMENT))
771                 return -EMSGSIZE;
772         if ((output->tun_flags & TUNNEL_CSUM) &&
773             nla_put_flag(skb, OVS_TUNNEL_KEY_ATTR_CSUM))
774                 return -EMSGSIZE;
775         if (output->tp_src &&
776             nla_put_be16(skb, OVS_TUNNEL_KEY_ATTR_TP_SRC, output->tp_src))
777                 return -EMSGSIZE;
778         if (output->tp_dst &&
779             nla_put_be16(skb, OVS_TUNNEL_KEY_ATTR_TP_DST, output->tp_dst))
780                 return -EMSGSIZE;
781         if ((output->tun_flags & TUNNEL_OAM) &&
782             nla_put_flag(skb, OVS_TUNNEL_KEY_ATTR_OAM))
783                 return -EMSGSIZE;
784         if (swkey_tun_opts_len) {
785                 if (output->tun_flags & TUNNEL_GENEVE_OPT &&
786                     nla_put(skb, OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS,
787                             swkey_tun_opts_len, tun_opts))
788                         return -EMSGSIZE;
789                 else if (output->tun_flags & TUNNEL_VXLAN_OPT &&
790                          vxlan_opt_to_nlattr(skb, tun_opts, swkey_tun_opts_len))
791                         return -EMSGSIZE;
792         }
793
794         return 0;
795 }
796
797 static int ip_tun_to_nlattr(struct sk_buff *skb,
798                             const struct ip_tunnel_key *output,
799                             const void *tun_opts, int swkey_tun_opts_len,
800                             unsigned short tun_proto)
801 {
802         struct nlattr *nla;
803         int err;
804
805         nla = nla_nest_start(skb, OVS_KEY_ATTR_TUNNEL);
806         if (!nla)
807                 return -EMSGSIZE;
808
809         err = __ip_tun_to_nlattr(skb, output, tun_opts, swkey_tun_opts_len,
810                                  tun_proto);
811         if (err)
812                 return err;
813
814         nla_nest_end(skb, nla);
815         return 0;
816 }
817
818 int ovs_nla_put_tunnel_info(struct sk_buff *skb,
819                             struct ip_tunnel_info *tun_info)
820 {
821         return __ip_tun_to_nlattr(skb, &tun_info->key,
822                                   ip_tunnel_info_opts(tun_info),
823                                   tun_info->options_len,
824                                   ip_tunnel_info_af(tun_info));
825 }
826
827 static int encode_vlan_from_nlattrs(struct sw_flow_match *match,
828                                     const struct nlattr *a[],
829                                     bool is_mask, bool inner)
830 {
831         __be16 tci = 0;
832         __be16 tpid = 0;
833
834         if (a[OVS_KEY_ATTR_VLAN])
835                 tci = nla_get_be16(a[OVS_KEY_ATTR_VLAN]);
836
837         if (a[OVS_KEY_ATTR_ETHERTYPE])
838                 tpid = nla_get_be16(a[OVS_KEY_ATTR_ETHERTYPE]);
839
840         if (likely(!inner)) {
841                 SW_FLOW_KEY_PUT(match, eth.vlan.tpid, tpid, is_mask);
842                 SW_FLOW_KEY_PUT(match, eth.vlan.tci, tci, is_mask);
843         } else {
844                 SW_FLOW_KEY_PUT(match, eth.cvlan.tpid, tpid, is_mask);
845                 SW_FLOW_KEY_PUT(match, eth.cvlan.tci, tci, is_mask);
846         }
847         return 0;
848 }
849
850 static int validate_vlan_from_nlattrs(const struct sw_flow_match *match,
851                                       u64 key_attrs, bool inner,
852                                       const struct nlattr **a, bool log)
853 {
854         __be16 tci = 0;
855
856         if (!((key_attrs & (1 << OVS_KEY_ATTR_ETHERNET)) &&
857               (key_attrs & (1 << OVS_KEY_ATTR_ETHERTYPE)) &&
858                eth_type_vlan(nla_get_be16(a[OVS_KEY_ATTR_ETHERTYPE])))) {
859                 /* Not a VLAN. */
860                 return 0;
861         }
862
863         if (!((key_attrs & (1 << OVS_KEY_ATTR_VLAN)) &&
864               (key_attrs & (1 << OVS_KEY_ATTR_ENCAP)))) {
865                 OVS_NLERR(log, "Invalid %s frame", (inner) ? "C-VLAN" : "VLAN");
866                 return -EINVAL;
867         }
868
869         if (a[OVS_KEY_ATTR_VLAN])
870                 tci = nla_get_be16(a[OVS_KEY_ATTR_VLAN]);
871
872         if (!(tci & htons(VLAN_TAG_PRESENT))) {
873                 if (tci) {
874                         OVS_NLERR(log, "%s TCI does not have VLAN_TAG_PRESENT bit set.",
875                                   (inner) ? "C-VLAN" : "VLAN");
876                         return -EINVAL;
877                 } else if (nla_len(a[OVS_KEY_ATTR_ENCAP])) {
878                         /* Corner case for truncated VLAN header. */
879                         OVS_NLERR(log, "Truncated %s header has non-zero encap attribute.",
880                                   (inner) ? "C-VLAN" : "VLAN");
881                         return -EINVAL;
882                 }
883         }
884
885         return 1;
886 }
887
888 static int validate_vlan_mask_from_nlattrs(const struct sw_flow_match *match,
889                                            u64 key_attrs, bool inner,
890                                            const struct nlattr **a, bool log)
891 {
892         __be16 tci = 0;
893         __be16 tpid = 0;
894         bool encap_valid = !!(match->key->eth.vlan.tci &
895                               htons(VLAN_TAG_PRESENT));
896         bool i_encap_valid = !!(match->key->eth.cvlan.tci &
897                                 htons(VLAN_TAG_PRESENT));
898
899         if (!(key_attrs & (1 << OVS_KEY_ATTR_ENCAP))) {
900                 /* Not a VLAN. */
901                 return 0;
902         }
903
904         if ((!inner && !encap_valid) || (inner && !i_encap_valid)) {
905                 OVS_NLERR(log, "Encap mask attribute is set for non-%s frame.",
906                           (inner) ? "C-VLAN" : "VLAN");
907                 return -EINVAL;
908         }
909
910         if (a[OVS_KEY_ATTR_VLAN])
911                 tci = nla_get_be16(a[OVS_KEY_ATTR_VLAN]);
912
913         if (a[OVS_KEY_ATTR_ETHERTYPE])
914                 tpid = nla_get_be16(a[OVS_KEY_ATTR_ETHERTYPE]);
915
916         if (tpid != htons(0xffff)) {
917                 OVS_NLERR(log, "Must have an exact match on %s TPID (mask=%x).",
918                           (inner) ? "C-VLAN" : "VLAN", ntohs(tpid));
919                 return -EINVAL;
920         }
921         if (!(tci & htons(VLAN_TAG_PRESENT))) {
922                 OVS_NLERR(log, "%s TCI mask does not have exact match for VLAN_TAG_PRESENT bit.",
923                           (inner) ? "C-VLAN" : "VLAN");
924                 return -EINVAL;
925         }
926
927         return 1;
928 }
929
930 static int __parse_vlan_from_nlattrs(struct sw_flow_match *match,
931                                      u64 *key_attrs, bool inner,
932                                      const struct nlattr **a, bool is_mask,
933                                      bool log)
934 {
935         int err;
936         const struct nlattr *encap;
937
938         if (!is_mask)
939                 err = validate_vlan_from_nlattrs(match, *key_attrs, inner,
940                                                  a, log);
941         else
942                 err = validate_vlan_mask_from_nlattrs(match, *key_attrs, inner,
943                                                       a, log);
944         if (err <= 0)
945                 return err;
946
947         err = encode_vlan_from_nlattrs(match, a, is_mask, inner);
948         if (err)
949                 return err;
950
951         *key_attrs &= ~(1 << OVS_KEY_ATTR_ENCAP);
952         *key_attrs &= ~(1 << OVS_KEY_ATTR_VLAN);
953         *key_attrs &= ~(1 << OVS_KEY_ATTR_ETHERTYPE);
954
955         encap = a[OVS_KEY_ATTR_ENCAP];
956
957         if (!is_mask)
958                 err = parse_flow_nlattrs(encap, a, key_attrs, log);
959         else
960                 err = parse_flow_mask_nlattrs(encap, a, key_attrs, log);
961
962         return err;
963 }
964
965 static int parse_vlan_from_nlattrs(struct sw_flow_match *match,
966                                    u64 *key_attrs, const struct nlattr **a,
967                                    bool is_mask, bool log)
968 {
969         int err;
970         bool encap_valid = false;
971
972         err = __parse_vlan_from_nlattrs(match, key_attrs, false, a,
973                                         is_mask, log);
974         if (err)
975                 return err;
976
977         encap_valid = !!(match->key->eth.vlan.tci & htons(VLAN_TAG_PRESENT));
978         if (encap_valid) {
979                 err = __parse_vlan_from_nlattrs(match, key_attrs, true, a,
980                                                 is_mask, log);
981                 if (err)
982                         return err;
983         }
984
985         return 0;
986 }
987
988 static int parse_eth_type_from_nlattrs(struct sw_flow_match *match,
989                                        u64 *attrs, const struct nlattr **a,
990                                        bool is_mask, bool log)
991 {
992         __be16 eth_type;
993
994         eth_type = nla_get_be16(a[OVS_KEY_ATTR_ETHERTYPE]);
995         if (is_mask) {
996                 /* Always exact match EtherType. */
997                 eth_type = htons(0xffff);
998         } else if (!eth_proto_is_802_3(eth_type)) {
999                 OVS_NLERR(log, "EtherType %x is less than min %x",
1000                                 ntohs(eth_type), ETH_P_802_3_MIN);
1001                 return -EINVAL;
1002         }
1003
1004         SW_FLOW_KEY_PUT(match, eth.type, eth_type, is_mask);
1005         *attrs &= ~(1 << OVS_KEY_ATTR_ETHERTYPE);
1006         return 0;
1007 }
1008
1009 static int metadata_from_nlattrs(struct net *net, struct sw_flow_match *match,
1010                                  u64 *attrs, const struct nlattr **a,
1011                                  bool is_mask, bool log)
1012 {
1013         u8 mac_proto = MAC_PROTO_ETHERNET;
1014
1015         if (*attrs & (1 << OVS_KEY_ATTR_DP_HASH)) {
1016                 u32 hash_val = nla_get_u32(a[OVS_KEY_ATTR_DP_HASH]);
1017
1018                 SW_FLOW_KEY_PUT(match, ovs_flow_hash, hash_val, is_mask);
1019                 *attrs &= ~(1 << OVS_KEY_ATTR_DP_HASH);
1020         }
1021
1022         if (*attrs & (1 << OVS_KEY_ATTR_RECIRC_ID)) {
1023                 u32 recirc_id = nla_get_u32(a[OVS_KEY_ATTR_RECIRC_ID]);
1024
1025                 SW_FLOW_KEY_PUT(match, recirc_id, recirc_id, is_mask);
1026                 *attrs &= ~(1 << OVS_KEY_ATTR_RECIRC_ID);
1027         }
1028
1029         if (*attrs & (1 << OVS_KEY_ATTR_PRIORITY)) {
1030                 SW_FLOW_KEY_PUT(match, phy.priority,
1031                           nla_get_u32(a[OVS_KEY_ATTR_PRIORITY]), is_mask);
1032                 *attrs &= ~(1 << OVS_KEY_ATTR_PRIORITY);
1033         }
1034
1035         if (*attrs & (1 << OVS_KEY_ATTR_IN_PORT)) {
1036                 u32 in_port = nla_get_u32(a[OVS_KEY_ATTR_IN_PORT]);
1037
1038                 if (is_mask) {
1039                         in_port = 0xffffffff; /* Always exact match in_port. */
1040                 } else if (in_port >= DP_MAX_PORTS) {
1041                         OVS_NLERR(log, "Port %d exceeds max allowable %d",
1042                                   in_port, DP_MAX_PORTS);
1043                         return -EINVAL;
1044                 }
1045
1046                 SW_FLOW_KEY_PUT(match, phy.in_port, in_port, is_mask);
1047                 *attrs &= ~(1 << OVS_KEY_ATTR_IN_PORT);
1048         } else if (!is_mask) {
1049                 SW_FLOW_KEY_PUT(match, phy.in_port, DP_MAX_PORTS, is_mask);
1050         }
1051
1052         if (*attrs & (1 << OVS_KEY_ATTR_SKB_MARK)) {
1053                 uint32_t mark = nla_get_u32(a[OVS_KEY_ATTR_SKB_MARK]);
1054
1055                 SW_FLOW_KEY_PUT(match, phy.skb_mark, mark, is_mask);
1056                 *attrs &= ~(1 << OVS_KEY_ATTR_SKB_MARK);
1057         }
1058         if (*attrs & (1 << OVS_KEY_ATTR_TUNNEL)) {
1059                 if (ip_tun_from_nlattr(a[OVS_KEY_ATTR_TUNNEL], match,
1060                                        is_mask, log) < 0)
1061                         return -EINVAL;
1062                 *attrs &= ~(1 << OVS_KEY_ATTR_TUNNEL);
1063         }
1064
1065         if (*attrs & (1 << OVS_KEY_ATTR_CT_STATE) &&
1066             ovs_ct_verify(net, OVS_KEY_ATTR_CT_STATE)) {
1067                 u32 ct_state = nla_get_u32(a[OVS_KEY_ATTR_CT_STATE]);
1068
1069                 if (ct_state & ~CT_SUPPORTED_MASK) {
1070                         OVS_NLERR(log, "ct_state flags %08x unsupported",
1071                                   ct_state);
1072                         return -EINVAL;
1073                 }
1074
1075                 SW_FLOW_KEY_PUT(match, ct_state, ct_state, is_mask);
1076                 *attrs &= ~(1ULL << OVS_KEY_ATTR_CT_STATE);
1077         }
1078         if (*attrs & (1 << OVS_KEY_ATTR_CT_ZONE) &&
1079             ovs_ct_verify(net, OVS_KEY_ATTR_CT_ZONE)) {
1080                 u16 ct_zone = nla_get_u16(a[OVS_KEY_ATTR_CT_ZONE]);
1081
1082                 SW_FLOW_KEY_PUT(match, ct_zone, ct_zone, is_mask);
1083                 *attrs &= ~(1ULL << OVS_KEY_ATTR_CT_ZONE);
1084         }
1085         if (*attrs & (1 << OVS_KEY_ATTR_CT_MARK) &&
1086             ovs_ct_verify(net, OVS_KEY_ATTR_CT_MARK)) {
1087                 u32 mark = nla_get_u32(a[OVS_KEY_ATTR_CT_MARK]);
1088
1089                 SW_FLOW_KEY_PUT(match, ct.mark, mark, is_mask);
1090                 *attrs &= ~(1ULL << OVS_KEY_ATTR_CT_MARK);
1091         }
1092         if (*attrs & (1 << OVS_KEY_ATTR_CT_LABELS) &&
1093             ovs_ct_verify(net, OVS_KEY_ATTR_CT_LABELS)) {
1094                 const struct ovs_key_ct_labels *cl;
1095
1096                 cl = nla_data(a[OVS_KEY_ATTR_CT_LABELS]);
1097                 SW_FLOW_KEY_MEMCPY(match, ct.labels, cl->ct_labels,
1098                                    sizeof(*cl), is_mask);
1099                 *attrs &= ~(1ULL << OVS_KEY_ATTR_CT_LABELS);
1100         }
1101         if (*attrs & (1ULL << OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4)) {
1102                 const struct ovs_key_ct_tuple_ipv4 *ct;
1103
1104                 ct = nla_data(a[OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4]);
1105
1106                 SW_FLOW_KEY_PUT(match, ipv4.ct_orig.src, ct->ipv4_src, is_mask);
1107                 SW_FLOW_KEY_PUT(match, ipv4.ct_orig.dst, ct->ipv4_dst, is_mask);
1108                 SW_FLOW_KEY_PUT(match, ct.orig_tp.src, ct->src_port, is_mask);
1109                 SW_FLOW_KEY_PUT(match, ct.orig_tp.dst, ct->dst_port, is_mask);
1110                 SW_FLOW_KEY_PUT(match, ct_orig_proto, ct->ipv4_proto, is_mask);
1111                 *attrs &= ~(1ULL << OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV4);
1112         }
1113         if (*attrs & (1ULL << OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6)) {
1114                 const struct ovs_key_ct_tuple_ipv6 *ct;
1115
1116                 ct = nla_data(a[OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6]);
1117
1118                 SW_FLOW_KEY_MEMCPY(match, ipv6.ct_orig.src, &ct->ipv6_src,
1119                                    sizeof(match->key->ipv6.ct_orig.src),
1120                                    is_mask);
1121                 SW_FLOW_KEY_MEMCPY(match, ipv6.ct_orig.dst, &ct->ipv6_dst,
1122                                    sizeof(match->key->ipv6.ct_orig.dst),
1123                                    is_mask);
1124                 SW_FLOW_KEY_PUT(match, ct.orig_tp.src, ct->src_port, is_mask);
1125                 SW_FLOW_KEY_PUT(match, ct.orig_tp.dst, ct->dst_port, is_mask);
1126                 SW_FLOW_KEY_PUT(match, ct_orig_proto, ct->ipv6_proto, is_mask);
1127                 *attrs &= ~(1ULL << OVS_KEY_ATTR_CT_ORIG_TUPLE_IPV6);
1128         }
1129
1130         /* For layer 3 packets the Ethernet type is provided
1131          * and treated as metadata but no MAC addresses are provided.
1132          */
1133         if (!(*attrs & (1ULL << OVS_KEY_ATTR_ETHERNET)) &&
1134             (*attrs & (1ULL << OVS_KEY_ATTR_ETHERTYPE)))
1135                 mac_proto = MAC_PROTO_NONE;
1136
1137         /* Always exact match mac_proto */
1138         SW_FLOW_KEY_PUT(match, mac_proto, is_mask ? 0xff : mac_proto, is_mask);
1139
1140         if (mac_proto == MAC_PROTO_NONE)
1141                 return parse_eth_type_from_nlattrs(match, attrs, a, is_mask,
1142                                                    log);
1143
1144         return 0;
1145 }
1146
1147 static int ovs_key_from_nlattrs(struct net *net, struct sw_flow_match *match,
1148                                 u64 attrs, const struct nlattr **a,
1149                                 bool is_mask, bool log)
1150 {
1151         int err;
1152
1153         err = metadata_from_nlattrs(net, match, &attrs, a, is_mask, log);
1154         if (err)
1155                 return err;
1156
1157         if (attrs & (1 << OVS_KEY_ATTR_ETHERNET)) {
1158                 const struct ovs_key_ethernet *eth_key;
1159
1160                 eth_key = nla_data(a[OVS_KEY_ATTR_ETHERNET]);
1161                 SW_FLOW_KEY_MEMCPY(match, eth.src,
1162                                 eth_key->eth_src, ETH_ALEN, is_mask);
1163                 SW_FLOW_KEY_MEMCPY(match, eth.dst,
1164                                 eth_key->eth_dst, ETH_ALEN, is_mask);
1165                 attrs &= ~(1 << OVS_KEY_ATTR_ETHERNET);
1166
1167                 if (attrs & (1 << OVS_KEY_ATTR_VLAN)) {
1168                         /* VLAN attribute is always parsed before getting here since it
1169                          * may occur multiple times.
1170                          */
1171                         OVS_NLERR(log, "VLAN attribute unexpected.");
1172                         return -EINVAL;
1173                 }
1174
1175                 if (attrs & (1 << OVS_KEY_ATTR_ETHERTYPE)) {
1176                         err = parse_eth_type_from_nlattrs(match, &attrs, a, is_mask,
1177                                                           log);
1178                         if (err)
1179                                 return err;
1180                 } else if (!is_mask) {
1181                         SW_FLOW_KEY_PUT(match, eth.type, htons(ETH_P_802_2), is_mask);
1182                 }
1183         } else if (!match->key->eth.type) {
1184                 OVS_NLERR(log, "Either Ethernet header or EtherType is required.");
1185                 return -EINVAL;
1186         }
1187
1188         if (attrs & (1 << OVS_KEY_ATTR_IPV4)) {
1189                 const struct ovs_key_ipv4 *ipv4_key;
1190
1191                 ipv4_key = nla_data(a[OVS_KEY_ATTR_IPV4]);
1192                 if (!is_mask && ipv4_key->ipv4_frag > OVS_FRAG_TYPE_MAX) {
1193                         OVS_NLERR(log, "IPv4 frag type %d is out of range max %d",
1194                                   ipv4_key->ipv4_frag, OVS_FRAG_TYPE_MAX);
1195                         return -EINVAL;
1196                 }
1197                 SW_FLOW_KEY_PUT(match, ip.proto,
1198                                 ipv4_key->ipv4_proto, is_mask);
1199                 SW_FLOW_KEY_PUT(match, ip.tos,
1200                                 ipv4_key->ipv4_tos, is_mask);
1201                 SW_FLOW_KEY_PUT(match, ip.ttl,
1202                                 ipv4_key->ipv4_ttl, is_mask);
1203                 SW_FLOW_KEY_PUT(match, ip.frag,
1204                                 ipv4_key->ipv4_frag, is_mask);
1205                 SW_FLOW_KEY_PUT(match, ipv4.addr.src,
1206                                 ipv4_key->ipv4_src, is_mask);
1207                 SW_FLOW_KEY_PUT(match, ipv4.addr.dst,
1208                                 ipv4_key->ipv4_dst, is_mask);
1209                 attrs &= ~(1 << OVS_KEY_ATTR_IPV4);
1210         }
1211
1212         if (attrs & (1 << OVS_KEY_ATTR_IPV6)) {
1213                 const struct ovs_key_ipv6 *ipv6_key;
1214
1215                 ipv6_key = nla_data(a[OVS_KEY_ATTR_IPV6]);
1216                 if (!is_mask && ipv6_key->ipv6_frag > OVS_FRAG_TYPE_MAX) {
1217                         OVS_NLERR(log, "IPv6 frag type %d is out of range max %d",
1218                                   ipv6_key->ipv6_frag, OVS_FRAG_TYPE_MAX);
1219                         return -EINVAL;
1220                 }
1221
1222                 if (!is_mask && ipv6_key->ipv6_label & htonl(0xFFF00000)) {
1223                         OVS_NLERR(log, "IPv6 flow label %x is out of range (max=%x).\n",
1224                                   ntohl(ipv6_key->ipv6_label), (1 << 20) - 1);
1225                         return -EINVAL;
1226                 }
1227
1228                 SW_FLOW_KEY_PUT(match, ipv6.label,
1229                                 ipv6_key->ipv6_label, is_mask);
1230                 SW_FLOW_KEY_PUT(match, ip.proto,
1231                                 ipv6_key->ipv6_proto, is_mask);
1232                 SW_FLOW_KEY_PUT(match, ip.tos,
1233                                 ipv6_key->ipv6_tclass, is_mask);
1234                 SW_FLOW_KEY_PUT(match, ip.ttl,
1235                                 ipv6_key->ipv6_hlimit, is_mask);
1236                 SW_FLOW_KEY_PUT(match, ip.frag,
1237                                 ipv6_key->ipv6_frag, is_mask);
1238                 SW_FLOW_KEY_MEMCPY(match, ipv6.addr.src,
1239                                 ipv6_key->ipv6_src,
1240                                 sizeof(match->key->ipv6.addr.src),
1241                                 is_mask);
1242                 SW_FLOW_KEY_MEMCPY(match, ipv6.addr.dst,
1243                                 ipv6_key->ipv6_dst,
1244                                 sizeof(match->key->ipv6.addr.dst),
1245                                 is_mask);
1246
1247                 attrs &= ~(1 << OVS_KEY_ATTR_IPV6);
1248         }
1249
1250         if (attrs & (1 << OVS_KEY_ATTR_ARP)) {
1251                 const struct ovs_key_arp *arp_key;
1252
1253                 arp_key = nla_data(a[OVS_KEY_ATTR_ARP]);
1254                 if (!is_mask && (arp_key->arp_op & htons(0xff00))) {
1255                         OVS_NLERR(log, "Unknown ARP opcode (opcode=%d).",
1256                                   arp_key->arp_op);
1257                         return -EINVAL;
1258                 }
1259
1260                 SW_FLOW_KEY_PUT(match, ipv4.addr.src,
1261                                 arp_key->arp_sip, is_mask);
1262                 SW_FLOW_KEY_PUT(match, ipv4.addr.dst,
1263                         arp_key->arp_tip, is_mask);
1264                 SW_FLOW_KEY_PUT(match, ip.proto,
1265                                 ntohs(arp_key->arp_op), is_mask);
1266                 SW_FLOW_KEY_MEMCPY(match, ipv4.arp.sha,
1267                                 arp_key->arp_sha, ETH_ALEN, is_mask);
1268                 SW_FLOW_KEY_MEMCPY(match, ipv4.arp.tha,
1269                                 arp_key->arp_tha, ETH_ALEN, is_mask);
1270
1271                 attrs &= ~(1 << OVS_KEY_ATTR_ARP);
1272         }
1273
1274         if (attrs & (1 << OVS_KEY_ATTR_MPLS)) {
1275                 const struct ovs_key_mpls *mpls_key;
1276
1277                 mpls_key = nla_data(a[OVS_KEY_ATTR_MPLS]);
1278                 SW_FLOW_KEY_PUT(match, mpls.top_lse,
1279                                 mpls_key->mpls_lse, is_mask);
1280
1281                 attrs &= ~(1 << OVS_KEY_ATTR_MPLS);
1282          }
1283
1284         if (attrs & (1 << OVS_KEY_ATTR_TCP)) {
1285                 const struct ovs_key_tcp *tcp_key;
1286
1287                 tcp_key = nla_data(a[OVS_KEY_ATTR_TCP]);
1288                 SW_FLOW_KEY_PUT(match, tp.src, tcp_key->tcp_src, is_mask);
1289                 SW_FLOW_KEY_PUT(match, tp.dst, tcp_key->tcp_dst, is_mask);
1290                 attrs &= ~(1 << OVS_KEY_ATTR_TCP);
1291         }
1292
1293         if (attrs & (1 << OVS_KEY_ATTR_TCP_FLAGS)) {
1294                 SW_FLOW_KEY_PUT(match, tp.flags,
1295                                 nla_get_be16(a[OVS_KEY_ATTR_TCP_FLAGS]),
1296                                 is_mask);
1297                 attrs &= ~(1 << OVS_KEY_ATTR_TCP_FLAGS);
1298         }
1299
1300         if (attrs & (1 << OVS_KEY_ATTR_UDP)) {
1301                 const struct ovs_key_udp *udp_key;
1302
1303                 udp_key = nla_data(a[OVS_KEY_ATTR_UDP]);
1304                 SW_FLOW_KEY_PUT(match, tp.src, udp_key->udp_src, is_mask);
1305                 SW_FLOW_KEY_PUT(match, tp.dst, udp_key->udp_dst, is_mask);
1306                 attrs &= ~(1 << OVS_KEY_ATTR_UDP);
1307         }
1308
1309         if (attrs & (1 << OVS_KEY_ATTR_SCTP)) {
1310                 const struct ovs_key_sctp *sctp_key;
1311
1312                 sctp_key = nla_data(a[OVS_KEY_ATTR_SCTP]);
1313                 SW_FLOW_KEY_PUT(match, tp.src, sctp_key->sctp_src, is_mask);
1314                 SW_FLOW_KEY_PUT(match, tp.dst, sctp_key->sctp_dst, is_mask);
1315                 attrs &= ~(1 << OVS_KEY_ATTR_SCTP);
1316         }
1317
1318         if (attrs & (1 << OVS_KEY_ATTR_ICMP)) {
1319                 const struct ovs_key_icmp *icmp_key;
1320
1321                 icmp_key = nla_data(a[OVS_KEY_ATTR_ICMP]);
1322                 SW_FLOW_KEY_PUT(match, tp.src,
1323                                 htons(icmp_key->icmp_type), is_mask);
1324                 SW_FLOW_KEY_PUT(match, tp.dst,
1325                                 htons(icmp_key->icmp_code), is_mask);
1326                 attrs &= ~(1 << OVS_KEY_ATTR_ICMP);
1327         }
1328
1329         if (attrs & (1 << OVS_KEY_ATTR_ICMPV6)) {
1330                 const struct ovs_key_icmpv6 *icmpv6_key;
1331
1332                 icmpv6_key = nla_data(a[OVS_KEY_ATTR_ICMPV6]);
1333                 SW_FLOW_KEY_PUT(match, tp.src,
1334                                 htons(icmpv6_key->icmpv6_type), is_mask);
1335                 SW_FLOW_KEY_PUT(match, tp.dst,
1336                                 htons(icmpv6_key->icmpv6_code), is_mask);
1337                 attrs &= ~(1 << OVS_KEY_ATTR_ICMPV6);
1338         }
1339
1340         if (attrs & (1 << OVS_KEY_ATTR_ND)) {
1341                 const struct ovs_key_nd *nd_key;
1342
1343                 nd_key = nla_data(a[OVS_KEY_ATTR_ND]);
1344                 SW_FLOW_KEY_MEMCPY(match, ipv6.nd.target,
1345                         nd_key->nd_target,
1346                         sizeof(match->key->ipv6.nd.target),
1347                         is_mask);
1348                 SW_FLOW_KEY_MEMCPY(match, ipv6.nd.sll,
1349                         nd_key->nd_sll, ETH_ALEN, is_mask);
1350                 SW_FLOW_KEY_MEMCPY(match, ipv6.nd.tll,
1351                                 nd_key->nd_tll, ETH_ALEN, is_mask);
1352                 attrs &= ~(1 << OVS_KEY_ATTR_ND);
1353         }
1354
1355         if (attrs != 0) {
1356                 OVS_NLERR(log, "Unknown key attributes %llx",
1357                           (unsigned long long)attrs);
1358                 return -EINVAL;
1359         }
1360
1361         return 0;
1362 }
1363
1364 static void nlattr_set(struct nlattr *attr, u8 val,
1365                        const struct ovs_len_tbl *tbl)
1366 {
1367         struct nlattr *nla;
1368         int rem;
1369
1370         /* The nlattr stream should already have been validated */
1371         nla_for_each_nested(nla, attr, rem) {
1372                 if (tbl[nla_type(nla)].len == OVS_ATTR_NESTED) {
1373                         if (tbl[nla_type(nla)].next)
1374                                 tbl = tbl[nla_type(nla)].next;
1375                         nlattr_set(nla, val, tbl);
1376                 } else {
1377                         memset(nla_data(nla), val, nla_len(nla));
1378                 }
1379
1380                 if (nla_type(nla) == OVS_KEY_ATTR_CT_STATE)
1381                         *(u32 *)nla_data(nla) &= CT_SUPPORTED_MASK;
1382         }
1383 }
1384
1385 static void mask_set_nlattr(struct nlattr *attr, u8 val)
1386 {
1387         nlattr_set(attr, val, ovs_key_lens);
1388 }
1389
1390 /**
1391  * ovs_nla_get_match - parses Netlink attributes into a flow key and
1392  * mask. In case the 'mask' is NULL, the flow is treated as exact match
1393  * flow. Otherwise, it is treated as a wildcarded flow, except the mask
1394  * does not include any don't care bit.
1395  * @net: Used to determine per-namespace field support.
1396  * @match: receives the extracted flow match information.
1397  * @key: Netlink attribute holding nested %OVS_KEY_ATTR_* Netlink attribute
1398  * sequence. The fields should of the packet that triggered the creation
1399  * of this flow.
1400  * @mask: Optional. Netlink attribute holding nested %OVS_KEY_ATTR_* Netlink
1401  * attribute specifies the mask field of the wildcarded flow.
1402  * @log: Boolean to allow kernel error logging.  Normally true, but when
1403  * probing for feature compatibility this should be passed in as false to
1404  * suppress unnecessary error logging.
1405  */
1406 int ovs_nla_get_match(struct net *net, struct sw_flow_match *match,
1407                       const struct nlattr *nla_key,
1408                       const struct nlattr *nla_mask,
1409                       bool log)
1410 {
1411         const struct nlattr *a[OVS_KEY_ATTR_MAX + 1];
1412         struct nlattr *newmask = NULL;
1413         u64 key_attrs = 0;
1414         u64 mask_attrs = 0;
1415         int err;
1416
1417         err = parse_flow_nlattrs(nla_key, a, &key_attrs, log);
1418         if (err)
1419                 return err;
1420
1421         err = parse_vlan_from_nlattrs(match, &key_attrs, a, false, log);
1422         if (err)
1423                 return err;
1424
1425         err = ovs_key_from_nlattrs(net, match, key_attrs, a, false, log);
1426         if (err)
1427                 return err;
1428
1429         if (match->mask) {
1430                 if (!nla_mask) {
1431                         /* Create an exact match mask. We need to set to 0xff
1432                          * all the 'match->mask' fields that have been touched
1433                          * in 'match->key'. We cannot simply memset
1434                          * 'match->mask', because padding bytes and fields not
1435                          * specified in 'match->key' should be left to 0.
1436                          * Instead, we use a stream of netlink attributes,
1437                          * copied from 'key' and set to 0xff.
1438                          * ovs_key_from_nlattrs() will take care of filling
1439                          * 'match->mask' appropriately.
1440                          */
1441                         newmask = kmemdup(nla_key,
1442                                           nla_total_size(nla_len(nla_key)),
1443                                           GFP_KERNEL);
1444                         if (!newmask)
1445                                 return -ENOMEM;
1446
1447                         mask_set_nlattr(newmask, 0xff);
1448
1449                         /* The userspace does not send tunnel attributes that
1450                          * are 0, but we should not wildcard them nonetheless.
1451                          */
1452                         if (match->key->tun_proto)
1453                                 SW_FLOW_KEY_MEMSET_FIELD(match, tun_key,
1454                                                          0xff, true);
1455
1456                         nla_mask = newmask;
1457                 }
1458
1459                 err = parse_flow_mask_nlattrs(nla_mask, a, &mask_attrs, log);
1460                 if (err)
1461                         goto free_newmask;
1462
1463                 /* Always match on tci. */
1464                 SW_FLOW_KEY_PUT(match, eth.vlan.tci, htons(0xffff), true);
1465                 SW_FLOW_KEY_PUT(match, eth.cvlan.tci, htons(0xffff), true);
1466
1467                 err = parse_vlan_from_nlattrs(match, &mask_attrs, a, true, log);
1468                 if (err)
1469                         goto free_newmask;
1470
1471                 err = ovs_key_from_nlattrs(net, match, mask_attrs, a, true,
1472                                            log);
1473                 if (err)
1474                         goto free_newmask;
1475         }
1476
1477         if (!match_validate(match, key_attrs, mask_attrs, log))
1478                 err = -EINVAL;
1479
1480 free_newmask:
1481         kfree(newmask);
1482         return err;
1483 }
1484
1485 static size_t get_ufid_len(const struct nlattr *attr, bool log)
1486 {
1487         size_t len;
1488
1489         if (!attr)
1490                 return 0;
1491
1492         len = nla_len(attr);
1493         if (len < 1 || len > MAX_UFID_LENGTH) {
1494                 OVS_NLERR(log, "ufid size %u bytes exceeds the range (1, %d)",
1495                           nla_len(attr), MAX_UFID_LENGTH);
1496                 return 0;
1497         }
1498
1499         return len;
1500 }
1501
1502 /* Initializes 'flow->ufid', returning true if 'attr' contains a valid UFID,
1503  * or false otherwise.
1504  */
1505 bool ovs_nla_get_ufid(struct sw_flow_id *sfid, const struct nlattr *attr,
1506                       bool log)
1507 {
1508         sfid->ufid_len = get_ufid_len(attr, log);
1509         if (sfid->ufid_len)
1510                 memcpy(sfid->ufid, nla_data(attr), sfid->ufid_len);
1511
1512         return sfid->ufid_len;
1513 }
1514
1515 int ovs_nla_get_identifier(struct sw_flow_id *sfid, const struct nlattr *ufid,
1516                            const struct sw_flow_key *key, bool log)
1517 {
1518         struct sw_flow_key *new_key;
1519
1520         if (ovs_nla_get_ufid(sfid, ufid, log))
1521                 return 0;
1522
1523         /* If UFID was not provided, use unmasked key. */
1524         new_key = kmalloc(sizeof(*new_key), GFP_KERNEL);
1525         if (!new_key)
1526                 return -ENOMEM;
1527         memcpy(new_key, key, sizeof(*key));
1528         sfid->unmasked_key = new_key;
1529
1530         return 0;
1531 }
1532
1533 u32 ovs_nla_get_ufid_flags(const struct nlattr *attr)
1534 {
1535         return attr ? nla_get_u32(attr) : 0;
1536 }
1537
1538 /**
1539  * ovs_nla_get_flow_metadata - parses Netlink attributes into a flow key.
1540  * @net: Network namespace.
1541  * @key: Receives extracted in_port, priority, tun_key, skb_mark and conntrack
1542  * metadata.
1543  * @a: Array of netlink attributes holding parsed %OVS_KEY_ATTR_* Netlink
1544  * attributes.
1545  * @attrs: Bit mask for the netlink attributes included in @a.
1546  * @log: Boolean to allow kernel error logging.  Normally true, but when
1547  * probing for feature compatibility this should be passed in as false to
1548  * suppress unnecessary error logging.
1549  *
1550  * This parses a series of Netlink attributes that form a flow key, which must
1551  * take the same form accepted by flow_from_nlattrs(), but only enough of it to
1552  * get the metadata, that is, the parts of the flow key that cannot be
1553  * extracted from the packet itself.
1554  *
1555  * This must be called before the packet key fields are filled in 'key'.
1556  */
1557
1558 int ovs_nla_get_flow_metadata(struct net *net,
1559                               const struct nlattr *a[OVS_KEY_ATTR_MAX + 1],
1560                               u64 attrs, struct sw_flow_key *key, bool log)
1561 {
1562         struct sw_flow_match match;
1563
1564         memset(&match, 0, sizeof(match));
1565         match.key = key;
1566
1567         key->ct_state = 0;
1568         key->ct_zone = 0;
1569         key->ct_orig_proto = 0;
1570         memset(&key->ct, 0, sizeof(key->ct));
1571         memset(&key->ipv4.ct_orig, 0, sizeof(key->ipv4.ct_orig));
1572         memset(&key->ipv6.ct_orig, 0, sizeof(key->ipv6.ct_orig));
1573
1574         key->phy.in_port = DP_MAX_PORTS;
1575
1576         return metadata_from_nlattrs(net, &match, &attrs, a, false, log);
1577 }
1578
1579 static int ovs_nla_put_vlan(struct sk_buff *skb, const struct vlan_head *vh,
1580                             bool is_mask)
1581 {
1582         __be16 eth_type = !is_mask ? vh->tpid : htons(0xffff);
1583
1584         if (nla_put_be16(skb, OVS_KEY_ATTR_ETHERTYPE, eth_type) ||
1585             nla_put_be16(skb, OVS_KEY_ATTR_VLAN, vh->tci))
1586                 return -EMSGSIZE;
1587         return 0;
1588 }
1589
1590 static int __ovs_nla_put_key(const struct sw_flow_key *swkey,
1591                              const struct sw_flow_key *output, bool is_mask,
1592                              struct sk_buff *skb)
1593 {
1594         struct ovs_key_ethernet *eth_key;
1595         struct nlattr *nla;
1596         struct nlattr *encap = NULL;
1597         struct nlattr *in_encap = NULL;
1598
1599         if (nla_put_u32(skb, OVS_KEY_ATTR_RECIRC_ID, output->recirc_id))
1600                 goto nla_put_failure;
1601
1602         if (nla_put_u32(skb, OVS_KEY_ATTR_DP_HASH, output->ovs_flow_hash))
1603                 goto nla_put_failure;
1604
1605         if (nla_put_u32(skb, OVS_KEY_ATTR_PRIORITY, output->phy.priority))
1606                 goto nla_put_failure;
1607
1608         if ((swkey->tun_proto || is_mask)) {
1609                 const void *opts = NULL;
1610
1611                 if (output->tun_key.tun_flags & TUNNEL_OPTIONS_PRESENT)
1612                         opts = TUN_METADATA_OPTS(output, swkey->tun_opts_len);
1613
1614                 if (ip_tun_to_nlattr(skb, &output->tun_key, opts,
1615                                      swkey->tun_opts_len, swkey->tun_proto))
1616                         goto nla_put_failure;
1617         }
1618
1619         if (swkey->phy.in_port == DP_MAX_PORTS) {
1620                 if (is_mask && (output->phy.in_port == 0xffff))
1621                         if (nla_put_u32(skb, OVS_KEY_ATTR_IN_PORT, 0xffffffff))
1622                                 goto nla_put_failure;
1623         } else {
1624                 u16 upper_u16;
1625                 upper_u16 = !is_mask ? 0 : 0xffff;
1626
1627                 if (nla_put_u32(skb, OVS_KEY_ATTR_IN_PORT,
1628                                 (upper_u16 << 16) | output->phy.in_port))
1629                         goto nla_put_failure;
1630         }
1631
1632         if (nla_put_u32(skb, OVS_KEY_ATTR_SKB_MARK, output->phy.skb_mark))
1633                 goto nla_put_failure;
1634
1635         if (ovs_ct_put_key(swkey, output, skb))
1636                 goto nla_put_failure;
1637
1638         if (ovs_key_mac_proto(swkey) == MAC_PROTO_ETHERNET) {
1639                 nla = nla_reserve(skb, OVS_KEY_ATTR_ETHERNET, sizeof(*eth_key));
1640                 if (!nla)
1641                         goto nla_put_failure;
1642
1643                 eth_key = nla_data(nla);
1644                 ether_addr_copy(eth_key->eth_src, output->eth.src);
1645                 ether_addr_copy(eth_key->eth_dst, output->eth.dst);
1646
1647                 if (swkey->eth.vlan.tci || eth_type_vlan(swkey->eth.type)) {
1648                         if (ovs_nla_put_vlan(skb, &output->eth.vlan, is_mask))
1649                                 goto nla_put_failure;
1650                         encap = nla_nest_start(skb, OVS_KEY_ATTR_ENCAP);
1651                         if (!swkey->eth.vlan.tci)
1652                                 goto unencap;
1653
1654                         if (swkey->eth.cvlan.tci || eth_type_vlan(swkey->eth.type)) {
1655                                 if (ovs_nla_put_vlan(skb, &output->eth.cvlan, is_mask))
1656                                         goto nla_put_failure;
1657                                 in_encap = nla_nest_start(skb, OVS_KEY_ATTR_ENCAP);
1658                                 if (!swkey->eth.cvlan.tci)
1659                                         goto unencap;
1660                         }
1661                 }
1662
1663                 if (swkey->eth.type == htons(ETH_P_802_2)) {
1664                         /*
1665                         * Ethertype 802.2 is represented in the netlink with omitted
1666                         * OVS_KEY_ATTR_ETHERTYPE in the flow key attribute, and
1667                         * 0xffff in the mask attribute.  Ethertype can also
1668                         * be wildcarded.
1669                         */
1670                         if (is_mask && output->eth.type)
1671                                 if (nla_put_be16(skb, OVS_KEY_ATTR_ETHERTYPE,
1672                                                         output->eth.type))
1673                                         goto nla_put_failure;
1674                         goto unencap;
1675                 }
1676         }
1677
1678         if (nla_put_be16(skb, OVS_KEY_ATTR_ETHERTYPE, output->eth.type))
1679                 goto nla_put_failure;
1680
1681         if (eth_type_vlan(swkey->eth.type)) {
1682                 /* There are 3 VLAN tags, we don't know anything about the rest
1683                  * of the packet, so truncate here.
1684                  */
1685                 WARN_ON_ONCE(!(encap && in_encap));
1686                 goto unencap;
1687         }
1688
1689         if (swkey->eth.type == htons(ETH_P_IP)) {
1690                 struct ovs_key_ipv4 *ipv4_key;
1691
1692                 nla = nla_reserve(skb, OVS_KEY_ATTR_IPV4, sizeof(*ipv4_key));
1693                 if (!nla)
1694                         goto nla_put_failure;
1695                 ipv4_key = nla_data(nla);
1696                 ipv4_key->ipv4_src = output->ipv4.addr.src;
1697                 ipv4_key->ipv4_dst = output->ipv4.addr.dst;
1698                 ipv4_key->ipv4_proto = output->ip.proto;
1699                 ipv4_key->ipv4_tos = output->ip.tos;
1700                 ipv4_key->ipv4_ttl = output->ip.ttl;
1701                 ipv4_key->ipv4_frag = output->ip.frag;
1702         } else if (swkey->eth.type == htons(ETH_P_IPV6)) {
1703                 struct ovs_key_ipv6 *ipv6_key;
1704
1705                 nla = nla_reserve(skb, OVS_KEY_ATTR_IPV6, sizeof(*ipv6_key));
1706                 if (!nla)
1707                         goto nla_put_failure;
1708                 ipv6_key = nla_data(nla);
1709                 memcpy(ipv6_key->ipv6_src, &output->ipv6.addr.src,
1710                                 sizeof(ipv6_key->ipv6_src));
1711                 memcpy(ipv6_key->ipv6_dst, &output->ipv6.addr.dst,
1712                                 sizeof(ipv6_key->ipv6_dst));
1713                 ipv6_key->ipv6_label = output->ipv6.label;
1714                 ipv6_key->ipv6_proto = output->ip.proto;
1715                 ipv6_key->ipv6_tclass = output->ip.tos;
1716                 ipv6_key->ipv6_hlimit = output->ip.ttl;
1717                 ipv6_key->ipv6_frag = output->ip.frag;
1718         } else if (swkey->eth.type == htons(ETH_P_ARP) ||
1719                    swkey->eth.type == htons(ETH_P_RARP)) {
1720                 struct ovs_key_arp *arp_key;
1721
1722                 nla = nla_reserve(skb, OVS_KEY_ATTR_ARP, sizeof(*arp_key));
1723                 if (!nla)
1724                         goto nla_put_failure;
1725                 arp_key = nla_data(nla);
1726                 memset(arp_key, 0, sizeof(struct ovs_key_arp));
1727                 arp_key->arp_sip = output->ipv4.addr.src;
1728                 arp_key->arp_tip = output->ipv4.addr.dst;
1729                 arp_key->arp_op = htons(output->ip.proto);
1730                 ether_addr_copy(arp_key->arp_sha, output->ipv4.arp.sha);
1731                 ether_addr_copy(arp_key->arp_tha, output->ipv4.arp.tha);
1732         } else if (eth_p_mpls(swkey->eth.type)) {
1733                 struct ovs_key_mpls *mpls_key;
1734
1735                 nla = nla_reserve(skb, OVS_KEY_ATTR_MPLS, sizeof(*mpls_key));
1736                 if (!nla)
1737                         goto nla_put_failure;
1738                 mpls_key = nla_data(nla);
1739                 mpls_key->mpls_lse = output->mpls.top_lse;
1740         }
1741
1742         if ((swkey->eth.type == htons(ETH_P_IP) ||
1743              swkey->eth.type == htons(ETH_P_IPV6)) &&
1744              swkey->ip.frag != OVS_FRAG_TYPE_LATER) {
1745
1746                 if (swkey->ip.proto == IPPROTO_TCP) {
1747                         struct ovs_key_tcp *tcp_key;
1748
1749                         nla = nla_reserve(skb, OVS_KEY_ATTR_TCP, sizeof(*tcp_key));
1750                         if (!nla)
1751                                 goto nla_put_failure;
1752                         tcp_key = nla_data(nla);
1753                         tcp_key->tcp_src = output->tp.src;
1754                         tcp_key->tcp_dst = output->tp.dst;
1755                         if (nla_put_be16(skb, OVS_KEY_ATTR_TCP_FLAGS,
1756                                          output->tp.flags))
1757                                 goto nla_put_failure;
1758                 } else if (swkey->ip.proto == IPPROTO_UDP) {
1759                         struct ovs_key_udp *udp_key;
1760
1761                         nla = nla_reserve(skb, OVS_KEY_ATTR_UDP, sizeof(*udp_key));
1762                         if (!nla)
1763                                 goto nla_put_failure;
1764                         udp_key = nla_data(nla);
1765                         udp_key->udp_src = output->tp.src;
1766                         udp_key->udp_dst = output->tp.dst;
1767                 } else if (swkey->ip.proto == IPPROTO_SCTP) {
1768                         struct ovs_key_sctp *sctp_key;
1769
1770                         nla = nla_reserve(skb, OVS_KEY_ATTR_SCTP, sizeof(*sctp_key));
1771                         if (!nla)
1772                                 goto nla_put_failure;
1773                         sctp_key = nla_data(nla);
1774                         sctp_key->sctp_src = output->tp.src;
1775                         sctp_key->sctp_dst = output->tp.dst;
1776                 } else if (swkey->eth.type == htons(ETH_P_IP) &&
1777                            swkey->ip.proto == IPPROTO_ICMP) {
1778                         struct ovs_key_icmp *icmp_key;
1779
1780                         nla = nla_reserve(skb, OVS_KEY_ATTR_ICMP, sizeof(*icmp_key));
1781                         if (!nla)
1782                                 goto nla_put_failure;
1783                         icmp_key = nla_data(nla);
1784                         icmp_key->icmp_type = ntohs(output->tp.src);
1785                         icmp_key->icmp_code = ntohs(output->tp.dst);
1786                 } else if (swkey->eth.type == htons(ETH_P_IPV6) &&
1787                            swkey->ip.proto == IPPROTO_ICMPV6) {
1788                         struct ovs_key_icmpv6 *icmpv6_key;
1789
1790                         nla = nla_reserve(skb, OVS_KEY_ATTR_ICMPV6,
1791                                                 sizeof(*icmpv6_key));
1792                         if (!nla)
1793                                 goto nla_put_failure;
1794                         icmpv6_key = nla_data(nla);
1795                         icmpv6_key->icmpv6_type = ntohs(output->tp.src);
1796                         icmpv6_key->icmpv6_code = ntohs(output->tp.dst);
1797
1798                         if (icmpv6_key->icmpv6_type == NDISC_NEIGHBOUR_SOLICITATION ||
1799                             icmpv6_key->icmpv6_type == NDISC_NEIGHBOUR_ADVERTISEMENT) {
1800                                 struct ovs_key_nd *nd_key;
1801
1802                                 nla = nla_reserve(skb, OVS_KEY_ATTR_ND, sizeof(*nd_key));
1803                                 if (!nla)
1804                                         goto nla_put_failure;
1805                                 nd_key = nla_data(nla);
1806                                 memcpy(nd_key->nd_target, &output->ipv6.nd.target,
1807                                                         sizeof(nd_key->nd_target));
1808                                 ether_addr_copy(nd_key->nd_sll, output->ipv6.nd.sll);
1809                                 ether_addr_copy(nd_key->nd_tll, output->ipv6.nd.tll);
1810                         }
1811                 }
1812         }
1813
1814 unencap:
1815         if (in_encap)
1816                 nla_nest_end(skb, in_encap);
1817         if (encap)
1818                 nla_nest_end(skb, encap);
1819
1820         return 0;
1821
1822 nla_put_failure:
1823         return -EMSGSIZE;
1824 }
1825
1826 int ovs_nla_put_key(const struct sw_flow_key *swkey,
1827                     const struct sw_flow_key *output, int attr, bool is_mask,
1828                     struct sk_buff *skb)
1829 {
1830         int err;
1831         struct nlattr *nla;
1832
1833         nla = nla_nest_start(skb, attr);
1834         if (!nla)
1835                 return -EMSGSIZE;
1836         err = __ovs_nla_put_key(swkey, output, is_mask, skb);
1837         if (err)
1838                 return err;
1839         nla_nest_end(skb, nla);
1840
1841         return 0;
1842 }
1843
1844 /* Called with ovs_mutex or RCU read lock. */
1845 int ovs_nla_put_identifier(const struct sw_flow *flow, struct sk_buff *skb)
1846 {
1847         if (ovs_identifier_is_ufid(&flow->id))
1848                 return nla_put(skb, OVS_FLOW_ATTR_UFID, flow->id.ufid_len,
1849                                flow->id.ufid);
1850
1851         return ovs_nla_put_key(flow->id.unmasked_key, flow->id.unmasked_key,
1852                                OVS_FLOW_ATTR_KEY, false, skb);
1853 }
1854
1855 /* Called with ovs_mutex or RCU read lock. */
1856 int ovs_nla_put_masked_key(const struct sw_flow *flow, struct sk_buff *skb)
1857 {
1858         return ovs_nla_put_key(&flow->key, &flow->key,
1859                                 OVS_FLOW_ATTR_KEY, false, skb);
1860 }
1861
1862 /* Called with ovs_mutex or RCU read lock. */
1863 int ovs_nla_put_mask(const struct sw_flow *flow, struct sk_buff *skb)
1864 {
1865         return ovs_nla_put_key(&flow->key, &flow->mask->key,
1866                                 OVS_FLOW_ATTR_MASK, true, skb);
1867 }
1868
1869 #define MAX_ACTIONS_BUFSIZE     (32 * 1024)
1870
1871 static struct sw_flow_actions *nla_alloc_flow_actions(int size, bool log)
1872 {
1873         struct sw_flow_actions *sfa;
1874
1875         if (size > MAX_ACTIONS_BUFSIZE) {
1876                 OVS_NLERR(log, "Flow action size %u bytes exceeds max", size);
1877                 return ERR_PTR(-EINVAL);
1878         }
1879
1880         sfa = kmalloc(sizeof(*sfa) + size, GFP_KERNEL);
1881         if (!sfa)
1882                 return ERR_PTR(-ENOMEM);
1883
1884         sfa->actions_len = 0;
1885         return sfa;
1886 }
1887
1888 static void ovs_nla_free_set_action(const struct nlattr *a)
1889 {
1890         const struct nlattr *ovs_key = nla_data(a);
1891         struct ovs_tunnel_info *ovs_tun;
1892
1893         switch (nla_type(ovs_key)) {
1894         case OVS_KEY_ATTR_TUNNEL_INFO:
1895                 ovs_tun = nla_data(ovs_key);
1896                 dst_release((struct dst_entry *)ovs_tun->tun_dst);
1897                 break;
1898         }
1899 }
1900
1901 void ovs_nla_free_flow_actions(struct sw_flow_actions *sf_acts)
1902 {
1903         const struct nlattr *a;
1904         int rem;
1905
1906         if (!sf_acts)
1907                 return;
1908
1909         nla_for_each_attr(a, sf_acts->actions, sf_acts->actions_len, rem) {
1910                 switch (nla_type(a)) {
1911                 case OVS_ACTION_ATTR_SET:
1912                         ovs_nla_free_set_action(a);
1913                         break;
1914                 case OVS_ACTION_ATTR_CT:
1915                         ovs_ct_free_action(a);
1916                         break;
1917                 }
1918         }
1919
1920         kfree(sf_acts);
1921 }
1922
1923 static void __ovs_nla_free_flow_actions(struct rcu_head *head)
1924 {
1925         ovs_nla_free_flow_actions(container_of(head, struct sw_flow_actions, rcu));
1926 }
1927
1928 /* Schedules 'sf_acts' to be freed after the next RCU grace period.
1929  * The caller must hold rcu_read_lock for this to be sensible. */
1930 void ovs_nla_free_flow_actions_rcu(struct sw_flow_actions *sf_acts)
1931 {
1932         call_rcu(&sf_acts->rcu, __ovs_nla_free_flow_actions);
1933 }
1934
1935 static struct nlattr *reserve_sfa_size(struct sw_flow_actions **sfa,
1936                                        int attr_len, bool log)
1937 {
1938
1939         struct sw_flow_actions *acts;
1940         int new_acts_size;
1941         int req_size = NLA_ALIGN(attr_len);
1942         int next_offset = offsetof(struct sw_flow_actions, actions) +
1943                                         (*sfa)->actions_len;
1944
1945         if (req_size <= (ksize(*sfa) - next_offset))
1946                 goto out;
1947
1948         new_acts_size = ksize(*sfa) * 2;
1949
1950         if (new_acts_size > MAX_ACTIONS_BUFSIZE) {
1951                 if ((MAX_ACTIONS_BUFSIZE - next_offset) < req_size)
1952                         return ERR_PTR(-EMSGSIZE);
1953                 new_acts_size = MAX_ACTIONS_BUFSIZE;
1954         }
1955
1956         acts = nla_alloc_flow_actions(new_acts_size, log);
1957         if (IS_ERR(acts))
1958                 return (void *)acts;
1959
1960         memcpy(acts->actions, (*sfa)->actions, (*sfa)->actions_len);
1961         acts->actions_len = (*sfa)->actions_len;
1962         acts->orig_len = (*sfa)->orig_len;
1963         kfree(*sfa);
1964         *sfa = acts;
1965
1966 out:
1967         (*sfa)->actions_len += req_size;
1968         return  (struct nlattr *) ((unsigned char *)(*sfa) + next_offset);
1969 }
1970
1971 static struct nlattr *__add_action(struct sw_flow_actions **sfa,
1972                                    int attrtype, void *data, int len, bool log)
1973 {
1974         struct nlattr *a;
1975
1976         a = reserve_sfa_size(sfa, nla_attr_size(len), log);
1977         if (IS_ERR(a))
1978                 return a;
1979
1980         a->nla_type = attrtype;
1981         a->nla_len = nla_attr_size(len);
1982
1983         if (data)
1984                 memcpy(nla_data(a), data, len);
1985         memset((unsigned char *) a + a->nla_len, 0, nla_padlen(len));
1986
1987         return a;
1988 }
1989
1990 int ovs_nla_add_action(struct sw_flow_actions **sfa, int attrtype, void *data,
1991                        int len, bool log)
1992 {
1993         struct nlattr *a;
1994
1995         a = __add_action(sfa, attrtype, data, len, log);
1996
1997         return PTR_ERR_OR_ZERO(a);
1998 }
1999
2000 static inline int add_nested_action_start(struct sw_flow_actions **sfa,
2001                                           int attrtype, bool log)
2002 {
2003         int used = (*sfa)->actions_len;
2004         int err;
2005
2006         err = ovs_nla_add_action(sfa, attrtype, NULL, 0, log);
2007         if (err)
2008                 return err;
2009
2010         return used;
2011 }
2012
2013 static inline void add_nested_action_end(struct sw_flow_actions *sfa,
2014                                          int st_offset)
2015 {
2016         struct nlattr *a = (struct nlattr *) ((unsigned char *)sfa->actions +
2017                                                                st_offset);
2018
2019         a->nla_len = sfa->actions_len - st_offset;
2020 }
2021
2022 static int __ovs_nla_copy_actions(struct net *net, const struct nlattr *attr,
2023                                   const struct sw_flow_key *key,
2024                                   int depth, struct sw_flow_actions **sfa,
2025                                   __be16 eth_type, __be16 vlan_tci, bool log);
2026
2027 static int validate_and_copy_sample(struct net *net, const struct nlattr *attr,
2028                                     const struct sw_flow_key *key, int depth,
2029                                     struct sw_flow_actions **sfa,
2030                                     __be16 eth_type, __be16 vlan_tci, bool log)
2031 {
2032         const struct nlattr *attrs[OVS_SAMPLE_ATTR_MAX + 1];
2033         const struct nlattr *probability, *actions;
2034         const struct nlattr *a;
2035         int rem, start, err, st_acts;
2036
2037         memset(attrs, 0, sizeof(attrs));
2038         nla_for_each_nested(a, attr, rem) {
2039                 int type = nla_type(a);
2040                 if (!type || type > OVS_SAMPLE_ATTR_MAX || attrs[type])
2041                         return -EINVAL;
2042                 attrs[type] = a;
2043         }
2044         if (rem)
2045                 return -EINVAL;
2046
2047         probability = attrs[OVS_SAMPLE_ATTR_PROBABILITY];
2048         if (!probability || nla_len(probability) != sizeof(u32))
2049                 return -EINVAL;
2050
2051         actions = attrs[OVS_SAMPLE_ATTR_ACTIONS];
2052         if (!actions || (nla_len(actions) && nla_len(actions) < NLA_HDRLEN))
2053                 return -EINVAL;
2054
2055         /* validation done, copy sample action. */
2056         start = add_nested_action_start(sfa, OVS_ACTION_ATTR_SAMPLE, log);
2057         if (start < 0)
2058                 return start;
2059         err = ovs_nla_add_action(sfa, OVS_SAMPLE_ATTR_PROBABILITY,
2060                                  nla_data(probability), sizeof(u32), log);
2061         if (err)
2062                 return err;
2063         st_acts = add_nested_action_start(sfa, OVS_SAMPLE_ATTR_ACTIONS, log);
2064         if (st_acts < 0)
2065                 return st_acts;
2066
2067         err = __ovs_nla_copy_actions(net, actions, key, depth + 1, sfa,
2068                                      eth_type, vlan_tci, log);
2069         if (err)
2070                 return err;
2071
2072         add_nested_action_end(*sfa, st_acts);
2073         add_nested_action_end(*sfa, start);
2074
2075         return 0;
2076 }
2077
2078 void ovs_match_init(struct sw_flow_match *match,
2079                     struct sw_flow_key *key,
2080                     bool reset_key,
2081                     struct sw_flow_mask *mask)
2082 {
2083         memset(match, 0, sizeof(*match));
2084         match->key = key;
2085         match->mask = mask;
2086
2087         if (reset_key)
2088                 memset(key, 0, sizeof(*key));
2089
2090         if (mask) {
2091                 memset(&mask->key, 0, sizeof(mask->key));
2092                 mask->range.start = mask->range.end = 0;
2093         }
2094 }
2095
2096 static int validate_geneve_opts(struct sw_flow_key *key)
2097 {
2098         struct geneve_opt *option;
2099         int opts_len = key->tun_opts_len;
2100         bool crit_opt = false;
2101
2102         option = (struct geneve_opt *)TUN_METADATA_OPTS(key, key->tun_opts_len);
2103         while (opts_len > 0) {
2104                 int len;
2105
2106                 if (opts_len < sizeof(*option))
2107                         return -EINVAL;
2108
2109                 len = sizeof(*option) + option->length * 4;
2110                 if (len > opts_len)
2111                         return -EINVAL;
2112
2113                 crit_opt |= !!(option->type & GENEVE_CRIT_OPT_TYPE);
2114
2115                 option = (struct geneve_opt *)((u8 *)option + len);
2116                 opts_len -= len;
2117         };
2118
2119         key->tun_key.tun_flags |= crit_opt ? TUNNEL_CRIT_OPT : 0;
2120
2121         return 0;
2122 }
2123
2124 static int validate_and_copy_set_tun(const struct nlattr *attr,
2125                                      struct sw_flow_actions **sfa, bool log)
2126 {
2127         struct sw_flow_match match;
2128         struct sw_flow_key key;
2129         struct metadata_dst *tun_dst;
2130         struct ip_tunnel_info *tun_info;
2131         struct ovs_tunnel_info *ovs_tun;
2132         struct nlattr *a;
2133         int err = 0, start, opts_type;
2134
2135         ovs_match_init(&match, &key, true, NULL);
2136         opts_type = ip_tun_from_nlattr(nla_data(attr), &match, false, log);
2137         if (opts_type < 0)
2138                 return opts_type;
2139
2140         if (key.tun_opts_len) {
2141                 switch (opts_type) {
2142                 case OVS_TUNNEL_KEY_ATTR_GENEVE_OPTS:
2143                         err = validate_geneve_opts(&key);
2144                         if (err < 0)
2145                                 return err;
2146                         break;
2147                 case OVS_TUNNEL_KEY_ATTR_VXLAN_OPTS:
2148                         break;
2149                 }
2150         };
2151
2152         start = add_nested_action_start(sfa, OVS_ACTION_ATTR_SET, log);
2153         if (start < 0)
2154                 return start;
2155
2156         tun_dst = metadata_dst_alloc(key.tun_opts_len, GFP_KERNEL);
2157         if (!tun_dst)
2158                 return -ENOMEM;
2159
2160         err = dst_cache_init(&tun_dst->u.tun_info.dst_cache, GFP_KERNEL);
2161         if (err) {
2162                 dst_release((struct dst_entry *)tun_dst);
2163                 return err;
2164         }
2165
2166         a = __add_action(sfa, OVS_KEY_ATTR_TUNNEL_INFO, NULL,
2167                          sizeof(*ovs_tun), log);
2168         if (IS_ERR(a)) {
2169                 dst_release((struct dst_entry *)tun_dst);
2170                 return PTR_ERR(a);
2171         }
2172
2173         ovs_tun = nla_data(a);
2174         ovs_tun->tun_dst = tun_dst;
2175
2176         tun_info = &tun_dst->u.tun_info;
2177         tun_info->mode = IP_TUNNEL_INFO_TX;
2178         if (key.tun_proto == AF_INET6)
2179                 tun_info->mode |= IP_TUNNEL_INFO_IPV6;
2180         tun_info->key = key.tun_key;
2181
2182         /* We need to store the options in the action itself since
2183          * everything else will go away after flow setup. We can append
2184          * it to tun_info and then point there.
2185          */
2186         ip_tunnel_info_opts_set(tun_info,
2187                                 TUN_METADATA_OPTS(&key, key.tun_opts_len),
2188                                 key.tun_opts_len);
2189         add_nested_action_end(*sfa, start);
2190
2191         return err;
2192 }
2193
2194 /* Return false if there are any non-masked bits set.
2195  * Mask follows data immediately, before any netlink padding.
2196  */
2197 static bool validate_masked(u8 *data, int len)
2198 {
2199         u8 *mask = data + len;
2200
2201         while (len--)
2202                 if (*data++ & ~*mask++)
2203                         return false;
2204
2205         return true;
2206 }
2207
2208 static int validate_set(const struct nlattr *a,
2209                         const struct sw_flow_key *flow_key,
2210                         struct sw_flow_actions **sfa, bool *skip_copy,
2211                         u8 mac_proto, __be16 eth_type, bool masked, bool log)
2212 {
2213         const struct nlattr *ovs_key = nla_data(a);
2214         int key_type = nla_type(ovs_key);
2215         size_t key_len;
2216
2217         /* There can be only one key in a action */
2218         if (nla_total_size(nla_len(ovs_key)) != nla_len(a))
2219                 return -EINVAL;
2220
2221         key_len = nla_len(ovs_key);
2222         if (masked)
2223                 key_len /= 2;
2224
2225         if (key_type > OVS_KEY_ATTR_MAX ||
2226             !check_attr_len(key_len, ovs_key_lens[key_type].len))
2227                 return -EINVAL;
2228
2229         if (masked && !validate_masked(nla_data(ovs_key), key_len))
2230                 return -EINVAL;
2231
2232         switch (key_type) {
2233         const struct ovs_key_ipv4 *ipv4_key;
2234         const struct ovs_key_ipv6 *ipv6_key;
2235         int err;
2236
2237         case OVS_KEY_ATTR_PRIORITY:
2238         case OVS_KEY_ATTR_SKB_MARK:
2239         case OVS_KEY_ATTR_CT_MARK:
2240         case OVS_KEY_ATTR_CT_LABELS:
2241                 break;
2242
2243         case OVS_KEY_ATTR_ETHERNET:
2244                 if (mac_proto != MAC_PROTO_ETHERNET)
2245                         return -EINVAL;
2246                 break;
2247
2248         case OVS_KEY_ATTR_TUNNEL:
2249                 if (masked)
2250                         return -EINVAL; /* Masked tunnel set not supported. */
2251
2252                 *skip_copy = true;
2253                 err = validate_and_copy_set_tun(a, sfa, log);
2254                 if (err)
2255                         return err;
2256                 break;
2257
2258         case OVS_KEY_ATTR_IPV4:
2259                 if (eth_type != htons(ETH_P_IP))
2260                         return -EINVAL;
2261
2262                 ipv4_key = nla_data(ovs_key);
2263
2264                 if (masked) {
2265                         const struct ovs_key_ipv4 *mask = ipv4_key + 1;
2266
2267                         /* Non-writeable fields. */
2268                         if (mask->ipv4_proto || mask->ipv4_frag)
2269                                 return -EINVAL;
2270                 } else {
2271                         if (ipv4_key->ipv4_proto != flow_key->ip.proto)
2272                                 return -EINVAL;
2273
2274                         if (ipv4_key->ipv4_frag != flow_key->ip.frag)
2275                                 return -EINVAL;
2276                 }
2277                 break;
2278
2279         case OVS_KEY_ATTR_IPV6:
2280                 if (eth_type != htons(ETH_P_IPV6))
2281                         return -EINVAL;
2282
2283                 ipv6_key = nla_data(ovs_key);
2284
2285                 if (masked) {
2286                         const struct ovs_key_ipv6 *mask = ipv6_key + 1;
2287
2288                         /* Non-writeable fields. */
2289                         if (mask->ipv6_proto || mask->ipv6_frag)
2290                                 return -EINVAL;
2291
2292                         /* Invalid bits in the flow label mask? */
2293                         if (ntohl(mask->ipv6_label) & 0xFFF00000)
2294                                 return -EINVAL;
2295                 } else {
2296                         if (ipv6_key->ipv6_proto != flow_key->ip.proto)
2297                                 return -EINVAL;
2298
2299                         if (ipv6_key->ipv6_frag != flow_key->ip.frag)
2300                                 return -EINVAL;
2301                 }
2302                 if (ntohl(ipv6_key->ipv6_label) & 0xFFF00000)
2303                         return -EINVAL;
2304
2305                 break;
2306
2307         case OVS_KEY_ATTR_TCP:
2308                 if ((eth_type != htons(ETH_P_IP) &&
2309                      eth_type != htons(ETH_P_IPV6)) ||
2310                     flow_key->ip.proto != IPPROTO_TCP)
2311                         return -EINVAL;
2312
2313                 break;
2314
2315         case OVS_KEY_ATTR_UDP:
2316                 if ((eth_type != htons(ETH_P_IP) &&
2317                      eth_type != htons(ETH_P_IPV6)) ||
2318                     flow_key->ip.proto != IPPROTO_UDP)
2319                         return -EINVAL;
2320
2321                 break;
2322
2323         case OVS_KEY_ATTR_MPLS:
2324                 if (!eth_p_mpls(eth_type))
2325                         return -EINVAL;
2326                 break;
2327
2328         case OVS_KEY_ATTR_SCTP:
2329                 if ((eth_type != htons(ETH_P_IP) &&
2330                      eth_type != htons(ETH_P_IPV6)) ||
2331                     flow_key->ip.proto != IPPROTO_SCTP)
2332                         return -EINVAL;
2333
2334                 break;
2335
2336         default:
2337                 return -EINVAL;
2338         }
2339
2340         /* Convert non-masked non-tunnel set actions to masked set actions. */
2341         if (!masked && key_type != OVS_KEY_ATTR_TUNNEL) {
2342                 int start, len = key_len * 2;
2343                 struct nlattr *at;
2344
2345                 *skip_copy = true;
2346
2347                 start = add_nested_action_start(sfa,
2348                                                 OVS_ACTION_ATTR_SET_TO_MASKED,
2349                                                 log);
2350                 if (start < 0)
2351                         return start;
2352
2353                 at = __add_action(sfa, key_type, NULL, len, log);
2354                 if (IS_ERR(at))
2355                         return PTR_ERR(at);
2356
2357                 memcpy(nla_data(at), nla_data(ovs_key), key_len); /* Key. */
2358                 memset(nla_data(at) + key_len, 0xff, key_len);    /* Mask. */
2359                 /* Clear non-writeable bits from otherwise writeable fields. */
2360                 if (key_type == OVS_KEY_ATTR_IPV6) {
2361                         struct ovs_key_ipv6 *mask = nla_data(at) + key_len;
2362
2363                         mask->ipv6_label &= htonl(0x000FFFFF);
2364                 }
2365                 add_nested_action_end(*sfa, start);
2366         }
2367
2368         return 0;
2369 }
2370
2371 static int validate_userspace(const struct nlattr *attr)
2372 {
2373         static const struct nla_policy userspace_policy[OVS_USERSPACE_ATTR_MAX + 1] = {
2374                 [OVS_USERSPACE_ATTR_PID] = {.type = NLA_U32 },
2375                 [OVS_USERSPACE_ATTR_USERDATA] = {.type = NLA_UNSPEC },
2376                 [OVS_USERSPACE_ATTR_EGRESS_TUN_PORT] = {.type = NLA_U32 },
2377         };
2378         struct nlattr *a[OVS_USERSPACE_ATTR_MAX + 1];
2379         int error;
2380
2381         error = nla_parse_nested(a, OVS_USERSPACE_ATTR_MAX,
2382                                  attr, userspace_policy);
2383         if (error)
2384                 return error;
2385
2386         if (!a[OVS_USERSPACE_ATTR_PID] ||
2387             !nla_get_u32(a[OVS_USERSPACE_ATTR_PID]))
2388                 return -EINVAL;
2389
2390         return 0;
2391 }
2392
2393 static int copy_action(const struct nlattr *from,
2394                        struct sw_flow_actions **sfa, bool log)
2395 {
2396         int totlen = NLA_ALIGN(from->nla_len);
2397         struct nlattr *to;
2398
2399         to = reserve_sfa_size(sfa, from->nla_len, log);
2400         if (IS_ERR(to))
2401                 return PTR_ERR(to);
2402
2403         memcpy(to, from, totlen);
2404         return 0;
2405 }
2406
2407 static int __ovs_nla_copy_actions(struct net *net, const struct nlattr *attr,
2408                                   const struct sw_flow_key *key,
2409                                   int depth, struct sw_flow_actions **sfa,
2410                                   __be16 eth_type, __be16 vlan_tci, bool log)
2411 {
2412         u8 mac_proto = ovs_key_mac_proto(key);
2413         const struct nlattr *a;
2414         int rem, err;
2415
2416         if (depth >= SAMPLE_ACTION_DEPTH)
2417                 return -EOVERFLOW;
2418
2419         nla_for_each_nested(a, attr, rem) {
2420                 /* Expected argument lengths, (u32)-1 for variable length. */
2421                 static const u32 action_lens[OVS_ACTION_ATTR_MAX + 1] = {
2422                         [OVS_ACTION_ATTR_OUTPUT] = sizeof(u32),
2423                         [OVS_ACTION_ATTR_RECIRC] = sizeof(u32),
2424                         [OVS_ACTION_ATTR_USERSPACE] = (u32)-1,
2425                         [OVS_ACTION_ATTR_PUSH_MPLS] = sizeof(struct ovs_action_push_mpls),
2426                         [OVS_ACTION_ATTR_POP_MPLS] = sizeof(__be16),
2427                         [OVS_ACTION_ATTR_PUSH_VLAN] = sizeof(struct ovs_action_push_vlan),
2428                         [OVS_ACTION_ATTR_POP_VLAN] = 0,
2429                         [OVS_ACTION_ATTR_SET] = (u32)-1,
2430                         [OVS_ACTION_ATTR_SET_MASKED] = (u32)-1,
2431                         [OVS_ACTION_ATTR_SAMPLE] = (u32)-1,
2432                         [OVS_ACTION_ATTR_HASH] = sizeof(struct ovs_action_hash),
2433                         [OVS_ACTION_ATTR_CT] = (u32)-1,
2434                         [OVS_ACTION_ATTR_TRUNC] = sizeof(struct ovs_action_trunc),
2435                         [OVS_ACTION_ATTR_PUSH_ETH] = sizeof(struct ovs_action_push_eth),
2436                         [OVS_ACTION_ATTR_POP_ETH] = 0,
2437                 };
2438                 const struct ovs_action_push_vlan *vlan;
2439                 int type = nla_type(a);
2440                 bool skip_copy;
2441
2442                 if (type > OVS_ACTION_ATTR_MAX ||
2443                     (action_lens[type] != nla_len(a) &&
2444                      action_lens[type] != (u32)-1))
2445                         return -EINVAL;
2446
2447                 skip_copy = false;
2448                 switch (type) {
2449                 case OVS_ACTION_ATTR_UNSPEC:
2450                         return -EINVAL;
2451
2452                 case OVS_ACTION_ATTR_USERSPACE:
2453                         err = validate_userspace(a);
2454                         if (err)
2455                                 return err;
2456                         break;
2457
2458                 case OVS_ACTION_ATTR_OUTPUT:
2459                         if (nla_get_u32(a) >= DP_MAX_PORTS)
2460                                 return -EINVAL;
2461                         break;
2462
2463                 case OVS_ACTION_ATTR_TRUNC: {
2464                         const struct ovs_action_trunc *trunc = nla_data(a);
2465
2466                         if (trunc->max_len < ETH_HLEN)
2467                                 return -EINVAL;
2468                         break;
2469                 }
2470
2471                 case OVS_ACTION_ATTR_HASH: {
2472                         const struct ovs_action_hash *act_hash = nla_data(a);
2473
2474                         switch (act_hash->hash_alg) {
2475                         case OVS_HASH_ALG_L4:
2476                                 break;
2477                         default:
2478                                 return  -EINVAL;
2479                         }
2480
2481                         break;
2482                 }
2483
2484                 case OVS_ACTION_ATTR_POP_VLAN:
2485                         if (mac_proto != MAC_PROTO_ETHERNET)
2486                                 return -EINVAL;
2487                         vlan_tci = htons(0);
2488                         break;
2489
2490                 case OVS_ACTION_ATTR_PUSH_VLAN:
2491                         if (mac_proto != MAC_PROTO_ETHERNET)
2492                                 return -EINVAL;
2493                         vlan = nla_data(a);
2494                         if (!eth_type_vlan(vlan->vlan_tpid))
2495                                 return -EINVAL;
2496                         if (!(vlan->vlan_tci & htons(VLAN_TAG_PRESENT)))
2497                                 return -EINVAL;
2498                         vlan_tci = vlan->vlan_tci;
2499                         break;
2500
2501                 case OVS_ACTION_ATTR_RECIRC:
2502                         break;
2503
2504                 case OVS_ACTION_ATTR_PUSH_MPLS: {
2505                         const struct ovs_action_push_mpls *mpls = nla_data(a);
2506
2507                         if (!eth_p_mpls(mpls->mpls_ethertype))
2508                                 return -EINVAL;
2509                         /* Prohibit push MPLS other than to a white list
2510                          * for packets that have a known tag order.
2511                          */
2512                         if (vlan_tci & htons(VLAN_TAG_PRESENT) ||
2513                             (eth_type != htons(ETH_P_IP) &&
2514                              eth_type != htons(ETH_P_IPV6) &&
2515                              eth_type != htons(ETH_P_ARP) &&
2516                              eth_type != htons(ETH_P_RARP) &&
2517                              !eth_p_mpls(eth_type)))
2518                                 return -EINVAL;
2519                         eth_type = mpls->mpls_ethertype;
2520                         break;
2521                 }
2522
2523                 case OVS_ACTION_ATTR_POP_MPLS:
2524                         if (vlan_tci & htons(VLAN_TAG_PRESENT) ||
2525                             !eth_p_mpls(eth_type))
2526                                 return -EINVAL;
2527
2528                         /* Disallow subsequent L2.5+ set and mpls_pop actions
2529                          * as there is no check here to ensure that the new
2530                          * eth_type is valid and thus set actions could
2531                          * write off the end of the packet or otherwise
2532                          * corrupt it.
2533                          *
2534                          * Support for these actions is planned using packet
2535                          * recirculation.
2536                          */
2537                         eth_type = htons(0);
2538                         break;
2539
2540                 case OVS_ACTION_ATTR_SET:
2541                         err = validate_set(a, key, sfa,
2542                                            &skip_copy, mac_proto, eth_type,
2543                                            false, log);
2544                         if (err)
2545                                 return err;
2546                         break;
2547
2548                 case OVS_ACTION_ATTR_SET_MASKED:
2549                         err = validate_set(a, key, sfa,
2550                                            &skip_copy, mac_proto, eth_type,
2551                                            true, log);
2552                         if (err)
2553                                 return err;
2554                         break;
2555
2556                 case OVS_ACTION_ATTR_SAMPLE:
2557                         err = validate_and_copy_sample(net, a, key, depth, sfa,
2558                                                        eth_type, vlan_tci, log);
2559                         if (err)
2560                                 return err;
2561                         skip_copy = true;
2562                         break;
2563
2564                 case OVS_ACTION_ATTR_CT:
2565                         err = ovs_ct_copy_action(net, a, key, sfa, log);
2566                         if (err)
2567                                 return err;
2568                         skip_copy = true;
2569                         break;
2570
2571                 case OVS_ACTION_ATTR_PUSH_ETH:
2572                         /* Disallow pushing an Ethernet header if one
2573                          * is already present */
2574                         if (mac_proto != MAC_PROTO_NONE)
2575                                 return -EINVAL;
2576                         mac_proto = MAC_PROTO_NONE;
2577                         break;
2578
2579                 case OVS_ACTION_ATTR_POP_ETH:
2580                         if (mac_proto != MAC_PROTO_ETHERNET)
2581                                 return -EINVAL;
2582                         if (vlan_tci & htons(VLAN_TAG_PRESENT))
2583                                 return -EINVAL;
2584                         mac_proto = MAC_PROTO_ETHERNET;
2585                         break;
2586
2587                 default:
2588                         OVS_NLERR(log, "Unknown Action type %d", type);
2589                         return -EINVAL;
2590                 }
2591                 if (!skip_copy) {
2592                         err = copy_action(a, sfa, log);
2593                         if (err)
2594                                 return err;
2595                 }
2596         }
2597
2598         if (rem > 0)
2599                 return -EINVAL;
2600
2601         return 0;
2602 }
2603
2604 /* 'key' must be the masked key. */
2605 int ovs_nla_copy_actions(struct net *net, const struct nlattr *attr,
2606                          const struct sw_flow_key *key,
2607                          struct sw_flow_actions **sfa, bool log)
2608 {
2609         int err;
2610
2611         *sfa = nla_alloc_flow_actions(nla_len(attr), log);
2612         if (IS_ERR(*sfa))
2613                 return PTR_ERR(*sfa);
2614
2615         (*sfa)->orig_len = nla_len(attr);
2616         err = __ovs_nla_copy_actions(net, attr, key, 0, sfa, key->eth.type,
2617                                      key->eth.vlan.tci, log);
2618         if (err)
2619                 ovs_nla_free_flow_actions(*sfa);
2620
2621         return err;
2622 }
2623
2624 static int sample_action_to_attr(const struct nlattr *attr, struct sk_buff *skb)
2625 {
2626         const struct nlattr *a;
2627         struct nlattr *start;
2628         int err = 0, rem;
2629
2630         start = nla_nest_start(skb, OVS_ACTION_ATTR_SAMPLE);
2631         if (!start)
2632                 return -EMSGSIZE;
2633
2634         nla_for_each_nested(a, attr, rem) {
2635                 int type = nla_type(a);
2636                 struct nlattr *st_sample;
2637
2638                 switch (type) {
2639                 case OVS_SAMPLE_ATTR_PROBABILITY:
2640                         if (nla_put(skb, OVS_SAMPLE_ATTR_PROBABILITY,
2641                                     sizeof(u32), nla_data(a)))
2642                                 return -EMSGSIZE;
2643                         break;
2644                 case OVS_SAMPLE_ATTR_ACTIONS:
2645                         st_sample = nla_nest_start(skb, OVS_SAMPLE_ATTR_ACTIONS);
2646                         if (!st_sample)
2647                                 return -EMSGSIZE;
2648                         err = ovs_nla_put_actions(nla_data(a), nla_len(a), skb);
2649                         if (err)
2650                                 return err;
2651                         nla_nest_end(skb, st_sample);
2652                         break;
2653                 }
2654         }
2655
2656         nla_nest_end(skb, start);
2657         return err;
2658 }
2659
2660 static int set_action_to_attr(const struct nlattr *a, struct sk_buff *skb)
2661 {
2662         const struct nlattr *ovs_key = nla_data(a);
2663         int key_type = nla_type(ovs_key);
2664         struct nlattr *start;
2665         int err;
2666
2667         switch (key_type) {
2668         case OVS_KEY_ATTR_TUNNEL_INFO: {
2669                 struct ovs_tunnel_info *ovs_tun = nla_data(ovs_key);
2670                 struct ip_tunnel_info *tun_info = &ovs_tun->tun_dst->u.tun_info;
2671
2672                 start = nla_nest_start(skb, OVS_ACTION_ATTR_SET);
2673                 if (!start)
2674                         return -EMSGSIZE;
2675
2676                 err =  ip_tun_to_nlattr(skb, &tun_info->key,
2677                                         ip_tunnel_info_opts(tun_info),
2678                                         tun_info->options_len,
2679                                         ip_tunnel_info_af(tun_info));
2680                 if (err)
2681                         return err;
2682                 nla_nest_end(skb, start);
2683                 break;
2684         }
2685         default:
2686                 if (nla_put(skb, OVS_ACTION_ATTR_SET, nla_len(a), ovs_key))
2687                         return -EMSGSIZE;
2688                 break;
2689         }
2690
2691         return 0;
2692 }
2693
2694 static int masked_set_action_to_set_action_attr(const struct nlattr *a,
2695                                                 struct sk_buff *skb)
2696 {
2697         const struct nlattr *ovs_key = nla_data(a);
2698         struct nlattr *nla;
2699         size_t key_len = nla_len(ovs_key) / 2;
2700
2701         /* Revert the conversion we did from a non-masked set action to
2702          * masked set action.
2703          */
2704         nla = nla_nest_start(skb, OVS_ACTION_ATTR_SET);
2705         if (!nla)
2706                 return -EMSGSIZE;
2707
2708         if (nla_put(skb, nla_type(ovs_key), key_len, nla_data(ovs_key)))
2709                 return -EMSGSIZE;
2710
2711         nla_nest_end(skb, nla);
2712         return 0;
2713 }
2714
2715 int ovs_nla_put_actions(const struct nlattr *attr, int len, struct sk_buff *skb)
2716 {
2717         const struct nlattr *a;
2718         int rem, err;
2719
2720         nla_for_each_attr(a, attr, len, rem) {
2721                 int type = nla_type(a);
2722
2723                 switch (type) {
2724                 case OVS_ACTION_ATTR_SET:
2725                         err = set_action_to_attr(a, skb);
2726                         if (err)
2727                                 return err;
2728                         break;
2729
2730                 case OVS_ACTION_ATTR_SET_TO_MASKED:
2731                         err = masked_set_action_to_set_action_attr(a, skb);
2732                         if (err)
2733                                 return err;
2734                         break;
2735
2736                 case OVS_ACTION_ATTR_SAMPLE:
2737                         err = sample_action_to_attr(a, skb);
2738                         if (err)
2739                                 return err;
2740                         break;
2741
2742                 case OVS_ACTION_ATTR_CT:
2743                         err = ovs_ct_action_to_attr(nla_data(a), skb);
2744                         if (err)
2745                                 return err;
2746                         break;
2747
2748                 default:
2749                         if (nla_put(skb, type, nla_len(a), nla_data(a)))
2750                                 return -EMSGSIZE;
2751                         break;
2752                 }
2753         }
2754
2755         return 0;
2756 }