wext: refactor
[linux-2.6.git] / net / core / net-sysfs.c
1 /*
2  * net-sysfs.c - network device class and attributes
3  *
4  * Copyright (c) 2003 Stephen Hemminger <shemminger@osdl.org>
5  *
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.
10  */
11
12 #include <linux/capability.h>
13 #include <linux/kernel.h>
14 #include <linux/netdevice.h>
15 #include <linux/if_arp.h>
16 #include <net/sock.h>
17 #include <linux/rtnetlink.h>
18 #include <linux/wireless.h>
19 #include <net/wext.h>
20
21 #include "net-sysfs.h"
22
23 #ifdef CONFIG_SYSFS
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";
28
29 static inline int dev_isalive(const struct net_device *dev)
30 {
31         return dev->reg_state <= NETREG_REGISTERED;
32 }
33
34 /* use same locking rules as GIF* ioctl's */
35 static ssize_t netdev_show(const struct device *dev,
36                            struct device_attribute *attr, char *buf,
37                            ssize_t (*format)(const struct net_device *, char *))
38 {
39         struct net_device *net = to_net_dev(dev);
40         ssize_t ret = -EINVAL;
41
42         read_lock(&dev_base_lock);
43         if (dev_isalive(net))
44                 ret = (*format)(net, buf);
45         read_unlock(&dev_base_lock);
46
47         return ret;
48 }
49
50 /* generate a show function for simple field */
51 #define NETDEVICE_SHOW(field, format_string)                            \
52 static ssize_t format_##field(const struct net_device *net, char *buf)  \
53 {                                                                       \
54         return sprintf(buf, format_string, net->field);                 \
55 }                                                                       \
56 static ssize_t show_##field(struct device *dev,                         \
57                             struct device_attribute *attr, char *buf)   \
58 {                                                                       \
59         return netdev_show(dev, attr, buf, format_##field);             \
60 }
61
62
63 /* use same locking and permission rules as SIF* ioctl's */
64 static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
65                             const char *buf, size_t len,
66                             int (*set)(struct net_device *, unsigned long))
67 {
68         struct net_device *net = to_net_dev(dev);
69         char *endp;
70         unsigned long new;
71         int ret = -EINVAL;
72
73         if (!capable(CAP_NET_ADMIN))
74                 return -EPERM;
75
76         new = simple_strtoul(buf, &endp, 0);
77         if (endp == buf)
78                 goto err;
79
80         if (!rtnl_trylock())
81                 return restart_syscall();
82
83         if (dev_isalive(net)) {
84                 if ((ret = (*set)(net, new)) == 0)
85                         ret = len;
86         }
87         rtnl_unlock();
88  err:
89         return ret;
90 }
91
92 NETDEVICE_SHOW(dev_id, fmt_hex);
93 NETDEVICE_SHOW(addr_len, fmt_dec);
94 NETDEVICE_SHOW(iflink, fmt_dec);
95 NETDEVICE_SHOW(ifindex, fmt_dec);
96 NETDEVICE_SHOW(features, fmt_long_hex);
97 NETDEVICE_SHOW(type, fmt_dec);
98 NETDEVICE_SHOW(link_mode, fmt_dec);
99
100 /* use same locking rules as GIFHWADDR ioctl's */
101 static ssize_t show_address(struct device *dev, struct device_attribute *attr,
102                             char *buf)
103 {
104         struct net_device *net = to_net_dev(dev);
105         ssize_t ret = -EINVAL;
106
107         read_lock(&dev_base_lock);
108         if (dev_isalive(net))
109                 ret = sysfs_format_mac(buf, net->dev_addr, net->addr_len);
110         read_unlock(&dev_base_lock);
111         return ret;
112 }
113
114 static ssize_t show_broadcast(struct device *dev,
115                             struct device_attribute *attr, char *buf)
116 {
117         struct net_device *net = to_net_dev(dev);
118         if (dev_isalive(net))
119                 return sysfs_format_mac(buf, net->broadcast, net->addr_len);
120         return -EINVAL;
121 }
122
123 static ssize_t show_carrier(struct device *dev,
124                             struct device_attribute *attr, char *buf)
125 {
126         struct net_device *netdev = to_net_dev(dev);
127         if (netif_running(netdev)) {
128                 return sprintf(buf, fmt_dec, !!netif_carrier_ok(netdev));
129         }
130         return -EINVAL;
131 }
132
133 static ssize_t show_speed(struct device *dev,
134                           struct device_attribute *attr, char *buf)
135 {
136         struct net_device *netdev = to_net_dev(dev);
137         int ret = -EINVAL;
138
139         if (!rtnl_trylock())
140                 return restart_syscall();
141
142         if (netif_running(netdev) && netdev->ethtool_ops->get_settings) {
143                 struct ethtool_cmd cmd = { ETHTOOL_GSET };
144
145                 if (!netdev->ethtool_ops->get_settings(netdev, &cmd))
146                         ret = sprintf(buf, fmt_dec, ethtool_cmd_speed(&cmd));
147         }
148         rtnl_unlock();
149         return ret;
150 }
151
152 static ssize_t show_duplex(struct device *dev,
153                            struct device_attribute *attr, char *buf)
154 {
155         struct net_device *netdev = to_net_dev(dev);
156         int ret = -EINVAL;
157
158         if (!rtnl_trylock())
159                 return restart_syscall();
160
161         if (netif_running(netdev) && netdev->ethtool_ops->get_settings) {
162                 struct ethtool_cmd cmd = { ETHTOOL_GSET };
163
164                 if (!netdev->ethtool_ops->get_settings(netdev, &cmd))
165                         ret = sprintf(buf, "%s\n", cmd.duplex ? "full" : "half");
166         }
167         rtnl_unlock();
168         return ret;
169 }
170
171 static ssize_t show_dormant(struct device *dev,
172                             struct device_attribute *attr, char *buf)
173 {
174         struct net_device *netdev = to_net_dev(dev);
175
176         if (netif_running(netdev))
177                 return sprintf(buf, fmt_dec, !!netif_dormant(netdev));
178
179         return -EINVAL;
180 }
181
182 static const char *const operstates[] = {
183         "unknown",
184         "notpresent", /* currently unused */
185         "down",
186         "lowerlayerdown",
187         "testing", /* currently unused */
188         "dormant",
189         "up"
190 };
191
192 static ssize_t show_operstate(struct device *dev,
193                               struct device_attribute *attr, char *buf)
194 {
195         const struct net_device *netdev = to_net_dev(dev);
196         unsigned char operstate;
197
198         read_lock(&dev_base_lock);
199         operstate = netdev->operstate;
200         if (!netif_running(netdev))
201                 operstate = IF_OPER_DOWN;
202         read_unlock(&dev_base_lock);
203
204         if (operstate >= ARRAY_SIZE(operstates))
205                 return -EINVAL; /* should not happen */
206
207         return sprintf(buf, "%s\n", operstates[operstate]);
208 }
209
210 /* read-write attributes */
211 NETDEVICE_SHOW(mtu, fmt_dec);
212
213 static int change_mtu(struct net_device *net, unsigned long new_mtu)
214 {
215         return dev_set_mtu(net, (int) new_mtu);
216 }
217
218 static ssize_t store_mtu(struct device *dev, struct device_attribute *attr,
219                          const char *buf, size_t len)
220 {
221         return netdev_store(dev, attr, buf, len, change_mtu);
222 }
223
224 NETDEVICE_SHOW(flags, fmt_hex);
225
226 static int change_flags(struct net_device *net, unsigned long new_flags)
227 {
228         return dev_change_flags(net, (unsigned) new_flags);
229 }
230
231 static ssize_t store_flags(struct device *dev, struct device_attribute *attr,
232                            const char *buf, size_t len)
233 {
234         return netdev_store(dev, attr, buf, len, change_flags);
235 }
236
237 NETDEVICE_SHOW(tx_queue_len, fmt_ulong);
238
239 static int change_tx_queue_len(struct net_device *net, unsigned long new_len)
240 {
241         net->tx_queue_len = new_len;
242         return 0;
243 }
244
245 static ssize_t store_tx_queue_len(struct device *dev,
246                                   struct device_attribute *attr,
247                                   const char *buf, size_t len)
248 {
249         return netdev_store(dev, attr, buf, len, change_tx_queue_len);
250 }
251
252 static ssize_t store_ifalias(struct device *dev, struct device_attribute *attr,
253                              const char *buf, size_t len)
254 {
255         struct net_device *netdev = to_net_dev(dev);
256         size_t count = len;
257         ssize_t ret;
258
259         if (!capable(CAP_NET_ADMIN))
260                 return -EPERM;
261
262         /* ignore trailing newline */
263         if (len >  0 && buf[len - 1] == '\n')
264                 --count;
265
266         if (!rtnl_trylock())
267                 return restart_syscall();
268         ret = dev_set_alias(netdev, buf, count);
269         rtnl_unlock();
270
271         return ret < 0 ? ret : len;
272 }
273
274 static ssize_t show_ifalias(struct device *dev,
275                             struct device_attribute *attr, char *buf)
276 {
277         const struct net_device *netdev = to_net_dev(dev);
278         ssize_t ret = 0;
279
280         if (!rtnl_trylock())
281                 return restart_syscall();
282         if (netdev->ifalias)
283                 ret = sprintf(buf, "%s\n", netdev->ifalias);
284         rtnl_unlock();
285         return ret;
286 }
287
288 static struct device_attribute net_class_attributes[] = {
289         __ATTR(addr_len, S_IRUGO, show_addr_len, NULL),
290         __ATTR(dev_id, S_IRUGO, show_dev_id, NULL),
291         __ATTR(ifalias, S_IRUGO | S_IWUSR, show_ifalias, store_ifalias),
292         __ATTR(iflink, S_IRUGO, show_iflink, NULL),
293         __ATTR(ifindex, S_IRUGO, show_ifindex, NULL),
294         __ATTR(features, S_IRUGO, show_features, NULL),
295         __ATTR(type, S_IRUGO, show_type, NULL),
296         __ATTR(link_mode, S_IRUGO, show_link_mode, NULL),
297         __ATTR(address, S_IRUGO, show_address, NULL),
298         __ATTR(broadcast, S_IRUGO, show_broadcast, NULL),
299         __ATTR(carrier, S_IRUGO, show_carrier, NULL),
300         __ATTR(speed, S_IRUGO, show_speed, NULL),
301         __ATTR(duplex, S_IRUGO, show_duplex, NULL),
302         __ATTR(dormant, S_IRUGO, show_dormant, NULL),
303         __ATTR(operstate, S_IRUGO, show_operstate, NULL),
304         __ATTR(mtu, S_IRUGO | S_IWUSR, show_mtu, store_mtu),
305         __ATTR(flags, S_IRUGO | S_IWUSR, show_flags, store_flags),
306         __ATTR(tx_queue_len, S_IRUGO | S_IWUSR, show_tx_queue_len,
307                store_tx_queue_len),
308         {}
309 };
310
311 /* Show a given an attribute in the statistics group */
312 static ssize_t netstat_show(const struct device *d,
313                             struct device_attribute *attr, char *buf,
314                             unsigned long offset)
315 {
316         struct net_device *dev = to_net_dev(d);
317         ssize_t ret = -EINVAL;
318
319         WARN_ON(offset > sizeof(struct net_device_stats) ||
320                         offset % sizeof(unsigned long) != 0);
321
322         read_lock(&dev_base_lock);
323         if (dev_isalive(dev)) {
324                 const struct net_device_stats *stats = dev_get_stats(dev);
325                 ret = sprintf(buf, fmt_ulong,
326                               *(unsigned long *)(((u8 *) stats) + offset));
327         }
328         read_unlock(&dev_base_lock);
329         return ret;
330 }
331
332 /* generate a read-only statistics attribute */
333 #define NETSTAT_ENTRY(name)                                             \
334 static ssize_t show_##name(struct device *d,                            \
335                            struct device_attribute *attr, char *buf)    \
336 {                                                                       \
337         return netstat_show(d, attr, buf,                               \
338                             offsetof(struct net_device_stats, name));   \
339 }                                                                       \
340 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
341
342 NETSTAT_ENTRY(rx_packets);
343 NETSTAT_ENTRY(tx_packets);
344 NETSTAT_ENTRY(rx_bytes);
345 NETSTAT_ENTRY(tx_bytes);
346 NETSTAT_ENTRY(rx_errors);
347 NETSTAT_ENTRY(tx_errors);
348 NETSTAT_ENTRY(rx_dropped);
349 NETSTAT_ENTRY(tx_dropped);
350 NETSTAT_ENTRY(multicast);
351 NETSTAT_ENTRY(collisions);
352 NETSTAT_ENTRY(rx_length_errors);
353 NETSTAT_ENTRY(rx_over_errors);
354 NETSTAT_ENTRY(rx_crc_errors);
355 NETSTAT_ENTRY(rx_frame_errors);
356 NETSTAT_ENTRY(rx_fifo_errors);
357 NETSTAT_ENTRY(rx_missed_errors);
358 NETSTAT_ENTRY(tx_aborted_errors);
359 NETSTAT_ENTRY(tx_carrier_errors);
360 NETSTAT_ENTRY(tx_fifo_errors);
361 NETSTAT_ENTRY(tx_heartbeat_errors);
362 NETSTAT_ENTRY(tx_window_errors);
363 NETSTAT_ENTRY(rx_compressed);
364 NETSTAT_ENTRY(tx_compressed);
365
366 static struct attribute *netstat_attrs[] = {
367         &dev_attr_rx_packets.attr,
368         &dev_attr_tx_packets.attr,
369         &dev_attr_rx_bytes.attr,
370         &dev_attr_tx_bytes.attr,
371         &dev_attr_rx_errors.attr,
372         &dev_attr_tx_errors.attr,
373         &dev_attr_rx_dropped.attr,
374         &dev_attr_tx_dropped.attr,
375         &dev_attr_multicast.attr,
376         &dev_attr_collisions.attr,
377         &dev_attr_rx_length_errors.attr,
378         &dev_attr_rx_over_errors.attr,
379         &dev_attr_rx_crc_errors.attr,
380         &dev_attr_rx_frame_errors.attr,
381         &dev_attr_rx_fifo_errors.attr,
382         &dev_attr_rx_missed_errors.attr,
383         &dev_attr_tx_aborted_errors.attr,
384         &dev_attr_tx_carrier_errors.attr,
385         &dev_attr_tx_fifo_errors.attr,
386         &dev_attr_tx_heartbeat_errors.attr,
387         &dev_attr_tx_window_errors.attr,
388         &dev_attr_rx_compressed.attr,
389         &dev_attr_tx_compressed.attr,
390         NULL
391 };
392
393
394 static struct attribute_group netstat_group = {
395         .name  = "statistics",
396         .attrs  = netstat_attrs,
397 };
398
399 #ifdef CONFIG_WIRELESS_EXT_SYSFS
400 /* helper function that does all the locking etc for wireless stats */
401 static ssize_t wireless_show(struct device *d, char *buf,
402                              ssize_t (*format)(const struct iw_statistics *,
403                                                char *))
404 {
405         struct net_device *dev = to_net_dev(d);
406         const struct iw_statistics *iw;
407         ssize_t ret = -EINVAL;
408
409         read_lock(&dev_base_lock);
410         if (dev_isalive(dev)) {
411                 iw = get_wireless_stats(dev);
412                 if (iw)
413                         ret = (*format)(iw, buf);
414         }
415         read_unlock(&dev_base_lock);
416
417         return ret;
418 }
419
420 /* show function template for wireless fields */
421 #define WIRELESS_SHOW(name, field, format_string)                       \
422 static ssize_t format_iw_##name(const struct iw_statistics *iw, char *buf) \
423 {                                                                       \
424         return sprintf(buf, format_string, iw->field);                  \
425 }                                                                       \
426 static ssize_t show_iw_##name(struct device *d,                         \
427                               struct device_attribute *attr, char *buf) \
428 {                                                                       \
429         return wireless_show(d, buf, format_iw_##name);                 \
430 }                                                                       \
431 static DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL)
432
433 WIRELESS_SHOW(status, status, fmt_hex);
434 WIRELESS_SHOW(link, qual.qual, fmt_dec);
435 WIRELESS_SHOW(level, qual.level, fmt_dec);
436 WIRELESS_SHOW(noise, qual.noise, fmt_dec);
437 WIRELESS_SHOW(nwid, discard.nwid, fmt_dec);
438 WIRELESS_SHOW(crypt, discard.code, fmt_dec);
439 WIRELESS_SHOW(fragment, discard.fragment, fmt_dec);
440 WIRELESS_SHOW(misc, discard.misc, fmt_dec);
441 WIRELESS_SHOW(retries, discard.retries, fmt_dec);
442 WIRELESS_SHOW(beacon, miss.beacon, fmt_dec);
443
444 static struct attribute *wireless_attrs[] = {
445         &dev_attr_status.attr,
446         &dev_attr_link.attr,
447         &dev_attr_level.attr,
448         &dev_attr_noise.attr,
449         &dev_attr_nwid.attr,
450         &dev_attr_crypt.attr,
451         &dev_attr_fragment.attr,
452         &dev_attr_retries.attr,
453         &dev_attr_misc.attr,
454         &dev_attr_beacon.attr,
455         NULL
456 };
457
458 static struct attribute_group wireless_group = {
459         .name = "wireless",
460         .attrs = wireless_attrs,
461 };
462 #endif
463
464 #endif /* CONFIG_SYSFS */
465
466 #ifdef CONFIG_HOTPLUG
467 static int netdev_uevent(struct device *d, struct kobj_uevent_env *env)
468 {
469         struct net_device *dev = to_net_dev(d);
470         int retval;
471
472         if (!net_eq(dev_net(dev), &init_net))
473                 return 0;
474
475         /* pass interface to uevent. */
476         retval = add_uevent_var(env, "INTERFACE=%s", dev->name);
477         if (retval)
478                 goto exit;
479
480         /* pass ifindex to uevent.
481          * ifindex is useful as it won't change (interface name may change)
482          * and is what RtNetlink uses natively. */
483         retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex);
484
485 exit:
486         return retval;
487 }
488 #endif
489
490 /*
491  *      netdev_release -- destroy and free a dead device.
492  *      Called when last reference to device kobject is gone.
493  */
494 static void netdev_release(struct device *d)
495 {
496         struct net_device *dev = to_net_dev(d);
497
498         BUG_ON(dev->reg_state != NETREG_RELEASED);
499
500         kfree(dev->ifalias);
501         kfree((char *)dev - dev->padded);
502 }
503
504 static struct class net_class = {
505         .name = "net",
506         .dev_release = netdev_release,
507 #ifdef CONFIG_SYSFS
508         .dev_attrs = net_class_attributes,
509 #endif /* CONFIG_SYSFS */
510 #ifdef CONFIG_HOTPLUG
511         .dev_uevent = netdev_uevent,
512 #endif
513 };
514
515 /* Delete sysfs entries but hold kobject reference until after all
516  * netdev references are gone.
517  */
518 void netdev_unregister_kobject(struct net_device * net)
519 {
520         struct device *dev = &(net->dev);
521
522         kobject_get(&dev->kobj);
523
524         if (dev_net(net) != &init_net)
525                 return;
526
527         device_del(dev);
528 }
529
530 /* Create sysfs entries for network device. */
531 int netdev_register_kobject(struct net_device *net)
532 {
533         struct device *dev = &(net->dev);
534         const struct attribute_group **groups = net->sysfs_groups;
535
536         dev->class = &net_class;
537         dev->platform_data = net;
538         dev->groups = groups;
539
540         dev_set_name(dev, "%s", net->name);
541
542 #ifdef CONFIG_SYSFS
543         *groups++ = &netstat_group;
544
545 #ifdef CONFIG_WIRELESS_EXT_SYSFS
546         if (net->ieee80211_ptr)
547                 *groups++ = &wireless_group;
548 #ifdef CONFIG_WIRELESS_EXT
549         else if (net->wireless_handlers)
550                 *groups++ = &wireless_group;
551 #endif
552 #endif
553 #endif /* CONFIG_SYSFS */
554
555         if (dev_net(net) != &init_net)
556                 return 0;
557
558         return device_add(dev);
559 }
560
561 int netdev_class_create_file(struct class_attribute *class_attr)
562 {
563         return class_create_file(&net_class, class_attr);
564 }
565
566 void netdev_class_remove_file(struct class_attribute *class_attr)
567 {
568         class_remove_file(&net_class, class_attr);
569 }
570
571 EXPORT_SYMBOL(netdev_class_create_file);
572 EXPORT_SYMBOL(netdev_class_remove_file);
573
574 void netdev_initialize_kobject(struct net_device *net)
575 {
576         struct device *device = &(net->dev);
577         device_initialize(device);
578 }
579
580 int netdev_kobject_init(void)
581 {
582         return class_register(&net_class);
583 }