xref: /linux/net/core/net-sysfs.c (revision b889fcf63cb62e7fdb7816565e28f44dbe4a76a5)
1 /*
2  * net-sysfs.c - network device class and attributes
3  *
4  * Copyright (c) 2003 Stephen Hemminger <shemminger@osdl.org>
5  *
6  *	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 
12 #include <linux/capability.h>
13 #include <linux/kernel.h>
14 #include <linux/netdevice.h>
15 #include <linux/if_arp.h>
16 #include <linux/slab.h>
17 #include <linux/nsproxy.h>
18 #include <net/sock.h>
19 #include <net/net_namespace.h>
20 #include <linux/rtnetlink.h>
21 #include <linux/vmalloc.h>
22 #include <linux/export.h>
23 #include <linux/jiffies.h>
24 
25 #include "net-sysfs.h"
26 
27 #ifdef CONFIG_SYSFS
28 static const char fmt_hex[] = "%#x\n";
29 static const char fmt_long_hex[] = "%#lx\n";
30 static const char fmt_dec[] = "%d\n";
31 static const char fmt_udec[] = "%u\n";
32 static const char fmt_ulong[] = "%lu\n";
33 static const char fmt_u64[] = "%llu\n";
34 
35 static inline int dev_isalive(const struct net_device *dev)
36 {
37 	return dev->reg_state <= NETREG_REGISTERED;
38 }
39 
40 /* use same locking rules as GIF* ioctl's */
41 static ssize_t netdev_show(const struct device *dev,
42 			   struct device_attribute *attr, char *buf,
43 			   ssize_t (*format)(const struct net_device *, char *))
44 {
45 	struct net_device *net = to_net_dev(dev);
46 	ssize_t ret = -EINVAL;
47 
48 	read_lock(&dev_base_lock);
49 	if (dev_isalive(net))
50 		ret = (*format)(net, buf);
51 	read_unlock(&dev_base_lock);
52 
53 	return ret;
54 }
55 
56 /* generate a show function for simple field */
57 #define NETDEVICE_SHOW(field, format_string)				\
58 static ssize_t format_##field(const struct net_device *net, char *buf)	\
59 {									\
60 	return sprintf(buf, format_string, net->field);			\
61 }									\
62 static ssize_t show_##field(struct device *dev,				\
63 			    struct device_attribute *attr, char *buf)	\
64 {									\
65 	return netdev_show(dev, attr, buf, format_##field);		\
66 }
67 
68 
69 /* use same locking and permission rules as SIF* ioctl's */
70 static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
71 			    const char *buf, size_t len,
72 			    int (*set)(struct net_device *, unsigned long))
73 {
74 	struct net_device *netdev = to_net_dev(dev);
75 	struct net *net = dev_net(netdev);
76 	unsigned long new;
77 	int ret = -EINVAL;
78 
79 	if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
80 		return -EPERM;
81 
82 	ret = kstrtoul(buf, 0, &new);
83 	if (ret)
84 		goto err;
85 
86 	if (!rtnl_trylock())
87 		return restart_syscall();
88 
89 	if (dev_isalive(netdev)) {
90 		if ((ret = (*set)(netdev, new)) == 0)
91 			ret = len;
92 	}
93 	rtnl_unlock();
94  err:
95 	return ret;
96 }
97 
98 NETDEVICE_SHOW(dev_id, fmt_hex);
99 NETDEVICE_SHOW(addr_assign_type, fmt_dec);
100 NETDEVICE_SHOW(addr_len, fmt_dec);
101 NETDEVICE_SHOW(iflink, fmt_dec);
102 NETDEVICE_SHOW(ifindex, fmt_dec);
103 NETDEVICE_SHOW(type, fmt_dec);
104 NETDEVICE_SHOW(link_mode, fmt_dec);
105 
106 /* use same locking rules as GIFHWADDR ioctl's */
107 static ssize_t show_address(struct device *dev, struct device_attribute *attr,
108 			    char *buf)
109 {
110 	struct net_device *net = to_net_dev(dev);
111 	ssize_t ret = -EINVAL;
112 
113 	read_lock(&dev_base_lock);
114 	if (dev_isalive(net))
115 		ret = sysfs_format_mac(buf, net->dev_addr, net->addr_len);
116 	read_unlock(&dev_base_lock);
117 	return ret;
118 }
119 
120 static ssize_t show_broadcast(struct device *dev,
121 			    struct device_attribute *attr, char *buf)
122 {
123 	struct net_device *net = to_net_dev(dev);
124 	if (dev_isalive(net))
125 		return sysfs_format_mac(buf, net->broadcast, net->addr_len);
126 	return -EINVAL;
127 }
128 
129 static ssize_t show_carrier(struct device *dev,
130 			    struct device_attribute *attr, char *buf)
131 {
132 	struct net_device *netdev = to_net_dev(dev);
133 	if (netif_running(netdev)) {
134 		return sprintf(buf, fmt_dec, !!netif_carrier_ok(netdev));
135 	}
136 	return -EINVAL;
137 }
138 
139 static ssize_t show_speed(struct device *dev,
140 			  struct device_attribute *attr, char *buf)
141 {
142 	struct net_device *netdev = to_net_dev(dev);
143 	int ret = -EINVAL;
144 
145 	if (!rtnl_trylock())
146 		return restart_syscall();
147 
148 	if (netif_running(netdev)) {
149 		struct ethtool_cmd cmd;
150 		if (!__ethtool_get_settings(netdev, &cmd))
151 			ret = sprintf(buf, fmt_udec, ethtool_cmd_speed(&cmd));
152 	}
153 	rtnl_unlock();
154 	return ret;
155 }
156 
157 static ssize_t show_duplex(struct device *dev,
158 			   struct device_attribute *attr, char *buf)
159 {
160 	struct net_device *netdev = to_net_dev(dev);
161 	int ret = -EINVAL;
162 
163 	if (!rtnl_trylock())
164 		return restart_syscall();
165 
166 	if (netif_running(netdev)) {
167 		struct ethtool_cmd cmd;
168 		if (!__ethtool_get_settings(netdev, &cmd)) {
169 			const char *duplex;
170 			switch (cmd.duplex) {
171 			case DUPLEX_HALF:
172 				duplex = "half";
173 				break;
174 			case DUPLEX_FULL:
175 				duplex = "full";
176 				break;
177 			default:
178 				duplex = "unknown";
179 				break;
180 			}
181 			ret = sprintf(buf, "%s\n", duplex);
182 		}
183 	}
184 	rtnl_unlock();
185 	return ret;
186 }
187 
188 static ssize_t show_dormant(struct device *dev,
189 			    struct device_attribute *attr, char *buf)
190 {
191 	struct net_device *netdev = to_net_dev(dev);
192 
193 	if (netif_running(netdev))
194 		return sprintf(buf, fmt_dec, !!netif_dormant(netdev));
195 
196 	return -EINVAL;
197 }
198 
199 static const char *const operstates[] = {
200 	"unknown",
201 	"notpresent", /* currently unused */
202 	"down",
203 	"lowerlayerdown",
204 	"testing", /* currently unused */
205 	"dormant",
206 	"up"
207 };
208 
209 static ssize_t show_operstate(struct device *dev,
210 			      struct device_attribute *attr, char *buf)
211 {
212 	const struct net_device *netdev = to_net_dev(dev);
213 	unsigned char operstate;
214 
215 	read_lock(&dev_base_lock);
216 	operstate = netdev->operstate;
217 	if (!netif_running(netdev))
218 		operstate = IF_OPER_DOWN;
219 	read_unlock(&dev_base_lock);
220 
221 	if (operstate >= ARRAY_SIZE(operstates))
222 		return -EINVAL; /* should not happen */
223 
224 	return sprintf(buf, "%s\n", operstates[operstate]);
225 }
226 
227 /* read-write attributes */
228 NETDEVICE_SHOW(mtu, fmt_dec);
229 
230 static int change_mtu(struct net_device *net, unsigned long new_mtu)
231 {
232 	return dev_set_mtu(net, (int) new_mtu);
233 }
234 
235 static ssize_t store_mtu(struct device *dev, struct device_attribute *attr,
236 			 const char *buf, size_t len)
237 {
238 	return netdev_store(dev, attr, buf, len, change_mtu);
239 }
240 
241 NETDEVICE_SHOW(flags, fmt_hex);
242 
243 static int change_flags(struct net_device *net, unsigned long new_flags)
244 {
245 	return dev_change_flags(net, (unsigned int) new_flags);
246 }
247 
248 static ssize_t store_flags(struct device *dev, struct device_attribute *attr,
249 			   const char *buf, size_t len)
250 {
251 	return netdev_store(dev, attr, buf, len, change_flags);
252 }
253 
254 NETDEVICE_SHOW(tx_queue_len, fmt_ulong);
255 
256 static int change_tx_queue_len(struct net_device *net, unsigned long new_len)
257 {
258 	net->tx_queue_len = new_len;
259 	return 0;
260 }
261 
262 static ssize_t store_tx_queue_len(struct device *dev,
263 				  struct device_attribute *attr,
264 				  const char *buf, size_t len)
265 {
266 	if (!capable(CAP_NET_ADMIN))
267 		return -EPERM;
268 
269 	return netdev_store(dev, attr, buf, len, change_tx_queue_len);
270 }
271 
272 static ssize_t store_ifalias(struct device *dev, struct device_attribute *attr,
273 			     const char *buf, size_t len)
274 {
275 	struct net_device *netdev = to_net_dev(dev);
276 	struct net *net = dev_net(netdev);
277 	size_t count = len;
278 	ssize_t ret;
279 
280 	if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
281 		return -EPERM;
282 
283 	/* ignore trailing newline */
284 	if (len >  0 && buf[len - 1] == '\n')
285 		--count;
286 
287 	if (!rtnl_trylock())
288 		return restart_syscall();
289 	ret = dev_set_alias(netdev, buf, count);
290 	rtnl_unlock();
291 
292 	return ret < 0 ? ret : len;
293 }
294 
295 static ssize_t show_ifalias(struct device *dev,
296 			    struct device_attribute *attr, char *buf)
297 {
298 	const struct net_device *netdev = to_net_dev(dev);
299 	ssize_t ret = 0;
300 
301 	if (!rtnl_trylock())
302 		return restart_syscall();
303 	if (netdev->ifalias)
304 		ret = sprintf(buf, "%s\n", netdev->ifalias);
305 	rtnl_unlock();
306 	return ret;
307 }
308 
309 NETDEVICE_SHOW(group, fmt_dec);
310 
311 static int change_group(struct net_device *net, unsigned long new_group)
312 {
313 	dev_set_group(net, (int) new_group);
314 	return 0;
315 }
316 
317 static ssize_t store_group(struct device *dev, struct device_attribute *attr,
318 			 const char *buf, size_t len)
319 {
320 	return netdev_store(dev, attr, buf, len, change_group);
321 }
322 
323 static struct device_attribute net_class_attributes[] = {
324 	__ATTR(addr_assign_type, S_IRUGO, show_addr_assign_type, NULL),
325 	__ATTR(addr_len, S_IRUGO, show_addr_len, NULL),
326 	__ATTR(dev_id, S_IRUGO, show_dev_id, NULL),
327 	__ATTR(ifalias, S_IRUGO | S_IWUSR, show_ifalias, store_ifalias),
328 	__ATTR(iflink, S_IRUGO, show_iflink, NULL),
329 	__ATTR(ifindex, S_IRUGO, show_ifindex, NULL),
330 	__ATTR(type, S_IRUGO, show_type, NULL),
331 	__ATTR(link_mode, S_IRUGO, show_link_mode, NULL),
332 	__ATTR(address, S_IRUGO, show_address, NULL),
333 	__ATTR(broadcast, S_IRUGO, show_broadcast, NULL),
334 	__ATTR(carrier, S_IRUGO, show_carrier, NULL),
335 	__ATTR(speed, S_IRUGO, show_speed, NULL),
336 	__ATTR(duplex, S_IRUGO, show_duplex, NULL),
337 	__ATTR(dormant, S_IRUGO, show_dormant, NULL),
338 	__ATTR(operstate, S_IRUGO, show_operstate, NULL),
339 	__ATTR(mtu, S_IRUGO | S_IWUSR, show_mtu, store_mtu),
340 	__ATTR(flags, S_IRUGO | S_IWUSR, show_flags, store_flags),
341 	__ATTR(tx_queue_len, S_IRUGO | S_IWUSR, show_tx_queue_len,
342 	       store_tx_queue_len),
343 	__ATTR(netdev_group, S_IRUGO | S_IWUSR, show_group, store_group),
344 	{}
345 };
346 
347 /* Show a given an attribute in the statistics group */
348 static ssize_t netstat_show(const struct device *d,
349 			    struct device_attribute *attr, char *buf,
350 			    unsigned long offset)
351 {
352 	struct net_device *dev = to_net_dev(d);
353 	ssize_t ret = -EINVAL;
354 
355 	WARN_ON(offset > sizeof(struct rtnl_link_stats64) ||
356 			offset % sizeof(u64) != 0);
357 
358 	read_lock(&dev_base_lock);
359 	if (dev_isalive(dev)) {
360 		struct rtnl_link_stats64 temp;
361 		const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);
362 
363 		ret = sprintf(buf, fmt_u64, *(u64 *)(((u8 *) stats) + offset));
364 	}
365 	read_unlock(&dev_base_lock);
366 	return ret;
367 }
368 
369 /* generate a read-only statistics attribute */
370 #define NETSTAT_ENTRY(name)						\
371 static ssize_t show_##name(struct device *d,				\
372 			   struct device_attribute *attr, char *buf) 	\
373 {									\
374 	return netstat_show(d, attr, buf,				\
375 			    offsetof(struct rtnl_link_stats64, name));	\
376 }									\
377 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL)
378 
379 NETSTAT_ENTRY(rx_packets);
380 NETSTAT_ENTRY(tx_packets);
381 NETSTAT_ENTRY(rx_bytes);
382 NETSTAT_ENTRY(tx_bytes);
383 NETSTAT_ENTRY(rx_errors);
384 NETSTAT_ENTRY(tx_errors);
385 NETSTAT_ENTRY(rx_dropped);
386 NETSTAT_ENTRY(tx_dropped);
387 NETSTAT_ENTRY(multicast);
388 NETSTAT_ENTRY(collisions);
389 NETSTAT_ENTRY(rx_length_errors);
390 NETSTAT_ENTRY(rx_over_errors);
391 NETSTAT_ENTRY(rx_crc_errors);
392 NETSTAT_ENTRY(rx_frame_errors);
393 NETSTAT_ENTRY(rx_fifo_errors);
394 NETSTAT_ENTRY(rx_missed_errors);
395 NETSTAT_ENTRY(tx_aborted_errors);
396 NETSTAT_ENTRY(tx_carrier_errors);
397 NETSTAT_ENTRY(tx_fifo_errors);
398 NETSTAT_ENTRY(tx_heartbeat_errors);
399 NETSTAT_ENTRY(tx_window_errors);
400 NETSTAT_ENTRY(rx_compressed);
401 NETSTAT_ENTRY(tx_compressed);
402 
403 static struct attribute *netstat_attrs[] = {
404 	&dev_attr_rx_packets.attr,
405 	&dev_attr_tx_packets.attr,
406 	&dev_attr_rx_bytes.attr,
407 	&dev_attr_tx_bytes.attr,
408 	&dev_attr_rx_errors.attr,
409 	&dev_attr_tx_errors.attr,
410 	&dev_attr_rx_dropped.attr,
411 	&dev_attr_tx_dropped.attr,
412 	&dev_attr_multicast.attr,
413 	&dev_attr_collisions.attr,
414 	&dev_attr_rx_length_errors.attr,
415 	&dev_attr_rx_over_errors.attr,
416 	&dev_attr_rx_crc_errors.attr,
417 	&dev_attr_rx_frame_errors.attr,
418 	&dev_attr_rx_fifo_errors.attr,
419 	&dev_attr_rx_missed_errors.attr,
420 	&dev_attr_tx_aborted_errors.attr,
421 	&dev_attr_tx_carrier_errors.attr,
422 	&dev_attr_tx_fifo_errors.attr,
423 	&dev_attr_tx_heartbeat_errors.attr,
424 	&dev_attr_tx_window_errors.attr,
425 	&dev_attr_rx_compressed.attr,
426 	&dev_attr_tx_compressed.attr,
427 	NULL
428 };
429 
430 
431 static struct attribute_group netstat_group = {
432 	.name  = "statistics",
433 	.attrs  = netstat_attrs,
434 };
435 
436 #if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211)
437 static struct attribute *wireless_attrs[] = {
438 	NULL
439 };
440 
441 static struct attribute_group wireless_group = {
442 	.name = "wireless",
443 	.attrs = wireless_attrs,
444 };
445 #endif
446 #endif /* CONFIG_SYSFS */
447 
448 #ifdef CONFIG_RPS
449 /*
450  * RX queue sysfs structures and functions.
451  */
452 struct rx_queue_attribute {
453 	struct attribute attr;
454 	ssize_t (*show)(struct netdev_rx_queue *queue,
455 	    struct rx_queue_attribute *attr, char *buf);
456 	ssize_t (*store)(struct netdev_rx_queue *queue,
457 	    struct rx_queue_attribute *attr, const char *buf, size_t len);
458 };
459 #define to_rx_queue_attr(_attr) container_of(_attr,		\
460     struct rx_queue_attribute, attr)
461 
462 #define to_rx_queue(obj) container_of(obj, struct netdev_rx_queue, kobj)
463 
464 static ssize_t rx_queue_attr_show(struct kobject *kobj, struct attribute *attr,
465 				  char *buf)
466 {
467 	struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
468 	struct netdev_rx_queue *queue = to_rx_queue(kobj);
469 
470 	if (!attribute->show)
471 		return -EIO;
472 
473 	return attribute->show(queue, attribute, buf);
474 }
475 
476 static ssize_t rx_queue_attr_store(struct kobject *kobj, struct attribute *attr,
477 				   const char *buf, size_t count)
478 {
479 	struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
480 	struct netdev_rx_queue *queue = to_rx_queue(kobj);
481 
482 	if (!attribute->store)
483 		return -EIO;
484 
485 	return attribute->store(queue, attribute, buf, count);
486 }
487 
488 static const struct sysfs_ops rx_queue_sysfs_ops = {
489 	.show = rx_queue_attr_show,
490 	.store = rx_queue_attr_store,
491 };
492 
493 static ssize_t show_rps_map(struct netdev_rx_queue *queue,
494 			    struct rx_queue_attribute *attribute, char *buf)
495 {
496 	struct rps_map *map;
497 	cpumask_var_t mask;
498 	size_t len = 0;
499 	int i;
500 
501 	if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
502 		return -ENOMEM;
503 
504 	rcu_read_lock();
505 	map = rcu_dereference(queue->rps_map);
506 	if (map)
507 		for (i = 0; i < map->len; i++)
508 			cpumask_set_cpu(map->cpus[i], mask);
509 
510 	len += cpumask_scnprintf(buf + len, PAGE_SIZE, mask);
511 	if (PAGE_SIZE - len < 3) {
512 		rcu_read_unlock();
513 		free_cpumask_var(mask);
514 		return -EINVAL;
515 	}
516 	rcu_read_unlock();
517 
518 	free_cpumask_var(mask);
519 	len += sprintf(buf + len, "\n");
520 	return len;
521 }
522 
523 static ssize_t store_rps_map(struct netdev_rx_queue *queue,
524 		      struct rx_queue_attribute *attribute,
525 		      const char *buf, size_t len)
526 {
527 	struct rps_map *old_map, *map;
528 	cpumask_var_t mask;
529 	int err, cpu, i;
530 	static DEFINE_SPINLOCK(rps_map_lock);
531 
532 	if (!capable(CAP_NET_ADMIN))
533 		return -EPERM;
534 
535 	if (!alloc_cpumask_var(&mask, GFP_KERNEL))
536 		return -ENOMEM;
537 
538 	err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
539 	if (err) {
540 		free_cpumask_var(mask);
541 		return err;
542 	}
543 
544 	map = kzalloc(max_t(unsigned int,
545 	    RPS_MAP_SIZE(cpumask_weight(mask)), L1_CACHE_BYTES),
546 	    GFP_KERNEL);
547 	if (!map) {
548 		free_cpumask_var(mask);
549 		return -ENOMEM;
550 	}
551 
552 	i = 0;
553 	for_each_cpu_and(cpu, mask, cpu_online_mask)
554 		map->cpus[i++] = cpu;
555 
556 	if (i)
557 		map->len = i;
558 	else {
559 		kfree(map);
560 		map = NULL;
561 	}
562 
563 	spin_lock(&rps_map_lock);
564 	old_map = rcu_dereference_protected(queue->rps_map,
565 					    lockdep_is_held(&rps_map_lock));
566 	rcu_assign_pointer(queue->rps_map, map);
567 	spin_unlock(&rps_map_lock);
568 
569 	if (map)
570 		static_key_slow_inc(&rps_needed);
571 	if (old_map) {
572 		kfree_rcu(old_map, rcu);
573 		static_key_slow_dec(&rps_needed);
574 	}
575 	free_cpumask_var(mask);
576 	return len;
577 }
578 
579 static ssize_t show_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
580 					   struct rx_queue_attribute *attr,
581 					   char *buf)
582 {
583 	struct rps_dev_flow_table *flow_table;
584 	unsigned long val = 0;
585 
586 	rcu_read_lock();
587 	flow_table = rcu_dereference(queue->rps_flow_table);
588 	if (flow_table)
589 		val = (unsigned long)flow_table->mask + 1;
590 	rcu_read_unlock();
591 
592 	return sprintf(buf, "%lu\n", val);
593 }
594 
595 static void rps_dev_flow_table_release_work(struct work_struct *work)
596 {
597 	struct rps_dev_flow_table *table = container_of(work,
598 	    struct rps_dev_flow_table, free_work);
599 
600 	vfree(table);
601 }
602 
603 static void rps_dev_flow_table_release(struct rcu_head *rcu)
604 {
605 	struct rps_dev_flow_table *table = container_of(rcu,
606 	    struct rps_dev_flow_table, rcu);
607 
608 	INIT_WORK(&table->free_work, rps_dev_flow_table_release_work);
609 	schedule_work(&table->free_work);
610 }
611 
612 static ssize_t store_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
613 				     struct rx_queue_attribute *attr,
614 				     const char *buf, size_t len)
615 {
616 	unsigned long mask, count;
617 	struct rps_dev_flow_table *table, *old_table;
618 	static DEFINE_SPINLOCK(rps_dev_flow_lock);
619 	int rc;
620 
621 	if (!capable(CAP_NET_ADMIN))
622 		return -EPERM;
623 
624 	rc = kstrtoul(buf, 0, &count);
625 	if (rc < 0)
626 		return rc;
627 
628 	if (count) {
629 		mask = count - 1;
630 		/* mask = roundup_pow_of_two(count) - 1;
631 		 * without overflows...
632 		 */
633 		while ((mask | (mask >> 1)) != mask)
634 			mask |= (mask >> 1);
635 		/* On 64 bit arches, must check mask fits in table->mask (u32),
636 		 * and on 32bit arches, must check RPS_DEV_FLOW_TABLE_SIZE(mask + 1)
637 		 * doesnt overflow.
638 		 */
639 #if BITS_PER_LONG > 32
640 		if (mask > (unsigned long)(u32)mask)
641 			return -EINVAL;
642 #else
643 		if (mask > (ULONG_MAX - RPS_DEV_FLOW_TABLE_SIZE(1))
644 				/ sizeof(struct rps_dev_flow)) {
645 			/* Enforce a limit to prevent overflow */
646 			return -EINVAL;
647 		}
648 #endif
649 		table = vmalloc(RPS_DEV_FLOW_TABLE_SIZE(mask + 1));
650 		if (!table)
651 			return -ENOMEM;
652 
653 		table->mask = mask;
654 		for (count = 0; count <= mask; count++)
655 			table->flows[count].cpu = RPS_NO_CPU;
656 	} else
657 		table = NULL;
658 
659 	spin_lock(&rps_dev_flow_lock);
660 	old_table = rcu_dereference_protected(queue->rps_flow_table,
661 					      lockdep_is_held(&rps_dev_flow_lock));
662 	rcu_assign_pointer(queue->rps_flow_table, table);
663 	spin_unlock(&rps_dev_flow_lock);
664 
665 	if (old_table)
666 		call_rcu(&old_table->rcu, rps_dev_flow_table_release);
667 
668 	return len;
669 }
670 
671 static struct rx_queue_attribute rps_cpus_attribute =
672 	__ATTR(rps_cpus, S_IRUGO | S_IWUSR, show_rps_map, store_rps_map);
673 
674 
675 static struct rx_queue_attribute rps_dev_flow_table_cnt_attribute =
676 	__ATTR(rps_flow_cnt, S_IRUGO | S_IWUSR,
677 	    show_rps_dev_flow_table_cnt, store_rps_dev_flow_table_cnt);
678 
679 static struct attribute *rx_queue_default_attrs[] = {
680 	&rps_cpus_attribute.attr,
681 	&rps_dev_flow_table_cnt_attribute.attr,
682 	NULL
683 };
684 
685 static void rx_queue_release(struct kobject *kobj)
686 {
687 	struct netdev_rx_queue *queue = to_rx_queue(kobj);
688 	struct rps_map *map;
689 	struct rps_dev_flow_table *flow_table;
690 
691 
692 	map = rcu_dereference_protected(queue->rps_map, 1);
693 	if (map) {
694 		RCU_INIT_POINTER(queue->rps_map, NULL);
695 		kfree_rcu(map, rcu);
696 	}
697 
698 	flow_table = rcu_dereference_protected(queue->rps_flow_table, 1);
699 	if (flow_table) {
700 		RCU_INIT_POINTER(queue->rps_flow_table, NULL);
701 		call_rcu(&flow_table->rcu, rps_dev_flow_table_release);
702 	}
703 
704 	memset(kobj, 0, sizeof(*kobj));
705 	dev_put(queue->dev);
706 }
707 
708 static struct kobj_type rx_queue_ktype = {
709 	.sysfs_ops = &rx_queue_sysfs_ops,
710 	.release = rx_queue_release,
711 	.default_attrs = rx_queue_default_attrs,
712 };
713 
714 static int rx_queue_add_kobject(struct net_device *net, int index)
715 {
716 	struct netdev_rx_queue *queue = net->_rx + index;
717 	struct kobject *kobj = &queue->kobj;
718 	int error = 0;
719 
720 	kobj->kset = net->queues_kset;
721 	error = kobject_init_and_add(kobj, &rx_queue_ktype, NULL,
722 	    "rx-%u", index);
723 	if (error) {
724 		kobject_put(kobj);
725 		return error;
726 	}
727 
728 	kobject_uevent(kobj, KOBJ_ADD);
729 	dev_hold(queue->dev);
730 
731 	return error;
732 }
733 #endif /* CONFIG_RPS */
734 
735 int
736 net_rx_queue_update_kobjects(struct net_device *net, int old_num, int new_num)
737 {
738 #ifdef CONFIG_RPS
739 	int i;
740 	int error = 0;
741 
742 	for (i = old_num; i < new_num; i++) {
743 		error = rx_queue_add_kobject(net, i);
744 		if (error) {
745 			new_num = old_num;
746 			break;
747 		}
748 	}
749 
750 	while (--i >= new_num)
751 		kobject_put(&net->_rx[i].kobj);
752 
753 	return error;
754 #else
755 	return 0;
756 #endif
757 }
758 
759 #ifdef CONFIG_SYSFS
760 /*
761  * netdev_queue sysfs structures and functions.
762  */
763 struct netdev_queue_attribute {
764 	struct attribute attr;
765 	ssize_t (*show)(struct netdev_queue *queue,
766 	    struct netdev_queue_attribute *attr, char *buf);
767 	ssize_t (*store)(struct netdev_queue *queue,
768 	    struct netdev_queue_attribute *attr, const char *buf, size_t len);
769 };
770 #define to_netdev_queue_attr(_attr) container_of(_attr,		\
771     struct netdev_queue_attribute, attr)
772 
773 #define to_netdev_queue(obj) container_of(obj, struct netdev_queue, kobj)
774 
775 static ssize_t netdev_queue_attr_show(struct kobject *kobj,
776 				      struct attribute *attr, char *buf)
777 {
778 	struct netdev_queue_attribute *attribute = to_netdev_queue_attr(attr);
779 	struct netdev_queue *queue = to_netdev_queue(kobj);
780 
781 	if (!attribute->show)
782 		return -EIO;
783 
784 	return attribute->show(queue, attribute, buf);
785 }
786 
787 static ssize_t netdev_queue_attr_store(struct kobject *kobj,
788 				       struct attribute *attr,
789 				       const char *buf, size_t count)
790 {
791 	struct netdev_queue_attribute *attribute = to_netdev_queue_attr(attr);
792 	struct netdev_queue *queue = to_netdev_queue(kobj);
793 
794 	if (!attribute->store)
795 		return -EIO;
796 
797 	return attribute->store(queue, attribute, buf, count);
798 }
799 
800 static const struct sysfs_ops netdev_queue_sysfs_ops = {
801 	.show = netdev_queue_attr_show,
802 	.store = netdev_queue_attr_store,
803 };
804 
805 static ssize_t show_trans_timeout(struct netdev_queue *queue,
806 				  struct netdev_queue_attribute *attribute,
807 				  char *buf)
808 {
809 	unsigned long trans_timeout;
810 
811 	spin_lock_irq(&queue->_xmit_lock);
812 	trans_timeout = queue->trans_timeout;
813 	spin_unlock_irq(&queue->_xmit_lock);
814 
815 	return sprintf(buf, "%lu", trans_timeout);
816 }
817 
818 static struct netdev_queue_attribute queue_trans_timeout =
819 	__ATTR(tx_timeout, S_IRUGO, show_trans_timeout, NULL);
820 
821 #ifdef CONFIG_BQL
822 /*
823  * Byte queue limits sysfs structures and functions.
824  */
825 static ssize_t bql_show(char *buf, unsigned int value)
826 {
827 	return sprintf(buf, "%u\n", value);
828 }
829 
830 static ssize_t bql_set(const char *buf, const size_t count,
831 		       unsigned int *pvalue)
832 {
833 	unsigned int value;
834 	int err;
835 
836 	if (!strcmp(buf, "max") || !strcmp(buf, "max\n"))
837 		value = DQL_MAX_LIMIT;
838 	else {
839 		err = kstrtouint(buf, 10, &value);
840 		if (err < 0)
841 			return err;
842 		if (value > DQL_MAX_LIMIT)
843 			return -EINVAL;
844 	}
845 
846 	*pvalue = value;
847 
848 	return count;
849 }
850 
851 static ssize_t bql_show_hold_time(struct netdev_queue *queue,
852 				  struct netdev_queue_attribute *attr,
853 				  char *buf)
854 {
855 	struct dql *dql = &queue->dql;
856 
857 	return sprintf(buf, "%u\n", jiffies_to_msecs(dql->slack_hold_time));
858 }
859 
860 static ssize_t bql_set_hold_time(struct netdev_queue *queue,
861 				 struct netdev_queue_attribute *attribute,
862 				 const char *buf, size_t len)
863 {
864 	struct dql *dql = &queue->dql;
865 	unsigned int value;
866 	int err;
867 
868 	err = kstrtouint(buf, 10, &value);
869 	if (err < 0)
870 		return err;
871 
872 	dql->slack_hold_time = msecs_to_jiffies(value);
873 
874 	return len;
875 }
876 
877 static struct netdev_queue_attribute bql_hold_time_attribute =
878 	__ATTR(hold_time, S_IRUGO | S_IWUSR, bql_show_hold_time,
879 	    bql_set_hold_time);
880 
881 static ssize_t bql_show_inflight(struct netdev_queue *queue,
882 				 struct netdev_queue_attribute *attr,
883 				 char *buf)
884 {
885 	struct dql *dql = &queue->dql;
886 
887 	return sprintf(buf, "%u\n", dql->num_queued - dql->num_completed);
888 }
889 
890 static struct netdev_queue_attribute bql_inflight_attribute =
891 	__ATTR(inflight, S_IRUGO, bql_show_inflight, NULL);
892 
893 #define BQL_ATTR(NAME, FIELD)						\
894 static ssize_t bql_show_ ## NAME(struct netdev_queue *queue,		\
895 				 struct netdev_queue_attribute *attr,	\
896 				 char *buf)				\
897 {									\
898 	return bql_show(buf, queue->dql.FIELD);				\
899 }									\
900 									\
901 static ssize_t bql_set_ ## NAME(struct netdev_queue *queue,		\
902 				struct netdev_queue_attribute *attr,	\
903 				const char *buf, size_t len)		\
904 {									\
905 	return bql_set(buf, len, &queue->dql.FIELD);			\
906 }									\
907 									\
908 static struct netdev_queue_attribute bql_ ## NAME ## _attribute =	\
909 	__ATTR(NAME, S_IRUGO | S_IWUSR, bql_show_ ## NAME,		\
910 	    bql_set_ ## NAME);
911 
912 BQL_ATTR(limit, limit)
913 BQL_ATTR(limit_max, max_limit)
914 BQL_ATTR(limit_min, min_limit)
915 
916 static struct attribute *dql_attrs[] = {
917 	&bql_limit_attribute.attr,
918 	&bql_limit_max_attribute.attr,
919 	&bql_limit_min_attribute.attr,
920 	&bql_hold_time_attribute.attr,
921 	&bql_inflight_attribute.attr,
922 	NULL
923 };
924 
925 static struct attribute_group dql_group = {
926 	.name  = "byte_queue_limits",
927 	.attrs  = dql_attrs,
928 };
929 #endif /* CONFIG_BQL */
930 
931 #ifdef CONFIG_XPS
932 static inline unsigned int get_netdev_queue_index(struct netdev_queue *queue)
933 {
934 	struct net_device *dev = queue->dev;
935 	int i;
936 
937 	for (i = 0; i < dev->num_tx_queues; i++)
938 		if (queue == &dev->_tx[i])
939 			break;
940 
941 	BUG_ON(i >= dev->num_tx_queues);
942 
943 	return i;
944 }
945 
946 
947 static ssize_t show_xps_map(struct netdev_queue *queue,
948 			    struct netdev_queue_attribute *attribute, char *buf)
949 {
950 	struct net_device *dev = queue->dev;
951 	struct xps_dev_maps *dev_maps;
952 	cpumask_var_t mask;
953 	unsigned long index;
954 	size_t len = 0;
955 	int i;
956 
957 	if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
958 		return -ENOMEM;
959 
960 	index = get_netdev_queue_index(queue);
961 
962 	rcu_read_lock();
963 	dev_maps = rcu_dereference(dev->xps_maps);
964 	if (dev_maps) {
965 		for_each_possible_cpu(i) {
966 			struct xps_map *map =
967 			    rcu_dereference(dev_maps->cpu_map[i]);
968 			if (map) {
969 				int j;
970 				for (j = 0; j < map->len; j++) {
971 					if (map->queues[j] == index) {
972 						cpumask_set_cpu(i, mask);
973 						break;
974 					}
975 				}
976 			}
977 		}
978 	}
979 	rcu_read_unlock();
980 
981 	len += cpumask_scnprintf(buf + len, PAGE_SIZE, mask);
982 	if (PAGE_SIZE - len < 3) {
983 		free_cpumask_var(mask);
984 		return -EINVAL;
985 	}
986 
987 	free_cpumask_var(mask);
988 	len += sprintf(buf + len, "\n");
989 	return len;
990 }
991 
992 static DEFINE_MUTEX(xps_map_mutex);
993 #define xmap_dereference(P)		\
994 	rcu_dereference_protected((P), lockdep_is_held(&xps_map_mutex))
995 
996 static void xps_queue_release(struct netdev_queue *queue)
997 {
998 	struct net_device *dev = queue->dev;
999 	struct xps_dev_maps *dev_maps;
1000 	struct xps_map *map;
1001 	unsigned long index;
1002 	int i, pos, nonempty = 0;
1003 
1004 	index = get_netdev_queue_index(queue);
1005 
1006 	mutex_lock(&xps_map_mutex);
1007 	dev_maps = xmap_dereference(dev->xps_maps);
1008 
1009 	if (dev_maps) {
1010 		for_each_possible_cpu(i) {
1011 			map = xmap_dereference(dev_maps->cpu_map[i]);
1012 			if (!map)
1013 				continue;
1014 
1015 			for (pos = 0; pos < map->len; pos++)
1016 				if (map->queues[pos] == index)
1017 					break;
1018 
1019 			if (pos < map->len) {
1020 				if (map->len > 1)
1021 					map->queues[pos] =
1022 					    map->queues[--map->len];
1023 				else {
1024 					RCU_INIT_POINTER(dev_maps->cpu_map[i],
1025 					    NULL);
1026 					kfree_rcu(map, rcu);
1027 					map = NULL;
1028 				}
1029 			}
1030 			if (map)
1031 				nonempty = 1;
1032 		}
1033 
1034 		if (!nonempty) {
1035 			RCU_INIT_POINTER(dev->xps_maps, NULL);
1036 			kfree_rcu(dev_maps, rcu);
1037 		}
1038 	}
1039 	mutex_unlock(&xps_map_mutex);
1040 }
1041 
1042 static ssize_t store_xps_map(struct netdev_queue *queue,
1043 		      struct netdev_queue_attribute *attribute,
1044 		      const char *buf, size_t len)
1045 {
1046 	struct net_device *dev = queue->dev;
1047 	cpumask_var_t mask;
1048 	int err, i, cpu, pos, map_len, alloc_len, need_set;
1049 	unsigned long index;
1050 	struct xps_map *map, *new_map;
1051 	struct xps_dev_maps *dev_maps, *new_dev_maps;
1052 	int nonempty = 0;
1053 	int numa_node_id = -2;
1054 
1055 	if (!capable(CAP_NET_ADMIN))
1056 		return -EPERM;
1057 
1058 	if (!alloc_cpumask_var(&mask, GFP_KERNEL))
1059 		return -ENOMEM;
1060 
1061 	index = get_netdev_queue_index(queue);
1062 
1063 	err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
1064 	if (err) {
1065 		free_cpumask_var(mask);
1066 		return err;
1067 	}
1068 
1069 	new_dev_maps = kzalloc(max_t(unsigned int,
1070 	    XPS_DEV_MAPS_SIZE, L1_CACHE_BYTES), GFP_KERNEL);
1071 	if (!new_dev_maps) {
1072 		free_cpumask_var(mask);
1073 		return -ENOMEM;
1074 	}
1075 
1076 	mutex_lock(&xps_map_mutex);
1077 
1078 	dev_maps = xmap_dereference(dev->xps_maps);
1079 
1080 	for_each_possible_cpu(cpu) {
1081 		map = dev_maps ?
1082 			xmap_dereference(dev_maps->cpu_map[cpu]) : NULL;
1083 		new_map = map;
1084 		if (map) {
1085 			for (pos = 0; pos < map->len; pos++)
1086 				if (map->queues[pos] == index)
1087 					break;
1088 			map_len = map->len;
1089 			alloc_len = map->alloc_len;
1090 		} else
1091 			pos = map_len = alloc_len = 0;
1092 
1093 		need_set = cpumask_test_cpu(cpu, mask) && cpu_online(cpu);
1094 #ifdef CONFIG_NUMA
1095 		if (need_set) {
1096 			if (numa_node_id == -2)
1097 				numa_node_id = cpu_to_node(cpu);
1098 			else if (numa_node_id != cpu_to_node(cpu))
1099 				numa_node_id = -1;
1100 		}
1101 #endif
1102 		if (need_set && pos >= map_len) {
1103 			/* Need to add queue to this CPU's map */
1104 			if (map_len >= alloc_len) {
1105 				alloc_len = alloc_len ?
1106 				    2 * alloc_len : XPS_MIN_MAP_ALLOC;
1107 				new_map = kzalloc_node(XPS_MAP_SIZE(alloc_len),
1108 						       GFP_KERNEL,
1109 						       cpu_to_node(cpu));
1110 				if (!new_map)
1111 					goto error;
1112 				new_map->alloc_len = alloc_len;
1113 				for (i = 0; i < map_len; i++)
1114 					new_map->queues[i] = map->queues[i];
1115 				new_map->len = map_len;
1116 			}
1117 			new_map->queues[new_map->len++] = index;
1118 		} else if (!need_set && pos < map_len) {
1119 			/* Need to remove queue from this CPU's map */
1120 			if (map_len > 1)
1121 				new_map->queues[pos] =
1122 				    new_map->queues[--new_map->len];
1123 			else
1124 				new_map = NULL;
1125 		}
1126 		RCU_INIT_POINTER(new_dev_maps->cpu_map[cpu], new_map);
1127 	}
1128 
1129 	/* Cleanup old maps */
1130 	for_each_possible_cpu(cpu) {
1131 		map = dev_maps ?
1132 			xmap_dereference(dev_maps->cpu_map[cpu]) : NULL;
1133 		if (map && xmap_dereference(new_dev_maps->cpu_map[cpu]) != map)
1134 			kfree_rcu(map, rcu);
1135 		if (new_dev_maps->cpu_map[cpu])
1136 			nonempty = 1;
1137 	}
1138 
1139 	if (nonempty) {
1140 		rcu_assign_pointer(dev->xps_maps, new_dev_maps);
1141 	} else {
1142 		kfree(new_dev_maps);
1143 		RCU_INIT_POINTER(dev->xps_maps, NULL);
1144 	}
1145 
1146 	if (dev_maps)
1147 		kfree_rcu(dev_maps, rcu);
1148 
1149 	netdev_queue_numa_node_write(queue, (numa_node_id >= 0) ? numa_node_id :
1150 					    NUMA_NO_NODE);
1151 
1152 	mutex_unlock(&xps_map_mutex);
1153 
1154 	free_cpumask_var(mask);
1155 	return len;
1156 
1157 error:
1158 	mutex_unlock(&xps_map_mutex);
1159 
1160 	if (new_dev_maps)
1161 		for_each_possible_cpu(i)
1162 			kfree(rcu_dereference_protected(
1163 				new_dev_maps->cpu_map[i],
1164 				1));
1165 	kfree(new_dev_maps);
1166 	free_cpumask_var(mask);
1167 	return -ENOMEM;
1168 }
1169 
1170 static struct netdev_queue_attribute xps_cpus_attribute =
1171     __ATTR(xps_cpus, S_IRUGO | S_IWUSR, show_xps_map, store_xps_map);
1172 #endif /* CONFIG_XPS */
1173 
1174 static struct attribute *netdev_queue_default_attrs[] = {
1175 	&queue_trans_timeout.attr,
1176 #ifdef CONFIG_XPS
1177 	&xps_cpus_attribute.attr,
1178 #endif
1179 	NULL
1180 };
1181 
1182 static void netdev_queue_release(struct kobject *kobj)
1183 {
1184 	struct netdev_queue *queue = to_netdev_queue(kobj);
1185 
1186 #ifdef CONFIG_XPS
1187 	xps_queue_release(queue);
1188 #endif
1189 
1190 	memset(kobj, 0, sizeof(*kobj));
1191 	dev_put(queue->dev);
1192 }
1193 
1194 static struct kobj_type netdev_queue_ktype = {
1195 	.sysfs_ops = &netdev_queue_sysfs_ops,
1196 	.release = netdev_queue_release,
1197 	.default_attrs = netdev_queue_default_attrs,
1198 };
1199 
1200 static int netdev_queue_add_kobject(struct net_device *net, int index)
1201 {
1202 	struct netdev_queue *queue = net->_tx + index;
1203 	struct kobject *kobj = &queue->kobj;
1204 	int error = 0;
1205 
1206 	kobj->kset = net->queues_kset;
1207 	error = kobject_init_and_add(kobj, &netdev_queue_ktype, NULL,
1208 	    "tx-%u", index);
1209 	if (error)
1210 		goto exit;
1211 
1212 #ifdef CONFIG_BQL
1213 	error = sysfs_create_group(kobj, &dql_group);
1214 	if (error)
1215 		goto exit;
1216 #endif
1217 
1218 	kobject_uevent(kobj, KOBJ_ADD);
1219 	dev_hold(queue->dev);
1220 
1221 	return 0;
1222 exit:
1223 	kobject_put(kobj);
1224 	return error;
1225 }
1226 #endif /* CONFIG_SYSFS */
1227 
1228 int
1229 netdev_queue_update_kobjects(struct net_device *net, int old_num, int new_num)
1230 {
1231 #ifdef CONFIG_SYSFS
1232 	int i;
1233 	int error = 0;
1234 
1235 	for (i = old_num; i < new_num; i++) {
1236 		error = netdev_queue_add_kobject(net, i);
1237 		if (error) {
1238 			new_num = old_num;
1239 			break;
1240 		}
1241 	}
1242 
1243 	while (--i >= new_num) {
1244 		struct netdev_queue *queue = net->_tx + i;
1245 
1246 #ifdef CONFIG_BQL
1247 		sysfs_remove_group(&queue->kobj, &dql_group);
1248 #endif
1249 		kobject_put(&queue->kobj);
1250 	}
1251 
1252 	return error;
1253 #else
1254 	return 0;
1255 #endif /* CONFIG_SYSFS */
1256 }
1257 
1258 static int register_queue_kobjects(struct net_device *net)
1259 {
1260 	int error = 0, txq = 0, rxq = 0, real_rx = 0, real_tx = 0;
1261 
1262 #ifdef CONFIG_SYSFS
1263 	net->queues_kset = kset_create_and_add("queues",
1264 	    NULL, &net->dev.kobj);
1265 	if (!net->queues_kset)
1266 		return -ENOMEM;
1267 #endif
1268 
1269 #ifdef CONFIG_RPS
1270 	real_rx = net->real_num_rx_queues;
1271 #endif
1272 	real_tx = net->real_num_tx_queues;
1273 
1274 	error = net_rx_queue_update_kobjects(net, 0, real_rx);
1275 	if (error)
1276 		goto error;
1277 	rxq = real_rx;
1278 
1279 	error = netdev_queue_update_kobjects(net, 0, real_tx);
1280 	if (error)
1281 		goto error;
1282 	txq = real_tx;
1283 
1284 	return 0;
1285 
1286 error:
1287 	netdev_queue_update_kobjects(net, txq, 0);
1288 	net_rx_queue_update_kobjects(net, rxq, 0);
1289 	return error;
1290 }
1291 
1292 static void remove_queue_kobjects(struct net_device *net)
1293 {
1294 	int real_rx = 0, real_tx = 0;
1295 
1296 #ifdef CONFIG_RPS
1297 	real_rx = net->real_num_rx_queues;
1298 #endif
1299 	real_tx = net->real_num_tx_queues;
1300 
1301 	net_rx_queue_update_kobjects(net, real_rx, 0);
1302 	netdev_queue_update_kobjects(net, real_tx, 0);
1303 #ifdef CONFIG_SYSFS
1304 	kset_unregister(net->queues_kset);
1305 #endif
1306 }
1307 
1308 static void *net_grab_current_ns(void)
1309 {
1310 	struct net *ns = current->nsproxy->net_ns;
1311 #ifdef CONFIG_NET_NS
1312 	if (ns)
1313 		atomic_inc(&ns->passive);
1314 #endif
1315 	return ns;
1316 }
1317 
1318 static const void *net_initial_ns(void)
1319 {
1320 	return &init_net;
1321 }
1322 
1323 static const void *net_netlink_ns(struct sock *sk)
1324 {
1325 	return sock_net(sk);
1326 }
1327 
1328 struct kobj_ns_type_operations net_ns_type_operations = {
1329 	.type = KOBJ_NS_TYPE_NET,
1330 	.grab_current_ns = net_grab_current_ns,
1331 	.netlink_ns = net_netlink_ns,
1332 	.initial_ns = net_initial_ns,
1333 	.drop_ns = net_drop_ns,
1334 };
1335 EXPORT_SYMBOL_GPL(net_ns_type_operations);
1336 
1337 #ifdef CONFIG_HOTPLUG
1338 static int netdev_uevent(struct device *d, struct kobj_uevent_env *env)
1339 {
1340 	struct net_device *dev = to_net_dev(d);
1341 	int retval;
1342 
1343 	/* pass interface to uevent. */
1344 	retval = add_uevent_var(env, "INTERFACE=%s", dev->name);
1345 	if (retval)
1346 		goto exit;
1347 
1348 	/* pass ifindex to uevent.
1349 	 * ifindex is useful as it won't change (interface name may change)
1350 	 * and is what RtNetlink uses natively. */
1351 	retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex);
1352 
1353 exit:
1354 	return retval;
1355 }
1356 #endif
1357 
1358 /*
1359  *	netdev_release -- destroy and free a dead device.
1360  *	Called when last reference to device kobject is gone.
1361  */
1362 static void netdev_release(struct device *d)
1363 {
1364 	struct net_device *dev = to_net_dev(d);
1365 
1366 	BUG_ON(dev->reg_state != NETREG_RELEASED);
1367 
1368 	kfree(dev->ifalias);
1369 	kfree((char *)dev - dev->padded);
1370 }
1371 
1372 static const void *net_namespace(struct device *d)
1373 {
1374 	struct net_device *dev;
1375 	dev = container_of(d, struct net_device, dev);
1376 	return dev_net(dev);
1377 }
1378 
1379 static struct class net_class = {
1380 	.name = "net",
1381 	.dev_release = netdev_release,
1382 #ifdef CONFIG_SYSFS
1383 	.dev_attrs = net_class_attributes,
1384 #endif /* CONFIG_SYSFS */
1385 #ifdef CONFIG_HOTPLUG
1386 	.dev_uevent = netdev_uevent,
1387 #endif
1388 	.ns_type = &net_ns_type_operations,
1389 	.namespace = net_namespace,
1390 };
1391 
1392 /* Delete sysfs entries but hold kobject reference until after all
1393  * netdev references are gone.
1394  */
1395 void netdev_unregister_kobject(struct net_device * net)
1396 {
1397 	struct device *dev = &(net->dev);
1398 
1399 	kobject_get(&dev->kobj);
1400 
1401 	remove_queue_kobjects(net);
1402 
1403 	device_del(dev);
1404 }
1405 
1406 /* Create sysfs entries for network device. */
1407 int netdev_register_kobject(struct net_device *net)
1408 {
1409 	struct device *dev = &(net->dev);
1410 	const struct attribute_group **groups = net->sysfs_groups;
1411 	int error = 0;
1412 
1413 	device_initialize(dev);
1414 	dev->class = &net_class;
1415 	dev->platform_data = net;
1416 	dev->groups = groups;
1417 
1418 	dev_set_name(dev, "%s", net->name);
1419 
1420 #ifdef CONFIG_SYSFS
1421 	/* Allow for a device specific group */
1422 	if (*groups)
1423 		groups++;
1424 
1425 	*groups++ = &netstat_group;
1426 
1427 #if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211)
1428 	if (net->ieee80211_ptr)
1429 		*groups++ = &wireless_group;
1430 #if IS_ENABLED(CONFIG_WIRELESS_EXT)
1431 	else if (net->wireless_handlers)
1432 		*groups++ = &wireless_group;
1433 #endif
1434 #endif
1435 #endif /* CONFIG_SYSFS */
1436 
1437 	error = device_add(dev);
1438 	if (error)
1439 		return error;
1440 
1441 	error = register_queue_kobjects(net);
1442 	if (error) {
1443 		device_del(dev);
1444 		return error;
1445 	}
1446 
1447 	return error;
1448 }
1449 
1450 int netdev_class_create_file(struct class_attribute *class_attr)
1451 {
1452 	return class_create_file(&net_class, class_attr);
1453 }
1454 EXPORT_SYMBOL(netdev_class_create_file);
1455 
1456 void netdev_class_remove_file(struct class_attribute *class_attr)
1457 {
1458 	class_remove_file(&net_class, class_attr);
1459 }
1460 EXPORT_SYMBOL(netdev_class_remove_file);
1461 
1462 int netdev_kobject_init(void)
1463 {
1464 	kobj_ns_type_register(&net_ns_type_operations);
1465 	return class_register(&net_class);
1466 }
1467