ce4da9d35d65924d5400415f7b115787d11026a5
[openvswitch] / ofproto / ofproto.c
1 /*
2  * Copyright (c) 2009, 2010, 2011, 2012 Nicira, Inc.
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 "bitmap.h"
25 #include "byte-order.h"
26 #include "classifier.h"
27 #include "connmgr.h"
28 #include "coverage.h"
29 #include "dynamic-string.h"
30 #include "hash.h"
31 #include "hmap.h"
32 #include "meta-flow.h"
33 #include "netdev.h"
34 #include "nx-match.h"
35 #include "ofp-errors.h"
36 #include "ofp-print.h"
37 #include "ofp-util.h"
38 #include "ofpbuf.h"
39 #include "ofproto-provider.h"
40 #include "openflow/nicira-ext.h"
41 #include "openflow/openflow.h"
42 #include "packets.h"
43 #include "pinsched.h"
44 #include "pktbuf.h"
45 #include "poll-loop.h"
46 #include "random.h"
47 #include "shash.h"
48 #include "simap.h"
49 #include "sset.h"
50 #include "timeval.h"
51 #include "unaligned.h"
52 #include "unixctl.h"
53 #include "vlog.h"
54
55 VLOG_DEFINE_THIS_MODULE(ofproto);
56
57 COVERAGE_DEFINE(ofproto_error);
58 COVERAGE_DEFINE(ofproto_flush);
59 COVERAGE_DEFINE(ofproto_no_packet_in);
60 COVERAGE_DEFINE(ofproto_packet_out);
61 COVERAGE_DEFINE(ofproto_queue_req);
62 COVERAGE_DEFINE(ofproto_recv_openflow);
63 COVERAGE_DEFINE(ofproto_reinit_ports);
64 COVERAGE_DEFINE(ofproto_uninstallable);
65 COVERAGE_DEFINE(ofproto_update_port);
66
67 enum ofproto_state {
68     S_OPENFLOW,                 /* Processing OpenFlow commands. */
69     S_EVICT,                    /* Evicting flows from over-limit tables. */
70     S_FLUSH,                    /* Deleting all flow table rules. */
71 };
72
73 enum ofoperation_type {
74     OFOPERATION_ADD,
75     OFOPERATION_DELETE,
76     OFOPERATION_MODIFY
77 };
78
79 /* A single OpenFlow request can execute any number of operations.  The
80  * ofopgroup maintain OpenFlow state common to all of the operations, e.g. the
81  * ofconn to which an error reply should be sent if necessary.
82  *
83  * ofproto initiates some operations internally.  These operations are still
84  * assigned to groups but will not have an associated ofconn. */
85 struct ofopgroup {
86     struct ofproto *ofproto;    /* Owning ofproto. */
87     struct list ofproto_node;   /* In ofproto's "pending" list. */
88     struct list ops;            /* List of "struct ofoperation"s. */
89
90     /* Data needed to send OpenFlow reply on failure or to send a buffered
91      * packet on success.
92      *
93      * If list_is_empty(ofconn_node) then this ofopgroup never had an
94      * associated ofconn or its ofconn's connection dropped after it initiated
95      * the operation.  In the latter case 'ofconn' is a wild pointer that
96      * refers to freed memory, so the 'ofconn' member must be used only if
97      * !list_is_empty(ofconn_node).
98      */
99     struct list ofconn_node;    /* In ofconn's list of pending opgroups. */
100     struct ofconn *ofconn;      /* ofconn for reply (but see note above). */
101     struct ofp_header *request; /* Original request (truncated at 64 bytes). */
102     uint32_t buffer_id;         /* Buffer id from original request. */
103     int error;                  /* 0 if no error yet, otherwise error code. */
104 };
105
106 static struct ofopgroup *ofopgroup_create_unattached(struct ofproto *);
107 static struct ofopgroup *ofopgroup_create(struct ofproto *, struct ofconn *,
108                                           const struct ofp_header *,
109                                           uint32_t buffer_id);
110 static void ofopgroup_submit(struct ofopgroup *);
111 static void ofopgroup_destroy(struct ofopgroup *);
112
113 /* A single flow table operation. */
114 struct ofoperation {
115     struct ofopgroup *group;    /* Owning group. */
116     struct list group_node;     /* In ofopgroup's "ops" list. */
117     struct hmap_node hmap_node; /* In ofproto's "deletions" hmap. */
118     struct rule *rule;          /* Rule being operated upon. */
119     enum ofoperation_type type; /* Type of operation. */
120     struct rule *victim;        /* OFOPERATION_ADDING: Replaced rule. */
121     union ofp_action *actions;  /* OFOPERATION_MODIFYING: Replaced actions. */
122     int n_actions;              /* OFOPERATION_MODIFYING: # of old actions. */
123     ovs_be64 flow_cookie;       /* Rule's old flow cookie. */
124 };
125
126 static void ofoperation_create(struct ofopgroup *, struct rule *,
127                                enum ofoperation_type);
128 static void ofoperation_destroy(struct ofoperation *);
129
130 /* oftable. */
131 static void oftable_init(struct oftable *);
132 static void oftable_destroy(struct oftable *);
133
134 static void oftable_set_name(struct oftable *, const char *name);
135
136 static void oftable_disable_eviction(struct oftable *);
137 static void oftable_enable_eviction(struct oftable *,
138                                     const struct mf_subfield *fields,
139                                     size_t n_fields);
140
141 static void oftable_remove_rule(struct rule *);
142 static struct rule *oftable_replace_rule(struct rule *);
143 static void oftable_substitute_rule(struct rule *old, struct rule *new);
144
145 /* A set of rules within a single OpenFlow table (oftable) that have the same
146  * values for the oftable's eviction_fields.  A rule to be evicted, when one is
147  * needed, is taken from the eviction group that contains the greatest number
148  * of rules.
149  *
150  * An oftable owns any number of eviction groups, each of which contains any
151  * number of rules.
152  *
153  * Membership in an eviction group is imprecise, based on the hash of the
154  * oftable's eviction_fields (in the eviction_group's id_node.hash member).
155  * That is, if two rules have different eviction_fields, but those
156  * eviction_fields hash to the same value, then they will belong to the same
157  * eviction_group anyway.
158  *
159  * (When eviction is not enabled on an oftable, we don't track any eviction
160  * groups, to save time and space.) */
161 struct eviction_group {
162     struct hmap_node id_node;   /* In oftable's "eviction_groups_by_id". */
163     struct heap_node size_node; /* In oftable's "eviction_groups_by_size". */
164     struct heap rules;          /* Contains "struct rule"s. */
165 };
166
167 static struct rule *choose_rule_to_evict(struct oftable *);
168 static void ofproto_evict(struct ofproto *);
169 static uint32_t rule_eviction_priority(struct rule *);
170
171 /* ofport. */
172 static void ofport_destroy__(struct ofport *);
173 static void ofport_destroy(struct ofport *);
174
175 static void update_port(struct ofproto *, const char *devname);
176 static int init_ports(struct ofproto *);
177 static void reinit_ports(struct ofproto *);
178
179 /* rule. */
180 static void ofproto_rule_destroy__(struct rule *);
181 static void ofproto_rule_send_removed(struct rule *, uint8_t reason);
182 static bool rule_is_modifiable(const struct rule *);
183 static bool rule_is_hidden(const struct rule *);
184
185 /* OpenFlow. */
186 static enum ofperr add_flow(struct ofproto *, struct ofconn *,
187                             const struct ofputil_flow_mod *,
188                             const struct ofp_header *);
189 static void delete_flow__(struct rule *, struct ofopgroup *);
190 static bool handle_openflow(struct ofconn *, struct ofpbuf *);
191 static enum ofperr handle_flow_mod__(struct ofproto *, struct ofconn *,
192                                      const struct ofputil_flow_mod *,
193                                      const struct ofp_header *);
194
195 /* ofproto. */
196 static uint64_t pick_datapath_id(const struct ofproto *);
197 static uint64_t pick_fallback_dpid(void);
198 static void ofproto_destroy__(struct ofproto *);
199 static void update_mtu(struct ofproto *, struct ofport *);
200
201 /* unixctl. */
202 static void ofproto_unixctl_init(void);
203
204 /* All registered ofproto classes, in probe order. */
205 static const struct ofproto_class **ofproto_classes;
206 static size_t n_ofproto_classes;
207 static size_t allocated_ofproto_classes;
208
209 /* Map from datapath name to struct ofproto, for use by unixctl commands. */
210 static struct hmap all_ofprotos = HMAP_INITIALIZER(&all_ofprotos);
211
212 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
213
214 static void
215 ofproto_initialize(void)
216 {
217     static bool inited;
218
219     if (!inited) {
220         inited = true;
221         ofproto_class_register(&ofproto_dpif_class);
222     }
223 }
224
225 /* 'type' should be a normalized datapath type, as returned by
226  * ofproto_normalize_type().  Returns the corresponding ofproto_class
227  * structure, or a null pointer if there is none registered for 'type'. */
228 static const struct ofproto_class *
229 ofproto_class_find__(const char *type)
230 {
231     size_t i;
232
233     ofproto_initialize();
234     for (i = 0; i < n_ofproto_classes; i++) {
235         const struct ofproto_class *class = ofproto_classes[i];
236         struct sset types;
237         bool found;
238
239         sset_init(&types);
240         class->enumerate_types(&types);
241         found = sset_contains(&types, type);
242         sset_destroy(&types);
243
244         if (found) {
245             return class;
246         }
247     }
248     VLOG_WARN("unknown datapath type %s", type);
249     return NULL;
250 }
251
252 /* Registers a new ofproto class.  After successful registration, new ofprotos
253  * of that type can be created using ofproto_create(). */
254 int
255 ofproto_class_register(const struct ofproto_class *new_class)
256 {
257     size_t i;
258
259     for (i = 0; i < n_ofproto_classes; i++) {
260         if (ofproto_classes[i] == new_class) {
261             return EEXIST;
262         }
263     }
264
265     if (n_ofproto_classes >= allocated_ofproto_classes) {
266         ofproto_classes = x2nrealloc(ofproto_classes,
267                                      &allocated_ofproto_classes,
268                                      sizeof *ofproto_classes);
269     }
270     ofproto_classes[n_ofproto_classes++] = new_class;
271     return 0;
272 }
273
274 /* Unregisters a datapath provider.  'type' must have been previously
275  * registered and not currently be in use by any ofprotos.  After
276  * unregistration new datapaths of that type cannot be opened using
277  * ofproto_create(). */
278 int
279 ofproto_class_unregister(const struct ofproto_class *class)
280 {
281     size_t i;
282
283     for (i = 0; i < n_ofproto_classes; i++) {
284         if (ofproto_classes[i] == class) {
285             for (i++; i < n_ofproto_classes; i++) {
286                 ofproto_classes[i - 1] = ofproto_classes[i];
287             }
288             n_ofproto_classes--;
289             return 0;
290         }
291     }
292     VLOG_WARN("attempted to unregister an ofproto class that is not "
293               "registered");
294     return EAFNOSUPPORT;
295 }
296
297 /* Clears 'types' and enumerates all registered ofproto types into it.  The
298  * caller must first initialize the sset. */
299 void
300 ofproto_enumerate_types(struct sset *types)
301 {
302     size_t i;
303
304     ofproto_initialize();
305     for (i = 0; i < n_ofproto_classes; i++) {
306         ofproto_classes[i]->enumerate_types(types);
307     }
308 }
309
310 /* Returns the fully spelled out name for the given ofproto 'type'.
311  *
312  * Normalized type string can be compared with strcmp().  Unnormalized type
313  * string might be the same even if they have different spellings. */
314 const char *
315 ofproto_normalize_type(const char *type)
316 {
317     return type && type[0] ? type : "system";
318 }
319
320 /* Clears 'names' and enumerates the names of all known created ofprotos with
321  * the given 'type'.  The caller must first initialize the sset.  Returns 0 if
322  * successful, otherwise a positive errno value.
323  *
324  * Some kinds of datapaths might not be practically enumerable.  This is not
325  * considered an error. */
326 int
327 ofproto_enumerate_names(const char *type, struct sset *names)
328 {
329     const struct ofproto_class *class = ofproto_class_find__(type);
330     return class ? class->enumerate_names(type, names) : EAFNOSUPPORT;
331  }
332
333 int
334 ofproto_create(const char *datapath_name, const char *datapath_type,
335                struct ofproto **ofprotop)
336 {
337     const struct ofproto_class *class;
338     struct ofproto *ofproto;
339     int error;
340
341     *ofprotop = NULL;
342
343     ofproto_initialize();
344     ofproto_unixctl_init();
345
346     datapath_type = ofproto_normalize_type(datapath_type);
347     class = ofproto_class_find__(datapath_type);
348     if (!class) {
349         VLOG_WARN("could not create datapath %s of unknown type %s",
350                   datapath_name, datapath_type);
351         return EAFNOSUPPORT;
352     }
353
354     ofproto = class->alloc();
355     if (!ofproto) {
356         VLOG_ERR("failed to allocate datapath %s of type %s",
357                  datapath_name, datapath_type);
358         return ENOMEM;
359     }
360
361     /* Initialize. */
362     memset(ofproto, 0, sizeof *ofproto);
363     ofproto->ofproto_class = class;
364     ofproto->name = xstrdup(datapath_name);
365     ofproto->type = xstrdup(datapath_type);
366     hmap_insert(&all_ofprotos, &ofproto->hmap_node,
367                 hash_string(ofproto->name, 0));
368     ofproto->datapath_id = 0;
369     ofproto_set_flow_eviction_threshold(ofproto,
370                                         OFPROTO_FLOW_EVICTON_THRESHOLD_DEFAULT);
371     ofproto->forward_bpdu = false;
372     ofproto->fallback_dpid = pick_fallback_dpid();
373     ofproto->mfr_desc = xstrdup(DEFAULT_MFR_DESC);
374     ofproto->hw_desc = xstrdup(DEFAULT_HW_DESC);
375     ofproto->sw_desc = xstrdup(DEFAULT_SW_DESC);
376     ofproto->serial_desc = xstrdup(DEFAULT_SERIAL_DESC);
377     ofproto->dp_desc = xstrdup(DEFAULT_DP_DESC);
378     ofproto->frag_handling = OFPC_FRAG_NORMAL;
379     hmap_init(&ofproto->ports);
380     shash_init(&ofproto->port_by_name);
381     ofproto->tables = NULL;
382     ofproto->n_tables = 0;
383     ofproto->connmgr = connmgr_create(ofproto, datapath_name, datapath_name);
384     ofproto->state = S_OPENFLOW;
385     list_init(&ofproto->pending);
386     ofproto->n_pending = 0;
387     hmap_init(&ofproto->deletions);
388     ofproto->n_add = ofproto->n_delete = ofproto->n_modify = 0;
389     ofproto->first_op = ofproto->last_op = LLONG_MIN;
390     ofproto->next_op_report = LLONG_MAX;
391     ofproto->op_backoff = LLONG_MIN;
392     ofproto->vlan_bitmap = NULL;
393     ofproto->vlans_changed = false;
394     ofproto->min_mtu = INT_MAX;
395
396     error = ofproto->ofproto_class->construct(ofproto);
397     if (error) {
398         VLOG_ERR("failed to open datapath %s: %s",
399                  datapath_name, strerror(error));
400         ofproto_destroy__(ofproto);
401         return error;
402     }
403
404     assert(ofproto->n_tables);
405
406     ofproto->datapath_id = pick_datapath_id(ofproto);
407     VLOG_INFO("using datapath ID %016"PRIx64, ofproto->datapath_id);
408     init_ports(ofproto);
409
410     *ofprotop = ofproto;
411     return 0;
412 }
413
414 void
415 ofproto_init_tables(struct ofproto *ofproto, int n_tables)
416 {
417     struct oftable *table;
418
419     assert(!ofproto->n_tables);
420     assert(n_tables >= 1 && n_tables <= 255);
421
422     ofproto->n_tables = n_tables;
423     ofproto->tables = xmalloc(n_tables * sizeof *ofproto->tables);
424     OFPROTO_FOR_EACH_TABLE (table, ofproto) {
425         oftable_init(table);
426     }
427 }
428
429 void
430 ofproto_set_datapath_id(struct ofproto *p, uint64_t datapath_id)
431 {
432     uint64_t old_dpid = p->datapath_id;
433     p->datapath_id = datapath_id ? datapath_id : pick_datapath_id(p);
434     if (p->datapath_id != old_dpid) {
435         VLOG_INFO("datapath ID changed to %016"PRIx64, p->datapath_id);
436
437         /* Force all active connections to reconnect, since there is no way to
438          * notify a controller that the datapath ID has changed. */
439         ofproto_reconnect_controllers(p);
440     }
441 }
442
443 void
444 ofproto_set_controllers(struct ofproto *p,
445                         const struct ofproto_controller *controllers,
446                         size_t n_controllers)
447 {
448     connmgr_set_controllers(p->connmgr, controllers, n_controllers);
449 }
450
451 void
452 ofproto_set_fail_mode(struct ofproto *p, enum ofproto_fail_mode fail_mode)
453 {
454     connmgr_set_fail_mode(p->connmgr, fail_mode);
455 }
456
457 /* Drops the connections between 'ofproto' and all of its controllers, forcing
458  * them to reconnect. */
459 void
460 ofproto_reconnect_controllers(struct ofproto *ofproto)
461 {
462     connmgr_reconnect(ofproto->connmgr);
463 }
464
465 /* Sets the 'n' TCP port addresses in 'extras' as ones to which 'ofproto''s
466  * in-band control should guarantee access, in the same way that in-band
467  * control guarantees access to OpenFlow controllers. */
468 void
469 ofproto_set_extra_in_band_remotes(struct ofproto *ofproto,
470                                   const struct sockaddr_in *extras, size_t n)
471 {
472     connmgr_set_extra_in_band_remotes(ofproto->connmgr, extras, n);
473 }
474
475 /* Sets the OpenFlow queue used by flows set up by in-band control on
476  * 'ofproto' to 'queue_id'.  If 'queue_id' is negative, then in-band control
477  * flows will use the default queue. */
478 void
479 ofproto_set_in_band_queue(struct ofproto *ofproto, int queue_id)
480 {
481     connmgr_set_in_band_queue(ofproto->connmgr, queue_id);
482 }
483
484 /* Sets the number of flows at which eviction from the kernel flow table
485  * will occur. */
486 void
487 ofproto_set_flow_eviction_threshold(struct ofproto *ofproto, unsigned threshold)
488 {
489     if (threshold < OFPROTO_FLOW_EVICTION_THRESHOLD_MIN) {
490         ofproto->flow_eviction_threshold = OFPROTO_FLOW_EVICTION_THRESHOLD_MIN;
491     } else {
492         ofproto->flow_eviction_threshold = threshold;
493     }
494 }
495
496 /* If forward_bpdu is true, the NORMAL action will forward frames with
497  * reserved (e.g. STP) destination Ethernet addresses. if forward_bpdu is false,
498  * the NORMAL action will drop these frames. */
499 void
500 ofproto_set_forward_bpdu(struct ofproto *ofproto, bool forward_bpdu)
501 {
502     bool old_val = ofproto->forward_bpdu;
503     ofproto->forward_bpdu = forward_bpdu;
504     if (old_val != ofproto->forward_bpdu) {
505         if (ofproto->ofproto_class->forward_bpdu_changed) {
506             ofproto->ofproto_class->forward_bpdu_changed(ofproto);
507         }
508     }
509 }
510
511 /* Sets the MAC aging timeout for the OFPP_NORMAL action on 'ofproto' to
512  * 'idle_time', in seconds. */
513 void
514 ofproto_set_mac_idle_time(struct ofproto *ofproto, unsigned idle_time)
515 {
516     if (ofproto->ofproto_class->set_mac_idle_time) {
517         ofproto->ofproto_class->set_mac_idle_time(ofproto, idle_time);
518     }
519 }
520
521 void
522 ofproto_set_desc(struct ofproto *p,
523                  const char *mfr_desc, const char *hw_desc,
524                  const char *sw_desc, const char *serial_desc,
525                  const char *dp_desc)
526 {
527     struct ofp_desc_stats *ods;
528
529     if (mfr_desc) {
530         if (strlen(mfr_desc) >= sizeof ods->mfr_desc) {
531             VLOG_WARN("truncating mfr_desc, must be less than %zu characters",
532                     sizeof ods->mfr_desc);
533         }
534         free(p->mfr_desc);
535         p->mfr_desc = xstrdup(mfr_desc);
536     }
537     if (hw_desc) {
538         if (strlen(hw_desc) >= sizeof ods->hw_desc) {
539             VLOG_WARN("truncating hw_desc, must be less than %zu characters",
540                     sizeof ods->hw_desc);
541         }
542         free(p->hw_desc);
543         p->hw_desc = xstrdup(hw_desc);
544     }
545     if (sw_desc) {
546         if (strlen(sw_desc) >= sizeof ods->sw_desc) {
547             VLOG_WARN("truncating sw_desc, must be less than %zu characters",
548                     sizeof ods->sw_desc);
549         }
550         free(p->sw_desc);
551         p->sw_desc = xstrdup(sw_desc);
552     }
553     if (serial_desc) {
554         if (strlen(serial_desc) >= sizeof ods->serial_num) {
555             VLOG_WARN("truncating serial_desc, must be less than %zu "
556                     "characters",
557                     sizeof ods->serial_num);
558         }
559         free(p->serial_desc);
560         p->serial_desc = xstrdup(serial_desc);
561     }
562     if (dp_desc) {
563         if (strlen(dp_desc) >= sizeof ods->dp_desc) {
564             VLOG_WARN("truncating dp_desc, must be less than %zu characters",
565                     sizeof ods->dp_desc);
566         }
567         free(p->dp_desc);
568         p->dp_desc = xstrdup(dp_desc);
569     }
570 }
571
572 int
573 ofproto_set_snoops(struct ofproto *ofproto, const struct sset *snoops)
574 {
575     return connmgr_set_snoops(ofproto->connmgr, snoops);
576 }
577
578 int
579 ofproto_set_netflow(struct ofproto *ofproto,
580                     const struct netflow_options *nf_options)
581 {
582     if (nf_options && sset_is_empty(&nf_options->collectors)) {
583         nf_options = NULL;
584     }
585
586     if (ofproto->ofproto_class->set_netflow) {
587         return ofproto->ofproto_class->set_netflow(ofproto, nf_options);
588     } else {
589         return nf_options ? EOPNOTSUPP : 0;
590     }
591 }
592
593 int
594 ofproto_set_sflow(struct ofproto *ofproto,
595                   const struct ofproto_sflow_options *oso)
596 {
597     if (oso && sset_is_empty(&oso->targets)) {
598         oso = NULL;
599     }
600
601     if (ofproto->ofproto_class->set_sflow) {
602         return ofproto->ofproto_class->set_sflow(ofproto, oso);
603     } else {
604         return oso ? EOPNOTSUPP : 0;
605     }
606 }
607 \f
608 /* Spanning Tree Protocol (STP) configuration. */
609
610 /* Configures STP on 'ofproto' using the settings defined in 's'.  If
611  * 's' is NULL, disables STP.
612  *
613  * Returns 0 if successful, otherwise a positive errno value. */
614 int
615 ofproto_set_stp(struct ofproto *ofproto,
616                 const struct ofproto_stp_settings *s)
617 {
618     return (ofproto->ofproto_class->set_stp
619             ? ofproto->ofproto_class->set_stp(ofproto, s)
620             : EOPNOTSUPP);
621 }
622
623 /* Retrieves STP status of 'ofproto' and stores it in 's'.  If the
624  * 'enabled' member of 's' is false, then the other members are not
625  * meaningful.
626  *
627  * Returns 0 if successful, otherwise a positive errno value. */
628 int
629 ofproto_get_stp_status(struct ofproto *ofproto,
630                        struct ofproto_stp_status *s)
631 {
632     return (ofproto->ofproto_class->get_stp_status
633             ? ofproto->ofproto_class->get_stp_status(ofproto, s)
634             : EOPNOTSUPP);
635 }
636
637 /* Configures STP on 'ofp_port' of 'ofproto' using the settings defined
638  * in 's'.  The caller is responsible for assigning STP port numbers
639  * (using the 'port_num' member in the range of 1 through 255, inclusive)
640  * and ensuring there are no duplicates.  If the 's' is NULL, then STP
641  * is disabled on the port.
642  *
643  * Returns 0 if successful, otherwise a positive errno value.*/
644 int
645 ofproto_port_set_stp(struct ofproto *ofproto, uint16_t ofp_port,
646                      const struct ofproto_port_stp_settings *s)
647 {
648     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
649     if (!ofport) {
650         VLOG_WARN("%s: cannot configure STP on nonexistent port %"PRIu16,
651                   ofproto->name, ofp_port);
652         return ENODEV;
653     }
654
655     return (ofproto->ofproto_class->set_stp_port
656             ? ofproto->ofproto_class->set_stp_port(ofport, s)
657             : EOPNOTSUPP);
658 }
659
660 /* Retrieves STP port status of 'ofp_port' on 'ofproto' and stores it in
661  * 's'.  If the 'enabled' member in 's' is false, then the other members
662  * are not meaningful.
663  *
664  * Returns 0 if successful, otherwise a positive errno value.*/
665 int
666 ofproto_port_get_stp_status(struct ofproto *ofproto, uint16_t ofp_port,
667                             struct ofproto_port_stp_status *s)
668 {
669     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
670     if (!ofport) {
671         VLOG_WARN_RL(&rl, "%s: cannot get STP status on nonexistent "
672                      "port %"PRIu16, ofproto->name, ofp_port);
673         return ENODEV;
674     }
675
676     return (ofproto->ofproto_class->get_stp_port_status
677             ? ofproto->ofproto_class->get_stp_port_status(ofport, s)
678             : EOPNOTSUPP);
679 }
680 \f
681 /* Queue DSCP configuration. */
682
683 /* Registers meta-data associated with the 'n_qdscp' Qualities of Service
684  * 'queues' attached to 'ofport'.  This data is not intended to be sufficient
685  * to implement QoS.  Instead, it is used to implement features which require
686  * knowledge of what queues exist on a port, and some basic information about
687  * them.
688  *
689  * Returns 0 if successful, otherwise a positive errno value. */
690 int
691 ofproto_port_set_queues(struct ofproto *ofproto, uint16_t ofp_port,
692                         const struct ofproto_port_queue *queues,
693                         size_t n_queues)
694 {
695     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
696
697     if (!ofport) {
698         VLOG_WARN("%s: cannot set queues on nonexistent port %"PRIu16,
699                   ofproto->name, ofp_port);
700         return ENODEV;
701     }
702
703     return (ofproto->ofproto_class->set_queues
704             ? ofproto->ofproto_class->set_queues(ofport, queues, n_queues)
705             : EOPNOTSUPP);
706 }
707 \f
708 /* Connectivity Fault Management configuration. */
709
710 /* Clears the CFM configuration from 'ofp_port' on 'ofproto'. */
711 void
712 ofproto_port_clear_cfm(struct ofproto *ofproto, uint16_t ofp_port)
713 {
714     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
715     if (ofport && ofproto->ofproto_class->set_cfm) {
716         ofproto->ofproto_class->set_cfm(ofport, NULL);
717     }
718 }
719
720 /* Configures connectivity fault management on 'ofp_port' in 'ofproto'.  Takes
721  * basic configuration from the configuration members in 'cfm', and the remote
722  * maintenance point ID from  remote_mpid.  Ignores the statistics members of
723  * 'cfm'.
724  *
725  * This function has no effect if 'ofproto' does not have a port 'ofp_port'. */
726 void
727 ofproto_port_set_cfm(struct ofproto *ofproto, uint16_t ofp_port,
728                      const struct cfm_settings *s)
729 {
730     struct ofport *ofport;
731     int error;
732
733     ofport = ofproto_get_port(ofproto, ofp_port);
734     if (!ofport) {
735         VLOG_WARN("%s: cannot configure CFM on nonexistent port %"PRIu16,
736                   ofproto->name, ofp_port);
737         return;
738     }
739
740     /* XXX: For configuration simplicity, we only support one remote_mpid
741      * outside of the CFM module.  It's not clear if this is the correct long
742      * term solution or not. */
743     error = (ofproto->ofproto_class->set_cfm
744              ? ofproto->ofproto_class->set_cfm(ofport, s)
745              : EOPNOTSUPP);
746     if (error) {
747         VLOG_WARN("%s: CFM configuration on port %"PRIu16" (%s) failed (%s)",
748                   ofproto->name, ofp_port, netdev_get_name(ofport->netdev),
749                   strerror(error));
750     }
751 }
752
753 /* Checks the status of LACP negotiation for 'ofp_port' within ofproto.
754  * Returns 1 if LACP partner information for 'ofp_port' is up-to-date,
755  * 0 if LACP partner information is not current (generally indicating a
756  * connectivity problem), or -1 if LACP is not enabled on 'ofp_port'. */
757 int
758 ofproto_port_is_lacp_current(struct ofproto *ofproto, uint16_t ofp_port)
759 {
760     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
761     return (ofport && ofproto->ofproto_class->port_is_lacp_current
762             ? ofproto->ofproto_class->port_is_lacp_current(ofport)
763             : -1);
764 }
765 \f
766 /* Bundles. */
767
768 /* Registers a "bundle" associated with client data pointer 'aux' in 'ofproto'.
769  * A bundle is the same concept as a Port in OVSDB, that is, it consists of one
770  * or more "slave" devices (Interfaces, in OVSDB) along with a VLAN
771  * configuration plus, if there is more than one slave, a bonding
772  * configuration.
773  *
774  * If 'aux' is already registered then this function updates its configuration
775  * to 's'.  Otherwise, this function registers a new bundle.
776  *
777  * Bundles only affect the NXAST_AUTOPATH action and output to the OFPP_NORMAL
778  * port. */
779 int
780 ofproto_bundle_register(struct ofproto *ofproto, void *aux,
781                         const struct ofproto_bundle_settings *s)
782 {
783     return (ofproto->ofproto_class->bundle_set
784             ? ofproto->ofproto_class->bundle_set(ofproto, aux, s)
785             : EOPNOTSUPP);
786 }
787
788 /* Unregisters the bundle registered on 'ofproto' with auxiliary data 'aux'.
789  * If no such bundle has been registered, this has no effect. */
790 int
791 ofproto_bundle_unregister(struct ofproto *ofproto, void *aux)
792 {
793     return ofproto_bundle_register(ofproto, aux, NULL);
794 }
795
796 \f
797 /* Registers a mirror associated with client data pointer 'aux' in 'ofproto'.
798  * If 'aux' is already registered then this function updates its configuration
799  * to 's'.  Otherwise, this function registers a new mirror. */
800 int
801 ofproto_mirror_register(struct ofproto *ofproto, void *aux,
802                         const struct ofproto_mirror_settings *s)
803 {
804     return (ofproto->ofproto_class->mirror_set
805             ? ofproto->ofproto_class->mirror_set(ofproto, aux, s)
806             : EOPNOTSUPP);
807 }
808
809 /* Unregisters the mirror registered on 'ofproto' with auxiliary data 'aux'.
810  * If no mirror has been registered, this has no effect. */
811 int
812 ofproto_mirror_unregister(struct ofproto *ofproto, void *aux)
813 {
814     return ofproto_mirror_register(ofproto, aux, NULL);
815 }
816
817 /* Retrieves statistics from mirror associated with client data pointer
818  * 'aux' in 'ofproto'.  Stores packet and byte counts in 'packets' and
819  * 'bytes', respectively.  If a particular counters is not supported,
820  * the appropriate argument is set to UINT64_MAX. */
821 int
822 ofproto_mirror_get_stats(struct ofproto *ofproto, void *aux,
823                          uint64_t *packets, uint64_t *bytes)
824 {
825     if (!ofproto->ofproto_class->mirror_get_stats) {
826         *packets = *bytes = UINT64_MAX;
827         return EOPNOTSUPP;
828     }
829
830     return ofproto->ofproto_class->mirror_get_stats(ofproto, aux,
831                                                     packets, bytes);
832 }
833
834 /* Configures the VLANs whose bits are set to 1 in 'flood_vlans' as VLANs on
835  * which all packets are flooded, instead of using MAC learning.  If
836  * 'flood_vlans' is NULL, then MAC learning applies to all VLANs.
837  *
838  * Flood VLANs affect only the treatment of packets output to the OFPP_NORMAL
839  * port. */
840 int
841 ofproto_set_flood_vlans(struct ofproto *ofproto, unsigned long *flood_vlans)
842 {
843     return (ofproto->ofproto_class->set_flood_vlans
844             ? ofproto->ofproto_class->set_flood_vlans(ofproto, flood_vlans)
845             : EOPNOTSUPP);
846 }
847
848 /* Returns true if 'aux' is a registered bundle that is currently in use as the
849  * output for a mirror. */
850 bool
851 ofproto_is_mirror_output_bundle(const struct ofproto *ofproto, void *aux)
852 {
853     return (ofproto->ofproto_class->is_mirror_output_bundle
854             ? ofproto->ofproto_class->is_mirror_output_bundle(ofproto, aux)
855             : false);
856 }
857 \f
858 /* Configuration of OpenFlow tables. */
859
860 /* Returns the number of OpenFlow tables in 'ofproto'. */
861 int
862 ofproto_get_n_tables(const struct ofproto *ofproto)
863 {
864     return ofproto->n_tables;
865 }
866
867 /* Configures the OpenFlow table in 'ofproto' with id 'table_id' with the
868  * settings from 's'.  'table_id' must be in the range 0 through the number of
869  * OpenFlow tables in 'ofproto' minus 1, inclusive.
870  *
871  * For read-only tables, only the name may be configured. */
872 void
873 ofproto_configure_table(struct ofproto *ofproto, int table_id,
874                         const struct ofproto_table_settings *s)
875 {
876     struct oftable *table;
877
878     assert(table_id >= 0 && table_id < ofproto->n_tables);
879     table = &ofproto->tables[table_id];
880
881     oftable_set_name(table, s->name);
882
883     if (table->flags & OFTABLE_READONLY) {
884         return;
885     }
886
887     if (s->groups) {
888         oftable_enable_eviction(table, s->groups, s->n_groups);
889     } else {
890         oftable_disable_eviction(table);
891     }
892
893     table->max_flows = s->max_flows;
894     if (classifier_count(&table->cls) > table->max_flows
895         && table->eviction_fields) {
896         /* 'table' contains more flows than allowed.  We might not be able to
897          * evict them right away because of the asynchronous nature of flow
898          * table changes.  Schedule eviction for later. */
899         switch (ofproto->state) {
900         case S_OPENFLOW:
901             ofproto->state = S_EVICT;
902             break;
903         case S_EVICT:
904         case S_FLUSH:
905             /* We're already deleting flows, nothing more to do. */
906             break;
907         }
908     }
909 }
910 \f
911 bool
912 ofproto_has_snoops(const struct ofproto *ofproto)
913 {
914     return connmgr_has_snoops(ofproto->connmgr);
915 }
916
917 void
918 ofproto_get_snoops(const struct ofproto *ofproto, struct sset *snoops)
919 {
920     connmgr_get_snoops(ofproto->connmgr, snoops);
921 }
922
923 static void
924 ofproto_flush__(struct ofproto *ofproto)
925 {
926     struct ofopgroup *group;
927     struct oftable *table;
928
929     if (ofproto->ofproto_class->flush) {
930         ofproto->ofproto_class->flush(ofproto);
931     }
932
933     group = ofopgroup_create_unattached(ofproto);
934     OFPROTO_FOR_EACH_TABLE (table, ofproto) {
935         struct rule *rule, *next_rule;
936         struct cls_cursor cursor;
937
938         if (table->flags & OFTABLE_HIDDEN) {
939             continue;
940         }
941
942         cls_cursor_init(&cursor, &table->cls, NULL);
943         CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, cr, &cursor) {
944             if (!rule->pending) {
945                 ofoperation_create(group, rule, OFOPERATION_DELETE);
946                 oftable_remove_rule(rule);
947                 ofproto->ofproto_class->rule_destruct(rule);
948             }
949         }
950     }
951     ofopgroup_submit(group);
952 }
953
954 static void
955 ofproto_destroy__(struct ofproto *ofproto)
956 {
957     struct oftable *table;
958
959     assert(list_is_empty(&ofproto->pending));
960     assert(!ofproto->n_pending);
961
962     connmgr_destroy(ofproto->connmgr);
963
964     hmap_remove(&all_ofprotos, &ofproto->hmap_node);
965     free(ofproto->name);
966     free(ofproto->type);
967     free(ofproto->mfr_desc);
968     free(ofproto->hw_desc);
969     free(ofproto->sw_desc);
970     free(ofproto->serial_desc);
971     free(ofproto->dp_desc);
972     hmap_destroy(&ofproto->ports);
973     shash_destroy(&ofproto->port_by_name);
974
975     OFPROTO_FOR_EACH_TABLE (table, ofproto) {
976         oftable_destroy(table);
977     }
978     free(ofproto->tables);
979
980     hmap_destroy(&ofproto->deletions);
981
982     free(ofproto->vlan_bitmap);
983
984     ofproto->ofproto_class->dealloc(ofproto);
985 }
986
987 void
988 ofproto_destroy(struct ofproto *p)
989 {
990     struct ofport *ofport, *next_ofport;
991
992     if (!p) {
993         return;
994     }
995
996     ofproto_flush__(p);
997     HMAP_FOR_EACH_SAFE (ofport, next_ofport, hmap_node, &p->ports) {
998         ofport_destroy(ofport);
999     }
1000
1001     p->ofproto_class->destruct(p);
1002     ofproto_destroy__(p);
1003 }
1004
1005 /* Destroys the datapath with the respective 'name' and 'type'.  With the Linux
1006  * kernel datapath, for example, this destroys the datapath in the kernel, and
1007  * with the netdev-based datapath, it tears down the data structures that
1008  * represent the datapath.
1009  *
1010  * The datapath should not be currently open as an ofproto. */
1011 int
1012 ofproto_delete(const char *name, const char *type)
1013 {
1014     const struct ofproto_class *class = ofproto_class_find__(type);
1015     return (!class ? EAFNOSUPPORT
1016             : !class->del ? EACCES
1017             : class->del(type, name));
1018 }
1019
1020 static void
1021 process_port_change(struct ofproto *ofproto, int error, char *devname)
1022 {
1023     if (error == ENOBUFS) {
1024         reinit_ports(ofproto);
1025     } else if (!error) {
1026         update_port(ofproto, devname);
1027         free(devname);
1028     }
1029 }
1030
1031 int
1032 ofproto_run(struct ofproto *p)
1033 {
1034     struct sset changed_netdevs;
1035     const char *changed_netdev;
1036     struct ofport *ofport;
1037     int error;
1038
1039     error = p->ofproto_class->run(p);
1040     if (error && error != EAGAIN) {
1041         VLOG_ERR_RL(&rl, "%s: run failed (%s)", p->name, strerror(error));
1042     }
1043
1044     if (p->ofproto_class->port_poll) {
1045         char *devname;
1046
1047         while ((error = p->ofproto_class->port_poll(p, &devname)) != EAGAIN) {
1048             process_port_change(p, error, devname);
1049         }
1050     }
1051
1052     /* Update OpenFlow port status for any port whose netdev has changed.
1053      *
1054      * Refreshing a given 'ofport' can cause an arbitrary ofport to be
1055      * destroyed, so it's not safe to update ports directly from the
1056      * HMAP_FOR_EACH loop, or even to use HMAP_FOR_EACH_SAFE.  Instead, we
1057      * need this two-phase approach. */
1058     sset_init(&changed_netdevs);
1059     HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
1060         unsigned int change_seq = netdev_change_seq(ofport->netdev);
1061         if (ofport->change_seq != change_seq) {
1062             ofport->change_seq = change_seq;
1063             sset_add(&changed_netdevs, netdev_get_name(ofport->netdev));
1064         }
1065     }
1066     SSET_FOR_EACH (changed_netdev, &changed_netdevs) {
1067         update_port(p, changed_netdev);
1068     }
1069     sset_destroy(&changed_netdevs);
1070
1071     switch (p->state) {
1072     case S_OPENFLOW:
1073         connmgr_run(p->connmgr, handle_openflow);
1074         break;
1075
1076     case S_EVICT:
1077         connmgr_run(p->connmgr, NULL);
1078         ofproto_evict(p);
1079         if (list_is_empty(&p->pending) && hmap_is_empty(&p->deletions)) {
1080             p->state = S_OPENFLOW;
1081         }
1082         break;
1083
1084     case S_FLUSH:
1085         connmgr_run(p->connmgr, NULL);
1086         ofproto_flush__(p);
1087         if (list_is_empty(&p->pending) && hmap_is_empty(&p->deletions)) {
1088             connmgr_flushed(p->connmgr);
1089             p->state = S_OPENFLOW;
1090         }
1091         break;
1092
1093     default:
1094         NOT_REACHED();
1095     }
1096
1097     if (time_msec() >= p->next_op_report) {
1098         long long int ago = (time_msec() - p->first_op) / 1000;
1099         long long int interval = (p->last_op - p->first_op) / 1000;
1100         struct ds s;
1101
1102         ds_init(&s);
1103         ds_put_format(&s, "%d flow_mods ",
1104                       p->n_add + p->n_delete + p->n_modify);
1105         if (interval == ago) {
1106             ds_put_format(&s, "in the last %lld s", ago);
1107         } else if (interval) {
1108             ds_put_format(&s, "in the %lld s starting %lld s ago",
1109                           interval, ago);
1110         } else {
1111             ds_put_format(&s, "%lld s ago", ago);
1112         }
1113
1114         ds_put_cstr(&s, " (");
1115         if (p->n_add) {
1116             ds_put_format(&s, "%d adds, ", p->n_add);
1117         }
1118         if (p->n_delete) {
1119             ds_put_format(&s, "%d deletes, ", p->n_delete);
1120         }
1121         if (p->n_modify) {
1122             ds_put_format(&s, "%d modifications, ", p->n_modify);
1123         }
1124         s.length -= 2;
1125         ds_put_char(&s, ')');
1126
1127         VLOG_INFO("%s", ds_cstr(&s));
1128         ds_destroy(&s);
1129
1130         p->n_add = p->n_delete = p->n_modify = 0;
1131         p->next_op_report = LLONG_MAX;
1132     }
1133
1134     return error;
1135 }
1136
1137 /* Performs periodic activity required by 'ofproto' that needs to be done
1138  * with the least possible latency.
1139  *
1140  * It makes sense to call this function a couple of times per poll loop, to
1141  * provide a significant performance boost on some benchmarks with the
1142  * ofproto-dpif implementation. */
1143 int
1144 ofproto_run_fast(struct ofproto *p)
1145 {
1146     int error;
1147
1148     error = p->ofproto_class->run_fast ? p->ofproto_class->run_fast(p) : 0;
1149     if (error && error != EAGAIN) {
1150         VLOG_ERR_RL(&rl, "%s: fastpath run failed (%s)",
1151                     p->name, strerror(error));
1152     }
1153     return error;
1154 }
1155
1156 void
1157 ofproto_wait(struct ofproto *p)
1158 {
1159     struct ofport *ofport;
1160
1161     p->ofproto_class->wait(p);
1162     if (p->ofproto_class->port_poll_wait) {
1163         p->ofproto_class->port_poll_wait(p);
1164     }
1165
1166     HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
1167         if (ofport->change_seq != netdev_change_seq(ofport->netdev)) {
1168             poll_immediate_wake();
1169         }
1170     }
1171
1172     switch (p->state) {
1173     case S_OPENFLOW:
1174         connmgr_wait(p->connmgr, true);
1175         break;
1176
1177     case S_EVICT:
1178     case S_FLUSH:
1179         connmgr_wait(p->connmgr, false);
1180         if (list_is_empty(&p->pending) && hmap_is_empty(&p->deletions)) {
1181             poll_immediate_wake();
1182         }
1183         break;
1184     }
1185 }
1186
1187 bool
1188 ofproto_is_alive(const struct ofproto *p)
1189 {
1190     return connmgr_has_controllers(p->connmgr);
1191 }
1192
1193 /* Adds some memory usage statistics for 'ofproto' into 'usage', for use with
1194  * memory_report(). */
1195 void
1196 ofproto_get_memory_usage(const struct ofproto *ofproto, struct simap *usage)
1197 {
1198     const struct oftable *table;
1199     unsigned int n_rules;
1200
1201     simap_increase(usage, "ports", hmap_count(&ofproto->ports));
1202     simap_increase(usage, "ops",
1203                    ofproto->n_pending + hmap_count(&ofproto->deletions));
1204
1205     n_rules = 0;
1206     OFPROTO_FOR_EACH_TABLE (table, ofproto) {
1207         n_rules += classifier_count(&table->cls);
1208     }
1209     simap_increase(usage, "rules", n_rules);
1210
1211     if (ofproto->ofproto_class->get_memory_usage) {
1212         ofproto->ofproto_class->get_memory_usage(ofproto, usage);
1213     }
1214
1215     connmgr_get_memory_usage(ofproto->connmgr, usage);
1216 }
1217
1218 void
1219 ofproto_get_ofproto_controller_info(const struct ofproto *ofproto,
1220                                     struct shash *info)
1221 {
1222     connmgr_get_controller_info(ofproto->connmgr, info);
1223 }
1224
1225 void
1226 ofproto_free_ofproto_controller_info(struct shash *info)
1227 {
1228     connmgr_free_controller_info(info);
1229 }
1230
1231 /* Makes a deep copy of 'old' into 'port'. */
1232 void
1233 ofproto_port_clone(struct ofproto_port *port, const struct ofproto_port *old)
1234 {
1235     port->name = xstrdup(old->name);
1236     port->type = xstrdup(old->type);
1237     port->ofp_port = old->ofp_port;
1238 }
1239
1240 /* Frees memory allocated to members of 'ofproto_port'.
1241  *
1242  * Do not call this function on an ofproto_port obtained from
1243  * ofproto_port_dump_next(): that function retains ownership of the data in the
1244  * ofproto_port. */
1245 void
1246 ofproto_port_destroy(struct ofproto_port *ofproto_port)
1247 {
1248     free(ofproto_port->name);
1249     free(ofproto_port->type);
1250 }
1251
1252 /* Initializes 'dump' to begin dumping the ports in an ofproto.
1253  *
1254  * This function provides no status indication.  An error status for the entire
1255  * dump operation is provided when it is completed by calling
1256  * ofproto_port_dump_done().
1257  */
1258 void
1259 ofproto_port_dump_start(struct ofproto_port_dump *dump,
1260                         const struct ofproto *ofproto)
1261 {
1262     dump->ofproto = ofproto;
1263     dump->error = ofproto->ofproto_class->port_dump_start(ofproto,
1264                                                           &dump->state);
1265 }
1266
1267 /* Attempts to retrieve another port from 'dump', which must have been created
1268  * with ofproto_port_dump_start().  On success, stores a new ofproto_port into
1269  * 'port' and returns true.  On failure, returns false.
1270  *
1271  * Failure might indicate an actual error or merely that the last port has been
1272  * dumped.  An error status for the entire dump operation is provided when it
1273  * is completed by calling ofproto_port_dump_done().
1274  *
1275  * The ofproto owns the data stored in 'port'.  It will remain valid until at
1276  * least the next time 'dump' is passed to ofproto_port_dump_next() or
1277  * ofproto_port_dump_done(). */
1278 bool
1279 ofproto_port_dump_next(struct ofproto_port_dump *dump,
1280                        struct ofproto_port *port)
1281 {
1282     const struct ofproto *ofproto = dump->ofproto;
1283
1284     if (dump->error) {
1285         return false;
1286     }
1287
1288     dump->error = ofproto->ofproto_class->port_dump_next(ofproto, dump->state,
1289                                                          port);
1290     if (dump->error) {
1291         ofproto->ofproto_class->port_dump_done(ofproto, dump->state);
1292         return false;
1293     }
1294     return true;
1295 }
1296
1297 /* Completes port table dump operation 'dump', which must have been created
1298  * with ofproto_port_dump_start().  Returns 0 if the dump operation was
1299  * error-free, otherwise a positive errno value describing the problem. */
1300 int
1301 ofproto_port_dump_done(struct ofproto_port_dump *dump)
1302 {
1303     const struct ofproto *ofproto = dump->ofproto;
1304     if (!dump->error) {
1305         dump->error = ofproto->ofproto_class->port_dump_done(ofproto,
1306                                                              dump->state);
1307     }
1308     return dump->error == EOF ? 0 : dump->error;
1309 }
1310
1311 /* Attempts to add 'netdev' as a port on 'ofproto'.  If successful, returns 0
1312  * and sets '*ofp_portp' to the new port's OpenFlow port number (if 'ofp_portp'
1313  * is non-null).  On failure, returns a positive errno value and sets
1314  * '*ofp_portp' to OFPP_NONE (if 'ofp_portp' is non-null). */
1315 int
1316 ofproto_port_add(struct ofproto *ofproto, struct netdev *netdev,
1317                  uint16_t *ofp_portp)
1318 {
1319     uint16_t ofp_port;
1320     int error;
1321
1322     error = ofproto->ofproto_class->port_add(ofproto, netdev, &ofp_port);
1323     if (!error) {
1324         update_port(ofproto, netdev_get_name(netdev));
1325     }
1326     if (ofp_portp) {
1327         *ofp_portp = error ? OFPP_NONE : ofp_port;
1328     }
1329     return error;
1330 }
1331
1332 /* Looks up a port named 'devname' in 'ofproto'.  On success, returns 0 and
1333  * initializes '*port' appropriately; on failure, returns a positive errno
1334  * value.
1335  *
1336  * The caller owns the data in 'ofproto_port' and must free it with
1337  * ofproto_port_destroy() when it is no longer needed. */
1338 int
1339 ofproto_port_query_by_name(const struct ofproto *ofproto, const char *devname,
1340                            struct ofproto_port *port)
1341 {
1342     int error;
1343
1344     error = ofproto->ofproto_class->port_query_by_name(ofproto, devname, port);
1345     if (error) {
1346         memset(port, 0, sizeof *port);
1347     }
1348     return error;
1349 }
1350
1351 /* Deletes port number 'ofp_port' from the datapath for 'ofproto'.
1352  * Returns 0 if successful, otherwise a positive errno. */
1353 int
1354 ofproto_port_del(struct ofproto *ofproto, uint16_t ofp_port)
1355 {
1356     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
1357     const char *name = ofport ? netdev_get_name(ofport->netdev) : "<unknown>";
1358     int error;
1359
1360     error = ofproto->ofproto_class->port_del(ofproto, ofp_port);
1361     if (!error && ofport) {
1362         /* 'name' is the netdev's name and update_port() is going to close the
1363          * netdev.  Just in case update_port() refers to 'name' after it
1364          * destroys 'ofport', make a copy of it around the update_port()
1365          * call. */
1366         char *devname = xstrdup(name);
1367         update_port(ofproto, devname);
1368         free(devname);
1369     }
1370     return error;
1371 }
1372
1373 /* Adds a flow to OpenFlow flow table 0 in 'p' that matches 'cls_rule' and
1374  * performs the 'n_actions' actions in 'actions'.  The new flow will not
1375  * timeout.
1376  *
1377  * If cls_rule->priority is in the range of priorities supported by OpenFlow
1378  * (0...65535, inclusive) then the flow will be visible to OpenFlow
1379  * controllers; otherwise, it will be hidden.
1380  *
1381  * The caller retains ownership of 'cls_rule' and 'actions'.
1382  *
1383  * This is a helper function for in-band control and fail-open. */
1384 void
1385 ofproto_add_flow(struct ofproto *ofproto, const struct cls_rule *cls_rule,
1386                  const union ofp_action *actions, size_t n_actions)
1387 {
1388     const struct rule *rule;
1389
1390     rule = rule_from_cls_rule(classifier_find_rule_exactly(
1391                                     &ofproto->tables[0].cls, cls_rule));
1392     if (!rule || !ofputil_actions_equal(rule->actions, rule->n_actions,
1393                                         actions, n_actions)) {
1394         struct ofputil_flow_mod fm;
1395
1396         memset(&fm, 0, sizeof fm);
1397         fm.cr = *cls_rule;
1398         fm.buffer_id = UINT32_MAX;
1399         fm.actions = (union ofp_action *) actions;
1400         fm.n_actions = n_actions;
1401         add_flow(ofproto, NULL, &fm, NULL);
1402     }
1403 }
1404
1405 /* Executes the flow modification specified in 'fm'.  Returns 0 on success, an
1406  * OFPERR_* OpenFlow error code on failure, or OFPROTO_POSTPONE if the
1407  * operation cannot be initiated now but may be retried later.
1408  *
1409  * This is a helper function for in-band control and fail-open. */
1410 int
1411 ofproto_flow_mod(struct ofproto *ofproto, const struct ofputil_flow_mod *fm)
1412 {
1413     return handle_flow_mod__(ofproto, NULL, fm, NULL);
1414 }
1415
1416 /* Searches for a rule with matching criteria exactly equal to 'target' in
1417  * ofproto's table 0 and, if it finds one, deletes it.
1418  *
1419  * This is a helper function for in-band control and fail-open. */
1420 bool
1421 ofproto_delete_flow(struct ofproto *ofproto, const struct cls_rule *target)
1422 {
1423     struct rule *rule;
1424
1425     rule = rule_from_cls_rule(classifier_find_rule_exactly(
1426                                   &ofproto->tables[0].cls, target));
1427     if (!rule) {
1428         /* No such rule -> success. */
1429         return true;
1430     } else if (rule->pending) {
1431         /* An operation on the rule is already pending -> failure.
1432          * Caller must retry later if it's important. */
1433         return false;
1434     } else {
1435         /* Initiate deletion -> success. */
1436         struct ofopgroup *group = ofopgroup_create_unattached(ofproto);
1437         ofoperation_create(group, rule, OFOPERATION_DELETE);
1438         oftable_remove_rule(rule);
1439         ofproto->ofproto_class->rule_destruct(rule);
1440         ofopgroup_submit(group);
1441         return true;
1442     }
1443
1444 }
1445
1446 /* Starts the process of deleting all of the flows from all of ofproto's flow
1447  * tables and then reintroducing the flows required by in-band control and
1448  * fail-open.  The process will complete in a later call to ofproto_run(). */
1449 void
1450 ofproto_flush_flows(struct ofproto *ofproto)
1451 {
1452     COVERAGE_INC(ofproto_flush);
1453     ofproto->state = S_FLUSH;
1454 }
1455 \f
1456 static void
1457 reinit_ports(struct ofproto *p)
1458 {
1459     struct ofproto_port_dump dump;
1460     struct sset devnames;
1461     struct ofport *ofport;
1462     struct ofproto_port ofproto_port;
1463     const char *devname;
1464
1465     COVERAGE_INC(ofproto_reinit_ports);
1466
1467     sset_init(&devnames);
1468     HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
1469         sset_add(&devnames, netdev_get_name(ofport->netdev));
1470     }
1471     OFPROTO_PORT_FOR_EACH (&ofproto_port, &dump, p) {
1472         sset_add(&devnames, ofproto_port.name);
1473     }
1474
1475     SSET_FOR_EACH (devname, &devnames) {
1476         update_port(p, devname);
1477     }
1478     sset_destroy(&devnames);
1479 }
1480
1481 /* Opens and returns a netdev for 'ofproto_port', or a null pointer if the
1482  * netdev cannot be opened.  On success, also fills in 'opp'.  */
1483 static struct netdev *
1484 ofport_open(const struct ofproto_port *ofproto_port,
1485             struct ofputil_phy_port *pp)
1486 {
1487     enum netdev_flags flags;
1488     struct netdev *netdev;
1489     int error;
1490
1491     error = netdev_open(ofproto_port->name, ofproto_port->type, &netdev);
1492     if (error) {
1493         VLOG_WARN_RL(&rl, "ignoring port %s (%"PRIu16") because netdev %s "
1494                      "cannot be opened (%s)",
1495                      ofproto_port->name, ofproto_port->ofp_port,
1496                      ofproto_port->name, strerror(error));
1497         return NULL;
1498     }
1499
1500     pp->port_no = ofproto_port->ofp_port;
1501     netdev_get_etheraddr(netdev, pp->hw_addr);
1502     ovs_strlcpy(pp->name, ofproto_port->name, sizeof pp->name);
1503     netdev_get_flags(netdev, &flags);
1504     pp->config = flags & NETDEV_UP ? 0 : OFPUTIL_PC_PORT_DOWN;
1505     pp->state = netdev_get_carrier(netdev) ? 0 : OFPUTIL_PS_LINK_DOWN;
1506     netdev_get_features(netdev, &pp->curr, &pp->advertised,
1507                         &pp->supported, &pp->peer);
1508     pp->curr_speed = netdev_features_to_bps(pp->curr);
1509     pp->max_speed = netdev_features_to_bps(pp->supported);
1510
1511     return netdev;
1512 }
1513
1514 /* Returns true if most fields of 'a' and 'b' are equal.  Differences in name,
1515  * port number, and 'config' bits other than OFPUTIL_PS_LINK_DOWN are
1516  * disregarded. */
1517 static bool
1518 ofport_equal(const struct ofputil_phy_port *a,
1519              const struct ofputil_phy_port *b)
1520 {
1521     return (eth_addr_equals(a->hw_addr, b->hw_addr)
1522             && a->state == b->state
1523             && !((a->config ^ b->config) & OFPUTIL_PC_PORT_DOWN)
1524             && a->curr == b->curr
1525             && a->advertised == b->advertised
1526             && a->supported == b->supported
1527             && a->peer == b->peer
1528             && a->curr_speed == b->curr_speed
1529             && a->max_speed == b->max_speed);
1530 }
1531
1532 /* Adds an ofport to 'p' initialized based on the given 'netdev' and 'opp'.
1533  * The caller must ensure that 'p' does not have a conflicting ofport (that is,
1534  * one with the same name or port number). */
1535 static void
1536 ofport_install(struct ofproto *p,
1537                struct netdev *netdev, const struct ofputil_phy_port *pp)
1538 {
1539     const char *netdev_name = netdev_get_name(netdev);
1540     struct ofport *ofport;
1541     int error;
1542
1543     /* Create ofport. */
1544     ofport = p->ofproto_class->port_alloc();
1545     if (!ofport) {
1546         error = ENOMEM;
1547         goto error;
1548     }
1549     ofport->ofproto = p;
1550     ofport->netdev = netdev;
1551     ofport->change_seq = netdev_change_seq(netdev);
1552     ofport->pp = *pp;
1553     ofport->ofp_port = pp->port_no;
1554
1555     /* Add port to 'p'. */
1556     hmap_insert(&p->ports, &ofport->hmap_node, hash_int(ofport->ofp_port, 0));
1557     shash_add(&p->port_by_name, netdev_name, ofport);
1558
1559     update_mtu(p, ofport);
1560
1561     /* Let the ofproto_class initialize its private data. */
1562     error = p->ofproto_class->port_construct(ofport);
1563     if (error) {
1564         goto error;
1565     }
1566     connmgr_send_port_status(p->connmgr, pp, OFPPR_ADD);
1567     return;
1568
1569 error:
1570     VLOG_WARN_RL(&rl, "%s: could not add port %s (%s)",
1571                  p->name, netdev_name, strerror(error));
1572     if (ofport) {
1573         ofport_destroy__(ofport);
1574     } else {
1575         netdev_close(netdev);
1576     }
1577 }
1578
1579 /* Removes 'ofport' from 'p' and destroys it. */
1580 static void
1581 ofport_remove(struct ofport *ofport)
1582 {
1583     connmgr_send_port_status(ofport->ofproto->connmgr, &ofport->pp,
1584                              OFPPR_DELETE);
1585     ofport_destroy(ofport);
1586 }
1587
1588 /* If 'ofproto' contains an ofport named 'name', removes it from 'ofproto' and
1589  * destroys it. */
1590 static void
1591 ofport_remove_with_name(struct ofproto *ofproto, const char *name)
1592 {
1593     struct ofport *port = shash_find_data(&ofproto->port_by_name, name);
1594     if (port) {
1595         ofport_remove(port);
1596     }
1597 }
1598
1599 /* Updates 'port' with new 'pp' description.
1600  *
1601  * Does not handle a name or port number change.  The caller must implement
1602  * such a change as a delete followed by an add.  */
1603 static void
1604 ofport_modified(struct ofport *port, struct ofputil_phy_port *pp)
1605 {
1606     memcpy(port->pp.hw_addr, pp->hw_addr, ETH_ADDR_LEN);
1607     port->pp.config = ((port->pp.config & ~OFPUTIL_PC_PORT_DOWN)
1608                         | (pp->config & OFPUTIL_PC_PORT_DOWN));
1609     port->pp.state = pp->state;
1610     port->pp.curr = pp->curr;
1611     port->pp.advertised = pp->advertised;
1612     port->pp.supported = pp->supported;
1613     port->pp.peer = pp->peer;
1614     port->pp.curr_speed = pp->curr_speed;
1615     port->pp.max_speed = pp->max_speed;
1616
1617     connmgr_send_port_status(port->ofproto->connmgr, &port->pp, OFPPR_MODIFY);
1618 }
1619
1620 /* Update OpenFlow 'state' in 'port' and notify controller. */
1621 void
1622 ofproto_port_set_state(struct ofport *port, enum ofputil_port_state state)
1623 {
1624     if (port->pp.state != state) {
1625         port->pp.state = state;
1626         connmgr_send_port_status(port->ofproto->connmgr, &port->pp,
1627                                  OFPPR_MODIFY);
1628     }
1629 }
1630
1631 void
1632 ofproto_port_unregister(struct ofproto *ofproto, uint16_t ofp_port)
1633 {
1634     struct ofport *port = ofproto_get_port(ofproto, ofp_port);
1635     if (port) {
1636         if (port->ofproto->ofproto_class->set_realdev) {
1637             port->ofproto->ofproto_class->set_realdev(port, 0, 0);
1638         }
1639         if (port->ofproto->ofproto_class->set_stp_port) {
1640             port->ofproto->ofproto_class->set_stp_port(port, NULL);
1641         }
1642         if (port->ofproto->ofproto_class->set_cfm) {
1643             port->ofproto->ofproto_class->set_cfm(port, NULL);
1644         }
1645         if (port->ofproto->ofproto_class->bundle_remove) {
1646             port->ofproto->ofproto_class->bundle_remove(port);
1647         }
1648     }
1649 }
1650
1651 static void
1652 ofport_destroy__(struct ofport *port)
1653 {
1654     struct ofproto *ofproto = port->ofproto;
1655     const char *name = netdev_get_name(port->netdev);
1656
1657     hmap_remove(&ofproto->ports, &port->hmap_node);
1658     shash_delete(&ofproto->port_by_name,
1659                  shash_find(&ofproto->port_by_name, name));
1660
1661     netdev_close(port->netdev);
1662     ofproto->ofproto_class->port_dealloc(port);
1663 }
1664
1665 static void
1666 ofport_destroy(struct ofport *port)
1667 {
1668     if (port) {
1669         port->ofproto->ofproto_class->port_destruct(port);
1670         ofport_destroy__(port);
1671      }
1672 }
1673
1674 struct ofport *
1675 ofproto_get_port(const struct ofproto *ofproto, uint16_t ofp_port)
1676 {
1677     struct ofport *port;
1678
1679     HMAP_FOR_EACH_IN_BUCKET (port, hmap_node,
1680                              hash_int(ofp_port, 0), &ofproto->ports) {
1681         if (port->ofp_port == ofp_port) {
1682             return port;
1683         }
1684     }
1685     return NULL;
1686 }
1687
1688 int
1689 ofproto_port_get_stats(const struct ofport *port, struct netdev_stats *stats)
1690 {
1691     struct ofproto *ofproto = port->ofproto;
1692     int error;
1693
1694     if (ofproto->ofproto_class->port_get_stats) {
1695         error = ofproto->ofproto_class->port_get_stats(port, stats);
1696     } else {
1697         error = EOPNOTSUPP;
1698     }
1699
1700     return error;
1701 }
1702
1703 static void
1704 update_port(struct ofproto *ofproto, const char *name)
1705 {
1706     struct ofproto_port ofproto_port;
1707     struct ofputil_phy_port pp;
1708     struct netdev *netdev;
1709     struct ofport *port;
1710
1711     COVERAGE_INC(ofproto_update_port);
1712
1713     /* Fetch 'name''s location and properties from the datapath. */
1714     netdev = (!ofproto_port_query_by_name(ofproto, name, &ofproto_port)
1715               ? ofport_open(&ofproto_port, &pp)
1716               : NULL);
1717     if (netdev) {
1718         port = ofproto_get_port(ofproto, ofproto_port.ofp_port);
1719         if (port && !strcmp(netdev_get_name(port->netdev), name)) {
1720             struct netdev *old_netdev = port->netdev;
1721
1722             /* 'name' hasn't changed location.  Any properties changed? */
1723             if (!ofport_equal(&port->pp, &pp)) {
1724                 ofport_modified(port, &pp);
1725             }
1726
1727             update_mtu(ofproto, port);
1728
1729             /* Install the newly opened netdev in case it has changed.
1730              * Don't close the old netdev yet in case port_modified has to
1731              * remove a retained reference to it.*/
1732             port->netdev = netdev;
1733             port->change_seq = netdev_change_seq(netdev);
1734
1735             if (port->ofproto->ofproto_class->port_modified) {
1736                 port->ofproto->ofproto_class->port_modified(port);
1737             }
1738
1739             netdev_close(old_netdev);
1740         } else {
1741             /* If 'port' is nonnull then its name differs from 'name' and thus
1742              * we should delete it.  If we think there's a port named 'name'
1743              * then its port number must be wrong now so delete it too. */
1744             if (port) {
1745                 ofport_remove(port);
1746             }
1747             ofport_remove_with_name(ofproto, name);
1748             ofport_install(ofproto, netdev, &pp);
1749         }
1750     } else {
1751         /* Any port named 'name' is gone now. */
1752         ofport_remove_with_name(ofproto, name);
1753     }
1754     ofproto_port_destroy(&ofproto_port);
1755 }
1756
1757 static int
1758 init_ports(struct ofproto *p)
1759 {
1760     struct ofproto_port_dump dump;
1761     struct ofproto_port ofproto_port;
1762
1763     OFPROTO_PORT_FOR_EACH (&ofproto_port, &dump, p) {
1764         uint16_t ofp_port = ofproto_port.ofp_port;
1765         if (ofproto_get_port(p, ofp_port)) {
1766             VLOG_WARN_RL(&rl, "ignoring duplicate port %"PRIu16" in datapath",
1767                          ofp_port);
1768         } else if (shash_find(&p->port_by_name, ofproto_port.name)) {
1769             VLOG_WARN_RL(&rl, "ignoring duplicate device %s in datapath",
1770                          ofproto_port.name);
1771         } else {
1772             struct ofputil_phy_port pp;
1773             struct netdev *netdev;
1774
1775             netdev = ofport_open(&ofproto_port, &pp);
1776             if (netdev) {
1777                 ofport_install(p, netdev, &pp);
1778             }
1779         }
1780     }
1781
1782     return 0;
1783 }
1784
1785 /* Find the minimum MTU of all non-datapath devices attached to 'p'.
1786  * Returns ETH_PAYLOAD_MAX or the minimum of the ports. */
1787 static int
1788 find_min_mtu(struct ofproto *p)
1789 {
1790     struct ofport *ofport;
1791     int mtu = 0;
1792
1793     HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
1794         struct netdev *netdev = ofport->netdev;
1795         int dev_mtu;
1796
1797         /* Skip any internal ports, since that's what we're trying to
1798          * set. */
1799         if (!strcmp(netdev_get_type(netdev), "internal")) {
1800             continue;
1801         }
1802
1803         if (netdev_get_mtu(netdev, &dev_mtu)) {
1804             continue;
1805         }
1806         if (!mtu || dev_mtu < mtu) {
1807             mtu = dev_mtu;
1808         }
1809     }
1810
1811     return mtu ? mtu: ETH_PAYLOAD_MAX;
1812 }
1813
1814 /* Update MTU of all datapath devices on 'p' to the minimum of the
1815  * non-datapath ports in event of 'port' added or changed. */
1816 static void
1817 update_mtu(struct ofproto *p, struct ofport *port)
1818 {
1819     struct ofport *ofport;
1820     struct netdev *netdev = port->netdev;
1821     int dev_mtu, old_min;
1822
1823     if (netdev_get_mtu(netdev, &dev_mtu)) {
1824         port->mtu = 0;
1825         return;
1826     }
1827     if (!strcmp(netdev_get_type(port->netdev), "internal")) {
1828         if (dev_mtu > p->min_mtu) {
1829            if (!netdev_set_mtu(port->netdev, p->min_mtu)) {
1830                dev_mtu = p->min_mtu;
1831            }
1832         }
1833         port->mtu = dev_mtu;
1834         return;
1835     }
1836
1837     /* For non-internal port find new min mtu. */
1838     old_min = p->min_mtu;
1839     port->mtu = dev_mtu;
1840     p->min_mtu = find_min_mtu(p);
1841     if (p->min_mtu == old_min) {
1842         return;
1843     }
1844
1845     HMAP_FOR_EACH (ofport, hmap_node, &p->ports) {
1846         struct netdev *netdev = ofport->netdev;
1847
1848         if (!strcmp(netdev_get_type(netdev), "internal")) {
1849             if (!netdev_set_mtu(netdev, p->min_mtu)) {
1850                 ofport->mtu = p->min_mtu;
1851             }
1852         }
1853     }
1854 }
1855 \f
1856 static void
1857 ofproto_rule_destroy__(struct rule *rule)
1858 {
1859     if (rule) {
1860         free(rule->actions);
1861         rule->ofproto->ofproto_class->rule_dealloc(rule);
1862     }
1863 }
1864
1865 /* This function allows an ofproto implementation to destroy any rules that
1866  * remain when its ->destruct() function is called.  The caller must have
1867  * already uninitialized any derived members of 'rule' (step 5 described in the
1868  * large comment in ofproto/ofproto-provider.h titled "Life Cycle").
1869  * This function implements steps 6 and 7.
1870  *
1871  * This function should only be called from an ofproto implementation's
1872  * ->destruct() function.  It is not suitable elsewhere. */
1873 void
1874 ofproto_rule_destroy(struct rule *rule)
1875 {
1876     assert(!rule->pending);
1877     oftable_remove_rule(rule);
1878     ofproto_rule_destroy__(rule);
1879 }
1880
1881 /* Returns true if 'rule' has an OpenFlow OFPAT_OUTPUT or OFPAT_ENQUEUE action
1882  * that outputs to 'out_port' (output to OFPP_FLOOD and OFPP_ALL doesn't
1883  * count). */
1884 static bool
1885 rule_has_out_port(const struct rule *rule, uint16_t out_port)
1886 {
1887     const union ofp_action *oa;
1888     size_t left;
1889
1890     if (out_port == OFPP_NONE) {
1891         return true;
1892     }
1893     OFPUTIL_ACTION_FOR_EACH_UNSAFE (oa, left, rule->actions, rule->n_actions) {
1894         if (action_outputs_to_port(oa, htons(out_port))) {
1895             return true;
1896         }
1897     }
1898     return false;
1899 }
1900
1901 /* Executes the actions indicated by 'rule' on 'packet' and credits 'rule''s
1902  * statistics appropriately.  'packet' must have at least sizeof(struct
1903  * ofp_packet_in) bytes of headroom.
1904  *
1905  * 'packet' doesn't necessarily have to match 'rule'.  'rule' will be credited
1906  * with statistics for 'packet' either way.
1907  *
1908  * Takes ownership of 'packet'. */
1909 static int
1910 rule_execute(struct rule *rule, uint16_t in_port, struct ofpbuf *packet)
1911 {
1912     struct flow flow;
1913
1914     assert(ofpbuf_headroom(packet) >= sizeof(struct ofp_packet_in));
1915
1916     flow_extract(packet, 0, 0, in_port, &flow);
1917     return rule->ofproto->ofproto_class->rule_execute(rule, &flow, packet);
1918 }
1919
1920 /* Returns true if 'rule' should be hidden from the controller.
1921  *
1922  * Rules with priority higher than UINT16_MAX are set up by ofproto itself
1923  * (e.g. by in-band control) and are intentionally hidden from the
1924  * controller. */
1925 static bool
1926 rule_is_hidden(const struct rule *rule)
1927 {
1928     return rule->cr.priority > UINT16_MAX;
1929 }
1930
1931 static enum oftable_flags
1932 rule_get_flags(const struct rule *rule)
1933 {
1934     return rule->ofproto->tables[rule->table_id].flags;
1935 }
1936
1937 static bool
1938 rule_is_modifiable(const struct rule *rule)
1939 {
1940     return !(rule_get_flags(rule) & OFTABLE_READONLY);
1941 }
1942 \f
1943 static enum ofperr
1944 handle_echo_request(struct ofconn *ofconn, const struct ofp_header *oh)
1945 {
1946     ofconn_send_reply(ofconn, make_echo_reply(oh));
1947     return 0;
1948 }
1949
1950 static enum ofperr
1951 handle_features_request(struct ofconn *ofconn, const struct ofp_header *oh)
1952 {
1953     struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
1954     struct ofputil_switch_features features;
1955     struct ofport *port;
1956     bool arp_match_ip;
1957     struct ofpbuf *b;
1958
1959     ofproto->ofproto_class->get_features(ofproto, &arp_match_ip,
1960                                          &features.actions);
1961     assert(features.actions & OFPUTIL_A_OUTPUT); /* sanity check */
1962
1963     features.datapath_id = ofproto->datapath_id;
1964     features.n_buffers = pktbuf_capacity();
1965     features.n_tables = ofproto->n_tables;
1966     features.capabilities = (OFPUTIL_C_FLOW_STATS | OFPUTIL_C_TABLE_STATS |
1967                              OFPUTIL_C_PORT_STATS | OFPUTIL_C_QUEUE_STATS);
1968     if (arp_match_ip) {
1969         features.capabilities |= OFPUTIL_C_ARP_MATCH_IP;
1970     }
1971
1972     b = ofputil_encode_switch_features(&features, ofconn_get_protocol(ofconn),
1973                                        oh->xid);
1974     HMAP_FOR_EACH (port, hmap_node, &ofproto->ports) {
1975         ofputil_put_switch_features_port(&port->pp, b);
1976     }
1977
1978     ofconn_send_reply(ofconn, b);
1979     return 0;
1980 }
1981
1982 static enum ofperr
1983 handle_get_config_request(struct ofconn *ofconn, const struct ofp_header *oh)
1984 {
1985     struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
1986     struct ofp_switch_config *osc;
1987     enum ofp_config_flags flags;
1988     struct ofpbuf *buf;
1989
1990     /* Send reply. */
1991     osc = make_openflow_xid(sizeof *osc, OFPT_GET_CONFIG_REPLY, oh->xid, &buf);
1992     flags = ofproto->frag_handling;
1993     if (ofconn_get_invalid_ttl_to_controller(ofconn)) {
1994         flags |= OFPC_INVALID_TTL_TO_CONTROLLER;
1995     }
1996     osc->flags = htons(flags);
1997     osc->miss_send_len = htons(ofconn_get_miss_send_len(ofconn));
1998     ofconn_send_reply(ofconn, buf);
1999
2000     return 0;
2001 }
2002
2003 static enum ofperr
2004 handle_set_config(struct ofconn *ofconn, const struct ofp_switch_config *osc)
2005 {
2006     struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
2007     uint16_t flags = ntohs(osc->flags);
2008
2009     if (ofconn_get_type(ofconn) != OFCONN_PRIMARY
2010         || ofconn_get_role(ofconn) != NX_ROLE_SLAVE) {
2011         enum ofp_config_flags cur = ofproto->frag_handling;
2012         enum ofp_config_flags next = flags & OFPC_FRAG_MASK;
2013
2014         assert((cur & OFPC_FRAG_MASK) == cur);
2015         if (cur != next) {
2016             if (ofproto->ofproto_class->set_frag_handling(ofproto, next)) {
2017                 ofproto->frag_handling = next;
2018             } else {
2019                 VLOG_WARN_RL(&rl, "%s: unsupported fragment handling mode %s",
2020                              ofproto->name,
2021                              ofputil_frag_handling_to_string(next));
2022             }
2023         }
2024     }
2025     ofconn_set_invalid_ttl_to_controller(ofconn,
2026              (flags & OFPC_INVALID_TTL_TO_CONTROLLER));
2027
2028     ofconn_set_miss_send_len(ofconn, ntohs(osc->miss_send_len));
2029
2030     return 0;
2031 }
2032
2033 /* Checks whether 'ofconn' is a slave controller.  If so, returns an OpenFlow
2034  * error message code for the caller to propagate upward.  Otherwise, returns
2035  * 0.
2036  *
2037  * The log message mentions 'msg_type'. */
2038 static enum ofperr
2039 reject_slave_controller(struct ofconn *ofconn)
2040 {
2041     if (ofconn_get_type(ofconn) == OFCONN_PRIMARY
2042         && ofconn_get_role(ofconn) == NX_ROLE_SLAVE) {
2043         return OFPERR_OFPBRC_EPERM;
2044     } else {
2045         return 0;
2046     }
2047 }
2048
2049 static enum ofperr
2050 handle_packet_out(struct ofconn *ofconn, const struct ofp_packet_out *opo)
2051 {
2052     struct ofproto *p = ofconn_get_ofproto(ofconn);
2053     struct ofputil_packet_out po;
2054     struct ofpbuf *payload;
2055     struct flow flow;
2056     enum ofperr error;
2057
2058     COVERAGE_INC(ofproto_packet_out);
2059
2060     error = reject_slave_controller(ofconn);
2061     if (error) {
2062         return error;
2063     }
2064
2065     /* Decode message. */
2066     error = ofputil_decode_packet_out(&po, opo);
2067     if (error) {
2068         return error;
2069     }
2070
2071     /* Get payload. */
2072     if (po.buffer_id != UINT32_MAX) {
2073         error = ofconn_pktbuf_retrieve(ofconn, po.buffer_id, &payload, NULL);
2074         if (error || !payload) {
2075             return error;
2076         }
2077     } else {
2078         payload = xmalloc(sizeof *payload);
2079         ofpbuf_use_const(payload, po.packet, po.packet_len);
2080     }
2081
2082     /* Send out packet. */
2083     flow_extract(payload, 0, 0, po.in_port, &flow);
2084     error = p->ofproto_class->packet_out(p, payload, &flow,
2085                                          po.actions, po.n_actions);
2086     ofpbuf_delete(payload);
2087
2088     return error;
2089 }
2090
2091 static void
2092 update_port_config(struct ofport *port,
2093                    enum ofputil_port_config config,
2094                    enum ofputil_port_config mask)
2095 {
2096     enum ofputil_port_config old_config = port->pp.config;
2097     enum ofputil_port_config toggle;
2098
2099     toggle = (config ^ port->pp.config) & mask;
2100     if (toggle & OFPUTIL_PC_PORT_DOWN) {
2101         if (config & OFPUTIL_PC_PORT_DOWN) {
2102             netdev_turn_flags_off(port->netdev, NETDEV_UP, true);
2103         } else {
2104             netdev_turn_flags_on(port->netdev, NETDEV_UP, true);
2105         }
2106         toggle &= ~OFPUTIL_PC_PORT_DOWN;
2107     }
2108
2109     port->pp.config ^= toggle;
2110     if (port->pp.config != old_config) {
2111         port->ofproto->ofproto_class->port_reconfigured(port, old_config);
2112     }
2113 }
2114
2115 static enum ofperr
2116 handle_port_mod(struct ofconn *ofconn, const struct ofp_header *oh)
2117 {
2118     struct ofproto *p = ofconn_get_ofproto(ofconn);
2119     struct ofputil_port_mod pm;
2120     struct ofport *port;
2121     enum ofperr error;
2122
2123     error = reject_slave_controller(ofconn);
2124     if (error) {
2125         return error;
2126     }
2127
2128     error = ofputil_decode_port_mod(oh, &pm);
2129     if (error) {
2130         return error;
2131     }
2132
2133     port = ofproto_get_port(p, pm.port_no);
2134     if (!port) {
2135         return OFPERR_OFPPMFC_BAD_PORT;
2136     } else if (!eth_addr_equals(port->pp.hw_addr, pm.hw_addr)) {
2137         return OFPERR_OFPPMFC_BAD_HW_ADDR;
2138     } else {
2139         update_port_config(port, pm.config, pm.mask);
2140         if (pm.advertise) {
2141             netdev_set_advertisements(port->netdev, pm.advertise);
2142         }
2143     }
2144     return 0;
2145 }
2146
2147 static enum ofperr
2148 handle_desc_stats_request(struct ofconn *ofconn,
2149                           const struct ofp_stats_msg *request)
2150 {
2151     struct ofproto *p = ofconn_get_ofproto(ofconn);
2152     struct ofp_desc_stats *ods;
2153     struct ofpbuf *msg;
2154
2155     ods = ofputil_make_stats_reply(sizeof *ods, request, &msg);
2156     ovs_strlcpy(ods->mfr_desc, p->mfr_desc, sizeof ods->mfr_desc);
2157     ovs_strlcpy(ods->hw_desc, p->hw_desc, sizeof ods->hw_desc);
2158     ovs_strlcpy(ods->sw_desc, p->sw_desc, sizeof ods->sw_desc);
2159     ovs_strlcpy(ods->serial_num, p->serial_desc, sizeof ods->serial_num);
2160     ovs_strlcpy(ods->dp_desc, p->dp_desc, sizeof ods->dp_desc);
2161     ofconn_send_reply(ofconn, msg);
2162
2163     return 0;
2164 }
2165
2166 static enum ofperr
2167 handle_table_stats_request(struct ofconn *ofconn,
2168                            const struct ofp_stats_msg *request)
2169 {
2170     struct ofproto *p = ofconn_get_ofproto(ofconn);
2171     struct ofp_table_stats *ots;
2172     struct ofpbuf *msg;
2173     size_t i;
2174
2175     ofputil_make_stats_reply(sizeof(struct ofp_stats_msg), request, &msg);
2176
2177     ots = ofpbuf_put_zeros(msg, sizeof *ots * p->n_tables);
2178     for (i = 0; i < p->n_tables; i++) {
2179         ots[i].table_id = i;
2180         sprintf(ots[i].name, "table%zu", i);
2181         ots[i].wildcards = htonl(OFPFW10_ALL);
2182         ots[i].max_entries = htonl(1000000); /* An arbitrary big number. */
2183         ots[i].active_count = htonl(classifier_count(&p->tables[i].cls));
2184     }
2185
2186     p->ofproto_class->get_tables(p, ots);
2187
2188     for (i = 0; i < p->n_tables; i++) {
2189         const struct oftable *table = &p->tables[i];
2190
2191         if (table->name) {
2192             ovs_strzcpy(ots[i].name, table->name, sizeof ots[i].name);
2193         }
2194
2195         if (table->max_flows < ntohl(ots[i].max_entries)) {
2196             ots[i].max_entries = htonl(table->max_flows);
2197         }
2198     }
2199
2200     ofconn_send_reply(ofconn, msg);
2201     return 0;
2202 }
2203
2204 static void
2205 append_port_stat(struct ofport *port, struct list *replies)
2206 {
2207     struct netdev_stats stats;
2208     struct ofp_port_stats *ops;
2209
2210     /* Intentionally ignore return value, since errors will set
2211      * 'stats' to all-1s, which is correct for OpenFlow, and
2212      * netdev_get_stats() will log errors. */
2213     ofproto_port_get_stats(port, &stats);
2214
2215     ops = ofputil_append_stats_reply(sizeof *ops, replies);
2216     ops->port_no = htons(port->pp.port_no);
2217     memset(ops->pad, 0, sizeof ops->pad);
2218     put_32aligned_be64(&ops->rx_packets, htonll(stats.rx_packets));
2219     put_32aligned_be64(&ops->tx_packets, htonll(stats.tx_packets));
2220     put_32aligned_be64(&ops->rx_bytes, htonll(stats.rx_bytes));
2221     put_32aligned_be64(&ops->tx_bytes, htonll(stats.tx_bytes));
2222     put_32aligned_be64(&ops->rx_dropped, htonll(stats.rx_dropped));
2223     put_32aligned_be64(&ops->tx_dropped, htonll(stats.tx_dropped));
2224     put_32aligned_be64(&ops->rx_errors, htonll(stats.rx_errors));
2225     put_32aligned_be64(&ops->tx_errors, htonll(stats.tx_errors));
2226     put_32aligned_be64(&ops->rx_frame_err, htonll(stats.rx_frame_errors));
2227     put_32aligned_be64(&ops->rx_over_err, htonll(stats.rx_over_errors));
2228     put_32aligned_be64(&ops->rx_crc_err, htonll(stats.rx_crc_errors));
2229     put_32aligned_be64(&ops->collisions, htonll(stats.collisions));
2230 }
2231
2232 static enum ofperr
2233 handle_port_stats_request(struct ofconn *ofconn,
2234                           const struct ofp_port_stats_request *psr)
2235 {
2236     struct ofproto *p = ofconn_get_ofproto(ofconn);
2237     struct ofport *port;
2238     struct list replies;
2239
2240     ofputil_start_stats_reply(&psr->osm, &replies);
2241     if (psr->port_no != htons(OFPP_NONE)) {
2242         port = ofproto_get_port(p, ntohs(psr->port_no));
2243         if (port) {
2244             append_port_stat(port, &replies);
2245         }
2246     } else {
2247         HMAP_FOR_EACH (port, hmap_node, &p->ports) {
2248             append_port_stat(port, &replies);
2249         }
2250     }
2251
2252     ofconn_send_replies(ofconn, &replies);
2253     return 0;
2254 }
2255
2256 static enum ofperr
2257 handle_port_desc_stats_request(struct ofconn *ofconn,
2258                                const struct ofp_stats_msg *osm)
2259 {
2260     struct ofproto *p = ofconn_get_ofproto(ofconn);
2261     struct ofport *port;
2262     struct list replies;
2263
2264     ofputil_start_stats_reply(osm, &replies);
2265
2266     HMAP_FOR_EACH (port, hmap_node, &p->ports) {
2267         ofputil_append_port_desc_stats_reply(ofconn_get_protocol(ofconn),
2268                                              &port->pp, &replies);
2269     }
2270
2271     ofconn_send_replies(ofconn, &replies);
2272     return 0;
2273 }
2274
2275 static void
2276 calc_flow_duration__(long long int start, long long int now,
2277                      uint32_t *sec, uint32_t *nsec)
2278 {
2279     long long int msecs = now - start;
2280     *sec = msecs / 1000;
2281     *nsec = (msecs % 1000) * (1000 * 1000);
2282 }
2283
2284 /* Checks whether 'table_id' is 0xff or a valid table ID in 'ofproto'.  Returns
2285  * 0 if 'table_id' is OK, otherwise an OpenFlow error code.  */
2286 static enum ofperr
2287 check_table_id(const struct ofproto *ofproto, uint8_t table_id)
2288 {
2289     return (table_id == 0xff || table_id < ofproto->n_tables
2290             ? 0
2291             : OFPERR_NXBRC_BAD_TABLE_ID);
2292
2293 }
2294
2295 static struct oftable *
2296 next_visible_table(struct ofproto *ofproto, uint8_t table_id)
2297 {
2298     struct oftable *table;
2299
2300     for (table = &ofproto->tables[table_id];
2301          table < &ofproto->tables[ofproto->n_tables];
2302          table++) {
2303         if (!(table->flags & OFTABLE_HIDDEN)) {
2304             return table;
2305         }
2306     }
2307
2308     return NULL;
2309 }
2310
2311 static struct oftable *
2312 first_matching_table(struct ofproto *ofproto, uint8_t table_id)
2313 {
2314     if (table_id == 0xff) {
2315         return next_visible_table(ofproto, 0);
2316     } else if (table_id < ofproto->n_tables) {
2317         return &ofproto->tables[table_id];
2318     } else {
2319         return NULL;
2320     }
2321 }
2322
2323 static struct oftable *
2324 next_matching_table(struct ofproto *ofproto,
2325                     struct oftable *table, uint8_t table_id)
2326 {
2327     return (table_id == 0xff
2328             ? next_visible_table(ofproto, (table - ofproto->tables) + 1)
2329             : NULL);
2330 }
2331
2332 /* Assigns TABLE to each oftable, in turn, that matches TABLE_ID in OFPROTO:
2333  *
2334  *   - If TABLE_ID is 0xff, this iterates over every classifier table in
2335  *     OFPROTO, skipping tables marked OFTABLE_HIDDEN.
2336  *
2337  *   - If TABLE_ID is the number of a table in OFPROTO, then the loop iterates
2338  *     only once, for that table.  (This can be used to access tables marked
2339  *     OFTABLE_HIDDEN.)
2340  *
2341  *   - Otherwise, TABLE_ID isn't valid for OFPROTO, so the loop won't be
2342  *     entered at all.  (Perhaps you should have validated TABLE_ID with
2343  *     check_table_id().)
2344  *
2345  * All parameters are evaluated multiple times.
2346  */
2347 #define FOR_EACH_MATCHING_TABLE(TABLE, TABLE_ID, OFPROTO)         \
2348     for ((TABLE) = first_matching_table(OFPROTO, TABLE_ID);       \
2349          (TABLE) != NULL;                                         \
2350          (TABLE) = next_matching_table(OFPROTO, TABLE, TABLE_ID))
2351
2352 /* Searches 'ofproto' for rules in table 'table_id' (or in all tables, if
2353  * 'table_id' is 0xff) that match 'match' in the "loose" way required for
2354  * OpenFlow OFPFC_MODIFY and OFPFC_DELETE requests and puts them on list
2355  * 'rules'.
2356  *
2357  * If 'out_port' is anything other than OFPP_NONE, then only rules that output
2358  * to 'out_port' are included.
2359  *
2360  * Hidden rules are always omitted.
2361  *
2362  * Returns 0 on success, otherwise an OpenFlow error code. */
2363 static enum ofperr
2364 collect_rules_loose(struct ofproto *ofproto, uint8_t table_id,
2365                     const struct cls_rule *match,
2366                     ovs_be64 cookie, ovs_be64 cookie_mask,
2367                     uint16_t out_port, struct list *rules)
2368 {
2369     struct oftable *table;
2370     enum ofperr error;
2371
2372     error = check_table_id(ofproto, table_id);
2373     if (error) {
2374         return error;
2375     }
2376
2377     list_init(rules);
2378     FOR_EACH_MATCHING_TABLE (table, table_id, ofproto) {
2379         struct cls_cursor cursor;
2380         struct rule *rule;
2381
2382         cls_cursor_init(&cursor, &table->cls, match);
2383         CLS_CURSOR_FOR_EACH (rule, cr, &cursor) {
2384             if (rule->pending) {
2385                 return OFPROTO_POSTPONE;
2386             }
2387             if (!rule_is_hidden(rule) && rule_has_out_port(rule, out_port)
2388                     && !((rule->flow_cookie ^ cookie) & cookie_mask)) {
2389                 list_push_back(rules, &rule->ofproto_node);
2390             }
2391         }
2392     }
2393     return 0;
2394 }
2395
2396 /* Searches 'ofproto' for rules in table 'table_id' (or in all tables, if
2397  * 'table_id' is 0xff) that match 'match' in the "strict" way required for
2398  * OpenFlow OFPFC_MODIFY_STRICT and OFPFC_DELETE_STRICT requests and puts them
2399  * on list 'rules'.
2400  *
2401  * If 'out_port' is anything other than OFPP_NONE, then only rules that output
2402  * to 'out_port' are included.
2403  *
2404  * Hidden rules are always omitted.
2405  *
2406  * Returns 0 on success, otherwise an OpenFlow error code. */
2407 static enum ofperr
2408 collect_rules_strict(struct ofproto *ofproto, uint8_t table_id,
2409                      const struct cls_rule *match,
2410                      ovs_be64 cookie, ovs_be64 cookie_mask,
2411                      uint16_t out_port, struct list *rules)
2412 {
2413     struct oftable *table;
2414     int error;
2415
2416     error = check_table_id(ofproto, table_id);
2417     if (error) {
2418         return error;
2419     }
2420
2421     list_init(rules);
2422     FOR_EACH_MATCHING_TABLE (table, table_id, ofproto) {
2423         struct rule *rule;
2424
2425         rule = rule_from_cls_rule(classifier_find_rule_exactly(&table->cls,
2426                                                                match));
2427         if (rule) {
2428             if (rule->pending) {
2429                 return OFPROTO_POSTPONE;
2430             }
2431             if (!rule_is_hidden(rule) && rule_has_out_port(rule, out_port)
2432                     && !((rule->flow_cookie ^ cookie) & cookie_mask)) {
2433                 list_push_back(rules, &rule->ofproto_node);
2434             }
2435         }
2436     }
2437     return 0;
2438 }
2439
2440 /* Returns 'age_ms' (a duration in milliseconds), converted to seconds and
2441  * forced into the range of a uint16_t. */
2442 static int
2443 age_secs(long long int age_ms)
2444 {
2445     return (age_ms < 0 ? 0
2446             : age_ms >= UINT16_MAX * 1000 ? UINT16_MAX
2447             : (unsigned int) age_ms / 1000);
2448 }
2449
2450 static enum ofperr
2451 handle_flow_stats_request(struct ofconn *ofconn,
2452                           const struct ofp_stats_msg *osm)
2453 {
2454     struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
2455     struct ofputil_flow_stats_request fsr;
2456     struct list replies;
2457     struct list rules;
2458     struct rule *rule;
2459     enum ofperr error;
2460
2461     error = ofputil_decode_flow_stats_request(&fsr, &osm->header);
2462     if (error) {
2463         return error;
2464     }
2465
2466     error = collect_rules_loose(ofproto, fsr.table_id, &fsr.match,
2467                                 fsr.cookie, fsr.cookie_mask,
2468                                 fsr.out_port, &rules);
2469     if (error) {
2470         return error;
2471     }
2472
2473     ofputil_start_stats_reply(osm, &replies);
2474     LIST_FOR_EACH (rule, ofproto_node, &rules) {
2475         long long int now = time_msec();
2476         struct ofputil_flow_stats fs;
2477
2478         fs.rule = rule->cr;
2479         fs.cookie = rule->flow_cookie;
2480         fs.table_id = rule->table_id;
2481         calc_flow_duration__(rule->created, now, &fs.duration_sec,
2482                              &fs.duration_nsec);
2483         fs.idle_timeout = rule->idle_timeout;
2484         fs.hard_timeout = rule->hard_timeout;
2485         fs.idle_age = age_secs(now - rule->used);
2486         fs.hard_age = age_secs(now - rule->modified);
2487         ofproto->ofproto_class->rule_get_stats(rule, &fs.packet_count,
2488                                                &fs.byte_count);
2489         fs.actions = rule->actions;
2490         fs.n_actions = rule->n_actions;
2491         ofputil_append_flow_stats_reply(&fs, &replies);
2492     }
2493     ofconn_send_replies(ofconn, &replies);
2494
2495     return 0;
2496 }
2497
2498 static void
2499 flow_stats_ds(struct rule *rule, struct ds *results)
2500 {
2501     uint64_t packet_count, byte_count;
2502
2503     rule->ofproto->ofproto_class->rule_get_stats(rule,
2504                                                  &packet_count, &byte_count);
2505
2506     if (rule->table_id != 0) {
2507         ds_put_format(results, "table_id=%"PRIu8", ", rule->table_id);
2508     }
2509     ds_put_format(results, "duration=%llds, ",
2510                   (time_msec() - rule->created) / 1000);
2511     ds_put_format(results, "priority=%u, ", rule->cr.priority);
2512     ds_put_format(results, "n_packets=%"PRIu64", ", packet_count);
2513     ds_put_format(results, "n_bytes=%"PRIu64", ", byte_count);
2514     cls_rule_format(&rule->cr, results);
2515     ds_put_char(results, ',');
2516     if (rule->n_actions > 0) {
2517         ofp_print_actions(results, rule->actions, rule->n_actions);
2518     } else {
2519         ds_put_cstr(results, "drop");
2520     }
2521     ds_put_cstr(results, "\n");
2522 }
2523
2524 /* Adds a pretty-printed description of all flows to 'results', including
2525  * hidden flows (e.g., set up by in-band control). */
2526 void
2527 ofproto_get_all_flows(struct ofproto *p, struct ds *results)
2528 {
2529     struct oftable *table;
2530
2531     OFPROTO_FOR_EACH_TABLE (table, p) {
2532         struct cls_cursor cursor;
2533         struct rule *rule;
2534
2535         cls_cursor_init(&cursor, &table->cls, NULL);
2536         CLS_CURSOR_FOR_EACH (rule, cr, &cursor) {
2537             flow_stats_ds(rule, results);
2538         }
2539     }
2540 }
2541
2542 /* Obtains the NetFlow engine type and engine ID for 'ofproto' into
2543  * '*engine_type' and '*engine_id', respectively. */
2544 void
2545 ofproto_get_netflow_ids(const struct ofproto *ofproto,
2546                         uint8_t *engine_type, uint8_t *engine_id)
2547 {
2548     ofproto->ofproto_class->get_netflow_ids(ofproto, engine_type, engine_id);
2549 }
2550
2551 /* Checks the fault status of CFM for 'ofp_port' within 'ofproto'.  Returns a
2552  * bitmask of 'cfm_fault_reason's to indicate a CFM fault (generally
2553  * indicating a connectivity problem).  Returns zero if CFM is not faulted,
2554  * and -1 if CFM is not enabled on 'port'. */
2555 int
2556 ofproto_port_get_cfm_fault(const struct ofproto *ofproto, uint16_t ofp_port)
2557 {
2558     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
2559     return (ofport && ofproto->ofproto_class->get_cfm_fault
2560             ? ofproto->ofproto_class->get_cfm_fault(ofport)
2561             : -1);
2562 }
2563
2564 /* Gets the MPIDs of the remote maintenance points broadcasting to 'ofp_port'
2565  * within 'ofproto'.  Populates 'rmps' with an array of MPIDs owned by
2566  * 'ofproto', and 'n_rmps' with the number of MPIDs in 'rmps'.  Returns a
2567  * number less than 0 if CFM is not enabled on 'ofp_port'. */
2568 int
2569 ofproto_port_get_cfm_remote_mpids(const struct ofproto *ofproto,
2570                                   uint16_t ofp_port, const uint64_t **rmps,
2571                                   size_t *n_rmps)
2572 {
2573     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
2574
2575     *rmps = NULL;
2576     *n_rmps = 0;
2577     return (ofport && ofproto->ofproto_class->get_cfm_remote_mpids
2578             ? ofproto->ofproto_class->get_cfm_remote_mpids(ofport, rmps,
2579                                                            n_rmps)
2580             : -1);
2581 }
2582
2583 /* Checks the health of the CFM for 'ofp_port' within 'ofproto'.  Returns an
2584  * integer value between 0 and 100 to indicate the health of the port as a
2585  * percentage which is the average of cfm health of all the remote_mpids or
2586  * returns -1 if CFM is not enabled on 'ofport'. */
2587 int
2588 ofproto_port_get_cfm_health(const struct ofproto *ofproto, uint16_t ofp_port)
2589 {
2590     struct ofport *ofport = ofproto_get_port(ofproto, ofp_port);
2591     return (ofport && ofproto->ofproto_class->get_cfm_health
2592             ? ofproto->ofproto_class->get_cfm_health(ofport)
2593             : -1);
2594 }
2595
2596 static enum ofperr
2597 handle_aggregate_stats_request(struct ofconn *ofconn,
2598                                const struct ofp_stats_msg *osm)
2599 {
2600     struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
2601     struct ofputil_flow_stats_request request;
2602     struct ofputil_aggregate_stats stats;
2603     bool unknown_packets, unknown_bytes;
2604     struct ofpbuf *reply;
2605     struct list rules;
2606     struct rule *rule;
2607     enum ofperr error;
2608
2609     error = ofputil_decode_flow_stats_request(&request, &osm->header);
2610     if (error) {
2611         return error;
2612     }
2613
2614     error = collect_rules_loose(ofproto, request.table_id, &request.match,
2615                                 request.cookie, request.cookie_mask,
2616                                 request.out_port, &rules);
2617     if (error) {
2618         return error;
2619     }
2620
2621     memset(&stats, 0, sizeof stats);
2622     unknown_packets = unknown_bytes = false;
2623     LIST_FOR_EACH (rule, ofproto_node, &rules) {
2624         uint64_t packet_count;
2625         uint64_t byte_count;
2626
2627         ofproto->ofproto_class->rule_get_stats(rule, &packet_count,
2628                                                &byte_count);
2629
2630         if (packet_count == UINT64_MAX) {
2631             unknown_packets = true;
2632         } else {
2633             stats.packet_count += packet_count;
2634         }
2635
2636         if (byte_count == UINT64_MAX) {
2637             unknown_bytes = true;
2638         } else {
2639             stats.byte_count += byte_count;
2640         }
2641
2642         stats.flow_count++;
2643     }
2644     if (unknown_packets) {
2645         stats.packet_count = UINT64_MAX;
2646     }
2647     if (unknown_bytes) {
2648         stats.byte_count = UINT64_MAX;
2649     }
2650
2651     reply = ofputil_encode_aggregate_stats_reply(&stats, osm);
2652     ofconn_send_reply(ofconn, reply);
2653
2654     return 0;
2655 }
2656
2657 struct queue_stats_cbdata {
2658     struct ofport *ofport;
2659     struct list replies;
2660 };
2661
2662 static void
2663 put_queue_stats(struct queue_stats_cbdata *cbdata, uint32_t queue_id,
2664                 const struct netdev_queue_stats *stats)
2665 {
2666     struct ofp_queue_stats *reply;
2667
2668     reply = ofputil_append_stats_reply(sizeof *reply, &cbdata->replies);
2669     reply->port_no = htons(cbdata->ofport->pp.port_no);
2670     memset(reply->pad, 0, sizeof reply->pad);
2671     reply->queue_id = htonl(queue_id);
2672     put_32aligned_be64(&reply->tx_bytes, htonll(stats->tx_bytes));
2673     put_32aligned_be64(&reply->tx_packets, htonll(stats->tx_packets));
2674     put_32aligned_be64(&reply->tx_errors, htonll(stats->tx_errors));
2675 }
2676
2677 static void
2678 handle_queue_stats_dump_cb(uint32_t queue_id,
2679                            struct netdev_queue_stats *stats,
2680                            void *cbdata_)
2681 {
2682     struct queue_stats_cbdata *cbdata = cbdata_;
2683
2684     put_queue_stats(cbdata, queue_id, stats);
2685 }
2686
2687 static enum ofperr
2688 handle_queue_stats_for_port(struct ofport *port, uint32_t queue_id,
2689                             struct queue_stats_cbdata *cbdata)
2690 {
2691     cbdata->ofport = port;
2692     if (queue_id == OFPQ_ALL) {
2693         netdev_dump_queue_stats(port->netdev,
2694                                 handle_queue_stats_dump_cb, cbdata);
2695     } else {
2696         struct netdev_queue_stats stats;
2697
2698         if (!netdev_get_queue_stats(port->netdev, queue_id, &stats)) {
2699             put_queue_stats(cbdata, queue_id, &stats);
2700         } else {
2701             return OFPERR_OFPQOFC_BAD_QUEUE;
2702         }
2703     }
2704     return 0;
2705 }
2706
2707 static enum ofperr
2708 handle_queue_stats_request(struct ofconn *ofconn,
2709                            const struct ofp_queue_stats_request *qsr)
2710 {
2711     struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
2712     struct queue_stats_cbdata cbdata;
2713     unsigned int port_no;
2714     struct ofport *port;
2715     uint32_t queue_id;
2716     enum ofperr error;
2717
2718     COVERAGE_INC(ofproto_queue_req);
2719
2720     ofputil_start_stats_reply(&qsr->osm, &cbdata.replies);
2721
2722     port_no = ntohs(qsr->port_no);
2723     queue_id = ntohl(qsr->queue_id);
2724     if (port_no == OFPP_ALL) {
2725         error = OFPERR_OFPQOFC_BAD_QUEUE;
2726         HMAP_FOR_EACH (port, hmap_node, &ofproto->ports) {
2727             if (!handle_queue_stats_for_port(port, queue_id, &cbdata)) {
2728                 error = 0;
2729             }
2730         }
2731     } else {
2732         port = ofproto_get_port(ofproto, port_no);
2733         error = (port
2734                  ? handle_queue_stats_for_port(port, queue_id, &cbdata)
2735                  : OFPERR_OFPQOFC_BAD_PORT);
2736     }
2737     if (!error) {
2738         ofconn_send_replies(ofconn, &cbdata.replies);
2739     } else {
2740         ofpbuf_list_delete(&cbdata.replies);
2741     }
2742
2743     return error;
2744 }
2745
2746 static bool
2747 is_flow_deletion_pending(const struct ofproto *ofproto,
2748                          const struct cls_rule *cls_rule,
2749                          uint8_t table_id)
2750 {
2751     if (!hmap_is_empty(&ofproto->deletions)) {
2752         struct ofoperation *op;
2753
2754         HMAP_FOR_EACH_WITH_HASH (op, hmap_node,
2755                                  cls_rule_hash(cls_rule, table_id),
2756                                  &ofproto->deletions) {
2757             if (cls_rule_equal(cls_rule, &op->rule->cr)) {
2758                 return true;
2759             }
2760         }
2761     }
2762
2763     return false;
2764 }
2765
2766 /* Implements OFPFC_ADD and the cases for OFPFC_MODIFY and OFPFC_MODIFY_STRICT
2767  * in which no matching flow already exists in the flow table.
2768  *
2769  * Adds the flow specified by 'ofm', which is followed by 'n_actions'
2770  * ofp_actions, to the ofproto's flow table.  Returns 0 on success, an OpenFlow
2771  * error code on failure, or OFPROTO_POSTPONE if the operation cannot be
2772  * initiated now but may be retried later.
2773  *
2774  * 'ofconn' is used to retrieve the packet buffer specified in ofm->buffer_id,
2775  * if any. */
2776 static enum ofperr
2777 add_flow(struct ofproto *ofproto, struct ofconn *ofconn,
2778          const struct ofputil_flow_mod *fm, const struct ofp_header *request)
2779 {
2780     struct oftable *table;
2781     struct ofopgroup *group;
2782     struct rule *victim;
2783     struct rule *rule;
2784     int error;
2785
2786     error = check_table_id(ofproto, fm->table_id);
2787     if (error) {
2788         return error;
2789     }
2790
2791     /* Pick table. */
2792     if (fm->table_id == 0xff) {
2793         uint8_t table_id;
2794         if (ofproto->ofproto_class->rule_choose_table) {
2795             error = ofproto->ofproto_class->rule_choose_table(ofproto, &fm->cr,
2796                                                               &table_id);
2797             if (error) {
2798                 return error;
2799             }
2800             assert(table_id < ofproto->n_tables);
2801             table = &ofproto->tables[table_id];
2802         } else {
2803             table = &ofproto->tables[0];
2804         }
2805     } else if (fm->table_id < ofproto->n_tables) {
2806         table = &ofproto->tables[fm->table_id];
2807     } else {
2808         return OFPERR_NXFMFC_BAD_TABLE_ID;
2809     }
2810
2811     if (table->flags & OFTABLE_READONLY) {
2812         return OFPERR_OFPBRC_EPERM;
2813     }
2814
2815     /* Check for overlap, if requested. */
2816     if (fm->flags & OFPFF_CHECK_OVERLAP
2817         && classifier_rule_overlaps(&table->cls, &fm->cr)) {
2818         return OFPERR_OFPFMFC_OVERLAP;
2819     }
2820
2821     /* Serialize against pending deletion. */
2822     if (is_flow_deletion_pending(ofproto, &fm->cr, table - ofproto->tables)) {
2823         return OFPROTO_POSTPONE;
2824     }
2825
2826     /* Allocate new rule. */
2827     rule = ofproto->ofproto_class->rule_alloc();
2828     if (!rule) {
2829         VLOG_WARN_RL(&rl, "%s: failed to create rule (%s)",
2830                      ofproto->name, strerror(error));
2831         return ENOMEM;
2832     }
2833     rule->ofproto = ofproto;
2834     rule->cr = fm->cr;
2835     rule->pending = NULL;
2836     rule->flow_cookie = fm->new_cookie;
2837     rule->created = rule->modified = rule->used = time_msec();
2838     rule->idle_timeout = fm->idle_timeout;
2839     rule->hard_timeout = fm->hard_timeout;
2840     rule->table_id = table - ofproto->tables;
2841     rule->send_flow_removed = (fm->flags & OFPFF_SEND_FLOW_REM) != 0;
2842     rule->actions = ofputil_actions_clone(fm->actions, fm->n_actions);
2843     rule->n_actions = fm->n_actions;
2844     rule->evictable = true;
2845     rule->eviction_group = NULL;
2846
2847     /* Insert new rule. */
2848     victim = oftable_replace_rule(rule);
2849     if (victim && !rule_is_modifiable(victim)) {
2850         error = OFPERR_OFPBRC_EPERM;
2851     } else if (victim && victim->pending) {
2852         error = OFPROTO_POSTPONE;
2853     } else {
2854         struct rule *evict;
2855
2856         if (classifier_count(&table->cls) > table->max_flows) {
2857             bool was_evictable;
2858
2859             was_evictable = rule->evictable;
2860             rule->evictable = false;
2861             evict = choose_rule_to_evict(table);
2862             rule->evictable = was_evictable;
2863
2864             if (!evict) {
2865                 error = OFPERR_OFPFMFC_ALL_TABLES_FULL;
2866                 goto exit;
2867             } else if (evict->pending) {
2868                 error = OFPROTO_POSTPONE;
2869                 goto exit;
2870             }
2871         } else {
2872             evict = NULL;
2873         }
2874
2875         group = ofopgroup_create(ofproto, ofconn, request, fm->buffer_id);
2876         ofoperation_create(group, rule, OFOPERATION_ADD);
2877         rule->pending->victim = victim;
2878
2879         error = ofproto->ofproto_class->rule_construct(rule);
2880         if (error) {
2881             ofoperation_destroy(rule->pending);
2882         } else if (evict) {
2883             delete_flow__(evict, group);
2884         }
2885         ofopgroup_submit(group);
2886     }
2887
2888 exit:
2889     /* Back out if an error occurred. */
2890     if (error) {
2891         oftable_substitute_rule(rule, victim);
2892         ofproto_rule_destroy__(rule);
2893     }
2894     return error;
2895 }
2896 \f
2897 /* OFPFC_MODIFY and OFPFC_MODIFY_STRICT. */
2898
2899 /* Modifies the rules listed in 'rules', changing their actions to match those
2900  * in 'fm'.
2901  *
2902  * 'ofconn' is used to retrieve the packet buffer specified in fm->buffer_id,
2903  * if any.
2904  *
2905  * Returns 0 on success, otherwise an OpenFlow error code. */
2906 static enum ofperr
2907 modify_flows__(struct ofproto *ofproto, struct ofconn *ofconn,
2908                const struct ofputil_flow_mod *fm,
2909                const struct ofp_header *request, struct list *rules)
2910 {
2911     struct ofopgroup *group;
2912     struct rule *rule;
2913     enum ofperr error;
2914
2915     group = ofopgroup_create(ofproto, ofconn, request, fm->buffer_id);
2916     error = OFPERR_OFPBRC_EPERM;
2917     LIST_FOR_EACH (rule, ofproto_node, rules) {
2918         if (rule_is_modifiable(rule)) {
2919             /* At least one rule is modifiable, don't report EPERM error. */
2920             error = 0;
2921         } else {
2922             continue;
2923         }
2924
2925         if (!ofputil_actions_equal(fm->actions, fm->n_actions,
2926                                    rule->actions, rule->n_actions)) {
2927             ofoperation_create(group, rule, OFOPERATION_MODIFY);
2928             rule->pending->actions = rule->actions;
2929             rule->pending->n_actions = rule->n_actions;
2930             rule->actions = ofputil_actions_clone(fm->actions, fm->n_actions);
2931             rule->n_actions = fm->n_actions;
2932             ofproto->ofproto_class->rule_modify_actions(rule);
2933         } else {
2934             rule->modified = time_msec();
2935         }
2936         if (fm->new_cookie != htonll(UINT64_MAX)) {
2937             rule->flow_cookie = fm->new_cookie;
2938         }
2939     }
2940     ofopgroup_submit(group);
2941
2942     return error;
2943 }
2944
2945 /* Implements OFPFC_MODIFY.  Returns 0 on success or an OpenFlow error code on
2946  * failure.
2947  *
2948  * 'ofconn' is used to retrieve the packet buffer specified in fm->buffer_id,
2949  * if any. */
2950 static enum ofperr
2951 modify_flows_loose(struct ofproto *ofproto, struct ofconn *ofconn,
2952                    const struct ofputil_flow_mod *fm,
2953                    const struct ofp_header *request)
2954 {
2955     struct list rules;
2956     int error;
2957
2958     error = collect_rules_loose(ofproto, fm->table_id, &fm->cr,
2959                                 fm->cookie, fm->cookie_mask,
2960                                 OFPP_NONE, &rules);
2961     if (error) {
2962         return error;
2963     } else if (list_is_empty(&rules)) {
2964         return fm->cookie_mask ? 0 : add_flow(ofproto, ofconn, fm, request);
2965     } else {
2966         return modify_flows__(ofproto, ofconn, fm, request, &rules);
2967     }
2968 }
2969
2970 /* Implements OFPFC_MODIFY_STRICT.  Returns 0 on success or an OpenFlow error
2971  * code on failure.
2972  *
2973  * 'ofconn' is used to retrieve the packet buffer specified in fm->buffer_id,
2974  * if any. */
2975 static enum ofperr
2976 modify_flow_strict(struct ofproto *ofproto, struct ofconn *ofconn,
2977                    const struct ofputil_flow_mod *fm,
2978                    const struct ofp_header *request)
2979 {
2980     struct list rules;
2981     int error;
2982
2983     error = collect_rules_strict(ofproto, fm->table_id, &fm->cr,
2984                                  fm->cookie, fm->cookie_mask,
2985                                  OFPP_NONE, &rules);
2986
2987     if (error) {
2988         return error;
2989     } else if (list_is_empty(&rules)) {
2990         return fm->cookie_mask ? 0 : add_flow(ofproto, ofconn, fm, request);
2991     } else {
2992         return list_is_singleton(&rules) ? modify_flows__(ofproto, ofconn,
2993                                                           fm, request, &rules)
2994                                          : 0;
2995     }
2996 }
2997 \f
2998 /* OFPFC_DELETE implementation. */
2999
3000 static void
3001 delete_flow__(struct rule *rule, struct ofopgroup *group)
3002 {
3003     struct ofproto *ofproto = rule->ofproto;
3004
3005     ofproto_rule_send_removed(rule, OFPRR_DELETE);
3006
3007     ofoperation_create(group, rule, OFOPERATION_DELETE);
3008     oftable_remove_rule(rule);
3009     ofproto->ofproto_class->rule_destruct(rule);
3010 }
3011
3012 /* Deletes the rules listed in 'rules'.
3013  *
3014  * Returns 0 on success, otherwise an OpenFlow error code. */
3015 static enum ofperr
3016 delete_flows__(struct ofproto *ofproto, struct ofconn *ofconn,
3017                const struct ofp_header *request, struct list *rules)
3018 {
3019     struct rule *rule, *next;
3020     struct ofopgroup *group;
3021
3022     group = ofopgroup_create(ofproto, ofconn, request, UINT32_MAX);
3023     LIST_FOR_EACH_SAFE (rule, next, ofproto_node, rules) {
3024         delete_flow__(rule, group);
3025     }
3026     ofopgroup_submit(group);
3027
3028     return 0;
3029 }
3030
3031 /* Implements OFPFC_DELETE. */
3032 static enum ofperr
3033 delete_flows_loose(struct ofproto *ofproto, struct ofconn *ofconn,
3034                    const struct ofputil_flow_mod *fm,
3035                    const struct ofp_header *request)
3036 {
3037     struct list rules;
3038     enum ofperr error;
3039
3040     error = collect_rules_loose(ofproto, fm->table_id, &fm->cr,
3041                                 fm->cookie, fm->cookie_mask,
3042                                 fm->out_port, &rules);
3043     return (error ? error
3044             : !list_is_empty(&rules) ? delete_flows__(ofproto, ofconn, request,
3045                                                       &rules)
3046             : 0);
3047 }
3048
3049 /* Implements OFPFC_DELETE_STRICT. */
3050 static enum ofperr
3051 delete_flow_strict(struct ofproto *ofproto, struct ofconn *ofconn,
3052                    const struct ofputil_flow_mod *fm,
3053                    const struct ofp_header *request)
3054 {
3055     struct list rules;
3056     enum ofperr error;
3057
3058     error = collect_rules_strict(ofproto, fm->table_id, &fm->cr,
3059                                  fm->cookie, fm->cookie_mask,
3060                                  fm->out_port, &rules);
3061     return (error ? error
3062             : list_is_singleton(&rules) ? delete_flows__(ofproto, ofconn,
3063                                                          request, &rules)
3064             : 0);
3065 }
3066
3067 static void
3068 ofproto_rule_send_removed(struct rule *rule, uint8_t reason)
3069 {
3070     struct ofputil_flow_removed fr;
3071
3072     if (rule_is_hidden(rule) || !rule->send_flow_removed) {
3073         return;
3074     }
3075
3076     fr.rule = rule->cr;
3077     fr.cookie = rule->flow_cookie;
3078     fr.reason = reason;
3079     calc_flow_duration__(rule->created, time_msec(),
3080                          &fr.duration_sec, &fr.duration_nsec);
3081     fr.idle_timeout = rule->idle_timeout;
3082     rule->ofproto->ofproto_class->rule_get_stats(rule, &fr.packet_count,
3083                                                  &fr.byte_count);
3084
3085     connmgr_send_flow_removed(rule->ofproto->connmgr, &fr);
3086 }
3087
3088 void
3089 ofproto_rule_update_used(struct rule *rule, long long int used)
3090 {
3091     if (used > rule->used) {
3092         struct eviction_group *evg = rule->eviction_group;
3093
3094         rule->used = used;
3095         if (evg) {
3096             heap_change(&evg->rules, &rule->evg_node,
3097                         rule_eviction_priority(rule));
3098         }
3099     }
3100 }
3101
3102 /* Sends an OpenFlow "flow removed" message with the given 'reason' (either
3103  * OFPRR_HARD_TIMEOUT or OFPRR_IDLE_TIMEOUT), and then removes 'rule' from its
3104  * ofproto.
3105  *
3106  * ofproto implementation ->run() functions should use this function to expire
3107  * OpenFlow flows. */
3108 void
3109 ofproto_rule_expire(struct rule *rule, uint8_t reason)
3110 {
3111     struct ofproto *ofproto = rule->ofproto;
3112     struct ofopgroup *group;
3113
3114     assert(reason == OFPRR_HARD_TIMEOUT || reason == OFPRR_IDLE_TIMEOUT);
3115
3116     ofproto_rule_send_removed(rule, reason);
3117
3118     group = ofopgroup_create_unattached(ofproto);
3119     ofoperation_create(group, rule, OFOPERATION_DELETE);
3120     oftable_remove_rule(rule);
3121     ofproto->ofproto_class->rule_destruct(rule);
3122     ofopgroup_submit(group);
3123 }
3124 \f
3125 static enum ofperr
3126 handle_flow_mod(struct ofconn *ofconn, const struct ofp_header *oh)
3127 {
3128     struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
3129     struct ofputil_flow_mod fm;
3130     enum ofperr error;
3131     long long int now;
3132
3133     error = reject_slave_controller(ofconn);
3134     if (error) {
3135         return error;
3136     }
3137
3138     error = ofputil_decode_flow_mod(&fm, oh, ofconn_get_protocol(ofconn));
3139     if (error) {
3140         return error;
3141     }
3142
3143     /* We do not support the OpenFlow 1.0 emergency flow cache, which is not
3144      * required in OpenFlow 1.0.1 and removed from OpenFlow 1.1. */
3145     if (fm.flags & OFPFF_EMERG) {
3146         /* There isn't a good fit for an error code, so just state that the
3147          * flow table is full. */
3148         return OFPERR_OFPFMFC_ALL_TABLES_FULL;
3149     }
3150
3151     error = handle_flow_mod__(ofconn_get_ofproto(ofconn), ofconn, &fm, oh);
3152     if (error) {
3153         return error;
3154     }
3155
3156     /* Record the operation for logging a summary report. */
3157     switch (fm.command) {
3158     case OFPFC_ADD:
3159         ofproto->n_add++;
3160         break;
3161
3162     case OFPFC_MODIFY:
3163     case OFPFC_MODIFY_STRICT:
3164         ofproto->n_modify++;
3165         break;
3166
3167     case OFPFC_DELETE:
3168     case OFPFC_DELETE_STRICT:
3169         ofproto->n_delete++;
3170         break;
3171     }
3172
3173     now = time_msec();
3174     if (ofproto->next_op_report == LLONG_MAX) {
3175         ofproto->first_op = now;
3176         ofproto->next_op_report = MAX(now + 10 * 1000,
3177                                       ofproto->op_backoff);
3178         ofproto->op_backoff = ofproto->next_op_report + 60 * 1000;
3179     }
3180     ofproto->last_op = now;
3181
3182     return 0;
3183 }
3184
3185 static enum ofperr
3186 handle_flow_mod__(struct ofproto *ofproto, struct ofconn *ofconn,
3187                   const struct ofputil_flow_mod *fm,
3188                   const struct ofp_header *oh)
3189 {
3190     if (ofproto->n_pending >= 50) {
3191         assert(!list_is_empty(&ofproto->pending));
3192         return OFPROTO_POSTPONE;
3193     }
3194
3195     switch (fm->command) {
3196     case OFPFC_ADD:
3197         return add_flow(ofproto, ofconn, fm, oh);
3198
3199     case OFPFC_MODIFY:
3200         return modify_flows_loose(ofproto, ofconn, fm, oh);
3201
3202     case OFPFC_MODIFY_STRICT:
3203         return modify_flow_strict(ofproto, ofconn, fm, oh);
3204
3205     case OFPFC_DELETE:
3206         return delete_flows_loose(ofproto, ofconn, fm, oh);
3207
3208     case OFPFC_DELETE_STRICT:
3209         return delete_flow_strict(ofproto, ofconn, fm, oh);
3210
3211     default:
3212         if (fm->command > 0xff) {
3213             VLOG_WARN_RL(&rl, "flow_mod has explicit table_id but "
3214                          "flow_mod_table_id extension is not enabled");
3215         }
3216         return OFPERR_OFPFMFC_BAD_COMMAND;
3217     }
3218 }
3219
3220 static enum ofperr
3221 handle_role_request(struct ofconn *ofconn, const struct ofp_header *oh)
3222 {
3223     struct nx_role_request *nrr = (struct nx_role_request *) oh;
3224     struct nx_role_request *reply;
3225     struct ofpbuf *buf;
3226     uint32_t role;
3227
3228     role = ntohl(nrr->role);
3229     if (role != NX_ROLE_OTHER && role != NX_ROLE_MASTER
3230         && role != NX_ROLE_SLAVE) {
3231         return OFPERR_OFPRRFC_BAD_ROLE;
3232     }
3233
3234     if (ofconn_get_role(ofconn) != role
3235         && ofconn_has_pending_opgroups(ofconn)) {
3236         return OFPROTO_POSTPONE;
3237     }
3238
3239     ofconn_set_role(ofconn, role);
3240
3241     reply = make_nxmsg_xid(sizeof *reply, NXT_ROLE_REPLY, oh->xid, &buf);
3242     reply->role = htonl(role);
3243     ofconn_send_reply(ofconn, buf);
3244
3245     return 0;
3246 }
3247
3248 static enum ofperr
3249 handle_nxt_flow_mod_table_id(struct ofconn *ofconn,
3250                              const struct ofp_header *oh)
3251 {
3252     const struct nx_flow_mod_table_id *msg
3253         = (const struct nx_flow_mod_table_id *) oh;
3254     enum ofputil_protocol cur, next;
3255
3256     cur = ofconn_get_protocol(ofconn);
3257     next = ofputil_protocol_set_tid(cur, msg->set != 0);
3258     ofconn_set_protocol(ofconn, next);
3259
3260     return 0;
3261 }
3262
3263 static enum ofperr
3264 handle_nxt_set_flow_format(struct ofconn *ofconn, const struct ofp_header *oh)
3265 {
3266     const struct nx_set_flow_format *msg
3267         = (const struct nx_set_flow_format *) oh;
3268     enum ofputil_protocol cur, next;
3269     enum ofputil_protocol next_base;
3270
3271     next_base = ofputil_nx_flow_format_to_protocol(ntohl(msg->format));
3272     if (!next_base) {
3273         return OFPERR_OFPBRC_EPERM;
3274     }
3275
3276     cur = ofconn_get_protocol(ofconn);
3277     next = ofputil_protocol_set_base(cur, next_base);
3278     if (cur != next && ofconn_has_pending_opgroups(ofconn)) {
3279         /* Avoid sending async messages in surprising protocol. */
3280         return OFPROTO_POSTPONE;
3281     }
3282
3283     ofconn_set_protocol(ofconn, next);
3284     return 0;
3285 }
3286
3287 static enum ofperr
3288 handle_nxt_set_packet_in_format(struct ofconn *ofconn,
3289                                 const struct ofp_header *oh)
3290 {
3291     const struct nx_set_packet_in_format *msg;
3292     uint32_t format;
3293
3294     msg = (const struct nx_set_packet_in_format *) oh;
3295     format = ntohl(msg->format);
3296     if (format != NXPIF_OPENFLOW10 && format != NXPIF_NXM) {
3297         return OFPERR_OFPBRC_EPERM;
3298     }
3299
3300     if (format != ofconn_get_packet_in_format(ofconn)
3301         && ofconn_has_pending_opgroups(ofconn)) {
3302         /* Avoid sending async message in surprsing packet in format. */
3303         return OFPROTO_POSTPONE;
3304     }
3305
3306     ofconn_set_packet_in_format(ofconn, format);
3307     return 0;
3308 }
3309
3310 static enum ofperr
3311 handle_nxt_set_async_config(struct ofconn *ofconn, const struct ofp_header *oh)
3312 {
3313     const struct nx_async_config *msg = (const struct nx_async_config *) oh;
3314     uint32_t master[OAM_N_TYPES];
3315     uint32_t slave[OAM_N_TYPES];
3316
3317     master[OAM_PACKET_IN] = ntohl(msg->packet_in_mask[0]);
3318     master[OAM_PORT_STATUS] = ntohl(msg->port_status_mask[0]);
3319     master[OAM_FLOW_REMOVED] = ntohl(msg->flow_removed_mask[0]);
3320
3321     slave[OAM_PACKET_IN] = ntohl(msg->packet_in_mask[1]);
3322     slave[OAM_PORT_STATUS] = ntohl(msg->port_status_mask[1]);
3323     slave[OAM_FLOW_REMOVED] = ntohl(msg->flow_removed_mask[1]);
3324
3325     ofconn_set_async_config(ofconn, master, slave);
3326     if (ofconn_get_type(ofconn) == OFCONN_SERVICE &&
3327         !ofconn_get_miss_send_len(ofconn)) {
3328         ofconn_set_miss_send_len(ofconn, OFP_DEFAULT_MISS_SEND_LEN);
3329     }
3330
3331     return 0;
3332 }
3333
3334 static enum ofperr
3335 handle_nxt_set_controller_id(struct ofconn *ofconn,
3336                              const struct ofp_header *oh)
3337 {
3338     const struct nx_controller_id *nci;
3339
3340     nci = (const struct nx_controller_id *) oh;
3341     if (!is_all_zeros(nci->zero, sizeof nci->zero)) {
3342         return OFPERR_NXBRC_MUST_BE_ZERO;
3343     }
3344
3345     ofconn_set_controller_id(ofconn, ntohs(nci->controller_id));
3346     return 0;
3347 }
3348
3349 static enum ofperr
3350 handle_barrier_request(struct ofconn *ofconn, const struct ofp_header *oh)
3351 {
3352     struct ofpbuf *buf;
3353
3354     if (ofconn_has_pending_opgroups(ofconn)) {
3355         return OFPROTO_POSTPONE;
3356     }
3357
3358     make_openflow_xid(sizeof *oh, OFPT10_BARRIER_REPLY, oh->xid, &buf);
3359     ofconn_send_reply(ofconn, buf);
3360     return 0;
3361 }
3362
3363 static enum ofperr
3364 handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg)
3365 {
3366     const struct ofp_header *oh = msg->data;
3367     const struct ofputil_msg_type *type;
3368     enum ofperr error;
3369
3370     error = ofputil_decode_msg_type(oh, &type);
3371     if (error) {
3372         return error;
3373     }
3374
3375     switch (ofputil_msg_type_code(type)) {
3376         /* OpenFlow requests. */
3377     case OFPUTIL_OFPT_ECHO_REQUEST:
3378         return handle_echo_request(ofconn, oh);
3379
3380     case OFPUTIL_OFPT_FEATURES_REQUEST:
3381         return handle_features_request(ofconn, oh);
3382
3383     case OFPUTIL_OFPT_GET_CONFIG_REQUEST:
3384         return handle_get_config_request(ofconn, oh);
3385
3386     case OFPUTIL_OFPT_SET_CONFIG:
3387         return handle_set_config(ofconn, msg->data);
3388
3389     case OFPUTIL_OFPT_PACKET_OUT:
3390         return handle_packet_out(ofconn, msg->data);
3391
3392     case OFPUTIL_OFPT_PORT_MOD:
3393         return handle_port_mod(ofconn, oh);
3394
3395     case OFPUTIL_OFPT_FLOW_MOD:
3396         return handle_flow_mod(ofconn, oh);
3397
3398     case OFPUTIL_OFPT_BARRIER_REQUEST:
3399         return handle_barrier_request(ofconn, oh);
3400
3401         /* OpenFlow replies. */
3402     case OFPUTIL_OFPT_ECHO_REPLY:
3403         return 0;
3404
3405         /* Nicira extension requests. */
3406     case OFPUTIL_NXT_ROLE_REQUEST:
3407         return handle_role_request(ofconn, oh);
3408
3409     case OFPUTIL_NXT_FLOW_MOD_TABLE_ID:
3410         return handle_nxt_flow_mod_table_id(ofconn, oh);
3411
3412     case OFPUTIL_NXT_SET_FLOW_FORMAT:
3413         return handle_nxt_set_flow_format(ofconn, oh);
3414
3415     case OFPUTIL_NXT_SET_PACKET_IN_FORMAT:
3416         return handle_nxt_set_packet_in_format(ofconn, oh);
3417
3418     case OFPUTIL_NXT_SET_CONTROLLER_ID:
3419         return handle_nxt_set_controller_id(ofconn, oh);
3420
3421     case OFPUTIL_NXT_FLOW_MOD:
3422         return handle_flow_mod(ofconn, oh);
3423
3424     case OFPUTIL_NXT_FLOW_AGE:
3425         /* Nothing to do. */
3426         return 0;
3427
3428     case OFPUTIL_NXT_SET_ASYNC_CONFIG:
3429         return handle_nxt_set_async_config(ofconn, oh);
3430
3431         /* Statistics requests. */
3432     case OFPUTIL_OFPST_DESC_REQUEST:
3433         return handle_desc_stats_request(ofconn, msg->data);
3434
3435     case OFPUTIL_OFPST_FLOW_REQUEST:
3436     case OFPUTIL_NXST_FLOW_REQUEST:
3437         return handle_flow_stats_request(ofconn, msg->data);
3438
3439     case OFPUTIL_OFPST_AGGREGATE_REQUEST:
3440     case OFPUTIL_NXST_AGGREGATE_REQUEST:
3441         return handle_aggregate_stats_request(ofconn, msg->data);
3442
3443     case OFPUTIL_OFPST_TABLE_REQUEST:
3444         return handle_table_stats_request(ofconn, msg->data);
3445
3446     case OFPUTIL_OFPST_PORT_REQUEST:
3447         return handle_port_stats_request(ofconn, msg->data);
3448
3449     case OFPUTIL_OFPST_QUEUE_REQUEST:
3450         return handle_queue_stats_request(ofconn, msg->data);
3451
3452     case OFPUTIL_OFPST_PORT_DESC_REQUEST:
3453         return handle_port_desc_stats_request(ofconn, msg->data);
3454
3455     case OFPUTIL_MSG_INVALID:
3456     case OFPUTIL_OFPT_HELLO:
3457     case OFPUTIL_OFPT_ERROR:
3458     case OFPUTIL_OFPT_FEATURES_REPLY:
3459     case OFPUTIL_OFPT_GET_CONFIG_REPLY:
3460     case OFPUTIL_OFPT_PACKET_IN:
3461     case OFPUTIL_OFPT_FLOW_REMOVED:
3462     case OFPUTIL_OFPT_PORT_STATUS:
3463     case OFPUTIL_OFPT_BARRIER_REPLY:
3464     case OFPUTIL_OFPT_QUEUE_GET_CONFIG_REQUEST:
3465     case OFPUTIL_OFPT_QUEUE_GET_CONFIG_REPLY:
3466     case OFPUTIL_OFPST_DESC_REPLY:
3467     case OFPUTIL_OFPST_FLOW_REPLY:
3468     case OFPUTIL_OFPST_QUEUE_REPLY:
3469     case OFPUTIL_OFPST_PORT_REPLY:
3470     case OFPUTIL_OFPST_TABLE_REPLY:
3471     case OFPUTIL_OFPST_AGGREGATE_REPLY:
3472     case OFPUTIL_OFPST_PORT_DESC_REPLY:
3473     case OFPUTIL_NXT_ROLE_REPLY:
3474     case OFPUTIL_NXT_FLOW_REMOVED:
3475     case OFPUTIL_NXT_PACKET_IN:
3476     case OFPUTIL_NXST_FLOW_REPLY:
3477     case OFPUTIL_NXST_AGGREGATE_REPLY:
3478     default:
3479         return (oh->type == OFPT10_STATS_REQUEST ||
3480                 oh->type == OFPT10_STATS_REPLY
3481                 ? OFPERR_OFPBRC_BAD_STAT
3482                 : OFPERR_OFPBRC_BAD_TYPE);
3483     }
3484 }
3485
3486 static bool
3487 handle_openflow(struct ofconn *ofconn, struct ofpbuf *ofp_msg)
3488 {
3489     int error = handle_openflow__(ofconn, ofp_msg);
3490     if (error && error != OFPROTO_POSTPONE) {
3491         ofconn_send_error(ofconn, ofp_msg->data, error);
3492     }
3493     COVERAGE_INC(ofproto_recv_openflow);
3494     return error != OFPROTO_POSTPONE;
3495 }
3496 \f
3497 /* Asynchronous operations. */
3498
3499 /* Creates and returns a new ofopgroup that is not associated with any
3500  * OpenFlow connection.
3501  *
3502  * The caller should add operations to the returned group with
3503  * ofoperation_create() and then submit it with ofopgroup_submit(). */
3504 static struct ofopgroup *
3505 ofopgroup_create_unattached(struct ofproto *ofproto)
3506 {
3507     struct ofopgroup *group = xzalloc(sizeof *group);
3508     group->ofproto = ofproto;
3509     list_init(&group->ofproto_node);
3510     list_init(&group->ops);
3511     list_init(&group->ofconn_node);
3512     return group;
3513 }
3514
3515 /* Creates and returns a new ofopgroup for 'ofproto'.
3516  *
3517  * If 'ofconn' is NULL, the new ofopgroup is not associated with any OpenFlow
3518  * connection.  The 'request' and 'buffer_id' arguments are ignored.
3519  *
3520  * If 'ofconn' is nonnull, then the new ofopgroup is associated with 'ofconn'.
3521  * If the ofopgroup eventually fails, then the error reply will include
3522  * 'request'.  If the ofopgroup eventually succeeds, then the packet with
3523  * buffer id 'buffer_id' on 'ofconn' will be sent by 'ofconn''s ofproto.
3524  *
3525  * The caller should add operations to the returned group with
3526  * ofoperation_create() and then submit it with ofopgroup_submit(). */
3527 static struct ofopgroup *
3528 ofopgroup_create(struct ofproto *ofproto, struct ofconn *ofconn,
3529                  const struct ofp_header *request, uint32_t buffer_id)
3530 {
3531     struct ofopgroup *group = ofopgroup_create_unattached(ofproto);
3532     if (ofconn) {
3533         size_t request_len = ntohs(request->length);
3534
3535         assert(ofconn_get_ofproto(ofconn) == ofproto);
3536
3537         ofconn_add_opgroup(ofconn, &group->ofconn_node);
3538         group->ofconn = ofconn;
3539         group->request = xmemdup(request, MIN(request_len, 64));
3540         group->buffer_id = buffer_id;
3541     }
3542     return group;
3543 }
3544
3545 /* Submits 'group' for processing.
3546  *
3547  * If 'group' contains no operations (e.g. none were ever added, or all of the
3548  * ones that were added completed synchronously), then it is destroyed
3549  * immediately.  Otherwise it is added to the ofproto's list of pending
3550  * groups. */
3551 static void
3552 ofopgroup_submit(struct ofopgroup *group)
3553 {
3554     if (list_is_empty(&group->ops)) {
3555         ofopgroup_destroy(group);
3556     } else {
3557         list_push_back(&group->ofproto->pending, &group->ofproto_node);
3558         group->ofproto->n_pending++;
3559     }
3560 }
3561
3562 static void
3563 ofopgroup_destroy(struct ofopgroup *group)
3564 {
3565     assert(list_is_empty(&group->ops));
3566     if (!list_is_empty(&group->ofproto_node)) {
3567         assert(group->ofproto->n_pending > 0);
3568         group->ofproto->n_pending--;
3569         list_remove(&group->ofproto_node);
3570     }
3571     if (!list_is_empty(&group->ofconn_node)) {
3572         list_remove(&group->ofconn_node);
3573         if (group->error) {
3574             ofconn_send_error(group->ofconn, group->request, group->error);
3575         }
3576         connmgr_retry(group->ofproto->connmgr);
3577     }
3578     free(group->request);
3579     free(group);
3580 }
3581
3582 /* Initiates a new operation on 'rule', of the specified 'type', within
3583  * 'group'.  Prior to calling, 'rule' must not have any pending operation. */
3584 static void
3585 ofoperation_create(struct ofopgroup *group, struct rule *rule,
3586                    enum ofoperation_type type)
3587 {
3588     struct ofproto *ofproto = group->ofproto;
3589     struct ofoperation *op;
3590
3591     assert(!rule->pending);
3592
3593     op = rule->pending = xzalloc(sizeof *op);
3594     op->group = group;
3595     list_push_back(&group->ops, &op->group_node);
3596     op->rule = rule;
3597     op->type = type;
3598     op->flow_cookie = rule->flow_cookie;
3599
3600     if (type == OFOPERATION_DELETE) {
3601         hmap_insert(&ofproto->deletions, &op->hmap_node,
3602                     cls_rule_hash(&rule->cr, rule->table_id));
3603     }
3604 }
3605
3606 static void
3607 ofoperation_destroy(struct ofoperation *op)
3608 {
3609     struct ofopgroup *group = op->group;
3610
3611     if (op->rule) {
3612         op->rule->pending = NULL;
3613     }
3614     if (op->type == OFOPERATION_DELETE) {
3615         hmap_remove(&group->ofproto->deletions, &op->hmap_node);
3616     }
3617     list_remove(&op->group_node);
3618     free(op->actions);
3619     free(op);
3620
3621     if (list_is_empty(&group->ops) && !list_is_empty(&group->ofproto_node)) {
3622         ofopgroup_destroy(group);
3623     }
3624 }
3625
3626 /* Indicates that 'op' completed with status 'error', which is either 0 to
3627  * indicate success or an OpenFlow error code on failure.
3628  *
3629  * If 'error' is 0, indicating success, the operation will be committed
3630  * permanently to the flow table.  There is one interesting subcase:
3631  *
3632  *   - If 'op' is an "add flow" operation that is replacing an existing rule in
3633  *     the flow table (the "victim" rule) by a new one, then the caller must
3634  *     have uninitialized any derived state in the victim rule, as in step 5 in
3635  *     the "Life Cycle" in ofproto/ofproto-provider.h.  ofoperation_complete()
3636  *     performs steps 6 and 7 for the victim rule, most notably by calling its
3637  *     ->rule_dealloc() function.
3638  *
3639  * If 'error' is nonzero, then generally the operation will be rolled back:
3640  *
3641  *   - If 'op' is an "add flow" operation, ofproto removes the new rule or
3642  *     restores the original rule.  The caller must have uninitialized any
3643  *     derived state in the new rule, as in step 5 of in the "Life Cycle" in
3644  *     ofproto/ofproto-provider.h.  ofoperation_complete() performs steps 6 and
3645  *     and 7 for the new rule, calling its ->rule_dealloc() function.
3646  *
3647  *   - If 'op' is a "modify flow" operation, ofproto restores the original
3648  *     actions.
3649  *
3650  *   - 'op' must not be a "delete flow" operation.  Removing a rule is not
3651  *     allowed to fail.  It must always succeed.
3652  *
3653  * Please see the large comment in ofproto/ofproto-provider.h titled
3654  * "Asynchronous Operation Support" for more information. */
3655 void
3656 ofoperation_complete(struct ofoperation *op, enum ofperr error)
3657 {
3658     struct ofopgroup *group = op->group;
3659     struct rule *rule = op->rule;
3660     struct ofproto *ofproto = rule->ofproto;
3661
3662     assert(rule->pending == op);
3663
3664     if (!error
3665         && !group->error
3666         && op->type != OFOPERATION_DELETE
3667         && group->ofconn
3668         && group->buffer_id != UINT32_MAX
3669         && list_is_singleton(&op->group_node)) {
3670         struct ofpbuf *packet;
3671         uint16_t in_port;
3672
3673         error = ofconn_pktbuf_retrieve(group->ofconn, group->buffer_id,
3674                                        &packet, &in_port);
3675         if (packet) {
3676             assert(!error);
3677             error = rule_execute(rule, in_port, packet);
3678         }
3679     }
3680     if (!group->error) {
3681         group->error = error;
3682     }
3683
3684     switch (op->type) {
3685     case OFOPERATION_ADD:
3686         if (!error) {
3687             ofproto_rule_destroy__(op->victim);
3688             if ((rule->cr.wc.vlan_tci_mask & htons(VLAN_VID_MASK))
3689                 == htons(VLAN_VID_MASK)) {
3690                 if (ofproto->vlan_bitmap) {
3691                     uint16_t vid = vlan_tci_to_vid(rule->cr.flow.vlan_tci);
3692
3693                     if (!bitmap_is_set(ofproto->vlan_bitmap, vid)) {
3694                         bitmap_set1(ofproto->vlan_bitmap, vid);
3695                         ofproto->vlans_changed = true;
3696                     }
3697                 } else {
3698                     ofproto->vlans_changed = true;
3699                 }
3700             }
3701         } else {
3702             oftable_substitute_rule(rule, op->victim);
3703             ofproto_rule_destroy__(rule);
3704             op->rule = NULL;
3705         }
3706         break;
3707
3708     case OFOPERATION_DELETE:
3709         assert(!error);
3710         ofproto_rule_destroy__(rule);
3711         op->rule = NULL;
3712         break;
3713
3714     case OFOPERATION_MODIFY:
3715         if (!error) {
3716             rule->modified = time_msec();
3717         } else {
3718             free(rule->actions);
3719             rule->actions = op->actions;
3720             rule->n_actions = op->n_actions;
3721             op->actions = NULL;
3722         }
3723         break;
3724
3725     default:
3726         NOT_REACHED();
3727     }
3728     ofoperation_destroy(op);
3729 }
3730
3731 struct rule *
3732 ofoperation_get_victim(struct ofoperation *op)
3733 {
3734     assert(op->type == OFOPERATION_ADD);
3735     return op->victim;
3736 }
3737 \f
3738 static uint64_t
3739 pick_datapath_id(const struct ofproto *ofproto)
3740 {
3741     const struct ofport *port;
3742
3743     port = ofproto_get_port(ofproto, OFPP_LOCAL);
3744     if (port) {
3745         uint8_t ea[ETH_ADDR_LEN];
3746         int error;
3747
3748         error = netdev_get_etheraddr(port->netdev, ea);
3749         if (!error) {
3750             return eth_addr_to_uint64(ea);
3751         }
3752         VLOG_WARN("could not get MAC address for %s (%s)",
3753                   netdev_get_name(port->netdev), strerror(error));
3754     }
3755     return ofproto->fallback_dpid;
3756 }
3757
3758 static uint64_t
3759 pick_fallback_dpid(void)
3760 {
3761     uint8_t ea[ETH_ADDR_LEN];
3762     eth_addr_nicira_random(ea);
3763     return eth_addr_to_uint64(ea);
3764 }
3765 \f
3766 /* Table overflow policy. */
3767
3768 /* Chooses and returns a rule to evict from 'table'.  Returns NULL if the table
3769  * is not configured to evict rules or if the table contains no evictable
3770  * rules.  (Rules with 'evictable' set to false or with no timeouts are not
3771  * evictable.) */
3772 static struct rule *
3773 choose_rule_to_evict(struct oftable *table)
3774 {
3775     struct eviction_group *evg;
3776
3777     if (!table->eviction_fields) {
3778         return NULL;
3779     }
3780
3781     /* In the common case, the outer and inner loops here will each be entered
3782      * exactly once:
3783      *
3784      *   - The inner loop normally "return"s in its first iteration.  If the
3785      *     eviction group has any evictable rules, then it always returns in
3786      *     some iteration.
3787      *
3788      *   - The outer loop only iterates more than once if the largest eviction
3789      *     group has no evictable rules.
3790      *
3791      *   - The outer loop can exit only if table's 'max_flows' is all filled up
3792      *     by unevictable rules'. */
3793     HEAP_FOR_EACH (evg, size_node, &table->eviction_groups_by_size) {
3794         struct rule *rule;
3795
3796         HEAP_FOR_EACH (rule, evg_node, &evg->rules) {
3797             if (rule->evictable) {
3798                 return rule;
3799             }
3800         }
3801     }
3802
3803     return NULL;
3804 }
3805
3806 /* Searches 'ofproto' for tables that have more flows than their configured
3807  * maximum and that have flow eviction enabled, and evicts as many flows as
3808  * necessary and currently feasible from them.
3809  *
3810  * This triggers only when an OpenFlow table has N flows in it and then the
3811  * client configures a maximum number of flows less than N. */
3812 static void
3813 ofproto_evict(struct ofproto *ofproto)
3814 {
3815     struct ofopgroup *group;
3816     struct oftable *table;
3817
3818     group = ofopgroup_create_unattached(ofproto);
3819     OFPROTO_FOR_EACH_TABLE (table, ofproto) {
3820         while (classifier_count(&table->cls) > table->max_flows
3821                && table->eviction_fields) {
3822             struct rule *rule;
3823
3824             rule = choose_rule_to_evict(table);
3825             if (!rule || rule->pending) {
3826                 break;
3827             }
3828
3829             ofoperation_create(group, rule, OFOPERATION_DELETE);
3830             oftable_remove_rule(rule);
3831             ofproto->ofproto_class->rule_destruct(rule);
3832         }
3833     }
3834     ofopgroup_submit(group);
3835 }
3836 \f
3837 /* Eviction groups. */
3838
3839 /* Returns the priority to use for an eviction_group that contains 'n_rules'
3840  * rules.  The priority contains low-order random bits to ensure that eviction
3841  * groups with the same number of rules are prioritized randomly. */
3842 static uint32_t
3843 eviction_group_priority(size_t n_rules)
3844 {
3845     uint16_t size = MIN(UINT16_MAX, n_rules);
3846     return (size << 16) | random_uint16();
3847 }
3848
3849 /* Updates 'evg', an eviction_group within 'table', following a change that
3850  * adds or removes rules in 'evg'. */
3851 static void
3852 eviction_group_resized(struct oftable *table, struct eviction_group *evg)
3853 {
3854     heap_change(&table->eviction_groups_by_size, &evg->size_node,
3855                 eviction_group_priority(heap_count(&evg->rules)));
3856 }
3857
3858 /* Destroys 'evg', an eviction_group within 'table':
3859  *
3860  *   - Removes all the rules, if any, from 'evg'.  (It doesn't destroy the
3861  *     rules themselves, just removes them from the eviction group.)
3862  *
3863  *   - Removes 'evg' from 'table'.
3864  *
3865  *   - Frees 'evg'. */
3866 static void
3867 eviction_group_destroy(struct oftable *table, struct eviction_group *evg)
3868 {
3869     while (!heap_is_empty(&evg->rules)) {
3870         struct rule *rule;
3871
3872         rule = CONTAINER_OF(heap_pop(&evg->rules), struct rule, evg_node);
3873         rule->eviction_group = NULL;
3874     }
3875     hmap_remove(&table->eviction_groups_by_id, &evg->id_node);
3876     heap_remove(&table->eviction_groups_by_size, &evg->size_node);
3877     heap_destroy(&evg->rules);
3878     free(evg);
3879 }
3880
3881 /* Removes 'rule' from its eviction group, if any. */
3882 static void
3883 eviction_group_remove_rule(struct rule *rule)
3884 {
3885     if (rule->eviction_group) {
3886         struct oftable *table = &rule->ofproto->tables[rule->table_id];
3887         struct eviction_group *evg = rule->eviction_group;
3888
3889         rule->eviction_group = NULL;
3890         heap_remove(&evg->rules, &rule->evg_node);
3891         if (heap_is_empty(&evg->rules)) {
3892             eviction_group_destroy(table, evg);
3893         } else {
3894             eviction_group_resized(table, evg);
3895         }
3896     }
3897 }
3898
3899 /* Hashes the 'rule''s values for the eviction_fields of 'rule''s table, and
3900  * returns the hash value. */
3901 static uint32_t
3902 eviction_group_hash_rule(struct rule *rule)
3903 {
3904     struct oftable *table = &rule->ofproto->tables[rule->table_id];
3905     const struct mf_subfield *sf;
3906     uint32_t hash;
3907
3908     hash = table->eviction_group_id_basis;
3909     for (sf = table->eviction_fields;
3910          sf < &table->eviction_fields[table->n_eviction_fields];
3911          sf++)
3912     {
3913         if (mf_are_prereqs_ok(sf->field, &rule->cr.flow)) {
3914             union mf_value value;
3915
3916             mf_get_value(sf->field, &rule->cr.flow, &value);
3917             if (sf->ofs) {
3918                 bitwise_zero(&value, sf->field->n_bytes, 0, sf->ofs);
3919             }
3920             if (sf->ofs + sf->n_bits < sf->field->n_bytes * 8) {
3921                 unsigned int start = sf->ofs + sf->n_bits;
3922                 bitwise_zero(&value, sf->field->n_bytes, start,
3923                              sf->field->n_bytes * 8 - start);
3924             }
3925             hash = hash_bytes(&value, sf->field->n_bytes, hash);
3926         } else {
3927             hash = hash_int(hash, 0);
3928         }
3929     }
3930
3931     return hash;
3932 }
3933
3934 /* Returns an eviction group within 'table' with the given 'id', creating one
3935  * if necessary. */
3936 static struct eviction_group *
3937 eviction_group_find(struct oftable *table, uint32_t id)
3938 {
3939     struct eviction_group *evg;
3940
3941     HMAP_FOR_EACH_WITH_HASH (evg, id_node, id, &table->eviction_groups_by_id) {
3942         return evg;
3943     }
3944
3945     evg = xmalloc(sizeof *evg);
3946     hmap_insert(&table->eviction_groups_by_id, &evg->id_node, id);
3947     heap_insert(&table->eviction_groups_by_size, &evg->size_node,
3948                 eviction_group_priority(0));
3949     heap_init(&evg->rules);
3950
3951     return evg;
3952 }
3953
3954 /* Returns an eviction priority for 'rule'.  The return value should be
3955  * interpreted so that higher priorities make a rule more attractive candidates
3956  * for eviction. */
3957 static uint32_t
3958 rule_eviction_priority(struct rule *rule)
3959 {
3960     long long int hard_expiration;
3961     long long int idle_expiration;
3962     long long int expiration;
3963     uint32_t expiration_offset;
3964
3965     /* Calculate time of expiration. */
3966     hard_expiration = (rule->hard_timeout
3967                        ? rule->modified + rule->hard_timeout * 1000
3968                        : LLONG_MAX);
3969     idle_expiration = (rule->idle_timeout
3970                        ? rule->used + rule->idle_timeout * 1000
3971                        : LLONG_MAX);
3972     expiration = MIN(hard_expiration, idle_expiration);
3973     if (expiration == LLONG_MAX) {
3974         return 0;
3975     }
3976
3977     /* Calculate the time of expiration as a number of (approximate) seconds
3978      * after program startup.
3979      *
3980      * This should work OK for program runs that last UINT32_MAX seconds or
3981      * less.  Therefore, please restart OVS at least once every 136 years. */
3982     expiration_offset = (expiration >> 10) - (time_boot_msec() >> 10);
3983
3984     /* Invert the expiration offset because we're using a max-heap. */
3985     return UINT32_MAX - expiration_offset;
3986 }
3987
3988 /* Adds 'rule' to an appropriate eviction group for its oftable's
3989  * configuration.  Does nothing if 'rule''s oftable doesn't have eviction
3990  * enabled, or if 'rule' is a permanent rule (one that will never expire on its
3991  * own).
3992  *
3993  * The caller must ensure that 'rule' is not already in an eviction group. */
3994 static void
3995 eviction_group_add_rule(struct rule *rule)
3996 {
3997     struct ofproto *ofproto = rule->ofproto;
3998     struct oftable *table = &ofproto->tables[rule->table_id];
3999
4000     if (table->eviction_fields
4001         && (rule->hard_timeout || rule->idle_timeout)) {
4002         struct eviction_group *evg;
4003
4004         evg = eviction_group_find(table, eviction_group_hash_rule(rule));
4005
4006         rule->eviction_group = evg;
4007         heap_insert(&evg->rules, &rule->evg_node,
4008                     rule_eviction_priority(rule));
4009         eviction_group_resized(table, evg);
4010     }
4011 }
4012 \f
4013 /* oftables. */
4014
4015 /* Initializes 'table'. */
4016 static void
4017 oftable_init(struct oftable *table)
4018 {
4019     memset(table, 0, sizeof *table);
4020     classifier_init(&table->cls);
4021     table->max_flows = UINT_MAX;
4022 }
4023
4024 /* Destroys 'table', including its classifier and eviction groups.
4025  *
4026  * The caller is responsible for freeing 'table' itself. */
4027 static void
4028 oftable_destroy(struct oftable *table)
4029 {
4030     assert(classifier_is_empty(&table->cls));
4031     oftable_disable_eviction(table);
4032     classifier_destroy(&table->cls);
4033     free(table->name);
4034 }
4035
4036 /* Changes the name of 'table' to 'name'.  If 'name' is NULL or the empty
4037  * string, then 'table' will use its default name.
4038  *
4039  * This only affects the name exposed for a table exposed through the OpenFlow
4040  * OFPST_TABLE (as printed by "ovs-ofctl dump-tables"). */
4041 static void
4042 oftable_set_name(struct oftable *table, const char *name)
4043 {
4044     if (name && name[0]) {
4045         int len = strnlen(name, OFP_MAX_TABLE_NAME_LEN);
4046         if (!table->name || strncmp(name, table->name, len)) {
4047             free(table->name);
4048             table->name = xmemdup0(name, len);
4049         }
4050     } else {
4051         free(table->name);
4052         table->name = NULL;
4053     }
4054 }
4055
4056 /* oftables support a choice of two policies when adding a rule would cause the
4057  * number of flows in the table to exceed the configured maximum number: either
4058  * they can refuse to add the new flow or they can evict some existing flow.
4059  * This function configures the former policy on 'table'. */
4060 static void
4061 oftable_disable_eviction(struct oftable *table)
4062 {
4063     if (table->eviction_fields) {
4064         struct eviction_group *evg, *next;
4065
4066         HMAP_FOR_EACH_SAFE (evg, next, id_node,
4067                             &table->eviction_groups_by_id) {
4068             eviction_group_destroy(table, evg);
4069         }
4070         hmap_destroy(&table->eviction_groups_by_id);
4071         heap_destroy(&table->eviction_groups_by_size);
4072
4073         free(table->eviction_fields);
4074         table->eviction_fields = NULL;
4075         table->n_eviction_fields = 0;
4076     }
4077 }
4078
4079 /* oftables support a choice of two policies when adding a rule would cause the
4080  * number of flows in the table to exceed the configured maximum number: either
4081  * they can refuse to add the new flow or they can evict some existing flow.
4082  * This function configures the latter policy on 'table', with fairness based
4083  * on the values of the 'n_fields' fields specified in 'fields'.  (Specifying
4084  * 'n_fields' as 0 disables fairness.) */
4085 static void
4086 oftable_enable_eviction(struct oftable *table,
4087                         const struct mf_subfield *fields, size_t n_fields)
4088 {
4089     struct cls_cursor cursor;
4090     struct rule *rule;
4091
4092     if (table->eviction_fields
4093         && n_fields == table->n_eviction_fields
4094         && (!n_fields
4095             || !memcmp(fields, table->eviction_fields,
4096                        n_fields * sizeof *fields))) {
4097         /* No change. */
4098         return;
4099     }
4100
4101     oftable_disable_eviction(table);
4102
4103     table->n_eviction_fields = n_fields;
4104     table->eviction_fields = xmemdup(fields, n_fields * sizeof *fields);
4105
4106     table->eviction_group_id_basis = random_uint32();
4107     hmap_init(&table->eviction_groups_by_id);
4108     heap_init(&table->eviction_groups_by_size);
4109
4110     cls_cursor_init(&cursor, &table->cls, NULL);
4111     CLS_CURSOR_FOR_EACH (rule, cr, &cursor) {
4112         eviction_group_add_rule(rule);
4113     }
4114 }
4115
4116 /* Removes 'rule' from the oftable that contains it. */
4117 static void
4118 oftable_remove_rule(struct rule *rule)
4119 {
4120     struct ofproto *ofproto = rule->ofproto;
4121     struct oftable *table = &ofproto->tables[rule->table_id];
4122
4123     classifier_remove(&table->cls, &rule->cr);
4124     eviction_group_remove_rule(rule);
4125 }
4126
4127 /* Inserts 'rule' into its oftable.  Removes any existing rule from 'rule''s
4128  * oftable that has an identical cls_rule.  Returns the rule that was removed,
4129  * if any, and otherwise NULL. */
4130 static struct rule *
4131 oftable_replace_rule(struct rule *rule)
4132 {
4133     struct ofproto *ofproto = rule->ofproto;
4134     struct oftable *table = &ofproto->tables[rule->table_id];
4135     struct rule *victim;
4136
4137     victim = rule_from_cls_rule(classifier_replace(&table->cls, &rule->cr));
4138     if (victim) {
4139         eviction_group_remove_rule(victim);
4140     }
4141     eviction_group_add_rule(rule);
4142     return victim;
4143 }
4144
4145 /* Removes 'old' from its oftable then, if 'new' is nonnull, inserts 'new'. */
4146 static void
4147 oftable_substitute_rule(struct rule *old, struct rule *new)
4148 {
4149     if (new) {
4150         oftable_replace_rule(new);
4151     } else {
4152         oftable_remove_rule(old);
4153     }
4154 }
4155 \f
4156 /* unixctl commands. */
4157
4158 struct ofproto *
4159 ofproto_lookup(const char *name)
4160 {
4161     struct ofproto *ofproto;
4162
4163     HMAP_FOR_EACH_WITH_HASH (ofproto, hmap_node, hash_string(name, 0),
4164                              &all_ofprotos) {
4165         if (!strcmp(ofproto->name, name)) {
4166             return ofproto;
4167         }
4168     }
4169     return NULL;
4170 }
4171
4172 static void
4173 ofproto_unixctl_list(struct unixctl_conn *conn, int argc OVS_UNUSED,
4174                      const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
4175 {
4176     struct ofproto *ofproto;
4177     struct ds results;
4178
4179     ds_init(&results);
4180     HMAP_FOR_EACH (ofproto, hmap_node, &all_ofprotos) {
4181         ds_put_format(&results, "%s\n", ofproto->name);
4182     }
4183     unixctl_command_reply(conn, ds_cstr(&results));
4184     ds_destroy(&results);
4185 }
4186
4187 static void
4188 ofproto_unixctl_init(void)
4189 {
4190     static bool registered;
4191     if (registered) {
4192         return;
4193     }
4194     registered = true;
4195
4196     unixctl_command_register("ofproto/list", "", 0, 0,
4197                              ofproto_unixctl_list, NULL);
4198 }
4199 \f
4200 /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
4201  *
4202  * This is deprecated.  It is only for compatibility with broken device drivers
4203  * in old versions of Linux that do not properly support VLANs when VLAN
4204  * devices are not used.  When broken device drivers are no longer in
4205  * widespread use, we will delete these interfaces. */
4206
4207 /* Sets a 1-bit in the 4096-bit 'vlan_bitmap' for each VLAN ID that is matched
4208  * (exactly) by an OpenFlow rule in 'ofproto'. */
4209 void
4210 ofproto_get_vlan_usage(struct ofproto *ofproto, unsigned long int *vlan_bitmap)
4211 {
4212     const struct oftable *oftable;
4213
4214     free(ofproto->vlan_bitmap);
4215     ofproto->vlan_bitmap = bitmap_allocate(4096);
4216     ofproto->vlans_changed = false;
4217
4218     OFPROTO_FOR_EACH_TABLE (oftable, ofproto) {
4219         const struct cls_table *table;
4220
4221         HMAP_FOR_EACH (table, hmap_node, &oftable->cls.tables) {
4222             if ((table->wc.vlan_tci_mask & htons(VLAN_VID_MASK))
4223                 == htons(VLAN_VID_MASK)) {
4224                 const struct cls_rule *rule;
4225
4226                 HMAP_FOR_EACH (rule, hmap_node, &table->rules) {
4227                     uint16_t vid = vlan_tci_to_vid(rule->flow.vlan_tci);
4228                     bitmap_set1(vlan_bitmap, vid);
4229                     bitmap_set1(ofproto->vlan_bitmap, vid);
4230                 }
4231             }
4232         }
4233     }
4234 }
4235
4236 /* Returns true if new VLANs have come into use by the flow table since the
4237  * last call to ofproto_get_vlan_usage().
4238  *
4239  * We don't track when old VLANs stop being used. */
4240 bool
4241 ofproto_has_vlan_usage_changed(const struct ofproto *ofproto)
4242 {
4243     return ofproto->vlans_changed;
4244 }
4245
4246 /* Configures a VLAN splinter binding between the ports identified by OpenFlow
4247  * port numbers 'vlandev_ofp_port' and 'realdev_ofp_port'.  If
4248  * 'realdev_ofp_port' is nonzero, then the VLAN device is enslaved to the real
4249  * device as a VLAN splinter for VLAN ID 'vid'.  If 'realdev_ofp_port' is zero,
4250  * then the VLAN device is un-enslaved. */
4251 int
4252 ofproto_port_set_realdev(struct ofproto *ofproto, uint16_t vlandev_ofp_port,
4253                          uint16_t realdev_ofp_port, int vid)
4254 {
4255     struct ofport *ofport;
4256     int error;
4257
4258     assert(vlandev_ofp_port != realdev_ofp_port);
4259
4260     ofport = ofproto_get_port(ofproto, vlandev_ofp_port);
4261     if (!ofport) {
4262         VLOG_WARN("%s: cannot set realdev on nonexistent port %"PRIu16,
4263                   ofproto->name, vlandev_ofp_port);
4264         return EINVAL;
4265     }
4266
4267     if (!ofproto->ofproto_class->set_realdev) {
4268         if (!vlandev_ofp_port) {
4269             return 0;
4270         }
4271         VLOG_WARN("%s: vlan splinters not supported", ofproto->name);
4272         return EOPNOTSUPP;
4273     }
4274
4275     error = ofproto->ofproto_class->set_realdev(ofport, realdev_ofp_port, vid);
4276     if (error) {
4277         VLOG_WARN("%s: setting realdev on port %"PRIu16" (%s) failed (%s)",
4278                   ofproto->name, vlandev_ofp_port,
4279                   netdev_get_name(ofport->netdev), strerror(error));
4280     }
4281     return error;
4282 }