1 files changed, 148 insertions, 2 deletions

diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index 7ab94c825b57..aa4ee4439f04 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -63,6 +63,7 @@
 #include <linux/if_tun.h>
 #include <linux/crc32.h>
 #include <linux/nsproxy.h>
+#include <linux/virtio_net.h>
 #include <net/net_namespace.h>
 #include <net/netns/generic.h>
 
@@ -283,6 +284,7 @@ static __inline__ ssize_t tun_get_user(struct tun_struct *tun, struct iovec *iv,
         struct tun_pi pi = { 0, __constant_htons(ETH_P_IP) };
         struct sk_buff *skb;
         size_t len = count, align = 0;
+        struct virtio_net_hdr gso = { 0 };
 
         if (!(tun->flags & TUN_NO_PI)) {
                 if ((len -= sizeof(pi)) > count)
@@ -292,6 +294,17 @@ static __inline__ ssize_t tun_get_user(struct tun_struct *tun, struct iovec *iv,
                         return -EFAULT;
         }
 
+        if (tun->flags & TUN_VNET_HDR) {
+                if ((len -= sizeof(gso)) > count)
+                        return -EINVAL;
+
+                if (memcpy_fromiovec((void *)&gso, iv, sizeof(gso)))
+                        return -EFAULT;
+
+                if (gso.hdr_len > len)
+                        return -EINVAL;
+        }
+
         if ((tun->flags & TUN_TYPE_MASK) == TUN_TAP_DEV) {
                 align = NET_IP_ALIGN;
                 if (unlikely(len < ETH_HLEN))
@@ -311,6 +324,16 @@ static __inline__ ssize_t tun_get_user(struct tun_struct *tun, struct iovec *iv,
                 return -EFAULT;
         }
 
+        if (gso.flags & VIRTIO_NET_HDR_F_NEEDS_CSUM) {
+                if (!skb_partial_csum_set(skb, gso.csum_start,
+                                          gso.csum_offset)) {
+                        tun->dev->stats.rx_frame_errors++;
+                        kfree_skb(skb);
+                        return -EINVAL;
+                }
+        } else if (tun->flags & TUN_NOCHECKSUM)
+                skb->ip_summed = CHECKSUM_UNNECESSARY;
+
         switch (tun->flags & TUN_TYPE_MASK) {
         case TUN_TUN_DEV:
                 if (tun->flags & TUN_NO_PI) {
@@ -337,8 +360,35 @@ static __inline__ ssize_t tun_get_user(struct tun_struct *tun, struct iovec *iv,
                 break;
         };
 
-        if (tun->flags & TUN_NOCHECKSUM)
-                skb->ip_summed = CHECKSUM_UNNECESSARY;
+        if (gso.gso_type != VIRTIO_NET_HDR_GSO_NONE) {
+                pr_debug("GSO!\n");
+                switch (gso.gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
+                case VIRTIO_NET_HDR_GSO_TCPV4:
+                        skb_shinfo(skb)->gso_type = SKB_GSO_TCPV4;
+                        break;
+                case VIRTIO_NET_HDR_GSO_TCPV6:
+                        skb_shinfo(skb)->gso_type = SKB_GSO_TCPV6;
+                        break;
+                default:
+                        tun->dev->stats.rx_frame_errors++;
+                        kfree_skb(skb);
+                        return -EINVAL;
+                }
+
+                if (gso.gso_type & VIRTIO_NET_HDR_GSO_ECN)
+                        skb_shinfo(skb)->gso_type |= SKB_GSO_TCP_ECN;
+
+                skb_shinfo(skb)->gso_size = gso.gso_size;
+                if (skb_shinfo(skb)->gso_size == 0) {
+                        tun->dev->stats.rx_frame_errors++;
+                        kfree_skb(skb);
+                        return -EINVAL;
+                }
+
+                /* Header must be checked, and gso_segs computed. */
+                skb_shinfo(skb)->gso_type |= SKB_GSO_DODGY;
+                skb_shinfo(skb)->gso_segs = 0;
+        }
 
         netif_rx_ni(skb);
         tun->dev->last_rx = jiffies;
@@ -384,6 +434,39 @@ static __inline__ ssize_t tun_put_user(struct tun_struct *tun,
                 total += sizeof(pi);
         }
 
+        if (tun->flags & TUN_VNET_HDR) {
+                struct virtio_net_hdr gso = { 0 }; /* no info leak */
+                if ((len -= sizeof(gso)) < 0)
+                        return -EINVAL;
+
+                if (skb_is_gso(skb)) {
+                        struct skb_shared_info *sinfo = skb_shinfo(skb);
+
+                        /* This is a hint as to how much should be linear. */
+                        gso.hdr_len = skb_headlen(skb);
+                        gso.gso_size = sinfo->gso_size;
+                        if (sinfo->gso_type & SKB_GSO_TCPV4)
+                                gso.gso_type = VIRTIO_NET_HDR_GSO_TCPV4;
+                        else if (sinfo->gso_type & SKB_GSO_TCPV6)
+                                gso.gso_type = VIRTIO_NET_HDR_GSO_TCPV6;
+                        else
+                                BUG();
+                        if (sinfo->gso_type & SKB_GSO_TCP_ECN)
+                                gso.gso_type |= VIRTIO_NET_HDR_GSO_ECN;
+                } else
+                        gso.gso_type = VIRTIO_NET_HDR_GSO_NONE;
+
+                if (skb->ip_summed == CHECKSUM_PARTIAL) {
+                        gso.flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
+                        gso.csum_start = skb->csum_start - skb_headroom(skb);
+                        gso.csum_offset = skb->csum_offset;
+                } /* else everything is zero */
+
+                if (unlikely(memcpy_toiovec(iv, (void *)&gso, sizeof(gso))))
+                        return -EFAULT;
+                total += sizeof(gso);
+        }
+
         len = min_t(int, skb->len, len);
 
         skb_copy_datagram_iovec(skb, 0, iv, len);
@@ -598,6 +681,11 @@ static int tun_set_iff(struct net *net, struct file *file, struct ifreq *ifr)
         else
                 tun->flags &= ~TUN_ONE_QUEUE;
 
+        if (ifr->ifr_flags & IFF_VNET_HDR)
+                tun->flags |= TUN_VNET_HDR;
+        else
+                tun->flags &= ~TUN_VNET_HDR;
+
         file->private_data = tun;
         tun->attached = 1;
         get_net(dev_net(tun->dev));
@@ -611,6 +699,46 @@ static int tun_set_iff(struct net *net, struct file *file, struct ifreq *ifr)
         return err;
 }
 
+/* This is like a cut-down ethtool ops, except done via tun fd so no
+ * privs required. */
+static int set_offload(struct net_device *dev, unsigned long arg)
+{
+        unsigned int old_features, features;
+
+        old_features = dev->features;
+        /* Unset features, set them as we chew on the arg. */
+        features = (old_features & ~(NETIF_F_HW_CSUM|NETIF_F_SG|NETIF_F_FRAGLIST
+                                    |NETIF_F_TSO_ECN|NETIF_F_TSO|NETIF_F_TSO6));
+
+        if (arg & TUN_F_CSUM) {
+                features |= NETIF_F_HW_CSUM|NETIF_F_SG|NETIF_F_FRAGLIST;
+                arg &= ~TUN_F_CSUM;
+
+                if (arg & (TUN_F_TSO4|TUN_F_TSO6)) {
+                        if (arg & TUN_F_TSO_ECN) {
+                                features |= NETIF_F_TSO_ECN;
+                                arg &= ~TUN_F_TSO_ECN;
+                        }
+                        if (arg & TUN_F_TSO4)
+                                features |= NETIF_F_TSO;
+                        if (arg & TUN_F_TSO6)
+                                features |= NETIF_F_TSO6;
+                        arg &= ~(TUN_F_TSO4|TUN_F_TSO6);
+                }
+        }
+
+        /* This gives the user a way to test for new features in future by
+         * trying to set them. */
+        if (arg)
+                return -EINVAL;
+
+        dev->features = features;
+        if (old_features != dev->features)
+                netdev_features_change(dev);
+
+        return 0;
+}
+
 static int tun_chr_ioctl(struct inode *inode, struct file *file,
                          unsigned int cmd, unsigned long arg)
 {
@@ -640,6 +768,15 @@ static int tun_chr_ioctl(struct inode *inode, struct file *file,
                 return 0;
         }
 
+        if (cmd == TUNGETFEATURES) {
+                /* Currently this just means: "what IFF flags are valid?".
+                 * This is needed because we never checked for invalid flags on
+                 * TUNSETIFF. */
+                return put_user(IFF_TUN | IFF_TAP | IFF_NO_PI | IFF_ONE_QUEUE |
+                                IFF_VNET_HDR,
+                                (unsigned int __user*)argp);
+        }
+
         if (!tun)
                 return -EBADFD;
 
@@ -707,6 +844,15 @@ static int tun_chr_ioctl(struct inode *inode, struct file *file,
                 break;
 #endif
 
+        case TUNSETOFFLOAD:
+        {
+                int ret;
+                rtnl_lock();
+                ret = set_offload(tun->dev, arg);
+                rtnl_unlock();
+                return ret;
+        }
+
         case SIOCGIFFLAGS:
                 ifr.ifr_flags = tun->if_flags;
                 if (copy_to_user( argp, &ifr, sizeof ifr))