blob: 65ea0ff4017c166fea648f3ef3db57966f44aa66 [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>
Ingo Molnar174cd4b2017-02-02 19:15:33 +010018#include <linux/sched/signal.h>
Eric W. Biederman608b4b92010-05-04 17:36:45 -070019#include <linux/nsproxy.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <net/sock.h>
Eric W. Biederman608b4b92010-05-04 17:36:45 -070021#include <net/net_namespace.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070022#include <linux/rtnetlink.h>
Tom Herbertfec5e652010-04-16 16:01:27 -070023#include <linux/vmalloc.h>
Paul Gortmakerbc3b2d72011-07-15 11:47:34 -040024#include <linux/export.h>
Tom Herbert114cf582011-11-28 16:33:09 +000025#include <linux/jiffies.h>
Ming Lei9802c8e2013-02-22 16:34:16 -080026#include <linux/pm_runtime.h>
Florian Fainelliaa836df2015-03-09 14:31:20 -070027#include <linux/of.h>
Ben Dooks88832a22016-06-07 19:27:51 +010028#include <linux/of_net.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070029
Pavel Emelyanov342709e2007-10-23 21:14:45 -070030#include "net-sysfs.h"
31
Eric W. Biederman8b41d182007-09-26 22:02:53 -070032#ifdef CONFIG_SYSFS
Linus Torvalds1da177e2005-04-16 15:20:36 -070033static const char fmt_hex[] = "%#x\n";
34static const char fmt_dec[] = "%d\n";
35static const char fmt_ulong[] = "%lu\n";
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +000036static const char fmt_u64[] = "%llu\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +090038static inline int dev_isalive(const struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070039{
Stephen Hemmingerfe9925b2006-05-06 17:56:03 -070040 return dev->reg_state <= NETREG_REGISTERED;
Linus Torvalds1da177e2005-04-16 15:20:36 -070041}
42
43/* use same locking rules as GIF* ioctl's */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070044static ssize_t netdev_show(const struct device *dev,
45 struct device_attribute *attr, char *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -070046 ssize_t (*format)(const struct net_device *, char *))
47{
WANG Cong6b53daf2014-07-23 16:09:10 -070048 struct net_device *ndev = to_net_dev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 ssize_t ret = -EINVAL;
50
51 read_lock(&dev_base_lock);
WANG Cong6b53daf2014-07-23 16:09:10 -070052 if (dev_isalive(ndev))
53 ret = (*format)(ndev, buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -070054 read_unlock(&dev_base_lock);
55
56 return ret;
57}
58
59/* generate a show function for simple field */
60#define NETDEVICE_SHOW(field, format_string) \
WANG Cong6b53daf2014-07-23 16:09:10 -070061static ssize_t format_##field(const struct net_device *dev, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -070062{ \
WANG Cong6b53daf2014-07-23 16:09:10 -070063 return sprintf(buf, format_string, dev->field); \
Linus Torvalds1da177e2005-04-16 15:20:36 -070064} \
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -070065static ssize_t field##_show(struct device *dev, \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070066 struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -070067{ \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070068 return netdev_show(dev, attr, buf, format_##field); \
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -070069} \
Linus Torvalds1da177e2005-04-16 15:20:36 -070070
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -070071#define NETDEVICE_SHOW_RO(field, format_string) \
72NETDEVICE_SHOW(field, format_string); \
73static DEVICE_ATTR_RO(field)
74
75#define NETDEVICE_SHOW_RW(field, format_string) \
76NETDEVICE_SHOW(field, format_string); \
77static DEVICE_ATTR_RW(field)
Linus Torvalds1da177e2005-04-16 15:20:36 -070078
79/* use same locking and permission rules as SIF* ioctl's */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070080static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -070081 const char *buf, size_t len,
82 int (*set)(struct net_device *, unsigned long))
83{
Eric W. Biederman5e1fccc2012-11-16 03:03:04 +000084 struct net_device *netdev = to_net_dev(dev);
85 struct net *net = dev_net(netdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070086 unsigned long new;
87 int ret = -EINVAL;
88
Eric W. Biederman5e1fccc2012-11-16 03:03:04 +000089 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Linus Torvalds1da177e2005-04-16 15:20:36 -070090 return -EPERM;
91
Shuah Khane1e420c2012-04-12 09:28:13 +000092 ret = kstrtoul(buf, 0, &new);
93 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -070094 goto err;
95
Stephen Hemminger5a5990d2009-02-26 06:49:24 +000096 if (!rtnl_trylock())
Eric W. Biederman336ca572009-05-13 16:57:25 +000097 return restart_syscall();
Stephen Hemminger5a5990d2009-02-26 06:49:24 +000098
Eric W. Biederman5e1fccc2012-11-16 03:03:04 +000099 if (dev_isalive(netdev)) {
100 if ((ret = (*set)(netdev, new)) == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 ret = len;
102 }
103 rtnl_unlock();
104 err:
105 return ret;
106}
107
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700108NETDEVICE_SHOW_RO(dev_id, fmt_hex);
Amir Vadai3f859442014-02-25 18:17:50 +0200109NETDEVICE_SHOW_RO(dev_port, fmt_dec);
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700110NETDEVICE_SHOW_RO(addr_assign_type, fmt_dec);
111NETDEVICE_SHOW_RO(addr_len, fmt_dec);
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700112NETDEVICE_SHOW_RO(ifindex, fmt_dec);
113NETDEVICE_SHOW_RO(type, fmt_dec);
114NETDEVICE_SHOW_RO(link_mode, fmt_dec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115
Nicolas Dichtela54acb32015-04-02 17:07:00 +0200116static ssize_t iflink_show(struct device *dev, struct device_attribute *attr,
117 char *buf)
118{
119 struct net_device *ndev = to_net_dev(dev);
120
121 return sprintf(buf, fmt_dec, dev_get_iflink(ndev));
122}
123static DEVICE_ATTR_RO(iflink);
124
WANG Cong6b53daf2014-07-23 16:09:10 -0700125static ssize_t format_name_assign_type(const struct net_device *dev, char *buf)
Tom Gundersen685343f2014-07-14 16:37:22 +0200126{
WANG Cong6b53daf2014-07-23 16:09:10 -0700127 return sprintf(buf, fmt_dec, dev->name_assign_type);
Tom Gundersen685343f2014-07-14 16:37:22 +0200128}
129
130static ssize_t name_assign_type_show(struct device *dev,
131 struct device_attribute *attr,
132 char *buf)
133{
WANG Cong6b53daf2014-07-23 16:09:10 -0700134 struct net_device *ndev = to_net_dev(dev);
Tom Gundersen685343f2014-07-14 16:37:22 +0200135 ssize_t ret = -EINVAL;
136
WANG Cong6b53daf2014-07-23 16:09:10 -0700137 if (ndev->name_assign_type != NET_NAME_UNKNOWN)
Tom Gundersen685343f2014-07-14 16:37:22 +0200138 ret = netdev_show(dev, attr, buf, format_name_assign_type);
139
140 return ret;
141}
142static DEVICE_ATTR_RO(name_assign_type);
143
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144/* use same locking rules as GIFHWADDR ioctl's */
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700145static ssize_t address_show(struct device *dev, struct device_attribute *attr,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700146 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147{
WANG Cong6b53daf2014-07-23 16:09:10 -0700148 struct net_device *ndev = to_net_dev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 ssize_t ret = -EINVAL;
150
151 read_lock(&dev_base_lock);
WANG Cong6b53daf2014-07-23 16:09:10 -0700152 if (dev_isalive(ndev))
153 ret = sysfs_format_mac(buf, ndev->dev_addr, ndev->addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 read_unlock(&dev_base_lock);
155 return ret;
156}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700157static DEVICE_ATTR_RO(address);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700159static ssize_t broadcast_show(struct device *dev,
160 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161{
WANG Cong6b53daf2014-07-23 16:09:10 -0700162 struct net_device *ndev = to_net_dev(dev);
163 if (dev_isalive(ndev))
164 return sysfs_format_mac(buf, ndev->broadcast, ndev->addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700165 return -EINVAL;
166}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700167static DEVICE_ATTR_RO(broadcast);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168
WANG Cong6b53daf2014-07-23 16:09:10 -0700169static int change_carrier(struct net_device *dev, unsigned long new_carrier)
Jiri Pirkofdae0fd2012-12-27 23:49:38 +0000170{
WANG Cong6b53daf2014-07-23 16:09:10 -0700171 if (!netif_running(dev))
Jiri Pirkofdae0fd2012-12-27 23:49:38 +0000172 return -EINVAL;
WANG Cong6b53daf2014-07-23 16:09:10 -0700173 return dev_change_carrier(dev, (bool) new_carrier);
Jiri Pirkofdae0fd2012-12-27 23:49:38 +0000174}
175
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700176static ssize_t carrier_store(struct device *dev, struct device_attribute *attr,
177 const char *buf, size_t len)
Jiri Pirkofdae0fd2012-12-27 23:49:38 +0000178{
179 return netdev_store(dev, attr, buf, len, change_carrier);
180}
181
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700182static ssize_t carrier_show(struct device *dev,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700183 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184{
185 struct net_device *netdev = to_net_dev(dev);
186 if (netif_running(netdev)) {
187 return sprintf(buf, fmt_dec, !!netif_carrier_ok(netdev));
188 }
189 return -EINVAL;
190}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700191static DEVICE_ATTR_RW(carrier);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700193static ssize_t speed_show(struct device *dev,
Andy Gospodarekd519e172009-10-02 09:26:12 +0000194 struct device_attribute *attr, char *buf)
195{
196 struct net_device *netdev = to_net_dev(dev);
197 int ret = -EINVAL;
198
199 if (!rtnl_trylock())
200 return restart_syscall();
201
David Decotigny8ae6daca2011-04-27 18:32:38 +0000202 if (netif_running(netdev)) {
David Decotigny7cad1ba2016-02-24 10:58:10 -0800203 struct ethtool_link_ksettings cmd;
204
205 if (!__ethtool_get_link_ksettings(netdev, &cmd))
206 ret = sprintf(buf, fmt_dec, cmd.base.speed);
Andy Gospodarekd519e172009-10-02 09:26:12 +0000207 }
208 rtnl_unlock();
209 return ret;
210}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700211static DEVICE_ATTR_RO(speed);
Andy Gospodarekd519e172009-10-02 09:26:12 +0000212
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700213static ssize_t duplex_show(struct device *dev,
Andy Gospodarekd519e172009-10-02 09:26:12 +0000214 struct device_attribute *attr, char *buf)
215{
216 struct net_device *netdev = to_net_dev(dev);
217 int ret = -EINVAL;
218
219 if (!rtnl_trylock())
220 return restart_syscall();
221
David Decotigny8ae6daca2011-04-27 18:32:38 +0000222 if (netif_running(netdev)) {
David Decotigny7cad1ba2016-02-24 10:58:10 -0800223 struct ethtool_link_ksettings cmd;
224
225 if (!__ethtool_get_link_ksettings(netdev, &cmd)) {
Nikolay Aleksandrovc6c13962012-09-05 04:11:28 +0000226 const char *duplex;
David Decotigny7cad1ba2016-02-24 10:58:10 -0800227
228 switch (cmd.base.duplex) {
Nikolay Aleksandrovc6c13962012-09-05 04:11:28 +0000229 case DUPLEX_HALF:
230 duplex = "half";
231 break;
232 case DUPLEX_FULL:
233 duplex = "full";
234 break;
235 default:
236 duplex = "unknown";
237 break;
238 }
239 ret = sprintf(buf, "%s\n", duplex);
240 }
Andy Gospodarekd519e172009-10-02 09:26:12 +0000241 }
242 rtnl_unlock();
243 return ret;
244}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700245static DEVICE_ATTR_RO(duplex);
Andy Gospodarekd519e172009-10-02 09:26:12 +0000246
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700247static ssize_t dormant_show(struct device *dev,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700248 struct device_attribute *attr, char *buf)
Stefan Rompfb00055a2006-03-20 17:09:11 -0800249{
250 struct net_device *netdev = to_net_dev(dev);
251
252 if (netif_running(netdev))
253 return sprintf(buf, fmt_dec, !!netif_dormant(netdev));
254
255 return -EINVAL;
256}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700257static DEVICE_ATTR_RO(dormant);
Stefan Rompfb00055a2006-03-20 17:09:11 -0800258
Jan Engelhardt36cbd3d2009-08-05 10:42:58 -0700259static const char *const operstates[] = {
Stefan Rompfb00055a2006-03-20 17:09:11 -0800260 "unknown",
261 "notpresent", /* currently unused */
262 "down",
263 "lowerlayerdown",
264 "testing", /* currently unused */
265 "dormant",
266 "up"
267};
268
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700269static ssize_t operstate_show(struct device *dev,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700270 struct device_attribute *attr, char *buf)
Stefan Rompfb00055a2006-03-20 17:09:11 -0800271{
272 const struct net_device *netdev = to_net_dev(dev);
273 unsigned char operstate;
274
275 read_lock(&dev_base_lock);
276 operstate = netdev->operstate;
277 if (!netif_running(netdev))
278 operstate = IF_OPER_DOWN;
279 read_unlock(&dev_base_lock);
280
Adrian Bunke3a5cd92006-04-05 22:19:47 -0700281 if (operstate >= ARRAY_SIZE(operstates))
Stefan Rompfb00055a2006-03-20 17:09:11 -0800282 return -EINVAL; /* should not happen */
283
284 return sprintf(buf, "%s\n", operstates[operstate]);
285}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700286static DEVICE_ATTR_RO(operstate);
Stefan Rompfb00055a2006-03-20 17:09:11 -0800287
david decotigny2d3b4792014-03-29 09:48:35 -0700288static ssize_t carrier_changes_show(struct device *dev,
289 struct device_attribute *attr,
290 char *buf)
291{
292 struct net_device *netdev = to_net_dev(dev);
293 return sprintf(buf, fmt_dec,
294 atomic_read(&netdev->carrier_changes));
295}
296static DEVICE_ATTR_RO(carrier_changes);
297
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298/* read-write attributes */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299
WANG Cong6b53daf2014-07-23 16:09:10 -0700300static int change_mtu(struct net_device *dev, unsigned long new_mtu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301{
WANG Cong6b53daf2014-07-23 16:09:10 -0700302 return dev_set_mtu(dev, (int) new_mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303}
304
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700305static ssize_t mtu_store(struct device *dev, struct device_attribute *attr,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700306 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700308 return netdev_store(dev, attr, buf, len, change_mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700310NETDEVICE_SHOW_RW(mtu, fmt_dec);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311
WANG Cong6b53daf2014-07-23 16:09:10 -0700312static int change_flags(struct net_device *dev, unsigned long new_flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313{
WANG Cong6b53daf2014-07-23 16:09:10 -0700314 return dev_change_flags(dev, (unsigned int) new_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315}
316
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700317static ssize_t flags_store(struct device *dev, struct device_attribute *attr,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700318 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700320 return netdev_store(dev, attr, buf, len, change_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700322NETDEVICE_SHOW_RW(flags, fmt_hex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323
WANG Cong6b53daf2014-07-23 16:09:10 -0700324static int change_tx_queue_len(struct net_device *dev, unsigned long new_len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325{
Jason Wang08294a22016-06-30 14:45:35 +0800326 int res, orig_len = dev->tx_queue_len;
327
328 if (new_len != orig_len) {
329 dev->tx_queue_len = new_len;
330 res = call_netdevice_notifiers(NETDEV_CHANGE_TX_QUEUE_LEN, dev);
331 res = notifier_to_errno(res);
332 if (res) {
333 netdev_err(dev,
334 "refused to change device tx_queue_len\n");
335 dev->tx_queue_len = orig_len;
336 return -EFAULT;
337 }
338 }
339
Linus Torvalds1da177e2005-04-16 15:20:36 -0700340 return 0;
341}
342
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700343static ssize_t tx_queue_len_store(struct device *dev,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700344 struct device_attribute *attr,
345 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346{
Eric W. Biederman5e1fccc2012-11-16 03:03:04 +0000347 if (!capable(CAP_NET_ADMIN))
348 return -EPERM;
349
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700350 return netdev_store(dev, attr, buf, len, change_tx_queue_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700352NETDEVICE_SHOW_RW(tx_queue_len, fmt_ulong);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353
Eric Dumazet3b47d302014-11-06 21:09:44 -0800354static int change_gro_flush_timeout(struct net_device *dev, unsigned long val)
355{
356 dev->gro_flush_timeout = val;
357 return 0;
358}
359
360static ssize_t gro_flush_timeout_store(struct device *dev,
361 struct device_attribute *attr,
362 const char *buf, size_t len)
363{
364 if (!capable(CAP_NET_ADMIN))
365 return -EPERM;
366
367 return netdev_store(dev, attr, buf, len, change_gro_flush_timeout);
368}
369NETDEVICE_SHOW_RW(gro_flush_timeout, fmt_ulong);
370
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700371static ssize_t ifalias_store(struct device *dev, struct device_attribute *attr,
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700372 const char *buf, size_t len)
373{
374 struct net_device *netdev = to_net_dev(dev);
Eric W. Biederman5e1fccc2012-11-16 03:03:04 +0000375 struct net *net = dev_net(netdev);
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700376 size_t count = len;
377 ssize_t ret;
378
Eric W. Biederman5e1fccc2012-11-16 03:03:04 +0000379 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700380 return -EPERM;
381
382 /* ignore trailing newline */
383 if (len > 0 && buf[len - 1] == '\n')
384 --count;
385
Eric W. Biederman336ca572009-05-13 16:57:25 +0000386 if (!rtnl_trylock())
387 return restart_syscall();
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700388 ret = dev_set_alias(netdev, buf, count);
389 rtnl_unlock();
390
391 return ret < 0 ? ret : len;
392}
393
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700394static ssize_t ifalias_show(struct device *dev,
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700395 struct device_attribute *attr, char *buf)
396{
397 const struct net_device *netdev = to_net_dev(dev);
398 ssize_t ret = 0;
399
Eric W. Biederman336ca572009-05-13 16:57:25 +0000400 if (!rtnl_trylock())
401 return restart_syscall();
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700402 if (netdev->ifalias)
403 ret = sprintf(buf, "%s\n", netdev->ifalias);
404 rtnl_unlock();
405 return ret;
406}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700407static DEVICE_ATTR_RW(ifalias);
Vlad Dogarua512b922011-01-24 03:37:29 +0000408
WANG Cong6b53daf2014-07-23 16:09:10 -0700409static int change_group(struct net_device *dev, unsigned long new_group)
Vlad Dogarua512b922011-01-24 03:37:29 +0000410{
WANG Cong6b53daf2014-07-23 16:09:10 -0700411 dev_set_group(dev, (int) new_group);
Vlad Dogarua512b922011-01-24 03:37:29 +0000412 return 0;
413}
414
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700415static ssize_t group_store(struct device *dev, struct device_attribute *attr,
416 const char *buf, size_t len)
Vlad Dogarua512b922011-01-24 03:37:29 +0000417{
418 return netdev_store(dev, attr, buf, len, change_group);
419}
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700420NETDEVICE_SHOW(group, fmt_dec);
421static DEVICE_ATTR(netdev_group, S_IRUGO | S_IWUSR, group_show, group_store);
Vlad Dogarua512b922011-01-24 03:37:29 +0000422
Anuradha Karuppiahd746d702015-07-14 13:43:19 -0700423static int change_proto_down(struct net_device *dev, unsigned long proto_down)
424{
425 return dev_change_proto_down(dev, (bool) proto_down);
426}
427
428static ssize_t proto_down_store(struct device *dev,
429 struct device_attribute *attr,
430 const char *buf, size_t len)
431{
432 return netdev_store(dev, attr, buf, len, change_proto_down);
433}
434NETDEVICE_SHOW_RW(proto_down, fmt_dec);
435
Linus Torvaldscc998ff2013-09-05 14:54:29 -0700436static ssize_t phys_port_id_show(struct device *dev,
Jiri Pirkoff80e512013-07-29 18:16:51 +0200437 struct device_attribute *attr, char *buf)
438{
439 struct net_device *netdev = to_net_dev(dev);
440 ssize_t ret = -EINVAL;
441
442 if (!rtnl_trylock())
443 return restart_syscall();
444
445 if (dev_isalive(netdev)) {
Jiri Pirko02637fc2014-11-28 14:34:16 +0100446 struct netdev_phys_item_id ppid;
Jiri Pirkoff80e512013-07-29 18:16:51 +0200447
448 ret = dev_get_phys_port_id(netdev, &ppid);
449 if (!ret)
450 ret = sprintf(buf, "%*phN\n", ppid.id_len, ppid.id);
451 }
452 rtnl_unlock();
453
454 return ret;
455}
Linus Torvaldscc998ff2013-09-05 14:54:29 -0700456static DEVICE_ATTR_RO(phys_port_id);
Jiri Pirkoff80e512013-07-29 18:16:51 +0200457
David Aherndb24a902015-03-17 20:23:15 -0600458static ssize_t phys_port_name_show(struct device *dev,
459 struct device_attribute *attr, char *buf)
460{
461 struct net_device *netdev = to_net_dev(dev);
462 ssize_t ret = -EINVAL;
463
464 if (!rtnl_trylock())
465 return restart_syscall();
466
467 if (dev_isalive(netdev)) {
468 char name[IFNAMSIZ];
469
470 ret = dev_get_phys_port_name(netdev, name, sizeof(name));
471 if (!ret)
472 ret = sprintf(buf, "%s\n", name);
473 }
474 rtnl_unlock();
475
476 return ret;
477}
478static DEVICE_ATTR_RO(phys_port_name);
479
Jiri Pirkoaecbe012014-11-28 14:34:19 +0100480static ssize_t phys_switch_id_show(struct device *dev,
481 struct device_attribute *attr, char *buf)
482{
483 struct net_device *netdev = to_net_dev(dev);
484 ssize_t ret = -EINVAL;
485
486 if (!rtnl_trylock())
487 return restart_syscall();
488
489 if (dev_isalive(netdev)) {
Scott Feldmanf8e20a92015-05-10 09:47:49 -0700490 struct switchdev_attr attr = {
Ido Schimmel6ff64f62015-12-15 16:03:35 +0100491 .orig_dev = netdev,
Jiri Pirko1f868392015-10-01 11:03:42 +0200492 .id = SWITCHDEV_ATTR_ID_PORT_PARENT_ID,
Scott Feldmanf8e20a92015-05-10 09:47:49 -0700493 .flags = SWITCHDEV_F_NO_RECURSE,
494 };
Jiri Pirkoaecbe012014-11-28 14:34:19 +0100495
Scott Feldmanf8e20a92015-05-10 09:47:49 -0700496 ret = switchdev_port_attr_get(netdev, &attr);
Jiri Pirkoaecbe012014-11-28 14:34:19 +0100497 if (!ret)
Scott Feldman42275bd2015-05-13 11:16:50 -0700498 ret = sprintf(buf, "%*phN\n", attr.u.ppid.id_len,
499 attr.u.ppid.id);
Jiri Pirkoaecbe012014-11-28 14:34:19 +0100500 }
501 rtnl_unlock();
502
503 return ret;
504}
505static DEVICE_ATTR_RO(phys_switch_id);
506
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700507static struct attribute *net_class_attrs[] = {
508 &dev_attr_netdev_group.attr,
509 &dev_attr_type.attr,
510 &dev_attr_dev_id.attr,
Amir Vadai3f859442014-02-25 18:17:50 +0200511 &dev_attr_dev_port.attr,
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700512 &dev_attr_iflink.attr,
513 &dev_attr_ifindex.attr,
Tom Gundersen685343f2014-07-14 16:37:22 +0200514 &dev_attr_name_assign_type.attr,
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700515 &dev_attr_addr_assign_type.attr,
516 &dev_attr_addr_len.attr,
517 &dev_attr_link_mode.attr,
518 &dev_attr_address.attr,
519 &dev_attr_broadcast.attr,
520 &dev_attr_speed.attr,
521 &dev_attr_duplex.attr,
522 &dev_attr_dormant.attr,
523 &dev_attr_operstate.attr,
david decotigny2d3b4792014-03-29 09:48:35 -0700524 &dev_attr_carrier_changes.attr,
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700525 &dev_attr_ifalias.attr,
526 &dev_attr_carrier.attr,
527 &dev_attr_mtu.attr,
528 &dev_attr_flags.attr,
529 &dev_attr_tx_queue_len.attr,
Eric Dumazet3b47d302014-11-06 21:09:44 -0800530 &dev_attr_gro_flush_timeout.attr,
Linus Torvaldscc998ff2013-09-05 14:54:29 -0700531 &dev_attr_phys_port_id.attr,
David Aherndb24a902015-03-17 20:23:15 -0600532 &dev_attr_phys_port_name.attr,
Jiri Pirkoaecbe012014-11-28 14:34:19 +0100533 &dev_attr_phys_switch_id.attr,
Anuradha Karuppiahd746d702015-07-14 13:43:19 -0700534 &dev_attr_proto_down.attr,
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700535 NULL,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536};
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700537ATTRIBUTE_GROUPS(net_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
539/* Show a given an attribute in the statistics group */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700540static ssize_t netstat_show(const struct device *d,
541 struct device_attribute *attr, char *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 unsigned long offset)
543{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700544 struct net_device *dev = to_net_dev(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 ssize_t ret = -EINVAL;
546
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000547 WARN_ON(offset > sizeof(struct rtnl_link_stats64) ||
548 offset % sizeof(u64) != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549
550 read_lock(&dev_base_lock);
Pavel Emelyanov96e74082008-05-21 14:12:46 -0700551 if (dev_isalive(dev)) {
Eric Dumazet28172732010-07-07 14:58:56 -0700552 struct rtnl_link_stats64 temp;
553 const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);
554
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000555 ret = sprintf(buf, fmt_u64, *(u64 *)(((u8 *) stats) + offset));
Pavel Emelyanov96e74082008-05-21 14:12:46 -0700556 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 read_unlock(&dev_base_lock);
558 return ret;
559}
560
561/* generate a read-only statistics attribute */
562#define NETSTAT_ENTRY(name) \
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700563static ssize_t name##_show(struct device *d, \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700564 struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565{ \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700566 return netstat_show(d, attr, buf, \
Ben Hutchingsbe1f3c22010-06-08 07:19:54 +0000567 offsetof(struct rtnl_link_stats64, name)); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700568} \
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700569static DEVICE_ATTR_RO(name)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570
571NETSTAT_ENTRY(rx_packets);
572NETSTAT_ENTRY(tx_packets);
573NETSTAT_ENTRY(rx_bytes);
574NETSTAT_ENTRY(tx_bytes);
575NETSTAT_ENTRY(rx_errors);
576NETSTAT_ENTRY(tx_errors);
577NETSTAT_ENTRY(rx_dropped);
578NETSTAT_ENTRY(tx_dropped);
579NETSTAT_ENTRY(multicast);
580NETSTAT_ENTRY(collisions);
581NETSTAT_ENTRY(rx_length_errors);
582NETSTAT_ENTRY(rx_over_errors);
583NETSTAT_ENTRY(rx_crc_errors);
584NETSTAT_ENTRY(rx_frame_errors);
585NETSTAT_ENTRY(rx_fifo_errors);
586NETSTAT_ENTRY(rx_missed_errors);
587NETSTAT_ENTRY(tx_aborted_errors);
588NETSTAT_ENTRY(tx_carrier_errors);
589NETSTAT_ENTRY(tx_fifo_errors);
590NETSTAT_ENTRY(tx_heartbeat_errors);
591NETSTAT_ENTRY(tx_window_errors);
592NETSTAT_ENTRY(rx_compressed);
593NETSTAT_ENTRY(tx_compressed);
Jarod Wilson6e7333d2016-02-01 18:51:05 -0500594NETSTAT_ENTRY(rx_nohandler);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595
596static struct attribute *netstat_attrs[] = {
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700597 &dev_attr_rx_packets.attr,
598 &dev_attr_tx_packets.attr,
599 &dev_attr_rx_bytes.attr,
600 &dev_attr_tx_bytes.attr,
601 &dev_attr_rx_errors.attr,
602 &dev_attr_tx_errors.attr,
603 &dev_attr_rx_dropped.attr,
604 &dev_attr_tx_dropped.attr,
605 &dev_attr_multicast.attr,
606 &dev_attr_collisions.attr,
607 &dev_attr_rx_length_errors.attr,
608 &dev_attr_rx_over_errors.attr,
609 &dev_attr_rx_crc_errors.attr,
610 &dev_attr_rx_frame_errors.attr,
611 &dev_attr_rx_fifo_errors.attr,
612 &dev_attr_rx_missed_errors.attr,
613 &dev_attr_tx_aborted_errors.attr,
614 &dev_attr_tx_carrier_errors.attr,
615 &dev_attr_tx_fifo_errors.attr,
616 &dev_attr_tx_heartbeat_errors.attr,
617 &dev_attr_tx_window_errors.attr,
618 &dev_attr_rx_compressed.attr,
619 &dev_attr_tx_compressed.attr,
Jarod Wilson6e7333d2016-02-01 18:51:05 -0500620 &dev_attr_rx_nohandler.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 NULL
622};
623
624
625static struct attribute_group netstat_group = {
626 .name = "statistics",
627 .attrs = netstat_attrs,
628};
Johannes Berg38c1a012012-11-16 20:46:19 +0100629
630#if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211)
631static struct attribute *wireless_attrs[] = {
632 NULL
633};
634
635static struct attribute_group wireless_group = {
636 .name = "wireless",
637 .attrs = wireless_attrs,
638};
639#endif
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -0700640
641#else /* CONFIG_SYSFS */
642#define net_class_groups NULL
Eric W. Biedermand6523dd2010-05-16 21:59:45 -0700643#endif /* CONFIG_SYSFS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
Michael Daltona953be52014-01-16 22:23:28 -0800645#ifdef CONFIG_SYSFS
Tom Herbert0a9627f2010-03-16 08:03:29 +0000646#define to_rx_queue_attr(_attr) container_of(_attr, \
647 struct rx_queue_attribute, attr)
648
649#define to_rx_queue(obj) container_of(obj, struct netdev_rx_queue, kobj)
650
651static ssize_t rx_queue_attr_show(struct kobject *kobj, struct attribute *attr,
652 char *buf)
653{
654 struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
655 struct netdev_rx_queue *queue = to_rx_queue(kobj);
656
657 if (!attribute->show)
658 return -EIO;
659
660 return attribute->show(queue, attribute, buf);
661}
662
663static ssize_t rx_queue_attr_store(struct kobject *kobj, struct attribute *attr,
664 const char *buf, size_t count)
665{
666 struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
667 struct netdev_rx_queue *queue = to_rx_queue(kobj);
668
669 if (!attribute->store)
670 return -EIO;
671
672 return attribute->store(queue, attribute, buf, count);
673}
674
stephen hemmingerfa50d642010-08-31 12:14:13 +0000675static const struct sysfs_ops rx_queue_sysfs_ops = {
Tom Herbert0a9627f2010-03-16 08:03:29 +0000676 .show = rx_queue_attr_show,
677 .store = rx_queue_attr_store,
678};
679
Michael Daltona953be52014-01-16 22:23:28 -0800680#ifdef CONFIG_RPS
Tom Herbert0a9627f2010-03-16 08:03:29 +0000681static ssize_t show_rps_map(struct netdev_rx_queue *queue,
682 struct rx_queue_attribute *attribute, char *buf)
683{
684 struct rps_map *map;
685 cpumask_var_t mask;
Tejun Heof0906822015-02-13 14:37:42 -0800686 int i, len;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000687
688 if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
689 return -ENOMEM;
690
691 rcu_read_lock();
692 map = rcu_dereference(queue->rps_map);
693 if (map)
694 for (i = 0; i < map->len; i++)
695 cpumask_set_cpu(map->cpus[i], mask);
696
Tejun Heof0906822015-02-13 14:37:42 -0800697 len = snprintf(buf, PAGE_SIZE, "%*pb\n", cpumask_pr_args(mask));
Tom Herbert0a9627f2010-03-16 08:03:29 +0000698 rcu_read_unlock();
Tom Herbert0a9627f2010-03-16 08:03:29 +0000699 free_cpumask_var(mask);
Tejun Heof0906822015-02-13 14:37:42 -0800700
701 return len < PAGE_SIZE ? len : -EINVAL;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000702}
703
Eric Dumazetf5acb902010-04-19 14:40:57 -0700704static ssize_t store_rps_map(struct netdev_rx_queue *queue,
Tom Herbert0a9627f2010-03-16 08:03:29 +0000705 struct rx_queue_attribute *attribute,
706 const char *buf, size_t len)
707{
708 struct rps_map *old_map, *map;
709 cpumask_var_t mask;
710 int err, cpu, i;
Sasha Levinda65ad12015-08-13 14:03:16 -0400711 static DEFINE_MUTEX(rps_map_mutex);
Tom Herbert0a9627f2010-03-16 08:03:29 +0000712
713 if (!capable(CAP_NET_ADMIN))
714 return -EPERM;
715
716 if (!alloc_cpumask_var(&mask, GFP_KERNEL))
717 return -ENOMEM;
718
719 err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
720 if (err) {
721 free_cpumask_var(mask);
722 return err;
723 }
724
Eric Dumazet95c96172012-04-15 05:58:06 +0000725 map = kzalloc(max_t(unsigned int,
Tom Herbert0a9627f2010-03-16 08:03:29 +0000726 RPS_MAP_SIZE(cpumask_weight(mask)), L1_CACHE_BYTES),
727 GFP_KERNEL);
728 if (!map) {
729 free_cpumask_var(mask);
730 return -ENOMEM;
731 }
732
733 i = 0;
734 for_each_cpu_and(cpu, mask, cpu_online_mask)
735 map->cpus[i++] = cpu;
736
737 if (i)
738 map->len = i;
739 else {
740 kfree(map);
741 map = NULL;
742 }
743
Sasha Levinda65ad12015-08-13 14:03:16 -0400744 mutex_lock(&rps_map_mutex);
Eric Dumazet6e3f7fa2010-10-25 03:02:02 +0000745 old_map = rcu_dereference_protected(queue->rps_map,
Sasha Levinda65ad12015-08-13 14:03:16 -0400746 mutex_is_locked(&rps_map_mutex));
Tom Herbert0a9627f2010-03-16 08:03:29 +0000747 rcu_assign_pointer(queue->rps_map, map);
Tom Herbert0a9627f2010-03-16 08:03:29 +0000748
Eric Dumazetadc93002011-11-17 03:13:26 +0000749 if (map)
Ingo Molnarc5905af2012-02-24 08:31:31 +0100750 static_key_slow_inc(&rps_needed);
Tom Herbert10e4ea72015-08-05 09:39:27 -0700751 if (old_map)
Ingo Molnarc5905af2012-02-24 08:31:31 +0100752 static_key_slow_dec(&rps_needed);
Tom Herbert10e4ea72015-08-05 09:39:27 -0700753
Sasha Levinda65ad12015-08-13 14:03:16 -0400754 mutex_unlock(&rps_map_mutex);
Tom Herbert10e4ea72015-08-05 09:39:27 -0700755
756 if (old_map)
757 kfree_rcu(old_map, rcu);
758
Tom Herbert0a9627f2010-03-16 08:03:29 +0000759 free_cpumask_var(mask);
760 return len;
761}
762
Tom Herbertfec5e652010-04-16 16:01:27 -0700763static ssize_t show_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
764 struct rx_queue_attribute *attr,
765 char *buf)
766{
767 struct rps_dev_flow_table *flow_table;
Eric Dumazet60b778c2011-12-24 06:56:49 +0000768 unsigned long val = 0;
Tom Herbertfec5e652010-04-16 16:01:27 -0700769
770 rcu_read_lock();
771 flow_table = rcu_dereference(queue->rps_flow_table);
772 if (flow_table)
Eric Dumazet60b778c2011-12-24 06:56:49 +0000773 val = (unsigned long)flow_table->mask + 1;
Tom Herbertfec5e652010-04-16 16:01:27 -0700774 rcu_read_unlock();
775
Eric Dumazet60b778c2011-12-24 06:56:49 +0000776 return sprintf(buf, "%lu\n", val);
Tom Herbertfec5e652010-04-16 16:01:27 -0700777}
778
Tom Herbertfec5e652010-04-16 16:01:27 -0700779static void rps_dev_flow_table_release(struct rcu_head *rcu)
780{
781 struct rps_dev_flow_table *table = container_of(rcu,
782 struct rps_dev_flow_table, rcu);
Al Viro243198d2013-05-05 16:05:55 +0000783 vfree(table);
Tom Herbertfec5e652010-04-16 16:01:27 -0700784}
785
Eric Dumazetf5acb902010-04-19 14:40:57 -0700786static ssize_t store_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
Tom Herbertfec5e652010-04-16 16:01:27 -0700787 struct rx_queue_attribute *attr,
788 const char *buf, size_t len)
789{
Eric Dumazet60b778c2011-12-24 06:56:49 +0000790 unsigned long mask, count;
Tom Herbertfec5e652010-04-16 16:01:27 -0700791 struct rps_dev_flow_table *table, *old_table;
792 static DEFINE_SPINLOCK(rps_dev_flow_lock);
Eric Dumazet60b778c2011-12-24 06:56:49 +0000793 int rc;
Tom Herbertfec5e652010-04-16 16:01:27 -0700794
795 if (!capable(CAP_NET_ADMIN))
796 return -EPERM;
797
Eric Dumazet60b778c2011-12-24 06:56:49 +0000798 rc = kstrtoul(buf, 0, &count);
799 if (rc < 0)
800 return rc;
Tom Herbertfec5e652010-04-16 16:01:27 -0700801
802 if (count) {
Eric Dumazet60b778c2011-12-24 06:56:49 +0000803 mask = count - 1;
804 /* mask = roundup_pow_of_two(count) - 1;
805 * without overflows...
806 */
807 while ((mask | (mask >> 1)) != mask)
808 mask |= (mask >> 1);
809 /* On 64 bit arches, must check mask fits in table->mask (u32),
stephen hemminger8e3bff92013-12-08 12:15:44 -0800810 * and on 32bit arches, must check
811 * RPS_DEV_FLOW_TABLE_SIZE(mask + 1) doesn't overflow.
Eric Dumazet60b778c2011-12-24 06:56:49 +0000812 */
813#if BITS_PER_LONG > 32
814 if (mask > (unsigned long)(u32)mask)
Xi Wanga0a129f2011-12-22 13:35:22 +0000815 return -EINVAL;
Eric Dumazet60b778c2011-12-24 06:56:49 +0000816#else
817 if (mask > (ULONG_MAX - RPS_DEV_FLOW_TABLE_SIZE(1))
Xi Wanga0a129f2011-12-22 13:35:22 +0000818 / sizeof(struct rps_dev_flow)) {
Tom Herbertfec5e652010-04-16 16:01:27 -0700819 /* Enforce a limit to prevent overflow */
820 return -EINVAL;
821 }
Eric Dumazet60b778c2011-12-24 06:56:49 +0000822#endif
823 table = vmalloc(RPS_DEV_FLOW_TABLE_SIZE(mask + 1));
Tom Herbertfec5e652010-04-16 16:01:27 -0700824 if (!table)
825 return -ENOMEM;
826
Eric Dumazet60b778c2011-12-24 06:56:49 +0000827 table->mask = mask;
828 for (count = 0; count <= mask; count++)
829 table->flows[count].cpu = RPS_NO_CPU;
Tom Herbertfec5e652010-04-16 16:01:27 -0700830 } else
831 table = NULL;
832
833 spin_lock(&rps_dev_flow_lock);
Eric Dumazet6e3f7fa2010-10-25 03:02:02 +0000834 old_table = rcu_dereference_protected(queue->rps_flow_table,
835 lockdep_is_held(&rps_dev_flow_lock));
Tom Herbertfec5e652010-04-16 16:01:27 -0700836 rcu_assign_pointer(queue->rps_flow_table, table);
837 spin_unlock(&rps_dev_flow_lock);
838
839 if (old_table)
840 call_rcu(&old_table->rcu, rps_dev_flow_table_release);
841
842 return len;
843}
844
Tom Herbert0a9627f2010-03-16 08:03:29 +0000845static struct rx_queue_attribute rps_cpus_attribute =
846 __ATTR(rps_cpus, S_IRUGO | S_IWUSR, show_rps_map, store_rps_map);
847
Tom Herbertfec5e652010-04-16 16:01:27 -0700848
849static struct rx_queue_attribute rps_dev_flow_table_cnt_attribute =
850 __ATTR(rps_flow_cnt, S_IRUGO | S_IWUSR,
851 show_rps_dev_flow_table_cnt, store_rps_dev_flow_table_cnt);
Michael Daltona953be52014-01-16 22:23:28 -0800852#endif /* CONFIG_RPS */
Tom Herbertfec5e652010-04-16 16:01:27 -0700853
Tom Herbert0a9627f2010-03-16 08:03:29 +0000854static struct attribute *rx_queue_default_attrs[] = {
Michael Daltona953be52014-01-16 22:23:28 -0800855#ifdef CONFIG_RPS
Tom Herbert0a9627f2010-03-16 08:03:29 +0000856 &rps_cpus_attribute.attr,
Tom Herbertfec5e652010-04-16 16:01:27 -0700857 &rps_dev_flow_table_cnt_attribute.attr,
Michael Daltona953be52014-01-16 22:23:28 -0800858#endif
Tom Herbert0a9627f2010-03-16 08:03:29 +0000859 NULL
860};
861
862static void rx_queue_release(struct kobject *kobj)
863{
864 struct netdev_rx_queue *queue = to_rx_queue(kobj);
Michael Daltona953be52014-01-16 22:23:28 -0800865#ifdef CONFIG_RPS
Eric Dumazet6e3f7fa2010-10-25 03:02:02 +0000866 struct rps_map *map;
867 struct rps_dev_flow_table *flow_table;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000868
Tom Herbertfec5e652010-04-16 16:01:27 -0700869
Eric Dumazet33d480c2011-08-11 19:30:52 +0000870 map = rcu_dereference_protected(queue->rps_map, 1);
John Fastabend9ea19482010-11-16 06:31:39 +0000871 if (map) {
872 RCU_INIT_POINTER(queue->rps_map, NULL);
Lai Jiangshanf6f80232011-03-18 12:01:31 +0800873 kfree_rcu(map, rcu);
John Fastabend9ea19482010-11-16 06:31:39 +0000874 }
Eric Dumazet6e3f7fa2010-10-25 03:02:02 +0000875
Eric Dumazet33d480c2011-08-11 19:30:52 +0000876 flow_table = rcu_dereference_protected(queue->rps_flow_table, 1);
John Fastabend9ea19482010-11-16 06:31:39 +0000877 if (flow_table) {
878 RCU_INIT_POINTER(queue->rps_flow_table, NULL);
Eric Dumazet6e3f7fa2010-10-25 03:02:02 +0000879 call_rcu(&flow_table->rcu, rps_dev_flow_table_release);
John Fastabend9ea19482010-11-16 06:31:39 +0000880 }
Michael Daltona953be52014-01-16 22:23:28 -0800881#endif
Tom Herbert0a9627f2010-03-16 08:03:29 +0000882
John Fastabend9ea19482010-11-16 06:31:39 +0000883 memset(kobj, 0, sizeof(*kobj));
Tom Herbertfe822242010-11-09 10:47:38 +0000884 dev_put(queue->dev);
Tom Herbert0a9627f2010-03-16 08:03:29 +0000885}
886
Weilong Chen82ef3d52014-01-16 17:24:31 +0800887static const void *rx_queue_namespace(struct kobject *kobj)
888{
889 struct netdev_rx_queue *queue = to_rx_queue(kobj);
890 struct device *dev = &queue->dev->dev;
891 const void *ns = NULL;
892
893 if (dev->class && dev->class->ns_type)
894 ns = dev->class->namespace(dev);
895
896 return ns;
897}
898
Tom Herbert0a9627f2010-03-16 08:03:29 +0000899static struct kobj_type rx_queue_ktype = {
900 .sysfs_ops = &rx_queue_sysfs_ops,
901 .release = rx_queue_release,
902 .default_attrs = rx_queue_default_attrs,
Weilong Chen82ef3d52014-01-16 17:24:31 +0800903 .namespace = rx_queue_namespace
Tom Herbert0a9627f2010-03-16 08:03:29 +0000904};
905
WANG Cong6b53daf2014-07-23 16:09:10 -0700906static int rx_queue_add_kobject(struct net_device *dev, int index)
Tom Herbert0a9627f2010-03-16 08:03:29 +0000907{
WANG Cong6b53daf2014-07-23 16:09:10 -0700908 struct netdev_rx_queue *queue = dev->_rx + index;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000909 struct kobject *kobj = &queue->kobj;
910 int error = 0;
911
WANG Cong6b53daf2014-07-23 16:09:10 -0700912 kobj->kset = dev->queues_kset;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000913 error = kobject_init_and_add(kobj, &rx_queue_ktype, NULL,
914 "rx-%u", index);
Michael Daltona953be52014-01-16 22:23:28 -0800915 if (error)
916 goto exit;
917
WANG Cong6b53daf2014-07-23 16:09:10 -0700918 if (dev->sysfs_rx_queue_group) {
919 error = sysfs_create_group(kobj, dev->sysfs_rx_queue_group);
Michael Daltona953be52014-01-16 22:23:28 -0800920 if (error)
921 goto exit;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000922 }
923
924 kobject_uevent(kobj, KOBJ_ADD);
Tom Herbertfe822242010-11-09 10:47:38 +0000925 dev_hold(queue->dev);
Tom Herbert0a9627f2010-03-16 08:03:29 +0000926
927 return error;
Michael Daltona953be52014-01-16 22:23:28 -0800928exit:
929 kobject_put(kobj);
930 return error;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000931}
Paul Bolle80dd6ea2014-02-09 14:07:11 +0100932#endif /* CONFIG_SYSFS */
Tom Herbert0a9627f2010-03-16 08:03:29 +0000933
Ben Hutchings62fe0b42010-09-27 08:24:33 +0000934int
WANG Cong6b53daf2014-07-23 16:09:10 -0700935net_rx_queue_update_kobjects(struct net_device *dev, int old_num, int new_num)
Tom Herbert0a9627f2010-03-16 08:03:29 +0000936{
Michael Daltona953be52014-01-16 22:23:28 -0800937#ifdef CONFIG_SYSFS
Tom Herbert0a9627f2010-03-16 08:03:29 +0000938 int i;
939 int error = 0;
940
Michael Daltona953be52014-01-16 22:23:28 -0800941#ifndef CONFIG_RPS
WANG Cong6b53daf2014-07-23 16:09:10 -0700942 if (!dev->sysfs_rx_queue_group)
Michael Daltona953be52014-01-16 22:23:28 -0800943 return 0;
944#endif
Ben Hutchings62fe0b42010-09-27 08:24:33 +0000945 for (i = old_num; i < new_num; i++) {
WANG Cong6b53daf2014-07-23 16:09:10 -0700946 error = rx_queue_add_kobject(dev, i);
Ben Hutchings62fe0b42010-09-27 08:24:33 +0000947 if (error) {
948 new_num = old_num;
Tom Herbert0a9627f2010-03-16 08:03:29 +0000949 break;
Ben Hutchings62fe0b42010-09-27 08:24:33 +0000950 }
Tom Herbert0a9627f2010-03-16 08:03:29 +0000951 }
952
Michael Daltona953be52014-01-16 22:23:28 -0800953 while (--i >= new_num) {
Andrey Vagin002d8a12016-10-24 19:09:53 -0700954 struct kobject *kobj = &dev->_rx[i].kobj;
955
Andrey Vagin91864f52017-03-12 21:36:18 -0700956 if (!atomic_read(&dev_net(dev)->count))
Andrey Vagin002d8a12016-10-24 19:09:53 -0700957 kobj->uevent_suppress = 1;
WANG Cong6b53daf2014-07-23 16:09:10 -0700958 if (dev->sysfs_rx_queue_group)
Andrey Vagin002d8a12016-10-24 19:09:53 -0700959 sysfs_remove_group(kobj, dev->sysfs_rx_queue_group);
960 kobject_put(kobj);
Michael Daltona953be52014-01-16 22:23:28 -0800961 }
Tom Herbert0a9627f2010-03-16 08:03:29 +0000962
963 return error;
Tom Herbertbf264142010-11-26 08:36:09 +0000964#else
965 return 0;
966#endif
Tom Herbert0a9627f2010-03-16 08:03:29 +0000967}
968
david decotignyccf5ff62011-11-16 12:15:10 +0000969#ifdef CONFIG_SYSFS
Tom Herbert1d24eb42010-11-21 13:17:27 +0000970/*
971 * netdev_queue sysfs structures and functions.
972 */
973struct netdev_queue_attribute {
974 struct attribute attr;
975 ssize_t (*show)(struct netdev_queue *queue,
976 struct netdev_queue_attribute *attr, char *buf);
977 ssize_t (*store)(struct netdev_queue *queue,
978 struct netdev_queue_attribute *attr, const char *buf, size_t len);
979};
980#define to_netdev_queue_attr(_attr) container_of(_attr, \
981 struct netdev_queue_attribute, attr)
982
983#define to_netdev_queue(obj) container_of(obj, struct netdev_queue, kobj)
984
985static ssize_t netdev_queue_attr_show(struct kobject *kobj,
986 struct attribute *attr, char *buf)
Ben Hutchings62fe0b42010-09-27 08:24:33 +0000987{
Tom Herbert1d24eb42010-11-21 13:17:27 +0000988 struct netdev_queue_attribute *attribute = to_netdev_queue_attr(attr);
989 struct netdev_queue *queue = to_netdev_queue(kobj);
990
991 if (!attribute->show)
992 return -EIO;
993
994 return attribute->show(queue, attribute, buf);
995}
996
997static ssize_t netdev_queue_attr_store(struct kobject *kobj,
998 struct attribute *attr,
999 const char *buf, size_t count)
1000{
1001 struct netdev_queue_attribute *attribute = to_netdev_queue_attr(attr);
1002 struct netdev_queue *queue = to_netdev_queue(kobj);
1003
1004 if (!attribute->store)
1005 return -EIO;
1006
1007 return attribute->store(queue, attribute, buf, count);
1008}
1009
1010static const struct sysfs_ops netdev_queue_sysfs_ops = {
1011 .show = netdev_queue_attr_show,
1012 .store = netdev_queue_attr_store,
1013};
1014
david decotignyccf5ff62011-11-16 12:15:10 +00001015static ssize_t show_trans_timeout(struct netdev_queue *queue,
1016 struct netdev_queue_attribute *attribute,
1017 char *buf)
1018{
1019 unsigned long trans_timeout;
1020
1021 spin_lock_irq(&queue->_xmit_lock);
1022 trans_timeout = queue->trans_timeout;
1023 spin_unlock_irq(&queue->_xmit_lock);
1024
1025 return sprintf(buf, "%lu", trans_timeout);
1026}
1027
Thadeu Lima de Souza Cascardoc4047f52015-09-15 18:28:00 -03001028static unsigned int get_netdev_queue_index(struct netdev_queue *queue)
John Fastabend822b3b22015-03-18 14:57:33 +02001029{
1030 struct net_device *dev = queue->dev;
Thadeu Lima de Souza Cascardoc4047f52015-09-15 18:28:00 -03001031 unsigned int i;
John Fastabend822b3b22015-03-18 14:57:33 +02001032
Thadeu Lima de Souza Cascardoc4047f52015-09-15 18:28:00 -03001033 i = queue - dev->_tx;
John Fastabend822b3b22015-03-18 14:57:33 +02001034 BUG_ON(i >= dev->num_tx_queues);
1035
1036 return i;
1037}
1038
Alexander Duyck8d059b02016-10-28 11:43:49 -04001039static ssize_t show_traffic_class(struct netdev_queue *queue,
1040 struct netdev_queue_attribute *attribute,
1041 char *buf)
1042{
1043 struct net_device *dev = queue->dev;
1044 int index = get_netdev_queue_index(queue);
1045 int tc = netdev_txq_to_tc(dev, index);
1046
1047 if (tc < 0)
1048 return -EINVAL;
1049
1050 return sprintf(buf, "%u\n", tc);
1051}
1052
1053#ifdef CONFIG_XPS
John Fastabend822b3b22015-03-18 14:57:33 +02001054static ssize_t show_tx_maxrate(struct netdev_queue *queue,
1055 struct netdev_queue_attribute *attribute,
1056 char *buf)
1057{
1058 return sprintf(buf, "%lu\n", queue->tx_maxrate);
1059}
1060
1061static ssize_t set_tx_maxrate(struct netdev_queue *queue,
1062 struct netdev_queue_attribute *attribute,
1063 const char *buf, size_t len)
1064{
1065 struct net_device *dev = queue->dev;
1066 int err, index = get_netdev_queue_index(queue);
1067 u32 rate = 0;
1068
1069 err = kstrtou32(buf, 10, &rate);
1070 if (err < 0)
1071 return err;
1072
1073 if (!rtnl_trylock())
1074 return restart_syscall();
1075
1076 err = -EOPNOTSUPP;
1077 if (dev->netdev_ops->ndo_set_tx_maxrate)
1078 err = dev->netdev_ops->ndo_set_tx_maxrate(dev, index, rate);
1079
1080 rtnl_unlock();
1081 if (!err) {
1082 queue->tx_maxrate = rate;
1083 return len;
1084 }
1085 return err;
1086}
1087
1088static struct netdev_queue_attribute queue_tx_maxrate =
1089 __ATTR(tx_maxrate, S_IRUGO | S_IWUSR,
1090 show_tx_maxrate, set_tx_maxrate);
1091#endif
1092
david decotignyccf5ff62011-11-16 12:15:10 +00001093static struct netdev_queue_attribute queue_trans_timeout =
1094 __ATTR(tx_timeout, S_IRUGO, show_trans_timeout, NULL);
1095
Alexander Duyck8d059b02016-10-28 11:43:49 -04001096static struct netdev_queue_attribute queue_traffic_class =
1097 __ATTR(traffic_class, S_IRUGO, show_traffic_class, NULL);
1098
Tom Herbert114cf582011-11-28 16:33:09 +00001099#ifdef CONFIG_BQL
1100/*
1101 * Byte queue limits sysfs structures and functions.
1102 */
1103static ssize_t bql_show(char *buf, unsigned int value)
1104{
1105 return sprintf(buf, "%u\n", value);
1106}
1107
1108static ssize_t bql_set(const char *buf, const size_t count,
1109 unsigned int *pvalue)
1110{
1111 unsigned int value;
1112 int err;
1113
1114 if (!strcmp(buf, "max") || !strcmp(buf, "max\n"))
1115 value = DQL_MAX_LIMIT;
1116 else {
1117 err = kstrtouint(buf, 10, &value);
1118 if (err < 0)
1119 return err;
1120 if (value > DQL_MAX_LIMIT)
1121 return -EINVAL;
1122 }
1123
1124 *pvalue = value;
1125
1126 return count;
1127}
1128
1129static ssize_t bql_show_hold_time(struct netdev_queue *queue,
1130 struct netdev_queue_attribute *attr,
1131 char *buf)
1132{
1133 struct dql *dql = &queue->dql;
1134
1135 return sprintf(buf, "%u\n", jiffies_to_msecs(dql->slack_hold_time));
1136}
1137
1138static ssize_t bql_set_hold_time(struct netdev_queue *queue,
1139 struct netdev_queue_attribute *attribute,
1140 const char *buf, size_t len)
1141{
1142 struct dql *dql = &queue->dql;
Eric Dumazet95c96172012-04-15 05:58:06 +00001143 unsigned int value;
Tom Herbert114cf582011-11-28 16:33:09 +00001144 int err;
1145
1146 err = kstrtouint(buf, 10, &value);
1147 if (err < 0)
1148 return err;
1149
1150 dql->slack_hold_time = msecs_to_jiffies(value);
1151
1152 return len;
1153}
1154
1155static struct netdev_queue_attribute bql_hold_time_attribute =
1156 __ATTR(hold_time, S_IRUGO | S_IWUSR, bql_show_hold_time,
1157 bql_set_hold_time);
1158
1159static ssize_t bql_show_inflight(struct netdev_queue *queue,
1160 struct netdev_queue_attribute *attr,
1161 char *buf)
1162{
1163 struct dql *dql = &queue->dql;
1164
1165 return sprintf(buf, "%u\n", dql->num_queued - dql->num_completed);
1166}
1167
1168static struct netdev_queue_attribute bql_inflight_attribute =
Hiroaki SHIMODA795d9a22012-01-14 07:10:21 +00001169 __ATTR(inflight, S_IRUGO, bql_show_inflight, NULL);
Tom Herbert114cf582011-11-28 16:33:09 +00001170
1171#define BQL_ATTR(NAME, FIELD) \
1172static ssize_t bql_show_ ## NAME(struct netdev_queue *queue, \
1173 struct netdev_queue_attribute *attr, \
1174 char *buf) \
1175{ \
1176 return bql_show(buf, queue->dql.FIELD); \
1177} \
1178 \
1179static ssize_t bql_set_ ## NAME(struct netdev_queue *queue, \
1180 struct netdev_queue_attribute *attr, \
1181 const char *buf, size_t len) \
1182{ \
1183 return bql_set(buf, len, &queue->dql.FIELD); \
1184} \
1185 \
1186static struct netdev_queue_attribute bql_ ## NAME ## _attribute = \
1187 __ATTR(NAME, S_IRUGO | S_IWUSR, bql_show_ ## NAME, \
1188 bql_set_ ## NAME);
1189
1190BQL_ATTR(limit, limit)
1191BQL_ATTR(limit_max, max_limit)
1192BQL_ATTR(limit_min, min_limit)
1193
1194static struct attribute *dql_attrs[] = {
1195 &bql_limit_attribute.attr,
1196 &bql_limit_max_attribute.attr,
1197 &bql_limit_min_attribute.attr,
1198 &bql_hold_time_attribute.attr,
1199 &bql_inflight_attribute.attr,
1200 NULL
1201};
1202
1203static struct attribute_group dql_group = {
1204 .name = "byte_queue_limits",
1205 .attrs = dql_attrs,
1206};
1207#endif /* CONFIG_BQL */
1208
david decotignyccf5ff62011-11-16 12:15:10 +00001209#ifdef CONFIG_XPS
Tom Herbert1d24eb42010-11-21 13:17:27 +00001210static ssize_t show_xps_map(struct netdev_queue *queue,
1211 struct netdev_queue_attribute *attribute, char *buf)
1212{
1213 struct net_device *dev = queue->dev;
Alexander Duyck184c4492016-10-28 11:50:13 -04001214 int cpu, len, num_tc = 1, tc = 0;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001215 struct xps_dev_maps *dev_maps;
1216 cpumask_var_t mask;
1217 unsigned long index;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001218
1219 if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
1220 return -ENOMEM;
1221
1222 index = get_netdev_queue_index(queue);
1223
Alexander Duyck184c4492016-10-28 11:50:13 -04001224 if (dev->num_tc) {
1225 num_tc = dev->num_tc;
1226 tc = netdev_txq_to_tc(dev, index);
1227 if (tc < 0)
1228 return -EINVAL;
1229 }
1230
Tom Herbert1d24eb42010-11-21 13:17:27 +00001231 rcu_read_lock();
1232 dev_maps = rcu_dereference(dev->xps_maps);
1233 if (dev_maps) {
Alexander Duyck184c4492016-10-28 11:50:13 -04001234 for_each_possible_cpu(cpu) {
1235 int i, tci = cpu * num_tc + tc;
1236 struct xps_map *map;
1237
1238 map = rcu_dereference(dev_maps->cpu_map[tci]);
1239 if (!map)
1240 continue;
1241
1242 for (i = map->len; i--;) {
1243 if (map->queues[i] == index) {
1244 cpumask_set_cpu(cpu, mask);
1245 break;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001246 }
1247 }
1248 }
1249 }
1250 rcu_read_unlock();
1251
Tejun Heof0906822015-02-13 14:37:42 -08001252 len = snprintf(buf, PAGE_SIZE, "%*pb\n", cpumask_pr_args(mask));
Tom Herbert1d24eb42010-11-21 13:17:27 +00001253 free_cpumask_var(mask);
Tejun Heof0906822015-02-13 14:37:42 -08001254 return len < PAGE_SIZE ? len : -EINVAL;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001255}
1256
Tom Herbert1d24eb42010-11-21 13:17:27 +00001257static ssize_t store_xps_map(struct netdev_queue *queue,
1258 struct netdev_queue_attribute *attribute,
1259 const char *buf, size_t len)
1260{
1261 struct net_device *dev = queue->dev;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001262 unsigned long index;
Alexander Duyck537c00d2013-01-10 08:57:02 +00001263 cpumask_var_t mask;
1264 int err;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001265
1266 if (!capable(CAP_NET_ADMIN))
1267 return -EPERM;
1268
1269 if (!alloc_cpumask_var(&mask, GFP_KERNEL))
1270 return -ENOMEM;
1271
1272 index = get_netdev_queue_index(queue);
1273
1274 err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
1275 if (err) {
1276 free_cpumask_var(mask);
1277 return err;
1278 }
1279
Alexander Duyck537c00d2013-01-10 08:57:02 +00001280 err = netif_set_xps_queue(dev, mask, index);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001281
1282 free_cpumask_var(mask);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001283
Alexander Duyck537c00d2013-01-10 08:57:02 +00001284 return err ? : len;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001285}
1286
1287static struct netdev_queue_attribute xps_cpus_attribute =
1288 __ATTR(xps_cpus, S_IRUGO | S_IWUSR, show_xps_map, store_xps_map);
david decotignyccf5ff62011-11-16 12:15:10 +00001289#endif /* CONFIG_XPS */
Tom Herbert1d24eb42010-11-21 13:17:27 +00001290
1291static struct attribute *netdev_queue_default_attrs[] = {
david decotignyccf5ff62011-11-16 12:15:10 +00001292 &queue_trans_timeout.attr,
Alexander Duyck8d059b02016-10-28 11:43:49 -04001293 &queue_traffic_class.attr,
david decotignyccf5ff62011-11-16 12:15:10 +00001294#ifdef CONFIG_XPS
Tom Herbert1d24eb42010-11-21 13:17:27 +00001295 &xps_cpus_attribute.attr,
John Fastabend822b3b22015-03-18 14:57:33 +02001296 &queue_tx_maxrate.attr,
david decotignyccf5ff62011-11-16 12:15:10 +00001297#endif
Tom Herbert1d24eb42010-11-21 13:17:27 +00001298 NULL
1299};
1300
1301static void netdev_queue_release(struct kobject *kobj)
1302{
1303 struct netdev_queue *queue = to_netdev_queue(kobj);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001304
Tom Herbert1d24eb42010-11-21 13:17:27 +00001305 memset(kobj, 0, sizeof(*kobj));
1306 dev_put(queue->dev);
1307}
1308
Weilong Chen82ef3d52014-01-16 17:24:31 +08001309static const void *netdev_queue_namespace(struct kobject *kobj)
1310{
1311 struct netdev_queue *queue = to_netdev_queue(kobj);
1312 struct device *dev = &queue->dev->dev;
1313 const void *ns = NULL;
1314
1315 if (dev->class && dev->class->ns_type)
1316 ns = dev->class->namespace(dev);
1317
1318 return ns;
1319}
1320
Tom Herbert1d24eb42010-11-21 13:17:27 +00001321static struct kobj_type netdev_queue_ktype = {
1322 .sysfs_ops = &netdev_queue_sysfs_ops,
1323 .release = netdev_queue_release,
1324 .default_attrs = netdev_queue_default_attrs,
Weilong Chen82ef3d52014-01-16 17:24:31 +08001325 .namespace = netdev_queue_namespace,
Tom Herbert1d24eb42010-11-21 13:17:27 +00001326};
1327
WANG Cong6b53daf2014-07-23 16:09:10 -07001328static int netdev_queue_add_kobject(struct net_device *dev, int index)
Tom Herbert1d24eb42010-11-21 13:17:27 +00001329{
WANG Cong6b53daf2014-07-23 16:09:10 -07001330 struct netdev_queue *queue = dev->_tx + index;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001331 struct kobject *kobj = &queue->kobj;
1332 int error = 0;
1333
WANG Cong6b53daf2014-07-23 16:09:10 -07001334 kobj->kset = dev->queues_kset;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001335 error = kobject_init_and_add(kobj, &netdev_queue_ktype, NULL,
1336 "tx-%u", index);
Tom Herbert114cf582011-11-28 16:33:09 +00001337 if (error)
1338 goto exit;
1339
1340#ifdef CONFIG_BQL
1341 error = sysfs_create_group(kobj, &dql_group);
1342 if (error)
1343 goto exit;
1344#endif
Tom Herbert1d24eb42010-11-21 13:17:27 +00001345
1346 kobject_uevent(kobj, KOBJ_ADD);
1347 dev_hold(queue->dev);
1348
Tom Herbert114cf582011-11-28 16:33:09 +00001349 return 0;
1350exit:
1351 kobject_put(kobj);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001352 return error;
1353}
david decotignyccf5ff62011-11-16 12:15:10 +00001354#endif /* CONFIG_SYSFS */
Tom Herbert1d24eb42010-11-21 13:17:27 +00001355
1356int
WANG Cong6b53daf2014-07-23 16:09:10 -07001357netdev_queue_update_kobjects(struct net_device *dev, int old_num, int new_num)
Tom Herbert1d24eb42010-11-21 13:17:27 +00001358{
david decotignyccf5ff62011-11-16 12:15:10 +00001359#ifdef CONFIG_SYSFS
Tom Herbert1d24eb42010-11-21 13:17:27 +00001360 int i;
1361 int error = 0;
1362
1363 for (i = old_num; i < new_num; i++) {
WANG Cong6b53daf2014-07-23 16:09:10 -07001364 error = netdev_queue_add_kobject(dev, i);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001365 if (error) {
1366 new_num = old_num;
1367 break;
1368 }
1369 }
1370
Tom Herbert114cf582011-11-28 16:33:09 +00001371 while (--i >= new_num) {
WANG Cong6b53daf2014-07-23 16:09:10 -07001372 struct netdev_queue *queue = dev->_tx + i;
Tom Herbert114cf582011-11-28 16:33:09 +00001373
Andrey Vagin91864f52017-03-12 21:36:18 -07001374 if (!atomic_read(&dev_net(dev)->count))
Andrey Vagin002d8a12016-10-24 19:09:53 -07001375 queue->kobj.uevent_suppress = 1;
Tom Herbert114cf582011-11-28 16:33:09 +00001376#ifdef CONFIG_BQL
1377 sysfs_remove_group(&queue->kobj, &dql_group);
1378#endif
1379 kobject_put(&queue->kobj);
1380 }
Tom Herbert1d24eb42010-11-21 13:17:27 +00001381
1382 return error;
Tom Herbertbf264142010-11-26 08:36:09 +00001383#else
1384 return 0;
david decotignyccf5ff62011-11-16 12:15:10 +00001385#endif /* CONFIG_SYSFS */
Tom Herbert1d24eb42010-11-21 13:17:27 +00001386}
1387
WANG Cong6b53daf2014-07-23 16:09:10 -07001388static int register_queue_kobjects(struct net_device *dev)
Tom Herbert1d24eb42010-11-21 13:17:27 +00001389{
Tom Herbertbf264142010-11-26 08:36:09 +00001390 int error = 0, txq = 0, rxq = 0, real_rx = 0, real_tx = 0;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001391
david decotignyccf5ff62011-11-16 12:15:10 +00001392#ifdef CONFIG_SYSFS
WANG Cong6b53daf2014-07-23 16:09:10 -07001393 dev->queues_kset = kset_create_and_add("queues",
1394 NULL, &dev->dev.kobj);
1395 if (!dev->queues_kset)
Ben Hutchings62fe0b42010-09-27 08:24:33 +00001396 return -ENOMEM;
WANG Cong6b53daf2014-07-23 16:09:10 -07001397 real_rx = dev->real_num_rx_queues;
Tom Herbertbf264142010-11-26 08:36:09 +00001398#endif
WANG Cong6b53daf2014-07-23 16:09:10 -07001399 real_tx = dev->real_num_tx_queues;
Tom Herbertbf264142010-11-26 08:36:09 +00001400
WANG Cong6b53daf2014-07-23 16:09:10 -07001401 error = net_rx_queue_update_kobjects(dev, 0, real_rx);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001402 if (error)
1403 goto error;
Tom Herbertbf264142010-11-26 08:36:09 +00001404 rxq = real_rx;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001405
WANG Cong6b53daf2014-07-23 16:09:10 -07001406 error = netdev_queue_update_kobjects(dev, 0, real_tx);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001407 if (error)
1408 goto error;
Tom Herbertbf264142010-11-26 08:36:09 +00001409 txq = real_tx;
Tom Herbert1d24eb42010-11-21 13:17:27 +00001410
1411 return 0;
1412
1413error:
WANG Cong6b53daf2014-07-23 16:09:10 -07001414 netdev_queue_update_kobjects(dev, txq, 0);
1415 net_rx_queue_update_kobjects(dev, rxq, 0);
Tom Herbert1d24eb42010-11-21 13:17:27 +00001416 return error;
Ben Hutchings62fe0b42010-09-27 08:24:33 +00001417}
1418
WANG Cong6b53daf2014-07-23 16:09:10 -07001419static void remove_queue_kobjects(struct net_device *dev)
Tom Herbert0a9627f2010-03-16 08:03:29 +00001420{
Tom Herbertbf264142010-11-26 08:36:09 +00001421 int real_rx = 0, real_tx = 0;
1422
Michael Daltona953be52014-01-16 22:23:28 -08001423#ifdef CONFIG_SYSFS
WANG Cong6b53daf2014-07-23 16:09:10 -07001424 real_rx = dev->real_num_rx_queues;
Tom Herbertbf264142010-11-26 08:36:09 +00001425#endif
WANG Cong6b53daf2014-07-23 16:09:10 -07001426 real_tx = dev->real_num_tx_queues;
Tom Herbertbf264142010-11-26 08:36:09 +00001427
WANG Cong6b53daf2014-07-23 16:09:10 -07001428 net_rx_queue_update_kobjects(dev, real_rx, 0);
1429 netdev_queue_update_kobjects(dev, real_tx, 0);
david decotignyccf5ff62011-11-16 12:15:10 +00001430#ifdef CONFIG_SYSFS
WANG Cong6b53daf2014-07-23 16:09:10 -07001431 kset_unregister(dev->queues_kset);
Tom Herbertbf264142010-11-26 08:36:09 +00001432#endif
Tom Herbert0a9627f2010-03-16 08:03:29 +00001433}
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001434
Eric W. Biederman7dc5dbc2013-03-25 20:07:01 -07001435static bool net_current_may_mount(void)
1436{
1437 struct net *net = current->nsproxy->net_ns;
1438
1439 return ns_capable(net->user_ns, CAP_SYS_ADMIN);
1440}
1441
Al Viroa685e082011-06-08 21:13:01 -04001442static void *net_grab_current_ns(void)
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001443{
Al Viroa685e082011-06-08 21:13:01 -04001444 struct net *ns = current->nsproxy->net_ns;
1445#ifdef CONFIG_NET_NS
1446 if (ns)
1447 atomic_inc(&ns->passive);
1448#endif
1449 return ns;
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001450}
1451
1452static const void *net_initial_ns(void)
1453{
1454 return &init_net;
1455}
1456
1457static const void *net_netlink_ns(struct sock *sk)
1458{
1459 return sock_net(sk);
1460}
1461
Johannes Berg04600792010-08-05 17:45:15 +02001462struct kobj_ns_type_operations net_ns_type_operations = {
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001463 .type = KOBJ_NS_TYPE_NET,
Eric W. Biederman7dc5dbc2013-03-25 20:07:01 -07001464 .current_may_mount = net_current_may_mount,
Al Viroa685e082011-06-08 21:13:01 -04001465 .grab_current_ns = net_grab_current_ns,
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001466 .netlink_ns = net_netlink_ns,
1467 .initial_ns = net_initial_ns,
Al Viroa685e082011-06-08 21:13:01 -04001468 .drop_ns = net_drop_ns,
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001469};
Johannes Berg04600792010-08-05 17:45:15 +02001470EXPORT_SYMBOL_GPL(net_ns_type_operations);
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001471
Kay Sievers7eff2e72007-08-14 15:15:12 +02001472static int netdev_uevent(struct device *d, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001474 struct net_device *dev = to_net_dev(d);
Kay Sievers7eff2e72007-08-14 15:15:12 +02001475 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476
Kay Sievers312c0042005-11-16 09:00:00 +01001477 /* pass interface to uevent. */
Kay Sievers7eff2e72007-08-14 15:15:12 +02001478 retval = add_uevent_var(env, "INTERFACE=%s", dev->name);
Eric Rannaudbf624562007-03-30 22:23:12 -07001479 if (retval)
1480 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481
Jean Tourrilhesca2f37d2007-03-07 10:49:30 -08001482 /* pass ifindex to uevent.
1483 * ifindex is useful as it won't change (interface name may change)
1484 * and is what RtNetlink uses natively. */
Kay Sievers7eff2e72007-08-14 15:15:12 +02001485 retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex);
Jean Tourrilhesca2f37d2007-03-07 10:49:30 -08001486
Eric Rannaudbf624562007-03-30 22:23:12 -07001487exit:
Eric Rannaudbf624562007-03-30 22:23:12 -07001488 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001489}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490
1491/*
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001492 * netdev_release -- destroy and free a dead device.
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001493 * Called when last reference to device kobject is gone.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001495static void netdev_release(struct device *d)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001497 struct net_device *dev = to_net_dev(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001498
1499 BUG_ON(dev->reg_state != NETREG_RELEASED);
1500
Stephen Hemminger0b815a12008-09-22 21:28:11 -07001501 kfree(dev->ifalias);
Eric Dumazet74d332c2013-10-30 13:10:44 -07001502 netdev_freemem(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001503}
1504
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001505static const void *net_namespace(struct device *d)
1506{
Geliang Tang5c294822015-12-22 23:11:49 +08001507 struct net_device *dev = to_net_dev(d);
1508
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001509 return dev_net(dev);
1510}
1511
Linus Torvalds1da177e2005-04-16 15:20:36 -07001512static struct class net_class = {
1513 .name = "net",
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001514 .dev_release = netdev_release,
Greg Kroah-Hartman6be8aee2013-07-24 15:05:33 -07001515 .dev_groups = net_class_groups,
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001516 .dev_uevent = netdev_uevent,
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001517 .ns_type = &net_ns_type_operations,
1518 .namespace = net_namespace,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519};
1520
Florian Fainelliaa836df2015-03-09 14:31:20 -07001521#ifdef CONFIG_OF_NET
1522static int of_dev_node_match(struct device *dev, const void *data)
1523{
1524 int ret = 0;
1525
1526 if (dev->parent)
1527 ret = dev->parent->of_node == data;
1528
1529 return ret == 0 ? dev->of_node == data : ret;
1530}
1531
Russell King9861f722015-09-24 20:36:33 +01001532/*
1533 * of_find_net_device_by_node - lookup the net device for the device node
1534 * @np: OF device node
1535 *
1536 * Looks up the net_device structure corresponding with the device node.
1537 * If successful, returns a pointer to the net_device with the embedded
1538 * struct device refcount incremented by one, or NULL on failure. The
1539 * refcount must be dropped when done with the net_device.
1540 */
Florian Fainelliaa836df2015-03-09 14:31:20 -07001541struct net_device *of_find_net_device_by_node(struct device_node *np)
1542{
1543 struct device *dev;
1544
1545 dev = class_find_device(&net_class, NULL, np, of_dev_node_match);
1546 if (!dev)
1547 return NULL;
1548
1549 return to_net_dev(dev);
1550}
1551EXPORT_SYMBOL(of_find_net_device_by_node);
1552#endif
1553
Stephen Hemminger9093bbb2007-05-19 15:39:25 -07001554/* Delete sysfs entries but hold kobject reference until after all
1555 * netdev references are gone.
1556 */
WANG Cong6b53daf2014-07-23 16:09:10 -07001557void netdev_unregister_kobject(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558{
WANG Cong6b53daf2014-07-23 16:09:10 -07001559 struct device *dev = &(ndev->dev);
Stephen Hemminger9093bbb2007-05-19 15:39:25 -07001560
Andrey Vagin91864f52017-03-12 21:36:18 -07001561 if (!atomic_read(&dev_net(ndev)->count))
Andrey Vagin002d8a12016-10-24 19:09:53 -07001562 dev_set_uevent_suppress(dev, 1);
1563
Stephen Hemminger9093bbb2007-05-19 15:39:25 -07001564 kobject_get(&dev->kobj);
Eric W. Biederman38918452008-10-27 17:51:47 -07001565
WANG Cong6b53daf2014-07-23 16:09:10 -07001566 remove_queue_kobjects(ndev);
Tom Herbert0a9627f2010-03-16 08:03:29 +00001567
Ming Lei9802c8e2013-02-22 16:34:16 -08001568 pm_runtime_set_memalloc_noio(dev, false);
1569
Stephen Hemminger9093bbb2007-05-19 15:39:25 -07001570 device_del(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571}
1572
1573/* Create sysfs entries for network device. */
WANG Cong6b53daf2014-07-23 16:09:10 -07001574int netdev_register_kobject(struct net_device *ndev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575{
WANG Cong6b53daf2014-07-23 16:09:10 -07001576 struct device *dev = &(ndev->dev);
1577 const struct attribute_group **groups = ndev->sysfs_groups;
Tom Herbert0a9627f2010-03-16 08:03:29 +00001578 int error = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001579
Eric W. Biedermana1b3f592010-05-04 17:36:49 -07001580 device_initialize(dev);
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001581 dev->class = &net_class;
WANG Cong6b53daf2014-07-23 16:09:10 -07001582 dev->platform_data = ndev;
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -07001583 dev->groups = groups;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584
WANG Cong6b53daf2014-07-23 16:09:10 -07001585 dev_set_name(dev, "%s", ndev->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586
Eric W. Biederman8b41d182007-09-26 22:02:53 -07001587#ifdef CONFIG_SYSFS
Eric W. Biederman0c509a62009-10-29 14:18:21 +00001588 /* Allow for a device specific group */
1589 if (*groups)
1590 groups++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591
Eric W. Biederman0c509a62009-10-29 14:18:21 +00001592 *groups++ = &netstat_group;
Johannes Berg38c1a012012-11-16 20:46:19 +01001593
1594#if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211)
WANG Cong6b53daf2014-07-23 16:09:10 -07001595 if (ndev->ieee80211_ptr)
Johannes Berg38c1a012012-11-16 20:46:19 +01001596 *groups++ = &wireless_group;
1597#if IS_ENABLED(CONFIG_WIRELESS_EXT)
WANG Cong6b53daf2014-07-23 16:09:10 -07001598 else if (ndev->wireless_handlers)
Johannes Berg38c1a012012-11-16 20:46:19 +01001599 *groups++ = &wireless_group;
1600#endif
1601#endif
Eric W. Biederman8b41d182007-09-26 22:02:53 -07001602#endif /* CONFIG_SYSFS */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001603
Tom Herbert0a9627f2010-03-16 08:03:29 +00001604 error = device_add(dev);
1605 if (error)
1606 return error;
1607
WANG Cong6b53daf2014-07-23 16:09:10 -07001608 error = register_queue_kobjects(ndev);
Tom Herbert0a9627f2010-03-16 08:03:29 +00001609 if (error) {
1610 device_del(dev);
1611 return error;
1612 }
1613
Ming Lei9802c8e2013-02-22 16:34:16 -08001614 pm_runtime_set_memalloc_noio(dev, true);
1615
Tom Herbert0a9627f2010-03-16 08:03:29 +00001616 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617}
1618
Tejun Heo58292cbe2013-09-11 22:29:04 -04001619int netdev_class_create_file_ns(struct class_attribute *class_attr,
1620 const void *ns)
Jay Vosburghb8a97872008-06-13 18:12:04 -07001621{
Tejun Heo58292cbe2013-09-11 22:29:04 -04001622 return class_create_file_ns(&net_class, class_attr, ns);
Jay Vosburghb8a97872008-06-13 18:12:04 -07001623}
Tejun Heo58292cbe2013-09-11 22:29:04 -04001624EXPORT_SYMBOL(netdev_class_create_file_ns);
Jay Vosburghb8a97872008-06-13 18:12:04 -07001625
Tejun Heo58292cbe2013-09-11 22:29:04 -04001626void netdev_class_remove_file_ns(struct class_attribute *class_attr,
1627 const void *ns)
Jay Vosburghb8a97872008-06-13 18:12:04 -07001628{
Tejun Heo58292cbe2013-09-11 22:29:04 -04001629 class_remove_file_ns(&net_class, class_attr, ns);
Jay Vosburghb8a97872008-06-13 18:12:04 -07001630}
Tejun Heo58292cbe2013-09-11 22:29:04 -04001631EXPORT_SYMBOL(netdev_class_remove_file_ns);
Jay Vosburghb8a97872008-06-13 18:12:04 -07001632
Daniel Borkmanna48d4bb2014-01-06 01:20:11 +01001633int __init netdev_kobject_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634{
Eric W. Biederman608b4b92010-05-04 17:36:45 -07001635 kobj_ns_type_register(&net_ns_type_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 return class_register(&net_class);
1637}