X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=ofproto%2Fofproto.c;h=1130eb748c4300a9cc85f8bf47b3538a8c22f3d6;hb=31a9e63f0f7e771c849f7ef45c9827fcc78abe03;hp=36de8e3a5281cf56d990fdc550405fbafbb02999;hpb=81a76618be9ea195a1e4a881ba9591728891d10b;p=sliver-openvswitch.git diff --git a/ofproto/ofproto.c b/ofproto/ofproto.c index 36de8e3a5..1130eb748 100644 --- a/ofproto/ofproto.c +++ b/ofproto/ofproto.c @@ -221,16 +221,43 @@ static size_t allocated_ofproto_classes; /* Map from datapath name to struct ofproto, for use by unixctl commands. */ static struct hmap all_ofprotos = HMAP_INITIALIZER(&all_ofprotos); +/* Initial mappings of port to OpenFlow number mappings. */ +static struct shash init_ofp_ports = SHASH_INITIALIZER(&init_ofp_ports); + static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(1, 5); -static void -ofproto_initialize(void) +/* Must be called to initialize the ofproto library. + * + * The caller may pass in 'iface_hints', which contains an shash of + * "iface_hint" elements indexed by the interface's name. The provider + * may use these hints to describe the startup configuration in order to + * reinitialize its state. The caller owns the provided data, so a + * provider will make copies of anything required. An ofproto provider + * will remove any existing state that is not described by the hint, and + * may choose to remove it all. */ +void +ofproto_init(const struct shash *iface_hints) { - static bool inited; + struct shash_node *node; + size_t i; - if (!inited) { - inited = true; - ofproto_class_register(&ofproto_dpif_class); + ofproto_class_register(&ofproto_dpif_class); + + /* Make a local copy, since we don't own 'iface_hints' elements. */ + SHASH_FOR_EACH(node, iface_hints) { + const struct iface_hint *orig_hint = node->data; + struct iface_hint *new_hint = xmalloc(sizeof *new_hint); + const char *br_type = ofproto_normalize_type(orig_hint->br_type); + + new_hint->br_name = xstrdup(orig_hint->br_name); + new_hint->br_type = xstrdup(br_type); + new_hint->ofp_port = orig_hint->ofp_port; + + shash_add(&init_ofp_ports, node->name, new_hint); + } + + for (i = 0; i < n_ofproto_classes; i++) { + ofproto_classes[i]->init(&init_ofp_ports); } } @@ -242,7 +269,6 @@ ofproto_class_find__(const char *type) { size_t i; - ofproto_initialize(); for (i = 0; i < n_ofproto_classes; i++) { const struct ofproto_class *class = ofproto_classes[i]; struct sset types; @@ -313,7 +339,6 @@ ofproto_enumerate_types(struct sset *types) { size_t i; - ofproto_initialize(); for (i = 0; i < n_ofproto_classes; i++) { ofproto_classes[i]->enumerate_types(types); } @@ -349,10 +374,10 @@ ofproto_create(const char *datapath_name, const char *datapath_type, const struct ofproto_class *class; struct ofproto *ofproto; int error; + int i; *ofprotop = NULL; - ofproto_initialize(); ofproto_unixctl_init(); datapath_type = ofproto_normalize_type(datapath_type); @@ -379,7 +404,7 @@ ofproto_create(const char *datapath_name, const char *datapath_type, hash_string(ofproto->name, 0)); ofproto->datapath_id = 0; ofproto_set_flow_eviction_threshold(ofproto, - OFPROTO_FLOW_EVICTON_THRESHOLD_DEFAULT); + OFPROTO_FLOW_EVICTION_THRESHOLD_DEFAULT); ofproto->forward_bpdu = false; ofproto->fallback_dpid = pick_fallback_dpid(); ofproto->mfr_desc = xstrdup(DEFAULT_MFR_DESC); @@ -390,6 +415,7 @@ ofproto_create(const char *datapath_name, const char *datapath_type, ofproto->frag_handling = OFPC_FRAG_NORMAL; hmap_init(&ofproto->ports); shash_init(&ofproto->port_by_name); + simap_init(&ofproto->ofp_requests); ofproto->max_ports = OFPP_MAX; ofproto->tables = NULL; ofproto->n_tables = 0; @@ -414,7 +440,19 @@ ofproto_create(const char *datapath_name, const char *datapath_type, 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); + bitmap_set1(ofproto->ofp_port_ids, 0); + + /* Check that hidden tables, if any, are at the end. */ assert(ofproto->n_tables); + for (i = 0; i + 1 < ofproto->n_tables; i++) { + enum oftable_flags flags = ofproto->tables[i].flags; + enum oftable_flags next_flags = ofproto->tables[i + 1].flags; + + assert(!(flags & OFTABLE_HIDDEN) || next_flags & OFTABLE_HIDDEN); + } ofproto->datapath_id = pick_datapath_id(ofproto); init_ports(ofproto); @@ -480,9 +518,10 @@ ofproto_set_datapath_id(struct ofproto *p, uint64_t datapath_id) void ofproto_set_controllers(struct ofproto *p, const struct ofproto_controller *controllers, - size_t n_controllers) + size_t n_controllers, uint32_t allowed_versions) { - connmgr_set_controllers(p->connmgr, controllers, n_controllers); + connmgr_set_controllers(p->connmgr, controllers, n_controllers, + allowed_versions); } void @@ -1008,6 +1047,8 @@ ofproto_destroy__(struct ofproto *ofproto) free(ofproto->dp_desc); hmap_destroy(&ofproto->ports); shash_destroy(&ofproto->port_by_name); + bitmap_free(ofproto->ofp_port_ids); + simap_destroy(&ofproto->ofp_requests); OFPROTO_FOR_EACH_TABLE (table, ofproto) { oftable_destroy(table); @@ -1065,6 +1106,53 @@ process_port_change(struct ofproto *ofproto, int error, char *devname) } } +int +ofproto_type_run(const char *datapath_type) +{ + const struct ofproto_class *class; + int error; + + datapath_type = ofproto_normalize_type(datapath_type); + class = ofproto_class_find__(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)); + } + return error; +} + +int +ofproto_type_run_fast(const char *datapath_type) +{ + const struct ofproto_class *class; + int error; + + datapath_type = ofproto_normalize_type(datapath_type); + class = ofproto_class_find__(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)); + } + return error; +} + +void +ofproto_type_wait(const char *datapath_type) +{ + const struct ofproto_class *class; + + datapath_type = ofproto_normalize_type(datapath_type); + class = ofproto_class_find__(datapath_type); + + if (class->type_wait) { + class->type_wait(datapath_type); + } +} + int ofproto_run(struct ofproto *p) { @@ -1345,23 +1433,59 @@ ofproto_port_dump_done(struct ofproto_port_dump *dump) return dump->error == EOF ? 0 : dump->error; } -/* Attempts to add 'netdev' as a port on 'ofproto'. If successful, returns 0 - * and sets '*ofp_portp' to the new port's OpenFlow port number (if 'ofp_portp' - * is non-null). On failure, returns a positive errno value and sets - * '*ofp_portp' to OFPP_NONE (if 'ofp_portp' is non-null). */ +/* Returns the type to pass to netdev_open() when a datapath of type + * 'datapath_type' has a port of type 'port_type', for a few special + * cases when a netdev type differs from a port type. For example, when + * using the userspace datapath, a port of type "internal" needs to be + * opened as "tap". + * + * Returns either 'type' itself or a string literal, which must not be + * freed. */ +const char * +ofproto_port_open_type(const char *datapath_type, const char *port_type) +{ + const struct ofproto_class *class; + + datapath_type = ofproto_normalize_type(datapath_type); + class = ofproto_class_find__(datapath_type); + if (!class) { + return port_type; + } + + return (class->port_open_type + ? class->port_open_type(datapath_type, port_type) + : port_type); +} + +/* Attempts to add 'netdev' as a port on 'ofproto'. If 'ofp_portp' is + * non-null and '*ofp_portp' is not OFPP_NONE, attempts to use that as + * the port's OpenFlow port number. + * + * If successful, returns 0 and sets '*ofp_portp' to the new port's + * OpenFlow port number (if 'ofp_portp' is non-null). On failure, + * returns a positive errno value and sets '*ofp_portp' to OFPP_NONE (if + * 'ofp_portp' is non-null). */ int ofproto_port_add(struct ofproto *ofproto, struct netdev *netdev, uint16_t *ofp_portp) { - uint16_t ofp_port; + uint16_t ofp_port = ofp_portp ? *ofp_portp : OFPP_NONE; int error; - error = ofproto->ofproto_class->port_add(ofproto, netdev, &ofp_port); + error = ofproto->ofproto_class->port_add(ofproto, netdev); if (!error) { - update_port(ofproto, netdev_get_name(netdev)); + const char *netdev_name = netdev_get_name(netdev); + + simap_put(&ofproto->ofp_requests, netdev_name, ofp_port); + update_port(ofproto, netdev_name); } if (ofp_portp) { - *ofp_portp = error ? OFPP_NONE : ofp_port; + struct ofproto_port ofproto_port; + + ofproto_port_query_by_name(ofproto, netdev_get_name(netdev), + &ofproto_port); + *ofp_portp = error ? OFPP_NONE : ofproto_port.ofp_port; + ofproto_port_destroy(&ofproto_port); } return error; } @@ -1392,8 +1516,14 @@ ofproto_port_del(struct ofproto *ofproto, uint16_t ofp_port) { struct ofport *ofport = ofproto_get_port(ofproto, ofp_port); const char *name = ofport ? netdev_get_name(ofport->netdev) : ""; + struct simap_node *ofp_request_node; int error; + ofp_request_node = simap_find(&ofproto->ofp_requests, name); + if (ofp_request_node) { + simap_delete(&ofproto->ofp_requests, ofp_request_node); + } + error = ofproto->ofproto_class->port_del(ofproto, ofp_port); if (!error && ofport) { /* 'name' is the netdev's name and update_port() is going to close the @@ -1519,12 +1649,58 @@ reinit_ports(struct ofproto *p) sset_destroy(&devnames); } +static uint16_t +alloc_ofp_port(struct ofproto *ofproto, const char *netdev_name) +{ + uint16_t ofp_port; + + ofp_port = simap_get(&ofproto->ofp_requests, netdev_name); + ofp_port = ofp_port ? ofp_port : OFPP_NONE; + + if (ofp_port >= ofproto->max_ports + || bitmap_is_set(ofproto->ofp_port_ids, ofp_port)) { + bool retry = ofproto->alloc_port_no ? true : false; + + /* Search for a free OpenFlow port number. We try not to + * immediately reuse them to prevent problems due to old + * flows. */ + while (ofp_port >= ofproto->max_ports) { + for (ofproto->alloc_port_no++; + ofproto->alloc_port_no < ofproto->max_ports; + ofproto->alloc_port_no++) { + if (!bitmap_is_set(ofproto->ofp_port_ids, + ofproto->alloc_port_no)) { + ofp_port = ofproto->alloc_port_no; + break; + } + } + if (ofproto->alloc_port_no >= ofproto->max_ports) { + if (retry) { + ofproto->alloc_port_no = 0; + retry = false; + } else { + return OFPP_NONE; + } + } + } + } + + bitmap_set1(ofproto->ofp_port_ids, ofp_port); + return ofp_port; +} + +static void +dealloc_ofp_port(const struct ofproto *ofproto, uint16_t ofp_port) +{ + bitmap_set0(ofproto->ofp_port_ids, ofp_port); +} + /* Opens and returns a netdev for 'ofproto_port' in 'ofproto', or a null * pointer if the netdev cannot be opened. On success, also fills in * 'opp'. */ static struct netdev * -ofport_open(const struct ofproto *ofproto, - const struct ofproto_port *ofproto_port, +ofport_open(struct ofproto *ofproto, + struct ofproto_port *ofproto_port, struct ofputil_phy_port *pp) { enum netdev_flags flags; @@ -1541,6 +1717,14 @@ ofport_open(const struct ofproto *ofproto, return NULL; } + if (ofproto_port->ofp_port == OFPP_NONE) { + if (!strcmp(ofproto->name, ofproto_port->name)) { + ofproto_port->ofp_port = OFPP_LOCAL; + } else { + ofproto_port->ofp_port = alloc_ofp_port(ofproto, + ofproto_port->name); + } + } pp->port_no = ofproto_port->ofp_port; netdev_get_etheraddr(netdev, pp->hw_addr); ovs_strlcpy(pp->name, ofproto_port->name, sizeof pp->name); @@ -1549,8 +1733,8 @@ ofport_open(const struct ofproto *ofproto, pp->state = netdev_get_carrier(netdev) ? 0 : OFPUTIL_PS_LINK_DOWN; netdev_get_features(netdev, &pp->curr, &pp->advertised, &pp->supported, &pp->peer); - pp->curr_speed = netdev_features_to_bps(pp->curr); - pp->max_speed = netdev_features_to_bps(pp->supported); + pp->curr_speed = netdev_features_to_bps(pp->curr, 0); + pp->max_speed = netdev_features_to_bps(pp->supported, 0); return netdev; } @@ -1710,6 +1894,7 @@ static void ofport_destroy(struct ofport *port) { if (port) { + dealloc_ofp_port(port->ofproto, port->ofp_port); port->ofproto->ofproto_class->port_destruct(port); ofport_destroy__(port); } @@ -1803,19 +1988,25 @@ init_ports(struct ofproto *p) { struct ofproto_port_dump dump; struct ofproto_port ofproto_port; + struct shash_node *node, *next; OFPROTO_PORT_FOR_EACH (&ofproto_port, &dump, p) { - uint16_t ofp_port = ofproto_port.ofp_port; - if (ofproto_get_port(p, ofp_port)) { - VLOG_WARN_RL(&rl, "%s: ignoring duplicate port %"PRIu16" " - "in datapath", p->name, ofp_port); - } else if (shash_find(&p->port_by_name, ofproto_port.name)) { + const char *name = ofproto_port.name; + + if (shash_find(&p->port_by_name, name)) { VLOG_WARN_RL(&rl, "%s: ignoring duplicate device %s in datapath", - p->name, ofproto_port.name); + p->name, name); } else { struct ofputil_phy_port pp; struct netdev *netdev; + /* Check if an OpenFlow port number had been requested. */ + 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); + } + netdev = ofport_open(p, &ofproto_port, &pp); if (netdev) { ofport_install(p, netdev, &pp); @@ -1823,6 +2014,16 @@ init_ports(struct ofproto *p) } } + SHASH_FOR_EACH_SAFE(node, next, &init_ofp_ports) { + const struct iface_hint *iface_hint = node->data; + + if (!strcmp(iface_hint->br_name, p->name)) { + free(iface_hint->br_name); + free(iface_hint->br_type); + shash_delete(&init_ofp_ports, node); + } + } + return 0; } @@ -1901,6 +2102,7 @@ static void ofproto_rule_destroy__(struct rule *rule) { if (rule) { + cls_rule_destroy(&rule->cr); free(rule->ofpacts); rule->ofproto->ofproto_class->rule_dealloc(rule); } @@ -1927,7 +2129,7 @@ ofproto_rule_destroy(struct rule *rule) bool ofproto_rule_has_out_port(const struct rule *rule, uint16_t port) { - return (port == OFPP_NONE + return (port == OFPP_ANY || ofpacts_output_to_port(rule->ofpacts, rule->ofpacts_len, port)); } @@ -1956,7 +2158,7 @@ ofoperation_has_out_port(const struct ofoperation *op, uint16_t out_port) /* Executes the actions indicated by 'rule' on 'packet' and credits 'rule''s * statistics appropriately. 'packet' must have at least sizeof(struct - * ofp_packet_in) bytes of headroom. + * ofp10_packet_in) bytes of headroom. * * 'packet' doesn't necessarily have to match 'rule'. 'rule' will be credited * with statistics for 'packet' either way. @@ -1967,9 +2169,9 @@ rule_execute(struct rule *rule, uint16_t in_port, struct ofpbuf *packet) { struct flow flow; - assert(ofpbuf_headroom(packet) >= sizeof(struct ofp_packet_in)); + assert(ofpbuf_headroom(packet) >= sizeof(struct ofp10_packet_in)); - flow_extract(packet, 0, 0, in_port, &flow); + flow_extract(packet, 0, 0, NULL, in_port, &flow); return rule->ofproto->ofproto_class->rule_execute(rule, &flow, packet); } @@ -2011,20 +2213,33 @@ handle_features_request(struct ofconn *ofconn, const struct ofp_header *oh) struct ofport *port; bool arp_match_ip; struct ofpbuf *b; + int n_tables; + int i; ofproto->ofproto_class->get_features(ofproto, &arp_match_ip, &features.actions); assert(features.actions & OFPUTIL_A_OUTPUT); /* sanity check */ + /* Count only non-hidden tables in the number of tables. (Hidden tables, + * if present, are always at the end.) */ + n_tables = ofproto->n_tables; + for (i = 0; i < ofproto->n_tables; i++) { + if (ofproto->tables[i].flags & OFTABLE_HIDDEN) { + n_tables = i; + break; + } + } + features.datapath_id = ofproto->datapath_id; features.n_buffers = pktbuf_capacity(); - features.n_tables = ofproto->n_tables; + features.n_tables = n_tables; features.capabilities = (OFPUTIL_C_FLOW_STATS | OFPUTIL_C_TABLE_STATS | OFPUTIL_C_PORT_STATS | OFPUTIL_C_QUEUE_STATS); if (arp_match_ip) { features.capabilities |= OFPUTIL_C_ARP_MATCH_IP; } - + /* FIXME: Fill in proper features.auxiliary_id for auxiliary connections */ + features.auxiliary_id = 0; b = ofputil_encode_switch_features(&features, ofconn_get_protocol(ofconn), oh->xid); HMAP_FOR_EACH (port, hmap_node, &ofproto->ports) { @@ -2047,7 +2262,9 @@ handle_get_config_request(struct ofconn *ofconn, const struct ofp_header *oh) buf = ofpraw_alloc_reply(OFPRAW_OFPT_GET_CONFIG_REPLY, oh, 0); osc = ofpbuf_put_uninit(buf, sizeof *osc); flags = ofproto->frag_handling; - if (ofconn_get_invalid_ttl_to_controller(ofconn)) { + /* OFPC_INVALID_TTL_TO_CONTROLLER is deprecated in OF 1.3 */ + if (oh->version < OFP13_VERSION + && ofconn_get_invalid_ttl_to_controller(ofconn)) { flags |= OFPC_INVALID_TTL_TO_CONTROLLER; } osc->flags = htons(flags); @@ -2080,8 +2297,10 @@ handle_set_config(struct ofconn *ofconn, const struct ofp_header *oh) } } } + /* OFPC_INVALID_TTL_TO_CONTROLLER is deprecated in OF 1.3 */ ofconn_set_invalid_ttl_to_controller(ofconn, - (flags & OFPC_INVALID_TTL_TO_CONTROLLER)); + (oh->version < OFP13_VERSION + && flags & OFPC_INVALID_TTL_TO_CONTROLLER)); ofconn_set_miss_send_len(ofconn, ntohs(osc->miss_send_len)); @@ -2129,10 +2348,11 @@ handle_packet_out(struct ofconn *ofconn, const struct ofp_header *oh) goto exit_free_ofpacts; } if (po.in_port >= p->max_ports && po.in_port < OFPP_MAX) { - error = OFPERR_NXBRC_BAD_IN_PORT; + error = OFPERR_OFPBRC_BAD_PORT; goto exit_free_ofpacts; } + /* Get payload. */ if (po.buffer_id != UINT32_MAX) { error = ofconn_pktbuf_retrieve(ofconn, po.buffer_id, &payload, NULL); @@ -2145,7 +2365,7 @@ 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, po.in_port, &flow); + flow_extract(payload, 0, 0, NULL, po.in_port, &flow); error = ofpacts_check(po.ofpacts, po.ofpacts_len, &flow, p->max_ports); if (!error) { error = p->ofproto_class->packet_out(p, payload, &flow, @@ -2240,25 +2460,47 @@ handle_table_stats_request(struct ofconn *ofconn, const struct ofp_header *request) { struct ofproto *p = ofconn_get_ofproto(ofconn); - struct ofp10_table_stats *ots; + struct ofp12_table_stats *ots; struct ofpbuf *msg; + int n_tables; size_t i; - msg = ofpraw_alloc_stats_reply(request, sizeof *ots * p->n_tables); - ots = ofpbuf_put_zeros(msg, sizeof *ots * p->n_tables); + /* Set up default values. + * + * ofp12_table_stats is used as a generic structure as + * it is able to hold all the fields for ofp10_table_stats + * and ofp11_table_stats (and of course itself). + */ + ots = xcalloc(p->n_tables, sizeof *ots); for (i = 0; i < p->n_tables; i++) { ots[i].table_id = i; sprintf(ots[i].name, "table%zu", i); - ots[i].wildcards = htonl(OFPFW10_ALL); + ots[i].match = htonll(OFPXMT12_MASK); + ots[i].wildcards = htonll(OFPXMT12_MASK); + ots[i].write_actions = htonl(OFPAT11_OUTPUT); + ots[i].apply_actions = htonl(OFPAT11_OUTPUT); + ots[i].write_setfields = htonll(OFPXMT12_MASK); + ots[i].apply_setfields = htonll(OFPXMT12_MASK); + ots[i].metadata_match = htonll(UINT64_MAX); + ots[i].metadata_write = htonll(UINT64_MAX); + ots[i].instructions = htonl(OFPIT11_ALL); + ots[i].config = htonl(OFPTC11_TABLE_MISS_MASK); ots[i].max_entries = htonl(1000000); /* An arbitrary big number. */ ots[i].active_count = htonl(classifier_count(&p->tables[i].cls)); } p->ofproto_class->get_tables(p, ots); + /* Post-process the tables, dropping hidden tables. */ + n_tables = p->n_tables; for (i = 0; i < p->n_tables; i++) { const struct oftable *table = &p->tables[i]; + if (table->flags & OFTABLE_HIDDEN) { + n_tables = i; + break; + } + if (table->name) { ovs_strzcpy(ots[i].name, table->name, sizeof ots[i].name); } @@ -2268,36 +2510,25 @@ handle_table_stats_request(struct ofconn *ofconn, } } + msg = ofputil_encode_table_stats_reply(ots, n_tables, request); ofconn_send_reply(ofconn, msg); + + free(ots); + return 0; } static void append_port_stat(struct ofport *port, struct list *replies) { - struct netdev_stats stats; - struct ofp10_port_stats *ops; + struct ofputil_port_stats ops = { .port_no = port->pp.port_no }; /* Intentionally ignore return value, since errors will set * 'stats' to all-1s, which is correct for OpenFlow, and * netdev_get_stats() will log errors. */ - ofproto_port_get_stats(port, &stats); - - ops = ofpmp_append(replies, sizeof *ops); - ops->port_no = htons(port->pp.port_no); - memset(ops->pad, 0, sizeof ops->pad); - put_32aligned_be64(&ops->rx_packets, htonll(stats.rx_packets)); - put_32aligned_be64(&ops->tx_packets, htonll(stats.tx_packets)); - put_32aligned_be64(&ops->rx_bytes, htonll(stats.rx_bytes)); - put_32aligned_be64(&ops->tx_bytes, htonll(stats.tx_bytes)); - put_32aligned_be64(&ops->rx_dropped, htonll(stats.rx_dropped)); - put_32aligned_be64(&ops->tx_dropped, htonll(stats.tx_dropped)); - put_32aligned_be64(&ops->rx_errors, htonll(stats.rx_errors)); - put_32aligned_be64(&ops->tx_errors, htonll(stats.tx_errors)); - put_32aligned_be64(&ops->rx_frame_err, htonll(stats.rx_frame_errors)); - put_32aligned_be64(&ops->rx_over_err, htonll(stats.rx_over_errors)); - put_32aligned_be64(&ops->rx_crc_err, htonll(stats.rx_crc_errors)); - put_32aligned_be64(&ops->collisions, htonll(stats.collisions)); + ofproto_port_get_stats(port, &ops.stats); + + ofputil_append_port_stat(replies, &ops); } static enum ofperr @@ -2305,13 +2536,19 @@ handle_port_stats_request(struct ofconn *ofconn, const struct ofp_header *request) { struct ofproto *p = ofconn_get_ofproto(ofconn); - const struct ofp10_port_stats_request *psr = ofpmsg_body(request); struct ofport *port; struct list replies; + uint16_t port_no; + enum ofperr error; + + error = ofputil_decode_port_stats_request(request, &port_no); + if (error) { + return error; + } ofpmp_init(&replies, request); - if (psr->port_no != htons(OFPP_NONE)) { - port = ofproto_get_port(p, ntohs(psr->port_no)); + if (port_no != OFPP_ANY) { + port = ofproto_get_port(p, port_no); if (port) { append_port_stat(port, &replies); } @@ -2361,7 +2598,7 @@ check_table_id(const struct ofproto *ofproto, uint8_t table_id) { return (table_id == 0xff || table_id < ofproto->n_tables ? 0 - : OFPERR_NXBRC_BAD_TABLE_ID); + : OFPERR_OFPBRC_BAD_TABLE_ID); } @@ -2427,7 +2664,7 @@ next_matching_table(const struct ofproto *ofproto, * OpenFlow OFPFC_MODIFY and OFPFC_DELETE requests and puts them on list * 'rules'. * - * If 'out_port' is anything other than OFPP_NONE, then only rules that output + * If 'out_port' is anything other than OFPP_ANY, then only rules that output * to 'out_port' are included. * * Hidden rules are always omitted. @@ -2457,7 +2694,8 @@ collect_rules_loose(struct ofproto *ofproto, uint8_t table_id, cls_cursor_init(&cursor, &table->cls, &cr); CLS_CURSOR_FOR_EACH (rule, cr, &cursor) { if (rule->pending) { - return OFPROTO_POSTPONE; + error = OFPROTO_POSTPONE; + goto exit; } if (!ofproto_rule_is_hidden(rule) && ofproto_rule_has_out_port(rule, out_port) @@ -2466,7 +2704,10 @@ collect_rules_loose(struct ofproto *ofproto, uint8_t table_id, } } } - return 0; + +exit: + cls_rule_destroy(&cr); + return error; } /* Searches 'ofproto' for rules in table 'table_id' (or in all tables, if @@ -2474,7 +2715,7 @@ collect_rules_loose(struct ofproto *ofproto, uint8_t table_id, * OpenFlow OFPFC_MODIFY_STRICT and OFPFC_DELETE_STRICT requests and puts them * on list 'rules'. * - * If 'out_port' is anything other than OFPP_NONE, then only rules that output + * If 'out_port' is anything other than OFPP_ANY, then only rules that output * to 'out_port' are included. * * Hidden rules are always omitted. @@ -2504,7 +2745,8 @@ collect_rules_strict(struct ofproto *ofproto, uint8_t table_id, &cr)); if (rule) { if (rule->pending) { - return OFPROTO_POSTPONE; + error = OFPROTO_POSTPONE; + goto exit; } if (!ofproto_rule_is_hidden(rule) && ofproto_rule_has_out_port(rule, out_port) @@ -2513,6 +2755,9 @@ collect_rules_strict(struct ofproto *ofproto, uint8_t table_id, } } } + +exit: + cls_rule_destroy(&cr); return 0; } @@ -2554,7 +2799,7 @@ handle_flow_stats_request(struct ofconn *ofconn, long long int now = time_msec(); struct ofputil_flow_stats fs; - fs.match = rule->cr.match; + minimatch_expand(&rule->cr.match, &fs.match); fs.priority = rule->cr.priority; fs.cookie = rule->flow_cookie; fs.table_id = rule->table_id; @@ -2568,6 +2813,12 @@ handle_flow_stats_request(struct ofconn *ofconn, &fs.byte_count); fs.ofpacts = rule->ofpacts; fs.ofpacts_len = rule->ofpacts_len; + fs.flags = 0; + if (rule->send_flow_removed) { + fs.flags |= OFPFF_SEND_FLOW_REM; + /* FIXME: Implement OF 1.3 flags OFPFF13_NO_PKT_COUNTS + and OFPFF13_NO_BYT_COUNTS */ + } ofputil_append_flow_stats_reply(&fs, &replies); } ofconn_send_replies(ofconn, &replies); @@ -2756,15 +3007,13 @@ static void put_queue_stats(struct queue_stats_cbdata *cbdata, uint32_t queue_id, const struct netdev_queue_stats *stats) { - struct ofp10_queue_stats *reply; - reply = ofpmp_append(&cbdata->replies, sizeof *reply); - reply->port_no = htons(cbdata->ofport->pp.port_no); - memset(reply->pad, 0, sizeof reply->pad); - reply->queue_id = htonl(queue_id); - put_32aligned_be64(&reply->tx_bytes, htonll(stats->tx_bytes)); - put_32aligned_be64(&reply->tx_packets, htonll(stats->tx_packets)); - put_32aligned_be64(&reply->tx_errors, htonll(stats->tx_errors)); + struct ofputil_queue_stats oqs = { + .port_no = cbdata->ofport->pp.port_no, + .queue_id = queue_id, + .stats = *stats, + }; + ofputil_append_queue_stat(&cbdata->replies, &oqs); } static void @@ -2802,30 +3051,31 @@ handle_queue_stats_request(struct ofconn *ofconn, const struct ofp_header *rq) { struct ofproto *ofproto = ofconn_get_ofproto(ofconn); - const struct ofp10_queue_stats_request *qsr = ofpmsg_body(rq); struct queue_stats_cbdata cbdata; - unsigned int port_no; struct ofport *port; - uint32_t queue_id; enum ofperr error; + struct ofputil_queue_stats_request oqsr; COVERAGE_INC(ofproto_queue_req); ofpmp_init(&cbdata.replies, rq); - port_no = ntohs(qsr->port_no); - queue_id = ntohl(qsr->queue_id); - if (port_no == OFPP_ALL) { + error = ofputil_decode_queue_stats_request(rq, &oqsr); + if (error) { + return error; + } + + if (oqsr.port_no == OFPP_ANY) { error = OFPERR_OFPQOFC_BAD_QUEUE; HMAP_FOR_EACH (port, hmap_node, &ofproto->ports) { - if (!handle_queue_stats_for_port(port, queue_id, &cbdata)) { + if (!handle_queue_stats_for_port(port, oqsr.queue_id, &cbdata)) { error = 0; } } } else { - port = ofproto_get_port(ofproto, port_no); + port = ofproto_get_port(ofproto, oqsr.port_no); error = (port - ? handle_queue_stats_for_port(port, queue_id, &cbdata) + ? handle_queue_stats_for_port(port, oqsr.queue_id, &cbdata) : OFPERR_OFPQOFC_BAD_PORT); } if (!error) { @@ -2904,7 +3154,7 @@ add_flow(struct ofproto *ofproto, struct ofconn *ofconn, } else if (fm->table_id < ofproto->n_tables) { table = &ofproto->tables[fm->table_id]; } else { - return OFPERR_NXFMFC_BAD_TABLE_ID; + return OFPERR_OFPBRC_BAD_TABLE_ID; } if (table->flags & OFTABLE_READONLY) { @@ -2922,6 +3172,7 @@ add_flow(struct ofproto *ofproto, struct ofconn *ofconn, /* Serialize against pending deletion. */ if (is_flow_deletion_pending(ofproto, &cr, table - ofproto->tables)) { + cls_rule_destroy(&rule->cr); ofproto->ofproto_class->rule_dealloc(rule); return OFPROTO_POSTPONE; } @@ -2929,10 +3180,13 @@ add_flow(struct ofproto *ofproto, struct ofconn *ofconn, /* 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; } + /* FIXME: Implement OFPFF12_RESET_COUNTS */ + rule->ofproto = ofproto; rule->pending = NULL; rule->flow_cookie = fm->new_cookie; @@ -2941,6 +3195,8 @@ add_flow(struct ofproto *ofproto, struct ofconn *ofconn, rule->hard_timeout = fm->hard_timeout; 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; @@ -2968,7 +3224,7 @@ add_flow(struct ofproto *ofproto, struct ofconn *ofconn, rule->evictable = was_evictable; if (!evict) { - error = OFPERR_OFPFMFC_ALL_TABLES_FULL; + error = OFPERR_OFPFMFC_TABLE_FULL; goto exit; } else if (evict->pending) { error = OFPROTO_POSTPONE; @@ -3026,6 +3282,8 @@ modify_flows__(struct ofproto *ofproto, struct ofconn *ofconn, bool actions_changed; ovs_be64 new_cookie; + /* FIXME: Implement OFPFF12_RESET_COUNTS */ + if (rule_is_modifiable(rule)) { /* At least one rule is modifiable, don't report EPERM error. */ error = 0; @@ -3060,6 +3318,17 @@ modify_flows__(struct ofproto *ofproto, struct ofconn *ofconn, return error; } +static enum ofperr +modify_flows_add(struct ofproto *ofproto, struct ofconn *ofconn, + const struct ofputil_flow_mod *fm, + const struct ofp_header *request) +{ + if (fm->cookie_mask != htonll(0) || fm->new_cookie == htonll(UINT64_MAX)) { + return 0; + } + return add_flow(ofproto, ofconn, fm, request); +} + /* Implements OFPFC_MODIFY. Returns 0 on success or an OpenFlow error code on * failure. * @@ -3075,11 +3344,11 @@ modify_flows_loose(struct ofproto *ofproto, struct ofconn *ofconn, error = collect_rules_loose(ofproto, fm->table_id, &fm->match, fm->cookie, fm->cookie_mask, - OFPP_NONE, &rules); + OFPP_ANY, &rules); if (error) { return error; } else if (list_is_empty(&rules)) { - return fm->cookie_mask ? 0 : add_flow(ofproto, ofconn, fm, request); + return modify_flows_add(ofproto, ofconn, fm, request); } else { return modify_flows__(ofproto, ofconn, fm, request, &rules); } @@ -3100,12 +3369,12 @@ modify_flow_strict(struct ofproto *ofproto, struct ofconn *ofconn, error = collect_rules_strict(ofproto, fm->table_id, &fm->match, fm->priority, fm->cookie, fm->cookie_mask, - OFPP_NONE, &rules); + OFPP_ANY, &rules); if (error) { return error; } else if (list_is_empty(&rules)) { - return fm->cookie_mask ? 0 : add_flow(ofproto, ofconn, fm, request); + return modify_flows_add(ofproto, ofconn, fm, request); } else { return list_is_singleton(&rules) ? modify_flows__(ofproto, ofconn, fm, request, &rules) @@ -3191,10 +3460,11 @@ ofproto_rule_send_removed(struct rule *rule, uint8_t reason) return; } - fr.match = rule->cr.match; + minimatch_expand(&rule->cr.match, &fr.match); fr.priority = rule->cr.priority; 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); fr.idle_timeout = rule->idle_timeout; @@ -3263,18 +3533,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) { - goto exit_free_ofpacts; - } - - if (fm.flags & OFPFF10_EMERG) { - /* We do not support the OpenFlow 1.0 emergency flow cache, which is not - * required in OpenFlow 1.0.1 and removed from OpenFlow 1.1. */ - /* We do not support the emergency flow cache. It will hopefully get - * dropped from OpenFlow in the near future. There is no good error - * code, so just state that the flow table is full. */ - error = OFPERR_OFPFMFC_ALL_TABLES_FULL; - } if (!error) { error = ofpacts_check(fm.ofpacts, fm.ofpacts_len, &fm.match.flow, ofproto->max_ports); @@ -3285,7 +3543,7 @@ handle_flow_mod(struct ofconn *ofconn, const struct ofp_header *oh) if (error) { goto exit_free_ofpacts; } - + /* Record the operation for logging a summary report. */ switch (fm.command) { case OFPFC_ADD: @@ -3503,6 +3761,7 @@ ofproto_compose_flow_refresh_update(const struct rule *rule, { struct ofoperation *op = rule->pending; struct ofputil_flow_update fu; + struct match match; if (op && op->type == OFOPERATION_ADD && !op->victim) { /* We'll report the final flow when the operation completes. Reporting @@ -3517,7 +3776,9 @@ ofproto_compose_flow_refresh_update(const struct rule *rule, fu.hard_timeout = rule->hard_timeout; fu.table_id = rule->table_id; fu.cookie = rule->flow_cookie; - fu.match = CONST_CAST(struct match *, &rule->cr.match); + minimatch_expand(&rule->cr.match, &match); + fu.match = &match; + fu.priority = rule->cr.priority; if (!(flags & NXFMF_ACTIONS)) { fu.ofpacts = NULL; fu.ofpacts_len = 0; @@ -3622,7 +3883,7 @@ ofproto_collect_ofmonitor_refresh_rules(const struct ofmonitor *m, const struct oftable *table; struct cls_rule target; - cls_rule_init(&target, &m->match, 0); + cls_rule_init_from_minimatch(&target, &m->match, 0); FOR_EACH_MATCHING_TABLE (table, m->table_id, ofproto) { struct cls_cursor cursor; struct rule *rule; @@ -3644,6 +3905,7 @@ ofproto_collect_ofmonitor_refresh_rules(const struct ofmonitor *m, ofproto_collect_ofmonitor_refresh_rule(m, rule, seqno, rules); } } + cls_rule_destroy(&target); } static void @@ -3839,6 +4101,18 @@ handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg) case OFPTYPE_FLOW_MONITOR_STATS_REQUEST: return handle_flow_monitor_request(ofconn, oh); + /* FIXME: Change the following once they are implemented: */ + 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: + return OFPERR_OFPBRC_BAD_TYPE; + case OFPTYPE_HELLO: case OFPTYPE_ERROR: case OFPTYPE_FEATURES_REPLY: @@ -3858,6 +4132,14 @@ handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg) case OFPTYPE_FLOW_MONITOR_PAUSED: 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: default: return OFPERR_OFPBRC_BAD_TYPE; } @@ -4007,13 +4289,13 @@ ofopgroup_complete(struct ofopgroup *group) switch (op->type) { case OFOPERATION_ADD: if (!op->error) { + uint16_t vid_mask; + ofproto_rule_destroy__(op->victim); - if ((rule->cr.match.wc.masks.vlan_tci & htons(VLAN_VID_MASK)) - == htons(VLAN_VID_MASK)) { + vid_mask = minimask_get_vid_mask(&rule->cr.match.mask); + if (vid_mask == VLAN_VID_MASK) { if (ofproto->vlan_bitmap) { - uint16_t vid; - - vid = vlan_tci_to_vid(rule->cr.match.flow.vlan_tci); + uint16_t vid = miniflow_get_vid(&rule->cr.match.flow); if (!bitmap_is_set(ofproto->vlan_bitmap, vid)) { bitmap_set1(ofproto->vlan_bitmap, vid); ofproto->vlans_changed = true; @@ -4347,17 +4629,19 @@ eviction_group_hash_rule(struct rule *rule) { struct oftable *table = &rule->ofproto->tables[rule->table_id]; const struct mf_subfield *sf; + struct flow flow; uint32_t hash; hash = table->eviction_group_id_basis; + miniflow_expand(&rule->cr.match.flow, &flow); for (sf = table->eviction_fields; sf < &table->eviction_fields[table->n_eviction_fields]; sf++) { - if (mf_are_prereqs_ok(sf->field, &rule->cr.match.flow)) { + if (mf_are_prereqs_ok(sf->field, &flow)) { union mf_value value; - mf_get_value(sf->field, &rule->cr.match.flow, &value); + mf_get_value(sf->field, &flow, &value); if (sf->ofs) { bitwise_zero(&value, sf->field->n_bytes, 0, sf->ofs); } @@ -4663,12 +4947,11 @@ ofproto_get_vlan_usage(struct ofproto *ofproto, unsigned long int *vlan_bitmap) const struct cls_table *table; HMAP_FOR_EACH (table, hmap_node, &oftable->cls.tables) { - if ((table->wc.masks.vlan_tci & htons(VLAN_VID_MASK)) - == htons(VLAN_VID_MASK)) { + if (minimask_get_vid_mask(&table->mask) == VLAN_VID_MASK) { const struct cls_rule *rule; HMAP_FOR_EACH (rule, hmap_node, &table->rules) { - uint16_t vid = vlan_tci_to_vid(rule->match.flow.vlan_tci); + uint16_t vid = miniflow_get_vid(&rule->match.flow); bitmap_set1(vlan_bitmap, vid); bitmap_set1(ofproto->vlan_bitmap, vid); }