blob: 427ded841224e6b7ce79cc91158efec24ab54b4a [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>
Johannes Berg8f1546c2009-09-28 15:26:43 +020019#include <net/wext.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
Stephen Hemminger5a5990d2009-02-26 06:49:24 +000080 if (!rtnl_trylock())
Eric W. Biederman336ca572009-05-13 16:57:25 +000081 return restart_syscall();
Stephen Hemminger5a5990d2009-02-26 06:49:24 +000082
Linus Torvalds1da177e2005-04-16 15:20:36 -070083 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
David Woodhouse9d296722008-04-20 16:07:43 -070092NETDEVICE_SHOW(dev_id, fmt_hex);
Kay Sieversfd586ba2005-12-19 01:42:56 +010093NETDEVICE_SHOW(addr_len, fmt_dec);
94NETDEVICE_SHOW(iflink, fmt_dec);
95NETDEVICE_SHOW(ifindex, fmt_dec);
96NETDEVICE_SHOW(features, fmt_long_hex);
97NETDEVICE_SHOW(type, fmt_dec);
Stefan Rompfb00055a2006-03-20 17:09:11 -080098NETDEVICE_SHOW(link_mode, fmt_dec);
Linus Torvalds1da177e2005-04-16 15:20:36 -070099
100/* use same locking rules as GIFHWADDR ioctl's */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700101static ssize_t show_address(struct device *dev, struct device_attribute *attr,
102 char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103{
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))
Michael Chan7ffc49a2007-12-24 21:28:09 -0800109 ret = sysfs_format_mac(buf, net->dev_addr, net->addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 read_unlock(&dev_base_lock);
111 return ret;
112}
113
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700114static ssize_t show_broadcast(struct device *dev,
115 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116{
117 struct net_device *net = to_net_dev(dev);
118 if (dev_isalive(net))
Michael Chan7ffc49a2007-12-24 21:28:09 -0800119 return sysfs_format_mac(buf, net->broadcast, net->addr_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 return -EINVAL;
121}
122
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700123static ssize_t show_carrier(struct device *dev,
124 struct device_attribute *attr, char *buf)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125{
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
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700133static ssize_t show_dormant(struct device *dev,
134 struct device_attribute *attr, char *buf)
Stefan Rompfb00055a2006-03-20 17:09:11 -0800135{
136 struct net_device *netdev = to_net_dev(dev);
137
138 if (netif_running(netdev))
139 return sprintf(buf, fmt_dec, !!netif_dormant(netdev));
140
141 return -EINVAL;
142}
143
Jan Engelhardt36cbd3d2009-08-05 10:42:58 -0700144static const char *const operstates[] = {
Stefan Rompfb00055a2006-03-20 17:09:11 -0800145 "unknown",
146 "notpresent", /* currently unused */
147 "down",
148 "lowerlayerdown",
149 "testing", /* currently unused */
150 "dormant",
151 "up"
152};
153
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700154static ssize_t show_operstate(struct device *dev,
155 struct device_attribute *attr, char *buf)
Stefan Rompfb00055a2006-03-20 17:09:11 -0800156{
157 const struct net_device *netdev = to_net_dev(dev);
158 unsigned char operstate;
159
160 read_lock(&dev_base_lock);
161 operstate = netdev->operstate;
162 if (!netif_running(netdev))
163 operstate = IF_OPER_DOWN;
164 read_unlock(&dev_base_lock);
165
Adrian Bunke3a5cd92006-04-05 22:19:47 -0700166 if (operstate >= ARRAY_SIZE(operstates))
Stefan Rompfb00055a2006-03-20 17:09:11 -0800167 return -EINVAL; /* should not happen */
168
169 return sprintf(buf, "%s\n", operstates[operstate]);
170}
171
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172/* read-write attributes */
173NETDEVICE_SHOW(mtu, fmt_dec);
174
175static int change_mtu(struct net_device *net, unsigned long new_mtu)
176{
177 return dev_set_mtu(net, (int) new_mtu);
178}
179
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700180static ssize_t store_mtu(struct device *dev, struct device_attribute *attr,
181 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700183 return netdev_store(dev, attr, buf, len, change_mtu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184}
185
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186NETDEVICE_SHOW(flags, fmt_hex);
187
188static int change_flags(struct net_device *net, unsigned long new_flags)
189{
190 return dev_change_flags(net, (unsigned) new_flags);
191}
192
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700193static ssize_t store_flags(struct device *dev, struct device_attribute *attr,
194 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700196 return netdev_store(dev, attr, buf, len, change_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197}
198
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199NETDEVICE_SHOW(tx_queue_len, fmt_ulong);
200
201static int change_tx_queue_len(struct net_device *net, unsigned long new_len)
202{
203 net->tx_queue_len = new_len;
204 return 0;
205}
206
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700207static ssize_t store_tx_queue_len(struct device *dev,
208 struct device_attribute *attr,
209 const char *buf, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700210{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700211 return netdev_store(dev, attr, buf, len, change_tx_queue_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212}
213
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700214static ssize_t store_ifalias(struct device *dev, struct device_attribute *attr,
215 const char *buf, size_t len)
216{
217 struct net_device *netdev = to_net_dev(dev);
218 size_t count = len;
219 ssize_t ret;
220
221 if (!capable(CAP_NET_ADMIN))
222 return -EPERM;
223
224 /* ignore trailing newline */
225 if (len > 0 && buf[len - 1] == '\n')
226 --count;
227
Eric W. Biederman336ca572009-05-13 16:57:25 +0000228 if (!rtnl_trylock())
229 return restart_syscall();
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700230 ret = dev_set_alias(netdev, buf, count);
231 rtnl_unlock();
232
233 return ret < 0 ? ret : len;
234}
235
236static ssize_t show_ifalias(struct device *dev,
237 struct device_attribute *attr, char *buf)
238{
239 const struct net_device *netdev = to_net_dev(dev);
240 ssize_t ret = 0;
241
Eric W. Biederman336ca572009-05-13 16:57:25 +0000242 if (!rtnl_trylock())
243 return restart_syscall();
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700244 if (netdev->ifalias)
245 ret = sprintf(buf, "%s\n", netdev->ifalias);
246 rtnl_unlock();
247 return ret;
248}
249
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700250static struct device_attribute net_class_attributes[] = {
Kay Sieversfd586ba2005-12-19 01:42:56 +0100251 __ATTR(addr_len, S_IRUGO, show_addr_len, NULL),
David Woodhouse9d296722008-04-20 16:07:43 -0700252 __ATTR(dev_id, S_IRUGO, show_dev_id, NULL),
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700253 __ATTR(ifalias, S_IRUGO | S_IWUSR, show_ifalias, store_ifalias),
Kay Sieversfd586ba2005-12-19 01:42:56 +0100254 __ATTR(iflink, S_IRUGO, show_iflink, NULL),
255 __ATTR(ifindex, S_IRUGO, show_ifindex, NULL),
256 __ATTR(features, S_IRUGO, show_features, NULL),
257 __ATTR(type, S_IRUGO, show_type, NULL),
Stefan Rompfb00055a2006-03-20 17:09:11 -0800258 __ATTR(link_mode, S_IRUGO, show_link_mode, NULL),
Kay Sieversfd586ba2005-12-19 01:42:56 +0100259 __ATTR(address, S_IRUGO, show_address, NULL),
260 __ATTR(broadcast, S_IRUGO, show_broadcast, NULL),
261 __ATTR(carrier, S_IRUGO, show_carrier, NULL),
Stefan Rompfb00055a2006-03-20 17:09:11 -0800262 __ATTR(dormant, S_IRUGO, show_dormant, NULL),
263 __ATTR(operstate, S_IRUGO, show_operstate, NULL),
Kay Sieversfd586ba2005-12-19 01:42:56 +0100264 __ATTR(mtu, S_IRUGO | S_IWUSR, show_mtu, store_mtu),
265 __ATTR(flags, S_IRUGO | S_IWUSR, show_flags, store_flags),
266 __ATTR(tx_queue_len, S_IRUGO | S_IWUSR, show_tx_queue_len,
267 store_tx_queue_len),
Kay Sieversfd586ba2005-12-19 01:42:56 +0100268 {}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269};
270
271/* Show a given an attribute in the statistics group */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700272static ssize_t netstat_show(const struct device *d,
273 struct device_attribute *attr, char *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274 unsigned long offset)
275{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700276 struct net_device *dev = to_net_dev(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 ssize_t ret = -EINVAL;
278
Pavel Emelyanovdf1b86c2007-11-30 00:42:42 +1100279 WARN_ON(offset > sizeof(struct net_device_stats) ||
280 offset % sizeof(unsigned long) != 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
282 read_lock(&dev_base_lock);
Pavel Emelyanov96e74082008-05-21 14:12:46 -0700283 if (dev_isalive(dev)) {
Stephen Hemmingereeda3fd2008-11-19 21:40:23 -0800284 const struct net_device_stats *stats = dev_get_stats(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 ret = sprintf(buf, fmt_ulong,
286 *(unsigned long *)(((u8 *) stats) + offset));
Pavel Emelyanov96e74082008-05-21 14:12:46 -0700287 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 read_unlock(&dev_base_lock);
289 return ret;
290}
291
292/* generate a read-only statistics attribute */
293#define NETSTAT_ENTRY(name) \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700294static ssize_t show_##name(struct device *d, \
295 struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296{ \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700297 return netstat_show(d, attr, buf, \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700298 offsetof(struct net_device_stats, name)); \
299} \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700300static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301
302NETSTAT_ENTRY(rx_packets);
303NETSTAT_ENTRY(tx_packets);
304NETSTAT_ENTRY(rx_bytes);
305NETSTAT_ENTRY(tx_bytes);
306NETSTAT_ENTRY(rx_errors);
307NETSTAT_ENTRY(tx_errors);
308NETSTAT_ENTRY(rx_dropped);
309NETSTAT_ENTRY(tx_dropped);
310NETSTAT_ENTRY(multicast);
311NETSTAT_ENTRY(collisions);
312NETSTAT_ENTRY(rx_length_errors);
313NETSTAT_ENTRY(rx_over_errors);
314NETSTAT_ENTRY(rx_crc_errors);
315NETSTAT_ENTRY(rx_frame_errors);
316NETSTAT_ENTRY(rx_fifo_errors);
317NETSTAT_ENTRY(rx_missed_errors);
318NETSTAT_ENTRY(tx_aborted_errors);
319NETSTAT_ENTRY(tx_carrier_errors);
320NETSTAT_ENTRY(tx_fifo_errors);
321NETSTAT_ENTRY(tx_heartbeat_errors);
322NETSTAT_ENTRY(tx_window_errors);
323NETSTAT_ENTRY(rx_compressed);
324NETSTAT_ENTRY(tx_compressed);
325
326static struct attribute *netstat_attrs[] = {
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700327 &dev_attr_rx_packets.attr,
328 &dev_attr_tx_packets.attr,
329 &dev_attr_rx_bytes.attr,
330 &dev_attr_tx_bytes.attr,
331 &dev_attr_rx_errors.attr,
332 &dev_attr_tx_errors.attr,
333 &dev_attr_rx_dropped.attr,
334 &dev_attr_tx_dropped.attr,
335 &dev_attr_multicast.attr,
336 &dev_attr_collisions.attr,
337 &dev_attr_rx_length_errors.attr,
338 &dev_attr_rx_over_errors.attr,
339 &dev_attr_rx_crc_errors.attr,
340 &dev_attr_rx_frame_errors.attr,
341 &dev_attr_rx_fifo_errors.attr,
342 &dev_attr_rx_missed_errors.attr,
343 &dev_attr_tx_aborted_errors.attr,
344 &dev_attr_tx_carrier_errors.attr,
345 &dev_attr_tx_fifo_errors.attr,
346 &dev_attr_tx_heartbeat_errors.attr,
347 &dev_attr_tx_window_errors.attr,
348 &dev_attr_rx_compressed.attr,
349 &dev_attr_tx_compressed.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 NULL
351};
352
353
354static struct attribute_group netstat_group = {
355 .name = "statistics",
356 .attrs = netstat_attrs,
357};
358
Johannes Berg22bb1be2008-07-10 11:16:47 +0200359#ifdef CONFIG_WIRELESS_EXT_SYSFS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360/* helper function that does all the locking etc for wireless stats */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700361static ssize_t wireless_show(struct device *d, char *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 ssize_t (*format)(const struct iw_statistics *,
363 char *))
364{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700365 struct net_device *dev = to_net_dev(d);
Johannes Berg8f1546c2009-09-28 15:26:43 +0200366 const struct iw_statistics *iw;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700367 ssize_t ret = -EINVAL;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900368
Johannes Berga160ee62009-10-05 02:22:23 -0700369 rtnl_lock();
Andrey Borzenkov6dd214b2006-01-09 20:51:28 -0800370 if (dev_isalive(dev)) {
Johannes Berg8f1546c2009-09-28 15:26:43 +0200371 iw = get_wireless_stats(dev);
372 if (iw)
Andrey Borzenkov6dd214b2006-01-09 20:51:28 -0800373 ret = (*format)(iw, buf);
374 }
Johannes Berga160ee62009-10-05 02:22:23 -0700375 rtnl_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700376
377 return ret;
378}
379
380/* show function template for wireless fields */
381#define WIRELESS_SHOW(name, field, format_string) \
382static ssize_t format_iw_##name(const struct iw_statistics *iw, char *buf) \
383{ \
384 return sprintf(buf, format_string, iw->field); \
385} \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700386static ssize_t show_iw_##name(struct device *d, \
387 struct device_attribute *attr, char *buf) \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388{ \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700389 return wireless_show(d, buf, format_iw_##name); \
Linus Torvalds1da177e2005-04-16 15:20:36 -0700390} \
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700391static DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392
393WIRELESS_SHOW(status, status, fmt_hex);
394WIRELESS_SHOW(link, qual.qual, fmt_dec);
395WIRELESS_SHOW(level, qual.level, fmt_dec);
396WIRELESS_SHOW(noise, qual.noise, fmt_dec);
397WIRELESS_SHOW(nwid, discard.nwid, fmt_dec);
398WIRELESS_SHOW(crypt, discard.code, fmt_dec);
399WIRELESS_SHOW(fragment, discard.fragment, fmt_dec);
400WIRELESS_SHOW(misc, discard.misc, fmt_dec);
401WIRELESS_SHOW(retries, discard.retries, fmt_dec);
402WIRELESS_SHOW(beacon, miss.beacon, fmt_dec);
403
404static struct attribute *wireless_attrs[] = {
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700405 &dev_attr_status.attr,
406 &dev_attr_link.attr,
407 &dev_attr_level.attr,
408 &dev_attr_noise.attr,
409 &dev_attr_nwid.attr,
410 &dev_attr_crypt.attr,
411 &dev_attr_fragment.attr,
412 &dev_attr_retries.attr,
413 &dev_attr_misc.attr,
414 &dev_attr_beacon.attr,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 NULL
416};
417
418static struct attribute_group wireless_group = {
419 .name = "wireless",
420 .attrs = wireless_attrs,
421};
422#endif
423
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700424#endif /* CONFIG_SYSFS */
425
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426#ifdef CONFIG_HOTPLUG
Kay Sievers7eff2e72007-08-14 15:15:12 +0200427static int netdev_uevent(struct device *d, struct kobj_uevent_env *env)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700429 struct net_device *dev = to_net_dev(d);
Kay Sievers7eff2e72007-08-14 15:15:12 +0200430 int retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431
Daniel Lezcano09bb5212008-11-25 16:46:37 -0800432 if (!net_eq(dev_net(dev), &init_net))
433 return 0;
434
Kay Sievers312c0042005-11-16 09:00:00 +0100435 /* pass interface to uevent. */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200436 retval = add_uevent_var(env, "INTERFACE=%s", dev->name);
Eric Rannaudbf624562007-03-30 22:23:12 -0700437 if (retval)
438 goto exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
Jean Tourrilhesca2f37d2007-03-07 10:49:30 -0800440 /* pass ifindex to uevent.
441 * ifindex is useful as it won't change (interface name may change)
442 * and is what RtNetlink uses natively. */
Kay Sievers7eff2e72007-08-14 15:15:12 +0200443 retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex);
Jean Tourrilhesca2f37d2007-03-07 10:49:30 -0800444
Eric Rannaudbf624562007-03-30 22:23:12 -0700445exit:
Eric Rannaudbf624562007-03-30 22:23:12 -0700446 return retval;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447}
448#endif
449
450/*
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900451 * netdev_release -- destroy and free a dead device.
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700452 * Called when last reference to device kobject is gone.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 */
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700454static void netdev_release(struct device *d)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700456 struct net_device *dev = to_net_dev(d);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457
458 BUG_ON(dev->reg_state != NETREG_RELEASED);
459
Stephen Hemminger0b815a12008-09-22 21:28:11 -0700460 kfree(dev->ifalias);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 kfree((char *)dev - dev->padded);
462}
463
464static struct class net_class = {
465 .name = "net",
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700466 .dev_release = netdev_release,
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700467#ifdef CONFIG_SYSFS
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700468 .dev_attrs = net_class_attributes,
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700469#endif /* CONFIG_SYSFS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470#ifdef CONFIG_HOTPLUG
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700471 .dev_uevent = netdev_uevent,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472#endif
473};
474
Stephen Hemminger9093bbb2007-05-19 15:39:25 -0700475/* Delete sysfs entries but hold kobject reference until after all
476 * netdev references are gone.
477 */
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700478void netdev_unregister_kobject(struct net_device * net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479{
Stephen Hemminger9093bbb2007-05-19 15:39:25 -0700480 struct device *dev = &(net->dev);
481
482 kobject_get(&dev->kobj);
Eric W. Biederman38918452008-10-27 17:51:47 -0700483
484 if (dev_net(net) != &init_net)
485 return;
486
Stephen Hemminger9093bbb2007-05-19 15:39:25 -0700487 device_del(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488}
489
490/* Create sysfs entries for network device. */
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700491int netdev_register_kobject(struct net_device *net)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492{
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700493 struct device *dev = &(net->dev);
David Brownella4dbd672009-06-24 10:06:31 -0700494 const struct attribute_group **groups = net->sysfs_groups;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700496 dev->class = &net_class;
497 dev->platform_data = net;
498 dev->groups = groups;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499
Stephen Hemmingera2205472009-03-09 13:51:55 +0000500 dev_set_name(dev, "%s", net->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700502#ifdef CONFIG_SYSFS
Pavel Emelyanov96e74082008-05-21 14:12:46 -0700503 *groups++ = &netstat_group;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504
Johannes Berg22bb1be2008-07-10 11:16:47 +0200505#ifdef CONFIG_WIRELESS_EXT_SYSFS
Johannes Berg8f1546c2009-09-28 15:26:43 +0200506 if (net->wireless_handlers || net->ieee80211_ptr)
Stephen Hemmingerfe9925b2006-05-06 17:56:03 -0700507 *groups++ = &wireless_group;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508#endif
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700509#endif /* CONFIG_SYSFS */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
Eric W. Biederman38918452008-10-27 17:51:47 -0700511 if (dev_net(net) != &init_net)
512 return 0;
513
Greg Kroah-Hartman43cb76d2002-04-09 12:14:34 -0700514 return device_add(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515}
516
Jay Vosburghb8a97872008-06-13 18:12:04 -0700517int netdev_class_create_file(struct class_attribute *class_attr)
518{
519 return class_create_file(&net_class, class_attr);
520}
521
522void netdev_class_remove_file(struct class_attribute *class_attr)
523{
524 class_remove_file(&net_class, class_attr);
525}
526
527EXPORT_SYMBOL(netdev_class_create_file);
528EXPORT_SYMBOL(netdev_class_remove_file);
529
Daniel Lezcanoaaf8cdc2008-05-02 17:00:58 -0700530void netdev_initialize_kobject(struct net_device *net)
531{
532 struct device *device = &(net->dev);
533 device_initialize(device);
534}
535
Eric W. Biederman8b41d182007-09-26 22:02:53 -0700536int netdev_kobject_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700537{
538 return class_register(&net_class);
539}