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