X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Flearning-switch.c;h=ca970540e0ff8e38f97e4e434b2a11cfaf4e2774;hb=9b45d7f5d;hp=bca479ef23cc33b92f7f2305be668063301a72a8;hpb=ba186119ca5f787486189c041d76d63dee629dc1;p=sliver-openvswitch.git diff --git a/lib/learning-switch.c b/lib/learning-switch.c index bca479ef2..ca970540e 100644 --- a/lib/learning-switch.c +++ b/lib/learning-switch.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010 Nicira Networks. + * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -23,7 +23,10 @@ #include #include +#include "byte-order.h" +#include "classifier.h" #include "flow.h" +#include "hmap.h" #include "mac-learning.h" #include "ofpbuf.h" #include "ofp-parse.h" @@ -31,14 +34,19 @@ #include "ofp-util.h" #include "openflow/openflow.h" #include "poll-loop.h" -#include "queue.h" #include "rconn.h" +#include "shash.h" #include "timeval.h" #include "vconn.h" #include "vlog.h" -#include "xtoxll.h" -VLOG_DEFINE_THIS_MODULE(learning_switch) +VLOG_DEFINE_THIS_MODULE(learning_switch); + +struct lswitch_port { + struct hmap_node hmap_node; /* Hash node for port number. */ + uint16_t port_no; /* OpenFlow port number, in host byte order. */ + uint32_t queue_id; /* OpenFlow queue number. */ +}; struct lswitch { /* If nonnegative, the switch sets up flows that expire after the given @@ -49,9 +57,13 @@ struct lswitch { unsigned long long int datapath_id; time_t last_features_request; struct mac_learning *ml; /* NULL to act as hub instead of switch. */ - uint32_t wildcards; /* Wildcards to apply to flows. */ + struct flow_wildcards wc; /* Wildcards to apply to flows. */ bool action_normal; /* Use OFPP_NORMAL? */ - uint32_t queue; /* OpenFlow queue to use, or UINT32_MAX. */ + + /* Queue distribution. */ + uint32_t default_queue; /* Default OpenFlow queue, or UINT32_MAX. */ + struct hmap queue_numbers; /* Map from port number to lswitch_port. */ + struct shash queue_names; /* Map from port name to lswitch_port. */ /* Number of outgoing queued packets on the rconn. */ struct rconn_packet_counter *queued; @@ -63,59 +75,66 @@ static struct vlog_rate_limit rl = VLOG_RATE_LIMIT_INIT(30, 300); static void queue_tx(struct lswitch *, struct rconn *, struct ofpbuf *); static void send_features_request(struct lswitch *, struct rconn *); -static void send_default_flows(struct lswitch *sw, struct rconn *rconn, - FILE *default_flows); -typedef void packet_handler_func(struct lswitch *, struct rconn *, void *); -static packet_handler_func process_switch_features; -static packet_handler_func process_packet_in; -static packet_handler_func process_echo_request; +static void process_switch_features(struct lswitch *, + struct ofp_switch_features *); +static void process_packet_in(struct lswitch *, struct rconn *, + const struct ofp_packet_in *); +static void process_echo_request(struct lswitch *, struct rconn *, + const struct ofp_header *); -/* Creates and returns a new learning switch. - * - * If 'learn_macs' is true, the new switch will learn the ports on which MAC - * addresses appear. Otherwise, the new switch will flood all packets. - * - * If 'max_idle' is nonnegative, the new switch will set up flows that expire - * after the given number of seconds (or never expire, if 'max_idle' is - * OFP_FLOW_PERMANENT). Otherwise, the new switch will process every packet. - * - * The caller may provide the file stream 'default_flows' that defines - * default flows that should be pushed when a switch connects. Each - * line is a flow entry in the format described for "add-flows" command - * in the Flow Syntax section of the ovs-ofct(8) man page. The caller - * is responsible for closing the stream. +/* Creates and returns a new learning switch whose configuration is given by + * 'cfg'. * * 'rconn' is used to send out an OpenFlow features request. */ struct lswitch * -lswitch_create(struct rconn *rconn, bool learn_macs, - bool exact_flows, int max_idle, bool action_normal, - FILE *default_flows) +lswitch_create(struct rconn *rconn, const struct lswitch_config *cfg) { struct lswitch *sw; sw = xzalloc(sizeof *sw); - sw->max_idle = max_idle; + sw->max_idle = cfg->max_idle; sw->datapath_id = 0; sw->last_features_request = time_now() - 1; - sw->ml = learn_macs ? mac_learning_create() : NULL; - sw->action_normal = action_normal; - if (exact_flows) { - /* Exact match. */ - sw->wildcards = 0; - } else { + sw->ml = cfg->mode == LSW_LEARN ? mac_learning_create() : NULL; + sw->action_normal = cfg->mode == LSW_NORMAL; + + flow_wildcards_init_exact(&sw->wc); + if (!cfg->exact_flows) { /* We cannot wildcard all fields. * We need in_port to detect moves. * We need both SA and DA to do learning. */ - sw->wildcards = (OFPFW_DL_TYPE | OFPFW_NW_SRC_MASK | OFPFW_NW_DST_MASK - | OFPFW_NW_PROTO | OFPFW_TP_SRC | OFPFW_TP_DST); + sw->wc.wildcards = (FWW_DL_TYPE | FWW_NW_PROTO + | FWW_TP_SRC | FWW_TP_DST); + sw->wc.nw_src_mask = htonl(0); + sw->wc.nw_dst_mask = htonl(0); + } + + sw->default_queue = cfg->default_queue; + hmap_init(&sw->queue_numbers); + shash_init(&sw->queue_names); + if (cfg->port_queues) { + struct shash_node *node; + + SHASH_FOR_EACH (node, cfg->port_queues) { + struct lswitch_port *port = xmalloc(sizeof *port); + hmap_node_nullify(&port->hmap_node); + port->queue_id = (uintptr_t) node->data; + shash_add(&sw->queue_names, node->name, port); + } } - sw->queue = UINT32_MAX; + sw->queued = rconn_packet_counter_create(); send_features_request(sw, rconn); - if (default_flows) { - send_default_flows(sw, rconn, default_flows); + + if (cfg->default_flows) { + const struct ofpbuf *b; + + LIST_FOR_EACH (b, list_node, cfg->default_flows) { + queue_tx(sw, rconn, ofpbuf_clone(b)); + } } + return sw; } @@ -124,21 +143,19 @@ void lswitch_destroy(struct lswitch *sw) { if (sw) { + struct lswitch_port *node, *next; + + HMAP_FOR_EACH_SAFE (node, next, hmap_node, &sw->queue_numbers) { + hmap_remove(&sw->queue_numbers, &node->hmap_node); + free(node); + } + shash_destroy(&sw->queue_names); mac_learning_destroy(sw->ml); rconn_packet_counter_destroy(sw->queued); free(sw); } } -/* Sets 'queue' as the OpenFlow queue used by packets and flows set up by 'sw'. - * Specify UINT32_MAX to avoid specifying a particular queue, which is also the - * default if this function is never called for 'sw'. */ -void -lswitch_set_queue(struct lswitch *sw, uint32_t queue) -{ - sw->queue = queue; -} - /* Takes care of necessary 'sw' activity, except for receiving packets (which * the caller must do). */ void @@ -165,38 +182,9 @@ void lswitch_process_packet(struct lswitch *sw, struct rconn *rconn, const struct ofpbuf *msg) { - struct processor { - uint8_t type; - size_t min_size; - packet_handler_func *handler; - }; - static const struct processor processors[] = { - { - OFPT_ECHO_REQUEST, - sizeof(struct ofp_header), - process_echo_request - }, - { - OFPT_FEATURES_REPLY, - sizeof(struct ofp_switch_features), - process_switch_features - }, - { - OFPT_PACKET_IN, - offsetof(struct ofp_packet_in, data), - process_packet_in - }, - { - OFPT_FLOW_REMOVED, - sizeof(struct ofp_flow_removed), - NULL - }, - }; - const size_t n_processors = ARRAY_SIZE(processors); - const struct processor *p; - struct ofp_header *oh; - - oh = msg->data; + const struct ofp_header *oh = msg->data; + const struct ofputil_msg_type *type; + if (sw->datapath_id == 0 && oh->type != OFPT_ECHO_REQUEST && oh->type != OFPT_FEATURES_REPLY) { @@ -204,27 +192,70 @@ lswitch_process_packet(struct lswitch *sw, struct rconn *rconn, return; } - for (p = processors; p < &processors[n_processors]; p++) { - if (oh->type == p->type) { - if (msg->size < p->min_size) { - VLOG_WARN_RL(&rl, "%016llx: %s: too short (%zu bytes) for " - "type %"PRIu8" (min %zu)", sw->datapath_id, - rconn_get_name(rconn), msg->size, oh->type, - p->min_size); - return; - } - if (p->handler) { - (p->handler)(sw, rconn, msg->data); - } - return; + ofputil_decode_msg_type(oh, &type); + switch (ofputil_msg_type_code(type)) { + case OFPUTIL_OFPT_ECHO_REQUEST: + process_echo_request(sw, rconn, msg->data); + break; + + case OFPUTIL_OFPT_FEATURES_REPLY: + process_switch_features(sw, msg->data); + break; + + case OFPUTIL_OFPT_PACKET_IN: + process_packet_in(sw, rconn, msg->data); + break; + + case OFPUTIL_OFPT_FLOW_REMOVED: + /* Nothing to do. */ + break; + + case OFPUTIL_INVALID: + case OFPUTIL_OFPT_HELLO: + case OFPUTIL_OFPT_ERROR: + case OFPUTIL_OFPT_ECHO_REPLY: + case OFPUTIL_OFPT_FEATURES_REQUEST: + case OFPUTIL_OFPT_GET_CONFIG_REQUEST: + case OFPUTIL_OFPT_GET_CONFIG_REPLY: + case OFPUTIL_OFPT_SET_CONFIG: + case OFPUTIL_OFPT_PORT_STATUS: + case OFPUTIL_OFPT_PACKET_OUT: + case OFPUTIL_OFPT_FLOW_MOD: + case OFPUTIL_OFPT_PORT_MOD: + case OFPUTIL_OFPT_BARRIER_REQUEST: + case OFPUTIL_OFPT_BARRIER_REPLY: + case OFPUTIL_OFPT_QUEUE_GET_CONFIG_REQUEST: + case OFPUTIL_OFPT_QUEUE_GET_CONFIG_REPLY: + case OFPUTIL_OFPST_DESC_REQUEST: + case OFPUTIL_OFPST_FLOW_REQUEST: + case OFPUTIL_OFPST_AGGREGATE_REQUEST: + case OFPUTIL_OFPST_TABLE_REQUEST: + case OFPUTIL_OFPST_PORT_REQUEST: + case OFPUTIL_OFPST_QUEUE_REQUEST: + case OFPUTIL_OFPST_DESC_REPLY: + case OFPUTIL_OFPST_FLOW_REPLY: + case OFPUTIL_OFPST_QUEUE_REPLY: + case OFPUTIL_OFPST_PORT_REPLY: + case OFPUTIL_OFPST_TABLE_REPLY: + case OFPUTIL_OFPST_AGGREGATE_REPLY: + case OFPUTIL_NXT_TUN_ID_FROM_COOKIE: + case OFPUTIL_NXT_ROLE_REQUEST: + case OFPUTIL_NXT_ROLE_REPLY: + case OFPUTIL_NXT_SET_FLOW_FORMAT: + case OFPUTIL_NXT_FLOW_MOD: + case OFPUTIL_NXT_FLOW_REMOVED: + case OFPUTIL_NXST_FLOW_REQUEST: + case OFPUTIL_NXST_AGGREGATE_REQUEST: + case OFPUTIL_NXST_FLOW_REPLY: + case OFPUTIL_NXST_AGGREGATE_REPLY: + default: + if (VLOG_IS_DBG_ENABLED()) { + char *s = ofp_to_string(msg->data, msg->size, 2); + VLOG_DBG_RL(&rl, "%016llx: OpenFlow packet ignored: %s", + sw->datapath_id, s); + free(s); } } - if (VLOG_IS_DBG_ENABLED()) { - char *p = ofp_to_string(msg->data, msg->size, 2); - VLOG_DBG_RL(&rl, "%016llx: OpenFlow packet ignored: %s", - sw->datapath_id, p); - free(p); - } } static void @@ -248,53 +279,6 @@ send_features_request(struct lswitch *sw, struct rconn *rconn) } } -static void -send_default_flows(struct lswitch *sw, struct rconn *rconn, - FILE *default_flows) -{ - char line[1024]; - - while (fgets(line, sizeof line, default_flows)) { - struct ofpbuf *b; - struct ofp_flow_mod *ofm; - uint16_t priority, idle_timeout, hard_timeout; - uint64_t cookie; - struct ofp_match match; - - char *comment; - - /* Delete comments. */ - comment = strchr(line, '#'); - if (comment) { - *comment = '\0'; - } - - /* Drop empty lines. */ - if (line[strspn(line, " \t\n")] == '\0') { - continue; - } - - /* Parse and send. str_to_flow() will expand and reallocate the data - * in 'buffer', so we can't keep pointers to across the str_to_flow() - * call. */ - make_openflow(sizeof *ofm, OFPT_FLOW_MOD, &b); - parse_ofp_str(line, &match, b, - NULL, NULL, &priority, &idle_timeout, &hard_timeout, - &cookie); - ofm = b->data; - ofm->match = match; - ofm->command = htons(OFPFC_ADD); - ofm->cookie = htonll(cookie); - ofm->idle_timeout = htons(idle_timeout); - ofm->hard_timeout = htons(hard_timeout); - ofm->buffer_id = htonl(UINT32_MAX); - ofm->priority = htons(priority); - - update_openflow_length(b); - queue_tx(sw, rconn, b); - } -} - static void queue_tx(struct lswitch *sw, struct rconn *rconn, struct ofpbuf *b) { @@ -312,16 +296,30 @@ queue_tx(struct lswitch *sw, struct rconn *rconn, struct ofpbuf *b) } static void -process_switch_features(struct lswitch *sw, struct rconn *rconn OVS_UNUSED, - void *osf_) +process_switch_features(struct lswitch *sw, struct ofp_switch_features *osf) { - struct ofp_switch_features *osf = osf_; + size_t n_ports; + size_t i; sw->datapath_id = ntohll(osf->datapath_id); + + n_ports = (ntohs(osf->header.length) - sizeof *osf) / sizeof *osf->ports; + for (i = 0; i < n_ports; i++) { + struct ofp_phy_port *opp = &osf->ports[i]; + struct lswitch_port *lp; + + opp->name[OFP_MAX_PORT_NAME_LEN - 1] = '\0'; + lp = shash_find_data(&sw->queue_names, opp->name); + if (lp && hmap_node_is_null(&lp->hmap_node)) { + lp->port_no = ntohs(opp->port_no); + hmap_insert(&sw->queue_numbers, &lp->hmap_node, + hash_int(lp->port_no, 0)); + } + } } static uint16_t -lswitch_choose_destination(struct lswitch *sw, const flow_t *flow) +lswitch_choose_destination(struct lswitch *sw, const struct flow *flow) { uint16_t out_port; @@ -360,11 +358,27 @@ lswitch_choose_destination(struct lswitch *sw, const flow_t *flow) return out_port; } +static uint32_t +get_queue_id(const struct lswitch *sw, uint16_t in_port) +{ + const struct lswitch_port *port; + + HMAP_FOR_EACH_WITH_HASH (port, hmap_node, hash_int(in_port, 0), + &sw->queue_numbers) { + if (port->port_no == in_port) { + return port->queue_id; + } + } + + return sw->default_queue; +} + static void -process_packet_in(struct lswitch *sw, struct rconn *rconn, void *opi_) +process_packet_in(struct lswitch *sw, struct rconn *rconn, + const struct ofp_packet_in *opi) { - struct ofp_packet_in *opi = opi_; uint16_t in_port = ntohs(opi->in_port); + uint32_t queue_id; uint16_t out_port; struct ofp_action_header actions[2]; @@ -372,22 +386,29 @@ process_packet_in(struct lswitch *sw, struct rconn *rconn, void *opi_) size_t pkt_ofs, pkt_len; struct ofpbuf pkt; - flow_t flow; + struct flow flow; + + /* Ignore packets sent via output to OFPP_CONTROLLER. This library never + * uses such an action. You never know what experiments might be going on, + * though, and it seems best not to interfere with them. */ + if (opi->reason != OFPR_NO_MATCH) { + return; + } /* Extract flow data from 'opi' into 'flow'. */ pkt_ofs = offsetof(struct ofp_packet_in, data); pkt_len = ntohs(opi->header.length) - pkt_ofs; - pkt.data = opi->data; - pkt.size = pkt_len; + ofpbuf_use_const(&pkt, opi->data, pkt_len); flow_extract(&pkt, 0, in_port, &flow); /* Choose output port. */ out_port = lswitch_choose_destination(sw, &flow); /* Make actions. */ + queue_id = get_queue_id(sw, in_port); if (out_port == OFPP_NONE) { actions_len = 0; - } else if (sw->queue == UINT32_MAX || out_port >= OFPP_MAX) { + } else if (queue_id == UINT32_MAX || out_port >= OFPP_MAX) { struct ofp_action_output oao; memset(&oao, 0, sizeof oao); @@ -404,7 +425,7 @@ process_packet_in(struct lswitch *sw, struct rconn *rconn, void *opi_) oae.type = htons(OFPAT_ENQUEUE); oae.len = htons(sizeof oae); oae.port = htons(out_port); - oae.queue_id = htonl(sw->queue); + oae.queue_id = htonl(queue_id); memcpy(actions, &oae, sizeof oae); actions_len = sizeof oae; @@ -415,14 +436,15 @@ process_packet_in(struct lswitch *sw, struct rconn *rconn, void *opi_) if (sw->max_idle >= 0 && (!sw->ml || out_port != OFPP_FLOOD)) { struct ofpbuf *buffer; struct ofp_flow_mod *ofm; + struct cls_rule rule; /* The output port is known, or we always flood everything, so add a * new flow. */ - buffer = make_add_flow(&flow, ntohl(opi->buffer_id), + cls_rule_init(&flow, &sw->wc, 0, &rule); + buffer = make_add_flow(&rule, ntohl(opi->buffer_id), sw->max_idle, actions_len); ofpbuf_put(buffer, actions, actions_len); ofm = buffer->data; - ofm->match.wildcards = htonl(sw->wildcards); queue_tx(sw, rconn, buffer); /* If the switch didn't buffer the packet, we need to send a copy. */ @@ -443,8 +465,8 @@ process_packet_in(struct lswitch *sw, struct rconn *rconn, void *opi_) } static void -process_echo_request(struct lswitch *sw, struct rconn *rconn, void *rq_) +process_echo_request(struct lswitch *sw, struct rconn *rconn, + const struct ofp_header *rq) { - struct ofp_header *rq = rq_; queue_tx(sw, rconn, make_echo_reply(rq)); }