X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=ofproto%2Fofproto.c;h=00c9c6964a222ebdae1d3851d862e3e9371743a7;hb=abaad8cf1b5089e17a4af0ab1ff644bfcf63cad9;hp=f80439c8c279bac7be8d1a1ea9fc81adc35d0958;hpb=ca069229880ba47ba100b62ed34c0c226355b0c6;p=openvswitch diff --git a/ofproto/ofproto.c b/ofproto/ofproto.c index f80439c8..00c9c696 100644 --- a/ofproto/ofproto.c +++ b/ofproto/ofproto.c @@ -83,6 +83,8 @@ static int xlate_actions(const union ofp_action *in, size_t n_in, struct rule { struct cls_rule cr; + uint64_t flow_cookie; /* Controller-issued identifier. + (Kept in network-byte order.) */ uint16_t idle_timeout; /* In seconds from time of last use. */ uint16_t hard_timeout; /* In seconds from time of creation. */ bool send_flow_removed; /* Send a flow removed message? */ @@ -144,7 +146,7 @@ rule_is_hidden(const struct rule *rule) static struct rule *rule_create(struct ofproto *, struct rule *super, const union ofp_action *, size_t n_actions, uint16_t idle_timeout, uint16_t hard_timeout, - bool send_flow_removed); + uint64_t flow_cookie, bool send_flow_removed); static void rule_free(struct rule *); static void rule_destroy(struct ofproto *, struct rule *); static struct rule *rule_from_cls_rule(const struct cls_rule *); @@ -189,6 +191,7 @@ struct ofproto { char *hardware; /* Hardware. */ char *software; /* Software version. */ char *serial; /* Serial number. */ + char *dp_desc; /* Datapath description. */ /* Datapath. */ struct dpif *dpif; @@ -300,6 +303,7 @@ ofproto_create(const char *datapath, const char *datapath_type, p->hardware = xstrdup("Reference Implementation"); p->software = xstrdup(VERSION BUILDNR); p->serial = xstrdup("None"); + p->dp_desc = xstrdup("None"); /* Initialize datapath. */ p->dpif = dpif; @@ -350,7 +354,7 @@ ofproto_create(const char *datapath, const char *datapath_type, /* Pick final datapath ID. */ p->datapath_id = pick_datapath_id(p); - VLOG_INFO("using datapath ID %012"PRIx64, p->datapath_id); + VLOG_INFO("using datapath ID %016"PRIx64, p->datapath_id); *ofprotop = p; return 0; @@ -362,7 +366,7 @@ ofproto_set_datapath_id(struct ofproto *p, uint64_t datapath_id) uint64_t old_dpid = p->datapath_id; p->datapath_id = datapath_id ? datapath_id : pick_datapath_id(p); if (p->datapath_id != old_dpid) { - VLOG_INFO("datapath ID changed to %012"PRIx64, p->datapath_id); + VLOG_INFO("datapath ID changed to %016"PRIx64, p->datapath_id); rconn_reconnect(p->controller->rconn); } } @@ -387,7 +391,8 @@ ofproto_set_max_backoff(struct ofproto *p, int max_backoff) void ofproto_set_desc(struct ofproto *p, const char *manufacturer, const char *hardware, - const char *software, const char *serial) + const char *software, const char *serial, + const char *dp_desc) { if (manufacturer) { free(p->manufacturer); @@ -405,6 +410,10 @@ ofproto_set_desc(struct ofproto *p, free(p->serial); p->serial = xstrdup(serial); } + if (dp_desc) { + free(p->dp_desc); + p->dp_desc = xstrdup(dp_desc); + } } int @@ -985,7 +994,7 @@ ofproto_add_flow(struct ofproto *p, struct rule *rule; rule = rule_create(p, NULL, actions, n_actions, idle_timeout >= 0 ? idle_timeout : 5 /* XXX */, - 0, false); + 0, 0, false); cls_rule_from_flow(&rule->cr, flow, wildcards, priority); rule_insert(p, rule, NULL, 0); } @@ -1397,11 +1406,12 @@ static struct rule * rule_create(struct ofproto *ofproto, struct rule *super, const union ofp_action *actions, size_t n_actions, uint16_t idle_timeout, uint16_t hard_timeout, - bool send_flow_removed) + uint64_t flow_cookie, bool send_flow_removed) { struct rule *rule = xzalloc(sizeof *rule); rule->idle_timeout = idle_timeout; rule->hard_timeout = hard_timeout; + rule->flow_cookie = flow_cookie; rule->used = rule->created = time_msec(); rule->send_flow_removed = send_flow_removed; rule->super = super; @@ -1564,7 +1574,7 @@ rule_create_subrule(struct ofproto *ofproto, struct rule *rule, { struct rule *subrule = rule_create(ofproto, rule, NULL, 0, rule->idle_timeout, rule->hard_timeout, - false); + 0, false); COVERAGE_INC(ofproto_subrule_create); cls_rule_from_flow(&subrule->cr, flow, 0, (rule->cr.priority <= UINT16_MAX ? UINT16_MAX @@ -1850,7 +1860,8 @@ handle_features_request(struct ofproto *p, struct ofconn *ofconn, osf->n_buffers = htonl(pktbuf_capacity()); osf->n_tables = 2; osf->capabilities = htonl(OFPC_FLOW_STATS | OFPC_TABLE_STATS | - OFPC_PORT_STATS | OFPC_MULTI_PHY_TX); + OFPC_PORT_STATS | OFPC_MULTI_PHY_TX | + OFPC_ARP_MATCH_IP); osf->actions = htonl((1u << OFPAT_OUTPUT) | (1u << OFPAT_SET_VLAN_VID) | (1u << OFPAT_SET_VLAN_PCP) | @@ -2385,6 +2396,7 @@ handle_desc_stats_request(struct ofproto *p, struct ofconn *ofconn, strncpy(ods->hw_desc, p->hardware, sizeof ods->hw_desc); strncpy(ods->sw_desc, p->software, sizeof ods->sw_desc); strncpy(ods->serial_num, p->serial, sizeof ods->serial_num); + strncpy(ods->dp_desc, p->dp_desc, sizeof ods->dp_desc); queue_tx(msg, ofconn, ofconn->reply_counter); return 0; @@ -2446,39 +2458,62 @@ handle_table_stats_request(struct ofproto *p, struct ofconn *ofconn, return 0; } +static void +append_port_stat(struct ofport *port, uint16_t port_no, struct ofconn *ofconn, + struct ofpbuf *msg) +{ + struct netdev_stats stats; + struct ofp_port_stats *ops; + + /* Intentionally ignore return value, since errors will set + * 'stats' to all-1s, which is correct for OpenFlow, and + * netdev_get_stats() will log errors. */ + netdev_get_stats(port->netdev, &stats); + + ops = append_stats_reply(sizeof *ops, ofconn, &msg); + ops->port_no = htons(odp_port_to_ofp_port(port_no)); + memset(ops->pad, 0, sizeof ops->pad); + ops->rx_packets = htonll(stats.rx_packets); + ops->tx_packets = htonll(stats.tx_packets); + ops->rx_bytes = htonll(stats.rx_bytes); + ops->tx_bytes = htonll(stats.tx_bytes); + ops->rx_dropped = htonll(stats.rx_dropped); + ops->tx_dropped = htonll(stats.tx_dropped); + ops->rx_errors = htonll(stats.rx_errors); + ops->tx_errors = htonll(stats.tx_errors); + ops->rx_frame_err = htonll(stats.rx_frame_errors); + ops->rx_over_err = htonll(stats.rx_over_errors); + ops->rx_crc_err = htonll(stats.rx_crc_errors); + ops->collisions = htonll(stats.collisions); +} + static int handle_port_stats_request(struct ofproto *p, struct ofconn *ofconn, - struct ofp_stats_request *request) + struct ofp_stats_request *osr, + size_t arg_size) { + struct ofp_port_stats_request *psr; struct ofp_port_stats *ops; struct ofpbuf *msg; struct ofport *port; unsigned int port_no; - msg = start_stats_reply(request, sizeof *ops * 16); - PORT_ARRAY_FOR_EACH (port, &p->ports, port_no) { - struct netdev_stats stats; - - /* Intentionally ignore return value, since errors will set 'stats' to - * all-1s, which is correct for OpenFlow, and netdev_get_stats() will - * log errors. */ - netdev_get_stats(port->netdev, &stats); - - ops = append_stats_reply(sizeof *ops, ofconn, &msg); - ops->port_no = htons(odp_port_to_ofp_port(port_no)); - memset(ops->pad, 0, sizeof ops->pad); - ops->rx_packets = htonll(stats.rx_packets); - ops->tx_packets = htonll(stats.tx_packets); - ops->rx_bytes = htonll(stats.rx_bytes); - ops->tx_bytes = htonll(stats.tx_bytes); - ops->rx_dropped = htonll(stats.rx_dropped); - ops->tx_dropped = htonll(stats.tx_dropped); - ops->rx_errors = htonll(stats.rx_errors); - ops->tx_errors = htonll(stats.tx_errors); - ops->rx_frame_err = htonll(stats.rx_frame_errors); - ops->rx_over_err = htonll(stats.rx_over_errors); - ops->rx_crc_err = htonll(stats.rx_crc_errors); - ops->collisions = htonll(stats.collisions); + if (arg_size != sizeof *psr) { + return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_LEN); + } + psr = (struct ofp_port_stats_request *) osr->body; + + msg = start_stats_reply(osr, sizeof *ops * 16); + if (psr->port_no != htons(OFPP_NONE)) { + port = port_array_get(&p->ports, + ofp_port_to_odp_port(ntohs(psr->port_no))); + if (port) { + append_port_stat(port, ntohs(psr->port_no), ofconn, msg); + } + } else { + PORT_ARRAY_FOR_EACH (port, &p->ports, port_no) { + append_port_stat(port, port_no, ofconn, msg); + } } queue_tx(msg, ofconn, ofconn->reply_counter); @@ -2541,6 +2576,9 @@ flow_stats_cb(struct cls_rule *rule_, void *cbdata_) struct ofp_flow_stats *ofs; uint64_t packet_count, byte_count; size_t act_len, len; + long long int tdiff = time_msec() - rule->created; + uint32_t sec = tdiff / 1000; + uint32_t msec = tdiff - (sec * 1000); if (rule_is_hidden(rule) || !rule_has_out_port(rule, cbdata->out_port)) { return; @@ -2556,11 +2594,13 @@ flow_stats_cb(struct cls_rule *rule_, void *cbdata_) ofs->table_id = rule->cr.wc.wildcards ? TABLEID_CLASSIFIER : TABLEID_HASH; ofs->pad = 0; flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, &ofs->match); - ofs->duration = htonl((time_msec() - rule->created) / 1000); + ofs->duration_sec = htonl(sec); + ofs->duration_nsec = htonl(msec * 1000000); + ofs->cookie = rule->flow_cookie; ofs->priority = htons(rule->cr.priority); ofs->idle_timeout = htons(rule->idle_timeout); ofs->hard_timeout = htons(rule->hard_timeout); - ofs->pad2 = 0; + memset(ofs->pad2, 0, sizeof ofs->pad2); ofs->packet_count = htonll(packet_count); ofs->byte_count = htonll(byte_count); memcpy(ofs->actions, rule->actions, act_len); @@ -2623,7 +2663,7 @@ flow_stats_ds_cb(struct cls_rule *rule_, void *cbdata_) } query_stats(cbdata->ofproto, rule, &packet_count, &byte_count); - flow_to_ovs_match(&rule->cr.flow, rule->cr.wc.wildcards, &match); + flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, &match); ds_put_format(results, "duration=%llds, ", (time_msec() - rule->created) / 1000); @@ -2746,7 +2786,7 @@ handle_stats_request(struct ofproto *p, struct ofconn *ofconn, return handle_table_stats_request(p, ofconn, osr); case OFPST_PORT: - return handle_port_stats_request(p, ofconn, osr); + return handle_port_stats_request(p, ofconn, osr, arg_size); case OFPST_VENDOR: return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_VENDOR); @@ -2811,7 +2851,7 @@ add_flow(struct ofproto *p, struct ofconn *ofconn, rule = rule_create(p, NULL, (const union ofp_action *) ofm->actions, n_actions, ntohs(ofm->idle_timeout), - ntohs(ofm->hard_timeout), + ntohs(ofm->hard_timeout), ofm->cookie, ofm->flags & htons(OFPFF_SEND_FLOW_REM)); cls_rule_from_match(&rule->cr, &ofm->match, ntohs(ofm->priority)); @@ -2853,6 +2893,7 @@ modify_flow(struct ofproto *p, const struct ofp_flow_mod *ofm, free(rule->actions); rule->actions = xmemdup(ofm->actions, actions_len); rule->n_actions = n_actions; + rule->flow_cookie = ofm->cookie; if (rule->cr.wc.wildcards) { COVERAGE_INC(ofproto_mod_wc_flow); @@ -3013,6 +3054,19 @@ handle_vendor(struct ofproto *p, struct ofconn *ofconn, void *msg) return ofp_mkerr(OFPET_BAD_REQUEST, OFPBRC_BAD_SUBTYPE); } +static int +handle_barrier_request(struct ofconn *ofconn, struct ofp_header *oh) +{ + struct ofp_header *ob; + struct ofpbuf *buf; + + /* Currently, everything executes synchronously, so we can just + * immediately send the barrier reply. */ + ob = make_openflow_xid(sizeof *ob, OFPT_BARRIER_REPLY, oh->xid, &buf); + queue_tx(buf, ofconn, ofconn->reply_counter); + return 0; +} + static void handle_openflow(struct ofconn *ofconn, struct ofproto *p, struct ofpbuf *ofp_msg) @@ -3062,6 +3116,10 @@ handle_openflow(struct ofconn *ofconn, struct ofproto *p, error = handle_vendor(p, ofconn, ofp_msg->data); break; + case OFPT_BARRIER_REQUEST: + error = handle_barrier_request(ofconn, oh); + break; + default: if (VLOG_IS_WARN_ENABLED()) { char *s = ofp_to_string(oh, ntohs(oh->length), 2); @@ -3232,12 +3290,17 @@ compose_flow_removed(const struct rule *rule, long long int now, uint8_t reason) { struct ofp_flow_removed *ofr; struct ofpbuf *buf; + long long int tdiff = time_msec() - rule->created; + uint32_t sec = tdiff / 1000; + uint32_t msec = tdiff - (sec * 1000); ofr = make_openflow(sizeof *ofr, OFPT_FLOW_REMOVED, &buf); flow_to_match(&rule->cr.flow, rule->cr.wc.wildcards, &ofr->match); + ofr->cookie = rule->flow_cookie; ofr->priority = htons(rule->cr.priority); ofr->reason = reason; - ofr->duration = htonl((now - rule->created) / 1000); + ofr->duration_sec = htonl(sec); + ofr->duration_nsec = htonl(msec * 1000000); ofr->idle_timeout = htons(rule->idle_timeout); ofr->packet_count = htonll(rule->packet_count); ofr->byte_count = htonll(rule->byte_count);