ofproto/ofproto-dpif.c

   1 /*
   2  * Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18
  19 #include "ofproto/ofproto-dpif.h"
  20 #include "ofproto/ofproto-provider.h"
  21
  22 #include <errno.h>
  23
  24 #include "bfd.h"
  25 #include "bond.h"
  26 #include "bundle.h"
  27 #include "byte-order.h"
  28 #include "connmgr.h"
  29 #include "coverage.h"
  30 #include "cfm.h"
  31 #include "dpif.h"
  32 #include "dynamic-string.h"
  33 #include "fail-open.h"
  34 #include "guarded-list.h"
  35 #include "hmapx.h"
  36 #include "lacp.h"
  37 #include "learn.h"
  38 #include "mac-learning.h"
  39 #include "meta-flow.h"
  40 #include "multipath.h"
  41 #include "netdev-vport.h"
  42 #include "netdev.h"
  43 #include "netlink.h"
  44 #include "nx-match.h"
  45 #include "odp-util.h"
  46 #include "odp-execute.h"
  47 #include "ofp-util.h"
  48 #include "ofpbuf.h"
  49 #include "ofp-actions.h"
  50 #include "ofp-parse.h"
  51 #include "ofp-print.h"
  52 #include "ofproto-dpif-governor.h"
  53 #include "ofproto-dpif-ipfix.h"
  54 #include "ofproto-dpif-mirror.h"
  55 #include "ofproto-dpif-monitor.h"
  56 #include "ofproto-dpif-sflow.h"
  57 #include "ofproto-dpif-upcall.h"
  58 #include "ofproto-dpif-xlate.h"
  59 #include "poll-loop.h"
  60 #include "simap.h"
  61 #include "smap.h"
  62 #include "timer.h"
  63 #include "tunnel.h"
  64 #include "unaligned.h"
  65 #include "unixctl.h"
  66 #include "vlan-bitmap.h"
  67 #include "vlog.h"
  68
  69 VLOG_DEFINE_THIS_MODULE(ofproto_dpif);
  70
  71 COVERAGE_DEFINE(ofproto_dpif_expired);
  72 COVERAGE_DEFINE(facet_revalidate);
  73 COVERAGE_DEFINE(facet_unexpected);
  74 COVERAGE_DEFINE(facet_create);
  75 COVERAGE_DEFINE(facet_remove);
  76 COVERAGE_DEFINE(subfacet_create);
  77 COVERAGE_DEFINE(subfacet_destroy);
  78 COVERAGE_DEFINE(subfacet_install_fail);
  79 COVERAGE_DEFINE(packet_in_overflow);
  80
  81 /* Number of implemented OpenFlow tables. */
  82 enum { N_TABLES = 255 };
  83 enum { TBL_INTERNAL = N_TABLES - 1 };    /* Used for internal hidden rules. */
  84 BUILD_ASSERT_DECL(N_TABLES >= 2 && N_TABLES <= 255);
  85
  86 struct flow_miss;
  87 struct facet;
  88
  89 struct rule_dpif {
  90     struct rule up;
  91
  92     /* These statistics:
  93      *
  94      *   - Do include packets and bytes from facets that have been deleted or
  95      *     whose own statistics have been folded into the rule.
  96      *
  97      *   - Do include packets and bytes sent "by hand" that were accounted to
  98      *     the rule without any facet being involved (this is a rare corner
  99      *     case in rule_execute()).
 100      *
 101      *   - Do not include packet or bytes that can be obtained from any facet's
 102      *     packet_count or byte_count member or that can be obtained from the
 103      *     datapath by, e.g., dpif_flow_get() for any subfacet.
 104      */
 105     struct ovs_mutex stats_mutex;
 106     uint64_t packet_count OVS_GUARDED;  /* Number of packets received. */
 107     uint64_t byte_count OVS_GUARDED;    /* Number of bytes received. */
 108 };
 109
 110 static void rule_get_stats(struct rule *, uint64_t *packets, uint64_t *bytes);
 111 static struct rule_dpif *rule_dpif_cast(const struct rule *);
 112
 113 struct ofbundle {
 114     struct hmap_node hmap_node; /* In struct ofproto's "bundles" hmap. */
 115     struct ofproto_dpif *ofproto; /* Owning ofproto. */
 116     void *aux;                  /* Key supplied by ofproto's client. */
 117     char *name;                 /* Identifier for log messages. */
 118
 119     /* Configuration. */
 120     struct list ports;          /* Contains "struct ofport"s. */
 121     enum port_vlan_mode vlan_mode; /* VLAN mode */
 122     int vlan;                   /* -1=trunk port, else a 12-bit VLAN ID. */
 123     unsigned long *trunks;      /* Bitmap of trunked VLANs, if 'vlan' == -1.
 124                                  * NULL if all VLANs are trunked. */
 125     struct lacp *lacp;          /* LACP if LACP is enabled, otherwise NULL. */
 126     struct bond *bond;          /* Nonnull iff more than one port. */
 127     bool use_priority_tags;     /* Use 802.1p tag for frames in VLAN 0? */
 128
 129     /* Status. */
 130     bool floodable;          /* True if no port has OFPUTIL_PC_NO_FLOOD set. */
 131 };
 132
 133 static void bundle_remove(struct ofport *);
 134 static void bundle_update(struct ofbundle *);
 135 static void bundle_destroy(struct ofbundle *);
 136 static void bundle_del_port(struct ofport_dpif *);
 137 static void bundle_run(struct ofbundle *);
 138 static void bundle_wait(struct ofbundle *);
 139
 140 static void stp_run(struct ofproto_dpif *ofproto);
 141 static void stp_wait(struct ofproto_dpif *ofproto);
 142 static int set_stp_port(struct ofport *,
 143                         const struct ofproto_port_stp_settings *);
 144
 145 static void compose_slow_path(const struct ofproto_dpif *, const struct flow *,
 146                               enum slow_path_reason,
 147                               uint64_t *stub, size_t stub_size,
 148                               const struct nlattr **actionsp,
 149                               size_t *actions_lenp);
 150
 151 /* A subfacet (see "struct subfacet" below) has three possible installation
 152  * states:
 153  *
 154  *   - SF_NOT_INSTALLED: Not installed in the datapath.  This will only be the
 155  *     case just after the subfacet is created, just before the subfacet is
 156  *     destroyed, or if the datapath returns an error when we try to install a
 157  *     subfacet.
 158  *
 159  *   - SF_FAST_PATH: The subfacet's actions are installed in the datapath.
 160  *
 161  *   - SF_SLOW_PATH: An action that sends every packet for the subfacet through
 162  *     ofproto_dpif is installed in the datapath.
 163  */
 164 enum subfacet_path {
 165     SF_NOT_INSTALLED,           /* No datapath flow for this subfacet. */
 166     SF_FAST_PATH,               /* Full actions are installed. */
 167     SF_SLOW_PATH,               /* Send-to-userspace action is installed. */
 168 };
 169
 170 /* A dpif flow and actions associated with a facet.
 171  *
 172  * See also the large comment on struct facet. */
 173 struct subfacet {
 174     /* Owners. */
 175     struct hmap_node hmap_node; /* In struct ofproto_dpif 'subfacets' list. */
 176     struct list list_node;      /* In struct facet's 'facets' list. */
 177     struct facet *facet;        /* Owning facet. */
 178     struct dpif_backer *backer; /* Owning backer. */
 179
 180     struct nlattr *key;
 181     int key_len;
 182
 183     long long int used;         /* Time last used; time created if not used. */
 184     long long int created;      /* Time created. */
 185
 186     uint64_t dp_packet_count;   /* Last known packet count in the datapath. */
 187     uint64_t dp_byte_count;     /* Last known byte count in the datapath. */
 188
 189     enum subfacet_path path;    /* Installed in datapath? */
 190 };
 191
 192 #define SUBFACET_DESTROY_MAX_BATCH 50
 193
 194 static struct subfacet *subfacet_create(struct facet *, struct flow_miss *);
 195 static struct subfacet *subfacet_find(struct dpif_backer *,
 196                                       const struct nlattr *key, size_t key_len,
 197                                       uint32_t key_hash);
 198 static void subfacet_destroy(struct subfacet *);
 199 static void subfacet_destroy__(struct subfacet *);
 200 static void subfacet_destroy_batch(struct dpif_backer *,
 201                                    struct subfacet **, int n);
 202 static void subfacet_reset_dp_stats(struct subfacet *,
 203                                     struct dpif_flow_stats *);
 204 static void subfacet_update_stats(struct subfacet *,
 205                                   const struct dpif_flow_stats *);
 206 static int subfacet_install(struct subfacet *,
 207                             const struct ofpbuf *odp_actions,
 208                             struct dpif_flow_stats *);
 209 static void subfacet_uninstall(struct subfacet *);
 210
 211 /* A unique, non-overlapping instantiation of an OpenFlow flow.
 212  *
 213  * A facet associates a "struct flow", which represents the Open vSwitch
 214  * userspace idea of an exact-match flow, with one or more subfacets.
 215  * While the facet is created based on an exact-match flow, it is stored
 216  * within the ofproto based on the wildcards that could be expressed
 217  * based on the flow table and other configuration.  (See the 'wc'
 218  * description in "struct xlate_out" for more details.)
 219  *
 220  * Each subfacet tracks the datapath's idea of the flow equivalent to
 221  * the facet.  When the kernel module (or other dpif implementation) and
 222  * Open vSwitch userspace agree on the definition of a flow key, there
 223  * is exactly one subfacet per facet.  If the dpif implementation
 224  * supports more-specific flow matching than userspace, however, a facet
 225  * can have more than one subfacet.  Examples include the dpif
 226  * implementation not supporting the same wildcards as userspace or some
 227  * distinction in flow that userspace simply doesn't understand.
 228  *
 229  * Flow expiration works in terms of subfacets, so a facet must have at
 230  * least one subfacet or it will never expire, leaking memory. */
 231 struct facet {
 232     /* Owner. */
 233     struct ofproto_dpif *ofproto;
 234
 235     /* Owned data. */
 236     struct list subfacets;
 237     long long int used;         /* Time last used; time created if not used. */
 238
 239     /* Key. */
 240     struct flow flow;           /* Flow of the creating subfacet. */
 241     struct cls_rule cr;         /* In 'ofproto_dpif's facets classifier. */
 242
 243     /* These statistics:
 244      *
 245      *   - Do include packets and bytes sent "by hand", e.g. with
 246      *     dpif_execute().
 247      *
 248      *   - Do include packets and bytes that were obtained from the datapath
 249      *     when a subfacet's statistics were reset (e.g. dpif_flow_put() with
 250      *     DPIF_FP_ZERO_STATS).
 251      *
 252      *   - Do not include packets or bytes that can be obtained from the
 253      *     datapath for any existing subfacet.
 254      */
 255     uint64_t packet_count;       /* Number of packets received. */
 256     uint64_t byte_count;         /* Number of bytes received. */
 257
 258     /* Resubmit statistics. */
 259     uint64_t prev_packet_count;  /* Number of packets from last stats push. */
 260     uint64_t prev_byte_count;    /* Number of bytes from last stats push. */
 261     long long int prev_used;     /* Used time from last stats push. */
 262
 263     /* Accounting. */
 264     uint64_t accounted_bytes;    /* Bytes processed by facet_account(). */
 265     struct netflow_flow nf_flow; /* Per-flow NetFlow tracking data. */
 266     uint8_t tcp_flags;           /* TCP flags seen for this 'rule'. */
 267
 268     struct xlate_out xout;
 269
 270     /* Storage for a single subfacet, to reduce malloc() time and space
 271      * overhead.  (A facet always has at least one subfacet and in the common
 272      * case has exactly one subfacet.  However, 'one_subfacet' may not
 273      * always be valid, since it could have been removed after newer
 274      * subfacets were pushed onto the 'subfacets' list.) */
 275     struct subfacet one_subfacet;
 276
 277     long long int learn_rl;      /* Rate limiter for facet_learn(). */
 278 };
 279
 280 static struct facet *facet_create(const struct flow_miss *);
 281 static void facet_remove(struct facet *);
 282 static void facet_free(struct facet *);
 283
 284 static struct facet *facet_find(struct ofproto_dpif *, const struct flow *);
 285 static struct facet *facet_lookup_valid(struct ofproto_dpif *,
 286                                         const struct flow *);
 287 static bool facet_revalidate(struct facet *);
 288 static bool facet_check_consistency(struct facet *);
 289
 290 static void facet_flush_stats(struct facet *);
 291
 292 static void facet_reset_counters(struct facet *);
 293 static void flow_push_stats(struct ofproto_dpif *, struct flow *,
 294                             struct dpif_flow_stats *, bool may_learn);
 295 static void facet_push_stats(struct facet *, bool may_learn);
 296 static void facet_learn(struct facet *);
 297 static void facet_account(struct facet *);
 298 static void push_all_stats(void);
 299
 300 static bool facet_is_controller_flow(struct facet *);
 301
 302 struct ofport_dpif {
 303     struct hmap_node odp_port_node; /* In dpif_backer's "odp_to_ofport_map". */
 304     struct ofport up;
 305
 306     odp_port_t odp_port;
 307     struct ofbundle *bundle;    /* Bundle that contains this port, if any. */
 308     struct list bundle_node;    /* In struct ofbundle's "ports" list. */
 309     struct cfm *cfm;            /* Connectivity Fault Management, if any. */
 310     struct bfd *bfd;            /* BFD, if any. */
 311     bool may_enable;            /* May be enabled in bonds. */
 312     bool is_tunnel;             /* This port is a tunnel. */
 313     long long int carrier_seq;  /* Carrier status changes. */
 314     struct ofport_dpif *peer;   /* Peer if patch port. */
 315
 316     /* Spanning tree. */
 317     struct stp_port *stp_port;  /* Spanning Tree Protocol, if any. */
 318     enum stp_state stp_state;   /* Always STP_DISABLED if STP not in use. */
 319     long long int stp_state_entered;
 320
 321     /* Queue to DSCP mapping. */
 322     struct ofproto_port_queue *qdscp;
 323     size_t n_qdscp;
 324
 325     /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
 326      *
 327      * This is deprecated.  It is only for compatibility with broken device
 328      * drivers in old versions of Linux that do not properly support VLANs when
 329      * VLAN devices are not used.  When broken device drivers are no longer in
 330      * widespread use, we will delete these interfaces. */
 331     ofp_port_t realdev_ofp_port;
 332     int vlandev_vid;
 333 };
 334
 335 /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
 336  *
 337  * This is deprecated.  It is only for compatibility with broken device drivers
 338  * in old versions of Linux that do not properly support VLANs when VLAN
 339  * devices are not used.  When broken device drivers are no longer in
 340  * widespread use, we will delete these interfaces. */
 341 struct vlan_splinter {
 342     struct hmap_node realdev_vid_node;
 343     struct hmap_node vlandev_node;
 344     ofp_port_t realdev_ofp_port;
 345     ofp_port_t vlandev_ofp_port;
 346     int vid;
 347 };
 348
 349 static void vsp_remove(struct ofport_dpif *);
 350 static void vsp_add(struct ofport_dpif *, ofp_port_t realdev_ofp_port, int vid);
 351
 352 static odp_port_t ofp_port_to_odp_port(const struct ofproto_dpif *,
 353                                        ofp_port_t);
 354
 355 static ofp_port_t odp_port_to_ofp_port(const struct ofproto_dpif *,
 356                                        odp_port_t);
 357
 358 static struct ofport_dpif *
 359 ofport_dpif_cast(const struct ofport *ofport)
 360 {
 361     return ofport ? CONTAINER_OF(ofport, struct ofport_dpif, up) : NULL;
 362 }
 363
 364 static void port_run(struct ofport_dpif *);
 365 static int set_bfd(struct ofport *, const struct smap *);
 366 static int set_cfm(struct ofport *, const struct cfm_settings *);
 367 static void ofport_update_peer(struct ofport_dpif *);
 368 static void run_fast_rl(void);
 369 static int run_fast(struct ofproto *);
 370
 371 struct dpif_completion {
 372     struct list list_node;
 373     struct ofoperation *op;
 374 };
 375
 376 /* Reasons that we might need to revalidate every facet, and corresponding
 377  * coverage counters.
 378  *
 379  * A value of 0 means that there is no need to revalidate.
 380  *
 381  * It would be nice to have some cleaner way to integrate with coverage
 382  * counters, but with only a few reasons I guess this is good enough for
 383  * now. */
 384 enum revalidate_reason {
 385     REV_RECONFIGURE = 1,       /* Switch configuration changed. */
 386     REV_STP,                   /* Spanning tree protocol port status change. */
 387     REV_BOND,                  /* Bonding changed. */
 388     REV_PORT_TOGGLED,          /* Port enabled or disabled by CFM, LACP, ...*/
 389     REV_FLOW_TABLE,            /* Flow table changed. */
 390     REV_MAC_LEARNING,          /* Mac learning changed. */
 391     REV_INCONSISTENCY          /* Facet self-check failed. */
 392 };
 393 COVERAGE_DEFINE(rev_reconfigure);
 394 COVERAGE_DEFINE(rev_stp);
 395 COVERAGE_DEFINE(rev_bond);
 396 COVERAGE_DEFINE(rev_port_toggled);
 397 COVERAGE_DEFINE(rev_flow_table);
 398 COVERAGE_DEFINE(rev_mac_learning);
 399 COVERAGE_DEFINE(rev_inconsistency);
 400
 401 struct avg_subfacet_rates {
 402     double add_rate;   /* Moving average of new flows created per minute. */
 403     double del_rate;   /* Moving average of flows deleted per minute. */
 404 };
 405
 406 /* All datapaths of a given type share a single dpif backer instance. */
 407 struct dpif_backer {
 408     char *type;
 409     int refcount;
 410     struct dpif *dpif;
 411     struct udpif *udpif;
 412     struct timer next_expiration;
 413
 414     struct ovs_rwlock odp_to_ofport_lock;
 415     struct hmap odp_to_ofport_map OVS_GUARDED; /* ODP port to ofport map. */
 416
 417     struct simap tnl_backers;      /* Set of dpif ports backing tunnels. */
 418
 419     /* Facet revalidation flags applying to facets which use this backer. */
 420     enum revalidate_reason need_revalidate; /* Revalidate every facet. */
 421
 422     struct hmap drop_keys; /* Set of dropped odp keys. */
 423     bool recv_set_enable; /* Enables or disables receiving packets. */
 424
 425     struct hmap subfacets;
 426     struct governor *governor;
 427
 428     /* Subfacet statistics.
 429      *
 430      * These keep track of the total number of subfacets added and deleted and
 431      * flow life span.  They are useful for computing the flow rates stats
 432      * exposed via "ovs-appctl dpif/show".  The goal is to learn about
 433      * traffic patterns in ways that we can use later to improve Open vSwitch
 434      * performance in new situations.  */
 435     long long int created;           /* Time when it is created. */
 436     unsigned max_n_subfacet;         /* Maximum number of flows */
 437     unsigned avg_n_subfacet;         /* Average number of flows. */
 438     long long int avg_subfacet_life; /* Average life span of subfacets. */
 439
 440     /* Number of upcall handling threads. */
 441     unsigned int n_handler_threads;
 442 };
 443
 444 /* All existing ofproto_backer instances, indexed by ofproto->up.type. */
 445 static struct shash all_dpif_backers = SHASH_INITIALIZER(&all_dpif_backers);
 446
 447 static void drop_key_clear(struct dpif_backer *);
 448
 449 struct ofproto_dpif {
 450     struct hmap_node all_ofproto_dpifs_node; /* In 'all_ofproto_dpifs'. */
 451     struct ofproto up;
 452     struct dpif_backer *backer;
 453
 454     /* Special OpenFlow rules. */
 455     struct rule_dpif *miss_rule; /* Sends flow table misses to controller. */
 456     struct rule_dpif *no_packet_in_rule; /* Drops flow table misses. */
 457     struct rule_dpif *drop_frags_rule; /* Used in OFPC_FRAG_DROP mode. */
 458
 459     /* Bridging. */
 460     struct netflow *netflow;
 461     struct dpif_sflow *sflow;
 462     struct dpif_ipfix *ipfix;
 463     struct hmap bundles;        /* Contains "struct ofbundle"s. */
 464     struct mac_learning *ml;
 465     bool has_bonded_bundles;
 466     struct mbridge *mbridge;
 467
 468     /* Facets. */
 469     struct classifier facets;     /* Contains 'struct facet's. */
 470     long long int consistency_rl;
 471
 472     struct ovs_mutex stats_mutex;
 473     struct netdev_stats stats OVS_GUARDED; /* To account packets generated and
 474                                             * consumed in userspace. */
 475
 476     /* Spanning tree. */
 477     struct stp *stp;
 478     long long int stp_last_tick;
 479
 480     /* VLAN splinters. */
 481     struct ovs_mutex vsp_mutex;
 482     struct hmap realdev_vid_map OVS_GUARDED; /* (realdev,vid) -> vlandev. */
 483     struct hmap vlandev_map OVS_GUARDED;     /* vlandev -> (realdev,vid). */
 484
 485     /* Ports. */
 486     struct sset ports;             /* Set of standard port names. */
 487     struct sset ghost_ports;       /* Ports with no datapath port. */
 488     struct sset port_poll_set;     /* Queued names for port_poll() reply. */
 489     int port_poll_errno;           /* Last errno for port_poll() reply. */
 490
 491     /* Per ofproto's dpif stats. */
 492     uint64_t n_hit;
 493     uint64_t n_missed;
 494
 495     /* Work queues. */
 496     struct guarded_list pins;      /* Contains "struct ofputil_packet_in"s. */
 497 };
 498
 499 /* By default, flows in the datapath are wildcarded (megaflows).  They
 500  * may be disabled with the "ovs-appctl dpif/disable-megaflows" command. */
 501 static bool enable_megaflows = true;
 502
 503 /* All existing ofproto_dpif instances, indexed by ->up.name. */
 504 static struct hmap all_ofproto_dpifs = HMAP_INITIALIZER(&all_ofproto_dpifs);
 505
 506 static void ofproto_dpif_unixctl_init(void);
 507
 508 static inline struct ofproto_dpif *
 509 ofproto_dpif_cast(const struct ofproto *ofproto)
 510 {
 511     ovs_assert(ofproto->ofproto_class == &ofproto_dpif_class);
 512     return CONTAINER_OF(ofproto, struct ofproto_dpif, up);
 513 }
 514
 515 static struct ofport_dpif *get_ofp_port(const struct ofproto_dpif *ofproto,
 516                                         ofp_port_t ofp_port);
 517 static void ofproto_trace(struct ofproto_dpif *, const struct flow *,
 518                           const struct ofpbuf *packet, struct ds *);
 519
 520 /* Upcalls. */
 521 static void handle_upcalls(struct dpif_backer *);
 522
 523 /* Flow expiration. */
 524 static int expire(struct dpif_backer *);
 525
 526 /* NetFlow. */
 527 static void send_netflow_active_timeouts(struct ofproto_dpif *);
 528
 529 /* Global variables. */
 530 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 531
 532 /* Initial mappings of port to bridge mappings. */
 533 static struct shash init_ofp_ports = SHASH_INITIALIZER(&init_ofp_ports);
 534
 535 /* Executes 'fm'.  The caller retains ownership of 'fm' and everything in
 536  * it. */
 537 void
 538 ofproto_dpif_flow_mod(struct ofproto_dpif *ofproto,
 539                       struct ofputil_flow_mod *fm)
 540 {
 541     ofproto_flow_mod(&ofproto->up, fm);
 542 }
 543
 544 /* Appends 'pin' to the queue of "packet ins" to be sent to the controller.
 545  * Takes ownership of 'pin' and pin->packet. */
 546 void
 547 ofproto_dpif_send_packet_in(struct ofproto_dpif *ofproto,
 548                             struct ofputil_packet_in *pin)
 549 {
 550     if (!guarded_list_push_back(&ofproto->pins, &pin->list_node, 1024)) {
 551         COVERAGE_INC(packet_in_overflow);
 552         free(CONST_CAST(void *, pin->packet));
 553         free(pin);
 554     }
 555 }
 556 \f
 557 /* Factory functions. */
 558
 559 static void
 560 init(const struct shash *iface_hints)
 561 {
 562     struct shash_node *node;
 563
 564     /* Make a local copy, since we don't own 'iface_hints' elements. */
 565     SHASH_FOR_EACH(node, iface_hints) {
 566         const struct iface_hint *orig_hint = node->data;
 567         struct iface_hint *new_hint = xmalloc(sizeof *new_hint);
 568
 569         new_hint->br_name = xstrdup(orig_hint->br_name);
 570         new_hint->br_type = xstrdup(orig_hint->br_type);
 571         new_hint->ofp_port = orig_hint->ofp_port;
 572
 573         shash_add(&init_ofp_ports, node->name, new_hint);
 574     }
 575 }
 576
 577 static void
 578 enumerate_types(struct sset *types)
 579 {
 580     dp_enumerate_types(types);
 581 }
 582
 583 static int
 584 enumerate_names(const char *type, struct sset *names)
 585 {
 586     struct ofproto_dpif *ofproto;
 587
 588     sset_clear(names);
 589     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 590         if (strcmp(type, ofproto->up.type)) {
 591             continue;
 592         }
 593         sset_add(names, ofproto->up.name);
 594     }
 595
 596     return 0;
 597 }
 598
 599 static int
 600 del(const char *type, const char *name)
 601 {
 602     struct dpif *dpif;
 603     int error;
 604
 605     error = dpif_open(name, type, &dpif);
 606     if (!error) {
 607         error = dpif_delete(dpif);
 608         dpif_close(dpif);
 609     }
 610     return error;
 611 }
 612 \f
 613 static const char *
 614 port_open_type(const char *datapath_type, const char *port_type)
 615 {
 616     return dpif_port_open_type(datapath_type, port_type);
 617 }
 618
 619 /* Type functions. */
 620
 621 static void process_dpif_port_changes(struct dpif_backer *);
 622 static void process_dpif_all_ports_changed(struct dpif_backer *);
 623 static void process_dpif_port_change(struct dpif_backer *,
 624                                      const char *devname);
 625 static void process_dpif_port_error(struct dpif_backer *, int error);
 626
 627 static struct ofproto_dpif *
 628 lookup_ofproto_dpif_by_port_name(const char *name)
 629 {
 630     struct ofproto_dpif *ofproto;
 631
 632     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 633         if (sset_contains(&ofproto->ports, name)) {
 634             return ofproto;
 635         }
 636     }
 637
 638     return NULL;
 639 }
 640
 641 static int
 642 type_run(const char *type)
 643 {
 644     static long long int push_timer = LLONG_MIN;
 645     struct dpif_backer *backer;
 646
 647     backer = shash_find_data(&all_dpif_backers, type);
 648     if (!backer) {
 649         /* This is not necessarily a problem, since backers are only
 650          * created on demand. */
 651         return 0;
 652     }
 653
 654     dpif_run(backer->dpif);
 655
 656     /* The most natural place to push facet statistics is when they're pulled
 657      * from the datapath.  However, when there are many flows in the datapath,
 658      * this expensive operation can occur so frequently, that it reduces our
 659      * ability to quickly set up flows.  To reduce the cost, we push statistics
 660      * here instead. */
 661     if (time_msec() > push_timer) {
 662         push_timer = time_msec() + 2000;
 663         push_all_stats();
 664     }
 665
 666     /* If vswitchd started with other_config:flow_restore_wait set as "true",
 667      * and the configuration has now changed to "false", enable receiving
 668      * packets from the datapath. */
 669     if (!backer->recv_set_enable && !ofproto_get_flow_restore_wait()) {
 670         int error;
 671
 672         backer->recv_set_enable = true;
 673
 674         error = dpif_recv_set(backer->dpif, backer->recv_set_enable);
 675         if (error) {
 676             udpif_recv_set(backer->udpif, 0, false);
 677             VLOG_ERR("Failed to enable receiving packets in dpif.");
 678             return error;
 679         }
 680         udpif_recv_set(backer->udpif, n_handler_threads,
 681                        backer->recv_set_enable);
 682         dpif_flow_flush(backer->dpif);
 683         backer->need_revalidate = REV_RECONFIGURE;
 684     }
 685
 686     /* If the n_handler_threads is reconfigured, call udpif_recv_set()
 687      * to reset the handler threads. */
 688     if (backer->n_handler_threads != n_handler_threads) {
 689         udpif_recv_set(backer->udpif, n_handler_threads,
 690                        backer->recv_set_enable);
 691         backer->n_handler_threads = n_handler_threads;
 692     }
 693
 694     if (backer->need_revalidate) {
 695         struct ofproto_dpif *ofproto;
 696         struct simap_node *node;
 697         struct simap tmp_backers;
 698
 699         /* Handle tunnel garbage collection. */
 700         simap_init(&tmp_backers);
 701         simap_swap(&backer->tnl_backers, &tmp_backers);
 702
 703         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 704             struct ofport_dpif *iter;
 705
 706             if (backer != ofproto->backer) {
 707                 continue;
 708             }
 709
 710             HMAP_FOR_EACH (iter, up.hmap_node, &ofproto->up.ports) {
 711                 char namebuf[NETDEV_VPORT_NAME_BUFSIZE];
 712                 const char *dp_port;
 713
 714                 if (!iter->is_tunnel) {
 715                     continue;
 716                 }
 717
 718                 dp_port = netdev_vport_get_dpif_port(iter->up.netdev,
 719                                                      namebuf, sizeof namebuf);
 720                 node = simap_find(&tmp_backers, dp_port);
 721                 if (node) {
 722                     simap_put(&backer->tnl_backers, dp_port, node->data);
 723                     simap_delete(&tmp_backers, node);
 724                     node = simap_find(&backer->tnl_backers, dp_port);
 725                 } else {
 726                     node = simap_find(&backer->tnl_backers, dp_port);
 727                     if (!node) {
 728                         odp_port_t odp_port = ODPP_NONE;
 729
 730                         if (!dpif_port_add(backer->dpif, iter->up.netdev,
 731                                            &odp_port)) {
 732                             simap_put(&backer->tnl_backers, dp_port,
 733                                       odp_to_u32(odp_port));
 734                             node = simap_find(&backer->tnl_backers, dp_port);
 735                         }
 736                     }
 737                 }
 738
 739                 iter->odp_port = node ? u32_to_odp(node->data) : ODPP_NONE;
 740                 if (tnl_port_reconfigure(iter, iter->up.netdev,
 741                                          iter->odp_port)) {
 742                     backer->need_revalidate = REV_RECONFIGURE;
 743                 }
 744             }
 745         }
 746
 747         SIMAP_FOR_EACH (node, &tmp_backers) {
 748             dpif_port_del(backer->dpif, u32_to_odp(node->data));
 749         }
 750         simap_destroy(&tmp_backers);
 751
 752         switch (backer->need_revalidate) {
 753         case REV_RECONFIGURE:   COVERAGE_INC(rev_reconfigure);   break;
 754         case REV_STP:           COVERAGE_INC(rev_stp);           break;
 755         case REV_BOND:          COVERAGE_INC(rev_bond);          break;
 756         case REV_PORT_TOGGLED:  COVERAGE_INC(rev_port_toggled);  break;
 757         case REV_FLOW_TABLE:    COVERAGE_INC(rev_flow_table);    break;
 758         case REV_MAC_LEARNING:  COVERAGE_INC(rev_mac_learning);  break;
 759         case REV_INCONSISTENCY: COVERAGE_INC(rev_inconsistency); break;
 760         }
 761         backer->need_revalidate = 0;
 762
 763         /* Clear the drop_keys in case we should now be accepting some
 764          * formerly dropped flows. */
 765         drop_key_clear(backer);
 766
 767         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 768             struct facet *facet, *next;
 769             struct ofport_dpif *ofport;
 770             struct cls_cursor cursor;
 771             struct ofbundle *bundle;
 772
 773             if (ofproto->backer != backer) {
 774                 continue;
 775             }
 776
 777             ovs_rwlock_wrlock(&xlate_rwlock);
 778             xlate_ofproto_set(ofproto, ofproto->up.name,
 779                               ofproto->backer->dpif, ofproto->miss_rule,
 780                               ofproto->no_packet_in_rule, ofproto->ml,
 781                               ofproto->stp, ofproto->mbridge,
 782                               ofproto->sflow, ofproto->ipfix,
 783                               ofproto->up.frag_handling,
 784                               ofproto->up.forward_bpdu,
 785                               connmgr_has_in_band(ofproto->up.connmgr),
 786                               ofproto->netflow != NULL);
 787
 788             HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
 789                 xlate_bundle_set(ofproto, bundle, bundle->name,
 790                                  bundle->vlan_mode, bundle->vlan,
 791                                  bundle->trunks, bundle->use_priority_tags,
 792                                  bundle->bond, bundle->lacp,
 793                                  bundle->floodable);
 794             }
 795
 796             HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
 797                 int stp_port = ofport->stp_port
 798                     ? stp_port_no(ofport->stp_port)
 799                     : -1;
 800                 xlate_ofport_set(ofproto, ofport->bundle, ofport,
 801                                  ofport->up.ofp_port, ofport->odp_port,
 802                                  ofport->up.netdev, ofport->cfm,
 803                                  ofport->bfd, ofport->peer, stp_port,
 804                                  ofport->qdscp, ofport->n_qdscp,
 805                                  ofport->up.pp.config, ofport->is_tunnel,
 806                                  ofport->may_enable);
 807             }
 808             ovs_rwlock_unlock(&xlate_rwlock);
 809
 810             /* Only ofproto-dpif cares about the facet classifier so we just
 811              * lock cls_cursor_init() to appease the thread safety analysis. */
 812             ovs_rwlock_rdlock(&ofproto->facets.rwlock);
 813             cls_cursor_init(&cursor, &ofproto->facets, NULL);
 814             ovs_rwlock_unlock(&ofproto->facets.rwlock);
 815             CLS_CURSOR_FOR_EACH_SAFE (facet, next, cr, &cursor) {
 816                 facet_revalidate(facet);
 817                 run_fast_rl();
 818             }
 819         }
 820
 821         udpif_revalidate(backer->udpif);
 822     }
 823
 824     if (!backer->recv_set_enable) {
 825         /* Wake up before a max of 1000ms. */
 826         timer_set_duration(&backer->next_expiration, 1000);
 827     } else if (timer_expired(&backer->next_expiration)) {
 828         int delay = expire(backer);
 829         timer_set_duration(&backer->next_expiration, delay);
 830     }
 831
 832     process_dpif_port_changes(backer);
 833
 834     if (backer->governor) {
 835         size_t n_subfacets;
 836
 837         governor_run(backer->governor);
 838
 839         /* If the governor has shrunk to its minimum size and the number of
 840          * subfacets has dwindled, then drop the governor entirely.
 841          *
 842          * For hysteresis, the number of subfacets to drop the governor is
 843          * smaller than the number needed to trigger its creation. */
 844         n_subfacets = hmap_count(&backer->subfacets);
 845         if (n_subfacets * 4 < flow_eviction_threshold
 846             && governor_is_idle(backer->governor)) {
 847             governor_destroy(backer->governor);
 848             backer->governor = NULL;
 849         }
 850     }
 851
 852     return 0;
 853 }
 854
 855 /* Check for and handle port changes in 'backer''s dpif. */
 856 static void
 857 process_dpif_port_changes(struct dpif_backer *backer)
 858 {
 859     for (;;) {
 860         char *devname;
 861         int error;
 862
 863         error = dpif_port_poll(backer->dpif, &devname);
 864         switch (error) {
 865         case EAGAIN:
 866             return;
 867
 868         case ENOBUFS:
 869             process_dpif_all_ports_changed(backer);
 870             break;
 871
 872         case 0:
 873             process_dpif_port_change(backer, devname);
 874             free(devname);
 875             break;
 876
 877         default:
 878             process_dpif_port_error(backer, error);
 879             break;
 880         }
 881     }
 882 }
 883
 884 static void
 885 process_dpif_all_ports_changed(struct dpif_backer *backer)
 886 {
 887     struct ofproto_dpif *ofproto;
 888     struct dpif_port dpif_port;
 889     struct dpif_port_dump dump;
 890     struct sset devnames;
 891     const char *devname;
 892
 893     sset_init(&devnames);
 894     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 895         if (ofproto->backer == backer) {
 896             struct ofport *ofport;
 897
 898             HMAP_FOR_EACH (ofport, hmap_node, &ofproto->up.ports) {
 899                 sset_add(&devnames, netdev_get_name(ofport->netdev));
 900             }
 901         }
 902     }
 903     DPIF_PORT_FOR_EACH (&dpif_port, &dump, backer->dpif) {
 904         sset_add(&devnames, dpif_port.name);
 905     }
 906
 907     SSET_FOR_EACH (devname, &devnames) {
 908         process_dpif_port_change(backer, devname);
 909     }
 910     sset_destroy(&devnames);
 911 }
 912
 913 static void
 914 process_dpif_port_change(struct dpif_backer *backer, const char *devname)
 915 {
 916     struct ofproto_dpif *ofproto;
 917     struct dpif_port port;
 918
 919     /* Don't report on the datapath's device. */
 920     if (!strcmp(devname, dpif_base_name(backer->dpif))) {
 921         return;
 922     }
 923
 924     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node,
 925                    &all_ofproto_dpifs) {
 926         if (simap_contains(&ofproto->backer->tnl_backers, devname)) {
 927             return;
 928         }
 929     }
 930
 931     ofproto = lookup_ofproto_dpif_by_port_name(devname);
 932     if (dpif_port_query_by_name(backer->dpif, devname, &port)) {
 933         /* The port was removed.  If we know the datapath,
 934          * report it through poll_set().  If we don't, it may be
 935          * notifying us of a removal we initiated, so ignore it.
 936          * If there's a pending ENOBUFS, let it stand, since
 937          * everything will be reevaluated. */
 938         if (ofproto && ofproto->port_poll_errno != ENOBUFS) {
 939             sset_add(&ofproto->port_poll_set, devname);
 940             ofproto->port_poll_errno = 0;
 941         }
 942     } else if (!ofproto) {
 943         /* The port was added, but we don't know with which
 944          * ofproto we should associate it.  Delete it. */
 945         dpif_port_del(backer->dpif, port.port_no);
 946     } else {
 947         struct ofport_dpif *ofport;
 948
 949         ofport = ofport_dpif_cast(shash_find_data(
 950                                       &ofproto->up.port_by_name, devname));
 951         if (ofport
 952             && ofport->odp_port != port.port_no
 953             && !odp_port_to_ofport(backer, port.port_no))
 954         {
 955             /* 'ofport''s datapath port number has changed from
 956              * 'ofport->odp_port' to 'port.port_no'.  Update our internal data
 957              * structures to match. */
 958             ovs_rwlock_wrlock(&backer->odp_to_ofport_lock);
 959             hmap_remove(&backer->odp_to_ofport_map, &ofport->odp_port_node);
 960             ofport->odp_port = port.port_no;
 961             hmap_insert(&backer->odp_to_ofport_map, &ofport->odp_port_node,
 962                         hash_odp_port(port.port_no));
 963             ovs_rwlock_unlock(&backer->odp_to_ofport_lock);
 964             backer->need_revalidate = REV_RECONFIGURE;
 965         }
 966     }
 967     dpif_port_destroy(&port);
 968 }
 969
 970 /* Propagate 'error' to all ofprotos based on 'backer'. */
 971 static void
 972 process_dpif_port_error(struct dpif_backer *backer, int error)
 973 {
 974     struct ofproto_dpif *ofproto;
 975
 976     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 977         if (ofproto->backer == backer) {
 978             sset_clear(&ofproto->port_poll_set);
 979             ofproto->port_poll_errno = error;
 980         }
 981     }
 982 }
 983
 984 static int
 985 dpif_backer_run_fast(struct dpif_backer *backer)
 986 {
 987     handle_upcalls(backer);
 988
 989     return 0;
 990 }
 991
 992 static int
 993 type_run_fast(const char *type)
 994 {
 995     struct dpif_backer *backer;
 996
 997     backer = shash_find_data(&all_dpif_backers, type);
 998     if (!backer) {
 999         /* This is not necessarily a problem, since backers are only
1000          * created on demand. */
1001         return 0;
1002     }
1003
1004     return dpif_backer_run_fast(backer);
1005 }
1006
1007 static void
1008 run_fast_rl(void)
1009 {
1010     static long long int port_rl = LLONG_MIN;
1011
1012     if (time_msec() >= port_rl) {
1013         struct ofproto_dpif *ofproto;
1014
1015         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
1016             run_fast(&ofproto->up);
1017         }
1018         port_rl = time_msec() + 200;
1019     }
1020 }
1021
1022 static void
1023 type_wait(const char *type)
1024 {
1025     struct dpif_backer *backer;
1026
1027     backer = shash_find_data(&all_dpif_backers, type);
1028     if (!backer) {
1029         /* This is not necessarily a problem, since backers are only
1030          * created on demand. */
1031         return;
1032     }
1033
1034     if (backer->governor) {
1035         governor_wait(backer->governor);
1036     }
1037
1038     timer_wait(&backer->next_expiration);
1039     dpif_wait(backer->dpif);
1040     udpif_wait(backer->udpif);
1041 }
1042 \f
1043 /* Basic life-cycle. */
1044
1045 static int add_internal_flows(struct ofproto_dpif *);
1046
1047 static struct ofproto *
1048 alloc(void)
1049 {
1050     struct ofproto_dpif *ofproto = xmalloc(sizeof *ofproto);
1051     return &ofproto->up;
1052 }
1053
1054 static void
1055 dealloc(struct ofproto *ofproto_)
1056 {
1057     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1058     free(ofproto);
1059 }
1060
1061 static void
1062 close_dpif_backer(struct dpif_backer *backer)
1063 {
1064     ovs_assert(backer->refcount > 0);
1065
1066     if (--backer->refcount) {
1067         return;
1068     }
1069
1070     drop_key_clear(backer);
1071     hmap_destroy(&backer->drop_keys);
1072
1073     udpif_destroy(backer->udpif);
1074
1075     simap_destroy(&backer->tnl_backers);
1076     ovs_rwlock_destroy(&backer->odp_to_ofport_lock);
1077     hmap_destroy(&backer->odp_to_ofport_map);
1078     shash_find_and_delete(&all_dpif_backers, backer->type);
1079     free(backer->type);
1080     dpif_close(backer->dpif);
1081
1082     ovs_assert(hmap_is_empty(&backer->subfacets));
1083     hmap_destroy(&backer->subfacets);
1084     governor_destroy(backer->governor);
1085
1086     free(backer);
1087 }
1088
1089 /* Datapath port slated for removal from datapath. */
1090 struct odp_garbage {
1091     struct list list_node;
1092     odp_port_t odp_port;
1093 };
1094
1095 static int
1096 open_dpif_backer(const char *type, struct dpif_backer **backerp)
1097 {
1098     struct dpif_backer *backer;
1099     struct dpif_port_dump port_dump;
1100     struct dpif_port port;
1101     struct shash_node *node;
1102     struct list garbage_list;
1103     struct odp_garbage *garbage, *next;
1104     struct sset names;
1105     char *backer_name;
1106     const char *name;
1107     int error;
1108
1109     backer = shash_find_data(&all_dpif_backers, type);
1110     if (backer) {
1111         backer->refcount++;
1112         *backerp = backer;
1113         return 0;
1114     }
1115
1116     backer_name = xasprintf("ovs-%s", type);
1117
1118     /* Remove any existing datapaths, since we assume we're the only
1119      * userspace controlling the datapath. */
1120     sset_init(&names);
1121     dp_enumerate_names(type, &names);
1122     SSET_FOR_EACH(name, &names) {
1123         struct dpif *old_dpif;
1124
1125         /* Don't remove our backer if it exists. */
1126         if (!strcmp(name, backer_name)) {
1127             continue;
1128         }
1129
1130         if (dpif_open(name, type, &old_dpif)) {
1131             VLOG_WARN("couldn't open old datapath %s to remove it", name);
1132         } else {
1133             dpif_delete(old_dpif);
1134             dpif_close(old_dpif);
1135         }
1136     }
1137     sset_destroy(&names);
1138
1139     backer = xmalloc(sizeof *backer);
1140
1141     error = dpif_create_and_open(backer_name, type, &backer->dpif);
1142     free(backer_name);
1143     if (error) {
1144         VLOG_ERR("failed to open datapath of type %s: %s", type,
1145                  ovs_strerror(error));
1146         free(backer);
1147         return error;
1148     }
1149     backer->udpif = udpif_create(backer, backer->dpif);
1150
1151     backer->type = xstrdup(type);
1152     backer->governor = NULL;
1153     backer->refcount = 1;
1154     hmap_init(&backer->odp_to_ofport_map);
1155     ovs_rwlock_init(&backer->odp_to_ofport_lock);
1156     hmap_init(&backer->drop_keys);
1157     hmap_init(&backer->subfacets);
1158     timer_set_duration(&backer->next_expiration, 1000);
1159     backer->need_revalidate = 0;
1160     simap_init(&backer->tnl_backers);
1161     backer->recv_set_enable = !ofproto_get_flow_restore_wait();
1162     *backerp = backer;
1163
1164     if (backer->recv_set_enable) {
1165         dpif_flow_flush(backer->dpif);
1166     }
1167
1168     /* Loop through the ports already on the datapath and remove any
1169      * that we don't need anymore. */
1170     list_init(&garbage_list);
1171     dpif_port_dump_start(&port_dump, backer->dpif);
1172     while (dpif_port_dump_next(&port_dump, &port)) {
1173         node = shash_find(&init_ofp_ports, port.name);
1174         if (!node && strcmp(port.name, dpif_base_name(backer->dpif))) {
1175             garbage = xmalloc(sizeof *garbage);
1176             garbage->odp_port = port.port_no;
1177             list_push_front(&garbage_list, &garbage->list_node);
1178         }
1179     }
1180     dpif_port_dump_done(&port_dump);
1181
1182     LIST_FOR_EACH_SAFE (garbage, next, list_node, &garbage_list) {
1183         dpif_port_del(backer->dpif, garbage->odp_port);
1184         list_remove(&garbage->list_node);
1185         free(garbage);
1186     }
1187
1188     shash_add(&all_dpif_backers, type, backer);
1189
1190     error = dpif_recv_set(backer->dpif, backer->recv_set_enable);
1191     if (error) {
1192         VLOG_ERR("failed to listen on datapath of type %s: %s",
1193                  type, ovs_strerror(error));
1194         close_dpif_backer(backer);
1195         return error;
1196     }
1197     udpif_recv_set(backer->udpif, n_handler_threads,
1198                    backer->recv_set_enable);
1199     backer->n_handler_threads = n_handler_threads;
1200
1201     backer->max_n_subfacet = 0;
1202     backer->created = time_msec();
1203     backer->avg_n_subfacet = 0;
1204     backer->avg_subfacet_life = 0;
1205
1206     return error;
1207 }
1208
1209 static int
1210 construct(struct ofproto *ofproto_)
1211 {
1212     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1213     struct shash_node *node, *next;
1214     uint32_t max_ports;
1215     int error;
1216
1217     error = open_dpif_backer(ofproto->up.type, &ofproto->backer);
1218     if (error) {
1219         return error;
1220     }
1221
1222     max_ports = dpif_get_max_ports(ofproto->backer->dpif);
1223     ofproto_init_max_ports(ofproto_, MIN(max_ports, ofp_to_u16(OFPP_MAX)));
1224
1225     ofproto->netflow = NULL;
1226     ofproto->sflow = NULL;
1227     ofproto->ipfix = NULL;
1228     ofproto->stp = NULL;
1229     hmap_init(&ofproto->bundles);
1230     ofproto->ml = mac_learning_create(MAC_ENTRY_DEFAULT_IDLE_TIME);
1231     ofproto->mbridge = mbridge_create();
1232     ofproto->has_bonded_bundles = false;
1233     ovs_mutex_init(&ofproto->stats_mutex);
1234     ovs_mutex_init(&ofproto->vsp_mutex);
1235
1236     classifier_init(&ofproto->facets);
1237     ofproto->consistency_rl = LLONG_MIN;
1238
1239     guarded_list_init(&ofproto->pins);
1240
1241     ofproto_dpif_unixctl_init();
1242
1243     hmap_init(&ofproto->vlandev_map);
1244     hmap_init(&ofproto->realdev_vid_map);
1245
1246     sset_init(&ofproto->ports);
1247     sset_init(&ofproto->ghost_ports);
1248     sset_init(&ofproto->port_poll_set);
1249     ofproto->port_poll_errno = 0;
1250
1251     SHASH_FOR_EACH_SAFE (node, next, &init_ofp_ports) {
1252         struct iface_hint *iface_hint = node->data;
1253
1254         if (!strcmp(iface_hint->br_name, ofproto->up.name)) {
1255             /* Check if the datapath already has this port. */
1256             if (dpif_port_exists(ofproto->backer->dpif, node->name)) {
1257                 sset_add(&ofproto->ports, node->name);
1258             }
1259
1260             free(iface_hint->br_name);
1261             free(iface_hint->br_type);
1262             free(iface_hint);
1263             shash_delete(&init_ofp_ports, node);
1264         }
1265     }
1266
1267     hmap_insert(&all_ofproto_dpifs, &ofproto->all_ofproto_dpifs_node,
1268                 hash_string(ofproto->up.name, 0));
1269     memset(&ofproto->stats, 0, sizeof ofproto->stats);
1270
1271     ofproto_init_tables(ofproto_, N_TABLES);
1272     error = add_internal_flows(ofproto);
1273     ofproto->up.tables[TBL_INTERNAL].flags = OFTABLE_HIDDEN | OFTABLE_READONLY;
1274
1275     ofproto->n_hit = 0;
1276     ofproto->n_missed = 0;
1277
1278     return error;
1279 }
1280
1281 static int
1282 add_internal_flow(struct ofproto_dpif *ofproto, int id,
1283                   const struct ofpbuf *ofpacts, struct rule_dpif **rulep)
1284 {
1285     struct ofputil_flow_mod fm;
1286     int error;
1287
1288     match_init_catchall(&fm.match);
1289     fm.priority = 0;
1290     match_set_reg(&fm.match, 0, id);
1291     fm.new_cookie = htonll(0);
1292     fm.cookie = htonll(0);
1293     fm.cookie_mask = htonll(0);
1294     fm.modify_cookie = false;
1295     fm.table_id = TBL_INTERNAL;
1296     fm.command = OFPFC_ADD;
1297     fm.idle_timeout = 0;
1298     fm.hard_timeout = 0;
1299     fm.buffer_id = 0;
1300     fm.out_port = 0;
1301     fm.flags = 0;
1302     fm.ofpacts = ofpacts->data;
1303     fm.ofpacts_len = ofpacts->size;
1304
1305     error = ofproto_flow_mod(&ofproto->up, &fm);
1306     if (error) {
1307         VLOG_ERR_RL(&rl, "failed to add internal flow %d (%s)",
1308                     id, ofperr_to_string(error));
1309         return error;
1310     }
1311
1312     if (rule_dpif_lookup_in_table(ofproto, &fm.match.flow, NULL, TBL_INTERNAL,
1313                                   rulep)) {
1314         rule_dpif_unref(*rulep);
1315     } else {
1316         NOT_REACHED();
1317     }
1318
1319     return 0;
1320 }
1321
1322 static int
1323 add_internal_flows(struct ofproto_dpif *ofproto)
1324 {
1325     struct ofpact_controller *controller;
1326     uint64_t ofpacts_stub[128 / 8];
1327     struct ofpbuf ofpacts;
1328     int error;
1329     int id;
1330
1331     ofpbuf_use_stack(&ofpacts, ofpacts_stub, sizeof ofpacts_stub);
1332     id = 1;
1333
1334     controller = ofpact_put_CONTROLLER(&ofpacts);
1335     controller->max_len = UINT16_MAX;
1336     controller->controller_id = 0;
1337     controller->reason = OFPR_NO_MATCH;
1338     ofpact_pad(&ofpacts);
1339
1340     error = add_internal_flow(ofproto, id++, &ofpacts, &ofproto->miss_rule);
1341     if (error) {
1342         return error;
1343     }
1344
1345     ofpbuf_clear(&ofpacts);
1346     error = add_internal_flow(ofproto, id++, &ofpacts,
1347                               &ofproto->no_packet_in_rule);
1348     if (error) {
1349         return error;
1350     }
1351
1352     error = add_internal_flow(ofproto, id++, &ofpacts,
1353                               &ofproto->drop_frags_rule);
1354     return error;
1355 }
1356
1357 static void
1358 destruct(struct ofproto *ofproto_)
1359 {
1360     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1361     struct rule_dpif *rule, *next_rule;
1362     struct ofputil_packet_in *pin, *next_pin;
1363     struct facet *facet, *next_facet;
1364     struct cls_cursor cursor;
1365     struct oftable *table;
1366     struct list pins;
1367
1368     ovs_rwlock_rdlock(&ofproto->facets.rwlock);
1369     cls_cursor_init(&cursor, &ofproto->facets, NULL);
1370     ovs_rwlock_unlock(&ofproto->facets.rwlock);
1371     CLS_CURSOR_FOR_EACH_SAFE (facet, next_facet, cr, &cursor) {
1372         facet_remove(facet);
1373     }
1374
1375     ofproto->backer->need_revalidate = REV_RECONFIGURE;
1376     ovs_rwlock_wrlock(&xlate_rwlock);
1377     xlate_remove_ofproto(ofproto);
1378     ovs_rwlock_unlock(&xlate_rwlock);
1379
1380     /* Discard any flow_miss_batches queued up for 'ofproto', avoiding a
1381      * use-after-free error. */
1382     udpif_revalidate(ofproto->backer->udpif);
1383
1384     hmap_remove(&all_ofproto_dpifs, &ofproto->all_ofproto_dpifs_node);
1385
1386     OFPROTO_FOR_EACH_TABLE (table, &ofproto->up) {
1387         struct cls_cursor cursor;
1388
1389         ovs_rwlock_rdlock(&table->cls.rwlock);
1390         cls_cursor_init(&cursor, &table->cls, NULL);
1391         ovs_rwlock_unlock(&table->cls.rwlock);
1392         CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, up.cr, &cursor) {
1393             ofproto_rule_delete(&ofproto->up, &rule->up);
1394         }
1395     }
1396
1397     guarded_list_pop_all(&ofproto->pins, &pins);
1398     LIST_FOR_EACH_SAFE (pin, next_pin, list_node, &pins) {
1399         list_remove(&pin->list_node);
1400         free(CONST_CAST(void *, pin->packet));
1401         free(pin);
1402     }
1403     guarded_list_destroy(&ofproto->pins);
1404
1405     mbridge_unref(ofproto->mbridge);
1406
1407     netflow_destroy(ofproto->netflow);
1408     dpif_sflow_unref(ofproto->sflow);
1409     hmap_destroy(&ofproto->bundles);
1410     mac_learning_unref(ofproto->ml);
1411
1412     classifier_destroy(&ofproto->facets);
1413
1414     hmap_destroy(&ofproto->vlandev_map);
1415     hmap_destroy(&ofproto->realdev_vid_map);
1416
1417     sset_destroy(&ofproto->ports);
1418     sset_destroy(&ofproto->ghost_ports);
1419     sset_destroy(&ofproto->port_poll_set);
1420
1421     ovs_mutex_destroy(&ofproto->stats_mutex);
1422     ovs_mutex_destroy(&ofproto->vsp_mutex);
1423
1424     close_dpif_backer(ofproto->backer);
1425 }
1426
1427 static int
1428 run_fast(struct ofproto *ofproto_)
1429 {
1430     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1431     struct ofputil_packet_in *pin, *next_pin;
1432     struct list pins;
1433
1434     /* Do not perform any periodic activity required by 'ofproto' while
1435      * waiting for flow restore to complete. */
1436     if (ofproto_get_flow_restore_wait()) {
1437         return 0;
1438     }
1439
1440     guarded_list_pop_all(&ofproto->pins, &pins);
1441     LIST_FOR_EACH_SAFE (pin, next_pin, list_node, &pins) {
1442         connmgr_send_packet_in(ofproto->up.connmgr, pin);
1443         list_remove(&pin->list_node);
1444         free(CONST_CAST(void *, pin->packet));
1445         free(pin);
1446     }
1447
1448     ofproto_dpif_monitor_run_fast();
1449     return 0;
1450 }
1451
1452 static int
1453 run(struct ofproto *ofproto_)
1454 {
1455     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1456     struct ofport_dpif *ofport;
1457     struct ofbundle *bundle;
1458     int error;
1459
1460     if (mbridge_need_revalidate(ofproto->mbridge)) {
1461         ofproto->backer->need_revalidate = REV_RECONFIGURE;
1462         ovs_rwlock_wrlock(&ofproto->ml->rwlock);
1463         mac_learning_flush(ofproto->ml);
1464         ovs_rwlock_unlock(&ofproto->ml->rwlock);
1465     }
1466
1467     /* Do not perform any periodic activity below required by 'ofproto' while
1468      * waiting for flow restore to complete. */
1469     if (ofproto_get_flow_restore_wait()) {
1470         return 0;
1471     }
1472
1473     error = run_fast(ofproto_);
1474     if (error) {
1475         return error;
1476     }
1477
1478     if (ofproto->netflow) {
1479         if (netflow_run(ofproto->netflow)) {
1480             send_netflow_active_timeouts(ofproto);
1481         }
1482     }
1483     if (ofproto->sflow) {
1484         dpif_sflow_run(ofproto->sflow);
1485     }
1486     if (ofproto->ipfix) {
1487         dpif_ipfix_run(ofproto->ipfix);
1488     }
1489
1490     ofproto_dpif_monitor_run_fast();
1491     ofproto_dpif_monitor_run();
1492
1493     HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
1494         port_run(ofport);
1495     }
1496     HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
1497         bundle_run(bundle);
1498     }
1499
1500     stp_run(ofproto);
1501     ovs_rwlock_wrlock(&ofproto->ml->rwlock);
1502     if (mac_learning_run(ofproto->ml)) {
1503         ofproto->backer->need_revalidate = REV_MAC_LEARNING;
1504     }
1505     ovs_rwlock_unlock(&ofproto->ml->rwlock);
1506
1507     /* Check the consistency of a random facet, to aid debugging. */
1508     ovs_rwlock_rdlock(&ofproto->facets.rwlock);
1509     if (time_msec() >= ofproto->consistency_rl
1510         && !classifier_is_empty(&ofproto->facets)
1511         && !ofproto->backer->need_revalidate) {
1512         struct cls_table *table;
1513         struct cls_rule *cr;
1514         struct facet *facet;
1515
1516         ofproto->consistency_rl = time_msec() + 250;
1517
1518         table = CONTAINER_OF(hmap_random_node(&ofproto->facets.tables),
1519                              struct cls_table, hmap_node);
1520         cr = CONTAINER_OF(hmap_random_node(&table->rules), struct cls_rule,
1521                           hmap_node);
1522         facet = CONTAINER_OF(cr, struct facet, cr);
1523
1524         if (!facet_check_consistency(facet)) {
1525             ofproto->backer->need_revalidate = REV_INCONSISTENCY;
1526         }
1527     }
1528     ovs_rwlock_unlock(&ofproto->facets.rwlock);
1529
1530     return 0;
1531 }
1532
1533 static void
1534 wait(struct ofproto *ofproto_)
1535 {
1536     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1537     struct ofbundle *bundle;
1538
1539     if (ofproto_get_flow_restore_wait()) {
1540         return;
1541     }
1542
1543     if (ofproto->sflow) {
1544         dpif_sflow_wait(ofproto->sflow);
1545     }
1546     if (ofproto->ipfix) {
1547         dpif_ipfix_wait(ofproto->ipfix);
1548     }
1549     ofproto_dpif_monitor_wait();
1550     HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
1551         bundle_wait(bundle);
1552     }
1553     if (ofproto->netflow) {
1554         netflow_wait(ofproto->netflow);
1555     }
1556     ovs_rwlock_rdlock(&ofproto->ml->rwlock);
1557     mac_learning_wait(ofproto->ml);
1558     ovs_rwlock_unlock(&ofproto->ml->rwlock);
1559     stp_wait(ofproto);
1560     if (ofproto->backer->need_revalidate) {
1561         /* Shouldn't happen, but if it does just go around again. */
1562         VLOG_DBG_RL(&rl, "need revalidate in ofproto_wait_cb()");
1563         poll_immediate_wake();
1564     }
1565 }
1566
1567 static void
1568 get_memory_usage(const struct ofproto *ofproto_, struct simap *usage)
1569 {
1570     const struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1571     struct cls_cursor cursor;
1572     size_t n_subfacets = 0;
1573     struct facet *facet;
1574
1575     ovs_rwlock_rdlock(&ofproto->facets.rwlock);
1576     simap_increase(usage, "facets", classifier_count(&ofproto->facets));
1577     ovs_rwlock_unlock(&ofproto->facets.rwlock);
1578
1579     ovs_rwlock_rdlock(&ofproto->facets.rwlock);
1580     cls_cursor_init(&cursor, &ofproto->facets, NULL);
1581     CLS_CURSOR_FOR_EACH (facet, cr, &cursor) {
1582         n_subfacets += list_size(&facet->subfacets);
1583     }
1584     ovs_rwlock_unlock(&ofproto->facets.rwlock);
1585     simap_increase(usage, "subfacets", n_subfacets);
1586 }
1587
1588 static void
1589 flush(struct ofproto *ofproto_)
1590 {
1591     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1592     struct subfacet *subfacet, *next_subfacet;
1593     struct subfacet *batch[SUBFACET_DESTROY_MAX_BATCH];
1594     int n_batch;
1595
1596     n_batch = 0;
1597     HMAP_FOR_EACH_SAFE (subfacet, next_subfacet, hmap_node,
1598                         &ofproto->backer->subfacets) {
1599         if (subfacet->facet->ofproto != ofproto) {
1600             continue;
1601         }
1602
1603         if (subfacet->path != SF_NOT_INSTALLED) {
1604             batch[n_batch++] = subfacet;
1605             if (n_batch >= SUBFACET_DESTROY_MAX_BATCH) {
1606                 subfacet_destroy_batch(ofproto->backer, batch, n_batch);
1607                 n_batch = 0;
1608             }
1609         } else {
1610             subfacet_destroy(subfacet);
1611         }
1612     }
1613
1614     if (n_batch > 0) {
1615         subfacet_destroy_batch(ofproto->backer, batch, n_batch);
1616     }
1617 }
1618
1619 static void
1620 get_features(struct ofproto *ofproto_ OVS_UNUSED,
1621              bool *arp_match_ip, enum ofputil_action_bitmap *actions)
1622 {
1623     *arp_match_ip = true;
1624     *actions = (OFPUTIL_A_OUTPUT |
1625                 OFPUTIL_A_SET_VLAN_VID |
1626                 OFPUTIL_A_SET_VLAN_PCP |
1627                 OFPUTIL_A_STRIP_VLAN |
1628                 OFPUTIL_A_SET_DL_SRC |
1629                 OFPUTIL_A_SET_DL_DST |
1630                 OFPUTIL_A_SET_NW_SRC |
1631                 OFPUTIL_A_SET_NW_DST |
1632                 OFPUTIL_A_SET_NW_TOS |
1633                 OFPUTIL_A_SET_TP_SRC |
1634                 OFPUTIL_A_SET_TP_DST |
1635                 OFPUTIL_A_ENQUEUE);
1636 }
1637
1638 static void
1639 get_tables(struct ofproto *ofproto_, struct ofp12_table_stats *ots)
1640 {
1641     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1642     struct dpif_dp_stats s;
1643     uint64_t n_miss, n_no_pkt_in, n_bytes, n_dropped_frags;
1644     uint64_t n_lookup;
1645
1646     strcpy(ots->name, "classifier");
1647
1648     dpif_get_dp_stats(ofproto->backer->dpif, &s);
1649     rule_get_stats(&ofproto->miss_rule->up, &n_miss, &n_bytes);
1650     rule_get_stats(&ofproto->no_packet_in_rule->up, &n_no_pkt_in, &n_bytes);
1651     rule_get_stats(&ofproto->drop_frags_rule->up, &n_dropped_frags, &n_bytes);
1652
1653     n_lookup = s.n_hit + s.n_missed - n_dropped_frags;
1654     ots->lookup_count = htonll(n_lookup);
1655     ots->matched_count = htonll(n_lookup - n_miss - n_no_pkt_in);
1656 }
1657
1658 static struct ofport *
1659 port_alloc(void)
1660 {
1661     struct ofport_dpif *port = xmalloc(sizeof *port);
1662     return &port->up;
1663 }
1664
1665 static void
1666 port_dealloc(struct ofport *port_)
1667 {
1668     struct ofport_dpif *port = ofport_dpif_cast(port_);
1669     free(port);
1670 }
1671
1672 static int
1673 port_construct(struct ofport *port_)
1674 {
1675     struct ofport_dpif *port = ofport_dpif_cast(port_);
1676     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
1677     const struct netdev *netdev = port->up.netdev;
1678     char namebuf[NETDEV_VPORT_NAME_BUFSIZE];
1679     struct dpif_port dpif_port;
1680     int error;
1681
1682     ofproto->backer->need_revalidate = REV_RECONFIGURE;
1683     port->bundle = NULL;
1684     port->cfm = NULL;
1685     port->bfd = NULL;
1686     port->may_enable = true;
1687     port->stp_port = NULL;
1688     port->stp_state = STP_DISABLED;
1689     port->is_tunnel = false;
1690     port->peer = NULL;
1691     port->qdscp = NULL;
1692     port->n_qdscp = 0;
1693     port->realdev_ofp_port = 0;
1694     port->vlandev_vid = 0;
1695     port->carrier_seq = netdev_get_carrier_resets(netdev);
1696
1697     if (netdev_vport_is_patch(netdev)) {
1698         /* By bailing out here, we don't submit the port to the sFlow module
1699          * to be considered for counter polling export.  This is correct
1700          * because the patch port represents an interface that sFlow considers
1701          * to be "internal" to the switch as a whole, and therefore not an
1702          * candidate for counter polling. */
1703         port->odp_port = ODPP_NONE;
1704         ofport_update_peer(port);
1705         return 0;
1706     }
1707
1708     error = dpif_port_query_by_name(ofproto->backer->dpif,
1709                                     netdev_vport_get_dpif_port(netdev, namebuf,
1710                                                                sizeof namebuf),
1711                                     &dpif_port);
1712     if (error) {
1713         return error;
1714     }
1715
1716     port->odp_port = dpif_port.port_no;
1717
1718     if (netdev_get_tunnel_config(netdev)) {
1719         tnl_port_add(port, port->up.netdev, port->odp_port);
1720         port->is_tunnel = true;
1721     } else {
1722         /* Sanity-check that a mapping doesn't already exist.  This
1723          * shouldn't happen for non-tunnel ports. */
1724         if (odp_port_to_ofp_port(ofproto, port->odp_port) != OFPP_NONE) {
1725             VLOG_ERR("port %s already has an OpenFlow port number",
1726                      dpif_port.name);
1727             dpif_port_destroy(&dpif_port);
1728             return EBUSY;
1729         }
1730
1731         ovs_rwlock_wrlock(&ofproto->backer->odp_to_ofport_lock);
1732         hmap_insert(&ofproto->backer->odp_to_ofport_map, &port->odp_port_node,
1733                     hash_odp_port(port->odp_port));
1734         ovs_rwlock_unlock(&ofproto->backer->odp_to_ofport_lock);
1735     }
1736     dpif_port_destroy(&dpif_port);
1737
1738     if (ofproto->sflow) {
1739         dpif_sflow_add_port(ofproto->sflow, port_, port->odp_port);
1740     }
1741
1742     return 0;
1743 }
1744
1745 static void
1746 port_destruct(struct ofport *port_)
1747 {
1748     struct ofport_dpif *port = ofport_dpif_cast(port_);
1749     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
1750     const char *devname = netdev_get_name(port->up.netdev);
1751     char namebuf[NETDEV_VPORT_NAME_BUFSIZE];
1752     const char *dp_port_name;
1753
1754     ofproto->backer->need_revalidate = REV_RECONFIGURE;
1755     ovs_rwlock_wrlock(&xlate_rwlock);
1756     xlate_ofport_remove(port);
1757     ovs_rwlock_unlock(&xlate_rwlock);
1758
1759     dp_port_name = netdev_vport_get_dpif_port(port->up.netdev, namebuf,
1760                                               sizeof namebuf);
1761     if (dpif_port_exists(ofproto->backer->dpif, dp_port_name)) {
1762         /* The underlying device is still there, so delete it.  This
1763          * happens when the ofproto is being destroyed, since the caller
1764          * assumes that removal of attached ports will happen as part of
1765          * destruction. */
1766         if (!port->is_tunnel) {
1767             dpif_port_del(ofproto->backer->dpif, port->odp_port);
1768         }
1769     }
1770
1771     if (port->peer) {
1772         port->peer->peer = NULL;
1773         port->peer = NULL;
1774     }
1775
1776     if (port->odp_port != ODPP_NONE && !port->is_tunnel) {
1777         ovs_rwlock_wrlock(&ofproto->backer->odp_to_ofport_lock);
1778         hmap_remove(&ofproto->backer->odp_to_ofport_map, &port->odp_port_node);
1779         ovs_rwlock_unlock(&ofproto->backer->odp_to_ofport_lock);
1780     }
1781
1782     tnl_port_del(port);
1783     sset_find_and_delete(&ofproto->ports, devname);
1784     sset_find_and_delete(&ofproto->ghost_ports, devname);
1785     bundle_remove(port_);
1786     set_cfm(port_, NULL);
1787     set_bfd(port_, NULL);
1788     if (ofproto->sflow) {
1789         dpif_sflow_del_port(ofproto->sflow, port->odp_port);
1790     }
1791
1792     free(port->qdscp);
1793 }
1794
1795 static void
1796 port_modified(struct ofport *port_)
1797 {
1798     struct ofport_dpif *port = ofport_dpif_cast(port_);
1799
1800     if (port->bundle && port->bundle->bond) {
1801         bond_slave_set_netdev(port->bundle->bond, port, port->up.netdev);
1802     }
1803
1804     if (port->cfm) {
1805         cfm_set_netdev(port->cfm, port->up.netdev);
1806     }
1807
1808     if (port->bfd) {
1809         bfd_set_netdev(port->bfd, port->up.netdev);
1810     }
1811
1812     ofproto_dpif_monitor_port_update(port, port->bfd, port->cfm,
1813                                      port->up.pp.hw_addr);
1814
1815     if (port->is_tunnel && tnl_port_reconfigure(port, port->up.netdev,
1816                                                 port->odp_port)) {
1817         ofproto_dpif_cast(port->up.ofproto)->backer->need_revalidate =
1818             REV_RECONFIGURE;
1819     }
1820
1821     ofport_update_peer(port);
1822 }
1823
1824 static void
1825 port_reconfigured(struct ofport *port_, enum ofputil_port_config old_config)
1826 {
1827     struct ofport_dpif *port = ofport_dpif_cast(port_);
1828     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
1829     enum ofputil_port_config changed = old_config ^ port->up.pp.config;
1830
1831     if (changed & (OFPUTIL_PC_NO_RECV | OFPUTIL_PC_NO_RECV_STP |
1832                    OFPUTIL_PC_NO_FWD | OFPUTIL_PC_NO_FLOOD |
1833                    OFPUTIL_PC_NO_PACKET_IN)) {
1834         ofproto->backer->need_revalidate = REV_RECONFIGURE;
1835
1836         if (changed & OFPUTIL_PC_NO_FLOOD && port->bundle) {
1837             bundle_update(port->bundle);
1838         }
1839     }
1840 }
1841
1842 static int
1843 set_sflow(struct ofproto *ofproto_,
1844           const struct ofproto_sflow_options *sflow_options)
1845 {
1846     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1847     struct dpif_sflow *ds = ofproto->sflow;
1848
1849     if (sflow_options) {
1850         if (!ds) {
1851             struct ofport_dpif *ofport;
1852
1853             ds = ofproto->sflow = dpif_sflow_create();
1854             HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
1855                 dpif_sflow_add_port(ds, &ofport->up, ofport->odp_port);
1856             }
1857             ofproto->backer->need_revalidate = REV_RECONFIGURE;
1858         }
1859         dpif_sflow_set_options(ds, sflow_options);
1860     } else {
1861         if (ds) {
1862             dpif_sflow_unref(ds);
1863             ofproto->backer->need_revalidate = REV_RECONFIGURE;
1864             ofproto->sflow = NULL;
1865         }
1866     }
1867     return 0;
1868 }
1869
1870 static int
1871 set_ipfix(
1872     struct ofproto *ofproto_,
1873     const struct ofproto_ipfix_bridge_exporter_options *bridge_exporter_options,
1874     const struct ofproto_ipfix_flow_exporter_options *flow_exporters_options,
1875     size_t n_flow_exporters_options)
1876 {
1877     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1878     struct dpif_ipfix *di = ofproto->ipfix;
1879     bool has_options = bridge_exporter_options || flow_exporters_options;
1880
1881     if (has_options && !di) {
1882         di = ofproto->ipfix = dpif_ipfix_create();
1883     }
1884
1885     if (di) {
1886         /* Call set_options in any case to cleanly flush the flow
1887          * caches in the last exporters that are to be destroyed. */
1888         dpif_ipfix_set_options(
1889             di, bridge_exporter_options, flow_exporters_options,
1890             n_flow_exporters_options);
1891
1892         if (!has_options) {
1893             dpif_ipfix_unref(di);
1894             ofproto->ipfix = NULL;
1895         }
1896     }
1897
1898     return 0;
1899 }
1900
1901 static int
1902 set_cfm(struct ofport *ofport_, const struct cfm_settings *s)
1903 {
1904     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1905     int error = 0;
1906
1907     if (s) {
1908         if (!ofport->cfm) {
1909             struct ofproto_dpif *ofproto;
1910
1911             ofproto = ofproto_dpif_cast(ofport->up.ofproto);
1912             ofproto->backer->need_revalidate = REV_RECONFIGURE;
1913             ofport->cfm = cfm_create(ofport->up.netdev);
1914         }
1915
1916         if (cfm_configure(ofport->cfm, s)) {
1917             error = 0;
1918             goto out;
1919         }
1920
1921         error = EINVAL;
1922     }
1923     cfm_unref(ofport->cfm);
1924     ofport->cfm = NULL;
1925 out:
1926     ofproto_dpif_monitor_port_update(ofport, ofport->bfd, ofport->cfm,
1927                                      ofport->up.pp.hw_addr);
1928     return error;
1929 }
1930
1931 static bool
1932 get_cfm_status(const struct ofport *ofport_,
1933                struct ofproto_cfm_status *status)
1934 {
1935     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1936
1937     if (ofport->cfm) {
1938         status->faults = cfm_get_fault(ofport->cfm);
1939         status->remote_opstate = cfm_get_opup(ofport->cfm);
1940         status->health = cfm_get_health(ofport->cfm);
1941         cfm_get_remote_mpids(ofport->cfm, &status->rmps, &status->n_rmps);
1942         return true;
1943     } else {
1944         return false;
1945     }
1946 }
1947
1948 static int
1949 set_bfd(struct ofport *ofport_, const struct smap *cfg)
1950 {
1951     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport_->ofproto);
1952     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1953     struct bfd *old;
1954
1955     old = ofport->bfd;
1956     ofport->bfd = bfd_configure(old, netdev_get_name(ofport->up.netdev),
1957                                 cfg, ofport->up.netdev);
1958     if (ofport->bfd != old) {
1959         ofproto->backer->need_revalidate = REV_RECONFIGURE;
1960     }
1961     ofproto_dpif_monitor_port_update(ofport, ofport->bfd, ofport->cfm,
1962                                      ofport->up.pp.hw_addr);
1963     return 0;
1964 }
1965
1966 static int
1967 get_bfd_status(struct ofport *ofport_, struct smap *smap)
1968 {
1969     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1970
1971     if (ofport->bfd) {
1972         bfd_get_status(ofport->bfd, smap);
1973         return 0;
1974     } else {
1975         return ENOENT;
1976     }
1977 }
1978 \f
1979 /* Spanning Tree. */
1980
1981 static void
1982 send_bpdu_cb(struct ofpbuf *pkt, int port_num, void *ofproto_)
1983 {
1984     struct ofproto_dpif *ofproto = ofproto_;
1985     struct stp_port *sp = stp_get_port(ofproto->stp, port_num);
1986     struct ofport_dpif *ofport;
1987
1988     ofport = stp_port_get_aux(sp);
1989     if (!ofport) {
1990         VLOG_WARN_RL(&rl, "%s: cannot send BPDU on unknown port %d",
1991                      ofproto->up.name, port_num);
1992     } else {
1993         struct eth_header *eth = pkt->l2;
1994
1995         netdev_get_etheraddr(ofport->up.netdev, eth->eth_src);
1996         if (eth_addr_is_zero(eth->eth_src)) {
1997             VLOG_WARN_RL(&rl, "%s: cannot send BPDU on port %d "
1998                          "with unknown MAC", ofproto->up.name, port_num);
1999         } else {
2000             ofproto_dpif_send_packet(ofport, pkt);
2001         }
2002     }
2003     ofpbuf_delete(pkt);
2004 }
2005
2006 /* Configures STP on 'ofproto_' using the settings defined in 's'. */
2007 static int
2008 set_stp(struct ofproto *ofproto_, const struct ofproto_stp_settings *s)
2009 {
2010     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2011
2012     /* Only revalidate flows if the configuration changed. */
2013     if (!s != !ofproto->stp) {
2014         ofproto->backer->need_revalidate = REV_RECONFIGURE;
2015     }
2016
2017     if (s) {
2018         if (!ofproto->stp) {
2019             ofproto->stp = stp_create(ofproto_->name, s->system_id,
2020                                       send_bpdu_cb, ofproto);
2021             ofproto->stp_last_tick = time_msec();
2022         }
2023
2024         stp_set_bridge_id(ofproto->stp, s->system_id);
2025         stp_set_bridge_priority(ofproto->stp, s->priority);
2026         stp_set_hello_time(ofproto->stp, s->hello_time);
2027         stp_set_max_age(ofproto->stp, s->max_age);
2028         stp_set_forward_delay(ofproto->stp, s->fwd_delay);
2029     }  else {
2030         struct ofport *ofport;
2031
2032         HMAP_FOR_EACH (ofport, hmap_node, &ofproto->up.ports) {
2033             set_stp_port(ofport, NULL);
2034         }
2035
2036         stp_unref(ofproto->stp);
2037         ofproto->stp = NULL;
2038     }
2039
2040     return 0;
2041 }
2042
2043 static int
2044 get_stp_status(struct ofproto *ofproto_, struct ofproto_stp_status *s)
2045 {
2046     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2047
2048     if (ofproto->stp) {
2049         s->enabled = true;
2050         s->bridge_id = stp_get_bridge_id(ofproto->stp);
2051         s->designated_root = stp_get_designated_root(ofproto->stp);
2052         s->root_path_cost = stp_get_root_path_cost(ofproto->stp);
2053     } else {
2054         s->enabled = false;
2055     }
2056
2057     return 0;
2058 }
2059
2060 static void
2061 update_stp_port_state(struct ofport_dpif *ofport)
2062 {
2063     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
2064     enum stp_state state;
2065
2066     /* Figure out new state. */
2067     state = ofport->stp_port ? stp_port_get_state(ofport->stp_port)
2068                              : STP_DISABLED;
2069
2070     /* Update state. */
2071     if (ofport->stp_state != state) {
2072         enum ofputil_port_state of_state;
2073         bool fwd_change;
2074
2075         VLOG_DBG_RL(&rl, "port %s: STP state changed from %s to %s",
2076                     netdev_get_name(ofport->up.netdev),
2077                     stp_state_name(ofport->stp_state),
2078                     stp_state_name(state));
2079         if (stp_learn_in_state(ofport->stp_state)
2080                 != stp_learn_in_state(state)) {
2081             /* xxx Learning action flows should also be flushed. */
2082             ovs_rwlock_wrlock(&ofproto->ml->rwlock);
2083             mac_learning_flush(ofproto->ml);
2084             ovs_rwlock_unlock(&ofproto->ml->rwlock);
2085         }
2086         fwd_change = stp_forward_in_state(ofport->stp_state)
2087                         != stp_forward_in_state(state);
2088
2089         ofproto->backer->need_revalidate = REV_STP;
2090         ofport->stp_state = state;
2091         ofport->stp_state_entered = time_msec();
2092
2093         if (fwd_change && ofport->bundle) {
2094             bundle_update(ofport->bundle);
2095         }
2096
2097         /* Update the STP state bits in the OpenFlow port description. */
2098         of_state = ofport->up.pp.state & ~OFPUTIL_PS_STP_MASK;
2099         of_state |= (state == STP_LISTENING ? OFPUTIL_PS_STP_LISTEN
2100                      : state == STP_LEARNING ? OFPUTIL_PS_STP_LEARN
2101                      : state == STP_FORWARDING ? OFPUTIL_PS_STP_FORWARD
2102                      : state == STP_BLOCKING ?  OFPUTIL_PS_STP_BLOCK
2103                      : 0);
2104         ofproto_port_set_state(&ofport->up, of_state);
2105     }
2106 }
2107
2108 /* Configures STP on 'ofport_' using the settings defined in 's'.  The
2109  * caller is responsible for assigning STP port numbers and ensuring
2110  * there are no duplicates. */
2111 static int
2112 set_stp_port(struct ofport *ofport_,
2113              const struct ofproto_port_stp_settings *s)
2114 {
2115     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
2116     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
2117     struct stp_port *sp = ofport->stp_port;
2118
2119     if (!s || !s->enable) {
2120         if (sp) {
2121             ofport->stp_port = NULL;
2122             stp_port_disable(sp);
2123             update_stp_port_state(ofport);
2124         }
2125         return 0;
2126     } else if (sp && stp_port_no(sp) != s->port_num
2127             && ofport == stp_port_get_aux(sp)) {
2128         /* The port-id changed, so disable the old one if it's not
2129          * already in use by another port. */
2130         stp_port_disable(sp);
2131     }
2132
2133     sp = ofport->stp_port = stp_get_port(ofproto->stp, s->port_num);
2134     stp_port_enable(sp);
2135
2136     stp_port_set_aux(sp, ofport);
2137     stp_port_set_priority(sp, s->priority);
2138     stp_port_set_path_cost(sp, s->path_cost);
2139
2140     update_stp_port_state(ofport);
2141
2142     return 0;
2143 }
2144
2145 static int
2146 get_stp_port_status(struct ofport *ofport_,
2147                     struct ofproto_port_stp_status *s)
2148 {
2149     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
2150     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
2151     struct stp_port *sp = ofport->stp_port;
2152
2153     if (!ofproto->stp || !sp) {
2154         s->enabled = false;
2155         return 0;
2156     }
2157
2158     s->enabled = true;
2159     s->port_id = stp_port_get_id(sp);
2160     s->state = stp_port_get_state(sp);
2161     s->sec_in_state = (time_msec() - ofport->stp_state_entered) / 1000;
2162     s->role = stp_port_get_role(sp);
2163     stp_port_get_counts(sp, &s->tx_count, &s->rx_count, &s->error_count);
2164
2165     return 0;
2166 }
2167
2168 static void
2169 stp_run(struct ofproto_dpif *ofproto)
2170 {
2171     if (ofproto->stp) {
2172         long long int now = time_msec();
2173         long long int elapsed = now - ofproto->stp_last_tick;
2174         struct stp_port *sp;
2175
2176         if (elapsed > 0) {
2177             stp_tick(ofproto->stp, MIN(INT_MAX, elapsed));
2178             ofproto->stp_last_tick = now;
2179         }
2180         while (stp_get_changed_port(ofproto->stp, &sp)) {
2181             struct ofport_dpif *ofport = stp_port_get_aux(sp);
2182
2183             if (ofport) {
2184                 update_stp_port_state(ofport);
2185             }
2186         }
2187
2188         if (stp_check_and_reset_fdb_flush(ofproto->stp)) {
2189             ovs_rwlock_wrlock(&ofproto->ml->rwlock);
2190             mac_learning_flush(ofproto->ml);
2191             ovs_rwlock_unlock(&ofproto->ml->rwlock);
2192         }
2193     }
2194 }
2195
2196 static void
2197 stp_wait(struct ofproto_dpif *ofproto)
2198 {
2199     if (ofproto->stp) {
2200         poll_timer_wait(1000);
2201     }
2202 }
2203 \f
2204 static int
2205 set_queues(struct ofport *ofport_, const struct ofproto_port_queue *qdscp,
2206            size_t n_qdscp)
2207 {
2208     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
2209     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
2210
2211     if (ofport->n_qdscp != n_qdscp
2212         || (n_qdscp && memcmp(ofport->qdscp, qdscp,
2213                               n_qdscp * sizeof *qdscp))) {
2214         ofproto->backer->need_revalidate = REV_RECONFIGURE;
2215         free(ofport->qdscp);
2216         ofport->qdscp = n_qdscp
2217             ? xmemdup(qdscp, n_qdscp * sizeof *qdscp)
2218             : NULL;
2219         ofport->n_qdscp = n_qdscp;
2220     }
2221
2222     return 0;
2223 }
2224 \f
2225 /* Bundles. */
2226
2227 /* Expires all MAC learning entries associated with 'bundle' and forces its
2228  * ofproto to revalidate every flow.
2229  *
2230  * Normally MAC learning entries are removed only from the ofproto associated
2231  * with 'bundle', but if 'all_ofprotos' is true, then the MAC learning entries
2232  * are removed from every ofproto.  When patch ports and SLB bonds are in use
2233  * and a VM migration happens and the gratuitous ARPs are somehow lost, this
2234  * avoids a MAC_ENTRY_IDLE_TIME delay before the migrated VM can communicate
2235  * with the host from which it migrated. */
2236 static void
2237 bundle_flush_macs(struct ofbundle *bundle, bool all_ofprotos)
2238 {
2239     struct ofproto_dpif *ofproto = bundle->ofproto;
2240     struct mac_learning *ml = ofproto->ml;
2241     struct mac_entry *mac, *next_mac;
2242
2243     ofproto->backer->need_revalidate = REV_RECONFIGURE;
2244     ovs_rwlock_wrlock(&ml->rwlock);
2245     LIST_FOR_EACH_SAFE (mac, next_mac, lru_node, &ml->lrus) {
2246         if (mac->port.p == bundle) {
2247             if (all_ofprotos) {
2248                 struct ofproto_dpif *o;
2249
2250                 HMAP_FOR_EACH (o, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
2251                     if (o != ofproto) {
2252                         struct mac_entry *e;
2253
2254                         ovs_rwlock_wrlock(&o->ml->rwlock);
2255                         e = mac_learning_lookup(o->ml, mac->mac, mac->vlan);
2256                         if (e) {
2257                             mac_learning_expire(o->ml, e);
2258                         }
2259                         ovs_rwlock_unlock(&o->ml->rwlock);
2260                     }
2261                 }
2262             }
2263
2264             mac_learning_expire(ml, mac);
2265         }
2266     }
2267     ovs_rwlock_unlock(&ml->rwlock);
2268 }
2269
2270 static struct ofbundle *
2271 bundle_lookup(const struct ofproto_dpif *ofproto, void *aux)
2272 {
2273     struct ofbundle *bundle;
2274
2275     HMAP_FOR_EACH_IN_BUCKET (bundle, hmap_node, hash_pointer(aux, 0),
2276                              &ofproto->bundles) {
2277         if (bundle->aux == aux) {
2278             return bundle;
2279         }
2280     }
2281     return NULL;
2282 }
2283
2284 static void
2285 bundle_update(struct ofbundle *bundle)
2286 {
2287     struct ofport_dpif *port;
2288
2289     bundle->floodable = true;
2290     LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
2291         if (port->up.pp.config & OFPUTIL_PC_NO_FLOOD
2292             || !stp_forward_in_state(port->stp_state)) {
2293             bundle->floodable = false;
2294             break;
2295         }
2296     }
2297 }
2298
2299 static void
2300 bundle_del_port(struct ofport_dpif *port)
2301 {
2302     struct ofbundle *bundle = port->bundle;
2303
2304     bundle->ofproto->backer->need_revalidate = REV_RECONFIGURE;
2305
2306     list_remove(&port->bundle_node);
2307     port->bundle = NULL;
2308
2309     if (bundle->lacp) {
2310         lacp_slave_unregister(bundle->lacp, port);
2311     }
2312     if (bundle->bond) {
2313         bond_slave_unregister(bundle->bond, port);
2314     }
2315
2316     bundle_update(bundle);
2317 }
2318
2319 static bool
2320 bundle_add_port(struct ofbundle *bundle, ofp_port_t ofp_port,
2321                 struct lacp_slave_settings *lacp)
2322 {
2323     struct ofport_dpif *port;
2324
2325     port = get_ofp_port(bundle->ofproto, ofp_port);
2326     if (!port) {
2327         return false;
2328     }
2329
2330     if (port->bundle != bundle) {
2331         bundle->ofproto->backer->need_revalidate = REV_RECONFIGURE;
2332         if (port->bundle) {
2333             bundle_remove(&port->up);
2334         }
2335
2336         port->bundle = bundle;
2337         list_push_back(&bundle->ports, &port->bundle_node);
2338         if (port->up.pp.config & OFPUTIL_PC_NO_FLOOD
2339             || !stp_forward_in_state(port->stp_state)) {
2340             bundle->floodable = false;
2341         }
2342     }
2343     if (lacp) {
2344         bundle->ofproto->backer->need_revalidate = REV_RECONFIGURE;
2345         lacp_slave_register(bundle->lacp, port, lacp);
2346     }
2347
2348     return true;
2349 }
2350
2351 static void
2352 bundle_destroy(struct ofbundle *bundle)
2353 {
2354     struct ofproto_dpif *ofproto;
2355     struct ofport_dpif *port, *next_port;
2356
2357     if (!bundle) {
2358         return;
2359     }
2360
2361     ofproto = bundle->ofproto;
2362     mbridge_unregister_bundle(ofproto->mbridge, bundle->aux);
2363
2364     ovs_rwlock_wrlock(&xlate_rwlock);
2365     xlate_bundle_remove(bundle);
2366     ovs_rwlock_unlock(&xlate_rwlock);
2367
2368     LIST_FOR_EACH_SAFE (port, next_port, bundle_node, &bundle->ports) {
2369         bundle_del_port(port);
2370     }
2371
2372     bundle_flush_macs(bundle, true);
2373     hmap_remove(&ofproto->bundles, &bundle->hmap_node);
2374     free(bundle->name);
2375     free(bundle->trunks);
2376     lacp_unref(bundle->lacp);
2377     bond_unref(bundle->bond);
2378     free(bundle);
2379 }
2380
2381 static int
2382 bundle_set(struct ofproto *ofproto_, void *aux,
2383            const struct ofproto_bundle_settings *s)
2384 {
2385     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2386     bool need_flush = false;
2387     struct ofport_dpif *port;
2388     struct ofbundle *bundle;
2389     unsigned long *trunks;
2390     int vlan;
2391     size_t i;
2392     bool ok;
2393
2394     if (!s) {
2395         bundle_destroy(bundle_lookup(ofproto, aux));
2396         return 0;
2397     }
2398
2399     ovs_assert(s->n_slaves == 1 || s->bond != NULL);
2400     ovs_assert((s->lacp != NULL) == (s->lacp_slaves != NULL));
2401
2402     bundle = bundle_lookup(ofproto, aux);
2403     if (!bundle) {
2404         bundle = xmalloc(sizeof *bundle);
2405
2406         bundle->ofproto = ofproto;
2407         hmap_insert(&ofproto->bundles, &bundle->hmap_node,
2408                     hash_pointer(aux, 0));
2409         bundle->aux = aux;
2410         bundle->name = NULL;
2411
2412         list_init(&bundle->ports);
2413         bundle->vlan_mode = PORT_VLAN_TRUNK;
2414         bundle->vlan = -1;
2415         bundle->trunks = NULL;
2416         bundle->use_priority_tags = s->use_priority_tags;
2417         bundle->lacp = NULL;
2418         bundle->bond = NULL;
2419
2420         bundle->floodable = true;
2421         mbridge_register_bundle(ofproto->mbridge, bundle);
2422     }
2423
2424     if (!bundle->name || strcmp(s->name, bundle->name)) {
2425         free(bundle->name);
2426         bundle->name = xstrdup(s->name);
2427     }
2428
2429     /* LACP. */
2430     if (s->lacp) {
2431         if (!bundle->lacp) {
2432             ofproto->backer->need_revalidate = REV_RECONFIGURE;
2433             bundle->lacp = lacp_create();
2434         }
2435         lacp_configure(bundle->lacp, s->lacp);
2436     } else {
2437         lacp_unref(bundle->lacp);
2438         bundle->lacp = NULL;
2439     }
2440
2441     /* Update set of ports. */
2442     ok = true;
2443     for (i = 0; i < s->n_slaves; i++) {
2444         if (!bundle_add_port(bundle, s->slaves[i],
2445                              s->lacp ? &s->lacp_slaves[i] : NULL)) {
2446             ok = false;
2447         }
2448     }
2449     if (!ok || list_size(&bundle->ports) != s->n_slaves) {
2450         struct ofport_dpif *next_port;
2451
2452         LIST_FOR_EACH_SAFE (port, next_port, bundle_node, &bundle->ports) {
2453             for (i = 0; i < s->n_slaves; i++) {
2454                 if (s->slaves[i] == port->up.ofp_port) {
2455                     goto found;
2456                 }
2457             }
2458
2459             bundle_del_port(port);
2460         found: ;
2461         }
2462     }
2463     ovs_assert(list_size(&bundle->ports) <= s->n_slaves);
2464
2465     if (list_is_empty(&bundle->ports)) {
2466         bundle_destroy(bundle);
2467         return EINVAL;
2468     }
2469
2470     /* Set VLAN tagging mode */
2471     if (s->vlan_mode != bundle->vlan_mode
2472         || s->use_priority_tags != bundle->use_priority_tags) {
2473         bundle->vlan_mode = s->vlan_mode;
2474         bundle->use_priority_tags = s->use_priority_tags;
2475         need_flush = true;
2476     }
2477
2478     /* Set VLAN tag. */
2479     vlan = (s->vlan_mode == PORT_VLAN_TRUNK ? -1
2480             : s->vlan >= 0 && s->vlan <= 4095 ? s->vlan
2481             : 0);
2482     if (vlan != bundle->vlan) {
2483         bundle->vlan = vlan;
2484         need_flush = true;
2485     }
2486
2487     /* Get trunked VLANs. */
2488     switch (s->vlan_mode) {
2489     case PORT_VLAN_ACCESS:
2490         trunks = NULL;
2491         break;
2492
2493     case PORT_VLAN_TRUNK:
2494         trunks = CONST_CAST(unsigned long *, s->trunks);
2495         break;
2496
2497     case PORT_VLAN_NATIVE_UNTAGGED:
2498     case PORT_VLAN_NATIVE_TAGGED:
2499         if (vlan != 0 && (!s->trunks
2500                           || !bitmap_is_set(s->trunks, vlan)
2501                           || bitmap_is_set(s->trunks, 0))) {
2502             /* Force trunking the native VLAN and prohibit trunking VLAN 0. */
2503             if (s->trunks) {
2504                 trunks = bitmap_clone(s->trunks, 4096);
2505             } else {
2506                 trunks = bitmap_allocate1(4096);
2507             }
2508             bitmap_set1(trunks, vlan);
2509             bitmap_set0(trunks, 0);
2510         } else {
2511             trunks = CONST_CAST(unsigned long *, s->trunks);
2512         }
2513         break;
2514
2515     default:
2516         NOT_REACHED();
2517     }
2518     if (!vlan_bitmap_equal(trunks, bundle->trunks)) {
2519         free(bundle->trunks);
2520         if (trunks == s->trunks) {
2521             bundle->trunks = vlan_bitmap_clone(trunks);
2522         } else {
2523             bundle->trunks = trunks;
2524             trunks = NULL;
2525         }
2526         need_flush = true;
2527     }
2528     if (trunks != s->trunks) {
2529         free(trunks);
2530     }
2531
2532     /* Bonding. */
2533     if (!list_is_short(&bundle->ports)) {
2534         bundle->ofproto->has_bonded_bundles = true;
2535         if (bundle->bond) {
2536             if (bond_reconfigure(bundle->bond, s->bond)) {
2537                 ofproto->backer->need_revalidate = REV_RECONFIGURE;
2538             }
2539         } else {
2540             bundle->bond = bond_create(s->bond);
2541             ofproto->backer->need_revalidate = REV_RECONFIGURE;
2542         }
2543
2544         LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
2545             bond_slave_register(bundle->bond, port, port->up.netdev);
2546         }
2547     } else {
2548         bond_unref(bundle->bond);
2549         bundle->bond = NULL;
2550     }
2551
2552     /* If we changed something that would affect MAC learning, un-learn
2553      * everything on this port and force flow revalidation. */
2554     if (need_flush) {
2555         bundle_flush_macs(bundle, false);
2556     }
2557
2558     return 0;
2559 }
2560
2561 static void
2562 bundle_remove(struct ofport *port_)
2563 {
2564     struct ofport_dpif *port = ofport_dpif_cast(port_);
2565     struct ofbundle *bundle = port->bundle;
2566
2567     if (bundle) {
2568         bundle_del_port(port);
2569         if (list_is_empty(&bundle->ports)) {
2570             bundle_destroy(bundle);
2571         } else if (list_is_short(&bundle->ports)) {
2572             bond_unref(bundle->bond);
2573             bundle->bond = NULL;
2574         }
2575     }
2576 }
2577
2578 static void
2579 send_pdu_cb(void *port_, const void *pdu, size_t pdu_size)
2580 {
2581     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 10);
2582     struct ofport_dpif *port = port_;
2583     uint8_t ea[ETH_ADDR_LEN];
2584     int error;
2585
2586     error = netdev_get_etheraddr(port->up.netdev, ea);
2587     if (!error) {
2588         struct ofpbuf packet;
2589         void *packet_pdu;
2590
2591         ofpbuf_init(&packet, 0);
2592         packet_pdu = eth_compose(&packet, eth_addr_lacp, ea, ETH_TYPE_LACP,
2593                                  pdu_size);
2594         memcpy(packet_pdu, pdu, pdu_size);
2595
2596         ofproto_dpif_send_packet(port, &packet);
2597         ofpbuf_uninit(&packet);
2598     } else {
2599         VLOG_ERR_RL(&rl, "port %s: cannot obtain Ethernet address of iface "
2600                     "%s (%s)", port->bundle->name,
2601                     netdev_get_name(port->up.netdev), ovs_strerror(error));
2602     }
2603 }
2604
2605 static void
2606 bundle_send_learning_packets(struct ofbundle *bundle)
2607 {
2608     struct ofproto_dpif *ofproto = bundle->ofproto;
2609     struct ofpbuf *learning_packet;
2610     int error, n_packets, n_errors;
2611     struct mac_entry *e;
2612     struct list packets;
2613
2614     list_init(&packets);
2615     ovs_rwlock_rdlock(&ofproto->ml->rwlock);
2616     LIST_FOR_EACH (e, lru_node, &ofproto->ml->lrus) {
2617         if (e->port.p != bundle) {
2618             void *port_void;
2619
2620             learning_packet = bond_compose_learning_packet(bundle->bond,
2621                                                            e->mac, e->vlan,
2622                                                            &port_void);
2623             learning_packet->private_p = port_void;
2624             list_push_back(&packets, &learning_packet->list_node);
2625         }
2626     }
2627     ovs_rwlock_unlock(&ofproto->ml->rwlock);
2628
2629     error = n_packets = n_errors = 0;
2630     LIST_FOR_EACH (learning_packet, list_node, &packets) {
2631         int ret;
2632
2633         ret = ofproto_dpif_send_packet(learning_packet->private_p, learning_packet);
2634         if (ret) {
2635             error = ret;
2636             n_errors++;
2637         }
2638         n_packets++;
2639     }
2640     ofpbuf_list_delete(&packets);
2641
2642     if (n_errors) {
2643         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2644         VLOG_WARN_RL(&rl, "bond %s: %d errors sending %d gratuitous learning "
2645                      "packets, last error was: %s",
2646                      bundle->name, n_errors, n_packets, ovs_strerror(error));
2647     } else {
2648         VLOG_DBG("bond %s: sent %d gratuitous learning packets",
2649                  bundle->name, n_packets);
2650     }
2651 }
2652
2653 static void
2654 bundle_run(struct ofbundle *bundle)
2655 {
2656     if (bundle->lacp) {
2657         lacp_run(bundle->lacp, send_pdu_cb);
2658     }
2659     if (bundle->bond) {
2660         struct ofport_dpif *port;
2661
2662         LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
2663             bond_slave_set_may_enable(bundle->bond, port, port->may_enable);
2664         }
2665
2666         if (bond_run(bundle->bond, lacp_status(bundle->lacp))) {
2667             bundle->ofproto->backer->need_revalidate = REV_BOND;
2668         }
2669
2670         if (bond_should_send_learning_packets(bundle->bond)) {
2671             bundle_send_learning_packets(bundle);
2672         }
2673     }
2674 }
2675
2676 static void
2677 bundle_wait(struct ofbundle *bundle)
2678 {
2679     if (bundle->lacp) {
2680         lacp_wait(bundle->lacp);
2681     }
2682     if (bundle->bond) {
2683         bond_wait(bundle->bond);
2684     }
2685 }
2686 \f
2687 /* Mirrors. */
2688
2689 static int
2690 mirror_set__(struct ofproto *ofproto_, void *aux,
2691              const struct ofproto_mirror_settings *s)
2692 {
2693     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2694     struct ofbundle **srcs, **dsts;
2695     int error;
2696     size_t i;
2697
2698     if (!s) {
2699         mirror_destroy(ofproto->mbridge, aux);
2700         return 0;
2701     }
2702
2703     srcs = xmalloc(s->n_srcs * sizeof *srcs);
2704     dsts = xmalloc(s->n_dsts * sizeof *dsts);
2705
2706     for (i = 0; i < s->n_srcs; i++) {
2707         srcs[i] = bundle_lookup(ofproto, s->srcs[i]);
2708     }
2709
2710     for (i = 0; i < s->n_dsts; i++) {
2711         dsts[i] = bundle_lookup(ofproto, s->dsts[i]);
2712     }
2713
2714     error = mirror_set(ofproto->mbridge, aux, s->name, srcs, s->n_srcs, dsts,
2715                        s->n_dsts, s->src_vlans,
2716                        bundle_lookup(ofproto, s->out_bundle), s->out_vlan);
2717     free(srcs);
2718     free(dsts);
2719     return error;
2720 }
2721
2722 static int
2723 mirror_get_stats__(struct ofproto *ofproto, void *aux,
2724                    uint64_t *packets, uint64_t *bytes)
2725 {
2726     push_all_stats();
2727     return mirror_get_stats(ofproto_dpif_cast(ofproto)->mbridge, aux, packets,
2728                             bytes);
2729 }
2730
2731 static int
2732 set_flood_vlans(struct ofproto *ofproto_, unsigned long *flood_vlans)
2733 {
2734     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2735     ovs_rwlock_wrlock(&ofproto->ml->rwlock);
2736     if (mac_learning_set_flood_vlans(ofproto->ml, flood_vlans)) {
2737         mac_learning_flush(ofproto->ml);
2738     }
2739     ovs_rwlock_unlock(&ofproto->ml->rwlock);
2740     return 0;
2741 }
2742
2743 static bool
2744 is_mirror_output_bundle(const struct ofproto *ofproto_, void *aux)
2745 {
2746     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2747     struct ofbundle *bundle = bundle_lookup(ofproto, aux);
2748     return bundle && mirror_bundle_out(ofproto->mbridge, bundle) != 0;
2749 }
2750
2751 static void
2752 forward_bpdu_changed(struct ofproto *ofproto_)
2753 {
2754     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2755     ofproto->backer->need_revalidate = REV_RECONFIGURE;
2756 }
2757
2758 static void
2759 set_mac_table_config(struct ofproto *ofproto_, unsigned int idle_time,
2760                      size_t max_entries)
2761 {
2762     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2763     ovs_rwlock_wrlock(&ofproto->ml->rwlock);
2764     mac_learning_set_idle_time(ofproto->ml, idle_time);
2765     mac_learning_set_max_entries(ofproto->ml, max_entries);
2766     ovs_rwlock_unlock(&ofproto->ml->rwlock);
2767 }
2768 \f
2769 /* Ports. */
2770
2771 static struct ofport_dpif *
2772 get_ofp_port(const struct ofproto_dpif *ofproto, ofp_port_t ofp_port)
2773 {
2774     struct ofport *ofport = ofproto_get_port(&ofproto->up, ofp_port);
2775     return ofport ? ofport_dpif_cast(ofport) : NULL;
2776 }
2777
2778 static struct ofport_dpif *
2779 get_odp_port(const struct ofproto_dpif *ofproto, odp_port_t odp_port)
2780 {
2781     struct ofport_dpif *port = odp_port_to_ofport(ofproto->backer, odp_port);
2782     return port && &ofproto->up == port->up.ofproto ? port : NULL;
2783 }
2784
2785 static void
2786 ofproto_port_from_dpif_port(struct ofproto_dpif *ofproto,
2787                             struct ofproto_port *ofproto_port,
2788                             struct dpif_port *dpif_port)
2789 {
2790     ofproto_port->name = dpif_port->name;
2791     ofproto_port->type = dpif_port->type;
2792     ofproto_port->ofp_port = odp_port_to_ofp_port(ofproto, dpif_port->port_no);
2793 }
2794
2795 static void
2796 ofport_update_peer(struct ofport_dpif *ofport)
2797 {
2798     const struct ofproto_dpif *ofproto;
2799     struct dpif_backer *backer;
2800     char *peer_name;
2801
2802     if (!netdev_vport_is_patch(ofport->up.netdev)) {
2803         return;
2804     }
2805
2806     backer = ofproto_dpif_cast(ofport->up.ofproto)->backer;
2807     backer->need_revalidate = REV_RECONFIGURE;
2808
2809     if (ofport->peer) {
2810         ofport->peer->peer = NULL;
2811         ofport->peer = NULL;
2812     }
2813
2814     peer_name = netdev_vport_patch_peer(ofport->up.netdev);
2815     if (!peer_name) {
2816         return;
2817     }
2818
2819     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
2820         struct ofport *peer_ofport;
2821         struct ofport_dpif *peer;
2822         char *peer_peer;
2823
2824         if (ofproto->backer != backer) {
2825             continue;
2826         }
2827
2828         peer_ofport = shash_find_data(&ofproto->up.port_by_name, peer_name);
2829         if (!peer_ofport) {
2830             continue;
2831         }
2832
2833         peer = ofport_dpif_cast(peer_ofport);
2834         peer_peer = netdev_vport_patch_peer(peer->up.netdev);
2835         if (peer_peer && !strcmp(netdev_get_name(ofport->up.netdev),
2836                                  peer_peer)) {
2837             ofport->peer = peer;
2838             ofport->peer->peer = ofport;
2839         }
2840         free(peer_peer);
2841
2842         break;
2843     }
2844     free(peer_name);
2845 }
2846
2847 static void
2848 port_run(struct ofport_dpif *ofport)
2849 {
2850     long long int carrier_seq = netdev_get_carrier_resets(ofport->up.netdev);
2851     bool carrier_changed = carrier_seq != ofport->carrier_seq;
2852     bool enable = netdev_get_carrier(ofport->up.netdev);
2853     bool cfm_enable = false;
2854     bool bfd_enable = false;
2855
2856     ofport->carrier_seq = carrier_seq;
2857
2858     if (ofport->cfm) {
2859         int cfm_opup = cfm_get_opup(ofport->cfm);
2860
2861         cfm_enable = !cfm_get_fault(ofport->cfm);
2862
2863         if (cfm_opup >= 0) {
2864             cfm_enable = cfm_enable && cfm_opup;
2865         }
2866     }
2867
2868     if (ofport->bfd) {
2869         bfd_enable = bfd_forwarding(ofport->bfd);
2870     }
2871
2872     if (ofport->bfd || ofport->cfm) {
2873         enable = enable && (cfm_enable || bfd_enable);
2874     }
2875
2876     if (ofport->bundle) {
2877         enable = enable && lacp_slave_may_enable(ofport->bundle->lacp, ofport);
2878         if (carrier_changed) {
2879             lacp_slave_carrier_changed(ofport->bundle->lacp, ofport);
2880         }
2881     }
2882
2883     if (ofport->may_enable != enable) {
2884         struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
2885         ofproto->backer->need_revalidate = REV_PORT_TOGGLED;
2886     }
2887
2888     ofport->may_enable = enable;
2889 }
2890
2891 static int
2892 port_query_by_name(const struct ofproto *ofproto_, const char *devname,
2893                    struct ofproto_port *ofproto_port)
2894 {
2895     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2896     struct dpif_port dpif_port;
2897     int error;
2898
2899     if (sset_contains(&ofproto->ghost_ports, devname)) {
2900         const char *type = netdev_get_type_from_name(devname);
2901
2902         /* We may be called before ofproto->up.port_by_name is populated with
2903          * the appropriate ofport.  For this reason, we must get the name and
2904          * type from the netdev layer directly. */
2905         if (type) {
2906             const struct ofport *ofport;
2907
2908             ofport = shash_find_data(&ofproto->up.port_by_name, devname);
2909             ofproto_port->ofp_port = ofport ? ofport->ofp_port : OFPP_NONE;
2910             ofproto_port->name = xstrdup(devname);
2911             ofproto_port->type = xstrdup(type);
2912             return 0;
2913         }
2914         return ENODEV;
2915     }
2916
2917     if (!sset_contains(&ofproto->ports, devname)) {
2918         return ENODEV;
2919     }
2920     error = dpif_port_query_by_name(ofproto->backer->dpif,
2921                                     devname, &dpif_port);
2922     if (!error) {
2923         ofproto_port_from_dpif_port(ofproto, ofproto_port, &dpif_port);
2924     }
2925     return error;
2926 }
2927
2928 static int
2929 port_add(struct ofproto *ofproto_, struct netdev *netdev)
2930 {
2931     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2932     const char *devname = netdev_get_name(netdev);
2933     char namebuf[NETDEV_VPORT_NAME_BUFSIZE];
2934     const char *dp_port_name;
2935
2936     if (netdev_vport_is_patch(netdev)) {
2937         sset_add(&ofproto->ghost_ports, netdev_get_name(netdev));
2938         return 0;
2939     }
2940
2941     dp_port_name = netdev_vport_get_dpif_port(netdev, namebuf, sizeof namebuf);
2942     if (!dpif_port_exists(ofproto->backer->dpif, dp_port_name)) {
2943         odp_port_t port_no = ODPP_NONE;
2944         int error;
2945
2946         error = dpif_port_add(ofproto->backer->dpif, netdev, &port_no);
2947         if (error) {
2948             return error;
2949         }
2950         if (netdev_get_tunnel_config(netdev)) {
2951             simap_put(&ofproto->backer->tnl_backers,
2952                       dp_port_name, odp_to_u32(port_no));
2953         }
2954     }
2955
2956     if (netdev_get_tunnel_config(netdev)) {
2957         sset_add(&ofproto->ghost_ports, devname);
2958     } else {
2959         sset_add(&ofproto->ports, devname);
2960     }
2961     return 0;
2962 }
2963
2964 static int
2965 port_del(struct ofproto *ofproto_, ofp_port_t ofp_port)
2966 {
2967     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2968     struct ofport_dpif *ofport = get_ofp_port(ofproto, ofp_port);
2969     int error = 0;
2970
2971     if (!ofport) {
2972         return 0;
2973     }
2974
2975     sset_find_and_delete(&ofproto->ghost_ports,
2976                          netdev_get_name(ofport->up.netdev));
2977     ofproto->backer->need_revalidate = REV_RECONFIGURE;
2978     if (!ofport->is_tunnel && !netdev_vport_is_patch(ofport->up.netdev)) {
2979         error = dpif_port_del(ofproto->backer->dpif, ofport->odp_port);
2980         if (!error) {
2981             /* The caller is going to close ofport->up.netdev.  If this is a
2982              * bonded port, then the bond is using that netdev, so remove it
2983              * from the bond.  The client will need to reconfigure everything
2984              * after deleting ports, so then the slave will get re-added. */
2985             bundle_remove(&ofport->up);
2986         }
2987     }
2988     return error;
2989 }
2990
2991 static int
2992 port_get_stats(const struct ofport *ofport_, struct netdev_stats *stats)
2993 {
2994     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
2995     int error;
2996
2997     push_all_stats();
2998
2999     error = netdev_get_stats(ofport->up.netdev, stats);
3000
3001     if (!error && ofport_->ofp_port == OFPP_LOCAL) {
3002         struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
3003
3004         ovs_mutex_lock(&ofproto->stats_mutex);
3005         /* ofproto->stats.tx_packets represents packets that we created
3006          * internally and sent to some port (e.g. packets sent with
3007          * ofproto_dpif_send_packet()).  Account for them as if they had
3008          * come from OFPP_LOCAL and got forwarded. */
3009
3010         if (stats->rx_packets != UINT64_MAX) {
3011             stats->rx_packets += ofproto->stats.tx_packets;
3012         }
3013
3014         if (stats->rx_bytes != UINT64_MAX) {
3015             stats->rx_bytes += ofproto->stats.tx_bytes;
3016         }
3017
3018         /* ofproto->stats.rx_packets represents packets that were received on
3019          * some port and we processed internally and dropped (e.g. STP).
3020          * Account for them as if they had been forwarded to OFPP_LOCAL. */
3021
3022         if (stats->tx_packets != UINT64_MAX) {
3023             stats->tx_packets += ofproto->stats.rx_packets;
3024         }
3025
3026         if (stats->tx_bytes != UINT64_MAX) {
3027             stats->tx_bytes += ofproto->stats.rx_bytes;
3028         }
3029         ovs_mutex_unlock(&ofproto->stats_mutex);
3030     }
3031
3032     return error;
3033 }
3034
3035 struct port_dump_state {
3036     uint32_t bucket;
3037     uint32_t offset;
3038     bool ghost;
3039
3040     struct ofproto_port port;
3041     bool has_port;
3042 };
3043
3044 static int
3045 port_dump_start(const struct ofproto *ofproto_ OVS_UNUSED, void **statep)
3046 {
3047     *statep = xzalloc(sizeof(struct port_dump_state));
3048     return 0;
3049 }
3050
3051 static int
3052 port_dump_next(const struct ofproto *ofproto_, void *state_,
3053                struct ofproto_port *port)
3054 {
3055     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3056     struct port_dump_state *state = state_;
3057     const struct sset *sset;
3058     struct sset_node *node;
3059
3060     if (state->has_port) {
3061         ofproto_port_destroy(&state->port);
3062         state->has_port = false;
3063     }
3064     sset = state->ghost ? &ofproto->ghost_ports : &ofproto->ports;
3065     while ((node = sset_at_position(sset, &state->bucket, &state->offset))) {
3066         int error;
3067
3068         error = port_query_by_name(ofproto_, node->name, &state->port);
3069         if (!error) {
3070             *port = state->port;
3071             state->has_port = true;
3072             return 0;
3073         } else if (error != ENODEV) {
3074             return error;
3075         }
3076     }
3077
3078     if (!state->ghost) {
3079         state->ghost = true;
3080         state->bucket = 0;
3081         state->offset = 0;
3082         return port_dump_next(ofproto_, state_, port);
3083     }
3084
3085     return EOF;
3086 }
3087
3088 static int
3089 port_dump_done(const struct ofproto *ofproto_ OVS_UNUSED, void *state_)
3090 {
3091     struct port_dump_state *state = state_;
3092
3093     if (state->has_port) {
3094         ofproto_port_destroy(&state->port);
3095     }
3096     free(state);
3097     return 0;
3098 }
3099
3100 static int
3101 port_poll(const struct ofproto *ofproto_, char **devnamep)
3102 {
3103     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3104
3105     if (ofproto->port_poll_errno) {
3106         int error = ofproto->port_poll_errno;
3107         ofproto->port_poll_errno = 0;
3108         return error;
3109     }
3110
3111     if (sset_is_empty(&ofproto->port_poll_set)) {
3112         return EAGAIN;
3113     }
3114
3115     *devnamep = sset_pop(&ofproto->port_poll_set);
3116     return 0;
3117 }
3118
3119 static void
3120 port_poll_wait(const struct ofproto *ofproto_)
3121 {
3122     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3123     dpif_port_poll_wait(ofproto->backer->dpif);
3124 }
3125
3126 static int
3127 port_is_lacp_current(const struct ofport *ofport_)
3128 {
3129     const struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
3130     return (ofport->bundle && ofport->bundle->lacp
3131             ? lacp_slave_is_current(ofport->bundle->lacp, ofport)
3132             : -1);
3133 }
3134 \f
3135 /* Upcall handling. */
3136
3137 struct flow_miss_op {
3138     struct dpif_op dpif_op;
3139
3140     uint64_t slow_stub[128 / 8]; /* Buffer for compose_slow_path() */
3141     struct xlate_out xout;
3142     bool xout_garbage;           /* 'xout' needs to be uninitialized? */
3143
3144     struct ofpbuf mask;          /* Flow mask for "put" ops. */
3145     struct odputil_keybuf maskbuf;
3146
3147     /* If this is a "put" op, then a pointer to the subfacet that should
3148      * be marked as uninstalled if the operation fails. */
3149     struct subfacet *subfacet;
3150 };
3151
3152 /* Figures out whether a flow that missed in 'ofproto', whose details are in
3153  * 'miss' masked by 'wc', is likely to be worth tracking in detail in userspace
3154  * and (usually) installing a datapath flow.  The answer is usually "yes" (a
3155  * return value of true).  However, for short flows the cost of bookkeeping is
3156  * much higher than the benefits, so when the datapath holds a large number of
3157  * flows we impose some heuristics to decide which flows are likely to be worth
3158  * tracking. */
3159 static bool
3160 flow_miss_should_make_facet(struct flow_miss *miss)
3161 {
3162     struct dpif_backer *backer = miss->ofproto->backer;
3163     uint32_t hash;
3164
3165     switch (flow_miss_model) {
3166     case OFPROTO_HANDLE_MISS_AUTO:
3167         break;
3168     case OFPROTO_HANDLE_MISS_WITH_FACETS:
3169         return true;
3170     case OFPROTO_HANDLE_MISS_WITHOUT_FACETS:
3171         return false;
3172     }
3173
3174     if (!backer->governor) {
3175         size_t n_subfacets;
3176
3177         n_subfacets = hmap_count(&backer->subfacets);
3178         if (n_subfacets * 2 <= flow_eviction_threshold) {
3179             return true;
3180         }
3181
3182         backer->governor = governor_create();
3183     }
3184
3185     hash = flow_hash_in_wildcards(&miss->flow, &miss->xout.wc, 0);
3186     return governor_should_install_flow(backer->governor, hash,
3187                                         miss->stats.n_packets);
3188 }
3189
3190 /* Handles 'miss', which matches 'facet'.  May add any required datapath
3191  * operations to 'ops', incrementing '*n_ops' for each new op.
3192  *
3193  * All of the packets in 'miss' are considered to have arrived at time
3194  * 'miss->stats.used'.  This is really important only for new facets: if we
3195  * just called time_msec() here, then the new subfacet or its packets could
3196  * look (occasionally) as though it was used some time after the facet was
3197  * used.  That can make a one-packet flow look like it has a nonzero duration,
3198  * which looks odd in e.g. NetFlow statistics. */
3199 static void
3200 handle_flow_miss_with_facet(struct flow_miss *miss, struct facet *facet,
3201                             struct flow_miss_op *ops, size_t *n_ops)
3202 {
3203     enum subfacet_path want_path;
3204     struct subfacet *subfacet;
3205
3206     facet->packet_count += miss->stats.n_packets;
3207     facet->prev_packet_count += miss->stats.n_packets;
3208     facet->byte_count += miss->stats.n_bytes;
3209     facet->prev_byte_count += miss->stats.n_bytes;
3210
3211     want_path = facet->xout.slow ? SF_SLOW_PATH : SF_FAST_PATH;
3212
3213     /* Don't install the flow if it's the result of the "userspace"
3214      * action for an already installed facet.  This can occur when a
3215      * datapath flow with wildcards has a "userspace" action and flows
3216      * sent to userspace result in a different subfacet, which will then
3217      * be rejected as overlapping by the datapath. */
3218     if (miss->upcall_type == DPIF_UC_ACTION
3219         && !list_is_empty(&facet->subfacets)) {
3220         return;
3221     }
3222
3223     subfacet = subfacet_create(facet, miss);
3224     if (subfacet->path != want_path) {
3225         struct flow_miss_op *op = &ops[(*n_ops)++];
3226         struct dpif_flow_put *put = &op->dpif_op.u.flow_put;
3227
3228         subfacet->path = want_path;
3229
3230         ofpbuf_use_stack(&op->mask, &op->maskbuf, sizeof op->maskbuf);
3231         if (enable_megaflows) {
3232             odp_flow_key_from_mask(&op->mask, &facet->xout.wc.masks,
3233                                    &miss->flow, UINT32_MAX);
3234         }
3235
3236         op->xout_garbage = false;
3237         op->dpif_op.type = DPIF_OP_FLOW_PUT;
3238         op->subfacet = subfacet;
3239         put->flags = DPIF_FP_CREATE;
3240         put->key = miss->key;
3241         put->key_len = miss->key_len;
3242         put->mask = op->mask.data;
3243         put->mask_len = op->mask.size;
3244
3245         if (want_path == SF_FAST_PATH) {
3246             put->actions = facet->xout.odp_actions.data;
3247             put->actions_len = facet->xout.odp_actions.size;
3248         } else {
3249             compose_slow_path(facet->ofproto, &miss->flow, facet->xout.slow,
3250                               op->slow_stub, sizeof op->slow_stub,
3251                               &put->actions, &put->actions_len);
3252         }
3253         put->stats = NULL;
3254     }
3255 }
3256
3257 /* Handles flow miss 'miss'.  May add any required datapath operations
3258  * to 'ops', incrementing '*n_ops' for each new op. */
3259 static void
3260 handle_flow_miss(struct flow_miss *miss, struct flow_miss_op *ops,
3261                  size_t *n_ops)
3262 {
3263     struct facet *facet;
3264
3265     miss->ofproto->n_missed += miss->stats.n_packets;
3266
3267     facet = facet_lookup_valid(miss->ofproto, &miss->flow);
3268     if (!facet) {
3269         /* There does not exist a bijection between 'struct flow' and datapath
3270          * flow keys with fitness ODP_FIT_TO_LITTLE.  This breaks a fundamental
3271          * assumption used throughout the facet and subfacet handling code.
3272          * Since we have to handle these misses in userspace anyway, we simply
3273          * skip facet creation, avoiding the problem altogether. */
3274         if (miss->key_fitness == ODP_FIT_TOO_LITTLE
3275             || !flow_miss_should_make_facet(miss)) {
3276             return;
3277         }
3278
3279         facet = facet_create(miss);
3280     }
3281     handle_flow_miss_with_facet(miss, facet, ops, n_ops);
3282 }
3283
3284 static struct drop_key *
3285 drop_key_lookup(const struct dpif_backer *backer, const struct nlattr *key,
3286                 size_t key_len)
3287 {
3288     struct drop_key *drop_key;
3289
3290     HMAP_FOR_EACH_WITH_HASH (drop_key, hmap_node, hash_bytes(key, key_len, 0),
3291                              &backer->drop_keys) {
3292         if (drop_key->key_len == key_len
3293             && !memcmp(drop_key->key, key, key_len)) {
3294             return drop_key;
3295         }
3296     }
3297     return NULL;
3298 }
3299
3300 static void
3301 drop_key_clear(struct dpif_backer *backer)
3302 {
3303     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 15);
3304     struct drop_key *drop_key, *next;
3305
3306     HMAP_FOR_EACH_SAFE (drop_key, next, hmap_node, &backer->drop_keys) {
3307         int error;
3308
3309         error = dpif_flow_del(backer->dpif, drop_key->key, drop_key->key_len,
3310                               NULL);
3311         if (error && !VLOG_DROP_WARN(&rl)) {
3312             struct ds ds = DS_EMPTY_INITIALIZER;
3313             odp_flow_key_format(drop_key->key, drop_key->key_len, &ds);
3314             VLOG_WARN("Failed to delete drop key (%s) (%s)",
3315                       ovs_strerror(error), ds_cstr(&ds));
3316             ds_destroy(&ds);
3317         }
3318
3319         hmap_remove(&backer->drop_keys, &drop_key->hmap_node);
3320         drop_key_destroy(drop_key);
3321     }
3322
3323     udpif_drop_key_clear(backer->udpif);
3324 }
3325
3326 static void
3327 handle_flow_misses(struct dpif_backer *backer, struct flow_miss_batch *fmb)
3328 {
3329     struct flow_miss_op flow_miss_ops[FLOW_MISS_MAX_BATCH];
3330     struct dpif_op *dpif_ops[FLOW_MISS_MAX_BATCH];
3331     struct flow_miss *miss;
3332     size_t n_ops, i;
3333
3334     /* Process each element in the to-do list, constructing the set of
3335      * operations to batch. */
3336     n_ops = 0;
3337     HMAP_FOR_EACH (miss, hmap_node, &fmb->misses) {
3338         handle_flow_miss(miss, flow_miss_ops, &n_ops);
3339     }
3340     ovs_assert(n_ops <= ARRAY_SIZE(flow_miss_ops));
3341
3342     /* Execute batch. */
3343     for (i = 0; i < n_ops; i++) {
3344         dpif_ops[i] = &flow_miss_ops[i].dpif_op;
3345     }
3346     dpif_operate(backer->dpif, dpif_ops, n_ops);
3347
3348     for (i = 0; i < n_ops; i++) {
3349         if (dpif_ops[i]->error != 0
3350             && flow_miss_ops[i].dpif_op.type == DPIF_OP_FLOW_PUT
3351             && flow_miss_ops[i].subfacet) {
3352             struct subfacet *subfacet = flow_miss_ops[i].subfacet;
3353
3354             COVERAGE_INC(subfacet_install_fail);
3355
3356             /* Zero-out subfacet counters when installation failed, but
3357              * datapath reported hits.  This should not happen and
3358              * indicates a bug, since if the datapath flow exists, we
3359              * should not be attempting to create a new subfacet.  A
3360              * buggy datapath could trigger this, so just zero out the
3361              * counters and log an error. */
3362             if (subfacet->dp_packet_count || subfacet->dp_byte_count) {
3363                 VLOG_ERR_RL(&rl, "failed to install subfacet for which "
3364                             "datapath reported hits");
3365                 subfacet->dp_packet_count = subfacet->dp_byte_count = 0;
3366             }
3367
3368             subfacet->path = SF_NOT_INSTALLED;
3369         }
3370     }
3371 }
3372
3373 static void
3374 handle_upcalls(struct dpif_backer *backer)
3375 {
3376     struct flow_miss_batch *fmb;
3377     int n_processed;
3378
3379     for (n_processed = 0; n_processed < FLOW_MISS_MAX_BATCH; n_processed++) {
3380         struct drop_key *drop_key = drop_key_next(backer->udpif);
3381         if (!drop_key) {
3382             break;
3383         }
3384
3385         if (!drop_key_lookup(backer, drop_key->key, drop_key->key_len)) {
3386             hmap_insert(&backer->drop_keys, &drop_key->hmap_node,
3387                         hash_bytes(drop_key->key, drop_key->key_len, 0));
3388             dpif_flow_put(backer->dpif, DPIF_FP_CREATE | DPIF_FP_MODIFY,
3389                           drop_key->key, drop_key->key_len,
3390                           NULL, 0, NULL, 0, NULL);
3391         } else {
3392             drop_key_destroy(drop_key);
3393         }
3394     }
3395
3396     fmb = flow_miss_batch_next(backer->udpif);
3397     if (fmb) {
3398         handle_flow_misses(backer, fmb);
3399         flow_miss_batch_destroy(fmb);
3400     }
3401 }
3402 \f
3403 /* Flow expiration. */
3404
3405 static int subfacet_max_idle(const struct dpif_backer *);
3406 static void update_stats(struct dpif_backer *);
3407 static void rule_expire(struct rule_dpif *) OVS_REQUIRES(ofproto_mutex);
3408 static void expire_subfacets(struct dpif_backer *, int dp_max_idle);
3409
3410 /* This function is called periodically by run().  Its job is to collect
3411  * updates for the flows that have been installed into the datapath, most
3412  * importantly when they last were used, and then use that information to
3413  * expire flows that have not been used recently.
3414  *
3415  * Returns the number of milliseconds after which it should be called again. */
3416 static int
3417 expire(struct dpif_backer *backer)
3418 {
3419     struct ofproto_dpif *ofproto;
3420     size_t n_subfacets;
3421     int max_idle;
3422
3423     /* Periodically clear out the drop keys in an effort to keep them
3424      * relatively few. */
3425     drop_key_clear(backer);
3426
3427     /* Update stats for each flow in the backer. */
3428     update_stats(backer);
3429
3430     n_subfacets = hmap_count(&backer->subfacets);
3431     if (n_subfacets) {
3432         struct subfacet *subfacet;
3433         long long int total, now;
3434
3435         total = 0;
3436         now = time_msec();
3437         HMAP_FOR_EACH (subfacet, hmap_node, &backer->subfacets) {
3438             total += now - subfacet->created;
3439         }
3440         backer->avg_subfacet_life += total / n_subfacets;
3441     }
3442     backer->avg_subfacet_life /= 2;
3443
3444     backer->avg_n_subfacet += n_subfacets;
3445     backer->avg_n_subfacet /= 2;
3446
3447     backer->max_n_subfacet = MAX(backer->max_n_subfacet, n_subfacets);
3448
3449     max_idle = subfacet_max_idle(backer);
3450     expire_subfacets(backer, max_idle);
3451
3452     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
3453         struct rule *rule, *next_rule;
3454
3455         if (ofproto->backer != backer) {
3456             continue;
3457         }
3458
3459         /* Expire OpenFlow flows whose idle_timeout or hard_timeout
3460          * has passed. */
3461         ovs_mutex_lock(&ofproto_mutex);
3462         LIST_FOR_EACH_SAFE (rule, next_rule, expirable,
3463                             &ofproto->up.expirable) {
3464             rule_expire(rule_dpif_cast(rule));
3465         }
3466         ovs_mutex_unlock(&ofproto_mutex);
3467
3468         /* All outstanding data in existing flows has been accounted, so it's a
3469          * good time to do bond rebalancing. */
3470         if (ofproto->has_bonded_bundles) {
3471             struct ofbundle *bundle;
3472
3473             HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
3474                 if (bundle->bond) {
3475                     bond_rebalance(bundle->bond);
3476                 }
3477             }
3478         }
3479     }
3480
3481     return MIN(max_idle, 1000);
3482 }
3483
3484 /* Updates flow table statistics given that the datapath just reported 'stats'
3485  * as 'subfacet''s statistics. */
3486 static void
3487 update_subfacet_stats(struct subfacet *subfacet,
3488                       const struct dpif_flow_stats *stats)
3489 {
3490     struct facet *facet = subfacet->facet;
3491     struct dpif_flow_stats diff;
3492
3493     diff.tcp_flags = stats->tcp_flags;
3494     diff.used = stats->used;
3495
3496     if (stats->n_packets >= subfacet->dp_packet_count) {
3497         diff.n_packets = stats->n_packets - subfacet->dp_packet_count;
3498     } else {
3499         VLOG_WARN_RL(&rl, "unexpected packet count from the datapath");
3500         diff.n_packets = 0;
3501     }
3502
3503     if (stats->n_bytes >= subfacet->dp_byte_count) {
3504         diff.n_bytes = stats->n_bytes - subfacet->dp_byte_count;
3505     } else {
3506         VLOG_WARN_RL(&rl, "unexpected byte count from datapath");
3507         diff.n_bytes = 0;
3508     }
3509
3510     facet->ofproto->n_hit += diff.n_packets;
3511     subfacet->dp_packet_count = stats->n_packets;
3512     subfacet->dp_byte_count = stats->n_bytes;
3513     subfacet_update_stats(subfacet, &diff);
3514
3515     if (facet->accounted_bytes < facet->byte_count) {
3516         facet_learn(facet);
3517         facet_account(facet);
3518         facet->accounted_bytes = facet->byte_count;
3519     }
3520 }
3521
3522 /* 'key' with length 'key_len' bytes is a flow in 'dpif' that we know nothing
3523  * about, or a flow that shouldn't be installed but was anyway.  Delete it. */
3524 static void
3525 delete_unexpected_flow(struct dpif_backer *backer,
3526                        const struct nlattr *key, size_t key_len)
3527 {
3528     if (!VLOG_DROP_WARN(&rl)) {
3529         struct ds s;
3530
3531         ds_init(&s);
3532         odp_flow_key_format(key, key_len, &s);
3533         VLOG_WARN("unexpected flow: %s", ds_cstr(&s));
3534         ds_destroy(&s);
3535     }
3536
3537     COVERAGE_INC(facet_unexpected);
3538     dpif_flow_del(backer->dpif, key, key_len, NULL);
3539 }
3540
3541 /* Update 'packet_count', 'byte_count', and 'used' members of installed facets.
3542  *
3543  * This function also pushes statistics updates to rules which each facet
3544  * resubmits into.  Generally these statistics will be accurate.  However, if a
3545  * facet changes the rule it resubmits into at some time in between
3546  * update_stats() runs, it is possible that statistics accrued to the
3547  * old rule will be incorrectly attributed to the new rule.  This could be
3548  * avoided by calling update_stats() whenever rules are created or
3549  * deleted.  However, the performance impact of making so many calls to the
3550  * datapath do not justify the benefit of having perfectly accurate statistics.
3551  *
3552  * In addition, this function maintains per ofproto flow hit counts. The patch
3553  * port is not treated specially. e.g. A packet ingress from br0 patched into
3554  * br1 will increase the hit count of br0 by 1, however, does not affect
3555  * the hit or miss counts of br1.
3556  */
3557 static void
3558 update_stats(struct dpif_backer *backer)
3559 {
3560     const struct dpif_flow_stats *stats;
3561     struct dpif_flow_dump dump;
3562     const struct nlattr *key, *mask;
3563     size_t key_len, mask_len;
3564
3565     dpif_flow_dump_start(&dump, backer->dpif);
3566     while (dpif_flow_dump_next(&dump, &key, &key_len,
3567                                &mask, &mask_len, NULL, NULL, &stats)) {
3568         struct subfacet *subfacet;
3569         uint32_t key_hash;
3570
3571         key_hash = odp_flow_key_hash(key, key_len);
3572         subfacet = subfacet_find(backer, key, key_len, key_hash);
3573         switch (subfacet ? subfacet->path : SF_NOT_INSTALLED) {
3574         case SF_FAST_PATH:
3575             update_subfacet_stats(subfacet, stats);
3576             break;
3577
3578         case SF_SLOW_PATH:
3579             /* Stats are updated per-packet. */
3580             break;
3581
3582         case SF_NOT_INSTALLED:
3583         default:
3584             delete_unexpected_flow(backer, key, key_len);
3585             break;
3586         }
3587         run_fast_rl();
3588     }
3589     dpif_flow_dump_done(&dump);
3590 }
3591
3592 /* Calculates and returns the number of milliseconds of idle time after which
3593  * subfacets should expire from the datapath.  When a subfacet expires, we fold
3594  * its statistics into its facet, and when a facet's last subfacet expires, we
3595  * fold its statistic into its rule. */
3596 static int
3597 subfacet_max_idle(const struct dpif_backer *backer)
3598 {
3599     /*
3600      * Idle time histogram.
3601      *
3602      * Most of the time a switch has a relatively small number of subfacets.
3603      * When this is the case we might as well keep statistics for all of them
3604      * in userspace and to cache them in the kernel datapath for performance as
3605      * well.
3606      *
3607      * As the number of subfacets increases, the memory required to maintain
3608      * statistics about them in userspace and in the kernel becomes
3609      * significant.  However, with a large number of subfacets it is likely
3610      * that only a few of them are "heavy hitters" that consume a large amount
3611      * of bandwidth.  At this point, only heavy hitters are worth caching in
3612      * the kernel and maintaining in userspaces; other subfacets we can
3613      * discard.
3614      *
3615      * The technique used to compute the idle time is to build a histogram with
3616      * N_BUCKETS buckets whose width is BUCKET_WIDTH msecs each.  Each subfacet
3617      * that is installed in the kernel gets dropped in the appropriate bucket.
3618      * After the histogram has been built, we compute the cutoff so that only
3619      * the most-recently-used 1% of subfacets (but at least
3620      * flow_eviction_threshold flows) are kept cached.  At least
3621      * the most-recently-used bucket of subfacets is kept, so actually an
3622      * arbitrary number of subfacets can be kept in any given expiration run
3623      * (though the next run will delete most of those unless they receive
3624      * additional data).
3625      *
3626      * This requires a second pass through the subfacets, in addition to the
3627      * pass made by update_stats(), because the former function never looks at
3628      * uninstallable subfacets.
3629      */
3630     enum { BUCKET_WIDTH = 100 };
3631     enum { N_BUCKETS = 5000 / BUCKET_WIDTH };
3632     int buckets[N_BUCKETS] = { 0 };
3633     int total, subtotal, bucket;
3634     struct subfacet *subfacet;
3635     long long int now;
3636     int i;
3637
3638     total = hmap_count(&backer->subfacets);
3639     if (total <= flow_eviction_threshold) {
3640         return N_BUCKETS * BUCKET_WIDTH;
3641     }
3642
3643     /* Build histogram. */
3644     now = time_msec();
3645     HMAP_FOR_EACH (subfacet, hmap_node, &backer->subfacets) {
3646         long long int idle = now - subfacet->used;
3647         int bucket = (idle <= 0 ? 0
3648                       : idle >= BUCKET_WIDTH * N_BUCKETS ? N_BUCKETS - 1
3649                       : (unsigned int) idle / BUCKET_WIDTH);
3650         buckets[bucket]++;
3651     }
3652
3653     /* Find the first bucket whose flows should be expired. */
3654     subtotal = bucket = 0;
3655     do {
3656         subtotal += buckets[bucket++];
3657     } while (bucket < N_BUCKETS &&
3658              subtotal < MAX(flow_eviction_threshold, total / 100));
3659
3660     if (VLOG_IS_DBG_ENABLED()) {
3661         struct ds s;
3662
3663         ds_init(&s);
3664         ds_put_cstr(&s, "keep");
3665         for (i = 0; i < N_BUCKETS; i++) {
3666             if (i == bucket) {
3667                 ds_put_cstr(&s, ", drop");
3668             }
3669             if (buckets[i]) {
3670                 ds_put_format(&s, " %d:%d", i * BUCKET_WIDTH, buckets[i]);
3671             }
3672         }
3673         VLOG_INFO("%s (msec:count)", ds_cstr(&s));
3674         ds_destroy(&s);
3675     }
3676
3677     return bucket * BUCKET_WIDTH;
3678 }
3679
3680 static void
3681 expire_subfacets(struct dpif_backer *backer, int dp_max_idle)
3682 {
3683     /* Cutoff time for most flows. */
3684     long long int normal_cutoff = time_msec() - dp_max_idle;
3685
3686     /* We really want to keep flows for special protocols around, so use a more
3687      * conservative cutoff. */
3688     long long int special_cutoff = time_msec() - 10000;
3689
3690     struct subfacet *subfacet, *next_subfacet;
3691     struct subfacet *batch[SUBFACET_DESTROY_MAX_BATCH];
3692     int n_batch;
3693
3694     n_batch = 0;
3695     HMAP_FOR_EACH_SAFE (subfacet, next_subfacet, hmap_node,
3696                         &backer->subfacets) {
3697         long long int cutoff;
3698
3699         cutoff = (subfacet->facet->xout.slow & (SLOW_CFM | SLOW_BFD | SLOW_LACP
3700                                                 | SLOW_STP)
3701                   ? special_cutoff
3702                   : normal_cutoff);
3703         if (subfacet->used < cutoff) {
3704             if (subfacet->path != SF_NOT_INSTALLED) {
3705                 batch[n_batch++] = subfacet;
3706                 if (n_batch >= SUBFACET_DESTROY_MAX_BATCH) {
3707                     subfacet_destroy_batch(backer, batch, n_batch);
3708                     n_batch = 0;
3709                 }
3710             } else {
3711                 subfacet_destroy(subfacet);
3712             }
3713         }
3714     }
3715
3716     if (n_batch > 0) {
3717         subfacet_destroy_batch(backer, batch, n_batch);
3718     }
3719 }
3720
3721 /* If 'rule' is an OpenFlow rule, that has expired according to OpenFlow rules,
3722  * then delete it entirely. */
3723 static void
3724 rule_expire(struct rule_dpif *rule)
3725     OVS_REQUIRES(ofproto_mutex)
3726 {
3727     uint16_t idle_timeout, hard_timeout;
3728     long long int now = time_msec();
3729     int reason;
3730
3731     ovs_assert(!rule->up.pending);
3732
3733     /* Has 'rule' expired? */
3734     ovs_mutex_lock(&rule->up.mutex);
3735     hard_timeout = rule->up.hard_timeout;
3736     idle_timeout = rule->up.idle_timeout;
3737     if (hard_timeout && now > rule->up.modified + hard_timeout * 1000) {
3738         reason = OFPRR_HARD_TIMEOUT;
3739     } else if (idle_timeout && now > rule->up.used + idle_timeout * 1000) {
3740         reason = OFPRR_IDLE_TIMEOUT;
3741     } else {
3742         reason = -1;
3743     }
3744     ovs_mutex_unlock(&rule->up.mutex);
3745
3746     if (reason >= 0) {
3747         COVERAGE_INC(ofproto_dpif_expired);
3748         ofproto_rule_expire(&rule->up, reason);
3749     }
3750 }
3751 \f
3752 /* Facets. */
3753
3754 /* Creates and returns a new facet based on 'miss'.
3755  *
3756  * The caller must already have determined that no facet with an identical
3757  * 'miss->flow' exists in 'miss->ofproto'.
3758  *
3759  * 'rule' and 'xout' must have been created based on 'miss'.
3760  *
3761  * 'facet'' statistics are initialized based on 'stats'.
3762  *
3763  * The facet will initially have no subfacets.  The caller should create (at
3764  * least) one subfacet with subfacet_create(). */
3765 static struct facet *
3766 facet_create(const struct flow_miss *miss)
3767 {
3768     struct ofproto_dpif *ofproto = miss->ofproto;
3769     struct facet *facet;
3770     struct match match;
3771
3772     COVERAGE_INC(facet_create);
3773     facet = xzalloc(sizeof *facet);
3774     facet->ofproto = miss->ofproto;
3775     facet->used = miss->stats.used;
3776     facet->flow = miss->flow;
3777     facet->learn_rl = time_msec() + 500;
3778
3779     list_init(&facet->subfacets);
3780     netflow_flow_init(&facet->nf_flow);
3781     netflow_flow_update_time(ofproto->netflow, &facet->nf_flow, facet->used);
3782
3783     xlate_out_copy(&facet->xout, &miss->xout);
3784
3785     match_init(&match, &facet->flow, &facet->xout.wc);
3786     cls_rule_init(&facet->cr, &match, OFP_DEFAULT_PRIORITY);
3787     ovs_rwlock_wrlock(&ofproto->facets.rwlock);
3788     classifier_insert(&ofproto->facets, &facet->cr);
3789     ovs_rwlock_unlock(&ofproto->facets.rwlock);
3790
3791     facet->nf_flow.output_iface = facet->xout.nf_output_iface;
3792     return facet;
3793 }
3794
3795 static void
3796 facet_free(struct facet *facet)
3797 {
3798     if (facet) {
3799         xlate_out_uninit(&facet->xout);
3800         free(facet);
3801     }
3802 }
3803
3804 /* Executes, within 'ofproto', the 'n_actions' actions in 'actions' on
3805  * 'packet', which arrived on 'in_port'. */
3806 static int
3807 execute_actions(struct ofproto *ofproto_, const struct flow *flow,
3808                 struct rule_dpif *rule,
3809                 const struct ofpact *ofpacts, size_t ofpacts_len,
3810                 struct ofpbuf *packet)
3811 {
3812     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3813     struct odputil_keybuf keybuf;
3814     struct dpif_flow_stats stats;
3815     struct xlate_out xout;
3816     struct xlate_in xin;
3817     ofp_port_t in_port;
3818     struct ofpbuf key;
3819     int error;
3820
3821     ovs_assert((rule != NULL) != (ofpacts != NULL));
3822
3823     dpif_flow_stats_extract(flow, packet, time_msec(), &stats);
3824     if (rule) {
3825         rule_dpif_credit_stats(rule, &stats);
3826     }
3827
3828     xlate_in_init(&xin, ofproto, flow, rule, stats.tcp_flags, packet);
3829     xin.ofpacts = ofpacts;
3830     xin.ofpacts_len = ofpacts_len;
3831     xin.resubmit_stats = &stats;
3832     xlate_actions(&xin, &xout);
3833
3834     ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
3835     in_port = flow->in_port.ofp_port;
3836     if (in_port == OFPP_NONE) {
3837         in_port = OFPP_LOCAL;
3838     }
3839     odp_flow_key_from_flow(&key, flow, ofp_port_to_odp_port(ofproto, in_port));
3840
3841     error = dpif_execute(ofproto->backer->dpif, key.data, key.size,
3842                          xout.odp_actions.data, xout.odp_actions.size, packet);
3843     xlate_out_uninit(&xout);
3844
3845     return error;
3846 }
3847
3848 /* Remove 'facet' from its ofproto and free up the associated memory:
3849  *
3850  *   - If 'facet' was installed in the datapath, uninstalls it and updates its
3851  *     rule's statistics, via subfacet_uninstall().
3852  *
3853  *   - Removes 'facet' from its rule and from ofproto->facets.
3854  */
3855 static void
3856 facet_remove(struct facet *facet)
3857 {
3858     struct subfacet *subfacet, *next_subfacet;
3859
3860     COVERAGE_INC(facet_remove);
3861     ovs_assert(!list_is_empty(&facet->subfacets));
3862
3863     /* First uninstall all of the subfacets to get final statistics. */
3864     LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
3865         subfacet_uninstall(subfacet);
3866     }
3867
3868     /* Flush the final stats to the rule.
3869      *
3870      * This might require us to have at least one subfacet around so that we
3871      * can use its actions for accounting in facet_account(), which is why we
3872      * have uninstalled but not yet destroyed the subfacets. */
3873     facet_flush_stats(facet);
3874
3875     /* Now we're really all done so destroy everything. */
3876     LIST_FOR_EACH_SAFE (subfacet, next_subfacet, list_node,
3877                         &facet->subfacets) {
3878         subfacet_destroy__(subfacet);
3879     }
3880     ovs_rwlock_wrlock(&facet->ofproto->facets.rwlock);
3881     classifier_remove(&facet->ofproto->facets, &facet->cr);
3882     ovs_rwlock_unlock(&facet->ofproto->facets.rwlock);
3883     cls_rule_destroy(&facet->cr);
3884     facet_free(facet);
3885 }
3886
3887 /* Feed information from 'facet' back into the learning table to keep it in
3888  * sync with what is actually flowing through the datapath. */
3889 static void
3890 facet_learn(struct facet *facet)
3891 {
3892     long long int now = time_msec();
3893
3894     if (!facet->xout.has_fin_timeout && now < facet->learn_rl) {
3895         return;
3896     }
3897
3898     facet->learn_rl = now + 500;
3899
3900     if (!facet->xout.has_learn
3901         && !facet->xout.has_normal
3902         && (!facet->xout.has_fin_timeout
3903             || !(facet->tcp_flags & (TCP_FIN | TCP_RST)))) {
3904         return;
3905     }
3906
3907     facet_push_stats(facet, true);
3908 }
3909
3910 static void
3911 facet_account(struct facet *facet)
3912 {
3913     const struct nlattr *a;
3914     unsigned int left;
3915     ovs_be16 vlan_tci;
3916     uint64_t n_bytes;
3917
3918     if (!facet->xout.has_normal || !facet->ofproto->has_bonded_bundles) {
3919         return;
3920     }
3921     n_bytes = facet->byte_count - facet->accounted_bytes;
3922
3923     /* This loop feeds byte counters to bond_account() for rebalancing to use
3924      * as a basis.  We also need to track the actual VLAN on which the packet
3925      * is going to be sent to ensure that it matches the one passed to
3926      * bond_choose_output_slave().  (Otherwise, we will account to the wrong
3927      * hash bucket.)
3928      *
3929      * We use the actions from an arbitrary subfacet because they should all
3930      * be equally valid for our purpose. */
3931     vlan_tci = facet->flow.vlan_tci;
3932     NL_ATTR_FOR_EACH_UNSAFE (a, left, facet->xout.odp_actions.data,
3933                              facet->xout.odp_actions.size) {
3934         const struct ovs_action_push_vlan *vlan;
3935         struct ofport_dpif *port;
3936
3937         switch (nl_attr_type(a)) {
3938         case OVS_ACTION_ATTR_OUTPUT:
3939             port = get_odp_port(facet->ofproto, nl_attr_get_odp_port(a));
3940             if (port && port->bundle && port->bundle->bond) {
3941                 bond_account(port->bundle->bond, &facet->flow,
3942                              vlan_tci_to_vid(vlan_tci), n_bytes);
3943             }
3944             break;
3945
3946         case OVS_ACTION_ATTR_POP_VLAN:
3947             vlan_tci = htons(0);
3948             break;
3949
3950         case OVS_ACTION_ATTR_PUSH_VLAN:
3951             vlan = nl_attr_get(a);
3952             vlan_tci = vlan->vlan_tci;
3953             break;
3954         }
3955     }
3956 }
3957
3958 /* Returns true if the only action for 'facet' is to send to the controller.
3959  * (We don't report NetFlow expiration messages for such facets because they
3960  * are just part of the control logic for the network, not real traffic). */
3961 static bool
3962 facet_is_controller_flow(struct facet *facet)
3963 {
3964     if (facet) {
3965         struct ofproto_dpif *ofproto = facet->ofproto;
3966         const struct ofpact *ofpacts;
3967         struct rule_actions *actions;
3968         struct rule_dpif *rule;
3969         size_t ofpacts_len;
3970         bool is_controller;
3971
3972         rule_dpif_lookup(ofproto, &facet->flow, NULL, &rule);
3973         actions = rule_dpif_get_actions(rule);
3974         rule_dpif_unref(rule);
3975
3976         ofpacts_len = actions->ofpacts_len;
3977         ofpacts = actions->ofpacts;
3978         is_controller = ofpacts_len > 0
3979             && ofpacts->type == OFPACT_CONTROLLER
3980             && ofpact_next(ofpacts) >= ofpact_end(ofpacts, ofpacts_len);
3981         rule_actions_unref(actions);
3982
3983         return is_controller;
3984     }
3985     return false;
3986 }
3987
3988 /* Folds all of 'facet''s statistics into its rule.  Also updates the
3989  * accounting ofhook and emits a NetFlow expiration if appropriate.  All of
3990  * 'facet''s statistics in the datapath should have been zeroed and folded into
3991  * its packet and byte counts before this function is called. */
3992 static void
3993 facet_flush_stats(struct facet *facet)
3994 {
3995     struct ofproto_dpif *ofproto = facet->ofproto;
3996     struct subfacet *subfacet;
3997
3998     LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
3999         ovs_assert(!subfacet->dp_byte_count);
4000         ovs_assert(!subfacet->dp_packet_count);
4001     }
4002
4003     facet_push_stats(facet, false);
4004     if (facet->accounted_bytes < facet->byte_count) {
4005         facet_account(facet);
4006         facet->accounted_bytes = facet->byte_count;
4007     }
4008
4009     if (ofproto->netflow && !facet_is_controller_flow(facet)) {
4010         struct ofexpired expired;
4011         expired.flow = facet->flow;
4012         expired.packet_count = facet->packet_count;
4013         expired.byte_count = facet->byte_count;
4014         expired.used = facet->used;
4015         netflow_expire(ofproto->netflow, &facet->nf_flow, &expired);
4016     }
4017
4018     /* Reset counters to prevent double counting if 'facet' ever gets
4019      * reinstalled. */
4020     facet_reset_counters(facet);
4021
4022     netflow_flow_clear(&facet->nf_flow);
4023     facet->tcp_flags = 0;
4024 }
4025
4026 /* Searches 'ofproto''s table of facets for one which would be responsible for
4027  * 'flow'.  Returns it if found, otherwise a null pointer.
4028  *
4029  * The returned facet might need revalidation; use facet_lookup_valid()
4030  * instead if that is important. */
4031 static struct facet *
4032 facet_find(struct ofproto_dpif *ofproto, const struct flow *flow)
4033 {
4034     struct cls_rule *cr;
4035
4036     ovs_rwlock_rdlock(&ofproto->facets.rwlock);
4037     cr = classifier_lookup(&ofproto->facets, flow, NULL);
4038     ovs_rwlock_unlock(&ofproto->facets.rwlock);
4039     return cr ? CONTAINER_OF(cr, struct facet, cr) : NULL;
4040 }
4041
4042 /* Searches 'ofproto''s table of facets for one capable that covers
4043  * 'flow'.  Returns it if found, otherwise a null pointer.
4044  *
4045  * The returned facet is guaranteed to be valid. */
4046 static struct facet *
4047 facet_lookup_valid(struct ofproto_dpif *ofproto, const struct flow *flow)
4048 {
4049     struct facet *facet;
4050
4051     facet = facet_find(ofproto, flow);
4052     if (facet
4053         && ofproto->backer->need_revalidate
4054         && !facet_revalidate(facet)) {
4055         return NULL;
4056     }
4057
4058     return facet;
4059 }
4060
4061 static bool
4062 facet_check_consistency(struct facet *facet)
4063 {
4064     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 15);
4065
4066     struct xlate_out xout;
4067     struct xlate_in xin;
4068     bool ok;
4069
4070     /* Check the datapath actions for consistency. */
4071     xlate_in_init(&xin, facet->ofproto, &facet->flow, NULL, 0, NULL);
4072     xlate_actions(&xin, &xout);
4073
4074     ok = ofpbuf_equal(&facet->xout.odp_actions, &xout.odp_actions)
4075         && facet->xout.slow == xout.slow;
4076     if (!ok && !VLOG_DROP_WARN(&rl)) {
4077         struct ds s = DS_EMPTY_INITIALIZER;
4078
4079         flow_format(&s, &facet->flow);
4080         ds_put_cstr(&s, ": inconsistency in facet");
4081
4082         if (!ofpbuf_equal(&facet->xout.odp_actions, &xout.odp_actions)) {
4083             ds_put_cstr(&s, " (actions were: ");
4084             format_odp_actions(&s, facet->xout.odp_actions.data,
4085                                facet->xout.odp_actions.size);
4086             ds_put_cstr(&s, ") (correct actions: ");
4087             format_odp_actions(&s, xout.odp_actions.data,
4088                                xout.odp_actions.size);
4089             ds_put_char(&s, ')');
4090         }
4091
4092         if (facet->xout.slow != xout.slow) {
4093             ds_put_format(&s, " slow path incorrect. should be %d", xout.slow);
4094         }
4095
4096         ds_destroy(&s);
4097     }
4098     xlate_out_uninit(&xout);
4099
4100     return ok;
4101 }
4102
4103 /* Re-searches the classifier for 'facet':
4104  *
4105  *   - If the rule found is different from 'facet''s current rule, moves
4106  *     'facet' to the new rule and recompiles its actions.
4107  *
4108  *   - If the rule found is the same as 'facet''s current rule, leaves 'facet'
4109  *     where it is and recompiles its actions anyway.
4110  *
4111  *   - If any of 'facet''s subfacets correspond to a new flow according to
4112  *     xlate_receive(), 'facet' is removed.
4113  *
4114  *   Returns true if 'facet' is still valid.  False if 'facet' was removed. */
4115 static bool
4116 facet_revalidate(struct facet *facet)
4117 {
4118     struct ofproto_dpif *ofproto = facet->ofproto;
4119     struct rule_dpif *new_rule;
4120     struct subfacet *subfacet;
4121     struct flow_wildcards wc;
4122     struct xlate_out xout;
4123     struct xlate_in xin;
4124
4125     COVERAGE_INC(facet_revalidate);
4126
4127     /* Check that child subfacets still correspond to this facet.  Tunnel
4128      * configuration changes could cause a subfacet's OpenFlow in_port to
4129      * change. */
4130     LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
4131         struct ofproto_dpif *recv_ofproto;
4132         struct flow recv_flow;
4133         int error;
4134
4135         error = xlate_receive(ofproto->backer, NULL, subfacet->key,
4136                               subfacet->key_len, &recv_flow, NULL,
4137                               &recv_ofproto, NULL);
4138         if (error
4139             || recv_ofproto != ofproto
4140             || facet != facet_find(ofproto, &recv_flow)) {
4141             facet_remove(facet);
4142             return false;
4143         }
4144     }
4145
4146     flow_wildcards_init_catchall(&wc);
4147     rule_dpif_lookup(ofproto, &facet->flow, &wc, &new_rule);
4148
4149     /* Calculate new datapath actions.
4150      *
4151      * We do not modify any 'facet' state yet, because we might need to, e.g.,
4152      * emit a NetFlow expiration and, if so, we need to have the old state
4153      * around to properly compose it. */
4154     xlate_in_init(&xin, ofproto, &facet->flow, new_rule, 0, NULL);
4155     xlate_actions(&xin, &xout);
4156     flow_wildcards_or(&xout.wc, &xout.wc, &wc);
4157
4158     /* A facet's slow path reason should only change under dramatic
4159      * circumstances.  Rather than try to update everything, it's simpler to
4160      * remove the facet and start over.
4161      *
4162      * More importantly, if a facet's wildcards change, it will be relatively
4163      * difficult to figure out if its subfacets still belong to it, and if not
4164      * which facet they may belong to.  Again, to avoid the complexity, we
4165      * simply give up instead. */
4166     if (facet->xout.slow != xout.slow
4167         || memcmp(&facet->xout.wc, &xout.wc, sizeof xout.wc)) {
4168         facet_remove(facet);
4169         xlate_out_uninit(&xout);
4170         rule_dpif_unref(new_rule);
4171         return false;
4172     }
4173
4174     if (!ofpbuf_equal(&facet->xout.odp_actions, &xout.odp_actions)) {
4175         LIST_FOR_EACH(subfacet, list_node, &facet->subfacets) {
4176             if (subfacet->path == SF_FAST_PATH) {
4177                 struct dpif_flow_stats stats;
4178
4179                 subfacet_install(subfacet, &xout.odp_actions, &stats);
4180                 subfacet_update_stats(subfacet, &stats);
4181             }
4182         }
4183
4184         facet_flush_stats(facet);
4185
4186         ofpbuf_clear(&facet->xout.odp_actions);
4187         ofpbuf_put(&facet->xout.odp_actions, xout.odp_actions.data,
4188                    xout.odp_actions.size);
4189     }
4190
4191     /* Update 'facet' now that we've taken care of all the old state. */
4192     facet->xout.slow = xout.slow;
4193     facet->xout.has_learn = xout.has_learn;
4194     facet->xout.has_normal = xout.has_normal;
4195     facet->xout.has_fin_timeout = xout.has_fin_timeout;
4196     facet->xout.nf_output_iface = xout.nf_output_iface;
4197     facet->xout.mirrors = xout.mirrors;
4198     facet->nf_flow.output_iface = facet->xout.nf_output_iface;
4199
4200     ovs_mutex_lock(&new_rule->up.mutex);
4201     facet->used = MAX(facet->used, new_rule->up.created);
4202     ovs_mutex_unlock(&new_rule->up.mutex);
4203
4204     xlate_out_uninit(&xout);
4205     rule_dpif_unref(new_rule);
4206     return true;
4207 }
4208
4209 static void
4210 facet_reset_counters(struct facet *facet)
4211 {
4212     facet->packet_count = 0;
4213     facet->byte_count = 0;
4214     facet->prev_packet_count = 0;
4215     facet->prev_byte_count = 0;
4216     facet->accounted_bytes = 0;
4217 }
4218
4219 static void
4220 flow_push_stats(struct ofproto_dpif *ofproto, struct flow *flow,
4221                 struct dpif_flow_stats *stats, bool may_learn)
4222 {
4223     struct ofport_dpif *in_port;
4224     struct xlate_in xin;
4225
4226     in_port = get_ofp_port(ofproto, flow->in_port.ofp_port);
4227     if (in_port && in_port->is_tunnel) {
4228         netdev_vport_inc_rx(in_port->up.netdev, stats);
4229     }
4230
4231     xlate_in_init(&xin, ofproto, flow, NULL, stats->tcp_flags, NULL);
4232     xin.resubmit_stats = stats;
4233     xin.may_learn = may_learn;
4234     xlate_actions_for_side_effects(&xin);
4235 }
4236
4237 static void
4238 facet_push_stats(struct facet *facet, bool may_learn)
4239 {
4240     struct dpif_flow_stats stats;
4241
4242     ovs_assert(facet->packet_count >= facet->prev_packet_count);
4243     ovs_assert(facet->byte_count >= facet->prev_byte_count);
4244     ovs_assert(facet->used >= facet->prev_used);
4245
4246     stats.n_packets = facet->packet_count - facet->prev_packet_count;
4247     stats.n_bytes = facet->byte_count - facet->prev_byte_count;
4248     stats.used = facet->used;
4249     stats.tcp_flags = facet->tcp_flags;
4250
4251     if (may_learn || stats.n_packets || facet->used > facet->prev_used) {
4252         facet->prev_packet_count = facet->packet_count;
4253         facet->prev_byte_count = facet->byte_count;
4254         facet->prev_used = facet->used;
4255
4256         netflow_flow_update_time(facet->ofproto->netflow, &facet->nf_flow,
4257                                  facet->used);
4258         netflow_flow_update_flags(&facet->nf_flow, facet->tcp_flags);
4259         mirror_update_stats(facet->ofproto->mbridge, facet->xout.mirrors,
4260                             stats.n_packets, stats.n_bytes);
4261         flow_push_stats(facet->ofproto, &facet->flow, &stats, may_learn);
4262     }
4263 }
4264
4265 static void
4266 push_all_stats__(bool run_fast)
4267 {
4268     static long long int rl = LLONG_MIN;
4269     struct ofproto_dpif *ofproto;
4270
4271     if (time_msec() < rl) {
4272         return;
4273     }
4274
4275     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
4276         struct cls_cursor cursor;
4277         struct facet *facet;
4278
4279         ovs_rwlock_rdlock(&ofproto->facets.rwlock);
4280         cls_cursor_init(&cursor, &ofproto->facets, NULL);
4281         CLS_CURSOR_FOR_EACH (facet, cr, &cursor) {
4282             facet_push_stats(facet, false);
4283             if (run_fast) {
4284                 run_fast_rl();
4285             }
4286         }
4287         ovs_rwlock_unlock(&ofproto->facets.rwlock);
4288     }
4289
4290     rl = time_msec() + 100;
4291 }
4292
4293 static void
4294 push_all_stats(void)
4295 {
4296     push_all_stats__(true);
4297 }
4298
4299 void
4300 rule_dpif_credit_stats(struct rule_dpif *rule,
4301                        const struct dpif_flow_stats *stats)
4302 {
4303     ovs_mutex_lock(&rule->stats_mutex);
4304     rule->packet_count += stats->n_packets;
4305     rule->byte_count += stats->n_bytes;
4306     rule->up.used = MAX(rule->up.used, stats->used);
4307     ovs_mutex_unlock(&rule->stats_mutex);
4308 }
4309
4310 bool
4311 rule_dpif_fail_open(const struct rule_dpif *rule)
4312 {
4313     return rule->up.cr.priority == FAIL_OPEN_PRIORITY;
4314 }
4315
4316 ovs_be64
4317 rule_dpif_get_flow_cookie(const struct rule_dpif *rule)
4318     OVS_REQUIRES(rule->up.mutex)
4319 {
4320     return rule->up.flow_cookie;
4321 }
4322
4323 void
4324 rule_dpif_reduce_timeouts(struct rule_dpif *rule, uint16_t idle_timeout,
4325                      uint16_t hard_timeout)
4326 {
4327     ofproto_rule_reduce_timeouts(&rule->up, idle_timeout, hard_timeout);
4328 }
4329
4330 /* Returns 'rule''s actions.  The caller owns a reference on the returned
4331  * actions and must eventually release it (with rule_actions_unref()) to avoid
4332  * a memory leak. */
4333 struct rule_actions *
4334 rule_dpif_get_actions(const struct rule_dpif *rule)
4335 {
4336     return rule_get_actions(&rule->up);
4337 }
4338 \f
4339 /* Subfacets. */
4340
4341 static struct subfacet *
4342 subfacet_find(struct dpif_backer *backer, const struct nlattr *key,
4343               size_t key_len, uint32_t key_hash)
4344 {
4345     struct subfacet *subfacet;
4346
4347     HMAP_FOR_EACH_WITH_HASH (subfacet, hmap_node, key_hash,
4348                              &backer->subfacets) {
4349         if (subfacet->key_len == key_len
4350             && !memcmp(key, subfacet->key, key_len)) {
4351             return subfacet;
4352         }
4353     }
4354
4355     return NULL;
4356 }
4357
4358 /* Searches 'facet' (within 'ofproto') for a subfacet with the specified
4359  * 'key_fitness', 'key', and 'key_len' members in 'miss'.  Returns the
4360  * existing subfacet if there is one, otherwise creates and returns a
4361  * new subfacet. */
4362 static struct subfacet *
4363 subfacet_create(struct facet *facet, struct flow_miss *miss)
4364 {
4365     struct dpif_backer *backer = miss->ofproto->backer;
4366     const struct nlattr *key = miss->key;
4367     size_t key_len = miss->key_len;
4368     uint32_t key_hash;
4369     struct subfacet *subfacet;
4370
4371     key_hash = odp_flow_key_hash(key, key_len);
4372
4373     if (list_is_empty(&facet->subfacets)) {
4374         subfacet = &facet->one_subfacet;
4375     } else {
4376         subfacet = subfacet_find(backer, key, key_len, key_hash);
4377         if (subfacet) {
4378             if (subfacet->facet == facet) {
4379                 return subfacet;
4380             }
4381
4382             /* This shouldn't happen. */
4383             VLOG_ERR_RL(&rl, "subfacet with wrong facet");
4384             subfacet_destroy(subfacet);
4385         }
4386
4387         subfacet = xmalloc(sizeof *subfacet);
4388     }
4389
4390     COVERAGE_INC(subfacet_create);
4391     hmap_insert(&backer->subfacets, &subfacet->hmap_node, key_hash);
4392     list_push_back(&facet->subfacets, &subfacet->list_node);
4393     subfacet->facet = facet;
4394     subfacet->key = xmemdup(key, key_len);
4395     subfacet->key_len = key_len;
4396     subfacet->used = miss->stats.used;
4397     subfacet->created = subfacet->used;
4398     subfacet->dp_packet_count = 0;
4399     subfacet->dp_byte_count = 0;
4400     subfacet->path = SF_NOT_INSTALLED;
4401     subfacet->backer = backer;
4402
4403     return subfacet;
4404 }
4405
4406 /* Uninstalls 'subfacet' from the datapath, if it is installed, removes it from
4407  * its facet within 'ofproto', and frees it. */
4408 static void
4409 subfacet_destroy__(struct subfacet *subfacet)
4410 {
4411     struct facet *facet = subfacet->facet;
4412
4413     COVERAGE_INC(subfacet_destroy);
4414     subfacet_uninstall(subfacet);
4415     hmap_remove(&subfacet->backer->subfacets, &subfacet->hmap_node);
4416     list_remove(&subfacet->list_node);
4417     free(subfacet->key);
4418     if (subfacet != &facet->one_subfacet) {
4419         free(subfacet);
4420     }
4421 }
4422
4423 /* Destroys 'subfacet', as with subfacet_destroy__(), and then if this was the
4424  * last remaining subfacet in its facet destroys the facet too. */
4425 static void
4426 subfacet_destroy(struct subfacet *subfacet)
4427 {
4428     struct facet *facet = subfacet->facet;
4429
4430     if (list_is_singleton(&facet->subfacets)) {
4431         /* facet_remove() needs at least one subfacet (it will remove it). */
4432         facet_remove(facet);
4433     } else {
4434         subfacet_destroy__(subfacet);
4435     }
4436 }
4437
4438 static void
4439 subfacet_destroy_batch(struct dpif_backer *backer,
4440                        struct subfacet **subfacets, int n)
4441 {
4442     struct dpif_op ops[SUBFACET_DESTROY_MAX_BATCH];
4443     struct dpif_op *opsp[SUBFACET_DESTROY_MAX_BATCH];
4444     struct dpif_flow_stats stats[SUBFACET_DESTROY_MAX_BATCH];
4445     int i;
4446
4447     for (i = 0; i < n; i++) {
4448         ops[i].type = DPIF_OP_FLOW_DEL;
4449         ops[i].u.flow_del.key = subfacets[i]->key;
4450         ops[i].u.flow_del.key_len = subfacets[i]->key_len;
4451         ops[i].u.flow_del.stats = &stats[i];
4452         opsp[i] = &ops[i];
4453     }
4454
4455     dpif_operate(backer->dpif, opsp, n);
4456     for (i = 0; i < n; i++) {
4457         subfacet_reset_dp_stats(subfacets[i], &stats[i]);
4458         subfacets[i]->path = SF_NOT_INSTALLED;
4459         subfacet_destroy(subfacets[i]);
4460         run_fast_rl();
4461     }
4462 }
4463
4464 /* Updates 'subfacet''s datapath flow, setting its actions to 'actions_len'
4465  * bytes of actions in 'actions'.  If 'stats' is non-null, statistics counters
4466  * in the datapath will be zeroed and 'stats' will be updated with traffic new
4467  * since 'subfacet' was last updated.
4468  *
4469  * Returns 0 if successful, otherwise a positive errno value. */
4470 static int
4471 subfacet_install(struct subfacet *subfacet, const struct ofpbuf *odp_actions,
4472                  struct dpif_flow_stats *stats)
4473 {
4474     struct facet *facet = subfacet->facet;
4475     enum subfacet_path path = facet->xout.slow ? SF_SLOW_PATH : SF_FAST_PATH;
4476     const struct nlattr *actions = odp_actions->data;
4477     size_t actions_len = odp_actions->size;
4478     struct odputil_keybuf maskbuf;
4479     struct ofpbuf mask;
4480
4481     uint64_t slow_path_stub[128 / 8];
4482     enum dpif_flow_put_flags flags;
4483     int ret;
4484
4485     flags = subfacet->path == SF_NOT_INSTALLED ? DPIF_FP_CREATE
4486                                                : DPIF_FP_MODIFY;
4487     if (stats) {
4488         flags |= DPIF_FP_ZERO_STATS;
4489     }
4490
4491     if (path == SF_SLOW_PATH) {
4492         compose_slow_path(facet->ofproto, &facet->flow, facet->xout.slow,
4493                           slow_path_stub, sizeof slow_path_stub,
4494                           &actions, &actions_len);
4495     }
4496
4497     ofpbuf_use_stack(&mask, &maskbuf, sizeof maskbuf);
4498     if (enable_megaflows) {
4499         odp_flow_key_from_mask(&mask, &facet->xout.wc.masks,
4500                                &facet->flow, UINT32_MAX);
4501     }
4502
4503     ret = dpif_flow_put(subfacet->backer->dpif, flags, subfacet->key,
4504                         subfacet->key_len,  mask.data, mask.size,
4505                         actions, actions_len, stats);
4506
4507     if (stats) {
4508         subfacet_reset_dp_stats(subfacet, stats);
4509     }
4510
4511     if (ret) {
4512         COVERAGE_INC(subfacet_install_fail);
4513     } else {
4514         subfacet->path = path;
4515     }
4516     return ret;
4517 }
4518
4519 /* If 'subfacet' is installed in the datapath, uninstalls it. */
4520 static void
4521 subfacet_uninstall(struct subfacet *subfacet)
4522 {
4523     if (subfacet->path != SF_NOT_INSTALLED) {
4524         struct ofproto_dpif *ofproto = subfacet->facet->ofproto;
4525         struct dpif_flow_stats stats;
4526         int error;
4527
4528         error = dpif_flow_del(ofproto->backer->dpif, subfacet->key,
4529                               subfacet->key_len, &stats);
4530         subfacet_reset_dp_stats(subfacet, &stats);
4531         if (!error) {
4532             subfacet_update_stats(subfacet, &stats);
4533         }
4534         subfacet->path = SF_NOT_INSTALLED;
4535     } else {
4536         ovs_assert(subfacet->dp_packet_count == 0);
4537         ovs_assert(subfacet->dp_byte_count == 0);
4538     }
4539 }
4540
4541 /* Resets 'subfacet''s datapath statistics counters.  This should be called
4542  * when 'subfacet''s statistics are cleared in the datapath.  If 'stats' is
4543  * non-null, it should contain the statistics returned by dpif when 'subfacet'
4544  * was reset in the datapath.  'stats' will be modified to include only
4545  * statistics new since 'subfacet' was last updated. */
4546 static void
4547 subfacet_reset_dp_stats(struct subfacet *subfacet,
4548                         struct dpif_flow_stats *stats)
4549 {
4550     if (stats
4551         && subfacet->dp_packet_count <= stats->n_packets
4552         && subfacet->dp_byte_count <= stats->n_bytes) {
4553         stats->n_packets -= subfacet->dp_packet_count;
4554         stats->n_bytes -= subfacet->dp_byte_count;
4555     }
4556
4557     subfacet->dp_packet_count = 0;
4558     subfacet->dp_byte_count = 0;
4559 }
4560
4561 /* Folds the statistics from 'stats' into the counters in 'subfacet'.
4562  *
4563  * Because of the meaning of a subfacet's counters, it only makes sense to do
4564  * this if 'stats' are not tracked in the datapath, that is, if 'stats'
4565  * represents a packet that was sent by hand or if it represents statistics
4566  * that have been cleared out of the datapath. */
4567 static void
4568 subfacet_update_stats(struct subfacet *subfacet,
4569                       const struct dpif_flow_stats *stats)
4570 {
4571     if (stats->n_packets || stats->used > subfacet->used) {
4572         struct facet *facet = subfacet->facet;
4573
4574         subfacet->used = MAX(subfacet->used, stats->used);
4575         facet->used = MAX(facet->used, stats->used);
4576         facet->packet_count += stats->n_packets;
4577         facet->byte_count += stats->n_bytes;
4578         facet->tcp_flags |= stats->tcp_flags;
4579     }
4580 }
4581 \f
4582 /* Rules. */
4583
4584 /* Lookup 'flow' in 'ofproto''s classifier.  If 'wc' is non-null, sets
4585  * the fields that were relevant as part of the lookup. */
4586 void
4587 rule_dpif_lookup(struct ofproto_dpif *ofproto, const struct flow *flow,
4588                  struct flow_wildcards *wc, struct rule_dpif **rule)
4589 {
4590     struct ofport_dpif *port;
4591
4592     if (rule_dpif_lookup_in_table(ofproto, flow, wc, 0, rule)) {
4593         return;
4594     }
4595     port = get_ofp_port(ofproto, flow->in_port.ofp_port);
4596     if (!port) {
4597         VLOG_WARN_RL(&rl, "packet-in on unknown OpenFlow port %"PRIu16,
4598                      flow->in_port.ofp_port);
4599     }
4600
4601     choose_miss_rule(port ? port->up.pp.config : 0, ofproto->miss_rule,
4602                      ofproto->no_packet_in_rule, rule);
4603 }
4604
4605 bool
4606 rule_dpif_lookup_in_table(struct ofproto_dpif *ofproto,
4607                           const struct flow *flow, struct flow_wildcards *wc,
4608                           uint8_t table_id, struct rule_dpif **rule)
4609 {
4610     const struct cls_rule *cls_rule;
4611     struct classifier *cls;
4612     bool frag;
4613
4614     *rule = NULL;
4615     if (table_id >= N_TABLES) {
4616         return false;
4617     }
4618
4619     if (wc) {
4620         memset(&wc->masks.dl_type, 0xff, sizeof wc->masks.dl_type);
4621         wc->masks.nw_frag |= FLOW_NW_FRAG_MASK;
4622     }
4623
4624     cls = &ofproto->up.tables[table_id].cls;
4625     ovs_rwlock_rdlock(&cls->rwlock);
4626     frag = (flow->nw_frag & FLOW_NW_FRAG_ANY) != 0;
4627     if (frag && ofproto->up.frag_handling == OFPC_FRAG_NORMAL) {
4628         /* We must pretend that transport ports are unavailable. */
4629         struct flow ofpc_normal_flow = *flow;
4630         ofpc_normal_flow.tp_src = htons(0);
4631         ofpc_normal_flow.tp_dst = htons(0);
4632         cls_rule = classifier_lookup(cls, &ofpc_normal_flow, wc);
4633     } else if (frag && ofproto->up.frag_handling == OFPC_FRAG_DROP) {
4634         cls_rule = &ofproto->drop_frags_rule->up.cr;
4635         if (wc) {
4636             flow_wildcards_init_exact(wc);
4637         }
4638     } else {
4639         cls_rule = classifier_lookup(cls, flow, wc);
4640     }
4641
4642     *rule = rule_dpif_cast(rule_from_cls_rule(cls_rule));
4643     rule_dpif_ref(*rule);
4644     ovs_rwlock_unlock(&cls->rwlock);
4645
4646     return *rule != NULL;
4647 }
4648
4649 /* Given a port configuration (specified as zero if there's no port), chooses
4650  * which of 'miss_rule' and 'no_packet_in_rule' should be used in case of a
4651  * flow table miss. */
4652 void
4653 choose_miss_rule(enum ofputil_port_config config, struct rule_dpif *miss_rule,
4654                  struct rule_dpif *no_packet_in_rule, struct rule_dpif **rule)
4655 {
4656     *rule = config & OFPUTIL_PC_NO_PACKET_IN ? no_packet_in_rule : miss_rule;
4657     rule_dpif_ref(*rule);
4658 }
4659
4660 void
4661 rule_dpif_ref(struct rule_dpif *rule)
4662 {
4663     if (rule) {
4664         ofproto_rule_ref(&rule->up);
4665     }
4666 }
4667
4668 void
4669 rule_dpif_unref(struct rule_dpif *rule)
4670 {
4671     if (rule) {
4672         ofproto_rule_unref(&rule->up);
4673     }
4674 }
4675
4676 static void
4677 complete_operation(struct rule_dpif *rule)
4678     OVS_REQUIRES(ofproto_mutex)
4679 {
4680     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
4681
4682     ofproto->backer->need_revalidate = REV_FLOW_TABLE;
4683     ofoperation_complete(rule->up.pending, 0);
4684 }
4685
4686 static struct rule_dpif *rule_dpif_cast(const struct rule *rule)
4687 {
4688     return rule ? CONTAINER_OF(rule, struct rule_dpif, up) : NULL;
4689 }
4690
4691 static struct rule *
4692 rule_alloc(void)
4693 {
4694     struct rule_dpif *rule = xmalloc(sizeof *rule);
4695     return &rule->up;
4696 }
4697
4698 static void
4699 rule_dealloc(struct rule *rule_)
4700 {
4701     struct rule_dpif *rule = rule_dpif_cast(rule_);
4702     free(rule);
4703 }
4704
4705 static enum ofperr
4706 rule_construct(struct rule *rule_)
4707 {
4708     struct rule_dpif *rule = rule_dpif_cast(rule_);
4709     ovs_mutex_init(&rule->stats_mutex);
4710     ovs_mutex_lock(&rule->stats_mutex);
4711     rule->packet_count = 0;
4712     rule->byte_count = 0;
4713     ovs_mutex_unlock(&rule->stats_mutex);
4714     return 0;
4715 }
4716
4717 static void
4718 rule_insert(struct rule *rule_)
4719     OVS_REQUIRES(ofproto_mutex)
4720 {
4721     struct rule_dpif *rule = rule_dpif_cast(rule_);
4722     complete_operation(rule);
4723 }
4724
4725 static void
4726 rule_delete(struct rule *rule_)
4727     OVS_REQUIRES(ofproto_mutex)
4728 {
4729     struct rule_dpif *rule = rule_dpif_cast(rule_);
4730     complete_operation(rule);
4731 }
4732
4733 static void
4734 rule_destruct(struct rule *rule_)
4735 {
4736     struct rule_dpif *rule = rule_dpif_cast(rule_);
4737     ovs_mutex_destroy(&rule->stats_mutex);
4738 }
4739
4740 static void
4741 rule_get_stats(struct rule *rule_, uint64_t *packets, uint64_t *bytes)
4742 {
4743     struct rule_dpif *rule = rule_dpif_cast(rule_);
4744
4745     /* push_all_stats() can handle flow misses which, when using the learn
4746      * action, can cause rules to be added and deleted.  This can corrupt our
4747      * caller's datastructures which assume that rule_get_stats() doesn't have
4748      * an impact on the flow table. To be safe, we disable miss handling. */
4749     push_all_stats__(false);
4750
4751     /* Start from historical data for 'rule' itself that are no longer tracked
4752      * in facets.  This counts, for example, facets that have expired. */
4753     ovs_mutex_lock(&rule->stats_mutex);
4754     *packets = rule->packet_count;
4755     *bytes = rule->byte_count;
4756     ovs_mutex_unlock(&rule->stats_mutex);
4757 }
4758
4759 static void
4760 rule_dpif_execute(struct rule_dpif *rule, const struct flow *flow,
4761                   struct ofpbuf *packet)
4762 {
4763     execute_actions(rule->up.ofproto, flow, rule, NULL, 0, packet);
4764 }
4765
4766 static enum ofperr
4767 rule_execute(struct rule *rule, const struct flow *flow,
4768              struct ofpbuf *packet)
4769 {
4770     rule_dpif_execute(rule_dpif_cast(rule), flow, packet);
4771     ofpbuf_delete(packet);
4772     return 0;
4773 }
4774
4775 static void
4776 rule_modify_actions(struct rule *rule_, bool reset_counters)
4777     OVS_REQUIRES(ofproto_mutex)
4778 {
4779     struct rule_dpif *rule = rule_dpif_cast(rule_);
4780
4781     if (reset_counters) {
4782         ovs_mutex_lock(&rule->stats_mutex);
4783         rule->packet_count = 0;
4784         rule->byte_count = 0;
4785         ovs_mutex_unlock(&rule->stats_mutex);
4786     }
4787
4788     complete_operation(rule);
4789 }
4790 \f
4791 /* Sends 'packet' out 'ofport'.
4792  * May modify 'packet'.
4793  * Returns 0 if successful, otherwise a positive errno value. */
4794 int
4795 ofproto_dpif_send_packet(const struct ofport_dpif *ofport, struct ofpbuf *packet)
4796 {
4797     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
4798     int error;
4799
4800     error = xlate_send_packet(ofport, packet);
4801
4802     ovs_mutex_lock(&ofproto->stats_mutex);
4803     ofproto->stats.tx_packets++;
4804     ofproto->stats.tx_bytes += packet->size;
4805     ovs_mutex_unlock(&ofproto->stats_mutex);
4806     return error;
4807 }
4808
4809 /* Composes an ODP action for a "slow path" action for 'flow' within 'ofproto'.
4810  * The action will state 'slow' as the reason that the action is in the slow
4811  * path.  (This is purely informational: it allows a human viewing "ovs-dpctl
4812  * dump-flows" output to see why a flow is in the slow path.)
4813  *
4814  * The 'stub_size' bytes in 'stub' will be used to store the action.
4815  * 'stub_size' must be large enough for the action.
4816  *
4817  * The action and its size will be stored in '*actionsp' and '*actions_lenp',
4818  * respectively. */
4819 static void
4820 compose_slow_path(const struct ofproto_dpif *ofproto, const struct flow *flow,
4821                   enum slow_path_reason slow,
4822                   uint64_t *stub, size_t stub_size,
4823                   const struct nlattr **actionsp, size_t *actions_lenp)
4824 {
4825     union user_action_cookie cookie;
4826     struct ofpbuf buf;
4827
4828     cookie.type = USER_ACTION_COOKIE_SLOW_PATH;
4829     cookie.slow_path.unused = 0;
4830     cookie.slow_path.reason = slow;
4831
4832     ofpbuf_use_stack(&buf, stub, stub_size);
4833     if (slow & (SLOW_CFM | SLOW_BFD | SLOW_LACP | SLOW_STP)) {
4834         uint32_t pid = dpif_port_get_pid(ofproto->backer->dpif,
4835                                          ODPP_NONE);
4836         odp_put_userspace_action(pid, &cookie, sizeof cookie.slow_path, &buf);
4837     } else {
4838         odp_port_t odp_port;
4839         uint32_t pid;
4840
4841         odp_port = ofp_port_to_odp_port(ofproto, flow->in_port.ofp_port);
4842         pid = dpif_port_get_pid(ofproto->backer->dpif, odp_port);
4843         odp_put_userspace_action(pid, &cookie, sizeof cookie.slow_path, &buf);
4844     }
4845     *actionsp = buf.data;
4846     *actions_lenp = buf.size;
4847 }
4848 \f
4849 static bool
4850 set_frag_handling(struct ofproto *ofproto_,
4851                   enum ofp_config_flags frag_handling)
4852 {
4853     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
4854     if (frag_handling != OFPC_FRAG_REASM) {
4855         ofproto->backer->need_revalidate = REV_RECONFIGURE;
4856         return true;
4857     } else {
4858         return false;
4859     }
4860 }
4861
4862 static enum ofperr
4863 packet_out(struct ofproto *ofproto, struct ofpbuf *packet,
4864            const struct flow *flow,
4865            const struct ofpact *ofpacts, size_t ofpacts_len)
4866 {
4867     execute_actions(ofproto, flow, NULL, ofpacts, ofpacts_len, packet);
4868     return 0;
4869 }
4870 \f
4871 /* NetFlow. */
4872
4873 static int
4874 set_netflow(struct ofproto *ofproto_,
4875             const struct netflow_options *netflow_options)
4876 {
4877     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
4878
4879     if (netflow_options) {
4880         if (!ofproto->netflow) {
4881             ofproto->netflow = netflow_create();
4882             ofproto->backer->need_revalidate = REV_RECONFIGURE;
4883         }
4884         return netflow_set_options(ofproto->netflow, netflow_options);
4885     } else if (ofproto->netflow) {
4886         ofproto->backer->need_revalidate = REV_RECONFIGURE;
4887         netflow_destroy(ofproto->netflow);
4888         ofproto->netflow = NULL;
4889     }
4890
4891     return 0;
4892 }
4893
4894 static void
4895 get_netflow_ids(const struct ofproto *ofproto_,
4896                 uint8_t *engine_type, uint8_t *engine_id)
4897 {
4898     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
4899
4900     dpif_get_netflow_ids(ofproto->backer->dpif, engine_type, engine_id);
4901 }
4902
4903 static void
4904 send_active_timeout(struct ofproto_dpif *ofproto, struct facet *facet)
4905 {
4906     if (!facet_is_controller_flow(facet) &&
4907         netflow_active_timeout_expired(ofproto->netflow, &facet->nf_flow)) {
4908         struct subfacet *subfacet;
4909         struct ofexpired expired;
4910
4911         LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
4912             if (subfacet->path == SF_FAST_PATH) {
4913                 struct dpif_flow_stats stats;
4914
4915                 subfacet_install(subfacet, &facet->xout.odp_actions,
4916                                  &stats);
4917                 subfacet_update_stats(subfacet, &stats);
4918             }
4919         }
4920
4921         expired.flow = facet->flow;
4922         expired.packet_count = facet->packet_count;
4923         expired.byte_count = facet->byte_count;
4924         expired.used = facet->used;
4925         netflow_expire(ofproto->netflow, &facet->nf_flow, &expired);
4926     }
4927 }
4928
4929 static void
4930 send_netflow_active_timeouts(struct ofproto_dpif *ofproto)
4931 {
4932     struct cls_cursor cursor;
4933     struct facet *facet;
4934
4935     ovs_rwlock_rdlock(&ofproto->facets.rwlock);
4936     cls_cursor_init(&cursor, &ofproto->facets, NULL);
4937     CLS_CURSOR_FOR_EACH (facet, cr, &cursor) {
4938         send_active_timeout(ofproto, facet);
4939     }
4940     ovs_rwlock_unlock(&ofproto->facets.rwlock);
4941 }
4942 \f
4943 static struct ofproto_dpif *
4944 ofproto_dpif_lookup(const char *name)
4945 {
4946     struct ofproto_dpif *ofproto;
4947
4948     HMAP_FOR_EACH_WITH_HASH (ofproto, all_ofproto_dpifs_node,
4949                              hash_string(name, 0), &all_ofproto_dpifs) {
4950         if (!strcmp(ofproto->up.name, name)) {
4951             return ofproto;
4952         }
4953     }
4954     return NULL;
4955 }
4956
4957 static void
4958 ofproto_unixctl_fdb_flush(struct unixctl_conn *conn, int argc,
4959                           const char *argv[], void *aux OVS_UNUSED)
4960 {
4961     struct ofproto_dpif *ofproto;
4962
4963     if (argc > 1) {
4964         ofproto = ofproto_dpif_lookup(argv[1]);
4965         if (!ofproto) {
4966             unixctl_command_reply_error(conn, "no such bridge");
4967             return;
4968         }
4969         ovs_rwlock_wrlock(&ofproto->ml->rwlock);
4970         mac_learning_flush(ofproto->ml);
4971         ovs_rwlock_unlock(&ofproto->ml->rwlock);
4972     } else {
4973         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
4974             ovs_rwlock_wrlock(&ofproto->ml->rwlock);
4975             mac_learning_flush(ofproto->ml);
4976             ovs_rwlock_unlock(&ofproto->ml->rwlock);
4977         }
4978     }
4979
4980     unixctl_command_reply(conn, "table successfully flushed");
4981 }
4982
4983 static struct ofport_dpif *
4984 ofbundle_get_a_port(const struct ofbundle *bundle)
4985 {
4986     return CONTAINER_OF(list_front(&bundle->ports), struct ofport_dpif,
4987                         bundle_node);
4988 }
4989
4990 static void
4991 ofproto_unixctl_fdb_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
4992                          const char *argv[], void *aux OVS_UNUSED)
4993 {
4994     struct ds ds = DS_EMPTY_INITIALIZER;
4995     const struct ofproto_dpif *ofproto;
4996     const struct mac_entry *e;
4997
4998     ofproto = ofproto_dpif_lookup(argv[1]);
4999     if (!ofproto) {
5000         unixctl_command_reply_error(conn, "no such bridge");
5001         return;
5002     }
5003
5004     ds_put_cstr(&ds, " port  VLAN  MAC                Age\n");
5005     ovs_rwlock_rdlock(&ofproto->ml->rwlock);
5006     LIST_FOR_EACH (e, lru_node, &ofproto->ml->lrus) {
5007         struct ofbundle *bundle = e->port.p;
5008         char name[OFP_MAX_PORT_NAME_LEN];
5009
5010         ofputil_port_to_string(ofbundle_get_a_port(bundle)->up.ofp_port,
5011                                name, sizeof name);
5012         ds_put_format(&ds, "%5s  %4d  "ETH_ADDR_FMT"  %3d\n",
5013                       name, e->vlan, ETH_ADDR_ARGS(e->mac),
5014                       mac_entry_age(ofproto->ml, e));
5015     }
5016     ovs_rwlock_unlock(&ofproto->ml->rwlock);
5017     unixctl_command_reply(conn, ds_cstr(&ds));
5018     ds_destroy(&ds);
5019 }
5020
5021 struct trace_ctx {
5022     struct xlate_out xout;
5023     struct xlate_in xin;
5024     struct flow flow;
5025     struct ds *result;
5026 };
5027
5028 static void
5029 trace_format_rule(struct ds *result, int level, const struct rule_dpif *rule)
5030 {
5031     struct rule_actions *actions;
5032     ovs_be64 cookie;
5033
5034     ds_put_char_multiple(result, '\t', level);
5035     if (!rule) {
5036         ds_put_cstr(result, "No match\n");
5037         return;
5038     }
5039
5040     ovs_mutex_lock(&rule->up.mutex);
5041     cookie = rule->up.flow_cookie;
5042     ovs_mutex_unlock(&rule->up.mutex);
5043
5044     ds_put_format(result, "Rule: table=%"PRIu8" cookie=%#"PRIx64" ",
5045                   rule ? rule->up.table_id : 0, ntohll(cookie));
5046     cls_rule_format(&rule->up.cr, result);
5047     ds_put_char(result, '\n');
5048
5049     actions = rule_dpif_get_actions(rule);
5050
5051     ds_put_char_multiple(result, '\t', level);
5052     ds_put_cstr(result, "OpenFlow ");
5053     ofpacts_format(actions->ofpacts, actions->ofpacts_len, result);
5054     ds_put_char(result, '\n');
5055
5056     rule_actions_unref(actions);
5057 }
5058
5059 static void
5060 trace_format_flow(struct ds *result, int level, const char *title,
5061                   struct trace_ctx *trace)
5062 {
5063     ds_put_char_multiple(result, '\t', level);
5064     ds_put_format(result, "%s: ", title);
5065     if (flow_equal(&trace->xin.flow, &trace->flow)) {
5066         ds_put_cstr(result, "unchanged");
5067     } else {
5068         flow_format(result, &trace->xin.flow);
5069         trace->flow = trace->xin.flow;
5070     }
5071     ds_put_char(result, '\n');
5072 }
5073
5074 static void
5075 trace_format_regs(struct ds *result, int level, const char *title,
5076                   struct trace_ctx *trace)
5077 {
5078     size_t i;
5079
5080     ds_put_char_multiple(result, '\t', level);
5081     ds_put_format(result, "%s:", title);
5082     for (i = 0; i < FLOW_N_REGS; i++) {
5083         ds_put_format(result, " reg%zu=0x%"PRIx32, i, trace->flow.regs[i]);
5084     }
5085     ds_put_char(result, '\n');
5086 }
5087
5088 static void
5089 trace_format_odp(struct ds *result, int level, const char *title,
5090                  struct trace_ctx *trace)
5091 {
5092     struct ofpbuf *odp_actions = &trace->xout.odp_actions;
5093
5094     ds_put_char_multiple(result, '\t', level);
5095     ds_put_format(result, "%s: ", title);
5096     format_odp_actions(result, odp_actions->data, odp_actions->size);
5097     ds_put_char(result, '\n');
5098 }
5099
5100 static void
5101 trace_resubmit(struct xlate_in *xin, struct rule_dpif *rule, int recurse)
5102 {
5103     struct trace_ctx *trace = CONTAINER_OF(xin, struct trace_ctx, xin);
5104     struct ds *result = trace->result;
5105
5106     ds_put_char(result, '\n');
5107     trace_format_flow(result, recurse + 1, "Resubmitted flow", trace);
5108     trace_format_regs(result, recurse + 1, "Resubmitted regs", trace);
5109     trace_format_odp(result,  recurse + 1, "Resubmitted  odp", trace);
5110     trace_format_rule(result, recurse + 1, rule);
5111 }
5112
5113 static void
5114 trace_report(struct xlate_in *xin, const char *s, int recurse)
5115 {
5116     struct trace_ctx *trace = CONTAINER_OF(xin, struct trace_ctx, xin);
5117     struct ds *result = trace->result;
5118
5119     ds_put_char_multiple(result, '\t', recurse);
5120     ds_put_cstr(result, s);
5121     ds_put_char(result, '\n');
5122 }
5123
5124 static void
5125 ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[],
5126                       void *aux OVS_UNUSED)
5127 {
5128     const struct dpif_backer *backer = NULL;
5129     struct ofproto_dpif *ofproto;
5130     struct ofpbuf odp_key, odp_mask;
5131     struct ofpbuf *packet;
5132     struct ds result;
5133     struct flow flow;
5134     struct simap port_names;
5135     char *s;
5136
5137     packet = NULL;
5138     backer = NULL;
5139     ds_init(&result);
5140     ofpbuf_init(&odp_key, 0);
5141     ofpbuf_init(&odp_mask, 0);
5142     simap_init(&port_names);
5143
5144     /* Handle "-generate" or a hex string as the last argument. */
5145     if (!strcmp(argv[argc - 1], "-generate")) {
5146         packet = ofpbuf_new(0);
5147         argc--;
5148     } else {
5149         const char *error = eth_from_hex(argv[argc - 1], &packet);
5150         if (!error) {
5151             argc--;
5152         } else if (argc == 4) {
5153             /* The 3-argument form must end in "-generate' or a hex string. */
5154             unixctl_command_reply_error(conn, error);
5155             goto exit;
5156         }
5157     }
5158
5159     /* odp_flow can have its in_port specified as a name instead of port no.
5160      * We do not yet know whether a given flow is a odp_flow or a br_flow.
5161      * But, to know whether a flow is odp_flow through odp_flow_from_string(),
5162      * we need to create a simap of name to port no. */
5163     if (argc == 3) {
5164         const char *dp_type;
5165         if (!strncmp(argv[1], "ovs-", 4)) {
5166             dp_type = argv[1] + 4;
5167         } else {
5168             dp_type = argv[1];
5169         }
5170         backer = shash_find_data(&all_dpif_backers, dp_type);
5171     } else {
5172         struct shash_node *node;
5173         if (shash_count(&all_dpif_backers) == 1) {
5174             node = shash_first(&all_dpif_backers);
5175             backer = node->data;
5176         }
5177     }
5178     if (backer && backer->dpif) {
5179         struct dpif_port dpif_port;
5180         struct dpif_port_dump port_dump;
5181         DPIF_PORT_FOR_EACH (&dpif_port, &port_dump, backer->dpif) {
5182             simap_put(&port_names, dpif_port.name,
5183                       odp_to_u32(dpif_port.port_no));
5184         }
5185     }
5186
5187     /* Parse the flow and determine whether a datapath or
5188      * bridge is specified. If function odp_flow_key_from_string()
5189      * returns 0, the flow is a odp_flow. If function
5190      * parse_ofp_exact_flow() returns 0, the flow is a br_flow. */
5191     if (!odp_flow_from_string(argv[argc - 1], &port_names, &odp_key, &odp_mask)) {
5192         if (!backer) {
5193             unixctl_command_reply_error(conn, "Cannot find the datapath");
5194             goto exit;
5195         }
5196
5197         if (xlate_receive(backer, NULL, odp_key.data, odp_key.size, &flow,
5198                           NULL, &ofproto, NULL)) {
5199             unixctl_command_reply_error(conn, "Invalid datapath flow");
5200             goto exit;
5201         }
5202         ds_put_format(&result, "Bridge: %s\n", ofproto->up.name);
5203     } else if (!parse_ofp_exact_flow(&flow, argv[argc - 1])) {
5204         if (argc != 3) {
5205             unixctl_command_reply_error(conn, "Must specify bridge name");
5206             goto exit;
5207         }
5208
5209         ofproto = ofproto_dpif_lookup(argv[1]);
5210         if (!ofproto) {
5211             unixctl_command_reply_error(conn, "Unknown bridge name");
5212             goto exit;
5213         }
5214     } else {
5215         unixctl_command_reply_error(conn, "Bad flow syntax");
5216         goto exit;
5217     }
5218
5219     /* Generate a packet, if requested. */
5220     if (packet) {
5221         if (!packet->size) {
5222             flow_compose(packet, &flow);
5223         } else {
5224             union flow_in_port in_port_;
5225
5226             in_port_ = flow.in_port;
5227             ds_put_cstr(&result, "Packet: ");
5228             s = ofp_packet_to_string(packet->data, packet->size);
5229             ds_put_cstr(&result, s);
5230             free(s);
5231
5232             /* Use the metadata from the flow and the packet argument
5233              * to reconstruct the flow. */
5234             flow_extract(packet, flow.skb_priority, flow.pkt_mark, NULL,
5235                          &in_port_, &flow);
5236         }
5237     }
5238
5239     ofproto_trace(ofproto, &flow, packet, &result);
5240     unixctl_command_reply(conn, ds_cstr(&result));
5241
5242 exit:
5243     ds_destroy(&result);
5244     ofpbuf_delete(packet);
5245     ofpbuf_uninit(&odp_key);
5246     ofpbuf_uninit(&odp_mask);
5247     simap_destroy(&port_names);
5248 }
5249
5250 static void
5251 ofproto_trace(struct ofproto_dpif *ofproto, const struct flow *flow,
5252               const struct ofpbuf *packet, struct ds *ds)
5253 {
5254     struct rule_dpif *rule;
5255     struct flow_wildcards wc;
5256
5257     ds_put_cstr(ds, "Flow: ");
5258     flow_format(ds, flow);
5259     ds_put_char(ds, '\n');
5260
5261     flow_wildcards_init_catchall(&wc);
5262     rule_dpif_lookup(ofproto, flow, &wc, &rule);
5263
5264     trace_format_rule(ds, 0, rule);
5265     if (rule == ofproto->miss_rule) {
5266         ds_put_cstr(ds, "\nNo match, flow generates \"packet in\"s.\n");
5267     } else if (rule == ofproto->no_packet_in_rule) {
5268         ds_put_cstr(ds, "\nNo match, packets dropped because "
5269                     "OFPPC_NO_PACKET_IN is set on in_port.\n");
5270     } else if (rule == ofproto->drop_frags_rule) {
5271         ds_put_cstr(ds, "\nPackets dropped because they are IP fragments "
5272                     "and the fragment handling mode is \"drop\".\n");
5273     }
5274
5275     if (rule) {
5276         uint64_t odp_actions_stub[1024 / 8];
5277         struct ofpbuf odp_actions;
5278         struct trace_ctx trace;
5279         struct match match;
5280         uint8_t tcp_flags;
5281
5282         tcp_flags = packet ? packet_get_tcp_flags(packet, flow) : 0;
5283         trace.result = ds;
5284         trace.flow = *flow;
5285         ofpbuf_use_stub(&odp_actions,
5286                         odp_actions_stub, sizeof odp_actions_stub);
5287         xlate_in_init(&trace.xin, ofproto, flow, rule, tcp_flags, packet);
5288         trace.xin.resubmit_hook = trace_resubmit;
5289         trace.xin.report_hook = trace_report;
5290
5291         xlate_actions(&trace.xin, &trace.xout);
5292         flow_wildcards_or(&trace.xout.wc, &trace.xout.wc, &wc);
5293
5294         ds_put_char(ds, '\n');
5295         trace_format_flow(ds, 0, "Final flow", &trace);
5296
5297         match_init(&match, flow, &trace.xout.wc);
5298         ds_put_cstr(ds, "Relevant fields: ");
5299         match_format(&match, ds, OFP_DEFAULT_PRIORITY);
5300         ds_put_char(ds, '\n');
5301
5302         ds_put_cstr(ds, "Datapath actions: ");
5303         format_odp_actions(ds, trace.xout.odp_actions.data,
5304                            trace.xout.odp_actions.size);
5305
5306         if (trace.xout.slow) {
5307             ds_put_cstr(ds, "\nThis flow is handled by the userspace "
5308                         "slow path because it:");
5309             switch (trace.xout.slow) {
5310             case SLOW_CFM:
5311                 ds_put_cstr(ds, "\n\t- Consists of CFM packets.");
5312                 break;
5313             case SLOW_LACP:
5314                 ds_put_cstr(ds, "\n\t- Consists of LACP packets.");
5315                 break;
5316             case SLOW_STP:
5317                 ds_put_cstr(ds, "\n\t- Consists of STP packets.");
5318                 break;
5319             case SLOW_BFD:
5320                 ds_put_cstr(ds, "\n\t- Consists of BFD packets.");
5321                 break;
5322             case SLOW_CONTROLLER:
5323                 ds_put_cstr(ds, "\n\t- Sends \"packet-in\" messages "
5324                             "to the OpenFlow controller.");
5325                 break;
5326             case __SLOW_MAX:
5327                 NOT_REACHED();
5328             }
5329         }
5330
5331         xlate_out_uninit(&trace.xout);
5332     }
5333
5334     rule_dpif_unref(rule);
5335 }
5336
5337 /* Runs a self-check of flow translations in 'ofproto'.  Appends a message to
5338  * 'reply' describing the results. */
5339 static void
5340 ofproto_dpif_self_check__(struct ofproto_dpif *ofproto, struct ds *reply)
5341 {
5342     struct cls_cursor cursor;
5343     struct facet *facet;
5344     int errors;
5345
5346     errors = 0;
5347     ovs_rwlock_rdlock(&ofproto->facets.rwlock);
5348     cls_cursor_init(&cursor, &ofproto->facets, NULL);
5349     CLS_CURSOR_FOR_EACH (facet, cr, &cursor) {
5350         if (!facet_check_consistency(facet)) {
5351             errors++;
5352         }
5353     }
5354     ovs_rwlock_unlock(&ofproto->facets.rwlock);
5355     if (errors) {
5356         ofproto->backer->need_revalidate = REV_INCONSISTENCY;
5357     }
5358
5359     if (errors) {
5360         ds_put_format(reply, "%s: self-check failed (%d errors)\n",
5361                       ofproto->up.name, errors);
5362     } else {
5363         ds_put_format(reply, "%s: self-check passed\n", ofproto->up.name);
5364     }
5365 }
5366
5367 static void
5368 ofproto_dpif_self_check(struct unixctl_conn *conn,
5369                         int argc, const char *argv[], void *aux OVS_UNUSED)
5370 {
5371     struct ds reply = DS_EMPTY_INITIALIZER;
5372     struct ofproto_dpif *ofproto;
5373
5374     if (argc > 1) {
5375         ofproto = ofproto_dpif_lookup(argv[1]);
5376         if (!ofproto) {
5377             unixctl_command_reply_error(conn, "Unknown ofproto (use "
5378                                         "ofproto/list for help)");
5379             return;
5380         }
5381         ofproto_dpif_self_check__(ofproto, &reply);
5382     } else {
5383         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
5384             ofproto_dpif_self_check__(ofproto, &reply);
5385         }
5386     }
5387
5388     unixctl_command_reply(conn, ds_cstr(&reply));
5389     ds_destroy(&reply);
5390 }
5391
5392 /* Store the current ofprotos in 'ofproto_shash'.  Returns a sorted list
5393  * of the 'ofproto_shash' nodes.  It is the responsibility of the caller
5394  * to destroy 'ofproto_shash' and free the returned value. */
5395 static const struct shash_node **
5396 get_ofprotos(struct shash *ofproto_shash)
5397 {
5398     const struct ofproto_dpif *ofproto;
5399
5400     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
5401         char *name = xasprintf("%s@%s", ofproto->up.type, ofproto->up.name);
5402         shash_add_nocopy(ofproto_shash, name, ofproto);
5403     }
5404
5405     return shash_sort(ofproto_shash);
5406 }
5407
5408 static void
5409 ofproto_unixctl_dpif_dump_dps(struct unixctl_conn *conn, int argc OVS_UNUSED,
5410                               const char *argv[] OVS_UNUSED,
5411                               void *aux OVS_UNUSED)
5412 {
5413     struct ds ds = DS_EMPTY_INITIALIZER;
5414     struct shash ofproto_shash;
5415     const struct shash_node **sorted_ofprotos;
5416     int i;
5417
5418     shash_init(&ofproto_shash);
5419     sorted_ofprotos = get_ofprotos(&ofproto_shash);
5420     for (i = 0; i < shash_count(&ofproto_shash); i++) {
5421         const struct shash_node *node = sorted_ofprotos[i];
5422         ds_put_format(&ds, "%s\n", node->name);
5423     }
5424
5425     shash_destroy(&ofproto_shash);
5426     free(sorted_ofprotos);
5427
5428     unixctl_command_reply(conn, ds_cstr(&ds));
5429     ds_destroy(&ds);
5430 }
5431
5432 static void
5433 dpif_show_backer(const struct dpif_backer *backer, struct ds *ds)
5434 {
5435     const struct shash_node **ofprotos;
5436     struct ofproto_dpif *ofproto;
5437     struct shash ofproto_shash;
5438     uint64_t n_hit, n_missed;
5439     size_t i;
5440
5441     n_hit = n_missed = 0;
5442     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
5443         if (ofproto->backer == backer) {
5444             n_missed += ofproto->n_missed;
5445             n_hit += ofproto->n_hit;
5446         }
5447     }
5448
5449     ds_put_format(ds, "%s: hit:%"PRIu64" missed:%"PRIu64"\n",
5450                   dpif_name(backer->dpif), n_hit, n_missed);
5451     ds_put_format(ds, "\tflows: cur: %zu, avg: %u, max: %u,"
5452                   " life span: %lldms\n", hmap_count(&backer->subfacets),
5453                   backer->avg_n_subfacet, backer->max_n_subfacet,
5454                   backer->avg_subfacet_life);
5455
5456     shash_init(&ofproto_shash);
5457     ofprotos = get_ofprotos(&ofproto_shash);
5458     for (i = 0; i < shash_count(&ofproto_shash); i++) {
5459         struct ofproto_dpif *ofproto = ofprotos[i]->data;
5460         const struct shash_node **ports;
5461         size_t j;
5462
5463         if (ofproto->backer != backer) {
5464             continue;
5465         }
5466
5467         ds_put_format(ds, "\t%s: hit:%"PRIu64" missed:%"PRIu64"\n",
5468                       ofproto->up.name, ofproto->n_hit, ofproto->n_missed);
5469
5470         ports = shash_sort(&ofproto->up.port_by_name);
5471         for (j = 0; j < shash_count(&ofproto->up.port_by_name); j++) {
5472             const struct shash_node *node = ports[j];
5473             struct ofport *ofport = node->data;
5474             struct smap config;
5475             odp_port_t odp_port;
5476
5477             ds_put_format(ds, "\t\t%s %u/", netdev_get_name(ofport->netdev),
5478                           ofport->ofp_port);
5479
5480             odp_port = ofp_port_to_odp_port(ofproto, ofport->ofp_port);
5481             if (odp_port != ODPP_NONE) {
5482                 ds_put_format(ds, "%"PRIu32":", odp_port);
5483             } else {
5484                 ds_put_cstr(ds, "none:");
5485             }
5486
5487             ds_put_format(ds, " (%s", netdev_get_type(ofport->netdev));
5488
5489             smap_init(&config);
5490             if (!netdev_get_config(ofport->netdev, &config)) {
5491                 const struct smap_node **nodes;
5492                 size_t i;
5493
5494                 nodes = smap_sort(&config);
5495                 for (i = 0; i < smap_count(&config); i++) {
5496                     const struct smap_node *node = nodes[i];
5497                     ds_put_format(ds, "%c %s=%s", i ? ',' : ':',
5498                                   node->key, node->value);
5499                 }
5500                 free(nodes);
5501             }
5502             smap_destroy(&config);
5503
5504             ds_put_char(ds, ')');
5505             ds_put_char(ds, '\n');
5506         }
5507         free(ports);
5508     }
5509     shash_destroy(&ofproto_shash);
5510     free(ofprotos);
5511 }
5512
5513 static void
5514 ofproto_unixctl_dpif_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
5515                           const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
5516 {
5517     struct ds ds = DS_EMPTY_INITIALIZER;
5518     const struct shash_node **backers;
5519     int i;
5520
5521     backers = shash_sort(&all_dpif_backers);
5522     for (i = 0; i < shash_count(&all_dpif_backers); i++) {
5523         dpif_show_backer(backers[i]->data, &ds);
5524     }
5525     free(backers);
5526
5527     unixctl_command_reply(conn, ds_cstr(&ds));
5528     ds_destroy(&ds);
5529 }
5530
5531 /* Dump the megaflow (facet) cache.  This is useful to check the
5532  * correctness of flow wildcarding, since the same mechanism is used for
5533  * both xlate caching and kernel wildcarding.
5534  *
5535  * It's important to note that in the output the flow description uses
5536  * OpenFlow (OFP) ports, but the actions use datapath (ODP) ports.
5537  *
5538  * This command is only needed for advanced debugging, so it's not
5539  * documented in the man page. */
5540 static void
5541 ofproto_unixctl_dpif_dump_megaflows(struct unixctl_conn *conn,
5542                                     int argc OVS_UNUSED, const char *argv[],
5543                                     void *aux OVS_UNUSED)
5544 {
5545     struct ds ds = DS_EMPTY_INITIALIZER;
5546     const struct ofproto_dpif *ofproto;
5547     long long int now = time_msec();
5548     struct cls_cursor cursor;
5549     struct facet *facet;
5550
5551     ofproto = ofproto_dpif_lookup(argv[1]);
5552     if (!ofproto) {
5553         unixctl_command_reply_error(conn, "no such bridge");
5554         return;
5555     }
5556
5557     ovs_rwlock_rdlock(&ofproto->facets.rwlock);
5558     cls_cursor_init(&cursor, &ofproto->facets, NULL);
5559     CLS_CURSOR_FOR_EACH (facet, cr, &cursor) {
5560         cls_rule_format(&facet->cr, &ds);
5561         ds_put_cstr(&ds, ", ");
5562         ds_put_format(&ds, "n_subfacets:%zu, ", list_size(&facet->subfacets));
5563         ds_put_format(&ds, "used:%.3fs, ", (now - facet->used) / 1000.0);
5564         ds_put_cstr(&ds, "Datapath actions: ");
5565         if (facet->xout.slow) {
5566             uint64_t slow_path_stub[128 / 8];
5567             const struct nlattr *actions;
5568             size_t actions_len;
5569
5570             compose_slow_path(ofproto, &facet->flow, facet->xout.slow,
5571                               slow_path_stub, sizeof slow_path_stub,
5572                               &actions, &actions_len);
5573             format_odp_actions(&ds, actions, actions_len);
5574         } else {
5575             format_odp_actions(&ds, facet->xout.odp_actions.data,
5576                                facet->xout.odp_actions.size);
5577         }
5578         ds_put_cstr(&ds, "\n");
5579     }
5580     ovs_rwlock_unlock(&ofproto->facets.rwlock);
5581
5582     ds_chomp(&ds, '\n');
5583     unixctl_command_reply(conn, ds_cstr(&ds));
5584     ds_destroy(&ds);
5585 }
5586
5587 /* Disable using the megaflows.
5588  *
5589  * This command is only needed for advanced debugging, so it's not
5590  * documented in the man page. */
5591 static void
5592 ofproto_unixctl_dpif_disable_megaflows(struct unixctl_conn *conn,
5593                                        int argc OVS_UNUSED,
5594                                        const char *argv[] OVS_UNUSED,
5595                                        void *aux OVS_UNUSED)
5596 {
5597     struct ofproto_dpif *ofproto;
5598
5599     enable_megaflows = false;
5600
5601     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
5602         flush(&ofproto->up);
5603     }
5604
5605     unixctl_command_reply(conn, "megaflows disabled");
5606 }
5607
5608 /* Re-enable using megaflows.
5609  *
5610  * This command is only needed for advanced debugging, so it's not
5611  * documented in the man page. */
5612 static void
5613 ofproto_unixctl_dpif_enable_megaflows(struct unixctl_conn *conn,
5614                                       int argc OVS_UNUSED,
5615                                       const char *argv[] OVS_UNUSED,
5616                                       void *aux OVS_UNUSED)
5617 {
5618     struct ofproto_dpif *ofproto;
5619
5620     enable_megaflows = true;
5621
5622     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
5623         flush(&ofproto->up);
5624     }
5625
5626     unixctl_command_reply(conn, "megaflows enabled");
5627 }
5628
5629 static void
5630 ofproto_unixctl_dpif_dump_flows(struct unixctl_conn *conn,
5631                                 int argc OVS_UNUSED, const char *argv[],
5632                                 void *aux OVS_UNUSED)
5633 {
5634     struct ds ds = DS_EMPTY_INITIALIZER;
5635     const struct ofproto_dpif *ofproto;
5636     struct subfacet *subfacet;
5637
5638     ofproto = ofproto_dpif_lookup(argv[1]);
5639     if (!ofproto) {
5640         unixctl_command_reply_error(conn, "no such bridge");
5641         return;
5642     }
5643
5644     update_stats(ofproto->backer);
5645
5646     HMAP_FOR_EACH (subfacet, hmap_node, &ofproto->backer->subfacets) {
5647         struct facet *facet = subfacet->facet;
5648         struct odputil_keybuf maskbuf;
5649         struct ofpbuf mask;
5650
5651         if (facet->ofproto != ofproto) {
5652             continue;
5653         }
5654
5655         ofpbuf_use_stack(&mask, &maskbuf, sizeof maskbuf);
5656         if (enable_megaflows) {
5657             odp_flow_key_from_mask(&mask, &facet->xout.wc.masks,
5658                                    &facet->flow, UINT32_MAX);
5659         }
5660
5661         odp_flow_format(subfacet->key, subfacet->key_len,
5662                         mask.data, mask.size, NULL, &ds, false);
5663
5664         ds_put_format(&ds, ", packets:%"PRIu64", bytes:%"PRIu64", used:",
5665                       subfacet->dp_packet_count, subfacet->dp_byte_count);
5666         if (subfacet->used) {
5667             ds_put_format(&ds, "%.3fs",
5668                           (time_msec() - subfacet->used) / 1000.0);
5669         } else {
5670             ds_put_format(&ds, "never");
5671         }
5672         if (subfacet->facet->tcp_flags) {
5673             ds_put_cstr(&ds, ", flags:");
5674             packet_format_tcp_flags(&ds, subfacet->facet->tcp_flags);
5675         }
5676
5677         ds_put_cstr(&ds, ", actions:");
5678         if (facet->xout.slow) {
5679             uint64_t slow_path_stub[128 / 8];
5680             const struct nlattr *actions;
5681             size_t actions_len;
5682
5683             compose_slow_path(ofproto, &facet->flow, facet->xout.slow,
5684                               slow_path_stub, sizeof slow_path_stub,
5685                               &actions, &actions_len);
5686             format_odp_actions(&ds, actions, actions_len);
5687         } else {
5688             format_odp_actions(&ds, facet->xout.odp_actions.data,
5689                                facet->xout.odp_actions.size);
5690         }
5691         ds_put_char(&ds, '\n');
5692     }
5693
5694     unixctl_command_reply(conn, ds_cstr(&ds));
5695     ds_destroy(&ds);
5696 }
5697
5698 static void
5699 ofproto_unixctl_dpif_del_flows(struct unixctl_conn *conn,
5700                                int argc OVS_UNUSED, const char *argv[],
5701                                void *aux OVS_UNUSED)
5702 {
5703     struct ds ds = DS_EMPTY_INITIALIZER;
5704     struct ofproto_dpif *ofproto;
5705
5706     ofproto = ofproto_dpif_lookup(argv[1]);
5707     if (!ofproto) {
5708         unixctl_command_reply_error(conn, "no such bridge");
5709         return;
5710     }
5711
5712     flush(&ofproto->up);
5713
5714     unixctl_command_reply(conn, ds_cstr(&ds));
5715     ds_destroy(&ds);
5716 }
5717
5718 static void
5719 ofproto_dpif_unixctl_init(void)
5720 {
5721     static bool registered;
5722     if (registered) {
5723         return;
5724     }
5725     registered = true;
5726
5727     unixctl_command_register(
5728         "ofproto/trace",
5729         "[dp_name]|bridge odp_flow|br_flow [-generate|packet]",
5730         1, 3, ofproto_unixctl_trace, NULL);
5731     unixctl_command_register("fdb/flush", "[bridge]", 0, 1,
5732                              ofproto_unixctl_fdb_flush, NULL);
5733     unixctl_command_register("fdb/show", "bridge", 1, 1,
5734                              ofproto_unixctl_fdb_show, NULL);
5735     unixctl_command_register("ofproto/self-check", "[bridge]", 0, 1,
5736                              ofproto_dpif_self_check, NULL);
5737     unixctl_command_register("dpif/dump-dps", "", 0, 0,
5738                              ofproto_unixctl_dpif_dump_dps, NULL);
5739     unixctl_command_register("dpif/show", "", 0, 0, ofproto_unixctl_dpif_show,
5740                              NULL);
5741     unixctl_command_register("dpif/dump-flows", "bridge", 1, 1,
5742                              ofproto_unixctl_dpif_dump_flows, NULL);
5743     unixctl_command_register("dpif/del-flows", "bridge", 1, 1,
5744                              ofproto_unixctl_dpif_del_flows, NULL);
5745     unixctl_command_register("dpif/dump-megaflows", "bridge", 1, 1,
5746                              ofproto_unixctl_dpif_dump_megaflows, NULL);
5747     unixctl_command_register("dpif/disable-megaflows", "", 0, 0,
5748                              ofproto_unixctl_dpif_disable_megaflows, NULL);
5749     unixctl_command_register("dpif/enable-megaflows", "", 0, 0,
5750                              ofproto_unixctl_dpif_enable_megaflows, NULL);
5751 }
5752 \f
5753 /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
5754  *
5755  * This is deprecated.  It is only for compatibility with broken device drivers
5756  * in old versions of Linux that do not properly support VLANs when VLAN
5757  * devices are not used.  When broken device drivers are no longer in
5758  * widespread use, we will delete these interfaces. */
5759
5760 static int
5761 set_realdev(struct ofport *ofport_, ofp_port_t realdev_ofp_port, int vid)
5762 {
5763     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport_->ofproto);
5764     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
5765
5766     if (realdev_ofp_port == ofport->realdev_ofp_port
5767         && vid == ofport->vlandev_vid) {
5768         return 0;
5769     }
5770
5771     ofproto->backer->need_revalidate = REV_RECONFIGURE;
5772
5773     if (ofport->realdev_ofp_port) {
5774         vsp_remove(ofport);
5775     }
5776     if (realdev_ofp_port && ofport->bundle) {
5777         /* vlandevs are enslaved to their realdevs, so they are not allowed to
5778          * themselves be part of a bundle. */
5779         bundle_set(ofport->up.ofproto, ofport->bundle, NULL);
5780     }
5781
5782     ofport->realdev_ofp_port = realdev_ofp_port;
5783     ofport->vlandev_vid = vid;
5784
5785     if (realdev_ofp_port) {
5786         vsp_add(ofport, realdev_ofp_port, vid);
5787     }
5788
5789     return 0;
5790 }
5791
5792 static uint32_t
5793 hash_realdev_vid(ofp_port_t realdev_ofp_port, int vid)
5794 {
5795     return hash_2words(ofp_to_u16(realdev_ofp_port), vid);
5796 }
5797
5798 bool
5799 ofproto_has_vlan_splinters(const struct ofproto_dpif *ofproto)
5800     OVS_EXCLUDED(ofproto->vsp_mutex)
5801 {
5802     bool ret;
5803
5804     ovs_mutex_lock(&ofproto->vsp_mutex);
5805     ret = !hmap_is_empty(&ofproto->realdev_vid_map);
5806     ovs_mutex_unlock(&ofproto->vsp_mutex);
5807     return ret;
5808 }
5809
5810 static ofp_port_t
5811 vsp_realdev_to_vlandev__(const struct ofproto_dpif *ofproto,
5812                          ofp_port_t realdev_ofp_port, ovs_be16 vlan_tci)
5813     OVS_REQUIRES(ofproto->vsp_mutex)
5814 {
5815     if (!hmap_is_empty(&ofproto->realdev_vid_map)) {
5816         int vid = vlan_tci_to_vid(vlan_tci);
5817         const struct vlan_splinter *vsp;
5818
5819         HMAP_FOR_EACH_WITH_HASH (vsp, realdev_vid_node,
5820                                  hash_realdev_vid(realdev_ofp_port, vid),
5821                                  &ofproto->realdev_vid_map) {
5822             if (vsp->realdev_ofp_port == realdev_ofp_port
5823                 && vsp->vid == vid) {
5824                 return vsp->vlandev_ofp_port;
5825             }
5826         }
5827     }
5828     return realdev_ofp_port;
5829 }
5830
5831 /* Returns the OFP port number of the Linux VLAN device that corresponds to
5832  * 'vlan_tci' on the network device with port number 'realdev_ofp_port' in
5833  * 'struct ofport_dpif'.  For example, given 'realdev_ofp_port' of eth0 and
5834  * 'vlan_tci' 9, it would return the port number of eth0.9.
5835  *
5836  * Unless VLAN splinters are enabled for port 'realdev_ofp_port', this
5837  * function just returns its 'realdev_ofp_port' argument. */
5838 ofp_port_t
5839 vsp_realdev_to_vlandev(const struct ofproto_dpif *ofproto,
5840                        ofp_port_t realdev_ofp_port, ovs_be16 vlan_tci)
5841     OVS_EXCLUDED(ofproto->vsp_mutex)
5842 {
5843     ofp_port_t ret;
5844
5845     ovs_mutex_lock(&ofproto->vsp_mutex);
5846     ret = vsp_realdev_to_vlandev__(ofproto, realdev_ofp_port, vlan_tci);
5847     ovs_mutex_unlock(&ofproto->vsp_mutex);
5848     return ret;
5849 }
5850
5851 static struct vlan_splinter *
5852 vlandev_find(const struct ofproto_dpif *ofproto, ofp_port_t vlandev_ofp_port)
5853 {
5854     struct vlan_splinter *vsp;
5855
5856     HMAP_FOR_EACH_WITH_HASH (vsp, vlandev_node,
5857                              hash_ofp_port(vlandev_ofp_port),
5858                              &ofproto->vlandev_map) {
5859         if (vsp->vlandev_ofp_port == vlandev_ofp_port) {
5860             return vsp;
5861         }
5862     }
5863
5864     return NULL;
5865 }
5866
5867 /* Returns the OpenFlow port number of the "real" device underlying the Linux
5868  * VLAN device with OpenFlow port number 'vlandev_ofp_port' and stores the
5869  * VLAN VID of the Linux VLAN device in '*vid'.  For example, given
5870  * 'vlandev_ofp_port' of eth0.9, it would return the OpenFlow port number of
5871  * eth0 and store 9 in '*vid'.
5872  *
5873  * Returns 0 and does not modify '*vid' if 'vlandev_ofp_port' is not a Linux
5874  * VLAN device.  Unless VLAN splinters are enabled, this is what this function
5875  * always does.*/
5876 static ofp_port_t
5877 vsp_vlandev_to_realdev(const struct ofproto_dpif *ofproto,
5878                        ofp_port_t vlandev_ofp_port, int *vid)
5879     OVS_REQUIRES(ofproto->vsp_mutex)
5880 {
5881     if (!hmap_is_empty(&ofproto->vlandev_map)) {
5882         const struct vlan_splinter *vsp;
5883
5884         vsp = vlandev_find(ofproto, vlandev_ofp_port);
5885         if (vsp) {
5886             if (vid) {
5887                 *vid = vsp->vid;
5888             }
5889             return vsp->realdev_ofp_port;
5890         }
5891     }
5892     return 0;
5893 }
5894
5895 /* Given 'flow', a flow representing a packet received on 'ofproto', checks
5896  * whether 'flow->in_port' represents a Linux VLAN device.  If so, changes
5897  * 'flow->in_port' to the "real" device backing the VLAN device, sets
5898  * 'flow->vlan_tci' to the VLAN VID, and returns true.  Otherwise (which is
5899  * always the case unless VLAN splinters are enabled), returns false without
5900  * making any changes. */
5901 bool
5902 vsp_adjust_flow(const struct ofproto_dpif *ofproto, struct flow *flow)
5903     OVS_EXCLUDED(ofproto->vsp_mutex)
5904 {
5905     ofp_port_t realdev;
5906     int vid;
5907
5908     ovs_mutex_lock(&ofproto->vsp_mutex);
5909     realdev = vsp_vlandev_to_realdev(ofproto, flow->in_port.ofp_port, &vid);
5910     ovs_mutex_unlock(&ofproto->vsp_mutex);
5911     if (!realdev) {
5912         return false;
5913     }
5914
5915     /* Cause the flow to be processed as if it came in on the real device with
5916      * the VLAN device's VLAN ID. */
5917     flow->in_port.ofp_port = realdev;
5918     flow->vlan_tci = htons((vid & VLAN_VID_MASK) | VLAN_CFI);
5919     return true;
5920 }
5921
5922 static void
5923 vsp_remove(struct ofport_dpif *port)
5924 {
5925     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
5926     struct vlan_splinter *vsp;
5927
5928     ovs_mutex_lock(&ofproto->vsp_mutex);
5929     vsp = vlandev_find(ofproto, port->up.ofp_port);
5930     if (vsp) {
5931         hmap_remove(&ofproto->vlandev_map, &vsp->vlandev_node);
5932         hmap_remove(&ofproto->realdev_vid_map, &vsp->realdev_vid_node);
5933         free(vsp);
5934
5935         port->realdev_ofp_port = 0;
5936     } else {
5937         VLOG_ERR("missing vlan device record");
5938     }
5939     ovs_mutex_unlock(&ofproto->vsp_mutex);
5940 }
5941
5942 static void
5943 vsp_add(struct ofport_dpif *port, ofp_port_t realdev_ofp_port, int vid)
5944 {
5945     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
5946
5947     ovs_mutex_lock(&ofproto->vsp_mutex);
5948     if (!vsp_vlandev_to_realdev(ofproto, port->up.ofp_port, NULL)
5949         && (vsp_realdev_to_vlandev__(ofproto, realdev_ofp_port, htons(vid))
5950             == realdev_ofp_port)) {
5951         struct vlan_splinter *vsp;
5952
5953         vsp = xmalloc(sizeof *vsp);
5954         vsp->realdev_ofp_port = realdev_ofp_port;
5955         vsp->vlandev_ofp_port = port->up.ofp_port;
5956         vsp->vid = vid;
5957
5958         port->realdev_ofp_port = realdev_ofp_port;
5959
5960         hmap_insert(&ofproto->vlandev_map, &vsp->vlandev_node,
5961                     hash_ofp_port(port->up.ofp_port));
5962         hmap_insert(&ofproto->realdev_vid_map, &vsp->realdev_vid_node,
5963                     hash_realdev_vid(realdev_ofp_port, vid));
5964     } else {
5965         VLOG_ERR("duplicate vlan device record");
5966     }
5967     ovs_mutex_unlock(&ofproto->vsp_mutex);
5968 }
5969
5970 static odp_port_t
5971 ofp_port_to_odp_port(const struct ofproto_dpif *ofproto, ofp_port_t ofp_port)
5972 {
5973     const struct ofport_dpif *ofport = get_ofp_port(ofproto, ofp_port);
5974     return ofport ? ofport->odp_port : ODPP_NONE;
5975 }
5976
5977 struct ofport_dpif *
5978 odp_port_to_ofport(const struct dpif_backer *backer, odp_port_t odp_port)
5979 {
5980     struct ofport_dpif *port;
5981
5982     ovs_rwlock_rdlock(&backer->odp_to_ofport_lock);
5983     HMAP_FOR_EACH_IN_BUCKET (port, odp_port_node, hash_odp_port(odp_port),
5984                              &backer->odp_to_ofport_map) {
5985         if (port->odp_port == odp_port) {
5986             ovs_rwlock_unlock(&backer->odp_to_ofport_lock);
5987             return port;
5988         }
5989     }
5990
5991     ovs_rwlock_unlock(&backer->odp_to_ofport_lock);
5992     return NULL;
5993 }
5994
5995 static ofp_port_t
5996 odp_port_to_ofp_port(const struct ofproto_dpif *ofproto, odp_port_t odp_port)
5997 {
5998     struct ofport_dpif *port;
5999
6000     port = odp_port_to_ofport(ofproto->backer, odp_port);
6001     if (port && &ofproto->up == port->up.ofproto) {
6002         return port->up.ofp_port;
6003     } else {
6004         return OFPP_NONE;
6005     }
6006 }
6007
6008 const struct ofproto_class ofproto_dpif_class = {
6009     init,
6010     enumerate_types,
6011     enumerate_names,
6012     del,
6013     port_open_type,
6014     type_run,
6015     type_run_fast,
6016     type_wait,
6017     alloc,
6018     construct,
6019     destruct,
6020     dealloc,
6021     run,
6022     run_fast,
6023     wait,
6024     get_memory_usage,
6025     flush,
6026     get_features,
6027     get_tables,
6028     port_alloc,
6029     port_construct,
6030     port_destruct,
6031     port_dealloc,
6032     port_modified,
6033     port_reconfigured,
6034     port_query_by_name,
6035     port_add,
6036     port_del,
6037     port_get_stats,
6038     port_dump_start,
6039     port_dump_next,
6040     port_dump_done,
6041     port_poll,
6042     port_poll_wait,
6043     port_is_lacp_current,
6044     NULL,                       /* rule_choose_table */
6045     rule_alloc,
6046     rule_construct,
6047     rule_insert,
6048     rule_delete,
6049     rule_destruct,
6050     rule_dealloc,
6051     rule_get_stats,
6052     rule_execute,
6053     rule_modify_actions,
6054     set_frag_handling,
6055     packet_out,
6056     set_netflow,
6057     get_netflow_ids,
6058     set_sflow,
6059     set_ipfix,
6060     set_cfm,
6061     get_cfm_status,
6062     set_bfd,
6063     get_bfd_status,
6064     set_stp,
6065     get_stp_status,
6066     set_stp_port,
6067     get_stp_port_status,
6068     set_queues,
6069     bundle_set,
6070     bundle_remove,
6071     mirror_set__,
6072     mirror_get_stats__,
6073     set_flood_vlans,
6074     is_mirror_output_bundle,
6075     forward_bpdu_changed,
6076     set_mac_table_config,
6077     set_realdev,
6078     NULL,                       /* meter_get_features */
6079     NULL,                       /* meter_set */
6080     NULL,                       /* meter_get */
6081     NULL,                       /* meter_del */
6082     NULL,                       /* group_alloc */
6083     NULL,                       /* group_construct */
6084     NULL,                       /* group_destruct */
6085     NULL,                       /* group_dealloc */
6086     NULL,                       /* group_modify */
6087     NULL,                       /* group_get_stats */
6088 };