ofproto/ofproto-dpif.c

   1 /*
   2  * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 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-ipfix.h"
  54 #include "ofproto-dpif-mirror.h"
  55 #include "ofproto-dpif-monitor.h"
  56 #include "ofproto-dpif-sflow.h"
  57 #include "ofproto-dpif-upcall.h"
  58 #include "ofproto-dpif-xlate.h"
  59 #include "poll-loop.h"
  60 #include "seq.h"
  61 #include "simap.h"
  62 #include "smap.h"
  63 #include "timer.h"
  64 #include "tunnel.h"
  65 #include "unaligned.h"
  66 #include "unixctl.h"
  67 #include "vlan-bitmap.h"
  68 #include "vlog.h"
  69
  70 VLOG_DEFINE_THIS_MODULE(ofproto_dpif);
  71
  72 COVERAGE_DEFINE(ofproto_dpif_expired);
  73 COVERAGE_DEFINE(packet_in_overflow);
  74
  75 /* Number of implemented OpenFlow tables. */
  76 enum { N_TABLES = 255 };
  77 enum { TBL_INTERNAL = N_TABLES - 1 };    /* Used for internal hidden rules. */
  78 BUILD_ASSERT_DECL(N_TABLES >= 2 && N_TABLES <= 255);
  79
  80 struct flow_miss;
  81
  82 struct rule_dpif {
  83     struct rule up;
  84
  85     /* These statistics:
  86      *
  87      *   - Do include packets and bytes from datapath flows which have not
  88      *   recently been processed by a revalidator. */
  89     struct ovs_mutex stats_mutex;
  90     struct dpif_flow_stats stats OVS_GUARDED;
  91 };
  92
  93 static void rule_get_stats(struct rule *, uint64_t *packets, uint64_t *bytes,
  94                            long long int *used);
  95 static struct rule_dpif *rule_dpif_cast(const struct rule *);
  96 static void rule_expire(struct rule_dpif *);
  97
  98 struct group_dpif {
  99     struct ofgroup up;
 100
 101     /* These statistics:
 102      *
 103      *   - Do include packets and bytes from datapath flows which have not
 104      *   recently been processed by a revalidator. */
 105     struct ovs_mutex stats_mutex;
 106     uint64_t packet_count OVS_GUARDED;  /* Number of packets received. */
 107     uint64_t byte_count OVS_GUARDED;    /* Number of bytes received. */
 108     struct bucket_counter *bucket_stats OVS_GUARDED;  /* Bucket statistics. */
 109 };
 110
 111 struct ofbundle {
 112     struct hmap_node hmap_node; /* In struct ofproto's "bundles" hmap. */
 113     struct ofproto_dpif *ofproto; /* Owning ofproto. */
 114     void *aux;                  /* Key supplied by ofproto's client. */
 115     char *name;                 /* Identifier for log messages. */
 116
 117     /* Configuration. */
 118     struct list ports;          /* Contains "struct ofport"s. */
 119     enum port_vlan_mode vlan_mode; /* VLAN mode */
 120     int vlan;                   /* -1=trunk port, else a 12-bit VLAN ID. */
 121     unsigned long *trunks;      /* Bitmap of trunked VLANs, if 'vlan' == -1.
 122                                  * NULL if all VLANs are trunked. */
 123     struct lacp *lacp;          /* LACP if LACP is enabled, otherwise NULL. */
 124     struct bond *bond;          /* Nonnull iff more than one port. */
 125     bool use_priority_tags;     /* Use 802.1p tag for frames in VLAN 0? */
 126
 127     /* Status. */
 128     bool floodable;          /* True if no port has OFPUTIL_PC_NO_FLOOD set. */
 129 };
 130
 131 static void bundle_remove(struct ofport *);
 132 static void bundle_update(struct ofbundle *);
 133 static void bundle_destroy(struct ofbundle *);
 134 static void bundle_del_port(struct ofport_dpif *);
 135 static void bundle_run(struct ofbundle *);
 136 static void bundle_wait(struct ofbundle *);
 137
 138 static void stp_run(struct ofproto_dpif *ofproto);
 139 static void stp_wait(struct ofproto_dpif *ofproto);
 140 static int set_stp_port(struct ofport *,
 141                         const struct ofproto_port_stp_settings *);
 142
 143 struct ofport_dpif {
 144     struct hmap_node odp_port_node; /* In dpif_backer's "odp_to_ofport_map". */
 145     struct ofport up;
 146
 147     odp_port_t odp_port;
 148     struct ofbundle *bundle;    /* Bundle that contains this port, if any. */
 149     struct list bundle_node;    /* In struct ofbundle's "ports" list. */
 150     struct cfm *cfm;            /* Connectivity Fault Management, if any. */
 151     struct bfd *bfd;            /* BFD, if any. */
 152     bool may_enable;            /* May be enabled in bonds. */
 153     bool is_tunnel;             /* This port is a tunnel. */
 154     bool is_layer3;             /* This is a layer 3 port. */
 155     long long int carrier_seq;  /* Carrier status changes. */
 156     struct ofport_dpif *peer;   /* Peer if patch port. */
 157
 158     /* Spanning tree. */
 159     struct stp_port *stp_port;  /* Spanning Tree Protocol, if any. */
 160     enum stp_state stp_state;   /* Always STP_DISABLED if STP not in use. */
 161     long long int stp_state_entered;
 162
 163     /* Queue to DSCP mapping. */
 164     struct ofproto_port_queue *qdscp;
 165     size_t n_qdscp;
 166
 167     /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
 168      *
 169      * This is deprecated.  It is only for compatibility with broken device
 170      * drivers in old versions of Linux that do not properly support VLANs when
 171      * VLAN devices are not used.  When broken device drivers are no longer in
 172      * widespread use, we will delete these interfaces. */
 173     ofp_port_t realdev_ofp_port;
 174     int vlandev_vid;
 175 };
 176
 177 /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
 178  *
 179  * This is deprecated.  It is only for compatibility with broken device drivers
 180  * in old versions of Linux that do not properly support VLANs when VLAN
 181  * devices are not used.  When broken device drivers are no longer in
 182  * widespread use, we will delete these interfaces. */
 183 struct vlan_splinter {
 184     struct hmap_node realdev_vid_node;
 185     struct hmap_node vlandev_node;
 186     ofp_port_t realdev_ofp_port;
 187     ofp_port_t vlandev_ofp_port;
 188     int vid;
 189 };
 190
 191 static void vsp_remove(struct ofport_dpif *);
 192 static void vsp_add(struct ofport_dpif *, ofp_port_t realdev_ofp_port, int vid);
 193
 194 static odp_port_t ofp_port_to_odp_port(const struct ofproto_dpif *,
 195                                        ofp_port_t);
 196
 197 static ofp_port_t odp_port_to_ofp_port(const struct ofproto_dpif *,
 198                                        odp_port_t);
 199
 200 static struct ofport_dpif *
 201 ofport_dpif_cast(const struct ofport *ofport)
 202 {
 203     return ofport ? CONTAINER_OF(ofport, struct ofport_dpif, up) : NULL;
 204 }
 205
 206 static void port_run(struct ofport_dpif *);
 207 static int set_bfd(struct ofport *, const struct smap *);
 208 static int set_cfm(struct ofport *, const struct cfm_settings *);
 209 static void ofport_update_peer(struct ofport_dpif *);
 210
 211 struct dpif_completion {
 212     struct list list_node;
 213     struct ofoperation *op;
 214 };
 215
 216 /* Reasons that we might need to revalidate every datapath flow, and
 217  * corresponding coverage counters.
 218  *
 219  * A value of 0 means that there is no need to revalidate.
 220  *
 221  * It would be nice to have some cleaner way to integrate with coverage
 222  * counters, but with only a few reasons I guess this is good enough for
 223  * now. */
 224 enum revalidate_reason {
 225     REV_RECONFIGURE = 1,       /* Switch configuration changed. */
 226     REV_STP,                   /* Spanning tree protocol port status change. */
 227     REV_BOND,                  /* Bonding changed. */
 228     REV_PORT_TOGGLED,          /* Port enabled or disabled by CFM, LACP, ...*/
 229     REV_FLOW_TABLE,            /* Flow table changed. */
 230     REV_MAC_LEARNING,          /* Mac learning changed. */
 231 };
 232 COVERAGE_DEFINE(rev_reconfigure);
 233 COVERAGE_DEFINE(rev_stp);
 234 COVERAGE_DEFINE(rev_bond);
 235 COVERAGE_DEFINE(rev_port_toggled);
 236 COVERAGE_DEFINE(rev_flow_table);
 237 COVERAGE_DEFINE(rev_mac_learning);
 238
 239 /* All datapaths of a given type share a single dpif backer instance. */
 240 struct dpif_backer {
 241     char *type;
 242     int refcount;
 243     struct dpif *dpif;
 244     struct udpif *udpif;
 245
 246     struct ovs_rwlock odp_to_ofport_lock;
 247     struct hmap odp_to_ofport_map OVS_GUARDED; /* Contains "struct ofport"s. */
 248
 249     struct simap tnl_backers;      /* Set of dpif ports backing tunnels. */
 250
 251     enum revalidate_reason need_revalidate; /* Revalidate all flows. */
 252
 253     bool recv_set_enable; /* Enables or disables receiving packets. */
 254
 255     /* True if the datapath supports variable-length
 256      * OVS_USERSPACE_ATTR_USERDATA in OVS_ACTION_ATTR_USERSPACE actions.
 257      * False if the datapath supports only 8-byte (or shorter) userdata. */
 258     bool variable_length_userdata;
 259
 260     /* Maximum number of MPLS label stack entries that the datapath supports
 261      * in a match */
 262     size_t max_mpls_depth;
 263 };
 264
 265 /* All existing ofproto_backer instances, indexed by ofproto->up.type. */
 266 static struct shash all_dpif_backers = SHASH_INITIALIZER(&all_dpif_backers);
 267
 268 struct ofproto_dpif {
 269     struct hmap_node all_ofproto_dpifs_node; /* In 'all_ofproto_dpifs'. */
 270     struct ofproto up;
 271     struct dpif_backer *backer;
 272
 273     uint64_t dump_seq; /* Last read of udpif_dump_seq(). */
 274
 275     /* Special OpenFlow rules. */
 276     struct rule_dpif *miss_rule; /* Sends flow table misses to controller. */
 277     struct rule_dpif *no_packet_in_rule; /* Drops flow table misses. */
 278     struct rule_dpif *drop_frags_rule; /* Used in OFPC_FRAG_DROP mode. */
 279
 280     /* Bridging. */
 281     struct netflow *netflow;
 282     struct dpif_sflow *sflow;
 283     struct dpif_ipfix *ipfix;
 284     struct hmap bundles;        /* Contains "struct ofbundle"s. */
 285     struct mac_learning *ml;
 286     bool has_bonded_bundles;
 287     bool lacp_enabled;
 288     struct mbridge *mbridge;
 289
 290     struct ovs_mutex stats_mutex;
 291     struct netdev_stats stats OVS_GUARDED; /* To account packets generated and
 292                                             * consumed in userspace. */
 293
 294     /* Spanning tree. */
 295     struct stp *stp;
 296     long long int stp_last_tick;
 297
 298     /* VLAN splinters. */
 299     struct ovs_mutex vsp_mutex;
 300     struct hmap realdev_vid_map OVS_GUARDED; /* (realdev,vid) -> vlandev. */
 301     struct hmap vlandev_map OVS_GUARDED;     /* vlandev -> (realdev,vid). */
 302
 303     /* Ports. */
 304     struct sset ports;             /* Set of standard port names. */
 305     struct sset ghost_ports;       /* Ports with no datapath port. */
 306     struct sset port_poll_set;     /* Queued names for port_poll() reply. */
 307     int port_poll_errno;           /* Last errno for port_poll() reply. */
 308     uint64_t change_seq;           /* Connectivity status changes. */
 309
 310     /* Work queues. */
 311     struct guarded_list pins;      /* Contains "struct ofputil_packet_in"s. */
 312 };
 313
 314 /* All existing ofproto_dpif instances, indexed by ->up.name. */
 315 static struct hmap all_ofproto_dpifs = HMAP_INITIALIZER(&all_ofproto_dpifs);
 316
 317 static void ofproto_dpif_unixctl_init(void);
 318
 319 static inline struct ofproto_dpif *
 320 ofproto_dpif_cast(const struct ofproto *ofproto)
 321 {
 322     ovs_assert(ofproto->ofproto_class == &ofproto_dpif_class);
 323     return CONTAINER_OF(ofproto, struct ofproto_dpif, up);
 324 }
 325
 326 size_t
 327 ofproto_dpif_get_max_mpls_depth(const struct ofproto_dpif *ofproto)
 328 {
 329     return ofproto->backer->max_mpls_depth;
 330 }
 331
 332 static struct ofport_dpif *get_ofp_port(const struct ofproto_dpif *ofproto,
 333                                         ofp_port_t ofp_port);
 334 static void ofproto_trace(struct ofproto_dpif *, const struct flow *,
 335                           const struct ofpbuf *packet,
 336                           const struct ofpact[], size_t ofpacts_len,
 337                           struct ds *);
 338
 339 /* Global variables. */
 340 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 341
 342 /* Initial mappings of port to bridge mappings. */
 343 static struct shash init_ofp_ports = SHASH_INITIALIZER(&init_ofp_ports);
 344
 345 /* Executes 'fm'.  The caller retains ownership of 'fm' and everything in
 346  * it. */
 347 void
 348 ofproto_dpif_flow_mod(struct ofproto_dpif *ofproto,
 349                       struct ofputil_flow_mod *fm)
 350 {
 351     ofproto_flow_mod(&ofproto->up, fm);
 352 }
 353
 354 /* Appends 'pin' to the queue of "packet ins" to be sent to the controller.
 355  * Takes ownership of 'pin' and pin->packet. */
 356 void
 357 ofproto_dpif_send_packet_in(struct ofproto_dpif *ofproto,
 358                             struct ofproto_packet_in *pin)
 359 {
 360     if (!guarded_list_push_back(&ofproto->pins, &pin->list_node, 1024)) {
 361         COVERAGE_INC(packet_in_overflow);
 362         free(CONST_CAST(void *, pin->up.packet));
 363         free(pin);
 364     }
 365 }
 366 \f
 367 /* Factory functions. */
 368
 369 static void
 370 init(const struct shash *iface_hints)
 371 {
 372     struct shash_node *node;
 373
 374     /* Make a local copy, since we don't own 'iface_hints' elements. */
 375     SHASH_FOR_EACH(node, iface_hints) {
 376         const struct iface_hint *orig_hint = node->data;
 377         struct iface_hint *new_hint = xmalloc(sizeof *new_hint);
 378
 379         new_hint->br_name = xstrdup(orig_hint->br_name);
 380         new_hint->br_type = xstrdup(orig_hint->br_type);
 381         new_hint->ofp_port = orig_hint->ofp_port;
 382
 383         shash_add(&init_ofp_ports, node->name, new_hint);
 384     }
 385 }
 386
 387 static void
 388 enumerate_types(struct sset *types)
 389 {
 390     dp_enumerate_types(types);
 391 }
 392
 393 static int
 394 enumerate_names(const char *type, struct sset *names)
 395 {
 396     struct ofproto_dpif *ofproto;
 397
 398     sset_clear(names);
 399     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 400         if (strcmp(type, ofproto->up.type)) {
 401             continue;
 402         }
 403         sset_add(names, ofproto->up.name);
 404     }
 405
 406     return 0;
 407 }
 408
 409 static int
 410 del(const char *type, const char *name)
 411 {
 412     struct dpif *dpif;
 413     int error;
 414
 415     error = dpif_open(name, type, &dpif);
 416     if (!error) {
 417         error = dpif_delete(dpif);
 418         dpif_close(dpif);
 419     }
 420     return error;
 421 }
 422 \f
 423 static const char *
 424 port_open_type(const char *datapath_type, const char *port_type)
 425 {
 426     return dpif_port_open_type(datapath_type, port_type);
 427 }
 428
 429 /* Type functions. */
 430
 431 static void process_dpif_port_changes(struct dpif_backer *);
 432 static void process_dpif_all_ports_changed(struct dpif_backer *);
 433 static void process_dpif_port_change(struct dpif_backer *,
 434                                      const char *devname);
 435 static void process_dpif_port_error(struct dpif_backer *, int error);
 436
 437 static struct ofproto_dpif *
 438 lookup_ofproto_dpif_by_port_name(const char *name)
 439 {
 440     struct ofproto_dpif *ofproto;
 441
 442     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 443         if (sset_contains(&ofproto->ports, name)) {
 444             return ofproto;
 445         }
 446     }
 447
 448     return NULL;
 449 }
 450
 451 static int
 452 type_run(const char *type)
 453 {
 454     struct dpif_backer *backer;
 455
 456     backer = shash_find_data(&all_dpif_backers, type);
 457     if (!backer) {
 458         /* This is not necessarily a problem, since backers are only
 459          * created on demand. */
 460         return 0;
 461     }
 462
 463     dpif_run(backer->dpif);
 464
 465     /* If vswitchd started with other_config:flow_restore_wait set as "true",
 466      * and the configuration has now changed to "false", enable receiving
 467      * packets from the datapath. */
 468     if (!backer->recv_set_enable && !ofproto_get_flow_restore_wait()) {
 469         int error;
 470
 471         backer->recv_set_enable = true;
 472
 473         error = dpif_recv_set(backer->dpif, backer->recv_set_enable);
 474         if (error) {
 475             VLOG_ERR("Failed to enable receiving packets in dpif.");
 476             return error;
 477         }
 478         dpif_flow_flush(backer->dpif);
 479         backer->need_revalidate = REV_RECONFIGURE;
 480     }
 481
 482     if (backer->recv_set_enable) {
 483         udpif_set_threads(backer->udpif, n_handlers, n_revalidators);
 484     }
 485
 486     if (backer->need_revalidate) {
 487         struct ofproto_dpif *ofproto;
 488         struct simap_node *node;
 489         struct simap tmp_backers;
 490
 491         /* Handle tunnel garbage collection. */
 492         simap_init(&tmp_backers);
 493         simap_swap(&backer->tnl_backers, &tmp_backers);
 494
 495         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 496             struct ofport_dpif *iter;
 497
 498             if (backer != ofproto->backer) {
 499                 continue;
 500             }
 501
 502             HMAP_FOR_EACH (iter, up.hmap_node, &ofproto->up.ports) {
 503                 char namebuf[NETDEV_VPORT_NAME_BUFSIZE];
 504                 const char *dp_port;
 505
 506                 if (!iter->is_tunnel) {
 507                     continue;
 508                 }
 509
 510                 dp_port = netdev_vport_get_dpif_port(iter->up.netdev,
 511                                                      namebuf, sizeof namebuf);
 512                 node = simap_find(&tmp_backers, dp_port);
 513                 if (node) {
 514                     simap_put(&backer->tnl_backers, dp_port, node->data);
 515                     simap_delete(&tmp_backers, node);
 516                     node = simap_find(&backer->tnl_backers, dp_port);
 517                 } else {
 518                     node = simap_find(&backer->tnl_backers, dp_port);
 519                     if (!node) {
 520                         odp_port_t odp_port = ODPP_NONE;
 521
 522                         if (!dpif_port_add(backer->dpif, iter->up.netdev,
 523                                            &odp_port)) {
 524                             simap_put(&backer->tnl_backers, dp_port,
 525                                       odp_to_u32(odp_port));
 526                             node = simap_find(&backer->tnl_backers, dp_port);
 527                         }
 528                     }
 529                 }
 530
 531                 iter->odp_port = node ? u32_to_odp(node->data) : ODPP_NONE;
 532                 if (tnl_port_reconfigure(iter, iter->up.netdev,
 533                                          iter->odp_port)) {
 534                     backer->need_revalidate = REV_RECONFIGURE;
 535                 }
 536             }
 537         }
 538
 539         SIMAP_FOR_EACH (node, &tmp_backers) {
 540             dpif_port_del(backer->dpif, u32_to_odp(node->data));
 541         }
 542         simap_destroy(&tmp_backers);
 543
 544         switch (backer->need_revalidate) {
 545         case REV_RECONFIGURE:   COVERAGE_INC(rev_reconfigure);   break;
 546         case REV_STP:           COVERAGE_INC(rev_stp);           break;
 547         case REV_BOND:          COVERAGE_INC(rev_bond);          break;
 548         case REV_PORT_TOGGLED:  COVERAGE_INC(rev_port_toggled);  break;
 549         case REV_FLOW_TABLE:    COVERAGE_INC(rev_flow_table);    break;
 550         case REV_MAC_LEARNING:  COVERAGE_INC(rev_mac_learning);  break;
 551         }
 552         backer->need_revalidate = 0;
 553
 554         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 555             struct ofport_dpif *ofport;
 556             struct ofbundle *bundle;
 557
 558             if (ofproto->backer != backer) {
 559                 continue;
 560             }
 561
 562             ovs_rwlock_wrlock(&xlate_rwlock);
 563             xlate_ofproto_set(ofproto, ofproto->up.name,
 564                               ofproto->backer->dpif, ofproto->miss_rule,
 565                               ofproto->no_packet_in_rule, ofproto->ml,
 566                               ofproto->stp, ofproto->mbridge,
 567                               ofproto->sflow, ofproto->ipfix,
 568                               ofproto->netflow, ofproto->up.frag_handling,
 569                               ofproto->up.forward_bpdu,
 570                               connmgr_has_in_band(ofproto->up.connmgr),
 571                               ofproto->backer->variable_length_userdata,
 572                               ofproto->backer->max_mpls_depth);
 573
 574             HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
 575                 xlate_bundle_set(ofproto, bundle, bundle->name,
 576                                  bundle->vlan_mode, bundle->vlan,
 577                                  bundle->trunks, bundle->use_priority_tags,
 578                                  bundle->bond, bundle->lacp,
 579                                  bundle->floodable);
 580             }
 581
 582             HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
 583                 int stp_port = ofport->stp_port
 584                     ? stp_port_no(ofport->stp_port)
 585                     : -1;
 586                 xlate_ofport_set(ofproto, ofport->bundle, ofport,
 587                                  ofport->up.ofp_port, ofport->odp_port,
 588                                  ofport->up.netdev, ofport->cfm,
 589                                  ofport->bfd, ofport->peer, stp_port,
 590                                  ofport->qdscp, ofport->n_qdscp,
 591                                  ofport->up.pp.config, ofport->up.pp.state,
 592                                  ofport->is_tunnel, ofport->may_enable);
 593             }
 594             ovs_rwlock_unlock(&xlate_rwlock);
 595         }
 596
 597         udpif_revalidate(backer->udpif);
 598     }
 599
 600     process_dpif_port_changes(backer);
 601
 602     return 0;
 603 }
 604
 605 /* Check for and handle port changes in 'backer''s dpif. */
 606 static void
 607 process_dpif_port_changes(struct dpif_backer *backer)
 608 {
 609     for (;;) {
 610         char *devname;
 611         int error;
 612
 613         error = dpif_port_poll(backer->dpif, &devname);
 614         switch (error) {
 615         case EAGAIN:
 616             return;
 617
 618         case ENOBUFS:
 619             process_dpif_all_ports_changed(backer);
 620             break;
 621
 622         case 0:
 623             process_dpif_port_change(backer, devname);
 624             free(devname);
 625             break;
 626
 627         default:
 628             process_dpif_port_error(backer, error);
 629             break;
 630         }
 631     }
 632 }
 633
 634 static void
 635 process_dpif_all_ports_changed(struct dpif_backer *backer)
 636 {
 637     struct ofproto_dpif *ofproto;
 638     struct dpif_port dpif_port;
 639     struct dpif_port_dump dump;
 640     struct sset devnames;
 641     const char *devname;
 642
 643     sset_init(&devnames);
 644     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 645         if (ofproto->backer == backer) {
 646             struct ofport *ofport;
 647
 648             HMAP_FOR_EACH (ofport, hmap_node, &ofproto->up.ports) {
 649                 sset_add(&devnames, netdev_get_name(ofport->netdev));
 650             }
 651         }
 652     }
 653     DPIF_PORT_FOR_EACH (&dpif_port, &dump, backer->dpif) {
 654         sset_add(&devnames, dpif_port.name);
 655     }
 656
 657     SSET_FOR_EACH (devname, &devnames) {
 658         process_dpif_port_change(backer, devname);
 659     }
 660     sset_destroy(&devnames);
 661 }
 662
 663 static void
 664 process_dpif_port_change(struct dpif_backer *backer, const char *devname)
 665 {
 666     struct ofproto_dpif *ofproto;
 667     struct dpif_port port;
 668
 669     /* Don't report on the datapath's device. */
 670     if (!strcmp(devname, dpif_base_name(backer->dpif))) {
 671         return;
 672     }
 673
 674     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node,
 675                    &all_ofproto_dpifs) {
 676         if (simap_contains(&ofproto->backer->tnl_backers, devname)) {
 677             return;
 678         }
 679     }
 680
 681     ofproto = lookup_ofproto_dpif_by_port_name(devname);
 682     if (dpif_port_query_by_name(backer->dpif, devname, &port)) {
 683         /* The port was removed.  If we know the datapath,
 684          * report it through poll_set().  If we don't, it may be
 685          * notifying us of a removal we initiated, so ignore it.
 686          * If there's a pending ENOBUFS, let it stand, since
 687          * everything will be reevaluated. */
 688         if (ofproto && ofproto->port_poll_errno != ENOBUFS) {
 689             sset_add(&ofproto->port_poll_set, devname);
 690             ofproto->port_poll_errno = 0;
 691         }
 692     } else if (!ofproto) {
 693         /* The port was added, but we don't know with which
 694          * ofproto we should associate it.  Delete it. */
 695         dpif_port_del(backer->dpif, port.port_no);
 696     } else {
 697         struct ofport_dpif *ofport;
 698
 699         ofport = ofport_dpif_cast(shash_find_data(
 700                                       &ofproto->up.port_by_name, devname));
 701         if (ofport
 702             && ofport->odp_port != port.port_no
 703             && !odp_port_to_ofport(backer, port.port_no))
 704         {
 705             /* 'ofport''s datapath port number has changed from
 706              * 'ofport->odp_port' to 'port.port_no'.  Update our internal data
 707              * structures to match. */
 708             ovs_rwlock_wrlock(&backer->odp_to_ofport_lock);
 709             hmap_remove(&backer->odp_to_ofport_map, &ofport->odp_port_node);
 710             ofport->odp_port = port.port_no;
 711             hmap_insert(&backer->odp_to_ofport_map, &ofport->odp_port_node,
 712                         hash_odp_port(port.port_no));
 713             ovs_rwlock_unlock(&backer->odp_to_ofport_lock);
 714             backer->need_revalidate = REV_RECONFIGURE;
 715         }
 716     }
 717     dpif_port_destroy(&port);
 718 }
 719
 720 /* Propagate 'error' to all ofprotos based on 'backer'. */
 721 static void
 722 process_dpif_port_error(struct dpif_backer *backer, int error)
 723 {
 724     struct ofproto_dpif *ofproto;
 725
 726     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 727         if (ofproto->backer == backer) {
 728             sset_clear(&ofproto->port_poll_set);
 729             ofproto->port_poll_errno = error;
 730         }
 731     }
 732 }
 733
 734 static void
 735 type_wait(const char *type)
 736 {
 737     struct dpif_backer *backer;
 738
 739     backer = shash_find_data(&all_dpif_backers, type);
 740     if (!backer) {
 741         /* This is not necessarily a problem, since backers are only
 742          * created on demand. */
 743         return;
 744     }
 745
 746     dpif_wait(backer->dpif);
 747 }
 748 \f
 749 /* Basic life-cycle. */
 750
 751 static int add_internal_flows(struct ofproto_dpif *);
 752
 753 static struct ofproto *
 754 alloc(void)
 755 {
 756     struct ofproto_dpif *ofproto = xmalloc(sizeof *ofproto);
 757     return &ofproto->up;
 758 }
 759
 760 static void
 761 dealloc(struct ofproto *ofproto_)
 762 {
 763     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 764     free(ofproto);
 765 }
 766
 767 static void
 768 close_dpif_backer(struct dpif_backer *backer)
 769 {
 770     ovs_assert(backer->refcount > 0);
 771
 772     if (--backer->refcount) {
 773         return;
 774     }
 775
 776     udpif_destroy(backer->udpif);
 777
 778     simap_destroy(&backer->tnl_backers);
 779     ovs_rwlock_destroy(&backer->odp_to_ofport_lock);
 780     hmap_destroy(&backer->odp_to_ofport_map);
 781     shash_find_and_delete(&all_dpif_backers, backer->type);
 782     free(backer->type);
 783     dpif_close(backer->dpif);
 784
 785     free(backer);
 786 }
 787
 788 /* Datapath port slated for removal from datapath. */
 789 struct odp_garbage {
 790     struct list list_node;
 791     odp_port_t odp_port;
 792 };
 793
 794 static bool check_variable_length_userdata(struct dpif_backer *backer);
 795 static size_t check_max_mpls_depth(struct dpif_backer *backer);
 796
 797 static int
 798 open_dpif_backer(const char *type, struct dpif_backer **backerp)
 799 {
 800     struct dpif_backer *backer;
 801     struct dpif_port_dump port_dump;
 802     struct dpif_port port;
 803     struct shash_node *node;
 804     struct list garbage_list;
 805     struct odp_garbage *garbage, *next;
 806     struct sset names;
 807     char *backer_name;
 808     const char *name;
 809     int error;
 810
 811     backer = shash_find_data(&all_dpif_backers, type);
 812     if (backer) {
 813         backer->refcount++;
 814         *backerp = backer;
 815         return 0;
 816     }
 817
 818     backer_name = xasprintf("ovs-%s", type);
 819
 820     /* Remove any existing datapaths, since we assume we're the only
 821      * userspace controlling the datapath. */
 822     sset_init(&names);
 823     dp_enumerate_names(type, &names);
 824     SSET_FOR_EACH(name, &names) {
 825         struct dpif *old_dpif;
 826
 827         /* Don't remove our backer if it exists. */
 828         if (!strcmp(name, backer_name)) {
 829             continue;
 830         }
 831
 832         if (dpif_open(name, type, &old_dpif)) {
 833             VLOG_WARN("couldn't open old datapath %s to remove it", name);
 834         } else {
 835             dpif_delete(old_dpif);
 836             dpif_close(old_dpif);
 837         }
 838     }
 839     sset_destroy(&names);
 840
 841     backer = xmalloc(sizeof *backer);
 842
 843     error = dpif_create_and_open(backer_name, type, &backer->dpif);
 844     free(backer_name);
 845     if (error) {
 846         VLOG_ERR("failed to open datapath of type %s: %s", type,
 847                  ovs_strerror(error));
 848         free(backer);
 849         return error;
 850     }
 851     backer->udpif = udpif_create(backer, backer->dpif);
 852
 853     backer->type = xstrdup(type);
 854     backer->refcount = 1;
 855     hmap_init(&backer->odp_to_ofport_map);
 856     ovs_rwlock_init(&backer->odp_to_ofport_lock);
 857     backer->need_revalidate = 0;
 858     simap_init(&backer->tnl_backers);
 859     backer->recv_set_enable = !ofproto_get_flow_restore_wait();
 860     *backerp = backer;
 861
 862     if (backer->recv_set_enable) {
 863         dpif_flow_flush(backer->dpif);
 864     }
 865
 866     /* Loop through the ports already on the datapath and remove any
 867      * that we don't need anymore. */
 868     list_init(&garbage_list);
 869     dpif_port_dump_start(&port_dump, backer->dpif);
 870     while (dpif_port_dump_next(&port_dump, &port)) {
 871         node = shash_find(&init_ofp_ports, port.name);
 872         if (!node && strcmp(port.name, dpif_base_name(backer->dpif))) {
 873             garbage = xmalloc(sizeof *garbage);
 874             garbage->odp_port = port.port_no;
 875             list_push_front(&garbage_list, &garbage->list_node);
 876         }
 877     }
 878     dpif_port_dump_done(&port_dump);
 879
 880     LIST_FOR_EACH_SAFE (garbage, next, list_node, &garbage_list) {
 881         dpif_port_del(backer->dpif, garbage->odp_port);
 882         list_remove(&garbage->list_node);
 883         free(garbage);
 884     }
 885
 886     shash_add(&all_dpif_backers, type, backer);
 887
 888     error = dpif_recv_set(backer->dpif, backer->recv_set_enable);
 889     if (error) {
 890         VLOG_ERR("failed to listen on datapath of type %s: %s",
 891                  type, ovs_strerror(error));
 892         close_dpif_backer(backer);
 893         return error;
 894     }
 895     backer->variable_length_userdata = check_variable_length_userdata(backer);
 896     backer->max_mpls_depth = check_max_mpls_depth(backer);
 897
 898     if (backer->recv_set_enable) {
 899         udpif_set_threads(backer->udpif, n_handlers, n_revalidators);
 900     }
 901
 902     return error;
 903 }
 904
 905 /* Tests whether 'backer''s datapath supports variable-length
 906  * OVS_USERSPACE_ATTR_USERDATA in OVS_ACTION_ATTR_USERSPACE actions.  We need
 907  * to disable some features on older datapaths that don't support this
 908  * feature.
 909  *
 910  * Returns false if 'backer' definitely does not support variable-length
 911  * userdata, true if it seems to support them or if at least the error we get
 912  * is ambiguous. */
 913 static bool
 914 check_variable_length_userdata(struct dpif_backer *backer)
 915 {
 916     struct eth_header *eth;
 917     struct ofpbuf actions;
 918     struct dpif_execute execute;
 919     struct ofpbuf packet;
 920     size_t start;
 921     int error;
 922
 923     /* Compose a userspace action that will cause an ERANGE error on older
 924      * datapaths that don't support variable-length userdata.
 925      *
 926      * We really test for using userdata longer than 8 bytes, but older
 927      * datapaths accepted these, silently truncating the userdata to 8 bytes.
 928      * The same older datapaths rejected userdata shorter than 8 bytes, so we
 929      * test for that instead as a proxy for longer userdata support. */
 930     ofpbuf_init(&actions, 64);
 931     start = nl_msg_start_nested(&actions, OVS_ACTION_ATTR_USERSPACE);
 932     nl_msg_put_u32(&actions, OVS_USERSPACE_ATTR_PID,
 933                    dpif_port_get_pid(backer->dpif, ODPP_NONE));
 934     nl_msg_put_unspec_zero(&actions, OVS_USERSPACE_ATTR_USERDATA, 4);
 935     nl_msg_end_nested(&actions, start);
 936
 937     /* Compose a dummy ethernet packet. */
 938     ofpbuf_init(&packet, ETH_HEADER_LEN);
 939     eth = ofpbuf_put_zeros(&packet, ETH_HEADER_LEN);
 940     eth->eth_type = htons(0x1234);
 941
 942     /* Execute the actions.  On older datapaths this fails with ERANGE, on
 943      * newer datapaths it succeeds. */
 944     execute.actions = actions.data;
 945     execute.actions_len = actions.size;
 946     execute.packet = &packet;
 947     execute.md = PKT_METADATA_INITIALIZER(0);
 948     execute.needs_help = false;
 949
 950     error = dpif_execute(backer->dpif, &execute);
 951
 952     ofpbuf_uninit(&packet);
 953     ofpbuf_uninit(&actions);
 954
 955     switch (error) {
 956     case 0:
 957         /* Variable-length userdata is supported.
 958          *
 959          * Purge received packets to avoid processing the nonsense packet we
 960          * sent to userspace, then report success. */
 961         dpif_recv_purge(backer->dpif);
 962         return true;
 963
 964     case ERANGE:
 965         /* Variable-length userdata is not supported. */
 966         VLOG_WARN("%s: datapath does not support variable-length userdata "
 967                   "feature (needs Linux 3.10+ or kernel module from OVS "
 968                   "1..11+).  The NXAST_SAMPLE action will be ignored.",
 969                   dpif_name(backer->dpif));
 970         return false;
 971
 972     default:
 973         /* Something odd happened.  We're not sure whether variable-length
 974          * userdata is supported.  Default to "yes". */
 975         VLOG_WARN("%s: variable-length userdata feature probe failed (%s)",
 976                   dpif_name(backer->dpif), ovs_strerror(error));
 977         return true;
 978     }
 979 }
 980
 981 /* Tests the MPLS label stack depth supported by 'backer''s datapath.
 982  *
 983  * Returns the number of elements in a struct flow's mpls_lse field
 984  * if the datapath supports at least that many entries in an
 985  * MPLS label stack.
 986  * Otherwise returns the number of MPLS push actions supported by
 987  * the datapath. */
 988 static size_t
 989 check_max_mpls_depth(struct dpif_backer *backer)
 990 {
 991     struct flow flow;
 992     int n;
 993
 994     for (n = 0; n < FLOW_MAX_MPLS_LABELS; n++) {
 995         struct odputil_keybuf keybuf;
 996         struct ofpbuf key;
 997         int error;
 998
 999         memset(&flow, 0, sizeof flow);
1000         flow.dl_type = htons(ETH_TYPE_MPLS);
1001         flow_set_mpls_bos(&flow, n, 1);
1002
1003         ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
1004         odp_flow_key_from_flow(&key, &flow, 0);
1005
1006         error = dpif_flow_put(backer->dpif, DPIF_FP_CREATE | DPIF_FP_MODIFY,
1007                               key.data, key.size, NULL, 0, NULL, 0, NULL);
1008         if (error && error != EEXIST) {
1009             if (error != EINVAL) {
1010                 VLOG_WARN("%s: MPLS stack length feature probe failed (%s)",
1011                           dpif_name(backer->dpif), ovs_strerror(error));
1012             }
1013             break;
1014         }
1015
1016         error = dpif_flow_del(backer->dpif, key.data, key.size, NULL);
1017         if (error) {
1018             VLOG_WARN("%s: failed to delete MPLS feature probe flow",
1019                       dpif_name(backer->dpif));
1020         }
1021     }
1022
1023     VLOG_INFO("%s: MPLS label stack length probed as %d",
1024               dpif_name(backer->dpif), n);
1025     return n;
1026 }
1027
1028 static int
1029 construct(struct ofproto *ofproto_)
1030 {
1031     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1032     struct shash_node *node, *next;
1033     int error;
1034
1035     error = open_dpif_backer(ofproto->up.type, &ofproto->backer);
1036     if (error) {
1037         return error;
1038     }
1039
1040     ofproto->netflow = NULL;
1041     ofproto->sflow = NULL;
1042     ofproto->ipfix = NULL;
1043     ofproto->stp = NULL;
1044     ofproto->dump_seq = 0;
1045     hmap_init(&ofproto->bundles);
1046     ofproto->ml = mac_learning_create(MAC_ENTRY_DEFAULT_IDLE_TIME);
1047     ofproto->mbridge = mbridge_create();
1048     ofproto->has_bonded_bundles = false;
1049     ofproto->lacp_enabled = false;
1050     ovs_mutex_init_adaptive(&ofproto->stats_mutex);
1051     ovs_mutex_init(&ofproto->vsp_mutex);
1052
1053     guarded_list_init(&ofproto->pins);
1054
1055     ofproto_dpif_unixctl_init();
1056
1057     hmap_init(&ofproto->vlandev_map);
1058     hmap_init(&ofproto->realdev_vid_map);
1059
1060     sset_init(&ofproto->ports);
1061     sset_init(&ofproto->ghost_ports);
1062     sset_init(&ofproto->port_poll_set);
1063     ofproto->port_poll_errno = 0;
1064     ofproto->change_seq = 0;
1065
1066     SHASH_FOR_EACH_SAFE (node, next, &init_ofp_ports) {
1067         struct iface_hint *iface_hint = node->data;
1068
1069         if (!strcmp(iface_hint->br_name, ofproto->up.name)) {
1070             /* Check if the datapath already has this port. */
1071             if (dpif_port_exists(ofproto->backer->dpif, node->name)) {
1072                 sset_add(&ofproto->ports, node->name);
1073             }
1074
1075             free(iface_hint->br_name);
1076             free(iface_hint->br_type);
1077             free(iface_hint);
1078             shash_delete(&init_ofp_ports, node);
1079         }
1080     }
1081
1082     hmap_insert(&all_ofproto_dpifs, &ofproto->all_ofproto_dpifs_node,
1083                 hash_string(ofproto->up.name, 0));
1084     memset(&ofproto->stats, 0, sizeof ofproto->stats);
1085
1086     ofproto_init_tables(ofproto_, N_TABLES);
1087     error = add_internal_flows(ofproto);
1088     ofproto->up.tables[TBL_INTERNAL].flags = OFTABLE_HIDDEN | OFTABLE_READONLY;
1089
1090     return error;
1091 }
1092
1093 static int
1094 add_internal_flow(struct ofproto_dpif *ofproto, int id,
1095                   const struct ofpbuf *ofpacts, struct rule_dpif **rulep)
1096 {
1097     struct ofputil_flow_mod fm;
1098     int error;
1099
1100     match_init_catchall(&fm.match);
1101     fm.priority = 0;
1102     match_set_reg(&fm.match, 0, id);
1103     fm.new_cookie = htonll(0);
1104     fm.cookie = htonll(0);
1105     fm.cookie_mask = htonll(0);
1106     fm.modify_cookie = false;
1107     fm.table_id = TBL_INTERNAL;
1108     fm.command = OFPFC_ADD;
1109     fm.idle_timeout = 0;
1110     fm.hard_timeout = 0;
1111     fm.buffer_id = 0;
1112     fm.out_port = 0;
1113     fm.flags = 0;
1114     fm.ofpacts = ofpacts->data;
1115     fm.ofpacts_len = ofpacts->size;
1116
1117     error = ofproto_flow_mod(&ofproto->up, &fm);
1118     if (error) {
1119         VLOG_ERR_RL(&rl, "failed to add internal flow %d (%s)",
1120                     id, ofperr_to_string(error));
1121         return error;
1122     }
1123
1124     if (rule_dpif_lookup_in_table(ofproto, &fm.match.flow, NULL, TBL_INTERNAL,
1125                                   rulep)) {
1126         rule_dpif_unref(*rulep);
1127     } else {
1128         OVS_NOT_REACHED();
1129     }
1130
1131     return 0;
1132 }
1133
1134 static int
1135 add_internal_flows(struct ofproto_dpif *ofproto)
1136 {
1137     struct ofpact_controller *controller;
1138     uint64_t ofpacts_stub[128 / 8];
1139     struct ofpbuf ofpacts;
1140     int error;
1141     int id;
1142
1143     ofpbuf_use_stack(&ofpacts, ofpacts_stub, sizeof ofpacts_stub);
1144     id = 1;
1145
1146     controller = ofpact_put_CONTROLLER(&ofpacts);
1147     controller->max_len = UINT16_MAX;
1148     controller->controller_id = 0;
1149     controller->reason = OFPR_NO_MATCH;
1150     ofpact_pad(&ofpacts);
1151
1152     error = add_internal_flow(ofproto, id++, &ofpacts, &ofproto->miss_rule);
1153     if (error) {
1154         return error;
1155     }
1156
1157     ofpbuf_clear(&ofpacts);
1158     error = add_internal_flow(ofproto, id++, &ofpacts,
1159                               &ofproto->no_packet_in_rule);
1160     if (error) {
1161         return error;
1162     }
1163
1164     error = add_internal_flow(ofproto, id++, &ofpacts,
1165                               &ofproto->drop_frags_rule);
1166     return error;
1167 }
1168
1169 static void
1170 destruct(struct ofproto *ofproto_)
1171 {
1172     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1173     struct rule_dpif *rule, *next_rule;
1174     struct ofproto_packet_in *pin, *next_pin;
1175     struct oftable *table;
1176     struct list pins;
1177
1178     ofproto->backer->need_revalidate = REV_RECONFIGURE;
1179     ovs_rwlock_wrlock(&xlate_rwlock);
1180     xlate_remove_ofproto(ofproto);
1181     ovs_rwlock_unlock(&xlate_rwlock);
1182
1183     /* Ensure that the upcall processing threads have no remaining references
1184      * to the ofproto or anything in it. */
1185     udpif_synchronize(ofproto->backer->udpif);
1186
1187     hmap_remove(&all_ofproto_dpifs, &ofproto->all_ofproto_dpifs_node);
1188
1189     OFPROTO_FOR_EACH_TABLE (table, &ofproto->up) {
1190         struct cls_cursor cursor;
1191
1192         fat_rwlock_rdlock(&table->cls.rwlock);
1193         cls_cursor_init(&cursor, &table->cls, NULL);
1194         fat_rwlock_unlock(&table->cls.rwlock);
1195         CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, up.cr, &cursor) {
1196             ofproto_rule_delete(&ofproto->up, &rule->up);
1197         }
1198     }
1199
1200     guarded_list_pop_all(&ofproto->pins, &pins);
1201     LIST_FOR_EACH_SAFE (pin, next_pin, list_node, &pins) {
1202         list_remove(&pin->list_node);
1203         free(CONST_CAST(void *, pin->up.packet));
1204         free(pin);
1205     }
1206     guarded_list_destroy(&ofproto->pins);
1207
1208     mbridge_unref(ofproto->mbridge);
1209
1210     netflow_unref(ofproto->netflow);
1211     dpif_sflow_unref(ofproto->sflow);
1212     hmap_destroy(&ofproto->bundles);
1213     mac_learning_unref(ofproto->ml);
1214
1215     hmap_destroy(&ofproto->vlandev_map);
1216     hmap_destroy(&ofproto->realdev_vid_map);
1217
1218     sset_destroy(&ofproto->ports);
1219     sset_destroy(&ofproto->ghost_ports);
1220     sset_destroy(&ofproto->port_poll_set);
1221
1222     ovs_mutex_destroy(&ofproto->stats_mutex);
1223     ovs_mutex_destroy(&ofproto->vsp_mutex);
1224
1225     close_dpif_backer(ofproto->backer);
1226 }
1227
1228 static int
1229 run(struct ofproto *ofproto_)
1230 {
1231     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1232     uint64_t new_seq, new_dump_seq;
1233
1234     if (mbridge_need_revalidate(ofproto->mbridge)) {
1235         ofproto->backer->need_revalidate = REV_RECONFIGURE;
1236         ovs_rwlock_wrlock(&ofproto->ml->rwlock);
1237         mac_learning_flush(ofproto->ml);
1238         ovs_rwlock_unlock(&ofproto->ml->rwlock);
1239     }
1240
1241     /* Do not perform any periodic activity required by 'ofproto' while
1242      * waiting for flow restore to complete. */
1243     if (!ofproto_get_flow_restore_wait()) {
1244         struct ofproto_packet_in *pin, *next_pin;
1245         struct list pins;
1246
1247         guarded_list_pop_all(&ofproto->pins, &pins);
1248         LIST_FOR_EACH_SAFE (pin, next_pin, list_node, &pins) {
1249             connmgr_send_packet_in(ofproto->up.connmgr, pin);
1250             list_remove(&pin->list_node);
1251             free(CONST_CAST(void *, pin->up.packet));
1252             free(pin);
1253         }
1254     }
1255
1256     if (ofproto->netflow) {
1257         netflow_run(ofproto->netflow);
1258     }
1259     if (ofproto->sflow) {
1260         dpif_sflow_run(ofproto->sflow);
1261     }
1262     if (ofproto->ipfix) {
1263         dpif_ipfix_run(ofproto->ipfix);
1264     }
1265
1266     new_seq = seq_read(connectivity_seq_get());
1267     if (ofproto->change_seq != new_seq) {
1268         struct ofport_dpif *ofport;
1269
1270         HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
1271             port_run(ofport);
1272         }
1273
1274         ofproto->change_seq = new_seq;
1275     }
1276     if (ofproto->lacp_enabled || ofproto->has_bonded_bundles) {
1277         struct ofbundle *bundle;
1278
1279         HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
1280             bundle_run(bundle);
1281         }
1282     }
1283
1284     stp_run(ofproto);
1285     ovs_rwlock_wrlock(&ofproto->ml->rwlock);
1286     if (mac_learning_run(ofproto->ml)) {
1287         ofproto->backer->need_revalidate = REV_MAC_LEARNING;
1288     }
1289     ovs_rwlock_unlock(&ofproto->ml->rwlock);
1290
1291     new_dump_seq = seq_read(udpif_dump_seq(ofproto->backer->udpif));
1292     if (ofproto->dump_seq != new_dump_seq) {
1293         struct rule *rule, *next_rule;
1294
1295         /* We know stats are relatively fresh, so now is a good time to do some
1296          * periodic work. */
1297         ofproto->dump_seq = new_dump_seq;
1298
1299         /* Expire OpenFlow flows whose idle_timeout or hard_timeout
1300          * has passed. */
1301         ovs_mutex_lock(&ofproto_mutex);
1302         LIST_FOR_EACH_SAFE (rule, next_rule, expirable,
1303                             &ofproto->up.expirable) {
1304             rule_expire(rule_dpif_cast(rule));
1305         }
1306         ovs_mutex_unlock(&ofproto_mutex);
1307
1308         /* All outstanding data in existing flows has been accounted, so it's a
1309          * good time to do bond rebalancing. */
1310         if (ofproto->has_bonded_bundles) {
1311             struct ofbundle *bundle;
1312
1313             HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
1314                 if (bundle->bond) {
1315                     bond_rebalance(bundle->bond);
1316                 }
1317             }
1318         }
1319     }
1320
1321     return 0;
1322 }
1323
1324 static void
1325 wait(struct ofproto *ofproto_)
1326 {
1327     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1328
1329     if (ofproto_get_flow_restore_wait()) {
1330         return;
1331     }
1332
1333     if (ofproto->sflow) {
1334         dpif_sflow_wait(ofproto->sflow);
1335     }
1336     if (ofproto->ipfix) {
1337         dpif_ipfix_wait(ofproto->ipfix);
1338     }
1339     if (ofproto->lacp_enabled || ofproto->has_bonded_bundles) {
1340         struct ofbundle *bundle;
1341
1342         HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
1343             bundle_wait(bundle);
1344         }
1345     }
1346     if (ofproto->netflow) {
1347         netflow_wait(ofproto->netflow);
1348     }
1349     ovs_rwlock_rdlock(&ofproto->ml->rwlock);
1350     mac_learning_wait(ofproto->ml);
1351     ovs_rwlock_unlock(&ofproto->ml->rwlock);
1352     stp_wait(ofproto);
1353     if (ofproto->backer->need_revalidate) {
1354         /* Shouldn't happen, but if it does just go around again. */
1355         VLOG_DBG_RL(&rl, "need revalidate in ofproto_wait_cb()");
1356         poll_immediate_wake();
1357     }
1358
1359     seq_wait(udpif_dump_seq(ofproto->backer->udpif), ofproto->dump_seq);
1360 }
1361
1362 static void
1363 type_get_memory_usage(const char *type, struct simap *usage)
1364 {
1365     struct dpif_backer *backer;
1366
1367     backer = shash_find_data(&all_dpif_backers, type);
1368     if (backer) {
1369         udpif_get_memory_usage(backer->udpif, usage);
1370     }
1371 }
1372
1373 static void
1374 flush(struct ofproto *ofproto OVS_UNUSED)
1375 {
1376     udpif_flush();
1377 }
1378
1379 static void
1380 get_features(struct ofproto *ofproto_ OVS_UNUSED,
1381              bool *arp_match_ip, enum ofputil_action_bitmap *actions)
1382 {
1383     *arp_match_ip = true;
1384     *actions = (OFPUTIL_A_OUTPUT |
1385                 OFPUTIL_A_SET_VLAN_VID |
1386                 OFPUTIL_A_SET_VLAN_PCP |
1387                 OFPUTIL_A_STRIP_VLAN |
1388                 OFPUTIL_A_SET_DL_SRC |
1389                 OFPUTIL_A_SET_DL_DST |
1390                 OFPUTIL_A_SET_NW_SRC |
1391                 OFPUTIL_A_SET_NW_DST |
1392                 OFPUTIL_A_SET_NW_TOS |
1393                 OFPUTIL_A_SET_TP_SRC |
1394                 OFPUTIL_A_SET_TP_DST |
1395                 OFPUTIL_A_ENQUEUE);
1396 }
1397
1398 static void
1399 get_tables(struct ofproto *ofproto_, struct ofp12_table_stats *ots)
1400 {
1401     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1402     struct dpif_dp_stats s;
1403     uint64_t n_miss, n_no_pkt_in, n_bytes, n_dropped_frags;
1404     uint64_t n_lookup;
1405     long long int used;
1406
1407     strcpy(ots->name, "classifier");
1408
1409     dpif_get_dp_stats(ofproto->backer->dpif, &s);
1410     rule_get_stats(&ofproto->miss_rule->up, &n_miss, &n_bytes, &used);
1411     rule_get_stats(&ofproto->no_packet_in_rule->up, &n_no_pkt_in, &n_bytes,
1412                    &used);
1413     rule_get_stats(&ofproto->drop_frags_rule->up, &n_dropped_frags, &n_bytes,
1414                    &used);
1415     n_lookup = s.n_hit + s.n_missed - n_dropped_frags;
1416     ots->lookup_count = htonll(n_lookup);
1417     ots->matched_count = htonll(n_lookup - n_miss - n_no_pkt_in);
1418 }
1419
1420 static struct ofport *
1421 port_alloc(void)
1422 {
1423     struct ofport_dpif *port = xmalloc(sizeof *port);
1424     return &port->up;
1425 }
1426
1427 static void
1428 port_dealloc(struct ofport *port_)
1429 {
1430     struct ofport_dpif *port = ofport_dpif_cast(port_);
1431     free(port);
1432 }
1433
1434 static int
1435 port_construct(struct ofport *port_)
1436 {
1437     struct ofport_dpif *port = ofport_dpif_cast(port_);
1438     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
1439     const struct netdev *netdev = port->up.netdev;
1440     char namebuf[NETDEV_VPORT_NAME_BUFSIZE];
1441     struct dpif_port dpif_port;
1442     int error;
1443
1444     ofproto->backer->need_revalidate = REV_RECONFIGURE;
1445     port->bundle = NULL;
1446     port->cfm = NULL;
1447     port->bfd = NULL;
1448     port->may_enable = true;
1449     port->stp_port = NULL;
1450     port->stp_state = STP_DISABLED;
1451     port->is_tunnel = false;
1452     port->peer = NULL;
1453     port->qdscp = NULL;
1454     port->n_qdscp = 0;
1455     port->realdev_ofp_port = 0;
1456     port->vlandev_vid = 0;
1457     port->carrier_seq = netdev_get_carrier_resets(netdev);
1458     port->is_layer3 = netdev_vport_is_layer3(netdev);
1459
1460     if (netdev_vport_is_patch(netdev)) {
1461         /* By bailing out here, we don't submit the port to the sFlow module
1462          * to be considered for counter polling export.  This is correct
1463          * because the patch port represents an interface that sFlow considers
1464          * to be "internal" to the switch as a whole, and therefore not an
1465          * candidate for counter polling. */
1466         port->odp_port = ODPP_NONE;
1467         ofport_update_peer(port);
1468         return 0;
1469     }
1470
1471     error = dpif_port_query_by_name(ofproto->backer->dpif,
1472                                     netdev_vport_get_dpif_port(netdev, namebuf,
1473                                                                sizeof namebuf),
1474                                     &dpif_port);
1475     if (error) {
1476         return error;
1477     }
1478
1479     port->odp_port = dpif_port.port_no;
1480
1481     if (netdev_get_tunnel_config(netdev)) {
1482         tnl_port_add(port, port->up.netdev, port->odp_port);
1483         port->is_tunnel = true;
1484     } else {
1485         /* Sanity-check that a mapping doesn't already exist.  This
1486          * shouldn't happen for non-tunnel ports. */
1487         if (odp_port_to_ofp_port(ofproto, port->odp_port) != OFPP_NONE) {
1488             VLOG_ERR("port %s already has an OpenFlow port number",
1489                      dpif_port.name);
1490             dpif_port_destroy(&dpif_port);
1491             return EBUSY;
1492         }
1493
1494         ovs_rwlock_wrlock(&ofproto->backer->odp_to_ofport_lock);
1495         hmap_insert(&ofproto->backer->odp_to_ofport_map, &port->odp_port_node,
1496                     hash_odp_port(port->odp_port));
1497         ovs_rwlock_unlock(&ofproto->backer->odp_to_ofport_lock);
1498     }
1499     dpif_port_destroy(&dpif_port);
1500
1501     if (ofproto->sflow) {
1502         dpif_sflow_add_port(ofproto->sflow, port_, port->odp_port);
1503     }
1504
1505     return 0;
1506 }
1507
1508 static void
1509 port_destruct(struct ofport *port_)
1510 {
1511     struct ofport_dpif *port = ofport_dpif_cast(port_);
1512     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
1513     const char *devname = netdev_get_name(port->up.netdev);
1514     char namebuf[NETDEV_VPORT_NAME_BUFSIZE];
1515     const char *dp_port_name;
1516
1517     ofproto->backer->need_revalidate = REV_RECONFIGURE;
1518     ovs_rwlock_wrlock(&xlate_rwlock);
1519     xlate_ofport_remove(port);
1520     ovs_rwlock_unlock(&xlate_rwlock);
1521
1522     dp_port_name = netdev_vport_get_dpif_port(port->up.netdev, namebuf,
1523                                               sizeof namebuf);
1524     if (dpif_port_exists(ofproto->backer->dpif, dp_port_name)) {
1525         /* The underlying device is still there, so delete it.  This
1526          * happens when the ofproto is being destroyed, since the caller
1527          * assumes that removal of attached ports will happen as part of
1528          * destruction. */
1529         if (!port->is_tunnel) {
1530             dpif_port_del(ofproto->backer->dpif, port->odp_port);
1531         }
1532     }
1533
1534     if (port->peer) {
1535         port->peer->peer = NULL;
1536         port->peer = NULL;
1537     }
1538
1539     if (port->odp_port != ODPP_NONE && !port->is_tunnel) {
1540         ovs_rwlock_wrlock(&ofproto->backer->odp_to_ofport_lock);
1541         hmap_remove(&ofproto->backer->odp_to_ofport_map, &port->odp_port_node);
1542         ovs_rwlock_unlock(&ofproto->backer->odp_to_ofport_lock);
1543     }
1544
1545     tnl_port_del(port);
1546     sset_find_and_delete(&ofproto->ports, devname);
1547     sset_find_and_delete(&ofproto->ghost_ports, devname);
1548     bundle_remove(port_);
1549     set_cfm(port_, NULL);
1550     set_bfd(port_, NULL);
1551     if (port->stp_port) {
1552         stp_port_disable(port->stp_port);
1553     }
1554     if (ofproto->sflow) {
1555         dpif_sflow_del_port(ofproto->sflow, port->odp_port);
1556     }
1557
1558     free(port->qdscp);
1559 }
1560
1561 static void
1562 port_modified(struct ofport *port_)
1563 {
1564     struct ofport_dpif *port = ofport_dpif_cast(port_);
1565
1566     if (port->bundle && port->bundle->bond) {
1567         bond_slave_set_netdev(port->bundle->bond, port, port->up.netdev);
1568     }
1569
1570     if (port->cfm) {
1571         cfm_set_netdev(port->cfm, port->up.netdev);
1572     }
1573
1574     if (port->bfd) {
1575         bfd_set_netdev(port->bfd, port->up.netdev);
1576     }
1577
1578     ofproto_dpif_monitor_port_update(port, port->bfd, port->cfm,
1579                                      port->up.pp.hw_addr);
1580
1581     if (port->is_tunnel && tnl_port_reconfigure(port, port->up.netdev,
1582                                                 port->odp_port)) {
1583         ofproto_dpif_cast(port->up.ofproto)->backer->need_revalidate =
1584             REV_RECONFIGURE;
1585     }
1586
1587     ofport_update_peer(port);
1588 }
1589
1590 static void
1591 port_reconfigured(struct ofport *port_, enum ofputil_port_config old_config)
1592 {
1593     struct ofport_dpif *port = ofport_dpif_cast(port_);
1594     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
1595     enum ofputil_port_config changed = old_config ^ port->up.pp.config;
1596
1597     if (changed & (OFPUTIL_PC_NO_RECV | OFPUTIL_PC_NO_RECV_STP |
1598                    OFPUTIL_PC_NO_FWD | OFPUTIL_PC_NO_FLOOD |
1599                    OFPUTIL_PC_NO_PACKET_IN)) {
1600         ofproto->backer->need_revalidate = REV_RECONFIGURE;
1601
1602         if (changed & OFPUTIL_PC_NO_FLOOD && port->bundle) {
1603             bundle_update(port->bundle);
1604         }
1605     }
1606 }
1607
1608 static int
1609 set_sflow(struct ofproto *ofproto_,
1610           const struct ofproto_sflow_options *sflow_options)
1611 {
1612     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1613     struct dpif_sflow *ds = ofproto->sflow;
1614
1615     if (sflow_options) {
1616         if (!ds) {
1617             struct ofport_dpif *ofport;
1618
1619             ds = ofproto->sflow = dpif_sflow_create();
1620             HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
1621                 dpif_sflow_add_port(ds, &ofport->up, ofport->odp_port);
1622             }
1623             ofproto->backer->need_revalidate = REV_RECONFIGURE;
1624         }
1625         dpif_sflow_set_options(ds, sflow_options);
1626     } else {
1627         if (ds) {
1628             dpif_sflow_unref(ds);
1629             ofproto->backer->need_revalidate = REV_RECONFIGURE;
1630             ofproto->sflow = NULL;
1631         }
1632     }
1633     return 0;
1634 }
1635
1636 static int
1637 set_ipfix(
1638     struct ofproto *ofproto_,
1639     const struct ofproto_ipfix_bridge_exporter_options *bridge_exporter_options,
1640     const struct ofproto_ipfix_flow_exporter_options *flow_exporters_options,
1641     size_t n_flow_exporters_options)
1642 {
1643     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1644     struct dpif_ipfix *di = ofproto->ipfix;
1645     bool has_options = bridge_exporter_options || flow_exporters_options;
1646
1647     if (has_options && !di) {
1648         di = ofproto->ipfix = dpif_ipfix_create();
1649     }
1650
1651     if (di) {
1652         /* Call set_options in any case to cleanly flush the flow
1653          * caches in the last exporters that are to be destroyed. */
1654         dpif_ipfix_set_options(
1655             di, bridge_exporter_options, flow_exporters_options,
1656             n_flow_exporters_options);
1657
1658         if (!has_options) {
1659             dpif_ipfix_unref(di);
1660             ofproto->ipfix = NULL;
1661         }
1662     }
1663
1664     return 0;
1665 }
1666
1667 static int
1668 set_cfm(struct ofport *ofport_, const struct cfm_settings *s)
1669 {
1670     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1671     int error = 0;
1672
1673     if (s) {
1674         if (!ofport->cfm) {
1675             struct ofproto_dpif *ofproto;
1676
1677             ofproto = ofproto_dpif_cast(ofport->up.ofproto);
1678             ofproto->backer->need_revalidate = REV_RECONFIGURE;
1679             ofport->cfm = cfm_create(ofport->up.netdev);
1680         }
1681
1682         if (cfm_configure(ofport->cfm, s)) {
1683             error = 0;
1684             goto out;
1685         }
1686
1687         error = EINVAL;
1688     }
1689     cfm_unref(ofport->cfm);
1690     ofport->cfm = NULL;
1691 out:
1692     ofproto_dpif_monitor_port_update(ofport, ofport->bfd, ofport->cfm,
1693                                      ofport->up.pp.hw_addr);
1694     return error;
1695 }
1696
1697 static bool
1698 get_cfm_status(const struct ofport *ofport_,
1699                struct ofproto_cfm_status *status)
1700 {
1701     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1702
1703     if (ofport->cfm) {
1704         status->faults = cfm_get_fault(ofport->cfm);
1705         status->flap_count = cfm_get_flap_count(ofport->cfm);
1706         status->remote_opstate = cfm_get_opup(ofport->cfm);
1707         status->health = cfm_get_health(ofport->cfm);
1708         cfm_get_remote_mpids(ofport->cfm, &status->rmps, &status->n_rmps);
1709         return true;
1710     } else {
1711         return false;
1712     }
1713 }
1714
1715 static int
1716 set_bfd(struct ofport *ofport_, const struct smap *cfg)
1717 {
1718     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport_->ofproto);
1719     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1720     struct bfd *old;
1721
1722     old = ofport->bfd;
1723     ofport->bfd = bfd_configure(old, netdev_get_name(ofport->up.netdev),
1724                                 cfg, ofport->up.netdev);
1725     if (ofport->bfd != old) {
1726         ofproto->backer->need_revalidate = REV_RECONFIGURE;
1727     }
1728     ofproto_dpif_monitor_port_update(ofport, ofport->bfd, ofport->cfm,
1729                                      ofport->up.pp.hw_addr);
1730     return 0;
1731 }
1732
1733 static int
1734 get_bfd_status(struct ofport *ofport_, struct smap *smap)
1735 {
1736     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1737
1738     if (ofport->bfd) {
1739         bfd_get_status(ofport->bfd, smap);
1740         return 0;
1741     } else {
1742         return ENOENT;
1743     }
1744 }
1745 \f
1746 /* Spanning Tree. */
1747
1748 static void
1749 send_bpdu_cb(struct ofpbuf *pkt, int port_num, void *ofproto_)
1750 {
1751     struct ofproto_dpif *ofproto = ofproto_;
1752     struct stp_port *sp = stp_get_port(ofproto->stp, port_num);
1753     struct ofport_dpif *ofport;
1754
1755     ofport = stp_port_get_aux(sp);
1756     if (!ofport) {
1757         VLOG_WARN_RL(&rl, "%s: cannot send BPDU on unknown port %d",
1758                      ofproto->up.name, port_num);
1759     } else {
1760         struct eth_header *eth = pkt->l2;
1761
1762         netdev_get_etheraddr(ofport->up.netdev, eth->eth_src);
1763         if (eth_addr_is_zero(eth->eth_src)) {
1764             VLOG_WARN_RL(&rl, "%s: cannot send BPDU on port %d "
1765                          "with unknown MAC", ofproto->up.name, port_num);
1766         } else {
1767             ofproto_dpif_send_packet(ofport, pkt);
1768         }
1769     }
1770     ofpbuf_delete(pkt);
1771 }
1772
1773 /* Configures STP on 'ofproto_' using the settings defined in 's'. */
1774 static int
1775 set_stp(struct ofproto *ofproto_, const struct ofproto_stp_settings *s)
1776 {
1777     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1778
1779     /* Only revalidate flows if the configuration changed. */
1780     if (!s != !ofproto->stp) {
1781         ofproto->backer->need_revalidate = REV_RECONFIGURE;
1782     }
1783
1784     if (s) {
1785         if (!ofproto->stp) {
1786             ofproto->stp = stp_create(ofproto_->name, s->system_id,
1787                                       send_bpdu_cb, ofproto);
1788             ofproto->stp_last_tick = time_msec();
1789         }
1790
1791         stp_set_bridge_id(ofproto->stp, s->system_id);
1792         stp_set_bridge_priority(ofproto->stp, s->priority);
1793         stp_set_hello_time(ofproto->stp, s->hello_time);
1794         stp_set_max_age(ofproto->stp, s->max_age);
1795         stp_set_forward_delay(ofproto->stp, s->fwd_delay);
1796     }  else {
1797         struct ofport *ofport;
1798
1799         HMAP_FOR_EACH (ofport, hmap_node, &ofproto->up.ports) {
1800             set_stp_port(ofport, NULL);
1801         }
1802
1803         stp_unref(ofproto->stp);
1804         ofproto->stp = NULL;
1805     }
1806
1807     return 0;
1808 }
1809
1810 static int
1811 get_stp_status(struct ofproto *ofproto_, struct ofproto_stp_status *s)
1812 {
1813     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1814
1815     if (ofproto->stp) {
1816         s->enabled = true;
1817         s->bridge_id = stp_get_bridge_id(ofproto->stp);
1818         s->designated_root = stp_get_designated_root(ofproto->stp);
1819         s->root_path_cost = stp_get_root_path_cost(ofproto->stp);
1820     } else {
1821         s->enabled = false;
1822     }
1823
1824     return 0;
1825 }
1826
1827 static void
1828 update_stp_port_state(struct ofport_dpif *ofport)
1829 {
1830     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
1831     enum stp_state state;
1832
1833     /* Figure out new state. */
1834     state = ofport->stp_port ? stp_port_get_state(ofport->stp_port)
1835                              : STP_DISABLED;
1836
1837     /* Update state. */
1838     if (ofport->stp_state != state) {
1839         enum ofputil_port_state of_state;
1840         bool fwd_change;
1841
1842         VLOG_DBG_RL(&rl, "port %s: STP state changed from %s to %s",
1843                     netdev_get_name(ofport->up.netdev),
1844                     stp_state_name(ofport->stp_state),
1845                     stp_state_name(state));
1846         if (stp_learn_in_state(ofport->stp_state)
1847                 != stp_learn_in_state(state)) {
1848             /* xxx Learning action flows should also be flushed. */
1849             ovs_rwlock_wrlock(&ofproto->ml->rwlock);
1850             mac_learning_flush(ofproto->ml);
1851             ovs_rwlock_unlock(&ofproto->ml->rwlock);
1852         }
1853         fwd_change = stp_forward_in_state(ofport->stp_state)
1854                         != stp_forward_in_state(state);
1855
1856         ofproto->backer->need_revalidate = REV_STP;
1857         ofport->stp_state = state;
1858         ofport->stp_state_entered = time_msec();
1859
1860         if (fwd_change && ofport->bundle) {
1861             bundle_update(ofport->bundle);
1862         }
1863
1864         /* Update the STP state bits in the OpenFlow port description. */
1865         of_state = ofport->up.pp.state & ~OFPUTIL_PS_STP_MASK;
1866         of_state |= (state == STP_LISTENING ? OFPUTIL_PS_STP_LISTEN
1867                      : state == STP_LEARNING ? OFPUTIL_PS_STP_LEARN
1868                      : state == STP_FORWARDING ? OFPUTIL_PS_STP_FORWARD
1869                      : state == STP_BLOCKING ?  OFPUTIL_PS_STP_BLOCK
1870                      : 0);
1871         ofproto_port_set_state(&ofport->up, of_state);
1872     }
1873 }
1874
1875 /* Configures STP on 'ofport_' using the settings defined in 's'.  The
1876  * caller is responsible for assigning STP port numbers and ensuring
1877  * there are no duplicates. */
1878 static int
1879 set_stp_port(struct ofport *ofport_,
1880              const struct ofproto_port_stp_settings *s)
1881 {
1882     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1883     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
1884     struct stp_port *sp = ofport->stp_port;
1885
1886     if (!s || !s->enable) {
1887         if (sp) {
1888             ofport->stp_port = NULL;
1889             stp_port_disable(sp);
1890             update_stp_port_state(ofport);
1891         }
1892         return 0;
1893     } else if (sp && stp_port_no(sp) != s->port_num
1894             && ofport == stp_port_get_aux(sp)) {
1895         /* The port-id changed, so disable the old one if it's not
1896          * already in use by another port. */
1897         stp_port_disable(sp);
1898     }
1899
1900     sp = ofport->stp_port = stp_get_port(ofproto->stp, s->port_num);
1901     stp_port_enable(sp);
1902
1903     stp_port_set_aux(sp, ofport);
1904     stp_port_set_priority(sp, s->priority);
1905     stp_port_set_path_cost(sp, s->path_cost);
1906
1907     update_stp_port_state(ofport);
1908
1909     return 0;
1910 }
1911
1912 static int
1913 get_stp_port_status(struct ofport *ofport_,
1914                     struct ofproto_port_stp_status *s)
1915 {
1916     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1917     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
1918     struct stp_port *sp = ofport->stp_port;
1919
1920     if (!ofproto->stp || !sp) {
1921         s->enabled = false;
1922         return 0;
1923     }
1924
1925     s->enabled = true;
1926     s->port_id = stp_port_get_id(sp);
1927     s->state = stp_port_get_state(sp);
1928     s->sec_in_state = (time_msec() - ofport->stp_state_entered) / 1000;
1929     s->role = stp_port_get_role(sp);
1930
1931     return 0;
1932 }
1933
1934 static int
1935 get_stp_port_stats(struct ofport *ofport_,
1936                    struct ofproto_port_stp_stats *s)
1937 {
1938     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1939     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
1940     struct stp_port *sp = ofport->stp_port;
1941
1942     if (!ofproto->stp || !sp) {
1943         s->enabled = false;
1944         return 0;
1945     }
1946
1947     s->enabled = true;
1948     stp_port_get_counts(sp, &s->tx_count, &s->rx_count, &s->error_count);
1949
1950     return 0;
1951 }
1952
1953 static void
1954 stp_run(struct ofproto_dpif *ofproto)
1955 {
1956     if (ofproto->stp) {
1957         long long int now = time_msec();
1958         long long int elapsed = now - ofproto->stp_last_tick;
1959         struct stp_port *sp;
1960
1961         if (elapsed > 0) {
1962             stp_tick(ofproto->stp, MIN(INT_MAX, elapsed));
1963             ofproto->stp_last_tick = now;
1964         }
1965         while (stp_get_changed_port(ofproto->stp, &sp)) {
1966             struct ofport_dpif *ofport = stp_port_get_aux(sp);
1967
1968             if (ofport) {
1969                 update_stp_port_state(ofport);
1970             }
1971         }
1972
1973         if (stp_check_and_reset_fdb_flush(ofproto->stp)) {
1974             ovs_rwlock_wrlock(&ofproto->ml->rwlock);
1975             mac_learning_flush(ofproto->ml);
1976             ovs_rwlock_unlock(&ofproto->ml->rwlock);
1977         }
1978     }
1979 }
1980
1981 static void
1982 stp_wait(struct ofproto_dpif *ofproto)
1983 {
1984     if (ofproto->stp) {
1985         poll_timer_wait(1000);
1986     }
1987 }
1988 \f
1989 static int
1990 set_queues(struct ofport *ofport_, const struct ofproto_port_queue *qdscp,
1991            size_t n_qdscp)
1992 {
1993     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1994     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
1995
1996     if (ofport->n_qdscp != n_qdscp
1997         || (n_qdscp && memcmp(ofport->qdscp, qdscp,
1998                               n_qdscp * sizeof *qdscp))) {
1999         ofproto->backer->need_revalidate = REV_RECONFIGURE;
2000         free(ofport->qdscp);
2001         ofport->qdscp = n_qdscp
2002             ? xmemdup(qdscp, n_qdscp * sizeof *qdscp)
2003             : NULL;
2004         ofport->n_qdscp = n_qdscp;
2005     }
2006
2007     return 0;
2008 }
2009 \f
2010 /* Bundles. */
2011
2012 /* Expires all MAC learning entries associated with 'bundle' and forces its
2013  * ofproto to revalidate every flow.
2014  *
2015  * Normally MAC learning entries are removed only from the ofproto associated
2016  * with 'bundle', but if 'all_ofprotos' is true, then the MAC learning entries
2017  * are removed from every ofproto.  When patch ports and SLB bonds are in use
2018  * and a VM migration happens and the gratuitous ARPs are somehow lost, this
2019  * avoids a MAC_ENTRY_IDLE_TIME delay before the migrated VM can communicate
2020  * with the host from which it migrated. */
2021 static void
2022 bundle_flush_macs(struct ofbundle *bundle, bool all_ofprotos)
2023 {
2024     struct ofproto_dpif *ofproto = bundle->ofproto;
2025     struct mac_learning *ml = ofproto->ml;
2026     struct mac_entry *mac, *next_mac;
2027
2028     ofproto->backer->need_revalidate = REV_RECONFIGURE;
2029     ovs_rwlock_wrlock(&ml->rwlock);
2030     LIST_FOR_EACH_SAFE (mac, next_mac, lru_node, &ml->lrus) {
2031         if (mac->port.p == bundle) {
2032             if (all_ofprotos) {
2033                 struct ofproto_dpif *o;
2034
2035                 HMAP_FOR_EACH (o, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
2036                     if (o != ofproto) {
2037                         struct mac_entry *e;
2038
2039                         ovs_rwlock_wrlock(&o->ml->rwlock);
2040                         e = mac_learning_lookup(o->ml, mac->mac, mac->vlan);
2041                         if (e) {
2042                             mac_learning_expire(o->ml, e);
2043                         }
2044                         ovs_rwlock_unlock(&o->ml->rwlock);
2045                     }
2046                 }
2047             }
2048
2049             mac_learning_expire(ml, mac);
2050         }
2051     }
2052     ovs_rwlock_unlock(&ml->rwlock);
2053 }
2054
2055 static struct ofbundle *
2056 bundle_lookup(const struct ofproto_dpif *ofproto, void *aux)
2057 {
2058     struct ofbundle *bundle;
2059
2060     HMAP_FOR_EACH_IN_BUCKET (bundle, hmap_node, hash_pointer(aux, 0),
2061                              &ofproto->bundles) {
2062         if (bundle->aux == aux) {
2063             return bundle;
2064         }
2065     }
2066     return NULL;
2067 }
2068
2069 static void
2070 bundle_update(struct ofbundle *bundle)
2071 {
2072     struct ofport_dpif *port;
2073
2074     bundle->floodable = true;
2075     LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
2076         if (port->up.pp.config & OFPUTIL_PC_NO_FLOOD
2077             || port->is_layer3
2078             || !stp_forward_in_state(port->stp_state)) {
2079             bundle->floodable = false;
2080             break;
2081         }
2082     }
2083 }
2084
2085 static void
2086 bundle_del_port(struct ofport_dpif *port)
2087 {
2088     struct ofbundle *bundle = port->bundle;
2089
2090     bundle->ofproto->backer->need_revalidate = REV_RECONFIGURE;
2091
2092     list_remove(&port->bundle_node);
2093     port->bundle = NULL;
2094
2095     if (bundle->lacp) {
2096         lacp_slave_unregister(bundle->lacp, port);
2097     }
2098     if (bundle->bond) {
2099         bond_slave_unregister(bundle->bond, port);
2100     }
2101
2102     bundle_update(bundle);
2103 }
2104
2105 static bool
2106 bundle_add_port(struct ofbundle *bundle, ofp_port_t ofp_port,
2107                 struct lacp_slave_settings *lacp)
2108 {
2109     struct ofport_dpif *port;
2110
2111     port = get_ofp_port(bundle->ofproto, ofp_port);
2112     if (!port) {
2113         return false;
2114     }
2115
2116     if (port->bundle != bundle) {
2117         bundle->ofproto->backer->need_revalidate = REV_RECONFIGURE;
2118         if (port->bundle) {
2119             bundle_remove(&port->up);
2120         }
2121
2122         port->bundle = bundle;
2123         list_push_back(&bundle->ports, &port->bundle_node);
2124         if (port->up.pp.config & OFPUTIL_PC_NO_FLOOD
2125             || port->is_layer3
2126             || !stp_forward_in_state(port->stp_state)) {
2127             bundle->floodable = false;
2128         }
2129     }
2130     if (lacp) {
2131         bundle->ofproto->backer->need_revalidate = REV_RECONFIGURE;
2132         lacp_slave_register(bundle->lacp, port, lacp);
2133     }
2134
2135     return true;
2136 }
2137
2138 static void
2139 bundle_destroy(struct ofbundle *bundle)
2140 {
2141     struct ofproto_dpif *ofproto;
2142     struct ofport_dpif *port, *next_port;
2143
2144     if (!bundle) {
2145         return;
2146     }
2147
2148     ofproto = bundle->ofproto;
2149     mbridge_unregister_bundle(ofproto->mbridge, bundle->aux);
2150
2151     ovs_rwlock_wrlock(&xlate_rwlock);
2152     xlate_bundle_remove(bundle);
2153     ovs_rwlock_unlock(&xlate_rwlock);
2154
2155     LIST_FOR_EACH_SAFE (port, next_port, bundle_node, &bundle->ports) {
2156         bundle_del_port(port);
2157     }
2158
2159     bundle_flush_macs(bundle, true);
2160     hmap_remove(&ofproto->bundles, &bundle->hmap_node);
2161     free(bundle->name);
2162     free(bundle->trunks);
2163     lacp_unref(bundle->lacp);
2164     bond_unref(bundle->bond);
2165     free(bundle);
2166 }
2167
2168 static int
2169 bundle_set(struct ofproto *ofproto_, void *aux,
2170            const struct ofproto_bundle_settings *s)
2171 {
2172     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2173     bool need_flush = false;
2174     struct ofport_dpif *port;
2175     struct ofbundle *bundle;
2176     unsigned long *trunks;
2177     int vlan;
2178     size_t i;
2179     bool ok;
2180
2181     if (!s) {
2182         bundle_destroy(bundle_lookup(ofproto, aux));
2183         return 0;
2184     }
2185
2186     ovs_assert(s->n_slaves == 1 || s->bond != NULL);
2187     ovs_assert((s->lacp != NULL) == (s->lacp_slaves != NULL));
2188
2189     bundle = bundle_lookup(ofproto, aux);
2190     if (!bundle) {
2191         bundle = xmalloc(sizeof *bundle);
2192
2193         bundle->ofproto = ofproto;
2194         hmap_insert(&ofproto->bundles, &bundle->hmap_node,
2195                     hash_pointer(aux, 0));
2196         bundle->aux = aux;
2197         bundle->name = NULL;
2198
2199         list_init(&bundle->ports);
2200         bundle->vlan_mode = PORT_VLAN_TRUNK;
2201         bundle->vlan = -1;
2202         bundle->trunks = NULL;
2203         bundle->use_priority_tags = s->use_priority_tags;
2204         bundle->lacp = NULL;
2205         bundle->bond = NULL;
2206
2207         bundle->floodable = true;
2208         mbridge_register_bundle(ofproto->mbridge, bundle);
2209     }
2210
2211     if (!bundle->name || strcmp(s->name, bundle->name)) {
2212         free(bundle->name);
2213         bundle->name = xstrdup(s->name);
2214     }
2215
2216     /* LACP. */
2217     if (s->lacp) {
2218         ofproto->lacp_enabled = true;
2219         if (!bundle->lacp) {
2220             ofproto->backer->need_revalidate = REV_RECONFIGURE;
2221             bundle->lacp = lacp_create();
2222         }
2223         lacp_configure(bundle->lacp, s->lacp);
2224     } else {
2225         lacp_unref(bundle->lacp);
2226         bundle->lacp = NULL;
2227     }
2228
2229     /* Update set of ports. */
2230     ok = true;
2231     for (i = 0; i < s->n_slaves; i++) {
2232         if (!bundle_add_port(bundle, s->slaves[i],
2233                              s->lacp ? &s->lacp_slaves[i] : NULL)) {
2234             ok = false;
2235         }
2236     }
2237     if (!ok || list_size(&bundle->ports) != s->n_slaves) {
2238         struct ofport_dpif *next_port;
2239
2240         LIST_FOR_EACH_SAFE (port, next_port, bundle_node, &bundle->ports) {
2241             for (i = 0; i < s->n_slaves; i++) {
2242                 if (s->slaves[i] == port->up.ofp_port) {
2243                     goto found;
2244                 }
2245             }
2246
2247             bundle_del_port(port);
2248         found: ;
2249         }
2250     }
2251     ovs_assert(list_size(&bundle->ports) <= s->n_slaves);
2252
2253     if (list_is_empty(&bundle->ports)) {
2254         bundle_destroy(bundle);
2255         return EINVAL;
2256     }
2257
2258     /* Set VLAN tagging mode */
2259     if (s->vlan_mode != bundle->vlan_mode
2260         || s->use_priority_tags != bundle->use_priority_tags) {
2261         bundle->vlan_mode = s->vlan_mode;
2262         bundle->use_priority_tags = s->use_priority_tags;
2263         need_flush = true;
2264     }
2265
2266     /* Set VLAN tag. */
2267     vlan = (s->vlan_mode == PORT_VLAN_TRUNK ? -1
2268             : s->vlan >= 0 && s->vlan <= 4095 ? s->vlan
2269             : 0);
2270     if (vlan != bundle->vlan) {
2271         bundle->vlan = vlan;
2272         need_flush = true;
2273     }
2274
2275     /* Get trunked VLANs. */
2276     switch (s->vlan_mode) {
2277     case PORT_VLAN_ACCESS:
2278         trunks = NULL;
2279         break;
2280
2281     case PORT_VLAN_TRUNK:
2282         trunks = CONST_CAST(unsigned long *, s->trunks);
2283         break;
2284
2285     case PORT_VLAN_NATIVE_UNTAGGED:
2286     case PORT_VLAN_NATIVE_TAGGED:
2287         if (vlan != 0 && (!s->trunks
2288                           || !bitmap_is_set(s->trunks, vlan)
2289                           || bitmap_is_set(s->trunks, 0))) {
2290             /* Force trunking the native VLAN and prohibit trunking VLAN 0. */
2291             if (s->trunks) {
2292                 trunks = bitmap_clone(s->trunks, 4096);
2293             } else {
2294                 trunks = bitmap_allocate1(4096);
2295             }
2296             bitmap_set1(trunks, vlan);
2297             bitmap_set0(trunks, 0);
2298         } else {
2299             trunks = CONST_CAST(unsigned long *, s->trunks);
2300         }
2301         break;
2302
2303     default:
2304         OVS_NOT_REACHED();
2305     }
2306     if (!vlan_bitmap_equal(trunks, bundle->trunks)) {
2307         free(bundle->trunks);
2308         if (trunks == s->trunks) {
2309             bundle->trunks = vlan_bitmap_clone(trunks);
2310         } else {
2311             bundle->trunks = trunks;
2312             trunks = NULL;
2313         }
2314         need_flush = true;
2315     }
2316     if (trunks != s->trunks) {
2317         free(trunks);
2318     }
2319
2320     /* Bonding. */
2321     if (!list_is_short(&bundle->ports)) {
2322         bundle->ofproto->has_bonded_bundles = true;
2323         if (bundle->bond) {
2324             if (bond_reconfigure(bundle->bond, s->bond)) {
2325                 ofproto->backer->need_revalidate = REV_RECONFIGURE;
2326             }
2327         } else {
2328             bundle->bond = bond_create(s->bond);
2329             ofproto->backer->need_revalidate = REV_RECONFIGURE;
2330         }
2331
2332         LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
2333             bond_slave_register(bundle->bond, port, port->up.netdev);
2334         }
2335     } else {
2336         bond_unref(bundle->bond);
2337         bundle->bond = NULL;
2338     }
2339
2340     /* If we changed something that would affect MAC learning, un-learn
2341      * everything on this port and force flow revalidation. */
2342     if (need_flush) {
2343         bundle_flush_macs(bundle, false);
2344     }
2345
2346     return 0;
2347 }
2348
2349 static void
2350 bundle_remove(struct ofport *port_)
2351 {
2352     struct ofport_dpif *port = ofport_dpif_cast(port_);
2353     struct ofbundle *bundle = port->bundle;
2354
2355     if (bundle) {
2356         bundle_del_port(port);
2357         if (list_is_empty(&bundle->ports)) {
2358             bundle_destroy(bundle);
2359         } else if (list_is_short(&bundle->ports)) {
2360             bond_unref(bundle->bond);
2361             bundle->bond = NULL;
2362         }
2363     }
2364 }
2365
2366 static void
2367 send_pdu_cb(void *port_, const void *pdu, size_t pdu_size)
2368 {
2369     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 10);
2370     struct ofport_dpif *port = port_;
2371     uint8_t ea[ETH_ADDR_LEN];
2372     int error;
2373
2374     error = netdev_get_etheraddr(port->up.netdev, ea);
2375     if (!error) {
2376         struct ofpbuf packet;
2377         void *packet_pdu;
2378
2379         ofpbuf_init(&packet, 0);
2380         packet_pdu = eth_compose(&packet, eth_addr_lacp, ea, ETH_TYPE_LACP,
2381                                  pdu_size);
2382         memcpy(packet_pdu, pdu, pdu_size);
2383
2384         ofproto_dpif_send_packet(port, &packet);
2385         ofpbuf_uninit(&packet);
2386     } else {
2387         VLOG_ERR_RL(&rl, "port %s: cannot obtain Ethernet address of iface "
2388                     "%s (%s)", port->bundle->name,
2389                     netdev_get_name(port->up.netdev), ovs_strerror(error));
2390     }
2391 }
2392
2393 static void
2394 bundle_send_learning_packets(struct ofbundle *bundle)
2395 {
2396     struct ofproto_dpif *ofproto = bundle->ofproto;
2397     struct ofpbuf *learning_packet;
2398     int error, n_packets, n_errors;
2399     struct mac_entry *e;
2400     struct list packets;
2401
2402     list_init(&packets);
2403     ovs_rwlock_rdlock(&ofproto->ml->rwlock);
2404     LIST_FOR_EACH (e, lru_node, &ofproto->ml->lrus) {
2405         if (e->port.p != bundle) {
2406             void *port_void;
2407
2408             learning_packet = bond_compose_learning_packet(bundle->bond,
2409                                                            e->mac, e->vlan,
2410                                                            &port_void);
2411             learning_packet->private_p = port_void;
2412             list_push_back(&packets, &learning_packet->list_node);
2413         }
2414     }
2415     ovs_rwlock_unlock(&ofproto->ml->rwlock);
2416
2417     error = n_packets = n_errors = 0;
2418     LIST_FOR_EACH (learning_packet, list_node, &packets) {
2419         int ret;
2420
2421         ret = ofproto_dpif_send_packet(learning_packet->private_p, learning_packet);
2422         if (ret) {
2423             error = ret;
2424             n_errors++;
2425         }
2426         n_packets++;
2427     }
2428     ofpbuf_list_delete(&packets);
2429
2430     if (n_errors) {
2431         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2432         VLOG_WARN_RL(&rl, "bond %s: %d errors sending %d gratuitous learning "
2433                      "packets, last error was: %s",
2434                      bundle->name, n_errors, n_packets, ovs_strerror(error));
2435     } else {
2436         VLOG_DBG("bond %s: sent %d gratuitous learning packets",
2437                  bundle->name, n_packets);
2438     }
2439 }
2440
2441 static void
2442 bundle_run(struct ofbundle *bundle)
2443 {
2444     if (bundle->lacp) {
2445         lacp_run(bundle->lacp, send_pdu_cb);
2446     }
2447     if (bundle->bond) {
2448         struct ofport_dpif *port;
2449
2450         LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
2451             bond_slave_set_may_enable(bundle->bond, port, port->may_enable);
2452         }
2453
2454         if (bond_run(bundle->bond, lacp_status(bundle->lacp))) {
2455             bundle->ofproto->backer->need_revalidate = REV_BOND;
2456         }
2457
2458         if (bond_should_send_learning_packets(bundle->bond)) {
2459             bundle_send_learning_packets(bundle);
2460         }
2461     }
2462 }
2463
2464 static void
2465 bundle_wait(struct ofbundle *bundle)
2466 {
2467     if (bundle->lacp) {
2468         lacp_wait(bundle->lacp);
2469     }
2470     if (bundle->bond) {
2471         bond_wait(bundle->bond);
2472     }
2473 }
2474 \f
2475 /* Mirrors. */
2476
2477 static int
2478 mirror_set__(struct ofproto *ofproto_, void *aux,
2479              const struct ofproto_mirror_settings *s)
2480 {
2481     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2482     struct ofbundle **srcs, **dsts;
2483     int error;
2484     size_t i;
2485
2486     if (!s) {
2487         mirror_destroy(ofproto->mbridge, aux);
2488         return 0;
2489     }
2490
2491     srcs = xmalloc(s->n_srcs * sizeof *srcs);
2492     dsts = xmalloc(s->n_dsts * sizeof *dsts);
2493
2494     for (i = 0; i < s->n_srcs; i++) {
2495         srcs[i] = bundle_lookup(ofproto, s->srcs[i]);
2496     }
2497
2498     for (i = 0; i < s->n_dsts; i++) {
2499         dsts[i] = bundle_lookup(ofproto, s->dsts[i]);
2500     }
2501
2502     error = mirror_set(ofproto->mbridge, aux, s->name, srcs, s->n_srcs, dsts,
2503                        s->n_dsts, s->src_vlans,
2504                        bundle_lookup(ofproto, s->out_bundle), s->out_vlan);
2505     free(srcs);
2506     free(dsts);
2507     return error;
2508 }
2509
2510 static int
2511 mirror_get_stats__(struct ofproto *ofproto, void *aux,
2512                    uint64_t *packets, uint64_t *bytes)
2513 {
2514     return mirror_get_stats(ofproto_dpif_cast(ofproto)->mbridge, aux, packets,
2515                             bytes);
2516 }
2517
2518 static int
2519 set_flood_vlans(struct ofproto *ofproto_, unsigned long *flood_vlans)
2520 {
2521     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2522     ovs_rwlock_wrlock(&ofproto->ml->rwlock);
2523     if (mac_learning_set_flood_vlans(ofproto->ml, flood_vlans)) {
2524         mac_learning_flush(ofproto->ml);
2525     }
2526     ovs_rwlock_unlock(&ofproto->ml->rwlock);
2527     return 0;
2528 }
2529
2530 static bool
2531 is_mirror_output_bundle(const struct ofproto *ofproto_, void *aux)
2532 {
2533     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2534     struct ofbundle *bundle = bundle_lookup(ofproto, aux);
2535     return bundle && mirror_bundle_out(ofproto->mbridge, bundle) != 0;
2536 }
2537
2538 static void
2539 forward_bpdu_changed(struct ofproto *ofproto_)
2540 {
2541     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2542     ofproto->backer->need_revalidate = REV_RECONFIGURE;
2543 }
2544
2545 static void
2546 set_mac_table_config(struct ofproto *ofproto_, unsigned int idle_time,
2547                      size_t max_entries)
2548 {
2549     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2550     ovs_rwlock_wrlock(&ofproto->ml->rwlock);
2551     mac_learning_set_idle_time(ofproto->ml, idle_time);
2552     mac_learning_set_max_entries(ofproto->ml, max_entries);
2553     ovs_rwlock_unlock(&ofproto->ml->rwlock);
2554 }
2555 \f
2556 /* Ports. */
2557
2558 static struct ofport_dpif *
2559 get_ofp_port(const struct ofproto_dpif *ofproto, ofp_port_t ofp_port)
2560 {
2561     struct ofport *ofport = ofproto_get_port(&ofproto->up, ofp_port);
2562     return ofport ? ofport_dpif_cast(ofport) : NULL;
2563 }
2564
2565 static void
2566 ofproto_port_from_dpif_port(struct ofproto_dpif *ofproto,
2567                             struct ofproto_port *ofproto_port,
2568                             struct dpif_port *dpif_port)
2569 {
2570     ofproto_port->name = dpif_port->name;
2571     ofproto_port->type = dpif_port->type;
2572     ofproto_port->ofp_port = odp_port_to_ofp_port(ofproto, dpif_port->port_no);
2573 }
2574
2575 static void
2576 ofport_update_peer(struct ofport_dpif *ofport)
2577 {
2578     const struct ofproto_dpif *ofproto;
2579     struct dpif_backer *backer;
2580     char *peer_name;
2581
2582     if (!netdev_vport_is_patch(ofport->up.netdev)) {
2583         return;
2584     }
2585
2586     backer = ofproto_dpif_cast(ofport->up.ofproto)->backer;
2587     backer->need_revalidate = REV_RECONFIGURE;
2588
2589     if (ofport->peer) {
2590         ofport->peer->peer = NULL;
2591         ofport->peer = NULL;
2592     }
2593
2594     peer_name = netdev_vport_patch_peer(ofport->up.netdev);
2595     if (!peer_name) {
2596         return;
2597     }
2598
2599     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
2600         struct ofport *peer_ofport;
2601         struct ofport_dpif *peer;
2602         char *peer_peer;
2603
2604         if (ofproto->backer != backer) {
2605             continue;
2606         }
2607
2608         peer_ofport = shash_find_data(&ofproto->up.port_by_name, peer_name);
2609         if (!peer_ofport) {
2610             continue;
2611         }
2612
2613         peer = ofport_dpif_cast(peer_ofport);
2614         peer_peer = netdev_vport_patch_peer(peer->up.netdev);
2615         if (peer_peer && !strcmp(netdev_get_name(ofport->up.netdev),
2616                                  peer_peer)) {
2617             ofport->peer = peer;
2618             ofport->peer->peer = ofport;
2619         }
2620         free(peer_peer);
2621
2622         break;
2623     }
2624     free(peer_name);
2625 }
2626
2627 static void
2628 port_run(struct ofport_dpif *ofport)
2629 {
2630     long long int carrier_seq = netdev_get_carrier_resets(ofport->up.netdev);
2631     bool carrier_changed = carrier_seq != ofport->carrier_seq;
2632     bool enable = netdev_get_carrier(ofport->up.netdev);
2633     bool cfm_enable = false;
2634     bool bfd_enable = false;
2635
2636     ofport->carrier_seq = carrier_seq;
2637
2638     if (ofport->cfm) {
2639         int cfm_opup = cfm_get_opup(ofport->cfm);
2640
2641         cfm_enable = !cfm_get_fault(ofport->cfm);
2642
2643         if (cfm_opup >= 0) {
2644             cfm_enable = cfm_enable && cfm_opup;
2645         }
2646     }
2647
2648     if (ofport->bfd) {
2649         bfd_enable = bfd_forwarding(ofport->bfd);
2650     }
2651
2652     if (ofport->bfd || ofport->cfm) {
2653         enable = enable && (cfm_enable || bfd_enable);
2654     }
2655
2656     if (ofport->bundle) {
2657         enable = enable && lacp_slave_may_enable(ofport->bundle->lacp, ofport);
2658         if (carrier_changed) {
2659             lacp_slave_carrier_changed(ofport->bundle->lacp, ofport);
2660         }
2661     }
2662
2663     if (ofport->may_enable != enable) {
2664         struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
2665         ofproto->backer->need_revalidate = REV_PORT_TOGGLED;
2666     }
2667
2668     ofport->may_enable = enable;
2669 }
2670
2671 static int
2672 port_query_by_name(const struct ofproto *ofproto_, const char *devname,
2673                    struct ofproto_port *ofproto_port)
2674 {
2675     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2676     struct dpif_port dpif_port;
2677     int error;
2678
2679     if (sset_contains(&ofproto->ghost_ports, devname)) {
2680         const char *type = netdev_get_type_from_name(devname);
2681
2682         /* We may be called before ofproto->up.port_by_name is populated with
2683          * the appropriate ofport.  For this reason, we must get the name and
2684          * type from the netdev layer directly. */
2685         if (type) {
2686             const struct ofport *ofport;
2687
2688             ofport = shash_find_data(&ofproto->up.port_by_name, devname);
2689             ofproto_port->ofp_port = ofport ? ofport->ofp_port : OFPP_NONE;
2690             ofproto_port->name = xstrdup(devname);
2691             ofproto_port->type = xstrdup(type);
2692             return 0;
2693         }
2694         return ENODEV;
2695     }
2696
2697     if (!sset_contains(&ofproto->ports, devname)) {
2698         return ENODEV;
2699     }
2700     error = dpif_port_query_by_name(ofproto->backer->dpif,
2701                                     devname, &dpif_port);
2702     if (!error) {
2703         ofproto_port_from_dpif_port(ofproto, ofproto_port, &dpif_port);
2704     }
2705     return error;
2706 }
2707
2708 static int
2709 port_add(struct ofproto *ofproto_, struct netdev *netdev)
2710 {
2711     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2712     const char *devname = netdev_get_name(netdev);
2713     char namebuf[NETDEV_VPORT_NAME_BUFSIZE];
2714     const char *dp_port_name;
2715
2716     if (netdev_vport_is_patch(netdev)) {
2717         sset_add(&ofproto->ghost_ports, netdev_get_name(netdev));
2718         return 0;
2719     }
2720
2721     dp_port_name = netdev_vport_get_dpif_port(netdev, namebuf, sizeof namebuf);
2722     if (!dpif_port_exists(ofproto->backer->dpif, dp_port_name)) {
2723         odp_port_t port_no = ODPP_NONE;
2724         int error;
2725
2726         error = dpif_port_add(ofproto->backer->dpif, netdev, &port_no);
2727         if (error) {
2728             return error;
2729         }
2730         if (netdev_get_tunnel_config(netdev)) {
2731             simap_put(&ofproto->backer->tnl_backers,
2732                       dp_port_name, odp_to_u32(port_no));
2733         }
2734     }
2735
2736     if (netdev_get_tunnel_config(netdev)) {
2737         sset_add(&ofproto->ghost_ports, devname);
2738     } else {
2739         sset_add(&ofproto->ports, devname);
2740     }
2741     return 0;
2742 }
2743
2744 static int
2745 port_del(struct ofproto *ofproto_, ofp_port_t ofp_port)
2746 {
2747     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2748     struct ofport_dpif *ofport = get_ofp_port(ofproto, ofp_port);
2749     int error = 0;
2750
2751     if (!ofport) {
2752         return 0;
2753     }
2754
2755     sset_find_and_delete(&ofproto->ghost_ports,
2756                          netdev_get_name(ofport->up.netdev));
2757     ofproto->backer->need_revalidate = REV_RECONFIGURE;
2758     if (!ofport->is_tunnel && !netdev_vport_is_patch(ofport->up.netdev)) {
2759         error = dpif_port_del(ofproto->backer->dpif, ofport->odp_port);
2760         if (!error) {
2761             /* The caller is going to close ofport->up.netdev.  If this is a
2762              * bonded port, then the bond is using that netdev, so remove it
2763              * from the bond.  The client will need to reconfigure everything
2764              * after deleting ports, so then the slave will get re-added. */
2765             bundle_remove(&ofport->up);
2766         }
2767     }
2768     return error;
2769 }
2770
2771 static int
2772 port_get_stats(const struct ofport *ofport_, struct netdev_stats *stats)
2773 {
2774     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
2775     int error;
2776
2777     error = netdev_get_stats(ofport->up.netdev, stats);
2778
2779     if (!error && ofport_->ofp_port == OFPP_LOCAL) {
2780         struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
2781
2782         ovs_mutex_lock(&ofproto->stats_mutex);
2783         /* ofproto->stats.tx_packets represents packets that we created
2784          * internally and sent to some port (e.g. packets sent with
2785          * ofproto_dpif_send_packet()).  Account for them as if they had
2786          * come from OFPP_LOCAL and got forwarded. */
2787
2788         if (stats->rx_packets != UINT64_MAX) {
2789             stats->rx_packets += ofproto->stats.tx_packets;
2790         }
2791
2792         if (stats->rx_bytes != UINT64_MAX) {
2793             stats->rx_bytes += ofproto->stats.tx_bytes;
2794         }
2795
2796         /* ofproto->stats.rx_packets represents packets that were received on
2797          * some port and we processed internally and dropped (e.g. STP).
2798          * Account for them as if they had been forwarded to OFPP_LOCAL. */
2799
2800         if (stats->tx_packets != UINT64_MAX) {
2801             stats->tx_packets += ofproto->stats.rx_packets;
2802         }
2803
2804         if (stats->tx_bytes != UINT64_MAX) {
2805             stats->tx_bytes += ofproto->stats.rx_bytes;
2806         }
2807         ovs_mutex_unlock(&ofproto->stats_mutex);
2808     }
2809
2810     return error;
2811 }
2812
2813 struct port_dump_state {
2814     uint32_t bucket;
2815     uint32_t offset;
2816     bool ghost;
2817
2818     struct ofproto_port port;
2819     bool has_port;
2820 };
2821
2822 static int
2823 port_dump_start(const struct ofproto *ofproto_ OVS_UNUSED, void **statep)
2824 {
2825     *statep = xzalloc(sizeof(struct port_dump_state));
2826     return 0;
2827 }
2828
2829 static int
2830 port_dump_next(const struct ofproto *ofproto_, void *state_,
2831                struct ofproto_port *port)
2832 {
2833     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2834     struct port_dump_state *state = state_;
2835     const struct sset *sset;
2836     struct sset_node *node;
2837
2838     if (state->has_port) {
2839         ofproto_port_destroy(&state->port);
2840         state->has_port = false;
2841     }
2842     sset = state->ghost ? &ofproto->ghost_ports : &ofproto->ports;
2843     while ((node = sset_at_position(sset, &state->bucket, &state->offset))) {
2844         int error;
2845
2846         error = port_query_by_name(ofproto_, node->name, &state->port);
2847         if (!error) {
2848             *port = state->port;
2849             state->has_port = true;
2850             return 0;
2851         } else if (error != ENODEV) {
2852             return error;
2853         }
2854     }
2855
2856     if (!state->ghost) {
2857         state->ghost = true;
2858         state->bucket = 0;
2859         state->offset = 0;
2860         return port_dump_next(ofproto_, state_, port);
2861     }
2862
2863     return EOF;
2864 }
2865
2866 static int
2867 port_dump_done(const struct ofproto *ofproto_ OVS_UNUSED, void *state_)
2868 {
2869     struct port_dump_state *state = state_;
2870
2871     if (state->has_port) {
2872         ofproto_port_destroy(&state->port);
2873     }
2874     free(state);
2875     return 0;
2876 }
2877
2878 static int
2879 port_poll(const struct ofproto *ofproto_, char **devnamep)
2880 {
2881     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2882
2883     if (ofproto->port_poll_errno) {
2884         int error = ofproto->port_poll_errno;
2885         ofproto->port_poll_errno = 0;
2886         return error;
2887     }
2888
2889     if (sset_is_empty(&ofproto->port_poll_set)) {
2890         return EAGAIN;
2891     }
2892
2893     *devnamep = sset_pop(&ofproto->port_poll_set);
2894     return 0;
2895 }
2896
2897 static void
2898 port_poll_wait(const struct ofproto *ofproto_)
2899 {
2900     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2901     dpif_port_poll_wait(ofproto->backer->dpif);
2902 }
2903
2904 static int
2905 port_is_lacp_current(const struct ofport *ofport_)
2906 {
2907     const struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
2908     return (ofport->bundle && ofport->bundle->lacp
2909             ? lacp_slave_is_current(ofport->bundle->lacp, ofport)
2910             : -1);
2911 }
2912 \f
2913 /* If 'rule' is an OpenFlow rule, that has expired according to OpenFlow rules,
2914  * then delete it entirely. */
2915 static void
2916 rule_expire(struct rule_dpif *rule)
2917     OVS_REQUIRES(ofproto_mutex)
2918 {
2919     uint16_t hard_timeout, idle_timeout;
2920     long long int now = time_msec();
2921     int reason = -1;
2922
2923     ovs_assert(!rule->up.pending);
2924
2925     hard_timeout = rule->up.hard_timeout;
2926     idle_timeout = rule->up.idle_timeout;
2927
2928     /* Has 'rule' expired? */
2929     if (hard_timeout) {
2930         long long int modified;
2931
2932         ovs_mutex_lock(&rule->up.mutex);
2933         modified = rule->up.modified;
2934         ovs_mutex_unlock(&rule->up.mutex);
2935
2936         if (now > modified + hard_timeout * 1000) {
2937             reason = OFPRR_HARD_TIMEOUT;
2938         }
2939     }
2940
2941     if (reason < 0 && idle_timeout) {
2942         long long int used;
2943
2944         ovs_mutex_lock(&rule->stats_mutex);
2945         used = rule->stats.used;
2946         ovs_mutex_unlock(&rule->stats_mutex);
2947
2948         if (now > used + idle_timeout * 1000) {
2949             reason = OFPRR_IDLE_TIMEOUT;
2950         }
2951     }
2952
2953     if (reason >= 0) {
2954         COVERAGE_INC(ofproto_dpif_expired);
2955         ofproto_rule_expire(&rule->up, reason);
2956     }
2957 }
2958
2959 /* Executes, within 'ofproto', the actions in 'rule' or 'ofpacts' on 'packet'.
2960  * 'flow' must reflect the data in 'packet'. */
2961 int
2962 ofproto_dpif_execute_actions(struct ofproto_dpif *ofproto,
2963                              const struct flow *flow,
2964                              struct rule_dpif *rule,
2965                              const struct ofpact *ofpacts, size_t ofpacts_len,
2966                              struct ofpbuf *packet)
2967 {
2968     struct dpif_flow_stats stats;
2969     struct xlate_out xout;
2970     struct xlate_in xin;
2971     ofp_port_t in_port;
2972     struct dpif_execute execute;
2973     int error;
2974
2975     ovs_assert((rule != NULL) != (ofpacts != NULL));
2976
2977     dpif_flow_stats_extract(flow, packet, time_msec(), &stats);
2978     if (rule) {
2979         rule_dpif_credit_stats(rule, &stats);
2980     }
2981
2982     xlate_in_init(&xin, ofproto, flow, rule, stats.tcp_flags, packet);
2983     xin.ofpacts = ofpacts;
2984     xin.ofpacts_len = ofpacts_len;
2985     xin.resubmit_stats = &stats;
2986     xlate_actions(&xin, &xout);
2987
2988     in_port = flow->in_port.ofp_port;
2989     if (in_port == OFPP_NONE) {
2990         in_port = OFPP_LOCAL;
2991     }
2992     execute.actions = xout.odp_actions.data;
2993     execute.actions_len = xout.odp_actions.size;
2994     execute.packet = packet;
2995     execute.md.tunnel = flow->tunnel;
2996     execute.md.skb_priority = flow->skb_priority;
2997     execute.md.pkt_mark = flow->pkt_mark;
2998     execute.md.in_port.odp_port = ofp_port_to_odp_port(ofproto, in_port);
2999     execute.needs_help = (xout.slow & SLOW_ACTION) != 0;
3000
3001     error = dpif_execute(ofproto->backer->dpif, &execute);
3002
3003     xlate_out_uninit(&xout);
3004
3005     return error;
3006 }
3007
3008 void
3009 rule_dpif_credit_stats(struct rule_dpif *rule,
3010                        const struct dpif_flow_stats *stats)
3011 {
3012     ovs_mutex_lock(&rule->stats_mutex);
3013     rule->stats.n_packets += stats->n_packets;
3014     rule->stats.n_bytes += stats->n_bytes;
3015     rule->stats.used = MAX(rule->stats.used, stats->used);
3016     ovs_mutex_unlock(&rule->stats_mutex);
3017 }
3018
3019 bool
3020 rule_dpif_is_fail_open(const struct rule_dpif *rule)
3021 {
3022     return is_fail_open_rule(&rule->up);
3023 }
3024
3025 bool
3026 rule_dpif_is_table_miss(const struct rule_dpif *rule)
3027 {
3028     return rule_is_table_miss(&rule->up);
3029 }
3030
3031 ovs_be64
3032 rule_dpif_get_flow_cookie(const struct rule_dpif *rule)
3033     OVS_REQUIRES(rule->up.mutex)
3034 {
3035     return rule->up.flow_cookie;
3036 }
3037
3038 void
3039 rule_dpif_reduce_timeouts(struct rule_dpif *rule, uint16_t idle_timeout,
3040                      uint16_t hard_timeout)
3041 {
3042     ofproto_rule_reduce_timeouts(&rule->up, idle_timeout, hard_timeout);
3043 }
3044
3045 /* Returns 'rule''s actions.  The caller owns a reference on the returned
3046  * actions and must eventually release it (with rule_actions_unref()) to avoid
3047  * a memory leak. */
3048 struct rule_actions *
3049 rule_dpif_get_actions(const struct rule_dpif *rule)
3050 {
3051     return rule_get_actions(&rule->up);
3052 }
3053
3054 /* Lookup 'flow' in 'ofproto''s classifier.  If 'wc' is non-null, sets
3055  * the fields that were relevant as part of the lookup. */
3056 void
3057 rule_dpif_lookup(struct ofproto_dpif *ofproto, const struct flow *flow,
3058                  struct flow_wildcards *wc, struct rule_dpif **rule)
3059 {
3060     struct ofport_dpif *port;
3061
3062     if (rule_dpif_lookup_in_table(ofproto, flow, wc, 0, rule)) {
3063         return;
3064     }
3065     port = get_ofp_port(ofproto, flow->in_port.ofp_port);
3066     if (!port) {
3067         VLOG_WARN_RL(&rl, "packet-in on unknown OpenFlow port %"PRIu16,
3068                      flow->in_port.ofp_port);
3069     }
3070
3071     choose_miss_rule(port ? port->up.pp.config : 0, ofproto->miss_rule,
3072                      ofproto->no_packet_in_rule, rule);
3073 }
3074
3075 bool
3076 rule_dpif_lookup_in_table(struct ofproto_dpif *ofproto,
3077                           const struct flow *flow, struct flow_wildcards *wc,
3078                           uint8_t table_id, struct rule_dpif **rule)
3079 {
3080     const struct cls_rule *cls_rule;
3081     struct classifier *cls;
3082     bool frag;
3083
3084     *rule = NULL;
3085     if (table_id >= N_TABLES) {
3086         return false;
3087     }
3088
3089     if (wc) {
3090         memset(&wc->masks.dl_type, 0xff, sizeof wc->masks.dl_type);
3091         if (is_ip_any(flow)) {
3092             wc->masks.nw_frag |= FLOW_NW_FRAG_MASK;
3093         }
3094     }
3095
3096     cls = &ofproto->up.tables[table_id].cls;
3097     fat_rwlock_rdlock(&cls->rwlock);
3098     frag = (flow->nw_frag & FLOW_NW_FRAG_ANY) != 0;
3099     if (frag && ofproto->up.frag_handling == OFPC_FRAG_NORMAL) {
3100         /* We must pretend that transport ports are unavailable. */
3101         struct flow ofpc_normal_flow = *flow;
3102         ofpc_normal_flow.tp_src = htons(0);
3103         ofpc_normal_flow.tp_dst = htons(0);
3104         cls_rule = classifier_lookup(cls, &ofpc_normal_flow, wc);
3105     } else if (frag && ofproto->up.frag_handling == OFPC_FRAG_DROP) {
3106         cls_rule = &ofproto->drop_frags_rule->up.cr;
3107         /* Frag mask in wc already set above. */
3108     } else {
3109         cls_rule = classifier_lookup(cls, flow, wc);
3110     }
3111
3112     *rule = rule_dpif_cast(rule_from_cls_rule(cls_rule));
3113     rule_dpif_ref(*rule);
3114     fat_rwlock_unlock(&cls->rwlock);
3115
3116     return *rule != NULL;
3117 }
3118
3119 /* Given a port configuration (specified as zero if there's no port), chooses
3120  * which of 'miss_rule' and 'no_packet_in_rule' should be used in case of a
3121  * flow table miss. */
3122 void
3123 choose_miss_rule(enum ofputil_port_config config, struct rule_dpif *miss_rule,
3124                  struct rule_dpif *no_packet_in_rule, struct rule_dpif **rule)
3125 {
3126     *rule = config & OFPUTIL_PC_NO_PACKET_IN ? no_packet_in_rule : miss_rule;
3127     rule_dpif_ref(*rule);
3128 }
3129
3130 void
3131 rule_dpif_ref(struct rule_dpif *rule)
3132 {
3133     if (rule) {
3134         ofproto_rule_ref(&rule->up);
3135     }
3136 }
3137
3138 void
3139 rule_dpif_unref(struct rule_dpif *rule)
3140 {
3141     if (rule) {
3142         ofproto_rule_unref(&rule->up);
3143     }
3144 }
3145
3146 static void
3147 complete_operation(struct rule_dpif *rule)
3148     OVS_REQUIRES(ofproto_mutex)
3149 {
3150     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
3151
3152     ofproto->backer->need_revalidate = REV_FLOW_TABLE;
3153     ofoperation_complete(rule->up.pending, 0);
3154 }
3155
3156 static struct rule_dpif *rule_dpif_cast(const struct rule *rule)
3157 {
3158     return rule ? CONTAINER_OF(rule, struct rule_dpif, up) : NULL;
3159 }
3160
3161 static struct rule *
3162 rule_alloc(void)
3163 {
3164     struct rule_dpif *rule = xmalloc(sizeof *rule);
3165     return &rule->up;
3166 }
3167
3168 static void
3169 rule_dealloc(struct rule *rule_)
3170 {
3171     struct rule_dpif *rule = rule_dpif_cast(rule_);
3172     free(rule);
3173 }
3174
3175 static enum ofperr
3176 rule_construct(struct rule *rule_)
3177     OVS_NO_THREAD_SAFETY_ANALYSIS
3178 {
3179     struct rule_dpif *rule = rule_dpif_cast(rule_);
3180     ovs_mutex_init_adaptive(&rule->stats_mutex);
3181     rule->stats.n_packets = 0;
3182     rule->stats.n_bytes = 0;
3183     rule->stats.used = rule->up.modified;
3184     return 0;
3185 }
3186
3187 static void
3188 rule_insert(struct rule *rule_)
3189     OVS_REQUIRES(ofproto_mutex)
3190 {
3191     struct rule_dpif *rule = rule_dpif_cast(rule_);
3192     complete_operation(rule);
3193 }
3194
3195 static void
3196 rule_delete(struct rule *rule_)
3197     OVS_REQUIRES(ofproto_mutex)
3198 {
3199     struct rule_dpif *rule = rule_dpif_cast(rule_);
3200     complete_operation(rule);
3201 }
3202
3203 static void
3204 rule_destruct(struct rule *rule_)
3205 {
3206     struct rule_dpif *rule = rule_dpif_cast(rule_);
3207     ovs_mutex_destroy(&rule->stats_mutex);
3208 }
3209
3210 static void
3211 rule_get_stats(struct rule *rule_, uint64_t *packets, uint64_t *bytes,
3212                long long int *used)
3213 {
3214     struct rule_dpif *rule = rule_dpif_cast(rule_);
3215
3216     ovs_mutex_lock(&rule->stats_mutex);
3217     *packets = rule->stats.n_packets;
3218     *bytes = rule->stats.n_bytes;
3219     *used = rule->stats.used;
3220     ovs_mutex_unlock(&rule->stats_mutex);
3221 }
3222
3223 static void
3224 rule_dpif_execute(struct rule_dpif *rule, const struct flow *flow,
3225                   struct ofpbuf *packet)
3226 {
3227     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
3228
3229     ofproto_dpif_execute_actions(ofproto, flow, rule, NULL, 0, packet);
3230 }
3231
3232 static enum ofperr
3233 rule_execute(struct rule *rule, const struct flow *flow,
3234              struct ofpbuf *packet)
3235 {
3236     rule_dpif_execute(rule_dpif_cast(rule), flow, packet);
3237     ofpbuf_delete(packet);
3238     return 0;
3239 }
3240
3241 static void
3242 rule_modify_actions(struct rule *rule_, bool reset_counters)
3243     OVS_REQUIRES(ofproto_mutex)
3244 {
3245     struct rule_dpif *rule = rule_dpif_cast(rule_);
3246
3247     if (reset_counters) {
3248         ovs_mutex_lock(&rule->stats_mutex);
3249         rule->stats.n_packets = 0;
3250         rule->stats.n_bytes = 0;
3251         ovs_mutex_unlock(&rule->stats_mutex);
3252     }
3253
3254     complete_operation(rule);
3255 }
3256
3257 static struct group_dpif *group_dpif_cast(const struct ofgroup *group)
3258 {
3259     return group ? CONTAINER_OF(group, struct group_dpif, up) : NULL;
3260 }
3261
3262 static struct ofgroup *
3263 group_alloc(void)
3264 {
3265     struct group_dpif *group = xzalloc(sizeof *group);
3266     return &group->up;
3267 }
3268
3269 static void
3270 group_dealloc(struct ofgroup *group_)
3271 {
3272     struct group_dpif *group = group_dpif_cast(group_);
3273     free(group);
3274 }
3275
3276 static void
3277 group_construct_stats(struct group_dpif *group)
3278     OVS_REQUIRES(group->stats_mutex)
3279 {
3280     group->packet_count = 0;
3281     group->byte_count = 0;
3282     if (!group->bucket_stats) {
3283         group->bucket_stats = xcalloc(group->up.n_buckets,
3284                                       sizeof *group->bucket_stats);
3285     } else {
3286         memset(group->bucket_stats, 0, group->up.n_buckets *
3287                sizeof *group->bucket_stats);
3288     }
3289 }
3290
3291 static enum ofperr
3292 group_construct(struct ofgroup *group_)
3293 {
3294     struct group_dpif *group = group_dpif_cast(group_);
3295     const struct ofputil_bucket *bucket;
3296
3297     /* Prevent group chaining because our locking structure makes it hard to
3298      * implement deadlock-free.  (See xlate_group_resource_check().) */
3299     LIST_FOR_EACH (bucket, list_node, &group->up.buckets) {
3300         const struct ofpact *a;
3301
3302         OFPACT_FOR_EACH (a, bucket->ofpacts, bucket->ofpacts_len) {
3303             if (a->type == OFPACT_GROUP) {
3304                 return OFPERR_OFPGMFC_CHAINING_UNSUPPORTED;
3305             }
3306         }
3307     }
3308
3309     ovs_mutex_init_adaptive(&group->stats_mutex);
3310     ovs_mutex_lock(&group->stats_mutex);
3311     group_construct_stats(group);
3312     ovs_mutex_unlock(&group->stats_mutex);
3313     return 0;
3314 }
3315
3316 static void
3317 group_destruct__(struct group_dpif *group)
3318     OVS_REQUIRES(group->stats_mutex)
3319 {
3320     free(group->bucket_stats);
3321     group->bucket_stats = NULL;
3322 }
3323
3324 static void
3325 group_destruct(struct ofgroup *group_)
3326 {
3327     struct group_dpif *group = group_dpif_cast(group_);
3328     ovs_mutex_lock(&group->stats_mutex);
3329     group_destruct__(group);
3330     ovs_mutex_unlock(&group->stats_mutex);
3331     ovs_mutex_destroy(&group->stats_mutex);
3332 }
3333
3334 static enum ofperr
3335 group_modify(struct ofgroup *group_, struct ofgroup *victim_)
3336 {
3337     struct group_dpif *group = group_dpif_cast(group_);
3338     struct group_dpif *victim = group_dpif_cast(victim_);
3339
3340     ovs_mutex_lock(&group->stats_mutex);
3341     if (victim->up.n_buckets < group->up.n_buckets) {
3342         group_destruct__(group);
3343     }
3344     group_construct_stats(group);
3345     ovs_mutex_unlock(&group->stats_mutex);
3346
3347     return 0;
3348 }
3349
3350 static enum ofperr
3351 group_get_stats(const struct ofgroup *group_, struct ofputil_group_stats *ogs)
3352 {
3353     struct group_dpif *group = group_dpif_cast(group_);
3354
3355     ovs_mutex_lock(&group->stats_mutex);
3356     ogs->packet_count = group->packet_count;
3357     ogs->byte_count = group->byte_count;
3358     memcpy(ogs->bucket_stats, group->bucket_stats,
3359            group->up.n_buckets * sizeof *group->bucket_stats);
3360     ovs_mutex_unlock(&group->stats_mutex);
3361
3362     return 0;
3363 }
3364
3365 bool
3366 group_dpif_lookup(struct ofproto_dpif *ofproto, uint32_t group_id,
3367                   struct group_dpif **group)
3368     OVS_TRY_RDLOCK(true, (*group)->up.rwlock)
3369 {
3370     struct ofgroup *ofgroup;
3371     bool found;
3372
3373     *group = NULL;
3374     found = ofproto_group_lookup(&ofproto->up, group_id, &ofgroup);
3375     *group = found ?  group_dpif_cast(ofgroup) : NULL;
3376
3377     return found;
3378 }
3379
3380 void
3381 group_dpif_release(struct group_dpif *group)
3382     OVS_RELEASES(group->up.rwlock)
3383 {
3384     ofproto_group_release(&group->up);
3385 }
3386
3387 void
3388 group_dpif_get_buckets(const struct group_dpif *group,
3389                        const struct list **buckets)
3390 {
3391     *buckets = &group->up.buckets;
3392 }
3393
3394 enum ofp11_group_type
3395 group_dpif_get_type(const struct group_dpif *group)
3396 {
3397     return group->up.type;
3398 }
3399 \f
3400 /* Sends 'packet' out 'ofport'.
3401  * May modify 'packet'.
3402  * Returns 0 if successful, otherwise a positive errno value. */
3403 int
3404 ofproto_dpif_send_packet(const struct ofport_dpif *ofport, struct ofpbuf *packet)
3405 {
3406     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
3407     int error;
3408
3409     error = xlate_send_packet(ofport, packet);
3410
3411     ovs_mutex_lock(&ofproto->stats_mutex);
3412     ofproto->stats.tx_packets++;
3413     ofproto->stats.tx_bytes += packet->size;
3414     ovs_mutex_unlock(&ofproto->stats_mutex);
3415     return error;
3416 }
3417 \f
3418 static bool
3419 set_frag_handling(struct ofproto *ofproto_,
3420                   enum ofp_config_flags frag_handling)
3421 {
3422     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3423     if (frag_handling != OFPC_FRAG_REASM) {
3424         ofproto->backer->need_revalidate = REV_RECONFIGURE;
3425         return true;
3426     } else {
3427         return false;
3428     }
3429 }
3430
3431 static enum ofperr
3432 packet_out(struct ofproto *ofproto_, struct ofpbuf *packet,
3433            const struct flow *flow,
3434            const struct ofpact *ofpacts, size_t ofpacts_len)
3435 {
3436     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3437
3438     ofproto_dpif_execute_actions(ofproto, flow, NULL, ofpacts,
3439                                  ofpacts_len, packet);
3440     return 0;
3441 }
3442 \f
3443 /* NetFlow. */
3444
3445 static int
3446 set_netflow(struct ofproto *ofproto_,
3447             const struct netflow_options *netflow_options)
3448 {
3449     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3450
3451     if (netflow_options) {
3452         if (!ofproto->netflow) {
3453             ofproto->netflow = netflow_create();
3454             ofproto->backer->need_revalidate = REV_RECONFIGURE;
3455         }
3456         return netflow_set_options(ofproto->netflow, netflow_options);
3457     } else if (ofproto->netflow) {
3458         ofproto->backer->need_revalidate = REV_RECONFIGURE;
3459         netflow_unref(ofproto->netflow);
3460         ofproto->netflow = NULL;
3461     }
3462
3463     return 0;
3464 }
3465
3466 static void
3467 get_netflow_ids(const struct ofproto *ofproto_,
3468                 uint8_t *engine_type, uint8_t *engine_id)
3469 {
3470     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3471
3472     dpif_get_netflow_ids(ofproto->backer->dpif, engine_type, engine_id);
3473 }
3474 \f
3475 static struct ofproto_dpif *
3476 ofproto_dpif_lookup(const char *name)
3477 {
3478     struct ofproto_dpif *ofproto;
3479
3480     HMAP_FOR_EACH_WITH_HASH (ofproto, all_ofproto_dpifs_node,
3481                              hash_string(name, 0), &all_ofproto_dpifs) {
3482         if (!strcmp(ofproto->up.name, name)) {
3483             return ofproto;
3484         }
3485     }
3486     return NULL;
3487 }
3488
3489 static void
3490 ofproto_unixctl_fdb_flush(struct unixctl_conn *conn, int argc,
3491                           const char *argv[], void *aux OVS_UNUSED)
3492 {
3493     struct ofproto_dpif *ofproto;
3494
3495     if (argc > 1) {
3496         ofproto = ofproto_dpif_lookup(argv[1]);
3497         if (!ofproto) {
3498             unixctl_command_reply_error(conn, "no such bridge");
3499             return;
3500         }
3501         ovs_rwlock_wrlock(&ofproto->ml->rwlock);
3502         mac_learning_flush(ofproto->ml);
3503         ovs_rwlock_unlock(&ofproto->ml->rwlock);
3504     } else {
3505         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
3506             ovs_rwlock_wrlock(&ofproto->ml->rwlock);
3507             mac_learning_flush(ofproto->ml);
3508             ovs_rwlock_unlock(&ofproto->ml->rwlock);
3509         }
3510     }
3511
3512     unixctl_command_reply(conn, "table successfully flushed");
3513 }
3514
3515 static struct ofport_dpif *
3516 ofbundle_get_a_port(const struct ofbundle *bundle)
3517 {
3518     return CONTAINER_OF(list_front(&bundle->ports), struct ofport_dpif,
3519                         bundle_node);
3520 }
3521
3522 static void
3523 ofproto_unixctl_fdb_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
3524                          const char *argv[], void *aux OVS_UNUSED)
3525 {
3526     struct ds ds = DS_EMPTY_INITIALIZER;
3527     const struct ofproto_dpif *ofproto;
3528     const struct mac_entry *e;
3529
3530     ofproto = ofproto_dpif_lookup(argv[1]);
3531     if (!ofproto) {
3532         unixctl_command_reply_error(conn, "no such bridge");
3533         return;
3534     }
3535
3536     ds_put_cstr(&ds, " port  VLAN  MAC                Age\n");
3537     ovs_rwlock_rdlock(&ofproto->ml->rwlock);
3538     LIST_FOR_EACH (e, lru_node, &ofproto->ml->lrus) {
3539         struct ofbundle *bundle = e->port.p;
3540         char name[OFP_MAX_PORT_NAME_LEN];
3541
3542         ofputil_port_to_string(ofbundle_get_a_port(bundle)->up.ofp_port,
3543                                name, sizeof name);
3544         ds_put_format(&ds, "%5s  %4d  "ETH_ADDR_FMT"  %3d\n",
3545                       name, e->vlan, ETH_ADDR_ARGS(e->mac),
3546                       mac_entry_age(ofproto->ml, e));
3547     }
3548     ovs_rwlock_unlock(&ofproto->ml->rwlock);
3549     unixctl_command_reply(conn, ds_cstr(&ds));
3550     ds_destroy(&ds);
3551 }
3552
3553 struct trace_ctx {
3554     struct xlate_out xout;
3555     struct xlate_in xin;
3556     struct flow flow;
3557     struct flow_wildcards wc;
3558     struct ds *result;
3559 };
3560
3561 static void
3562 trace_format_rule(struct ds *result, int level, const struct rule_dpif *rule)
3563 {
3564     struct rule_actions *actions;
3565     ovs_be64 cookie;
3566
3567     ds_put_char_multiple(result, '\t', level);
3568     if (!rule) {
3569         ds_put_cstr(result, "No match\n");
3570         return;
3571     }
3572
3573     ovs_mutex_lock(&rule->up.mutex);
3574     cookie = rule->up.flow_cookie;
3575     ovs_mutex_unlock(&rule->up.mutex);
3576
3577     ds_put_format(result, "Rule: table=%"PRIu8" cookie=%#"PRIx64" ",
3578                   rule ? rule->up.table_id : 0, ntohll(cookie));
3579     cls_rule_format(&rule->up.cr, result);
3580     ds_put_char(result, '\n');
3581
3582     actions = rule_dpif_get_actions(rule);
3583
3584     ds_put_char_multiple(result, '\t', level);
3585     ds_put_cstr(result, "OpenFlow actions=");
3586     ofpacts_format(actions->ofpacts, actions->ofpacts_len, result);
3587     ds_put_char(result, '\n');
3588
3589     rule_actions_unref(actions);
3590 }
3591
3592 static void
3593 trace_format_flow(struct ds *result, int level, const char *title,
3594                   struct trace_ctx *trace)
3595 {
3596     ds_put_char_multiple(result, '\t', level);
3597     ds_put_format(result, "%s: ", title);
3598     if (flow_equal(&trace->xin.flow, &trace->flow)) {
3599         ds_put_cstr(result, "unchanged");
3600     } else {
3601         flow_format(result, &trace->xin.flow);
3602         trace->flow = trace->xin.flow;
3603     }
3604     ds_put_char(result, '\n');
3605 }
3606
3607 static void
3608 trace_format_regs(struct ds *result, int level, const char *title,
3609                   struct trace_ctx *trace)
3610 {
3611     size_t i;
3612
3613     ds_put_char_multiple(result, '\t', level);
3614     ds_put_format(result, "%s:", title);
3615     for (i = 0; i < FLOW_N_REGS; i++) {
3616         ds_put_format(result, " reg%"PRIuSIZE"=0x%"PRIx32, i, trace->flow.regs[i]);
3617     }
3618     ds_put_char(result, '\n');
3619 }
3620
3621 static void
3622 trace_format_odp(struct ds *result, int level, const char *title,
3623                  struct trace_ctx *trace)
3624 {
3625     struct ofpbuf *odp_actions = &trace->xout.odp_actions;
3626
3627     ds_put_char_multiple(result, '\t', level);
3628     ds_put_format(result, "%s: ", title);
3629     format_odp_actions(result, odp_actions->data, odp_actions->size);
3630     ds_put_char(result, '\n');
3631 }
3632
3633 static void
3634 trace_format_megaflow(struct ds *result, int level, const char *title,
3635                       struct trace_ctx *trace)
3636 {
3637     struct match match;
3638
3639     ds_put_char_multiple(result, '\t', level);
3640     ds_put_format(result, "%s: ", title);
3641     flow_wildcards_or(&trace->wc, &trace->xout.wc, &trace->wc);
3642     match_init(&match, &trace->flow, &trace->wc);
3643     match_format(&match, result, OFP_DEFAULT_PRIORITY);
3644     ds_put_char(result, '\n');
3645 }
3646
3647 static void
3648 trace_resubmit(struct xlate_in *xin, struct rule_dpif *rule, int recurse)
3649 {
3650     struct trace_ctx *trace = CONTAINER_OF(xin, struct trace_ctx, xin);
3651     struct ds *result = trace->result;
3652
3653     ds_put_char(result, '\n');
3654     trace_format_flow(result, recurse + 1, "Resubmitted flow", trace);
3655     trace_format_regs(result, recurse + 1, "Resubmitted regs", trace);
3656     trace_format_odp(result,  recurse + 1, "Resubmitted  odp", trace);
3657     trace_format_megaflow(result, recurse + 1, "Resubmitted megaflow", trace);
3658     trace_format_rule(result, recurse + 1, rule);
3659 }
3660
3661 static void
3662 trace_report(struct xlate_in *xin, const char *s, int recurse)
3663 {
3664     struct trace_ctx *trace = CONTAINER_OF(xin, struct trace_ctx, xin);
3665     struct ds *result = trace->result;
3666
3667     ds_put_char_multiple(result, '\t', recurse);
3668     ds_put_cstr(result, s);
3669     ds_put_char(result, '\n');
3670 }
3671
3672 /* Parses the 'argc' elements of 'argv', ignoring argv[0].  The following
3673  * forms are supported:
3674  *
3675  *     - [dpname] odp_flow [-generate | packet]
3676  *     - bridge br_flow [-generate | packet]
3677  *
3678  * On success, initializes '*ofprotop' and 'flow' and returns NULL.  On failure
3679  * returns a nonnull malloced error message. */
3680 static char * WARN_UNUSED_RESULT
3681 parse_flow_and_packet(int argc, const char *argv[],
3682                       struct ofproto_dpif **ofprotop, struct flow *flow,
3683                       struct ofpbuf **packetp)
3684 {
3685     const struct dpif_backer *backer = NULL;
3686     const char *error = NULL;
3687     char *m_err = NULL;
3688     struct simap port_names = SIMAP_INITIALIZER(&port_names);
3689     struct ofpbuf *packet;
3690     struct ofpbuf odp_key;
3691     struct ofpbuf odp_mask;
3692
3693     ofpbuf_init(&odp_key, 0);
3694     ofpbuf_init(&odp_mask, 0);
3695
3696     /* Handle "-generate" or a hex string as the last argument. */
3697     if (!strcmp(argv[argc - 1], "-generate")) {
3698         packet = ofpbuf_new(0);
3699         argc--;
3700     } else {
3701         error = eth_from_hex(argv[argc - 1], &packet);
3702         if (!error) {
3703             argc--;
3704         } else if (argc == 4) {
3705             /* The 3-argument form must end in "-generate' or a hex string. */
3706             goto exit;
3707         }
3708         error = NULL;
3709     }
3710
3711     /* odp_flow can have its in_port specified as a name instead of port no.
3712      * We do not yet know whether a given flow is a odp_flow or a br_flow.
3713      * But, to know whether a flow is odp_flow through odp_flow_from_string(),
3714      * we need to create a simap of name to port no. */
3715     if (argc == 3) {
3716         const char *dp_type;
3717         if (!strncmp(argv[1], "ovs-", 4)) {
3718             dp_type = argv[1] + 4;
3719         } else {
3720             dp_type = argv[1];
3721         }
3722         backer = shash_find_data(&all_dpif_backers, dp_type);
3723     } else if (argc == 2) {
3724         struct shash_node *node;
3725         if (shash_count(&all_dpif_backers) == 1) {
3726             node = shash_first(&all_dpif_backers);
3727             backer = node->data;
3728         }
3729     } else {
3730         error = "Syntax error";
3731         goto exit;
3732     }
3733     if (backer && backer->dpif) {
3734         struct dpif_port dpif_port;
3735         struct dpif_port_dump port_dump;
3736         DPIF_PORT_FOR_EACH (&dpif_port, &port_dump, backer->dpif) {
3737             simap_put(&port_names, dpif_port.name,
3738                       odp_to_u32(dpif_port.port_no));
3739         }
3740     }
3741
3742     /* Parse the flow and determine whether a datapath or
3743      * bridge is specified. If function odp_flow_key_from_string()
3744      * returns 0, the flow is a odp_flow. If function
3745      * parse_ofp_exact_flow() returns NULL, the flow is a br_flow. */
3746     if (!odp_flow_from_string(argv[argc - 1], &port_names,
3747                               &odp_key, &odp_mask)) {
3748         if (!backer) {
3749             error = "Cannot find the datapath";
3750             goto exit;
3751         }
3752
3753         if (xlate_receive(backer, NULL, odp_key.data, odp_key.size, flow,
3754                           ofprotop, NULL, NULL, NULL, NULL)) {
3755             error = "Invalid datapath flow";
3756             goto exit;
3757         }
3758     } else {
3759         char *err = parse_ofp_exact_flow(flow, NULL, argv[argc - 1], NULL);
3760
3761         if (err) {
3762             m_err = xasprintf("Bad flow syntax: %s", err);
3763             free(err);
3764             goto exit;
3765         } else {
3766             if (argc != 3) {
3767                 error = "Must specify bridge name";
3768                 goto exit;
3769             }
3770
3771             *ofprotop = ofproto_dpif_lookup(argv[1]);
3772             if (!*ofprotop) {
3773                 error = "Unknown bridge name";
3774                 goto exit;
3775             }
3776         }
3777     }
3778
3779     /* Generate a packet, if requested. */
3780     if (packet) {
3781         if (!packet->size) {
3782             flow_compose(packet, flow);
3783         } else {
3784             union flow_in_port in_port = flow->in_port;
3785             struct pkt_metadata md;
3786
3787             /* Use the metadata from the flow and the packet argument
3788              * to reconstruct the flow. */
3789             pkt_metadata_init(&md, NULL, flow->skb_priority,
3790                                    flow->pkt_mark, &in_port);
3791
3792             flow_extract(packet, &md, flow);
3793         }
3794     }
3795
3796 exit:
3797     if (error && !m_err) {
3798         m_err = xstrdup(error);
3799     }
3800     if (m_err) {
3801         ofpbuf_delete(packet);
3802         packet = NULL;
3803     }
3804     *packetp = packet;
3805     ofpbuf_uninit(&odp_key);
3806     ofpbuf_uninit(&odp_mask);
3807     simap_destroy(&port_names);
3808     return m_err;
3809 }
3810
3811 static void
3812 ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[],
3813                       void *aux OVS_UNUSED)
3814 {
3815     struct ofproto_dpif *ofproto;
3816     struct ofpbuf *packet;
3817     char *error;
3818     struct flow flow;
3819
3820     error = parse_flow_and_packet(argc, argv, &ofproto, &flow, &packet);
3821     if (!error) {
3822         struct ds result;
3823
3824         ds_init(&result);
3825         ofproto_trace(ofproto, &flow, packet, NULL, 0, &result);
3826         unixctl_command_reply(conn, ds_cstr(&result));
3827         ds_destroy(&result);
3828         ofpbuf_delete(packet);
3829     } else {
3830         unixctl_command_reply_error(conn, error);
3831         free(error);
3832     }
3833 }
3834
3835 static void
3836 ofproto_unixctl_trace_actions(struct unixctl_conn *conn, int argc,
3837                               const char *argv[], void *aux OVS_UNUSED)
3838 {
3839     enum ofputil_protocol usable_protocols;
3840     struct ofproto_dpif *ofproto;
3841     bool enforce_consistency;
3842     struct ofpbuf ofpacts;
3843     struct ofpbuf *packet;
3844     struct ds result;
3845     struct flow flow;
3846     uint16_t in_port;
3847
3848     /* Three kinds of error return values! */
3849     enum ofperr retval;
3850     char *error;
3851
3852     packet = NULL;
3853     ds_init(&result);
3854     ofpbuf_init(&ofpacts, 0);
3855
3856     /* Parse actions. */
3857     error = parse_ofpacts(argv[--argc], &ofpacts, &usable_protocols);
3858     if (error) {
3859         unixctl_command_reply_error(conn, error);
3860         free(error);
3861         goto exit;
3862     }
3863
3864     /* OpenFlow 1.1 and later suggest that the switch enforces certain forms of
3865      * consistency between the flow and the actions.  With -consistent, we
3866      * enforce consistency even for a flow supported in OpenFlow 1.0. */
3867     if (!strcmp(argv[1], "-consistent")) {
3868         enforce_consistency = true;
3869         argv++;
3870         argc--;
3871     } else {
3872         enforce_consistency = false;
3873     }
3874
3875     error = parse_flow_and_packet(argc, argv, &ofproto, &flow, &packet);
3876     if (error) {
3877         unixctl_command_reply_error(conn, error);
3878         free(error);
3879         goto exit;
3880     }
3881
3882     /* Do the same checks as handle_packet_out() in ofproto.c.
3883      *
3884      * We pass a 'table_id' of 0 to ofproto_check_ofpacts(), which isn't
3885      * strictly correct because these actions aren't in any table, but it's OK
3886      * because it 'table_id' is used only to check goto_table instructions, but
3887      * packet-outs take a list of actions and therefore it can't include
3888      * instructions.
3889      *
3890      * We skip the "meter" check here because meter is an instruction, not an
3891      * action, and thus cannot appear in ofpacts. */
3892     in_port = ofp_to_u16(flow.in_port.ofp_port);
3893     if (in_port >= ofproto->up.max_ports && in_port < ofp_to_u16(OFPP_MAX)) {
3894         unixctl_command_reply_error(conn, "invalid in_port");
3895         goto exit;
3896     }
3897     if (enforce_consistency) {
3898         retval = ofpacts_check_consistency(ofpacts.data, ofpacts.size, &flow,
3899                                            u16_to_ofp(ofproto->up.max_ports),
3900                                            0, 0, usable_protocols);
3901     } else {
3902         retval = ofpacts_check(ofpacts.data, ofpacts.size, &flow,
3903                                u16_to_ofp(ofproto->up.max_ports), 0, 0,
3904                                &usable_protocols);
3905     }
3906
3907     if (retval) {
3908         ds_clear(&result);
3909         ds_put_format(&result, "Bad actions: %s", ofperr_to_string(retval));
3910         unixctl_command_reply_error(conn, ds_cstr(&result));
3911         goto exit;
3912     }
3913
3914     ofproto_trace(ofproto, &flow, packet, ofpacts.data, ofpacts.size, &result);
3915     unixctl_command_reply(conn, ds_cstr(&result));
3916
3917 exit:
3918     ds_destroy(&result);
3919     ofpbuf_delete(packet);
3920     ofpbuf_uninit(&ofpacts);
3921 }
3922
3923 /* Implements a "trace" through 'ofproto''s flow table, appending a textual
3924  * description of the results to 'ds'.
3925  *
3926  * The trace follows a packet with the specified 'flow' through the flow
3927  * table.  'packet' may be nonnull to trace an actual packet, with consequent
3928  * side effects (if it is nonnull then its flow must be 'flow').
3929  *
3930  * If 'ofpacts' is nonnull then its 'ofpacts_len' bytes specify the actions to
3931  * trace, otherwise the actions are determined by a flow table lookup. */
3932 static void
3933 ofproto_trace(struct ofproto_dpif *ofproto, const struct flow *flow,
3934               const struct ofpbuf *packet,
3935               const struct ofpact ofpacts[], size_t ofpacts_len,
3936               struct ds *ds)
3937 {
3938     struct rule_dpif *rule;
3939     struct trace_ctx trace;
3940
3941     ds_put_format(ds, "Bridge: %s\n", ofproto->up.name);
3942     ds_put_cstr(ds, "Flow: ");
3943     flow_format(ds, flow);
3944     ds_put_char(ds, '\n');
3945
3946     flow_wildcards_init_catchall(&trace.wc);
3947     if (ofpacts) {
3948         rule = NULL;
3949     } else {
3950         rule_dpif_lookup(ofproto, flow, &trace.wc, &rule);
3951
3952         trace_format_rule(ds, 0, rule);
3953         if (rule == ofproto->miss_rule) {
3954             ds_put_cstr(ds, "\nNo match, flow generates \"packet in\"s.\n");
3955         } else if (rule == ofproto->no_packet_in_rule) {
3956             ds_put_cstr(ds, "\nNo match, packets dropped because "
3957                         "OFPPC_NO_PACKET_IN is set on in_port.\n");
3958         } else if (rule == ofproto->drop_frags_rule) {
3959             ds_put_cstr(ds, "\nPackets dropped because they are IP fragments "
3960                         "and the fragment handling mode is \"drop\".\n");
3961         }
3962     }
3963
3964     if (rule || ofpacts) {
3965         uint16_t tcp_flags;
3966
3967         tcp_flags = packet ? packet_get_tcp_flags(packet, flow) : 0;
3968         trace.result = ds;
3969         trace.flow = *flow;
3970         xlate_in_init(&trace.xin, ofproto, flow, rule, tcp_flags, packet);
3971         if (ofpacts) {
3972             trace.xin.ofpacts = ofpacts;
3973             trace.xin.ofpacts_len = ofpacts_len;
3974         }
3975         trace.xin.resubmit_hook = trace_resubmit;
3976         trace.xin.report_hook = trace_report;
3977
3978         xlate_actions(&trace.xin, &trace.xout);
3979
3980         ds_put_char(ds, '\n');
3981         trace_format_flow(ds, 0, "Final flow", &trace);
3982         trace_format_megaflow(ds, 0, "Megaflow", &trace);
3983
3984         ds_put_cstr(ds, "Datapath actions: ");
3985         format_odp_actions(ds, trace.xout.odp_actions.data,
3986                            trace.xout.odp_actions.size);
3987
3988         if (trace.xout.slow) {
3989             enum slow_path_reason slow;
3990
3991             ds_put_cstr(ds, "\nThis flow is handled by the userspace "
3992                         "slow path because it:");
3993
3994             slow = trace.xout.slow;
3995             while (slow) {
3996                 enum slow_path_reason bit = rightmost_1bit(slow);
3997
3998                 ds_put_format(ds, "\n\t- %s.",
3999                               slow_path_reason_to_explanation(bit));
4000
4001                 slow &= ~bit;
4002             }
4003         }
4004
4005         xlate_out_uninit(&trace.xout);
4006     }
4007
4008     rule_dpif_unref(rule);
4009 }
4010
4011 /* Store the current ofprotos in 'ofproto_shash'.  Returns a sorted list
4012  * of the 'ofproto_shash' nodes.  It is the responsibility of the caller
4013  * to destroy 'ofproto_shash' and free the returned value. */
4014 static const struct shash_node **
4015 get_ofprotos(struct shash *ofproto_shash)
4016 {
4017     const struct ofproto_dpif *ofproto;
4018
4019     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
4020         char *name = xasprintf("%s@%s", ofproto->up.type, ofproto->up.name);
4021         shash_add_nocopy(ofproto_shash, name, ofproto);
4022     }
4023
4024     return shash_sort(ofproto_shash);
4025 }
4026
4027 static void
4028 ofproto_unixctl_dpif_dump_dps(struct unixctl_conn *conn, int argc OVS_UNUSED,
4029                               const char *argv[] OVS_UNUSED,
4030                               void *aux OVS_UNUSED)
4031 {
4032     struct ds ds = DS_EMPTY_INITIALIZER;
4033     struct shash ofproto_shash;
4034     const struct shash_node **sorted_ofprotos;
4035     int i;
4036
4037     shash_init(&ofproto_shash);
4038     sorted_ofprotos = get_ofprotos(&ofproto_shash);
4039     for (i = 0; i < shash_count(&ofproto_shash); i++) {
4040         const struct shash_node *node = sorted_ofprotos[i];
4041         ds_put_format(&ds, "%s\n", node->name);
4042     }
4043
4044     shash_destroy(&ofproto_shash);
4045     free(sorted_ofprotos);
4046
4047     unixctl_command_reply(conn, ds_cstr(&ds));
4048     ds_destroy(&ds);
4049 }
4050
4051 static void
4052 dpif_show_backer(const struct dpif_backer *backer, struct ds *ds)
4053 {
4054     const struct shash_node **ofprotos;
4055     struct dpif_dp_stats dp_stats;
4056     struct shash ofproto_shash;
4057     size_t i;
4058
4059     dpif_get_dp_stats(backer->dpif, &dp_stats);
4060
4061     ds_put_format(ds, "%s: hit:%"PRIu64" missed:%"PRIu64"\n",
4062                   dpif_name(backer->dpif), dp_stats.n_hit, dp_stats.n_missed);
4063
4064     shash_init(&ofproto_shash);
4065     ofprotos = get_ofprotos(&ofproto_shash);
4066     for (i = 0; i < shash_count(&ofproto_shash); i++) {
4067         struct ofproto_dpif *ofproto = ofprotos[i]->data;
4068         const struct shash_node **ports;
4069         size_t j;
4070
4071         if (ofproto->backer != backer) {
4072             continue;
4073         }
4074
4075         ds_put_format(ds, "\t%s:\n", ofproto->up.name);
4076
4077         ports = shash_sort(&ofproto->up.port_by_name);
4078         for (j = 0; j < shash_count(&ofproto->up.port_by_name); j++) {
4079             const struct shash_node *node = ports[j];
4080             struct ofport *ofport = node->data;
4081             struct smap config;
4082             odp_port_t odp_port;
4083
4084             ds_put_format(ds, "\t\t%s %u/", netdev_get_name(ofport->netdev),
4085                           ofport->ofp_port);
4086
4087             odp_port = ofp_port_to_odp_port(ofproto, ofport->ofp_port);
4088             if (odp_port != ODPP_NONE) {
4089                 ds_put_format(ds, "%"PRIu32":", odp_port);
4090             } else {
4091                 ds_put_cstr(ds, "none:");
4092             }
4093
4094             ds_put_format(ds, " (%s", netdev_get_type(ofport->netdev));
4095
4096             smap_init(&config);
4097             if (!netdev_get_config(ofport->netdev, &config)) {
4098                 const struct smap_node **nodes;
4099                 size_t i;
4100
4101                 nodes = smap_sort(&config);
4102                 for (i = 0; i < smap_count(&config); i++) {
4103                     const struct smap_node *node = nodes[i];
4104                     ds_put_format(ds, "%c %s=%s", i ? ',' : ':',
4105                                   node->key, node->value);
4106                 }
4107                 free(nodes);
4108             }
4109             smap_destroy(&config);
4110
4111             ds_put_char(ds, ')');
4112             ds_put_char(ds, '\n');
4113         }
4114         free(ports);
4115     }
4116     shash_destroy(&ofproto_shash);
4117     free(ofprotos);
4118 }
4119
4120 static void
4121 ofproto_unixctl_dpif_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
4122                           const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
4123 {
4124     struct ds ds = DS_EMPTY_INITIALIZER;
4125     const struct shash_node **backers;
4126     int i;
4127
4128     backers = shash_sort(&all_dpif_backers);
4129     for (i = 0; i < shash_count(&all_dpif_backers); i++) {
4130         dpif_show_backer(backers[i]->data, &ds);
4131     }
4132     free(backers);
4133
4134     unixctl_command_reply(conn, ds_cstr(&ds));
4135     ds_destroy(&ds);
4136 }
4137
4138 static bool
4139 ofproto_dpif_contains_flow(const struct ofproto_dpif *ofproto,
4140                            const struct nlattr *key, size_t key_len)
4141 {
4142     struct ofproto_dpif *ofp;
4143     struct flow flow;
4144
4145     xlate_receive(ofproto->backer, NULL, key, key_len, &flow, &ofp,
4146                   NULL, NULL, NULL, NULL);
4147     return ofp == ofproto;
4148 }
4149
4150 static void
4151 ofproto_unixctl_dpif_dump_flows(struct unixctl_conn *conn,
4152                                 int argc OVS_UNUSED, const char *argv[],
4153                                 void *aux OVS_UNUSED)
4154 {
4155     struct ds ds = DS_EMPTY_INITIALIZER;
4156     const struct dpif_flow_stats *stats;
4157     const struct ofproto_dpif *ofproto;
4158     struct dpif_flow_dump flow_dump;
4159     const struct nlattr *actions;
4160     const struct nlattr *mask;
4161     const struct nlattr *key;
4162     size_t actions_len;
4163     size_t mask_len;
4164     size_t key_len;
4165     bool verbosity = false;
4166     struct dpif_port dpif_port;
4167     struct dpif_port_dump port_dump;
4168     struct hmap portno_names;
4169     void *state = NULL;
4170     int error;
4171
4172     ofproto = ofproto_dpif_lookup(argv[argc - 1]);
4173     if (!ofproto) {
4174         unixctl_command_reply_error(conn, "no such bridge");
4175         return;
4176     }
4177
4178     if (argc > 2 && !strcmp(argv[1], "-m")) {
4179         verbosity = true;
4180     }
4181
4182     hmap_init(&portno_names);
4183     DPIF_PORT_FOR_EACH (&dpif_port, &port_dump, ofproto->backer->dpif) {
4184         odp_portno_names_set(&portno_names, dpif_port.port_no, dpif_port.name);
4185     }
4186
4187     ds_init(&ds);
4188     error = dpif_flow_dump_start(&flow_dump, ofproto->backer->dpif);
4189     if (error) {
4190         goto exit;
4191     }
4192     dpif_flow_dump_state_init(ofproto->backer->dpif, &state);
4193     while (dpif_flow_dump_next(&flow_dump, state, &key, &key_len,
4194                                &mask, &mask_len, &actions, &actions_len,
4195                                &stats)) {
4196         if (!ofproto_dpif_contains_flow(ofproto, key, key_len)) {
4197             continue;
4198         }
4199
4200         odp_flow_format(key, key_len, mask, mask_len, &portno_names, &ds,
4201                         verbosity);
4202         ds_put_cstr(&ds, ", ");
4203         dpif_flow_stats_format(stats, &ds);
4204         ds_put_cstr(&ds, ", actions:");
4205         format_odp_actions(&ds, actions, actions_len);
4206         ds_put_char(&ds, '\n');
4207     }
4208     dpif_flow_dump_state_uninit(ofproto->backer->dpif, state);
4209     error = dpif_flow_dump_done(&flow_dump);
4210
4211 exit:
4212     if (error) {
4213         ds_clear(&ds);
4214         ds_put_format(&ds, "dpif/dump_flows failed: %s", ovs_strerror(errno));
4215         unixctl_command_reply_error(conn, ds_cstr(&ds));
4216     } else {
4217         unixctl_command_reply(conn, ds_cstr(&ds));
4218     }
4219     odp_portno_names_destroy(&portno_names);
4220     hmap_destroy(&portno_names);
4221     ds_destroy(&ds);
4222 }
4223
4224 static void
4225 ofproto_dpif_unixctl_init(void)
4226 {
4227     static bool registered;
4228     if (registered) {
4229         return;
4230     }
4231     registered = true;
4232
4233     unixctl_command_register(
4234         "ofproto/trace",
4235         "{[dp_name] odp_flow | bridge br_flow} [-generate|packet]",
4236         1, 3, ofproto_unixctl_trace, NULL);
4237     unixctl_command_register(
4238         "ofproto/trace-packet-out",
4239         "[-consistent] {[dp_name] odp_flow | bridge br_flow} [-generate|packet] actions",
4240         2, 6, ofproto_unixctl_trace_actions, NULL);
4241     unixctl_command_register("fdb/flush", "[bridge]", 0, 1,
4242                              ofproto_unixctl_fdb_flush, NULL);
4243     unixctl_command_register("fdb/show", "bridge", 1, 1,
4244                              ofproto_unixctl_fdb_show, NULL);
4245     unixctl_command_register("dpif/dump-dps", "", 0, 0,
4246                              ofproto_unixctl_dpif_dump_dps, NULL);
4247     unixctl_command_register("dpif/show", "", 0, 0, ofproto_unixctl_dpif_show,
4248                              NULL);
4249     unixctl_command_register("dpif/dump-flows", "[-m] bridge", 1, 2,
4250                              ofproto_unixctl_dpif_dump_flows, NULL);
4251 }
4252 \f
4253 /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
4254  *
4255  * This is deprecated.  It is only for compatibility with broken device drivers
4256  * in old versions of Linux that do not properly support VLANs when VLAN
4257  * devices are not used.  When broken device drivers are no longer in
4258  * widespread use, we will delete these interfaces. */
4259
4260 static int
4261 set_realdev(struct ofport *ofport_, ofp_port_t realdev_ofp_port, int vid)
4262 {
4263     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport_->ofproto);
4264     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
4265
4266     if (realdev_ofp_port == ofport->realdev_ofp_port
4267         && vid == ofport->vlandev_vid) {
4268         return 0;
4269     }
4270
4271     ofproto->backer->need_revalidate = REV_RECONFIGURE;
4272
4273     if (ofport->realdev_ofp_port) {
4274         vsp_remove(ofport);
4275     }
4276     if (realdev_ofp_port && ofport->bundle) {
4277         /* vlandevs are enslaved to their realdevs, so they are not allowed to
4278          * themselves be part of a bundle. */
4279         bundle_set(ofport->up.ofproto, ofport->bundle, NULL);
4280     }
4281
4282     ofport->realdev_ofp_port = realdev_ofp_port;
4283     ofport->vlandev_vid = vid;
4284
4285     if (realdev_ofp_port) {
4286         vsp_add(ofport, realdev_ofp_port, vid);
4287     }
4288
4289     return 0;
4290 }
4291
4292 static uint32_t
4293 hash_realdev_vid(ofp_port_t realdev_ofp_port, int vid)
4294 {
4295     return hash_2words(ofp_to_u16(realdev_ofp_port), vid);
4296 }
4297
4298 bool
4299 ofproto_has_vlan_splinters(const struct ofproto_dpif *ofproto)
4300     OVS_EXCLUDED(ofproto->vsp_mutex)
4301 {
4302     /* hmap_is_empty is thread safe. */
4303     return !hmap_is_empty(&ofproto->realdev_vid_map);
4304 }
4305
4306 static ofp_port_t
4307 vsp_realdev_to_vlandev__(const struct ofproto_dpif *ofproto,
4308                          ofp_port_t realdev_ofp_port, ovs_be16 vlan_tci)
4309     OVS_REQUIRES(ofproto->vsp_mutex)
4310 {
4311     if (!hmap_is_empty(&ofproto->realdev_vid_map)) {
4312         int vid = vlan_tci_to_vid(vlan_tci);
4313         const struct vlan_splinter *vsp;
4314
4315         HMAP_FOR_EACH_WITH_HASH (vsp, realdev_vid_node,
4316                                  hash_realdev_vid(realdev_ofp_port, vid),
4317                                  &ofproto->realdev_vid_map) {
4318             if (vsp->realdev_ofp_port == realdev_ofp_port
4319                 && vsp->vid == vid) {
4320                 return vsp->vlandev_ofp_port;
4321             }
4322         }
4323     }
4324     return realdev_ofp_port;
4325 }
4326
4327 /* Returns the OFP port number of the Linux VLAN device that corresponds to
4328  * 'vlan_tci' on the network device with port number 'realdev_ofp_port' in
4329  * 'struct ofport_dpif'.  For example, given 'realdev_ofp_port' of eth0 and
4330  * 'vlan_tci' 9, it would return the port number of eth0.9.
4331  *
4332  * Unless VLAN splinters are enabled for port 'realdev_ofp_port', this
4333  * function just returns its 'realdev_ofp_port' argument. */
4334 ofp_port_t
4335 vsp_realdev_to_vlandev(const struct ofproto_dpif *ofproto,
4336                        ofp_port_t realdev_ofp_port, ovs_be16 vlan_tci)
4337     OVS_EXCLUDED(ofproto->vsp_mutex)
4338 {
4339     ofp_port_t ret;
4340
4341     /* hmap_is_empty is thread safe, see if we can return immediately. */
4342     if (hmap_is_empty(&ofproto->realdev_vid_map)) {
4343         return realdev_ofp_port;
4344     }
4345     ovs_mutex_lock(&ofproto->vsp_mutex);
4346     ret = vsp_realdev_to_vlandev__(ofproto, realdev_ofp_port, vlan_tci);
4347     ovs_mutex_unlock(&ofproto->vsp_mutex);
4348     return ret;
4349 }
4350
4351 static struct vlan_splinter *
4352 vlandev_find(const struct ofproto_dpif *ofproto, ofp_port_t vlandev_ofp_port)
4353 {
4354     struct vlan_splinter *vsp;
4355
4356     HMAP_FOR_EACH_WITH_HASH (vsp, vlandev_node,
4357                              hash_ofp_port(vlandev_ofp_port),
4358                              &ofproto->vlandev_map) {
4359         if (vsp->vlandev_ofp_port == vlandev_ofp_port) {
4360             return vsp;
4361         }
4362     }
4363
4364     return NULL;
4365 }
4366
4367 /* Returns the OpenFlow port number of the "real" device underlying the Linux
4368  * VLAN device with OpenFlow port number 'vlandev_ofp_port' and stores the
4369  * VLAN VID of the Linux VLAN device in '*vid'.  For example, given
4370  * 'vlandev_ofp_port' of eth0.9, it would return the OpenFlow port number of
4371  * eth0 and store 9 in '*vid'.
4372  *
4373  * Returns 0 and does not modify '*vid' if 'vlandev_ofp_port' is not a Linux
4374  * VLAN device.  Unless VLAN splinters are enabled, this is what this function
4375  * always does.*/
4376 static ofp_port_t
4377 vsp_vlandev_to_realdev(const struct ofproto_dpif *ofproto,
4378                        ofp_port_t vlandev_ofp_port, int *vid)
4379     OVS_REQUIRES(ofproto->vsp_mutex)
4380 {
4381     if (!hmap_is_empty(&ofproto->vlandev_map)) {
4382         const struct vlan_splinter *vsp;
4383
4384         vsp = vlandev_find(ofproto, vlandev_ofp_port);
4385         if (vsp) {
4386             if (vid) {
4387                 *vid = vsp->vid;
4388             }
4389             return vsp->realdev_ofp_port;
4390         }
4391     }
4392     return 0;
4393 }
4394
4395 /* Given 'flow', a flow representing a packet received on 'ofproto', checks
4396  * whether 'flow->in_port' represents a Linux VLAN device.  If so, changes
4397  * 'flow->in_port' to the "real" device backing the VLAN device, sets
4398  * 'flow->vlan_tci' to the VLAN VID, and returns true.  Otherwise (which is
4399  * always the case unless VLAN splinters are enabled), returns false without
4400  * making any changes. */
4401 bool
4402 vsp_adjust_flow(const struct ofproto_dpif *ofproto, struct flow *flow)
4403     OVS_EXCLUDED(ofproto->vsp_mutex)
4404 {
4405     ofp_port_t realdev;
4406     int vid;
4407
4408     /* hmap_is_empty is thread safe. */
4409     if (hmap_is_empty(&ofproto->vlandev_map)) {
4410         return false;
4411     }
4412
4413     ovs_mutex_lock(&ofproto->vsp_mutex);
4414     realdev = vsp_vlandev_to_realdev(ofproto, flow->in_port.ofp_port, &vid);
4415     ovs_mutex_unlock(&ofproto->vsp_mutex);
4416     if (!realdev) {
4417         return false;
4418     }
4419
4420     /* Cause the flow to be processed as if it came in on the real device with
4421      * the VLAN device's VLAN ID. */
4422     flow->in_port.ofp_port = realdev;
4423     flow->vlan_tci = htons((vid & VLAN_VID_MASK) | VLAN_CFI);
4424     return true;
4425 }
4426
4427 static void
4428 vsp_remove(struct ofport_dpif *port)
4429 {
4430     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
4431     struct vlan_splinter *vsp;
4432
4433     ovs_mutex_lock(&ofproto->vsp_mutex);
4434     vsp = vlandev_find(ofproto, port->up.ofp_port);
4435     if (vsp) {
4436         hmap_remove(&ofproto->vlandev_map, &vsp->vlandev_node);
4437         hmap_remove(&ofproto->realdev_vid_map, &vsp->realdev_vid_node);
4438         free(vsp);
4439
4440         port->realdev_ofp_port = 0;
4441     } else {
4442         VLOG_ERR("missing vlan device record");
4443     }
4444     ovs_mutex_unlock(&ofproto->vsp_mutex);
4445 }
4446
4447 static void
4448 vsp_add(struct ofport_dpif *port, ofp_port_t realdev_ofp_port, int vid)
4449 {
4450     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
4451
4452     ovs_mutex_lock(&ofproto->vsp_mutex);
4453     if (!vsp_vlandev_to_realdev(ofproto, port->up.ofp_port, NULL)
4454         && (vsp_realdev_to_vlandev__(ofproto, realdev_ofp_port, htons(vid))
4455             == realdev_ofp_port)) {
4456         struct vlan_splinter *vsp;
4457
4458         vsp = xmalloc(sizeof *vsp);
4459         vsp->realdev_ofp_port = realdev_ofp_port;
4460         vsp->vlandev_ofp_port = port->up.ofp_port;
4461         vsp->vid = vid;
4462
4463         port->realdev_ofp_port = realdev_ofp_port;
4464
4465         hmap_insert(&ofproto->vlandev_map, &vsp->vlandev_node,
4466                     hash_ofp_port(port->up.ofp_port));
4467         hmap_insert(&ofproto->realdev_vid_map, &vsp->realdev_vid_node,
4468                     hash_realdev_vid(realdev_ofp_port, vid));
4469     } else {
4470         VLOG_ERR("duplicate vlan device record");
4471     }
4472     ovs_mutex_unlock(&ofproto->vsp_mutex);
4473 }
4474
4475 static odp_port_t
4476 ofp_port_to_odp_port(const struct ofproto_dpif *ofproto, ofp_port_t ofp_port)
4477 {
4478     const struct ofport_dpif *ofport = get_ofp_port(ofproto, ofp_port);
4479     return ofport ? ofport->odp_port : ODPP_NONE;
4480 }
4481
4482 struct ofport_dpif *
4483 odp_port_to_ofport(const struct dpif_backer *backer, odp_port_t odp_port)
4484 {
4485     struct ofport_dpif *port;
4486
4487     ovs_rwlock_rdlock(&backer->odp_to_ofport_lock);
4488     HMAP_FOR_EACH_IN_BUCKET (port, odp_port_node, hash_odp_port(odp_port),
4489                              &backer->odp_to_ofport_map) {
4490         if (port->odp_port == odp_port) {
4491             ovs_rwlock_unlock(&backer->odp_to_ofport_lock);
4492             return port;
4493         }
4494     }
4495
4496     ovs_rwlock_unlock(&backer->odp_to_ofport_lock);
4497     return NULL;
4498 }
4499
4500 static ofp_port_t
4501 odp_port_to_ofp_port(const struct ofproto_dpif *ofproto, odp_port_t odp_port)
4502 {
4503     struct ofport_dpif *port;
4504
4505     port = odp_port_to_ofport(ofproto->backer, odp_port);
4506     if (port && &ofproto->up == port->up.ofproto) {
4507         return port->up.ofp_port;
4508     } else {
4509         return OFPP_NONE;
4510     }
4511 }
4512
4513 const struct ofproto_class ofproto_dpif_class = {
4514     init,
4515     enumerate_types,
4516     enumerate_names,
4517     del,
4518     port_open_type,
4519     type_run,
4520     type_wait,
4521     alloc,
4522     construct,
4523     destruct,
4524     dealloc,
4525     run,
4526     wait,
4527     NULL,                       /* get_memory_usage. */
4528     type_get_memory_usage,
4529     flush,
4530     get_features,
4531     get_tables,
4532     port_alloc,
4533     port_construct,
4534     port_destruct,
4535     port_dealloc,
4536     port_modified,
4537     port_reconfigured,
4538     port_query_by_name,
4539     port_add,
4540     port_del,
4541     port_get_stats,
4542     port_dump_start,
4543     port_dump_next,
4544     port_dump_done,
4545     port_poll,
4546     port_poll_wait,
4547     port_is_lacp_current,
4548     NULL,                       /* rule_choose_table */
4549     rule_alloc,
4550     rule_construct,
4551     rule_insert,
4552     rule_delete,
4553     rule_destruct,
4554     rule_dealloc,
4555     rule_get_stats,
4556     rule_execute,
4557     rule_modify_actions,
4558     set_frag_handling,
4559     packet_out,
4560     set_netflow,
4561     get_netflow_ids,
4562     set_sflow,
4563     set_ipfix,
4564     set_cfm,
4565     get_cfm_status,
4566     set_bfd,
4567     get_bfd_status,
4568     set_stp,
4569     get_stp_status,
4570     set_stp_port,
4571     get_stp_port_status,
4572     get_stp_port_stats,
4573     set_queues,
4574     bundle_set,
4575     bundle_remove,
4576     mirror_set__,
4577     mirror_get_stats__,
4578     set_flood_vlans,
4579     is_mirror_output_bundle,
4580     forward_bpdu_changed,
4581     set_mac_table_config,
4582     set_realdev,
4583     NULL,                       /* meter_get_features */
4584     NULL,                       /* meter_set */
4585     NULL,                       /* meter_get */
4586     NULL,                       /* meter_del */
4587     group_alloc,                /* group_alloc */
4588     group_construct,            /* group_construct */
4589     group_destruct,             /* group_destruct */
4590     group_dealloc,              /* group_dealloc */
4591     group_modify,               /* group_modify */
4592     group_get_stats,            /* group_get_stats */
4593 };