b7b31b0228bffd0757d382609df7638a8097b8ee
[openvswitch] / ofproto.c
1 /*
2  * Copyright (c) 2009, 2010, 2011 Nicira Networks.
3  * Copyright (c) 2010 Jean Tourrilhes - HP-Labs.
4  *
5  * Licensed under the Apache License, Version 2.0 (the "License");
6  * you may not use this file except in compliance with the License.
7  * You may obtain a copy of the License at:
8  *
9  *     http://www.apache.org/licenses/LICENSE-2.0
10  *
11  * Unless required by applicable law or agreed to in writing, software
12  * distributed under the License is distributed on an "AS IS" BASIS,
13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  * See the License for the specific language governing permissions and
15  * limitations under the License.
16  */
17
18 #include <config.h>
19 #include "ofproto.h"
20 #include <errno.h>
21 #include <inttypes.h>
22 #include <stdbool.h>
23 #include <stdlib.h>
24 #include "byte-order.h"
25 #include "classifier.h"
26 #include "connmgr.h"
27 #include "coverage.h"
28 #include "dynamic-string.h"
29 #include "hash.h"
30 #include "hmap.h"
31 #include "netdev.h"
32 #include "nx-match.h"
33 #include "ofp-print.h"
34 #include "ofp-util.h"
35 #include "ofpbuf.h"
36 #include "ofproto-provider.h"
37 #include "openflow/nicira-ext.h"
38 #include "openflow/openflow.h"
39 #include "packets.h"
40 #include "pinsched.h"
41 #include "pktbuf.h"
42 #include "poll-loop.h"
43 #include "shash.h"
44 #include "sset.h"
45 #include "timeval.h"
46 #include "unaligned.h"
47 #include "unixctl.h"
48 #include "vlog.h"
49
50 VLOG_DEFINE_THIS_MODULE(ofproto);
51
52 COVERAGE_DEFINE(ofproto_error);
53 COVERAGE_DEFINE(ofproto_flush);
54 COVERAGE_DEFINE(ofproto_no_packet_in);
55 COVERAGE_DEFINE(ofproto_packet_out);
56 COVERAGE_DEFINE(ofproto_queue_req);
57 COVERAGE_DEFINE(ofproto_recv_openflow);
58 COVERAGE_DEFINE(ofproto_reinit_ports);
59 COVERAGE_DEFINE(ofproto_uninstallable);
60 COVERAGE_DEFINE(ofproto_update_port);
61
62 enum ofproto_state {
63     S_OPENFLOW,                 /* Processing OpenFlow commands. */
64     S_FLUSH,                    /* Deleting all flow table rules. */
65 };
66
67 enum ofoperation_type {
68     OFOPERATION_ADD,
69     OFOPERATION_DELETE,
70     OFOPERATION_MODIFY
71 };
72
73 /* A single OpenFlow request can execute any number of operations.  The
74  * ofopgroup maintain OpenFlow state common to all of the operations, e.g. the
75  * ofconn to which an error reply should be sent if necessary.
76  *
77  * ofproto initiates some operations internally.  These operations are still
78  * assigned to groups but will not have an associated ofconn. */
79 struct ofopgroup {
80     struct ofproto *ofproto;    /* Owning ofproto. */
81     struct list ofproto_node;   /* In ofproto's "pending" list. */
82     struct list ops;            /* List of "struct ofoperation"s. */
83
84     /* Data needed to send OpenFlow reply on failure or to send a buffered
85      * packet on success.
86      *
87      * If list_is_empty(ofconn_node) then this ofopgroup never had an
88      * associated ofconn or its ofconn's connection dropped after it initiated
89      * the operation.  In the latter case 'ofconn' is a wild pointer that
90      * refers to freed memory, so the 'ofconn' member must be used only if
91      * !list_is_empty(ofconn_node).
92      */
93     struct list ofconn_node;    /* In ofconn's list of pending opgroups. */
94     struct ofconn *ofconn;      /* ofconn for reply (but see note above). */
95     struct ofp_header *request; /* Original request (truncated at 64 bytes). */
96     uint32_t buffer_id;         /* Buffer id from original request. */
97     int error;                  /* 0 if no error yet, otherwise error code. */
98 };
99
100 static struct ofopgroup *ofopgroup_create_unattached(struct ofproto *);
101 static struct ofopgroup *ofopgroup_create(struct ofproto *, struct ofconn *,
102                                           const struct ofp_header *,
103                                           uint32_t buffer_id);
104 static void ofopgroup_submit(struct ofopgroup *);
105 static void ofopgroup_destroy(struct ofopgroup *);
106
107 /* A single flow table operation. */
108 struct ofoperation {
109     struct ofopgroup *group;    /* Owning group. */
110     struct list group_node;     /* In ofopgroup's "ops" list. */
111     struct hmap_node hmap_node; /* In ofproto's "deletions" hmap. */
112     struct rule *rule;          /* Rule being operated upon. */
113     enum ofoperation_type type; /* Type of operation. */
114     int status;                 /* -1 if pending, otherwise 0 or error code. */
115     struct rule *victim;        /* OFOPERATION_ADDING: Replaced rule. */
116     union ofp_action *actions;  /* OFOPERATION_MODIFYING: Replaced actions. */
117     int n_actions;              /* OFOPERATION_MODIFYING: # of old actions. */
118     ovs_be64 flow_cookie;       /* Rule's old flow cookie. */
119 };
120
121 static void ofoperation_create(struct ofopgroup *, struct rule *,
122                                enum ofoperation_type);
123 static void ofoperation_destroy(struct ofoperation *);
124
125 static void ofport_destroy__(struct ofport *);
126 static void ofport_destroy(struct ofport *);
127
128 static uint64_t pick_datapath_id(const struct ofproto *);
129 static uint64_t pick_fallback_dpid(void);
130
131 static void ofproto_destroy__(struct ofproto *);
132
133 static void ofproto_rule_destroy__(struct rule *);
134 static void ofproto_rule_send_removed(struct rule *, uint8_t reason);
135
136 static void ofopgroup_destroy(struct ofopgroup *);
137
138 static int add_flow(struct ofproto *, struct ofconn *,
139                     const struct ofputil_flow_mod *,
140                     const struct ofp_header *);
141
142 static bool handle_openflow(struct ofconn *, struct ofpbuf *);
143 static int handle_flow_mod__(struct ofproto *, struct ofconn *,
144                              const struct ofputil_flow_mod *,
145                              const struct ofp_header *);
146
147 static void update_port(struct ofproto *, const char *devname);
148 static int init_ports(struct ofproto *);
149 static void reinit_ports(struct ofproto *);
150 static void set_internal_devs_mtu(struct ofproto *);
151
152 static void ofproto_unixctl_init(void);
153
154 /* All registered ofproto classes, in probe order. */
155 static const struct ofproto_class **ofproto_classes;
156 static size_t n_ofproto_classes;
157 static size_t allocated_ofproto_classes;
158
159 /* Map from datapath name to struct ofproto, for use by unixctl commands. */
160 static struct hmap all_ofprotos = HMAP_INITIALIZER(&all_ofprotos);
161
162 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
163
164 static void
165 ofproto_initialize(void)
166 {
167     static bool inited;
168
169     if (!inited) {
170         inited = true;
171         ofproto_class_register(&ofproto_dpif_class);
172     }
173 }
174
175 /* 'type' should be a normalized datapath type, as returned by
176  * ofproto_normalize_type().  Returns the corresponding ofproto_class
177  * structure, or a null pointer if there is none registered for 'type'. */
178 static const struct ofproto_class *
179 ofproto_class_find__(const char *type)
180 {
181     size_t i;
182
183     ofproto_initialize();
184     for (i = 0; i < n_ofproto_classes; i++) {
185         const struct ofproto_class *class = ofproto_classes[i];
186         struct sset types;
187         bool found;
188
189         sset_init(&types);
190         class->enumerate_types(&types);
191         found = sset_contains(&types, type);
192         sset_destroy(&types);
193
194         if (found) {
195             return class;
196         }
197     }
198     VLOG_WARN("unknown datapath type %s", type);
199     return NULL;
200 }
201
202 /* Registers a new ofproto class.  After successful registration, new ofprotos
203  * of that type can be created using ofproto_create(). */
204 int
205 ofproto_class_register(const struct ofproto_class *new_class)
206 {
207     size_t i;
208
209     for (i = 0; i < n_ofproto_classes; i++) {
210         if (ofproto_classes[i] == new_class) {
211             return EEXIST;
212         }
213     }
214
215     if (n_ofproto_classes >= allocated_ofproto_classes) {
216         ofproto_classes = x2nrealloc(ofproto_classes,
217                                      &allocated_ofproto_classes,
218                                      sizeof *ofproto_classes);
219     }
220     ofproto_classes[n_ofproto_classes++] = new_class;
221     return 0;
222 }
223
224 /* Unregisters a datapath provider.  'type' must have been previously
225  * registered and not currently be in use by any ofprotos.  After
226  * unregistration new datapaths of that type cannot be opened using
227  * ofproto_create(). */
228 int
229 ofproto_class_unregister(const struct ofproto_class *class)
230 {
231     size_t i;
232
233     for (i = 0; i < n_ofproto_classes; i++) {
234         if (ofproto_classes[i] == class) {
235             for (i++; i < n_ofproto_classes; i++) {
236                 ofproto_classes[i - 1] = ofproto_classes[i];
237             }
238             n_ofproto_classes--;
239             return 0;
240         }
241     }
242     VLOG_WARN("attempted to unregister an ofproto class that is not "
243               "registered");
244     return EAFNOSUPPORT;
245 }
246
247 /* Clears 'types' and enumerates all registered ofproto types into it.  The
248  * caller must first initialize the sset. */
249 void
250 ofproto_enumerate_types(struct sset *types)
251 {
252     size_t i;
253
254     ofproto_initialize();
255     for (i = 0; i < n_ofproto_classes; i++) {
256         ofproto_classes[i]->enumerate_types(types);
257     }
258 }
259
260 /* Returns the fully spelled out name for the given ofproto 'type'.
261  *
262  * Normalized type string can be compared with strcmp().  Unnormalized type
263  * string might be the same even if they have different spellings. */
264 const char *
265 ofproto_normalize_type(const char *type)
266 {
267     return type && type[0] ? type : "system";
268 }
269
270 /* Clears 'names' and enumerates the names of all known created ofprotos with
271  * the given 'type'.  The caller must first initialize the sset.  Returns 0 if
272  * successful, otherwise a positive errno value.
273  *
274  * Some kinds of datapaths might not be practically enumerable.  This is not
275  * considered an error. */
276 int
277 ofproto_enumerate_names(const char *type, struct sset *names)
278 {
279     const struct ofproto_class *class = ofproto_class_find__(type);
280     return class ? class->enumerate_names(type, names) : EAFNOSUPPORT;
281  }
282
283 int
284 ofproto_create(const char *datapath_name, const char *datapath_type,
285                struct ofproto **ofprotop)
286 {
287     const struct ofproto_class *class;
288     struct classifier *table;
289     struct ofproto *ofproto;
290     int n_tables;
291     int error;
292
293     *ofprotop = NULL;
294
295     ofproto_initialize();
296     ofproto_unixctl_init();
297
298     datapath_type = ofproto_normalize_type(datapath_type);
299     class = ofproto_class_find__(datapath_type);
300     if (!class) {
301         VLOG_WARN("could not create datapath %s of unknown type %s",
302                   datapath_name, datapath_type);
303         return EAFNOSUPPORT;
304     }
305
306     ofproto = class->alloc();
307     if (!ofproto) {
308         VLOG_ERR("failed to allocate datapath %s of type %s",
309                  datapath_name, datapath_type);
310         return ENOMEM;
311     }
312
313     /* Initialize. */
314     memset(ofproto, 0, sizeof *ofproto);
315     ofproto->ofproto_class = class;
316     ofproto->name = xstrdup(datapath_name);
317     ofproto->type = xstrdup(datapath_type);
318     hmap_insert(&all_ofprotos, &ofproto->hmap_node,
319                 hash_string(ofproto->name, 0));
320     ofproto->datapath_id = 0;
321     ofproto_set_flow_eviction_threshold(ofproto,
322                                         OFPROTO_FLOW_EVICTON_THRESHOLD_DEFAULT);
323     ofproto->forward_bpdu = false;
324     ofproto->fallback_dpid = pick_fallback_dpid();
325     ofproto->mfr_desc = xstrdup(DEFAULT_MFR_DESC);
326     ofproto->hw_desc = xstrdup(DEFAULT_HW_DESC);
327     ofproto->sw_desc = xstrdup(DEFAULT_SW_DESC);
328     ofproto->serial_desc = xstrdup(DEFAULT_SERIAL_DESC);
329     ofproto->dp_desc = xstrdup(DEFAULT_DP_DESC);
330     ofproto->frag_handling = OFPC_FRAG_NORMAL;
331     hmap_init(&ofproto->ports);
332     shash_init(&ofproto->port_by_name);
333     ofproto->tables = NULL;
334     ofproto->n_tables = 0;
335     ofproto->connmgr = connmgr_create(ofproto, datapath_name, datapath_name);
336     ofproto->state = S_OPENFLOW;
337     list_init(&ofproto->pending);
338     ofproto->n_pending = 0;
339     hmap_init(&ofproto->deletions);
340
341     error = ofproto->ofproto_class->construct(ofproto, &n_tables);
342     if (error) {
343         VLOG_ERR("failed to open datapath %s: %s",
344                  datapath_name, strerror(error));
345         ofproto_destroy__(ofproto);
346         return error;
347     }
348
349     assert(n_tables >= 1 && n_tables <= 255);
350     ofproto->n_tables = n_tables;
351     ofproto->tables = xmalloc(n_tables * sizeof *ofproto->tables);
352     OFPROTO_FOR_EACH_TABLE (table, ofproto) {
353         classifier_init(table);
354     }
355
356     ofproto->datapath_id = pick_datapath_id(ofproto);
357     VLOG_INFO("using datapath ID %016"PRIx64, ofproto->datapath_id);
358     init_ports(ofproto);
359
360     *ofprotop = ofproto;
361     return 0;
362 }
363
364 void
365 ofproto_set_datapath_id(struct ofproto *p, uint64_t datapath_id)
366 {
367     uint64_t old_dpid = p->datapath_id;
368     p->datapath_id = datapath_id ? datapath_id : pick_datapath_id(p);
369     if (p->datapath_id != old_dpid) {
370         VLOG_INFO("datapath ID changed to %016"PRIx64, p->datapath_id);
371
372         /* Force all active connections to reconnect, since there is no way to
373          * notify a controller that the datapath ID has changed. */
374         ofproto_reconnect_controllers(p);
375     }
376 }
377
378 void
379 ofproto_set_controllers(struct ofproto *p,
380                         const struct ofproto_controller *controllers,
381                         size_t n_controllers)
382 {
383     connmgr_set_controllers(p->connmgr, controllers, n_controllers);
384 }
385
386 void
387 ofproto_set_fail_mode(struct ofproto *p, enum ofproto_fail_mode fail_mode)
388 {
389     connmgr_set_fail_mode(p->connmgr, fail_mode);
390 }
391
392 /* Drops the connections between 'ofproto' and all of its controllers, forcing
393  * them to reconnect. */
394 void
395 ofproto_reconnect_controllers(struct ofproto *ofproto)
396 {
397     connmgr_reconnect(ofproto->connmgr);
398 }
399
400 /* Sets the 'n' TCP port addresses in 'extras' as ones to which 'ofproto''s
401  * in-band control should guarantee access, in the same way that in-band
402  * control guarantees access to OpenFlow controllers. */
403 void
404 ofproto_set_extra_in_band_remotes(struct ofproto *ofproto,
405                                   const struct sockaddr_in *extras, size_t n)
406 {
407     connmgr_set_extra_in_band_remotes(ofproto->connmgr, extras, n);
408 }
409
410 /* Sets the OpenFlow queue used by flows set up by in-band control on
411  * 'ofproto' to 'queue_id'.  If 'queue_id' is negative, then in-band control
412  * flows will use the default queue. */
413 void
414 ofproto_set_in_band_queue(struct ofproto *ofproto, int queue_id)
415 {
416     connmgr_set_in_band_queue(ofproto->connmgr, queue_id);
417 }
418
419 /* Sets the number of flows at which eviction from the kernel flow table
420  * will occur. */
421 void
422 ofproto_set_flow_eviction_threshold(struct ofproto *ofproto, unsigned threshold)
423 {
424     if (threshold < OFPROTO_FLOW_EVICTION_THRESHOLD_MIN) {
425         ofproto->flow_eviction_threshold = OFPROTO_FLOW_EVICTION_THRESHOLD_MIN;
426     } else {
427         ofproto->flow_eviction_threshold = threshold;
428     }
429 }
430
431 /* If forward_bpdu is true, the NORMAL action will forward frames with
432  * reserved (e.g. STP) destination Ethernet addresses. if forward_bpdu is false,
433  * the NORMAL action will drop these frames. */
434 void
435 ofproto_set_forward_bpdu(struct ofproto *ofproto, bool forward_bpdu)
436 {
437     bool old_val = ofproto->forward_bpdu;
438     ofproto->forward_bpdu = forward_bpdu;
439     if (old_val != ofproto->forward_bpdu) {
440         if (ofproto->ofproto_class->forward_bpdu_changed) {
441             ofproto->ofproto_class->forward_bpdu_changed(ofproto);
442         }
443     }
444 }
445
446 void
447 ofproto_set_desc(struct ofproto *p,
448                  const char *mfr_desc, const char *hw_desc,
449                  const char *sw_desc, const char *serial_desc,
450                  const char *dp_desc)
451 {
452     struct ofp_desc_stats *ods;
453
454     if (mfr_desc) {
455         if (strlen(mfr_desc) >= sizeof ods->mfr_desc) {
456             VLOG_WARN("truncating mfr_desc, must be less than %zu characters",
457                     sizeof ods->mfr_desc);
458         }
459         free(p->mfr_desc);
460         p->mfr_desc = xstrdup(mfr_desc);
461     }
462     if (hw_desc) {
463         if (strlen(hw_desc) >= sizeof ods->hw_desc) {
464             VLOG_WARN("truncating hw_desc, must be less than %zu characters",
465                     sizeof ods->hw_desc);
466         }
467         free(p->hw_desc);
468         p->hw_desc = xstrdup(hw_desc);
469     }
470     if (sw_desc) {
471         if (strlen(sw_desc) >= sizeof ods->sw_desc) {
472             VLOG_WARN("truncating sw_desc, must be less than %zu characters",
473                     sizeof ods->sw_desc);
474         }
475         free(p->sw_desc);
476         p->sw_desc = xstrdup(sw_desc);
477     }
478     if (serial_desc) {
479         if (strlen(serial_desc) >= sizeof ods->serial_num) {
480             VLOG_WARN("truncating serial_desc, must be less than %zu "
481                     "characters",
482                     sizeof ods->serial_num);
483         }
484         free(p->serial_desc);
485         p->serial_desc = xstrdup(serial_desc);
486     }
487     if (dp_desc) {
488         if (strlen(dp_desc) >= sizeof ods->dp_desc) {
489             VLOG_WARN("truncating dp_desc, must be less than %zu characters",
490                     sizeof ods->dp_desc);
491         }
492         free(p->dp_desc);
493         p->dp_desc = xstrdup(dp_desc);
494     }
495 }
496
497 int
498 ofproto_set_snoops(struct ofproto *ofproto, const struct sset *snoops)
499 {
500     return connmgr_set_snoops(ofproto->connmgr, snoops);
501 }
502
503 int
504 ofproto_set_netflow(struct ofproto *ofproto,
505                     const struct netflow_options *nf_options)
506 {
507     if (nf_options && sset_is_empty(&nf_options->collectors)) {
508         nf_options = NULL;
509     }
510
511     if (ofproto->ofproto_class->set_netflow) {
512         return ofproto->ofproto_class->set_netflow(ofproto, nf_options);
513     } else {
514         return nf_options ? EOPNOTSUPP : 0;
515     }
516 }
517
518 int
519 ofproto_set_sflow(struct ofproto *ofproto,
520                   const struct ofproto_sflow_options *oso)
521 {
522     if (oso && sset_is_empty(&oso->targets)) {
523         oso = NULL;
524     }
525
526     if (ofproto->ofproto_class->set_sflow) {
527         return ofproto->ofproto_class->set_sflow(ofproto, oso);
528     } else {
529         return oso ? EOPNOTSUPP : 0;
530     }
531 }
532 \f
533 /* Spanning Tree Protocol (STP) configuration. */
534
535 /* Configures STP on 'ofproto' using the settings defined in 's'.  If
536  * 's' is NULL, disables STP.
537  *
538  * Returns 0 if successful, otherwise a positive errno value. */
539 int
540 ofproto_set_stp(struct ofproto *ofproto,
541                 const struct ofproto_stp_settings *s)
542 {
543     return (ofproto->ofproto_class->set_stp
544             ? ofproto->ofproto_class->set_stp(ofproto, s)
545             : EOPNOTSUPP);
546 }
547
548 /* Retrieves STP status of 'ofproto' and stores it in 's'.  If the
549  * 'enabled' member of 's' is false, then the other members are not
550  * meaningful.
551  *
552  * Returns 0 if successful, otherwise a positive errno value. */
553 int
554 ofproto_get_stp_status(struct ofproto *ofproto,
555                        struct ofproto_stp_status *s)
556 {
557     return (ofproto->ofproto_class->get_stp_status
558             ? ofproto->ofproto_class->get_stp_status(ofproto, s)
559             : EOPNOTSUPP);
560 }
561
562 /* Configures STP on 'ofp_port' of 'ofproto' using the settings defined
563  * in 's'.  The caller is responsible for assigning STP port numbers
564  * (using the 'port_num' member in the range of 1 through 255, inclusive)
565  * and ensuring there are no duplicates.  If the 's' is NULL, then STP
566  * is disabled on the port.
567  *
568  * Returns 0 if successful, otherwise a positive errno value.*/
569 int
570 ofproto_port_set_stp(struct ofproto *ofproto, uint16_t ofp_port,
571                      const struct ofproto_port_stp_settings *s)
572 {
573     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
574     if (!ofport) {
575         VLOG_WARN("%s: cannot configure STP on nonexistent port %"PRIu16,
576                   ofproto->name, ofp_port);
577         return ENODEV;
578     }
579
580     return (ofproto->ofproto_class->set_stp_port
581             ? ofproto->ofproto_class->set_stp_port(ofport, s)
582             : EOPNOTSUPP);
583 }
584
585 /* Retrieves STP port status of 'ofp_port' on 'ofproto' and stores it in
586  * 's'.  If the 'enabled' member in 's' is false, then the other members
587  * are not meaningful.
588  *
589  * Returns 0 if successful, otherwise a positive errno value.*/
590 int
591 ofproto_port_get_stp_status(struct ofproto *ofproto, uint16_t ofp_port,
592                             struct ofproto_port_stp_status *s)
593 {
594     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
595     if (!ofport) {
596         VLOG_WARN("%s: cannot get STP status on nonexistent port %"PRIu16,
597                   ofproto->name, ofp_port);
598         return ENODEV;
599     }
600
601     return (ofproto->ofproto_class->get_stp_port_status
602             ? ofproto->ofproto_class->get_stp_port_status(ofport, s)
603             : EOPNOTSUPP);
604 }
605 \f
606 /* Connectivity Fault Management configuration. */
607
608 /* Clears the CFM configuration from 'ofp_port' on 'ofproto'. */
609 void
610 ofproto_port_clear_cfm(struct ofproto *ofproto, uint16_t ofp_port)
611 {
612     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
613     if (ofport && ofproto->ofproto_class->set_cfm) {
614         ofproto->ofproto_class->set_cfm(ofport, NULL);
615     }
616 }
617
618 /* Configures connectivity fault management on 'ofp_port' in 'ofproto'.  Takes
619  * basic configuration from the configuration members in 'cfm', and the remote
620  * maintenance point ID from  remote_mpid.  Ignores the statistics members of
621  * 'cfm'.
622  *
623  * This function has no effect if 'ofproto' does not have a port 'ofp_port'. */
624 void
625 ofproto_port_set_cfm(struct ofproto *ofproto, uint16_t ofp_port,
626                      const struct cfm_settings *s)
627 {
628     struct ofport *ofport;
629     int error;
630
631     ofport = ofproto_get_port(ofproto, ofp_port);
632     if (!ofport) {
633         VLOG_WARN("%s: cannot configure CFM on nonexistent port %"PRIu16,
634                   ofproto->name, ofp_port);
635         return;
636     }
637
638     /* XXX: For configuration simplicity, we only support one remote_mpid
639      * outside of the CFM module.  It's not clear if this is the correct long
640      * term solution or not. */
641     error = (ofproto->ofproto_class->set_cfm
642              ? ofproto->ofproto_class->set_cfm(ofport, s)
643              : EOPNOTSUPP);
644     if (error) {
645         VLOG_WARN("%s: CFM configuration on port %"PRIu16" (%s) failed (%s)",
646                   ofproto->name, ofp_port, netdev_get_name(ofport->netdev),
647                   strerror(error));
648     }
649 }
650
651 /* Checks the status of LACP negotiation for 'ofp_port' within ofproto.
652  * Returns 1 if LACP partner information for 'ofp_port' is up-to-date,
653  * 0 if LACP partner information is not current (generally indicating a
654  * connectivity problem), or -1 if LACP is not enabled on 'ofp_port'. */
655 int
656 ofproto_port_is_lacp_current(struct ofproto *ofproto, uint16_t ofp_port)
657 {
658     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
659     return (ofport && ofproto->ofproto_class->port_is_lacp_current
660             ? ofproto->ofproto_class->port_is_lacp_current(ofport)
661             : -1);
662 }
663 \f
664 /* Bundles. */
665
666 /* Registers a "bundle" associated with client data pointer 'aux' in 'ofproto'.
667  * A bundle is the same concept as a Port in OVSDB, that is, it consists of one
668  * or more "slave" devices (Interfaces, in OVSDB) along with a VLAN
669  * configuration plus, if there is more than one slave, a bonding
670  * configuration.
671  *
672  * If 'aux' is already registered then this function updates its configuration
673  * to 's'.  Otherwise, this function registers a new bundle.
674  *
675  * Bundles only affect the NXAST_AUTOPATH action and output to the OFPP_NORMAL
676  * port. */
677 int
678 ofproto_bundle_register(struct ofproto *ofproto, void *aux,
679                         const struct ofproto_bundle_settings *s)
680 {
681     return (ofproto->ofproto_class->bundle_set
682             ? ofproto->ofproto_class->bundle_set(ofproto, aux, s)
683             : EOPNOTSUPP);
684 }
685
686 /* Unregisters the bundle registered on 'ofproto' with auxiliary data 'aux'.
687  * If no such bundle has been registered, this has no effect. */
688 int
689 ofproto_bundle_unregister(struct ofproto *ofproto, void *aux)
690 {
691     return ofproto_bundle_register(ofproto, aux, NULL);
692 }
693
694 \f
695 /* Registers a mirror associated with client data pointer 'aux' in 'ofproto'.
696  * If 'aux' is already registered then this function updates its configuration
697  * to 's'.  Otherwise, this function registers a new mirror.
698  *
699  * Mirrors affect only the treatment of packets output to the OFPP_NORMAL
700  * port.  */
701 int
702 ofproto_mirror_register(struct ofproto *ofproto, void *aux,
703                         const struct ofproto_mirror_settings *s)
704 {
705     return (ofproto->ofproto_class->mirror_set
706             ? ofproto->ofproto_class->mirror_set(ofproto, aux, s)
707             : EOPNOTSUPP);
708 }
709
710 /* Unregisters the mirror registered on 'ofproto' with auxiliary data 'aux'.
711  * If no mirror has been registered, this has no effect. */
712 int
713 ofproto_mirror_unregister(struct ofproto *ofproto, void *aux)
714 {
715     return ofproto_mirror_register(ofproto, aux, NULL);
716 }
717
718 /* Configures the VLANs whose bits are set to 1 in 'flood_vlans' as VLANs on
719  * which all packets are flooded, instead of using MAC learning.  If
720  * 'flood_vlans' is NULL, then MAC learning applies to all VLANs.
721  *
722  * Flood VLANs affect only the treatment of packets output to the OFPP_NORMAL
723  * port. */
724 int
725 ofproto_set_flood_vlans(struct ofproto *ofproto, unsigned long *flood_vlans)
726 {
727     return (ofproto->ofproto_class->set_flood_vlans
728             ? ofproto->ofproto_class->set_flood_vlans(ofproto, flood_vlans)
729             : EOPNOTSUPP);
730 }
731
732 /* Returns true if 'aux' is a registered bundle that is currently in use as the
733  * output for a mirror. */
734 bool
735 ofproto_is_mirror_output_bundle(const struct ofproto *ofproto, void *aux)
736 {
737     return (ofproto->ofproto_class->is_mirror_output_bundle
738             ? ofproto->ofproto_class->is_mirror_output_bundle(ofproto, aux)
739             : false);
740 }
741 \f
742 bool
743 ofproto_has_snoops(const struct ofproto *ofproto)
744 {
745     return connmgr_has_snoops(ofproto->connmgr);
746 }
747
748 void
749 ofproto_get_snoops(const struct ofproto *ofproto, struct sset *snoops)
750 {
751     connmgr_get_snoops(ofproto->connmgr, snoops);
752 }
753
754 static void
755 ofproto_flush__(struct ofproto *ofproto)
756 {
757     struct classifier *table;
758     struct ofopgroup *group;
759
760     if (ofproto->ofproto_class->flush) {
761         ofproto->ofproto_class->flush(ofproto);
762     }
763
764     group = ofopgroup_create_unattached(ofproto);
765     OFPROTO_FOR_EACH_TABLE (table, ofproto) {
766         struct rule *rule, *next_rule;
767         struct cls_cursor cursor;
768
769         cls_cursor_init(&cursor, table, NULL);
770         CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, cr, &cursor) {
771             if (!rule->pending) {
772                 ofoperation_create(group, rule, OFOPERATION_DELETE);
773                 classifier_remove(table, &rule->cr);
774                 ofproto->ofproto_class->rule_destruct(rule);
775             }
776         }
777     }
778     ofopgroup_submit(group);
779 }
780
781 static void
782 ofproto_destroy__(struct ofproto *ofproto)
783 {
784     struct classifier *table;
785
786     assert(list_is_empty(&ofproto->pending));
787     assert(!ofproto->n_pending);
788
789     connmgr_destroy(ofproto->connmgr);
790
791     hmap_remove(&all_ofprotos, &ofproto->hmap_node);
792     free(ofproto->name);
793     free(ofproto->type);
794     free(ofproto->mfr_desc);
795     free(ofproto->hw_desc);
796     free(ofproto->sw_desc);
797     free(ofproto->serial_desc);
798     free(ofproto->dp_desc);
799     hmap_destroy(&ofproto->ports);
800     shash_destroy(&ofproto->port_by_name);
801
802     OFPROTO_FOR_EACH_TABLE (table, ofproto) {
803         assert(classifier_is_empty(table));
804         classifier_destroy(table);
805     }
806     free(ofproto->tables);
807
808     hmap_destroy(&ofproto->deletions);
809
810     ofproto->ofproto_class->dealloc(ofproto);
811 }
812
813 void
814 ofproto_destroy(struct ofproto *p)
815 {
816     struct ofport *ofport, *next_ofport;
817
818     if (!p) {
819         return;
820     }
821
822     ofproto_flush__(p);
823     HMAP_FOR_EACH_SAFE (ofport, next_ofport, hmap_node, &p->ports) {
824         ofport_destroy(ofport);
825     }
826
827     p->ofproto_class->destruct(p);
828     ofproto_destroy__(p);
829 }
830
831 /* Destroys the datapath with the respective 'name' and 'type'.  With the Linux
832  * kernel datapath, for example, this destroys the datapath in the kernel, and
833  * with the netdev-based datapath, it tears down the data structures that
834  * represent the datapath.
835  *
836  * The datapath should not be currently open as an ofproto. */
837 int
838 ofproto_delete(const char *name, const char *type)
839 {
840     const struct ofproto_class *class = ofproto_class_find__(type);
841     return (!class ? EAFNOSUPPORT
842             : !class->del ? EACCES
843             : class->del(type, name));
844 }
845
846 static void
847 process_port_change(struct ofproto *ofproto, int error, char *devname)
848 {
849     if (error == ENOBUFS) {
850         reinit_ports(ofproto);
851     } else if (!error) {
852         update_port(ofproto, devname);
853         free(devname);
854     }
855 }
856
857 int
858 ofproto_run(struct ofproto *p)
859 {
860     struct ofport *ofport;
861     char *devname;
862     int error;
863
864     error = p->ofproto_class->run(p);
865     if (error == ENODEV) {
866         /* Someone destroyed the datapath behind our back.  The caller
867          * better destroy us and give up, because we're just going to
868          * spin from here on out. */
869         static struct vlog_rate_limit rl2 = VLOG_RATE_LIMIT_INIT(1, 5);
870         VLOG_ERR_RL(&rl2, "%s: datapath was destroyed externally",
871                     p->name);
872         return ENODEV;
873     }
874
875     if (p->ofproto_class->port_poll) {
876         while ((error = p->ofproto_class->port_poll(p, &devname)) != EAGAIN) {
877             process_port_change(p, error, devname);
878         }
879     }
880
881     HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
882         unsigned int change_seq = netdev_change_seq(ofport->netdev);
883         if (ofport->change_seq != change_seq) {
884             ofport->change_seq = change_seq;
885             update_port(p, netdev_get_name(ofport->netdev));
886         }
887     }
888
889
890     switch (p->state) {
891     case S_OPENFLOW:
892         connmgr_run(p->connmgr, handle_openflow);
893         break;
894
895     case S_FLUSH:
896         connmgr_run(p->connmgr, NULL);
897         ofproto_flush__(p);
898         if (list_is_empty(&p->pending) && hmap_is_empty(&p->deletions)) {
899             connmgr_flushed(p->connmgr);
900             p->state = S_OPENFLOW;
901         }
902         break;
903
904     default:
905         NOT_REACHED();
906     }
907
908     return 0;
909 }
910
911 void
912 ofproto_wait(struct ofproto *p)
913 {
914     struct ofport *ofport;
915
916     p->ofproto_class->wait(p);
917     if (p->ofproto_class->port_poll_wait) {
918         p->ofproto_class->port_poll_wait(p);
919     }
920
921     HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
922         if (ofport->change_seq != netdev_change_seq(ofport->netdev)) {
923             poll_immediate_wake();
924         }
925     }
926
927     switch (p->state) {
928     case S_OPENFLOW:
929         connmgr_wait(p->connmgr, true);
930         break;
931
932     case S_FLUSH:
933         connmgr_wait(p->connmgr, false);
934         if (list_is_empty(&p->pending) && hmap_is_empty(&p->deletions)) {
935             poll_immediate_wake();
936         }
937         break;
938     }
939 }
940
941 bool
942 ofproto_is_alive(const struct ofproto *p)
943 {
944     return connmgr_has_controllers(p->connmgr);
945 }
946
947 void
948 ofproto_get_ofproto_controller_info(const struct ofproto *ofproto,
949                                     struct shash *info)
950 {
951     connmgr_get_controller_info(ofproto->connmgr, info);
952 }
953
954 void
955 ofproto_free_ofproto_controller_info(struct shash *info)
956 {
957     connmgr_free_controller_info(info);
958 }
959
960 /* Makes a deep copy of 'old' into 'port'. */
961 void
962 ofproto_port_clone(struct ofproto_port *port, const struct ofproto_port *old)
963 {
964     port->name = xstrdup(old->name);
965     port->type = xstrdup(old->type);
966     port->ofp_port = old->ofp_port;
967 }
968
969 /* Frees memory allocated to members of 'ofproto_port'.
970  *
971  * Do not call this function on an ofproto_port obtained from
972  * ofproto_port_dump_next(): that function retains ownership of the data in the
973  * ofproto_port. */
974 void
975 ofproto_port_destroy(struct ofproto_port *ofproto_port)
976 {
977     free(ofproto_port->name);
978     free(ofproto_port->type);
979 }
980
981 /* Initializes 'dump' to begin dumping the ports in an ofproto.
982  *
983  * This function provides no status indication.  An error status for the entire
984  * dump operation is provided when it is completed by calling
985  * ofproto_port_dump_done().
986  */
987 void
988 ofproto_port_dump_start(struct ofproto_port_dump *dump,
989                         const struct ofproto *ofproto)
990 {
991     dump->ofproto = ofproto;
992     dump->error = ofproto->ofproto_class->port_dump_start(ofproto,
993                                                           &dump->state);
994 }
995
996 /* Attempts to retrieve another port from 'dump', which must have been created
997  * with ofproto_port_dump_start().  On success, stores a new ofproto_port into
998  * 'port' and returns true.  On failure, returns false.
999  *
1000  * Failure might indicate an actual error or merely that the last port has been
1001  * dumped.  An error status for the entire dump operation is provided when it
1002  * is completed by calling ofproto_port_dump_done().
1003  *
1004  * The ofproto owns the data stored in 'port'.  It will remain valid until at
1005  * least the next time 'dump' is passed to ofproto_port_dump_next() or
1006  * ofproto_port_dump_done(). */
1007 bool
1008 ofproto_port_dump_next(struct ofproto_port_dump *dump,
1009                        struct ofproto_port *port)
1010 {
1011     const struct ofproto *ofproto = dump->ofproto;
1012
1013     if (dump->error) {
1014         return false;
1015     }
1016
1017     dump->error = ofproto->ofproto_class->port_dump_next(ofproto, dump->state,
1018                                                          port);
1019     if (dump->error) {
1020         ofproto->ofproto_class->port_dump_done(ofproto, dump->state);
1021         return false;
1022     }
1023     return true;
1024 }
1025
1026 /* Completes port table dump operation 'dump', which must have been created
1027  * with ofproto_port_dump_start().  Returns 0 if the dump operation was
1028  * error-free, otherwise a positive errno value describing the problem. */
1029 int
1030 ofproto_port_dump_done(struct ofproto_port_dump *dump)
1031 {
1032     const struct ofproto *ofproto = dump->ofproto;
1033     if (!dump->error) {
1034         dump->error = ofproto->ofproto_class->port_dump_done(ofproto,
1035                                                              dump->state);
1036     }
1037     return dump->error == EOF ? 0 : dump->error;
1038 }
1039
1040 /* Attempts to add 'netdev' as a port on 'ofproto'.  If successful, returns 0
1041  * and sets '*ofp_portp' to the new port's OpenFlow port number (if 'ofp_portp'
1042  * is non-null).  On failure, returns a positive errno value and sets
1043  * '*ofp_portp' to OFPP_NONE (if 'ofp_portp' is non-null). */
1044 int
1045 ofproto_port_add(struct ofproto *ofproto, struct netdev *netdev,
1046                  uint16_t *ofp_portp)
1047 {
1048     uint16_t ofp_port;
1049     int error;
1050
1051     error = ofproto->ofproto_class->port_add(ofproto, netdev, &ofp_port);
1052     if (!error) {
1053         update_port(ofproto, netdev_get_name(netdev));
1054     }
1055     if (ofp_portp) {
1056         *ofp_portp = error ? OFPP_NONE : ofp_port;
1057     }
1058     return error;
1059 }
1060
1061 /* Looks up a port named 'devname' in 'ofproto'.  On success, returns 0 and
1062  * initializes '*port' appropriately; on failure, returns a positive errno
1063  * value.
1064  *
1065  * The caller owns the data in 'ofproto_port' and must free it with
1066  * ofproto_port_destroy() when it is no longer needed. */
1067 int
1068 ofproto_port_query_by_name(const struct ofproto *ofproto, const char *devname,
1069                            struct ofproto_port *port)
1070 {
1071     int error;
1072
1073     error = ofproto->ofproto_class->port_query_by_name(ofproto, devname, port);
1074     if (error) {
1075         memset(port, 0, sizeof *port);
1076     }
1077     return error;
1078 }
1079
1080 /* Deletes port number 'ofp_port' from the datapath for 'ofproto'.
1081  * Returns 0 if successful, otherwise a positive errno. */
1082 int
1083 ofproto_port_del(struct ofproto *ofproto, uint16_t ofp_port)
1084 {
1085     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
1086     const char *name = ofport ? netdev_get_name(ofport->netdev) : "<unknown>";
1087     int error;
1088
1089     error = ofproto->ofproto_class->port_del(ofproto, ofp_port);
1090     if (!error && ofport) {
1091         /* 'name' is the netdev's name and update_port() is going to close the
1092          * netdev.  Just in case update_port() refers to 'name' after it
1093          * destroys 'ofport', make a copy of it around the update_port()
1094          * call. */
1095         char *devname = xstrdup(name);
1096         update_port(ofproto, devname);
1097         free(devname);
1098     }
1099     return error;
1100 }
1101
1102 /* Adds a flow to OpenFlow flow table 0 in 'p' that matches 'cls_rule' and
1103  * performs the 'n_actions' actions in 'actions'.  The new flow will not
1104  * timeout.
1105  *
1106  * If cls_rule->priority is in the range of priorities supported by OpenFlow
1107  * (0...65535, inclusive) then the flow will be visible to OpenFlow
1108  * controllers; otherwise, it will be hidden.
1109  *
1110  * The caller retains ownership of 'cls_rule' and 'actions'.
1111  *
1112  * This is a helper function for in-band control and fail-open. */
1113 void
1114 ofproto_add_flow(struct ofproto *ofproto, const struct cls_rule *cls_rule,
1115                  const union ofp_action *actions, size_t n_actions)
1116 {
1117     const struct rule *rule;
1118
1119     rule = rule_from_cls_rule(classifier_find_rule_exactly(
1120                                     &ofproto->tables[0], cls_rule));
1121     if (!rule || !ofputil_actions_equal(rule->actions, rule->n_actions,
1122                                         actions, n_actions)) {
1123         struct ofputil_flow_mod fm;
1124
1125         memset(&fm, 0, sizeof fm);
1126         fm.cr = *cls_rule;
1127         fm.buffer_id = UINT32_MAX;
1128         fm.actions = (union ofp_action *) actions;
1129         fm.n_actions = n_actions;
1130         add_flow(ofproto, NULL, &fm, NULL);
1131     }
1132 }
1133
1134 /* Executes the flow modification specified in 'fm'.  Returns 0 on success, an
1135  * OpenFlow error code as encoded by ofp_mkerr() on failure, or
1136  * OFPROTO_POSTPONE if the operation cannot be initiated now but may be retried
1137  * later.
1138  *
1139  * This is a helper function for in-band control and fail-open. */
1140 int
1141 ofproto_flow_mod(struct ofproto *ofproto, const struct ofputil_flow_mod *fm)
1142 {
1143     return handle_flow_mod__(ofproto, NULL, fm, NULL);
1144 }
1145
1146 /* Searches for a rule with matching criteria exactly equal to 'target' in
1147  * ofproto's table 0 and, if it finds one, deletes it.
1148  *
1149  * This is a helper function for in-band control and fail-open. */
1150 bool
1151 ofproto_delete_flow(struct ofproto *ofproto, const struct cls_rule *target)
1152 {
1153     struct rule *rule;
1154
1155     rule = rule_from_cls_rule(classifier_find_rule_exactly(
1156                                   &ofproto->tables[0], target));
1157     if (!rule) {
1158         /* No such rule -> success. */
1159         return true;
1160     } else if (rule->pending) {
1161         /* An operation on the rule is already pending -> failure.
1162          * Caller must retry later if it's important. */
1163         return false;
1164     } else {
1165         /* Initiate deletion -> success. */
1166         struct ofopgroup *group = ofopgroup_create_unattached(ofproto);
1167         ofoperation_create(group, rule, OFOPERATION_DELETE);
1168         classifier_remove(&ofproto->tables[rule->table_id], &rule->cr);
1169         rule->ofproto->ofproto_class->rule_destruct(rule);
1170         ofopgroup_submit(group);
1171         return true;
1172     }
1173
1174 }
1175
1176 /* Starts the process of deleting all of the flows from all of ofproto's flow
1177  * tables and then reintroducing the flows required by in-band control and
1178  * fail-open.  The process will complete in a later call to ofproto_run(). */
1179 void
1180 ofproto_flush_flows(struct ofproto *ofproto)
1181 {
1182     COVERAGE_INC(ofproto_flush);
1183     ofproto->state = S_FLUSH;
1184 }
1185 \f
1186 static void
1187 reinit_ports(struct ofproto *p)
1188 {
1189     struct ofproto_port_dump dump;
1190     struct sset devnames;
1191     struct ofport *ofport;
1192     struct ofproto_port ofproto_port;
1193     const char *devname;
1194
1195     COVERAGE_INC(ofproto_reinit_ports);
1196
1197     sset_init(&devnames);
1198     HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
1199         sset_add(&devnames, netdev_get_name(ofport->netdev));
1200     }
1201     OFPROTO_PORT_FOR_EACH (&ofproto_port, &dump, p) {
1202         sset_add(&devnames, ofproto_port.name);
1203     }
1204
1205     SSET_FOR_EACH (devname, &devnames) {
1206         update_port(p, devname);
1207     }
1208     sset_destroy(&devnames);
1209 }
1210
1211 /* Opens and returns a netdev for 'ofproto_port', or a null pointer if the
1212  * netdev cannot be opened.  On success, also fills in 'opp'.  */
1213 static struct netdev *
1214 ofport_open(const struct ofproto_port *ofproto_port, struct ofp_phy_port *opp)
1215 {
1216     uint32_t curr, advertised, supported, peer;
1217     enum netdev_flags flags;
1218     struct netdev *netdev;
1219     int error;
1220
1221     error = netdev_open(ofproto_port->name, ofproto_port->type, &netdev);
1222     if (error) {
1223         VLOG_WARN_RL(&rl, "ignoring port %s (%"PRIu16") because netdev %s "
1224                      "cannot be opened (%s)",
1225                      ofproto_port->name, ofproto_port->ofp_port,
1226                      ofproto_port->name, strerror(error));
1227         return NULL;
1228     }
1229
1230     netdev_get_flags(netdev, &flags);
1231     netdev_get_features(netdev, &curr, &advertised, &supported, &peer);
1232
1233     opp->port_no = htons(ofproto_port->ofp_port);
1234     netdev_get_etheraddr(netdev, opp->hw_addr);
1235     ovs_strzcpy(opp->name, ofproto_port->name, sizeof opp->name);
1236     opp->config = flags & NETDEV_UP ? 0 : htonl(OFPPC_PORT_DOWN);
1237     opp->state = netdev_get_carrier(netdev) ? 0 : htonl(OFPPS_LINK_DOWN);
1238     opp->curr = htonl(curr);
1239     opp->advertised = htonl(advertised);
1240     opp->supported = htonl(supported);
1241     opp->peer = htonl(peer);
1242
1243     return netdev;
1244 }
1245
1246 /* Returns true if most fields of 'a' and 'b' are equal.  Differences in name,
1247  * port number, and 'config' bits other than OFPPC_PORT_DOWN are
1248  * disregarded. */
1249 static bool
1250 ofport_equal(const struct ofp_phy_port *a, const struct ofp_phy_port *b)
1251 {
1252     BUILD_ASSERT_DECL(sizeof *a == 48); /* Detect ofp_phy_port changes. */
1253     return (!memcmp(a->hw_addr, b->hw_addr, sizeof a->hw_addr)
1254             && a->state == b->state
1255             && !((a->config ^ b->config) & htonl(OFPPC_PORT_DOWN))
1256             && a->curr == b->curr
1257             && a->advertised == b->advertised
1258             && a->supported == b->supported
1259             && a->peer == b->peer);
1260 }
1261
1262 /* Adds an ofport to 'p' initialized based on the given 'netdev' and 'opp'.
1263  * The caller must ensure that 'p' does not have a conflicting ofport (that is,
1264  * one with the same name or port number). */
1265 static void
1266 ofport_install(struct ofproto *p,
1267                struct netdev *netdev, const struct ofp_phy_port *opp)
1268 {
1269     const char *netdev_name = netdev_get_name(netdev);
1270     struct ofport *ofport;
1271     int dev_mtu;
1272     int error;
1273
1274     /* Create ofport. */
1275     ofport = p->ofproto_class->port_alloc();
1276     if (!ofport) {
1277         error = ENOMEM;
1278         goto error;
1279     }
1280     ofport->ofproto = p;
1281     ofport->netdev = netdev;
1282     ofport->change_seq = netdev_change_seq(netdev);
1283     ofport->opp = *opp;
1284     ofport->ofp_port = ntohs(opp->port_no);
1285
1286     /* Add port to 'p'. */
1287     hmap_insert(&p->ports, &ofport->hmap_node, hash_int(ofport->ofp_port, 0));
1288     shash_add(&p->port_by_name, netdev_name, ofport);
1289
1290     if (!netdev_get_mtu(netdev, &dev_mtu)) {
1291         set_internal_devs_mtu(p);
1292         ofport->mtu = dev_mtu;
1293     } else {
1294         ofport->mtu = 0;
1295     }
1296
1297     /* Let the ofproto_class initialize its private data. */
1298     error = p->ofproto_class->port_construct(ofport);
1299     if (error) {
1300         goto error;
1301     }
1302     connmgr_send_port_status(p->connmgr, opp, OFPPR_ADD);
1303     return;
1304
1305 error:
1306     VLOG_WARN_RL(&rl, "%s: could not add port %s (%s)",
1307                  p->name, netdev_name, strerror(error));
1308     if (ofport) {
1309         ofport_destroy__(ofport);
1310     } else {
1311         netdev_close(netdev);
1312     }
1313 }
1314
1315 /* Removes 'ofport' from 'p' and destroys it. */
1316 static void
1317 ofport_remove(struct ofport *ofport)
1318 {
1319     connmgr_send_port_status(ofport->ofproto->connmgr, &ofport->opp,
1320                              OFPPR_DELETE);
1321     ofport_destroy(ofport);
1322 }
1323
1324 /* If 'ofproto' contains an ofport named 'name', removes it from 'ofproto' and
1325  * destroys it. */
1326 static void
1327 ofport_remove_with_name(struct ofproto *ofproto, const char *name)
1328 {
1329     struct ofport *port = shash_find_data(&ofproto->port_by_name, name);
1330     if (port) {
1331         ofport_remove(port);
1332     }
1333 }
1334
1335 /* Updates 'port' with new 'opp' description.
1336  *
1337  * Does not handle a name or port number change.  The caller must implement
1338  * such a change as a delete followed by an add.  */
1339 static void
1340 ofport_modified(struct ofport *port, struct ofp_phy_port *opp)
1341 {
1342     memcpy(port->opp.hw_addr, opp->hw_addr, ETH_ADDR_LEN);
1343     port->opp.config = ((port->opp.config & ~htonl(OFPPC_PORT_DOWN))
1344                         | (opp->config & htonl(OFPPC_PORT_DOWN)));
1345     port->opp.state = opp->state;
1346     port->opp.curr = opp->curr;
1347     port->opp.advertised = opp->advertised;
1348     port->opp.supported = opp->supported;
1349     port->opp.peer = opp->peer;
1350
1351     connmgr_send_port_status(port->ofproto->connmgr, &port->opp, OFPPR_MODIFY);
1352 }
1353
1354 /* Update OpenFlow 'state' in 'port' and notify controller. */
1355 void
1356 ofproto_port_set_state(struct ofport *port, ovs_be32 state)
1357 {
1358     if (port->opp.state != state) {
1359         port->opp.state = state;
1360         connmgr_send_port_status(port->ofproto->connmgr, &port->opp,
1361                                  OFPPR_MODIFY);
1362     }
1363 }
1364
1365 void
1366 ofproto_port_unregister(struct ofproto *ofproto, uint16_t ofp_port)
1367 {
1368     struct ofport *port = ofproto_get_port(ofproto, ofp_port);
1369     if (port) {
1370         if (port->ofproto->ofproto_class->set_cfm) {
1371             port->ofproto->ofproto_class->set_cfm(port, NULL);
1372         }
1373         if (port->ofproto->ofproto_class->bundle_remove) {
1374             port->ofproto->ofproto_class->bundle_remove(port);
1375         }
1376     }
1377 }
1378
1379 static void
1380 ofport_destroy__(struct ofport *port)
1381 {
1382     struct ofproto *ofproto = port->ofproto;
1383     const char *name = netdev_get_name(port->netdev);
1384
1385     hmap_remove(&ofproto->ports, &port->hmap_node);
1386     shash_delete(&ofproto->port_by_name,
1387                  shash_find(&ofproto->port_by_name, name));
1388
1389     netdev_close(port->netdev);
1390     ofproto->ofproto_class->port_dealloc(port);
1391 }
1392
1393 static void
1394 ofport_destroy(struct ofport *port)
1395 {
1396     if (port) {
1397         port->ofproto->ofproto_class->port_destruct(port);
1398         ofport_destroy__(port);
1399      }
1400 }
1401
1402 struct ofport *
1403 ofproto_get_port(const struct ofproto *ofproto, uint16_t ofp_port)
1404 {
1405     struct ofport *port;
1406
1407     HMAP_FOR_EACH_IN_BUCKET (port, hmap_node,
1408                              hash_int(ofp_port, 0), &ofproto->ports) {
1409         if (port->ofp_port == ofp_port) {
1410             return port;
1411         }
1412     }
1413     return NULL;
1414 }
1415
1416 static void
1417 update_port(struct ofproto *ofproto, const char *name)
1418 {
1419     struct ofproto_port ofproto_port;
1420     struct ofp_phy_port opp;
1421     struct netdev *netdev;
1422     struct ofport *port;
1423
1424     COVERAGE_INC(ofproto_update_port);
1425
1426     /* Fetch 'name''s location and properties from the datapath. */
1427     netdev = (!ofproto_port_query_by_name(ofproto, name, &ofproto_port)
1428               ? ofport_open(&ofproto_port, &opp)
1429               : NULL);
1430     if (netdev) {
1431         port = ofproto_get_port(ofproto, ofproto_port.ofp_port);
1432         if (port && !strcmp(netdev_get_name(port->netdev), name)) {
1433             struct netdev *old_netdev = port->netdev;
1434             int dev_mtu;
1435
1436             /* 'name' hasn't changed location.  Any properties changed? */
1437             if (!ofport_equal(&port->opp, &opp)) {
1438                 ofport_modified(port, &opp);
1439             }
1440
1441             /* If this is a non-internal port and the MTU changed, check
1442              * if the datapath's MTU needs to be updated. */
1443             if (strcmp(netdev_get_type(netdev), "internal")
1444                     && !netdev_get_mtu(netdev, &dev_mtu)
1445                     && port->mtu != dev_mtu) {
1446                 set_internal_devs_mtu(ofproto);
1447                 port->mtu = dev_mtu;
1448             }
1449
1450             /* Install the newly opened netdev in case it has changed.
1451              * Don't close the old netdev yet in case port_modified has to
1452              * remove a retained reference to it.*/
1453             port->netdev = netdev;
1454             port->change_seq = netdev_change_seq(netdev);
1455
1456             if (port->ofproto->ofproto_class->port_modified) {
1457                 port->ofproto->ofproto_class->port_modified(port);
1458             }
1459
1460             netdev_close(old_netdev);
1461         } else {
1462             /* If 'port' is nonnull then its name differs from 'name' and thus
1463              * we should delete it.  If we think there's a port named 'name'
1464              * then its port number must be wrong now so delete it too. */
1465             if (port) {
1466                 ofport_remove(port);
1467             }
1468             ofport_remove_with_name(ofproto, name);
1469             ofport_install(ofproto, netdev, &opp);
1470         }
1471     } else {
1472         /* Any port named 'name' is gone now. */
1473         ofport_remove_with_name(ofproto, name);
1474     }
1475     ofproto_port_destroy(&ofproto_port);
1476 }
1477
1478 static int
1479 init_ports(struct ofproto *p)
1480 {
1481     struct ofproto_port_dump dump;
1482     struct ofproto_port ofproto_port;
1483
1484     OFPROTO_PORT_FOR_EACH (&ofproto_port, &dump, p) {
1485         uint16_t ofp_port = ofproto_port.ofp_port;
1486         if (ofproto_get_port(p, ofp_port)) {
1487             VLOG_WARN_RL(&rl, "ignoring duplicate port %"PRIu16" in datapath",
1488                          ofp_port);
1489         } else if (shash_find(&p->port_by_name, ofproto_port.name)) {
1490             VLOG_WARN_RL(&rl, "ignoring duplicate device %s in datapath",
1491                          ofproto_port.name);
1492         } else {
1493             struct ofp_phy_port opp;
1494             struct netdev *netdev;
1495
1496             netdev = ofport_open(&ofproto_port, &opp);
1497             if (netdev) {
1498                 ofport_install(p, netdev, &opp);
1499             }
1500         }
1501     }
1502
1503     return 0;
1504 }
1505
1506 /* Find the minimum MTU of all non-datapath devices attached to 'p'.
1507  * Returns ETH_PAYLOAD_MAX or the minimum of the ports. */
1508 static int
1509 find_min_mtu(struct ofproto *p)
1510 {
1511     struct ofport *ofport;
1512     int mtu = 0;
1513
1514     HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
1515         struct netdev *netdev = ofport->netdev;
1516         int dev_mtu;
1517
1518         /* Skip any internal ports, since that's what we're trying to
1519          * set. */
1520         if (!strcmp(netdev_get_type(netdev), "internal")) {
1521             continue;
1522         }
1523
1524         if (netdev_get_mtu(netdev, &dev_mtu)) {
1525             continue;
1526         }
1527         if (!mtu || dev_mtu < mtu) {
1528             mtu = dev_mtu;
1529         }
1530     }
1531
1532     return mtu ? mtu: ETH_PAYLOAD_MAX;
1533 }
1534
1535 /* Set the MTU of all datapath devices on 'p' to the minimum of the
1536  * non-datapath ports. */
1537 static void
1538 set_internal_devs_mtu(struct ofproto *p)
1539 {
1540     struct ofport *ofport;
1541     int mtu = find_min_mtu(p);
1542
1543     HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
1544         struct netdev *netdev = ofport->netdev;
1545
1546         if (!strcmp(netdev_get_type(netdev), "internal")) {
1547             netdev_set_mtu(netdev, mtu);
1548         }
1549     }
1550 }
1551 \f
1552 static void
1553 ofproto_rule_destroy__(struct rule *rule)
1554 {
1555     free(rule->actions);
1556     rule->ofproto->ofproto_class->rule_dealloc(rule);
1557 }
1558
1559 /* This function allows an ofproto implementation to destroy any rules that
1560  * remain when its ->destruct() function is called.  The caller must have
1561  * already uninitialized any derived members of 'rule' (step 5 described in the
1562  * large comment in ofproto/ofproto-provider.h titled "Life Cycle").
1563  * This function implements steps 6 and 7.
1564  *
1565  * This function should only be called from an ofproto implementation's
1566  * ->destruct() function.  It is not suitable elsewhere. */
1567 void
1568 ofproto_rule_destroy(struct rule *rule)
1569 {
1570     assert(!rule->pending);
1571     classifier_remove(&rule->ofproto->tables[rule->table_id], &rule->cr);
1572     ofproto_rule_destroy__(rule);
1573 }
1574
1575 /* Returns true if 'rule' has an OpenFlow OFPAT_OUTPUT or OFPAT_ENQUEUE action
1576  * that outputs to 'out_port' (output to OFPP_FLOOD and OFPP_ALL doesn't
1577  * count). */
1578 static bool
1579 rule_has_out_port(const struct rule *rule, uint16_t out_port)
1580 {
1581     const union ofp_action *oa;
1582     size_t left;
1583
1584     if (out_port == OFPP_NONE) {
1585         return true;
1586     }
1587     OFPUTIL_ACTION_FOR_EACH_UNSAFE (oa, left, rule->actions, rule->n_actions) {
1588         if (action_outputs_to_port(oa, htons(out_port))) {
1589             return true;
1590         }
1591     }
1592     return false;
1593 }
1594
1595 /* Executes the actions indicated by 'rule' on 'packet' and credits 'rule''s
1596  * statistics appropriately.  'packet' must have at least sizeof(struct
1597  * ofp_packet_in) bytes of headroom.
1598  *
1599  * 'packet' doesn't necessarily have to match 'rule'.  'rule' will be credited
1600  * with statistics for 'packet' either way.
1601  *
1602  * Takes ownership of 'packet'. */
1603 static int
1604 rule_execute(struct rule *rule, uint16_t in_port, struct ofpbuf *packet)
1605 {
1606     struct flow flow;
1607
1608     assert(ofpbuf_headroom(packet) >= sizeof(struct ofp_packet_in));
1609
1610     flow_extract(packet, 0, 0, in_port, &flow);
1611     return rule->ofproto->ofproto_class->rule_execute(rule, &flow, packet);
1612 }
1613
1614 /* Returns true if 'rule' should be hidden from the controller.
1615  *
1616  * Rules with priority higher than UINT16_MAX are set up by ofproto itself
1617  * (e.g. by in-band control) and are intentionally hidden from the
1618  * controller. */
1619 static bool
1620 rule_is_hidden(const struct rule *rule)
1621 {
1622     return rule->cr.priority > UINT16_MAX;
1623 }
1624 \f
1625 static int
1626 handle_echo_request(struct ofconn *ofconn, const struct ofp_header *oh)
1627 {
1628     ofconn_send_reply(ofconn, make_echo_reply(oh));
1629     return 0;
1630 }
1631
1632 static int
1633 handle_features_request(struct ofconn *ofconn, const struct ofp_header *oh)
1634 {
1635     struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
1636     struct ofp_switch_features *osf;
1637     struct ofpbuf *buf;
1638     struct ofport *port;
1639     bool arp_match_ip;
1640     uint32_t actions;
1641
1642     ofproto->ofproto_class->get_features(ofproto, &arp_match_ip, &actions);
1643     assert(actions & (1 << OFPAT_OUTPUT)); /* sanity check */
1644
1645     osf = make_openflow_xid(sizeof *osf, OFPT_FEATURES_REPLY, oh->xid, &buf);
1646     osf->datapath_id = htonll(ofproto->datapath_id);
1647     osf->n_buffers = htonl(pktbuf_capacity());
1648     osf->n_tables = ofproto->n_tables;
1649     osf->capabilities = htonl(OFPC_FLOW_STATS | OFPC_TABLE_STATS |
1650                               OFPC_PORT_STATS | OFPC_QUEUE_STATS);
1651     if (arp_match_ip) {
1652         osf->capabilities |= htonl(OFPC_ARP_MATCH_IP);
1653     }
1654     osf->actions = htonl(actions);
1655
1656     HMAP_FOR_EACH (port, hmap_node, &ofproto->ports) {
1657         ofpbuf_put(buf, &port->opp, sizeof port->opp);
1658     }
1659
1660     ofconn_send_reply(ofconn, buf);
1661     return 0;
1662 }
1663
1664 static int
1665 handle_get_config_request(struct ofconn *ofconn, const struct ofp_header *oh)
1666 {
1667     struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
1668     struct ofp_switch_config *osc;
1669     struct ofpbuf *buf;
1670
1671     /* Send reply. */
1672     osc = make_openflow_xid(sizeof *osc, OFPT_GET_CONFIG_REPLY, oh->xid, &buf);
1673     osc->flags = htons(ofproto->frag_handling);
1674     osc->miss_send_len = htons(ofconn_get_miss_send_len(ofconn));
1675     ofconn_send_reply(ofconn, buf);
1676
1677     return 0;
1678 }
1679
1680 static int
1681 handle_set_config(struct ofconn *ofconn, const struct ofp_switch_config *osc)
1682 {
1683     struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
1684     uint16_t flags = ntohs(osc->flags);
1685
1686     if (ofconn_get_type(ofconn) != OFCONN_PRIMARY
1687         || ofconn_get_role(ofconn) != NX_ROLE_SLAVE) {
1688         enum ofp_config_flags cur = ofproto->frag_handling;
1689         enum ofp_config_flags next = flags & OFPC_FRAG_MASK;
1690
1691         assert((cur & OFPC_FRAG_MASK) == cur);
1692         if (cur != next) {
1693             if (ofproto->ofproto_class->set_frag_handling(ofproto, next)) {
1694                 ofproto->frag_handling = next;
1695             } else {
1696                 VLOG_WARN_RL(&rl, "%s: unsupported fragment handling mode %s",
1697                              ofproto->name,
1698                              ofputil_frag_handling_to_string(next));
1699             }
1700         }
1701     }
1702
1703     ofconn_set_miss_send_len(ofconn, ntohs(osc->miss_send_len));
1704
1705     return 0;
1706 }
1707
1708 /* Checks whether 'ofconn' is a slave controller.  If so, returns an OpenFlow
1709  * error message code (composed with ofp_mkerr()) for the caller to propagate
1710  * upward.  Otherwise, returns 0. */
1711 static int
1712 reject_slave_controller(const struct ofconn *ofconn)
1713 {
1714     if (ofconn_get_type(ofconn) == OFCONN_PRIMARY
1715         && ofconn_get_role(ofconn) == NX_ROLE_SLAVE) {
1716         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_EPERM);
1717     } else {
1718         return 0;
1719     }
1720 }
1721
1722 static int
1723 handle_packet_out(struct ofconn *ofconn, const struct ofp_header *oh)
1724 {
1725     struct ofproto *p = ofconn_get_ofproto(ofconn);
1726     struct ofp_packet_out *opo;
1727     struct ofpbuf payload, *buffer;
1728     union ofp_action *ofp_actions;
1729     struct ofpbuf request;
1730     struct flow flow;
1731     size_t n_ofp_actions;
1732     uint16_t in_port;
1733     int error;
1734
1735     COVERAGE_INC(ofproto_packet_out);
1736
1737     error = reject_slave_controller(ofconn);
1738     if (error) {
1739         return error;
1740     }
1741
1742     /* Get ofp_packet_out. */
1743     ofpbuf_use_const(&request, oh, ntohs(oh->length));
1744     opo = ofpbuf_pull(&request, offsetof(struct ofp_packet_out, actions));
1745
1746     /* Get actions. */
1747     error = ofputil_pull_actions(&request, ntohs(opo->actions_len),
1748                                  &ofp_actions, &n_ofp_actions);
1749     if (error) {
1750         return error;
1751     }
1752
1753     /* Get payload. */
1754     if (opo->buffer_id != htonl(UINT32_MAX)) {
1755         error = ofconn_pktbuf_retrieve(ofconn, ntohl(opo->buffer_id),
1756                                        &buffer, NULL);
1757         if (error || !buffer) {
1758             return error;
1759         }
1760         payload = *buffer;
1761     } else {
1762         payload = request;
1763         buffer = NULL;
1764     }
1765
1766     /* Get in_port and partially validate it.
1767      *
1768      * We don't know what range of ports the ofproto actually implements, but
1769      * we do know that only certain reserved ports (numbered OFPP_MAX and
1770      * above) are valid. */
1771     in_port = ntohs(opo->in_port);
1772     if (in_port >= OFPP_MAX && in_port != OFPP_LOCAL && in_port != OFPP_NONE) {
1773         return ofp_mkerr_nicira(OFPET_BAD_REQUEST, NXBRC_BAD_IN_PORT);
1774     }
1775
1776     /* Send out packet. */
1777     flow_extract(&payload, 0, 0, in_port, &flow);
1778     error = p->ofproto_class->packet_out(p, &payload, &flow,
1779                                          ofp_actions, n_ofp_actions);
1780     ofpbuf_delete(buffer);
1781
1782     return error;
1783 }
1784
1785 static void
1786 update_port_config(struct ofport *port, ovs_be32 config, ovs_be32 mask)
1787 {
1788     ovs_be32 old_config = port->opp.config;
1789
1790     mask &= config ^ port->opp.config;
1791     if (mask & htonl(OFPPC_PORT_DOWN)) {
1792         if (config & htonl(OFPPC_PORT_DOWN)) {
1793             netdev_turn_flags_off(port->netdev, NETDEV_UP, true);
1794         } else {
1795             netdev_turn_flags_on(port->netdev, NETDEV_UP, true);
1796         }
1797     }
1798
1799     port->opp.config ^= mask & (htonl(OFPPC_NO_RECV | OFPPC_NO_RECV_STP |
1800                                       OFPPC_NO_FLOOD | OFPPC_NO_FWD |
1801                                       OFPPC_NO_PACKET_IN));
1802     if (port->opp.config != old_config) {
1803         port->ofproto->ofproto_class->port_reconfigured(port, old_config);
1804     }
1805 }
1806
1807 static int
1808 handle_port_mod(struct ofconn *ofconn, const struct ofp_header *oh)
1809 {
1810     struct ofproto *p = ofconn_get_ofproto(ofconn);
1811     const struct ofp_port_mod *opm = (const struct ofp_port_mod *) oh;
1812     struct ofport *port;
1813     int error;
1814
1815     error = reject_slave_controller(ofconn);
1816     if (error) {
1817         return error;
1818     }
1819
1820     port = ofproto_get_port(p, ntohs(opm->port_no));
1821     if (!port) {
1822         return ofp_mkerr(OFPET_PORT_MOD_FAILED, OFPPMFC_BAD_PORT);
1823     } else if (memcmp(port->opp.hw_addr, opm->hw_addr, OFP_ETH_ALEN)) {
1824         return ofp_mkerr(OFPET_PORT_MOD_FAILED, OFPPMFC_BAD_HW_ADDR);
1825     } else {
1826         update_port_config(port, opm->config, opm->mask);
1827         if (opm->advertise) {
1828             netdev_set_advertisements(port->netdev, ntohl(opm->advertise));
1829         }
1830     }
1831     return 0;
1832 }
1833
1834 static int
1835 handle_desc_stats_request(struct ofconn *ofconn,
1836                           const struct ofp_stats_msg *request)
1837 {
1838     struct ofproto *p = ofconn_get_ofproto(ofconn);
1839     struct ofp_desc_stats *ods;
1840     struct ofpbuf *msg;
1841
1842     ods = ofputil_make_stats_reply(sizeof *ods, request, &msg);
1843     ovs_strlcpy(ods->mfr_desc, p->mfr_desc, sizeof ods->mfr_desc);
1844     ovs_strlcpy(ods->hw_desc, p->hw_desc, sizeof ods->hw_desc);
1845     ovs_strlcpy(ods->sw_desc, p->sw_desc, sizeof ods->sw_desc);
1846     ovs_strlcpy(ods->serial_num, p->serial_desc, sizeof ods->serial_num);
1847     ovs_strlcpy(ods->dp_desc, p->dp_desc, sizeof ods->dp_desc);
1848     ofconn_send_reply(ofconn, msg);
1849
1850     return 0;
1851 }
1852
1853 static int
1854 handle_table_stats_request(struct ofconn *ofconn,
1855                            const struct ofp_stats_msg *request)
1856 {
1857     struct ofproto *p = ofconn_get_ofproto(ofconn);
1858     struct ofp_table_stats *ots;
1859     struct ofpbuf *msg;
1860     size_t i;
1861
1862     ofputil_make_stats_reply(sizeof(struct ofp_stats_msg), request, &msg);
1863
1864     ots = ofpbuf_put_zeros(msg, sizeof *ots * p->n_tables);
1865     for (i = 0; i < p->n_tables; i++) {
1866         ots[i].table_id = i;
1867         sprintf(ots[i].name, "table%zu", i);
1868         ots[i].wildcards = htonl(OFPFW_ALL);
1869         ots[i].max_entries = htonl(1000000); /* An arbitrary big number. */
1870         ots[i].active_count = htonl(classifier_count(&p->tables[i]));
1871     }
1872
1873     p->ofproto_class->get_tables(p, ots);
1874
1875     ofconn_send_reply(ofconn, msg);
1876     return 0;
1877 }
1878
1879 static void
1880 append_port_stat(struct ofport *port, struct list *replies)
1881 {
1882     struct netdev_stats stats;
1883     struct ofp_port_stats *ops;
1884
1885     /* Intentionally ignore return value, since errors will set
1886      * 'stats' to all-1s, which is correct for OpenFlow, and
1887      * netdev_get_stats() will log errors. */
1888     netdev_get_stats(port->netdev, &stats);
1889
1890     ops = ofputil_append_stats_reply(sizeof *ops, replies);
1891     ops->port_no = port->opp.port_no;
1892     memset(ops->pad, 0, sizeof ops->pad);
1893     put_32aligned_be64(&ops->rx_packets, htonll(stats.rx_packets));
1894     put_32aligned_be64(&ops->tx_packets, htonll(stats.tx_packets));
1895     put_32aligned_be64(&ops->rx_bytes, htonll(stats.rx_bytes));
1896     put_32aligned_be64(&ops->tx_bytes, htonll(stats.tx_bytes));
1897     put_32aligned_be64(&ops->rx_dropped, htonll(stats.rx_dropped));
1898     put_32aligned_be64(&ops->tx_dropped, htonll(stats.tx_dropped));
1899     put_32aligned_be64(&ops->rx_errors, htonll(stats.rx_errors));
1900     put_32aligned_be64(&ops->tx_errors, htonll(stats.tx_errors));
1901     put_32aligned_be64(&ops->rx_frame_err, htonll(stats.rx_frame_errors));
1902     put_32aligned_be64(&ops->rx_over_err, htonll(stats.rx_over_errors));
1903     put_32aligned_be64(&ops->rx_crc_err, htonll(stats.rx_crc_errors));
1904     put_32aligned_be64(&ops->collisions, htonll(stats.collisions));
1905 }
1906
1907 static int
1908 handle_port_stats_request(struct ofconn *ofconn,
1909                           const struct ofp_port_stats_request *psr)
1910 {
1911     struct ofproto *p = ofconn_get_ofproto(ofconn);
1912     struct ofport *port;
1913     struct list replies;
1914
1915     ofputil_start_stats_reply(&psr->osm, &replies);
1916     if (psr->port_no != htons(OFPP_NONE)) {
1917         port = ofproto_get_port(p, ntohs(psr->port_no));
1918         if (port) {
1919             append_port_stat(port, &replies);
1920         }
1921     } else {
1922         HMAP_FOR_EACH (port, hmap_node, &p->ports) {
1923             append_port_stat(port, &replies);
1924         }
1925     }
1926
1927     ofconn_send_replies(ofconn, &replies);
1928     return 0;
1929 }
1930
1931 static void
1932 calc_flow_duration__(long long int start, uint32_t *sec, uint32_t *nsec)
1933 {
1934     long long int msecs = time_msec() - start;
1935     *sec = msecs / 1000;
1936     *nsec = (msecs % 1000) * (1000 * 1000);
1937 }
1938
1939 /* Checks whether 'table_id' is 0xff or a valid table ID in 'ofproto'.  Returns
1940  * 0 if 'table_id' is OK, otherwise an OpenFlow error code.  */
1941 static int
1942 check_table_id(const struct ofproto *ofproto, uint8_t table_id)
1943 {
1944     return (table_id == 0xff || table_id < ofproto->n_tables
1945             ? 0
1946             : ofp_mkerr_nicira(OFPET_BAD_REQUEST, NXBRC_BAD_TABLE_ID));
1947
1948 }
1949
1950 static struct classifier *
1951 first_matching_table(struct ofproto *ofproto, uint8_t table_id)
1952 {
1953     if (table_id == 0xff) {
1954         return &ofproto->tables[0];
1955     } else if (table_id < ofproto->n_tables) {
1956         return &ofproto->tables[table_id];
1957     } else {
1958         return NULL;
1959     }
1960 }
1961
1962 static struct classifier *
1963 next_matching_table(struct ofproto *ofproto,
1964                     struct classifier *cls, uint8_t table_id)
1965 {
1966     return (table_id == 0xff && cls != &ofproto->tables[ofproto->n_tables - 1]
1967             ? cls + 1
1968             : NULL);
1969 }
1970
1971 /* Assigns CLS to each classifier table, in turn, that matches TABLE_ID in
1972  * OFPROTO:
1973  *
1974  *   - If TABLE_ID is 0xff, this iterates over every classifier table in
1975  *     OFPROTO.
1976  *
1977  *   - If TABLE_ID is the number of a table in OFPROTO, then the loop iterates
1978  *     only once, for that table.
1979  *
1980  *   - Otherwise, TABLE_ID isn't valid for OFPROTO, so the loop won't be
1981  *     entered at all.  (Perhaps you should have validated TABLE_ID with
1982  *     check_table_id().)
1983  *
1984  * All parameters are evaluated multiple times.
1985  */
1986 #define FOR_EACH_MATCHING_TABLE(CLS, TABLE_ID, OFPROTO)         \
1987     for ((CLS) = first_matching_table(OFPROTO, TABLE_ID);       \
1988          (CLS) != NULL;                                         \
1989          (CLS) = next_matching_table(OFPROTO, CLS, TABLE_ID))
1990
1991 /* Searches 'ofproto' for rules in table 'table_id' (or in all tables, if
1992  * 'table_id' is 0xff) that match 'match' in the "loose" way required for
1993  * OpenFlow OFPFC_MODIFY and OFPFC_DELETE requests and puts them on list
1994  * 'rules'.
1995  *
1996  * If 'out_port' is anything other than OFPP_NONE, then only rules that output
1997  * to 'out_port' are included.
1998  *
1999  * Hidden rules are always omitted.
2000  *
2001  * Returns 0 on success, otherwise an OpenFlow error code. */
2002 static int
2003 collect_rules_loose(struct ofproto *ofproto, uint8_t table_id,
2004                     const struct cls_rule *match, uint16_t out_port,
2005                     struct list *rules)
2006 {
2007     struct classifier *cls;
2008     int error;
2009
2010     error = check_table_id(ofproto, table_id);
2011     if (error) {
2012         return error;
2013     }
2014
2015     list_init(rules);
2016     FOR_EACH_MATCHING_TABLE (cls, table_id, ofproto) {
2017         struct cls_cursor cursor;
2018         struct rule *rule;
2019
2020         cls_cursor_init(&cursor, cls, match);
2021         CLS_CURSOR_FOR_EACH (rule, cr, &cursor) {
2022             if (rule->pending) {
2023                 return OFPROTO_POSTPONE;
2024             }
2025             if (!rule_is_hidden(rule) && rule_has_out_port(rule, out_port)) {
2026                 list_push_back(rules, &rule->ofproto_node);
2027             }
2028         }
2029     }
2030     return 0;
2031 }
2032
2033 /* Searches 'ofproto' for rules in table 'table_id' (or in all tables, if
2034  * 'table_id' is 0xff) that match 'match' in the "strict" way required for
2035  * OpenFlow OFPFC_MODIFY_STRICT and OFPFC_DELETE_STRICT requests and puts them
2036  * on list 'rules'.
2037  *
2038  * If 'out_port' is anything other than OFPP_NONE, then only rules that output
2039  * to 'out_port' are included.
2040  *
2041  * Hidden rules are always omitted.
2042  *
2043  * Returns 0 on success, otherwise an OpenFlow error code. */
2044 static int
2045 collect_rules_strict(struct ofproto *ofproto, uint8_t table_id,
2046                      const struct cls_rule *match, uint16_t out_port,
2047                      struct list *rules)
2048 {
2049     struct classifier *cls;
2050     int error;
2051
2052     error = check_table_id(ofproto, table_id);
2053     if (error) {
2054         return error;
2055     }
2056
2057     list_init(rules);
2058     FOR_EACH_MATCHING_TABLE (cls, table_id, ofproto) {
2059         struct rule *rule;
2060
2061         rule = rule_from_cls_rule(classifier_find_rule_exactly(cls, match));
2062         if (rule) {
2063             if (rule->pending) {
2064                 return OFPROTO_POSTPONE;
2065             }
2066             if (!rule_is_hidden(rule) && rule_has_out_port(rule, out_port)) {
2067                 list_push_back(rules, &rule->ofproto_node);
2068             }
2069         }
2070     }
2071     return 0;
2072 }
2073
2074 static int
2075 handle_flow_stats_request(struct ofconn *ofconn,
2076                           const struct ofp_stats_msg *osm)
2077 {
2078     struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
2079     struct ofputil_flow_stats_request fsr;
2080     struct list replies;
2081     struct list rules;
2082     struct rule *rule;
2083     int error;
2084
2085     error = ofputil_decode_flow_stats_request(&fsr, &osm->header);
2086     if (error) {
2087         return error;
2088     }
2089
2090     error = collect_rules_loose(ofproto, fsr.table_id, &fsr.match,
2091                                 fsr.out_port, &rules);
2092     if (error) {
2093         return error;
2094     }
2095
2096     ofputil_start_stats_reply(osm, &replies);
2097     LIST_FOR_EACH (rule, ofproto_node, &rules) {
2098         struct ofputil_flow_stats fs;
2099
2100         fs.rule = rule->cr;
2101         fs.cookie = rule->flow_cookie;
2102         fs.table_id = rule->table_id;
2103         calc_flow_duration__(rule->created, &fs.duration_sec,
2104                              &fs.duration_nsec);
2105         fs.idle_timeout = rule->idle_timeout;
2106         fs.hard_timeout = rule->hard_timeout;
2107         ofproto->ofproto_class->rule_get_stats(rule, &fs.packet_count,
2108                                                &fs.byte_count);
2109         fs.actions = rule->actions;
2110         fs.n_actions = rule->n_actions;
2111         ofputil_append_flow_stats_reply(&fs, &replies);
2112     }
2113     ofconn_send_replies(ofconn, &replies);
2114
2115     return 0;
2116 }
2117
2118 static void
2119 flow_stats_ds(struct rule *rule, struct ds *results)
2120 {
2121     uint64_t packet_count, byte_count;
2122
2123     rule->ofproto->ofproto_class->rule_get_stats(rule,
2124                                                  &packet_count, &byte_count);
2125
2126     if (rule->table_id != 0) {
2127         ds_put_format(results, "table_id=%"PRIu8", ", rule->table_id);
2128     }
2129     ds_put_format(results, "duration=%llds, ",
2130                   (time_msec() - rule->created) / 1000);
2131     ds_put_format(results, "priority=%u, ", rule->cr.priority);
2132     ds_put_format(results, "n_packets=%"PRIu64", ", packet_count);
2133     ds_put_format(results, "n_bytes=%"PRIu64", ", byte_count);
2134     cls_rule_format(&rule->cr, results);
2135     ds_put_char(results, ',');
2136     if (rule->n_actions > 0) {
2137         ofp_print_actions(results, rule->actions, rule->n_actions);
2138     } else {
2139         ds_put_cstr(results, "drop");
2140     }
2141     ds_put_cstr(results, "\n");
2142 }
2143
2144 /* Adds a pretty-printed description of all flows to 'results', including
2145  * hidden flows (e.g., set up by in-band control). */
2146 void
2147 ofproto_get_all_flows(struct ofproto *p, struct ds *results)
2148 {
2149     struct classifier *cls;
2150
2151     OFPROTO_FOR_EACH_TABLE (cls, p) {
2152         struct cls_cursor cursor;
2153         struct rule *rule;
2154
2155         cls_cursor_init(&cursor, cls, NULL);
2156         CLS_CURSOR_FOR_EACH (rule, cr, &cursor) {
2157             flow_stats_ds(rule, results);
2158         }
2159     }
2160 }
2161
2162 /* Obtains the NetFlow engine type and engine ID for 'ofproto' into
2163  * '*engine_type' and '*engine_id', respectively. */
2164 void
2165 ofproto_get_netflow_ids(const struct ofproto *ofproto,
2166                         uint8_t *engine_type, uint8_t *engine_id)
2167 {
2168     ofproto->ofproto_class->get_netflow_ids(ofproto, engine_type, engine_id);
2169 }
2170
2171 /* Checks the fault status of CFM for 'ofp_port' within 'ofproto'.  Returns 1
2172  * if CFM is faulted (generally indiciating a connectivity problem), 0 if CFM
2173  * is not faulted, and -1 if CFM is not enabled on 'ofp_port'. */
2174 int
2175 ofproto_port_get_cfm_fault(const struct ofproto *ofproto, uint16_t ofp_port)
2176 {
2177     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
2178     return (ofport && ofproto->ofproto_class->get_cfm_fault
2179             ? ofproto->ofproto_class->get_cfm_fault(ofport)
2180             : -1);
2181 }
2182
2183 /* Gets the MPIDs of the remote maintenance points broadcasting to 'ofp_port'
2184  * within 'ofproto'.  Populates 'rmps' with an array of MPIDs owned by
2185  * 'ofproto', and 'n_rmps' with the number of MPIDs in 'rmps'.  Returns a
2186  * number less than 0 if CFM is not enabled on 'ofp_port'. */
2187 int
2188 ofproto_port_get_cfm_remote_mpids(const struct ofproto *ofproto,
2189                                   uint16_t ofp_port, const uint64_t **rmps,
2190                                   size_t *n_rmps)
2191 {
2192     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
2193
2194     *rmps = NULL;
2195     *n_rmps = 0;
2196     return (ofport && ofproto->ofproto_class->get_cfm_remote_mpids
2197             ? ofproto->ofproto_class->get_cfm_remote_mpids(ofport, rmps,
2198                                                            n_rmps)
2199             : -1);
2200 }
2201
2202 static int
2203 handle_aggregate_stats_request(struct ofconn *ofconn,
2204                                const struct ofp_stats_msg *osm)
2205 {
2206     struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
2207     struct ofputil_flow_stats_request request;
2208     struct ofputil_aggregate_stats stats;
2209     bool unknown_packets, unknown_bytes;
2210     struct ofpbuf *reply;
2211     struct list rules;
2212     struct rule *rule;
2213     int error;
2214
2215     error = ofputil_decode_flow_stats_request(&request, &osm->header);
2216     if (error) {
2217         return error;
2218     }
2219
2220     error = collect_rules_loose(ofproto, request.table_id, &request.match,
2221                                 request.out_port, &rules);
2222     if (error) {
2223         return error;
2224     }
2225
2226     memset(&stats, 0, sizeof stats);
2227     unknown_packets = unknown_bytes = false;
2228     LIST_FOR_EACH (rule, ofproto_node, &rules) {
2229         uint64_t packet_count;
2230         uint64_t byte_count;
2231
2232         ofproto->ofproto_class->rule_get_stats(rule, &packet_count,
2233                                                &byte_count);
2234
2235         if (packet_count == UINT64_MAX) {
2236             unknown_packets = true;
2237         } else {
2238             stats.packet_count += packet_count;
2239         }
2240
2241         if (byte_count == UINT64_MAX) {
2242             unknown_bytes = true;
2243         } else {
2244             stats.byte_count += byte_count;
2245         }
2246
2247         stats.flow_count++;
2248     }
2249     if (unknown_packets) {
2250         stats.packet_count = UINT64_MAX;
2251     }
2252     if (unknown_bytes) {
2253         stats.byte_count = UINT64_MAX;
2254     }
2255
2256     reply = ofputil_encode_aggregate_stats_reply(&stats, osm);
2257     ofconn_send_reply(ofconn, reply);
2258
2259     return 0;
2260 }
2261
2262 struct queue_stats_cbdata {
2263     struct ofport *ofport;
2264     struct list replies;
2265 };
2266
2267 static void
2268 put_queue_stats(struct queue_stats_cbdata *cbdata, uint32_t queue_id,
2269                 const struct netdev_queue_stats *stats)
2270 {
2271     struct ofp_queue_stats *reply;
2272
2273     reply = ofputil_append_stats_reply(sizeof *reply, &cbdata->replies);
2274     reply->port_no = cbdata->ofport->opp.port_no;
2275     memset(reply->pad, 0, sizeof reply->pad);
2276     reply->queue_id = htonl(queue_id);
2277     put_32aligned_be64(&reply->tx_bytes, htonll(stats->tx_bytes));
2278     put_32aligned_be64(&reply->tx_packets, htonll(stats->tx_packets));
2279     put_32aligned_be64(&reply->tx_errors, htonll(stats->tx_errors));
2280 }
2281
2282 static void
2283 handle_queue_stats_dump_cb(uint32_t queue_id,
2284                            struct netdev_queue_stats *stats,
2285                            void *cbdata_)
2286 {
2287     struct queue_stats_cbdata *cbdata = cbdata_;
2288
2289     put_queue_stats(cbdata, queue_id, stats);
2290 }
2291
2292 static void
2293 handle_queue_stats_for_port(struct ofport *port, uint32_t queue_id,
2294                             struct queue_stats_cbdata *cbdata)
2295 {
2296     cbdata->ofport = port;
2297     if (queue_id == OFPQ_ALL) {
2298         netdev_dump_queue_stats(port->netdev,
2299                                 handle_queue_stats_dump_cb, cbdata);
2300     } else {
2301         struct netdev_queue_stats stats;
2302
2303         if (!netdev_get_queue_stats(port->netdev, queue_id, &stats)) {
2304             put_queue_stats(cbdata, queue_id, &stats);
2305         }
2306     }
2307 }
2308
2309 static int
2310 handle_queue_stats_request(struct ofconn *ofconn,
2311                            const struct ofp_queue_stats_request *qsr)
2312 {
2313     struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
2314     struct queue_stats_cbdata cbdata;
2315     struct ofport *port;
2316     unsigned int port_no;
2317     uint32_t queue_id;
2318
2319     COVERAGE_INC(ofproto_queue_req);
2320
2321     ofputil_start_stats_reply(&qsr->osm, &cbdata.replies);
2322
2323     port_no = ntohs(qsr->port_no);
2324     queue_id = ntohl(qsr->queue_id);
2325     if (port_no == OFPP_ALL) {
2326         HMAP_FOR_EACH (port, hmap_node, &ofproto->ports) {
2327             handle_queue_stats_for_port(port, queue_id, &cbdata);
2328         }
2329     } else if (port_no < OFPP_MAX) {
2330         port = ofproto_get_port(ofproto, port_no);
2331         if (port) {
2332             handle_queue_stats_for_port(port, queue_id, &cbdata);
2333         }
2334     } else {
2335         ofpbuf_list_delete(&cbdata.replies);
2336         return ofp_mkerr(OFPET_QUEUE_OP_FAILED, OFPQOFC_BAD_PORT);
2337     }
2338     ofconn_send_replies(ofconn, &cbdata.replies);
2339
2340     return 0;
2341 }
2342
2343 static bool
2344 is_flow_deletion_pending(const struct ofproto *ofproto,
2345                          const struct cls_rule *cls_rule,
2346                          uint8_t table_id)
2347 {
2348     if (!hmap_is_empty(&ofproto->deletions)) {
2349         struct ofoperation *op;
2350
2351         HMAP_FOR_EACH_WITH_HASH (op, hmap_node,
2352                                  cls_rule_hash(cls_rule, table_id),
2353                                  &ofproto->deletions) {
2354             if (cls_rule_equal(cls_rule, &op->rule->cr)) {
2355                 return true;
2356             }
2357         }
2358     }
2359
2360     return false;
2361 }
2362
2363 /* Implements OFPFC_ADD and the cases for OFPFC_MODIFY and OFPFC_MODIFY_STRICT
2364  * in which no matching flow already exists in the flow table.
2365  *
2366  * Adds the flow specified by 'ofm', which is followed by 'n_actions'
2367  * ofp_actions, to the ofproto's flow table.  Returns 0 on success, an OpenFlow
2368  * error code as encoded by ofp_mkerr() on failure, or OFPROTO_POSTPONE if the
2369  * operation cannot be initiated now but may be retried later.
2370  *
2371  * 'ofconn' is used to retrieve the packet buffer specified in ofm->buffer_id,
2372  * if any. */
2373 static int
2374 add_flow(struct ofproto *ofproto, struct ofconn *ofconn,
2375          const struct ofputil_flow_mod *fm, const struct ofp_header *request)
2376 {
2377     struct classifier *table;
2378     struct ofopgroup *group;
2379     struct rule *victim;
2380     struct rule *rule;
2381     int error;
2382
2383     error = check_table_id(ofproto, fm->table_id);
2384     if (error) {
2385         return error;
2386     }
2387
2388     /* Pick table. */
2389     if (fm->table_id == 0xff) {
2390         uint8_t table_id;
2391         if (ofproto->ofproto_class->rule_choose_table) {
2392             error = ofproto->ofproto_class->rule_choose_table(ofproto, &fm->cr,
2393                                                               &table_id);
2394             if (error) {
2395                 return error;
2396             }
2397             assert(table_id < ofproto->n_tables);
2398             table = &ofproto->tables[table_id];
2399         } else {
2400             table = &ofproto->tables[0];
2401         }
2402     } else if (fm->table_id < ofproto->n_tables) {
2403         table = &ofproto->tables[fm->table_id];
2404     } else {
2405         return ofp_mkerr_nicira(OFPET_FLOW_MOD_FAILED, NXFMFC_BAD_TABLE_ID);
2406     }
2407
2408     /* Check for overlap, if requested. */
2409     if (fm->flags & OFPFF_CHECK_OVERLAP
2410         && classifier_rule_overlaps(table, &fm->cr)) {
2411         return ofp_mkerr(OFPET_FLOW_MOD_FAILED, OFPFMFC_OVERLAP);
2412     }
2413
2414     /* Serialize against pending deletion. */
2415     if (is_flow_deletion_pending(ofproto, &fm->cr, table - ofproto->tables)) {
2416         return OFPROTO_POSTPONE;
2417     }
2418
2419     /* Allocate new rule. */
2420     rule = ofproto->ofproto_class->rule_alloc();
2421     if (!rule) {
2422         VLOG_WARN_RL(&rl, "%s: failed to create rule (%s)",
2423                      ofproto->name, strerror(error));
2424         return ENOMEM;
2425     }
2426     rule->ofproto = ofproto;
2427     rule->cr = fm->cr;
2428     rule->pending = NULL;
2429     rule->flow_cookie = fm->cookie;
2430     rule->created = rule->modified = time_msec();
2431     rule->idle_timeout = fm->idle_timeout;
2432     rule->hard_timeout = fm->hard_timeout;
2433     rule->table_id = table - ofproto->tables;
2434     rule->send_flow_removed = (fm->flags & OFPFF_SEND_FLOW_REM) != 0;
2435     rule->actions = ofputil_actions_clone(fm->actions, fm->n_actions);
2436     rule->n_actions = fm->n_actions;
2437
2438     /* Insert new rule. */
2439     victim = rule_from_cls_rule(classifier_replace(table, &rule->cr));
2440     if (victim && victim->pending) {
2441         error = OFPROTO_POSTPONE;
2442     } else {
2443         group = ofopgroup_create(ofproto, ofconn, request, fm->buffer_id);
2444         ofoperation_create(group, rule, OFOPERATION_ADD);
2445         rule->pending->victim = victim;
2446
2447         error = ofproto->ofproto_class->rule_construct(rule);
2448         if (error) {
2449             ofoperation_destroy(rule->pending);
2450         }
2451         ofopgroup_submit(group);
2452     }
2453
2454     /* Back out if an error occurred. */
2455     if (error) {
2456         if (victim) {
2457             classifier_replace(table, &victim->cr);
2458         } else {
2459             classifier_remove(table, &rule->cr);
2460         }
2461         ofproto_rule_destroy__(rule);
2462     }
2463     return error;
2464 }
2465 \f
2466 /* OFPFC_MODIFY and OFPFC_MODIFY_STRICT. */
2467
2468 /* Modifies the rules listed in 'rules', changing their actions to match those
2469  * in 'fm'.
2470  *
2471  * 'ofconn' is used to retrieve the packet buffer specified in fm->buffer_id,
2472  * if any.
2473  *
2474  * Returns 0 on success, otherwise an OpenFlow error code. */
2475 static int
2476 modify_flows__(struct ofproto *ofproto, struct ofconn *ofconn,
2477                const struct ofputil_flow_mod *fm,
2478                const struct ofp_header *request, struct list *rules)
2479 {
2480     struct ofopgroup *group;
2481     struct rule *rule;
2482
2483     group = ofopgroup_create(ofproto, ofconn, request, fm->buffer_id);
2484     LIST_FOR_EACH (rule, ofproto_node, rules) {
2485         if (!ofputil_actions_equal(fm->actions, fm->n_actions,
2486                                    rule->actions, rule->n_actions)) {
2487             ofoperation_create(group, rule, OFOPERATION_MODIFY);
2488             rule->pending->actions = rule->actions;
2489             rule->pending->n_actions = rule->n_actions;
2490             rule->actions = ofputil_actions_clone(fm->actions, fm->n_actions);
2491             rule->n_actions = fm->n_actions;
2492             rule->ofproto->ofproto_class->rule_modify_actions(rule);
2493         } else {
2494             rule->modified = time_msec();
2495         }
2496         rule->flow_cookie = fm->cookie;
2497     }
2498     ofopgroup_submit(group);
2499
2500     return 0;
2501 }
2502
2503 /* Implements OFPFC_MODIFY.  Returns 0 on success or an OpenFlow error code as
2504  * encoded by ofp_mkerr() on failure.
2505  *
2506  * 'ofconn' is used to retrieve the packet buffer specified in fm->buffer_id,
2507  * if any. */
2508 static int
2509 modify_flows_loose(struct ofproto *ofproto, struct ofconn *ofconn,
2510                    const struct ofputil_flow_mod *fm,
2511                    const struct ofp_header *request)
2512 {
2513     struct list rules;
2514     int error;
2515
2516     error = collect_rules_loose(ofproto, fm->table_id, &fm->cr, OFPP_NONE,
2517                                 &rules);
2518     return (error ? error
2519             : list_is_empty(&rules) ? add_flow(ofproto, ofconn, fm, request)
2520             : modify_flows__(ofproto, ofconn, fm, request, &rules));
2521 }
2522
2523 /* Implements OFPFC_MODIFY_STRICT.  Returns 0 on success or an OpenFlow error
2524  * code as encoded by ofp_mkerr() on failure.
2525  *
2526  * 'ofconn' is used to retrieve the packet buffer specified in fm->buffer_id,
2527  * if any. */
2528 static int
2529 modify_flow_strict(struct ofproto *ofproto, struct ofconn *ofconn,
2530                    const struct ofputil_flow_mod *fm,
2531                    const struct ofp_header *request)
2532 {
2533     struct list rules;
2534     int error;
2535
2536     error = collect_rules_strict(ofproto, fm->table_id, &fm->cr, OFPP_NONE,
2537                                  &rules);
2538     return (error ? error
2539             : list_is_empty(&rules) ? add_flow(ofproto, ofconn, fm, request)
2540             : list_is_singleton(&rules) ? modify_flows__(ofproto, ofconn,
2541                                                          fm, request, &rules)
2542             : 0);
2543 }
2544 \f
2545 /* OFPFC_DELETE implementation. */
2546
2547 /* Deletes the rules listed in 'rules'.
2548  *
2549  * Returns 0 on success, otherwise an OpenFlow error code. */
2550 static int
2551 delete_flows__(struct ofproto *ofproto, struct ofconn *ofconn,
2552                const struct ofp_header *request, struct list *rules)
2553 {
2554     struct rule *rule, *next;
2555     struct ofopgroup *group;
2556
2557     group = ofopgroup_create(ofproto, ofconn, request, UINT32_MAX);
2558     LIST_FOR_EACH_SAFE (rule, next, ofproto_node, rules) {
2559         ofproto_rule_send_removed(rule, OFPRR_DELETE);
2560
2561         ofoperation_create(group, rule, OFOPERATION_DELETE);
2562         classifier_remove(&ofproto->tables[rule->table_id], &rule->cr);
2563         rule->ofproto->ofproto_class->rule_destruct(rule);
2564     }
2565     ofopgroup_submit(group);
2566
2567     return 0;
2568 }
2569
2570 /* Implements OFPFC_DELETE. */
2571 static int
2572 delete_flows_loose(struct ofproto *ofproto, struct ofconn *ofconn,
2573                    const struct ofputil_flow_mod *fm,
2574                    const struct ofp_header *request)
2575 {
2576     struct list rules;
2577     int error;
2578
2579     error = collect_rules_loose(ofproto, fm->table_id, &fm->cr, fm->out_port,
2580                                 &rules);
2581     return (error ? error
2582             : !list_is_empty(&rules) ? delete_flows__(ofproto, ofconn, request,
2583                                                       &rules)
2584             : 0);
2585 }
2586
2587 /* Implements OFPFC_DELETE_STRICT. */
2588 static int
2589 delete_flow_strict(struct ofproto *ofproto, struct ofconn *ofconn,
2590                    const struct ofputil_flow_mod *fm,
2591                    const struct ofp_header *request)
2592 {
2593     struct list rules;
2594     int error;
2595
2596     error = collect_rules_strict(ofproto, fm->table_id, &fm->cr, fm->out_port,
2597                                  &rules);
2598     return (error ? error
2599             : list_is_singleton(&rules) ? delete_flows__(ofproto, ofconn,
2600                                                          request, &rules)
2601             : 0);
2602 }
2603
2604 static void
2605 ofproto_rule_send_removed(struct rule *rule, uint8_t reason)
2606 {
2607     struct ofputil_flow_removed fr;
2608
2609     if (rule_is_hidden(rule) || !rule->send_flow_removed) {
2610         return;
2611     }
2612
2613     fr.rule = rule->cr;
2614     fr.cookie = rule->flow_cookie;
2615     fr.reason = reason;
2616     calc_flow_duration__(rule->created, &fr.duration_sec, &fr.duration_nsec);
2617     fr.idle_timeout = rule->idle_timeout;
2618     rule->ofproto->ofproto_class->rule_get_stats(rule, &fr.packet_count,
2619                                                  &fr.byte_count);
2620
2621     connmgr_send_flow_removed(rule->ofproto->connmgr, &fr);
2622 }
2623
2624 /* Sends an OpenFlow "flow removed" message with the given 'reason' (either
2625  * OFPRR_HARD_TIMEOUT or OFPRR_IDLE_TIMEOUT), and then removes 'rule' from its
2626  * ofproto.
2627  *
2628  * ofproto implementation ->run() functions should use this function to expire
2629  * OpenFlow flows. */
2630 void
2631 ofproto_rule_expire(struct rule *rule, uint8_t reason)
2632 {
2633     struct ofproto *ofproto = rule->ofproto;
2634     struct ofopgroup *group;
2635
2636     assert(reason == OFPRR_HARD_TIMEOUT || reason == OFPRR_IDLE_TIMEOUT);
2637
2638     ofproto_rule_send_removed(rule, reason);
2639
2640     group = ofopgroup_create_unattached(ofproto);
2641     ofoperation_create(group, rule, OFOPERATION_DELETE);
2642     classifier_remove(&ofproto->tables[rule->table_id], &rule->cr);
2643     rule->ofproto->ofproto_class->rule_destruct(rule);
2644     ofopgroup_submit(group);
2645 }
2646 \f
2647 static int
2648 handle_flow_mod(struct ofconn *ofconn, const struct ofp_header *oh)
2649 {
2650     struct ofputil_flow_mod fm;
2651     int error;
2652
2653     error = reject_slave_controller(ofconn);
2654     if (error) {
2655         return error;
2656     }
2657
2658     error = ofputil_decode_flow_mod(&fm, oh,
2659                                     ofconn_get_flow_mod_table_id(ofconn));
2660     if (error) {
2661         return error;
2662     }
2663
2664     /* We do not support the emergency flow cache.  It will hopefully get
2665      * dropped from OpenFlow in the near future. */
2666     if (fm.flags & OFPFF_EMERG) {
2667         /* There isn't a good fit for an error code, so just state that the
2668          * flow table is full. */
2669         return ofp_mkerr(OFPET_FLOW_MOD_FAILED, OFPFMFC_ALL_TABLES_FULL);
2670     }
2671
2672     return handle_flow_mod__(ofconn_get_ofproto(ofconn), ofconn, &fm, oh);
2673 }
2674
2675 static int
2676 handle_flow_mod__(struct ofproto *ofproto, struct ofconn *ofconn,
2677                   const struct ofputil_flow_mod *fm,
2678                   const struct ofp_header *oh)
2679 {
2680     if (ofproto->n_pending >= 50) {
2681         assert(!list_is_empty(&ofproto->pending));
2682         return OFPROTO_POSTPONE;
2683     }
2684
2685     switch (fm->command) {
2686     case OFPFC_ADD:
2687         return add_flow(ofproto, ofconn, fm, oh);
2688
2689     case OFPFC_MODIFY:
2690         return modify_flows_loose(ofproto, ofconn, fm, oh);
2691
2692     case OFPFC_MODIFY_STRICT:
2693         return modify_flow_strict(ofproto, ofconn, fm, oh);
2694
2695     case OFPFC_DELETE:
2696         return delete_flows_loose(ofproto, ofconn, fm, oh);
2697
2698     case OFPFC_DELETE_STRICT:
2699         return delete_flow_strict(ofproto, ofconn, fm, oh);
2700
2701     default:
2702         if (fm->command > 0xff) {
2703             VLOG_WARN_RL(&rl, "flow_mod has explicit table_id but "
2704                          "flow_mod_table_id extension is not enabled");
2705         }
2706         return ofp_mkerr(OFPET_FLOW_MOD_FAILED, OFPFMFC_BAD_COMMAND);
2707     }
2708 }
2709
2710 static int
2711 handle_role_request(struct ofconn *ofconn, const struct ofp_header *oh)
2712 {
2713     struct nx_role_request *nrr = (struct nx_role_request *) oh;
2714     struct nx_role_request *reply;
2715     struct ofpbuf *buf;
2716     uint32_t role;
2717
2718     if (ofconn_get_type(ofconn) != OFCONN_PRIMARY) {
2719         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_EPERM);
2720     }
2721
2722     role = ntohl(nrr->role);
2723     if (role != NX_ROLE_OTHER && role != NX_ROLE_MASTER
2724         && role != NX_ROLE_SLAVE) {
2725         return ofp_mkerr_nicira(OFPET_BAD_REQUEST, NXBRC_BAD_ROLE);
2726     }
2727
2728     if (ofconn_get_role(ofconn) != role
2729         && ofconn_has_pending_opgroups(ofconn)) {
2730         return OFPROTO_POSTPONE;
2731     }
2732
2733     ofconn_set_role(ofconn, role);
2734
2735     reply = make_nxmsg_xid(sizeof *reply, NXT_ROLE_REPLY, oh->xid, &buf);
2736     reply->role = htonl(role);
2737     ofconn_send_reply(ofconn, buf);
2738
2739     return 0;
2740 }
2741
2742 static int
2743 handle_nxt_flow_mod_table_id(struct ofconn *ofconn,
2744                              const struct ofp_header *oh)
2745 {
2746     const struct nxt_flow_mod_table_id *msg
2747         = (const struct nxt_flow_mod_table_id *) oh;
2748
2749     ofconn_set_flow_mod_table_id(ofconn, msg->set != 0);
2750     return 0;
2751 }
2752
2753 static int
2754 handle_nxt_set_flow_format(struct ofconn *ofconn, const struct ofp_header *oh)
2755 {
2756     const struct nxt_set_flow_format *msg
2757         = (const struct nxt_set_flow_format *) oh;
2758     uint32_t format;
2759
2760     format = ntohl(msg->format);
2761     if (format != NXFF_OPENFLOW10 && format != NXFF_NXM) {
2762         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_EPERM);
2763     }
2764
2765     if (format != ofconn_get_flow_format(ofconn)
2766         && ofconn_has_pending_opgroups(ofconn)) {
2767         /* Avoid sending async messages in surprising flow format. */
2768         return OFPROTO_POSTPONE;
2769     }
2770
2771     ofconn_set_flow_format(ofconn, format);
2772     return 0;
2773 }
2774
2775 static int
2776 handle_barrier_request(struct ofconn *ofconn, const struct ofp_header *oh)
2777 {
2778     struct ofp_header *ob;
2779     struct ofpbuf *buf;
2780
2781     if (ofconn_has_pending_opgroups(ofconn)) {
2782         return OFPROTO_POSTPONE;
2783     }
2784
2785     ob = make_openflow_xid(sizeof *ob, OFPT_BARRIER_REPLY, oh->xid, &buf);
2786     ofconn_send_reply(ofconn, buf);
2787     return 0;
2788 }
2789
2790 static int
2791 handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg)
2792 {
2793     const struct ofp_header *oh = msg->data;
2794     const struct ofputil_msg_type *type;
2795     int error;
2796
2797     error = ofputil_decode_msg_type(oh, &type);
2798     if (error) {
2799         return error;
2800     }
2801
2802     switch (ofputil_msg_type_code(type)) {
2803         /* OpenFlow requests. */
2804     case OFPUTIL_OFPT_ECHO_REQUEST:
2805         return handle_echo_request(ofconn, oh);
2806
2807     case OFPUTIL_OFPT_FEATURES_REQUEST:
2808         return handle_features_request(ofconn, oh);
2809
2810     case OFPUTIL_OFPT_GET_CONFIG_REQUEST:
2811         return handle_get_config_request(ofconn, oh);
2812
2813     case OFPUTIL_OFPT_SET_CONFIG:
2814         return handle_set_config(ofconn, msg->data);
2815
2816     case OFPUTIL_OFPT_PACKET_OUT:
2817         return handle_packet_out(ofconn, oh);
2818
2819     case OFPUTIL_OFPT_PORT_MOD:
2820         return handle_port_mod(ofconn, oh);
2821
2822     case OFPUTIL_OFPT_FLOW_MOD:
2823         return handle_flow_mod(ofconn, oh);
2824
2825     case OFPUTIL_OFPT_BARRIER_REQUEST:
2826         return handle_barrier_request(ofconn, oh);
2827
2828         /* OpenFlow replies. */
2829     case OFPUTIL_OFPT_ECHO_REPLY:
2830         return 0;
2831
2832         /* Nicira extension requests. */
2833     case OFPUTIL_NXT_ROLE_REQUEST:
2834         return handle_role_request(ofconn, oh);
2835
2836     case OFPUTIL_NXT_FLOW_MOD_TABLE_ID:
2837         return handle_nxt_flow_mod_table_id(ofconn, oh);
2838
2839     case OFPUTIL_NXT_SET_FLOW_FORMAT:
2840         return handle_nxt_set_flow_format(ofconn, oh);
2841
2842     case OFPUTIL_NXT_FLOW_MOD:
2843         return handle_flow_mod(ofconn, oh);
2844
2845         /* Statistics requests. */
2846     case OFPUTIL_OFPST_DESC_REQUEST:
2847         return handle_desc_stats_request(ofconn, msg->data);
2848
2849     case OFPUTIL_OFPST_FLOW_REQUEST:
2850     case OFPUTIL_NXST_FLOW_REQUEST:
2851         return handle_flow_stats_request(ofconn, msg->data);
2852
2853     case OFPUTIL_OFPST_AGGREGATE_REQUEST:
2854     case OFPUTIL_NXST_AGGREGATE_REQUEST:
2855         return handle_aggregate_stats_request(ofconn, msg->data);
2856
2857     case OFPUTIL_OFPST_TABLE_REQUEST:
2858         return handle_table_stats_request(ofconn, msg->data);
2859
2860     case OFPUTIL_OFPST_PORT_REQUEST:
2861         return handle_port_stats_request(ofconn, msg->data);
2862
2863     case OFPUTIL_OFPST_QUEUE_REQUEST:
2864         return handle_queue_stats_request(ofconn, msg->data);
2865
2866     case OFPUTIL_MSG_INVALID:
2867     case OFPUTIL_OFPT_HELLO:
2868     case OFPUTIL_OFPT_ERROR:
2869     case OFPUTIL_OFPT_FEATURES_REPLY:
2870     case OFPUTIL_OFPT_GET_CONFIG_REPLY:
2871     case OFPUTIL_OFPT_PACKET_IN:
2872     case OFPUTIL_OFPT_FLOW_REMOVED:
2873     case OFPUTIL_OFPT_PORT_STATUS:
2874     case OFPUTIL_OFPT_BARRIER_REPLY:
2875     case OFPUTIL_OFPT_QUEUE_GET_CONFIG_REQUEST:
2876     case OFPUTIL_OFPT_QUEUE_GET_CONFIG_REPLY:
2877     case OFPUTIL_OFPST_DESC_REPLY:
2878     case OFPUTIL_OFPST_FLOW_REPLY:
2879     case OFPUTIL_OFPST_QUEUE_REPLY:
2880     case OFPUTIL_OFPST_PORT_REPLY:
2881     case OFPUTIL_OFPST_TABLE_REPLY:
2882     case OFPUTIL_OFPST_AGGREGATE_REPLY:
2883     case OFPUTIL_NXT_ROLE_REPLY:
2884     case OFPUTIL_NXT_FLOW_REMOVED:
2885     case OFPUTIL_NXST_FLOW_REPLY:
2886     case OFPUTIL_NXST_AGGREGATE_REPLY:
2887     default:
2888         if (oh->type == OFPT_STATS_REQUEST || oh->type == OFPT_STATS_REPLY) {
2889             return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_STAT);
2890         } else {
2891             return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_TYPE);
2892         }
2893     }
2894 }
2895
2896 static bool
2897 handle_openflow(struct ofconn *ofconn, struct ofpbuf *ofp_msg)
2898 {
2899     int error = handle_openflow__(ofconn, ofp_msg);
2900     if (error && error != OFPROTO_POSTPONE) {
2901         ofconn_send_error(ofconn, ofp_msg->data, error);
2902     }
2903     COVERAGE_INC(ofproto_recv_openflow);
2904     return error != OFPROTO_POSTPONE;
2905 }
2906 \f
2907 /* Asynchronous operations. */
2908
2909 /* Creates and returns a new ofopgroup that is not associated with any
2910  * OpenFlow connection.
2911  *
2912  * The caller should add operations to the returned group with
2913  * ofoperation_create() and then submit it with ofopgroup_submit(). */
2914 static struct ofopgroup *
2915 ofopgroup_create_unattached(struct ofproto *ofproto)
2916 {
2917     struct ofopgroup *group = xzalloc(sizeof *group);
2918     group->ofproto = ofproto;
2919     list_init(&group->ofproto_node);
2920     list_init(&group->ops);
2921     list_init(&group->ofconn_node);
2922     return group;
2923 }
2924
2925 /* Creates and returns a new ofopgroup for 'ofproto'.
2926  *
2927  * If 'ofconn' is NULL, the new ofopgroup is not associated with any OpenFlow
2928  * connection.  The 'request' and 'buffer_id' arguments are ignored.
2929  *
2930  * If 'ofconn' is nonnull, then the new ofopgroup is associated with 'ofconn'.
2931  * If the ofopgroup eventually fails, then the error reply will include
2932  * 'request'.  If the ofopgroup eventually succeeds, then the packet with
2933  * buffer id 'buffer_id' on 'ofconn' will be sent by 'ofconn''s ofproto.
2934  *
2935  * The caller should add operations to the returned group with
2936  * ofoperation_create() and then submit it with ofopgroup_submit(). */
2937 static struct ofopgroup *
2938 ofopgroup_create(struct ofproto *ofproto, struct ofconn *ofconn,
2939                  const struct ofp_header *request, uint32_t buffer_id)
2940 {
2941     struct ofopgroup *group = ofopgroup_create_unattached(ofproto);
2942     if (ofconn) {
2943         size_t request_len = ntohs(request->length);
2944
2945         assert(ofconn_get_ofproto(ofconn) == ofproto);
2946
2947         ofconn_add_opgroup(ofconn, &group->ofconn_node);
2948         group->ofconn = ofconn;
2949         group->request = xmemdup(request, MIN(request_len, 64));
2950         group->buffer_id = buffer_id;
2951     }
2952     return group;
2953 }
2954
2955 /* Submits 'group' for processing.
2956  *
2957  * If 'group' contains no operations (e.g. none were ever added, or all of the
2958  * ones that were added completed synchronously), then it is destroyed
2959  * immediately.  Otherwise it is added to the ofproto's list of pending
2960  * groups. */
2961 static void
2962 ofopgroup_submit(struct ofopgroup *group)
2963 {
2964     if (list_is_empty(&group->ops)) {
2965         ofopgroup_destroy(group);
2966     } else {
2967         list_push_back(&group->ofproto->pending, &group->ofproto_node);
2968         group->ofproto->n_pending++;
2969     }
2970 }
2971
2972 static void
2973 ofopgroup_destroy(struct ofopgroup *group)
2974 {
2975     assert(list_is_empty(&group->ops));
2976     if (!list_is_empty(&group->ofproto_node)) {
2977         assert(group->ofproto->n_pending > 0);
2978         group->ofproto->n_pending--;
2979         list_remove(&group->ofproto_node);
2980     }
2981     if (!list_is_empty(&group->ofconn_node)) {
2982         list_remove(&group->ofconn_node);
2983         if (group->error) {
2984             ofconn_send_error(group->ofconn, group->request, group->error);
2985         }
2986         connmgr_retry(group->ofproto->connmgr);
2987     }
2988     free(group->request);
2989     free(group);
2990 }
2991
2992 /* Initiates a new operation on 'rule', of the specified 'type', within
2993  * 'group'.  Prior to calling, 'rule' must not have any pending operation. */
2994 static void
2995 ofoperation_create(struct ofopgroup *group, struct rule *rule,
2996                    enum ofoperation_type type)
2997 {
2998     struct ofoperation *op;
2999
3000     assert(!rule->pending);
3001
3002     op = rule->pending = xzalloc(sizeof *op);
3003     op->group = group;
3004     list_push_back(&group->ops, &op->group_node);
3005     op->rule = rule;
3006     op->type = type;
3007     op->status = -1;
3008     op->flow_cookie = rule->flow_cookie;
3009
3010     if (type == OFOPERATION_DELETE) {
3011         hmap_insert(&op->group->ofproto->deletions, &op->hmap_node,
3012                     cls_rule_hash(&rule->cr, rule->table_id));
3013     }
3014 }
3015
3016 static void
3017 ofoperation_destroy(struct ofoperation *op)
3018 {
3019     struct ofopgroup *group = op->group;
3020
3021     if (op->rule) {
3022         op->rule->pending = NULL;
3023     }
3024     if (op->type == OFOPERATION_DELETE) {
3025         hmap_remove(&group->ofproto->deletions, &op->hmap_node);
3026     }
3027     list_remove(&op->group_node);
3028     free(op->actions);
3029     free(op);
3030
3031     if (list_is_empty(&group->ops) && !list_is_empty(&group->ofproto_node)) {
3032         ofopgroup_destroy(group);
3033     }
3034 }
3035
3036 /* Indicates that 'op' completed with status 'error', which is either 0 to
3037  * indicate success or an OpenFlow error code (constructed with
3038  * e.g. ofp_mkerr()).
3039  *
3040  * If 'error' is 0, indicating success, the operation will be committed
3041  * permanently to the flow table.  There is one interesting subcase:
3042  *
3043  *   - If 'op' is an "add flow" operation that is replacing an existing rule in
3044  *     the flow table (the "victim" rule) by a new one, then the caller must
3045  *     have uninitialized any derived state in the victim rule, as in step 5 in
3046  *     the "Life Cycle" in ofproto/ofproto-provider.h.  ofoperation_complete()
3047  *     performs steps 6 and 7 for the victim rule, most notably by calling its
3048  *     ->rule_dealloc() function.
3049  *
3050  * If 'error' is nonzero, then generally the operation will be rolled back:
3051  *
3052  *   - If 'op' is an "add flow" operation, ofproto removes the new rule or
3053  *     restores the original rule.  The caller must have uninitialized any
3054  *     derived state in the new rule, as in step 5 of in the "Life Cycle" in
3055  *     ofproto/ofproto-provider.h.  ofoperation_complete() performs steps 6 and
3056  *     and 7 for the new rule, calling its ->rule_dealloc() function.
3057  *
3058  *   - If 'op' is a "modify flow" operation, ofproto restores the original
3059  *     actions.
3060  *
3061  *   - 'op' must not be a "delete flow" operation.  Removing a rule is not
3062  *     allowed to fail.  It must always succeed.
3063  *
3064  * Please see the large comment in ofproto/ofproto-provider.h titled
3065  * "Asynchronous Operation Support" for more information. */
3066 void
3067 ofoperation_complete(struct ofoperation *op, int error)
3068 {
3069     struct ofopgroup *group = op->group;
3070     struct rule *rule = op->rule;
3071     struct classifier *table = &rule->ofproto->tables[rule->table_id];
3072
3073     assert(rule->pending == op);
3074     assert(op->status < 0);
3075     assert(error >= 0);
3076
3077     if (!error
3078         && !group->error
3079         && op->type != OFOPERATION_DELETE
3080         && group->ofconn
3081         && group->buffer_id != UINT32_MAX
3082         && list_is_singleton(&op->group_node)) {
3083         struct ofpbuf *packet;
3084         uint16_t in_port;
3085
3086         error = ofconn_pktbuf_retrieve(group->ofconn, group->buffer_id,
3087                                        &packet, &in_port);
3088         if (packet) {
3089             assert(!error);
3090             error = rule_execute(rule, in_port, packet);
3091         }
3092     }
3093     if (!group->error) {
3094         group->error = error;
3095     }
3096
3097     switch (op->type) {
3098     case OFOPERATION_ADD:
3099         if (!error) {
3100             if (op->victim) {
3101                 ofproto_rule_destroy__(op->victim);
3102             }
3103         } else {
3104             if (op->victim) {
3105                 classifier_replace(table, &op->victim->cr);
3106                 op->victim = NULL;
3107             } else {
3108                 classifier_remove(table, &rule->cr);
3109             }
3110             ofproto_rule_destroy__(rule);
3111         }
3112         op->victim = NULL;
3113         break;
3114
3115     case OFOPERATION_DELETE:
3116         assert(!error);
3117         ofproto_rule_destroy__(rule);
3118         op->rule = NULL;
3119         break;
3120
3121     case OFOPERATION_MODIFY:
3122         if (!error) {
3123             rule->modified = time_msec();
3124         } else {
3125             free(rule->actions);
3126             rule->actions = op->actions;
3127             rule->n_actions = op->n_actions;
3128             op->actions = NULL;
3129         }
3130         break;
3131
3132     default:
3133         NOT_REACHED();
3134     }
3135     ofoperation_destroy(op);
3136 }
3137
3138 struct rule *
3139 ofoperation_get_victim(struct ofoperation *op)
3140 {
3141     assert(op->type == OFOPERATION_ADD);
3142     return op->victim;
3143 }
3144 \f
3145 static uint64_t
3146 pick_datapath_id(const struct ofproto *ofproto)
3147 {
3148     const struct ofport *port;
3149
3150     port = ofproto_get_port(ofproto, OFPP_LOCAL);
3151     if (port) {
3152         uint8_t ea[ETH_ADDR_LEN];
3153         int error;
3154
3155         error = netdev_get_etheraddr(port->netdev, ea);
3156         if (!error) {
3157             return eth_addr_to_uint64(ea);
3158         }
3159         VLOG_WARN("could not get MAC address for %s (%s)",
3160                   netdev_get_name(port->netdev), strerror(error));
3161     }
3162     return ofproto->fallback_dpid;
3163 }
3164
3165 static uint64_t
3166 pick_fallback_dpid(void)
3167 {
3168     uint8_t ea[ETH_ADDR_LEN];
3169     eth_addr_nicira_random(ea);
3170     return eth_addr_to_uint64(ea);
3171 }
3172 \f
3173 /* unixctl commands. */
3174
3175 struct ofproto *
3176 ofproto_lookup(const char *name)
3177 {
3178     struct ofproto *ofproto;
3179
3180     HMAP_FOR_EACH_WITH_HASH (ofproto, hmap_node, hash_string(name, 0),
3181                              &all_ofprotos) {
3182         if (!strcmp(ofproto->name, name)) {
3183             return ofproto;
3184         }
3185     }
3186     return NULL;
3187 }
3188
3189 static void
3190 ofproto_unixctl_list(struct unixctl_conn *conn, const char *arg OVS_UNUSED,
3191                      void *aux OVS_UNUSED)
3192 {
3193     struct ofproto *ofproto;
3194     struct ds results;
3195
3196     ds_init(&results);
3197     HMAP_FOR_EACH (ofproto, hmap_node, &all_ofprotos) {
3198         ds_put_format(&results, "%s\n", ofproto->name);
3199     }
3200     unixctl_command_reply(conn, 200, ds_cstr(&results));
3201     ds_destroy(&results);
3202 }
3203
3204 static void
3205 ofproto_unixctl_init(void)
3206 {
3207     static bool registered;
3208     if (registered) {
3209         return;
3210     }
3211     registered = true;
3212
3213     unixctl_command_register("ofproto/list", "", ofproto_unixctl_list, NULL);
3214 }