connmgr: Drop 'next_in_band_update' timer.
[openvswitch] / lib / nx-match.c
1 /*
2  * Copyright (c) 2010, 2011 Nicira Networks.
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 "nx-match.h"
20
21 #include <netinet/icmp6.h>
22
23 #include "classifier.h"
24 #include "dynamic-string.h"
25 #include "ofp-util.h"
26 #include "ofpbuf.h"
27 #include "openflow/nicira-ext.h"
28 #include "packets.h"
29 #include "unaligned.h"
30 #include "vlog.h"
31
32 VLOG_DEFINE_THIS_MODULE(nx_match);
33
34 /* Rate limit for nx_match parse errors.  These always indicate a bug in the
35  * peer and so there's not much point in showing a lot of them. */
36 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
37
38 enum {
39     NXM_INVALID = OFP_MKERR_NICIRA(OFPET_BAD_REQUEST, NXBRC_NXM_INVALID),
40     NXM_BAD_TYPE = OFP_MKERR_NICIRA(OFPET_BAD_REQUEST, NXBRC_NXM_BAD_TYPE),
41     NXM_BAD_VALUE = OFP_MKERR_NICIRA(OFPET_BAD_REQUEST, NXBRC_NXM_BAD_VALUE),
42     NXM_BAD_MASK = OFP_MKERR_NICIRA(OFPET_BAD_REQUEST, NXBRC_NXM_BAD_MASK),
43     NXM_BAD_PREREQ = OFP_MKERR_NICIRA(OFPET_BAD_REQUEST, NXBRC_NXM_BAD_PREREQ),
44     NXM_DUP_TYPE = OFP_MKERR_NICIRA(OFPET_BAD_REQUEST, NXBRC_NXM_DUP_TYPE),
45     BAD_ARGUMENT = OFP_MKERR(OFPET_BAD_ACTION, OFPBAC_BAD_ARGUMENT)
46 };
47
48 /* For each NXM_* field, define NFI_NXM_* as consecutive integers starting from
49  * zero. */
50 enum nxm_field_index {
51 #define DEFINE_FIELD(HEADER, WILDCARD, DL_TYPES, NW_PROTO, WRITABLE) \
52         NFI_NXM_##HEADER,
53 #include "nx-match.def"
54     N_NXM_FIELDS
55 };
56
57 struct nxm_field {
58     struct hmap_node hmap_node;
59     enum nxm_field_index index;       /* NFI_* value. */
60     uint32_t header;                  /* NXM_* value. */
61     flow_wildcards_t wildcard;        /* FWW_* bit, if exactly one. */
62     ovs_be16 dl_type[N_NXM_DL_TYPES]; /* dl_type prerequisites. */
63     uint8_t nw_proto;                 /* nw_proto prerequisite, if nonzero. */
64     const char *name;                 /* "NXM_*" string. */
65     bool writable;                    /* Writable with NXAST_REG_{MOVE,LOAD}? */
66 };
67
68
69 /* All the known fields. */
70 static struct nxm_field nxm_fields[N_NXM_FIELDS] = {
71 #define DEFINE_FIELD(HEADER, WILDCARD, DL_TYPES, NW_PROTO, WRITABLE)     \
72     { HMAP_NODE_NULL_INITIALIZER, NFI_NXM_##HEADER, NXM_##HEADER, WILDCARD, \
73         DL_CONVERT DL_TYPES, NW_PROTO, "NXM_" #HEADER, WRITABLE },
74 #define DL_CONVERT(T1, T2) { CONSTANT_HTONS(T1), CONSTANT_HTONS(T2) }
75 #include "nx-match.def"
76 };
77
78 /* Hash table of 'nxm_fields'. */
79 static struct hmap all_nxm_fields = HMAP_INITIALIZER(&all_nxm_fields);
80
81 static void
82 nxm_init(void)
83 {
84     if (hmap_is_empty(&all_nxm_fields)) {
85         int i;
86
87         for (i = 0; i < N_NXM_FIELDS; i++) {
88             struct nxm_field *f = &nxm_fields[i];
89             hmap_insert(&all_nxm_fields, &f->hmap_node,
90                         hash_int(f->header, 0));
91         }
92
93         /* Verify that the header values are unique (duplicate "case" values
94          * cause a compile error). */
95         switch (0) {
96 #define DEFINE_FIELD(HEADER, WILDCARD, DL_TYPE, NW_PROTO, WRITABLE)  \
97         case NXM_##HEADER: break;
98 #include "nx-match.def"
99         }
100     }
101 }
102
103 static const struct nxm_field *
104 nxm_field_lookup(uint32_t header)
105 {
106     struct nxm_field *f;
107
108     nxm_init();
109
110     HMAP_FOR_EACH_WITH_HASH (f, hmap_node, hash_int(header, 0),
111                              &all_nxm_fields) {
112         if (f->header == header) {
113             return f;
114         }
115     }
116
117     return NULL;
118 }
119
120 /* Returns the width of the data for a field with the given 'header', in
121  * bytes. */
122 int
123 nxm_field_bytes(uint32_t header)
124 {
125     unsigned int length = NXM_LENGTH(header);
126     return NXM_HASMASK(header) ? length / 2 : length;
127 }
128
129 /* Returns the width of the data for a field with the given 'header', in
130  * bits. */
131 int
132 nxm_field_bits(uint32_t header)
133 {
134     return nxm_field_bytes(header) * 8;
135 }
136 \f
137 /* nx_pull_match() and helpers. */
138
139 static int
140 parse_nx_reg(const struct nxm_field *f,
141              struct flow *flow, struct flow_wildcards *wc,
142              const void *value, const void *maskp)
143 {
144     int idx = NXM_NX_REG_IDX(f->header);
145     if (wc->reg_masks[idx]) {
146         return NXM_DUP_TYPE;
147     } else {
148         flow_wildcards_set_reg_mask(wc, idx,
149                                     (NXM_HASMASK(f->header)
150                                      ? ntohl(get_unaligned_be32(maskp))
151                                      : UINT32_MAX));
152         flow->regs[idx] = ntohl(get_unaligned_be32(value));
153         flow->regs[idx] &= wc->reg_masks[idx];
154         return 0;
155     }
156 }
157
158 static int
159 parse_nxm_entry(struct cls_rule *rule, const struct nxm_field *f,
160                 const void *value, const void *mask)
161 {
162     struct flow_wildcards *wc = &rule->wc;
163     struct flow *flow = &rule->flow;
164
165     switch (f->index) {
166         /* Metadata. */
167     case NFI_NXM_OF_IN_PORT:
168         flow->in_port = ntohs(get_unaligned_be16(value));
169         return 0;
170
171         /* Ethernet header. */
172     case NFI_NXM_OF_ETH_DST:
173         if ((wc->wildcards & (FWW_DL_DST | FWW_ETH_MCAST))
174             != (FWW_DL_DST | FWW_ETH_MCAST)) {
175             return NXM_DUP_TYPE;
176         } else {
177             wc->wildcards &= ~(FWW_DL_DST | FWW_ETH_MCAST);
178             memcpy(flow->dl_dst, value, ETH_ADDR_LEN);
179             return 0;
180         }
181     case NFI_NXM_OF_ETH_DST_W:
182         if ((wc->wildcards & (FWW_DL_DST | FWW_ETH_MCAST))
183             != (FWW_DL_DST | FWW_ETH_MCAST)) {
184             return NXM_DUP_TYPE;
185         } else if (flow_wildcards_is_dl_dst_mask_valid(mask)) {
186             cls_rule_set_dl_dst_masked(rule, value, mask);
187             return 0;
188         } else {
189             return NXM_BAD_MASK;
190         }
191     case NFI_NXM_OF_ETH_SRC:
192         memcpy(flow->dl_src, value, ETH_ADDR_LEN);
193         return 0;
194     case NFI_NXM_OF_ETH_TYPE:
195         flow->dl_type = ofputil_dl_type_from_openflow(get_unaligned_be16(value));
196         return 0;
197
198         /* 802.1Q header. */
199     case NFI_NXM_OF_VLAN_TCI:
200         if (wc->vlan_tci_mask) {
201             return NXM_DUP_TYPE;
202         } else {
203             cls_rule_set_dl_tci(rule, get_unaligned_be16(value));
204             return 0;
205         }
206     case NFI_NXM_OF_VLAN_TCI_W:
207         if (wc->vlan_tci_mask) {
208             return NXM_DUP_TYPE;
209         } else {
210             cls_rule_set_dl_tci_masked(rule, get_unaligned_be16(value),
211                                        get_unaligned_be16(mask));
212             return 0;
213         }
214
215         /* IP header. */
216     case NFI_NXM_OF_IP_TOS:
217         if (*(uint8_t *) value & 0x03) {
218             return NXM_BAD_VALUE;
219         } else {
220             flow->nw_tos = *(uint8_t *) value;
221             return 0;
222         }
223     case NFI_NXM_OF_IP_PROTO:
224         flow->nw_proto = *(uint8_t *) value;
225         return 0;
226
227         /* IP addresses in IP and ARP headers. */
228     case NFI_NXM_OF_IP_SRC:
229     case NFI_NXM_OF_ARP_SPA:
230         if (wc->nw_src_mask) {
231             return NXM_DUP_TYPE;
232         } else {
233             cls_rule_set_nw_src(rule, get_unaligned_be32(value));
234             return 0;
235         }
236     case NFI_NXM_OF_IP_SRC_W:
237     case NFI_NXM_OF_ARP_SPA_W:
238         if (wc->nw_src_mask) {
239             return NXM_DUP_TYPE;
240         } else {
241             ovs_be32 ip = get_unaligned_be32(value);
242             ovs_be32 netmask = get_unaligned_be32(mask);
243             if (!cls_rule_set_nw_src_masked(rule, ip, netmask)) {
244                 return NXM_BAD_MASK;
245             }
246             return 0;
247         }
248     case NFI_NXM_OF_IP_DST:
249     case NFI_NXM_OF_ARP_TPA:
250         if (wc->nw_dst_mask) {
251             return NXM_DUP_TYPE;
252         } else {
253             cls_rule_set_nw_dst(rule, get_unaligned_be32(value));
254             return 0;
255         }
256     case NFI_NXM_OF_IP_DST_W:
257     case NFI_NXM_OF_ARP_TPA_W:
258         if (wc->nw_dst_mask) {
259             return NXM_DUP_TYPE;
260         } else {
261             ovs_be32 ip = get_unaligned_be32(value);
262             ovs_be32 netmask = get_unaligned_be32(mask);
263             if (!cls_rule_set_nw_dst_masked(rule, ip, netmask)) {
264                 return NXM_BAD_MASK;
265             }
266             return 0;
267         }
268
269         /* IPv6 addresses. */
270     case NFI_NXM_NX_IPV6_SRC:
271         if (!ipv6_mask_is_any(&wc->ipv6_src_mask)) {
272             return NXM_DUP_TYPE;
273         } else {
274             struct in6_addr ipv6;
275             memcpy(&ipv6, value, sizeof ipv6);
276             cls_rule_set_ipv6_src(rule, &ipv6);
277             return 0;
278         }
279     case NFI_NXM_NX_IPV6_SRC_W:
280         if (!ipv6_mask_is_any(&wc->ipv6_src_mask)) {
281             return NXM_DUP_TYPE;
282         } else {
283             struct in6_addr ipv6, netmask;
284             memcpy(&ipv6, value, sizeof ipv6);
285             memcpy(&netmask, mask, sizeof netmask);
286             if (!cls_rule_set_ipv6_src_masked(rule, &ipv6, &netmask)) {
287                 return NXM_BAD_MASK;
288             }
289             return 0;
290         }
291     case NFI_NXM_NX_IPV6_DST:
292         if (!ipv6_mask_is_any(&wc->ipv6_dst_mask)) {
293             return NXM_DUP_TYPE;
294         } else {
295             struct in6_addr ipv6;
296             memcpy(&ipv6, value, sizeof ipv6);
297             cls_rule_set_ipv6_dst(rule, &ipv6);
298             return 0;
299         }
300     case NFI_NXM_NX_IPV6_DST_W:
301         if (!ipv6_mask_is_any(&wc->ipv6_dst_mask)) {
302             return NXM_DUP_TYPE;
303         } else {
304             struct in6_addr ipv6, netmask;
305             memcpy(&ipv6, value, sizeof ipv6);
306             memcpy(&netmask, mask, sizeof netmask);
307             if (!cls_rule_set_ipv6_dst_masked(rule, &ipv6, &netmask)) {
308                 return NXM_BAD_MASK;
309             }
310             return 0;
311         }
312
313         /* TCP header. */
314     case NFI_NXM_OF_TCP_SRC:
315         flow->tp_src = get_unaligned_be16(value);
316         return 0;
317     case NFI_NXM_OF_TCP_DST:
318         flow->tp_dst = get_unaligned_be16(value);
319         return 0;
320
321         /* UDP header. */
322     case NFI_NXM_OF_UDP_SRC:
323         flow->tp_src = get_unaligned_be16(value);
324         return 0;
325     case NFI_NXM_OF_UDP_DST:
326         flow->tp_dst = get_unaligned_be16(value);
327         return 0;
328
329         /* ICMP header. */
330     case NFI_NXM_OF_ICMP_TYPE:
331         flow->tp_src = htons(*(uint8_t *) value);
332         return 0;
333     case NFI_NXM_OF_ICMP_CODE:
334         flow->tp_dst = htons(*(uint8_t *) value);
335         return 0;
336
337         /* ICMPv6 header. */
338     case NFI_NXM_NX_ICMPV6_TYPE:
339         flow->tp_src = htons(*(uint8_t *) value);
340         return 0;
341     case NFI_NXM_NX_ICMPV6_CODE:
342         flow->tp_dst = htons(*(uint8_t *) value);
343         return 0;
344
345         /* IPv6 Neighbor Discovery. */
346     case NFI_NXM_NX_ND_TARGET:
347         /* We've already verified that it's an ICMPv6 message. */
348         if ((flow->tp_src != htons(ND_NEIGHBOR_SOLICIT))
349                     && (flow->tp_src != htons(ND_NEIGHBOR_ADVERT))) {
350             return NXM_BAD_PREREQ;
351         }
352         memcpy(&flow->nd_target, value, sizeof flow->nd_target);
353         return 0;
354     case NFI_NXM_NX_ND_SLL:
355         /* We've already verified that it's an ICMPv6 message. */
356         if (flow->tp_src != htons(ND_NEIGHBOR_SOLICIT)) {
357             return NXM_BAD_PREREQ;
358         }
359         memcpy(flow->arp_sha, value, ETH_ADDR_LEN);
360         return 0;
361     case NFI_NXM_NX_ND_TLL:
362         /* We've already verified that it's an ICMPv6 message. */
363         if (flow->tp_src != htons(ND_NEIGHBOR_ADVERT)) {
364             return NXM_BAD_PREREQ;
365         }
366         memcpy(flow->arp_tha, value, ETH_ADDR_LEN);
367         return 0;
368
369         /* ARP header. */
370     case NFI_NXM_OF_ARP_OP:
371         if (ntohs(get_unaligned_be16(value)) > 255) {
372             return NXM_BAD_VALUE;
373         } else {
374             flow->nw_proto = ntohs(get_unaligned_be16(value));
375             return 0;
376         }
377
378     case NFI_NXM_NX_ARP_SHA:
379         memcpy(flow->arp_sha, value, ETH_ADDR_LEN);
380         return 0;
381     case NFI_NXM_NX_ARP_THA:
382         memcpy(flow->arp_tha, value, ETH_ADDR_LEN);
383         return 0;
384
385         /* Tunnel ID. */
386     case NFI_NXM_NX_TUN_ID:
387         if (wc->tun_id_mask) {
388             return NXM_DUP_TYPE;
389         } else {
390             cls_rule_set_tun_id(rule, get_unaligned_be64(value));
391             return 0;
392         }
393     case NFI_NXM_NX_TUN_ID_W:
394         if (wc->tun_id_mask) {
395             return NXM_DUP_TYPE;
396         } else {
397             ovs_be64 tun_id = get_unaligned_be64(value);
398             ovs_be64 tun_mask = get_unaligned_be64(mask);
399             cls_rule_set_tun_id_masked(rule, tun_id, tun_mask);
400             return 0;
401         }
402
403         /* Registers. */
404     case NFI_NXM_NX_REG0:
405     case NFI_NXM_NX_REG0_W:
406 #if FLOW_N_REGS >= 2
407     case NFI_NXM_NX_REG1:
408     case NFI_NXM_NX_REG1_W:
409 #endif
410 #if FLOW_N_REGS >= 3
411     case NFI_NXM_NX_REG2:
412     case NFI_NXM_NX_REG2_W:
413 #endif
414 #if FLOW_N_REGS >= 4
415     case NFI_NXM_NX_REG3:
416     case NFI_NXM_NX_REG3_W:
417 #endif
418 #if FLOW_N_REGS > 4
419 #error
420 #endif
421         return parse_nx_reg(f, flow, wc, value, mask);
422
423     case N_NXM_FIELDS:
424         NOT_REACHED();
425     }
426     NOT_REACHED();
427 }
428
429 static bool
430 nxm_prereqs_ok(const struct nxm_field *field, const struct flow *flow)
431 {
432     if (field->nw_proto && field->nw_proto != flow->nw_proto) {
433         return false;
434     }
435
436     if (!field->dl_type[0]) {
437         return true;
438     } else if (field->dl_type[0] == flow->dl_type) {
439         return true;
440     } else if (field->dl_type[1] && field->dl_type[1] == flow->dl_type) {
441         return true;
442     }
443
444     return false;
445 }
446
447 static uint32_t
448 nx_entry_ok(const void *p, unsigned int match_len)
449 {
450     unsigned int payload_len;
451     ovs_be32 header_be;
452     uint32_t header;
453
454     if (match_len < 4) {
455         if (match_len) {
456             VLOG_DBG_RL(&rl, "nx_match ends with partial nxm_header");
457         }
458         return 0;
459     }
460     memcpy(&header_be, p, 4);
461     header = ntohl(header_be);
462
463     payload_len = NXM_LENGTH(header);
464     if (!payload_len) {
465         VLOG_DBG_RL(&rl, "nxm_entry %08"PRIx32" has invalid payload "
466                     "length 0", header);
467         return 0;
468     }
469     if (match_len < payload_len + 4) {
470         VLOG_DBG_RL(&rl, "%"PRIu32"-byte nxm_entry but only "
471                     "%u bytes left in nx_match", payload_len + 4, match_len);
472         return 0;
473     }
474
475     return header;
476 }
477
478 int
479 nx_pull_match(struct ofpbuf *b, unsigned int match_len, uint16_t priority,
480               struct cls_rule *rule)
481 {
482     uint32_t header;
483     uint8_t *p;
484
485     p = ofpbuf_try_pull(b, ROUND_UP(match_len, 8));
486     if (!p) {
487         VLOG_DBG_RL(&rl, "nx_match length %u, rounded up to a "
488                     "multiple of 8, is longer than space in message (max "
489                     "length %zu)", match_len, b->size);
490         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN);
491     }
492
493     cls_rule_init_catchall(rule, priority);
494     while ((header = nx_entry_ok(p, match_len)) != 0) {
495         unsigned length = NXM_LENGTH(header);
496         const struct nxm_field *f;
497         int error;
498
499         f = nxm_field_lookup(header);
500         if (!f) {
501             error = NXM_BAD_TYPE;
502         } else if (!nxm_prereqs_ok(f, &rule->flow)) {
503             error = NXM_BAD_PREREQ;
504         } else if (f->wildcard && !(rule->wc.wildcards & f->wildcard)) {
505             error = NXM_DUP_TYPE;
506         } else {
507             /* 'hasmask' and 'length' are known to be correct at this point
508              * because they are included in 'header' and nxm_field_lookup()
509              * checked them already. */
510             rule->wc.wildcards &= ~f->wildcard;
511             error = parse_nxm_entry(rule, f, p + 4, p + 4 + length / 2);
512         }
513         if (error) {
514             VLOG_DBG_RL(&rl, "bad nxm_entry with vendor=%"PRIu32", "
515                         "field=%"PRIu32", hasmask=%"PRIu32", type=%"PRIu32" "
516                         "(error %x)",
517                         NXM_VENDOR(header), NXM_FIELD(header),
518                         NXM_HASMASK(header), NXM_TYPE(header),
519                         error);
520             return error;
521         }
522
523
524         p += 4 + length;
525         match_len -= 4 + length;
526     }
527
528     return match_len ? NXM_INVALID : 0;
529 }
530 \f
531 /* nx_put_match() and helpers.
532  *
533  * 'put' functions whose names end in 'w' add a wildcarded field.
534  * 'put' functions whose names end in 'm' add a field that might be wildcarded.
535  * Other 'put' functions add exact-match fields.
536  */
537
538 static void
539 nxm_put_header(struct ofpbuf *b, uint32_t header)
540 {
541     ovs_be32 n_header = htonl(header);
542     ofpbuf_put(b, &n_header, sizeof n_header);
543 }
544
545 static void
546 nxm_put_8(struct ofpbuf *b, uint32_t header, uint8_t value)
547 {
548     nxm_put_header(b, header);
549     ofpbuf_put(b, &value, sizeof value);
550 }
551
552 static void
553 nxm_put_16(struct ofpbuf *b, uint32_t header, ovs_be16 value)
554 {
555     nxm_put_header(b, header);
556     ofpbuf_put(b, &value, sizeof value);
557 }
558
559 static void
560 nxm_put_16w(struct ofpbuf *b, uint32_t header, ovs_be16 value, ovs_be16 mask)
561 {
562     nxm_put_header(b, header);
563     ofpbuf_put(b, &value, sizeof value);
564     ofpbuf_put(b, &mask, sizeof mask);
565 }
566
567 static void
568 nxm_put_16m(struct ofpbuf *b, uint32_t header, ovs_be16 value, ovs_be16 mask)
569 {
570     switch (mask) {
571     case 0:
572         break;
573
574     case CONSTANT_HTONS(UINT16_MAX):
575         nxm_put_16(b, header, value);
576         break;
577
578     default:
579         nxm_put_16w(b, NXM_MAKE_WILD_HEADER(header), value, mask);
580         break;
581     }
582 }
583
584 static void
585 nxm_put_32(struct ofpbuf *b, uint32_t header, ovs_be32 value)
586 {
587     nxm_put_header(b, header);
588     ofpbuf_put(b, &value, sizeof value);
589 }
590
591 static void
592 nxm_put_32w(struct ofpbuf *b, uint32_t header, ovs_be32 value, ovs_be32 mask)
593 {
594     nxm_put_header(b, header);
595     ofpbuf_put(b, &value, sizeof value);
596     ofpbuf_put(b, &mask, sizeof mask);
597 }
598
599 static void
600 nxm_put_32m(struct ofpbuf *b, uint32_t header, ovs_be32 value, ovs_be32 mask)
601 {
602     switch (mask) {
603     case 0:
604         break;
605
606     case CONSTANT_HTONL(UINT32_MAX):
607         nxm_put_32(b, header, value);
608         break;
609
610     default:
611         nxm_put_32w(b, NXM_MAKE_WILD_HEADER(header), value, mask);
612         break;
613     }
614 }
615
616 static void
617 nxm_put_64(struct ofpbuf *b, uint32_t header, ovs_be64 value)
618 {
619     nxm_put_header(b, header);
620     ofpbuf_put(b, &value, sizeof value);
621 }
622
623 static void
624 nxm_put_64w(struct ofpbuf *b, uint32_t header, ovs_be64 value, ovs_be64 mask)
625 {
626     nxm_put_header(b, header);
627     ofpbuf_put(b, &value, sizeof value);
628     ofpbuf_put(b, &mask, sizeof mask);
629 }
630
631 static void
632 nxm_put_64m(struct ofpbuf *b, uint32_t header, ovs_be64 value, ovs_be64 mask)
633 {
634     switch (mask) {
635     case 0:
636         break;
637
638     case CONSTANT_HTONLL(UINT64_MAX):
639         nxm_put_64(b, header, value);
640         break;
641
642     default:
643         nxm_put_64w(b, NXM_MAKE_WILD_HEADER(header), value, mask);
644         break;
645     }
646 }
647
648 static void
649 nxm_put_eth(struct ofpbuf *b, uint32_t header,
650             const uint8_t value[ETH_ADDR_LEN])
651 {
652     nxm_put_header(b, header);
653     ofpbuf_put(b, value, ETH_ADDR_LEN);
654 }
655
656 static void
657 nxm_put_eth_dst(struct ofpbuf *b,
658                 flow_wildcards_t wc, const uint8_t value[ETH_ADDR_LEN])
659 {
660     switch (wc & (FWW_DL_DST | FWW_ETH_MCAST)) {
661     case FWW_DL_DST | FWW_ETH_MCAST:
662         break;
663     default:
664         nxm_put_header(b, NXM_OF_ETH_DST_W);
665         ofpbuf_put(b, value, ETH_ADDR_LEN);
666         ofpbuf_put(b, flow_wildcards_to_dl_dst_mask(wc), ETH_ADDR_LEN);
667         break;
668     case 0:
669         nxm_put_eth(b, NXM_OF_ETH_DST, value);
670         break;
671     }
672 }
673
674 static void
675 nxm_put_ipv6(struct ofpbuf *b, uint32_t header,
676              const struct in6_addr *value, const struct in6_addr *mask)
677 {
678     if (ipv6_mask_is_any(mask)) {
679         return;
680     } else if (ipv6_mask_is_exact(mask)) {
681         nxm_put_header(b, header);
682         ofpbuf_put(b, value, sizeof *value);
683     } else {
684         nxm_put_header(b, NXM_MAKE_WILD_HEADER(header));
685         ofpbuf_put(b, value, sizeof *value);
686         ofpbuf_put(b, mask, sizeof *mask);
687     }
688 }
689
690 /* Appends to 'b' the nx_match format that expresses 'cr' (except for
691  * 'cr->priority', because priority is not part of nx_match), plus enough
692  * zero bytes to pad the nx_match out to a multiple of 8.
693  *
694  * This function can cause 'b''s data to be reallocated.
695  *
696  * Returns the number of bytes appended to 'b', excluding padding.
697  *
698  * If 'cr' is a catch-all rule that matches every packet, then this function
699  * appends nothing to 'b' and returns 0. */
700 int
701 nx_put_match(struct ofpbuf *b, const struct cls_rule *cr)
702 {
703     const flow_wildcards_t wc = cr->wc.wildcards;
704     const struct flow *flow = &cr->flow;
705     const size_t start_len = b->size;
706     int match_len;
707     int i;
708
709     /* Metadata. */
710     if (!(wc & FWW_IN_PORT)) {
711         uint16_t in_port = flow->in_port;
712         nxm_put_16(b, NXM_OF_IN_PORT, htons(in_port));
713     }
714
715     /* Ethernet. */
716     nxm_put_eth_dst(b, wc, flow->dl_dst);
717     if (!(wc & FWW_DL_SRC)) {
718         nxm_put_eth(b, NXM_OF_ETH_SRC, flow->dl_src);
719     }
720     if (!(wc & FWW_DL_TYPE)) {
721         nxm_put_16(b, NXM_OF_ETH_TYPE,
722                    ofputil_dl_type_to_openflow(flow->dl_type));
723     }
724
725     /* 802.1Q. */
726     nxm_put_16m(b, NXM_OF_VLAN_TCI, flow->vlan_tci, cr->wc.vlan_tci_mask);
727
728     /* L3. */
729     if (!(wc & FWW_DL_TYPE) && flow->dl_type == htons(ETH_TYPE_IP)) {
730         /* IP. */
731         if (!(wc & FWW_NW_TOS)) {
732             nxm_put_8(b, NXM_OF_IP_TOS, flow->nw_tos & 0xfc);
733         }
734         nxm_put_32m(b, NXM_OF_IP_SRC, flow->nw_src, cr->wc.nw_src_mask);
735         nxm_put_32m(b, NXM_OF_IP_DST, flow->nw_dst, cr->wc.nw_dst_mask);
736
737         if (!(wc & FWW_NW_PROTO)) {
738             nxm_put_8(b, NXM_OF_IP_PROTO, flow->nw_proto);
739             switch (flow->nw_proto) {
740                 /* TCP. */
741             case IPPROTO_TCP:
742                 if (!(wc & FWW_TP_SRC)) {
743                     nxm_put_16(b, NXM_OF_TCP_SRC, flow->tp_src);
744                 }
745                 if (!(wc & FWW_TP_DST)) {
746                     nxm_put_16(b, NXM_OF_TCP_DST, flow->tp_dst);
747                 }
748                 break;
749
750                 /* UDP. */
751             case IPPROTO_UDP:
752                 if (!(wc & FWW_TP_SRC)) {
753                     nxm_put_16(b, NXM_OF_UDP_SRC, flow->tp_src);
754                 }
755                 if (!(wc & FWW_TP_DST)) {
756                     nxm_put_16(b, NXM_OF_UDP_DST, flow->tp_dst);
757                 }
758                 break;
759
760                 /* ICMP. */
761             case IPPROTO_ICMP:
762                 if (!(wc & FWW_TP_SRC)) {
763                     nxm_put_8(b, NXM_OF_ICMP_TYPE, ntohs(flow->tp_src));
764                 }
765                 if (!(wc & FWW_TP_DST)) {
766                     nxm_put_8(b, NXM_OF_ICMP_CODE, ntohs(flow->tp_dst));
767                 }
768                 break;
769             }
770         }
771     } else if (!(wc & FWW_DL_TYPE) && flow->dl_type == htons(ETH_TYPE_IPV6)) {
772         /* IPv6. */
773
774         if (!(wc & FWW_NW_TOS)) {
775             nxm_put_8(b, NXM_OF_IP_TOS, flow->nw_tos & 0xfc);
776         }
777         nxm_put_ipv6(b, NXM_NX_IPV6_SRC, &flow->ipv6_src,
778                 &cr->wc.ipv6_src_mask);
779         nxm_put_ipv6(b, NXM_NX_IPV6_DST, &flow->ipv6_dst,
780                 &cr->wc.ipv6_dst_mask);
781
782         if (!(wc & FWW_NW_PROTO)) {
783             nxm_put_8(b, NXM_OF_IP_PROTO, flow->nw_proto);
784             switch (flow->nw_proto) {
785                 /* TCP. */
786             case IPPROTO_TCP:
787                 if (!(wc & FWW_TP_SRC)) {
788                     nxm_put_16(b, NXM_OF_TCP_SRC, flow->tp_src);
789                 }
790                 if (!(wc & FWW_TP_DST)) {
791                     nxm_put_16(b, NXM_OF_TCP_DST, flow->tp_dst);
792                 }
793                 break;
794
795                 /* UDP. */
796             case IPPROTO_UDP:
797                 if (!(wc & FWW_TP_SRC)) {
798                     nxm_put_16(b, NXM_OF_UDP_SRC, flow->tp_src);
799                 }
800                 if (!(wc & FWW_TP_DST)) {
801                     nxm_put_16(b, NXM_OF_UDP_DST, flow->tp_dst);
802                 }
803                 break;
804
805                 /* ICMPv6. */
806             case IPPROTO_ICMPV6:
807                 if (!(wc & FWW_TP_SRC)) {
808                     nxm_put_8(b, NXM_NX_ICMPV6_TYPE, ntohs(flow->tp_src));
809
810                     if (flow->tp_src == htons(ND_NEIGHBOR_SOLICIT) ||
811                         flow->tp_src == htons(ND_NEIGHBOR_ADVERT)) {
812                         if (!(wc & FWW_ND_TARGET)) {
813                             nxm_put_ipv6(b, NXM_NX_ND_TARGET, &flow->nd_target,
814                                          &in6addr_exact);
815                         }
816                         if (!(wc & FWW_ARP_SHA)
817                             && flow->tp_src == htons(ND_NEIGHBOR_SOLICIT)) {
818                             nxm_put_eth(b, NXM_NX_ND_SLL, flow->arp_sha);
819                         }
820                         if (!(wc & FWW_ARP_THA)
821                             && flow->tp_src == htons(ND_NEIGHBOR_ADVERT)) {
822                             nxm_put_eth(b, NXM_NX_ND_TLL, flow->arp_tha);
823                         }
824                     }
825                 }
826                 if (!(wc & FWW_TP_DST)) {
827                     nxm_put_8(b, NXM_NX_ICMPV6_CODE, ntohs(flow->tp_dst));
828                 }
829                 break;
830             }
831         }
832     } else if (!(wc & FWW_DL_TYPE) && flow->dl_type == htons(ETH_TYPE_ARP)) {
833         /* ARP. */
834         if (!(wc & FWW_NW_PROTO)) {
835             nxm_put_16(b, NXM_OF_ARP_OP, htons(flow->nw_proto));
836         }
837         nxm_put_32m(b, NXM_OF_ARP_SPA, flow->nw_src, cr->wc.nw_src_mask);
838         nxm_put_32m(b, NXM_OF_ARP_TPA, flow->nw_dst, cr->wc.nw_dst_mask);
839         if (!(wc & FWW_ARP_SHA)) {
840             nxm_put_eth(b, NXM_NX_ARP_SHA, flow->arp_sha);
841         }
842         if (!(wc & FWW_ARP_THA)) {
843             nxm_put_eth(b, NXM_NX_ARP_THA, flow->arp_tha);
844         }
845     }
846
847     /* Tunnel ID. */
848     nxm_put_64m(b, NXM_NX_TUN_ID, flow->tun_id, cr->wc.tun_id_mask);
849
850     /* Registers. */
851     for (i = 0; i < FLOW_N_REGS; i++) {
852         nxm_put_32m(b, NXM_NX_REG(i),
853                     htonl(flow->regs[i]), htonl(cr->wc.reg_masks[i]));
854     }
855
856     match_len = b->size - start_len;
857     ofpbuf_put_zeros(b, ROUND_UP(match_len, 8) - match_len);
858     return match_len;
859 }
860 \f
861 /* nx_match_to_string() and helpers. */
862
863 static void format_nxm_field_name(struct ds *, uint32_t header);
864
865 char *
866 nx_match_to_string(const uint8_t *p, unsigned int match_len)
867 {
868     uint32_t header;
869     struct ds s;
870
871     if (!match_len) {
872         return xstrdup("<any>");
873     }
874
875     ds_init(&s);
876     while ((header = nx_entry_ok(p, match_len)) != 0) {
877         unsigned int length = NXM_LENGTH(header);
878         unsigned int value_len = nxm_field_bytes(header);
879         const uint8_t *value = p + 4;
880         const uint8_t *mask = value + value_len;
881         unsigned int i;
882
883         if (s.length) {
884             ds_put_cstr(&s, ", ");
885         }
886
887         format_nxm_field_name(&s, header);
888         ds_put_char(&s, '(');
889
890         for (i = 0; i < value_len; i++) {
891             ds_put_format(&s, "%02x", value[i]);
892         }
893         if (NXM_HASMASK(header)) {
894             ds_put_char(&s, '/');
895             for (i = 0; i < value_len; i++) {
896                 ds_put_format(&s, "%02x", mask[i]);
897             }
898         }
899         ds_put_char(&s, ')');
900
901         p += 4 + length;
902         match_len -= 4 + length;
903     }
904
905     if (match_len) {
906         if (s.length) {
907             ds_put_cstr(&s, ", ");
908         }
909
910         ds_put_format(&s, "<%u invalid bytes>", match_len);
911     }
912
913     return ds_steal_cstr(&s);
914 }
915
916 static void
917 format_nxm_field_name(struct ds *s, uint32_t header)
918 {
919     const struct nxm_field *f = nxm_field_lookup(header);
920     if (f) {
921         ds_put_cstr(s, f->name);
922     } else {
923         ds_put_format(s, "%d:%d", NXM_VENDOR(header), NXM_FIELD(header));
924     }
925 }
926
927 static uint32_t
928 parse_nxm_field_name(const char *name, int name_len)
929 {
930     const struct nxm_field *f;
931
932     /* Check whether it's a field name. */
933     for (f = nxm_fields; f < &nxm_fields[ARRAY_SIZE(nxm_fields)]; f++) {
934         if (!strncmp(f->name, name, name_len) && f->name[name_len] == '\0') {
935             return f->header;
936         }
937     }
938
939     /* Check whether it's a 32-bit field header value as hex.
940      * (This isn't ordinarily useful except for testing error behavior.) */
941     if (name_len == 8) {
942         uint32_t header = hexits_value(name, name_len, NULL);
943         if (header != UINT_MAX) {
944             return header;
945         }
946     }
947
948     return 0;
949 }
950 \f
951 /* nx_match_from_string(). */
952
953 int
954 nx_match_from_string(const char *s, struct ofpbuf *b)
955 {
956     const char *full_s = s;
957     const size_t start_len = b->size;
958     int match_len;
959
960     if (!strcmp(s, "<any>")) {
961         /* Ensure that 'b->data' isn't actually null. */
962         ofpbuf_prealloc_tailroom(b, 1);
963         return 0;
964     }
965
966     for (s += strspn(s, ", "); *s; s += strspn(s, ", ")) {
967         const char *name;
968         uint32_t header;
969         int name_len;
970         size_t n;
971
972         name = s;
973         name_len = strcspn(s, "(");
974         if (s[name_len] != '(') {
975             ovs_fatal(0, "%s: missing ( at end of nx_match", full_s);
976         }
977
978         header = parse_nxm_field_name(name, name_len);
979         if (!header) {
980             ovs_fatal(0, "%s: unknown field `%.*s'", full_s, name_len, s);
981         }
982
983         s += name_len + 1;
984
985         nxm_put_header(b, header);
986         s = ofpbuf_put_hex(b, s, &n);
987         if (n != nxm_field_bytes(header)) {
988             ovs_fatal(0, "%.2s: hex digits expected", s);
989         }
990         if (NXM_HASMASK(header)) {
991             s += strspn(s, " ");
992             if (*s != '/') {
993                 ovs_fatal(0, "%s: missing / in masked field %.*s",
994                           full_s, name_len, name);
995             }
996             s = ofpbuf_put_hex(b, s + 1, &n);
997             if (n != nxm_field_bytes(header)) {
998                 ovs_fatal(0, "%.2s: hex digits expected", s);
999             }
1000         }
1001
1002         s += strspn(s, " ");
1003         if (*s != ')') {
1004             ovs_fatal(0, "%s: missing ) following field %.*s",
1005                       full_s, name_len, name);
1006         }
1007         s++;
1008     }
1009
1010     match_len = b->size - start_len;
1011     ofpbuf_put_zeros(b, ROUND_UP(match_len, 8) - match_len);
1012     return match_len;
1013 }
1014 \f
1015 const char *
1016 nxm_parse_field_bits(const char *s, uint32_t *headerp, int *ofsp, int *n_bitsp)
1017 {
1018     const char *full_s = s;
1019     const char *name;
1020     uint32_t header;
1021     int start, end;
1022     int name_len;
1023     int width;
1024
1025     name = s;
1026     name_len = strcspn(s, "[");
1027     if (s[name_len] != '[') {
1028         ovs_fatal(0, "%s: missing [ looking for field name", full_s);
1029     }
1030
1031     header = parse_nxm_field_name(name, name_len);
1032     if (!header) {
1033         ovs_fatal(0, "%s: unknown field `%.*s'", full_s, name_len, s);
1034     }
1035     width = nxm_field_bits(header);
1036
1037     s += name_len;
1038     if (sscanf(s, "[%d..%d]", &start, &end) == 2) {
1039         /* Nothing to do. */
1040     } else if (sscanf(s, "[%d]", &start) == 1) {
1041         end = start;
1042     } else if (!strncmp(s, "[]", 2)) {
1043         start = 0;
1044         end = width - 1;
1045     } else {
1046         ovs_fatal(0, "%s: syntax error expecting [] or [<bit>] or "
1047                   "[<start>..<end>]", full_s);
1048     }
1049     s = strchr(s, ']') + 1;
1050
1051     if (start > end) {
1052         ovs_fatal(0, "%s: starting bit %d is after ending bit %d",
1053                   full_s, start, end);
1054     } else if (start >= width) {
1055         ovs_fatal(0, "%s: starting bit %d is not valid because field is only "
1056                   "%d bits wide", full_s, start, width);
1057     } else if (end >= width){
1058         ovs_fatal(0, "%s: ending bit %d is not valid because field is only "
1059                   "%d bits wide", full_s, end, width);
1060     }
1061
1062     *headerp = header;
1063     *ofsp = start;
1064     *n_bitsp = end - start + 1;
1065
1066     return s;
1067 }
1068
1069 void
1070 nxm_parse_reg_move(struct nx_action_reg_move *move, const char *s)
1071 {
1072     const char *full_s = s;
1073     uint32_t src, dst;
1074     int src_ofs, dst_ofs;
1075     int src_n_bits, dst_n_bits;
1076
1077     s = nxm_parse_field_bits(s, &src, &src_ofs, &src_n_bits);
1078     if (strncmp(s, "->", 2)) {
1079         ovs_fatal(0, "%s: missing `->' following source", full_s);
1080     }
1081     s += 2;
1082     s = nxm_parse_field_bits(s, &dst, &dst_ofs, &dst_n_bits);
1083     if (*s != '\0') {
1084         ovs_fatal(0, "%s: trailing garbage following destination", full_s);
1085     }
1086
1087     if (src_n_bits != dst_n_bits) {
1088         ovs_fatal(0, "%s: source field is %d bits wide but destination is "
1089                   "%d bits wide", full_s, src_n_bits, dst_n_bits);
1090     }
1091
1092     move->type = htons(OFPAT_VENDOR);
1093     move->len = htons(sizeof *move);
1094     move->vendor = htonl(NX_VENDOR_ID);
1095     move->subtype = htons(NXAST_REG_MOVE);
1096     move->n_bits = htons(src_n_bits);
1097     move->src_ofs = htons(src_ofs);
1098     move->dst_ofs = htons(dst_ofs);
1099     move->src = htonl(src);
1100     move->dst = htonl(dst);
1101 }
1102
1103 void
1104 nxm_parse_reg_load(struct nx_action_reg_load *load, const char *s)
1105 {
1106     const char *full_s = s;
1107     uint32_t dst;
1108     int ofs, n_bits;
1109     uint64_t value;
1110
1111     value = strtoull(s, (char **) &s, 0);
1112     if (strncmp(s, "->", 2)) {
1113         ovs_fatal(0, "%s: missing `->' following value", full_s);
1114     }
1115     s += 2;
1116     s = nxm_parse_field_bits(s, &dst, &ofs, &n_bits);
1117     if (*s != '\0') {
1118         ovs_fatal(0, "%s: trailing garbage following destination", full_s);
1119     }
1120
1121     if (n_bits < 64 && (value >> n_bits) != 0) {
1122         ovs_fatal(0, "%s: value %"PRIu64" does not fit into %d bits",
1123                   full_s, value, n_bits);
1124     }
1125
1126     load->type = htons(OFPAT_VENDOR);
1127     load->len = htons(sizeof *load);
1128     load->vendor = htonl(NX_VENDOR_ID);
1129     load->subtype = htons(NXAST_REG_LOAD);
1130     load->ofs_nbits = nxm_encode_ofs_nbits(ofs, n_bits);
1131     load->dst = htonl(dst);
1132     load->value = htonll(value);
1133 }
1134 \f
1135 /* nxm_format_reg_move(), nxm_format_reg_load(). */
1136
1137 void
1138 nxm_format_field_bits(struct ds *s, uint32_t header, int ofs, int n_bits)
1139 {
1140     format_nxm_field_name(s, header);
1141     if (ofs == 0 && n_bits == nxm_field_bits(header)) {
1142         ds_put_cstr(s, "[]");
1143     } else if (n_bits == 1) {
1144         ds_put_format(s, "[%d]", ofs);
1145     } else {
1146         ds_put_format(s, "[%d..%d]", ofs, ofs + n_bits - 1);
1147     }
1148 }
1149
1150 void
1151 nxm_format_reg_move(const struct nx_action_reg_move *move, struct ds *s)
1152 {
1153     int n_bits = ntohs(move->n_bits);
1154     int src_ofs = ntohs(move->src_ofs);
1155     int dst_ofs = ntohs(move->dst_ofs);
1156     uint32_t src = ntohl(move->src);
1157     uint32_t dst = ntohl(move->dst);
1158
1159     ds_put_format(s, "move:");
1160     nxm_format_field_bits(s, src, src_ofs, n_bits);
1161     ds_put_cstr(s, "->");
1162     nxm_format_field_bits(s, dst, dst_ofs, n_bits);
1163 }
1164
1165 void
1166 nxm_format_reg_load(const struct nx_action_reg_load *load, struct ds *s)
1167 {
1168     int ofs = nxm_decode_ofs(load->ofs_nbits);
1169     int n_bits = nxm_decode_n_bits(load->ofs_nbits);
1170     uint32_t dst = ntohl(load->dst);
1171     uint64_t value = ntohll(load->value);
1172
1173     ds_put_format(s, "load:%#"PRIx64"->", value);
1174     nxm_format_field_bits(s, dst, ofs, n_bits);
1175 }
1176 \f
1177 /* nxm_check_reg_move(), nxm_check_reg_load(). */
1178
1179 static bool
1180 field_ok(const struct nxm_field *f, const struct flow *flow, int size)
1181 {
1182     return (f && !NXM_HASMASK(f->header)
1183             && nxm_prereqs_ok(f, flow) && size <= nxm_field_bits(f->header));
1184 }
1185
1186 int
1187 nxm_check_reg_move(const struct nx_action_reg_move *action,
1188                    const struct flow *flow)
1189 {
1190     const struct nxm_field *src;
1191     const struct nxm_field *dst;
1192
1193     if (action->n_bits == htons(0)) {
1194         return BAD_ARGUMENT;
1195     }
1196
1197     src = nxm_field_lookup(ntohl(action->src));
1198     if (!field_ok(src, flow, ntohs(action->src_ofs) + ntohs(action->n_bits))) {
1199         return BAD_ARGUMENT;
1200     }
1201
1202     dst = nxm_field_lookup(ntohl(action->dst));
1203     if (!field_ok(dst, flow, ntohs(action->dst_ofs) + ntohs(action->n_bits))) {
1204         return BAD_ARGUMENT;
1205     }
1206
1207     if (!dst->writable) {
1208         return BAD_ARGUMENT;
1209     }
1210
1211     return 0;
1212 }
1213
1214 /* Given a flow, checks that the destination field represented by 'dst_header'
1215  * and 'ofs_nbits' is valid and large enough for 'min_n_bits' bits of data. */
1216 int
1217 nxm_dst_check(ovs_be32 dst_header, ovs_be16 ofs_nbits, size_t min_n_bits,
1218               const struct flow *flow)
1219 {
1220     const struct nxm_field *dst;
1221     int ofs, n_bits;
1222
1223     ofs = nxm_decode_ofs(ofs_nbits);
1224     n_bits = nxm_decode_n_bits(ofs_nbits);
1225     dst = nxm_field_lookup(ntohl(dst_header));
1226
1227     if (!field_ok(dst, flow, ofs + n_bits)) {
1228         VLOG_WARN_RL(&rl, "invalid destination field");
1229     } else if (!dst->writable) {
1230         VLOG_WARN_RL(&rl, "destination field is not writable");
1231     } else if (n_bits < min_n_bits) {
1232         VLOG_WARN_RL(&rl, "insufficient bits in destination");
1233     } else {
1234         return 0;
1235     }
1236
1237     return BAD_ARGUMENT;
1238 }
1239
1240 int
1241 nxm_check_reg_load(const struct nx_action_reg_load *action,
1242                    const struct flow *flow)
1243 {
1244     int n_bits;
1245     int error;
1246
1247     error = nxm_dst_check(action->dst, action->ofs_nbits, 0, flow);
1248     if (error) {
1249         return error;
1250     }
1251
1252     /* Reject 'action' if a bit numbered 'n_bits' or higher is set to 1 in
1253      * action->value. */
1254     n_bits = nxm_decode_n_bits(action->ofs_nbits);
1255     if (n_bits < 64 && ntohll(action->value) >> n_bits) {
1256         return BAD_ARGUMENT;
1257     }
1258
1259     return 0;
1260 }
1261 \f
1262 /* nxm_execute_reg_move(), nxm_execute_reg_load(). */
1263
1264 static uint64_t
1265 nxm_read_field(const struct nxm_field *src, const struct flow *flow)
1266 {
1267     switch (src->index) {
1268     case NFI_NXM_OF_IN_PORT:
1269         return flow->in_port;
1270
1271     case NFI_NXM_OF_ETH_DST:
1272         return eth_addr_to_uint64(flow->dl_dst);
1273
1274     case NFI_NXM_OF_ETH_SRC:
1275         return eth_addr_to_uint64(flow->dl_src);
1276
1277     case NFI_NXM_OF_ETH_TYPE:
1278         return ntohs(ofputil_dl_type_to_openflow(flow->dl_type));
1279
1280     case NFI_NXM_OF_VLAN_TCI:
1281         return ntohs(flow->vlan_tci);
1282
1283     case NFI_NXM_OF_IP_TOS:
1284         return flow->nw_tos;
1285
1286     case NFI_NXM_OF_IP_PROTO:
1287     case NFI_NXM_OF_ARP_OP:
1288         return flow->nw_proto;
1289
1290     case NFI_NXM_OF_IP_SRC:
1291     case NFI_NXM_OF_ARP_SPA:
1292         return ntohl(flow->nw_src);
1293
1294     case NFI_NXM_OF_IP_DST:
1295     case NFI_NXM_OF_ARP_TPA:
1296         return ntohl(flow->nw_dst);
1297
1298     case NFI_NXM_OF_TCP_SRC:
1299     case NFI_NXM_OF_UDP_SRC:
1300         return ntohs(flow->tp_src);
1301
1302     case NFI_NXM_OF_TCP_DST:
1303     case NFI_NXM_OF_UDP_DST:
1304         return ntohs(flow->tp_dst);
1305
1306     case NFI_NXM_OF_ICMP_TYPE:
1307     case NFI_NXM_NX_ICMPV6_TYPE:
1308         return ntohs(flow->tp_src) & 0xff;
1309
1310     case NFI_NXM_OF_ICMP_CODE:
1311     case NFI_NXM_NX_ICMPV6_CODE:
1312         return ntohs(flow->tp_dst) & 0xff;
1313
1314     case NFI_NXM_NX_TUN_ID:
1315         return ntohll(flow->tun_id);
1316
1317 #define NXM_READ_REGISTER(IDX)                  \
1318     case NFI_NXM_NX_REG##IDX:                   \
1319         return flow->regs[IDX];                 \
1320     case NFI_NXM_NX_REG##IDX##_W:               \
1321         NOT_REACHED();
1322
1323     NXM_READ_REGISTER(0);
1324 #if FLOW_N_REGS >= 2
1325     NXM_READ_REGISTER(1);
1326 #endif
1327 #if FLOW_N_REGS >= 3
1328     NXM_READ_REGISTER(2);
1329 #endif
1330 #if FLOW_N_REGS >= 4
1331     NXM_READ_REGISTER(3);
1332 #endif
1333 #if FLOW_N_REGS > 4
1334 #error
1335 #endif
1336
1337     case NFI_NXM_NX_ARP_SHA:
1338     case NFI_NXM_NX_ND_SLL:
1339         return eth_addr_to_uint64(flow->arp_sha);
1340
1341     case NFI_NXM_NX_ARP_THA:
1342     case NFI_NXM_NX_ND_TLL:
1343         return eth_addr_to_uint64(flow->arp_tha);
1344
1345     case NFI_NXM_NX_TUN_ID_W:
1346     case NFI_NXM_OF_ETH_DST_W:
1347     case NFI_NXM_OF_VLAN_TCI_W:
1348     case NFI_NXM_OF_IP_SRC_W:
1349     case NFI_NXM_OF_IP_DST_W:
1350     case NFI_NXM_OF_ARP_SPA_W:
1351     case NFI_NXM_OF_ARP_TPA_W:
1352     case NFI_NXM_NX_IPV6_SRC:
1353     case NFI_NXM_NX_IPV6_SRC_W:
1354     case NFI_NXM_NX_IPV6_DST:
1355     case NFI_NXM_NX_IPV6_DST_W:
1356     case NFI_NXM_NX_ND_TARGET:
1357     case N_NXM_FIELDS:
1358         NOT_REACHED();
1359     }
1360
1361     NOT_REACHED();
1362 }
1363
1364 static void
1365 nxm_write_field(const struct nxm_field *dst, struct flow *flow,
1366                 uint64_t new_value)
1367 {
1368     switch (dst->index) {
1369     case NFI_NXM_OF_ETH_DST:
1370         eth_addr_from_uint64(new_value, flow->dl_dst);
1371         break;
1372
1373     case NFI_NXM_OF_ETH_SRC:
1374         eth_addr_from_uint64(new_value, flow->dl_src);
1375         break;
1376
1377     case NFI_NXM_OF_VLAN_TCI:
1378         flow->vlan_tci = htons(new_value);
1379         break;
1380
1381     case NFI_NXM_NX_TUN_ID:
1382         flow->tun_id = htonll(new_value);
1383         break;
1384
1385 #define NXM_WRITE_REGISTER(IDX)                 \
1386     case NFI_NXM_NX_REG##IDX:                   \
1387         flow->regs[IDX] = new_value;            \
1388         break;                                  \
1389     case NFI_NXM_NX_REG##IDX##_W:               \
1390         NOT_REACHED();
1391
1392     NXM_WRITE_REGISTER(0);
1393 #if FLOW_N_REGS >= 2
1394     NXM_WRITE_REGISTER(1);
1395 #endif
1396 #if FLOW_N_REGS >= 3
1397     NXM_WRITE_REGISTER(2);
1398 #endif
1399 #if FLOW_N_REGS >= 4
1400     NXM_WRITE_REGISTER(3);
1401 #endif
1402 #if FLOW_N_REGS > 4
1403 #error
1404 #endif
1405
1406     case NFI_NXM_OF_IP_TOS:
1407         flow->nw_tos = new_value & IP_DSCP_MASK;
1408         break;
1409
1410     case NFI_NXM_OF_IP_SRC:
1411         flow->nw_src = htonl(new_value);
1412         break;
1413
1414     case NFI_NXM_OF_IP_DST:
1415         flow->nw_dst = htonl(new_value);
1416         break;
1417
1418     case NFI_NXM_OF_TCP_SRC:
1419     case NFI_NXM_OF_UDP_SRC:
1420         flow->tp_src = htons(new_value);
1421         break;
1422
1423     case NFI_NXM_OF_TCP_DST:
1424     case NFI_NXM_OF_UDP_DST:
1425         flow->tp_dst = htons(new_value);
1426         break;
1427
1428     case NFI_NXM_OF_IN_PORT:
1429     case NFI_NXM_OF_ETH_TYPE:
1430     case NFI_NXM_OF_IP_PROTO:
1431     case NFI_NXM_OF_ARP_OP:
1432     case NFI_NXM_OF_ARP_SPA:
1433     case NFI_NXM_OF_ARP_TPA:
1434     case NFI_NXM_OF_ICMP_TYPE:
1435     case NFI_NXM_OF_ICMP_CODE:
1436     case NFI_NXM_NX_TUN_ID_W:
1437     case NFI_NXM_OF_ETH_DST_W:
1438     case NFI_NXM_OF_VLAN_TCI_W:
1439     case NFI_NXM_OF_IP_SRC_W:
1440     case NFI_NXM_OF_IP_DST_W:
1441     case NFI_NXM_OF_ARP_SPA_W:
1442     case NFI_NXM_OF_ARP_TPA_W:
1443     case NFI_NXM_NX_ARP_SHA:
1444     case NFI_NXM_NX_ARP_THA:
1445     case NFI_NXM_NX_IPV6_SRC:
1446     case NFI_NXM_NX_IPV6_SRC_W:
1447     case NFI_NXM_NX_IPV6_DST:
1448     case NFI_NXM_NX_IPV6_DST_W:
1449     case NFI_NXM_NX_ICMPV6_TYPE:
1450     case NFI_NXM_NX_ICMPV6_CODE:
1451     case NFI_NXM_NX_ND_TARGET:
1452     case NFI_NXM_NX_ND_SLL:
1453     case NFI_NXM_NX_ND_TLL:
1454     case N_NXM_FIELDS:
1455         NOT_REACHED();
1456     }
1457 }
1458
1459 void
1460 nxm_execute_reg_move(const struct nx_action_reg_move *action,
1461                      struct flow *flow)
1462 {
1463     /* Preparation. */
1464     int n_bits = ntohs(action->n_bits);
1465     uint64_t mask = n_bits == 64 ? UINT64_MAX : (UINT64_C(1) << n_bits) - 1;
1466
1467     /* Get the interesting bits of the source field. */
1468     const struct nxm_field *src = nxm_field_lookup(ntohl(action->src));
1469     int src_ofs = ntohs(action->src_ofs);
1470     uint64_t src_data = nxm_read_field(src, flow) & (mask << src_ofs);
1471
1472     nxm_reg_load(action->dst,
1473                  nxm_encode_ofs_nbits(ntohs(action->dst_ofs), n_bits),
1474                  src_data, flow);
1475 }
1476
1477 void
1478 nxm_execute_reg_load(const struct nx_action_reg_load *action,
1479                      struct flow *flow)
1480 {
1481     nxm_reg_load(action->dst, action->ofs_nbits, ntohll(action->value), flow);
1482 }
1483
1484 /* Calculates ofs and n_bits from the given 'ofs_nbits' parameter, and copies
1485  * 'src_data'[0:n_bits] to 'dst_header'[ofs:ofs+n_bits] in the given 'flow'. */
1486 void
1487 nxm_reg_load(ovs_be32 dst_header, ovs_be16 ofs_nbits, uint64_t src_data,
1488              struct flow *flow)
1489 {
1490     int n_bits = nxm_decode_n_bits(ofs_nbits);
1491     int dst_ofs = nxm_decode_ofs(ofs_nbits);
1492     uint64_t mask = n_bits == 64 ? UINT64_MAX : (UINT64_C(1) << n_bits) - 1;
1493
1494     /* Get remaining bits of the destination field. */
1495     const struct nxm_field *dst = nxm_field_lookup(ntohl(dst_header));
1496     uint64_t dst_data = nxm_read_field(dst, flow) & ~(mask << dst_ofs);
1497
1498     /* Get the final value. */
1499     uint64_t new_data = dst_data | (src_data << dst_ofs);
1500
1501     nxm_write_field(dst, flow, new_data);
1502 }