Merge 'master' into 'next'.
authorBen Pfaff <blp@nicira.com>
Thu, 12 May 2011 19:05:42 +0000 (12:05 -0700)
committerBen Pfaff <blp@nicira.com>
Thu, 12 May 2011 19:05:42 +0000 (12:05 -0700)
28 files changed:
1  2 
include/openflow/nicira-ext.h
lib/automake.mk
lib/bond.c
lib/bond.h
lib/dpif-linux.c
lib/dpif.c
lib/dpif.h
lib/flow.h
lib/learning-switch.c
lib/netdev-linux.c
lib/ofp-parse.c
lib/ofp-print.c
lib/ofp-util.c
lib/ofp-util.h
ofproto/connmgr.c
ofproto/in-band.c
ofproto/ofproto-dpif.c
ofproto/ofproto.c
ofproto/ofproto.h
ofproto/private.h
tests/ofproto.at
tests/ovs-ofctl.at
utilities/ovs-controller.c
utilities/ovs-ofctl.8.in
utilities/ovs-ofctl.c
utilities/ovs-openflowd.c
vswitchd/bridge.c
vswitchd/ovs-vswitchd.c

index 7df978b0cb9fbf0570c7e419f40374856da83243,241cfe99f3581047adb1d4693b6cc4d67f70dfa9..738fd90d8e255229bf5bc7bf52b265f1c646ae1d
@@@ -177,63 -167,6 +174,53 @@@ enum nicira_stats_type 
      NXST_AGGREGATE              /* Analogous to OFPST_AGGREGATE. */
  };
  
- /* NXT_TUN_ID_FROM_COOKIE request. */
- struct nxt_tun_id_cookie {
-     struct ofp_header header;
-     ovs_be32 vendor;            /* NX_VENDOR_ID. */
-     ovs_be32 subtype;           /* NXT_TUN_ID_FROM_COOKIE */
-     uint8_t set;                /* Nonzero to enable, zero to disable. */
-     uint8_t pad[7];
- };
- OFP_ASSERT(sizeof(struct nxt_tun_id_cookie) == 24);
 +/* This command enables or disables an Open vSwitch extension that allows a
 + * controller to specify the OpenFlow table to which a flow should be added,
 + * instead of having the switch decide which table is most appropriate as
 + * required by OpenFlow 1.0.  By default, the extension is disabled.
 + *
 + * When this feature is enabled, Open vSwitch treats struct ofp_flow_mod's
 + * 16-bit 'command' member as two separate fields.  The upper 8 bits are used
 + * as the table ID, the lower 8 bits specify the command as usual.  A table ID
 + * of 0xff is treated like a wildcarded table ID.
 + *
 + * The specific treatment of the table ID depends on the type of flow mod:
 + *
 + *    - OFPFC_ADD: Given a specific table ID, the flow is always placed in that
 + *      table.  If an identical flow already exists in that table only, then it
 + *      is replaced.  If the flow cannot be placed in the specified table,
 + *      either because the table is full or because the table cannot support
 + *      flows of the given type, the switch replies with an
 + *      OFPFMFC_ALL_TABLES_FULL error.  (A controller can distinguish these
 + *      cases by comparing the current and maximum number of entries reported
 + *      in ofp_table_stats.)
 + *
 + *      If the table ID is wildcarded, the switch picks an appropriate table
 + *      itself.  If an identical flow already exist in the selected flow table,
 + *      then it is replaced.  The choice of table might depend on the flows
 + *      that are already in the switch; for example, if one table fills up then
 + *      the switch might fall back to another one.
 + *
 + *    - OFPFC_MODIFY, OFPFC_DELETE: Given a specific table ID, only flows
 + *      within that table are matched and modified or deleted.  If the table ID
 + *      is wildcarded, flows within any table may be matched and modified or
 + *      deleted.
 + *
 + *    - OFPFC_MODIFY_STRICT, OFPFC_DELETE_STRICT: Given a specific table ID,
 + *      only a flow within that table may be matched and modified or deleted.
 + *      If the table ID is wildcarded and exactly one flow within any table
 + *      matches, then it is modified or deleted; if flows in more than one
 + *      table match, then none is modified or deleted.
 + */
 +struct nxt_flow_mod_table_id {
 +    struct ofp_header header;
 +    uint32_t vendor;            /* NX_VENDOR_ID. */
 +    uint32_t subtype;           /* NXT_FLOW_MOD_TABLE_ID. */
 +    uint8_t set;                /* Nonzero to enable, zero to disable. */
 +    uint8_t pad[7];
 +};
 +OFP_ASSERT(sizeof(struct nxt_flow_mod_table_id) == 24);
 +
  /* Configures the "role" of the sending controller.  The default role is:
   *
   *    - Other (NX_ROLE_OTHER), which allows the controller access to all
diff --cc lib/automake.mk
Simple merge
diff --cc lib/bond.c
Simple merge
diff --cc lib/bond.h
index 8736f4cd4d16d9c4d77493bf27660bad7b41da69,c2efb8b02faeff2b8d8aed39d6fb9333e2004b9c..fe587928dfd5f8549894de91437f8c68227c83bf
@@@ -74,8 -75,7 +75,8 @@@ void bond_destroy(struct bond *)
  
  bool bond_reconfigure(struct bond *, const struct bond_settings *);
  void bond_slave_register(struct bond *, void *slave_,
-                          uint16_t stable_id, struct netdev *);
+                          uint32_t stable_id, struct netdev *);
 +void bond_slave_set_netdev(struct bond *, void *slave_, struct netdev *);
  void bond_slave_unregister(struct bond *, const void *slave);
  
  void bond_run(struct bond *, struct tag_set *, bool lacp_negotiated);
Simple merge
diff --cc lib/dpif.c
Simple merge
diff --cc lib/dpif.h
Simple merge
diff --cc lib/flow.h
index f5f965c5b45bbacb8e6d85a70cae48131ada91b9,60229f58d3080440a0c33141e15d4fecf15e7ac8..6bd2c3d13ed715cd40132994502d3e0925ed9da8
@@@ -118,7 -118,7 +118,7 @@@ typedef unsigned int OVS_BITWISE flow_w
  #define FWW_TP_DST      ((OVS_FORCE flow_wildcards_t) (1 << 7))
  /* Same meanings as corresponding OFPFW_* bits, but differ in value. */
  #define FWW_NW_TOS      ((OVS_FORCE flow_wildcards_t) (1 << 1))
--/* No corresponding OFPFW_* or OVSFW_* bits. */
++/* No corresponding OFPFW_* bits. */
  #define FWW_ETH_MCAST   ((OVS_FORCE flow_wildcards_t) (1 << 8))
                                                         /* multicast bit only */
  #define FWW_ARP_SHA     ((OVS_FORCE flow_wildcards_t) (1 << 9))
index 75e04df62657b5a16e42668e6532ad6096cc7553,e003b8f994cfac8637ce4993e94f3e9f469f3c75..6bd2286234ca031d83d5f1fe6682e5963d830e11
@@@ -238,10 -238,8 +238,9 @@@ lswitch_process_packet(struct lswitch *
      case OFPUTIL_OFPST_PORT_REPLY:
      case OFPUTIL_OFPST_TABLE_REPLY:
      case OFPUTIL_OFPST_AGGREGATE_REPLY:
-     case OFPUTIL_NXT_TUN_ID_FROM_COOKIE:
      case OFPUTIL_NXT_ROLE_REQUEST:
      case OFPUTIL_NXT_ROLE_REPLY:
 +    case OFPUTIL_NXT_FLOW_MOD_TABLE_ID:
      case OFPUTIL_NXT_SET_FLOW_FORMAT:
      case OFPUTIL_NXT_FLOW_MOD:
      case OFPUTIL_NXT_FLOW_REMOVED:
Simple merge
diff --cc lib/ofp-parse.c
index c7ff4c3238a821a0effc433d359465048eb7a455,f45c450c65ca4b07cfed86fa554d3c753e9cf568..29137ac9d34675b78941e8e64a4bd8f334357d39
@@@ -850,10 -856,10 +850,10 @@@ parse_ofp_flow_mod_str(struct list *pac
      struct flow_mod fm;
  
      ofpbuf_init(&actions, 64);
 -    parse_ofp_str(&fm, NULL, is_del ? NULL : &actions, string);
 +    parse_ofp_str(&fm, is_del ? NULL : &actions, string);
      fm.command = command;
  
-     min_format = ofputil_min_flow_format(&fm.cr, true, fm.cookie);
+     min_format = ofputil_min_flow_format(&fm.cr);
      next_format = MAX(*cur_format, min_format);
      if (next_format != *cur_format) {
          struct ofpbuf *sff = ofputil_make_set_flow_format(next_format);
diff --cc lib/ofp-print.c
index 5b04d19234a5b1442087f1b8bc7460c4fb082c20,65dea728b399b1888b0756059e16ae7cfcd4c36f..cbac1e44ac8e67b80941db2e2f00e9bd9805dd61
@@@ -837,7 -834,7 +834,7 @@@ ofp_print_flow_mod(struct ds *s, const 
      bool need_priority;
      int error;
  
-     error = ofputil_decode_flow_mod(&fm, oh, NXFF_OPENFLOW10, true);
 -    error = ofputil_decode_flow_mod(&fm, oh);
++    error = ofputil_decode_flow_mod(&fm, oh, true);
      if (error) {
          ofp_print_error(s, error);
          return;
diff --cc lib/ofp-util.c
index 962727cc96b27af51b35774c6585075320c751c5,ddac77270e1b60c80ef7123d767f26121914cc02..3487cbac14528c3a8aa24a9786803508209c28e9
@@@ -408,14 -361,7 +370,10 @@@ static in
  ofputil_decode_vendor(const struct ofp_header *oh,
                        const struct ofputil_msg_type **typep)
  {
 +    BUILD_ASSERT_DECL(sizeof(struct nxt_set_flow_format)
 +                      != sizeof(struct nxt_flow_mod_table_id));
 +
      static const struct ofputil_msg_type nxt_messages[] = {
-         { OFPUTIL_NXT_TUN_ID_FROM_COOKIE,
-           NXT_TUN_ID_FROM_COOKIE, "NXT_TUN_ID_FROM_COOKIE",
-           sizeof(struct nxt_tun_id_cookie), 0 },
          { OFPUTIL_NXT_ROLE_REQUEST,
            NXT_ROLE_REQUEST, "NXT_ROLE_REQUEST",
            sizeof(struct nx_role_request), 0 },
@@@ -997,21 -856,11 +885,16 @@@ ofputil_make_flow_mod_table_id(bool flo
   * flow_mod in 'fm'.  Returns 0 if successful, otherwise an OpenFlow error
   * code.
   *
-  * For OFPT_FLOW_MOD messages, 'flow_format' should be the current flow format
-  * at the time when the message was received.  Otherwise 'flow_format' is
-  * ignored.
-  *
 + * 'flow_mod_table_id' should be true if the NXT_FLOW_MOD_TABLE_ID extension is
 + * enabled, false otherwise.
 + *
   * Does not validate the flow_mod actions. */
  int
 -ofputil_decode_flow_mod(struct flow_mod *fm, const struct ofp_header *oh)
 +ofputil_decode_flow_mod(struct flow_mod *fm, const struct ofp_header *oh,
-                         enum nx_flow_format flow_format,
 +                        bool flow_mod_table_id)
  {
      const struct ofputil_msg_type *type;
 +    uint16_t command;
      struct ofpbuf b;
  
      ofpbuf_use_const(&b, oh, ntohs(oh->length));
          }
  
          /* Translate the message. */
-         ofputil_cls_rule_from_match(&match, ntohs(ofm->priority), flow_format,
-                                     ofm->cookie, &fm->cr);
+         ofputil_cls_rule_from_match(&match, ntohs(ofm->priority), &fm->cr);
          fm->cookie = ofm->cookie;
 -        fm->command = ntohs(ofm->command);
 +        command = ntohs(ofm->command);
          fm->idle_timeout = ntohs(ofm->idle_timeout);
          fm->hard_timeout = ntohs(ofm->hard_timeout);
          fm->buffer_id = ntohl(ofm->buffer_id);
@@@ -1110,21 -946,15 +992,19 @@@ ofputil_encode_flow_mod(const struct fl
  {
      size_t actions_len = fm->n_actions * sizeof *fm->actions;
      struct ofpbuf *msg;
 +    uint16_t command;
 +
 +    command = (flow_mod_table_id
 +               ? (fm->command & 0xff) | (fm->table_id << 8)
 +               : fm->command);
  
-     if (flow_format == NXFF_OPENFLOW10
-         || flow_format == NXFF_TUN_ID_FROM_COOKIE) {
+     if (flow_format == NXFF_OPENFLOW10) {
          struct ofp_flow_mod *ofm;
  
          msg = ofpbuf_new(sizeof *ofm + actions_len);
          ofm = put_openflow(sizeof *ofm, OFPT_FLOW_MOD, msg);
-         ofputil_cls_rule_to_match(&fm->cr, flow_format, &ofm->match,
-                                   fm->cookie, &ofm->cookie);
-         ofm->command = htons(command);
+         ofputil_cls_rule_to_match(&fm->cr, &ofm->match);
 -        ofm->cookie = fm->cookie;
+         ofm->command = htons(fm->command);
          ofm->idle_timeout = htons(fm->idle_timeout);
          ofm->hard_timeout = htons(fm->hard_timeout);
          ofm->priority = htons(fm->cr.priority);
diff --cc lib/ofp-util.h
index 55c2c58891bc65cdfe4490c5d21c876fcd8508e4,6e69bae05e25baaa0b642f89543345e63c67ff50..c87b04b745a42f8531ae3223549471ad9ac1605c
@@@ -141,11 -130,9 +135,11 @@@ struct flow_mod 
      size_t n_actions;
  };
  
 -int ofputil_decode_flow_mod(struct flow_mod *, const struct ofp_header *);
 +int ofputil_decode_flow_mod(struct flow_mod *, const struct ofp_header *,
-                             enum nx_flow_format, bool flow_mod_table_id);
++                            bool flow_mod_table_id);
  struct ofpbuf *ofputil_encode_flow_mod(const struct flow_mod *,
 -                                       enum nx_flow_format);
 +                                       enum nx_flow_format,
 +                                       bool flow_mod_table_id);
  
  /* Flow stats or aggregate stats request, independent of flow format. */
  struct flow_stats_request {
Simple merge
Simple merge
index ea0e9e491bd98b1931f66454dc4422d8129db84c,0000000000000000000000000000000000000000..93acd429bbdadd6663b0a1e8fb46ad31892e6fd0
mode 100644,000000..100644
--- /dev/null
@@@ -1,3932 -1,0 +1,3934 @@@
-                 struct lacp_slave_settings *lacp)
 +/*
 + * Copyright (c) 2009, 2010, 2011 Nicira Networks.
 + *
 + * Licensed under the Apache License, Version 2.0 (the "License");
 + * you may not use this file except in compliance with the License.
 + * You may obtain a copy of the License at:
 + *
 + *     http://www.apache.org/licenses/LICENSE-2.0
 + *
 + * Unless required by applicable law or agreed to in writing, software
 + * distributed under the License is distributed on an "AS IS" BASIS,
 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 + * See the License for the specific language governing permissions and
 + * limitations under the License.
 + */
 +
 +#include <config.h>
 +
 +#include "ofproto/private.h"
 +
 +#include <errno.h>
 +
 +#include "autopath.h"
 +#include "bond.h"
 +#include "byte-order.h"
 +#include "connmgr.h"
 +#include "coverage.h"
 +#include "cfm.h"
 +#include "dpif.h"
 +#include "dynamic-string.h"
 +#include "fail-open.h"
 +#include "hmapx.h"
 +#include "lacp.h"
 +#include "mac-learning.h"
 +#include "multipath.h"
 +#include "netdev.h"
 +#include "netlink.h"
 +#include "nx-match.h"
 +#include "odp-util.h"
 +#include "ofp-util.h"
 +#include "ofpbuf.h"
 +#include "ofp-print.h"
 +#include "ofproto-sflow.h"
 +#include "poll-loop.h"
 +#include "timer.h"
 +#include "unaligned.h"
 +#include "unixctl.h"
 +#include "vlan-bitmap.h"
 +#include "vlog.h"
 +
 +VLOG_DEFINE_THIS_MODULE(ofproto_dpif);
 +
 +COVERAGE_DEFINE(ofproto_dpif_ctlr_action);
 +COVERAGE_DEFINE(ofproto_dpif_expired);
 +COVERAGE_DEFINE(ofproto_dpif_no_packet_in);
 +COVERAGE_DEFINE(ofproto_dpif_xlate);
 +COVERAGE_DEFINE(facet_changed_rule);
 +COVERAGE_DEFINE(facet_invalidated);
 +COVERAGE_DEFINE(facet_revalidate);
 +COVERAGE_DEFINE(facet_unexpected);
 +
 +/* Maximum depth of flow table recursion (due to NXAST_RESUBMIT actions) in a
 + * flow translation. */
 +#define MAX_RESUBMIT_RECURSION 16
 +
 +struct ofport_dpif;
 +struct ofproto_dpif;
 +
 +struct rule_dpif {
 +    struct rule up;
 +
 +    long long int used;         /* Time last used; time created if not used. */
 +
 +    /* These statistics:
 +     *
 +     *   - Do include packets and bytes from facets that have been deleted or
 +     *     whose own statistics have been folded into the rule.
 +     *
 +     *   - Do include packets and bytes sent "by hand" that were accounted to
 +     *     the rule without any facet being involved (this is a rare corner
 +     *     case in rule_execute()).
 +     *
 +     *   - Do not include packet or bytes that can be obtained from any facet's
 +     *     packet_count or byte_count member or that can be obtained from the
 +     *     datapath by, e.g., dpif_flow_get() for any facet.
 +     */
 +    uint64_t packet_count;       /* Number of packets received. */
 +    uint64_t byte_count;         /* Number of bytes received. */
 +
 +    struct list facets;          /* List of "struct facet"s. */
 +};
 +
 +static struct rule_dpif *rule_dpif_cast(const struct rule *rule)
 +{
 +    return rule ? CONTAINER_OF(rule, struct rule_dpif, up) : NULL;
 +}
 +
 +static struct rule_dpif *rule_dpif_lookup(struct ofproto_dpif *ofproto,
 +                                          const struct flow *flow);
 +
 +#define MAX_MIRRORS 32
 +typedef uint32_t mirror_mask_t;
 +#define MIRROR_MASK_C(X) UINT32_C(X)
 +BUILD_ASSERT_DECL(sizeof(mirror_mask_t) * CHAR_BIT >= MAX_MIRRORS);
 +struct ofmirror {
 +    struct ofproto_dpif *ofproto; /* Owning ofproto. */
 +    size_t idx;                 /* In ofproto's "mirrors" array. */
 +    void *aux;                  /* Key supplied by ofproto's client. */
 +    char *name;                 /* Identifier for log messages. */
 +
 +    /* Selection criteria. */
 +    struct hmapx srcs;          /* Contains "struct ofbundle *"s. */
 +    struct hmapx dsts;          /* Contains "struct ofbundle *"s. */
 +    unsigned long *vlans;       /* Bitmap of chosen VLANs, NULL selects all. */
 +
 +    /* Output (mutually exclusive). */
 +    struct ofbundle *out;       /* Output port or NULL. */
 +    int out_vlan;               /* Output VLAN or -1. */
 +};
 +
 +static void mirror_destroy(struct ofmirror *);
 +
 +/* A group of one or more OpenFlow ports. */
 +#define OFBUNDLE_FLOOD ((struct ofbundle *) 1)
 +struct ofbundle {
 +    struct ofproto_dpif *ofproto; /* Owning ofproto. */
 +    struct hmap_node hmap_node; /* In struct ofproto's "bundles" hmap. */
 +    void *aux;                  /* Key supplied by ofproto's client. */
 +    char *name;                 /* Identifier for log messages. */
 +
 +    /* Configuration. */
 +    struct list ports;          /* Contains "struct ofport"s. */
 +    int vlan;                   /* -1=trunk port, else a 12-bit VLAN ID. */
 +    unsigned long *trunks;      /* Bitmap of trunked VLANs, if 'vlan' == -1.
 +                                 * NULL if all VLANs are trunked. */
 +    struct lacp *lacp;          /* LACP if LACP is enabled, otherwise NULL. */
 +    struct bond *bond;          /* Nonnull iff more than one port. */
 +
 +    /* Status. */
 +    bool floodable;             /* True if no port has OFPPC_NO_FLOOD set. */
 +
 +    /* Port mirroring info. */
 +    mirror_mask_t src_mirrors;  /* Mirrors triggered when packet received. */
 +    mirror_mask_t dst_mirrors;  /* Mirrors triggered when packet sent. */
 +    mirror_mask_t mirror_out;   /* Mirrors that output to this bundle. */
 +};
 +
 +static void bundle_remove(struct ofport *);
 +static void bundle_destroy(struct ofbundle *);
 +static void bundle_del_port(struct ofport_dpif *);
 +static void bundle_run(struct ofbundle *);
 +static void bundle_wait(struct ofbundle *);
 +
 +struct action_xlate_ctx {
 +/* action_xlate_ctx_init() initializes these members. */
 +
 +    /* The ofproto. */
 +    struct ofproto_dpif *ofproto;
 +
 +    /* Flow to which the OpenFlow actions apply.  xlate_actions() will modify
 +     * this flow when actions change header fields. */
 +    struct flow flow;
 +
 +    /* The packet corresponding to 'flow', or a null pointer if we are
 +     * revalidating without a packet to refer to. */
 +    const struct ofpbuf *packet;
 +
 +    /* If nonnull, called just before executing a resubmit action.
 +     *
 +     * This is normally null so the client has to set it manually after
 +     * calling action_xlate_ctx_init(). */
 +    void (*resubmit_hook)(struct action_xlate_ctx *, struct rule_dpif *);
 +
 +/* xlate_actions() initializes and uses these members.  The client might want
 + * to look at them after it returns. */
 +
 +    struct ofpbuf *odp_actions; /* Datapath actions. */
 +    tag_type tags;              /* Tags associated with OFPP_NORMAL actions. */
 +    bool may_set_up_flow;       /* True ordinarily; false if the actions must
 +                                 * be reassessed for every packet. */
 +    uint16_t nf_output_iface;   /* Output interface index for NetFlow. */
 +
 +/* xlate_actions() initializes and uses these members, but the client has no
 + * reason to look at them. */
 +
 +    int recurse;                /* Recursion level, via xlate_table_action. */
 +    int last_pop_priority;      /* Offset in 'odp_actions' just past most
 +                                 * recent ODP_ACTION_ATTR_SET_PRIORITY. */
 +};
 +
 +static void action_xlate_ctx_init(struct action_xlate_ctx *,
 +                                  struct ofproto_dpif *, const struct flow *,
 +                                  const struct ofpbuf *);
 +static struct ofpbuf *xlate_actions(struct action_xlate_ctx *,
 +                                    const union ofp_action *in, size_t n_in);
 +
 +/* An exact-match instantiation of an OpenFlow flow. */
 +struct facet {
 +    long long int used;         /* Time last used; time created if not used. */
 +
 +    /* These statistics:
 +     *
 +     *   - Do include packets and bytes sent "by hand", e.g. with
 +     *     dpif_execute().
 +     *
 +     *   - Do include packets and bytes that were obtained from the datapath
 +     *     when a flow was deleted (e.g. dpif_flow_del()) or when its
 +     *     statistics were reset (e.g. dpif_flow_put() with
 +     *     DPIF_FP_ZERO_STATS).
 +     *
 +     *   - Do not include any packets or bytes that can currently be obtained
 +     *     from the datapath by, e.g., dpif_flow_get().
 +     */
 +    uint64_t packet_count;       /* Number of packets received. */
 +    uint64_t byte_count;         /* Number of bytes received. */
 +
 +    uint64_t dp_packet_count;    /* Last known packet count in the datapath. */
 +    uint64_t dp_byte_count;      /* Last known byte count in the datapath. */
 +
 +    uint64_t rs_packet_count;    /* Packets pushed to resubmit children. */
 +    uint64_t rs_byte_count;      /* Bytes pushed to resubmit children. */
 +    long long int rs_used;       /* Used time pushed to resubmit children. */
 +
 +    /* Number of bytes passed to account_cb.  This may include bytes that can
 +     * currently obtained from the datapath (thus, it can be greater than
 +     * byte_count). */
 +    uint64_t accounted_bytes;
 +
 +    struct hmap_node hmap_node;  /* In owning ofproto's 'facets' hmap. */
 +    struct list list_node;       /* In owning rule's 'facets' list. */
 +    struct rule_dpif *rule;      /* Owning rule. */
 +    struct flow flow;            /* Exact-match flow. */
 +    bool installed;              /* Installed in datapath? */
 +    bool may_install;            /* True ordinarily; false if actions must
 +                                  * be reassessed for every packet. */
 +    size_t actions_len;          /* Number of bytes in actions[]. */
 +    struct nlattr *actions;      /* Datapath actions. */
 +    tag_type tags;               /* Tags. */
 +    struct netflow_flow nf_flow; /* Per-flow NetFlow tracking data. */
 +};
 +
 +static struct facet *facet_create(struct rule_dpif *, const struct flow *,
 +                                  const struct ofpbuf *packet);
 +static void facet_remove(struct ofproto_dpif *, struct facet *);
 +static void facet_free(struct facet *);
 +
 +static struct facet *facet_find(struct ofproto_dpif *, const struct flow *);
 +static struct facet *facet_lookup_valid(struct ofproto_dpif *,
 +                                        const struct flow *);
 +static bool facet_revalidate(struct ofproto_dpif *, struct facet *);
 +
 +static void facet_execute(struct ofproto_dpif *, struct facet *,
 +                          struct ofpbuf *packet);
 +
 +static int facet_put__(struct ofproto_dpif *, struct facet *,
 +                       const struct nlattr *actions, size_t actions_len,
 +                       struct dpif_flow_stats *);
 +static void facet_install(struct ofproto_dpif *, struct facet *,
 +                          bool zero_stats);
 +static void facet_uninstall(struct ofproto_dpif *, struct facet *);
 +static void facet_flush_stats(struct ofproto_dpif *, struct facet *);
 +
 +static void facet_make_actions(struct ofproto_dpif *, struct facet *,
 +                               const struct ofpbuf *packet);
 +static void facet_update_time(struct ofproto_dpif *, struct facet *,
 +                              long long int used);
 +static void facet_update_stats(struct ofproto_dpif *, struct facet *,
 +                               const struct dpif_flow_stats *);
 +static void facet_push_stats(struct facet *);
 +static void facet_account(struct ofproto_dpif *, struct facet *,
 +                          uint64_t extra_bytes);
 +
 +static bool facet_is_controller_flow(struct facet *);
 +
 +static void flow_push_stats(const struct rule_dpif *,
 +                            struct flow *, uint64_t packets, uint64_t bytes,
 +                            long long int used);
 +
 +struct ofport_dpif {
 +    struct ofport up;
 +
 +    uint32_t odp_port;
 +    struct ofbundle *bundle;    /* Bundle that contains this port, if any. */
 +    struct list bundle_node;    /* In struct ofbundle's "ports" list. */
 +    struct cfm *cfm;            /* Connectivity Fault Management, if any. */
 +    tag_type tag;               /* Tag associated with this port. */
++    uint32_t bond_stable_id;    /* stable_id to use as bond slave, or 0. */
 +};
 +
 +static struct ofport_dpif *
 +ofport_dpif_cast(const struct ofport *ofport)
 +{
 +    assert(ofport->ofproto->ofproto_class == &ofproto_dpif_class);
 +    return ofport ? CONTAINER_OF(ofport, struct ofport_dpif, up) : NULL;
 +}
 +
 +static void port_run(struct ofport_dpif *);
 +static void port_wait(struct ofport_dpif *);
 +static int set_cfm(struct ofport *, const struct cfm *,
 +                   const uint16_t *remote_mps, size_t n_remote_mps);
 +
 +struct ofproto_dpif {
 +    struct ofproto up;
 +    struct dpif *dpif;
 +    int max_ports;
 +
 +    /* Statistics. */
 +    uint64_t n_matches;
 +
 +    /* Bridging. */
 +    struct netflow *netflow;
 +    struct ofproto_sflow *sflow;
 +    struct hmap bundles;        /* Contains "struct ofbundle"s. */
 +    struct mac_learning *ml;
 +    struct ofmirror *mirrors[MAX_MIRRORS];
 +    bool has_bonded_bundles;
 +
 +    /* Expiration. */
 +    struct timer next_expiration;
 +
 +    /* Facets. */
 +    struct hmap facets;
 +    bool need_revalidate;
 +    struct tag_set revalidate_set;
 +};
 +
 +static void ofproto_dpif_unixctl_init(void);
 +
 +static struct ofproto_dpif *
 +ofproto_dpif_cast(const struct ofproto *ofproto)
 +{
 +    assert(ofproto->ofproto_class == &ofproto_dpif_class);
 +    return CONTAINER_OF(ofproto, struct ofproto_dpif, up);
 +}
 +
 +static struct ofport_dpif *get_ofp_port(struct ofproto_dpif *,
 +                                        uint16_t ofp_port);
 +static struct ofport_dpif *get_odp_port(struct ofproto_dpif *,
 +                                        uint32_t odp_port);
 +
 +/* Packet processing. */
 +static void update_learning_table(struct ofproto_dpif *,
 +                                  const struct flow *, int vlan,
 +                                  struct ofbundle *);
 +static bool is_admissible(struct ofproto_dpif *, const struct flow *,
 +                          bool have_packet, tag_type *, int *vlanp,
 +                          struct ofbundle **in_bundlep);
 +static void handle_upcall(struct ofproto_dpif *, struct dpif_upcall *);
 +
 +/* Flow expiration. */
 +static int expire(struct ofproto_dpif *);
 +
 +/* Utilities. */
 +static int send_packet(struct ofproto_dpif *,
 +                       uint32_t odp_port, uint16_t vlan_tci,
 +                       const struct ofpbuf *packet);
 +
 +/* Global variables. */
 +static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 +\f
 +/* Factory functions. */
 +
 +static void
 +enumerate_types(struct sset *types)
 +{
 +    dp_enumerate_types(types);
 +}
 +
 +static int
 +enumerate_names(const char *type, struct sset *names)
 +{
 +    return dp_enumerate_names(type, names);
 +}
 +
 +static int
 +del(const char *type, const char *name)
 +{
 +    struct dpif *dpif;
 +    int error;
 +
 +    error = dpif_open(name, type, &dpif);
 +    if (!error) {
 +        error = dpif_delete(dpif);
 +        dpif_close(dpif);
 +    }
 +    return error;
 +}
 +\f
 +/* Basic life-cycle. */
 +
 +static struct ofproto *
 +alloc(void)
 +{
 +    struct ofproto_dpif *ofproto = xmalloc(sizeof *ofproto);
 +    return &ofproto->up;
 +}
 +
 +static void
 +dealloc(struct ofproto *ofproto_)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    free(ofproto);
 +}
 +
 +static int
 +construct(struct ofproto *ofproto_)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    const char *name = ofproto->up.name;
 +    int error;
 +    int i;
 +
 +    error = dpif_create_and_open(name, ofproto->up.type, &ofproto->dpif);
 +    if (error) {
 +        VLOG_ERR("failed to open datapath %s: %s", name, strerror(error));
 +        return error;
 +    }
 +
 +    ofproto->max_ports = dpif_get_max_ports(ofproto->dpif);
 +    ofproto->n_matches = 0;
 +
 +    error = dpif_recv_set_mask(ofproto->dpif,
 +                               ((1u << DPIF_UC_MISS) |
 +                                (1u << DPIF_UC_ACTION) |
 +                                (1u << DPIF_UC_SAMPLE)));
 +    if (error) {
 +        VLOG_ERR("failed to listen on datapath %s: %s", name, strerror(error));
 +        dpif_close(ofproto->dpif);
 +        return error;
 +    }
 +    dpif_flow_flush(ofproto->dpif);
 +    dpif_recv_purge(ofproto->dpif);
 +
 +    ofproto->netflow = NULL;
 +    ofproto->sflow = NULL;
 +    hmap_init(&ofproto->bundles);
 +    ofproto->ml = mac_learning_create();
 +    for (i = 0; i < MAX_MIRRORS; i++) {
 +        ofproto->mirrors[i] = NULL;
 +    }
 +    ofproto->has_bonded_bundles = false;
 +
 +    timer_set_duration(&ofproto->next_expiration, 1000);
 +
 +    hmap_init(&ofproto->facets);
 +    ofproto->need_revalidate = false;
 +    tag_set_init(&ofproto->revalidate_set);
 +
 +    ofproto->up.tables = xmalloc(sizeof *ofproto->up.tables);
 +    classifier_init(&ofproto->up.tables[0]);
 +    ofproto->up.n_tables = 1;
 +
 +    ofproto_dpif_unixctl_init();
 +
 +    return 0;
 +}
 +
 +static void
 +destruct(struct ofproto *ofproto_)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    int i;
 +
 +    for (i = 0; i < MAX_MIRRORS; i++) {
 +        mirror_destroy(ofproto->mirrors[i]);
 +    }
 +
 +    netflow_destroy(ofproto->netflow);
 +    ofproto_sflow_destroy(ofproto->sflow);
 +    hmap_destroy(&ofproto->bundles);
 +    mac_learning_destroy(ofproto->ml);
 +
 +    hmap_destroy(&ofproto->facets);
 +
 +    dpif_close(ofproto->dpif);
 +}
 +
 +static int
 +run(struct ofproto *ofproto_)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    struct ofport_dpif *ofport;
 +    struct ofbundle *bundle;
 +    int i;
 +
 +    dpif_run(ofproto->dpif);
 +
 +    for (i = 0; i < 50; i++) {
 +        struct dpif_upcall packet;
 +        int error;
 +
 +        error = dpif_recv(ofproto->dpif, &packet);
 +        if (error) {
 +            if (error == ENODEV) {
 +                /* Datapath destroyed. */
 +                return error;
 +            }
 +            break;
 +        }
 +
 +        handle_upcall(ofproto, &packet);
 +    }
 +
 +    if (timer_expired(&ofproto->next_expiration)) {
 +        int delay = expire(ofproto);
 +        timer_set_duration(&ofproto->next_expiration, delay);
 +    }
 +
 +    if (ofproto->netflow) {
 +        netflow_run(ofproto->netflow);
 +    }
 +    if (ofproto->sflow) {
 +        ofproto_sflow_run(ofproto->sflow);
 +    }
 +
 +    HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
 +        port_run(ofport);
 +    }
 +    HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
 +        bundle_run(bundle);
 +    }
 +
 +    /* Now revalidate if there's anything to do. */
 +    if (ofproto->need_revalidate
 +        || !tag_set_is_empty(&ofproto->revalidate_set)) {
 +        struct tag_set revalidate_set = ofproto->revalidate_set;
 +        bool revalidate_all = ofproto->need_revalidate;
 +        struct facet *facet, *next;
 +
 +        /* Clear the revalidation flags. */
 +        tag_set_init(&ofproto->revalidate_set);
 +        ofproto->need_revalidate = false;
 +
 +        HMAP_FOR_EACH_SAFE (facet, next, hmap_node, &ofproto->facets) {
 +            if (revalidate_all
 +                || tag_set_intersects(&revalidate_set, facet->tags)) {
 +                facet_revalidate(ofproto, facet);
 +            }
 +        }
 +    }
 +
 +    return 0;
 +}
 +
 +static void
 +wait(struct ofproto *ofproto_)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    struct ofport_dpif *ofport;
 +    struct ofbundle *bundle;
 +
 +    dpif_wait(ofproto->dpif);
 +    dpif_recv_wait(ofproto->dpif);
 +    if (ofproto->sflow) {
 +        ofproto_sflow_wait(ofproto->sflow);
 +    }
 +    if (!tag_set_is_empty(&ofproto->revalidate_set)) {
 +        poll_immediate_wake();
 +    }
 +    HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
 +        port_wait(ofport);
 +    }
 +    HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
 +        bundle_wait(bundle);
 +    }
 +    if (ofproto->need_revalidate) {
 +        /* Shouldn't happen, but if it does just go around again. */
 +        VLOG_DBG_RL(&rl, "need revalidate in ofproto_wait_cb()");
 +        poll_immediate_wake();
 +    } else {
 +        timer_wait(&ofproto->next_expiration);
 +    }
 +}
 +
 +static void
 +flush(struct ofproto *ofproto_)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    struct facet *facet, *next_facet;
 +
 +    HMAP_FOR_EACH_SAFE (facet, next_facet, hmap_node, &ofproto->facets) {
 +        /* Mark the facet as not installed so that facet_remove() doesn't
 +         * bother trying to uninstall it.  There is no point in uninstalling it
 +         * individually since we are about to blow away all the facets with
 +         * dpif_flow_flush(). */
 +        facet->installed = false;
 +        facet->dp_packet_count = 0;
 +        facet->dp_byte_count = 0;
 +        facet_remove(ofproto, facet);
 +    }
 +    dpif_flow_flush(ofproto->dpif);
 +}
 +
 +static void
 +get_features(struct ofproto *ofproto_ OVS_UNUSED,
 +             bool *arp_match_ip, uint32_t *actions)
 +{
 +    *arp_match_ip = true;
 +    *actions = ((1u << OFPAT_OUTPUT) |
 +                (1u << OFPAT_SET_VLAN_VID) |
 +                (1u << OFPAT_SET_VLAN_PCP) |
 +                (1u << OFPAT_STRIP_VLAN) |
 +                (1u << OFPAT_SET_DL_SRC) |
 +                (1u << OFPAT_SET_DL_DST) |
 +                (1u << OFPAT_SET_NW_SRC) |
 +                (1u << OFPAT_SET_NW_DST) |
 +                (1u << OFPAT_SET_NW_TOS) |
 +                (1u << OFPAT_SET_TP_SRC) |
 +                (1u << OFPAT_SET_TP_DST) |
 +                (1u << OFPAT_ENQUEUE));
 +}
 +
 +static void
 +get_tables(struct ofproto *ofproto_, struct ofp_table_stats *ots)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    struct odp_stats s;
 +
 +    strcpy(ots->name, "classifier");
 +
 +    dpif_get_dp_stats(ofproto->dpif, &s);
 +    put_32aligned_be64(&ots->lookup_count, htonll(s.n_hit + s.n_missed));
 +    put_32aligned_be64(&ots->matched_count,
 +                       htonll(s.n_hit + ofproto->n_matches));
 +}
 +
 +static int
 +set_netflow(struct ofproto *ofproto_,
 +            const struct netflow_options *netflow_options)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +
 +    if (netflow_options) {
 +        if (!ofproto->netflow) {
 +            ofproto->netflow = netflow_create();
 +        }
 +        return netflow_set_options(ofproto->netflow, netflow_options);
 +    } else {
 +        netflow_destroy(ofproto->netflow);
 +        ofproto->netflow = NULL;
 +        return 0;
 +    }
 +}
 +
 +static struct ofport *
 +port_alloc(void)
 +{
 +    struct ofport_dpif *port = xmalloc(sizeof *port);
 +    return &port->up;
 +}
 +
 +static void
 +port_dealloc(struct ofport *port_)
 +{
 +    struct ofport_dpif *port = ofport_dpif_cast(port_);
 +    free(port);
 +}
 +
 +static int
 +port_construct(struct ofport *port_)
 +{
 +    struct ofport_dpif *port = ofport_dpif_cast(port_);
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
 +
 +    port->odp_port = ofp_port_to_odp_port(port->up.ofp_port);
 +    port->bundle = NULL;
 +    port->cfm = NULL;
 +    port->tag = tag_create_random();
 +
 +    if (ofproto->sflow) {
 +        ofproto_sflow_add_port(ofproto->sflow, port->odp_port,
 +                               netdev_get_name(port->up.netdev));
 +    }
 +
 +    return 0;
 +}
 +
 +static void
 +port_destruct(struct ofport *port_)
 +{
 +    struct ofport_dpif *port = ofport_dpif_cast(port_);
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
 +
 +    bundle_remove(port_);
 +    set_cfm(port_, NULL, NULL, 0);
 +    if (ofproto->sflow) {
 +        ofproto_sflow_del_port(ofproto->sflow, port->odp_port);
 +    }
 +}
 +
 +static void
 +port_modified(struct ofport *port_)
 +{
 +    struct ofport_dpif *port = ofport_dpif_cast(port_);
 +
 +    if (port->bundle && port->bundle->bond) {
 +        bond_slave_set_netdev(port->bundle->bond, port, port->up.netdev);
 +    }
 +}
 +
 +static void
 +port_reconfigured(struct ofport *port_, ovs_be32 old_config)
 +{
 +    struct ofport_dpif *port = ofport_dpif_cast(port_);
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
 +    ovs_be32 changed = old_config ^ port->up.opp.config;
 +
 +    if (changed & htonl(OFPPC_NO_RECV | OFPPC_NO_RECV_STP |
 +                        OFPPC_NO_FWD | OFPPC_NO_FLOOD)) {
 +        ofproto->need_revalidate = true;
 +    }
 +}
 +
 +static int
 +set_sflow(struct ofproto *ofproto_,
 +          const struct ofproto_sflow_options *sflow_options)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    struct ofproto_sflow *os = ofproto->sflow;
 +    if (sflow_options) {
 +        if (!os) {
 +            struct ofport_dpif *ofport;
 +
 +            os = ofproto->sflow = ofproto_sflow_create(ofproto->dpif);
 +            HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
 +                ofproto_sflow_add_port(os, ofport->odp_port,
 +                                       netdev_get_name(ofport->up.netdev));
 +            }
 +        }
 +        ofproto_sflow_set_options(os, sflow_options);
 +    } else {
 +        ofproto_sflow_destroy(os);
 +        ofproto->sflow = NULL;
 +    }
 +    return 0;
 +}
 +
 +static int
 +set_cfm(struct ofport *ofport_, const struct cfm *cfm,
 +        const uint16_t *remote_mps, size_t n_remote_mps)
 +{
 +    struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
 +    int error;
 +
 +    if (!cfm) {
 +        error = 0;
 +    } else {
 +        if (!ofport->cfm) {
 +            ofport->cfm = cfm_create();
 +        }
 +
 +        ofport->cfm->mpid = cfm->mpid;
 +        ofport->cfm->interval = cfm->interval;
 +        memcpy(ofport->cfm->maid, cfm->maid, CCM_MAID_LEN);
 +
 +        cfm_update_remote_mps(ofport->cfm, remote_mps, n_remote_mps);
 +
 +        if (cfm_configure(ofport->cfm)) {
 +            return 0;
 +        }
 +
 +        error = EINVAL;
 +    }
 +    cfm_destroy(ofport->cfm);
 +    ofport->cfm = NULL;
 +    return error;
 +}
 +
 +static int
 +get_cfm(struct ofport *ofport_, const struct cfm **cfmp)
 +{
 +    struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
 +    *cfmp = ofport->cfm;
 +    return 0;
 +}
 +\f
 +/* Bundles. */
 +
 +/* Expires all MAC learning entries associated with 'port' and forces ofproto
 + * to revalidate every flow. */
 +static void
 +bundle_flush_macs(struct ofbundle *bundle)
 +{
 +    struct ofproto_dpif *ofproto = bundle->ofproto;
 +    struct mac_learning *ml = ofproto->ml;
 +    struct mac_entry *mac, *next_mac;
 +
 +    ofproto->need_revalidate = true;
 +    LIST_FOR_EACH_SAFE (mac, next_mac, lru_node, &ml->lrus) {
 +        if (mac->port.p == bundle) {
 +            mac_learning_expire(ml, mac);
 +        }
 +    }
 +}
 +
 +static struct ofbundle *
 +bundle_lookup(const struct ofproto_dpif *ofproto, void *aux)
 +{
 +    struct ofbundle *bundle;
 +
 +    HMAP_FOR_EACH_IN_BUCKET (bundle, hmap_node, hash_pointer(aux, 0),
 +                             &ofproto->bundles) {
 +        if (bundle->aux == aux) {
 +            return bundle;
 +        }
 +    }
 +    return NULL;
 +}
 +
 +/* Looks up each of the 'n_auxes' pointers in 'auxes' as bundles and adds the
 + * ones that are found to 'bundles'. */
 +static void
 +bundle_lookup_multiple(struct ofproto_dpif *ofproto,
 +                       void **auxes, size_t n_auxes,
 +                       struct hmapx *bundles)
 +{
 +    size_t i;
 +
 +    hmapx_init(bundles);
 +    for (i = 0; i < n_auxes; i++) {
 +        struct ofbundle *bundle = bundle_lookup(ofproto, auxes[i]);
 +        if (bundle) {
 +            hmapx_add(bundles, bundle);
 +        }
 +    }
 +}
 +
 +static void
 +bundle_del_port(struct ofport_dpif *port)
 +{
 +    struct ofbundle *bundle = port->bundle;
 +
 +    list_remove(&port->bundle_node);
 +    port->bundle = NULL;
 +
 +    if (bundle->lacp) {
 +        lacp_slave_unregister(bundle->lacp, port);
 +    }
 +    if (bundle->bond) {
 +        bond_slave_unregister(bundle->bond, port);
 +    }
 +
 +    bundle->floodable = true;
 +    LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
 +        if (port->up.opp.config & htonl(OFPPC_NO_FLOOD)) {
 +            bundle->floodable = false;
 +        }
 +    }
 +}
 +
 +static bool
 +bundle_add_port(struct ofbundle *bundle, uint32_t ofp_port,
-                              s->lacp ? &s->lacp_slaves[i] : NULL)) {
++                struct lacp_slave_settings *lacp,
++                uint32_t bond_stable_id)
 +{
 +    struct ofport_dpif *port;
 +
 +    port = get_ofp_port(bundle->ofproto, ofp_port);
 +    if (!port) {
 +        return false;
 +    }
 +
 +    if (port->bundle != bundle) {
 +        if (port->bundle) {
 +            bundle_del_port(port);
 +        }
 +
 +        port->bundle = bundle;
 +        list_push_back(&bundle->ports, &port->bundle_node);
 +        if (port->up.opp.config & htonl(OFPPC_NO_FLOOD)) {
 +            bundle->floodable = false;
 +        }
 +    }
 +    if (lacp) {
 +        lacp_slave_register(bundle->lacp, port, lacp);
 +    }
 +
++    port->bond_stable_id = bond_stable_id;
++
 +    return true;
 +}
 +
 +static void
 +bundle_destroy(struct ofbundle *bundle)
 +{
 +    struct ofproto_dpif *ofproto;
 +    struct ofport_dpif *port, *next_port;
 +    int i;
 +
 +    if (!bundle) {
 +        return;
 +    }
 +
 +    ofproto = bundle->ofproto;
 +    for (i = 0; i < MAX_MIRRORS; i++) {
 +        struct ofmirror *m = ofproto->mirrors[i];
 +        if (m) {
 +            if (m->out == bundle) {
 +                mirror_destroy(m);
 +            } else if (hmapx_find_and_delete(&m->srcs, bundle)
 +                       || hmapx_find_and_delete(&m->dsts, bundle)) {
 +                ofproto->need_revalidate = true;
 +            }
 +        }
 +    }
 +
 +    LIST_FOR_EACH_SAFE (port, next_port, bundle_node, &bundle->ports) {
 +        bundle_del_port(port);
 +    }
 +
 +    bundle_flush_macs(bundle);
 +    hmap_remove(&ofproto->bundles, &bundle->hmap_node);
 +    free(bundle->name);
 +    free(bundle->trunks);
 +    lacp_destroy(bundle->lacp);
 +    bond_destroy(bundle->bond);
 +    free(bundle);
 +}
 +
 +static int
 +bundle_set(struct ofproto *ofproto_, void *aux,
 +           const struct ofproto_bundle_settings *s)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    bool need_flush = false;
 +    const unsigned long *trunks;
 +    struct ofport_dpif *port;
 +    struct ofbundle *bundle;
 +    size_t i;
 +    bool ok;
 +
 +    if (!s) {
 +        bundle_destroy(bundle_lookup(ofproto, aux));
 +        return 0;
 +    }
 +
 +    assert(s->n_slaves == 1 || s->bond != NULL);
 +    assert((s->lacp != NULL) == (s->lacp_slaves != NULL));
 +
 +    bundle = bundle_lookup(ofproto, aux);
 +    if (!bundle) {
 +        bundle = xmalloc(sizeof *bundle);
 +
 +        bundle->ofproto = ofproto;
 +        hmap_insert(&ofproto->bundles, &bundle->hmap_node,
 +                    hash_pointer(aux, 0));
 +        bundle->aux = aux;
 +        bundle->name = NULL;
 +
 +        list_init(&bundle->ports);
 +        bundle->vlan = -1;
 +        bundle->trunks = NULL;
 +        bundle->lacp = NULL;
 +        bundle->bond = NULL;
 +
 +        bundle->floodable = true;
 +
 +        bundle->src_mirrors = 0;
 +        bundle->dst_mirrors = 0;
 +        bundle->mirror_out = 0;
 +    }
 +
 +    if (!bundle->name || strcmp(s->name, bundle->name)) {
 +        free(bundle->name);
 +        bundle->name = xstrdup(s->name);
 +    }
 +
 +    /* LACP. */
 +    if (s->lacp) {
 +        if (!bundle->lacp) {
 +            bundle->lacp = lacp_create();
 +        }
 +        lacp_configure(bundle->lacp, s->lacp);
 +    } else {
 +        lacp_destroy(bundle->lacp);
 +        bundle->lacp = NULL;
 +    }
 +
 +    /* Update set of ports. */
 +    ok = true;
 +    for (i = 0; i < s->n_slaves; i++) {
 +        if (!bundle_add_port(bundle, s->slaves[i],
-             uint16_t stable_id = (bundle->lacp
-                                   ? lacp_slave_get_port_id(bundle->lacp, port)
-                                   : port->odp_port);
-             bond_slave_register(bundle->bond, port, stable_id,
++                             s->lacp ? &s->lacp_slaves[i] : NULL,
++                             s->bond_stable_ids ? s->bond_stable_ids[i] : 0)) {
 +            ok = false;
 +        }
 +    }
 +    if (!ok || list_size(&bundle->ports) != s->n_slaves) {
 +        struct ofport_dpif *next_port;
 +
 +        LIST_FOR_EACH_SAFE (port, next_port, bundle_node, &bundle->ports) {
 +            for (i = 0; i < s->n_slaves; i++) {
 +                if (s->slaves[i] == odp_port_to_ofp_port(port->odp_port)) {
 +                    goto found;
 +                }
 +            }
 +
 +            bundle_del_port(port);
 +        found: ;
 +        }
 +    }
 +    assert(list_size(&bundle->ports) <= s->n_slaves);
 +
 +    if (list_is_empty(&bundle->ports)) {
 +        bundle_destroy(bundle);
 +        return EINVAL;
 +    }
 +
 +    /* Set VLAN tag. */
 +    if (s->vlan != bundle->vlan) {
 +        bundle->vlan = s->vlan;
 +        need_flush = true;
 +    }
 +
 +    /* Get trunked VLANs. */
 +    trunks = s->vlan == -1 ? NULL : s->trunks;
 +    if (!vlan_bitmap_equal(trunks, bundle->trunks)) {
 +        free(bundle->trunks);
 +        bundle->trunks = vlan_bitmap_clone(trunks);
 +        need_flush = true;
 +    }
 +
 +    /* Bonding. */
 +    if (!list_is_short(&bundle->ports)) {
 +        bundle->ofproto->has_bonded_bundles = true;
 +        if (bundle->bond) {
 +            if (bond_reconfigure(bundle->bond, s->bond)) {
 +                ofproto->need_revalidate = true;
 +            }
 +        } else {
 +            bundle->bond = bond_create(s->bond);
 +        }
 +
 +        LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
++            bond_slave_register(bundle->bond, port, port->bond_stable_id,
 +                                port->up.netdev);
 +        }
 +    } else {
 +        bond_destroy(bundle->bond);
 +        bundle->bond = NULL;
 +    }
 +
 +    /* If we changed something that would affect MAC learning, un-learn
 +     * everything on this port and force flow revalidation. */
 +    if (need_flush) {
 +        bundle_flush_macs(bundle);
 +    }
 +
 +    return 0;
 +}
 +
 +static void
 +bundle_remove(struct ofport *port_)
 +{
 +    struct ofport_dpif *port = ofport_dpif_cast(port_);
 +    struct ofbundle *bundle = port->bundle;
 +
 +    if (bundle) {
 +        bundle_del_port(port);
 +        if (list_is_empty(&bundle->ports)) {
 +            bundle_destroy(bundle);
 +        } else if (list_is_short(&bundle->ports)) {
 +            bond_destroy(bundle->bond);
 +            bundle->bond = NULL;
 +        }
 +    }
 +}
 +
 +static void
 +send_pdu_cb(void *port_, const struct lacp_pdu *pdu)
 +{
 +    static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 10);
 +    struct ofport_dpif *port = port_;
 +    uint8_t ea[ETH_ADDR_LEN];
 +    int error;
 +
 +    error = netdev_get_etheraddr(port->up.netdev, ea);
 +    if (!error) {
 +        struct lacp_pdu *packet_pdu;
 +        struct ofpbuf packet;
 +
 +        ofpbuf_init(&packet, 0);
 +        packet_pdu = eth_compose(&packet, eth_addr_lacp, ea, ETH_TYPE_LACP,
 +                                 sizeof *packet_pdu);
 +        *packet_pdu = *pdu;
 +        error = netdev_send(port->up.netdev, &packet);
 +        if (error) {
 +            VLOG_WARN_RL(&rl, "port %s: sending LACP PDU on iface %s failed "
 +                         "(%s)", port->bundle->name,
 +                         netdev_get_name(port->up.netdev), strerror(error));
 +        }
 +        ofpbuf_uninit(&packet);
 +    } else {
 +        VLOG_ERR_RL(&rl, "port %s: cannot obtain Ethernet address of iface "
 +                    "%s (%s)", port->bundle->name,
 +                    netdev_get_name(port->up.netdev), strerror(error));
 +    }
 +}
 +
 +static void
 +bundle_send_learning_packets(struct ofbundle *bundle)
 +{
 +    struct ofproto_dpif *ofproto = bundle->ofproto;
 +    int error, n_packets, n_errors;
 +    struct mac_entry *e;
 +
 +    error = n_packets = n_errors = 0;
 +    LIST_FOR_EACH (e, lru_node, &ofproto->ml->lrus) {
 +        if (e->port.p != bundle) {
 +            int ret = bond_send_learning_packet(bundle->bond, e->mac, e->vlan);
 +            if (ret) {
 +                error = ret;
 +                n_errors++;
 +            }
 +            n_packets++;
 +        }
 +    }
 +
 +    if (n_errors) {
 +        static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 +        VLOG_WARN_RL(&rl, "bond %s: %d errors sending %d gratuitous learning "
 +                     "packets, last error was: %s",
 +                     bundle->name, n_errors, n_packets, strerror(error));
 +    } else {
 +        VLOG_DBG("bond %s: sent %d gratuitous learning packets",
 +                 bundle->name, n_packets);
 +    }
 +}
 +
 +static void
 +bundle_run(struct ofbundle *bundle)
 +{
 +    if (bundle->lacp) {
 +        lacp_run(bundle->lacp, send_pdu_cb);
 +    }
 +    if (bundle->bond) {
 +        struct ofport_dpif *port;
 +
 +        LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
 +            bool may_enable = lacp_slave_may_enable(bundle->lacp, port);
 +            bond_slave_set_lacp_may_enable(bundle->bond, port, may_enable);
 +        }
 +
 +        bond_run(bundle->bond, &bundle->ofproto->revalidate_set,
 +                 lacp_negotiated(bundle->lacp));
 +        if (bond_should_send_learning_packets(bundle->bond)) {
 +            bundle_send_learning_packets(bundle);
 +        }
 +    }
 +}
 +
 +static void
 +bundle_wait(struct ofbundle *bundle)
 +{
 +    if (bundle->lacp) {
 +        lacp_wait(bundle->lacp);
 +    }
 +    if (bundle->bond) {
 +        bond_wait(bundle->bond);
 +    }
 +}
 +\f
 +/* Mirrors. */
 +
 +static int
 +mirror_scan(struct ofproto_dpif *ofproto)
 +{
 +    int idx;
 +
 +    for (idx = 0; idx < MAX_MIRRORS; idx++) {
 +        if (!ofproto->mirrors[idx]) {
 +            return idx;
 +        }
 +    }
 +    return -1;
 +}
 +
 +static struct ofmirror *
 +mirror_lookup(struct ofproto_dpif *ofproto, void *aux)
 +{
 +    int i;
 +
 +    for (i = 0; i < MAX_MIRRORS; i++) {
 +        struct ofmirror *mirror = ofproto->mirrors[i];
 +        if (mirror && mirror->aux == aux) {
 +            return mirror;
 +        }
 +    }
 +
 +    return NULL;
 +}
 +
 +static int
 +mirror_set(struct ofproto *ofproto_, void *aux,
 +           const struct ofproto_mirror_settings *s)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    mirror_mask_t mirror_bit;
 +    struct ofbundle *bundle;
 +    struct ofmirror *mirror;
 +    struct ofbundle *out;
 +    struct hmapx srcs;          /* Contains "struct ofbundle *"s. */
 +    struct hmapx dsts;          /* Contains "struct ofbundle *"s. */
 +    int out_vlan;
 +
 +    mirror = mirror_lookup(ofproto, aux);
 +    if (!s) {
 +        mirror_destroy(mirror);
 +        return 0;
 +    }
 +    if (!mirror) {
 +        int idx;
 +
 +        idx = mirror_scan(ofproto);
 +        if (idx < 0) {
 +            VLOG_WARN("bridge %s: maximum of %d port mirrors reached, "
 +                      "cannot create %s",
 +                      ofproto->up.name, MAX_MIRRORS, s->name);
 +            return EFBIG;
 +        }
 +
 +        mirror = ofproto->mirrors[idx] = xzalloc(sizeof *mirror);
 +        mirror->ofproto = ofproto;
 +        mirror->idx = idx;
 +        mirror->out_vlan = -1;
 +        mirror->name = NULL;
 +    }
 +
 +    if (!mirror->name || strcmp(s->name, mirror->name)) {
 +        free(mirror->name);
 +        mirror->name = xstrdup(s->name);
 +    }
 +
 +    /* Get the new configuration. */
 +    if (s->out_bundle) {
 +        out = bundle_lookup(ofproto, s->out_bundle);
 +        if (!out) {
 +            mirror_destroy(mirror);
 +            return EINVAL;
 +        }
 +        out_vlan = -1;
 +    } else {
 +        out = NULL;
 +        out_vlan = s->out_vlan;
 +    }
 +    bundle_lookup_multiple(ofproto, s->srcs, s->n_srcs, &srcs);
 +    bundle_lookup_multiple(ofproto, s->dsts, s->n_dsts, &dsts);
 +
 +    /* If the configuration has not changed, do nothing. */
 +    if (hmapx_equals(&srcs, &mirror->srcs)
 +        && hmapx_equals(&dsts, &mirror->dsts)
 +        && vlan_bitmap_equal(mirror->vlans, s->src_vlans)
 +        && mirror->out == out
 +        && mirror->out_vlan == out_vlan)
 +    {
 +        hmapx_destroy(&srcs);
 +        hmapx_destroy(&dsts);
 +        return 0;
 +    }
 +
 +    hmapx_swap(&srcs, &mirror->srcs);
 +    hmapx_destroy(&srcs);
 +
 +    hmapx_swap(&dsts, &mirror->dsts);
 +    hmapx_destroy(&dsts);
 +
 +    free(mirror->vlans);
 +    mirror->vlans = vlan_bitmap_clone(s->src_vlans);
 +
 +    mirror->out = out;
 +    mirror->out_vlan = out_vlan;
 +
 +    /* Update bundles. */
 +    mirror_bit = MIRROR_MASK_C(1) << mirror->idx;
 +    HMAP_FOR_EACH (bundle, hmap_node, &mirror->ofproto->bundles) {
 +        if (hmapx_contains(&mirror->srcs, bundle)) {
 +            bundle->src_mirrors |= mirror_bit;
 +        } else {
 +            bundle->src_mirrors &= ~mirror_bit;
 +        }
 +
 +        if (hmapx_contains(&mirror->dsts, bundle)) {
 +            bundle->dst_mirrors |= mirror_bit;
 +        } else {
 +            bundle->dst_mirrors &= ~mirror_bit;
 +        }
 +
 +        if (mirror->out == bundle) {
 +            bundle->mirror_out |= mirror_bit;
 +        } else {
 +            bundle->mirror_out &= ~mirror_bit;
 +        }
 +    }
 +
 +    ofproto->need_revalidate = true;
 +    mac_learning_flush(ofproto->ml);
 +
 +    return 0;
 +}
 +
 +static void
 +mirror_destroy(struct ofmirror *mirror)
 +{
 +    struct ofproto_dpif *ofproto;
 +    mirror_mask_t mirror_bit;
 +    struct ofbundle *bundle;
 +
 +    if (!mirror) {
 +        return;
 +    }
 +
 +    ofproto = mirror->ofproto;
 +    ofproto->need_revalidate = true;
 +    mac_learning_flush(ofproto->ml);
 +
 +    mirror_bit = MIRROR_MASK_C(1) << mirror->idx;
 +    HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
 +        bundle->src_mirrors &= ~mirror_bit;
 +        bundle->dst_mirrors &= ~mirror_bit;
 +        bundle->mirror_out &= ~mirror_bit;
 +    }
 +
 +    hmapx_destroy(&mirror->srcs);
 +    hmapx_destroy(&mirror->dsts);
 +    free(mirror->vlans);
 +
 +    ofproto->mirrors[mirror->idx] = NULL;
 +    free(mirror->name);
 +    free(mirror);
 +}
 +
 +static int
 +set_flood_vlans(struct ofproto *ofproto_, unsigned long *flood_vlans)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    if (mac_learning_set_flood_vlans(ofproto->ml, flood_vlans)) {
 +        ofproto->need_revalidate = true;
 +        mac_learning_flush(ofproto->ml);
 +    }
 +    return 0;
 +}
 +
 +static bool
 +is_mirror_output_bundle(struct ofproto *ofproto_, void *aux)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    struct ofbundle *bundle = bundle_lookup(ofproto, aux);
 +    return bundle && bundle->mirror_out != 0;
 +}
 +\f
 +/* Ports. */
 +
 +static struct ofport_dpif *
 +get_ofp_port(struct ofproto_dpif *ofproto, uint16_t ofp_port)
 +{
 +    return ofport_dpif_cast(ofproto_get_port(&ofproto->up, ofp_port));
 +}
 +
 +static struct ofport_dpif *
 +get_odp_port(struct ofproto_dpif *ofproto, uint32_t odp_port)
 +{
 +    return get_ofp_port(ofproto, odp_port_to_ofp_port(odp_port));
 +}
 +
 +static void
 +ofproto_port_from_dpif_port(struct ofproto_port *ofproto_port,
 +                            struct dpif_port *dpif_port)
 +{
 +    ofproto_port->name = dpif_port->name;
 +    ofproto_port->type = dpif_port->type;
 +    ofproto_port->ofp_port = odp_port_to_ofp_port(dpif_port->port_no);
 +}
 +
 +static void
 +port_run(struct ofport_dpif *ofport)
 +{
 +    if (ofport->cfm) {
 +        cfm_run(ofport->cfm);
 +
 +        if (cfm_should_send_ccm(ofport->cfm)) {
 +            struct ofpbuf packet;
 +            struct ccm *ccm;
 +
 +            ofpbuf_init(&packet, 0);
 +            ccm = eth_compose(&packet, eth_addr_ccm, ofport->up.opp.hw_addr,
 +                              ETH_TYPE_CFM, sizeof *ccm);
 +            cfm_compose_ccm(ofport->cfm, ccm);
 +            send_packet(ofproto_dpif_cast(ofport->up.ofproto),
 +                        ofport->odp_port, 0, &packet);
 +            ofpbuf_uninit(&packet);
 +        }
 +    }
 +}
 +
 +static void
 +port_wait(struct ofport_dpif *ofport)
 +{
 +    if (ofport->cfm) {
 +        cfm_wait(ofport->cfm);
 +    }
 +}
 +
 +static int
 +port_query_by_name(const struct ofproto *ofproto_, const char *devname,
 +                   struct ofproto_port *ofproto_port)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    struct dpif_port dpif_port;
 +    int error;
 +
 +    error = dpif_port_query_by_name(ofproto->dpif, devname, &dpif_port);
 +    if (!error) {
 +        ofproto_port_from_dpif_port(ofproto_port, &dpif_port);
 +    }
 +    return error;
 +}
 +
 +static int
 +port_add(struct ofproto *ofproto_, struct netdev *netdev, uint16_t *ofp_portp)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    uint16_t odp_port;
 +    int error;
 +
 +    error = dpif_port_add(ofproto->dpif, netdev, &odp_port);
 +    if (!error) {
 +        *ofp_portp = odp_port_to_ofp_port(odp_port);
 +    }
 +    return error;
 +}
 +
 +static int
 +port_del(struct ofproto *ofproto_, uint16_t ofp_port)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    int error;
 +
 +    error = dpif_port_del(ofproto->dpif, ofp_port_to_odp_port(ofp_port));
 +    if (!error) {
 +        struct ofport_dpif *ofport = get_ofp_port(ofproto, ofp_port);
 +        if (ofport) {
 +            /* The caller is going to close ofport->up.netdev.  If this is a
 +             * bonded port, then the bond is using that netdev, so remove it
 +             * from the bond.  The client will need to reconfigure everything
 +             * after deleting ports, so then the slave will get re-added. */
 +            bundle_remove(&ofport->up);
 +        }
 +    }
 +    return error;
 +}
 +
 +struct port_dump_state {
 +    struct dpif_port_dump dump;
 +    bool done;
 +};
 +
 +static int
 +port_dump_start(const struct ofproto *ofproto_, void **statep)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    struct port_dump_state *state;
 +
 +    *statep = state = xmalloc(sizeof *state);
 +    dpif_port_dump_start(&state->dump, ofproto->dpif);
 +    state->done = false;
 +    return 0;
 +}
 +
 +static int
 +port_dump_next(const struct ofproto *ofproto_ OVS_UNUSED, void *state_,
 +               struct ofproto_port *port)
 +{
 +    struct port_dump_state *state = state_;
 +    struct dpif_port dpif_port;
 +
 +    if (dpif_port_dump_next(&state->dump, &dpif_port)) {
 +        ofproto_port_from_dpif_port(port, &dpif_port);
 +        return 0;
 +    } else {
 +        int error = dpif_port_dump_done(&state->dump);
 +        state->done = true;
 +        return error ? error : EOF;
 +    }
 +}
 +
 +static int
 +port_dump_done(const struct ofproto *ofproto_ OVS_UNUSED, void *state_)
 +{
 +    struct port_dump_state *state = state_;
 +
 +    if (!state->done) {
 +        dpif_port_dump_done(&state->dump);
 +    }
 +    free(state);
 +    return 0;
 +}
 +
 +static int
 +port_poll(const struct ofproto *ofproto_, char **devnamep)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    return dpif_port_poll(ofproto->dpif, devnamep);
 +}
 +
 +static void
 +port_poll_wait(const struct ofproto *ofproto_)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    dpif_port_poll_wait(ofproto->dpif);
 +}
 +
 +static int
 +port_is_lacp_current(const struct ofport *ofport_)
 +{
 +    const struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
 +    return (ofport->bundle && ofport->bundle->lacp
 +            ? lacp_slave_is_current(ofport->bundle->lacp, ofport)
 +            : -1);
 +}
 +\f
 +/* Upcall handling. */
 +
 +/* Given 'upcall', of type DPIF_UC_ACTION or DPIF_UC_MISS, sends an
 + * OFPT_PACKET_IN message to each OpenFlow controller as necessary according to
 + * their individual configurations.
 + *
 + * If 'clone' is true, the caller retains ownership of 'upcall->packet'.
 + * Otherwise, ownership is transferred to this function. */
 +static void
 +send_packet_in(struct ofproto_dpif *ofproto, struct dpif_upcall *upcall,
 +               const struct flow *flow, bool clone)
 +{
 +    struct ofputil_packet_in pin;
 +
 +    pin.packet = upcall->packet;
 +    pin.in_port = flow->in_port;
 +    pin.reason = upcall->type == DPIF_UC_MISS ? OFPR_NO_MATCH : OFPR_ACTION;
 +    pin.buffer_id = 0;          /* not yet known */
 +    pin.send_len = upcall->userdata;
 +    connmgr_send_packet_in(ofproto->up.connmgr, &pin, flow,
 +                           clone ? NULL : upcall->packet);
 +}
 +
 +static bool
 +process_special(struct ofproto_dpif *ofproto, const struct flow *flow,
 +                const struct ofpbuf *packet)
 +{
 +    if (cfm_should_process_flow(flow)) {
 +        struct ofport_dpif *ofport = get_ofp_port(ofproto, flow->in_port);
 +        if (ofport && ofport->cfm) {
 +            cfm_process_heartbeat(ofport->cfm, packet);
 +        }
 +        return true;
 +    } else if (flow->dl_type == htons(ETH_TYPE_LACP)) {
 +        struct ofport_dpif *port = get_ofp_port(ofproto, flow->in_port);
 +        if (port && port->bundle && port->bundle->lacp) {
 +            const struct lacp_pdu *pdu = parse_lacp_packet(packet);
 +            if (pdu) {
 +                lacp_process_pdu(port->bundle->lacp, port, pdu);
 +            }
 +            return true;
 +        }
 +    }
 +    return false;
 +}
 +
 +static void
 +handle_miss_upcall(struct ofproto_dpif *ofproto, struct dpif_upcall *upcall)
 +{
 +    struct facet *facet;
 +    struct flow flow;
 +
 +    /* Obtain in_port and tun_id, at least. */
 +    odp_flow_key_to_flow(upcall->key, upcall->key_len, &flow);
 +
 +    /* Set header pointers in 'flow'. */
 +    flow_extract(upcall->packet, flow.tun_id, flow.in_port, &flow);
 +
 +    /* Handle 802.1ag and LACP. */
 +    if (process_special(ofproto, &flow, upcall->packet)) {
 +        ofpbuf_delete(upcall->packet);
 +        ofproto->n_matches++;
 +        return;
 +    }
 +
 +    /* Check with in-band control to see if this packet should be sent
 +     * to the local port regardless of the flow table. */
 +    if (connmgr_msg_in_hook(ofproto->up.connmgr, &flow, upcall->packet)) {
 +        send_packet(ofproto, OFPP_LOCAL, 0, upcall->packet);
 +    }
 +
 +    facet = facet_lookup_valid(ofproto, &flow);
 +    if (!facet) {
 +        struct rule_dpif *rule = rule_dpif_lookup(ofproto, &flow);
 +        if (!rule) {
 +            /* Don't send a packet-in if OFPPC_NO_PACKET_IN asserted. */
 +            struct ofport_dpif *port = get_ofp_port(ofproto, flow.in_port);
 +            if (port) {
 +                if (port->up.opp.config & htonl(OFPPC_NO_PACKET_IN)) {
 +                    COVERAGE_INC(ofproto_dpif_no_packet_in);
 +                    /* XXX install 'drop' flow entry */
 +                    ofpbuf_delete(upcall->packet);
 +                    return;
 +                }
 +            } else {
 +                VLOG_WARN_RL(&rl, "packet-in on unknown port %"PRIu16,
 +                             flow.in_port);
 +            }
 +
 +            send_packet_in(ofproto, upcall, &flow, false);
 +            return;
 +        }
 +
 +        facet = facet_create(rule, &flow, upcall->packet);
 +    } else if (!facet->may_install) {
 +        /* The facet is not installable, that is, we need to process every
 +         * packet, so process the current packet's actions into 'facet'. */
 +        facet_make_actions(ofproto, facet, upcall->packet);
 +    }
 +
 +    if (facet->rule->up.cr.priority == FAIL_OPEN_PRIORITY) {
 +        /*
 +         * Extra-special case for fail-open mode.
 +         *
 +         * We are in fail-open mode and the packet matched the fail-open rule,
 +         * but we are connected to a controller too.  We should send the packet
 +         * up to the controller in the hope that it will try to set up a flow
 +         * and thereby allow us to exit fail-open.
 +         *
 +         * See the top-level comment in fail-open.c for more information.
 +         */
 +        send_packet_in(ofproto, upcall, &flow, true);
 +    }
 +
 +    facet_execute(ofproto, facet, upcall->packet);
 +    facet_install(ofproto, facet, false);
 +    ofproto->n_matches++;
 +}
 +
 +static void
 +handle_upcall(struct ofproto_dpif *ofproto, struct dpif_upcall *upcall)
 +{
 +    struct flow flow;
 +
 +    switch (upcall->type) {
 +    case DPIF_UC_ACTION:
 +        COVERAGE_INC(ofproto_dpif_ctlr_action);
 +        odp_flow_key_to_flow(upcall->key, upcall->key_len, &flow);
 +        send_packet_in(ofproto, upcall, &flow, false);
 +        break;
 +
 +    case DPIF_UC_SAMPLE:
 +        if (ofproto->sflow) {
 +            odp_flow_key_to_flow(upcall->key, upcall->key_len, &flow);
 +            ofproto_sflow_received(ofproto->sflow, upcall, &flow);
 +        }
 +        ofpbuf_delete(upcall->packet);
 +        break;
 +
 +    case DPIF_UC_MISS:
 +        handle_miss_upcall(ofproto, upcall);
 +        break;
 +
 +    case DPIF_N_UC_TYPES:
 +    default:
 +        VLOG_WARN_RL(&rl, "upcall has unexpected type %"PRIu32, upcall->type);
 +        break;
 +    }
 +}
 +\f
 +/* Flow expiration. */
 +
 +static int facet_max_idle(const struct ofproto_dpif *);
 +static void update_stats(struct ofproto_dpif *);
 +static void rule_expire(struct rule_dpif *);
 +static void expire_facets(struct ofproto_dpif *, int dp_max_idle);
 +
 +/* This function is called periodically by run().  Its job is to collect
 + * updates for the flows that have been installed into the datapath, most
 + * importantly when they last were used, and then use that information to
 + * expire flows that have not been used recently.
 + *
 + * Returns the number of milliseconds after which it should be called again. */
 +static int
 +expire(struct ofproto_dpif *ofproto)
 +{
 +    struct rule_dpif *rule, *next_rule;
 +    struct cls_cursor cursor;
 +    int dp_max_idle;
 +
 +    /* Update stats for each flow in the datapath. */
 +    update_stats(ofproto);
 +
 +    /* Expire facets that have been idle too long. */
 +    dp_max_idle = facet_max_idle(ofproto);
 +    expire_facets(ofproto, dp_max_idle);
 +
 +    /* Expire OpenFlow flows whose idle_timeout or hard_timeout has passed. */
 +    cls_cursor_init(&cursor, &ofproto->up.tables[0], NULL);
 +    CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, up.cr, &cursor) {
 +        rule_expire(rule);
 +    }
 +
 +    /* All outstanding data in existing flows has been accounted, so it's a
 +     * good time to do bond rebalancing. */
 +    if (ofproto->has_bonded_bundles) {
 +        struct ofbundle *bundle;
 +
 +        HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
 +            if (bundle->bond) {
 +                bond_rebalance(bundle->bond, &ofproto->revalidate_set);
 +            }
 +        }
 +    }
 +
 +    return MIN(dp_max_idle, 1000);
 +}
 +
 +/* Update 'packet_count', 'byte_count', and 'used' members of installed facets.
 + *
 + * This function also pushes statistics updates to rules which each facet
 + * resubmits into.  Generally these statistics will be accurate.  However, if a
 + * facet changes the rule it resubmits into at some time in between
 + * update_stats() runs, it is possible that statistics accrued to the
 + * old rule will be incorrectly attributed to the new rule.  This could be
 + * avoided by calling update_stats() whenever rules are created or
 + * deleted.  However, the performance impact of making so many calls to the
 + * datapath do not justify the benefit of having perfectly accurate statistics.
 + */
 +static void
 +update_stats(struct ofproto_dpif *p)
 +{
 +    const struct dpif_flow_stats *stats;
 +    struct dpif_flow_dump dump;
 +    const struct nlattr *key;
 +    size_t key_len;
 +
 +    dpif_flow_dump_start(&dump, p->dpif);
 +    while (dpif_flow_dump_next(&dump, &key, &key_len, NULL, NULL, &stats)) {
 +        struct facet *facet;
 +        struct flow flow;
 +
 +        if (odp_flow_key_to_flow(key, key_len, &flow)) {
 +            struct ds s;
 +
 +            ds_init(&s);
 +            odp_flow_key_format(key, key_len, &s);
 +            VLOG_WARN_RL(&rl, "failed to convert ODP flow key to flow: %s",
 +                         ds_cstr(&s));
 +            ds_destroy(&s);
 +
 +            continue;
 +        }
 +        facet = facet_find(p, &flow);
 +
 +        if (facet && facet->installed) {
 +
 +            if (stats->n_packets >= facet->dp_packet_count) {
 +                uint64_t extra = stats->n_packets - facet->dp_packet_count;
 +                facet->packet_count += extra;
 +            } else {
 +                VLOG_WARN_RL(&rl, "unexpected packet count from the datapath");
 +            }
 +
 +            if (stats->n_bytes >= facet->dp_byte_count) {
 +                facet->byte_count += stats->n_bytes - facet->dp_byte_count;
 +            } else {
 +                VLOG_WARN_RL(&rl, "unexpected byte count from datapath");
 +            }
 +
 +            facet->dp_packet_count = stats->n_packets;
 +            facet->dp_byte_count = stats->n_bytes;
 +
 +            facet_update_time(p, facet, stats->used);
 +            facet_account(p, facet, stats->n_bytes);
 +            facet_push_stats(facet);
 +        } else {
 +            /* There's a flow in the datapath that we know nothing about.
 +             * Delete it. */
 +            COVERAGE_INC(facet_unexpected);
 +            dpif_flow_del(p->dpif, key, key_len, NULL);
 +        }
 +    }
 +    dpif_flow_dump_done(&dump);
 +}
 +
 +/* Calculates and returns the number of milliseconds of idle time after which
 + * facets should expire from the datapath and we should fold their statistics
 + * into their parent rules in userspace. */
 +static int
 +facet_max_idle(const struct ofproto_dpif *ofproto)
 +{
 +    /*
 +     * Idle time histogram.
 +     *
 +     * Most of the time a switch has a relatively small number of facets.  When
 +     * this is the case we might as well keep statistics for all of them in
 +     * userspace and to cache them in the kernel datapath for performance as
 +     * well.
 +     *
 +     * As the number of facets increases, the memory required to maintain
 +     * statistics about them in userspace and in the kernel becomes
 +     * significant.  However, with a large number of facets it is likely that
 +     * only a few of them are "heavy hitters" that consume a large amount of
 +     * bandwidth.  At this point, only heavy hitters are worth caching in the
 +     * kernel and maintaining in userspaces; other facets we can discard.
 +     *
 +     * The technique used to compute the idle time is to build a histogram with
 +     * N_BUCKETS buckets whose width is BUCKET_WIDTH msecs each.  Each facet
 +     * that is installed in the kernel gets dropped in the appropriate bucket.
 +     * After the histogram has been built, we compute the cutoff so that only
 +     * the most-recently-used 1% of facets (but at least 1000 flows) are kept
 +     * cached.  At least the most-recently-used bucket of facets is kept, so
 +     * actually an arbitrary number of facets can be kept in any given
 +     * expiration run (though the next run will delete most of those unless
 +     * they receive additional data).
 +     *
 +     * This requires a second pass through the facets, in addition to the pass
 +     * made by update_stats(), because the former function never looks
 +     * at uninstallable facets.
 +     */
 +    enum { BUCKET_WIDTH = ROUND_UP(100, TIME_UPDATE_INTERVAL) };
 +    enum { N_BUCKETS = 5000 / BUCKET_WIDTH };
 +    int buckets[N_BUCKETS] = { 0 };
 +    struct facet *facet;
 +    int total, bucket;
 +    long long int now;
 +    int i;
 +
 +    total = hmap_count(&ofproto->facets);
 +    if (total <= 1000) {
 +        return N_BUCKETS * BUCKET_WIDTH;
 +    }
 +
 +    /* Build histogram. */
 +    now = time_msec();
 +    HMAP_FOR_EACH (facet, hmap_node, &ofproto->facets) {
 +        long long int idle = now - facet->used;
 +        int bucket = (idle <= 0 ? 0
 +                      : idle >= BUCKET_WIDTH * N_BUCKETS ? N_BUCKETS - 1
 +                      : (unsigned int) idle / BUCKET_WIDTH);
 +        buckets[bucket]++;
 +    }
 +
 +    /* Find the first bucket whose flows should be expired. */
 +    for (bucket = 0; bucket < N_BUCKETS; bucket++) {
 +        if (buckets[bucket]) {
 +            int subtotal = 0;
 +            do {
 +                subtotal += buckets[bucket++];
 +            } while (bucket < N_BUCKETS && subtotal < MAX(1000, total / 100));
 +            break;
 +        }
 +    }
 +
 +    if (VLOG_IS_DBG_ENABLED()) {
 +        struct ds s;
 +
 +        ds_init(&s);
 +        ds_put_cstr(&s, "keep");
 +        for (i = 0; i < N_BUCKETS; i++) {
 +            if (i == bucket) {
 +                ds_put_cstr(&s, ", drop");
 +            }
 +            if (buckets[i]) {
 +                ds_put_format(&s, " %d:%d", i * BUCKET_WIDTH, buckets[i]);
 +            }
 +        }
 +        VLOG_INFO("%s: %s (msec:count)", ofproto->up.name, ds_cstr(&s));
 +        ds_destroy(&s);
 +    }
 +
 +    return bucket * BUCKET_WIDTH;
 +}
 +
 +static void
 +facet_active_timeout(struct ofproto_dpif *ofproto, struct facet *facet)
 +{
 +    if (ofproto->netflow && !facet_is_controller_flow(facet) &&
 +        netflow_active_timeout_expired(ofproto->netflow, &facet->nf_flow)) {
 +        struct ofexpired expired;
 +
 +        if (facet->installed) {
 +            struct dpif_flow_stats stats;
 +
 +            facet_put__(ofproto, facet, facet->actions, facet->actions_len,
 +                        &stats);
 +            facet_update_stats(ofproto, facet, &stats);
 +        }
 +
 +        expired.flow = facet->flow;
 +        expired.packet_count = facet->packet_count;
 +        expired.byte_count = facet->byte_count;
 +        expired.used = facet->used;
 +        netflow_expire(ofproto->netflow, &facet->nf_flow, &expired);
 +    }
 +}
 +
 +static void
 +expire_facets(struct ofproto_dpif *ofproto, int dp_max_idle)
 +{
 +    long long int cutoff = time_msec() - dp_max_idle;
 +    struct facet *facet, *next_facet;
 +
 +    HMAP_FOR_EACH_SAFE (facet, next_facet, hmap_node, &ofproto->facets) {
 +        facet_active_timeout(ofproto, facet);
 +        if (facet->used < cutoff) {
 +            facet_remove(ofproto, facet);
 +        }
 +    }
 +}
 +
 +/* If 'rule' is an OpenFlow rule, that has expired according to OpenFlow rules,
 + * then delete it entirely. */
 +static void
 +rule_expire(struct rule_dpif *rule)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
 +    struct facet *facet, *next_facet;
 +    long long int now;
 +    uint8_t reason;
 +
 +    /* Has 'rule' expired? */
 +    now = time_msec();
 +    if (rule->up.hard_timeout
 +        && now > rule->up.created + rule->up.hard_timeout * 1000) {
 +        reason = OFPRR_HARD_TIMEOUT;
 +    } else if (rule->up.idle_timeout && list_is_empty(&rule->facets)
 +               && now > rule->used + rule->up.idle_timeout * 1000) {
 +        reason = OFPRR_IDLE_TIMEOUT;
 +    } else {
 +        return;
 +    }
 +
 +    COVERAGE_INC(ofproto_dpif_expired);
 +
 +    /* Update stats.  (This is a no-op if the rule expired due to an idle
 +     * timeout, because that only happens when the rule has no facets left.) */
 +    LIST_FOR_EACH_SAFE (facet, next_facet, list_node, &rule->facets) {
 +        facet_remove(ofproto, facet);
 +    }
 +
 +    /* Get rid of the rule. */
 +    ofproto_rule_expire(&rule->up, reason);
 +}
 +\f
 +/* Facets. */
 +
 +/* Creates and returns a new facet owned by 'rule', given a 'flow' and an
 + * example 'packet' within that flow.
 + *
 + * The caller must already have determined that no facet with an identical
 + * 'flow' exists in 'ofproto' and that 'flow' is the best match for 'rule' in
 + * the ofproto's classifier table. */
 +static struct facet *
 +facet_create(struct rule_dpif *rule, const struct flow *flow,
 +             const struct ofpbuf *packet)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
 +    struct facet *facet;
 +
 +    facet = xzalloc(sizeof *facet);
 +    facet->used = time_msec();
 +    hmap_insert(&ofproto->facets, &facet->hmap_node, flow_hash(flow, 0));
 +    list_push_back(&rule->facets, &facet->list_node);
 +    facet->rule = rule;
 +    facet->flow = *flow;
 +    netflow_flow_init(&facet->nf_flow);
 +    netflow_flow_update_time(ofproto->netflow, &facet->nf_flow, facet->used);
 +
 +    facet_make_actions(ofproto, facet, packet);
 +
 +    return facet;
 +}
 +
 +static void
 +facet_free(struct facet *facet)
 +{
 +    free(facet->actions);
 +    free(facet);
 +}
 +
 +/* Executes, within 'ofproto', the 'n_actions' actions in 'actions' on
 + * 'packet', which arrived on 'in_port'.
 + *
 + * Takes ownership of 'packet'. */
 +static bool
 +execute_odp_actions(struct ofproto_dpif *ofproto, const struct flow *flow,
 +                    const struct nlattr *odp_actions, size_t actions_len,
 +                    struct ofpbuf *packet)
 +{
 +    if (actions_len == NLA_ALIGN(NLA_HDRLEN + sizeof(uint64_t))
 +        && odp_actions->nla_type == ODP_ACTION_ATTR_CONTROLLER) {
 +        /* As an optimization, avoid a round-trip from userspace to kernel to
 +         * userspace.  This also avoids possibly filling up kernel packet
 +         * buffers along the way. */
 +        struct dpif_upcall upcall;
 +
 +        upcall.type = DPIF_UC_ACTION;
 +        upcall.packet = packet;
 +        upcall.key = NULL;
 +        upcall.key_len = 0;
 +        upcall.userdata = nl_attr_get_u64(odp_actions);
 +        upcall.sample_pool = 0;
 +        upcall.actions = NULL;
 +        upcall.actions_len = 0;
 +
 +        send_packet_in(ofproto, &upcall, flow, false);
 +
 +        return true;
 +    } else {
 +        int error;
 +
 +        error = dpif_execute(ofproto->dpif, odp_actions, actions_len, packet);
 +        ofpbuf_delete(packet);
 +        return !error;
 +    }
 +}
 +
 +/* Executes the actions indicated by 'facet' on 'packet' and credits 'facet''s
 + * statistics appropriately.  'packet' must have at least sizeof(struct
 + * ofp_packet_in) bytes of headroom.
 + *
 + * For correct results, 'packet' must actually be in 'facet''s flow; that is,
 + * applying flow_extract() to 'packet' would yield the same flow as
 + * 'facet->flow'.
 + *
 + * 'facet' must have accurately composed ODP actions; that is, it must not be
 + * in need of revalidation.
 + *
 + * Takes ownership of 'packet'. */
 +static void
 +facet_execute(struct ofproto_dpif *ofproto, struct facet *facet,
 +              struct ofpbuf *packet)
 +{
 +    struct dpif_flow_stats stats;
 +
 +    assert(ofpbuf_headroom(packet) >= sizeof(struct ofp_packet_in));
 +
 +    flow_extract_stats(&facet->flow, packet, &stats);
 +    stats.used = time_msec();
 +    if (execute_odp_actions(ofproto, &facet->flow,
 +                            facet->actions, facet->actions_len, packet)) {
 +        facet_update_stats(ofproto, facet, &stats);
 +    }
 +}
 +
 +/* Remove 'facet' from 'ofproto' and free up the associated memory:
 + *
 + *   - If 'facet' was installed in the datapath, uninstalls it and updates its
 + *     rule's statistics, via facet_uninstall().
 + *
 + *   - Removes 'facet' from its rule and from ofproto->facets.
 + */
 +static void
 +facet_remove(struct ofproto_dpif *ofproto, struct facet *facet)
 +{
 +    facet_uninstall(ofproto, facet);
 +    facet_flush_stats(ofproto, facet);
 +    hmap_remove(&ofproto->facets, &facet->hmap_node);
 +    list_remove(&facet->list_node);
 +    facet_free(facet);
 +}
 +
 +/* Composes the ODP actions for 'facet' based on its rule's actions. */
 +static void
 +facet_make_actions(struct ofproto_dpif *p, struct facet *facet,
 +                   const struct ofpbuf *packet)
 +{
 +    const struct rule_dpif *rule = facet->rule;
 +    struct ofpbuf *odp_actions;
 +    struct action_xlate_ctx ctx;
 +
 +    action_xlate_ctx_init(&ctx, p, &facet->flow, packet);
 +    odp_actions = xlate_actions(&ctx, rule->up.actions, rule->up.n_actions);
 +    facet->tags = ctx.tags;
 +    facet->may_install = ctx.may_set_up_flow;
 +    facet->nf_flow.output_iface = ctx.nf_output_iface;
 +
 +    if (facet->actions_len != odp_actions->size
 +        || memcmp(facet->actions, odp_actions->data, odp_actions->size)) {
 +        free(facet->actions);
 +        facet->actions_len = odp_actions->size;
 +        facet->actions = xmemdup(odp_actions->data, odp_actions->size);
 +    }
 +
 +    ofpbuf_delete(odp_actions);
 +}
 +
 +static int
 +facet_put__(struct ofproto_dpif *ofproto, struct facet *facet,
 +            const struct nlattr *actions, size_t actions_len,
 +            struct dpif_flow_stats *stats)
 +{
 +    struct odputil_keybuf keybuf;
 +    enum dpif_flow_put_flags flags;
 +    struct ofpbuf key;
 +
 +    flags = DPIF_FP_CREATE | DPIF_FP_MODIFY;
 +    if (stats) {
 +        flags |= DPIF_FP_ZERO_STATS;
 +        facet->dp_packet_count = 0;
 +        facet->dp_byte_count = 0;
 +    }
 +
 +    ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
 +    odp_flow_key_from_flow(&key, &facet->flow);
 +
 +    return dpif_flow_put(ofproto->dpif, flags, key.data, key.size,
 +                         actions, actions_len, stats);
 +}
 +
 +/* If 'facet' is installable, inserts or re-inserts it into 'p''s datapath.  If
 + * 'zero_stats' is true, clears any existing statistics from the datapath for
 + * 'facet'. */
 +static void
 +facet_install(struct ofproto_dpif *p, struct facet *facet, bool zero_stats)
 +{
 +    struct dpif_flow_stats stats;
 +
 +    if (facet->may_install
 +        && !facet_put__(p, facet, facet->actions, facet->actions_len,
 +                        zero_stats ? &stats : NULL)) {
 +        facet->installed = true;
 +    }
 +}
 +
 +static void
 +facet_account(struct ofproto_dpif *ofproto,
 +              struct facet *facet, uint64_t extra_bytes)
 +{
 +    uint64_t total_bytes, n_bytes;
 +    struct ofbundle *in_bundle;
 +    const struct nlattr *a;
 +    tag_type dummy = 0;
 +    unsigned int left;
 +    int vlan;
 +
 +    total_bytes = facet->byte_count + extra_bytes;
 +    if (total_bytes <= facet->accounted_bytes) {
 +        return;
 +    }
 +    n_bytes = total_bytes - facet->accounted_bytes;
 +    facet->accounted_bytes = total_bytes;
 +
 +    /* Test that 'tags' is nonzero to ensure that only flows that include an
 +     * OFPP_NORMAL action are used for learning and bond slave rebalancing.
 +     * This works because OFPP_NORMAL always sets a nonzero tag value.
 +     *
 +     * Feed information from the active flows back into the learning table to
 +     * ensure that table is always in sync with what is actually flowing
 +     * through the datapath. */
 +    if (!facet->tags
 +        || !is_admissible(ofproto, &facet->flow, false, &dummy,
 +                          &vlan, &in_bundle)) {
 +        return;
 +    }
 +
 +    update_learning_table(ofproto, &facet->flow, vlan, in_bundle);
 +
 +    if (!ofproto->has_bonded_bundles) {
 +        return;
 +    }
 +    NL_ATTR_FOR_EACH_UNSAFE (a, left, facet->actions, facet->actions_len) {
 +        if (nl_attr_type(a) == ODP_ACTION_ATTR_OUTPUT) {
 +            struct ofport_dpif *port;
 +
 +            port = get_odp_port(ofproto, nl_attr_get_u32(a));
 +            if (port && port->bundle && port->bundle->bond) {
 +                bond_account(port->bundle->bond, &facet->flow, vlan, n_bytes);
 +            }
 +        }
 +    }
 +}
 +
 +/* If 'rule' is installed in the datapath, uninstalls it. */
 +static void
 +facet_uninstall(struct ofproto_dpif *p, struct facet *facet)
 +{
 +    if (facet->installed) {
 +        struct odputil_keybuf keybuf;
 +        struct dpif_flow_stats stats;
 +        struct ofpbuf key;
 +
 +        ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
 +        odp_flow_key_from_flow(&key, &facet->flow);
 +
 +        if (!dpif_flow_del(p->dpif, key.data, key.size, &stats)) {
 +            facet_update_stats(p, facet, &stats);
 +        }
 +        facet->installed = false;
 +        facet->dp_packet_count = 0;
 +        facet->dp_byte_count = 0;
 +    } else {
 +        assert(facet->dp_packet_count == 0);
 +        assert(facet->dp_byte_count == 0);
 +    }
 +}
 +
 +/* Returns true if the only action for 'facet' is to send to the controller.
 + * (We don't report NetFlow expiration messages for such facets because they
 + * are just part of the control logic for the network, not real traffic). */
 +static bool
 +facet_is_controller_flow(struct facet *facet)
 +{
 +    return (facet
 +            && facet->rule->up.n_actions == 1
 +            && action_outputs_to_port(&facet->rule->up.actions[0],
 +                                      htons(OFPP_CONTROLLER)));
 +}
 +
 +/* Folds all of 'facet''s statistics into its rule.  Also updates the
 + * accounting ofhook and emits a NetFlow expiration if appropriate.  All of
 + * 'facet''s statistics in the datapath should have been zeroed and folded into
 + * its packet and byte counts before this function is called. */
 +static void
 +facet_flush_stats(struct ofproto_dpif *ofproto, struct facet *facet)
 +{
 +    assert(!facet->dp_byte_count);
 +    assert(!facet->dp_packet_count);
 +
 +    facet_push_stats(facet);
 +    facet_account(ofproto, facet, 0);
 +
 +    if (ofproto->netflow && !facet_is_controller_flow(facet)) {
 +        struct ofexpired expired;
 +        expired.flow = facet->flow;
 +        expired.packet_count = facet->packet_count;
 +        expired.byte_count = facet->byte_count;
 +        expired.used = facet->used;
 +        netflow_expire(ofproto->netflow, &facet->nf_flow, &expired);
 +    }
 +
 +    facet->rule->packet_count += facet->packet_count;
 +    facet->rule->byte_count += facet->byte_count;
 +
 +    /* Reset counters to prevent double counting if 'facet' ever gets
 +     * reinstalled. */
 +    facet->packet_count = 0;
 +    facet->byte_count = 0;
 +    facet->rs_packet_count = 0;
 +    facet->rs_byte_count = 0;
 +    facet->accounted_bytes = 0;
 +
 +    netflow_flow_clear(&facet->nf_flow);
 +}
 +
 +/* Searches 'ofproto''s table of facets for one exactly equal to 'flow'.
 + * Returns it if found, otherwise a null pointer.
 + *
 + * The returned facet might need revalidation; use facet_lookup_valid()
 + * instead if that is important. */
 +static struct facet *
 +facet_find(struct ofproto_dpif *ofproto, const struct flow *flow)
 +{
 +    struct facet *facet;
 +
 +    HMAP_FOR_EACH_WITH_HASH (facet, hmap_node, flow_hash(flow, 0),
 +                             &ofproto->facets) {
 +        if (flow_equal(flow, &facet->flow)) {
 +            return facet;
 +        }
 +    }
 +
 +    return NULL;
 +}
 +
 +/* Searches 'ofproto''s table of facets for one exactly equal to 'flow'.
 + * Returns it if found, otherwise a null pointer.
 + *
 + * The returned facet is guaranteed to be valid. */
 +static struct facet *
 +facet_lookup_valid(struct ofproto_dpif *ofproto, const struct flow *flow)
 +{
 +    struct facet *facet = facet_find(ofproto, flow);
 +
 +    /* The facet we found might not be valid, since we could be in need of
 +     * revalidation.  If it is not valid, don't return it. */
 +    if (facet
 +        && ofproto->need_revalidate
 +        && !facet_revalidate(ofproto, facet)) {
 +        COVERAGE_INC(facet_invalidated);
 +        return NULL;
 +    }
 +
 +    return facet;
 +}
 +
 +/* Re-searches 'ofproto''s classifier for a rule matching 'facet':
 + *
 + *   - If the rule found is different from 'facet''s current rule, moves
 + *     'facet' to the new rule and recompiles its actions.
 + *
 + *   - If the rule found is the same as 'facet''s current rule, leaves 'facet'
 + *     where it is and recompiles its actions anyway.
 + *
 + *   - If there is none, destroys 'facet'.
 + *
 + * Returns true if 'facet' still exists, false if it has been destroyed. */
 +static bool
 +facet_revalidate(struct ofproto_dpif *ofproto, struct facet *facet)
 +{
 +    struct action_xlate_ctx ctx;
 +    struct ofpbuf *odp_actions;
 +    struct rule_dpif *new_rule;
 +    bool actions_changed;
 +
 +    COVERAGE_INC(facet_revalidate);
 +
 +    /* Determine the new rule. */
 +    new_rule = rule_dpif_lookup(ofproto, &facet->flow);
 +    if (!new_rule) {
 +        /* No new rule, so delete the facet. */
 +        facet_remove(ofproto, facet);
 +        return false;
 +    }
 +
 +    /* Calculate new ODP actions.
 +     *
 +     * We do not modify any 'facet' state yet, because we might need to, e.g.,
 +     * emit a NetFlow expiration and, if so, we need to have the old state
 +     * around to properly compose it. */
 +    action_xlate_ctx_init(&ctx, ofproto, &facet->flow, NULL);
 +    odp_actions = xlate_actions(&ctx,
 +                                new_rule->up.actions, new_rule->up.n_actions);
 +    actions_changed = (facet->actions_len != odp_actions->size
 +                       || memcmp(facet->actions, odp_actions->data,
 +                                 facet->actions_len));
 +
 +    /* If the ODP actions changed or the installability changed, then we need
 +     * to talk to the datapath. */
 +    if (actions_changed || ctx.may_set_up_flow != facet->installed) {
 +        if (ctx.may_set_up_flow) {
 +            struct dpif_flow_stats stats;
 +
 +            facet_put__(ofproto, facet,
 +                        odp_actions->data, odp_actions->size, &stats);
 +            facet_update_stats(ofproto, facet, &stats);
 +        } else {
 +            facet_uninstall(ofproto, facet);
 +        }
 +
 +        /* The datapath flow is gone or has zeroed stats, so push stats out of
 +         * 'facet' into 'rule'. */
 +        facet_flush_stats(ofproto, facet);
 +    }
 +
 +    /* Update 'facet' now that we've taken care of all the old state. */
 +    facet->tags = ctx.tags;
 +    facet->nf_flow.output_iface = ctx.nf_output_iface;
 +    facet->may_install = ctx.may_set_up_flow;
 +    if (actions_changed) {
 +        free(facet->actions);
 +        facet->actions_len = odp_actions->size;
 +        facet->actions = xmemdup(odp_actions->data, odp_actions->size);
 +    }
 +    if (facet->rule != new_rule) {
 +        COVERAGE_INC(facet_changed_rule);
 +        list_remove(&facet->list_node);
 +        list_push_back(&new_rule->facets, &facet->list_node);
 +        facet->rule = new_rule;
 +        facet->used = new_rule->up.created;
 +        facet->rs_used = facet->used;
 +    }
 +
 +    ofpbuf_delete(odp_actions);
 +
 +    return true;
 +}
 +
 +/* Updates 'facet''s used time.  Caller is responsible for calling
 + * facet_push_stats() to update the flows which 'facet' resubmits into. */
 +static void
 +facet_update_time(struct ofproto_dpif *ofproto, struct facet *facet,
 +                  long long int used)
 +{
 +    if (used > facet->used) {
 +        facet->used = used;
 +        if (used > facet->rule->used) {
 +            facet->rule->used = used;
 +        }
 +        netflow_flow_update_time(ofproto->netflow, &facet->nf_flow, used);
 +    }
 +}
 +
 +/* Folds the statistics from 'stats' into the counters in 'facet'.
 + *
 + * Because of the meaning of a facet's counters, it only makes sense to do this
 + * if 'stats' are not tracked in the datapath, that is, if 'stats' represents a
 + * packet that was sent by hand or if it represents statistics that have been
 + * cleared out of the datapath. */
 +static void
 +facet_update_stats(struct ofproto_dpif *ofproto, struct facet *facet,
 +                   const struct dpif_flow_stats *stats)
 +{
 +    if (stats->n_packets || stats->used > facet->used) {
 +        facet_update_time(ofproto, facet, stats->used);
 +        facet->packet_count += stats->n_packets;
 +        facet->byte_count += stats->n_bytes;
 +        facet_push_stats(facet);
 +        netflow_flow_update_flags(&facet->nf_flow, stats->tcp_flags);
 +    }
 +}
 +
 +static void
 +facet_push_stats(struct facet *facet)
 +{
 +    uint64_t rs_packets, rs_bytes;
 +
 +    assert(facet->packet_count >= facet->rs_packet_count);
 +    assert(facet->byte_count >= facet->rs_byte_count);
 +    assert(facet->used >= facet->rs_used);
 +
 +    rs_packets = facet->packet_count - facet->rs_packet_count;
 +    rs_bytes = facet->byte_count - facet->rs_byte_count;
 +
 +    if (rs_packets || rs_bytes || facet->used > facet->rs_used) {
 +        facet->rs_packet_count = facet->packet_count;
 +        facet->rs_byte_count = facet->byte_count;
 +        facet->rs_used = facet->used;
 +
 +        flow_push_stats(facet->rule, &facet->flow,
 +                        rs_packets, rs_bytes, facet->used);
 +    }
 +}
 +
 +struct ofproto_push {
 +    struct action_xlate_ctx ctx;
 +    uint64_t packets;
 +    uint64_t bytes;
 +    long long int used;
 +};
 +
 +static void
 +push_resubmit(struct action_xlate_ctx *ctx, struct rule_dpif *rule)
 +{
 +    struct ofproto_push *push = CONTAINER_OF(ctx, struct ofproto_push, ctx);
 +
 +    if (rule) {
 +        rule->packet_count += push->packets;
 +        rule->byte_count += push->bytes;
 +        rule->used = MAX(push->used, rule->used);
 +    }
 +}
 +
 +/* Pushes flow statistics to the rules which 'flow' resubmits into given
 + * 'rule''s actions. */
 +static void
 +flow_push_stats(const struct rule_dpif *rule,
 +                struct flow *flow, uint64_t packets, uint64_t bytes,
 +                long long int used)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
 +    struct ofproto_push push;
 +
 +    push.packets = packets;
 +    push.bytes = bytes;
 +    push.used = used;
 +
 +    action_xlate_ctx_init(&push.ctx, ofproto, flow, NULL);
 +    push.ctx.resubmit_hook = push_resubmit;
 +    ofpbuf_delete(xlate_actions(&push.ctx,
 +                                rule->up.actions, rule->up.n_actions));
 +}
 +\f
 +/* Rules. */
 +
 +static struct rule_dpif *
 +rule_dpif_lookup(struct ofproto_dpif *ofproto, const struct flow *flow)
 +{
 +    return rule_dpif_cast(rule_from_cls_rule(
 +                              classifier_lookup(&ofproto->up.tables[0],
 +                                                flow)));
 +}
 +
 +static struct rule *
 +rule_alloc(void)
 +{
 +    struct rule_dpif *rule = xmalloc(sizeof *rule);
 +    return &rule->up;
 +}
 +
 +static void
 +rule_dealloc(struct rule *rule_)
 +{
 +    struct rule_dpif *rule = rule_dpif_cast(rule_);
 +    free(rule);
 +}
 +
 +static int
 +rule_construct(struct rule *rule_)
 +{
 +    struct rule_dpif *rule = rule_dpif_cast(rule_);
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
 +    struct rule_dpif *old_rule;
 +    int error;
 +
 +    error = validate_actions(rule->up.actions, rule->up.n_actions,
 +                             &rule->up.cr.flow, ofproto->max_ports);
 +    if (error) {
 +        return error;
 +    }
 +
 +    old_rule = rule_dpif_cast(rule_from_cls_rule(classifier_find_rule_exactly(
 +                                                     &ofproto->up.tables[0],
 +                                                     &rule->up.cr)));
 +    if (old_rule) {
 +        ofproto_rule_destroy(&old_rule->up);
 +    }
 +
 +    rule->used = rule->up.created;
 +    rule->packet_count = 0;
 +    rule->byte_count = 0;
 +    list_init(&rule->facets);
 +    classifier_insert(&ofproto->up.tables[0], &rule->up.cr);
 +
 +    ofproto->need_revalidate = true;
 +
 +    return 0;
 +}
 +
 +static void
 +rule_destruct(struct rule *rule_)
 +{
 +    struct rule_dpif *rule = rule_dpif_cast(rule_);
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
 +    struct facet *facet, *next_facet;
 +
 +    classifier_remove(&ofproto->up.tables[0], &rule->up.cr);
 +    LIST_FOR_EACH_SAFE (facet, next_facet, list_node, &rule->facets) {
 +        facet_revalidate(ofproto, facet);
 +    }
 +    ofproto->need_revalidate = true;
 +}
 +
 +static void
 +rule_get_stats(struct rule *rule_, uint64_t *packets, uint64_t *bytes)
 +{
 +    struct rule_dpif *rule = rule_dpif_cast(rule_);
 +    struct facet *facet;
 +
 +    /* Start from historical data for 'rule' itself that are no longer tracked
 +     * in facets.  This counts, for example, facets that have expired. */
 +    *packets = rule->packet_count;
 +    *bytes = rule->byte_count;
 +
 +    /* Add any statistics that are tracked by facets.  This includes
 +     * statistical data recently updated by ofproto_update_stats() as well as
 +     * stats for packets that were executed "by hand" via dpif_execute(). */
 +    LIST_FOR_EACH (facet, list_node, &rule->facets) {
 +        *packets += facet->packet_count;
 +        *bytes += facet->byte_count;
 +    }
 +}
 +
 +static int
 +rule_execute(struct rule *rule_, struct flow *flow, struct ofpbuf *packet)
 +{
 +    struct rule_dpif *rule = rule_dpif_cast(rule_);
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
 +    struct action_xlate_ctx ctx;
 +    struct ofpbuf *odp_actions;
 +    struct facet *facet;
 +    size_t size;
 +
 +    /* First look for a related facet.  If we find one, account it to that. */
 +    facet = facet_lookup_valid(ofproto, flow);
 +    if (facet && facet->rule == rule) {
 +        facet_execute(ofproto, facet, packet);
 +        return 0;
 +    }
 +
 +    /* Otherwise, if 'rule' is in fact the correct rule for 'packet', then
 +     * create a new facet for it and use that. */
 +    if (rule_dpif_lookup(ofproto, flow) == rule) {
 +        facet = facet_create(rule, flow, packet);
 +        facet_execute(ofproto, facet, packet);
 +        facet_install(ofproto, facet, true);
 +        return 0;
 +    }
 +
 +    /* We can't account anything to a facet.  If we were to try, then that
 +     * facet would have a non-matching rule, busting our invariants. */
 +    action_xlate_ctx_init(&ctx, ofproto, flow, packet);
 +    odp_actions = xlate_actions(&ctx, rule->up.actions, rule->up.n_actions);
 +    size = packet->size;
 +    if (execute_odp_actions(ofproto, flow, odp_actions->data,
 +                            odp_actions->size, packet)) {
 +        rule->used = time_msec();
 +        rule->packet_count++;
 +        rule->byte_count += size;
 +        flow_push_stats(rule, flow, 1, size, rule->used);
 +    }
 +    ofpbuf_delete(odp_actions);
 +
 +    return 0;
 +}
 +
 +static int
 +rule_modify_actions(struct rule *rule_,
 +                    const union ofp_action *actions, size_t n_actions)
 +{
 +    struct rule_dpif *rule = rule_dpif_cast(rule_);
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
 +    int error;
 +
 +    error = validate_actions(actions, n_actions, &rule->up.cr.flow,
 +                             ofproto->max_ports);
 +    if (!error) {
 +        ofproto->need_revalidate = true;
 +    }
 +    return error;
 +}
 +\f
 +/* Sends 'packet' out of port 'odp_port' within 'ofproto'.  If 'vlan_tci' is
 + * zero the packet will not have any 802.1Q hader; if it is nonzero, then the
 + * packet will be sent with the VLAN TCI specified by 'vlan_tci & ~VLAN_CFI'.
 + *
 + * Returns 0 if successful, otherwise a positive errno value. */
 +static int
 +send_packet(struct ofproto_dpif *ofproto, uint32_t odp_port, uint16_t vlan_tci,
 +            const struct ofpbuf *packet)
 +{
 +    struct ofpbuf odp_actions;
 +    int error;
 +
 +    ofpbuf_init(&odp_actions, 32);
 +    if (vlan_tci != 0) {
 +        nl_msg_put_u32(&odp_actions, ODP_ACTION_ATTR_SET_DL_TCI,
 +                       ntohs(vlan_tci & ~VLAN_CFI));
 +    }
 +    nl_msg_put_u32(&odp_actions, ODP_ACTION_ATTR_OUTPUT, odp_port);
 +    error = dpif_execute(ofproto->dpif, odp_actions.data, odp_actions.size,
 +                         packet);
 +    ofpbuf_uninit(&odp_actions);
 +
 +    if (error) {
 +        VLOG_WARN_RL(&rl, "%s: failed to send packet on port %"PRIu32" (%s)",
 +                     ofproto->up.name, odp_port, strerror(error));
 +    }
 +    return error;
 +}
 +\f
 +/* OpenFlow to ODP action translation. */
 +
 +static void do_xlate_actions(const union ofp_action *in, size_t n_in,
 +                             struct action_xlate_ctx *ctx);
 +static bool xlate_normal(struct action_xlate_ctx *);
 +
 +static void
 +add_output_action(struct action_xlate_ctx *ctx, uint16_t ofp_port)
 +{
 +    const struct ofport_dpif *ofport = get_ofp_port(ctx->ofproto, ofp_port);
 +    uint16_t odp_port = ofp_port_to_odp_port(ofp_port);
 +
 +    if (ofport) {
 +        if (ofport->up.opp.config & htonl(OFPPC_NO_FWD)) {
 +            /* Forwarding disabled on port. */
 +            return;
 +        }
 +    } else {
 +        /*
 +         * We don't have an ofport record for this port, but it doesn't hurt to
 +         * allow forwarding to it anyhow.  Maybe such a port will appear later
 +         * and we're pre-populating the flow table.
 +         */
 +    }
 +
 +    nl_msg_put_u32(ctx->odp_actions, ODP_ACTION_ATTR_OUTPUT, odp_port);
 +    ctx->nf_output_iface = ofp_port;
 +}
 +
 +static void
 +xlate_table_action(struct action_xlate_ctx *ctx, uint16_t in_port)
 +{
 +    if (ctx->recurse < MAX_RESUBMIT_RECURSION) {
 +        struct rule_dpif *rule;
 +        uint16_t old_in_port;
 +
 +        /* Look up a flow with 'in_port' as the input port.  Then restore the
 +         * original input port (otherwise OFPP_NORMAL and OFPP_IN_PORT will
 +         * have surprising behavior). */
 +        old_in_port = ctx->flow.in_port;
 +        ctx->flow.in_port = in_port;
 +        rule = rule_dpif_lookup(ctx->ofproto, &ctx->flow);
 +        ctx->flow.in_port = old_in_port;
 +
 +        if (ctx->resubmit_hook) {
 +            ctx->resubmit_hook(ctx, rule);
 +        }
 +
 +        if (rule) {
 +            ctx->recurse++;
 +            do_xlate_actions(rule->up.actions, rule->up.n_actions, ctx);
 +            ctx->recurse--;
 +        }
 +    } else {
 +        static struct vlog_rate_limit recurse_rl = VLOG_RATE_LIMIT_INIT(1, 1);
 +
 +        VLOG_ERR_RL(&recurse_rl, "NXAST_RESUBMIT recursed over %d times",
 +                    MAX_RESUBMIT_RECURSION);
 +    }
 +}
 +
 +static void
 +flood_packets(struct ofproto_dpif *ofproto,
 +              uint16_t ofp_in_port, ovs_be32 mask,
 +              uint16_t *nf_output_iface, struct ofpbuf *odp_actions)
 +{
 +    struct ofport_dpif *ofport;
 +
 +    HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
 +        uint16_t ofp_port = ofport->up.ofp_port;
 +        if (ofp_port != ofp_in_port && !(ofport->up.opp.config & mask)) {
 +            nl_msg_put_u32(odp_actions, ODP_ACTION_ATTR_OUTPUT,
 +                           ofport->odp_port);
 +        }
 +    }
 +    *nf_output_iface = NF_OUT_FLOOD;
 +}
 +
 +static void
 +xlate_output_action__(struct action_xlate_ctx *ctx,
 +                      uint16_t port, uint16_t max_len)
 +{
 +    uint16_t prev_nf_output_iface = ctx->nf_output_iface;
 +
 +    ctx->nf_output_iface = NF_OUT_DROP;
 +
 +    switch (port) {
 +    case OFPP_IN_PORT:
 +        add_output_action(ctx, ctx->flow.in_port);
 +        break;
 +    case OFPP_TABLE:
 +        xlate_table_action(ctx, ctx->flow.in_port);
 +        break;
 +    case OFPP_NORMAL:
 +        xlate_normal(ctx);
 +        break;
 +    case OFPP_FLOOD:
 +        flood_packets(ctx->ofproto, ctx->flow.in_port, htonl(OFPPC_NO_FLOOD),
 +                      &ctx->nf_output_iface, ctx->odp_actions);
 +        break;
 +    case OFPP_ALL:
 +        flood_packets(ctx->ofproto, ctx->flow.in_port, htonl(0),
 +                      &ctx->nf_output_iface, ctx->odp_actions);
 +        break;
 +    case OFPP_CONTROLLER:
 +        nl_msg_put_u64(ctx->odp_actions, ODP_ACTION_ATTR_CONTROLLER, max_len);
 +        break;
 +    case OFPP_LOCAL:
 +        add_output_action(ctx, OFPP_LOCAL);
 +        break;
 +    default:
 +        if (port != ctx->flow.in_port) {
 +            add_output_action(ctx, port);
 +        }
 +        break;
 +    }
 +
 +    if (prev_nf_output_iface == NF_OUT_FLOOD) {
 +        ctx->nf_output_iface = NF_OUT_FLOOD;
 +    } else if (ctx->nf_output_iface == NF_OUT_DROP) {
 +        ctx->nf_output_iface = prev_nf_output_iface;
 +    } else if (prev_nf_output_iface != NF_OUT_DROP &&
 +               ctx->nf_output_iface != NF_OUT_FLOOD) {
 +        ctx->nf_output_iface = NF_OUT_MULTI;
 +    }
 +}
 +
 +static void
 +xlate_output_action(struct action_xlate_ctx *ctx,
 +                    const struct ofp_action_output *oao)
 +{
 +    xlate_output_action__(ctx, ntohs(oao->port), ntohs(oao->max_len));
 +}
 +
 +/* If the final ODP action in 'ctx' is "pop priority", drop it, as an
 + * optimization, because we're going to add another action that sets the
 + * priority immediately after, or because there are no actions following the
 + * pop.  */
 +static void
 +remove_pop_action(struct action_xlate_ctx *ctx)
 +{
 +    if (ctx->odp_actions->size == ctx->last_pop_priority) {
 +        ctx->odp_actions->size -= NLA_ALIGN(NLA_HDRLEN);
 +        ctx->last_pop_priority = -1;
 +    }
 +}
 +
 +static void
 +add_pop_action(struct action_xlate_ctx *ctx)
 +{
 +    if (ctx->odp_actions->size != ctx->last_pop_priority) {
 +        nl_msg_put_flag(ctx->odp_actions, ODP_ACTION_ATTR_POP_PRIORITY);
 +        ctx->last_pop_priority = ctx->odp_actions->size;
 +    }
 +}
 +
 +static void
 +xlate_enqueue_action(struct action_xlate_ctx *ctx,
 +                     const struct ofp_action_enqueue *oae)
 +{
 +    uint16_t ofp_port, odp_port;
 +    uint32_t priority;
 +    int error;
 +
 +    error = dpif_queue_to_priority(ctx->ofproto->dpif, ntohl(oae->queue_id),
 +                                   &priority);
 +    if (error) {
 +        /* Fall back to ordinary output action. */
 +        xlate_output_action__(ctx, ntohs(oae->port), 0);
 +        return;
 +    }
 +
 +    /* Figure out ODP output port. */
 +    ofp_port = ntohs(oae->port);
 +    if (ofp_port == OFPP_IN_PORT) {
 +        ofp_port = ctx->flow.in_port;
 +    }
 +    odp_port = ofp_port_to_odp_port(ofp_port);
 +
 +    /* Add ODP actions. */
 +    remove_pop_action(ctx);
 +    nl_msg_put_u32(ctx->odp_actions, ODP_ACTION_ATTR_SET_PRIORITY, priority);
 +    add_output_action(ctx, odp_port);
 +    add_pop_action(ctx);
 +
 +    /* Update NetFlow output port. */
 +    if (ctx->nf_output_iface == NF_OUT_DROP) {
 +        ctx->nf_output_iface = odp_port;
 +    } else if (ctx->nf_output_iface != NF_OUT_FLOOD) {
 +        ctx->nf_output_iface = NF_OUT_MULTI;
 +    }
 +}
 +
 +static void
 +xlate_set_queue_action(struct action_xlate_ctx *ctx,
 +                       const struct nx_action_set_queue *nasq)
 +{
 +    uint32_t priority;
 +    int error;
 +
 +    error = dpif_queue_to_priority(ctx->ofproto->dpif, ntohl(nasq->queue_id),
 +                                   &priority);
 +    if (error) {
 +        /* Couldn't translate queue to a priority, so ignore.  A warning
 +         * has already been logged. */
 +        return;
 +    }
 +
 +    remove_pop_action(ctx);
 +    nl_msg_put_u32(ctx->odp_actions, ODP_ACTION_ATTR_SET_PRIORITY, priority);
 +}
 +
 +static void
 +xlate_set_dl_tci(struct action_xlate_ctx *ctx)
 +{
 +    ovs_be16 tci = ctx->flow.vlan_tci;
 +    if (!(tci & htons(VLAN_CFI))) {
 +        nl_msg_put_flag(ctx->odp_actions, ODP_ACTION_ATTR_STRIP_VLAN);
 +    } else {
 +        nl_msg_put_be16(ctx->odp_actions, ODP_ACTION_ATTR_SET_DL_TCI,
 +                        tci & ~htons(VLAN_CFI));
 +    }
 +}
 +
 +struct xlate_reg_state {
 +    ovs_be16 vlan_tci;
 +    ovs_be64 tun_id;
 +};
 +
 +static void
 +save_reg_state(const struct action_xlate_ctx *ctx,
 +               struct xlate_reg_state *state)
 +{
 +    state->vlan_tci = ctx->flow.vlan_tci;
 +    state->tun_id = ctx->flow.tun_id;
 +}
 +
 +static void
 +update_reg_state(struct action_xlate_ctx *ctx,
 +                 const struct xlate_reg_state *state)
 +{
 +    if (ctx->flow.vlan_tci != state->vlan_tci) {
 +        xlate_set_dl_tci(ctx);
 +    }
 +    if (ctx->flow.tun_id != state->tun_id) {
 +        nl_msg_put_be64(ctx->odp_actions,
 +                        ODP_ACTION_ATTR_SET_TUNNEL, ctx->flow.tun_id);
 +    }
 +}
 +
 +static void
 +xlate_autopath(struct action_xlate_ctx *ctx,
 +               const struct nx_action_autopath *naa)
 +{
 +    uint16_t ofp_port = ntohl(naa->id);
 +    struct ofport_dpif *port = get_ofp_port(ctx->ofproto, ofp_port);
 +
 +    if (!port || !port->bundle) {
 +        ofp_port = OFPP_NONE;
 +    } else if (port->bundle->bond) {
 +        /* Autopath does not support VLAN hashing. */
 +        struct ofport_dpif *slave = bond_choose_output_slave(
 +            port->bundle->bond, &ctx->flow, OFP_VLAN_NONE, &ctx->tags);
 +        if (slave) {
 +            ofp_port = slave->up.ofp_port;
 +        }
 +    }
 +    autopath_execute(naa, &ctx->flow, ofp_port);
 +}
 +
 +static void
 +xlate_nicira_action(struct action_xlate_ctx *ctx,
 +                    const struct nx_action_header *nah)
 +{
 +    const struct nx_action_resubmit *nar;
 +    const struct nx_action_set_tunnel *nast;
 +    const struct nx_action_set_queue *nasq;
 +    const struct nx_action_multipath *nam;
 +    const struct nx_action_autopath *naa;
 +    enum nx_action_subtype subtype = ntohs(nah->subtype);
 +    struct xlate_reg_state state;
 +    ovs_be64 tun_id;
 +
 +    assert(nah->vendor == htonl(NX_VENDOR_ID));
 +    switch (subtype) {
 +    case NXAST_RESUBMIT:
 +        nar = (const struct nx_action_resubmit *) nah;
 +        xlate_table_action(ctx, ntohs(nar->in_port));
 +        break;
 +
 +    case NXAST_SET_TUNNEL:
 +        nast = (const struct nx_action_set_tunnel *) nah;
 +        tun_id = htonll(ntohl(nast->tun_id));
 +        nl_msg_put_be64(ctx->odp_actions, ODP_ACTION_ATTR_SET_TUNNEL, tun_id);
 +        ctx->flow.tun_id = tun_id;
 +        break;
 +
 +    case NXAST_DROP_SPOOFED_ARP:
 +        if (ctx->flow.dl_type == htons(ETH_TYPE_ARP)) {
 +            nl_msg_put_flag(ctx->odp_actions,
 +                            ODP_ACTION_ATTR_DROP_SPOOFED_ARP);
 +        }
 +        break;
 +
 +    case NXAST_SET_QUEUE:
 +        nasq = (const struct nx_action_set_queue *) nah;
 +        xlate_set_queue_action(ctx, nasq);
 +        break;
 +
 +    case NXAST_POP_QUEUE:
 +        add_pop_action(ctx);
 +        break;
 +
 +    case NXAST_REG_MOVE:
 +        save_reg_state(ctx, &state);
 +        nxm_execute_reg_move((const struct nx_action_reg_move *) nah,
 +                             &ctx->flow);
 +        update_reg_state(ctx, &state);
 +        break;
 +
 +    case NXAST_REG_LOAD:
 +        save_reg_state(ctx, &state);
 +        nxm_execute_reg_load((const struct nx_action_reg_load *) nah,
 +                             &ctx->flow);
 +        update_reg_state(ctx, &state);
 +        break;
 +
 +    case NXAST_NOTE:
 +        /* Nothing to do. */
 +        break;
 +
 +    case NXAST_SET_TUNNEL64:
 +        tun_id = ((const struct nx_action_set_tunnel64 *) nah)->tun_id;
 +        nl_msg_put_be64(ctx->odp_actions, ODP_ACTION_ATTR_SET_TUNNEL, tun_id);
 +        ctx->flow.tun_id = tun_id;
 +        break;
 +
 +    case NXAST_MULTIPATH:
 +        nam = (const struct nx_action_multipath *) nah;
 +        multipath_execute(nam, &ctx->flow);
 +        break;
 +
 +    case NXAST_AUTOPATH:
 +        naa = (const struct nx_action_autopath *) nah;
 +        xlate_autopath(ctx, naa);
 +        break;
 +
 +    /* If you add a new action here that modifies flow data, don't forget to
 +     * update the flow key in ctx->flow at the same time. */
 +
 +    case NXAST_SNAT__OBSOLETE:
 +    default:
 +        VLOG_DBG_RL(&rl, "unknown Nicira action type %d", (int) subtype);
 +        break;
 +    }
 +}
 +
 +static void
 +do_xlate_actions(const union ofp_action *in, size_t n_in,
 +                 struct action_xlate_ctx *ctx)
 +{
 +    const struct ofport_dpif *port;
 +    struct actions_iterator iter;
 +    const union ofp_action *ia;
 +
 +    port = get_ofp_port(ctx->ofproto, ctx->flow.in_port);
 +    if (port
 +        && port->up.opp.config & htonl(OFPPC_NO_RECV | OFPPC_NO_RECV_STP) &&
 +        port->up.opp.config & (eth_addr_equals(ctx->flow.dl_dst, eth_addr_stp)
 +                               ? htonl(OFPPC_NO_RECV_STP)
 +                               : htonl(OFPPC_NO_RECV))) {
 +        /* Drop this flow. */
 +        return;
 +    }
 +
 +    for (ia = actions_first(&iter, in, n_in); ia; ia = actions_next(&iter)) {
 +        enum ofp_action_type type = ntohs(ia->type);
 +        const struct ofp_action_dl_addr *oada;
 +
 +        switch (type) {
 +        case OFPAT_OUTPUT:
 +            xlate_output_action(ctx, &ia->output);
 +            break;
 +
 +        case OFPAT_SET_VLAN_VID:
 +            ctx->flow.vlan_tci &= ~htons(VLAN_VID_MASK);
 +            ctx->flow.vlan_tci |= ia->vlan_vid.vlan_vid | htons(VLAN_CFI);
 +            xlate_set_dl_tci(ctx);
 +            break;
 +
 +        case OFPAT_SET_VLAN_PCP:
 +            ctx->flow.vlan_tci &= ~htons(VLAN_PCP_MASK);
 +            ctx->flow.vlan_tci |= htons(
 +                (ia->vlan_pcp.vlan_pcp << VLAN_PCP_SHIFT) | VLAN_CFI);
 +            xlate_set_dl_tci(ctx);
 +            break;
 +
 +        case OFPAT_STRIP_VLAN:
 +            ctx->flow.vlan_tci = htons(0);
 +            xlate_set_dl_tci(ctx);
 +            break;
 +
 +        case OFPAT_SET_DL_SRC:
 +            oada = ((struct ofp_action_dl_addr *) ia);
 +            nl_msg_put_unspec(ctx->odp_actions, ODP_ACTION_ATTR_SET_DL_SRC,
 +                              oada->dl_addr, ETH_ADDR_LEN);
 +            memcpy(ctx->flow.dl_src, oada->dl_addr, ETH_ADDR_LEN);
 +            break;
 +
 +        case OFPAT_SET_DL_DST:
 +            oada = ((struct ofp_action_dl_addr *) ia);
 +            nl_msg_put_unspec(ctx->odp_actions, ODP_ACTION_ATTR_SET_DL_DST,
 +                              oada->dl_addr, ETH_ADDR_LEN);
 +            memcpy(ctx->flow.dl_dst, oada->dl_addr, ETH_ADDR_LEN);
 +            break;
 +
 +        case OFPAT_SET_NW_SRC:
 +            nl_msg_put_be32(ctx->odp_actions, ODP_ACTION_ATTR_SET_NW_SRC,
 +                            ia->nw_addr.nw_addr);
 +            ctx->flow.nw_src = ia->nw_addr.nw_addr;
 +            break;
 +
 +        case OFPAT_SET_NW_DST:
 +            nl_msg_put_be32(ctx->odp_actions, ODP_ACTION_ATTR_SET_NW_DST,
 +                            ia->nw_addr.nw_addr);
 +            ctx->flow.nw_dst = ia->nw_addr.nw_addr;
 +            break;
 +
 +        case OFPAT_SET_NW_TOS:
 +            nl_msg_put_u8(ctx->odp_actions, ODP_ACTION_ATTR_SET_NW_TOS,
 +                          ia->nw_tos.nw_tos);
 +            ctx->flow.nw_tos = ia->nw_tos.nw_tos;
 +            break;
 +
 +        case OFPAT_SET_TP_SRC:
 +            nl_msg_put_be16(ctx->odp_actions, ODP_ACTION_ATTR_SET_TP_SRC,
 +                            ia->tp_port.tp_port);
 +            ctx->flow.tp_src = ia->tp_port.tp_port;
 +            break;
 +
 +        case OFPAT_SET_TP_DST:
 +            nl_msg_put_be16(ctx->odp_actions, ODP_ACTION_ATTR_SET_TP_DST,
 +                            ia->tp_port.tp_port);
 +            ctx->flow.tp_dst = ia->tp_port.tp_port;
 +            break;
 +
 +        case OFPAT_VENDOR:
 +            xlate_nicira_action(ctx, (const struct nx_action_header *) ia);
 +            break;
 +
 +        case OFPAT_ENQUEUE:
 +            xlate_enqueue_action(ctx, (const struct ofp_action_enqueue *) ia);
 +            break;
 +
 +        default:
 +            VLOG_DBG_RL(&rl, "unknown action type %d", (int) type);
 +            break;
 +        }
 +    }
 +}
 +
 +static void
 +action_xlate_ctx_init(struct action_xlate_ctx *ctx,
 +                      struct ofproto_dpif *ofproto, const struct flow *flow,
 +                      const struct ofpbuf *packet)
 +{
 +    ctx->ofproto = ofproto;
 +    ctx->flow = *flow;
 +    ctx->packet = packet;
 +    ctx->resubmit_hook = NULL;
 +}
 +
 +static struct ofpbuf *
 +xlate_actions(struct action_xlate_ctx *ctx,
 +              const union ofp_action *in, size_t n_in)
 +{
 +    COVERAGE_INC(ofproto_dpif_xlate);
 +
 +    ctx->odp_actions = ofpbuf_new(512);
 +    ctx->tags = 0;
 +    ctx->may_set_up_flow = true;
 +    ctx->nf_output_iface = NF_OUT_DROP;
 +    ctx->recurse = 0;
 +    ctx->last_pop_priority = -1;
 +
 +    if (process_special(ctx->ofproto, &ctx->flow, ctx->packet)) {
 +        ctx->may_set_up_flow = false;
 +    } else {
 +        do_xlate_actions(in, n_in, ctx);
 +    }
 +
 +    remove_pop_action(ctx);
 +
 +    /* Check with in-band control to see if we're allowed to set up this
 +     * flow. */
 +    if (!connmgr_may_set_up_flow(ctx->ofproto->up.connmgr, &ctx->flow,
 +                                 ctx->odp_actions->data,
 +                                 ctx->odp_actions->size)) {
 +        ctx->may_set_up_flow = false;
 +    }
 +
 +    return ctx->odp_actions;
 +}
 +\f
 +/* OFPP_NORMAL implementation. */
 +
 +struct dst {
 +    struct ofport_dpif *port;
 +    uint16_t vlan;
 +};
 +
 +struct dst_set {
 +    struct dst builtin[32];
 +    struct dst *dsts;
 +    size_t n, allocated;
 +};
 +
 +static void dst_set_init(struct dst_set *);
 +static void dst_set_add(struct dst_set *, const struct dst *);
 +static void dst_set_free(struct dst_set *);
 +
 +static struct ofport_dpif *ofbundle_get_a_port(const struct ofbundle *);
 +
 +static bool
 +set_dst(struct action_xlate_ctx *ctx, struct dst *dst,
 +        const struct ofbundle *in_bundle, const struct ofbundle *out_bundle)
 +{
 +    dst->vlan = (out_bundle->vlan >= 0 ? OFP_VLAN_NONE
 +                 : in_bundle->vlan >= 0 ? in_bundle->vlan
 +                 : ctx->flow.vlan_tci == 0 ? OFP_VLAN_NONE
 +                 : vlan_tci_to_vid(ctx->flow.vlan_tci));
 +
 +    dst->port = (!out_bundle->bond
 +                 ? ofbundle_get_a_port(out_bundle)
 +                 : bond_choose_output_slave(out_bundle->bond, &ctx->flow,
 +                                            dst->vlan, &ctx->tags));
 +
 +    return dst->port != NULL;
 +}
 +
 +static int
 +mirror_mask_ffs(mirror_mask_t mask)
 +{
 +    BUILD_ASSERT_DECL(sizeof(unsigned int) >= sizeof(mask));
 +    return ffs(mask);
 +}
 +
 +static void
 +dst_set_init(struct dst_set *set)
 +{
 +    set->dsts = set->builtin;
 +    set->n = 0;
 +    set->allocated = ARRAY_SIZE(set->builtin);
 +}
 +
 +static void
 +dst_set_add(struct dst_set *set, const struct dst *dst)
 +{
 +    if (set->n >= set->allocated) {
 +        size_t new_allocated;
 +        struct dst *new_dsts;
 +
 +        new_allocated = set->allocated * 2;
 +        new_dsts = xmalloc(new_allocated * sizeof *new_dsts);
 +        memcpy(new_dsts, set->dsts, set->n * sizeof *new_dsts);
 +
 +        dst_set_free(set);
 +
 +        set->dsts = new_dsts;
 +        set->allocated = new_allocated;
 +    }
 +    set->dsts[set->n++] = *dst;
 +}
 +
 +static void
 +dst_set_free(struct dst_set *set)
 +{
 +    if (set->dsts != set->builtin) {
 +        free(set->dsts);
 +    }
 +}
 +
 +static bool
 +dst_is_duplicate(const struct dst_set *set, const struct dst *test)
 +{
 +    size_t i;
 +    for (i = 0; i < set->n; i++) {
 +        if (set->dsts[i].vlan == test->vlan
 +            && set->dsts[i].port == test->port) {
 +            return true;
 +        }
 +    }
 +    return false;
 +}
 +
 +static bool
 +ofbundle_trunks_vlan(const struct ofbundle *bundle, uint16_t vlan)
 +{
 +    return bundle->vlan < 0 && vlan_bitmap_contains(bundle->trunks, vlan);
 +}
 +
 +static bool
 +ofbundle_includes_vlan(const struct ofbundle *bundle, uint16_t vlan)
 +{
 +    return vlan == bundle->vlan || ofbundle_trunks_vlan(bundle, vlan);
 +}
 +
 +/* Returns an arbitrary interface within 'bundle'. */
 +static struct ofport_dpif *
 +ofbundle_get_a_port(const struct ofbundle *bundle)
 +{
 +    return CONTAINER_OF(list_front(&bundle->ports),
 +                        struct ofport_dpif, bundle_node);
 +}
 +
 +static void
 +compose_dsts(struct action_xlate_ctx *ctx, uint16_t vlan,
 +             const struct ofbundle *in_bundle,
 +             const struct ofbundle *out_bundle, struct dst_set *set)
 +{
 +    struct dst dst;
 +
 +    if (out_bundle == OFBUNDLE_FLOOD) {
 +        struct ofbundle *bundle;
 +
 +        HMAP_FOR_EACH (bundle, hmap_node, &ctx->ofproto->bundles) {
 +            if (bundle != in_bundle
 +                && ofbundle_includes_vlan(bundle, vlan)
 +                && bundle->floodable
 +                && !bundle->mirror_out
 +                && set_dst(ctx, &dst, in_bundle, bundle)) {
 +                dst_set_add(set, &dst);
 +            }
 +        }
 +        ctx->nf_output_iface = NF_OUT_FLOOD;
 +    } else if (out_bundle && set_dst(ctx, &dst, in_bundle, out_bundle)) {
 +        dst_set_add(set, &dst);
 +        ctx->nf_output_iface = dst.port->odp_port;
 +    }
 +}
 +
 +static bool
 +vlan_is_mirrored(const struct ofmirror *m, int vlan)
 +{
 +    return vlan_bitmap_contains(m->vlans, vlan);
 +}
 +
 +static void
 +compose_mirror_dsts(struct action_xlate_ctx *ctx,
 +                    uint16_t vlan, const struct ofbundle *in_bundle,
 +                    struct dst_set *set)
 +{
 +    struct ofproto_dpif *ofproto = ctx->ofproto;
 +    mirror_mask_t mirrors;
 +    int flow_vlan;
 +    size_t i;
 +
 +    mirrors = in_bundle->src_mirrors;
 +    for (i = 0; i < set->n; i++) {
 +        mirrors |= set->dsts[i].port->bundle->dst_mirrors;
 +    }
 +
 +    if (!mirrors) {
 +        return;
 +    }
 +
 +    flow_vlan = vlan_tci_to_vid(ctx->flow.vlan_tci);
 +    if (flow_vlan == 0) {
 +        flow_vlan = OFP_VLAN_NONE;
 +    }
 +
 +    while (mirrors) {
 +        struct ofmirror *m = ofproto->mirrors[mirror_mask_ffs(mirrors) - 1];
 +        if (vlan_is_mirrored(m, vlan)) {
 +            struct dst dst;
 +
 +            if (m->out) {
 +                if (set_dst(ctx, &dst, in_bundle, m->out)
 +                    && !dst_is_duplicate(set, &dst)) {
 +                    dst_set_add(set, &dst);
 +                }
 +            } else {
 +                struct ofbundle *bundle;
 +
 +                HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
 +                    if (ofbundle_includes_vlan(bundle, m->out_vlan)
 +                        && set_dst(ctx, &dst, in_bundle, bundle))
 +                    {
 +                        if (bundle->vlan < 0) {
 +                            dst.vlan = m->out_vlan;
 +                        }
 +                        if (dst_is_duplicate(set, &dst)) {
 +                            continue;
 +                        }
 +
 +                        /* Use the vlan tag on the original flow instead of
 +                         * the one passed in the vlan parameter.  This ensures
 +                         * that we compare the vlan from before any implicit
 +                         * tagging tags place. This is necessary because
 +                         * dst->vlan is the final vlan, after removing implicit
 +                         * tags. */
 +                        if (bundle == in_bundle && dst.vlan == flow_vlan) {
 +                            /* Don't send out input port on same VLAN. */
 +                            continue;
 +                        }
 +                        dst_set_add(set, &dst);
 +                    }
 +                }
 +            }
 +        }
 +        mirrors &= mirrors - 1;
 +    }
 +}
 +
 +static void
 +compose_actions(struct action_xlate_ctx *ctx, uint16_t vlan,
 +                const struct ofbundle *in_bundle,
 +                const struct ofbundle *out_bundle)
 +{
 +    uint16_t initial_vlan, cur_vlan;
 +    const struct dst *dst;
 +    struct dst_set set;
 +
 +    dst_set_init(&set);
 +    compose_dsts(ctx, vlan, in_bundle, out_bundle, &set);
 +    compose_mirror_dsts(ctx, vlan, in_bundle, &set);
 +
 +    /* Output all the packets we can without having to change the VLAN. */
 +    initial_vlan = vlan_tci_to_vid(ctx->flow.vlan_tci);
 +    if (initial_vlan == 0) {
 +        initial_vlan = OFP_VLAN_NONE;
 +    }
 +    for (dst = set.dsts; dst < &set.dsts[set.n]; dst++) {
 +        if (dst->vlan != initial_vlan) {
 +            continue;
 +        }
 +        nl_msg_put_u32(ctx->odp_actions,
 +                       ODP_ACTION_ATTR_OUTPUT, dst->port->odp_port);
 +    }
 +
 +    /* Then output the rest. */
 +    cur_vlan = initial_vlan;
 +    for (dst = set.dsts; dst < &set.dsts[set.n]; dst++) {
 +        if (dst->vlan == initial_vlan) {
 +            continue;
 +        }
 +        if (dst->vlan != cur_vlan) {
 +            if (dst->vlan == OFP_VLAN_NONE) {
 +                nl_msg_put_flag(ctx->odp_actions, ODP_ACTION_ATTR_STRIP_VLAN);
 +            } else {
 +                ovs_be16 tci;
 +                tci = htons(dst->vlan & VLAN_VID_MASK);
 +                tci |= ctx->flow.vlan_tci & htons(VLAN_PCP_MASK);
 +                nl_msg_put_be16(ctx->odp_actions,
 +                                ODP_ACTION_ATTR_SET_DL_TCI, tci);
 +            }
 +            cur_vlan = dst->vlan;
 +        }
 +        nl_msg_put_u32(ctx->odp_actions,
 +                       ODP_ACTION_ATTR_OUTPUT, dst->port->odp_port);
 +    }
 +
 +    dst_set_free(&set);
 +}
 +
 +/* Returns the effective vlan of a packet, taking into account both the
 + * 802.1Q header and implicitly tagged ports.  A value of 0 indicates that
 + * the packet is untagged and -1 indicates it has an invalid header and
 + * should be dropped. */
 +static int
 +flow_get_vlan(struct ofproto_dpif *ofproto, const struct flow *flow,
 +              struct ofbundle *in_bundle, bool have_packet)
 +{
 +    int vlan = vlan_tci_to_vid(flow->vlan_tci);
 +    if (in_bundle->vlan >= 0) {
 +        if (vlan) {
 +            if (have_packet) {
 +                static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 +                VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %d tagged "
 +                             "packet received on port %s configured with "
 +                             "implicit VLAN %"PRIu16,
 +                             ofproto->up.name, vlan,
 +                             in_bundle->name, in_bundle->vlan);
 +            }
 +            return -1;
 +        }
 +        vlan = in_bundle->vlan;
 +    } else {
 +        if (!ofbundle_includes_vlan(in_bundle, vlan)) {
 +            if (have_packet) {
 +                static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 +                VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %d tagged "
 +                             "packet received on port %s not configured for "
 +                             "trunking VLAN %d",
 +                             ofproto->up.name, vlan, in_bundle->name, vlan);
 +            }
 +            return -1;
 +        }
 +    }
 +
 +    return vlan;
 +}
 +
 +/* A VM broadcasts a gratuitous ARP to indicate that it has resumed after
 + * migration.  Older Citrix-patched Linux DomU used gratuitous ARP replies to
 + * indicate this; newer upstream kernels use gratuitous ARP requests. */
 +static bool
 +is_gratuitous_arp(const struct flow *flow)
 +{
 +    return (flow->dl_type == htons(ETH_TYPE_ARP)
 +            && eth_addr_is_broadcast(flow->dl_dst)
 +            && (flow->nw_proto == ARP_OP_REPLY
 +                || (flow->nw_proto == ARP_OP_REQUEST
 +                    && flow->nw_src == flow->nw_dst)));
 +}
 +
 +static void
 +update_learning_table(struct ofproto_dpif *ofproto,
 +                      const struct flow *flow, int vlan,
 +                      struct ofbundle *in_bundle)
 +{
 +    struct mac_entry *mac;
 +
 +    if (!mac_learning_may_learn(ofproto->ml, flow->dl_src, vlan)) {
 +        return;
 +    }
 +
 +    mac = mac_learning_insert(ofproto->ml, flow->dl_src, vlan);
 +    if (is_gratuitous_arp(flow)) {
 +        /* We don't want to learn from gratuitous ARP packets that are
 +         * reflected back over bond slaves so we lock the learning table. */
 +        if (!in_bundle->bond) {
 +            mac_entry_set_grat_arp_lock(mac);
 +        } else if (mac_entry_is_grat_arp_locked(mac)) {
 +            return;
 +        }
 +    }
 +
 +    if (mac_entry_is_new(mac) || mac->port.p != in_bundle) {
 +        /* The log messages here could actually be useful in debugging,
 +         * so keep the rate limit relatively high. */
 +        static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(30, 300);
 +        VLOG_DBG_RL(&rl, "bridge %s: learned that "ETH_ADDR_FMT" is "
 +                    "on port %s in VLAN %d",
 +                    ofproto->up.name, ETH_ADDR_ARGS(flow->dl_src),
 +                    in_bundle->name, vlan);
 +
 +        mac->port.p = in_bundle;
 +        tag_set_add(&ofproto->revalidate_set,
 +                    mac_learning_changed(ofproto->ml, mac));
 +    }
 +}
 +
 +/* Determines whether packets in 'flow' within 'br' should be forwarded or
 + * dropped.  Returns true if they may be forwarded, false if they should be
 + * dropped.
 + *
 + * If 'have_packet' is true, it indicates that the caller is processing a
 + * received packet.  If 'have_packet' is false, then the caller is just
 + * revalidating an existing flow because configuration has changed.  Either
 + * way, 'have_packet' only affects logging (there is no point in logging errors
 + * during revalidation).
 + *
 + * Sets '*in_portp' to the input port.  This will be a null pointer if
 + * flow->in_port does not designate a known input port (in which case
 + * is_admissible() returns false).
 + *
 + * When returning true, sets '*vlanp' to the effective VLAN of the input
 + * packet, as returned by flow_get_vlan().
 + *
 + * May also add tags to '*tags', although the current implementation only does
 + * so in one special case.
 + */
 +static bool
 +is_admissible(struct ofproto_dpif *ofproto, const struct flow *flow,
 +              bool have_packet,
 +              tag_type *tags, int *vlanp, struct ofbundle **in_bundlep)
 +{
 +    struct ofport_dpif *in_port;
 +    struct ofbundle *in_bundle;
 +    int vlan;
 +
 +    /* Find the port and bundle for the received packet. */
 +    in_port = get_ofp_port(ofproto, flow->in_port);
 +    *in_bundlep = in_bundle = in_port->bundle;
 +    if (!in_port || !in_bundle) {
 +        /* No interface?  Something fishy... */
 +        if (have_packet) {
 +            /* Odd.  A few possible reasons here:
 +             *
 +             * - We deleted a port but there are still a few packets queued up
 +             *   from it.
 +             *
 +             * - Someone externally added a port (e.g. "ovs-dpctl add-if") that
 +             *   we don't know about.
 +             *
 +             * - Packet arrived on the local port but the local port is not
 +             *   part of a bundle.
 +             */
 +            static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 +
 +            VLOG_WARN_RL(&rl, "bridge %s: received packet on unknown "
 +                         "port %"PRIu16,
 +                         ofproto->up.name, flow->in_port);
 +        }
 +        return false;
 +    }
 +    *vlanp = vlan = flow_get_vlan(ofproto, flow, in_bundle, have_packet);
 +    if (vlan < 0) {
 +        return false;
 +    }
 +
 +    /* Drop frames for reserved multicast addresses. */
 +    if (eth_addr_is_reserved(flow->dl_dst)) {
 +        return false;
 +    }
 +
 +    /* Drop frames on bundles reserved for mirroring. */
 +    if (in_bundle->mirror_out) {
 +        if (have_packet) {
 +            static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 +            VLOG_WARN_RL(&rl, "bridge %s: dropping packet received on port "
 +                         "%s, which is reserved exclusively for mirroring",
 +                         ofproto->up.name, in_bundle->name);
 +        }
 +        return false;
 +    }
 +
 +    if (in_bundle->bond) {
 +        struct mac_entry *mac;
 +
 +        switch (bond_check_admissibility(in_bundle->bond, in_port,
 +                                         flow->dl_dst, tags)) {
 +        case BV_ACCEPT:
 +            break;
 +
 +        case BV_DROP:
 +            return false;
 +
 +        case BV_DROP_IF_MOVED:
 +            mac = mac_learning_lookup(ofproto->ml, flow->dl_src, vlan, NULL);
 +            if (mac && mac->port.p != in_bundle &&
 +                (!is_gratuitous_arp(flow)
 +                 || mac_entry_is_grat_arp_locked(mac))) {
 +                return false;
 +            }
 +            break;
 +        }
 +    }
 +
 +    return true;
 +}
 +
 +/* If the composed actions may be applied to any packet in the given 'flow',
 + * returns true.  Otherwise, the actions should only be applied to 'packet', or
 + * not at all, if 'packet' was NULL. */
 +static bool
 +xlate_normal(struct action_xlate_ctx *ctx)
 +{
 +    struct ofbundle *in_bundle;
 +    struct ofbundle *out_bundle;
 +    struct mac_entry *mac;
 +    int vlan;
 +
 +    /* Check whether we should drop packets in this flow. */
 +    if (!is_admissible(ctx->ofproto, &ctx->flow, ctx->packet != NULL,
 +                       &ctx->tags, &vlan, &in_bundle)) {
 +        out_bundle = NULL;
 +        goto done;
 +    }
 +
 +    /* Learn source MAC (but don't try to learn from revalidation). */
 +    if (ctx->packet) {
 +        update_learning_table(ctx->ofproto, &ctx->flow, vlan, in_bundle);
 +    }
 +
 +    /* Determine output bundle. */
 +    mac = mac_learning_lookup(ctx->ofproto->ml, ctx->flow.dl_dst, vlan,
 +                              &ctx->tags);
 +    if (mac) {
 +        out_bundle = mac->port.p;
 +    } else if (!ctx->packet && !eth_addr_is_multicast(ctx->flow.dl_dst)) {
 +        /* If we are revalidating but don't have a learning entry then eject
 +         * the flow.  Installing a flow that floods packets opens up a window
 +         * of time where we could learn from a packet reflected on a bond and
 +         * blackhole packets before the learning table is updated to reflect
 +         * the correct port. */
 +        return false;
 +    } else {
 +        out_bundle = OFBUNDLE_FLOOD;
 +    }
 +
 +    /* Don't send packets out their input bundles. */
 +    if (in_bundle == out_bundle) {
 +        out_bundle = NULL;
 +    }
 +
 +done:
 +    if (in_bundle) {
 +        compose_actions(ctx, vlan, in_bundle, out_bundle);
 +    }
 +
 +    return true;
 +}
 +\f
 +static bool
 +get_drop_frags(struct ofproto *ofproto_)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    bool drop_frags;
 +
 +    dpif_get_drop_frags(ofproto->dpif, &drop_frags);
 +    return drop_frags;
 +}
 +
 +static void
 +set_drop_frags(struct ofproto *ofproto_, bool drop_frags)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +
 +    dpif_set_drop_frags(ofproto->dpif, drop_frags);
 +}
 +
 +static int
 +packet_out(struct ofproto *ofproto_, struct ofpbuf *packet,
 +           const struct flow *flow,
 +           const union ofp_action *ofp_actions, size_t n_ofp_actions)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +    int error;
 +
 +    error = validate_actions(ofp_actions, n_ofp_actions, flow,
 +                             ofproto->max_ports);
 +    if (!error) {
 +        struct action_xlate_ctx ctx;
 +        struct ofpbuf *odp_actions;
 +
 +        action_xlate_ctx_init(&ctx, ofproto, flow, packet);
 +        odp_actions = xlate_actions(&ctx, ofp_actions, n_ofp_actions);
 +        dpif_execute(ofproto->dpif, odp_actions->data, odp_actions->size,
 +                     packet);
 +        ofpbuf_delete(odp_actions);
 +    }
 +    return error;
 +}
 +
 +static void
 +get_netflow_ids(const struct ofproto *ofproto_,
 +                uint8_t *engine_type, uint8_t *engine_id)
 +{
 +    struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 +
 +    dpif_get_netflow_ids(ofproto->dpif, engine_type, engine_id);
 +}
 +\f
 +static struct ofproto_dpif *
 +ofproto_dpif_lookup(const char *name)
 +{
 +    struct ofproto *ofproto = ofproto_lookup(name);
 +    return (ofproto && ofproto->ofproto_class == &ofproto_dpif_class
 +            ? ofproto_dpif_cast(ofproto)
 +            : NULL);
 +}
 +
 +static void
 +ofproto_unixctl_fdb_show(struct unixctl_conn *conn,
 +                         const char *args, void *aux OVS_UNUSED)
 +{
 +    struct ds ds = DS_EMPTY_INITIALIZER;
 +    const struct ofproto_dpif *ofproto;
 +    const struct mac_entry *e;
 +
 +    ofproto = ofproto_dpif_lookup(args);
 +    if (!ofproto) {
 +        unixctl_command_reply(conn, 501, "no such bridge");
 +        return;
 +    }
 +
 +    ds_put_cstr(&ds, " port  VLAN  MAC                Age\n");
 +    LIST_FOR_EACH (e, lru_node, &ofproto->ml->lrus) {
 +        struct ofbundle *bundle = e->port.p;
 +        ds_put_format(&ds, "%5d  %4d  "ETH_ADDR_FMT"  %3d\n",
 +                      ofbundle_get_a_port(bundle)->odp_port,
 +                      e->vlan, ETH_ADDR_ARGS(e->mac), mac_entry_age(e));
 +    }
 +    unixctl_command_reply(conn, 200, ds_cstr(&ds));
 +    ds_destroy(&ds);
 +}
 +
 +struct ofproto_trace {
 +    struct action_xlate_ctx ctx;
 +    struct flow flow;
 +    struct ds *result;
 +};
 +
 +static void
 +trace_format_rule(struct ds *result, int level, const struct rule *rule)
 +{
 +    ds_put_char_multiple(result, '\t', level);
 +    if (!rule) {
 +        ds_put_cstr(result, "No match\n");
 +        return;
 +    }
 +
 +    ds_put_format(result, "Rule: cookie=%#"PRIx64" ",
 +                  ntohll(rule->flow_cookie));
 +    cls_rule_format(&rule->cr, result);
 +    ds_put_char(result, '\n');
 +
 +    ds_put_char_multiple(result, '\t', level);
 +    ds_put_cstr(result, "OpenFlow ");
 +    ofp_print_actions(result, (const struct ofp_action_header *) rule->actions,
 +                      rule->n_actions * sizeof *rule->actions);
 +    ds_put_char(result, '\n');
 +}
 +
 +static void
 +trace_format_flow(struct ds *result, int level, const char *title,
 +                 struct ofproto_trace *trace)
 +{
 +    ds_put_char_multiple(result, '\t', level);
 +    ds_put_format(result, "%s: ", title);
 +    if (flow_equal(&trace->ctx.flow, &trace->flow)) {
 +        ds_put_cstr(result, "unchanged");
 +    } else {
 +        flow_format(result, &trace->ctx.flow);
 +        trace->flow = trace->ctx.flow;
 +    }
 +    ds_put_char(result, '\n');
 +}
 +
 +static void
 +trace_resubmit(struct action_xlate_ctx *ctx, struct rule_dpif *rule)
 +{
 +    struct ofproto_trace *trace = CONTAINER_OF(ctx, struct ofproto_trace, ctx);
 +    struct ds *result = trace->result;
 +
 +    ds_put_char(result, '\n');
 +    trace_format_flow(result, ctx->recurse + 1, "Resubmitted flow", trace);
 +    trace_format_rule(result, ctx->recurse + 1, &rule->up);
 +}
 +
 +static void
 +ofproto_unixctl_trace(struct unixctl_conn *conn, const char *args_,
 +                      void *aux OVS_UNUSED)
 +{
 +    char *dpname, *in_port_s, *tun_id_s, *packet_s;
 +    char *args = xstrdup(args_);
 +    char *save_ptr = NULL;
 +    struct ofproto_dpif *ofproto;
 +    struct ofpbuf packet;
 +    struct rule_dpif *rule;
 +    struct ds result;
 +    struct flow flow;
 +    uint16_t in_port;
 +    ovs_be64 tun_id;
 +    char *s;
 +
 +    ofpbuf_init(&packet, strlen(args) / 2);
 +    ds_init(&result);
 +
 +    dpname = strtok_r(args, " ", &save_ptr);
 +    tun_id_s = strtok_r(NULL, " ", &save_ptr);
 +    in_port_s = strtok_r(NULL, " ", &save_ptr);
 +    packet_s = strtok_r(NULL, "", &save_ptr); /* Get entire rest of line. */
 +    if (!dpname || !in_port_s || !packet_s) {
 +        unixctl_command_reply(conn, 501, "Bad command syntax");
 +        goto exit;
 +    }
 +
 +    ofproto = ofproto_dpif_lookup(dpname);
 +    if (!ofproto) {
 +        unixctl_command_reply(conn, 501, "Unknown ofproto (use ofproto/list "
 +                              "for help)");
 +        goto exit;
 +    }
 +
 +    tun_id = htonll(strtoull(tun_id_s, NULL, 0));
 +    in_port = ofp_port_to_odp_port(atoi(in_port_s));
 +
 +    packet_s = ofpbuf_put_hex(&packet, packet_s, NULL);
 +    packet_s += strspn(packet_s, " ");
 +    if (*packet_s != '\0') {
 +        unixctl_command_reply(conn, 501, "Trailing garbage in command");
 +        goto exit;
 +    }
 +    if (packet.size < ETH_HEADER_LEN) {
 +        unixctl_command_reply(conn, 501, "Packet data too short for Ethernet");
 +        goto exit;
 +    }
 +
 +    ds_put_cstr(&result, "Packet: ");
 +    s = ofp_packet_to_string(packet.data, packet.size, packet.size);
 +    ds_put_cstr(&result, s);
 +    free(s);
 +
 +    flow_extract(&packet, tun_id, in_port, &flow);
 +    ds_put_cstr(&result, "Flow: ");
 +    flow_format(&result, &flow);
 +    ds_put_char(&result, '\n');
 +
 +    rule = rule_dpif_lookup(ofproto, &flow);
 +    trace_format_rule(&result, 0, &rule->up);
 +    if (rule) {
 +        struct ofproto_trace trace;
 +        struct ofpbuf *odp_actions;
 +
 +        trace.result = &result;
 +        trace.flow = flow;
 +        action_xlate_ctx_init(&trace.ctx, ofproto, &flow, &packet);
 +        trace.ctx.resubmit_hook = trace_resubmit;
 +        odp_actions = xlate_actions(&trace.ctx,
 +                                    rule->up.actions, rule->up.n_actions);
 +
 +        ds_put_char(&result, '\n');
 +        trace_format_flow(&result, 0, "Final flow", &trace);
 +        ds_put_cstr(&result, "Datapath actions: ");
 +        format_odp_actions(&result, odp_actions->data, odp_actions->size);
 +        ofpbuf_delete(odp_actions);
 +    }
 +
 +    unixctl_command_reply(conn, 200, ds_cstr(&result));
 +
 +exit:
 +    ds_destroy(&result);
 +    ofpbuf_uninit(&packet);
 +    free(args);
 +}
 +
 +static void
 +ofproto_dpif_unixctl_init(void)
 +{
 +    static bool registered;
 +    if (registered) {
 +        return;
 +    }
 +    registered = true;
 +
 +    unixctl_command_register("ofproto/trace", ofproto_unixctl_trace, NULL);
 +    unixctl_command_register("fdb/show", ofproto_unixctl_fdb_show, NULL);
 +}
 +\f
 +const struct ofproto_class ofproto_dpif_class = {
 +    enumerate_types,
 +    enumerate_names,
 +    del,
 +    alloc,
 +    construct,
 +    destruct,
 +    dealloc,
 +    run,
 +    wait,
 +    flush,
 +    get_features,
 +    get_tables,
 +    port_alloc,
 +    port_construct,
 +    port_destruct,
 +    port_dealloc,
 +    port_modified,
 +    port_reconfigured,
 +    port_query_by_name,
 +    port_add,
 +    port_del,
 +    port_dump_start,
 +    port_dump_next,
 +    port_dump_done,
 +    port_poll,
 +    port_poll_wait,
 +    port_is_lacp_current,
 +    rule_alloc,
 +    rule_construct,
 +    rule_destruct,
 +    rule_dealloc,
 +    rule_get_stats,
 +    rule_execute,
 +    rule_modify_actions,
 +    get_drop_frags,
 +    set_drop_frags,
 +    packet_out,
 +    set_netflow,
 +    get_netflow_ids,
 +    set_sflow,
 +    set_cfm,
 +    get_cfm,
 +    bundle_set,
 +    bundle_remove,
 +    mirror_set,
 +    set_flood_vlans,
 +    is_mirror_output_bundle,
 +};
index f0fc4ec73e485200560e76e02de3949ff76fe8ea,4ed29143709fcf80e42b159e49212f9cdd9820bd..bfcae57a1b27aa89b67832e816aaff5a3663fa22
@@@ -1668,28 -2771,19 +1668,21 @@@ handle_table_stats_request(struct ofcon
      struct ofproto *p = ofconn_get_ofproto(ofconn);
      struct ofp_table_stats *ots;
      struct ofpbuf *msg;
 +    size_t i;
  
 -    msg = start_ofp_stats_reply(request, sizeof *ots * 2);
 +    msg = start_ofp_stats_reply(request, sizeof *ots * p->n_tables);
  
 -    /* Classifier table. */
 -    ots = append_ofp_stats_reply(sizeof *ots, ofconn, &msg);
 -    memset(ots, 0, sizeof *ots);
 -    strcpy(ots->name, "classifier");
 -    ots->wildcards = htonl(OFPFW_ALL);
 -    ots->max_entries = htonl(1024 * 1024); /* An arbitrary big number. */
 -    ots->active_count = htonl(classifier_count(&p->cls));
 -    put_32aligned_be64(&ots->lookup_count, htonll(0));  /* XXX */
 -    put_32aligned_be64(&ots->matched_count, htonll(0)); /* XXX */
 +    ots = ofpbuf_put_zeros(msg, sizeof *ots * p->n_tables);
 +    for (i = 0; i < p->n_tables; i++) {
 +        ots[i].table_id = i;
 +        sprintf(ots[i].name, "table%d", i);
-         ots[i].wildcards = htonl(OVSFW_ALL);
++        ots[i].wildcards = htonl(OFPFW_ALL);
 +        ots[i].max_entries = htonl(1000000); /* An arbitrary big number. */
 +        ots[i].active_count = htonl(classifier_count(&p->tables[i]));
 +    }
 +
 +    p->ofproto_class->get_tables(p, ots);
  
-     if (ofconn_get_flow_format(ofconn) == NXFF_OPENFLOW10) {
-         /* OpenFlow 1.0 only supports the OFPFW_* bits. */
-         for (i = 0; i < p->n_tables; i++) {
-             ots[i].wildcards &= htonl(OFPFW_ALL);
-         }
-     }
      ofconn_send_reply(ofconn, msg);
      return 0;
  }
@@@ -1770,10 -2864,8 +1763,9 @@@ static voi
  put_ofp_flow_stats(struct ofconn *ofconn, struct rule *rule,
                     ovs_be16 out_port, struct ofpbuf **replyp)
  {
 +    struct ofproto *ofproto = ofconn_get_ofproto(ofconn);
      struct ofp_flow_stats *ofs;
      uint64_t packet_count, byte_count;
-     ovs_be64 cookie;
      size_t act_len, len;
  
      if (rule_is_hidden(rule) || !rule_has_out_port(rule, out_port)) {
  
      ofs = append_ofp_stats_reply(len, ofconn, replyp);
      ofs->length = htons(len);
 -    ofs->table_id = 0;
 +    ofs->table_id = rule->table_id;
      ofs->pad = 0;
-     ofputil_cls_rule_to_match(&rule->cr, ofconn_get_flow_format(ofconn),
-                               &ofs->match, rule->flow_cookie, &cookie);
-     put_32aligned_be64(&ofs->cookie, cookie);
+     ofputil_cls_rule_to_match(&rule->cr, &ofs->match);
+     put_32aligned_be64(&ofs->cookie, rule->flow_cookie);
      calc_flow_duration(rule->created, &ofs->duration_sec, &ofs->duration_nsec);
      ofs->priority = htons(rule->cr.priority);
      ofs->idle_timeout = htons(rule->idle_timeout);
@@@ -1860,12 -2919,13 +1851,12 @@@ handle_flow_stats_request(struct ofcon
  
      COVERAGE_INC(ofproto_flows_req);
      reply = start_ofp_stats_reply(oh, 1024);
-     ofputil_cls_rule_from_match(&fsr->match, 0, NXFF_OPENFLOW10, 0, &target);
 -    if (is_valid_table(fsr->table_id)) {
++    ofputil_cls_rule_from_match(&fsr->match, 0, &target);
 +    FOR_EACH_MATCHING_TABLE (cls, fsr->table_id, ofproto) {
          struct cls_cursor cursor;
 -        struct cls_rule target;
          struct rule *rule;
  
 -        ofputil_cls_rule_from_match(&fsr->match, 0, &target);
 -        cls_cursor_init(&cursor, &ofproto->cls, &target);
 +        cls_cursor_init(&cursor, cls, &target);
          CLS_CURSOR_FOR_EACH (rule, cr, &cursor) {
              put_ofp_flow_stats(ofconn, rule, fsr->out_port, &reply);
          }
@@@ -2503,8 -3543,7 +2493,8 @@@ handle_flow_mod(struct ofconn *ofconn, 
          return error;
      }
  
-     error = ofputil_decode_flow_mod(&fm, oh, ofconn_get_flow_format(ofconn),
 -    error = ofputil_decode_flow_mod(&fm, oh);
++    error = ofputil_decode_flow_mod(&fm, oh,
 +                                    ofconn_get_flow_mod_table_id(ofconn));
      if (error) {
          return error;
      }
index ed8d45b3f11fa69b3581492a8d71f9037264feb0,9a56beec27aec9bee43b15dbc5a8fcbb3ea58915..ea9f98b3d391f5e90a8b3defed256dfbf7435d75
@@@ -163,68 -121,22 +163,69 @@@ void ofproto_set_desc(struct ofproto *
  int ofproto_set_snoops(struct ofproto *, const struct sset *snoops);
  int ofproto_set_netflow(struct ofproto *,
                          const struct netflow_options *nf_options);
 -void ofproto_set_sflow(struct ofproto *, const struct ofproto_sflow_options *);
 +int ofproto_set_sflow(struct ofproto *, const struct ofproto_sflow_options *);
  
 -/* Configuration of individual interfaces. */
 -struct cfm;
 +/* Configuration of ports. */
 +
 +void ofproto_port_unregister(struct ofproto *, uint16_t ofp_port);
 +
 +void ofproto_port_clear_cfm(struct ofproto *, uint16_t ofp_port);
 +void ofproto_port_set_cfm(struct ofproto *, uint16_t ofp_port,
 +                          const struct cfm *,
 +                          const uint16_t *remote_mps, size_t n_remote_mps);
 +const struct cfm *ofproto_port_get_cfm(struct ofproto *, uint16_t ofp_port);
 +int ofproto_port_is_lacp_current(struct ofproto *, uint16_t ofp_port);
  
 -void ofproto_iface_clear_cfm(struct ofproto *, uint32_t port_no);
 -void ofproto_iface_set_cfm(struct ofproto *, uint32_t port_no,
 -                           const struct cfm *,
 -                           const uint16_t *remote_mps, size_t n_remote_mps);
 -const struct cfm *ofproto_iface_get_cfm(struct ofproto *, uint32_t port_no);
 +/* Configuration of bundles. */
 +struct ofproto_bundle_settings {
 +    char *name;                 /* For use in log messages. */
 +
 +    uint16_t *slaves;           /* OpenFlow port numbers for slaves. */
 +    size_t n_slaves;
 +
 +    int vlan;                   /* VLAN if access port, -1 if trunk port. */
 +    unsigned long *trunks;      /* vlan_bitmap, NULL to trunk all VLANs. */
 +
 +    struct bond_settings *bond; /* Must be nonnull iff if n_slaves > 1. */
++    uint32_t *bond_stable_ids;  /* Array of n_slaves elements. */
 +
 +    struct lacp_settings *lacp;              /* Nonnull to enable LACP. */
 +    struct lacp_slave_settings *lacp_slaves; /* Array of n_slaves elements. */
 +};
 +
 +int ofproto_bundle_register(struct ofproto *, void *aux,
 +                            const struct ofproto_bundle_settings *);
 +int ofproto_bundle_unregister(struct ofproto *, void *aux);
 +
 +/* Configuration of mirrors. */
 +struct ofproto_mirror_settings {
 +    /* Name for log messages. */
 +    char *name;
 +
 +    /* Bundles that select packets for mirroring upon ingress.  */
 +    void **srcs;                /* A set of registered ofbundle handles. */
 +    size_t n_srcs;
 +
 +    /* Bundles that select packets for mirroring upon egress.  */
 +    void **dsts;                /* A set of registered ofbundle handles. */
 +    size_t n_dsts;
 +
 +    /* VLANs of packets to select for mirroring. */
 +    unsigned long *src_vlans;   /* vlan_bitmap, NULL selects all VLANs. */
 +
 +    /* Output (mutually exclusive). */
 +    void *out_bundle;           /* A registered ofbundle handle or NULL. */
 +    uint16_t out_vlan;          /* Output VLAN, only if out_bundle is NULL. */
 +};
 +
 +int ofproto_mirror_register(struct ofproto *, void *aux,
 +                            const struct ofproto_mirror_settings *);
 +int ofproto_mirror_unregister(struct ofproto *, void *aux);
 +
 +int ofproto_set_flood_vlans(struct ofproto *, unsigned long *flood_vlans);
 +bool ofproto_is_mirror_output_bundle(struct ofproto *, void *aux);
  
  /* Configuration querying. */
 -uint64_t ofproto_get_datapath_id(const struct ofproto *);
 -bool ofproto_has_primary_controller(const struct ofproto *);
 -enum ofproto_fail_mode ofproto_get_fail_mode(const struct ofproto *);
 -void ofproto_get_listeners(const struct ofproto *, struct sset *);
  bool ofproto_has_snoops(const struct ofproto *);
  void ofproto_get_snoops(const struct ofproto *, struct sset *);
  void ofproto_get_all_flows(struct ofproto *p, struct ds *);
index f2e3204594db38e310d28887bb9e4365ecc922e5,0000000000000000000000000000000000000000..35a6d1c599dd0f6195ffddf90fbebf20b32620fe
mode 100644,000000..100644
--- /dev/null
@@@ -1,743 -1,0 +1,743 @@@
-      *   - 'wildcards' to OVSFW_ALL.
 +/*
 + * Copyright (c) 2009, 2010, 2011 Nicira Networks.
 + *
 + * Licensed under the Apache License, Version 2.0 (the "License");
 + * you may not use this file except in compliance with the License.
 + * You may obtain a copy of the License at:
 + *
 + *     http://www.apache.org/licenses/LICENSE-2.0
 + *
 + * Unless required by applicable law or agreed to in writing, software
 + * distributed under the License is distributed on an "AS IS" BASIS,
 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 + * See the License for the specific language governing permissions and
 + * limitations under the License.
 + */
 +
 +#ifndef OFPROTO_PRIVATE_H
 +#define OFPROTO_PRIVATE_H 1
 +
 +/* Definitions for use within ofproto. */
 +
 +#include "ofproto/ofproto.h"
 +#include "classifier.h"
 +#include "list.h"
 +#include "shash.h"
 +#include "timeval.h"
 +
 +/* An OpenFlow switch.
 + *
 + * With few exceptions, ofproto implementations may look at these fields but
 + * should not modify them. */
 +struct ofproto {
 +    const struct ofproto_class *ofproto_class;
 +    char *type;                 /* Datapath type. */
 +    char *name;                 /* Datapath name. */
 +    struct hmap_node hmap_node; /* In global 'all_ofprotos' hmap. */
 +
 +    /* Settings. */
 +    uint64_t fallback_dpid;     /* Datapath ID if no better choice found. */
 +    uint64_t datapath_id;       /* Datapath ID. */
 +    char *mfr_desc;             /* Manufacturer. */
 +    char *hw_desc;              /* Hardware. */
 +    char *sw_desc;              /* Software version. */
 +    char *serial_desc;          /* Serial number. */
 +    char *dp_desc;              /* Datapath description. */
 +
 +    /* Datapath. */
 +    struct netdev_monitor *netdev_monitor;
 +    struct hmap ports;          /* Contains "struct ofport"s. */
 +    struct shash port_by_name;
 +
 +    /* Flow tables. */
 +    struct classifier *tables;  /* Each classifier contains "struct rule"s. */
 +    int n_tables;
 +
 +    /* OpenFlow connections. */
 +    struct connmgr *connmgr;
 +};
 +
 +struct ofproto *ofproto_lookup(const char *name);
 +struct ofport *ofproto_get_port(const struct ofproto *, uint16_t ofp_port);
 +
 +/* An OpenFlow port within a "struct ofproto".
 + *
 + * With few exceptions, ofproto implementations may look at these fields but
 + * should not modify them. */
 +struct ofport {
 +    struct ofproto *ofproto;    /* The ofproto that contains this port. */
 +    struct hmap_node hmap_node; /* In struct ofproto's "ports" hmap. */
 +    struct netdev *netdev;
 +    struct ofp_phy_port opp;
 +    uint16_t ofp_port;          /* OpenFlow port number. */
 +};
 +
 +/* An OpenFlow flow within a "struct ofproto".
 + *
 + * With few exceptions, ofproto implementations may look at these fields but
 + * should not modify them. */
 +struct rule {
 +    struct ofproto *ofproto;     /* The ofproto that contains this rule. */
 +    struct cls_rule cr;          /* In owning ofproto's classifier. */
 +
 +    ovs_be64 flow_cookie;        /* Controller-issued identifier. */
 +
 +    long long int created;       /* Creation time. */
 +    uint16_t idle_timeout;       /* In seconds from time of last use. */
 +    uint16_t hard_timeout;       /* In seconds from time of creation. */
 +    uint8_t table_id;            /* Index in ofproto's 'tables' array. */
 +    bool send_flow_removed;      /* Send a flow removed message? */
 +
 +    union ofp_action *actions;   /* OpenFlow actions. */
 +    int n_actions;               /* Number of elements in actions[]. */
 +};
 +
 +static inline struct rule *
 +rule_from_cls_rule(const struct cls_rule *cls_rule)
 +{
 +    return cls_rule ? CONTAINER_OF(cls_rule, struct rule, cr) : NULL;
 +}
 +
 +void ofproto_rule_expire(struct rule *, uint8_t reason);
 +void ofproto_rule_destroy(struct rule *);
 +
 +/* ofproto class structure, to be defined by each ofproto implementation.
 + *
 + *
 + * Data Structures
 + * ===============
 + *
 + * These functions work primarily with three different kinds of data
 + * structures:
 + *
 + *   - "struct ofproto", which represents an OpenFlow switch.
 + *
 + *   - "struct ofport", which represents a port within an ofproto.
 + *
 + *   - "struct rule", which represents an OpenFlow flow within an ofproto.
 + *
 + * Each of these data structures contains all of the implementation-independent
 + * generic state for the respective concept, called the "base" state.  None of
 + * them contains any extra space for ofproto implementations to use.  Instead,
 + * each implementation is expected to declare its own data structure that
 + * contains an instance of the generic data structure plus additional
 + * implementation-specific members, called the "derived" state.  The
 + * implementation can use casts or (preferably) the CONTAINER_OF macro to
 + * obtain access to derived state given only a pointer to the embedded generic
 + * data structure.
 + *
 + *
 + * Life Cycle
 + * ==========
 + *
 + * Four stylized functions accompany each of these data structures:
 + *
 + *            "alloc"       "construct"       "destruct"       "dealloc"
 + *            ------------  ----------------  ---------------  --------------
 + *   ofproto  ->alloc       ->construct       ->destruct       ->dealloc
 + *   ofport   ->port_alloc  ->port_construct  ->port_destruct  ->port_dealloc
 + *   rule     ->rule_alloc  ->rule_construct  ->rule_destruct  ->rule_dealloc
 + *
 + * Any instance of a given data structure goes through the following life
 + * cycle:
 + *
 + *   1. The client calls the "alloc" function to obtain raw memory.  If "alloc"
 + *      fails, skip all the other steps.
 + *
 + *   2. The client initializes all of the data structure's base state.  If this
 + *      fails, skip to step 7.
 + *
 + *   3. The client calls the "construct" function.  The implementation
 + *      initializes derived state.  It may refer to the already-initialized
 + *      base state.  If "construct" fails, skip to step 6.
 + *
 + *   4. The data structure is now initialized and in use.
 + *
 + *   5. When the data structure is no longer needed, the client calls the
 + *      "destruct" function.  The implementation uninitializes derived state.
 + *      The base state has not been uninitialized yet, so the implementation
 + *      may still refer to it.
 + *
 + *   6. The client uninitializes all of the data structure's base state.
 + *
 + *   7. The client calls the "dealloc" to free the raw memory.  The
 + *      implementation must not refer to base or derived state in the data
 + *      structure, because it has already been uninitialized.
 + *
 + * Each "alloc" function allocates and returns a new instance of the respective
 + * data structure.  The "alloc" function is not given any information about the
 + * use of the new data structure, so it cannot perform much initialization.
 + * Its purpose is just to ensure that the new data structure has enough room
 + * for base and derived state.  It may return a null pointer if memory is not
 + * available, in which case none of the other functions is called.
 + *
 + * Each "construct" function initializes derived state in its respective data
 + * structure.  When "construct" is called, all of the base state has already
 + * been initialized, so the "construct" function may refer to it.  The
 + * "construct" function is allowed to fail, in which case the client calls the
 + * "dealloc" function (but not the "destruct" function).
 + *
 + * Each "destruct" function uninitializes and frees derived state in its
 + * respective data structure.  When "destruct" is called, the base state has
 + * not yet been uninitialized, so the "destruct" function may refer to it.  The
 + * "destruct" function is not allowed to fail.
 + *
 + * Each "dealloc" function frees raw memory that was allocated by the the
 + * "alloc" function.  The memory's base and derived members might not have ever
 + * been initialized (but if "construct" returned successfully, then it has been
 + * "destruct"ed already).  The "dealloc" function is not allowed to fail.
 + *
 + *
 + * Conventions
 + * ===========
 + *
 + * Most of these functions return 0 if they are successful or a positive error
 + * code on failure.  Depending on the function, valid error codes are either
 + * errno values or OpenFlow error codes constructed with ofp_mkerr().
 + *
 + * Most of these functions are expected to execute synchronously, that is, to
 + * block as necessary to obtain a result.  Thus, these functions may return
 + * EAGAIN (or EWOULDBLOCK or EINPROGRESS) only where the function descriptions
 + * explicitly say those errors are a possibility.  We may relax this
 + * requirement in the future if and when we encounter performance problems. */
 +struct ofproto_class {
 +/* ## ----------------- ## */
 +/* ## Factory Functions ## */
 +/* ## ----------------- ## */
 +
 +    /* Enumerates the types of all support ofproto types into 'types'.  The
 +     * caller has already initialized 'types' and other ofproto classes might
 +     * already have added names to it. */
 +    void (*enumerate_types)(struct sset *types);
 +
 +    /* Enumerates the names of all existing datapath of the specified 'type'
 +     * into 'names' 'all_dps'.  The caller has already initialized 'names' as
 +     * an empty sset.
 +     *
 +     * 'type' is one of the types enumerated by ->enumerate_types().
 +     *
 +     * Returns 0 if successful, otherwise a positive errno value.
 +     */
 +    int (*enumerate_names)(const char *type, struct sset *names);
 +
 +    /* Deletes the datapath with the specified 'type' and 'name'.  The caller
 +     * should have closed any open ofproto with this 'type' and 'name'; this
 +     * function is allowed to fail if that is not the case.
 +     *
 +     * 'type' is one of the types enumerated by ->enumerate_types().
 +     * 'name' is one of the names enumerated by ->enumerate_names() for 'type'.
 +     *
 +     * Returns 0 if successful, otherwise a positive errno value.
 +     */
 +    int (*del)(const char *type, const char *name);
 +
 +/* ## --------------------------- ## */
 +/* ## Top-Level ofproto Functions ## */
 +/* ## --------------------------- ## */
 +
 +    /* Life-cycle functions for an "ofproto" (see "Life Cycle" above).
 +     *
 +     * ->construct() should not modify most base members of the ofproto.  In
 +     * particular, the client will initialize the ofproto's 'ports' member
 +     * after construction is complete.
 +     *
 +     * ->construct() should initialize the base 'n_tables' member to the number
 +     * of flow tables supported by the datapath (between 1 and 254, inclusive),
 +     * initialize the base 'tables' member with space for one classifier per
 +     * table, and initialize each classifier with classifier_init.  Each flow
 +     * table should be initially empty, so ->construct() should delete flows
 +     * from the underlying datapath, if necessary, rather than populating the
 +     * tables.
 +     *
 +     * Only one ofproto instance needs to be supported for any given datapath.
 +     * If a datapath is already open as part of one "ofproto", then another
 +     * attempt to "construct" the same datapath as part of another ofproto is
 +     * allowed to fail with an error.
 +     *
 +     * ->construct() returns 0 if successful, otherwise a positive errno
 +     * value. */
 +    struct ofproto *(*alloc)(void);
 +    int (*construct)(struct ofproto *ofproto);
 +    void (*destruct)(struct ofproto *ofproto);
 +    void (*dealloc)(struct ofproto *ofproto);
 +
 +    /* Performs any periodic activity required by 'ofproto'.  It should:
 +     *
 +     *   - Call connmgr_send_packet_in() for each received packet that missed
 +     *     in the OpenFlow flow table or that had a OFPP_CONTROLLER output
 +     *     action.
 +     *
 +     *   - Call ofproto_rule_expire() for each OpenFlow flow that has reached
 +     *     its hard_timeout or idle_timeout, to expire the flow.
 +     *
 +     * Returns 0 if successful, otherwise a positive errno value.  The ENODEV
 +     * return value specifically means that the datapath underlying 'ofproto'
 +     * has been destroyed (externally, e.g. by an admin running ovs-dpctl).
 +     */
 +    int (*run)(struct ofproto *ofproto);
 +
 +    /* Causes the poll loop to wake up when 'ofproto''s 'run' function needs to
 +     * be called, e.g. by calling the timer or fd waiting functions in
 +     * poll-loop.h.  */
 +    void (*wait)(struct ofproto *ofproto);
 +
 +    /* Every "struct rule" in 'ofproto' is about to be deleted, one by one.
 +     * This function may prepare for that, for example by clearing state in
 +     * advance.  It should *not* actually delete any "struct rule"s from
 +     * 'ofproto', only prepare for it.
 +     *
 +     * This function is optional; it's really just for optimization in case
 +     * it's cheaper to delete all the flows from your hardware in a single pass
 +     * than to do it one by one. */
 +    void (*flush)(struct ofproto *ofproto);
 +
 +    /* Helper for the OpenFlow OFPT_FEATURES_REQUEST request.
 +     *
 +     * The implementation should store true in '*arp_match_ip' if the switch
 +     * supports matching IP addresses inside ARP requests and replies, false
 +     * otherwise.
 +     *
 +     * The implementation should store in '*actions' a bitmap of the supported
 +     * OpenFlow actions: the bit with value (1 << n) should be set to 1 if the
 +     * implementation supports the action with value 'n', and to 0 otherwise.
 +     * For example, if the implementation supports the OFPAT_OUTPUT and
 +     * OFPAT_ENQUEUE actions, but no others, it would set '*actions' to (1 <<
 +     * OFPAT_OUTPUT) | (1 << OFPAT_ENQUEUE).  Vendor actions are not included
 +     * in '*actions'. */
 +    void (*get_features)(struct ofproto *ofproto,
 +                         bool *arp_match_ip, uint32_t *actions);
 +
 +    /* Helper for the OpenFlow OFPST_TABLE statistics request.
 +     *
 +     * The 'ots' array contains 'ofproto->n_tables' elements.  Each element is
 +     * initialized as:
 +     *
 +     *   - 'table_id' to the array index.
 +     *
 +     *   - 'name' to "table#" where # is the table ID.
 +     *
++     *   - 'wildcards' to OFPFW_ALL.
 +     *
 +     *   - 'max_entries' to 1,000,000.
 +     *
 +     *   - 'active_count' to the classifier_count() for the table.
 +     *
 +     *   - 'lookup_count' and 'matched_count' to 0.
 +     *
 +     * The implementation should update any members in each element for which
 +     * it has better values:
 +     *
 +     *   - 'name' to a more meaningful name.
 +     *
 +     *   - 'wildcards' to the set of wildcards actually supported by the table
 +     *     (if it doesn't support all OpenFlow wildcards).
 +     *
 +     *   - 'max_entries' to the maximum number of flows actually supported by
 +     *     the hardware.
 +     *
 +     *   - 'lookup_count' to the number of packets looked up in this flow table
 +     *     so far.
 +     *
 +     *   - 'matched_count' to the number of packets looked up in this flow
 +     *     table so far that matched one of the flow entries.
 +     *
 +     * Keep in mind that all of the members of struct ofp_table_stats are in
 +     * network byte order.
 +     */
 +    void (*get_tables)(struct ofproto *ofproto, struct ofp_table_stats *ots);
 +
 +/* ## ---------------- ## */
 +/* ## ofport Functions ## */
 +/* ## ---------------- ## */
 +
 +    /* Life-cycle functions for a "struct ofport" (see "Life Cycle" above).
 +     *
 +     * ->port_construct() should not modify any base members of the ofport.
 +     *
 +     * ofports are managed by the base ofproto code.  The ofproto
 +     * implementation should only create and destroy them in response to calls
 +     * to these functions.  The base ofproto code will create and destroy
 +     * ofports in the following situations:
 +     *
 +     *   - Just after the ->construct() function is called, the base ofproto
 +     *     iterates over all of the implementation's ports, using
 +     *     ->port_dump_start() and related functions, and constructs an ofport
 +     *     for each dumped port.
 +     *
 +     *   - If ->port_poll() reports that a specific port has changed, then the
 +     *     base ofproto will query that port with ->port_query_by_name() and
 +     *     construct or destruct ofports as necessary to reflect the updated
 +     *     set of ports.
 +     *
 +     *   - If ->port_poll() returns ENOBUFS to report an unspecified port set
 +     *     change, then the base ofproto will iterate over all of the
 +     *     implementation's ports, in the same way as at ofproto
 +     *     initialization, and construct and destruct ofports to reflect all of
 +     *     the changes.
 +     *
 +     * ->port_construct() returns 0 if successful, otherwise a positive errno
 +     * value.
 +     */
 +    struct ofport *(*port_alloc)(void);
 +    int (*port_construct)(struct ofport *ofport);
 +    void (*port_destruct)(struct ofport *ofport);
 +    void (*port_dealloc)(struct ofport *ofport);
 +
 +    /* Called after 'ofport->netdev' is replaced by a new netdev object.  If
 +     * the ofproto implementation uses the ofport's netdev internally, then it
 +     * should switch to using the new one.  The old one has been closed.
 +     *
 +     * An ofproto implementation that doesn't need to do anything in this
 +     * function may use a null pointer. */
 +    void (*port_modified)(struct ofport *ofport);
 +
 +    /* Called after an OpenFlow OFPT_PORT_MOD request changes a port's
 +     * configuration.  'ofport->opp.config' contains the new configuration.
 +     * 'old_config' contains the previous configuration.
 +     *
 +     * The caller implements OFPPC_PORT_DOWN using netdev functions to turn
 +     * NETDEV_UP on and off, so this function doesn't have to do anything for
 +     * that bit (and it won't be called if that is the only bit that
 +     * changes). */
 +    void (*port_reconfigured)(struct ofport *ofport, ovs_be32 old_config);
 +
 +    /* Looks up a port named 'devname' in 'ofproto'.  On success, initializes
 +     * '*port' appropriately.
 +     *
 +     * The caller owns the data in 'port' and must free it with
 +     * ofproto_port_destroy() when it is no longer needed. */
 +    int (*port_query_by_name)(const struct ofproto *ofproto,
 +                              const char *devname, struct ofproto_port *port);
 +
 +    /* Attempts to add 'netdev' as a port on 'ofproto'.  Returns 0 if
 +     * successful, otherwise a positive errno value.  If successful, sets
 +     * '*ofp_portp' to the new port's port number.
 +     *
 +     * It doesn't matter whether the new port will be returned by a later call
 +     * to ->port_poll(); the implementation may do whatever is more
 +     * convenient. */
 +    int (*port_add)(struct ofproto *ofproto, struct netdev *netdev,
 +                    uint16_t *ofp_portp);
 +
 +    /* Deletes port number 'ofp_port' from the datapath for 'ofproto'.  Returns
 +     * 0 if successful, otherwise a positive errno value.
 +     *
 +     * It doesn't matter whether the new port will be returned by a later call
 +     * to ->port_poll(); the implementation may do whatever is more
 +     * convenient. */
 +    int (*port_del)(struct ofproto *ofproto, uint16_t ofp_port);
 +
 +    /* Attempts to begin dumping the ports in 'ofproto'.  On success, returns 0
 +     * and initializes '*statep' with any data needed for iteration.  On
 +     * failure, returns a positive errno value. */
 +    int (*port_dump_start)(const struct ofproto *ofproto, void **statep);
 +
 +    /* Attempts to retrieve another port from 'ofproto' for 'state', which was
 +     * initialized by a successful call to the 'port_dump_start' function for
 +     * 'ofproto'.  On success, stores a new ofproto_port into 'port' and
 +     * returns 0.  Returns EOF if the end of the port table has been reached,
 +     * or a positive errno value on error.  This function will not be called
 +     * again once it returns nonzero once for a given iteration (but the
 +     * 'port_dump_done' function will be called afterward).
 +     *
 +     * The ofproto provider retains ownership of the data stored in 'port'.  It
 +     * must remain valid until at least the next call to 'port_dump_next' or
 +     * 'port_dump_done' for 'state'. */
 +    int (*port_dump_next)(const struct ofproto *ofproto, void *state,
 +                          struct ofproto_port *port);
 +
 +    /* Releases resources from 'ofproto' for 'state', which was initialized by
 +     * a successful call to the 'port_dump_start' function for 'ofproto'.  */
 +    int (*port_dump_done)(const struct ofproto *ofproto, void *state);
 +
 +    /* Polls for changes in the set of ports in 'ofproto'.  If the set of ports
 +     * in 'ofproto' has changed, then this function should do one of the
 +     * following:
 +     *
 +     * - Preferably: store the name of the device that was added to or deleted
 +     *   from 'ofproto' in '*devnamep' and return 0.  The caller is responsible
 +     *   for freeing '*devnamep' (with free()) when it no longer needs it.
 +     *
 +     * - Alternatively: return ENOBUFS, without indicating the device that was
 +     *   added or deleted.
 +     *
 +     * Occasional 'false positives', in which the function returns 0 while
 +     * indicating a device that was not actually added or deleted or returns
 +     * ENOBUFS without any change, are acceptable.
 +     *
 +     * The purpose of 'port_poll' is to let 'ofproto' know about changes made
 +     * externally to the 'ofproto' object, e.g. by a system administrator via
 +     * ovs-dpctl.  Therefore, it's OK, and even preferable, for port_poll() to
 +     * not report changes made through calls to 'port_add' or 'port_del' on the
 +     * same 'ofproto' object.  (But it's OK for it to report them too, just
 +     * slightly less efficient.)
 +     *
 +     * If the set of ports in 'ofproto' has not changed, returns EAGAIN.  May
 +     * also return other positive errno values to indicate that something has
 +     * gone wrong.
 +     *
 +     * If the set of ports in a datapath is fixed, or if the only way that the
 +     * set of ports in a datapath can change is through ->port_add() and
 +     * ->port_del(), then this function may be a null pointer.
 +     */
 +    int (*port_poll)(const struct ofproto *ofproto, char **devnamep);
 +
 +    /* Arranges for the poll loop to wake up when ->port_poll() will return a
 +     * value other than EAGAIN.
 +     *
 +     * If the set of ports in a datapath is fixed, or if the only way that the
 +     * set of ports in a datapath can change is through ->port_add() and
 +     * ->port_del(), or if the poll loop will always wake up anyway when
 +     * ->port_poll() will return a value other than EAGAIN, then this function
 +     * may be a null pointer.
 +     */
 +    void (*port_poll_wait)(const struct ofproto *ofproto);
 +
 +    /* Checks the status of LACP negotiation for 'port'.  Returns 1 if LACP
 +     * partner information for 'port' is up-to-date, 0 if LACP partner
 +     * information is not current (generally indicating a connectivity
 +     * problem), or -1 if LACP is not enabled on 'port'.
 +     *
 +     * This function may be a null pointer if the ofproto implementation does
 +     * not support LACP. */
 +    int (*port_is_lacp_current)(const struct ofport *port);
 +
 +/* ## ----------------------- ## */
 +/* ## OpenFlow Rule Functions ## */
 +/* ## ----------------------- ## */
 +
 +    /* Life-cycle functions for a "struct rule" (see "Life Cycle" above).
 +     *
 +     * ->rule_construct() should first check whether the rule is acceptable:
 +     *
 +     *   - Validate that the matching rule in 'rule->cr' is supported by the
 +     *     datapath.  If not, then return an OpenFlow error code (as returned
 +     *     by ofp_mkerr()).
 +     *
 +     *     For example, if the datapath does not support registers, then it
 +     *     should return an error if 'rule->cr' does not wildcard all
 +     *     registers.
 +     *
 +     *   - Validate that 'rule->actions' and 'rule->n_actions' are well-formed
 +     *     OpenFlow actions that can be correctly implemented by the datapath.
 +     *     If not, then return an OpenFlow error code (as returned by
 +     *     ofp_mkerr()).
 +     *
 +     *     The validate_actions() function (in ofp-util.c) can be useful as a
 +     *     model for action validation, but it accepts all of the OpenFlow
 +     *     actions that OVS understands.  If your ofproto implementation only
 +     *     implements a subset of those, then you should implement your own
 +     *     action validation.
 +     *
 +     * If the rule is acceptable, then ->rule_construct() should modify the
 +     * flow table:
 +     *
 +     *   - If there was already a rule with exactly the same matching criteria
 +     *     and priority in the classifier, then it should destroy it (with
 +     *     ofproto_rule_destroy()).
 +     *
 +     *     To the greatest extent possible, the old rule should be destroyed
 +     *     only if inserting the new rule succeeds; that is, ->rule_construct()
 +     *     should be transactional.
 +     *
 +     *     The function classifier_find_rule_exactly() can locate such a rule.
 +     *
 +     *   - Insert the new rule into the ofproto's 'cls' classifier, and into
 +     *     the datapath flow table.
 +     *
 +     *     The function classifier_insert() inserts a rule into the classifier.
 +     *
 +     * Other than inserting 'rule->cr' into the classifier, ->rule_construct()
 +     * should not modify any base members of struct rule.
 +     *
 +     * ->rule_destruct() should remove 'rule' from the ofproto's 'cls'
 +     * classifier (e.g. with classifier_remove()) and from the datapath flow
 +     * table. */
 +    struct rule *(*rule_alloc)(void);
 +    int (*rule_construct)(struct rule *rule);
 +    void (*rule_destruct)(struct rule *rule);
 +    void (*rule_dealloc)(struct rule *rule);
 +
 +    /* Obtains statistics for 'rule', storing the number of packets that have
 +     * matched it in '*packet_count' and the number of bytes in those packets
 +     * in '*byte_count'. */
 +    void (*rule_get_stats)(struct rule *rule, uint64_t *packet_count,
 +                           uint64_t *byte_count);
 +
 +    /* Applies the actions in 'rule' to 'packet'.  (This implements sending
 +     * buffered packets for OpenFlow OFPT_FLOW_MOD commands.)
 +     *
 +     * Takes ownership of 'packet' (so it should eventually free it, with
 +     * ofpbuf_delete()).
 +     *
 +     * 'flow' reflects the flow information for 'packet'.  All of the
 +     * information in 'flow' is extracted from 'packet', except for
 +     * flow->tun_id and flow->in_port, which are assigned the correct values
 +     * for the incoming packet.  The register values are zeroed.
 +     *
 +     * The statistics for 'packet' should be included in 'rule'.
 +     *
 +     * Returns 0 if successful, otherwise an OpenFlow error code (as returned
 +     * by ofp_mkerr()). */
 +    int (*rule_execute)(struct rule *rule, struct flow *flow,
 +                        struct ofpbuf *packet);
 +
 +    /* Validates that the 'n' elements in 'actions' are well-formed OpenFlow
 +     * actions that can be correctly implemented by the datapath.  If not, then
 +     * return an OpenFlow error code (as returned by ofp_mkerr()).  If so,
 +     * then update the datapath to implement the new actions and return 0.
 +     *
 +     * When this function runs, 'rule' still has its original actions.  If this
 +     * function returns 0, then the caller will update 'rule' with the new
 +     * actions and free the old ones. */
 +    int (*rule_modify_actions)(struct rule *rule,
 +                               const union ofp_action *actions, size_t n);
 +
 +    /* These functions implement the OpenFlow IP fragment handling policy.  By
 +     * default ('drop_frags' == false), an OpenFlow switch should treat IP
 +     * fragments the same way as other packets (although TCP and UDP port
 +     * numbers cannot be determined).  With 'drop_frags' == true, the switch
 +     * should drop all IP fragments without passing them through the flow
 +     * table. */
 +    bool (*get_drop_frags)(struct ofproto *ofproto);
 +    void (*set_drop_frags)(struct ofproto *ofproto, bool drop_frags);
 +
 +    /* Implements the OpenFlow OFPT_PACKET_OUT command.  The datapath should
 +     * execute the 'n_actions' in the 'actions' array on 'packet'.
 +     *
 +     * The caller retains ownership of 'packet', so ->packet_out() should not
 +     * modify or free it.
 +     *
 +     * This function must validate that the 'n_actions' elements in 'actions'
 +     * are well-formed OpenFlow actions that can be correctly implemented by
 +     * the datapath.  If not, then it should return an OpenFlow error code (as
 +     * returned by ofp_mkerr()).
 +     *
 +     * 'flow' reflects the flow information for 'packet'.  All of the
 +     * information in 'flow' is extracted from 'packet', except for
 +     * flow->in_port, which is taken from the OFPT_PACKET_OUT message.
 +     * flow->tun_id and its register values are zeroed.
 +     *
 +     * 'packet' is not matched against the OpenFlow flow table, so its
 +     * statistics should not be included in OpenFlow flow statistics.
 +     *
 +     * Returns 0 if successful, otherwise an OpenFlow error code (as returned
 +     * by ofp_mkerr()). */
 +    int (*packet_out)(struct ofproto *ofproto, struct ofpbuf *packet,
 +                      const struct flow *flow,
 +                      const union ofp_action *actions,
 +                      size_t n_actions);
 +
 +/* ## ------------------------- ## */
 +/* ## OFPP_NORMAL configuration ## */
 +/* ## ------------------------- ## */
 +
 +    /* Configures NetFlow on 'ofproto' according to the options in
 +     * 'netflow_options', or turns off NetFlow if 'netflow_options' is NULL.
 +     *
 +     * EOPNOTSUPP as a return value indicates that 'ofproto' does not support
 +     * sFlow, as does a null pointer. */
 +    int (*set_netflow)(struct ofproto *ofproto,
 +                       const struct netflow_options *netflow_options);
 +
 +    void (*get_netflow_ids)(const struct ofproto *ofproto,
 +                            uint8_t *engine_type, uint8_t *engine_id);
 +
 +    /* Configures sFlow on 'ofproto' according to the options in
 +     * 'sflow_options', or turns off sFlow if 'sflow_options' is NULL.
 +     *
 +     * EOPNOTSUPP as a return value indicates that 'ofproto' does not support
 +     * sFlow, as does a null pointer. */
 +    int (*set_sflow)(struct ofproto *ofproto,
 +                     const struct ofproto_sflow_options *sflow_options);
 +
 +    /* Configures connectivity fault management on 'ofport'.
 +     *
 +     * If 'cfm' is nonnull, takes basic configuration from the configuration
 +     * members in 'cfm', and the set of remote maintenance points from the
 +     * 'n_remote_mps' elements in 'remote_mps'.  Ignores the statistics members
 +     * of 'cfm'.
 +     *
 +     * If 'cfm' is null, removes any connectivity fault management
 +     * configuration from 'ofport'.
 +     *
 +     * EOPNOTSUPP as a return value indicates that this ofproto_class does not
 +     * support CFM, as does a null pointer. */
 +    int (*set_cfm)(struct ofport *ofport, const struct cfm *cfm,
 +                   const uint16_t *remote_mps, size_t n_remote_mps);
 +
 +    /* Stores the connectivity fault management object associated with 'ofport'
 +     * in '*cfmp'.  Stores a null pointer in '*cfmp' if CFM is not configured
 +     * on 'ofport'.  The caller must not modify or destroy the returned object.
 +     *
 +     * This function may be NULL if this ofproto_class does not support CFM. */
 +    int (*get_cfm)(struct ofport *ofport, const struct cfm **cfmp);
 +
 +    /* If 's' is nonnull, this function registers a "bundle" associated with
 +     * client data pointer 'aux' in 'ofproto'.  A bundle is the same concept as
 +     * a Port in OVSDB, that is, it consists of one or more "slave" devices
 +     * (Interfaces, in OVSDB) along with VLAN and LACP configuration and, if
 +     * there is more than one slave, a bonding configuration.  If 'aux' is
 +     * already registered then this function updates its configuration to 's'.
 +     * Otherwise, this function registers a new bundle.
 +     *
 +     * If 's' is NULL, this function unregisters the bundle registered on
 +     * 'ofproto' associated with client data pointer 'aux'.  If no such bundle
 +     * has been registered, this has no effect.
 +     *
 +     * This function affects only the behavior of the NXAST_AUTOPATH action and
 +     * output to the OFPP_NORMAL port.  An implementation that does not support
 +     * it at all may set it to NULL or return EOPNOTSUPP.  An implementation
 +     * that supports only a subset of the functionality should implement what
 +     * it can and return 0. */
 +    int (*bundle_set)(struct ofproto *ofproto, void *aux,
 +                      const struct ofproto_bundle_settings *s);
 +
 +    /* If 'port' is part of any bundle, removes it from that bundle.  If the
 +     * bundle now has no ports, deletes the bundle.  If the bundle now has only
 +     * one port, deconfigures the bundle's bonding configuration. */
 +    void (*bundle_remove)(struct ofport *ofport);
 +
 +    /* If 's' is nonnull, this function registers a mirror associated with
 +     * client data pointer 'aux' in 'ofproto'.  A mirror is the same concept as
 +     * a Mirror in OVSDB.  If 'aux' is already registered then this function
 +     * updates its configuration to 's'.  Otherwise, this function registers a
 +     * new mirror.
 +     *
 +     * If 's' is NULL, this function unregisters the mirror registered on
 +     * 'ofproto' associated with client data pointer 'aux'.  If no such mirror
 +     * has been registered, this has no effect.
 +     *
 +     * This function affects only the behavior of the OFPP_NORMAL action.  An
 +     * implementation that does not support it at all may set it to NULL or
 +     * return EOPNOTSUPP.  An implementation that supports only a subset of the
 +     * functionality should implement what it can and return 0. */
 +    int (*mirror_set)(struct ofproto *ofproto, void *aux,
 +                      const struct ofproto_mirror_settings *s);
 +
 +    /* Configures the VLANs whose bits are set to 1 in 'flood_vlans' as VLANs
 +     * on which all packets are flooded, instead of using MAC learning.  If
 +     * 'flood_vlans' is NULL, then MAC learning applies to all VLANs.
 +     *
 +     * This function affects only the behavior of the OFPP_NORMAL action.  An
 +     * implementation that does not support it may set it to NULL or return
 +     * EOPNOTSUPP. */
 +    int (*set_flood_vlans)(struct ofproto *ofproto,
 +                           unsigned long *flood_vlans);
 +
 +    /* Returns true if 'aux' is a registered bundle that is currently in use as
 +     * the output for a mirror. */
 +    bool (*is_mirror_output_bundle)(struct ofproto *ofproto, void *aux);
 +};
 +
 +extern const struct ofproto_class ofproto_dpif_class;
 +
 +int ofproto_class_register(const struct ofproto_class *);
 +int ofproto_class_unregister(const struct ofproto_class *);
 +
 +void ofproto_add_flow(struct ofproto *, const struct cls_rule *,
 +                      const union ofp_action *, size_t n_actions);
 +void ofproto_delete_flow(struct ofproto *, const struct cls_rule *);
 +void ofproto_flush_flows(struct ofproto *);
 +
 +#endif /* ofproto/private.h */
index 6f785e97d517aa97b2a4f8502295d9af7540ac96,10080e6713c282ebd286b4660634bd68473a2498..713cc769589ba34a72a949a16c5bca8a0a468828
@@@ -48,13 -48,9 +48,10 @@@ AT_CHECK([ovs-ofctl dump-flows br0 | ST
  ])
  AT_CHECK([echo 'in_port=1,actions=0' | ovs-ofctl add-flows br0 -])
  AT_CHECK([ovs-ofctl add-flow br0 in_port=0,actions=1])
- dnl Tests for a bug in which ofproto ignored tun_id in tun_id_from_cookie
- dnl flow_mod commands.
- AT_CHECK([ovs-ofctl add-flow -F tun_id_from_cookie br0 tun_id=1,actions=mod_vlan_vid:4])
  AT_CHECK([ovs-ofctl dump-flows br0 | STRIP_XIDS | STRIP_DURATION | sort], [0], [dnl
 + cookie=0x0, duration=?s, table_id=0, n_packets=0, n_bytes=0, in_port=0 actions=output:1
   cookie=0x0, duration=?s, table_id=0, n_packets=0, n_bytes=0, in_port=1 actions=output:0
-  cookie=0x100000000, duration=?s, table_id=0, n_packets=0, n_bytes=0, tun_id=0x1 actions=mod_vlan_vid:4
+  cookie=0x0, duration=?s, table_id=0, n_packets=0, n_bytes=0, in_port=65534 actions=output:1
  NXST_FLOW reply:
  ])
  AT_CHECK([ovs-ofctl del-flows br0])
index a9c3c20531b4121d5d84b11d99231dcf3933fe06,1014710821c7c3c69695cb5a4d36e7d15b518d42..a8cdbe9a9864fc293081586e1e3c4814d0720155
@@@ -42,17 -40,11 +40,11 @@@ normalization changed ofp_match, detail
   pre: wildcards=  0x3820f8  in_port=65534  dl_src=00:0a:e4:25:6b:b0  dl_dst=00:00:00:00:00:00  dl_vlan=    9  dl_vlan_pcp=  0  dl_type=     0  nw_tos=   0  nw_proto=   0  nw_src=         0  nw_dst=         0  tp_src=    0  tp_dst=    0
  post: wildcards=  0x3ffff8  in_port=65534  dl_src=00:0a:e4:25:6b:b0  dl_dst=00:00:00:00:00:00  dl_vlan=    9  dl_vlan_pcp=  0  dl_type=     0  nw_tos=   0  nw_proto=   0  nw_src=         0  nw_dst=         0  tp_src=    0  tp_dst=    0
  normalization changed ofp_match, details:
 - pre: wildcards=  0x3820ff  in_port=65534  dl_src=00:00:00:00:00:00  dl_dst=00:00:00:00:00:00  dl_vlan=    0  dl_vlan_pcp=  0  dl_type=     0  nw_tos=   0  nw_proto=   0  nw_src=         0  nw_dst=         0  tp_src=    0  tp_dst=    0
 -post: wildcards=  0x3fffff  in_port=65534  dl_src=00:00:00:00:00:00  dl_dst=00:00:00:00:00:00  dl_vlan=    0  dl_vlan_pcp=  0  dl_type=     0  nw_tos=   0  nw_proto=   0  nw_src=         0  nw_dst=         0  tp_src=    0  tp_dst=    0
 + pre: wildcards=  0x3820ff  in_port=    0  dl_src=00:00:00:00:00:00  dl_dst=00:00:00:00:00:00  dl_vlan=    0  dl_vlan_pcp=  0  dl_type=     0  nw_tos=   0  nw_proto=   0  nw_src=         0  nw_dst=         0  tp_src=    0  tp_dst=    0
 +post: wildcards=  0x3fffff  in_port=    0  dl_src=00:00:00:00:00:00  dl_dst=00:00:00:00:00:00  dl_vlan=    0  dl_vlan_pcp=  0  dl_type=     0  nw_tos=   0  nw_proto=   0  nw_src=         0  nw_dst=         0  tp_src=    0  tp_dst=    0
  normalization changed ofp_match, details:
-  pre: wildcards=  0x3820ff  in_port=    0  dl_src=00:00:00:00:00:00  dl_dst=00:00:00:00:00:00  dl_vlan=    0  dl_vlan_pcp=  0  dl_type=     0  nw_tos=   0  nw_proto=   0  nw_src=         0  nw_dst=         0  tp_src=    0  tp_dst=    0
- post: wildcards=  0x3fffff  in_port=    0  dl_src=00:00:00:00:00:00  dl_dst=00:00:00:00:00:00  dl_vlan=    0  dl_vlan_pcp=  0  dl_type=     0  nw_tos=   0  nw_proto=   0  nw_src=         0  nw_dst=         0  tp_src=    0  tp_dst=    0
- normalization changed ofp_match, details:
-  pre: wildcards=  0x3820ff  in_port=    0  dl_src=00:00:00:00:00:00  dl_dst=00:00:00:00:00:00  dl_vlan=    0  dl_vlan_pcp=  0  dl_type=     0  nw_tos=   0  nw_proto=   0  nw_src=         0  nw_dst=         0  tp_src=    0  tp_dst=    0
- post: wildcards=  0x3fffff  in_port=    0  dl_src=00:00:00:00:00:00  dl_dst=00:00:00:00:00:00  dl_vlan=    0  dl_vlan_pcp=  0  dl_type=     0  nw_tos=   0  nw_proto=   0  nw_src=         0  nw_dst=         0  tp_src=    0  tp_dst=    0
- normalization changed ofp_match, details:
-  pre: wildcards= 0x23820ff  in_port=    0  dl_src=00:00:00:00:00:00  dl_dst=00:00:00:00:00:00  dl_vlan=    0  dl_vlan_pcp=  0  dl_type=     0  nw_tos=   0  nw_proto=   0  nw_src=         0  nw_dst=         0  tp_src=    0  tp_dst=    0
- post: wildcards= 0x23fffff  in_port=    0  dl_src=00:00:00:00:00:00  dl_dst=00:00:00:00:00:00  dl_vlan=    0  dl_vlan_pcp=  0  dl_type=     0  nw_tos=   0  nw_proto=   0  nw_src=         0  nw_dst=         0  tp_src=    0  tp_dst=    0
+  pre: wildcards=  0x3820ff  in_port=65534  dl_src=00:00:00:00:00:00  dl_dst=00:00:00:00:00:00  dl_vlan=    0  dl_vlan_pcp=  0  dl_type=     0  nw_tos=   0  nw_proto=   0  nw_src=         0  nw_dst=         0  tp_src=    0  tp_dst=    0
+ post: wildcards=  0x3fffff  in_port=65534  dl_src=00:00:00:00:00:00  dl_dst=00:00:00:00:00:00  dl_vlan=    0  dl_vlan_pcp=  0  dl_type=     0  nw_tos=   0  nw_proto=   0  nw_src=         0  nw_dst=         0  tp_src=    0  tp_dst=    0
  ])
  AT_CLEANUP
  
Simple merge
Simple merge
Simple merge
Simple merge
index 761d02ba36bdaaecfc144786d2a2f5c77c730bb1,55c9f40af32c981db9f3cfea2eb0254b0a5aa9f4..127e0b7cfd525128923a715b279eeb733ad1c418
@@@ -2019,9 -2908,9 +2019,12 @@@ port_del_ifaces(struct port *port
  
      /* Collect list of new interfaces. */
      sset_init(&new_ifaces);
 -    for (i = 0; i < cfg->n_interfaces; i++) {
 -        const char *name = cfg->interfaces[i]->name;
 -        sset_add(&new_ifaces, name);
 +    for (i = 0; i < port->cfg->n_interfaces; i++) {
 +        const char *name = port->cfg->interfaces[i]->name;
-         sset_add(&new_ifaces, name);
++        const char *type = port->cfg->interfaces[i]->name;
++        if (strcmp(type, "null")) {
++            sset_add(&new_ifaces, name);
++        }
      }
  
      /* Get rid of deleted interfaces. */
      sset_destroy(&new_ifaces);
  }
  
 -/* Expires all MAC learning entries associated with 'port' and forces ofproto
 - * to revalidate every flow. */
 +/* Adds new interfaces to 'port' and updates 'type' and 'cfg' members of
 + * existing ones. */
  static void
 -port_flush_macs(struct port *port)
 +port_add_ifaces(struct port *port)
  {
 -    struct bridge *br = port->bridge;
 -    struct mac_learning *ml = br->ml;
 -    struct mac_entry *mac, *next_mac;
 +    struct shash new_ifaces;
 +    struct shash_node *node;
 +    size_t i;
  
 -    bridge_flush(br);
 -    LIST_FOR_EACH_SAFE (mac, next_mac, lru_node, &ml->lrus) {
 -        if (mac->port.p == port) {
 -            mac_learning_expire(ml, mac);
 +    /* Collect new ifaces. */
 +    shash_init(&new_ifaces);
 +    for (i = 0; i < port->cfg->n_interfaces; i++) {
 +        const struct ovsrec_interface *cfg = port->cfg->interfaces[i];
-         if (!shash_add_once(&new_ifaces, cfg->name, cfg)) {
++        if (strcmp(cfg->type, "null")
++            && !shash_add_once(&new_ifaces, cfg->name, cfg)) {
 +            VLOG_WARN("port %s: %s specified twice as port interface",
 +                      port->name, cfg->name);
 +            iface_set_ofport(cfg, -1);
          }
      }
 -}
 -
 -static void
 -port_reconfigure(struct port *port, const struct ovsrec_port *cfg)
 -{
 -    struct sset new_ifaces;
 -    bool need_flush = false;
 -    unsigned long *trunks;
 -    int vlan;
 -    size_t i;
 -
 -    port->cfg = cfg;
  
 -    /* Add new interfaces and update 'cfg' member of existing ones. */
 -    sset_init(&new_ifaces);
 -    for (i = 0; i < cfg->n_interfaces; i++) {
 -        const struct ovsrec_interface *if_cfg = cfg->interfaces[i];
 +    /* Create new interfaces.
 +     * Update interface types and 'cfg' members. */
 +    SHASH_FOR_EACH (node, &new_ifaces) {
 +        const struct ovsrec_interface *cfg = node->data;
 +        const char *iface_name = node->name;
          struct iface *iface;
 -        const char *type;
  
 -        if (!sset_add(&new_ifaces, if_cfg->name)) {
 -            VLOG_WARN("port %s: %s specified twice as port interface",
 -                      port->name, if_cfg->name);
 -            iface_set_ofport(if_cfg, -1);
 -            continue;
 +        iface = iface_lookup(port->bridge, iface_name);
 +        if (!iface) {
 +            iface = iface_create(port, cfg);
 +        } else {
 +            iface->cfg = cfg;
          }
  
          /* Determine interface type.  The local port always has type
@@@ -2155,89 -3192,140 +2159,98 @@@ port_configure_lacp(struct port *port, 
      /* Prefer bondable links if unspecified. */
      priority = atoi(get_port_other_config(port->cfg, "lacp-system-priority",
                                            "0"));
 -    s.priority = (priority > 0 && priority <= UINT16_MAX
 -                  ? priority
 -                  : UINT16_MAX - !list_is_short(&port->ifaces));
 +    s->priority = (priority > 0 && priority <= UINT16_MAX
 +                   ? priority
 +                   : UINT16_MAX - !list_is_short(&port->ifaces));
 +
-     s->strict = !strcmp(get_port_other_config(port->cfg, "lacp-strict",
-                                               "false"),
-                         "true");
++    s->heartbeat = !strcmp(get_port_other_config(port->cfg,
++                                                 "lacp-heartbeat",
++                                                 "false"), "true");
 -    s.heartbeat = !strcmp(get_port_other_config(port->cfg,
 -                                                "lacp-heartbeat",
 -                                                "false"), "true");
  
      lacp_time = get_port_other_config(port->cfg, "lacp-time", "slow");
      custom_time = atoi(lacp_time);
      if (!strcmp(lacp_time, "fast")) {
 -        s.lacp_time = LACP_TIME_FAST;
 +        s->lacp_time = LACP_TIME_FAST;
      } else if (!strcmp(lacp_time, "slow")) {
 -        s.lacp_time = LACP_TIME_SLOW;
 +        s->lacp_time = LACP_TIME_SLOW;
      } else if (custom_time > 0) {
 -        s.lacp_time = LACP_TIME_CUSTOM;
 -        s.custom_time = custom_time;
 +        s->lacp_time = LACP_TIME_CUSTOM;
 +        s->custom_time = custom_time;
      } else {
 -        s.lacp_time = LACP_TIME_SLOW;
 +        s->lacp_time = LACP_TIME_SLOW;
      }
  
 -    if (!port->lacp) {
 -        port->lacp = lacp_create();
 +    return s;
 +}
 +
 +static void
 +iface_configure_lacp(struct iface *iface, struct lacp_slave_settings *s)
 +{
-     int priority, portid;
++    int priority, portid, key;
 +
 +    portid = atoi(get_interface_other_config(iface->cfg, "lacp-port-id", "0"));
 +    priority = atoi(get_interface_other_config(iface->cfg,
 +                                               "lacp-port-priority", "0"));
++    key = atoi(get_interface_other_config(iface->cfg, "lacp-aggregation-key",
++                                          "0"));
 +
 +    if (portid <= 0 || portid > UINT16_MAX) {
 +        portid = iface->ofp_port;
      }
  
 -    lacp_configure(port->lacp, &s);
 +    if (priority <= 0 || priority > UINT16_MAX) {
 +        priority = UINT16_MAX;
 +    }
  
 -    LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
 -        iface_reconfigure_lacp(iface);
++    if (key < 0 || key > UINT16_MAX) {
++        key = 0;
+     }
++
 +    s->name = iface->name;
 +    s->id = portid;
 +    s->priority = priority;
++    s->key = key;
  }
  
  static void
 -port_reconfigure_bond(struct port *port)
 +port_configure_bond(struct port *port, struct bond_settings *s)
  {
 -    struct bond_settings s;
      const char *detect_s;
 -    struct iface *iface;
  
 -    if (list_is_short(&port->ifaces)) {
 -        /* Not a bonded port. */
 -        bond_destroy(port->bond);
 -        port->bond = NULL;
 -        return;
 -    }
 -
 -    port->bridge->has_bonded_ports = true;
 -
 -    s.name = port->name;
 -    s.balance = BM_SLB;
 +    s->name = port->name;
 +    s->balance = BM_SLB;
      if (port->cfg->bond_mode
 -        && !bond_mode_from_string(&s.balance, port->cfg->bond_mode)) {
 +        && !bond_mode_from_string(&s->balance, port->cfg->bond_mode)) {
          VLOG_WARN("port %s: unknown bond_mode %s, defaulting to %s",
                    port->name, port->cfg->bond_mode,
 -                  bond_mode_to_string(s.balance));
 +                  bond_mode_to_string(s->balance));
      }
  
 -    s.detect = BLSM_CARRIER;
 +    s->detect = BLSM_CARRIER;
      detect_s = get_port_other_config(port->cfg, "bond-detect-mode", NULL);
 -    if (detect_s && !bond_detect_mode_from_string(&s.detect, detect_s)) {
 +    if (detect_s && !bond_detect_mode_from_string(&s->detect, detect_s)) {
          VLOG_WARN("port %s: unsupported bond-detect-mode %s, "
                    "defaulting to %s",
 -                  port->name, detect_s, bond_detect_mode_to_string(s.detect));
 +                  port->name, detect_s, bond_detect_mode_to_string(s->detect));
      }
  
 -    s.miimon_interval = atoi(
 +    s->miimon_interval = atoi(
          get_port_other_config(port->cfg, "bond-miimon-interval", "200"));
 -    if (s.miimon_interval < 100) {
 -        s.miimon_interval = 100;
 +    if (s->miimon_interval < 100) {
 +        s->miimon_interval = 100;
      }
  
 -    s.up_delay = MAX(0, port->cfg->bond_updelay);
 -    s.down_delay = MAX(0, port->cfg->bond_downdelay);
 -    s.basis = atoi(get_port_other_config(port->cfg, "bond-hash-basis", "0"));
 -
 -    s.rebalance_interval = atoi(
 +    s->up_delay = MAX(0, port->cfg->bond_updelay);
 +    s->down_delay = MAX(0, port->cfg->bond_downdelay);
++    s->basis = atoi(get_port_other_config(port->cfg, "bond-hash-basis", "0"));
 +    s->rebalance_interval = atoi(
          get_port_other_config(port->cfg, "bond-rebalance-interval", "10000"));
 -    if (s.rebalance_interval < 1000) {
 -        s.rebalance_interval = 1000;
 -    }
 -
 -    s.fake_iface = port->cfg->bond_fake_iface;
 -
 -    if (!port->bond) {
 -        port->bond = bond_create(&s);
 -    } else {
 -        if (bond_reconfigure(port->bond, &s)) {
 -            bridge_flush(port->bridge);
 -        }
 -    }
 -
 -    LIST_FOR_EACH (iface, port_elem, &port->ifaces) {
 -        long long stable_id;
 -
 -        stable_id = atoll(get_interface_other_config(iface->cfg,
 -                                                     "bond-stable-id", "0"));
 -
 -        if (stable_id <= 0 || stable_id >= UINT32_MAX) {
 -            stable_id = odp_port_to_ofp_port(iface->dp_ifidx);
 -        }
 -
 -        bond_slave_register(iface->port->bond, iface, stable_id,
 -                            iface->netdev);
 -    }
 -}
 -
 -static void
 -port_send_learning_packets(struct port *port)
 -{
 -    struct bridge *br = port->bridge;
 -    int error, n_packets, n_errors;
 -    struct mac_entry *e;
 -
 -    error = n_packets = n_errors = 0;
 -    LIST_FOR_EACH (e, lru_node, &br->ml->lrus) {
 -        if (e->port.p != port) {
 -            int ret = bond_send_learning_packet(port->bond, e->mac, e->vlan);
 -            if (ret) {
 -                error = ret;
 -                n_errors++;
 -            }
 -            n_packets++;
 -        }
 +    if (s->rebalance_interval < 1000) {
 +        s->rebalance_interval = 1000;
      }
  
 -    if (n_errors) {
 -        static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 -        VLOG_WARN_RL(&rl, "bond %s: %d errors sending %d gratuitous learning "
 -                     "packets, last error was: %s",
 -                     port->name, n_errors, n_packets, strerror(error));
 -    } else {
 -        VLOG_DBG("bond %s: sent %d gratuitous learning packets",
 -                 port->name, n_packets);
 -    }
 +    s->fake_iface = port->cfg->bond_fake_iface;
  }
  \f
  /* Interface functions. */
@@@ -2444,9 -3532,9 +2457,9 @@@ iface_delete_queues(unsigned int queue_
  }
  
  static void
 -iface_update_qos(struct iface *iface, const struct ovsrec_qos *qos)
 +iface_configure_qos(struct iface *iface, const struct ovsrec_qos *qos)
  {
-     if (!qos || qos->type[0] == '\0') {
+     if (!qos || qos->type[0] == '\0' || qos->n_queues < 1) {
          netdev_set_qos(iface->netdev, NULL, NULL);
      } else {
          struct iface_delete_queues_cbdata cbdata;
Simple merge