net-sysfs.c 31.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4
/*
 * net-sysfs.c - network device class and attributes
 *
 * Copyright (c) 2003 Stephen Hemminger <shemminger@osdl.org>
5
 *
L
Linus Torvalds 已提交
6 7 8 9 10 11
 *	This program is free software; you can redistribute it and/or
 *	modify it under the terms of the GNU General Public License
 *	as published by the Free Software Foundation; either version
 *	2 of the License, or (at your option) any later version.
 */

12
#include <linux/capability.h>
L
Linus Torvalds 已提交
13 14 15
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/if_arp.h>
16
#include <linux/slab.h>
17
#include <linux/nsproxy.h>
L
Linus Torvalds 已提交
18
#include <net/sock.h>
19
#include <net/net_namespace.h>
L
Linus Torvalds 已提交
20 21
#include <linux/rtnetlink.h>
#include <linux/wireless.h>
T
Tom Herbert 已提交
22
#include <linux/vmalloc.h>
23
#include <linux/export.h>
24
#include <net/wext.h>
L
Linus Torvalds 已提交
25

26 27
#include "net-sysfs.h"

28
#ifdef CONFIG_SYSFS
L
Linus Torvalds 已提交
29
static const char fmt_hex[] = "%#x\n";
30
static const char fmt_long_hex[] = "%#lx\n";
L
Linus Torvalds 已提交
31
static const char fmt_dec[] = "%d\n";
32
static const char fmt_udec[] = "%u\n";
L
Linus Torvalds 已提交
33
static const char fmt_ulong[] = "%lu\n";
34
static const char fmt_u64[] = "%llu\n";
L
Linus Torvalds 已提交
35

36
static inline int dev_isalive(const struct net_device *dev)
L
Linus Torvalds 已提交
37
{
38
	return dev->reg_state <= NETREG_REGISTERED;
L
Linus Torvalds 已提交
39 40 41
}

/* use same locking rules as GIF* ioctl's */
42 43
static ssize_t netdev_show(const struct device *dev,
			   struct device_attribute *attr, char *buf,
L
Linus Torvalds 已提交
44 45
			   ssize_t (*format)(const struct net_device *, char *))
{
46
	struct net_device *net = to_net_dev(dev);
L
Linus Torvalds 已提交
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62
	ssize_t ret = -EINVAL;

	read_lock(&dev_base_lock);
	if (dev_isalive(net))
		ret = (*format)(net, buf);
	read_unlock(&dev_base_lock);

	return ret;
}

/* generate a show function for simple field */
#define NETDEVICE_SHOW(field, format_string)				\
static ssize_t format_##field(const struct net_device *net, char *buf)	\
{									\
	return sprintf(buf, format_string, net->field);			\
}									\
63 64
static ssize_t show_##field(struct device *dev,				\
			    struct device_attribute *attr, char *buf)	\
L
Linus Torvalds 已提交
65
{									\
66
	return netdev_show(dev, attr, buf, format_##field);		\
L
Linus Torvalds 已提交
67 68 69 70
}


/* use same locking and permission rules as SIF* ioctl's */
71
static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
L
Linus Torvalds 已提交
72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
			    const char *buf, size_t len,
			    int (*set)(struct net_device *, unsigned long))
{
	struct net_device *net = to_net_dev(dev);
	char *endp;
	unsigned long new;
	int ret = -EINVAL;

	if (!capable(CAP_NET_ADMIN))
		return -EPERM;

	new = simple_strtoul(buf, &endp, 0);
	if (endp == buf)
		goto err;

87
	if (!rtnl_trylock())
88
		return restart_syscall();
89

L
Linus Torvalds 已提交
90 91 92 93 94 95 96 97 98
	if (dev_isalive(net)) {
		if ((ret = (*set)(net, new)) == 0)
			ret = len;
	}
	rtnl_unlock();
 err:
	return ret;
}

99
NETDEVICE_SHOW(dev_id, fmt_hex);
100
NETDEVICE_SHOW(addr_assign_type, fmt_dec);
101 102 103 104
NETDEVICE_SHOW(addr_len, fmt_dec);
NETDEVICE_SHOW(iflink, fmt_dec);
NETDEVICE_SHOW(ifindex, fmt_dec);
NETDEVICE_SHOW(type, fmt_dec);
S
Stefan Rompf 已提交
105
NETDEVICE_SHOW(link_mode, fmt_dec);
L
Linus Torvalds 已提交
106 107

/* use same locking rules as GIFHWADDR ioctl's */
108 109
static ssize_t show_address(struct device *dev, struct device_attribute *attr,
			    char *buf)
L
Linus Torvalds 已提交
110 111 112 113 114 115
{
	struct net_device *net = to_net_dev(dev);
	ssize_t ret = -EINVAL;

	read_lock(&dev_base_lock);
	if (dev_isalive(net))
116
		ret = sysfs_format_mac(buf, net->dev_addr, net->addr_len);
L
Linus Torvalds 已提交
117 118 119 120
	read_unlock(&dev_base_lock);
	return ret;
}

121 122
static ssize_t show_broadcast(struct device *dev,
			    struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
123 124 125
{
	struct net_device *net = to_net_dev(dev);
	if (dev_isalive(net))
126
		return sysfs_format_mac(buf, net->broadcast, net->addr_len);
L
Linus Torvalds 已提交
127 128 129
	return -EINVAL;
}

130 131
static ssize_t show_carrier(struct device *dev,
			    struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
132 133 134 135 136 137 138 139
{
	struct net_device *netdev = to_net_dev(dev);
	if (netif_running(netdev)) {
		return sprintf(buf, fmt_dec, !!netif_carrier_ok(netdev));
	}
	return -EINVAL;
}

140 141 142 143 144 145 146 147 148
static ssize_t show_speed(struct device *dev,
			  struct device_attribute *attr, char *buf)
{
	struct net_device *netdev = to_net_dev(dev);
	int ret = -EINVAL;

	if (!rtnl_trylock())
		return restart_syscall();

149 150
	if (netif_running(netdev)) {
		struct ethtool_cmd cmd;
151
		if (!__ethtool_get_settings(netdev, &cmd))
152
			ret = sprintf(buf, fmt_udec, ethtool_cmd_speed(&cmd));
153 154 155 156 157 158 159 160 161 162 163 164 165 166
	}
	rtnl_unlock();
	return ret;
}

static ssize_t show_duplex(struct device *dev,
			   struct device_attribute *attr, char *buf)
{
	struct net_device *netdev = to_net_dev(dev);
	int ret = -EINVAL;

	if (!rtnl_trylock())
		return restart_syscall();

167 168
	if (netif_running(netdev)) {
		struct ethtool_cmd cmd;
169
		if (!__ethtool_get_settings(netdev, &cmd))
170 171
			ret = sprintf(buf, "%s\n",
				      cmd.duplex ? "full" : "half");
172 173 174 175 176
	}
	rtnl_unlock();
	return ret;
}

177 178
static ssize_t show_dormant(struct device *dev,
			    struct device_attribute *attr, char *buf)
S
Stefan Rompf 已提交
179 180 181 182 183 184 185 186 187
{
	struct net_device *netdev = to_net_dev(dev);

	if (netif_running(netdev))
		return sprintf(buf, fmt_dec, !!netif_dormant(netdev));

	return -EINVAL;
}

188
static const char *const operstates[] = {
S
Stefan Rompf 已提交
189 190 191 192 193 194 195 196 197
	"unknown",
	"notpresent", /* currently unused */
	"down",
	"lowerlayerdown",
	"testing", /* currently unused */
	"dormant",
	"up"
};

198 199
static ssize_t show_operstate(struct device *dev,
			      struct device_attribute *attr, char *buf)
S
Stefan Rompf 已提交
200 201 202 203 204 205 206 207 208 209
{
	const struct net_device *netdev = to_net_dev(dev);
	unsigned char operstate;

	read_lock(&dev_base_lock);
	operstate = netdev->operstate;
	if (!netif_running(netdev))
		operstate = IF_OPER_DOWN;
	read_unlock(&dev_base_lock);

210
	if (operstate >= ARRAY_SIZE(operstates))
S
Stefan Rompf 已提交
211 212 213 214 215
		return -EINVAL; /* should not happen */

	return sprintf(buf, "%s\n", operstates[operstate]);
}

L
Linus Torvalds 已提交
216 217 218 219 220 221 222 223
/* read-write attributes */
NETDEVICE_SHOW(mtu, fmt_dec);

static int change_mtu(struct net_device *net, unsigned long new_mtu)
{
	return dev_set_mtu(net, (int) new_mtu);
}

224 225
static ssize_t store_mtu(struct device *dev, struct device_attribute *attr,
			 const char *buf, size_t len)
L
Linus Torvalds 已提交
226
{
227
	return netdev_store(dev, attr, buf, len, change_mtu);
L
Linus Torvalds 已提交
228 229 230 231 232 233 234 235 236
}

NETDEVICE_SHOW(flags, fmt_hex);

static int change_flags(struct net_device *net, unsigned long new_flags)
{
	return dev_change_flags(net, (unsigned) new_flags);
}

237 238
static ssize_t store_flags(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t len)
L
Linus Torvalds 已提交
239
{
240
	return netdev_store(dev, attr, buf, len, change_flags);
L
Linus Torvalds 已提交
241 242 243 244 245 246 247 248 249 250
}

NETDEVICE_SHOW(tx_queue_len, fmt_ulong);

static int change_tx_queue_len(struct net_device *net, unsigned long new_len)
{
	net->tx_queue_len = new_len;
	return 0;
}

251 252 253
static ssize_t store_tx_queue_len(struct device *dev,
				  struct device_attribute *attr,
				  const char *buf, size_t len)
L
Linus Torvalds 已提交
254
{
255
	return netdev_store(dev, attr, buf, len, change_tx_queue_len);
L
Linus Torvalds 已提交
256 257
}

258 259 260 261 262 263 264 265 266 267 268 269 270 271
static ssize_t store_ifalias(struct device *dev, struct device_attribute *attr,
			     const char *buf, size_t len)
{
	struct net_device *netdev = to_net_dev(dev);
	size_t count = len;
	ssize_t ret;

	if (!capable(CAP_NET_ADMIN))
		return -EPERM;

	/* ignore trailing newline */
	if (len >  0 && buf[len - 1] == '\n')
		--count;

272 273
	if (!rtnl_trylock())
		return restart_syscall();
274 275 276 277 278 279 280 281 282 283 284 285
	ret = dev_set_alias(netdev, buf, count);
	rtnl_unlock();

	return ret < 0 ? ret : len;
}

static ssize_t show_ifalias(struct device *dev,
			    struct device_attribute *attr, char *buf)
{
	const struct net_device *netdev = to_net_dev(dev);
	ssize_t ret = 0;

286 287
	if (!rtnl_trylock())
		return restart_syscall();
288 289 290 291 292 293
	if (netdev->ifalias)
		ret = sprintf(buf, "%s\n", netdev->ifalias);
	rtnl_unlock();
	return ret;
}

294 295 296 297 298 299 300 301 302 303 304 305 306 307
NETDEVICE_SHOW(group, fmt_dec);

static int change_group(struct net_device *net, unsigned long new_group)
{
	dev_set_group(net, (int) new_group);
	return 0;
}

static ssize_t store_group(struct device *dev, struct device_attribute *attr,
			 const char *buf, size_t len)
{
	return netdev_store(dev, attr, buf, len, change_group);
}

308
static struct device_attribute net_class_attributes[] = {
309
	__ATTR(addr_assign_type, S_IRUGO, show_addr_assign_type, NULL),
310
	__ATTR(addr_len, S_IRUGO, show_addr_len, NULL),
311
	__ATTR(dev_id, S_IRUGO, show_dev_id, NULL),
312
	__ATTR(ifalias, S_IRUGO | S_IWUSR, show_ifalias, store_ifalias),
313 314 315
	__ATTR(iflink, S_IRUGO, show_iflink, NULL),
	__ATTR(ifindex, S_IRUGO, show_ifindex, NULL),
	__ATTR(type, S_IRUGO, show_type, NULL),
S
Stefan Rompf 已提交
316
	__ATTR(link_mode, S_IRUGO, show_link_mode, NULL),
317 318 319
	__ATTR(address, S_IRUGO, show_address, NULL),
	__ATTR(broadcast, S_IRUGO, show_broadcast, NULL),
	__ATTR(carrier, S_IRUGO, show_carrier, NULL),
320 321
	__ATTR(speed, S_IRUGO, show_speed, NULL),
	__ATTR(duplex, S_IRUGO, show_duplex, NULL),
S
Stefan Rompf 已提交
322 323
	__ATTR(dormant, S_IRUGO, show_dormant, NULL),
	__ATTR(operstate, S_IRUGO, show_operstate, NULL),
324 325 326 327
	__ATTR(mtu, S_IRUGO | S_IWUSR, show_mtu, store_mtu),
	__ATTR(flags, S_IRUGO | S_IWUSR, show_flags, store_flags),
	__ATTR(tx_queue_len, S_IRUGO | S_IWUSR, show_tx_queue_len,
	       store_tx_queue_len),
328
	__ATTR(netdev_group, S_IRUGO | S_IWUSR, show_group, store_group),
329
	{}
L
Linus Torvalds 已提交
330 331 332
};

/* Show a given an attribute in the statistics group */
333 334
static ssize_t netstat_show(const struct device *d,
			    struct device_attribute *attr, char *buf,
L
Linus Torvalds 已提交
335 336
			    unsigned long offset)
{
337
	struct net_device *dev = to_net_dev(d);
L
Linus Torvalds 已提交
338 339
	ssize_t ret = -EINVAL;

340 341
	WARN_ON(offset > sizeof(struct rtnl_link_stats64) ||
			offset % sizeof(u64) != 0);
L
Linus Torvalds 已提交
342 343

	read_lock(&dev_base_lock);
344
	if (dev_isalive(dev)) {
345 346 347
		struct rtnl_link_stats64 temp;
		const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);

348
		ret = sprintf(buf, fmt_u64, *(u64 *)(((u8 *) stats) + offset));
349
	}
L
Linus Torvalds 已提交
350 351 352 353 354 355
	read_unlock(&dev_base_lock);
	return ret;
}

/* generate a read-only statistics attribute */
#define NETSTAT_ENTRY(name)						\
356 357
static ssize_t show_##name(struct device *d,				\
			   struct device_attribute *attr, char *buf) 	\
L
Linus Torvalds 已提交
358
{									\
359
	return netstat_show(d, attr, buf,				\
360
			    offsetof(struct rtnl_link_stats64, name));	\
L
Linus Torvalds 已提交
361
}									\
362
static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
L
Linus Torvalds 已提交
363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388

NETSTAT_ENTRY(rx_packets);
NETSTAT_ENTRY(tx_packets);
NETSTAT_ENTRY(rx_bytes);
NETSTAT_ENTRY(tx_bytes);
NETSTAT_ENTRY(rx_errors);
NETSTAT_ENTRY(tx_errors);
NETSTAT_ENTRY(rx_dropped);
NETSTAT_ENTRY(tx_dropped);
NETSTAT_ENTRY(multicast);
NETSTAT_ENTRY(collisions);
NETSTAT_ENTRY(rx_length_errors);
NETSTAT_ENTRY(rx_over_errors);
NETSTAT_ENTRY(rx_crc_errors);
NETSTAT_ENTRY(rx_frame_errors);
NETSTAT_ENTRY(rx_fifo_errors);
NETSTAT_ENTRY(rx_missed_errors);
NETSTAT_ENTRY(tx_aborted_errors);
NETSTAT_ENTRY(tx_carrier_errors);
NETSTAT_ENTRY(tx_fifo_errors);
NETSTAT_ENTRY(tx_heartbeat_errors);
NETSTAT_ENTRY(tx_window_errors);
NETSTAT_ENTRY(rx_compressed);
NETSTAT_ENTRY(tx_compressed);

static struct attribute *netstat_attrs[] = {
389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411
	&dev_attr_rx_packets.attr,
	&dev_attr_tx_packets.attr,
	&dev_attr_rx_bytes.attr,
	&dev_attr_tx_bytes.attr,
	&dev_attr_rx_errors.attr,
	&dev_attr_tx_errors.attr,
	&dev_attr_rx_dropped.attr,
	&dev_attr_tx_dropped.attr,
	&dev_attr_multicast.attr,
	&dev_attr_collisions.attr,
	&dev_attr_rx_length_errors.attr,
	&dev_attr_rx_over_errors.attr,
	&dev_attr_rx_crc_errors.attr,
	&dev_attr_rx_frame_errors.attr,
	&dev_attr_rx_fifo_errors.attr,
	&dev_attr_rx_missed_errors.attr,
	&dev_attr_tx_aborted_errors.attr,
	&dev_attr_tx_carrier_errors.attr,
	&dev_attr_tx_fifo_errors.attr,
	&dev_attr_tx_heartbeat_errors.attr,
	&dev_attr_tx_window_errors.attr,
	&dev_attr_rx_compressed.attr,
	&dev_attr_tx_compressed.attr,
L
Linus Torvalds 已提交
412 413 414 415 416 417 418 419 420
	NULL
};


static struct attribute_group netstat_group = {
	.name  = "statistics",
	.attrs  = netstat_attrs,
};

421
#ifdef CONFIG_WIRELESS_EXT_SYSFS
L
Linus Torvalds 已提交
422
/* helper function that does all the locking etc for wireless stats */
423
static ssize_t wireless_show(struct device *d, char *buf,
L
Linus Torvalds 已提交
424 425 426
			     ssize_t (*format)(const struct iw_statistics *,
					       char *))
{
427
	struct net_device *dev = to_net_dev(d);
428
	const struct iw_statistics *iw;
L
Linus Torvalds 已提交
429
	ssize_t ret = -EINVAL;
430

431 432
	if (!rtnl_trylock())
		return restart_syscall();
433
	if (dev_isalive(dev)) {
434 435
		iw = get_wireless_stats(dev);
		if (iw)
436 437
			ret = (*format)(iw, buf);
	}
438
	rtnl_unlock();
L
Linus Torvalds 已提交
439 440 441 442 443 444 445 446 447 448

	return ret;
}

/* show function template for wireless fields */
#define WIRELESS_SHOW(name, field, format_string)			\
static ssize_t format_iw_##name(const struct iw_statistics *iw, char *buf) \
{									\
	return sprintf(buf, format_string, iw->field);			\
}									\
449 450
static ssize_t show_iw_##name(struct device *d,				\
			      struct device_attribute *attr, char *buf)	\
L
Linus Torvalds 已提交
451
{									\
452
	return wireless_show(d, buf, format_iw_##name);			\
L
Linus Torvalds 已提交
453
}									\
454
static DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL)
L
Linus Torvalds 已提交
455 456 457 458 459 460 461 462 463 464 465 466 467

WIRELESS_SHOW(status, status, fmt_hex);
WIRELESS_SHOW(link, qual.qual, fmt_dec);
WIRELESS_SHOW(level, qual.level, fmt_dec);
WIRELESS_SHOW(noise, qual.noise, fmt_dec);
WIRELESS_SHOW(nwid, discard.nwid, fmt_dec);
WIRELESS_SHOW(crypt, discard.code, fmt_dec);
WIRELESS_SHOW(fragment, discard.fragment, fmt_dec);
WIRELESS_SHOW(misc, discard.misc, fmt_dec);
WIRELESS_SHOW(retries, discard.retries, fmt_dec);
WIRELESS_SHOW(beacon, miss.beacon, fmt_dec);

static struct attribute *wireless_attrs[] = {
468 469 470 471 472 473 474 475 476 477
	&dev_attr_status.attr,
	&dev_attr_link.attr,
	&dev_attr_level.attr,
	&dev_attr_noise.attr,
	&dev_attr_nwid.attr,
	&dev_attr_crypt.attr,
	&dev_attr_fragment.attr,
	&dev_attr_retries.attr,
	&dev_attr_misc.attr,
	&dev_attr_beacon.attr,
L
Linus Torvalds 已提交
478 479 480 481 482 483 484 485
	NULL
};

static struct attribute_group wireless_group = {
	.name = "wireless",
	.attrs = wireless_attrs,
};
#endif
486
#endif /* CONFIG_SYSFS */
L
Linus Torvalds 已提交
487

488
#ifdef CONFIG_RPS
T
Tom Herbert 已提交
489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527
/*
 * RX queue sysfs structures and functions.
 */
struct rx_queue_attribute {
	struct attribute attr;
	ssize_t (*show)(struct netdev_rx_queue *queue,
	    struct rx_queue_attribute *attr, char *buf);
	ssize_t (*store)(struct netdev_rx_queue *queue,
	    struct rx_queue_attribute *attr, const char *buf, size_t len);
};
#define to_rx_queue_attr(_attr) container_of(_attr,		\
    struct rx_queue_attribute, attr)

#define to_rx_queue(obj) container_of(obj, struct netdev_rx_queue, kobj)

static ssize_t rx_queue_attr_show(struct kobject *kobj, struct attribute *attr,
				  char *buf)
{
	struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
	struct netdev_rx_queue *queue = to_rx_queue(kobj);

	if (!attribute->show)
		return -EIO;

	return attribute->show(queue, attribute, buf);
}

static ssize_t rx_queue_attr_store(struct kobject *kobj, struct attribute *attr,
				   const char *buf, size_t count)
{
	struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
	struct netdev_rx_queue *queue = to_rx_queue(kobj);

	if (!attribute->store)
		return -EIO;

	return attribute->store(queue, attribute, buf, count);
}

528
static const struct sysfs_ops rx_queue_sysfs_ops = {
T
Tom Herbert 已提交
529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562
	.show = rx_queue_attr_show,
	.store = rx_queue_attr_store,
};

static ssize_t show_rps_map(struct netdev_rx_queue *queue,
			    struct rx_queue_attribute *attribute, char *buf)
{
	struct rps_map *map;
	cpumask_var_t mask;
	size_t len = 0;
	int i;

	if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
		return -ENOMEM;

	rcu_read_lock();
	map = rcu_dereference(queue->rps_map);
	if (map)
		for (i = 0; i < map->len; i++)
			cpumask_set_cpu(map->cpus[i], mask);

	len += cpumask_scnprintf(buf + len, PAGE_SIZE, mask);
	if (PAGE_SIZE - len < 3) {
		rcu_read_unlock();
		free_cpumask_var(mask);
		return -EINVAL;
	}
	rcu_read_unlock();

	free_cpumask_var(mask);
	len += sprintf(buf + len, "\n");
	return len;
}

E
Eric Dumazet 已提交
563
static ssize_t store_rps_map(struct netdev_rx_queue *queue,
T
Tom Herbert 已提交
564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603
		      struct rx_queue_attribute *attribute,
		      const char *buf, size_t len)
{
	struct rps_map *old_map, *map;
	cpumask_var_t mask;
	int err, cpu, i;
	static DEFINE_SPINLOCK(rps_map_lock);

	if (!capable(CAP_NET_ADMIN))
		return -EPERM;

	if (!alloc_cpumask_var(&mask, GFP_KERNEL))
		return -ENOMEM;

	err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
	if (err) {
		free_cpumask_var(mask);
		return err;
	}

	map = kzalloc(max_t(unsigned,
	    RPS_MAP_SIZE(cpumask_weight(mask)), L1_CACHE_BYTES),
	    GFP_KERNEL);
	if (!map) {
		free_cpumask_var(mask);
		return -ENOMEM;
	}

	i = 0;
	for_each_cpu_and(cpu, mask, cpu_online_mask)
		map->cpus[i++] = cpu;

	if (i)
		map->len = i;
	else {
		kfree(map);
		map = NULL;
	}

	spin_lock(&rps_map_lock);
E
Eric Dumazet 已提交
604 605
	old_map = rcu_dereference_protected(queue->rps_map,
					    lockdep_is_held(&rps_map_lock));
T
Tom Herbert 已提交
606 607 608 609
	rcu_assign_pointer(queue->rps_map, map);
	spin_unlock(&rps_map_lock);

	if (old_map)
610
		kfree_rcu(old_map, rcu);
T
Tom Herbert 已提交
611 612 613 614 615

	free_cpumask_var(mask);
	return len;
}

T
Tom Herbert 已提交
616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648
static ssize_t show_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
					   struct rx_queue_attribute *attr,
					   char *buf)
{
	struct rps_dev_flow_table *flow_table;
	unsigned int val = 0;

	rcu_read_lock();
	flow_table = rcu_dereference(queue->rps_flow_table);
	if (flow_table)
		val = flow_table->mask + 1;
	rcu_read_unlock();

	return sprintf(buf, "%u\n", val);
}

static void rps_dev_flow_table_release_work(struct work_struct *work)
{
	struct rps_dev_flow_table *table = container_of(work,
	    struct rps_dev_flow_table, free_work);

	vfree(table);
}

static void rps_dev_flow_table_release(struct rcu_head *rcu)
{
	struct rps_dev_flow_table *table = container_of(rcu,
	    struct rps_dev_flow_table, rcu);

	INIT_WORK(&table->free_work, rps_dev_flow_table_release_work);
	schedule_work(&table->free_work);
}

E
Eric Dumazet 已提交
649
static ssize_t store_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
T
Tom Herbert 已提交
650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667
				     struct rx_queue_attribute *attr,
				     const char *buf, size_t len)
{
	unsigned int count;
	char *endp;
	struct rps_dev_flow_table *table, *old_table;
	static DEFINE_SPINLOCK(rps_dev_flow_lock);

	if (!capable(CAP_NET_ADMIN))
		return -EPERM;

	count = simple_strtoul(buf, &endp, 0);
	if (endp == buf)
		return -EINVAL;

	if (count) {
		int i;

668 669 670 671 672
		if (count > INT_MAX)
			return -EINVAL;
		count = roundup_pow_of_two(count);
		if (count > (ULONG_MAX - sizeof(struct rps_dev_flow_table))
				/ sizeof(struct rps_dev_flow)) {
T
Tom Herbert 已提交
673 674 675 676 677 678 679 680 681 682 683 684 685 686
			/* Enforce a limit to prevent overflow */
			return -EINVAL;
		}
		table = vmalloc(RPS_DEV_FLOW_TABLE_SIZE(count));
		if (!table)
			return -ENOMEM;

		table->mask = count - 1;
		for (i = 0; i < count; i++)
			table->flows[i].cpu = RPS_NO_CPU;
	} else
		table = NULL;

	spin_lock(&rps_dev_flow_lock);
E
Eric Dumazet 已提交
687 688
	old_table = rcu_dereference_protected(queue->rps_flow_table,
					      lockdep_is_held(&rps_dev_flow_lock));
T
Tom Herbert 已提交
689 690 691 692 693 694 695 696 697
	rcu_assign_pointer(queue->rps_flow_table, table);
	spin_unlock(&rps_dev_flow_lock);

	if (old_table)
		call_rcu(&old_table->rcu, rps_dev_flow_table_release);

	return len;
}

T
Tom Herbert 已提交
698 699 700
static struct rx_queue_attribute rps_cpus_attribute =
	__ATTR(rps_cpus, S_IRUGO | S_IWUSR, show_rps_map, store_rps_map);

T
Tom Herbert 已提交
701 702 703 704 705

static struct rx_queue_attribute rps_dev_flow_table_cnt_attribute =
	__ATTR(rps_flow_cnt, S_IRUGO | S_IWUSR,
	    show_rps_dev_flow_table_cnt, store_rps_dev_flow_table_cnt);

T
Tom Herbert 已提交
706 707
static struct attribute *rx_queue_default_attrs[] = {
	&rps_cpus_attribute.attr,
T
Tom Herbert 已提交
708
	&rps_dev_flow_table_cnt_attribute.attr,
T
Tom Herbert 已提交
709 710 711 712 713 714
	NULL
};

static void rx_queue_release(struct kobject *kobj)
{
	struct netdev_rx_queue *queue = to_rx_queue(kobj);
E
Eric Dumazet 已提交
715 716
	struct rps_map *map;
	struct rps_dev_flow_table *flow_table;
T
Tom Herbert 已提交
717

T
Tom Herbert 已提交
718

719
	map = rcu_dereference_protected(queue->rps_map, 1);
720 721
	if (map) {
		RCU_INIT_POINTER(queue->rps_map, NULL);
722
		kfree_rcu(map, rcu);
723
	}
E
Eric Dumazet 已提交
724

725
	flow_table = rcu_dereference_protected(queue->rps_flow_table, 1);
726 727
	if (flow_table) {
		RCU_INIT_POINTER(queue->rps_flow_table, NULL);
E
Eric Dumazet 已提交
728
		call_rcu(&flow_table->rcu, rps_dev_flow_table_release);
729
	}
T
Tom Herbert 已提交
730

731
	memset(kobj, 0, sizeof(*kobj));
T
Tom Herbert 已提交
732
	dev_put(queue->dev);
T
Tom Herbert 已提交
733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755
}

static struct kobj_type rx_queue_ktype = {
	.sysfs_ops = &rx_queue_sysfs_ops,
	.release = rx_queue_release,
	.default_attrs = rx_queue_default_attrs,
};

static int rx_queue_add_kobject(struct net_device *net, int index)
{
	struct netdev_rx_queue *queue = net->_rx + index;
	struct kobject *kobj = &queue->kobj;
	int error = 0;

	kobj->kset = net->queues_kset;
	error = kobject_init_and_add(kobj, &rx_queue_ktype, NULL,
	    "rx-%u", index);
	if (error) {
		kobject_put(kobj);
		return error;
	}

	kobject_uevent(kobj, KOBJ_ADD);
T
Tom Herbert 已提交
756
	dev_hold(queue->dev);
T
Tom Herbert 已提交
757 758 759

	return error;
}
T
Tom Herbert 已提交
760
#endif /* CONFIG_RPS */
T
Tom Herbert 已提交
761

762 763
int
net_rx_queue_update_kobjects(struct net_device *net, int old_num, int new_num)
T
Tom Herbert 已提交
764
{
T
Tom Herbert 已提交
765
#ifdef CONFIG_RPS
T
Tom Herbert 已提交
766 767 768
	int i;
	int error = 0;

769
	for (i = old_num; i < new_num; i++) {
T
Tom Herbert 已提交
770
		error = rx_queue_add_kobject(net, i);
771 772
		if (error) {
			new_num = old_num;
T
Tom Herbert 已提交
773
			break;
774
		}
T
Tom Herbert 已提交
775 776
	}

777 778
	while (--i >= new_num)
		kobject_put(&net->_rx[i].kobj);
T
Tom Herbert 已提交
779 780

	return error;
T
Tom Herbert 已提交
781 782 783
#else
	return 0;
#endif
T
Tom Herbert 已提交
784 785
}

T
Tom Herbert 已提交
786
#ifdef CONFIG_XPS
T
Tom Herbert 已提交
787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832
/*
 * netdev_queue sysfs structures and functions.
 */
struct netdev_queue_attribute {
	struct attribute attr;
	ssize_t (*show)(struct netdev_queue *queue,
	    struct netdev_queue_attribute *attr, char *buf);
	ssize_t (*store)(struct netdev_queue *queue,
	    struct netdev_queue_attribute *attr, const char *buf, size_t len);
};
#define to_netdev_queue_attr(_attr) container_of(_attr,		\
    struct netdev_queue_attribute, attr)

#define to_netdev_queue(obj) container_of(obj, struct netdev_queue, kobj)

static ssize_t netdev_queue_attr_show(struct kobject *kobj,
				      struct attribute *attr, char *buf)
{
	struct netdev_queue_attribute *attribute = to_netdev_queue_attr(attr);
	struct netdev_queue *queue = to_netdev_queue(kobj);

	if (!attribute->show)
		return -EIO;

	return attribute->show(queue, attribute, buf);
}

static ssize_t netdev_queue_attr_store(struct kobject *kobj,
				       struct attribute *attr,
				       const char *buf, size_t count)
{
	struct netdev_queue_attribute *attribute = to_netdev_queue_attr(attr);
	struct netdev_queue *queue = to_netdev_queue(kobj);

	if (!attribute->store)
		return -EIO;

	return attribute->store(queue, attribute, buf, count);
}

static const struct sysfs_ops netdev_queue_sysfs_ops = {
	.show = netdev_queue_attr_show,
	.store = netdev_queue_attr_store,
};

static inline unsigned int get_netdev_queue_index(struct netdev_queue *queue)
T
Tom Herbert 已提交
833
{
T
Tom Herbert 已提交
834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892
	struct net_device *dev = queue->dev;
	int i;

	for (i = 0; i < dev->num_tx_queues; i++)
		if (queue == &dev->_tx[i])
			break;

	BUG_ON(i >= dev->num_tx_queues);

	return i;
}


static ssize_t show_xps_map(struct netdev_queue *queue,
			    struct netdev_queue_attribute *attribute, char *buf)
{
	struct net_device *dev = queue->dev;
	struct xps_dev_maps *dev_maps;
	cpumask_var_t mask;
	unsigned long index;
	size_t len = 0;
	int i;

	if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
		return -ENOMEM;

	index = get_netdev_queue_index(queue);

	rcu_read_lock();
	dev_maps = rcu_dereference(dev->xps_maps);
	if (dev_maps) {
		for_each_possible_cpu(i) {
			struct xps_map *map =
			    rcu_dereference(dev_maps->cpu_map[i]);
			if (map) {
				int j;
				for (j = 0; j < map->len; j++) {
					if (map->queues[j] == index) {
						cpumask_set_cpu(i, mask);
						break;
					}
				}
			}
		}
	}
	rcu_read_unlock();

	len += cpumask_scnprintf(buf + len, PAGE_SIZE, mask);
	if (PAGE_SIZE - len < 3) {
		free_cpumask_var(mask);
		return -EINVAL;
	}

	free_cpumask_var(mask);
	len += sprintf(buf + len, "\n");
	return len;
}

static DEFINE_MUTEX(xps_map_mutex);
E
Eric Dumazet 已提交
893 894
#define xmap_dereference(P)		\
	rcu_dereference_protected((P), lockdep_is_held(&xps_map_mutex))
T
Tom Herbert 已提交
895 896 897 898 899 900 901 902 903 904 905 906

static ssize_t store_xps_map(struct netdev_queue *queue,
		      struct netdev_queue_attribute *attribute,
		      const char *buf, size_t len)
{
	struct net_device *dev = queue->dev;
	cpumask_var_t mask;
	int err, i, cpu, pos, map_len, alloc_len, need_set;
	unsigned long index;
	struct xps_map *map, *new_map;
	struct xps_dev_maps *dev_maps, *new_dev_maps;
	int nonempty = 0;
907
	int numa_node = -2;
T
Tom Herbert 已提交
908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931

	if (!capable(CAP_NET_ADMIN))
		return -EPERM;

	if (!alloc_cpumask_var(&mask, GFP_KERNEL))
		return -ENOMEM;

	index = get_netdev_queue_index(queue);

	err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
	if (err) {
		free_cpumask_var(mask);
		return err;
	}

	new_dev_maps = kzalloc(max_t(unsigned,
	    XPS_DEV_MAPS_SIZE, L1_CACHE_BYTES), GFP_KERNEL);
	if (!new_dev_maps) {
		free_cpumask_var(mask);
		return -ENOMEM;
	}

	mutex_lock(&xps_map_mutex);

E
Eric Dumazet 已提交
932
	dev_maps = xmap_dereference(dev->xps_maps);
T
Tom Herbert 已提交
933 934

	for_each_possible_cpu(cpu) {
E
Eric Dumazet 已提交
935 936 937
		map = dev_maps ?
			xmap_dereference(dev_maps->cpu_map[cpu]) : NULL;
		new_map = map;
T
Tom Herbert 已提交
938 939 940 941 942 943 944 945 946
		if (map) {
			for (pos = 0; pos < map->len; pos++)
				if (map->queues[pos] == index)
					break;
			map_len = map->len;
			alloc_len = map->alloc_len;
		} else
			pos = map_len = alloc_len = 0;

947
		need_set = cpumask_test_cpu(cpu, mask) && cpu_online(cpu);
948 949 950 951 952 953 954 955
#ifdef CONFIG_NUMA
		if (need_set) {
			if (numa_node == -2)
				numa_node = cpu_to_node(cpu);
			else if (numa_node != cpu_to_node(cpu))
				numa_node = -1;
		}
#endif
T
Tom Herbert 已提交
956 957 958 959 960
		if (need_set && pos >= map_len) {
			/* Need to add queue to this CPU's map */
			if (map_len >= alloc_len) {
				alloc_len = alloc_len ?
				    2 * alloc_len : XPS_MIN_MAP_ALLOC;
961 962 963
				new_map = kzalloc_node(XPS_MAP_SIZE(alloc_len),
						       GFP_KERNEL,
						       cpu_to_node(cpu));
T
Tom Herbert 已提交
964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979
				if (!new_map)
					goto error;
				new_map->alloc_len = alloc_len;
				for (i = 0; i < map_len; i++)
					new_map->queues[i] = map->queues[i];
				new_map->len = map_len;
			}
			new_map->queues[new_map->len++] = index;
		} else if (!need_set && pos < map_len) {
			/* Need to remove queue from this CPU's map */
			if (map_len > 1)
				new_map->queues[pos] =
				    new_map->queues[--new_map->len];
			else
				new_map = NULL;
		}
E
Eric Dumazet 已提交
980
		RCU_INIT_POINTER(new_dev_maps->cpu_map[cpu], new_map);
T
Tom Herbert 已提交
981 982 983 984
	}

	/* Cleanup old maps */
	for_each_possible_cpu(cpu) {
E
Eric Dumazet 已提交
985 986 987
		map = dev_maps ?
			xmap_dereference(dev_maps->cpu_map[cpu]) : NULL;
		if (map && xmap_dereference(new_dev_maps->cpu_map[cpu]) != map)
988
			kfree_rcu(map, rcu);
T
Tom Herbert 已提交
989 990 991 992 993
		if (new_dev_maps->cpu_map[cpu])
			nonempty = 1;
	}

	if (nonempty)
994
		RCU_INIT_POINTER(dev->xps_maps, new_dev_maps);
T
Tom Herbert 已提交
995 996
	else {
		kfree(new_dev_maps);
997
		RCU_INIT_POINTER(dev->xps_maps, NULL);
T
Tom Herbert 已提交
998 999 1000
	}

	if (dev_maps)
1001
		kfree_rcu(dev_maps, rcu);
T
Tom Herbert 已提交
1002

1003 1004
	netdev_queue_numa_node_write(queue, (numa_node >= 0) ? numa_node :
					    NUMA_NO_NODE);
1005

T
Tom Herbert 已提交
1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
	mutex_unlock(&xps_map_mutex);

	free_cpumask_var(mask);
	return len;

error:
	mutex_unlock(&xps_map_mutex);

	if (new_dev_maps)
		for_each_possible_cpu(i)
E
Eric Dumazet 已提交
1016 1017 1018
			kfree(rcu_dereference_protected(
				new_dev_maps->cpu_map[i],
				1));
T
Tom Herbert 已提交
1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043
	kfree(new_dev_maps);
	free_cpumask_var(mask);
	return -ENOMEM;
}

static struct netdev_queue_attribute xps_cpus_attribute =
    __ATTR(xps_cpus, S_IRUGO | S_IWUSR, show_xps_map, store_xps_map);

static struct attribute *netdev_queue_default_attrs[] = {
	&xps_cpus_attribute.attr,
	NULL
};

static void netdev_queue_release(struct kobject *kobj)
{
	struct netdev_queue *queue = to_netdev_queue(kobj);
	struct net_device *dev = queue->dev;
	struct xps_dev_maps *dev_maps;
	struct xps_map *map;
	unsigned long index;
	int i, pos, nonempty = 0;

	index = get_netdev_queue_index(queue);

	mutex_lock(&xps_map_mutex);
E
Eric Dumazet 已提交
1044
	dev_maps = xmap_dereference(dev->xps_maps);
T
Tom Herbert 已提交
1045 1046 1047

	if (dev_maps) {
		for_each_possible_cpu(i) {
E
Eric Dumazet 已提交
1048
			map = xmap_dereference(dev_maps->cpu_map[i]);
T
Tom Herbert 已提交
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
			if (!map)
				continue;

			for (pos = 0; pos < map->len; pos++)
				if (map->queues[pos] == index)
					break;

			if (pos < map->len) {
				if (map->len > 1)
					map->queues[pos] =
					    map->queues[--map->len];
				else {
					RCU_INIT_POINTER(dev_maps->cpu_map[i],
					    NULL);
1063
					kfree_rcu(map, rcu);
T
Tom Herbert 已提交
1064 1065 1066 1067 1068 1069 1070 1071 1072
					map = NULL;
				}
			}
			if (map)
				nonempty = 1;
		}

		if (!nonempty) {
			RCU_INIT_POINTER(dev->xps_maps, NULL);
1073
			kfree_rcu(dev_maps, rcu);
T
Tom Herbert 已提交
1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107
		}
	}

	mutex_unlock(&xps_map_mutex);

	memset(kobj, 0, sizeof(*kobj));
	dev_put(queue->dev);
}

static struct kobj_type netdev_queue_ktype = {
	.sysfs_ops = &netdev_queue_sysfs_ops,
	.release = netdev_queue_release,
	.default_attrs = netdev_queue_default_attrs,
};

static int netdev_queue_add_kobject(struct net_device *net, int index)
{
	struct netdev_queue *queue = net->_tx + index;
	struct kobject *kobj = &queue->kobj;
	int error = 0;

	kobj->kset = net->queues_kset;
	error = kobject_init_and_add(kobj, &netdev_queue_ktype, NULL,
	    "tx-%u", index);
	if (error) {
		kobject_put(kobj);
		return error;
	}

	kobject_uevent(kobj, KOBJ_ADD);
	dev_hold(queue->dev);

	return error;
}
T
Tom Herbert 已提交
1108
#endif /* CONFIG_XPS */
T
Tom Herbert 已提交
1109 1110 1111 1112

int
netdev_queue_update_kobjects(struct net_device *net, int old_num, int new_num)
{
T
Tom Herbert 已提交
1113
#ifdef CONFIG_XPS
T
Tom Herbert 已提交
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
	int i;
	int error = 0;

	for (i = old_num; i < new_num; i++) {
		error = netdev_queue_add_kobject(net, i);
		if (error) {
			new_num = old_num;
			break;
		}
	}

	while (--i >= new_num)
		kobject_put(&net->_tx[i].kobj);

	return error;
T
Tom Herbert 已提交
1129 1130 1131
#else
	return 0;
#endif
T
Tom Herbert 已提交
1132 1133 1134 1135
}

static int register_queue_kobjects(struct net_device *net)
{
T
Tom Herbert 已提交
1136
	int error = 0, txq = 0, rxq = 0, real_rx = 0, real_tx = 0;
T
Tom Herbert 已提交
1137

T
Tom Herbert 已提交
1138
#if defined(CONFIG_RPS) || defined(CONFIG_XPS)
1139 1140 1141 1142
	net->queues_kset = kset_create_and_add("queues",
	    NULL, &net->dev.kobj);
	if (!net->queues_kset)
		return -ENOMEM;
T
Tom Herbert 已提交
1143 1144 1145 1146 1147 1148
#endif

#ifdef CONFIG_RPS
	real_rx = net->real_num_rx_queues;
#endif
	real_tx = net->real_num_tx_queues;
T
Tom Herbert 已提交
1149

T
Tom Herbert 已提交
1150
	error = net_rx_queue_update_kobjects(net, 0, real_rx);
T
Tom Herbert 已提交
1151 1152
	if (error)
		goto error;
T
Tom Herbert 已提交
1153
	rxq = real_rx;
T
Tom Herbert 已提交
1154

T
Tom Herbert 已提交
1155
	error = netdev_queue_update_kobjects(net, 0, real_tx);
T
Tom Herbert 已提交
1156 1157
	if (error)
		goto error;
T
Tom Herbert 已提交
1158
	txq = real_tx;
T
Tom Herbert 已提交
1159 1160 1161 1162 1163 1164 1165

	return 0;

error:
	netdev_queue_update_kobjects(net, txq, 0);
	net_rx_queue_update_kobjects(net, rxq, 0);
	return error;
1166
}
T
Tom Herbert 已提交
1167

T
Tom Herbert 已提交
1168
static void remove_queue_kobjects(struct net_device *net)
1169
{
T
Tom Herbert 已提交
1170 1171 1172 1173 1174 1175 1176 1177 1178 1179
	int real_rx = 0, real_tx = 0;

#ifdef CONFIG_RPS
	real_rx = net->real_num_rx_queues;
#endif
	real_tx = net->real_num_tx_queues;

	net_rx_queue_update_kobjects(net, real_rx, 0);
	netdev_queue_update_kobjects(net, real_tx, 0);
#if defined(CONFIG_RPS) || defined(CONFIG_XPS)
T
Tom Herbert 已提交
1180
	kset_unregister(net->queues_kset);
T
Tom Herbert 已提交
1181
#endif
T
Tom Herbert 已提交
1182
}
1183

1184
static void *net_grab_current_ns(void)
1185
{
1186 1187 1188 1189 1190 1191
	struct net *ns = current->nsproxy->net_ns;
#ifdef CONFIG_NET_NS
	if (ns)
		atomic_inc(&ns->passive);
#endif
	return ns;
1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203
}

static const void *net_initial_ns(void)
{
	return &init_net;
}

static const void *net_netlink_ns(struct sock *sk)
{
	return sock_net(sk);
}

1204
struct kobj_ns_type_operations net_ns_type_operations = {
1205
	.type = KOBJ_NS_TYPE_NET,
1206
	.grab_current_ns = net_grab_current_ns,
1207 1208
	.netlink_ns = net_netlink_ns,
	.initial_ns = net_initial_ns,
1209
	.drop_ns = net_drop_ns,
1210
};
1211
EXPORT_SYMBOL_GPL(net_ns_type_operations);
1212

L
Linus Torvalds 已提交
1213
#ifdef CONFIG_HOTPLUG
1214
static int netdev_uevent(struct device *d, struct kobj_uevent_env *env)
L
Linus Torvalds 已提交
1215
{
1216
	struct net_device *dev = to_net_dev(d);
1217
	int retval;
L
Linus Torvalds 已提交
1218

1219
	/* pass interface to uevent. */
1220
	retval = add_uevent_var(env, "INTERFACE=%s", dev->name);
1221 1222
	if (retval)
		goto exit;
1223 1224 1225 1226

	/* pass ifindex to uevent.
	 * ifindex is useful as it won't change (interface name may change)
	 * and is what RtNetlink uses natively. */
1227
	retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex);
L
Linus Torvalds 已提交
1228

1229 1230
exit:
	return retval;
L
Linus Torvalds 已提交
1231 1232 1233 1234
}
#endif

/*
1235
 *	netdev_release -- destroy and free a dead device.
1236
 *	Called when last reference to device kobject is gone.
L
Linus Torvalds 已提交
1237
 */
1238
static void netdev_release(struct device *d)
L
Linus Torvalds 已提交
1239
{
1240
	struct net_device *dev = to_net_dev(d);
L
Linus Torvalds 已提交
1241 1242 1243

	BUG_ON(dev->reg_state != NETREG_RELEASED);

1244
	kfree(dev->ifalias);
L
Linus Torvalds 已提交
1245 1246 1247
	kfree((char *)dev - dev->padded);
}

1248 1249 1250 1251 1252 1253 1254
static const void *net_namespace(struct device *d)
{
	struct net_device *dev;
	dev = container_of(d, struct net_device, dev);
	return dev_net(dev);
}

L
Linus Torvalds 已提交
1255 1256
static struct class net_class = {
	.name = "net",
1257
	.dev_release = netdev_release,
1258
#ifdef CONFIG_SYSFS
1259
	.dev_attrs = net_class_attributes,
1260
#endif /* CONFIG_SYSFS */
L
Linus Torvalds 已提交
1261
#ifdef CONFIG_HOTPLUG
1262
	.dev_uevent = netdev_uevent,
L
Linus Torvalds 已提交
1263
#endif
1264 1265
	.ns_type = &net_ns_type_operations,
	.namespace = net_namespace,
L
Linus Torvalds 已提交
1266 1267
};

1268 1269 1270
/* Delete sysfs entries but hold kobject reference until after all
 * netdev references are gone.
 */
1271
void netdev_unregister_kobject(struct net_device * net)
L
Linus Torvalds 已提交
1272
{
1273 1274 1275
	struct device *dev = &(net->dev);

	kobject_get(&dev->kobj);
1276

T
Tom Herbert 已提交
1277
	remove_queue_kobjects(net);
T
Tom Herbert 已提交
1278

1279
	device_del(dev);
L
Linus Torvalds 已提交
1280 1281 1282
}

/* Create sysfs entries for network device. */
1283
int netdev_register_kobject(struct net_device *net)
L
Linus Torvalds 已提交
1284
{
1285
	struct device *dev = &(net->dev);
1286
	const struct attribute_group **groups = net->sysfs_groups;
T
Tom Herbert 已提交
1287
	int error = 0;
L
Linus Torvalds 已提交
1288

1289
	device_initialize(dev);
1290 1291 1292
	dev->class = &net_class;
	dev->platform_data = net;
	dev->groups = groups;
L
Linus Torvalds 已提交
1293

1294
	dev_set_name(dev, "%s", net->name);
L
Linus Torvalds 已提交
1295

1296
#ifdef CONFIG_SYSFS
1297 1298 1299
	/* Allow for a device specific group */
	if (*groups)
		groups++;
L
Linus Torvalds 已提交
1300

1301
	*groups++ = &netstat_group;
1302
#ifdef CONFIG_WIRELESS_EXT_SYSFS
J
Johannes Berg 已提交
1303
	if (net->ieee80211_ptr)
1304
		*groups++ = &wireless_group;
J
Johannes Berg 已提交
1305 1306 1307 1308
#ifdef CONFIG_WIRELESS_EXT
	else if (net->wireless_handlers)
		*groups++ = &wireless_group;
#endif
L
Linus Torvalds 已提交
1309
#endif
1310
#endif /* CONFIG_SYSFS */
L
Linus Torvalds 已提交
1311

T
Tom Herbert 已提交
1312 1313 1314 1315
	error = device_add(dev);
	if (error)
		return error;

T
Tom Herbert 已提交
1316
	error = register_queue_kobjects(net);
T
Tom Herbert 已提交
1317 1318 1319 1320 1321 1322
	if (error) {
		device_del(dev);
		return error;
	}

	return error;
L
Linus Torvalds 已提交
1323 1324
}

1325 1326 1327 1328
int netdev_class_create_file(struct class_attribute *class_attr)
{
	return class_create_file(&net_class, class_attr);
}
E
Eric Dumazet 已提交
1329
EXPORT_SYMBOL(netdev_class_create_file);
1330 1331 1332 1333 1334 1335 1336

void netdev_class_remove_file(struct class_attribute *class_attr)
{
	class_remove_file(&net_class, class_attr);
}
EXPORT_SYMBOL(netdev_class_remove_file);

1337
int netdev_kobject_init(void)
L
Linus Torvalds 已提交
1338
{
1339
	kobj_ns_type_register(&net_ns_type_operations);
L
Linus Torvalds 已提交
1340 1341
	return class_register(&net_class);
}