X-Git-Url: http://git.cascardo.eti.br/?a=blobdiff_plain;f=ofproto%2Fofproto.c;h=3faf42ac8db1bba57e0bbd24eaeef972cace5ff1;hb=6b1c573408f8771e428707278f86c5b3b076982a;hp=a7240716e3c9750026ad4fc3b3a863f7b41e3f3e;hpb=980904823303ef02af605e62a30c9bebda25f1ef;p=cascardo%2Fovs.git diff --git a/ofproto/ofproto.c b/ofproto/ofproto.c index a7240716e..3faf42ac8 100644 --- a/ofproto/ofproto.c +++ b/ofproto/ofproto.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2009-2015 Nicira, Inc. + * Copyright (c) 2009-2016 Nicira, Inc. * Copyright (c) 2010 Jean Tourrilhes - HP-Labs. * * Licensed under the Apache License, Version 2.0 (the "License"); @@ -297,7 +297,8 @@ static bool ofproto_group_exists__(const struct ofproto *ofproto, static bool ofproto_group_exists(const struct ofproto *ofproto, uint32_t group_id) OVS_EXCLUDED(ofproto->groups_rwlock); -static enum ofperr add_group(struct ofproto *, struct ofputil_group_mod *); +static enum ofperr add_group(struct ofproto *, + const struct ofputil_group_mod *); static void handle_openflow(struct ofconn *, const struct ofpbuf *); static enum ofperr ofproto_flow_mod_start(struct ofproto *, struct ofproto_flow_mod *) @@ -544,7 +545,7 @@ ofproto_create(const char *datapath_name, const char *datapath_type, ofproto->sw_desc = NULL; ofproto->serial_desc = NULL; ofproto->dp_desc = NULL; - ofproto->frag_handling = OFPC_FRAG_NORMAL; + ofproto->frag_handling = OFPUTIL_FRAG_NORMAL; hmap_init(&ofproto->ports); hmap_init(&ofproto->ofport_usage); shash_init(&ofproto->port_by_name); @@ -2033,24 +2034,18 @@ flow_mod_init(struct ofputil_flow_mod *fm, const struct ofpact *ofpacts, size_t ofpacts_len, enum ofp_flow_mod_command command) { - memset(fm, 0, sizeof *fm); - fm->match = *match; - fm->priority = priority; - fm->cookie = 0; - fm->new_cookie = 0; - fm->modify_cookie = false; - fm->table_id = 0; - fm->command = command; - fm->idle_timeout = 0; - fm->hard_timeout = 0; - fm->importance = 0; - fm->buffer_id = UINT32_MAX; - fm->out_port = OFPP_ANY; - fm->out_group = OFPG_ANY; - fm->flags = 0; - fm->ofpacts = CONST_CAST(struct ofpact *, ofpacts); - fm->ofpacts_len = ofpacts_len; - fm->delete_reason = OFPRR_DELETE; + *fm = (struct ofputil_flow_mod) { + .match = *match, + .priority = priority, + .table_id = 0, + .command = command, + .buffer_id = UINT32_MAX, + .out_port = OFPP_ANY, + .out_group = OFPG_ANY, + .ofpacts = CONST_CAST(struct ofpact *, ofpacts), + .ofpacts_len = ofpacts_len, + .delete_reason = OFPRR_DELETE, + }; } static int @@ -2317,7 +2312,7 @@ ofport_open(struct ofproto *ofproto, } } pp->port_no = ofproto_port->ofp_port; - netdev_get_etheraddr(netdev, pp->hw_addr); + netdev_get_etheraddr(netdev, &pp->hw_addr); ovs_strlcpy(pp->name, ofproto_port->name, sizeof pp->name); netdev_get_flags(netdev, &flags); pp->config = flags & NETDEV_UP ? 0 : OFPUTIL_PC_PORT_DOWN; @@ -2424,7 +2419,7 @@ ofport_remove_with_name(struct ofproto *ofproto, const char *name) static void ofport_modified(struct ofport *port, struct ofputil_phy_port *pp) { - memcpy(port->pp.hw_addr, pp->hw_addr, ETH_ADDR_LEN); + port->pp.hw_addr = pp->hw_addr; port->pp.config = ((port->pp.config & ~OFPUTIL_PC_PORT_DOWN) | (pp->config & OFPUTIL_PC_PORT_DOWN)); port->pp.state = ((port->pp.state & ~OFPUTIL_PS_LINK_DOWN) @@ -3255,23 +3250,13 @@ handle_features_request(struct ofconn *ofconn, const struct ofp_header *oh) static enum ofperr handle_get_config_request(struct ofconn *ofconn, const struct ofp_header *oh) { - struct ofproto *ofproto = ofconn_get_ofproto(ofconn); - struct ofp_switch_config *osc; - enum ofp_config_flags flags; - struct ofpbuf *buf; + struct ofputil_switch_config config; + config.frag = ofconn_get_ofproto(ofconn)->frag_handling; + config.invalid_ttl_to_controller + = ofconn_get_invalid_ttl_to_controller(ofconn); + config.miss_send_len = ofconn_get_miss_send_len(ofconn); - /* Send reply. */ - buf = ofpraw_alloc_reply(OFPRAW_OFPT_GET_CONFIG_REPLY, oh, 0); - osc = ofpbuf_put_uninit(buf, sizeof *osc); - flags = ofproto->frag_handling; - /* 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); - osc->miss_send_len = htons(ofconn_get_miss_send_len(ofconn)); - ofconn_send_reply(ofconn, buf); + ofconn_send_reply(ofconn, ofputil_encode_get_config_reply(oh, &config)); return 0; } @@ -3279,16 +3264,20 @@ handle_get_config_request(struct ofconn *ofconn, const struct ofp_header *oh) static enum ofperr handle_set_config(struct ofconn *ofconn, const struct ofp_header *oh) { - const struct ofp_switch_config *osc = ofpmsg_body(oh); struct ofproto *ofproto = ofconn_get_ofproto(ofconn); - uint16_t flags = ntohs(osc->flags); + struct ofputil_switch_config config; + enum ofperr error; + + error = ofputil_decode_set_config(oh, &config); + if (error) { + return error; + } if (ofconn_get_type(ofconn) != OFCONN_PRIMARY || ofconn_get_role(ofconn) != OFPCR12_ROLE_SLAVE) { - enum ofp_config_flags cur = ofproto->frag_handling; - enum ofp_config_flags next = flags & OFPC_FRAG_MASK; + enum ofputil_frag_handling cur = ofproto->frag_handling; + enum ofputil_frag_handling next = config.frag; - ovs_assert((cur & OFPC_FRAG_MASK) == cur); if (cur != next) { if (ofproto->ofproto_class->set_frag_handling(ofproto, next)) { ofproto->frag_handling = next; @@ -3299,12 +3288,13 @@ 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, - (oh->version < OFP13_VERSION - && flags & OFPC_INVALID_TTL_TO_CONTROLLER)); - ofconn_set_miss_send_len(ofconn, ntohs(osc->miss_send_len)); + if (config.invalid_ttl_to_controller >= 0) { + ofconn_set_invalid_ttl_to_controller(ofconn, + config.invalid_ttl_to_controller); + } + + ofconn_set_miss_send_len(ofconn, config.miss_send_len); return 0; } @@ -3333,7 +3323,7 @@ reject_slave_controller(struct ofconn *ofconn) * - If they use any groups, then 'ofproto' has that group configured. * * Returns 0 if successful, otherwise an OpenFlow error. */ -static enum ofperr +enum ofperr ofproto_check_ofpacts(struct ofproto *ofproto, const struct ofpact ofpacts[], size_t ofpacts_len) { @@ -3345,7 +3335,7 @@ ofproto_check_ofpacts(struct ofproto *ofproto, return OFPERR_OFPMMFC_INVALID_METER; } - OFPACT_FOR_EACH (a, ofpacts, ofpacts_len) { + OFPACT_FOR_EACH_FLATTENED (a, ofpacts, ofpacts_len) { if (a->type == OFPACT_GROUP && !ofproto_group_exists(ofproto, ofpact_get_GROUP(a)->group_id)) { return OFPERR_OFPBAC_BAD_OUT_GROUP; @@ -3388,7 +3378,7 @@ handle_packet_out(struct ofconn *ofconn, const struct ofp_header *oh) /* Get payload. */ if (po.buffer_id != UINT32_MAX) { error = ofconn_pktbuf_retrieve(ofconn, po.buffer_id, &payload, NULL); - if (error || !payload) { + if (error) { goto exit_free_ofpacts; } } else { @@ -3399,10 +3389,22 @@ handle_packet_out(struct ofconn *ofconn, const struct ofp_header *oh) /* Verify actions against packet, then send packet if successful. */ flow_extract(payload, &flow); flow.in_port.ofp_port = po.in_port; - error = ofproto_check_ofpacts(p, po.ofpacts, po.ofpacts_len); + + /* Check actions like for flow mods. We pass a 'table_id' of 0 to + * ofproto_check_consistency(), which isn't strictly correct because these + * actions aren't in any table. This is OK as 'table_id' is only used to + * check instructions (e.g., goto-table), which can't appear on the action + * list of a packet-out. */ + error = ofpacts_check_consistency(po.ofpacts, po.ofpacts_len, + &flow, u16_to_ofp(p->max_ports), + 0, p->n_tables, + ofconn_get_protocol(ofconn)); if (!error) { - error = p->ofproto_class->packet_out(p, payload, &flow, - po.ofpacts, po.ofpacts_len); + error = ofproto_check_ofpacts(p, po.ofpacts, po.ofpacts_len); + if (!error) { + error = p->ofproto_class->packet_out(p, payload, &flow, + po.ofpacts, po.ofpacts_len); + } } dp_packet_delete(payload); @@ -3576,6 +3578,26 @@ handle_table_features_request(struct ofconn *ofconn, return 0; } +static void +query_table_desc__(struct ofputil_table_desc *td, + struct ofproto *ofproto, uint8_t table_id) +{ + unsigned int count = ofproto->tables[table_id].n_flows; + unsigned int max_flows = ofproto->tables[table_id].max_flows; + + td->table_id = table_id; + td->eviction = (ofproto->tables[table_id].eviction & EVICTION_OPENFLOW + ? OFPUTIL_TABLE_EVICTION_ON + : OFPUTIL_TABLE_EVICTION_OFF); + td->eviction_flags = OFPROTO_EVICTION_FLAGS; + td->vacancy = (ofproto->tables[table_id].vacancy_enabled + ? OFPUTIL_TABLE_VACANCY_ON + : OFPUTIL_TABLE_VACANCY_OFF); + td->table_vacancy.vacancy_down = ofproto->tables[table_id].vacancy_down; + td->table_vacancy.vacancy_up = ofproto->tables[table_id].vacancy_up; + td->table_vacancy.vacancy = max_flows ? (count * 100) / max_flows : 0; +} + /* This function queries the database for dumping table-desc. */ static void query_tables_desc(struct ofproto *ofproto, struct ofputil_table_desc **descp) @@ -3586,11 +3608,7 @@ query_tables_desc(struct ofproto *ofproto, struct ofputil_table_desc **descp) table_desc = *descp = xcalloc(ofproto->n_tables, sizeof *table_desc); for (i = 0; i < ofproto->n_tables; i++) { struct ofputil_table_desc *td = &table_desc[i]; - td->table_id = i; - td->eviction = (ofproto->tables[i].eviction & EVICTION_OPENFLOW - ? OFPUTIL_TABLE_EVICTION_ON - : OFPUTIL_TABLE_EVICTION_OFF); - td->eviction_flags = OFPROTO_EVICTION_FLAGS; + query_table_desc__(td, ofproto, i); } } @@ -4917,7 +4935,7 @@ modify_flows_start_loose(struct ofproto *ofproto, struct ofproto_flow_mod *ofm) enum ofperr error; rule_criteria_init(&criteria, fm->table_id, &fm->match, 0, CLS_MAX_VERSION, - fm->cookie, fm->cookie_mask, OFPP_ANY, OFPG11_ANY); + fm->cookie, fm->cookie_mask, OFPP_ANY, OFPG_ANY); rule_criteria_require_rw(&criteria, (fm->flags & OFPUTIL_FF_NO_READONLY) != 0); error = collect_rules_loose(ofproto, &criteria, old_rules); @@ -4994,7 +5012,7 @@ modify_flow_start_strict(struct ofproto *ofproto, struct ofproto_flow_mod *ofm) rule_criteria_init(&criteria, fm->table_id, &fm->match, fm->priority, CLS_MAX_VERSION, fm->cookie, fm->cookie_mask, OFPP_ANY, - OFPG11_ANY); + OFPG_ANY); rule_criteria_require_rw(&criteria, (fm->flags & OFPUTIL_FF_NO_READONLY) != 0); error = collect_rules_strict(ofproto, &criteria, old_rules); @@ -5315,7 +5333,8 @@ handle_role_request(struct ofconn *ofconn, const struct ofp_header *oh) } if (request.role != OFPCR12_ROLE_NOCHANGE) { - if (request.have_generation_id + if (request.role != OFPCR12_ROLE_EQUAL + && request.have_generation_id && !ofconn_set_master_election_id(ofconn, request.generation_id)) { return OFPERR_OFPRRFC_STALE; } @@ -5384,12 +5403,16 @@ handle_nxt_set_packet_in_format(struct ofconn *ofconn, static enum ofperr handle_nxt_set_async_config(struct ofconn *ofconn, const struct ofp_header *oh) { - uint32_t master[OAM_N_TYPES] = {0}; - uint32_t slave[OAM_N_TYPES] = {0}; + struct ofputil_async_cfg basis = ofconn_get_async_config(ofconn); + struct ofputil_async_cfg ac; + enum ofperr error; - ofputil_decode_set_async_config(oh, master, slave, false); + error = ofputil_decode_set_async_config(oh, false, &basis, &ac); + if (error) { + return error; + } - ofconn_set_async_config(ofconn, master, slave); + ofconn_set_async_config(ofconn, &ac); if (ofconn_get_type(ofconn) == OFCONN_SERVICE && !ofconn_get_miss_send_len(ofconn)) { ofconn_set_miss_send_len(ofconn, OFP_DEFAULT_MISS_SEND_LEN); @@ -5401,14 +5424,8 @@ handle_nxt_set_async_config(struct ofconn *ofconn, const struct ofp_header *oh) static enum ofperr handle_nxt_get_async_request(struct ofconn *ofconn, const struct ofp_header *oh) { - struct ofpbuf *buf; - uint32_t master[OAM_N_TYPES]; - uint32_t slave[OAM_N_TYPES]; - - ofconn_get_async_config(ofconn, master, slave); - - buf = ofputil_encode_get_async_config(oh, master, slave); - ofconn_send_reply(ofconn, buf); + struct ofputil_async_cfg ac = ofconn_get_async_config(ofconn); + ofconn_send_reply(ofconn, ofputil_encode_get_async_reply(oh, &ac)); return 0; } @@ -5907,6 +5924,14 @@ handle_meter_mod(struct ofconn *ofconn, const struct ofp_header *oh) break; } + if (!error) { + struct ofputil_requestforward rf; + rf.xid = oh->xid; + rf.reason = OFPRFR_METER_MOD; + rf.meter_mod = &mm; + connmgr_send_requestforward(ofproto->connmgr, ofconn, &rf); + } + exit_free_bands: ofpbuf_uninit(&bands); return error; @@ -6195,51 +6220,94 @@ handle_group_features_stats_request(struct ofconn *ofconn, return 0; } -static enum ofperr -handle_queue_get_config_request(struct ofconn *ofconn, - const struct ofp_header *oh) +static void +put_queue_get_config_reply(struct ofport *port, uint32_t queue, + struct ovs_list *replies) { - struct ofproto *p = ofconn_get_ofproto(ofconn); - struct netdev_queue_dump queue_dump; - struct ofport *ofport; - unsigned int queue_id; - struct ofpbuf *reply; - struct smap details; - ofp_port_t request; - enum ofperr error; + struct ofputil_queue_config qc; - error = ofputil_decode_queue_get_config_request(oh, &request); - if (error) { - return error; - } + /* None of the existing queues have compatible properties, so we hard-code + * omitting min_rate and max_rate. */ + qc.port = port->ofp_port; + qc.queue = queue; + qc.min_rate = UINT16_MAX; + qc.max_rate = UINT16_MAX; + ofputil_append_queue_get_config_reply(&qc, replies); +} - ofport = ofproto_get_port(p, request); - if (!ofport) { - return OFPERR_OFPQOFC_BAD_PORT; - } +static int +handle_queue_get_config_request_for_port(struct ofport *port, uint32_t queue, + struct ovs_list *replies) +{ + struct smap details = SMAP_INITIALIZER(&details); + if (queue != OFPQ_ALL) { + int error = netdev_get_queue(port->netdev, queue, &details); + switch (error) { + case 0: + put_queue_get_config_reply(port, queue, replies); + break; + case EOPNOTSUPP: + case EINVAL: + return OFPERR_OFPQOFC_BAD_QUEUE; + default: + return OFPERR_NXQOFC_QUEUE_ERROR; + } + } else { + struct netdev_queue_dump queue_dump; + uint32_t queue_id; - reply = ofputil_encode_queue_get_config_reply(oh); + NETDEV_QUEUE_FOR_EACH (&queue_id, &details, &queue_dump, + port->netdev) { + put_queue_get_config_reply(port, queue_id, replies); + } + } + smap_destroy(&details); + return 0; +} - smap_init(&details); - NETDEV_QUEUE_FOR_EACH (&queue_id, &details, &queue_dump, ofport->netdev) { - struct ofputil_queue_config queue; +static enum ofperr +handle_queue_get_config_request(struct ofconn *ofconn, + const struct ofp_header *oh) +{ + struct ofproto *ofproto = ofconn_get_ofproto(ofconn); + struct ovs_list replies; + struct ofport *port; + ofp_port_t req_port; + uint32_t req_queue; + enum ofperr error; - /* None of the existing queues have compatible properties, so we - * hard-code omitting min_rate and max_rate. */ - queue.queue_id = queue_id; - queue.min_rate = UINT16_MAX; - queue.max_rate = UINT16_MAX; - ofputil_append_queue_get_config_reply(reply, &queue); - } - smap_destroy(&details); + error = ofputil_decode_queue_get_config_request(oh, &req_port, &req_queue); + if (error) { + return error; + } - ofconn_send_reply(ofconn, reply); + ofputil_start_queue_get_config_reply(oh, &replies); + if (req_port == OFPP_ANY) { + error = OFPERR_OFPQOFC_BAD_QUEUE; + HMAP_FOR_EACH (port, hmap_node, &ofproto->ports) { + if (!handle_queue_get_config_request_for_port(port, req_queue, + &replies)) { + error = 0; + } + } + } else { + port = ofproto_get_port(ofproto, req_port); + error = (port + ? handle_queue_get_config_request_for_port(port, req_queue, + &replies) + : OFPERR_OFPQOFC_BAD_PORT); + } + if (!error) { + ofconn_send_replies(ofconn, &replies); + } else { + ofpbuf_list_delete(&replies); + } - return 0; + return error; } static enum ofperr -init_group(struct ofproto *ofproto, struct ofputil_group_mod *gm, +init_group(struct ofproto *ofproto, const struct ofputil_group_mod *gm, struct ofgroup **ofgroup) { enum ofperr error; @@ -6265,7 +6333,9 @@ init_group(struct ofproto *ofproto, struct ofputil_group_mod *gm, *CONST_CAST(long long int *, &((*ofgroup)->modified)) = now; ovs_refcount_init(&(*ofgroup)->ref_count); - list_move(&(*ofgroup)->buckets, &gm->buckets); + list_init(&(*ofgroup)->buckets); + ofputil_bucket_clone_list(&(*ofgroup)->buckets, &gm->buckets, NULL); + *CONST_CAST(uint32_t *, &(*ofgroup)->n_buckets) = list_size(&(*ofgroup)->buckets); @@ -6285,7 +6355,7 @@ init_group(struct ofproto *ofproto, struct ofputil_group_mod *gm, * 'ofproto''s group table. Returns 0 on success or an OpenFlow error code on * failure. */ static enum ofperr -add_group(struct ofproto *ofproto, struct ofputil_group_mod *gm) +add_group(struct ofproto *ofproto, const struct ofputil_group_mod *gm) { struct ofgroup *ofgroup; enum ofperr error; @@ -6359,22 +6429,24 @@ copy_buckets_for_insert_bucket(const struct ofgroup *ofgroup, ofputil_bucket_clone_list(&new_ofgroup->buckets, &ofgroup->buckets, NULL); - if (ofputil_bucket_check_duplicate_id(&ofgroup->buckets)) { - VLOG_WARN_RL(&rl, "Duplicate bucket id"); + if (ofputil_bucket_check_duplicate_id(&new_ofgroup->buckets)) { + VLOG_INFO_RL(&rl, "Duplicate bucket id"); return OFPERR_OFPGMFC_BUCKET_EXISTS; } /* Rearrange list according to command_bucket_id */ if (command_bucket_id == OFPG15_BUCKET_LAST) { - struct ofputil_bucket *new_first; - const struct ofputil_bucket *first; + if (!list_is_empty(&ofgroup->buckets)) { + struct ofputil_bucket *new_first; + const struct ofputil_bucket *first; - first = ofputil_bucket_list_front(&ofgroup->buckets); - new_first = ofputil_bucket_find(&new_ofgroup->buckets, - first->bucket_id); + first = ofputil_bucket_list_front(&ofgroup->buckets); + new_first = ofputil_bucket_find(&new_ofgroup->buckets, + first->bucket_id); - list_splice(new_ofgroup->buckets.next, &new_first->list_node, - &new_ofgroup->buckets); + list_splice(new_ofgroup->buckets.next, &new_first->list_node, + &new_ofgroup->buckets); + } } else if (command_bucket_id <= OFPG15_BUCKET_MAX && last) { struct ofputil_bucket *after; @@ -6431,7 +6503,7 @@ copy_buckets_for_remove_bucket(const struct ofgroup *ofgroup, * ofproto's ofgroup hash map. Thus, the group is never altered while users of * the xlate module hold a pointer to the group. */ static enum ofperr -modify_group(struct ofproto *ofproto, struct ofputil_group_mod *gm) +modify_group(struct ofproto *ofproto, const struct ofputil_group_mod *gm) { struct ofgroup *ofgroup, *new_ofgroup, *retiring; enum ofperr error; @@ -6505,6 +6577,7 @@ delete_group__(struct ofproto *ofproto, struct ofgroup *ofgroup) flow_mod_init(&ofm.fm, &match, 0, NULL, 0, OFPFC_DELETE); ofm.fm.delete_reason = OFPRR_GROUP_DELETE; ofm.fm.out_group = ofgroup->group_id; + ofm.fm.table_id = OFPTT_ALL; handle_flow_mod__(ofproto, &ofm, NULL); hmap_remove(&ofproto->groups, &ofgroup->hmap_node); @@ -6574,28 +6647,44 @@ handle_group_mod(struct ofconn *ofconn, const struct ofp_header *oh) switch (gm.command) { case OFPGC11_ADD: - return add_group(ofproto, &gm); + error = add_group(ofproto, &gm); + break; case OFPGC11_MODIFY: - return modify_group(ofproto, &gm); + error = modify_group(ofproto, &gm); + break; case OFPGC11_DELETE: delete_group(ofproto, gm.group_id); - return 0; + error = 0; + break; case OFPGC15_INSERT_BUCKET: - return modify_group(ofproto, &gm); + error = modify_group(ofproto, &gm); + break; case OFPGC15_REMOVE_BUCKET: - return modify_group(ofproto, &gm); + error = modify_group(ofproto, &gm); + break; default: if (gm.command > OFPGC11_DELETE) { - VLOG_WARN_RL(&rl, "%s: Invalid group_mod command type %d", + VLOG_INFO_RL(&rl, "%s: Invalid group_mod command type %d", ofproto->name, gm.command); } - return OFPERR_OFPGMFC_BAD_COMMAND; + error = OFPERR_OFPGMFC_BAD_COMMAND; + } + + if (!error) { + struct ofputil_requestforward rf; + rf.xid = oh->xid; + rf.reason = OFPRFR_GROUP_MOD; + rf.group_mod = &gm; + connmgr_send_requestforward(ofproto->connmgr, ofconn, &rf); } + ofputil_bucket_list_destroy(&gm.buckets); + + return error; } enum ofputil_table_miss @@ -6609,20 +6698,20 @@ ofproto_table_get_miss_config(const struct ofproto *ofproto, uint8_t table_id) static void table_mod__(struct oftable *oftable, - enum ofputil_table_miss miss, enum ofputil_table_eviction eviction) + const struct ofputil_table_mod *tm) { - if (miss == OFPUTIL_TABLE_MISS_DEFAULT) { + if (tm->miss == OFPUTIL_TABLE_MISS_DEFAULT) { /* This is how an OFPT_TABLE_MOD decodes if it doesn't specify any * table-miss configuration (because the protocol used doesn't have * such a concept), so there's nothing to do. */ } else { - atomic_store_relaxed(&oftable->miss_config, miss); + atomic_store_relaxed(&oftable->miss_config, tm->miss); } unsigned int new_eviction = oftable->eviction; - if (eviction == OFPUTIL_TABLE_EVICTION_ON) { + if (tm->eviction == OFPUTIL_TABLE_EVICTION_ON) { new_eviction |= EVICTION_OPENFLOW; - } else if (eviction == OFPUTIL_TABLE_EVICTION_OFF) { + } else if (tm->eviction == OFPUTIL_TABLE_EVICTION_OFF) { new_eviction &= ~EVICTION_OPENFLOW; } @@ -6633,6 +6722,16 @@ table_mod__(struct oftable *oftable, oftable->n_eviction_fields); ovs_mutex_unlock(&ofproto_mutex); } + + if (tm->vacancy != OFPUTIL_TABLE_VACANCY_DEFAULT) { + ovs_mutex_lock(&ofproto_mutex); + oftable->vacancy_enabled = (tm->vacancy == OFPUTIL_TABLE_VACANCY_ON + ? OFPTC14_VACANCY_EVENTS + : 0); + oftable->vacancy_down = tm->table_vacancy.vacancy_down; + oftable->vacancy_up = tm->table_vacancy.vacancy_up; + ovs_mutex_unlock(&ofproto_mutex); + } } static enum ofperr @@ -6656,7 +6755,7 @@ table_mod(struct ofproto *ofproto, const struct ofputil_table_mod *tm) struct oftable *oftable; OFPROTO_FOR_EACH_TABLE (oftable, ofproto) { if (!(oftable->flags & (OFTABLE_HIDDEN | OFTABLE_READONLY))) { - table_mod__(oftable, tm->miss, tm->eviction); + table_mod__(oftable, tm); } } } else { @@ -6664,7 +6763,7 @@ table_mod(struct ofproto *ofproto, const struct ofputil_table_mod *tm) if (oftable->flags & OFTABLE_READONLY) { return OFPERR_OFPTMFC_EPERM; } - table_mod__(oftable, tm->miss, tm->eviction); + table_mod__(oftable, tm); } return 0; @@ -6995,9 +7094,9 @@ handle_bundle_add(struct ofconn *ofconn, const struct ofp_header *oh) } static enum ofperr -handle_geneve_table_mod(struct ofconn *ofconn, const struct ofp_header *oh) +handle_tlv_table_mod(struct ofconn *ofconn, const struct ofp_header *oh) { - struct ofputil_geneve_table_mod gtm; + struct ofputil_tlv_table_mod ttm; enum ofperr error; error = reject_slave_controller(ofconn); @@ -7005,26 +7104,26 @@ handle_geneve_table_mod(struct ofconn *ofconn, const struct ofp_header *oh) return error; } - error = ofputil_decode_geneve_table_mod(oh, >m); + error = ofputil_decode_tlv_table_mod(oh, &ttm); if (error) { return error; } - error = tun_metadata_table_mod(>m); + error = tun_metadata_table_mod(&ttm); - ofputil_uninit_geneve_table(>m.mappings); + ofputil_uninit_tlv_table(&ttm.mappings); return error; } static enum ofperr -handle_geneve_table_request(struct ofconn *ofconn, const struct ofp_header *oh) +handle_tlv_table_request(struct ofconn *ofconn, const struct ofp_header *oh) { - struct ofputil_geneve_table_reply gtr; + struct ofputil_tlv_table_reply ttr; struct ofpbuf *b; - tun_metadata_table_request(>r); - b = ofputil_encode_geneve_table_reply(oh, >r); - ofputil_uninit_geneve_table(>r.mappings); + tun_metadata_table_request(&ttr); + b = ofputil_encode_tlv_table_reply(oh, &ttr); + ofputil_uninit_tlv_table(&ttr.mappings); ofconn_send_reply(ofconn, b); return 0; @@ -7174,11 +7273,11 @@ handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg) case OFPTYPE_BUNDLE_ADD_MESSAGE: return handle_bundle_add(ofconn, oh); - case OFPTYPE_NXT_GENEVE_TABLE_MOD: - return handle_geneve_table_mod(ofconn, oh); + case OFPTYPE_NXT_TLV_TABLE_MOD: + return handle_tlv_table_mod(ofconn, oh); - case OFPTYPE_NXT_GENEVE_TABLE_REQUEST: - return handle_geneve_table_request(ofconn, oh); + case OFPTYPE_NXT_TLV_TABLE_REQUEST: + return handle_tlv_table_request(ofconn, oh); case OFPTYPE_HELLO: case OFPTYPE_ERROR: @@ -7210,7 +7309,8 @@ handle_openflow__(struct ofconn *ofconn, const struct ofpbuf *msg) case OFPTYPE_TABLE_FEATURES_STATS_REPLY: case OFPTYPE_TABLE_DESC_REPLY: case OFPTYPE_ROLE_STATUS: - case OFPTYPE_NXT_GENEVE_TABLE_REPLY: + case OFPTYPE_REQUESTFORWARD: + case OFPTYPE_NXT_TLV_TABLE_REPLY: default: if (ofpmsg_is_stat_request(oh)) { return OFPERR_OFPBRC_BAD_STAT; @@ -7276,10 +7376,10 @@ pick_datapath_id(const struct ofproto *ofproto) port = ofproto_get_port(ofproto, OFPP_LOCAL); if (port) { - uint8_t ea[ETH_ADDR_LEN]; + struct eth_addr ea; int error; - error = netdev_get_etheraddr(port->netdev, ea); + error = netdev_get_etheraddr(port->netdev, &ea); if (!error) { return eth_addr_to_uint64(ea); } @@ -7293,8 +7393,8 @@ pick_datapath_id(const struct ofproto *ofproto) static uint64_t pick_fallback_dpid(void) { - uint8_t ea[ETH_ADDR_LEN]; - eth_addr_nicira_random(ea); + struct eth_addr ea; + eth_addr_nicira_random(&ea); return eth_addr_to_uint64(ea); }