1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * net-sysfs.c - network device class and attributes
5 * Copyright (c) 2003 Stephen Hemminger <shemminger@osdl.org>
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/nsproxy.h>
16 #include <net/net_namespace.h>
17 #include <linux/rtnetlink.h>
18 #include <linux/vmalloc.h>
19 #include <linux/export.h>
20 #include <linux/jiffies.h>
21 #include <linux/pm_runtime.h>
23 #include <linux/of_net.h>
24 #include <linux/cpu.h>
26 #include "net-sysfs.h"
29 static const char fmt_hex
[] = "%#x\n";
30 static const char fmt_dec
[] = "%d\n";
31 static const char fmt_ulong
[] = "%lu\n";
32 static const char fmt_u64
[] = "%llu\n";
34 static inline int dev_isalive(const struct net_device
*dev
)
36 return dev
->reg_state
<= NETREG_REGISTERED
;
39 /* use same locking rules as GIF* ioctl's */
40 static ssize_t
netdev_show(const struct device
*dev
,
41 struct device_attribute
*attr
, char *buf
,
42 ssize_t (*format
)(const struct net_device
*, char *))
44 struct net_device
*ndev
= to_net_dev(dev
);
45 ssize_t ret
= -EINVAL
;
47 read_lock(&dev_base_lock
);
48 if (dev_isalive(ndev
))
49 ret
= (*format
)(ndev
, buf
);
50 read_unlock(&dev_base_lock
);
55 /* generate a show function for simple field */
56 #define NETDEVICE_SHOW(field, format_string) \
57 static ssize_t format_##field(const struct net_device *dev, char *buf) \
59 return sprintf(buf, format_string, dev->field); \
61 static ssize_t field##_show(struct device *dev, \
62 struct device_attribute *attr, char *buf) \
64 return netdev_show(dev, attr, buf, format_##field); \
67 #define NETDEVICE_SHOW_RO(field, format_string) \
68 NETDEVICE_SHOW(field, format_string); \
69 static DEVICE_ATTR_RO(field)
71 #define NETDEVICE_SHOW_RW(field, format_string) \
72 NETDEVICE_SHOW(field, format_string); \
73 static DEVICE_ATTR_RW(field)
75 /* use same locking and permission rules as SIF* ioctl's */
76 static ssize_t
netdev_store(struct device
*dev
, struct device_attribute
*attr
,
77 const char *buf
, size_t len
,
78 int (*set
)(struct net_device
*, unsigned long))
80 struct net_device
*netdev
= to_net_dev(dev
);
81 struct net
*net
= dev_net(netdev
);
85 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
88 ret
= kstrtoul(buf
, 0, &new);
93 return restart_syscall();
95 if (dev_isalive(netdev
)) {
96 ret
= (*set
)(netdev
, new);
105 NETDEVICE_SHOW_RO(dev_id
, fmt_hex
);
106 NETDEVICE_SHOW_RO(dev_port
, fmt_dec
);
107 NETDEVICE_SHOW_RO(addr_assign_type
, fmt_dec
);
108 NETDEVICE_SHOW_RO(addr_len
, fmt_dec
);
109 NETDEVICE_SHOW_RO(ifindex
, fmt_dec
);
110 NETDEVICE_SHOW_RO(type
, fmt_dec
);
111 NETDEVICE_SHOW_RO(link_mode
, fmt_dec
);
113 static ssize_t
iflink_show(struct device
*dev
, struct device_attribute
*attr
,
116 struct net_device
*ndev
= to_net_dev(dev
);
118 return sprintf(buf
, fmt_dec
, dev_get_iflink(ndev
));
120 static DEVICE_ATTR_RO(iflink
);
122 static ssize_t
format_name_assign_type(const struct net_device
*dev
, char *buf
)
124 return sprintf(buf
, fmt_dec
, dev
->name_assign_type
);
127 static ssize_t
name_assign_type_show(struct device
*dev
,
128 struct device_attribute
*attr
,
131 struct net_device
*ndev
= to_net_dev(dev
);
132 ssize_t ret
= -EINVAL
;
134 if (ndev
->name_assign_type
!= NET_NAME_UNKNOWN
)
135 ret
= netdev_show(dev
, attr
, buf
, format_name_assign_type
);
139 static DEVICE_ATTR_RO(name_assign_type
);
141 /* use same locking rules as GIFHWADDR ioctl's */
142 static ssize_t
address_show(struct device
*dev
, struct device_attribute
*attr
,
145 struct net_device
*ndev
= to_net_dev(dev
);
146 ssize_t ret
= -EINVAL
;
148 read_lock(&dev_base_lock
);
149 if (dev_isalive(ndev
))
150 ret
= sysfs_format_mac(buf
, ndev
->dev_addr
, ndev
->addr_len
);
151 read_unlock(&dev_base_lock
);
154 static DEVICE_ATTR_RO(address
);
156 static ssize_t
broadcast_show(struct device
*dev
,
157 struct device_attribute
*attr
, char *buf
)
159 struct net_device
*ndev
= to_net_dev(dev
);
161 if (dev_isalive(ndev
))
162 return sysfs_format_mac(buf
, ndev
->broadcast
, ndev
->addr_len
);
165 static DEVICE_ATTR_RO(broadcast
);
167 static int change_carrier(struct net_device
*dev
, unsigned long new_carrier
)
169 if (!netif_running(dev
))
171 return dev_change_carrier(dev
, (bool)new_carrier
);
174 static ssize_t
carrier_store(struct device
*dev
, struct device_attribute
*attr
,
175 const char *buf
, size_t len
)
177 return netdev_store(dev
, attr
, buf
, len
, change_carrier
);
180 static ssize_t
carrier_show(struct device
*dev
,
181 struct device_attribute
*attr
, char *buf
)
183 struct net_device
*netdev
= to_net_dev(dev
);
185 if (netif_running(netdev
))
186 return sprintf(buf
, fmt_dec
, !!netif_carrier_ok(netdev
));
190 static DEVICE_ATTR_RW(carrier
);
192 static ssize_t
speed_show(struct device
*dev
,
193 struct device_attribute
*attr
, char *buf
)
195 struct net_device
*netdev
= to_net_dev(dev
);
199 return restart_syscall();
201 if (netif_running(netdev
)) {
202 struct ethtool_link_ksettings cmd
;
204 if (!__ethtool_get_link_ksettings(netdev
, &cmd
))
205 ret
= sprintf(buf
, fmt_dec
, cmd
.base
.speed
);
210 static DEVICE_ATTR_RO(speed
);
212 static ssize_t
duplex_show(struct device
*dev
,
213 struct device_attribute
*attr
, char *buf
)
215 struct net_device
*netdev
= to_net_dev(dev
);
219 return restart_syscall();
221 if (netif_running(netdev
)) {
222 struct ethtool_link_ksettings cmd
;
224 if (!__ethtool_get_link_ksettings(netdev
, &cmd
)) {
227 switch (cmd
.base
.duplex
) {
238 ret
= sprintf(buf
, "%s\n", duplex
);
244 static DEVICE_ATTR_RO(duplex
);
246 static ssize_t
dormant_show(struct device
*dev
,
247 struct device_attribute
*attr
, char *buf
)
249 struct net_device
*netdev
= to_net_dev(dev
);
251 if (netif_running(netdev
))
252 return sprintf(buf
, fmt_dec
, !!netif_dormant(netdev
));
256 static DEVICE_ATTR_RO(dormant
);
258 static const char *const operstates
[] = {
260 "notpresent", /* currently unused */
263 "testing", /* currently unused */
268 static ssize_t
operstate_show(struct device
*dev
,
269 struct device_attribute
*attr
, char *buf
)
271 const struct net_device
*netdev
= to_net_dev(dev
);
272 unsigned char operstate
;
274 read_lock(&dev_base_lock
);
275 operstate
= netdev
->operstate
;
276 if (!netif_running(netdev
))
277 operstate
= IF_OPER_DOWN
;
278 read_unlock(&dev_base_lock
);
280 if (operstate
>= ARRAY_SIZE(operstates
))
281 return -EINVAL
; /* should not happen */
283 return sprintf(buf
, "%s\n", operstates
[operstate
]);
285 static DEVICE_ATTR_RO(operstate
);
287 static ssize_t
carrier_changes_show(struct device
*dev
,
288 struct device_attribute
*attr
,
291 struct net_device
*netdev
= to_net_dev(dev
);
293 return sprintf(buf
, fmt_dec
,
294 atomic_read(&netdev
->carrier_up_count
) +
295 atomic_read(&netdev
->carrier_down_count
));
297 static DEVICE_ATTR_RO(carrier_changes
);
299 static ssize_t
carrier_up_count_show(struct device
*dev
,
300 struct device_attribute
*attr
,
303 struct net_device
*netdev
= to_net_dev(dev
);
305 return sprintf(buf
, fmt_dec
, atomic_read(&netdev
->carrier_up_count
));
307 static DEVICE_ATTR_RO(carrier_up_count
);
309 static ssize_t
carrier_down_count_show(struct device
*dev
,
310 struct device_attribute
*attr
,
313 struct net_device
*netdev
= to_net_dev(dev
);
315 return sprintf(buf
, fmt_dec
, atomic_read(&netdev
->carrier_down_count
));
317 static DEVICE_ATTR_RO(carrier_down_count
);
319 /* read-write attributes */
321 static int change_mtu(struct net_device
*dev
, unsigned long new_mtu
)
323 return dev_set_mtu(dev
, (int)new_mtu
);
326 static ssize_t
mtu_store(struct device
*dev
, struct device_attribute
*attr
,
327 const char *buf
, size_t len
)
329 return netdev_store(dev
, attr
, buf
, len
, change_mtu
);
331 NETDEVICE_SHOW_RW(mtu
, fmt_dec
);
333 static int change_flags(struct net_device
*dev
, unsigned long new_flags
)
335 return dev_change_flags(dev
, (unsigned int)new_flags
, NULL
);
338 static ssize_t
flags_store(struct device
*dev
, struct device_attribute
*attr
,
339 const char *buf
, size_t len
)
341 return netdev_store(dev
, attr
, buf
, len
, change_flags
);
343 NETDEVICE_SHOW_RW(flags
, fmt_hex
);
345 static ssize_t
tx_queue_len_store(struct device
*dev
,
346 struct device_attribute
*attr
,
347 const char *buf
, size_t len
)
349 if (!capable(CAP_NET_ADMIN
))
352 return netdev_store(dev
, attr
, buf
, len
, dev_change_tx_queue_len
);
354 NETDEVICE_SHOW_RW(tx_queue_len
, fmt_dec
);
356 static int change_gro_flush_timeout(struct net_device
*dev
, unsigned long val
)
358 dev
->gro_flush_timeout
= val
;
362 static ssize_t
gro_flush_timeout_store(struct device
*dev
,
363 struct device_attribute
*attr
,
364 const char *buf
, size_t len
)
366 if (!capable(CAP_NET_ADMIN
))
369 return netdev_store(dev
, attr
, buf
, len
, change_gro_flush_timeout
);
371 NETDEVICE_SHOW_RW(gro_flush_timeout
, fmt_ulong
);
373 static ssize_t
ifalias_store(struct device
*dev
, struct device_attribute
*attr
,
374 const char *buf
, size_t len
)
376 struct net_device
*netdev
= to_net_dev(dev
);
377 struct net
*net
= dev_net(netdev
);
381 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
384 /* ignore trailing newline */
385 if (len
> 0 && buf
[len
- 1] == '\n')
389 return restart_syscall();
391 if (dev_isalive(netdev
)) {
392 ret
= dev_set_alias(netdev
, buf
, count
);
396 netdev_state_change(netdev
);
404 static ssize_t
ifalias_show(struct device
*dev
,
405 struct device_attribute
*attr
, char *buf
)
407 const struct net_device
*netdev
= to_net_dev(dev
);
411 ret
= dev_get_alias(netdev
, tmp
, sizeof(tmp
));
413 ret
= sprintf(buf
, "%s\n", tmp
);
416 static DEVICE_ATTR_RW(ifalias
);
418 static int change_group(struct net_device
*dev
, unsigned long new_group
)
420 dev_set_group(dev
, (int)new_group
);
424 static ssize_t
group_store(struct device
*dev
, struct device_attribute
*attr
,
425 const char *buf
, size_t len
)
427 return netdev_store(dev
, attr
, buf
, len
, change_group
);
429 NETDEVICE_SHOW(group
, fmt_dec
);
430 static DEVICE_ATTR(netdev_group
, 0644, group_show
, group_store
);
432 static int change_proto_down(struct net_device
*dev
, unsigned long proto_down
)
434 return dev_change_proto_down(dev
, (bool)proto_down
);
437 static ssize_t
proto_down_store(struct device
*dev
,
438 struct device_attribute
*attr
,
439 const char *buf
, size_t len
)
441 return netdev_store(dev
, attr
, buf
, len
, change_proto_down
);
443 NETDEVICE_SHOW_RW(proto_down
, fmt_dec
);
445 static ssize_t
phys_port_id_show(struct device
*dev
,
446 struct device_attribute
*attr
, char *buf
)
448 struct net_device
*netdev
= to_net_dev(dev
);
449 ssize_t ret
= -EINVAL
;
452 return restart_syscall();
454 if (dev_isalive(netdev
)) {
455 struct netdev_phys_item_id ppid
;
457 ret
= dev_get_phys_port_id(netdev
, &ppid
);
459 ret
= sprintf(buf
, "%*phN\n", ppid
.id_len
, ppid
.id
);
465 static DEVICE_ATTR_RO(phys_port_id
);
467 static ssize_t
phys_port_name_show(struct device
*dev
,
468 struct device_attribute
*attr
, char *buf
)
470 struct net_device
*netdev
= to_net_dev(dev
);
471 ssize_t ret
= -EINVAL
;
474 return restart_syscall();
476 if (dev_isalive(netdev
)) {
479 ret
= dev_get_phys_port_name(netdev
, name
, sizeof(name
));
481 ret
= sprintf(buf
, "%s\n", name
);
487 static DEVICE_ATTR_RO(phys_port_name
);
489 static ssize_t
phys_switch_id_show(struct device
*dev
,
490 struct device_attribute
*attr
, char *buf
)
492 struct net_device
*netdev
= to_net_dev(dev
);
493 ssize_t ret
= -EINVAL
;
496 return restart_syscall();
498 if (dev_isalive(netdev
)) {
499 struct netdev_phys_item_id ppid
= { };
501 ret
= dev_get_port_parent_id(netdev
, &ppid
, false);
503 ret
= sprintf(buf
, "%*phN\n", ppid
.id_len
, ppid
.id
);
509 static DEVICE_ATTR_RO(phys_switch_id
);
511 static struct attribute
*net_class_attrs
[] __ro_after_init
= {
512 &dev_attr_netdev_group
.attr
,
514 &dev_attr_dev_id
.attr
,
515 &dev_attr_dev_port
.attr
,
516 &dev_attr_iflink
.attr
,
517 &dev_attr_ifindex
.attr
,
518 &dev_attr_name_assign_type
.attr
,
519 &dev_attr_addr_assign_type
.attr
,
520 &dev_attr_addr_len
.attr
,
521 &dev_attr_link_mode
.attr
,
522 &dev_attr_address
.attr
,
523 &dev_attr_broadcast
.attr
,
524 &dev_attr_speed
.attr
,
525 &dev_attr_duplex
.attr
,
526 &dev_attr_dormant
.attr
,
527 &dev_attr_operstate
.attr
,
528 &dev_attr_carrier_changes
.attr
,
529 &dev_attr_ifalias
.attr
,
530 &dev_attr_carrier
.attr
,
532 &dev_attr_flags
.attr
,
533 &dev_attr_tx_queue_len
.attr
,
534 &dev_attr_gro_flush_timeout
.attr
,
535 &dev_attr_phys_port_id
.attr
,
536 &dev_attr_phys_port_name
.attr
,
537 &dev_attr_phys_switch_id
.attr
,
538 &dev_attr_proto_down
.attr
,
539 &dev_attr_carrier_up_count
.attr
,
540 &dev_attr_carrier_down_count
.attr
,
543 ATTRIBUTE_GROUPS(net_class
);
545 /* Show a given an attribute in the statistics group */
546 static ssize_t
netstat_show(const struct device
*d
,
547 struct device_attribute
*attr
, char *buf
,
548 unsigned long offset
)
550 struct net_device
*dev
= to_net_dev(d
);
551 ssize_t ret
= -EINVAL
;
553 WARN_ON(offset
> sizeof(struct rtnl_link_stats64
) ||
554 offset
% sizeof(u64
) != 0);
556 read_lock(&dev_base_lock
);
557 if (dev_isalive(dev
)) {
558 struct rtnl_link_stats64 temp
;
559 const struct rtnl_link_stats64
*stats
= dev_get_stats(dev
, &temp
);
561 ret
= sprintf(buf
, fmt_u64
, *(u64
*)(((u8
*)stats
) + offset
));
563 read_unlock(&dev_base_lock
);
567 /* generate a read-only statistics attribute */
568 #define NETSTAT_ENTRY(name) \
569 static ssize_t name##_show(struct device *d, \
570 struct device_attribute *attr, char *buf) \
572 return netstat_show(d, attr, buf, \
573 offsetof(struct rtnl_link_stats64, name)); \
575 static DEVICE_ATTR_RO(name)
577 NETSTAT_ENTRY(rx_packets
);
578 NETSTAT_ENTRY(tx_packets
);
579 NETSTAT_ENTRY(rx_bytes
);
580 NETSTAT_ENTRY(tx_bytes
);
581 NETSTAT_ENTRY(rx_errors
);
582 NETSTAT_ENTRY(tx_errors
);
583 NETSTAT_ENTRY(rx_dropped
);
584 NETSTAT_ENTRY(tx_dropped
);
585 NETSTAT_ENTRY(multicast
);
586 NETSTAT_ENTRY(collisions
);
587 NETSTAT_ENTRY(rx_length_errors
);
588 NETSTAT_ENTRY(rx_over_errors
);
589 NETSTAT_ENTRY(rx_crc_errors
);
590 NETSTAT_ENTRY(rx_frame_errors
);
591 NETSTAT_ENTRY(rx_fifo_errors
);
592 NETSTAT_ENTRY(rx_missed_errors
);
593 NETSTAT_ENTRY(tx_aborted_errors
);
594 NETSTAT_ENTRY(tx_carrier_errors
);
595 NETSTAT_ENTRY(tx_fifo_errors
);
596 NETSTAT_ENTRY(tx_heartbeat_errors
);
597 NETSTAT_ENTRY(tx_window_errors
);
598 NETSTAT_ENTRY(rx_compressed
);
599 NETSTAT_ENTRY(tx_compressed
);
600 NETSTAT_ENTRY(rx_nohandler
);
602 static struct attribute
*netstat_attrs
[] __ro_after_init
= {
603 &dev_attr_rx_packets
.attr
,
604 &dev_attr_tx_packets
.attr
,
605 &dev_attr_rx_bytes
.attr
,
606 &dev_attr_tx_bytes
.attr
,
607 &dev_attr_rx_errors
.attr
,
608 &dev_attr_tx_errors
.attr
,
609 &dev_attr_rx_dropped
.attr
,
610 &dev_attr_tx_dropped
.attr
,
611 &dev_attr_multicast
.attr
,
612 &dev_attr_collisions
.attr
,
613 &dev_attr_rx_length_errors
.attr
,
614 &dev_attr_rx_over_errors
.attr
,
615 &dev_attr_rx_crc_errors
.attr
,
616 &dev_attr_rx_frame_errors
.attr
,
617 &dev_attr_rx_fifo_errors
.attr
,
618 &dev_attr_rx_missed_errors
.attr
,
619 &dev_attr_tx_aborted_errors
.attr
,
620 &dev_attr_tx_carrier_errors
.attr
,
621 &dev_attr_tx_fifo_errors
.attr
,
622 &dev_attr_tx_heartbeat_errors
.attr
,
623 &dev_attr_tx_window_errors
.attr
,
624 &dev_attr_rx_compressed
.attr
,
625 &dev_attr_tx_compressed
.attr
,
626 &dev_attr_rx_nohandler
.attr
,
630 static const struct attribute_group netstat_group
= {
631 .name
= "statistics",
632 .attrs
= netstat_attrs
,
635 #if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211)
636 static struct attribute
*wireless_attrs
[] = {
640 static const struct attribute_group wireless_group
= {
642 .attrs
= wireless_attrs
,
646 #else /* CONFIG_SYSFS */
647 #define net_class_groups NULL
648 #endif /* CONFIG_SYSFS */
651 #define to_rx_queue_attr(_attr) \
652 container_of(_attr, struct rx_queue_attribute, attr)
654 #define to_rx_queue(obj) container_of(obj, struct netdev_rx_queue, kobj)
656 static ssize_t
rx_queue_attr_show(struct kobject
*kobj
, struct attribute
*attr
,
659 const struct rx_queue_attribute
*attribute
= to_rx_queue_attr(attr
);
660 struct netdev_rx_queue
*queue
= to_rx_queue(kobj
);
662 if (!attribute
->show
)
665 return attribute
->show(queue
, buf
);
668 static ssize_t
rx_queue_attr_store(struct kobject
*kobj
, struct attribute
*attr
,
669 const char *buf
, size_t count
)
671 const struct rx_queue_attribute
*attribute
= to_rx_queue_attr(attr
);
672 struct netdev_rx_queue
*queue
= to_rx_queue(kobj
);
674 if (!attribute
->store
)
677 return attribute
->store(queue
, buf
, count
);
680 static const struct sysfs_ops rx_queue_sysfs_ops
= {
681 .show
= rx_queue_attr_show
,
682 .store
= rx_queue_attr_store
,
686 static ssize_t
show_rps_map(struct netdev_rx_queue
*queue
, char *buf
)
692 if (!zalloc_cpumask_var(&mask
, GFP_KERNEL
))
696 map
= rcu_dereference(queue
->rps_map
);
698 for (i
= 0; i
< map
->len
; i
++)
699 cpumask_set_cpu(map
->cpus
[i
], mask
);
701 len
= snprintf(buf
, PAGE_SIZE
, "%*pb\n", cpumask_pr_args(mask
));
703 free_cpumask_var(mask
);
705 return len
< PAGE_SIZE
? len
: -EINVAL
;
708 static ssize_t
store_rps_map(struct netdev_rx_queue
*queue
,
709 const char *buf
, size_t len
)
711 struct rps_map
*old_map
, *map
;
714 static DEFINE_MUTEX(rps_map_mutex
);
716 if (!capable(CAP_NET_ADMIN
))
719 if (!alloc_cpumask_var(&mask
, GFP_KERNEL
))
722 err
= bitmap_parse(buf
, len
, cpumask_bits(mask
), nr_cpumask_bits
);
724 free_cpumask_var(mask
);
728 map
= kzalloc(max_t(unsigned int,
729 RPS_MAP_SIZE(cpumask_weight(mask
)), L1_CACHE_BYTES
),
732 free_cpumask_var(mask
);
737 for_each_cpu_and(cpu
, mask
, cpu_online_mask
)
738 map
->cpus
[i
++] = cpu
;
747 mutex_lock(&rps_map_mutex
);
748 old_map
= rcu_dereference_protected(queue
->rps_map
,
749 mutex_is_locked(&rps_map_mutex
));
750 rcu_assign_pointer(queue
->rps_map
, map
);
753 static_branch_inc(&rps_needed
);
755 static_branch_dec(&rps_needed
);
757 mutex_unlock(&rps_map_mutex
);
760 kfree_rcu(old_map
, rcu
);
762 free_cpumask_var(mask
);
766 static ssize_t
show_rps_dev_flow_table_cnt(struct netdev_rx_queue
*queue
,
769 struct rps_dev_flow_table
*flow_table
;
770 unsigned long val
= 0;
773 flow_table
= rcu_dereference(queue
->rps_flow_table
);
775 val
= (unsigned long)flow_table
->mask
+ 1;
778 return sprintf(buf
, "%lu\n", val
);
781 static void rps_dev_flow_table_release(struct rcu_head
*rcu
)
783 struct rps_dev_flow_table
*table
= container_of(rcu
,
784 struct rps_dev_flow_table
, rcu
);
788 static ssize_t
store_rps_dev_flow_table_cnt(struct netdev_rx_queue
*queue
,
789 const char *buf
, size_t len
)
791 unsigned long mask
, count
;
792 struct rps_dev_flow_table
*table
, *old_table
;
793 static DEFINE_SPINLOCK(rps_dev_flow_lock
);
796 if (!capable(CAP_NET_ADMIN
))
799 rc
= kstrtoul(buf
, 0, &count
);
805 /* mask = roundup_pow_of_two(count) - 1;
806 * without overflows...
808 while ((mask
| (mask
>> 1)) != mask
)
810 /* On 64 bit arches, must check mask fits in table->mask (u32),
811 * and on 32bit arches, must check
812 * RPS_DEV_FLOW_TABLE_SIZE(mask + 1) doesn't overflow.
814 #if BITS_PER_LONG > 32
815 if (mask
> (unsigned long)(u32
)mask
)
818 if (mask
> (ULONG_MAX
- RPS_DEV_FLOW_TABLE_SIZE(1))
819 / sizeof(struct rps_dev_flow
)) {
820 /* Enforce a limit to prevent overflow */
824 table
= vmalloc(RPS_DEV_FLOW_TABLE_SIZE(mask
+ 1));
829 for (count
= 0; count
<= mask
; count
++)
830 table
->flows
[count
].cpu
= RPS_NO_CPU
;
835 spin_lock(&rps_dev_flow_lock
);
836 old_table
= rcu_dereference_protected(queue
->rps_flow_table
,
837 lockdep_is_held(&rps_dev_flow_lock
));
838 rcu_assign_pointer(queue
->rps_flow_table
, table
);
839 spin_unlock(&rps_dev_flow_lock
);
842 call_rcu(&old_table
->rcu
, rps_dev_flow_table_release
);
847 static struct rx_queue_attribute rps_cpus_attribute __ro_after_init
848 = __ATTR(rps_cpus
, 0644, show_rps_map
, store_rps_map
);
850 static struct rx_queue_attribute rps_dev_flow_table_cnt_attribute __ro_after_init
851 = __ATTR(rps_flow_cnt
, 0644,
852 show_rps_dev_flow_table_cnt
, store_rps_dev_flow_table_cnt
);
853 #endif /* CONFIG_RPS */
855 static struct attribute
*rx_queue_default_attrs
[] __ro_after_init
= {
857 &rps_cpus_attribute
.attr
,
858 &rps_dev_flow_table_cnt_attribute
.attr
,
862 ATTRIBUTE_GROUPS(rx_queue_default
);
864 static void rx_queue_release(struct kobject
*kobj
)
866 struct netdev_rx_queue
*queue
= to_rx_queue(kobj
);
869 struct rps_dev_flow_table
*flow_table
;
871 map
= rcu_dereference_protected(queue
->rps_map
, 1);
873 RCU_INIT_POINTER(queue
->rps_map
, NULL
);
877 flow_table
= rcu_dereference_protected(queue
->rps_flow_table
, 1);
879 RCU_INIT_POINTER(queue
->rps_flow_table
, NULL
);
880 call_rcu(&flow_table
->rcu
, rps_dev_flow_table_release
);
884 memset(kobj
, 0, sizeof(*kobj
));
888 static const void *rx_queue_namespace(struct kobject
*kobj
)
890 struct netdev_rx_queue
*queue
= to_rx_queue(kobj
);
891 struct device
*dev
= &queue
->dev
->dev
;
892 const void *ns
= NULL
;
894 if (dev
->class && dev
->class->ns_type
)
895 ns
= dev
->class->namespace(dev
);
900 static void rx_queue_get_ownership(struct kobject
*kobj
,
901 kuid_t
*uid
, kgid_t
*gid
)
903 const struct net
*net
= rx_queue_namespace(kobj
);
905 net_ns_get_ownership(net
, uid
, gid
);
908 static struct kobj_type rx_queue_ktype __ro_after_init
= {
909 .sysfs_ops
= &rx_queue_sysfs_ops
,
910 .release
= rx_queue_release
,
911 .default_groups
= rx_queue_default_groups
,
912 .namespace = rx_queue_namespace
,
913 .get_ownership
= rx_queue_get_ownership
,
916 static int rx_queue_add_kobject(struct net_device
*dev
, int index
)
918 struct netdev_rx_queue
*queue
= dev
->_rx
+ index
;
919 struct kobject
*kobj
= &queue
->kobj
;
922 /* Kobject_put later will trigger rx_queue_release call which
923 * decreases dev refcount: Take that reference here
925 dev_hold(queue
->dev
);
927 kobj
->kset
= dev
->queues_kset
;
928 error
= kobject_init_and_add(kobj
, &rx_queue_ktype
, NULL
,
933 if (dev
->sysfs_rx_queue_group
) {
934 error
= sysfs_create_group(kobj
, dev
->sysfs_rx_queue_group
);
939 kobject_uevent(kobj
, KOBJ_ADD
);
948 static int rx_queue_change_owner(struct net_device
*dev
, int index
, kuid_t kuid
,
951 struct netdev_rx_queue
*queue
= dev
->_rx
+ index
;
952 struct kobject
*kobj
= &queue
->kobj
;
955 error
= sysfs_change_owner(kobj
, kuid
, kgid
);
959 if (dev
->sysfs_rx_queue_group
)
960 error
= sysfs_group_change_owner(
961 kobj
, dev
->sysfs_rx_queue_group
, kuid
, kgid
);
965 #endif /* CONFIG_SYSFS */
968 net_rx_queue_update_kobjects(struct net_device
*dev
, int old_num
, int new_num
)
975 if (!dev
->sysfs_rx_queue_group
)
978 for (i
= old_num
; i
< new_num
; i
++) {
979 error
= rx_queue_add_kobject(dev
, i
);
986 while (--i
>= new_num
) {
987 struct kobject
*kobj
= &dev
->_rx
[i
].kobj
;
989 if (!refcount_read(&dev_net(dev
)->count
))
990 kobj
->uevent_suppress
= 1;
991 if (dev
->sysfs_rx_queue_group
)
992 sysfs_remove_group(kobj
, dev
->sysfs_rx_queue_group
);
1002 static int net_rx_queue_change_owner(struct net_device
*dev
, int num
,
1003 kuid_t kuid
, kgid_t kgid
)
1010 if (!dev
->sysfs_rx_queue_group
)
1013 for (i
= 0; i
< num
; i
++) {
1014 error
= rx_queue_change_owner(dev
, i
, kuid
, kgid
);
1027 * netdev_queue sysfs structures and functions.
1029 struct netdev_queue_attribute
{
1030 struct attribute attr
;
1031 ssize_t (*show
)(struct netdev_queue
*queue
, char *buf
);
1032 ssize_t (*store
)(struct netdev_queue
*queue
,
1033 const char *buf
, size_t len
);
1035 #define to_netdev_queue_attr(_attr) \
1036 container_of(_attr, struct netdev_queue_attribute, attr)
1038 #define to_netdev_queue(obj) container_of(obj, struct netdev_queue, kobj)
1040 static ssize_t
netdev_queue_attr_show(struct kobject
*kobj
,
1041 struct attribute
*attr
, char *buf
)
1043 const struct netdev_queue_attribute
*attribute
1044 = to_netdev_queue_attr(attr
);
1045 struct netdev_queue
*queue
= to_netdev_queue(kobj
);
1047 if (!attribute
->show
)
1050 return attribute
->show(queue
, buf
);
1053 static ssize_t
netdev_queue_attr_store(struct kobject
*kobj
,
1054 struct attribute
*attr
,
1055 const char *buf
, size_t count
)
1057 const struct netdev_queue_attribute
*attribute
1058 = to_netdev_queue_attr(attr
);
1059 struct netdev_queue
*queue
= to_netdev_queue(kobj
);
1061 if (!attribute
->store
)
1064 return attribute
->store(queue
, buf
, count
);
1067 static const struct sysfs_ops netdev_queue_sysfs_ops
= {
1068 .show
= netdev_queue_attr_show
,
1069 .store
= netdev_queue_attr_store
,
1072 static ssize_t
tx_timeout_show(struct netdev_queue
*queue
, char *buf
)
1074 unsigned long trans_timeout
;
1076 spin_lock_irq(&queue
->_xmit_lock
);
1077 trans_timeout
= queue
->trans_timeout
;
1078 spin_unlock_irq(&queue
->_xmit_lock
);
1080 return sprintf(buf
, "%lu", trans_timeout
);
1083 static unsigned int get_netdev_queue_index(struct netdev_queue
*queue
)
1085 struct net_device
*dev
= queue
->dev
;
1088 i
= queue
- dev
->_tx
;
1089 BUG_ON(i
>= dev
->num_tx_queues
);
1094 static ssize_t
traffic_class_show(struct netdev_queue
*queue
,
1097 struct net_device
*dev
= queue
->dev
;
1101 if (!netif_is_multiqueue(dev
))
1104 index
= get_netdev_queue_index(queue
);
1106 /* If queue belongs to subordinate dev use its TC mapping */
1107 dev
= netdev_get_tx_queue(dev
, index
)->sb_dev
? : dev
;
1109 tc
= netdev_txq_to_tc(dev
, index
);
1113 /* We can report the traffic class one of two ways:
1114 * Subordinate device traffic classes are reported with the traffic
1115 * class first, and then the subordinate class so for example TC0 on
1116 * subordinate device 2 will be reported as "0-2". If the queue
1117 * belongs to the root device it will be reported with just the
1118 * traffic class, so just "0" for TC 0 for example.
1120 return dev
->num_tc
< 0 ? sprintf(buf
, "%u%d\n", tc
, dev
->num_tc
) :
1121 sprintf(buf
, "%u\n", tc
);
1125 static ssize_t
tx_maxrate_show(struct netdev_queue
*queue
,
1128 return sprintf(buf
, "%lu\n", queue
->tx_maxrate
);
1131 static ssize_t
tx_maxrate_store(struct netdev_queue
*queue
,
1132 const char *buf
, size_t len
)
1134 struct net_device
*dev
= queue
->dev
;
1135 int err
, index
= get_netdev_queue_index(queue
);
1138 if (!capable(CAP_NET_ADMIN
))
1141 err
= kstrtou32(buf
, 10, &rate
);
1145 if (!rtnl_trylock())
1146 return restart_syscall();
1149 if (dev
->netdev_ops
->ndo_set_tx_maxrate
)
1150 err
= dev
->netdev_ops
->ndo_set_tx_maxrate(dev
, index
, rate
);
1154 queue
->tx_maxrate
= rate
;
1160 static struct netdev_queue_attribute queue_tx_maxrate __ro_after_init
1161 = __ATTR_RW(tx_maxrate
);
1164 static struct netdev_queue_attribute queue_trans_timeout __ro_after_init
1165 = __ATTR_RO(tx_timeout
);
1167 static struct netdev_queue_attribute queue_traffic_class __ro_after_init
1168 = __ATTR_RO(traffic_class
);
1172 * Byte queue limits sysfs structures and functions.
1174 static ssize_t
bql_show(char *buf
, unsigned int value
)
1176 return sprintf(buf
, "%u\n", value
);
1179 static ssize_t
bql_set(const char *buf
, const size_t count
,
1180 unsigned int *pvalue
)
1185 if (!strcmp(buf
, "max") || !strcmp(buf
, "max\n")) {
1186 value
= DQL_MAX_LIMIT
;
1188 err
= kstrtouint(buf
, 10, &value
);
1191 if (value
> DQL_MAX_LIMIT
)
1200 static ssize_t
bql_show_hold_time(struct netdev_queue
*queue
,
1203 struct dql
*dql
= &queue
->dql
;
1205 return sprintf(buf
, "%u\n", jiffies_to_msecs(dql
->slack_hold_time
));
1208 static ssize_t
bql_set_hold_time(struct netdev_queue
*queue
,
1209 const char *buf
, size_t len
)
1211 struct dql
*dql
= &queue
->dql
;
1215 err
= kstrtouint(buf
, 10, &value
);
1219 dql
->slack_hold_time
= msecs_to_jiffies(value
);
1224 static struct netdev_queue_attribute bql_hold_time_attribute __ro_after_init
1225 = __ATTR(hold_time
, 0644,
1226 bql_show_hold_time
, bql_set_hold_time
);
1228 static ssize_t
bql_show_inflight(struct netdev_queue
*queue
,
1231 struct dql
*dql
= &queue
->dql
;
1233 return sprintf(buf
, "%u\n", dql
->num_queued
- dql
->num_completed
);
1236 static struct netdev_queue_attribute bql_inflight_attribute __ro_after_init
=
1237 __ATTR(inflight
, 0444, bql_show_inflight
, NULL
);
1239 #define BQL_ATTR(NAME, FIELD) \
1240 static ssize_t bql_show_ ## NAME(struct netdev_queue *queue, \
1243 return bql_show(buf, queue->dql.FIELD); \
1246 static ssize_t bql_set_ ## NAME(struct netdev_queue *queue, \
1247 const char *buf, size_t len) \
1249 return bql_set(buf, len, &queue->dql.FIELD); \
1252 static struct netdev_queue_attribute bql_ ## NAME ## _attribute __ro_after_init \
1253 = __ATTR(NAME, 0644, \
1254 bql_show_ ## NAME, bql_set_ ## NAME)
1256 BQL_ATTR(limit
, limit
);
1257 BQL_ATTR(limit_max
, max_limit
);
1258 BQL_ATTR(limit_min
, min_limit
);
1260 static struct attribute
*dql_attrs
[] __ro_after_init
= {
1261 &bql_limit_attribute
.attr
,
1262 &bql_limit_max_attribute
.attr
,
1263 &bql_limit_min_attribute
.attr
,
1264 &bql_hold_time_attribute
.attr
,
1265 &bql_inflight_attribute
.attr
,
1269 static const struct attribute_group dql_group
= {
1270 .name
= "byte_queue_limits",
1273 #endif /* CONFIG_BQL */
1276 static ssize_t
xps_cpus_show(struct netdev_queue
*queue
,
1279 struct net_device
*dev
= queue
->dev
;
1280 int cpu
, len
, num_tc
= 1, tc
= 0;
1281 struct xps_dev_maps
*dev_maps
;
1283 unsigned long index
;
1285 if (!netif_is_multiqueue(dev
))
1288 index
= get_netdev_queue_index(queue
);
1291 /* Do not allow XPS on subordinate device directly */
1292 num_tc
= dev
->num_tc
;
1296 /* If queue belongs to subordinate dev use its map */
1297 dev
= netdev_get_tx_queue(dev
, index
)->sb_dev
? : dev
;
1299 tc
= netdev_txq_to_tc(dev
, index
);
1304 if (!zalloc_cpumask_var(&mask
, GFP_KERNEL
))
1308 dev_maps
= rcu_dereference(dev
->xps_cpus_map
);
1310 for_each_possible_cpu(cpu
) {
1311 int i
, tci
= cpu
* num_tc
+ tc
;
1312 struct xps_map
*map
;
1314 map
= rcu_dereference(dev_maps
->attr_map
[tci
]);
1318 for (i
= map
->len
; i
--;) {
1319 if (map
->queues
[i
] == index
) {
1320 cpumask_set_cpu(cpu
, mask
);
1328 len
= snprintf(buf
, PAGE_SIZE
, "%*pb\n", cpumask_pr_args(mask
));
1329 free_cpumask_var(mask
);
1330 return len
< PAGE_SIZE
? len
: -EINVAL
;
1333 static ssize_t
xps_cpus_store(struct netdev_queue
*queue
,
1334 const char *buf
, size_t len
)
1336 struct net_device
*dev
= queue
->dev
;
1337 unsigned long index
;
1341 if (!netif_is_multiqueue(dev
))
1344 if (!capable(CAP_NET_ADMIN
))
1347 if (!alloc_cpumask_var(&mask
, GFP_KERNEL
))
1350 index
= get_netdev_queue_index(queue
);
1352 err
= bitmap_parse(buf
, len
, cpumask_bits(mask
), nr_cpumask_bits
);
1354 free_cpumask_var(mask
);
1358 err
= netif_set_xps_queue(dev
, mask
, index
);
1360 free_cpumask_var(mask
);
1365 static struct netdev_queue_attribute xps_cpus_attribute __ro_after_init
1366 = __ATTR_RW(xps_cpus
);
1368 static ssize_t
xps_rxqs_show(struct netdev_queue
*queue
, char *buf
)
1370 struct net_device
*dev
= queue
->dev
;
1371 struct xps_dev_maps
*dev_maps
;
1372 unsigned long *mask
, index
;
1373 int j
, len
, num_tc
= 1, tc
= 0;
1375 index
= get_netdev_queue_index(queue
);
1378 num_tc
= dev
->num_tc
;
1379 tc
= netdev_txq_to_tc(dev
, index
);
1383 mask
= bitmap_zalloc(dev
->num_rx_queues
, GFP_KERNEL
);
1388 dev_maps
= rcu_dereference(dev
->xps_rxqs_map
);
1392 for (j
= -1; j
= netif_attrmask_next(j
, NULL
, dev
->num_rx_queues
),
1393 j
< dev
->num_rx_queues
;) {
1394 int i
, tci
= j
* num_tc
+ tc
;
1395 struct xps_map
*map
;
1397 map
= rcu_dereference(dev_maps
->attr_map
[tci
]);
1401 for (i
= map
->len
; i
--;) {
1402 if (map
->queues
[i
] == index
) {
1411 len
= bitmap_print_to_pagebuf(false, buf
, mask
, dev
->num_rx_queues
);
1414 return len
< PAGE_SIZE
? len
: -EINVAL
;
1417 static ssize_t
xps_rxqs_store(struct netdev_queue
*queue
, const char *buf
,
1420 struct net_device
*dev
= queue
->dev
;
1421 struct net
*net
= dev_net(dev
);
1422 unsigned long *mask
, index
;
1425 if (!ns_capable(net
->user_ns
, CAP_NET_ADMIN
))
1428 mask
= bitmap_zalloc(dev
->num_rx_queues
, GFP_KERNEL
);
1432 index
= get_netdev_queue_index(queue
);
1434 err
= bitmap_parse(buf
, len
, mask
, dev
->num_rx_queues
);
1441 err
= __netif_set_xps_queue(dev
, mask
, index
, true);
1448 static struct netdev_queue_attribute xps_rxqs_attribute __ro_after_init
1449 = __ATTR_RW(xps_rxqs
);
1450 #endif /* CONFIG_XPS */
1452 static struct attribute
*netdev_queue_default_attrs
[] __ro_after_init
= {
1453 &queue_trans_timeout
.attr
,
1454 &queue_traffic_class
.attr
,
1456 &xps_cpus_attribute
.attr
,
1457 &xps_rxqs_attribute
.attr
,
1458 &queue_tx_maxrate
.attr
,
1462 ATTRIBUTE_GROUPS(netdev_queue_default
);
1464 static void netdev_queue_release(struct kobject
*kobj
)
1466 struct netdev_queue
*queue
= to_netdev_queue(kobj
);
1468 memset(kobj
, 0, sizeof(*kobj
));
1469 dev_put(queue
->dev
);
1472 static const void *netdev_queue_namespace(struct kobject
*kobj
)
1474 struct netdev_queue
*queue
= to_netdev_queue(kobj
);
1475 struct device
*dev
= &queue
->dev
->dev
;
1476 const void *ns
= NULL
;
1478 if (dev
->class && dev
->class->ns_type
)
1479 ns
= dev
->class->namespace(dev
);
1484 static void netdev_queue_get_ownership(struct kobject
*kobj
,
1485 kuid_t
*uid
, kgid_t
*gid
)
1487 const struct net
*net
= netdev_queue_namespace(kobj
);
1489 net_ns_get_ownership(net
, uid
, gid
);
1492 static struct kobj_type netdev_queue_ktype __ro_after_init
= {
1493 .sysfs_ops
= &netdev_queue_sysfs_ops
,
1494 .release
= netdev_queue_release
,
1495 .default_groups
= netdev_queue_default_groups
,
1496 .namespace = netdev_queue_namespace
,
1497 .get_ownership
= netdev_queue_get_ownership
,
1500 static int netdev_queue_add_kobject(struct net_device
*dev
, int index
)
1502 struct netdev_queue
*queue
= dev
->_tx
+ index
;
1503 struct kobject
*kobj
= &queue
->kobj
;
1506 /* Kobject_put later will trigger netdev_queue_release call
1507 * which decreases dev refcount: Take that reference here
1509 dev_hold(queue
->dev
);
1511 kobj
->kset
= dev
->queues_kset
;
1512 error
= kobject_init_and_add(kobj
, &netdev_queue_ktype
, NULL
,
1518 error
= sysfs_create_group(kobj
, &dql_group
);
1523 kobject_uevent(kobj
, KOBJ_ADD
);
1531 static int tx_queue_change_owner(struct net_device
*ndev
, int index
,
1532 kuid_t kuid
, kgid_t kgid
)
1534 struct netdev_queue
*queue
= ndev
->_tx
+ index
;
1535 struct kobject
*kobj
= &queue
->kobj
;
1538 error
= sysfs_change_owner(kobj
, kuid
, kgid
);
1543 error
= sysfs_group_change_owner(kobj
, &dql_group
, kuid
, kgid
);
1547 #endif /* CONFIG_SYSFS */
1550 netdev_queue_update_kobjects(struct net_device
*dev
, int old_num
, int new_num
)
1556 for (i
= old_num
; i
< new_num
; i
++) {
1557 error
= netdev_queue_add_kobject(dev
, i
);
1564 while (--i
>= new_num
) {
1565 struct netdev_queue
*queue
= dev
->_tx
+ i
;
1567 if (!refcount_read(&dev_net(dev
)->count
))
1568 queue
->kobj
.uevent_suppress
= 1;
1570 sysfs_remove_group(&queue
->kobj
, &dql_group
);
1572 kobject_put(&queue
->kobj
);
1578 #endif /* CONFIG_SYSFS */
1581 static int net_tx_queue_change_owner(struct net_device
*dev
, int num
,
1582 kuid_t kuid
, kgid_t kgid
)
1588 for (i
= 0; i
< num
; i
++) {
1589 error
= tx_queue_change_owner(dev
, i
, kuid
, kgid
);
1597 #endif /* CONFIG_SYSFS */
1600 static int register_queue_kobjects(struct net_device
*dev
)
1602 int error
= 0, txq
= 0, rxq
= 0, real_rx
= 0, real_tx
= 0;
1605 dev
->queues_kset
= kset_create_and_add("queues",
1606 NULL
, &dev
->dev
.kobj
);
1607 if (!dev
->queues_kset
)
1609 real_rx
= dev
->real_num_rx_queues
;
1611 real_tx
= dev
->real_num_tx_queues
;
1613 error
= net_rx_queue_update_kobjects(dev
, 0, real_rx
);
1618 error
= netdev_queue_update_kobjects(dev
, 0, real_tx
);
1626 netdev_queue_update_kobjects(dev
, txq
, 0);
1627 net_rx_queue_update_kobjects(dev
, rxq
, 0);
1629 kset_unregister(dev
->queues_kset
);
1634 static int queue_change_owner(struct net_device
*ndev
, kuid_t kuid
, kgid_t kgid
)
1636 int error
= 0, real_rx
= 0, real_tx
= 0;
1639 if (ndev
->queues_kset
) {
1640 error
= sysfs_change_owner(&ndev
->queues_kset
->kobj
, kuid
, kgid
);
1644 real_rx
= ndev
->real_num_rx_queues
;
1646 real_tx
= ndev
->real_num_tx_queues
;
1648 error
= net_rx_queue_change_owner(ndev
, real_rx
, kuid
, kgid
);
1652 error
= net_tx_queue_change_owner(ndev
, real_tx
, kuid
, kgid
);
1659 static void remove_queue_kobjects(struct net_device
*dev
)
1661 int real_rx
= 0, real_tx
= 0;
1664 real_rx
= dev
->real_num_rx_queues
;
1666 real_tx
= dev
->real_num_tx_queues
;
1668 net_rx_queue_update_kobjects(dev
, real_rx
, 0);
1669 netdev_queue_update_kobjects(dev
, real_tx
, 0);
1671 kset_unregister(dev
->queues_kset
);
1675 static bool net_current_may_mount(void)
1677 struct net
*net
= current
->nsproxy
->net_ns
;
1679 return ns_capable(net
->user_ns
, CAP_SYS_ADMIN
);
1682 static void *net_grab_current_ns(void)
1684 struct net
*ns
= current
->nsproxy
->net_ns
;
1685 #ifdef CONFIG_NET_NS
1687 refcount_inc(&ns
->passive
);
1692 static const void *net_initial_ns(void)
1697 static const void *net_netlink_ns(struct sock
*sk
)
1699 return sock_net(sk
);
1702 const struct kobj_ns_type_operations net_ns_type_operations
= {
1703 .type
= KOBJ_NS_TYPE_NET
,
1704 .current_may_mount
= net_current_may_mount
,
1705 .grab_current_ns
= net_grab_current_ns
,
1706 .netlink_ns
= net_netlink_ns
,
1707 .initial_ns
= net_initial_ns
,
1708 .drop_ns
= net_drop_ns
,
1710 EXPORT_SYMBOL_GPL(net_ns_type_operations
);
1712 static int netdev_uevent(struct device
*d
, struct kobj_uevent_env
*env
)
1714 struct net_device
*dev
= to_net_dev(d
);
1717 /* pass interface to uevent. */
1718 retval
= add_uevent_var(env
, "INTERFACE=%s", dev
->name
);
1722 /* pass ifindex to uevent.
1723 * ifindex is useful as it won't change (interface name may change)
1724 * and is what RtNetlink uses natively.
1726 retval
= add_uevent_var(env
, "IFINDEX=%d", dev
->ifindex
);
1733 * netdev_release -- destroy and free a dead device.
1734 * Called when last reference to device kobject is gone.
1736 static void netdev_release(struct device
*d
)
1738 struct net_device
*dev
= to_net_dev(d
);
1740 BUG_ON(dev
->reg_state
!= NETREG_RELEASED
);
1742 /* no need to wait for rcu grace period:
1743 * device is dead and about to be freed.
1745 kfree(rcu_access_pointer(dev
->ifalias
));
1746 netdev_freemem(dev
);
1749 static const void *net_namespace(struct device
*d
)
1751 struct net_device
*dev
= to_net_dev(d
);
1753 return dev_net(dev
);
1756 static void net_get_ownership(struct device
*d
, kuid_t
*uid
, kgid_t
*gid
)
1758 struct net_device
*dev
= to_net_dev(d
);
1759 const struct net
*net
= dev_net(dev
);
1761 net_ns_get_ownership(net
, uid
, gid
);
1764 static struct class net_class __ro_after_init
= {
1766 .dev_release
= netdev_release
,
1767 .dev_groups
= net_class_groups
,
1768 .dev_uevent
= netdev_uevent
,
1769 .ns_type
= &net_ns_type_operations
,
1770 .namespace = net_namespace
,
1771 .get_ownership
= net_get_ownership
,
1774 #ifdef CONFIG_OF_NET
1775 static int of_dev_node_match(struct device
*dev
, const void *data
)
1780 ret
= dev
->parent
->of_node
== data
;
1782 return ret
== 0 ? dev
->of_node
== data
: ret
;
1786 * of_find_net_device_by_node - lookup the net device for the device node
1787 * @np: OF device node
1789 * Looks up the net_device structure corresponding with the device node.
1790 * If successful, returns a pointer to the net_device with the embedded
1791 * struct device refcount incremented by one, or NULL on failure. The
1792 * refcount must be dropped when done with the net_device.
1794 struct net_device
*of_find_net_device_by_node(struct device_node
*np
)
1798 dev
= class_find_device(&net_class
, NULL
, np
, of_dev_node_match
);
1802 return to_net_dev(dev
);
1804 EXPORT_SYMBOL(of_find_net_device_by_node
);
1807 /* Delete sysfs entries but hold kobject reference until after all
1808 * netdev references are gone.
1810 void netdev_unregister_kobject(struct net_device
*ndev
)
1812 struct device
*dev
= &ndev
->dev
;
1814 if (!refcount_read(&dev_net(ndev
)->count
))
1815 dev_set_uevent_suppress(dev
, 1);
1817 kobject_get(&dev
->kobj
);
1819 remove_queue_kobjects(ndev
);
1821 pm_runtime_set_memalloc_noio(dev
, false);
1826 /* Create sysfs entries for network device. */
1827 int netdev_register_kobject(struct net_device
*ndev
)
1829 struct device
*dev
= &ndev
->dev
;
1830 const struct attribute_group
**groups
= ndev
->sysfs_groups
;
1833 device_initialize(dev
);
1834 dev
->class = &net_class
;
1835 dev
->platform_data
= ndev
;
1836 dev
->groups
= groups
;
1838 dev_set_name(dev
, "%s", ndev
->name
);
1841 /* Allow for a device specific group */
1845 *groups
++ = &netstat_group
;
1847 #if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211)
1848 if (ndev
->ieee80211_ptr
)
1849 *groups
++ = &wireless_group
;
1850 #if IS_ENABLED(CONFIG_WIRELESS_EXT)
1851 else if (ndev
->wireless_handlers
)
1852 *groups
++ = &wireless_group
;
1855 #endif /* CONFIG_SYSFS */
1857 error
= device_add(dev
);
1861 error
= register_queue_kobjects(ndev
);
1867 pm_runtime_set_memalloc_noio(dev
, true);
1872 /* Change owner for sysfs entries when moving network devices across network
1873 * namespaces owned by different user namespaces.
1875 int netdev_change_owner(struct net_device
*ndev
, const struct net
*net_old
,
1876 const struct net
*net_new
)
1878 struct device
*dev
= &ndev
->dev
;
1879 kuid_t old_uid
, new_uid
;
1880 kgid_t old_gid
, new_gid
;
1883 net_ns_get_ownership(net_old
, &old_uid
, &old_gid
);
1884 net_ns_get_ownership(net_new
, &new_uid
, &new_gid
);
1886 /* The network namespace was changed but the owning user namespace is
1887 * identical so there's no need to change the owner of sysfs entries.
1889 if (uid_eq(old_uid
, new_uid
) && gid_eq(old_gid
, new_gid
))
1892 error
= device_change_owner(dev
, new_uid
, new_gid
);
1896 error
= queue_change_owner(ndev
, new_uid
, new_gid
);
1903 int netdev_class_create_file_ns(const struct class_attribute
*class_attr
,
1906 return class_create_file_ns(&net_class
, class_attr
, ns
);
1908 EXPORT_SYMBOL(netdev_class_create_file_ns
);
1910 void netdev_class_remove_file_ns(const struct class_attribute
*class_attr
,
1913 class_remove_file_ns(&net_class
, class_attr
, ns
);
1915 EXPORT_SYMBOL(netdev_class_remove_file_ns
);
1917 int __init
netdev_kobject_init(void)
1919 kobj_ns_type_register(&net_ns_type_operations
);
1920 return class_register(&net_class
);