Merge branch 'ethtool-ksettings'

David Decotigny says:

====================
new ETHTOOL_GLINKSETTINGS/SLINKSETTINGS API

History:
 v9
 - add 'link' in macro, struct and function names
 - rename ethtool_link_ksettings::parent -> ::base
 - remove un-needed mlx4 en_dbg_enabled() companion patch
 - note: bitmap u32[] API patches were merged separately by Kan Liang
 v8
 - bitmap u32 API returns number of bits copied, unit tests updated
 v7
 - module_exit in test_bitmap
 v6
 - fix copy_from_user in user/kernel handshake
 v5
 note: please see v4 bullets for a question regarding bitmap.c
 - minor fix to make allyesconfig/allmodconfig
 v4
 - removed typedef for link mode bitmaps
 - moved bitmap<->u32[] conversion routines to bitmap.c . This is the
   naive implementation. I have an endian-aware version that uses
   memcpy/memset as much as possible, but I find it harder to follow
   (see http://paste.ubuntu.com/13863722/). Please let me know if I
   should use it instead.
 - fixes suggested by Ben Hutchings
 v3
 - rebased v2 on top of latest net-next, minor checkpatch/printf %*pb
   updates
 v2
 - keep return 0 in get_settings when successful, instead of
   propagating positive result from driver's get_settings callback.
 v1
 - original submission

The main goal of this series is to support ethtool link mode masks
larger than 32 bits. It implements a new ioctl pair
(ETHTOOL_GLINKSETTINGS/SLINKSETTINGS), its associated callbacks
(get/set_link_ksettings) and a new struct ethtool_link_settings, which
should eventually replace legacy ethtool_cmd. Internally, the kernel
uses fixed length link mode masks defined at compilation time in
ethtool.h (for now: 31 bits), that can be increased by changing
__ETHTOOL_LINK_MODE_LAST in ethtool.h (absolute max is 4064 bits,
checked at compile time), and the user/kernel interface allows this
length to be arbitrary within 1..4064. This should allow some
flexibility without using too much heap/stack space, at the cost of a
small kernel/user handshake for the user to determine the sizes of
those bitmaps.

Along the way, I chose to drop in the new structure the 3 ethtool_cmd
fields marked "deprecated" (transceiver/maxrxpkt/maxtxpkt). They are
still available for old drivers via the (old) ETHTOOL_GSET/SSET API,
but are not available to drivers that switch to new API. Of those 3
fields, ethtool_cmd::transceiver seems to be still actively used by
several drivers, maybe we should not consider this field deprecated?
The 2 other fields are basically not used. This transition requires
some care in the way old and new ethtool talk to the kernel.

More technical details provided in the description for main patch. In
particular details about backward compatibility properties.

Some open questions:
 - the kernel/interface multiplexes the "tell me the bitmap length"
   handshake and the "give me the settings" inside the new
   ETHTOOL_GLINKSETTINGS cmd. I was thinking of making this into 2
   separate cmds: 1 cmd ETHTOOL_GKERNELPROPERTIES which would be
   kernel-wide rather than device-specific, would return properties
   like "length of the link mode bitmaps", and possibly others. And
   ETHTOOL_GLINKSETTINGS would expect the proper bitmaps
 - the link mode bitmaps are piggybacked at tail of the new struct
   ethtool_link_settings. Since its user-visible definition does not
   assume specific bitmap width, I am using a 0-length array as the
   publicly visible placeholder. But then, the kernel needs to
   specialize it (struct ethtool_link_ksettings) to specify its
   current link mode masks. This means that kernel code is "littered"
   with "ksettings->base.field" to access "field" inside
   ethtool_settings:
   + I could use ethtool_link_settings everywhere (instead of a new
     ethtool_ksettings) and an container_of accessor (or a plain cast)
     to retrieve the link mode masks?
   + or: we could decide to make the link mode masks statically
     bounded again, ie. make their width public, but larger than
     current 32, and unchangeable forever. This would make everything
     straightforward, but we might hit limits later, or have an
     unneeded memory/stack usage for unused bits.
   any preference?
 - I foresee bugs where people use the legacy/deprecated SUPPORTED_x
   macros instead of the new ETHTOOL_LINK_MODE_x_BIT enums in the new
   get/set_link_ksettings callbacks. Not sure how to prevent problems
   with this.

The only driver which was converted for now is mlx4. I am not
considering fcoe as fully converted, but I updated it a minima to be
able to remove __ethtool_get_settings, now known as
__ethtool_get_link_ksettings.

Tested with legacy and "future" ethtool on 64b x86 kernel and 32+64b
ethtool, and on a 32b x86 kernel + 32b ethtool.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>

5 files changed, 456 insertions, 30 deletions

diff --git a/net/8021q/vlan_dev.c b/net/8021q/vlan_dev.c
index 055f0e989e90..e416a4038a12 100644
--- a/net/8021q/vlan_dev.c
+++ b/net/8021q/vlan_dev.c
@@ -621,12 +621,12 @@ static netdev_features_t vlan_dev_fix_features(struct net_device *dev,
         return features;
 }
 
-static int vlan_ethtool_get_settings(struct net_device *dev,
-                                     struct ethtool_cmd *cmd)
+static int vlan_ethtool_get_link_ksettings(struct net_device *dev,
+                                           struct ethtool_link_ksettings *cmd)
 {
         const struct vlan_dev_priv *vlan = vlan_dev_priv(dev);
 
-        return __ethtool_get_settings(vlan->real_dev, cmd);
+        return __ethtool_get_link_ksettings(vlan->real_dev, cmd);
 }
 
 static void vlan_ethtool_get_drvinfo(struct net_device *dev,
@@ -741,7 +741,7 @@ static int vlan_dev_get_iflink(const struct net_device *dev)
 }
 
 static const struct ethtool_ops vlan_ethtool_ops = {
-        .get_settings           = vlan_ethtool_get_settings,
+        .get_link_ksettings     = vlan_ethtool_get_link_ksettings,
         .get_drvinfo            = vlan_ethtool_get_drvinfo,
         .get_link               = ethtool_op_get_link,
         .get_ts_info            = vlan_ethtool_get_ts_info,
diff --git a/net/bridge/br_if.c b/net/bridge/br_if.c
index c367b3e1b5ac..b37a1cc97d98 100644
--- a/net/bridge/br_if.c
+++ b/net/bridge/br_if.c
@@ -36,10 +36,10 @@
  */
 static int port_cost(struct net_device *dev)
 {
-        struct ethtool_cmd ecmd;
+        struct ethtool_link_ksettings ecmd;
 
-        if (!__ethtool_get_settings(dev, &ecmd)) {
-                switch (ethtool_cmd_speed(&ecmd)) {
+        if (!__ethtool_get_link_ksettings(dev, &ecmd)) {
+                switch (ecmd.base.speed) {
                 case SPEED_10000:
                         return 2;
                 case SPEED_1000:
diff --git a/net/core/ethtool.c b/net/core/ethtool.c
index 2406101002b1..2966cd0d7c93 100644
--- a/net/core/ethtool.c
+++ b/net/core/ethtool.c
@@ -387,43 +387,461 @@ static int __ethtool_set_flags(struct net_device *dev, u32 data)
         return 0;
 }
 
-int __ethtool_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
+static void convert_legacy_u32_to_link_mode(unsigned long *dst, u32 legacy_u32)
 {
+        bitmap_zero(dst, __ETHTOOL_LINK_MODE_MASK_NBITS);
+        dst[0] = legacy_u32;
+}
+
+/* return false if src had higher bits set. lower bits always updated. */
+static bool convert_link_mode_to_legacy_u32(u32 *legacy_u32,
+                                            const unsigned long *src)
+{
+        bool retval = true;
+
+        /* TODO: following test will soon always be true */
+        if (__ETHTOOL_LINK_MODE_MASK_NBITS > 32) {
+                __ETHTOOL_DECLARE_LINK_MODE_MASK(ext);
+
+                bitmap_zero(ext, __ETHTOOL_LINK_MODE_MASK_NBITS);
+                bitmap_fill(ext, 32);
+                bitmap_complement(ext, ext, __ETHTOOL_LINK_MODE_MASK_NBITS);
+                if (bitmap_intersects(ext, src,
+                                      __ETHTOOL_LINK_MODE_MASK_NBITS)) {
+                        /* src mask goes beyond bit 31 */
+                        retval = false;
+                }
+        }
+        *legacy_u32 = src[0];
+        return retval;
+}
+
+/* return false if legacy contained non-0 deprecated fields
+ * transceiver/maxtxpkt/maxrxpkt. rest of ksettings always updated
+ */
+static bool
+convert_legacy_settings_to_link_ksettings(
+        struct ethtool_link_ksettings *link_ksettings,
+        const struct ethtool_cmd *legacy_settings)
+{
+        bool retval = true;
+
+        memset(link_ksettings, 0, sizeof(*link_ksettings));
+
+        /* This is used to tell users that driver is still using these
+         * deprecated legacy fields, and they should not use
+         * %ETHTOOL_GLINKSETTINGS/%ETHTOOL_SLINKSETTINGS
+         */
+        if (legacy_settings->transceiver ||
+            legacy_settings->maxtxpkt ||
+            legacy_settings->maxrxpkt)
+                retval = false;
+
+        convert_legacy_u32_to_link_mode(
+                link_ksettings->link_modes.supported,
+                legacy_settings->supported);
+        convert_legacy_u32_to_link_mode(
+                link_ksettings->link_modes.advertising,
+                legacy_settings->advertising);
+        convert_legacy_u32_to_link_mode(
+                link_ksettings->link_modes.lp_advertising,
+                legacy_settings->lp_advertising);
+        link_ksettings->base.speed
+                = ethtool_cmd_speed(legacy_settings);
+        link_ksettings->base.duplex
+                = legacy_settings->duplex;
+        link_ksettings->base.port
+                = legacy_settings->port;
+        link_ksettings->base.phy_address
+                = legacy_settings->phy_address;
+        link_ksettings->base.autoneg
+                = legacy_settings->autoneg;
+        link_ksettings->base.mdio_support
+                = legacy_settings->mdio_support;
+        link_ksettings->base.eth_tp_mdix
+                = legacy_settings->eth_tp_mdix;
+        link_ksettings->base.eth_tp_mdix_ctrl
+                = legacy_settings->eth_tp_mdix_ctrl;
+        return retval;
+}
+
+/* return false if ksettings link modes had higher bits
+ * set. legacy_settings always updated (best effort)
+ */
+static bool
+convert_link_ksettings_to_legacy_settings(
+        struct ethtool_cmd *legacy_settings,
+        const struct ethtool_link_ksettings *link_ksettings)
+{
+        bool retval = true;
+
+        memset(legacy_settings, 0, sizeof(*legacy_settings));
+        /* this also clears the deprecated fields in legacy structure:
+         * __u8         transceiver;
+         * __u32        maxtxpkt;
+         * __u32        maxrxpkt;
+         */
+
+        retval &= convert_link_mode_to_legacy_u32(
+                &legacy_settings->supported,
+                link_ksettings->link_modes.supported);
+        retval &= convert_link_mode_to_legacy_u32(
+                &legacy_settings->advertising,
+                link_ksettings->link_modes.advertising);
+        retval &= convert_link_mode_to_legacy_u32(
+                &legacy_settings->lp_advertising,
+                link_ksettings->link_modes.lp_advertising);
+        ethtool_cmd_speed_set(legacy_settings, link_ksettings->base.speed);
+        legacy_settings->duplex
+                = link_ksettings->base.duplex;
+        legacy_settings->port
+                = link_ksettings->base.port;
+        legacy_settings->phy_address
+                = link_ksettings->base.phy_address;
+        legacy_settings->autoneg
+                = link_ksettings->base.autoneg;
+        legacy_settings->mdio_support
+                = link_ksettings->base.mdio_support;
+        legacy_settings->eth_tp_mdix
+                = link_ksettings->base.eth_tp_mdix;
+        legacy_settings->eth_tp_mdix_ctrl
+                = link_ksettings->base.eth_tp_mdix_ctrl;
+        return retval;
+}
+
+/* number of 32-bit words to store the user's link mode bitmaps */
+#define __ETHTOOL_LINK_MODE_MASK_NU32                   \
+        DIV_ROUND_UP(__ETHTOOL_LINK_MODE_MASK_NBITS, 32)
+
+/* layout of the struct passed from/to userland */
+struct ethtool_link_usettings {
+        struct ethtool_link_settings base;
+        struct {
+                __u32 supported[__ETHTOOL_LINK_MODE_MASK_NU32];
+                __u32 advertising[__ETHTOOL_LINK_MODE_MASK_NU32];
+                __u32 lp_advertising[__ETHTOOL_LINK_MODE_MASK_NU32];
+        } link_modes;
+};
+
+/* Internal kernel helper to query a device ethtool_link_settings.
+ *
+ * Backward compatibility note: for compatibility with legacy drivers
+ * that implement only the ethtool_cmd API, this has to work with both
+ * drivers implementing get_link_ksettings API and drivers
+ * implementing get_settings API. When drivers implement get_settings
+ * and report ethtool_cmd deprecated fields
+ * (transceiver/maxrxpkt/maxtxpkt), these fields are silently ignored
+ * because the resulting struct ethtool_link_settings does not report them.
+ */
+int __ethtool_get_link_ksettings(struct net_device *dev,
+                                 struct ethtool_link_ksettings *link_ksettings)
+{
+        int err;
+        struct ethtool_cmd cmd;
+
         ASSERT_RTNL();
 
+        if (dev->ethtool_ops->get_link_ksettings) {
+                memset(link_ksettings, 0, sizeof(*link_ksettings));
+                return dev->ethtool_ops->get_link_ksettings(dev,
+                                                            link_ksettings);
+        }
+
+        /* driver doesn't support %ethtool_link_ksettings API. revert to
+         * legacy %ethtool_cmd API, unless it's not supported either.
+         * TODO: remove when ethtool_ops::get_settings disappears internally
+         */
         if (!dev->ethtool_ops->get_settings)
                 return -EOPNOTSUPP;
 
-        memset(cmd, 0, sizeof(struct ethtool_cmd));
-        cmd->cmd = ETHTOOL_GSET;
-        return dev->ethtool_ops->get_settings(dev, cmd);
+        memset(&cmd, 0, sizeof(cmd));
+        cmd.cmd = ETHTOOL_GSET;
+        err = dev->ethtool_ops->get_settings(dev, &cmd);
+        if (err < 0)
+                return err;
+
+        /* we ignore deprecated fields transceiver/maxrxpkt/maxtxpkt
+         */
+        convert_legacy_settings_to_link_ksettings(link_ksettings, &cmd);
+        return err;
+}
+EXPORT_SYMBOL(__ethtool_get_link_ksettings);
+
+/* convert ethtool_link_usettings in user space to a kernel internal
+ * ethtool_link_ksettings. return 0 on success, errno on error.
+ */
+static int load_link_ksettings_from_user(struct ethtool_link_ksettings *to,
+                                         const void __user *from)
+{
+        struct ethtool_link_usettings link_usettings;
+
+        if (copy_from_user(&link_usettings, from, sizeof(link_usettings)))
+                return -EFAULT;
+
+        memcpy(&to->base, &link_usettings.base, sizeof(to->base));
+        bitmap_from_u32array(to->link_modes.supported,
+                             __ETHTOOL_LINK_MODE_MASK_NBITS,
+                             link_usettings.link_modes.supported,
+                             __ETHTOOL_LINK_MODE_MASK_NU32);
+        bitmap_from_u32array(to->link_modes.advertising,
+                             __ETHTOOL_LINK_MODE_MASK_NBITS,
+                             link_usettings.link_modes.advertising,
+                             __ETHTOOL_LINK_MODE_MASK_NU32);
+        bitmap_from_u32array(to->link_modes.lp_advertising,
+                             __ETHTOOL_LINK_MODE_MASK_NBITS,
+                             link_usettings.link_modes.lp_advertising,
+                             __ETHTOOL_LINK_MODE_MASK_NU32);
+
+        return 0;
 }
-EXPORT_SYMBOL(__ethtool_get_settings);
 
-static int ethtool_get_settings(struct net_device *dev, void __user *useraddr)
+/* convert a kernel internal ethtool_link_ksettings to
+ * ethtool_link_usettings in user space. return 0 on success, errno on
+ * error.
+ */
+static int
+store_link_ksettings_for_user(void __user *to,
+                              const struct ethtool_link_ksettings *from)
+{
+        struct ethtool_link_usettings link_usettings;
+
+        memcpy(&link_usettings.base, &from->base, sizeof(link_usettings));
+        bitmap_to_u32array(link_usettings.link_modes.supported,
+                           __ETHTOOL_LINK_MODE_MASK_NU32,
+                           from->link_modes.supported,
+                           __ETHTOOL_LINK_MODE_MASK_NBITS);
+        bitmap_to_u32array(link_usettings.link_modes.advertising,
+                           __ETHTOOL_LINK_MODE_MASK_NU32,
+                           from->link_modes.advertising,
+                           __ETHTOOL_LINK_MODE_MASK_NBITS);
+        bitmap_to_u32array(link_usettings.link_modes.lp_advertising,
+                           __ETHTOOL_LINK_MODE_MASK_NU32,
+                           from->link_modes.lp_advertising,
+                           __ETHTOOL_LINK_MODE_MASK_NBITS);
+
+        if (copy_to_user(to, &link_usettings, sizeof(link_usettings)))
+                return -EFAULT;
+
+        return 0;
+}
+
+/* Query device for its ethtool_link_settings.
+ *
+ * Backward compatibility note: this function must fail when driver
+ * does not implement ethtool::get_link_ksettings, even if legacy
+ * ethtool_ops::get_settings is implemented. This tells new versions
+ * of ethtool that they should use the legacy API %ETHTOOL_GSET for
+ * this driver, so that they can correctly access the ethtool_cmd
+ * deprecated fields (transceiver/maxrxpkt/maxtxpkt), until no driver
+ * implements ethtool_ops::get_settings anymore.
+ */
+static int ethtool_get_link_ksettings(struct net_device *dev,
+                                      void __user *useraddr)
 {
-        int err;
-        struct ethtool_cmd cmd;
+        int err = 0;
+        struct ethtool_link_ksettings link_ksettings;
+
+        ASSERT_RTNL();
+
+        if (!dev->ethtool_ops->get_link_ksettings)
+                return -EOPNOTSUPP;
+
+        /* handle bitmap nbits handshake */
+        if (copy_from_user(&link_ksettings.base, useraddr,
+                           sizeof(link_ksettings.base)))
+                return -EFAULT;
+
+        if (__ETHTOOL_LINK_MODE_MASK_NU32
+            != link_ksettings.base.link_mode_masks_nwords) {
+                /* wrong link mode nbits requested */
+                memset(&link_ksettings, 0, sizeof(link_ksettings));
+                /* keep cmd field reset to 0 */
+                /* send back number of words required as negative val */
+                compiletime_assert(__ETHTOOL_LINK_MODE_MASK_NU32 <= S8_MAX,
+                                   "need too many bits for link modes!");
+                link_ksettings.base.link_mode_masks_nwords
+                        = -((s8)__ETHTOOL_LINK_MODE_MASK_NU32);
+
+                /* copy the base fields back to user, not the link
+                 * mode bitmaps
+                 */
+                if (copy_to_user(useraddr, &link_ksettings.base,
+                                 sizeof(link_ksettings.base)))
+                        return -EFAULT;
+
+                return 0;
+        }
+
+        /* handshake successful: user/kernel agree on
+         * link_mode_masks_nwords
+         */
 
-        err = __ethtool_get_settings(dev, &cmd);
+        memset(&link_ksettings, 0, sizeof(link_ksettings));
+        err = dev->ethtool_ops->get_link_ksettings(dev, &link_ksettings);
         if (err < 0)
                 return err;
 
+        /* make sure we tell the right values to user */
+        link_ksettings.base.cmd = ETHTOOL_GLINKSETTINGS;
+        link_ksettings.base.link_mode_masks_nwords
+                = __ETHTOOL_LINK_MODE_MASK_NU32;
+
+        return store_link_ksettings_for_user(useraddr, &link_ksettings);
+}
+
+/* Update device ethtool_link_settings.
+ *
+ * Backward compatibility note: this function must fail when driver
+ * does not implement ethtool::set_link_ksettings, even if legacy
+ * ethtool_ops::set_settings is implemented. This tells new versions
+ * of ethtool that they should use the legacy API %ETHTOOL_SSET for
+ * this driver, so that they can correctly update the ethtool_cmd
+ * deprecated fields (transceiver/maxrxpkt/maxtxpkt), until no driver
+ * implements ethtool_ops::get_settings anymore.
+ */
+static int ethtool_set_link_ksettings(struct net_device *dev,
+                                      void __user *useraddr)
+{
+        int err;
+        struct ethtool_link_ksettings link_ksettings;
+
+        ASSERT_RTNL();
+
+        if (!dev->ethtool_ops->set_link_ksettings)
+                return -EOPNOTSUPP;
+
+        /* make sure nbits field has expected value */
+        if (copy_from_user(&link_ksettings.base, useraddr,
+                           sizeof(link_ksettings.base)))
+                return -EFAULT;
+
+        if (__ETHTOOL_LINK_MODE_MASK_NU32
+            != link_ksettings.base.link_mode_masks_nwords)
+                return -EINVAL;
+
+        /* copy the whole structure, now that we know it has expected
+         * format
+         */
+        err = load_link_ksettings_from_user(&link_ksettings, useraddr);
+        if (err)
+                return err;
+
+        /* re-check nwords field, just in case */
+        if (__ETHTOOL_LINK_MODE_MASK_NU32
+            != link_ksettings.base.link_mode_masks_nwords)
+                return -EINVAL;
+
+        return dev->ethtool_ops->set_link_ksettings(dev, &link_ksettings);
+}
+
+static void
+warn_incomplete_ethtool_legacy_settings_conversion(const char *details)
+{
+        char name[sizeof(current->comm)];
+
+        pr_info_once("warning: `%s' uses legacy ethtool link settings API, %s\n",
+                     get_task_comm(name, current), details);
+}
+
+/* Query device for its ethtool_cmd settings.
+ *
+ * Backward compatibility note: for compatibility with legacy ethtool,
+ * this has to work with both drivers implementing get_link_ksettings
+ * API and drivers implementing get_settings API. When drivers
+ * implement get_link_ksettings and report higher link mode bits, a
+ * kernel warning is logged once (with name of 1st driver/device) to
+ * recommend user to upgrade ethtool, but the command is successful
+ * (only the lower link mode bits reported back to user).
+ */
+static int ethtool_get_settings(struct net_device *dev, void __user *useraddr)
+{
+        struct ethtool_cmd cmd;
+
+        ASSERT_RTNL();
+
+        if (dev->ethtool_ops->get_link_ksettings) {
+                /* First, use link_ksettings API if it is supported */
+                int err;
+                struct ethtool_link_ksettings link_ksettings;
+
+                memset(&link_ksettings, 0, sizeof(link_ksettings));
+                err = dev->ethtool_ops->get_link_ksettings(dev,
+                                                           &link_ksettings);
+                if (err < 0)
+                        return err;
+                if (!convert_link_ksettings_to_legacy_settings(&cmd,
+                                                               &link_ksettings))
+                        warn_incomplete_ethtool_legacy_settings_conversion(
+                                "link modes are only partially reported");
+
+                /* send a sensible cmd tag back to user */
+                cmd.cmd = ETHTOOL_GSET;
+        } else {
+                /* driver doesn't support %ethtool_link_ksettings
+                 * API. revert to legacy %ethtool_cmd API, unless it's
+                 * not supported either.
+                 */
+                int err;
+
+                if (!dev->ethtool_ops->get_settings)
+                        return -EOPNOTSUPP;
+
+                memset(&cmd, 0, sizeof(cmd));
+                cmd.cmd = ETHTOOL_GSET;
+                err = dev->ethtool_ops->get_settings(dev, &cmd);
+                if (err < 0)
+                        return err;
+        }
+
         if (copy_to_user(useraddr, &cmd, sizeof(cmd)))
                 return -EFAULT;
+
         return 0;
 }
 
+/* Update device link settings with given ethtool_cmd.
+ *
+ * Backward compatibility note: for compatibility with legacy ethtool,
+ * this has to work with both drivers implementing set_link_ksettings
+ * API and drivers implementing set_settings API. When drivers
+ * implement set_link_ksettings and user's request updates deprecated
+ * ethtool_cmd fields (transceiver/maxrxpkt/maxtxpkt), a kernel
+ * warning is logged once (with name of 1st driver/device) to
+ * recommend user to upgrade ethtool, and the request is rejected.
+ */
 static int ethtool_set_settings(struct net_device *dev, void __user *useraddr)
 {
         struct ethtool_cmd cmd;
 
-        if (!dev->ethtool_ops->set_settings)
-                return -EOPNOTSUPP;
+        ASSERT_RTNL();
 
         if (copy_from_user(&cmd, useraddr, sizeof(cmd)))
                 return -EFAULT;
 
+        /* first, try new %ethtool_link_ksettings API. */
+        if (dev->ethtool_ops->set_link_ksettings) {
+                struct ethtool_link_ksettings link_ksettings;
+
+                if (!convert_legacy_settings_to_link_ksettings(&link_ksettings,
+                                                               &cmd))
+                        return -EINVAL;
+
+                link_ksettings.base.cmd = ETHTOOL_SLINKSETTINGS;
+                link_ksettings.base.link_mode_masks_nwords
+                        = __ETHTOOL_LINK_MODE_MASK_NU32;
+                return dev->ethtool_ops->set_link_ksettings(dev,
+                                                            &link_ksettings);
+        }
+
+        /* legacy %ethtool_cmd API */
+
+        /* TODO: return -EOPNOTSUPP when ethtool_ops::get_settings
+         * disappears internally
+         */
+
+        if (!dev->ethtool_ops->set_settings)
+                return -EOPNOTSUPP;
+
         return dev->ethtool_ops->set_settings(dev, &cmd);
 }
 
@@ -2252,6 +2670,12 @@ int dev_ethtool(struct net *net, struct ifreq *ifr)
         case ETHTOOL_PERQUEUE:
                 rc = ethtool_set_per_queue(dev, useraddr);
                 break;
+        case ETHTOOL_GLINKSETTINGS:
+                rc = ethtool_get_link_ksettings(dev, useraddr);
+                break;
+        case ETHTOOL_SLINKSETTINGS:
+                rc = ethtool_set_link_ksettings(dev, useraddr);
+                break;
         default:
                 rc = -EOPNOTSUPP;
         }
diff --git a/net/core/net-sysfs.c b/net/core/net-sysfs.c
index 4ae17c3166fc..2b3f76fe65f4 100644
--- a/net/core/net-sysfs.c
+++ b/net/core/net-sysfs.c
@@ -198,9 +198,10 @@ static ssize_t speed_show(struct device *dev,
                 return restart_syscall();
 
         if (netif_running(netdev)) {
-                struct ethtool_cmd cmd;
-                if (!__ethtool_get_settings(netdev, &cmd))
-                        ret = sprintf(buf, fmt_dec, ethtool_cmd_speed(&cmd));
+                struct ethtool_link_ksettings cmd;
+
+                if (!__ethtool_get_link_ksettings(netdev, &cmd))
+                        ret = sprintf(buf, fmt_dec, cmd.base.speed);
         }
         rtnl_unlock();
         return ret;
@@ -217,10 +218,12 @@ static ssize_t duplex_show(struct device *dev,
                 return restart_syscall();
 
         if (netif_running(netdev)) {
-                struct ethtool_cmd cmd;
-                if (!__ethtool_get_settings(netdev, &cmd)) {
+                struct ethtool_link_ksettings cmd;
+
+                if (!__ethtool_get_link_ksettings(netdev, &cmd)) {
                         const char *duplex;
-                        switch (cmd.duplex) {
+
+                        switch (cmd.base.duplex) {
                         case DUPLEX_HALF:
                                 duplex = "half";
                                 break;
diff --git a/net/packet/af_packet.c b/net/packet/af_packet.c
index b7e7851ddc5d..d41b1074cb2d 100644
--- a/net/packet/af_packet.c
+++ b/net/packet/af_packet.c
@@ -557,9 +557,8 @@ static int prb_calc_retire_blk_tmo(struct packet_sock *po,
 {
         struct net_device *dev;
         unsigned int mbits = 0, msec = 0, div = 0, tmo = 0;
-        struct ethtool_cmd ecmd;
+        struct ethtool_link_ksettings ecmd;
         int err;
-        u32 speed;
 
         rtnl_lock();
         dev = __dev_get_by_index(sock_net(&po->sk), po->ifindex);
@@ -567,19 +566,19 @@ static int prb_calc_retire_blk_tmo(struct packet_sock *po,
                 rtnl_unlock();
                 return DEFAULT_PRB_RETIRE_TOV;
         }
-        err = __ethtool_get_settings(dev, &ecmd);
-        speed = ethtool_cmd_speed(&ecmd);
+        err = __ethtool_get_link_ksettings(dev, &ecmd);
         rtnl_unlock();
         if (!err) {
                 /*
                  * If the link speed is so slow you don't really
                  * need to worry about perf anyways
                  */
-                if (speed < SPEED_1000 || speed == SPEED_UNKNOWN) {
+                if (ecmd.base.speed < SPEED_1000 ||
+                    ecmd.base.speed == SPEED_UNKNOWN) {
                         return DEFAULT_PRB_RETIRE_TOV;
                 } else {
                         msec = 1;
-                        div = speed / 1000;
+                        div = ecmd.base.speed / 1000;
                 }
         }