projects / linux-block.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Merge tag 'mm-hotfixes-stable-2025-07-11-16-16' of git://git.kernel.org/pub/scm/linux...
[linux-block.git] / net / core / net-sysfs.c
... / ...
CommitLineData
1// SPDX-License-Identifier: GPL-2.0-or-later
2/*
3 * net-sysfs.c - network device class and attributes
4 *
5 * Copyright (c) 2003 Stephen Hemminger <shemminger@osdl.org>
6 */
7
8#include <linux/capability.h>
9#include <linux/kernel.h>
10#include <linux/netdevice.h>
11#include <linux/if_arp.h>
12#include <linux/slab.h>
13#include <linux/sched/signal.h>
14#include <linux/sched/isolation.h>
15#include <linux/nsproxy.h>
16#include <net/sock.h>
17#include <net/net_namespace.h>
18#include <linux/rtnetlink.h>
19#include <linux/vmalloc.h>
20#include <linux/export.h>
21#include <linux/jiffies.h>
22#include <linux/pm_runtime.h>
23#include <linux/of.h>
24#include <linux/of_net.h>
25#include <linux/cpu.h>
26#include <net/netdev_lock.h>
27#include <net/netdev_rx_queue.h>
28#include <net/rps.h>
29
30#include "dev.h"
31#include "net-sysfs.h"
32
33#ifdef CONFIG_SYSFS
34static const char fmt_hex[] = "%#x\n";
35static const char fmt_dec[] = "%d\n";
36static const char fmt_uint[] = "%u\n";
37static const char fmt_ulong[] = "%lu\n";
38static const char fmt_u64[] = "%llu\n";
39
40/* Caller holds RTNL, netdev->lock or RCU */
41static inline int dev_isalive(const struct net_device *dev)
42{
43 return READ_ONCE(dev->reg_state) <= NETREG_REGISTERED;
44}
45
46/* There is a possible ABBA deadlock between rtnl_lock and kernfs_node->active,
47 * when unregistering a net device and accessing associated sysfs files. The
48 * potential deadlock is as follow:
49 *
50 * CPU 0 CPU 1
51 *
52 * rtnl_lock vfs_read
53 * unregister_netdevice_many kernfs_seq_start
54 * device_del / kobject_put kernfs_get_active (kn->active++)
55 * kernfs_drain sysfs_kf_seq_show
56 * wait_event( rtnl_lock
57 * kn->active == KN_DEACTIVATED_BIAS) -> waits on CPU 0 to release
58 * -> waits on CPU 1 to decrease kn->active the rtnl lock.
59 *
60 * The historical fix was to use rtnl_trylock with restart_syscall to bail out
61 * of sysfs operations when the lock couldn't be taken. This fixed the above
62 * issue as it allowed CPU 1 to bail out of the ABBA situation.
63 *
64 * But it came with performances issues, as syscalls are being restarted in
65 * loops when there was contention on the rtnl lock, with huge slow downs in
66 * specific scenarios (e.g. lots of virtual interfaces created and userspace
67 * daemons querying their attributes).
68 *
69 * The idea below is to bail out of the active kernfs_node protection
70 * (kn->active) while trying to take the rtnl lock.
71 *
72 * This replaces rtnl_lock() and still has to be used with rtnl_unlock(). The
73 * net device is guaranteed to be alive if this returns successfully.
74 */
75static int sysfs_rtnl_lock(struct kobject *kobj, struct attribute *attr,
76 struct net_device *ndev)
77{
78 struct kernfs_node *kn;
79 int ret = 0;
80
81 /* First, we hold a reference to the net device as the unregistration
82 * path might run in parallel. This will ensure the net device and the
83 * associated sysfs objects won't be freed while we try to take the rtnl
84 * lock.
85 */
86 dev_hold(ndev);
87 /* sysfs_break_active_protection was introduced to allow self-removal of
88 * devices and their associated sysfs files by bailing out of the
89 * sysfs/kernfs protection. We do this here to allow the unregistration
90 * path to complete in parallel. The following takes a reference on the
91 * kobject and the kernfs_node being accessed.
92 *
93 * This works because we hold a reference onto the net device and the
94 * unregistration path will wait for us eventually in netdev_run_todo
95 * (outside an rtnl lock section).
96 */
97 kn = sysfs_break_active_protection(kobj, attr);
98 /* We can now try to take the rtnl lock. This can't deadlock us as the
99 * unregistration path is able to drain sysfs files (kernfs_node) thanks
100 * to the above dance.
101 */
102 if (rtnl_lock_interruptible()) {
103 ret = -ERESTARTSYS;
104 goto unbreak;
105 }
106 /* Check dismantle on the device hasn't started, otherwise deny the
107 * operation.
108 */
109 if (!dev_isalive(ndev)) {
110 rtnl_unlock();
111 ret = -ENODEV;
112 goto unbreak;
113 }
114 /* We are now sure the device dismantle hasn't started nor that it can
115 * start before we exit the locking section as we hold the rtnl lock.
116 * There's no need to keep unbreaking the sysfs protection nor to hold
117 * a net device reference from that point; that was only needed to take
118 * the rtnl lock.
119 */
120unbreak:
121 sysfs_unbreak_active_protection(kn);
122 dev_put(ndev);
123
124 return ret;
125}
126
127/* use same locking rules as GIF* ioctl's */
128static ssize_t netdev_show(const struct device *dev,
129 struct device_attribute *attr, char *buf,
130 ssize_t (*format)(const struct net_device *, char *))
131{
132 struct net_device *ndev = to_net_dev(dev);
133 ssize_t ret = -EINVAL;
134
135 rcu_read_lock();
136 if (dev_isalive(ndev))
137 ret = (*format)(ndev, buf);
138 rcu_read_unlock();
139
140 return ret;
141}
142
143/* generate a show function for simple field */
144#define NETDEVICE_SHOW(field, format_string) \
145static ssize_t format_##field(const struct net_device *dev, char *buf) \
146{ \
147 return sysfs_emit(buf, format_string, READ_ONCE(dev->field)); \
148} \
149static ssize_t field##_show(struct device *dev, \
150 struct device_attribute *attr, char *buf) \
151{ \
152 return netdev_show(dev, attr, buf, format_##field); \
153} \
154
155#define NETDEVICE_SHOW_RO(field, format_string) \
156NETDEVICE_SHOW(field, format_string); \
157static DEVICE_ATTR_RO(field)
158
159#define NETDEVICE_SHOW_RW(field, format_string) \
160NETDEVICE_SHOW(field, format_string); \
161static DEVICE_ATTR_RW(field)
162
163/* use same locking and permission rules as SIF* ioctl's */
164static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
165 const char *buf, size_t len,
166 int (*set)(struct net_device *, unsigned long))
167{
168 struct net_device *netdev = to_net_dev(dev);
169 struct net *net = dev_net(netdev);
170 unsigned long new;
171 int ret;
172
173 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
174 return -EPERM;
175
176 ret = kstrtoul(buf, 0, &new);
177 if (ret)
178 goto err;
179
180 ret = sysfs_rtnl_lock(&dev->kobj, &attr->attr, netdev);
181 if (ret)
182 goto err;
183
184 ret = (*set)(netdev, new);
185 if (ret == 0)
186 ret = len;
187
188 rtnl_unlock();
189 err:
190 return ret;
191}
192
193/* Same as netdev_store() but takes netdev_lock() instead of rtnl_lock() */
194static ssize_t
195netdev_lock_store(struct device *dev, struct device_attribute *attr,
196 const char *buf, size_t len,
197 int (*set)(struct net_device *, unsigned long))
198{
199 struct net_device *netdev = to_net_dev(dev);
200 struct net *net = dev_net(netdev);
201 unsigned long new;
202 int ret;
203
204 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
205 return -EPERM;
206
207 ret = kstrtoul(buf, 0, &new);
208 if (ret)
209 return ret;
210
211 netdev_lock(netdev);
212
213 if (dev_isalive(netdev)) {
214 ret = (*set)(netdev, new);
215 if (ret == 0)
216 ret = len;
217 }
218 netdev_unlock(netdev);
219
220 return ret;
221}
222
223NETDEVICE_SHOW_RO(dev_id, fmt_hex);
224NETDEVICE_SHOW_RO(dev_port, fmt_dec);
225NETDEVICE_SHOW_RO(addr_assign_type, fmt_dec);
226NETDEVICE_SHOW_RO(addr_len, fmt_dec);
227NETDEVICE_SHOW_RO(ifindex, fmt_dec);
228NETDEVICE_SHOW_RO(type, fmt_dec);
229NETDEVICE_SHOW_RO(link_mode, fmt_dec);
230
231static ssize_t iflink_show(struct device *dev, struct device_attribute *attr,
232 char *buf)
233{
234 struct net_device *ndev = to_net_dev(dev);
235
236 return sysfs_emit(buf, fmt_dec, dev_get_iflink(ndev));
237}
238static DEVICE_ATTR_RO(iflink);
239
240static ssize_t format_name_assign_type(const struct net_device *dev, char *buf)
241{
242 return sysfs_emit(buf, fmt_dec, READ_ONCE(dev->name_assign_type));
243}
244
245static ssize_t name_assign_type_show(struct device *dev,
246 struct device_attribute *attr,
247 char *buf)
248{
249 struct net_device *ndev = to_net_dev(dev);
250 ssize_t ret = -EINVAL;
251
252 if (READ_ONCE(ndev->name_assign_type) != NET_NAME_UNKNOWN)
253 ret = netdev_show(dev, attr, buf, format_name_assign_type);
254
255 return ret;
256}
257static DEVICE_ATTR_RO(name_assign_type);
258
259/* use same locking rules as GIFHWADDR ioctl's (dev_get_mac_address()) */
260static ssize_t address_show(struct device *dev, struct device_attribute *attr,
261 char *buf)
262{
263 struct net_device *ndev = to_net_dev(dev);
264 ssize_t ret = -EINVAL;
265
266 down_read(&dev_addr_sem);
267
268 rcu_read_lock();
269 if (dev_isalive(ndev))
270 ret = sysfs_format_mac(buf, ndev->dev_addr, ndev->addr_len);
271 rcu_read_unlock();
272
273 up_read(&dev_addr_sem);
274 return ret;
275}
276static DEVICE_ATTR_RO(address);
277
278static ssize_t broadcast_show(struct device *dev,
279 struct device_attribute *attr, char *buf)
280{
281 struct net_device *ndev = to_net_dev(dev);
282 int ret = -EINVAL;
283
284 rcu_read_lock();
285 if (dev_isalive(ndev))
286 ret = sysfs_format_mac(buf, ndev->broadcast, ndev->addr_len);
287 rcu_read_unlock();
288 return ret;
289}
290static DEVICE_ATTR_RO(broadcast);
291
292static int change_carrier(struct net_device *dev, unsigned long new_carrier)
293{
294 if (!netif_running(dev))
295 return -EINVAL;
296 return dev_change_carrier(dev, (bool)new_carrier);
297}
298
299static ssize_t carrier_store(struct device *dev, struct device_attribute *attr,
300 const char *buf, size_t len)
301{
302 struct net_device *netdev = to_net_dev(dev);
303
304 /* The check is also done in change_carrier; this helps returning early
305 * without hitting the locking section in netdev_store.
306 */
307 if (!netdev->netdev_ops->ndo_change_carrier)
308 return -EOPNOTSUPP;
309
310 return netdev_store(dev, attr, buf, len, change_carrier);
311}
312
313static ssize_t carrier_show(struct device *dev,
314 struct device_attribute *attr, char *buf)
315{
316 struct net_device *netdev = to_net_dev(dev);
317 int ret;
318
319 ret = sysfs_rtnl_lock(&dev->kobj, &attr->attr, netdev);
320 if (ret)
321 return ret;
322
323 ret = -EINVAL;
324 if (netif_running(netdev)) {
325 /* Synchronize carrier state with link watch,
326 * see also rtnl_getlink().
327 */
328 linkwatch_sync_dev(netdev);
329
330 ret = sysfs_emit(buf, fmt_dec, !!netif_carrier_ok(netdev));
331 }
332
333 rtnl_unlock();
334 return ret;
335}
336static DEVICE_ATTR_RW(carrier);
337
338static ssize_t speed_show(struct device *dev,
339 struct device_attribute *attr, char *buf)
340{
341 struct net_device *netdev = to_net_dev(dev);
342 int ret = -EINVAL;
343
344 /* The check is also done in __ethtool_get_link_ksettings; this helps
345 * returning early without hitting the locking section below.
346 */
347 if (!netdev->ethtool_ops->get_link_ksettings)
348 return ret;
349
350 ret = sysfs_rtnl_lock(&dev->kobj, &attr->attr, netdev);
351 if (ret)
352 return ret;
353
354 ret = -EINVAL;
355 if (netif_running(netdev)) {
356 struct ethtool_link_ksettings cmd;
357
358 if (!__ethtool_get_link_ksettings(netdev, &cmd))
359 ret = sysfs_emit(buf, fmt_dec, cmd.base.speed);
360 }
361 rtnl_unlock();
362 return ret;
363}
364static DEVICE_ATTR_RO(speed);
365
366static ssize_t duplex_show(struct device *dev,
367 struct device_attribute *attr, char *buf)
368{
369 struct net_device *netdev = to_net_dev(dev);
370 int ret = -EINVAL;
371
372 /* The check is also done in __ethtool_get_link_ksettings; this helps
373 * returning early without hitting the locking section below.
374 */
375 if (!netdev->ethtool_ops->get_link_ksettings)
376 return ret;
377
378 ret = sysfs_rtnl_lock(&dev->kobj, &attr->attr, netdev);
379 if (ret)
380 return ret;
381
382 ret = -EINVAL;
383 if (netif_running(netdev)) {
384 struct ethtool_link_ksettings cmd;
385
386 if (!__ethtool_get_link_ksettings(netdev, &cmd)) {
387 const char *duplex;
388
389 switch (cmd.base.duplex) {
390 case DUPLEX_HALF:
391 duplex = "half";
392 break;
393 case DUPLEX_FULL:
394 duplex = "full";
395 break;
396 default:
397 duplex = "unknown";
398 break;
399 }
400 ret = sysfs_emit(buf, "%s\n", duplex);
401 }
402 }
403 rtnl_unlock();
404 return ret;
405}
406static DEVICE_ATTR_RO(duplex);
407
408static ssize_t testing_show(struct device *dev,
409 struct device_attribute *attr, char *buf)
410{
411 struct net_device *netdev = to_net_dev(dev);
412
413 if (netif_running(netdev))
414 return sysfs_emit(buf, fmt_dec, !!netif_testing(netdev));
415
416 return -EINVAL;
417}
418static DEVICE_ATTR_RO(testing);
419
420static ssize_t dormant_show(struct device *dev,
421 struct device_attribute *attr, char *buf)
422{
423 struct net_device *netdev = to_net_dev(dev);
424
425 if (netif_running(netdev))
426 return sysfs_emit(buf, fmt_dec, !!netif_dormant(netdev));
427
428 return -EINVAL;
429}
430static DEVICE_ATTR_RO(dormant);
431
432static const char *const operstates[] = {
433 "unknown",
434 "notpresent", /* currently unused */
435 "down",
436 "lowerlayerdown",
437 "testing",
438 "dormant",
439 "up"
440};
441
442static ssize_t operstate_show(struct device *dev,
443 struct device_attribute *attr, char *buf)
444{
445 const struct net_device *netdev = to_net_dev(dev);
446 unsigned char operstate;
447
448 operstate = READ_ONCE(netdev->operstate);
449 if (!netif_running(netdev))
450 operstate = IF_OPER_DOWN;
451
452 if (operstate >= ARRAY_SIZE(operstates))
453 return -EINVAL; /* should not happen */
454
455 return sysfs_emit(buf, "%s\n", operstates[operstate]);
456}
457static DEVICE_ATTR_RO(operstate);
458
459static ssize_t carrier_changes_show(struct device *dev,
460 struct device_attribute *attr,
461 char *buf)
462{
463 struct net_device *netdev = to_net_dev(dev);
464
465 return sysfs_emit(buf, fmt_dec,
466 atomic_read(&netdev->carrier_up_count) +
467 atomic_read(&netdev->carrier_down_count));
468}
469static DEVICE_ATTR_RO(carrier_changes);
470
471static ssize_t carrier_up_count_show(struct device *dev,
472 struct device_attribute *attr,
473 char *buf)
474{
475 struct net_device *netdev = to_net_dev(dev);
476
477 return sysfs_emit(buf, fmt_dec, atomic_read(&netdev->carrier_up_count));
478}
479static DEVICE_ATTR_RO(carrier_up_count);
480
481static ssize_t carrier_down_count_show(struct device *dev,
482 struct device_attribute *attr,
483 char *buf)
484{
485 struct net_device *netdev = to_net_dev(dev);
486
487 return sysfs_emit(buf, fmt_dec, atomic_read(&netdev->carrier_down_count));
488}
489static DEVICE_ATTR_RO(carrier_down_count);
490
491/* read-write attributes */
492
493static int change_mtu(struct net_device *dev, unsigned long new_mtu)
494{
495 return dev_set_mtu(dev, (int)new_mtu);
496}
497
498static ssize_t mtu_store(struct device *dev, struct device_attribute *attr,
499 const char *buf, size_t len)
500{
501 return netdev_store(dev, attr, buf, len, change_mtu);
502}
503NETDEVICE_SHOW_RW(mtu, fmt_dec);
504
505static int change_flags(struct net_device *dev, unsigned long new_flags)
506{
507 return dev_change_flags(dev, (unsigned int)new_flags, NULL);
508}
509
510static ssize_t flags_store(struct device *dev, struct device_attribute *attr,
511 const char *buf, size_t len)
512{
513 return netdev_store(dev, attr, buf, len, change_flags);
514}
515NETDEVICE_SHOW_RW(flags, fmt_hex);
516
517static ssize_t tx_queue_len_store(struct device *dev,
518 struct device_attribute *attr,
519 const char *buf, size_t len)
520{
521 if (!capable(CAP_NET_ADMIN))
522 return -EPERM;
523
524 return netdev_store(dev, attr, buf, len, dev_change_tx_queue_len);
525}
526NETDEVICE_SHOW_RW(tx_queue_len, fmt_dec);
527
528static int change_gro_flush_timeout(struct net_device *dev, unsigned long val)
529{
530 netdev_set_gro_flush_timeout(dev, val);
531 return 0;
532}
533
534static ssize_t gro_flush_timeout_store(struct device *dev,
535 struct device_attribute *attr,
536 const char *buf, size_t len)
537{
538 if (!capable(CAP_NET_ADMIN))
539 return -EPERM;
540
541 return netdev_lock_store(dev, attr, buf, len, change_gro_flush_timeout);
542}
543NETDEVICE_SHOW_RW(gro_flush_timeout, fmt_ulong);
544
545static int change_napi_defer_hard_irqs(struct net_device *dev, unsigned long val)
546{
547 if (val > S32_MAX)
548 return -ERANGE;
549
550 netdev_set_defer_hard_irqs(dev, (u32)val);
551 return 0;
552}
553
554static ssize_t napi_defer_hard_irqs_store(struct device *dev,
555 struct device_attribute *attr,
556 const char *buf, size_t len)
557{
558 if (!capable(CAP_NET_ADMIN))
559 return -EPERM;
560
561 return netdev_lock_store(dev, attr, buf, len,
562 change_napi_defer_hard_irqs);
563}
564NETDEVICE_SHOW_RW(napi_defer_hard_irqs, fmt_uint);
565
566static ssize_t ifalias_store(struct device *dev, struct device_attribute *attr,
567 const char *buf, size_t len)
568{
569 struct net_device *netdev = to_net_dev(dev);
570 struct net *net = dev_net(netdev);
571 size_t count = len;
572 ssize_t ret;
573
574 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
575 return -EPERM;
576
577 /* ignore trailing newline */
578 if (len > 0 && buf[len - 1] == '\n')
579 --count;
580
581 ret = sysfs_rtnl_lock(&dev->kobj, &attr->attr, netdev);
582 if (ret)
583 return ret;
584
585 ret = dev_set_alias(netdev, buf, count);
586 if (ret < 0)
587 goto err;
588 ret = len;
589 netdev_state_change(netdev);
590err:
591 rtnl_unlock();
592
593 return ret;
594}
595
596static ssize_t ifalias_show(struct device *dev,
597 struct device_attribute *attr, char *buf)
598{
599 const struct net_device *netdev = to_net_dev(dev);
600 char tmp[IFALIASZ];
601 ssize_t ret;
602
603 ret = dev_get_alias(netdev, tmp, sizeof(tmp));
604 if (ret > 0)
605 ret = sysfs_emit(buf, "%s\n", tmp);
606 return ret;
607}
608static DEVICE_ATTR_RW(ifalias);
609
610static int change_group(struct net_device *dev, unsigned long new_group)
611{
612 dev_set_group(dev, (int)new_group);
613 return 0;
614}
615
616static ssize_t group_store(struct device *dev, struct device_attribute *attr,
617 const char *buf, size_t len)
618{
619 return netdev_store(dev, attr, buf, len, change_group);
620}
621NETDEVICE_SHOW(group, fmt_dec);
622static DEVICE_ATTR(netdev_group, 0644, group_show, group_store);
623
624static int change_proto_down(struct net_device *dev, unsigned long proto_down)
625{
626 return dev_change_proto_down(dev, (bool)proto_down);
627}
628
629static ssize_t proto_down_store(struct device *dev,
630 struct device_attribute *attr,
631 const char *buf, size_t len)
632{
633 return netdev_store(dev, attr, buf, len, change_proto_down);
634}
635NETDEVICE_SHOW_RW(proto_down, fmt_dec);
636
637static ssize_t phys_port_id_show(struct device *dev,
638 struct device_attribute *attr, char *buf)
639{
640 struct net_device *netdev = to_net_dev(dev);
641 struct netdev_phys_item_id ppid;
642 ssize_t ret;
643
644 /* The check is also done in dev_get_phys_port_id; this helps returning
645 * early without hitting the locking section below.
646 */
647 if (!netdev->netdev_ops->ndo_get_phys_port_id)
648 return -EOPNOTSUPP;
649
650 ret = sysfs_rtnl_lock(&dev->kobj, &attr->attr, netdev);
651 if (ret)
652 return ret;
653
654 ret = dev_get_phys_port_id(netdev, &ppid);
655 if (!ret)
656 ret = sysfs_emit(buf, "%*phN\n", ppid.id_len, ppid.id);
657
658 rtnl_unlock();
659
660 return ret;
661}
662static DEVICE_ATTR_RO(phys_port_id);
663
664static ssize_t phys_port_name_show(struct device *dev,
665 struct device_attribute *attr, char *buf)
666{
667 struct net_device *netdev = to_net_dev(dev);
668 char name[IFNAMSIZ];
669 ssize_t ret;
670
671 /* The checks are also done in dev_get_phys_port_name; this helps
672 * returning early without hitting the locking section below.
673 */
674 if (!netdev->netdev_ops->ndo_get_phys_port_name &&
675 !netdev->devlink_port)
676 return -EOPNOTSUPP;
677
678 ret = sysfs_rtnl_lock(&dev->kobj, &attr->attr, netdev);
679 if (ret)
680 return ret;
681
682 ret = dev_get_phys_port_name(netdev, name, sizeof(name));
683 if (!ret)
684 ret = sysfs_emit(buf, "%s\n", name);
685
686 rtnl_unlock();
687
688 return ret;
689}
690static DEVICE_ATTR_RO(phys_port_name);
691
692static ssize_t phys_switch_id_show(struct device *dev,
693 struct device_attribute *attr, char *buf)
694{
695 struct net_device *netdev = to_net_dev(dev);
696 struct netdev_phys_item_id ppid = { };
697 ssize_t ret;
698
699 /* The checks are also done in dev_get_phys_port_name; this helps
700 * returning early without hitting the locking section below. This works
701 * because recurse is false when calling dev_get_port_parent_id.
702 */
703 if (!netdev->netdev_ops->ndo_get_port_parent_id &&
704 !netdev->devlink_port)
705 return -EOPNOTSUPP;
706
707 ret = sysfs_rtnl_lock(&dev->kobj, &attr->attr, netdev);
708 if (ret)
709 return ret;
710
711 ret = dev_get_port_parent_id(netdev, &ppid, false);
712 if (!ret)
713 ret = sysfs_emit(buf, "%*phN\n", ppid.id_len, ppid.id);
714
715 rtnl_unlock();
716
717 return ret;
718}
719static DEVICE_ATTR_RO(phys_switch_id);
720
721static ssize_t threaded_show(struct device *dev,
722 struct device_attribute *attr, char *buf)
723{
724 struct net_device *netdev = to_net_dev(dev);
725 ssize_t ret = -EINVAL;
726
727 rcu_read_lock();
728
729 if (dev_isalive(netdev))
730 ret = sysfs_emit(buf, fmt_dec, READ_ONCE(netdev->threaded));
731
732 rcu_read_unlock();
733
734 return ret;
735}
736
737static int modify_napi_threaded(struct net_device *dev, unsigned long val)
738{
739 int ret;
740
741 if (list_empty(&dev->napi_list))
742 return -EOPNOTSUPP;
743
744 if (val != 0 && val != 1)
745 return -EOPNOTSUPP;
746
747 ret = dev_set_threaded(dev, val);
748
749 return ret;
750}
751
752static ssize_t threaded_store(struct device *dev,
753 struct device_attribute *attr,
754 const char *buf, size_t len)
755{
756 return netdev_lock_store(dev, attr, buf, len, modify_napi_threaded);
757}
758static DEVICE_ATTR_RW(threaded);
759
760static struct attribute *net_class_attrs[] __ro_after_init = {
761 &dev_attr_netdev_group.attr,
762 &dev_attr_type.attr,
763 &dev_attr_dev_id.attr,
764 &dev_attr_dev_port.attr,
765 &dev_attr_iflink.attr,
766 &dev_attr_ifindex.attr,
767 &dev_attr_name_assign_type.attr,
768 &dev_attr_addr_assign_type.attr,
769 &dev_attr_addr_len.attr,
770 &dev_attr_link_mode.attr,
771 &dev_attr_address.attr,
772 &dev_attr_broadcast.attr,
773 &dev_attr_speed.attr,
774 &dev_attr_duplex.attr,
775 &dev_attr_dormant.attr,
776 &dev_attr_testing.attr,
777 &dev_attr_operstate.attr,
778 &dev_attr_carrier_changes.attr,
779 &dev_attr_ifalias.attr,
780 &dev_attr_carrier.attr,
781 &dev_attr_mtu.attr,
782 &dev_attr_flags.attr,
783 &dev_attr_tx_queue_len.attr,
784 &dev_attr_gro_flush_timeout.attr,
785 &dev_attr_napi_defer_hard_irqs.attr,
786 &dev_attr_phys_port_id.attr,
787 &dev_attr_phys_port_name.attr,
788 &dev_attr_phys_switch_id.attr,
789 &dev_attr_proto_down.attr,
790 &dev_attr_carrier_up_count.attr,
791 &dev_attr_carrier_down_count.attr,
792 &dev_attr_threaded.attr,
793 NULL,
794};
795ATTRIBUTE_GROUPS(net_class);
796
797/* Show a given an attribute in the statistics group */
798static ssize_t netstat_show(const struct device *d,
799 struct device_attribute *attr, char *buf,
800 unsigned long offset)
801{
802 struct net_device *dev = to_net_dev(d);
803 ssize_t ret = -EINVAL;
804
805 WARN_ON(offset > sizeof(struct rtnl_link_stats64) ||
806 offset % sizeof(u64) != 0);
807
808 rcu_read_lock();
809 if (dev_isalive(dev)) {
810 struct rtnl_link_stats64 temp;
811 const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);
812
813 ret = sysfs_emit(buf, fmt_u64, *(u64 *)(((u8 *)stats) + offset));
814 }
815 rcu_read_unlock();
816 return ret;
817}
818
819/* generate a read-only statistics attribute */
820#define NETSTAT_ENTRY(name) \
821static ssize_t name##_show(struct device *d, \
822 struct device_attribute *attr, char *buf) \
823{ \
824 return netstat_show(d, attr, buf, \
825 offsetof(struct rtnl_link_stats64, name)); \
826} \
827static DEVICE_ATTR_RO(name)
828
829NETSTAT_ENTRY(rx_packets);
830NETSTAT_ENTRY(tx_packets);
831NETSTAT_ENTRY(rx_bytes);
832NETSTAT_ENTRY(tx_bytes);
833NETSTAT_ENTRY(rx_errors);
834NETSTAT_ENTRY(tx_errors);
835NETSTAT_ENTRY(rx_dropped);
836NETSTAT_ENTRY(tx_dropped);
837NETSTAT_ENTRY(multicast);
838NETSTAT_ENTRY(collisions);
839NETSTAT_ENTRY(rx_length_errors);
840NETSTAT_ENTRY(rx_over_errors);
841NETSTAT_ENTRY(rx_crc_errors);
842NETSTAT_ENTRY(rx_frame_errors);
843NETSTAT_ENTRY(rx_fifo_errors);
844NETSTAT_ENTRY(rx_missed_errors);
845NETSTAT_ENTRY(tx_aborted_errors);
846NETSTAT_ENTRY(tx_carrier_errors);
847NETSTAT_ENTRY(tx_fifo_errors);
848NETSTAT_ENTRY(tx_heartbeat_errors);
849NETSTAT_ENTRY(tx_window_errors);
850NETSTAT_ENTRY(rx_compressed);
851NETSTAT_ENTRY(tx_compressed);
852NETSTAT_ENTRY(rx_nohandler);
853
854static struct attribute *netstat_attrs[] __ro_after_init = {
855 &dev_attr_rx_packets.attr,
856 &dev_attr_tx_packets.attr,
857 &dev_attr_rx_bytes.attr,
858 &dev_attr_tx_bytes.attr,
859 &dev_attr_rx_errors.attr,
860 &dev_attr_tx_errors.attr,
861 &dev_attr_rx_dropped.attr,
862 &dev_attr_tx_dropped.attr,
863 &dev_attr_multicast.attr,
864 &dev_attr_collisions.attr,
865 &dev_attr_rx_length_errors.attr,
866 &dev_attr_rx_over_errors.attr,
867 &dev_attr_rx_crc_errors.attr,
868 &dev_attr_rx_frame_errors.attr,
869 &dev_attr_rx_fifo_errors.attr,
870 &dev_attr_rx_missed_errors.attr,
871 &dev_attr_tx_aborted_errors.attr,
872 &dev_attr_tx_carrier_errors.attr,
873 &dev_attr_tx_fifo_errors.attr,
874 &dev_attr_tx_heartbeat_errors.attr,
875 &dev_attr_tx_window_errors.attr,
876 &dev_attr_rx_compressed.attr,
877 &dev_attr_tx_compressed.attr,
878 &dev_attr_rx_nohandler.attr,
879 NULL
880};
881
882static const struct attribute_group netstat_group = {
883 .name = "statistics",
884 .attrs = netstat_attrs,
885};
886
887static struct attribute *wireless_attrs[] = {
888 NULL
889};
890
891static const struct attribute_group wireless_group = {
892 .name = "wireless",
893 .attrs = wireless_attrs,
894};
895
896static bool wireless_group_needed(struct net_device *ndev)
897{
898#if IS_ENABLED(CONFIG_CFG80211)
899 if (ndev->ieee80211_ptr)
900 return true;
901#endif
902#if IS_ENABLED(CONFIG_WIRELESS_EXT)
903 if (ndev->wireless_handlers)
904 return true;
905#endif
906 return false;
907}
908
909#else /* CONFIG_SYSFS */
910#define net_class_groups NULL
911#endif /* CONFIG_SYSFS */
912
913#ifdef CONFIG_SYSFS
914#define to_rx_queue_attr(_attr) \
915 container_of(_attr, struct rx_queue_attribute, attr)
916
917#define to_rx_queue(obj) container_of(obj, struct netdev_rx_queue, kobj)
918
919static ssize_t rx_queue_attr_show(struct kobject *kobj, struct attribute *attr,
920 char *buf)
921{
922 const struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
923 struct netdev_rx_queue *queue = to_rx_queue(kobj);
924
925 if (!attribute->show)
926 return -EIO;
927
928 return attribute->show(queue, buf);
929}
930
931static ssize_t rx_queue_attr_store(struct kobject *kobj, struct attribute *attr,
932 const char *buf, size_t count)
933{
934 const struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
935 struct netdev_rx_queue *queue = to_rx_queue(kobj);
936
937 if (!attribute->store)
938 return -EIO;
939
940 return attribute->store(queue, buf, count);
941}
942
943static const struct sysfs_ops rx_queue_sysfs_ops = {
944 .show = rx_queue_attr_show,
945 .store = rx_queue_attr_store,
946};
947
948#ifdef CONFIG_RPS
949static ssize_t show_rps_map(struct netdev_rx_queue *queue, char *buf)
950{
951 struct rps_map *map;
952 cpumask_var_t mask;
953 int i, len;
954
955 if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
956 return -ENOMEM;
957
958 rcu_read_lock();
959 map = rcu_dereference(queue->rps_map);
960 if (map)
961 for (i = 0; i < map->len; i++)
962 cpumask_set_cpu(map->cpus[i], mask);
963
964 len = sysfs_emit(buf, "%*pb\n", cpumask_pr_args(mask));
965 rcu_read_unlock();
966 free_cpumask_var(mask);
967
968 return len < PAGE_SIZE ? len : -EINVAL;
969}
970
971static int netdev_rx_queue_set_rps_mask(struct netdev_rx_queue *queue,
972 cpumask_var_t mask)
973{
974 static DEFINE_MUTEX(rps_map_mutex);
975 struct rps_map *old_map, *map;
976 int cpu, i;
977
978 map = kzalloc(max_t(unsigned int,
979 RPS_MAP_SIZE(cpumask_weight(mask)), L1_CACHE_BYTES),
980 GFP_KERNEL);
981 if (!map)
982 return -ENOMEM;
983
984 i = 0;
985 for_each_cpu_and(cpu, mask, cpu_online_mask)
986 map->cpus[i++] = cpu;
987
988 if (i) {
989 map->len = i;
990 } else {
991 kfree(map);
992 map = NULL;
993 }
994
995 mutex_lock(&rps_map_mutex);
996 old_map = rcu_dereference_protected(queue->rps_map,
997 mutex_is_locked(&rps_map_mutex));
998 rcu_assign_pointer(queue->rps_map, map);
999
1000 if (map)
1001 static_branch_inc(&rps_needed);
1002 if (old_map)
1003 static_branch_dec(&rps_needed);
1004
1005 mutex_unlock(&rps_map_mutex);
1006
1007 if (old_map)
1008 kfree_rcu(old_map, rcu);
1009 return 0;
1010}
1011
1012int rps_cpumask_housekeeping(struct cpumask *mask)
1013{
1014 if (!cpumask_empty(mask)) {
1015 cpumask_and(mask, mask, housekeeping_cpumask(HK_TYPE_DOMAIN));
1016 cpumask_and(mask, mask, housekeeping_cpumask(HK_TYPE_WQ));
1017 if (cpumask_empty(mask))
1018 return -EINVAL;
1019 }
1020 return 0;
1021}
1022
1023static ssize_t store_rps_map(struct netdev_rx_queue *queue,
1024 const char *buf, size_t len)
1025{
1026 cpumask_var_t mask;
1027 int err;
1028
1029 if (!capable(CAP_NET_ADMIN))
1030 return -EPERM;
1031
1032 if (!alloc_cpumask_var(&mask, GFP_KERNEL))
1033 return -ENOMEM;
1034
1035 err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
1036 if (err)
1037 goto out;
1038
1039 err = rps_cpumask_housekeeping(mask);
1040 if (err)
1041 goto out;
1042
1043 err = netdev_rx_queue_set_rps_mask(queue, mask);
1044
1045out:
1046 free_cpumask_var(mask);
1047 return err ? : len;
1048}
1049
1050static ssize_t show_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
1051 char *buf)
1052{
1053 struct rps_dev_flow_table *flow_table;
1054 unsigned long val = 0;
1055
1056 rcu_read_lock();
1057 flow_table = rcu_dereference(queue->rps_flow_table);
1058 if (flow_table)
1059 val = 1UL << flow_table->log;
1060 rcu_read_unlock();
1061
1062 return sysfs_emit(buf, "%lu\n", val);
1063}
1064
1065static void rps_dev_flow_table_release(struct rcu_head *rcu)
1066{
1067 struct rps_dev_flow_table *table = container_of(rcu,
1068 struct rps_dev_flow_table, rcu);
1069 vfree(table);
1070}
1071
1072static ssize_t store_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
1073 const char *buf, size_t len)
1074{
1075 unsigned long mask, count;
1076 struct rps_dev_flow_table *table, *old_table;
1077 static DEFINE_SPINLOCK(rps_dev_flow_lock);
1078 int rc;
1079
1080 if (!capable(CAP_NET_ADMIN))
1081 return -EPERM;
1082
1083 rc = kstrtoul(buf, 0, &count);
1084 if (rc < 0)
1085 return rc;
1086
1087 if (count) {
1088 mask = count - 1;
1089 /* mask = roundup_pow_of_two(count) - 1;
1090 * without overflows...
1091 */
1092 while ((mask | (mask >> 1)) != mask)
1093 mask |= (mask >> 1);
1094 /* On 64 bit arches, must check mask fits in table->mask (u32),
1095 * and on 32bit arches, must check
1096 * RPS_DEV_FLOW_TABLE_SIZE(mask + 1) doesn't overflow.
1097 */
1098#if BITS_PER_LONG > 32
1099 if (mask > (unsigned long)(u32)mask)
1100 return -EINVAL;
1101#else
1102 if (mask > (ULONG_MAX - RPS_DEV_FLOW_TABLE_SIZE(1))
1103 / sizeof(struct rps_dev_flow)) {
1104 /* Enforce a limit to prevent overflow */
1105 return -EINVAL;
1106 }
1107#endif
1108 table = vmalloc(RPS_DEV_FLOW_TABLE_SIZE(mask + 1));
1109 if (!table)
1110 return -ENOMEM;
1111
1112 table->log = ilog2(mask) + 1;
1113 for (count = 0; count <= mask; count++)
1114 table->flows[count].cpu = RPS_NO_CPU;
1115 } else {
1116 table = NULL;
1117 }
1118
1119 spin_lock(&rps_dev_flow_lock);
1120 old_table = rcu_dereference_protected(queue->rps_flow_table,
1121 lockdep_is_held(&rps_dev_flow_lock));
1122 rcu_assign_pointer(queue->rps_flow_table, table);
1123 spin_unlock(&rps_dev_flow_lock);
1124
1125 if (old_table)
1126 call_rcu(&old_table->rcu, rps_dev_flow_table_release);
1127
1128 return len;
1129}
1130
1131static struct rx_queue_attribute rps_cpus_attribute __ro_after_init
1132 = __ATTR(rps_cpus, 0644, show_rps_map, store_rps_map);
1133
1134static struct rx_queue_attribute rps_dev_flow_table_cnt_attribute __ro_after_init
1135 = __ATTR(rps_flow_cnt, 0644,
1136 show_rps_dev_flow_table_cnt, store_rps_dev_flow_table_cnt);
1137#endif /* CONFIG_RPS */
1138
1139static struct attribute *rx_queue_default_attrs[] __ro_after_init = {
1140#ifdef CONFIG_RPS
1141 &rps_cpus_attribute.attr,
1142 &rps_dev_flow_table_cnt_attribute.attr,
1143#endif
1144 NULL
1145};
1146ATTRIBUTE_GROUPS(rx_queue_default);
1147
1148static void rx_queue_release(struct kobject *kobj)
1149{
1150 struct netdev_rx_queue *queue = to_rx_queue(kobj);
1151#ifdef CONFIG_RPS
1152 struct rps_map *map;
1153 struct rps_dev_flow_table *flow_table;
1154
1155 map = rcu_dereference_protected(queue->rps_map, 1);
1156 if (map) {
1157 RCU_INIT_POINTER(queue->rps_map, NULL);
1158 kfree_rcu(map, rcu);
1159 }
1160
1161 flow_table = rcu_dereference_protected(queue->rps_flow_table, 1);
1162 if (flow_table) {
1163 RCU_INIT_POINTER(queue->rps_flow_table, NULL);
1164 call_rcu(&flow_table->rcu, rps_dev_flow_table_release);
1165 }
1166#endif
1167
1168 memset(kobj, 0, sizeof(*kobj));
1169 netdev_put(queue->dev, &queue->dev_tracker);
1170}
1171
1172static const void *rx_queue_namespace(const struct kobject *kobj)
1173{
1174 struct netdev_rx_queue *queue = to_rx_queue(kobj);
1175 struct device *dev = &queue->dev->dev;
1176 const void *ns = NULL;
1177
1178 if (dev->class && dev->class->namespace)
1179 ns = dev->class->namespace(dev);
1180
1181 return ns;
1182}
1183
1184static void rx_queue_get_ownership(const struct kobject *kobj,
1185 kuid_t *uid, kgid_t *gid)
1186{
1187 const struct net *net = rx_queue_namespace(kobj);
1188
1189 net_ns_get_ownership(net, uid, gid);
1190}
1191
1192static const struct kobj_type rx_queue_ktype = {
1193 .sysfs_ops = &rx_queue_sysfs_ops,
1194 .release = rx_queue_release,
1195 .namespace = rx_queue_namespace,
1196 .get_ownership = rx_queue_get_ownership,
1197};
1198
1199static int rx_queue_default_mask(struct net_device *dev,
1200 struct netdev_rx_queue *queue)
1201{
1202#if IS_ENABLED(CONFIG_RPS) && IS_ENABLED(CONFIG_SYSCTL)
1203 struct cpumask *rps_default_mask = READ_ONCE(dev_net(dev)->core.rps_default_mask);
1204
1205 if (rps_default_mask && !cpumask_empty(rps_default_mask))
1206 return netdev_rx_queue_set_rps_mask(queue, rps_default_mask);
1207#endif
1208 return 0;
1209}
1210
1211static int rx_queue_add_kobject(struct net_device *dev, int index)
1212{
1213 struct netdev_rx_queue *queue = dev->_rx + index;
1214 struct kobject *kobj = &queue->kobj;
1215 int error = 0;
1216
1217 /* Rx queues are cleared in rx_queue_release to allow later
1218 * re-registration. This is triggered when their kobj refcount is
1219 * dropped.
1220 *
1221 * If a queue is removed while both a read (or write) operation and a
1222 * the re-addition of the same queue are pending (waiting on rntl_lock)
1223 * it might happen that the re-addition will execute before the read,
1224 * making the initial removal to never happen (queue's kobj refcount
1225 * won't drop enough because of the pending read). In such rare case,
1226 * return to allow the removal operation to complete.
1227 */
1228 if (unlikely(kobj->state_initialized)) {
1229 netdev_warn_once(dev, "Cannot re-add rx queues before their removal completed");
1230 return -EAGAIN;
1231 }
1232
1233 /* Kobject_put later will trigger rx_queue_release call which
1234 * decreases dev refcount: Take that reference here
1235 */
1236 netdev_hold(queue->dev, &queue->dev_tracker, GFP_KERNEL);
1237
1238 kobj->kset = dev->queues_kset;
1239 error = kobject_init_and_add(kobj, &rx_queue_ktype, NULL,
1240 "rx-%u", index);
1241 if (error)
1242 goto err;
1243
1244 queue->groups = rx_queue_default_groups;
1245 error = sysfs_create_groups(kobj, queue->groups);
1246 if (error)
1247 goto err;
1248
1249 if (dev->sysfs_rx_queue_group) {
1250 error = sysfs_create_group(kobj, dev->sysfs_rx_queue_group);
1251 if (error)
1252 goto err_default_groups;
1253 }
1254
1255 error = rx_queue_default_mask(dev, queue);
1256 if (error)
1257 goto err_default_groups;
1258
1259 kobject_uevent(kobj, KOBJ_ADD);
1260
1261 return error;
1262
1263err_default_groups:
1264 sysfs_remove_groups(kobj, queue->groups);
1265err:
1266 kobject_put(kobj);
1267 return error;
1268}
1269
1270static int rx_queue_change_owner(struct net_device *dev, int index, kuid_t kuid,
1271 kgid_t kgid)
1272{
1273 struct netdev_rx_queue *queue = dev->_rx + index;
1274 struct kobject *kobj = &queue->kobj;
1275 int error;
1276
1277 error = sysfs_change_owner(kobj, kuid, kgid);
1278 if (error)
1279 return error;
1280
1281 if (dev->sysfs_rx_queue_group)
1282 error = sysfs_group_change_owner(
1283 kobj, dev->sysfs_rx_queue_group, kuid, kgid);
1284
1285 return error;
1286}
1287#endif /* CONFIG_SYSFS */
1288
1289int
1290net_rx_queue_update_kobjects(struct net_device *dev, int old_num, int new_num)
1291{
1292#ifdef CONFIG_SYSFS
1293 int i;
1294 int error = 0;
1295
1296#ifndef CONFIG_RPS
1297 if (!dev->sysfs_rx_queue_group)
1298 return 0;
1299#endif
1300 for (i = old_num; i < new_num; i++) {
1301 error = rx_queue_add_kobject(dev, i);
1302 if (error) {
1303 new_num = old_num;
1304 break;
1305 }
1306 }
1307
1308 while (--i >= new_num) {
1309 struct netdev_rx_queue *queue = &dev->_rx[i];
1310 struct kobject *kobj = &queue->kobj;
1311
1312 if (!refcount_read(&dev_net(dev)->ns.count))
1313 kobj->uevent_suppress = 1;
1314 if (dev->sysfs_rx_queue_group)
1315 sysfs_remove_group(kobj, dev->sysfs_rx_queue_group);
1316 sysfs_remove_groups(kobj, queue->groups);
1317 kobject_put(kobj);
1318 }
1319
1320 return error;
1321#else
1322 return 0;
1323#endif
1324}
1325
1326static int net_rx_queue_change_owner(struct net_device *dev, int num,
1327 kuid_t kuid, kgid_t kgid)
1328{
1329#ifdef CONFIG_SYSFS
1330 int error = 0;
1331 int i;
1332
1333#ifndef CONFIG_RPS
1334 if (!dev->sysfs_rx_queue_group)
1335 return 0;
1336#endif
1337 for (i = 0; i < num; i++) {
1338 error = rx_queue_change_owner(dev, i, kuid, kgid);
1339 if (error)
1340 break;
1341 }
1342
1343 return error;
1344#else
1345 return 0;
1346#endif
1347}
1348
1349#ifdef CONFIG_SYSFS
1350/*
1351 * netdev_queue sysfs structures and functions.
1352 */
1353struct netdev_queue_attribute {
1354 struct attribute attr;
1355 ssize_t (*show)(struct kobject *kobj, struct attribute *attr,
1356 struct netdev_queue *queue, char *buf);
1357 ssize_t (*store)(struct kobject *kobj, struct attribute *attr,
1358 struct netdev_queue *queue, const char *buf,
1359 size_t len);
1360};
1361#define to_netdev_queue_attr(_attr) \
1362 container_of(_attr, struct netdev_queue_attribute, attr)
1363
1364#define to_netdev_queue(obj) container_of(obj, struct netdev_queue, kobj)
1365
1366static ssize_t netdev_queue_attr_show(struct kobject *kobj,
1367 struct attribute *attr, char *buf)
1368{
1369 const struct netdev_queue_attribute *attribute
1370 = to_netdev_queue_attr(attr);
1371 struct netdev_queue *queue = to_netdev_queue(kobj);
1372
1373 if (!attribute->show)
1374 return -EIO;
1375
1376 return attribute->show(kobj, attr, queue, buf);
1377}
1378
1379static ssize_t netdev_queue_attr_store(struct kobject *kobj,
1380 struct attribute *attr,
1381 const char *buf, size_t count)
1382{
1383 const struct netdev_queue_attribute *attribute
1384 = to_netdev_queue_attr(attr);
1385 struct netdev_queue *queue = to_netdev_queue(kobj);
1386
1387 if (!attribute->store)
1388 return -EIO;
1389
1390 return attribute->store(kobj, attr, queue, buf, count);
1391}
1392
1393static const struct sysfs_ops netdev_queue_sysfs_ops = {
1394 .show = netdev_queue_attr_show,
1395 .store = netdev_queue_attr_store,
1396};
1397
1398static ssize_t tx_timeout_show(struct kobject *kobj, struct attribute *attr,
1399 struct netdev_queue *queue, char *buf)
1400{
1401 unsigned long trans_timeout = atomic_long_read(&queue->trans_timeout);
1402
1403 return sysfs_emit(buf, fmt_ulong, trans_timeout);
1404}
1405
1406static unsigned int get_netdev_queue_index(struct netdev_queue *queue)
1407{
1408 struct net_device *dev = queue->dev;
1409 unsigned int i;
1410
1411 i = queue - dev->_tx;
1412 BUG_ON(i >= dev->num_tx_queues);
1413
1414 return i;
1415}
1416
1417static ssize_t traffic_class_show(struct kobject *kobj, struct attribute *attr,
1418 struct netdev_queue *queue, char *buf)
1419{
1420 struct net_device *dev = queue->dev;
1421 int num_tc, tc, index, ret;
1422
1423 if (!netif_is_multiqueue(dev))
1424 return -ENOENT;
1425
1426 ret = sysfs_rtnl_lock(kobj, attr, queue->dev);
1427 if (ret)
1428 return ret;
1429
1430 index = get_netdev_queue_index(queue);
1431
1432 /* If queue belongs to subordinate dev use its TC mapping */
1433 dev = netdev_get_tx_queue(dev, index)->sb_dev ? : dev;
1434
1435 num_tc = dev->num_tc;
1436 tc = netdev_txq_to_tc(dev, index);
1437
1438 rtnl_unlock();
1439
1440 if (tc < 0)
1441 return -EINVAL;
1442
1443 /* We can report the traffic class one of two ways:
1444 * Subordinate device traffic classes are reported with the traffic
1445 * class first, and then the subordinate class so for example TC0 on
1446 * subordinate device 2 will be reported as "0-2". If the queue
1447 * belongs to the root device it will be reported with just the
1448 * traffic class, so just "0" for TC 0 for example.
1449 */
1450 return num_tc < 0 ? sysfs_emit(buf, "%d%d\n", tc, num_tc) :
1451 sysfs_emit(buf, "%d\n", tc);
1452}
1453
1454#ifdef CONFIG_XPS
1455static ssize_t tx_maxrate_show(struct kobject *kobj, struct attribute *attr,
1456 struct netdev_queue *queue, char *buf)
1457{
1458 return sysfs_emit(buf, "%lu\n", queue->tx_maxrate);
1459}
1460
1461static ssize_t tx_maxrate_store(struct kobject *kobj, struct attribute *attr,
1462 struct netdev_queue *queue, const char *buf,
1463 size_t len)
1464{
1465 int err, index = get_netdev_queue_index(queue);
1466 struct net_device *dev = queue->dev;
1467 u32 rate = 0;
1468
1469 if (!capable(CAP_NET_ADMIN))
1470 return -EPERM;
1471
1472 /* The check is also done later; this helps returning early without
1473 * hitting the locking section below.
1474 */
1475 if (!dev->netdev_ops->ndo_set_tx_maxrate)
1476 return -EOPNOTSUPP;
1477
1478 err = kstrtou32(buf, 10, &rate);
1479 if (err < 0)
1480 return err;
1481
1482 err = sysfs_rtnl_lock(kobj, attr, dev);
1483 if (err)
1484 return err;
1485
1486 err = -EOPNOTSUPP;
1487 netdev_lock_ops(dev);
1488 if (dev->netdev_ops->ndo_set_tx_maxrate)
1489 err = dev->netdev_ops->ndo_set_tx_maxrate(dev, index, rate);
1490 netdev_unlock_ops(dev);
1491
1492 if (!err) {
1493 queue->tx_maxrate = rate;
1494 rtnl_unlock();
1495 return len;
1496 }
1497
1498 rtnl_unlock();
1499 return err;
1500}
1501
1502static struct netdev_queue_attribute queue_tx_maxrate __ro_after_init
1503 = __ATTR_RW(tx_maxrate);
1504#endif
1505
1506static struct netdev_queue_attribute queue_trans_timeout __ro_after_init
1507 = __ATTR_RO(tx_timeout);
1508
1509static struct netdev_queue_attribute queue_traffic_class __ro_after_init
1510 = __ATTR_RO(traffic_class);
1511
1512#ifdef CONFIG_BQL
1513/*
1514 * Byte queue limits sysfs structures and functions.
1515 */
1516static ssize_t bql_show(char *buf, unsigned int value)
1517{
1518 return sysfs_emit(buf, "%u\n", value);
1519}
1520
1521static ssize_t bql_set(const char *buf, const size_t count,
1522 unsigned int *pvalue)
1523{
1524 unsigned int value;
1525 int err;
1526
1527 if (!strcmp(buf, "max") || !strcmp(buf, "max\n")) {
1528 value = DQL_MAX_LIMIT;
1529 } else {
1530 err = kstrtouint(buf, 10, &value);
1531 if (err < 0)
1532 return err;
1533 if (value > DQL_MAX_LIMIT)
1534 return -EINVAL;
1535 }
1536
1537 *pvalue = value;
1538
1539 return count;
1540}
1541
1542static ssize_t bql_show_hold_time(struct kobject *kobj, struct attribute *attr,
1543 struct netdev_queue *queue, char *buf)
1544{
1545 struct dql *dql = &queue->dql;
1546
1547 return sysfs_emit(buf, "%u\n", jiffies_to_msecs(dql->slack_hold_time));
1548}
1549
1550static ssize_t bql_set_hold_time(struct kobject *kobj, struct attribute *attr,
1551 struct netdev_queue *queue, const char *buf,
1552 size_t len)
1553{
1554 struct dql *dql = &queue->dql;
1555 unsigned int value;
1556 int err;
1557
1558 err = kstrtouint(buf, 10, &value);
1559 if (err < 0)
1560 return err;
1561
1562 dql->slack_hold_time = msecs_to_jiffies(value);
1563
1564 return len;
1565}
1566
1567static struct netdev_queue_attribute bql_hold_time_attribute __ro_after_init
1568 = __ATTR(hold_time, 0644,
1569 bql_show_hold_time, bql_set_hold_time);
1570
1571static ssize_t bql_show_stall_thrs(struct kobject *kobj, struct attribute *attr,
1572 struct netdev_queue *queue, char *buf)
1573{
1574 struct dql *dql = &queue->dql;
1575
1576 return sysfs_emit(buf, "%u\n", jiffies_to_msecs(dql->stall_thrs));
1577}
1578
1579static ssize_t bql_set_stall_thrs(struct kobject *kobj, struct attribute *attr,
1580 struct netdev_queue *queue, const char *buf,
1581 size_t len)
1582{
1583 struct dql *dql = &queue->dql;
1584 unsigned int value;
1585 int err;
1586
1587 err = kstrtouint(buf, 10, &value);
1588 if (err < 0)
1589 return err;
1590
1591 value = msecs_to_jiffies(value);
1592 if (value && (value < 4 || value > 4 / 2 * BITS_PER_LONG))
1593 return -ERANGE;
1594
1595 if (!dql->stall_thrs && value)
1596 dql->last_reap = jiffies;
1597 /* Force last_reap to be live */
1598 smp_wmb();
1599 dql->stall_thrs = value;
1600
1601 return len;
1602}
1603
1604static struct netdev_queue_attribute bql_stall_thrs_attribute __ro_after_init =
1605 __ATTR(stall_thrs, 0644, bql_show_stall_thrs, bql_set_stall_thrs);
1606
1607static ssize_t bql_show_stall_max(struct kobject *kobj, struct attribute *attr,
1608 struct netdev_queue *queue, char *buf)
1609{
1610 return sysfs_emit(buf, "%u\n", READ_ONCE(queue->dql.stall_max));
1611}
1612
1613static ssize_t bql_set_stall_max(struct kobject *kobj, struct attribute *attr,
1614 struct netdev_queue *queue, const char *buf,
1615 size_t len)
1616{
1617 WRITE_ONCE(queue->dql.stall_max, 0);
1618 return len;
1619}
1620
1621static struct netdev_queue_attribute bql_stall_max_attribute __ro_after_init =
1622 __ATTR(stall_max, 0644, bql_show_stall_max, bql_set_stall_max);
1623
1624static ssize_t bql_show_stall_cnt(struct kobject *kobj, struct attribute *attr,
1625 struct netdev_queue *queue, char *buf)
1626{
1627 struct dql *dql = &queue->dql;
1628
1629 return sysfs_emit(buf, "%lu\n", dql->stall_cnt);
1630}
1631
1632static struct netdev_queue_attribute bql_stall_cnt_attribute __ro_after_init =
1633 __ATTR(stall_cnt, 0444, bql_show_stall_cnt, NULL);
1634
1635static ssize_t bql_show_inflight(struct kobject *kobj, struct attribute *attr,
1636 struct netdev_queue *queue, char *buf)
1637{
1638 struct dql *dql = &queue->dql;
1639
1640 return sysfs_emit(buf, "%u\n", dql->num_queued - dql->num_completed);
1641}
1642
1643static struct netdev_queue_attribute bql_inflight_attribute __ro_after_init =
1644 __ATTR(inflight, 0444, bql_show_inflight, NULL);
1645
1646#define BQL_ATTR(NAME, FIELD) \
1647static ssize_t bql_show_ ## NAME(struct kobject *kobj, \
1648 struct attribute *attr, \
1649 struct netdev_queue *queue, char *buf) \
1650{ \
1651 return bql_show(buf, queue->dql.FIELD); \
1652} \
1653 \
1654static ssize_t bql_set_ ## NAME(struct kobject *kobj, \
1655 struct attribute *attr, \
1656 struct netdev_queue *queue, \
1657 const char *buf, size_t len) \
1658{ \
1659 return bql_set(buf, len, &queue->dql.FIELD); \
1660} \
1661 \
1662static struct netdev_queue_attribute bql_ ## NAME ## _attribute __ro_after_init \
1663 = __ATTR(NAME, 0644, \
1664 bql_show_ ## NAME, bql_set_ ## NAME)
1665
1666BQL_ATTR(limit, limit);
1667BQL_ATTR(limit_max, max_limit);
1668BQL_ATTR(limit_min, min_limit);
1669
1670static struct attribute *dql_attrs[] __ro_after_init = {
1671 &bql_limit_attribute.attr,
1672 &bql_limit_max_attribute.attr,
1673 &bql_limit_min_attribute.attr,
1674 &bql_hold_time_attribute.attr,
1675 &bql_inflight_attribute.attr,
1676 &bql_stall_thrs_attribute.attr,
1677 &bql_stall_cnt_attribute.attr,
1678 &bql_stall_max_attribute.attr,
1679 NULL
1680};
1681
1682static const struct attribute_group dql_group = {
1683 .name = "byte_queue_limits",
1684 .attrs = dql_attrs,
1685};
1686#else
1687/* Fake declaration, all the code using it should be dead */
1688static const struct attribute_group dql_group = {};
1689#endif /* CONFIG_BQL */
1690
1691#ifdef CONFIG_XPS
1692static ssize_t xps_queue_show(struct net_device *dev, unsigned int index,
1693 int tc, char *buf, enum xps_map_type type)
1694{
1695 struct xps_dev_maps *dev_maps;
1696 unsigned long *mask;
1697 unsigned int nr_ids;
1698 int j, len;
1699
1700 rcu_read_lock();
1701 dev_maps = rcu_dereference(dev->xps_maps[type]);
1702
1703 /* Default to nr_cpu_ids/dev->num_rx_queues and do not just return 0
1704 * when dev_maps hasn't been allocated yet, to be backward compatible.
1705 */
1706 nr_ids = dev_maps ? dev_maps->nr_ids :
1707 (type == XPS_CPUS ? nr_cpu_ids : dev->num_rx_queues);
1708
1709 mask = bitmap_zalloc(nr_ids, GFP_NOWAIT);
1710 if (!mask) {
1711 rcu_read_unlock();
1712 return -ENOMEM;
1713 }
1714
1715 if (!dev_maps || tc >= dev_maps->num_tc)
1716 goto out_no_maps;
1717
1718 for (j = 0; j < nr_ids; j++) {
1719 int i, tci = j * dev_maps->num_tc + tc;
1720 struct xps_map *map;
1721
1722 map = rcu_dereference(dev_maps->attr_map[tci]);
1723 if (!map)
1724 continue;
1725
1726 for (i = map->len; i--;) {
1727 if (map->queues[i] == index) {
1728 __set_bit(j, mask);
1729 break;
1730 }
1731 }
1732 }
1733out_no_maps:
1734 rcu_read_unlock();
1735
1736 len = bitmap_print_to_pagebuf(false, buf, mask, nr_ids);
1737 bitmap_free(mask);
1738
1739 return len < PAGE_SIZE ? len : -EINVAL;
1740}
1741
1742static ssize_t xps_cpus_show(struct kobject *kobj, struct attribute *attr,
1743 struct netdev_queue *queue, char *buf)
1744{
1745 struct net_device *dev = queue->dev;
1746 unsigned int index;
1747 int len, tc, ret;
1748
1749 if (!netif_is_multiqueue(dev))
1750 return -ENOENT;
1751
1752 index = get_netdev_queue_index(queue);
1753
1754 ret = sysfs_rtnl_lock(kobj, attr, queue->dev);
1755 if (ret)
1756 return ret;
1757
1758 /* If queue belongs to subordinate dev use its map */
1759 dev = netdev_get_tx_queue(dev, index)->sb_dev ? : dev;
1760
1761 tc = netdev_txq_to_tc(dev, index);
1762 if (tc < 0) {
1763 rtnl_unlock();
1764 return -EINVAL;
1765 }
1766
1767 /* Increase the net device refcnt to make sure it won't be freed while
1768 * xps_queue_show is running.
1769 */
1770 dev_hold(dev);
1771 rtnl_unlock();
1772
1773 len = xps_queue_show(dev, index, tc, buf, XPS_CPUS);
1774
1775 dev_put(dev);
1776 return len;
1777}
1778
1779static ssize_t xps_cpus_store(struct kobject *kobj, struct attribute *attr,
1780 struct netdev_queue *queue, const char *buf,
1781 size_t len)
1782{
1783 struct net_device *dev = queue->dev;
1784 unsigned int index;
1785 cpumask_var_t mask;
1786 int err;
1787
1788 if (!netif_is_multiqueue(dev))
1789 return -ENOENT;
1790
1791 if (!capable(CAP_NET_ADMIN))
1792 return -EPERM;
1793
1794 if (!alloc_cpumask_var(&mask, GFP_KERNEL))
1795 return -ENOMEM;
1796
1797 index = get_netdev_queue_index(queue);
1798
1799 err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
1800 if (err) {
1801 free_cpumask_var(mask);
1802 return err;
1803 }
1804
1805 err = sysfs_rtnl_lock(kobj, attr, dev);
1806 if (err) {
1807 free_cpumask_var(mask);
1808 return err;
1809 }
1810
1811 err = netif_set_xps_queue(dev, mask, index);
1812 rtnl_unlock();
1813
1814 free_cpumask_var(mask);
1815
1816 return err ? : len;
1817}
1818
1819static struct netdev_queue_attribute xps_cpus_attribute __ro_after_init
1820 = __ATTR_RW(xps_cpus);
1821
1822static ssize_t xps_rxqs_show(struct kobject *kobj, struct attribute *attr,
1823 struct netdev_queue *queue, char *buf)
1824{
1825 struct net_device *dev = queue->dev;
1826 unsigned int index;
1827 int tc, ret;
1828
1829 index = get_netdev_queue_index(queue);
1830
1831 ret = sysfs_rtnl_lock(kobj, attr, dev);
1832 if (ret)
1833 return ret;
1834
1835 tc = netdev_txq_to_tc(dev, index);
1836
1837 /* Increase the net device refcnt to make sure it won't be freed while
1838 * xps_queue_show is running.
1839 */
1840 dev_hold(dev);
1841 rtnl_unlock();
1842
1843 ret = tc >= 0 ? xps_queue_show(dev, index, tc, buf, XPS_RXQS) : -EINVAL;
1844 dev_put(dev);
1845 return ret;
1846}
1847
1848static ssize_t xps_rxqs_store(struct kobject *kobj, struct attribute *attr,
1849 struct netdev_queue *queue, const char *buf,
1850 size_t len)
1851{
1852 struct net_device *dev = queue->dev;
1853 struct net *net = dev_net(dev);
1854 unsigned long *mask;
1855 unsigned int index;
1856 int err;
1857
1858 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1859 return -EPERM;
1860
1861 mask = bitmap_zalloc(dev->num_rx_queues, GFP_KERNEL);
1862 if (!mask)
1863 return -ENOMEM;
1864
1865 index = get_netdev_queue_index(queue);
1866
1867 err = bitmap_parse(buf, len, mask, dev->num_rx_queues);
1868 if (err) {
1869 bitmap_free(mask);
1870 return err;
1871 }
1872
1873 err = sysfs_rtnl_lock(kobj, attr, dev);
1874 if (err) {
1875 bitmap_free(mask);
1876 return err;
1877 }
1878
1879 cpus_read_lock();
1880 err = __netif_set_xps_queue(dev, mask, index, XPS_RXQS);
1881 cpus_read_unlock();
1882
1883 rtnl_unlock();
1884
1885 bitmap_free(mask);
1886 return err ? : len;
1887}
1888
1889static struct netdev_queue_attribute xps_rxqs_attribute __ro_after_init
1890 = __ATTR_RW(xps_rxqs);
1891#endif /* CONFIG_XPS */
1892
1893static struct attribute *netdev_queue_default_attrs[] __ro_after_init = {
1894 &queue_trans_timeout.attr,
1895 &queue_traffic_class.attr,
1896#ifdef CONFIG_XPS
1897 &xps_cpus_attribute.attr,
1898 &xps_rxqs_attribute.attr,
1899 &queue_tx_maxrate.attr,
1900#endif
1901 NULL
1902};
1903ATTRIBUTE_GROUPS(netdev_queue_default);
1904
1905static void netdev_queue_release(struct kobject *kobj)
1906{
1907 struct netdev_queue *queue = to_netdev_queue(kobj);
1908
1909 memset(kobj, 0, sizeof(*kobj));
1910 netdev_put(queue->dev, &queue->dev_tracker);
1911}
1912
1913static const void *netdev_queue_namespace(const struct kobject *kobj)
1914{
1915 struct netdev_queue *queue = to_netdev_queue(kobj);
1916 struct device *dev = &queue->dev->dev;
1917 const void *ns = NULL;
1918
1919 if (dev->class && dev->class->namespace)
1920 ns = dev->class->namespace(dev);
1921
1922 return ns;
1923}
1924
1925static void netdev_queue_get_ownership(const struct kobject *kobj,
1926 kuid_t *uid, kgid_t *gid)
1927{
1928 const struct net *net = netdev_queue_namespace(kobj);
1929
1930 net_ns_get_ownership(net, uid, gid);
1931}
1932
1933static const struct kobj_type netdev_queue_ktype = {
1934 .sysfs_ops = &netdev_queue_sysfs_ops,
1935 .release = netdev_queue_release,
1936 .namespace = netdev_queue_namespace,
1937 .get_ownership = netdev_queue_get_ownership,
1938};
1939
1940static bool netdev_uses_bql(const struct net_device *dev)
1941{
1942 if (dev->lltx || (dev->priv_flags & IFF_NO_QUEUE))
1943 return false;
1944
1945 return IS_ENABLED(CONFIG_BQL);
1946}
1947
1948static int netdev_queue_add_kobject(struct net_device *dev, int index)
1949{
1950 struct netdev_queue *queue = dev->_tx + index;
1951 struct kobject *kobj = &queue->kobj;
1952 int error = 0;
1953
1954 /* Tx queues are cleared in netdev_queue_release to allow later
1955 * re-registration. This is triggered when their kobj refcount is
1956 * dropped.
1957 *
1958 * If a queue is removed while both a read (or write) operation and a
1959 * the re-addition of the same queue are pending (waiting on rntl_lock)
1960 * it might happen that the re-addition will execute before the read,
1961 * making the initial removal to never happen (queue's kobj refcount
1962 * won't drop enough because of the pending read). In such rare case,
1963 * return to allow the removal operation to complete.
1964 */
1965 if (unlikely(kobj->state_initialized)) {
1966 netdev_warn_once(dev, "Cannot re-add tx queues before their removal completed");
1967 return -EAGAIN;
1968 }
1969
1970 /* Kobject_put later will trigger netdev_queue_release call
1971 * which decreases dev refcount: Take that reference here
1972 */
1973 netdev_hold(queue->dev, &queue->dev_tracker, GFP_KERNEL);
1974
1975 kobj->kset = dev->queues_kset;
1976 error = kobject_init_and_add(kobj, &netdev_queue_ktype, NULL,
1977 "tx-%u", index);
1978 if (error)
1979 goto err;
1980
1981 queue->groups = netdev_queue_default_groups;
1982 error = sysfs_create_groups(kobj, queue->groups);
1983 if (error)
1984 goto err;
1985
1986 if (netdev_uses_bql(dev)) {
1987 error = sysfs_create_group(kobj, &dql_group);
1988 if (error)
1989 goto err_default_groups;
1990 }
1991
1992 kobject_uevent(kobj, KOBJ_ADD);
1993 return 0;
1994
1995err_default_groups:
1996 sysfs_remove_groups(kobj, queue->groups);
1997err:
1998 kobject_put(kobj);
1999 return error;
2000}
2001
2002static int tx_queue_change_owner(struct net_device *ndev, int index,
2003 kuid_t kuid, kgid_t kgid)
2004{
2005 struct netdev_queue *queue = ndev->_tx + index;
2006 struct kobject *kobj = &queue->kobj;
2007 int error;
2008
2009 error = sysfs_change_owner(kobj, kuid, kgid);
2010 if (error)
2011 return error;
2012
2013 if (netdev_uses_bql(ndev))
2014 error = sysfs_group_change_owner(kobj, &dql_group, kuid, kgid);
2015
2016 return error;
2017}
2018#endif /* CONFIG_SYSFS */
2019
2020int
2021netdev_queue_update_kobjects(struct net_device *dev, int old_num, int new_num)
2022{
2023#ifdef CONFIG_SYSFS
2024 int i;
2025 int error = 0;
2026
2027 /* Tx queue kobjects are allowed to be updated when a device is being
2028 * unregistered, but solely to remove queues from qdiscs. Any path
2029 * adding queues should be fixed.
2030 */
2031 WARN(dev->reg_state == NETREG_UNREGISTERING && new_num > old_num,
2032 "New queues can't be registered after device unregistration.");
2033
2034 for (i = old_num; i < new_num; i++) {
2035 error = netdev_queue_add_kobject(dev, i);
2036 if (error) {
2037 new_num = old_num;
2038 break;
2039 }
2040 }
2041
2042 while (--i >= new_num) {
2043 struct netdev_queue *queue = dev->_tx + i;
2044
2045 if (!refcount_read(&dev_net(dev)->ns.count))
2046 queue->kobj.uevent_suppress = 1;
2047
2048 if (netdev_uses_bql(dev))
2049 sysfs_remove_group(&queue->kobj, &dql_group);
2050
2051 sysfs_remove_groups(&queue->kobj, queue->groups);
2052 kobject_put(&queue->kobj);
2053 }
2054
2055 return error;
2056#else
2057 return 0;
2058#endif /* CONFIG_SYSFS */
2059}
2060
2061static int net_tx_queue_change_owner(struct net_device *dev, int num,
2062 kuid_t kuid, kgid_t kgid)
2063{
2064#ifdef CONFIG_SYSFS
2065 int error = 0;
2066 int i;
2067
2068 for (i = 0; i < num; i++) {
2069 error = tx_queue_change_owner(dev, i, kuid, kgid);
2070 if (error)
2071 break;
2072 }
2073
2074 return error;
2075#else
2076 return 0;
2077#endif /* CONFIG_SYSFS */
2078}
2079
2080static int register_queue_kobjects(struct net_device *dev)
2081{
2082 int error = 0, txq = 0, rxq = 0, real_rx = 0, real_tx = 0;
2083
2084#ifdef CONFIG_SYSFS
2085 dev->queues_kset = kset_create_and_add("queues",
2086 NULL, &dev->dev.kobj);
2087 if (!dev->queues_kset)
2088 return -ENOMEM;
2089 real_rx = dev->real_num_rx_queues;
2090#endif
2091 real_tx = dev->real_num_tx_queues;
2092
2093 error = net_rx_queue_update_kobjects(dev, 0, real_rx);
2094 if (error)
2095 goto error;
2096 rxq = real_rx;
2097
2098 error = netdev_queue_update_kobjects(dev, 0, real_tx);
2099 if (error)
2100 goto error;
2101 txq = real_tx;
2102
2103 return 0;
2104
2105error:
2106 netdev_queue_update_kobjects(dev, txq, 0);
2107 net_rx_queue_update_kobjects(dev, rxq, 0);
2108#ifdef CONFIG_SYSFS
2109 kset_unregister(dev->queues_kset);
2110#endif
2111 return error;
2112}
2113
2114static int queue_change_owner(struct net_device *ndev, kuid_t kuid, kgid_t kgid)
2115{
2116 int error = 0, real_rx = 0, real_tx = 0;
2117
2118#ifdef CONFIG_SYSFS
2119 if (ndev->queues_kset) {
2120 error = sysfs_change_owner(&ndev->queues_kset->kobj, kuid, kgid);
2121 if (error)
2122 return error;
2123 }
2124 real_rx = ndev->real_num_rx_queues;
2125#endif
2126 real_tx = ndev->real_num_tx_queues;
2127
2128 error = net_rx_queue_change_owner(ndev, real_rx, kuid, kgid);
2129 if (error)
2130 return error;
2131
2132 error = net_tx_queue_change_owner(ndev, real_tx, kuid, kgid);
2133 if (error)
2134 return error;
2135
2136 return 0;
2137}
2138
2139static void remove_queue_kobjects(struct net_device *dev)
2140{
2141 int real_rx = 0, real_tx = 0;
2142
2143#ifdef CONFIG_SYSFS
2144 real_rx = dev->real_num_rx_queues;
2145#endif
2146 real_tx = dev->real_num_tx_queues;
2147
2148 net_rx_queue_update_kobjects(dev, real_rx, 0);
2149 netdev_queue_update_kobjects(dev, real_tx, 0);
2150
2151 netdev_lock_ops(dev);
2152 dev->real_num_rx_queues = 0;
2153 dev->real_num_tx_queues = 0;
2154 netdev_unlock_ops(dev);
2155#ifdef CONFIG_SYSFS
2156 kset_unregister(dev->queues_kset);
2157#endif
2158}
2159
2160static bool net_current_may_mount(void)
2161{
2162 struct net *net = current->nsproxy->net_ns;
2163
2164 return ns_capable(net->user_ns, CAP_SYS_ADMIN);
2165}
2166
2167static void *net_grab_current_ns(void)
2168{
2169 struct net *ns = current->nsproxy->net_ns;
2170#ifdef CONFIG_NET_NS
2171 if (ns)
2172 refcount_inc(&ns->passive);
2173#endif
2174 return ns;
2175}
2176
2177static const void *net_initial_ns(void)
2178{
2179 return &init_net;
2180}
2181
2182static const void *net_netlink_ns(struct sock *sk)
2183{
2184 return sock_net(sk);
2185}
2186
2187const struct kobj_ns_type_operations net_ns_type_operations = {
2188 .type = KOBJ_NS_TYPE_NET,
2189 .current_may_mount = net_current_may_mount,
2190 .grab_current_ns = net_grab_current_ns,
2191 .netlink_ns = net_netlink_ns,
2192 .initial_ns = net_initial_ns,
2193 .drop_ns = net_drop_ns,
2194};
2195EXPORT_SYMBOL_GPL(net_ns_type_operations);
2196
2197static int netdev_uevent(const struct device *d, struct kobj_uevent_env *env)
2198{
2199 const struct net_device *dev = to_net_dev(d);
2200 int retval;
2201
2202 /* pass interface to uevent. */
2203 retval = add_uevent_var(env, "INTERFACE=%s", dev->name);
2204 if (retval)
2205 goto exit;
2206
2207 /* pass ifindex to uevent.
2208 * ifindex is useful as it won't change (interface name may change)
2209 * and is what RtNetlink uses natively.
2210 */
2211 retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex);
2212
2213exit:
2214 return retval;
2215}
2216
2217/*
2218 * netdev_release -- destroy and free a dead device.
2219 * Called when last reference to device kobject is gone.
2220 */
2221static void netdev_release(struct device *d)
2222{
2223 struct net_device *dev = to_net_dev(d);
2224
2225 BUG_ON(dev->reg_state != NETREG_RELEASED);
2226
2227 /* no need to wait for rcu grace period:
2228 * device is dead and about to be freed.
2229 */
2230 kfree(rcu_access_pointer(dev->ifalias));
2231 kvfree(dev);
2232}
2233
2234static const void *net_namespace(const struct device *d)
2235{
2236 const struct net_device *dev = to_net_dev(d);
2237
2238 return dev_net(dev);
2239}
2240
2241static void net_get_ownership(const struct device *d, kuid_t *uid, kgid_t *gid)
2242{
2243 const struct net_device *dev = to_net_dev(d);
2244 const struct net *net = dev_net(dev);
2245
2246 net_ns_get_ownership(net, uid, gid);
2247}
2248
2249static const struct class net_class = {
2250 .name = "net",
2251 .dev_release = netdev_release,
2252 .dev_groups = net_class_groups,
2253 .dev_uevent = netdev_uevent,
2254 .ns_type = &net_ns_type_operations,
2255 .namespace = net_namespace,
2256 .get_ownership = net_get_ownership,
2257};
2258
2259#ifdef CONFIG_OF
2260static int of_dev_node_match(struct device *dev, const void *data)
2261{
2262 for (; dev; dev = dev->parent) {
2263 if (dev->of_node == data)
2264 return 1;
2265 }
2266
2267 return 0;
2268}
2269
2270/*
2271 * of_find_net_device_by_node - lookup the net device for the device node
2272 * @np: OF device node
2273 *
2274 * Looks up the net_device structure corresponding with the device node.
2275 * If successful, returns a pointer to the net_device with the embedded
2276 * struct device refcount incremented by one, or NULL on failure. The
2277 * refcount must be dropped when done with the net_device.
2278 */
2279struct net_device *of_find_net_device_by_node(struct device_node *np)
2280{
2281 struct device *dev;
2282
2283 dev = class_find_device(&net_class, NULL, np, of_dev_node_match);
2284 if (!dev)
2285 return NULL;
2286
2287 return to_net_dev(dev);
2288}
2289EXPORT_SYMBOL(of_find_net_device_by_node);
2290#endif
2291
2292/* Delete sysfs entries but hold kobject reference until after all
2293 * netdev references are gone.
2294 */
2295void netdev_unregister_kobject(struct net_device *ndev)
2296{
2297 struct device *dev = &ndev->dev;
2298
2299 if (!refcount_read(&dev_net(ndev)->ns.count))
2300 dev_set_uevent_suppress(dev, 1);
2301
2302 kobject_get(&dev->kobj);
2303
2304 remove_queue_kobjects(ndev);
2305
2306 pm_runtime_set_memalloc_noio(dev, false);
2307
2308 device_del(dev);
2309}
2310
2311/* Create sysfs entries for network device. */
2312int netdev_register_kobject(struct net_device *ndev)
2313{
2314 struct device *dev = &ndev->dev;
2315 const struct attribute_group **groups = ndev->sysfs_groups;
2316 int error = 0;
2317
2318 device_initialize(dev);
2319 dev->class = &net_class;
2320 dev->platform_data = ndev;
2321 dev->groups = groups;
2322
2323 dev_set_name(dev, "%s", ndev->name);
2324
2325#ifdef CONFIG_SYSFS
2326 /* Allow for a device specific group */
2327 if (*groups)
2328 groups++;
2329
2330 *groups++ = &netstat_group;
2331
2332 if (wireless_group_needed(ndev))
2333 *groups++ = &wireless_group;
2334#endif /* CONFIG_SYSFS */
2335
2336 error = device_add(dev);
2337 if (error)
2338 return error;
2339
2340 error = register_queue_kobjects(ndev);
2341 if (error) {
2342 device_del(dev);
2343 return error;
2344 }
2345
2346 pm_runtime_set_memalloc_noio(dev, true);
2347
2348 return error;
2349}
2350
2351/* Change owner for sysfs entries when moving network devices across network
2352 * namespaces owned by different user namespaces.
2353 */
2354int netdev_change_owner(struct net_device *ndev, const struct net *net_old,
2355 const struct net *net_new)
2356{
2357 kuid_t old_uid = GLOBAL_ROOT_UID, new_uid = GLOBAL_ROOT_UID;
2358 kgid_t old_gid = GLOBAL_ROOT_GID, new_gid = GLOBAL_ROOT_GID;
2359 struct device *dev = &ndev->dev;
2360 int error;
2361
2362 net_ns_get_ownership(net_old, &old_uid, &old_gid);
2363 net_ns_get_ownership(net_new, &new_uid, &new_gid);
2364
2365 /* The network namespace was changed but the owning user namespace is
2366 * identical so there's no need to change the owner of sysfs entries.
2367 */
2368 if (uid_eq(old_uid, new_uid) && gid_eq(old_gid, new_gid))
2369 return 0;
2370
2371 error = device_change_owner(dev, new_uid, new_gid);
2372 if (error)
2373 return error;
2374
2375 error = queue_change_owner(ndev, new_uid, new_gid);
2376 if (error)
2377 return error;
2378
2379 return 0;
2380}
2381
2382int netdev_class_create_file_ns(const struct class_attribute *class_attr,
2383 const void *ns)
2384{
2385 return class_create_file_ns(&net_class, class_attr, ns);
2386}
2387EXPORT_SYMBOL(netdev_class_create_file_ns);
2388
2389void netdev_class_remove_file_ns(const struct class_attribute *class_attr,
2390 const void *ns)
2391{
2392 class_remove_file_ns(&net_class, class_attr, ns);
2393}
2394EXPORT_SYMBOL(netdev_class_remove_file_ns);
2395
2396int __init netdev_kobject_init(void)
2397{
2398 kobj_ns_type_register(&net_ns_type_operations);
2399 return class_register(&net_class);
2400}
Linux 6.x block layer and io_uring tree(s)