blob: b6c8a6629b397134f5ea539adb7ef8ba80625225 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * net-sysfs.c - network device class and attributes
3 *
4 * Copyright (c) 2003 Stephen Hemminger <shemminger@osdl.org>
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09005 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
10 */
11
Randy Dunlap4fc268d2006-01-11 12:17:47 -080012#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#include <linux/kernel.h>
14#include <linux/netdevice.h>
Jiri Pirkoaecbe012014-11-28 14:34:19 +010015#include <net/switchdev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070016#include <linux/if_arp.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090017#include <linux/slab.h>
Eric W. Biederman608b4b92010-05-04 17:36:45 -070018#include <linux/nsproxy.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070019#include <net/sock.h>
Eric W. Biederman608b4b92010-05-04 17:36:45 -070020#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070021#include <linux/rtnetlink.h>
Tom Herbertfec5e652010-04-16 16:01:27 -070022#include <linux/vmalloc.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040023#include <linux/export.h>
Tom Herbert114cf582011-11-28 16:33:09 +000024#include <linux/jiffies.h>
Ming Lei9802c8e2013-02-22 16:34:16 -080025#include <linux/pm_runtime.h>
Florian Fainelliaa836df2015-03-09 14:31:20 -070026#include <linux/of.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027
Pavel Emelyanov342709e2007-10-23 21:14:45 -070028#include "net-sysfs.h"
29
Eric W. Biederman8b41d182007-09-26 22:02:53 -070030#ifdef CONFIG_SYSFS
Linus Torvalds1da177e2005-04-16 15:20:36 -070031static const char fmt_hex[] = "%#x\n";
David S. Millerd1102b52005-05-29 20:28:25 -070032static const char fmt_long_hex[] = "%#lx\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -070033static const char fmt_dec[] = "%d\n";
34static const char fmt_ulong[] = "%lu\n";
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +000035static const char fmt_u64[] = "%llu\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -070036
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +090037static inline int dev_isalive(const struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070038{
Stephen Hemmingerfe9925b2006-05-06 17:56:03 -070039 return dev->reg_state <= NETREG_REGISTERED;
Linus Torvalds1da177e2005-04-16 15:20:36 -070040}
41
42/* use same locking rules as GIF* ioctl's */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070043static ssize_t netdev_show(const struct device *dev,
44 struct device_attribute *attr, char *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -070045 ssize_t (*format)(const struct net_device *, char *))
46{
WANG Cong6b53daf2014-07-23 16:09:10 -070047 struct net_device *ndev = to_net_dev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 ssize_t ret = -EINVAL;
49
50 read_lock(&dev_base_lock);
WANG Cong6b53daf2014-07-23 16:09:10 -070051 if (dev_isalive(ndev))
52 ret = (*format)(ndev, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 read_unlock(&dev_base_lock);
54
55 return ret;
56}
57
58/* generate a show function for simple field */
59#define NETDEVICE_SHOW(field, format_string) \
WANG Cong6b53daf2014-07-23 16:09:10 -070060static ssize_t format_##field(const struct net_device *dev, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -070061{ \
WANG Cong6b53daf2014-07-23 16:09:10 -070062 return sprintf(buf, format_string, dev->field); \
Linus Torvalds1da177e2005-04-16 15:20:36 -070063} \
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -070064static ssize_t field##_show(struct device *dev, \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070065 struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -070066{ \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070067 return netdev_show(dev, attr, buf, format_##field); \
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -070068} \
Linus Torvalds1da177e2005-04-16 15:20:36 -070069
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -070070#define NETDEVICE_SHOW_RO(field, format_string) \
71NETDEVICE_SHOW(field, format_string); \
72static DEVICE_ATTR_RO(field)
73
74#define NETDEVICE_SHOW_RW(field, format_string) \
75NETDEVICE_SHOW(field, format_string); \
76static DEVICE_ATTR_RW(field)
Linus Torvalds1da177e2005-04-16 15:20:36 -070077
78/* use same locking and permission rules as SIF* ioctl's */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070079static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -070080 const char *buf, size_t len,
81 int (*set)(struct net_device *, unsigned long))
82{
Eric W. Biederman5e1fccc2012-11-16 03:03:04 +000083 struct net_device *netdev = to_net_dev(dev);
84 struct net *net = dev_net(netdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 unsigned long new;
86 int ret = -EINVAL;
87
Eric W. Biederman5e1fccc2012-11-16 03:03:04 +000088 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -070089 return -EPERM;
90
Shuah Khane1e420c2012-04-12 09:28:13 +000091 ret = kstrtoul(buf, 0, &new);
92 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -070093 goto err;
94
Stephen Hemminger5a5990d2009-02-26 06:49:24 +000095 if (!rtnl_trylock())
Eric W. Biederman336ca572009-05-13 16:57:25 +000096 return restart_syscall();
Stephen Hemminger5a5990d2009-02-26 06:49:24 +000097
Eric W. Biederman5e1fccc2012-11-16 03:03:04 +000098 if (dev_isalive(netdev)) {
99 if ((ret = (*set)(netdev, new)) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 ret = len;
101 }
102 rtnl_unlock();
103 err:
104 return ret;
105}
106
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700107NETDEVICE_SHOW_RO(dev_id, fmt_hex);
Amir Vadai3f859442014-02-25 18:17:50 +0200108NETDEVICE_SHOW_RO(dev_port, fmt_dec);
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700109NETDEVICE_SHOW_RO(addr_assign_type, fmt_dec);
110NETDEVICE_SHOW_RO(addr_len, fmt_dec);
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700111NETDEVICE_SHOW_RO(ifindex, fmt_dec);
112NETDEVICE_SHOW_RO(type, fmt_dec);
113NETDEVICE_SHOW_RO(link_mode, fmt_dec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114
Nicolas Dichtela54acb32015-04-02 17:07:00 +0200115static ssize_t iflink_show(struct device *dev, struct device_attribute *attr,
116 char *buf)
117{
118 struct net_device *ndev = to_net_dev(dev);
119
120 return sprintf(buf, fmt_dec, dev_get_iflink(ndev));
121}
122static DEVICE_ATTR_RO(iflink);
123
WANG Cong6b53daf2014-07-23 16:09:10 -0700124static ssize_t format_name_assign_type(const struct net_device *dev, char *buf)
Tom Gundersen685343f2014-07-14 16:37:22 +0200125{
WANG Cong6b53daf2014-07-23 16:09:10 -0700126 return sprintf(buf, fmt_dec, dev->name_assign_type);
Tom Gundersen685343f2014-07-14 16:37:22 +0200127}
128
129static ssize_t name_assign_type_show(struct device *dev,
130 struct device_attribute *attr,
131 char *buf)
132{
WANG Cong6b53daf2014-07-23 16:09:10 -0700133 struct net_device *ndev = to_net_dev(dev);
Tom Gundersen685343f2014-07-14 16:37:22 +0200134 ssize_t ret = -EINVAL;
135
WANG Cong6b53daf2014-07-23 16:09:10 -0700136 if (ndev->name_assign_type != NET_NAME_UNKNOWN)
Tom Gundersen685343f2014-07-14 16:37:22 +0200137 ret = netdev_show(dev, attr, buf, format_name_assign_type);
138
139 return ret;
140}
141static DEVICE_ATTR_RO(name_assign_type);
142
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143/* use same locking rules as GIFHWADDR ioctl's */
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700144static ssize_t address_show(struct device *dev, struct device_attribute *attr,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700145 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146{
WANG Cong6b53daf2014-07-23 16:09:10 -0700147 struct net_device *ndev = to_net_dev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148 ssize_t ret = -EINVAL;
149
150 read_lock(&dev_base_lock);
WANG Cong6b53daf2014-07-23 16:09:10 -0700151 if (dev_isalive(ndev))
152 ret = sysfs_format_mac(buf, ndev->dev_addr, ndev->addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153 read_unlock(&dev_base_lock);
154 return ret;
155}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700156static DEVICE_ATTR_RO(address);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700158static ssize_t broadcast_show(struct device *dev,
159 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700160{
WANG Cong6b53daf2014-07-23 16:09:10 -0700161 struct net_device *ndev = to_net_dev(dev);
162 if (dev_isalive(ndev))
163 return sysfs_format_mac(buf, ndev->broadcast, ndev->addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164 return -EINVAL;
165}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700166static DEVICE_ATTR_RO(broadcast);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167
WANG Cong6b53daf2014-07-23 16:09:10 -0700168static int change_carrier(struct net_device *dev, unsigned long new_carrier)
Jiri Pirkofdae0fd2012-12-27 23:49:38 +0000169{
WANG Cong6b53daf2014-07-23 16:09:10 -0700170 if (!netif_running(dev))
Jiri Pirkofdae0fd2012-12-27 23:49:38 +0000171 return -EINVAL;
WANG Cong6b53daf2014-07-23 16:09:10 -0700172 return dev_change_carrier(dev, (bool) new_carrier);
Jiri Pirkofdae0fd2012-12-27 23:49:38 +0000173}
174
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700175static ssize_t carrier_store(struct device *dev, struct device_attribute *attr,
176 const char *buf, size_t len)
Jiri Pirkofdae0fd2012-12-27 23:49:38 +0000177{
178 return netdev_store(dev, attr, buf, len, change_carrier);
179}
180
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700181static ssize_t carrier_show(struct device *dev,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700182 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183{
184 struct net_device *netdev = to_net_dev(dev);
185 if (netif_running(netdev)) {
186 return sprintf(buf, fmt_dec, !!netif_carrier_ok(netdev));
187 }
188 return -EINVAL;
189}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700190static DEVICE_ATTR_RW(carrier);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700192static ssize_t speed_show(struct device *dev,
Andy Gospodarekd519e172009-10-02 09:26:12 +0000193 struct device_attribute *attr, char *buf)
194{
195 struct net_device *netdev = to_net_dev(dev);
196 int ret = -EINVAL;
197
198 if (!rtnl_trylock())
199 return restart_syscall();
200
David Decotigny8ae6dac2011-04-27 18:32:38 +0000201 if (netif_running(netdev)) {
202 struct ethtool_cmd cmd;
Jiri Pirko4bc71cb2011-09-03 03:34:30 +0000203 if (!__ethtool_get_settings(netdev, &cmd))
Alexander Stein75c261b2015-09-28 15:05:33 +0200204 ret = sprintf(buf, fmt_dec, ethtool_cmd_speed(&cmd));
Andy Gospodarekd519e172009-10-02 09:26:12 +0000205 }
206 rtnl_unlock();
207 return ret;
208}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700209static DEVICE_ATTR_RO(speed);
Andy Gospodarekd519e172009-10-02 09:26:12 +0000210
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700211static ssize_t duplex_show(struct device *dev,
Andy Gospodarekd519e172009-10-02 09:26:12 +0000212 struct device_attribute *attr, char *buf)
213{
214 struct net_device *netdev = to_net_dev(dev);
215 int ret = -EINVAL;
216
217 if (!rtnl_trylock())
218 return restart_syscall();
219
David Decotigny8ae6dac2011-04-27 18:32:38 +0000220 if (netif_running(netdev)) {
221 struct ethtool_cmd cmd;
Nikolay Aleksandrovc6c13962012-09-05 04:11:28 +0000222 if (!__ethtool_get_settings(netdev, &cmd)) {
223 const char *duplex;
224 switch (cmd.duplex) {
225 case DUPLEX_HALF:
226 duplex = "half";
227 break;
228 case DUPLEX_FULL:
229 duplex = "full";
230 break;
231 default:
232 duplex = "unknown";
233 break;
234 }
235 ret = sprintf(buf, "%s\n", duplex);
236 }
Andy Gospodarekd519e172009-10-02 09:26:12 +0000237 }
238 rtnl_unlock();
239 return ret;
240}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700241static DEVICE_ATTR_RO(duplex);
Andy Gospodarekd519e172009-10-02 09:26:12 +0000242
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700243static ssize_t dormant_show(struct device *dev,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700244 struct device_attribute *attr, char *buf)
Stefan Rompfb00055a2006-03-20 17:09:11 -0800245{
246 struct net_device *netdev = to_net_dev(dev);
247
248 if (netif_running(netdev))
249 return sprintf(buf, fmt_dec, !!netif_dormant(netdev));
250
251 return -EINVAL;
252}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700253static DEVICE_ATTR_RO(dormant);
Stefan Rompfb00055a2006-03-20 17:09:11 -0800254
Jan Engelhardt36cbd3d2009-08-05 10:42:58 -0700255static const char *const operstates[] = {
Stefan Rompfb00055a2006-03-20 17:09:11 -0800256 "unknown",
257 "notpresent", /* currently unused */
258 "down",
259 "lowerlayerdown",
260 "testing", /* currently unused */
261 "dormant",
262 "up"
263};
264
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700265static ssize_t operstate_show(struct device *dev,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700266 struct device_attribute *attr, char *buf)
Stefan Rompfb00055a2006-03-20 17:09:11 -0800267{
268 const struct net_device *netdev = to_net_dev(dev);
269 unsigned char operstate;
270
271 read_lock(&dev_base_lock);
272 operstate = netdev->operstate;
273 if (!netif_running(netdev))
274 operstate = IF_OPER_DOWN;
275 read_unlock(&dev_base_lock);
276
Adrian Bunke3a5cd92006-04-05 22:19:47 -0700277 if (operstate >= ARRAY_SIZE(operstates))
Stefan Rompfb00055a2006-03-20 17:09:11 -0800278 return -EINVAL; /* should not happen */
279
280 return sprintf(buf, "%s\n", operstates[operstate]);
281}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700282static DEVICE_ATTR_RO(operstate);
Stefan Rompfb00055a2006-03-20 17:09:11 -0800283
david decotigny2d3b4792014-03-29 09:48:35 -0700284static ssize_t carrier_changes_show(struct device *dev,
285 struct device_attribute *attr,
286 char *buf)
287{
288 struct net_device *netdev = to_net_dev(dev);
289 return sprintf(buf, fmt_dec,
290 atomic_read(&netdev->carrier_changes));
291}
292static DEVICE_ATTR_RO(carrier_changes);
293
Linus Torvalds1da177e2005-04-16 15:20:36 -0700294/* read-write attributes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295
WANG Cong6b53daf2014-07-23 16:09:10 -0700296static int change_mtu(struct net_device *dev, unsigned long new_mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297{
WANG Cong6b53daf2014-07-23 16:09:10 -0700298 return dev_set_mtu(dev, (int) new_mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299}
300
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700301static ssize_t mtu_store(struct device *dev, struct device_attribute *attr,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700302 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700304 return netdev_store(dev, attr, buf, len, change_mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700306NETDEVICE_SHOW_RW(mtu, fmt_dec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307
WANG Cong6b53daf2014-07-23 16:09:10 -0700308static int change_flags(struct net_device *dev, unsigned long new_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309{
WANG Cong6b53daf2014-07-23 16:09:10 -0700310 return dev_change_flags(dev, (unsigned int) new_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311}
312
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700313static ssize_t flags_store(struct device *dev, struct device_attribute *attr,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700314 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700316 return netdev_store(dev, attr, buf, len, change_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700318NETDEVICE_SHOW_RW(flags, fmt_hex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319
WANG Cong6b53daf2014-07-23 16:09:10 -0700320static int change_tx_queue_len(struct net_device *dev, unsigned long new_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321{
WANG Cong6b53daf2014-07-23 16:09:10 -0700322 dev->tx_queue_len = new_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 return 0;
324}
325
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700326static ssize_t tx_queue_len_store(struct device *dev,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700327 struct device_attribute *attr,
328 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329{
Eric W. Biederman5e1fccc2012-11-16 03:03:04 +0000330 if (!capable(CAP_NET_ADMIN))
331 return -EPERM;
332
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700333 return netdev_store(dev, attr, buf, len, change_tx_queue_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700334}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700335NETDEVICE_SHOW_RW(tx_queue_len, fmt_ulong);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336
Eric Dumazet3b47d302014-11-06 21:09:44 -0800337static int change_gro_flush_timeout(struct net_device *dev, unsigned long val)
338{
339 dev->gro_flush_timeout = val;
340 return 0;
341}
342
343static ssize_t gro_flush_timeout_store(struct device *dev,
344 struct device_attribute *attr,
345 const char *buf, size_t len)
346{
347 if (!capable(CAP_NET_ADMIN))
348 return -EPERM;
349
350 return netdev_store(dev, attr, buf, len, change_gro_flush_timeout);
351}
352NETDEVICE_SHOW_RW(gro_flush_timeout, fmt_ulong);
353
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700354static ssize_t ifalias_store(struct device *dev, struct device_attribute *attr,
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700355 const char *buf, size_t len)
356{
357 struct net_device *netdev = to_net_dev(dev);
Eric W. Biederman5e1fccc2012-11-16 03:03:04 +0000358 struct net *net = dev_net(netdev);
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700359 size_t count = len;
360 ssize_t ret;
361
Eric W. Biederman5e1fccc2012-11-16 03:03:04 +0000362 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700363 return -EPERM;
364
365 /* ignore trailing newline */
366 if (len > 0 && buf[len - 1] == '\n')
367 --count;
368
Eric W. Biederman336ca572009-05-13 16:57:25 +0000369 if (!rtnl_trylock())
370 return restart_syscall();
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700371 ret = dev_set_alias(netdev, buf, count);
372 rtnl_unlock();
373
374 return ret < 0 ? ret : len;
375}
376
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700377static ssize_t ifalias_show(struct device *dev,
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700378 struct device_attribute *attr, char *buf)
379{
380 const struct net_device *netdev = to_net_dev(dev);
381 ssize_t ret = 0;
382
Eric W. Biederman336ca572009-05-13 16:57:25 +0000383 if (!rtnl_trylock())
384 return restart_syscall();
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700385 if (netdev->ifalias)
386 ret = sprintf(buf, "%s\n", netdev->ifalias);
387 rtnl_unlock();
388 return ret;
389}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700390static DEVICE_ATTR_RW(ifalias);
Vlad Dogarua512b922011-01-24 03:37:29 +0000391
WANG Cong6b53daf2014-07-23 16:09:10 -0700392static int change_group(struct net_device *dev, unsigned long new_group)
Vlad Dogarua512b922011-01-24 03:37:29 +0000393{
WANG Cong6b53daf2014-07-23 16:09:10 -0700394 dev_set_group(dev, (int) new_group);
Vlad Dogarua512b922011-01-24 03:37:29 +0000395 return 0;
396}
397
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700398static ssize_t group_store(struct device *dev, struct device_attribute *attr,
399 const char *buf, size_t len)
Vlad Dogarua512b922011-01-24 03:37:29 +0000400{
401 return netdev_store(dev, attr, buf, len, change_group);
402}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700403NETDEVICE_SHOW(group, fmt_dec);
404static DEVICE_ATTR(netdev_group, S_IRUGO | S_IWUSR, group_show, group_store);
Vlad Dogarua512b922011-01-24 03:37:29 +0000405
Anuradha Karuppiahd746d702015-07-14 13:43:19 -0700406static int change_proto_down(struct net_device *dev, unsigned long proto_down)
407{
408 return dev_change_proto_down(dev, (bool) proto_down);
409}
410
411static ssize_t proto_down_store(struct device *dev,
412 struct device_attribute *attr,
413 const char *buf, size_t len)
414{
415 return netdev_store(dev, attr, buf, len, change_proto_down);
416}
417NETDEVICE_SHOW_RW(proto_down, fmt_dec);
418
Linus Torvaldscc998ff2013-09-05 14:54:29 -0700419static ssize_t phys_port_id_show(struct device *dev,
Jiri Pirkoff80e512013-07-29 18:16:51 +0200420 struct device_attribute *attr, char *buf)
421{
422 struct net_device *netdev = to_net_dev(dev);
423 ssize_t ret = -EINVAL;
424
425 if (!rtnl_trylock())
426 return restart_syscall();
427
428 if (dev_isalive(netdev)) {
Jiri Pirko02637fc2014-11-28 14:34:16 +0100429 struct netdev_phys_item_id ppid;
Jiri Pirkoff80e512013-07-29 18:16:51 +0200430
431 ret = dev_get_phys_port_id(netdev, &ppid);
432 if (!ret)
433 ret = sprintf(buf, "%*phN\n", ppid.id_len, ppid.id);
434 }
435 rtnl_unlock();
436
437 return ret;
438}
Linus Torvaldscc998ff2013-09-05 14:54:29 -0700439static DEVICE_ATTR_RO(phys_port_id);
Jiri Pirkoff80e512013-07-29 18:16:51 +0200440
David Aherndb24a902015-03-17 20:23:15 -0600441static ssize_t phys_port_name_show(struct device *dev,
442 struct device_attribute *attr, char *buf)
443{
444 struct net_device *netdev = to_net_dev(dev);
445 ssize_t ret = -EINVAL;
446
447 if (!rtnl_trylock())
448 return restart_syscall();
449
450 if (dev_isalive(netdev)) {
451 char name[IFNAMSIZ];
452
453 ret = dev_get_phys_port_name(netdev, name, sizeof(name));
454 if (!ret)
455 ret = sprintf(buf, "%s\n", name);
456 }
457 rtnl_unlock();
458
459 return ret;
460}
461static DEVICE_ATTR_RO(phys_port_name);
462
Jiri Pirkoaecbe012014-11-28 14:34:19 +0100463static ssize_t phys_switch_id_show(struct device *dev,
464 struct device_attribute *attr, char *buf)
465{
466 struct net_device *netdev = to_net_dev(dev);
467 ssize_t ret = -EINVAL;
468
469 if (!rtnl_trylock())
470 return restart_syscall();
471
472 if (dev_isalive(netdev)) {
Scott Feldmanf8e20a92015-05-10 09:47:49 -0700473 struct switchdev_attr attr = {
Ido Schimmel6ff64f62015-12-15 16:03:35 +0100474 .orig_dev = netdev,
Jiri Pirko1f868392015-10-01 11:03:42 +0200475 .id = SWITCHDEV_ATTR_ID_PORT_PARENT_ID,
Scott Feldmanf8e20a92015-05-10 09:47:49 -0700476 .flags = SWITCHDEV_F_NO_RECURSE,
477 };
Jiri Pirkoaecbe012014-11-28 14:34:19 +0100478
Scott Feldmanf8e20a92015-05-10 09:47:49 -0700479 ret = switchdev_port_attr_get(netdev, &attr);
Jiri Pirkoaecbe012014-11-28 14:34:19 +0100480 if (!ret)
Scott Feldman42275bd2015-05-13 11:16:50 -0700481 ret = sprintf(buf, "%*phN\n", attr.u.ppid.id_len,
482 attr.u.ppid.id);
Jiri Pirkoaecbe012014-11-28 14:34:19 +0100483 }
484 rtnl_unlock();
485
486 return ret;
487}
488static DEVICE_ATTR_RO(phys_switch_id);
489
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700490static struct attribute *net_class_attrs[] = {
491 &dev_attr_netdev_group.attr,
492 &dev_attr_type.attr,
493 &dev_attr_dev_id.attr,
Amir Vadai3f859442014-02-25 18:17:50 +0200494 &dev_attr_dev_port.attr,
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700495 &dev_attr_iflink.attr,
496 &dev_attr_ifindex.attr,
Tom Gundersen685343f2014-07-14 16:37:22 +0200497 &dev_attr_name_assign_type.attr,
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700498 &dev_attr_addr_assign_type.attr,
499 &dev_attr_addr_len.attr,
500 &dev_attr_link_mode.attr,
501 &dev_attr_address.attr,
502 &dev_attr_broadcast.attr,
503 &dev_attr_speed.attr,
504 &dev_attr_duplex.attr,
505 &dev_attr_dormant.attr,
506 &dev_attr_operstate.attr,
david decotigny2d3b4792014-03-29 09:48:35 -0700507 &dev_attr_carrier_changes.attr,
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700508 &dev_attr_ifalias.attr,
509 &dev_attr_carrier.attr,
510 &dev_attr_mtu.attr,
511 &dev_attr_flags.attr,
512 &dev_attr_tx_queue_len.attr,
Eric Dumazet3b47d302014-11-06 21:09:44 -0800513 &dev_attr_gro_flush_timeout.attr,
Linus Torvaldscc998ff2013-09-05 14:54:29 -0700514 &dev_attr_phys_port_id.attr,
David Aherndb24a902015-03-17 20:23:15 -0600515 &dev_attr_phys_port_name.attr,
Jiri Pirkoaecbe012014-11-28 14:34:19 +0100516 &dev_attr_phys_switch_id.attr,
Anuradha Karuppiahd746d702015-07-14 13:43:19 -0700517 &dev_attr_proto_down.attr,
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700518 NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519};
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700520ATTRIBUTE_GROUPS(net_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521
522/* Show a given an attribute in the statistics group */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700523static ssize_t netstat_show(const struct device *d,
524 struct device_attribute *attr, char *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525 unsigned long offset)
526{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700527 struct net_device *dev = to_net_dev(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700528 ssize_t ret = -EINVAL;
529
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000530 WARN_ON(offset > sizeof(struct rtnl_link_stats64) ||
531 offset % sizeof(u64) != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532
533 read_lock(&dev_base_lock);
Pavel Emelyanov96e74082008-05-21 14:12:46 -0700534 if (dev_isalive(dev)) {
Eric Dumazet28172732010-07-07 14:58:56 -0700535 struct rtnl_link_stats64 temp;
536 const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);
537
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000538 ret = sprintf(buf, fmt_u64, *(u64 *)(((u8 *) stats) + offset));
Pavel Emelyanov96e74082008-05-21 14:12:46 -0700539 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 read_unlock(&dev_base_lock);
541 return ret;
542}
543
544/* generate a read-only statistics attribute */
545#define NETSTAT_ENTRY(name) \
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700546static ssize_t name##_show(struct device *d, \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700547 struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548{ \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700549 return netstat_show(d, attr, buf, \
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000550 offsetof(struct rtnl_link_stats64, name)); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551} \
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700552static DEVICE_ATTR_RO(name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
554NETSTAT_ENTRY(rx_packets);
555NETSTAT_ENTRY(tx_packets);
556NETSTAT_ENTRY(rx_bytes);
557NETSTAT_ENTRY(tx_bytes);
558NETSTAT_ENTRY(rx_errors);
559NETSTAT_ENTRY(tx_errors);
560NETSTAT_ENTRY(rx_dropped);
561NETSTAT_ENTRY(tx_dropped);
562NETSTAT_ENTRY(multicast);
563NETSTAT_ENTRY(collisions);
564NETSTAT_ENTRY(rx_length_errors);
565NETSTAT_ENTRY(rx_over_errors);
566NETSTAT_ENTRY(rx_crc_errors);
567NETSTAT_ENTRY(rx_frame_errors);
568NETSTAT_ENTRY(rx_fifo_errors);
569NETSTAT_ENTRY(rx_missed_errors);
570NETSTAT_ENTRY(tx_aborted_errors);
571NETSTAT_ENTRY(tx_carrier_errors);
572NETSTAT_ENTRY(tx_fifo_errors);
573NETSTAT_ENTRY(tx_heartbeat_errors);
574NETSTAT_ENTRY(tx_window_errors);
575NETSTAT_ENTRY(rx_compressed);
576NETSTAT_ENTRY(tx_compressed);
577
578static struct attribute *netstat_attrs[] = {
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700579 &dev_attr_rx_packets.attr,
580 &dev_attr_tx_packets.attr,
581 &dev_attr_rx_bytes.attr,
582 &dev_attr_tx_bytes.attr,
583 &dev_attr_rx_errors.attr,
584 &dev_attr_tx_errors.attr,
585 &dev_attr_rx_dropped.attr,
586 &dev_attr_tx_dropped.attr,
587 &dev_attr_multicast.attr,
588 &dev_attr_collisions.attr,
589 &dev_attr_rx_length_errors.attr,
590 &dev_attr_rx_over_errors.attr,
591 &dev_attr_rx_crc_errors.attr,
592 &dev_attr_rx_frame_errors.attr,
593 &dev_attr_rx_fifo_errors.attr,
594 &dev_attr_rx_missed_errors.attr,
595 &dev_attr_tx_aborted_errors.attr,
596 &dev_attr_tx_carrier_errors.attr,
597 &dev_attr_tx_fifo_errors.attr,
598 &dev_attr_tx_heartbeat_errors.attr,
599 &dev_attr_tx_window_errors.attr,
600 &dev_attr_rx_compressed.attr,
601 &dev_attr_tx_compressed.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 NULL
603};
604
605
606static struct attribute_group netstat_group = {
607 .name = "statistics",
608 .attrs = netstat_attrs,
609};
Johannes Berg38c1a012012-11-16 20:46:19 +0100610
611#if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211)
612static struct attribute *wireless_attrs[] = {
613 NULL
614};
615
616static struct attribute_group wireless_group = {
617 .name = "wireless",
618 .attrs = wireless_attrs,
619};
620#endif
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700621
622#else /* CONFIG_SYSFS */
623#define net_class_groups NULL
Eric W. Biedermand6523dd2010-05-16 21:59:45 -0700624#endif /* CONFIG_SYSFS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625
Michael Daltona953be52014-01-16 22:23:28 -0800626#ifdef CONFIG_SYSFS
Tom Herbert0a9627f2010-03-16 08:03:29 +0000627#define to_rx_queue_attr(_attr) container_of(_attr, \
628 struct rx_queue_attribute, attr)
629
630#define to_rx_queue(obj) container_of(obj, struct netdev_rx_queue, kobj)
631
632static ssize_t rx_queue_attr_show(struct kobject *kobj, struct attribute *attr,
633 char *buf)
634{
635 struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
636 struct netdev_rx_queue *queue = to_rx_queue(kobj);
637
638 if (!attribute->show)
639 return -EIO;
640
641 return attribute->show(queue, attribute, buf);
642}
643
644static ssize_t rx_queue_attr_store(struct kobject *kobj, struct attribute *attr,
645 const char *buf, size_t count)
646{
647 struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
648 struct netdev_rx_queue *queue = to_rx_queue(kobj);
649
650 if (!attribute->store)
651 return -EIO;
652
653 return attribute->store(queue, attribute, buf, count);
654}
655
stephen hemmingerfa50d642010-08-31 12:14:13 +0000656static const struct sysfs_ops rx_queue_sysfs_ops = {
Tom Herbert0a9627f2010-03-16 08:03:29 +0000657 .show = rx_queue_attr_show,
658 .store = rx_queue_attr_store,
659};
660
Michael Daltona953be52014-01-16 22:23:28 -0800661#ifdef CONFIG_RPS
Tom Herbert0a9627f2010-03-16 08:03:29 +0000662static ssize_t show_rps_map(struct netdev_rx_queue *queue,
663 struct rx_queue_attribute *attribute, char *buf)
664{
665 struct rps_map *map;
666 cpumask_var_t mask;
Tejun Heof0906822015-02-13 14:37:42 -0800667 int i, len;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000668
669 if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
670 return -ENOMEM;
671
672 rcu_read_lock();
673 map = rcu_dereference(queue->rps_map);
674 if (map)
675 for (i = 0; i < map->len; i++)
676 cpumask_set_cpu(map->cpus[i], mask);
677
Tejun Heof0906822015-02-13 14:37:42 -0800678 len = snprintf(buf, PAGE_SIZE, "%*pb\n", cpumask_pr_args(mask));
Tom Herbert0a9627f2010-03-16 08:03:29 +0000679 rcu_read_unlock();
Tom Herbert0a9627f2010-03-16 08:03:29 +0000680 free_cpumask_var(mask);
Tejun Heof0906822015-02-13 14:37:42 -0800681
682 return len < PAGE_SIZE ? len : -EINVAL;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000683}
684
Eric Dumazetf5acb902010-04-19 14:40:57 -0700685static ssize_t store_rps_map(struct netdev_rx_queue *queue,
Tom Herbert0a9627f2010-03-16 08:03:29 +0000686 struct rx_queue_attribute *attribute,
687 const char *buf, size_t len)
688{
689 struct rps_map *old_map, *map;
690 cpumask_var_t mask;
691 int err, cpu, i;
Sasha Levinda65ad12015-08-13 14:03:16 -0400692 static DEFINE_MUTEX(rps_map_mutex);
Tom Herbert0a9627f2010-03-16 08:03:29 +0000693
694 if (!capable(CAP_NET_ADMIN))
695 return -EPERM;
696
697 if (!alloc_cpumask_var(&mask, GFP_KERNEL))
698 return -ENOMEM;
699
700 err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
701 if (err) {
702 free_cpumask_var(mask);
703 return err;
704 }
705
Eric Dumazet95c96172012-04-15 05:58:06 +0000706 map = kzalloc(max_t(unsigned int,
Tom Herbert0a9627f2010-03-16 08:03:29 +0000707 RPS_MAP_SIZE(cpumask_weight(mask)), L1_CACHE_BYTES),
708 GFP_KERNEL);
709 if (!map) {
710 free_cpumask_var(mask);
711 return -ENOMEM;
712 }
713
714 i = 0;
715 for_each_cpu_and(cpu, mask, cpu_online_mask)
716 map->cpus[i++] = cpu;
717
718 if (i)
719 map->len = i;
720 else {
721 kfree(map);
722 map = NULL;
723 }
724
Sasha Levinda65ad12015-08-13 14:03:16 -0400725 mutex_lock(&rps_map_mutex);
Eric Dumazet6e3f7fa2010-10-25 03:02:02 +0000726 old_map = rcu_dereference_protected(queue->rps_map,
Sasha Levinda65ad12015-08-13 14:03:16 -0400727 mutex_is_locked(&rps_map_mutex));
Tom Herbert0a9627f2010-03-16 08:03:29 +0000728 rcu_assign_pointer(queue->rps_map, map);
Tom Herbert0a9627f2010-03-16 08:03:29 +0000729
Eric Dumazetadc93002011-11-17 03:13:26 +0000730 if (map)
Ingo Molnarc5905af2012-02-24 08:31:31 +0100731 static_key_slow_inc(&rps_needed);
Tom Herbert10e4ea72015-08-05 09:39:27 -0700732 if (old_map)
Ingo Molnarc5905af2012-02-24 08:31:31 +0100733 static_key_slow_dec(&rps_needed);
Tom Herbert10e4ea72015-08-05 09:39:27 -0700734
Sasha Levinda65ad12015-08-13 14:03:16 -0400735 mutex_unlock(&rps_map_mutex);
Tom Herbert10e4ea72015-08-05 09:39:27 -0700736
737 if (old_map)
738 kfree_rcu(old_map, rcu);
739
Tom Herbert0a9627f2010-03-16 08:03:29 +0000740 free_cpumask_var(mask);
741 return len;
742}
743
Tom Herbertfec5e652010-04-16 16:01:27 -0700744static ssize_t show_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
745 struct rx_queue_attribute *attr,
746 char *buf)
747{
748 struct rps_dev_flow_table *flow_table;
Eric Dumazet60b778c2011-12-24 06:56:49 +0000749 unsigned long val = 0;
Tom Herbertfec5e652010-04-16 16:01:27 -0700750
751 rcu_read_lock();
752 flow_table = rcu_dereference(queue->rps_flow_table);
753 if (flow_table)
Eric Dumazet60b778c2011-12-24 06:56:49 +0000754 val = (unsigned long)flow_table->mask + 1;
Tom Herbertfec5e652010-04-16 16:01:27 -0700755 rcu_read_unlock();
756
Eric Dumazet60b778c2011-12-24 06:56:49 +0000757 return sprintf(buf, "%lu\n", val);
Tom Herbertfec5e652010-04-16 16:01:27 -0700758}
759
Tom Herbertfec5e652010-04-16 16:01:27 -0700760static void rps_dev_flow_table_release(struct rcu_head *rcu)
761{
762 struct rps_dev_flow_table *table = container_of(rcu,
763 struct rps_dev_flow_table, rcu);
Al Viro243198d2013-05-05 16:05:55 +0000764 vfree(table);
Tom Herbertfec5e652010-04-16 16:01:27 -0700765}
766
Eric Dumazetf5acb902010-04-19 14:40:57 -0700767static ssize_t store_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
Tom Herbertfec5e652010-04-16 16:01:27 -0700768 struct rx_queue_attribute *attr,
769 const char *buf, size_t len)
770{
Eric Dumazet60b778c2011-12-24 06:56:49 +0000771 unsigned long mask, count;
Tom Herbertfec5e652010-04-16 16:01:27 -0700772 struct rps_dev_flow_table *table, *old_table;
773 static DEFINE_SPINLOCK(rps_dev_flow_lock);
Eric Dumazet60b778c2011-12-24 06:56:49 +0000774 int rc;
Tom Herbertfec5e652010-04-16 16:01:27 -0700775
776 if (!capable(CAP_NET_ADMIN))
777 return -EPERM;
778
Eric Dumazet60b778c2011-12-24 06:56:49 +0000779 rc = kstrtoul(buf, 0, &count);
780 if (rc < 0)
781 return rc;
Tom Herbertfec5e652010-04-16 16:01:27 -0700782
783 if (count) {
Eric Dumazet60b778c2011-12-24 06:56:49 +0000784 mask = count - 1;
785 /* mask = roundup_pow_of_two(count) - 1;
786 * without overflows...
787 */
788 while ((mask | (mask >> 1)) != mask)
789 mask |= (mask >> 1);
790 /* On 64 bit arches, must check mask fits in table->mask (u32),
stephen hemminger8e3bff92013-12-08 12:15:44 -0800791 * and on 32bit arches, must check
792 * RPS_DEV_FLOW_TABLE_SIZE(mask + 1) doesn't overflow.
Eric Dumazet60b778c2011-12-24 06:56:49 +0000793 */
794#if BITS_PER_LONG > 32
795 if (mask > (unsigned long)(u32)mask)
Xi Wanga0a129f2011-12-22 13:35:22 +0000796 return -EINVAL;
Eric Dumazet60b778c2011-12-24 06:56:49 +0000797#else
798 if (mask > (ULONG_MAX - RPS_DEV_FLOW_TABLE_SIZE(1))
Xi Wanga0a129f2011-12-22 13:35:22 +0000799 / sizeof(struct rps_dev_flow)) {
Tom Herbertfec5e652010-04-16 16:01:27 -0700800 /* Enforce a limit to prevent overflow */
801 return -EINVAL;
802 }
Eric Dumazet60b778c2011-12-24 06:56:49 +0000803#endif
804 table = vmalloc(RPS_DEV_FLOW_TABLE_SIZE(mask + 1));
Tom Herbertfec5e652010-04-16 16:01:27 -0700805 if (!table)
806 return -ENOMEM;
807
Eric Dumazet60b778c2011-12-24 06:56:49 +0000808 table->mask = mask;
809 for (count = 0; count <= mask; count++)
810 table->flows[count].cpu = RPS_NO_CPU;
Tom Herbertfec5e652010-04-16 16:01:27 -0700811 } else
812 table = NULL;
813
814 spin_lock(&rps_dev_flow_lock);
Eric Dumazet6e3f7fa2010-10-25 03:02:02 +0000815 old_table = rcu_dereference_protected(queue->rps_flow_table,
816 lockdep_is_held(&rps_dev_flow_lock));
Tom Herbertfec5e652010-04-16 16:01:27 -0700817 rcu_assign_pointer(queue->rps_flow_table, table);
818 spin_unlock(&rps_dev_flow_lock);
819
820 if (old_table)
821 call_rcu(&old_table->rcu, rps_dev_flow_table_release);
822
823 return len;
824}
825
Tom Herbert0a9627f2010-03-16 08:03:29 +0000826static struct rx_queue_attribute rps_cpus_attribute =
827 __ATTR(rps_cpus, S_IRUGO | S_IWUSR, show_rps_map, store_rps_map);
828
Tom Herbertfec5e652010-04-16 16:01:27 -0700829
830static struct rx_queue_attribute rps_dev_flow_table_cnt_attribute =
831 __ATTR(rps_flow_cnt, S_IRUGO | S_IWUSR,
832 show_rps_dev_flow_table_cnt, store_rps_dev_flow_table_cnt);
Michael Daltona953be52014-01-16 22:23:28 -0800833#endif /* CONFIG_RPS */
Tom Herbertfec5e652010-04-16 16:01:27 -0700834
Tom Herbert0a9627f2010-03-16 08:03:29 +0000835static struct attribute *rx_queue_default_attrs[] = {
Michael Daltona953be52014-01-16 22:23:28 -0800836#ifdef CONFIG_RPS
Tom Herbert0a9627f2010-03-16 08:03:29 +0000837 &rps_cpus_attribute.attr,
Tom Herbertfec5e652010-04-16 16:01:27 -0700838 &rps_dev_flow_table_cnt_attribute.attr,
Michael Daltona953be52014-01-16 22:23:28 -0800839#endif
Tom Herbert0a9627f2010-03-16 08:03:29 +0000840 NULL
841};
842
843static void rx_queue_release(struct kobject *kobj)
844{
845 struct netdev_rx_queue *queue = to_rx_queue(kobj);
Michael Daltona953be52014-01-16 22:23:28 -0800846#ifdef CONFIG_RPS
Eric Dumazet6e3f7fa2010-10-25 03:02:02 +0000847 struct rps_map *map;
848 struct rps_dev_flow_table *flow_table;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000849
Tom Herbertfec5e652010-04-16 16:01:27 -0700850
Eric Dumazet33d480c2011-08-11 19:30:52 +0000851 map = rcu_dereference_protected(queue->rps_map, 1);
John Fastabend9ea19482010-11-16 06:31:39 +0000852 if (map) {
853 RCU_INIT_POINTER(queue->rps_map, NULL);
Lai Jiangshanf6f80232011-03-18 12:01:31 +0800854 kfree_rcu(map, rcu);
John Fastabend9ea19482010-11-16 06:31:39 +0000855 }
Eric Dumazet6e3f7fa2010-10-25 03:02:02 +0000856
Eric Dumazet33d480c2011-08-11 19:30:52 +0000857 flow_table = rcu_dereference_protected(queue->rps_flow_table, 1);
John Fastabend9ea19482010-11-16 06:31:39 +0000858 if (flow_table) {
859 RCU_INIT_POINTER(queue->rps_flow_table, NULL);
Eric Dumazet6e3f7fa2010-10-25 03:02:02 +0000860 call_rcu(&flow_table->rcu, rps_dev_flow_table_release);
John Fastabend9ea19482010-11-16 06:31:39 +0000861 }
Michael Daltona953be52014-01-16 22:23:28 -0800862#endif
Tom Herbert0a9627f2010-03-16 08:03:29 +0000863
John Fastabend9ea19482010-11-16 06:31:39 +0000864 memset(kobj, 0, sizeof(*kobj));
Tom Herbertfe822242010-11-09 10:47:38 +0000865 dev_put(queue->dev);
Tom Herbert0a9627f2010-03-16 08:03:29 +0000866}
867
Weilong Chen82ef3d52014-01-16 17:24:31 +0800868static const void *rx_queue_namespace(struct kobject *kobj)
869{
870 struct netdev_rx_queue *queue = to_rx_queue(kobj);
871 struct device *dev = &queue->dev->dev;
872 const void *ns = NULL;
873
874 if (dev->class && dev->class->ns_type)
875 ns = dev->class->namespace(dev);
876
877 return ns;
878}
879
Tom Herbert0a9627f2010-03-16 08:03:29 +0000880static struct kobj_type rx_queue_ktype = {
881 .sysfs_ops = &rx_queue_sysfs_ops,
882 .release = rx_queue_release,
883 .default_attrs = rx_queue_default_attrs,
Weilong Chen82ef3d52014-01-16 17:24:31 +0800884 .namespace = rx_queue_namespace
Tom Herbert0a9627f2010-03-16 08:03:29 +0000885};
886
WANG Cong6b53daf2014-07-23 16:09:10 -0700887static int rx_queue_add_kobject(struct net_device *dev, int index)
Tom Herbert0a9627f2010-03-16 08:03:29 +0000888{
WANG Cong6b53daf2014-07-23 16:09:10 -0700889 struct netdev_rx_queue *queue = dev->_rx + index;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000890 struct kobject *kobj = &queue->kobj;
891 int error = 0;
892
WANG Cong6b53daf2014-07-23 16:09:10 -0700893 kobj->kset = dev->queues_kset;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000894 error = kobject_init_and_add(kobj, &rx_queue_ktype, NULL,
895 "rx-%u", index);
Michael Daltona953be52014-01-16 22:23:28 -0800896 if (error)
897 goto exit;
898
WANG Cong6b53daf2014-07-23 16:09:10 -0700899 if (dev->sysfs_rx_queue_group) {
900 error = sysfs_create_group(kobj, dev->sysfs_rx_queue_group);
Michael Daltona953be52014-01-16 22:23:28 -0800901 if (error)
902 goto exit;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000903 }
904
905 kobject_uevent(kobj, KOBJ_ADD);
Tom Herbertfe822242010-11-09 10:47:38 +0000906 dev_hold(queue->dev);
Tom Herbert0a9627f2010-03-16 08:03:29 +0000907
908 return error;
Michael Daltona953be52014-01-16 22:23:28 -0800909exit:
910 kobject_put(kobj);
911 return error;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000912}
Paul Bolle80dd6ea2014-02-09 14:07:11 +0100913#endif /* CONFIG_SYSFS */
Tom Herbert0a9627f2010-03-16 08:03:29 +0000914
Ben Hutchings62fe0b42010-09-27 08:24:33 +0000915int
WANG Cong6b53daf2014-07-23 16:09:10 -0700916net_rx_queue_update_kobjects(struct net_device *dev, int old_num, int new_num)
Tom Herbert0a9627f2010-03-16 08:03:29 +0000917{
Michael Daltona953be52014-01-16 22:23:28 -0800918#ifdef CONFIG_SYSFS
Tom Herbert0a9627f2010-03-16 08:03:29 +0000919 int i;
920 int error = 0;
921
Michael Daltona953be52014-01-16 22:23:28 -0800922#ifndef CONFIG_RPS
WANG Cong6b53daf2014-07-23 16:09:10 -0700923 if (!dev->sysfs_rx_queue_group)
Michael Daltona953be52014-01-16 22:23:28 -0800924 return 0;
925#endif
Ben Hutchings62fe0b42010-09-27 08:24:33 +0000926 for (i = old_num; i < new_num; i++) {
WANG Cong6b53daf2014-07-23 16:09:10 -0700927 error = rx_queue_add_kobject(dev, i);
Ben Hutchings62fe0b42010-09-27 08:24:33 +0000928 if (error) {
929 new_num = old_num;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000930 break;
Ben Hutchings62fe0b42010-09-27 08:24:33 +0000931 }
Tom Herbert0a9627f2010-03-16 08:03:29 +0000932 }
933
Michael Daltona953be52014-01-16 22:23:28 -0800934 while (--i >= new_num) {
WANG Cong6b53daf2014-07-23 16:09:10 -0700935 if (dev->sysfs_rx_queue_group)
936 sysfs_remove_group(&dev->_rx[i].kobj,
937 dev->sysfs_rx_queue_group);
938 kobject_put(&dev->_rx[i].kobj);
Michael Daltona953be52014-01-16 22:23:28 -0800939 }
Tom Herbert0a9627f2010-03-16 08:03:29 +0000940
941 return error;
Tom Herbertbf264142010-11-26 08:36:09 +0000942#else
943 return 0;
944#endif
Tom Herbert0a9627f2010-03-16 08:03:29 +0000945}
946
david decotignyccf5ff62011-11-16 12:15:10 +0000947#ifdef CONFIG_SYSFS
Tom Herbert1d24eb42010-11-21 13:17:27 +0000948/*
949 * netdev_queue sysfs structures and functions.
950 */
951struct netdev_queue_attribute {
952 struct attribute attr;
953 ssize_t (*show)(struct netdev_queue *queue,
954 struct netdev_queue_attribute *attr, char *buf);
955 ssize_t (*store)(struct netdev_queue *queue,
956 struct netdev_queue_attribute *attr, const char *buf, size_t len);
957};
958#define to_netdev_queue_attr(_attr) container_of(_attr, \
959 struct netdev_queue_attribute, attr)
960
961#define to_netdev_queue(obj) container_of(obj, struct netdev_queue, kobj)
962
963static ssize_t netdev_queue_attr_show(struct kobject *kobj,
964 struct attribute *attr, char *buf)
Ben Hutchings62fe0b42010-09-27 08:24:33 +0000965{
Tom Herbert1d24eb42010-11-21 13:17:27 +0000966 struct netdev_queue_attribute *attribute = to_netdev_queue_attr(attr);
967 struct netdev_queue *queue = to_netdev_queue(kobj);
968
969 if (!attribute->show)
970 return -EIO;
971
972 return attribute->show(queue, attribute, buf);
973}
974
975static ssize_t netdev_queue_attr_store(struct kobject *kobj,
976 struct attribute *attr,
977 const char *buf, size_t count)
978{
979 struct netdev_queue_attribute *attribute = to_netdev_queue_attr(attr);
980 struct netdev_queue *queue = to_netdev_queue(kobj);
981
982 if (!attribute->store)
983 return -EIO;
984
985 return attribute->store(queue, attribute, buf, count);
986}
987
988static const struct sysfs_ops netdev_queue_sysfs_ops = {
989 .show = netdev_queue_attr_show,
990 .store = netdev_queue_attr_store,
991};
992
david decotignyccf5ff62011-11-16 12:15:10 +0000993static ssize_t show_trans_timeout(struct netdev_queue *queue,
994 struct netdev_queue_attribute *attribute,
995 char *buf)
996{
997 unsigned long trans_timeout;
998
999 spin_lock_irq(&queue->_xmit_lock);
1000 trans_timeout = queue->trans_timeout;
1001 spin_unlock_irq(&queue->_xmit_lock);
1002
1003 return sprintf(buf, "%lu", trans_timeout);
1004}
1005
John Fastabend822b3b22015-03-18 14:57:33 +02001006#ifdef CONFIG_XPS
Thadeu Lima de Souza Cascardoc4047f52015-09-15 18:28:00 -03001007static unsigned int get_netdev_queue_index(struct netdev_queue *queue)
John Fastabend822b3b22015-03-18 14:57:33 +02001008{
1009 struct net_device *dev = queue->dev;
Thadeu Lima de Souza Cascardoc4047f52015-09-15 18:28:00 -03001010 unsigned int i;
John Fastabend822b3b22015-03-18 14:57:33 +02001011
Thadeu Lima de Souza Cascardoc4047f52015-09-15 18:28:00 -03001012 i = queue - dev->_tx;
John Fastabend822b3b22015-03-18 14:57:33 +02001013 BUG_ON(i >= dev->num_tx_queues);
1014
1015 return i;
1016}
1017
1018static ssize_t show_tx_maxrate(struct netdev_queue *queue,
1019 struct netdev_queue_attribute *attribute,
1020 char *buf)
1021{
1022 return sprintf(buf, "%lu\n", queue->tx_maxrate);
1023}
1024
1025static ssize_t set_tx_maxrate(struct netdev_queue *queue,
1026 struct netdev_queue_attribute *attribute,
1027 const char *buf, size_t len)
1028{
1029 struct net_device *dev = queue->dev;
1030 int err, index = get_netdev_queue_index(queue);
1031 u32 rate = 0;
1032
1033 err = kstrtou32(buf, 10, &rate);
1034 if (err < 0)
1035 return err;
1036
1037 if (!rtnl_trylock())
1038 return restart_syscall();
1039
1040 err = -EOPNOTSUPP;
1041 if (dev->netdev_ops->ndo_set_tx_maxrate)
1042 err = dev->netdev_ops->ndo_set_tx_maxrate(dev, index, rate);
1043
1044 rtnl_unlock();
1045 if (!err) {
1046 queue->tx_maxrate = rate;
1047 return len;
1048 }
1049 return err;
1050}
1051
1052static struct netdev_queue_attribute queue_tx_maxrate =
1053 __ATTR(tx_maxrate, S_IRUGO | S_IWUSR,
1054 show_tx_maxrate, set_tx_maxrate);
1055#endif
1056
david decotignyccf5ff62011-11-16 12:15:10 +00001057static struct netdev_queue_attribute queue_trans_timeout =
1058 __ATTR(tx_timeout, S_IRUGO, show_trans_timeout, NULL);
1059
Tom Herbert114cf582011-11-28 16:33:09 +00001060#ifdef CONFIG_BQL
1061/*
1062 * Byte queue limits sysfs structures and functions.
1063 */
1064static ssize_t bql_show(char *buf, unsigned int value)
1065{
1066 return sprintf(buf, "%u\n", value);
1067}
1068
1069static ssize_t bql_set(const char *buf, const size_t count,
1070 unsigned int *pvalue)
1071{
1072 unsigned int value;
1073 int err;
1074
1075 if (!strcmp(buf, "max") || !strcmp(buf, "max\n"))
1076 value = DQL_MAX_LIMIT;
1077 else {
1078 err = kstrtouint(buf, 10, &value);
1079 if (err < 0)
1080 return err;
1081 if (value > DQL_MAX_LIMIT)
1082 return -EINVAL;
1083 }
1084
1085 *pvalue = value;
1086
1087 return count;
1088}
1089
1090static ssize_t bql_show_hold_time(struct netdev_queue *queue,
1091 struct netdev_queue_attribute *attr,
1092 char *buf)
1093{
1094 struct dql *dql = &queue->dql;
1095
1096 return sprintf(buf, "%u\n", jiffies_to_msecs(dql->slack_hold_time));
1097}
1098
1099static ssize_t bql_set_hold_time(struct netdev_queue *queue,
1100 struct netdev_queue_attribute *attribute,
1101 const char *buf, size_t len)
1102{
1103 struct dql *dql = &queue->dql;
Eric Dumazet95c96172012-04-15 05:58:06 +00001104 unsigned int value;
Tom Herbert114cf582011-11-28 16:33:09 +00001105 int err;
1106
1107 err = kstrtouint(buf, 10, &value);
1108 if (err < 0)
1109 return err;
1110
1111 dql->slack_hold_time = msecs_to_jiffies(value);
1112
1113 return len;
1114}
1115
1116static struct netdev_queue_attribute bql_hold_time_attribute =
1117 __ATTR(hold_time, S_IRUGO | S_IWUSR, bql_show_hold_time,
1118 bql_set_hold_time);
1119
1120static ssize_t bql_show_inflight(struct netdev_queue *queue,
1121 struct netdev_queue_attribute *attr,
1122 char *buf)
1123{
1124 struct dql *dql = &queue->dql;
1125
1126 return sprintf(buf, "%u\n", dql->num_queued - dql->num_completed);
1127}
1128
1129static struct netdev_queue_attribute bql_inflight_attribute =
Hiroaki SHIMODA795d9a22012-01-14 07:10:21 +00001130 __ATTR(inflight, S_IRUGO, bql_show_inflight, NULL);
Tom Herbert114cf582011-11-28 16:33:09 +00001131
1132#define BQL_ATTR(NAME, FIELD) \
1133static ssize_t bql_show_ ## NAME(struct netdev_queue *queue, \
1134 struct netdev_queue_attribute *attr, \
1135 char *buf) \
1136{ \
1137 return bql_show(buf, queue->dql.FIELD); \
1138} \
1139 \
1140static ssize_t bql_set_ ## NAME(struct netdev_queue *queue, \
1141 struct netdev_queue_attribute *attr, \
1142 const char *buf, size_t len) \
1143{ \
1144 return bql_set(buf, len, &queue->dql.FIELD); \
1145} \
1146 \
1147static struct netdev_queue_attribute bql_ ## NAME ## _attribute = \
1148 __ATTR(NAME, S_IRUGO | S_IWUSR, bql_show_ ## NAME, \
1149 bql_set_ ## NAME);
1150
1151BQL_ATTR(limit, limit)
1152BQL_ATTR(limit_max, max_limit)
1153BQL_ATTR(limit_min, min_limit)
1154
1155static struct attribute *dql_attrs[] = {
1156 &bql_limit_attribute.attr,
1157 &bql_limit_max_attribute.attr,
1158 &bql_limit_min_attribute.attr,
1159 &bql_hold_time_attribute.attr,
1160 &bql_inflight_attribute.attr,
1161 NULL
1162};
1163
1164static struct attribute_group dql_group = {
1165 .name = "byte_queue_limits",
1166 .attrs = dql_attrs,
1167};
1168#endif /* CONFIG_BQL */
1169
david decotignyccf5ff62011-11-16 12:15:10 +00001170#ifdef CONFIG_XPS
Tom Herbert1d24eb42010-11-21 13:17:27 +00001171static ssize_t show_xps_map(struct netdev_queue *queue,
1172 struct netdev_queue_attribute *attribute, char *buf)
1173{
1174 struct net_device *dev = queue->dev;
1175 struct xps_dev_maps *dev_maps;
1176 cpumask_var_t mask;
1177 unsigned long index;
Tejun Heof0906822015-02-13 14:37:42 -08001178 int i, len;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001179
1180 if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
1181 return -ENOMEM;
1182
1183 index = get_netdev_queue_index(queue);
1184
1185 rcu_read_lock();
1186 dev_maps = rcu_dereference(dev->xps_maps);
1187 if (dev_maps) {
1188 for_each_possible_cpu(i) {
1189 struct xps_map *map =
1190 rcu_dereference(dev_maps->cpu_map[i]);
1191 if (map) {
1192 int j;
1193 for (j = 0; j < map->len; j++) {
1194 if (map->queues[j] == index) {
1195 cpumask_set_cpu(i, mask);
1196 break;
1197 }
1198 }
1199 }
1200 }
1201 }
1202 rcu_read_unlock();
1203
Tejun Heof0906822015-02-13 14:37:42 -08001204 len = snprintf(buf, PAGE_SIZE, "%*pb\n", cpumask_pr_args(mask));
Tom Herbert1d24eb42010-11-21 13:17:27 +00001205 free_cpumask_var(mask);
Tejun Heof0906822015-02-13 14:37:42 -08001206 return len < PAGE_SIZE ? len : -EINVAL;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001207}
1208
Tom Herbert1d24eb42010-11-21 13:17:27 +00001209static ssize_t store_xps_map(struct netdev_queue *queue,
1210 struct netdev_queue_attribute *attribute,
1211 const char *buf, size_t len)
1212{
1213 struct net_device *dev = queue->dev;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001214 unsigned long index;
Alexander Duyck537c00d2013-01-10 08:57:02 +00001215 cpumask_var_t mask;
1216 int err;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001217
1218 if (!capable(CAP_NET_ADMIN))
1219 return -EPERM;
1220
1221 if (!alloc_cpumask_var(&mask, GFP_KERNEL))
1222 return -ENOMEM;
1223
1224 index = get_netdev_queue_index(queue);
1225
1226 err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
1227 if (err) {
1228 free_cpumask_var(mask);
1229 return err;
1230 }
1231
Alexander Duyck537c00d2013-01-10 08:57:02 +00001232 err = netif_set_xps_queue(dev, mask, index);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001233
1234 free_cpumask_var(mask);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001235
Alexander Duyck537c00d2013-01-10 08:57:02 +00001236 return err ? : len;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001237}
1238
1239static struct netdev_queue_attribute xps_cpus_attribute =
1240 __ATTR(xps_cpus, S_IRUGO | S_IWUSR, show_xps_map, store_xps_map);
david decotignyccf5ff62011-11-16 12:15:10 +00001241#endif /* CONFIG_XPS */
Tom Herbert1d24eb42010-11-21 13:17:27 +00001242
1243static struct attribute *netdev_queue_default_attrs[] = {
david decotignyccf5ff62011-11-16 12:15:10 +00001244 &queue_trans_timeout.attr,
1245#ifdef CONFIG_XPS
Tom Herbert1d24eb42010-11-21 13:17:27 +00001246 &xps_cpus_attribute.attr,
John Fastabend822b3b22015-03-18 14:57:33 +02001247 &queue_tx_maxrate.attr,
david decotignyccf5ff62011-11-16 12:15:10 +00001248#endif
Tom Herbert1d24eb42010-11-21 13:17:27 +00001249 NULL
1250};
1251
1252static void netdev_queue_release(struct kobject *kobj)
1253{
1254 struct netdev_queue *queue = to_netdev_queue(kobj);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001255
Tom Herbert1d24eb42010-11-21 13:17:27 +00001256 memset(kobj, 0, sizeof(*kobj));
1257 dev_put(queue->dev);
1258}
1259
Weilong Chen82ef3d52014-01-16 17:24:31 +08001260static const void *netdev_queue_namespace(struct kobject *kobj)
1261{
1262 struct netdev_queue *queue = to_netdev_queue(kobj);
1263 struct device *dev = &queue->dev->dev;
1264 const void *ns = NULL;
1265
1266 if (dev->class && dev->class->ns_type)
1267 ns = dev->class->namespace(dev);
1268
1269 return ns;
1270}
1271
Tom Herbert1d24eb42010-11-21 13:17:27 +00001272static struct kobj_type netdev_queue_ktype = {
1273 .sysfs_ops = &netdev_queue_sysfs_ops,
1274 .release = netdev_queue_release,
1275 .default_attrs = netdev_queue_default_attrs,
Weilong Chen82ef3d52014-01-16 17:24:31 +08001276 .namespace = netdev_queue_namespace,
Tom Herbert1d24eb42010-11-21 13:17:27 +00001277};
1278
WANG Cong6b53daf2014-07-23 16:09:10 -07001279static int netdev_queue_add_kobject(struct net_device *dev, int index)
Tom Herbert1d24eb42010-11-21 13:17:27 +00001280{
WANG Cong6b53daf2014-07-23 16:09:10 -07001281 struct netdev_queue *queue = dev->_tx + index;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001282 struct kobject *kobj = &queue->kobj;
1283 int error = 0;
1284
WANG Cong6b53daf2014-07-23 16:09:10 -07001285 kobj->kset = dev->queues_kset;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001286 error = kobject_init_and_add(kobj, &netdev_queue_ktype, NULL,
1287 "tx-%u", index);
Tom Herbert114cf582011-11-28 16:33:09 +00001288 if (error)
1289 goto exit;
1290
1291#ifdef CONFIG_BQL
1292 error = sysfs_create_group(kobj, &dql_group);
1293 if (error)
1294 goto exit;
1295#endif
Tom Herbert1d24eb42010-11-21 13:17:27 +00001296
1297 kobject_uevent(kobj, KOBJ_ADD);
1298 dev_hold(queue->dev);
1299
Tom Herbert114cf582011-11-28 16:33:09 +00001300 return 0;
1301exit:
1302 kobject_put(kobj);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001303 return error;
1304}
david decotignyccf5ff62011-11-16 12:15:10 +00001305#endif /* CONFIG_SYSFS */
Tom Herbert1d24eb42010-11-21 13:17:27 +00001306
1307int
WANG Cong6b53daf2014-07-23 16:09:10 -07001308netdev_queue_update_kobjects(struct net_device *dev, int old_num, int new_num)
Tom Herbert1d24eb42010-11-21 13:17:27 +00001309{
david decotignyccf5ff62011-11-16 12:15:10 +00001310#ifdef CONFIG_SYSFS
Tom Herbert1d24eb42010-11-21 13:17:27 +00001311 int i;
1312 int error = 0;
1313
1314 for (i = old_num; i < new_num; i++) {
WANG Cong6b53daf2014-07-23 16:09:10 -07001315 error = netdev_queue_add_kobject(dev, i);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001316 if (error) {
1317 new_num = old_num;
1318 break;
1319 }
1320 }
1321
Tom Herbert114cf582011-11-28 16:33:09 +00001322 while (--i >= new_num) {
WANG Cong6b53daf2014-07-23 16:09:10 -07001323 struct netdev_queue *queue = dev->_tx + i;
Tom Herbert114cf582011-11-28 16:33:09 +00001324
1325#ifdef CONFIG_BQL
1326 sysfs_remove_group(&queue->kobj, &dql_group);
1327#endif
1328 kobject_put(&queue->kobj);
1329 }
Tom Herbert1d24eb42010-11-21 13:17:27 +00001330
1331 return error;
Tom Herbertbf264142010-11-26 08:36:09 +00001332#else
1333 return 0;
david decotignyccf5ff62011-11-16 12:15:10 +00001334#endif /* CONFIG_SYSFS */
Tom Herbert1d24eb42010-11-21 13:17:27 +00001335}
1336
WANG Cong6b53daf2014-07-23 16:09:10 -07001337static int register_queue_kobjects(struct net_device *dev)
Tom Herbert1d24eb42010-11-21 13:17:27 +00001338{
Tom Herbertbf264142010-11-26 08:36:09 +00001339 int error = 0, txq = 0, rxq = 0, real_rx = 0, real_tx = 0;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001340
david decotignyccf5ff62011-11-16 12:15:10 +00001341#ifdef CONFIG_SYSFS
WANG Cong6b53daf2014-07-23 16:09:10 -07001342 dev->queues_kset = kset_create_and_add("queues",
1343 NULL, &dev->dev.kobj);
1344 if (!dev->queues_kset)
Ben Hutchings62fe0b42010-09-27 08:24:33 +00001345 return -ENOMEM;
WANG Cong6b53daf2014-07-23 16:09:10 -07001346 real_rx = dev->real_num_rx_queues;
Tom Herbertbf264142010-11-26 08:36:09 +00001347#endif
WANG Cong6b53daf2014-07-23 16:09:10 -07001348 real_tx = dev->real_num_tx_queues;
Tom Herbertbf264142010-11-26 08:36:09 +00001349
WANG Cong6b53daf2014-07-23 16:09:10 -07001350 error = net_rx_queue_update_kobjects(dev, 0, real_rx);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001351 if (error)
1352 goto error;
Tom Herbertbf264142010-11-26 08:36:09 +00001353 rxq = real_rx;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001354
WANG Cong6b53daf2014-07-23 16:09:10 -07001355 error = netdev_queue_update_kobjects(dev, 0, real_tx);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001356 if (error)
1357 goto error;
Tom Herbertbf264142010-11-26 08:36:09 +00001358 txq = real_tx;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001359
1360 return 0;
1361
1362error:
WANG Cong6b53daf2014-07-23 16:09:10 -07001363 netdev_queue_update_kobjects(dev, txq, 0);
1364 net_rx_queue_update_kobjects(dev, rxq, 0);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001365 return error;
Ben Hutchings62fe0b42010-09-27 08:24:33 +00001366}
1367
WANG Cong6b53daf2014-07-23 16:09:10 -07001368static void remove_queue_kobjects(struct net_device *dev)
Tom Herbert0a9627f2010-03-16 08:03:29 +00001369{
Tom Herbertbf264142010-11-26 08:36:09 +00001370 int real_rx = 0, real_tx = 0;
1371
Michael Daltona953be52014-01-16 22:23:28 -08001372#ifdef CONFIG_SYSFS
WANG Cong6b53daf2014-07-23 16:09:10 -07001373 real_rx = dev->real_num_rx_queues;
Tom Herbertbf264142010-11-26 08:36:09 +00001374#endif
WANG Cong6b53daf2014-07-23 16:09:10 -07001375 real_tx = dev->real_num_tx_queues;
Tom Herbertbf264142010-11-26 08:36:09 +00001376
WANG Cong6b53daf2014-07-23 16:09:10 -07001377 net_rx_queue_update_kobjects(dev, real_rx, 0);
1378 netdev_queue_update_kobjects(dev, real_tx, 0);
david decotignyccf5ff62011-11-16 12:15:10 +00001379#ifdef CONFIG_SYSFS
WANG Cong6b53daf2014-07-23 16:09:10 -07001380 kset_unregister(dev->queues_kset);
Tom Herbertbf264142010-11-26 08:36:09 +00001381#endif
Tom Herbert0a9627f2010-03-16 08:03:29 +00001382}
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001383
Eric W. Biederman7dc5dbc2013-03-25 20:07:01 -07001384static bool net_current_may_mount(void)
1385{
1386 struct net *net = current->nsproxy->net_ns;
1387
1388 return ns_capable(net->user_ns, CAP_SYS_ADMIN);
1389}
1390
Al Viroa685e082011-06-08 21:13:01 -04001391static void *net_grab_current_ns(void)
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001392{
Al Viroa685e082011-06-08 21:13:01 -04001393 struct net *ns = current->nsproxy->net_ns;
1394#ifdef CONFIG_NET_NS
1395 if (ns)
1396 atomic_inc(&ns->passive);
1397#endif
1398 return ns;
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001399}
1400
1401static const void *net_initial_ns(void)
1402{
1403 return &init_net;
1404}
1405
1406static const void *net_netlink_ns(struct sock *sk)
1407{
1408 return sock_net(sk);
1409}
1410
Johannes Berg04600792010-08-05 17:45:15 +02001411struct kobj_ns_type_operations net_ns_type_operations = {
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001412 .type = KOBJ_NS_TYPE_NET,
Eric W. Biederman7dc5dbc2013-03-25 20:07:01 -07001413 .current_may_mount = net_current_may_mount,
Al Viroa685e082011-06-08 21:13:01 -04001414 .grab_current_ns = net_grab_current_ns,
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001415 .netlink_ns = net_netlink_ns,
1416 .initial_ns = net_initial_ns,
Al Viroa685e082011-06-08 21:13:01 -04001417 .drop_ns = net_drop_ns,
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001418};
Johannes Berg04600792010-08-05 17:45:15 +02001419EXPORT_SYMBOL_GPL(net_ns_type_operations);
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001420
Kay Sievers7eff2e72007-08-14 15:15:12 +02001421static int netdev_uevent(struct device *d, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001422{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001423 struct net_device *dev = to_net_dev(d);
Kay Sievers7eff2e72007-08-14 15:15:12 +02001424 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001425
Kay Sievers312c0042005-11-16 09:00:00 +01001426 /* pass interface to uevent. */
Kay Sievers7eff2e72007-08-14 15:15:12 +02001427 retval = add_uevent_var(env, "INTERFACE=%s", dev->name);
Eric Rannaudbf624562007-03-30 22:23:12 -07001428 if (retval)
1429 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430
Jean Tourrilhesca2f37d2007-03-07 10:49:30 -08001431 /* pass ifindex to uevent.
1432 * ifindex is useful as it won't change (interface name may change)
1433 * and is what RtNetlink uses natively. */
Kay Sievers7eff2e72007-08-14 15:15:12 +02001434 retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex);
Jean Tourrilhesca2f37d2007-03-07 10:49:30 -08001435
Eric Rannaudbf624562007-03-30 22:23:12 -07001436exit:
Eric Rannaudbf624562007-03-30 22:23:12 -07001437 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001439
1440/*
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001441 * netdev_release -- destroy and free a dead device.
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001442 * Called when last reference to device kobject is gone.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001443 */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001444static void netdev_release(struct device *d)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001446 struct net_device *dev = to_net_dev(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
1448 BUG_ON(dev->reg_state != NETREG_RELEASED);
1449
Stephen Hemminger0b815a12008-09-22 21:28:11 -07001450 kfree(dev->ifalias);
Eric Dumazet74d332c2013-10-30 13:10:44 -07001451 netdev_freemem(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452}
1453
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001454static const void *net_namespace(struct device *d)
1455{
Geliang Tang5c294822015-12-22 23:11:49 +08001456 struct net_device *dev = to_net_dev(d);
1457
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001458 return dev_net(dev);
1459}
1460
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461static struct class net_class = {
1462 .name = "net",
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001463 .dev_release = netdev_release,
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -07001464 .dev_groups = net_class_groups,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001465 .dev_uevent = netdev_uevent,
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001466 .ns_type = &net_ns_type_operations,
1467 .namespace = net_namespace,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468};
1469
Florian Fainelliaa836df2015-03-09 14:31:20 -07001470#ifdef CONFIG_OF_NET
1471static int of_dev_node_match(struct device *dev, const void *data)
1472{
1473 int ret = 0;
1474
1475 if (dev->parent)
1476 ret = dev->parent->of_node == data;
1477
1478 return ret == 0 ? dev->of_node == data : ret;
1479}
1480
Russell King9861f722015-09-24 20:36:33 +01001481/*
1482 * of_find_net_device_by_node - lookup the net device for the device node
1483 * @np: OF device node
1484 *
1485 * Looks up the net_device structure corresponding with the device node.
1486 * If successful, returns a pointer to the net_device with the embedded
1487 * struct device refcount incremented by one, or NULL on failure. The
1488 * refcount must be dropped when done with the net_device.
1489 */
Florian Fainelliaa836df2015-03-09 14:31:20 -07001490struct net_device *of_find_net_device_by_node(struct device_node *np)
1491{
1492 struct device *dev;
1493
1494 dev = class_find_device(&net_class, NULL, np, of_dev_node_match);
1495 if (!dev)
1496 return NULL;
1497
1498 return to_net_dev(dev);
1499}
1500EXPORT_SYMBOL(of_find_net_device_by_node);
1501#endif
1502
Stephen Hemminger9093bbb2007-05-19 15:39:25 -07001503/* Delete sysfs entries but hold kobject reference until after all
1504 * netdev references are gone.
1505 */
WANG Cong6b53daf2014-07-23 16:09:10 -07001506void netdev_unregister_kobject(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001507{
WANG Cong6b53daf2014-07-23 16:09:10 -07001508 struct device *dev = &(ndev->dev);
Stephen Hemminger9093bbb2007-05-19 15:39:25 -07001509
1510 kobject_get(&dev->kobj);
Eric W. Biederman38918452008-10-27 17:51:47 -07001511
WANG Cong6b53daf2014-07-23 16:09:10 -07001512 remove_queue_kobjects(ndev);
Tom Herbert0a9627f2010-03-16 08:03:29 +00001513
Ming Lei9802c8e2013-02-22 16:34:16 -08001514 pm_runtime_set_memalloc_noio(dev, false);
1515
Stephen Hemminger9093bbb2007-05-19 15:39:25 -07001516 device_del(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517}
1518
1519/* Create sysfs entries for network device. */
WANG Cong6b53daf2014-07-23 16:09:10 -07001520int netdev_register_kobject(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001521{
WANG Cong6b53daf2014-07-23 16:09:10 -07001522 struct device *dev = &(ndev->dev);
1523 const struct attribute_group **groups = ndev->sysfs_groups;
Tom Herbert0a9627f2010-03-16 08:03:29 +00001524 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001525
Eric W. Biedermana1b3f592010-05-04 17:36:49 -07001526 device_initialize(dev);
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001527 dev->class = &net_class;
WANG Cong6b53daf2014-07-23 16:09:10 -07001528 dev->platform_data = ndev;
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001529 dev->groups = groups;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530
WANG Cong6b53daf2014-07-23 16:09:10 -07001531 dev_set_name(dev, "%s", ndev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001532
Eric W. Biederman8b41d182007-09-26 22:02:53 -07001533#ifdef CONFIG_SYSFS
Eric W. Biederman0c509a62009-10-29 14:18:21 +00001534 /* Allow for a device specific group */
1535 if (*groups)
1536 groups++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537
Eric W. Biederman0c509a62009-10-29 14:18:21 +00001538 *groups++ = &netstat_group;
Johannes Berg38c1a012012-11-16 20:46:19 +01001539
1540#if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211)
WANG Cong6b53daf2014-07-23 16:09:10 -07001541 if (ndev->ieee80211_ptr)
Johannes Berg38c1a012012-11-16 20:46:19 +01001542 *groups++ = &wireless_group;
1543#if IS_ENABLED(CONFIG_WIRELESS_EXT)
WANG Cong6b53daf2014-07-23 16:09:10 -07001544 else if (ndev->wireless_handlers)
Johannes Berg38c1a012012-11-16 20:46:19 +01001545 *groups++ = &wireless_group;
1546#endif
1547#endif
Eric W. Biederman8b41d182007-09-26 22:02:53 -07001548#endif /* CONFIG_SYSFS */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549
Tom Herbert0a9627f2010-03-16 08:03:29 +00001550 error = device_add(dev);
1551 if (error)
1552 return error;
1553
WANG Cong6b53daf2014-07-23 16:09:10 -07001554 error = register_queue_kobjects(ndev);
Tom Herbert0a9627f2010-03-16 08:03:29 +00001555 if (error) {
1556 device_del(dev);
1557 return error;
1558 }
1559
Ming Lei9802c8e2013-02-22 16:34:16 -08001560 pm_runtime_set_memalloc_noio(dev, true);
1561
Tom Herbert0a9627f2010-03-16 08:03:29 +00001562 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563}
1564
Tejun Heo58292cbe2013-09-11 22:29:04 -04001565int netdev_class_create_file_ns(struct class_attribute *class_attr,
1566 const void *ns)
Jay Vosburghb8a97872008-06-13 18:12:04 -07001567{
Tejun Heo58292cbe2013-09-11 22:29:04 -04001568 return class_create_file_ns(&net_class, class_attr, ns);
Jay Vosburghb8a97872008-06-13 18:12:04 -07001569}
Tejun Heo58292cbe2013-09-11 22:29:04 -04001570EXPORT_SYMBOL(netdev_class_create_file_ns);
Jay Vosburghb8a97872008-06-13 18:12:04 -07001571
Tejun Heo58292cbe2013-09-11 22:29:04 -04001572void netdev_class_remove_file_ns(struct class_attribute *class_attr,
1573 const void *ns)
Jay Vosburghb8a97872008-06-13 18:12:04 -07001574{
Tejun Heo58292cbe2013-09-11 22:29:04 -04001575 class_remove_file_ns(&net_class, class_attr, ns);
Jay Vosburghb8a97872008-06-13 18:12:04 -07001576}
Tejun Heo58292cbe2013-09-11 22:29:04 -04001577EXPORT_SYMBOL(netdev_class_remove_file_ns);
Jay Vosburghb8a97872008-06-13 18:12:04 -07001578
Daniel Borkmanna48d4bb2014-01-06 01:20:11 +01001579int __init netdev_kobject_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580{
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001581 kobj_ns_type_register(&net_ns_type_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582 return class_register(&net_class);
1583}