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