ofproto/ofproto-dpif.c

   1 /*
   2  * Copyright (c) 2009, 2010, 2011, 2012, 2013 Nicira, Inc.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18
  19 #include "ofproto/ofproto-provider.h"
  20
  21 #include <errno.h>
  22
  23 #include "autopath.h"
  24 #include "bond.h"
  25 #include "bundle.h"
  26 #include "byte-order.h"
  27 #include "connmgr.h"
  28 #include "coverage.h"
  29 #include "cfm.h"
  30 #include "dpif.h"
  31 #include "dynamic-string.h"
  32 #include "fail-open.h"
  33 #include "hmapx.h"
  34 #include "lacp.h"
  35 #include "learn.h"
  36 #include "mac-learning.h"
  37 #include "meta-flow.h"
  38 #include "multipath.h"
  39 #include "netdev-vport.h"
  40 #include "netdev.h"
  41 #include "netlink.h"
  42 #include "nx-match.h"
  43 #include "odp-util.h"
  44 #include "ofp-util.h"
  45 #include "ofpbuf.h"
  46 #include "ofp-actions.h"
  47 #include "ofp-parse.h"
  48 #include "ofp-print.h"
  49 #include "ofproto-dpif-governor.h"
  50 #include "ofproto-dpif-sflow.h"
  51 #include "poll-loop.h"
  52 #include "simap.h"
  53 #include "smap.h"
  54 #include "timer.h"
  55 #include "tunnel.h"
  56 #include "unaligned.h"
  57 #include "unixctl.h"
  58 #include "vlan-bitmap.h"
  59 #include "vlog.h"
  60
  61 VLOG_DEFINE_THIS_MODULE(ofproto_dpif);
  62
  63 COVERAGE_DEFINE(ofproto_dpif_expired);
  64 COVERAGE_DEFINE(ofproto_dpif_xlate);
  65 COVERAGE_DEFINE(facet_changed_rule);
  66 COVERAGE_DEFINE(facet_revalidate);
  67 COVERAGE_DEFINE(facet_unexpected);
  68 COVERAGE_DEFINE(facet_suppress);
  69
  70 /* Maximum depth of flow table recursion (due to resubmit actions) in a
  71  * flow translation. */
  72 #define MAX_RESUBMIT_RECURSION 64
  73
  74 /* Number of implemented OpenFlow tables. */
  75 enum { N_TABLES = 255 };
  76 enum { TBL_INTERNAL = N_TABLES - 1 };    /* Used for internal hidden rules. */
  77 BUILD_ASSERT_DECL(N_TABLES >= 2 && N_TABLES <= 255);
  78
  79 struct ofport_dpif;
  80 struct ofproto_dpif;
  81 struct flow_miss;
  82
  83 struct rule_dpif {
  84     struct rule up;
  85
  86     /* These statistics:
  87      *
  88      *   - Do include packets and bytes from facets that have been deleted or
  89      *     whose own statistics have been folded into the rule.
  90      *
  91      *   - Do include packets and bytes sent "by hand" that were accounted to
  92      *     the rule without any facet being involved (this is a rare corner
  93      *     case in rule_execute()).
  94      *
  95      *   - Do not include packet or bytes that can be obtained from any facet's
  96      *     packet_count or byte_count member or that can be obtained from the
  97      *     datapath by, e.g., dpif_flow_get() for any subfacet.
  98      */
  99     uint64_t packet_count;       /* Number of packets received. */
 100     uint64_t byte_count;         /* Number of bytes received. */
 101
 102     tag_type tag;                /* Caches rule_calculate_tag() result. */
 103
 104     struct list facets;          /* List of "struct facet"s. */
 105 };
 106
 107 static struct rule_dpif *rule_dpif_cast(const struct rule *rule)
 108 {
 109     return rule ? CONTAINER_OF(rule, struct rule_dpif, up) : NULL;
 110 }
 111
 112 static struct rule_dpif *rule_dpif_lookup(struct ofproto_dpif *,
 113                                           const struct flow *);
 114 static struct rule_dpif *rule_dpif_lookup__(struct ofproto_dpif *,
 115                                             const struct flow *,
 116                                             uint8_t table);
 117 static struct rule_dpif *rule_dpif_miss_rule(struct ofproto_dpif *ofproto,
 118                                              const struct flow *flow);
 119
 120 static void rule_credit_stats(struct rule_dpif *,
 121                               const struct dpif_flow_stats *);
 122 static void flow_push_stats(struct rule_dpif *, const struct flow *,
 123                             const struct dpif_flow_stats *);
 124 static tag_type rule_calculate_tag(const struct flow *,
 125                                    const struct minimask *, uint32_t basis);
 126 static void rule_invalidate(const struct rule_dpif *);
 127
 128 #define MAX_MIRRORS 32
 129 typedef uint32_t mirror_mask_t;
 130 #define MIRROR_MASK_C(X) UINT32_C(X)
 131 BUILD_ASSERT_DECL(sizeof(mirror_mask_t) * CHAR_BIT >= MAX_MIRRORS);
 132 struct ofmirror {
 133     struct ofproto_dpif *ofproto; /* Owning ofproto. */
 134     size_t idx;                 /* In ofproto's "mirrors" array. */
 135     void *aux;                  /* Key supplied by ofproto's client. */
 136     char *name;                 /* Identifier for log messages. */
 137
 138     /* Selection criteria. */
 139     struct hmapx srcs;          /* Contains "struct ofbundle *"s. */
 140     struct hmapx dsts;          /* Contains "struct ofbundle *"s. */
 141     unsigned long *vlans;       /* Bitmap of chosen VLANs, NULL selects all. */
 142
 143     /* Output (exactly one of out == NULL and out_vlan == -1 is true). */
 144     struct ofbundle *out;       /* Output port or NULL. */
 145     int out_vlan;               /* Output VLAN or -1. */
 146     mirror_mask_t dup_mirrors;  /* Bitmap of mirrors with the same output. */
 147
 148     /* Counters. */
 149     int64_t packet_count;       /* Number of packets sent. */
 150     int64_t byte_count;         /* Number of bytes sent. */
 151 };
 152
 153 static void mirror_destroy(struct ofmirror *);
 154 static void update_mirror_stats(struct ofproto_dpif *ofproto,
 155                                 mirror_mask_t mirrors,
 156                                 uint64_t packets, uint64_t bytes);
 157
 158 struct ofbundle {
 159     struct hmap_node hmap_node; /* In struct ofproto's "bundles" hmap. */
 160     struct ofproto_dpif *ofproto; /* Owning ofproto. */
 161     void *aux;                  /* Key supplied by ofproto's client. */
 162     char *name;                 /* Identifier for log messages. */
 163
 164     /* Configuration. */
 165     struct list ports;          /* Contains "struct ofport"s. */
 166     enum port_vlan_mode vlan_mode; /* VLAN mode */
 167     int vlan;                   /* -1=trunk port, else a 12-bit VLAN ID. */
 168     unsigned long *trunks;      /* Bitmap of trunked VLANs, if 'vlan' == -1.
 169                                  * NULL if all VLANs are trunked. */
 170     struct lacp *lacp;          /* LACP if LACP is enabled, otherwise NULL. */
 171     struct bond *bond;          /* Nonnull iff more than one port. */
 172     bool use_priority_tags;     /* Use 802.1p tag for frames in VLAN 0? */
 173
 174     /* Status. */
 175     bool floodable;          /* True if no port has OFPUTIL_PC_NO_FLOOD set. */
 176
 177     /* Port mirroring info. */
 178     mirror_mask_t src_mirrors;  /* Mirrors triggered when packet received. */
 179     mirror_mask_t dst_mirrors;  /* Mirrors triggered when packet sent. */
 180     mirror_mask_t mirror_out;   /* Mirrors that output to this bundle. */
 181 };
 182
 183 static void bundle_remove(struct ofport *);
 184 static void bundle_update(struct ofbundle *);
 185 static void bundle_destroy(struct ofbundle *);
 186 static void bundle_del_port(struct ofport_dpif *);
 187 static void bundle_run(struct ofbundle *);
 188 static void bundle_wait(struct ofbundle *);
 189 static struct ofbundle *lookup_input_bundle(const struct ofproto_dpif *,
 190                                             uint16_t in_port, bool warn,
 191                                             struct ofport_dpif **in_ofportp);
 192
 193 /* A controller may use OFPP_NONE as the ingress port to indicate that
 194  * it did not arrive on a "real" port.  'ofpp_none_bundle' exists for
 195  * when an input bundle is needed for validation (e.g., mirroring or
 196  * OFPP_NORMAL processing).  It is not connected to an 'ofproto' or have
 197  * any 'port' structs, so care must be taken when dealing with it. */
 198 static struct ofbundle ofpp_none_bundle = {
 199     .name      = "OFPP_NONE",
 200     .vlan_mode = PORT_VLAN_TRUNK
 201 };
 202
 203 static void stp_run(struct ofproto_dpif *ofproto);
 204 static void stp_wait(struct ofproto_dpif *ofproto);
 205 static int set_stp_port(struct ofport *,
 206                         const struct ofproto_port_stp_settings *);
 207
 208 static bool ofbundle_includes_vlan(const struct ofbundle *, uint16_t vlan);
 209
 210 struct action_xlate_ctx {
 211 /* action_xlate_ctx_init() initializes these members. */
 212
 213     /* The ofproto. */
 214     struct ofproto_dpif *ofproto;
 215
 216     /* Flow to which the OpenFlow actions apply.  xlate_actions() will modify
 217      * this flow when actions change header fields. */
 218     struct flow flow;
 219
 220     /* The packet corresponding to 'flow', or a null pointer if we are
 221      * revalidating without a packet to refer to. */
 222     const struct ofpbuf *packet;
 223
 224     /* Should OFPP_NORMAL update the MAC learning table?  Should "learn"
 225      * actions update the flow table?
 226      *
 227      * We want to update these tables if we are actually processing a packet,
 228      * or if we are accounting for packets that the datapath has processed, but
 229      * not if we are just revalidating. */
 230     bool may_learn;
 231
 232     /* The rule that we are currently translating, or NULL. */
 233     struct rule_dpif *rule;
 234
 235     /* Union of the set of TCP flags seen so far in this flow.  (Used only by
 236      * NXAST_FIN_TIMEOUT.  Set to zero to avoid updating updating rules'
 237      * timeouts.) */
 238     uint8_t tcp_flags;
 239
 240     /* If nonnull, flow translation calls this function just before executing a
 241      * resubmit or OFPP_TABLE action.  In addition, disables logging of traces
 242      * when the recursion depth is exceeded.
 243      *
 244      * 'rule' is the rule being submitted into.  It will be null if the
 245      * resubmit or OFPP_TABLE action didn't find a matching rule.
 246      *
 247      * This is normally null so the client has to set it manually after
 248      * calling action_xlate_ctx_init(). */
 249     void (*resubmit_hook)(struct action_xlate_ctx *, struct rule_dpif *rule);
 250
 251     /* If nonnull, flow translation calls this function to report some
 252      * significant decision, e.g. to explain why OFPP_NORMAL translation
 253      * dropped a packet. */
 254     void (*report_hook)(struct action_xlate_ctx *, const char *s);
 255
 256     /* If nonnull, flow translation credits the specified statistics to each
 257      * rule reached through a resubmit or OFPP_TABLE action.
 258      *
 259      * This is normally null so the client has to set it manually after
 260      * calling action_xlate_ctx_init(). */
 261     const struct dpif_flow_stats *resubmit_stats;
 262
 263 /* xlate_actions() initializes and uses these members.  The client might want
 264  * to look at them after it returns. */
 265
 266     struct ofpbuf *odp_actions; /* Datapath actions. */
 267     tag_type tags;              /* Tags associated with actions. */
 268     enum slow_path_reason slow; /* 0 if fast path may be used. */
 269     bool has_learn;             /* Actions include NXAST_LEARN? */
 270     bool has_normal;            /* Actions output to OFPP_NORMAL? */
 271     bool has_fin_timeout;       /* Actions include NXAST_FIN_TIMEOUT? */
 272     uint16_t nf_output_iface;   /* Output interface index for NetFlow. */
 273     mirror_mask_t mirrors;      /* Bitmap of associated mirrors. */
 274
 275 /* xlate_actions() initializes and uses these members, but the client has no
 276  * reason to look at them. */
 277
 278     int recurse;                /* Recursion level, via xlate_table_action. */
 279     bool max_resubmit_trigger;  /* Recursed too deeply during translation. */
 280     struct flow base_flow;      /* Flow at the last commit. */
 281     uint32_t orig_skb_priority; /* Priority when packet arrived. */
 282     uint8_t table_id;           /* OpenFlow table ID where flow was found. */
 283     uint32_t sflow_n_outputs;   /* Number of output ports. */
 284     uint32_t sflow_odp_port;    /* Output port for composing sFlow action. */
 285     uint16_t user_cookie_offset;/* Used for user_action_cookie fixup. */
 286     bool exit;                  /* No further actions should be processed. */
 287     struct flow orig_flow;      /* Copy of original flow. */
 288 };
 289
 290 static void action_xlate_ctx_init(struct action_xlate_ctx *,
 291                                   struct ofproto_dpif *, const struct flow *,
 292                                   ovs_be16 initial_tci, struct rule_dpif *,
 293                                   uint8_t tcp_flags, const struct ofpbuf *);
 294 static void xlate_actions(struct action_xlate_ctx *,
 295                           const struct ofpact *ofpacts, size_t ofpacts_len,
 296                           struct ofpbuf *odp_actions);
 297 static void xlate_actions_for_side_effects(struct action_xlate_ctx *,
 298                                            const struct ofpact *ofpacts,
 299                                            size_t ofpacts_len);
 300 static void xlate_table_action(struct action_xlate_ctx *, uint16_t in_port,
 301                                uint8_t table_id, bool may_packet_in);
 302
 303 static size_t put_userspace_action(const struct ofproto_dpif *,
 304                                    struct ofpbuf *odp_actions,
 305                                    const struct flow *,
 306                                    const union user_action_cookie *);
 307
 308 static void compose_slow_path(const struct ofproto_dpif *, const struct flow *,
 309                               enum slow_path_reason,
 310                               uint64_t *stub, size_t stub_size,
 311                               const struct nlattr **actionsp,
 312                               size_t *actions_lenp);
 313
 314 static void xlate_report(struct action_xlate_ctx *ctx, const char *s);
 315
 316 /* A subfacet (see "struct subfacet" below) has three possible installation
 317  * states:
 318  *
 319  *   - SF_NOT_INSTALLED: Not installed in the datapath.  This will only be the
 320  *     case just after the subfacet is created, just before the subfacet is
 321  *     destroyed, or if the datapath returns an error when we try to install a
 322  *     subfacet.
 323  *
 324  *   - SF_FAST_PATH: The subfacet's actions are installed in the datapath.
 325  *
 326  *   - SF_SLOW_PATH: An action that sends every packet for the subfacet through
 327  *     ofproto_dpif is installed in the datapath.
 328  */
 329 enum subfacet_path {
 330     SF_NOT_INSTALLED,           /* No datapath flow for this subfacet. */
 331     SF_FAST_PATH,               /* Full actions are installed. */
 332     SF_SLOW_PATH,               /* Send-to-userspace action is installed. */
 333 };
 334
 335 static const char *subfacet_path_to_string(enum subfacet_path);
 336
 337 /* A dpif flow and actions associated with a facet.
 338  *
 339  * See also the large comment on struct facet. */
 340 struct subfacet {
 341     /* Owners. */
 342     struct hmap_node hmap_node; /* In struct ofproto_dpif 'subfacets' list. */
 343     struct list list_node;      /* In struct facet's 'facets' list. */
 344     struct facet *facet;        /* Owning facet. */
 345
 346     /* Key.
 347      *
 348      * To save memory in the common case, 'key' is NULL if 'key_fitness' is
 349      * ODP_FIT_PERFECT, that is, odp_flow_key_from_flow() can accurately
 350      * regenerate the ODP flow key from ->facet->flow. */
 351     enum odp_key_fitness key_fitness;
 352     struct nlattr *key;
 353     int key_len;
 354
 355     long long int used;         /* Time last used; time created if not used. */
 356
 357     uint64_t dp_packet_count;   /* Last known packet count in the datapath. */
 358     uint64_t dp_byte_count;     /* Last known byte count in the datapath. */
 359
 360     /* Datapath actions.
 361      *
 362      * These should be essentially identical for every subfacet in a facet, but
 363      * may differ in trivial ways due to VLAN splinters. */
 364     size_t actions_len;         /* Number of bytes in actions[]. */
 365     struct nlattr *actions;     /* Datapath actions. */
 366
 367     enum slow_path_reason slow; /* 0 if fast path may be used. */
 368     enum subfacet_path path;    /* Installed in datapath? */
 369
 370     /* This value is normally the same as ->facet->flow.vlan_tci.  Only VLAN
 371      * splinters can cause it to differ.  This value should be removed when
 372      * the VLAN splinters feature is no longer needed.  */
 373     ovs_be16 initial_tci;       /* Initial VLAN TCI value. */
 374
 375     /* Datapath port the packet arrived on.  This is needed to remove
 376      * flows for ports that are no longer part of the bridge.  Since the
 377      * flow definition only has the OpenFlow port number and the port is
 378      * no longer part of the bridge, we can't determine the datapath port
 379      * number needed to delete the flow from the datapath. */
 380     uint32_t odp_in_port;
 381 };
 382
 383 #define SUBFACET_DESTROY_MAX_BATCH 50
 384
 385 static struct subfacet *subfacet_create(struct facet *, struct flow_miss *miss,
 386                                         long long int now);
 387 static struct subfacet *subfacet_find(struct ofproto_dpif *,
 388                                       const struct nlattr *key, size_t key_len,
 389                                       uint32_t key_hash,
 390                                       const struct flow *flow);
 391 static void subfacet_destroy(struct subfacet *);
 392 static void subfacet_destroy__(struct subfacet *);
 393 static void subfacet_destroy_batch(struct ofproto_dpif *,
 394                                    struct subfacet **, int n);
 395 static void subfacet_get_key(struct subfacet *, struct odputil_keybuf *,
 396                              struct ofpbuf *key);
 397 static void subfacet_reset_dp_stats(struct subfacet *,
 398                                     struct dpif_flow_stats *);
 399 static void subfacet_update_time(struct subfacet *, long long int used);
 400 static void subfacet_update_stats(struct subfacet *,
 401                                   const struct dpif_flow_stats *);
 402 static void subfacet_make_actions(struct subfacet *,
 403                                   const struct ofpbuf *packet,
 404                                   struct ofpbuf *odp_actions);
 405 static int subfacet_install(struct subfacet *,
 406                             const struct nlattr *actions, size_t actions_len,
 407                             struct dpif_flow_stats *, enum slow_path_reason);
 408 static void subfacet_uninstall(struct subfacet *);
 409
 410 static enum subfacet_path subfacet_want_path(enum slow_path_reason);
 411
 412 /* An exact-match instantiation of an OpenFlow flow.
 413  *
 414  * A facet associates a "struct flow", which represents the Open vSwitch
 415  * userspace idea of an exact-match flow, with one or more subfacets.  Each
 416  * subfacet tracks the datapath's idea of the exact-match flow equivalent to
 417  * the facet.  When the kernel module (or other dpif implementation) and Open
 418  * vSwitch userspace agree on the definition of a flow key, there is exactly
 419  * one subfacet per facet.  If the dpif implementation supports more-specific
 420  * flow matching than userspace, however, a facet can have more than one
 421  * subfacet, each of which corresponds to some distinction in flow that
 422  * userspace simply doesn't understand.
 423  *
 424  * Flow expiration works in terms of subfacets, so a facet must have at least
 425  * one subfacet or it will never expire, leaking memory. */
 426 struct facet {
 427     /* Owners. */
 428     struct hmap_node hmap_node;  /* In owning ofproto's 'facets' hmap. */
 429     struct list list_node;       /* In owning rule's 'facets' list. */
 430     struct rule_dpif *rule;      /* Owning rule. */
 431
 432     /* Owned data. */
 433     struct list subfacets;
 434     long long int used;         /* Time last used; time created if not used. */
 435
 436     /* Key. */
 437     struct flow flow;
 438
 439     /* These statistics:
 440      *
 441      *   - Do include packets and bytes sent "by hand", e.g. with
 442      *     dpif_execute().
 443      *
 444      *   - Do include packets and bytes that were obtained from the datapath
 445      *     when a subfacet's statistics were reset (e.g. dpif_flow_put() with
 446      *     DPIF_FP_ZERO_STATS).
 447      *
 448      *   - Do not include packets or bytes that can be obtained from the
 449      *     datapath for any existing subfacet.
 450      */
 451     uint64_t packet_count;       /* Number of packets received. */
 452     uint64_t byte_count;         /* Number of bytes received. */
 453
 454     /* Resubmit statistics. */
 455     uint64_t prev_packet_count;  /* Number of packets from last stats push. */
 456     uint64_t prev_byte_count;    /* Number of bytes from last stats push. */
 457     long long int prev_used;     /* Used time from last stats push. */
 458
 459     /* Accounting. */
 460     uint64_t accounted_bytes;    /* Bytes processed by facet_account(). */
 461     struct netflow_flow nf_flow; /* Per-flow NetFlow tracking data. */
 462     uint8_t tcp_flags;           /* TCP flags seen for this 'rule'. */
 463
 464     /* Properties of datapath actions.
 465      *
 466      * Every subfacet has its own actions because actions can differ slightly
 467      * between splintered and non-splintered subfacets due to the VLAN tag
 468      * being initially different (present vs. absent).  All of them have these
 469      * properties in common so we just store one copy of them here. */
 470     bool has_learn;              /* Actions include NXAST_LEARN? */
 471     bool has_normal;             /* Actions output to OFPP_NORMAL? */
 472     bool has_fin_timeout;        /* Actions include NXAST_FIN_TIMEOUT? */
 473     tag_type tags;               /* Tags that would require revalidation. */
 474     mirror_mask_t mirrors;       /* Bitmap of dependent mirrors. */
 475
 476     /* Storage for a single subfacet, to reduce malloc() time and space
 477      * overhead.  (A facet always has at least one subfacet and in the common
 478      * case has exactly one subfacet.) */
 479     struct subfacet one_subfacet;
 480 };
 481
 482 static struct facet *facet_create(struct rule_dpif *,
 483                                   const struct flow *, uint32_t hash);
 484 static void facet_remove(struct facet *);
 485 static void facet_free(struct facet *);
 486
 487 static struct facet *facet_find(struct ofproto_dpif *,
 488                                 const struct flow *, uint32_t hash);
 489 static struct facet *facet_lookup_valid(struct ofproto_dpif *,
 490                                         const struct flow *, uint32_t hash);
 491 static void facet_revalidate(struct facet *);
 492 static bool facet_check_consistency(struct facet *);
 493
 494 static void facet_flush_stats(struct facet *);
 495
 496 static void facet_update_time(struct facet *, long long int used);
 497 static void facet_reset_counters(struct facet *);
 498 static void facet_push_stats(struct facet *);
 499 static void facet_learn(struct facet *);
 500 static void facet_account(struct facet *);
 501
 502 static bool facet_is_controller_flow(struct facet *);
 503
 504 struct ofport_dpif {
 505     struct hmap_node odp_port_node; /* In dpif_backer's "odp_to_ofport_map". */
 506     struct ofport up;
 507
 508     uint32_t odp_port;
 509     struct ofbundle *bundle;    /* Bundle that contains this port, if any. */
 510     struct list bundle_node;    /* In struct ofbundle's "ports" list. */
 511     struct cfm *cfm;            /* Connectivity Fault Management, if any. */
 512     tag_type tag;               /* Tag associated with this port. */
 513     uint32_t bond_stable_id;    /* stable_id to use as bond slave, or 0. */
 514     bool may_enable;            /* May be enabled in bonds. */
 515     long long int carrier_seq;  /* Carrier status changes. */
 516     struct tnl_port *tnl_port;  /* Tunnel handle, or null. */
 517
 518     /* Spanning tree. */
 519     struct stp_port *stp_port;  /* Spanning Tree Protocol, if any. */
 520     enum stp_state stp_state;   /* Always STP_DISABLED if STP not in use. */
 521     long long int stp_state_entered;
 522
 523     struct hmap priorities;     /* Map of attached 'priority_to_dscp's. */
 524
 525     /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
 526      *
 527      * This is deprecated.  It is only for compatibility with broken device
 528      * drivers in old versions of Linux that do not properly support VLANs when
 529      * VLAN devices are not used.  When broken device drivers are no longer in
 530      * widespread use, we will delete these interfaces. */
 531     uint16_t realdev_ofp_port;
 532     int vlandev_vid;
 533 };
 534
 535 /* Node in 'ofport_dpif''s 'priorities' map.  Used to maintain a map from
 536  * 'priority' (the datapath's term for QoS queue) to the dscp bits which all
 537  * traffic egressing the 'ofport' with that priority should be marked with. */
 538 struct priority_to_dscp {
 539     struct hmap_node hmap_node; /* Node in 'ofport_dpif''s 'priorities' map. */
 540     uint32_t priority;          /* Priority of this queue (see struct flow). */
 541
 542     uint8_t dscp;               /* DSCP bits to mark outgoing traffic with. */
 543 };
 544
 545 /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
 546  *
 547  * This is deprecated.  It is only for compatibility with broken device drivers
 548  * in old versions of Linux that do not properly support VLANs when VLAN
 549  * devices are not used.  When broken device drivers are no longer in
 550  * widespread use, we will delete these interfaces. */
 551 struct vlan_splinter {
 552     struct hmap_node realdev_vid_node;
 553     struct hmap_node vlandev_node;
 554     uint16_t realdev_ofp_port;
 555     uint16_t vlandev_ofp_port;
 556     int vid;
 557 };
 558
 559 static uint32_t vsp_realdev_to_vlandev(const struct ofproto_dpif *,
 560                                        uint32_t realdev, ovs_be16 vlan_tci);
 561 static bool vsp_adjust_flow(const struct ofproto_dpif *, struct flow *);
 562 static void vsp_remove(struct ofport_dpif *);
 563 static void vsp_add(struct ofport_dpif *, uint16_t realdev_ofp_port, int vid);
 564
 565 static uint32_t ofp_port_to_odp_port(const struct ofproto_dpif *,
 566                                      uint16_t ofp_port);
 567 static uint16_t odp_port_to_ofp_port(const struct ofproto_dpif *,
 568                                      uint32_t odp_port);
 569
 570 static struct ofport_dpif *
 571 ofport_dpif_cast(const struct ofport *ofport)
 572 {
 573     ovs_assert(ofport->ofproto->ofproto_class == &ofproto_dpif_class);
 574     return ofport ? CONTAINER_OF(ofport, struct ofport_dpif, up) : NULL;
 575 }
 576
 577 static void port_run(struct ofport_dpif *);
 578 static void port_run_fast(struct ofport_dpif *);
 579 static void port_wait(struct ofport_dpif *);
 580 static int set_cfm(struct ofport *, const struct cfm_settings *);
 581 static void ofport_clear_priorities(struct ofport_dpif *);
 582
 583 struct dpif_completion {
 584     struct list list_node;
 585     struct ofoperation *op;
 586 };
 587
 588 /* Extra information about a classifier table.
 589  * Currently used just for optimized flow revalidation. */
 590 struct table_dpif {
 591     /* If either of these is nonnull, then this table has a form that allows
 592      * flows to be tagged to avoid revalidating most flows for the most common
 593      * kinds of flow table changes. */
 594     struct cls_table *catchall_table; /* Table that wildcards all fields. */
 595     struct cls_table *other_table;    /* Table with any other wildcard set. */
 596     uint32_t basis;                   /* Keeps each table's tags separate. */
 597 };
 598
 599 /* Reasons that we might need to revalidate every facet, and corresponding
 600  * coverage counters.
 601  *
 602  * A value of 0 means that there is no need to revalidate.
 603  *
 604  * It would be nice to have some cleaner way to integrate with coverage
 605  * counters, but with only a few reasons I guess this is good enough for
 606  * now. */
 607 enum revalidate_reason {
 608     REV_RECONFIGURE = 1,       /* Switch configuration changed. */
 609     REV_STP,                   /* Spanning tree protocol port status change. */
 610     REV_PORT_TOGGLED,          /* Port enabled or disabled by CFM, LACP, ...*/
 611     REV_FLOW_TABLE,            /* Flow table changed. */
 612     REV_INCONSISTENCY          /* Facet self-check failed. */
 613 };
 614 COVERAGE_DEFINE(rev_reconfigure);
 615 COVERAGE_DEFINE(rev_stp);
 616 COVERAGE_DEFINE(rev_port_toggled);
 617 COVERAGE_DEFINE(rev_flow_table);
 618 COVERAGE_DEFINE(rev_inconsistency);
 619
 620 /* Drop keys are odp flow keys which have drop flows installed in the kernel.
 621  * These are datapath flows which have no associated ofproto, if they did we
 622  * would use facets. */
 623 struct drop_key {
 624     struct hmap_node hmap_node;
 625     struct nlattr *key;
 626     size_t key_len;
 627 };
 628
 629 /* All datapaths of a given type share a single dpif backer instance. */
 630 struct dpif_backer {
 631     char *type;
 632     int refcount;
 633     struct dpif *dpif;
 634     struct timer next_expiration;
 635     struct hmap odp_to_ofport_map; /* ODP port to ofport mapping. */
 636
 637     struct simap tnl_backers;      /* Set of dpif ports backing tunnels. */
 638
 639     /* Facet revalidation flags applying to facets which use this backer. */
 640     enum revalidate_reason need_revalidate; /* Revalidate every facet. */
 641     struct tag_set revalidate_set; /* Revalidate only matching facets. */
 642
 643     struct hmap drop_keys; /* Set of dropped odp keys. */
 644 };
 645
 646 /* All existing ofproto_backer instances, indexed by ofproto->up.type. */
 647 static struct shash all_dpif_backers = SHASH_INITIALIZER(&all_dpif_backers);
 648
 649 static void drop_key_clear(struct dpif_backer *);
 650 static struct ofport_dpif *
 651 odp_port_to_ofport(const struct dpif_backer *, uint32_t odp_port);
 652
 653 struct ofproto_dpif {
 654     struct hmap_node all_ofproto_dpifs_node; /* In 'all_ofproto_dpifs'. */
 655     struct ofproto up;
 656     struct dpif_backer *backer;
 657
 658     /* Special OpenFlow rules. */
 659     struct rule_dpif *miss_rule; /* Sends flow table misses to controller. */
 660     struct rule_dpif *no_packet_in_rule; /* Drops flow table misses. */
 661
 662     /* Statistics. */
 663     uint64_t n_matches;
 664
 665     /* Bridging. */
 666     struct netflow *netflow;
 667     struct dpif_sflow *sflow;
 668     struct hmap bundles;        /* Contains "struct ofbundle"s. */
 669     struct mac_learning *ml;
 670     struct ofmirror *mirrors[MAX_MIRRORS];
 671     bool has_mirrors;
 672     bool has_bonded_bundles;
 673
 674     /* Facets. */
 675     struct hmap facets;
 676     struct hmap subfacets;
 677     struct governor *governor;
 678
 679     /* Revalidation. */
 680     struct table_dpif tables[N_TABLES];
 681
 682     /* Support for debugging async flow mods. */
 683     struct list completions;
 684
 685     bool has_bundle_action; /* True when the first bundle action appears. */
 686     struct netdev_stats stats; /* To account packets generated and consumed in
 687                                 * userspace. */
 688
 689     /* Spanning tree. */
 690     struct stp *stp;
 691     long long int stp_last_tick;
 692
 693     /* VLAN splinters. */
 694     struct hmap realdev_vid_map; /* (realdev,vid) -> vlandev. */
 695     struct hmap vlandev_map;     /* vlandev -> (realdev,vid). */
 696
 697     /* Ports. */
 698     struct sset ports;             /* Set of standard port names. */
 699     struct sset ghost_ports;       /* Ports with no datapath port. */
 700     struct sset port_poll_set;     /* Queued names for port_poll() reply. */
 701     int port_poll_errno;           /* Last errno for port_poll() reply. */
 702 };
 703
 704 /* Defer flow mod completion until "ovs-appctl ofproto/unclog"?  (Useful only
 705  * for debugging the asynchronous flow_mod implementation.) */
 706 static bool clogged;
 707
 708 /* All existing ofproto_dpif instances, indexed by ->up.name. */
 709 static struct hmap all_ofproto_dpifs = HMAP_INITIALIZER(&all_ofproto_dpifs);
 710
 711 static void ofproto_dpif_unixctl_init(void);
 712
 713 static struct ofproto_dpif *
 714 ofproto_dpif_cast(const struct ofproto *ofproto)
 715 {
 716     ovs_assert(ofproto->ofproto_class == &ofproto_dpif_class);
 717     return CONTAINER_OF(ofproto, struct ofproto_dpif, up);
 718 }
 719
 720 static struct ofport_dpif *get_ofp_port(const struct ofproto_dpif *,
 721                                         uint16_t ofp_port);
 722 static struct ofport_dpif *get_odp_port(const struct ofproto_dpif *,
 723                                         uint32_t odp_port);
 724 static void ofproto_trace(struct ofproto_dpif *, const struct flow *,
 725                           const struct ofpbuf *, ovs_be16 initial_tci,
 726                           struct ds *);
 727
 728 /* Packet processing. */
 729 static void update_learning_table(struct ofproto_dpif *,
 730                                   const struct flow *, int vlan,
 731                                   struct ofbundle *);
 732 /* Upcalls. */
 733 #define FLOW_MISS_MAX_BATCH 50
 734 static int handle_upcalls(struct dpif_backer *, unsigned int max_batch);
 735
 736 /* Flow expiration. */
 737 static int expire(struct dpif_backer *);
 738
 739 /* NetFlow. */
 740 static void send_netflow_active_timeouts(struct ofproto_dpif *);
 741
 742 /* Utilities. */
 743 static int send_packet(const struct ofport_dpif *, struct ofpbuf *packet);
 744 static size_t compose_sflow_action(const struct ofproto_dpif *,
 745                                    struct ofpbuf *odp_actions,
 746                                    const struct flow *, uint32_t odp_port);
 747 static void add_mirror_actions(struct action_xlate_ctx *ctx,
 748                                const struct flow *flow);
 749 /* Global variables. */
 750 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 751
 752 /* Initial mappings of port to bridge mappings. */
 753 static struct shash init_ofp_ports = SHASH_INITIALIZER(&init_ofp_ports);
 754 \f
 755 /* Factory functions. */
 756
 757 static void
 758 init(const struct shash *iface_hints)
 759 {
 760     struct shash_node *node;
 761
 762     /* Make a local copy, since we don't own 'iface_hints' elements. */
 763     SHASH_FOR_EACH(node, iface_hints) {
 764         const struct iface_hint *orig_hint = node->data;
 765         struct iface_hint *new_hint = xmalloc(sizeof *new_hint);
 766
 767         new_hint->br_name = xstrdup(orig_hint->br_name);
 768         new_hint->br_type = xstrdup(orig_hint->br_type);
 769         new_hint->ofp_port = orig_hint->ofp_port;
 770
 771         shash_add(&init_ofp_ports, node->name, new_hint);
 772     }
 773 }
 774
 775 static void
 776 enumerate_types(struct sset *types)
 777 {
 778     dp_enumerate_types(types);
 779 }
 780
 781 static int
 782 enumerate_names(const char *type, struct sset *names)
 783 {
 784     struct ofproto_dpif *ofproto;
 785
 786     sset_clear(names);
 787     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 788         if (strcmp(type, ofproto->up.type)) {
 789             continue;
 790         }
 791         sset_add(names, ofproto->up.name);
 792     }
 793
 794     return 0;
 795 }
 796
 797 static int
 798 del(const char *type, const char *name)
 799 {
 800     struct dpif *dpif;
 801     int error;
 802
 803     error = dpif_open(name, type, &dpif);
 804     if (!error) {
 805         error = dpif_delete(dpif);
 806         dpif_close(dpif);
 807     }
 808     return error;
 809 }
 810 \f
 811 static const char *
 812 port_open_type(const char *datapath_type, const char *port_type)
 813 {
 814     return dpif_port_open_type(datapath_type, port_type);
 815 }
 816
 817 /* Type functions. */
 818
 819 static struct ofproto_dpif *
 820 lookup_ofproto_dpif_by_port_name(const char *name)
 821 {
 822     struct ofproto_dpif *ofproto;
 823
 824     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 825         if (sset_contains(&ofproto->ports, name)) {
 826             return ofproto;
 827         }
 828     }
 829
 830     return NULL;
 831 }
 832
 833 static int
 834 type_run(const char *type)
 835 {
 836     struct dpif_backer *backer;
 837     char *devname;
 838     int error;
 839
 840     backer = shash_find_data(&all_dpif_backers, type);
 841     if (!backer) {
 842         /* This is not necessarily a problem, since backers are only
 843          * created on demand. */
 844         return 0;
 845     }
 846
 847     dpif_run(backer->dpif);
 848
 849     if (backer->need_revalidate
 850         || !tag_set_is_empty(&backer->revalidate_set)) {
 851         struct tag_set revalidate_set = backer->revalidate_set;
 852         bool need_revalidate = backer->need_revalidate;
 853         struct ofproto_dpif *ofproto;
 854         struct simap_node *node;
 855         struct simap tmp_backers;
 856
 857         /* Handle tunnel garbage collection. */
 858         simap_init(&tmp_backers);
 859         simap_swap(&backer->tnl_backers, &tmp_backers);
 860
 861         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 862             struct ofport_dpif *iter;
 863
 864             if (backer != ofproto->backer) {
 865                 continue;
 866             }
 867
 868             HMAP_FOR_EACH (iter, up.hmap_node, &ofproto->up.ports) {
 869                 const char *dp_port;
 870
 871                 if (!iter->tnl_port) {
 872                     continue;
 873                 }
 874
 875                 dp_port = netdev_vport_get_dpif_port(iter->up.netdev);
 876                 node = simap_find(&tmp_backers, dp_port);
 877                 if (node) {
 878                     simap_put(&backer->tnl_backers, dp_port, node->data);
 879                     simap_delete(&tmp_backers, node);
 880                     node = simap_find(&backer->tnl_backers, dp_port);
 881                 } else {
 882                     node = simap_find(&backer->tnl_backers, dp_port);
 883                     if (!node) {
 884                         uint32_t odp_port = UINT32_MAX;
 885
 886                         if (!dpif_port_add(backer->dpif, iter->up.netdev,
 887                                            &odp_port)) {
 888                             simap_put(&backer->tnl_backers, dp_port, odp_port);
 889                             node = simap_find(&backer->tnl_backers, dp_port);
 890                         }
 891                     }
 892                 }
 893
 894                 iter->odp_port = node ? node->data : OVSP_NONE;
 895                 if (tnl_port_reconfigure(&iter->up, iter->odp_port,
 896                                          &iter->tnl_port)) {
 897                     backer->need_revalidate = REV_RECONFIGURE;
 898                 }
 899             }
 900         }
 901
 902         SIMAP_FOR_EACH (node, &tmp_backers) {
 903             dpif_port_del(backer->dpif, node->data);
 904         }
 905         simap_destroy(&tmp_backers);
 906
 907         switch (backer->need_revalidate) {
 908         case REV_RECONFIGURE:   COVERAGE_INC(rev_reconfigure);   break;
 909         case REV_STP:           COVERAGE_INC(rev_stp);           break;
 910         case REV_PORT_TOGGLED:  COVERAGE_INC(rev_port_toggled);  break;
 911         case REV_FLOW_TABLE:    COVERAGE_INC(rev_flow_table);    break;
 912         case REV_INCONSISTENCY: COVERAGE_INC(rev_inconsistency); break;
 913         }
 914
 915         if (backer->need_revalidate) {
 916             /* Clear the drop_keys in case we should now be accepting some
 917              * formerly dropped flows. */
 918             drop_key_clear(backer);
 919         }
 920
 921         /* Clear the revalidation flags. */
 922         tag_set_init(&backer->revalidate_set);
 923         backer->need_revalidate = 0;
 924
 925         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
 926             struct facet *facet;
 927
 928             if (ofproto->backer != backer) {
 929                 continue;
 930             }
 931
 932             HMAP_FOR_EACH (facet, hmap_node, &ofproto->facets) {
 933                 if (need_revalidate
 934                     || tag_set_intersects(&revalidate_set, facet->tags)) {
 935                     facet_revalidate(facet);
 936                 }
 937             }
 938         }
 939     }
 940
 941     if (timer_expired(&backer->next_expiration)) {
 942         int delay = expire(backer);
 943         timer_set_duration(&backer->next_expiration, delay);
 944     }
 945
 946     /* Check for port changes in the dpif. */
 947     while ((error = dpif_port_poll(backer->dpif, &devname)) == 0) {
 948         struct ofproto_dpif *ofproto;
 949         struct dpif_port port;
 950
 951         /* Don't report on the datapath's device. */
 952         if (!strcmp(devname, dpif_base_name(backer->dpif))) {
 953             goto next;
 954         }
 955
 956         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node,
 957                        &all_ofproto_dpifs) {
 958             if (simap_contains(&ofproto->backer->tnl_backers, devname)) {
 959                 goto next;
 960             }
 961         }
 962
 963         ofproto = lookup_ofproto_dpif_by_port_name(devname);
 964         if (dpif_port_query_by_name(backer->dpif, devname, &port)) {
 965             /* The port was removed.  If we know the datapath,
 966              * report it through poll_set().  If we don't, it may be
 967              * notifying us of a removal we initiated, so ignore it.
 968              * If there's a pending ENOBUFS, let it stand, since
 969              * everything will be reevaluated. */
 970             if (ofproto && ofproto->port_poll_errno != ENOBUFS) {
 971                 sset_add(&ofproto->port_poll_set, devname);
 972                 ofproto->port_poll_errno = 0;
 973             }
 974         } else if (!ofproto) {
 975             /* The port was added, but we don't know with which
 976              * ofproto we should associate it.  Delete it. */
 977             dpif_port_del(backer->dpif, port.port_no);
 978         }
 979         dpif_port_destroy(&port);
 980
 981     next:
 982         free(devname);
 983     }
 984
 985     if (error != EAGAIN) {
 986         struct ofproto_dpif *ofproto;
 987
 988         /* There was some sort of error, so propagate it to all
 989          * ofprotos that use this backer. */
 990         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node,
 991                        &all_ofproto_dpifs) {
 992             if (ofproto->backer == backer) {
 993                 sset_clear(&ofproto->port_poll_set);
 994                 ofproto->port_poll_errno = error;
 995             }
 996         }
 997     }
 998
 999     return 0;
1000 }
1001
1002 static int
1003 type_run_fast(const char *type)
1004 {
1005     struct dpif_backer *backer;
1006     unsigned int work;
1007
1008     backer = shash_find_data(&all_dpif_backers, type);
1009     if (!backer) {
1010         /* This is not necessarily a problem, since backers are only
1011          * created on demand. */
1012         return 0;
1013     }
1014
1015     /* Handle one or more batches of upcalls, until there's nothing left to do
1016      * or until we do a fixed total amount of work.
1017      *
1018      * We do work in batches because it can be much cheaper to set up a number
1019      * of flows and fire off their patches all at once.  We do multiple batches
1020      * because in some cases handling a packet can cause another packet to be
1021      * queued almost immediately as part of the return flow.  Both
1022      * optimizations can make major improvements on some benchmarks and
1023      * presumably for real traffic as well. */
1024     work = 0;
1025     while (work < FLOW_MISS_MAX_BATCH) {
1026         int retval = handle_upcalls(backer, FLOW_MISS_MAX_BATCH - work);
1027         if (retval <= 0) {
1028             return -retval;
1029         }
1030         work += retval;
1031     }
1032
1033     return 0;
1034 }
1035
1036 static void
1037 type_wait(const char *type)
1038 {
1039     struct dpif_backer *backer;
1040
1041     backer = shash_find_data(&all_dpif_backers, type);
1042     if (!backer) {
1043         /* This is not necessarily a problem, since backers are only
1044          * created on demand. */
1045         return;
1046     }
1047
1048     timer_wait(&backer->next_expiration);
1049 }
1050 \f
1051 /* Basic life-cycle. */
1052
1053 static int add_internal_flows(struct ofproto_dpif *);
1054
1055 static struct ofproto *
1056 alloc(void)
1057 {
1058     struct ofproto_dpif *ofproto = xmalloc(sizeof *ofproto);
1059     return &ofproto->up;
1060 }
1061
1062 static void
1063 dealloc(struct ofproto *ofproto_)
1064 {
1065     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1066     free(ofproto);
1067 }
1068
1069 static void
1070 close_dpif_backer(struct dpif_backer *backer)
1071 {
1072     struct shash_node *node;
1073
1074     ovs_assert(backer->refcount > 0);
1075
1076     if (--backer->refcount) {
1077         return;
1078     }
1079
1080     drop_key_clear(backer);
1081     hmap_destroy(&backer->drop_keys);
1082
1083     simap_destroy(&backer->tnl_backers);
1084     hmap_destroy(&backer->odp_to_ofport_map);
1085     node = shash_find(&all_dpif_backers, backer->type);
1086     free(backer->type);
1087     shash_delete(&all_dpif_backers, node);
1088     dpif_close(backer->dpif);
1089
1090     free(backer);
1091 }
1092
1093 /* Datapath port slated for removal from datapath. */
1094 struct odp_garbage {
1095     struct list list_node;
1096     uint32_t odp_port;
1097 };
1098
1099 static int
1100 open_dpif_backer(const char *type, struct dpif_backer **backerp)
1101 {
1102     struct dpif_backer *backer;
1103     struct dpif_port_dump port_dump;
1104     struct dpif_port port;
1105     struct shash_node *node;
1106     struct list garbage_list;
1107     struct odp_garbage *garbage, *next;
1108     struct sset names;
1109     char *backer_name;
1110     const char *name;
1111     int error;
1112
1113     backer = shash_find_data(&all_dpif_backers, type);
1114     if (backer) {
1115         backer->refcount++;
1116         *backerp = backer;
1117         return 0;
1118     }
1119
1120     backer_name = xasprintf("ovs-%s", type);
1121
1122     /* Remove any existing datapaths, since we assume we're the only
1123      * userspace controlling the datapath. */
1124     sset_init(&names);
1125     dp_enumerate_names(type, &names);
1126     SSET_FOR_EACH(name, &names) {
1127         struct dpif *old_dpif;
1128
1129         /* Don't remove our backer if it exists. */
1130         if (!strcmp(name, backer_name)) {
1131             continue;
1132         }
1133
1134         if (dpif_open(name, type, &old_dpif)) {
1135             VLOG_WARN("couldn't open old datapath %s to remove it", name);
1136         } else {
1137             dpif_delete(old_dpif);
1138             dpif_close(old_dpif);
1139         }
1140     }
1141     sset_destroy(&names);
1142
1143     backer = xmalloc(sizeof *backer);
1144
1145     error = dpif_create_and_open(backer_name, type, &backer->dpif);
1146     free(backer_name);
1147     if (error) {
1148         VLOG_ERR("failed to open datapath of type %s: %s", type,
1149                  strerror(error));
1150         free(backer);
1151         return error;
1152     }
1153
1154     backer->type = xstrdup(type);
1155     backer->refcount = 1;
1156     hmap_init(&backer->odp_to_ofport_map);
1157     hmap_init(&backer->drop_keys);
1158     timer_set_duration(&backer->next_expiration, 1000);
1159     backer->need_revalidate = 0;
1160     simap_init(&backer->tnl_backers);
1161     tag_set_init(&backer->revalidate_set);
1162     *backerp = backer;
1163
1164     dpif_flow_flush(backer->dpif);
1165
1166     /* Loop through the ports already on the datapath and remove any
1167      * that we don't need anymore. */
1168     list_init(&garbage_list);
1169     dpif_port_dump_start(&port_dump, backer->dpif);
1170     while (dpif_port_dump_next(&port_dump, &port)) {
1171         node = shash_find(&init_ofp_ports, port.name);
1172         if (!node && strcmp(port.name, dpif_base_name(backer->dpif))) {
1173             garbage = xmalloc(sizeof *garbage);
1174             garbage->odp_port = port.port_no;
1175             list_push_front(&garbage_list, &garbage->list_node);
1176         }
1177     }
1178     dpif_port_dump_done(&port_dump);
1179
1180     LIST_FOR_EACH_SAFE (garbage, next, list_node, &garbage_list) {
1181         dpif_port_del(backer->dpif, garbage->odp_port);
1182         list_remove(&garbage->list_node);
1183         free(garbage);
1184     }
1185
1186     shash_add(&all_dpif_backers, type, backer);
1187
1188     error = dpif_recv_set(backer->dpif, true);
1189     if (error) {
1190         VLOG_ERR("failed to listen on datapath of type %s: %s",
1191                  type, strerror(error));
1192         close_dpif_backer(backer);
1193         return error;
1194     }
1195
1196     return error;
1197 }
1198
1199 static int
1200 construct(struct ofproto *ofproto_)
1201 {
1202     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1203     struct shash_node *node, *next;
1204     int max_ports;
1205     int error;
1206     int i;
1207
1208     error = open_dpif_backer(ofproto->up.type, &ofproto->backer);
1209     if (error) {
1210         return error;
1211     }
1212
1213     max_ports = dpif_get_max_ports(ofproto->backer->dpif);
1214     ofproto_init_max_ports(ofproto_, MIN(max_ports, OFPP_MAX));
1215
1216     ofproto->n_matches = 0;
1217
1218     ofproto->netflow = NULL;
1219     ofproto->sflow = NULL;
1220     ofproto->stp = NULL;
1221     hmap_init(&ofproto->bundles);
1222     ofproto->ml = mac_learning_create(MAC_ENTRY_DEFAULT_IDLE_TIME);
1223     for (i = 0; i < MAX_MIRRORS; i++) {
1224         ofproto->mirrors[i] = NULL;
1225     }
1226     ofproto->has_bonded_bundles = false;
1227
1228     hmap_init(&ofproto->facets);
1229     hmap_init(&ofproto->subfacets);
1230     ofproto->governor = NULL;
1231
1232     for (i = 0; i < N_TABLES; i++) {
1233         struct table_dpif *table = &ofproto->tables[i];
1234
1235         table->catchall_table = NULL;
1236         table->other_table = NULL;
1237         table->basis = random_uint32();
1238     }
1239
1240     list_init(&ofproto->completions);
1241
1242     ofproto_dpif_unixctl_init();
1243
1244     ofproto->has_mirrors = false;
1245     ofproto->has_bundle_action = false;
1246
1247     hmap_init(&ofproto->vlandev_map);
1248     hmap_init(&ofproto->realdev_vid_map);
1249
1250     sset_init(&ofproto->ports);
1251     sset_init(&ofproto->ghost_ports);
1252     sset_init(&ofproto->port_poll_set);
1253     ofproto->port_poll_errno = 0;
1254
1255     SHASH_FOR_EACH_SAFE (node, next, &init_ofp_ports) {
1256         struct iface_hint *iface_hint = node->data;
1257
1258         if (!strcmp(iface_hint->br_name, ofproto->up.name)) {
1259             /* Check if the datapath already has this port. */
1260             if (dpif_port_exists(ofproto->backer->dpif, node->name)) {
1261                 sset_add(&ofproto->ports, node->name);
1262             }
1263
1264             free(iface_hint->br_name);
1265             free(iface_hint->br_type);
1266             free(iface_hint);
1267             shash_delete(&init_ofp_ports, node);
1268         }
1269     }
1270
1271     hmap_insert(&all_ofproto_dpifs, &ofproto->all_ofproto_dpifs_node,
1272                 hash_string(ofproto->up.name, 0));
1273     memset(&ofproto->stats, 0, sizeof ofproto->stats);
1274
1275     ofproto_init_tables(ofproto_, N_TABLES);
1276     error = add_internal_flows(ofproto);
1277     ofproto->up.tables[TBL_INTERNAL].flags = OFTABLE_HIDDEN | OFTABLE_READONLY;
1278
1279     return error;
1280 }
1281
1282 static int
1283 add_internal_flow(struct ofproto_dpif *ofproto, int id,
1284                   const struct ofpbuf *ofpacts, struct rule_dpif **rulep)
1285 {
1286     struct ofputil_flow_mod fm;
1287     int error;
1288
1289     match_init_catchall(&fm.match);
1290     fm.priority = 0;
1291     match_set_reg(&fm.match, 0, id);
1292     fm.new_cookie = htonll(0);
1293     fm.cookie = htonll(0);
1294     fm.cookie_mask = htonll(0);
1295     fm.table_id = TBL_INTERNAL;
1296     fm.command = OFPFC_ADD;
1297     fm.idle_timeout = 0;
1298     fm.hard_timeout = 0;
1299     fm.buffer_id = 0;
1300     fm.out_port = 0;
1301     fm.flags = 0;
1302     fm.ofpacts = ofpacts->data;
1303     fm.ofpacts_len = ofpacts->size;
1304
1305     error = ofproto_flow_mod(&ofproto->up, &fm);
1306     if (error) {
1307         VLOG_ERR_RL(&rl, "failed to add internal flow %d (%s)",
1308                     id, ofperr_to_string(error));
1309         return error;
1310     }
1311
1312     *rulep = rule_dpif_lookup__(ofproto, &fm.match.flow, TBL_INTERNAL);
1313     ovs_assert(*rulep != NULL);
1314
1315     return 0;
1316 }
1317
1318 static int
1319 add_internal_flows(struct ofproto_dpif *ofproto)
1320 {
1321     struct ofpact_controller *controller;
1322     uint64_t ofpacts_stub[128 / 8];
1323     struct ofpbuf ofpacts;
1324     int error;
1325     int id;
1326
1327     ofpbuf_use_stack(&ofpacts, ofpacts_stub, sizeof ofpacts_stub);
1328     id = 1;
1329
1330     controller = ofpact_put_CONTROLLER(&ofpacts);
1331     controller->max_len = UINT16_MAX;
1332     controller->controller_id = 0;
1333     controller->reason = OFPR_NO_MATCH;
1334     ofpact_pad(&ofpacts);
1335
1336     error = add_internal_flow(ofproto, id++, &ofpacts, &ofproto->miss_rule);
1337     if (error) {
1338         return error;
1339     }
1340
1341     ofpbuf_clear(&ofpacts);
1342     error = add_internal_flow(ofproto, id++, &ofpacts,
1343                               &ofproto->no_packet_in_rule);
1344     return error;
1345 }
1346
1347 static void
1348 complete_operations(struct ofproto_dpif *ofproto)
1349 {
1350     struct dpif_completion *c, *next;
1351
1352     LIST_FOR_EACH_SAFE (c, next, list_node, &ofproto->completions) {
1353         ofoperation_complete(c->op, 0);
1354         list_remove(&c->list_node);
1355         free(c);
1356     }
1357 }
1358
1359 static void
1360 destruct(struct ofproto *ofproto_)
1361 {
1362     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1363     struct rule_dpif *rule, *next_rule;
1364     struct oftable *table;
1365     int i;
1366
1367     hmap_remove(&all_ofproto_dpifs, &ofproto->all_ofproto_dpifs_node);
1368     complete_operations(ofproto);
1369
1370     OFPROTO_FOR_EACH_TABLE (table, &ofproto->up) {
1371         struct cls_cursor cursor;
1372
1373         cls_cursor_init(&cursor, &table->cls, NULL);
1374         CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, up.cr, &cursor) {
1375             ofproto_rule_destroy(&rule->up);
1376         }
1377     }
1378
1379     for (i = 0; i < MAX_MIRRORS; i++) {
1380         mirror_destroy(ofproto->mirrors[i]);
1381     }
1382
1383     netflow_destroy(ofproto->netflow);
1384     dpif_sflow_destroy(ofproto->sflow);
1385     hmap_destroy(&ofproto->bundles);
1386     mac_learning_destroy(ofproto->ml);
1387
1388     hmap_destroy(&ofproto->facets);
1389     hmap_destroy(&ofproto->subfacets);
1390     governor_destroy(ofproto->governor);
1391
1392     hmap_destroy(&ofproto->vlandev_map);
1393     hmap_destroy(&ofproto->realdev_vid_map);
1394
1395     sset_destroy(&ofproto->ports);
1396     sset_destroy(&ofproto->ghost_ports);
1397     sset_destroy(&ofproto->port_poll_set);
1398
1399     close_dpif_backer(ofproto->backer);
1400 }
1401
1402 static int
1403 run_fast(struct ofproto *ofproto_)
1404 {
1405     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1406     struct ofport_dpif *ofport;
1407
1408     HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
1409         port_run_fast(ofport);
1410     }
1411
1412     return 0;
1413 }
1414
1415 static int
1416 run(struct ofproto *ofproto_)
1417 {
1418     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1419     struct ofport_dpif *ofport;
1420     struct ofbundle *bundle;
1421     int error;
1422
1423     if (!clogged) {
1424         complete_operations(ofproto);
1425     }
1426
1427     error = run_fast(ofproto_);
1428     if (error) {
1429         return error;
1430     }
1431
1432     if (ofproto->netflow) {
1433         if (netflow_run(ofproto->netflow)) {
1434             send_netflow_active_timeouts(ofproto);
1435         }
1436     }
1437     if (ofproto->sflow) {
1438         dpif_sflow_run(ofproto->sflow);
1439     }
1440
1441     HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
1442         port_run(ofport);
1443     }
1444     HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
1445         bundle_run(bundle);
1446     }
1447
1448     stp_run(ofproto);
1449     mac_learning_run(ofproto->ml, &ofproto->backer->revalidate_set);
1450
1451     /* Check the consistency of a random facet, to aid debugging. */
1452     if (!hmap_is_empty(&ofproto->facets)
1453         && !ofproto->backer->need_revalidate) {
1454         struct facet *facet;
1455
1456         facet = CONTAINER_OF(hmap_random_node(&ofproto->facets),
1457                              struct facet, hmap_node);
1458         if (!tag_set_intersects(&ofproto->backer->revalidate_set,
1459                                 facet->tags)) {
1460             if (!facet_check_consistency(facet)) {
1461                 ofproto->backer->need_revalidate = REV_INCONSISTENCY;
1462             }
1463         }
1464     }
1465
1466     if (ofproto->governor) {
1467         size_t n_subfacets;
1468
1469         governor_run(ofproto->governor);
1470
1471         /* If the governor has shrunk to its minimum size and the number of
1472          * subfacets has dwindled, then drop the governor entirely.
1473          *
1474          * For hysteresis, the number of subfacets to drop the governor is
1475          * smaller than the number needed to trigger its creation. */
1476         n_subfacets = hmap_count(&ofproto->subfacets);
1477         if (n_subfacets * 4 < ofproto->up.flow_eviction_threshold
1478             && governor_is_idle(ofproto->governor)) {
1479             governor_destroy(ofproto->governor);
1480             ofproto->governor = NULL;
1481         }
1482     }
1483
1484     return 0;
1485 }
1486
1487 static void
1488 wait(struct ofproto *ofproto_)
1489 {
1490     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1491     struct ofport_dpif *ofport;
1492     struct ofbundle *bundle;
1493
1494     if (!clogged && !list_is_empty(&ofproto->completions)) {
1495         poll_immediate_wake();
1496     }
1497
1498     dpif_wait(ofproto->backer->dpif);
1499     dpif_recv_wait(ofproto->backer->dpif);
1500     if (ofproto->sflow) {
1501         dpif_sflow_wait(ofproto->sflow);
1502     }
1503     if (!tag_set_is_empty(&ofproto->backer->revalidate_set)) {
1504         poll_immediate_wake();
1505     }
1506     HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
1507         port_wait(ofport);
1508     }
1509     HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
1510         bundle_wait(bundle);
1511     }
1512     if (ofproto->netflow) {
1513         netflow_wait(ofproto->netflow);
1514     }
1515     mac_learning_wait(ofproto->ml);
1516     stp_wait(ofproto);
1517     if (ofproto->backer->need_revalidate) {
1518         /* Shouldn't happen, but if it does just go around again. */
1519         VLOG_DBG_RL(&rl, "need revalidate in ofproto_wait_cb()");
1520         poll_immediate_wake();
1521     }
1522     if (ofproto->governor) {
1523         governor_wait(ofproto->governor);
1524     }
1525 }
1526
1527 static void
1528 get_memory_usage(const struct ofproto *ofproto_, struct simap *usage)
1529 {
1530     const struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1531
1532     simap_increase(usage, "facets", hmap_count(&ofproto->facets));
1533     simap_increase(usage, "subfacets", hmap_count(&ofproto->subfacets));
1534 }
1535
1536 static void
1537 flush(struct ofproto *ofproto_)
1538 {
1539     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1540     struct subfacet *subfacet, *next_subfacet;
1541     struct subfacet *batch[SUBFACET_DESTROY_MAX_BATCH];
1542     int n_batch;
1543
1544     n_batch = 0;
1545     HMAP_FOR_EACH_SAFE (subfacet, next_subfacet, hmap_node,
1546                         &ofproto->subfacets) {
1547         if (subfacet->path != SF_NOT_INSTALLED) {
1548             batch[n_batch++] = subfacet;
1549             if (n_batch >= SUBFACET_DESTROY_MAX_BATCH) {
1550                 subfacet_destroy_batch(ofproto, batch, n_batch);
1551                 n_batch = 0;
1552             }
1553         } else {
1554             subfacet_destroy(subfacet);
1555         }
1556     }
1557
1558     if (n_batch > 0) {
1559         subfacet_destroy_batch(ofproto, batch, n_batch);
1560     }
1561 }
1562
1563 static void
1564 get_features(struct ofproto *ofproto_ OVS_UNUSED,
1565              bool *arp_match_ip, enum ofputil_action_bitmap *actions)
1566 {
1567     *arp_match_ip = true;
1568     *actions = (OFPUTIL_A_OUTPUT |
1569                 OFPUTIL_A_SET_VLAN_VID |
1570                 OFPUTIL_A_SET_VLAN_PCP |
1571                 OFPUTIL_A_STRIP_VLAN |
1572                 OFPUTIL_A_SET_DL_SRC |
1573                 OFPUTIL_A_SET_DL_DST |
1574                 OFPUTIL_A_SET_NW_SRC |
1575                 OFPUTIL_A_SET_NW_DST |
1576                 OFPUTIL_A_SET_NW_TOS |
1577                 OFPUTIL_A_SET_TP_SRC |
1578                 OFPUTIL_A_SET_TP_DST |
1579                 OFPUTIL_A_ENQUEUE);
1580 }
1581
1582 static void
1583 get_tables(struct ofproto *ofproto_, struct ofp12_table_stats *ots)
1584 {
1585     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1586     struct dpif_dp_stats s;
1587
1588     strcpy(ots->name, "classifier");
1589
1590     dpif_get_dp_stats(ofproto->backer->dpif, &s);
1591
1592     ots->lookup_count = htonll(s.n_hit + s.n_missed);
1593     ots->matched_count = htonll(s.n_hit + ofproto->n_matches);
1594 }
1595
1596 static struct ofport *
1597 port_alloc(void)
1598 {
1599     struct ofport_dpif *port = xmalloc(sizeof *port);
1600     return &port->up;
1601 }
1602
1603 static void
1604 port_dealloc(struct ofport *port_)
1605 {
1606     struct ofport_dpif *port = ofport_dpif_cast(port_);
1607     free(port);
1608 }
1609
1610 static int
1611 port_construct(struct ofport *port_)
1612 {
1613     struct ofport_dpif *port = ofport_dpif_cast(port_);
1614     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
1615     const struct netdev *netdev = port->up.netdev;
1616     struct dpif_port dpif_port;
1617     int error;
1618
1619     ofproto->backer->need_revalidate = REV_RECONFIGURE;
1620     port->bundle = NULL;
1621     port->cfm = NULL;
1622     port->tag = tag_create_random();
1623     port->may_enable = true;
1624     port->stp_port = NULL;
1625     port->stp_state = STP_DISABLED;
1626     port->tnl_port = NULL;
1627     hmap_init(&port->priorities);
1628     port->realdev_ofp_port = 0;
1629     port->vlandev_vid = 0;
1630     port->carrier_seq = netdev_get_carrier_resets(netdev);
1631
1632     if (netdev_vport_is_patch(netdev)) {
1633         /* XXX By bailing out here, we don't do required sFlow work. */
1634         port->odp_port = OVSP_NONE;
1635         return 0;
1636     }
1637
1638     error = dpif_port_query_by_name(ofproto->backer->dpif,
1639                                     netdev_vport_get_dpif_port(netdev),
1640                                     &dpif_port);
1641     if (error) {
1642         return error;
1643     }
1644
1645     port->odp_port = dpif_port.port_no;
1646
1647     if (netdev_get_tunnel_config(netdev)) {
1648         port->tnl_port = tnl_port_add(&port->up, port->odp_port);
1649     } else {
1650         /* Sanity-check that a mapping doesn't already exist.  This
1651          * shouldn't happen for non-tunnel ports. */
1652         if (odp_port_to_ofp_port(ofproto, port->odp_port) != OFPP_NONE) {
1653             VLOG_ERR("port %s already has an OpenFlow port number",
1654                      dpif_port.name);
1655             dpif_port_destroy(&dpif_port);
1656             return EBUSY;
1657         }
1658
1659         hmap_insert(&ofproto->backer->odp_to_ofport_map, &port->odp_port_node,
1660                     hash_int(port->odp_port, 0));
1661     }
1662     dpif_port_destroy(&dpif_port);
1663
1664     if (ofproto->sflow) {
1665         dpif_sflow_add_port(ofproto->sflow, port_, port->odp_port);
1666     }
1667
1668     return 0;
1669 }
1670
1671 static void
1672 port_destruct(struct ofport *port_)
1673 {
1674     struct ofport_dpif *port = ofport_dpif_cast(port_);
1675     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
1676     const char *dp_port_name = netdev_vport_get_dpif_port(port->up.netdev);
1677     const char *devname = netdev_get_name(port->up.netdev);
1678
1679     if (dpif_port_exists(ofproto->backer->dpif, dp_port_name)) {
1680         /* The underlying device is still there, so delete it.  This
1681          * happens when the ofproto is being destroyed, since the caller
1682          * assumes that removal of attached ports will happen as part of
1683          * destruction. */
1684         if (!port->tnl_port) {
1685             dpif_port_del(ofproto->backer->dpif, port->odp_port);
1686         }
1687         ofproto->backer->need_revalidate = REV_RECONFIGURE;
1688     }
1689
1690     if (port->odp_port != OVSP_NONE && !port->tnl_port) {
1691         hmap_remove(&ofproto->backer->odp_to_ofport_map, &port->odp_port_node);
1692     }
1693
1694     tnl_port_del(port->tnl_port);
1695     sset_find_and_delete(&ofproto->ports, devname);
1696     sset_find_and_delete(&ofproto->ghost_ports, devname);
1697     ofproto->backer->need_revalidate = REV_RECONFIGURE;
1698     bundle_remove(port_);
1699     set_cfm(port_, NULL);
1700     if (ofproto->sflow) {
1701         dpif_sflow_del_port(ofproto->sflow, port->odp_port);
1702     }
1703
1704     ofport_clear_priorities(port);
1705     hmap_destroy(&port->priorities);
1706 }
1707
1708 static void
1709 port_modified(struct ofport *port_)
1710 {
1711     struct ofport_dpif *port = ofport_dpif_cast(port_);
1712
1713     if (port->bundle && port->bundle->bond) {
1714         bond_slave_set_netdev(port->bundle->bond, port, port->up.netdev);
1715     }
1716 }
1717
1718 static void
1719 port_reconfigured(struct ofport *port_, enum ofputil_port_config old_config)
1720 {
1721     struct ofport_dpif *port = ofport_dpif_cast(port_);
1722     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
1723     enum ofputil_port_config changed = old_config ^ port->up.pp.config;
1724
1725     if (changed & (OFPUTIL_PC_NO_RECV | OFPUTIL_PC_NO_RECV_STP |
1726                    OFPUTIL_PC_NO_FWD | OFPUTIL_PC_NO_FLOOD |
1727                    OFPUTIL_PC_NO_PACKET_IN)) {
1728         ofproto->backer->need_revalidate = REV_RECONFIGURE;
1729
1730         if (changed & OFPUTIL_PC_NO_FLOOD && port->bundle) {
1731             bundle_update(port->bundle);
1732         }
1733     }
1734 }
1735
1736 static int
1737 set_sflow(struct ofproto *ofproto_,
1738           const struct ofproto_sflow_options *sflow_options)
1739 {
1740     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1741     struct dpif_sflow *ds = ofproto->sflow;
1742
1743     if (sflow_options) {
1744         if (!ds) {
1745             struct ofport_dpif *ofport;
1746
1747             ds = ofproto->sflow = dpif_sflow_create();
1748             HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
1749                 dpif_sflow_add_port(ds, &ofport->up, ofport->odp_port);
1750             }
1751             ofproto->backer->need_revalidate = REV_RECONFIGURE;
1752         }
1753         dpif_sflow_set_options(ds, sflow_options);
1754     } else {
1755         if (ds) {
1756             dpif_sflow_destroy(ds);
1757             ofproto->backer->need_revalidate = REV_RECONFIGURE;
1758             ofproto->sflow = NULL;
1759         }
1760     }
1761     return 0;
1762 }
1763
1764 static int
1765 set_cfm(struct ofport *ofport_, const struct cfm_settings *s)
1766 {
1767     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1768     int error;
1769
1770     if (!s) {
1771         error = 0;
1772     } else {
1773         if (!ofport->cfm) {
1774             struct ofproto_dpif *ofproto;
1775
1776             ofproto = ofproto_dpif_cast(ofport->up.ofproto);
1777             ofproto->backer->need_revalidate = REV_RECONFIGURE;
1778             ofport->cfm = cfm_create(netdev_get_name(ofport->up.netdev));
1779         }
1780
1781         if (cfm_configure(ofport->cfm, s)) {
1782             return 0;
1783         }
1784
1785         error = EINVAL;
1786     }
1787     cfm_destroy(ofport->cfm);
1788     ofport->cfm = NULL;
1789     return error;
1790 }
1791
1792 static int
1793 get_cfm_fault(const struct ofport *ofport_)
1794 {
1795     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1796
1797     return ofport->cfm ? cfm_get_fault(ofport->cfm) : -1;
1798 }
1799
1800 static int
1801 get_cfm_opup(const struct ofport *ofport_)
1802 {
1803     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1804
1805     return ofport->cfm ? cfm_get_opup(ofport->cfm) : -1;
1806 }
1807
1808 static int
1809 get_cfm_remote_mpids(const struct ofport *ofport_, const uint64_t **rmps,
1810                      size_t *n_rmps)
1811 {
1812     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1813
1814     if (ofport->cfm) {
1815         cfm_get_remote_mpids(ofport->cfm, rmps, n_rmps);
1816         return 0;
1817     } else {
1818         return -1;
1819     }
1820 }
1821
1822 static int
1823 get_cfm_health(const struct ofport *ofport_)
1824 {
1825     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1826
1827     return ofport->cfm ? cfm_get_health(ofport->cfm) : -1;
1828 }
1829 \f
1830 /* Spanning Tree. */
1831
1832 static void
1833 send_bpdu_cb(struct ofpbuf *pkt, int port_num, void *ofproto_)
1834 {
1835     struct ofproto_dpif *ofproto = ofproto_;
1836     struct stp_port *sp = stp_get_port(ofproto->stp, port_num);
1837     struct ofport_dpif *ofport;
1838
1839     ofport = stp_port_get_aux(sp);
1840     if (!ofport) {
1841         VLOG_WARN_RL(&rl, "%s: cannot send BPDU on unknown port %d",
1842                      ofproto->up.name, port_num);
1843     } else {
1844         struct eth_header *eth = pkt->l2;
1845
1846         netdev_get_etheraddr(ofport->up.netdev, eth->eth_src);
1847         if (eth_addr_is_zero(eth->eth_src)) {
1848             VLOG_WARN_RL(&rl, "%s: cannot send BPDU on port %d "
1849                          "with unknown MAC", ofproto->up.name, port_num);
1850         } else {
1851             send_packet(ofport, pkt);
1852         }
1853     }
1854     ofpbuf_delete(pkt);
1855 }
1856
1857 /* Configures STP on 'ofproto_' using the settings defined in 's'. */
1858 static int
1859 set_stp(struct ofproto *ofproto_, const struct ofproto_stp_settings *s)
1860 {
1861     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1862
1863     /* Only revalidate flows if the configuration changed. */
1864     if (!s != !ofproto->stp) {
1865         ofproto->backer->need_revalidate = REV_RECONFIGURE;
1866     }
1867
1868     if (s) {
1869         if (!ofproto->stp) {
1870             ofproto->stp = stp_create(ofproto_->name, s->system_id,
1871                                       send_bpdu_cb, ofproto);
1872             ofproto->stp_last_tick = time_msec();
1873         }
1874
1875         stp_set_bridge_id(ofproto->stp, s->system_id);
1876         stp_set_bridge_priority(ofproto->stp, s->priority);
1877         stp_set_hello_time(ofproto->stp, s->hello_time);
1878         stp_set_max_age(ofproto->stp, s->max_age);
1879         stp_set_forward_delay(ofproto->stp, s->fwd_delay);
1880     }  else {
1881         struct ofport *ofport;
1882
1883         HMAP_FOR_EACH (ofport, hmap_node, &ofproto->up.ports) {
1884             set_stp_port(ofport, NULL);
1885         }
1886
1887         stp_destroy(ofproto->stp);
1888         ofproto->stp = NULL;
1889     }
1890
1891     return 0;
1892 }
1893
1894 static int
1895 get_stp_status(struct ofproto *ofproto_, struct ofproto_stp_status *s)
1896 {
1897     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1898
1899     if (ofproto->stp) {
1900         s->enabled = true;
1901         s->bridge_id = stp_get_bridge_id(ofproto->stp);
1902         s->designated_root = stp_get_designated_root(ofproto->stp);
1903         s->root_path_cost = stp_get_root_path_cost(ofproto->stp);
1904     } else {
1905         s->enabled = false;
1906     }
1907
1908     return 0;
1909 }
1910
1911 static void
1912 update_stp_port_state(struct ofport_dpif *ofport)
1913 {
1914     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
1915     enum stp_state state;
1916
1917     /* Figure out new state. */
1918     state = ofport->stp_port ? stp_port_get_state(ofport->stp_port)
1919                              : STP_DISABLED;
1920
1921     /* Update state. */
1922     if (ofport->stp_state != state) {
1923         enum ofputil_port_state of_state;
1924         bool fwd_change;
1925
1926         VLOG_DBG_RL(&rl, "port %s: STP state changed from %s to %s",
1927                     netdev_get_name(ofport->up.netdev),
1928                     stp_state_name(ofport->stp_state),
1929                     stp_state_name(state));
1930         if (stp_learn_in_state(ofport->stp_state)
1931                 != stp_learn_in_state(state)) {
1932             /* xxx Learning action flows should also be flushed. */
1933             mac_learning_flush(ofproto->ml,
1934                                &ofproto->backer->revalidate_set);
1935         }
1936         fwd_change = stp_forward_in_state(ofport->stp_state)
1937                         != stp_forward_in_state(state);
1938
1939         ofproto->backer->need_revalidate = REV_STP;
1940         ofport->stp_state = state;
1941         ofport->stp_state_entered = time_msec();
1942
1943         if (fwd_change && ofport->bundle) {
1944             bundle_update(ofport->bundle);
1945         }
1946
1947         /* Update the STP state bits in the OpenFlow port description. */
1948         of_state = ofport->up.pp.state & ~OFPUTIL_PS_STP_MASK;
1949         of_state |= (state == STP_LISTENING ? OFPUTIL_PS_STP_LISTEN
1950                      : state == STP_LEARNING ? OFPUTIL_PS_STP_LEARN
1951                      : state == STP_FORWARDING ? OFPUTIL_PS_STP_FORWARD
1952                      : state == STP_BLOCKING ?  OFPUTIL_PS_STP_BLOCK
1953                      : 0);
1954         ofproto_port_set_state(&ofport->up, of_state);
1955     }
1956 }
1957
1958 /* Configures STP on 'ofport_' using the settings defined in 's'.  The
1959  * caller is responsible for assigning STP port numbers and ensuring
1960  * there are no duplicates. */
1961 static int
1962 set_stp_port(struct ofport *ofport_,
1963              const struct ofproto_port_stp_settings *s)
1964 {
1965     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1966     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
1967     struct stp_port *sp = ofport->stp_port;
1968
1969     if (!s || !s->enable) {
1970         if (sp) {
1971             ofport->stp_port = NULL;
1972             stp_port_disable(sp);
1973             update_stp_port_state(ofport);
1974         }
1975         return 0;
1976     } else if (sp && stp_port_no(sp) != s->port_num
1977             && ofport == stp_port_get_aux(sp)) {
1978         /* The port-id changed, so disable the old one if it's not
1979          * already in use by another port. */
1980         stp_port_disable(sp);
1981     }
1982
1983     sp = ofport->stp_port = stp_get_port(ofproto->stp, s->port_num);
1984     stp_port_enable(sp);
1985
1986     stp_port_set_aux(sp, ofport);
1987     stp_port_set_priority(sp, s->priority);
1988     stp_port_set_path_cost(sp, s->path_cost);
1989
1990     update_stp_port_state(ofport);
1991
1992     return 0;
1993 }
1994
1995 static int
1996 get_stp_port_status(struct ofport *ofport_,
1997                     struct ofproto_port_stp_status *s)
1998 {
1999     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
2000     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
2001     struct stp_port *sp = ofport->stp_port;
2002
2003     if (!ofproto->stp || !sp) {
2004         s->enabled = false;
2005         return 0;
2006     }
2007
2008     s->enabled = true;
2009     s->port_id = stp_port_get_id(sp);
2010     s->state = stp_port_get_state(sp);
2011     s->sec_in_state = (time_msec() - ofport->stp_state_entered) / 1000;
2012     s->role = stp_port_get_role(sp);
2013     stp_port_get_counts(sp, &s->tx_count, &s->rx_count, &s->error_count);
2014
2015     return 0;
2016 }
2017
2018 static void
2019 stp_run(struct ofproto_dpif *ofproto)
2020 {
2021     if (ofproto->stp) {
2022         long long int now = time_msec();
2023         long long int elapsed = now - ofproto->stp_last_tick;
2024         struct stp_port *sp;
2025
2026         if (elapsed > 0) {
2027             stp_tick(ofproto->stp, MIN(INT_MAX, elapsed));
2028             ofproto->stp_last_tick = now;
2029         }
2030         while (stp_get_changed_port(ofproto->stp, &sp)) {
2031             struct ofport_dpif *ofport = stp_port_get_aux(sp);
2032
2033             if (ofport) {
2034                 update_stp_port_state(ofport);
2035             }
2036         }
2037
2038         if (stp_check_and_reset_fdb_flush(ofproto->stp)) {
2039             mac_learning_flush(ofproto->ml, &ofproto->backer->revalidate_set);
2040         }
2041     }
2042 }
2043
2044 static void
2045 stp_wait(struct ofproto_dpif *ofproto)
2046 {
2047     if (ofproto->stp) {
2048         poll_timer_wait(1000);
2049     }
2050 }
2051
2052 /* Returns true if STP should process 'flow'. */
2053 static bool
2054 stp_should_process_flow(const struct flow *flow)
2055 {
2056     return eth_addr_equals(flow->dl_dst, eth_addr_stp);
2057 }
2058
2059 static void
2060 stp_process_packet(const struct ofport_dpif *ofport,
2061                    const struct ofpbuf *packet)
2062 {
2063     struct ofpbuf payload = *packet;
2064     struct eth_header *eth = payload.data;
2065     struct stp_port *sp = ofport->stp_port;
2066
2067     /* Sink packets on ports that have STP disabled when the bridge has
2068      * STP enabled. */
2069     if (!sp || stp_port_get_state(sp) == STP_DISABLED) {
2070         return;
2071     }
2072
2073     /* Trim off padding on payload. */
2074     if (payload.size > ntohs(eth->eth_type) + ETH_HEADER_LEN) {
2075         payload.size = ntohs(eth->eth_type) + ETH_HEADER_LEN;
2076     }
2077
2078     if (ofpbuf_try_pull(&payload, ETH_HEADER_LEN + LLC_HEADER_LEN)) {
2079         stp_received_bpdu(sp, payload.data, payload.size);
2080     }
2081 }
2082 \f
2083 static struct priority_to_dscp *
2084 get_priority(const struct ofport_dpif *ofport, uint32_t priority)
2085 {
2086     struct priority_to_dscp *pdscp;
2087     uint32_t hash;
2088
2089     hash = hash_int(priority, 0);
2090     HMAP_FOR_EACH_IN_BUCKET (pdscp, hmap_node, hash, &ofport->priorities) {
2091         if (pdscp->priority == priority) {
2092             return pdscp;
2093         }
2094     }
2095     return NULL;
2096 }
2097
2098 static void
2099 ofport_clear_priorities(struct ofport_dpif *ofport)
2100 {
2101     struct priority_to_dscp *pdscp, *next;
2102
2103     HMAP_FOR_EACH_SAFE (pdscp, next, hmap_node, &ofport->priorities) {
2104         hmap_remove(&ofport->priorities, &pdscp->hmap_node);
2105         free(pdscp);
2106     }
2107 }
2108
2109 static int
2110 set_queues(struct ofport *ofport_,
2111            const struct ofproto_port_queue *qdscp_list,
2112            size_t n_qdscp)
2113 {
2114     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
2115     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
2116     struct hmap new = HMAP_INITIALIZER(&new);
2117     size_t i;
2118
2119     for (i = 0; i < n_qdscp; i++) {
2120         struct priority_to_dscp *pdscp;
2121         uint32_t priority;
2122         uint8_t dscp;
2123
2124         dscp = (qdscp_list[i].dscp << 2) & IP_DSCP_MASK;
2125         if (dpif_queue_to_priority(ofproto->backer->dpif, qdscp_list[i].queue,
2126                                    &priority)) {
2127             continue;
2128         }
2129
2130         pdscp = get_priority(ofport, priority);
2131         if (pdscp) {
2132             hmap_remove(&ofport->priorities, &pdscp->hmap_node);
2133         } else {
2134             pdscp = xmalloc(sizeof *pdscp);
2135             pdscp->priority = priority;
2136             pdscp->dscp = dscp;
2137             ofproto->backer->need_revalidate = REV_RECONFIGURE;
2138         }
2139
2140         if (pdscp->dscp != dscp) {
2141             pdscp->dscp = dscp;
2142             ofproto->backer->need_revalidate = REV_RECONFIGURE;
2143         }
2144
2145         hmap_insert(&new, &pdscp->hmap_node, hash_int(pdscp->priority, 0));
2146     }
2147
2148     if (!hmap_is_empty(&ofport->priorities)) {
2149         ofport_clear_priorities(ofport);
2150         ofproto->backer->need_revalidate = REV_RECONFIGURE;
2151     }
2152
2153     hmap_swap(&new, &ofport->priorities);
2154     hmap_destroy(&new);
2155
2156     return 0;
2157 }
2158 \f
2159 /* Bundles. */
2160
2161 /* Expires all MAC learning entries associated with 'bundle' and forces its
2162  * ofproto to revalidate every flow.
2163  *
2164  * Normally MAC learning entries are removed only from the ofproto associated
2165  * with 'bundle', but if 'all_ofprotos' is true, then the MAC learning entries
2166  * are removed from every ofproto.  When patch ports and SLB bonds are in use
2167  * and a VM migration happens and the gratuitous ARPs are somehow lost, this
2168  * avoids a MAC_ENTRY_IDLE_TIME delay before the migrated VM can communicate
2169  * with the host from which it migrated. */
2170 static void
2171 bundle_flush_macs(struct ofbundle *bundle, bool all_ofprotos)
2172 {
2173     struct ofproto_dpif *ofproto = bundle->ofproto;
2174     struct mac_learning *ml = ofproto->ml;
2175     struct mac_entry *mac, *next_mac;
2176
2177     ofproto->backer->need_revalidate = REV_RECONFIGURE;
2178     LIST_FOR_EACH_SAFE (mac, next_mac, lru_node, &ml->lrus) {
2179         if (mac->port.p == bundle) {
2180             if (all_ofprotos) {
2181                 struct ofproto_dpif *o;
2182
2183                 HMAP_FOR_EACH (o, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
2184                     if (o != ofproto) {
2185                         struct mac_entry *e;
2186
2187                         e = mac_learning_lookup(o->ml, mac->mac, mac->vlan,
2188                                                 NULL);
2189                         if (e) {
2190                             mac_learning_expire(o->ml, e);
2191                         }
2192                     }
2193                 }
2194             }
2195
2196             mac_learning_expire(ml, mac);
2197         }
2198     }
2199 }
2200
2201 static struct ofbundle *
2202 bundle_lookup(const struct ofproto_dpif *ofproto, void *aux)
2203 {
2204     struct ofbundle *bundle;
2205
2206     HMAP_FOR_EACH_IN_BUCKET (bundle, hmap_node, hash_pointer(aux, 0),
2207                              &ofproto->bundles) {
2208         if (bundle->aux == aux) {
2209             return bundle;
2210         }
2211     }
2212     return NULL;
2213 }
2214
2215 /* Looks up each of the 'n_auxes' pointers in 'auxes' as bundles and adds the
2216  * ones that are found to 'bundles'. */
2217 static void
2218 bundle_lookup_multiple(struct ofproto_dpif *ofproto,
2219                        void **auxes, size_t n_auxes,
2220                        struct hmapx *bundles)
2221 {
2222     size_t i;
2223
2224     hmapx_init(bundles);
2225     for (i = 0; i < n_auxes; i++) {
2226         struct ofbundle *bundle = bundle_lookup(ofproto, auxes[i]);
2227         if (bundle) {
2228             hmapx_add(bundles, bundle);
2229         }
2230     }
2231 }
2232
2233 static void
2234 bundle_update(struct ofbundle *bundle)
2235 {
2236     struct ofport_dpif *port;
2237
2238     bundle->floodable = true;
2239     LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
2240         if (port->up.pp.config & OFPUTIL_PC_NO_FLOOD
2241             || !stp_forward_in_state(port->stp_state)) {
2242             bundle->floodable = false;
2243             break;
2244         }
2245     }
2246 }
2247
2248 static void
2249 bundle_del_port(struct ofport_dpif *port)
2250 {
2251     struct ofbundle *bundle = port->bundle;
2252
2253     bundle->ofproto->backer->need_revalidate = REV_RECONFIGURE;
2254
2255     list_remove(&port->bundle_node);
2256     port->bundle = NULL;
2257
2258     if (bundle->lacp) {
2259         lacp_slave_unregister(bundle->lacp, port);
2260     }
2261     if (bundle->bond) {
2262         bond_slave_unregister(bundle->bond, port);
2263     }
2264
2265     bundle_update(bundle);
2266 }
2267
2268 static bool
2269 bundle_add_port(struct ofbundle *bundle, uint32_t ofp_port,
2270                 struct lacp_slave_settings *lacp,
2271                 uint32_t bond_stable_id)
2272 {
2273     struct ofport_dpif *port;
2274
2275     port = get_ofp_port(bundle->ofproto, ofp_port);
2276     if (!port) {
2277         return false;
2278     }
2279
2280     if (port->bundle != bundle) {
2281         bundle->ofproto->backer->need_revalidate = REV_RECONFIGURE;
2282         if (port->bundle) {
2283             bundle_del_port(port);
2284         }
2285
2286         port->bundle = bundle;
2287         list_push_back(&bundle->ports, &port->bundle_node);
2288         if (port->up.pp.config & OFPUTIL_PC_NO_FLOOD
2289             || !stp_forward_in_state(port->stp_state)) {
2290             bundle->floodable = false;
2291         }
2292     }
2293     if (lacp) {
2294         bundle->ofproto->backer->need_revalidate = REV_RECONFIGURE;
2295         lacp_slave_register(bundle->lacp, port, lacp);
2296     }
2297
2298     port->bond_stable_id = bond_stable_id;
2299
2300     return true;
2301 }
2302
2303 static void
2304 bundle_destroy(struct ofbundle *bundle)
2305 {
2306     struct ofproto_dpif *ofproto;
2307     struct ofport_dpif *port, *next_port;
2308     int i;
2309
2310     if (!bundle) {
2311         return;
2312     }
2313
2314     ofproto = bundle->ofproto;
2315     for (i = 0; i < MAX_MIRRORS; i++) {
2316         struct ofmirror *m = ofproto->mirrors[i];
2317         if (m) {
2318             if (m->out == bundle) {
2319                 mirror_destroy(m);
2320             } else if (hmapx_find_and_delete(&m->srcs, bundle)
2321                        || hmapx_find_and_delete(&m->dsts, bundle)) {
2322                 ofproto->backer->need_revalidate = REV_RECONFIGURE;
2323             }
2324         }
2325     }
2326
2327     LIST_FOR_EACH_SAFE (port, next_port, bundle_node, &bundle->ports) {
2328         bundle_del_port(port);
2329     }
2330
2331     bundle_flush_macs(bundle, true);
2332     hmap_remove(&ofproto->bundles, &bundle->hmap_node);
2333     free(bundle->name);
2334     free(bundle->trunks);
2335     lacp_destroy(bundle->lacp);
2336     bond_destroy(bundle->bond);
2337     free(bundle);
2338 }
2339
2340 static int
2341 bundle_set(struct ofproto *ofproto_, void *aux,
2342            const struct ofproto_bundle_settings *s)
2343 {
2344     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2345     bool need_flush = false;
2346     struct ofport_dpif *port;
2347     struct ofbundle *bundle;
2348     unsigned long *trunks;
2349     int vlan;
2350     size_t i;
2351     bool ok;
2352
2353     if (!s) {
2354         bundle_destroy(bundle_lookup(ofproto, aux));
2355         return 0;
2356     }
2357
2358     ovs_assert(s->n_slaves == 1 || s->bond != NULL);
2359     ovs_assert((s->lacp != NULL) == (s->lacp_slaves != NULL));
2360
2361     bundle = bundle_lookup(ofproto, aux);
2362     if (!bundle) {
2363         bundle = xmalloc(sizeof *bundle);
2364
2365         bundle->ofproto = ofproto;
2366         hmap_insert(&ofproto->bundles, &bundle->hmap_node,
2367                     hash_pointer(aux, 0));
2368         bundle->aux = aux;
2369         bundle->name = NULL;
2370
2371         list_init(&bundle->ports);
2372         bundle->vlan_mode = PORT_VLAN_TRUNK;
2373         bundle->vlan = -1;
2374         bundle->trunks = NULL;
2375         bundle->use_priority_tags = s->use_priority_tags;
2376         bundle->lacp = NULL;
2377         bundle->bond = NULL;
2378
2379         bundle->floodable = true;
2380
2381         bundle->src_mirrors = 0;
2382         bundle->dst_mirrors = 0;
2383         bundle->mirror_out = 0;
2384     }
2385
2386     if (!bundle->name || strcmp(s->name, bundle->name)) {
2387         free(bundle->name);
2388         bundle->name = xstrdup(s->name);
2389     }
2390
2391     /* LACP. */
2392     if (s->lacp) {
2393         if (!bundle->lacp) {
2394             ofproto->backer->need_revalidate = REV_RECONFIGURE;
2395             bundle->lacp = lacp_create();
2396         }
2397         lacp_configure(bundle->lacp, s->lacp);
2398     } else {
2399         lacp_destroy(bundle->lacp);
2400         bundle->lacp = NULL;
2401     }
2402
2403     /* Update set of ports. */
2404     ok = true;
2405     for (i = 0; i < s->n_slaves; i++) {
2406         if (!bundle_add_port(bundle, s->slaves[i],
2407                              s->lacp ? &s->lacp_slaves[i] : NULL,
2408                              s->bond_stable_ids ? s->bond_stable_ids[i] : 0)) {
2409             ok = false;
2410         }
2411     }
2412     if (!ok || list_size(&bundle->ports) != s->n_slaves) {
2413         struct ofport_dpif *next_port;
2414
2415         LIST_FOR_EACH_SAFE (port, next_port, bundle_node, &bundle->ports) {
2416             for (i = 0; i < s->n_slaves; i++) {
2417                 if (s->slaves[i] == port->up.ofp_port) {
2418                     goto found;
2419                 }
2420             }
2421
2422             bundle_del_port(port);
2423         found: ;
2424         }
2425     }
2426     ovs_assert(list_size(&bundle->ports) <= s->n_slaves);
2427
2428     if (list_is_empty(&bundle->ports)) {
2429         bundle_destroy(bundle);
2430         return EINVAL;
2431     }
2432
2433     /* Set VLAN tagging mode */
2434     if (s->vlan_mode != bundle->vlan_mode
2435         || s->use_priority_tags != bundle->use_priority_tags) {
2436         bundle->vlan_mode = s->vlan_mode;
2437         bundle->use_priority_tags = s->use_priority_tags;
2438         need_flush = true;
2439     }
2440
2441     /* Set VLAN tag. */
2442     vlan = (s->vlan_mode == PORT_VLAN_TRUNK ? -1
2443             : s->vlan >= 0 && s->vlan <= 4095 ? s->vlan
2444             : 0);
2445     if (vlan != bundle->vlan) {
2446         bundle->vlan = vlan;
2447         need_flush = true;
2448     }
2449
2450     /* Get trunked VLANs. */
2451     switch (s->vlan_mode) {
2452     case PORT_VLAN_ACCESS:
2453         trunks = NULL;
2454         break;
2455
2456     case PORT_VLAN_TRUNK:
2457         trunks = CONST_CAST(unsigned long *, s->trunks);
2458         break;
2459
2460     case PORT_VLAN_NATIVE_UNTAGGED:
2461     case PORT_VLAN_NATIVE_TAGGED:
2462         if (vlan != 0 && (!s->trunks
2463                           || !bitmap_is_set(s->trunks, vlan)
2464                           || bitmap_is_set(s->trunks, 0))) {
2465             /* Force trunking the native VLAN and prohibit trunking VLAN 0. */
2466             if (s->trunks) {
2467                 trunks = bitmap_clone(s->trunks, 4096);
2468             } else {
2469                 trunks = bitmap_allocate1(4096);
2470             }
2471             bitmap_set1(trunks, vlan);
2472             bitmap_set0(trunks, 0);
2473         } else {
2474             trunks = CONST_CAST(unsigned long *, s->trunks);
2475         }
2476         break;
2477
2478     default:
2479         NOT_REACHED();
2480     }
2481     if (!vlan_bitmap_equal(trunks, bundle->trunks)) {
2482         free(bundle->trunks);
2483         if (trunks == s->trunks) {
2484             bundle->trunks = vlan_bitmap_clone(trunks);
2485         } else {
2486             bundle->trunks = trunks;
2487             trunks = NULL;
2488         }
2489         need_flush = true;
2490     }
2491     if (trunks != s->trunks) {
2492         free(trunks);
2493     }
2494
2495     /* Bonding. */
2496     if (!list_is_short(&bundle->ports)) {
2497         bundle->ofproto->has_bonded_bundles = true;
2498         if (bundle->bond) {
2499             if (bond_reconfigure(bundle->bond, s->bond)) {
2500                 ofproto->backer->need_revalidate = REV_RECONFIGURE;
2501             }
2502         } else {
2503             bundle->bond = bond_create(s->bond);
2504             ofproto->backer->need_revalidate = REV_RECONFIGURE;
2505         }
2506
2507         LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
2508             bond_slave_register(bundle->bond, port, port->bond_stable_id,
2509                                 port->up.netdev);
2510         }
2511     } else {
2512         bond_destroy(bundle->bond);
2513         bundle->bond = NULL;
2514     }
2515
2516     /* If we changed something that would affect MAC learning, un-learn
2517      * everything on this port and force flow revalidation. */
2518     if (need_flush) {
2519         bundle_flush_macs(bundle, false);
2520     }
2521
2522     return 0;
2523 }
2524
2525 static void
2526 bundle_remove(struct ofport *port_)
2527 {
2528     struct ofport_dpif *port = ofport_dpif_cast(port_);
2529     struct ofbundle *bundle = port->bundle;
2530
2531     if (bundle) {
2532         bundle_del_port(port);
2533         if (list_is_empty(&bundle->ports)) {
2534             bundle_destroy(bundle);
2535         } else if (list_is_short(&bundle->ports)) {
2536             bond_destroy(bundle->bond);
2537             bundle->bond = NULL;
2538         }
2539     }
2540 }
2541
2542 static void
2543 send_pdu_cb(void *port_, const void *pdu, size_t pdu_size)
2544 {
2545     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 10);
2546     struct ofport_dpif *port = port_;
2547     uint8_t ea[ETH_ADDR_LEN];
2548     int error;
2549
2550     error = netdev_get_etheraddr(port->up.netdev, ea);
2551     if (!error) {
2552         struct ofpbuf packet;
2553         void *packet_pdu;
2554
2555         ofpbuf_init(&packet, 0);
2556         packet_pdu = eth_compose(&packet, eth_addr_lacp, ea, ETH_TYPE_LACP,
2557                                  pdu_size);
2558         memcpy(packet_pdu, pdu, pdu_size);
2559
2560         send_packet(port, &packet);
2561         ofpbuf_uninit(&packet);
2562     } else {
2563         VLOG_ERR_RL(&rl, "port %s: cannot obtain Ethernet address of iface "
2564                     "%s (%s)", port->bundle->name,
2565                     netdev_get_name(port->up.netdev), strerror(error));
2566     }
2567 }
2568
2569 static void
2570 bundle_send_learning_packets(struct ofbundle *bundle)
2571 {
2572     struct ofproto_dpif *ofproto = bundle->ofproto;
2573     int error, n_packets, n_errors;
2574     struct mac_entry *e;
2575
2576     error = n_packets = n_errors = 0;
2577     LIST_FOR_EACH (e, lru_node, &ofproto->ml->lrus) {
2578         if (e->port.p != bundle) {
2579             struct ofpbuf *learning_packet;
2580             struct ofport_dpif *port;
2581             void *port_void;
2582             int ret;
2583
2584             /* The assignment to "port" is unnecessary but makes "grep"ing for
2585              * struct ofport_dpif more effective. */
2586             learning_packet = bond_compose_learning_packet(bundle->bond,
2587                                                            e->mac, e->vlan,
2588                                                            &port_void);
2589             port = port_void;
2590             ret = send_packet(port, learning_packet);
2591             ofpbuf_delete(learning_packet);
2592             if (ret) {
2593                 error = ret;
2594                 n_errors++;
2595             }
2596             n_packets++;
2597         }
2598     }
2599
2600     if (n_errors) {
2601         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
2602         VLOG_WARN_RL(&rl, "bond %s: %d errors sending %d gratuitous learning "
2603                      "packets, last error was: %s",
2604                      bundle->name, n_errors, n_packets, strerror(error));
2605     } else {
2606         VLOG_DBG("bond %s: sent %d gratuitous learning packets",
2607                  bundle->name, n_packets);
2608     }
2609 }
2610
2611 static void
2612 bundle_run(struct ofbundle *bundle)
2613 {
2614     if (bundle->lacp) {
2615         lacp_run(bundle->lacp, send_pdu_cb);
2616     }
2617     if (bundle->bond) {
2618         struct ofport_dpif *port;
2619
2620         LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
2621             bond_slave_set_may_enable(bundle->bond, port, port->may_enable);
2622         }
2623
2624         bond_run(bundle->bond, &bundle->ofproto->backer->revalidate_set,
2625                  lacp_status(bundle->lacp));
2626         if (bond_should_send_learning_packets(bundle->bond)) {
2627             bundle_send_learning_packets(bundle);
2628         }
2629     }
2630 }
2631
2632 static void
2633 bundle_wait(struct ofbundle *bundle)
2634 {
2635     if (bundle->lacp) {
2636         lacp_wait(bundle->lacp);
2637     }
2638     if (bundle->bond) {
2639         bond_wait(bundle->bond);
2640     }
2641 }
2642 \f
2643 /* Mirrors. */
2644
2645 static int
2646 mirror_scan(struct ofproto_dpif *ofproto)
2647 {
2648     int idx;
2649
2650     for (idx = 0; idx < MAX_MIRRORS; idx++) {
2651         if (!ofproto->mirrors[idx]) {
2652             return idx;
2653         }
2654     }
2655     return -1;
2656 }
2657
2658 static struct ofmirror *
2659 mirror_lookup(struct ofproto_dpif *ofproto, void *aux)
2660 {
2661     int i;
2662
2663     for (i = 0; i < MAX_MIRRORS; i++) {
2664         struct ofmirror *mirror = ofproto->mirrors[i];
2665         if (mirror && mirror->aux == aux) {
2666             return mirror;
2667         }
2668     }
2669
2670     return NULL;
2671 }
2672
2673 /* Update the 'dup_mirrors' member of each of the ofmirrors in 'ofproto'. */
2674 static void
2675 mirror_update_dups(struct ofproto_dpif *ofproto)
2676 {
2677     int i;
2678
2679     for (i = 0; i < MAX_MIRRORS; i++) {
2680         struct ofmirror *m = ofproto->mirrors[i];
2681
2682         if (m) {
2683             m->dup_mirrors = MIRROR_MASK_C(1) << i;
2684         }
2685     }
2686
2687     for (i = 0; i < MAX_MIRRORS; i++) {
2688         struct ofmirror *m1 = ofproto->mirrors[i];
2689         int j;
2690
2691         if (!m1) {
2692             continue;
2693         }
2694
2695         for (j = i + 1; j < MAX_MIRRORS; j++) {
2696             struct ofmirror *m2 = ofproto->mirrors[j];
2697
2698             if (m2 && m1->out == m2->out && m1->out_vlan == m2->out_vlan) {
2699                 m1->dup_mirrors |= MIRROR_MASK_C(1) << j;
2700                 m2->dup_mirrors |= m1->dup_mirrors;
2701             }
2702         }
2703     }
2704 }
2705
2706 static int
2707 mirror_set(struct ofproto *ofproto_, void *aux,
2708            const struct ofproto_mirror_settings *s)
2709 {
2710     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2711     mirror_mask_t mirror_bit;
2712     struct ofbundle *bundle;
2713     struct ofmirror *mirror;
2714     struct ofbundle *out;
2715     struct hmapx srcs;          /* Contains "struct ofbundle *"s. */
2716     struct hmapx dsts;          /* Contains "struct ofbundle *"s. */
2717     int out_vlan;
2718
2719     mirror = mirror_lookup(ofproto, aux);
2720     if (!s) {
2721         mirror_destroy(mirror);
2722         return 0;
2723     }
2724     if (!mirror) {
2725         int idx;
2726
2727         idx = mirror_scan(ofproto);
2728         if (idx < 0) {
2729             VLOG_WARN("bridge %s: maximum of %d port mirrors reached, "
2730                       "cannot create %s",
2731                       ofproto->up.name, MAX_MIRRORS, s->name);
2732             return EFBIG;
2733         }
2734
2735         mirror = ofproto->mirrors[idx] = xzalloc(sizeof *mirror);
2736         mirror->ofproto = ofproto;
2737         mirror->idx = idx;
2738         mirror->aux = aux;
2739         mirror->out_vlan = -1;
2740         mirror->name = NULL;
2741     }
2742
2743     if (!mirror->name || strcmp(s->name, mirror->name)) {
2744         free(mirror->name);
2745         mirror->name = xstrdup(s->name);
2746     }
2747
2748     /* Get the new configuration. */
2749     if (s->out_bundle) {
2750         out = bundle_lookup(ofproto, s->out_bundle);
2751         if (!out) {
2752             mirror_destroy(mirror);
2753             return EINVAL;
2754         }
2755         out_vlan = -1;
2756     } else {
2757         out = NULL;
2758         out_vlan = s->out_vlan;
2759     }
2760     bundle_lookup_multiple(ofproto, s->srcs, s->n_srcs, &srcs);
2761     bundle_lookup_multiple(ofproto, s->dsts, s->n_dsts, &dsts);
2762
2763     /* If the configuration has not changed, do nothing. */
2764     if (hmapx_equals(&srcs, &mirror->srcs)
2765         && hmapx_equals(&dsts, &mirror->dsts)
2766         && vlan_bitmap_equal(mirror->vlans, s->src_vlans)
2767         && mirror->out == out
2768         && mirror->out_vlan == out_vlan)
2769     {
2770         hmapx_destroy(&srcs);
2771         hmapx_destroy(&dsts);
2772         return 0;
2773     }
2774
2775     hmapx_swap(&srcs, &mirror->srcs);
2776     hmapx_destroy(&srcs);
2777
2778     hmapx_swap(&dsts, &mirror->dsts);
2779     hmapx_destroy(&dsts);
2780
2781     free(mirror->vlans);
2782     mirror->vlans = vlan_bitmap_clone(s->src_vlans);
2783
2784     mirror->out = out;
2785     mirror->out_vlan = out_vlan;
2786
2787     /* Update bundles. */
2788     mirror_bit = MIRROR_MASK_C(1) << mirror->idx;
2789     HMAP_FOR_EACH (bundle, hmap_node, &mirror->ofproto->bundles) {
2790         if (hmapx_contains(&mirror->srcs, bundle)) {
2791             bundle->src_mirrors |= mirror_bit;
2792         } else {
2793             bundle->src_mirrors &= ~mirror_bit;
2794         }
2795
2796         if (hmapx_contains(&mirror->dsts, bundle)) {
2797             bundle->dst_mirrors |= mirror_bit;
2798         } else {
2799             bundle->dst_mirrors &= ~mirror_bit;
2800         }
2801
2802         if (mirror->out == bundle) {
2803             bundle->mirror_out |= mirror_bit;
2804         } else {
2805             bundle->mirror_out &= ~mirror_bit;
2806         }
2807     }
2808
2809     ofproto->backer->need_revalidate = REV_RECONFIGURE;
2810     ofproto->has_mirrors = true;
2811     mac_learning_flush(ofproto->ml,
2812                        &ofproto->backer->revalidate_set);
2813     mirror_update_dups(ofproto);
2814
2815     return 0;
2816 }
2817
2818 static void
2819 mirror_destroy(struct ofmirror *mirror)
2820 {
2821     struct ofproto_dpif *ofproto;
2822     mirror_mask_t mirror_bit;
2823     struct ofbundle *bundle;
2824     int i;
2825
2826     if (!mirror) {
2827         return;
2828     }
2829
2830     ofproto = mirror->ofproto;
2831     ofproto->backer->need_revalidate = REV_RECONFIGURE;
2832     mac_learning_flush(ofproto->ml, &ofproto->backer->revalidate_set);
2833
2834     mirror_bit = MIRROR_MASK_C(1) << mirror->idx;
2835     HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
2836         bundle->src_mirrors &= ~mirror_bit;
2837         bundle->dst_mirrors &= ~mirror_bit;
2838         bundle->mirror_out &= ~mirror_bit;
2839     }
2840
2841     hmapx_destroy(&mirror->srcs);
2842     hmapx_destroy(&mirror->dsts);
2843     free(mirror->vlans);
2844
2845     ofproto->mirrors[mirror->idx] = NULL;
2846     free(mirror->name);
2847     free(mirror);
2848
2849     mirror_update_dups(ofproto);
2850
2851     ofproto->has_mirrors = false;
2852     for (i = 0; i < MAX_MIRRORS; i++) {
2853         if (ofproto->mirrors[i]) {
2854             ofproto->has_mirrors = true;
2855             break;
2856         }
2857     }
2858 }
2859
2860 static int
2861 mirror_get_stats(struct ofproto *ofproto_, void *aux,
2862                  uint64_t *packets, uint64_t *bytes)
2863 {
2864     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2865     struct ofmirror *mirror = mirror_lookup(ofproto, aux);
2866
2867     if (!mirror) {
2868         *packets = *bytes = UINT64_MAX;
2869         return 0;
2870     }
2871
2872     *packets = mirror->packet_count;
2873     *bytes = mirror->byte_count;
2874
2875     return 0;
2876 }
2877
2878 static int
2879 set_flood_vlans(struct ofproto *ofproto_, unsigned long *flood_vlans)
2880 {
2881     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2882     if (mac_learning_set_flood_vlans(ofproto->ml, flood_vlans)) {
2883         mac_learning_flush(ofproto->ml, &ofproto->backer->revalidate_set);
2884     }
2885     return 0;
2886 }
2887
2888 static bool
2889 is_mirror_output_bundle(const struct ofproto *ofproto_, void *aux)
2890 {
2891     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2892     struct ofbundle *bundle = bundle_lookup(ofproto, aux);
2893     return bundle && bundle->mirror_out != 0;
2894 }
2895
2896 static void
2897 forward_bpdu_changed(struct ofproto *ofproto_)
2898 {
2899     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2900     ofproto->backer->need_revalidate = REV_RECONFIGURE;
2901 }
2902
2903 static void
2904 set_mac_table_config(struct ofproto *ofproto_, unsigned int idle_time,
2905                      size_t max_entries)
2906 {
2907     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
2908     mac_learning_set_idle_time(ofproto->ml, idle_time);
2909     mac_learning_set_max_entries(ofproto->ml, max_entries);
2910 }
2911 \f
2912 /* Ports. */
2913
2914 static struct ofport_dpif *
2915 get_ofp_port(const struct ofproto_dpif *ofproto, uint16_t ofp_port)
2916 {
2917     struct ofport *ofport = ofproto_get_port(&ofproto->up, ofp_port);
2918     return ofport ? ofport_dpif_cast(ofport) : NULL;
2919 }
2920
2921 static struct ofport_dpif *
2922 get_odp_port(const struct ofproto_dpif *ofproto, uint32_t odp_port)
2923 {
2924     struct ofport_dpif *port = odp_port_to_ofport(ofproto->backer, odp_port);
2925     return port && &ofproto->up == port->up.ofproto ? port : NULL;
2926 }
2927
2928 static void
2929 ofproto_port_from_dpif_port(struct ofproto_dpif *ofproto,
2930                             struct ofproto_port *ofproto_port,
2931                             struct dpif_port *dpif_port)
2932 {
2933     ofproto_port->name = dpif_port->name;
2934     ofproto_port->type = dpif_port->type;
2935     ofproto_port->ofp_port = odp_port_to_ofp_port(ofproto, dpif_port->port_no);
2936 }
2937
2938 static struct ofport_dpif *
2939 ofport_get_peer(const struct ofport_dpif *ofport_dpif)
2940 {
2941     const struct ofproto_dpif *ofproto;
2942     const char *peer;
2943
2944     peer = netdev_vport_patch_peer(ofport_dpif->up.netdev);
2945     if (!peer) {
2946         return NULL;
2947     }
2948
2949     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
2950         struct ofport *ofport;
2951
2952         ofport = shash_find_data(&ofproto->up.port_by_name, peer);
2953         if (ofport && ofport->ofproto->ofproto_class == &ofproto_dpif_class) {
2954             return ofport_dpif_cast(ofport);
2955         }
2956     }
2957     return NULL;
2958 }
2959
2960 static void
2961 port_run_fast(struct ofport_dpif *ofport)
2962 {
2963     if (ofport->cfm && cfm_should_send_ccm(ofport->cfm)) {
2964         struct ofpbuf packet;
2965
2966         ofpbuf_init(&packet, 0);
2967         cfm_compose_ccm(ofport->cfm, &packet, ofport->up.pp.hw_addr);
2968         send_packet(ofport, &packet);
2969         ofpbuf_uninit(&packet);
2970     }
2971 }
2972
2973 static void
2974 port_run(struct ofport_dpif *ofport)
2975 {
2976     long long int carrier_seq = netdev_get_carrier_resets(ofport->up.netdev);
2977     bool carrier_changed = carrier_seq != ofport->carrier_seq;
2978     bool enable = netdev_get_carrier(ofport->up.netdev);
2979
2980     ofport->carrier_seq = carrier_seq;
2981
2982     port_run_fast(ofport);
2983
2984     if (ofport->tnl_port
2985         && tnl_port_reconfigure(&ofport->up, ofport->odp_port,
2986                                 &ofport->tnl_port)) {
2987         ofproto_dpif_cast(ofport->up.ofproto)->backer->need_revalidate = true;
2988     }
2989
2990     if (ofport->cfm) {
2991         int cfm_opup = cfm_get_opup(ofport->cfm);
2992
2993         cfm_run(ofport->cfm);
2994         enable = enable && !cfm_get_fault(ofport->cfm);
2995
2996         if (cfm_opup >= 0) {
2997             enable = enable && cfm_opup;
2998         }
2999     }
3000
3001     if (ofport->bundle) {
3002         enable = enable && lacp_slave_may_enable(ofport->bundle->lacp, ofport);
3003         if (carrier_changed) {
3004             lacp_slave_carrier_changed(ofport->bundle->lacp, ofport);
3005         }
3006     }
3007
3008     if (ofport->may_enable != enable) {
3009         struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
3010
3011         if (ofproto->has_bundle_action) {
3012             ofproto->backer->need_revalidate = REV_PORT_TOGGLED;
3013         }
3014     }
3015
3016     ofport->may_enable = enable;
3017 }
3018
3019 static void
3020 port_wait(struct ofport_dpif *ofport)
3021 {
3022     if (ofport->cfm) {
3023         cfm_wait(ofport->cfm);
3024     }
3025 }
3026
3027 static int
3028 port_query_by_name(const struct ofproto *ofproto_, const char *devname,
3029                    struct ofproto_port *ofproto_port)
3030 {
3031     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3032     struct dpif_port dpif_port;
3033     int error;
3034
3035     if (sset_contains(&ofproto->ghost_ports, devname)) {
3036         const char *type = netdev_get_type_from_name(devname);
3037
3038         /* We may be called before ofproto->up.port_by_name is populated with
3039          * the appropriate ofport.  For this reason, we must get the name and
3040          * type from the netdev layer directly. */
3041         if (type) {
3042             const struct ofport *ofport;
3043
3044             ofport = shash_find_data(&ofproto->up.port_by_name, devname);
3045             ofproto_port->ofp_port = ofport ? ofport->ofp_port : OFPP_NONE;
3046             ofproto_port->name = xstrdup(devname);
3047             ofproto_port->type = xstrdup(type);
3048             return 0;
3049         }
3050         return ENODEV;
3051     }
3052
3053     if (!sset_contains(&ofproto->ports, devname)) {
3054         return ENODEV;
3055     }
3056     error = dpif_port_query_by_name(ofproto->backer->dpif,
3057                                     devname, &dpif_port);
3058     if (!error) {
3059         ofproto_port_from_dpif_port(ofproto, ofproto_port, &dpif_port);
3060     }
3061     return error;
3062 }
3063
3064 static int
3065 port_add(struct ofproto *ofproto_, struct netdev *netdev)
3066 {
3067     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3068     const char *dp_port_name = netdev_vport_get_dpif_port(netdev);
3069     const char *devname = netdev_get_name(netdev);
3070
3071     if (netdev_vport_is_patch(netdev)) {
3072         sset_add(&ofproto->ghost_ports, netdev_get_name(netdev));
3073         return 0;
3074     }
3075
3076     if (!dpif_port_exists(ofproto->backer->dpif, dp_port_name)) {
3077         uint32_t port_no = UINT32_MAX;
3078         int error;
3079
3080         error = dpif_port_add(ofproto->backer->dpif, netdev, &port_no);
3081         if (error) {
3082             return error;
3083         }
3084         if (netdev_get_tunnel_config(netdev)) {
3085             simap_put(&ofproto->backer->tnl_backers, dp_port_name, port_no);
3086         }
3087     }
3088
3089     if (netdev_get_tunnel_config(netdev)) {
3090         sset_add(&ofproto->ghost_ports, devname);
3091     } else {
3092         sset_add(&ofproto->ports, devname);
3093     }
3094     return 0;
3095 }
3096
3097 static int
3098 port_del(struct ofproto *ofproto_, uint16_t ofp_port)
3099 {
3100     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3101     struct ofport_dpif *ofport = get_ofp_port(ofproto, ofp_port);
3102     int error = 0;
3103
3104     if (!ofport) {
3105         return 0;
3106     }
3107
3108     sset_find_and_delete(&ofproto->ghost_ports,
3109                          netdev_get_name(ofport->up.netdev));
3110     ofproto->backer->need_revalidate = REV_RECONFIGURE;
3111     if (!ofport->tnl_port) {
3112         error = dpif_port_del(ofproto->backer->dpif, ofport->odp_port);
3113         if (!error) {
3114             /* The caller is going to close ofport->up.netdev.  If this is a
3115              * bonded port, then the bond is using that netdev, so remove it
3116              * from the bond.  The client will need to reconfigure everything
3117              * after deleting ports, so then the slave will get re-added. */
3118             bundle_remove(&ofport->up);
3119         }
3120     }
3121     return error;
3122 }
3123
3124 static int
3125 port_get_stats(const struct ofport *ofport_, struct netdev_stats *stats)
3126 {
3127     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
3128     int error;
3129
3130     error = netdev_get_stats(ofport->up.netdev, stats);
3131
3132     if (!error && ofport_->ofp_port == OFPP_LOCAL) {
3133         struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
3134
3135         /* ofproto->stats.tx_packets represents packets that we created
3136          * internally and sent to some port (e.g. packets sent with
3137          * send_packet()).  Account for them as if they had come from
3138          * OFPP_LOCAL and got forwarded. */
3139
3140         if (stats->rx_packets != UINT64_MAX) {
3141             stats->rx_packets += ofproto->stats.tx_packets;
3142         }
3143
3144         if (stats->rx_bytes != UINT64_MAX) {
3145             stats->rx_bytes += ofproto->stats.tx_bytes;
3146         }
3147
3148         /* ofproto->stats.rx_packets represents packets that were received on
3149          * some port and we processed internally and dropped (e.g. STP).
3150          * Account for them as if they had been forwarded to OFPP_LOCAL. */
3151
3152         if (stats->tx_packets != UINT64_MAX) {
3153             stats->tx_packets += ofproto->stats.rx_packets;
3154         }
3155
3156         if (stats->tx_bytes != UINT64_MAX) {
3157             stats->tx_bytes += ofproto->stats.rx_bytes;
3158         }
3159     }
3160
3161     return error;
3162 }
3163
3164 /* Account packets for LOCAL port. */
3165 static void
3166 ofproto_update_local_port_stats(const struct ofproto *ofproto_,
3167                                 size_t tx_size, size_t rx_size)
3168 {
3169     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3170
3171     if (rx_size) {
3172         ofproto->stats.rx_packets++;
3173         ofproto->stats.rx_bytes += rx_size;
3174     }
3175     if (tx_size) {
3176         ofproto->stats.tx_packets++;
3177         ofproto->stats.tx_bytes += tx_size;
3178     }
3179 }
3180
3181 struct port_dump_state {
3182     uint32_t bucket;
3183     uint32_t offset;
3184     bool ghost;
3185
3186     struct ofproto_port port;
3187     bool has_port;
3188 };
3189
3190 static int
3191 port_dump_start(const struct ofproto *ofproto_ OVS_UNUSED, void **statep)
3192 {
3193     *statep = xzalloc(sizeof(struct port_dump_state));
3194     return 0;
3195 }
3196
3197 static int
3198 port_dump_next(const struct ofproto *ofproto_, void *state_,
3199                struct ofproto_port *port)
3200 {
3201     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3202     struct port_dump_state *state = state_;
3203     const struct sset *sset;
3204     struct sset_node *node;
3205
3206     if (state->has_port) {
3207         ofproto_port_destroy(&state->port);
3208         state->has_port = false;
3209     }
3210     sset = state->ghost ? &ofproto->ghost_ports : &ofproto->ports;
3211     while ((node = sset_at_position(sset, &state->bucket, &state->offset))) {
3212         int error;
3213
3214         error = port_query_by_name(ofproto_, node->name, &state->port);
3215         if (!error) {
3216             *port = state->port;
3217             state->has_port = true;
3218             return 0;
3219         } else if (error != ENODEV) {
3220             return error;
3221         }
3222     }
3223
3224     if (!state->ghost) {
3225         state->ghost = true;
3226         state->bucket = 0;
3227         state->offset = 0;
3228         return port_dump_next(ofproto_, state_, port);
3229     }
3230
3231     return EOF;
3232 }
3233
3234 static int
3235 port_dump_done(const struct ofproto *ofproto_ OVS_UNUSED, void *state_)
3236 {
3237     struct port_dump_state *state = state_;
3238
3239     if (state->has_port) {
3240         ofproto_port_destroy(&state->port);
3241     }
3242     free(state);
3243     return 0;
3244 }
3245
3246 static int
3247 port_poll(const struct ofproto *ofproto_, char **devnamep)
3248 {
3249     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3250
3251     if (ofproto->port_poll_errno) {
3252         int error = ofproto->port_poll_errno;
3253         ofproto->port_poll_errno = 0;
3254         return error;
3255     }
3256
3257     if (sset_is_empty(&ofproto->port_poll_set)) {
3258         return EAGAIN;
3259     }
3260
3261     *devnamep = sset_pop(&ofproto->port_poll_set);
3262     return 0;
3263 }
3264
3265 static void
3266 port_poll_wait(const struct ofproto *ofproto_)
3267 {
3268     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3269     dpif_port_poll_wait(ofproto->backer->dpif);
3270 }
3271
3272 static int
3273 port_is_lacp_current(const struct ofport *ofport_)
3274 {
3275     const struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
3276     return (ofport->bundle && ofport->bundle->lacp
3277             ? lacp_slave_is_current(ofport->bundle->lacp, ofport)
3278             : -1);
3279 }
3280 \f
3281 /* Upcall handling. */
3282
3283 /* Flow miss batching.
3284  *
3285  * Some dpifs implement operations faster when you hand them off in a batch.
3286  * To allow batching, "struct flow_miss" queues the dpif-related work needed
3287  * for a given flow.  Each "struct flow_miss" corresponds to sending one or
3288  * more packets, plus possibly installing the flow in the dpif.
3289  *
3290  * So far we only batch the operations that affect flow setup time the most.
3291  * It's possible to batch more than that, but the benefit might be minimal. */
3292 struct flow_miss {
3293     struct hmap_node hmap_node;
3294     struct ofproto_dpif *ofproto;
3295     struct flow flow;
3296     enum odp_key_fitness key_fitness;
3297     const struct nlattr *key;
3298     size_t key_len;
3299     ovs_be16 initial_tci;
3300     struct list packets;
3301     enum dpif_upcall_type upcall_type;
3302     uint32_t odp_in_port;
3303 };
3304
3305 struct flow_miss_op {
3306     struct dpif_op dpif_op;
3307     struct subfacet *subfacet;  /* Subfacet  */
3308     void *garbage;              /* Pointer to pass to free(), NULL if none. */
3309     uint64_t stub[1024 / 8];    /* Temporary buffer. */
3310 };
3311
3312 /* Sends an OFPT_PACKET_IN message for 'packet' of type OFPR_NO_MATCH to each
3313  * OpenFlow controller as necessary according to their individual
3314  * configurations. */
3315 static void
3316 send_packet_in_miss(struct ofproto_dpif *ofproto, const struct ofpbuf *packet,
3317                     const struct flow *flow)
3318 {
3319     struct ofputil_packet_in pin;
3320
3321     pin.packet = packet->data;
3322     pin.packet_len = packet->size;
3323     pin.reason = OFPR_NO_MATCH;
3324     pin.controller_id = 0;
3325
3326     pin.table_id = 0;
3327     pin.cookie = 0;
3328
3329     pin.send_len = 0;           /* not used for flow table misses */
3330
3331     flow_get_metadata(flow, &pin.fmd);
3332
3333     connmgr_send_packet_in(ofproto->up.connmgr, &pin);
3334 }
3335
3336 static enum slow_path_reason
3337 process_special(struct ofproto_dpif *ofproto, const struct flow *flow,
3338                 const struct ofport_dpif *ofport, const struct ofpbuf *packet)
3339 {
3340     if (!ofport) {
3341         return 0;
3342     } else if (ofport->cfm && cfm_should_process_flow(ofport->cfm, flow)) {
3343         if (packet) {
3344             cfm_process_heartbeat(ofport->cfm, packet);
3345         }
3346         return SLOW_CFM;
3347     } else if (ofport->bundle && ofport->bundle->lacp
3348                && flow->dl_type == htons(ETH_TYPE_LACP)) {
3349         if (packet) {
3350             lacp_process_packet(ofport->bundle->lacp, ofport, packet);
3351         }
3352         return SLOW_LACP;
3353     } else if (ofproto->stp && stp_should_process_flow(flow)) {
3354         if (packet) {
3355             stp_process_packet(ofport, packet);
3356         }
3357         return SLOW_STP;
3358     } else {
3359         return 0;
3360     }
3361 }
3362
3363 static struct flow_miss *
3364 flow_miss_find(struct hmap *todo, const struct ofproto_dpif *ofproto,
3365                const struct flow *flow, uint32_t hash)
3366 {
3367     struct flow_miss *miss;
3368
3369     HMAP_FOR_EACH_WITH_HASH (miss, hmap_node, hash, todo) {
3370         if (miss->ofproto == ofproto && flow_equal(&miss->flow, flow)) {
3371             return miss;
3372         }
3373     }
3374
3375     return NULL;
3376 }
3377
3378 /* Partially Initializes 'op' as an "execute" operation for 'miss' and
3379  * 'packet'.  The caller must initialize op->actions and op->actions_len.  If
3380  * 'miss' is associated with a subfacet the caller must also initialize the
3381  * returned op->subfacet, and if anything needs to be freed after processing
3382  * the op, the caller must initialize op->garbage also. */
3383 static void
3384 init_flow_miss_execute_op(struct flow_miss *miss, struct ofpbuf *packet,
3385                           struct flow_miss_op *op)
3386 {
3387     if (miss->flow.vlan_tci != miss->initial_tci) {
3388         /* This packet was received on a VLAN splinter port.  We
3389          * added a VLAN to the packet to make the packet resemble
3390          * the flow, but the actions were composed assuming that
3391          * the packet contained no VLAN.  So, we must remove the
3392          * VLAN header from the packet before trying to execute the
3393          * actions. */
3394         eth_pop_vlan(packet);
3395     }
3396
3397     op->subfacet = NULL;
3398     op->garbage = NULL;
3399     op->dpif_op.type = DPIF_OP_EXECUTE;
3400     op->dpif_op.u.execute.key = miss->key;
3401     op->dpif_op.u.execute.key_len = miss->key_len;
3402     op->dpif_op.u.execute.packet = packet;
3403 }
3404
3405 /* Helper for handle_flow_miss_without_facet() and
3406  * handle_flow_miss_with_facet(). */
3407 static void
3408 handle_flow_miss_common(struct rule_dpif *rule,
3409                         struct ofpbuf *packet, const struct flow *flow)
3410 {
3411     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
3412
3413     ofproto->n_matches++;
3414
3415     if (rule->up.cr.priority == FAIL_OPEN_PRIORITY) {
3416         /*
3417          * Extra-special case for fail-open mode.
3418          *
3419          * We are in fail-open mode and the packet matched the fail-open
3420          * rule, but we are connected to a controller too.  We should send
3421          * the packet up to the controller in the hope that it will try to
3422          * set up a flow and thereby allow us to exit fail-open.
3423          *
3424          * See the top-level comment in fail-open.c for more information.
3425          */
3426         send_packet_in_miss(ofproto, packet, flow);
3427     }
3428 }
3429
3430 /* Figures out whether a flow that missed in 'ofproto', whose details are in
3431  * 'miss', is likely to be worth tracking in detail in userspace and (usually)
3432  * installing a datapath flow.  The answer is usually "yes" (a return value of
3433  * true).  However, for short flows the cost of bookkeeping is much higher than
3434  * the benefits, so when the datapath holds a large number of flows we impose
3435  * some heuristics to decide which flows are likely to be worth tracking. */
3436 static bool
3437 flow_miss_should_make_facet(struct ofproto_dpif *ofproto,
3438                             struct flow_miss *miss, uint32_t hash)
3439 {
3440     if (!ofproto->governor) {
3441         size_t n_subfacets;
3442
3443         n_subfacets = hmap_count(&ofproto->subfacets);
3444         if (n_subfacets * 2 <= ofproto->up.flow_eviction_threshold) {
3445             return true;
3446         }
3447
3448         ofproto->governor = governor_create(ofproto->up.name);
3449     }
3450
3451     return governor_should_install_flow(ofproto->governor, hash,
3452                                         list_size(&miss->packets));
3453 }
3454
3455 /* Handles 'miss', which matches 'rule', without creating a facet or subfacet
3456  * or creating any datapath flow.  May add an "execute" operation to 'ops' and
3457  * increment '*n_ops'. */
3458 static void
3459 handle_flow_miss_without_facet(struct flow_miss *miss,
3460                                struct rule_dpif *rule,
3461                                struct flow_miss_op *ops, size_t *n_ops)
3462 {
3463     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
3464     long long int now = time_msec();
3465     struct action_xlate_ctx ctx;
3466     struct ofpbuf *packet;
3467
3468     LIST_FOR_EACH (packet, list_node, &miss->packets) {
3469         struct flow_miss_op *op = &ops[*n_ops];
3470         struct dpif_flow_stats stats;
3471         struct ofpbuf odp_actions;
3472
3473         COVERAGE_INC(facet_suppress);
3474
3475         ofpbuf_use_stub(&odp_actions, op->stub, sizeof op->stub);
3476
3477         dpif_flow_stats_extract(&miss->flow, packet, now, &stats);
3478         rule_credit_stats(rule, &stats);
3479
3480         action_xlate_ctx_init(&ctx, ofproto, &miss->flow, miss->initial_tci,
3481                               rule, 0, packet);
3482         ctx.resubmit_stats = &stats;
3483         xlate_actions(&ctx, rule->up.ofpacts, rule->up.ofpacts_len,
3484                       &odp_actions);
3485
3486         if (odp_actions.size) {
3487             struct dpif_execute *execute = &op->dpif_op.u.execute;
3488
3489             init_flow_miss_execute_op(miss, packet, op);
3490             execute->actions = odp_actions.data;
3491             execute->actions_len = odp_actions.size;
3492             op->garbage = ofpbuf_get_uninit_pointer(&odp_actions);
3493
3494             (*n_ops)++;
3495         } else {
3496             ofpbuf_uninit(&odp_actions);
3497         }
3498     }
3499 }
3500
3501 /* Handles 'miss', which matches 'facet'.  May add any required datapath
3502  * operations to 'ops', incrementing '*n_ops' for each new op.
3503  *
3504  * All of the packets in 'miss' are considered to have arrived at time 'now'.
3505  * This is really important only for new facets: if we just called time_msec()
3506  * here, then the new subfacet or its packets could look (occasionally) as
3507  * though it was used some time after the facet was used.  That can make a
3508  * one-packet flow look like it has a nonzero duration, which looks odd in
3509  * e.g. NetFlow statistics. */
3510 static void
3511 handle_flow_miss_with_facet(struct flow_miss *miss, struct facet *facet,
3512                             long long int now,
3513                             struct flow_miss_op *ops, size_t *n_ops)
3514 {
3515     struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
3516     enum subfacet_path want_path;
3517     struct subfacet *subfacet;
3518     struct ofpbuf *packet;
3519
3520     subfacet = subfacet_create(facet, miss, now);
3521
3522     LIST_FOR_EACH (packet, list_node, &miss->packets) {
3523         struct flow_miss_op *op = &ops[*n_ops];
3524         struct dpif_flow_stats stats;
3525         struct ofpbuf odp_actions;
3526
3527         handle_flow_miss_common(facet->rule, packet, &miss->flow);
3528
3529         ofpbuf_use_stub(&odp_actions, op->stub, sizeof op->stub);
3530         if (!subfacet->actions || subfacet->slow) {
3531             subfacet_make_actions(subfacet, packet, &odp_actions);
3532         }
3533
3534         dpif_flow_stats_extract(&facet->flow, packet, now, &stats);
3535         subfacet_update_stats(subfacet, &stats);
3536
3537         if (subfacet->actions_len) {
3538             struct dpif_execute *execute = &op->dpif_op.u.execute;
3539
3540             init_flow_miss_execute_op(miss, packet, op);
3541             op->subfacet = subfacet;
3542             if (!subfacet->slow) {
3543                 execute->actions = subfacet->actions;
3544                 execute->actions_len = subfacet->actions_len;
3545                 ofpbuf_uninit(&odp_actions);
3546             } else {
3547                 execute->actions = odp_actions.data;
3548                 execute->actions_len = odp_actions.size;
3549                 op->garbage = ofpbuf_get_uninit_pointer(&odp_actions);
3550             }
3551
3552             (*n_ops)++;
3553         } else {
3554             ofpbuf_uninit(&odp_actions);
3555         }
3556     }
3557
3558     want_path = subfacet_want_path(subfacet->slow);
3559     if (miss->upcall_type == DPIF_UC_MISS || subfacet->path != want_path) {
3560         struct flow_miss_op *op = &ops[(*n_ops)++];
3561         struct dpif_flow_put *put = &op->dpif_op.u.flow_put;
3562
3563         op->subfacet = subfacet;
3564         op->garbage = NULL;
3565         op->dpif_op.type = DPIF_OP_FLOW_PUT;
3566         put->flags = DPIF_FP_CREATE | DPIF_FP_MODIFY;
3567         put->key = miss->key;
3568         put->key_len = miss->key_len;
3569         if (want_path == SF_FAST_PATH) {
3570             put->actions = subfacet->actions;
3571             put->actions_len = subfacet->actions_len;
3572         } else {
3573             compose_slow_path(ofproto, &facet->flow, subfacet->slow,
3574                               op->stub, sizeof op->stub,
3575                               &put->actions, &put->actions_len);
3576         }
3577         put->stats = NULL;
3578     }
3579 }
3580
3581 /* Handles flow miss 'miss'.  May add any required datapath operations
3582  * to 'ops', incrementing '*n_ops' for each new op. */
3583 static void
3584 handle_flow_miss(struct flow_miss *miss, struct flow_miss_op *ops,
3585                  size_t *n_ops)
3586 {
3587     struct ofproto_dpif *ofproto = miss->ofproto;
3588     struct facet *facet;
3589     long long int now;
3590     uint32_t hash;
3591
3592     /* The caller must ensure that miss->hmap_node.hash contains
3593      * flow_hash(miss->flow, 0). */
3594     hash = miss->hmap_node.hash;
3595
3596     facet = facet_lookup_valid(ofproto, &miss->flow, hash);
3597     if (!facet) {
3598         struct rule_dpif *rule = rule_dpif_lookup(ofproto, &miss->flow);
3599
3600         if (!flow_miss_should_make_facet(ofproto, miss, hash)) {
3601             handle_flow_miss_without_facet(miss, rule, ops, n_ops);
3602             return;
3603         }
3604
3605         facet = facet_create(rule, &miss->flow, hash);
3606         now = facet->used;
3607     } else {
3608         now = time_msec();
3609     }
3610     handle_flow_miss_with_facet(miss, facet, now, ops, n_ops);
3611 }
3612
3613 static struct drop_key *
3614 drop_key_lookup(const struct dpif_backer *backer, const struct nlattr *key,
3615                 size_t key_len)
3616 {
3617     struct drop_key *drop_key;
3618
3619     HMAP_FOR_EACH_WITH_HASH (drop_key, hmap_node, hash_bytes(key, key_len, 0),
3620                              &backer->drop_keys) {
3621         if (drop_key->key_len == key_len
3622             && !memcmp(drop_key->key, key, key_len)) {
3623             return drop_key;
3624         }
3625     }
3626     return NULL;
3627 }
3628
3629 static void
3630 drop_key_clear(struct dpif_backer *backer)
3631 {
3632     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 15);
3633     struct drop_key *drop_key, *next;
3634
3635     HMAP_FOR_EACH_SAFE (drop_key, next, hmap_node, &backer->drop_keys) {
3636         int error;
3637
3638         error = dpif_flow_del(backer->dpif, drop_key->key, drop_key->key_len,
3639                               NULL);
3640         if (error && !VLOG_DROP_WARN(&rl)) {
3641             struct ds ds = DS_EMPTY_INITIALIZER;
3642             odp_flow_key_format(drop_key->key, drop_key->key_len, &ds);
3643             VLOG_WARN("Failed to delete drop key (%s) (%s)", strerror(error),
3644                       ds_cstr(&ds));
3645             ds_destroy(&ds);
3646         }
3647
3648         hmap_remove(&backer->drop_keys, &drop_key->hmap_node);
3649         free(drop_key->key);
3650         free(drop_key);
3651     }
3652 }
3653
3654 /* Given a datpath, packet, and flow metadata ('backer', 'packet', and 'key'
3655  * respectively), populates 'flow' with the result of odp_flow_key_to_flow().
3656  * Optionally, if nonnull, populates 'fitnessp' with the fitness of 'flow' as
3657  * returned by odp_flow_key_to_flow().  Also, optionally populates 'ofproto'
3658  * with the ofproto_dpif, and 'odp_in_port' with the datapath in_port, that
3659  * 'packet' ingressed.
3660  *
3661  * If 'ofproto' is nonnull, requires 'flow''s in_port to exist.  Otherwise sets
3662  * 'flow''s in_port to OFPP_NONE.
3663  *
3664  * This function does post-processing on data returned from
3665  * odp_flow_key_to_flow() to help make VLAN splinters transparent to the rest
3666  * of the upcall processing logic.  In particular, if the extracted in_port is
3667  * a VLAN splinter port, it replaces flow->in_port by the "real" port, sets
3668  * flow->vlan_tci correctly for the VLAN of the VLAN splinter port, and pushes
3669  * a VLAN header onto 'packet' (if it is nonnull).
3670  *
3671  * Optionally, if nonnull, sets '*initial_tci' to the VLAN TCI with which the
3672  * packet was really received, that is, the actual VLAN TCI extracted by
3673  * odp_flow_key_to_flow().  (This differs from the value returned in
3674  * flow->vlan_tci only for packets received on VLAN splinters.)
3675  *
3676  * Similarly, this function also includes some logic to help with tunnels.  It
3677  * may modify 'flow' as necessary to make the tunneling implementation
3678  * transparent to the upcall processing logic.
3679  *
3680  * Returns 0 if successful, ENODEV if the parsed flow has no associated ofport,
3681  * or some other positive errno if there are other problems. */
3682 static int
3683 ofproto_receive(const struct dpif_backer *backer, struct ofpbuf *packet,
3684                 const struct nlattr *key, size_t key_len,
3685                 struct flow *flow, enum odp_key_fitness *fitnessp,
3686                 struct ofproto_dpif **ofproto, uint32_t *odp_in_port,
3687                 ovs_be16 *initial_tci)
3688 {
3689     const struct ofport_dpif *port;
3690     enum odp_key_fitness fitness;
3691     int error = ENODEV;
3692
3693     fitness = odp_flow_key_to_flow(key, key_len, flow);
3694     if (fitness == ODP_FIT_ERROR) {
3695         error = EINVAL;
3696         goto exit;
3697     }
3698
3699     if (initial_tci) {
3700         *initial_tci = flow->vlan_tci;
3701     }
3702
3703     if (odp_in_port) {
3704         *odp_in_port = flow->in_port;
3705     }
3706
3707     if (tnl_port_should_receive(flow)) {
3708         const struct ofport *ofport = tnl_port_receive(flow);
3709         if (!ofport) {
3710             flow->in_port = OFPP_NONE;
3711             goto exit;
3712         }
3713         port = ofport_dpif_cast(ofport);
3714
3715         /* We can't reproduce 'key' from 'flow'. */
3716         fitness = fitness == ODP_FIT_PERFECT ? ODP_FIT_TOO_MUCH : fitness;
3717
3718         /* XXX: Since the tunnel module is not scoped per backer, it's
3719          * theoretically possible that we'll receive an ofport belonging to an
3720          * entirely different datapath.  In practice, this can't happen because
3721          * no platforms has two separate datapaths which each support
3722          * tunneling. */
3723         ovs_assert(ofproto_dpif_cast(port->up.ofproto)->backer == backer);
3724     } else {
3725         port = odp_port_to_ofport(backer, flow->in_port);
3726         if (!port) {
3727             flow->in_port = OFPP_NONE;
3728             goto exit;
3729         }
3730
3731         flow->in_port = port->up.ofp_port;
3732         if (vsp_adjust_flow(ofproto_dpif_cast(port->up.ofproto), flow)) {
3733             if (packet) {
3734                 /* Make the packet resemble the flow, so that it gets sent to
3735                  * an OpenFlow controller properly, so that it looks correct
3736                  * for sFlow, and so that flow_extract() will get the correct
3737                  * vlan_tci if it is called on 'packet'.
3738                  *
3739                  * The allocated space inside 'packet' probably also contains
3740                  * 'key', that is, both 'packet' and 'key' are probably part of
3741                  * a struct dpif_upcall (see the large comment on that
3742                  * structure definition), so pushing data on 'packet' is in
3743                  * general not a good idea since it could overwrite 'key' or
3744                  * free it as a side effect.  However, it's OK in this special
3745                  * case because we know that 'packet' is inside a Netlink
3746                  * attribute: pushing 4 bytes will just overwrite the 4-byte
3747                  * "struct nlattr", which is fine since we don't need that
3748                  * header anymore. */
3749                 eth_push_vlan(packet, flow->vlan_tci);
3750             }
3751             /* We can't reproduce 'key' from 'flow'. */
3752             fitness = fitness == ODP_FIT_PERFECT ? ODP_FIT_TOO_MUCH : fitness;
3753         }
3754     }
3755     error = 0;
3756
3757     if (ofproto) {
3758         *ofproto = ofproto_dpif_cast(port->up.ofproto);
3759     }
3760
3761 exit:
3762     if (fitnessp) {
3763         *fitnessp = fitness;
3764     }
3765     return error;
3766 }
3767
3768 static void
3769 handle_miss_upcalls(struct dpif_backer *backer, struct dpif_upcall *upcalls,
3770                     size_t n_upcalls)
3771 {
3772     struct dpif_upcall *upcall;
3773     struct flow_miss *miss;
3774     struct flow_miss misses[FLOW_MISS_MAX_BATCH];
3775     struct flow_miss_op flow_miss_ops[FLOW_MISS_MAX_BATCH * 2];
3776     struct dpif_op *dpif_ops[FLOW_MISS_MAX_BATCH * 2];
3777     struct hmap todo;
3778     int n_misses;
3779     size_t n_ops;
3780     size_t i;
3781
3782     if (!n_upcalls) {
3783         return;
3784     }
3785
3786     /* Construct the to-do list.
3787      *
3788      * This just amounts to extracting the flow from each packet and sticking
3789      * the packets that have the same flow in the same "flow_miss" structure so
3790      * that we can process them together. */
3791     hmap_init(&todo);
3792     n_misses = 0;
3793     for (upcall = upcalls; upcall < &upcalls[n_upcalls]; upcall++) {
3794         struct flow_miss *miss = &misses[n_misses];
3795         struct flow_miss *existing_miss;
3796         struct ofproto_dpif *ofproto;
3797         uint32_t odp_in_port;
3798         struct flow flow;
3799         uint32_t hash;
3800         int error;
3801
3802         error = ofproto_receive(backer, upcall->packet, upcall->key,
3803                                 upcall->key_len, &flow, &miss->key_fitness,
3804                                 &ofproto, &odp_in_port, &miss->initial_tci);
3805         if (error == ENODEV) {
3806             struct drop_key *drop_key;
3807
3808             /* Received packet on port for which we couldn't associate
3809              * an ofproto.  This can happen if a port is removed while
3810              * traffic is being received.  Print a rate-limited message
3811              * in case it happens frequently.  Install a drop flow so
3812              * that future packets of the flow are inexpensively dropped
3813              * in the kernel. */
3814             VLOG_INFO_RL(&rl, "received packet on unassociated port %"PRIu32,
3815                          flow.in_port);
3816
3817             drop_key = drop_key_lookup(backer, upcall->key, upcall->key_len);
3818             if (!drop_key) {
3819                 drop_key = xmalloc(sizeof *drop_key);
3820                 drop_key->key = xmemdup(upcall->key, upcall->key_len);
3821                 drop_key->key_len = upcall->key_len;
3822
3823                 hmap_insert(&backer->drop_keys, &drop_key->hmap_node,
3824                             hash_bytes(drop_key->key, drop_key->key_len, 0));
3825                 dpif_flow_put(backer->dpif, DPIF_FP_CREATE | DPIF_FP_MODIFY,
3826                               drop_key->key, drop_key->key_len, NULL, 0, NULL);
3827             }
3828             continue;
3829         }
3830         if (error) {
3831             continue;
3832         }
3833         flow_extract(upcall->packet, flow.skb_priority, flow.skb_mark,
3834                      &flow.tunnel, flow.in_port, &miss->flow);
3835
3836         /* Add other packets to a to-do list. */
3837         hash = flow_hash(&miss->flow, 0);
3838         existing_miss = flow_miss_find(&todo, ofproto, &miss->flow, hash);
3839         if (!existing_miss) {
3840             hmap_insert(&todo, &miss->hmap_node, hash);
3841             miss->ofproto = ofproto;
3842             miss->key = upcall->key;
3843             miss->key_len = upcall->key_len;
3844             miss->upcall_type = upcall->type;
3845             miss->odp_in_port = odp_in_port;
3846             list_init(&miss->packets);
3847
3848             n_misses++;
3849         } else {
3850             miss = existing_miss;
3851         }
3852         list_push_back(&miss->packets, &upcall->packet->list_node);
3853     }
3854
3855     /* Process each element in the to-do list, constructing the set of
3856      * operations to batch. */
3857     n_ops = 0;
3858     HMAP_FOR_EACH (miss, hmap_node, &todo) {
3859         handle_flow_miss(miss, flow_miss_ops, &n_ops);
3860     }
3861     ovs_assert(n_ops <= ARRAY_SIZE(flow_miss_ops));
3862
3863     /* Execute batch. */
3864     for (i = 0; i < n_ops; i++) {
3865         dpif_ops[i] = &flow_miss_ops[i].dpif_op;
3866     }
3867     dpif_operate(backer->dpif, dpif_ops, n_ops);
3868
3869     /* Free memory and update facets. */
3870     for (i = 0; i < n_ops; i++) {
3871         struct flow_miss_op *op = &flow_miss_ops[i];
3872
3873         switch (op->dpif_op.type) {
3874         case DPIF_OP_EXECUTE:
3875             break;
3876
3877         case DPIF_OP_FLOW_PUT:
3878             if (!op->dpif_op.error) {
3879                 op->subfacet->path = subfacet_want_path(op->subfacet->slow);
3880             }
3881             break;
3882
3883         case DPIF_OP_FLOW_DEL:
3884             NOT_REACHED();
3885         }
3886
3887         free(op->garbage);
3888     }
3889     hmap_destroy(&todo);
3890 }
3891
3892 static enum { SFLOW_UPCALL, MISS_UPCALL, BAD_UPCALL }
3893 classify_upcall(const struct dpif_upcall *upcall)
3894 {
3895     union user_action_cookie cookie;
3896
3897     /* First look at the upcall type. */
3898     switch (upcall->type) {
3899     case DPIF_UC_ACTION:
3900         break;
3901
3902     case DPIF_UC_MISS:
3903         return MISS_UPCALL;
3904
3905     case DPIF_N_UC_TYPES:
3906     default:
3907         VLOG_WARN_RL(&rl, "upcall has unexpected type %"PRIu32, upcall->type);
3908         return BAD_UPCALL;
3909     }
3910
3911     /* "action" upcalls need a closer look. */
3912     memcpy(&cookie, &upcall->userdata, sizeof(cookie));
3913     switch (cookie.type) {
3914     case USER_ACTION_COOKIE_SFLOW:
3915         return SFLOW_UPCALL;
3916
3917     case USER_ACTION_COOKIE_SLOW_PATH:
3918         return MISS_UPCALL;
3919
3920     case USER_ACTION_COOKIE_UNSPEC:
3921     default:
3922         VLOG_WARN_RL(&rl, "invalid user cookie : 0x%"PRIx64, upcall->userdata);
3923         return BAD_UPCALL;
3924     }
3925 }
3926
3927 static void
3928 handle_sflow_upcall(struct dpif_backer *backer,
3929                     const struct dpif_upcall *upcall)
3930 {
3931     struct ofproto_dpif *ofproto;
3932     union user_action_cookie cookie;
3933     struct flow flow;
3934     uint32_t odp_in_port;
3935
3936     if (ofproto_receive(backer, upcall->packet, upcall->key, upcall->key_len,
3937                         &flow, NULL, &ofproto, &odp_in_port, NULL)
3938         || !ofproto->sflow) {
3939         return;
3940     }
3941
3942     memcpy(&cookie, &upcall->userdata, sizeof(cookie));
3943     dpif_sflow_received(ofproto->sflow, upcall->packet, &flow,
3944                         odp_in_port, &cookie);
3945 }
3946
3947 static int
3948 handle_upcalls(struct dpif_backer *backer, unsigned int max_batch)
3949 {
3950     struct dpif_upcall misses[FLOW_MISS_MAX_BATCH];
3951     struct ofpbuf miss_bufs[FLOW_MISS_MAX_BATCH];
3952     uint64_t miss_buf_stubs[FLOW_MISS_MAX_BATCH][4096 / 8];
3953     int n_processed;
3954     int n_misses;
3955     int i;
3956
3957     ovs_assert(max_batch <= FLOW_MISS_MAX_BATCH);
3958
3959     n_misses = 0;
3960     for (n_processed = 0; n_processed < max_batch; n_processed++) {
3961         struct dpif_upcall *upcall = &misses[n_misses];
3962         struct ofpbuf *buf = &miss_bufs[n_misses];
3963         int error;
3964
3965         ofpbuf_use_stub(buf, miss_buf_stubs[n_misses],
3966                         sizeof miss_buf_stubs[n_misses]);
3967         error = dpif_recv(backer->dpif, upcall, buf);
3968         if (error) {
3969             ofpbuf_uninit(buf);
3970             break;
3971         }
3972
3973         switch (classify_upcall(upcall)) {
3974         case MISS_UPCALL:
3975             /* Handle it later. */
3976             n_misses++;
3977             break;
3978
3979         case SFLOW_UPCALL:
3980             handle_sflow_upcall(backer, upcall);
3981             ofpbuf_uninit(buf);
3982             break;
3983
3984         case BAD_UPCALL:
3985             ofpbuf_uninit(buf);
3986             break;
3987         }
3988     }
3989
3990     /* Handle deferred MISS_UPCALL processing. */
3991     handle_miss_upcalls(backer, misses, n_misses);
3992     for (i = 0; i < n_misses; i++) {
3993         ofpbuf_uninit(&miss_bufs[i]);
3994     }
3995
3996     return n_processed;
3997 }
3998 \f
3999 /* Flow expiration. */
4000
4001 static int subfacet_max_idle(const struct ofproto_dpif *);
4002 static void update_stats(struct dpif_backer *);
4003 static void rule_expire(struct rule_dpif *);
4004 static void expire_subfacets(struct ofproto_dpif *, int dp_max_idle);
4005
4006 /* This function is called periodically by run().  Its job is to collect
4007  * updates for the flows that have been installed into the datapath, most
4008  * importantly when they last were used, and then use that information to
4009  * expire flows that have not been used recently.
4010  *
4011  * Returns the number of milliseconds after which it should be called again. */
4012 static int
4013 expire(struct dpif_backer *backer)
4014 {
4015     struct ofproto_dpif *ofproto;
4016     int max_idle = INT32_MAX;
4017
4018     /* Periodically clear out the drop keys in an effort to keep them
4019      * relatively few. */
4020     drop_key_clear(backer);
4021
4022     /* Update stats for each flow in the backer. */
4023     update_stats(backer);
4024
4025     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
4026         struct rule *rule, *next_rule;
4027         int dp_max_idle;
4028
4029         if (ofproto->backer != backer) {
4030             continue;
4031         }
4032
4033         /* Expire subfacets that have been idle too long. */
4034         dp_max_idle = subfacet_max_idle(ofproto);
4035         expire_subfacets(ofproto, dp_max_idle);
4036
4037         max_idle = MIN(max_idle, dp_max_idle);
4038
4039         /* Expire OpenFlow flows whose idle_timeout or hard_timeout
4040          * has passed. */
4041         LIST_FOR_EACH_SAFE (rule, next_rule, expirable,
4042                             &ofproto->up.expirable) {
4043             rule_expire(rule_dpif_cast(rule));
4044         }
4045
4046         /* All outstanding data in existing flows has been accounted, so it's a
4047          * good time to do bond rebalancing. */
4048         if (ofproto->has_bonded_bundles) {
4049             struct ofbundle *bundle;
4050
4051             HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
4052                 if (bundle->bond) {
4053                     bond_rebalance(bundle->bond, &backer->revalidate_set);
4054                 }
4055             }
4056         }
4057     }
4058
4059     return MIN(max_idle, 1000);
4060 }
4061
4062 /* Updates flow table statistics given that the datapath just reported 'stats'
4063  * as 'subfacet''s statistics. */
4064 static void
4065 update_subfacet_stats(struct subfacet *subfacet,
4066                       const struct dpif_flow_stats *stats)
4067 {
4068     struct facet *facet = subfacet->facet;
4069
4070     if (stats->n_packets >= subfacet->dp_packet_count) {
4071         uint64_t extra = stats->n_packets - subfacet->dp_packet_count;
4072         facet->packet_count += extra;
4073     } else {
4074         VLOG_WARN_RL(&rl, "unexpected packet count from the datapath");
4075     }
4076
4077     if (stats->n_bytes >= subfacet->dp_byte_count) {
4078         facet->byte_count += stats->n_bytes - subfacet->dp_byte_count;
4079     } else {
4080         VLOG_WARN_RL(&rl, "unexpected byte count from datapath");
4081     }
4082
4083     subfacet->dp_packet_count = stats->n_packets;
4084     subfacet->dp_byte_count = stats->n_bytes;
4085
4086     facet->tcp_flags |= stats->tcp_flags;
4087
4088     subfacet_update_time(subfacet, stats->used);
4089     if (facet->accounted_bytes < facet->byte_count) {
4090         facet_learn(facet);
4091         facet_account(facet);
4092         facet->accounted_bytes = facet->byte_count;
4093     }
4094     facet_push_stats(facet);
4095 }
4096
4097 /* 'key' with length 'key_len' bytes is a flow in 'dpif' that we know nothing
4098  * about, or a flow that shouldn't be installed but was anyway.  Delete it. */
4099 static void
4100 delete_unexpected_flow(struct ofproto_dpif *ofproto,
4101                        const struct nlattr *key, size_t key_len)
4102 {
4103     if (!VLOG_DROP_WARN(&rl)) {
4104         struct ds s;
4105
4106         ds_init(&s);
4107         odp_flow_key_format(key, key_len, &s);
4108         VLOG_WARN("unexpected flow on %s: %s", ofproto->up.name, ds_cstr(&s));
4109         ds_destroy(&s);
4110     }
4111
4112     COVERAGE_INC(facet_unexpected);
4113     dpif_flow_del(ofproto->backer->dpif, key, key_len, NULL);
4114 }
4115
4116 /* Update 'packet_count', 'byte_count', and 'used' members of installed facets.
4117  *
4118  * This function also pushes statistics updates to rules which each facet
4119  * resubmits into.  Generally these statistics will be accurate.  However, if a
4120  * facet changes the rule it resubmits into at some time in between
4121  * update_stats() runs, it is possible that statistics accrued to the
4122  * old rule will be incorrectly attributed to the new rule.  This could be
4123  * avoided by calling update_stats() whenever rules are created or
4124  * deleted.  However, the performance impact of making so many calls to the
4125  * datapath do not justify the benefit of having perfectly accurate statistics.
4126  */
4127 static void
4128 update_stats(struct dpif_backer *backer)
4129 {
4130     const struct dpif_flow_stats *stats;
4131     struct dpif_flow_dump dump;
4132     const struct nlattr *key;
4133     size_t key_len;
4134
4135     dpif_flow_dump_start(&dump, backer->dpif);
4136     while (dpif_flow_dump_next(&dump, &key, &key_len, NULL, NULL, &stats)) {
4137         struct flow flow;
4138         struct subfacet *subfacet;
4139         struct ofproto_dpif *ofproto;
4140         struct ofport_dpif *ofport;
4141         uint32_t key_hash;
4142
4143         if (ofproto_receive(backer, NULL, key, key_len, &flow, NULL, &ofproto,
4144                             NULL, NULL)) {
4145             continue;
4146         }
4147
4148         ofport = get_ofp_port(ofproto, flow.in_port);
4149         if (ofport && ofport->tnl_port) {
4150             netdev_vport_inc_rx(ofport->up.netdev, stats);
4151         }
4152
4153         key_hash = odp_flow_key_hash(key, key_len);
4154         subfacet = subfacet_find(ofproto, key, key_len, key_hash, &flow);
4155         switch (subfacet ? subfacet->path : SF_NOT_INSTALLED) {
4156         case SF_FAST_PATH:
4157             update_subfacet_stats(subfacet, stats);
4158             break;
4159
4160         case SF_SLOW_PATH:
4161             /* Stats are updated per-packet. */
4162             break;
4163
4164         case SF_NOT_INSTALLED:
4165         default:
4166             delete_unexpected_flow(ofproto, key, key_len);
4167             break;
4168         }
4169     }
4170     dpif_flow_dump_done(&dump);
4171 }
4172
4173 /* Calculates and returns the number of milliseconds of idle time after which
4174  * subfacets should expire from the datapath.  When a subfacet expires, we fold
4175  * its statistics into its facet, and when a facet's last subfacet expires, we
4176  * fold its statistic into its rule. */
4177 static int
4178 subfacet_max_idle(const struct ofproto_dpif *ofproto)
4179 {
4180     /*
4181      * Idle time histogram.
4182      *
4183      * Most of the time a switch has a relatively small number of subfacets.
4184      * When this is the case we might as well keep statistics for all of them
4185      * in userspace and to cache them in the kernel datapath for performance as
4186      * well.
4187      *
4188      * As the number of subfacets increases, the memory required to maintain
4189      * statistics about them in userspace and in the kernel becomes
4190      * significant.  However, with a large number of subfacets it is likely
4191      * that only a few of them are "heavy hitters" that consume a large amount
4192      * of bandwidth.  At this point, only heavy hitters are worth caching in
4193      * the kernel and maintaining in userspaces; other subfacets we can
4194      * discard.
4195      *
4196      * The technique used to compute the idle time is to build a histogram with
4197      * N_BUCKETS buckets whose width is BUCKET_WIDTH msecs each.  Each subfacet
4198      * that is installed in the kernel gets dropped in the appropriate bucket.
4199      * After the histogram has been built, we compute the cutoff so that only
4200      * the most-recently-used 1% of subfacets (but at least
4201      * ofproto->up.flow_eviction_threshold flows) are kept cached.  At least
4202      * the most-recently-used bucket of subfacets is kept, so actually an
4203      * arbitrary number of subfacets can be kept in any given expiration run
4204      * (though the next run will delete most of those unless they receive
4205      * additional data).
4206      *
4207      * This requires a second pass through the subfacets, in addition to the
4208      * pass made by update_stats(), because the former function never looks at
4209      * uninstallable subfacets.
4210      */
4211     enum { BUCKET_WIDTH = ROUND_UP(100, TIME_UPDATE_INTERVAL) };
4212     enum { N_BUCKETS = 5000 / BUCKET_WIDTH };
4213     int buckets[N_BUCKETS] = { 0 };
4214     int total, subtotal, bucket;
4215     struct subfacet *subfacet;
4216     long long int now;
4217     int i;
4218
4219     total = hmap_count(&ofproto->subfacets);
4220     if (total <= ofproto->up.flow_eviction_threshold) {
4221         return N_BUCKETS * BUCKET_WIDTH;
4222     }
4223
4224     /* Build histogram. */
4225     now = time_msec();
4226     HMAP_FOR_EACH (subfacet, hmap_node, &ofproto->subfacets) {
4227         long long int idle = now - subfacet->used;
4228         int bucket = (idle <= 0 ? 0
4229                       : idle >= BUCKET_WIDTH * N_BUCKETS ? N_BUCKETS - 1
4230                       : (unsigned int) idle / BUCKET_WIDTH);
4231         buckets[bucket]++;
4232     }
4233
4234     /* Find the first bucket whose flows should be expired. */
4235     subtotal = bucket = 0;
4236     do {
4237         subtotal += buckets[bucket++];
4238     } while (bucket < N_BUCKETS &&
4239              subtotal < MAX(ofproto->up.flow_eviction_threshold, total / 100));
4240
4241     if (VLOG_IS_DBG_ENABLED()) {
4242         struct ds s;
4243
4244         ds_init(&s);
4245         ds_put_cstr(&s, "keep");
4246         for (i = 0; i < N_BUCKETS; i++) {
4247             if (i == bucket) {
4248                 ds_put_cstr(&s, ", drop");
4249             }
4250             if (buckets[i]) {
4251                 ds_put_format(&s, " %d:%d", i * BUCKET_WIDTH, buckets[i]);
4252             }
4253         }
4254         VLOG_INFO("%s: %s (msec:count)", ofproto->up.name, ds_cstr(&s));
4255         ds_destroy(&s);
4256     }
4257
4258     return bucket * BUCKET_WIDTH;
4259 }
4260
4261 static void
4262 expire_subfacets(struct ofproto_dpif *ofproto, int dp_max_idle)
4263 {
4264     /* Cutoff time for most flows. */
4265     long long int normal_cutoff = time_msec() - dp_max_idle;
4266
4267     /* We really want to keep flows for special protocols around, so use a more
4268      * conservative cutoff. */
4269     long long int special_cutoff = time_msec() - 10000;
4270
4271     struct subfacet *subfacet, *next_subfacet;
4272     struct subfacet *batch[SUBFACET_DESTROY_MAX_BATCH];
4273     int n_batch;
4274
4275     n_batch = 0;
4276     HMAP_FOR_EACH_SAFE (subfacet, next_subfacet, hmap_node,
4277                         &ofproto->subfacets) {
4278         long long int cutoff;
4279
4280         cutoff = (subfacet->slow & (SLOW_CFM | SLOW_LACP | SLOW_STP)
4281                   ? special_cutoff
4282                   : normal_cutoff);
4283         if (subfacet->used < cutoff) {
4284             if (subfacet->path != SF_NOT_INSTALLED) {
4285                 batch[n_batch++] = subfacet;
4286                 if (n_batch >= SUBFACET_DESTROY_MAX_BATCH) {
4287                     subfacet_destroy_batch(ofproto, batch, n_batch);
4288                     n_batch = 0;
4289                 }
4290             } else {
4291                 subfacet_destroy(subfacet);
4292             }
4293         }
4294     }
4295
4296     if (n_batch > 0) {
4297         subfacet_destroy_batch(ofproto, batch, n_batch);
4298     }
4299 }
4300
4301 /* If 'rule' is an OpenFlow rule, that has expired according to OpenFlow rules,
4302  * then delete it entirely. */
4303 static void
4304 rule_expire(struct rule_dpif *rule)
4305 {
4306     struct facet *facet, *next_facet;
4307     long long int now;
4308     uint8_t reason;
4309
4310     if (rule->up.pending) {
4311         /* We'll have to expire it later. */
4312         return;
4313     }
4314
4315     /* Has 'rule' expired? */
4316     now = time_msec();
4317     if (rule->up.hard_timeout
4318         && now > rule->up.modified + rule->up.hard_timeout * 1000) {
4319         reason = OFPRR_HARD_TIMEOUT;
4320     } else if (rule->up.idle_timeout
4321                && now > rule->up.used + rule->up.idle_timeout * 1000) {
4322         reason = OFPRR_IDLE_TIMEOUT;
4323     } else {
4324         return;
4325     }
4326
4327     COVERAGE_INC(ofproto_dpif_expired);
4328
4329     /* Update stats.  (This is a no-op if the rule expired due to an idle
4330      * timeout, because that only happens when the rule has no facets left.) */
4331     LIST_FOR_EACH_SAFE (facet, next_facet, list_node, &rule->facets) {
4332         facet_remove(facet);
4333     }
4334
4335     /* Get rid of the rule. */
4336     ofproto_rule_expire(&rule->up, reason);
4337 }
4338 \f
4339 /* Facets. */
4340
4341 /* Creates and returns a new facet owned by 'rule', given a 'flow'.
4342  *
4343  * The caller must already have determined that no facet with an identical
4344  * 'flow' exists in 'ofproto' and that 'flow' is the best match for 'rule' in
4345  * the ofproto's classifier table.
4346  *
4347  * 'hash' must be the return value of flow_hash(flow, 0).
4348  *
4349  * The facet will initially have no subfacets.  The caller should create (at
4350  * least) one subfacet with subfacet_create(). */
4351 static struct facet *
4352 facet_create(struct rule_dpif *rule, const struct flow *flow, uint32_t hash)
4353 {
4354     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
4355     struct facet *facet;
4356
4357     facet = xzalloc(sizeof *facet);
4358     facet->used = time_msec();
4359     hmap_insert(&ofproto->facets, &facet->hmap_node, hash);
4360     list_push_back(&rule->facets, &facet->list_node);
4361     facet->rule = rule;
4362     facet->flow = *flow;
4363     list_init(&facet->subfacets);
4364     netflow_flow_init(&facet->nf_flow);
4365     netflow_flow_update_time(ofproto->netflow, &facet->nf_flow, facet->used);
4366
4367     return facet;
4368 }
4369
4370 static void
4371 facet_free(struct facet *facet)
4372 {
4373     free(facet);
4374 }
4375
4376 /* Executes, within 'ofproto', the 'n_actions' actions in 'actions' on
4377  * 'packet', which arrived on 'in_port'. */
4378 static bool
4379 execute_odp_actions(struct ofproto_dpif *ofproto, const struct flow *flow,
4380                     const struct nlattr *odp_actions, size_t actions_len,
4381                     struct ofpbuf *packet)
4382 {
4383     struct odputil_keybuf keybuf;
4384     struct ofpbuf key;
4385     int error;
4386
4387     ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
4388     odp_flow_key_from_flow(&key, flow,
4389                            ofp_port_to_odp_port(ofproto, flow->in_port));
4390
4391     error = dpif_execute(ofproto->backer->dpif, key.data, key.size,
4392                          odp_actions, actions_len, packet);
4393     return !error;
4394 }
4395
4396 /* Remove 'facet' from 'ofproto' and free up the associated memory:
4397  *
4398  *   - If 'facet' was installed in the datapath, uninstalls it and updates its
4399  *     rule's statistics, via subfacet_uninstall().
4400  *
4401  *   - Removes 'facet' from its rule and from ofproto->facets.
4402  */
4403 static void
4404 facet_remove(struct facet *facet)
4405 {
4406     struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
4407     struct subfacet *subfacet, *next_subfacet;
4408
4409     ovs_assert(!list_is_empty(&facet->subfacets));
4410
4411     /* First uninstall all of the subfacets to get final statistics. */
4412     LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
4413         subfacet_uninstall(subfacet);
4414     }
4415
4416     /* Flush the final stats to the rule.
4417      *
4418      * This might require us to have at least one subfacet around so that we
4419      * can use its actions for accounting in facet_account(), which is why we
4420      * have uninstalled but not yet destroyed the subfacets. */
4421     facet_flush_stats(facet);
4422
4423     /* Now we're really all done so destroy everything. */
4424     LIST_FOR_EACH_SAFE (subfacet, next_subfacet, list_node,
4425                         &facet->subfacets) {
4426         subfacet_destroy__(subfacet);
4427     }
4428     hmap_remove(&ofproto->facets, &facet->hmap_node);
4429     list_remove(&facet->list_node);
4430     facet_free(facet);
4431 }
4432
4433 /* Feed information from 'facet' back into the learning table to keep it in
4434  * sync with what is actually flowing through the datapath. */
4435 static void
4436 facet_learn(struct facet *facet)
4437 {
4438     struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
4439     struct action_xlate_ctx ctx;
4440
4441     if (!facet->has_learn
4442         && !facet->has_normal
4443         && (!facet->has_fin_timeout
4444             || !(facet->tcp_flags & (TCP_FIN | TCP_RST)))) {
4445         return;
4446     }
4447
4448     action_xlate_ctx_init(&ctx, ofproto, &facet->flow,
4449                           facet->flow.vlan_tci,
4450                           facet->rule, facet->tcp_flags, NULL);
4451     ctx.may_learn = true;
4452     xlate_actions_for_side_effects(&ctx, facet->rule->up.ofpacts,
4453                                    facet->rule->up.ofpacts_len);
4454 }
4455
4456 static void
4457 facet_account(struct facet *facet)
4458 {
4459     struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
4460     struct subfacet *subfacet;
4461     const struct nlattr *a;
4462     unsigned int left;
4463     ovs_be16 vlan_tci;
4464     uint64_t n_bytes;
4465
4466     if (!facet->has_normal || !ofproto->has_bonded_bundles) {
4467         return;
4468     }
4469     n_bytes = facet->byte_count - facet->accounted_bytes;
4470
4471     /* This loop feeds byte counters to bond_account() for rebalancing to use
4472      * as a basis.  We also need to track the actual VLAN on which the packet
4473      * is going to be sent to ensure that it matches the one passed to
4474      * bond_choose_output_slave().  (Otherwise, we will account to the wrong
4475      * hash bucket.)
4476      *
4477      * We use the actions from an arbitrary subfacet because they should all
4478      * be equally valid for our purpose. */
4479     subfacet = CONTAINER_OF(list_front(&facet->subfacets),
4480                             struct subfacet, list_node);
4481     vlan_tci = facet->flow.vlan_tci;
4482     NL_ATTR_FOR_EACH_UNSAFE (a, left,
4483                              subfacet->actions, subfacet->actions_len) {
4484         const struct ovs_action_push_vlan *vlan;
4485         struct ofport_dpif *port;
4486
4487         switch (nl_attr_type(a)) {
4488         case OVS_ACTION_ATTR_OUTPUT:
4489             port = get_odp_port(ofproto, nl_attr_get_u32(a));
4490             if (port && port->bundle && port->bundle->bond) {
4491                 bond_account(port->bundle->bond, &facet->flow,
4492                              vlan_tci_to_vid(vlan_tci), n_bytes);
4493             }
4494             break;
4495
4496         case OVS_ACTION_ATTR_POP_VLAN:
4497             vlan_tci = htons(0);
4498             break;
4499
4500         case OVS_ACTION_ATTR_PUSH_VLAN:
4501             vlan = nl_attr_get(a);
4502             vlan_tci = vlan->vlan_tci;
4503             break;
4504         }
4505     }
4506 }
4507
4508 /* Returns true if the only action for 'facet' is to send to the controller.
4509  * (We don't report NetFlow expiration messages for such facets because they
4510  * are just part of the control logic for the network, not real traffic). */
4511 static bool
4512 facet_is_controller_flow(struct facet *facet)
4513 {
4514     if (facet) {
4515         const struct rule *rule = &facet->rule->up;
4516         const struct ofpact *ofpacts = rule->ofpacts;
4517         size_t ofpacts_len = rule->ofpacts_len;
4518
4519         if (ofpacts_len > 0 &&
4520             ofpacts->type == OFPACT_CONTROLLER &&
4521             ofpact_next(ofpacts) >= ofpact_end(ofpacts, ofpacts_len)) {
4522             return true;
4523         }
4524     }
4525     return false;
4526 }
4527
4528 /* Folds all of 'facet''s statistics into its rule.  Also updates the
4529  * accounting ofhook and emits a NetFlow expiration if appropriate.  All of
4530  * 'facet''s statistics in the datapath should have been zeroed and folded into
4531  * its packet and byte counts before this function is called. */
4532 static void
4533 facet_flush_stats(struct facet *facet)
4534 {
4535     struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
4536     struct subfacet *subfacet;
4537
4538     LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
4539         ovs_assert(!subfacet->dp_byte_count);
4540         ovs_assert(!subfacet->dp_packet_count);
4541     }
4542
4543     facet_push_stats(facet);
4544     if (facet->accounted_bytes < facet->byte_count) {
4545         facet_account(facet);
4546         facet->accounted_bytes = facet->byte_count;
4547     }
4548
4549     if (ofproto->netflow && !facet_is_controller_flow(facet)) {
4550         struct ofexpired expired;
4551         expired.flow = facet->flow;
4552         expired.packet_count = facet->packet_count;
4553         expired.byte_count = facet->byte_count;
4554         expired.used = facet->used;
4555         netflow_expire(ofproto->netflow, &facet->nf_flow, &expired);
4556     }
4557
4558     facet->rule->packet_count += facet->packet_count;
4559     facet->rule->byte_count += facet->byte_count;
4560
4561     /* Reset counters to prevent double counting if 'facet' ever gets
4562      * reinstalled. */
4563     facet_reset_counters(facet);
4564
4565     netflow_flow_clear(&facet->nf_flow);
4566     facet->tcp_flags = 0;
4567 }
4568
4569 /* Searches 'ofproto''s table of facets for one exactly equal to 'flow'.
4570  * Returns it if found, otherwise a null pointer.
4571  *
4572  * 'hash' must be the return value of flow_hash(flow, 0).
4573  *
4574  * The returned facet might need revalidation; use facet_lookup_valid()
4575  * instead if that is important. */
4576 static struct facet *
4577 facet_find(struct ofproto_dpif *ofproto,
4578            const struct flow *flow, uint32_t hash)
4579 {
4580     struct facet *facet;
4581
4582     HMAP_FOR_EACH_WITH_HASH (facet, hmap_node, hash, &ofproto->facets) {
4583         if (flow_equal(flow, &facet->flow)) {
4584             return facet;
4585         }
4586     }
4587
4588     return NULL;
4589 }
4590
4591 /* Searches 'ofproto''s table of facets for one exactly equal to 'flow'.
4592  * Returns it if found, otherwise a null pointer.
4593  *
4594  * 'hash' must be the return value of flow_hash(flow, 0).
4595  *
4596  * The returned facet is guaranteed to be valid. */
4597 static struct facet *
4598 facet_lookup_valid(struct ofproto_dpif *ofproto, const struct flow *flow,
4599                    uint32_t hash)
4600 {
4601     struct facet *facet;
4602
4603     facet = facet_find(ofproto, flow, hash);
4604     if (facet
4605         && (ofproto->backer->need_revalidate
4606             || tag_set_intersects(&ofproto->backer->revalidate_set,
4607                                   facet->tags))) {
4608         facet_revalidate(facet);
4609     }
4610
4611     return facet;
4612 }
4613
4614 static const char *
4615 subfacet_path_to_string(enum subfacet_path path)
4616 {
4617     switch (path) {
4618     case SF_NOT_INSTALLED:
4619         return "not installed";
4620     case SF_FAST_PATH:
4621         return "in fast path";
4622     case SF_SLOW_PATH:
4623         return "in slow path";
4624     default:
4625         return "<error>";
4626     }
4627 }
4628
4629 /* Returns the path in which a subfacet should be installed if its 'slow'
4630  * member has the specified value. */
4631 static enum subfacet_path
4632 subfacet_want_path(enum slow_path_reason slow)
4633 {
4634     return slow ? SF_SLOW_PATH : SF_FAST_PATH;
4635 }
4636
4637 /* Returns true if 'subfacet' needs to have its datapath flow updated,
4638  * supposing that its actions have been recalculated as 'want_actions' and that
4639  * 'slow' is nonzero iff 'subfacet' should be in the slow path. */
4640 static bool
4641 subfacet_should_install(struct subfacet *subfacet, enum slow_path_reason slow,
4642                         const struct ofpbuf *want_actions)
4643 {
4644     enum subfacet_path want_path = subfacet_want_path(slow);
4645     return (want_path != subfacet->path
4646             || (want_path == SF_FAST_PATH
4647                 && (subfacet->actions_len != want_actions->size
4648                     || memcmp(subfacet->actions, want_actions->data,
4649                               subfacet->actions_len))));
4650 }
4651
4652 static bool
4653 facet_check_consistency(struct facet *facet)
4654 {
4655     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 15);
4656
4657     struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
4658
4659     uint64_t odp_actions_stub[1024 / 8];
4660     struct ofpbuf odp_actions;
4661
4662     struct rule_dpif *rule;
4663     struct subfacet *subfacet;
4664     bool may_log = false;
4665     bool ok;
4666
4667     /* Check the rule for consistency. */
4668     rule = rule_dpif_lookup(ofproto, &facet->flow);
4669     ok = rule == facet->rule;
4670     if (!ok) {
4671         may_log = !VLOG_DROP_WARN(&rl);
4672         if (may_log) {
4673             struct ds s;
4674
4675             ds_init(&s);
4676             flow_format(&s, &facet->flow);
4677             ds_put_format(&s, ": facet associated with wrong rule (was "
4678                           "table=%"PRIu8",", facet->rule->up.table_id);
4679             cls_rule_format(&facet->rule->up.cr, &s);
4680             ds_put_format(&s, ") (should have been table=%"PRIu8",",
4681                           rule->up.table_id);
4682             cls_rule_format(&rule->up.cr, &s);
4683             ds_put_char(&s, ')');
4684
4685             VLOG_WARN("%s", ds_cstr(&s));
4686             ds_destroy(&s);
4687         }
4688     }
4689
4690     /* Check the datapath actions for consistency. */
4691     ofpbuf_use_stub(&odp_actions, odp_actions_stub, sizeof odp_actions_stub);
4692     LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
4693         enum subfacet_path want_path;
4694         struct odputil_keybuf keybuf;
4695         struct action_xlate_ctx ctx;
4696         struct ofpbuf key;
4697         struct ds s;
4698
4699         action_xlate_ctx_init(&ctx, ofproto, &facet->flow,
4700                               subfacet->initial_tci, rule, 0, NULL);
4701         xlate_actions(&ctx, rule->up.ofpacts, rule->up.ofpacts_len,
4702                       &odp_actions);
4703
4704         if (subfacet->path == SF_NOT_INSTALLED) {
4705             /* This only happens if the datapath reported an error when we
4706              * tried to install the flow.  Don't flag another error here. */
4707             continue;
4708         }
4709
4710         want_path = subfacet_want_path(subfacet->slow);
4711         if (want_path == SF_SLOW_PATH && subfacet->path == SF_SLOW_PATH) {
4712             /* The actions for slow-path flows may legitimately vary from one
4713              * packet to the next.  We're done. */
4714             continue;
4715         }
4716
4717         if (!subfacet_should_install(subfacet, subfacet->slow, &odp_actions)) {
4718             continue;
4719         }
4720
4721         /* Inconsistency! */
4722         if (ok) {
4723             may_log = !VLOG_DROP_WARN(&rl);
4724             ok = false;
4725         }
4726         if (!may_log) {
4727             /* Rate-limited, skip reporting. */
4728             continue;
4729         }
4730
4731         ds_init(&s);
4732         subfacet_get_key(subfacet, &keybuf, &key);
4733         odp_flow_key_format(key.data, key.size, &s);
4734
4735         ds_put_cstr(&s, ": inconsistency in subfacet");
4736         if (want_path != subfacet->path) {
4737             enum odp_key_fitness fitness = subfacet->key_fitness;
4738
4739             ds_put_format(&s, " (%s, fitness=%s)",
4740                           subfacet_path_to_string(subfacet->path),
4741                           odp_key_fitness_to_string(fitness));
4742             ds_put_format(&s, " (should have been %s)",
4743                           subfacet_path_to_string(want_path));
4744         } else if (want_path == SF_FAST_PATH) {
4745             ds_put_cstr(&s, " (actions were: ");
4746             format_odp_actions(&s, subfacet->actions,
4747                                subfacet->actions_len);
4748             ds_put_cstr(&s, ") (correct actions: ");
4749             format_odp_actions(&s, odp_actions.data, odp_actions.size);
4750             ds_put_char(&s, ')');
4751         } else {
4752             ds_put_cstr(&s, " (actions: ");
4753             format_odp_actions(&s, subfacet->actions,
4754                                subfacet->actions_len);
4755             ds_put_char(&s, ')');
4756         }
4757         VLOG_WARN("%s", ds_cstr(&s));
4758         ds_destroy(&s);
4759     }
4760     ofpbuf_uninit(&odp_actions);
4761
4762     return ok;
4763 }
4764
4765 /* Re-searches the classifier for 'facet':
4766  *
4767  *   - If the rule found is different from 'facet''s current rule, moves
4768  *     'facet' to the new rule and recompiles its actions.
4769  *
4770  *   - If the rule found is the same as 'facet''s current rule, leaves 'facet'
4771  *     where it is and recompiles its actions anyway. */
4772 static void
4773 facet_revalidate(struct facet *facet)
4774 {
4775     struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
4776     struct actions {
4777         struct nlattr *odp_actions;
4778         size_t actions_len;
4779     };
4780     struct actions *new_actions;
4781
4782     struct action_xlate_ctx ctx;
4783     uint64_t odp_actions_stub[1024 / 8];
4784     struct ofpbuf odp_actions;
4785
4786     struct rule_dpif *new_rule;
4787     struct subfacet *subfacet;
4788     int i;
4789
4790     COVERAGE_INC(facet_revalidate);
4791
4792     new_rule = rule_dpif_lookup(ofproto, &facet->flow);
4793
4794     /* Calculate new datapath actions.
4795      *
4796      * We do not modify any 'facet' state yet, because we might need to, e.g.,
4797      * emit a NetFlow expiration and, if so, we need to have the old state
4798      * around to properly compose it. */
4799
4800     /* If the datapath actions changed or the installability changed,
4801      * then we need to talk to the datapath. */
4802     i = 0;
4803     new_actions = NULL;
4804     memset(&ctx, 0, sizeof ctx);
4805     ofpbuf_use_stub(&odp_actions, odp_actions_stub, sizeof odp_actions_stub);
4806     LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
4807         enum slow_path_reason slow;
4808
4809         action_xlate_ctx_init(&ctx, ofproto, &facet->flow,
4810                               subfacet->initial_tci, new_rule, 0, NULL);
4811         xlate_actions(&ctx, new_rule->up.ofpacts, new_rule->up.ofpacts_len,
4812                       &odp_actions);
4813
4814         slow = (subfacet->slow & SLOW_MATCH) | ctx.slow;
4815         if (subfacet_should_install(subfacet, slow, &odp_actions)) {
4816             struct dpif_flow_stats stats;
4817
4818             subfacet_install(subfacet,
4819                              odp_actions.data, odp_actions.size, &stats, slow);
4820             subfacet_update_stats(subfacet, &stats);
4821
4822             if (!new_actions) {
4823                 new_actions = xcalloc(list_size(&facet->subfacets),
4824                                       sizeof *new_actions);
4825             }
4826             new_actions[i].odp_actions = xmemdup(odp_actions.data,
4827                                                  odp_actions.size);
4828             new_actions[i].actions_len = odp_actions.size;
4829         }
4830
4831         i++;
4832     }
4833     ofpbuf_uninit(&odp_actions);
4834
4835     if (new_actions) {
4836         facet_flush_stats(facet);
4837     }
4838
4839     /* Update 'facet' now that we've taken care of all the old state. */
4840     facet->tags = ctx.tags;
4841     facet->nf_flow.output_iface = ctx.nf_output_iface;
4842     facet->has_learn = ctx.has_learn;
4843     facet->has_normal = ctx.has_normal;
4844     facet->has_fin_timeout = ctx.has_fin_timeout;
4845     facet->mirrors = ctx.mirrors;
4846
4847     i = 0;
4848     LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
4849         subfacet->slow = (subfacet->slow & SLOW_MATCH) | ctx.slow;
4850
4851         if (new_actions && new_actions[i].odp_actions) {
4852             free(subfacet->actions);
4853             subfacet->actions = new_actions[i].odp_actions;
4854             subfacet->actions_len = new_actions[i].actions_len;
4855         }
4856         i++;
4857     }
4858     free(new_actions);
4859
4860     if (facet->rule != new_rule) {
4861         COVERAGE_INC(facet_changed_rule);
4862         list_remove(&facet->list_node);
4863         list_push_back(&new_rule->facets, &facet->list_node);
4864         facet->rule = new_rule;
4865         facet->used = new_rule->up.created;
4866         facet->prev_used = facet->used;
4867     }
4868 }
4869
4870 /* Updates 'facet''s used time.  Caller is responsible for calling
4871  * facet_push_stats() to update the flows which 'facet' resubmits into. */
4872 static void
4873 facet_update_time(struct facet *facet, long long int used)
4874 {
4875     struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
4876     if (used > facet->used) {
4877         facet->used = used;
4878         ofproto_rule_update_used(&facet->rule->up, used);
4879         netflow_flow_update_time(ofproto->netflow, &facet->nf_flow, used);
4880     }
4881 }
4882
4883 static void
4884 facet_reset_counters(struct facet *facet)
4885 {
4886     facet->packet_count = 0;
4887     facet->byte_count = 0;
4888     facet->prev_packet_count = 0;
4889     facet->prev_byte_count = 0;
4890     facet->accounted_bytes = 0;
4891 }
4892
4893 static void
4894 facet_push_stats(struct facet *facet)
4895 {
4896     struct dpif_flow_stats stats;
4897
4898     ovs_assert(facet->packet_count >= facet->prev_packet_count);
4899     ovs_assert(facet->byte_count >= facet->prev_byte_count);
4900     ovs_assert(facet->used >= facet->prev_used);
4901
4902     stats.n_packets = facet->packet_count - facet->prev_packet_count;
4903     stats.n_bytes = facet->byte_count - facet->prev_byte_count;
4904     stats.used = facet->used;
4905     stats.tcp_flags = 0;
4906
4907     if (stats.n_packets || stats.n_bytes || facet->used > facet->prev_used) {
4908         facet->prev_packet_count = facet->packet_count;
4909         facet->prev_byte_count = facet->byte_count;
4910         facet->prev_used = facet->used;
4911
4912         flow_push_stats(facet->rule, &facet->flow, &stats);
4913
4914         update_mirror_stats(ofproto_dpif_cast(facet->rule->up.ofproto),
4915                             facet->mirrors, stats.n_packets, stats.n_bytes);
4916     }
4917 }
4918
4919 static void
4920 rule_credit_stats(struct rule_dpif *rule, const struct dpif_flow_stats *stats)
4921 {
4922     rule->packet_count += stats->n_packets;
4923     rule->byte_count += stats->n_bytes;
4924     ofproto_rule_update_used(&rule->up, stats->used);
4925 }
4926
4927 /* Pushes flow statistics to the rules which 'flow' resubmits into given
4928  * 'rule''s actions and mirrors. */
4929 static void
4930 flow_push_stats(struct rule_dpif *rule,
4931                 const struct flow *flow, const struct dpif_flow_stats *stats)
4932 {
4933     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
4934     struct action_xlate_ctx ctx;
4935
4936     ofproto_rule_update_used(&rule->up, stats->used);
4937
4938     action_xlate_ctx_init(&ctx, ofproto, flow, flow->vlan_tci, rule,
4939                           0, NULL);
4940     ctx.resubmit_stats = stats;
4941     xlate_actions_for_side_effects(&ctx, rule->up.ofpacts,
4942                                    rule->up.ofpacts_len);
4943 }
4944 \f
4945 /* Subfacets. */
4946
4947 static struct subfacet *
4948 subfacet_find(struct ofproto_dpif *ofproto,
4949               const struct nlattr *key, size_t key_len, uint32_t key_hash,
4950               const struct flow *flow)
4951 {
4952     struct subfacet *subfacet;
4953
4954     HMAP_FOR_EACH_WITH_HASH (subfacet, hmap_node, key_hash,
4955                              &ofproto->subfacets) {
4956         if (subfacet->key
4957             ? (subfacet->key_len == key_len
4958                && !memcmp(key, subfacet->key, key_len))
4959             : flow_equal(flow, &subfacet->facet->flow)) {
4960             return subfacet;
4961         }
4962     }
4963
4964     return NULL;
4965 }
4966
4967 /* Searches 'facet' (within 'ofproto') for a subfacet with the specified
4968  * 'key_fitness', 'key', and 'key_len' members in 'miss'.  Returns the
4969  * existing subfacet if there is one, otherwise creates and returns a
4970  * new subfacet.
4971  *
4972  * If the returned subfacet is new, then subfacet->actions will be NULL, in
4973  * which case the caller must populate the actions with
4974  * subfacet_make_actions(). */
4975 static struct subfacet *
4976 subfacet_create(struct facet *facet, struct flow_miss *miss,
4977                 long long int now)
4978 {
4979     struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
4980     enum odp_key_fitness key_fitness = miss->key_fitness;
4981     const struct nlattr *key = miss->key;
4982     size_t key_len = miss->key_len;
4983     uint32_t key_hash;
4984     struct subfacet *subfacet;
4985
4986     key_hash = odp_flow_key_hash(key, key_len);
4987
4988     if (list_is_empty(&facet->subfacets)) {
4989         subfacet = &facet->one_subfacet;
4990     } else {
4991         subfacet = subfacet_find(ofproto, key, key_len, key_hash,
4992                                  &facet->flow);
4993         if (subfacet) {
4994             if (subfacet->facet == facet) {
4995                 return subfacet;
4996             }
4997
4998             /* This shouldn't happen. */
4999             VLOG_ERR_RL(&rl, "subfacet with wrong facet");
5000             subfacet_destroy(subfacet);
5001         }
5002
5003         subfacet = xmalloc(sizeof *subfacet);
5004     }
5005
5006     hmap_insert(&ofproto->subfacets, &subfacet->hmap_node, key_hash);
5007     list_push_back(&facet->subfacets, &subfacet->list_node);
5008     subfacet->facet = facet;
5009     subfacet->key_fitness = key_fitness;
5010     if (key_fitness != ODP_FIT_PERFECT) {
5011         subfacet->key = xmemdup(key, key_len);
5012         subfacet->key_len = key_len;
5013     } else {
5014         subfacet->key = NULL;
5015         subfacet->key_len = 0;
5016     }
5017     subfacet->used = now;
5018     subfacet->dp_packet_count = 0;
5019     subfacet->dp_byte_count = 0;
5020     subfacet->actions_len = 0;
5021     subfacet->actions = NULL;
5022     subfacet->slow = (subfacet->key_fitness == ODP_FIT_TOO_LITTLE
5023                       ? SLOW_MATCH
5024                       : 0);
5025     subfacet->path = SF_NOT_INSTALLED;
5026     subfacet->initial_tci = miss->initial_tci;
5027     subfacet->odp_in_port = miss->odp_in_port;
5028
5029     return subfacet;
5030 }
5031
5032 /* Uninstalls 'subfacet' from the datapath, if it is installed, removes it from
5033  * its facet within 'ofproto', and frees it. */
5034 static void
5035 subfacet_destroy__(struct subfacet *subfacet)
5036 {
5037     struct facet *facet = subfacet->facet;
5038     struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
5039
5040     subfacet_uninstall(subfacet);
5041     hmap_remove(&ofproto->subfacets, &subfacet->hmap_node);
5042     list_remove(&subfacet->list_node);
5043     free(subfacet->key);
5044     free(subfacet->actions);
5045     if (subfacet != &facet->one_subfacet) {
5046         free(subfacet);
5047     }
5048 }
5049
5050 /* Destroys 'subfacet', as with subfacet_destroy__(), and then if this was the
5051  * last remaining subfacet in its facet destroys the facet too. */
5052 static void
5053 subfacet_destroy(struct subfacet *subfacet)
5054 {
5055     struct facet *facet = subfacet->facet;
5056
5057     if (list_is_singleton(&facet->subfacets)) {
5058         /* facet_remove() needs at least one subfacet (it will remove it). */
5059         facet_remove(facet);
5060     } else {
5061         subfacet_destroy__(subfacet);
5062     }
5063 }
5064
5065 static void
5066 subfacet_destroy_batch(struct ofproto_dpif *ofproto,
5067                        struct subfacet **subfacets, int n)
5068 {
5069     struct odputil_keybuf keybufs[SUBFACET_DESTROY_MAX_BATCH];
5070     struct dpif_op ops[SUBFACET_DESTROY_MAX_BATCH];
5071     struct dpif_op *opsp[SUBFACET_DESTROY_MAX_BATCH];
5072     struct ofpbuf keys[SUBFACET_DESTROY_MAX_BATCH];
5073     struct dpif_flow_stats stats[SUBFACET_DESTROY_MAX_BATCH];
5074     int i;
5075
5076     for (i = 0; i < n; i++) {
5077         ops[i].type = DPIF_OP_FLOW_DEL;
5078         subfacet_get_key(subfacets[i], &keybufs[i], &keys[i]);
5079         ops[i].u.flow_del.key = keys[i].data;
5080         ops[i].u.flow_del.key_len = keys[i].size;
5081         ops[i].u.flow_del.stats = &stats[i];
5082         opsp[i] = &ops[i];
5083     }
5084
5085     dpif_operate(ofproto->backer->dpif, opsp, n);
5086     for (i = 0; i < n; i++) {
5087         subfacet_reset_dp_stats(subfacets[i], &stats[i]);
5088         subfacets[i]->path = SF_NOT_INSTALLED;
5089         subfacet_destroy(subfacets[i]);
5090     }
5091 }
5092
5093 /* Initializes 'key' with the sequence of OVS_KEY_ATTR_* Netlink attributes
5094  * that can be used to refer to 'subfacet'.  The caller must provide 'keybuf'
5095  * for use as temporary storage. */
5096 static void
5097 subfacet_get_key(struct subfacet *subfacet, struct odputil_keybuf *keybuf,
5098                  struct ofpbuf *key)
5099 {
5100
5101     if (!subfacet->key) {
5102         struct flow *flow = &subfacet->facet->flow;
5103
5104         ofpbuf_use_stack(key, keybuf, sizeof *keybuf);
5105         odp_flow_key_from_flow(key, flow, subfacet->odp_in_port);
5106     } else {
5107         ofpbuf_use_const(key, subfacet->key, subfacet->key_len);
5108     }
5109 }
5110
5111 /* Composes the datapath actions for 'subfacet' based on its rule's actions.
5112  * Translates the actions into 'odp_actions', which the caller must have
5113  * initialized and is responsible for uninitializing. */
5114 static void
5115 subfacet_make_actions(struct subfacet *subfacet, const struct ofpbuf *packet,
5116                       struct ofpbuf *odp_actions)
5117 {
5118     struct facet *facet = subfacet->facet;
5119     struct rule_dpif *rule = facet->rule;
5120     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
5121
5122     struct action_xlate_ctx ctx;
5123
5124     action_xlate_ctx_init(&ctx, ofproto, &facet->flow, subfacet->initial_tci,
5125                           rule, 0, packet);
5126     xlate_actions(&ctx, rule->up.ofpacts, rule->up.ofpacts_len, odp_actions);
5127     facet->tags = ctx.tags;
5128     facet->has_learn = ctx.has_learn;
5129     facet->has_normal = ctx.has_normal;
5130     facet->has_fin_timeout = ctx.has_fin_timeout;
5131     facet->nf_flow.output_iface = ctx.nf_output_iface;
5132     facet->mirrors = ctx.mirrors;
5133
5134     subfacet->slow = (subfacet->slow & SLOW_MATCH) | ctx.slow;
5135     if (subfacet->actions_len != odp_actions->size
5136         || memcmp(subfacet->actions, odp_actions->data, odp_actions->size)) {
5137         free(subfacet->actions);
5138         subfacet->actions_len = odp_actions->size;
5139         subfacet->actions = xmemdup(odp_actions->data, odp_actions->size);
5140     }
5141 }
5142
5143 /* Updates 'subfacet''s datapath flow, setting its actions to 'actions_len'
5144  * bytes of actions in 'actions'.  If 'stats' is non-null, statistics counters
5145  * in the datapath will be zeroed and 'stats' will be updated with traffic new
5146  * since 'subfacet' was last updated.
5147  *
5148  * Returns 0 if successful, otherwise a positive errno value. */
5149 static int
5150 subfacet_install(struct subfacet *subfacet,
5151                  const struct nlattr *actions, size_t actions_len,
5152                  struct dpif_flow_stats *stats,
5153                  enum slow_path_reason slow)
5154 {
5155     struct facet *facet = subfacet->facet;
5156     struct ofproto_dpif *ofproto = ofproto_dpif_cast(facet->rule->up.ofproto);
5157     enum subfacet_path path = subfacet_want_path(slow);
5158     uint64_t slow_path_stub[128 / 8];
5159     struct odputil_keybuf keybuf;
5160     enum dpif_flow_put_flags flags;
5161     struct ofpbuf key;
5162     int ret;
5163
5164     flags = DPIF_FP_CREATE | DPIF_FP_MODIFY;
5165     if (stats) {
5166         flags |= DPIF_FP_ZERO_STATS;
5167     }
5168
5169     if (path == SF_SLOW_PATH) {
5170         compose_slow_path(ofproto, &facet->flow, slow,
5171                           slow_path_stub, sizeof slow_path_stub,
5172                           &actions, &actions_len);
5173     }
5174
5175     subfacet_get_key(subfacet, &keybuf, &key);
5176     ret = dpif_flow_put(ofproto->backer->dpif, flags, key.data, key.size,
5177                         actions, actions_len, stats);
5178
5179     if (stats) {
5180         subfacet_reset_dp_stats(subfacet, stats);
5181     }
5182
5183     if (!ret) {
5184         subfacet->path = path;
5185     }
5186     return ret;
5187 }
5188
5189 static int
5190 subfacet_reinstall(struct subfacet *subfacet, struct dpif_flow_stats *stats)
5191 {
5192     return subfacet_install(subfacet, subfacet->actions, subfacet->actions_len,
5193                             stats, subfacet->slow);
5194 }
5195
5196 /* If 'subfacet' is installed in the datapath, uninstalls it. */
5197 static void
5198 subfacet_uninstall(struct subfacet *subfacet)
5199 {
5200     if (subfacet->path != SF_NOT_INSTALLED) {
5201         struct rule_dpif *rule = subfacet->facet->rule;
5202         struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
5203         struct odputil_keybuf keybuf;
5204         struct dpif_flow_stats stats;
5205         struct ofpbuf key;
5206         int error;
5207
5208         subfacet_get_key(subfacet, &keybuf, &key);
5209         error = dpif_flow_del(ofproto->backer->dpif,
5210                               key.data, key.size, &stats);
5211         subfacet_reset_dp_stats(subfacet, &stats);
5212         if (!error) {
5213             subfacet_update_stats(subfacet, &stats);
5214         }
5215         subfacet->path = SF_NOT_INSTALLED;
5216     } else {
5217         ovs_assert(subfacet->dp_packet_count == 0);
5218         ovs_assert(subfacet->dp_byte_count == 0);
5219     }
5220 }
5221
5222 /* Resets 'subfacet''s datapath statistics counters.  This should be called
5223  * when 'subfacet''s statistics are cleared in the datapath.  If 'stats' is
5224  * non-null, it should contain the statistics returned by dpif when 'subfacet'
5225  * was reset in the datapath.  'stats' will be modified to include only
5226  * statistics new since 'subfacet' was last updated. */
5227 static void
5228 subfacet_reset_dp_stats(struct subfacet *subfacet,
5229                         struct dpif_flow_stats *stats)
5230 {
5231     if (stats
5232         && subfacet->dp_packet_count <= stats->n_packets
5233         && subfacet->dp_byte_count <= stats->n_bytes) {
5234         stats->n_packets -= subfacet->dp_packet_count;
5235         stats->n_bytes -= subfacet->dp_byte_count;
5236     }
5237
5238     subfacet->dp_packet_count = 0;
5239     subfacet->dp_byte_count = 0;
5240 }
5241
5242 /* Updates 'subfacet''s used time.  The caller is responsible for calling
5243  * facet_push_stats() to update the flows which 'subfacet' resubmits into. */
5244 static void
5245 subfacet_update_time(struct subfacet *subfacet, long long int used)
5246 {
5247     if (used > subfacet->used) {
5248         subfacet->used = used;
5249         facet_update_time(subfacet->facet, used);
5250     }
5251 }
5252
5253 /* Folds the statistics from 'stats' into the counters in 'subfacet'.
5254  *
5255  * Because of the meaning of a subfacet's counters, it only makes sense to do
5256  * this if 'stats' are not tracked in the datapath, that is, if 'stats'
5257  * represents a packet that was sent by hand or if it represents statistics
5258  * that have been cleared out of the datapath. */
5259 static void
5260 subfacet_update_stats(struct subfacet *subfacet,
5261                       const struct dpif_flow_stats *stats)
5262 {
5263     if (stats->n_packets || stats->used > subfacet->used) {
5264         struct facet *facet = subfacet->facet;
5265
5266         subfacet_update_time(subfacet, stats->used);
5267         facet->packet_count += stats->n_packets;
5268         facet->byte_count += stats->n_bytes;
5269         facet->tcp_flags |= stats->tcp_flags;
5270         facet_push_stats(facet);
5271         netflow_flow_update_flags(&facet->nf_flow, stats->tcp_flags);
5272     }
5273 }
5274 \f
5275 /* Rules. */
5276
5277 static struct rule_dpif *
5278 rule_dpif_lookup(struct ofproto_dpif *ofproto, const struct flow *flow)
5279 {
5280     struct rule_dpif *rule;
5281
5282     rule = rule_dpif_lookup__(ofproto, flow, 0);
5283     if (rule) {
5284         return rule;
5285     }
5286
5287     return rule_dpif_miss_rule(ofproto, flow);
5288 }
5289
5290 static struct rule_dpif *
5291 rule_dpif_lookup__(struct ofproto_dpif *ofproto, const struct flow *flow,
5292                    uint8_t table_id)
5293 {
5294     struct cls_rule *cls_rule;
5295     struct classifier *cls;
5296
5297     if (table_id >= N_TABLES) {
5298         return NULL;
5299     }
5300
5301     cls = &ofproto->up.tables[table_id].cls;
5302     if (flow->nw_frag & FLOW_NW_FRAG_ANY
5303         && ofproto->up.frag_handling == OFPC_FRAG_NORMAL) {
5304         /* For OFPC_NORMAL frag_handling, we must pretend that transport ports
5305          * are unavailable. */
5306         struct flow ofpc_normal_flow = *flow;
5307         ofpc_normal_flow.tp_src = htons(0);
5308         ofpc_normal_flow.tp_dst = htons(0);
5309         cls_rule = classifier_lookup(cls, &ofpc_normal_flow);
5310     } else {
5311         cls_rule = classifier_lookup(cls, flow);
5312     }
5313     return rule_dpif_cast(rule_from_cls_rule(cls_rule));
5314 }
5315
5316 static struct rule_dpif *
5317 rule_dpif_miss_rule(struct ofproto_dpif *ofproto, const struct flow *flow)
5318 {
5319     struct ofport_dpif *port;
5320
5321     port = get_ofp_port(ofproto, flow->in_port);
5322     if (!port) {
5323         VLOG_WARN_RL(&rl, "packet-in on unknown port %"PRIu16, flow->in_port);
5324         return ofproto->miss_rule;
5325     }
5326
5327     if (port->up.pp.config & OFPUTIL_PC_NO_PACKET_IN) {
5328         return ofproto->no_packet_in_rule;
5329     }
5330     return ofproto->miss_rule;
5331 }
5332
5333 static void
5334 complete_operation(struct rule_dpif *rule)
5335 {
5336     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
5337
5338     rule_invalidate(rule);
5339     if (clogged) {
5340         struct dpif_completion *c = xmalloc(sizeof *c);
5341         c->op = rule->up.pending;
5342         list_push_back(&ofproto->completions, &c->list_node);
5343     } else {
5344         ofoperation_complete(rule->up.pending, 0);
5345     }
5346 }
5347
5348 static struct rule *
5349 rule_alloc(void)
5350 {
5351     struct rule_dpif *rule = xmalloc(sizeof *rule);
5352     return &rule->up;
5353 }
5354
5355 static void
5356 rule_dealloc(struct rule *rule_)
5357 {
5358     struct rule_dpif *rule = rule_dpif_cast(rule_);
5359     free(rule);
5360 }
5361
5362 static enum ofperr
5363 rule_construct(struct rule *rule_)
5364 {
5365     struct rule_dpif *rule = rule_dpif_cast(rule_);
5366     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
5367     struct rule_dpif *victim;
5368     uint8_t table_id;
5369
5370     rule->packet_count = 0;
5371     rule->byte_count = 0;
5372
5373     victim = rule_dpif_cast(ofoperation_get_victim(rule->up.pending));
5374     if (victim && !list_is_empty(&victim->facets)) {
5375         struct facet *facet;
5376
5377         rule->facets = victim->facets;
5378         list_moved(&rule->facets);
5379         LIST_FOR_EACH (facet, list_node, &rule->facets) {
5380             /* XXX: We're only clearing our local counters here.  It's possible
5381              * that quite a few packets are unaccounted for in the datapath
5382              * statistics.  These will be accounted to the new rule instead of
5383              * cleared as required.  This could be fixed by clearing out the
5384              * datapath statistics for this facet, but currently it doesn't
5385              * seem worth it. */
5386             facet_reset_counters(facet);
5387             facet->rule = rule;
5388         }
5389     } else {
5390         /* Must avoid list_moved() in this case. */
5391         list_init(&rule->facets);
5392     }
5393
5394     table_id = rule->up.table_id;
5395     if (victim) {
5396         rule->tag = victim->tag;
5397     } else if (table_id == 0) {
5398         rule->tag = 0;
5399     } else {
5400         struct flow flow;
5401
5402         miniflow_expand(&rule->up.cr.match.flow, &flow);
5403         rule->tag = rule_calculate_tag(&flow, &rule->up.cr.match.mask,
5404                                        ofproto->tables[table_id].basis);
5405     }
5406
5407     complete_operation(rule);
5408     return 0;
5409 }
5410
5411 static void
5412 rule_destruct(struct rule *rule_)
5413 {
5414     struct rule_dpif *rule = rule_dpif_cast(rule_);
5415     struct facet *facet, *next_facet;
5416
5417     LIST_FOR_EACH_SAFE (facet, next_facet, list_node, &rule->facets) {
5418         facet_revalidate(facet);
5419     }
5420
5421     complete_operation(rule);
5422 }
5423
5424 static void
5425 rule_get_stats(struct rule *rule_, uint64_t *packets, uint64_t *bytes)
5426 {
5427     struct rule_dpif *rule = rule_dpif_cast(rule_);
5428     struct facet *facet;
5429
5430     /* Start from historical data for 'rule' itself that are no longer tracked
5431      * in facets.  This counts, for example, facets that have expired. */
5432     *packets = rule->packet_count;
5433     *bytes = rule->byte_count;
5434
5435     /* Add any statistics that are tracked by facets.  This includes
5436      * statistical data recently updated by ofproto_update_stats() as well as
5437      * stats for packets that were executed "by hand" via dpif_execute(). */
5438     LIST_FOR_EACH (facet, list_node, &rule->facets) {
5439         *packets += facet->packet_count;
5440         *bytes += facet->byte_count;
5441     }
5442 }
5443
5444 static void
5445 rule_dpif_execute(struct rule_dpif *rule, const struct flow *flow,
5446                   struct ofpbuf *packet)
5447 {
5448     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
5449
5450     struct dpif_flow_stats stats;
5451
5452     struct action_xlate_ctx ctx;
5453     uint64_t odp_actions_stub[1024 / 8];
5454     struct ofpbuf odp_actions;
5455
5456     dpif_flow_stats_extract(flow, packet, time_msec(), &stats);
5457     rule_credit_stats(rule, &stats);
5458
5459     ofpbuf_use_stub(&odp_actions, odp_actions_stub, sizeof odp_actions_stub);
5460     action_xlate_ctx_init(&ctx, ofproto, flow, flow->vlan_tci,
5461                           rule, stats.tcp_flags, packet);
5462     ctx.resubmit_stats = &stats;
5463     xlate_actions(&ctx, rule->up.ofpacts, rule->up.ofpacts_len, &odp_actions);
5464
5465     execute_odp_actions(ofproto, flow, odp_actions.data,
5466                         odp_actions.size, packet);
5467
5468     ofpbuf_uninit(&odp_actions);
5469 }
5470
5471 static enum ofperr
5472 rule_execute(struct rule *rule, const struct flow *flow,
5473              struct ofpbuf *packet)
5474 {
5475     rule_dpif_execute(rule_dpif_cast(rule), flow, packet);
5476     ofpbuf_delete(packet);
5477     return 0;
5478 }
5479
5480 static void
5481 rule_modify_actions(struct rule *rule_)
5482 {
5483     struct rule_dpif *rule = rule_dpif_cast(rule_);
5484
5485     complete_operation(rule);
5486 }
5487 \f
5488 /* Sends 'packet' out 'ofport'.
5489  * May modify 'packet'.
5490  * Returns 0 if successful, otherwise a positive errno value. */
5491 static int
5492 send_packet(const struct ofport_dpif *ofport, struct ofpbuf *packet)
5493 {
5494     const struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto);
5495     uint64_t odp_actions_stub[1024 / 8];
5496     struct ofpbuf key, odp_actions;
5497     struct odputil_keybuf keybuf;
5498     uint32_t odp_port;
5499     struct flow flow;
5500     int error;
5501
5502     flow_extract(packet, 0, 0, NULL, OFPP_LOCAL, &flow);
5503     if (netdev_vport_is_patch(ofport->up.netdev)) {
5504         struct ofproto_dpif *peer_ofproto;
5505         struct dpif_flow_stats stats;
5506         struct ofport_dpif *peer;
5507         struct rule_dpif *rule;
5508
5509         peer = ofport_get_peer(ofport);
5510         if (!peer) {
5511             return ENODEV;
5512         }
5513
5514         dpif_flow_stats_extract(&flow, packet, time_msec(), &stats);
5515         netdev_vport_inc_tx(ofport->up.netdev, &stats);
5516         netdev_vport_inc_rx(peer->up.netdev, &stats);
5517
5518         flow.in_port = peer->up.ofp_port;
5519         peer_ofproto = ofproto_dpif_cast(peer->up.ofproto);
5520         rule = rule_dpif_lookup(peer_ofproto, &flow);
5521         rule_dpif_execute(rule, &flow, packet);
5522
5523         return 0;
5524     }
5525
5526     ofpbuf_use_stub(&odp_actions, odp_actions_stub, sizeof odp_actions_stub);
5527
5528     if (ofport->tnl_port) {
5529         struct dpif_flow_stats stats;
5530
5531         odp_port = tnl_port_send(ofport->tnl_port, &flow);
5532         if (odp_port == OVSP_NONE) {
5533             return ENODEV;
5534         }
5535
5536         dpif_flow_stats_extract(&flow, packet, time_msec(), &stats);
5537         netdev_vport_inc_tx(ofport->up.netdev, &stats);
5538         odp_put_tunnel_action(&flow.tunnel, &odp_actions);
5539         odp_put_skb_mark_action(flow.skb_mark, &odp_actions);
5540     } else {
5541         odp_port = vsp_realdev_to_vlandev(ofproto, ofport->odp_port,
5542                                           flow.vlan_tci);
5543         if (odp_port != ofport->odp_port) {
5544             eth_pop_vlan(packet);
5545             flow.vlan_tci = htons(0);
5546         }
5547     }
5548
5549     ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
5550     odp_flow_key_from_flow(&key, &flow,
5551                            ofp_port_to_odp_port(ofproto, flow.in_port));
5552
5553     compose_sflow_action(ofproto, &odp_actions, &flow, odp_port);
5554
5555     nl_msg_put_u32(&odp_actions, OVS_ACTION_ATTR_OUTPUT, odp_port);
5556     error = dpif_execute(ofproto->backer->dpif,
5557                          key.data, key.size,
5558                          odp_actions.data, odp_actions.size,
5559                          packet);
5560     ofpbuf_uninit(&odp_actions);
5561
5562     if (error) {
5563         VLOG_WARN_RL(&rl, "%s: failed to send packet on port %"PRIu32" (%s)",
5564                      ofproto->up.name, odp_port, strerror(error));
5565     }
5566     ofproto_update_local_port_stats(ofport->up.ofproto, packet->size, 0);
5567     return error;
5568 }
5569 \f
5570 /* OpenFlow to datapath action translation. */
5571
5572 static bool may_receive(const struct ofport_dpif *, struct action_xlate_ctx *);
5573 static void do_xlate_actions(const struct ofpact *, size_t ofpacts_len,
5574                              struct action_xlate_ctx *);
5575 static void xlate_normal(struct action_xlate_ctx *);
5576
5577 /* Composes an ODP action for a "slow path" action for 'flow' within 'ofproto'.
5578  * The action will state 'slow' as the reason that the action is in the slow
5579  * path.  (This is purely informational: it allows a human viewing "ovs-dpctl
5580  * dump-flows" output to see why a flow is in the slow path.)
5581  *
5582  * The 'stub_size' bytes in 'stub' will be used to store the action.
5583  * 'stub_size' must be large enough for the action.
5584  *
5585  * The action and its size will be stored in '*actionsp' and '*actions_lenp',
5586  * respectively. */
5587 static void
5588 compose_slow_path(const struct ofproto_dpif *ofproto, const struct flow *flow,
5589                   enum slow_path_reason slow,
5590                   uint64_t *stub, size_t stub_size,
5591                   const struct nlattr **actionsp, size_t *actions_lenp)
5592 {
5593     union user_action_cookie cookie;
5594     struct ofpbuf buf;
5595
5596     cookie.type = USER_ACTION_COOKIE_SLOW_PATH;
5597     cookie.slow_path.unused = 0;
5598     cookie.slow_path.reason = slow;
5599
5600     ofpbuf_use_stack(&buf, stub, stub_size);
5601     if (slow & (SLOW_CFM | SLOW_LACP | SLOW_STP)) {
5602         uint32_t pid = dpif_port_get_pid(ofproto->backer->dpif, UINT32_MAX);
5603         odp_put_userspace_action(pid, &cookie, &buf);
5604     } else {
5605         put_userspace_action(ofproto, &buf, flow, &cookie);
5606     }
5607     *actionsp = buf.data;
5608     *actions_lenp = buf.size;
5609 }
5610
5611 static size_t
5612 put_userspace_action(const struct ofproto_dpif *ofproto,
5613                      struct ofpbuf *odp_actions,
5614                      const struct flow *flow,
5615                      const union user_action_cookie *cookie)
5616 {
5617     uint32_t pid;
5618
5619     pid = dpif_port_get_pid(ofproto->backer->dpif,
5620                             ofp_port_to_odp_port(ofproto, flow->in_port));
5621
5622     return odp_put_userspace_action(pid, cookie, odp_actions);
5623 }
5624
5625 static void
5626 compose_sflow_cookie(const struct ofproto_dpif *ofproto,
5627                      ovs_be16 vlan_tci, uint32_t odp_port,
5628                      unsigned int n_outputs, union user_action_cookie *cookie)
5629 {
5630     int ifindex;
5631
5632     cookie->type = USER_ACTION_COOKIE_SFLOW;
5633     cookie->sflow.vlan_tci = vlan_tci;
5634
5635     /* See http://www.sflow.org/sflow_version_5.txt (search for "Input/output
5636      * port information") for the interpretation of cookie->output. */
5637     switch (n_outputs) {
5638     case 0:
5639         /* 0x40000000 | 256 means "packet dropped for unknown reason". */
5640         cookie->sflow.output = 0x40000000 | 256;
5641         break;
5642
5643     case 1:
5644         ifindex = dpif_sflow_odp_port_to_ifindex(ofproto->sflow, odp_port);
5645         if (ifindex) {
5646             cookie->sflow.output = ifindex;
5647             break;
5648         }
5649         /* Fall through. */
5650     default:
5651         /* 0x80000000 means "multiple output ports. */
5652         cookie->sflow.output = 0x80000000 | n_outputs;
5653         break;
5654     }
5655 }
5656
5657 /* Compose SAMPLE action for sFlow. */
5658 static size_t
5659 compose_sflow_action(const struct ofproto_dpif *ofproto,
5660                      struct ofpbuf *odp_actions,
5661                      const struct flow *flow,
5662                      uint32_t odp_port)
5663 {
5664     uint32_t probability;
5665     union user_action_cookie cookie;
5666     size_t sample_offset, actions_offset;
5667     int cookie_offset;
5668
5669     if (!ofproto->sflow || flow->in_port == OFPP_NONE) {
5670         return 0;
5671     }
5672
5673     sample_offset = nl_msg_start_nested(odp_actions, OVS_ACTION_ATTR_SAMPLE);
5674
5675     /* Number of packets out of UINT_MAX to sample. */
5676     probability = dpif_sflow_get_probability(ofproto->sflow);
5677     nl_msg_put_u32(odp_actions, OVS_SAMPLE_ATTR_PROBABILITY, probability);
5678
5679     actions_offset = nl_msg_start_nested(odp_actions, OVS_SAMPLE_ATTR_ACTIONS);
5680     compose_sflow_cookie(ofproto, htons(0), odp_port,
5681                          odp_port == OVSP_NONE ? 0 : 1, &cookie);
5682     cookie_offset = put_userspace_action(ofproto, odp_actions, flow, &cookie);
5683
5684     nl_msg_end_nested(odp_actions, actions_offset);
5685     nl_msg_end_nested(odp_actions, sample_offset);
5686     return cookie_offset;
5687 }
5688
5689 /* SAMPLE action must be first action in any given list of actions.
5690  * At this point we do not have all information required to build it. So try to
5691  * build sample action as complete as possible. */
5692 static void
5693 add_sflow_action(struct action_xlate_ctx *ctx)
5694 {
5695     ctx->user_cookie_offset = compose_sflow_action(ctx->ofproto,
5696                                                    ctx->odp_actions,
5697                                                    &ctx->flow, OVSP_NONE);
5698     ctx->sflow_odp_port = 0;
5699     ctx->sflow_n_outputs = 0;
5700 }
5701
5702 /* Fix SAMPLE action according to data collected while composing ODP actions.
5703  * We need to fix SAMPLE actions OVS_SAMPLE_ATTR_ACTIONS attribute, i.e. nested
5704  * USERSPACE action's user-cookie which is required for sflow. */
5705 static void
5706 fix_sflow_action(struct action_xlate_ctx *ctx)
5707 {
5708     const struct flow *base = &ctx->base_flow;
5709     union user_action_cookie *cookie;
5710
5711     if (!ctx->user_cookie_offset) {
5712         return;
5713     }
5714
5715     cookie = ofpbuf_at(ctx->odp_actions, ctx->user_cookie_offset,
5716                        sizeof(*cookie));
5717     ovs_assert(cookie->type == USER_ACTION_COOKIE_SFLOW);
5718
5719     compose_sflow_cookie(ctx->ofproto, base->vlan_tci,
5720                          ctx->sflow_odp_port, ctx->sflow_n_outputs, cookie);
5721 }
5722
5723 static void
5724 compose_output_action__(struct action_xlate_ctx *ctx, uint16_t ofp_port,
5725                         bool check_stp)
5726 {
5727     const struct ofport_dpif *ofport = get_ofp_port(ctx->ofproto, ofp_port);
5728     ovs_be16 flow_vlan_tci = ctx->flow.vlan_tci;
5729     ovs_be64 flow_tun_id = ctx->flow.tunnel.tun_id;
5730     uint8_t flow_nw_tos = ctx->flow.nw_tos;
5731     struct priority_to_dscp *pdscp;
5732     uint32_t out_port, odp_port;
5733
5734     /* If 'struct flow' gets additional metadata, we'll need to zero it out
5735      * before traversing a patch port. */
5736     BUILD_ASSERT_DECL(FLOW_WC_SEQ == 18);
5737
5738     if (!ofport) {
5739         xlate_report(ctx, "Nonexistent output port");
5740         return;
5741     } else if (ofport->up.pp.config & OFPUTIL_PC_NO_FWD) {
5742         xlate_report(ctx, "OFPPC_NO_FWD set, skipping output");
5743         return;
5744     } else if (check_stp && !stp_forward_in_state(ofport->stp_state)) {
5745         xlate_report(ctx, "STP not in forwarding state, skipping output");
5746         return;
5747     }
5748
5749     if (netdev_vport_is_patch(ofport->up.netdev)) {
5750         struct ofport_dpif *peer = ofport_get_peer(ofport);
5751         struct flow old_flow = ctx->flow;
5752         const struct ofproto_dpif *peer_ofproto;
5753         enum slow_path_reason special;
5754         struct ofport_dpif *in_port;
5755
5756         if (!peer) {
5757             xlate_report(ctx, "Nonexistent patch port peer");
5758             return;
5759         }
5760
5761         peer_ofproto = ofproto_dpif_cast(peer->up.ofproto);
5762         if (peer_ofproto->backer != ctx->ofproto->backer) {
5763             xlate_report(ctx, "Patch port peer on a different datapath");
5764             return;
5765         }
5766
5767         ctx->ofproto = ofproto_dpif_cast(peer->up.ofproto);
5768         ctx->flow.in_port = peer->up.ofp_port;
5769         ctx->flow.metadata = htonll(0);
5770         memset(&ctx->flow.tunnel, 0, sizeof ctx->flow.tunnel);
5771         memset(ctx->flow.regs, 0, sizeof ctx->flow.regs);
5772
5773         in_port = get_ofp_port(ctx->ofproto, ctx->flow.in_port);
5774         special = process_special(ctx->ofproto, &ctx->flow, in_port,
5775                                   ctx->packet);
5776         if (special) {
5777             ctx->slow |= special;
5778         } else if (!in_port || may_receive(in_port, ctx)) {
5779             if (!in_port || stp_forward_in_state(in_port->stp_state)) {
5780                 xlate_table_action(ctx, ctx->flow.in_port, 0, true);
5781             } else {
5782                 /* Forwarding is disabled by STP.  Let OFPP_NORMAL and the
5783                  * learning action look at the packet, then drop it. */
5784                 struct flow old_base_flow = ctx->base_flow;
5785                 size_t old_size = ctx->odp_actions->size;
5786                 xlate_table_action(ctx, ctx->flow.in_port, 0, true);
5787                 ctx->base_flow = old_base_flow;
5788                 ctx->odp_actions->size = old_size;
5789             }
5790         }
5791
5792         ctx->flow = old_flow;
5793         ctx->ofproto = ofproto_dpif_cast(ofport->up.ofproto);
5794
5795         if (ctx->resubmit_stats) {
5796             netdev_vport_inc_tx(ofport->up.netdev, ctx->resubmit_stats);
5797             netdev_vport_inc_rx(peer->up.netdev, ctx->resubmit_stats);
5798         }
5799
5800         return;
5801     }
5802
5803     pdscp = get_priority(ofport, ctx->flow.skb_priority);
5804     if (pdscp) {
5805         ctx->flow.nw_tos &= ~IP_DSCP_MASK;
5806         ctx->flow.nw_tos |= pdscp->dscp;
5807     }
5808
5809     odp_port = ofp_port_to_odp_port(ctx->ofproto, ofp_port);
5810     if (ofport->tnl_port) {
5811         odp_port = tnl_port_send(ofport->tnl_port, &ctx->flow);
5812         if (odp_port == OVSP_NONE) {
5813             xlate_report(ctx, "Tunneling decided against output");
5814             return;
5815         }
5816
5817         if (ctx->resubmit_stats) {
5818             netdev_vport_inc_tx(ofport->up.netdev, ctx->resubmit_stats);
5819         }
5820         out_port = odp_port;
5821         commit_odp_tunnel_action(&ctx->flow, &ctx->base_flow,
5822                                  ctx->odp_actions);
5823     } else {
5824         out_port = vsp_realdev_to_vlandev(ctx->ofproto, odp_port,
5825                                           ctx->flow.vlan_tci);
5826         if (out_port != odp_port) {
5827             ctx->flow.vlan_tci = htons(0);
5828         }
5829     }
5830     commit_odp_actions(&ctx->flow, &ctx->base_flow, ctx->odp_actions);
5831     nl_msg_put_u32(ctx->odp_actions, OVS_ACTION_ATTR_OUTPUT, out_port);
5832
5833     ctx->sflow_odp_port = odp_port;
5834     ctx->sflow_n_outputs++;
5835     ctx->nf_output_iface = ofp_port;
5836     ctx->flow.tunnel.tun_id = flow_tun_id;
5837     ctx->flow.vlan_tci = flow_vlan_tci;
5838     ctx->flow.nw_tos = flow_nw_tos;
5839 }
5840
5841 static void
5842 compose_output_action(struct action_xlate_ctx *ctx, uint16_t ofp_port)
5843 {
5844     compose_output_action__(ctx, ofp_port, true);
5845 }
5846
5847 static void
5848 xlate_table_action(struct action_xlate_ctx *ctx,
5849                    uint16_t in_port, uint8_t table_id, bool may_packet_in)
5850 {
5851     if (ctx->recurse < MAX_RESUBMIT_RECURSION) {
5852         struct ofproto_dpif *ofproto = ctx->ofproto;
5853         struct rule_dpif *rule;
5854         uint16_t old_in_port;
5855         uint8_t old_table_id;
5856
5857         old_table_id = ctx->table_id;
5858         ctx->table_id = table_id;
5859
5860         /* Look up a flow with 'in_port' as the input port. */
5861         old_in_port = ctx->flow.in_port;
5862         ctx->flow.in_port = in_port;
5863         rule = rule_dpif_lookup__(ofproto, &ctx->flow, table_id);
5864
5865         /* Tag the flow. */
5866         if (table_id > 0 && table_id < N_TABLES) {
5867             struct table_dpif *table = &ofproto->tables[table_id];
5868             if (table->other_table) {
5869                 ctx->tags |= (rule && rule->tag
5870                               ? rule->tag
5871                               : rule_calculate_tag(&ctx->flow,
5872                                                    &table->other_table->mask,
5873                                                    table->basis));
5874             }
5875         }
5876
5877         /* Restore the original input port.  Otherwise OFPP_NORMAL and
5878          * OFPP_IN_PORT will have surprising behavior. */
5879         ctx->flow.in_port = old_in_port;
5880
5881         if (ctx->resubmit_hook) {
5882             ctx->resubmit_hook(ctx, rule);
5883         }
5884
5885         if (rule == NULL && may_packet_in) {
5886             /* XXX
5887              * check if table configuration flags
5888              * OFPTC_TABLE_MISS_CONTROLLER, default.
5889              * OFPTC_TABLE_MISS_CONTINUE,
5890              * OFPTC_TABLE_MISS_DROP
5891              * When OF1.0, OFPTC_TABLE_MISS_CONTINUE is used. What to do?
5892              */
5893             rule = rule_dpif_miss_rule(ofproto, &ctx->flow);
5894         }
5895
5896         if (rule) {
5897             struct rule_dpif *old_rule = ctx->rule;
5898
5899             if (ctx->resubmit_stats) {
5900                 rule_credit_stats(rule, ctx->resubmit_stats);
5901             }
5902
5903             ctx->recurse++;
5904             ctx->rule = rule;
5905             do_xlate_actions(rule->up.ofpacts, rule->up.ofpacts_len, ctx);
5906             ctx->rule = old_rule;
5907             ctx->recurse--;
5908         }
5909
5910         ctx->table_id = old_table_id;
5911     } else {
5912         static struct vlog_rate_limit recurse_rl = VLOG_RATE_LIMIT_INIT(1, 1);
5913
5914         VLOG_ERR_RL(&recurse_rl, "resubmit actions recursed over %d times",
5915                     MAX_RESUBMIT_RECURSION);
5916         ctx->max_resubmit_trigger = true;
5917     }
5918 }
5919
5920 static void
5921 xlate_ofpact_resubmit(struct action_xlate_ctx *ctx,
5922                       const struct ofpact_resubmit *resubmit)
5923 {
5924     uint16_t in_port;
5925     uint8_t table_id;
5926
5927     in_port = resubmit->in_port;
5928     if (in_port == OFPP_IN_PORT) {
5929         in_port = ctx->flow.in_port;
5930     }
5931
5932     table_id = resubmit->table_id;
5933     if (table_id == 255) {
5934         table_id = ctx->table_id;
5935     }
5936
5937     xlate_table_action(ctx, in_port, table_id, false);
5938 }
5939
5940 static void
5941 flood_packets(struct action_xlate_ctx *ctx, bool all)
5942 {
5943     struct ofport_dpif *ofport;
5944
5945     HMAP_FOR_EACH (ofport, up.hmap_node, &ctx->ofproto->up.ports) {
5946         uint16_t ofp_port = ofport->up.ofp_port;
5947
5948         if (ofp_port == ctx->flow.in_port) {
5949             continue;
5950         }
5951
5952         if (all) {
5953             compose_output_action__(ctx, ofp_port, false);
5954         } else if (!(ofport->up.pp.config & OFPUTIL_PC_NO_FLOOD)) {
5955             compose_output_action(ctx, ofp_port);
5956         }
5957     }
5958
5959     ctx->nf_output_iface = NF_OUT_FLOOD;
5960 }
5961
5962 static void
5963 execute_controller_action(struct action_xlate_ctx *ctx, int len,
5964                           enum ofp_packet_in_reason reason,
5965                           uint16_t controller_id)
5966 {
5967     struct ofputil_packet_in pin;
5968     struct ofpbuf *packet;
5969
5970     ctx->slow |= SLOW_CONTROLLER;
5971     if (!ctx->packet) {
5972         return;
5973     }
5974
5975     packet = ofpbuf_clone(ctx->packet);
5976
5977     if (packet->l2 && packet->l3) {
5978         struct eth_header *eh;
5979
5980         eth_pop_vlan(packet);
5981         eh = packet->l2;
5982
5983         /* If the Ethernet type is less than ETH_TYPE_MIN, it's likely an 802.2
5984          * LLC frame.  Calculating the Ethernet type of these frames is more
5985          * trouble than seems appropriate for a simple assertion. */
5986         ovs_assert(ntohs(eh->eth_type) < ETH_TYPE_MIN
5987                    || eh->eth_type == ctx->flow.dl_type);
5988
5989         memcpy(eh->eth_src, ctx->flow.dl_src, sizeof eh->eth_src);
5990         memcpy(eh->eth_dst, ctx->flow.dl_dst, sizeof eh->eth_dst);
5991
5992         if (ctx->flow.vlan_tci & htons(VLAN_CFI)) {
5993             eth_push_vlan(packet, ctx->flow.vlan_tci);
5994         }
5995
5996         if (packet->l4) {
5997             if (ctx->flow.dl_type == htons(ETH_TYPE_IP)) {
5998                 packet_set_ipv4(packet, ctx->flow.nw_src, ctx->flow.nw_dst,
5999                                 ctx->flow.nw_tos, ctx->flow.nw_ttl);
6000             }
6001
6002             if (packet->l7) {
6003                 if (ctx->flow.nw_proto == IPPROTO_TCP) {
6004                     packet_set_tcp_port(packet, ctx->flow.tp_src,
6005                                         ctx->flow.tp_dst);
6006                 } else if (ctx->flow.nw_proto == IPPROTO_UDP) {
6007                     packet_set_udp_port(packet, ctx->flow.tp_src,
6008                                         ctx->flow.tp_dst);
6009                 }
6010             }
6011         }
6012     }
6013
6014     pin.packet = packet->data;
6015     pin.packet_len = packet->size;
6016     pin.reason = reason;
6017     pin.controller_id = controller_id;
6018     pin.table_id = ctx->table_id;
6019     pin.cookie = ctx->rule ? ctx->rule->up.flow_cookie : 0;
6020
6021     pin.send_len = len;
6022     flow_get_metadata(&ctx->flow, &pin.fmd);
6023
6024     connmgr_send_packet_in(ctx->ofproto->up.connmgr, &pin);
6025     ofpbuf_delete(packet);
6026 }
6027
6028 static bool
6029 compose_dec_ttl(struct action_xlate_ctx *ctx, struct ofpact_cnt_ids *ids)
6030 {
6031     if (ctx->flow.dl_type != htons(ETH_TYPE_IP) &&
6032         ctx->flow.dl_type != htons(ETH_TYPE_IPV6)) {
6033         return false;
6034     }
6035
6036     if (ctx->flow.nw_ttl > 1) {
6037         ctx->flow.nw_ttl--;
6038         return false;
6039     } else {
6040         size_t i;
6041
6042         for (i = 0; i < ids->n_controllers; i++) {
6043             execute_controller_action(ctx, UINT16_MAX, OFPR_INVALID_TTL,
6044                                       ids->cnt_ids[i]);
6045         }
6046
6047         /* Stop processing for current table. */
6048         return true;
6049     }
6050 }
6051
6052 static void
6053 xlate_output_action(struct action_xlate_ctx *ctx,
6054                     uint16_t port, uint16_t max_len, bool may_packet_in)
6055 {
6056     uint16_t prev_nf_output_iface = ctx->nf_output_iface;
6057
6058     ctx->nf_output_iface = NF_OUT_DROP;
6059
6060     switch (port) {
6061     case OFPP_IN_PORT:
6062         compose_output_action(ctx, ctx->flow.in_port);
6063         break;
6064     case OFPP_TABLE:
6065         xlate_table_action(ctx, ctx->flow.in_port, 0, may_packet_in);
6066         break;
6067     case OFPP_NORMAL:
6068         xlate_normal(ctx);
6069         break;
6070     case OFPP_FLOOD:
6071         flood_packets(ctx,  false);
6072         break;
6073     case OFPP_ALL:
6074         flood_packets(ctx, true);
6075         break;
6076     case OFPP_CONTROLLER:
6077         execute_controller_action(ctx, max_len, OFPR_ACTION, 0);
6078         break;
6079     case OFPP_NONE:
6080         break;
6081     case OFPP_LOCAL:
6082     default:
6083         if (port != ctx->flow.in_port) {
6084             compose_output_action(ctx, port);
6085         } else {
6086             xlate_report(ctx, "skipping output to input port");
6087         }
6088         break;
6089     }
6090
6091     if (prev_nf_output_iface == NF_OUT_FLOOD) {
6092         ctx->nf_output_iface = NF_OUT_FLOOD;
6093     } else if (ctx->nf_output_iface == NF_OUT_DROP) {
6094         ctx->nf_output_iface = prev_nf_output_iface;
6095     } else if (prev_nf_output_iface != NF_OUT_DROP &&
6096                ctx->nf_output_iface != NF_OUT_FLOOD) {
6097         ctx->nf_output_iface = NF_OUT_MULTI;
6098     }
6099 }
6100
6101 static void
6102 xlate_output_reg_action(struct action_xlate_ctx *ctx,
6103                         const struct ofpact_output_reg *or)
6104 {
6105     uint64_t port = mf_get_subfield(&or->src, &ctx->flow);
6106     if (port <= UINT16_MAX) {
6107         xlate_output_action(ctx, port, or->max_len, false);
6108     }
6109 }
6110
6111 static void
6112 xlate_enqueue_action(struct action_xlate_ctx *ctx,
6113                      const struct ofpact_enqueue *enqueue)
6114 {
6115     uint16_t ofp_port = enqueue->port;
6116     uint32_t queue_id = enqueue->queue;
6117     uint32_t flow_priority, priority;
6118     int error;
6119
6120     /* Translate queue to priority. */
6121     error = dpif_queue_to_priority(ctx->ofproto->backer->dpif,
6122                                    queue_id, &priority);
6123     if (error) {
6124         /* Fall back to ordinary output action. */
6125         xlate_output_action(ctx, enqueue->port, 0, false);
6126         return;
6127     }
6128
6129     /* Check output port. */
6130     if (ofp_port == OFPP_IN_PORT) {
6131         ofp_port = ctx->flow.in_port;
6132     } else if (ofp_port == ctx->flow.in_port) {
6133         return;
6134     }
6135
6136     /* Add datapath actions. */
6137     flow_priority = ctx->flow.skb_priority;
6138     ctx->flow.skb_priority = priority;
6139     compose_output_action(ctx, ofp_port);
6140     ctx->flow.skb_priority = flow_priority;
6141
6142     /* Update NetFlow output port. */
6143     if (ctx->nf_output_iface == NF_OUT_DROP) {
6144         ctx->nf_output_iface = ofp_port;
6145     } else if (ctx->nf_output_iface != NF_OUT_FLOOD) {
6146         ctx->nf_output_iface = NF_OUT_MULTI;
6147     }
6148 }
6149
6150 static void
6151 xlate_set_queue_action(struct action_xlate_ctx *ctx, uint32_t queue_id)
6152 {
6153     uint32_t skb_priority;
6154
6155     if (!dpif_queue_to_priority(ctx->ofproto->backer->dpif,
6156                                 queue_id, &skb_priority)) {
6157         ctx->flow.skb_priority = skb_priority;
6158     } else {
6159         /* Couldn't translate queue to a priority.  Nothing to do.  A warning
6160          * has already been logged. */
6161     }
6162 }
6163
6164 struct xlate_reg_state {
6165     ovs_be16 vlan_tci;
6166     ovs_be64 tun_id;
6167 };
6168
6169 static void
6170 xlate_autopath(struct action_xlate_ctx *ctx,
6171                const struct ofpact_autopath *ap)
6172 {
6173     uint16_t ofp_port = ap->port;
6174     struct ofport_dpif *port = get_ofp_port(ctx->ofproto, ofp_port);
6175
6176     if (!port || !port->bundle) {
6177         ofp_port = OFPP_NONE;
6178     } else if (port->bundle->bond) {
6179         /* Autopath does not support VLAN hashing. */
6180         struct ofport_dpif *slave = bond_choose_output_slave(
6181             port->bundle->bond, &ctx->flow, 0, &ctx->tags);
6182         if (slave) {
6183             ofp_port = slave->up.ofp_port;
6184         }
6185     }
6186     nxm_reg_load(&ap->dst, ofp_port, &ctx->flow);
6187 }
6188
6189 static bool
6190 slave_enabled_cb(uint16_t ofp_port, void *ofproto_)
6191 {
6192     struct ofproto_dpif *ofproto = ofproto_;
6193     struct ofport_dpif *port;
6194
6195     switch (ofp_port) {
6196     case OFPP_IN_PORT:
6197     case OFPP_TABLE:
6198     case OFPP_NORMAL:
6199     case OFPP_FLOOD:
6200     case OFPP_ALL:
6201     case OFPP_NONE:
6202         return true;
6203     case OFPP_CONTROLLER: /* Not supported by the bundle action. */
6204         return false;
6205     default:
6206         port = get_ofp_port(ofproto, ofp_port);
6207         return port ? port->may_enable : false;
6208     }
6209 }
6210
6211 static void
6212 xlate_bundle_action(struct action_xlate_ctx *ctx,
6213                     const struct ofpact_bundle *bundle)
6214 {
6215     uint16_t port;
6216
6217     port = bundle_execute(bundle, &ctx->flow, slave_enabled_cb, ctx->ofproto);
6218     if (bundle->dst.field) {
6219         nxm_reg_load(&bundle->dst, port, &ctx->flow);
6220     } else {
6221         xlate_output_action(ctx, port, 0, false);
6222     }
6223 }
6224
6225 static void
6226 xlate_learn_action(struct action_xlate_ctx *ctx,
6227                    const struct ofpact_learn *learn)
6228 {
6229     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(5, 1);
6230     struct ofputil_flow_mod fm;
6231     uint64_t ofpacts_stub[1024 / 8];
6232     struct ofpbuf ofpacts;
6233     int error;
6234
6235     ofpbuf_use_stack(&ofpacts, ofpacts_stub, sizeof ofpacts_stub);
6236     learn_execute(learn, &ctx->flow, &fm, &ofpacts);
6237
6238     error = ofproto_flow_mod(&ctx->ofproto->up, &fm);
6239     if (error && !VLOG_DROP_WARN(&rl)) {
6240         VLOG_WARN("learning action failed to modify flow table (%s)",
6241                   ofperr_get_name(error));
6242     }
6243
6244     ofpbuf_uninit(&ofpacts);
6245 }
6246
6247 /* Reduces '*timeout' to no more than 'max'.  A value of zero in either case
6248  * means "infinite". */
6249 static void
6250 reduce_timeout(uint16_t max, uint16_t *timeout)
6251 {
6252     if (max && (!*timeout || *timeout > max)) {
6253         *timeout = max;
6254     }
6255 }
6256
6257 static void
6258 xlate_fin_timeout(struct action_xlate_ctx *ctx,
6259                   const struct ofpact_fin_timeout *oft)
6260 {
6261     if (ctx->tcp_flags & (TCP_FIN | TCP_RST) && ctx->rule) {
6262         struct rule_dpif *rule = ctx->rule;
6263
6264         reduce_timeout(oft->fin_idle_timeout, &rule->up.idle_timeout);
6265         reduce_timeout(oft->fin_hard_timeout, &rule->up.hard_timeout);
6266     }
6267 }
6268
6269 static bool
6270 may_receive(const struct ofport_dpif *port, struct action_xlate_ctx *ctx)
6271 {
6272     if (port->up.pp.config & (eth_addr_equals(ctx->flow.dl_dst, eth_addr_stp)
6273                               ? OFPUTIL_PC_NO_RECV_STP
6274                               : OFPUTIL_PC_NO_RECV)) {
6275         return false;
6276     }
6277
6278     /* Only drop packets here if both forwarding and learning are
6279      * disabled.  If just learning is enabled, we need to have
6280      * OFPP_NORMAL and the learning action have a look at the packet
6281      * before we can drop it. */
6282     if (!stp_forward_in_state(port->stp_state)
6283             && !stp_learn_in_state(port->stp_state)) {
6284         return false;
6285     }
6286
6287     return true;
6288 }
6289
6290 static void
6291 do_xlate_actions(const struct ofpact *ofpacts, size_t ofpacts_len,
6292                  struct action_xlate_ctx *ctx)
6293 {
6294     bool was_evictable = true;
6295     const struct ofpact *a;
6296
6297     if (ctx->rule) {
6298         /* Don't let the rule we're working on get evicted underneath us. */
6299         was_evictable = ctx->rule->up.evictable;
6300         ctx->rule->up.evictable = false;
6301     }
6302     OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) {
6303         struct ofpact_controller *controller;
6304         const struct ofpact_metadata *metadata;
6305
6306         if (ctx->exit) {
6307             break;
6308         }
6309
6310         switch (a->type) {
6311         case OFPACT_OUTPUT:
6312             xlate_output_action(ctx, ofpact_get_OUTPUT(a)->port,
6313                                 ofpact_get_OUTPUT(a)->max_len, true);
6314             break;
6315
6316         case OFPACT_CONTROLLER:
6317             controller = ofpact_get_CONTROLLER(a);
6318             execute_controller_action(ctx, controller->max_len,
6319                                       controller->reason,
6320                                       controller->controller_id);
6321             break;
6322
6323         case OFPACT_ENQUEUE:
6324             xlate_enqueue_action(ctx, ofpact_get_ENQUEUE(a));
6325             break;
6326
6327         case OFPACT_SET_VLAN_VID:
6328             ctx->flow.vlan_tci &= ~htons(VLAN_VID_MASK);
6329             ctx->flow.vlan_tci |= (htons(ofpact_get_SET_VLAN_VID(a)->vlan_vid)
6330                                    | htons(VLAN_CFI));
6331             break;
6332
6333         case OFPACT_SET_VLAN_PCP:
6334             ctx->flow.vlan_tci &= ~htons(VLAN_PCP_MASK);
6335             ctx->flow.vlan_tci |= htons((ofpact_get_SET_VLAN_PCP(a)->vlan_pcp
6336                                          << VLAN_PCP_SHIFT)
6337                                         | VLAN_CFI);
6338             break;
6339
6340         case OFPACT_STRIP_VLAN:
6341             ctx->flow.vlan_tci = htons(0);
6342             break;
6343
6344         case OFPACT_PUSH_VLAN:
6345             /* XXX 802.1AD(QinQ) */
6346             ctx->flow.vlan_tci = htons(VLAN_CFI);
6347             break;
6348
6349         case OFPACT_SET_ETH_SRC:
6350             memcpy(ctx->flow.dl_src, ofpact_get_SET_ETH_SRC(a)->mac,
6351                    ETH_ADDR_LEN);
6352             break;
6353
6354         case OFPACT_SET_ETH_DST:
6355             memcpy(ctx->flow.dl_dst, ofpact_get_SET_ETH_DST(a)->mac,
6356                    ETH_ADDR_LEN);
6357             break;
6358
6359         case OFPACT_SET_IPV4_SRC:
6360             ctx->flow.nw_src = ofpact_get_SET_IPV4_SRC(a)->ipv4;
6361             break;
6362
6363         case OFPACT_SET_IPV4_DST:
6364             ctx->flow.nw_dst = ofpact_get_SET_IPV4_DST(a)->ipv4;
6365             break;
6366
6367         case OFPACT_SET_IPV4_DSCP:
6368             /* OpenFlow 1.0 only supports IPv4. */
6369             if (ctx->flow.dl_type == htons(ETH_TYPE_IP)) {
6370                 ctx->flow.nw_tos &= ~IP_DSCP_MASK;
6371                 ctx->flow.nw_tos |= ofpact_get_SET_IPV4_DSCP(a)->dscp;
6372             }
6373             break;
6374
6375         case OFPACT_SET_L4_SRC_PORT:
6376             ctx->flow.tp_src = htons(ofpact_get_SET_L4_SRC_PORT(a)->port);
6377             break;
6378
6379         case OFPACT_SET_L4_DST_PORT:
6380             ctx->flow.tp_dst = htons(ofpact_get_SET_L4_DST_PORT(a)->port);
6381             break;
6382
6383         case OFPACT_RESUBMIT:
6384             xlate_ofpact_resubmit(ctx, ofpact_get_RESUBMIT(a));
6385             break;
6386
6387         case OFPACT_SET_TUNNEL:
6388             ctx->flow.tunnel.tun_id = htonll(ofpact_get_SET_TUNNEL(a)->tun_id);
6389             break;
6390
6391         case OFPACT_SET_QUEUE:
6392             xlate_set_queue_action(ctx, ofpact_get_SET_QUEUE(a)->queue_id);
6393             break;
6394
6395         case OFPACT_POP_QUEUE:
6396             ctx->flow.skb_priority = ctx->orig_skb_priority;
6397             break;
6398
6399         case OFPACT_REG_MOVE:
6400             nxm_execute_reg_move(ofpact_get_REG_MOVE(a), &ctx->flow);
6401             break;
6402
6403         case OFPACT_REG_LOAD:
6404             nxm_execute_reg_load(ofpact_get_REG_LOAD(a), &ctx->flow);
6405             break;
6406
6407         case OFPACT_DEC_TTL:
6408             if (compose_dec_ttl(ctx, ofpact_get_DEC_TTL(a))) {
6409                 goto out;
6410             }
6411             break;
6412
6413         case OFPACT_NOTE:
6414             /* Nothing to do. */
6415             break;
6416
6417         case OFPACT_MULTIPATH:
6418             multipath_execute(ofpact_get_MULTIPATH(a), &ctx->flow);
6419             break;
6420
6421         case OFPACT_AUTOPATH:
6422             xlate_autopath(ctx, ofpact_get_AUTOPATH(a));
6423             break;
6424
6425         case OFPACT_BUNDLE:
6426             ctx->ofproto->has_bundle_action = true;
6427             xlate_bundle_action(ctx, ofpact_get_BUNDLE(a));
6428             break;
6429
6430         case OFPACT_OUTPUT_REG:
6431             xlate_output_reg_action(ctx, ofpact_get_OUTPUT_REG(a));
6432             break;
6433
6434         case OFPACT_LEARN:
6435             ctx->has_learn = true;
6436             if (ctx->may_learn) {
6437                 xlate_learn_action(ctx, ofpact_get_LEARN(a));
6438             }
6439             break;
6440
6441         case OFPACT_EXIT:
6442             ctx->exit = true;
6443             break;
6444
6445         case OFPACT_FIN_TIMEOUT:
6446             ctx->has_fin_timeout = true;
6447             xlate_fin_timeout(ctx, ofpact_get_FIN_TIMEOUT(a));
6448             break;
6449
6450         case OFPACT_CLEAR_ACTIONS:
6451             /* XXX
6452              * Nothing to do because writa-actions is not supported for now.
6453              * When writa-actions is supported, clear-actions also must
6454              * be supported at the same time.
6455              */
6456             break;
6457
6458         case OFPACT_WRITE_METADATA:
6459             metadata = ofpact_get_WRITE_METADATA(a);
6460             ctx->flow.metadata &= ~metadata->mask;
6461             ctx->flow.metadata |= metadata->metadata & metadata->mask;
6462             break;
6463
6464         case OFPACT_GOTO_TABLE: {
6465             /* XXX remove recursion */
6466             /* It is assumed that goto-table is last action */
6467             struct ofpact_goto_table *ogt = ofpact_get_GOTO_TABLE(a);
6468             ovs_assert(ctx->table_id < ogt->table_id);
6469             xlate_table_action(ctx, ctx->flow.in_port, ogt->table_id, true);
6470             break;
6471         }
6472         }
6473     }
6474
6475 out:
6476     if (ctx->rule) {
6477         ctx->rule->up.evictable = was_evictable;
6478     }
6479 }
6480
6481 static void
6482 action_xlate_ctx_init(struct action_xlate_ctx *ctx,
6483                       struct ofproto_dpif *ofproto, const struct flow *flow,
6484                       ovs_be16 initial_tci, struct rule_dpif *rule,
6485                       uint8_t tcp_flags, const struct ofpbuf *packet)
6486 {
6487     ovs_be64 initial_tun_id = flow->tunnel.tun_id;
6488
6489     /* Flow initialization rules:
6490      * - 'base_flow' must match the kernel's view of the packet at the
6491      *   time that action processing starts.  'flow' represents any
6492      *   transformations we wish to make through actions.
6493      * - By default 'base_flow' and 'flow' are the same since the input
6494      *   packet matches the output before any actions are applied.
6495      * - When using VLAN splinters, 'base_flow''s VLAN is set to the value
6496      *   of the received packet as seen by the kernel.  If we later output
6497      *   to another device without any modifications this will cause us to
6498      *   insert a new tag since the original one was stripped off by the
6499      *   VLAN device.
6500      * - Tunnel 'flow' is largely cleared when transitioning between
6501      *   the input and output stages since it does not make sense to output
6502      *   a packet with the exact headers that it was received with (i.e.
6503      *   the destination IP is us).  The one exception is the tun_id, which
6504      *   is preserved to allow use in later resubmit lookups and loads into
6505      *   registers.
6506      * - Tunnel 'base_flow' is completely cleared since that is what the
6507      *   kernel does.  If we wish to maintain the original values an action
6508      *   needs to be generated. */
6509
6510     ctx->ofproto = ofproto;
6511     ctx->flow = *flow;
6512     memset(&ctx->flow.tunnel, 0, sizeof ctx->flow.tunnel);
6513     ctx->base_flow = ctx->flow;
6514     ctx->base_flow.vlan_tci = initial_tci;
6515     ctx->flow.tunnel.tun_id = initial_tun_id;
6516     ctx->rule = rule;
6517     ctx->packet = packet;
6518     ctx->may_learn = packet != NULL;
6519     ctx->tcp_flags = tcp_flags;
6520     ctx->resubmit_hook = NULL;
6521     ctx->report_hook = NULL;
6522     ctx->resubmit_stats = NULL;
6523 }
6524
6525 /* Translates the 'ofpacts_len' bytes of "struct ofpacts" starting at 'ofpacts'
6526  * into datapath actions in 'odp_actions', using 'ctx'. */
6527 static void
6528 xlate_actions(struct action_xlate_ctx *ctx,
6529               const struct ofpact *ofpacts, size_t ofpacts_len,
6530               struct ofpbuf *odp_actions)
6531 {
6532     /* Normally false.  Set to true if we ever hit MAX_RESUBMIT_RECURSION, so
6533      * that in the future we always keep a copy of the original flow for
6534      * tracing purposes. */
6535     static bool hit_resubmit_limit;
6536
6537     enum slow_path_reason special;
6538     struct ofport_dpif *in_port;
6539
6540     COVERAGE_INC(ofproto_dpif_xlate);
6541
6542     ofpbuf_clear(odp_actions);
6543     ofpbuf_reserve(odp_actions, NL_A_U32_SIZE);
6544
6545     ctx->odp_actions = odp_actions;
6546     ctx->tags = 0;
6547     ctx->slow = 0;
6548     ctx->has_learn = false;
6549     ctx->has_normal = false;
6550     ctx->has_fin_timeout = false;
6551     ctx->nf_output_iface = NF_OUT_DROP;
6552     ctx->mirrors = 0;
6553     ctx->recurse = 0;
6554     ctx->max_resubmit_trigger = false;
6555     ctx->orig_skb_priority = ctx->flow.skb_priority;
6556     ctx->table_id = 0;
6557     ctx->exit = false;
6558
6559     if (ctx->ofproto->has_mirrors || hit_resubmit_limit) {
6560         /* Do this conditionally because the copy is expensive enough that it
6561          * shows up in profiles.
6562          *
6563          * We keep orig_flow in 'ctx' only because I couldn't make GCC 4.4
6564          * believe that I wasn't using it without initializing it if I kept it
6565          * in a local variable. */
6566         ctx->orig_flow = ctx->flow;
6567     }
6568
6569     if (ctx->flow.nw_frag & FLOW_NW_FRAG_ANY) {
6570         switch (ctx->ofproto->up.frag_handling) {
6571         case OFPC_FRAG_NORMAL:
6572             /* We must pretend that transport ports are unavailable. */
6573             ctx->flow.tp_src = ctx->base_flow.tp_src = htons(0);
6574             ctx->flow.tp_dst = ctx->base_flow.tp_dst = htons(0);
6575             break;
6576
6577         case OFPC_FRAG_DROP:
6578             return;
6579
6580         case OFPC_FRAG_REASM:
6581             NOT_REACHED();
6582
6583         case OFPC_FRAG_NX_MATCH:
6584             /* Nothing to do. */
6585             break;
6586
6587         case OFPC_INVALID_TTL_TO_CONTROLLER:
6588             NOT_REACHED();
6589         }
6590     }
6591
6592     in_port = get_ofp_port(ctx->ofproto, ctx->flow.in_port);
6593     special = process_special(ctx->ofproto, &ctx->flow, in_port, ctx->packet);
6594     if (special) {
6595         ctx->slow |= special;
6596     } else {
6597         static struct vlog_rate_limit trace_rl = VLOG_RATE_LIMIT_INIT(1, 1);
6598         ovs_be16 initial_tci = ctx->base_flow.vlan_tci;
6599         uint32_t local_odp_port;
6600
6601         add_sflow_action(ctx);
6602
6603         if (!in_port || may_receive(in_port, ctx)) {
6604             do_xlate_actions(ofpacts, ofpacts_len, ctx);
6605
6606             /* We've let OFPP_NORMAL and the learning action look at the
6607              * packet, so drop it now if forwarding is disabled. */
6608             if (in_port && !stp_forward_in_state(in_port->stp_state)) {
6609                 ofpbuf_clear(ctx->odp_actions);
6610                 add_sflow_action(ctx);
6611             }
6612         }
6613
6614         if (ctx->max_resubmit_trigger && !ctx->resubmit_hook) {
6615             if (!hit_resubmit_limit) {
6616                 /* We didn't record the original flow.  Make sure we do from
6617                  * now on. */
6618                 hit_resubmit_limit = true;
6619             } else if (!VLOG_DROP_ERR(&trace_rl)) {
6620                 struct ds ds = DS_EMPTY_INITIALIZER;
6621
6622                 ofproto_trace(ctx->ofproto, &ctx->orig_flow, ctx->packet,
6623                               initial_tci, &ds);
6624                 VLOG_ERR("Trace triggered by excessive resubmit "
6625                          "recursion:\n%s", ds_cstr(&ds));
6626                 ds_destroy(&ds);
6627             }
6628         }
6629
6630         local_odp_port = ofp_port_to_odp_port(ctx->ofproto, OFPP_LOCAL);
6631         if (!connmgr_may_set_up_flow(ctx->ofproto->up.connmgr, &ctx->flow,
6632                                      local_odp_port,
6633                                      ctx->odp_actions->data,
6634                                      ctx->odp_actions->size)) {
6635             ctx->slow |= SLOW_IN_BAND;
6636             if (ctx->packet
6637                 && connmgr_msg_in_hook(ctx->ofproto->up.connmgr, &ctx->flow,
6638                                        ctx->packet)) {
6639                 compose_output_action(ctx, OFPP_LOCAL);
6640             }
6641         }
6642         if (ctx->ofproto->has_mirrors) {
6643             add_mirror_actions(ctx, &ctx->orig_flow);
6644         }
6645         fix_sflow_action(ctx);
6646     }
6647 }
6648
6649 /* Translates the 'ofpacts_len' bytes of "struct ofpact"s starting at 'ofpacts'
6650  * into datapath actions, using 'ctx', and discards the datapath actions. */
6651 static void
6652 xlate_actions_for_side_effects(struct action_xlate_ctx *ctx,
6653                                const struct ofpact *ofpacts,
6654                                size_t ofpacts_len)
6655 {
6656     uint64_t odp_actions_stub[1024 / 8];
6657     struct ofpbuf odp_actions;
6658
6659     ofpbuf_use_stub(&odp_actions, odp_actions_stub, sizeof odp_actions_stub);
6660     xlate_actions(ctx, ofpacts, ofpacts_len, &odp_actions);
6661     ofpbuf_uninit(&odp_actions);
6662 }
6663
6664 static void
6665 xlate_report(struct action_xlate_ctx *ctx, const char *s)
6666 {
6667     if (ctx->report_hook) {
6668         ctx->report_hook(ctx, s);
6669     }
6670 }
6671 \f
6672 /* OFPP_NORMAL implementation. */
6673
6674 static struct ofport_dpif *ofbundle_get_a_port(const struct ofbundle *);
6675
6676 /* Given 'vid', the VID obtained from the 802.1Q header that was received as
6677  * part of a packet (specify 0 if there was no 802.1Q header), and 'in_bundle',
6678  * the bundle on which the packet was received, returns the VLAN to which the
6679  * packet belongs.
6680  *
6681  * Both 'vid' and the return value are in the range 0...4095. */
6682 static uint16_t
6683 input_vid_to_vlan(const struct ofbundle *in_bundle, uint16_t vid)
6684 {
6685     switch (in_bundle->vlan_mode) {
6686     case PORT_VLAN_ACCESS:
6687         return in_bundle->vlan;
6688         break;
6689
6690     case PORT_VLAN_TRUNK:
6691         return vid;
6692
6693     case PORT_VLAN_NATIVE_UNTAGGED:
6694     case PORT_VLAN_NATIVE_TAGGED:
6695         return vid ? vid : in_bundle->vlan;
6696
6697     default:
6698         NOT_REACHED();
6699     }
6700 }
6701
6702 /* Checks whether a packet with the given 'vid' may ingress on 'in_bundle'.
6703  * If so, returns true.  Otherwise, returns false and, if 'warn' is true, logs
6704  * a warning.
6705  *
6706  * 'vid' should be the VID obtained from the 802.1Q header that was received as
6707  * part of a packet (specify 0 if there was no 802.1Q header), in the range
6708  * 0...4095. */
6709 static bool
6710 input_vid_is_valid(uint16_t vid, struct ofbundle *in_bundle, bool warn)
6711 {
6712     /* Allow any VID on the OFPP_NONE port. */
6713     if (in_bundle == &ofpp_none_bundle) {
6714         return true;
6715     }
6716
6717     switch (in_bundle->vlan_mode) {
6718     case PORT_VLAN_ACCESS:
6719         if (vid) {
6720             if (warn) {
6721                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
6722                 VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %"PRIu16" tagged "
6723                              "packet received on port %s configured as VLAN "
6724                              "%"PRIu16" access port",
6725                              in_bundle->ofproto->up.name, vid,
6726                              in_bundle->name, in_bundle->vlan);
6727             }
6728             return false;
6729         }
6730         return true;
6731
6732     case PORT_VLAN_NATIVE_UNTAGGED:
6733     case PORT_VLAN_NATIVE_TAGGED:
6734         if (!vid) {
6735             /* Port must always carry its native VLAN. */
6736             return true;
6737         }
6738         /* Fall through. */
6739     case PORT_VLAN_TRUNK:
6740         if (!ofbundle_includes_vlan(in_bundle, vid)) {
6741             if (warn) {
6742                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
6743                 VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %"PRIu16" packet "
6744                              "received on port %s not configured for trunking "
6745                              "VLAN %"PRIu16,
6746                              in_bundle->ofproto->up.name, vid,
6747                              in_bundle->name, vid);
6748             }
6749             return false;
6750         }
6751         return true;
6752
6753     default:
6754         NOT_REACHED();
6755     }
6756
6757 }
6758
6759 /* Given 'vlan', the VLAN that a packet belongs to, and
6760  * 'out_bundle', a bundle on which the packet is to be output, returns the VID
6761  * that should be included in the 802.1Q header.  (If the return value is 0,
6762  * then the 802.1Q header should only be included in the packet if there is a
6763  * nonzero PCP.)
6764  *
6765  * Both 'vlan' and the return value are in the range 0...4095. */
6766 static uint16_t
6767 output_vlan_to_vid(const struct ofbundle *out_bundle, uint16_t vlan)
6768 {
6769     switch (out_bundle->vlan_mode) {
6770     case PORT_VLAN_ACCESS:
6771         return 0;
6772
6773     case PORT_VLAN_TRUNK:
6774     case PORT_VLAN_NATIVE_TAGGED:
6775         return vlan;
6776
6777     case PORT_VLAN_NATIVE_UNTAGGED:
6778         return vlan == out_bundle->vlan ? 0 : vlan;
6779
6780     default:
6781         NOT_REACHED();
6782     }
6783 }
6784
6785 static void
6786 output_normal(struct action_xlate_ctx *ctx, const struct ofbundle *out_bundle,
6787               uint16_t vlan)
6788 {
6789     struct ofport_dpif *port;
6790     uint16_t vid;
6791     ovs_be16 tci, old_tci;
6792
6793     vid = output_vlan_to_vid(out_bundle, vlan);
6794     if (!out_bundle->bond) {
6795         port = ofbundle_get_a_port(out_bundle);
6796     } else {
6797         port = bond_choose_output_slave(out_bundle->bond, &ctx->flow,
6798                                         vid, &ctx->tags);
6799         if (!port) {
6800             /* No slaves enabled, so drop packet. */
6801             return;
6802         }
6803     }
6804
6805     old_tci = ctx->flow.vlan_tci;
6806     tci = htons(vid);
6807     if (tci || out_bundle->use_priority_tags) {
6808         tci |= ctx->flow.vlan_tci & htons(VLAN_PCP_MASK);
6809         if (tci) {
6810             tci |= htons(VLAN_CFI);
6811         }
6812     }
6813     ctx->flow.vlan_tci = tci;
6814
6815     compose_output_action(ctx, port->up.ofp_port);
6816     ctx->flow.vlan_tci = old_tci;
6817 }
6818
6819 static int
6820 mirror_mask_ffs(mirror_mask_t mask)
6821 {
6822     BUILD_ASSERT_DECL(sizeof(unsigned int) >= sizeof(mask));
6823     return ffs(mask);
6824 }
6825
6826 static bool
6827 ofbundle_trunks_vlan(const struct ofbundle *bundle, uint16_t vlan)
6828 {
6829     return (bundle->vlan_mode != PORT_VLAN_ACCESS
6830             && (!bundle->trunks || bitmap_is_set(bundle->trunks, vlan)));
6831 }
6832
6833 static bool
6834 ofbundle_includes_vlan(const struct ofbundle *bundle, uint16_t vlan)
6835 {
6836     return vlan == bundle->vlan || ofbundle_trunks_vlan(bundle, vlan);
6837 }
6838
6839 /* Returns an arbitrary interface within 'bundle'. */
6840 static struct ofport_dpif *
6841 ofbundle_get_a_port(const struct ofbundle *bundle)
6842 {
6843     return CONTAINER_OF(list_front(&bundle->ports),
6844                         struct ofport_dpif, bundle_node);
6845 }
6846
6847 static bool
6848 vlan_is_mirrored(const struct ofmirror *m, int vlan)
6849 {
6850     return !m->vlans || bitmap_is_set(m->vlans, vlan);
6851 }
6852
6853 static void
6854 add_mirror_actions(struct action_xlate_ctx *ctx, const struct flow *orig_flow)
6855 {
6856     struct ofproto_dpif *ofproto = ctx->ofproto;
6857     mirror_mask_t mirrors;
6858     struct ofbundle *in_bundle;
6859     uint16_t vlan;
6860     uint16_t vid;
6861     const struct nlattr *a;
6862     size_t left;
6863
6864     in_bundle = lookup_input_bundle(ctx->ofproto, orig_flow->in_port,
6865                                     ctx->packet != NULL, NULL);
6866     if (!in_bundle) {
6867         return;
6868     }
6869     mirrors = in_bundle->src_mirrors;
6870
6871     /* Drop frames on bundles reserved for mirroring. */
6872     if (in_bundle->mirror_out) {
6873         if (ctx->packet != NULL) {
6874             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
6875             VLOG_WARN_RL(&rl, "bridge %s: dropping packet received on port "
6876                          "%s, which is reserved exclusively for mirroring",
6877                          ctx->ofproto->up.name, in_bundle->name);
6878         }
6879         return;
6880     }
6881
6882     /* Check VLAN. */
6883     vid = vlan_tci_to_vid(orig_flow->vlan_tci);
6884     if (!input_vid_is_valid(vid, in_bundle, ctx->packet != NULL)) {
6885         return;
6886     }
6887     vlan = input_vid_to_vlan(in_bundle, vid);
6888
6889     /* Look at the output ports to check for destination selections. */
6890
6891     NL_ATTR_FOR_EACH (a, left, ctx->odp_actions->data,
6892                       ctx->odp_actions->size) {
6893         enum ovs_action_attr type = nl_attr_type(a);
6894         struct ofport_dpif *ofport;
6895
6896         if (type != OVS_ACTION_ATTR_OUTPUT) {
6897             continue;
6898         }
6899
6900         ofport = get_odp_port(ofproto, nl_attr_get_u32(a));
6901         if (ofport && ofport->bundle) {
6902             mirrors |= ofport->bundle->dst_mirrors;
6903         }
6904     }
6905
6906     if (!mirrors) {
6907         return;
6908     }
6909
6910     /* Restore the original packet before adding the mirror actions. */
6911     ctx->flow = *orig_flow;
6912
6913     while (mirrors) {
6914         struct ofmirror *m;
6915
6916         m = ofproto->mirrors[mirror_mask_ffs(mirrors) - 1];
6917
6918         if (!vlan_is_mirrored(m, vlan)) {
6919             mirrors = zero_rightmost_1bit(mirrors);
6920             continue;
6921         }
6922
6923         mirrors &= ~m->dup_mirrors;
6924         ctx->mirrors |= m->dup_mirrors;
6925         if (m->out) {
6926             output_normal(ctx, m->out, vlan);
6927         } else if (vlan != m->out_vlan
6928                    && !eth_addr_is_reserved(orig_flow->dl_dst)) {
6929             struct ofbundle *bundle;
6930
6931             HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
6932                 if (ofbundle_includes_vlan(bundle, m->out_vlan)
6933                     && !bundle->mirror_out) {
6934                     output_normal(ctx, bundle, m->out_vlan);
6935                 }
6936             }
6937         }
6938     }
6939 }
6940
6941 static void
6942 update_mirror_stats(struct ofproto_dpif *ofproto, mirror_mask_t mirrors,
6943                     uint64_t packets, uint64_t bytes)
6944 {
6945     if (!mirrors) {
6946         return;
6947     }
6948
6949     for (; mirrors; mirrors = zero_rightmost_1bit(mirrors)) {
6950         struct ofmirror *m;
6951
6952         m = ofproto->mirrors[mirror_mask_ffs(mirrors) - 1];
6953
6954         if (!m) {
6955             /* In normal circumstances 'm' will not be NULL.  However,
6956              * if mirrors are reconfigured, we can temporarily get out
6957              * of sync in facet_revalidate().  We could "correct" the
6958              * mirror list before reaching here, but doing that would
6959              * not properly account the traffic stats we've currently
6960              * accumulated for previous mirror configuration. */
6961             continue;
6962         }
6963
6964         m->packet_count += packets;
6965         m->byte_count += bytes;
6966     }
6967 }
6968
6969 /* A VM broadcasts a gratuitous ARP to indicate that it has resumed after
6970  * migration.  Older Citrix-patched Linux DomU used gratuitous ARP replies to
6971  * indicate this; newer upstream kernels use gratuitous ARP requests. */
6972 static bool
6973 is_gratuitous_arp(const struct flow *flow)
6974 {
6975     return (flow->dl_type == htons(ETH_TYPE_ARP)
6976             && eth_addr_is_broadcast(flow->dl_dst)
6977             && (flow->nw_proto == ARP_OP_REPLY
6978                 || (flow->nw_proto == ARP_OP_REQUEST
6979                     && flow->nw_src == flow->nw_dst)));
6980 }
6981
6982 static void
6983 update_learning_table(struct ofproto_dpif *ofproto,
6984                       const struct flow *flow, int vlan,
6985                       struct ofbundle *in_bundle)
6986 {
6987     struct mac_entry *mac;
6988
6989     /* Don't learn the OFPP_NONE port. */
6990     if (in_bundle == &ofpp_none_bundle) {
6991         return;
6992     }
6993
6994     if (!mac_learning_may_learn(ofproto->ml, flow->dl_src, vlan)) {
6995         return;
6996     }
6997
6998     mac = mac_learning_insert(ofproto->ml, flow->dl_src, vlan);
6999     if (is_gratuitous_arp(flow)) {
7000         /* We don't want to learn from gratuitous ARP packets that are
7001          * reflected back over bond slaves so we lock the learning table. */
7002         if (!in_bundle->bond) {
7003             mac_entry_set_grat_arp_lock(mac);
7004         } else if (mac_entry_is_grat_arp_locked(mac)) {
7005             return;
7006         }
7007     }
7008
7009     if (mac_entry_is_new(mac) || mac->port.p != in_bundle) {
7010         /* The log messages here could actually be useful in debugging,
7011          * so keep the rate limit relatively high. */
7012         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(30, 300);
7013         VLOG_DBG_RL(&rl, "bridge %s: learned that "ETH_ADDR_FMT" is "
7014                     "on port %s in VLAN %d",
7015                     ofproto->up.name, ETH_ADDR_ARGS(flow->dl_src),
7016                     in_bundle->name, vlan);
7017
7018         mac->port.p = in_bundle;
7019         tag_set_add(&ofproto->backer->revalidate_set,
7020                     mac_learning_changed(ofproto->ml, mac));
7021     }
7022 }
7023
7024 static struct ofbundle *
7025 lookup_input_bundle(const struct ofproto_dpif *ofproto, uint16_t in_port,
7026                     bool warn, struct ofport_dpif **in_ofportp)
7027 {
7028     struct ofport_dpif *ofport;
7029
7030     /* Find the port and bundle for the received packet. */
7031     ofport = get_ofp_port(ofproto, in_port);
7032     if (in_ofportp) {
7033         *in_ofportp = ofport;
7034     }
7035     if (ofport && ofport->bundle) {
7036         return ofport->bundle;
7037     }
7038
7039     /* Special-case OFPP_NONE, which a controller may use as the ingress
7040      * port for traffic that it is sourcing. */
7041     if (in_port == OFPP_NONE) {
7042         return &ofpp_none_bundle;
7043     }
7044
7045     /* Odd.  A few possible reasons here:
7046      *
7047      * - We deleted a port but there are still a few packets queued up
7048      *   from it.
7049      *
7050      * - Someone externally added a port (e.g. "ovs-dpctl add-if") that
7051      *   we don't know about.
7052      *
7053      * - The ofproto client didn't configure the port as part of a bundle.
7054      *   This is particularly likely to happen if a packet was received on the
7055      *   port after it was created, but before the client had a chance to
7056      *   configure its bundle.
7057      */
7058     if (warn) {
7059         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
7060
7061         VLOG_WARN_RL(&rl, "bridge %s: received packet on unknown "
7062                      "port %"PRIu16, ofproto->up.name, in_port);
7063     }
7064     return NULL;
7065 }
7066
7067 /* Determines whether packets in 'flow' within 'ofproto' should be forwarded or
7068  * dropped.  Returns true if they may be forwarded, false if they should be
7069  * dropped.
7070  *
7071  * 'in_port' must be the ofport_dpif that corresponds to flow->in_port.
7072  * 'in_port' must be part of a bundle (e.g. in_port->bundle must be nonnull).
7073  *
7074  * 'vlan' must be the VLAN that corresponds to flow->vlan_tci on 'in_port', as
7075  * returned by input_vid_to_vlan().  It must be a valid VLAN for 'in_port', as
7076  * checked by input_vid_is_valid().
7077  *
7078  * May also add tags to '*tags', although the current implementation only does
7079  * so in one special case.
7080  */
7081 static bool
7082 is_admissible(struct action_xlate_ctx *ctx, struct ofport_dpif *in_port,
7083               uint16_t vlan)
7084 {
7085     struct ofproto_dpif *ofproto = ctx->ofproto;
7086     struct flow *flow = &ctx->flow;
7087     struct ofbundle *in_bundle = in_port->bundle;
7088
7089     /* Drop frames for reserved multicast addresses
7090      * only if forward_bpdu option is absent. */
7091     if (!ofproto->up.forward_bpdu && eth_addr_is_reserved(flow->dl_dst)) {
7092         xlate_report(ctx, "packet has reserved destination MAC, dropping");
7093         return false;
7094     }
7095
7096     if (in_bundle->bond) {
7097         struct mac_entry *mac;
7098
7099         switch (bond_check_admissibility(in_bundle->bond, in_port,
7100                                          flow->dl_dst, &ctx->tags)) {
7101         case BV_ACCEPT:
7102             break;
7103
7104         case BV_DROP:
7105             xlate_report(ctx, "bonding refused admissibility, dropping");
7106             return false;
7107
7108         case BV_DROP_IF_MOVED:
7109             mac = mac_learning_lookup(ofproto->ml, flow->dl_src, vlan, NULL);
7110             if (mac && mac->port.p != in_bundle &&
7111                 (!is_gratuitous_arp(flow)
7112                  || mac_entry_is_grat_arp_locked(mac))) {
7113                 xlate_report(ctx, "SLB bond thinks this packet looped back, "
7114                             "dropping");
7115                 return false;
7116             }
7117             break;
7118         }
7119     }
7120
7121     return true;
7122 }
7123
7124 static void
7125 xlate_normal(struct action_xlate_ctx *ctx)
7126 {
7127     struct ofport_dpif *in_port;
7128     struct ofbundle *in_bundle;
7129     struct mac_entry *mac;
7130     uint16_t vlan;
7131     uint16_t vid;
7132
7133     ctx->has_normal = true;
7134
7135     in_bundle = lookup_input_bundle(ctx->ofproto, ctx->flow.in_port,
7136                                     ctx->packet != NULL, &in_port);
7137     if (!in_bundle) {
7138         xlate_report(ctx, "no input bundle, dropping");
7139         return;
7140     }
7141
7142     /* Drop malformed frames. */
7143     if (ctx->flow.dl_type == htons(ETH_TYPE_VLAN) &&
7144         !(ctx->flow.vlan_tci & htons(VLAN_CFI))) {
7145         if (ctx->packet != NULL) {
7146             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
7147             VLOG_WARN_RL(&rl, "bridge %s: dropping packet with partial "
7148                          "VLAN tag received on port %s",
7149                          ctx->ofproto->up.name, in_bundle->name);
7150         }
7151         xlate_report(ctx, "partial VLAN tag, dropping");
7152         return;
7153     }
7154
7155     /* Drop frames on bundles reserved for mirroring. */
7156     if (in_bundle->mirror_out) {
7157         if (ctx->packet != NULL) {
7158             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
7159             VLOG_WARN_RL(&rl, "bridge %s: dropping packet received on port "
7160                          "%s, which is reserved exclusively for mirroring",
7161                          ctx->ofproto->up.name, in_bundle->name);
7162         }
7163         xlate_report(ctx, "input port is mirror output port, dropping");
7164         return;
7165     }
7166
7167     /* Check VLAN. */
7168     vid = vlan_tci_to_vid(ctx->flow.vlan_tci);
7169     if (!input_vid_is_valid(vid, in_bundle, ctx->packet != NULL)) {
7170         xlate_report(ctx, "disallowed VLAN VID for this input port, dropping");
7171         return;
7172     }
7173     vlan = input_vid_to_vlan(in_bundle, vid);
7174
7175     /* Check other admissibility requirements. */
7176     if (in_port && !is_admissible(ctx, in_port, vlan)) {
7177         return;
7178     }
7179
7180     /* Learn source MAC. */
7181     if (ctx->may_learn) {
7182         update_learning_table(ctx->ofproto, &ctx->flow, vlan, in_bundle);
7183     }
7184
7185     /* Determine output bundle. */
7186     mac = mac_learning_lookup(ctx->ofproto->ml, ctx->flow.dl_dst, vlan,
7187                               &ctx->tags);
7188     if (mac) {
7189         if (mac->port.p != in_bundle) {
7190             xlate_report(ctx, "forwarding to learned port");
7191             output_normal(ctx, mac->port.p, vlan);
7192         } else {
7193             xlate_report(ctx, "learned port is input port, dropping");
7194         }
7195     } else {
7196         struct ofbundle *bundle;
7197
7198         xlate_report(ctx, "no learned MAC for destination, flooding");
7199         HMAP_FOR_EACH (bundle, hmap_node, &ctx->ofproto->bundles) {
7200             if (bundle != in_bundle
7201                 && ofbundle_includes_vlan(bundle, vlan)
7202                 && bundle->floodable
7203                 && !bundle->mirror_out) {
7204                 output_normal(ctx, bundle, vlan);
7205             }
7206         }
7207         ctx->nf_output_iface = NF_OUT_FLOOD;
7208     }
7209 }
7210 \f
7211 /* Optimized flow revalidation.
7212  *
7213  * It's a difficult problem, in general, to tell which facets need to have
7214  * their actions recalculated whenever the OpenFlow flow table changes.  We
7215  * don't try to solve that general problem: for most kinds of OpenFlow flow
7216  * table changes, we recalculate the actions for every facet.  This is
7217  * relatively expensive, but it's good enough if the OpenFlow flow table
7218  * doesn't change very often.
7219  *
7220  * However, we can expect one particular kind of OpenFlow flow table change to
7221  * happen frequently: changes caused by MAC learning.  To avoid wasting a lot
7222  * of CPU on revalidating every facet whenever MAC learning modifies the flow
7223  * table, we add a special case that applies to flow tables in which every rule
7224  * has the same form (that is, the same wildcards), except that the table is
7225  * also allowed to have a single "catch-all" flow that matches all packets.  We
7226  * optimize this case by tagging all of the facets that resubmit into the table
7227  * and invalidating the same tag whenever a flow changes in that table.  The
7228  * end result is that we revalidate just the facets that need it (and sometimes
7229  * a few more, but not all of the facets or even all of the facets that
7230  * resubmit to the table modified by MAC learning). */
7231
7232 /* Calculates the tag to use for 'flow' and mask 'mask' when it is inserted
7233  * into an OpenFlow table with the given 'basis'. */
7234 static tag_type
7235 rule_calculate_tag(const struct flow *flow, const struct minimask *mask,
7236                    uint32_t secret)
7237 {
7238     if (minimask_is_catchall(mask)) {
7239         return 0;
7240     } else {
7241         uint32_t hash = flow_hash_in_minimask(flow, mask, secret);
7242         return tag_create_deterministic(hash);
7243     }
7244 }
7245
7246 /* Following a change to OpenFlow table 'table_id' in 'ofproto', update the
7247  * taggability of that table.
7248  *
7249  * This function must be called after *each* change to a flow table.  If you
7250  * skip calling it on some changes then the pointer comparisons at the end can
7251  * be invalid if you get unlucky.  For example, if a flow removal causes a
7252  * cls_table to be destroyed and then a flow insertion causes a cls_table with
7253  * different wildcards to be created with the same address, then this function
7254  * will incorrectly skip revalidation. */
7255 static void
7256 table_update_taggable(struct ofproto_dpif *ofproto, uint8_t table_id)
7257 {
7258     struct table_dpif *table = &ofproto->tables[table_id];
7259     const struct oftable *oftable = &ofproto->up.tables[table_id];
7260     struct cls_table *catchall, *other;
7261     struct cls_table *t;
7262
7263     catchall = other = NULL;
7264
7265     switch (hmap_count(&oftable->cls.tables)) {
7266     case 0:
7267         /* We could tag this OpenFlow table but it would make the logic a
7268          * little harder and it's a corner case that doesn't seem worth it
7269          * yet. */
7270         break;
7271
7272     case 1:
7273     case 2:
7274         HMAP_FOR_EACH (t, hmap_node, &oftable->cls.tables) {
7275             if (cls_table_is_catchall(t)) {
7276                 catchall = t;
7277             } else if (!other) {
7278                 other = t;
7279             } else {
7280                 /* Indicate that we can't tag this by setting both tables to
7281                  * NULL.  (We know that 'catchall' is already NULL.) */
7282                 other = NULL;
7283             }
7284         }
7285         break;
7286
7287     default:
7288         /* Can't tag this table. */
7289         break;
7290     }
7291
7292     if (table->catchall_table != catchall || table->other_table != other) {
7293         table->catchall_table = catchall;
7294         table->other_table = other;
7295         ofproto->backer->need_revalidate = REV_FLOW_TABLE;
7296     }
7297 }
7298
7299 /* Given 'rule' that has changed in some way (either it is a rule being
7300  * inserted, a rule being deleted, or a rule whose actions are being
7301  * modified), marks facets for revalidation to ensure that packets will be
7302  * forwarded correctly according to the new state of the flow table.
7303  *
7304  * This function must be called after *each* change to a flow table.  See
7305  * the comment on table_update_taggable() for more information. */
7306 static void
7307 rule_invalidate(const struct rule_dpif *rule)
7308 {
7309     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
7310
7311     table_update_taggable(ofproto, rule->up.table_id);
7312
7313     if (!ofproto->backer->need_revalidate) {
7314         struct table_dpif *table = &ofproto->tables[rule->up.table_id];
7315
7316         if (table->other_table && rule->tag) {
7317             tag_set_add(&ofproto->backer->revalidate_set, rule->tag);
7318         } else {
7319             ofproto->backer->need_revalidate = REV_FLOW_TABLE;
7320         }
7321     }
7322 }
7323 \f
7324 static bool
7325 set_frag_handling(struct ofproto *ofproto_,
7326                   enum ofp_config_flags frag_handling)
7327 {
7328     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
7329     if (frag_handling != OFPC_FRAG_REASM) {
7330         ofproto->backer->need_revalidate = REV_RECONFIGURE;
7331         return true;
7332     } else {
7333         return false;
7334     }
7335 }
7336
7337 static enum ofperr
7338 packet_out(struct ofproto *ofproto_, struct ofpbuf *packet,
7339            const struct flow *flow,
7340            const struct ofpact *ofpacts, size_t ofpacts_len)
7341 {
7342     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
7343     struct odputil_keybuf keybuf;
7344     struct dpif_flow_stats stats;
7345
7346     struct ofpbuf key;
7347
7348     struct action_xlate_ctx ctx;
7349     uint64_t odp_actions_stub[1024 / 8];
7350     struct ofpbuf odp_actions;
7351
7352     ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
7353     odp_flow_key_from_flow(&key, flow,
7354                            ofp_port_to_odp_port(ofproto, flow->in_port));
7355
7356     dpif_flow_stats_extract(flow, packet, time_msec(), &stats);
7357
7358     action_xlate_ctx_init(&ctx, ofproto, flow, flow->vlan_tci, NULL,
7359                           packet_get_tcp_flags(packet, flow), packet);
7360     ctx.resubmit_stats = &stats;
7361
7362     ofpbuf_use_stub(&odp_actions,
7363                     odp_actions_stub, sizeof odp_actions_stub);
7364     xlate_actions(&ctx, ofpacts, ofpacts_len, &odp_actions);
7365     dpif_execute(ofproto->backer->dpif, key.data, key.size,
7366                  odp_actions.data, odp_actions.size, packet);
7367     ofpbuf_uninit(&odp_actions);
7368
7369     return 0;
7370 }
7371 \f
7372 /* NetFlow. */
7373
7374 static int
7375 set_netflow(struct ofproto *ofproto_,
7376             const struct netflow_options *netflow_options)
7377 {
7378     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
7379
7380     if (netflow_options) {
7381         if (!ofproto->netflow) {
7382             ofproto->netflow = netflow_create();
7383         }
7384         return netflow_set_options(ofproto->netflow, netflow_options);
7385     } else {
7386         netflow_destroy(ofproto->netflow);
7387         ofproto->netflow = NULL;
7388         return 0;
7389     }
7390 }
7391
7392 static void
7393 get_netflow_ids(const struct ofproto *ofproto_,
7394                 uint8_t *engine_type, uint8_t *engine_id)
7395 {
7396     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
7397
7398     dpif_get_netflow_ids(ofproto->backer->dpif, engine_type, engine_id);
7399 }
7400
7401 static void
7402 send_active_timeout(struct ofproto_dpif *ofproto, struct facet *facet)
7403 {
7404     if (!facet_is_controller_flow(facet) &&
7405         netflow_active_timeout_expired(ofproto->netflow, &facet->nf_flow)) {
7406         struct subfacet *subfacet;
7407         struct ofexpired expired;
7408
7409         LIST_FOR_EACH (subfacet, list_node, &facet->subfacets) {
7410             if (subfacet->path == SF_FAST_PATH) {
7411                 struct dpif_flow_stats stats;
7412
7413                 subfacet_reinstall(subfacet, &stats);
7414                 subfacet_update_stats(subfacet, &stats);
7415             }
7416         }
7417
7418         expired.flow = facet->flow;
7419         expired.packet_count = facet->packet_count;
7420         expired.byte_count = facet->byte_count;
7421         expired.used = facet->used;
7422         netflow_expire(ofproto->netflow, &facet->nf_flow, &expired);
7423     }
7424 }
7425
7426 static void
7427 send_netflow_active_timeouts(struct ofproto_dpif *ofproto)
7428 {
7429     struct facet *facet;
7430
7431     HMAP_FOR_EACH (facet, hmap_node, &ofproto->facets) {
7432         send_active_timeout(ofproto, facet);
7433     }
7434 }
7435 \f
7436 static struct ofproto_dpif *
7437 ofproto_dpif_lookup(const char *name)
7438 {
7439     struct ofproto_dpif *ofproto;
7440
7441     HMAP_FOR_EACH_WITH_HASH (ofproto, all_ofproto_dpifs_node,
7442                              hash_string(name, 0), &all_ofproto_dpifs) {
7443         if (!strcmp(ofproto->up.name, name)) {
7444             return ofproto;
7445         }
7446     }
7447     return NULL;
7448 }
7449
7450 static void
7451 ofproto_unixctl_fdb_flush(struct unixctl_conn *conn, int argc,
7452                           const char *argv[], void *aux OVS_UNUSED)
7453 {
7454     struct ofproto_dpif *ofproto;
7455
7456     if (argc > 1) {
7457         ofproto = ofproto_dpif_lookup(argv[1]);
7458         if (!ofproto) {
7459             unixctl_command_reply_error(conn, "no such bridge");
7460             return;
7461         }
7462         mac_learning_flush(ofproto->ml, &ofproto->backer->revalidate_set);
7463     } else {
7464         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
7465             mac_learning_flush(ofproto->ml, &ofproto->backer->revalidate_set);
7466         }
7467     }
7468
7469     unixctl_command_reply(conn, "table successfully flushed");
7470 }
7471
7472 static void
7473 ofproto_unixctl_fdb_show(struct unixctl_conn *conn, int argc OVS_UNUSED,
7474                          const char *argv[], void *aux OVS_UNUSED)
7475 {
7476     struct ds ds = DS_EMPTY_INITIALIZER;
7477     const struct ofproto_dpif *ofproto;
7478     const struct mac_entry *e;
7479
7480     ofproto = ofproto_dpif_lookup(argv[1]);
7481     if (!ofproto) {
7482         unixctl_command_reply_error(conn, "no such bridge");
7483         return;
7484     }
7485
7486     ds_put_cstr(&ds, " port  VLAN  MAC                Age\n");
7487     LIST_FOR_EACH (e, lru_node, &ofproto->ml->lrus) {
7488         struct ofbundle *bundle = e->port.p;
7489         ds_put_format(&ds, "%5d  %4d  "ETH_ADDR_FMT"  %3d\n",
7490                       ofbundle_get_a_port(bundle)->odp_port,
7491                       e->vlan, ETH_ADDR_ARGS(e->mac),
7492                       mac_entry_age(ofproto->ml, e));
7493     }
7494     unixctl_command_reply(conn, ds_cstr(&ds));
7495     ds_destroy(&ds);
7496 }
7497
7498 struct trace_ctx {
7499     struct action_xlate_ctx ctx;
7500     struct flow flow;
7501     struct ds *result;
7502 };
7503
7504 static void
7505 trace_format_rule(struct ds *result, uint8_t table_id, int level,
7506                   const struct rule_dpif *rule)
7507 {
7508     ds_put_char_multiple(result, '\t', level);
7509     if (!rule) {
7510         ds_put_cstr(result, "No match\n");
7511         return;
7512     }
7513
7514     ds_put_format(result, "Rule: table=%"PRIu8" cookie=%#"PRIx64" ",
7515                   table_id, ntohll(rule->up.flow_cookie));
7516     cls_rule_format(&rule->up.cr, result);
7517     ds_put_char(result, '\n');
7518
7519     ds_put_char_multiple(result, '\t', level);
7520     ds_put_cstr(result, "OpenFlow ");
7521     ofpacts_format(rule->up.ofpacts, rule->up.ofpacts_len, result);
7522     ds_put_char(result, '\n');
7523 }
7524
7525 static void
7526 trace_format_flow(struct ds *result, int level, const char *title,
7527                  struct trace_ctx *trace)
7528 {
7529     ds_put_char_multiple(result, '\t', level);
7530     ds_put_format(result, "%s: ", title);
7531     if (flow_equal(&trace->ctx.flow, &trace->flow)) {
7532         ds_put_cstr(result, "unchanged");
7533     } else {
7534         flow_format(result, &trace->ctx.flow);
7535         trace->flow = trace->ctx.flow;
7536     }
7537     ds_put_char(result, '\n');
7538 }
7539
7540 static void
7541 trace_format_regs(struct ds *result, int level, const char *title,
7542                   struct trace_ctx *trace)
7543 {
7544     size_t i;
7545
7546     ds_put_char_multiple(result, '\t', level);
7547     ds_put_format(result, "%s:", title);
7548     for (i = 0; i < FLOW_N_REGS; i++) {
7549         ds_put_format(result, " reg%zu=0x%"PRIx32, i, trace->flow.regs[i]);
7550     }
7551     ds_put_char(result, '\n');
7552 }
7553
7554 static void
7555 trace_format_odp(struct ds *result, int level, const char *title,
7556                  struct trace_ctx *trace)
7557 {
7558     struct ofpbuf *odp_actions = trace->ctx.odp_actions;
7559
7560     ds_put_char_multiple(result, '\t', level);
7561     ds_put_format(result, "%s: ", title);
7562     format_odp_actions(result, odp_actions->data, odp_actions->size);
7563     ds_put_char(result, '\n');
7564 }
7565
7566 static void
7567 trace_resubmit(struct action_xlate_ctx *ctx, struct rule_dpif *rule)
7568 {
7569     struct trace_ctx *trace = CONTAINER_OF(ctx, struct trace_ctx, ctx);
7570     struct ds *result = trace->result;
7571
7572     ds_put_char(result, '\n');
7573     trace_format_flow(result, ctx->recurse + 1, "Resubmitted flow", trace);
7574     trace_format_regs(result, ctx->recurse + 1, "Resubmitted regs", trace);
7575     trace_format_odp(result,  ctx->recurse + 1, "Resubmitted  odp", trace);
7576     trace_format_rule(result, ctx->table_id, ctx->recurse + 1, rule);
7577 }
7578
7579 static void
7580 trace_report(struct action_xlate_ctx *ctx, const char *s)
7581 {
7582     struct trace_ctx *trace = CONTAINER_OF(ctx, struct trace_ctx, ctx);
7583     struct ds *result = trace->result;
7584
7585     ds_put_char_multiple(result, '\t', ctx->recurse);
7586     ds_put_cstr(result, s);
7587     ds_put_char(result, '\n');
7588 }
7589
7590 static void
7591 ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[],
7592                       void *aux OVS_UNUSED)
7593 {
7594     const char *dpname = argv[1];
7595     struct ofproto_dpif *ofproto;
7596     struct ofpbuf odp_key;
7597     struct ofpbuf *packet;
7598     ovs_be16 initial_tci;
7599     struct ds result;
7600     struct flow flow;
7601     char *s;
7602
7603     packet = NULL;
7604     ofpbuf_init(&odp_key, 0);
7605     ds_init(&result);
7606
7607     ofproto = ofproto_dpif_lookup(dpname);
7608     if (!ofproto) {
7609         unixctl_command_reply_error(conn, "Unknown ofproto (use ofproto/list "
7610                                     "for help)");
7611         goto exit;
7612     }
7613     if (argc == 3 || (argc == 4 && !strcmp(argv[3], "-generate"))) {
7614         /* ofproto/trace dpname flow [-generate] */
7615         const char *flow_s = argv[2];
7616         const char *generate_s = argv[3];
7617
7618         /* Allow 'flow_s' to be either a datapath flow or an OpenFlow-like
7619          * flow.  We guess which type it is based on whether 'flow_s' contains
7620          * an '(', since a datapath flow always contains '(') but an
7621          * OpenFlow-like flow should not (in fact it's allowed but I believe
7622          * that's not documented anywhere).
7623          *
7624          * An alternative would be to try to parse 'flow_s' both ways, but then
7625          * it would be tricky giving a sensible error message.  After all, do
7626          * you just say "syntax error" or do you present both error messages?
7627          * Both choices seem lousy. */
7628         if (strchr(flow_s, '(')) {
7629             int error;
7630
7631             /* Convert string to datapath key. */
7632             ofpbuf_init(&odp_key, 0);
7633             error = odp_flow_key_from_string(flow_s, NULL, &odp_key);
7634             if (error) {
7635                 unixctl_command_reply_error(conn, "Bad flow syntax");
7636                 goto exit;
7637             }
7638
7639             /* XXX: Since we allow the user to specify an ofproto, it's
7640              * possible they will specify a different ofproto than the one the
7641              * port actually belongs too.  Ideally we should simply remove the
7642              * ability to specify the ofproto. */
7643             if (ofproto_receive(ofproto->backer, NULL, odp_key.data,
7644                                 odp_key.size, &flow, NULL, NULL, NULL,
7645                                 &initial_tci)) {
7646                 unixctl_command_reply_error(conn, "Invalid flow");
7647                 goto exit;
7648             }
7649         } else {
7650             char *error_s;
7651
7652             error_s = parse_ofp_exact_flow(&flow, argv[2]);
7653             if (error_s) {
7654                 unixctl_command_reply_error(conn, error_s);
7655                 free(error_s);
7656                 goto exit;
7657             }
7658
7659             initial_tci = flow.vlan_tci;
7660         }
7661
7662         /* Generate a packet, if requested. */
7663         if (generate_s) {
7664             packet = ofpbuf_new(0);
7665             flow_compose(packet, &flow);
7666         }
7667     } else if (argc == 7) {
7668         /* ofproto/trace dpname priority tun_id in_port mark packet */
7669         const char *priority_s = argv[2];
7670         const char *tun_id_s = argv[3];
7671         const char *in_port_s = argv[4];
7672         const char *mark_s = argv[5];
7673         const char *packet_s = argv[6];
7674         uint32_t in_port = atoi(in_port_s);
7675         ovs_be64 tun_id = htonll(strtoull(tun_id_s, NULL, 0));
7676         uint32_t priority = atoi(priority_s);
7677         uint32_t mark = atoi(mark_s);
7678         const char *msg;
7679
7680         msg = eth_from_hex(packet_s, &packet);
7681         if (msg) {
7682             unixctl_command_reply_error(conn, msg);
7683             goto exit;
7684         }
7685
7686         ds_put_cstr(&result, "Packet: ");
7687         s = ofp_packet_to_string(packet->data, packet->size);
7688         ds_put_cstr(&result, s);
7689         free(s);
7690
7691         flow_extract(packet, priority, mark, NULL, in_port, &flow);
7692         flow.tunnel.tun_id = tun_id;
7693         initial_tci = flow.vlan_tci;
7694     } else {
7695         unixctl_command_reply_error(conn, "Bad command syntax");
7696         goto exit;
7697     }
7698
7699     ofproto_trace(ofproto, &flow, packet, initial_tci, &result);
7700     unixctl_command_reply(conn, ds_cstr(&result));
7701
7702 exit:
7703     ds_destroy(&result);
7704     ofpbuf_delete(packet);
7705     ofpbuf_uninit(&odp_key);
7706 }
7707
7708 static void
7709 ofproto_trace(struct ofproto_dpif *ofproto, const struct flow *flow,
7710               const struct ofpbuf *packet, ovs_be16 initial_tci,
7711               struct ds *ds)
7712 {
7713     struct rule_dpif *rule;
7714
7715     ds_put_cstr(ds, "Flow: ");
7716     flow_format(ds, flow);
7717     ds_put_char(ds, '\n');
7718
7719     rule = rule_dpif_lookup(ofproto, flow);
7720
7721     trace_format_rule(ds, 0, 0, rule);
7722     if (rule == ofproto->miss_rule) {
7723         ds_put_cstr(ds, "\nNo match, flow generates \"packet in\"s.\n");
7724     } else if (rule == ofproto->no_packet_in_rule) {
7725         ds_put_cstr(ds, "\nNo match, packets dropped because "
7726                     "OFPPC_NO_PACKET_IN is set on in_port.\n");
7727     }
7728
7729     if (rule) {
7730         uint64_t odp_actions_stub[1024 / 8];
7731         struct ofpbuf odp_actions;
7732
7733         struct trace_ctx trace;
7734         uint8_t tcp_flags;
7735
7736         tcp_flags = packet ? packet_get_tcp_flags(packet, flow) : 0;
7737         trace.result = ds;
7738         trace.flow = *flow;
7739         ofpbuf_use_stub(&odp_actions,
7740                         odp_actions_stub, sizeof odp_actions_stub);
7741         action_xlate_ctx_init(&trace.ctx, ofproto, flow, initial_tci,
7742                               rule, tcp_flags, packet);
7743         trace.ctx.resubmit_hook = trace_resubmit;
7744         trace.ctx.report_hook = trace_report;
7745         xlate_actions(&trace.ctx, rule->up.ofpacts, rule->up.ofpacts_len,
7746                       &odp_actions);
7747
7748         ds_put_char(ds, '\n');
7749         trace_format_flow(ds, 0, "Final flow", &trace);
7750         ds_put_cstr(ds, "Datapath actions: ");
7751         format_odp_actions(ds, odp_actions.data, odp_actions.size);
7752         ofpbuf_uninit(&odp_actions);
7753
7754         if (trace.ctx.slow) {
7755             enum slow_path_reason slow;
7756
7757             ds_put_cstr(ds, "\nThis flow is handled by the userspace "
7758                         "slow path because it:");
7759             for (slow = trace.ctx.slow; slow; ) {
7760                 enum slow_path_reason bit = rightmost_1bit(slow);
7761
7762                 switch (bit) {
7763                 case SLOW_CFM:
7764                     ds_put_cstr(ds, "\n\t- Consists of CFM packets.");
7765                     break;
7766                 case SLOW_LACP:
7767                     ds_put_cstr(ds, "\n\t- Consists of LACP packets.");
7768                     break;
7769                 case SLOW_STP:
7770                     ds_put_cstr(ds, "\n\t- Consists of STP packets.");
7771                     break;
7772                 case SLOW_IN_BAND:
7773                     ds_put_cstr(ds, "\n\t- Needs in-band special case "
7774                                 "processing.");
7775                     if (!packet) {
7776                         ds_put_cstr(ds, "\n\t  (The datapath actions are "
7777                                     "incomplete--for complete actions, "
7778                                     "please supply a packet.)");
7779                     }
7780                     break;
7781                 case SLOW_CONTROLLER:
7782                     ds_put_cstr(ds, "\n\t- Sends \"packet-in\" messages "
7783                                 "to the OpenFlow controller.");
7784                     break;
7785                 case SLOW_MATCH:
7786                     ds_put_cstr(ds, "\n\t- Needs more specific matching "
7787                                 "than the datapath supports.");
7788                     break;
7789                 }
7790
7791                 slow &= ~bit;
7792             }
7793
7794             if (slow & ~SLOW_MATCH) {
7795                 ds_put_cstr(ds, "\nThe datapath actions above do not reflect "
7796                             "the special slow-path processing.");
7797             }
7798         }
7799     }
7800 }
7801
7802 static void
7803 ofproto_dpif_clog(struct unixctl_conn *conn OVS_UNUSED, int argc OVS_UNUSED,
7804                   const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
7805 {
7806     clogged = true;
7807     unixctl_command_reply(conn, NULL);
7808 }
7809
7810 static void
7811 ofproto_dpif_unclog(struct unixctl_conn *conn OVS_UNUSED, int argc OVS_UNUSED,
7812                     const char *argv[] OVS_UNUSED, void *aux OVS_UNUSED)
7813 {
7814     clogged = false;
7815     unixctl_command_reply(conn, NULL);
7816 }
7817
7818 /* Runs a self-check of flow translations in 'ofproto'.  Appends a message to
7819  * 'reply' describing the results. */
7820 static void
7821 ofproto_dpif_self_check__(struct ofproto_dpif *ofproto, struct ds *reply)
7822 {
7823     struct facet *facet;
7824     int errors;
7825
7826     errors = 0;
7827     HMAP_FOR_EACH (facet, hmap_node, &ofproto->facets) {
7828         if (!facet_check_consistency(facet)) {
7829             errors++;
7830         }
7831     }
7832     if (errors) {
7833         ofproto->backer->need_revalidate = REV_INCONSISTENCY;
7834     }
7835
7836     if (errors) {
7837         ds_put_format(reply, "%s: self-check failed (%d errors)\n",
7838                       ofproto->up.name, errors);
7839     } else {
7840         ds_put_format(reply, "%s: self-check passed\n", ofproto->up.name);
7841     }
7842 }
7843
7844 static void
7845 ofproto_dpif_self_check(struct unixctl_conn *conn,
7846                         int argc, const char *argv[], void *aux OVS_UNUSED)
7847 {
7848     struct ds reply = DS_EMPTY_INITIALIZER;
7849     struct ofproto_dpif *ofproto;
7850
7851     if (argc > 1) {
7852         ofproto = ofproto_dpif_lookup(argv[1]);
7853         if (!ofproto) {
7854             unixctl_command_reply_error(conn, "Unknown ofproto (use "
7855                                         "ofproto/list for help)");
7856             return;
7857         }
7858         ofproto_dpif_self_check__(ofproto, &reply);
7859     } else {
7860         HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
7861             ofproto_dpif_self_check__(ofproto, &reply);
7862         }
7863     }
7864
7865     unixctl_command_reply(conn, ds_cstr(&reply));
7866     ds_destroy(&reply);
7867 }
7868
7869 /* Store the current ofprotos in 'ofproto_shash'.  Returns a sorted list
7870  * of the 'ofproto_shash' nodes.  It is the responsibility of the caller
7871  * to destroy 'ofproto_shash' and free the returned value. */
7872 static const struct shash_node **
7873 get_ofprotos(struct shash *ofproto_shash)
7874 {
7875     const struct ofproto_dpif *ofproto;
7876
7877     HMAP_FOR_EACH (ofproto, all_ofproto_dpifs_node, &all_ofproto_dpifs) {
7878         char *name = xasprintf("%s@%s", ofproto->up.type, ofproto->up.name);
7879         shash_add_nocopy(ofproto_shash, name, ofproto);
7880     }
7881
7882     return shash_sort(ofproto_shash);
7883 }
7884
7885 static void
7886 ofproto_unixctl_dpif_dump_dps(struct unixctl_conn *conn, int argc OVS_UNUSED,
7887                               const char *argv[] OVS_UNUSED,
7888                               void *aux OVS_UNUSED)
7889 {
7890     struct ds ds = DS_EMPTY_INITIALIZER;
7891     struct shash ofproto_shash;
7892     const struct shash_node **sorted_ofprotos;
7893     int i;
7894
7895     shash_init(&ofproto_shash);
7896     sorted_ofprotos = get_ofprotos(&ofproto_shash);
7897     for (i = 0; i < shash_count(&ofproto_shash); i++) {
7898         const struct shash_node *node = sorted_ofprotos[i];
7899         ds_put_format(&ds, "%s\n", node->name);
7900     }
7901
7902     shash_destroy(&ofproto_shash);
7903     free(sorted_ofprotos);
7904
7905     unixctl_command_reply(conn, ds_cstr(&ds));
7906     ds_destroy(&ds);
7907 }
7908
7909 static void
7910 show_dp_format(const struct ofproto_dpif *ofproto, struct ds *ds)
7911 {
7912     struct dpif_dp_stats s;
7913     const struct shash_node **ports;
7914     int i;
7915
7916     dpif_get_dp_stats(ofproto->backer->dpif, &s);
7917
7918     ds_put_format(ds, "%s (%s):\n", ofproto->up.name,
7919                   dpif_name(ofproto->backer->dpif));
7920     /* xxx It would be better to show bridge-specific stats instead
7921      * xxx of dp ones. */
7922     ds_put_format(ds,
7923                   "\tlookups: hit:%"PRIu64" missed:%"PRIu64" lost:%"PRIu64"\n",
7924                   s.n_hit, s.n_missed, s.n_lost);
7925     ds_put_format(ds, "\tflows: %zu\n",
7926                   hmap_count(&ofproto->subfacets));
7927
7928     ports = shash_sort(&ofproto->up.port_by_name);
7929     for (i = 0; i < shash_count(&ofproto->up.port_by_name); i++) {
7930         const struct shash_node *node = ports[i];
7931         struct ofport *ofport = node->data;
7932         const char *name = netdev_get_name(ofport->netdev);
7933         const char *type = netdev_get_type(ofport->netdev);
7934         uint32_t odp_port;
7935
7936         ds_put_format(ds, "\t%s %u/", name, ofport->ofp_port);
7937
7938         odp_port = ofp_port_to_odp_port(ofproto, ofport->ofp_port);
7939         if (odp_port != OVSP_NONE) {
7940             ds_put_format(ds, "%"PRIu32":", odp_port);
7941         } else {
7942             ds_put_cstr(ds, "none:");
7943         }
7944
7945         if (strcmp(type, "system")) {
7946             struct netdev *netdev;
7947             int error;
7948
7949             ds_put_format(ds, " (%s", type);
7950
7951             error = netdev_open(name, type, &netdev);
7952             if (!error) {
7953                 struct smap config;
7954
7955                 smap_init(&config);
7956                 error = netdev_get_config(netdev, &config);
7957                 if (!error) {
7958                     const struct smap_node **nodes;
7959                     size_t i;
7960
7961                     nodes = smap_sort(&config);
7962                     for (i = 0; i < smap_count(&config); i++) {
7963                         const struct smap_node *node = nodes[i];
7964                         ds_put_format(ds, "%c %s=%s", i ? ',' : ':',
7965                                       node->key, node->value);
7966                     }
7967                     free(nodes);
7968                 }
7969                 smap_destroy(&config);
7970
7971                 netdev_close(netdev);
7972             }
7973             ds_put_char(ds, ')');
7974         }
7975         ds_put_char(ds, '\n');
7976     }
7977     free(ports);
7978 }
7979
7980 static void
7981 ofproto_unixctl_dpif_show(struct unixctl_conn *conn, int argc,
7982                           const char *argv[], void *aux OVS_UNUSED)
7983 {
7984     struct ds ds = DS_EMPTY_INITIALIZER;
7985     const struct ofproto_dpif *ofproto;
7986
7987     if (argc > 1) {
7988         int i;
7989         for (i = 1; i < argc; i++) {
7990             ofproto = ofproto_dpif_lookup(argv[i]);
7991             if (!ofproto) {
7992                 ds_put_format(&ds, "Unknown bridge %s (use dpif/dump-dps "
7993                                    "for help)", argv[i]);
7994                 unixctl_command_reply_error(conn, ds_cstr(&ds));
7995                 return;
7996             }
7997             show_dp_format(ofproto, &ds);
7998         }
7999     } else {
8000         struct shash ofproto_shash;
8001         const struct shash_node **sorted_ofprotos;
8002         int i;
8003
8004         shash_init(&ofproto_shash);
8005         sorted_ofprotos = get_ofprotos(&ofproto_shash);
8006         for (i = 0; i < shash_count(&ofproto_shash); i++) {
8007             const struct shash_node *node = sorted_ofprotos[i];
8008             show_dp_format(node->data, &ds);
8009         }
8010
8011         shash_destroy(&ofproto_shash);
8012         free(sorted_ofprotos);
8013     }
8014
8015     unixctl_command_reply(conn, ds_cstr(&ds));
8016     ds_destroy(&ds);
8017 }
8018
8019 static void
8020 ofproto_unixctl_dpif_dump_flows(struct unixctl_conn *conn,
8021                                 int argc OVS_UNUSED, const char *argv[],
8022                                 void *aux OVS_UNUSED)
8023 {
8024     struct ds ds = DS_EMPTY_INITIALIZER;
8025     const struct ofproto_dpif *ofproto;
8026     struct subfacet *subfacet;
8027
8028     ofproto = ofproto_dpif_lookup(argv[1]);
8029     if (!ofproto) {
8030         unixctl_command_reply_error(conn, "no such bridge");
8031         return;
8032     }
8033
8034     update_stats(ofproto->backer);
8035
8036     HMAP_FOR_EACH (subfacet, hmap_node, &ofproto->subfacets) {
8037         struct odputil_keybuf keybuf;
8038         struct ofpbuf key;
8039
8040         subfacet_get_key(subfacet, &keybuf, &key);
8041         odp_flow_key_format(key.data, key.size, &ds);
8042
8043         ds_put_format(&ds, ", packets:%"PRIu64", bytes:%"PRIu64", used:",
8044                       subfacet->dp_packet_count, subfacet->dp_byte_count);
8045         if (subfacet->used) {
8046             ds_put_format(&ds, "%.3fs",
8047                           (time_msec() - subfacet->used) / 1000.0);
8048         } else {
8049             ds_put_format(&ds, "never");
8050         }
8051         if (subfacet->facet->tcp_flags) {
8052             ds_put_cstr(&ds, ", flags:");
8053             packet_format_tcp_flags(&ds, subfacet->facet->tcp_flags);
8054         }
8055
8056         ds_put_cstr(&ds, ", actions:");
8057         format_odp_actions(&ds, subfacet->actions, subfacet->actions_len);
8058         ds_put_char(&ds, '\n');
8059     }
8060
8061     unixctl_command_reply(conn, ds_cstr(&ds));
8062     ds_destroy(&ds);
8063 }
8064
8065 static void
8066 ofproto_unixctl_dpif_del_flows(struct unixctl_conn *conn,
8067                                int argc OVS_UNUSED, const char *argv[],
8068                                void *aux OVS_UNUSED)
8069 {
8070     struct ds ds = DS_EMPTY_INITIALIZER;
8071     struct ofproto_dpif *ofproto;
8072
8073     ofproto = ofproto_dpif_lookup(argv[1]);
8074     if (!ofproto) {
8075         unixctl_command_reply_error(conn, "no such bridge");
8076         return;
8077     }
8078
8079     flush(&ofproto->up);
8080
8081     unixctl_command_reply(conn, ds_cstr(&ds));
8082     ds_destroy(&ds);
8083 }
8084
8085 static void
8086 ofproto_dpif_unixctl_init(void)
8087 {
8088     static bool registered;
8089     if (registered) {
8090         return;
8091     }
8092     registered = true;
8093
8094     unixctl_command_register(
8095         "ofproto/trace",
8096         "bridge {priority tun_id in_port mark packet | odp_flow [-generate]}",
8097         2, 6, ofproto_unixctl_trace, NULL);
8098     unixctl_command_register("fdb/flush", "[bridge]", 0, 1,
8099                              ofproto_unixctl_fdb_flush, NULL);
8100     unixctl_command_register("fdb/show", "bridge", 1, 1,
8101                              ofproto_unixctl_fdb_show, NULL);
8102     unixctl_command_register("ofproto/clog", "", 0, 0,
8103                              ofproto_dpif_clog, NULL);
8104     unixctl_command_register("ofproto/unclog", "", 0, 0,
8105                              ofproto_dpif_unclog, NULL);
8106     unixctl_command_register("ofproto/self-check", "[bridge]", 0, 1,
8107                              ofproto_dpif_self_check, NULL);
8108     unixctl_command_register("dpif/dump-dps", "", 0, 0,
8109                              ofproto_unixctl_dpif_dump_dps, NULL);
8110     unixctl_command_register("dpif/show", "[bridge]", 0, INT_MAX,
8111                              ofproto_unixctl_dpif_show, NULL);
8112     unixctl_command_register("dpif/dump-flows", "bridge", 1, 1,
8113                              ofproto_unixctl_dpif_dump_flows, NULL);
8114     unixctl_command_register("dpif/del-flows", "bridge", 1, 1,
8115                              ofproto_unixctl_dpif_del_flows, NULL);
8116 }
8117 \f
8118 /* Linux VLAN device support (e.g. "eth0.10" for VLAN 10.)
8119  *
8120  * This is deprecated.  It is only for compatibility with broken device drivers
8121  * in old versions of Linux that do not properly support VLANs when VLAN
8122  * devices are not used.  When broken device drivers are no longer in
8123  * widespread use, we will delete these interfaces. */
8124
8125 static int
8126 set_realdev(struct ofport *ofport_, uint16_t realdev_ofp_port, int vid)
8127 {
8128     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport_->ofproto);
8129     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
8130
8131     if (realdev_ofp_port == ofport->realdev_ofp_port
8132         && vid == ofport->vlandev_vid) {
8133         return 0;
8134     }
8135
8136     ofproto->backer->need_revalidate = REV_RECONFIGURE;
8137
8138     if (ofport->realdev_ofp_port) {
8139         vsp_remove(ofport);
8140     }
8141     if (realdev_ofp_port && ofport->bundle) {
8142         /* vlandevs are enslaved to their realdevs, so they are not allowed to
8143          * themselves be part of a bundle. */
8144         bundle_set(ofport->up.ofproto, ofport->bundle, NULL);
8145     }
8146
8147     ofport->realdev_ofp_port = realdev_ofp_port;
8148     ofport->vlandev_vid = vid;
8149
8150     if (realdev_ofp_port) {
8151         vsp_add(ofport, realdev_ofp_port, vid);
8152     }
8153
8154     return 0;
8155 }
8156
8157 static uint32_t
8158 hash_realdev_vid(uint16_t realdev_ofp_port, int vid)
8159 {
8160     return hash_2words(realdev_ofp_port, vid);
8161 }
8162
8163 /* Returns the ODP port number of the Linux VLAN device that corresponds to
8164  * 'vlan_tci' on the network device with port number 'realdev_odp_port' in
8165  * 'ofproto'.  For example, given 'realdev_odp_port' of eth0 and 'vlan_tci' 9,
8166  * it would return the port number of eth0.9.
8167  *
8168  * Unless VLAN splinters are enabled for port 'realdev_odp_port', this
8169  * function just returns its 'realdev_odp_port' argument. */
8170 static uint32_t
8171 vsp_realdev_to_vlandev(const struct ofproto_dpif *ofproto,
8172                        uint32_t realdev_odp_port, ovs_be16 vlan_tci)
8173 {
8174     if (!hmap_is_empty(&ofproto->realdev_vid_map)) {
8175         uint16_t realdev_ofp_port;
8176         int vid = vlan_tci_to_vid(vlan_tci);
8177         const struct vlan_splinter *vsp;
8178
8179         realdev_ofp_port = odp_port_to_ofp_port(ofproto, realdev_odp_port);
8180         HMAP_FOR_EACH_WITH_HASH (vsp, realdev_vid_node,
8181                                  hash_realdev_vid(realdev_ofp_port, vid),
8182                                  &ofproto->realdev_vid_map) {
8183             if (vsp->realdev_ofp_port == realdev_ofp_port
8184                 && vsp->vid == vid) {
8185                 return ofp_port_to_odp_port(ofproto, vsp->vlandev_ofp_port);
8186             }
8187         }
8188     }
8189     return realdev_odp_port;
8190 }
8191
8192 static struct vlan_splinter *
8193 vlandev_find(const struct ofproto_dpif *ofproto, uint16_t vlandev_ofp_port)
8194 {
8195     struct vlan_splinter *vsp;
8196
8197     HMAP_FOR_EACH_WITH_HASH (vsp, vlandev_node, hash_int(vlandev_ofp_port, 0),
8198                              &ofproto->vlandev_map) {
8199         if (vsp->vlandev_ofp_port == vlandev_ofp_port) {
8200             return vsp;
8201         }
8202     }
8203
8204     return NULL;
8205 }
8206
8207 /* Returns the OpenFlow port number of the "real" device underlying the Linux
8208  * VLAN device with OpenFlow port number 'vlandev_ofp_port' and stores the
8209  * VLAN VID of the Linux VLAN device in '*vid'.  For example, given
8210  * 'vlandev_ofp_port' of eth0.9, it would return the OpenFlow port number of
8211  * eth0 and store 9 in '*vid'.
8212  *
8213  * Returns 0 and does not modify '*vid' if 'vlandev_ofp_port' is not a Linux
8214  * VLAN device.  Unless VLAN splinters are enabled, this is what this function
8215  * always does.*/
8216 static uint16_t
8217 vsp_vlandev_to_realdev(const struct ofproto_dpif *ofproto,
8218                        uint16_t vlandev_ofp_port, int *vid)
8219 {
8220     if (!hmap_is_empty(&ofproto->vlandev_map)) {
8221         const struct vlan_splinter *vsp;
8222
8223         vsp = vlandev_find(ofproto, vlandev_ofp_port);
8224         if (vsp) {
8225             if (vid) {
8226                 *vid = vsp->vid;
8227             }
8228             return vsp->realdev_ofp_port;
8229         }
8230     }
8231     return 0;
8232 }
8233
8234 /* Given 'flow', a flow representing a packet received on 'ofproto', checks
8235  * whether 'flow->in_port' represents a Linux VLAN device.  If so, changes
8236  * 'flow->in_port' to the "real" device backing the VLAN device, sets
8237  * 'flow->vlan_tci' to the VLAN VID, and returns true.  Otherwise (which is
8238  * always the case unless VLAN splinters are enabled), returns false without
8239  * making any changes. */
8240 static bool
8241 vsp_adjust_flow(const struct ofproto_dpif *ofproto, struct flow *flow)
8242 {
8243     uint16_t realdev;
8244     int vid;
8245
8246     realdev = vsp_vlandev_to_realdev(ofproto, flow->in_port, &vid);
8247     if (!realdev) {
8248         return false;
8249     }
8250
8251     /* Cause the flow to be processed as if it came in on the real device with
8252      * the VLAN device's VLAN ID. */
8253     flow->in_port = realdev;
8254     flow->vlan_tci = htons((vid & VLAN_VID_MASK) | VLAN_CFI);
8255     return true;
8256 }
8257
8258 static void
8259 vsp_remove(struct ofport_dpif *port)
8260 {
8261     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
8262     struct vlan_splinter *vsp;
8263
8264     vsp = vlandev_find(ofproto, port->up.ofp_port);
8265     if (vsp) {
8266         hmap_remove(&ofproto->vlandev_map, &vsp->vlandev_node);
8267         hmap_remove(&ofproto->realdev_vid_map, &vsp->realdev_vid_node);
8268         free(vsp);
8269
8270         port->realdev_ofp_port = 0;
8271     } else {
8272         VLOG_ERR("missing vlan device record");
8273     }
8274 }
8275
8276 static void
8277 vsp_add(struct ofport_dpif *port, uint16_t realdev_ofp_port, int vid)
8278 {
8279     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
8280
8281     if (!vsp_vlandev_to_realdev(ofproto, port->up.ofp_port, NULL)
8282         && (vsp_realdev_to_vlandev(ofproto, realdev_ofp_port, htons(vid))
8283             == realdev_ofp_port)) {
8284         struct vlan_splinter *vsp;
8285
8286         vsp = xmalloc(sizeof *vsp);
8287         hmap_insert(&ofproto->vlandev_map, &vsp->vlandev_node,
8288                     hash_int(port->up.ofp_port, 0));
8289         hmap_insert(&ofproto->realdev_vid_map, &vsp->realdev_vid_node,
8290                     hash_realdev_vid(realdev_ofp_port, vid));
8291         vsp->realdev_ofp_port = realdev_ofp_port;
8292         vsp->vlandev_ofp_port = port->up.ofp_port;
8293         vsp->vid = vid;
8294
8295         port->realdev_ofp_port = realdev_ofp_port;
8296     } else {
8297         VLOG_ERR("duplicate vlan device record");
8298     }
8299 }
8300
8301 static uint32_t
8302 ofp_port_to_odp_port(const struct ofproto_dpif *ofproto, uint16_t ofp_port)
8303 {
8304     const struct ofport_dpif *ofport = get_ofp_port(ofproto, ofp_port);
8305     return ofport ? ofport->odp_port : OVSP_NONE;
8306 }
8307
8308 static struct ofport_dpif *
8309 odp_port_to_ofport(const struct dpif_backer *backer, uint32_t odp_port)
8310 {
8311     struct ofport_dpif *port;
8312
8313     HMAP_FOR_EACH_IN_BUCKET (port, odp_port_node,
8314                              hash_int(odp_port, 0),
8315                              &backer->odp_to_ofport_map) {
8316         if (port->odp_port == odp_port) {
8317             return port;
8318         }
8319     }
8320
8321     return NULL;
8322 }
8323
8324 static uint16_t
8325 odp_port_to_ofp_port(const struct ofproto_dpif *ofproto, uint32_t odp_port)
8326 {
8327     struct ofport_dpif *port;
8328
8329     port = odp_port_to_ofport(ofproto->backer, odp_port);
8330     if (port && &ofproto->up == port->up.ofproto) {
8331         return port->up.ofp_port;
8332     } else {
8333         return OFPP_NONE;
8334     }
8335 }
8336
8337 const struct ofproto_class ofproto_dpif_class = {
8338     init,
8339     enumerate_types,
8340     enumerate_names,
8341     del,
8342     port_open_type,
8343     type_run,
8344     type_run_fast,
8345     type_wait,
8346     alloc,
8347     construct,
8348     destruct,
8349     dealloc,
8350     run,
8351     run_fast,
8352     wait,
8353     get_memory_usage,
8354     flush,
8355     get_features,
8356     get_tables,
8357     port_alloc,
8358     port_construct,
8359     port_destruct,
8360     port_dealloc,
8361     port_modified,
8362     port_reconfigured,
8363     port_query_by_name,
8364     port_add,
8365     port_del,
8366     port_get_stats,
8367     port_dump_start,
8368     port_dump_next,
8369     port_dump_done,
8370     port_poll,
8371     port_poll_wait,
8372     port_is_lacp_current,
8373     NULL,                       /* rule_choose_table */
8374     rule_alloc,
8375     rule_construct,
8376     rule_destruct,
8377     rule_dealloc,
8378     rule_get_stats,
8379     rule_execute,
8380     rule_modify_actions,
8381     set_frag_handling,
8382     packet_out,
8383     set_netflow,
8384     get_netflow_ids,
8385     set_sflow,
8386     set_cfm,
8387     get_cfm_fault,
8388     get_cfm_opup,
8389     get_cfm_remote_mpids,
8390     get_cfm_health,
8391     set_stp,
8392     get_stp_status,
8393     set_stp_port,
8394     get_stp_port_status,
8395     set_queues,
8396     bundle_set,
8397     bundle_remove,
8398     mirror_set,
8399     mirror_get_stats,
8400     set_flood_vlans,
8401     is_mirror_output_bundle,
8402     forward_bpdu_changed,
8403     set_mac_table_config,
8404     set_realdev,
8405 };