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>
17 #include <linux/rtnetlink.h>
18 #include <linux/wireless.h>
19 #include <net/iw_handler.h>
21 #define to_class_dev(obj) container_of(obj,struct class_device,kobj)
22 #define to_net_dev(class) container_of(class, struct net_device, class_dev)
24 static const char fmt_hex
[] = "%#x\n";
25 static const char fmt_long_hex
[] = "%#lx\n";
26 static const char fmt_dec
[] = "%d\n";
27 static const char fmt_ulong
[] = "%lu\n";
29 static inline int dev_isalive(const struct net_device
*dev
)
31 return dev
->reg_state
<= NETREG_REGISTERED
;
34 /* use same locking rules as GIF* ioctl's */
35 static ssize_t
netdev_show(const struct class_device
*cd
, char *buf
,
36 ssize_t (*format
)(const struct net_device
*, char *))
38 struct net_device
*net
= to_net_dev(cd
);
39 ssize_t ret
= -EINVAL
;
41 read_lock(&dev_base_lock
);
43 ret
= (*format
)(net
, buf
);
44 read_unlock(&dev_base_lock
);
49 /* generate a show function for simple field */
50 #define NETDEVICE_SHOW(field, format_string) \
51 static ssize_t format_##field(const struct net_device *net, char *buf) \
53 return sprintf(buf, format_string, net->field); \
55 static ssize_t show_##field(struct class_device *cd, char *buf) \
57 return netdev_show(cd, buf, format_##field); \
61 /* use same locking and permission rules as SIF* ioctl's */
62 static ssize_t
netdev_store(struct class_device
*dev
,
63 const char *buf
, size_t len
,
64 int (*set
)(struct net_device
*, unsigned long))
66 struct net_device
*net
= to_net_dev(dev
);
71 if (!capable(CAP_NET_ADMIN
))
74 new = simple_strtoul(buf
, &endp
, 0);
79 if (dev_isalive(net
)) {
80 if ((ret
= (*set
)(net
, new)) == 0)
88 NETDEVICE_SHOW(addr_len
, fmt_dec
);
89 NETDEVICE_SHOW(iflink
, fmt_dec
);
90 NETDEVICE_SHOW(ifindex
, fmt_dec
);
91 NETDEVICE_SHOW(features
, fmt_long_hex
);
92 NETDEVICE_SHOW(type
, fmt_dec
);
93 NETDEVICE_SHOW(link_mode
, fmt_dec
);
95 /* use same locking rules as GIFHWADDR ioctl's */
96 static ssize_t
format_addr(char *buf
, const unsigned char *addr
, int len
)
101 for (i
= 0; i
< len
; i
++)
102 cp
+= sprintf(cp
, "%02x%c", addr
[i
],
103 i
== (len
- 1) ? '\n' : ':');
107 static ssize_t
show_address(struct class_device
*dev
, char *buf
)
109 struct net_device
*net
= to_net_dev(dev
);
110 ssize_t ret
= -EINVAL
;
112 read_lock(&dev_base_lock
);
113 if (dev_isalive(net
))
114 ret
= format_addr(buf
, net
->dev_addr
, net
->addr_len
);
115 read_unlock(&dev_base_lock
);
119 static ssize_t
show_broadcast(struct class_device
*dev
, char *buf
)
121 struct net_device
*net
= to_net_dev(dev
);
122 if (dev_isalive(net
))
123 return format_addr(buf
, net
->broadcast
, net
->addr_len
);
127 static ssize_t
show_carrier(struct class_device
*dev
, char *buf
)
129 struct net_device
*netdev
= to_net_dev(dev
);
130 if (netif_running(netdev
)) {
131 return sprintf(buf
, fmt_dec
, !!netif_carrier_ok(netdev
));
136 static ssize_t
show_dormant(struct class_device
*dev
, char *buf
)
138 struct net_device
*netdev
= to_net_dev(dev
);
140 if (netif_running(netdev
))
141 return sprintf(buf
, fmt_dec
, !!netif_dormant(netdev
));
146 static const char *operstates
[] = {
148 "notpresent", /* currently unused */
151 "testing", /* currently unused */
156 static ssize_t
show_operstate(struct class_device
*dev
, char *buf
)
158 const struct net_device
*netdev
= to_net_dev(dev
);
159 unsigned char operstate
;
161 read_lock(&dev_base_lock
);
162 operstate
= netdev
->operstate
;
163 if (!netif_running(netdev
))
164 operstate
= IF_OPER_DOWN
;
165 read_unlock(&dev_base_lock
);
167 if (operstate
>= ARRAY_SIZE(operstates
))
168 return -EINVAL
; /* should not happen */
170 return sprintf(buf
, "%s\n", operstates
[operstate
]);
173 /* read-write attributes */
174 NETDEVICE_SHOW(mtu
, fmt_dec
);
176 static int change_mtu(struct net_device
*net
, unsigned long new_mtu
)
178 return dev_set_mtu(net
, (int) new_mtu
);
181 static ssize_t
store_mtu(struct class_device
*dev
, const char *buf
, size_t len
)
183 return netdev_store(dev
, buf
, len
, change_mtu
);
186 NETDEVICE_SHOW(flags
, fmt_hex
);
188 static int change_flags(struct net_device
*net
, unsigned long new_flags
)
190 return dev_change_flags(net
, (unsigned) new_flags
);
193 static ssize_t
store_flags(struct class_device
*dev
, const char *buf
, size_t len
)
195 return netdev_store(dev
, buf
, len
, change_flags
);
198 NETDEVICE_SHOW(tx_queue_len
, fmt_ulong
);
200 static int change_tx_queue_len(struct net_device
*net
, unsigned long new_len
)
202 net
->tx_queue_len
= new_len
;
206 static ssize_t
store_tx_queue_len(struct class_device
*dev
, const char *buf
, size_t len
)
208 return netdev_store(dev
, buf
, len
, change_tx_queue_len
);
211 NETDEVICE_SHOW(weight
, fmt_dec
);
213 static int change_weight(struct net_device
*net
, unsigned long new_weight
)
215 net
->weight
= new_weight
;
219 static ssize_t
store_weight(struct class_device
*dev
, const char *buf
, size_t len
)
221 return netdev_store(dev
, buf
, len
, change_weight
);
224 static struct class_device_attribute net_class_attributes
[] = {
225 __ATTR(addr_len
, S_IRUGO
, show_addr_len
, NULL
),
226 __ATTR(iflink
, S_IRUGO
, show_iflink
, NULL
),
227 __ATTR(ifindex
, S_IRUGO
, show_ifindex
, NULL
),
228 __ATTR(features
, S_IRUGO
, show_features
, NULL
),
229 __ATTR(type
, S_IRUGO
, show_type
, NULL
),
230 __ATTR(link_mode
, S_IRUGO
, show_link_mode
, NULL
),
231 __ATTR(address
, S_IRUGO
, show_address
, NULL
),
232 __ATTR(broadcast
, S_IRUGO
, show_broadcast
, NULL
),
233 __ATTR(carrier
, S_IRUGO
, show_carrier
, NULL
),
234 __ATTR(dormant
, S_IRUGO
, show_dormant
, NULL
),
235 __ATTR(operstate
, S_IRUGO
, show_operstate
, NULL
),
236 __ATTR(mtu
, S_IRUGO
| S_IWUSR
, show_mtu
, store_mtu
),
237 __ATTR(flags
, S_IRUGO
| S_IWUSR
, show_flags
, store_flags
),
238 __ATTR(tx_queue_len
, S_IRUGO
| S_IWUSR
, show_tx_queue_len
,
240 __ATTR(weight
, S_IRUGO
| S_IWUSR
, show_weight
, store_weight
),
244 /* Show a given an attribute in the statistics group */
245 static ssize_t
netstat_show(const struct class_device
*cd
, char *buf
,
246 unsigned long offset
)
248 struct net_device
*dev
= to_net_dev(cd
);
249 struct net_device_stats
*stats
;
250 ssize_t ret
= -EINVAL
;
252 if (offset
> sizeof(struct net_device_stats
) ||
253 offset
% sizeof(unsigned long) != 0)
256 read_lock(&dev_base_lock
);
257 if (dev_isalive(dev
) && dev
->get_stats
&&
258 (stats
= (*dev
->get_stats
)(dev
)))
259 ret
= sprintf(buf
, fmt_ulong
,
260 *(unsigned long *)(((u8
*) stats
) + offset
));
262 read_unlock(&dev_base_lock
);
266 /* generate a read-only statistics attribute */
267 #define NETSTAT_ENTRY(name) \
268 static ssize_t show_##name(struct class_device *cd, char *buf) \
270 return netstat_show(cd, buf, \
271 offsetof(struct net_device_stats, name)); \
273 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
275 NETSTAT_ENTRY(rx_packets
);
276 NETSTAT_ENTRY(tx_packets
);
277 NETSTAT_ENTRY(rx_bytes
);
278 NETSTAT_ENTRY(tx_bytes
);
279 NETSTAT_ENTRY(rx_errors
);
280 NETSTAT_ENTRY(tx_errors
);
281 NETSTAT_ENTRY(rx_dropped
);
282 NETSTAT_ENTRY(tx_dropped
);
283 NETSTAT_ENTRY(multicast
);
284 NETSTAT_ENTRY(collisions
);
285 NETSTAT_ENTRY(rx_length_errors
);
286 NETSTAT_ENTRY(rx_over_errors
);
287 NETSTAT_ENTRY(rx_crc_errors
);
288 NETSTAT_ENTRY(rx_frame_errors
);
289 NETSTAT_ENTRY(rx_fifo_errors
);
290 NETSTAT_ENTRY(rx_missed_errors
);
291 NETSTAT_ENTRY(tx_aborted_errors
);
292 NETSTAT_ENTRY(tx_carrier_errors
);
293 NETSTAT_ENTRY(tx_fifo_errors
);
294 NETSTAT_ENTRY(tx_heartbeat_errors
);
295 NETSTAT_ENTRY(tx_window_errors
);
296 NETSTAT_ENTRY(rx_compressed
);
297 NETSTAT_ENTRY(tx_compressed
);
299 static struct attribute
*netstat_attrs
[] = {
300 &class_device_attr_rx_packets
.attr
,
301 &class_device_attr_tx_packets
.attr
,
302 &class_device_attr_rx_bytes
.attr
,
303 &class_device_attr_tx_bytes
.attr
,
304 &class_device_attr_rx_errors
.attr
,
305 &class_device_attr_tx_errors
.attr
,
306 &class_device_attr_rx_dropped
.attr
,
307 &class_device_attr_tx_dropped
.attr
,
308 &class_device_attr_multicast
.attr
,
309 &class_device_attr_collisions
.attr
,
310 &class_device_attr_rx_length_errors
.attr
,
311 &class_device_attr_rx_over_errors
.attr
,
312 &class_device_attr_rx_crc_errors
.attr
,
313 &class_device_attr_rx_frame_errors
.attr
,
314 &class_device_attr_rx_fifo_errors
.attr
,
315 &class_device_attr_rx_missed_errors
.attr
,
316 &class_device_attr_tx_aborted_errors
.attr
,
317 &class_device_attr_tx_carrier_errors
.attr
,
318 &class_device_attr_tx_fifo_errors
.attr
,
319 &class_device_attr_tx_heartbeat_errors
.attr
,
320 &class_device_attr_tx_window_errors
.attr
,
321 &class_device_attr_rx_compressed
.attr
,
322 &class_device_attr_tx_compressed
.attr
,
327 static struct attribute_group netstat_group
= {
328 .name
= "statistics",
329 .attrs
= netstat_attrs
,
333 /* helper function that does all the locking etc for wireless stats */
334 static ssize_t
wireless_show(struct class_device
*cd
, char *buf
,
335 ssize_t (*format
)(const struct iw_statistics
*,
338 struct net_device
*dev
= to_net_dev(cd
);
339 const struct iw_statistics
*iw
= NULL
;
340 ssize_t ret
= -EINVAL
;
342 read_lock(&dev_base_lock
);
343 if (dev_isalive(dev
)) {
344 if(dev
->wireless_handlers
&&
345 dev
->wireless_handlers
->get_wireless_stats
)
346 iw
= dev
->wireless_handlers
->get_wireless_stats(dev
);
348 ret
= (*format
)(iw
, buf
);
350 read_unlock(&dev_base_lock
);
355 /* show function template for wireless fields */
356 #define WIRELESS_SHOW(name, field, format_string) \
357 static ssize_t format_iw_##name(const struct iw_statistics *iw, char *buf) \
359 return sprintf(buf, format_string, iw->field); \
361 static ssize_t show_iw_##name(struct class_device *cd, char *buf) \
363 return wireless_show(cd, buf, format_iw_##name); \
365 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL)
367 WIRELESS_SHOW(status
, status
, fmt_hex
);
368 WIRELESS_SHOW(link
, qual
.qual
, fmt_dec
);
369 WIRELESS_SHOW(level
, qual
.level
, fmt_dec
);
370 WIRELESS_SHOW(noise
, qual
.noise
, fmt_dec
);
371 WIRELESS_SHOW(nwid
, discard
.nwid
, fmt_dec
);
372 WIRELESS_SHOW(crypt
, discard
.code
, fmt_dec
);
373 WIRELESS_SHOW(fragment
, discard
.fragment
, fmt_dec
);
374 WIRELESS_SHOW(misc
, discard
.misc
, fmt_dec
);
375 WIRELESS_SHOW(retries
, discard
.retries
, fmt_dec
);
376 WIRELESS_SHOW(beacon
, miss
.beacon
, fmt_dec
);
378 static struct attribute
*wireless_attrs
[] = {
379 &class_device_attr_status
.attr
,
380 &class_device_attr_link
.attr
,
381 &class_device_attr_level
.attr
,
382 &class_device_attr_noise
.attr
,
383 &class_device_attr_nwid
.attr
,
384 &class_device_attr_crypt
.attr
,
385 &class_device_attr_fragment
.attr
,
386 &class_device_attr_retries
.attr
,
387 &class_device_attr_misc
.attr
,
388 &class_device_attr_beacon
.attr
,
392 static struct attribute_group wireless_group
= {
394 .attrs
= wireless_attrs
,
398 #ifdef CONFIG_HOTPLUG
399 static int netdev_uevent(struct class_device
*cd
, char **envp
,
400 int num_envp
, char *buf
, int size
)
402 struct net_device
*dev
= to_net_dev(cd
);
406 /* pass interface to uevent. */
408 n
= snprintf(buf
, size
, "INTERFACE=%s", dev
->name
) + 1;
412 if ((size
<= 0) || (i
>= num_envp
))
421 * netdev_release -- destroy and free a dead device.
422 * Called when last reference to class_device kobject is gone.
424 static void netdev_release(struct class_device
*cd
)
426 struct net_device
*dev
427 = container_of(cd
, struct net_device
, class_dev
);
429 BUG_ON(dev
->reg_state
!= NETREG_RELEASED
);
431 kfree((char *)dev
- dev
->padded
);
434 static struct class net_class
= {
436 .release
= netdev_release
,
437 .class_dev_attrs
= net_class_attributes
,
438 #ifdef CONFIG_HOTPLUG
439 .uevent
= netdev_uevent
,
443 void netdev_unregister_sysfs(struct net_device
* net
)
445 class_device_del(&(net
->class_dev
));
448 /* Create sysfs entries for network device. */
449 int netdev_register_sysfs(struct net_device
*net
)
451 struct class_device
*class_dev
= &(net
->class_dev
);
452 struct attribute_group
**groups
= net
->sysfs_groups
;
454 class_device_initialize(class_dev
);
455 class_dev
->class = &net_class
;
456 class_dev
->class_data
= net
;
457 class_dev
->groups
= groups
;
459 BUILD_BUG_ON(BUS_ID_SIZE
< IFNAMSIZ
);
460 strlcpy(class_dev
->class_id
, net
->name
, BUS_ID_SIZE
);
463 *groups
++ = &netstat_group
;
466 if (net
->wireless_handlers
&& net
->wireless_handlers
->get_wireless_stats
)
467 *groups
++ = &wireless_group
;
470 return class_device_add(class_dev
);
473 int netdev_sysfs_init(void)
475 return class_register(&net_class
);