Release 4.11 net/core/net-sysfs.c
/*
* net-sysfs.c - network device class and attributes
*
* Copyright (c) 2003 Stephen Hemminger <shemminger@osdl.org>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*/
#include <linux/capability.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <net/switchdev.h>
#include <linux/if_arp.h>
#include <linux/slab.h>
#include <linux/sched/signal.h>
#include <linux/nsproxy.h>
#include <net/sock.h>
#include <net/net_namespace.h>
#include <linux/rtnetlink.h>
#include <linux/vmalloc.h>
#include <linux/export.h>
#include <linux/jiffies.h>
#include <linux/pm_runtime.h>
#include <linux/of.h>
#include <linux/of_net.h>
#include "net-sysfs.h"
#ifdef CONFIG_SYSFS
static const char fmt_hex[] = "%#x\n";
static const char fmt_dec[] = "%d\n";
static const char fmt_ulong[] = "%lu\n";
static const char fmt_u64[] = "%llu\n";
static inline int dev_isalive(const struct net_device *dev)
{
return dev->reg_state <= NETREG_REGISTERED;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Stephen Hemminger | 20 | 100.00% | 2 | 100.00% |
Total | 20 | 100.00% | 2 | 100.00% |
/* 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;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Stephen Hemminger | 75 | 87.21% | 2 | 50.00% |
Greg Kroah-Hartman | 8 | 9.30% | 1 | 25.00% |
Américo Wang | 3 | 3.49% | 1 | 25.00% |
Total | 86 | 100.00% | 4 | 100.00% |
/* generate a show function for simple field */
#define NETDEVICE_SHOW(field, format_string) \
static ssize_t format_##field(const struct net_device *dev, char *buf) \
{ \
return sprintf(buf, format_string, dev->field); \
} \
static ssize_t field##_show(struct device *dev, \
struct device_attribute *attr, char *buf) \
{ \
return netdev_show(dev, attr, buf, format_##field); \
} \
#define NETDEVICE_SHOW_RO(field, format_string) \
NETDEVICE_SHOW(field, format_string); \
static DEVICE_ATTR_RO(field)
#define NETDEVICE_SHOW_RW(field, format_string) \
NETDEVICE_SHOW(field, format_string); \
static DEVICE_ATTR_RW(field)
/* use same locking and permission rules as SIF* ioctl's */
static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t len,
int (*set)(struct net_device *, unsigned long))
{
struct net_device *netdev = to_net_dev(dev);
struct net *net = dev_net(netdev);
unsigned long new;
int ret = -EINVAL;
if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
return -EPERM;
ret = kstrtoul(buf, 0, &new);
if (ret)
goto err;
if (!rtnl_trylock())
return restart_syscall();
if (dev_isalive(netdev)) {
if ((ret = (*set)(netdev, new)) == 0)
ret = len;
}
rtnl_unlock();
err:
return ret;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Stephen Hemminger | 120 | 78.95% | 4 | 50.00% |
Eric W. Biedermann | 20 | 13.16% | 2 | 25.00% |
Shuah Khan | 6 | 3.95% | 1 | 12.50% |
Greg Kroah-Hartman | 6 | 3.95% | 1 | 12.50% |
Total | 152 | 100.00% | 8 | 100.00% |
NETDEVICE_SHOW_RO(dev_id, fmt_hex);
NETDEVICE_SHOW_RO(dev_port, fmt_dec);
NETDEVICE_SHOW_RO(addr_assign_type, fmt_dec);
NETDEVICE_SHOW_RO(addr_len, fmt_dec);
NETDEVICE_SHOW_RO(ifindex, fmt_dec);
NETDEVICE_SHOW_RO(type, fmt_dec);
NETDEVICE_SHOW_RO(link_mode, fmt_dec);
static ssize_t iflink_show(struct device *dev, struct device_attribute *attr,
char *buf)
{
struct net_device *ndev = to_net_dev(dev);
return sprintf(buf, fmt_dec, dev_get_iflink(ndev));
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Nicolas Dichtel | 40 | 93.02% | 1 | 50.00% |
Stefan Rompf | 3 | 6.98% | 1 | 50.00% |
Total | 43 | 100.00% | 2 | 100.00% |
static DEVICE_ATTR_RO(iflink);
static ssize_t format_name_assign_type(const struct net_device *dev, char *buf)
{
return sprintf(buf, fmt_dec, dev->name_assign_type);
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Tom Gundersen | 26 | 92.86% | 1 | 50.00% |
Américo Wang | 2 | 7.14% | 1 | 50.00% |
Total | 28 | 100.00% | 2 | 100.00% |
static ssize_t name_assign_type_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct net_device *ndev = to_net_dev(dev);
ssize_t ret = -EINVAL;
if (ndev->name_assign_type != NET_NAME_UNKNOWN)
ret = netdev_show(dev, attr, buf, format_name_assign_type);
return ret;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Tom Gundersen | 58 | 96.67% | 1 | 50.00% |
Américo Wang | 2 | 3.33% | 1 | 50.00% |
Total | 60 | 100.00% | 2 | 100.00% |
static DEVICE_ATTR_RO(name_assign_type);
/* 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;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Stephen Hemminger | 61 | 83.56% | 4 | 50.00% |
Greg Kroah-Hartman | 7 | 9.59% | 2 | 25.00% |
Américo Wang | 4 | 5.48% | 1 | 12.50% |
Michael Chan | 1 | 1.37% | 1 | 12.50% |
Total | 73 | 100.00% | 8 | 100.00% |
static DEVICE_ATTR_RO(address);
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;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Stephen Hemminger | 43 | 78.18% | 3 | 42.86% |
Greg Kroah-Hartman | 7 | 12.73% | 2 | 28.57% |
Américo Wang | 4 | 7.27% | 1 | 14.29% |
Michael Chan | 1 | 1.82% | 1 | 14.29% |
Total | 55 | 100.00% | 7 | 100.00% |
static DEVICE_ATTR_RO(broadcast);
static int change_carrier(struct net_device *dev, unsigned long new_carrier)
{
if (!netif_running(dev))
return -EINVAL;
return dev_change_carrier(dev, (bool) new_carrier);
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Jiri Pirko | 35 | 92.11% | 1 | 50.00% |
Américo Wang | 3 | 7.89% | 1 | 50.00% |
Total | 38 | 100.00% | 2 | 100.00% |
static ssize_t carrier_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t len)
{
return netdev_store(dev, attr, buf, len, change_carrier);
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Jiri Pirko | 37 | 97.37% | 1 | 50.00% |
Greg Kroah-Hartman | 1 | 2.63% | 1 | 50.00% |
Total | 38 | 100.00% | 2 | 100.00% |
static ssize_t carrier_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_dev(dev);
if (netif_running(netdev)) {
return sprintf(buf, fmt_dec, !!netif_carrier_ok(netdev));
}
return -EINVAL;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Andrew Morton | 51 | 87.93% | 1 | 33.33% |
Greg Kroah-Hartman | 7 | 12.07% | 2 | 66.67% |
Total | 58 | 100.00% | 3 | 100.00% |
static DEVICE_ATTR_RW(carrier);
static ssize_t speed_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_dev(dev);
int ret = -EINVAL;
if (!rtnl_trylock())
return restart_syscall();
if (netif_running(netdev)) {
struct ethtool_link_ksettings cmd;
if (!__ethtool_get_link_ksettings(netdev, &cmd))
ret = sprintf(buf, fmt_dec, cmd.base.speed);
}
rtnl_unlock();
return ret;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Andy Gospodarek | 83 | 91.21% | 1 | 25.00% |
David Decotigny | 6 | 6.59% | 1 | 25.00% |
Alexander Stein | 1 | 1.10% | 1 | 25.00% |
Greg Kroah-Hartman | 1 | 1.10% | 1 | 25.00% |
Total | 91 | 100.00% | 4 | 100.00% |
static DEVICE_ATTR_RO(speed);
static ssize_t duplex_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_dev(dev);
int ret = -EINVAL;
if (!rtnl_trylock())
return restart_syscall();
if (netif_running(netdev)) {
struct ethtool_link_ksettings cmd;
if (!__ethtool_get_link_ksettings(netdev, &cmd)) {
const char *duplex;
switch (cmd.base.duplex) {
case DUPLEX_HALF:
duplex = "half";
break;
case DUPLEX_FULL:
duplex = "full";
break;
default:
duplex = "unknown";
break;
}
ret = sprintf(buf, "%s\n", duplex);
}
}
rtnl_unlock();
return ret;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Andy Gospodarek | 84 | 66.67% | 1 | 25.00% |
Nikolay Aleksandrov | 37 | 29.37% | 1 | 25.00% |
David Decotigny | 4 | 3.17% | 1 | 25.00% |
Greg Kroah-Hartman | 1 | 0.79% | 1 | 25.00% |
Total | 126 | 100.00% | 4 | 100.00% |
static DEVICE_ATTR_RO(duplex);
static ssize_t dormant_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
struct net_device *netdev = to_net_dev(dev);
if (netif_running(netdev))
return sprintf(buf, fmt_dec, !!netif_dormant(netdev));
return -EINVAL;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Stefan Rompf | 49 | 87.50% | 1 | 33.33% |
Greg Kroah-Hartman | 7 | 12.50% | 2 | 66.67% |
Total | 56 | 100.00% | 3 | 100.00% |
static DEVICE_ATTR_RO(dormant);
static const char *const operstates[] = {
"unknown",
"notpresent", /* currently unused */
"down",
"lowerlayerdown",
"testing", /* currently unused */
"dormant",
"up"
};
static ssize_t operstate_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
const struct net_device *netdev = to_net_dev(dev);
unsigned char operstate;
read_lock(&dev_base_lock);
operstate = netdev->operstate;
if (!netif_running(netdev))
operstate = IF_OPER_DOWN;
read_unlock(&dev_base_lock);
if (operstate >= ARRAY_SIZE(operstates))
return -EINVAL; /* should not happen */
return sprintf(buf, "%s\n", operstates[operstate]);
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Stefan Rompf | 84 | 91.30% | 1 | 25.00% |
Greg Kroah-Hartman | 7 | 7.61% | 2 | 50.00% |
Adrian Bunk | 1 | 1.09% | 1 | 25.00% |
Total | 92 | 100.00% | 4 | 100.00% |
static DEVICE_ATTR_RO(operstate);
static ssize_t carrier_changes_show(struct device *dev,
struct device_attribute *attr,
char *buf)
{
struct net_device *netdev = to_net_dev(dev);
return sprintf(buf, fmt_dec,
atomic_read(&netdev->carrier_changes));
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
David Decotigny | 46 | 100.00% | 1 | 100.00% |
Total | 46 | 100.00% | 1 | 100.00% |
static DEVICE_ATTR_RO(carrier_changes);
/* read-write attributes */
static int change_mtu(struct net_device *dev, unsigned long new_mtu)
{
return dev_set_mtu(dev, (int) new_mtu);
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Stephen Hemminger | 24 | 92.31% | 1 | 50.00% |
Américo Wang | 2 | 7.69% | 1 | 50.00% |
Total | 26 | 100.00% | 2 | 100.00% |
static ssize_t mtu_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t len)
{
return netdev_store(dev, attr, buf, len, change_mtu);
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Stephen Hemminger | 29 | 76.32% | 2 | 50.00% |
Greg Kroah-Hartman | 9 | 23.68% | 2 | 50.00% |
Total | 38 | 100.00% | 4 | 100.00% |
NETDEVICE_SHOW_RW(mtu, fmt_dec);
static int change_flags(struct net_device *dev, unsigned long new_flags)
{
return dev_change_flags(dev, (unsigned int) new_flags);
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Stephen Hemminger | 24 | 88.89% | 1 | 33.33% |
Américo Wang | 2 | 7.41% | 1 | 33.33% |
Eric Dumazet | 1 | 3.70% | 1 | 33.33% |
Total | 27 | 100.00% | 3 | 100.00% |
static ssize_t flags_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t len)
{
return netdev_store(dev, attr, buf, len, change_flags);
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Stephen Hemminger | 29 | 76.32% | 2 | 50.00% |
Greg Kroah-Hartman | 9 | 23.68% | 2 | 50.00% |
Total | 38 | 100.00% | 4 | 100.00% |
NETDEVICE_SHOW_RW(flags, fmt_hex);
static int change_tx_queue_len(struct net_device *dev, unsigned long new_len)
{
int res, orig_len = dev->tx_queue_len;
if (new_len != orig_len) {
dev->tx_queue_len = new_len;
res = call_netdevice_notifiers(NETDEV_CHANGE_TX_QUEUE_LEN, dev);
res = notifier_to_errno(res);
if (res) {
netdev_err(dev,
"refused to change device tx_queue_len\n");
dev->tx_queue_len = orig_len;
return -EFAULT;
}
}
return 0;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Jason (Hui) Wang | 56 | 70.00% | 1 | 25.00% |
Stephen Hemminger | 22 | 27.50% | 2 | 50.00% |
Américo Wang | 2 | 2.50% | 1 | 25.00% |
Total | 80 | 100.00% | 4 | 100.00% |
static ssize_t tx_queue_len_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
{
if (!capable(CAP_NET_ADMIN))
return -EPERM;
return netdev_store(dev, attr, buf, len, change_tx_queue_len);
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Stephen Hemminger | 29 | 58.00% | 1 | 25.00% |
Eric W. Biedermann | 12 | 24.00% | 1 | 25.00% |
Greg Kroah-Hartman | 9 | 18.00% | 2 | 50.00% |
Total | 50 | 100.00% | 4 | 100.00% |
NETDEVICE_SHOW_RW(tx_queue_len, fmt_ulong);
static int change_gro_flush_timeout(struct net_device *dev, unsigned long val)
{
dev->gro_flush_timeout = val;
return 0;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Eric Dumazet | 24 | 100.00% | 1 | 100.00% |
Total | 24 | 100.00% | 1 | 100.00% |
static ssize_t gro_flush_timeout_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
{
if (!capable(CAP_NET_ADMIN))
return -EPERM;
return netdev_store(dev, attr, buf, len, change_gro_flush_timeout);
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Eric Dumazet | 50 | 100.00% | 1 | 100.00% |
Total | 50 | 100.00% | 1 | 100.00% |
NETDEVICE_SHOW_RW(gro_flush_timeout, fmt_ulong);
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;
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();
ret = dev_set_alias(netdev, buf, count);
rtnl_unlock();
return ret < 0 ? ret : len;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Stephen Hemminger | 95 | 79.17% | 1 | 25.00% |
Eric W. Biedermann | 24 | 20.00% | 2 | 50.00% |
Greg Kroah-Hartman | 1 | 0.83% | 1 | 25.00% |
Total | 120 | 100.00% | 4 | 100.00% |
static ssize_t ifalias_show(struct device *dev,
struct device_attribute *attr, char *buf)
{
const struct net_device *netdev = to_net_dev(dev);
ssize_t ret = 0;
if (!rtnl_trylock())
return restart_syscall();
if (netdev->ifalias)
ret = sprintf(buf, "%s\n", netdev->ifalias);
rtnl_unlock();
return ret;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Stephen Hemminger | 61 | 85.92% | 1 | 33.33% |
Eric W. Biedermann | 9 | 12.68% | 1 | 33.33% |
Greg Kroah-Hartman | 1 | 1.41% | 1 | 33.33% |
Total | 71 | 100.00% | 3 | 100.00% |
static DEVICE_ATTR_RW(ifalias);
static int change_group(struct net_device *dev, unsigned long new_group)
{
dev_set_group(dev, (int) new_group);
return 0;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Vlad Dogaru | 26 | 92.86% | 1 | 50.00% |
Américo Wang | 2 | 7.14% | 1 | 50.00% |
Total | 28 | 100.00% | 2 | 100.00% |
static ssize_t group_store(struct device *dev, struct device_attribute *attr,
const char *buf, size_t len)
{
return netdev_store(dev, attr, buf, len, change_group);
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Vlad Dogaru | 37 | 97.37% | 1 | 50.00% |
Greg Kroah-Hartman | 1 | 2.63% | 1 | 50.00% |
Total | 38 | 100.00% | 2 | 100.00% |
NETDEVICE_SHOW(group, fmt_dec);
static DEVICE_ATTR(netdev_group, S_IRUGO | S_IWUSR, group_show, group_store);
static int change_proto_down(struct net_device *dev, unsigned long proto_down)
{
return dev_change_proto_down(dev, (bool) proto_down);
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Anuradha Karuppiah | 26 | 100.00% | 1 | 100.00% |
Total | 26 | 100.00% | 1 | 100.00% |
static ssize_t proto_down_store(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t len)
{
return netdev_store(dev, attr, buf, len, change_proto_down);
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Anuradha Karuppiah | 38 | 100.00% | 1 | 100.00% |
Total | 38 | 100.00% | 1 | 100.00% |
NETDEVICE_SHOW_RW(proto_down, fmt_dec);
static ssize_t phys_port_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_phys_port_id(netdev, &ppid);
if (!ret)
ret = sprintf(buf, "%*phN\n", ppid.id_len, ppid.id);
}
rtnl_unlock();
return ret;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Jiri Pirko | 96 | 98.97% | 2 | 66.67% |
Linus Torvalds | 1 | 1.03% | 1 | 33.33% |
Total | 97 | 100.00% | 3 | 100.00% |
static DEVICE_ATTR_RO(phys_port_id);
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;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
David Ahern | 97 | 100.00% | 1 | 100.00% |
Total | 97 | 100.00% | 1 | 100.00% |
static DEVICE_ATTR_RO(phys_port_name);
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 switchdev_attr attr = {
.orig_dev = netdev,
.id = SWITCHDEV_ATTR_ID_PORT_PARENT_ID,
.flags = SWITCHDEV_F_NO_RECURSE,
};
ret = switchdev_port_attr_get(netdev, &attr);
if (!ret)
ret = sprintf(buf, "%*phN\n", attr.u.ppid.id_len,
attr.u.ppid.id);
}
rtnl_unlock();
return ret;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Jiri Pirko | 94 | 77.05% | 2 | 40.00% |
Scott Feldman | 23 | 18.85% | 2 | 40.00% |
Ido Schimmel | 5 | 4.10% | 1 | 20.00% |
Total | 122 | 100.00% | 5 | 100.00% |
static DEVICE_ATTR_RO(phys_switch_id);
static struct attribute *net_class_attrs[] = {
&dev_attr_netdev_group.attr,
&dev_attr_type.attr,
&dev_attr_dev_id.attr,
&dev_attr_dev_port.attr,
&dev_attr_iflink.attr,
&dev_attr_ifindex.attr,
&dev_attr_name_assign_type.attr,
&dev_attr_addr_assign_type.attr,
&dev_attr_addr_len.attr,
&dev_attr_link_mode.attr,
&dev_attr_address.attr,
&dev_attr_broadcast.attr,
&dev_attr_speed.attr,
&dev_attr_duplex.attr,
&dev_attr_dormant.attr,
&dev_attr_operstate.attr,
&dev_attr_carrier_changes.attr,
&dev_attr_ifalias.attr,
&dev_attr_carrier.attr,
&dev_attr_mtu.attr,
&dev_attr_flags.attr,
&dev_attr_tx_queue_len.attr,
&dev_attr_gro_flush_timeout.attr,
&dev_attr_phys_port_id.attr,
&dev_attr_phys_port_name.attr,
&dev_attr_phys_switch_id.attr,
&dev_attr_proto_down.attr,
NULL,
};
ATTRIBUTE_GROUPS(net_class);
/* 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;
}
Contributors
Person | Tokens | Prop | Commits | CommitProp |
Stephen Hemminger | 101 | 78.29% | 3 | 37.50% |
Ben Hutchings | 8 | 6.20% | 1 | 12.50% |
Greg Kroah-Hartman | 8 | 6.20% | 1 | 12.50% |
Eric Dumazet | 7 | 5.43% | 1 | 12.50% |
Pavel Emelyanov | 5 | 3.88% | 2 | 25.00% |
Total | 129 | 100.00% | 8 | 100.00% |
/* generate a read-only statistics attribute */
#define NETSTAT_ENTRY(name) \
static ssize_t name##_show(struct device *d, \
struct device_attribute *attr, char *buf) \
{ \
return netstat_show(d, attr, buf, \
offsetof(struct rtnl_link_stats64, name)); \
} \
static DEVICE_ATTR_RO(name)
NETSTAT_ENTRY(rx_packets);
NETSTAT_ENTRY(tx_packets);
NETSTAT_ENTRY(rx_bytes);
NETSTAT_ENTRY(tx_bytes);
NETSTAT_ENTRY(rx_errors);
NETSTAT_ENTRY(tx_errors);
NETSTAT_ENTRY(rx_dropped);
NETSTAT_ENTRY(tx_dropped);
NETSTAT_ENTRY(multicast);
NETSTAT_ENTRY(collisions);
NETSTAT_ENTRY(rx_length_errors);
NETSTAT_ENTRY(rx_over_errors);
NETSTAT_ENTRY(rx_crc_errors);
NETSTAT_ENTRY(rx_frame_errors);
NETSTAT_ENTRY(rx_fifo_errors);
NETSTAT_ENTRY(rx_missed_errors);
NETSTAT_ENTRY(tx_aborted_errors);
NETSTAT_ENTRY(tx_carrier_errors);
NETSTAT_ENTRY(tx_fifo_errors);
NETSTAT_ENTRY(tx_heartbeat_errors);
NETSTAT_ENTRY(tx_window_errors);
NETSTAT_ENTRY(rx_compressed);
NETSTAT_ENTRY(tx_compressed);
NETSTAT_ENTRY(rx_nohandler);
static struct attribute *netstat_attrs[] = {
&dev_attr_rx_packets.attr,
&dev_attr_tx_packets.attr,
&dev_attr_rx_bytes.attr,
&dev_attr_tx_bytes.attr,
&dev_attr_rx_errors.attr,
&dev_attr_tx_errors.attr,
&dev_attr_rx_dropped.attr,
&dev_attr_tx_dropped.attr,
&dev_attr_multicast.attr,
&dev_attr_collisions.attr,
&dev_attr_rx_length_errors.attr,
&dev_attr_rx_over_errors.attr,
&dev_attr_rx_crc_errors.attr,
&dev_attr_rx_frame_errors.attr,
&dev_attr_rx_fifo_errors.attr,
&dev_attr_rx_missed_errors.attr,
&dev_attr_tx_aborted_errors.attr,
&dev_attr_tx_carrier_errors.attr,
&dev_attr_tx_fifo_errors.attr,
&dev_attr_tx_heartbeat_errors.attr,
&dev_attr_tx_window_errors.attr,
&dev_attr_rx_compressed.attr,
&dev_attr_tx_compressed.attr,
&dev_attr_rx_nohandler.attr,
NULL
};
static struct attribute_group netstat_group = {
.name = "statistics",
.attrs = netstat_attrs,
};
#if IS_ENABLED(CONFIG_WIRELESS_EXT