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>
18 #include <linux/rtnetlink.h>
19 #include <linux/wireless.h>
22 #include "net-sysfs.h"
25 static const char fmt_hex
[] = "%#x\n";
26 static const char fmt_long_hex
[] = "%#lx\n";
27 static const char fmt_dec
[] = "%d\n";
28 static const char fmt_ulong
[] = "%lu\n";
30 static inline int dev_isalive(const struct net_device
*dev
)
32 return dev
->reg_state
<= NETREG_REGISTERED
;
35 /* use same locking rules as GIF* ioctl's */
36 static ssize_t
netdev_show(const struct device
*dev
,
37 struct device_attribute
*attr
, char *buf
,
38 ssize_t (*format
)(const struct net_device
*, char *))
40 struct net_device
*net
= to_net_dev(dev
);
41 ssize_t ret
= -EINVAL
;
43 read_lock(&dev_base_lock
);
45 ret
= (*format
)(net
, buf
);
46 read_unlock(&dev_base_lock
);
51 /* generate a show function for simple field */
52 #define NETDEVICE_SHOW(field, format_string) \
53 static ssize_t format_##field(const struct net_device *net, char *buf) \
55 return sprintf(buf, format_string, net->field); \
57 static ssize_t show_##field(struct device *dev, \
58 struct device_attribute *attr, char *buf) \
60 return netdev_show(dev, attr, buf, format_##field); \
64 /* use same locking and permission rules as SIF* ioctl's */
65 static ssize_t
netdev_store(struct device
*dev
, struct device_attribute
*attr
,
66 const char *buf
, size_t len
,
67 int (*set
)(struct net_device
*, unsigned long))
69 struct net_device
*net
= to_net_dev(dev
);
74 if (!capable(CAP_NET_ADMIN
))
77 new = simple_strtoul(buf
, &endp
, 0);
82 return restart_syscall();
84 if (dev_isalive(net
)) {
85 if ((ret
= (*set
)(net
, new)) == 0)
93 NETDEVICE_SHOW(dev_id
, fmt_hex
);
94 NETDEVICE_SHOW(addr_len
, fmt_dec
);
95 NETDEVICE_SHOW(iflink
, fmt_dec
);
96 NETDEVICE_SHOW(ifindex
, fmt_dec
);
97 NETDEVICE_SHOW(features
, fmt_long_hex
);
98 NETDEVICE_SHOW(type
, fmt_dec
);
99 NETDEVICE_SHOW(link_mode
, fmt_dec
);
101 /* use same locking rules as GIFHWADDR ioctl's */
102 static ssize_t
show_address(struct device
*dev
, struct device_attribute
*attr
,
105 struct net_device
*net
= to_net_dev(dev
);
106 ssize_t ret
= -EINVAL
;
108 read_lock(&dev_base_lock
);
109 if (dev_isalive(net
))
110 ret
= sysfs_format_mac(buf
, net
->dev_addr
, net
->addr_len
);
111 read_unlock(&dev_base_lock
);
115 static ssize_t
show_broadcast(struct device
*dev
,
116 struct device_attribute
*attr
, char *buf
)
118 struct net_device
*net
= to_net_dev(dev
);
119 if (dev_isalive(net
))
120 return sysfs_format_mac(buf
, net
->broadcast
, net
->addr_len
);
124 static ssize_t
show_carrier(struct device
*dev
,
125 struct device_attribute
*attr
, char *buf
)
127 struct net_device
*netdev
= to_net_dev(dev
);
128 if (netif_running(netdev
)) {
129 return sprintf(buf
, fmt_dec
, !!netif_carrier_ok(netdev
));
134 static ssize_t
show_speed(struct device
*dev
,
135 struct device_attribute
*attr
, char *buf
)
137 struct net_device
*netdev
= to_net_dev(dev
);
141 return restart_syscall();
143 if (netif_running(netdev
) &&
144 netdev
->ethtool_ops
&&
145 netdev
->ethtool_ops
->get_settings
) {
146 struct ethtool_cmd cmd
= { ETHTOOL_GSET
};
148 if (!netdev
->ethtool_ops
->get_settings(netdev
, &cmd
))
149 ret
= sprintf(buf
, fmt_dec
, ethtool_cmd_speed(&cmd
));
155 static ssize_t
show_duplex(struct device
*dev
,
156 struct device_attribute
*attr
, char *buf
)
158 struct net_device
*netdev
= to_net_dev(dev
);
162 return restart_syscall();
164 if (netif_running(netdev
) &&
165 netdev
->ethtool_ops
&&
166 netdev
->ethtool_ops
->get_settings
) {
167 struct ethtool_cmd cmd
= { ETHTOOL_GSET
};
169 if (!netdev
->ethtool_ops
->get_settings(netdev
, &cmd
))
170 ret
= sprintf(buf
, "%s\n", cmd
.duplex
? "full" : "half");
176 static ssize_t
show_dormant(struct device
*dev
,
177 struct device_attribute
*attr
, char *buf
)
179 struct net_device
*netdev
= to_net_dev(dev
);
181 if (netif_running(netdev
))
182 return sprintf(buf
, fmt_dec
, !!netif_dormant(netdev
));
187 static const char *const operstates
[] = {
189 "notpresent", /* currently unused */
192 "testing", /* currently unused */
197 static ssize_t
show_operstate(struct device
*dev
,
198 struct device_attribute
*attr
, char *buf
)
200 const struct net_device
*netdev
= to_net_dev(dev
);
201 unsigned char operstate
;
203 read_lock(&dev_base_lock
);
204 operstate
= netdev
->operstate
;
205 if (!netif_running(netdev
))
206 operstate
= IF_OPER_DOWN
;
207 read_unlock(&dev_base_lock
);
209 if (operstate
>= ARRAY_SIZE(operstates
))
210 return -EINVAL
; /* should not happen */
212 return sprintf(buf
, "%s\n", operstates
[operstate
]);
215 /* read-write attributes */
216 NETDEVICE_SHOW(mtu
, fmt_dec
);
218 static int change_mtu(struct net_device
*net
, unsigned long new_mtu
)
220 return dev_set_mtu(net
, (int) new_mtu
);
223 static ssize_t
store_mtu(struct device
*dev
, struct device_attribute
*attr
,
224 const char *buf
, size_t len
)
226 return netdev_store(dev
, attr
, buf
, len
, change_mtu
);
229 NETDEVICE_SHOW(flags
, fmt_hex
);
231 static int change_flags(struct net_device
*net
, unsigned long new_flags
)
233 return dev_change_flags(net
, (unsigned) new_flags
);
236 static ssize_t
store_flags(struct device
*dev
, struct device_attribute
*attr
,
237 const char *buf
, size_t len
)
239 return netdev_store(dev
, attr
, buf
, len
, change_flags
);
242 NETDEVICE_SHOW(tx_queue_len
, fmt_ulong
);
244 static int change_tx_queue_len(struct net_device
*net
, unsigned long new_len
)
246 net
->tx_queue_len
= new_len
;
250 static ssize_t
store_tx_queue_len(struct device
*dev
,
251 struct device_attribute
*attr
,
252 const char *buf
, size_t len
)
254 return netdev_store(dev
, attr
, buf
, len
, change_tx_queue_len
);
257 static ssize_t
store_ifalias(struct device
*dev
, struct device_attribute
*attr
,
258 const char *buf
, size_t len
)
260 struct net_device
*netdev
= to_net_dev(dev
);
264 if (!capable(CAP_NET_ADMIN
))
267 /* ignore trailing newline */
268 if (len
> 0 && buf
[len
- 1] == '\n')
272 return restart_syscall();
273 ret
= dev_set_alias(netdev
, buf
, count
);
276 return ret
< 0 ? ret
: len
;
279 static ssize_t
show_ifalias(struct device
*dev
,
280 struct device_attribute
*attr
, char *buf
)
282 const struct net_device
*netdev
= to_net_dev(dev
);
286 return restart_syscall();
288 ret
= sprintf(buf
, "%s\n", netdev
->ifalias
);
293 static struct device_attribute net_class_attributes
[] = {
294 __ATTR(addr_len
, S_IRUGO
, show_addr_len
, NULL
),
295 __ATTR(dev_id
, S_IRUGO
, show_dev_id
, NULL
),
296 __ATTR(ifalias
, S_IRUGO
| S_IWUSR
, show_ifalias
, store_ifalias
),
297 __ATTR(iflink
, S_IRUGO
, show_iflink
, NULL
),
298 __ATTR(ifindex
, S_IRUGO
, show_ifindex
, NULL
),
299 __ATTR(features
, S_IRUGO
, show_features
, NULL
),
300 __ATTR(type
, S_IRUGO
, show_type
, NULL
),
301 __ATTR(link_mode
, S_IRUGO
, show_link_mode
, NULL
),
302 __ATTR(address
, S_IRUGO
, show_address
, NULL
),
303 __ATTR(broadcast
, S_IRUGO
, show_broadcast
, NULL
),
304 __ATTR(carrier
, S_IRUGO
, show_carrier
, NULL
),
305 __ATTR(speed
, S_IRUGO
, show_speed
, NULL
),
306 __ATTR(duplex
, S_IRUGO
, show_duplex
, NULL
),
307 __ATTR(dormant
, S_IRUGO
, show_dormant
, NULL
),
308 __ATTR(operstate
, S_IRUGO
, show_operstate
, NULL
),
309 __ATTR(mtu
, S_IRUGO
| S_IWUSR
, show_mtu
, store_mtu
),
310 __ATTR(flags
, S_IRUGO
| S_IWUSR
, show_flags
, store_flags
),
311 __ATTR(tx_queue_len
, S_IRUGO
| S_IWUSR
, show_tx_queue_len
,
316 /* Show a given an attribute in the statistics group */
317 static ssize_t
netstat_show(const struct device
*d
,
318 struct device_attribute
*attr
, char *buf
,
319 unsigned long offset
)
321 struct net_device
*dev
= to_net_dev(d
);
322 ssize_t ret
= -EINVAL
;
324 WARN_ON(offset
> sizeof(struct net_device_stats
) ||
325 offset
% sizeof(unsigned long) != 0);
327 read_lock(&dev_base_lock
);
328 if (dev_isalive(dev
)) {
329 const struct net_device_stats
*stats
= dev_get_stats(dev
);
330 ret
= sprintf(buf
, fmt_ulong
,
331 *(unsigned long *)(((u8
*) stats
) + offset
));
333 read_unlock(&dev_base_lock
);
337 /* generate a read-only statistics attribute */
338 #define NETSTAT_ENTRY(name) \
339 static ssize_t show_##name(struct device *d, \
340 struct device_attribute *attr, char *buf) \
342 return netstat_show(d, attr, buf, \
343 offsetof(struct net_device_stats, name)); \
345 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
347 NETSTAT_ENTRY(rx_packets
);
348 NETSTAT_ENTRY(tx_packets
);
349 NETSTAT_ENTRY(rx_bytes
);
350 NETSTAT_ENTRY(tx_bytes
);
351 NETSTAT_ENTRY(rx_errors
);
352 NETSTAT_ENTRY(tx_errors
);
353 NETSTAT_ENTRY(rx_dropped
);
354 NETSTAT_ENTRY(tx_dropped
);
355 NETSTAT_ENTRY(multicast
);
356 NETSTAT_ENTRY(collisions
);
357 NETSTAT_ENTRY(rx_length_errors
);
358 NETSTAT_ENTRY(rx_over_errors
);
359 NETSTAT_ENTRY(rx_crc_errors
);
360 NETSTAT_ENTRY(rx_frame_errors
);
361 NETSTAT_ENTRY(rx_fifo_errors
);
362 NETSTAT_ENTRY(rx_missed_errors
);
363 NETSTAT_ENTRY(tx_aborted_errors
);
364 NETSTAT_ENTRY(tx_carrier_errors
);
365 NETSTAT_ENTRY(tx_fifo_errors
);
366 NETSTAT_ENTRY(tx_heartbeat_errors
);
367 NETSTAT_ENTRY(tx_window_errors
);
368 NETSTAT_ENTRY(rx_compressed
);
369 NETSTAT_ENTRY(tx_compressed
);
371 static struct attribute
*netstat_attrs
[] = {
372 &dev_attr_rx_packets
.attr
,
373 &dev_attr_tx_packets
.attr
,
374 &dev_attr_rx_bytes
.attr
,
375 &dev_attr_tx_bytes
.attr
,
376 &dev_attr_rx_errors
.attr
,
377 &dev_attr_tx_errors
.attr
,
378 &dev_attr_rx_dropped
.attr
,
379 &dev_attr_tx_dropped
.attr
,
380 &dev_attr_multicast
.attr
,
381 &dev_attr_collisions
.attr
,
382 &dev_attr_rx_length_errors
.attr
,
383 &dev_attr_rx_over_errors
.attr
,
384 &dev_attr_rx_crc_errors
.attr
,
385 &dev_attr_rx_frame_errors
.attr
,
386 &dev_attr_rx_fifo_errors
.attr
,
387 &dev_attr_rx_missed_errors
.attr
,
388 &dev_attr_tx_aborted_errors
.attr
,
389 &dev_attr_tx_carrier_errors
.attr
,
390 &dev_attr_tx_fifo_errors
.attr
,
391 &dev_attr_tx_heartbeat_errors
.attr
,
392 &dev_attr_tx_window_errors
.attr
,
393 &dev_attr_rx_compressed
.attr
,
394 &dev_attr_tx_compressed
.attr
,
399 static struct attribute_group netstat_group
= {
400 .name
= "statistics",
401 .attrs
= netstat_attrs
,
404 #ifdef CONFIG_WIRELESS_EXT_SYSFS
405 /* helper function that does all the locking etc for wireless stats */
406 static ssize_t
wireless_show(struct device
*d
, char *buf
,
407 ssize_t (*format
)(const struct iw_statistics
*,
410 struct net_device
*dev
= to_net_dev(d
);
411 const struct iw_statistics
*iw
;
412 ssize_t ret
= -EINVAL
;
415 return restart_syscall();
416 if (dev_isalive(dev
)) {
417 iw
= get_wireless_stats(dev
);
419 ret
= (*format
)(iw
, buf
);
426 /* show function template for wireless fields */
427 #define WIRELESS_SHOW(name, field, format_string) \
428 static ssize_t format_iw_##name(const struct iw_statistics *iw, char *buf) \
430 return sprintf(buf, format_string, iw->field); \
432 static ssize_t show_iw_##name(struct device *d, \
433 struct device_attribute *attr, char *buf) \
435 return wireless_show(d, buf, format_iw_##name); \
437 static DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL)
439 WIRELESS_SHOW(status
, status
, fmt_hex
);
440 WIRELESS_SHOW(link
, qual
.qual
, fmt_dec
);
441 WIRELESS_SHOW(level
, qual
.level
, fmt_dec
);
442 WIRELESS_SHOW(noise
, qual
.noise
, fmt_dec
);
443 WIRELESS_SHOW(nwid
, discard
.nwid
, fmt_dec
);
444 WIRELESS_SHOW(crypt
, discard
.code
, fmt_dec
);
445 WIRELESS_SHOW(fragment
, discard
.fragment
, fmt_dec
);
446 WIRELESS_SHOW(misc
, discard
.misc
, fmt_dec
);
447 WIRELESS_SHOW(retries
, discard
.retries
, fmt_dec
);
448 WIRELESS_SHOW(beacon
, miss
.beacon
, fmt_dec
);
450 static struct attribute
*wireless_attrs
[] = {
451 &dev_attr_status
.attr
,
453 &dev_attr_level
.attr
,
454 &dev_attr_noise
.attr
,
456 &dev_attr_crypt
.attr
,
457 &dev_attr_fragment
.attr
,
458 &dev_attr_retries
.attr
,
460 &dev_attr_beacon
.attr
,
464 static struct attribute_group wireless_group
= {
466 .attrs
= wireless_attrs
,
470 #endif /* CONFIG_SYSFS */
472 #ifdef CONFIG_HOTPLUG
473 static int netdev_uevent(struct device
*d
, struct kobj_uevent_env
*env
)
475 struct net_device
*dev
= to_net_dev(d
);
478 if (!net_eq(dev_net(dev
), &init_net
))
481 /* pass interface to uevent. */
482 retval
= add_uevent_var(env
, "INTERFACE=%s", dev
->name
);
486 /* pass ifindex to uevent.
487 * ifindex is useful as it won't change (interface name may change)
488 * and is what RtNetlink uses natively. */
489 retval
= add_uevent_var(env
, "IFINDEX=%d", dev
->ifindex
);
497 * netdev_release -- destroy and free a dead device.
498 * Called when last reference to device kobject is gone.
500 static void netdev_release(struct device
*d
)
502 struct net_device
*dev
= to_net_dev(d
);
504 BUG_ON(dev
->reg_state
!= NETREG_RELEASED
);
507 kfree((char *)dev
- dev
->padded
);
510 static struct class net_class
= {
512 .dev_release
= netdev_release
,
514 .dev_attrs
= net_class_attributes
,
515 #endif /* CONFIG_SYSFS */
516 #ifdef CONFIG_HOTPLUG
517 .dev_uevent
= netdev_uevent
,
521 /* Delete sysfs entries but hold kobject reference until after all
522 * netdev references are gone.
524 void netdev_unregister_kobject(struct net_device
* net
)
526 struct device
*dev
= &(net
->dev
);
528 kobject_get(&dev
->kobj
);
530 if (!net_eq(dev_net(net
), &init_net
))
536 /* Create sysfs entries for network device. */
537 int netdev_register_kobject(struct net_device
*net
)
539 struct device
*dev
= &(net
->dev
);
540 const struct attribute_group
**groups
= net
->sysfs_groups
;
542 dev
->class = &net_class
;
543 dev
->platform_data
= net
;
544 dev
->groups
= groups
;
546 dev_set_name(dev
, "%s", net
->name
);
549 /* Allow for a device specific group */
553 *groups
++ = &netstat_group
;
554 #ifdef CONFIG_WIRELESS_EXT_SYSFS
555 if (net
->ieee80211_ptr
)
556 *groups
++ = &wireless_group
;
557 #ifdef CONFIG_WIRELESS_EXT
558 else if (net
->wireless_handlers
)
559 *groups
++ = &wireless_group
;
562 #endif /* CONFIG_SYSFS */
564 if (!net_eq(dev_net(net
), &init_net
))
567 return device_add(dev
);
570 int netdev_class_create_file(struct class_attribute
*class_attr
)
572 return class_create_file(&net_class
, class_attr
);
575 void netdev_class_remove_file(struct class_attribute
*class_attr
)
577 class_remove_file(&net_class
, class_attr
);
580 EXPORT_SYMBOL(netdev_class_create_file
);
581 EXPORT_SYMBOL(netdev_class_remove_file
);
583 void netdev_initialize_kobject(struct net_device
*net
)
585 struct device
*device
= &(net
->dev
);
586 device_initialize(device
);
589 int netdev_kobject_init(void)
591 return class_register(&net_class
);