1 files changed, 419 insertions, 14 deletions

diff --git a/net/core/ethtool.c b/net/core/ethtool.c
index 236a9988ea91..f4cb6b6299d9 100644
--- a/net/core/ethtool.c
+++ b/net/core/ethtool.c
@@ -17,6 +17,7 @@
 #include <linux/errno.h>
 #include <linux/ethtool.h>
 #include <linux/netdevice.h>
+#include <linux/bitops.h>
 #include <asm/uaccess.h>
 
 /*
@@ -120,7 +121,7 @@ int ethtool_op_set_ufo(struct net_device *dev, u32 data)
  * NETIF_F_xxx values in include/linux/netdevice.h
  */
 static const u32 flags_dup_features =
-        ETH_FLAG_LRO;
+        (ETH_FLAG_LRO | ETH_FLAG_NTUPLE);
 
 u32 ethtool_op_get_flags(struct net_device *dev)
 {
@@ -134,19 +135,44 @@ u32 ethtool_op_get_flags(struct net_device *dev)
 
 int ethtool_op_set_flags(struct net_device *dev, u32 data)
 {
+        const struct ethtool_ops *ops = dev->ethtool_ops;
+        unsigned long features = dev->features;
+
         if (data & ETH_FLAG_LRO)
-                dev->features |= NETIF_F_LRO;
+                features |= NETIF_F_LRO;
         else
-                dev->features &= ~NETIF_F_LRO;
+                features &= ~NETIF_F_LRO;
+
+        if (data & ETH_FLAG_NTUPLE) {
+                if (!ops->set_rx_ntuple)
+                        return -EOPNOTSUPP;
+                features |= NETIF_F_NTUPLE;
+        } else {
+                /* safe to clear regardless */
+                features &= ~NETIF_F_NTUPLE;
+        }
 
+        dev->features = features;
         return 0;
 }
 
+void ethtool_ntuple_flush(struct net_device *dev)
+{
+        struct ethtool_rx_ntuple_flow_spec_container *fsc, *f;
+
+        list_for_each_entry_safe(fsc, f, &dev->ethtool_ntuple_list.list, list) {
+                list_del(&fsc->list);
+                kfree(fsc);
+        }
+        dev->ethtool_ntuple_list.count = 0;
+}
+EXPORT_SYMBOL(ethtool_ntuple_flush);
+
 /* Handlers for each ethtool command */
 
 static int ethtool_get_settings(struct net_device *dev, void __user *useraddr)
 {
-        struct ethtool_cmd cmd = { ETHTOOL_GSET };
+        struct ethtool_cmd cmd = { .cmd = ETHTOOL_GSET };
         int err;
 
         if (!dev->ethtool_ops->get_settings)
@@ -174,7 +200,7 @@ static int ethtool_set_settings(struct net_device *dev, void __user *useraddr)
         return dev->ethtool_ops->set_settings(dev, &cmd);
 }
 
-static int ethtool_get_drvinfo(struct net_device *dev, void __user *useraddr)
+static noinline_for_stack int ethtool_get_drvinfo(struct net_device *dev, void __user *useraddr)
 {
         struct ethtool_drvinfo info;
         const struct ethtool_ops *ops = dev->ethtool_ops;
@@ -186,6 +212,10 @@ static int ethtool_get_drvinfo(struct net_device *dev, void __user *useraddr)
         info.cmd = ETHTOOL_GDRVINFO;
         ops->get_drvinfo(dev, &info);
 
+        /*
+         * this method of obtaining string set info is deprecated;
+         * Use ETHTOOL_GSSET_INFO instead.
+         */
         if (ops->get_sset_count) {
                 int rc;
 
@@ -209,7 +239,67 @@ static int ethtool_get_drvinfo(struct net_device *dev, void __user *useraddr)
         return 0;
 }
 
-static int ethtool_set_rxnfc(struct net_device *dev, void __user *useraddr)
+static noinline_for_stack int ethtool_get_sset_info(struct net_device *dev,
+                                          void __user *useraddr)
+{
+        struct ethtool_sset_info info;
+        const struct ethtool_ops *ops = dev->ethtool_ops;
+        u64 sset_mask;
+        int i, idx = 0, n_bits = 0, ret, rc;
+        u32 *info_buf = NULL;
+
+        if (!ops->get_sset_count)
+                return -EOPNOTSUPP;
+
+        if (copy_from_user(&info, useraddr, sizeof(info)))
+                return -EFAULT;
+
+        /* store copy of mask, because we zero struct later on */
+        sset_mask = info.sset_mask;
+        if (!sset_mask)
+                return 0;
+
+        /* calculate size of return buffer */
+        n_bits = hweight64(sset_mask);
+
+        memset(&info, 0, sizeof(info));
+        info.cmd = ETHTOOL_GSSET_INFO;
+
+        info_buf = kzalloc(n_bits * sizeof(u32), GFP_USER);
+        if (!info_buf)
+                return -ENOMEM;
+
+        /*
+         * fill return buffer based on input bitmask and successful
+         * get_sset_count return
+         */
+        for (i = 0; i < 64; i++) {
+                if (!(sset_mask & (1ULL << i)))
+                        continue;
+
+                rc = ops->get_sset_count(dev, i);
+                if (rc >= 0) {
+                        info.sset_mask |= (1ULL << i);
+                        info_buf[idx++] = rc;
+                }
+        }
+
+        ret = -EFAULT;
+        if (copy_to_user(useraddr, &info, sizeof(info)))
+                goto out;
+
+        useraddr += offsetof(struct ethtool_sset_info, data);
+        if (copy_to_user(useraddr, info_buf, idx * sizeof(u32)))
+                goto out;
+
+        ret = 0;
+
+out:
+        kfree(info_buf);
+        return ret;
+}
+
+static noinline_for_stack int ethtool_set_rxnfc(struct net_device *dev, void __user *useraddr)
 {
         struct ethtool_rxnfc cmd;
 
@@ -222,7 +312,7 @@ static int ethtool_set_rxnfc(struct net_device *dev, void __user *useraddr)
         return dev->ethtool_ops->set_rxnfc(dev, &cmd);
 }
 
-static int ethtool_get_rxnfc(struct net_device *dev, void __user *useraddr)
+static noinline_for_stack int ethtool_get_rxnfc(struct net_device *dev, void __user *useraddr)
 {
         struct ethtool_rxnfc info;
         const struct ethtool_ops *ops = dev->ethtool_ops;
@@ -266,6 +356,312 @@ err_out:
         return ret;
 }
 
+static void __rx_ntuple_filter_add(struct ethtool_rx_ntuple_list *list,
+                              struct ethtool_rx_ntuple_flow_spec *spec,
+                              struct ethtool_rx_ntuple_flow_spec_container *fsc)
+{
+
+        /* don't add filters forever */
+        if (list->count >= ETHTOOL_MAX_NTUPLE_LIST_ENTRY) {
+                /* free the container */
+                kfree(fsc);
+                return;
+        }
+
+        /* Copy the whole filter over */
+        fsc->fs.flow_type = spec->flow_type;
+        memcpy(&fsc->fs.h_u, &spec->h_u, sizeof(spec->h_u));
+        memcpy(&fsc->fs.m_u, &spec->m_u, sizeof(spec->m_u));
+
+        fsc->fs.vlan_tag = spec->vlan_tag;
+        fsc->fs.vlan_tag_mask = spec->vlan_tag_mask;
+        fsc->fs.data = spec->data;
+        fsc->fs.data_mask = spec->data_mask;
+        fsc->fs.action = spec->action;
+
+        /* add to the list */
+        list_add_tail_rcu(&fsc->list, &list->list);
+        list->count++;
+}
+
+static noinline_for_stack int ethtool_set_rx_ntuple(struct net_device *dev, void __user *useraddr)
+{
+        struct ethtool_rx_ntuple cmd;
+        const struct ethtool_ops *ops = dev->ethtool_ops;
+        struct ethtool_rx_ntuple_flow_spec_container *fsc = NULL;
+        int ret;
+
+        if (!(dev->features & NETIF_F_NTUPLE))
+                return -EINVAL;
+
+        if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
+                return -EFAULT;
+
+        /*
+         * Cache filter in dev struct for GET operation only if
+         * the underlying driver doesn't have its own GET operation, and
+         * only if the filter was added successfully.  First make sure we
+         * can allocate the filter, then continue if successful.
+         */
+        if (!ops->get_rx_ntuple) {
+                fsc = kmalloc(sizeof(*fsc), GFP_ATOMIC);
+                if (!fsc)
+                        return -ENOMEM;
+        }
+
+        ret = ops->set_rx_ntuple(dev, &cmd);
+        if (ret) {
+                kfree(fsc);
+                return ret;
+        }
+
+        if (!ops->get_rx_ntuple)
+                __rx_ntuple_filter_add(&dev->ethtool_ntuple_list, &cmd.fs, fsc);
+
+        return ret;
+}
+
+static int ethtool_get_rx_ntuple(struct net_device *dev, void __user *useraddr)
+{
+        struct ethtool_gstrings gstrings;
+        const struct ethtool_ops *ops = dev->ethtool_ops;
+        struct ethtool_rx_ntuple_flow_spec_container *fsc;
+        u8 *data;
+        char *p;
+        int ret, i, num_strings = 0;
+
+        if (!ops->get_sset_count)
+                return -EOPNOTSUPP;
+
+        if (copy_from_user(&gstrings, useraddr, sizeof(gstrings)))
+                return -EFAULT;
+
+        ret = ops->get_sset_count(dev, gstrings.string_set);
+        if (ret < 0)
+                return ret;
+
+        gstrings.len = ret;
+
+        data = kmalloc(gstrings.len * ETH_GSTRING_LEN, GFP_USER);
+        if (!data)
+                return -ENOMEM;
+
+        if (ops->get_rx_ntuple) {
+                /* driver-specific filter grab */
+                ret = ops->get_rx_ntuple(dev, gstrings.string_set, data);
+                goto copy;
+        }
+
+        /* default ethtool filter grab */
+        i = 0;
+        p = (char *)data;
+        list_for_each_entry(fsc, &dev->ethtool_ntuple_list.list, list) {
+                sprintf(p, "Filter %d:\n", i);
+                p += ETH_GSTRING_LEN;
+                num_strings++;
+
+                switch (fsc->fs.flow_type) {
+                case TCP_V4_FLOW:
+                        sprintf(p, "\tFlow Type: TCP\n");
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        break;
+                case UDP_V4_FLOW:
+                        sprintf(p, "\tFlow Type: UDP\n");
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        break;
+                case SCTP_V4_FLOW:
+                        sprintf(p, "\tFlow Type: SCTP\n");
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        break;
+                case AH_ESP_V4_FLOW:
+                        sprintf(p, "\tFlow Type: AH ESP\n");
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        break;
+                case ESP_V4_FLOW:
+                        sprintf(p, "\tFlow Type: ESP\n");
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        break;
+                case IP_USER_FLOW:
+                        sprintf(p, "\tFlow Type: Raw IP\n");
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        break;
+                case IPV4_FLOW:
+                        sprintf(p, "\tFlow Type: IPv4\n");
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        break;
+                default:
+                        sprintf(p, "\tFlow Type: Unknown\n");
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        goto unknown_filter;
+                };
+
+                /* now the rest of the filters */
+                switch (fsc->fs.flow_type) {
+                case TCP_V4_FLOW:
+                case UDP_V4_FLOW:
+                case SCTP_V4_FLOW:
+                        sprintf(p, "\tSrc IP addr: 0x%x\n",
+                                fsc->fs.h_u.tcp_ip4_spec.ip4src);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tSrc IP mask: 0x%x\n",
+                                fsc->fs.m_u.tcp_ip4_spec.ip4src);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tDest IP addr: 0x%x\n",
+                                fsc->fs.h_u.tcp_ip4_spec.ip4dst);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tDest IP mask: 0x%x\n",
+                                fsc->fs.m_u.tcp_ip4_spec.ip4dst);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tSrc Port: %d, mask: 0x%x\n",
+                                fsc->fs.h_u.tcp_ip4_spec.psrc,
+                                fsc->fs.m_u.tcp_ip4_spec.psrc);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tDest Port: %d, mask: 0x%x\n",
+                                fsc->fs.h_u.tcp_ip4_spec.pdst,
+                                fsc->fs.m_u.tcp_ip4_spec.pdst);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tTOS: %d, mask: 0x%x\n",
+                                fsc->fs.h_u.tcp_ip4_spec.tos,
+                                fsc->fs.m_u.tcp_ip4_spec.tos);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        break;
+                case AH_ESP_V4_FLOW:
+                case ESP_V4_FLOW:
+                        sprintf(p, "\tSrc IP addr: 0x%x\n",
+                                fsc->fs.h_u.ah_ip4_spec.ip4src);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tSrc IP mask: 0x%x\n",
+                                fsc->fs.m_u.ah_ip4_spec.ip4src);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tDest IP addr: 0x%x\n",
+                                fsc->fs.h_u.ah_ip4_spec.ip4dst);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tDest IP mask: 0x%x\n",
+                                fsc->fs.m_u.ah_ip4_spec.ip4dst);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tSPI: %d, mask: 0x%x\n",
+                                fsc->fs.h_u.ah_ip4_spec.spi,
+                                fsc->fs.m_u.ah_ip4_spec.spi);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tTOS: %d, mask: 0x%x\n",
+                                fsc->fs.h_u.ah_ip4_spec.tos,
+                                fsc->fs.m_u.ah_ip4_spec.tos);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        break;
+                case IP_USER_FLOW:
+                        sprintf(p, "\tSrc IP addr: 0x%x\n",
+                                fsc->fs.h_u.raw_ip4_spec.ip4src);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tSrc IP mask: 0x%x\n",
+                                fsc->fs.m_u.raw_ip4_spec.ip4src);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tDest IP addr: 0x%x\n",
+                                fsc->fs.h_u.raw_ip4_spec.ip4dst);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tDest IP mask: 0x%x\n",
+                                fsc->fs.m_u.raw_ip4_spec.ip4dst);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        break;
+                case IPV4_FLOW:
+                        sprintf(p, "\tSrc IP addr: 0x%x\n",
+                                fsc->fs.h_u.usr_ip4_spec.ip4src);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tSrc IP mask: 0x%x\n",
+                                fsc->fs.m_u.usr_ip4_spec.ip4src);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tDest IP addr: 0x%x\n",
+                                fsc->fs.h_u.usr_ip4_spec.ip4dst);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tDest IP mask: 0x%x\n",
+                                fsc->fs.m_u.usr_ip4_spec.ip4dst);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tL4 bytes: 0x%x, mask: 0x%x\n",
+                                fsc->fs.h_u.usr_ip4_spec.l4_4_bytes,
+                                fsc->fs.m_u.usr_ip4_spec.l4_4_bytes);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tTOS: %d, mask: 0x%x\n",
+                                fsc->fs.h_u.usr_ip4_spec.tos,
+                                fsc->fs.m_u.usr_ip4_spec.tos);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tIP Version: %d, mask: 0x%x\n",
+                                fsc->fs.h_u.usr_ip4_spec.ip_ver,
+                                fsc->fs.m_u.usr_ip4_spec.ip_ver);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        sprintf(p, "\tProtocol: %d, mask: 0x%x\n",
+                                fsc->fs.h_u.usr_ip4_spec.proto,
+                                fsc->fs.m_u.usr_ip4_spec.proto);
+                        p += ETH_GSTRING_LEN;
+                        num_strings++;
+                        break;
+                };
+                sprintf(p, "\tVLAN: %d, mask: 0x%x\n",
+                        fsc->fs.vlan_tag, fsc->fs.vlan_tag_mask);
+                p += ETH_GSTRING_LEN;
+                num_strings++;
+                sprintf(p, "\tUser-defined: 0x%Lx\n", fsc->fs.data);
+                p += ETH_GSTRING_LEN;
+                num_strings++;
+                sprintf(p, "\tUser-defined mask: 0x%Lx\n", fsc->fs.data_mask);
+                p += ETH_GSTRING_LEN;
+                num_strings++;
+                if (fsc->fs.action == ETHTOOL_RXNTUPLE_ACTION_DROP)
+                        sprintf(p, "\tAction: Drop\n");
+                else
+                        sprintf(p, "\tAction: Direct to queue %d\n",
+                                fsc->fs.action);
+                p += ETH_GSTRING_LEN;
+                num_strings++;
+unknown_filter:
+                i++;
+        }
+copy:
+        /* indicate to userspace how many strings we actually have */
+        gstrings.len = num_strings;
+        ret = -EFAULT;
+        if (copy_to_user(useraddr, &gstrings, sizeof(gstrings)))
+                goto out;
+        useraddr += sizeof(gstrings);
+        if (copy_to_user(useraddr, data, gstrings.len * ETH_GSTRING_LEN))
+                goto out;
+        ret = 0;
+
+out:
+        kfree(data);
+        return ret;
+}
+
 static int ethtool_get_regs(struct net_device *dev, char __user *useraddr)
 {
         struct ethtool_regs regs;
@@ -324,7 +720,7 @@ static int ethtool_reset(struct net_device *dev, char __user *useraddr)
 
 static int ethtool_get_wol(struct net_device *dev, char __user *useraddr)
 {
-        struct ethtool_wolinfo wol = { ETHTOOL_GWOL };
+        struct ethtool_wolinfo wol = { .cmd = ETHTOOL_GWOL };
 
         if (!dev->ethtool_ops->get_wol)
                 return -EOPNOTSUPP;
@@ -456,9 +852,9 @@ static int ethtool_set_eeprom(struct net_device *dev, void __user *useraddr)
         return ret;
 }
 
-static int ethtool_get_coalesce(struct net_device *dev, void __user *useraddr)
+static noinline_for_stack int ethtool_get_coalesce(struct net_device *dev, void __user *useraddr)
 {
-        struct ethtool_coalesce coalesce = { ETHTOOL_GCOALESCE };
+        struct ethtool_coalesce coalesce = { .cmd = ETHTOOL_GCOALESCE };
 
         if (!dev->ethtool_ops->get_coalesce)
                 return -EOPNOTSUPP;
@@ -470,7 +866,7 @@ static int ethtool_get_coalesce(struct net_device *dev, void __user *useraddr)
         return 0;
 }
 
-static int ethtool_set_coalesce(struct net_device *dev, void __user *useraddr)
+static noinline_for_stack int ethtool_set_coalesce(struct net_device *dev, void __user *useraddr)
 {
         struct ethtool_coalesce coalesce;
 
@@ -485,7 +881,7 @@ static int ethtool_set_coalesce(struct net_device *dev, void __user *useraddr)
 
 static int ethtool_get_ringparam(struct net_device *dev, void __user *useraddr)
 {
-        struct ethtool_ringparam ringparam = { ETHTOOL_GRINGPARAM };
+        struct ethtool_ringparam ringparam = { .cmd = ETHTOOL_GRINGPARAM };
 
         if (!dev->ethtool_ops->get_ringparam)
                 return -EOPNOTSUPP;
@@ -839,7 +1235,7 @@ static int ethtool_get_perm_addr(struct net_device *dev, void __user *useraddr)
 static int ethtool_get_value(struct net_device *dev, char __user *useraddr,
                              u32 cmd, u32 (*actor)(struct net_device *))
 {
-        struct ethtool_value edata = { cmd };
+        struct ethtool_value edata = { .cmd = cmd };
 
         if (!actor)
                 return -EOPNOTSUPP;
@@ -880,7 +1276,7 @@ static int ethtool_set_value(struct net_device *dev, char __user *useraddr,
         return actor(dev, edata.data);
 }
 
-static int ethtool_flash_device(struct net_device *dev, char __user *useraddr)
+static noinline_for_stack int ethtool_flash_device(struct net_device *dev, char __user *useraddr)
 {
         struct ethtool_flash efl;
 
@@ -1113,6 +1509,15 @@ int dev_ethtool(struct net *net, struct ifreq *ifr)
         case ETHTOOL_RESET:
                 rc = ethtool_reset(dev, useraddr);
                 break;
+        case ETHTOOL_SRXNTUPLE:
+                rc = ethtool_set_rx_ntuple(dev, useraddr);
+                break;
+        case ETHTOOL_GRXNTUPLE:
+                rc = ethtool_get_rx_ntuple(dev, useraddr);
+                break;
+        case ETHTOOL_GSSET_INFO:
+                rc = ethtool_get_sset_info(dev, useraddr);
+                break;
         default:
                 rc = -EOPNOTSUPP;
         }