X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;ds=sidebyside;f=lib%2Flearning-switch.c;h=22fa70d5d3b13dad3fd27a555151d167d1ba5ac1;hb=882c2399908b0f33f73651ccfc3aaf76a7858ce4;hp=7eb9e1c29d0bb09e25de87d585368333122cced2;hpb=fa37b408eac875cbc0d7adbbb3f7a004371172da;p=openvswitch diff --git a/lib/learning-switch.c b/lib/learning-switch.c index 7eb9e1c2..22fa70d5 100644 --- a/lib/learning-switch.c +++ b/lib/learning-switch.c @@ -26,6 +26,7 @@ #include "flow.h" #include "mac-learning.h" #include "ofpbuf.h" +#include "ofp-parse.h" #include "ofp-print.h" #include "ofp-util.h" #include "openflow/openflow.h" @@ -35,10 +36,10 @@ #include "stp.h" #include "timeval.h" #include "vconn.h" +#include "vlog.h" #include "xtoxll.h" -#define THIS_MODULE VLM_learning_switch -#include "vlog.h" +VLOG_DEFINE_THIS_MODULE(learning_switch) enum port_state { P_DISABLED = 1 << 0, @@ -58,8 +59,9 @@ struct lswitch { uint32_t capabilities; time_t last_features_request; struct mac_learning *ml; /* NULL to act as hub instead of switch. */ - bool exact_flows; /* Use exact-match flows? */ + uint32_t wildcards; /* Wildcards to apply to flows. */ bool action_normal; /* Use OFPP_NORMAL? */ + uint32_t queue; /* OpenFlow queue to use, or UINT32_MAX. */ /* Number of outgoing queued packets on the rconn. */ struct rconn_packet_counter *queued; @@ -83,6 +85,8 @@ 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); static void schedule_query(struct lswitch *, long long int delay); static bool may_learn(const struct lswitch *, uint16_t port_no); static bool may_recv(const struct lswitch *, uint16_t port_no, @@ -106,10 +110,17 @@ static packet_handler_func process_stats_reply; * 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. + * * '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) + bool exact_flows, int max_idle, bool action_normal, + FILE *default_flows) { struct lswitch *sw; size_t i; @@ -120,7 +131,17 @@ lswitch_create(struct rconn *rconn, bool learn_macs, sw->last_features_request = time_now() - 1; sw->ml = learn_macs ? mac_learning_create() : NULL; sw->action_normal = action_normal; - sw->exact_flows = exact_flows; + if (exact_flows) { + /* Exact match. */ + sw->wildcards = 0; + } else { + /* 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->queue = UINT32_MAX; sw->queued = rconn_packet_counter_create(); sw->next_query = LLONG_MIN; sw->last_query = LLONG_MIN; @@ -129,6 +150,9 @@ lswitch_create(struct rconn *rconn, bool learn_macs, sw->port_states[i] = P_DISABLED; } send_features_request(sw, rconn); + if (default_flows) { + send_default_flows(sw, rconn, default_flows); + } return sw; } @@ -143,6 +167,15 @@ lswitch_destroy(struct lswitch *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 @@ -339,6 +372,53 @@ 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) { @@ -383,118 +463,124 @@ process_switch_features(struct lswitch *sw, struct rconn *rconn, void *osf_) } } -static void -process_packet_in(struct lswitch *sw, struct rconn *rconn, void *opi_) +static uint16_t +lswitch_choose_destination(struct lswitch *sw, const flow_t *flow) { - struct ofp_packet_in *opi = opi_; - uint16_t in_port = ntohs(opi->in_port); - uint16_t out_port = OFPP_FLOOD; + uint16_t out_port; - size_t pkt_ofs, pkt_len; - struct ofpbuf pkt; - flow_t flow; - - /* 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; - flow_extract(&pkt, 0, in_port, &flow); - - if (may_learn(sw, in_port) && sw->ml) { - if (mac_learning_learn(sw->ml, flow.dl_src, 0, in_port, + /* Learn the source MAC. */ + if (may_learn(sw, flow->in_port) && sw->ml) { + if (mac_learning_learn(sw->ml, flow->dl_src, 0, flow->in_port, GRAT_ARP_LOCK_NONE)) { VLOG_DBG_RL(&rl, "%016llx: learned that "ETH_ADDR_FMT" is on " "port %"PRIu16, sw->datapath_id, - ETH_ADDR_ARGS(flow.dl_src), in_port); + ETH_ADDR_ARGS(flow->dl_src), flow->in_port); } } - if (eth_addr_is_reserved(flow.dl_src)) { - goto drop_it; + /* Drop frames for reserved multicast addresses. */ + if (eth_addr_is_reserved(flow->dl_dst)) { + return OFPP_NONE; } - if (!may_recv(sw, in_port, false)) { + if (!may_recv(sw, flow->in_port, false)) { /* STP prevents receiving anything on this port. */ - goto drop_it; + return OFPP_NONE; } + out_port = OFPP_FLOOD; if (sw->ml) { - int learned_port = mac_learning_lookup(sw->ml, flow.dl_dst, 0, NULL); + int learned_port = mac_learning_lookup(sw->ml, flow->dl_dst, 0, NULL); if (learned_port >= 0 && may_send(sw, learned_port)) { out_port = learned_port; + if (out_port == flow->in_port) { + /* Don't send a packet back out its input port. */ + return OFPP_NONE; + } } } - if (in_port == out_port) { - /* Don't send out packets on their input ports. */ - goto drop_it; - } else if (sw->max_idle >= 0 && (!sw->ml || out_port != OFPP_FLOOD)) { + /* Check if we need to use "NORMAL" action. */ + if (sw->action_normal && out_port != OFPP_FLOOD) { + return OFPP_NORMAL; + } + + return out_port; +} + +static void +process_packet_in(struct lswitch *sw, struct rconn *rconn, void *opi_) +{ + struct ofp_packet_in *opi = opi_; + uint16_t in_port = ntohs(opi->in_port); + uint16_t out_port; + + struct ofp_action_header actions[2]; + size_t actions_len; + + size_t pkt_ofs, pkt_len; + struct ofpbuf pkt; + flow_t flow; + + /* 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; + flow_extract(&pkt, 0, in_port, &flow); + + /* Choose output port. */ + out_port = lswitch_choose_destination(sw, &flow); + + /* Make actions. */ + memset(actions, 0, sizeof actions); + if (out_port == OFPP_NONE) { + actions_len = 0; + } else if (sw->queue == UINT32_MAX || out_port >= OFPP_MAX) { + struct ofp_action_output *oao = (struct ofp_action_output *) actions; + oao->type = htons(OFPAT_OUTPUT); + oao->len = htons(sizeof *oao); + oao->port = htons(out_port); + actions_len = sizeof *oao; + } else { + struct ofp_action_enqueue *oae = (struct ofp_action_enqueue *) actions; + oae->type = htons(OFPAT_ENQUEUE); + oae->len = htons(sizeof *oae); + oae->port = htons(out_port); + oae->queue_id = htonl(sw->queue); + actions_len = sizeof *oae; + } + assert(actions_len <= sizeof actions); + + /* Send the packet, and possibly the whole flow, to the output port. */ + if (sw->max_idle >= 0 && (!sw->ml || out_port != OFPP_FLOOD)) { struct ofpbuf *buffer; struct ofp_flow_mod *ofm; - uint32_t wildcards; - - /* Check if we need to wildcard the flows. */ - if (!sw->exact_flows) { - /* We can not wildcard all fields. - * We need in_port to detect moves. - * We need both SA and DA to do learning. */ - wildcards = (OFPFW_DL_TYPE | OFPFW_NW_SRC_MASK | OFPFW_NW_DST_MASK - | OFPFW_NW_PROTO | OFPFW_TP_SRC | OFPFW_TP_DST); - } else { - /* Exact match */ - wildcards = 0; - } - - /* Check if we need to use "NORMAL" action. */ - if (sw->action_normal && out_port != OFPP_FLOOD) { - out_port = OFPP_NORMAL; - } /* The output port is known, or we always flood everything, so add a * new flow. */ - buffer = make_add_simple_flow(&flow, ntohl(opi->buffer_id), - out_port, sw->max_idle); + buffer = make_add_flow(&flow, ntohl(opi->buffer_id), + sw->max_idle, actions_len); + ofpbuf_put(buffer, actions, actions_len); ofm = buffer->data; - ofm->match.wildcards = htonl(wildcards); + 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. */ - if (ntohl(opi->buffer_id) == UINT32_MAX) { + if (ntohl(opi->buffer_id) == UINT32_MAX && actions_len > 0) { queue_tx(sw, rconn, - make_unbuffered_packet_out(&pkt, in_port, out_port)); + make_packet_out(&pkt, UINT32_MAX, in_port, + actions, actions_len / sizeof *actions)); } } else { - struct ofpbuf *b; - - /* Check if we need to use "NORMAL" action. */ - if (sw->action_normal && out_port != OFPP_FLOOD) { - out_port = OFPP_NORMAL; - } - /* We don't know that MAC, or we don't set up flows. Send along the * packet without setting up a flow. */ - if (ntohl(opi->buffer_id) == UINT32_MAX) { - b = make_unbuffered_packet_out(&pkt, in_port, out_port); - } else { - b = make_buffered_packet_out(ntohl(opi->buffer_id), - in_port, out_port); + if (ntohl(opi->buffer_id) != UINT32_MAX || actions_len > 0) { + queue_tx(sw, rconn, + make_packet_out(&pkt, ntohl(opi->buffer_id), in_port, + actions, actions_len / sizeof *actions)); } - queue_tx(sw, rconn, b); - } - return; - -drop_it: - if (sw->max_idle >= 0) { - /* Set up a flow to drop packets. */ - queue_tx(sw, rconn, make_add_flow(&flow, ntohl(opi->buffer_id), - sw->max_idle, 0)); - } else { - /* Just drop the packet, since we don't set up flows at all. - * XXX we should send a packet_out with no actions if buffer_id != - * UINT32_MAX, to avoid clogging the kernel buffers. */ } - return; } static void