X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=datapath%2Fforward.c;h=b3c2f7af4f27d2168254b1f4713d5b4a554f56a8;hb=6b617bac12401ffad57c47ec9815860b87fa4152;hp=5d57fb1631511df6562e474cb6d15d00ff4640f5;hpb=39136b0fb9a89fa1489ef30eccfef115e584a74d;p=sliver-openvswitch.git diff --git a/datapath/forward.c b/datapath/forward.c index 5d57fb163..b3c2f7af4 100644 --- a/datapath/forward.c +++ b/datapath/forward.c @@ -8,22 +8,18 @@ #include #include #include -#include -#include -#include -#include -#include #include #include -#include #include "forward.h" #include "datapath.h" +#include "openflow/nicira-ext.h" +#include "dp_act.h" +#include "nx_msg.h" #include "chain.h" #include "flow.h" /* FIXME: do we need to use GFP_ATOMIC everywhere here? */ -static int make_writable(struct sk_buff **); static struct sk_buff *retrieve_skb(uint32_t id); static void discard_skb(uint32_t id); @@ -47,18 +43,19 @@ int run_flow_through_tables(struct sw_chain *chain, struct sk_buff *skb, kfree_skb(skb); return 0; } - if (p && p->flags & (OFPPFL_NO_RECV | OFPPFL_NO_RECV_STP) && - p->flags & (compare_ether_addr(key.dl_dst, stp_eth_addr) - ? OFPPFL_NO_RECV : OFPPFL_NO_RECV_STP)) { + if (p && p->config & (OFPPC_NO_RECV | OFPPC_NO_RECV_STP) && + p->config & (compare_ether_addr(key.dl_dst, stp_eth_addr) + ? OFPPC_NO_RECV : OFPPC_NO_RECV_STP)) { kfree_skb(skb); return 0; } flow = chain_lookup(chain, &key); if (likely(flow != NULL)) { + struct sw_flow_actions *sf_acts = rcu_dereference(flow->sf_acts); flow_used(flow, skb); execute_actions(chain->dp, skb, &key, - flow->actions, flow->n_actions, 0); + sf_acts->actions, sf_acts->actions_len, 0); return 0; } else { return -ESRCH; @@ -77,227 +74,11 @@ void fwd_port_input(struct sw_chain *chain, struct sk_buff *skb, OFPR_NO_MATCH); } -static int do_output(struct datapath *dp, struct sk_buff *skb, size_t max_len, - int out_port, int ignore_no_fwd) -{ - if (!skb) - return -ENOMEM; - return (likely(out_port != OFPP_CONTROLLER) - ? dp_output_port(dp, skb, out_port, ignore_no_fwd) - : dp_output_control(dp, skb, fwd_save_skb(skb), - max_len, OFPR_ACTION)); -} - -void execute_actions(struct datapath *dp, struct sk_buff *skb, - const struct sw_flow_key *key, - const struct ofp_action *actions, int n_actions, - int ignore_no_fwd) -{ - /* Every output action needs a separate clone of 'skb', but the common - * case is just a single output action, so that doing a clone and - * then freeing the original skbuff is wasteful. So the following code - * is slightly obscure just to avoid that. */ - int prev_port; - size_t max_len=0; /* Initialze to make compiler happy */ - uint16_t eth_proto; - int i; - - prev_port = -1; - eth_proto = ntohs(key->dl_type); - - for (i = 0; i < n_actions; i++) { - const struct ofp_action *a = &actions[i]; - - if (prev_port != -1) { - do_output(dp, skb_clone(skb, GFP_ATOMIC), - max_len, prev_port, ignore_no_fwd); - prev_port = -1; - } - - if (likely(a->type == htons(OFPAT_OUTPUT))) { - prev_port = ntohs(a->arg.output.port); - max_len = ntohs(a->arg.output.max_len); - } else { - if (!make_writable(&skb)) { - if (net_ratelimit()) - printk("make_writable failed\n"); - break; - } - skb = execute_setter(skb, eth_proto, key, a); - if (!skb) { - if (net_ratelimit()) - printk("execute_setter lost skb\n"); - return; - } - } - } - if (prev_port != -1) - do_output(dp, skb, max_len, prev_port, ignore_no_fwd); - else - kfree_skb(skb); -} - -/* Updates 'sum', which is a field in 'skb''s data, given that a 4-byte field - * covered by the sum has been changed from 'from' to 'to'. If set, - * 'pseudohdr' indicates that the field is in the TCP or UDP pseudo-header. - * Based on nf_proto_csum_replace4. */ -static void update_csum(__sum16 *sum, struct sk_buff *skb, - __be32 from, __be32 to, int pseudohdr) -{ - __be32 diff[] = { ~from, to }; - if (skb->ip_summed != CHECKSUM_PARTIAL) { - *sum = csum_fold(csum_partial((char *)diff, sizeof(diff), - ~csum_unfold(*sum))); - if (skb->ip_summed == CHECKSUM_COMPLETE && pseudohdr) - skb->csum = ~csum_partial((char *)diff, sizeof(diff), - ~skb->csum); - } else if (pseudohdr) - *sum = ~csum_fold(csum_partial((char *)diff, sizeof(diff), - csum_unfold(*sum))); -} - -static void modify_nh(struct sk_buff *skb, uint16_t eth_proto, - uint8_t nw_proto, const struct ofp_action *a) -{ - if (eth_proto == ETH_P_IP) { - struct iphdr *nh = ip_hdr(skb); - uint32_t new, *field; - - new = a->arg.nw_addr; - - if (a->type == htons(OFPAT_SET_NW_SRC)) - field = &nh->saddr; - else - field = &nh->daddr; - - if (nw_proto == IPPROTO_TCP) { - struct tcphdr *th = tcp_hdr(skb); - update_csum(&th->check, skb, *field, new, 1); - } else if (nw_proto == IPPROTO_UDP) { - struct udphdr *th = udp_hdr(skb); - update_csum(&th->check, skb, *field, new, 1); - } - update_csum(&nh->check, skb, *field, new, 0); - *field = new; - } -} - -static void modify_th(struct sk_buff *skb, uint16_t eth_proto, - uint8_t nw_proto, const struct ofp_action *a) -{ - if (eth_proto == ETH_P_IP) { - uint16_t new, *field; - - new = a->arg.tp; - - if (nw_proto == IPPROTO_TCP) { - struct tcphdr *th = tcp_hdr(skb); - - if (a->type == htons(OFPAT_SET_TP_SRC)) - field = &th->source; - else - field = &th->dest; - - update_csum(&th->check, skb, *field, new, 1); - *field = new; - } else if (nw_proto == IPPROTO_UDP) { - struct udphdr *th = udp_hdr(skb); - - if (a->type == htons(OFPAT_SET_TP_SRC)) - field = &th->source; - else - field = &th->dest; - - update_csum(&th->check, skb, *field, new, 1); - *field = new; - } - } -} - -static struct sk_buff *vlan_pull_tag(struct sk_buff *skb) -{ - struct vlan_ethhdr *vh = vlan_eth_hdr(skb); - struct ethhdr *eh; - - - /* Verify we were given a vlan packet */ - if (vh->h_vlan_proto != htons(ETH_P_8021Q)) - return skb; - - memmove(skb->data + VLAN_HLEN, skb->data, 2 * VLAN_ETH_ALEN); - - eh = (struct ethhdr *)skb_pull(skb, VLAN_HLEN); - - skb->protocol = eh->h_proto; - skb->mac_header += VLAN_HLEN; - - return skb; -} - -static struct sk_buff *modify_vlan(struct sk_buff *skb, - const struct sw_flow_key *key, const struct ofp_action *a) -{ - uint16_t new_id = ntohs(a->arg.vlan_id); - - if (new_id != OFP_VLAN_NONE) { - if (key->dl_vlan != htons(OFP_VLAN_NONE)) { - /* Modify vlan id, but maintain other TCI values */ - struct vlan_ethhdr *vh = vlan_eth_hdr(skb); - vh->h_vlan_TCI = (vh->h_vlan_TCI - & ~(htons(VLAN_VID_MASK))) | a->arg.vlan_id; - } else { - /* Add vlan header */ - - /* xxx The vlan_put_tag function, doesn't seem to work - * xxx reliably when it attempts to use the hardware-accelerated - * xxx version. We'll directly use the software version - * xxx until the problem can be diagnosed. - */ - skb = __vlan_put_tag(skb, new_id); - } - } else { - /* Remove an existing vlan header if it exists */ - vlan_pull_tag(skb); - } - - return skb; -} - -struct sk_buff *execute_setter(struct sk_buff *skb, uint16_t eth_proto, - const struct sw_flow_key *key, const struct ofp_action *a) +static int +recv_hello(struct sw_chain *chain, const struct sender *sender, + const void *msg) { - switch (ntohs(a->type)) { - case OFPAT_SET_DL_VLAN: - skb = modify_vlan(skb, key, a); - break; - - case OFPAT_SET_DL_SRC: { - struct ethhdr *eh = eth_hdr(skb); - memcpy(eh->h_source, a->arg.dl_addr, sizeof eh->h_source); - break; - } - case OFPAT_SET_DL_DST: { - struct ethhdr *eh = eth_hdr(skb); - memcpy(eh->h_dest, a->arg.dl_addr, sizeof eh->h_dest); - break; - } - - case OFPAT_SET_NW_SRC: - case OFPAT_SET_NW_DST: - modify_nh(skb, eth_proto, key->nw_proto, a); - break; - - case OFPAT_SET_TP_SRC: - case OFPAT_SET_TP_DST: - modify_th(skb, eth_proto, key->nw_proto, a); - break; - - default: - if (net_ratelimit()) - printk("execute_setter: unknown action: %d\n", ntohs(a->type)); - } - - return skb; + return dp_send_hello(chain->dp, sender, msg); } static int @@ -341,18 +122,18 @@ recv_packet_out(struct sw_chain *chain, const struct sender *sender, struct sk_buff *skb; struct vlan_ethhdr *mac; int nh_ofs; + uint16_t v_code; struct sw_flow_key key; - int n_actions = ntohs(opo->n_actions); - int act_len = n_actions * sizeof opo->actions[0]; + size_t actions_len = ntohs(opo->actions_len); - if (act_len > (ntohs(opo->header.length) - sizeof *opo)) { + if (actions_len > (ntohs(opo->header.length) - sizeof *opo)) { if (net_ratelimit()) printk("message too short for number of actions\n"); return -EINVAL; } if (ntohl(opo->buffer_id) == (uint32_t) -1) { - int data_len = ntohs(opo->header.length) - sizeof *opo - act_len; + int data_len = ntohs(opo->header.length) - sizeof *opo - actions_len; /* FIXME: there is likely a way to reuse the data in msg. */ skb = alloc_skb(data_len, GFP_ATOMIC); @@ -362,7 +143,8 @@ recv_packet_out(struct sw_chain *chain, const struct sender *sender, /* FIXME? We don't reserve NET_IP_ALIGN or NET_SKB_PAD since * we're just transmitting this raw without examining anything * at those layers. */ - memcpy(skb_put(skb, data_len), &opo->actions[n_actions], data_len); + memcpy(skb_put(skb, data_len), (uint8_t *)opo->actions + actions_len, + data_len); skb_set_mac_header(skb, 0); mac = vlan_eth_hdr(skb); @@ -380,9 +162,21 @@ recv_packet_out(struct sw_chain *chain, const struct sender *sender, dp_set_origin(chain->dp, ntohs(opo->in_port), skb); flow_extract(skb, ntohs(opo->in_port), &key); - execute_actions(chain->dp, skb, &key, opo->actions, n_actions, 1); + + v_code = validate_actions(chain->dp, &key, opo->actions, actions_len); + if (v_code != ACT_VALIDATION_OK) { + dp_send_error_msg(chain->dp, sender, OFPET_BAD_ACTION, v_code, + msg, ntohs(opo->header.length)); + goto error; + } + + execute_actions(chain->dp, skb, &key, opo->actions, actions_len, 1); return 0; + +error: + kfree_skb(skb); + return -EINVAL; } static int @@ -411,52 +205,46 @@ recv_echo_reply(struct sw_chain *chain, const struct sender *sender, } static int -add_flow(struct sw_chain *chain, const struct ofp_flow_mod *ofm) +add_flow(struct sw_chain *chain, const struct sender *sender, + const struct ofp_flow_mod *ofm) { int error = -ENOMEM; - int i; - int n_actions; + uint16_t v_code; struct sw_flow *flow; - - - /* To prevent loops, make sure there's no action to send to the - * OFP_TABLE virtual port. - */ - n_actions = (ntohs(ofm->header.length) - sizeof *ofm) - / sizeof *ofm->actions; - for (i=0; iactions[i]; - - if (a->type == htons(OFPAT_OUTPUT) - && (a->arg.output.port == htons(OFPP_TABLE) - || a->arg.output.port == htons(OFPP_NONE) - || a->arg.output.port == ofm->match.in_port)) { - /* xxx Send fancy new error message? */ - goto error; - } - } + size_t actions_len = ntohs(ofm->header.length) - sizeof *ofm; /* Allocate memory. */ - flow = flow_alloc(n_actions, GFP_ATOMIC); + flow = flow_alloc(actions_len, GFP_ATOMIC); if (flow == NULL) goto error; - /* Fill out flow. */ flow_extract_match(&flow->key, &ofm->match); + + v_code = validate_actions(chain->dp, &flow->key, ofm->actions, actions_len); + if (v_code != ACT_VALIDATION_OK) { + dp_send_error_msg(chain->dp, sender, OFPET_BAD_ACTION, v_code, + ofm, ntohs(ofm->header.length)); + goto error_free_flow; + } + + /* Fill out flow. */ flow->priority = flow->key.wildcards ? ntohs(ofm->priority) : -1; flow->idle_timeout = ntohs(ofm->idle_timeout); flow->hard_timeout = ntohs(ofm->hard_timeout); flow->used = jiffies; - flow->n_actions = n_actions; flow->init_time = jiffies; flow->byte_count = 0; flow->packet_count = 0; spin_lock_init(&flow->lock); - memcpy(flow->actions, ofm->actions, n_actions * sizeof *flow->actions); + memcpy(flow->sf_acts->actions, ofm->actions, actions_len); /* Act. */ error = chain_insert(chain, flow); - if (error) + if (error == -ENOBUFS) { + dp_send_error_msg(chain->dp, sender, OFPET_FLOW_MOD_FAILED, + OFPFMFC_ALL_TABLES_FULL, ofm, ntohs(ofm->header.length)); + goto error_free_flow; + } else if (error) goto error_free_flow; error = 0; if (ntohl(ofm->buffer_id) != (uint32_t) -1) { @@ -464,8 +252,9 @@ add_flow(struct sw_chain *chain, const struct ofp_flow_mod *ofm) if (skb) { struct sw_flow_key key; flow_used(flow, skb); + dp_set_origin(chain->dp, ntohs(ofm->match.in_port), skb); flow_extract(skb, ntohs(ofm->match.in_port), &key); - execute_actions(chain->dp, skb, &key, ofm->actions, n_actions, 0); + execute_actions(chain->dp, skb, &key, ofm->actions, actions_len, 0); } else error = -ESRCH; @@ -480,6 +269,51 @@ error: return error; } +static int +mod_flow(struct sw_chain *chain, const struct sender *sender, + const struct ofp_flow_mod *ofm) +{ + int error = -ENOMEM; + uint16_t v_code; + size_t actions_len; + struct sw_flow_key key; + uint16_t priority; + int strict; + + flow_extract_match(&key, &ofm->match); + + actions_len = ntohs(ofm->header.length) - sizeof *ofm; + + v_code = validate_actions(chain->dp, &key, ofm->actions, actions_len); + if (v_code != ACT_VALIDATION_OK) { + dp_send_error_msg(chain->dp, sender, OFPET_BAD_ACTION, v_code, + ofm, ntohs(ofm->header.length)); + goto error; + } + + priority = key.wildcards ? ntohs(ofm->priority) : -1; + strict = (ofm->command == htons(OFPFC_MODIFY_STRICT)) ? 1 : 0; + chain_modify(chain, &key, priority, strict, ofm->actions, actions_len); + + if (ntohl(ofm->buffer_id) != (uint32_t) -1) { + struct sk_buff *skb = retrieve_skb(ntohl(ofm->buffer_id)); + if (skb) { + struct sw_flow_key skb_key; + flow_extract(skb, ntohs(ofm->match.in_port), &skb_key); + execute_actions(chain->dp, skb, &skb_key, + ofm->actions, actions_len, 0); + } + else + error = -ESRCH; + } + return error; + +error: + if (ntohl(ofm->buffer_id) != (uint32_t) -1) + discard_skb(ntohl(ofm->buffer_id)); + return error; +} + static int recv_flow(struct sw_chain *chain, const struct sender *sender, const void *msg) { @@ -487,7 +321,9 @@ recv_flow(struct sw_chain *chain, const struct sender *sender, const void *msg) uint16_t command = ntohs(ofm->command); if (command == OFPFC_ADD) { - return add_flow(chain, ofm); + return add_flow(chain, sender, ofm); + } else if ((command == OFPFC_MODIFY) || (command == OFPFC_MODIFY_STRICT)) { + return mod_flow(chain, sender, ofm); } else if (command == OFPFC_DELETE) { struct sw_flow_key key; flow_extract_match(&key, &ofm->match); @@ -503,6 +339,25 @@ recv_flow(struct sw_chain *chain, const struct sender *sender, const void *msg) } } +static int +recv_vendor(struct sw_chain *chain, const struct sender *sender, + const void *msg) +{ + const struct ofp_vendor_header *ovh = msg; + + switch(ntohl(ovh->vendor)) + { + case NX_VENDOR_ID: + return nx_recv_msg(chain, sender, msg); + default: + if (net_ratelimit()) + printk("Uknown vendor: %#x\n", ntohl(ovh->vendor)); + dp_send_error_msg(chain->dp, sender, OFPET_BAD_REQUEST, + OFPBRC_BAD_VENDOR, msg, ntohs(ovh->header.length)); + return -EINVAL; + } +} + /* 'msg', which is 'length' bytes long, was received across Netlink from * 'sender'. Apply it to 'chain'. */ int @@ -517,6 +372,22 @@ fwd_control_input(struct sw_chain *chain, const struct sender *sender, }; static const struct openflow_packet packets[] = { + [OFPT_HELLO] = { + sizeof (struct ofp_header), + recv_hello, + }, + [OFPT_ECHO_REQUEST] = { + sizeof (struct ofp_header), + recv_echo_request, + }, + [OFPT_ECHO_REPLY] = { + sizeof (struct ofp_header), + recv_echo_reply, + }, + [OFPT_VENDOR] = { + sizeof (struct ofp_vendor_header), + recv_vendor, + }, [OFPT_FEATURES_REQUEST] = { sizeof (struct ofp_header), recv_features_request, @@ -540,27 +411,29 @@ fwd_control_input(struct sw_chain *chain, const struct sender *sender, [OFPT_PORT_MOD] = { sizeof (struct ofp_port_mod), recv_port_mod, - }, - [OFPT_ECHO_REQUEST] = { - sizeof (struct ofp_header), - recv_echo_request, - }, - [OFPT_ECHO_REPLY] = { - sizeof (struct ofp_header), - recv_echo_reply, - }, + } }; struct ofp_header *oh; oh = (struct ofp_header *) msg; - if (oh->version != OFP_VERSION) { + if (oh->version != OFP_VERSION + && oh->type != OFPT_HELLO + && oh->type != OFPT_ERROR + && oh->type != OFPT_ECHO_REQUEST + && oh->type != OFPT_ECHO_REPLY + && oh->type != OFPT_VENDOR) + { dp_send_error_msg(chain->dp, sender, OFPET_BAD_REQUEST, OFPBRC_BAD_VERSION, msg, length); return -EINVAL; } - if (ntohs(oh->length) > length) + if (ntohs(oh->length) != length) { + if (net_ratelimit()) + printk("received message length wrong: %d/%d\n", + ntohs(oh->length), length); return -EINVAL; + } if (oh->type < ARRAY_SIZE(packets)) { const struct openflow_packet *pkt = &packets[oh->type]; @@ -688,35 +561,3 @@ void fwd_exit(void) { fwd_discard_all(); } - -/* Utility functions. */ - -/* Makes '*pskb' writable, possibly copying it and setting '*pskb' to point to - * the copy. - * Returns 1 if successful, 0 on failure. */ -static int -make_writable(struct sk_buff **pskb) -{ - /* Based on skb_make_writable() in net/netfilter/core.c. */ - struct sk_buff *nskb; - - /* Not exclusive use of packet? Must copy. */ - if (skb_shared(*pskb) || skb_cloned(*pskb)) - goto copy_skb; - - return pskb_may_pull(*pskb, 40); /* FIXME? */ - -copy_skb: - nskb = skb_copy(*pskb, GFP_ATOMIC); - if (!nskb) - return 0; - BUG_ON(skb_is_nonlinear(nskb)); - - /* Rest of kernel will get very unhappy if we pass it a - suddenly-orphaned skbuff */ - if ((*pskb)->sk) - skb_set_owner_w(nskb, (*pskb)->sk); - kfree_skb(*pskb); - *pskb = nskb; - return 1; -}