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/config.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>
20 #define to_class_dev(obj) container_of(obj,struct class_device,kobj)
21 #define to_net_dev(class) container_of(class, struct net_device, class_dev)
23 static const char fmt_hex
[] = "%#x\n";
24 static const char fmt_long_hex
[] = "%#lx\n";
25 static const char fmt_dec
[] = "%d\n";
26 static const char fmt_ulong
[] = "%lu\n";
28 static inline int dev_isalive(const struct net_device
*dev
)
30 return dev
->reg_state
== NETREG_REGISTERED
;
33 /* use same locking rules as GIF* ioctl's */
34 static ssize_t
netdev_show(const struct class_device
*cd
, char *buf
,
35 ssize_t (*format
)(const struct net_device
*, char *))
37 struct net_device
*net
= to_net_dev(cd
);
38 ssize_t ret
= -EINVAL
;
40 read_lock(&dev_base_lock
);
42 ret
= (*format
)(net
, buf
);
43 read_unlock(&dev_base_lock
);
48 /* generate a show function for simple field */
49 #define NETDEVICE_SHOW(field, format_string) \
50 static ssize_t format_##field(const struct net_device *net, char *buf) \
52 return sprintf(buf, format_string, net->field); \
54 static ssize_t show_##field(struct class_device *cd, char *buf) \
56 return netdev_show(cd, buf, format_##field); \
60 /* use same locking and permission rules as SIF* ioctl's */
61 static ssize_t
netdev_store(struct class_device
*dev
,
62 const char *buf
, size_t len
,
63 int (*set
)(struct net_device
*, unsigned long))
65 struct net_device
*net
= to_net_dev(dev
);
70 if (!capable(CAP_NET_ADMIN
))
73 new = simple_strtoul(buf
, &endp
, 0);
78 if (dev_isalive(net
)) {
79 if ((ret
= (*set
)(net
, new)) == 0)
87 NETDEVICE_SHOW(addr_len
, fmt_dec
);
88 NETDEVICE_SHOW(iflink
, fmt_dec
);
89 NETDEVICE_SHOW(ifindex
, fmt_dec
);
90 NETDEVICE_SHOW(features
, fmt_long_hex
);
91 NETDEVICE_SHOW(type
, fmt_dec
);
93 /* use same locking rules as GIFHWADDR ioctl's */
94 static ssize_t
format_addr(char *buf
, const unsigned char *addr
, int len
)
99 for (i
= 0; i
< len
; i
++)
100 cp
+= sprintf(cp
, "%02x%c", addr
[i
],
101 i
== (len
- 1) ? '\n' : ':');
105 static ssize_t
show_address(struct class_device
*dev
, char *buf
)
107 struct net_device
*net
= to_net_dev(dev
);
108 ssize_t ret
= -EINVAL
;
110 read_lock(&dev_base_lock
);
111 if (dev_isalive(net
))
112 ret
= format_addr(buf
, net
->dev_addr
, net
->addr_len
);
113 read_unlock(&dev_base_lock
);
117 static ssize_t
show_broadcast(struct class_device
*dev
, char *buf
)
119 struct net_device
*net
= to_net_dev(dev
);
120 if (dev_isalive(net
))
121 return format_addr(buf
, net
->broadcast
, net
->addr_len
);
125 static ssize_t
show_carrier(struct class_device
*dev
, 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 /* read-write attributes */
135 NETDEVICE_SHOW(mtu
, fmt_dec
);
137 static int change_mtu(struct net_device
*net
, unsigned long new_mtu
)
139 return dev_set_mtu(net
, (int) new_mtu
);
142 static ssize_t
store_mtu(struct class_device
*dev
, const char *buf
, size_t len
)
144 return netdev_store(dev
, buf
, len
, change_mtu
);
147 NETDEVICE_SHOW(flags
, fmt_hex
);
149 static int change_flags(struct net_device
*net
, unsigned long new_flags
)
151 return dev_change_flags(net
, (unsigned) new_flags
);
154 static ssize_t
store_flags(struct class_device
*dev
, const char *buf
, size_t len
)
156 return netdev_store(dev
, buf
, len
, change_flags
);
159 NETDEVICE_SHOW(tx_queue_len
, fmt_ulong
);
161 static int change_tx_queue_len(struct net_device
*net
, unsigned long new_len
)
163 net
->tx_queue_len
= new_len
;
167 static ssize_t
store_tx_queue_len(struct class_device
*dev
, const char *buf
, size_t len
)
169 return netdev_store(dev
, buf
, len
, change_tx_queue_len
);
172 NETDEVICE_SHOW(weight
, fmt_dec
);
174 static int change_weight(struct net_device
*net
, unsigned long new_weight
)
176 net
->weight
= new_weight
;
180 static ssize_t
store_weight(struct class_device
*dev
, const char *buf
, size_t len
)
182 return netdev_store(dev
, buf
, len
, change_weight
);
185 static struct class_device_attribute net_class_attributes
[] = {
186 __ATTR(addr_len
, S_IRUGO
, show_addr_len
, NULL
),
187 __ATTR(iflink
, S_IRUGO
, show_iflink
, NULL
),
188 __ATTR(ifindex
, S_IRUGO
, show_ifindex
, NULL
),
189 __ATTR(features
, S_IRUGO
, show_features
, NULL
),
190 __ATTR(type
, S_IRUGO
, show_type
, NULL
),
191 __ATTR(address
, S_IRUGO
, show_address
, NULL
),
192 __ATTR(broadcast
, S_IRUGO
, show_broadcast
, NULL
),
193 __ATTR(carrier
, S_IRUGO
, show_carrier
, NULL
),
194 __ATTR(mtu
, S_IRUGO
| S_IWUSR
, show_mtu
, store_mtu
),
195 __ATTR(flags
, S_IRUGO
| S_IWUSR
, show_flags
, store_flags
),
196 __ATTR(tx_queue_len
, S_IRUGO
| S_IWUSR
, show_tx_queue_len
,
198 __ATTR(weight
, S_IRUGO
| S_IWUSR
, show_weight
, store_weight
),
202 /* Show a given an attribute in the statistics group */
203 static ssize_t
netstat_show(const struct class_device
*cd
, char *buf
,
204 unsigned long offset
)
206 struct net_device
*dev
= to_net_dev(cd
);
207 struct net_device_stats
*stats
;
208 ssize_t ret
= -EINVAL
;
210 if (offset
> sizeof(struct net_device_stats
) ||
211 offset
% sizeof(unsigned long) != 0)
214 read_lock(&dev_base_lock
);
215 if (dev_isalive(dev
) && dev
->get_stats
&&
216 (stats
= (*dev
->get_stats
)(dev
)))
217 ret
= sprintf(buf
, fmt_ulong
,
218 *(unsigned long *)(((u8
*) stats
) + offset
));
220 read_unlock(&dev_base_lock
);
224 /* generate a read-only statistics attribute */
225 #define NETSTAT_ENTRY(name) \
226 static ssize_t show_##name(struct class_device *cd, char *buf) \
228 return netstat_show(cd, buf, \
229 offsetof(struct net_device_stats, name)); \
231 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
233 NETSTAT_ENTRY(rx_packets
);
234 NETSTAT_ENTRY(tx_packets
);
235 NETSTAT_ENTRY(rx_bytes
);
236 NETSTAT_ENTRY(tx_bytes
);
237 NETSTAT_ENTRY(rx_errors
);
238 NETSTAT_ENTRY(tx_errors
);
239 NETSTAT_ENTRY(rx_dropped
);
240 NETSTAT_ENTRY(tx_dropped
);
241 NETSTAT_ENTRY(multicast
);
242 NETSTAT_ENTRY(collisions
);
243 NETSTAT_ENTRY(rx_length_errors
);
244 NETSTAT_ENTRY(rx_over_errors
);
245 NETSTAT_ENTRY(rx_crc_errors
);
246 NETSTAT_ENTRY(rx_frame_errors
);
247 NETSTAT_ENTRY(rx_fifo_errors
);
248 NETSTAT_ENTRY(rx_missed_errors
);
249 NETSTAT_ENTRY(tx_aborted_errors
);
250 NETSTAT_ENTRY(tx_carrier_errors
);
251 NETSTAT_ENTRY(tx_fifo_errors
);
252 NETSTAT_ENTRY(tx_heartbeat_errors
);
253 NETSTAT_ENTRY(tx_window_errors
);
254 NETSTAT_ENTRY(rx_compressed
);
255 NETSTAT_ENTRY(tx_compressed
);
257 static struct attribute
*netstat_attrs
[] = {
258 &class_device_attr_rx_packets
.attr
,
259 &class_device_attr_tx_packets
.attr
,
260 &class_device_attr_rx_bytes
.attr
,
261 &class_device_attr_tx_bytes
.attr
,
262 &class_device_attr_rx_errors
.attr
,
263 &class_device_attr_tx_errors
.attr
,
264 &class_device_attr_rx_dropped
.attr
,
265 &class_device_attr_tx_dropped
.attr
,
266 &class_device_attr_multicast
.attr
,
267 &class_device_attr_collisions
.attr
,
268 &class_device_attr_rx_length_errors
.attr
,
269 &class_device_attr_rx_over_errors
.attr
,
270 &class_device_attr_rx_crc_errors
.attr
,
271 &class_device_attr_rx_frame_errors
.attr
,
272 &class_device_attr_rx_fifo_errors
.attr
,
273 &class_device_attr_rx_missed_errors
.attr
,
274 &class_device_attr_tx_aborted_errors
.attr
,
275 &class_device_attr_tx_carrier_errors
.attr
,
276 &class_device_attr_tx_fifo_errors
.attr
,
277 &class_device_attr_tx_heartbeat_errors
.attr
,
278 &class_device_attr_tx_window_errors
.attr
,
279 &class_device_attr_rx_compressed
.attr
,
280 &class_device_attr_tx_compressed
.attr
,
285 static struct attribute_group netstat_group
= {
286 .name
= "statistics",
287 .attrs
= netstat_attrs
,
291 /* helper function that does all the locking etc for wireless stats */
292 static ssize_t
wireless_show(struct class_device
*cd
, char *buf
,
293 ssize_t (*format
)(const struct iw_statistics
*,
296 struct net_device
*dev
= to_net_dev(cd
);
297 const struct iw_statistics
*iw
;
298 ssize_t ret
= -EINVAL
;
300 read_lock(&dev_base_lock
);
301 if (dev_isalive(dev
) && dev
->get_wireless_stats
302 && (iw
= dev
->get_wireless_stats(dev
)) != NULL
)
303 ret
= (*format
)(iw
, buf
);
304 read_unlock(&dev_base_lock
);
309 /* show function template for wireless fields */
310 #define WIRELESS_SHOW(name, field, format_string) \
311 static ssize_t format_iw_##name(const struct iw_statistics *iw, char *buf) \
313 return sprintf(buf, format_string, iw->field); \
315 static ssize_t show_iw_##name(struct class_device *cd, char *buf) \
317 return wireless_show(cd, buf, format_iw_##name); \
319 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL)
321 WIRELESS_SHOW(status
, status
, fmt_hex
);
322 WIRELESS_SHOW(link
, qual
.qual
, fmt_dec
);
323 WIRELESS_SHOW(level
, qual
.level
, fmt_dec
);
324 WIRELESS_SHOW(noise
, qual
.noise
, fmt_dec
);
325 WIRELESS_SHOW(nwid
, discard
.nwid
, fmt_dec
);
326 WIRELESS_SHOW(crypt
, discard
.code
, fmt_dec
);
327 WIRELESS_SHOW(fragment
, discard
.fragment
, fmt_dec
);
328 WIRELESS_SHOW(misc
, discard
.misc
, fmt_dec
);
329 WIRELESS_SHOW(retries
, discard
.retries
, fmt_dec
);
330 WIRELESS_SHOW(beacon
, miss
.beacon
, fmt_dec
);
332 static struct attribute
*wireless_attrs
[] = {
333 &class_device_attr_status
.attr
,
334 &class_device_attr_link
.attr
,
335 &class_device_attr_level
.attr
,
336 &class_device_attr_noise
.attr
,
337 &class_device_attr_nwid
.attr
,
338 &class_device_attr_crypt
.attr
,
339 &class_device_attr_fragment
.attr
,
340 &class_device_attr_retries
.attr
,
341 &class_device_attr_misc
.attr
,
342 &class_device_attr_beacon
.attr
,
346 static struct attribute_group wireless_group
= {
348 .attrs
= wireless_attrs
,
352 #ifdef CONFIG_HOTPLUG
353 static int netdev_uevent(struct class_device
*cd
, char **envp
,
354 int num_envp
, char *buf
, int size
)
356 struct net_device
*dev
= to_net_dev(cd
);
360 /* pass interface to uevent. */
362 n
= snprintf(buf
, size
, "INTERFACE=%s", dev
->name
) + 1;
366 if ((size
<= 0) || (i
>= num_envp
))
375 * netdev_release -- destroy and free a dead device.
376 * Called when last reference to class_device kobject is gone.
378 static void netdev_release(struct class_device
*cd
)
380 struct net_device
*dev
381 = container_of(cd
, struct net_device
, class_dev
);
383 BUG_ON(dev
->reg_state
!= NETREG_RELEASED
);
385 kfree((char *)dev
- dev
->padded
);
388 static struct class net_class
= {
390 .release
= netdev_release
,
391 .class_dev_attrs
= net_class_attributes
,
392 #ifdef CONFIG_HOTPLUG
393 .uevent
= netdev_uevent
,
397 void netdev_unregister_sysfs(struct net_device
* net
)
399 struct class_device
* class_dev
= &(net
->class_dev
);
402 sysfs_remove_group(&class_dev
->kobj
, &netstat_group
);
405 if (net
->get_wireless_stats
)
406 sysfs_remove_group(&class_dev
->kobj
, &wireless_group
);
408 class_device_del(class_dev
);
412 /* Create sysfs entries for network device. */
413 int netdev_register_sysfs(struct net_device
*net
)
415 struct class_device
*class_dev
= &(net
->class_dev
);
418 class_dev
->class = &net_class
;
419 class_dev
->class_data
= net
;
421 strlcpy(class_dev
->class_id
, net
->name
, BUS_ID_SIZE
);
422 if ((ret
= class_device_register(class_dev
)))
425 if (net
->get_stats
&&
426 (ret
= sysfs_create_group(&class_dev
->kobj
, &netstat_group
)))
430 if (net
->get_wireless_stats
&&
431 (ret
= sysfs_create_group(&class_dev
->kobj
, &wireless_group
)))
437 sysfs_remove_group(&class_dev
->kobj
, &netstat_group
);
443 printk(KERN_WARNING
"%s: sysfs attribute registration failed %d\n",
445 class_device_unregister(class_dev
);
450 int netdev_sysfs_init(void)
452 return class_register(&net_class
);