net-sysfs.c 23.1 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 <net/wext.h>
L
Linus Torvalds 已提交
24

25 26
#include "net-sysfs.h"

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

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

/* use same locking rules as GIF* ioctl's */
40 41
static ssize_t netdev_show(const struct device *dev,
			   struct device_attribute *attr, char *buf,
L
Linus Torvalds 已提交
42 43
			   ssize_t (*format)(const struct net_device *, char *))
{
44
	struct net_device *net = to_net_dev(dev);
L
Linus Torvalds 已提交
45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60
	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);			\
}									\
61 62
static ssize_t show_##field(struct device *dev,				\
			    struct device_attribute *attr, char *buf)	\
L
Linus Torvalds 已提交
63
{									\
64
	return netdev_show(dev, attr, buf, format_##field);		\
L
Linus Torvalds 已提交
65 66 67 68
}


/* use same locking and permission rules as SIF* ioctl's */
69
static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
L
Linus Torvalds 已提交
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
			    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;

85
	if (!rtnl_trylock())
86
		return restart_syscall();
87

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

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

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

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

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

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

139 140 141 142 143 144 145 146 147
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();

E
Eric Dumazet 已提交
148 149 150
	if (netif_running(netdev) &&
	    netdev->ethtool_ops &&
	    netdev->ethtool_ops->get_settings) {
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168
		struct ethtool_cmd cmd = { ETHTOOL_GSET };

		if (!netdev->ethtool_ops->get_settings(netdev, &cmd))
			ret = sprintf(buf, fmt_dec, ethtool_cmd_speed(&cmd));
	}
	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();

E
Eric Dumazet 已提交
169 170 171
	if (netif_running(netdev) &&
	    netdev->ethtool_ops &&
	    netdev->ethtool_ops->get_settings) {
172 173 174 175 176 177 178 179 180
		struct ethtool_cmd cmd = { ETHTOOL_GSET };

		if (!netdev->ethtool_ops->get_settings(netdev, &cmd))
			ret = sprintf(buf, "%s\n", cmd.duplex ? "full" : "half");
	}
	rtnl_unlock();
	return ret;
}

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

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

	return -EINVAL;
}

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

202 203
static ssize_t show_operstate(struct device *dev,
			      struct device_attribute *attr, char *buf)
S
Stefan Rompf 已提交
204 205 206 207 208 209 210 211 212 213
{
	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);

214
	if (operstate >= ARRAY_SIZE(operstates))
S
Stefan Rompf 已提交
215 216 217 218 219
		return -EINVAL; /* should not happen */

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

L
Linus Torvalds 已提交
220 221 222 223 224 225 226 227
/* 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);
}

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

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);
}

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

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;
}

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

262 263 264 265 266 267 268 269 270 271 272 273 274 275
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;

276 277
	if (!rtnl_trylock())
		return restart_syscall();
278 279 280 281 282 283 284 285 286 287 288 289
	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;

290 291
	if (!rtnl_trylock())
		return restart_syscall();
292 293 294 295 296 297
	if (netdev->ifalias)
		ret = sprintf(buf, "%s\n", netdev->ifalias);
	rtnl_unlock();
	return ret;
}

298
static struct device_attribute net_class_attributes[] = {
299
	__ATTR(addr_assign_type, S_IRUGO, show_addr_assign_type, NULL),
300
	__ATTR(addr_len, S_IRUGO, show_addr_len, NULL),
301
	__ATTR(dev_id, S_IRUGO, show_dev_id, NULL),
302
	__ATTR(ifalias, S_IRUGO | S_IWUSR, show_ifalias, store_ifalias),
303 304 305 306
	__ATTR(iflink, S_IRUGO, show_iflink, NULL),
	__ATTR(ifindex, S_IRUGO, show_ifindex, NULL),
	__ATTR(features, S_IRUGO, show_features, NULL),
	__ATTR(type, S_IRUGO, show_type, NULL),
S
Stefan Rompf 已提交
307
	__ATTR(link_mode, S_IRUGO, show_link_mode, NULL),
308 309 310
	__ATTR(address, S_IRUGO, show_address, NULL),
	__ATTR(broadcast, S_IRUGO, show_broadcast, NULL),
	__ATTR(carrier, S_IRUGO, show_carrier, NULL),
311 312
	__ATTR(speed, S_IRUGO, show_speed, NULL),
	__ATTR(duplex, S_IRUGO, show_duplex, NULL),
S
Stefan Rompf 已提交
313 314
	__ATTR(dormant, S_IRUGO, show_dormant, NULL),
	__ATTR(operstate, S_IRUGO, show_operstate, NULL),
315 316 317 318 319
	__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),
	{}
L
Linus Torvalds 已提交
320 321 322
};

/* Show a given an attribute in the statistics group */
323 324
static ssize_t netstat_show(const struct device *d,
			    struct device_attribute *attr, char *buf,
L
Linus Torvalds 已提交
325 326
			    unsigned long offset)
{
327
	struct net_device *dev = to_net_dev(d);
L
Linus Torvalds 已提交
328 329
	ssize_t ret = -EINVAL;

330 331
	WARN_ON(offset > sizeof(struct rtnl_link_stats64) ||
			offset % sizeof(u64) != 0);
L
Linus Torvalds 已提交
332 333

	read_lock(&dev_base_lock);
334
	if (dev_isalive(dev)) {
335 336 337
		struct rtnl_link_stats64 temp;
		const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);

338
		ret = sprintf(buf, fmt_u64, *(u64 *)(((u8 *) stats) + offset));
339
	}
L
Linus Torvalds 已提交
340 341 342 343 344 345
	read_unlock(&dev_base_lock);
	return ret;
}

/* generate a read-only statistics attribute */
#define NETSTAT_ENTRY(name)						\
346 347
static ssize_t show_##name(struct device *d,				\
			   struct device_attribute *attr, char *buf) 	\
L
Linus Torvalds 已提交
348
{									\
349
	return netstat_show(d, attr, buf,				\
350
			    offsetof(struct rtnl_link_stats64, name));	\
L
Linus Torvalds 已提交
351
}									\
352
static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
L
Linus Torvalds 已提交
353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378

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[] = {
379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401
	&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 已提交
402 403 404 405 406 407 408 409 410
	NULL
};


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

411
#ifdef CONFIG_WIRELESS_EXT_SYSFS
L
Linus Torvalds 已提交
412
/* helper function that does all the locking etc for wireless stats */
413
static ssize_t wireless_show(struct device *d, char *buf,
L
Linus Torvalds 已提交
414 415 416
			     ssize_t (*format)(const struct iw_statistics *,
					       char *))
{
417
	struct net_device *dev = to_net_dev(d);
418
	const struct iw_statistics *iw;
L
Linus Torvalds 已提交
419
	ssize_t ret = -EINVAL;
420

421 422
	if (!rtnl_trylock())
		return restart_syscall();
423
	if (dev_isalive(dev)) {
424 425
		iw = get_wireless_stats(dev);
		if (iw)
426 427
			ret = (*format)(iw, buf);
	}
428
	rtnl_unlock();
L
Linus Torvalds 已提交
429 430 431 432 433 434 435 436 437 438

	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);			\
}									\
439 440
static ssize_t show_iw_##name(struct device *d,				\
			      struct device_attribute *attr, char *buf)	\
L
Linus Torvalds 已提交
441
{									\
442
	return wireless_show(d, buf, format_iw_##name);			\
L
Linus Torvalds 已提交
443
}									\
444
static DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL)
L
Linus Torvalds 已提交
445 446 447 448 449 450 451 452 453 454 455 456 457

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[] = {
458 459 460 461 462 463 464 465 466 467
	&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 已提交
468 469 470 471 472 473 474 475
	NULL
};

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

478
#ifdef CONFIG_RPS
T
Tom Herbert 已提交
479 480 481 482 483 484 485 486 487 488 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
/*
 * 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);
}

518
static const struct sysfs_ops rx_queue_sysfs_ops = {
T
Tom Herbert 已提交
519 520 521 522 523 524 525 526 527 528 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
	.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;
}

static void rps_map_release(struct rcu_head *rcu)
{
	struct rps_map *map = container_of(rcu, struct rps_map, rcu);

	kfree(map);
}

E
Eric Dumazet 已提交
560
static ssize_t store_rps_map(struct netdev_rx_queue *queue,
T
Tom Herbert 已提交
561 562 563 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
		      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 已提交
601 602
	old_map = rcu_dereference_protected(queue->rps_map,
					    lockdep_is_held(&rps_map_lock));
T
Tom Herbert 已提交
603 604 605 606 607 608 609 610 611 612
	rcu_assign_pointer(queue->rps_map, map);
	spin_unlock(&rps_map_lock);

	if (old_map)
		call_rcu(&old_map->rcu, rps_map_release);

	free_cpumask_var(mask);
	return len;
}

T
Tom Herbert 已提交
613 614 615 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
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 已提交
646
static ssize_t store_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
T
Tom Herbert 已提交
647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680
				     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;

		if (count > 1<<30) {
			/* Enforce a limit to prevent overflow */
			return -EINVAL;
		}
		count = roundup_pow_of_two(count);
		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 已提交
681 682
	old_table = rcu_dereference_protected(queue->rps_flow_table,
					      lockdep_is_held(&rps_dev_flow_lock));
T
Tom Herbert 已提交
683 684 685 686 687 688 689 690 691
	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 已提交
692 693 694
static struct rx_queue_attribute rps_cpus_attribute =
	__ATTR(rps_cpus, S_IRUGO | S_IWUSR, show_rps_map, store_rps_map);

T
Tom Herbert 已提交
695 696 697 698 699

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 已提交
700 701
static struct attribute *rx_queue_default_attrs[] = {
	&rps_cpus_attribute.attr,
T
Tom Herbert 已提交
702
	&rps_dev_flow_table_cnt_attribute.attr,
T
Tom Herbert 已提交
703 704 705 706 707 708
	NULL
};

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

T
Tom Herbert 已提交
712

E
Eric Dumazet 已提交
713 714 715 716 717 718 719
	map = rcu_dereference_raw(queue->rps_map);
	if (map)
		call_rcu(&map->rcu, rps_map_release);

	flow_table = rcu_dereference_raw(queue->rps_flow_table);
	if (flow_table)
		call_rcu(&flow_table->rcu, rps_dev_flow_table_release);
T
Tom Herbert 已提交
720

T
Tom Herbert 已提交
721
	dev_put(queue->dev);
T
Tom Herbert 已提交
722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744
}

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 已提交
745
	dev_hold(queue->dev);
T
Tom Herbert 已提交
746 747 748 749

	return error;
}

750 751
int
net_rx_queue_update_kobjects(struct net_device *net, int old_num, int new_num)
T
Tom Herbert 已提交
752 753 754 755
{
	int i;
	int error = 0;

756
	for (i = old_num; i < new_num; i++) {
T
Tom Herbert 已提交
757
		error = rx_queue_add_kobject(net, i);
758 759
		if (error) {
			new_num = old_num;
T
Tom Herbert 已提交
760
			break;
761
		}
T
Tom Herbert 已提交
762 763
	}

764 765
	while (--i >= new_num)
		kobject_put(&net->_rx[i].kobj);
T
Tom Herbert 已提交
766 767 768 769

	return error;
}

770
static int rx_queue_register_kobjects(struct net_device *net)
T
Tom Herbert 已提交
771
{
772 773 774 775 776 777
	net->queues_kset = kset_create_and_add("queues",
	    NULL, &net->dev.kobj);
	if (!net->queues_kset)
		return -ENOMEM;
	return net_rx_queue_update_kobjects(net, 0, net->real_num_rx_queues);
}
T
Tom Herbert 已提交
778

779 780 781
static void rx_queue_remove_kobjects(struct net_device *net)
{
	net_rx_queue_update_kobjects(net, net->real_num_rx_queues, 0);
T
Tom Herbert 已提交
782 783
	kset_unregister(net->queues_kset);
}
784
#endif /* CONFIG_RPS */
785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800

static const void *net_current_ns(void)
{
	return current->nsproxy->net_ns;
}

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

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

801
struct kobj_ns_type_operations net_ns_type_operations = {
802 803 804 805 806
	.type = KOBJ_NS_TYPE_NET,
	.current_ns = net_current_ns,
	.netlink_ns = net_netlink_ns,
	.initial_ns = net_initial_ns,
};
807
EXPORT_SYMBOL_GPL(net_ns_type_operations);
808 809 810 811 812 813

static void net_kobj_ns_exit(struct net *net)
{
	kobj_ns_exit(KOBJ_NS_TYPE_NET, net);
}

814
static struct pernet_operations kobj_net_ops = {
815 816 817
	.exit = net_kobj_ns_exit,
};

818

L
Linus Torvalds 已提交
819
#ifdef CONFIG_HOTPLUG
820
static int netdev_uevent(struct device *d, struct kobj_uevent_env *env)
L
Linus Torvalds 已提交
821
{
822
	struct net_device *dev = to_net_dev(d);
823
	int retval;
L
Linus Torvalds 已提交
824

825
	/* pass interface to uevent. */
826
	retval = add_uevent_var(env, "INTERFACE=%s", dev->name);
827 828
	if (retval)
		goto exit;
829 830 831 832

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

835 836
exit:
	return retval;
L
Linus Torvalds 已提交
837 838 839 840
}
#endif

/*
841
 *	netdev_release -- destroy and free a dead device.
842
 *	Called when last reference to device kobject is gone.
L
Linus Torvalds 已提交
843
 */
844
static void netdev_release(struct device *d)
L
Linus Torvalds 已提交
845
{
846
	struct net_device *dev = to_net_dev(d);
L
Linus Torvalds 已提交
847 848 849

	BUG_ON(dev->reg_state != NETREG_RELEASED);

850
	kfree(dev->ifalias);
L
Linus Torvalds 已提交
851 852 853
	kfree((char *)dev - dev->padded);
}

854 855 856 857 858 859 860
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 已提交
861 862
static struct class net_class = {
	.name = "net",
863
	.dev_release = netdev_release,
864
#ifdef CONFIG_SYSFS
865
	.dev_attrs = net_class_attributes,
866
#endif /* CONFIG_SYSFS */
L
Linus Torvalds 已提交
867
#ifdef CONFIG_HOTPLUG
868
	.dev_uevent = netdev_uevent,
L
Linus Torvalds 已提交
869
#endif
870 871
	.ns_type = &net_ns_type_operations,
	.namespace = net_namespace,
L
Linus Torvalds 已提交
872 873
};

874 875 876
/* Delete sysfs entries but hold kobject reference until after all
 * netdev references are gone.
 */
877
void netdev_unregister_kobject(struct net_device * net)
L
Linus Torvalds 已提交
878
{
879 880 881
	struct device *dev = &(net->dev);

	kobject_get(&dev->kobj);
882

883
#ifdef CONFIG_RPS
T
Tom Herbert 已提交
884
	rx_queue_remove_kobjects(net);
885
#endif
T
Tom Herbert 已提交
886

887
	device_del(dev);
L
Linus Torvalds 已提交
888 889 890
}

/* Create sysfs entries for network device. */
891
int netdev_register_kobject(struct net_device *net)
L
Linus Torvalds 已提交
892
{
893
	struct device *dev = &(net->dev);
894
	const struct attribute_group **groups = net->sysfs_groups;
T
Tom Herbert 已提交
895
	int error = 0;
L
Linus Torvalds 已提交
896

897
	device_initialize(dev);
898 899 900
	dev->class = &net_class;
	dev->platform_data = net;
	dev->groups = groups;
L
Linus Torvalds 已提交
901

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

904
#ifdef CONFIG_SYSFS
905 906 907
	/* Allow for a device specific group */
	if (*groups)
		groups++;
L
Linus Torvalds 已提交
908

909
	*groups++ = &netstat_group;
910
#ifdef CONFIG_WIRELESS_EXT_SYSFS
J
Johannes Berg 已提交
911
	if (net->ieee80211_ptr)
912
		*groups++ = &wireless_group;
J
Johannes Berg 已提交
913 914 915 916
#ifdef CONFIG_WIRELESS_EXT
	else if (net->wireless_handlers)
		*groups++ = &wireless_group;
#endif
L
Linus Torvalds 已提交
917
#endif
918
#endif /* CONFIG_SYSFS */
L
Linus Torvalds 已提交
919

T
Tom Herbert 已提交
920 921 922 923
	error = device_add(dev);
	if (error)
		return error;

924
#ifdef CONFIG_RPS
T
Tom Herbert 已提交
925 926 927 928 929
	error = rx_queue_register_kobjects(net);
	if (error) {
		device_del(dev);
		return error;
	}
930
#endif
T
Tom Herbert 已提交
931 932

	return error;
L
Linus Torvalds 已提交
933 934
}

935 936 937 938
int netdev_class_create_file(struct class_attribute *class_attr)
{
	return class_create_file(&net_class, class_attr);
}
E
Eric Dumazet 已提交
939
EXPORT_SYMBOL(netdev_class_create_file);
940 941 942 943 944 945 946

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

947
int netdev_kobject_init(void)
L
Linus Torvalds 已提交
948
{
949
	kobj_ns_type_register(&net_ns_type_operations);
950
	register_pernet_subsys(&kobj_net_ops);
L
Linus Torvalds 已提交
951 952
	return class_register(&net_class);
}