X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ofproto%2Fofproto.c;h=c8edb2d4761296d73705b8a679d6e53f4a938764;hb=6b900de4efd368be88ef3db88b1eff8f835a7cf7;hp=249f2d5d53730b611c271f49b5199bd077a45e1b;hpb=644e2a7cbd7043a88322177173606f675e55e7d7;p=sliver-openvswitch.git diff --git a/ofproto/ofproto.c b/ofproto/ofproto.c index 249f2d5d5..c8edb2d47 100644 --- a/ofproto/ofproto.c +++ b/ofproto/ofproto.c @@ -21,6 +21,7 @@ #include #include #include +#include #include "bitmap.h" #include "byte-order.h" #include "classifier.h" @@ -126,6 +127,7 @@ struct ofoperation { /* OFOPERATION_MODIFY: The old actions, if the actions are changing. */ struct ofpact *ofpacts; size_t ofpacts_len; + uint32_t meter_id; /* OFOPERATION_DELETE. */ enum ofp_flow_removed_reason reason; /* Reason flow was removed. */ @@ -151,7 +153,10 @@ static void oftable_enable_eviction(struct oftable *, const struct mf_subfield *fields, size_t n_fields); -static void oftable_remove_rule(struct rule *); +static void oftable_remove_rule(struct rule *rule) OVS_RELEASES(rule->evict); +static void oftable_remove_rule__(struct ofproto *ofproto, + struct classifier *cls, struct rule *rule) + OVS_REQ_WRLOCK(cls->rwlock) OVS_RELEASES(rule->evict); static struct rule *oftable_replace_rule(struct rule *); static void oftable_substitute_rule(struct rule *old, struct rule *new); @@ -177,7 +182,8 @@ struct eviction_group { struct heap rules; /* Contains "struct rule"s. */ }; -static struct rule *choose_rule_to_evict(struct oftable *); +static bool choose_rule_to_evict(struct oftable *table, struct rule **rulep) + OVS_TRY_WRLOCK(true, (*rulep)->evict); static void ofproto_evict(struct ofproto *); static uint32_t rule_eviction_priority(struct rule *); @@ -196,19 +202,24 @@ static bool rule_is_modifiable(const struct rule *); /* OpenFlow. */ static enum ofperr add_flow(struct ofproto *, struct ofconn *, - const struct ofputil_flow_mod *, + struct ofputil_flow_mod *, const struct ofp_header *); -static void delete_flow__(struct rule *, struct ofopgroup *); -static bool handle_openflow(struct ofconn *, struct ofpbuf *); +static void delete_flow__(struct rule *rule, struct ofopgroup *, + enum ofp_flow_removed_reason) + OVS_RELEASES(rule->evict); +static bool handle_openflow(struct ofconn *, const struct ofpbuf *); static enum ofperr handle_flow_mod__(struct ofproto *, struct ofconn *, - const struct ofputil_flow_mod *, + struct ofputil_flow_mod *, const struct ofp_header *); +static void calc_duration(long long int start, long long int now, + uint32_t *sec, uint32_t *nsec); /* ofproto. */ static uint64_t pick_datapath_id(const struct ofproto *); static uint64_t pick_fallback_dpid(void); static void ofproto_destroy__(struct ofproto *); static void update_mtu(struct ofproto *, struct ofport *); +static void meter_delete(struct ofproto *, uint32_t first, uint32_t last); /* unixctl. */ static void ofproto_unixctl_init(void); @@ -218,6 +229,10 @@ static const struct ofproto_class **ofproto_classes; static size_t n_ofproto_classes; static size_t allocated_ofproto_classes; +unsigned flow_eviction_threshold = OFPROTO_FLOW_EVICTION_THRESHOLD_DEFAULT; +unsigned n_handler_threads; +enum ofproto_flow_miss_model flow_miss_model = OFPROTO_HANDLE_MISS_AUTO; + /* Map from datapath name to struct ofproto, for use by unixctl commands. */ static struct hmap all_ofprotos = HMAP_INITIALIZER(&all_ofprotos); @@ -226,6 +241,9 @@ static struct shash init_ofp_ports = SHASH_INITIALIZER(&init_ofp_ports); static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); +/* The default value of true waits for flow restore. */ +static bool flow_restore_wait = true; + /* Must be called to initialize the ofproto library. * * The caller may pass in 'iface_hints', which contains an shash of @@ -403,8 +421,6 @@ ofproto_create(const char *datapath_name, const char *datapath_type, hmap_insert(&all_ofprotos, &ofproto->hmap_node, hash_string(ofproto->name, 0)); ofproto->datapath_id = 0; - ofproto_set_flow_eviction_threshold(ofproto, - OFPROTO_FLOW_EVICTION_THRESHOLD_DEFAULT); ofproto->forward_bpdu = false; ofproto->fallback_dpid = pick_fallback_dpid(); ofproto->mfr_desc = NULL; @@ -419,7 +435,9 @@ ofproto_create(const char *datapath_name, const char *datapath_type, ofproto->max_ports = OFPP_MAX; ofproto->tables = NULL; ofproto->n_tables = 0; + hindex_init(&ofproto->cookies); list_init(&ofproto->expirable); + ovs_mutex_init(&ofproto->expirable_mutex, PTHREAD_MUTEX_RECURSIVE); ofproto->connmgr = connmgr_create(ofproto, datapath_name, datapath_name); ofproto->state = S_OPENFLOW; list_init(&ofproto->pending); @@ -436,14 +454,14 @@ ofproto_create(const char *datapath_name, const char *datapath_type, error = ofproto->ofproto_class->construct(ofproto); if (error) { VLOG_ERR("failed to open datapath %s: %s", - datapath_name, strerror(error)); + datapath_name, ovs_strerror(error)); ofproto_destroy__(ofproto); return error; } /* The "max_ports" member should have been set by ->construct(ofproto). * Port 0 is not a valid OpenFlow port, so mark that as unavailable. */ - ofproto->ofp_port_ids = bitmap_allocate(ofproto->max_ports); + ofproto->ofp_port_ids = bitmap_allocate(ofp_to_u16(ofproto->max_ports)); bitmap_set1(ofproto->ofp_port_ids, 0); /* Check that hidden tables, if any, are at the end. */ @@ -458,6 +476,16 @@ ofproto_create(const char *datapath_name, const char *datapath_type, ofproto->datapath_id = pick_datapath_id(ofproto); init_ports(ofproto); + /* Initialize meters table. */ + if (ofproto->ofproto_class->meter_get_features) { + ofproto->ofproto_class->meter_get_features(ofproto, + &ofproto->meter_features); + } else { + memset(&ofproto->meter_features, 0, sizeof ofproto->meter_features); + } + ofproto->meters = xzalloc((ofproto->meter_features.max_meters + 1) + * sizeof(struct meter *)); + *ofprotop = ofproto; return 0; } @@ -492,9 +520,9 @@ ofproto_init_tables(struct ofproto *ofproto, int n_tables) * Reserved ports numbered OFPP_MAX and higher are special and not subject to * the 'max_ports' restriction. */ void -ofproto_init_max_ports(struct ofproto *ofproto, uint16_t max_ports) +ofproto_init_max_ports(struct ofproto *ofproto, ofp_port_t max_ports) { - ovs_assert(max_ports <= OFPP_MAX); + ovs_assert(ofp_to_u16(max_ports) <= ofp_to_u16(OFPP_MAX)); ofproto->max_ports = max_ports; } @@ -561,13 +589,17 @@ ofproto_set_in_band_queue(struct ofproto *ofproto, int queue_id) /* Sets the number of flows at which eviction from the kernel flow table * will occur. */ void -ofproto_set_flow_eviction_threshold(struct ofproto *ofproto, unsigned threshold) +ofproto_set_flow_eviction_threshold(unsigned threshold) { - if (threshold < OFPROTO_FLOW_EVICTION_THRESHOLD_MIN) { - ofproto->flow_eviction_threshold = OFPROTO_FLOW_EVICTION_THRESHOLD_MIN; - } else { - ofproto->flow_eviction_threshold = threshold; - } + flow_eviction_threshold = MAX(OFPROTO_FLOW_EVICTION_THRESHOLD_MIN, + threshold); +} + +/* Sets the path for handling flow misses. */ +void +ofproto_set_flow_miss_model(unsigned model) +{ + flow_miss_model = model; } /* If forward_bpdu is true, the NORMAL action will forward frames with @@ -598,6 +630,18 @@ ofproto_set_mac_table_config(struct ofproto *ofproto, unsigned idle_time, } } +/* Sets number of upcall handler threads. The default is + * (number of online cores - 1). */ +void +ofproto_set_n_handler_threads(unsigned limit) +{ + if (limit) { + n_handler_threads = limit; + } else { + n_handler_threads = MAX(1, sysconf(_SC_NPROCESSORS_ONLN) - 1); + } +} + void ofproto_set_dp_desc(struct ofproto *p, const char *dp_desc) { @@ -640,6 +684,32 @@ ofproto_set_sflow(struct ofproto *ofproto, return oso ? EOPNOTSUPP : 0; } } + +int +ofproto_set_ipfix(struct ofproto *ofproto, + const struct ofproto_ipfix_bridge_exporter_options *bo, + const struct ofproto_ipfix_flow_exporter_options *fo, + size_t n_fo) +{ + if (ofproto->ofproto_class->set_ipfix) { + return ofproto->ofproto_class->set_ipfix(ofproto, bo, fo, n_fo); + } else { + return (bo || fo) ? EOPNOTSUPP : 0; + } +} + +void +ofproto_set_flow_restore_wait(bool flow_restore_wait_db) +{ + flow_restore_wait = flow_restore_wait_db; +} + +bool +ofproto_get_flow_restore_wait(void) +{ + return flow_restore_wait; +} + /* Spanning Tree Protocol (STP) configuration. */ @@ -678,7 +748,7 @@ ofproto_get_stp_status(struct ofproto *ofproto, * * Returns 0 if successful, otherwise a positive errno value.*/ int -ofproto_port_set_stp(struct ofproto *ofproto, uint16_t ofp_port, +ofproto_port_set_stp(struct ofproto *ofproto, ofp_port_t ofp_port, const struct ofproto_port_stp_settings *s) { struct ofport *ofport = ofproto_get_port(ofproto, ofp_port); @@ -699,7 +769,7 @@ ofproto_port_set_stp(struct ofproto *ofproto, uint16_t ofp_port, * * Returns 0 if successful, otherwise a positive errno value.*/ int -ofproto_port_get_stp_status(struct ofproto *ofproto, uint16_t ofp_port, +ofproto_port_get_stp_status(struct ofproto *ofproto, ofp_port_t ofp_port, struct ofproto_port_stp_status *s) { struct ofport *ofport = ofproto_get_port(ofproto, ofp_port); @@ -724,7 +794,7 @@ ofproto_port_get_stp_status(struct ofproto *ofproto, uint16_t ofp_port, * * Returns 0 if successful, otherwise a positive errno value. */ int -ofproto_port_set_queues(struct ofproto *ofproto, uint16_t ofp_port, +ofproto_port_set_queues(struct ofproto *ofproto, ofp_port_t ofp_port, const struct ofproto_port_queue *queues, size_t n_queues) { @@ -745,7 +815,7 @@ ofproto_port_set_queues(struct ofproto *ofproto, uint16_t ofp_port, /* Clears the CFM configuration from 'ofp_port' on 'ofproto'. */ void -ofproto_port_clear_cfm(struct ofproto *ofproto, uint16_t ofp_port) +ofproto_port_clear_cfm(struct ofproto *ofproto, ofp_port_t ofp_port) { struct ofport *ofport = ofproto_get_port(ofproto, ofp_port); if (ofport && ofproto->ofproto_class->set_cfm) { @@ -760,7 +830,7 @@ ofproto_port_clear_cfm(struct ofproto *ofproto, uint16_t ofp_port) * * This function has no effect if 'ofproto' does not have a port 'ofp_port'. */ void -ofproto_port_set_cfm(struct ofproto *ofproto, uint16_t ofp_port, +ofproto_port_set_cfm(struct ofproto *ofproto, ofp_port_t ofp_port, const struct cfm_settings *s) { struct ofport *ofport; @@ -782,16 +852,56 @@ ofproto_port_set_cfm(struct ofproto *ofproto, uint16_t ofp_port, if (error) { VLOG_WARN("%s: CFM configuration on port %"PRIu16" (%s) failed (%s)", ofproto->name, ofp_port, netdev_get_name(ofport->netdev), - strerror(error)); + ovs_strerror(error)); + } +} + +/* Configures BFD on 'ofp_port' in 'ofproto'. This function has no effect if + * 'ofproto' does not have a port 'ofp_port'. */ +void +ofproto_port_set_bfd(struct ofproto *ofproto, ofp_port_t ofp_port, + const struct smap *cfg) +{ + struct ofport *ofport; + int error; + + ofport = ofproto_get_port(ofproto, ofp_port); + if (!ofport) { + VLOG_WARN("%s: cannot configure bfd on nonexistent port %"PRIu16, + ofproto->name, ofp_port); + return; + } + + error = (ofproto->ofproto_class->set_bfd + ? ofproto->ofproto_class->set_bfd(ofport, cfg) + : EOPNOTSUPP); + if (error) { + VLOG_WARN("%s: bfd configuration on port %"PRIu16" (%s) failed (%s)", + ofproto->name, ofp_port, netdev_get_name(ofport->netdev), + ovs_strerror(error)); } } +/* Populates 'status' with key value pairs indicating the status of the BFD + * session on 'ofp_port'. This information is intended to be populated in the + * OVS database. Has no effect if 'ofp_port' is not na OpenFlow port in + * 'ofproto'. */ +int +ofproto_port_get_bfd_status(struct ofproto *ofproto, ofp_port_t ofp_port, + struct smap *status) +{ + struct ofport *ofport = ofproto_get_port(ofproto, ofp_port); + return (ofport && ofproto->ofproto_class->get_bfd_status + ? ofproto->ofproto_class->get_bfd_status(ofport, status) + : EOPNOTSUPP); +} + /* Checks the status of LACP negotiation for 'ofp_port' within ofproto. * Returns 1 if LACP partner information for 'ofp_port' is up-to-date, * 0 if LACP partner information is not current (generally indicating a * connectivity problem), or -1 if LACP is not enabled on 'ofp_port'. */ int -ofproto_port_is_lacp_current(struct ofproto *ofproto, uint16_t ofp_port) +ofproto_port_is_lacp_current(struct ofproto *ofproto, ofp_port_t ofp_port) { struct ofport *ofport = ofproto_get_port(ofproto, ofp_port); return (ofport && ofproto->ofproto_class->port_is_lacp_current @@ -927,6 +1037,7 @@ ofproto_configure_table(struct ofproto *ofproto, int table_id, } table->max_flows = s->max_flows; + ovs_rwlock_rdlock(&table->cls.rwlock); if (classifier_count(&table->cls) > table->max_flows && table->eviction_fields) { /* 'table' contains more flows than allowed. We might not be able to @@ -942,6 +1053,7 @@ ofproto_configure_table(struct ofproto *ofproto, int table_id, break; } } + ovs_rwlock_unlock(&table->cls.rwlock); } bool @@ -975,15 +1087,18 @@ ofproto_flush__(struct ofproto *ofproto) continue; } + ovs_rwlock_wrlock(&table->cls.rwlock); cls_cursor_init(&cursor, &table->cls, NULL); CLS_CURSOR_FOR_EACH_SAFE (rule, next_rule, cr, &cursor) { if (!rule->pending) { ofoperation_create(group, rule, OFOPERATION_DELETE, OFPRR_DELETE); - oftable_remove_rule(rule); + ovs_rwlock_wrlock(&rule->evict); + oftable_remove_rule__(ofproto, &table->cls, rule); ofproto->ofproto_class->rule_destruct(rule); } } + ovs_rwlock_unlock(&table->cls.rwlock); } ofopgroup_submit(group); } @@ -996,6 +1111,11 @@ ofproto_destroy__(struct ofproto *ofproto) ovs_assert(list_is_empty(&ofproto->pending)); ovs_assert(!ofproto->n_pending); + if (ofproto->meters) { + meter_delete(ofproto, 1, ofproto->meter_features.max_meters); + free(ofproto->meters); + } + connmgr_destroy(ofproto->connmgr); hmap_remove(&all_ofprotos, &ofproto->hmap_node); @@ -1020,6 +1140,7 @@ ofproto_destroy__(struct ofproto *ofproto) free(ofproto->vlan_bitmap); + ovs_mutex_destroy(&ofproto->expirable_mutex); ofproto->ofproto_class->dealloc(ofproto); } @@ -1079,7 +1200,7 @@ ofproto_type_run(const char *datapath_type) error = class->type_run ? class->type_run(datapath_type) : 0; if (error && error != EAGAIN) { VLOG_ERR_RL(&rl, "%s: type_run failed (%s)", - datapath_type, strerror(error)); + datapath_type, ovs_strerror(error)); } return error; } @@ -1096,7 +1217,7 @@ ofproto_type_run_fast(const char *datapath_type) error = class->type_run_fast ? class->type_run_fast(datapath_type) : 0; if (error && error != EAGAIN) { VLOG_ERR_RL(&rl, "%s: type_run_fast failed (%s)", - datapath_type, strerror(error)); + datapath_type, ovs_strerror(error)); } return error; } @@ -1124,7 +1245,7 @@ ofproto_run(struct ofproto *p) error = p->ofproto_class->run(p); if (error && error != EAGAIN) { - VLOG_ERR_RL(&rl, "%s: run failed (%s)", p->name, strerror(error)); + VLOG_ERR_RL(&rl, "%s: run failed (%s)", p->name, ovs_strerror(error)); } if (p->ofproto_class->port_poll) { @@ -1234,7 +1355,7 @@ ofproto_run_fast(struct ofproto *p) error = p->ofproto_class->run_fast ? p->ofproto_class->run_fast(p) : 0; if (error && error != EAGAIN) { VLOG_ERR_RL(&rl, "%s: fastpath run failed (%s)", - p->name, strerror(error)); + p->name, ovs_strerror(error)); } return error; } @@ -1290,7 +1411,9 @@ ofproto_get_memory_usage(const struct ofproto *ofproto, struct simap *usage) n_rules = 0; OFPROTO_FOR_EACH_TABLE (table, ofproto) { + ovs_rwlock_rdlock(&table->cls.rwlock); n_rules += classifier_count(&table->cls); + ovs_rwlock_unlock(&table->cls.rwlock); } simap_increase(usage, "rules", n_rules); @@ -1428,16 +1551,17 @@ ofproto_port_open_type(const char *datapath_type, const char *port_type) * 'ofp_portp' is non-null). */ int ofproto_port_add(struct ofproto *ofproto, struct netdev *netdev, - uint16_t *ofp_portp) + ofp_port_t *ofp_portp) { - uint16_t ofp_port = ofp_portp ? *ofp_portp : OFPP_NONE; + ofp_port_t ofp_port = ofp_portp ? *ofp_portp : OFPP_NONE; int error; error = ofproto->ofproto_class->port_add(ofproto, netdev); if (!error) { const char *netdev_name = netdev_get_name(netdev); - simap_put(&ofproto->ofp_requests, netdev_name, ofp_port); + simap_put(&ofproto->ofp_requests, netdev_name, + ofp_to_u16(ofp_port)); update_port(ofproto, netdev_name); } if (ofp_portp) { @@ -1473,7 +1597,7 @@ ofproto_port_query_by_name(const struct ofproto *ofproto, const char *devname, /* Deletes port number 'ofp_port' from the datapath for 'ofproto'. * Returns 0 if successful, otherwise a positive errno. */ int -ofproto_port_del(struct ofproto *ofproto, uint16_t ofp_port) +ofproto_port_del(struct ofproto *ofproto, ofp_port_t ofp_port) { struct ofport *ofport = ofproto_get_port(ofproto, ofp_port); const char *name = ofport ? netdev_get_name(ofport->netdev) : ""; @@ -1516,8 +1640,10 @@ ofproto_add_flow(struct ofproto *ofproto, const struct match *match, { const struct rule *rule; + ovs_rwlock_rdlock(&ofproto->tables[0].cls.rwlock); rule = rule_from_cls_rule(classifier_find_match_exactly( &ofproto->tables[0].cls, match, priority)); + ovs_rwlock_unlock(&ofproto->tables[0].cls.rwlock); if (!rule || !ofpacts_equal(rule->ofpacts, rule->ofpacts_len, ofpacts, ofpacts_len)) { struct ofputil_flow_mod fm; @@ -1539,7 +1665,7 @@ ofproto_add_flow(struct ofproto *ofproto, const struct match *match, * * This is a helper function for in-band control and fail-open. */ int -ofproto_flow_mod(struct ofproto *ofproto, const struct ofputil_flow_mod *fm) +ofproto_flow_mod(struct ofproto *ofproto, struct ofputil_flow_mod *fm) { return handle_flow_mod__(ofproto, NULL, fm, NULL); } @@ -1554,8 +1680,10 @@ ofproto_delete_flow(struct ofproto *ofproto, { struct rule *rule; + ovs_rwlock_rdlock(&ofproto->tables[0].cls.rwlock); rule = rule_from_cls_rule(classifier_find_match_exactly( &ofproto->tables[0].cls, target, priority)); + ovs_rwlock_unlock(&ofproto->tables[0].cls.rwlock); if (!rule) { /* No such rule -> success. */ return true; @@ -1567,6 +1695,7 @@ ofproto_delete_flow(struct ofproto *ofproto, /* Initiate deletion -> success. */ struct ofopgroup *group = ofopgroup_create_unattached(ofproto); ofoperation_create(group, rule, OFOPERATION_DELETE, OFPRR_DELETE); + ovs_rwlock_wrlock(&rule->evict); oftable_remove_rule(rule); ofproto->ofproto_class->rule_destruct(rule); ofopgroup_submit(group); @@ -1610,43 +1739,48 @@ reinit_ports(struct ofproto *p) sset_destroy(&devnames); } -static uint16_t +static ofp_port_t alloc_ofp_port(struct ofproto *ofproto, const char *netdev_name) { - uint16_t ofp_port; - uint16_t end_port_no = ofproto->alloc_port_no; + uint16_t max_ports = ofp_to_u16(ofproto->max_ports); + uint16_t port_idx; + + port_idx = simap_get(&ofproto->ofp_requests, netdev_name); + if (!port_idx) { + port_idx = UINT16_MAX; + } - ofp_port = simap_get(&ofproto->ofp_requests, netdev_name); - ofp_port = ofp_port ? ofp_port : OFPP_NONE; + if (port_idx >= max_ports + || bitmap_is_set(ofproto->ofp_port_ids, port_idx)) { + uint16_t end_port_no = ofp_to_u16(ofproto->alloc_port_no); + uint16_t alloc_port_no = end_port_no; - if (ofp_port >= ofproto->max_ports - || bitmap_is_set(ofproto->ofp_port_ids, ofp_port)) { /* Search for a free OpenFlow port number. We try not to * immediately reuse them to prevent problems due to old * flows. */ for (;;) { - if (++ofproto->alloc_port_no >= ofproto->max_ports) { - ofproto->alloc_port_no = 0; + if (++alloc_port_no >= max_ports) { + alloc_port_no = 0; } - if (!bitmap_is_set(ofproto->ofp_port_ids, - ofproto->alloc_port_no)) { - ofp_port = ofproto->alloc_port_no; + if (!bitmap_is_set(ofproto->ofp_port_ids, alloc_port_no)) { + port_idx = alloc_port_no; + ofproto->alloc_port_no = u16_to_ofp(alloc_port_no); break; } - if (ofproto->alloc_port_no == end_port_no) { + if (alloc_port_no == end_port_no) { return OFPP_NONE; } } } - bitmap_set1(ofproto->ofp_port_ids, ofp_port); - return ofp_port; + bitmap_set1(ofproto->ofp_port_ids, port_idx); + return u16_to_ofp(port_idx); } static void -dealloc_ofp_port(const struct ofproto *ofproto, uint16_t ofp_port) +dealloc_ofp_port(const struct ofproto *ofproto, ofp_port_t ofp_port) { - if (ofp_port < ofproto->max_ports) { - bitmap_set0(ofproto->ofp_port_ids, ofp_port); + if (ofp_to_u16(ofp_port) < ofp_to_u16(ofproto->max_ports)) { + bitmap_set0(ofproto->ofp_port_ids, ofp_to_u16(ofp_port)); } } @@ -1668,7 +1802,7 @@ ofport_open(struct ofproto *ofproto, "cannot be opened (%s)", ofproto->name, ofproto_port->name, ofproto_port->ofp_port, - ofproto_port->name, strerror(error)); + ofproto_port->name, ovs_strerror(error)); return NULL; } @@ -1734,9 +1868,11 @@ ofport_install(struct ofproto *p, ofport->change_seq = netdev_change_seq(netdev); ofport->pp = *pp; ofport->ofp_port = pp->port_no; + ofport->created = time_msec(); /* Add port to 'p'. */ - hmap_insert(&p->ports, &ofport->hmap_node, hash_int(ofport->ofp_port, 0)); + hmap_insert(&p->ports, &ofport->hmap_node, + hash_ofp_port(ofport->ofp_port)); shash_add(&p->port_by_name, netdev_name, ofport); update_mtu(p, ofport); @@ -1751,7 +1887,7 @@ ofport_install(struct ofproto *p, error: VLOG_WARN_RL(&rl, "%s: could not add port %s (%s)", - p->name, netdev_name, strerror(error)); + p->name, netdev_name, ovs_strerror(error)); if (ofport) { ofport_destroy__(ofport); } else { @@ -1812,7 +1948,7 @@ ofproto_port_set_state(struct ofport *port, enum ofputil_port_state state) } void -ofproto_port_unregister(struct ofproto *ofproto, uint16_t ofp_port) +ofproto_port_unregister(struct ofproto *ofproto, ofp_port_t ofp_port) { struct ofport *port = ofproto_get_port(ofproto, ofp_port); if (port) { @@ -1856,12 +1992,12 @@ ofport_destroy(struct ofport *port) } struct ofport * -ofproto_get_port(const struct ofproto *ofproto, uint16_t ofp_port) +ofproto_get_port(const struct ofproto *ofproto, ofp_port_t ofp_port) { struct ofport *port; - HMAP_FOR_EACH_IN_BUCKET (port, hmap_node, - hash_int(ofp_port, 0), &ofproto->ports) { + HMAP_FOR_EACH_IN_BUCKET (port, hmap_node, hash_ofp_port(ofp_port), + &ofproto->ports) { if (port->ofp_port == ofp_port) { return port; } @@ -1898,6 +2034,7 @@ update_port(struct ofproto *ofproto, const char *name) netdev = (!ofproto_port_query_by_name(ofproto, name, &ofproto_port) ? ofport_open(ofproto, &ofproto_port, &pp) : NULL); + if (netdev) { port = ofproto_get_port(ofproto, ofproto_port.ofp_port); if (port && !strcmp(netdev_get_name(port->netdev), name)) { @@ -1959,7 +2096,8 @@ init_ports(struct ofproto *p) node = shash_find(&init_ofp_ports, name); if (node) { const struct iface_hint *iface_hint = node->data; - simap_put(&p->ofp_requests, name, iface_hint->ofp_port); + simap_put(&p->ofp_requests, name, + ofp_to_u16(iface_hint->ofp_port)); } netdev = ofport_open(p, &ofproto_port, &pp); @@ -2060,6 +2198,8 @@ ofproto_rule_destroy__(struct rule *rule) if (rule) { cls_rule_destroy(&rule->cr); free(rule->ofpacts); + ovs_mutex_destroy(&rule->timeout_mutex); + ovs_rwlock_destroy(&rule->evict); rule->ofproto->ofproto_class->rule_dealloc(rule); } } @@ -2073,17 +2213,22 @@ ofproto_rule_destroy__(struct rule *rule) * This function should only be called from an ofproto implementation's * ->destruct() function. It is not suitable elsewhere. */ void -ofproto_rule_destroy(struct rule *rule) +ofproto_rule_destroy(struct ofproto *ofproto, struct classifier *cls, + struct rule *rule) OVS_REQ_WRLOCK(cls->rwlock) { ovs_assert(!rule->pending); - oftable_remove_rule(rule); + if (!ovs_rwlock_trywrlock(&rule->evict)) { + oftable_remove_rule__(ofproto, cls, rule); + } else { + NOT_REACHED(); + } ofproto_rule_destroy__(rule); } /* Returns true if 'rule' has an OpenFlow OFPAT_OUTPUT or OFPAT_ENQUEUE action * that outputs to 'port' (output to OFPP_FLOOD and OFPP_ALL doesn't count). */ bool -ofproto_rule_has_out_port(const struct rule *rule, uint16_t port) +ofproto_rule_has_out_port(const struct rule *rule, ofp_port_t port) { return (port == OFPP_ANY || ofpacts_output_to_port(rule->ofpacts, rule->ofpacts_len, port)); @@ -2092,7 +2237,7 @@ ofproto_rule_has_out_port(const struct rule *rule, uint16_t port) /* Returns true if a rule related to 'op' has an OpenFlow OFPAT_OUTPUT or * OFPAT_ENQUEUE action that outputs to 'out_port'. */ bool -ofoperation_has_out_port(const struct ofoperation *op, uint16_t out_port) +ofoperation_has_out_port(const struct ofoperation *op, ofp_port_t out_port) { if (ofproto_rule_has_out_port(op->rule, out_port)) { return true; @@ -2121,13 +2266,15 @@ ofoperation_has_out_port(const struct ofoperation *op, uint16_t out_port) * * Takes ownership of 'packet'. */ static int -rule_execute(struct rule *rule, uint16_t in_port, struct ofpbuf *packet) +rule_execute(struct rule *rule, ofp_port_t in_port, struct ofpbuf *packet) { struct flow flow; + union flow_in_port in_port_; ovs_assert(ofpbuf_headroom(packet) >= sizeof(struct ofp10_packet_in)); - flow_extract(packet, 0, 0, NULL, in_port, &flow); + in_port_.ofp_port = in_port; + flow_extract(packet, 0, 0, NULL, &in_port_, &flow); return rule->ofproto->ofproto_class->rule_execute(rule, &flow, packet); } @@ -2238,7 +2385,7 @@ handle_set_config(struct ofconn *ofconn, const struct ofp_header *oh) uint16_t flags = ntohs(osc->flags); if (ofconn_get_type(ofconn) != OFCONN_PRIMARY - || ofconn_get_role(ofconn) != NX_ROLE_SLAVE) { + || ofconn_get_role(ofconn) != OFPCR12_ROLE_SLAVE) { enum ofp_config_flags cur = ofproto->frag_handling; enum ofp_config_flags next = flags & OFPC_FRAG_MASK; @@ -2272,13 +2419,62 @@ static enum ofperr reject_slave_controller(struct ofconn *ofconn) { if (ofconn_get_type(ofconn) == OFCONN_PRIMARY - && ofconn_get_role(ofconn) == NX_ROLE_SLAVE) { + && ofconn_get_role(ofconn) == OFPCR12_ROLE_SLAVE) { return OFPERR_OFPBRC_EPERM; } else { return 0; } } +/* Finds the OFPACT_METER action, if any, in the 'ofpacts_len' bytes of + * 'ofpacts'. If found, returns its meter ID; if not, returns 0. + * + * This function relies on the order of 'ofpacts' being correct (as checked by + * ofpacts_verify()). */ +static uint32_t +find_meter(const struct ofpact ofpacts[], size_t ofpacts_len) +{ + const struct ofpact *a; + + OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) { + enum ovs_instruction_type inst; + + inst = ovs_instruction_type_from_ofpact_type(a->type); + if (a->type == OFPACT_METER) { + return ofpact_get_METER(a)->meter_id; + } else if (inst > OVSINST_OFPIT13_METER) { + break; + } + } + + return 0; +} + +/* Checks that the 'ofpacts_len' bytes of actions in 'ofpacts' are appropriate + * for a packet with the prerequisites satisfied by 'flow' in table 'table_id'. + * 'flow' may be temporarily modified, but is restored at return. + */ +static enum ofperr +ofproto_check_ofpacts(struct ofproto *ofproto, + const struct ofpact ofpacts[], size_t ofpacts_len, + struct flow *flow, uint8_t table_id) +{ + enum ofperr error; + uint32_t mid; + + error = ofpacts_check(ofpacts, ofpacts_len, flow, ofproto->max_ports, + table_id); + if (error) { + return error; + } + + mid = find_meter(ofpacts, ofpacts_len); + if (mid && ofproto_get_provider_meter_id(ofproto, mid) == UINT32_MAX) { + return OFPERR_OFPMMFC_INVALID_METER; + } + return 0; +} + static enum ofperr handle_packet_out(struct ofconn *ofconn, const struct ofp_header *oh) { @@ -2288,6 +2484,7 @@ handle_packet_out(struct ofconn *ofconn, const struct ofp_header *oh) uint64_t ofpacts_stub[1024 / 8]; struct ofpbuf ofpacts; struct flow flow; + union flow_in_port in_port_; enum ofperr error; COVERAGE_INC(ofproto_packet_out); @@ -2303,7 +2500,8 @@ handle_packet_out(struct ofconn *ofconn, const struct ofp_header *oh) if (error) { goto exit_free_ofpacts; } - if (po.in_port >= p->max_ports && po.in_port < OFPP_MAX) { + if (ofp_to_u16(po.in_port) >= ofp_to_u16(p->max_ports) + && ofp_to_u16(po.in_port) < ofp_to_u16(OFPP_MAX)) { error = OFPERR_OFPBRC_BAD_PORT; goto exit_free_ofpacts; } @@ -2321,8 +2519,9 @@ handle_packet_out(struct ofconn *ofconn, const struct ofp_header *oh) } /* Verify actions against packet, then send packet if successful. */ - flow_extract(payload, 0, 0, NULL, po.in_port, &flow); - error = ofpacts_check(po.ofpacts, po.ofpacts_len, &flow, p->max_ports); + in_port_.ofp_port = po.in_port; + flow_extract(payload, 0, 0, NULL, &in_port_, &flow); + error = ofproto_check_ofpacts(p, po.ofpacts, po.ofpacts_len, &flow, 0); if (!error) { error = p->ofproto_class->packet_out(p, payload, &flow, po.ofpacts, po.ofpacts_len); @@ -2346,9 +2545,9 @@ update_port_config(struct ofport *port, toggle = (config ^ port->pp.config) & mask; if (toggle & OFPUTIL_PC_PORT_DOWN) { if (config & OFPUTIL_PC_PORT_DOWN) { - netdev_turn_flags_off(port->netdev, NETDEV_UP, true); + netdev_turn_flags_off(port->netdev, NETDEV_UP, NULL); } else { - netdev_turn_flags_on(port->netdev, NETDEV_UP, true); + netdev_turn_flags_on(port->netdev, NETDEV_UP, NULL); } toggle &= ~OFPUTIL_PC_PORT_DOWN; } @@ -2454,7 +2653,9 @@ handle_table_stats_request(struct ofconn *ofconn, ots[i].instructions = htonl(OFPIT11_ALL); ots[i].config = htonl(OFPTC11_TABLE_MISS_MASK); ots[i].max_entries = htonl(1000000); /* An arbitrary big number. */ + ovs_rwlock_rdlock(&p->tables[i].cls.rwlock); ots[i].active_count = htonl(classifier_count(&p->tables[i].cls)); + ovs_rwlock_unlock(&p->tables[i].cls.rwlock); } p->ofproto_class->get_tables(p, ots); @@ -2491,6 +2692,9 @@ append_port_stat(struct ofport *port, struct list *replies) { struct ofputil_port_stats ops = { .port_no = port->pp.port_no }; + calc_duration(port->created, time_msec(), + &ops.duration_sec, &ops.duration_nsec); + /* Intentionally ignore return value, since errors will set * 'stats' to all-1s, which is correct for OpenFlow, and * netdev_get_stats() will log errors. */ @@ -2506,7 +2710,7 @@ handle_port_stats_request(struct ofconn *ofconn, struct ofproto *p = ofconn_get_ofproto(ofconn); struct ofport *port; struct list replies; - uint16_t port_no; + ofp_port_t port_no; enum ofperr error; error = ofputil_decode_port_stats_request(request, &port_no); @@ -2550,9 +2754,42 @@ handle_port_desc_stats_request(struct ofconn *ofconn, return 0; } +static uint32_t +hash_cookie(ovs_be64 cookie) +{ + return hash_2words((OVS_FORCE uint64_t)cookie >> 32, + (OVS_FORCE uint64_t)cookie); +} + +static void +cookies_insert(struct ofproto *ofproto, struct rule *rule) +{ + hindex_insert(&ofproto->cookies, &rule->cookie_node, + hash_cookie(rule->flow_cookie)); +} + +static void +cookies_remove(struct ofproto *ofproto, struct rule *rule) +{ + hindex_remove(&ofproto->cookies, &rule->cookie_node); +} + +static void +ofproto_rule_change_cookie(struct ofproto *ofproto, struct rule *rule, + ovs_be64 new_cookie) +{ + if (new_cookie != rule->flow_cookie) { + cookies_remove(ofproto, rule); + + rule->flow_cookie = new_cookie; + + cookies_insert(ofproto, rule); + } +} + static void -calc_flow_duration__(long long int start, long long int now, - uint32_t *sec, uint32_t *nsec) +calc_duration(long long int start, long long int now, + uint32_t *sec, uint32_t *nsec) { long long int msecs = now - start; *sec = msecs / 1000; @@ -2642,7 +2879,7 @@ static enum ofperr collect_rules_loose(struct ofproto *ofproto, uint8_t table_id, const struct match *match, ovs_be64 cookie, ovs_be64 cookie_mask, - uint16_t out_port, struct list *rules) + ofp_port_t out_port, struct list *rules) { struct oftable *table; struct cls_rule cr; @@ -2655,13 +2892,41 @@ collect_rules_loose(struct ofproto *ofproto, uint8_t table_id, list_init(rules); cls_rule_init(&cr, match, 0); + + if (cookie_mask == htonll(UINT64_MAX)) { + struct rule *rule; + + HINDEX_FOR_EACH_WITH_HASH (rule, cookie_node, hash_cookie(cookie), + &ofproto->cookies) { + if (table_id != rule->table_id && table_id != 0xff) { + continue; + } + if (ofproto_rule_is_hidden(rule)) { + continue; + } + if (cls_rule_is_loose_match(&rule->cr, &cr.match)) { + if (rule->pending) { + error = OFPROTO_POSTPONE; + goto exit; + } + if (rule->flow_cookie == cookie /* Hash collisions possible. */ + && ofproto_rule_has_out_port(rule, out_port)) { + list_push_back(rules, &rule->ofproto_node); + } + } + } + goto exit; + } + FOR_EACH_MATCHING_TABLE (table, table_id, ofproto) { struct cls_cursor cursor; struct rule *rule; + ovs_rwlock_rdlock(&table->cls.rwlock); cls_cursor_init(&cursor, &table->cls, &cr); CLS_CURSOR_FOR_EACH (rule, cr, &cursor) { if (rule->pending) { + ovs_rwlock_unlock(&table->cls.rwlock); error = OFPROTO_POSTPONE; goto exit; } @@ -2671,6 +2936,7 @@ collect_rules_loose(struct ofproto *ofproto, uint8_t table_id, list_push_back(rules, &rule->ofproto_node); } } + ovs_rwlock_unlock(&table->cls.rwlock); } exit: @@ -2693,7 +2959,7 @@ static enum ofperr collect_rules_strict(struct ofproto *ofproto, uint8_t table_id, const struct match *match, unsigned int priority, ovs_be64 cookie, ovs_be64 cookie_mask, - uint16_t out_port, struct list *rules) + ofp_port_t out_port, struct list *rules) { struct oftable *table; struct cls_rule cr; @@ -2706,11 +2972,39 @@ collect_rules_strict(struct ofproto *ofproto, uint8_t table_id, list_init(rules); cls_rule_init(&cr, match, priority); + + if (cookie_mask == htonll(UINT64_MAX)) { + struct rule *rule; + + HINDEX_FOR_EACH_WITH_HASH (rule, cookie_node, hash_cookie(cookie), + &ofproto->cookies) { + if (table_id != rule->table_id && table_id != 0xff) { + continue; + } + if (ofproto_rule_is_hidden(rule)) { + continue; + } + if (cls_rule_equal(&rule->cr, &cr)) { + if (rule->pending) { + error = OFPROTO_POSTPONE; + goto exit; + } + if (rule->flow_cookie == cookie /* Hash collisions possible. */ + && ofproto_rule_has_out_port(rule, out_port)) { + list_push_back(rules, &rule->ofproto_node); + } + } + } + goto exit; + } + FOR_EACH_MATCHING_TABLE (table, table_id, ofproto) { struct rule *rule; + ovs_rwlock_rdlock(&table->cls.rwlock); rule = rule_from_cls_rule(classifier_find_rule_exactly(&table->cls, &cr)); + ovs_rwlock_unlock(&table->cls.rwlock); if (rule) { if (rule->pending) { error = OFPROTO_POSTPONE; @@ -2771,10 +3065,7 @@ handle_flow_stats_request(struct ofconn *ofconn, fs.priority = rule->cr.priority; fs.cookie = rule->flow_cookie; fs.table_id = rule->table_id; - calc_flow_duration__(rule->created, now, &fs.duration_sec, - &fs.duration_nsec); - fs.idle_timeout = rule->idle_timeout; - fs.hard_timeout = rule->hard_timeout; + calc_duration(rule->created, now, &fs.duration_sec, &fs.duration_nsec); fs.idle_age = age_secs(now - rule->used); fs.hard_age = age_secs(now - rule->modified); ofproto->ofproto_class->rule_get_stats(rule, &fs.packet_count, @@ -2782,6 +3073,12 @@ handle_flow_stats_request(struct ofconn *ofconn, fs.ofpacts = rule->ofpacts; fs.ofpacts_len = rule->ofpacts_len; fs.flags = 0; + + ovs_mutex_lock(&rule->timeout_mutex); + fs.idle_timeout = rule->idle_timeout; + fs.hard_timeout = rule->hard_timeout; + ovs_mutex_unlock(&rule->timeout_mutex); + if (rule->send_flow_removed) { fs.flags |= OFPFF_SEND_FLOW_REM; /* FIXME: Implement OF 1.3 flags OFPFF13_NO_PKT_COUNTS @@ -2827,10 +3124,12 @@ ofproto_get_all_flows(struct ofproto *p, struct ds *results) struct cls_cursor cursor; struct rule *rule; + ovs_rwlock_rdlock(&table->cls.rwlock); cls_cursor_init(&cursor, &table->cls, NULL); CLS_CURSOR_FOR_EACH (rule, cr, &cursor) { flow_stats_ds(rule, results); } + ovs_rwlock_unlock(&table->cls.rwlock); } } @@ -2843,62 +3142,20 @@ ofproto_get_netflow_ids(const struct ofproto *ofproto, ofproto->ofproto_class->get_netflow_ids(ofproto, engine_type, engine_id); } -/* Checks the fault status of CFM for 'ofp_port' within 'ofproto'. Returns a - * bitmask of 'cfm_fault_reason's to indicate a CFM fault (generally - * indicating a connectivity problem). Returns zero if CFM is not faulted, - * and -1 if CFM is not enabled on 'ofp_port'. */ -int -ofproto_port_get_cfm_fault(const struct ofproto *ofproto, uint16_t ofp_port) -{ - struct ofport *ofport = ofproto_get_port(ofproto, ofp_port); - return (ofport && ofproto->ofproto_class->get_cfm_fault - ? ofproto->ofproto_class->get_cfm_fault(ofport) - : -1); -} - -/* Checks the operational status reported by the remote CFM endpoint of - * 'ofp_port' Returns 1 if operationally up, 0 if operationally down, and -1 - * if CFM is not enabled on 'ofp_port' or does not support operational status. - */ -int -ofproto_port_get_cfm_opup(const struct ofproto *ofproto, uint16_t ofp_port) -{ - struct ofport *ofport = ofproto_get_port(ofproto, ofp_port); - return (ofport && ofproto->ofproto_class->get_cfm_opup - ? ofproto->ofproto_class->get_cfm_opup(ofport) - : -1); -} - -/* Gets the MPIDs of the remote maintenance points broadcasting to 'ofp_port' - * within 'ofproto'. Populates 'rmps' with an array of MPIDs owned by - * 'ofproto', and 'n_rmps' with the number of MPIDs in 'rmps'. Returns a - * number less than 0 if CFM is not enabled on 'ofp_port'. */ -int -ofproto_port_get_cfm_remote_mpids(const struct ofproto *ofproto, - uint16_t ofp_port, const uint64_t **rmps, - size_t *n_rmps) -{ - struct ofport *ofport = ofproto_get_port(ofproto, ofp_port); - - *rmps = NULL; - *n_rmps = 0; - return (ofport && ofproto->ofproto_class->get_cfm_remote_mpids - ? ofproto->ofproto_class->get_cfm_remote_mpids(ofport, rmps, - n_rmps) - : -1); -} - -/* Checks the health of the CFM for 'ofp_port' within 'ofproto'. Returns an - * integer value between 0 and 100 to indicate the health of the port as a - * percentage which is the average of cfm health of all the remote_mpids or - * returns -1 if CFM is not enabled on 'ofport'. */ -int -ofproto_port_get_cfm_health(const struct ofproto *ofproto, uint16_t ofp_port) +/* Checks the status of CFM configured on 'ofp_port' within 'ofproto'. Returns + * true if the port's CFM status was successfully stored into '*status'. + * Returns false if the port did not have CFM configured, in which case + * '*status' is indeterminate. + * + * The caller must provide and owns '*status', and must free 'status->rmps'. */ +bool +ofproto_port_get_cfm_status(const struct ofproto *ofproto, ofp_port_t ofp_port, + struct ofproto_cfm_status *status) { struct ofport *ofport = ofproto_get_port(ofproto, ofp_port); - return (ofport && ofproto->ofproto_class->get_cfm_health - ? ofproto->ofproto_class->get_cfm_health(ofport) - : -1); + return (ofport + && ofproto->ofproto_class->get_cfm_status + && ofproto->ofproto_class->get_cfm_status(ofport, status)); } static enum ofperr @@ -2965,18 +3222,26 @@ handle_aggregate_stats_request(struct ofconn *ofconn, struct queue_stats_cbdata { struct ofport *ofport; struct list replies; + long long int now; }; static void put_queue_stats(struct queue_stats_cbdata *cbdata, uint32_t queue_id, const struct netdev_queue_stats *stats) { + struct ofputil_queue_stats oqs; - struct ofputil_queue_stats oqs = { - .port_no = cbdata->ofport->pp.port_no, - .queue_id = queue_id, - .stats = *stats, - }; + oqs.port_no = cbdata->ofport->pp.port_no; + oqs.queue_id = queue_id; + oqs.tx_bytes = stats->tx_bytes; + oqs.tx_packets = stats->tx_packets; + oqs.tx_errors = stats->tx_errors; + if (stats->created != LLONG_MIN) { + calc_duration(stats->created, cbdata->now, + &oqs.duration_sec, &oqs.duration_nsec); + } else { + oqs.duration_sec = oqs.duration_nsec = UINT32_MAX; + } ofputil_append_queue_stat(&cbdata->replies, &oqs); } @@ -3023,6 +3288,7 @@ handle_queue_stats_request(struct ofconn *ofconn, COVERAGE_INC(ofproto_queue_req); ofpmp_init(&cbdata.replies, rq); + cbdata.now = time_msec(); error = ofputil_decode_queue_stats_request(rq, &oqsr); if (error) { @@ -3086,13 +3352,13 @@ is_flow_deletion_pending(const struct ofproto *ofproto, * if any. */ static enum ofperr add_flow(struct ofproto *ofproto, struct ofconn *ofconn, - const struct ofputil_flow_mod *fm, const struct ofp_header *request) + struct ofputil_flow_mod *fm, const struct ofp_header *request) { struct oftable *table; struct ofopgroup *group; struct rule *victim; - struct cls_rule cr; struct rule *rule; + uint8_t table_id; int error; error = check_table_id(ofproto, fm->table_id); @@ -3102,7 +3368,6 @@ add_flow(struct ofproto *ofproto, struct ofconn *ofconn, /* Pick table. */ if (fm->table_id == 0xff) { - uint8_t table_id; if (ofproto->ofproto_class->rule_choose_table) { error = ofproto->ofproto_class->rule_choose_table(ofproto, &fm->match, @@ -3111,42 +3376,57 @@ add_flow(struct ofproto *ofproto, struct ofconn *ofconn, return error; } ovs_assert(table_id < ofproto->n_tables); - table = &ofproto->tables[table_id]; } else { - table = &ofproto->tables[0]; + table_id = 0; } } else if (fm->table_id < ofproto->n_tables) { - table = &ofproto->tables[fm->table_id]; + table_id = fm->table_id; } else { return OFPERR_OFPBRC_BAD_TABLE_ID; } + table = &ofproto->tables[table_id]; + if (table->flags & OFTABLE_READONLY) { return OFPERR_OFPBRC_EPERM; } + /* Verify actions. */ + error = ofproto_check_ofpacts(ofproto, fm->ofpacts, fm->ofpacts_len, + &fm->match.flow, table_id); + if (error) { + return error; + } + /* Allocate new rule and initialize classifier rule. */ rule = ofproto->ofproto_class->rule_alloc(); if (!rule) { VLOG_WARN_RL(&rl, "%s: failed to create rule (%s)", - ofproto->name, strerror(error)); + ofproto->name, ovs_strerror(error)); return ENOMEM; } cls_rule_init(&rule->cr, &fm->match, fm->priority); /* Serialize against pending deletion. */ - if (is_flow_deletion_pending(ofproto, &cr, table - ofproto->tables)) { + if (is_flow_deletion_pending(ofproto, &rule->cr, table_id)) { cls_rule_destroy(&rule->cr); ofproto->ofproto_class->rule_dealloc(rule); return OFPROTO_POSTPONE; } /* Check for overlap, if requested. */ - if (fm->flags & OFPFF_CHECK_OVERLAP - && classifier_rule_overlaps(&table->cls, &rule->cr)) { - cls_rule_destroy(&rule->cr); - ofproto->ofproto_class->rule_dealloc(rule); - return OFPERR_OFPFMFC_OVERLAP; + if (fm->flags & OFPFF_CHECK_OVERLAP) { + bool overlaps; + + ovs_rwlock_rdlock(&table->cls.rwlock); + overlaps = classifier_rule_overlaps(&table->cls, &rule->cr); + ovs_rwlock_unlock(&table->cls.rwlock); + + if (overlaps) { + cls_rule_destroy(&rule->cr); + ofproto->ofproto_class->rule_dealloc(rule); + return OFPERR_OFPFMFC_OVERLAP; + } } /* FIXME: Implement OFPFF12_RESET_COUNTS */ @@ -3155,20 +3435,27 @@ add_flow(struct ofproto *ofproto, struct ofconn *ofconn, rule->pending = NULL; rule->flow_cookie = fm->new_cookie; rule->created = rule->modified = rule->used = time_msec(); + + ovs_mutex_init(&rule->timeout_mutex, OVS_MUTEX_ADAPTIVE); + ovs_mutex_lock(&rule->timeout_mutex); rule->idle_timeout = fm->idle_timeout; rule->hard_timeout = fm->hard_timeout; + ovs_mutex_unlock(&rule->timeout_mutex); + rule->table_id = table - ofproto->tables; rule->send_flow_removed = (fm->flags & OFPFF_SEND_FLOW_REM) != 0; /* FIXME: Implement OF 1.3 flags OFPFF13_NO_PKT_COUNTS and OFPFF13_NO_BYT_COUNTS */ rule->ofpacts = xmemdup(fm->ofpacts, fm->ofpacts_len); rule->ofpacts_len = fm->ofpacts_len; - rule->evictable = true; + rule->meter_id = find_meter(rule->ofpacts, rule->ofpacts_len); + list_init(&rule->meter_list_node); rule->eviction_group = NULL; list_init(&rule->expirable); rule->monitor_flags = 0; rule->add_seqno = 0; rule->modify_seqno = 0; + ovs_rwlock_init(&rule->evict); /* Insert new rule. */ victim = oftable_replace_rule(rule); @@ -3179,21 +3466,24 @@ add_flow(struct ofproto *ofproto, struct ofconn *ofconn, } else { struct ofoperation *op; struct rule *evict; - - if (classifier_count(&table->cls) > table->max_flows) { - bool was_evictable; - - was_evictable = rule->evictable; - rule->evictable = false; - evict = choose_rule_to_evict(table); - rule->evictable = was_evictable; - - if (!evict) { + size_t n_rules; + + ovs_rwlock_rdlock(&table->cls.rwlock); + n_rules = classifier_count(&table->cls); + ovs_rwlock_unlock(&table->cls.rwlock); + if (n_rules > table->max_flows) { + ovs_rwlock_rdlock(&rule->evict); + if (choose_rule_to_evict(table, &evict)) { + ovs_rwlock_unlock(&rule->evict); + ovs_rwlock_unlock(&evict->evict); + if (evict->pending) { + error = OFPROTO_POSTPONE; + goto exit; + } + } else { + ovs_rwlock_unlock(&rule->evict); error = OFPERR_OFPFMFC_TABLE_FULL; goto exit; - } else if (evict->pending) { - error = OFPROTO_POSTPONE; - goto exit; } } else { evict = NULL; @@ -3208,7 +3498,14 @@ add_flow(struct ofproto *ofproto, struct ofconn *ofconn, op->group->n_running--; ofoperation_destroy(rule->pending); } else if (evict) { - delete_flow__(evict, group); + /* It would be better if we maintained the lock we took in + * choose_rule_to_evict() earlier, but that confuses the thread + * safety analysis, and this code is fragile enough that we really + * need it. In the worst case, we'll have to block a little while + * before we perform the eviction, which doesn't seem like a big + * problem. */ + ovs_rwlock_wrlock(&evict->evict); + delete_flow__(evict, group, OFPRR_EVICTION); } ofopgroup_submit(group); } @@ -3233,8 +3530,8 @@ exit: * Returns 0 on success, otherwise an OpenFlow error code. */ static enum ofperr modify_flows__(struct ofproto *ofproto, struct ofconn *ofconn, - const struct ofputil_flow_mod *fm, - const struct ofp_header *request, struct list *rules) + struct ofputil_flow_mod *fm, const struct ofp_header *request, + struct list *rules) { struct ofopgroup *group; struct rule *rule; @@ -3245,7 +3542,6 @@ modify_flows__(struct ofproto *ofproto, struct ofconn *ofconn, LIST_FOR_EACH (rule, ofproto_node, rules) { struct ofoperation *op; bool actions_changed; - ovs_be64 new_cookie; /* FIXME: Implement OFPFF12_RESET_COUNTS */ @@ -3256,19 +3552,28 @@ modify_flows__(struct ofproto *ofproto, struct ofconn *ofconn, continue; } + /* Verify actions. */ + error = ofpacts_check(fm->ofpacts, fm->ofpacts_len, &fm->match.flow, + ofproto->max_ports, rule->table_id); + if (error) { + return error; + } + actions_changed = !ofpacts_equal(fm->ofpacts, fm->ofpacts_len, rule->ofpacts, rule->ofpacts_len); - new_cookie = (fm->new_cookie != htonll(UINT64_MAX) - ? fm->new_cookie - : rule->flow_cookie); op = ofoperation_create(group, rule, OFOPERATION_MODIFY, 0); - rule->flow_cookie = new_cookie; + + if (fm->modify_cookie && fm->new_cookie != htonll(UINT64_MAX)) { + ofproto_rule_change_cookie(ofproto, rule, fm->new_cookie); + } if (actions_changed) { op->ofpacts = rule->ofpacts; op->ofpacts_len = rule->ofpacts_len; + op->meter_id = rule->meter_id; rule->ofpacts = xmemdup(fm->ofpacts, fm->ofpacts_len); rule->ofpacts_len = fm->ofpacts_len; + rule->meter_id = find_meter(rule->ofpacts, rule->ofpacts_len); rule->ofproto->ofproto_class->rule_modify_actions(rule); } else { ofoperation_complete(op, 0); @@ -3281,8 +3586,7 @@ modify_flows__(struct ofproto *ofproto, struct ofconn *ofconn, static enum ofperr modify_flows_add(struct ofproto *ofproto, struct ofconn *ofconn, - const struct ofputil_flow_mod *fm, - const struct ofp_header *request) + struct ofputil_flow_mod *fm, const struct ofp_header *request) { if (fm->cookie_mask != htonll(0) || fm->new_cookie == htonll(UINT64_MAX)) { return 0; @@ -3297,7 +3601,7 @@ modify_flows_add(struct ofproto *ofproto, struct ofconn *ofconn, * if any. */ static enum ofperr modify_flows_loose(struct ofproto *ofproto, struct ofconn *ofconn, - const struct ofputil_flow_mod *fm, + struct ofputil_flow_mod *fm, const struct ofp_header *request) { struct list rules; @@ -3322,7 +3626,7 @@ modify_flows_loose(struct ofproto *ofproto, struct ofconn *ofconn, * if any. */ static enum ofperr modify_flow_strict(struct ofproto *ofproto, struct ofconn *ofconn, - const struct ofputil_flow_mod *fm, + struct ofputil_flow_mod *fm, const struct ofp_header *request) { struct list rules; @@ -3346,13 +3650,14 @@ modify_flow_strict(struct ofproto *ofproto, struct ofconn *ofconn, /* OFPFC_DELETE implementation. */ static void -delete_flow__(struct rule *rule, struct ofopgroup *group) +delete_flow__(struct rule *rule, struct ofopgroup *group, + enum ofp_flow_removed_reason reason) { struct ofproto *ofproto = rule->ofproto; - ofproto_rule_send_removed(rule, OFPRR_DELETE); + ofproto_rule_send_removed(rule, reason); - ofoperation_create(group, rule, OFOPERATION_DELETE, OFPRR_DELETE); + ofoperation_create(group, rule, OFOPERATION_DELETE, reason); oftable_remove_rule(rule); ofproto->ofproto_class->rule_destruct(rule); } @@ -3362,14 +3667,16 @@ delete_flow__(struct rule *rule, struct ofopgroup *group) * Returns 0 on success, otherwise an OpenFlow error code. */ static enum ofperr delete_flows__(struct ofproto *ofproto, struct ofconn *ofconn, - const struct ofp_header *request, struct list *rules) + const struct ofp_header *request, struct list *rules, + enum ofp_flow_removed_reason reason) { struct rule *rule, *next; struct ofopgroup *group; group = ofopgroup_create(ofproto, ofconn, request, UINT32_MAX); LIST_FOR_EACH_SAFE (rule, next, ofproto_node, rules) { - delete_flow__(rule, group); + ovs_rwlock_wrlock(&rule->evict); + delete_flow__(rule, group, reason); } ofopgroup_submit(group); @@ -3390,7 +3697,7 @@ delete_flows_loose(struct ofproto *ofproto, struct ofconn *ofconn, fm->out_port, &rules); return (error ? error : !list_is_empty(&rules) ? delete_flows__(ofproto, ofconn, request, - &rules) + &rules, OFPRR_DELETE) : 0); } @@ -3408,7 +3715,8 @@ delete_flow_strict(struct ofproto *ofproto, struct ofconn *ofconn, fm->out_port, &rules); return (error ? error : list_is_singleton(&rules) ? delete_flows__(ofproto, ofconn, - request, &rules) + request, &rules, + OFPRR_DELETE) : 0); } @@ -3426,10 +3734,12 @@ ofproto_rule_send_removed(struct rule *rule, uint8_t reason) fr.cookie = rule->flow_cookie; fr.reason = reason; fr.table_id = rule->table_id; - calc_flow_duration__(rule->created, time_msec(), - &fr.duration_sec, &fr.duration_nsec); + calc_duration(rule->created, time_msec(), + &fr.duration_sec, &fr.duration_nsec); + ovs_mutex_lock(&rule->timeout_mutex); fr.idle_timeout = rule->idle_timeout; fr.hard_timeout = rule->hard_timeout; + ovs_mutex_unlock(&rule->timeout_mutex); rule->ofproto->ofproto_class->rule_get_stats(rule, &fr.packet_count, &fr.byte_count); @@ -3494,10 +3804,6 @@ handle_flow_mod(struct ofconn *ofconn, const struct ofp_header *oh) ofpbuf_use_stub(&ofpacts, ofpacts_stub, sizeof ofpacts_stub); error = ofputil_decode_flow_mod(&fm, oh, ofconn_get_protocol(ofconn), &ofpacts); - if (!error) { - error = ofpacts_check(fm.ofpacts, fm.ofpacts_len, - &fm.match.flow, ofproto->max_ports); - } if (!error) { error = handle_flow_mod__(ofproto, ofconn, &fm, oh); } @@ -3539,8 +3845,7 @@ exit: static enum ofperr handle_flow_mod__(struct ofproto *ofproto, struct ofconn *ofconn, - const struct ofputil_flow_mod *fm, - const struct ofp_header *oh) + struct ofputil_flow_mod *fm, const struct ofp_header *oh) { if (ofproto->n_pending >= 50) { ovs_assert(!list_is_empty(&ofproto->pending)); @@ -3576,38 +3881,34 @@ handle_flow_mod__(struct ofproto *ofproto, struct ofconn *ofconn, static enum ofperr handle_role_request(struct ofconn *ofconn, const struct ofp_header *oh) { - struct ofputil_role_request rr; + struct ofputil_role_request request; + struct ofputil_role_request reply; struct ofpbuf *buf; - uint32_t role; enum ofperr error; - error = ofputil_decode_role_message(oh, &rr); + error = ofputil_decode_role_message(oh, &request); if (error) { return error; } - if (rr.request_current_role_only) { - role = ofconn_get_role(ofconn); /* NX_ROLE_* */ - goto reply; - } - - role = rr.role; - - if (ofconn_get_role(ofconn) != role - && ofconn_has_pending_opgroups(ofconn)) { - return OFPROTO_POSTPONE; - } + if (request.role != OFPCR12_ROLE_NOCHANGE) { + if (ofconn_get_role(ofconn) != request.role + && ofconn_has_pending_opgroups(ofconn)) { + return OFPROTO_POSTPONE; + } - if (rr.have_generation_id) { - if (!ofconn_set_master_election_id(ofconn, rr.generation_id)) { - return OFPERR_OFPRRFC_STALE; + if (request.have_generation_id + && !ofconn_set_master_election_id(ofconn, request.generation_id)) { + return OFPERR_OFPRRFC_STALE; } - } - ofconn_set_role(ofconn, role); + ofconn_set_role(ofconn, request.role); + } -reply: - buf = ofputil_encode_role_reply(oh, role); + reply.role = ofconn_get_role(ofconn); + reply.have_generation_id = ofconn_get_master_election_id( + ofconn, &reply.generation_id); + buf = ofputil_encode_role_reply(oh, &reply); ofconn_send_reply(ofconn, buf); return 0; @@ -3744,8 +4045,10 @@ ofproto_compose_flow_refresh_update(const struct rule *rule, fu.event = (flags & (NXFMF_INITIAL | NXFMF_ADD) ? NXFME_ADDED : NXFME_MODIFIED); fu.reason = 0; + ovs_mutex_lock(&rule->timeout_mutex); fu.idle_timeout = rule->idle_timeout; fu.hard_timeout = rule->hard_timeout; + ovs_mutex_unlock(&rule->timeout_mutex); fu.table_id = rule->table_id; fu.cookie = rule->flow_cookie; minimatch_expand(&rule->cr.match, &match); @@ -3860,11 +4163,13 @@ ofproto_collect_ofmonitor_refresh_rules(const struct ofmonitor *m, struct cls_cursor cursor; struct rule *rule; + ovs_rwlock_rdlock(&table->cls.rwlock); cls_cursor_init(&cursor, &table->cls, &target); CLS_CURSOR_FOR_EACH (rule, cr, &cursor) { ovs_assert(!rule->pending); /* XXX */ ofproto_collect_ofmonitor_refresh_rule(m, rule, seqno, rules); } + ovs_rwlock_unlock(&table->cls.rwlock); } HMAP_FOR_EACH (op, hmap_node, &ofproto->deletions) { @@ -3980,6 +4285,318 @@ handle_flow_monitor_cancel(struct ofconn *ofconn, const struct ofp_header *oh) return 0; } +/* Meters implementation. + * + * Meter table entry, indexed by the OpenFlow meter_id. + * These are always dynamically allocated to allocate enough space for + * the bands. + * 'created' is used to compute the duration for meter stats. + * 'list rules' is needed so that we can delete the dependent rules when the + * meter table entry is deleted. + * 'provider_meter_id' is for the provider's private use. + */ +struct meter { + long long int created; /* Time created. */ + struct list rules; /* List of "struct rule_dpif"s. */ + ofproto_meter_id provider_meter_id; + uint16_t flags; /* Meter flags. */ + uint16_t n_bands; /* Number of meter bands. */ + struct ofputil_meter_band *bands; +}; + +/* + * This is used in instruction validation at flow set-up time, + * as flows may not use non-existing meters. + * This is also used by ofproto-providers to translate OpenFlow meter_ids + * in METER instructions to the corresponding provider meter IDs. + * Return value of UINT32_MAX signifies an invalid meter. + */ +uint32_t +ofproto_get_provider_meter_id(const struct ofproto * ofproto, + uint32_t of_meter_id) +{ + if (of_meter_id && of_meter_id <= ofproto->meter_features.max_meters) { + const struct meter *meter = ofproto->meters[of_meter_id]; + if (meter) { + return meter->provider_meter_id.uint32; + } + } + return UINT32_MAX; +} + +static void +meter_update(struct meter *meter, const struct ofputil_meter_config *config) +{ + free(meter->bands); + + meter->flags = config->flags; + meter->n_bands = config->n_bands; + meter->bands = xmemdup(config->bands, + config->n_bands * sizeof *meter->bands); +} + +static struct meter * +meter_create(const struct ofputil_meter_config *config, + ofproto_meter_id provider_meter_id) +{ + struct meter *meter; + + meter = xzalloc(sizeof *meter); + meter->provider_meter_id = provider_meter_id; + meter->created = time_msec(); + list_init(&meter->rules); + + meter_update(meter, config); + + return meter; +} + +static void +meter_delete(struct ofproto *ofproto, uint32_t first, uint32_t last) +{ + uint32_t mid; + for (mid = first; mid <= last; ++mid) { + struct meter *meter = ofproto->meters[mid]; + if (meter) { + ofproto->meters[mid] = NULL; + ofproto->ofproto_class->meter_del(ofproto, + meter->provider_meter_id); + free(meter->bands); + free(meter); + } + } +} + +static enum ofperr +handle_add_meter(struct ofproto *ofproto, struct ofputil_meter_mod *mm) +{ + ofproto_meter_id provider_meter_id = { UINT32_MAX }; + struct meter **meterp = &ofproto->meters[mm->meter.meter_id]; + enum ofperr error; + + if (*meterp) { + return OFPERR_OFPMMFC_METER_EXISTS; + } + + error = ofproto->ofproto_class->meter_set(ofproto, &provider_meter_id, + &mm->meter); + if (!error) { + ovs_assert(provider_meter_id.uint32 != UINT32_MAX); + *meterp = meter_create(&mm->meter, provider_meter_id); + } + return 0; +} + +static enum ofperr +handle_modify_meter(struct ofproto *ofproto, struct ofputil_meter_mod *mm) +{ + struct meter *meter = ofproto->meters[mm->meter.meter_id]; + enum ofperr error; + + if (!meter) { + return OFPERR_OFPMMFC_UNKNOWN_METER; + } + + error = ofproto->ofproto_class->meter_set(ofproto, + &meter->provider_meter_id, + &mm->meter); + ovs_assert(meter->provider_meter_id.uint32 != UINT32_MAX); + if (!error) { + meter_update(meter, &mm->meter); + } + return error; +} + +static enum ofperr +handle_delete_meter(struct ofconn *ofconn, const struct ofp_header *oh, + struct ofputil_meter_mod *mm) +{ + struct ofproto *ofproto = ofconn_get_ofproto(ofconn); + uint32_t meter_id = mm->meter.meter_id; + uint32_t first, last; + struct list rules; + + if (meter_id == OFPM13_ALL) { + first = 1; + last = ofproto->meter_features.max_meters; + } else { + if (!meter_id || meter_id > ofproto->meter_features.max_meters) { + return 0; + } + first = last = meter_id; + } + + /* First delete the rules that use this meter. If any of those rules are + * currently being modified, postpone the whole operation until later. */ + list_init(&rules); + for (meter_id = first; meter_id <= last; ++meter_id) { + struct meter *meter = ofproto->meters[meter_id]; + if (meter && !list_is_empty(&meter->rules)) { + struct rule *rule; + + LIST_FOR_EACH (rule, meter_list_node, &meter->rules) { + if (rule->pending) { + return OFPROTO_POSTPONE; + } + list_push_back(&rules, &rule->ofproto_node); + } + } + } + if (!list_is_empty(&rules)) { + delete_flows__(ofproto, ofconn, oh, &rules, OFPRR_METER_DELETE); + } + + /* Delete the meters. */ + meter_delete(ofproto, first, last); + + return 0; +} + +static enum ofperr +handle_meter_mod(struct ofconn *ofconn, const struct ofp_header *oh) +{ + struct ofproto *ofproto = ofconn_get_ofproto(ofconn); + struct ofputil_meter_mod mm; + uint64_t bands_stub[256 / 8]; + struct ofpbuf bands; + uint32_t meter_id; + enum ofperr error; + + error = reject_slave_controller(ofconn); + if (error) { + return error; + } + + ofpbuf_use_stub(&bands, bands_stub, sizeof bands_stub); + + error = ofputil_decode_meter_mod(oh, &mm, &bands); + if (error) { + goto exit_free_bands; + } + + meter_id = mm.meter.meter_id; + + if (mm.command != OFPMC13_DELETE) { + /* Fails also when meters are not implemented by the provider. */ + if (!meter_id || meter_id > ofproto->meter_features.max_meters) { + error = OFPERR_OFPMMFC_INVALID_METER; + goto exit_free_bands; + } + if (mm.meter.n_bands > ofproto->meter_features.max_bands) { + error = OFPERR_OFPMMFC_OUT_OF_BANDS; + goto exit_free_bands; + } + } + + switch (mm.command) { + case OFPMC13_ADD: + error = handle_add_meter(ofproto, &mm); + break; + + case OFPMC13_MODIFY: + error = handle_modify_meter(ofproto, &mm); + break; + + case OFPMC13_DELETE: + error = handle_delete_meter(ofconn, oh, &mm); + break; + + default: + error = OFPERR_OFPMMFC_BAD_COMMAND; + break; + } + +exit_free_bands: + ofpbuf_uninit(&bands); + return error; +} + +static enum ofperr +handle_meter_features_request(struct ofconn *ofconn, + const struct ofp_header *request) +{ + struct ofproto *ofproto = ofconn_get_ofproto(ofconn); + struct ofputil_meter_features features; + struct ofpbuf *b; + + if (ofproto->ofproto_class->meter_get_features) { + ofproto->ofproto_class->meter_get_features(ofproto, &features); + } else { + memset(&features, 0, sizeof features); + } + b = ofputil_encode_meter_features_reply(&features, request); + + ofconn_send_reply(ofconn, b); + return 0; +} + +static enum ofperr +handle_meter_request(struct ofconn *ofconn, const struct ofp_header *request, + enum ofptype type) +{ + struct ofproto *ofproto = ofconn_get_ofproto(ofconn); + struct list replies; + uint64_t bands_stub[256 / 8]; + struct ofpbuf bands; + uint32_t meter_id, first, last; + + ofputil_decode_meter_request(request, &meter_id); + + if (meter_id == OFPM13_ALL) { + first = 1; + last = ofproto->meter_features.max_meters; + } else { + if (!meter_id || meter_id > ofproto->meter_features.max_meters || + !ofproto->meters[meter_id]) { + return OFPERR_OFPMMFC_UNKNOWN_METER; + } + first = last = meter_id; + } + + ofpbuf_use_stub(&bands, bands_stub, sizeof bands_stub); + ofpmp_init(&replies, request); + + for (meter_id = first; meter_id <= last; ++meter_id) { + struct meter *meter = ofproto->meters[meter_id]; + if (!meter) { + continue; /* Skip non-existing meters. */ + } + if (type == OFPTYPE_METER_STATS_REQUEST) { + struct ofputil_meter_stats stats; + + stats.meter_id = meter_id; + + /* Provider sets the packet and byte counts, we do the rest. */ + stats.flow_count = list_size(&meter->rules); + calc_duration(meter->created, time_msec(), + &stats.duration_sec, &stats.duration_nsec); + stats.n_bands = meter->n_bands; + ofpbuf_clear(&bands); + stats.bands + = ofpbuf_put_uninit(&bands, + meter->n_bands * sizeof *stats.bands); + + if (!ofproto->ofproto_class->meter_get(ofproto, + meter->provider_meter_id, + &stats)) { + ofputil_append_meter_stats(&replies, &stats); + } + } else { /* type == OFPTYPE_METER_CONFIG_REQUEST */ + struct ofputil_meter_config config; + + config.meter_id = meter_id; + config.flags = meter->flags; + config.n_bands = meter->n_bands; + config.bands = meter->bands; + ofputil_append_meter_config(&replies, &config); + } + } + + ofconn_send_replies(ofconn, &replies); + ofpbuf_uninit(&bands); + return 0; +} + static enum ofperr handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg) { @@ -4015,6 +4632,9 @@ handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg) case OFPTYPE_FLOW_MOD: return handle_flow_mod(ofconn, oh); + case OFPTYPE_METER_MOD: + return handle_meter_mod(ofconn, oh); + case OFPTYPE_BARRIER_REQUEST: return handle_barrier_request(ofconn, oh); @@ -4073,17 +4693,20 @@ handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg) case OFPTYPE_FLOW_MONITOR_STATS_REQUEST: return handle_flow_monitor_request(ofconn, oh); + case OFPTYPE_METER_STATS_REQUEST: + case OFPTYPE_METER_CONFIG_STATS_REQUEST: + return handle_meter_request(ofconn, oh, type); + + case OFPTYPE_METER_FEATURES_STATS_REQUEST: + return handle_meter_features_request(ofconn, oh); + /* FIXME: Change the following once they are implemented: */ case OFPTYPE_QUEUE_GET_CONFIG_REQUEST: case OFPTYPE_GET_ASYNC_REQUEST: - case OFPTYPE_METER_MOD: - case OFPTYPE_GROUP_REQUEST: - case OFPTYPE_GROUP_DESC_REQUEST: - case OFPTYPE_GROUP_FEATURES_REQUEST: - case OFPTYPE_METER_REQUEST: - case OFPTYPE_METER_CONFIG_REQUEST: - case OFPTYPE_METER_FEATURES_REQUEST: - case OFPTYPE_TABLE_FEATURES_REQUEST: + case OFPTYPE_GROUP_STATS_REQUEST: + case OFPTYPE_GROUP_DESC_STATS_REQUEST: + case OFPTYPE_GROUP_FEATURES_STATS_REQUEST: + case OFPTYPE_TABLE_FEATURES_STATS_REQUEST: return OFPERR_OFPBRC_BAD_TYPE; case OFPTYPE_HELLO: @@ -4107,20 +4730,20 @@ handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg) case OFPTYPE_FLOW_MONITOR_RESUMED: case OFPTYPE_FLOW_MONITOR_STATS_REPLY: case OFPTYPE_GET_ASYNC_REPLY: - case OFPTYPE_GROUP_REPLY: - case OFPTYPE_GROUP_DESC_REPLY: - case OFPTYPE_GROUP_FEATURES_REPLY: - case OFPTYPE_METER_REPLY: - case OFPTYPE_METER_CONFIG_REPLY: - case OFPTYPE_METER_FEATURES_REPLY: - case OFPTYPE_TABLE_FEATURES_REPLY: + case OFPTYPE_GROUP_STATS_REPLY: + case OFPTYPE_GROUP_DESC_STATS_REPLY: + case OFPTYPE_GROUP_FEATURES_STATS_REPLY: + case OFPTYPE_METER_STATS_REPLY: + case OFPTYPE_METER_CONFIG_STATS_REPLY: + case OFPTYPE_METER_FEATURES_STATS_REPLY: + case OFPTYPE_TABLE_FEATURES_STATS_REPLY: default: return OFPERR_OFPBRC_BAD_TYPE; } } static bool -handle_openflow(struct ofconn *ofconn, struct ofpbuf *ofp_msg) +handle_openflow(struct ofconn *ofconn, const struct ofpbuf *ofp_msg) { int error = handle_openflow__(ofconn, ofp_msg); if (error && error != OFPROTO_POSTPONE) { @@ -4220,7 +4843,7 @@ ofopgroup_complete(struct ofopgroup *group) LIST_FOR_EACH (op, group_node, &group->ops) { if (op->type != OFOPERATION_DELETE) { struct ofpbuf *packet; - uint16_t in_port; + ofp_port_t in_port; error = ofconn_pktbuf_retrieve(group->ofconn, group->buffer_id, &packet, &in_port); @@ -4306,7 +4929,7 @@ ofopgroup_complete(struct ofopgroup *group) if (!op->error) { rule->modified = time_msec(); } else { - rule->flow_cookie = op->flow_cookie; + ofproto_rule_change_cookie(ofproto, rule, op->flow_cookie); if (op->ofpacts) { free(rule->ofpacts); rule->ofpacts = op->ofpacts; @@ -4461,7 +5084,7 @@ pick_datapath_id(const struct ofproto *ofproto) } VLOG_WARN("%s: could not get MAC address for %s (%s)", ofproto->name, netdev_get_name(port->netdev), - strerror(error)); + ovs_strerror(error)); } return ofproto->fallback_dpid; } @@ -4476,17 +5099,18 @@ pick_fallback_dpid(void) /* Table overflow policy. */ -/* Chooses and returns a rule to evict from 'table'. Returns NULL if the table - * is not configured to evict rules or if the table contains no evictable - * rules. (Rules with 'evictable' set to false or with no timeouts are not - * evictable.) */ -static struct rule * -choose_rule_to_evict(struct oftable *table) +/* Chooses and updates 'rulep' with a rule to evict from 'table'. Sets 'rulep' + * to NULL if the table is not configured to evict rules or if the table + * contains no evictable rules. (Rules with a readlock on their evict rwlock, + * or with no timeouts are not evictable.) */ +static bool +choose_rule_to_evict(struct oftable *table, struct rule **rulep) { struct eviction_group *evg; + *rulep = NULL; if (!table->eviction_fields) { - return NULL; + return false; } /* In the common case, the outer and inner loops here will each be entered @@ -4505,13 +5129,14 @@ choose_rule_to_evict(struct oftable *table) struct rule *rule; HEAP_FOR_EACH (rule, evg_node, &evg->rules) { - if (rule->evictable) { - return rule; + if (!ovs_rwlock_trywrlock(&rule->evict)) { + *rulep = rule; + return true; } } } - return NULL; + return false; } /* Searches 'ofproto' for tables that have more flows than their configured @@ -4528,12 +5153,24 @@ ofproto_evict(struct ofproto *ofproto) group = ofopgroup_create_unattached(ofproto); OFPROTO_FOR_EACH_TABLE (table, ofproto) { - while (classifier_count(&table->cls) > table->max_flows - && table->eviction_fields) { + while (table->eviction_fields) { struct rule *rule; + size_t n_rules; + + ovs_rwlock_rdlock(&table->cls.rwlock); + n_rules = classifier_count(&table->cls); + ovs_rwlock_unlock(&table->cls.rwlock); + + if (n_rules <= table->max_flows) { + break; + } + + if (!choose_rule_to_evict(table, &rule)) { + break; + } - rule = choose_rule_to_evict(table); - if (!rule || rule->pending) { + if (rule->pending) { + ovs_rwlock_unlock(&rule->evict); break; } @@ -4677,6 +5314,7 @@ rule_eviction_priority(struct rule *rule) uint32_t expiration_offset; /* Calculate time of expiration. */ + ovs_mutex_lock(&rule->timeout_mutex); hard_expiration = (rule->hard_timeout ? rule->modified + rule->hard_timeout * 1000 : LLONG_MAX); @@ -4684,6 +5322,7 @@ rule_eviction_priority(struct rule *rule) ? rule->used + rule->idle_timeout * 1000 : LLONG_MAX); expiration = MIN(hard_expiration, idle_expiration); + ovs_mutex_unlock(&rule->timeout_mutex); if (expiration == LLONG_MAX) { return 0; } @@ -4710,9 +5349,13 @@ eviction_group_add_rule(struct rule *rule) { struct ofproto *ofproto = rule->ofproto; struct oftable *table = &ofproto->tables[rule->table_id]; + bool has_timeout; - if (table->eviction_fields - && (rule->hard_timeout || rule->idle_timeout)) { + ovs_mutex_lock(&rule->timeout_mutex); + has_timeout = rule->hard_timeout || rule->idle_timeout; + ovs_mutex_unlock(&rule->timeout_mutex); + + if (table->eviction_fields && has_timeout) { struct eviction_group *evg; evg = eviction_group_find(table, eviction_group_hash_rule(rule)); @@ -4741,7 +5384,9 @@ oftable_init(struct oftable *table) static void oftable_destroy(struct oftable *table) { + ovs_rwlock_rdlock(&table->cls.rwlock); ovs_assert(classifier_is_empty(&table->cls)); + ovs_rwlock_unlock(&table->cls.rwlock); oftable_disable_eviction(table); classifier_destroy(&table->cls); free(table->name); @@ -4821,24 +5466,46 @@ oftable_enable_eviction(struct oftable *table, hmap_init(&table->eviction_groups_by_id); heap_init(&table->eviction_groups_by_size); + ovs_rwlock_rdlock(&table->cls.rwlock); cls_cursor_init(&cursor, &table->cls, NULL); CLS_CURSOR_FOR_EACH (rule, cr, &cursor) { eviction_group_add_rule(rule); } + ovs_rwlock_unlock(&table->cls.rwlock); } /* Removes 'rule' from the oftable that contains it. */ static void -oftable_remove_rule(struct rule *rule) +oftable_remove_rule__(struct ofproto *ofproto, struct classifier *cls, + struct rule *rule) + OVS_REQ_WRLOCK(cls->rwlock) OVS_RELEASES(rule->evict) { - struct ofproto *ofproto = rule->ofproto; - struct oftable *table = &ofproto->tables[rule->table_id]; - - classifier_remove(&table->cls, &rule->cr); + classifier_remove(cls, &rule->cr); + if (rule->meter_id) { + list_remove(&rule->meter_list_node); + } + cookies_remove(ofproto, rule); eviction_group_remove_rule(rule); + ovs_mutex_lock(&ofproto->expirable_mutex); if (!list_is_empty(&rule->expirable)) { list_remove(&rule->expirable); } + ovs_mutex_unlock(&ofproto->expirable_mutex); + if (!list_is_empty(&rule->meter_list_node)) { + list_remove(&rule->meter_list_node); + } + ovs_rwlock_unlock(&rule->evict); +} + +static void +oftable_remove_rule(struct rule *rule) +{ + struct ofproto *ofproto = rule->ofproto; + struct oftable *table = &ofproto->tables[rule->table_id]; + + ovs_rwlock_wrlock(&table->cls.rwlock); + oftable_remove_rule__(ofproto, &table->cls, rule); + ovs_rwlock_unlock(&table->cls.rwlock); } /* Inserts 'rule' into its oftable. Removes any existing rule from 'rule''s @@ -4850,14 +5517,36 @@ oftable_replace_rule(struct rule *rule) struct ofproto *ofproto = rule->ofproto; struct oftable *table = &ofproto->tables[rule->table_id]; struct rule *victim; - bool may_expire = rule->hard_timeout || rule->idle_timeout; + bool may_expire; + + ovs_mutex_lock(&rule->timeout_mutex); + may_expire = rule->hard_timeout || rule->idle_timeout; + ovs_mutex_unlock(&rule->timeout_mutex); if (may_expire) { + ovs_mutex_lock(&ofproto->expirable_mutex); list_insert(&ofproto->expirable, &rule->expirable); + ovs_mutex_unlock(&ofproto->expirable_mutex); } - + cookies_insert(ofproto, rule); + if (rule->meter_id) { + struct meter *meter = ofproto->meters[rule->meter_id]; + list_insert(&meter->rules, &rule->meter_list_node); + } + ovs_rwlock_wrlock(&table->cls.rwlock); victim = rule_from_cls_rule(classifier_replace(&table->cls, &rule->cr)); + ovs_rwlock_unlock(&table->cls.rwlock); if (victim) { + if (victim->meter_id) { + list_remove(&victim->meter_list_node); + } + cookies_remove(ofproto, victim); + + ovs_mutex_lock(&ofproto->expirable_mutex); + if (!list_is_empty(&victim->expirable)) { + list_remove(&victim->expirable); + } + ovs_mutex_unlock(&ofproto->expirable_mutex); eviction_group_remove_rule(victim); } eviction_group_add_rule(rule); @@ -4871,6 +5560,7 @@ oftable_substitute_rule(struct rule *old, struct rule *new) if (new) { oftable_replace_rule(new); } else { + ovs_rwlock_wrlock(&old->evict); oftable_remove_rule(old); } } @@ -4970,8 +5660,8 @@ ofproto_has_vlan_usage_changed(const struct ofproto *ofproto) * device as a VLAN splinter for VLAN ID 'vid'. If 'realdev_ofp_port' is zero, * then the VLAN device is un-enslaved. */ int -ofproto_port_set_realdev(struct ofproto *ofproto, uint16_t vlandev_ofp_port, - uint16_t realdev_ofp_port, int vid) +ofproto_port_set_realdev(struct ofproto *ofproto, ofp_port_t vlandev_ofp_port, + ofp_port_t realdev_ofp_port, int vid) { struct ofport *ofport; int error; @@ -4997,7 +5687,7 @@ ofproto_port_set_realdev(struct ofproto *ofproto, uint16_t vlandev_ofp_port, if (error) { VLOG_WARN("%s: setting realdev on port %"PRIu16" (%s) failed (%s)", ofproto->name, vlandev_ofp_port, - netdev_get_name(ofport->netdev), strerror(error)); + netdev_get_name(ofport->netdev), ovs_strerror(error)); } return error; }