2 * net-sysfs.c - network device class and attributes
4 * Copyright (c) 2003 Stephen Hemminger <shemminger@osdl.org>
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
12 #include <linux/capability.h>
13 #include <linux/kernel.h>
14 #include <linux/netdevice.h>
15 #include <linux/if_arp.h>
16 #include <linux/slab.h>
17 #include <linux/nsproxy.h>
19 #include <net/net_namespace.h>
20 #include <linux/rtnetlink.h>
21 #include <linux/wireless.h>
22 #include <linux/vmalloc.h>
25 #include "net-sysfs.h"
28 static const char fmt_hex
[] = "%#x\n";
29 static const char fmt_long_hex
[] = "%#lx\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
*net
= to_net_dev(dev
);
45 ssize_t ret
= -EINVAL
;
47 read_lock(&dev_base_lock
);
49 ret
= (*format
)(net
, 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 *net, char *buf) \
59 return sprintf(buf, format_string, net->field); \
61 static ssize_t show_##field(struct device *dev, \
62 struct device_attribute *attr, char *buf) \
64 return netdev_show(dev, attr, buf, format_##field); \
68 /* use same locking and permission rules as SIF* ioctl's */
69 static ssize_t
netdev_store(struct device
*dev
, struct device_attribute
*attr
,
70 const char *buf
, size_t len
,
71 int (*set
)(struct net_device
*, unsigned long))
73 struct net_device
*net
= to_net_dev(dev
);
78 if (!capable(CAP_NET_ADMIN
))
81 new = simple_strtoul(buf
, &endp
, 0);
86 return restart_syscall();
88 if (dev_isalive(net
)) {
89 if ((ret
= (*set
)(net
, new)) == 0)
97 NETDEVICE_SHOW(dev_id
, fmt_hex
);
98 NETDEVICE_SHOW(addr_assign_type
, fmt_dec
);
99 NETDEVICE_SHOW(addr_len
, fmt_dec
);
100 NETDEVICE_SHOW(iflink
, fmt_dec
);
101 NETDEVICE_SHOW(ifindex
, fmt_dec
);
102 NETDEVICE_SHOW(features
, fmt_long_hex
);
103 NETDEVICE_SHOW(type
, fmt_dec
);
104 NETDEVICE_SHOW(link_mode
, fmt_dec
);
106 /* use same locking rules as GIFHWADDR ioctl's */
107 static ssize_t
show_address(struct device
*dev
, struct device_attribute
*attr
,
110 struct net_device
*net
= to_net_dev(dev
);
111 ssize_t ret
= -EINVAL
;
113 read_lock(&dev_base_lock
);
114 if (dev_isalive(net
))
115 ret
= sysfs_format_mac(buf
, net
->dev_addr
, net
->addr_len
);
116 read_unlock(&dev_base_lock
);
120 static ssize_t
show_broadcast(struct device
*dev
,
121 struct device_attribute
*attr
, char *buf
)
123 struct net_device
*net
= to_net_dev(dev
);
124 if (dev_isalive(net
))
125 return sysfs_format_mac(buf
, net
->broadcast
, net
->addr_len
);
129 static ssize_t
show_carrier(struct device
*dev
,
130 struct device_attribute
*attr
, char *buf
)
132 struct net_device
*netdev
= to_net_dev(dev
);
133 if (netif_running(netdev
)) {
134 return sprintf(buf
, fmt_dec
, !!netif_carrier_ok(netdev
));
139 static ssize_t
show_speed(struct device
*dev
,
140 struct device_attribute
*attr
, char *buf
)
142 struct net_device
*netdev
= to_net_dev(dev
);
146 return restart_syscall();
148 if (netif_running(netdev
) &&
149 netdev
->ethtool_ops
&&
150 netdev
->ethtool_ops
->get_settings
) {
151 struct ethtool_cmd cmd
= { ETHTOOL_GSET
};
153 if (!netdev
->ethtool_ops
->get_settings(netdev
, &cmd
))
154 ret
= sprintf(buf
, fmt_dec
, ethtool_cmd_speed(&cmd
));
160 static ssize_t
show_duplex(struct device
*dev
,
161 struct device_attribute
*attr
, char *buf
)
163 struct net_device
*netdev
= to_net_dev(dev
);
167 return restart_syscall();
169 if (netif_running(netdev
) &&
170 netdev
->ethtool_ops
&&
171 netdev
->ethtool_ops
->get_settings
) {
172 struct ethtool_cmd cmd
= { ETHTOOL_GSET
};
174 if (!netdev
->ethtool_ops
->get_settings(netdev
, &cmd
))
175 ret
= sprintf(buf
, "%s\n", cmd
.duplex
? "full" : "half");
181 static ssize_t
show_dormant(struct device
*dev
,
182 struct device_attribute
*attr
, char *buf
)
184 struct net_device
*netdev
= to_net_dev(dev
);
186 if (netif_running(netdev
))
187 return sprintf(buf
, fmt_dec
, !!netif_dormant(netdev
));
192 static const char *const operstates
[] = {
194 "notpresent", /* currently unused */
197 "testing", /* currently unused */
202 static ssize_t
show_operstate(struct device
*dev
,
203 struct device_attribute
*attr
, char *buf
)
205 const struct net_device
*netdev
= to_net_dev(dev
);
206 unsigned char operstate
;
208 read_lock(&dev_base_lock
);
209 operstate
= netdev
->operstate
;
210 if (!netif_running(netdev
))
211 operstate
= IF_OPER_DOWN
;
212 read_unlock(&dev_base_lock
);
214 if (operstate
>= ARRAY_SIZE(operstates
))
215 return -EINVAL
; /* should not happen */
217 return sprintf(buf
, "%s\n", operstates
[operstate
]);
220 /* read-write attributes */
221 NETDEVICE_SHOW(mtu
, fmt_dec
);
223 static int change_mtu(struct net_device
*net
, unsigned long new_mtu
)
225 return dev_set_mtu(net
, (int) new_mtu
);
228 static ssize_t
store_mtu(struct device
*dev
, struct device_attribute
*attr
,
229 const char *buf
, size_t len
)
231 return netdev_store(dev
, attr
, buf
, len
, change_mtu
);
234 NETDEVICE_SHOW(flags
, fmt_hex
);
236 static int change_flags(struct net_device
*net
, unsigned long new_flags
)
238 return dev_change_flags(net
, (unsigned) new_flags
);
241 static ssize_t
store_flags(struct device
*dev
, struct device_attribute
*attr
,
242 const char *buf
, size_t len
)
244 return netdev_store(dev
, attr
, buf
, len
, change_flags
);
247 NETDEVICE_SHOW(tx_queue_len
, fmt_ulong
);
249 static int change_tx_queue_len(struct net_device
*net
, unsigned long new_len
)
251 net
->tx_queue_len
= new_len
;
255 static ssize_t
store_tx_queue_len(struct device
*dev
,
256 struct device_attribute
*attr
,
257 const char *buf
, size_t len
)
259 return netdev_store(dev
, attr
, buf
, len
, change_tx_queue_len
);
262 static ssize_t
store_ifalias(struct device
*dev
, struct device_attribute
*attr
,
263 const char *buf
, size_t len
)
265 struct net_device
*netdev
= to_net_dev(dev
);
269 if (!capable(CAP_NET_ADMIN
))
272 /* ignore trailing newline */
273 if (len
> 0 && buf
[len
- 1] == '\n')
277 return restart_syscall();
278 ret
= dev_set_alias(netdev
, buf
, count
);
281 return ret
< 0 ? ret
: len
;
284 static ssize_t
show_ifalias(struct device
*dev
,
285 struct device_attribute
*attr
, char *buf
)
287 const struct net_device
*netdev
= to_net_dev(dev
);
291 return restart_syscall();
293 ret
= sprintf(buf
, "%s\n", netdev
->ifalias
);
298 static struct device_attribute net_class_attributes
[] = {
299 __ATTR(addr_assign_type
, S_IRUGO
, show_addr_assign_type
, NULL
),
300 __ATTR(addr_len
, S_IRUGO
, show_addr_len
, NULL
),
301 __ATTR(dev_id
, S_IRUGO
, show_dev_id
, NULL
),
302 __ATTR(ifalias
, S_IRUGO
| S_IWUSR
, show_ifalias
, store_ifalias
),
303 __ATTR(iflink
, S_IRUGO
, show_iflink
, NULL
),
304 __ATTR(ifindex
, S_IRUGO
, show_ifindex
, NULL
),
305 __ATTR(features
, S_IRUGO
, show_features
, NULL
),
306 __ATTR(type
, S_IRUGO
, show_type
, NULL
),
307 __ATTR(link_mode
, S_IRUGO
, show_link_mode
, NULL
),
308 __ATTR(address
, S_IRUGO
, show_address
, NULL
),
309 __ATTR(broadcast
, S_IRUGO
, show_broadcast
, NULL
),
310 __ATTR(carrier
, S_IRUGO
, show_carrier
, NULL
),
311 __ATTR(speed
, S_IRUGO
, show_speed
, NULL
),
312 __ATTR(duplex
, S_IRUGO
, show_duplex
, NULL
),
313 __ATTR(dormant
, S_IRUGO
, show_dormant
, NULL
),
314 __ATTR(operstate
, S_IRUGO
, show_operstate
, NULL
),
315 __ATTR(mtu
, S_IRUGO
| S_IWUSR
, show_mtu
, store_mtu
),
316 __ATTR(flags
, S_IRUGO
| S_IWUSR
, show_flags
, store_flags
),
317 __ATTR(tx_queue_len
, S_IRUGO
| S_IWUSR
, show_tx_queue_len
,
322 /* Show a given an attribute in the statistics group */
323 static ssize_t
netstat_show(const struct device
*d
,
324 struct device_attribute
*attr
, char *buf
,
325 unsigned long offset
)
327 struct net_device
*dev
= to_net_dev(d
);
328 ssize_t ret
= -EINVAL
;
330 WARN_ON(offset
> sizeof(struct rtnl_link_stats64
) ||
331 offset
% sizeof(u64
) != 0);
333 read_lock(&dev_base_lock
);
334 if (dev_isalive(dev
)) {
335 struct rtnl_link_stats64 temp
;
336 const struct rtnl_link_stats64
*stats
= dev_get_stats(dev
, &temp
);
338 ret
= sprintf(buf
, fmt_u64
, *(u64
*)(((u8
*) stats
) + offset
));
340 read_unlock(&dev_base_lock
);
344 /* generate a read-only statistics attribute */
345 #define NETSTAT_ENTRY(name) \
346 static ssize_t show_##name(struct device *d, \
347 struct device_attribute *attr, char *buf) \
349 return netstat_show(d, attr, buf, \
350 offsetof(struct rtnl_link_stats64, name)); \
352 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
354 NETSTAT_ENTRY(rx_packets
);
355 NETSTAT_ENTRY(tx_packets
);
356 NETSTAT_ENTRY(rx_bytes
);
357 NETSTAT_ENTRY(tx_bytes
);
358 NETSTAT_ENTRY(rx_errors
);
359 NETSTAT_ENTRY(tx_errors
);
360 NETSTAT_ENTRY(rx_dropped
);
361 NETSTAT_ENTRY(tx_dropped
);
362 NETSTAT_ENTRY(multicast
);
363 NETSTAT_ENTRY(collisions
);
364 NETSTAT_ENTRY(rx_length_errors
);
365 NETSTAT_ENTRY(rx_over_errors
);
366 NETSTAT_ENTRY(rx_crc_errors
);
367 NETSTAT_ENTRY(rx_frame_errors
);
368 NETSTAT_ENTRY(rx_fifo_errors
);
369 NETSTAT_ENTRY(rx_missed_errors
);
370 NETSTAT_ENTRY(tx_aborted_errors
);
371 NETSTAT_ENTRY(tx_carrier_errors
);
372 NETSTAT_ENTRY(tx_fifo_errors
);
373 NETSTAT_ENTRY(tx_heartbeat_errors
);
374 NETSTAT_ENTRY(tx_window_errors
);
375 NETSTAT_ENTRY(rx_compressed
);
376 NETSTAT_ENTRY(tx_compressed
);
378 static struct attribute
*netstat_attrs
[] = {
379 &dev_attr_rx_packets
.attr
,
380 &dev_attr_tx_packets
.attr
,
381 &dev_attr_rx_bytes
.attr
,
382 &dev_attr_tx_bytes
.attr
,
383 &dev_attr_rx_errors
.attr
,
384 &dev_attr_tx_errors
.attr
,
385 &dev_attr_rx_dropped
.attr
,
386 &dev_attr_tx_dropped
.attr
,
387 &dev_attr_multicast
.attr
,
388 &dev_attr_collisions
.attr
,
389 &dev_attr_rx_length_errors
.attr
,
390 &dev_attr_rx_over_errors
.attr
,
391 &dev_attr_rx_crc_errors
.attr
,
392 &dev_attr_rx_frame_errors
.attr
,
393 &dev_attr_rx_fifo_errors
.attr
,
394 &dev_attr_rx_missed_errors
.attr
,
395 &dev_attr_tx_aborted_errors
.attr
,
396 &dev_attr_tx_carrier_errors
.attr
,
397 &dev_attr_tx_fifo_errors
.attr
,
398 &dev_attr_tx_heartbeat_errors
.attr
,
399 &dev_attr_tx_window_errors
.attr
,
400 &dev_attr_rx_compressed
.attr
,
401 &dev_attr_tx_compressed
.attr
,
406 static struct attribute_group netstat_group
= {
407 .name
= "statistics",
408 .attrs
= netstat_attrs
,
411 #ifdef CONFIG_WIRELESS_EXT_SYSFS
412 /* helper function that does all the locking etc for wireless stats */
413 static ssize_t
wireless_show(struct device
*d
, char *buf
,
414 ssize_t (*format
)(const struct iw_statistics
*,
417 struct net_device
*dev
= to_net_dev(d
);
418 const struct iw_statistics
*iw
;
419 ssize_t ret
= -EINVAL
;
422 return restart_syscall();
423 if (dev_isalive(dev
)) {
424 iw
= get_wireless_stats(dev
);
426 ret
= (*format
)(iw
, buf
);
433 /* show function template for wireless fields */
434 #define WIRELESS_SHOW(name, field, format_string) \
435 static ssize_t format_iw_##name(const struct iw_statistics *iw, char *buf) \
437 return sprintf(buf, format_string, iw->field); \
439 static ssize_t show_iw_##name(struct device *d, \
440 struct device_attribute *attr, char *buf) \
442 return wireless_show(d, buf, format_iw_##name); \
444 static DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL)
446 WIRELESS_SHOW(status
, status
, fmt_hex
);
447 WIRELESS_SHOW(link
, qual
.qual
, fmt_dec
);
448 WIRELESS_SHOW(level
, qual
.level
, fmt_dec
);
449 WIRELESS_SHOW(noise
, qual
.noise
, fmt_dec
);
450 WIRELESS_SHOW(nwid
, discard
.nwid
, fmt_dec
);
451 WIRELESS_SHOW(crypt
, discard
.code
, fmt_dec
);
452 WIRELESS_SHOW(fragment
, discard
.fragment
, fmt_dec
);
453 WIRELESS_SHOW(misc
, discard
.misc
, fmt_dec
);
454 WIRELESS_SHOW(retries
, discard
.retries
, fmt_dec
);
455 WIRELESS_SHOW(beacon
, miss
.beacon
, fmt_dec
);
457 static struct attribute
*wireless_attrs
[] = {
458 &dev_attr_status
.attr
,
460 &dev_attr_level
.attr
,
461 &dev_attr_noise
.attr
,
463 &dev_attr_crypt
.attr
,
464 &dev_attr_fragment
.attr
,
465 &dev_attr_retries
.attr
,
467 &dev_attr_beacon
.attr
,
471 static struct attribute_group wireless_group
= {
473 .attrs
= wireless_attrs
,
476 #endif /* CONFIG_SYSFS */
480 * RX queue sysfs structures and functions.
482 struct rx_queue_attribute
{
483 struct attribute attr
;
484 ssize_t (*show
)(struct netdev_rx_queue
*queue
,
485 struct rx_queue_attribute
*attr
, char *buf
);
486 ssize_t (*store
)(struct netdev_rx_queue
*queue
,
487 struct rx_queue_attribute
*attr
, const char *buf
, size_t len
);
489 #define to_rx_queue_attr(_attr) container_of(_attr, \
490 struct rx_queue_attribute, attr)
492 #define to_rx_queue(obj) container_of(obj, struct netdev_rx_queue, kobj)
494 static ssize_t
rx_queue_attr_show(struct kobject
*kobj
, struct attribute
*attr
,
497 struct rx_queue_attribute
*attribute
= to_rx_queue_attr(attr
);
498 struct netdev_rx_queue
*queue
= to_rx_queue(kobj
);
500 if (!attribute
->show
)
503 return attribute
->show(queue
, attribute
, buf
);
506 static ssize_t
rx_queue_attr_store(struct kobject
*kobj
, struct attribute
*attr
,
507 const char *buf
, size_t count
)
509 struct rx_queue_attribute
*attribute
= to_rx_queue_attr(attr
);
510 struct netdev_rx_queue
*queue
= to_rx_queue(kobj
);
512 if (!attribute
->store
)
515 return attribute
->store(queue
, attribute
, buf
, count
);
518 static const struct sysfs_ops rx_queue_sysfs_ops
= {
519 .show
= rx_queue_attr_show
,
520 .store
= rx_queue_attr_store
,
523 static ssize_t
show_rps_map(struct netdev_rx_queue
*queue
,
524 struct rx_queue_attribute
*attribute
, char *buf
)
531 if (!zalloc_cpumask_var(&mask
, GFP_KERNEL
))
535 map
= rcu_dereference(queue
->rps_map
);
537 for (i
= 0; i
< map
->len
; i
++)
538 cpumask_set_cpu(map
->cpus
[i
], mask
);
540 len
+= cpumask_scnprintf(buf
+ len
, PAGE_SIZE
, mask
);
541 if (PAGE_SIZE
- len
< 3) {
543 free_cpumask_var(mask
);
548 free_cpumask_var(mask
);
549 len
+= sprintf(buf
+ len
, "\n");
553 static void rps_map_release(struct rcu_head
*rcu
)
555 struct rps_map
*map
= container_of(rcu
, struct rps_map
, rcu
);
560 static ssize_t
store_rps_map(struct netdev_rx_queue
*queue
,
561 struct rx_queue_attribute
*attribute
,
562 const char *buf
, size_t len
)
564 struct rps_map
*old_map
, *map
;
567 static DEFINE_SPINLOCK(rps_map_lock
);
569 if (!capable(CAP_NET_ADMIN
))
572 if (!alloc_cpumask_var(&mask
, GFP_KERNEL
))
575 err
= bitmap_parse(buf
, len
, cpumask_bits(mask
), nr_cpumask_bits
);
577 free_cpumask_var(mask
);
581 map
= kzalloc(max_t(unsigned,
582 RPS_MAP_SIZE(cpumask_weight(mask
)), L1_CACHE_BYTES
),
585 free_cpumask_var(mask
);
590 for_each_cpu_and(cpu
, mask
, cpu_online_mask
)
591 map
->cpus
[i
++] = cpu
;
600 spin_lock(&rps_map_lock
);
601 old_map
= rcu_dereference_protected(queue
->rps_map
,
602 lockdep_is_held(&rps_map_lock
));
603 rcu_assign_pointer(queue
->rps_map
, map
);
604 spin_unlock(&rps_map_lock
);
607 call_rcu(&old_map
->rcu
, rps_map_release
);
609 free_cpumask_var(mask
);
613 static ssize_t
show_rps_dev_flow_table_cnt(struct netdev_rx_queue
*queue
,
614 struct rx_queue_attribute
*attr
,
617 struct rps_dev_flow_table
*flow_table
;
618 unsigned int val
= 0;
621 flow_table
= rcu_dereference(queue
->rps_flow_table
);
623 val
= flow_table
->mask
+ 1;
626 return sprintf(buf
, "%u\n", val
);
629 static void rps_dev_flow_table_release_work(struct work_struct
*work
)
631 struct rps_dev_flow_table
*table
= container_of(work
,
632 struct rps_dev_flow_table
, free_work
);
637 static void rps_dev_flow_table_release(struct rcu_head
*rcu
)
639 struct rps_dev_flow_table
*table
= container_of(rcu
,
640 struct rps_dev_flow_table
, rcu
);
642 INIT_WORK(&table
->free_work
, rps_dev_flow_table_release_work
);
643 schedule_work(&table
->free_work
);
646 static ssize_t
store_rps_dev_flow_table_cnt(struct netdev_rx_queue
*queue
,
647 struct rx_queue_attribute
*attr
,
648 const char *buf
, size_t len
)
652 struct rps_dev_flow_table
*table
, *old_table
;
653 static DEFINE_SPINLOCK(rps_dev_flow_lock
);
655 if (!capable(CAP_NET_ADMIN
))
658 count
= simple_strtoul(buf
, &endp
, 0);
666 /* Enforce a limit to prevent overflow */
669 count
= roundup_pow_of_two(count
);
670 table
= vmalloc(RPS_DEV_FLOW_TABLE_SIZE(count
));
674 table
->mask
= count
- 1;
675 for (i
= 0; i
< count
; i
++)
676 table
->flows
[i
].cpu
= RPS_NO_CPU
;
680 spin_lock(&rps_dev_flow_lock
);
681 old_table
= rcu_dereference_protected(queue
->rps_flow_table
,
682 lockdep_is_held(&rps_dev_flow_lock
));
683 rcu_assign_pointer(queue
->rps_flow_table
, table
);
684 spin_unlock(&rps_dev_flow_lock
);
687 call_rcu(&old_table
->rcu
, rps_dev_flow_table_release
);
692 static struct rx_queue_attribute rps_cpus_attribute
=
693 __ATTR(rps_cpus
, S_IRUGO
| S_IWUSR
, show_rps_map
, store_rps_map
);
696 static struct rx_queue_attribute rps_dev_flow_table_cnt_attribute
=
697 __ATTR(rps_flow_cnt
, S_IRUGO
| S_IWUSR
,
698 show_rps_dev_flow_table_cnt
, store_rps_dev_flow_table_cnt
);
700 static struct attribute
*rx_queue_default_attrs
[] = {
701 &rps_cpus_attribute
.attr
,
702 &rps_dev_flow_table_cnt_attribute
.attr
,
706 static void rx_queue_release(struct kobject
*kobj
)
708 struct netdev_rx_queue
*queue
= to_rx_queue(kobj
);
709 struct netdev_rx_queue
*first
= queue
->first
;
711 struct rps_dev_flow_table
*flow_table
;
714 map
= rcu_dereference_raw(queue
->rps_map
);
716 RCU_INIT_POINTER(queue
->rps_map
, NULL
);
717 call_rcu(&map
->rcu
, rps_map_release
);
720 flow_table
= rcu_dereference_raw(queue
->rps_flow_table
);
722 RCU_INIT_POINTER(queue
->rps_flow_table
, NULL
);
723 call_rcu(&flow_table
->rcu
, rps_dev_flow_table_release
);
726 if (atomic_dec_and_test(&first
->count
))
729 memset(kobj
, 0, sizeof(*kobj
));
732 static struct kobj_type rx_queue_ktype
= {
733 .sysfs_ops
= &rx_queue_sysfs_ops
,
734 .release
= rx_queue_release
,
735 .default_attrs
= rx_queue_default_attrs
,
738 static int rx_queue_add_kobject(struct net_device
*net
, int index
)
740 struct netdev_rx_queue
*queue
= net
->_rx
+ index
;
741 struct netdev_rx_queue
*first
= queue
->first
;
742 struct kobject
*kobj
= &queue
->kobj
;
745 kobj
->kset
= net
->queues_kset
;
746 error
= kobject_init_and_add(kobj
, &rx_queue_ktype
, NULL
,
753 kobject_uevent(kobj
, KOBJ_ADD
);
754 atomic_inc(&first
->count
);
760 net_rx_queue_update_kobjects(struct net_device
*net
, int old_num
, int new_num
)
765 for (i
= old_num
; i
< new_num
; i
++) {
766 error
= rx_queue_add_kobject(net
, i
);
773 while (--i
>= new_num
)
774 kobject_put(&net
->_rx
[i
].kobj
);
779 static int rx_queue_register_kobjects(struct net_device
*net
)
781 net
->queues_kset
= kset_create_and_add("queues",
782 NULL
, &net
->dev
.kobj
);
783 if (!net
->queues_kset
)
785 return net_rx_queue_update_kobjects(net
, 0, net
->real_num_rx_queues
);
788 static void rx_queue_remove_kobjects(struct net_device
*net
)
790 net_rx_queue_update_kobjects(net
, net
->real_num_rx_queues
, 0);
791 kset_unregister(net
->queues_kset
);
793 #endif /* CONFIG_RPS */
795 static const void *net_current_ns(void)
797 return current
->nsproxy
->net_ns
;
800 static const void *net_initial_ns(void)
805 static const void *net_netlink_ns(struct sock
*sk
)
810 struct kobj_ns_type_operations net_ns_type_operations
= {
811 .type
= KOBJ_NS_TYPE_NET
,
812 .current_ns
= net_current_ns
,
813 .netlink_ns
= net_netlink_ns
,
814 .initial_ns
= net_initial_ns
,
816 EXPORT_SYMBOL_GPL(net_ns_type_operations
);
818 static void net_kobj_ns_exit(struct net
*net
)
820 kobj_ns_exit(KOBJ_NS_TYPE_NET
, net
);
823 static struct pernet_operations kobj_net_ops
= {
824 .exit
= net_kobj_ns_exit
,
828 #ifdef CONFIG_HOTPLUG
829 static int netdev_uevent(struct device
*d
, struct kobj_uevent_env
*env
)
831 struct net_device
*dev
= to_net_dev(d
);
834 /* pass interface to uevent. */
835 retval
= add_uevent_var(env
, "INTERFACE=%s", dev
->name
);
839 /* pass ifindex to uevent.
840 * ifindex is useful as it won't change (interface name may change)
841 * and is what RtNetlink uses natively. */
842 retval
= add_uevent_var(env
, "IFINDEX=%d", dev
->ifindex
);
850 * netdev_release -- destroy and free a dead device.
851 * Called when last reference to device kobject is gone.
853 static void netdev_release(struct device
*d
)
855 struct net_device
*dev
= to_net_dev(d
);
857 BUG_ON(dev
->reg_state
!= NETREG_RELEASED
);
860 kfree((char *)dev
- dev
->padded
);
863 static const void *net_namespace(struct device
*d
)
865 struct net_device
*dev
;
866 dev
= container_of(d
, struct net_device
, dev
);
870 static struct class net_class
= {
872 .dev_release
= netdev_release
,
874 .dev_attrs
= net_class_attributes
,
875 #endif /* CONFIG_SYSFS */
876 #ifdef CONFIG_HOTPLUG
877 .dev_uevent
= netdev_uevent
,
879 .ns_type
= &net_ns_type_operations
,
880 .namespace = net_namespace
,
883 /* Delete sysfs entries but hold kobject reference until after all
884 * netdev references are gone.
886 void netdev_unregister_kobject(struct net_device
* net
)
888 struct device
*dev
= &(net
->dev
);
890 kobject_get(&dev
->kobj
);
893 rx_queue_remove_kobjects(net
);
899 /* Create sysfs entries for network device. */
900 int netdev_register_kobject(struct net_device
*net
)
902 struct device
*dev
= &(net
->dev
);
903 const struct attribute_group
**groups
= net
->sysfs_groups
;
906 device_initialize(dev
);
907 dev
->class = &net_class
;
908 dev
->platform_data
= net
;
909 dev
->groups
= groups
;
911 dev_set_name(dev
, "%s", net
->name
);
914 /* Allow for a device specific group */
918 *groups
++ = &netstat_group
;
919 #ifdef CONFIG_WIRELESS_EXT_SYSFS
920 if (net
->ieee80211_ptr
)
921 *groups
++ = &wireless_group
;
922 #ifdef CONFIG_WIRELESS_EXT
923 else if (net
->wireless_handlers
)
924 *groups
++ = &wireless_group
;
927 #endif /* CONFIG_SYSFS */
929 error
= device_add(dev
);
934 error
= rx_queue_register_kobjects(net
);
944 int netdev_class_create_file(struct class_attribute
*class_attr
)
946 return class_create_file(&net_class
, class_attr
);
948 EXPORT_SYMBOL(netdev_class_create_file
);
950 void netdev_class_remove_file(struct class_attribute
*class_attr
)
952 class_remove_file(&net_class
, class_attr
);
954 EXPORT_SYMBOL(netdev_class_remove_file
);
956 int netdev_kobject_init(void)
958 kobj_ns_type_register(&net_ns_type_operations
);
959 register_pernet_subsys(&kobj_net_ops
);
960 return class_register(&net_class
);