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_odp_actions(struct ofproto_dpif *ofproto, const struct flow *flow,
3808                     const struct nlattr *odp_actions, size_t actions_len,
3809                     struct ofpbuf *packet)
3810 {
3811     struct odputil_keybuf keybuf;
3812     struct ofpbuf key;
3813
3814     ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
3815     odp_flow_key_from_flow(&key, flow,
3816                            ofp_port_to_odp_port(ofproto, flow->in_port.ofp_port));
3817
3818     return dpif_execute(ofproto->backer->dpif, key.data, key.size,
3819                         odp_actions, actions_len, packet);
3820 }
3821
3822 /* Remove 'facet' from its ofproto and free up the associated memory:
3823  *
3824  *   - If 'facet' was installed in the datapath, uninstalls it and updates its
3825  *     rule's statistics, via subfacet_uninstall().
3826  *
3827  *   - Removes 'facet' from its rule and from ofproto->facets.
3828  */
3829 static void
3830 facet_remove(struct facet *facet)
3831 {
3832     struct subfacet *subfacet, *next_subfacet;
3833
3834     COVERAGE_INC(facet_remove);
3835     ovs_assert(!list_is_empty(&facet->subfacets));
3836
3837     /* First uninstall all of the subfacets to get final statistics. */
3838     LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
3839         subfacet_uninstall(subfacet);
3840     }
3841
3842     /* Flush the final stats to the rule.
3843      *
3844      * This might require us to have at least one subfacet around so that we
3845      * can use its actions for accounting in facet_account(), which is why we
3846      * have uninstalled but not yet destroyed the subfacets. */
3847     facet_flush_stats(facet);
3848
3849     /* Now we're really all done so destroy everything. */
3850     LIST_FOR_EACH_SAFE (subfacet, next_subfacet, list_node,
3851                         &facet->subfacets) {
3852         subfacet_destroy__(subfacet);
3853     }
3854     ovs_rwlock_wrlock(&facet->ofproto->facets.rwlock);
3855     classifier_remove(&facet->ofproto->facets, &facet->cr);
3856     ovs_rwlock_unlock(&facet->ofproto->facets.rwlock);
3857     cls_rule_destroy(&facet->cr);
3858     facet_free(facet);
3859 }
3860
3861 /* Feed information from 'facet' back into the learning table to keep it in
3862  * sync with what is actually flowing through the datapath. */
3863 static void
3864 facet_learn(struct facet *facet)
3865 {
3866     long long int now = time_msec();
3867
3868     if (!facet->xout.has_fin_timeout && now < facet->learn_rl) {
3869         return;
3870     }
3871
3872     facet->learn_rl = now + 500;
3873
3874     if (!facet->xout.has_learn
3875         && !facet->xout.has_normal
3876         && (!facet->xout.has_fin_timeout
3877             || !(facet->tcp_flags & (TCP_FIN | TCP_RST)))) {
3878         return;
3879     }
3880
3881     facet_push_stats(facet, true);
3882 }
3883
3884 static void
3885 facet_account(struct facet *facet)
3886 {
3887     const struct nlattr *a;
3888     unsigned int left;
3889     ovs_be16 vlan_tci;
3890     uint64_t n_bytes;
3891
3892     if (!facet->xout.has_normal || !facet->ofproto->has_bonded_bundles) {
3893         return;
3894     }
3895     n_bytes = facet->byte_count - facet->accounted_bytes;
3896
3897     /* This loop feeds byte counters to bond_account() for rebalancing to use
3898      * as a basis.  We also need to track the actual VLAN on which the packet
3899      * is going to be sent to ensure that it matches the one passed to
3900      * bond_choose_output_slave().  (Otherwise, we will account to the wrong
3901      * hash bucket.)
3902      *
3903      * We use the actions from an arbitrary subfacet because they should all
3904      * be equally valid for our purpose. */
3905     vlan_tci = facet->flow.vlan_tci;
3906     NL_ATTR_FOR_EACH_UNSAFE (a, left, facet->xout.odp_actions.data,
3907                              facet->xout.odp_actions.size) {
3908         const struct ovs_action_push_vlan *vlan;
3909         struct ofport_dpif *port;
3910
3911         switch (nl_attr_type(a)) {
3912         case OVS_ACTION_ATTR_OUTPUT:
3913             port = get_odp_port(facet->ofproto, nl_attr_get_odp_port(a));
3914             if (port && port->bundle && port->bundle->bond) {
3915                 bond_account(port->bundle->bond, &facet->flow,
3916                              vlan_tci_to_vid(vlan_tci), n_bytes);
3917             }
3918             break;
3919
3920         case OVS_ACTION_ATTR_POP_VLAN:
3921             vlan_tci = htons(0);
3922             break;
3923
3924         case OVS_ACTION_ATTR_PUSH_VLAN:
3925             vlan = nl_attr_get(a);
3926             vlan_tci = vlan->vlan_tci;
3927             break;
3928         }
3929     }
3930 }
3931
3932 /* Returns true if the only action for 'facet' is to send to the controller.
3933  * (We don't report NetFlow expiration messages for such facets because they
3934  * are just part of the control logic for the network, not real traffic). */
3935 static bool
3936 facet_is_controller_flow(struct facet *facet)
3937 {
3938     if (facet) {
3939         struct ofproto_dpif *ofproto = facet->ofproto;
3940         const struct ofpact *ofpacts;
3941         struct rule_actions *actions;
3942         struct rule_dpif *rule;
3943         size_t ofpacts_len;
3944         bool is_controller;
3945
3946         rule_dpif_lookup(ofproto, &facet->flow, NULL, &rule);
3947         actions = rule_dpif_get_actions(rule);
3948         rule_dpif_unref(rule);
3949
3950         ofpacts_len = actions->ofpacts_len;
3951         ofpacts = actions->ofpacts;
3952         is_controller = ofpacts_len > 0
3953             && ofpacts->type == OFPACT_CONTROLLER
3954             && ofpact_next(ofpacts) >= ofpact_end(ofpacts, ofpacts_len);
3955         rule_actions_unref(actions);
3956
3957         return is_controller;
3958     }
3959     return false;
3960 }
3961
3962 /* Folds all of 'facet''s statistics into its rule.  Also updates the
3963  * accounting ofhook and emits a NetFlow expiration if appropriate.  All of
3964  * 'facet''s statistics in the datapath should have been zeroed and folded into
3965  * its packet and byte counts before this function is called. */
3966 static void
3967 facet_flush_stats(struct facet *facet)
3968 {
3969     struct ofproto_dpif *ofproto = facet->ofproto;
3970     struct subfacet *subfacet;
3971
3972     LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
3973         ovs_assert(!subfacet->dp_byte_count);
3974         ovs_assert(!subfacet->dp_packet_count);
3975     }
3976
3977     facet_push_stats(facet, false);
3978     if (facet->accounted_bytes < facet->byte_count) {
3979         facet_account(facet);
3980         facet->accounted_bytes = facet->byte_count;
3981     }
3982
3983     if (ofproto->netflow && !facet_is_controller_flow(facet)) {
3984         struct ofexpired expired;
3985         expired.flow = facet->flow;
3986         expired.packet_count = facet->packet_count;
3987         expired.byte_count = facet->byte_count;
3988         expired.used = facet->used;
3989         netflow_expire(ofproto->netflow, &facet->nf_flow, &expired);
3990     }
3991
3992     /* Reset counters to prevent double counting if 'facet' ever gets
3993      * reinstalled. */
3994     facet_reset_counters(facet);
3995
3996     netflow_flow_clear(&facet->nf_flow);
3997     facet->tcp_flags = 0;
3998 }
3999
4000 /* Searches 'ofproto''s table of facets for one which would be responsible for
4001  * 'flow'.  Returns it if found, otherwise a null pointer.
4002  *
4003  * The returned facet might need revalidation; use facet_lookup_valid()
4004  * instead if that is important. */
4005 static struct facet *
4006 facet_find(struct ofproto_dpif *ofproto, const struct flow *flow)
4007 {
4008     struct cls_rule *cr;
4009
4010     ovs_rwlock_rdlock(&ofproto->facets.rwlock);
4011     cr = classifier_lookup(&ofproto->facets, flow, NULL);
4012     ovs_rwlock_unlock(&ofproto->facets.rwlock);
4013     return cr ? CONTAINER_OF(cr, struct facet, cr) : NULL;
4014 }
4015
4016 /* Searches 'ofproto''s table of facets for one capable that covers
4017  * 'flow'.  Returns it if found, otherwise a null pointer.
4018  *
4019  * The returned facet is guaranteed to be valid. */
4020 static struct facet *
4021 facet_lookup_valid(struct ofproto_dpif *ofproto, const struct flow *flow)
4022 {
4023     struct facet *facet;
4024
4025     facet = facet_find(ofproto, flow);
4026     if (facet
4027         && ofproto->backer->need_revalidate
4028         && !facet_revalidate(facet)) {
4029         return NULL;
4030     }
4031
4032     return facet;
4033 }
4034
4035 static bool
4036 facet_check_consistency(struct facet *facet)
4037 {
4038     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 15);
4039
4040     struct xlate_out xout;
4041     struct xlate_in xin;
4042     bool ok;
4043
4044     /* Check the datapath actions for consistency. */
4045     xlate_in_init(&xin, facet->ofproto, &facet->flow, NULL, 0, NULL);
4046     xlate_actions(&xin, &xout);
4047
4048     ok = ofpbuf_equal(&facet->xout.odp_actions, &xout.odp_actions)
4049         && facet->xout.slow == xout.slow;
4050     if (!ok && !VLOG_DROP_WARN(&rl)) {
4051         struct ds s = DS_EMPTY_INITIALIZER;
4052
4053         flow_format(&s, &facet->flow);
4054         ds_put_cstr(&s, ": inconsistency in facet");
4055
4056         if (!ofpbuf_equal(&facet->xout.odp_actions, &xout.odp_actions)) {
4057             ds_put_cstr(&s, " (actions were: ");
4058             format_odp_actions(&s, facet->xout.odp_actions.data,
4059                                facet->xout.odp_actions.size);
4060             ds_put_cstr(&s, ") (correct actions: ");
4061             format_odp_actions(&s, xout.odp_actions.data,
4062                                xout.odp_actions.size);
4063             ds_put_char(&s, ')');
4064         }
4065
4066         if (facet->xout.slow != xout.slow) {
4067             ds_put_format(&s, " slow path incorrect. should be %d", xout.slow);
4068         }
4069
4070         ds_destroy(&s);
4071     }
4072     xlate_out_uninit(&xout);
4073
4074     return ok;
4075 }
4076
4077 /* Re-searches the classifier for 'facet':
4078  *
4079  *   - If the rule found is different from 'facet''s current rule, moves
4080  *     'facet' to the new rule and recompiles its actions.
4081  *
4082  *   - If the rule found is the same as 'facet''s current rule, leaves 'facet'
4083  *     where it is and recompiles its actions anyway.
4084  *
4085  *   - If any of 'facet''s subfacets correspond to a new flow according to
4086  *     xlate_receive(), 'facet' is removed.
4087  *
4088  *   Returns true if 'facet' is still valid.  False if 'facet' was removed. */
4089 static bool
4090 facet_revalidate(struct facet *facet)
4091 {
4092     struct ofproto_dpif *ofproto = facet->ofproto;
4093     struct rule_dpif *new_rule;
4094     struct subfacet *subfacet;
4095     struct flow_wildcards wc;
4096     struct xlate_out xout;
4097     struct xlate_in xin;
4098
4099     COVERAGE_INC(facet_revalidate);
4100
4101     /* Check that child subfacets still correspond to this facet.  Tunnel
4102      * configuration changes could cause a subfacet's OpenFlow in_port to
4103      * change. */
4104     LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
4105         struct ofproto_dpif *recv_ofproto;
4106         struct flow recv_flow;
4107         int error;
4108
4109         error = xlate_receive(ofproto->backer, NULL, subfacet->key,
4110                               subfacet->key_len, &recv_flow, NULL,
4111                               &recv_ofproto, NULL);
4112         if (error
4113             || recv_ofproto != ofproto
4114             || facet != facet_find(ofproto, &recv_flow)) {
4115             facet_remove(facet);
4116             return false;
4117         }
4118     }
4119
4120     flow_wildcards_init_catchall(&wc);
4121     rule_dpif_lookup(ofproto, &facet->flow, &wc, &new_rule);
4122
4123     /* Calculate new datapath actions.
4124      *
4125      * We do not modify any 'facet' state yet, because we might need to, e.g.,
4126      * emit a NetFlow expiration and, if so, we need to have the old state
4127      * around to properly compose it. */
4128     xlate_in_init(&xin, ofproto, &facet->flow, new_rule, 0, NULL);
4129     xlate_actions(&xin, &xout);
4130     flow_wildcards_or(&xout.wc, &xout.wc, &wc);
4131
4132     /* A facet's slow path reason should only change under dramatic
4133      * circumstances.  Rather than try to update everything, it's simpler to
4134      * remove the facet and start over.
4135      *
4136      * More importantly, if a facet's wildcards change, it will be relatively
4137      * difficult to figure out if its subfacets still belong to it, and if not
4138      * which facet they may belong to.  Again, to avoid the complexity, we
4139      * simply give up instead. */
4140     if (facet->xout.slow != xout.slow
4141         || memcmp(&facet->xout.wc, &xout.wc, sizeof xout.wc)) {
4142         facet_remove(facet);
4143         xlate_out_uninit(&xout);
4144         rule_dpif_unref(new_rule);
4145         return false;
4146     }
4147
4148     if (!ofpbuf_equal(&facet->xout.odp_actions, &xout.odp_actions)) {
4149         LIST_FOR_EACH(subfacet, list_node, &facet->subfacets) {
4150             if (subfacet->path == SF_FAST_PATH) {
4151                 struct dpif_flow_stats stats;
4152
4153                 subfacet_install(subfacet, &xout.odp_actions, &stats);
4154                 subfacet_update_stats(subfacet, &stats);
4155             }
4156         }
4157
4158         facet_flush_stats(facet);
4159
4160         ofpbuf_clear(&facet->xout.odp_actions);
4161         ofpbuf_put(&facet->xout.odp_actions, xout.odp_actions.data,
4162                    xout.odp_actions.size);
4163     }
4164
4165     /* Update 'facet' now that we've taken care of all the old state. */
4166     facet->xout.slow = xout.slow;
4167     facet->xout.has_learn = xout.has_learn;
4168     facet->xout.has_normal = xout.has_normal;
4169     facet->xout.has_fin_timeout = xout.has_fin_timeout;
4170     facet->xout.nf_output_iface = xout.nf_output_iface;
4171     facet->xout.mirrors = xout.mirrors;
4172     facet->nf_flow.output_iface = facet->xout.nf_output_iface;
4173
4174     ovs_mutex_lock(&new_rule->up.mutex);
4175     facet->used = MAX(facet->used, new_rule->up.created);
4176     ovs_mutex_unlock(&new_rule->up.mutex);
4177
4178     xlate_out_uninit(&xout);
4179     rule_dpif_unref(new_rule);
4180     return true;
4181 }
4182
4183 static void
4184 facet_reset_counters(struct facet *facet)
4185 {
4186     facet->packet_count = 0;
4187     facet->byte_count = 0;
4188     facet->prev_packet_count = 0;
4189     facet->prev_byte_count = 0;
4190     facet->accounted_bytes = 0;
4191 }
4192
4193 static void
4194 flow_push_stats(struct ofproto_dpif *ofproto, struct flow *flow,
4195                 struct dpif_flow_stats *stats, bool may_learn)
4196 {
4197     struct ofport_dpif *in_port;
4198     struct xlate_in xin;
4199
4200     in_port = get_ofp_port(ofproto, flow->in_port.ofp_port);
4201     if (in_port && in_port->is_tunnel) {
4202         netdev_vport_inc_rx(in_port->up.netdev, stats);
4203     }
4204
4205     xlate_in_init(&xin, ofproto, flow, NULL, stats->tcp_flags, NULL);
4206     xin.resubmit_stats = stats;
4207     xin.may_learn = may_learn;
4208     xlate_actions_for_side_effects(&xin);
4209 }
4210
4211 static void
4212 facet_push_stats(struct facet *facet, bool may_learn)
4213 {
4214     struct dpif_flow_stats stats;
4215
4216     ovs_assert(facet->packet_count >= facet->prev_packet_count);
4217     ovs_assert(facet->byte_count >= facet->prev_byte_count);
4218     ovs_assert(facet->used >= facet->prev_used);
4219
4220     stats.n_packets = facet->packet_count - facet->prev_packet_count;
4221     stats.n_bytes = facet->byte_count - facet->prev_byte_count;
4222     stats.used = facet->used;
4223     stats.tcp_flags = facet->tcp_flags;
4224
4225     if (may_learn || stats.n_packets || facet->used > facet->prev_used) {
4226         facet->prev_packet_count = facet->packet_count;
4227         facet->prev_byte_count = facet->byte_count;
4228         facet->prev_used = facet->used;
4229
4230         netflow_flow_update_time(facet->ofproto->netflow, &facet->nf_flow,
4231                                  facet->used);
4232         netflow_flow_update_flags(&facet->nf_flow, facet->tcp_flags);
4233         mirror_update_stats(facet->ofproto->mbridge, facet->xout.mirrors,
4234                             stats.n_packets, stats.n_bytes);
4235         flow_push_stats(facet->ofproto, &facet->flow, &stats, may_learn);
4236     }
4237 }
4238
4239 static void
4240 push_all_stats__(bool run_fast)
4241 {
4242     static long long int rl = LLONG_MIN;
4243     struct ofproto_dpif *ofproto;
4244
4245     if (time_msec() < rl) {
4246         return;
4247     }
4248
4249     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
4250         struct cls_cursor cursor;
4251         struct facet *facet;
4252
4253         ovs_rwlock_rdlock(&ofproto->facets.rwlock);
4254         cls_cursor_init(&cursor, &ofproto->facets, NULL);
4255         CLS_CURSOR_FOR_EACH (facet, cr, &cursor) {
4256             facet_push_stats(facet, false);
4257             if (run_fast) {
4258                 run_fast_rl();
4259             }
4260         }
4261         ovs_rwlock_unlock(&ofproto->facets.rwlock);
4262     }
4263
4264     rl = time_msec() + 100;
4265 }
4266
4267 static void
4268 push_all_stats(void)
4269 {
4270     push_all_stats__(true);
4271 }
4272
4273 void
4274 rule_dpif_credit_stats(struct rule_dpif *rule,
4275                        const struct dpif_flow_stats *stats)
4276 {
4277     ovs_mutex_lock(&rule->stats_mutex);
4278     rule->packet_count += stats->n_packets;
4279     rule->byte_count += stats->n_bytes;
4280     rule->up.used = MAX(rule->up.used, stats->used);
4281     ovs_mutex_unlock(&rule->stats_mutex);
4282 }
4283
4284 bool
4285 rule_dpif_fail_open(const struct rule_dpif *rule)
4286 {
4287     return rule->up.cr.priority == FAIL_OPEN_PRIORITY;
4288 }
4289
4290 ovs_be64
4291 rule_dpif_get_flow_cookie(const struct rule_dpif *rule)
4292     OVS_REQUIRES(rule->up.mutex)
4293 {
4294     return rule->up.flow_cookie;
4295 }
4296
4297 void
4298 rule_dpif_reduce_timeouts(struct rule_dpif *rule, uint16_t idle_timeout,
4299                      uint16_t hard_timeout)
4300 {
4301     ofproto_rule_reduce_timeouts(&rule->up, idle_timeout, hard_timeout);
4302 }
4303
4304 /* Returns 'rule''s actions.  The caller owns a reference on the returned
4305  * actions and must eventually release it (with rule_actions_unref()) to avoid
4306  * a memory leak. */
4307 struct rule_actions *
4308 rule_dpif_get_actions(const struct rule_dpif *rule)
4309 {
4310     return rule_get_actions(&rule->up);
4311 }
4312 \f
4313 /* Subfacets. */
4314
4315 static struct subfacet *
4316 subfacet_find(struct dpif_backer *backer, const struct nlattr *key,
4317               size_t key_len, uint32_t key_hash)
4318 {
4319     struct subfacet *subfacet;
4320
4321     HMAP_FOR_EACH_WITH_HASH (subfacet, hmap_node, key_hash,
4322                              &backer->subfacets) {
4323         if (subfacet->key_len == key_len
4324             && !memcmp(key, subfacet->key, key_len)) {
4325             return subfacet;
4326         }
4327     }
4328
4329     return NULL;
4330 }
4331
4332 /* Searches 'facet' (within 'ofproto') for a subfacet with the specified
4333  * 'key_fitness', 'key', and 'key_len' members in 'miss'.  Returns the
4334  * existing subfacet if there is one, otherwise creates and returns a
4335  * new subfacet. */
4336 static struct subfacet *
4337 subfacet_create(struct facet *facet, struct flow_miss *miss)
4338 {
4339     struct dpif_backer *backer = miss->ofproto->backer;
4340     const struct nlattr *key = miss->key;
4341     size_t key_len = miss->key_len;
4342     uint32_t key_hash;
4343     struct subfacet *subfacet;
4344
4345     key_hash = odp_flow_key_hash(key, key_len);
4346
4347     if (list_is_empty(&facet->subfacets)) {
4348         subfacet = &facet->one_subfacet;
4349     } else {
4350         subfacet = subfacet_find(backer, key, key_len, key_hash);
4351         if (subfacet) {
4352             if (subfacet->facet == facet) {
4353                 return subfacet;
4354             }
4355
4356             /* This shouldn't happen. */
4357             VLOG_ERR_RL(&rl, "subfacet with wrong facet");
4358             subfacet_destroy(subfacet);
4359         }
4360
4361         subfacet = xmalloc(sizeof *subfacet);
4362     }
4363
4364     COVERAGE_INC(subfacet_create);
4365     hmap_insert(&backer->subfacets, &subfacet->hmap_node, key_hash);
4366     list_push_back(&facet->subfacets, &subfacet->list_node);
4367     subfacet->facet = facet;
4368     subfacet->key = xmemdup(key, key_len);
4369     subfacet->key_len = key_len;
4370     subfacet->used = miss->stats.used;
4371     subfacet->created = subfacet->used;
4372     subfacet->dp_packet_count = 0;
4373     subfacet->dp_byte_count = 0;
4374     subfacet->path = SF_NOT_INSTALLED;
4375     subfacet->backer = backer;
4376
4377     return subfacet;
4378 }
4379
4380 /* Uninstalls 'subfacet' from the datapath, if it is installed, removes it from
4381  * its facet within 'ofproto', and frees it. */
4382 static void
4383 subfacet_destroy__(struct subfacet *subfacet)
4384 {
4385     struct facet *facet = subfacet->facet;
4386
4387     COVERAGE_INC(subfacet_destroy);
4388     subfacet_uninstall(subfacet);
4389     hmap_remove(&subfacet->backer->subfacets, &subfacet->hmap_node);
4390     list_remove(&subfacet->list_node);
4391     free(subfacet->key);
4392     if (subfacet != &facet->one_subfacet) {
4393         free(subfacet);
4394     }
4395 }
4396
4397 /* Destroys 'subfacet', as with subfacet_destroy__(), and then if this was the
4398  * last remaining subfacet in its facet destroys the facet too. */
4399 static void
4400 subfacet_destroy(struct subfacet *subfacet)
4401 {
4402     struct facet *facet = subfacet->facet;
4403
4404     if (list_is_singleton(&facet->subfacets)) {
4405         /* facet_remove() needs at least one subfacet (it will remove it). */
4406         facet_remove(facet);
4407     } else {
4408         subfacet_destroy__(subfacet);
4409     }
4410 }
4411
4412 static void
4413 subfacet_destroy_batch(struct dpif_backer *backer,
4414                        struct subfacet **subfacets, int n)
4415 {
4416     struct dpif_op ops[SUBFACET_DESTROY_MAX_BATCH];
4417     struct dpif_op *opsp[SUBFACET_DESTROY_MAX_BATCH];
4418     struct dpif_flow_stats stats[SUBFACET_DESTROY_MAX_BATCH];
4419     int i;
4420
4421     for (i = 0; i < n; i++) {
4422         ops[i].type = DPIF_OP_FLOW_DEL;
4423         ops[i].u.flow_del.key = subfacets[i]->key;
4424         ops[i].u.flow_del.key_len = subfacets[i]->key_len;
4425         ops[i].u.flow_del.stats = &stats[i];
4426         opsp[i] = &ops[i];
4427     }
4428
4429     dpif_operate(backer->dpif, opsp, n);
4430     for (i = 0; i < n; i++) {
4431         subfacet_reset_dp_stats(subfacets[i], &stats[i]);
4432         subfacets[i]->path = SF_NOT_INSTALLED;
4433         subfacet_destroy(subfacets[i]);
4434         run_fast_rl();
4435     }
4436 }
4437
4438 /* Updates 'subfacet''s datapath flow, setting its actions to 'actions_len'
4439  * bytes of actions in 'actions'.  If 'stats' is non-null, statistics counters
4440  * in the datapath will be zeroed and 'stats' will be updated with traffic new
4441  * since 'subfacet' was last updated.
4442  *
4443  * Returns 0 if successful, otherwise a positive errno value. */
4444 static int
4445 subfacet_install(struct subfacet *subfacet, const struct ofpbuf *odp_actions,
4446                  struct dpif_flow_stats *stats)
4447 {
4448     struct facet *facet = subfacet->facet;
4449     enum subfacet_path path = facet->xout.slow ? SF_SLOW_PATH : SF_FAST_PATH;
4450     const struct nlattr *actions = odp_actions->data;
4451     size_t actions_len = odp_actions->size;
4452     struct odputil_keybuf maskbuf;
4453     struct ofpbuf mask;
4454
4455     uint64_t slow_path_stub[128 / 8];
4456     enum dpif_flow_put_flags flags;
4457     int ret;
4458
4459     flags = subfacet->path == SF_NOT_INSTALLED ? DPIF_FP_CREATE
4460                                                : DPIF_FP_MODIFY;
4461     if (stats) {
4462         flags |= DPIF_FP_ZERO_STATS;
4463     }
4464
4465     if (path == SF_SLOW_PATH) {
4466         compose_slow_path(facet->ofproto, &facet->flow, facet->xout.slow,
4467                           slow_path_stub, sizeof slow_path_stub,
4468                           &actions, &actions_len);
4469     }
4470
4471     ofpbuf_use_stack(&mask, &maskbuf, sizeof maskbuf);
4472     if (enable_megaflows) {
4473         odp_flow_key_from_mask(&mask, &facet->xout.wc.masks,
4474                                &facet->flow, UINT32_MAX);
4475     }
4476
4477     ret = dpif_flow_put(subfacet->backer->dpif, flags, subfacet->key,
4478                         subfacet->key_len,  mask.data, mask.size,
4479                         actions, actions_len, stats);
4480
4481     if (stats) {
4482         subfacet_reset_dp_stats(subfacet, stats);
4483     }
4484
4485     if (ret) {
4486         COVERAGE_INC(subfacet_install_fail);
4487     } else {
4488         subfacet->path = path;
4489     }
4490     return ret;
4491 }
4492
4493 /* If 'subfacet' is installed in the datapath, uninstalls it. */
4494 static void
4495 subfacet_uninstall(struct subfacet *subfacet)
4496 {
4497     if (subfacet->path != SF_NOT_INSTALLED) {
4498         struct ofproto_dpif *ofproto = subfacet->facet->ofproto;
4499         struct dpif_flow_stats stats;
4500         int error;
4501
4502         error = dpif_flow_del(ofproto->backer->dpif, subfacet->key,
4503                               subfacet->key_len, &stats);
4504         subfacet_reset_dp_stats(subfacet, &stats);
4505         if (!error) {
4506             subfacet_update_stats(subfacet, &stats);
4507         }
4508         subfacet->path = SF_NOT_INSTALLED;
4509     } else {
4510         ovs_assert(subfacet->dp_packet_count == 0);
4511         ovs_assert(subfacet->dp_byte_count == 0);
4512     }
4513 }
4514
4515 /* Resets 'subfacet''s datapath statistics counters.  This should be called
4516  * when 'subfacet''s statistics are cleared in the datapath.  If 'stats' is
4517  * non-null, it should contain the statistics returned by dpif when 'subfacet'
4518  * was reset in the datapath.  'stats' will be modified to include only
4519  * statistics new since 'subfacet' was last updated. */
4520 static void
4521 subfacet_reset_dp_stats(struct subfacet *subfacet,
4522                         struct dpif_flow_stats *stats)
4523 {
4524     if (stats
4525         && subfacet->dp_packet_count <= stats->n_packets
4526         && subfacet->dp_byte_count <= stats->n_bytes) {
4527         stats->n_packets -= subfacet->dp_packet_count;
4528         stats->n_bytes -= subfacet->dp_byte_count;
4529     }
4530
4531     subfacet->dp_packet_count = 0;
4532     subfacet->dp_byte_count = 0;
4533 }
4534
4535 /* Folds the statistics from 'stats' into the counters in 'subfacet'.
4536  *
4537  * Because of the meaning of a subfacet's counters, it only makes sense to do
4538  * this if 'stats' are not tracked in the datapath, that is, if 'stats'
4539  * represents a packet that was sent by hand or if it represents statistics
4540  * that have been cleared out of the datapath. */
4541 static void
4542 subfacet_update_stats(struct subfacet *subfacet,
4543                       const struct dpif_flow_stats *stats)
4544 {
4545     if (stats->n_packets || stats->used > subfacet->used) {
4546         struct facet *facet = subfacet->facet;
4547
4548         subfacet->used = MAX(subfacet->used, stats->used);
4549         facet->used = MAX(facet->used, stats->used);
4550         facet->packet_count += stats->n_packets;
4551         facet->byte_count += stats->n_bytes;
4552         facet->tcp_flags |= stats->tcp_flags;
4553     }
4554 }
4555 \f
4556 /* Rules. */
4557
4558 /* Lookup 'flow' in 'ofproto''s classifier.  If 'wc' is non-null, sets
4559  * the fields that were relevant as part of the lookup. */
4560 void
4561 rule_dpif_lookup(struct ofproto_dpif *ofproto, const struct flow *flow,
4562                  struct flow_wildcards *wc, struct rule_dpif **rule)
4563 {
4564     struct ofport_dpif *port;
4565
4566     if (rule_dpif_lookup_in_table(ofproto, flow, wc, 0, rule)) {
4567         return;
4568     }
4569     port = get_ofp_port(ofproto, flow->in_port.ofp_port);
4570     if (!port) {
4571         VLOG_WARN_RL(&rl, "packet-in on unknown OpenFlow port %"PRIu16,
4572                      flow->in_port.ofp_port);
4573     }
4574
4575     choose_miss_rule(port ? port->up.pp.config : 0, ofproto->miss_rule,
4576                      ofproto->no_packet_in_rule, rule);
4577 }
4578
4579 bool
4580 rule_dpif_lookup_in_table(struct ofproto_dpif *ofproto,
4581                           const struct flow *flow, struct flow_wildcards *wc,
4582                           uint8_t table_id, struct rule_dpif **rule)
4583 {
4584     const struct cls_rule *cls_rule;
4585     struct classifier *cls;
4586     bool frag;
4587
4588     *rule = NULL;
4589     if (table_id >= N_TABLES) {
4590         return false;
4591     }
4592
4593     if (wc) {
4594         memset(&wc->masks.dl_type, 0xff, sizeof wc->masks.dl_type);
4595         wc->masks.nw_frag |= FLOW_NW_FRAG_MASK;
4596     }
4597
4598     cls = &ofproto->up.tables[table_id].cls;
4599     ovs_rwlock_rdlock(&cls->rwlock);
4600     frag = (flow->nw_frag & FLOW_NW_FRAG_ANY) != 0;
4601     if (frag && ofproto->up.frag_handling == OFPC_FRAG_NORMAL) {
4602         /* We must pretend that transport ports are unavailable. */
4603         struct flow ofpc_normal_flow = *flow;
4604         ofpc_normal_flow.tp_src = htons(0);
4605         ofpc_normal_flow.tp_dst = htons(0);
4606         cls_rule = classifier_lookup(cls, &ofpc_normal_flow, wc);
4607     } else if (frag && ofproto->up.frag_handling == OFPC_FRAG_DROP) {
4608         cls_rule = &ofproto->drop_frags_rule->up.cr;
4609         if (wc) {
4610             flow_wildcards_init_exact(wc);
4611         }
4612     } else {
4613         cls_rule = classifier_lookup(cls, flow, wc);
4614     }
4615
4616     *rule = rule_dpif_cast(rule_from_cls_rule(cls_rule));
4617     rule_dpif_ref(*rule);
4618     ovs_rwlock_unlock(&cls->rwlock);
4619
4620     return *rule != NULL;
4621 }
4622
4623 /* Given a port configuration (specified as zero if there's no port), chooses
4624  * which of 'miss_rule' and 'no_packet_in_rule' should be used in case of a
4625  * flow table miss. */
4626 void
4627 choose_miss_rule(enum ofputil_port_config config, struct rule_dpif *miss_rule,
4628                  struct rule_dpif *no_packet_in_rule, struct rule_dpif **rule)
4629 {
4630     *rule = config & OFPUTIL_PC_NO_PACKET_IN ? no_packet_in_rule : miss_rule;
4631     rule_dpif_ref(*rule);
4632 }
4633
4634 void
4635 rule_dpif_ref(struct rule_dpif *rule)
4636 {
4637     if (rule) {
4638         ofproto_rule_ref(&rule->up);
4639     }
4640 }
4641
4642 void
4643 rule_dpif_unref(struct rule_dpif *rule)
4644 {
4645     if (rule) {
4646         ofproto_rule_unref(&rule->up);
4647     }
4648 }
4649
4650 static void
4651 complete_operation(struct rule_dpif *rule)
4652     OVS_REQUIRES(ofproto_mutex)
4653 {
4654     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
4655
4656     ofproto->backer->need_revalidate = REV_FLOW_TABLE;
4657     ofoperation_complete(rule->up.pending, 0);
4658 }
4659
4660 static struct rule_dpif *rule_dpif_cast(const struct rule *rule)
4661 {
4662     return rule ? CONTAINER_OF(rule, struct rule_dpif, up) : NULL;
4663 }
4664
4665 static struct rule *
4666 rule_alloc(void)
4667 {
4668     struct rule_dpif *rule = xmalloc(sizeof *rule);
4669     return &rule->up;
4670 }
4671
4672 static void
4673 rule_dealloc(struct rule *rule_)
4674 {
4675     struct rule_dpif *rule = rule_dpif_cast(rule_);
4676     free(rule);
4677 }
4678
4679 static enum ofperr
4680 rule_construct(struct rule *rule_)
4681 {
4682     struct rule_dpif *rule = rule_dpif_cast(rule_);
4683     ovs_mutex_init(&rule->stats_mutex);
4684     ovs_mutex_lock(&rule->stats_mutex);
4685     rule->packet_count = 0;
4686     rule->byte_count = 0;
4687     ovs_mutex_unlock(&rule->stats_mutex);
4688     return 0;
4689 }
4690
4691 static void
4692 rule_insert(struct rule *rule_)
4693     OVS_REQUIRES(ofproto_mutex)
4694 {
4695     struct rule_dpif *rule = rule_dpif_cast(rule_);
4696     complete_operation(rule);
4697 }
4698
4699 static void
4700 rule_delete(struct rule *rule_)
4701     OVS_REQUIRES(ofproto_mutex)
4702 {
4703     struct rule_dpif *rule = rule_dpif_cast(rule_);
4704     complete_operation(rule);
4705 }
4706
4707 static void
4708 rule_destruct(struct rule *rule_)
4709 {
4710     struct rule_dpif *rule = rule_dpif_cast(rule_);
4711     ovs_mutex_destroy(&rule->stats_mutex);
4712 }
4713
4714 static void
4715 rule_get_stats(struct rule *rule_, uint64_t *packets, uint64_t *bytes)
4716 {
4717     struct rule_dpif *rule = rule_dpif_cast(rule_);
4718
4719     /* push_all_stats() can handle flow misses which, when using the learn
4720      * action, can cause rules to be added and deleted.  This can corrupt our
4721      * caller's datastructures which assume that rule_get_stats() doesn't have
4722      * an impact on the flow table. To be safe, we disable miss handling. */
4723     push_all_stats__(false);
4724
4725     /* Start from historical data for 'rule' itself that are no longer tracked
4726      * in facets.  This counts, for example, facets that have expired. */
4727     ovs_mutex_lock(&rule->stats_mutex);
4728     *packets = rule->packet_count;
4729     *bytes = rule->byte_count;
4730     ovs_mutex_unlock(&rule->stats_mutex);
4731 }
4732
4733 static void
4734 rule_dpif_execute(struct rule_dpif *rule, const struct flow *flow,
4735                   struct ofpbuf *packet)
4736 {
4737     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
4738     struct dpif_flow_stats stats;
4739     struct xlate_out xout;
4740     struct xlate_in xin;
4741
4742     dpif_flow_stats_extract(flow, packet, time_msec(), &stats);
4743     rule_dpif_credit_stats(rule, &stats);
4744
4745     xlate_in_init(&xin, ofproto, flow, rule, stats.tcp_flags, packet);
4746     xin.resubmit_stats = &stats;
4747     xlate_actions(&xin, &xout);
4748
4749     execute_odp_actions(ofproto, flow, xout.odp_actions.data,
4750                         xout.odp_actions.size, packet);
4751
4752     xlate_out_uninit(&xout);
4753 }
4754
4755 static enum ofperr
4756 rule_execute(struct rule *rule, const struct flow *flow,
4757              struct ofpbuf *packet)
4758 {
4759     rule_dpif_execute(rule_dpif_cast(rule), flow, packet);
4760     ofpbuf_delete(packet);
4761     return 0;
4762 }
4763
4764 static void
4765 rule_modify_actions(struct rule *rule_, bool reset_counters)
4766     OVS_REQUIRES(ofproto_mutex)
4767 {
4768     struct rule_dpif *rule = rule_dpif_cast(rule_);
4769
4770     if (reset_counters) {
4771         ovs_mutex_lock(&rule->stats_mutex);
4772         rule->packet_count = 0;
4773         rule->byte_count = 0;
4774         ovs_mutex_unlock(&rule->stats_mutex);
4775     }
4776
4777     complete_operation(rule);
4778 }
4779 \f
4780 /* Sends 'packet' out 'ofport'.
4781  * May modify 'packet'.
4782  * Returns 0 if successful, otherwise a positive errno value. */
4783 int
4784 ofproto_dpif_send_packet(const struct ofport_dpif *ofport, struct ofpbuf *packet)
4785 {
4786     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
4787     int error;
4788
4789     error = xlate_send_packet(ofport, packet);
4790
4791     ovs_mutex_lock(&ofproto->stats_mutex);
4792     ofproto->stats.tx_packets++;
4793     ofproto->stats.tx_bytes += packet->size;
4794     ovs_mutex_unlock(&ofproto->stats_mutex);
4795     return error;
4796 }
4797
4798 /* Composes an ODP action for a "slow path" action for 'flow' within 'ofproto'.
4799  * The action will state 'slow' as the reason that the action is in the slow
4800  * path.  (This is purely informational: it allows a human viewing "ovs-dpctl
4801  * dump-flows" output to see why a flow is in the slow path.)
4802  *
4803  * The 'stub_size' bytes in 'stub' will be used to store the action.
4804  * 'stub_size' must be large enough for the action.
4805  *
4806  * The action and its size will be stored in '*actionsp' and '*actions_lenp',
4807  * respectively. */
4808 static void
4809 compose_slow_path(const struct ofproto_dpif *ofproto, const struct flow *flow,
4810                   enum slow_path_reason slow,
4811                   uint64_t *stub, size_t stub_size,
4812                   const struct nlattr **actionsp, size_t *actions_lenp)
4813 {
4814     union user_action_cookie cookie;
4815     struct ofpbuf buf;
4816
4817     cookie.type = USER_ACTION_COOKIE_SLOW_PATH;
4818     cookie.slow_path.unused = 0;
4819     cookie.slow_path.reason = slow;
4820
4821     ofpbuf_use_stack(&buf, stub, stub_size);
4822     if (slow & (SLOW_CFM | SLOW_BFD | SLOW_LACP | SLOW_STP)) {
4823         uint32_t pid = dpif_port_get_pid(ofproto->backer->dpif,
4824                                          ODPP_NONE);
4825         odp_put_userspace_action(pid, &cookie, sizeof cookie.slow_path, &buf);
4826     } else {
4827         odp_port_t odp_port;
4828         uint32_t pid;
4829
4830         odp_port = ofp_port_to_odp_port(ofproto, flow->in_port.ofp_port);
4831         pid = dpif_port_get_pid(ofproto->backer->dpif, odp_port);
4832         odp_put_userspace_action(pid, &cookie, sizeof cookie.slow_path, &buf);
4833     }
4834     *actionsp = buf.data;
4835     *actions_lenp = buf.size;
4836 }
4837 \f
4838 static bool
4839 set_frag_handling(struct ofproto *ofproto_,
4840                   enum ofp_config_flags frag_handling)
4841 {
4842     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
4843     if (frag_handling != OFPC_FRAG_REASM) {
4844         ofproto->backer->need_revalidate = REV_RECONFIGURE;
4845         return true;
4846     } else {
4847         return false;
4848     }
4849 }
4850
4851 static enum ofperr
4852 packet_out(struct ofproto *ofproto_, struct ofpbuf *packet,
4853            const struct flow *flow,
4854            const struct ofpact *ofpacts, size_t ofpacts_len)
4855 {
4856     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
4857     struct dpif_flow_stats stats;
4858     struct xlate_out xout;
4859     struct xlate_in xin;
4860
4861     dpif_flow_stats_extract(flow, packet, time_msec(), &stats);
4862
4863     xlate_in_init(&xin, ofproto, flow, NULL, stats.tcp_flags, packet);
4864     xin.resubmit_stats = &stats;
4865     xin.ofpacts_len = ofpacts_len;
4866     xin.ofpacts = ofpacts;
4867
4868     xlate_actions(&xin, &xout);
4869     execute_odp_actions(ofproto, flow,
4870                         xout.odp_actions.data, xout.odp_actions.size, packet);
4871     xlate_out_uninit(&xout);
4872
4873     return 0;
4874 }
4875 \f
4876 /* NetFlow. */
4877
4878 static int
4879 set_netflow(struct ofproto *ofproto_,
4880             const struct netflow_options *netflow_options)
4881 {
4882     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
4883
4884     if (netflow_options) {
4885         if (!ofproto->netflow) {
4886             ofproto->netflow = netflow_create();
4887             ofproto->backer->need_revalidate = REV_RECONFIGURE;
4888         }
4889         return netflow_set_options(ofproto->netflow, netflow_options);
4890     } else if (ofproto->netflow) {
4891         ofproto->backer->need_revalidate = REV_RECONFIGURE;
4892         netflow_destroy(ofproto->netflow);
4893         ofproto->netflow = NULL;
4894     }
4895
4896     return 0;
4897 }
4898
4899 static void
4900 get_netflow_ids(const struct ofproto *ofproto_,
4901                 uint8_t *engine_type, uint8_t *engine_id)
4902 {
4903     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
4904
4905     dpif_get_netflow_ids(ofproto->backer->dpif, engine_type, engine_id);
4906 }
4907
4908 static void
4909 send_active_timeout(struct ofproto_dpif *ofproto, struct facet *facet)
4910 {
4911     if (!facet_is_controller_flow(facet) &&
4912         netflow_active_timeout_expired(ofproto->netflow, &facet->nf_flow)) {
4913         struct subfacet *subfacet;
4914         struct ofexpired expired;
4915
4916         LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
4917             if (subfacet->path == SF_FAST_PATH) {
4918                 struct dpif_flow_stats stats;
4919
4920                 subfacet_install(subfacet, &facet->xout.odp_actions,
4921                                  &stats);
4922                 subfacet_update_stats(subfacet, &stats);
4923             }
4924         }
4925
4926         expired.flow = facet->flow;
4927         expired.packet_count = facet->packet_count;
4928         expired.byte_count = facet->byte_count;
4929         expired.used = facet->used;
4930         netflow_expire(ofproto->netflow, &facet->nf_flow, &expired);
4931     }
4932 }
4933
4934 static void
4935 send_netflow_active_timeouts(struct ofproto_dpif *ofproto)
4936 {
4937     struct cls_cursor cursor;
4938     struct facet *facet;
4939
4940     ovs_rwlock_rdlock(&ofproto->facets.rwlock);
4941     cls_cursor_init(&cursor, &ofproto->facets, NULL);
4942     CLS_CURSOR_FOR_EACH (facet, cr, &cursor) {
4943         send_active_timeout(ofproto, facet);
4944     }
4945     ovs_rwlock_unlock(&ofproto->facets.rwlock);
4946 }
4947 \f
4948 static struct ofproto_dpif *
4949 ofproto_dpif_lookup(const char *name)
4950 {
4951     struct ofproto_dpif *ofproto;
4952
4953     HMAP_FOR_EACH_WITH_HASH (ofproto, all_ofproto_dpifs_node,
4954                              hash_string(name, 0), &all_ofproto_dpifs) {
4955         if (!strcmp(ofproto->up.name, name)) {
4956             return ofproto;
4957         }
4958     }
4959     return NULL;
4960 }
4961
4962 static void
4963 ofproto_unixctl_fdb_flush(struct unixctl_conn *conn, int argc,
4964                           const char *argv[], void *aux OVS_UNUSED)
4965 {
4966     struct ofproto_dpif *ofproto;
4967
4968     if (argc > 1) {
4969         ofproto = ofproto_dpif_lookup(argv[1]);
4970         if (!ofproto) {
4971             unixctl_command_reply_error(conn, "no such bridge");
4972             return;
4973         }
4974         ovs_rwlock_wrlock(&ofproto->ml->rwlock);
4975         mac_learning_flush(ofproto->ml);
4976         ovs_rwlock_unlock(&ofproto->ml->rwlock);
4977     } else {
4978         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
4979             ovs_rwlock_wrlock(&ofproto->ml->rwlock);
4980             mac_learning_flush(ofproto->ml);
4981             ovs_rwlock_unlock(&ofproto->ml->rwlock);
4982         }
4983     }
4984
4985     unixctl_command_reply(conn, "table successfully flushed");
4986 }
4987
4988 static struct ofport_dpif *
4989 ofbundle_get_a_port(const struct ofbundle *bundle)
4990 {
4991     return CONTAINER_OF(list_front(&bundle->ports), struct ofport_dpif,
4992                         bundle_node);
4993 }
4994
4995 static void
4996 ofproto_unixctl_fdb_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
4997                          const char *argv[], void *aux OVS_UNUSED)
4998 {
4999     struct ds ds = DS_EMPTY_INITIALIZER;
5000     const struct ofproto_dpif *ofproto;
5001     const struct mac_entry *e;
5002
5003     ofproto = ofproto_dpif_lookup(argv[1]);
5004     if (!ofproto) {
5005         unixctl_command_reply_error(conn, "no such bridge");
5006         return;
5007     }
5008
5009     ds_put_cstr(&ds, " port  VLAN  MAC                Age\n");
5010     ovs_rwlock_rdlock(&ofproto->ml->rwlock);
5011     LIST_FOR_EACH (e, lru_node, &ofproto->ml->lrus) {
5012         struct ofbundle *bundle = e->port.p;
5013         char name[OFP_MAX_PORT_NAME_LEN];
5014
5015         ofputil_port_to_string(ofbundle_get_a_port(bundle)->up.ofp_port,
5016                                name, sizeof name);
5017         ds_put_format(&ds, "%5s  %4d  "ETH_ADDR_FMT"  %3d\n",
5018                       name, e->vlan, ETH_ADDR_ARGS(e->mac),
5019                       mac_entry_age(ofproto->ml, e));
5020     }
5021     ovs_rwlock_unlock(&ofproto->ml->rwlock);
5022     unixctl_command_reply(conn, ds_cstr(&ds));
5023     ds_destroy(&ds);
5024 }
5025
5026 struct trace_ctx {
5027     struct xlate_out xout;
5028     struct xlate_in xin;
5029     struct flow flow;
5030     struct ds *result;
5031 };
5032
5033 static void
5034 trace_format_rule(struct ds *result, int level, const struct rule_dpif *rule)
5035 {
5036     struct rule_actions *actions;
5037     ovs_be64 cookie;
5038
5039     ds_put_char_multiple(result, '\t', level);
5040     if (!rule) {
5041         ds_put_cstr(result, "No match\n");
5042         return;
5043     }
5044
5045     ovs_mutex_lock(&rule->up.mutex);
5046     cookie = rule->up.flow_cookie;
5047     ovs_mutex_unlock(&rule->up.mutex);
5048
5049     ds_put_format(result, "Rule: table=%"PRIu8" cookie=%#"PRIx64" ",
5050                   rule ? rule->up.table_id : 0, ntohll(cookie));
5051     cls_rule_format(&rule->up.cr, result);
5052     ds_put_char(result, '\n');
5053
5054     actions = rule_dpif_get_actions(rule);
5055
5056     ds_put_char_multiple(result, '\t', level);
5057     ds_put_cstr(result, "OpenFlow ");
5058     ofpacts_format(actions->ofpacts, actions->ofpacts_len, result);
5059     ds_put_char(result, '\n');
5060
5061     rule_actions_unref(actions);
5062 }
5063
5064 static void
5065 trace_format_flow(struct ds *result, int level, const char *title,
5066                   struct trace_ctx *trace)
5067 {
5068     ds_put_char_multiple(result, '\t', level);
5069     ds_put_format(result, "%s: ", title);
5070     if (flow_equal(&trace->xin.flow, &trace->flow)) {
5071         ds_put_cstr(result, "unchanged");
5072     } else {
5073         flow_format(result, &trace->xin.flow);
5074         trace->flow = trace->xin.flow;
5075     }
5076     ds_put_char(result, '\n');
5077 }
5078
5079 static void
5080 trace_format_regs(struct ds *result, int level, const char *title,
5081                   struct trace_ctx *trace)
5082 {
5083     size_t i;
5084
5085     ds_put_char_multiple(result, '\t', level);
5086     ds_put_format(result, "%s:", title);
5087     for (i = 0; i < FLOW_N_REGS; i++) {
5088         ds_put_format(result, " reg%zu=0x%"PRIx32, i, trace->flow.regs[i]);
5089     }
5090     ds_put_char(result, '\n');
5091 }
5092
5093 static void
5094 trace_format_odp(struct ds *result, int level, const char *title,
5095                  struct trace_ctx *trace)
5096 {
5097     struct ofpbuf *odp_actions = &trace->xout.odp_actions;
5098
5099     ds_put_char_multiple(result, '\t', level);
5100     ds_put_format(result, "%s: ", title);
5101     format_odp_actions(result, odp_actions->data, odp_actions->size);
5102     ds_put_char(result, '\n');
5103 }
5104
5105 static void
5106 trace_resubmit(struct xlate_in *xin, struct rule_dpif *rule, int recurse)
5107 {
5108     struct trace_ctx *trace = CONTAINER_OF(xin, struct trace_ctx, xin);
5109     struct ds *result = trace->result;
5110
5111     ds_put_char(result, '\n');
5112     trace_format_flow(result, recurse + 1, "Resubmitted flow", trace);
5113     trace_format_regs(result, recurse + 1, "Resubmitted regs", trace);
5114     trace_format_odp(result,  recurse + 1, "Resubmitted  odp", trace);
5115     trace_format_rule(result, recurse + 1, rule);
5116 }
5117
5118 static void
5119 trace_report(struct xlate_in *xin, const char *s, int recurse)
5120 {
5121     struct trace_ctx *trace = CONTAINER_OF(xin, struct trace_ctx, xin);
5122     struct ds *result = trace->result;
5123
5124     ds_put_char_multiple(result, '\t', recurse);
5125     ds_put_cstr(result, s);
5126     ds_put_char(result, '\n');
5127 }
5128
5129 static void
5130 ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[],
5131                       void *aux OVS_UNUSED)
5132 {
5133     const struct dpif_backer *backer = NULL;
5134     struct ofproto_dpif *ofproto;
5135     struct ofpbuf odp_key, odp_mask;
5136     struct ofpbuf *packet;
5137     struct ds result;
5138     struct flow flow;
5139     struct simap port_names;
5140     char *s;
5141
5142     packet = NULL;
5143     backer = NULL;
5144     ds_init(&result);
5145     ofpbuf_init(&odp_key, 0);
5146     ofpbuf_init(&odp_mask, 0);
5147     simap_init(&port_names);
5148
5149     /* Handle "-generate" or a hex string as the last argument. */
5150     if (!strcmp(argv[argc - 1], "-generate")) {
5151         packet = ofpbuf_new(0);
5152         argc--;
5153     } else {
5154         const char *error = eth_from_hex(argv[argc - 1], &packet);
5155         if (!error) {
5156             argc--;
5157         } else if (argc == 4) {
5158             /* The 3-argument form must end in "-generate' or a hex string. */
5159             unixctl_command_reply_error(conn, error);
5160             goto exit;
5161         }
5162     }
5163
5164     /* odp_flow can have its in_port specified as a name instead of port no.
5165      * We do not yet know whether a given flow is a odp_flow or a br_flow.
5166      * But, to know whether a flow is odp_flow through odp_flow_from_string(),
5167      * we need to create a simap of name to port no. */
5168     if (argc == 3) {
5169         const char *dp_type;
5170         if (!strncmp(argv[1], "ovs-", 4)) {
5171             dp_type = argv[1] + 4;
5172         } else {
5173             dp_type = argv[1];
5174         }
5175         backer = shash_find_data(&all_dpif_backers, dp_type);
5176     } else {
5177         struct shash_node *node;
5178         if (shash_count(&all_dpif_backers) == 1) {
5179             node = shash_first(&all_dpif_backers);
5180             backer = node->data;
5181         }
5182     }
5183     if (backer && backer->dpif) {
5184         struct dpif_port dpif_port;
5185         struct dpif_port_dump port_dump;
5186         DPIF_PORT_FOR_EACH (&dpif_port, &port_dump, backer->dpif) {
5187             simap_put(&port_names, dpif_port.name,
5188                       odp_to_u32(dpif_port.port_no));
5189         }
5190     }
5191
5192     /* Parse the flow and determine whether a datapath or
5193      * bridge is specified. If function odp_flow_key_from_string()
5194      * returns 0, the flow is a odp_flow. If function
5195      * parse_ofp_exact_flow() returns 0, the flow is a br_flow. */
5196     if (!odp_flow_from_string(argv[argc - 1], &port_names, &odp_key, &odp_mask)) {
5197         if (!backer) {
5198             unixctl_command_reply_error(conn, "Cannot find the datapath");
5199             goto exit;
5200         }
5201
5202         if (xlate_receive(backer, NULL, odp_key.data, odp_key.size, &flow,
5203                           NULL, &ofproto, NULL)) {
5204             unixctl_command_reply_error(conn, "Invalid datapath flow");
5205             goto exit;
5206         }
5207         ds_put_format(&result, "Bridge: %s\n", ofproto->up.name);
5208     } else if (!parse_ofp_exact_flow(&flow, argv[argc - 1])) {
5209         if (argc != 3) {
5210             unixctl_command_reply_error(conn, "Must specify bridge name");
5211             goto exit;
5212         }
5213
5214         ofproto = ofproto_dpif_lookup(argv[1]);
5215         if (!ofproto) {
5216             unixctl_command_reply_error(conn, "Unknown bridge name");
5217             goto exit;
5218         }
5219     } else {
5220         unixctl_command_reply_error(conn, "Bad flow syntax");
5221         goto exit;
5222     }
5223
5224     /* Generate a packet, if requested. */
5225     if (packet) {
5226         if (!packet->size) {
5227             flow_compose(packet, &flow);
5228         } else {
5229             union flow_in_port in_port_;
5230
5231             in_port_ = flow.in_port;
5232             ds_put_cstr(&result, "Packet: ");
5233             s = ofp_packet_to_string(packet->data, packet->size);
5234             ds_put_cstr(&result, s);
5235             free(s);
5236
5237             /* Use the metadata from the flow and the packet argument
5238              * to reconstruct the flow. */
5239             flow_extract(packet, flow.skb_priority, flow.pkt_mark, NULL,
5240                          &in_port_, &flow);
5241         }
5242     }
5243
5244     ofproto_trace(ofproto, &flow, packet, &result);
5245     unixctl_command_reply(conn, ds_cstr(&result));
5246
5247 exit:
5248     ds_destroy(&result);
5249     ofpbuf_delete(packet);
5250     ofpbuf_uninit(&odp_key);
5251     ofpbuf_uninit(&odp_mask);
5252     simap_destroy(&port_names);
5253 }
5254
5255 static void
5256 ofproto_trace(struct ofproto_dpif *ofproto, const struct flow *flow,
5257               const struct ofpbuf *packet, struct ds *ds)
5258 {
5259     struct rule_dpif *rule;
5260     struct flow_wildcards wc;
5261
5262     ds_put_cstr(ds, "Flow: ");
5263     flow_format(ds, flow);
5264     ds_put_char(ds, '\n');
5265
5266     flow_wildcards_init_catchall(&wc);
5267     rule_dpif_lookup(ofproto, flow, &wc, &rule);
5268
5269     trace_format_rule(ds, 0, rule);
5270     if (rule == ofproto->miss_rule) {
5271         ds_put_cstr(ds, "\nNo match, flow generates \"packet in\"s.\n");
5272     } else if (rule == ofproto->no_packet_in_rule) {
5273         ds_put_cstr(ds, "\nNo match, packets dropped because "
5274                     "OFPPC_NO_PACKET_IN is set on in_port.\n");
5275     } else if (rule == ofproto->drop_frags_rule) {
5276         ds_put_cstr(ds, "\nPackets dropped because they are IP fragments "
5277                     "and the fragment handling mode is \"drop\".\n");
5278     }
5279
5280     if (rule) {
5281         uint64_t odp_actions_stub[1024 / 8];
5282         struct ofpbuf odp_actions;
5283         struct trace_ctx trace;
5284         struct match match;
5285         uint8_t tcp_flags;
5286
5287         tcp_flags = packet ? packet_get_tcp_flags(packet, flow) : 0;
5288         trace.result = ds;
5289         trace.flow = *flow;
5290         ofpbuf_use_stub(&odp_actions,
5291                         odp_actions_stub, sizeof odp_actions_stub);
5292         xlate_in_init(&trace.xin, ofproto, flow, rule, tcp_flags, packet);
5293         trace.xin.resubmit_hook = trace_resubmit;
5294         trace.xin.report_hook = trace_report;
5295
5296         xlate_actions(&trace.xin, &trace.xout);
5297         flow_wildcards_or(&trace.xout.wc, &trace.xout.wc, &wc);
5298
5299         ds_put_char(ds, '\n');
5300         trace_format_flow(ds, 0, "Final flow", &trace);
5301
5302         match_init(&match, flow, &trace.xout.wc);
5303         ds_put_cstr(ds, "Relevant fields: ");
5304         match_format(&match, ds, OFP_DEFAULT_PRIORITY);
5305         ds_put_char(ds, '\n');
5306
5307         ds_put_cstr(ds, "Datapath actions: ");
5308         format_odp_actions(ds, trace.xout.odp_actions.data,
5309                            trace.xout.odp_actions.size);
5310
5311         if (trace.xout.slow) {
5312             ds_put_cstr(ds, "\nThis flow is handled by the userspace "
5313                         "slow path because it:");
5314             switch (trace.xout.slow) {
5315             case SLOW_CFM:
5316                 ds_put_cstr(ds, "\n\t- Consists of CFM packets.");
5317                 break;
5318             case SLOW_LACP:
5319                 ds_put_cstr(ds, "\n\t- Consists of LACP packets.");
5320                 break;
5321             case SLOW_STP:
5322                 ds_put_cstr(ds, "\n\t- Consists of STP packets.");
5323                 break;
5324             case SLOW_BFD:
5325                 ds_put_cstr(ds, "\n\t- Consists of BFD packets.");
5326                 break;
5327             case SLOW_CONTROLLER:
5328                 ds_put_cstr(ds, "\n\t- Sends \"packet-in\" messages "
5329                             "to the OpenFlow controller.");
5330                 break;
5331             case __SLOW_MAX:
5332                 NOT_REACHED();
5333             }
5334         }
5335
5336         xlate_out_uninit(&trace.xout);
5337     }
5338
5339     rule_dpif_unref(rule);
5340 }
5341
5342 /* Runs a self-check of flow translations in 'ofproto'.  Appends a message to
5343  * 'reply' describing the results. */
5344 static void
5345 ofproto_dpif_self_check__(struct ofproto_dpif *ofproto, struct ds *reply)
5346 {
5347     struct cls_cursor cursor;
5348     struct facet *facet;
5349     int errors;
5350
5351     errors = 0;
5352     ovs_rwlock_rdlock(&ofproto->facets.rwlock);
5353     cls_cursor_init(&cursor, &ofproto->facets, NULL);
5354     CLS_CURSOR_FOR_EACH (facet, cr, &cursor) {
5355         if (!facet_check_consistency(facet)) {
5356             errors++;
5357         }
5358     }
5359     ovs_rwlock_unlock(&ofproto->facets.rwlock);
5360     if (errors) {
5361         ofproto->backer->need_revalidate = REV_INCONSISTENCY;
5362     }
5363
5364     if (errors) {
5365         ds_put_format(reply, "%s: self-check failed (%d errors)\n",
5366                       ofproto->up.name, errors);
5367     } else {
5368         ds_put_format(reply, "%s: self-check passed\n", ofproto->up.name);
5369     }
5370 }
5371
5372 static void
5373 ofproto_dpif_self_check(struct unixctl_conn *conn,
5374                         int argc, const char *argv[], void *aux OVS_UNUSED)
5375 {
5376     struct ds reply = DS_EMPTY_INITIALIZER;
5377     struct ofproto_dpif *ofproto;
5378
5379     if (argc > 1) {
5380         ofproto = ofproto_dpif_lookup(argv[1]);
5381         if (!ofproto) {
5382             unixctl_command_reply_error(conn, "Unknown ofproto (use "
5383                                         "ofproto/list for help)");
5384             return;
5385         }
5386         ofproto_dpif_self_check__(ofproto, &reply);
5387     } else {
5388         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
5389             ofproto_dpif_self_check__(ofproto, &reply);
5390         }
5391     }
5392
5393     unixctl_command_reply(conn, ds_cstr(&reply));
5394     ds_destroy(&reply);
5395 }
5396
5397 /* Store the current ofprotos in 'ofproto_shash'.  Returns a sorted list
5398  * of the 'ofproto_shash' nodes.  It is the responsibility of the caller
5399  * to destroy 'ofproto_shash' and free the returned value. */
5400 static const struct shash_node **
5401 get_ofprotos(struct shash *ofproto_shash)
5402 {
5403     const struct ofproto_dpif *ofproto;
5404
5405     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
5406         char *name = xasprintf("%s@%s", ofproto->up.type, ofproto->up.name);
5407         shash_add_nocopy(ofproto_shash, name, ofproto);
5408     }
5409
5410     return shash_sort(ofproto_shash);
5411 }
5412
5413 static void
5414 ofproto_unixctl_dpif_dump_dps(struct unixctl_conn *conn, int argc OVS_UNUSED,
5415                               const char *argv[] OVS_UNUSED,
5416                               void *aux OVS_UNUSED)
5417 {
5418     struct ds ds = DS_EMPTY_INITIALIZER;
5419     struct shash ofproto_shash;
5420     const struct shash_node **sorted_ofprotos;
5421     int i;
5422
5423     shash_init(&ofproto_shash);
5424     sorted_ofprotos = get_ofprotos(&ofproto_shash);
5425     for (i = 0; i < shash_count(&ofproto_shash); i++) {
5426         const struct shash_node *node = sorted_ofprotos[i];
5427         ds_put_format(&ds, "%s\n", node->name);
5428     }
5429
5430     shash_destroy(&ofproto_shash);
5431     free(sorted_ofprotos);
5432
5433     unixctl_command_reply(conn, ds_cstr(&ds));
5434     ds_destroy(&ds);
5435 }
5436
5437 static void
5438 dpif_show_backer(const struct dpif_backer *backer, struct ds *ds)
5439 {
5440     const struct shash_node **ofprotos;
5441     struct ofproto_dpif *ofproto;
5442     struct shash ofproto_shash;
5443     uint64_t n_hit, n_missed;
5444     size_t i;
5445
5446     n_hit = n_missed = 0;
5447     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
5448         if (ofproto->backer == backer) {
5449             n_missed += ofproto->n_missed;
5450             n_hit += ofproto->n_hit;
5451         }
5452     }
5453
5454     ds_put_format(ds, "%s: hit:%"PRIu64" missed:%"PRIu64"\n",
5455                   dpif_name(backer->dpif), n_hit, n_missed);
5456     ds_put_format(ds, "\tflows: cur: %zu, avg: %u, max: %u,"
5457                   " life span: %lldms\n", hmap_count(&backer->subfacets),
5458                   backer->avg_n_subfacet, backer->max_n_subfacet,
5459                   backer->avg_subfacet_life);
5460
5461     shash_init(&ofproto_shash);
5462     ofprotos = get_ofprotos(&ofproto_shash);
5463     for (i = 0; i < shash_count(&ofproto_shash); i++) {
5464         struct ofproto_dpif *ofproto = ofprotos[i]->data;
5465         const struct shash_node **ports;
5466         size_t j;
5467
5468         if (ofproto->backer != backer) {
5469             continue;
5470         }
5471
5472         ds_put_format(ds, "\t%s: hit:%"PRIu64" missed:%"PRIu64"\n",
5473                       ofproto->up.name, ofproto->n_hit, ofproto->n_missed);
5474
5475         ports = shash_sort(&ofproto->up.port_by_name);
5476         for (j = 0; j < shash_count(&ofproto->up.port_by_name); j++) {
5477             const struct shash_node *node = ports[j];
5478             struct ofport *ofport = node->data;
5479             struct smap config;
5480             odp_port_t odp_port;
5481
5482             ds_put_format(ds, "\t\t%s %u/", netdev_get_name(ofport->netdev),
5483                           ofport->ofp_port);
5484
5485             odp_port = ofp_port_to_odp_port(ofproto, ofport->ofp_port);
5486             if (odp_port != ODPP_NONE) {
5487                 ds_put_format(ds, "%"PRIu32":", odp_port);
5488             } else {
5489                 ds_put_cstr(ds, "none:");
5490             }
5491
5492             ds_put_format(ds, " (%s", netdev_get_type(ofport->netdev));
5493
5494             smap_init(&config);
5495             if (!netdev_get_config(ofport->netdev, &config)) {
5496                 const struct smap_node **nodes;
5497                 size_t i;
5498
5499                 nodes = smap_sort(&config);
5500                 for (i = 0; i < smap_count(&config); i++) {
5501                     const struct smap_node *node = nodes[i];
5502                     ds_put_format(ds, "%c %s=%s", i ? ',' : ':',
5503                                   node->key, node->value);
5504                 }
5505                 free(nodes);
5506             }
5507             smap_destroy(&config);
5508
5509             ds_put_char(ds, ')');
5510             ds_put_char(ds, '\n');
5511         }
5512         free(ports);
5513     }
5514     shash_destroy(&ofproto_shash);
5515     free(ofprotos);
5516 }
5517
5518 static void
5519 ofproto_unixctl_dpif_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
5520                           const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
5521 {
5522     struct ds ds = DS_EMPTY_INITIALIZER;
5523     const struct shash_node **backers;
5524     int i;
5525
5526     backers = shash_sort(&all_dpif_backers);
5527     for (i = 0; i < shash_count(&all_dpif_backers); i++) {
5528         dpif_show_backer(backers[i]->data, &ds);
5529     }
5530     free(backers);
5531
5532     unixctl_command_reply(conn, ds_cstr(&ds));
5533     ds_destroy(&ds);
5534 }
5535
5536 /* Dump the megaflow (facet) cache.  This is useful to check the
5537  * correctness of flow wildcarding, since the same mechanism is used for
5538  * both xlate caching and kernel wildcarding.
5539  *
5540  * It's important to note that in the output the flow description uses
5541  * OpenFlow (OFP) ports, but the actions use datapath (ODP) ports.
5542  *
5543  * This command is only needed for advanced debugging, so it's not
5544  * documented in the man page. */
5545 static void
5546 ofproto_unixctl_dpif_dump_megaflows(struct unixctl_conn *conn,
5547                                     int argc OVS_UNUSED, const char *argv[],
5548                                     void *aux OVS_UNUSED)
5549 {
5550     struct ds ds = DS_EMPTY_INITIALIZER;
5551     const struct ofproto_dpif *ofproto;
5552     long long int now = time_msec();
5553     struct cls_cursor cursor;
5554     struct facet *facet;
5555
5556     ofproto = ofproto_dpif_lookup(argv[1]);
5557     if (!ofproto) {
5558         unixctl_command_reply_error(conn, "no such bridge");
5559         return;
5560     }
5561
5562     ovs_rwlock_rdlock(&ofproto->facets.rwlock);
5563     cls_cursor_init(&cursor, &ofproto->facets, NULL);
5564     CLS_CURSOR_FOR_EACH (facet, cr, &cursor) {
5565         cls_rule_format(&facet->cr, &ds);
5566         ds_put_cstr(&ds, ", ");
5567         ds_put_format(&ds, "n_subfacets:%zu, ", list_size(&facet->subfacets));
5568         ds_put_format(&ds, "used:%.3fs, ", (now - facet->used) / 1000.0);
5569         ds_put_cstr(&ds, "Datapath actions: ");
5570         if (facet->xout.slow) {
5571             uint64_t slow_path_stub[128 / 8];
5572             const struct nlattr *actions;
5573             size_t actions_len;
5574
5575             compose_slow_path(ofproto, &facet->flow, facet->xout.slow,
5576                               slow_path_stub, sizeof slow_path_stub,
5577                               &actions, &actions_len);
5578             format_odp_actions(&ds, actions, actions_len);
5579         } else {
5580             format_odp_actions(&ds, facet->xout.odp_actions.data,
5581                                facet->xout.odp_actions.size);
5582         }
5583         ds_put_cstr(&ds, "\n");
5584     }
5585     ovs_rwlock_unlock(&ofproto->facets.rwlock);
5586
5587     ds_chomp(&ds, '\n');
5588     unixctl_command_reply(conn, ds_cstr(&ds));
5589     ds_destroy(&ds);
5590 }
5591
5592 /* Disable using the megaflows.
5593  *
5594  * This command is only needed for advanced debugging, so it's not
5595  * documented in the man page. */
5596 static void
5597 ofproto_unixctl_dpif_disable_megaflows(struct unixctl_conn *conn,
5598                                        int argc OVS_UNUSED,
5599                                        const char *argv[] OVS_UNUSED,
5600                                        void *aux OVS_UNUSED)
5601 {
5602     struct ofproto_dpif *ofproto;
5603
5604     enable_megaflows = false;
5605
5606     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
5607         flush(&ofproto->up);
5608     }
5609
5610     unixctl_command_reply(conn, "megaflows disabled");
5611 }
5612
5613 /* Re-enable using megaflows.
5614  *
5615  * This command is only needed for advanced debugging, so it's not
5616  * documented in the man page. */
5617 static void
5618 ofproto_unixctl_dpif_enable_megaflows(struct unixctl_conn *conn,
5619                                       int argc OVS_UNUSED,
5620                                       const char *argv[] OVS_UNUSED,
5621                                       void *aux OVS_UNUSED)
5622 {
5623     struct ofproto_dpif *ofproto;
5624
5625     enable_megaflows = true;
5626
5627     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
5628         flush(&ofproto->up);
5629     }
5630
5631     unixctl_command_reply(conn, "megaflows enabled");
5632 }
5633
5634 static void
5635 ofproto_unixctl_dpif_dump_flows(struct unixctl_conn *conn,
5636                                 int argc OVS_UNUSED, const char *argv[],
5637                                 void *aux OVS_UNUSED)
5638 {
5639     struct ds ds = DS_EMPTY_INITIALIZER;
5640     const struct ofproto_dpif *ofproto;
5641     struct subfacet *subfacet;
5642
5643     ofproto = ofproto_dpif_lookup(argv[1]);
5644     if (!ofproto) {
5645         unixctl_command_reply_error(conn, "no such bridge");
5646         return;
5647     }
5648
5649     update_stats(ofproto->backer);
5650
5651     HMAP_FOR_EACH (subfacet, hmap_node, &ofproto->backer->subfacets) {
5652         struct facet *facet = subfacet->facet;
5653         struct odputil_keybuf maskbuf;
5654         struct ofpbuf mask;
5655
5656         if (facet->ofproto != ofproto) {
5657             continue;
5658         }
5659
5660         ofpbuf_use_stack(&mask, &maskbuf, sizeof maskbuf);
5661         if (enable_megaflows) {
5662             odp_flow_key_from_mask(&mask, &facet->xout.wc.masks,
5663                                    &facet->flow, UINT32_MAX);
5664         }
5665
5666         odp_flow_format(subfacet->key, subfacet->key_len,
5667                         mask.data, mask.size, NULL, &ds, false);
5668
5669         ds_put_format(&ds, ", packets:%"PRIu64", bytes:%"PRIu64", used:",
5670                       subfacet->dp_packet_count, subfacet->dp_byte_count);
5671         if (subfacet->used) {
5672             ds_put_format(&ds, "%.3fs",
5673                           (time_msec() - subfacet->used) / 1000.0);
5674         } else {
5675             ds_put_format(&ds, "never");
5676         }
5677         if (subfacet->facet->tcp_flags) {
5678             ds_put_cstr(&ds, ", flags:");
5679             packet_format_tcp_flags(&ds, subfacet->facet->tcp_flags);
5680         }
5681
5682         ds_put_cstr(&ds, ", actions:");
5683         if (facet->xout.slow) {
5684             uint64_t slow_path_stub[128 / 8];
5685             const struct nlattr *actions;
5686             size_t actions_len;
5687
5688             compose_slow_path(ofproto, &facet->flow, facet->xout.slow,
5689                               slow_path_stub, sizeof slow_path_stub,
5690                               &actions, &actions_len);
5691             format_odp_actions(&ds, actions, actions_len);
5692         } else {
5693             format_odp_actions(&ds, facet->xout.odp_actions.data,
5694                                facet->xout.odp_actions.size);
5695         }
5696         ds_put_char(&ds, '\n');
5697     }
5698
5699     unixctl_command_reply(conn, ds_cstr(&ds));
5700     ds_destroy(&ds);
5701 }
5702
5703 static void
5704 ofproto_unixctl_dpif_del_flows(struct unixctl_conn *conn,
5705                                int argc OVS_UNUSED, const char *argv[],
5706                                void *aux OVS_UNUSED)
5707 {
5708     struct ds ds = DS_EMPTY_INITIALIZER;
5709     struct ofproto_dpif *ofproto;
5710
5711     ofproto = ofproto_dpif_lookup(argv[1]);
5712     if (!ofproto) {
5713         unixctl_command_reply_error(conn, "no such bridge");
5714         return;
5715     }
5716
5717     flush(&ofproto->up);
5718
5719     unixctl_command_reply(conn, ds_cstr(&ds));
5720     ds_destroy(&ds);
5721 }
5722
5723 static void
5724 ofproto_dpif_unixctl_init(void)
5725 {
5726     static bool registered;
5727     if (registered) {
5728         return;
5729     }
5730     registered = true;
5731
5732     unixctl_command_register(
5733         "ofproto/trace",
5734         "[dp_name]|bridge odp_flow|br_flow [-generate|packet]",
5735         1, 3, ofproto_unixctl_trace, NULL);
5736     unixctl_command_register("fdb/flush", "[bridge]", 0, 1,
5737                              ofproto_unixctl_fdb_flush, NULL);
5738     unixctl_command_register("fdb/show", "bridge", 1, 1,
5739                              ofproto_unixctl_fdb_show, NULL);
5740     unixctl_command_register("ofproto/self-check", "[bridge]", 0, 1,
5741                              ofproto_dpif_self_check, NULL);
5742     unixctl_command_register("dpif/dump-dps", "", 0, 0,
5743                              ofproto_unixctl_dpif_dump_dps, NULL);
5744     unixctl_command_register("dpif/show", "", 0, 0, ofproto_unixctl_dpif_show,
5745                              NULL);
5746     unixctl_command_register("dpif/dump-flows", "bridge", 1, 1,
5747                              ofproto_unixctl_dpif_dump_flows, NULL);
5748     unixctl_command_register("dpif/del-flows", "bridge", 1, 1,
5749                              ofproto_unixctl_dpif_del_flows, NULL);
5750     unixctl_command_register("dpif/dump-megaflows", "bridge", 1, 1,
5751                              ofproto_unixctl_dpif_dump_megaflows, NULL);
5752     unixctl_command_register("dpif/disable-megaflows", "", 0, 0,
5753                              ofproto_unixctl_dpif_disable_megaflows, NULL);
5754     unixctl_command_register("dpif/enable-megaflows", "", 0, 0,
5755                              ofproto_unixctl_dpif_enable_megaflows, NULL);
5756 }
5757 \f
5758 /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
5759  *
5760  * This is deprecated.  It is only for compatibility with broken device drivers
5761  * in old versions of Linux that do not properly support VLANs when VLAN
5762  * devices are not used.  When broken device drivers are no longer in
5763  * widespread use, we will delete these interfaces. */
5764
5765 static int
5766 set_realdev(struct ofport *ofport_, ofp_port_t realdev_ofp_port, int vid)
5767 {
5768     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport_->ofproto);
5769     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
5770
5771     if (realdev_ofp_port == ofport->realdev_ofp_port
5772         && vid == ofport->vlandev_vid) {
5773         return 0;
5774     }
5775
5776     ofproto->backer->need_revalidate = REV_RECONFIGURE;
5777
5778     if (ofport->realdev_ofp_port) {
5779         vsp_remove(ofport);
5780     }
5781     if (realdev_ofp_port && ofport->bundle) {
5782         /* vlandevs are enslaved to their realdevs, so they are not allowed to
5783          * themselves be part of a bundle. */
5784         bundle_set(ofport->up.ofproto, ofport->bundle, NULL);
5785     }
5786
5787     ofport->realdev_ofp_port = realdev_ofp_port;
5788     ofport->vlandev_vid = vid;
5789
5790     if (realdev_ofp_port) {
5791         vsp_add(ofport, realdev_ofp_port, vid);
5792     }
5793
5794     return 0;
5795 }
5796
5797 static uint32_t
5798 hash_realdev_vid(ofp_port_t realdev_ofp_port, int vid)
5799 {
5800     return hash_2words(ofp_to_u16(realdev_ofp_port), vid);
5801 }
5802
5803 bool
5804 ofproto_has_vlan_splinters(const struct ofproto_dpif *ofproto)
5805     OVS_EXCLUDED(ofproto->vsp_mutex)
5806 {
5807     bool ret;
5808
5809     ovs_mutex_lock(&ofproto->vsp_mutex);
5810     ret = !hmap_is_empty(&ofproto->realdev_vid_map);
5811     ovs_mutex_unlock(&ofproto->vsp_mutex);
5812     return ret;
5813 }
5814
5815 static ofp_port_t
5816 vsp_realdev_to_vlandev__(const struct ofproto_dpif *ofproto,
5817                          ofp_port_t realdev_ofp_port, ovs_be16 vlan_tci)
5818     OVS_REQUIRES(ofproto->vsp_mutex)
5819 {
5820     if (!hmap_is_empty(&ofproto->realdev_vid_map)) {
5821         int vid = vlan_tci_to_vid(vlan_tci);
5822         const struct vlan_splinter *vsp;
5823
5824         HMAP_FOR_EACH_WITH_HASH (vsp, realdev_vid_node,
5825                                  hash_realdev_vid(realdev_ofp_port, vid),
5826                                  &ofproto->realdev_vid_map) {
5827             if (vsp->realdev_ofp_port == realdev_ofp_port
5828                 && vsp->vid == vid) {
5829                 return vsp->vlandev_ofp_port;
5830             }
5831         }
5832     }
5833     return realdev_ofp_port;
5834 }
5835
5836 /* Returns the OFP port number of the Linux VLAN device that corresponds to
5837  * 'vlan_tci' on the network device with port number 'realdev_ofp_port' in
5838  * 'struct ofport_dpif'.  For example, given 'realdev_ofp_port' of eth0 and
5839  * 'vlan_tci' 9, it would return the port number of eth0.9.
5840  *
5841  * Unless VLAN splinters are enabled for port 'realdev_ofp_port', this
5842  * function just returns its 'realdev_ofp_port' argument. */
5843 ofp_port_t
5844 vsp_realdev_to_vlandev(const struct ofproto_dpif *ofproto,
5845                        ofp_port_t realdev_ofp_port, ovs_be16 vlan_tci)
5846     OVS_EXCLUDED(ofproto->vsp_mutex)
5847 {
5848     ofp_port_t ret;
5849
5850     ovs_mutex_lock(&ofproto->vsp_mutex);
5851     ret = vsp_realdev_to_vlandev__(ofproto, realdev_ofp_port, vlan_tci);
5852     ovs_mutex_unlock(&ofproto->vsp_mutex);
5853     return ret;
5854 }
5855
5856 static struct vlan_splinter *
5857 vlandev_find(const struct ofproto_dpif *ofproto, ofp_port_t vlandev_ofp_port)
5858 {
5859     struct vlan_splinter *vsp;
5860
5861     HMAP_FOR_EACH_WITH_HASH (vsp, vlandev_node,
5862                              hash_ofp_port(vlandev_ofp_port),
5863                              &ofproto->vlandev_map) {
5864         if (vsp->vlandev_ofp_port == vlandev_ofp_port) {
5865             return vsp;
5866         }
5867     }
5868
5869     return NULL;
5870 }
5871
5872 /* Returns the OpenFlow port number of the "real" device underlying the Linux
5873  * VLAN device with OpenFlow port number 'vlandev_ofp_port' and stores the
5874  * VLAN VID of the Linux VLAN device in '*vid'.  For example, given
5875  * 'vlandev_ofp_port' of eth0.9, it would return the OpenFlow port number of
5876  * eth0 and store 9 in '*vid'.
5877  *
5878  * Returns 0 and does not modify '*vid' if 'vlandev_ofp_port' is not a Linux
5879  * VLAN device.  Unless VLAN splinters are enabled, this is what this function
5880  * always does.*/
5881 static ofp_port_t
5882 vsp_vlandev_to_realdev(const struct ofproto_dpif *ofproto,
5883                        ofp_port_t vlandev_ofp_port, int *vid)
5884     OVS_REQUIRES(ofproto->vsp_mutex)
5885 {
5886     if (!hmap_is_empty(&ofproto->vlandev_map)) {
5887         const struct vlan_splinter *vsp;
5888
5889         vsp = vlandev_find(ofproto, vlandev_ofp_port);
5890         if (vsp) {
5891             if (vid) {
5892                 *vid = vsp->vid;
5893             }
5894             return vsp->realdev_ofp_port;
5895         }
5896     }
5897     return 0;
5898 }
5899
5900 /* Given 'flow', a flow representing a packet received on 'ofproto', checks
5901  * whether 'flow->in_port' represents a Linux VLAN device.  If so, changes
5902  * 'flow->in_port' to the "real" device backing the VLAN device, sets
5903  * 'flow->vlan_tci' to the VLAN VID, and returns true.  Otherwise (which is
5904  * always the case unless VLAN splinters are enabled), returns false without
5905  * making any changes. */
5906 bool
5907 vsp_adjust_flow(const struct ofproto_dpif *ofproto, struct flow *flow)
5908     OVS_EXCLUDED(ofproto->vsp_mutex)
5909 {
5910     ofp_port_t realdev;
5911     int vid;
5912
5913     ovs_mutex_lock(&ofproto->vsp_mutex);
5914     realdev = vsp_vlandev_to_realdev(ofproto, flow->in_port.ofp_port, &vid);
5915     ovs_mutex_unlock(&ofproto->vsp_mutex);
5916     if (!realdev) {
5917         return false;
5918     }
5919
5920     /* Cause the flow to be processed as if it came in on the real device with
5921      * the VLAN device's VLAN ID. */
5922     flow->in_port.ofp_port = realdev;
5923     flow->vlan_tci = htons((vid & VLAN_VID_MASK) | VLAN_CFI);
5924     return true;
5925 }
5926
5927 static void
5928 vsp_remove(struct ofport_dpif *port)
5929 {
5930     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
5931     struct vlan_splinter *vsp;
5932
5933     ovs_mutex_lock(&ofproto->vsp_mutex);
5934     vsp = vlandev_find(ofproto, port->up.ofp_port);
5935     if (vsp) {
5936         hmap_remove(&ofproto->vlandev_map, &vsp->vlandev_node);
5937         hmap_remove(&ofproto->realdev_vid_map, &vsp->realdev_vid_node);
5938         free(vsp);
5939
5940         port->realdev_ofp_port = 0;
5941     } else {
5942         VLOG_ERR("missing vlan device record");
5943     }
5944     ovs_mutex_unlock(&ofproto->vsp_mutex);
5945 }
5946
5947 static void
5948 vsp_add(struct ofport_dpif *port, ofp_port_t realdev_ofp_port, int vid)
5949 {
5950     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
5951
5952     ovs_mutex_lock(&ofproto->vsp_mutex);
5953     if (!vsp_vlandev_to_realdev(ofproto, port->up.ofp_port, NULL)
5954         && (vsp_realdev_to_vlandev__(ofproto, realdev_ofp_port, htons(vid))
5955             == realdev_ofp_port)) {
5956         struct vlan_splinter *vsp;
5957
5958         vsp = xmalloc(sizeof *vsp);
5959         vsp->realdev_ofp_port = realdev_ofp_port;
5960         vsp->vlandev_ofp_port = port->up.ofp_port;
5961         vsp->vid = vid;
5962
5963         port->realdev_ofp_port = realdev_ofp_port;
5964
5965         hmap_insert(&ofproto->vlandev_map, &vsp->vlandev_node,
5966                     hash_ofp_port(port->up.ofp_port));
5967         hmap_insert(&ofproto->realdev_vid_map, &vsp->realdev_vid_node,
5968                     hash_realdev_vid(realdev_ofp_port, vid));
5969     } else {
5970         VLOG_ERR("duplicate vlan device record");
5971     }
5972     ovs_mutex_unlock(&ofproto->vsp_mutex);
5973 }
5974
5975 static odp_port_t
5976 ofp_port_to_odp_port(const struct ofproto_dpif *ofproto, ofp_port_t ofp_port)
5977 {
5978     const struct ofport_dpif *ofport = get_ofp_port(ofproto, ofp_port);
5979     return ofport ? ofport->odp_port : ODPP_NONE;
5980 }
5981
5982 struct ofport_dpif *
5983 odp_port_to_ofport(const struct dpif_backer *backer, odp_port_t odp_port)
5984 {
5985     struct ofport_dpif *port;
5986
5987     ovs_rwlock_rdlock(&backer->odp_to_ofport_lock);
5988     HMAP_FOR_EACH_IN_BUCKET (port, odp_port_node, hash_odp_port(odp_port),
5989                              &backer->odp_to_ofport_map) {
5990         if (port->odp_port == odp_port) {
5991             ovs_rwlock_unlock(&backer->odp_to_ofport_lock);
5992             return port;
5993         }
5994     }
5995
5996     ovs_rwlock_unlock(&backer->odp_to_ofport_lock);
5997     return NULL;
5998 }
5999
6000 static ofp_port_t
6001 odp_port_to_ofp_port(const struct ofproto_dpif *ofproto, odp_port_t odp_port)
6002 {
6003     struct ofport_dpif *port;
6004
6005     port = odp_port_to_ofport(ofproto->backer, odp_port);
6006     if (port && &ofproto->up == port->up.ofproto) {
6007         return port->up.ofp_port;
6008     } else {
6009         return OFPP_NONE;
6010     }
6011 }
6012
6013 const struct ofproto_class ofproto_dpif_class = {
6014     init,
6015     enumerate_types,
6016     enumerate_names,
6017     del,
6018     port_open_type,
6019     type_run,
6020     type_run_fast,
6021     type_wait,
6022     alloc,
6023     construct,
6024     destruct,
6025     dealloc,
6026     run,
6027     run_fast,
6028     wait,
6029     get_memory_usage,
6030     flush,
6031     get_features,
6032     get_tables,
6033     port_alloc,
6034     port_construct,
6035     port_destruct,
6036     port_dealloc,
6037     port_modified,
6038     port_reconfigured,
6039     port_query_by_name,
6040     port_add,
6041     port_del,
6042     port_get_stats,
6043     port_dump_start,
6044     port_dump_next,
6045     port_dump_done,
6046     port_poll,
6047     port_poll_wait,
6048     port_is_lacp_current,
6049     NULL,                       /* rule_choose_table */
6050     rule_alloc,
6051     rule_construct,
6052     rule_insert,
6053     rule_delete,
6054     rule_destruct,
6055     rule_dealloc,
6056     rule_get_stats,
6057     rule_execute,
6058     rule_modify_actions,
6059     set_frag_handling,
6060     packet_out,
6061     set_netflow,
6062     get_netflow_ids,
6063     set_sflow,
6064     set_ipfix,
6065     set_cfm,
6066     get_cfm_status,
6067     set_bfd,
6068     get_bfd_status,
6069     set_stp,
6070     get_stp_status,
6071     set_stp_port,
6072     get_stp_port_status,
6073     set_queues,
6074     bundle_set,
6075     bundle_remove,
6076     mirror_set__,
6077     mirror_get_stats__,
6078     set_flood_vlans,
6079     is_mirror_output_bundle,
6080     forward_bpdu_changed,
6081     set_mac_table_config,
6082     set_realdev,
6083     NULL,                       /* meter_get_features */
6084     NULL,                       /* meter_set */
6085     NULL,                       /* meter_get */
6086     NULL,                       /* meter_del */
6087     NULL,                       /* group_alloc */
6088     NULL,                       /* group_construct */
6089     NULL,                       /* group_destruct */
6090     NULL,                       /* group_dealloc */
6091     NULL,                       /* group_modify */
6092     NULL,                       /* group_get_stats */
6093 };