ofproto/ofproto-dpif.c

   1 /*
   2  * Copyright (c) 2009, 2010, 2011 Nicira Networks.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at:
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <config.h>
  18
  19 #include "ofproto/private.h"
  20
  21 #include <errno.h>
  22
  23 #include "autopath.h"
  24 #include "bond.h"
  25 #include "byte-order.h"
  26 #include "connmgr.h"
  27 #include "coverage.h"
  28 #include "cfm.h"
  29 #include "dpif.h"
  30 #include "dynamic-string.h"
  31 #include "fail-open.h"
  32 #include "hmapx.h"
  33 #include "lacp.h"
  34 #include "mac-learning.h"
  35 #include "multipath.h"
  36 #include "netdev.h"
  37 #include "netlink.h"
  38 #include "nx-match.h"
  39 #include "odp-util.h"
  40 #include "ofp-util.h"
  41 #include "ofpbuf.h"
  42 #include "ofp-print.h"
  43 #include "ofproto-sflow.h"
  44 #include "poll-loop.h"
  45 #include "timer.h"
  46 #include "unaligned.h"
  47 #include "unixctl.h"
  48 #include "vlan-bitmap.h"
  49 #include "vlog.h"
  50
  51 VLOG_DEFINE_THIS_MODULE(ofproto_dpif);
  52
  53 COVERAGE_DEFINE(ofproto_dpif_ctlr_action);
  54 COVERAGE_DEFINE(ofproto_dpif_expired);
  55 COVERAGE_DEFINE(ofproto_dpif_no_packet_in);
  56 COVERAGE_DEFINE(ofproto_dpif_xlate);
  57 COVERAGE_DEFINE(facet_changed_rule);
  58 COVERAGE_DEFINE(facet_invalidated);
  59 COVERAGE_DEFINE(facet_revalidate);
  60 COVERAGE_DEFINE(facet_unexpected);
  61
  62 /* Maximum depth of flow table recursion (due to NXAST_RESUBMIT actions) in a
  63  * flow translation. */
  64 #define MAX_RESUBMIT_RECURSION 16
  65
  66 struct ofport_dpif;
  67 struct ofproto_dpif;
  68
  69 struct rule_dpif {
  70     struct rule up;
  71
  72     long long int used;         /* Time last used; time created if not used. */
  73
  74     /* These statistics:
  75      *
  76      *   - Do include packets and bytes from facets that have been deleted or
  77      *     whose own statistics have been folded into the rule.
  78      *
  79      *   - Do include packets and bytes sent "by hand" that were accounted to
  80      *     the rule without any facet being involved (this is a rare corner
  81      *     case in rule_execute()).
  82      *
  83      *   - Do not include packet or bytes that can be obtained from any facet's
  84      *     packet_count or byte_count member or that can be obtained from the
  85      *     datapath by, e.g., dpif_flow_get() for any facet.
  86      */
  87     uint64_t packet_count;       /* Number of packets received. */
  88     uint64_t byte_count;         /* Number of bytes received. */
  89
  90     struct list facets;          /* List of "struct facet"s. */
  91 };
  92
  93 static struct rule_dpif *rule_dpif_cast(const struct rule *rule)
  94 {
  95     return rule ? CONTAINER_OF(rule, struct rule_dpif, up) : NULL;
  96 }
  97
  98 static struct rule_dpif *rule_dpif_lookup(struct ofproto_dpif *ofproto,
  99                                           const struct flow *flow);
 100
 101 #define MAX_MIRRORS 32
 102 typedef uint32_t mirror_mask_t;
 103 #define MIRROR_MASK_C(X) UINT32_C(X)
 104 BUILD_ASSERT_DECL(sizeof(mirror_mask_t) * CHAR_BIT >= MAX_MIRRORS);
 105 struct ofmirror {
 106     struct ofproto_dpif *ofproto; /* Owning ofproto. */
 107     size_t idx;                 /* In ofproto's "mirrors" array. */
 108     void *aux;                  /* Key supplied by ofproto's client. */
 109     char *name;                 /* Identifier for log messages. */
 110
 111     /* Selection criteria. */
 112     struct hmapx srcs;          /* Contains "struct ofbundle *"s. */
 113     struct hmapx dsts;          /* Contains "struct ofbundle *"s. */
 114     unsigned long *vlans;       /* Bitmap of chosen VLANs, NULL selects all. */
 115
 116     /* Output (mutually exclusive). */
 117     struct ofbundle *out;       /* Output port or NULL. */
 118     int out_vlan;               /* Output VLAN or -1. */
 119 };
 120
 121 static void mirror_destroy(struct ofmirror *);
 122
 123 /* A group of one or more OpenFlow ports. */
 124 #define OFBUNDLE_FLOOD ((struct ofbundle *) 1)
 125 struct ofbundle {
 126     struct ofproto_dpif *ofproto; /* Owning ofproto. */
 127     struct hmap_node hmap_node; /* In struct ofproto's "bundles" hmap. */
 128     void *aux;                  /* Key supplied by ofproto's client. */
 129     char *name;                 /* Identifier for log messages. */
 130
 131     /* Configuration. */
 132     struct list ports;          /* Contains "struct ofport"s. */
 133     int vlan;                   /* -1=trunk port, else a 12-bit VLAN ID. */
 134     unsigned long *trunks;      /* Bitmap of trunked VLANs, if 'vlan' == -1.
 135                                  * NULL if all VLANs are trunked. */
 136     struct lacp *lacp;          /* LACP if LACP is enabled, otherwise NULL. */
 137     struct bond *bond;          /* Nonnull iff more than one port. */
 138
 139     /* Status. */
 140     bool floodable;             /* True if no port has OFPPC_NO_FLOOD set. */
 141
 142     /* Port mirroring info. */
 143     mirror_mask_t src_mirrors;  /* Mirrors triggered when packet received. */
 144     mirror_mask_t dst_mirrors;  /* Mirrors triggered when packet sent. */
 145     mirror_mask_t mirror_out;   /* Mirrors that output to this bundle. */
 146 };
 147
 148 static void bundle_remove(struct ofport *);
 149 static void bundle_destroy(struct ofbundle *);
 150 static void bundle_del_port(struct ofport_dpif *);
 151 static void bundle_run(struct ofbundle *);
 152 static void bundle_wait(struct ofbundle *);
 153
 154 struct action_xlate_ctx {
 155 /* action_xlate_ctx_init() initializes these members. */
 156
 157     /* The ofproto. */
 158     struct ofproto_dpif *ofproto;
 159
 160     /* Flow to which the OpenFlow actions apply.  xlate_actions() will modify
 161      * this flow when actions change header fields. */
 162     struct flow flow;
 163
 164     /* The packet corresponding to 'flow', or a null pointer if we are
 165      * revalidating without a packet to refer to. */
 166     const struct ofpbuf *packet;
 167
 168     /* If nonnull, called just before executing a resubmit action.
 169      *
 170      * This is normally null so the client has to set it manually after
 171      * calling action_xlate_ctx_init(). */
 172     void (*resubmit_hook)(struct action_xlate_ctx *, struct rule_dpif *);
 173
 174 /* xlate_actions() initializes and uses these members.  The client might want
 175  * to look at them after it returns. */
 176
 177     struct ofpbuf *odp_actions; /* Datapath actions. */
 178     tag_type tags;              /* Tags associated with OFPP_NORMAL actions. */
 179     bool may_set_up_flow;       /* True ordinarily; false if the actions must
 180                                  * be reassessed for every packet. */
 181     uint16_t nf_output_iface;   /* Output interface index for NetFlow. */
 182
 183 /* xlate_actions() initializes and uses these members, but the client has no
 184  * reason to look at them. */
 185
 186     int recurse;                /* Recursion level, via xlate_table_action. */
 187     uint32_t priority;          /* Current flow priority. 0 if none. */
 188     struct flow base_flow;      /* Flow at the last commit. */
 189     uint32_t base_priority;     /* Priority at the last commit. */
 190 };
 191
 192 static void action_xlate_ctx_init(struct action_xlate_ctx *,
 193                                   struct ofproto_dpif *, const struct flow *,
 194                                   const struct ofpbuf *);
 195 static struct ofpbuf *xlate_actions(struct action_xlate_ctx *,
 196                                     const union ofp_action *in, size_t n_in);
 197
 198 /* An exact-match instantiation of an OpenFlow flow. */
 199 struct facet {
 200     long long int used;         /* Time last used; time created if not used. */
 201
 202     /* These statistics:
 203      *
 204      *   - Do include packets and bytes sent "by hand", e.g. with
 205      *     dpif_execute().
 206      *
 207      *   - Do include packets and bytes that were obtained from the datapath
 208      *     when a flow was deleted (e.g. dpif_flow_del()) or when its
 209      *     statistics were reset (e.g. dpif_flow_put() with
 210      *     DPIF_FP_ZERO_STATS).
 211      *
 212      *   - Do not include any packets or bytes that can currently be obtained
 213      *     from the datapath by, e.g., dpif_flow_get().
 214      */
 215     uint64_t packet_count;       /* Number of packets received. */
 216     uint64_t byte_count;         /* Number of bytes received. */
 217
 218     uint64_t dp_packet_count;    /* Last known packet count in the datapath. */
 219     uint64_t dp_byte_count;      /* Last known byte count in the datapath. */
 220
 221     uint64_t rs_packet_count;    /* Packets pushed to resubmit children. */
 222     uint64_t rs_byte_count;      /* Bytes pushed to resubmit children. */
 223     long long int rs_used;       /* Used time pushed to resubmit children. */
 224
 225     /* Number of bytes passed to account_cb.  This may include bytes that can
 226      * currently obtained from the datapath (thus, it can be greater than
 227      * byte_count). */
 228     uint64_t accounted_bytes;
 229
 230     struct hmap_node hmap_node;  /* In owning ofproto's 'facets' hmap. */
 231     struct list list_node;       /* In owning rule's 'facets' list. */
 232     struct rule_dpif *rule;      /* Owning rule. */
 233     struct flow flow;            /* Exact-match flow. */
 234     bool installed;              /* Installed in datapath? */
 235     bool may_install;            /* True ordinarily; false if actions must
 236                                   * be reassessed for every packet. */
 237     size_t actions_len;          /* Number of bytes in actions[]. */
 238     struct nlattr *actions;      /* Datapath actions. */
 239     tag_type tags;               /* Tags. */
 240     struct netflow_flow nf_flow; /* Per-flow NetFlow tracking data. */
 241 };
 242
 243 static struct facet *facet_create(struct rule_dpif *, const struct flow *,
 244                                   const struct ofpbuf *packet);
 245 static void facet_remove(struct ofproto_dpif *, struct facet *);
 246 static void facet_free(struct facet *);
 247
 248 static struct facet *facet_find(struct ofproto_dpif *, const struct flow *);
 249 static struct facet *facet_lookup_valid(struct ofproto_dpif *,
 250                                         const struct flow *);
 251 static bool facet_revalidate(struct ofproto_dpif *, struct facet *);
 252
 253 static void facet_execute(struct ofproto_dpif *, struct facet *,
 254                           struct ofpbuf *packet);
 255
 256 static int facet_put__(struct ofproto_dpif *, struct facet *,
 257                        const struct nlattr *actions, size_t actions_len,
 258                        struct dpif_flow_stats *);
 259 static void facet_install(struct ofproto_dpif *, struct facet *,
 260                           bool zero_stats);
 261 static void facet_uninstall(struct ofproto_dpif *, struct facet *);
 262 static void facet_flush_stats(struct ofproto_dpif *, struct facet *);
 263
 264 static void facet_make_actions(struct ofproto_dpif *, struct facet *,
 265                                const struct ofpbuf *packet);
 266 static void facet_update_time(struct ofproto_dpif *, struct facet *,
 267                               long long int used);
 268 static void facet_update_stats(struct ofproto_dpif *, struct facet *,
 269                                const struct dpif_flow_stats *);
 270 static void facet_reset_dp_stats(struct facet *, struct dpif_flow_stats *);
 271 static void facet_push_stats(struct facet *);
 272 static void facet_account(struct ofproto_dpif *, struct facet *,
 273                           uint64_t extra_bytes);
 274
 275 static bool facet_is_controller_flow(struct facet *);
 276
 277 static void flow_push_stats(const struct rule_dpif *,
 278                             struct flow *, uint64_t packets, uint64_t bytes,
 279                             long long int used);
 280
 281 struct ofport_dpif {
 282     struct ofport up;
 283
 284     uint32_t odp_port;
 285     struct ofbundle *bundle;    /* Bundle that contains this port, if any. */
 286     struct list bundle_node;    /* In struct ofbundle's "ports" list. */
 287     struct cfm *cfm;            /* Connectivity Fault Management, if any. */
 288     tag_type tag;               /* Tag associated with this port. */
 289     uint32_t bond_stable_id;    /* stable_id to use as bond slave, or 0. */
 290 };
 291
 292 static struct ofport_dpif *
 293 ofport_dpif_cast(const struct ofport *ofport)
 294 {
 295     assert(ofport->ofproto->ofproto_class == &ofproto_dpif_class);
 296     return ofport ? CONTAINER_OF(ofport, struct ofport_dpif, up) : NULL;
 297 }
 298
 299 static void port_run(struct ofport_dpif *);
 300 static void port_wait(struct ofport_dpif *);
 301 static int set_cfm(struct ofport *, const struct cfm_settings *);
 302
 303 struct ofproto_dpif {
 304     struct ofproto up;
 305     struct dpif *dpif;
 306     int max_ports;
 307
 308     /* Statistics. */
 309     uint64_t n_matches;
 310
 311     /* Bridging. */
 312     struct netflow *netflow;
 313     struct ofproto_sflow *sflow;
 314     struct hmap bundles;        /* Contains "struct ofbundle"s. */
 315     struct mac_learning *ml;
 316     struct ofmirror *mirrors[MAX_MIRRORS];
 317     bool has_bonded_bundles;
 318
 319     /* Expiration. */
 320     struct timer next_expiration;
 321
 322     /* Facets. */
 323     struct hmap facets;
 324     bool need_revalidate;
 325     struct tag_set revalidate_set;
 326 };
 327
 328 static void ofproto_dpif_unixctl_init(void);
 329
 330 static struct ofproto_dpif *
 331 ofproto_dpif_cast(const struct ofproto *ofproto)
 332 {
 333     assert(ofproto->ofproto_class == &ofproto_dpif_class);
 334     return CONTAINER_OF(ofproto, struct ofproto_dpif, up);
 335 }
 336
 337 static struct ofport_dpif *get_ofp_port(struct ofproto_dpif *,
 338                                         uint16_t ofp_port);
 339 static struct ofport_dpif *get_odp_port(struct ofproto_dpif *,
 340                                         uint32_t odp_port);
 341
 342 /* Packet processing. */
 343 static void update_learning_table(struct ofproto_dpif *,
 344                                   const struct flow *, int vlan,
 345                                   struct ofbundle *);
 346 static bool is_admissible(struct ofproto_dpif *, const struct flow *,
 347                           bool have_packet, tag_type *, int *vlanp,
 348                           struct ofbundle **in_bundlep);
 349 static void handle_upcall(struct ofproto_dpif *, struct dpif_upcall *);
 350
 351 /* Flow expiration. */
 352 static int expire(struct ofproto_dpif *);
 353
 354 /* Utilities. */
 355 static int send_packet(struct ofproto_dpif *, uint32_t odp_port,
 356                        const struct ofpbuf *packet);
 357
 358 /* Global variables. */
 359 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
 360 \f
 361 /* Factory functions. */
 362
 363 static void
 364 enumerate_types(struct sset *types)
 365 {
 366     dp_enumerate_types(types);
 367 }
 368
 369 static int
 370 enumerate_names(const char *type, struct sset *names)
 371 {
 372     return dp_enumerate_names(type, names);
 373 }
 374
 375 static int
 376 del(const char *type, const char *name)
 377 {
 378     struct dpif *dpif;
 379     int error;
 380
 381     error = dpif_open(name, type, &dpif);
 382     if (!error) {
 383         error = dpif_delete(dpif);
 384         dpif_close(dpif);
 385     }
 386     return error;
 387 }
 388 \f
 389 /* Basic life-cycle. */
 390
 391 static struct ofproto *
 392 alloc(void)
 393 {
 394     struct ofproto_dpif *ofproto = xmalloc(sizeof *ofproto);
 395     return &ofproto->up;
 396 }
 397
 398 static void
 399 dealloc(struct ofproto *ofproto_)
 400 {
 401     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 402     free(ofproto);
 403 }
 404
 405 static int
 406 construct(struct ofproto *ofproto_)
 407 {
 408     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 409     const char *name = ofproto->up.name;
 410     int error;
 411     int i;
 412
 413     error = dpif_create_and_open(name, ofproto->up.type, &ofproto->dpif);
 414     if (error) {
 415         VLOG_ERR("failed to open datapath %s: %s", name, strerror(error));
 416         return error;
 417     }
 418
 419     ofproto->max_ports = dpif_get_max_ports(ofproto->dpif);
 420     ofproto->n_matches = 0;
 421
 422     error = dpif_recv_set_mask(ofproto->dpif,
 423                                ((1u << DPIF_UC_MISS) |
 424                                 (1u << DPIF_UC_ACTION) |
 425                                 (1u << DPIF_UC_SAMPLE)));
 426     if (error) {
 427         VLOG_ERR("failed to listen on datapath %s: %s", name, strerror(error));
 428         dpif_close(ofproto->dpif);
 429         return error;
 430     }
 431     dpif_flow_flush(ofproto->dpif);
 432     dpif_recv_purge(ofproto->dpif);
 433
 434     ofproto->netflow = NULL;
 435     ofproto->sflow = NULL;
 436     hmap_init(&ofproto->bundles);
 437     ofproto->ml = mac_learning_create();
 438     for (i = 0; i < MAX_MIRRORS; i++) {
 439         ofproto->mirrors[i] = NULL;
 440     }
 441     ofproto->has_bonded_bundles = false;
 442
 443     timer_set_duration(&ofproto->next_expiration, 1000);
 444
 445     hmap_init(&ofproto->facets);
 446     ofproto->need_revalidate = false;
 447     tag_set_init(&ofproto->revalidate_set);
 448
 449     ofproto->up.tables = xmalloc(sizeof *ofproto->up.tables);
 450     classifier_init(&ofproto->up.tables[0]);
 451     ofproto->up.n_tables = 1;
 452
 453     ofproto_dpif_unixctl_init();
 454
 455     return 0;
 456 }
 457
 458 static void
 459 destruct(struct ofproto *ofproto_)
 460 {
 461     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 462     int i;
 463
 464     for (i = 0; i < MAX_MIRRORS; i++) {
 465         mirror_destroy(ofproto->mirrors[i]);
 466     }
 467
 468     netflow_destroy(ofproto->netflow);
 469     ofproto_sflow_destroy(ofproto->sflow);
 470     hmap_destroy(&ofproto->bundles);
 471     mac_learning_destroy(ofproto->ml);
 472
 473     hmap_destroy(&ofproto->facets);
 474
 475     dpif_close(ofproto->dpif);
 476 }
 477
 478 static int
 479 run(struct ofproto *ofproto_)
 480 {
 481     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 482     struct ofport_dpif *ofport;
 483     struct ofbundle *bundle;
 484     int i;
 485
 486     dpif_run(ofproto->dpif);
 487
 488     for (i = 0; i < 50; i++) {
 489         struct dpif_upcall packet;
 490         int error;
 491
 492         error = dpif_recv(ofproto->dpif, &packet);
 493         if (error) {
 494             if (error == ENODEV) {
 495                 /* Datapath destroyed. */
 496                 return error;
 497             }
 498             break;
 499         }
 500
 501         handle_upcall(ofproto, &packet);
 502     }
 503
 504     if (timer_expired(&ofproto->next_expiration)) {
 505         int delay = expire(ofproto);
 506         timer_set_duration(&ofproto->next_expiration, delay);
 507     }
 508
 509     if (ofproto->netflow) {
 510         netflow_run(ofproto->netflow);
 511     }
 512     if (ofproto->sflow) {
 513         ofproto_sflow_run(ofproto->sflow);
 514     }
 515
 516     HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
 517         port_run(ofport);
 518     }
 519     HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
 520         bundle_run(bundle);
 521     }
 522
 523     /* Now revalidate if there's anything to do. */
 524     if (ofproto->need_revalidate
 525         || !tag_set_is_empty(&ofproto->revalidate_set)) {
 526         struct tag_set revalidate_set = ofproto->revalidate_set;
 527         bool revalidate_all = ofproto->need_revalidate;
 528         struct facet *facet, *next;
 529
 530         /* Clear the revalidation flags. */
 531         tag_set_init(&ofproto->revalidate_set);
 532         ofproto->need_revalidate = false;
 533
 534         HMAP_FOR_EACH_SAFE (facet, next, hmap_node, &ofproto->facets) {
 535             if (revalidate_all
 536                 || tag_set_intersects(&revalidate_set, facet->tags)) {
 537                 facet_revalidate(ofproto, facet);
 538             }
 539         }
 540     }
 541
 542     return 0;
 543 }
 544
 545 static void
 546 wait(struct ofproto *ofproto_)
 547 {
 548     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 549     struct ofport_dpif *ofport;
 550     struct ofbundle *bundle;
 551
 552     dpif_wait(ofproto->dpif);
 553     dpif_recv_wait(ofproto->dpif);
 554     if (ofproto->sflow) {
 555         ofproto_sflow_wait(ofproto->sflow);
 556     }
 557     if (!tag_set_is_empty(&ofproto->revalidate_set)) {
 558         poll_immediate_wake();
 559     }
 560     HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
 561         port_wait(ofport);
 562     }
 563     HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
 564         bundle_wait(bundle);
 565     }
 566     if (ofproto->need_revalidate) {
 567         /* Shouldn't happen, but if it does just go around again. */
 568         VLOG_DBG_RL(&rl, "need revalidate in ofproto_wait_cb()");
 569         poll_immediate_wake();
 570     } else {
 571         timer_wait(&ofproto->next_expiration);
 572     }
 573 }
 574
 575 static void
 576 flush(struct ofproto *ofproto_)
 577 {
 578     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 579     struct facet *facet, *next_facet;
 580
 581     HMAP_FOR_EACH_SAFE (facet, next_facet, hmap_node, &ofproto->facets) {
 582         /* Mark the facet as not installed so that facet_remove() doesn't
 583          * bother trying to uninstall it.  There is no point in uninstalling it
 584          * individually since we are about to blow away all the facets with
 585          * dpif_flow_flush(). */
 586         facet->installed = false;
 587         facet->dp_packet_count = 0;
 588         facet->dp_byte_count = 0;
 589         facet_remove(ofproto, facet);
 590     }
 591     dpif_flow_flush(ofproto->dpif);
 592 }
 593
 594 static void
 595 get_features(struct ofproto *ofproto_ OVS_UNUSED,
 596              bool *arp_match_ip, uint32_t *actions)
 597 {
 598     *arp_match_ip = true;
 599     *actions = ((1u << OFPAT_OUTPUT) |
 600                 (1u << OFPAT_SET_VLAN_VID) |
 601                 (1u << OFPAT_SET_VLAN_PCP) |
 602                 (1u << OFPAT_STRIP_VLAN) |
 603                 (1u << OFPAT_SET_DL_SRC) |
 604                 (1u << OFPAT_SET_DL_DST) |
 605                 (1u << OFPAT_SET_NW_SRC) |
 606                 (1u << OFPAT_SET_NW_DST) |
 607                 (1u << OFPAT_SET_NW_TOS) |
 608                 (1u << OFPAT_SET_TP_SRC) |
 609                 (1u << OFPAT_SET_TP_DST) |
 610                 (1u << OFPAT_ENQUEUE));
 611 }
 612
 613 static void
 614 get_tables(struct ofproto *ofproto_, struct ofp_table_stats *ots)
 615 {
 616     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 617     struct odp_stats s;
 618
 619     strcpy(ots->name, "classifier");
 620
 621     dpif_get_dp_stats(ofproto->dpif, &s);
 622     put_32aligned_be64(&ots->lookup_count, htonll(s.n_hit + s.n_missed));
 623     put_32aligned_be64(&ots->matched_count,
 624                        htonll(s.n_hit + ofproto->n_matches));
 625 }
 626
 627 static int
 628 set_netflow(struct ofproto *ofproto_,
 629             const struct netflow_options *netflow_options)
 630 {
 631     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 632
 633     if (netflow_options) {
 634         if (!ofproto->netflow) {
 635             ofproto->netflow = netflow_create();
 636         }
 637         return netflow_set_options(ofproto->netflow, netflow_options);
 638     } else {
 639         netflow_destroy(ofproto->netflow);
 640         ofproto->netflow = NULL;
 641         return 0;
 642     }
 643 }
 644
 645 static struct ofport *
 646 port_alloc(void)
 647 {
 648     struct ofport_dpif *port = xmalloc(sizeof *port);
 649     return &port->up;
 650 }
 651
 652 static void
 653 port_dealloc(struct ofport *port_)
 654 {
 655     struct ofport_dpif *port = ofport_dpif_cast(port_);
 656     free(port);
 657 }
 658
 659 static int
 660 port_construct(struct ofport *port_)
 661 {
 662     struct ofport_dpif *port = ofport_dpif_cast(port_);
 663     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
 664
 665     port->odp_port = ofp_port_to_odp_port(port->up.ofp_port);
 666     port->bundle = NULL;
 667     port->cfm = NULL;
 668     port->tag = tag_create_random();
 669
 670     if (ofproto->sflow) {
 671         ofproto_sflow_add_port(ofproto->sflow, port->odp_port,
 672                                netdev_get_name(port->up.netdev));
 673     }
 674
 675     return 0;
 676 }
 677
 678 static void
 679 port_destruct(struct ofport *port_)
 680 {
 681     struct ofport_dpif *port = ofport_dpif_cast(port_);
 682     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
 683
 684     bundle_remove(port_);
 685     set_cfm(port_, NULL);
 686     if (ofproto->sflow) {
 687         ofproto_sflow_del_port(ofproto->sflow, port->odp_port);
 688     }
 689 }
 690
 691 static void
 692 port_modified(struct ofport *port_)
 693 {
 694     struct ofport_dpif *port = ofport_dpif_cast(port_);
 695
 696     if (port->bundle && port->bundle->bond) {
 697         bond_slave_set_netdev(port->bundle->bond, port, port->up.netdev);
 698     }
 699 }
 700
 701 static void
 702 port_reconfigured(struct ofport *port_, ovs_be32 old_config)
 703 {
 704     struct ofport_dpif *port = ofport_dpif_cast(port_);
 705     struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto);
 706     ovs_be32 changed = old_config ^ port->up.opp.config;
 707
 708     if (changed & htonl(OFPPC_NO_RECV | OFPPC_NO_RECV_STP |
 709                         OFPPC_NO_FWD | OFPPC_NO_FLOOD)) {
 710         ofproto->need_revalidate = true;
 711     }
 712 }
 713
 714 static int
 715 set_sflow(struct ofproto *ofproto_,
 716           const struct ofproto_sflow_options *sflow_options)
 717 {
 718     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 719     struct ofproto_sflow *os = ofproto->sflow;
 720     if (sflow_options) {
 721         if (!os) {
 722             struct ofport_dpif *ofport;
 723
 724             os = ofproto->sflow = ofproto_sflow_create(ofproto->dpif);
 725             HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) {
 726                 ofproto_sflow_add_port(os, ofport->odp_port,
 727                                        netdev_get_name(ofport->up.netdev));
 728             }
 729         }
 730         ofproto_sflow_set_options(os, sflow_options);
 731     } else {
 732         ofproto_sflow_destroy(os);
 733         ofproto->sflow = NULL;
 734     }
 735     return 0;
 736 }
 737
 738 static int
 739 set_cfm(struct ofport *ofport_, const struct cfm_settings *s)
 740 {
 741     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
 742     int error;
 743
 744     if (!s) {
 745         error = 0;
 746     } else {
 747         if (!ofport->cfm) {
 748             ofport->cfm = cfm_create(netdev_get_name(ofport->up.netdev));
 749         }
 750
 751         if (cfm_configure(ofport->cfm, s)) {
 752             return 0;
 753         }
 754
 755         error = EINVAL;
 756     }
 757     cfm_destroy(ofport->cfm);
 758     ofport->cfm = NULL;
 759     return error;
 760 }
 761
 762 static int
 763 get_cfm_fault(const struct ofport *ofport_)
 764 {
 765     struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
 766
 767     return ofport->cfm ? cfm_get_fault(ofport->cfm) : -1;
 768 }
 769 \f
 770 /* Bundles. */
 771
 772 /* Expires all MAC learning entries associated with 'port' and forces ofproto
 773  * to revalidate every flow. */
 774 static void
 775 bundle_flush_macs(struct ofbundle *bundle)
 776 {
 777     struct ofproto_dpif *ofproto = bundle->ofproto;
 778     struct mac_learning *ml = ofproto->ml;
 779     struct mac_entry *mac, *next_mac;
 780
 781     ofproto->need_revalidate = true;
 782     LIST_FOR_EACH_SAFE (mac, next_mac, lru_node, &ml->lrus) {
 783         if (mac->port.p == bundle) {
 784             mac_learning_expire(ml, mac);
 785         }
 786     }
 787 }
 788
 789 static struct ofbundle *
 790 bundle_lookup(const struct ofproto_dpif *ofproto, void *aux)
 791 {
 792     struct ofbundle *bundle;
 793
 794     HMAP_FOR_EACH_IN_BUCKET (bundle, hmap_node, hash_pointer(aux, 0),
 795                              &ofproto->bundles) {
 796         if (bundle->aux == aux) {
 797             return bundle;
 798         }
 799     }
 800     return NULL;
 801 }
 802
 803 /* Looks up each of the 'n_auxes' pointers in 'auxes' as bundles and adds the
 804  * ones that are found to 'bundles'. */
 805 static void
 806 bundle_lookup_multiple(struct ofproto_dpif *ofproto,
 807                        void **auxes, size_t n_auxes,
 808                        struct hmapx *bundles)
 809 {
 810     size_t i;
 811
 812     hmapx_init(bundles);
 813     for (i = 0; i < n_auxes; i++) {
 814         struct ofbundle *bundle = bundle_lookup(ofproto, auxes[i]);
 815         if (bundle) {
 816             hmapx_add(bundles, bundle);
 817         }
 818     }
 819 }
 820
 821 static void
 822 bundle_del_port(struct ofport_dpif *port)
 823 {
 824     struct ofbundle *bundle = port->bundle;
 825
 826     bundle->ofproto->need_revalidate = true;
 827
 828     list_remove(&port->bundle_node);
 829     port->bundle = NULL;
 830
 831     if (bundle->lacp) {
 832         lacp_slave_unregister(bundle->lacp, port);
 833     }
 834     if (bundle->bond) {
 835         bond_slave_unregister(bundle->bond, port);
 836     }
 837
 838     bundle->floodable = true;
 839     LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
 840         if (port->up.opp.config & htonl(OFPPC_NO_FLOOD)) {
 841             bundle->floodable = false;
 842         }
 843     }
 844 }
 845
 846 static bool
 847 bundle_add_port(struct ofbundle *bundle, uint32_t ofp_port,
 848                 struct lacp_slave_settings *lacp,
 849                 uint32_t bond_stable_id)
 850 {
 851     struct ofport_dpif *port;
 852
 853     port = get_ofp_port(bundle->ofproto, ofp_port);
 854     if (!port) {
 855         return false;
 856     }
 857
 858     if (port->bundle != bundle) {
 859         bundle->ofproto->need_revalidate = true;
 860         if (port->bundle) {
 861             bundle_del_port(port);
 862         }
 863
 864         port->bundle = bundle;
 865         list_push_back(&bundle->ports, &port->bundle_node);
 866         if (port->up.opp.config & htonl(OFPPC_NO_FLOOD)) {
 867             bundle->floodable = false;
 868         }
 869     }
 870     if (lacp) {
 871         lacp_slave_register(bundle->lacp, port, lacp);
 872     }
 873
 874     port->bond_stable_id = bond_stable_id;
 875
 876     return true;
 877 }
 878
 879 static void
 880 bundle_destroy(struct ofbundle *bundle)
 881 {
 882     struct ofproto_dpif *ofproto;
 883     struct ofport_dpif *port, *next_port;
 884     int i;
 885
 886     if (!bundle) {
 887         return;
 888     }
 889
 890     ofproto = bundle->ofproto;
 891     for (i = 0; i < MAX_MIRRORS; i++) {
 892         struct ofmirror *m = ofproto->mirrors[i];
 893         if (m) {
 894             if (m->out == bundle) {
 895                 mirror_destroy(m);
 896             } else if (hmapx_find_and_delete(&m->srcs, bundle)
 897                        || hmapx_find_and_delete(&m->dsts, bundle)) {
 898                 ofproto->need_revalidate = true;
 899             }
 900         }
 901     }
 902
 903     LIST_FOR_EACH_SAFE (port, next_port, bundle_node, &bundle->ports) {
 904         bundle_del_port(port);
 905     }
 906
 907     bundle_flush_macs(bundle);
 908     hmap_remove(&ofproto->bundles, &bundle->hmap_node);
 909     free(bundle->name);
 910     free(bundle->trunks);
 911     lacp_destroy(bundle->lacp);
 912     bond_destroy(bundle->bond);
 913     free(bundle);
 914 }
 915
 916 static int
 917 bundle_set(struct ofproto *ofproto_, void *aux,
 918            const struct ofproto_bundle_settings *s)
 919 {
 920     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
 921     bool need_flush = false;
 922     const unsigned long *trunks;
 923     struct ofport_dpif *port;
 924     struct ofbundle *bundle;
 925     size_t i;
 926     bool ok;
 927
 928     if (!s) {
 929         bundle_destroy(bundle_lookup(ofproto, aux));
 930         return 0;
 931     }
 932
 933     assert(s->n_slaves == 1 || s->bond != NULL);
 934     assert((s->lacp != NULL) == (s->lacp_slaves != NULL));
 935
 936     bundle = bundle_lookup(ofproto, aux);
 937     if (!bundle) {
 938         bundle = xmalloc(sizeof *bundle);
 939
 940         bundle->ofproto = ofproto;
 941         hmap_insert(&ofproto->bundles, &bundle->hmap_node,
 942                     hash_pointer(aux, 0));
 943         bundle->aux = aux;
 944         bundle->name = NULL;
 945
 946         list_init(&bundle->ports);
 947         bundle->vlan = -1;
 948         bundle->trunks = NULL;
 949         bundle->lacp = NULL;
 950         bundle->bond = NULL;
 951
 952         bundle->floodable = true;
 953
 954         bundle->src_mirrors = 0;
 955         bundle->dst_mirrors = 0;
 956         bundle->mirror_out = 0;
 957     }
 958
 959     if (!bundle->name || strcmp(s->name, bundle->name)) {
 960         free(bundle->name);
 961         bundle->name = xstrdup(s->name);
 962     }
 963
 964     /* LACP. */
 965     if (s->lacp) {
 966         if (!bundle->lacp) {
 967             bundle->lacp = lacp_create();
 968         }
 969         lacp_configure(bundle->lacp, s->lacp);
 970     } else {
 971         lacp_destroy(bundle->lacp);
 972         bundle->lacp = NULL;
 973     }
 974
 975     /* Update set of ports. */
 976     ok = true;
 977     for (i = 0; i < s->n_slaves; i++) {
 978         if (!bundle_add_port(bundle, s->slaves[i],
 979                              s->lacp ? &s->lacp_slaves[i] : NULL,
 980                              s->bond_stable_ids ? s->bond_stable_ids[i] : 0)) {
 981             ok = false;
 982         }
 983     }
 984     if (!ok || list_size(&bundle->ports) != s->n_slaves) {
 985         struct ofport_dpif *next_port;
 986
 987         LIST_FOR_EACH_SAFE (port, next_port, bundle_node, &bundle->ports) {
 988             for (i = 0; i < s->n_slaves; i++) {
 989                 if (s->slaves[i] == port->up.ofp_port) {
 990                     goto found;
 991                 }
 992             }
 993
 994             bundle_del_port(port);
 995         found: ;
 996         }
 997     }
 998     assert(list_size(&bundle->ports) <= s->n_slaves);
 999
1000     if (list_is_empty(&bundle->ports)) {
1001         bundle_destroy(bundle);
1002         return EINVAL;
1003     }
1004
1005     /* Set VLAN tag. */
1006     if (s->vlan != bundle->vlan) {
1007         bundle->vlan = s->vlan;
1008         need_flush = true;
1009     }
1010
1011     /* Get trunked VLANs. */
1012     trunks = s->vlan == -1 ? NULL : s->trunks;
1013     if (!vlan_bitmap_equal(trunks, bundle->trunks)) {
1014         free(bundle->trunks);
1015         bundle->trunks = vlan_bitmap_clone(trunks);
1016         need_flush = true;
1017     }
1018
1019     /* Bonding. */
1020     if (!list_is_short(&bundle->ports)) {
1021         bundle->ofproto->has_bonded_bundles = true;
1022         if (bundle->bond) {
1023             if (bond_reconfigure(bundle->bond, s->bond)) {
1024                 ofproto->need_revalidate = true;
1025             }
1026         } else {
1027             bundle->bond = bond_create(s->bond);
1028             ofproto->need_revalidate = true;
1029         }
1030
1031         LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
1032             bond_slave_register(bundle->bond, port, port->bond_stable_id,
1033                                 port->up.netdev);
1034         }
1035     } else {
1036         bond_destroy(bundle->bond);
1037         bundle->bond = NULL;
1038     }
1039
1040     /* If we changed something that would affect MAC learning, un-learn
1041      * everything on this port and force flow revalidation. */
1042     if (need_flush) {
1043         bundle_flush_macs(bundle);
1044     }
1045
1046     return 0;
1047 }
1048
1049 static void
1050 bundle_remove(struct ofport *port_)
1051 {
1052     struct ofport_dpif *port = ofport_dpif_cast(port_);
1053     struct ofbundle *bundle = port->bundle;
1054
1055     if (bundle) {
1056         bundle_del_port(port);
1057         if (list_is_empty(&bundle->ports)) {
1058             bundle_destroy(bundle);
1059         } else if (list_is_short(&bundle->ports)) {
1060             bond_destroy(bundle->bond);
1061             bundle->bond = NULL;
1062         }
1063     }
1064 }
1065
1066 static void
1067 send_pdu_cb(void *port_, const struct lacp_pdu *pdu)
1068 {
1069     static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 10);
1070     struct ofport_dpif *port = port_;
1071     uint8_t ea[ETH_ADDR_LEN];
1072     int error;
1073
1074     error = netdev_get_etheraddr(port->up.netdev, ea);
1075     if (!error) {
1076         struct lacp_pdu *packet_pdu;
1077         struct ofpbuf packet;
1078
1079         ofpbuf_init(&packet, 0);
1080         packet_pdu = eth_compose(&packet, eth_addr_lacp, ea, ETH_TYPE_LACP,
1081                                  sizeof *packet_pdu);
1082         *packet_pdu = *pdu;
1083         error = netdev_send(port->up.netdev, &packet);
1084         if (error) {
1085             VLOG_WARN_RL(&rl, "port %s: sending LACP PDU on iface %s failed "
1086                          "(%s)", port->bundle->name,
1087                          netdev_get_name(port->up.netdev), strerror(error));
1088         }
1089         ofpbuf_uninit(&packet);
1090     } else {
1091         VLOG_ERR_RL(&rl, "port %s: cannot obtain Ethernet address of iface "
1092                     "%s (%s)", port->bundle->name,
1093                     netdev_get_name(port->up.netdev), strerror(error));
1094     }
1095 }
1096
1097 static void
1098 bundle_send_learning_packets(struct ofbundle *bundle)
1099 {
1100     struct ofproto_dpif *ofproto = bundle->ofproto;
1101     int error, n_packets, n_errors;
1102     struct mac_entry *e;
1103
1104     error = n_packets = n_errors = 0;
1105     LIST_FOR_EACH (e, lru_node, &ofproto->ml->lrus) {
1106         if (e->port.p != bundle) {
1107             int ret = bond_send_learning_packet(bundle->bond, e->mac, e->vlan);
1108             if (ret) {
1109                 error = ret;
1110                 n_errors++;
1111             }
1112             n_packets++;
1113         }
1114     }
1115
1116     if (n_errors) {
1117         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
1118         VLOG_WARN_RL(&rl, "bond %s: %d errors sending %d gratuitous learning "
1119                      "packets, last error was: %s",
1120                      bundle->name, n_errors, n_packets, strerror(error));
1121     } else {
1122         VLOG_DBG("bond %s: sent %d gratuitous learning packets",
1123                  bundle->name, n_packets);
1124     }
1125 }
1126
1127 static void
1128 bundle_run(struct ofbundle *bundle)
1129 {
1130     if (bundle->lacp) {
1131         lacp_run(bundle->lacp, send_pdu_cb);
1132     }
1133     if (bundle->bond) {
1134         struct ofport_dpif *port;
1135
1136         LIST_FOR_EACH (port, bundle_node, &bundle->ports) {
1137             bool may_enable = lacp_slave_may_enable(bundle->lacp, port);
1138
1139             if (may_enable && port->cfm) {
1140                 may_enable = !cfm_get_fault(port->cfm);
1141             }
1142             bond_slave_set_may_enable(bundle->bond, port, may_enable);
1143         }
1144
1145         bond_run(bundle->bond, &bundle->ofproto->revalidate_set,
1146                  lacp_negotiated(bundle->lacp));
1147         if (bond_should_send_learning_packets(bundle->bond)) {
1148             bundle_send_learning_packets(bundle);
1149         }
1150     }
1151 }
1152
1153 static void
1154 bundle_wait(struct ofbundle *bundle)
1155 {
1156     if (bundle->lacp) {
1157         lacp_wait(bundle->lacp);
1158     }
1159     if (bundle->bond) {
1160         bond_wait(bundle->bond);
1161     }
1162 }
1163 \f
1164 /* Mirrors. */
1165
1166 static int
1167 mirror_scan(struct ofproto_dpif *ofproto)
1168 {
1169     int idx;
1170
1171     for (idx = 0; idx < MAX_MIRRORS; idx++) {
1172         if (!ofproto->mirrors[idx]) {
1173             return idx;
1174         }
1175     }
1176     return -1;
1177 }
1178
1179 static struct ofmirror *
1180 mirror_lookup(struct ofproto_dpif *ofproto, void *aux)
1181 {
1182     int i;
1183
1184     for (i = 0; i < MAX_MIRRORS; i++) {
1185         struct ofmirror *mirror = ofproto->mirrors[i];
1186         if (mirror && mirror->aux == aux) {
1187             return mirror;
1188         }
1189     }
1190
1191     return NULL;
1192 }
1193
1194 static int
1195 mirror_set(struct ofproto *ofproto_, void *aux,
1196            const struct ofproto_mirror_settings *s)
1197 {
1198     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1199     mirror_mask_t mirror_bit;
1200     struct ofbundle *bundle;
1201     struct ofmirror *mirror;
1202     struct ofbundle *out;
1203     struct hmapx srcs;          /* Contains "struct ofbundle *"s. */
1204     struct hmapx dsts;          /* Contains "struct ofbundle *"s. */
1205     int out_vlan;
1206
1207     mirror = mirror_lookup(ofproto, aux);
1208     if (!s) {
1209         mirror_destroy(mirror);
1210         return 0;
1211     }
1212     if (!mirror) {
1213         int idx;
1214
1215         idx = mirror_scan(ofproto);
1216         if (idx < 0) {
1217             VLOG_WARN("bridge %s: maximum of %d port mirrors reached, "
1218                       "cannot create %s",
1219                       ofproto->up.name, MAX_MIRRORS, s->name);
1220             return EFBIG;
1221         }
1222
1223         mirror = ofproto->mirrors[idx] = xzalloc(sizeof *mirror);
1224         mirror->ofproto = ofproto;
1225         mirror->idx = idx;
1226         mirror->out_vlan = -1;
1227         mirror->name = NULL;
1228     }
1229
1230     if (!mirror->name || strcmp(s->name, mirror->name)) {
1231         free(mirror->name);
1232         mirror->name = xstrdup(s->name);
1233     }
1234
1235     /* Get the new configuration. */
1236     if (s->out_bundle) {
1237         out = bundle_lookup(ofproto, s->out_bundle);
1238         if (!out) {
1239             mirror_destroy(mirror);
1240             return EINVAL;
1241         }
1242         out_vlan = -1;
1243     } else {
1244         out = NULL;
1245         out_vlan = s->out_vlan;
1246     }
1247     bundle_lookup_multiple(ofproto, s->srcs, s->n_srcs, &srcs);
1248     bundle_lookup_multiple(ofproto, s->dsts, s->n_dsts, &dsts);
1249
1250     /* If the configuration has not changed, do nothing. */
1251     if (hmapx_equals(&srcs, &mirror->srcs)
1252         && hmapx_equals(&dsts, &mirror->dsts)
1253         && vlan_bitmap_equal(mirror->vlans, s->src_vlans)
1254         && mirror->out == out
1255         && mirror->out_vlan == out_vlan)
1256     {
1257         hmapx_destroy(&srcs);
1258         hmapx_destroy(&dsts);
1259         return 0;
1260     }
1261
1262     hmapx_swap(&srcs, &mirror->srcs);
1263     hmapx_destroy(&srcs);
1264
1265     hmapx_swap(&dsts, &mirror->dsts);
1266     hmapx_destroy(&dsts);
1267
1268     free(mirror->vlans);
1269     mirror->vlans = vlan_bitmap_clone(s->src_vlans);
1270
1271     mirror->out = out;
1272     mirror->out_vlan = out_vlan;
1273
1274     /* Update bundles. */
1275     mirror_bit = MIRROR_MASK_C(1) << mirror->idx;
1276     HMAP_FOR_EACH (bundle, hmap_node, &mirror->ofproto->bundles) {
1277         if (hmapx_contains(&mirror->srcs, bundle)) {
1278             bundle->src_mirrors |= mirror_bit;
1279         } else {
1280             bundle->src_mirrors &= ~mirror_bit;
1281         }
1282
1283         if (hmapx_contains(&mirror->dsts, bundle)) {
1284             bundle->dst_mirrors |= mirror_bit;
1285         } else {
1286             bundle->dst_mirrors &= ~mirror_bit;
1287         }
1288
1289         if (mirror->out == bundle) {
1290             bundle->mirror_out |= mirror_bit;
1291         } else {
1292             bundle->mirror_out &= ~mirror_bit;
1293         }
1294     }
1295
1296     ofproto->need_revalidate = true;
1297     mac_learning_flush(ofproto->ml);
1298
1299     return 0;
1300 }
1301
1302 static void
1303 mirror_destroy(struct ofmirror *mirror)
1304 {
1305     struct ofproto_dpif *ofproto;
1306     mirror_mask_t mirror_bit;
1307     struct ofbundle *bundle;
1308
1309     if (!mirror) {
1310         return;
1311     }
1312
1313     ofproto = mirror->ofproto;
1314     ofproto->need_revalidate = true;
1315     mac_learning_flush(ofproto->ml);
1316
1317     mirror_bit = MIRROR_MASK_C(1) << mirror->idx;
1318     HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
1319         bundle->src_mirrors &= ~mirror_bit;
1320         bundle->dst_mirrors &= ~mirror_bit;
1321         bundle->mirror_out &= ~mirror_bit;
1322     }
1323
1324     hmapx_destroy(&mirror->srcs);
1325     hmapx_destroy(&mirror->dsts);
1326     free(mirror->vlans);
1327
1328     ofproto->mirrors[mirror->idx] = NULL;
1329     free(mirror->name);
1330     free(mirror);
1331 }
1332
1333 static int
1334 set_flood_vlans(struct ofproto *ofproto_, unsigned long *flood_vlans)
1335 {
1336     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1337     if (mac_learning_set_flood_vlans(ofproto->ml, flood_vlans)) {
1338         ofproto->need_revalidate = true;
1339         mac_learning_flush(ofproto->ml);
1340     }
1341     return 0;
1342 }
1343
1344 static bool
1345 is_mirror_output_bundle(struct ofproto *ofproto_, void *aux)
1346 {
1347     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1348     struct ofbundle *bundle = bundle_lookup(ofproto, aux);
1349     return bundle && bundle->mirror_out != 0;
1350 }
1351 \f
1352 /* Ports. */
1353
1354 static struct ofport_dpif *
1355 get_ofp_port(struct ofproto_dpif *ofproto, uint16_t ofp_port)
1356 {
1357     struct ofport *ofport = ofproto_get_port(&ofproto->up, ofp_port);
1358     return ofport ? ofport_dpif_cast(ofport) : NULL;
1359 }
1360
1361 static struct ofport_dpif *
1362 get_odp_port(struct ofproto_dpif *ofproto, uint32_t odp_port)
1363 {
1364     return get_ofp_port(ofproto, odp_port_to_ofp_port(odp_port));
1365 }
1366
1367 static void
1368 ofproto_port_from_dpif_port(struct ofproto_port *ofproto_port,
1369                             struct dpif_port *dpif_port)
1370 {
1371     ofproto_port->name = dpif_port->name;
1372     ofproto_port->type = dpif_port->type;
1373     ofproto_port->ofp_port = odp_port_to_ofp_port(dpif_port->port_no);
1374 }
1375
1376 static void
1377 port_run(struct ofport_dpif *ofport)
1378 {
1379     if (ofport->cfm) {
1380         cfm_run(ofport->cfm);
1381
1382         if (cfm_should_send_ccm(ofport->cfm)) {
1383             struct ofpbuf packet;
1384
1385             ofpbuf_init(&packet, 0);
1386             cfm_compose_ccm(ofport->cfm, &packet, ofport->up.opp.hw_addr);
1387             send_packet(ofproto_dpif_cast(ofport->up.ofproto),
1388                         ofport->odp_port, &packet);
1389             ofpbuf_uninit(&packet);
1390         }
1391     }
1392 }
1393
1394 static void
1395 port_wait(struct ofport_dpif *ofport)
1396 {
1397     if (ofport->cfm) {
1398         cfm_wait(ofport->cfm);
1399     }
1400 }
1401
1402 static int
1403 port_query_by_name(const struct ofproto *ofproto_, const char *devname,
1404                    struct ofproto_port *ofproto_port)
1405 {
1406     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1407     struct dpif_port dpif_port;
1408     int error;
1409
1410     error = dpif_port_query_by_name(ofproto->dpif, devname, &dpif_port);
1411     if (!error) {
1412         ofproto_port_from_dpif_port(ofproto_port, &dpif_port);
1413     }
1414     return error;
1415 }
1416
1417 static int
1418 port_add(struct ofproto *ofproto_, struct netdev *netdev, uint16_t *ofp_portp)
1419 {
1420     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1421     uint16_t odp_port;
1422     int error;
1423
1424     error = dpif_port_add(ofproto->dpif, netdev, &odp_port);
1425     if (!error) {
1426         *ofp_portp = odp_port_to_ofp_port(odp_port);
1427     }
1428     return error;
1429 }
1430
1431 static int
1432 port_del(struct ofproto *ofproto_, uint16_t ofp_port)
1433 {
1434     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1435     int error;
1436
1437     error = dpif_port_del(ofproto->dpif, ofp_port_to_odp_port(ofp_port));
1438     if (!error) {
1439         struct ofport_dpif *ofport = get_ofp_port(ofproto, ofp_port);
1440         if (ofport) {
1441             /* The caller is going to close ofport->up.netdev.  If this is a
1442              * bonded port, then the bond is using that netdev, so remove it
1443              * from the bond.  The client will need to reconfigure everything
1444              * after deleting ports, so then the slave will get re-added. */
1445             bundle_remove(&ofport->up);
1446         }
1447     }
1448     return error;
1449 }
1450
1451 struct port_dump_state {
1452     struct dpif_port_dump dump;
1453     bool done;
1454 };
1455
1456 static int
1457 port_dump_start(const struct ofproto *ofproto_, void **statep)
1458 {
1459     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1460     struct port_dump_state *state;
1461
1462     *statep = state = xmalloc(sizeof *state);
1463     dpif_port_dump_start(&state->dump, ofproto->dpif);
1464     state->done = false;
1465     return 0;
1466 }
1467
1468 static int
1469 port_dump_next(const struct ofproto *ofproto_ OVS_UNUSED, void *state_,
1470                struct ofproto_port *port)
1471 {
1472     struct port_dump_state *state = state_;
1473     struct dpif_port dpif_port;
1474
1475     if (dpif_port_dump_next(&state->dump, &dpif_port)) {
1476         ofproto_port_from_dpif_port(port, &dpif_port);
1477         return 0;
1478     } else {
1479         int error = dpif_port_dump_done(&state->dump);
1480         state->done = true;
1481         return error ? error : EOF;
1482     }
1483 }
1484
1485 static int
1486 port_dump_done(const struct ofproto *ofproto_ OVS_UNUSED, void *state_)
1487 {
1488     struct port_dump_state *state = state_;
1489
1490     if (!state->done) {
1491         dpif_port_dump_done(&state->dump);
1492     }
1493     free(state);
1494     return 0;
1495 }
1496
1497 static int
1498 port_poll(const struct ofproto *ofproto_, char **devnamep)
1499 {
1500     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1501     return dpif_port_poll(ofproto->dpif, devnamep);
1502 }
1503
1504 static void
1505 port_poll_wait(const struct ofproto *ofproto_)
1506 {
1507     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
1508     dpif_port_poll_wait(ofproto->dpif);
1509 }
1510
1511 static int
1512 port_is_lacp_current(const struct ofport *ofport_)
1513 {
1514     const struct ofport_dpif *ofport = ofport_dpif_cast(ofport_);
1515     return (ofport->bundle && ofport->bundle->lacp
1516             ? lacp_slave_is_current(ofport->bundle->lacp, ofport)
1517             : -1);
1518 }
1519 \f
1520 /* Upcall handling. */
1521
1522 /* Given 'upcall', of type DPIF_UC_ACTION or DPIF_UC_MISS, sends an
1523  * OFPT_PACKET_IN message to each OpenFlow controller as necessary according to
1524  * their individual configurations.
1525  *
1526  * If 'clone' is true, the caller retains ownership of 'upcall->packet'.
1527  * Otherwise, ownership is transferred to this function. */
1528 static void
1529 send_packet_in(struct ofproto_dpif *ofproto, struct dpif_upcall *upcall,
1530                const struct flow *flow, bool clone)
1531 {
1532     struct ofputil_packet_in pin;
1533
1534     pin.packet = upcall->packet;
1535     pin.in_port = flow->in_port;
1536     pin.reason = upcall->type == DPIF_UC_MISS ? OFPR_NO_MATCH : OFPR_ACTION;
1537     pin.buffer_id = 0;          /* not yet known */
1538     pin.send_len = upcall->userdata;
1539     connmgr_send_packet_in(ofproto->up.connmgr, &pin, flow,
1540                            clone ? NULL : upcall->packet);
1541 }
1542
1543 static bool
1544 process_special(struct ofproto_dpif *ofproto, const struct flow *flow,
1545                 const struct ofpbuf *packet)
1546 {
1547     if (cfm_should_process_flow(flow)) {
1548         struct ofport_dpif *ofport = get_ofp_port(ofproto, flow->in_port);
1549         if (packet && ofport && ofport->cfm) {
1550             cfm_process_heartbeat(ofport->cfm, packet);
1551         }
1552         return true;
1553     } else if (flow->dl_type == htons(ETH_TYPE_LACP)) {
1554         struct ofport_dpif *port = get_ofp_port(ofproto, flow->in_port);
1555         if (packet && port && port->bundle && port->bundle->lacp) {
1556             const struct lacp_pdu *pdu = parse_lacp_packet(packet);
1557             if (pdu) {
1558                 lacp_process_pdu(port->bundle->lacp, port, pdu);
1559             }
1560         }
1561         return true;
1562     }
1563     return false;
1564 }
1565
1566 static void
1567 handle_miss_upcall(struct ofproto_dpif *ofproto, struct dpif_upcall *upcall)
1568 {
1569     struct facet *facet;
1570     struct flow flow;
1571
1572     /* Obtain in_port and tun_id, at least. */
1573     odp_flow_key_to_flow(upcall->key, upcall->key_len, &flow);
1574
1575     /* Set header pointers in 'flow'. */
1576     flow_extract(upcall->packet, flow.tun_id, flow.in_port, &flow);
1577
1578     /* Handle 802.1ag and LACP. */
1579     if (process_special(ofproto, &flow, upcall->packet)) {
1580         ofpbuf_delete(upcall->packet);
1581         ofproto->n_matches++;
1582         return;
1583     }
1584
1585     /* Check with in-band control to see if this packet should be sent
1586      * to the local port regardless of the flow table. */
1587     if (connmgr_msg_in_hook(ofproto->up.connmgr, &flow, upcall->packet)) {
1588         send_packet(ofproto, ODPP_LOCAL, upcall->packet);
1589     }
1590
1591     facet = facet_lookup_valid(ofproto, &flow);
1592     if (!facet) {
1593         struct rule_dpif *rule = rule_dpif_lookup(ofproto, &flow);
1594         if (!rule) {
1595             /* Don't send a packet-in if OFPPC_NO_PACKET_IN asserted. */
1596             struct ofport_dpif *port = get_ofp_port(ofproto, flow.in_port);
1597             if (port) {
1598                 if (port->up.opp.config & htonl(OFPPC_NO_PACKET_IN)) {
1599                     COVERAGE_INC(ofproto_dpif_no_packet_in);
1600                     /* XXX install 'drop' flow entry */
1601                     ofpbuf_delete(upcall->packet);
1602                     return;
1603                 }
1604             } else {
1605                 VLOG_WARN_RL(&rl, "packet-in on unknown port %"PRIu16,
1606                              flow.in_port);
1607             }
1608
1609             send_packet_in(ofproto, upcall, &flow, false);
1610             return;
1611         }
1612
1613         facet = facet_create(rule, &flow, upcall->packet);
1614     } else if (!facet->may_install) {
1615         /* The facet is not installable, that is, we need to process every
1616          * packet, so process the current packet's actions into 'facet'. */
1617         facet_make_actions(ofproto, facet, upcall->packet);
1618     }
1619
1620     if (facet->rule->up.cr.priority == FAIL_OPEN_PRIORITY) {
1621         /*
1622          * Extra-special case for fail-open mode.
1623          *
1624          * We are in fail-open mode and the packet matched the fail-open rule,
1625          * but we are connected to a controller too.  We should send the packet
1626          * up to the controller in the hope that it will try to set up a flow
1627          * and thereby allow us to exit fail-open.
1628          *
1629          * See the top-level comment in fail-open.c for more information.
1630          */
1631         send_packet_in(ofproto, upcall, &flow, true);
1632     }
1633
1634     facet_execute(ofproto, facet, upcall->packet);
1635     facet_install(ofproto, facet, false);
1636     ofproto->n_matches++;
1637 }
1638
1639 static void
1640 handle_upcall(struct ofproto_dpif *ofproto, struct dpif_upcall *upcall)
1641 {
1642     struct flow flow;
1643
1644     switch (upcall->type) {
1645     case DPIF_UC_ACTION:
1646         COVERAGE_INC(ofproto_dpif_ctlr_action);
1647         odp_flow_key_to_flow(upcall->key, upcall->key_len, &flow);
1648         send_packet_in(ofproto, upcall, &flow, false);
1649         break;
1650
1651     case DPIF_UC_SAMPLE:
1652         if (ofproto->sflow) {
1653             odp_flow_key_to_flow(upcall->key, upcall->key_len, &flow);
1654             ofproto_sflow_received(ofproto->sflow, upcall, &flow);
1655         }
1656         ofpbuf_delete(upcall->packet);
1657         break;
1658
1659     case DPIF_UC_MISS:
1660         handle_miss_upcall(ofproto, upcall);
1661         break;
1662
1663     case DPIF_N_UC_TYPES:
1664     default:
1665         VLOG_WARN_RL(&rl, "upcall has unexpected type %"PRIu32, upcall->type);
1666         break;
1667     }
1668 }
1669 \f
1670 /* Flow expiration. */
1671
1672 static int facet_max_idle(const struct ofproto_dpif *);
1673 static void update_stats(struct ofproto_dpif *);
1674 static void rule_expire(struct rule_dpif *);
1675 static void expire_facets(struct ofproto_dpif *, int dp_max_idle);
1676
1677 /* This function is called periodically by run().  Its job is to collect
1678  * updates for the flows that have been installed into the datapath, most
1679  * importantly when they last were used, and then use that information to
1680  * expire flows that have not been used recently.
1681  *
1682  * Returns the number of milliseconds after which it should be called again. */
1683 static int
1684 expire(struct ofproto_dpif *ofproto)
1685 {
1686     struct rule_dpif *rule, *next_rule;
1687     struct cls_cursor cursor;
1688     int dp_max_idle;
1689
1690     /* Update stats for each flow in the datapath. */
1691     update_stats(ofproto);
1692
1693     /* Expire facets that have been idle too long. */
1694     dp_max_idle = facet_max_idle(ofproto);
1695     expire_facets(ofproto, dp_max_idle);
1696
1697     /* Expire OpenFlow flows whose idle_timeout or hard_timeout has passed. */
1698     cls_cursor_init(&cursor, &ofproto->up.tables[0], NULL);
1699     CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, up.cr, &cursor) {
1700         rule_expire(rule);
1701     }
1702
1703     /* All outstanding data in existing flows has been accounted, so it's a
1704      * good time to do bond rebalancing. */
1705     if (ofproto->has_bonded_bundles) {
1706         struct ofbundle *bundle;
1707
1708         HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
1709             if (bundle->bond) {
1710                 bond_rebalance(bundle->bond, &ofproto->revalidate_set);
1711             }
1712         }
1713     }
1714
1715     return MIN(dp_max_idle, 1000);
1716 }
1717
1718 /* Update 'packet_count', 'byte_count', and 'used' members of installed facets.
1719  *
1720  * This function also pushes statistics updates to rules which each facet
1721  * resubmits into.  Generally these statistics will be accurate.  However, if a
1722  * facet changes the rule it resubmits into at some time in between
1723  * update_stats() runs, it is possible that statistics accrued to the
1724  * old rule will be incorrectly attributed to the new rule.  This could be
1725  * avoided by calling update_stats() whenever rules are created or
1726  * deleted.  However, the performance impact of making so many calls to the
1727  * datapath do not justify the benefit of having perfectly accurate statistics.
1728  */
1729 static void
1730 update_stats(struct ofproto_dpif *p)
1731 {
1732     const struct dpif_flow_stats *stats;
1733     struct dpif_flow_dump dump;
1734     const struct nlattr *key;
1735     size_t key_len;
1736
1737     dpif_flow_dump_start(&dump, p->dpif);
1738     while (dpif_flow_dump_next(&dump, &key, &key_len, NULL, NULL, &stats)) {
1739         struct facet *facet;
1740         struct flow flow;
1741
1742         if (odp_flow_key_to_flow(key, key_len, &flow)) {
1743             struct ds s;
1744
1745             ds_init(&s);
1746             odp_flow_key_format(key, key_len, &s);
1747             VLOG_WARN_RL(&rl, "failed to convert ODP flow key to flow: %s",
1748                          ds_cstr(&s));
1749             ds_destroy(&s);
1750
1751             continue;
1752         }
1753         facet = facet_find(p, &flow);
1754
1755         if (facet && facet->installed) {
1756
1757             if (stats->n_packets >= facet->dp_packet_count) {
1758                 uint64_t extra = stats->n_packets - facet->dp_packet_count;
1759                 facet->packet_count += extra;
1760             } else {
1761                 VLOG_WARN_RL(&rl, "unexpected packet count from the datapath");
1762             }
1763
1764             if (stats->n_bytes >= facet->dp_byte_count) {
1765                 facet->byte_count += stats->n_bytes - facet->dp_byte_count;
1766             } else {
1767                 VLOG_WARN_RL(&rl, "unexpected byte count from datapath");
1768             }
1769
1770             facet->dp_packet_count = stats->n_packets;
1771             facet->dp_byte_count = stats->n_bytes;
1772
1773             facet_update_time(p, facet, stats->used);
1774             facet_account(p, facet, stats->n_bytes);
1775             facet_push_stats(facet);
1776         } else {
1777             /* There's a flow in the datapath that we know nothing about.
1778              * Delete it. */
1779             COVERAGE_INC(facet_unexpected);
1780             dpif_flow_del(p->dpif, key, key_len, NULL);
1781         }
1782     }
1783     dpif_flow_dump_done(&dump);
1784 }
1785
1786 /* Calculates and returns the number of milliseconds of idle time after which
1787  * facets should expire from the datapath and we should fold their statistics
1788  * into their parent rules in userspace. */
1789 static int
1790 facet_max_idle(const struct ofproto_dpif *ofproto)
1791 {
1792     /*
1793      * Idle time histogram.
1794      *
1795      * Most of the time a switch has a relatively small number of facets.  When
1796      * this is the case we might as well keep statistics for all of them in
1797      * userspace and to cache them in the kernel datapath for performance as
1798      * well.
1799      *
1800      * As the number of facets increases, the memory required to maintain
1801      * statistics about them in userspace and in the kernel becomes
1802      * significant.  However, with a large number of facets it is likely that
1803      * only a few of them are "heavy hitters" that consume a large amount of
1804      * bandwidth.  At this point, only heavy hitters are worth caching in the
1805      * kernel and maintaining in userspaces; other facets we can discard.
1806      *
1807      * The technique used to compute the idle time is to build a histogram with
1808      * N_BUCKETS buckets whose width is BUCKET_WIDTH msecs each.  Each facet
1809      * that is installed in the kernel gets dropped in the appropriate bucket.
1810      * After the histogram has been built, we compute the cutoff so that only
1811      * the most-recently-used 1% of facets (but at least 1000 flows) are kept
1812      * cached.  At least the most-recently-used bucket of facets is kept, so
1813      * actually an arbitrary number of facets can be kept in any given
1814      * expiration run (though the next run will delete most of those unless
1815      * they receive additional data).
1816      *
1817      * This requires a second pass through the facets, in addition to the pass
1818      * made by update_stats(), because the former function never looks
1819      * at uninstallable facets.
1820      */
1821     enum { BUCKET_WIDTH = ROUND_UP(100, TIME_UPDATE_INTERVAL) };
1822     enum { N_BUCKETS = 5000 / BUCKET_WIDTH };
1823     int buckets[N_BUCKETS] = { 0 };
1824     struct facet *facet;
1825     int total, bucket;
1826     long long int now;
1827     int i;
1828
1829     total = hmap_count(&ofproto->facets);
1830     if (total <= 1000) {
1831         return N_BUCKETS * BUCKET_WIDTH;
1832     }
1833
1834     /* Build histogram. */
1835     now = time_msec();
1836     HMAP_FOR_EACH (facet, hmap_node, &ofproto->facets) {
1837         long long int idle = now - facet->used;
1838         int bucket = (idle <= 0 ? 0
1839                       : idle >= BUCKET_WIDTH * N_BUCKETS ? N_BUCKETS - 1
1840                       : (unsigned int) idle / BUCKET_WIDTH);
1841         buckets[bucket]++;
1842     }
1843
1844     /* Find the first bucket whose flows should be expired. */
1845     for (bucket = 0; bucket < N_BUCKETS; bucket++) {
1846         if (buckets[bucket]) {
1847             int subtotal = 0;
1848             do {
1849                 subtotal += buckets[bucket++];
1850             } while (bucket < N_BUCKETS && subtotal < MAX(1000, total / 100));
1851             break;
1852         }
1853     }
1854
1855     if (VLOG_IS_DBG_ENABLED()) {
1856         struct ds s;
1857
1858         ds_init(&s);
1859         ds_put_cstr(&s, "keep");
1860         for (i = 0; i < N_BUCKETS; i++) {
1861             if (i == bucket) {
1862                 ds_put_cstr(&s, ", drop");
1863             }
1864             if (buckets[i]) {
1865                 ds_put_format(&s, " %d:%d", i * BUCKET_WIDTH, buckets[i]);
1866             }
1867         }
1868         VLOG_INFO("%s: %s (msec:count)", ofproto->up.name, ds_cstr(&s));
1869         ds_destroy(&s);
1870     }
1871
1872     return bucket * BUCKET_WIDTH;
1873 }
1874
1875 static void
1876 facet_active_timeout(struct ofproto_dpif *ofproto, struct facet *facet)
1877 {
1878     if (ofproto->netflow && !facet_is_controller_flow(facet) &&
1879         netflow_active_timeout_expired(ofproto->netflow, &facet->nf_flow)) {
1880         struct ofexpired expired;
1881
1882         if (facet->installed) {
1883             struct dpif_flow_stats stats;
1884
1885             facet_put__(ofproto, facet, facet->actions, facet->actions_len,
1886                         &stats);
1887             facet_update_stats(ofproto, facet, &stats);
1888         }
1889
1890         expired.flow = facet->flow;
1891         expired.packet_count = facet->packet_count;
1892         expired.byte_count = facet->byte_count;
1893         expired.used = facet->used;
1894         netflow_expire(ofproto->netflow, &facet->nf_flow, &expired);
1895     }
1896 }
1897
1898 static void
1899 expire_facets(struct ofproto_dpif *ofproto, int dp_max_idle)
1900 {
1901     long long int cutoff = time_msec() - dp_max_idle;
1902     struct facet *facet, *next_facet;
1903
1904     HMAP_FOR_EACH_SAFE (facet, next_facet, hmap_node, &ofproto->facets) {
1905         facet_active_timeout(ofproto, facet);
1906         if (facet->used < cutoff) {
1907             facet_remove(ofproto, facet);
1908         }
1909     }
1910 }
1911
1912 /* If 'rule' is an OpenFlow rule, that has expired according to OpenFlow rules,
1913  * then delete it entirely. */
1914 static void
1915 rule_expire(struct rule_dpif *rule)
1916 {
1917     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
1918     struct facet *facet, *next_facet;
1919     long long int now;
1920     uint8_t reason;
1921
1922     /* Has 'rule' expired? */
1923     now = time_msec();
1924     if (rule->up.hard_timeout
1925         && now > rule->up.created + rule->up.hard_timeout * 1000) {
1926         reason = OFPRR_HARD_TIMEOUT;
1927     } else if (rule->up.idle_timeout && list_is_empty(&rule->facets)
1928                && now > rule->used + rule->up.idle_timeout * 1000) {
1929         reason = OFPRR_IDLE_TIMEOUT;
1930     } else {
1931         return;
1932     }
1933
1934     COVERAGE_INC(ofproto_dpif_expired);
1935
1936     /* Update stats.  (This is a no-op if the rule expired due to an idle
1937      * timeout, because that only happens when the rule has no facets left.) */
1938     LIST_FOR_EACH_SAFE (facet, next_facet, list_node, &rule->facets) {
1939         facet_remove(ofproto, facet);
1940     }
1941
1942     /* Get rid of the rule. */
1943     ofproto_rule_expire(&rule->up, reason);
1944 }
1945 \f
1946 /* Facets. */
1947
1948 /* Creates and returns a new facet owned by 'rule', given a 'flow' and an
1949  * example 'packet' within that flow.
1950  *
1951  * The caller must already have determined that no facet with an identical
1952  * 'flow' exists in 'ofproto' and that 'flow' is the best match for 'rule' in
1953  * the ofproto's classifier table. */
1954 static struct facet *
1955 facet_create(struct rule_dpif *rule, const struct flow *flow,
1956              const struct ofpbuf *packet)
1957 {
1958     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
1959     struct facet *facet;
1960
1961     facet = xzalloc(sizeof *facet);
1962     facet->used = time_msec();
1963     hmap_insert(&ofproto->facets, &facet->hmap_node, flow_hash(flow, 0));
1964     list_push_back(&rule->facets, &facet->list_node);
1965     facet->rule = rule;
1966     facet->flow = *flow;
1967     netflow_flow_init(&facet->nf_flow);
1968     netflow_flow_update_time(ofproto->netflow, &facet->nf_flow, facet->used);
1969
1970     facet_make_actions(ofproto, facet, packet);
1971
1972     return facet;
1973 }
1974
1975 static void
1976 facet_free(struct facet *facet)
1977 {
1978     free(facet->actions);
1979     free(facet);
1980 }
1981
1982 /* Executes, within 'ofproto', the 'n_actions' actions in 'actions' on
1983  * 'packet', which arrived on 'in_port'.
1984  *
1985  * Takes ownership of 'packet'. */
1986 static bool
1987 execute_odp_actions(struct ofproto_dpif *ofproto, const struct flow *flow,
1988                     const struct nlattr *odp_actions, size_t actions_len,
1989                     struct ofpbuf *packet)
1990 {
1991     if (actions_len == NLA_ALIGN(NLA_HDRLEN + sizeof(uint64_t))
1992         && odp_actions->nla_type == ODP_ACTION_ATTR_CONTROLLER) {
1993         /* As an optimization, avoid a round-trip from userspace to kernel to
1994          * userspace.  This also avoids possibly filling up kernel packet
1995          * buffers along the way. */
1996         struct dpif_upcall upcall;
1997
1998         upcall.type = DPIF_UC_ACTION;
1999         upcall.packet = packet;
2000         upcall.key = NULL;
2001         upcall.key_len = 0;
2002         upcall.userdata = nl_attr_get_u64(odp_actions);
2003         upcall.sample_pool = 0;
2004         upcall.actions = NULL;
2005         upcall.actions_len = 0;
2006
2007         send_packet_in(ofproto, &upcall, flow, false);
2008
2009         return true;
2010     } else {
2011         struct odputil_keybuf keybuf;
2012         struct ofpbuf key;
2013         int error;
2014
2015         ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
2016         odp_flow_key_from_flow(&key, flow);
2017
2018         error = dpif_execute(ofproto->dpif, key.data, key.size,
2019                              odp_actions, actions_len, packet);
2020
2021         ofpbuf_delete(packet);
2022         return !error;
2023     }
2024 }
2025
2026 /* Executes the actions indicated by 'facet' on 'packet' and credits 'facet''s
2027  * statistics appropriately.  'packet' must have at least sizeof(struct
2028  * ofp_packet_in) bytes of headroom.
2029  *
2030  * For correct results, 'packet' must actually be in 'facet''s flow; that is,
2031  * applying flow_extract() to 'packet' would yield the same flow as
2032  * 'facet->flow'.
2033  *
2034  * 'facet' must have accurately composed ODP actions; that is, it must not be
2035  * in need of revalidation.
2036  *
2037  * Takes ownership of 'packet'. */
2038 static void
2039 facet_execute(struct ofproto_dpif *ofproto, struct facet *facet,
2040               struct ofpbuf *packet)
2041 {
2042     struct dpif_flow_stats stats;
2043
2044     assert(ofpbuf_headroom(packet) >= sizeof(struct ofp_packet_in));
2045
2046     flow_extract_stats(&facet->flow, packet, &stats);
2047     stats.used = time_msec();
2048     if (execute_odp_actions(ofproto, &facet->flow,
2049                             facet->actions, facet->actions_len, packet)) {
2050         facet_update_stats(ofproto, facet, &stats);
2051     }
2052 }
2053
2054 /* Remove 'facet' from 'ofproto' and free up the associated memory:
2055  *
2056  *   - If 'facet' was installed in the datapath, uninstalls it and updates its
2057  *     rule's statistics, via facet_uninstall().
2058  *
2059  *   - Removes 'facet' from its rule and from ofproto->facets.
2060  */
2061 static void
2062 facet_remove(struct ofproto_dpif *ofproto, struct facet *facet)
2063 {
2064     facet_uninstall(ofproto, facet);
2065     facet_flush_stats(ofproto, facet);
2066     hmap_remove(&ofproto->facets, &facet->hmap_node);
2067     list_remove(&facet->list_node);
2068     facet_free(facet);
2069 }
2070
2071 /* Composes the ODP actions for 'facet' based on its rule's actions. */
2072 static void
2073 facet_make_actions(struct ofproto_dpif *p, struct facet *facet,
2074                    const struct ofpbuf *packet)
2075 {
2076     const struct rule_dpif *rule = facet->rule;
2077     struct ofpbuf *odp_actions;
2078     struct action_xlate_ctx ctx;
2079
2080     action_xlate_ctx_init(&ctx, p, &facet->flow, packet);
2081     odp_actions = xlate_actions(&ctx, rule->up.actions, rule->up.n_actions);
2082     facet->tags = ctx.tags;
2083     facet->may_install = ctx.may_set_up_flow;
2084     facet->nf_flow.output_iface = ctx.nf_output_iface;
2085
2086     if (facet->actions_len != odp_actions->size
2087         || memcmp(facet->actions, odp_actions->data, odp_actions->size)) {
2088         free(facet->actions);
2089         facet->actions_len = odp_actions->size;
2090         facet->actions = xmemdup(odp_actions->data, odp_actions->size);
2091     }
2092
2093     ofpbuf_delete(odp_actions);
2094 }
2095
2096 /* Updates 'facet''s flow in the datapath setting its actions to 'actions_len'
2097  * bytes of actions in 'actions'.  If 'stats' is non-null, statistics counters
2098  * in the datapath will be zeroed and 'stats' will be updated with traffic new
2099  * since 'facet' was last updated.
2100  *
2101  * Returns 0 if successful, otherwise a positive errno value.*/
2102 static int
2103 facet_put__(struct ofproto_dpif *ofproto, struct facet *facet,
2104             const struct nlattr *actions, size_t actions_len,
2105             struct dpif_flow_stats *stats)
2106 {
2107     struct odputil_keybuf keybuf;
2108     enum dpif_flow_put_flags flags;
2109     struct ofpbuf key;
2110     int ret;
2111
2112     flags = DPIF_FP_CREATE | DPIF_FP_MODIFY;
2113     if (stats) {
2114         flags |= DPIF_FP_ZERO_STATS;
2115     }
2116
2117     ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
2118     odp_flow_key_from_flow(&key, &facet->flow);
2119
2120     ret = dpif_flow_put(ofproto->dpif, flags, key.data, key.size,
2121                         actions, actions_len, stats);
2122
2123     if (stats) {
2124         facet_reset_dp_stats(facet, stats);
2125     }
2126
2127     return ret;
2128 }
2129
2130 /* If 'facet' is installable, inserts or re-inserts it into 'p''s datapath.  If
2131  * 'zero_stats' is true, clears any existing statistics from the datapath for
2132  * 'facet'. */
2133 static void
2134 facet_install(struct ofproto_dpif *p, struct facet *facet, bool zero_stats)
2135 {
2136     struct dpif_flow_stats stats;
2137
2138     if (facet->may_install
2139         && !facet_put__(p, facet, facet->actions, facet->actions_len,
2140                         zero_stats ? &stats : NULL)) {
2141         facet->installed = true;
2142     }
2143 }
2144
2145 static int
2146 vlan_tci_to_openflow_vlan(ovs_be16 vlan_tci)
2147 {
2148     return vlan_tci != htons(0) ? vlan_tci_to_vid(vlan_tci) : OFP_VLAN_NONE;
2149 }
2150
2151 static void
2152 facet_account(struct ofproto_dpif *ofproto,
2153               struct facet *facet, uint64_t extra_bytes)
2154 {
2155     uint64_t total_bytes, n_bytes;
2156     struct ofbundle *in_bundle;
2157     const struct nlattr *a;
2158     tag_type dummy = 0;
2159     unsigned int left;
2160     ovs_be16 vlan_tci;
2161     int vlan;
2162
2163     total_bytes = facet->byte_count + extra_bytes;
2164     if (total_bytes <= facet->accounted_bytes) {
2165         return;
2166     }
2167     n_bytes = total_bytes - facet->accounted_bytes;
2168     facet->accounted_bytes = total_bytes;
2169
2170     /* Test that 'tags' is nonzero to ensure that only flows that include an
2171      * OFPP_NORMAL action are used for learning and bond slave rebalancing.
2172      * This works because OFPP_NORMAL always sets a nonzero tag value.
2173      *
2174      * Feed information from the active flows back into the learning table to
2175      * ensure that table is always in sync with what is actually flowing
2176      * through the datapath. */
2177     if (!facet->tags
2178         || !is_admissible(ofproto, &facet->flow, false, &dummy,
2179                           &vlan, &in_bundle)) {
2180         return;
2181     }
2182
2183     update_learning_table(ofproto, &facet->flow, vlan, in_bundle);
2184
2185     if (!ofproto->has_bonded_bundles) {
2186         return;
2187     }
2188
2189     /* This loop feeds byte counters to bond_account() for rebalancing to use
2190      * as a basis.  We also need to track the actual VLAN on which the packet
2191      * is going to be sent to ensure that it matches the one passed to
2192      * bond_choose_output_slave().  (Otherwise, we will account to the wrong
2193      * hash bucket.) */
2194     vlan_tci = facet->flow.vlan_tci;
2195     NL_ATTR_FOR_EACH_UNSAFE (a, left, facet->actions, facet->actions_len) {
2196         struct ofport_dpif *port;
2197
2198         switch (nl_attr_type(a)) {
2199         case ODP_ACTION_ATTR_OUTPUT:
2200             port = get_odp_port(ofproto, nl_attr_get_u32(a));
2201             if (port && port->bundle && port->bundle->bond) {
2202                 bond_account(port->bundle->bond, &facet->flow,
2203                              vlan_tci_to_openflow_vlan(vlan_tci), n_bytes);
2204             }
2205             break;
2206
2207         case ODP_ACTION_ATTR_STRIP_VLAN:
2208             vlan_tci = htons(0);
2209             break;
2210
2211         case ODP_ACTION_ATTR_SET_DL_TCI:
2212             vlan_tci = nl_attr_get_be16(a);
2213             break;
2214         }
2215     }
2216 }
2217
2218 /* If 'rule' is installed in the datapath, uninstalls it. */
2219 static void
2220 facet_uninstall(struct ofproto_dpif *p, struct facet *facet)
2221 {
2222     if (facet->installed) {
2223         struct odputil_keybuf keybuf;
2224         struct dpif_flow_stats stats;
2225         struct ofpbuf key;
2226         int error;
2227
2228         ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
2229         odp_flow_key_from_flow(&key, &facet->flow);
2230
2231         error = dpif_flow_del(p->dpif, key.data, key.size, &stats);
2232         facet_reset_dp_stats(facet, &stats);
2233         if (!error) {
2234             facet_update_stats(p, facet, &stats);
2235         }
2236         facet->installed = false;
2237     } else {
2238         assert(facet->dp_packet_count == 0);
2239         assert(facet->dp_byte_count == 0);
2240     }
2241 }
2242
2243 /* Returns true if the only action for 'facet' is to send to the controller.
2244  * (We don't report NetFlow expiration messages for such facets because they
2245  * are just part of the control logic for the network, not real traffic). */
2246 static bool
2247 facet_is_controller_flow(struct facet *facet)
2248 {
2249     return (facet
2250             && facet->rule->up.n_actions == 1
2251             && action_outputs_to_port(&facet->rule->up.actions[0],
2252                                       htons(OFPP_CONTROLLER)));
2253 }
2254
2255 /* Resets 'facet''s datapath statistics counters.  This should be called when
2256  * 'facet''s statistics are cleared in the datapath.  If 'stats' is non-null,
2257  * it should contain the statistics returned by dpif when 'facet' was reset in
2258  * the datapath.  'stats' will be modified to only included statistics new
2259  * since 'facet' was last updated. */
2260 static void
2261 facet_reset_dp_stats(struct facet *facet, struct dpif_flow_stats *stats)
2262 {
2263     if (stats && facet->dp_packet_count <= stats->n_packets
2264         && facet->dp_byte_count <= stats->n_bytes) {
2265         stats->n_packets -= facet->dp_packet_count;
2266         stats->n_bytes -= facet->dp_byte_count;
2267     }
2268
2269     facet->dp_packet_count = 0;
2270     facet->dp_byte_count = 0;
2271 }
2272
2273 /* Folds all of 'facet''s statistics into its rule.  Also updates the
2274  * accounting ofhook and emits a NetFlow expiration if appropriate.  All of
2275  * 'facet''s statistics in the datapath should have been zeroed and folded into
2276  * its packet and byte counts before this function is called. */
2277 static void
2278 facet_flush_stats(struct ofproto_dpif *ofproto, struct facet *facet)
2279 {
2280     assert(!facet->dp_byte_count);
2281     assert(!facet->dp_packet_count);
2282
2283     facet_push_stats(facet);
2284     facet_account(ofproto, facet, 0);
2285
2286     if (ofproto->netflow && !facet_is_controller_flow(facet)) {
2287         struct ofexpired expired;
2288         expired.flow = facet->flow;
2289         expired.packet_count = facet->packet_count;
2290         expired.byte_count = facet->byte_count;
2291         expired.used = facet->used;
2292         netflow_expire(ofproto->netflow, &facet->nf_flow, &expired);
2293     }
2294
2295     facet->rule->packet_count += facet->packet_count;
2296     facet->rule->byte_count += facet->byte_count;
2297
2298     /* Reset counters to prevent double counting if 'facet' ever gets
2299      * reinstalled. */
2300     facet->packet_count = 0;
2301     facet->byte_count = 0;
2302     facet->rs_packet_count = 0;
2303     facet->rs_byte_count = 0;
2304     facet->accounted_bytes = 0;
2305
2306     netflow_flow_clear(&facet->nf_flow);
2307 }
2308
2309 /* Searches 'ofproto''s table of facets for one exactly equal to 'flow'.
2310  * Returns it if found, otherwise a null pointer.
2311  *
2312  * The returned facet might need revalidation; use facet_lookup_valid()
2313  * instead if that is important. */
2314 static struct facet *
2315 facet_find(struct ofproto_dpif *ofproto, const struct flow *flow)
2316 {
2317     struct facet *facet;
2318
2319     HMAP_FOR_EACH_WITH_HASH (facet, hmap_node, flow_hash(flow, 0),
2320                              &ofproto->facets) {
2321         if (flow_equal(flow, &facet->flow)) {
2322             return facet;
2323         }
2324     }
2325
2326     return NULL;
2327 }
2328
2329 /* Searches 'ofproto''s table of facets for one exactly equal to 'flow'.
2330  * Returns it if found, otherwise a null pointer.
2331  *
2332  * The returned facet is guaranteed to be valid. */
2333 static struct facet *
2334 facet_lookup_valid(struct ofproto_dpif *ofproto, const struct flow *flow)
2335 {
2336     struct facet *facet = facet_find(ofproto, flow);
2337
2338     /* The facet we found might not be valid, since we could be in need of
2339      * revalidation.  If it is not valid, don't return it. */
2340     if (facet
2341         && ofproto->need_revalidate
2342         && !facet_revalidate(ofproto, facet)) {
2343         COVERAGE_INC(facet_invalidated);
2344         return NULL;
2345     }
2346
2347     return facet;
2348 }
2349
2350 /* Re-searches 'ofproto''s classifier for a rule matching 'facet':
2351  *
2352  *   - If the rule found is different from 'facet''s current rule, moves
2353  *     'facet' to the new rule and recompiles its actions.
2354  *
2355  *   - If the rule found is the same as 'facet''s current rule, leaves 'facet'
2356  *     where it is and recompiles its actions anyway.
2357  *
2358  *   - If there is none, destroys 'facet'.
2359  *
2360  * Returns true if 'facet' still exists, false if it has been destroyed. */
2361 static bool
2362 facet_revalidate(struct ofproto_dpif *ofproto, struct facet *facet)
2363 {
2364     struct action_xlate_ctx ctx;
2365     struct ofpbuf *odp_actions;
2366     struct rule_dpif *new_rule;
2367     bool actions_changed;
2368
2369     COVERAGE_INC(facet_revalidate);
2370
2371     /* Determine the new rule. */
2372     new_rule = rule_dpif_lookup(ofproto, &facet->flow);
2373     if (!new_rule) {
2374         /* No new rule, so delete the facet. */
2375         facet_remove(ofproto, facet);
2376         return false;
2377     }
2378
2379     /* Calculate new ODP actions.
2380      *
2381      * We do not modify any 'facet' state yet, because we might need to, e.g.,
2382      * emit a NetFlow expiration and, if so, we need to have the old state
2383      * around to properly compose it. */
2384     action_xlate_ctx_init(&ctx, ofproto, &facet->flow, NULL);
2385     odp_actions = xlate_actions(&ctx,
2386                                 new_rule->up.actions, new_rule->up.n_actions);
2387     actions_changed = (facet->actions_len != odp_actions->size
2388                        || memcmp(facet->actions, odp_actions->data,
2389                                  facet->actions_len));
2390
2391     /* If the ODP actions changed or the installability changed, then we need
2392      * to talk to the datapath. */
2393     if (actions_changed || ctx.may_set_up_flow != facet->installed) {
2394         if (ctx.may_set_up_flow) {
2395             struct dpif_flow_stats stats;
2396
2397             facet_put__(ofproto, facet,
2398                         odp_actions->data, odp_actions->size, &stats);
2399             facet_update_stats(ofproto, facet, &stats);
2400         } else {
2401             facet_uninstall(ofproto, facet);
2402         }
2403
2404         /* The datapath flow is gone or has zeroed stats, so push stats out of
2405          * 'facet' into 'rule'. */
2406         facet_flush_stats(ofproto, facet);
2407     }
2408
2409     /* Update 'facet' now that we've taken care of all the old state. */
2410     facet->tags = ctx.tags;
2411     facet->nf_flow.output_iface = ctx.nf_output_iface;
2412     facet->may_install = ctx.may_set_up_flow;
2413     if (actions_changed) {
2414         free(facet->actions);
2415         facet->actions_len = odp_actions->size;
2416         facet->actions = xmemdup(odp_actions->data, odp_actions->size);
2417     }
2418     if (facet->rule != new_rule) {
2419         COVERAGE_INC(facet_changed_rule);
2420         list_remove(&facet->list_node);
2421         list_push_back(&new_rule->facets, &facet->list_node);
2422         facet->rule = new_rule;
2423         facet->used = new_rule->up.created;
2424         facet->rs_used = facet->used;
2425     }
2426
2427     ofpbuf_delete(odp_actions);
2428
2429     return true;
2430 }
2431
2432 /* Updates 'facet''s used time.  Caller is responsible for calling
2433  * facet_push_stats() to update the flows which 'facet' resubmits into. */
2434 static void
2435 facet_update_time(struct ofproto_dpif *ofproto, struct facet *facet,
2436                   long long int used)
2437 {
2438     if (used > facet->used) {
2439         facet->used = used;
2440         if (used > facet->rule->used) {
2441             facet->rule->used = used;
2442         }
2443         netflow_flow_update_time(ofproto->netflow, &facet->nf_flow, used);
2444     }
2445 }
2446
2447 /* Folds the statistics from 'stats' into the counters in 'facet'.
2448  *
2449  * Because of the meaning of a facet's counters, it only makes sense to do this
2450  * if 'stats' are not tracked in the datapath, that is, if 'stats' represents a
2451  * packet that was sent by hand or if it represents statistics that have been
2452  * cleared out of the datapath. */
2453 static void
2454 facet_update_stats(struct ofproto_dpif *ofproto, struct facet *facet,
2455                    const struct dpif_flow_stats *stats)
2456 {
2457     if (stats->n_packets || stats->used > facet->used) {
2458         facet_update_time(ofproto, facet, stats->used);
2459         facet->packet_count += stats->n_packets;
2460         facet->byte_count += stats->n_bytes;
2461         facet_push_stats(facet);
2462         netflow_flow_update_flags(&facet->nf_flow, stats->tcp_flags);
2463     }
2464 }
2465
2466 static void
2467 facet_push_stats(struct facet *facet)
2468 {
2469     uint64_t rs_packets, rs_bytes;
2470
2471     assert(facet->packet_count >= facet->rs_packet_count);
2472     assert(facet->byte_count >= facet->rs_byte_count);
2473     assert(facet->used >= facet->rs_used);
2474
2475     rs_packets = facet->packet_count - facet->rs_packet_count;
2476     rs_bytes = facet->byte_count - facet->rs_byte_count;
2477
2478     if (rs_packets || rs_bytes || facet->used > facet->rs_used) {
2479         facet->rs_packet_count = facet->packet_count;
2480         facet->rs_byte_count = facet->byte_count;
2481         facet->rs_used = facet->used;
2482
2483         flow_push_stats(facet->rule, &facet->flow,
2484                         rs_packets, rs_bytes, facet->used);
2485     }
2486 }
2487
2488 struct ofproto_push {
2489     struct action_xlate_ctx ctx;
2490     uint64_t packets;
2491     uint64_t bytes;
2492     long long int used;
2493 };
2494
2495 static void
2496 push_resubmit(struct action_xlate_ctx *ctx, struct rule_dpif *rule)
2497 {
2498     struct ofproto_push *push = CONTAINER_OF(ctx, struct ofproto_push, ctx);
2499
2500     if (rule) {
2501         rule->packet_count += push->packets;
2502         rule->byte_count += push->bytes;
2503         rule->used = MAX(push->used, rule->used);
2504     }
2505 }
2506
2507 /* Pushes flow statistics to the rules which 'flow' resubmits into given
2508  * 'rule''s actions. */
2509 static void
2510 flow_push_stats(const struct rule_dpif *rule,
2511                 struct flow *flow, uint64_t packets, uint64_t bytes,
2512                 long long int used)
2513 {
2514     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
2515     struct ofproto_push push;
2516
2517     push.packets = packets;
2518     push.bytes = bytes;
2519     push.used = used;
2520
2521     action_xlate_ctx_init(&push.ctx, ofproto, flow, NULL);
2522     push.ctx.resubmit_hook = push_resubmit;
2523     ofpbuf_delete(xlate_actions(&push.ctx,
2524                                 rule->up.actions, rule->up.n_actions));
2525 }
2526 \f
2527 /* Rules. */
2528
2529 static struct rule_dpif *
2530 rule_dpif_lookup(struct ofproto_dpif *ofproto, const struct flow *flow)
2531 {
2532     return rule_dpif_cast(rule_from_cls_rule(
2533                               classifier_lookup(&ofproto->up.tables[0],
2534                                                 flow)));
2535 }
2536
2537 static struct rule *
2538 rule_alloc(void)
2539 {
2540     struct rule_dpif *rule = xmalloc(sizeof *rule);
2541     return &rule->up;
2542 }
2543
2544 static void
2545 rule_dealloc(struct rule *rule_)
2546 {
2547     struct rule_dpif *rule = rule_dpif_cast(rule_);
2548     free(rule);
2549 }
2550
2551 static int
2552 rule_construct(struct rule *rule_)
2553 {
2554     struct rule_dpif *rule = rule_dpif_cast(rule_);
2555     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
2556     struct rule_dpif *old_rule;
2557     int error;
2558
2559     error = validate_actions(rule->up.actions, rule->up.n_actions,
2560                              &rule->up.cr.flow, ofproto->max_ports);
2561     if (error) {
2562         return error;
2563     }
2564
2565     old_rule = rule_dpif_cast(rule_from_cls_rule(classifier_find_rule_exactly(
2566                                                      &ofproto->up.tables[0],
2567                                                      &rule->up.cr)));
2568     if (old_rule) {
2569         ofproto_rule_destroy(&old_rule->up);
2570     }
2571
2572     rule->used = rule->up.created;
2573     rule->packet_count = 0;
2574     rule->byte_count = 0;
2575     list_init(&rule->facets);
2576     classifier_insert(&ofproto->up.tables[0], &rule->up.cr);
2577
2578     ofproto->need_revalidate = true;
2579
2580     return 0;
2581 }
2582
2583 static void
2584 rule_destruct(struct rule *rule_)
2585 {
2586     struct rule_dpif *rule = rule_dpif_cast(rule_);
2587     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
2588     struct facet *facet, *next_facet;
2589
2590     classifier_remove(&ofproto->up.tables[0], &rule->up.cr);
2591     LIST_FOR_EACH_SAFE (facet, next_facet, list_node, &rule->facets) {
2592         facet_revalidate(ofproto, facet);
2593     }
2594     ofproto->need_revalidate = true;
2595 }
2596
2597 static void
2598 rule_get_stats(struct rule *rule_, uint64_t *packets, uint64_t *bytes)
2599 {
2600     struct rule_dpif *rule = rule_dpif_cast(rule_);
2601     struct facet *facet;
2602
2603     /* Start from historical data for 'rule' itself that are no longer tracked
2604      * in facets.  This counts, for example, facets that have expired. */
2605     *packets = rule->packet_count;
2606     *bytes = rule->byte_count;
2607
2608     /* Add any statistics that are tracked by facets.  This includes
2609      * statistical data recently updated by ofproto_update_stats() as well as
2610      * stats for packets that were executed "by hand" via dpif_execute(). */
2611     LIST_FOR_EACH (facet, list_node, &rule->facets) {
2612         *packets += facet->packet_count;
2613         *bytes += facet->byte_count;
2614     }
2615 }
2616
2617 static int
2618 rule_execute(struct rule *rule_, struct flow *flow, struct ofpbuf *packet)
2619 {
2620     struct rule_dpif *rule = rule_dpif_cast(rule_);
2621     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
2622     struct action_xlate_ctx ctx;
2623     struct ofpbuf *odp_actions;
2624     struct facet *facet;
2625     size_t size;
2626
2627     /* First look for a related facet.  If we find one, account it to that. */
2628     facet = facet_lookup_valid(ofproto, flow);
2629     if (facet && facet->rule == rule) {
2630         facet_execute(ofproto, facet, packet);
2631         return 0;
2632     }
2633
2634     /* Otherwise, if 'rule' is in fact the correct rule for 'packet', then
2635      * create a new facet for it and use that. */
2636     if (rule_dpif_lookup(ofproto, flow) == rule) {
2637         facet = facet_create(rule, flow, packet);
2638         facet_execute(ofproto, facet, packet);
2639         facet_install(ofproto, facet, true);
2640         return 0;
2641     }
2642
2643     /* We can't account anything to a facet.  If we were to try, then that
2644      * facet would have a non-matching rule, busting our invariants. */
2645     action_xlate_ctx_init(&ctx, ofproto, flow, packet);
2646     odp_actions = xlate_actions(&ctx, rule->up.actions, rule->up.n_actions);
2647     size = packet->size;
2648     if (execute_odp_actions(ofproto, flow, odp_actions->data,
2649                             odp_actions->size, packet)) {
2650         rule->used = time_msec();
2651         rule->packet_count++;
2652         rule->byte_count += size;
2653         flow_push_stats(rule, flow, 1, size, rule->used);
2654     }
2655     ofpbuf_delete(odp_actions);
2656
2657     return 0;
2658 }
2659
2660 static int
2661 rule_modify_actions(struct rule *rule_,
2662                     const union ofp_action *actions, size_t n_actions)
2663 {
2664     struct rule_dpif *rule = rule_dpif_cast(rule_);
2665     struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto);
2666     int error;
2667
2668     error = validate_actions(actions, n_actions, &rule->up.cr.flow,
2669                              ofproto->max_ports);
2670     if (!error) {
2671         ofproto->need_revalidate = true;
2672     }
2673     return error;
2674 }
2675 \f
2676 /* Sends 'packet' out of port 'odp_port' within 'p'.
2677  * Returns 0 if successful, otherwise a positive errno value. */
2678 static int
2679 send_packet(struct ofproto_dpif *ofproto, uint32_t odp_port,
2680             const struct ofpbuf *packet)
2681 {
2682     struct ofpbuf key, odp_actions;
2683     struct odputil_keybuf keybuf;
2684     struct flow flow;
2685     int error;
2686
2687     flow_extract((struct ofpbuf *) packet, 0, 0, &flow);
2688     ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
2689     odp_flow_key_from_flow(&key, &flow);
2690
2691     ofpbuf_init(&odp_actions, 32);
2692     nl_msg_put_u32(&odp_actions, ODP_ACTION_ATTR_OUTPUT, odp_port);
2693     error = dpif_execute(ofproto->dpif,
2694                          key.data, key.size,
2695                          odp_actions.data, odp_actions.size,
2696                          packet);
2697     ofpbuf_uninit(&odp_actions);
2698
2699     if (error) {
2700         VLOG_WARN_RL(&rl, "%s: failed to send packet on port %"PRIu32" (%s)",
2701                      ofproto->up.name, odp_port, strerror(error));
2702     }
2703     return error;
2704 }
2705 \f
2706 /* OpenFlow to ODP action translation. */
2707
2708 static void do_xlate_actions(const union ofp_action *in, size_t n_in,
2709                              struct action_xlate_ctx *ctx);
2710 static bool xlate_normal(struct action_xlate_ctx *);
2711
2712 static void
2713 commit_odp_actions(struct action_xlate_ctx *ctx)
2714 {
2715     const struct flow *flow = &ctx->flow;
2716     struct flow *base = &ctx->base_flow;
2717     struct ofpbuf *odp_actions = ctx->odp_actions;
2718
2719     if (base->tun_id != flow->tun_id) {
2720         nl_msg_put_be64(odp_actions, ODP_ACTION_ATTR_SET_TUNNEL, flow->tun_id);
2721         base->tun_id = flow->tun_id;
2722     }
2723
2724     if (base->nw_src != flow->nw_src) {
2725         nl_msg_put_be32(odp_actions, ODP_ACTION_ATTR_SET_NW_SRC, flow->nw_src);
2726         base->nw_src = flow->nw_src;
2727     }
2728
2729     if (base->nw_dst != flow->nw_dst) {
2730         nl_msg_put_be32(odp_actions, ODP_ACTION_ATTR_SET_NW_DST, flow->nw_dst);
2731         base->nw_dst = flow->nw_dst;
2732     }
2733
2734     if (base->vlan_tci != flow->vlan_tci) {
2735         if (!(flow->vlan_tci & htons(VLAN_CFI))) {
2736             nl_msg_put_flag(odp_actions, ODP_ACTION_ATTR_STRIP_VLAN);
2737         } else {
2738             nl_msg_put_be16(odp_actions, ODP_ACTION_ATTR_SET_DL_TCI,
2739                             flow->vlan_tci & ~htons(VLAN_CFI));
2740         }
2741         base->vlan_tci = flow->vlan_tci;
2742     }
2743
2744     if (base->tp_src != flow->tp_src) {
2745         nl_msg_put_be16(odp_actions, ODP_ACTION_ATTR_SET_TP_SRC, flow->tp_src);
2746         base->tp_src = flow->tp_src;
2747     }
2748
2749     if (base->tp_dst != flow->tp_dst) {
2750         nl_msg_put_be16(odp_actions, ODP_ACTION_ATTR_SET_TP_DST, flow->tp_dst);
2751         base->tp_dst = flow->tp_dst;
2752     }
2753
2754     if (!eth_addr_equals(base->dl_src, flow->dl_src)) {
2755         nl_msg_put_unspec(odp_actions, ODP_ACTION_ATTR_SET_DL_SRC,
2756                           flow->dl_src, ETH_ADDR_LEN);
2757         memcpy(base->dl_src, flow->dl_src, ETH_ADDR_LEN);
2758     }
2759
2760     if (!eth_addr_equals(base->dl_dst, flow->dl_dst)) {
2761         nl_msg_put_unspec(odp_actions, ODP_ACTION_ATTR_SET_DL_DST,
2762                           flow->dl_dst, ETH_ADDR_LEN);
2763         memcpy(base->dl_dst, flow->dl_dst, ETH_ADDR_LEN);
2764     }
2765
2766     if (ctx->base_priority != ctx->priority) {
2767         if (ctx->priority) {
2768             nl_msg_put_u32(odp_actions, ODP_ACTION_ATTR_SET_PRIORITY,
2769                            ctx->priority);
2770         } else {
2771             nl_msg_put_flag(odp_actions, ODP_ACTION_ATTR_POP_PRIORITY);
2772         }
2773         ctx->base_priority = ctx->priority;
2774     }
2775 }
2776
2777 static void
2778 add_output_action(struct action_xlate_ctx *ctx, uint16_t ofp_port)
2779 {
2780     const struct ofport_dpif *ofport = get_ofp_port(ctx->ofproto, ofp_port);
2781     uint16_t odp_port = ofp_port_to_odp_port(ofp_port);
2782
2783     if (ofport) {
2784         if (ofport->up.opp.config & htonl(OFPPC_NO_FWD)) {
2785             /* Forwarding disabled on port. */
2786             return;
2787         }
2788     } else {
2789         /*
2790          * We don't have an ofport record for this port, but it doesn't hurt to
2791          * allow forwarding to it anyhow.  Maybe such a port will appear later
2792          * and we're pre-populating the flow table.
2793          */
2794     }
2795
2796     commit_odp_actions(ctx);
2797     nl_msg_put_u32(ctx->odp_actions, ODP_ACTION_ATTR_OUTPUT, odp_port);
2798     ctx->nf_output_iface = ofp_port;
2799 }
2800
2801 static void
2802 xlate_table_action(struct action_xlate_ctx *ctx, uint16_t in_port)
2803 {
2804     if (ctx->recurse < MAX_RESUBMIT_RECURSION) {
2805         struct rule_dpif *rule;
2806         uint16_t old_in_port;
2807
2808         /* Look up a flow with 'in_port' as the input port.  Then restore the
2809          * original input port (otherwise OFPP_NORMAL and OFPP_IN_PORT will
2810          * have surprising behavior). */
2811         old_in_port = ctx->flow.in_port;
2812         ctx->flow.in_port = in_port;
2813         rule = rule_dpif_lookup(ctx->ofproto, &ctx->flow);
2814         ctx->flow.in_port = old_in_port;
2815
2816         if (ctx->resubmit_hook) {
2817             ctx->resubmit_hook(ctx, rule);
2818         }
2819
2820         if (rule) {
2821             ctx->recurse++;
2822             do_xlate_actions(rule->up.actions, rule->up.n_actions, ctx);
2823             ctx->recurse--;
2824         }
2825     } else {
2826         static struct vlog_rate_limit recurse_rl = VLOG_RATE_LIMIT_INIT(1, 1);
2827
2828         VLOG_ERR_RL(&recurse_rl, "NXAST_RESUBMIT recursed over %d times",
2829                     MAX_RESUBMIT_RECURSION);
2830     }
2831 }
2832
2833 static void
2834 flood_packets(struct action_xlate_ctx *ctx, ovs_be32 mask)
2835 {
2836     struct ofport_dpif *ofport;
2837
2838     commit_odp_actions(ctx);
2839     HMAP_FOR_EACH (ofport, up.hmap_node, &ctx->ofproto->up.ports) {
2840         uint16_t ofp_port = ofport->up.ofp_port;
2841         if (ofp_port != ctx->flow.in_port && !(ofport->up.opp.config & mask)) {
2842             nl_msg_put_u32(ctx->odp_actions, ODP_ACTION_ATTR_OUTPUT,
2843                            ofport->odp_port);
2844         }
2845     }
2846
2847     ctx->nf_output_iface = NF_OUT_FLOOD;
2848 }
2849
2850 static void
2851 xlate_output_action__(struct action_xlate_ctx *ctx,
2852                       uint16_t port, uint16_t max_len)
2853 {
2854     uint16_t prev_nf_output_iface = ctx->nf_output_iface;
2855
2856     ctx->nf_output_iface = NF_OUT_DROP;
2857
2858     switch (port) {
2859     case OFPP_IN_PORT:
2860         add_output_action(ctx, ctx->flow.in_port);
2861         break;
2862     case OFPP_TABLE:
2863         xlate_table_action(ctx, ctx->flow.in_port);
2864         break;
2865     case OFPP_NORMAL:
2866         xlate_normal(ctx);
2867         break;
2868     case OFPP_FLOOD:
2869         flood_packets(ctx,  htonl(OFPPC_NO_FLOOD));
2870         break;
2871     case OFPP_ALL:
2872         flood_packets(ctx, htonl(0));
2873         break;
2874     case OFPP_CONTROLLER:
2875         commit_odp_actions(ctx);
2876         nl_msg_put_u64(ctx->odp_actions, ODP_ACTION_ATTR_CONTROLLER, max_len);
2877         break;
2878     case OFPP_LOCAL:
2879         add_output_action(ctx, OFPP_LOCAL);
2880         break;
2881     default:
2882         if (port != ctx->flow.in_port) {
2883             add_output_action(ctx, port);
2884         }
2885         break;
2886     }
2887
2888     if (prev_nf_output_iface == NF_OUT_FLOOD) {
2889         ctx->nf_output_iface = NF_OUT_FLOOD;
2890     } else if (ctx->nf_output_iface == NF_OUT_DROP) {
2891         ctx->nf_output_iface = prev_nf_output_iface;
2892     } else if (prev_nf_output_iface != NF_OUT_DROP &&
2893                ctx->nf_output_iface != NF_OUT_FLOOD) {
2894         ctx->nf_output_iface = NF_OUT_MULTI;
2895     }
2896 }
2897
2898 static void
2899 xlate_output_action(struct action_xlate_ctx *ctx,
2900                     const struct ofp_action_output *oao)
2901 {
2902     xlate_output_action__(ctx, ntohs(oao->port), ntohs(oao->max_len));
2903 }
2904
2905 static void
2906 xlate_enqueue_action(struct action_xlate_ctx *ctx,
2907                      const struct ofp_action_enqueue *oae)
2908 {
2909     uint16_t ofp_port, odp_port;
2910     uint32_t ctx_priority, priority;
2911     int error;
2912
2913     error = dpif_queue_to_priority(ctx->ofproto->dpif, ntohl(oae->queue_id),
2914                                    &priority);
2915     if (error) {
2916         /* Fall back to ordinary output action. */
2917         xlate_output_action__(ctx, ntohs(oae->port), 0);
2918         return;
2919     }
2920
2921     /* Figure out ODP output port. */
2922     ofp_port = ntohs(oae->port);
2923     if (ofp_port == OFPP_IN_PORT) {
2924         ofp_port = ctx->flow.in_port;
2925     }
2926     odp_port = ofp_port_to_odp_port(ofp_port);
2927
2928     /* Add ODP actions. */
2929     ctx_priority = ctx->priority;
2930     ctx->priority = priority;
2931     add_output_action(ctx, odp_port);
2932     ctx->priority = ctx_priority;
2933
2934     /* Update NetFlow output port. */
2935     if (ctx->nf_output_iface == NF_OUT_DROP) {
2936         ctx->nf_output_iface = odp_port;
2937     } else if (ctx->nf_output_iface != NF_OUT_FLOOD) {
2938         ctx->nf_output_iface = NF_OUT_MULTI;
2939     }
2940 }
2941
2942 static void
2943 xlate_set_queue_action(struct action_xlate_ctx *ctx,
2944                        const struct nx_action_set_queue *nasq)
2945 {
2946     uint32_t priority;
2947     int error;
2948
2949     error = dpif_queue_to_priority(ctx->ofproto->dpif, ntohl(nasq->queue_id),
2950                                    &priority);
2951     if (error) {
2952         /* Couldn't translate queue to a priority, so ignore.  A warning
2953          * has already been logged. */
2954         return;
2955     }
2956
2957     ctx->priority = priority;
2958 }
2959
2960 struct xlate_reg_state {
2961     ovs_be16 vlan_tci;
2962     ovs_be64 tun_id;
2963 };
2964
2965 static void
2966 xlate_autopath(struct action_xlate_ctx *ctx,
2967                const struct nx_action_autopath *naa)
2968 {
2969     uint16_t ofp_port = ntohl(naa->id);
2970     struct ofport_dpif *port = get_ofp_port(ctx->ofproto, ofp_port);
2971
2972     if (!port || !port->bundle) {
2973         ofp_port = OFPP_NONE;
2974     } else if (port->bundle->bond) {
2975         /* Autopath does not support VLAN hashing. */
2976         struct ofport_dpif *slave = bond_choose_output_slave(
2977             port->bundle->bond, &ctx->flow, OFP_VLAN_NONE, &ctx->tags);
2978         if (slave) {
2979             ofp_port = slave->up.ofp_port;
2980         }
2981     }
2982     autopath_execute(naa, &ctx->flow, ofp_port);
2983 }
2984
2985 static void
2986 xlate_nicira_action(struct action_xlate_ctx *ctx,
2987                     const struct nx_action_header *nah)
2988 {
2989     const struct nx_action_resubmit *nar;
2990     const struct nx_action_set_tunnel *nast;
2991     const struct nx_action_set_queue *nasq;
2992     const struct nx_action_multipath *nam;
2993     const struct nx_action_autopath *naa;
2994     enum nx_action_subtype subtype = ntohs(nah->subtype);
2995     ovs_be64 tun_id;
2996
2997     assert(nah->vendor == htonl(NX_VENDOR_ID));
2998     switch (subtype) {
2999     case NXAST_RESUBMIT:
3000         nar = (const struct nx_action_resubmit *) nah;
3001         xlate_table_action(ctx, ntohs(nar->in_port));
3002         break;
3003
3004     case NXAST_SET_TUNNEL:
3005         nast = (const struct nx_action_set_tunnel *) nah;
3006         tun_id = htonll(ntohl(nast->tun_id));
3007         ctx->flow.tun_id = tun_id;
3008         break;
3009
3010     case NXAST_SET_QUEUE:
3011         nasq = (const struct nx_action_set_queue *) nah;
3012         xlate_set_queue_action(ctx, nasq);
3013         break;
3014
3015     case NXAST_POP_QUEUE:
3016         ctx->priority = 0;
3017         break;
3018
3019     case NXAST_REG_MOVE:
3020         nxm_execute_reg_move((const struct nx_action_reg_move *) nah,
3021                              &ctx->flow);
3022         break;
3023
3024     case NXAST_REG_LOAD:
3025         nxm_execute_reg_load((const struct nx_action_reg_load *) nah,
3026                              &ctx->flow);
3027         break;
3028
3029     case NXAST_NOTE:
3030         /* Nothing to do. */
3031         break;
3032
3033     case NXAST_SET_TUNNEL64:
3034         tun_id = ((const struct nx_action_set_tunnel64 *) nah)->tun_id;
3035         ctx->flow.tun_id = tun_id;
3036         break;
3037
3038     case NXAST_MULTIPATH:
3039         nam = (const struct nx_action_multipath *) nah;
3040         multipath_execute(nam, &ctx->flow);
3041         break;
3042
3043     case NXAST_AUTOPATH:
3044         naa = (const struct nx_action_autopath *) nah;
3045         xlate_autopath(ctx, naa);
3046         break;
3047
3048     /* If you add a new action here that modifies flow data, don't forget to
3049      * update the flow key in ctx->flow at the same time. */
3050
3051     case NXAST_SNAT__OBSOLETE:
3052     case NXAST_DROP_SPOOFED_ARP__OBSOLETE:
3053     default:
3054         VLOG_DBG_RL(&rl, "unknown Nicira action type %d", (int) subtype);
3055         break;
3056     }
3057 }
3058
3059 static void
3060 do_xlate_actions(const union ofp_action *in, size_t n_in,
3061                  struct action_xlate_ctx *ctx)
3062 {
3063     const struct ofport_dpif *port;
3064     struct actions_iterator iter;
3065     const union ofp_action *ia;
3066
3067     port = get_ofp_port(ctx->ofproto, ctx->flow.in_port);
3068     if (port
3069         && port->up.opp.config & htonl(OFPPC_NO_RECV | OFPPC_NO_RECV_STP) &&
3070         port->up.opp.config & (eth_addr_equals(ctx->flow.dl_dst, eth_addr_stp)
3071                                ? htonl(OFPPC_NO_RECV_STP)
3072                                : htonl(OFPPC_NO_RECV))) {
3073         /* Drop this flow. */
3074         return;
3075     }
3076
3077     for (ia = actions_first(&iter, in, n_in); ia; ia = actions_next(&iter)) {
3078         enum ofp_action_type type = ntohs(ia->type);
3079         const struct ofp_action_dl_addr *oada;
3080
3081         switch (type) {
3082         case OFPAT_OUTPUT:
3083             xlate_output_action(ctx, &ia->output);
3084             break;
3085
3086         case OFPAT_SET_VLAN_VID:
3087             ctx->flow.vlan_tci &= ~htons(VLAN_VID_MASK);
3088             ctx->flow.vlan_tci |= ia->vlan_vid.vlan_vid | htons(VLAN_CFI);
3089             break;
3090
3091         case OFPAT_SET_VLAN_PCP:
3092             ctx->flow.vlan_tci &= ~htons(VLAN_PCP_MASK);
3093             ctx->flow.vlan_tci |= htons(
3094                 (ia->vlan_pcp.vlan_pcp << VLAN_PCP_SHIFT) | VLAN_CFI);
3095             break;
3096
3097         case OFPAT_STRIP_VLAN:
3098             ctx->flow.vlan_tci = htons(0);
3099             break;
3100
3101         case OFPAT_SET_DL_SRC:
3102             oada = ((struct ofp_action_dl_addr *) ia);
3103             memcpy(ctx->flow.dl_src, oada->dl_addr, ETH_ADDR_LEN);
3104             break;
3105
3106         case OFPAT_SET_DL_DST:
3107             oada = ((struct ofp_action_dl_addr *) ia);
3108             memcpy(ctx->flow.dl_dst, oada->dl_addr, ETH_ADDR_LEN);
3109             break;
3110
3111         case OFPAT_SET_NW_SRC:
3112             ctx->flow.nw_src = ia->nw_addr.nw_addr;
3113             break;
3114
3115         case OFPAT_SET_NW_DST:
3116             ctx->flow.nw_dst = ia->nw_addr.nw_addr;
3117             break;
3118
3119         case OFPAT_SET_NW_TOS:
3120             ctx->flow.nw_tos = ia->nw_tos.nw_tos;
3121             break;
3122
3123         case OFPAT_SET_TP_SRC:
3124             ctx->flow.tp_src = ia->tp_port.tp_port;
3125             break;
3126
3127         case OFPAT_SET_TP_DST:
3128             ctx->flow.tp_dst = ia->tp_port.tp_port;
3129             break;
3130
3131         case OFPAT_VENDOR:
3132             xlate_nicira_action(ctx, (const struct nx_action_header *) ia);
3133             break;
3134
3135         case OFPAT_ENQUEUE:
3136             xlate_enqueue_action(ctx, (const struct ofp_action_enqueue *) ia);
3137             break;
3138
3139         default:
3140             VLOG_DBG_RL(&rl, "unknown action type %d", (int) type);
3141             break;
3142         }
3143     }
3144 }
3145
3146 static void
3147 action_xlate_ctx_init(struct action_xlate_ctx *ctx,
3148                       struct ofproto_dpif *ofproto, const struct flow *flow,
3149                       const struct ofpbuf *packet)
3150 {
3151     ctx->ofproto = ofproto;
3152     ctx->flow = *flow;
3153     ctx->packet = packet;
3154     ctx->resubmit_hook = NULL;
3155 }
3156
3157 static struct ofpbuf *
3158 xlate_actions(struct action_xlate_ctx *ctx,
3159               const union ofp_action *in, size_t n_in)
3160 {
3161     COVERAGE_INC(ofproto_dpif_xlate);
3162
3163     ctx->odp_actions = ofpbuf_new(512);
3164     ctx->tags = 0;
3165     ctx->may_set_up_flow = true;
3166     ctx->nf_output_iface = NF_OUT_DROP;
3167     ctx->recurse = 0;
3168     ctx->priority = 0;
3169     ctx->base_priority = 0;
3170     ctx->base_flow = ctx->flow;
3171
3172     if (process_special(ctx->ofproto, &ctx->flow, ctx->packet)) {
3173         ctx->may_set_up_flow = false;
3174     } else {
3175         do_xlate_actions(in, n_in, ctx);
3176     }
3177
3178     /* Check with in-band control to see if we're allowed to set up this
3179      * flow. */
3180     if (!connmgr_may_set_up_flow(ctx->ofproto->up.connmgr, &ctx->flow,
3181                                  ctx->odp_actions->data,
3182                                  ctx->odp_actions->size)) {
3183         ctx->may_set_up_flow = false;
3184     }
3185
3186     return ctx->odp_actions;
3187 }
3188 \f
3189 /* OFPP_NORMAL implementation. */
3190
3191 struct dst {
3192     struct ofport_dpif *port;
3193     uint16_t vlan;
3194 };
3195
3196 struct dst_set {
3197     struct dst builtin[32];
3198     struct dst *dsts;
3199     size_t n, allocated;
3200 };
3201
3202 static void dst_set_init(struct dst_set *);
3203 static void dst_set_add(struct dst_set *, const struct dst *);
3204 static void dst_set_free(struct dst_set *);
3205
3206 static struct ofport_dpif *ofbundle_get_a_port(const struct ofbundle *);
3207
3208 static bool
3209 set_dst(struct action_xlate_ctx *ctx, struct dst *dst,
3210         const struct ofbundle *in_bundle, const struct ofbundle *out_bundle)
3211 {
3212     dst->vlan = (out_bundle->vlan >= 0 ? OFP_VLAN_NONE
3213                  : in_bundle->vlan >= 0 ? in_bundle->vlan
3214                  : ctx->flow.vlan_tci == 0 ? OFP_VLAN_NONE
3215                  : vlan_tci_to_vid(ctx->flow.vlan_tci));
3216
3217     dst->port = (!out_bundle->bond
3218                  ? ofbundle_get_a_port(out_bundle)
3219                  : bond_choose_output_slave(out_bundle->bond, &ctx->flow,
3220                                             dst->vlan, &ctx->tags));
3221
3222     return dst->port != NULL;
3223 }
3224
3225 static int
3226 mirror_mask_ffs(mirror_mask_t mask)
3227 {
3228     BUILD_ASSERT_DECL(sizeof(unsigned int) >= sizeof(mask));
3229     return ffs(mask);
3230 }
3231
3232 static void
3233 dst_set_init(struct dst_set *set)
3234 {
3235     set->dsts = set->builtin;
3236     set->n = 0;
3237     set->allocated = ARRAY_SIZE(set->builtin);
3238 }
3239
3240 static void
3241 dst_set_add(struct dst_set *set, const struct dst *dst)
3242 {
3243     if (set->n >= set->allocated) {
3244         size_t new_allocated;
3245         struct dst *new_dsts;
3246
3247         new_allocated = set->allocated * 2;
3248         new_dsts = xmalloc(new_allocated * sizeof *new_dsts);
3249         memcpy(new_dsts, set->dsts, set->n * sizeof *new_dsts);
3250
3251         dst_set_free(set);
3252
3253         set->dsts = new_dsts;
3254         set->allocated = new_allocated;
3255     }
3256     set->dsts[set->n++] = *dst;
3257 }
3258
3259 static void
3260 dst_set_free(struct dst_set *set)
3261 {
3262     if (set->dsts != set->builtin) {
3263         free(set->dsts);
3264     }
3265 }
3266
3267 static bool
3268 dst_is_duplicate(const struct dst_set *set, const struct dst *test)
3269 {
3270     size_t i;
3271     for (i = 0; i < set->n; i++) {
3272         if (set->dsts[i].vlan == test->vlan
3273             && set->dsts[i].port == test->port) {
3274             return true;
3275         }
3276     }
3277     return false;
3278 }
3279
3280 static bool
3281 ofbundle_trunks_vlan(const struct ofbundle *bundle, uint16_t vlan)
3282 {
3283     return bundle->vlan < 0 && vlan_bitmap_contains(bundle->trunks, vlan);
3284 }
3285
3286 static bool
3287 ofbundle_includes_vlan(const struct ofbundle *bundle, uint16_t vlan)
3288 {
3289     return vlan == bundle->vlan || ofbundle_trunks_vlan(bundle, vlan);
3290 }
3291
3292 /* Returns an arbitrary interface within 'bundle'. */
3293 static struct ofport_dpif *
3294 ofbundle_get_a_port(const struct ofbundle *bundle)
3295 {
3296     return CONTAINER_OF(list_front(&bundle->ports),
3297                         struct ofport_dpif, bundle_node);
3298 }
3299
3300 static void
3301 compose_dsts(struct action_xlate_ctx *ctx, uint16_t vlan,
3302              const struct ofbundle *in_bundle,
3303              const struct ofbundle *out_bundle, struct dst_set *set)
3304 {
3305     struct dst dst;
3306
3307     if (out_bundle == OFBUNDLE_FLOOD) {
3308         struct ofbundle *bundle;
3309
3310         HMAP_FOR_EACH (bundle, hmap_node, &ctx->ofproto->bundles) {
3311             if (bundle != in_bundle
3312                 && ofbundle_includes_vlan(bundle, vlan)
3313                 && bundle->floodable
3314                 && !bundle->mirror_out
3315                 && set_dst(ctx, &dst, in_bundle, bundle)) {
3316                 dst_set_add(set, &dst);
3317             }
3318         }
3319         ctx->nf_output_iface = NF_OUT_FLOOD;
3320     } else if (out_bundle && set_dst(ctx, &dst, in_bundle, out_bundle)) {
3321         dst_set_add(set, &dst);
3322         ctx->nf_output_iface = dst.port->odp_port;
3323     }
3324 }
3325
3326 static bool
3327 vlan_is_mirrored(const struct ofmirror *m, int vlan)
3328 {
3329     return vlan_bitmap_contains(m->vlans, vlan);
3330 }
3331
3332 static void
3333 compose_mirror_dsts(struct action_xlate_ctx *ctx,
3334                     uint16_t vlan, const struct ofbundle *in_bundle,
3335                     struct dst_set *set)
3336 {
3337     struct ofproto_dpif *ofproto = ctx->ofproto;
3338     mirror_mask_t mirrors;
3339     int flow_vlan;
3340     size_t i;
3341
3342     mirrors = in_bundle->src_mirrors;
3343     for (i = 0; i < set->n; i++) {
3344         mirrors |= set->dsts[i].port->bundle->dst_mirrors;
3345     }
3346
3347     if (!mirrors) {
3348         return;
3349     }
3350
3351     flow_vlan = vlan_tci_to_vid(ctx->flow.vlan_tci);
3352     if (flow_vlan == 0) {
3353         flow_vlan = OFP_VLAN_NONE;
3354     }
3355
3356     while (mirrors) {
3357         struct ofmirror *m = ofproto->mirrors[mirror_mask_ffs(mirrors) - 1];
3358         if (vlan_is_mirrored(m, vlan)) {
3359             struct dst dst;
3360
3361             if (m->out) {
3362                 if (set_dst(ctx, &dst, in_bundle, m->out)
3363                     && !dst_is_duplicate(set, &dst)) {
3364                     dst_set_add(set, &dst);
3365                 }
3366             } else {
3367                 struct ofbundle *bundle;
3368
3369                 HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) {
3370                     if (ofbundle_includes_vlan(bundle, m->out_vlan)
3371                         && set_dst(ctx, &dst, in_bundle, bundle))
3372                     {
3373                         if (bundle->vlan < 0) {
3374                             dst.vlan = m->out_vlan;
3375                         }
3376                         if (dst_is_duplicate(set, &dst)) {
3377                             continue;
3378                         }
3379
3380                         /* Use the vlan tag on the original flow instead of
3381                          * the one passed in the vlan parameter.  This ensures
3382                          * that we compare the vlan from before any implicit
3383                          * tagging tags place. This is necessary because
3384                          * dst->vlan is the final vlan, after removing implicit
3385                          * tags. */
3386                         if (bundle == in_bundle && dst.vlan == flow_vlan) {
3387                             /* Don't send out input port on same VLAN. */
3388                             continue;
3389                         }
3390                         dst_set_add(set, &dst);
3391                     }
3392                 }
3393             }
3394         }
3395         mirrors &= mirrors - 1;
3396     }
3397 }
3398
3399 static void
3400 compose_actions(struct action_xlate_ctx *ctx, uint16_t vlan,
3401                 const struct ofbundle *in_bundle,
3402                 const struct ofbundle *out_bundle)
3403 {
3404     uint16_t initial_vlan, cur_vlan;
3405     const struct dst *dst;
3406     struct dst_set set;
3407
3408     dst_set_init(&set);
3409     compose_dsts(ctx, vlan, in_bundle, out_bundle, &set);
3410     compose_mirror_dsts(ctx, vlan, in_bundle, &set);
3411
3412     /* Output all the packets we can without having to change the VLAN. */
3413     initial_vlan = vlan_tci_to_vid(ctx->flow.vlan_tci);
3414     if (initial_vlan == 0) {
3415         initial_vlan = OFP_VLAN_NONE;
3416     }
3417     for (dst = set.dsts; dst < &set.dsts[set.n]; dst++) {
3418         if (dst->vlan != initial_vlan) {
3419             continue;
3420         }
3421         nl_msg_put_u32(ctx->odp_actions,
3422                        ODP_ACTION_ATTR_OUTPUT, dst->port->odp_port);
3423     }
3424
3425     /* Then output the rest. */
3426     cur_vlan = initial_vlan;
3427     for (dst = set.dsts; dst < &set.dsts[set.n]; dst++) {
3428         if (dst->vlan == initial_vlan) {
3429             continue;
3430         }
3431         if (dst->vlan != cur_vlan) {
3432             if (dst->vlan == OFP_VLAN_NONE) {
3433                 nl_msg_put_flag(ctx->odp_actions, ODP_ACTION_ATTR_STRIP_VLAN);
3434             } else {
3435                 ovs_be16 tci;
3436                 tci = htons(dst->vlan & VLAN_VID_MASK);
3437                 tci |= ctx->flow.vlan_tci & htons(VLAN_PCP_MASK);
3438                 nl_msg_put_be16(ctx->odp_actions,
3439                                 ODP_ACTION_ATTR_SET_DL_TCI, tci);
3440             }
3441             cur_vlan = dst->vlan;
3442         }
3443         nl_msg_put_u32(ctx->odp_actions,
3444                        ODP_ACTION_ATTR_OUTPUT, dst->port->odp_port);
3445     }
3446
3447     dst_set_free(&set);
3448 }
3449
3450 /* Returns the effective vlan of a packet, taking into account both the
3451  * 802.1Q header and implicitly tagged ports.  A value of 0 indicates that
3452  * the packet is untagged and -1 indicates it has an invalid header and
3453  * should be dropped. */
3454 static int
3455 flow_get_vlan(struct ofproto_dpif *ofproto, const struct flow *flow,
3456               struct ofbundle *in_bundle, bool have_packet)
3457 {
3458     int vlan = vlan_tci_to_vid(flow->vlan_tci);
3459     if (in_bundle->vlan >= 0) {
3460         if (vlan) {
3461             if (have_packet) {
3462                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
3463                 VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %d tagged "
3464                              "packet received on port %s configured with "
3465                              "implicit VLAN %"PRIu16,
3466                              ofproto->up.name, vlan,
3467                              in_bundle->name, in_bundle->vlan);
3468             }
3469             return -1;
3470         }
3471         vlan = in_bundle->vlan;
3472     } else {
3473         if (!ofbundle_includes_vlan(in_bundle, vlan)) {
3474             if (have_packet) {
3475                 static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
3476                 VLOG_WARN_RL(&rl, "bridge %s: dropping VLAN %d tagged "
3477                              "packet received on port %s not configured for "
3478                              "trunking VLAN %d",
3479                              ofproto->up.name, vlan, in_bundle->name, vlan);
3480             }
3481             return -1;
3482         }
3483     }
3484
3485     return vlan;
3486 }
3487
3488 /* A VM broadcasts a gratuitous ARP to indicate that it has resumed after
3489  * migration.  Older Citrix-patched Linux DomU used gratuitous ARP replies to
3490  * indicate this; newer upstream kernels use gratuitous ARP requests. */
3491 static bool
3492 is_gratuitous_arp(const struct flow *flow)
3493 {
3494     return (flow->dl_type == htons(ETH_TYPE_ARP)
3495             && eth_addr_is_broadcast(flow->dl_dst)
3496             && (flow->nw_proto == ARP_OP_REPLY
3497                 || (flow->nw_proto == ARP_OP_REQUEST
3498                     && flow->nw_src == flow->nw_dst)));
3499 }
3500
3501 static void
3502 update_learning_table(struct ofproto_dpif *ofproto,
3503                       const struct flow *flow, int vlan,
3504                       struct ofbundle *in_bundle)
3505 {
3506     struct mac_entry *mac;
3507
3508     if (!mac_learning_may_learn(ofproto->ml, flow->dl_src, vlan)) {
3509         return;
3510     }
3511
3512     mac = mac_learning_insert(ofproto->ml, flow->dl_src, vlan);
3513     if (is_gratuitous_arp(flow)) {
3514         /* We don't want to learn from gratuitous ARP packets that are
3515          * reflected back over bond slaves so we lock the learning table. */
3516         if (!in_bundle->bond) {
3517             mac_entry_set_grat_arp_lock(mac);
3518         } else if (mac_entry_is_grat_arp_locked(mac)) {
3519             return;
3520         }
3521     }
3522
3523     if (mac_entry_is_new(mac) || mac->port.p != in_bundle) {
3524         /* The log messages here could actually be useful in debugging,
3525          * so keep the rate limit relatively high. */
3526         static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(30, 300);
3527         VLOG_DBG_RL(&rl, "bridge %s: learned that "ETH_ADDR_FMT" is "
3528                     "on port %s in VLAN %d",
3529                     ofproto->up.name, ETH_ADDR_ARGS(flow->dl_src),
3530                     in_bundle->name, vlan);
3531
3532         mac->port.p = in_bundle;
3533         tag_set_add(&ofproto->revalidate_set,
3534                     mac_learning_changed(ofproto->ml, mac));
3535     }
3536 }
3537
3538 /* Determines whether packets in 'flow' within 'br' should be forwarded or
3539  * dropped.  Returns true if they may be forwarded, false if they should be
3540  * dropped.
3541  *
3542  * If 'have_packet' is true, it indicates that the caller is processing a
3543  * received packet.  If 'have_packet' is false, then the caller is just
3544  * revalidating an existing flow because configuration has changed.  Either
3545  * way, 'have_packet' only affects logging (there is no point in logging errors
3546  * during revalidation).
3547  *
3548  * Sets '*in_portp' to the input port.  This will be a null pointer if
3549  * flow->in_port does not designate a known input port (in which case
3550  * is_admissible() returns false).
3551  *
3552  * When returning true, sets '*vlanp' to the effective VLAN of the input
3553  * packet, as returned by flow_get_vlan().
3554  *
3555  * May also add tags to '*tags', although the current implementation only does
3556  * so in one special case.
3557  */
3558 static bool
3559 is_admissible(struct ofproto_dpif *ofproto, const struct flow *flow,
3560               bool have_packet,
3561               tag_type *tags, int *vlanp, struct ofbundle **in_bundlep)
3562 {
3563     struct ofport_dpif *in_port;
3564     struct ofbundle *in_bundle;
3565     int vlan;
3566
3567     /* Find the port and bundle for the received packet. */
3568     in_port = get_ofp_port(ofproto, flow->in_port);
3569     *in_bundlep = in_bundle = in_port ? in_port->bundle : NULL;
3570     if (!in_port || !in_bundle) {
3571         /* No interface?  Something fishy... */
3572         if (have_packet) {
3573             /* Odd.  A few possible reasons here:
3574              *
3575              * - We deleted a port but there are still a few packets queued up
3576              *   from it.
3577              *
3578              * - Someone externally added a port (e.g. "ovs-dpctl add-if") that
3579              *   we don't know about.
3580              *
3581              * - Packet arrived on the local port but the local port is not
3582              *   part of a bundle.
3583              */
3584             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
3585
3586             VLOG_WARN_RL(&rl, "bridge %s: received packet on unknown "
3587                          "port %"PRIu16,
3588                          ofproto->up.name, flow->in_port);
3589         }
3590         return false;
3591     }
3592     *vlanp = vlan = flow_get_vlan(ofproto, flow, in_bundle, have_packet);
3593     if (vlan < 0) {
3594         return false;
3595     }
3596
3597     /* Drop frames for reserved multicast addresses. */
3598     if (eth_addr_is_reserved(flow->dl_dst)) {
3599         return false;
3600     }
3601
3602     /* Drop frames on bundles reserved for mirroring. */
3603     if (in_bundle->mirror_out) {
3604         if (have_packet) {
3605             static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5);
3606             VLOG_WARN_RL(&rl, "bridge %s: dropping packet received on port "
3607                          "%s, which is reserved exclusively for mirroring",
3608                          ofproto->up.name, in_bundle->name);
3609         }
3610         return false;
3611     }
3612
3613     if (in_bundle->bond) {
3614         struct mac_entry *mac;
3615
3616         switch (bond_check_admissibility(in_bundle->bond, in_port,
3617                                          flow->dl_dst, tags)) {
3618         case BV_ACCEPT:
3619             break;
3620
3621         case BV_DROP:
3622             return false;
3623
3624         case BV_DROP_IF_MOVED:
3625             mac = mac_learning_lookup(ofproto->ml, flow->dl_src, vlan, NULL);
3626             if (mac && mac->port.p != in_bundle &&
3627                 (!is_gratuitous_arp(flow)
3628                  || mac_entry_is_grat_arp_locked(mac))) {
3629                 return false;
3630             }
3631             break;
3632         }
3633     }
3634
3635     return true;
3636 }
3637
3638 /* If the composed actions may be applied to any packet in the given 'flow',
3639  * returns true.  Otherwise, the actions should only be applied to 'packet', or
3640  * not at all, if 'packet' was NULL. */
3641 static bool
3642 xlate_normal(struct action_xlate_ctx *ctx)
3643 {
3644     struct ofbundle *in_bundle;
3645     struct ofbundle *out_bundle;
3646     struct mac_entry *mac;
3647     int vlan;
3648
3649     /* Check whether we should drop packets in this flow. */
3650     if (!is_admissible(ctx->ofproto, &ctx->flow, ctx->packet != NULL,
3651                        &ctx->tags, &vlan, &in_bundle)) {
3652         out_bundle = NULL;
3653         goto done;
3654     }
3655
3656     /* Learn source MAC (but don't try to learn from revalidation). */
3657     if (ctx->packet) {
3658         update_learning_table(ctx->ofproto, &ctx->flow, vlan, in_bundle);
3659     }
3660
3661     /* Determine output bundle. */
3662     mac = mac_learning_lookup(ctx->ofproto->ml, ctx->flow.dl_dst, vlan,
3663                               &ctx->tags);
3664     if (mac) {
3665         out_bundle = mac->port.p;
3666     } else if (!ctx->packet && !eth_addr_is_multicast(ctx->flow.dl_dst)) {
3667         /* If we are revalidating but don't have a learning entry then eject
3668          * the flow.  Installing a flow that floods packets opens up a window
3669          * of time where we could learn from a packet reflected on a bond and
3670          * blackhole packets before the learning table is updated to reflect
3671          * the correct port. */
3672         return false;
3673     } else {
3674         out_bundle = OFBUNDLE_FLOOD;
3675     }
3676
3677     /* Don't send packets out their input bundles. */
3678     if (in_bundle == out_bundle) {
3679         out_bundle = NULL;
3680     }
3681
3682 done:
3683     if (in_bundle) {
3684         compose_actions(ctx, vlan, in_bundle, out_bundle);
3685     }
3686
3687     return true;
3688 }
3689 \f
3690 static bool
3691 get_drop_frags(struct ofproto *ofproto_)
3692 {
3693     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3694     bool drop_frags;
3695
3696     dpif_get_drop_frags(ofproto->dpif, &drop_frags);
3697     return drop_frags;
3698 }
3699
3700 static void
3701 set_drop_frags(struct ofproto *ofproto_, bool drop_frags)
3702 {
3703     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3704
3705     dpif_set_drop_frags(ofproto->dpif, drop_frags);
3706 }
3707
3708 static int
3709 packet_out(struct ofproto *ofproto_, struct ofpbuf *packet,
3710            const struct flow *flow,
3711            const union ofp_action *ofp_actions, size_t n_ofp_actions)
3712 {
3713     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3714     int error;
3715
3716     error = validate_actions(ofp_actions, n_ofp_actions, flow,
3717                              ofproto->max_ports);
3718     if (!error) {
3719         struct odputil_keybuf keybuf;
3720         struct action_xlate_ctx ctx;
3721         struct ofpbuf *odp_actions;
3722         struct ofpbuf key;
3723
3724         ofpbuf_use_stack(&key, &keybuf, sizeof keybuf);
3725         odp_flow_key_from_flow(&key, flow);
3726
3727         action_xlate_ctx_init(&ctx, ofproto, flow, packet);
3728         odp_actions = xlate_actions(&ctx, ofp_actions, n_ofp_actions);
3729         dpif_execute(ofproto->dpif, key.data, key.size,
3730                      odp_actions->data, odp_actions->size, packet);
3731         ofpbuf_delete(odp_actions);
3732     }
3733     return error;
3734 }
3735
3736 static void
3737 get_netflow_ids(const struct ofproto *ofproto_,
3738                 uint8_t *engine_type, uint8_t *engine_id)
3739 {
3740     struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_);
3741
3742     dpif_get_netflow_ids(ofproto->dpif, engine_type, engine_id);
3743 }
3744 \f
3745 static struct ofproto_dpif *
3746 ofproto_dpif_lookup(const char *name)
3747 {
3748     struct ofproto *ofproto = ofproto_lookup(name);
3749     return (ofproto && ofproto->ofproto_class == &ofproto_dpif_class
3750             ? ofproto_dpif_cast(ofproto)
3751             : NULL);
3752 }
3753
3754 static void
3755 ofproto_unixctl_fdb_show(struct unixctl_conn *conn,
3756                          const char *args, void *aux OVS_UNUSED)
3757 {
3758     struct ds ds = DS_EMPTY_INITIALIZER;
3759     const struct ofproto_dpif *ofproto;
3760     const struct mac_entry *e;
3761
3762     ofproto = ofproto_dpif_lookup(args);
3763     if (!ofproto) {
3764         unixctl_command_reply(conn, 501, "no such bridge");
3765         return;
3766     }
3767
3768     ds_put_cstr(&ds, " port  VLAN  MAC                Age\n");
3769     LIST_FOR_EACH (e, lru_node, &ofproto->ml->lrus) {
3770         struct ofbundle *bundle = e->port.p;
3771         ds_put_format(&ds, "%5d  %4d  "ETH_ADDR_FMT"  %3d\n",
3772                       ofbundle_get_a_port(bundle)->odp_port,
3773                       e->vlan, ETH_ADDR_ARGS(e->mac), mac_entry_age(e));
3774     }
3775     unixctl_command_reply(conn, 200, ds_cstr(&ds));
3776     ds_destroy(&ds);
3777 }
3778
3779 struct ofproto_trace {
3780     struct action_xlate_ctx ctx;
3781     struct flow flow;
3782     struct ds *result;
3783 };
3784
3785 static void
3786 trace_format_rule(struct ds *result, int level, const struct rule *rule)
3787 {
3788     ds_put_char_multiple(result, '\t', level);
3789     if (!rule) {
3790         ds_put_cstr(result, "No match\n");
3791         return;
3792     }
3793
3794     ds_put_format(result, "Rule: cookie=%#"PRIx64" ",
3795                   ntohll(rule->flow_cookie));
3796     cls_rule_format(&rule->cr, result);
3797     ds_put_char(result, '\n');
3798
3799     ds_put_char_multiple(result, '\t', level);
3800     ds_put_cstr(result, "OpenFlow ");
3801     ofp_print_actions(result, (const struct ofp_action_header *) rule->actions,
3802                       rule->n_actions * sizeof *rule->actions);
3803     ds_put_char(result, '\n');
3804 }
3805
3806 static void
3807 trace_format_flow(struct ds *result, int level, const char *title,
3808                  struct ofproto_trace *trace)
3809 {
3810     ds_put_char_multiple(result, '\t', level);
3811     ds_put_format(result, "%s: ", title);
3812     if (flow_equal(&trace->ctx.flow, &trace->flow)) {
3813         ds_put_cstr(result, "unchanged");
3814     } else {
3815         flow_format(result, &trace->ctx.flow);
3816         trace->flow = trace->ctx.flow;
3817     }
3818     ds_put_char(result, '\n');
3819 }
3820
3821 static void
3822 trace_resubmit(struct action_xlate_ctx *ctx, struct rule_dpif *rule)
3823 {
3824     struct ofproto_trace *trace = CONTAINER_OF(ctx, struct ofproto_trace, ctx);
3825     struct ds *result = trace->result;
3826
3827     ds_put_char(result, '\n');
3828     trace_format_flow(result, ctx->recurse + 1, "Resubmitted flow", trace);
3829     trace_format_rule(result, ctx->recurse + 1, &rule->up);
3830 }
3831
3832 static void
3833 ofproto_unixctl_trace(struct unixctl_conn *conn, const char *args_,
3834                       void *aux OVS_UNUSED)
3835 {
3836     char *dpname, *in_port_s, *tun_id_s, *packet_s;
3837     char *args = xstrdup(args_);
3838     char *save_ptr = NULL;
3839     struct ofproto_dpif *ofproto;
3840     struct ofpbuf packet;
3841     struct rule_dpif *rule;
3842     struct ds result;
3843     struct flow flow;
3844     uint16_t in_port;
3845     ovs_be64 tun_id;
3846     char *s;
3847
3848     ofpbuf_init(&packet, strlen(args) / 2);
3849     ds_init(&result);
3850
3851     dpname = strtok_r(args, " ", &save_ptr);
3852     tun_id_s = strtok_r(NULL, " ", &save_ptr);
3853     in_port_s = strtok_r(NULL, " ", &save_ptr);
3854     packet_s = strtok_r(NULL, "", &save_ptr); /* Get entire rest of line. */
3855     if (!dpname || !in_port_s || !packet_s) {
3856         unixctl_command_reply(conn, 501, "Bad command syntax");
3857         goto exit;
3858     }
3859
3860     ofproto = ofproto_dpif_lookup(dpname);
3861     if (!ofproto) {
3862         unixctl_command_reply(conn, 501, "Unknown ofproto (use ofproto/list "
3863                               "for help)");
3864         goto exit;
3865     }
3866
3867     tun_id = htonll(strtoull(tun_id_s, NULL, 0));
3868     in_port = ofp_port_to_odp_port(atoi(in_port_s));
3869
3870     packet_s = ofpbuf_put_hex(&packet, packet_s, NULL);
3871     packet_s += strspn(packet_s, " ");
3872     if (*packet_s != '\0') {
3873         unixctl_command_reply(conn, 501, "Trailing garbage in command");
3874         goto exit;
3875     }
3876     if (packet.size < ETH_HEADER_LEN) {
3877         unixctl_command_reply(conn, 501, "Packet data too short for Ethernet");
3878         goto exit;
3879     }
3880
3881     ds_put_cstr(&result, "Packet: ");
3882     s = ofp_packet_to_string(packet.data, packet.size, packet.size);
3883     ds_put_cstr(&result, s);
3884     free(s);
3885
3886     flow_extract(&packet, tun_id, in_port, &flow);
3887     ds_put_cstr(&result, "Flow: ");
3888     flow_format(&result, &flow);
3889     ds_put_char(&result, '\n');
3890
3891     rule = rule_dpif_lookup(ofproto, &flow);
3892     trace_format_rule(&result, 0, &rule->up);
3893     if (rule) {
3894         struct ofproto_trace trace;
3895         struct ofpbuf *odp_actions;
3896
3897         trace.result = &result;
3898         trace.flow = flow;
3899         action_xlate_ctx_init(&trace.ctx, ofproto, &flow, &packet);
3900         trace.ctx.resubmit_hook = trace_resubmit;
3901         odp_actions = xlate_actions(&trace.ctx,
3902                                     rule->up.actions, rule->up.n_actions);
3903
3904         ds_put_char(&result, '\n');
3905         trace_format_flow(&result, 0, "Final flow", &trace);
3906         ds_put_cstr(&result, "Datapath actions: ");
3907         format_odp_actions(&result, odp_actions->data, odp_actions->size);
3908         ofpbuf_delete(odp_actions);
3909     }
3910
3911     unixctl_command_reply(conn, 200, ds_cstr(&result));
3912
3913 exit:
3914     ds_destroy(&result);
3915     ofpbuf_uninit(&packet);
3916     free(args);
3917 }
3918
3919 static void
3920 ofproto_dpif_unixctl_init(void)
3921 {
3922     static bool registered;
3923     if (registered) {
3924         return;
3925     }
3926     registered = true;
3927
3928     unixctl_command_register("ofproto/trace", ofproto_unixctl_trace, NULL);
3929     unixctl_command_register("fdb/show", ofproto_unixctl_fdb_show, NULL);
3930 }
3931 \f
3932 const struct ofproto_class ofproto_dpif_class = {
3933     enumerate_types,
3934     enumerate_names,
3935     del,
3936     alloc,
3937     construct,
3938     destruct,
3939     dealloc,
3940     run,
3941     wait,
3942     flush,
3943     get_features,
3944     get_tables,
3945     port_alloc,
3946     port_construct,
3947     port_destruct,
3948     port_dealloc,
3949     port_modified,
3950     port_reconfigured,
3951     port_query_by_name,
3952     port_add,
3953     port_del,
3954     port_dump_start,
3955     port_dump_next,
3956     port_dump_done,
3957     port_poll,
3958     port_poll_wait,
3959     port_is_lacp_current,
3960     NULL,                       /* rule_choose_table */
3961     rule_alloc,
3962     rule_construct,
3963     rule_destruct,
3964     rule_dealloc,
3965     rule_get_stats,
3966     rule_execute,
3967     rule_modify_actions,
3968     get_drop_frags,
3969     set_drop_frags,
3970     packet_out,
3971     set_netflow,
3972     get_netflow_ids,
3973     set_sflow,
3974     set_cfm,
3975     get_cfm_fault,
3976     bundle_set,
3977     bundle_remove,
3978     mirror_set,
3979     set_flood_vlans,
3980     is_mirror_output_bundle,
3981 };