X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=datapath%2Fvport-gre.c;h=8ce8a35744211e0903fc6507a6693e3941367fe9;hb=5ca1ba484bd9ade5116a49cf241cb98219d7d696;hp=eb1000910d17e19cc1179cbbde0e5505e22f5210;hpb=69feaa6f1b37d6c6787f815b92a0ab65f5d8bbb4;p=sliver-openvswitch.git diff --git a/datapath/vport-gre.c b/datapath/vport-gre.c index eb1000910..8ce8a3574 100644 --- a/datapath/vport-gre.c +++ b/datapath/vport-gre.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2007-2011 Nicira Networks. + * Copyright (c) 2007-2012 Nicira, Inc. * * This program is free software; you can redistribute it and/or * modify it under the terms of version 2 of the GNU General Public @@ -29,9 +29,9 @@ #include #include +#include "datapath.h" #include "tunnel.h" #include "vport.h" -#include "vport-generic.h" /* * The GRE header is composed of a series of sections: a base and then a variable @@ -44,21 +44,32 @@ struct gre_base_hdr { __be16 protocol; }; -static int gre_hdr_len(const struct tnl_mutable_config *mutable) +static int gre_hdr_len(const struct tnl_mutable_config *mutable, + const struct ovs_key_ipv4_tunnel *tun_key) { int len; + u32 flags; + __be64 out_key; + tnl_get_param(mutable, tun_key, &flags, &out_key); len = GRE_HEADER_SECTION; - if (mutable->flags & TNL_F_CSUM) + if (flags & TNL_F_CSUM) len += GRE_HEADER_SECTION; - if (mutable->out_key || mutable->flags & TNL_F_OUT_KEY_ACTION) - len += GRE_HEADER_SECTION; + /* Set key for GRE64 tunnels, even when key if is zero. */ + if (out_key || + mutable->key.tunnel_type & TNL_T_PROTO_GRE64 || + flags & TNL_F_OUT_KEY_ACTION) { + len += GRE_HEADER_SECTION; + if (mutable->key.tunnel_type & TNL_T_PROTO_GRE64) + len += GRE_HEADER_SECTION; + } return len; } + /* Returns the least-significant 32 bits of a __be64. */ static __be32 be64_get_low32(__be64 x) { @@ -69,49 +80,55 @@ static __be32 be64_get_low32(__be64 x) #endif } -static void gre_build_header(const struct vport *vport, - const struct tnl_mutable_config *mutable, - void *header) +static __be32 be64_get_high32(__be64 x) { - struct gre_base_hdr *greh = header; - __be32 *options = (__be32 *)(greh + 1); - - greh->protocol = htons(ETH_P_TEB); - greh->flags = 0; - - if (mutable->flags & TNL_F_CSUM) { - greh->flags |= GRE_CSUM; - *options = 0; - options++; - } - - if (mutable->out_key || mutable->flags & TNL_F_OUT_KEY_ACTION) - greh->flags |= GRE_KEY; - - if (mutable->out_key) - *options = be64_get_low32(mutable->out_key); +#ifdef __BIG_ENDIAN + return (__force __be32)((__force u64)x >> 32); +#else + return (__force __be32)x; +#endif } -static struct sk_buff *gre_update_header(const struct vport *vport, +static struct sk_buff *gre_build_header(const struct vport *vport, const struct tnl_mutable_config *mutable, struct dst_entry *dst, - struct sk_buff *skb) + struct sk_buff *skb, + int tunnel_hlen) { - __be32 *options = (__be32 *)(skb_network_header(skb) + mutable->tunnel_hlen + u32 flags; + __be64 out_key; + const struct ovs_key_ipv4_tunnel *tun_key = OVS_CB(skb)->tun_key; + __be32 *options = (__be32 *)(skb_network_header(skb) + tunnel_hlen - GRE_HEADER_SECTION); + struct gre_base_hdr *greh = (struct gre_base_hdr *) skb_transport_header(skb); - /* Work backwards over the options so the checksum is last. */ - if (mutable->flags & TNL_F_OUT_KEY_ACTION) - *options = be64_get_low32(OVS_CB(skb)->tun_id); + tnl_get_param(mutable, tun_key, &flags, &out_key); - if (mutable->out_key || mutable->flags & TNL_F_OUT_KEY_ACTION) + greh->protocol = htons(ETH_P_TEB); + greh->flags = 0; + + /* Work backwards over the options so the checksum is last. */ + if (out_key || flags & TNL_F_OUT_KEY_ACTION || + mutable->key.tunnel_type & TNL_T_PROTO_GRE64) { + greh->flags |= GRE_KEY; + if (mutable->key.tunnel_type & TNL_T_PROTO_GRE64) { + /* Set higher 32 bits to seq. */ + *options = be64_get_high32(out_key); + options--; + greh->flags |= GRE_SEQ; + } + *options = be64_get_low32(out_key); options--; + } - if (mutable->flags & TNL_F_CSUM) + if (flags & TNL_F_CSUM) { + greh->flags |= GRE_CSUM; + *options = 0; *(__sum16 *)options = csum_fold(skb_checksum(skb, skb_transport_offset(skb), skb->len - skb_transport_offset(skb), 0)); + } /* * Allow our local IP stack to fragment the outer packet even if the * DF bit is set as a last resort. We also need to force selection of @@ -124,17 +141,17 @@ static struct sk_buff *gre_update_header(const struct vport *vport, return skb; } -/* Zero-extends a __be32 into the least-significant 32 bits of a __be64. */ -static __be64 be32_extend_to_be64(__be32 x) +static __be64 key_to_tunnel_id(__be32 key, __be32 seq) { #ifdef __BIG_ENDIAN - return (__force __be64)x; + return (__force __be64)((__force u64)seq << 32 | (__force u32)key); #else - return (__force __be64)((__force u64)x << 32); + return (__force __be64)((__force u64)key << 32 | (__force u32)seq); #endif } -static int parse_header(struct iphdr *iph, __be16 *flags, __be64 *key) +static int parse_header(struct iphdr *iph, __be16 *flags, __be64 *tun_id, + u32 *tunnel_type) { /* IP and ICMP protocol handlers check that the IHL is valid. */ struct gre_base_hdr *greh = (struct gre_base_hdr *)((u8 *)iph + (iph->ihl << 2)); @@ -157,14 +174,28 @@ static int parse_header(struct iphdr *iph, __be16 *flags, __be64 *key) } if (greh->flags & GRE_KEY) { - hdr_len += GRE_HEADER_SECTION; + __be32 seq; + __be32 gre_key; - *key = be32_extend_to_be64(*options); + gre_key = *options; + hdr_len += GRE_HEADER_SECTION; options++; - } else - *key = 0; - if (unlikely(greh->flags & GRE_SEQ)) + if (greh->flags & GRE_SEQ) { + seq = *options; + *tunnel_type = TNL_T_PROTO_GRE64; + } else { + seq = 0; + *tunnel_type = TNL_T_PROTO_GRE; + } + *tun_id = key_to_tunnel_id(gre_key, seq); + } else { + *tun_id = 0; + /* Ignore GRE seq if there is no key present. */ + *tunnel_type = TNL_T_PROTO_GRE; + } + + if (greh->flags & GRE_SEQ) hdr_len += GRE_HEADER_SECTION; return hdr_len; @@ -178,6 +209,7 @@ static void gre_err(struct sk_buff *skb, u32 info) const int type = icmp_hdr(skb)->type; const int code = icmp_hdr(skb)->code; int mtu = ntohs(icmp_hdr(skb)->un.frag.mtu); + u32 tunnel_type; struct iphdr *iph; __be16 flags; @@ -202,12 +234,12 @@ static void gre_err(struct sk_buff *skb, u32 info) if (ipv4_is_multicast(iph->daddr)) return; - tunnel_hdr_len = parse_header(iph, &flags, &key); + tunnel_hdr_len = parse_header(iph, &flags, &key, &tunnel_type); if (tunnel_hdr_len < 0) return; - vport = ovs_tnl_find_port(iph->saddr, iph->daddr, key, TNL_T_PROTO_GRE, - &mutable); + vport = ovs_tnl_find_port(dev_net(skb->dev), iph->saddr, iph->daddr, key, + tunnel_type, &mutable); if (!vport) return; @@ -284,7 +316,7 @@ static void gre_err(struct sk_buff *skb, u32 info) #endif __skb_pull(skb, tunnel_hdr_len); - ovs_tnl_frag_needed(vport, mutable, skb, mtu, key); + ovs_tnl_frag_needed(vport, mutable, skb, mtu); __skb_push(skb, tunnel_hdr_len); out: @@ -319,6 +351,25 @@ static bool check_checksum(struct sk_buff *skb) return (csum == 0); } +static u32 gre_flags_to_tunnel_flags(const struct tnl_mutable_config *mutable, + __be16 gre_flags, __be64 *key) +{ + u32 tunnel_flags = 0; + + if (gre_flags & GRE_KEY) { + if (mutable->flags & TNL_F_IN_KEY_MATCH || + !mutable->key.daddr) + tunnel_flags = OVS_TNL_F_KEY; + else + *key = 0; + } + + if (gre_flags & GRE_CSUM) + tunnel_flags |= OVS_TNL_F_CSUM; + + return tunnel_flags; +} + /* Called with rcu_read_lock and BH disabled. */ static int gre_rcv(struct sk_buff *skb) { @@ -326,16 +377,18 @@ static int gre_rcv(struct sk_buff *skb) const struct tnl_mutable_config *mutable; int hdr_len; struct iphdr *iph; - __be16 flags; + struct ovs_key_ipv4_tunnel tun_key; + __be16 gre_flags; + u32 tnl_flags; __be64 key; + u32 tunnel_type; if (unlikely(!pskb_may_pull(skb, sizeof(struct gre_base_hdr) + ETH_HLEN))) goto error; - if (unlikely(!check_checksum(skb))) goto error; - hdr_len = parse_header(ip_hdr(skb), &flags, &key); + hdr_len = parse_header(ip_hdr(skb), &gre_flags, &key, &tunnel_type); if (unlikely(hdr_len < 0)) goto error; @@ -343,22 +396,21 @@ static int gre_rcv(struct sk_buff *skb) goto error; iph = ip_hdr(skb); - vport = ovs_tnl_find_port(iph->daddr, iph->saddr, key, TNL_T_PROTO_GRE, - &mutable); + vport = ovs_tnl_find_port(dev_net(skb->dev), iph->daddr, iph->saddr, key, + tunnel_type, &mutable); if (unlikely(!vport)) { icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0); goto error; } - if (mutable->flags & TNL_F_IN_KEY_MATCH) - OVS_CB(skb)->tun_id = key; - else - OVS_CB(skb)->tun_id = 0; + tnl_flags = gre_flags_to_tunnel_flags(mutable, gre_flags, &key); + tnl_tun_key_init(&tun_key, iph, key, tnl_flags); + OVS_CB(skb)->tun_key = &tun_key; __skb_pull(skb, hdr_len); skb_postpull_rcsum(skb, skb_transport_header(skb), hdr_len + ETH_HLEN); - ovs_tnl_rcv(vport, skb, iph->tos); + ovs_tnl_rcv(vport, skb); return 0; error: @@ -371,7 +423,6 @@ static const struct tnl_ops gre_tnl_ops = { .ipproto = IPPROTO_GRE, .hdr_len = gre_hdr_len, .build_header = gre_build_header, - .update_header = gre_update_header, }; static struct vport *gre_create(const struct vport_parms *parms) @@ -379,15 +430,41 @@ static struct vport *gre_create(const struct vport_parms *parms) return ovs_tnl_create(parms, &ovs_gre_vport_ops, &gre_tnl_ops); } +static struct vport *gre_create_ft(const struct vport_parms *parms) +{ + return ovs_tnl_create(parms, &ovs_gre_ft_vport_ops, &gre_tnl_ops); +} + +static const struct tnl_ops gre64_tnl_ops = { + .tunnel_type = TNL_T_PROTO_GRE64, + .ipproto = IPPROTO_GRE, + .hdr_len = gre_hdr_len, + .build_header = gre_build_header, +}; + +static struct vport *gre_create64(const struct vport_parms *parms) +{ + return ovs_tnl_create(parms, &ovs_gre64_vport_ops, &gre64_tnl_ops); +} + static const struct net_protocol gre_protocol_handlers = { .handler = gre_rcv, .err_handler = gre_err, +#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32) + .netns_ok = 1, +#endif }; +static bool inited; + static int gre_init(void) { int err; + if (inited) + return 0; + + inited = true; err = inet_add_protocol(&gre_protocol_handlers, IPPROTO_GRE); if (err) pr_warn("cannot register gre protocol handler\n"); @@ -397,9 +474,29 @@ static int gre_init(void) static void gre_exit(void) { + if (!inited) + return; + + inited = false; + inet_del_protocol(&gre_protocol_handlers, IPPROTO_GRE); } +const struct vport_ops ovs_gre_ft_vport_ops = { + .type = OVS_VPORT_TYPE_FT_GRE, + .flags = VPORT_F_TUN_ID, + .init = gre_init, + .exit = gre_exit, + .create = gre_create_ft, + .destroy = ovs_tnl_destroy, + .set_addr = ovs_tnl_set_addr, + .get_name = ovs_tnl_get_name, + .get_addr = ovs_tnl_get_addr, + .get_options = ovs_tnl_get_options, + .set_options = ovs_tnl_set_options, + .send = ovs_tnl_send, +}; + const struct vport_ops ovs_gre_vport_ops = { .type = OVS_VPORT_TYPE_GRE, .flags = VPORT_F_TUN_ID, @@ -412,8 +509,20 @@ const struct vport_ops ovs_gre_vport_ops = { .get_addr = ovs_tnl_get_addr, .get_options = ovs_tnl_get_options, .set_options = ovs_tnl_set_options, - .get_dev_flags = ovs_vport_gen_get_dev_flags, - .is_running = ovs_vport_gen_is_running, - .get_operstate = ovs_vport_gen_get_operstate, + .send = ovs_tnl_send, +}; + +const struct vport_ops ovs_gre64_vport_ops = { + .type = OVS_VPORT_TYPE_GRE64, + .flags = VPORT_F_TUN_ID, + .init = gre_init, + .exit = gre_exit, + .create = gre_create64, + .destroy = ovs_tnl_destroy, + .set_addr = ovs_tnl_set_addr, + .get_name = ovs_tnl_get_name, + .get_addr = ovs_tnl_get_addr, + .get_options = ovs_tnl_get_options, + .set_options = ovs_tnl_set_options, .send = ovs_tnl_send, };