1
2
3
4
5
6
7
8
9
10
11
12#include <linux/capability.h>
13#include <linux/kernel.h>
14#include <linux/netdevice.h>
15#include <net/switchdev.h>
16#include <linux/if_arp.h>
17#include <linux/slab.h>
18#include <linux/sched/signal.h>
19#include <linux/nsproxy.h>
20#include <net/sock.h>
21#include <net/net_namespace.h>
22#include <linux/rtnetlink.h>
23#include <linux/vmalloc.h>
24#include <linux/export.h>
25#include <linux/jiffies.h>
26#include <linux/pm_runtime.h>
27#include <linux/of.h>
28#include <linux/of_net.h>
29
30#include "net-sysfs.h"
31
32#ifdef CONFIG_SYSFS
33static const char fmt_hex[] = "%#x\n";
34static const char fmt_dec[] = "%d\n";
35static const char fmt_ulong[] = "%lu\n";
36static const char fmt_u64[] = "%llu\n";
37
38static inline int dev_isalive(const struct net_device *dev)
39{
40 return dev->reg_state <= NETREG_REGISTERED;
41}
42
43
44static ssize_t netdev_show(const struct device *dev,
45 struct device_attribute *attr, char *buf,
46 ssize_t (*format)(const struct net_device *, char *))
47{
48 struct net_device *ndev = to_net_dev(dev);
49 ssize_t ret = -EINVAL;
50
51 read_lock(&dev_base_lock);
52 if (dev_isalive(ndev))
53 ret = (*format)(ndev, buf);
54 read_unlock(&dev_base_lock);
55
56 return ret;
57}
58
59
60#define NETDEVICE_SHOW(field, format_string) \
61static ssize_t format_##field(const struct net_device *dev, char *buf) \
62{ \
63 return sprintf(buf, format_string, dev->field); \
64} \
65static ssize_t field##_show(struct device *dev, \
66 struct device_attribute *attr, char *buf) \
67{ \
68 return netdev_show(dev, attr, buf, format_##field); \
69} \
70
71#define NETDEVICE_SHOW_RO(field, format_string) \
72NETDEVICE_SHOW(field, format_string); \
73static DEVICE_ATTR_RO(field)
74
75#define NETDEVICE_SHOW_RW(field, format_string) \
76NETDEVICE_SHOW(field, format_string); \
77static DEVICE_ATTR_RW(field)
78
79
80static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
81 const char *buf, size_t len,
82 int (*set)(struct net_device *, unsigned long))
83{
84 struct net_device *netdev = to_net_dev(dev);
85 struct net *net = dev_net(netdev);
86 unsigned long new;
87 int ret = -EINVAL;
88
89 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
90 return -EPERM;
91
92 ret = kstrtoul(buf, 0, &new);
93 if (ret)
94 goto err;
95
96 if (!rtnl_trylock())
97 return restart_syscall();
98
99 if (dev_isalive(netdev)) {
100 if ((ret = (*set)(netdev, new)) == 0)
101 ret = len;
102 }
103 rtnl_unlock();
104 err:
105 return ret;
106}
107
108NETDEVICE_SHOW_RO(dev_id, fmt_hex);
109NETDEVICE_SHOW_RO(dev_port, fmt_dec);
110NETDEVICE_SHOW_RO(addr_assign_type, fmt_dec);
111NETDEVICE_SHOW_RO(addr_len, fmt_dec);
112NETDEVICE_SHOW_RO(ifindex, fmt_dec);
113NETDEVICE_SHOW_RO(type, fmt_dec);
114NETDEVICE_SHOW_RO(link_mode, fmt_dec);
115
116static ssize_t iflink_show(struct device *dev, struct device_attribute *attr,
117 char *buf)
118{
119 struct net_device *ndev = to_net_dev(dev);
120
121 return sprintf(buf, fmt_dec, dev_get_iflink(ndev));
122}
123static DEVICE_ATTR_RO(iflink);
124
125static ssize_t format_name_assign_type(const struct net_device *dev, char *buf)
126{
127 return sprintf(buf, fmt_dec, dev->name_assign_type);
128}
129
130static ssize_t name_assign_type_show(struct device *dev,
131 struct device_attribute *attr,
132 char *buf)
133{
134 struct net_device *ndev = to_net_dev(dev);
135 ssize_t ret = -EINVAL;
136
137 if (ndev->name_assign_type != NET_NAME_UNKNOWN)
138 ret = netdev_show(dev, attr, buf, format_name_assign_type);
139
140 return ret;
141}
142static DEVICE_ATTR_RO(name_assign_type);
143
144
145static ssize_t address_show(struct device *dev, struct device_attribute *attr,
146 char *buf)
147{
148 struct net_device *ndev = to_net_dev(dev);
149 ssize_t ret = -EINVAL;
150
151 read_lock(&dev_base_lock);
152 if (dev_isalive(ndev))
153 ret = sysfs_format_mac(buf, ndev->dev_addr, ndev->addr_len);
154 read_unlock(&dev_base_lock);
155 return ret;
156}
157static DEVICE_ATTR_RO(address);
158
159static ssize_t broadcast_show(struct device *dev,
160 struct device_attribute *attr, char *buf)
161{
162 struct net_device *ndev = to_net_dev(dev);
163 if (dev_isalive(ndev))
164 return sysfs_format_mac(buf, ndev->broadcast, ndev->addr_len);
165 return -EINVAL;
166}
167static DEVICE_ATTR_RO(broadcast);
168
169static int change_carrier(struct net_device *dev, unsigned long new_carrier)
170{
171 if (!netif_running(dev))
172 return -EINVAL;
173 return dev_change_carrier(dev, (bool) new_carrier);
174}
175
176static ssize_t carrier_store(struct device *dev, struct device_attribute *attr,
177 const char *buf, size_t len)
178{
179 return netdev_store(dev, attr, buf, len, change_carrier);
180}
181
182static ssize_t carrier_show(struct device *dev,
183 struct device_attribute *attr, char *buf)
184{
185 struct net_device *netdev = to_net_dev(dev);
186 if (netif_running(netdev)) {
187 return sprintf(buf, fmt_dec, !!netif_carrier_ok(netdev));
188 }
189 return -EINVAL;
190}
191static DEVICE_ATTR_RW(carrier);
192
193static ssize_t speed_show(struct device *dev,
194 struct device_attribute *attr, char *buf)
195{
196 struct net_device *netdev = to_net_dev(dev);
197 int ret = -EINVAL;
198
199 if (!rtnl_trylock())
200 return restart_syscall();
201
202 if (netif_running(netdev)) {
203 struct ethtool_link_ksettings cmd;
204
205 if (!__ethtool_get_link_ksettings(netdev, &cmd))
206 ret = sprintf(buf, fmt_dec, cmd.base.speed);
207 }
208 rtnl_unlock();
209 return ret;
210}
211static DEVICE_ATTR_RO(speed);
212
213static ssize_t duplex_show(struct device *dev,
214 struct device_attribute *attr, char *buf)
215{
216 struct net_device *netdev = to_net_dev(dev);
217 int ret = -EINVAL;
218
219 if (!rtnl_trylock())
220 return restart_syscall();
221
222 if (netif_running(netdev)) {
223 struct ethtool_link_ksettings cmd;
224
225 if (!__ethtool_get_link_ksettings(netdev, &cmd)) {
226 const char *duplex;
227
228 switch (cmd.base.duplex) {
229 case DUPLEX_HALF:
230 duplex = "half";
231 break;
232 case DUPLEX_FULL:
233 duplex = "full";
234 break;
235 default:
236 duplex = "unknown";
237 break;
238 }
239 ret = sprintf(buf, "%s\n", duplex);
240 }
241 }
242 rtnl_unlock();
243 return ret;
244}
245static DEVICE_ATTR_RO(duplex);
246
247static ssize_t dormant_show(struct device *dev,
248 struct device_attribute *attr, char *buf)
249{
250 struct net_device *netdev = to_net_dev(dev);
251
252 if (netif_running(netdev))
253 return sprintf(buf, fmt_dec, !!netif_dormant(netdev));
254
255 return -EINVAL;
256}
257static DEVICE_ATTR_RO(dormant);
258
259static const char *const operstates[] = {
260 "unknown",
261 "notpresent",
262 "down",
263 "lowerlayerdown",
264 "testing",
265 "dormant",
266 "up"
267};
268
269static ssize_t operstate_show(struct device *dev,
270 struct device_attribute *attr, char *buf)
271{
272 const struct net_device *netdev = to_net_dev(dev);
273 unsigned char operstate;
274
275 read_lock(&dev_base_lock);
276 operstate = netdev->operstate;
277 if (!netif_running(netdev))
278 operstate = IF_OPER_DOWN;
279 read_unlock(&dev_base_lock);
280
281 if (operstate >= ARRAY_SIZE(operstates))
282 return -EINVAL;
283
284 return sprintf(buf, "%s\n", operstates[operstate]);
285}
286static DEVICE_ATTR_RO(operstate);
287
288static ssize_t carrier_changes_show(struct device *dev,
289 struct device_attribute *attr,
290 char *buf)
291{
292 struct net_device *netdev = to_net_dev(dev);
293 return sprintf(buf, fmt_dec,
294 atomic_read(&netdev->carrier_changes));
295}
296static DEVICE_ATTR_RO(carrier_changes);
297
298
299
300static int change_mtu(struct net_device *dev, unsigned long new_mtu)
301{
302 return dev_set_mtu(dev, (int) new_mtu);
303}
304
305static ssize_t mtu_store(struct device *dev, struct device_attribute *attr,
306 const char *buf, size_t len)
307{
308 return netdev_store(dev, attr, buf, len, change_mtu);
309}
310NETDEVICE_SHOW_RW(mtu, fmt_dec);
311
312static int change_flags(struct net_device *dev, unsigned long new_flags)
313{
314 return dev_change_flags(dev, (unsigned int) new_flags);
315}
316
317static ssize_t flags_store(struct device *dev, struct device_attribute *attr,
318 const char *buf, size_t len)
319{
320 return netdev_store(dev, attr, buf, len, change_flags);
321}
322NETDEVICE_SHOW_RW(flags, fmt_hex);
323
324static int change_tx_queue_len(struct net_device *dev, unsigned long new_len)
325{
326 int res, orig_len = dev->tx_queue_len;
327
328 if (new_len != orig_len) {
329 dev->tx_queue_len = new_len;
330 res = call_netdevice_notifiers(NETDEV_CHANGE_TX_QUEUE_LEN, dev);
331 res = notifier_to_errno(res);
332 if (res) {
333 netdev_err(dev,
334 "refused to change device tx_queue_len\n");
335 dev->tx_queue_len = orig_len;
336 return -EFAULT;
337 }
338 }
339
340 return 0;
341}
342
343static ssize_t tx_queue_len_store(struct device *dev,
344 struct device_attribute *attr,
345 const char *buf, size_t len)
346{
347 if (!capable(CAP_NET_ADMIN))
348 return -EPERM;
349
350 return netdev_store(dev, attr, buf, len, change_tx_queue_len);
351}
352NETDEVICE_SHOW_RW(tx_queue_len, fmt_ulong);
353
354static int change_gro_flush_timeout(struct net_device *dev, unsigned long val)
355{
356 dev->gro_flush_timeout = val;
357 return 0;
358}
359
360static ssize_t gro_flush_timeout_store(struct device *dev,
361 struct device_attribute *attr,
362 const char *buf, size_t len)
363{
364 if (!capable(CAP_NET_ADMIN))
365 return -EPERM;
366
367 return netdev_store(dev, attr, buf, len, change_gro_flush_timeout);
368}
369NETDEVICE_SHOW_RW(gro_flush_timeout, fmt_ulong);
370
371static ssize_t ifalias_store(struct device *dev, struct device_attribute *attr,
372 const char *buf, size_t len)
373{
374 struct net_device *netdev = to_net_dev(dev);
375 struct net *net = dev_net(netdev);
376 size_t count = len;
377 ssize_t ret;
378
379 if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
380 return -EPERM;
381
382
383 if (len > 0 && buf[len - 1] == '\n')
384 --count;
385
386 if (!rtnl_trylock())
387 return restart_syscall();
388 ret = dev_set_alias(netdev, buf, count);
389 rtnl_unlock();
390
391 return ret < 0 ? ret : len;
392}
393
394static ssize_t ifalias_show(struct device *dev,
395 struct device_attribute *attr, char *buf)
396{
397 const struct net_device *netdev = to_net_dev(dev);
398 ssize_t ret = 0;
399
400 if (!rtnl_trylock())
401 return restart_syscall();
402 if (netdev->ifalias)
403 ret = sprintf(buf, "%s\n", netdev->ifalias);
404 rtnl_unlock();
405 return ret;
406}
407static DEVICE_ATTR_RW(ifalias);
408
409static int change_group(struct net_device *dev, unsigned long new_group)
410{
411 dev_set_group(dev, (int) new_group);
412 return 0;
413}
414
415static ssize_t group_store(struct device *dev, struct device_attribute *attr,
416 const char *buf, size_t len)
417{
418 return netdev_store(dev, attr, buf, len, change_group);
419}
420NETDEVICE_SHOW(group, fmt_dec);
421static DEVICE_ATTR(netdev_group, S_IRUGO | S_IWUSR, group_show, group_store);
422
423static int change_proto_down(struct net_device *dev, unsigned long proto_down)
424{
425 return dev_change_proto_down(dev, (bool) proto_down);
426}
427
428static ssize_t proto_down_store(struct device *dev,
429 struct device_attribute *attr,
430 const char *buf, size_t len)
431{
432 return netdev_store(dev, attr, buf, len, change_proto_down);
433}
434NETDEVICE_SHOW_RW(proto_down, fmt_dec);
435
436static ssize_t phys_port_id_show(struct device *dev,
437 struct device_attribute *attr, char *buf)
438{
439 struct net_device *netdev = to_net_dev(dev);
440 ssize_t ret = -EINVAL;
441
442 if (!rtnl_trylock())
443 return restart_syscall();
444
445 if (dev_isalive(netdev)) {
446 struct netdev_phys_item_id ppid;
447
448 ret = dev_get_phys_port_id(netdev, &ppid);
449 if (!ret)
450 ret = sprintf(buf, "%*phN\n", ppid.id_len, ppid.id);
451 }
452 rtnl_unlock();
453
454 return ret;
455}
456static DEVICE_ATTR_RO(phys_port_id);
457
458static ssize_t phys_port_name_show(struct device *dev,
459 struct device_attribute *attr, char *buf)
460{
461 struct net_device *netdev = to_net_dev(dev);
462 ssize_t ret = -EINVAL;
463
464 if (!rtnl_trylock())
465 return restart_syscall();
466
467 if (dev_isalive(netdev)) {
468 char name[IFNAMSIZ];
469
470 ret = dev_get_phys_port_name(netdev, name, sizeof(name));
471 if (!ret)
472 ret = sprintf(buf, "%s\n", name);
473 }
474 rtnl_unlock();
475
476 return ret;
477}
478static DEVICE_ATTR_RO(phys_port_name);
479
480static ssize_t phys_switch_id_show(struct device *dev,
481 struct device_attribute *attr, char *buf)
482{
483 struct net_device *netdev = to_net_dev(dev);
484 ssize_t ret = -EINVAL;
485
486 if (!rtnl_trylock())
487 return restart_syscall();
488
489 if (dev_isalive(netdev)) {
490 struct switchdev_attr attr = {
491 .orig_dev = netdev,
492 .id = SWITCHDEV_ATTR_ID_PORT_PARENT_ID,
493 .flags = SWITCHDEV_F_NO_RECURSE,
494 };
495
496 ret = switchdev_port_attr_get(netdev, &attr);
497 if (!ret)
498 ret = sprintf(buf, "%*phN\n", attr.u.ppid.id_len,
499 attr.u.ppid.id);
500 }
501 rtnl_unlock();
502
503 return ret;
504}
505static DEVICE_ATTR_RO(phys_switch_id);
506
507static struct attribute *net_class_attrs[] = {
508 &dev_attr_netdev_group.attr,
509 &dev_attr_type.attr,
510 &dev_attr_dev_id.attr,
511 &dev_attr_dev_port.attr,
512 &dev_attr_iflink.attr,
513 &dev_attr_ifindex.attr,
514 &dev_attr_name_assign_type.attr,
515 &dev_attr_addr_assign_type.attr,
516 &dev_attr_addr_len.attr,
517 &dev_attr_link_mode.attr,
518 &dev_attr_address.attr,
519 &dev_attr_broadcast.attr,
520 &dev_attr_speed.attr,
521 &dev_attr_duplex.attr,
522 &dev_attr_dormant.attr,
523 &dev_attr_operstate.attr,
524 &dev_attr_carrier_changes.attr,
525 &dev_attr_ifalias.attr,
526 &dev_attr_carrier.attr,
527 &dev_attr_mtu.attr,
528 &dev_attr_flags.attr,
529 &dev_attr_tx_queue_len.attr,
530 &dev_attr_gro_flush_timeout.attr,
531 &dev_attr_phys_port_id.attr,
532 &dev_attr_phys_port_name.attr,
533 &dev_attr_phys_switch_id.attr,
534 &dev_attr_proto_down.attr,
535 NULL,
536};
537ATTRIBUTE_GROUPS(net_class);
538
539
540static ssize_t netstat_show(const struct device *d,
541 struct device_attribute *attr, char *buf,
542 unsigned long offset)
543{
544 struct net_device *dev = to_net_dev(d);
545 ssize_t ret = -EINVAL;
546
547 WARN_ON(offset > sizeof(struct rtnl_link_stats64) ||
548 offset % sizeof(u64) != 0);
549
550 read_lock(&dev_base_lock);
551 if (dev_isalive(dev)) {
552 struct rtnl_link_stats64 temp;
553 const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);
554
555 ret = sprintf(buf, fmt_u64, *(u64 *)(((u8 *) stats) + offset));
556 }
557 read_unlock(&dev_base_lock);
558 return ret;
559}
560
561
562#define NETSTAT_ENTRY(name) \
563static ssize_t name##_show(struct device *d, \
564 struct device_attribute *attr, char *buf) \
565{ \
566 return netstat_show(d, attr, buf, \
567 offsetof(struct rtnl_link_stats64, name)); \
568} \
569static DEVICE_ATTR_RO(name)
570
571NETSTAT_ENTRY(rx_packets);
572NETSTAT_ENTRY(tx_packets);
573NETSTAT_ENTRY(rx_bytes);
574NETSTAT_ENTRY(tx_bytes);
575NETSTAT_ENTRY(rx_errors);
576NETSTAT_ENTRY(tx_errors);
577NETSTAT_ENTRY(rx_dropped);
578NETSTAT_ENTRY(tx_dropped);
579NETSTAT_ENTRY(multicast);
580NETSTAT_ENTRY(collisions);
581NETSTAT_ENTRY(rx_length_errors);
582NETSTAT_ENTRY(rx_over_errors);
583NETSTAT_ENTRY(rx_crc_errors);
584NETSTAT_ENTRY(rx_frame_errors);
585NETSTAT_ENTRY(rx_fifo_errors);
586NETSTAT_ENTRY(rx_missed_errors);
587NETSTAT_ENTRY(tx_aborted_errors);
588NETSTAT_ENTRY(tx_carrier_errors);
589NETSTAT_ENTRY(tx_fifo_errors);
590NETSTAT_ENTRY(tx_heartbeat_errors);
591NETSTAT_ENTRY(tx_window_errors);
592NETSTAT_ENTRY(rx_compressed);
593NETSTAT_ENTRY(tx_compressed);
594NETSTAT_ENTRY(rx_nohandler);
595
596static struct attribute *netstat_attrs[] = {
597 &dev_attr_rx_packets.attr,
598 &dev_attr_tx_packets.attr,
599 &dev_attr_rx_bytes.attr,
600 &dev_attr_tx_bytes.attr,
601 &dev_attr_rx_errors.attr,
602 &dev_attr_tx_errors.attr,
603 &dev_attr_rx_dropped.attr,
604 &dev_attr_tx_dropped.attr,
605 &dev_attr_multicast.attr,
606 &dev_attr_collisions.attr,
607 &dev_attr_rx_length_errors.attr,
608 &dev_attr_rx_over_errors.attr,
609 &dev_attr_rx_crc_errors.attr,
610 &dev_attr_rx_frame_errors.attr,
611 &dev_attr_rx_fifo_errors.attr,
612 &dev_attr_rx_missed_errors.attr,
613 &dev_attr_tx_aborted_errors.attr,
614 &dev_attr_tx_carrier_errors.attr,
615 &dev_attr_tx_fifo_errors.attr,
616 &dev_attr_tx_heartbeat_errors.attr,
617 &dev_attr_tx_window_errors.attr,
618 &dev_attr_rx_compressed.attr,
619 &dev_attr_tx_compressed.attr,
620 &dev_attr_rx_nohandler.attr,
621 NULL
622};
623
624
625static struct attribute_group netstat_group = {
626 .name = "statistics",
627 .attrs = netstat_attrs,
628};
629
630#if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211)
631static struct attribute *wireless_attrs[] = {
632 NULL
633};
634
635static struct attribute_group wireless_group = {
636 .name = "wireless",
637 .attrs = wireless_attrs,
638};
639#endif
640
641#else
642#define net_class_groups NULL
643#endif
644
645#ifdef CONFIG_SYSFS
646#define to_rx_queue_attr(_attr) container_of(_attr, \
647 struct rx_queue_attribute, attr)
648
649#define to_rx_queue(obj) container_of(obj, struct netdev_rx_queue, kobj)
650
651static ssize_t rx_queue_attr_show(struct kobject *kobj, struct attribute *attr,
652 char *buf)
653{
654 struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
655 struct netdev_rx_queue *queue = to_rx_queue(kobj);
656
657 if (!attribute->show)
658 return -EIO;
659
660 return attribute->show(queue, attribute, buf);
661}
662
663static ssize_t rx_queue_attr_store(struct kobject *kobj, struct attribute *attr,
664 const char *buf, size_t count)
665{
666 struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
667 struct netdev_rx_queue *queue = to_rx_queue(kobj);
668
669 if (!attribute->store)
670 return -EIO;
671
672 return attribute->store(queue, attribute, buf, count);
673}
674
675static const struct sysfs_ops rx_queue_sysfs_ops = {
676 .show = rx_queue_attr_show,
677 .store = rx_queue_attr_store,
678};
679
680#ifdef CONFIG_RPS
681static ssize_t show_rps_map(struct netdev_rx_queue *queue,
682 struct rx_queue_attribute *attribute, char *buf)
683{
684 struct rps_map *map;
685 cpumask_var_t mask;
686 int i, len;
687
688 if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
689 return -ENOMEM;
690
691 rcu_read_lock();
692 map = rcu_dereference(queue->rps_map);
693 if (map)
694 for (i = 0; i < map->len; i++)
695 cpumask_set_cpu(map->cpus[i], mask);
696
697 len = snprintf(buf, PAGE_SIZE, "%*pb\n", cpumask_pr_args(mask));
698 rcu_read_unlock();
699 free_cpumask_var(mask);
700
701 return len < PAGE_SIZE ? len : -EINVAL;
702}
703
704static ssize_t store_rps_map(struct netdev_rx_queue *queue,
705 struct rx_queue_attribute *attribute,
706 const char *buf, size_t len)
707{
708 struct rps_map *old_map, *map;
709 cpumask_var_t mask;
710 int err, cpu, i;
711 static DEFINE_MUTEX(rps_map_mutex);
712
713 if (!capable(CAP_NET_ADMIN))
714 return -EPERM;
715
716 if (!alloc_cpumask_var(&mask, GFP_KERNEL))
717 return -ENOMEM;
718
719 err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
720 if (err) {
721 free_cpumask_var(mask);
722 return err;
723 }
724
725 map = kzalloc(max_t(unsigned int,
726 RPS_MAP_SIZE(cpumask_weight(mask)), L1_CACHE_BYTES),
727 GFP_KERNEL);
728 if (!map) {
729 free_cpumask_var(mask);
730 return -ENOMEM;
731 }
732
733 i = 0;
734 for_each_cpu_and(cpu, mask, cpu_online_mask)
735 map->cpus[i++] = cpu;
736
737 if (i)
738 map->len = i;
739 else {
740 kfree(map);
741 map = NULL;
742 }
743
744 mutex_lock(&rps_map_mutex);
745 old_map = rcu_dereference_protected(queue->rps_map,
746 mutex_is_locked(&rps_map_mutex));
747 rcu_assign_pointer(queue->rps_map, map);
748
749 if (map)
750 static_key_slow_inc(&rps_needed);
751 if (old_map)
752 static_key_slow_dec(&rps_needed);
753
754 mutex_unlock(&rps_map_mutex);
755
756 if (old_map)
757 kfree_rcu(old_map, rcu);
758
759 free_cpumask_var(mask);
760 return len;
761}
762
763static ssize_t show_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
764 struct rx_queue_attribute *attr,
765 char *buf)
766{
767 struct rps_dev_flow_table *flow_table;
768 unsigned long val = 0;
769
770 rcu_read_lock();
771 flow_table = rcu_dereference(queue->rps_flow_table);
772 if (flow_table)
773 val = (unsigned long)flow_table->mask + 1;
774 rcu_read_unlock();
775
776 return sprintf(buf, "%lu\n", val);
777}
778
779static void rps_dev_flow_table_release(struct rcu_head *rcu)
780{
781 struct rps_dev_flow_table *table = container_of(rcu,
782 struct rps_dev_flow_table, rcu);
783 vfree(table);
784}
785
786static ssize_t store_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
787 struct rx_queue_attribute *attr,
788 const char *buf, size_t len)
789{
790 unsigned long mask, count;
791 struct rps_dev_flow_table *table, *old_table;
792 static DEFINE_SPINLOCK(rps_dev_flow_lock);
793 int rc;
794
795 if (!capable(CAP_NET_ADMIN))
796 return -EPERM;
797
798 rc = kstrtoul(buf, 0, &count);
799 if (rc < 0)
800 return rc;
801
802 if (count) {
803 mask = count - 1;
804
805
806
807 while ((mask | (mask >> 1)) != mask)
808 mask |= (mask >> 1);
809
810
811
812
813#if BITS_PER_LONG > 32
814 if (mask > (unsigned long)(u32)mask)
815 return -EINVAL;
816#else
817 if (mask > (ULONG_MAX - RPS_DEV_FLOW_TABLE_SIZE(1))
818 / sizeof(struct rps_dev_flow)) {
819
820 return -EINVAL;
821 }
822#endif
823 table = vmalloc(RPS_DEV_FLOW_TABLE_SIZE(mask + 1));
824 if (!table)
825 return -ENOMEM;
826
827 table->mask = mask;
828 for (count = 0; count <= mask; count++)
829 table->flows[count].cpu = RPS_NO_CPU;
830 } else
831 table = NULL;
832
833 spin_lock(&rps_dev_flow_lock);
834 old_table = rcu_dereference_protected(queue->rps_flow_table,
835 lockdep_is_held(&rps_dev_flow_lock));
836 rcu_assign_pointer(queue->rps_flow_table, table);
837 spin_unlock(&rps_dev_flow_lock);
838
839 if (old_table)
840 call_rcu(&old_table->rcu, rps_dev_flow_table_release);
841
842 return len;
843}
844
845static struct rx_queue_attribute rps_cpus_attribute =
846 __ATTR(rps_cpus, S_IRUGO | S_IWUSR, show_rps_map, store_rps_map);
847
848
849static struct rx_queue_attribute rps_dev_flow_table_cnt_attribute =
850 __ATTR(rps_flow_cnt, S_IRUGO | S_IWUSR,
851 show_rps_dev_flow_table_cnt, store_rps_dev_flow_table_cnt);
852#endif
853
854static struct attribute *rx_queue_default_attrs[] = {
855#ifdef CONFIG_RPS
856 &rps_cpus_attribute.attr,
857 &rps_dev_flow_table_cnt_attribute.attr,
858#endif
859 NULL
860};
861
862static void rx_queue_release(struct kobject *kobj)
863{
864 struct netdev_rx_queue *queue = to_rx_queue(kobj);
865#ifdef CONFIG_RPS
866 struct rps_map *map;
867 struct rps_dev_flow_table *flow_table;
868
869
870 map = rcu_dereference_protected(queue->rps_map, 1);
871 if (map) {
872 RCU_INIT_POINTER(queue->rps_map, NULL);
873 kfree_rcu(map, rcu);
874 }
875
876 flow_table = rcu_dereference_protected(queue->rps_flow_table, 1);
877 if (flow_table) {
878 RCU_INIT_POINTER(queue->rps_flow_table, NULL);
879 call_rcu(&flow_table->rcu, rps_dev_flow_table_release);
880 }
881#endif
882
883 memset(kobj, 0, sizeof(*kobj));
884 dev_put(queue->dev);
885}
886
887static const void *rx_queue_namespace(struct kobject *kobj)
888{
889 struct netdev_rx_queue *queue = to_rx_queue(kobj);
890 struct device *dev = &queue->dev->dev;
891 const void *ns = NULL;
892
893 if (dev->class && dev->class->ns_type)
894 ns = dev->class->namespace(dev);
895
896 return ns;
897}
898
899static struct kobj_type rx_queue_ktype = {
900 .sysfs_ops = &rx_queue_sysfs_ops,
901 .release = rx_queue_release,
902 .default_attrs = rx_queue_default_attrs,
903 .namespace = rx_queue_namespace
904};
905
906static int rx_queue_add_kobject(struct net_device *dev, int index)
907{
908 struct netdev_rx_queue *queue = dev->_rx + index;
909 struct kobject *kobj = &queue->kobj;
910 int error = 0;
911
912 kobj->kset = dev->queues_kset;
913 error = kobject_init_and_add(kobj, &rx_queue_ktype, NULL,
914 "rx-%u", index);
915 if (error)
916 goto exit;
917
918 if (dev->sysfs_rx_queue_group) {
919 error = sysfs_create_group(kobj, dev->sysfs_rx_queue_group);
920 if (error)
921 goto exit;
922 }
923
924 kobject_uevent(kobj, KOBJ_ADD);
925 dev_hold(queue->dev);
926
927 return error;
928exit:
929 kobject_put(kobj);
930 return error;
931}
932#endif
933
934int
935net_rx_queue_update_kobjects(struct net_device *dev, int old_num, int new_num)
936{
937#ifdef CONFIG_SYSFS
938 int i;
939 int error = 0;
940
941#ifndef CONFIG_RPS
942 if (!dev->sysfs_rx_queue_group)
943 return 0;
944#endif
945 for (i = old_num; i < new_num; i++) {
946 error = rx_queue_add_kobject(dev, i);
947 if (error) {
948 new_num = old_num;
949 break;
950 }
951 }
952
953 while (--i >= new_num) {
954 struct kobject *kobj = &dev->_rx[i].kobj;
955
956 if (!atomic_read(&dev_net(dev)->count))
957 kobj->uevent_suppress = 1;
958 if (dev->sysfs_rx_queue_group)
959 sysfs_remove_group(kobj, dev->sysfs_rx_queue_group);
960 kobject_put(kobj);
961 }
962
963 return error;
964#else
965 return 0;
966#endif
967}
968
969#ifdef CONFIG_SYSFS
970
971
972
973struct netdev_queue_attribute {
974 struct attribute attr;
975 ssize_t (*show)(struct netdev_queue *queue,
976 struct netdev_queue_attribute *attr, char *buf);
977 ssize_t (*store)(struct netdev_queue *queue,
978 struct netdev_queue_attribute *attr, const char *buf, size_t len);
979};
980#define to_netdev_queue_attr(_attr) container_of(_attr, \
981 struct netdev_queue_attribute, attr)
982
983#define to_netdev_queue(obj) container_of(obj, struct netdev_queue, kobj)
984
985static ssize_t netdev_queue_attr_show(struct kobject *kobj,
986 struct attribute *attr, char *buf)
987{
988 struct netdev_queue_attribute *attribute = to_netdev_queue_attr(attr);
989 struct netdev_queue *queue = to_netdev_queue(kobj);
990
991 if (!attribute->show)
992 return -EIO;
993
994 return attribute->show(queue, attribute, buf);
995}
996
997static ssize_t netdev_queue_attr_store(struct kobject *kobj,
998 struct attribute *attr,
999 const char *buf, size_t count)
1000{
1001 struct netdev_queue_attribute *attribute = to_netdev_queue_attr(attr);
1002 struct netdev_queue *queue = to_netdev_queue(kobj);
1003
1004 if (!attribute->store)
1005 return -EIO;
1006
1007 return attribute->store(queue, attribute, buf, count);
1008}
1009
1010static const struct sysfs_ops netdev_queue_sysfs_ops = {
1011 .show = netdev_queue_attr_show,
1012 .store = netdev_queue_attr_store,
1013};
1014
1015static ssize_t show_trans_timeout(struct netdev_queue *queue,
1016 struct netdev_queue_attribute *attribute,
1017 char *buf)
1018{
1019 unsigned long trans_timeout;
1020
1021 spin_lock_irq(&queue->_xmit_lock);
1022 trans_timeout = queue->trans_timeout;
1023 spin_unlock_irq(&queue->_xmit_lock);
1024
1025 return sprintf(buf, "%lu", trans_timeout);
1026}
1027
1028static unsigned int get_netdev_queue_index(struct netdev_queue *queue)
1029{
1030 struct net_device *dev = queue->dev;
1031 unsigned int i;
1032
1033 i = queue - dev->_tx;
1034 BUG_ON(i >= dev->num_tx_queues);
1035
1036 return i;
1037}
1038
1039static ssize_t show_traffic_class(struct netdev_queue *queue,
1040 struct netdev_queue_attribute *attribute,
1041 char *buf)
1042{
1043 struct net_device *dev = queue->dev;
1044 int index = get_netdev_queue_index(queue);
1045 int tc = netdev_txq_to_tc(dev, index);
1046
1047 if (tc < 0)
1048 return -EINVAL;
1049
1050 return sprintf(buf, "%u\n", tc);
1051}
1052
1053#ifdef CONFIG_XPS
1054static ssize_t show_tx_maxrate(struct netdev_queue *queue,
1055 struct netdev_queue_attribute *attribute,
1056 char *buf)
1057{
1058 return sprintf(buf, "%lu\n", queue->tx_maxrate);
1059}
1060
1061static ssize_t set_tx_maxrate(struct netdev_queue *queue,
1062 struct netdev_queue_attribute *attribute,
1063 const char *buf, size_t len)
1064{
1065 struct net_device *dev = queue->dev;
1066 int err, index = get_netdev_queue_index(queue);
1067 u32 rate = 0;
1068
1069 err = kstrtou32(buf, 10, &rate);
1070 if (err < 0)
1071 return err;
1072
1073 if (!rtnl_trylock())
1074 return restart_syscall();
1075
1076 err = -EOPNOTSUPP;
1077 if (dev->netdev_ops->ndo_set_tx_maxrate)
1078 err = dev->netdev_ops->ndo_set_tx_maxrate(dev, index, rate);
1079
1080 rtnl_unlock();
1081 if (!err) {
1082 queue->tx_maxrate = rate;
1083 return len;
1084 }
1085 return err;
1086}
1087
1088static struct netdev_queue_attribute queue_tx_maxrate =
1089 __ATTR(tx_maxrate, S_IRUGO | S_IWUSR,
1090 show_tx_maxrate, set_tx_maxrate);
1091#endif
1092
1093static struct netdev_queue_attribute queue_trans_timeout =
1094 __ATTR(tx_timeout, S_IRUGO, show_trans_timeout, NULL);
1095
1096static struct netdev_queue_attribute queue_traffic_class =
1097 __ATTR(traffic_class, S_IRUGO, show_traffic_class, NULL);
1098
1099#ifdef CONFIG_BQL
1100
1101
1102
1103static ssize_t bql_show(char *buf, unsigned int value)
1104{
1105 return sprintf(buf, "%u\n", value);
1106}
1107
1108static ssize_t bql_set(const char *buf, const size_t count,
1109 unsigned int *pvalue)
1110{
1111 unsigned int value;
1112 int err;
1113
1114 if (!strcmp(buf, "max") || !strcmp(buf, "max\n"))
1115 value = DQL_MAX_LIMIT;
1116 else {
1117 err = kstrtouint(buf, 10, &value);
1118 if (err < 0)
1119 return err;
1120 if (value > DQL_MAX_LIMIT)
1121 return -EINVAL;
1122 }
1123
1124 *pvalue = value;
1125
1126 return count;
1127}
1128
1129static ssize_t bql_show_hold_time(struct netdev_queue *queue,
1130 struct netdev_queue_attribute *attr,
1131 char *buf)
1132{
1133 struct dql *dql = &queue->dql;
1134
1135 return sprintf(buf, "%u\n", jiffies_to_msecs(dql->slack_hold_time));
1136}
1137
1138static ssize_t bql_set_hold_time(struct netdev_queue *queue,
1139 struct netdev_queue_attribute *attribute,
1140 const char *buf, size_t len)
1141{
1142 struct dql *dql = &queue->dql;
1143 unsigned int value;
1144 int err;
1145
1146 err = kstrtouint(buf, 10, &value);
1147 if (err < 0)
1148 return err;
1149
1150 dql->slack_hold_time = msecs_to_jiffies(value);
1151
1152 return len;
1153}
1154
1155static struct netdev_queue_attribute bql_hold_time_attribute =
1156 __ATTR(hold_time, S_IRUGO | S_IWUSR, bql_show_hold_time,
1157 bql_set_hold_time);
1158
1159static ssize_t bql_show_inflight(struct netdev_queue *queue,
1160 struct netdev_queue_attribute *attr,
1161 char *buf)
1162{
1163 struct dql *dql = &queue->dql;
1164
1165 return sprintf(buf, "%u\n", dql->num_queued - dql->num_completed);
1166}
1167
1168static struct netdev_queue_attribute bql_inflight_attribute =
1169 __ATTR(inflight, S_IRUGO, bql_show_inflight, NULL);
1170
1171#define BQL_ATTR(NAME, FIELD) \
1172static ssize_t bql_show_ ## NAME(struct netdev_queue *queue, \
1173 struct netdev_queue_attribute *attr, \
1174 char *buf) \
1175{ \
1176 return bql_show(buf, queue->dql.FIELD); \
1177} \
1178 \
1179static ssize_t bql_set_ ## NAME(struct netdev_queue *queue, \
1180 struct netdev_queue_attribute *attr, \
1181 const char *buf, size_t len) \
1182{ \
1183 return bql_set(buf, len, &queue->dql.FIELD); \
1184} \
1185 \
1186static struct netdev_queue_attribute bql_ ## NAME ## _attribute = \
1187 __ATTR(NAME, S_IRUGO | S_IWUSR, bql_show_ ## NAME, \
1188 bql_set_ ## NAME);
1189
1190BQL_ATTR(limit, limit)
1191BQL_ATTR(limit_max, max_limit)
1192BQL_ATTR(limit_min, min_limit)
1193
1194static struct attribute *dql_attrs[] = {
1195 &bql_limit_attribute.attr,
1196 &bql_limit_max_attribute.attr,
1197 &bql_limit_min_attribute.attr,
1198 &bql_hold_time_attribute.attr,
1199 &bql_inflight_attribute.attr,
1200 NULL
1201};
1202
1203static struct attribute_group dql_group = {
1204 .name = "byte_queue_limits",
1205 .attrs = dql_attrs,
1206};
1207#endif
1208
1209#ifdef CONFIG_XPS
1210static ssize_t show_xps_map(struct netdev_queue *queue,
1211 struct netdev_queue_attribute *attribute, char *buf)
1212{
1213 struct net_device *dev = queue->dev;
1214 int cpu, len, num_tc = 1, tc = 0;
1215 struct xps_dev_maps *dev_maps;
1216 cpumask_var_t mask;
1217 unsigned long index;
1218
1219 if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
1220 return -ENOMEM;
1221
1222 index = get_netdev_queue_index(queue);
1223
1224 if (dev->num_tc) {
1225 num_tc = dev->num_tc;
1226 tc = netdev_txq_to_tc(dev, index);
1227 if (tc < 0)
1228 return -EINVAL;
1229 }
1230
1231 rcu_read_lock();
1232 dev_maps = rcu_dereference(dev->xps_maps);
1233 if (dev_maps) {
1234 for_each_possible_cpu(cpu) {
1235 int i, tci = cpu * num_tc + tc;
1236 struct xps_map *map;
1237
1238 map = rcu_dereference(dev_maps->cpu_map[tci]);
1239 if (!map)
1240 continue;
1241
1242 for (i = map->len; i--;) {
1243 if (map->queues[i] == index) {
1244 cpumask_set_cpu(cpu, mask);
1245 break;
1246 }
1247 }
1248 }
1249 }
1250 rcu_read_unlock();
1251
1252 len = snprintf(buf, PAGE_SIZE, "%*pb\n", cpumask_pr_args(mask));
1253 free_cpumask_var(mask);
1254 return len < PAGE_SIZE ? len : -EINVAL;
1255}
1256
1257static ssize_t store_xps_map(struct netdev_queue *queue,
1258 struct netdev_queue_attribute *attribute,
1259 const char *buf, size_t len)
1260{
1261 struct net_device *dev = queue->dev;
1262 unsigned long index;
1263 cpumask_var_t mask;
1264 int err;
1265
1266 if (!capable(CAP_NET_ADMIN))
1267 return -EPERM;
1268
1269 if (!alloc_cpumask_var(&mask, GFP_KERNEL))
1270 return -ENOMEM;
1271
1272 index = get_netdev_queue_index(queue);
1273
1274 err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
1275 if (err) {
1276 free_cpumask_var(mask);
1277 return err;
1278 }
1279
1280 err = netif_set_xps_queue(dev, mask, index);
1281
1282 free_cpumask_var(mask);
1283
1284 return err ? : len;
1285}
1286
1287static struct netdev_queue_attribute xps_cpus_attribute =
1288 __ATTR(xps_cpus, S_IRUGO | S_IWUSR, show_xps_map, store_xps_map);
1289#endif
1290
1291static struct attribute *netdev_queue_default_attrs[] = {
1292 &queue_trans_timeout.attr,
1293 &queue_traffic_class.attr,
1294#ifdef CONFIG_XPS
1295 &xps_cpus_attribute.attr,
1296 &queue_tx_maxrate.attr,
1297#endif
1298 NULL
1299};
1300
1301static void netdev_queue_release(struct kobject *kobj)
1302{
1303 struct netdev_queue *queue = to_netdev_queue(kobj);
1304
1305 memset(kobj, 0, sizeof(*kobj));
1306 dev_put(queue->dev);
1307}
1308
1309static const void *netdev_queue_namespace(struct kobject *kobj)
1310{
1311 struct netdev_queue *queue = to_netdev_queue(kobj);
1312 struct device *dev = &queue->dev->dev;
1313 const void *ns = NULL;
1314
1315 if (dev->class && dev->class->ns_type)
1316 ns = dev->class->namespace(dev);
1317
1318 return ns;
1319}
1320
1321static struct kobj_type netdev_queue_ktype = {
1322 .sysfs_ops = &netdev_queue_sysfs_ops,
1323 .release = netdev_queue_release,
1324 .default_attrs = netdev_queue_default_attrs,
1325 .namespace = netdev_queue_namespace,
1326};
1327
1328static int netdev_queue_add_kobject(struct net_device *dev, int index)
1329{
1330 struct netdev_queue *queue = dev->_tx + index;
1331 struct kobject *kobj = &queue->kobj;
1332 int error = 0;
1333
1334 kobj->kset = dev->queues_kset;
1335 error = kobject_init_and_add(kobj, &netdev_queue_ktype, NULL,
1336 "tx-%u", index);
1337 if (error)
1338 goto exit;
1339
1340#ifdef CONFIG_BQL
1341 error = sysfs_create_group(kobj, &dql_group);
1342 if (error)
1343 goto exit;
1344#endif
1345
1346 kobject_uevent(kobj, KOBJ_ADD);
1347 dev_hold(queue->dev);
1348
1349 return 0;
1350exit:
1351 kobject_put(kobj);
1352 return error;
1353}
1354#endif
1355
1356int
1357netdev_queue_update_kobjects(struct net_device *dev, int old_num, int new_num)
1358{
1359#ifdef CONFIG_SYSFS
1360 int i;
1361 int error = 0;
1362
1363 for (i = old_num; i < new_num; i++) {
1364 error = netdev_queue_add_kobject(dev, i);
1365 if (error) {
1366 new_num = old_num;
1367 break;
1368 }
1369 }
1370
1371 while (--i >= new_num) {
1372 struct netdev_queue *queue = dev->_tx + i;
1373
1374 if (!atomic_read(&dev_net(dev)->count))
1375 queue->kobj.uevent_suppress = 1;
1376#ifdef CONFIG_BQL
1377 sysfs_remove_group(&queue->kobj, &dql_group);
1378#endif
1379 kobject_put(&queue->kobj);
1380 }
1381
1382 return error;
1383#else
1384 return 0;
1385#endif
1386}
1387
1388static int register_queue_kobjects(struct net_device *dev)
1389{
1390 int error = 0, txq = 0, rxq = 0, real_rx = 0, real_tx = 0;
1391
1392#ifdef CONFIG_SYSFS
1393 dev->queues_kset = kset_create_and_add("queues",
1394 NULL, &dev->dev.kobj);
1395 if (!dev->queues_kset)
1396 return -ENOMEM;
1397 real_rx = dev->real_num_rx_queues;
1398#endif
1399 real_tx = dev->real_num_tx_queues;
1400
1401 error = net_rx_queue_update_kobjects(dev, 0, real_rx);
1402 if (error)
1403 goto error;
1404 rxq = real_rx;
1405
1406 error = netdev_queue_update_kobjects(dev, 0, real_tx);
1407 if (error)
1408 goto error;
1409 txq = real_tx;
1410
1411 return 0;
1412
1413error:
1414 netdev_queue_update_kobjects(dev, txq, 0);
1415 net_rx_queue_update_kobjects(dev, rxq, 0);
1416 return error;
1417}
1418
1419static void remove_queue_kobjects(struct net_device *dev)
1420{
1421 int real_rx = 0, real_tx = 0;
1422
1423#ifdef CONFIG_SYSFS
1424 real_rx = dev->real_num_rx_queues;
1425#endif
1426 real_tx = dev->real_num_tx_queues;
1427
1428 net_rx_queue_update_kobjects(dev, real_rx, 0);
1429 netdev_queue_update_kobjects(dev, real_tx, 0);
1430#ifdef CONFIG_SYSFS
1431 kset_unregister(dev->queues_kset);
1432#endif
1433}
1434
1435static bool net_current_may_mount(void)
1436{
1437 struct net *net = current->nsproxy->net_ns;
1438
1439 return ns_capable(net->user_ns, CAP_SYS_ADMIN);
1440}
1441
1442static void *net_grab_current_ns(void)
1443{
1444 struct net *ns = current->nsproxy->net_ns;
1445#ifdef CONFIG_NET_NS
1446 if (ns)
1447 atomic_inc(&ns->passive);
1448#endif
1449 return ns;
1450}
1451
1452static const void *net_initial_ns(void)
1453{
1454 return &init_net;
1455}
1456
1457static const void *net_netlink_ns(struct sock *sk)
1458{
1459 return sock_net(sk);
1460}
1461
1462struct kobj_ns_type_operations net_ns_type_operations = {
1463 .type = KOBJ_NS_TYPE_NET,
1464 .current_may_mount = net_current_may_mount,
1465 .grab_current_ns = net_grab_current_ns,
1466 .netlink_ns = net_netlink_ns,
1467 .initial_ns = net_initial_ns,
1468 .drop_ns = net_drop_ns,
1469};
1470EXPORT_SYMBOL_GPL(net_ns_type_operations);
1471
1472static int netdev_uevent(struct device *d, struct kobj_uevent_env *env)
1473{
1474 struct net_device *dev = to_net_dev(d);
1475 int retval;
1476
1477
1478 retval = add_uevent_var(env, "INTERFACE=%s", dev->name);
1479 if (retval)
1480 goto exit;
1481
1482
1483
1484
1485 retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex);
1486
1487exit:
1488 return retval;
1489}
1490
1491
1492
1493
1494
1495static void netdev_release(struct device *d)
1496{
1497 struct net_device *dev = to_net_dev(d);
1498
1499 BUG_ON(dev->reg_state != NETREG_RELEASED);
1500
1501 kfree(dev->ifalias);
1502 netdev_freemem(dev);
1503}
1504
1505static const void *net_namespace(struct device *d)
1506{
1507 struct net_device *dev = to_net_dev(d);
1508
1509 return dev_net(dev);
1510}
1511
1512static struct class net_class = {
1513 .name = "net",
1514 .dev_release = netdev_release,
1515 .dev_groups = net_class_groups,
1516 .dev_uevent = netdev_uevent,
1517 .ns_type = &net_ns_type_operations,
1518 .namespace = net_namespace,
1519};
1520
1521#ifdef CONFIG_OF_NET
1522static int of_dev_node_match(struct device *dev, const void *data)
1523{
1524 int ret = 0;
1525
1526 if (dev->parent)
1527 ret = dev->parent->of_node == data;
1528
1529 return ret == 0 ? dev->of_node == data : ret;
1530}
1531
1532
1533
1534
1535
1536
1537
1538
1539
1540
1541struct net_device *of_find_net_device_by_node(struct device_node *np)
1542{
1543 struct device *dev;
1544
1545 dev = class_find_device(&net_class, NULL, np, of_dev_node_match);
1546 if (!dev)
1547 return NULL;
1548
1549 return to_net_dev(dev);
1550}
1551EXPORT_SYMBOL(of_find_net_device_by_node);
1552#endif
1553
1554
1555
1556
1557void netdev_unregister_kobject(struct net_device *ndev)
1558{
1559 struct device *dev = &(ndev->dev);
1560
1561 if (!atomic_read(&dev_net(ndev)->count))
1562 dev_set_uevent_suppress(dev, 1);
1563
1564 kobject_get(&dev->kobj);
1565
1566 remove_queue_kobjects(ndev);
1567
1568 pm_runtime_set_memalloc_noio(dev, false);
1569
1570 device_del(dev);
1571}
1572
1573
1574int netdev_register_kobject(struct net_device *ndev)
1575{
1576 struct device *dev = &(ndev->dev);
1577 const struct attribute_group **groups = ndev->sysfs_groups;
1578 int error = 0;
1579
1580 device_initialize(dev);
1581 dev->class = &net_class;
1582 dev->platform_data = ndev;
1583 dev->groups = groups;
1584
1585 dev_set_name(dev, "%s", ndev->name);
1586
1587#ifdef CONFIG_SYSFS
1588
1589 if (*groups)
1590 groups++;
1591
1592 *groups++ = &netstat_group;
1593
1594#if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211)
1595 if (ndev->ieee80211_ptr)
1596 *groups++ = &wireless_group;
1597#if IS_ENABLED(CONFIG_WIRELESS_EXT)
1598 else if (ndev->wireless_handlers)
1599 *groups++ = &wireless_group;
1600#endif
1601#endif
1602#endif
1603
1604 error = device_add(dev);
1605 if (error)
1606 return error;
1607
1608 error = register_queue_kobjects(ndev);
1609 if (error) {
1610 device_del(dev);
1611 return error;
1612 }
1613
1614 pm_runtime_set_memalloc_noio(dev, true);
1615
1616 return error;
1617}
1618
1619int netdev_class_create_file_ns(struct class_attribute *class_attr,
1620 const void *ns)
1621{
1622 return class_create_file_ns(&net_class, class_attr, ns);
1623}
1624EXPORT_SYMBOL(netdev_class_create_file_ns);
1625
1626void netdev_class_remove_file_ns(struct class_attribute *class_attr,
1627 const void *ns)
1628{
1629 class_remove_file_ns(&net_class, class_attr, ns);
1630}
1631EXPORT_SYMBOL(netdev_class_remove_file_ns);
1632
1633int __init netdev_kobject_init(void)
1634{
1635 kobj_ns_type_register(&net_ns_type_operations);
1636 return class_register(&net_class);
1637}
1638
