Merge citrix branch into master.
[openvswitch] / ofproto / ofproto.c
1 /*
2  * Copyright (c) 2009 Nicira Networks.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at:
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 #include <config.h>
18 #include "ofproto.h"
19 #include <errno.h>
20 #include <inttypes.h>
21 #include <net/if.h>
22 #include <netinet/in.h>
23 #include <stdbool.h>
24 #include <stdlib.h>
25 #include "classifier.h"
26 #include "coverage.h"
27 #include "discovery.h"
28 #include "dpif.h"
29 #include "dynamic-string.h"
30 #include "executer.h"
31 #include "fail-open.h"
32 #include "in-band.h"
33 #include "mac-learning.h"
34 #include "netdev.h"
35 #include "netflow.h"
36 #include "odp-util.h"
37 #include "ofp-print.h"
38 #include "ofpbuf.h"
39 #include "openflow/nicira-ext.h"
40 #include "openflow/openflow.h"
41 #include "openflow/openflow-mgmt.h"
42 #include "openvswitch/datapath-protocol.h"
43 #include "packets.h"
44 #include "pinsched.h"
45 #include "pktbuf.h"
46 #include "poll-loop.h"
47 #include "port-array.h"
48 #include "rconn.h"
49 #include "shash.h"
50 #include "status.h"
51 #include "stp.h"
52 #include "svec.h"
53 #include "tag.h"
54 #include "timeval.h"
55 #include "unixctl.h"
56 #include "vconn.h"
57 #include "vconn-ssl.h"
58 #include "xtoxll.h"
59
60 #define THIS_MODULE VLM_ofproto
61 #include "vlog.h"
62
63 enum {
64     DP_GROUP_FLOOD = 0,
65     DP_GROUP_ALL = 1
66 };
67
68 enum {
69     TABLEID_HASH = 0,
70     TABLEID_CLASSIFIER = 1
71 };
72
73 struct ofport {
74     struct netdev *netdev;
75     struct ofp_phy_port opp;    /* In host byte order. */
76 };
77
78 static void ofport_free(struct ofport *);
79 static void hton_ofp_phy_port(struct ofp_phy_port *);
80
81 static int xlate_actions(const union ofp_action *in, size_t n_in,
82                          const flow_t *flow, struct ofproto *ofproto,
83                          const struct ofpbuf *packet,
84                          struct odp_actions *out, tag_type *tags,
85                          bool *may_setup_flow);
86
87 struct rule {
88     struct cls_rule cr;
89
90     uint16_t idle_timeout;      /* In seconds from time of last use. */
91     uint16_t hard_timeout;      /* In seconds from time of creation. */
92     long long int used;         /* Last-used time (0 if never used). */
93     long long int created;      /* Creation time. */
94     uint64_t packet_count;      /* Number of packets received. */
95     uint64_t byte_count;        /* Number of bytes received. */
96     uint64_t accounted_bytes;   /* Number of bytes passed to account_cb. */
97     uint8_t tcp_flags;          /* Bitwise-OR of all TCP flags seen. */
98     uint8_t ip_tos;             /* Last-seen IP type-of-service. */
99     tag_type tags;              /* Tags (set only by hooks). */
100
101     /* If 'super' is non-NULL, this rule is a subrule, that is, it is an
102      * exact-match rule (having cr.wc.wildcards of 0) generated from the
103      * wildcard rule 'super'.  In this case, 'list' is an element of the
104      * super-rule's list.
105      *
106      * If 'super' is NULL, this rule is a super-rule, and 'list' is the head of
107      * a list of subrules.  A super-rule with no wildcards (where
108      * cr.wc.wildcards is 0) will never have any subrules. */
109     struct rule *super;
110     struct list list;
111
112     /* OpenFlow actions.
113      *
114      * A subrule has no actions (it uses the super-rule's actions). */
115     int n_actions;
116     union ofp_action *actions;
117
118     /* Datapath actions.
119      *
120      * A super-rule with wildcard fields never has ODP actions (since the
121      * datapath only supports exact-match flows). */
122     bool installed;             /* Installed in datapath? */
123     bool may_install;           /* True ordinarily; false if actions must
124                                  * be reassessed for every packet. */
125     int n_odp_actions;
126     union odp_action *odp_actions;
127 };
128
129 static inline bool
130 rule_is_hidden(const struct rule *rule)
131 {
132     /* Subrules are merely an implementation detail, so hide them from the
133      * controller. */
134     if (rule->super != NULL) {
135         return true;
136     }
137
138     /* Rules with priority higher than UINT16_MAX are set up by ofproto itself
139      * (e.g. by in-band control) and are intentionally hidden from the
140      * controller. */
141     if (rule->cr.priority > UINT16_MAX) {
142         return true;
143     }
144
145     return false;
146 }
147
148 static struct rule *rule_create(struct rule *super, const union ofp_action *,
149                                 size_t n_actions, uint16_t idle_timeout,
150                                 uint16_t hard_timeout);
151 static void rule_free(struct rule *);
152 static void rule_destroy(struct ofproto *, struct rule *);
153 static struct rule *rule_from_cls_rule(const struct cls_rule *);
154 static void rule_insert(struct ofproto *, struct rule *,
155                         struct ofpbuf *packet, uint16_t in_port);
156 static void rule_remove(struct ofproto *, struct rule *);
157 static bool rule_make_actions(struct ofproto *, struct rule *,
158                               const struct ofpbuf *packet);
159 static void rule_install(struct ofproto *, struct rule *,
160                          struct rule *displaced_rule);
161 static void rule_uninstall(struct ofproto *, struct rule *);
162 static void rule_post_uninstall(struct ofproto *, struct rule *);
163
164 struct ofconn {
165     struct list node;
166     struct rconn *rconn;
167     struct pktbuf *pktbuf;
168     bool send_flow_exp;
169     int miss_send_len;
170
171     struct rconn_packet_counter *packet_in_counter;
172
173     /* Number of OpenFlow messages queued as replies to OpenFlow requests, and
174      * the maximum number before we stop reading OpenFlow requests.  */
175 #define OFCONN_REPLY_MAX 100
176     struct rconn_packet_counter *reply_counter;
177 };
178
179 static struct ofconn *ofconn_create(struct ofproto *, struct rconn *);
180 static void ofconn_destroy(struct ofconn *, struct ofproto *);
181 static void ofconn_run(struct ofconn *, struct ofproto *);
182 static void ofconn_wait(struct ofconn *);
183 static void queue_tx(struct ofpbuf *msg, const struct ofconn *ofconn,
184                      struct rconn_packet_counter *counter);
185
186 struct ofproto {
187     /* Settings. */
188     uint64_t datapath_id;       /* Datapath ID. */
189     uint64_t fallback_dpid;     /* Datapath ID if no better choice found. */
190     uint64_t mgmt_id;           /* Management channel identifier. */
191     char *manufacturer;         /* Manufacturer. */
192     char *hardware;             /* Hardware. */
193     char *software;             /* Software version. */
194     char *serial;               /* Serial number. */
195
196     /* Datapath. */
197     struct dpif *dpif;
198     struct netdev_monitor *netdev_monitor;
199     struct port_array ports;    /* Index is ODP port nr; ofport->opp.port_no is
200                                  * OFP port nr. */
201     struct shash port_by_name;
202     uint32_t max_ports;
203
204     /* Configuration. */
205     struct switch_status *switch_status;
206     struct status_category *ss_cat;
207     struct in_band *in_band;
208     struct discovery *discovery;
209     struct fail_open *fail_open;
210     struct pinsched *miss_sched, *action_sched;
211     struct executer *executer;
212     struct netflow *netflow;
213
214     /* Flow table. */
215     struct classifier cls;
216     bool need_revalidate;
217     long long int next_expiration;
218     struct tag_set revalidate_set;
219
220     /* OpenFlow connections. */
221     struct list all_conns;
222     struct ofconn *controller;
223     struct pvconn **listeners;
224     size_t n_listeners;
225     struct pvconn **snoops;
226     size_t n_snoops;
227
228     /* Hooks for ovs-vswitchd. */
229     const struct ofhooks *ofhooks;
230     void *aux;
231
232     /* Used by default ofhooks. */
233     struct mac_learning *ml;
234 };
235
236 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
237
238 static const struct ofhooks default_ofhooks;
239
240 static uint64_t pick_datapath_id(const struct ofproto *);
241 static uint64_t pick_fallback_dpid(void);
242 static void send_packet_in_miss(struct ofpbuf *, void *ofproto);
243 static void send_packet_in_action(struct ofpbuf *, void *ofproto);
244 static void update_used(struct ofproto *);
245 static void update_stats(struct rule *, const struct odp_flow_stats *);
246 static void expire_rule(struct cls_rule *, void *ofproto);
247 static bool revalidate_rule(struct ofproto *p, struct rule *rule);
248 static void revalidate_cb(struct cls_rule *rule_, void *p_);
249
250 static void handle_odp_msg(struct ofproto *, struct ofpbuf *);
251
252 static void handle_openflow(struct ofconn *, struct ofproto *,
253                             struct ofpbuf *);
254
255 static void refresh_port_group(struct ofproto *, unsigned int group);
256 static void update_port(struct ofproto *, const char *devname);
257 static int init_ports(struct ofproto *);
258 static void reinit_ports(struct ofproto *);
259
260 int
261 ofproto_create(const char *datapath, const struct ofhooks *ofhooks, void *aux,
262                struct ofproto **ofprotop)
263 {
264     struct odp_stats stats;
265     struct ofproto *p;
266     struct dpif *dpif;
267     int error;
268
269     *ofprotop = NULL;
270
271     /* Connect to datapath and start listening for messages. */
272     error = dpif_open(datapath, &dpif);
273     if (error) {
274         VLOG_ERR("failed to open datapath %s: %s", datapath, strerror(error));
275         return error;
276     }
277     error = dpif_get_dp_stats(dpif, &stats);
278     if (error) {
279         VLOG_ERR("failed to obtain stats for datapath %s: %s",
280                  datapath, strerror(error));
281         dpif_close(dpif);
282         return error;
283     }
284     error = dpif_recv_set_mask(dpif, ODPL_MISS | ODPL_ACTION);
285     if (error) {
286         VLOG_ERR("failed to listen on datapath %s: %s",
287                  datapath, strerror(error));
288         dpif_close(dpif);
289         return error;
290     }
291     dpif_flow_flush(dpif);
292     dpif_recv_purge(dpif);
293
294     /* Initialize settings. */
295     p = xcalloc(1, sizeof *p);
296     p->fallback_dpid = pick_fallback_dpid();
297     p->datapath_id = p->fallback_dpid;
298     p->manufacturer = xstrdup("Nicira Networks, Inc.");
299     p->hardware = xstrdup("Reference Implementation");
300     p->software = xstrdup(VERSION BUILDNR);
301     p->serial = xstrdup("None");
302
303     /* Initialize datapath. */
304     p->dpif = dpif;
305     p->netdev_monitor = netdev_monitor_create();
306     port_array_init(&p->ports);
307     shash_init(&p->port_by_name);
308     p->max_ports = stats.max_ports;
309
310     /* Initialize submodules. */
311     p->switch_status = switch_status_create(p);
312     p->in_band = NULL;
313     p->discovery = NULL;
314     p->fail_open = NULL;
315     p->miss_sched = p->action_sched = NULL;
316     p->executer = NULL;
317     p->netflow = NULL;
318
319     /* Initialize flow table. */
320     classifier_init(&p->cls);
321     p->need_revalidate = false;
322     p->next_expiration = time_msec() + 1000;
323     tag_set_init(&p->revalidate_set);
324
325     /* Initialize OpenFlow connections. */
326     list_init(&p->all_conns);
327     p->controller = ofconn_create(p, rconn_create(5, 8));
328     p->controller->pktbuf = pktbuf_create();
329     p->controller->miss_send_len = OFP_DEFAULT_MISS_SEND_LEN;
330     p->listeners = NULL;
331     p->n_listeners = 0;
332     p->snoops = NULL;
333     p->n_snoops = 0;
334
335     /* Initialize hooks. */
336     if (ofhooks) {
337         p->ofhooks = ofhooks;
338         p->aux = aux;
339         p->ml = NULL;
340     } else {
341         p->ofhooks = &default_ofhooks;
342         p->aux = p;
343         p->ml = mac_learning_create();
344     }
345
346     /* Register switch status category. */
347     p->ss_cat = switch_status_register(p->switch_status, "remote",
348                                        rconn_status_cb, p->controller->rconn);
349
350     /* Almost done... */
351     error = init_ports(p);
352     if (error) {
353         ofproto_destroy(p);
354         return error;
355     }
356
357     /* Pick final datapath ID. */
358     p->datapath_id = pick_datapath_id(p);
359     VLOG_INFO("using datapath ID %012"PRIx64, p->datapath_id);
360
361     *ofprotop = p;
362     return 0;
363 }
364
365 void
366 ofproto_set_datapath_id(struct ofproto *p, uint64_t datapath_id)
367 {
368     uint64_t old_dpid = p->datapath_id;
369     p->datapath_id = datapath_id ? datapath_id : pick_datapath_id(p);
370     if (p->datapath_id != old_dpid) {
371         VLOG_INFO("datapath ID changed to %012"PRIx64, p->datapath_id);
372         rconn_reconnect(p->controller->rconn);
373     }
374 }
375
376 void
377 ofproto_set_mgmt_id(struct ofproto *p, uint64_t mgmt_id)
378 {
379     p->mgmt_id = mgmt_id;
380 }
381
382 void
383 ofproto_set_probe_interval(struct ofproto *p, int probe_interval)
384 {
385     probe_interval = probe_interval ? MAX(probe_interval, 5) : 0;
386     rconn_set_probe_interval(p->controller->rconn, probe_interval);
387     if (p->fail_open) {
388         int trigger_duration = probe_interval ? probe_interval * 3 : 15;
389         fail_open_set_trigger_duration(p->fail_open, trigger_duration);
390     }
391 }
392
393 void
394 ofproto_set_max_backoff(struct ofproto *p, int max_backoff)
395 {
396     rconn_set_max_backoff(p->controller->rconn, max_backoff);
397 }
398
399 void
400 ofproto_set_desc(struct ofproto *p,
401                  const char *manufacturer, const char *hardware,
402                  const char *software, const char *serial)
403 {
404     if (manufacturer) {
405         free(p->manufacturer);
406         p->manufacturer = xstrdup(manufacturer);
407     }
408     if (hardware) {
409         free(p->hardware);
410         p->hardware = xstrdup(hardware);
411     }
412     if (software) {
413         free(p->software);
414         p->software = xstrdup(software);
415     }
416     if (serial) {
417         free(p->serial);
418         p->serial = xstrdup(serial);
419     }
420 }
421
422 int
423 ofproto_set_in_band(struct ofproto *p, bool in_band)
424 {
425     if (in_band != (p->in_band != NULL)) {
426         if (in_band) {
427             return in_band_create(p, p->dpif, p->switch_status,
428                                   p->controller->rconn, &p->in_band);
429         } else {
430             ofproto_set_discovery(p, false, NULL, true);
431             in_band_destroy(p->in_band);
432             p->in_band = NULL;
433         }
434         rconn_reconnect(p->controller->rconn);
435     }
436     return 0;
437 }
438
439 int
440 ofproto_set_discovery(struct ofproto *p, bool discovery,
441                       const char *re, bool update_resolv_conf)
442 {
443     if (discovery != (p->discovery != NULL)) {
444         if (discovery) {
445             int error = ofproto_set_in_band(p, true);
446             if (error) {
447                 return error;
448             }
449             error = discovery_create(re, update_resolv_conf,
450                                      p->dpif, p->switch_status,
451                                      &p->discovery);
452             if (error) {
453                 return error;
454             }
455         } else {
456             discovery_destroy(p->discovery);
457             p->discovery = NULL;
458         }
459         rconn_disconnect(p->controller->rconn);
460     } else if (discovery) {
461         discovery_set_update_resolv_conf(p->discovery, update_resolv_conf);
462         return discovery_set_accept_controller_re(p->discovery, re);
463     }
464     return 0;
465 }
466
467 int
468 ofproto_set_controller(struct ofproto *ofproto, const char *controller)
469 {
470     if (ofproto->discovery) {
471         return EINVAL;
472     } else if (controller) {
473         if (strcmp(rconn_get_name(ofproto->controller->rconn), controller)) {
474             return rconn_connect(ofproto->controller->rconn, controller);
475         } else {
476             return 0;
477         }
478     } else {
479         rconn_disconnect(ofproto->controller->rconn);
480         return 0;
481     }
482 }
483
484 static int
485 set_pvconns(struct pvconn ***pvconnsp, size_t *n_pvconnsp,
486             const struct svec *svec)
487 {
488     struct pvconn **pvconns = *pvconnsp;
489     size_t n_pvconns = *n_pvconnsp;
490     int retval = 0;
491     size_t i;
492
493     for (i = 0; i < n_pvconns; i++) {
494         pvconn_close(pvconns[i]);
495     }
496     free(pvconns);
497
498     pvconns = xmalloc(svec->n * sizeof *pvconns);
499     n_pvconns = 0;
500     for (i = 0; i < svec->n; i++) {
501         const char *name = svec->names[i];
502         struct pvconn *pvconn;
503         int error;
504
505         error = pvconn_open(name, &pvconn);
506         if (!error) {
507             pvconns[n_pvconns++] = pvconn;
508         } else {
509             VLOG_ERR("failed to listen on %s: %s", name, strerror(error));
510             if (!retval) {
511                 retval = error;
512             }
513         }
514     }
515
516     *pvconnsp = pvconns;
517     *n_pvconnsp = n_pvconns;
518
519     return retval;
520 }
521
522 int
523 ofproto_set_listeners(struct ofproto *ofproto, const struct svec *listeners)
524 {
525     return set_pvconns(&ofproto->listeners, &ofproto->n_listeners, listeners);
526 }
527
528 int
529 ofproto_set_snoops(struct ofproto *ofproto, const struct svec *snoops)
530 {
531     return set_pvconns(&ofproto->snoops, &ofproto->n_snoops, snoops);
532 }
533
534 int
535 ofproto_set_netflow(struct ofproto *ofproto, const struct svec *collectors,
536         uint8_t engine_type, uint8_t engine_id, bool add_id_to_iface)
537 {
538     if (collectors && collectors->n) {
539         if (!ofproto->netflow) {
540             ofproto->netflow = netflow_create();
541         }
542         netflow_set_engine(ofproto->netflow, engine_type, engine_id, 
543                 add_id_to_iface);
544         return netflow_set_collectors(ofproto->netflow, collectors);
545     } else {
546         netflow_destroy(ofproto->netflow);
547         ofproto->netflow = NULL;
548         return 0;
549     }
550 }
551
552 void
553 ofproto_set_failure(struct ofproto *ofproto, bool fail_open)
554 {
555     if (fail_open) {
556         struct rconn *rconn = ofproto->controller->rconn;
557         int trigger_duration = rconn_get_probe_interval(rconn) * 3;
558         if (!ofproto->fail_open) {
559             ofproto->fail_open = fail_open_create(ofproto, trigger_duration,
560                                                   ofproto->switch_status,
561                                                   rconn);
562         } else {
563             fail_open_set_trigger_duration(ofproto->fail_open,
564                                            trigger_duration);
565         }
566     } else {
567         fail_open_destroy(ofproto->fail_open);
568         ofproto->fail_open = NULL;
569     }
570 }
571
572 void
573 ofproto_set_rate_limit(struct ofproto *ofproto,
574                        int rate_limit, int burst_limit)
575 {
576     if (rate_limit > 0) {
577         if (!ofproto->miss_sched) {
578             ofproto->miss_sched = pinsched_create(rate_limit, burst_limit,
579                                                   ofproto->switch_status);
580             ofproto->action_sched = pinsched_create(rate_limit, burst_limit,
581                                                     NULL);
582         } else {
583             pinsched_set_limits(ofproto->miss_sched, rate_limit, burst_limit);
584             pinsched_set_limits(ofproto->action_sched,
585                                 rate_limit, burst_limit);
586         }
587     } else {
588         pinsched_destroy(ofproto->miss_sched);
589         ofproto->miss_sched = NULL;
590         pinsched_destroy(ofproto->action_sched);
591         ofproto->action_sched = NULL;
592     }
593 }
594
595 int
596 ofproto_set_stp(struct ofproto *ofproto UNUSED, bool enable_stp)
597 {
598     /* XXX */
599     if (enable_stp) {
600         VLOG_WARN("STP is not yet implemented");
601         return EINVAL;
602     } else {
603         return 0;
604     }
605 }
606
607 int
608 ofproto_set_remote_execution(struct ofproto *ofproto, const char *command_acl,
609                              const char *command_dir)
610 {
611     if (command_acl) {
612         if (!ofproto->executer) {
613             return executer_create(command_acl, command_dir,
614                                    &ofproto->executer);
615         } else {
616             executer_set_acl(ofproto->executer, command_acl, command_dir);
617         }
618     } else {
619         executer_destroy(ofproto->executer);
620         ofproto->executer = NULL;
621     }
622     return 0;
623 }
624
625 uint64_t
626 ofproto_get_datapath_id(const struct ofproto *ofproto)
627 {
628     return ofproto->datapath_id;
629 }
630
631 uint64_t
632 ofproto_get_mgmt_id(const struct ofproto *ofproto)
633 {
634     return ofproto->mgmt_id;
635 }
636
637 int
638 ofproto_get_probe_interval(const struct ofproto *ofproto)
639 {
640     return rconn_get_probe_interval(ofproto->controller->rconn);
641 }
642
643 int
644 ofproto_get_max_backoff(const struct ofproto *ofproto)
645 {
646     return rconn_get_max_backoff(ofproto->controller->rconn);
647 }
648
649 bool
650 ofproto_get_in_band(const struct ofproto *ofproto)
651 {
652     return ofproto->in_band != NULL;
653 }
654
655 bool
656 ofproto_get_discovery(const struct ofproto *ofproto)
657 {
658     return ofproto->discovery != NULL;
659 }
660
661 const char *
662 ofproto_get_controller(const struct ofproto *ofproto)
663 {
664     return rconn_get_name(ofproto->controller->rconn);
665 }
666
667 void
668 ofproto_get_listeners(const struct ofproto *ofproto, struct svec *listeners)
669 {
670     size_t i;
671
672     for (i = 0; i < ofproto->n_listeners; i++) {
673         svec_add(listeners, pvconn_get_name(ofproto->listeners[i]));
674     }
675 }
676
677 void
678 ofproto_get_snoops(const struct ofproto *ofproto, struct svec *snoops)
679 {
680     size_t i;
681
682     for (i = 0; i < ofproto->n_snoops; i++) {
683         svec_add(snoops, pvconn_get_name(ofproto->snoops[i]));
684     }
685 }
686
687 void
688 ofproto_destroy(struct ofproto *p)
689 {
690     struct ofconn *ofconn, *next_ofconn;
691     struct ofport *ofport;
692     unsigned int port_no;
693     size_t i;
694
695     if (!p) {
696         return;
697     }
698
699     ofproto_flush_flows(p);
700     classifier_destroy(&p->cls);
701
702     LIST_FOR_EACH_SAFE (ofconn, next_ofconn, struct ofconn, node,
703                         &p->all_conns) {
704         ofconn_destroy(ofconn, p);
705     }
706
707     dpif_close(p->dpif);
708     netdev_monitor_destroy(p->netdev_monitor);
709     PORT_ARRAY_FOR_EACH (ofport, &p->ports, port_no) {
710         ofport_free(ofport);
711     }
712     shash_destroy(&p->port_by_name);
713
714     switch_status_destroy(p->switch_status);
715     in_band_destroy(p->in_band);
716     discovery_destroy(p->discovery);
717     fail_open_destroy(p->fail_open);
718     pinsched_destroy(p->miss_sched);
719     pinsched_destroy(p->action_sched);
720     executer_destroy(p->executer);
721     netflow_destroy(p->netflow);
722
723     switch_status_unregister(p->ss_cat);
724
725     for (i = 0; i < p->n_listeners; i++) {
726         pvconn_close(p->listeners[i]);
727     }
728     free(p->listeners);
729
730     for (i = 0; i < p->n_snoops; i++) {
731         pvconn_close(p->snoops[i]);
732     }
733     free(p->snoops);
734
735     mac_learning_destroy(p->ml);
736
737     free(p);
738 }
739
740 int
741 ofproto_run(struct ofproto *p)
742 {
743     int error = ofproto_run1(p);
744     if (!error) {
745         error = ofproto_run2(p, false);
746     }
747     return error;
748 }
749
750 static void
751 process_port_change(struct ofproto *ofproto, int error, char *devname)
752 {
753     if (error == ENOBUFS) {
754         reinit_ports(ofproto);
755     } else if (!error) {
756         update_port(ofproto, devname);
757         free(devname);
758     }
759 }
760
761 int
762 ofproto_run1(struct ofproto *p)
763 {
764     struct ofconn *ofconn, *next_ofconn;
765     char *devname;
766     int error;
767     int i;
768
769     for (i = 0; i < 50; i++) {
770         struct ofpbuf *buf;
771         int error;
772
773         error = dpif_recv(p->dpif, &buf);
774         if (error) {
775             if (error == ENODEV) {
776                 /* Someone destroyed the datapath behind our back.  The caller
777                  * better destroy us and give up, because we're just going to
778                  * spin from here on out. */
779                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
780                 VLOG_ERR_RL(&rl, "%s: datapath was destroyed externally",
781                             dpif_name(p->dpif));
782                 return ENODEV;
783             }
784             break;
785         }
786
787         handle_odp_msg(p, buf);
788     }
789
790     while ((error = dpif_port_poll(p->dpif, &devname)) != EAGAIN) {
791         process_port_change(p, error, devname);
792     }
793     while ((error = netdev_monitor_poll(p->netdev_monitor,
794                                         &devname)) != EAGAIN) {
795         process_port_change(p, error, devname);
796     }
797
798     if (p->in_band) {
799         in_band_run(p->in_band);
800     }
801     if (p->discovery) {
802         char *controller_name;
803         if (rconn_is_connectivity_questionable(p->controller->rconn)) {
804             discovery_question_connectivity(p->discovery);
805         }
806         if (discovery_run(p->discovery, &controller_name)) {
807             if (controller_name) {
808                 rconn_connect(p->controller->rconn, controller_name);
809             } else {
810                 rconn_disconnect(p->controller->rconn);
811             }
812         }
813     }
814     if (p->fail_open) {
815         fail_open_run(p->fail_open);
816     }
817     pinsched_run(p->miss_sched, send_packet_in_miss, p);
818     pinsched_run(p->action_sched, send_packet_in_action, p);
819     if (p->executer) {
820         executer_run(p->executer);
821     }
822
823     LIST_FOR_EACH_SAFE (ofconn, next_ofconn, struct ofconn, node,
824                         &p->all_conns) {
825         ofconn_run(ofconn, p);
826     }
827
828     for (i = 0; i < p->n_listeners; i++) {
829         struct vconn *vconn;
830         int retval;
831
832         retval = pvconn_accept(p->listeners[i], OFP_VERSION, &vconn);
833         if (!retval) {
834             ofconn_create(p, rconn_new_from_vconn("passive", vconn));
835         } else if (retval != EAGAIN) {
836             VLOG_WARN_RL(&rl, "accept failed (%s)", strerror(retval));
837         }
838     }
839
840     for (i = 0; i < p->n_snoops; i++) {
841         struct vconn *vconn;
842         int retval;
843
844         retval = pvconn_accept(p->snoops[i], OFP_VERSION, &vconn);
845         if (!retval) {
846             rconn_add_monitor(p->controller->rconn, vconn);
847         } else if (retval != EAGAIN) {
848             VLOG_WARN_RL(&rl, "accept failed (%s)", strerror(retval));
849         }
850     }
851
852     if (time_msec() >= p->next_expiration) {
853         COVERAGE_INC(ofproto_expiration);
854         p->next_expiration = time_msec() + 1000;
855         update_used(p);
856
857         classifier_for_each(&p->cls, CLS_INC_ALL, expire_rule, p);
858
859         /* Let the hook know that we're at a stable point: all outstanding data
860          * in existing flows has been accounted to the account_cb.  Thus, the
861          * hook can now reasonably do operations that depend on having accurate
862          * flow volume accounting (currently, that's just bond rebalancing). */
863         if (p->ofhooks->account_checkpoint_cb) {
864             p->ofhooks->account_checkpoint_cb(p->aux);
865         }
866     }
867
868     if (p->netflow) {
869         netflow_run(p->netflow);
870     }
871
872     return 0;
873 }
874
875 struct revalidate_cbdata {
876     struct ofproto *ofproto;
877     bool revalidate_all;        /* Revalidate all exact-match rules? */
878     bool revalidate_subrules;   /* Revalidate all exact-match subrules? */
879     struct tag_set revalidate_set; /* Set of tags to revalidate. */
880 };
881
882 int
883 ofproto_run2(struct ofproto *p, bool revalidate_all)
884 {
885     if (p->need_revalidate || revalidate_all
886         || !tag_set_is_empty(&p->revalidate_set)) {
887         struct revalidate_cbdata cbdata;
888         cbdata.ofproto = p;
889         cbdata.revalidate_all = revalidate_all;
890         cbdata.revalidate_subrules = p->need_revalidate;
891         cbdata.revalidate_set = p->revalidate_set;
892         tag_set_init(&p->revalidate_set);
893         COVERAGE_INC(ofproto_revalidate);
894         classifier_for_each(&p->cls, CLS_INC_EXACT, revalidate_cb, &cbdata);
895         p->need_revalidate = false;
896     }
897
898     return 0;
899 }
900
901 void
902 ofproto_wait(struct ofproto *p)
903 {
904     struct ofconn *ofconn;
905     size_t i;
906
907     dpif_recv_wait(p->dpif);
908     dpif_port_poll_wait(p->dpif);
909     netdev_monitor_poll_wait(p->netdev_monitor);
910     LIST_FOR_EACH (ofconn, struct ofconn, node, &p->all_conns) {
911         ofconn_wait(ofconn);
912     }
913     if (p->in_band) {
914         in_band_wait(p->in_band);
915     }
916     if (p->discovery) {
917         discovery_wait(p->discovery);
918     }
919     if (p->fail_open) {
920         fail_open_wait(p->fail_open);
921     }
922     pinsched_wait(p->miss_sched);
923     pinsched_wait(p->action_sched);
924     if (p->executer) {
925         executer_wait(p->executer);
926     }
927     if (!tag_set_is_empty(&p->revalidate_set)) {
928         poll_immediate_wake();
929     }
930     if (p->need_revalidate) {
931         /* Shouldn't happen, but if it does just go around again. */
932         VLOG_DBG_RL(&rl, "need revalidate in ofproto_wait_cb()");
933         poll_immediate_wake();
934     } else if (p->next_expiration != LLONG_MAX) {
935         poll_timer_wait(p->next_expiration - time_msec());
936     }
937     for (i = 0; i < p->n_listeners; i++) {
938         pvconn_wait(p->listeners[i]);
939     }
940     for (i = 0; i < p->n_snoops; i++) {
941         pvconn_wait(p->snoops[i]);
942     }
943 }
944
945 void
946 ofproto_revalidate(struct ofproto *ofproto, tag_type tag)
947 {
948     tag_set_add(&ofproto->revalidate_set, tag);
949 }
950
951 struct tag_set *
952 ofproto_get_revalidate_set(struct ofproto *ofproto)
953 {
954     return &ofproto->revalidate_set;
955 }
956
957 bool
958 ofproto_is_alive(const struct ofproto *p)
959 {
960     return p->discovery || rconn_is_alive(p->controller->rconn);
961 }
962
963 int
964 ofproto_send_packet(struct ofproto *p, const flow_t *flow,
965                     const union ofp_action *actions, size_t n_actions,
966                     const struct ofpbuf *packet)
967 {
968     struct odp_actions odp_actions;
969     int error;
970
971     error = xlate_actions(actions, n_actions, flow, p, packet, &odp_actions,
972                           NULL, NULL);
973     if (error) {
974         return error;
975     }
976
977     /* XXX Should we translate the dpif_execute() errno value into an OpenFlow
978      * error code? */
979     dpif_execute(p->dpif, flow->in_port, odp_actions.actions,
980                  odp_actions.n_actions, packet);
981     return 0;
982 }
983
984 void
985 ofproto_add_flow(struct ofproto *p,
986                  const flow_t *flow, uint32_t wildcards, unsigned int priority,
987                  const union ofp_action *actions, size_t n_actions,
988                  int idle_timeout)
989 {
990     struct rule *rule;
991     rule = rule_create(NULL, actions, n_actions,
992                        idle_timeout >= 0 ? idle_timeout : 5 /* XXX */, 0);
993     cls_rule_from_flow(&rule->cr, flow, wildcards, priority);
994     rule_insert(p, rule, NULL, 0);
995 }
996
997 void
998 ofproto_delete_flow(struct ofproto *ofproto, const flow_t *flow,
999                     uint32_t wildcards, unsigned int priority)
1000 {
1001     struct rule *rule;
1002
1003     rule = rule_from_cls_rule(classifier_find_rule_exactly(&ofproto->cls,
1004                                                            flow, wildcards,
1005                                                            priority));
1006     if (rule) {
1007         rule_remove(ofproto, rule);
1008     }
1009 }
1010
1011 static void
1012 destroy_rule(struct cls_rule *rule_, void *ofproto_)
1013 {
1014     struct rule *rule = rule_from_cls_rule(rule_);
1015     struct ofproto *ofproto = ofproto_;
1016
1017     /* Mark the flow as not installed, even though it might really be
1018      * installed, so that rule_remove() doesn't bother trying to uninstall it.
1019      * There is no point in uninstalling it individually since we are about to
1020      * blow away all the flows with dpif_flow_flush(). */
1021     rule->installed = false;
1022
1023     rule_remove(ofproto, rule);
1024 }
1025
1026 void
1027 ofproto_flush_flows(struct ofproto *ofproto)
1028 {
1029     COVERAGE_INC(ofproto_flush);
1030     classifier_for_each(&ofproto->cls, CLS_INC_ALL, destroy_rule, ofproto);
1031     dpif_flow_flush(ofproto->dpif);
1032     if (ofproto->in_band) {
1033         in_band_flushed(ofproto->in_band);
1034     }
1035     if (ofproto->fail_open) {
1036         fail_open_flushed(ofproto->fail_open);
1037     }
1038 }
1039 \f
1040 static void
1041 reinit_ports(struct ofproto *p)
1042 {
1043     struct svec devnames;
1044     struct ofport *ofport;
1045     unsigned int port_no;
1046     struct odp_port *odp_ports;
1047     size_t n_odp_ports;
1048     size_t i;
1049
1050     svec_init(&devnames);
1051     PORT_ARRAY_FOR_EACH (ofport, &p->ports, port_no) {
1052         svec_add (&devnames, (char *) ofport->opp.name);
1053     }
1054     dpif_port_list(p->dpif, &odp_ports, &n_odp_ports);
1055     for (i = 0; i < n_odp_ports; i++) {
1056         svec_add (&devnames, odp_ports[i].devname);
1057     }
1058     free(odp_ports);
1059
1060     svec_sort_unique(&devnames);
1061     for (i = 0; i < devnames.n; i++) {
1062         update_port(p, devnames.names[i]);
1063     }
1064     svec_destroy(&devnames);
1065 }
1066
1067 static void
1068 refresh_port_group(struct ofproto *p, unsigned int group)
1069 {
1070     uint16_t *ports;
1071     size_t n_ports;
1072     struct ofport *port;
1073     unsigned int port_no;
1074
1075     assert(group == DP_GROUP_ALL || group == DP_GROUP_FLOOD);
1076
1077     ports = xmalloc(port_array_count(&p->ports) * sizeof *ports);
1078     n_ports = 0;
1079     PORT_ARRAY_FOR_EACH (port, &p->ports, port_no) {
1080         if (group == DP_GROUP_ALL || !(port->opp.config & OFPPC_NO_FLOOD)) {
1081             ports[n_ports++] = port_no;
1082         }
1083     }
1084     dpif_port_group_set(p->dpif, group, ports, n_ports);
1085     free(ports);
1086 }
1087
1088 static void
1089 refresh_port_groups(struct ofproto *p)
1090 {
1091     refresh_port_group(p, DP_GROUP_FLOOD);
1092     refresh_port_group(p, DP_GROUP_ALL);
1093 }
1094
1095 static struct ofport *
1096 make_ofport(const struct odp_port *odp_port)
1097 {
1098     enum netdev_flags flags;
1099     struct ofport *ofport;
1100     struct netdev *netdev;
1101     bool carrier;
1102     int error;
1103
1104     error = netdev_open(odp_port->devname, NETDEV_ETH_TYPE_NONE, &netdev);
1105     if (error) {
1106         VLOG_WARN_RL(&rl, "ignoring port %s (%"PRIu16") because netdev %s "
1107                      "cannot be opened (%s)",
1108                      odp_port->devname, odp_port->port,
1109                      odp_port->devname, strerror(error));
1110         return NULL;
1111     }
1112
1113     ofport = xmalloc(sizeof *ofport);
1114     ofport->netdev = netdev;
1115     ofport->opp.port_no = odp_port_to_ofp_port(odp_port->port);
1116     netdev_get_etheraddr(netdev, ofport->opp.hw_addr);
1117     memcpy(ofport->opp.name, odp_port->devname,
1118            MIN(sizeof ofport->opp.name, sizeof odp_port->devname));
1119     ofport->opp.name[sizeof ofport->opp.name - 1] = '\0';
1120
1121     netdev_get_flags(netdev, &flags);
1122     ofport->opp.config = flags & NETDEV_UP ? 0 : OFPPC_PORT_DOWN;
1123
1124     netdev_get_carrier(netdev, &carrier);
1125     ofport->opp.state = carrier ? 0 : OFPPS_LINK_DOWN;
1126
1127     netdev_get_features(netdev,
1128                         &ofport->opp.curr, &ofport->opp.advertised,
1129                         &ofport->opp.supported, &ofport->opp.peer);
1130     return ofport;
1131 }
1132
1133 static bool
1134 ofport_conflicts(const struct ofproto *p, const struct odp_port *odp_port)
1135 {
1136     if (port_array_get(&p->ports, odp_port->port)) {
1137         VLOG_WARN_RL(&rl, "ignoring duplicate port %"PRIu16" in datapath",
1138                      odp_port->port);
1139         return true;
1140     } else if (shash_find(&p->port_by_name, odp_port->devname)) {
1141         VLOG_WARN_RL(&rl, "ignoring duplicate device %s in datapath",
1142                      odp_port->devname);
1143         return true;
1144     } else {
1145         return false;
1146     }
1147 }
1148
1149 static int
1150 ofport_equal(const struct ofport *a_, const struct ofport *b_)
1151 {
1152     const struct ofp_phy_port *a = &a_->opp;
1153     const struct ofp_phy_port *b = &b_->opp;
1154
1155     BUILD_ASSERT_DECL(sizeof *a == 48); /* Detect ofp_phy_port changes. */
1156     return (a->port_no == b->port_no
1157             && !memcmp(a->hw_addr, b->hw_addr, sizeof a->hw_addr)
1158             && !strcmp((char *) a->name, (char *) b->name)
1159             && a->state == b->state
1160             && a->config == b->config
1161             && a->curr == b->curr
1162             && a->advertised == b->advertised
1163             && a->supported == b->supported
1164             && a->peer == b->peer);
1165 }
1166
1167 static void
1168 send_port_status(struct ofproto *p, const struct ofport *ofport,
1169                  uint8_t reason)
1170 {
1171     /* XXX Should limit the number of queued port status change messages. */
1172     struct ofconn *ofconn;
1173     LIST_FOR_EACH (ofconn, struct ofconn, node, &p->all_conns) {
1174         struct ofp_port_status *ops;
1175         struct ofpbuf *b;
1176
1177         ops = make_openflow_xid(sizeof *ops, OFPT_PORT_STATUS, 0, &b);
1178         ops->reason = reason;
1179         ops->desc = ofport->opp;
1180         hton_ofp_phy_port(&ops->desc);
1181         queue_tx(b, ofconn, NULL);
1182     }
1183     if (p->ofhooks->port_changed_cb) {
1184         p->ofhooks->port_changed_cb(reason, &ofport->opp, p->aux);
1185     }
1186 }
1187
1188 static void
1189 ofport_install(struct ofproto *p, struct ofport *ofport)
1190 {
1191     netdev_monitor_add(p->netdev_monitor, ofport->netdev);
1192     port_array_set(&p->ports, ofp_port_to_odp_port(ofport->opp.port_no),
1193                    ofport);
1194     shash_add(&p->port_by_name, (char *) ofport->opp.name, ofport);
1195 }
1196
1197 static void
1198 ofport_remove(struct ofproto *p, struct ofport *ofport)
1199 {
1200     netdev_monitor_remove(p->netdev_monitor, ofport->netdev);
1201     port_array_set(&p->ports, ofp_port_to_odp_port(ofport->opp.port_no), NULL);
1202     shash_delete(&p->port_by_name,
1203                  shash_find(&p->port_by_name, (char *) ofport->opp.name));
1204 }
1205
1206 static void
1207 ofport_free(struct ofport *ofport)
1208 {
1209     if (ofport) {
1210         netdev_close(ofport->netdev);
1211         free(ofport);
1212     }
1213 }
1214
1215 static void
1216 update_port(struct ofproto *p, const char *devname)
1217 {
1218     struct odp_port odp_port;
1219     struct ofport *old_ofport;
1220     struct ofport *new_ofport;
1221     int error;
1222
1223     COVERAGE_INC(ofproto_update_port);
1224
1225     /* Query the datapath for port information. */
1226     error = dpif_port_query_by_name(p->dpif, devname, &odp_port);
1227
1228     /* Find the old ofport. */
1229     old_ofport = shash_find_data(&p->port_by_name, devname);
1230     if (!error) {
1231         if (!old_ofport) {
1232             /* There's no port named 'devname' but there might be a port with
1233              * the same port number.  This could happen if a port is deleted
1234              * and then a new one added in its place very quickly, or if a port
1235              * is renamed.  In the former case we want to send an OFPPR_DELETE
1236              * and an OFPPR_ADD, and in the latter case we want to send a
1237              * single OFPPR_MODIFY.  We can distinguish the cases by comparing
1238              * the old port's ifindex against the new port, or perhaps less
1239              * reliably but more portably by comparing the old port's MAC
1240              * against the new port's MAC.  However, this code isn't that smart
1241              * and always sends an OFPPR_MODIFY (XXX). */
1242             old_ofport = port_array_get(&p->ports, odp_port.port);
1243         }
1244     } else if (error != ENOENT && error != ENODEV) {
1245         VLOG_WARN_RL(&rl, "dpif_port_query_by_name returned unexpected error "
1246                      "%s", strerror(error));
1247         return;
1248     }
1249
1250     /* Create a new ofport. */
1251     new_ofport = !error ? make_ofport(&odp_port) : NULL;
1252
1253     /* Eliminate a few pathological cases. */
1254     if (!old_ofport && !new_ofport) {
1255         return;
1256     } else if (old_ofport && new_ofport) {
1257         /* Most of the 'config' bits are OpenFlow soft state, but
1258          * OFPPC_PORT_DOWN is maintained the kernel.  So transfer the OpenFlow
1259          * bits from old_ofport.  (make_ofport() only sets OFPPC_PORT_DOWN and
1260          * leaves the other bits 0.)  */
1261         new_ofport->opp.config |= old_ofport->opp.config & ~OFPPC_PORT_DOWN;
1262
1263         if (ofport_equal(old_ofport, new_ofport)) {
1264             /* False alarm--no change. */
1265             ofport_free(new_ofport);
1266             return;
1267         }
1268     }
1269
1270     /* Now deal with the normal cases. */
1271     if (old_ofport) {
1272         ofport_remove(p, old_ofport);
1273     }
1274     if (new_ofport) {
1275         ofport_install(p, new_ofport);
1276     }
1277     send_port_status(p, new_ofport ? new_ofport : old_ofport,
1278                      (!old_ofport ? OFPPR_ADD
1279                       : !new_ofport ? OFPPR_DELETE
1280                       : OFPPR_MODIFY));
1281     ofport_free(old_ofport);
1282
1283     /* Update port groups. */
1284     refresh_port_groups(p);
1285 }
1286
1287 static int
1288 init_ports(struct ofproto *p)
1289 {
1290     struct odp_port *ports;
1291     size_t n_ports;
1292     size_t i;
1293     int error;
1294
1295     error = dpif_port_list(p->dpif, &ports, &n_ports);
1296     if (error) {
1297         return error;
1298     }
1299
1300     for (i = 0; i < n_ports; i++) {
1301         const struct odp_port *odp_port = &ports[i];
1302         if (!ofport_conflicts(p, odp_port)) {
1303             struct ofport *ofport = make_ofport(odp_port);
1304             if (ofport) {
1305                 ofport_install(p, ofport);
1306             }
1307         }
1308     }
1309     free(ports);
1310     refresh_port_groups(p);
1311     return 0;
1312 }
1313 \f
1314 static struct ofconn *
1315 ofconn_create(struct ofproto *p, struct rconn *rconn)
1316 {
1317     struct ofconn *ofconn = xmalloc(sizeof *ofconn);
1318     list_push_back(&p->all_conns, &ofconn->node);
1319     ofconn->rconn = rconn;
1320     ofconn->pktbuf = NULL;
1321     ofconn->send_flow_exp = false;
1322     ofconn->miss_send_len = 0;
1323     ofconn->packet_in_counter = rconn_packet_counter_create ();
1324     ofconn->reply_counter = rconn_packet_counter_create ();
1325     return ofconn;
1326 }
1327
1328 static void
1329 ofconn_destroy(struct ofconn *ofconn, struct ofproto *p)
1330 {
1331     if (p->executer) {
1332         executer_rconn_closing(p->executer, ofconn->rconn);
1333     }
1334
1335     list_remove(&ofconn->node);
1336     rconn_destroy(ofconn->rconn);
1337     rconn_packet_counter_destroy(ofconn->packet_in_counter);
1338     rconn_packet_counter_destroy(ofconn->reply_counter);
1339     pktbuf_destroy(ofconn->pktbuf);
1340     free(ofconn);
1341 }
1342
1343 static void
1344 ofconn_run(struct ofconn *ofconn, struct ofproto *p)
1345 {
1346     int iteration;
1347
1348     rconn_run(ofconn->rconn);
1349
1350     if (rconn_packet_counter_read (ofconn->reply_counter) < OFCONN_REPLY_MAX) {
1351         /* Limit the number of iterations to prevent other tasks from
1352          * starving. */
1353         for (iteration = 0; iteration < 50; iteration++) {
1354             struct ofpbuf *of_msg = rconn_recv(ofconn->rconn);
1355             if (!of_msg) {
1356                 break;
1357             }
1358             handle_openflow(ofconn, p, of_msg);
1359             ofpbuf_delete(of_msg);
1360         }
1361     }
1362
1363     if (ofconn != p->controller && !rconn_is_alive(ofconn->rconn)) {
1364         ofconn_destroy(ofconn, p);
1365     }
1366 }
1367
1368 static void
1369 ofconn_wait(struct ofconn *ofconn)
1370 {
1371     rconn_run_wait(ofconn->rconn);
1372     if (rconn_packet_counter_read (ofconn->reply_counter) < OFCONN_REPLY_MAX) {
1373         rconn_recv_wait(ofconn->rconn);
1374     } else {
1375         COVERAGE_INC(ofproto_ofconn_stuck);
1376     }
1377 }
1378 \f
1379 /* Caller is responsible for initializing the 'cr' member of the returned
1380  * rule. */
1381 static struct rule *
1382 rule_create(struct rule *super,
1383             const union ofp_action *actions, size_t n_actions,
1384             uint16_t idle_timeout, uint16_t hard_timeout)
1385 {
1386     struct rule *rule = xcalloc(1, sizeof *rule);
1387     rule->idle_timeout = idle_timeout;
1388     rule->hard_timeout = hard_timeout;
1389     rule->used = rule->created = time_msec();
1390     rule->super = super;
1391     if (super) {
1392         list_push_back(&super->list, &rule->list);
1393     } else {
1394         list_init(&rule->list);
1395     }
1396     rule->n_actions = n_actions;
1397     rule->actions = xmemdup(actions, n_actions * sizeof *actions);
1398     return rule;
1399 }
1400
1401 static struct rule *
1402 rule_from_cls_rule(const struct cls_rule *cls_rule)
1403 {
1404     return cls_rule ? CONTAINER_OF(cls_rule, struct rule, cr) : NULL;
1405 }
1406
1407 static void
1408 rule_free(struct rule *rule)
1409 {
1410     free(rule->actions);
1411     free(rule->odp_actions);
1412     free(rule);
1413 }
1414
1415 /* Destroys 'rule'.  If 'rule' is a subrule, also removes it from its
1416  * super-rule's list of subrules.  If 'rule' is a super-rule, also iterates
1417  * through all of its subrules and revalidates them, destroying any that no
1418  * longer has a super-rule (which is probably all of them).
1419  *
1420  * Before calling this function, the caller must make have removed 'rule' from
1421  * the classifier.  If 'rule' is an exact-match rule, the caller is also
1422  * responsible for ensuring that it has been uninstalled from the datapath. */
1423 static void
1424 rule_destroy(struct ofproto *ofproto, struct rule *rule)
1425 {
1426     if (!rule->super) {
1427         struct rule *subrule, *next;
1428         LIST_FOR_EACH_SAFE (subrule, next, struct rule, list, &rule->list) {
1429             revalidate_rule(ofproto, subrule);
1430         }
1431     } else {
1432         list_remove(&rule->list);
1433     }
1434     rule_free(rule);
1435 }
1436
1437 static bool
1438 rule_has_out_port(const struct rule *rule, uint16_t out_port)
1439 {
1440     const union ofp_action *oa;
1441     struct actions_iterator i;
1442
1443     if (out_port == htons(OFPP_NONE)) {
1444         return true;
1445     }
1446     for (oa = actions_first(&i, rule->actions, rule->n_actions); oa;
1447          oa = actions_next(&i)) {
1448         if (oa->type == htons(OFPAT_OUTPUT) && oa->output.port == out_port) {
1449             return true;
1450         }
1451     }
1452     return false;
1453 }
1454
1455 /* Executes the actions indicated by 'rule' on 'packet', which is in flow
1456  * 'flow' and is considered to have arrived on ODP port 'in_port'.
1457  *
1458  * The flow that 'packet' actually contains does not need to actually match
1459  * 'rule'; the actions in 'rule' will be applied to it either way.  Likewise,
1460  * the packet and byte counters for 'rule' will be credited for the packet sent
1461  * out whether or not the packet actually matches 'rule'.
1462  *
1463  * If 'rule' is an exact-match rule and 'flow' actually equals the rule's flow,
1464  * the caller must already have accurately composed ODP actions for it given
1465  * 'packet' using rule_make_actions().  If 'rule' is a wildcard rule, or if
1466  * 'rule' is an exact-match rule but 'flow' is not the rule's flow, then this
1467  * function will compose a set of ODP actions based on 'rule''s OpenFlow
1468  * actions and apply them to 'packet'. */
1469 static void
1470 rule_execute(struct ofproto *ofproto, struct rule *rule,
1471              struct ofpbuf *packet, const flow_t *flow)
1472 {
1473     const union odp_action *actions;
1474     size_t n_actions;
1475     struct odp_actions a;
1476
1477     /* Grab or compose the ODP actions.
1478      *
1479      * The special case for an exact-match 'rule' where 'flow' is not the
1480      * rule's flow is important to avoid, e.g., sending a packet out its input
1481      * port simply because the ODP actions were composed for the wrong
1482      * scenario. */
1483     if (rule->cr.wc.wildcards || !flow_equal(flow, &rule->cr.flow)) {
1484         struct rule *super = rule->super ? rule->super : rule;
1485         if (xlate_actions(super->actions, super->n_actions, flow, ofproto,
1486                           packet, &a, NULL, 0)) {
1487             return;
1488         }
1489         actions = a.actions;
1490         n_actions = a.n_actions;
1491     } else {
1492         actions = rule->odp_actions;
1493         n_actions = rule->n_odp_actions;
1494     }
1495
1496     /* Execute the ODP actions. */
1497     if (!dpif_execute(ofproto->dpif, flow->in_port,
1498                       actions, n_actions, packet)) {
1499         struct odp_flow_stats stats;
1500         flow_extract_stats(flow, packet, &stats);
1501         update_stats(rule, &stats);
1502         rule->used = time_msec();
1503     }
1504 }
1505
1506 static void
1507 rule_insert(struct ofproto *p, struct rule *rule, struct ofpbuf *packet,
1508             uint16_t in_port)
1509 {
1510     struct rule *displaced_rule;
1511
1512     /* Insert the rule in the classifier. */
1513     displaced_rule = rule_from_cls_rule(classifier_insert(&p->cls, &rule->cr));
1514     if (!rule->cr.wc.wildcards) {
1515         rule_make_actions(p, rule, packet);
1516     }
1517
1518     /* Send the packet and credit it to the rule. */
1519     if (packet) {
1520         flow_t flow;
1521         flow_extract(packet, in_port, &flow);
1522         rule_execute(p, rule, packet, &flow);
1523     }
1524
1525     /* Install the rule in the datapath only after sending the packet, to
1526      * avoid packet reordering.  */
1527     if (rule->cr.wc.wildcards) {
1528         COVERAGE_INC(ofproto_add_wc_flow);
1529         p->need_revalidate = true;
1530     } else {
1531         rule_install(p, rule, displaced_rule);
1532     }
1533
1534     /* Free the rule that was displaced, if any. */
1535     if (displaced_rule) {
1536         rule_destroy(p, displaced_rule);
1537     }
1538 }
1539
1540 static struct rule *
1541 rule_create_subrule(struct ofproto *ofproto, struct rule *rule,
1542                     const flow_t *flow)
1543 {
1544     struct rule *subrule = rule_create(rule, NULL, 0,
1545                                        rule->idle_timeout, rule->hard_timeout);
1546     COVERAGE_INC(ofproto_subrule_create);
1547     cls_rule_from_flow(&subrule->cr, flow, 0,
1548                        (rule->cr.priority <= UINT16_MAX ? UINT16_MAX
1549                         : rule->cr.priority));
1550     classifier_insert_exact(&ofproto->cls, &subrule->cr);
1551
1552     return subrule;
1553 }
1554
1555 static void
1556 rule_remove(struct ofproto *ofproto, struct rule *rule)
1557 {
1558     if (rule->cr.wc.wildcards) {
1559         COVERAGE_INC(ofproto_del_wc_flow);
1560         ofproto->need_revalidate = true;
1561     } else {
1562         rule_uninstall(ofproto, rule);
1563     }
1564     classifier_remove(&ofproto->cls, &rule->cr);
1565     rule_destroy(ofproto, rule);
1566 }
1567
1568 /* Returns true if the actions changed, false otherwise. */
1569 static bool
1570 rule_make_actions(struct ofproto *p, struct rule *rule,
1571                   const struct ofpbuf *packet)
1572 {
1573     const struct rule *super;
1574     struct odp_actions a;
1575     size_t actions_len;
1576
1577     assert(!rule->cr.wc.wildcards);
1578
1579     super = rule->super ? rule->super : rule;
1580     rule->tags = 0;
1581     xlate_actions(super->actions, super->n_actions, &rule->cr.flow, p,
1582                   packet, &a, &rule->tags, &rule->may_install);
1583
1584     actions_len = a.n_actions * sizeof *a.actions;
1585     if (rule->n_odp_actions != a.n_actions
1586         || memcmp(rule->odp_actions, a.actions, actions_len)) {
1587         COVERAGE_INC(ofproto_odp_unchanged);
1588         free(rule->odp_actions);
1589         rule->n_odp_actions = a.n_actions;
1590         rule->odp_actions = xmemdup(a.actions, actions_len);
1591         return true;
1592     } else {
1593         return false;
1594     }
1595 }
1596
1597 static int
1598 do_put_flow(struct ofproto *ofproto, struct rule *rule, int flags,
1599             struct odp_flow_put *put)
1600 {
1601     memset(&put->flow.stats, 0, sizeof put->flow.stats);
1602     put->flow.key = rule->cr.flow;
1603     put->flow.actions = rule->odp_actions;
1604     put->flow.n_actions = rule->n_odp_actions;
1605     put->flags = flags;
1606     return dpif_flow_put(ofproto->dpif, put);
1607 }
1608
1609 static void
1610 rule_install(struct ofproto *p, struct rule *rule, struct rule *displaced_rule)
1611 {
1612     assert(!rule->cr.wc.wildcards);
1613
1614     if (rule->may_install) {
1615         struct odp_flow_put put;
1616         if (!do_put_flow(p, rule,
1617                          ODPPF_CREATE | ODPPF_MODIFY | ODPPF_ZERO_STATS,
1618                          &put)) {
1619             rule->installed = true;
1620             if (displaced_rule) {
1621                 update_stats(rule, &put.flow.stats);
1622                 rule_post_uninstall(p, displaced_rule);
1623             }
1624         }
1625     } else if (displaced_rule) {
1626         rule_uninstall(p, displaced_rule);
1627     }
1628 }
1629
1630 static void
1631 rule_reinstall(struct ofproto *ofproto, struct rule *rule)
1632 {
1633     if (rule->installed) {
1634         struct odp_flow_put put;
1635         COVERAGE_INC(ofproto_dp_missed);
1636         do_put_flow(ofproto, rule, ODPPF_CREATE | ODPPF_MODIFY, &put);
1637     } else {
1638         rule_install(ofproto, rule, NULL);
1639     }
1640 }
1641
1642 static void
1643 rule_update_actions(struct ofproto *ofproto, struct rule *rule)
1644 {
1645     bool actions_changed = rule_make_actions(ofproto, rule, NULL);
1646     if (rule->may_install) {
1647         if (rule->installed) {
1648             if (actions_changed) {
1649                 /* XXX should really do rule_post_uninstall() for the *old* set
1650                  * of actions, and distinguish the old stats from the new. */
1651                 struct odp_flow_put put;
1652                 do_put_flow(ofproto, rule, ODPPF_CREATE | ODPPF_MODIFY, &put);
1653             }
1654         } else {
1655             rule_install(ofproto, rule, NULL);
1656         }
1657     } else {
1658         rule_uninstall(ofproto, rule);
1659     }
1660 }
1661
1662 static void
1663 rule_account(struct ofproto *ofproto, struct rule *rule, uint64_t extra_bytes)
1664 {
1665     uint64_t total_bytes = rule->byte_count + extra_bytes;
1666
1667     if (ofproto->ofhooks->account_flow_cb
1668         && total_bytes > rule->accounted_bytes)
1669     {
1670         ofproto->ofhooks->account_flow_cb(
1671             &rule->cr.flow, rule->odp_actions, rule->n_odp_actions,
1672             total_bytes - rule->accounted_bytes, ofproto->aux);
1673         rule->accounted_bytes = total_bytes;
1674     }
1675 }
1676
1677 static void
1678 rule_uninstall(struct ofproto *p, struct rule *rule)
1679 {
1680     assert(!rule->cr.wc.wildcards);
1681     if (rule->installed) {
1682         struct odp_flow odp_flow;
1683
1684         odp_flow.key = rule->cr.flow;
1685         odp_flow.actions = NULL;
1686         odp_flow.n_actions = 0;
1687         if (!dpif_flow_del(p->dpif, &odp_flow)) {
1688             update_stats(rule, &odp_flow.stats);
1689         }
1690         rule->installed = false;
1691
1692         rule_post_uninstall(p, rule);
1693     }
1694 }
1695
1696 static void
1697 rule_post_uninstall(struct ofproto *ofproto, struct rule *rule)
1698 {
1699     struct rule *super = rule->super;
1700
1701     rule_account(ofproto, rule, 0);
1702     if (ofproto->netflow && rule->byte_count) {
1703         struct ofexpired expired;
1704         expired.flow = rule->cr.flow;
1705         expired.packet_count = rule->packet_count;
1706         expired.byte_count = rule->byte_count;
1707         expired.used = rule->used;
1708         expired.created = rule->created;
1709         expired.tcp_flags = rule->tcp_flags;
1710         expired.ip_tos = rule->ip_tos;
1711         netflow_expire(ofproto->netflow, &expired);
1712     }
1713     if (super) {
1714         super->packet_count += rule->packet_count;
1715         super->byte_count += rule->byte_count;
1716         super->tcp_flags |= rule->tcp_flags;
1717         if (rule->packet_count) {
1718             super->ip_tos = rule->ip_tos;
1719         }
1720     }
1721
1722     /* Reset counters to prevent double counting if the rule ever gets
1723      * reinstalled. */
1724     rule->packet_count = 0;
1725     rule->byte_count = 0;
1726     rule->accounted_bytes = 0;
1727     rule->tcp_flags = 0;
1728     rule->ip_tos = 0;
1729 }
1730 \f
1731 static void
1732 queue_tx(struct ofpbuf *msg, const struct ofconn *ofconn,
1733          struct rconn_packet_counter *counter)
1734 {
1735     update_openflow_length(msg);
1736     if (rconn_send(ofconn->rconn, msg, counter)) {
1737         ofpbuf_delete(msg);
1738     }
1739 }
1740
1741 static void
1742 send_error(const struct ofconn *ofconn, const struct ofp_header *oh,
1743            int error, const void *data, size_t len)
1744 {
1745     struct ofpbuf *buf;
1746     struct ofp_error_msg *oem;
1747
1748     if (!(error >> 16)) {
1749         VLOG_WARN_RL(&rl, "not sending bad error code %d to controller",
1750                      error);
1751         return;
1752     }
1753
1754     COVERAGE_INC(ofproto_error);
1755     oem = make_openflow_xid(len + sizeof *oem, OFPT_ERROR,
1756                             oh ? oh->xid : 0, &buf);
1757     oem->type = htons((unsigned int) error >> 16);
1758     oem->code = htons(error & 0xffff);
1759     memcpy(oem->data, data, len);
1760     queue_tx(buf, ofconn, ofconn->reply_counter);
1761 }
1762
1763 static void
1764 send_error_oh(const struct ofconn *ofconn, const struct ofp_header *oh,
1765               int error)
1766 {
1767     size_t oh_length = ntohs(oh->length);
1768     send_error(ofconn, oh, error, oh, MIN(oh_length, 64));
1769 }
1770
1771 static void
1772 hton_ofp_phy_port(struct ofp_phy_port *opp)
1773 {
1774     opp->port_no = htons(opp->port_no);
1775     opp->config = htonl(opp->config);
1776     opp->state = htonl(opp->state);
1777     opp->curr = htonl(opp->curr);
1778     opp->advertised = htonl(opp->advertised);
1779     opp->supported = htonl(opp->supported);
1780     opp->peer = htonl(opp->peer);
1781 }
1782
1783 static int
1784 handle_echo_request(struct ofconn *ofconn, struct ofp_header *oh)
1785 {
1786     struct ofp_header *rq = oh;
1787     queue_tx(make_echo_reply(rq), ofconn, ofconn->reply_counter);
1788     return 0;
1789 }
1790
1791 static int
1792 handle_features_request(struct ofproto *p, struct ofconn *ofconn,
1793                         struct ofp_header *oh)
1794 {
1795     struct ofp_switch_features *osf;
1796     struct ofpbuf *buf;
1797     unsigned int port_no;
1798     struct ofport *port;
1799
1800     osf = make_openflow_xid(sizeof *osf, OFPT_FEATURES_REPLY, oh->xid, &buf);
1801     osf->datapath_id = htonll(p->datapath_id);
1802     osf->n_buffers = htonl(pktbuf_capacity());
1803     osf->n_tables = 2;
1804     osf->capabilities = htonl(OFPC_FLOW_STATS | OFPC_TABLE_STATS |
1805                               OFPC_PORT_STATS | OFPC_MULTI_PHY_TX);
1806     osf->actions = htonl((1u << OFPAT_OUTPUT) |
1807                          (1u << OFPAT_SET_VLAN_VID) |
1808                          (1u << OFPAT_SET_VLAN_PCP) |
1809                          (1u << OFPAT_STRIP_VLAN) |
1810                          (1u << OFPAT_SET_DL_SRC) |
1811                          (1u << OFPAT_SET_DL_DST) |
1812                          (1u << OFPAT_SET_NW_SRC) |
1813                          (1u << OFPAT_SET_NW_DST) |
1814                          (1u << OFPAT_SET_TP_SRC) |
1815                          (1u << OFPAT_SET_TP_DST));
1816
1817     PORT_ARRAY_FOR_EACH (port, &p->ports, port_no) {
1818         hton_ofp_phy_port(ofpbuf_put(buf, &port->opp, sizeof port->opp));
1819     }
1820
1821     queue_tx(buf, ofconn, ofconn->reply_counter);
1822     return 0;
1823 }
1824
1825 static int
1826 handle_get_config_request(struct ofproto *p, struct ofconn *ofconn,
1827                           struct ofp_header *oh)
1828 {
1829     struct ofpbuf *buf;
1830     struct ofp_switch_config *osc;
1831     uint16_t flags;
1832     bool drop_frags;
1833
1834     /* Figure out flags. */
1835     dpif_get_drop_frags(p->dpif, &drop_frags);
1836     flags = drop_frags ? OFPC_FRAG_DROP : OFPC_FRAG_NORMAL;
1837     if (ofconn->send_flow_exp) {
1838         flags |= OFPC_SEND_FLOW_EXP;
1839     }
1840
1841     /* Send reply. */
1842     osc = make_openflow_xid(sizeof *osc, OFPT_GET_CONFIG_REPLY, oh->xid, &buf);
1843     osc->flags = htons(flags);
1844     osc->miss_send_len = htons(ofconn->miss_send_len);
1845     queue_tx(buf, ofconn, ofconn->reply_counter);
1846
1847     return 0;
1848 }
1849
1850 static int
1851 handle_set_config(struct ofproto *p, struct ofconn *ofconn,
1852                   struct ofp_switch_config *osc)
1853 {
1854     uint16_t flags;
1855     int error;
1856
1857     error = check_ofp_message(&osc->header, OFPT_SET_CONFIG, sizeof *osc);
1858     if (error) {
1859         return error;
1860     }
1861     flags = ntohs(osc->flags);
1862
1863     ofconn->send_flow_exp = (flags & OFPC_SEND_FLOW_EXP) != 0;
1864
1865     if (ofconn == p->controller) {
1866         switch (flags & OFPC_FRAG_MASK) {
1867         case OFPC_FRAG_NORMAL:
1868             dpif_set_drop_frags(p->dpif, false);
1869             break;
1870         case OFPC_FRAG_DROP:
1871             dpif_set_drop_frags(p->dpif, true);
1872             break;
1873         default:
1874             VLOG_WARN_RL(&rl, "requested bad fragment mode (flags=%"PRIx16")",
1875                          osc->flags);
1876             break;
1877         }
1878     }
1879
1880     if ((ntohs(osc->miss_send_len) != 0) != (ofconn->miss_send_len != 0)) {
1881         if (ntohs(osc->miss_send_len) != 0) {
1882             ofconn->pktbuf = pktbuf_create();
1883         } else {
1884             pktbuf_destroy(ofconn->pktbuf);
1885         }
1886     }
1887
1888     ofconn->miss_send_len = ntohs(osc->miss_send_len);
1889
1890     return 0;
1891 }
1892
1893 static void
1894 add_output_group_action(struct odp_actions *actions, uint16_t group)
1895 {
1896     odp_actions_add(actions, ODPAT_OUTPUT_GROUP)->output_group.group = group;
1897 }
1898
1899 static void
1900 add_controller_action(struct odp_actions *actions,
1901                       const struct ofp_action_output *oao)
1902 {
1903     union odp_action *a = odp_actions_add(actions, ODPAT_CONTROLLER);
1904     a->controller.arg = oao->max_len ? ntohs(oao->max_len) : UINT32_MAX;
1905 }
1906
1907 struct action_xlate_ctx {
1908     /* Input. */
1909     const flow_t *flow;         /* Flow to which these actions correspond. */
1910     int recurse;                /* Recursion level, via xlate_table_action. */
1911     struct ofproto *ofproto;
1912     const struct ofpbuf *packet; /* The packet corresponding to 'flow', or a
1913                                   * null pointer if we are revalidating
1914                                   * without a packet to refer to. */
1915
1916     /* Output. */
1917     struct odp_actions *out;    /* Datapath actions. */
1918     tag_type *tags;             /* Tags associated with OFPP_NORMAL actions. */
1919     bool may_setup_flow;        /* True ordinarily; false if the actions must
1920                                  * be reassessed for every packet. */
1921 };
1922
1923 static void do_xlate_actions(const union ofp_action *in, size_t n_in,
1924                              struct action_xlate_ctx *ctx);
1925
1926 static void
1927 add_output_action(struct action_xlate_ctx *ctx, uint16_t port)
1928 {
1929     const struct ofport *ofport = port_array_get(&ctx->ofproto->ports, port);
1930     if (!ofport || !(ofport->opp.config & OFPPC_NO_FWD)) {
1931         odp_actions_add(ctx->out, ODPAT_OUTPUT)->output.port = port;
1932     }
1933 }
1934
1935 static struct rule *
1936 lookup_valid_rule(struct ofproto *ofproto, const flow_t *flow)
1937 {
1938     struct rule *rule;
1939     rule = rule_from_cls_rule(classifier_lookup(&ofproto->cls, flow));
1940
1941     /* The rule we found might not be valid, since we could be in need of
1942      * revalidation.  If it is not valid, don't return it. */
1943     if (rule
1944         && rule->super
1945         && ofproto->need_revalidate
1946         && !revalidate_rule(ofproto, rule)) {
1947         COVERAGE_INC(ofproto_invalidated);
1948         return NULL;
1949     }
1950
1951     return rule;
1952 }
1953
1954 static void
1955 xlate_table_action(struct action_xlate_ctx *ctx, uint16_t in_port)
1956 {
1957     if (!ctx->recurse) {
1958         struct rule *rule;
1959         flow_t flow;
1960
1961         flow = *ctx->flow;
1962         flow.in_port = in_port;
1963
1964         rule = lookup_valid_rule(ctx->ofproto, &flow);
1965         if (rule) {
1966             if (rule->super) {
1967                 rule = rule->super;
1968             }
1969
1970             ctx->recurse++;
1971             do_xlate_actions(rule->actions, rule->n_actions, ctx);
1972             ctx->recurse--;
1973         }
1974     }
1975 }
1976
1977 static void
1978 xlate_output_action(struct action_xlate_ctx *ctx,
1979                     const struct ofp_action_output *oao)
1980 {
1981     uint16_t odp_port;
1982
1983     switch (ntohs(oao->port)) {
1984     case OFPP_IN_PORT:
1985         add_output_action(ctx, ctx->flow->in_port);
1986         break;
1987     case OFPP_TABLE:
1988         xlate_table_action(ctx, ctx->flow->in_port);
1989         break;
1990     case OFPP_NORMAL:
1991         if (!ctx->ofproto->ofhooks->normal_cb(ctx->flow, ctx->packet,
1992                                               ctx->out, ctx->tags,
1993                                               ctx->ofproto->aux)) {
1994             COVERAGE_INC(ofproto_uninstallable);
1995             ctx->may_setup_flow = false;
1996         }
1997         break;
1998     case OFPP_FLOOD:
1999         add_output_group_action(ctx->out, DP_GROUP_FLOOD);
2000         break;
2001     case OFPP_ALL:
2002         add_output_group_action(ctx->out, DP_GROUP_ALL);
2003         break;
2004     case OFPP_CONTROLLER:
2005         add_controller_action(ctx->out, oao);
2006         break;
2007     case OFPP_LOCAL:
2008         add_output_action(ctx, ODPP_LOCAL);
2009         break;
2010     default:
2011         odp_port = ofp_port_to_odp_port(ntohs(oao->port));
2012         if (odp_port != ctx->flow->in_port) {
2013             add_output_action(ctx, odp_port);
2014         }
2015         break;
2016     }
2017 }
2018
2019 static void
2020 xlate_nicira_action(struct action_xlate_ctx *ctx,
2021                     const struct nx_action_header *nah)
2022 {
2023     const struct nx_action_resubmit *nar;
2024     int subtype = ntohs(nah->subtype);
2025
2026     assert(nah->vendor == htonl(NX_VENDOR_ID));
2027     switch (subtype) {
2028     case NXAST_RESUBMIT:
2029         nar = (const struct nx_action_resubmit *) nah;
2030         xlate_table_action(ctx, ofp_port_to_odp_port(ntohs(nar->in_port)));
2031         break;
2032
2033     default:
2034         VLOG_DBG_RL(&rl, "unknown Nicira action type %"PRIu16, subtype);
2035         break;
2036     }
2037 }
2038
2039 static void
2040 do_xlate_actions(const union ofp_action *in, size_t n_in,
2041                  struct action_xlate_ctx *ctx)
2042 {
2043     struct actions_iterator iter;
2044     const union ofp_action *ia;
2045     const struct ofport *port;
2046
2047     port = port_array_get(&ctx->ofproto->ports, ctx->flow->in_port);
2048     if (port && port->opp.config & (OFPPC_NO_RECV | OFPPC_NO_RECV_STP) &&
2049         port->opp.config & (eth_addr_equals(ctx->flow->dl_dst, stp_eth_addr)
2050                             ? OFPPC_NO_RECV_STP : OFPPC_NO_RECV)) {
2051         /* Drop this flow. */
2052         return;
2053     }
2054
2055     for (ia = actions_first(&iter, in, n_in); ia; ia = actions_next(&iter)) {
2056         uint16_t type = ntohs(ia->type);
2057         union odp_action *oa;
2058
2059         switch (type) {
2060         case OFPAT_OUTPUT:
2061             xlate_output_action(ctx, &ia->output);
2062             break;
2063
2064         case OFPAT_SET_VLAN_VID:
2065             oa = odp_actions_add(ctx->out, ODPAT_SET_VLAN_VID);
2066             oa->vlan_vid.vlan_vid = ia->vlan_vid.vlan_vid;
2067             break;
2068
2069         case OFPAT_SET_VLAN_PCP:
2070             oa = odp_actions_add(ctx->out, ODPAT_SET_VLAN_PCP);
2071             oa->vlan_pcp.vlan_pcp = ia->vlan_pcp.vlan_pcp;
2072             break;
2073
2074         case OFPAT_STRIP_VLAN:
2075             odp_actions_add(ctx->out, ODPAT_STRIP_VLAN);
2076             break;
2077
2078         case OFPAT_SET_DL_SRC:
2079             oa = odp_actions_add(ctx->out, ODPAT_SET_DL_SRC);
2080             memcpy(oa->dl_addr.dl_addr,
2081                    ((struct ofp_action_dl_addr *) ia)->dl_addr, ETH_ADDR_LEN);
2082             break;
2083
2084         case OFPAT_SET_DL_DST:
2085             oa = odp_actions_add(ctx->out, ODPAT_SET_DL_DST);
2086             memcpy(oa->dl_addr.dl_addr,
2087                    ((struct ofp_action_dl_addr *) ia)->dl_addr, ETH_ADDR_LEN);
2088             break;
2089
2090         case OFPAT_SET_NW_SRC:
2091             oa = odp_actions_add(ctx->out, ODPAT_SET_NW_SRC);
2092             oa->nw_addr.nw_addr = ia->nw_addr.nw_addr;
2093             break;
2094
2095         case OFPAT_SET_TP_SRC:
2096             oa = odp_actions_add(ctx->out, ODPAT_SET_TP_SRC);
2097             oa->tp_port.tp_port = ia->tp_port.tp_port;
2098             break;
2099
2100         case OFPAT_VENDOR:
2101             xlate_nicira_action(ctx, (const struct nx_action_header *) ia);
2102             break;
2103
2104         default:
2105             VLOG_DBG_RL(&rl, "unknown action type %"PRIu16, type);
2106             break;
2107         }
2108     }
2109 }
2110
2111 static int
2112 xlate_actions(const union ofp_action *in, size_t n_in,
2113               const flow_t *flow, struct ofproto *ofproto,
2114               const struct ofpbuf *packet,
2115               struct odp_actions *out, tag_type *tags, bool *may_setup_flow)
2116 {
2117     tag_type no_tags = 0;
2118     struct action_xlate_ctx ctx;
2119     COVERAGE_INC(ofproto_ofp2odp);
2120     odp_actions_init(out);
2121     ctx.flow = flow;
2122     ctx.recurse = 0;
2123     ctx.ofproto = ofproto;
2124     ctx.packet = packet;
2125     ctx.out = out;
2126     ctx.tags = tags ? tags : &no_tags;
2127     ctx.may_setup_flow = true;
2128     do_xlate_actions(in, n_in, &ctx);
2129
2130     /* Check with in-band control to see if we're allowed to setup this
2131      * flow. */
2132     if (!in_band_rule_check(ofproto->in_band, flow, out)) {
2133         ctx.may_setup_flow = false;
2134     }
2135
2136     if (may_setup_flow) {
2137         *may_setup_flow = ctx.may_setup_flow;
2138     }
2139     if (odp_actions_overflow(out)) {
2140         odp_actions_init(out);
2141         return ofp_mkerr(OFPET_BAD_ACTION, OFPBAC_TOO_MANY);
2142     }
2143     return 0;
2144 }
2145
2146 static int
2147 handle_packet_out(struct ofproto *p, struct ofconn *ofconn,
2148                   struct ofp_header *oh)
2149 {
2150     struct ofp_packet_out *opo;
2151     struct ofpbuf payload, *buffer;
2152     struct odp_actions actions;
2153     int n_actions;
2154     uint16_t in_port;
2155     flow_t flow;
2156     int error;
2157
2158     error = check_ofp_packet_out(oh, &payload, &n_actions, p->max_ports);
2159     if (error) {
2160         return error;
2161     }
2162     opo = (struct ofp_packet_out *) oh;
2163
2164     COVERAGE_INC(ofproto_packet_out);
2165     if (opo->buffer_id != htonl(UINT32_MAX)) {
2166         error = pktbuf_retrieve(ofconn->pktbuf, ntohl(opo->buffer_id),
2167                                 &buffer, &in_port);
2168         if (error) {
2169             return error;
2170         }
2171         payload = *buffer;
2172     } else {
2173         buffer = NULL;
2174     }
2175
2176     flow_extract(&payload, ofp_port_to_odp_port(ntohs(opo->in_port)), &flow);
2177     error = xlate_actions((const union ofp_action *) opo->actions, n_actions,
2178                           &flow, p, &payload, &actions, NULL, NULL);
2179     if (error) {
2180         return error;
2181     }
2182
2183     dpif_execute(p->dpif, flow.in_port, actions.actions, actions.n_actions,
2184                  &payload);
2185     ofpbuf_delete(buffer);
2186
2187     return 0;
2188 }
2189
2190 static void
2191 update_port_config(struct ofproto *p, struct ofport *port,
2192                    uint32_t config, uint32_t mask)
2193 {
2194     mask &= config ^ port->opp.config;
2195     if (mask & OFPPC_PORT_DOWN) {
2196         if (config & OFPPC_PORT_DOWN) {
2197             netdev_turn_flags_off(port->netdev, NETDEV_UP, true);
2198         } else {
2199             netdev_turn_flags_on(port->netdev, NETDEV_UP, true);
2200         }
2201     }
2202 #define REVALIDATE_BITS (OFPPC_NO_RECV | OFPPC_NO_RECV_STP | OFPPC_NO_FWD)
2203     if (mask & REVALIDATE_BITS) {
2204         COVERAGE_INC(ofproto_costly_flags);
2205         port->opp.config ^= mask & REVALIDATE_BITS;
2206         p->need_revalidate = true;
2207     }
2208 #undef REVALIDATE_BITS
2209     if (mask & OFPPC_NO_FLOOD) {
2210         port->opp.config ^= OFPPC_NO_FLOOD;
2211         refresh_port_group(p, DP_GROUP_FLOOD);
2212     }
2213     if (mask & OFPPC_NO_PACKET_IN) {
2214         port->opp.config ^= OFPPC_NO_PACKET_IN;
2215     }
2216 }
2217
2218 static int
2219 handle_port_mod(struct ofproto *p, struct ofp_header *oh)
2220 {
2221     const struct ofp_port_mod *opm;
2222     struct ofport *port;
2223     int error;
2224
2225     error = check_ofp_message(oh, OFPT_PORT_MOD, sizeof *opm);
2226     if (error) {
2227         return error;
2228     }
2229     opm = (struct ofp_port_mod *) oh;
2230
2231     port = port_array_get(&p->ports,
2232                           ofp_port_to_odp_port(ntohs(opm->port_no)));
2233     if (!port) {
2234         return ofp_mkerr(OFPET_PORT_MOD_FAILED, OFPPMFC_BAD_PORT);
2235     } else if (memcmp(port->opp.hw_addr, opm->hw_addr, OFP_ETH_ALEN)) {
2236         return ofp_mkerr(OFPET_PORT_MOD_FAILED, OFPPMFC_BAD_HW_ADDR);
2237     } else {
2238         update_port_config(p, port, ntohl(opm->config), ntohl(opm->mask));
2239         if (opm->advertise) {
2240             netdev_set_advertisements(port->netdev, ntohl(opm->advertise));
2241         }
2242     }
2243     return 0;
2244 }
2245
2246 static struct ofpbuf *
2247 make_stats_reply(uint32_t xid, uint16_t type, size_t body_len)
2248 {
2249     struct ofp_stats_reply *osr;
2250     struct ofpbuf *msg;
2251
2252     msg = ofpbuf_new(MIN(sizeof *osr + body_len, UINT16_MAX));
2253     osr = put_openflow_xid(sizeof *osr, OFPT_STATS_REPLY, xid, msg);
2254     osr->type = type;
2255     osr->flags = htons(0);
2256     return msg;
2257 }
2258
2259 static struct ofpbuf *
2260 start_stats_reply(const struct ofp_stats_request *request, size_t body_len)
2261 {
2262     return make_stats_reply(request->header.xid, request->type, body_len);
2263 }
2264
2265 static void *
2266 append_stats_reply(size_t nbytes, struct ofconn *ofconn, struct ofpbuf **msgp)
2267 {
2268     struct ofpbuf *msg = *msgp;
2269     assert(nbytes <= UINT16_MAX - sizeof(struct ofp_stats_reply));
2270     if (nbytes + msg->size > UINT16_MAX) {
2271         struct ofp_stats_reply *reply = msg->data;
2272         reply->flags = htons(OFPSF_REPLY_MORE);
2273         *msgp = make_stats_reply(reply->header.xid, reply->type, nbytes);
2274         queue_tx(msg, ofconn, ofconn->reply_counter);
2275     }
2276     return ofpbuf_put_uninit(*msgp, nbytes);
2277 }
2278
2279 static int
2280 handle_desc_stats_request(struct ofproto *p, struct ofconn *ofconn,
2281                            struct ofp_stats_request *request)
2282 {
2283     struct ofp_desc_stats *ods;
2284     struct ofpbuf *msg;
2285
2286     msg = start_stats_reply(request, sizeof *ods);
2287     ods = append_stats_reply(sizeof *ods, ofconn, &msg);
2288     strncpy(ods->mfr_desc, p->manufacturer, sizeof ods->mfr_desc);
2289     strncpy(ods->hw_desc, p->hardware, sizeof ods->hw_desc);
2290     strncpy(ods->sw_desc, p->software, sizeof ods->sw_desc);
2291     strncpy(ods->serial_num, p->serial, sizeof ods->serial_num);
2292     queue_tx(msg, ofconn, ofconn->reply_counter);
2293
2294     return 0;
2295 }
2296
2297 static void
2298 count_subrules(struct cls_rule *cls_rule, void *n_subrules_)
2299 {
2300     struct rule *rule = rule_from_cls_rule(cls_rule);
2301     int *n_subrules = n_subrules_;
2302
2303     if (rule->super) {
2304         (*n_subrules)++;
2305     }
2306 }
2307
2308 static int
2309 handle_table_stats_request(struct ofproto *p, struct ofconn *ofconn,
2310                            struct ofp_stats_request *request)
2311 {
2312     struct ofp_table_stats *ots;
2313     struct ofpbuf *msg;
2314     struct odp_stats dpstats;
2315     int n_exact, n_subrules, n_wild;
2316
2317     msg = start_stats_reply(request, sizeof *ots * 2);
2318
2319     /* Count rules of various kinds. */
2320     n_subrules = 0;
2321     classifier_for_each(&p->cls, CLS_INC_EXACT, count_subrules, &n_subrules);
2322     n_exact = classifier_count_exact(&p->cls) - n_subrules;
2323     n_wild = classifier_count(&p->cls) - classifier_count_exact(&p->cls);
2324
2325     /* Hash table. */
2326     dpif_get_dp_stats(p->dpif, &dpstats);
2327     ots = append_stats_reply(sizeof *ots, ofconn, &msg);
2328     memset(ots, 0, sizeof *ots);
2329     ots->table_id = TABLEID_HASH;
2330     strcpy(ots->name, "hash");
2331     ots->wildcards = htonl(0);
2332     ots->max_entries = htonl(dpstats.max_capacity);
2333     ots->active_count = htonl(n_exact);
2334     ots->lookup_count = htonll(dpstats.n_frags + dpstats.n_hit +
2335                                dpstats.n_missed);
2336     ots->matched_count = htonll(dpstats.n_hit); /* XXX */
2337
2338     /* Classifier table. */
2339     ots = append_stats_reply(sizeof *ots, ofconn, &msg);
2340     memset(ots, 0, sizeof *ots);
2341     ots->table_id = TABLEID_CLASSIFIER;
2342     strcpy(ots->name, "classifier");
2343     ots->wildcards = htonl(OFPFW_ALL);
2344     ots->max_entries = htonl(65536);
2345     ots->active_count = htonl(n_wild);
2346     ots->lookup_count = htonll(0);              /* XXX */
2347     ots->matched_count = htonll(0);             /* XXX */
2348
2349     queue_tx(msg, ofconn, ofconn->reply_counter);
2350     return 0;
2351 }
2352
2353 static int
2354 handle_port_stats_request(struct ofproto *p, struct ofconn *ofconn,
2355                           struct ofp_stats_request *request)
2356 {
2357     struct ofp_port_stats *ops;
2358     struct ofpbuf *msg;
2359     struct ofport *port;
2360     unsigned int port_no;
2361
2362     msg = start_stats_reply(request, sizeof *ops * 16);
2363     PORT_ARRAY_FOR_EACH (port, &p->ports, port_no) {
2364         struct netdev_stats stats;
2365
2366         /* Intentionally ignore return value, since errors will set 'stats' to
2367          * all-1s, which is correct for OpenFlow, and netdev_get_stats() will
2368          * log errors. */
2369         netdev_get_stats(port->netdev, &stats);
2370
2371         ops = append_stats_reply(sizeof *ops, ofconn, &msg);
2372         ops->port_no = htons(odp_port_to_ofp_port(port_no));
2373         memset(ops->pad, 0, sizeof ops->pad);
2374         ops->rx_packets = htonll(stats.rx_packets);
2375         ops->tx_packets = htonll(stats.tx_packets);
2376         ops->rx_bytes = htonll(stats.rx_bytes);
2377         ops->tx_bytes = htonll(stats.tx_bytes);
2378         ops->rx_dropped = htonll(stats.rx_dropped);
2379         ops->tx_dropped = htonll(stats.tx_dropped);
2380         ops->rx_errors = htonll(stats.rx_errors);
2381         ops->tx_errors = htonll(stats.tx_errors);
2382         ops->rx_frame_err = htonll(stats.rx_frame_errors);
2383         ops->rx_over_err = htonll(stats.rx_over_errors);
2384         ops->rx_crc_err = htonll(stats.rx_crc_errors);
2385         ops->collisions = htonll(stats.collisions);
2386     }
2387
2388     queue_tx(msg, ofconn, ofconn->reply_counter);
2389     return 0;
2390 }
2391
2392 struct flow_stats_cbdata {
2393     struct ofproto *ofproto;
2394     struct ofconn *ofconn;
2395     uint16_t out_port;
2396     struct ofpbuf *msg;
2397 };
2398
2399 static void
2400 query_stats(struct ofproto *p, struct rule *rule,
2401             uint64_t *packet_countp, uint64_t *byte_countp)
2402 {
2403     uint64_t packet_count, byte_count;
2404     struct rule *subrule;
2405     struct odp_flow *odp_flows;
2406     size_t n_odp_flows;
2407
2408     n_odp_flows = rule->cr.wc.wildcards ? list_size(&rule->list) : 1;
2409     odp_flows = xcalloc(1, n_odp_flows * sizeof *odp_flows);
2410     if (rule->cr.wc.wildcards) {
2411         size_t i = 0;
2412         LIST_FOR_EACH (subrule, struct rule, list, &rule->list) {
2413             odp_flows[i++].key = subrule->cr.flow;
2414         }
2415     } else {
2416         odp_flows[0].key = rule->cr.flow;
2417     }
2418
2419     packet_count = rule->packet_count;
2420     byte_count = rule->byte_count;
2421     if (!dpif_flow_get_multiple(p->dpif, odp_flows, n_odp_flows)) {
2422         size_t i;
2423         for (i = 0; i < n_odp_flows; i++) {
2424             struct odp_flow *odp_flow = &odp_flows[i];
2425             packet_count += odp_flow->stats.n_packets;
2426             byte_count += odp_flow->stats.n_bytes;
2427         }
2428     }
2429     free(odp_flows);
2430
2431     *packet_countp = packet_count;
2432     *byte_countp = byte_count;
2433 }
2434
2435 static void
2436 flow_stats_cb(struct cls_rule *rule_, void *cbdata_)
2437 {
2438     struct rule *rule = rule_from_cls_rule(rule_);
2439     struct flow_stats_cbdata *cbdata = cbdata_;
2440     struct ofp_flow_stats *ofs;
2441     uint64_t packet_count, byte_count;
2442     size_t act_len, len;
2443
2444     if (rule_is_hidden(rule) || !rule_has_out_port(rule, cbdata->out_port)) {
2445         return;
2446     }
2447
2448     act_len = sizeof *rule->actions * rule->n_actions;
2449     len = offsetof(struct ofp_flow_stats, actions) + act_len;
2450
2451     query_stats(cbdata->ofproto, rule, &packet_count, &byte_count);
2452
2453     ofs = append_stats_reply(len, cbdata->ofconn, &cbdata->msg);
2454     ofs->length = htons(len);
2455     ofs->table_id = rule->cr.wc.wildcards ? TABLEID_CLASSIFIER : TABLEID_HASH;
2456     ofs->pad = 0;
2457     flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, &ofs->match);
2458     ofs->duration = htonl((time_msec() - rule->created) / 1000);
2459     ofs->priority = htons(rule->cr.priority);
2460     ofs->idle_timeout = htons(rule->idle_timeout);
2461     ofs->hard_timeout = htons(rule->hard_timeout);
2462     memset(ofs->pad2, 0, sizeof ofs->pad2);
2463     ofs->packet_count = htonll(packet_count);
2464     ofs->byte_count = htonll(byte_count);
2465     memcpy(ofs->actions, rule->actions, act_len);
2466 }
2467
2468 static int
2469 table_id_to_include(uint8_t table_id)
2470 {
2471     return (table_id == TABLEID_HASH ? CLS_INC_EXACT
2472             : table_id == TABLEID_CLASSIFIER ? CLS_INC_WILD
2473             : table_id == 0xff ? CLS_INC_ALL
2474             : 0);
2475 }
2476
2477 static int
2478 handle_flow_stats_request(struct ofproto *p, struct ofconn *ofconn,
2479                           const struct ofp_stats_request *osr,
2480                           size_t arg_size)
2481 {
2482     struct ofp_flow_stats_request *fsr;
2483     struct flow_stats_cbdata cbdata;
2484     struct cls_rule target;
2485
2486     if (arg_size != sizeof *fsr) {
2487         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
2488     }
2489     fsr = (struct ofp_flow_stats_request *) osr->body;
2490
2491     COVERAGE_INC(ofproto_flows_req);
2492     cbdata.ofproto = p;
2493     cbdata.ofconn = ofconn;
2494     cbdata.out_port = fsr->out_port;
2495     cbdata.msg = start_stats_reply(osr, 1024);
2496     cls_rule_from_match(&target, &fsr->match, 0);
2497     classifier_for_each_match(&p->cls, &target,
2498                               table_id_to_include(fsr->table_id),
2499                               flow_stats_cb, &cbdata);
2500     queue_tx(cbdata.msg, ofconn, ofconn->reply_counter);
2501     return 0;
2502 }
2503
2504 struct flow_stats_ds_cbdata {
2505     struct ofproto *ofproto;
2506     struct ds *results;
2507 };
2508
2509 static void
2510 flow_stats_ds_cb(struct cls_rule *rule_, void *cbdata_)
2511 {
2512     struct rule *rule = rule_from_cls_rule(rule_);
2513     struct flow_stats_ds_cbdata *cbdata = cbdata_;
2514     struct ds *results = cbdata->results;
2515     struct ofp_match match;
2516     uint64_t packet_count, byte_count;
2517     size_t act_len = sizeof *rule->actions * rule->n_actions;
2518
2519     /* Don't report on subrules. */
2520     if (rule->super != NULL) {
2521         return;
2522     }
2523
2524     query_stats(cbdata->ofproto, rule, &packet_count, &byte_count);
2525     flow_to_ovs_match(&rule->cr.flow, rule->cr.wc.wildcards, &match);
2526
2527     ds_put_format(results, "duration=%llds, ",
2528                   (time_msec() - rule->created) / 1000);
2529     ds_put_format(results, "priority=%u, ", rule->cr.priority);
2530     ds_put_format(results, "n_packets=%"PRIu64", ", packet_count);
2531     ds_put_format(results, "n_bytes=%"PRIu64", ", byte_count);
2532     ofp_print_match(results, &match, true);
2533     ofp_print_actions(results, &rule->actions->header, act_len);
2534     ds_put_cstr(results, "\n");
2535 }
2536
2537 /* Adds a pretty-printed description of all flows to 'results', including 
2538  * those marked hidden by secchan (e.g., by in-band control). */
2539 void
2540 ofproto_get_all_flows(struct ofproto *p, struct ds *results)
2541 {
2542     struct ofp_match match;
2543     struct cls_rule target;
2544     struct flow_stats_ds_cbdata cbdata;
2545
2546     memset(&match, 0, sizeof match);
2547     match.wildcards = htonl(OFPFW_ALL);
2548
2549     cbdata.ofproto = p;
2550     cbdata.results = results;
2551
2552     cls_rule_from_match(&target, &match, 0);
2553     classifier_for_each_match(&p->cls, &target, CLS_INC_ALL,
2554                               flow_stats_ds_cb, &cbdata);
2555 }
2556
2557 struct aggregate_stats_cbdata {
2558     struct ofproto *ofproto;
2559     uint16_t out_port;
2560     uint64_t packet_count;
2561     uint64_t byte_count;
2562     uint32_t n_flows;
2563 };
2564
2565 static void
2566 aggregate_stats_cb(struct cls_rule *rule_, void *cbdata_)
2567 {
2568     struct rule *rule = rule_from_cls_rule(rule_);
2569     struct aggregate_stats_cbdata *cbdata = cbdata_;
2570     uint64_t packet_count, byte_count;
2571
2572     if (rule_is_hidden(rule) || !rule_has_out_port(rule, cbdata->out_port)) {
2573         return;
2574     }
2575
2576     query_stats(cbdata->ofproto, rule, &packet_count, &byte_count);
2577
2578     cbdata->packet_count += packet_count;
2579     cbdata->byte_count += byte_count;
2580     cbdata->n_flows++;
2581 }
2582
2583 static int
2584 handle_aggregate_stats_request(struct ofproto *p, struct ofconn *ofconn,
2585                                const struct ofp_stats_request *osr,
2586                                size_t arg_size)
2587 {
2588     struct ofp_aggregate_stats_request *asr;
2589     struct ofp_aggregate_stats_reply *reply;
2590     struct aggregate_stats_cbdata cbdata;
2591     struct cls_rule target;
2592     struct ofpbuf *msg;
2593
2594     if (arg_size != sizeof *asr) {
2595         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
2596     }
2597     asr = (struct ofp_aggregate_stats_request *) osr->body;
2598
2599     COVERAGE_INC(ofproto_agg_request);
2600     cbdata.ofproto = p;
2601     cbdata.out_port = asr->out_port;
2602     cbdata.packet_count = 0;
2603     cbdata.byte_count = 0;
2604     cbdata.n_flows = 0;
2605     cls_rule_from_match(&target, &asr->match, 0);
2606     classifier_for_each_match(&p->cls, &target,
2607                               table_id_to_include(asr->table_id),
2608                               aggregate_stats_cb, &cbdata);
2609
2610     msg = start_stats_reply(osr, sizeof *reply);
2611     reply = append_stats_reply(sizeof *reply, ofconn, &msg);
2612     reply->flow_count = htonl(cbdata.n_flows);
2613     reply->packet_count = htonll(cbdata.packet_count);
2614     reply->byte_count = htonll(cbdata.byte_count);
2615     queue_tx(msg, ofconn, ofconn->reply_counter);
2616     return 0;
2617 }
2618
2619 static int
2620 handle_stats_request(struct ofproto *p, struct ofconn *ofconn,
2621                      struct ofp_header *oh)
2622 {
2623     struct ofp_stats_request *osr;
2624     size_t arg_size;
2625     int error;
2626
2627     error = check_ofp_message_array(oh, OFPT_STATS_REQUEST, sizeof *osr,
2628                                     1, &arg_size);
2629     if (error) {
2630         return error;
2631     }
2632     osr = (struct ofp_stats_request *) oh;
2633
2634     switch (ntohs(osr->type)) {
2635     case OFPST_DESC:
2636         return handle_desc_stats_request(p, ofconn, osr);
2637
2638     case OFPST_FLOW:
2639         return handle_flow_stats_request(p, ofconn, osr, arg_size);
2640
2641     case OFPST_AGGREGATE:
2642         return handle_aggregate_stats_request(p, ofconn, osr, arg_size);
2643
2644     case OFPST_TABLE:
2645         return handle_table_stats_request(p, ofconn, osr);
2646
2647     case OFPST_PORT:
2648         return handle_port_stats_request(p, ofconn, osr);
2649
2650     case OFPST_VENDOR:
2651         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_VENDOR);
2652
2653     default:
2654         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_STAT);
2655     }
2656 }
2657
2658 static long long int
2659 msec_from_nsec(uint64_t sec, uint32_t nsec)
2660 {
2661     return !sec ? 0 : sec * 1000 + nsec / 1000000;
2662 }
2663
2664 static void
2665 update_time(struct rule *rule, const struct odp_flow_stats *stats)
2666 {
2667     long long int used = msec_from_nsec(stats->used_sec, stats->used_nsec);
2668     if (used > rule->used) {
2669         rule->used = used;
2670     }
2671 }
2672
2673 static void
2674 update_stats(struct rule *rule, const struct odp_flow_stats *stats)
2675 {
2676     update_time(rule, stats);
2677     rule->packet_count += stats->n_packets;
2678     rule->byte_count += stats->n_bytes;
2679     rule->tcp_flags |= stats->tcp_flags;
2680     if (stats->n_packets) {
2681         rule->ip_tos = stats->ip_tos;
2682     }
2683 }
2684
2685 static int
2686 add_flow(struct ofproto *p, struct ofconn *ofconn,
2687          struct ofp_flow_mod *ofm, size_t n_actions)
2688 {
2689     struct ofpbuf *packet;
2690     struct rule *rule;
2691     uint16_t in_port;
2692     int error;
2693
2694     rule = rule_create(NULL, (const union ofp_action *) ofm->actions,
2695                        n_actions, ntohs(ofm->idle_timeout),
2696                        ntohs(ofm->hard_timeout));
2697     cls_rule_from_match(&rule->cr, &ofm->match, ntohs(ofm->priority));
2698
2699     packet = NULL;
2700     error = 0;
2701     if (ofm->buffer_id != htonl(UINT32_MAX)) {
2702         error = pktbuf_retrieve(ofconn->pktbuf, ntohl(ofm->buffer_id),
2703                                 &packet, &in_port);
2704     }
2705
2706     rule_insert(p, rule, packet, in_port);
2707     ofpbuf_delete(packet);
2708     return error;
2709 }
2710
2711 static int
2712 modify_flow(struct ofproto *p, const struct ofp_flow_mod *ofm,
2713             size_t n_actions, uint16_t command, struct rule *rule)
2714 {
2715     if (rule_is_hidden(rule)) {
2716         return 0;
2717     }
2718
2719     if (command == OFPFC_DELETE) {
2720         rule_remove(p, rule);
2721     } else {
2722         size_t actions_len = n_actions * sizeof *rule->actions;
2723
2724         if (n_actions == rule->n_actions
2725             && !memcmp(ofm->actions, rule->actions, actions_len))
2726         {
2727             return 0;
2728         }
2729
2730         free(rule->actions);
2731         rule->actions = xmemdup(ofm->actions, actions_len);
2732         rule->n_actions = n_actions;
2733
2734         if (rule->cr.wc.wildcards) {
2735             COVERAGE_INC(ofproto_mod_wc_flow);
2736             p->need_revalidate = true;
2737         } else {
2738             rule_update_actions(p, rule);
2739         }
2740     }
2741
2742     return 0;
2743 }
2744
2745 static int
2746 modify_flows_strict(struct ofproto *p, const struct ofp_flow_mod *ofm,
2747                     size_t n_actions, uint16_t command)
2748 {
2749     struct rule *rule;
2750     uint32_t wildcards;
2751     flow_t flow;
2752
2753     flow_from_match(&flow, &wildcards, &ofm->match);
2754     rule = rule_from_cls_rule(classifier_find_rule_exactly(
2755                                   &p->cls, &flow, wildcards,
2756                                   ntohs(ofm->priority)));
2757
2758     if (rule) {
2759         if (command == OFPFC_DELETE
2760             && ofm->out_port != htons(OFPP_NONE)
2761             && !rule_has_out_port(rule, ofm->out_port)) {
2762             return 0;
2763         }
2764
2765         modify_flow(p, ofm, n_actions, command, rule);
2766     }
2767     return 0;
2768 }
2769
2770 struct modify_flows_cbdata {
2771     struct ofproto *ofproto;
2772     const struct ofp_flow_mod *ofm;
2773     uint16_t out_port;
2774     size_t n_actions;
2775     uint16_t command;
2776 };
2777
2778 static void
2779 modify_flows_cb(struct cls_rule *rule_, void *cbdata_)
2780 {
2781     struct rule *rule = rule_from_cls_rule(rule_);
2782     struct modify_flows_cbdata *cbdata = cbdata_;
2783
2784     if (cbdata->out_port != htons(OFPP_NONE)
2785         && !rule_has_out_port(rule, cbdata->out_port)) {
2786         return;
2787     }
2788
2789     modify_flow(cbdata->ofproto, cbdata->ofm, cbdata->n_actions,
2790                 cbdata->command, rule);
2791 }
2792
2793 static int
2794 modify_flows_loose(struct ofproto *p, const struct ofp_flow_mod *ofm,
2795                    size_t n_actions, uint16_t command)
2796 {
2797     struct modify_flows_cbdata cbdata;
2798     struct cls_rule target;
2799
2800     cbdata.ofproto = p;
2801     cbdata.ofm = ofm;
2802     cbdata.out_port = (command == OFPFC_DELETE ? ofm->out_port
2803                        : htons(OFPP_NONE));
2804     cbdata.n_actions = n_actions;
2805     cbdata.command = command;
2806
2807     cls_rule_from_match(&target, &ofm->match, 0);
2808
2809     classifier_for_each_match(&p->cls, &target, CLS_INC_ALL,
2810                               modify_flows_cb, &cbdata);
2811     return 0;
2812 }
2813
2814 static int
2815 handle_flow_mod(struct ofproto *p, struct ofconn *ofconn,
2816                 struct ofp_flow_mod *ofm)
2817 {
2818     size_t n_actions;
2819     int error;
2820
2821     error = check_ofp_message_array(&ofm->header, OFPT_FLOW_MOD, sizeof *ofm,
2822                                     sizeof *ofm->actions, &n_actions);
2823     if (error) {
2824         return error;
2825     }
2826
2827     normalize_match(&ofm->match);
2828     if (!ofm->match.wildcards) {
2829         ofm->priority = htons(UINT16_MAX);
2830     }
2831
2832     error = validate_actions((const union ofp_action *) ofm->actions,
2833                              n_actions, p->max_ports);
2834     if (error) {
2835         return error;
2836     }
2837
2838     switch (ntohs(ofm->command)) {
2839     case OFPFC_ADD:
2840         return add_flow(p, ofconn, ofm, n_actions);
2841
2842     case OFPFC_MODIFY:
2843         return modify_flows_loose(p, ofm, n_actions, OFPFC_MODIFY);
2844
2845     case OFPFC_MODIFY_STRICT:
2846         return modify_flows_strict(p, ofm, n_actions, OFPFC_MODIFY);
2847
2848     case OFPFC_DELETE:
2849         return modify_flows_loose(p, ofm, n_actions, OFPFC_DELETE);
2850
2851     case OFPFC_DELETE_STRICT:
2852         return modify_flows_strict(p, ofm, n_actions, OFPFC_DELETE);
2853
2854     default:
2855         return ofp_mkerr(OFPET_FLOW_MOD_FAILED, OFPFMFC_BAD_COMMAND);
2856     }
2857 }
2858
2859 static void
2860 send_capability_reply(struct ofproto *p, struct ofconn *ofconn, uint32_t xid)
2861 {
2862     struct ofmp_capability_reply *ocr;
2863     struct ofpbuf *b;
2864     char capabilities[] = "com.nicira.mgmt.manager=false\n";
2865
2866     ocr = make_openflow_xid(sizeof(*ocr), OFPT_VENDOR, xid, &b);
2867     ocr->header.header.vendor = htonl(NX_VENDOR_ID);
2868     ocr->header.header.subtype = htonl(NXT_MGMT);
2869     ocr->header.type = htons(OFMPT_CAPABILITY_REPLY);
2870
2871     ocr->format = htonl(OFMPCOF_SIMPLE);
2872     ocr->mgmt_id = htonll(p->mgmt_id);
2873
2874     ofpbuf_put(b, capabilities, strlen(capabilities));
2875
2876     queue_tx(b, ofconn, ofconn->reply_counter);
2877 }
2878
2879 static int
2880 handle_ofmp(struct ofproto *p, struct ofconn *ofconn, 
2881             struct ofmp_header *ofmph)
2882 {
2883     size_t msg_len = ntohs(ofmph->header.header.length);
2884     if (msg_len < sizeof(*ofmph)) {
2885         VLOG_WARN_RL(&rl, "dropping short managment message: %d\n", msg_len);
2886         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
2887     }
2888
2889     if (ofmph->type == htons(OFMPT_CAPABILITY_REQUEST)) {
2890         struct ofmp_capability_request *ofmpcr;
2891
2892         if (msg_len < sizeof(struct ofmp_capability_request)) {
2893             VLOG_WARN_RL(&rl, "dropping short capability request: %d\n", 
2894                     msg_len);
2895             return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
2896         }
2897
2898         ofmpcr = (struct ofmp_capability_request *)ofmph;
2899         if (ofmpcr->format != htonl(OFMPCAF_SIMPLE)) {
2900             /* xxx Find a better type than bad subtype */
2901             return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE);
2902         }
2903
2904         send_capability_reply(p, ofconn, ofmph->header.header.xid);
2905         return 0;
2906     } else {
2907         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE);
2908     }
2909 }
2910
2911 static int
2912 handle_vendor(struct ofproto *p, struct ofconn *ofconn, void *msg)
2913 {
2914     struct ofp_vendor_header *ovh = msg;
2915     struct nicira_header *nh;
2916
2917     if (ntohs(ovh->header.length) < sizeof(struct ofp_vendor_header)) {
2918         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
2919     }
2920     if (ovh->vendor != htonl(NX_VENDOR_ID)) {
2921         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_VENDOR);
2922     }
2923     if (ntohs(ovh->header.length) < sizeof(struct nicira_header)) {
2924         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LENGTH);
2925     }
2926
2927     nh = msg;
2928     switch (ntohl(nh->subtype)) {
2929     case NXT_STATUS_REQUEST:
2930         return switch_status_handle_request(p->switch_status, ofconn->rconn,
2931                                             msg);
2932
2933     case NXT_ACT_SET_CONFIG:
2934         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE); /* XXX */
2935
2936     case NXT_ACT_GET_CONFIG:
2937         return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE); /* XXX */
2938
2939     case NXT_COMMAND_REQUEST:
2940         if (p->executer) {
2941             return executer_handle_request(p->executer, ofconn->rconn, msg);
2942         }
2943         break;
2944
2945     case NXT_MGMT:
2946         return handle_ofmp(p, ofconn, msg);
2947     }
2948
2949     return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE);
2950 }
2951
2952 static void
2953 handle_openflow(struct ofconn *ofconn, struct ofproto *p,
2954                 struct ofpbuf *ofp_msg)
2955 {
2956     struct ofp_header *oh = ofp_msg->data;
2957     int error;
2958
2959     COVERAGE_INC(ofproto_recv_openflow);
2960     switch (oh->type) {
2961     case OFPT_ECHO_REQUEST:
2962         error = handle_echo_request(ofconn, oh);
2963         break;
2964
2965     case OFPT_ECHO_REPLY:
2966         error = 0;
2967         break;
2968
2969     case OFPT_FEATURES_REQUEST:
2970         error = handle_features_request(p, ofconn, oh);
2971         break;
2972
2973     case OFPT_GET_CONFIG_REQUEST:
2974         error = handle_get_config_request(p, ofconn, oh);
2975         break;
2976
2977     case OFPT_SET_CONFIG:
2978         error = handle_set_config(p, ofconn, ofp_msg->data);
2979         break;
2980
2981     case OFPT_PACKET_OUT:
2982         error = handle_packet_out(p, ofconn, ofp_msg->data);
2983         break;
2984
2985     case OFPT_PORT_MOD:
2986         error = handle_port_mod(p, oh);
2987         break;
2988
2989     case OFPT_FLOW_MOD:
2990         error = handle_flow_mod(p, ofconn, ofp_msg->data);
2991         break;
2992
2993     case OFPT_STATS_REQUEST:
2994         error = handle_stats_request(p, ofconn, oh);
2995         break;
2996
2997     case OFPT_VENDOR:
2998         error = handle_vendor(p, ofconn, ofp_msg->data);
2999         break;
3000
3001     default:
3002         if (VLOG_IS_WARN_ENABLED()) {
3003             char *s = ofp_to_string(oh, ntohs(oh->length), 2);
3004             VLOG_DBG_RL(&rl, "OpenFlow message ignored: %s", s);
3005             free(s);
3006         }
3007         error = ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_TYPE);
3008         break;
3009     }
3010
3011     if (error) {
3012         send_error_oh(ofconn, ofp_msg->data, error);
3013     }
3014 }
3015 \f
3016 static void
3017 handle_odp_msg(struct ofproto *p, struct ofpbuf *packet)
3018 {
3019     struct odp_msg *msg = packet->data;
3020     uint16_t in_port = odp_port_to_ofp_port(msg->port);
3021     struct rule *rule;
3022     struct ofpbuf payload;
3023     flow_t flow;
3024
3025     /* Handle controller actions. */
3026     if (msg->type == _ODPL_ACTION_NR) {
3027         COVERAGE_INC(ofproto_ctlr_action);
3028         pinsched_send(p->action_sched, in_port, packet,
3029                       send_packet_in_action, p);
3030         return;
3031     }
3032
3033     payload.data = msg + 1;
3034     payload.size = msg->length - sizeof *msg;
3035     flow_extract(&payload, msg->port, &flow);
3036
3037     /* Check with in-band control to see if this packet should be sent
3038      * to the local port regardless of the flow table. */
3039     if (in_band_msg_in_hook(p->in_band, &flow, &payload)) {
3040         union odp_action action;
3041
3042         memset(&action, 0, sizeof(action));
3043         action.output.type = ODPAT_OUTPUT;
3044         action.output.port = ODPP_LOCAL;
3045         dpif_execute(p->dpif, flow.in_port, &action, 1, &payload);
3046     }
3047
3048     rule = lookup_valid_rule(p, &flow);
3049     if (!rule) {
3050         /* Don't send a packet-in if OFPPC_NO_PACKET_IN asserted. */
3051         struct ofport *port = port_array_get(&p->ports, msg->port);
3052         if (port) {
3053             if (port->opp.config & OFPPC_NO_PACKET_IN) {
3054                 COVERAGE_INC(ofproto_no_packet_in);
3055                 /* XXX install 'drop' flow entry */
3056                 ofpbuf_delete(packet);
3057                 return;
3058             }
3059         } else {
3060             VLOG_WARN_RL(&rl, "packet-in on unknown port %"PRIu16, msg->port);
3061         }
3062
3063         COVERAGE_INC(ofproto_packet_in);
3064         pinsched_send(p->miss_sched, in_port, packet, send_packet_in_miss, p);
3065         return;
3066     }
3067
3068     if (rule->cr.wc.wildcards) {
3069         rule = rule_create_subrule(p, rule, &flow);
3070         rule_make_actions(p, rule, packet);
3071     } else {
3072         if (!rule->may_install) {
3073             /* The rule is not installable, that is, we need to process every
3074              * packet, so process the current packet and set its actions into
3075              * 'subrule'. */
3076             rule_make_actions(p, rule, packet);
3077         } else {
3078             /* XXX revalidate rule if it needs it */
3079         }
3080     }
3081
3082     rule_execute(p, rule, &payload, &flow);
3083     rule_reinstall(p, rule);
3084     ofpbuf_delete(packet);
3085 }
3086 \f
3087 static void
3088 revalidate_cb(struct cls_rule *sub_, void *cbdata_)
3089 {
3090     struct rule *sub = rule_from_cls_rule(sub_);
3091     struct revalidate_cbdata *cbdata = cbdata_;
3092
3093     if (cbdata->revalidate_all
3094         || (cbdata->revalidate_subrules && sub->super)
3095         || (tag_set_intersects(&cbdata->revalidate_set, sub->tags))) {
3096         revalidate_rule(cbdata->ofproto, sub);
3097     }
3098 }
3099
3100 static bool
3101 revalidate_rule(struct ofproto *p, struct rule *rule)
3102 {
3103     const flow_t *flow = &rule->cr.flow;
3104
3105     COVERAGE_INC(ofproto_revalidate_rule);
3106     if (rule->super) {
3107         struct rule *super;
3108         super = rule_from_cls_rule(classifier_lookup_wild(&p->cls, flow));
3109         if (!super) {
3110             rule_remove(p, rule);
3111             return false;
3112         } else if (super != rule->super) {
3113             COVERAGE_INC(ofproto_revalidate_moved);
3114             list_remove(&rule->list);
3115             list_push_back(&super->list, &rule->list);
3116             rule->super = super;
3117             rule->hard_timeout = super->hard_timeout;
3118             rule->idle_timeout = super->idle_timeout;
3119             rule->created = super->created;
3120             rule->used = 0;
3121         }
3122     }
3123
3124     rule_update_actions(p, rule);
3125     return true;
3126 }
3127
3128 static struct ofpbuf *
3129 compose_flow_exp(const struct rule *rule, long long int now, uint8_t reason)
3130 {
3131     struct ofp_flow_expired *ofe;
3132     struct ofpbuf *buf;
3133
3134     ofe = make_openflow(sizeof *ofe, OFPT_FLOW_EXPIRED, &buf);
3135     flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, &ofe->match);
3136     ofe->priority = htons(rule->cr.priority);
3137     ofe->reason = reason;
3138     ofe->duration = (now - rule->created) / 1000;
3139     ofe->packet_count = rule->packet_count;
3140     ofe->byte_count = rule->byte_count;
3141
3142     return buf;
3143 }
3144
3145 static void
3146 send_flow_exp(struct ofproto *p, struct rule *rule,
3147               long long int now, uint8_t reason)
3148 {
3149     struct ofconn *ofconn;
3150     struct ofconn *prev;
3151     struct ofpbuf *buf = NULL;
3152
3153     /* We limit the maximum number of queued flow expirations it by accounting
3154      * them under the counter for replies.  That works because preventing
3155      * OpenFlow requests from being processed also prevents new flows from
3156      * being added (and expiring).  (It also prevents processing OpenFlow
3157      * requests that would not add new flows, so it is imperfect.) */
3158
3159     prev = NULL;
3160     LIST_FOR_EACH (ofconn, struct ofconn, node, &p->all_conns) {
3161         if (ofconn->send_flow_exp && rconn_is_connected(ofconn->rconn)) {
3162             if (prev) {
3163                 queue_tx(ofpbuf_clone(buf), prev, ofconn->reply_counter);
3164             } else {
3165                 buf = compose_flow_exp(rule, now, reason);
3166             }
3167             prev = ofconn;
3168         }
3169     }
3170     if (prev) {
3171         queue_tx(buf, prev, ofconn->reply_counter);
3172     }
3173 }
3174
3175 static void
3176 uninstall_idle_flow(struct ofproto *ofproto, struct rule *rule)
3177 {
3178     assert(rule->installed);
3179     assert(!rule->cr.wc.wildcards);
3180
3181     if (rule->super) {
3182         rule_remove(ofproto, rule);
3183     } else {
3184         rule_uninstall(ofproto, rule);
3185     }
3186 }
3187
3188 static void
3189 expire_rule(struct cls_rule *cls_rule, void *p_)
3190 {
3191     struct ofproto *p = p_;
3192     struct rule *rule = rule_from_cls_rule(cls_rule);
3193     long long int hard_expire, idle_expire, expire, now;
3194
3195     hard_expire = (rule->hard_timeout
3196                    ? rule->created + rule->hard_timeout * 1000
3197                    : LLONG_MAX);
3198     idle_expire = (rule->idle_timeout
3199                    && (rule->super || list_is_empty(&rule->list))
3200                    ? rule->used + rule->idle_timeout * 1000
3201                    : LLONG_MAX);
3202     expire = MIN(hard_expire, idle_expire);
3203     if (expire == LLONG_MAX) {
3204         if (rule->installed && time_msec() >= rule->used + 5000) {
3205             uninstall_idle_flow(p, rule);
3206         }
3207         return;
3208     }
3209
3210     now = time_msec();
3211     if (now < expire) {
3212         if (rule->installed && now >= rule->used + 5000) {
3213             uninstall_idle_flow(p, rule);
3214         }
3215         return;
3216     }
3217
3218     COVERAGE_INC(ofproto_expired);
3219     if (rule->cr.wc.wildcards) {
3220         /* Update stats.  (This code will be a no-op if the rule expired
3221          * due to an idle timeout, because in that case the rule has no
3222          * subrules left.) */
3223         struct rule *subrule, *next;
3224         LIST_FOR_EACH_SAFE (subrule, next, struct rule, list, &rule->list) {
3225             rule_remove(p, subrule);
3226         }
3227     }
3228
3229     send_flow_exp(p, rule, now,
3230                   (now >= hard_expire
3231                    ? OFPER_HARD_TIMEOUT : OFPER_IDLE_TIMEOUT));
3232     rule_remove(p, rule);
3233 }
3234
3235 static void
3236 update_used(struct ofproto *p)
3237 {
3238     struct odp_flow *flows;
3239     size_t n_flows;
3240     size_t i;
3241     int error;
3242
3243     error = dpif_flow_list_all(p->dpif, &flows, &n_flows);
3244     if (error) {
3245         return;
3246     }
3247
3248     for (i = 0; i < n_flows; i++) {
3249         struct odp_flow *f = &flows[i];
3250         struct rule *rule;
3251
3252         rule = rule_from_cls_rule(
3253             classifier_find_rule_exactly(&p->cls, &f->key, 0, UINT16_MAX));
3254         if (!rule || !rule->installed) {
3255             COVERAGE_INC(ofproto_unexpected_rule);
3256             dpif_flow_del(p->dpif, f);
3257             continue;
3258         }
3259
3260         update_time(rule, &f->stats);
3261         rule_account(p, rule, f->stats.n_bytes);
3262     }
3263     free(flows);
3264 }
3265
3266 static void
3267 do_send_packet_in(struct ofconn *ofconn, uint32_t buffer_id,
3268                   const struct ofpbuf *packet, int send_len)
3269 {
3270     struct ofp_packet_in *opi;
3271     struct ofpbuf payload, *buf;
3272     struct odp_msg *msg;
3273
3274     msg = packet->data;
3275     payload.data = msg + 1;
3276     payload.size = msg->length - sizeof *msg;
3277
3278     send_len = MIN(send_len, payload.size);
3279     buf = ofpbuf_new(sizeof *opi + send_len);
3280     opi = put_openflow_xid(offsetof(struct ofp_packet_in, data),
3281                            OFPT_PACKET_IN, 0, buf);
3282     opi->buffer_id = htonl(buffer_id);
3283     opi->total_len = htons(payload.size);
3284     opi->in_port = htons(odp_port_to_ofp_port(msg->port));
3285     opi->reason = msg->type == _ODPL_ACTION_NR ? OFPR_ACTION : OFPR_NO_MATCH;
3286     ofpbuf_put(buf, payload.data, MIN(send_len, payload.size));
3287     update_openflow_length(buf);
3288     rconn_send_with_limit(ofconn->rconn, buf, ofconn->packet_in_counter, 100);
3289 }
3290
3291 static void
3292 send_packet_in_action(struct ofpbuf *packet, void *p_)
3293 {
3294     struct ofproto *p = p_;
3295     struct ofconn *ofconn;
3296     struct odp_msg *msg;
3297
3298     msg = packet->data;
3299     LIST_FOR_EACH (ofconn, struct ofconn, node, &p->all_conns) {
3300         if (ofconn == p->controller || ofconn->miss_send_len) {
3301             do_send_packet_in(ofconn, UINT32_MAX, packet, msg->arg);
3302         }
3303     }
3304     ofpbuf_delete(packet);
3305 }
3306
3307 static void
3308 send_packet_in_miss(struct ofpbuf *packet, void *p_)
3309 {
3310     struct ofproto *p = p_;
3311     struct ofconn *ofconn;
3312     struct ofpbuf payload;
3313     struct odp_msg *msg;
3314
3315     msg = packet->data;
3316     payload.data = msg + 1;
3317     payload.size = msg->length - sizeof *msg;
3318     LIST_FOR_EACH (ofconn, struct ofconn, node, &p->all_conns) {
3319         if (ofconn->miss_send_len) {
3320             uint32_t buffer_id = pktbuf_save(ofconn->pktbuf, &payload,
3321                                              msg->port);
3322             int send_len = (buffer_id != UINT32_MAX ? ofconn->miss_send_len
3323                             : UINT32_MAX);
3324             do_send_packet_in(ofconn, buffer_id, packet, send_len);
3325         }
3326     }
3327     ofpbuf_delete(packet);
3328 }
3329
3330 static uint64_t
3331 pick_datapath_id(const struct ofproto *ofproto)
3332 {
3333     const struct ofport *port;
3334
3335     port = port_array_get(&ofproto->ports, ODPP_LOCAL);
3336     if (port) {
3337         uint8_t ea[ETH_ADDR_LEN];
3338         int error;
3339
3340         error = netdev_get_etheraddr(port->netdev, ea);
3341         if (!error) {
3342             return eth_addr_to_uint64(ea);
3343         }
3344         VLOG_WARN("could not get MAC address for %s (%s)",
3345                   netdev_get_name(port->netdev), strerror(error));
3346     }
3347     return ofproto->fallback_dpid;
3348 }
3349
3350 static uint64_t
3351 pick_fallback_dpid(void)
3352 {
3353     uint8_t ea[ETH_ADDR_LEN];
3354     eth_addr_random(ea);
3355     ea[0] = 0x00;               /* Set Nicira OUI. */
3356     ea[1] = 0x23;
3357     ea[2] = 0x20;
3358     return eth_addr_to_uint64(ea);
3359 }
3360 \f
3361 static bool
3362 default_normal_ofhook_cb(const flow_t *flow, const struct ofpbuf *packet,
3363                          struct odp_actions *actions, tag_type *tags,
3364                          void *ofproto_)
3365 {
3366     struct ofproto *ofproto = ofproto_;
3367     int out_port;
3368
3369     /* Drop frames for reserved multicast addresses. */
3370     if (eth_addr_is_reserved(flow->dl_dst)) {
3371         return true;
3372     }
3373
3374     /* Learn source MAC (but don't try to learn from revalidation). */
3375     if (packet != NULL) {
3376         tag_type rev_tag = mac_learning_learn(ofproto->ml, flow->dl_src,
3377                                               0, flow->in_port);
3378         if (rev_tag) {
3379             /* The log messages here could actually be useful in debugging,
3380              * so keep the rate limit relatively high. */
3381             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(30, 300);
3382             VLOG_DBG_RL(&rl, "learned that "ETH_ADDR_FMT" is on port %"PRIu16,
3383                         ETH_ADDR_ARGS(flow->dl_src), flow->in_port);
3384             ofproto_revalidate(ofproto, rev_tag);
3385         }
3386     }
3387
3388     /* Determine output port. */
3389     out_port = mac_learning_lookup_tag(ofproto->ml, flow->dl_dst, 0, tags);
3390     if (out_port < 0) {
3391         add_output_group_action(actions, DP_GROUP_FLOOD);
3392     } else if (out_port != flow->in_port) {
3393         odp_actions_add(actions, ODPAT_OUTPUT)->output.port = out_port;
3394     } else {
3395         /* Drop. */
3396     }
3397
3398     return true;
3399 }
3400
3401 static const struct ofhooks default_ofhooks = {
3402     NULL,
3403     default_normal_ofhook_cb,
3404     NULL,
3405     NULL
3406 };