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