X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=ofproto%2Fofproto-dpif.c;h=6561c65d5bb2255e253dd936e46b8ae4e17de038;hb=b476e2f21b1f20bd0d24c0522e4d745603599582;hp=df963f8b0576c84f82178529319c3590a1a54fbc;hpb=a36de779d739cdcd72c65c67a547a786798b595a;p=cascardo%2Fovs.git diff --git a/ofproto/ofproto-dpif.c b/ofproto/ofproto-dpif.c index df963f8b0..6561c65d5 100644 --- a/ofproto/ofproto-dpif.c +++ b/ofproto/ofproto-dpif.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014 Nicira, Inc. + * Copyright (c) 2009, 2010, 2011, 2012, 2013, 2014, 2015 Nicira, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -29,6 +29,7 @@ #include "connmgr.h" #include "coverage.h" #include "cfm.h" +#include "ovs-lldp.h" #include "dpif.h" #include "dynamic-string.h" #include "fail-open.h" @@ -59,6 +60,7 @@ #include "ofproto-dpif-upcall.h" #include "ofproto-dpif-xlate.h" #include "poll-loop.h" +#include "ovs-rcu.h" #include "ovs-router.h" #include "seq.h" #include "simap.h" @@ -68,7 +70,7 @@ #include "unaligned.h" #include "unixctl.h" #include "vlan-bitmap.h" -#include "vlog.h" +#include "openvswitch/vlog.h" VLOG_DEFINE_THIS_MODULE(ofproto_dpif); @@ -87,6 +89,15 @@ struct rule_dpif { struct ovs_mutex stats_mutex; struct dpif_flow_stats stats OVS_GUARDED; + /* In non-NULL, will point to a new rule (for which a reference is held) to + * which all the stats updates should be forwarded. This exists only + * transitionally when flows are replaced. + * + * Protected by stats_mutex. If both 'rule->stats_mutex' and + * 'rule->new_rule->stats_mutex' must be held together, acquire them in that + * order, */ + struct rule_dpif *new_rule OVS_GUARDED; + /* If non-zero then the recirculation id that has * been allocated for use with this rule. * The recirculation id and associated internal flow should @@ -121,7 +132,7 @@ struct ofbundle { char *name; /* Identifier for log messages. */ /* Configuration. */ - struct list ports; /* Contains "struct ofport"s. */ + struct ovs_list ports; /* Contains "struct ofport"s. */ enum port_vlan_mode vlan_mode; /* VLAN mode */ int vlan; /* -1=trunk port, else a 12-bit VLAN ID. */ unsigned long *trunks; /* Bitmap of trunked VLANs, if 'vlan' == -1. @@ -140,6 +151,8 @@ static void bundle_destroy(struct ofbundle *); static void bundle_del_port(struct ofport_dpif *); static void bundle_run(struct ofbundle *); static void bundle_wait(struct ofbundle *); +static void bundle_flush_macs(struct ofbundle *, bool); +static void bundle_move(struct ofbundle *, struct ofbundle *); static void stp_run(struct ofproto_dpif *ofproto); static void stp_wait(struct ofproto_dpif *ofproto); @@ -156,9 +169,10 @@ struct ofport_dpif { odp_port_t odp_port; struct ofbundle *bundle; /* Bundle that contains this port, if any. */ - struct list bundle_node; /* In struct ofbundle's "ports" list. */ + struct ovs_list bundle_node;/* In struct ofbundle's "ports" list. */ struct cfm *cfm; /* Connectivity Fault Management, if any. */ struct bfd *bfd; /* BFD, if any. */ + struct lldp *lldp; /* lldp, if any. */ bool may_enable; /* May be enabled in bonds. */ bool is_tunnel; /* This port is a tunnel. */ bool is_layer3; /* This is a layer 3 port. */ @@ -220,6 +234,7 @@ ofport_dpif_cast(const struct ofport *ofport) static void port_run(struct ofport_dpif *); static int set_bfd(struct ofport *, const struct smap *); static int set_cfm(struct ofport *, const struct cfm_settings *); +static int set_lldp(struct ofport *ofport_, const struct smap *cfg); static void ofport_update_peer(struct ofport_dpif *); /* Reasons that we might need to revalidate every datapath flow, and @@ -265,28 +280,11 @@ struct dpif_backer { bool recv_set_enable; /* Enables or disables receiving packets. */ - /* Recirculation. */ - struct recirc_id_pool *rid_pool; /* Recirculation ID pool. */ - bool enable_recirc; /* True if the datapath supports recirculation */ - - /* True if the datapath supports variable-length - * OVS_USERSPACE_ATTR_USERDATA in OVS_ACTION_ATTR_USERSPACE actions. - * False if the datapath supports only 8-byte (or shorter) userdata. */ - bool variable_length_userdata; - - /* True if the datapath supports masked data in OVS_ACTION_ATTR_SET - * actions. */ - bool masked_set_action; - - /* Maximum number of MPLS label stack entries that the datapath supports - * in a match */ - size_t max_mpls_depth; - /* Version string of the datapath stored in OVSDB. */ char *dp_version_string; - /* True if the datapath supports tnl_push and pop actions. */ - bool enable_tnl_push_pop; + /* Datapath feature support. */ + struct dpif_backer_support support; struct atomic_count tnl_count; }; @@ -298,6 +296,8 @@ struct ofproto_dpif { struct ofproto up; struct dpif_backer *backer; + ATOMIC(cls_version_t) tables_version; /* For classifier lookups. */ + uint64_t dump_seq; /* Last read of udpif_dump_seq(). */ /* Special OpenFlow rules. */ @@ -359,22 +359,20 @@ ofproto_dpif_cast(const struct ofproto *ofproto) return CONTAINER_OF(ofproto, struct ofproto_dpif, up); } -size_t -ofproto_dpif_get_max_mpls_depth(const struct ofproto_dpif *ofproto) +bool +ofproto_dpif_get_enable_ufid(const struct dpif_backer *backer) { - return ofproto->backer->max_mpls_depth; + return backer->support.ufid; } -bool -ofproto_dpif_get_enable_recirc(const struct ofproto_dpif *ofproto) +struct dpif_backer_support * +ofproto_dpif_get_support(const struct ofproto_dpif *ofproto) { - return ofproto->backer->enable_recirc; + return &ofproto->backer->support; } -static struct ofport_dpif *get_ofp_port(const struct ofproto_dpif *ofproto, - ofp_port_t ofp_port); static void ofproto_trace(struct ofproto_dpif *, struct flow *, - const struct ofpbuf *packet, + const struct dp_packet *packet, const struct ofpact[], size_t ofpacts_len, struct ds *); @@ -388,9 +386,18 @@ static struct shash init_ofp_ports = SHASH_INITIALIZER(&init_ofp_ports); * it. */ void ofproto_dpif_flow_mod(struct ofproto_dpif *ofproto, - struct ofputil_flow_mod *fm) + const struct ofputil_flow_mod *fm) { - ofproto_flow_mod(&ofproto->up, fm); + struct ofproto_flow_mod ofm; + + /* Multiple threads may do this for the same 'fm' at the same time. + * Allocate ofproto_flow_mod with execution context from stack. + * + * Note: This copy could be avoided by making ofproto_flow_mod more + * complex, but that may not be desireable, and a learn action is not that + * fast to begin with. */ + ofm.fm = *fm; + ofproto_flow_mod(&ofproto->up, &ofm); } /* Appends 'pin' to the queue of "packet ins" to be sent to the controller. @@ -439,6 +446,9 @@ init(const struct shash *iface_hints) shash_add(&init_ofp_ports, node->name, new_hint); } + + ofproto_unixctl_init(); + udpif_init(); } static void @@ -505,6 +515,12 @@ lookup_ofproto_dpif_by_port_name(const char *name) return NULL; } +bool +ofproto_dpif_backer_enabled(struct dpif_backer* backer) +{ + return backer->recv_set_enable; +} + static int type_run(const char *type) { @@ -634,10 +650,7 @@ type_run(const char *type) ofproto->netflow, ofproto->up.forward_bpdu, connmgr_has_in_band(ofproto->up.connmgr), - ofproto->backer->enable_recirc, - ofproto->backer->variable_length_userdata, - ofproto->backer->max_mpls_depth, - ofproto->backer->masked_set_action); + &ofproto->backer->support); HMAP_FOR_EACH (bundle, hmap_node, &ofproto->bundles) { xlate_bundle_set(ofproto, bundle, bundle->name, @@ -653,8 +666,8 @@ type_run(const char *type) : -1; xlate_ofport_set(ofproto, ofport->bundle, ofport, ofport->up.ofp_port, ofport->odp_port, - ofport->up.netdev, ofport->cfm, - ofport->bfd, ofport->peer, stp_port, + ofport->up.netdev, ofport->cfm, ofport->bfd, + ofport->lldp, ofport->peer, stp_port, ofport->rstp_port, ofport->qdscp, ofport->n_qdscp, ofport->up.pp.config, ofport->up.pp.state, ofport->is_tunnel, @@ -822,7 +835,7 @@ static int add_internal_flows(struct ofproto_dpif *); static struct ofproto * alloc(void) { - struct ofproto_dpif *ofproto = xmalloc(sizeof *ofproto); + struct ofproto_dpif *ofproto = xzalloc(sizeof *ofproto); return &ofproto->up; } @@ -848,7 +861,6 @@ close_dpif_backer(struct dpif_backer *backer) ovs_rwlock_destroy(&backer->odp_to_ofport_lock); hmap_destroy(&backer->odp_to_ofport_map); shash_find_and_delete(&all_dpif_backers, backer->type); - recirc_id_pool_destroy(backer->rid_pool); free(backer->type); free(backer->dp_version_string); dpif_close(backer->dpif); @@ -857,14 +869,12 @@ close_dpif_backer(struct dpif_backer *backer) /* Datapath port slated for removal from datapath. */ struct odp_garbage { - struct list list_node; + struct ovs_list list_node; odp_port_t odp_port; }; static bool check_variable_length_userdata(struct dpif_backer *backer); -static size_t check_max_mpls_depth(struct dpif_backer *backer); -static bool check_recirc(struct dpif_backer *backer); -static bool check_masked_set_action(struct dpif_backer *backer); +static void check_support(struct dpif_backer *backer); static int open_dpif_backer(const char *type, struct dpif_backer **backerp) @@ -873,14 +883,16 @@ open_dpif_backer(const char *type, struct dpif_backer **backerp) struct dpif_port_dump port_dump; struct dpif_port port; struct shash_node *node; - struct list garbage_list; - struct odp_garbage *garbage, *next; + struct ovs_list garbage_list; + struct odp_garbage *garbage; struct sset names; char *backer_name; const char *name; int error; + recirc_init(); + backer = shash_find_data(&all_dpif_backers, type); if (backer) { backer->refcount++; @@ -950,20 +962,14 @@ open_dpif_backer(const char *type, struct dpif_backer **backerp) } dpif_port_dump_done(&port_dump); - LIST_FOR_EACH_SAFE (garbage, next, list_node, &garbage_list) { + LIST_FOR_EACH_POP (garbage, list_node, &garbage_list) { dpif_port_del(backer->dpif, garbage->odp_port); - list_remove(&garbage->list_node); free(garbage); } shash_add(&all_dpif_backers, type, backer); - backer->enable_recirc = check_recirc(backer); - backer->max_mpls_depth = check_max_mpls_depth(backer); - backer->masked_set_action = check_masked_set_action(backer); - backer->rid_pool = recirc_id_pool_create(); - - backer->enable_tnl_push_pop = dpif_supports_tnl_push_pop(backer->dpif); + check_support(backer); atomic_count_init(&backer->tnl_count, 0); error = dpif_recv_set(backer->dpif, backer->recv_set_enable); @@ -981,7 +987,8 @@ open_dpif_backer(const char *type, struct dpif_backer **backerp) /* This check fails if performed before udpif threads have been set, * as the kernel module checks that the 'pid' in userspace action * is non-zero. */ - backer->variable_length_userdata = check_variable_length_userdata(backer); + backer->support.variable_length_userdata + = check_variable_length_userdata(backer); backer->dp_version_string = dpif_get_dp_version(backer->dpif); return error; @@ -990,7 +997,7 @@ open_dpif_backer(const char *type, struct dpif_backer **backerp) bool ovs_native_tunneling_is_on(struct ofproto_dpif *ofproto) { - return ofproto_use_tnl_push_pop && ofproto->backer->enable_tnl_push_pop && + return ofproto_use_tnl_push_pop && ofproto->backer->support.tnl_push_pop && atomic_count_get(&ofproto->backer->tnl_count); } @@ -1007,37 +1014,23 @@ check_recirc(struct dpif_backer *backer) struct flow flow; struct odputil_keybuf keybuf; struct ofpbuf key; - int error; - bool enable_recirc = false; + bool enable_recirc; + struct odp_flow_key_parms odp_parms = { + .flow = &flow, + .support = { + .recirc = true, + }, + }; memset(&flow, 0, sizeof flow); flow.recirc_id = 1; flow.dp_hash = 1; ofpbuf_use_stack(&key, &keybuf, sizeof keybuf); - odp_flow_key_from_flow(&key, &flow, NULL, 0, true); - - error = dpif_flow_put(backer->dpif, DPIF_FP_CREATE | DPIF_FP_PROBE, - ofpbuf_data(&key), ofpbuf_size(&key), NULL, 0, NULL, - 0, NULL); - if (error && error != EEXIST) { - if (error != EINVAL) { - VLOG_WARN("%s: Reciculation flow probe failed (%s)", - dpif_name(backer->dpif), ovs_strerror(error)); - } - goto done; - } + odp_flow_key_from_flow(&odp_parms, &key); + enable_recirc = dpif_probe_feature(backer->dpif, "recirculation", &key, + NULL); - error = dpif_flow_del(backer->dpif, ofpbuf_data(&key), ofpbuf_size(&key), - NULL); - if (error) { - VLOG_WARN("%s: failed to delete recirculation feature probe flow", - dpif_name(backer->dpif)); - } - - enable_recirc = true; - -done: if (enable_recirc) { VLOG_INFO("%s: Datapath supports recirculation", dpif_name(backer->dpif)); @@ -1049,6 +1042,42 @@ done: return enable_recirc; } +/* Tests whether 'dpif' supports unique flow ids. We can skip serializing + * some flow attributes for datapaths that support this feature. + * + * Returns true if 'dpif' supports UFID for flow operations. + * Returns false if 'dpif' does not support UFID. */ +static bool +check_ufid(struct dpif_backer *backer) +{ + struct flow flow; + struct odputil_keybuf keybuf; + struct ofpbuf key; + ovs_u128 ufid; + bool enable_ufid; + struct odp_flow_key_parms odp_parms = { + .flow = &flow, + }; + + memset(&flow, 0, sizeof flow); + flow.dl_type = htons(0x1234); + + ofpbuf_use_stack(&key, &keybuf, sizeof keybuf); + odp_flow_key_from_flow(&odp_parms, &key); + dpif_flow_hash(backer->dpif, key.data, key.size, &ufid); + + enable_ufid = dpif_probe_feature(backer->dpif, "UFID", &key, &ufid); + + if (enable_ufid) { + VLOG_INFO("%s: Datapath supports unique flow ids", + dpif_name(backer->dpif)); + } else { + VLOG_INFO("%s: Datapath does not support unique flow ids", + dpif_name(backer->dpif)); + } + return enable_ufid; +} + /* Tests whether 'backer''s datapath supports variable-length * OVS_USERSPACE_ATTR_USERDATA in OVS_ACTION_ATTR_USERSPACE actions. We need * to disable some features on older datapaths that don't support this @@ -1063,7 +1092,7 @@ check_variable_length_userdata(struct dpif_backer *backer) struct eth_header *eth; struct ofpbuf actions; struct dpif_execute execute; - struct ofpbuf packet; + struct dp_packet packet; size_t start; int error; @@ -1082,22 +1111,22 @@ check_variable_length_userdata(struct dpif_backer *backer) nl_msg_end_nested(&actions, start); /* Compose a dummy ethernet packet. */ - ofpbuf_init(&packet, ETH_HEADER_LEN); - eth = ofpbuf_put_zeros(&packet, ETH_HEADER_LEN); + dp_packet_init(&packet, ETH_HEADER_LEN); + eth = dp_packet_put_zeros(&packet, ETH_HEADER_LEN); eth->eth_type = htons(0x1234); /* Execute the actions. On older datapaths this fails with ERANGE, on * newer datapaths it succeeds. */ - execute.actions = ofpbuf_data(&actions); - execute.actions_len = ofpbuf_size(&actions); + execute.actions = actions.data; + execute.actions_len = actions.size; execute.packet = &packet; - execute.md = PKT_METADATA_INITIALIZER(0); execute.needs_help = false; execute.probe = true; + execute.mtu = 0; error = dpif_execute(backer->dpif, &execute); - ofpbuf_uninit(&packet); + dp_packet_uninit(&packet); ofpbuf_uninit(&actions); switch (error) { @@ -1137,32 +1166,19 @@ check_max_mpls_depth(struct dpif_backer *backer) for (n = 0; n < FLOW_MAX_MPLS_LABELS; n++) { struct odputil_keybuf keybuf; struct ofpbuf key; - int error; + struct odp_flow_key_parms odp_parms = { + .flow = &flow, + }; memset(&flow, 0, sizeof flow); flow.dl_type = htons(ETH_TYPE_MPLS); flow_set_mpls_bos(&flow, n, 1); ofpbuf_use_stack(&key, &keybuf, sizeof keybuf); - odp_flow_key_from_flow(&key, &flow, NULL, 0, false); - - error = dpif_flow_put(backer->dpif, DPIF_FP_CREATE | DPIF_FP_PROBE, - ofpbuf_data(&key), ofpbuf_size(&key), NULL, 0, - NULL, 0, NULL); - if (error && error != EEXIST) { - if (error != EINVAL) { - VLOG_WARN("%s: MPLS stack length feature probe failed (%s)", - dpif_name(backer->dpif), ovs_strerror(error)); - } + odp_flow_key_from_flow(&odp_parms, &key); + if (!dpif_probe_feature(backer->dpif, "MPLS", &key, NULL)) { break; } - - error = dpif_flow_del(backer->dpif, ofpbuf_data(&key), - ofpbuf_size(&key), NULL); - if (error) { - VLOG_WARN("%s: failed to delete MPLS feature probe flow", - dpif_name(backer->dpif)); - } } VLOG_INFO("%s: MPLS label stack length probed as %d", @@ -1179,7 +1195,7 @@ check_masked_set_action(struct dpif_backer *backer) struct eth_header *eth; struct ofpbuf actions; struct dpif_execute execute; - struct ofpbuf packet; + struct dp_packet packet; int error; struct ovs_key_ethernet key, mask; @@ -1194,22 +1210,22 @@ check_masked_set_action(struct dpif_backer *backer) sizeof key); /* Compose a dummy ethernet packet. */ - ofpbuf_init(&packet, ETH_HEADER_LEN); - eth = ofpbuf_put_zeros(&packet, ETH_HEADER_LEN); + dp_packet_init(&packet, ETH_HEADER_LEN); + eth = dp_packet_put_zeros(&packet, ETH_HEADER_LEN); eth->eth_type = htons(0x1234); /* Execute the actions. On older datapaths this fails with EINVAL, on * newer datapaths it succeeds. */ - execute.actions = ofpbuf_data(&actions); - execute.actions_len = ofpbuf_size(&actions); + execute.actions = actions.data; + execute.actions_len = actions.size; execute.packet = &packet; - execute.md = PKT_METADATA_INITIALIZER(0); execute.needs_help = false; execute.probe = true; + execute.mtu = 0; error = dpif_execute(backer->dpif, &execute); - ofpbuf_uninit(&packet); + dp_packet_uninit(&packet); ofpbuf_uninit(&actions); if (error) { @@ -1220,6 +1236,68 @@ check_masked_set_action(struct dpif_backer *backer) return !error; } +#define CHECK_FEATURE__(NAME, SUPPORT, FIELD, VALUE) \ +static bool \ +check_##NAME(struct dpif_backer *backer) \ +{ \ + struct flow flow; \ + struct odputil_keybuf keybuf; \ + struct ofpbuf key; \ + bool enable; \ + struct odp_flow_key_parms odp_parms = { \ + .flow = &flow, \ + .support = { \ + .SUPPORT = true, \ + }, \ + }; \ + \ + memset(&flow, 0, sizeof flow); \ + flow.FIELD = VALUE; \ + \ + ofpbuf_use_stack(&key, &keybuf, sizeof keybuf); \ + odp_flow_key_from_flow(&odp_parms, &key); \ + enable = dpif_probe_feature(backer->dpif, #NAME, &key, NULL); \ + \ + if (enable) { \ + VLOG_INFO("%s: Datapath supports "#NAME, dpif_name(backer->dpif)); \ + } else { \ + VLOG_INFO("%s: Datapath does not support "#NAME, \ + dpif_name(backer->dpif)); \ + } \ + \ + return enable; \ +} +#define CHECK_FEATURE(FIELD) CHECK_FEATURE__(FIELD, FIELD, FIELD, 1) + +CHECK_FEATURE(ct_state) +CHECK_FEATURE(ct_zone) +CHECK_FEATURE(ct_mark) +CHECK_FEATURE__(ct_label, ct_label, ct_label.u64.lo, 1) +CHECK_FEATURE__(ct_state_nat, ct_state, ct_state, CS_TRACKED|CS_SRC_NAT) + +#undef CHECK_FEATURE +#undef CHECK_FEATURE__ + +static void +check_support(struct dpif_backer *backer) +{ + /* This feature needs to be tested after udpif threads are set. */ + backer->support.variable_length_userdata = false; + + backer->support.odp.recirc = check_recirc(backer); + backer->support.odp.max_mpls_depth = check_max_mpls_depth(backer); + backer->support.masked_set_action = check_masked_set_action(backer); + backer->support.ufid = check_ufid(backer); + backer->support.tnl_push_pop = dpif_supports_tnl_push_pop(backer->dpif); + + backer->support.odp.ct_state = check_ct_state(backer); + backer->support.odp.ct_zone = check_ct_zone(backer); + backer->support.odp.ct_mark = check_ct_mark(backer); + backer->support.odp.ct_label = check_ct_label(backer); + + backer->support.odp.ct_state_nat = check_ct_state_nat(backer); +} + static int construct(struct ofproto *ofproto_) { @@ -1227,11 +1305,15 @@ construct(struct ofproto *ofproto_) struct shash_node *node, *next; int error; + /* Tunnel module can get used right after the udpif threads are running. */ + ofproto_tunnel_init(); + error = open_dpif_backer(ofproto->up.type, &ofproto->backer); if (error) { return error; } + atomic_init(&ofproto->tables_version, CLS_MIN_VERSION); ofproto->netflow = NULL; ofproto->sflow = NULL; ofproto->ipfix = NULL; @@ -1244,15 +1326,11 @@ construct(struct ofproto *ofproto_) ofproto->mbridge = mbridge_create(); ofproto->has_bonded_bundles = false; ofproto->lacp_enabled = false; - ofproto_tunnel_init(); ovs_mutex_init_adaptive(&ofproto->stats_mutex); ovs_mutex_init(&ofproto->vsp_mutex); guarded_list_init(&ofproto->pins); - ofproto_unixctl_init(); - ovs_router_unixctl_register(); - hmap_init(&ofproto->vlandev_map); hmap_init(&ofproto->realdev_vid_map); @@ -1318,7 +1396,6 @@ add_internal_flows(struct ofproto_dpif *ofproto) uint64_t ofpacts_stub[128 / 8]; struct ofpbuf ofpacts; struct rule *unused_rulep OVS_UNUSED; - struct ofpact_resubmit *resubmit; struct match match; int error; int id; @@ -1351,33 +1428,16 @@ add_internal_flows(struct ofproto_dpif *ofproto) return error; } - /* Continue non-recirculation rule lookups from table 0. + /* Drop any run away non-recirc rule lookups. Recirc_id has to be + * zero when reaching this rule. * - * (priority=2), recirc=0, actions=resubmit(, 0) + * (priority=2), recirc_id=0, actions=drop */ - resubmit = ofpact_put_RESUBMIT(&ofpacts); - resubmit->in_port = OFPP_IN_PORT; - resubmit->table_id = 0; - + ofpbuf_clear(&ofpacts); match_init_catchall(&match); match_set_recirc_id(&match, 0); - error = ofproto_dpif_add_internal_flow(ofproto, &match, 2, 0, &ofpacts, &unused_rulep); - if (error) { - return error; - } - - /* Drop any run away recirc rule lookups. Recirc_id has to be - * non-zero when reaching this rule. - * - * (priority=1), *, actions=drop - */ - ofpbuf_clear(&ofpacts); - match_init_catchall(&match); - error = ofproto_dpif_add_internal_flow(ofproto, &match, 1, 0, &ofpacts, - &unused_rulep); - return error; } @@ -1385,10 +1445,10 @@ static void destruct(struct ofproto *ofproto_) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_); - struct ofproto_packet_in *pin, *next_pin; + struct ofproto_packet_in *pin; struct rule_dpif *rule; struct oftable *table; - struct list pins; + struct ovs_list pins; ofproto->backer->need_revalidate = REV_RECONFIGURE; xlate_txn_start(); @@ -1402,19 +1462,21 @@ destruct(struct ofproto *ofproto_) hmap_remove(&all_ofproto_dpifs, &ofproto->all_ofproto_dpifs_node); OFPROTO_FOR_EACH_TABLE (table, &ofproto->up) { - CLS_FOR_EACH_SAFE (rule, up.cr, &table->cls) { + CLS_FOR_EACH (rule, up.cr, &table->cls) { ofproto_rule_delete(&ofproto->up, &rule->up); } } + ofproto_group_delete_all(&ofproto->up); guarded_list_pop_all(&ofproto->pins, &pins); - LIST_FOR_EACH_SAFE (pin, next_pin, list_node, &pins) { - list_remove(&pin->list_node); + LIST_FOR_EACH_POP (pin, list_node, &pins) { free(CONST_CAST(void *, pin->up.packet)); free(pin); } guarded_list_destroy(&ofproto->pins); + recirc_free_ofproto(ofproto, ofproto->up.name); + mbridge_unref(ofproto->mbridge); netflow_unref(ofproto->netflow); @@ -1462,13 +1524,12 @@ run(struct ofproto *ofproto_) /* Do not perform any periodic activity required by 'ofproto' while * waiting for flow restore to complete. */ if (!ofproto_get_flow_restore_wait()) { - struct ofproto_packet_in *pin, *next_pin; - struct list pins; + struct ofproto_packet_in *pin; + struct ovs_list pins; guarded_list_pop_all(&ofproto->pins, &pins); - LIST_FOR_EACH_SAFE (pin, next_pin, list_node, &pins) { + LIST_FOR_EACH_POP (pin, list_node, &pins) { connmgr_send_packet_in(ofproto->up.connmgr, pin); - list_remove(&pin->list_node); free(CONST_CAST(void *, pin->up.packet)); free(pin); } @@ -1577,8 +1638,6 @@ wait(struct ofproto *ofproto_) mcast_snooping_wait(ofproto->ms); stp_wait(ofproto); if (ofproto->backer->need_revalidate) { - /* Shouldn't happen, but if it does just go around again. */ - VLOG_DBG_RL(&rl, "need revalidate in ofproto_wait_cb()"); poll_immediate_wake(); } @@ -1630,10 +1689,19 @@ query_tables(struct ofproto *ofproto, } } +static void +set_tables_version(struct ofproto *ofproto_, cls_version_t version) +{ + struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_); + + atomic_store_relaxed(&ofproto->tables_version, version); +} + + static struct ofport * port_alloc(void) { - struct ofport_dpif *port = xmalloc(sizeof *port); + struct ofport_dpif *port = xzalloc(sizeof *port); return &port->up; } @@ -1651,6 +1719,7 @@ port_construct(struct ofport *port_) struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto); const struct netdev *netdev = port->up.netdev; char namebuf[NETDEV_VPORT_NAME_BUFSIZE]; + const char *dp_port_name; struct dpif_port dpif_port; int error; @@ -1658,6 +1727,7 @@ port_construct(struct ofport *port_) port->bundle = NULL; port->cfm = NULL; port->bfd = NULL; + port->lldp = NULL; port->may_enable = false; port->stp_port = NULL; port->stp_state = STP_DISABLED; @@ -1674,18 +1744,17 @@ port_construct(struct ofport *port_) if (netdev_vport_is_patch(netdev)) { /* By bailing out here, we don't submit the port to the sFlow module - * to be considered for counter polling export. This is correct - * because the patch port represents an interface that sFlow considers - * to be "internal" to the switch as a whole, and therefore not an - * candidate for counter polling. */ + * to be considered for counter polling export. This is correct + * because the patch port represents an interface that sFlow considers + * to be "internal" to the switch as a whole, and therefore not a + * candidate for counter polling. */ port->odp_port = ODPP_NONE; ofport_update_peer(port); return 0; } - error = dpif_port_query_by_name(ofproto->backer->dpif, - netdev_vport_get_dpif_port(netdev, namebuf, - sizeof namebuf), + dp_port_name = netdev_vport_get_dpif_port(netdev, namebuf, sizeof namebuf); + error = dpif_port_query_by_name(ofproto->backer->dpif, dp_port_name, &dpif_port); if (error) { return error; @@ -1695,8 +1764,14 @@ port_construct(struct ofport *port_) if (netdev_get_tunnel_config(netdev)) { atomic_count_inc(&ofproto->backer->tnl_count); - tnl_port_add(port, port->up.netdev, port->odp_port, - ovs_native_tunneling_is_on(ofproto), namebuf); + error = tnl_port_add(port, port->up.netdev, port->odp_port, + ovs_native_tunneling_is_on(ofproto), dp_port_name); + if (error) { + atomic_count_dec(&ofproto->backer->tnl_count); + dpif_port_destroy(&dpif_port); + return error; + } + port->is_tunnel = true; if (ofproto->ipfix) { dpif_ipfix_add_tunnel_port(ofproto->ipfix, port_, port->odp_port); @@ -1776,6 +1851,7 @@ port_destruct(struct ofport *port_) bundle_remove(port_); set_cfm(port_, NULL); set_bfd(port_, NULL); + set_lldp(port_, NULL); if (port->stp_port) { stp_port_disable(port->stp_port); } @@ -1792,6 +1868,7 @@ port_modified(struct ofport *port_) { struct ofport_dpif *port = ofport_dpif_cast(port_); char namebuf[NETDEV_VPORT_NAME_BUFSIZE]; + const char *dp_port_name; struct netdev *netdev = port->up.netdev; if (port->bundle && port->bundle->bond) { @@ -1807,15 +1884,16 @@ port_modified(struct ofport *port_) } ofproto_dpif_monitor_port_update(port, port->bfd, port->cfm, - port->up.pp.hw_addr); + port->lldp, &port->up.pp.hw_addr); - netdev_vport_get_dpif_port(netdev, namebuf, sizeof namebuf); + dp_port_name = netdev_vport_get_dpif_port(netdev, namebuf, sizeof namebuf); if (port->is_tunnel) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(port->up.ofproto); if (tnl_port_reconfigure(port, netdev, port->odp_port, - ovs_native_tunneling_is_on(ofproto), namebuf)) { + ovs_native_tunneling_is_on(ofproto), + dp_port_name)) { ofproto->backer->need_revalidate = REV_RECONFIGURE; } } @@ -1849,6 +1927,7 @@ set_sflow(struct ofproto *ofproto_, struct dpif_sflow *ds = ofproto->sflow; if (sflow_options) { + uint32_t old_probability = ds ? dpif_sflow_get_probability(ds) : 0; if (!ds) { struct ofport_dpif *ofport; @@ -1856,9 +1935,11 @@ set_sflow(struct ofproto *ofproto_, HMAP_FOR_EACH (ofport, up.hmap_node, &ofproto->up.ports) { dpif_sflow_add_port(ds, &ofport->up, ofport->odp_port); } - ofproto->backer->need_revalidate = REV_RECONFIGURE; } dpif_sflow_set_options(ds, sflow_options); + if (dpif_sflow_get_probability(ds) != old_probability) { + ofproto->backer->need_revalidate = REV_RECONFIGURE; + } } else { if (ds) { dpif_sflow_unref(ds); @@ -1916,14 +1997,12 @@ static int set_cfm(struct ofport *ofport_, const struct cfm_settings *s) { struct ofport_dpif *ofport = ofport_dpif_cast(ofport_); + struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto); + struct cfm *old = ofport->cfm; int error = 0; if (s) { if (!ofport->cfm) { - struct ofproto_dpif *ofproto; - - ofproto = ofproto_dpif_cast(ofport->up.ofproto); - ofproto->backer->need_revalidate = REV_RECONFIGURE; ofport->cfm = cfm_create(ofport->up.netdev); } @@ -1937,8 +2016,11 @@ set_cfm(struct ofport *ofport_, const struct cfm_settings *s) cfm_unref(ofport->cfm); ofport->cfm = NULL; out: + if (ofport->cfm != old) { + ofproto->backer->need_revalidate = REV_RECONFIGURE; + } ofproto_dpif_monitor_port_update(ofport, ofport->bfd, ofport->cfm, - ofport->up.pp.hw_addr); + ofport->lldp, &ofport->up.pp.hw_addr); return error; } @@ -1980,7 +2062,7 @@ set_bfd(struct ofport *ofport_, const struct smap *cfg) ofproto->backer->need_revalidate = REV_RECONFIGURE; } ofproto_dpif_monitor_port_update(ofport, ofport->bfd, ofport->cfm, - ofport->up.pp.hw_addr); + ofport->lldp, &ofport->up.pp.hw_addr); return 0; } @@ -2006,18 +2088,93 @@ get_bfd_status(struct ofport *ofport_, struct smap *smap) return ret; } + +static int +set_lldp(struct ofport *ofport_, + const struct smap *cfg) +{ + struct ofport_dpif *ofport = ofport_dpif_cast(ofport_); + int error = 0; + + if (cfg) { + if (!ofport->lldp) { + struct ofproto_dpif *ofproto; + + ofproto = ofproto_dpif_cast(ofport->up.ofproto); + ofproto->backer->need_revalidate = REV_RECONFIGURE; + ofport->lldp = lldp_create(ofport->up.netdev, ofport_->mtu, cfg); + } + + if (!lldp_configure(ofport->lldp, cfg)) { + error = EINVAL; + } + } + if (error) { + lldp_unref(ofport->lldp); + ofport->lldp = NULL; + } + + ofproto_dpif_monitor_port_update(ofport, + ofport->bfd, + ofport->cfm, + ofport->lldp, + &ofport->up.pp.hw_addr); + return error; +} + +static bool +get_lldp_status(const struct ofport *ofport_, + struct lldp_status *status OVS_UNUSED) +{ + struct ofport_dpif *ofport = ofport_dpif_cast(ofport_); + + return ofport->lldp ? true : false; +} + +static int +set_aa(struct ofproto *ofproto OVS_UNUSED, + const struct aa_settings *s) +{ + return aa_configure(s); +} + +static int +aa_mapping_set(struct ofproto *ofproto_ OVS_UNUSED, void *aux, + const struct aa_mapping_settings *s) +{ + return aa_mapping_register(aux, s); +} + +static int +aa_mapping_unset(struct ofproto *ofproto OVS_UNUSED, void *aux) +{ + return aa_mapping_unregister(aux); +} + +static int +aa_vlan_get_queued(struct ofproto *ofproto OVS_UNUSED, struct ovs_list *list) +{ + return aa_get_vlan_queued(list); +} + +static unsigned int +aa_vlan_get_queue_size(struct ofproto *ofproto OVS_UNUSED) +{ + return aa_get_vlan_queue_size(); +} + /* Spanning Tree. */ /* Called while rstp_mutex is held. */ static void -rstp_send_bpdu_cb(struct ofpbuf *pkt, void *ofport_, void *ofproto_) +rstp_send_bpdu_cb(struct dp_packet *pkt, void *ofport_, void *ofproto_) { struct ofproto_dpif *ofproto = ofproto_; struct ofport_dpif *ofport = ofport_; - struct eth_header *eth = ofpbuf_l2(pkt); + struct eth_header *eth = dp_packet_l2(pkt); - netdev_get_etheraddr(ofport->up.netdev, eth->eth_src); + netdev_get_etheraddr(ofport->up.netdev, ð->eth_src); if (eth_addr_is_zero(eth->eth_src)) { VLOG_WARN_RL(&rl, "%s port %d: cannot send RSTP BPDU on a port which " "does not have a configured source MAC address.", @@ -2025,11 +2182,11 @@ rstp_send_bpdu_cb(struct ofpbuf *pkt, void *ofport_, void *ofproto_) } else { ofproto_dpif_send_packet(ofport, pkt); } - ofpbuf_delete(pkt); + dp_packet_delete(pkt); } static void -send_bpdu_cb(struct ofpbuf *pkt, int port_num, void *ofproto_) +send_bpdu_cb(struct dp_packet *pkt, int port_num, void *ofproto_) { struct ofproto_dpif *ofproto = ofproto_; struct stp_port *sp = stp_get_port(ofproto->stp, port_num); @@ -2040,9 +2197,9 @@ send_bpdu_cb(struct ofpbuf *pkt, int port_num, void *ofproto_) VLOG_WARN_RL(&rl, "%s: cannot send BPDU on unknown port %d", ofproto->up.name, port_num); } else { - struct eth_header *eth = ofpbuf_l2(pkt); + struct eth_header *eth = dp_packet_l2(pkt); - netdev_get_etheraddr(ofport->up.netdev, eth->eth_src); + netdev_get_etheraddr(ofport->up.netdev, ð->eth_src); if (eth_addr_is_zero(eth->eth_src)) { VLOG_WARN_RL(&rl, "%s: cannot send BPDU on port %d " "with unknown MAC", ofproto->up.name, port_num); @@ -2050,7 +2207,7 @@ send_bpdu_cb(struct ofpbuf *pkt, int port_num, void *ofproto_) ofproto_dpif_send_packet(ofport, pkt); } } - ofpbuf_delete(pkt); + dp_packet_delete(pkt); } /* Configure RSTP on 'ofproto_' using the settings defined in 's'. */ @@ -2126,12 +2283,16 @@ update_rstp_port_state(struct ofport_dpif *ofport) netdev_get_name(ofport->up.netdev), rstp_state_name(ofport->rstp_state), rstp_state_name(state)); + if (rstp_learn_in_state(ofport->rstp_state) - != rstp_learn_in_state(state)) { - /* xxx Learning action flows should also be flushed. */ - ovs_rwlock_wrlock(&ofproto->ml->rwlock); - mac_learning_flush(ofproto->ml); - ovs_rwlock_unlock(&ofproto->ml->rwlock); + != rstp_learn_in_state(state)) { + /* XXX: Learning action flows should also be flushed. */ + if (ofport->bundle) { + if (!rstp_shift_root_learned_address(ofproto->rstp) + || rstp_get_old_root_aux(ofproto->rstp) != ofport) { + bundle_flush_macs(ofport->bundle, false); + } + } } fwd_change = rstp_forward_in_state(ofport->rstp_state) != rstp_forward_in_state(state); @@ -2171,16 +2332,27 @@ rstp_run(struct ofproto_dpif *ofproto) while ((ofport = rstp_get_next_changed_port_aux(ofproto->rstp, &rp))) { update_rstp_port_state(ofport); } + rp = NULL; + ofport = NULL; /* FIXME: This check should be done on-event (i.e., when setting * p->fdb_flush) and not periodically. */ - if (rstp_check_and_reset_fdb_flush(ofproto->rstp)) { - ovs_rwlock_wrlock(&ofproto->ml->rwlock); - /* FIXME: RSTP should be able to flush the entries pertaining to a - * single port, not the whole table. - */ - mac_learning_flush(ofproto->ml); - ovs_rwlock_unlock(&ofproto->ml->rwlock); + while ((ofport = rstp_check_and_reset_fdb_flush(ofproto->rstp, &rp))) { + if (!rstp_shift_root_learned_address(ofproto->rstp) + || rstp_get_old_root_aux(ofproto->rstp) != ofport) { + bundle_flush_macs(ofport->bundle, false); + } + } + + if (rstp_shift_root_learned_address(ofproto->rstp)) { + struct ofport_dpif *old_root_aux = + (struct ofport_dpif *)rstp_get_old_root_aux(ofproto->rstp); + struct ofport_dpif *new_root_aux = + (struct ofport_dpif *)rstp_get_new_root_aux(ofproto->rstp); + if (old_root_aux != NULL && new_root_aux != NULL) { + bundle_move(old_root_aux->bundle, new_root_aux->bundle); + rstp_reset_root_changed(ofproto->rstp); + } } } } @@ -2420,8 +2592,11 @@ set_rstp_port(struct ofport *ofport_, if (!s || !s->enable) { if (rp) { - rstp_port_unref(rp); + rstp_port_set_aux(rp, NULL); + rstp_port_set_state(rp, RSTP_DISABLED); + rstp_port_set_mac_operational(rp, false); ofport->rstp_port = NULL; + rstp_port_unref(rp); update_rstp_port_state(ofport); } return; @@ -2433,7 +2608,9 @@ set_rstp_port(struct ofport *ofport_, } rstp_port_set(rp, s->port_num, s->priority, s->path_cost, - s->admin_edge_port, s->auto_edge, s->mcheck, ofport); + s->admin_edge_port, s->auto_edge, + s->admin_p2p_mac_state, s->admin_port_state, s->mcheck, + ofport); update_rstp_port_state(ofport); /* Synchronize operational status. */ rstp_port_set_mac_operational(rp, ofport->may_enable); @@ -2453,7 +2630,9 @@ get_rstp_port_status(struct ofport *ofport_, } s->enabled = true; - rstp_port_get_status(rp, &s->port_id, &s->state, &s->role, &s->tx_count, + rstp_port_get_status(rp, &s->port_id, &s->state, &s->role, + &s->designated_bridge_id, &s->designated_port_id, + &s->designated_path_cost, &s->tx_count, &s->rx_count, &s->error_count, &s->uptime); } @@ -2500,7 +2679,7 @@ bundle_flush_macs(struct ofbundle *bundle, bool all_ofprotos) ofproto->backer->need_revalidate = REV_RECONFIGURE; ovs_rwlock_wrlock(&ml->rwlock); LIST_FOR_EACH_SAFE (mac, next_mac, lru_node, &ml->lrus) { - if (mac->port.p == bundle) { + if (mac_entry_get_port(ml, mac) == bundle) { if (all_ofprotos) { struct ofproto_dpif *o; @@ -2524,6 +2703,25 @@ bundle_flush_macs(struct ofbundle *bundle, bool all_ofprotos) ovs_rwlock_unlock(&ml->rwlock); } +static void +bundle_move(struct ofbundle *old, struct ofbundle *new) +{ + struct ofproto_dpif *ofproto = old->ofproto; + struct mac_learning *ml = ofproto->ml; + struct mac_entry *mac, *next_mac; + + ovs_assert(new->ofproto == old->ofproto); + + ofproto->backer->need_revalidate = REV_RECONFIGURE; + ovs_rwlock_wrlock(&ml->rwlock); + LIST_FOR_EACH_SAFE (mac, next_mac, lru_node, &ml->lrus) { + if (mac_entry_get_port(ml, mac) == old) { + mac_entry_set_port(ml, mac, new); + } + } + ovs_rwlock_unlock(&ml->rwlock); +} + static struct ofbundle * bundle_lookup(const struct ofproto_dpif *ofproto, void *aux) { @@ -2547,7 +2745,8 @@ bundle_update(struct ofbundle *bundle) LIST_FOR_EACH (port, bundle_node, &bundle->ports) { if (port->up.pp.config & OFPUTIL_PC_NO_FLOOD || port->is_layer3 - || !stp_forward_in_state(port->stp_state)) { + || (bundle->ofproto->stp && !stp_forward_in_state(port->stp_state)) + || (bundle->ofproto->rstp && !rstp_forward_in_state(port->rstp_state))) { bundle->floodable = false; break; } @@ -2580,7 +2779,7 @@ bundle_add_port(struct ofbundle *bundle, ofp_port_t ofp_port, { struct ofport_dpif *port; - port = get_ofp_port(bundle->ofproto, ofp_port); + port = ofp_port_to_ofport(bundle->ofproto, ofp_port); if (!port) { return false; } @@ -2595,7 +2794,8 @@ bundle_add_port(struct ofbundle *bundle, ofp_port_t ofp_port, list_push_back(&bundle->ports, &port->bundle_node); if (port->up.pp.config & OFPUTIL_PC_NO_FLOOD || port->is_layer3 - || !stp_forward_in_state(port->stp_state)) { + || (bundle->ofproto->stp && !stp_forward_in_state(port->stp_state)) + || (bundle->ofproto->rstp && !rstp_forward_in_state(port->rstp_state))) { bundle->floodable = false; } } @@ -2618,7 +2818,7 @@ bundle_destroy(struct ofbundle *bundle) } ofproto = bundle->ofproto; - mbridge_unregister_bundle(ofproto->mbridge, bundle->aux); + mbridge_unregister_bundle(ofproto->mbridge, bundle); xlate_txn_start(); xlate_bundle_remove(bundle); @@ -2841,21 +3041,21 @@ send_pdu_cb(void *port_, const void *pdu, size_t pdu_size) { static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 10); struct ofport_dpif *port = port_; - uint8_t ea[ETH_ADDR_LEN]; + struct eth_addr ea; int error; - error = netdev_get_etheraddr(port->up.netdev, ea); + error = netdev_get_etheraddr(port->up.netdev, &ea); if (!error) { - struct ofpbuf packet; + struct dp_packet packet; void *packet_pdu; - ofpbuf_init(&packet, 0); + dp_packet_init(&packet, 0); packet_pdu = eth_compose(&packet, eth_addr_lacp, ea, ETH_TYPE_LACP, pdu_size); memcpy(packet_pdu, pdu, pdu_size); ofproto_dpif_send_packet(port, &packet); - ofpbuf_uninit(&packet); + dp_packet_uninit(&packet); } else { VLOG_ERR_RL(&rl, "port %s: cannot obtain Ethernet address of iface " "%s (%s)", port->bundle->name, @@ -2867,43 +3067,41 @@ static void bundle_send_learning_packets(struct ofbundle *bundle) { struct ofproto_dpif *ofproto = bundle->ofproto; - struct ofpbuf *learning_packet; int error, n_packets, n_errors; struct mac_entry *e; - struct list packets; + struct pkt_list { + struct ovs_list list_node; + struct ofport_dpif *port; + struct dp_packet *pkt; + } *pkt_node; + struct ovs_list packets; list_init(&packets); ovs_rwlock_rdlock(&ofproto->ml->rwlock); LIST_FOR_EACH (e, lru_node, &ofproto->ml->lrus) { - if (e->port.p != bundle) { - void *port_void; - - learning_packet = bond_compose_learning_packet(bundle->bond, - e->mac, e->vlan, - &port_void); - /* Temporarily use 'frame' as a private pointer (see below). */ - ovs_assert(learning_packet->frame == ofpbuf_data(learning_packet)); - learning_packet->frame = port_void; - list_push_back(&packets, &learning_packet->list_node); + if (mac_entry_get_port(ofproto->ml, e) != bundle) { + pkt_node = xmalloc(sizeof *pkt_node); + pkt_node->pkt = bond_compose_learning_packet(bundle->bond, + e->mac, e->vlan, + (void **)&pkt_node->port); + list_push_back(&packets, &pkt_node->list_node); } } ovs_rwlock_unlock(&ofproto->ml->rwlock); error = n_packets = n_errors = 0; - LIST_FOR_EACH (learning_packet, list_node, &packets) { + LIST_FOR_EACH_POP (pkt_node, list_node, &packets) { int ret; - void *port_void = learning_packet->frame; - /* Restore 'frame'. */ - learning_packet->frame = ofpbuf_data(learning_packet); - ret = ofproto_dpif_send_packet(port_void, learning_packet); + ret = ofproto_dpif_send_packet(pkt_node->port, pkt_node->pkt); + dp_packet_delete(pkt_node->pkt); + free(pkt_node); if (ret) { error = ret; n_errors++; } n_packets++; } - ofpbuf_list_delete(&packets); if (n_errors) { static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); @@ -3064,17 +3262,19 @@ set_mcast_snooping(struct ofproto *ofproto_, return 0; } -/* Configures multicast snooping port's flood setting on 'ofproto'. */ +/* Configures multicast snooping port's flood settings on 'ofproto'. */ static int -set_mcast_snooping_port(struct ofproto *ofproto_, void *aux, bool flood) +set_mcast_snooping_port(struct ofproto *ofproto_, void *aux, + const struct ofproto_mcast_snooping_port_settings *s) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_); struct ofbundle *bundle = bundle_lookup(ofproto, aux); - if (ofproto->ms) { + if (ofproto->ms && s) { ovs_rwlock_wrlock(&ofproto->ms->rwlock); - mcast_snooping_set_port_flood(ofproto->ms, bundle->vlan, bundle, - flood); + mcast_snooping_set_port_flood(ofproto->ms, bundle, s->flood); + mcast_snooping_set_port_flood_reports(ofproto->ms, bundle, + s->flood_reports); ovs_rwlock_unlock(&ofproto->ms->rwlock); } return 0; @@ -3083,8 +3283,8 @@ set_mcast_snooping_port(struct ofproto *ofproto_, void *aux, bool flood) /* Ports. */ -static struct ofport_dpif * -get_ofp_port(const struct ofproto_dpif *ofproto, ofp_port_t ofp_port) +struct ofport_dpif * +ofp_port_to_ofport(const struct ofproto_dpif *ofproto, ofp_port_t ofp_port) { struct ofport *ofport = ofproto_get_port(&ofproto->up, ofp_port); return ofport ? ofport_dpif_cast(ofport) : NULL; @@ -3278,7 +3478,7 @@ static int port_del(struct ofproto *ofproto_, ofp_port_t ofp_port) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofproto_); - struct ofport_dpif *ofport = get_ofp_port(ofproto, ofp_port); + struct ofport_dpif *ofport = ofp_port_to_ofport(ofproto, ofp_port); int error = 0; if (!ofport) { @@ -3499,14 +3699,13 @@ rule_expire(struct rule_dpif *rule) } } -/* Executes, within 'ofproto', the actions in 'rule' or 'ofpacts' on 'packet'. - * 'flow' must reflect the data in 'packet'. */ int -ofproto_dpif_execute_actions(struct ofproto_dpif *ofproto, - const struct flow *flow, - struct rule_dpif *rule, - const struct ofpact *ofpacts, size_t ofpacts_len, - struct ofpbuf *packet) +ofproto_dpif_execute_actions__(struct ofproto_dpif *ofproto, + const struct flow *flow, + struct rule_dpif *rule, + const struct ofpact *ofpacts, size_t ofpacts_len, + int recurse, int resubmits, + struct dp_packet *packet) { struct dpif_flow_stats stats; struct xlate_out xout; @@ -3523,43 +3722,69 @@ ofproto_dpif_execute_actions(struct ofproto_dpif *ofproto, rule_dpif_credit_stats(rule, &stats); } + uint64_t odp_actions_stub[1024 / 8]; + struct ofpbuf odp_actions = OFPBUF_STUB_INITIALIZER(odp_actions_stub); xlate_in_init(&xin, ofproto, flow, flow->in_port.ofp_port, rule, - stats.tcp_flags, packet); + stats.tcp_flags, packet, NULL, &odp_actions); xin.ofpacts = ofpacts; xin.ofpacts_len = ofpacts_len; xin.resubmit_stats = &stats; - xlate_actions(&xin, &xout); + xin.recurse = recurse; + xin.resubmits = resubmits; + if (xlate_actions(&xin, &xout) != XLATE_OK) { + error = EINVAL; + goto out; + } - execute.actions = ofpbuf_data(xout.odp_actions); - execute.actions_len = ofpbuf_size(xout.odp_actions); + execute.actions = odp_actions.data; + execute.actions_len = odp_actions.size; + pkt_metadata_from_flow(&packet->md, flow); execute.packet = packet; - execute.md = pkt_metadata_from_flow(flow); execute.needs_help = (xout.slow & SLOW_ACTION) != 0; execute.probe = false; + execute.mtu = 0; /* Fix up in_port. */ in_port = flow->in_port.ofp_port; if (in_port == OFPP_NONE) { in_port = OFPP_LOCAL; } - execute.md.in_port.odp_port = ofp_port_to_odp_port(ofproto, in_port); + execute.packet->md.in_port.odp_port = ofp_port_to_odp_port(ofproto, in_port); error = dpif_execute(ofproto->backer->dpif, &execute); - +out: xlate_out_uninit(&xout); + ofpbuf_uninit(&odp_actions); return error; } +/* Executes, within 'ofproto', the actions in 'rule' or 'ofpacts' on 'packet'. + * 'flow' must reflect the data in 'packet'. */ +int +ofproto_dpif_execute_actions(struct ofproto_dpif *ofproto, + const struct flow *flow, + struct rule_dpif *rule, + const struct ofpact *ofpacts, size_t ofpacts_len, + struct dp_packet *packet) +{ + return ofproto_dpif_execute_actions__(ofproto, flow, rule, ofpacts, + ofpacts_len, 0, 0, packet); +} + void rule_dpif_credit_stats(struct rule_dpif *rule, const struct dpif_flow_stats *stats) { ovs_mutex_lock(&rule->stats_mutex); - rule->stats.n_packets += stats->n_packets; - rule->stats.n_bytes += stats->n_bytes; - rule->stats.used = MAX(rule->stats.used, stats->used); + if (OVS_UNLIKELY(rule->new_rule)) { + rule_dpif_credit_stats(rule->new_rule, stats); + } else { + rule->stats.n_packets += stats->n_packets; + rule->stats.n_bytes += stats->n_bytes; + rule->stats.used = MAX(rule->stats.used, stats->used); + } ovs_mutex_unlock(&rule->stats_mutex); } @@ -3590,21 +3815,13 @@ static void rule_dpif_set_recirc_id(struct rule_dpif *rule, uint32_t id) OVS_REQUIRES(rule->up.mutex) { - ovs_assert(!rule->recirc_id); - rule->recirc_id = id; -} - -/* Returns 'rule''s recirculation id. */ -uint32_t -rule_dpif_get_recirc_id(struct rule_dpif *rule) - OVS_REQUIRES(rule->up.mutex) -{ - if (!rule->recirc_id) { - struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto); - - rule_dpif_set_recirc_id(rule, ofproto_dpif_alloc_recirc_id(ofproto)); + ovs_assert(!rule->recirc_id || rule->recirc_id == id); + if (rule->recirc_id == id) { + /* Release the new reference to the same id. */ + recirc_free_id(id); + } else { + rule->recirc_id = id; } - return rule->recirc_id; } /* Sets 'rule''s recirculation id. */ @@ -3618,74 +3835,38 @@ rule_set_recirc_id(struct rule *rule_, uint32_t id) ovs_mutex_unlock(&rule->up.mutex); } -/* Lookup 'flow' in table 0 of 'ofproto''s classifier. - * If 'wc' is non-null, sets the fields that were relevant as part of - * the lookup. Returns the table id where a match or miss occurred via - * 'table_id'. This will be zero unless there was a miss and - * OFPTC11_TABLE_MISS_CONTINUE is in effect for the sequence of tables - * where misses occur, or TBL_INTERNAL if the rule has a non-zero - * recirculation ID, and a match was found in the internal table, or if - * there was no match and one of the special rules (drop_frags_rule, - * miss_rule, or no_packet_in_rule) was returned. - * - * The return value is the found rule, which is valid at least until the next - * RCU quiescent period. If the rule needs to stay around longer, - * a non-zero 'take_ref' must be passed in to cause a reference to be taken - * on it before this returns. */ -struct rule_dpif * -rule_dpif_lookup(struct ofproto_dpif *ofproto, struct flow *flow, - struct flow_wildcards *wc, bool take_ref, - const struct dpif_flow_stats *stats, uint8_t *table_id) +cls_version_t +ofproto_dpif_get_tables_version(struct ofproto_dpif *ofproto OVS_UNUSED) { - *table_id = 0; + cls_version_t version; - if (ofproto_dpif_get_enable_recirc(ofproto)) { - /* Always exactly match recirc_id since datapath supports - * recirculation. */ - if (wc) { - wc->masks.recirc_id = UINT32_MAX; - } - if (flow->recirc_id) { - /* Start looking up from internal table for post recirculation - * flows or packets. */ - *table_id = TBL_INTERNAL; - } - } + atomic_read_relaxed(&ofproto->tables_version, &version); - return rule_dpif_lookup_from_table(ofproto, flow, wc, take_ref, stats, - table_id, flow->in_port.ofp_port, true, - true); + return version; } /* The returned rule (if any) is valid at least until the next RCU quiescent - * period. If the rule needs to stay around longer, a non-zero 'take_ref' - * must be passed in to cause a reference to be taken on it. */ + * period. If the rule needs to stay around longer, the caller should take + * a reference. + * + * 'flow' is non-const to allow for temporary modifications during the lookup. + * Any changes are restored before returning. */ static struct rule_dpif * -rule_dpif_lookup_in_table(struct ofproto_dpif *ofproto, uint8_t table_id, - const struct flow *flow, struct flow_wildcards *wc, - bool take_ref) +rule_dpif_lookup_in_table(struct ofproto_dpif *ofproto, cls_version_t version, + uint8_t table_id, struct flow *flow, + struct flow_wildcards *wc) { struct classifier *cls = &ofproto->up.tables[table_id].cls; - const struct cls_rule *cls_rule; - struct rule_dpif *rule; - - do { - cls_rule = classifier_lookup(cls, flow, wc); - - rule = rule_dpif_cast(rule_from_cls_rule(cls_rule)); - - /* Try again if the rule was released before we get the reference. */ - } while (rule && take_ref && !rule_dpif_try_ref(rule)); - - return rule; + return rule_dpif_cast(rule_from_cls_rule(classifier_lookup(cls, version, + flow, wc))); } -/* Look up 'flow' in 'ofproto''s classifier starting from table '*table_id'. - * Returns the rule that was found, which may be one of the special rules - * according to packet miss hadling. If 'may_packet_in' is false, returning of - * the miss_rule (which issues packet ins for the controller) is avoided. - * Updates 'wc', if nonnull, to reflect the fields that were used during the - * lookup. +/* Look up 'flow' in 'ofproto''s classifier version 'version', starting from + * table '*table_id'. Returns the rule that was found, which may be one of the + * special rules according to packet miss hadling. If 'may_packet_in' is + * false, returning of the miss_rule (which issues packet ins for the + * controller) is avoided. Updates 'wc', if nonnull, to reflect the fields + * that were used during the lookup. * * If 'honor_table_miss' is true, the first lookup occurs in '*table_id', but * if none is found then the table miss configuration for that table is @@ -3697,15 +3878,18 @@ rule_dpif_lookup_in_table(struct ofproto_dpif *ofproto, uint8_t table_id, * '*table_id'. * * The rule is returned in '*rule', which is valid at least until the next - * RCU quiescent period. If the '*rule' needs to stay around longer, - * a non-zero 'take_ref' must be passed in to cause a reference to be taken - * on it before this returns. + * RCU quiescent period. If the '*rule' needs to stay around longer, the + * caller must take a reference. * * 'in_port' allows the lookup to take place as if the in port had the value - * 'in_port'. This is needed for resubmit action support. */ + * 'in_port'. This is needed for resubmit action support. + * + * 'flow' is non-const to allow for temporary modifications during the lookup. + * Any changes are restored before returning. */ struct rule_dpif * -rule_dpif_lookup_from_table(struct ofproto_dpif *ofproto, struct flow *flow, - struct flow_wildcards *wc, bool take_ref, +rule_dpif_lookup_from_table(struct ofproto_dpif *ofproto, + cls_version_t version, struct flow *flow, + struct flow_wildcards *wc, const struct dpif_flow_stats *stats, uint8_t *table_id, ofp_port_t in_port, bool may_packet_in, bool honor_table_miss) @@ -3728,9 +3912,6 @@ rule_dpif_lookup_from_table(struct ofproto_dpif *ofproto, struct flow *flow, /* Must be OFPC_FRAG_DROP (we don't have OFPC_FRAG_REASM). * Use the drop_frags_rule (which cannot disappear). */ rule = ofproto->drop_frags_rule; - if (take_ref) { - rule_dpif_ref(rule); - } if (stats) { struct oftable *tbl = &ofproto->up.tables[*table_id]; unsigned long orig; @@ -3757,7 +3938,7 @@ rule_dpif_lookup_from_table(struct ofproto_dpif *ofproto, struct flow *flow, next_id++, next_id += (next_id == TBL_INTERNAL)) { *table_id = next_id; - rule = rule_dpif_lookup_in_table(ofproto, next_id, flow, wc, take_ref); + rule = rule_dpif_lookup_in_table(ofproto, version, next_id, flow, wc); if (stats) { struct oftable *tbl = &ofproto->up.tables[next_id]; unsigned long orig; @@ -3784,7 +3965,7 @@ rule_dpif_lookup_from_table(struct ofproto_dpif *ofproto, struct flow *flow, || miss_config == OFPUTIL_TABLE_MISS_CONTROLLER) { struct ofport_dpif *port; - port = get_ofp_port(ofproto, old_in_port); + port = ofp_port_to_ofport(ofproto, old_in_port); if (!port) { VLOG_WARN_RL(&rl, "packet-in on unknown OpenFlow port %"PRIu16, old_in_port); @@ -3796,9 +3977,6 @@ rule_dpif_lookup_from_table(struct ofproto_dpif *ofproto, struct flow *flow, rule = ofproto->miss_rule; } } - if (take_ref) { - rule_dpif_ref(rule); - } out: /* Restore port numbers, as they may have been modified above. */ flow->tp_src = old_tp_src; @@ -3826,7 +4004,7 @@ static struct rule_dpif *rule_dpif_cast(const struct rule *rule) static struct rule * rule_alloc(void) { - struct rule_dpif *rule = xmalloc(sizeof *rule); + struct rule_dpif *rule = xzalloc(sizeof *rule); return &rule->up; } @@ -3837,27 +4015,140 @@ rule_dealloc(struct rule *rule_) free(rule); } +static enum ofperr +check_mask(struct ofproto_dpif *ofproto, const struct miniflow *flow) +{ + const struct odp_support *support; + uint16_t ct_state, ct_zone; + ovs_u128 ct_label; + uint32_t ct_mark; + + support = &ofproto_dpif_get_support(ofproto)->odp; + ct_state = MINIFLOW_GET_U16(flow, ct_state); + if (support->ct_state && support->ct_zone && support->ct_mark + && support->ct_label && support->ct_state_nat) { + return ct_state & CS_UNSUPPORTED_MASK ? OFPERR_OFPBMC_BAD_MASK : 0; + } + + ct_zone = MINIFLOW_GET_U16(flow, ct_zone); + ct_mark = MINIFLOW_GET_U32(flow, ct_mark); + ct_label = MINIFLOW_GET_U128(flow, ct_label); + + if ((ct_state && !support->ct_state) + || (ct_state & CS_UNSUPPORTED_MASK) + || ((ct_state & (CS_SRC_NAT | CS_DST_NAT)) && !support->ct_state_nat) + || (ct_zone && !support->ct_zone) + || (ct_mark && !support->ct_mark) + || (!ovs_u128_is_zero(&ct_label) && !support->ct_label)) { + return OFPERR_OFPBMC_BAD_MASK; + } + + return 0; +} + +static enum ofperr +check_actions(const struct ofproto_dpif *ofproto, + const struct rule_actions *const actions) +{ + const struct ofpact *ofpact; + + OFPACT_FOR_EACH (ofpact, actions->ofpacts, actions->ofpacts_len) { + const struct odp_support *support; + const struct ofpact_conntrack *ct; + const struct ofpact *a; + + if (ofpact->type != OFPACT_CT) { + continue; + } + + ct = CONTAINER_OF(ofpact, struct ofpact_conntrack, ofpact); + support = &ofproto_dpif_get_support(ofproto)->odp; + + if (!support->ct_state) { + return OFPERR_OFPBAC_BAD_TYPE; + } + if ((ct->zone_imm || ct->zone_src.field) && !support->ct_zone) { + return OFPERR_OFPBAC_BAD_ARGUMENT; + } + + OFPACT_FOR_EACH(a, ct->actions, ofpact_ct_get_action_len(ct)) { + const struct mf_field *dst = ofpact_get_mf_dst(a); + + if (a->type == OFPACT_NAT && !support->ct_state_nat) { + /* The backer doesn't seem to support the NAT bits in + * 'ct_state': assume that it doesn't support the NAT + * action. */ + return OFPERR_OFPBAC_BAD_TYPE; + } + if (dst && ((dst->id == MFF_CT_MARK && !support->ct_mark) + || (dst->id == MFF_CT_LABEL && !support->ct_label))) { + return OFPERR_OFPBAC_BAD_SET_ARGUMENT; + } + } + } + + return 0; +} + +static enum ofperr +rule_check(struct rule *rule) +{ + struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->ofproto); + enum ofperr err; + + err = check_mask(ofproto, &rule->cr.match.mask->masks); + if (err) { + return err; + } + return check_actions(ofproto, rule->actions); +} + static enum ofperr rule_construct(struct rule *rule_) OVS_NO_THREAD_SAFETY_ANALYSIS { struct rule_dpif *rule = rule_dpif_cast(rule_); + int error; + + error = rule_check(rule_); + if (error) { + return error; + } + ovs_mutex_init_adaptive(&rule->stats_mutex); rule->stats.n_packets = 0; rule->stats.n_bytes = 0; rule->stats.used = rule->up.modified; rule->recirc_id = 0; + rule->new_rule = NULL; return 0; } -static enum ofperr -rule_insert(struct rule *rule_) +static void +rule_insert(struct rule *rule_, struct rule *old_rule_, bool forward_stats) OVS_REQUIRES(ofproto_mutex) { struct rule_dpif *rule = rule_dpif_cast(rule_); + + if (old_rule_ && forward_stats) { + struct rule_dpif *old_rule = rule_dpif_cast(old_rule_); + + ovs_assert(!old_rule->new_rule); + + /* Take a reference to the new rule, and refer all stats updates from + * the old rule to the new rule. */ + rule_dpif_ref(rule); + + ovs_mutex_lock(&old_rule->stats_mutex); + ovs_mutex_lock(&rule->stats_mutex); + old_rule->new_rule = rule; /* Forward future stats. */ + rule->stats = old_rule->stats; /* Transfer stats to the new rule. */ + ovs_mutex_unlock(&rule->stats_mutex); + ovs_mutex_unlock(&old_rule->stats_mutex); + } + complete_operation(rule); - return 0; } static void @@ -3870,14 +4161,17 @@ rule_delete(struct rule *rule_) static void rule_destruct(struct rule *rule_) + OVS_NO_THREAD_SAFETY_ANALYSIS { struct rule_dpif *rule = rule_dpif_cast(rule_); ovs_mutex_destroy(&rule->stats_mutex); + /* Release reference to the new rule, if any. */ + if (rule->new_rule) { + rule_dpif_unref(rule->new_rule); + } if (rule->recirc_id) { - struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto); - - ofproto_dpif_free_recirc_id(ofproto, rule->recirc_id); + recirc_free_id(rule->recirc_id); } } @@ -3888,15 +4182,19 @@ rule_get_stats(struct rule *rule_, uint64_t *packets, uint64_t *bytes, struct rule_dpif *rule = rule_dpif_cast(rule_); ovs_mutex_lock(&rule->stats_mutex); - *packets = rule->stats.n_packets; - *bytes = rule->stats.n_bytes; - *used = rule->stats.used; + if (OVS_UNLIKELY(rule->new_rule)) { + rule_get_stats(&rule->new_rule->up, packets, bytes, used); + } else { + *packets = rule->stats.n_packets; + *bytes = rule->stats.n_bytes; + *used = rule->stats.used; + } ovs_mutex_unlock(&rule->stats_mutex); } static void rule_dpif_execute(struct rule_dpif *rule, const struct flow *flow, - struct ofpbuf *packet) + struct dp_packet *packet) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(rule->up.ofproto); @@ -3905,29 +4203,13 @@ rule_dpif_execute(struct rule_dpif *rule, const struct flow *flow, static enum ofperr rule_execute(struct rule *rule, const struct flow *flow, - struct ofpbuf *packet) + struct dp_packet *packet) { rule_dpif_execute(rule_dpif_cast(rule), flow, packet); - ofpbuf_delete(packet); + dp_packet_delete(packet); return 0; } -static void -rule_modify_actions(struct rule *rule_, bool reset_counters) - OVS_REQUIRES(ofproto_mutex) -{ - struct rule_dpif *rule = rule_dpif_cast(rule_); - - if (reset_counters) { - ovs_mutex_lock(&rule->stats_mutex); - rule->stats.n_packets = 0; - rule->stats.n_bytes = 0; - ovs_mutex_unlock(&rule->stats_mutex); - } - - complete_operation(rule); -} - static struct group_dpif *group_dpif_cast(const struct ofgroup *group) { return group ? CONTAINER_OF(group, struct group_dpif, up) : NULL; @@ -3952,7 +4234,7 @@ group_construct_stats(struct group_dpif *group) OVS_REQUIRES(group->stats_mutex) { struct ofputil_bucket *bucket; - const struct list *buckets; + const struct ovs_list *buckets; group->packet_count = 0; group->byte_count = 0; @@ -3976,7 +4258,7 @@ group_dpif_credit_stats(struct group_dpif *group, bucket->stats.packet_count += stats->n_packets; bucket->stats.byte_count += stats->n_bytes; } else { /* Credit to all buckets */ - const struct list *buckets; + const struct ovs_list *buckets; group_dpif_get_buckets(group, &buckets); LIST_FOR_EACH (bucket, list_node, buckets) { @@ -3991,19 +4273,6 @@ static enum ofperr group_construct(struct ofgroup *group_) { struct group_dpif *group = group_dpif_cast(group_); - const struct ofputil_bucket *bucket; - - /* Prevent group chaining because our locking structure makes it hard to - * implement deadlock-free. (See xlate_group_resource_check().) */ - LIST_FOR_EACH (bucket, list_node, &group->up.buckets) { - const struct ofpact *a; - - OFPACT_FOR_EACH (a, bucket->ofpacts, bucket->ofpacts_len) { - if (a->type == OFPACT_GROUP) { - return OFPERR_OFPGMFC_CHAINING_UNSUPPORTED; - } - } - } ovs_mutex_init_adaptive(&group->stats_mutex); ovs_mutex_lock(&group->stats_mutex); @@ -4034,7 +4303,7 @@ group_get_stats(const struct ofgroup *group_, struct ofputil_group_stats *ogs) { struct group_dpif *group = group_dpif_cast(group_); struct ofputil_bucket *bucket; - const struct list *buckets; + const struct ovs_list *buckets; struct bucket_counter *bucket_stats; ovs_mutex_lock(&group->stats_mutex); @@ -4072,7 +4341,7 @@ group_dpif_lookup(struct ofproto_dpif *ofproto, uint32_t group_id, void group_dpif_get_buckets(const struct group_dpif *group, - const struct list **buckets) + const struct ovs_list **buckets) { *buckets = &group->up.buckets; } @@ -4082,12 +4351,18 @@ group_dpif_get_type(const struct group_dpif *group) { return group->up.type; } + +const char * +group_dpif_get_selection_method(const struct group_dpif *group) +{ + return group->up.props.selection_method; +} /* Sends 'packet' out 'ofport'. * May modify 'packet'. * Returns 0 if successful, otherwise a positive errno value. */ int -ofproto_dpif_send_packet(const struct ofport_dpif *ofport, struct ofpbuf *packet) +ofproto_dpif_send_packet(const struct ofport_dpif *ofport, struct dp_packet *packet) { struct ofproto_dpif *ofproto = ofproto_dpif_cast(ofport->up.ofproto); int error; @@ -4096,10 +4371,22 @@ ofproto_dpif_send_packet(const struct ofport_dpif *ofport, struct ofpbuf *packet ovs_mutex_lock(&ofproto->stats_mutex); ofproto->stats.tx_packets++; - ofproto->stats.tx_bytes += ofpbuf_size(packet); + ofproto->stats.tx_bytes += dp_packet_size(packet); ovs_mutex_unlock(&ofproto->stats_mutex); return error; } + +uint64_t +group_dpif_get_selection_method_param(const struct group_dpif *group) +{ + return group->up.props.selection_method_param; +} + +const struct field_array * +group_dpif_get_fields(const struct group_dpif *group) +{ + return &group->up.props.fields; +} /* Return the version string of the datapath that backs up * this 'ofproto'. @@ -4126,7 +4413,7 @@ set_frag_handling(struct ofproto *ofproto_, } static enum ofperr -packet_out(struct ofproto *ofproto_, struct ofpbuf *packet, +packet_out(struct ofproto *ofproto_, struct dp_packet *packet, const struct flow *flow, const struct ofpact *ofpacts, size_t ofpacts_len) { @@ -4263,7 +4550,7 @@ ofproto_unixctl_fdb_show(struct unixctl_conn *conn, int argc OVS_UNUSED, ds_put_cstr(&ds, " port VLAN MAC Age\n"); ovs_rwlock_rdlock(&ofproto->ml->rwlock); LIST_FOR_EACH (e, lru_node, &ofproto->ml->lrus) { - struct ofbundle *bundle = e->port.p; + struct ofbundle *bundle = mac_entry_get_port(ofproto->ml, e); char name[OFP_MAX_PORT_NAME_LEN]; ofputil_port_to_string(ofbundle_get_a_port(bundle)->up.ofp_port, @@ -4310,8 +4597,9 @@ ofproto_unixctl_mcast_snooping_show(struct unixctl_conn *conn, bundle = b->port; ofputil_port_to_string(ofbundle_get_a_port(bundle)->up.ofp_port, name, sizeof name); - ds_put_format(&ds, "%5s %4d "IP_FMT" %3d\n", - name, grp->vlan, IP_ARGS(grp->ip4), + ds_put_format(&ds, "%5s %4d ", name, grp->vlan); + ipv6_format_mapped(&grp->addr, &ds); + ds_put_format(&ds, " %3d\n", mcast_bundle_age(ofproto->ms, b)); } } @@ -4323,7 +4611,7 @@ ofproto_unixctl_mcast_snooping_show(struct unixctl_conn *conn, bundle = mrouter->port; ofputil_port_to_string(ofbundle_get_a_port(bundle)->up.ofp_port, name, sizeof name); - ds_put_format(&ds, "%5s %4d querier %3d\n", + ds_put_format(&ds, "%5s %4d querier %3d\n", name, mrouter->vlan, mcast_mrouter_age(ofproto->ms, mrouter)); } @@ -4337,8 +4625,9 @@ struct trace_ctx { struct xlate_in xin; const struct flow *key; struct flow flow; - struct flow_wildcards wc; struct ds *result; + struct flow_wildcards wc; + struct ofpbuf odp_actions; }; static void @@ -4405,12 +4694,11 @@ static void trace_format_odp(struct ds *result, int level, const char *title, struct trace_ctx *trace) { - struct ofpbuf *odp_actions = trace->xout.odp_actions; + struct ofpbuf *odp_actions = &trace->odp_actions; ds_put_char_multiple(result, '\t', level); ds_put_format(result, "%s: ", title); - format_odp_actions(result, ofpbuf_data(odp_actions), - ofpbuf_size(odp_actions)); + format_odp_actions(result, odp_actions->data, odp_actions->size); ds_put_char(result, '\n'); } @@ -4422,13 +4710,17 @@ trace_format_megaflow(struct ds *result, int level, const char *title, ds_put_char_multiple(result, '\t', level); ds_put_format(result, "%s: ", title); - flow_wildcards_or(&trace->wc, &trace->xout.wc, &trace->wc); match_init(&match, trace->key, &trace->wc); match_format(&match, result, OFP_DEFAULT_PRIORITY); ds_put_char(result, '\n'); } -static void trace_report(struct xlate_in *xin, const char *s, int recurse); +static void trace_report(struct xlate_in *, int recurse, + const char *format, ...) + OVS_PRINTF_FORMAT(3, 4); +static void trace_report_valist(struct xlate_in *, int recurse, + const char *format, va_list args) + OVS_PRINTF_FORMAT(3, 0); static void trace_resubmit(struct xlate_in *xin, struct rule_dpif *rule, int recurse) @@ -4438,15 +4730,15 @@ trace_resubmit(struct xlate_in *xin, struct rule_dpif *rule, int recurse) if (!recurse) { if (rule == xin->ofproto->miss_rule) { - trace_report(xin, "No match, flow generates \"packet in\"s.", - recurse); + trace_report(xin, recurse, + "No match, flow generates \"packet in\"s."); } else if (rule == xin->ofproto->no_packet_in_rule) { - trace_report(xin, "No match, packets dropped because " - "OFPPC_NO_PACKET_IN is set on in_port.", recurse); + trace_report(xin, recurse, "No match, packets dropped because " + "OFPPC_NO_PACKET_IN is set on in_port."); } else if (rule == xin->ofproto->drop_frags_rule) { - trace_report(xin, "Packets dropped because they are IP " + trace_report(xin, recurse, "Packets dropped because they are IP " "fragments and the fragment handling mode is " - "\"drop\".", recurse); + "\"drop\"."); } } @@ -4461,16 +4753,27 @@ trace_resubmit(struct xlate_in *xin, struct rule_dpif *rule, int recurse) } static void -trace_report(struct xlate_in *xin, const char *s, int recurse) +trace_report_valist(struct xlate_in *xin, int recurse, + const char *format, va_list args) { struct trace_ctx *trace = CONTAINER_OF(xin, struct trace_ctx, xin); struct ds *result = trace->result; ds_put_char_multiple(result, '\t', recurse); - ds_put_cstr(result, s); + ds_put_format_valist(result, format, args); ds_put_char(result, '\n'); } +static void +trace_report(struct xlate_in *xin, int recurse, const char *format, ...) +{ + va_list args; + + va_start(args, format); + trace_report_valist(xin, recurse, format, args); + va_end(args); +} + /* Parses the 'argc' elements of 'argv', ignoring argv[0]. The following * forms are supported: * @@ -4479,16 +4782,16 @@ trace_report(struct xlate_in *xin, const char *s, int recurse) * * On success, initializes '*ofprotop' and 'flow' and returns NULL. On failure * returns a nonnull malloced error message. */ -static char * WARN_UNUSED_RESULT +static char * OVS_WARN_UNUSED_RESULT parse_flow_and_packet(int argc, const char *argv[], struct ofproto_dpif **ofprotop, struct flow *flow, - struct ofpbuf **packetp) + struct dp_packet **packetp) { const struct dpif_backer *backer = NULL; const char *error = NULL; char *m_err = NULL; struct simap port_names = SIMAP_INITIALIZER(&port_names); - struct ofpbuf *packet; + struct dp_packet *packet; struct ofpbuf odp_key; struct ofpbuf odp_mask; @@ -4497,7 +4800,7 @@ parse_flow_and_packet(int argc, const char *argv[], /* Handle "-generate" or a hex string as the last argument. */ if (!strcmp(argv[argc - 1], "-generate")) { - packet = ofpbuf_new(0); + packet = dp_packet_new(0); argc--; } else { error = eth_from_hex(argv[argc - 1], &packet); @@ -4552,9 +4855,8 @@ parse_flow_and_packet(int argc, const char *argv[], goto exit; } - if (odp_flow_key_to_flow(ofpbuf_data(&odp_key), ofpbuf_size(&odp_key), - flow) == ODP_FIT_ERROR) { - error = "Failed to parse flow key"; + if (odp_flow_key_to_flow(odp_key.data, odp_key.size, flow) == ODP_FIT_ERROR) { + error = "Failed to parse datapath flow key"; goto exit; } @@ -4571,7 +4873,7 @@ parse_flow_and_packet(int argc, const char *argv[], char *err = parse_ofp_exact_flow(flow, NULL, argv[argc - 1], NULL); if (err) { - m_err = xasprintf("Bad flow syntax: %s", err); + m_err = xasprintf("Bad openflow flow syntax: %s", err); free(err); goto exit; } else { @@ -4590,14 +4892,13 @@ parse_flow_and_packet(int argc, const char *argv[], /* Generate a packet, if requested. */ if (packet) { - if (!ofpbuf_size(packet)) { + if (!dp_packet_size(packet)) { flow_compose(packet, flow); } else { - struct pkt_metadata md = pkt_metadata_from_flow(flow); - /* Use the metadata from the flow and the packet argument * to reconstruct the flow. */ - flow_extract(packet, &md, flow); + pkt_metadata_from_flow(&packet->md, flow); + flow_extract(packet, flow); } } @@ -4606,7 +4907,7 @@ exit: m_err = xstrdup(error); } if (m_err) { - ofpbuf_delete(packet); + dp_packet_delete(packet); packet = NULL; } *packetp = packet; @@ -4621,7 +4922,7 @@ ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[], void *aux OVS_UNUSED) { struct ofproto_dpif *ofproto; - struct ofpbuf *packet; + struct dp_packet *packet; char *error; struct flow flow; @@ -4633,7 +4934,7 @@ ofproto_unixctl_trace(struct unixctl_conn *conn, int argc, const char *argv[], ofproto_trace(ofproto, &flow, packet, NULL, 0, &result); unixctl_command_reply(conn, ds_cstr(&result)); ds_destroy(&result); - ofpbuf_delete(packet); + dp_packet_delete(packet); } else { unixctl_command_reply_error(conn, error); free(error); @@ -4648,7 +4949,7 @@ ofproto_unixctl_trace_actions(struct unixctl_conn *conn, int argc, struct ofproto_dpif *ofproto; bool enforce_consistency; struct ofpbuf ofpacts; - struct ofpbuf *packet; + struct dp_packet *packet; struct ds result; struct flow flow; uint16_t in_port; @@ -4703,13 +5004,18 @@ ofproto_unixctl_trace_actions(struct unixctl_conn *conn, int argc, goto exit; } if (enforce_consistency) { - retval = ofpacts_check_consistency(ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts), - &flow, u16_to_ofp(ofproto->up.max_ports), - 0, 0, usable_protocols); + retval = ofpacts_check_consistency(ofpacts.data, ofpacts.size, &flow, + u16_to_ofp(ofproto->up.max_ports), + 0, ofproto->up.n_tables, + usable_protocols); } else { - retval = ofpacts_check(ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts), &flow, - u16_to_ofp(ofproto->up.max_ports), 0, 0, - &usable_protocols); + retval = ofpacts_check(ofpacts.data, ofpacts.size, &flow, + u16_to_ofp(ofproto->up.max_ports), 0, + ofproto->up.n_tables, &usable_protocols); + } + if (!retval) { + retval = ofproto_check_ofpacts(&ofproto->up, ofpacts.data, + ofpacts.size); } if (retval) { @@ -4720,12 +5026,12 @@ ofproto_unixctl_trace_actions(struct unixctl_conn *conn, int argc, } ofproto_trace(ofproto, &flow, packet, - ofpbuf_data(&ofpacts), ofpbuf_size(&ofpacts), &result); + ofpacts.data, ofpacts.size, &result); unixctl_command_reply(conn, ds_cstr(&result)); exit: ds_destroy(&result); - ofpbuf_delete(packet); + dp_packet_delete(packet); ofpbuf_uninit(&ofpacts); } @@ -4740,40 +5046,43 @@ exit: * trace, otherwise the actions are determined by a flow table lookup. */ static void ofproto_trace(struct ofproto_dpif *ofproto, struct flow *flow, - const struct ofpbuf *packet, + const struct dp_packet *packet, const struct ofpact ofpacts[], size_t ofpacts_len, struct ds *ds) { struct trace_ctx trace; + enum xlate_error error; ds_put_format(ds, "Bridge: %s\n", ofproto->up.name); ds_put_cstr(ds, "Flow: "); flow_format(ds, flow); ds_put_char(ds, '\n'); - flow_wildcards_init_catchall(&trace.wc); + ofpbuf_init(&trace.odp_actions, 0); trace.result = ds; trace.key = flow; /* Original flow key, used for megaflow. */ trace.flow = *flow; /* May be modified by actions. */ xlate_in_init(&trace.xin, ofproto, flow, flow->in_port.ofp_port, NULL, - ntohs(flow->tcp_flags), packet); + ntohs(flow->tcp_flags), packet, &trace.wc, + &trace.odp_actions); trace.xin.ofpacts = ofpacts; trace.xin.ofpacts_len = ofpacts_len; trace.xin.resubmit_hook = trace_resubmit; - trace.xin.report_hook = trace_report; - - xlate_actions(&trace.xin, &trace.xout); + trace.xin.report_hook = trace_report_valist; + error = xlate_actions(&trace.xin, &trace.xout); ds_put_char(ds, '\n'); trace_format_flow(ds, 0, "Final flow", &trace); trace_format_megaflow(ds, 0, "Megaflow", &trace); ds_put_cstr(ds, "Datapath actions: "); - format_odp_actions(ds, ofpbuf_data(trace.xout.odp_actions), - ofpbuf_size(trace.xout.odp_actions)); + format_odp_actions(ds, trace.odp_actions.data, trace.odp_actions.size); - if (trace.xout.slow) { + if (error != XLATE_OK) { + ds_put_format(ds, "\nTranslation failed (%s), packet is dropped.\n", + xlate_strerror(error)); + } else if (trace.xout.slow) { enum slow_path_reason slow; ds_put_cstr(ds, "\nThis flow is handled by the userspace " @@ -4791,6 +5100,7 @@ ofproto_trace(struct ofproto_dpif *ofproto, struct flow *flow, } xlate_out_uninit(&trace.xout); + ofpbuf_uninit(&trace.odp_actions); } /* Store the current ofprotos in 'ofproto_shash'. Returns a sorted list @@ -4955,7 +5265,7 @@ ofproto_unixctl_dpif_dump_flows(struct unixctl_conn *conn, } ds_init(&ds); - flow_dump = dpif_flow_dump_create(ofproto->backer->dpif); + flow_dump = dpif_flow_dump_create(ofproto->backer->dpif, false); flow_dump_thread = dpif_flow_dump_thread_create(flow_dump); while (dpif_flow_dump_next(flow_dump_thread, &f, 1)) { struct flow flow; @@ -4965,6 +5275,10 @@ ofproto_unixctl_dpif_dump_flows(struct unixctl_conn *conn, continue; } + if (verbosity) { + odp_format_ufid(&f.ufid, &ds); + ds_put_cstr(&ds, " "); + } odp_flow_format(f.key, f.key_len, f.mask, f.mask_len, &portno_names, &ds, verbosity); ds_put_cstr(&ds, ", "); @@ -5014,6 +5328,8 @@ disable_tnl_push_pop(struct unixctl_conn *conn OVS_UNUSED, int argc OVS_UNUSED, ofproto_use_tnl_push_pop = true; unixctl_command_reply(conn, "Tunnel push-pop on"); ofproto_revalidate_all_backers(); + } else { + unixctl_command_reply_error(conn, "Invalid argument"); } } @@ -5213,7 +5529,7 @@ vsp_vlandev_to_realdev(const struct ofproto_dpif *ofproto, * changes. */ bool vsp_adjust_flow(const struct ofproto_dpif *ofproto, struct flow *flow, - struct ofpbuf *packet) + struct dp_packet *packet) OVS_EXCLUDED(ofproto->vsp_mutex) { ofp_port_t realdev; @@ -5298,7 +5614,7 @@ vsp_add(struct ofport_dpif *port, ofp_port_t realdev_ofp_port, int vid) static odp_port_t ofp_port_to_odp_port(const struct ofproto_dpif *ofproto, ofp_port_t ofp_port) { - const struct ofport_dpif *ofport = get_ofp_port(ofproto, ofp_port); + const struct ofport_dpif *ofport = ofp_port_to_ofport(ofproto, ofp_port); return ofport ? ofport->odp_port : ODPP_NONE; } @@ -5333,22 +5649,6 @@ odp_port_to_ofp_port(const struct ofproto_dpif *ofproto, odp_port_t odp_port) } } -uint32_t -ofproto_dpif_alloc_recirc_id(struct ofproto_dpif *ofproto) -{ - struct dpif_backer *backer = ofproto->backer; - - return recirc_id_alloc(backer->rid_pool); -} - -void -ofproto_dpif_free_recirc_id(struct ofproto_dpif *ofproto, uint32_t recirc_id) -{ - struct dpif_backer *backer = ofproto->backer; - - recirc_id_free(backer->rid_pool, recirc_id); -} - int ofproto_dpif_add_internal_flow(struct ofproto_dpif *ofproto, const struct match *match, int priority, @@ -5356,28 +5656,28 @@ ofproto_dpif_add_internal_flow(struct ofproto_dpif *ofproto, const struct ofpbuf *ofpacts, struct rule **rulep) { - struct ofputil_flow_mod fm; + struct ofproto_flow_mod ofm; struct rule_dpif *rule; int error; - fm.match = *match; - fm.priority = priority; - fm.new_cookie = htonll(0); - fm.cookie = htonll(0); - fm.cookie_mask = htonll(0); - fm.modify_cookie = false; - fm.table_id = TBL_INTERNAL; - fm.command = OFPFC_ADD; - fm.idle_timeout = idle_timeout; - fm.hard_timeout = 0; - fm.importance = 0; - fm.buffer_id = 0; - fm.out_port = 0; - fm.flags = OFPUTIL_FF_HIDDEN_FIELDS | OFPUTIL_FF_NO_READONLY; - fm.ofpacts = ofpbuf_data(ofpacts); - fm.ofpacts_len = ofpbuf_size(ofpacts); - - error = ofproto_flow_mod(&ofproto->up, &fm); + ofm.fm.match = *match; + ofm.fm.priority = priority; + ofm.fm.new_cookie = htonll(0); + ofm.fm.cookie = htonll(0); + ofm.fm.cookie_mask = htonll(0); + ofm.fm.modify_cookie = false; + ofm.fm.table_id = TBL_INTERNAL; + ofm.fm.command = OFPFC_ADD; + ofm.fm.idle_timeout = idle_timeout; + ofm.fm.hard_timeout = 0; + ofm.fm.importance = 0; + ofm.fm.buffer_id = 0; + ofm.fm.out_port = 0; + ofm.fm.flags = OFPUTIL_FF_HIDDEN_FIELDS | OFPUTIL_FF_NO_READONLY; + ofm.fm.ofpacts = ofpacts->data; + ofm.fm.ofpacts_len = ofpacts->size; + + error = ofproto_flow_mod(&ofproto->up, &ofm); if (error) { VLOG_ERR_RL(&rl, "failed to add internal flow (%s)", ofperr_to_string(error)); @@ -5385,8 +5685,10 @@ ofproto_dpif_add_internal_flow(struct ofproto_dpif *ofproto, return error; } - rule = rule_dpif_lookup_in_table(ofproto, TBL_INTERNAL, &fm.match.flow, - &fm.match.wc, false); + rule = rule_dpif_lookup_in_table(ofproto, + ofproto_dpif_get_tables_version(ofproto), + TBL_INTERNAL, &ofm.fm.match.flow, + &ofm.fm.match.wc); if (rule) { *rulep = &rule->up; } else { @@ -5399,20 +5701,20 @@ int ofproto_dpif_delete_internal_flow(struct ofproto_dpif *ofproto, struct match *match, int priority) { - struct ofputil_flow_mod fm; + struct ofproto_flow_mod ofm; int error; - fm.match = *match; - fm.priority = priority; - fm.new_cookie = htonll(0); - fm.cookie = htonll(0); - fm.cookie_mask = htonll(0); - fm.modify_cookie = false; - fm.table_id = TBL_INTERNAL; - fm.flags = OFPUTIL_FF_HIDDEN_FIELDS | OFPUTIL_FF_NO_READONLY; - fm.command = OFPFC_DELETE_STRICT; - - error = ofproto_flow_mod(&ofproto->up, &fm); + ofm.fm.match = *match; + ofm.fm.priority = priority; + ofm.fm.new_cookie = htonll(0); + ofm.fm.cookie = htonll(0); + ofm.fm.cookie_mask = htonll(0); + ofm.fm.modify_cookie = false; + ofm.fm.table_id = TBL_INTERNAL; + ofm.fm.flags = OFPUTIL_FF_HIDDEN_FIELDS | OFPUTIL_FF_NO_READONLY; + ofm.fm.command = OFPFC_DELETE_STRICT; + + error = ofproto_flow_mod(&ofproto->up, &ofm); if (error) { VLOG_ERR_RL(&rl, "failed to delete internal flow (%s)", ofperr_to_string(error)); @@ -5440,6 +5742,7 @@ const struct ofproto_class ofproto_dpif_class = { type_get_memory_usage, flush, query_tables, + set_tables_version, port_alloc, port_construct, port_destruct, @@ -5466,8 +5769,6 @@ const struct ofproto_class ofproto_dpif_class = { rule_dealloc, rule_get_stats, rule_execute, - NULL, /* rule_premodify_actions */ - rule_modify_actions, set_frag_handling, packet_out, set_netflow, @@ -5477,6 +5778,13 @@ const struct ofproto_class ofproto_dpif_class = { set_cfm, cfm_status_changed, get_cfm_status, + set_lldp, + get_lldp_status, + set_aa, + aa_mapping_set, + aa_mapping_unset, + aa_vlan_get_queued, + aa_vlan_get_queue_size, set_bfd, bfd_status_changed, get_bfd_status,