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