]> git.proxmox.com Git - ovs.git/blob - lib/meta-flow.c
projects / ovs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
odp: Support conntrack orig tuple key.
[ovs.git] / lib / meta-flow.c
1 /*
2 * Copyright (c) 2011-2017 Nicira, Inc.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at:
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <config.h>
18
19 #include "openvswitch/meta-flow.h"
20
21 #include <errno.h>
22 #include <limits.h>
23 #include <netinet/icmp6.h>
24 #include <netinet/ip6.h>
25
26 #include "classifier.h"
27 #include "openvswitch/dynamic-string.h"
28 #include "nx-match.h"
29 #include "openvswitch/ofp-util.h"
30 #include "ovs-rcu.h"
31 #include "ovs-thread.h"
32 #include "packets.h"
33 #include "random.h"
34 #include "openvswitch/shash.h"
35 #include "socket-util.h"
36 #include "tun-metadata.h"
37 #include "unaligned.h"
38 #include "util.h"
39 #include "openvswitch/ofp-errors.h"
40 #include "openvswitch/vlog.h"
41 #include "vl-mff-map.h"
42
43 VLOG_DEFINE_THIS_MODULE(meta_flow);
44
45 #define FLOW_U32OFS(FIELD) \
46 offsetof(struct flow, FIELD) % 4 ? -1 : offsetof(struct flow, FIELD) / 4
47
48 #define MF_FIELD_SIZES(MEMBER) \
49 sizeof ((union mf_value *)0)->MEMBER, \
50 8 * sizeof ((union mf_value *)0)->MEMBER
51
52 extern const struct mf_field mf_fields[MFF_N_IDS]; /* Silence a warning. */
53
54 const struct mf_field mf_fields[MFF_N_IDS] = {
55 #include "meta-flow.inc"
56 };
57
58 /* Maps from an mf_field's 'name' or 'extra_name' to the mf_field. */
59 static struct shash mf_by_name;
60
61 /* Rate limit for parse errors. These always indicate a bug in an OpenFlow
62 * controller and so there's not much point in showing a lot of them. */
63 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
64
65 #define MF_VALUE_EXACT_8 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
66 #define MF_VALUE_EXACT_16 MF_VALUE_EXACT_8, MF_VALUE_EXACT_8
67 #define MF_VALUE_EXACT_32 MF_VALUE_EXACT_16, MF_VALUE_EXACT_16
68 #define MF_VALUE_EXACT_64 MF_VALUE_EXACT_32, MF_VALUE_EXACT_32
69 #define MF_VALUE_EXACT_128 MF_VALUE_EXACT_64, MF_VALUE_EXACT_64
70 #define MF_VALUE_EXACT_INITIALIZER { .tun_metadata = { MF_VALUE_EXACT_128 } }
71
72 const union mf_value exact_match_mask = MF_VALUE_EXACT_INITIALIZER;
73
74 static void nxm_init(void);
75
76 /* Returns the field with the given 'name', or a null pointer if no field has
77 * that name. */
78 const struct mf_field *
79 mf_from_name(const char *name)
80 {
81 nxm_init();
82 return shash_find_data(&mf_by_name, name);
83 }
84
85 /* Returns the field with the given 'name' (which is 'len' bytes long), or a
86 * null pointer if no field has that name. */
87 const struct mf_field *
88 mf_from_name_len(const char *name, size_t len)
89 {
90 nxm_init();
91
92 struct shash_node *node = shash_find_len(&mf_by_name, name, len);
93 return node ? node->data : NULL;
94 }
95
96 static void
97 nxm_do_init(void)
98 {
99 int i;
100
101 shash_init(&mf_by_name);
102 for (i = 0; i < MFF_N_IDS; i++) {
103 const struct mf_field *mf = &mf_fields[i];
104
105 ovs_assert(mf->id == i); /* Fields must be in the enum order. */
106
107 shash_add_once(&mf_by_name, mf->name, mf);
108 if (mf->extra_name) {
109 shash_add_once(&mf_by_name, mf->extra_name, mf);
110 }
111 }
112 }
113
114 static void
115 nxm_init(void)
116 {
117 static pthread_once_t once = PTHREAD_ONCE_INIT;
118 pthread_once(&once, nxm_do_init);
119 }
120
121 /* Consider the two value/mask pairs 'a_value/a_mask' and 'b_value/b_mask' as
122 * restrictions on a field's value. Then, this function initializes
123 * 'dst_value/dst_mask' such that it combines the restrictions of both pairs.
124 * This is not always possible, i.e. if one pair insists on a value of 0 in
125 * some bit and the other pair insists on a value of 1 in that bit. This
126 * function returns false in a case where the combined restriction is
127 * impossible (in which case 'dst_value/dst_mask' is not fully initialized),
128 * true otherwise.
129 *
130 * (As usually true for value/mask pairs in OVS, any 1-bit in a value must have
131 * a corresponding 1-bit in its mask.) */
132 bool
133 mf_subvalue_intersect(const union mf_subvalue *a_value,
134 const union mf_subvalue *a_mask,
135 const union mf_subvalue *b_value,
136 const union mf_subvalue *b_mask,
137 union mf_subvalue *dst_value,
138 union mf_subvalue *dst_mask)
139 {
140 for (int i = 0; i < ARRAY_SIZE(a_value->be64); i++) {
141 ovs_be64 av = a_value->be64[i];
142 ovs_be64 am = a_mask->be64[i];
143 ovs_be64 bv = b_value->be64[i];
144 ovs_be64 bm = b_mask->be64[i];
145 ovs_be64 *dv = &dst_value->be64[i];
146 ovs_be64 *dm = &dst_mask->be64[i];
147
148 if ((av ^ bv) & (am & bm)) {
149 return false;
150 }
151 *dv = av | bv;
152 *dm = am | bm;
153 }
154 return true;
155 }
156
157 /* Returns the "number of bits" in 'v', e.g. 1 if only the lowest-order bit is
158 * set, 2 if the second-lowest-order bit is set, and so on. */
159 int
160 mf_subvalue_width(const union mf_subvalue *v)
161 {
162 return 1 + bitwise_rscan(v, sizeof *v, true, sizeof *v * 8 - 1, -1);
163 }
164
165 /* For positive 'n', shifts the bits in 'value' 'n' bits to the left, and for
166 * negative 'n', shifts the bits '-n' bits to the right. */
167 void
168 mf_subvalue_shift(union mf_subvalue *value, int n)
169 {
170 if (n) {
171 union mf_subvalue tmp;
172 memset(&tmp, 0, sizeof tmp);
173
174 if (n > 0 && n < 8 * sizeof tmp) {
175 bitwise_copy(value, sizeof *value, 0,
176 &tmp, sizeof tmp, n,
177 8 * sizeof tmp - n);
178 } else if (n < 0 && n > -8 * sizeof tmp) {
179 bitwise_copy(value, sizeof *value, -n,
180 &tmp, sizeof tmp, 0,
181 8 * sizeof tmp + n);
182 }
183 *value = tmp;
184 }
185 }
186
187 /* Appends a formatted representation of 'sv' to 's'. */
188 void
189 mf_subvalue_format(const union mf_subvalue *sv, struct ds *s)
190 {
191 ds_put_hex(s, sv, sizeof *sv);
192 }
193
194 /* Returns true if 'wc' wildcards all the bits in field 'mf', false if 'wc'
195 * specifies at least one bit in the field.
196 *
197 * The caller is responsible for ensuring that 'wc' corresponds to a flow that
198 * meets 'mf''s prerequisites. */
199 bool
200 mf_is_all_wild(const struct mf_field *mf, const struct flow_wildcards *wc)
201 {
202 switch (mf->id) {
203 case MFF_DP_HASH:
204 return !wc->masks.dp_hash;
205 case MFF_RECIRC_ID:
206 return !wc->masks.recirc_id;
207 case MFF_CONJ_ID:
208 return !wc->masks.conj_id;
209 case MFF_TUN_SRC:
210 return !wc->masks.tunnel.ip_src;
211 case MFF_TUN_DST:
212 return !wc->masks.tunnel.ip_dst;
213 case MFF_TUN_IPV6_SRC:
214 return ipv6_mask_is_any(&wc->masks.tunnel.ipv6_src);
215 case MFF_TUN_IPV6_DST:
216 return ipv6_mask_is_any(&wc->masks.tunnel.ipv6_dst);
217 case MFF_TUN_ID:
218 return !wc->masks.tunnel.tun_id;
219 case MFF_TUN_TOS:
220 return !wc->masks.tunnel.ip_tos;
221 case MFF_TUN_TTL:
222 return !wc->masks.tunnel.ip_ttl;
223 case MFF_TUN_FLAGS:
224 return !(wc->masks.tunnel.flags & FLOW_TNL_PUB_F_MASK);
225 case MFF_TUN_GBP_ID:
226 return !wc->masks.tunnel.gbp_id;
227 case MFF_TUN_GBP_FLAGS:
228 return !wc->masks.tunnel.gbp_flags;
229 CASE_MFF_TUN_METADATA:
230 return !ULLONG_GET(wc->masks.tunnel.metadata.present.map,
231 mf->id - MFF_TUN_METADATA0);
232 case MFF_METADATA:
233 return !wc->masks.metadata;
234 case MFF_IN_PORT:
235 case MFF_IN_PORT_OXM:
236 return !wc->masks.in_port.ofp_port;
237 case MFF_SKB_PRIORITY:
238 return !wc->masks.skb_priority;
239 case MFF_PKT_MARK:
240 return !wc->masks.pkt_mark;
241 case MFF_CT_STATE:
242 return !wc->masks.ct_state;
243 case MFF_CT_ZONE:
244 return !wc->masks.ct_zone;
245 case MFF_CT_MARK:
246 return !wc->masks.ct_mark;
247 case MFF_CT_LABEL:
248 return ovs_u128_is_zero(wc->masks.ct_label);
249 case MFF_CT_NW_PROTO:
250 return !wc->masks.ct_nw_proto;
251 case MFF_CT_NW_SRC:
252 return !wc->masks.ct_nw_src;
253 case MFF_CT_NW_DST:
254 return !wc->masks.ct_nw_dst;
255 case MFF_CT_TP_SRC:
256 return !wc->masks.ct_tp_src;
257 case MFF_CT_TP_DST:
258 return !wc->masks.ct_tp_dst;
259 case MFF_CT_IPV6_SRC:
260 return ipv6_mask_is_any(&wc->masks.ct_ipv6_src);
261 case MFF_CT_IPV6_DST:
262 return ipv6_mask_is_any(&wc->masks.ct_ipv6_dst);
263 CASE_MFF_REGS:
264 return !wc->masks.regs[mf->id - MFF_REG0];
265 CASE_MFF_XREGS:
266 return !flow_get_xreg(&wc->masks, mf->id - MFF_XREG0);
267 CASE_MFF_XXREGS: {
268 ovs_u128 value = flow_get_xxreg(&wc->masks, mf->id - MFF_XXREG0);
269 return ovs_u128_is_zero(value);
270 }
271 case MFF_ACTSET_OUTPUT:
272 return !wc->masks.actset_output;
273
274 case MFF_ETH_SRC:
275 return eth_addr_is_zero(wc->masks.dl_src);
276 case MFF_ETH_DST:
277 return eth_addr_is_zero(wc->masks.dl_dst);
278 case MFF_ETH_TYPE:
279 return !wc->masks.dl_type;
280
281 case MFF_ARP_SHA:
282 case MFF_ND_SLL:
283 return eth_addr_is_zero(wc->masks.arp_sha);
284
285 case MFF_ARP_THA:
286 case MFF_ND_TLL:
287 return eth_addr_is_zero(wc->masks.arp_tha);
288
289 case MFF_VLAN_TCI:
290 return !wc->masks.vlan_tci;
291 case MFF_DL_VLAN:
292 return !(wc->masks.vlan_tci & htons(VLAN_VID_MASK));
293 case MFF_VLAN_VID:
294 return !(wc->masks.vlan_tci & htons(VLAN_VID_MASK | VLAN_CFI));
295 case MFF_DL_VLAN_PCP:
296 case MFF_VLAN_PCP:
297 return !(wc->masks.vlan_tci & htons(VLAN_PCP_MASK));
298
299 case MFF_MPLS_LABEL:
300 return !(wc->masks.mpls_lse[0] & htonl(MPLS_LABEL_MASK));
301 case MFF_MPLS_TC:
302 return !(wc->masks.mpls_lse[0] & htonl(MPLS_TC_MASK));
303 case MFF_MPLS_BOS:
304 return !(wc->masks.mpls_lse[0] & htonl(MPLS_BOS_MASK));
305 case MFF_MPLS_TTL:
306 return !(wc->masks.mpls_lse[0] & htonl(MPLS_TTL_MASK));
307
308 case MFF_IPV4_SRC:
309 return !wc->masks.nw_src;
310 case MFF_IPV4_DST:
311 return !wc->masks.nw_dst;
312
313 case MFF_IPV6_SRC:
314 return ipv6_mask_is_any(&wc->masks.ipv6_src);
315 case MFF_IPV6_DST:
316 return ipv6_mask_is_any(&wc->masks.ipv6_dst);
317
318 case MFF_IPV6_LABEL:
319 return !wc->masks.ipv6_label;
320
321 case MFF_IP_PROTO:
322 return !wc->masks.nw_proto;
323 case MFF_IP_DSCP:
324 case MFF_IP_DSCP_SHIFTED:
325 return !(wc->masks.nw_tos & IP_DSCP_MASK);
326 case MFF_IP_ECN:
327 return !(wc->masks.nw_tos & IP_ECN_MASK);
328 case MFF_IP_TTL:
329 return !wc->masks.nw_ttl;
330
331 case MFF_ND_TARGET:
332 return ipv6_mask_is_any(&wc->masks.nd_target);
333
334 case MFF_IP_FRAG:
335 return !(wc->masks.nw_frag & FLOW_NW_FRAG_MASK);
336
337 case MFF_ARP_OP:
338 return !wc->masks.nw_proto;
339 case MFF_ARP_SPA:
340 return !wc->masks.nw_src;
341 case MFF_ARP_TPA:
342 return !wc->masks.nw_dst;
343
344 case MFF_TCP_SRC:
345 case MFF_UDP_SRC:
346 case MFF_SCTP_SRC:
347 case MFF_ICMPV4_TYPE:
348 case MFF_ICMPV6_TYPE:
349 return !wc->masks.tp_src;
350 case MFF_TCP_DST:
351 case MFF_UDP_DST:
352 case MFF_SCTP_DST:
353 case MFF_ICMPV4_CODE:
354 case MFF_ICMPV6_CODE:
355 return !wc->masks.tp_dst;
356 case MFF_TCP_FLAGS:
357 return !wc->masks.tcp_flags;
358
359 case MFF_N_IDS:
360 default:
361 OVS_NOT_REACHED();
362 }
363 }
364
365 /* Initializes 'mask' with the wildcard bit pattern for field 'mf' within 'wc'.
366 * Each bit in 'mask' will be set to 1 if the bit is significant for matching
367 * purposes, or to 0 if it is wildcarded.
368 *
369 * The caller is responsible for ensuring that 'wc' corresponds to a flow that
370 * meets 'mf''s prerequisites. */
371 void
372 mf_get_mask(const struct mf_field *mf, const struct flow_wildcards *wc,
373 union mf_value *mask)
374 {
375 mf_get_value(mf, &wc->masks, mask);
376 }
377
378 /* Tests whether 'mask' is a valid wildcard bit pattern for 'mf'. Returns true
379 * if the mask is valid, false otherwise. */
380 bool
381 mf_is_mask_valid(const struct mf_field *mf, const union mf_value *mask)
382 {
383 switch (mf->maskable) {
384 case MFM_NONE:
385 return (is_all_zeros(mask, mf->n_bytes) ||
386 is_all_ones(mask, mf->n_bytes));
387
388 case MFM_FULLY:
389 return true;
390 }
391
392 OVS_NOT_REACHED();
393 }
394
395 /* Returns true if 'flow' meets the prerequisites for 'mf', false otherwise.
396 * If a non-NULL 'mask' is passed, zero-valued matches can also be verified.
397 * Sets inspected bits in 'wc', if non-NULL. */
398 static bool
399 mf_are_prereqs_ok__(const struct mf_field *mf, const struct flow *flow,
400 const struct flow_wildcards *mask,
401 struct flow_wildcards *wc)
402 {
403 switch (mf->prereqs) {
404 case MFP_NONE:
405 return true;
406 case MFP_ARP:
407 return (flow->dl_type == htons(ETH_TYPE_ARP) ||
408 flow->dl_type == htons(ETH_TYPE_RARP));
409 case MFP_IPV4:
410 return flow->dl_type == htons(ETH_TYPE_IP);
411 case MFP_IPV6:
412 return flow->dl_type == htons(ETH_TYPE_IPV6);
413 case MFP_VLAN_VID:
414 return is_vlan(flow, wc);
415 case MFP_MPLS:
416 return eth_type_mpls(flow->dl_type);
417 case MFP_IP_ANY:
418 return is_ip_any(flow);
419 case MFP_CT_VALID:
420 return is_ct_valid(flow, mask, wc);
421 case MFP_CTV4_VALID:
422 return flow->dl_type == htons(ETH_TYPE_IP)
423 && is_ct_valid(flow, mask, wc);
424 case MFP_CTV6_VALID:
425 return flow->dl_type == htons(ETH_TYPE_IPV6)
426 && is_ct_valid(flow, mask, wc);
427 case MFP_TCP:
428 /* Matching !FRAG_LATER is not enforced (mask is not checked). */
429 return is_tcp(flow, wc) && !(flow->nw_frag & FLOW_NW_FRAG_LATER);
430 case MFP_UDP:
431 return is_udp(flow, wc) && !(flow->nw_frag & FLOW_NW_FRAG_LATER);
432 case MFP_SCTP:
433 return is_sctp(flow, wc) && !(flow->nw_frag & FLOW_NW_FRAG_LATER);
434 case MFP_ICMPV4:
435 return is_icmpv4(flow, wc);
436 case MFP_ICMPV6:
437 return is_icmpv6(flow, wc);
438 case MFP_ND:
439 return is_nd(flow, wc);
440 case MFP_ND_SOLICIT:
441 return is_nd(flow, wc) && flow->tp_src == htons(ND_NEIGHBOR_SOLICIT);
442 case MFP_ND_ADVERT:
443 return is_nd(flow, wc) && flow->tp_src == htons(ND_NEIGHBOR_ADVERT);
444 }
445
446 OVS_NOT_REACHED();
447 }
448
449 /* Returns true if 'flow' meets the prerequisites for 'mf', false otherwise.
450 * Sets inspected bits in 'wc', if non-NULL. */
451 bool
452 mf_are_prereqs_ok(const struct mf_field *mf, const struct flow *flow,
453 struct flow_wildcards *wc)
454 {
455 return mf_are_prereqs_ok__(mf, flow, NULL, wc);
456 }
457
458 /* Returns true if 'match' meets the prerequisites for 'mf', false otherwise.
459 */
460 bool
461 mf_are_match_prereqs_ok(const struct mf_field *mf, const struct match *match)
462 {
463 return mf_are_prereqs_ok__(mf, &match->flow, &match->wc, NULL);
464 }
465
466 /* Returns true if 'value' may be a valid value *as part of a masked match*,
467 * false otherwise.
468 *
469 * A value is not rejected just because it is not valid for the field in
470 * question, but only if it doesn't make sense to test the bits in question at
471 * all. For example, the MFF_VLAN_TCI field will never have a nonzero value
472 * without the VLAN_CFI bit being set, but we can't reject those values because
473 * it is still legitimate to test just for those bits (see the documentation
474 * for NXM_OF_VLAN_TCI in meta-flow.h). On the other hand, there is never a
475 * reason to set the low bit of MFF_IP_DSCP to 1, so we reject that. */
476 bool
477 mf_is_value_valid(const struct mf_field *mf, const union mf_value *value)
478 {
479 switch (mf->id) {
480 case MFF_DP_HASH:
481 case MFF_RECIRC_ID:
482 case MFF_CONJ_ID:
483 case MFF_TUN_ID:
484 case MFF_TUN_SRC:
485 case MFF_TUN_DST:
486 case MFF_TUN_IPV6_SRC:
487 case MFF_TUN_IPV6_DST:
488 case MFF_TUN_TOS:
489 case MFF_TUN_TTL:
490 case MFF_TUN_GBP_ID:
491 case MFF_TUN_GBP_FLAGS:
492 CASE_MFF_TUN_METADATA:
493 case MFF_METADATA:
494 case MFF_IN_PORT:
495 case MFF_SKB_PRIORITY:
496 case MFF_PKT_MARK:
497 case MFF_CT_ZONE:
498 case MFF_CT_MARK:
499 case MFF_CT_LABEL:
500 case MFF_CT_NW_PROTO:
501 case MFF_CT_NW_SRC:
502 case MFF_CT_NW_DST:
503 case MFF_CT_IPV6_SRC:
504 case MFF_CT_IPV6_DST:
505 case MFF_CT_TP_SRC:
506 case MFF_CT_TP_DST:
507 CASE_MFF_REGS:
508 CASE_MFF_XREGS:
509 CASE_MFF_XXREGS:
510 case MFF_ETH_SRC:
511 case MFF_ETH_DST:
512 case MFF_ETH_TYPE:
513 case MFF_VLAN_TCI:
514 case MFF_MPLS_TTL:
515 case MFF_IPV4_SRC:
516 case MFF_IPV4_DST:
517 case MFF_IPV6_SRC:
518 case MFF_IPV6_DST:
519 case MFF_IP_PROTO:
520 case MFF_IP_TTL:
521 case MFF_ARP_SPA:
522 case MFF_ARP_TPA:
523 case MFF_ARP_SHA:
524 case MFF_ARP_THA:
525 case MFF_TCP_SRC:
526 case MFF_TCP_DST:
527 case MFF_UDP_SRC:
528 case MFF_UDP_DST:
529 case MFF_SCTP_SRC:
530 case MFF_SCTP_DST:
531 case MFF_ICMPV4_TYPE:
532 case MFF_ICMPV4_CODE:
533 case MFF_ICMPV6_TYPE:
534 case MFF_ICMPV6_CODE:
535 case MFF_ND_TARGET:
536 case MFF_ND_SLL:
537 case MFF_ND_TLL:
538 return true;
539
540 case MFF_IN_PORT_OXM:
541 case MFF_ACTSET_OUTPUT: {
542 ofp_port_t port;
543 return !ofputil_port_from_ofp11(value->be32, &port);
544 }
545
546 case MFF_IP_DSCP:
547 return !(value->u8 & ~IP_DSCP_MASK);
548 case MFF_IP_DSCP_SHIFTED:
549 return !(value->u8 & (~IP_DSCP_MASK >> 2));
550 case MFF_IP_ECN:
551 return !(value->u8 & ~IP_ECN_MASK);
552 case MFF_IP_FRAG:
553 return !(value->u8 & ~FLOW_NW_FRAG_MASK);
554 case MFF_TCP_FLAGS:
555 return !(value->be16 & ~htons(0x0fff));
556
557 case MFF_ARP_OP:
558 return !(value->be16 & htons(0xff00));
559
560 case MFF_DL_VLAN:
561 return !(value->be16 & htons(VLAN_CFI | VLAN_PCP_MASK));
562 case MFF_VLAN_VID:
563 return !(value->be16 & htons(VLAN_PCP_MASK));
564
565 case MFF_DL_VLAN_PCP:
566 case MFF_VLAN_PCP:
567 return !(value->u8 & ~(VLAN_PCP_MASK >> VLAN_PCP_SHIFT));
568
569 case MFF_IPV6_LABEL:
570 return !(value->be32 & ~htonl(IPV6_LABEL_MASK));
571
572 case MFF_MPLS_LABEL:
573 return !(value->be32 & ~htonl(MPLS_LABEL_MASK >> MPLS_LABEL_SHIFT));
574
575 case MFF_MPLS_TC:
576 return !(value->u8 & ~(MPLS_TC_MASK >> MPLS_TC_SHIFT));
577
578 case MFF_MPLS_BOS:
579 return !(value->u8 & ~(MPLS_BOS_MASK >> MPLS_BOS_SHIFT));
580
581 case MFF_TUN_FLAGS:
582 return !(value->be16 & ~htons(FLOW_TNL_PUB_F_MASK));
583
584 case MFF_CT_STATE:
585 return !(value->be32 & ~htonl(CS_SUPPORTED_MASK));
586
587 case MFF_N_IDS:
588 default:
589 OVS_NOT_REACHED();
590 }
591 }
592
593 /* Copies the value of field 'mf' from 'flow' into 'value'. The caller is
594 * responsible for ensuring that 'flow' meets 'mf''s prerequisites. */
595 void
596 mf_get_value(const struct mf_field *mf, const struct flow *flow,
597 union mf_value *value)
598 {
599 switch (mf->id) {
600 case MFF_DP_HASH:
601 value->be32 = htonl(flow->dp_hash);
602 break;
603 case MFF_RECIRC_ID:
604 value->be32 = htonl(flow->recirc_id);
605 break;
606 case MFF_CONJ_ID:
607 value->be32 = htonl(flow->conj_id);
608 break;
609 case MFF_TUN_ID:
610 value->be64 = flow->tunnel.tun_id;
611 break;
612 case MFF_TUN_SRC:
613 value->be32 = flow->tunnel.ip_src;
614 break;
615 case MFF_TUN_DST:
616 value->be32 = flow->tunnel.ip_dst;
617 break;
618 case MFF_TUN_IPV6_SRC:
619 value->ipv6 = flow->tunnel.ipv6_src;
620 break;
621 case MFF_TUN_IPV6_DST:
622 value->ipv6 = flow->tunnel.ipv6_dst;
623 break;
624 case MFF_TUN_FLAGS:
625 value->be16 = htons(flow->tunnel.flags & FLOW_TNL_PUB_F_MASK);
626 break;
627 case MFF_TUN_GBP_ID:
628 value->be16 = flow->tunnel.gbp_id;
629 break;
630 case MFF_TUN_GBP_FLAGS:
631 value->u8 = flow->tunnel.gbp_flags;
632 break;
633 case MFF_TUN_TTL:
634 value->u8 = flow->tunnel.ip_ttl;
635 break;
636 case MFF_TUN_TOS:
637 value->u8 = flow->tunnel.ip_tos;
638 break;
639 CASE_MFF_TUN_METADATA:
640 tun_metadata_read(&flow->tunnel, mf, value);
641 break;
642
643 case MFF_METADATA:
644 value->be64 = flow->metadata;
645 break;
646
647 case MFF_IN_PORT:
648 value->be16 = htons(ofp_to_u16(flow->in_port.ofp_port));
649 break;
650 case MFF_IN_PORT_OXM:
651 value->be32 = ofputil_port_to_ofp11(flow->in_port.ofp_port);
652 break;
653 case MFF_ACTSET_OUTPUT:
654 value->be32 = ofputil_port_to_ofp11(flow->actset_output);
655 break;
656
657 case MFF_SKB_PRIORITY:
658 value->be32 = htonl(flow->skb_priority);
659 break;
660
661 case MFF_PKT_MARK:
662 value->be32 = htonl(flow->pkt_mark);
663 break;
664
665 case MFF_CT_STATE:
666 value->be32 = htonl(flow->ct_state);
667 break;
668
669 case MFF_CT_ZONE:
670 value->be16 = htons(flow->ct_zone);
671 break;
672
673 case MFF_CT_MARK:
674 value->be32 = htonl(flow->ct_mark);
675 break;
676
677 case MFF_CT_LABEL:
678 value->be128 = hton128(flow->ct_label);
679 break;
680
681 case MFF_CT_NW_PROTO:
682 value->u8 = flow->ct_nw_proto;
683 break;
684
685 case MFF_CT_NW_SRC:
686 value->be32 = flow->ct_nw_src;
687 break;
688
689 case MFF_CT_NW_DST:
690 value->be32 = flow->ct_nw_dst;
691 break;
692
693 case MFF_CT_IPV6_SRC:
694 value->ipv6 = flow->ct_ipv6_src;
695 break;
696
697 case MFF_CT_IPV6_DST:
698 value->ipv6 = flow->ct_ipv6_dst;
699 break;
700
701 case MFF_CT_TP_SRC:
702 value->be16 = flow->ct_tp_src;
703 break;
704
705 case MFF_CT_TP_DST:
706 value->be16 = flow->ct_tp_dst;
707 break;
708
709 CASE_MFF_REGS:
710 value->be32 = htonl(flow->regs[mf->id - MFF_REG0]);
711 break;
712
713 CASE_MFF_XREGS:
714 value->be64 = htonll(flow_get_xreg(flow, mf->id - MFF_XREG0));
715 break;
716
717 CASE_MFF_XXREGS:
718 value->be128 = hton128(flow_get_xxreg(flow, mf->id - MFF_XXREG0));
719 break;
720
721 case MFF_ETH_SRC:
722 value->mac = flow->dl_src;
723 break;
724
725 case MFF_ETH_DST:
726 value->mac = flow->dl_dst;
727 break;
728
729 case MFF_ETH_TYPE:
730 value->be16 = flow->dl_type;
731 break;
732
733 case MFF_VLAN_TCI:
734 value->be16 = flow->vlan_tci;
735 break;
736
737 case MFF_DL_VLAN:
738 value->be16 = flow->vlan_tci & htons(VLAN_VID_MASK);
739 break;
740 case MFF_VLAN_VID:
741 value->be16 = flow->vlan_tci & htons(VLAN_VID_MASK | VLAN_CFI);
742 break;
743
744 case MFF_DL_VLAN_PCP:
745 case MFF_VLAN_PCP:
746 value->u8 = vlan_tci_to_pcp(flow->vlan_tci);
747 break;
748
749 case MFF_MPLS_LABEL:
750 value->be32 = htonl(mpls_lse_to_label(flow->mpls_lse[0]));
751 break;
752
753 case MFF_MPLS_TC:
754 value->u8 = mpls_lse_to_tc(flow->mpls_lse[0]);
755 break;
756
757 case MFF_MPLS_BOS:
758 value->u8 = mpls_lse_to_bos(flow->mpls_lse[0]);
759 break;
760
761 case MFF_MPLS_TTL:
762 value->u8 = mpls_lse_to_ttl(flow->mpls_lse[0]);
763 break;
764
765 case MFF_IPV4_SRC:
766 value->be32 = flow->nw_src;
767 break;
768
769 case MFF_IPV4_DST:
770 value->be32 = flow->nw_dst;
771 break;
772
773 case MFF_IPV6_SRC:
774 value->ipv6 = flow->ipv6_src;
775 break;
776
777 case MFF_IPV6_DST:
778 value->ipv6 = flow->ipv6_dst;
779 break;
780
781 case MFF_IPV6_LABEL:
782 value->be32 = flow->ipv6_label;
783 break;
784
785 case MFF_IP_PROTO:
786 value->u8 = flow->nw_proto;
787 break;
788
789 case MFF_IP_DSCP:
790 value->u8 = flow->nw_tos & IP_DSCP_MASK;
791 break;
792
793 case MFF_IP_DSCP_SHIFTED:
794 value->u8 = flow->nw_tos >> 2;
795 break;
796
797 case MFF_IP_ECN:
798 value->u8 = flow->nw_tos & IP_ECN_MASK;
799 break;
800
801 case MFF_IP_TTL:
802 value->u8 = flow->nw_ttl;
803 break;
804
805 case MFF_IP_FRAG:
806 value->u8 = flow->nw_frag;
807 break;
808
809 case MFF_ARP_OP:
810 value->be16 = htons(flow->nw_proto);
811 break;
812
813 case MFF_ARP_SPA:
814 value->be32 = flow->nw_src;
815 break;
816
817 case MFF_ARP_TPA:
818 value->be32 = flow->nw_dst;
819 break;
820
821 case MFF_ARP_SHA:
822 case MFF_ND_SLL:
823 value->mac = flow->arp_sha;
824 break;
825
826 case MFF_ARP_THA:
827 case MFF_ND_TLL:
828 value->mac = flow->arp_tha;
829 break;
830
831 case MFF_TCP_SRC:
832 case MFF_UDP_SRC:
833 case MFF_SCTP_SRC:
834 value->be16 = flow->tp_src;
835 break;
836
837 case MFF_TCP_DST:
838 case MFF_UDP_DST:
839 case MFF_SCTP_DST:
840 value->be16 = flow->tp_dst;
841 break;
842
843 case MFF_TCP_FLAGS:
844 value->be16 = flow->tcp_flags;
845 break;
846
847 case MFF_ICMPV4_TYPE:
848 case MFF_ICMPV6_TYPE:
849 value->u8 = ntohs(flow->tp_src);
850 break;
851
852 case MFF_ICMPV4_CODE:
853 case MFF_ICMPV6_CODE:
854 value->u8 = ntohs(flow->tp_dst);
855 break;
856
857 case MFF_ND_TARGET:
858 value->ipv6 = flow->nd_target;
859 break;
860
861 case MFF_N_IDS:
862 default:
863 OVS_NOT_REACHED();
864 }
865 }
866
867 /* Makes 'match' match field 'mf' exactly, with the value matched taken from
868 * 'value'. The caller is responsible for ensuring that 'match' meets 'mf''s
869 * prerequisites.
870 *
871 * If non-NULL, 'err_str' returns a malloc'ed string describing any errors
872 * with the request or NULL if there is no error. The caller is reponsible
873 * for freeing the string. */
874 void
875 mf_set_value(const struct mf_field *mf,
876 const union mf_value *value, struct match *match, char **err_str)
877 {
878 if (err_str) {
879 *err_str = NULL;
880 }
881
882 switch (mf->id) {
883 case MFF_DP_HASH:
884 match_set_dp_hash(match, ntohl(value->be32));
885 break;
886 case MFF_RECIRC_ID:
887 match_set_recirc_id(match, ntohl(value->be32));
888 break;
889 case MFF_CONJ_ID:
890 match_set_conj_id(match, ntohl(value->be32));
891 break;
892 case MFF_TUN_ID:
893 match_set_tun_id(match, value->be64);
894 break;
895 case MFF_TUN_SRC:
896 match_set_tun_src(match, value->be32);
897 break;
898 case MFF_TUN_DST:
899 match_set_tun_dst(match, value->be32);
900 break;
901 case MFF_TUN_IPV6_SRC:
902 match_set_tun_ipv6_src(match, &value->ipv6);
903 break;
904 case MFF_TUN_IPV6_DST:
905 match_set_tun_ipv6_dst(match, &value->ipv6);
906 break;
907 case MFF_TUN_FLAGS:
908 match_set_tun_flags(match, ntohs(value->be16));
909 break;
910 case MFF_TUN_GBP_ID:
911 match_set_tun_gbp_id(match, value->be16);
912 break;
913 case MFF_TUN_GBP_FLAGS:
914 match_set_tun_gbp_flags(match, value->u8);
915 break;
916 case MFF_TUN_TOS:
917 match_set_tun_tos(match, value->u8);
918 break;
919 case MFF_TUN_TTL:
920 match_set_tun_ttl(match, value->u8);
921 break;
922 CASE_MFF_TUN_METADATA:
923 tun_metadata_set_match(mf, value, NULL, match, err_str);
924 break;
925
926 case MFF_METADATA:
927 match_set_metadata(match, value->be64);
928 break;
929
930 case MFF_IN_PORT:
931 match_set_in_port(match, u16_to_ofp(ntohs(value->be16)));
932 break;
933
934 case MFF_IN_PORT_OXM: {
935 ofp_port_t port;
936 ofputil_port_from_ofp11(value->be32, &port);
937 match_set_in_port(match, port);
938 break;
939 }
940 case MFF_ACTSET_OUTPUT: {
941 ofp_port_t port;
942 ofputil_port_from_ofp11(value->be32, &port);
943 match_set_actset_output(match, port);
944 break;
945 }
946
947 case MFF_SKB_PRIORITY:
948 match_set_skb_priority(match, ntohl(value->be32));
949 break;
950
951 case MFF_PKT_MARK:
952 match_set_pkt_mark(match, ntohl(value->be32));
953 break;
954
955 case MFF_CT_STATE:
956 match_set_ct_state(match, ntohl(value->be32));
957 break;
958
959 case MFF_CT_ZONE:
960 match_set_ct_zone(match, ntohs(value->be16));
961 break;
962
963 case MFF_CT_MARK:
964 match_set_ct_mark(match, ntohl(value->be32));
965 break;
966
967 case MFF_CT_LABEL:
968 match_set_ct_label(match, ntoh128(value->be128));
969 break;
970
971 case MFF_CT_NW_PROTO:
972 match_set_ct_nw_proto(match, value->u8);
973 break;
974
975 case MFF_CT_NW_SRC:
976 match_set_ct_nw_src(match, value->be32);
977 break;
978
979 case MFF_CT_NW_DST:
980 match_set_ct_nw_dst(match, value->be32);
981 break;
982
983 case MFF_CT_IPV6_SRC:
984 match_set_ct_ipv6_src(match, &value->ipv6);
985 break;
986
987 case MFF_CT_IPV6_DST:
988 match_set_ct_ipv6_dst(match, &value->ipv6);
989 break;
990
991 case MFF_CT_TP_SRC:
992 match_set_ct_tp_src(match, value->be16);
993 break;
994
995 case MFF_CT_TP_DST:
996 match_set_ct_tp_dst(match, value->be16);
997 break;
998
999 CASE_MFF_REGS:
1000 match_set_reg(match, mf->id - MFF_REG0, ntohl(value->be32));
1001 break;
1002
1003 CASE_MFF_XREGS:
1004 match_set_xreg(match, mf->id - MFF_XREG0, ntohll(value->be64));
1005 break;
1006
1007 CASE_MFF_XXREGS:
1008 match_set_xxreg(match, mf->id - MFF_XXREG0, ntoh128(value->be128));
1009 break;
1010
1011 case MFF_ETH_SRC:
1012 match_set_dl_src(match, value->mac);
1013 break;
1014
1015 case MFF_ETH_DST:
1016 match_set_dl_dst(match, value->mac);
1017 break;
1018
1019 case MFF_ETH_TYPE:
1020 match_set_dl_type(match, value->be16);
1021 break;
1022
1023 case MFF_VLAN_TCI:
1024 match_set_dl_tci(match, value->be16);
1025 break;
1026
1027 case MFF_DL_VLAN:
1028 match_set_dl_vlan(match, value->be16);
1029 break;
1030 case MFF_VLAN_VID:
1031 match_set_vlan_vid(match, value->be16);
1032 break;
1033
1034 case MFF_DL_VLAN_PCP:
1035 case MFF_VLAN_PCP:
1036 match_set_dl_vlan_pcp(match, value->u8);
1037 break;
1038
1039 case MFF_MPLS_LABEL:
1040 match_set_mpls_label(match, 0, value->be32);
1041 break;
1042
1043 case MFF_MPLS_TC:
1044 match_set_mpls_tc(match, 0, value->u8);
1045 break;
1046
1047 case MFF_MPLS_BOS:
1048 match_set_mpls_bos(match, 0, value->u8);
1049 break;
1050
1051 case MFF_MPLS_TTL:
1052 match_set_mpls_ttl(match, 0, value->u8);
1053 break;
1054
1055 case MFF_IPV4_SRC:
1056 match_set_nw_src(match, value->be32);
1057 break;
1058
1059 case MFF_IPV4_DST:
1060 match_set_nw_dst(match, value->be32);
1061 break;
1062
1063 case MFF_IPV6_SRC:
1064 match_set_ipv6_src(match, &value->ipv6);
1065 break;
1066
1067 case MFF_IPV6_DST:
1068 match_set_ipv6_dst(match, &value->ipv6);
1069 break;
1070
1071 case MFF_IPV6_LABEL:
1072 match_set_ipv6_label(match, value->be32);
1073 break;
1074
1075 case MFF_IP_PROTO:
1076 match_set_nw_proto(match, value->u8);
1077 break;
1078
1079 case MFF_IP_DSCP:
1080 match_set_nw_dscp(match, value->u8);
1081 break;
1082
1083 case MFF_IP_DSCP_SHIFTED:
1084 match_set_nw_dscp(match, value->u8 << 2);
1085 break;
1086
1087 case MFF_IP_ECN:
1088 match_set_nw_ecn(match, value->u8);
1089 break;
1090
1091 case MFF_IP_TTL:
1092 match_set_nw_ttl(match, value->u8);
1093 break;
1094
1095 case MFF_IP_FRAG:
1096 match_set_nw_frag(match, value->u8);
1097 break;
1098
1099 case MFF_ARP_OP:
1100 match_set_nw_proto(match, ntohs(value->be16));
1101 break;
1102
1103 case MFF_ARP_SPA:
1104 match_set_nw_src(match, value->be32);
1105 break;
1106
1107 case MFF_ARP_TPA:
1108 match_set_nw_dst(match, value->be32);
1109 break;
1110
1111 case MFF_ARP_SHA:
1112 case MFF_ND_SLL:
1113 match_set_arp_sha(match, value->mac);
1114 break;
1115
1116 case MFF_ARP_THA:
1117 case MFF_ND_TLL:
1118 match_set_arp_tha(match, value->mac);
1119 break;
1120
1121 case MFF_TCP_SRC:
1122 case MFF_UDP_SRC:
1123 case MFF_SCTP_SRC:
1124 match_set_tp_src(match, value->be16);
1125 break;
1126
1127 case MFF_TCP_DST:
1128 case MFF_UDP_DST:
1129 case MFF_SCTP_DST:
1130 match_set_tp_dst(match, value->be16);
1131 break;
1132
1133 case MFF_TCP_FLAGS:
1134 match_set_tcp_flags(match, value->be16);
1135 break;
1136
1137 case MFF_ICMPV4_TYPE:
1138 case MFF_ICMPV6_TYPE:
1139 match_set_icmp_type(match, value->u8);
1140 break;
1141
1142 case MFF_ICMPV4_CODE:
1143 case MFF_ICMPV6_CODE:
1144 match_set_icmp_code(match, value->u8);
1145 break;
1146
1147 case MFF_ND_TARGET:
1148 match_set_nd_target(match, &value->ipv6);
1149 break;
1150
1151 case MFF_N_IDS:
1152 default:
1153 OVS_NOT_REACHED();
1154 }
1155 }
1156
1157 /* Unwildcard the bits in 'mask' of the 'wc' member field described by 'mf'.
1158 * The caller is responsible for ensuring that 'wc' meets 'mf''s
1159 * prerequisites. */
1160 void
1161 mf_mask_field_masked(const struct mf_field *mf, const union mf_value *mask,
1162 struct flow_wildcards *wc)
1163 {
1164 union mf_value temp_mask;
1165 /* For MFF_DL_VLAN, we cannot send a all 1's to flow_set_dl_vlan() as that
1166 * will be considered as OFP10_VLAN_NONE. So make sure the mask only has
1167 * valid bits in this case. */
1168 if (mf->id == MFF_DL_VLAN) {
1169 temp_mask.be16 = htons(VLAN_VID_MASK) & mask->be16;
1170 mask = &temp_mask;
1171 }
1172
1173 union mf_value mask_value;
1174
1175 mf_get_value(mf, &wc->masks, &mask_value);
1176 for (size_t i = 0; i < mf->n_bytes; i++) {
1177 mask_value.b[i] |= mask->b[i];
1178 }
1179 mf_set_flow_value(mf, &mask_value, &wc->masks);
1180 }
1181
1182 /* Unwildcard 'wc' member field described by 'mf'. The caller is
1183 * responsible for ensuring that 'mask' meets 'mf''s prerequisites. */
1184 void
1185 mf_mask_field(const struct mf_field *mf, struct flow_wildcards *wc)
1186 {
1187 mf_mask_field_masked(mf, &exact_match_mask, wc);
1188 }
1189
1190 static int
1191 field_len(const struct mf_field *mf, const union mf_value *value_)
1192 {
1193 const uint8_t *value = &value_->u8;
1194 int i;
1195
1196 if (!mf->variable_len) {
1197 return mf->n_bytes;
1198 }
1199
1200 if (!value) {
1201 return 0;
1202 }
1203
1204 for (i = 0; i < mf->n_bytes; i++) {
1205 if (value[i] != 0) {
1206 break;
1207 }
1208 }
1209
1210 return mf->n_bytes - i;
1211 }
1212
1213 /* Returns the effective length of the field. For fixed length fields,
1214 * this is just the defined length. For variable length fields, it is
1215 * the minimum size encoding that retains the same meaning (i.e.
1216 * discarding leading zeros).
1217 *
1218 * 'is_masked' returns (if non-NULL) whether the original contained
1219 * a mask. Otherwise, a mask that is the same length as the value
1220 * might be misinterpreted as an exact match. */
1221 int
1222 mf_field_len(const struct mf_field *mf, const union mf_value *value,
1223 const union mf_value *mask, bool *is_masked_)
1224 {
1225 int len, mask_len;
1226 bool is_masked = mask && !is_all_ones(mask, mf->n_bytes);
1227
1228 len = field_len(mf, value);
1229 if (is_masked) {
1230 mask_len = field_len(mf, mask);
1231 len = MAX(len, mask_len);
1232 }
1233
1234 if (is_masked_) {
1235 *is_masked_ = is_masked;
1236 }
1237
1238 return len;
1239 }
1240
1241 /* Sets 'flow' member field described by 'mf' to 'value'. The caller is
1242 * responsible for ensuring that 'flow' meets 'mf''s prerequisites.*/
1243 void
1244 mf_set_flow_value(const struct mf_field *mf,
1245 const union mf_value *value, struct flow *flow)
1246 {
1247 switch (mf->id) {
1248 case MFF_DP_HASH:
1249 flow->dp_hash = ntohl(value->be32);
1250 break;
1251 case MFF_RECIRC_ID:
1252 flow->recirc_id = ntohl(value->be32);
1253 break;
1254 case MFF_CONJ_ID:
1255 flow->conj_id = ntohl(value->be32);
1256 break;
1257 case MFF_TUN_ID:
1258 flow->tunnel.tun_id = value->be64;
1259 break;
1260 case MFF_TUN_SRC:
1261 flow->tunnel.ip_src = value->be32;
1262 break;
1263 case MFF_TUN_DST:
1264 flow->tunnel.ip_dst = value->be32;
1265 break;
1266 case MFF_TUN_IPV6_SRC:
1267 flow->tunnel.ipv6_src = value->ipv6;
1268 break;
1269 case MFF_TUN_IPV6_DST:
1270 flow->tunnel.ipv6_dst = value->ipv6;
1271 break;
1272 case MFF_TUN_FLAGS:
1273 flow->tunnel.flags = (flow->tunnel.flags & ~FLOW_TNL_PUB_F_MASK) |
1274 ntohs(value->be16);
1275 break;
1276 case MFF_TUN_GBP_ID:
1277 flow->tunnel.gbp_id = value->be16;
1278 break;
1279 case MFF_TUN_GBP_FLAGS:
1280 flow->tunnel.gbp_flags = value->u8;
1281 break;
1282 case MFF_TUN_TOS:
1283 flow->tunnel.ip_tos = value->u8;
1284 break;
1285 case MFF_TUN_TTL:
1286 flow->tunnel.ip_ttl = value->u8;
1287 break;
1288 CASE_MFF_TUN_METADATA:
1289 tun_metadata_write(&flow->tunnel, mf, value);
1290 break;
1291 case MFF_METADATA:
1292 flow->metadata = value->be64;
1293 break;
1294
1295 case MFF_IN_PORT:
1296 flow->in_port.ofp_port = u16_to_ofp(ntohs(value->be16));
1297 break;
1298
1299 case MFF_IN_PORT_OXM:
1300 ofputil_port_from_ofp11(value->be32, &flow->in_port.ofp_port);
1301 break;
1302 case MFF_ACTSET_OUTPUT:
1303 ofputil_port_from_ofp11(value->be32, &flow->actset_output);
1304 break;
1305
1306 case MFF_SKB_PRIORITY:
1307 flow->skb_priority = ntohl(value->be32);
1308 break;
1309
1310 case MFF_PKT_MARK:
1311 flow->pkt_mark = ntohl(value->be32);
1312 break;
1313
1314 case MFF_CT_STATE:
1315 flow->ct_state = ntohl(value->be32);
1316 break;
1317
1318 case MFF_CT_ZONE:
1319 flow->ct_zone = ntohs(value->be16);
1320 break;
1321
1322 case MFF_CT_MARK:
1323 flow->ct_mark = ntohl(value->be32);
1324 break;
1325
1326 case MFF_CT_LABEL:
1327 flow->ct_label = ntoh128(value->be128);
1328 break;
1329
1330 case MFF_CT_NW_PROTO:
1331 flow->ct_nw_proto = value->u8;
1332 break;
1333
1334 case MFF_CT_NW_SRC:
1335 flow->ct_nw_src = value->be32;
1336 break;
1337
1338 case MFF_CT_NW_DST:
1339 flow->ct_nw_dst = value->be32;
1340 break;
1341
1342 case MFF_CT_IPV6_SRC:
1343 flow->ct_ipv6_src = value->ipv6;
1344 break;
1345
1346 case MFF_CT_IPV6_DST:
1347 flow->ct_ipv6_dst = value->ipv6;
1348 break;
1349
1350 case MFF_CT_TP_SRC:
1351 flow->ct_tp_src = value->be16;
1352 break;
1353
1354 case MFF_CT_TP_DST:
1355 flow->ct_tp_dst = value->be16;
1356 break;
1357
1358 CASE_MFF_REGS:
1359 flow->regs[mf->id - MFF_REG0] = ntohl(value->be32);
1360 break;
1361
1362 CASE_MFF_XREGS:
1363 flow_set_xreg(flow, mf->id - MFF_XREG0, ntohll(value->be64));
1364 break;
1365
1366 CASE_MFF_XXREGS:
1367 flow_set_xxreg(flow, mf->id - MFF_XXREG0, ntoh128(value->be128));
1368 break;
1369
1370 case MFF_ETH_SRC:
1371 flow->dl_src = value->mac;
1372 break;
1373
1374 case MFF_ETH_DST:
1375 flow->dl_dst = value->mac;
1376 break;
1377
1378 case MFF_ETH_TYPE:
1379 flow->dl_type = value->be16;
1380 break;
1381
1382 case MFF_VLAN_TCI:
1383 flow->vlan_tci = value->be16;
1384 break;
1385
1386 case MFF_DL_VLAN:
1387 flow_set_dl_vlan(flow, value->be16);
1388 break;
1389 case MFF_VLAN_VID:
1390 flow_set_vlan_vid(flow, value->be16);
1391 break;
1392
1393 case MFF_DL_VLAN_PCP:
1394 case MFF_VLAN_PCP:
1395 flow_set_vlan_pcp(flow, value->u8);
1396 break;
1397
1398 case MFF_MPLS_LABEL:
1399 flow_set_mpls_label(flow, 0, value->be32);
1400 break;
1401
1402 case MFF_MPLS_TC:
1403 flow_set_mpls_tc(flow, 0, value->u8);
1404 break;
1405
1406 case MFF_MPLS_BOS:
1407 flow_set_mpls_bos(flow, 0, value->u8);
1408 break;
1409
1410 case MFF_MPLS_TTL:
1411 flow_set_mpls_ttl(flow, 0, value->u8);
1412 break;
1413
1414 case MFF_IPV4_SRC:
1415 flow->nw_src = value->be32;
1416 break;
1417
1418 case MFF_IPV4_DST:
1419 flow->nw_dst = value->be32;
1420 break;
1421
1422 case MFF_IPV6_SRC:
1423 flow->ipv6_src = value->ipv6;
1424 break;
1425
1426 case MFF_IPV6_DST:
1427 flow->ipv6_dst = value->ipv6;
1428 break;
1429
1430 case MFF_IPV6_LABEL:
1431 flow->ipv6_label = value->be32 & htonl(IPV6_LABEL_MASK);
1432 break;
1433
1434 case MFF_IP_PROTO:
1435 flow->nw_proto = value->u8;
1436 break;
1437
1438 case MFF_IP_DSCP:
1439 flow->nw_tos &= ~IP_DSCP_MASK;
1440 flow->nw_tos |= value->u8 & IP_DSCP_MASK;
1441 break;
1442
1443 case MFF_IP_DSCP_SHIFTED:
1444 flow->nw_tos &= ~IP_DSCP_MASK;
1445 flow->nw_tos |= value->u8 << 2;
1446 break;
1447
1448 case MFF_IP_ECN:
1449 flow->nw_tos &= ~IP_ECN_MASK;
1450 flow->nw_tos |= value->u8 & IP_ECN_MASK;
1451 break;
1452
1453 case MFF_IP_TTL:
1454 flow->nw_ttl = value->u8;
1455 break;
1456
1457 case MFF_IP_FRAG:
1458 flow->nw_frag = value->u8 & FLOW_NW_FRAG_MASK;
1459 break;
1460
1461 case MFF_ARP_OP:
1462 flow->nw_proto = ntohs(value->be16);
1463 break;
1464
1465 case MFF_ARP_SPA:
1466 flow->nw_src = value->be32;
1467 break;
1468
1469 case MFF_ARP_TPA:
1470 flow->nw_dst = value->be32;
1471 break;
1472
1473 case MFF_ARP_SHA:
1474 case MFF_ND_SLL:
1475 flow->arp_sha = value->mac;
1476 break;
1477
1478 case MFF_ARP_THA:
1479 case MFF_ND_TLL:
1480 flow->arp_tha = value->mac;
1481 break;
1482
1483 case MFF_TCP_SRC:
1484 case MFF_UDP_SRC:
1485 case MFF_SCTP_SRC:
1486 flow->tp_src = value->be16;
1487 break;
1488
1489 case MFF_TCP_DST:
1490 case MFF_UDP_DST:
1491 case MFF_SCTP_DST:
1492 flow->tp_dst = value->be16;
1493 break;
1494
1495 case MFF_TCP_FLAGS:
1496 flow->tcp_flags = value->be16;
1497 break;
1498
1499 case MFF_ICMPV4_TYPE:
1500 case MFF_ICMPV6_TYPE:
1501 flow->tp_src = htons(value->u8);
1502 break;
1503
1504 case MFF_ICMPV4_CODE:
1505 case MFF_ICMPV6_CODE:
1506 flow->tp_dst = htons(value->u8);
1507 break;
1508
1509 case MFF_ND_TARGET:
1510 flow->nd_target = value->ipv6;
1511 break;
1512
1513 case MFF_N_IDS:
1514 default:
1515 OVS_NOT_REACHED();
1516 }
1517 }
1518
1519 /* Consider each of 'src', 'mask', and 'dst' as if they were arrays of 8*n
1520 * bits. Then, for each 0 <= i < 8 * n such that mask[i] == 1, sets dst[i] =
1521 * src[i]. */
1522 static void
1523 apply_mask(const uint8_t *src, const uint8_t *mask, uint8_t *dst, size_t n)
1524 {
1525 size_t i;
1526
1527 for (i = 0; i < n; i++) {
1528 dst[i] = (src[i] & mask[i]) | (dst[i] & ~mask[i]);
1529 }
1530 }
1531
1532 /* Sets 'flow' member field described by 'field' to 'value', except that bits
1533 * for which 'mask' has a 0-bit keep their existing values. The caller is
1534 * responsible for ensuring that 'flow' meets 'field''s prerequisites.*/
1535 void
1536 mf_set_flow_value_masked(const struct mf_field *field,
1537 const union mf_value *value,
1538 const union mf_value *mask,
1539 struct flow *flow)
1540 {
1541 union mf_value tmp;
1542
1543 mf_get_value(field, flow, &tmp);
1544 apply_mask((const uint8_t *) value, (const uint8_t *) mask,
1545 (uint8_t *) &tmp, field->n_bytes);
1546 mf_set_flow_value(field, &tmp, flow);
1547 }
1548
1549 bool
1550 mf_is_tun_metadata(const struct mf_field *mf)
1551 {
1552 return mf->id >= MFF_TUN_METADATA0 &&
1553 mf->id < MFF_TUN_METADATA0 + TUN_METADATA_NUM_OPTS;
1554 }
1555
1556 /* Returns true if 'mf' has previously been set in 'flow', false if
1557 * it contains a non-default value.
1558 *
1559 * The caller is responsible for ensuring that 'flow' meets 'mf''s
1560 * prerequisites. */
1561 bool
1562 mf_is_set(const struct mf_field *mf, const struct flow *flow)
1563 {
1564 if (!mf_is_tun_metadata(mf)) {
1565 union mf_value value;
1566
1567 mf_get_value(mf, flow, &value);
1568 return !is_all_zeros(&value, mf->n_bytes);
1569 } else {
1570 return ULLONG_GET(flow->tunnel.metadata.present.map,
1571 mf->id - MFF_TUN_METADATA0);
1572 }
1573 }
1574
1575 /* Makes 'match' wildcard field 'mf'.
1576 *
1577 * The caller is responsible for ensuring that 'match' meets 'mf''s
1578 * prerequisites.
1579 *
1580 * If non-NULL, 'err_str' returns a malloc'ed string describing any errors
1581 * with the request or NULL if there is no error. The caller is reponsible
1582 * for freeing the string. */
1583 void
1584 mf_set_wild(const struct mf_field *mf, struct match *match, char **err_str)
1585 {
1586 if (err_str) {
1587 *err_str = NULL;
1588 }
1589
1590 switch (mf->id) {
1591 case MFF_DP_HASH:
1592 match->flow.dp_hash = 0;
1593 match->wc.masks.dp_hash = 0;
1594 break;
1595 case MFF_RECIRC_ID:
1596 match->flow.recirc_id = 0;
1597 match->wc.masks.recirc_id = 0;
1598 break;
1599 case MFF_CONJ_ID:
1600 match->flow.conj_id = 0;
1601 match->wc.masks.conj_id = 0;
1602 break;
1603 case MFF_TUN_ID:
1604 match_set_tun_id_masked(match, htonll(0), htonll(0));
1605 break;
1606 case MFF_TUN_SRC:
1607 match_set_tun_src_masked(match, htonl(0), htonl(0));
1608 break;
1609 case MFF_TUN_DST:
1610 match_set_tun_dst_masked(match, htonl(0), htonl(0));
1611 break;
1612 case MFF_TUN_IPV6_SRC:
1613 memset(&match->wc.masks.tunnel.ipv6_src, 0,
1614 sizeof match->wc.masks.tunnel.ipv6_src);
1615 memset(&match->flow.tunnel.ipv6_src, 0,
1616 sizeof match->flow.tunnel.ipv6_src);
1617 break;
1618 case MFF_TUN_IPV6_DST:
1619 memset(&match->wc.masks.tunnel.ipv6_dst, 0,
1620 sizeof match->wc.masks.tunnel.ipv6_dst);
1621 memset(&match->flow.tunnel.ipv6_dst, 0,
1622 sizeof match->flow.tunnel.ipv6_dst);
1623 break;
1624 case MFF_TUN_FLAGS:
1625 match_set_tun_flags_masked(match, 0, 0);
1626 break;
1627 case MFF_TUN_GBP_ID:
1628 match_set_tun_gbp_id_masked(match, 0, 0);
1629 break;
1630 case MFF_TUN_GBP_FLAGS:
1631 match_set_tun_gbp_flags_masked(match, 0, 0);
1632 break;
1633 case MFF_TUN_TOS:
1634 match_set_tun_tos_masked(match, 0, 0);
1635 break;
1636 case MFF_TUN_TTL:
1637 match_set_tun_ttl_masked(match, 0, 0);
1638 break;
1639 CASE_MFF_TUN_METADATA:
1640 tun_metadata_set_match(mf, NULL, NULL, match, err_str);
1641 break;
1642
1643 case MFF_METADATA:
1644 match_set_metadata_masked(match, htonll(0), htonll(0));
1645 break;
1646
1647 case MFF_IN_PORT:
1648 case MFF_IN_PORT_OXM:
1649 match->flow.in_port.ofp_port = 0;
1650 match->wc.masks.in_port.ofp_port = 0;
1651 break;
1652 case MFF_ACTSET_OUTPUT:
1653 match->flow.actset_output = 0;
1654 match->wc.masks.actset_output = 0;
1655 break;
1656
1657 case MFF_SKB_PRIORITY:
1658 match->flow.skb_priority = 0;
1659 match->wc.masks.skb_priority = 0;
1660 break;
1661
1662 case MFF_PKT_MARK:
1663 match->flow.pkt_mark = 0;
1664 match->wc.masks.pkt_mark = 0;
1665 break;
1666
1667 case MFF_CT_STATE:
1668 match->flow.ct_state = 0;
1669 match->wc.masks.ct_state = 0;
1670 break;
1671
1672 case MFF_CT_ZONE:
1673 match->flow.ct_zone = 0;
1674 match->wc.masks.ct_zone = 0;
1675 break;
1676
1677 case MFF_CT_MARK:
1678 match->flow.ct_mark = 0;
1679 match->wc.masks.ct_mark = 0;
1680 break;
1681
1682 case MFF_CT_LABEL:
1683 memset(&match->flow.ct_label, 0, sizeof(match->flow.ct_label));
1684 memset(&match->wc.masks.ct_label, 0, sizeof(match->wc.masks.ct_label));
1685 break;
1686
1687 case MFF_CT_NW_PROTO:
1688 match->flow.ct_nw_proto = 0;
1689 match->wc.masks.ct_nw_proto = 0;
1690 break;
1691
1692 case MFF_CT_NW_SRC:
1693 match->flow.ct_nw_src = 0;
1694 match->wc.masks.ct_nw_src = 0;
1695 break;
1696
1697 case MFF_CT_NW_DST:
1698 match->flow.ct_nw_dst = 0;
1699 match->wc.masks.ct_nw_dst = 0;
1700 break;
1701
1702 case MFF_CT_IPV6_SRC:
1703 memset(&match->flow.ct_ipv6_src, 0, sizeof(match->flow.ct_ipv6_src));
1704 WC_UNMASK_FIELD(&match->wc, ct_ipv6_src);
1705 break;
1706
1707 case MFF_CT_IPV6_DST:
1708 memset(&match->flow.ct_ipv6_dst, 0, sizeof(match->flow.ct_ipv6_dst));
1709 WC_UNMASK_FIELD(&match->wc, ct_ipv6_dst);
1710 break;
1711
1712 case MFF_CT_TP_SRC:
1713 match->flow.ct_tp_src = 0;
1714 match->wc.masks.ct_tp_src = 0;
1715 break;
1716
1717 case MFF_CT_TP_DST:
1718 match->flow.ct_tp_dst = 0;
1719 match->wc.masks.ct_tp_dst = 0;
1720 break;
1721
1722 CASE_MFF_REGS:
1723 match_set_reg_masked(match, mf->id - MFF_REG0, 0, 0);
1724 break;
1725
1726 CASE_MFF_XREGS:
1727 match_set_xreg_masked(match, mf->id - MFF_XREG0, 0, 0);
1728 break;
1729
1730 CASE_MFF_XXREGS: {
1731 match_set_xxreg_masked(match, mf->id - MFF_XXREG0, OVS_U128_ZERO,
1732 OVS_U128_ZERO);
1733 break;
1734 }
1735
1736 case MFF_ETH_SRC:
1737 match->flow.dl_src = eth_addr_zero;
1738 match->wc.masks.dl_src = eth_addr_zero;
1739 break;
1740
1741 case MFF_ETH_DST:
1742 match->flow.dl_dst = eth_addr_zero;
1743 match->wc.masks.dl_dst = eth_addr_zero;
1744 break;
1745
1746 case MFF_ETH_TYPE:
1747 match->flow.dl_type = htons(0);
1748 match->wc.masks.dl_type = htons(0);
1749 break;
1750
1751 case MFF_VLAN_TCI:
1752 match_set_dl_tci_masked(match, htons(0), htons(0));
1753 break;
1754
1755 case MFF_DL_VLAN:
1756 case MFF_VLAN_VID:
1757 match_set_any_vid(match);
1758 break;
1759
1760 case MFF_DL_VLAN_PCP:
1761 case MFF_VLAN_PCP:
1762 match_set_any_pcp(match);
1763 break;
1764
1765 case MFF_MPLS_LABEL:
1766 match_set_any_mpls_label(match, 0);
1767 break;
1768
1769 case MFF_MPLS_TC:
1770 match_set_any_mpls_tc(match, 0);
1771 break;
1772
1773 case MFF_MPLS_BOS:
1774 match_set_any_mpls_bos(match, 0);
1775 break;
1776
1777 case MFF_MPLS_TTL:
1778 match_set_any_mpls_ttl(match, 0);
1779 break;
1780
1781 case MFF_IPV4_SRC:
1782 case MFF_ARP_SPA:
1783 match_set_nw_src_masked(match, htonl(0), htonl(0));
1784 break;
1785
1786 case MFF_IPV4_DST:
1787 case MFF_ARP_TPA:
1788 match_set_nw_dst_masked(match, htonl(0), htonl(0));
1789 break;
1790
1791 case MFF_IPV6_SRC:
1792 memset(&match->wc.masks.ipv6_src, 0, sizeof match->wc.masks.ipv6_src);
1793 memset(&match->flow.ipv6_src, 0, sizeof match->flow.ipv6_src);
1794 break;
1795
1796 case MFF_IPV6_DST:
1797 memset(&match->wc.masks.ipv6_dst, 0, sizeof match->wc.masks.ipv6_dst);
1798 memset(&match->flow.ipv6_dst, 0, sizeof match->flow.ipv6_dst);
1799 break;
1800
1801 case MFF_IPV6_LABEL:
1802 match->wc.masks.ipv6_label = htonl(0);
1803 match->flow.ipv6_label = htonl(0);
1804 break;
1805
1806 case MFF_IP_PROTO:
1807 match->wc.masks.nw_proto = 0;
1808 match->flow.nw_proto = 0;
1809 break;
1810
1811 case MFF_IP_DSCP:
1812 case MFF_IP_DSCP_SHIFTED:
1813 match->wc.masks.nw_tos &= ~IP_DSCP_MASK;
1814 match->flow.nw_tos &= ~IP_DSCP_MASK;
1815 break;
1816
1817 case MFF_IP_ECN:
1818 match->wc.masks.nw_tos &= ~IP_ECN_MASK;
1819 match->flow.nw_tos &= ~IP_ECN_MASK;
1820 break;
1821
1822 case MFF_IP_TTL:
1823 match->wc.masks.nw_ttl = 0;
1824 match->flow.nw_ttl = 0;
1825 break;
1826
1827 case MFF_IP_FRAG:
1828 match->wc.masks.nw_frag &= ~FLOW_NW_FRAG_MASK;
1829 match->flow.nw_frag &= ~FLOW_NW_FRAG_MASK;
1830 break;
1831
1832 case MFF_ARP_OP:
1833 match->wc.masks.nw_proto = 0;
1834 match->flow.nw_proto = 0;
1835 break;
1836
1837 case MFF_ARP_SHA:
1838 case MFF_ND_SLL:
1839 match->flow.arp_sha = eth_addr_zero;
1840 match->wc.masks.arp_sha = eth_addr_zero;
1841 break;
1842
1843 case MFF_ARP_THA:
1844 case MFF_ND_TLL:
1845 match->flow.arp_tha = eth_addr_zero;
1846 match->wc.masks.arp_tha = eth_addr_zero;
1847 break;
1848
1849 case MFF_TCP_SRC:
1850 case MFF_UDP_SRC:
1851 case MFF_SCTP_SRC:
1852 case MFF_ICMPV4_TYPE:
1853 case MFF_ICMPV6_TYPE:
1854 match->wc.masks.tp_src = htons(0);
1855 match->flow.tp_src = htons(0);
1856 break;
1857
1858 case MFF_TCP_DST:
1859 case MFF_UDP_DST:
1860 case MFF_SCTP_DST:
1861 case MFF_ICMPV4_CODE:
1862 case MFF_ICMPV6_CODE:
1863 match->wc.masks.tp_dst = htons(0);
1864 match->flow.tp_dst = htons(0);
1865 break;
1866
1867 case MFF_TCP_FLAGS:
1868 match->wc.masks.tcp_flags = htons(0);
1869 match->flow.tcp_flags = htons(0);
1870 break;
1871
1872 case MFF_ND_TARGET:
1873 memset(&match->wc.masks.nd_target, 0,
1874 sizeof match->wc.masks.nd_target);
1875 memset(&match->flow.nd_target, 0, sizeof match->flow.nd_target);
1876 break;
1877
1878 case MFF_N_IDS:
1879 default:
1880 OVS_NOT_REACHED();
1881 }
1882 }
1883
1884 /* Makes 'match' match field 'mf' with the specified 'value' and 'mask'.
1885 * 'value' specifies a value to match and 'mask' specifies a wildcard pattern,
1886 * with a 1-bit indicating that the corresponding value bit must match and a
1887 * 0-bit indicating a don't-care.
1888 *
1889 * If 'mask' is NULL or points to all-1-bits, then this call is equivalent to
1890 * mf_set_value(mf, value, match). If 'mask' points to all-0-bits, then this
1891 * call is equivalent to mf_set_wild(mf, match).
1892 *
1893 * 'mask' must be a valid mask for 'mf' (see mf_is_mask_valid()). The caller
1894 * is responsible for ensuring that 'match' meets 'mf''s prerequisites.
1895 *
1896 * If non-NULL, 'err_str' returns a malloc'ed string describing any errors
1897 * with the request or NULL if there is no error. The caller is reponsible
1898 * for freeing the string.
1899 *
1900 * Return a set of enum ofputil_protocol bits (as an uint32_t to avoid circular
1901 * dependency on enum ofputil_protocol definition) indicating which OpenFlow
1902 * protocol versions can support this functionality. */
1903 uint32_t
1904 mf_set(const struct mf_field *mf,
1905 const union mf_value *value, const union mf_value *mask,
1906 struct match *match, char **err_str)
1907 {
1908 if (!mask || is_all_ones(mask, mf->n_bytes)) {
1909 mf_set_value(mf, value, match, err_str);
1910 return mf->usable_protocols_exact;
1911 } else if (is_all_zeros(mask, mf->n_bytes) && !mf_is_tun_metadata(mf)) {
1912 /* Tunnel metadata matches on the existence of the field itself, so
1913 * it still needs to be encoded even if the value is wildcarded. */
1914 mf_set_wild(mf, match, err_str);
1915 return OFPUTIL_P_ANY;
1916 }
1917
1918 if (err_str) {
1919 *err_str = NULL;
1920 }
1921
1922 switch (mf->id) {
1923 case MFF_CT_ZONE:
1924 case MFF_CT_NW_PROTO:
1925 case MFF_CT_NW_SRC:
1926 case MFF_CT_NW_DST:
1927 case MFF_CT_IPV6_SRC:
1928 case MFF_CT_IPV6_DST:
1929 case MFF_CT_TP_SRC:
1930 case MFF_CT_TP_DST:
1931 case MFF_RECIRC_ID:
1932 case MFF_CONJ_ID:
1933 case MFF_IN_PORT:
1934 case MFF_IN_PORT_OXM:
1935 case MFF_ACTSET_OUTPUT:
1936 case MFF_SKB_PRIORITY:
1937 case MFF_ETH_TYPE:
1938 case MFF_DL_VLAN:
1939 case MFF_DL_VLAN_PCP:
1940 case MFF_VLAN_PCP:
1941 case MFF_MPLS_LABEL:
1942 case MFF_MPLS_TC:
1943 case MFF_MPLS_BOS:
1944 case MFF_MPLS_TTL:
1945 case MFF_IP_PROTO:
1946 case MFF_IP_TTL:
1947 case MFF_IP_DSCP:
1948 case MFF_IP_DSCP_SHIFTED:
1949 case MFF_IP_ECN:
1950 case MFF_ARP_OP:
1951 case MFF_ICMPV4_TYPE:
1952 case MFF_ICMPV4_CODE:
1953 case MFF_ICMPV6_TYPE:
1954 case MFF_ICMPV6_CODE:
1955 return OFPUTIL_P_NONE;
1956
1957 case MFF_DP_HASH:
1958 match_set_dp_hash_masked(match, ntohl(value->be32), ntohl(mask->be32));
1959 break;
1960 case MFF_TUN_ID:
1961 match_set_tun_id_masked(match, value->be64, mask->be64);
1962 break;
1963 case MFF_TUN_SRC:
1964 match_set_tun_src_masked(match, value->be32, mask->be32);
1965 break;
1966 case MFF_TUN_DST:
1967 match_set_tun_dst_masked(match, value->be32, mask->be32);
1968 break;
1969 case MFF_TUN_IPV6_SRC:
1970 match_set_tun_ipv6_src_masked(match, &value->ipv6, &mask->ipv6);
1971 break;
1972 case MFF_TUN_IPV6_DST:
1973 match_set_tun_ipv6_dst_masked(match, &value->ipv6, &mask->ipv6);
1974 break;
1975 case MFF_TUN_FLAGS:
1976 match_set_tun_flags_masked(match, ntohs(value->be16), ntohs(mask->be16));
1977 break;
1978 case MFF_TUN_GBP_ID:
1979 match_set_tun_gbp_id_masked(match, value->be16, mask->be16);
1980 break;
1981 case MFF_TUN_GBP_FLAGS:
1982 match_set_tun_gbp_flags_masked(match, value->u8, mask->u8);
1983 break;
1984 case MFF_TUN_TTL:
1985 match_set_tun_ttl_masked(match, value->u8, mask->u8);
1986 break;
1987 case MFF_TUN_TOS:
1988 match_set_tun_tos_masked(match, value->u8, mask->u8);
1989 break;
1990 CASE_MFF_TUN_METADATA:
1991 tun_metadata_set_match(mf, value, mask, match, err_str);
1992 break;
1993
1994 case MFF_METADATA:
1995 match_set_metadata_masked(match, value->be64, mask->be64);
1996 break;
1997
1998 CASE_MFF_REGS:
1999 match_set_reg_masked(match, mf->id - MFF_REG0,
2000 ntohl(value->be32), ntohl(mask->be32));
2001 break;
2002
2003 CASE_MFF_XREGS:
2004 match_set_xreg_masked(match, mf->id - MFF_XREG0,
2005 ntohll(value->be64), ntohll(mask->be64));
2006 break;
2007
2008 CASE_MFF_XXREGS: {
2009 match_set_xxreg_masked(match, mf->id - MFF_XXREG0,
2010 ntoh128(value->be128), ntoh128(mask->be128));
2011 break;
2012 }
2013
2014 case MFF_PKT_MARK:
2015 match_set_pkt_mark_masked(match, ntohl(value->be32),
2016 ntohl(mask->be32));
2017 break;
2018
2019 case MFF_CT_STATE:
2020 match_set_ct_state_masked(match, ntohl(value->be32), ntohl(mask->be32));
2021 break;
2022
2023 case MFF_CT_MARK:
2024 match_set_ct_mark_masked(match, ntohl(value->be32), ntohl(mask->be32));
2025 break;
2026
2027 case MFF_CT_LABEL:
2028 match_set_ct_label_masked(match, ntoh128(value->be128),
2029 mask ? ntoh128(mask->be128) : OVS_U128_MAX);
2030 break;
2031
2032 case MFF_ETH_DST:
2033 match_set_dl_dst_masked(match, value->mac, mask->mac);
2034 break;
2035
2036 case MFF_ETH_SRC:
2037 match_set_dl_src_masked(match, value->mac, mask->mac);
2038 break;
2039
2040 case MFF_ARP_SHA:
2041 case MFF_ND_SLL:
2042 match_set_arp_sha_masked(match, value->mac, mask->mac);
2043 break;
2044
2045 case MFF_ARP_THA:
2046 case MFF_ND_TLL:
2047 match_set_arp_tha_masked(match, value->mac, mask->mac);
2048 break;
2049
2050 case MFF_VLAN_TCI:
2051 match_set_dl_tci_masked(match, value->be16, mask->be16);
2052 break;
2053
2054 case MFF_VLAN_VID:
2055 match_set_vlan_vid_masked(match, value->be16, mask->be16);
2056 break;
2057
2058 case MFF_IPV4_SRC:
2059 match_set_nw_src_masked(match, value->be32, mask->be32);
2060 break;
2061
2062 case MFF_IPV4_DST:
2063 match_set_nw_dst_masked(match, value->be32, mask->be32);
2064 break;
2065
2066 case MFF_IPV6_SRC:
2067 match_set_ipv6_src_masked(match, &value->ipv6, &mask->ipv6);
2068 break;
2069
2070 case MFF_IPV6_DST:
2071 match_set_ipv6_dst_masked(match, &value->ipv6, &mask->ipv6);
2072 break;
2073
2074 case MFF_IPV6_LABEL:
2075 if ((mask->be32 & htonl(IPV6_LABEL_MASK)) == htonl(IPV6_LABEL_MASK)) {
2076 mf_set_value(mf, value, match, err_str);
2077 } else {
2078 match_set_ipv6_label_masked(match, value->be32, mask->be32);
2079 }
2080 break;
2081
2082 case MFF_ND_TARGET:
2083 match_set_nd_target_masked(match, &value->ipv6, &mask->ipv6);
2084 break;
2085
2086 case MFF_IP_FRAG:
2087 match_set_nw_frag_masked(match, value->u8, mask->u8);
2088 break;
2089
2090 case MFF_ARP_SPA:
2091 match_set_nw_src_masked(match, value->be32, mask->be32);
2092 break;
2093
2094 case MFF_ARP_TPA:
2095 match_set_nw_dst_masked(match, value->be32, mask->be32);
2096 break;
2097
2098 case MFF_TCP_SRC:
2099 case MFF_UDP_SRC:
2100 case MFF_SCTP_SRC:
2101 match_set_tp_src_masked(match, value->be16, mask->be16);
2102 break;
2103
2104 case MFF_TCP_DST:
2105 case MFF_UDP_DST:
2106 case MFF_SCTP_DST:
2107 match_set_tp_dst_masked(match, value->be16, mask->be16);
2108 break;
2109
2110 case MFF_TCP_FLAGS:
2111 match_set_tcp_flags_masked(match, value->be16, mask->be16);
2112 break;
2113
2114 case MFF_N_IDS:
2115 default:
2116 OVS_NOT_REACHED();
2117 }
2118
2119 return ((mf->usable_protocols_bitwise == mf->usable_protocols_cidr
2120 || ip_is_cidr(mask->be32))
2121 ? mf->usable_protocols_cidr
2122 : mf->usable_protocols_bitwise);
2123 }
2124
2125 static enum ofperr
2126 mf_check__(const struct mf_subfield *sf, const struct match *match,
2127 const char *type)
2128 {
2129 if (!sf->field) {
2130 VLOG_WARN_RL(&rl, "unknown %s field", type);
2131 return OFPERR_OFPBAC_BAD_SET_TYPE;
2132 } else if (!sf->n_bits) {
2133 VLOG_WARN_RL(&rl, "zero bit %s field %s", type, sf->field->name);
2134 return OFPERR_OFPBAC_BAD_SET_LEN;
2135 } else if (sf->ofs >= sf->field->n_bits) {
2136 VLOG_WARN_RL(&rl, "bit offset %d exceeds %d-bit width of %s field %s",
2137 sf->ofs, sf->field->n_bits, type, sf->field->name);
2138 return OFPERR_OFPBAC_BAD_SET_LEN;
2139 } else if (sf->ofs + sf->n_bits > sf->field->n_bits) {
2140 VLOG_WARN_RL(&rl, "bit offset %d and width %d exceeds %d-bit width "
2141 "of %s field %s", sf->ofs, sf->n_bits,
2142 sf->field->n_bits, type, sf->field->name);
2143 return OFPERR_OFPBAC_BAD_SET_LEN;
2144 } else if (match && !mf_are_match_prereqs_ok(sf->field, match)) {
2145 VLOG_WARN_RL(&rl, "%s field %s lacks correct prerequisites",
2146 type, sf->field->name);
2147 return OFPERR_OFPBAC_MATCH_INCONSISTENT;
2148 } else {
2149 return 0;
2150 }
2151 }
2152
2153 /* Sets all the bits in 'sf' to 1 within 'wc', if 'wc' is nonnull. */
2154 static void
2155 unwildcard_subfield(const struct mf_subfield *sf, struct flow_wildcards *wc)
2156 {
2157 if (wc) {
2158 union mf_value mask;
2159
2160 memset(&mask, 0, sizeof mask);
2161 bitwise_one(&mask, sf->field->n_bytes, sf->ofs, sf->n_bits);
2162 mf_mask_field_masked(sf->field, &mask, wc);
2163 }
2164 }
2165
2166 /* Copies 'src' into 'dst' within 'flow', and sets all the bits in 'src' and
2167 * 'dst' to 1s in 'wc', if 'wc' is nonnull.
2168 *
2169 * 'src' and 'dst' may overlap. */
2170 void
2171 mf_subfield_copy(const struct mf_subfield *src,
2172 const struct mf_subfield *dst,
2173 struct flow *flow, struct flow_wildcards *wc)
2174 {
2175 ovs_assert(src->n_bits == dst->n_bits);
2176 if (mf_are_prereqs_ok(dst->field, flow, wc)
2177 && mf_are_prereqs_ok(src->field, flow, wc)) {
2178 unwildcard_subfield(src, wc);
2179 unwildcard_subfield(dst, wc);
2180
2181 union mf_value src_value;
2182 union mf_value dst_value;
2183 mf_get_value(dst->field, flow, &dst_value);
2184 mf_get_value(src->field, flow, &src_value);
2185 bitwise_copy(&src_value, src->field->n_bytes, src->ofs,
2186 &dst_value, dst->field->n_bytes, dst->ofs,
2187 src->n_bits);
2188 mf_set_flow_value(dst->field, &dst_value, flow);
2189 }
2190 }
2191
2192 /* Swaps the bits in 'src' and 'dst' within 'flow', and sets all the bits in
2193 * 'src' and 'dst' to 1s in 'wc', if 'wc' is nonnull.
2194 *
2195 * 'src' and 'dst' may overlap. */
2196 void
2197 mf_subfield_swap(const struct mf_subfield *a,
2198 const struct mf_subfield *b,
2199 struct flow *flow, struct flow_wildcards *wc)
2200 {
2201 ovs_assert(a->n_bits == b->n_bits);
2202 if (mf_are_prereqs_ok(a->field, flow, wc)
2203 && mf_are_prereqs_ok(b->field, flow, wc)) {
2204 unwildcard_subfield(a, wc);
2205 unwildcard_subfield(b, wc);
2206
2207 union mf_value a_value;
2208 union mf_value b_value;
2209 mf_get_value(a->field, flow, &a_value);
2210 mf_get_value(b->field, flow, &b_value);
2211 union mf_value b2_value = b_value;
2212
2213 /* Copy 'a' into 'b'. */
2214 bitwise_copy(&a_value, a->field->n_bytes, a->ofs,
2215 &b_value, b->field->n_bytes, b->ofs,
2216 a->n_bits);
2217 mf_set_flow_value(b->field, &b_value, flow);
2218
2219 /* Copy original 'b' into 'a'. */
2220 bitwise_copy(&b2_value, b->field->n_bytes, b->ofs,
2221 &a_value, a->field->n_bytes, a->ofs,
2222 b->n_bits);
2223 mf_set_flow_value(a->field, &a_value, flow);
2224 }
2225 }
2226
2227 /* Checks whether 'sf' is valid for reading a subfield out of 'flow'. Returns
2228 * 0 if so, otherwise an OpenFlow error code (e.g. as returned by
2229 * ofp_mkerr()). */
2230 enum ofperr
2231 mf_check_src(const struct mf_subfield *sf, const struct match *match)
2232 {
2233 return mf_check__(sf, match, "source");
2234 }
2235
2236 /* Checks whether 'sf' is valid for writing a subfield into 'flow'. Returns 0
2237 * if so, otherwise an OpenFlow error code (e.g. as returned by
2238 * ofp_mkerr()). */
2239 enum ofperr
2240 mf_check_dst(const struct mf_subfield *sf, const struct match *match)
2241 {
2242 int error = mf_check__(sf, match, "destination");
2243 if (!error && !sf->field->writable) {
2244 VLOG_WARN_RL(&rl, "destination field %s is not writable",
2245 sf->field->name);
2246 return OFPERR_OFPBAC_BAD_SET_ARGUMENT;
2247 }
2248 return error;
2249 }
2250
2251 /* Copies the value and wildcard bit pattern for 'mf' from 'match' into the
2252 * 'value' and 'mask', respectively. */
2253 void
2254 mf_get(const struct mf_field *mf, const struct match *match,
2255 union mf_value *value, union mf_value *mask)
2256 {
2257 mf_get_value(mf, &match->flow, value);
2258 mf_get_mask(mf, &match->wc, mask);
2259 }
2260
2261 static char *
2262 mf_from_integer_string(const struct mf_field *mf, const char *s,
2263 uint8_t *valuep, uint8_t *maskp)
2264 {
2265 char *tail;
2266 const char *err_str = "";
2267 int err;
2268
2269 err = parse_int_string(s, valuep, mf->n_bytes, &tail);
2270 if (err || (*tail != '\0' && *tail != '/')) {
2271 err_str = "value";
2272 goto syntax_error;
2273 }
2274
2275 if (*tail == '/') {
2276 err = parse_int_string(tail + 1, maskp, mf->n_bytes, &tail);
2277 if (err || *tail != '\0') {
2278 err_str = "mask";
2279 goto syntax_error;
2280 }
2281 } else {
2282 memset(maskp, 0xff, mf->n_bytes);
2283 }
2284
2285 return NULL;
2286
2287 syntax_error:
2288 if (err == ERANGE) {
2289 return xasprintf("%s: %s too large for %u-byte field %s",
2290 s, err_str, mf->n_bytes, mf->name);
2291 } else {
2292 return xasprintf("%s: bad syntax for %s %s", s, mf->name, err_str);
2293 }
2294 }
2295
2296 static char *
2297 mf_from_ethernet_string(const struct mf_field *mf, const char *s,
2298 struct eth_addr *mac, struct eth_addr *mask)
2299 {
2300 int n;
2301
2302 ovs_assert(mf->n_bytes == ETH_ADDR_LEN);
2303
2304 n = -1;
2305 if (ovs_scan(s, ETH_ADDR_SCAN_FMT"%n", ETH_ADDR_SCAN_ARGS(*mac), &n)
2306 && n == strlen(s)) {
2307 *mask = eth_addr_exact;
2308 return NULL;
2309 }
2310
2311 n = -1;
2312 if (ovs_scan(s, ETH_ADDR_SCAN_FMT"/"ETH_ADDR_SCAN_FMT"%n",
2313 ETH_ADDR_SCAN_ARGS(*mac), ETH_ADDR_SCAN_ARGS(*mask), &n)
2314 && n == strlen(s)) {
2315 return NULL;
2316 }
2317
2318 return xasprintf("%s: invalid Ethernet address", s);
2319 }
2320
2321 static char *
2322 mf_from_ipv4_string(const struct mf_field *mf, const char *s,
2323 ovs_be32 *ip, ovs_be32 *mask)
2324 {
2325 ovs_assert(mf->n_bytes == sizeof *ip);
2326 return ip_parse_masked(s, ip, mask);
2327 }
2328
2329 static char *
2330 mf_from_ipv6_string(const struct mf_field *mf, const char *s,
2331 struct in6_addr *ipv6, struct in6_addr *mask)
2332 {
2333 ovs_assert(mf->n_bytes == sizeof *ipv6);
2334 return ipv6_parse_masked(s, ipv6, mask);
2335 }
2336
2337 static char *
2338 mf_from_ofp_port_string(const struct mf_field *mf, const char *s,
2339 ovs_be16 *valuep, ovs_be16 *maskp)
2340 {
2341 ofp_port_t port;
2342
2343 ovs_assert(mf->n_bytes == sizeof(ovs_be16));
2344
2345 if (ofputil_port_from_string(s, &port)) {
2346 *valuep = htons(ofp_to_u16(port));
2347 *maskp = OVS_BE16_MAX;
2348 return NULL;
2349 }
2350 return xasprintf("%s: port value out of range for %s", s, mf->name);
2351 }
2352
2353 static char *
2354 mf_from_ofp_port_string32(const struct mf_field *mf, const char *s,
2355 ovs_be32 *valuep, ovs_be32 *maskp)
2356 {
2357 ofp_port_t port;
2358
2359 ovs_assert(mf->n_bytes == sizeof(ovs_be32));
2360 if (ofputil_port_from_string(s, &port)) {
2361 *valuep = ofputil_port_to_ofp11(port);
2362 *maskp = OVS_BE32_MAX;
2363 return NULL;
2364 }
2365 return xasprintf("%s: port value out of range for %s", s, mf->name);
2366 }
2367
2368 struct frag_handling {
2369 const char *name;
2370 uint8_t mask;
2371 uint8_t value;
2372 };
2373
2374 static const struct frag_handling all_frags[] = {
2375 #define A FLOW_NW_FRAG_ANY
2376 #define L FLOW_NW_FRAG_LATER
2377 /* name mask value */
2378
2379 { "no", A|L, 0 },
2380 { "first", A|L, A },
2381 { "later", A|L, A|L },
2382
2383 { "no", A, 0 },
2384 { "yes", A, A },
2385
2386 { "not_later", L, 0 },
2387 { "later", L, L },
2388 #undef A
2389 #undef L
2390 };
2391
2392 static char *
2393 mf_from_frag_string(const char *s, uint8_t *valuep, uint8_t *maskp)
2394 {
2395 const struct frag_handling *h;
2396
2397 for (h = all_frags; h < &all_frags[ARRAY_SIZE(all_frags)]; h++) {
2398 if (!strcasecmp(s, h->name)) {
2399 /* We force the upper bits of the mask on to make mf_parse_value()
2400 * happy (otherwise it will never think it's an exact match.) */
2401 *maskp = h->mask | ~FLOW_NW_FRAG_MASK;
2402 *valuep = h->value;
2403 return NULL;
2404 }
2405 }
2406
2407 return xasprintf("%s: unknown fragment type (valid types are \"no\", "
2408 "\"yes\", \"first\", \"later\", \"not_first\"", s);
2409 }
2410
2411 static char *
2412 parse_mf_flags(const char *s, const char *(*bit_to_string)(uint32_t),
2413 const char *field_name, ovs_be16 *flagsp, ovs_be16 allowed,
2414 ovs_be16 *maskp)
2415 {
2416 int err;
2417 char *err_str;
2418 uint32_t flags, mask;
2419
2420 err = parse_flags(s, bit_to_string, '\0', field_name, &err_str,
2421 &flags, ntohs(allowed), maskp ? &mask : NULL);
2422 if (err < 0) {
2423 return err_str;
2424 }
2425
2426 *flagsp = htons(flags);
2427 if (maskp) {
2428 *maskp = htons(mask);
2429 }
2430
2431 return NULL;
2432 }
2433
2434 static char *
2435 mf_from_tcp_flags_string(const char *s, ovs_be16 *flagsp, ovs_be16 *maskp)
2436 {
2437 return parse_mf_flags(s, packet_tcp_flag_to_string, "TCP", flagsp,
2438 TCP_FLAGS_BE16(OVS_BE16_MAX), maskp);
2439 }
2440
2441 static char *
2442 mf_from_tun_flags_string(const char *s, ovs_be16 *flagsp, ovs_be16 *maskp)
2443 {
2444 return parse_mf_flags(s, flow_tun_flag_to_string, "tunnel", flagsp,
2445 htons(FLOW_TNL_PUB_F_MASK), maskp);
2446 }
2447
2448 static char *
2449 mf_from_ct_state_string(const char *s, ovs_be32 *flagsp, ovs_be32 *maskp)
2450 {
2451 int err;
2452 char *err_str;
2453 uint32_t flags, mask;
2454
2455 err = parse_flags(s, ct_state_to_string, '\0', "ct_state", &err_str,
2456 &flags, CS_SUPPORTED_MASK, maskp ? &mask : NULL);
2457 if (err < 0) {
2458 return err_str;
2459 }
2460
2461 *flagsp = htonl(flags);
2462 if (maskp) {
2463 *maskp = htonl(mask);
2464 }
2465
2466 return NULL;
2467 }
2468
2469 /* Parses 's', a string value for field 'mf', into 'value' and 'mask'. Returns
2470 * NULL if successful, otherwise a malloc()'d string describing the error. */
2471 char *
2472 mf_parse(const struct mf_field *mf, const char *s,
2473 union mf_value *value, union mf_value *mask)
2474 {
2475 char *error;
2476
2477 if (!strcmp(s, "*")) {
2478 memset(value, 0, mf->n_bytes);
2479 memset(mask, 0, mf->n_bytes);
2480 return NULL;
2481 }
2482
2483 switch (mf->string) {
2484 case MFS_DECIMAL:
2485 case MFS_HEXADECIMAL:
2486 error = mf_from_integer_string(mf, s,
2487 (uint8_t *) value, (uint8_t *) mask);
2488 break;
2489
2490 case MFS_CT_STATE:
2491 ovs_assert(mf->n_bytes == sizeof(ovs_be32));
2492 error = mf_from_ct_state_string(s, &value->be32, &mask->be32);
2493 break;
2494
2495 case MFS_ETHERNET:
2496 error = mf_from_ethernet_string(mf, s, &value->mac, &mask->mac);
2497 break;
2498
2499 case MFS_IPV4:
2500 error = mf_from_ipv4_string(mf, s, &value->be32, &mask->be32);
2501 break;
2502
2503 case MFS_IPV6:
2504 error = mf_from_ipv6_string(mf, s, &value->ipv6, &mask->ipv6);
2505 break;
2506
2507 case MFS_OFP_PORT:
2508 error = mf_from_ofp_port_string(mf, s, &value->be16, &mask->be16);
2509 break;
2510
2511 case MFS_OFP_PORT_OXM:
2512 error = mf_from_ofp_port_string32(mf, s, &value->be32, &mask->be32);
2513 break;
2514
2515 case MFS_FRAG:
2516 error = mf_from_frag_string(s, &value->u8, &mask->u8);
2517 break;
2518
2519 case MFS_TNL_FLAGS:
2520 ovs_assert(mf->n_bytes == sizeof(ovs_be16));
2521 error = mf_from_tun_flags_string(s, &value->be16, &mask->be16);
2522 break;
2523
2524 case MFS_TCP_FLAGS:
2525 ovs_assert(mf->n_bytes == sizeof(ovs_be16));
2526 error = mf_from_tcp_flags_string(s, &value->be16, &mask->be16);
2527 break;
2528
2529 default:
2530 OVS_NOT_REACHED();
2531 }
2532
2533 if (!error && !mf_is_mask_valid(mf, mask)) {
2534 error = xasprintf("%s: invalid mask for field %s", s, mf->name);
2535 }
2536 return error;
2537 }
2538
2539 /* Parses 's', a string value for field 'mf', into 'value'. Returns NULL if
2540 * successful, otherwise a malloc()'d string describing the error. */
2541 char *
2542 mf_parse_value(const struct mf_field *mf, const char *s, union mf_value *value)
2543 {
2544 union mf_value mask;
2545 char *error;
2546
2547 error = mf_parse(mf, s, value, &mask);
2548 if (error) {
2549 return error;
2550 }
2551
2552 if (!is_all_ones((const uint8_t *) &mask, mf->n_bytes)) {
2553 return xasprintf("%s: wildcards not allowed here", s);
2554 }
2555 return NULL;
2556 }
2557
2558 static void
2559 mf_format_integer_string(const struct mf_field *mf, const uint8_t *valuep,
2560 const uint8_t *maskp, struct ds *s)
2561 {
2562 if (mf->string == MFS_HEXADECIMAL) {
2563 ds_put_hex(s, valuep, mf->n_bytes);
2564 } else {
2565 unsigned long long int integer = 0;
2566 int i;
2567
2568 ovs_assert(mf->n_bytes <= 8);
2569 for (i = 0; i < mf->n_bytes; i++) {
2570 integer = (integer << 8) | valuep[i];
2571 }
2572 ds_put_format(s, "%lld", integer);
2573 }
2574
2575 if (maskp) {
2576 /* I guess we could write the mask in decimal for MFS_DECIMAL but I'm
2577 * not sure that that a bit-mask written in decimal is ever easier to
2578 * understand than the same bit-mask written in hexadecimal. */
2579 ds_put_char(s, '/');
2580 ds_put_hex(s, maskp, mf->n_bytes);
2581 }
2582 }
2583
2584 static void
2585 mf_format_frag_string(uint8_t value, uint8_t mask, struct ds *s)
2586 {
2587 const struct frag_handling *h;
2588
2589 mask &= FLOW_NW_FRAG_MASK;
2590 value &= mask;
2591
2592 for (h = all_frags; h < &all_frags[ARRAY_SIZE(all_frags)]; h++) {
2593 if (value == h->value && mask == h->mask) {
2594 ds_put_cstr(s, h->name);
2595 return;
2596 }
2597 }
2598 ds_put_cstr(s, "<error>");
2599 }
2600
2601 static void
2602 mf_format_tnl_flags_string(ovs_be16 value, ovs_be16 mask, struct ds *s)
2603 {
2604 format_flags_masked(s, NULL, flow_tun_flag_to_string, ntohs(value),
2605 ntohs(mask) & FLOW_TNL_PUB_F_MASK, FLOW_TNL_PUB_F_MASK);
2606 }
2607
2608 static void
2609 mf_format_tcp_flags_string(ovs_be16 value, ovs_be16 mask, struct ds *s)
2610 {
2611 format_flags_masked(s, NULL, packet_tcp_flag_to_string, ntohs(value),
2612 TCP_FLAGS(mask), TCP_FLAGS(OVS_BE16_MAX));
2613 }
2614
2615 static void
2616 mf_format_ct_state_string(ovs_be32 value, ovs_be32 mask, struct ds *s)
2617 {
2618 format_flags_masked(s, NULL, ct_state_to_string, ntohl(value),
2619 ntohl(mask), UINT16_MAX);
2620 }
2621
2622 /* Appends to 's' a string representation of field 'mf' whose value is in
2623 * 'value' and 'mask'. 'mask' may be NULL to indicate an exact match. */
2624 void
2625 mf_format(const struct mf_field *mf,
2626 const union mf_value *value, const union mf_value *mask,
2627 struct ds *s)
2628 {
2629 if (mask) {
2630 if (is_all_zeros(mask, mf->n_bytes)) {
2631 ds_put_cstr(s, "ANY");
2632 return;
2633 } else if (is_all_ones(mask, mf->n_bytes)) {
2634 mask = NULL;
2635 }
2636 }
2637
2638 switch (mf->string) {
2639 case MFS_OFP_PORT_OXM:
2640 if (!mask) {
2641 ofp_port_t port;
2642 ofputil_port_from_ofp11(value->be32, &port);
2643 ofputil_format_port(port, s);
2644 break;
2645 }
2646 /* fall through */
2647 case MFS_OFP_PORT:
2648 if (!mask) {
2649 ofputil_format_port(u16_to_ofp(ntohs(value->be16)), s);
2650 break;
2651 }
2652 /* fall through */
2653 case MFS_DECIMAL:
2654 case MFS_HEXADECIMAL:
2655 mf_format_integer_string(mf, (uint8_t *) value, (uint8_t *) mask, s);
2656 break;
2657
2658 case MFS_CT_STATE:
2659 mf_format_ct_state_string(value->be32,
2660 mask ? mask->be32 : OVS_BE32_MAX, s);
2661 break;
2662
2663 case MFS_ETHERNET:
2664 eth_format_masked(value->mac, mask ? &mask->mac : NULL, s);
2665 break;
2666
2667 case MFS_IPV4:
2668 ip_format_masked(value->be32, mask ? mask->be32 : OVS_BE32_MAX, s);
2669 break;
2670
2671 case MFS_IPV6:
2672 ipv6_format_masked(&value->ipv6, mask ? &mask->ipv6 : NULL, s);
2673 break;
2674
2675 case MFS_FRAG:
2676 mf_format_frag_string(value->u8, mask ? mask->u8 : UINT8_MAX, s);
2677 break;
2678
2679 case MFS_TNL_FLAGS:
2680 mf_format_tnl_flags_string(value->be16,
2681 mask ? mask->be16 : OVS_BE16_MAX, s);
2682 break;
2683
2684 case MFS_TCP_FLAGS:
2685 mf_format_tcp_flags_string(value->be16,
2686 mask ? mask->be16 : OVS_BE16_MAX, s);
2687 break;
2688
2689 default:
2690 OVS_NOT_REACHED();
2691 }
2692 }
2693 \f
2694 /* Makes subfield 'sf' within 'flow' exactly match the 'sf->n_bits'
2695 * least-significant bits in 'x'.
2696 */
2697 void
2698 mf_write_subfield_flow(const struct mf_subfield *sf,
2699 const union mf_subvalue *x, struct flow *flow)
2700 {
2701 const struct mf_field *field = sf->field;
2702 union mf_value value;
2703
2704 mf_get_value(field, flow, &value);
2705 bitwise_copy(x, sizeof *x, 0, &value, field->n_bytes,
2706 sf->ofs, sf->n_bits);
2707 mf_set_flow_value(field, &value, flow);
2708 }
2709
2710 /* Makes subfield 'sf' within 'match' exactly match the 'sf->n_bits'
2711 * least-significant bits in 'x'.
2712 */
2713 void
2714 mf_write_subfield(const struct mf_subfield *sf, const union mf_subvalue *x,
2715 struct match *match)
2716 {
2717 const struct mf_field *field = sf->field;
2718 union mf_value value, mask;
2719
2720 mf_get(field, match, &value, &mask);
2721 bitwise_copy(x, sizeof *x, 0, &value, field->n_bytes, sf->ofs, sf->n_bits);
2722 bitwise_one ( &mask, field->n_bytes, sf->ofs, sf->n_bits);
2723 mf_set(field, &value, &mask, match, NULL);
2724 }
2725
2726 void
2727 mf_write_subfield_value(const struct mf_subfield *sf, const void *src,
2728 struct match *match)
2729 {
2730 const struct mf_field *field = sf->field;
2731 union mf_value value, mask;
2732 unsigned int size = DIV_ROUND_UP(sf->n_bits, 8);
2733
2734 mf_get(field, match, &value, &mask);
2735 bitwise_copy(src, size, 0, &value, field->n_bytes, sf->ofs, sf->n_bits);
2736 bitwise_one ( &mask, field->n_bytes, sf->ofs, sf->n_bits);
2737 mf_set(field, &value, &mask, match, NULL);
2738 }
2739
2740 /* 'v' and 'm' correspond to values of 'field'. This function copies them into
2741 * 'match' in the correspond positions. */
2742 void
2743 mf_mask_subfield(const struct mf_field *field,
2744 const union mf_subvalue *v,
2745 const union mf_subvalue *m,
2746 struct match *match)
2747 {
2748 union mf_value value, mask;
2749
2750 mf_get(field, match, &value, &mask);
2751 bitwise_copy(v, sizeof *v, 0, &value, field->n_bytes, 0, field->n_bits);
2752 bitwise_copy(m, sizeof *m, 0, &mask, field->n_bytes, 0, field->n_bits);
2753 mf_set(field, &value, &mask, match, NULL);
2754 }
2755
2756 /* Initializes 'x' to the value of 'sf' within 'flow'. 'sf' must be valid for
2757 * reading 'flow', e.g. as checked by mf_check_src(). */
2758 void
2759 mf_read_subfield(const struct mf_subfield *sf, const struct flow *flow,
2760 union mf_subvalue *x)
2761 {
2762 union mf_value value;
2763
2764 mf_get_value(sf->field, flow, &value);
2765
2766 memset(x, 0, sizeof *x);
2767 bitwise_copy(&value, sf->field->n_bytes, sf->ofs,
2768 x, sizeof *x, 0,
2769 sf->n_bits);
2770 }
2771
2772 /* Returns the value of 'sf' within 'flow'. 'sf' must be valid for reading
2773 * 'flow', e.g. as checked by mf_check_src() and sf->n_bits must be 64 or
2774 * less. */
2775 uint64_t
2776 mf_get_subfield(const struct mf_subfield *sf, const struct flow *flow)
2777 {
2778 union mf_value value;
2779
2780 mf_get_value(sf->field, flow, &value);
2781 return bitwise_get(&value, sf->field->n_bytes, sf->ofs, sf->n_bits);
2782 }
2783
2784 void
2785 mf_format_subvalue(const union mf_subvalue *subvalue, struct ds *s)
2786 {
2787 ds_put_hex(s, subvalue->u8, sizeof subvalue->u8);
2788 }
2789
2790 void
2791 field_array_set(enum mf_field_id id, const union mf_value *value,
2792 struct field_array *fa)
2793 {
2794 size_t i, offset = 0;
2795
2796 ovs_assert(id < MFF_N_IDS);
2797
2798 /* Find the spot for 'id'. */
2799 BITMAP_FOR_EACH_1 (i, id, fa->used.bm) {
2800 offset += mf_from_id(i)->n_bytes;
2801 }
2802
2803 size_t value_size = mf_from_id(id)->n_bytes;
2804
2805 /* make room if necessary. */
2806 if (!bitmap_is_set(fa->used.bm, id)) {
2807 fa->values = xrealloc(fa->values, fa->values_size + value_size);
2808 /* Move remainder forward, if any. */
2809 if (offset < fa->values_size) {
2810 memmove(fa->values + offset + value_size, fa->values + offset,
2811 fa->values_size - offset);
2812 }
2813 fa->values_size += value_size;
2814 }
2815 bitmap_set1(fa->used.bm, id);
2816
2817 memcpy(fa->values + offset, value, value_size);
2818 }
2819
2820 /* A wrapper for variable length mf_fields that is maintained by
2821 * struct vl_mff_map.*/
2822 struct vl_mf_field {
2823 struct mf_field mf;
2824 struct cmap_node cmap_node; /* In ofproto->vl_mff_map->cmap. */
2825 };
2826
2827 static inline uint32_t
2828 mf_field_hash(uint32_t key)
2829 {
2830 return hash_int(key, 0);
2831 }
2832
2833 void
2834 mf_vl_mff_map_clear(struct vl_mff_map *vl_mff_map)
2835 OVS_REQUIRES(vl_mff_map->mutex)
2836 {
2837 struct vl_mf_field *vmf;
2838
2839 CMAP_FOR_EACH (vmf, cmap_node, &vl_mff_map->cmap) {
2840 cmap_remove(&vl_mff_map->cmap, &vmf->cmap_node,
2841 mf_field_hash(vmf->mf.id));
2842 ovsrcu_postpone(free, vmf);
2843 }
2844 }
2845
2846 static struct vl_mf_field *
2847 mf_get_vl_mff__(uint32_t id, const struct vl_mff_map *vl_mff_map)
2848 {
2849 struct vl_mf_field *vmf;
2850
2851 CMAP_FOR_EACH_WITH_HASH (vmf, cmap_node, mf_field_hash(id),
2852 &vl_mff_map->cmap) {
2853 if (vmf->mf.id == id) {
2854 return vmf;
2855 }
2856 }
2857
2858 return NULL;
2859 }
2860
2861 /* If 'mff' is a variable length field, looks up 'vl_mff_map', returns a
2862 * pointer to the variable length meta-flow field corresponding to 'mff'.
2863 * Returns NULL if no mapping is existed for 'mff'. */
2864 const struct mf_field *
2865 mf_get_vl_mff(const struct mf_field *mff,
2866 const struct vl_mff_map *vl_mff_map)
2867 {
2868 if (mff && mff->variable_len && vl_mff_map) {
2869 return &mf_get_vl_mff__(mff->id, vl_mff_map)->mf;
2870 }
2871
2872 return NULL;
2873 }
2874
2875 /* Updates the tun_metadata mf_field in 'vl_mff_map' according to 'ttm'.
2876 * This function is supposed to be invoked after tun_metadata_table_mod(). */
2877 enum ofperr
2878 mf_vl_mff_map_mod_from_tun_metadata(struct vl_mff_map *vl_mff_map,
2879 const struct ofputil_tlv_table_mod *ttm)
2880 OVS_REQUIRES(vl_mff_map->mutex)
2881 {
2882 struct ofputil_tlv_map *tlv_map;
2883
2884 if (ttm->command == NXTTMC_CLEAR) {
2885 mf_vl_mff_map_clear(vl_mff_map);
2886 return 0;
2887 }
2888
2889 LIST_FOR_EACH (tlv_map, list_node, &ttm->mappings) {
2890 unsigned int idx = MFF_TUN_METADATA0 + tlv_map->index;
2891 struct vl_mf_field *vmf;
2892
2893 if (idx >= MFF_TUN_METADATA0 + TUN_METADATA_NUM_OPTS) {
2894 return OFPERR_NXTTMFC_BAD_FIELD_IDX;
2895 }
2896
2897 switch (ttm->command) {
2898 case NXTTMC_ADD:
2899 vmf = xmalloc(sizeof *vmf);
2900 vmf->mf = mf_fields[idx];
2901 vmf->mf.n_bytes = tlv_map->option_len;
2902 vmf->mf.n_bits = tlv_map->option_len * 8;
2903 vmf->mf.mapped = true;
2904
2905 cmap_insert(&vl_mff_map->cmap, &vmf->cmap_node,
2906 mf_field_hash(idx));
2907 break;
2908
2909 case NXTTMC_DELETE:
2910 vmf = mf_get_vl_mff__(idx, vl_mff_map);
2911 if (vmf) {
2912 cmap_remove(&vl_mff_map->cmap, &vmf->cmap_node,
2913 mf_field_hash(idx));
2914 ovsrcu_postpone(free, vmf);
2915 }
2916 break;
2917
2918 case NXTTMC_CLEAR:
2919 default:
2920 OVS_NOT_REACHED();
2921 }
2922 }
2923
2924 return 0;
2925 }
2926
2927 /* Returns true if a variable length meta-flow field 'mff' is not mapped in
2928 * the 'vl_mff_map'. */
2929 bool
2930 mf_vl_mff_invalid(const struct mf_field *mff, const struct vl_mff_map *map)
2931 {
2932 return map && mff && mff->variable_len && !mff->mapped;
2933 }
openvswitch packages for PVE