X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ofproto%2Fofproto.c;h=0625ccfa196e2b173e6aae6b939d20af250c733e;hb=c54c2f836a6cd65169e030316813bf5fa3a2269c;hp=afd8e170c7681fcb564efa66778cfb5dd5217e16;hpb=4e022ec09e14ac89add74c1b4b8e3ff3873edbf0;p=sliver-openvswitch.git diff --git a/ofproto/ofproto.c b/ofproto/ofproto.c index afd8e170c..0625ccfa1 100644 --- a/ofproto/ofproto.c +++ b/ofproto/ofproto.c @@ -126,6 +126,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. */ @@ -196,12 +197,13 @@ 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 void delete_flow__(struct rule *, struct ofopgroup *, + enum ofp_flow_removed_reason); 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); @@ -211,6 +213,7 @@ 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); @@ -221,6 +224,7 @@ static size_t n_ofproto_classes; static size_t allocated_ofproto_classes; unsigned flow_eviction_threshold = OFPROTO_FLOW_EVICTION_THRESHOLD_DEFAULT; +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); @@ -442,7 +446,7 @@ 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; } @@ -464,6 +468,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; } @@ -573,6 +587,13 @@ ofproto_set_flow_eviction_threshold(unsigned threshold) 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 * reserved (e.g. STP) destination Ethernet addresses. if forward_bpdu is false, * the NORMAL action will drop these frames. */ @@ -811,7 +832,7 @@ ofproto_port_set_cfm(struct ofproto *ofproto, ofp_port_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)); } } @@ -837,7 +858,7 @@ ofproto_port_set_bfd(struct ofproto *ofproto, ofp_port_t ofp_port, if (error) { VLOG_WARN("%s: bfd configuration on port %"PRIu16" (%s) failed (%s)", ofproto->name, ofp_port, netdev_get_name(ofport->netdev), - strerror(error)); + ovs_strerror(error)); } } @@ -1065,6 +1086,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); @@ -1148,7 +1174,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; } @@ -1165,7 +1191,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; } @@ -1193,7 +1219,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) { @@ -1303,7 +1329,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; } @@ -1609,7 +1635,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); } @@ -1743,7 +1769,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; } @@ -1813,7 +1839,7 @@ ofport_install(struct ofproto *p, /* Add port to 'p'. */ hmap_insert(&p->ports, &ofport->hmap_node, - hash_int(ofp_to_u16(ofport->ofp_port), 0)); + hash_ofp_port(ofport->ofp_port)); shash_add(&p->port_by_name, netdev_name, ofport); update_mtu(p, ofport); @@ -1828,7 +1854,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 { @@ -1937,8 +1963,7 @@ 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_to_u16(ofp_port), 0), + HMAP_FOR_EACH_IN_BUCKET (port, hmap_node, hash_ofp_port(ofp_port), &ofproto->ports) { if (port->ofp_port == ofp_port) { return port; @@ -2361,6 +2386,55 @@ reject_slave_controller(struct ofconn *ofconn) } } +/* 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) { @@ -2407,7 +2481,7 @@ handle_packet_out(struct ofconn *ofconn, const struct ofp_header *oh) /* Verify actions against packet, then send packet if successful. */ in_port_.ofp_port = po.in_port; flow_extract(payload, 0, 0, NULL, &in_port_, &flow); - error = ofpacts_check(po.ofpacts, po.ofpacts_len, &flow, p->max_ports); + 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); @@ -3020,8 +3094,7 @@ ofproto_get_netflow_ids(const struct ofproto *ofproto, * Returns false if the port did not have CFM configured, in which case * '*status' is indeterminate. * - * The caller must provide and owns '*status', but it does not own and must not - * modify or free the array returned in 'status->rmps'. */ + * 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) @@ -3096,18 +3169,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); } @@ -3154,6 +3235,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) { @@ -3217,7 +3299,7 @@ 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; @@ -3256,11 +3338,18 @@ add_flow(struct ofproto *ofproto, struct ofconn *ofconn, 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); @@ -3294,6 +3383,8 @@ add_flow(struct ofproto *ofproto, struct ofconn *ofconn, and OFPFF13_NO_BYT_COUNTS */ rule->ofpacts = xmemdup(fm->ofpacts, fm->ofpacts_len); rule->ofpacts_len = fm->ofpacts_len; + rule->meter_id = find_meter(rule->ofpacts, rule->ofpacts_len); + list_init(&rule->meter_list_node); rule->evictable = true; rule->eviction_group = NULL; list_init(&rule->expirable); @@ -3339,7 +3430,7 @@ add_flow(struct ofproto *ofproto, struct ofconn *ofconn, op->group->n_running--; ofoperation_destroy(rule->pending); } else if (evict) { - delete_flow__(evict, group); + delete_flow__(evict, group, OFPRR_EVICTION); } ofopgroup_submit(group); } @@ -3364,8 +3455,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; @@ -3386,19 +3477,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); op = ofoperation_create(group, rule, OFOPERATION_MODIFY, 0); - if (fm->new_cookie != htonll(UINT64_MAX)) { + 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); @@ -3411,8 +3511,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; @@ -3427,7 +3526,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; @@ -3452,7 +3551,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; @@ -3476,13 +3575,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); } @@ -3492,14 +3592,15 @@ 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); + delete_flow__(rule, group, reason); } ofopgroup_submit(group); @@ -3520,7 +3621,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); } @@ -3538,7 +3639,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); } @@ -3624,10 +3726,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); } @@ -3669,8 +3767,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)); @@ -4106,6 +4203,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) { @@ -4141,6 +4550,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); @@ -4199,17 +4611,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: @@ -4233,13 +4648,13 @@ 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; } @@ -4587,7 +5002,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; } @@ -4961,11 +5376,17 @@ oftable_remove_rule(struct rule *rule) struct oftable *table = &ofproto->tables[rule->table_id]; classifier_remove(&table->cls, &rule->cr); + if (rule->meter_id) { + list_remove(&rule->meter_list_node); + } cookies_remove(ofproto, rule); eviction_group_remove_rule(rule); if (!list_is_empty(&rule->expirable)) { list_remove(&rule->expirable); } + if (!list_is_empty(&rule->meter_list_node)) { + list_remove(&rule->meter_list_node); + } } /* Inserts 'rule' into its oftable. Removes any existing rule from 'rule''s @@ -4983,9 +5404,15 @@ oftable_replace_rule(struct rule *rule) list_insert(&ofproto->expirable, &rule->expirable); } cookies_insert(ofproto, rule); - + if (rule->meter_id) { + struct meter *meter = ofproto->meters[rule->meter_id]; + list_insert(&meter->rules, &rule->meter_list_node); + } victim = rule_from_cls_rule(classifier_replace(&table->cls, &rule->cr)); if (victim) { + if (victim->meter_id) { + list_remove(&victim->meter_list_node); + } cookies_remove(ofproto, victim); if (!list_is_empty(&victim->expirable)) { @@ -5130,7 +5557,7 @@ ofproto_port_set_realdev(struct ofproto *ofproto, ofp_port_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; }