// SPDX-License-Identifier: GPL-2.0-or-later

/*

* net/core/ethtool.c - Ethtool ioctl handler

* Copyright (c) 2003 Matthew Wilcox <matthew@wil.cx>

*

* This file is where we call all the ethtool_ops commands to get

* the information ethtool needs.

*/

#include <linux/compat.h>

#include <linux/etherdevice.h>

#include <linux/module.h>

#include <linux/types.h>

#include <linux/capability.h>

#include <linux/errno.h>

#include <linux/ethtool.h>

#include <linux/netdevice.h>

#include <linux/net_tstamp.h>

#include <linux/phy.h>

#include <linux/bitops.h>

#include <linux/uaccess.h>

#include <linux/vmalloc.h>

#include <linux/sfp.h>

#include <linux/slab.h>

#include <linux/rtnetlink.h>

#include <linux/sched/signal.h>

#include <linux/net.h>

#include <linux/pm_runtime.h>

#include <linux/utsname.h>

#include <linux/ethtool_netlink.h>

#include <net/devlink.h>

#include <net/ipv6.h>

#include <net/flow_offload.h>

#include <net/netdev_lock.h>

#include <net/netdev_queues.h>

#include "common.h"

/* State held across locks and calls for commands which have devlink fallback */

struct ethtool_devlink_compat {

struct devlink *devlink;

union {

struct ethtool_flash efl;

struct ethtool_drvinfo info;

};

};

static struct devlink *netdev_to_devlink_get(struct net_device *dev)

{

if (!dev->devlink_port)

return NULL;

return devlink_try_get(dev->devlink_port->devlink);

}

/*

* Some useful ethtool_ops methods that're device independent.

* If we find that all drivers want to do the same thing here,

* we can turn these into dev_() function calls.

*/

u32 ethtool_op_get_link(struct net_device *dev)

{

/* Synchronize carrier state with link watch, see also rtnl_getlink() */

__linkwatch_sync_dev(dev);

return netif_carrier_ok(dev) ? 1 : 0;

}

EXPORT_SYMBOL(ethtool_op_get_link);

int ethtool_op_get_ts_info(struct net_device *dev,

struct kernel_ethtool_ts_info *info)

{

info->so_timestamping =

SOF_TIMESTAMPING_TX_SOFTWARE |

SOF_TIMESTAMPING_RX_SOFTWARE |

SOF_TIMESTAMPING_SOFTWARE;

info->phc_index = -1;

return 0;

}

EXPORT_SYMBOL(ethtool_op_get_ts_info);

/* Handlers for each ethtool command */

static int ethtool_get_features(struct net_device *dev, void __user *useraddr)

{

struct ethtool_gfeatures cmd = {

.cmd = ETHTOOL_GFEATURES,

.size = ETHTOOL_DEV_FEATURE_WORDS,

};

struct ethtool_get_features_block features[ETHTOOL_DEV_FEATURE_WORDS];

u32 __user *sizeaddr;

u32 copy_size;

int i;

/* in case feature bits run out again */

BUILD_BUG_ON(ETHTOOL_DEV_FEATURE_WORDS * sizeof(u32) > sizeof(netdev_features_t));

for (i = 0; i < ETHTOOL_DEV_FEATURE_WORDS; ++i) {

features[i].available = (u32)(dev->hw_features >> (32 * i));

features[i].requested = (u32)(dev->wanted_features >> (32 * i));

features[i].active = (u32)(dev->features >> (32 * i));

features[i].never_changed =

(u32)(NETIF_F_NEVER_CHANGE >> (32 * i));

}

sizeaddr = useraddr + offsetof(struct ethtool_gfeatures, size);

if (get_user(copy_size, sizeaddr))

return -EFAULT;

if (copy_size > ETHTOOL_DEV_FEATURE_WORDS)

copy_size = ETHTOOL_DEV_FEATURE_WORDS;

if (copy_to_user(useraddr, &cmd, sizeof(cmd)))

return -EFAULT;

useraddr += sizeof(cmd);

if (copy_to_user(useraddr, features,

array_size(copy_size, sizeof(*features))))

return -EFAULT;

return 0;

}

static int ethtool_set_features(struct net_device *dev, void __user *useraddr)

{

struct ethtool_sfeatures cmd;

struct ethtool_set_features_block features[ETHTOOL_DEV_FEATURE_WORDS];

netdev_features_t wanted = 0, valid = 0;

int i, ret = 0;

if (copy_from_user(&cmd, useraddr, sizeof(cmd)))

return -EFAULT;

useraddr += sizeof(cmd);

if (cmd.size != ETHTOOL_DEV_FEATURE_WORDS)

return -EINVAL;

if (copy_from_user(features, useraddr, sizeof(features)))

return -EFAULT;

for (i = 0; i < ETHTOOL_DEV_FEATURE_WORDS; ++i) {

valid |= (netdev_features_t)features[i].valid << (32 * i);

wanted |= (netdev_features_t)features[i].requested << (32 * i);

}

if (valid & ~NETIF_F_ETHTOOL_BITS)

return -EINVAL;

if (valid & ~dev->hw_features) {

valid &= dev->hw_features;

ret |= ETHTOOL_F_UNSUPPORTED;

}

dev->wanted_features &= ~valid;

dev->wanted_features |= wanted & valid;

__netdev_update_features(dev);

if ((dev->wanted_features ^ dev->features) & valid)

ret |= ETHTOOL_F_WISH;

return ret;

}

static int __ethtool_get_sset_count(struct net_device *dev, int sset)

{

const struct ethtool_phy_ops *phy_ops = ethtool_phy_ops;

const struct ethtool_ops *ops = dev->ethtool_ops;

if (sset == ETH_SS_FEATURES)

return ARRAY_SIZE(netdev_features_strings);

if (sset == ETH_SS_RSS_HASH_FUNCS)

return ARRAY_SIZE(rss_hash_func_strings);

if (sset == ETH_SS_TUNABLES)

return ARRAY_SIZE(tunable_strings);

if (sset == ETH_SS_PHY_TUNABLES)

return ARRAY_SIZE(phy_tunable_strings);

if (sset == ETH_SS_PHY_STATS && dev->phydev &&

!ops->get_ethtool_phy_stats &&

phy_ops && phy_ops->get_sset_count)

return phy_ops->get_sset_count(dev->phydev);

if (sset == ETH_SS_LINK_MODES)

return __ETHTOOL_LINK_MODE_MASK_NBITS;

if (ops->get_sset_count && ops->get_strings)

return ops->get_sset_count(dev, sset);

else

return -EOPNOTSUPP;

}

static void __ethtool_get_strings(struct net_device *dev,

u32 stringset, u8 *data)

{

const struct ethtool_phy_ops *phy_ops = ethtool_phy_ops;

const struct ethtool_ops *ops = dev->ethtool_ops;

if (stringset == ETH_SS_FEATURES)

memcpy(data, netdev_features_strings,

sizeof(netdev_features_strings));

else if (stringset == ETH_SS_RSS_HASH_FUNCS)

memcpy(data, rss_hash_func_strings,

sizeof(rss_hash_func_strings));

else if (stringset == ETH_SS_TUNABLES)

memcpy(data, tunable_strings, sizeof(tunable_strings));

else if (stringset == ETH_SS_PHY_TUNABLES)

memcpy(data, phy_tunable_strings, sizeof(phy_tunable_strings));

else if (stringset == ETH_SS_PHY_STATS && dev->phydev &&

!ops->get_ethtool_phy_stats && phy_ops &&

phy_ops->get_strings)

phy_ops->get_strings(dev->phydev, data);

else if (stringset == ETH_SS_LINK_MODES)

memcpy(data, link_mode_names,

__ETHTOOL_LINK_MODE_MASK_NBITS * ETH_GSTRING_LEN);

else

/* ops->get_strings is valid because checked earlier */

ops->get_strings(dev, stringset, data);

}

static netdev_features_t ethtool_get_feature_mask(u32 eth_cmd)

{

/* feature masks of legacy discrete ethtool ops */

switch (eth_cmd) {

case ETHTOOL_GTXCSUM:

case ETHTOOL_STXCSUM:

return NETIF_F_CSUM_MASK | NETIF_F_FCOE_CRC |

NETIF_F_SCTP_CRC;

case ETHTOOL_GRXCSUM:

case ETHTOOL_SRXCSUM:

return NETIF_F_RXCSUM;

case ETHTOOL_GSG:

case ETHTOOL_SSG:

return NETIF_F_SG | NETIF_F_FRAGLIST;

case ETHTOOL_GTSO:

case ETHTOOL_STSO:

return NETIF_F_ALL_TSO;

case ETHTOOL_GGSO:

case ETHTOOL_SGSO:

return NETIF_F_GSO;

case ETHTOOL_GGRO:

case ETHTOOL_SGRO:

return NETIF_F_GRO;

default:

BUG();

}

}

static int ethtool_get_one_feature(struct net_device *dev,

char __user *useraddr, u32 ethcmd)

{

netdev_features_t mask = ethtool_get_feature_mask(ethcmd);

struct ethtool_value edata = {

.cmd = ethcmd,

.data = !!(dev->features & mask),

};

if (copy_to_user(useraddr, &edata, sizeof(edata)))

return -EFAULT;

return 0;

}

static int ethtool_set_one_feature(struct net_device *dev,

void __user *useraddr, u32 ethcmd)

{

struct ethtool_value edata;

netdev_features_t mask;

if (copy_from_user(&edata, useraddr, sizeof(edata)))

return -EFAULT;

mask = ethtool_get_feature_mask(ethcmd);

mask &= dev->hw_features;

if (!mask)

return -EOPNOTSUPP;

if (edata.data)

dev->wanted_features |= mask;

else

dev->wanted_features &= ~mask;

__netdev_update_features(dev);

return 0;

}

#define ETH_ALL_FLAGS (ETH_FLAG_LRO | ETH_FLAG_RXVLAN | ETH_FLAG_TXVLAN | \

ETH_FLAG_NTUPLE | ETH_FLAG_RXHASH)

#define ETH_ALL_FEATURES (NETIF_F_LRO | NETIF_F_HW_VLAN_CTAG_RX | \

NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_NTUPLE | \

NETIF_F_RXHASH)

static u32 __ethtool_get_flags(struct net_device *dev)

{

u32 flags = 0;

if (dev->features & NETIF_F_LRO)

flags |= ETH_FLAG_LRO;

if (dev->features & NETIF_F_HW_VLAN_CTAG_RX)

flags |= ETH_FLAG_RXVLAN;

if (dev->features & NETIF_F_HW_VLAN_CTAG_TX)

flags |= ETH_FLAG_TXVLAN;

if (dev->features & NETIF_F_NTUPLE)

flags |= ETH_FLAG_NTUPLE;

if (dev->features & NETIF_F_RXHASH)

flags |= ETH_FLAG_RXHASH;

return flags;

}

static int __ethtool_set_flags(struct net_device *dev, u32 data)

{

netdev_features_t features = 0, changed;

if (data & ~ETH_ALL_FLAGS)

return -EINVAL;

if (data & ETH_FLAG_LRO)

features |= NETIF_F_LRO;

if (data & ETH_FLAG_RXVLAN)

features |= NETIF_F_HW_VLAN_CTAG_RX;

if (data & ETH_FLAG_TXVLAN)

features |= NETIF_F_HW_VLAN_CTAG_TX;

if (data & ETH_FLAG_NTUPLE)

features |= NETIF_F_NTUPLE;

if (data & ETH_FLAG_RXHASH)

features |= NETIF_F_RXHASH;

/* allow changing only bits set in hw_features */

changed = (features ^ dev->features) & ETH_ALL_FEATURES;

if (changed & ~dev->hw_features)

return (changed & dev->hw_features) ? -EINVAL : -EOPNOTSUPP;

dev->wanted_features =

(dev->wanted_features & ~changed) | (features & changed);

__netdev_update_features(dev);

return 0;

}

/* Given two link masks, AND them together and save the result in dst. */

void ethtool_intersect_link_masks(struct ethtool_link_ksettings *dst,

struct ethtool_link_ksettings *src)

{

unsigned int size = BITS_TO_LONGS(__ETHTOOL_LINK_MODE_MASK_NBITS);

unsigned int idx = 0;

for (; idx < size; idx++) {

dst->link_modes.supported[idx] &=

src->link_modes.supported[idx];

dst->link_modes.advertising[idx] &=

src->link_modes.advertising[idx];

}

}

EXPORT_SYMBOL(ethtool_intersect_link_masks);

void ethtool_convert_legacy_u32_to_link_mode(unsigned long *dst,

u32 legacy_u32)

{

linkmode_zero(dst);

dst[0] = legacy_u32;

}

EXPORT_SYMBOL(ethtool_convert_legacy_u32_to_link_mode);

/* return false if src had higher bits set. lower bits always updated. */

bool ethtool_convert_link_mode_to_legacy_u32(u32 *legacy_u32,

const unsigned long *src)

{

*legacy_u32 = src[0];

return find_next_bit(src, __ETHTOOL_LINK_MODE_MASK_NBITS, 32) ==

__ETHTOOL_LINK_MODE_MASK_NBITS;

}

EXPORT_SYMBOL(ethtool_convert_link_mode_to_legacy_u32);

/* 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 &= ethtool_convert_link_mode_to_legacy_u32(

&legacy_settings->supported,

link_ksettings->link_modes.supported);

retval &= ethtool_convert_link_mode_to_legacy_u32(

&legacy_settings->advertising,

link_ksettings->link_modes.advertising);

retval &= ethtool_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;

legacy_settings->transceiver

= link_ksettings->base.transceiver;

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. */

int __ethtool_get_link_ksettings(struct net_device *dev,

struct ethtool_link_ksettings *link_ksettings)

{

ASSERT_RTNL();

if (!dev->ethtool_ops->get_link_ksettings)

return -EOPNOTSUPP;

if (!netif_device_present(dev))

return -ENODEV;

memset(link_ksettings, 0, sizeof(*link_ksettings));

return dev->ethtool_ops->get_link_ksettings(dev, link_ksettings);

}

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_arr32(to->link_modes.supported,

link_usettings.link_modes.supported,

__ETHTOOL_LINK_MODE_MASK_NBITS);

bitmap_from_arr32(to->link_modes.advertising,

link_usettings.link_modes.advertising,

__ETHTOOL_LINK_MODE_MASK_NBITS);

bitmap_from_arr32(to->link_modes.lp_advertising,

link_usettings.link_modes.lp_advertising,

__ETHTOOL_LINK_MODE_MASK_NBITS);

return 0;

}

/* Check if the user is trying to change anything besides speed/duplex */

bool ethtool_virtdev_validate_cmd(const struct ethtool_link_ksettings *cmd)

{

struct ethtool_link_settings base2 = {};

base2.speed = cmd->base.speed;

base2.port = PORT_OTHER;

base2.duplex = cmd->base.duplex;

base2.cmd = cmd->base.cmd;

base2.link_mode_masks_nwords = cmd->base.link_mode_masks_nwords;

return !memcmp(&base2, &cmd->base, sizeof(base2)) &&

bitmap_empty(cmd->link_modes.supported,

__ETHTOOL_LINK_MODE_MASK_NBITS) &&

bitmap_empty(cmd->link_modes.lp_advertising,

__ETHTOOL_LINK_MODE_MASK_NBITS);

}

/* 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, from, sizeof(link_usettings));

bitmap_to_arr32(link_usettings.link_modes.supported,

from->link_modes.supported,

__ETHTOOL_LINK_MODE_MASK_NBITS);

bitmap_to_arr32(link_usettings.link_modes.advertising,

from->link_modes.advertising,

__ETHTOOL_LINK_MODE_MASK_NBITS);

bitmap_to_arr32(link_usettings.link_modes.lp_advertising,

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. */

static int ethtool_get_link_ksettings(struct net_device *dev,

void __user *useraddr)

{

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));

link_ksettings.base.cmd = ETHTOOL_GLINKSETTINGS;

/* 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

*/

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;

link_ksettings.base.master_slave_cfg = MASTER_SLAVE_CFG_UNSUPPORTED;

link_ksettings.base.master_slave_state = MASTER_SLAVE_STATE_UNSUPPORTED;

link_ksettings.base.rate_matching = RATE_MATCH_NONE;

return store_link_ksettings_for_user(useraddr, &link_ksettings);

}

/* Update device ethtool_link_settings. */

static int ethtool_set_link_ksettings(struct net_device *dev,

void __user *useraddr)

{

struct ethtool_link_ksettings link_ksettings = {};

int err;

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;

if (link_ksettings.base.master_slave_cfg ||

link_ksettings.base.master_slave_state)

return -EINVAL;

err = dev->ethtool_ops->set_link_ksettings(dev, &link_ksettings);

if (err >= 0) {

ethtool_notify(dev, ETHTOOL_MSG_LINKINFO_NTF);

ethtool_notify(dev, ETHTOOL_MSG_LINKMODES_NTF);

}

return err;

}

int ethtool_virtdev_set_link_ksettings(struct net_device *dev,

const struct ethtool_link_ksettings *cmd,

u32 *dev_speed, u8 *dev_duplex)

{

u32 speed;

u8 duplex;

speed = cmd->base.speed;

duplex = cmd->base.duplex;

/* don't allow custom speed and duplex */

if (!ethtool_validate_speed(speed) ||

!ethtool_validate_duplex(duplex) ||

!ethtool_virtdev_validate_cmd(cmd))

return -EINVAL;

*dev_speed = speed;

*dev_duplex = duplex;

return 0;

}

EXPORT_SYMBOL(ethtool_virtdev_set_link_ksettings);

/* Query device for its ethtool_cmd settings.

*

* Backward compatibility note: for compatibility with legacy ethtool, this is

* now implemented via get_link_ksettings. When driver reports 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). Deprecated fields from

* ethtool_cmd (transceiver/maxrxpkt/maxtxpkt) are always set to zero.

*/

static int ethtool_get_settings(struct net_device *dev, void __user *useraddr)

{

struct ethtool_link_ksettings link_ksettings;

struct ethtool_cmd cmd;

int err;

ASSERT_RTNL();

if (!dev->ethtool_ops->get_link_ksettings)

return -EOPNOTSUPP;

if (dev->ethtool->module_fw_flash_in_progress)

return -EBUSY;

memset(&link_ksettings, 0, sizeof(link_ksettings));

err = dev->ethtool_ops->get_link_ksettings(dev, &link_ksettings);

if (err < 0)

return err;

convert_link_ksettings_to_legacy_settings(&cmd, &link_ksettings);

/* send a sensible cmd tag back to user */

cmd.cmd = ETHTOOL_GSET;

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 is

* now always implemented via set_link_settings. When 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_link_ksettings link_ksettings;

struct ethtool_cmd cmd;

int ret;

ASSERT_RTNL();

if (copy_from_user(&cmd, useraddr, sizeof(cmd)))

return -EFAULT;

if (!dev->ethtool_ops->set_link_ksettings)

return -EOPNOTSUPP;

if (!convert_legacy_settings_to_link_ksettings(&link_ksettings, &cmd))

return -EINVAL;

link_ksettings.base.link_mode_masks_nwords =

__ETHTOOL_LINK_MODE_MASK_NU32;

ret = dev->ethtool_ops->set_link_ksettings(dev, &link_ksettings);

if (ret >= 0) {

ethtool_notify(dev, ETHTOOL_MSG_LINKINFO_NTF);

ethtool_notify(dev, ETHTOOL_MSG_LINKMODES_NTF);

}

return ret;

}

static int

ethtool_get_drvinfo(struct net_device *dev, struct ethtool_devlink_compat *rsp)

{

const struct ethtool_ops *ops = dev->ethtool_ops;

struct device *parent = dev->dev.parent;

rsp->info.cmd = ETHTOOL_GDRVINFO;

strscpy(rsp->info.version, init_uts_ns.name.release,

sizeof(rsp->info.version));

if (ops->get_drvinfo) {

ops->get_drvinfo(dev, &rsp->info);

if (!rsp->info.bus_info[0] && parent)

strscpy(rsp->info.bus_info, dev_name(parent),

sizeof(rsp->info.bus_info));

if (!rsp->info.driver[0] && parent && parent->driver)

strscpy(rsp->info.driver, parent->driver->name,

sizeof(rsp->info.driver));

} else if (parent && parent->driver) {

strscpy(rsp->info.bus_info, dev_name(parent),

sizeof(rsp->info.bus_info));

strscpy(rsp->info.driver, parent->driver->name,

sizeof(rsp->info.driver));

} else if (dev->rtnl_link_ops) {

strscpy(rsp->info.driver, dev->rtnl_link_ops->kind,

sizeof(rsp->info.driver));

} else {

return -EOPNOTSUPP;

}

/*

* this method of obtaining string set info is deprecated;

* Use ETHTOOL_GSSET_INFO instead.

*/

if (ops->get_sset_count) {

int rc;

rc = ops->get_sset_count(dev, ETH_SS_TEST);

if (rc >= 0)

rsp->info.testinfo_len = rc;

rc = ops->get_sset_count(dev, ETH_SS_STATS);

if (rc >= 0)

rsp->info.n_stats = rc;

rc = ops->get_sset_count(dev, ETH_SS_PRIV_FLAGS);

if (rc >= 0)

rsp->info.n_priv_flags = rc;

}

if (ops->get_regs_len) {

int ret = ops->get_regs_len(dev);

if (ret > 0)

rsp->info.regdump_len = ret;

}

if (ops->get_eeprom_len)

rsp->info.eedump_len = ops->get_eeprom_len(dev);

if (!rsp->info.fw_version[0])

rsp->devlink = netdev_to_devlink_get(dev);

return 0;

}

static noinline_for_stack int ethtool_get_sset_info(struct net_device *dev,

void __user *useraddr)

{

struct ethtool_sset_info info;

u64 sset_mask;

int i, idx = 0, n_bits = 0, ret, rc;

u32 *info_buf = NULL;

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 = kcalloc(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 = __ethtool_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, array_size(idx, sizeof(u32))))

goto out;

ret = 0;

out:

kfree(info_buf);

return ret;

}

static noinline_for_stack int

ethtool_rxnfc_copy_from_compat(struct ethtool_rxnfc *rxnfc,

const struct compat_ethtool_rxnfc __user *useraddr,

size_t size)

{

struct compat_ethtool_rxnfc crxnfc = {};

/* We expect there to be holes between fs.m_ext and

* fs.ring_cookie and at the end of fs, but nowhere else.

* On non-x86, no conversion should be needed.

*/

BUILD_BUG_ON(!IS_ENABLED(CONFIG_X86_64) &&

sizeof(struct compat_ethtool_rxnfc) !=

sizeof(struct ethtool_rxnfc));

BUILD_BUG_ON(offsetof(struct compat_ethtool_rxnfc, fs.m_ext) +

sizeof(useraddr->fs.m_ext) !=

offsetof(struct ethtool_rxnfc, fs.m_ext) +

sizeof(rxnfc->fs.m_ext));

BUILD_BUG_ON(offsetof(struct compat_ethtool_rxnfc, fs.location) -

offsetof(struct compat_ethtool_rxnfc, fs.ring_cookie) !=

offsetof(struct ethtool_rxnfc, fs.location) -

offsetof(struct ethtool_rxnfc, fs.ring_cookie));

if (copy_from_user(&crxnfc, useraddr, min(size, sizeof(crxnfc))))

return -EFAULT;

*rxnfc = (struct ethtool_rxnfc) {

.cmd = crxnfc.cmd,

.flow_type = crxnfc.flow_type,

.data = crxnfc.data,

.fs = {

.flow_type = crxnfc.fs.flow_type,

.h_u = crxnfc.fs.h_u,

.h_ext = crxnfc.fs.h_ext,

.m_u = crxnfc.fs.m_u,

.m_ext = crxnfc.fs.m_ext,

.ring_cookie = crxnfc.fs.ring_cookie,

.location = crxnfc.fs.location,

},

.rule_cnt = crxnfc.rule_cnt,

};

return 0;

}

static int ethtool_rxnfc_copy_from_user(struct ethtool_rxnfc *rxnfc,

const void __user *useraddr,

size_t size)

{

if (compat_need_64bit_alignment_fixup())

return ethtool_rxnfc_copy_from_compat(rxnfc, useraddr, size);

if (copy_from_user(rxnfc, useraddr, size))

return -EFAULT;

return 0;

}

static int ethtool_rxnfc_copy_to_compat(void __user *useraddr,

const struct ethtool_rxnfc *rxnfc,

size_t size, const u32 *rule_buf)

{

struct compat_ethtool_rxnfc crxnfc;

memset(&crxnfc, 0, sizeof(crxnfc));

crxnfc = (struct compat_ethtool_rxnfc) {

.cmd = rxnfc->cmd,

.flow_type = rxnfc->flow_type,

.data = rxnfc->data,

.fs = {

.flow_type = rxnfc->fs.flow_type,

.h_u = rxnfc->fs.h_u,

.h_ext = rxnfc->fs.h_ext,

.m_u = rxnfc->fs.m_u,

.m_ext = rxnfc->fs.m_ext,

.ring_cookie = rxnfc->fs.ring_cookie,

.location = rxnfc->fs.location,

},

.rule_cnt = rxnfc->rule_cnt,

};

if (copy_to_user(useraddr, &crxnfc, min(size, sizeof(crxnfc))))

return -EFAULT;

return 0;

}

static int ethtool_rxnfc_copy_struct(u32 cmd, struct ethtool_rxnfc *info,

size_t *info_size, void __user *useraddr)

{

/* struct ethtool_rxnfc was originally defined for

* ETHTOOL_{G,S}RXFH with only the cmd, flow_type and data

* members. User-space might still be using that

* definition.

*/

if (cmd == ETHTOOL_GRXFH || cmd == ETHTOOL_SRXFH)

*info_size = (offsetof(struct ethtool_rxnfc, data) +

sizeof(info->data));

if (ethtool_rxnfc_copy_from_user(info, useraddr, *info_size))

return -EFAULT;

if ((cmd == ETHTOOL_GRXFH || cmd == ETHTOOL_SRXFH) && info->flow_type & FLOW_RSS) {

*info_size = sizeof(*info);

if (ethtool_rxnfc_copy_from_user(info, useraddr, *info_size))

return -EFAULT;

/* Since malicious users may modify the original data,

* we need to check whether FLOW_RSS is still requested.

*/

if (!(info->flow_type & FLOW_RSS))

return -EINVAL;

}

if (info->cmd != cmd)

return -EINVAL;

return 0;

}

static int ethtool_rxnfc_copy_to_user(void __user *useraddr,

const struct ethtool_rxnfc *rxnfc,

size_t size, const u32 *rule_buf)

{

int ret;

if (compat_need_64bit_alignment_fixup()) {

ret = ethtool_rxnfc_copy_to_compat(useraddr, rxnfc, size,

rule_buf);

useraddr += offsetof(struct compat_ethtool_rxnfc, rule_locs);

} else {

ret = copy_to_user(useraddr, rxnfc, size);

useraddr += offsetof(struct ethtool_rxnfc, rule_locs);

}

if (ret)

return -EFAULT;

if (rule_buf) {

if (copy_to_user(useraddr, rule_buf,

rxnfc->rule_cnt * sizeof(u32)))

return -EFAULT;

}

return 0;

}

static bool flow_type_hashable(u32 flow_type)

{

switch (flow_type) {

case ETHER_FLOW:

case TCP_V4_FLOW:

case UDP_V4_FLOW:

case SCTP_V4_FLOW:

case AH_ESP_V4_FLOW:

case TCP_V6_FLOW:

case UDP_V6_FLOW:

case SCTP_V6_FLOW:

case AH_ESP_V6_FLOW:

case AH_V4_FLOW:

case ESP_V4_FLOW:

case AH_V6_FLOW:

case ESP_V6_FLOW:

case IPV4_FLOW:

case IPV6_FLOW:

case GTPU_V4_FLOW: