[PARISC] Pretty print the name of the lba type on kernel boot
[linux-2.6/lfs.git] / net / core / net-sysfs.c
blobf47f319bb7dc2ae78b02e5f97f2d84519e686710
1 /*
2 * net-sysfs.c - network device class and attributes
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.
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/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);
42 if (dev_isalive(net))
43 ret = (*format)(net, buf);
44 read_unlock(&dev_base_lock);
46 return ret;
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) \
52 { \
53 return sprintf(buf, format_string, net->field); \
54 } \
55 static ssize_t show_##field(struct class_device *cd, char *buf) \
56 { \
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);
67 char *endp;
68 unsigned long new;
69 int ret = -EINVAL;
71 if (!capable(CAP_NET_ADMIN))
72 return -EPERM;
74 new = simple_strtoul(buf, &endp, 0);
75 if (endp == buf)
76 goto err;
78 rtnl_lock();
79 if (dev_isalive(net)) {
80 if ((ret = (*set)(net, new)) == 0)
81 ret = len;
83 rtnl_unlock();
84 err:
85 return ret;
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)
98 int i;
99 char *cp = buf;
101 for (i = 0; i < len; i++)
102 cp += sprintf(cp, "%02x%c", addr[i],
103 i == (len - 1) ? '\n' : ':');
104 return cp - buf;
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);
116 return ret;
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);
124 return -EINVAL;
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));
133 return -EINVAL;
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));
143 return -EINVAL;
146 static const char *operstates[] = {
147 "unknown",
148 "notpresent", /* currently unused */
149 "down",
150 "lowerlayerdown",
151 "testing", /* currently unused */
152 "dormant",
153 "up"
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;
203 return 0;
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;
216 return 0;
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,
239 store_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)
254 WARN_ON(1);
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);
263 return ret;
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,
323 NULL
327 static struct attribute_group netstat_group = {
328 .name = "statistics",
329 .attrs = netstat_attrs,
332 #ifdef WIRELESS_EXT
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 *,
336 char *))
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);
347 if (iw != NULL)
348 ret = (*format)(iw, buf);
350 read_unlock(&dev_base_lock);
352 return ret;
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,
389 NULL
392 static struct attribute_group wireless_group = {
393 .name = "wireless",
394 .attrs = wireless_attrs,
396 #endif
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);
403 int i = 0;
404 int n;
406 /* pass interface to uevent. */
407 envp[i++] = buf;
408 n = snprintf(buf, size, "INTERFACE=%s", dev->name) + 1;
409 buf += n;
410 size -= n;
412 if ((size <= 0) || (i >= num_envp))
413 return -ENOMEM;
415 envp[i] = NULL;
416 return 0;
418 #endif
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 = {
435 .name = "net",
436 .release = netdev_release,
437 .class_dev_attrs = net_class_attributes,
438 #ifdef CONFIG_HOTPLUG
439 .uevent = netdev_uevent,
440 #endif
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);
462 if (net->get_stats)
463 *groups++ = &netstat_group;
465 #ifdef WIRELESS_EXT
466 if (net->wireless_handlers && net->wireless_handlers->get_wireless_stats)
467 *groups++ = &wireless_group;
468 #endif
470 return class_device_add(class_dev);
473 int netdev_sysfs_init(void)
475 return class_register(&net_class);