mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-09-05 10:29:37 +00:00
![Vladimir Oltean](/assets/img/avatar_default.png)
There was a sort of rush surrounding commit88c0a6b503
("net: create a netdev notifier for DSA to reject PTP on DSA master"), due to a desire to convert DSA's attempt to deny TX timestamping on a DSA master to something that doesn't block the kernel-wide API conversion from ndo_eth_ioctl() to ndo_hwtstamp_set(). What was required was a mechanism that did not depend on ndo_eth_ioctl(), and what was provided was a mechanism that did not depend on ndo_eth_ioctl(), while at the same time introducing something that wasn't absolutely necessary - a new netdev notifier. There have been objections from Jakub Kicinski that using notifiers in general when they are not absolutely necessary creates complications to the control flow and difficulties to maintainers who look at the code. So there is a desire to not use notifiers. In addition to that, the notifier chain gets called even if there is no DSA in the system and no one is interested in applying any restriction. Take the model of udp_tunnel_nic_ops and introduce a stub mechanism, through which net/core/dev_ioctl.c can call into DSA even when CONFIG_NET_DSA=m. Compared to the code that existed prior to the notifier conversion, aka what was added in commits: -4cfab35667
("net: dsa: Add wrappers for overloaded ndo_ops") -3369afba1e
("net: Call into DSA netdevice_ops wrappers") this is different because we are not overloading any struct net_device_ops of the DSA master anymore, but rather, we are exposing a rather specific functionality which is orthogonal to which API is used to enable it - ndo_eth_ioctl() or ndo_hwtstamp_set(). Also, what is similar is that both approaches use function pointers to get from built-in code to DSA. There is no point in replicating the function pointers towards __dsa_master_hwtstamp_validate() once for every CPU port (dev->dsa_ptr). Instead, it is sufficient to introduce a singleton struct dsa_stubs, built into the kernel, which contains a single function pointer to __dsa_master_hwtstamp_validate(). I find this approach preferable to what we had originally, because dev->dsa_ptr->netdev_ops->ndo_do_ioctl() used to require going through struct dsa_port (dev->dsa_ptr), and so, this was incompatible with any attempts to add any data encapsulation and hide DSA data structures from the outside world. Link: https://lore.kernel.org/netdev/20230403083019.120b72fd@kernel.org/ Signed-off-by: Vladimir Oltean <vladimir.oltean@nxp.com> Reviewed-by: Florian Fainelli <f.fainelli@gmail.com> Signed-off-by: David S. Miller <davem@davemloft.net>
636 lines
14 KiB
C
636 lines
14 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
#include <linux/kmod.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/inetdevice.h>
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/rtnetlink.h>
|
|
#include <linux/net_tstamp.h>
|
|
#include <linux/wireless.h>
|
|
#include <linux/if_bridge.h>
|
|
#include <net/dsa_stubs.h>
|
|
#include <net/wext.h>
|
|
|
|
#include "dev.h"
|
|
|
|
/*
|
|
* Map an interface index to its name (SIOCGIFNAME)
|
|
*/
|
|
|
|
/*
|
|
* We need this ioctl for efficient implementation of the
|
|
* if_indextoname() function required by the IPv6 API. Without
|
|
* it, we would have to search all the interfaces to find a
|
|
* match. --pb
|
|
*/
|
|
|
|
static int dev_ifname(struct net *net, struct ifreq *ifr)
|
|
{
|
|
ifr->ifr_name[IFNAMSIZ-1] = 0;
|
|
return netdev_get_name(net, ifr->ifr_name, ifr->ifr_ifindex);
|
|
}
|
|
|
|
/*
|
|
* Perform a SIOCGIFCONF call. This structure will change
|
|
* size eventually, and there is nothing I can do about it.
|
|
* Thus we will need a 'compatibility mode'.
|
|
*/
|
|
int dev_ifconf(struct net *net, struct ifconf __user *uifc)
|
|
{
|
|
struct net_device *dev;
|
|
void __user *pos;
|
|
size_t size;
|
|
int len, total = 0, done;
|
|
|
|
/* both the ifconf and the ifreq structures are slightly different */
|
|
if (in_compat_syscall()) {
|
|
struct compat_ifconf ifc32;
|
|
|
|
if (copy_from_user(&ifc32, uifc, sizeof(struct compat_ifconf)))
|
|
return -EFAULT;
|
|
|
|
pos = compat_ptr(ifc32.ifcbuf);
|
|
len = ifc32.ifc_len;
|
|
size = sizeof(struct compat_ifreq);
|
|
} else {
|
|
struct ifconf ifc;
|
|
|
|
if (copy_from_user(&ifc, uifc, sizeof(struct ifconf)))
|
|
return -EFAULT;
|
|
|
|
pos = ifc.ifc_buf;
|
|
len = ifc.ifc_len;
|
|
size = sizeof(struct ifreq);
|
|
}
|
|
|
|
/* Loop over the interfaces, and write an info block for each. */
|
|
rtnl_lock();
|
|
for_each_netdev(net, dev) {
|
|
if (!pos)
|
|
done = inet_gifconf(dev, NULL, 0, size);
|
|
else
|
|
done = inet_gifconf(dev, pos + total,
|
|
len - total, size);
|
|
if (done < 0) {
|
|
rtnl_unlock();
|
|
return -EFAULT;
|
|
}
|
|
total += done;
|
|
}
|
|
rtnl_unlock();
|
|
|
|
return put_user(total, &uifc->ifc_len);
|
|
}
|
|
|
|
static int dev_getifmap(struct net_device *dev, struct ifreq *ifr)
|
|
{
|
|
struct ifmap *ifmap = &ifr->ifr_map;
|
|
|
|
if (in_compat_syscall()) {
|
|
struct compat_ifmap *cifmap = (struct compat_ifmap *)ifmap;
|
|
|
|
cifmap->mem_start = dev->mem_start;
|
|
cifmap->mem_end = dev->mem_end;
|
|
cifmap->base_addr = dev->base_addr;
|
|
cifmap->irq = dev->irq;
|
|
cifmap->dma = dev->dma;
|
|
cifmap->port = dev->if_port;
|
|
|
|
return 0;
|
|
}
|
|
|
|
ifmap->mem_start = dev->mem_start;
|
|
ifmap->mem_end = dev->mem_end;
|
|
ifmap->base_addr = dev->base_addr;
|
|
ifmap->irq = dev->irq;
|
|
ifmap->dma = dev->dma;
|
|
ifmap->port = dev->if_port;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int dev_setifmap(struct net_device *dev, struct ifreq *ifr)
|
|
{
|
|
struct compat_ifmap *cifmap = (struct compat_ifmap *)&ifr->ifr_map;
|
|
|
|
if (!dev->netdev_ops->ndo_set_config)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (in_compat_syscall()) {
|
|
struct ifmap ifmap = {
|
|
.mem_start = cifmap->mem_start,
|
|
.mem_end = cifmap->mem_end,
|
|
.base_addr = cifmap->base_addr,
|
|
.irq = cifmap->irq,
|
|
.dma = cifmap->dma,
|
|
.port = cifmap->port,
|
|
};
|
|
|
|
return dev->netdev_ops->ndo_set_config(dev, &ifmap);
|
|
}
|
|
|
|
return dev->netdev_ops->ndo_set_config(dev, &ifr->ifr_map);
|
|
}
|
|
|
|
/*
|
|
* Perform the SIOCxIFxxx calls, inside rcu_read_lock()
|
|
*/
|
|
static int dev_ifsioc_locked(struct net *net, struct ifreq *ifr, unsigned int cmd)
|
|
{
|
|
int err;
|
|
struct net_device *dev = dev_get_by_name_rcu(net, ifr->ifr_name);
|
|
|
|
if (!dev)
|
|
return -ENODEV;
|
|
|
|
switch (cmd) {
|
|
case SIOCGIFFLAGS: /* Get interface flags */
|
|
ifr->ifr_flags = (short) dev_get_flags(dev);
|
|
return 0;
|
|
|
|
case SIOCGIFMETRIC: /* Get the metric on the interface
|
|
(currently unused) */
|
|
ifr->ifr_metric = 0;
|
|
return 0;
|
|
|
|
case SIOCGIFMTU: /* Get the MTU of a device */
|
|
ifr->ifr_mtu = dev->mtu;
|
|
return 0;
|
|
|
|
case SIOCGIFSLAVE:
|
|
err = -EINVAL;
|
|
break;
|
|
|
|
case SIOCGIFMAP:
|
|
return dev_getifmap(dev, ifr);
|
|
|
|
case SIOCGIFINDEX:
|
|
ifr->ifr_ifindex = dev->ifindex;
|
|
return 0;
|
|
|
|
case SIOCGIFTXQLEN:
|
|
ifr->ifr_qlen = dev->tx_queue_len;
|
|
return 0;
|
|
|
|
default:
|
|
/* dev_ioctl() should ensure this case
|
|
* is never reached
|
|
*/
|
|
WARN_ON(1);
|
|
err = -ENOTTY;
|
|
break;
|
|
|
|
}
|
|
return err;
|
|
}
|
|
|
|
static int net_hwtstamp_validate(const struct kernel_hwtstamp_config *cfg)
|
|
{
|
|
enum hwtstamp_tx_types tx_type;
|
|
enum hwtstamp_rx_filters rx_filter;
|
|
int tx_type_valid = 0;
|
|
int rx_filter_valid = 0;
|
|
|
|
if (cfg->flags & ~HWTSTAMP_FLAG_MASK)
|
|
return -EINVAL;
|
|
|
|
tx_type = cfg->tx_type;
|
|
rx_filter = cfg->rx_filter;
|
|
|
|
switch (tx_type) {
|
|
case HWTSTAMP_TX_OFF:
|
|
case HWTSTAMP_TX_ON:
|
|
case HWTSTAMP_TX_ONESTEP_SYNC:
|
|
case HWTSTAMP_TX_ONESTEP_P2P:
|
|
tx_type_valid = 1;
|
|
break;
|
|
case __HWTSTAMP_TX_CNT:
|
|
/* not a real value */
|
|
break;
|
|
}
|
|
|
|
switch (rx_filter) {
|
|
case HWTSTAMP_FILTER_NONE:
|
|
case HWTSTAMP_FILTER_ALL:
|
|
case HWTSTAMP_FILTER_SOME:
|
|
case HWTSTAMP_FILTER_PTP_V1_L4_EVENT:
|
|
case HWTSTAMP_FILTER_PTP_V1_L4_SYNC:
|
|
case HWTSTAMP_FILTER_PTP_V1_L4_DELAY_REQ:
|
|
case HWTSTAMP_FILTER_PTP_V2_L4_EVENT:
|
|
case HWTSTAMP_FILTER_PTP_V2_L4_SYNC:
|
|
case HWTSTAMP_FILTER_PTP_V2_L4_DELAY_REQ:
|
|
case HWTSTAMP_FILTER_PTP_V2_L2_EVENT:
|
|
case HWTSTAMP_FILTER_PTP_V2_L2_SYNC:
|
|
case HWTSTAMP_FILTER_PTP_V2_L2_DELAY_REQ:
|
|
case HWTSTAMP_FILTER_PTP_V2_EVENT:
|
|
case HWTSTAMP_FILTER_PTP_V2_SYNC:
|
|
case HWTSTAMP_FILTER_PTP_V2_DELAY_REQ:
|
|
case HWTSTAMP_FILTER_NTP_ALL:
|
|
rx_filter_valid = 1;
|
|
break;
|
|
case __HWTSTAMP_FILTER_CNT:
|
|
/* not a real value */
|
|
break;
|
|
}
|
|
|
|
if (!tx_type_valid || !rx_filter_valid)
|
|
return -ERANGE;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int dev_eth_ioctl(struct net_device *dev,
|
|
struct ifreq *ifr, unsigned int cmd)
|
|
{
|
|
const struct net_device_ops *ops = dev->netdev_ops;
|
|
|
|
if (!ops->ndo_eth_ioctl)
|
|
return -EOPNOTSUPP;
|
|
|
|
if (!netif_device_present(dev))
|
|
return -ENODEV;
|
|
|
|
return ops->ndo_eth_ioctl(dev, ifr, cmd);
|
|
}
|
|
|
|
static int dev_get_hwtstamp(struct net_device *dev, struct ifreq *ifr)
|
|
{
|
|
return dev_eth_ioctl(dev, ifr, SIOCGHWTSTAMP);
|
|
}
|
|
|
|
static int dev_set_hwtstamp(struct net_device *dev, struct ifreq *ifr)
|
|
{
|
|
struct kernel_hwtstamp_config kernel_cfg;
|
|
struct netlink_ext_ack extack = {};
|
|
struct hwtstamp_config cfg;
|
|
int err;
|
|
|
|
if (copy_from_user(&cfg, ifr->ifr_data, sizeof(cfg)))
|
|
return -EFAULT;
|
|
|
|
hwtstamp_config_to_kernel(&kernel_cfg, &cfg);
|
|
|
|
err = net_hwtstamp_validate(&kernel_cfg);
|
|
if (err)
|
|
return err;
|
|
|
|
err = dsa_master_hwtstamp_validate(dev, &kernel_cfg, &extack);
|
|
if (err) {
|
|
if (extack._msg)
|
|
netdev_err(dev, "%s\n", extack._msg);
|
|
return err;
|
|
}
|
|
|
|
return dev_eth_ioctl(dev, ifr, SIOCSHWTSTAMP);
|
|
}
|
|
|
|
static int dev_siocbond(struct net_device *dev,
|
|
struct ifreq *ifr, unsigned int cmd)
|
|
{
|
|
const struct net_device_ops *ops = dev->netdev_ops;
|
|
|
|
if (ops->ndo_siocbond) {
|
|
if (netif_device_present(dev))
|
|
return ops->ndo_siocbond(dev, ifr, cmd);
|
|
else
|
|
return -ENODEV;
|
|
}
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
static int dev_siocdevprivate(struct net_device *dev, struct ifreq *ifr,
|
|
void __user *data, unsigned int cmd)
|
|
{
|
|
const struct net_device_ops *ops = dev->netdev_ops;
|
|
|
|
if (ops->ndo_siocdevprivate) {
|
|
if (netif_device_present(dev))
|
|
return ops->ndo_siocdevprivate(dev, ifr, data, cmd);
|
|
else
|
|
return -ENODEV;
|
|
}
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
static int dev_siocwandev(struct net_device *dev, struct if_settings *ifs)
|
|
{
|
|
const struct net_device_ops *ops = dev->netdev_ops;
|
|
|
|
if (ops->ndo_siocwandev) {
|
|
if (netif_device_present(dev))
|
|
return ops->ndo_siocwandev(dev, ifs);
|
|
else
|
|
return -ENODEV;
|
|
}
|
|
|
|
return -EOPNOTSUPP;
|
|
}
|
|
|
|
/*
|
|
* Perform the SIOCxIFxxx calls, inside rtnl_lock()
|
|
*/
|
|
static int dev_ifsioc(struct net *net, struct ifreq *ifr, void __user *data,
|
|
unsigned int cmd)
|
|
{
|
|
int err;
|
|
struct net_device *dev = __dev_get_by_name(net, ifr->ifr_name);
|
|
const struct net_device_ops *ops;
|
|
netdevice_tracker dev_tracker;
|
|
|
|
if (!dev)
|
|
return -ENODEV;
|
|
|
|
ops = dev->netdev_ops;
|
|
|
|
switch (cmd) {
|
|
case SIOCSIFFLAGS: /* Set interface flags */
|
|
return dev_change_flags(dev, ifr->ifr_flags, NULL);
|
|
|
|
case SIOCSIFMETRIC: /* Set the metric on the interface
|
|
(currently unused) */
|
|
return -EOPNOTSUPP;
|
|
|
|
case SIOCSIFMTU: /* Set the MTU of a device */
|
|
return dev_set_mtu(dev, ifr->ifr_mtu);
|
|
|
|
case SIOCSIFHWADDR:
|
|
if (dev->addr_len > sizeof(struct sockaddr))
|
|
return -EINVAL;
|
|
return dev_set_mac_address_user(dev, &ifr->ifr_hwaddr, NULL);
|
|
|
|
case SIOCSIFHWBROADCAST:
|
|
if (ifr->ifr_hwaddr.sa_family != dev->type)
|
|
return -EINVAL;
|
|
memcpy(dev->broadcast, ifr->ifr_hwaddr.sa_data,
|
|
min(sizeof(ifr->ifr_hwaddr.sa_data_min),
|
|
(size_t)dev->addr_len));
|
|
call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
|
|
return 0;
|
|
|
|
case SIOCSIFMAP:
|
|
return dev_setifmap(dev, ifr);
|
|
|
|
case SIOCADDMULTI:
|
|
if (!ops->ndo_set_rx_mode ||
|
|
ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
|
|
return -EINVAL;
|
|
if (!netif_device_present(dev))
|
|
return -ENODEV;
|
|
return dev_mc_add_global(dev, ifr->ifr_hwaddr.sa_data);
|
|
|
|
case SIOCDELMULTI:
|
|
if (!ops->ndo_set_rx_mode ||
|
|
ifr->ifr_hwaddr.sa_family != AF_UNSPEC)
|
|
return -EINVAL;
|
|
if (!netif_device_present(dev))
|
|
return -ENODEV;
|
|
return dev_mc_del_global(dev, ifr->ifr_hwaddr.sa_data);
|
|
|
|
case SIOCSIFTXQLEN:
|
|
if (ifr->ifr_qlen < 0)
|
|
return -EINVAL;
|
|
return dev_change_tx_queue_len(dev, ifr->ifr_qlen);
|
|
|
|
case SIOCSIFNAME:
|
|
ifr->ifr_newname[IFNAMSIZ-1] = '\0';
|
|
return dev_change_name(dev, ifr->ifr_newname);
|
|
|
|
case SIOCWANDEV:
|
|
return dev_siocwandev(dev, &ifr->ifr_settings);
|
|
|
|
case SIOCBRADDIF:
|
|
case SIOCBRDELIF:
|
|
if (!netif_device_present(dev))
|
|
return -ENODEV;
|
|
if (!netif_is_bridge_master(dev))
|
|
return -EOPNOTSUPP;
|
|
netdev_hold(dev, &dev_tracker, GFP_KERNEL);
|
|
rtnl_unlock();
|
|
err = br_ioctl_call(net, netdev_priv(dev), cmd, ifr, NULL);
|
|
netdev_put(dev, &dev_tracker);
|
|
rtnl_lock();
|
|
return err;
|
|
|
|
case SIOCDEVPRIVATE ... SIOCDEVPRIVATE + 15:
|
|
return dev_siocdevprivate(dev, ifr, data, cmd);
|
|
|
|
case SIOCSHWTSTAMP:
|
|
return dev_set_hwtstamp(dev, ifr);
|
|
|
|
case SIOCGHWTSTAMP:
|
|
return dev_get_hwtstamp(dev, ifr);
|
|
|
|
case SIOCGMIIPHY:
|
|
case SIOCGMIIREG:
|
|
case SIOCSMIIREG:
|
|
return dev_eth_ioctl(dev, ifr, cmd);
|
|
|
|
case SIOCBONDENSLAVE:
|
|
case SIOCBONDRELEASE:
|
|
case SIOCBONDSETHWADDR:
|
|
case SIOCBONDSLAVEINFOQUERY:
|
|
case SIOCBONDINFOQUERY:
|
|
case SIOCBONDCHANGEACTIVE:
|
|
return dev_siocbond(dev, ifr, cmd);
|
|
|
|
/* Unknown ioctl */
|
|
default:
|
|
err = -EINVAL;
|
|
}
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* dev_load - load a network module
|
|
* @net: the applicable net namespace
|
|
* @name: name of interface
|
|
*
|
|
* If a network interface is not present and the process has suitable
|
|
* privileges this function loads the module. If module loading is not
|
|
* available in this kernel then it becomes a nop.
|
|
*/
|
|
|
|
void dev_load(struct net *net, const char *name)
|
|
{
|
|
struct net_device *dev;
|
|
int no_module;
|
|
|
|
rcu_read_lock();
|
|
dev = dev_get_by_name_rcu(net, name);
|
|
rcu_read_unlock();
|
|
|
|
no_module = !dev;
|
|
if (no_module && capable(CAP_NET_ADMIN))
|
|
no_module = request_module("netdev-%s", name);
|
|
if (no_module && capable(CAP_SYS_MODULE))
|
|
request_module("%s", name);
|
|
}
|
|
EXPORT_SYMBOL(dev_load);
|
|
|
|
/*
|
|
* This function handles all "interface"-type I/O control requests. The actual
|
|
* 'doing' part of this is dev_ifsioc above.
|
|
*/
|
|
|
|
/**
|
|
* dev_ioctl - network device ioctl
|
|
* @net: the applicable net namespace
|
|
* @cmd: command to issue
|
|
* @ifr: pointer to a struct ifreq in user space
|
|
* @data: data exchanged with userspace
|
|
* @need_copyout: whether or not copy_to_user() should be called
|
|
*
|
|
* Issue ioctl functions to devices. This is normally called by the
|
|
* user space syscall interfaces but can sometimes be useful for
|
|
* other purposes. The return value is the return from the syscall if
|
|
* positive or a negative errno code on error.
|
|
*/
|
|
|
|
int dev_ioctl(struct net *net, unsigned int cmd, struct ifreq *ifr,
|
|
void __user *data, bool *need_copyout)
|
|
{
|
|
int ret;
|
|
char *colon;
|
|
|
|
if (need_copyout)
|
|
*need_copyout = true;
|
|
if (cmd == SIOCGIFNAME)
|
|
return dev_ifname(net, ifr);
|
|
|
|
ifr->ifr_name[IFNAMSIZ-1] = 0;
|
|
|
|
colon = strchr(ifr->ifr_name, ':');
|
|
if (colon)
|
|
*colon = 0;
|
|
|
|
/*
|
|
* See which interface the caller is talking about.
|
|
*/
|
|
|
|
switch (cmd) {
|
|
case SIOCGIFHWADDR:
|
|
dev_load(net, ifr->ifr_name);
|
|
ret = dev_get_mac_address(&ifr->ifr_hwaddr, net, ifr->ifr_name);
|
|
if (colon)
|
|
*colon = ':';
|
|
return ret;
|
|
/*
|
|
* These ioctl calls:
|
|
* - can be done by all.
|
|
* - atomic and do not require locking.
|
|
* - return a value
|
|
*/
|
|
case SIOCGIFFLAGS:
|
|
case SIOCGIFMETRIC:
|
|
case SIOCGIFMTU:
|
|
case SIOCGIFSLAVE:
|
|
case SIOCGIFMAP:
|
|
case SIOCGIFINDEX:
|
|
case SIOCGIFTXQLEN:
|
|
dev_load(net, ifr->ifr_name);
|
|
rcu_read_lock();
|
|
ret = dev_ifsioc_locked(net, ifr, cmd);
|
|
rcu_read_unlock();
|
|
if (colon)
|
|
*colon = ':';
|
|
return ret;
|
|
|
|
case SIOCETHTOOL:
|
|
dev_load(net, ifr->ifr_name);
|
|
ret = dev_ethtool(net, ifr, data);
|
|
if (colon)
|
|
*colon = ':';
|
|
return ret;
|
|
|
|
/*
|
|
* These ioctl calls:
|
|
* - require superuser power.
|
|
* - require strict serialization.
|
|
* - return a value
|
|
*/
|
|
case SIOCGMIIPHY:
|
|
case SIOCGMIIREG:
|
|
case SIOCSIFNAME:
|
|
dev_load(net, ifr->ifr_name);
|
|
if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
|
|
return -EPERM;
|
|
rtnl_lock();
|
|
ret = dev_ifsioc(net, ifr, data, cmd);
|
|
rtnl_unlock();
|
|
if (colon)
|
|
*colon = ':';
|
|
return ret;
|
|
|
|
/*
|
|
* These ioctl calls:
|
|
* - require superuser power.
|
|
* - require strict serialization.
|
|
* - do not return a value
|
|
*/
|
|
case SIOCSIFMAP:
|
|
case SIOCSIFTXQLEN:
|
|
if (!capable(CAP_NET_ADMIN))
|
|
return -EPERM;
|
|
fallthrough;
|
|
/*
|
|
* These ioctl calls:
|
|
* - require local superuser power.
|
|
* - require strict serialization.
|
|
* - do not return a value
|
|
*/
|
|
case SIOCSIFFLAGS:
|
|
case SIOCSIFMETRIC:
|
|
case SIOCSIFMTU:
|
|
case SIOCSIFHWADDR:
|
|
case SIOCSIFSLAVE:
|
|
case SIOCADDMULTI:
|
|
case SIOCDELMULTI:
|
|
case SIOCSIFHWBROADCAST:
|
|
case SIOCSMIIREG:
|
|
case SIOCBONDENSLAVE:
|
|
case SIOCBONDRELEASE:
|
|
case SIOCBONDSETHWADDR:
|
|
case SIOCBONDCHANGEACTIVE:
|
|
case SIOCBRADDIF:
|
|
case SIOCBRDELIF:
|
|
case SIOCSHWTSTAMP:
|
|
if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
|
|
return -EPERM;
|
|
fallthrough;
|
|
case SIOCBONDSLAVEINFOQUERY:
|
|
case SIOCBONDINFOQUERY:
|
|
dev_load(net, ifr->ifr_name);
|
|
rtnl_lock();
|
|
ret = dev_ifsioc(net, ifr, data, cmd);
|
|
rtnl_unlock();
|
|
if (need_copyout)
|
|
*need_copyout = false;
|
|
return ret;
|
|
|
|
case SIOCGIFMEM:
|
|
/* Get the per device memory space. We can add this but
|
|
* currently do not support it */
|
|
case SIOCSIFMEM:
|
|
/* Set the per device memory buffer space.
|
|
* Not applicable in our case */
|
|
case SIOCSIFLINK:
|
|
return -ENOTTY;
|
|
|
|
/*
|
|
* Unknown or private ioctl.
|
|
*/
|
|
default:
|
|
if (cmd == SIOCWANDEV ||
|
|
cmd == SIOCGHWTSTAMP ||
|
|
(cmd >= SIOCDEVPRIVATE &&
|
|
cmd <= SIOCDEVPRIVATE + 15)) {
|
|
dev_load(net, ifr->ifr_name);
|
|
rtnl_lock();
|
|
ret = dev_ifsioc(net, ifr, data, cmd);
|
|
rtnl_unlock();
|
|
return ret;
|
|
}
|
|
return -ENOTTY;
|
|
}
|
|
}
|