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