static ssize_t ifalias_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t len)
{
struct net_device *netdev = to_net_dev(dev);
struct net *net = dev_net(netdev);
size_t count = len;
ssize_t ret = 0;
if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
return -EPERM;
/* ignore trailing newline */
if (len > 0 && buf[len - 1] == '\n')
--count;
if (!rtnl_trylock())
return restart_syscall();
if (dev_isalive(netdev)) {
ret = dev_set_alias(netdev, buf, count);
if (ret < 0)
goto err;
ret = len;
netdev_state_change(netdev);
}
err:
rtnl_unlock();
return ret;
}
static ssize_t broadcast_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *ndev = to_net_dev(dev);
if (dev_isalive(ndev))
return sysfs_format_mac(buf, ndev->broadcast, ndev->addr_len);
return -EINVAL;
}
/* use same locking rules as GIFHWADDR ioctl's */
static ssize_t address_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct net_device *ndev = to_net_dev(dev);
ssize_t ret = -EINVAL;
read_lock(&dev_base_lock);
if (dev_isalive(ndev))
ret = sysfs_format_mac(buf, ndev->dev_addr, ndev->addr_len);
read_unlock(&dev_base_lock);
return ret;
}
/* use same locking rules as GIF* ioctl's */
static ssize_t netdev_show(const struct device *dev,
struct device_attribute *attr, char *buf,
ssize_t (*format)(const struct net_device *, char *))
{
struct net_device *ndev = to_net_dev(dev);
ssize_t ret = -EINVAL;
read_lock(&dev_base_lock);
if (dev_isalive(ndev))
ret = (*format)(ndev, buf);
read_unlock(&dev_base_lock);
return ret;
}
/* Show a given an attribute in the statistics group */
static ssize_t netstat_show(const struct device *d,
struct device_attribute *attr, char *buf,
unsigned long offset)
{
struct net_device *dev = to_net_dev(d);
ssize_t ret = -EINVAL;
WARN_ON(offset > sizeof(struct rtnl_link_stats64) ||
offset % sizeof(u64) != 0);
read_lock(&dev_base_lock);
if (dev_isalive(dev)) {
struct rtnl_link_stats64 temp;
const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);
ret = sprintf(buf, fmt_u64, *(u64 *)(((u8 *)stats) + offset));
}
read_unlock(&dev_base_lock);
return ret;
}
static ssize_t phys_switch_id_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_dev(dev);
ssize_t ret = -EINVAL;
if (!rtnl_trylock())
return restart_syscall();
if (dev_isalive(netdev)) {
struct netdev_phys_item_id ppid = { };
ret = dev_get_port_parent_id(netdev, &ppid, false);
if (!ret)
ret = sprintf(buf, "%*phN\n", ppid.id_len, ppid.id);
}
rtnl_unlock();
return ret;
}
static ssize_t phys_port_name_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_dev(dev);
ssize_t ret = -EINVAL;
if (!rtnl_trylock())
return restart_syscall();
if (dev_isalive(netdev)) {
char name[IFNAMSIZ];
ret = dev_get_phys_port_name(netdev, name, sizeof(name));
if (!ret)
ret = sprintf(buf, "%s\n", name);
}
rtnl_unlock();
return ret;
}
/*
* empirically even if tallies are defined as 32 bits entities, only
* high 16 bits are relevant; low half is always zero. It means tallies
* are pretty much useless for traffic counting but at least give overview
* about where error come from
*/
static ssize_t show_tallies(struct device *d, struct device_attribute *attr,
char *buf)
{
struct net_device *dev = to_net_dev(d);
struct wl_private *lp = wl_priv(dev);
unsigned long flags;
CFG_HERMES_TALLIES_STRCT tallies;
ssize_t ret = -EINVAL;
rcu_read_lock();
if (dev_isalive(dev)) {
wl_lock(lp, &flags);
ret = wl_get_tallies(lp, &tallies);
if (ret == 0) {
wl_unlock(lp, &flags);
ret = snprintf(buf, PAGE_SIZE,
"TxUnicastFrames: %u\n"
"TxMulticastFrames: %u\n"
"TxFragments: %u\n"
"TxUnicastOctets: %u\n"
"TxMulticastOctets: %u\n"
"TxDeferredTransmissions: %u\n"
"TxSingleRetryFrames: %u\n"
"TxMultipleRetryFrames: %u\n"
"TxRetryLimitExceeded: %u\n"
"TxDiscards: %u\n"
"RxUnicastFrames: %u\n"
"RxMulticastFrames: %u\n"
"RxFragments: %u\n"
"RxUnicastOctets: %u\n"
"RxMulticastOctets: %u\n"
"RxFCSErrors: %u\n"
"RxDiscardsNoBuffer: %u\n"
"TxDiscardsWrongSA: %u\n"
"RxWEPUndecryptable: %u\n"
"RxMsgInMsgFragments: %u\n"
"RxMsgInBadMsgFragments: %u\n"
"RxDiscardsWEPICVError: %u\n"
"RxDiscardsWEPExcluded: %u\n"
,
(unsigned int)tallies.TxUnicastFrames,
(unsigned int)tallies.TxMulticastFrames,
(unsigned int)tallies.TxFragments,
(unsigned int)tallies.TxUnicastOctets,
(unsigned int)tallies.TxMulticastOctets,
(unsigned int)tallies.TxDeferredTransmissions,
(unsigned int)tallies.TxSingleRetryFrames,
(unsigned int)tallies.TxMultipleRetryFrames,
(unsigned int)tallies.TxRetryLimitExceeded,
(unsigned int)tallies.TxDiscards,
(unsigned int)tallies.RxUnicastFrames,
(unsigned int)tallies.RxMulticastFrames,
(unsigned int)tallies.RxFragments,
(unsigned int)tallies.RxUnicastOctets,
(unsigned int)tallies.RxMulticastOctets,
(unsigned int)tallies.RxFCSErrors,
(unsigned int)tallies.RxDiscardsNoBuffer,
(unsigned int)tallies.TxDiscardsWrongSA,
(unsigned int)tallies.RxWEPUndecryptable,
(unsigned int)tallies.RxMsgInMsgFragments,
(unsigned int)tallies.RxMsgInBadMsgFragments,
(unsigned int)tallies.RxDiscardsWEPICVError,
(unsigned int)tallies.RxDiscardsWEPExcluded);
} else {
wl_unlock( lp, &flags );
}
}
rcu_read_unlock();
return ret;
}