blob: c1f4e0d428c0bf75e79f8513e441262a6d28d949 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * net-sysfs.c - network device class and attributes
3 *
4 * Copyright (c) 2003 Stephen Hemminger <shemminger@osdl.org>
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09005 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 * 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
Randy Dunlap4fc268d2006-01-11 12:17:47 -080012#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013#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>
Andrey Borzenkov6dd214b2006-01-09 20:51:28 -080019#include <net/iw_handler.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020
Pavel Emelyanov342709e2007-10-23 21:14:45 -070021#include "net-sysfs.h"
22
Eric W. Biederman8b41d182007-09-26 22:02:53 -070023#ifdef CONFIG_SYSFS
Linus Torvalds1da177e2005-04-16 15:20:36 -070024static const char fmt_hex[] = "%#x\n";
David S. Millerd1102b52005-05-29 20:28:25 -070025static const char fmt_long_hex[] = "%#lx\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -070026static const char fmt_dec[] = "%d\n";
27static const char fmt_ulong[] = "%lu\n";
28
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +090029static inline int dev_isalive(const struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070030{
Stephen Hemmingerfe9925b2006-05-06 17:56:03 -070031 return dev->reg_state <= NETREG_REGISTERED;
Linus Torvalds1da177e2005-04-16 15:20:36 -070032}
33
34/* use same locking rules as GIF* ioctl's */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070035static ssize_t netdev_show(const struct device *dev,
36 struct device_attribute *attr, char *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -070037 ssize_t (*format)(const struct net_device *, char *))
38{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070039 struct net_device *net = to_net_dev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 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) \
52static ssize_t format_##field(const struct net_device *net, char *buf) \
53{ \
54 return sprintf(buf, format_string, net->field); \
55} \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070056static ssize_t show_##field(struct device *dev, \
57 struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -070058{ \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070059 return netdev_show(dev, attr, buf, format_##field); \
Linus Torvalds1da177e2005-04-16 15:20:36 -070060}
61
62
63/* use same locking and permission rules as SIF* ioctl's */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070064static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -070065 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 rtnl_lock();
81 if (dev_isalive(net)) {
82 if ((ret = (*set)(net, new)) == 0)
83 ret = len;
84 }
85 rtnl_unlock();
86 err:
87 return ret;
88}
89
David Woodhouse9d296722008-04-20 16:07:43 -070090NETDEVICE_SHOW(dev_id, fmt_hex);
Kay Sieversfd586ba2005-12-19 01:42:56 +010091NETDEVICE_SHOW(addr_len, fmt_dec);
92NETDEVICE_SHOW(iflink, fmt_dec);
93NETDEVICE_SHOW(ifindex, fmt_dec);
94NETDEVICE_SHOW(features, fmt_long_hex);
95NETDEVICE_SHOW(type, fmt_dec);
Stefan Rompfb00055a2006-03-20 17:09:11 -080096NETDEVICE_SHOW(link_mode, fmt_dec);
Linus Torvalds1da177e2005-04-16 15:20:36 -070097
98/* use same locking rules as GIFHWADDR ioctl's */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070099static ssize_t show_address(struct device *dev, struct device_attribute *attr,
100 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101{
102 struct net_device *net = to_net_dev(dev);
103 ssize_t ret = -EINVAL;
104
105 read_lock(&dev_base_lock);
106 if (dev_isalive(net))
Michael Chan7ffc49a2007-12-24 21:28:09 -0800107 ret = sysfs_format_mac(buf, net->dev_addr, net->addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 read_unlock(&dev_base_lock);
109 return ret;
110}
111
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700112static ssize_t show_broadcast(struct device *dev,
113 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700114{
115 struct net_device *net = to_net_dev(dev);
116 if (dev_isalive(net))
Michael Chan7ffc49a2007-12-24 21:28:09 -0800117 return sysfs_format_mac(buf, net->broadcast, net->addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118 return -EINVAL;
119}
120
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700121static ssize_t show_carrier(struct device *dev,
122 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123{
124 struct net_device *netdev = to_net_dev(dev);
125 if (netif_running(netdev)) {
126 return sprintf(buf, fmt_dec, !!netif_carrier_ok(netdev));
127 }
128 return -EINVAL;
129}
130
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700131static ssize_t show_dormant(struct device *dev,
132 struct device_attribute *attr, char *buf)
Stefan Rompfb00055a2006-03-20 17:09:11 -0800133{
134 struct net_device *netdev = to_net_dev(dev);
135
136 if (netif_running(netdev))
137 return sprintf(buf, fmt_dec, !!netif_dormant(netdev));
138
139 return -EINVAL;
140}
141
142static const char *operstates[] = {
143 "unknown",
144 "notpresent", /* currently unused */
145 "down",
146 "lowerlayerdown",
147 "testing", /* currently unused */
148 "dormant",
149 "up"
150};
151
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700152static ssize_t show_operstate(struct device *dev,
153 struct device_attribute *attr, char *buf)
Stefan Rompfb00055a2006-03-20 17:09:11 -0800154{
155 const struct net_device *netdev = to_net_dev(dev);
156 unsigned char operstate;
157
158 read_lock(&dev_base_lock);
159 operstate = netdev->operstate;
160 if (!netif_running(netdev))
161 operstate = IF_OPER_DOWN;
162 read_unlock(&dev_base_lock);
163
Adrian Bunke3a5cd92006-04-05 22:19:47 -0700164 if (operstate >= ARRAY_SIZE(operstates))
Stefan Rompfb00055a2006-03-20 17:09:11 -0800165 return -EINVAL; /* should not happen */
166
167 return sprintf(buf, "%s\n", operstates[operstate]);
168}
169
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170/* read-write attributes */
171NETDEVICE_SHOW(mtu, fmt_dec);
172
173static int change_mtu(struct net_device *net, unsigned long new_mtu)
174{
175 return dev_set_mtu(net, (int) new_mtu);
176}
177
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700178static ssize_t store_mtu(struct device *dev, struct device_attribute *attr,
179 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700180{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700181 return netdev_store(dev, attr, buf, len, change_mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182}
183
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184NETDEVICE_SHOW(flags, fmt_hex);
185
186static int change_flags(struct net_device *net, unsigned long new_flags)
187{
188 return dev_change_flags(net, (unsigned) new_flags);
189}
190
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700191static ssize_t store_flags(struct device *dev, struct device_attribute *attr,
192 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700194 return netdev_store(dev, attr, buf, len, change_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195}
196
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197NETDEVICE_SHOW(tx_queue_len, fmt_ulong);
198
199static int change_tx_queue_len(struct net_device *net, unsigned long new_len)
200{
201 net->tx_queue_len = new_len;
202 return 0;
203}
204
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700205static ssize_t store_tx_queue_len(struct device *dev,
206 struct device_attribute *attr,
207 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700209 return netdev_store(dev, attr, buf, len, change_tx_queue_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210}
211
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700212static struct device_attribute net_class_attributes[] = {
Kay Sieversfd586ba2005-12-19 01:42:56 +0100213 __ATTR(addr_len, S_IRUGO, show_addr_len, NULL),
David Woodhouse9d296722008-04-20 16:07:43 -0700214 __ATTR(dev_id, S_IRUGO, show_dev_id, NULL),
Kay Sieversfd586ba2005-12-19 01:42:56 +0100215 __ATTR(iflink, S_IRUGO, show_iflink, NULL),
216 __ATTR(ifindex, S_IRUGO, show_ifindex, NULL),
217 __ATTR(features, S_IRUGO, show_features, NULL),
218 __ATTR(type, S_IRUGO, show_type, NULL),
Stefan Rompfb00055a2006-03-20 17:09:11 -0800219 __ATTR(link_mode, S_IRUGO, show_link_mode, NULL),
Kay Sieversfd586ba2005-12-19 01:42:56 +0100220 __ATTR(address, S_IRUGO, show_address, NULL),
221 __ATTR(broadcast, S_IRUGO, show_broadcast, NULL),
222 __ATTR(carrier, S_IRUGO, show_carrier, NULL),
Stefan Rompfb00055a2006-03-20 17:09:11 -0800223 __ATTR(dormant, S_IRUGO, show_dormant, NULL),
224 __ATTR(operstate, S_IRUGO, show_operstate, NULL),
Kay Sieversfd586ba2005-12-19 01:42:56 +0100225 __ATTR(mtu, S_IRUGO | S_IWUSR, show_mtu, store_mtu),
226 __ATTR(flags, S_IRUGO | S_IWUSR, show_flags, store_flags),
227 __ATTR(tx_queue_len, S_IRUGO | S_IWUSR, show_tx_queue_len,
228 store_tx_queue_len),
Kay Sieversfd586ba2005-12-19 01:42:56 +0100229 {}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230};
231
232/* Show a given an attribute in the statistics group */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700233static ssize_t netstat_show(const struct device *d,
234 struct device_attribute *attr, char *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235 unsigned long offset)
236{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700237 struct net_device *dev = to_net_dev(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 struct net_device_stats *stats;
239 ssize_t ret = -EINVAL;
240
Pavel Emelyanovdf1b86c2007-11-30 00:42:42 +1100241 WARN_ON(offset > sizeof(struct net_device_stats) ||
242 offset % sizeof(unsigned long) != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243
244 read_lock(&dev_base_lock);
Pavel Emelyanov96e74082008-05-21 14:12:46 -0700245 if (dev_isalive(dev)) {
246 stats = dev->get_stats(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 ret = sprintf(buf, fmt_ulong,
248 *(unsigned long *)(((u8 *) stats) + offset));
Pavel Emelyanov96e74082008-05-21 14:12:46 -0700249 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 read_unlock(&dev_base_lock);
251 return ret;
252}
253
254/* generate a read-only statistics attribute */
255#define NETSTAT_ENTRY(name) \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700256static ssize_t show_##name(struct device *d, \
257 struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258{ \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700259 return netstat_show(d, attr, buf, \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 offsetof(struct net_device_stats, name)); \
261} \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700262static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263
264NETSTAT_ENTRY(rx_packets);
265NETSTAT_ENTRY(tx_packets);
266NETSTAT_ENTRY(rx_bytes);
267NETSTAT_ENTRY(tx_bytes);
268NETSTAT_ENTRY(rx_errors);
269NETSTAT_ENTRY(tx_errors);
270NETSTAT_ENTRY(rx_dropped);
271NETSTAT_ENTRY(tx_dropped);
272NETSTAT_ENTRY(multicast);
273NETSTAT_ENTRY(collisions);
274NETSTAT_ENTRY(rx_length_errors);
275NETSTAT_ENTRY(rx_over_errors);
276NETSTAT_ENTRY(rx_crc_errors);
277NETSTAT_ENTRY(rx_frame_errors);
278NETSTAT_ENTRY(rx_fifo_errors);
279NETSTAT_ENTRY(rx_missed_errors);
280NETSTAT_ENTRY(tx_aborted_errors);
281NETSTAT_ENTRY(tx_carrier_errors);
282NETSTAT_ENTRY(tx_fifo_errors);
283NETSTAT_ENTRY(tx_heartbeat_errors);
284NETSTAT_ENTRY(tx_window_errors);
285NETSTAT_ENTRY(rx_compressed);
286NETSTAT_ENTRY(tx_compressed);
287
288static struct attribute *netstat_attrs[] = {
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700289 &dev_attr_rx_packets.attr,
290 &dev_attr_tx_packets.attr,
291 &dev_attr_rx_bytes.attr,
292 &dev_attr_tx_bytes.attr,
293 &dev_attr_rx_errors.attr,
294 &dev_attr_tx_errors.attr,
295 &dev_attr_rx_dropped.attr,
296 &dev_attr_tx_dropped.attr,
297 &dev_attr_multicast.attr,
298 &dev_attr_collisions.attr,
299 &dev_attr_rx_length_errors.attr,
300 &dev_attr_rx_over_errors.attr,
301 &dev_attr_rx_crc_errors.attr,
302 &dev_attr_rx_frame_errors.attr,
303 &dev_attr_rx_fifo_errors.attr,
304 &dev_attr_rx_missed_errors.attr,
305 &dev_attr_tx_aborted_errors.attr,
306 &dev_attr_tx_carrier_errors.attr,
307 &dev_attr_tx_fifo_errors.attr,
308 &dev_attr_tx_heartbeat_errors.attr,
309 &dev_attr_tx_window_errors.attr,
310 &dev_attr_rx_compressed.attr,
311 &dev_attr_tx_compressed.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 NULL
313};
314
315
316static struct attribute_group netstat_group = {
317 .name = "statistics",
318 .attrs = netstat_attrs,
319};
320
Johannes Berg22bb1be2008-07-10 11:16:47 +0200321#ifdef CONFIG_WIRELESS_EXT_SYSFS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322/* helper function that does all the locking etc for wireless stats */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700323static ssize_t wireless_show(struct device *d, char *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 ssize_t (*format)(const struct iw_statistics *,
325 char *))
326{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700327 struct net_device *dev = to_net_dev(d);
Andrey Borzenkov6dd214b2006-01-09 20:51:28 -0800328 const struct iw_statistics *iw = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 ssize_t ret = -EINVAL;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900330
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331 read_lock(&dev_base_lock);
Andrey Borzenkov6dd214b2006-01-09 20:51:28 -0800332 if (dev_isalive(dev)) {
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700333 if (dev->wireless_handlers &&
334 dev->wireless_handlers->get_wireless_stats)
Andrey Borzenkov6dd214b2006-01-09 20:51:28 -0800335 iw = dev->wireless_handlers->get_wireless_stats(dev);
Andrey Borzenkov6dd214b2006-01-09 20:51:28 -0800336 if (iw != NULL)
337 ret = (*format)(iw, buf);
338 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 read_unlock(&dev_base_lock);
340
341 return ret;
342}
343
344/* show function template for wireless fields */
345#define WIRELESS_SHOW(name, field, format_string) \
346static ssize_t format_iw_##name(const struct iw_statistics *iw, char *buf) \
347{ \
348 return sprintf(buf, format_string, iw->field); \
349} \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700350static ssize_t show_iw_##name(struct device *d, \
351 struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352{ \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700353 return wireless_show(d, buf, format_iw_##name); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354} \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700355static DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
357WIRELESS_SHOW(status, status, fmt_hex);
358WIRELESS_SHOW(link, qual.qual, fmt_dec);
359WIRELESS_SHOW(level, qual.level, fmt_dec);
360WIRELESS_SHOW(noise, qual.noise, fmt_dec);
361WIRELESS_SHOW(nwid, discard.nwid, fmt_dec);
362WIRELESS_SHOW(crypt, discard.code, fmt_dec);
363WIRELESS_SHOW(fragment, discard.fragment, fmt_dec);
364WIRELESS_SHOW(misc, discard.misc, fmt_dec);
365WIRELESS_SHOW(retries, discard.retries, fmt_dec);
366WIRELESS_SHOW(beacon, miss.beacon, fmt_dec);
367
368static struct attribute *wireless_attrs[] = {
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700369 &dev_attr_status.attr,
370 &dev_attr_link.attr,
371 &dev_attr_level.attr,
372 &dev_attr_noise.attr,
373 &dev_attr_nwid.attr,
374 &dev_attr_crypt.attr,
375 &dev_attr_fragment.attr,
376 &dev_attr_retries.attr,
377 &dev_attr_misc.attr,
378 &dev_attr_beacon.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 NULL
380};
381
382static struct attribute_group wireless_group = {
383 .name = "wireless",
384 .attrs = wireless_attrs,
385};
386#endif
387
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700388#endif /* CONFIG_SYSFS */
389
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390#ifdef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +0200391static int netdev_uevent(struct device *d, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700393 struct net_device *dev = to_net_dev(d);
Kay Sievers7eff2e72007-08-14 15:15:12 +0200394 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
Kay Sievers312c0042005-11-16 09:00:00 +0100396 /* pass interface to uevent. */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200397 retval = add_uevent_var(env, "INTERFACE=%s", dev->name);
Eric Rannaudbf624562007-03-30 22:23:12 -0700398 if (retval)
399 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400
Jean Tourrilhesca2f37d2007-03-07 10:49:30 -0800401 /* pass ifindex to uevent.
402 * ifindex is useful as it won't change (interface name may change)
403 * and is what RtNetlink uses natively. */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200404 retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex);
Jean Tourrilhesca2f37d2007-03-07 10:49:30 -0800405
Eric Rannaudbf624562007-03-30 22:23:12 -0700406exit:
Eric Rannaudbf624562007-03-30 22:23:12 -0700407 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408}
409#endif
410
411/*
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900412 * netdev_release -- destroy and free a dead device.
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700413 * Called when last reference to device kobject is gone.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700414 */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700415static void netdev_release(struct device *d)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700417 struct net_device *dev = to_net_dev(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418
419 BUG_ON(dev->reg_state != NETREG_RELEASED);
420
421 kfree((char *)dev - dev->padded);
422}
423
424static struct class net_class = {
425 .name = "net",
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700426 .dev_release = netdev_release,
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700427#ifdef CONFIG_SYSFS
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700428 .dev_attrs = net_class_attributes,
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700429#endif /* CONFIG_SYSFS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430#ifdef CONFIG_HOTPLUG
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700431 .dev_uevent = netdev_uevent,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432#endif
433};
434
Stephen Hemminger9093bbb2007-05-19 15:39:25 -0700435/* Delete sysfs entries but hold kobject reference until after all
436 * netdev references are gone.
437 */
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700438void netdev_unregister_kobject(struct net_device * net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439{
Stephen Hemminger9093bbb2007-05-19 15:39:25 -0700440 struct device *dev = &(net->dev);
441
442 kobject_get(&dev->kobj);
443 device_del(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444}
445
446/* Create sysfs entries for network device. */
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700447int netdev_register_kobject(struct net_device *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700449 struct device *dev = &(net->dev);
Stephen Hemmingerfe9925b2006-05-06 17:56:03 -0700450 struct attribute_group **groups = net->sysfs_groups;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700452 dev->class = &net_class;
453 dev->platform_data = net;
454 dev->groups = groups;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455
Stephen Hemmingerfe9925b2006-05-06 17:56:03 -0700456 BUILD_BUG_ON(BUS_ID_SIZE < IFNAMSIZ);
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700457 strlcpy(dev->bus_id, net->name, BUS_ID_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700459#ifdef CONFIG_SYSFS
Pavel Emelyanov96e74082008-05-21 14:12:46 -0700460 *groups++ = &netstat_group;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461
Johannes Berg22bb1be2008-07-10 11:16:47 +0200462#ifdef CONFIG_WIRELESS_EXT_SYSFS
John W. Linvillebaef1862006-09-08 16:04:05 -0400463 if (net->wireless_handlers && net->wireless_handlers->get_wireless_stats)
Stephen Hemmingerfe9925b2006-05-06 17:56:03 -0700464 *groups++ = &wireless_group;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465#endif
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700466#endif /* CONFIG_SYSFS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700468 return device_add(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469}
470
Jay Vosburghb8a97872008-06-13 18:12:04 -0700471int netdev_class_create_file(struct class_attribute *class_attr)
472{
473 return class_create_file(&net_class, class_attr);
474}
475
476void netdev_class_remove_file(struct class_attribute *class_attr)
477{
478 class_remove_file(&net_class, class_attr);
479}
480
481EXPORT_SYMBOL(netdev_class_create_file);
482EXPORT_SYMBOL(netdev_class_remove_file);
483
Daniel Lezcanoaaf8cdc2008-05-02 17:00:58 -0700484void netdev_initialize_kobject(struct net_device *net)
485{
486 struct device *device = &(net->dev);
487 device_initialize(device);
488}
489
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700490int netdev_kobject_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700491{
492 return class_register(&net_class);
493}