blob: 6628e457ddc0f1179e3e5fc42e965eaf19b9b283 [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
Eric W. Biederman8b41d182007-09-26 22:02:53 -070021#ifdef CONFIG_SYSFS
Linus Torvalds1da177e2005-04-16 15:20:36 -070022static const char fmt_hex[] = "%#x\n";
David S. Millerd1102b52005-05-29 20:28:25 -070023static const char fmt_long_hex[] = "%#lx\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -070024static const char fmt_dec[] = "%d\n";
25static const char fmt_ulong[] = "%lu\n";
26
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +090027static inline int dev_isalive(const struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070028{
Stephen Hemmingerfe9925b2006-05-06 17:56:03 -070029 return dev->reg_state <= NETREG_REGISTERED;
Linus Torvalds1da177e2005-04-16 15:20:36 -070030}
31
32/* use same locking rules as GIF* ioctl's */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070033static ssize_t netdev_show(const struct device *dev,
34 struct device_attribute *attr, char *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 ssize_t (*format)(const struct net_device *, char *))
36{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070037 struct net_device *net = to_net_dev(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -070038 ssize_t ret = -EINVAL;
39
40 read_lock(&dev_base_lock);
41 if (dev_isalive(net))
42 ret = (*format)(net, buf);
43 read_unlock(&dev_base_lock);
44
45 return ret;
46}
47
48/* generate a show function for simple field */
49#define NETDEVICE_SHOW(field, format_string) \
50static ssize_t format_##field(const struct net_device *net, char *buf) \
51{ \
52 return sprintf(buf, format_string, net->field); \
53} \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070054static ssize_t show_##field(struct device *dev, \
55 struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -070056{ \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070057 return netdev_show(dev, attr, buf, format_##field); \
Linus Torvalds1da177e2005-04-16 15:20:36 -070058}
59
60
61/* use same locking and permission rules as SIF* ioctl's */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -070062static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -070063 const char *buf, size_t len,
64 int (*set)(struct net_device *, unsigned long))
65{
66 struct net_device *net = to_net_dev(dev);
67 char *endp;
68 unsigned long new;
69 int ret = -EINVAL;
70
71 if (!capable(CAP_NET_ADMIN))
72 return -EPERM;
73
74 new = simple_strtoul(buf, &endp, 0);
75 if (endp == buf)
76 goto err;
77
78 rtnl_lock();
79 if (dev_isalive(net)) {
80 if ((ret = (*set)(net, new)) == 0)
81 ret = len;
82 }
83 rtnl_unlock();
84 err:
85 return ret;
86}
87
Kay Sieversfd586ba2005-12-19 01:42:56 +010088NETDEVICE_SHOW(addr_len, fmt_dec);
89NETDEVICE_SHOW(iflink, fmt_dec);
90NETDEVICE_SHOW(ifindex, fmt_dec);
91NETDEVICE_SHOW(features, fmt_long_hex);
92NETDEVICE_SHOW(type, fmt_dec);
Stefan Rompfb00055a2006-03-20 17:09:11 -080093NETDEVICE_SHOW(link_mode, fmt_dec);
Linus Torvalds1da177e2005-04-16 15:20:36 -070094
95/* use same locking rules as GIFHWADDR ioctl's */
96static ssize_t format_addr(char *buf, const unsigned char *addr, int len)
97{
98 int i;
99 char *cp = buf;
100
101 for (i = 0; i < len; i++)
102 cp += sprintf(cp, "%02x%c", addr[i],
103 i == (len - 1) ? '\n' : ':');
104 return cp - buf;
105}
106
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700107static ssize_t show_address(struct device *dev, struct device_attribute *attr,
108 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109{
110 struct net_device *net = to_net_dev(dev);
111 ssize_t ret = -EINVAL;
112
113 read_lock(&dev_base_lock);
114 if (dev_isalive(net))
115 ret = format_addr(buf, net->dev_addr, net->addr_len);
116 read_unlock(&dev_base_lock);
117 return ret;
118}
119
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700120static ssize_t show_broadcast(struct device *dev,
121 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122{
123 struct net_device *net = to_net_dev(dev);
124 if (dev_isalive(net))
125 return format_addr(buf, net->broadcast, net->addr_len);
126 return -EINVAL;
127}
128
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700129static ssize_t show_carrier(struct device *dev,
130 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131{
132 struct net_device *netdev = to_net_dev(dev);
133 if (netif_running(netdev)) {
134 return sprintf(buf, fmt_dec, !!netif_carrier_ok(netdev));
135 }
136 return -EINVAL;
137}
138
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700139static ssize_t show_dormant(struct device *dev,
140 struct device_attribute *attr, char *buf)
Stefan Rompfb00055a2006-03-20 17:09:11 -0800141{
142 struct net_device *netdev = to_net_dev(dev);
143
144 if (netif_running(netdev))
145 return sprintf(buf, fmt_dec, !!netif_dormant(netdev));
146
147 return -EINVAL;
148}
149
150static const char *operstates[] = {
151 "unknown",
152 "notpresent", /* currently unused */
153 "down",
154 "lowerlayerdown",
155 "testing", /* currently unused */
156 "dormant",
157 "up"
158};
159
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700160static ssize_t show_operstate(struct device *dev,
161 struct device_attribute *attr, char *buf)
Stefan Rompfb00055a2006-03-20 17:09:11 -0800162{
163 const struct net_device *netdev = to_net_dev(dev);
164 unsigned char operstate;
165
166 read_lock(&dev_base_lock);
167 operstate = netdev->operstate;
168 if (!netif_running(netdev))
169 operstate = IF_OPER_DOWN;
170 read_unlock(&dev_base_lock);
171
Adrian Bunke3a5cd92006-04-05 22:19:47 -0700172 if (operstate >= ARRAY_SIZE(operstates))
Stefan Rompfb00055a2006-03-20 17:09:11 -0800173 return -EINVAL; /* should not happen */
174
175 return sprintf(buf, "%s\n", operstates[operstate]);
176}
177
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178/* read-write attributes */
179NETDEVICE_SHOW(mtu, fmt_dec);
180
181static int change_mtu(struct net_device *net, unsigned long new_mtu)
182{
183 return dev_set_mtu(net, (int) new_mtu);
184}
185
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700186static ssize_t store_mtu(struct device *dev, struct device_attribute *attr,
187 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700189 return netdev_store(dev, attr, buf, len, change_mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190}
191
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192NETDEVICE_SHOW(flags, fmt_hex);
193
194static int change_flags(struct net_device *net, unsigned long new_flags)
195{
196 return dev_change_flags(net, (unsigned) new_flags);
197}
198
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700199static ssize_t store_flags(struct device *dev, struct device_attribute *attr,
200 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700202 return netdev_store(dev, attr, buf, len, change_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203}
204
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205NETDEVICE_SHOW(tx_queue_len, fmt_ulong);
206
207static int change_tx_queue_len(struct net_device *net, unsigned long new_len)
208{
209 net->tx_queue_len = new_len;
210 return 0;
211}
212
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700213static ssize_t store_tx_queue_len(struct device *dev,
214 struct device_attribute *attr,
215 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700217 return netdev_store(dev, attr, buf, len, change_tx_queue_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700218}
219
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700220static struct device_attribute net_class_attributes[] = {
Kay Sieversfd586ba2005-12-19 01:42:56 +0100221 __ATTR(addr_len, S_IRUGO, show_addr_len, NULL),
222 __ATTR(iflink, S_IRUGO, show_iflink, NULL),
223 __ATTR(ifindex, S_IRUGO, show_ifindex, NULL),
224 __ATTR(features, S_IRUGO, show_features, NULL),
225 __ATTR(type, S_IRUGO, show_type, NULL),
Stefan Rompfb00055a2006-03-20 17:09:11 -0800226 __ATTR(link_mode, S_IRUGO, show_link_mode, NULL),
Kay Sieversfd586ba2005-12-19 01:42:56 +0100227 __ATTR(address, S_IRUGO, show_address, NULL),
228 __ATTR(broadcast, S_IRUGO, show_broadcast, NULL),
229 __ATTR(carrier, S_IRUGO, show_carrier, NULL),
Stefan Rompfb00055a2006-03-20 17:09:11 -0800230 __ATTR(dormant, S_IRUGO, show_dormant, NULL),
231 __ATTR(operstate, S_IRUGO, show_operstate, NULL),
Kay Sieversfd586ba2005-12-19 01:42:56 +0100232 __ATTR(mtu, S_IRUGO | S_IWUSR, show_mtu, store_mtu),
233 __ATTR(flags, S_IRUGO | S_IWUSR, show_flags, store_flags),
234 __ATTR(tx_queue_len, S_IRUGO | S_IWUSR, show_tx_queue_len,
235 store_tx_queue_len),
Kay Sieversfd586ba2005-12-19 01:42:56 +0100236 {}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237};
238
239/* Show a given an attribute in the statistics group */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700240static ssize_t netstat_show(const struct device *d,
241 struct device_attribute *attr, char *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 unsigned long offset)
243{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700244 struct net_device *dev = to_net_dev(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 struct net_device_stats *stats;
246 ssize_t ret = -EINVAL;
247
248 if (offset > sizeof(struct net_device_stats) ||
249 offset % sizeof(unsigned long) != 0)
250 WARN_ON(1);
251
252 read_lock(&dev_base_lock);
253 if (dev_isalive(dev) && dev->get_stats &&
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900254 (stats = (*dev->get_stats)(dev)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 ret = sprintf(buf, fmt_ulong,
256 *(unsigned long *)(((u8 *) stats) + offset));
257
258 read_unlock(&dev_base_lock);
259 return ret;
260}
261
262/* generate a read-only statistics attribute */
263#define NETSTAT_ENTRY(name) \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700264static ssize_t show_##name(struct device *d, \
265 struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266{ \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700267 return netstat_show(d, attr, buf, \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268 offsetof(struct net_device_stats, name)); \
269} \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700270static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271
272NETSTAT_ENTRY(rx_packets);
273NETSTAT_ENTRY(tx_packets);
274NETSTAT_ENTRY(rx_bytes);
275NETSTAT_ENTRY(tx_bytes);
276NETSTAT_ENTRY(rx_errors);
277NETSTAT_ENTRY(tx_errors);
278NETSTAT_ENTRY(rx_dropped);
279NETSTAT_ENTRY(tx_dropped);
280NETSTAT_ENTRY(multicast);
281NETSTAT_ENTRY(collisions);
282NETSTAT_ENTRY(rx_length_errors);
283NETSTAT_ENTRY(rx_over_errors);
284NETSTAT_ENTRY(rx_crc_errors);
285NETSTAT_ENTRY(rx_frame_errors);
286NETSTAT_ENTRY(rx_fifo_errors);
287NETSTAT_ENTRY(rx_missed_errors);
288NETSTAT_ENTRY(tx_aborted_errors);
289NETSTAT_ENTRY(tx_carrier_errors);
290NETSTAT_ENTRY(tx_fifo_errors);
291NETSTAT_ENTRY(tx_heartbeat_errors);
292NETSTAT_ENTRY(tx_window_errors);
293NETSTAT_ENTRY(rx_compressed);
294NETSTAT_ENTRY(tx_compressed);
295
296static struct attribute *netstat_attrs[] = {
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700297 &dev_attr_rx_packets.attr,
298 &dev_attr_tx_packets.attr,
299 &dev_attr_rx_bytes.attr,
300 &dev_attr_tx_bytes.attr,
301 &dev_attr_rx_errors.attr,
302 &dev_attr_tx_errors.attr,
303 &dev_attr_rx_dropped.attr,
304 &dev_attr_tx_dropped.attr,
305 &dev_attr_multicast.attr,
306 &dev_attr_collisions.attr,
307 &dev_attr_rx_length_errors.attr,
308 &dev_attr_rx_over_errors.attr,
309 &dev_attr_rx_crc_errors.attr,
310 &dev_attr_rx_frame_errors.attr,
311 &dev_attr_rx_fifo_errors.attr,
312 &dev_attr_rx_missed_errors.attr,
313 &dev_attr_tx_aborted_errors.attr,
314 &dev_attr_tx_carrier_errors.attr,
315 &dev_attr_tx_fifo_errors.attr,
316 &dev_attr_tx_heartbeat_errors.attr,
317 &dev_attr_tx_window_errors.attr,
318 &dev_attr_rx_compressed.attr,
319 &dev_attr_tx_compressed.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 NULL
321};
322
323
324static struct attribute_group netstat_group = {
325 .name = "statistics",
326 .attrs = netstat_attrs,
327};
328
Robert P. J. Day9d4a6042007-02-05 16:41:36 -0800329#ifdef CONFIG_WIRELESS_EXT
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330/* helper function that does all the locking etc for wireless stats */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700331static ssize_t wireless_show(struct device *d, char *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700332 ssize_t (*format)(const struct iw_statistics *,
333 char *))
334{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700335 struct net_device *dev = to_net_dev(d);
Andrey Borzenkov6dd214b2006-01-09 20:51:28 -0800336 const struct iw_statistics *iw = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337 ssize_t ret = -EINVAL;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900338
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339 read_lock(&dev_base_lock);
Andrey Borzenkov6dd214b2006-01-09 20:51:28 -0800340 if (dev_isalive(dev)) {
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700341 if (dev->wireless_handlers &&
342 dev->wireless_handlers->get_wireless_stats)
Andrey Borzenkov6dd214b2006-01-09 20:51:28 -0800343 iw = dev->wireless_handlers->get_wireless_stats(dev);
Andrey Borzenkov6dd214b2006-01-09 20:51:28 -0800344 if (iw != NULL)
345 ret = (*format)(iw, buf);
346 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 read_unlock(&dev_base_lock);
348
349 return ret;
350}
351
352/* show function template for wireless fields */
353#define WIRELESS_SHOW(name, field, format_string) \
354static ssize_t format_iw_##name(const struct iw_statistics *iw, char *buf) \
355{ \
356 return sprintf(buf, format_string, iw->field); \
357} \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700358static ssize_t show_iw_##name(struct device *d, \
359 struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360{ \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700361 return wireless_show(d, buf, format_iw_##name); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362} \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700363static DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364
365WIRELESS_SHOW(status, status, fmt_hex);
366WIRELESS_SHOW(link, qual.qual, fmt_dec);
367WIRELESS_SHOW(level, qual.level, fmt_dec);
368WIRELESS_SHOW(noise, qual.noise, fmt_dec);
369WIRELESS_SHOW(nwid, discard.nwid, fmt_dec);
370WIRELESS_SHOW(crypt, discard.code, fmt_dec);
371WIRELESS_SHOW(fragment, discard.fragment, fmt_dec);
372WIRELESS_SHOW(misc, discard.misc, fmt_dec);
373WIRELESS_SHOW(retries, discard.retries, fmt_dec);
374WIRELESS_SHOW(beacon, miss.beacon, fmt_dec);
375
376static struct attribute *wireless_attrs[] = {
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700377 &dev_attr_status.attr,
378 &dev_attr_link.attr,
379 &dev_attr_level.attr,
380 &dev_attr_noise.attr,
381 &dev_attr_nwid.attr,
382 &dev_attr_crypt.attr,
383 &dev_attr_fragment.attr,
384 &dev_attr_retries.attr,
385 &dev_attr_misc.attr,
386 &dev_attr_beacon.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387 NULL
388};
389
390static struct attribute_group wireless_group = {
391 .name = "wireless",
392 .attrs = wireless_attrs,
393};
394#endif
395
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700396#endif /* CONFIG_SYSFS */
397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398#ifdef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +0200399static int netdev_uevent(struct device *d, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700401 struct net_device *dev = to_net_dev(d);
Kay Sievers7eff2e72007-08-14 15:15:12 +0200402 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Kay Sievers312c0042005-11-16 09:00:00 +0100404 /* pass interface to uevent. */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200405 retval = add_uevent_var(env, "INTERFACE=%s", dev->name);
Eric Rannaudbf624562007-03-30 22:23:12 -0700406 if (retval)
407 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
Jean Tourrilhesca2f37d2007-03-07 10:49:30 -0800409 /* pass ifindex to uevent.
410 * ifindex is useful as it won't change (interface name may change)
411 * and is what RtNetlink uses natively. */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200412 retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex);
Jean Tourrilhesca2f37d2007-03-07 10:49:30 -0800413
Eric Rannaudbf624562007-03-30 22:23:12 -0700414exit:
Eric Rannaudbf624562007-03-30 22:23:12 -0700415 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416}
417#endif
418
419/*
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900420 * netdev_release -- destroy and free a dead device.
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700421 * Called when last reference to device kobject is gone.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700423static void netdev_release(struct device *d)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700425 struct net_device *dev = to_net_dev(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426
427 BUG_ON(dev->reg_state != NETREG_RELEASED);
428
429 kfree((char *)dev - dev->padded);
430}
431
432static struct class net_class = {
433 .name = "net",
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700434 .dev_release = netdev_release,
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700435#ifdef CONFIG_SYSFS
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700436 .dev_attrs = net_class_attributes,
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700437#endif /* CONFIG_SYSFS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438#ifdef CONFIG_HOTPLUG
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700439 .dev_uevent = netdev_uevent,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440#endif
441};
442
Stephen Hemminger9093bbb2007-05-19 15:39:25 -0700443/* Delete sysfs entries but hold kobject reference until after all
444 * netdev references are gone.
445 */
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700446void netdev_unregister_kobject(struct net_device * net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447{
Stephen Hemminger9093bbb2007-05-19 15:39:25 -0700448 struct device *dev = &(net->dev);
449
450 kobject_get(&dev->kobj);
451 device_del(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452}
453
454/* Create sysfs entries for network device. */
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700455int netdev_register_kobject(struct net_device *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700457 struct device *dev = &(net->dev);
Stephen Hemmingerfe9925b2006-05-06 17:56:03 -0700458 struct attribute_group **groups = net->sysfs_groups;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700460 device_initialize(dev);
461 dev->class = &net_class;
462 dev->platform_data = net;
463 dev->groups = groups;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464
Stephen Hemmingerfe9925b2006-05-06 17:56:03 -0700465 BUILD_BUG_ON(BUS_ID_SIZE < IFNAMSIZ);
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700466 strlcpy(dev->bus_id, net->name, BUS_ID_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700468#ifdef CONFIG_SYSFS
Stephen Hemmingerfe9925b2006-05-06 17:56:03 -0700469 if (net->get_stats)
470 *groups++ = &netstat_group;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
Robert P. J. Day9d4a6042007-02-05 16:41:36 -0800472#ifdef CONFIG_WIRELESS_EXT
John W. Linvillebaef1862006-09-08 16:04:05 -0400473 if (net->wireless_handlers && net->wireless_handlers->get_wireless_stats)
Stephen Hemmingerfe9925b2006-05-06 17:56:03 -0700474 *groups++ = &wireless_group;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700475#endif
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700476#endif /* CONFIG_SYSFS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700478 return device_add(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479}
480
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700481int netdev_kobject_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482{
483 return class_register(&net_class);
484}