Line data Source code
1 : // SPDX-License-Identifier: GPL-2.0-or-later
2 : /*
3 : * net-sysfs.c - network device class and attributes
4 : *
5 : * Copyright (c) 2003 Stephen Hemminger <shemminger@osdl.org>
6 : */
7 :
8 : #include <linux/capability.h>
9 : #include <linux/kernel.h>
10 : #include <linux/netdevice.h>
11 : #include <linux/if_arp.h>
12 : #include <linux/slab.h>
13 : #include <linux/sched/signal.h>
14 : #include <linux/sched/isolation.h>
15 : #include <linux/nsproxy.h>
16 : #include <net/sock.h>
17 : #include <net/net_namespace.h>
18 : #include <linux/rtnetlink.h>
19 : #include <linux/vmalloc.h>
20 : #include <linux/export.h>
21 : #include <linux/jiffies.h>
22 : #include <linux/pm_runtime.h>
23 : #include <linux/of.h>
24 : #include <linux/of_net.h>
25 : #include <linux/cpu.h>
26 :
27 : #include "net-sysfs.h"
28 :
29 : #ifdef CONFIG_SYSFS
30 : static const char fmt_hex[] = "%#x\n";
31 : static const char fmt_dec[] = "%d\n";
32 : static const char fmt_ulong[] = "%lu\n";
33 : static const char fmt_u64[] = "%llu\n";
34 :
35 6 : static inline int dev_isalive(const struct net_device *dev)
36 : {
37 6 : return dev->reg_state <= NETREG_REGISTERED;
38 : }
39 :
40 : /* use same locking rules as GIF* ioctl's */
41 4 : 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 4 : struct net_device *ndev = to_net_dev(dev);
46 4 : ssize_t ret = -EINVAL;
47 :
48 4 : read_lock(&dev_base_lock);
49 4 : if (dev_isalive(ndev))
50 4 : ret = (*format)(ndev, buf);
51 4 : read_unlock(&dev_base_lock);
52 :
53 4 : 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 *dev, char *buf) \
59 : { \
60 : return sprintf(buf, format_string, dev->field); \
61 : } \
62 : static ssize_t field##_show(struct device *dev, \
63 : struct device_attribute *attr, char *buf) \
64 : { \
65 : return netdev_show(dev, attr, buf, format_##field); \
66 : } \
67 :
68 : #define NETDEVICE_SHOW_RO(field, format_string) \
69 : NETDEVICE_SHOW(field, format_string); \
70 : static DEVICE_ATTR_RO(field)
71 :
72 : #define NETDEVICE_SHOW_RW(field, format_string) \
73 : NETDEVICE_SHOW(field, format_string); \
74 : static DEVICE_ATTR_RW(field)
75 :
76 : /* use same locking and permission rules as SIF* ioctl's */
77 0 : static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
78 : const char *buf, size_t len,
79 : int (*set)(struct net_device *, unsigned long))
80 : {
81 0 : struct net_device *netdev = to_net_dev(dev);
82 0 : struct net *net = dev_net(netdev);
83 0 : unsigned long new;
84 0 : int ret;
85 :
86 0 : if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
87 : return -EPERM;
88 :
89 0 : ret = kstrtoul(buf, 0, &new);
90 0 : if (ret)
91 0 : goto err;
92 :
93 0 : if (!rtnl_trylock())
94 0 : return restart_syscall();
95 :
96 0 : if (dev_isalive(netdev)) {
97 0 : ret = (*set)(netdev, new);
98 0 : if (ret == 0)
99 0 : ret = len;
100 : }
101 0 : rtnl_unlock();
102 0 : err:
103 0 : return ret;
104 : }
105 :
106 0 : NETDEVICE_SHOW_RO(dev_id, fmt_hex);
107 0 : NETDEVICE_SHOW_RO(dev_port, fmt_dec);
108 2 : NETDEVICE_SHOW_RO(addr_assign_type, fmt_dec);
109 0 : NETDEVICE_SHOW_RO(addr_len, fmt_dec);
110 2 : NETDEVICE_SHOW_RO(ifindex, fmt_dec);
111 4 : NETDEVICE_SHOW_RO(type, fmt_dec);
112 0 : NETDEVICE_SHOW_RO(link_mode, fmt_dec);
113 :
114 1 : static ssize_t iflink_show(struct device *dev, struct device_attribute *attr,
115 : char *buf)
116 : {
117 1 : struct net_device *ndev = to_net_dev(dev);
118 :
119 1 : return sprintf(buf, fmt_dec, dev_get_iflink(ndev));
120 : }
121 : static DEVICE_ATTR_RO(iflink);
122 :
123 0 : static ssize_t format_name_assign_type(const struct net_device *dev, char *buf)
124 : {
125 0 : return sprintf(buf, fmt_dec, dev->name_assign_type);
126 : }
127 :
128 2 : static ssize_t name_assign_type_show(struct device *dev,
129 : struct device_attribute *attr,
130 : char *buf)
131 : {
132 2 : struct net_device *ndev = to_net_dev(dev);
133 2 : ssize_t ret = -EINVAL;
134 :
135 2 : if (ndev->name_assign_type != NET_NAME_UNKNOWN)
136 0 : ret = netdev_show(dev, attr, buf, format_name_assign_type);
137 :
138 2 : return ret;
139 : }
140 : static DEVICE_ATTR_RO(name_assign_type);
141 :
142 : /* use same locking rules as GIFHWADDR ioctl's */
143 2 : static ssize_t address_show(struct device *dev, struct device_attribute *attr,
144 : char *buf)
145 : {
146 2 : struct net_device *ndev = to_net_dev(dev);
147 2 : ssize_t ret = -EINVAL;
148 :
149 2 : read_lock(&dev_base_lock);
150 2 : if (dev_isalive(ndev))
151 2 : ret = sysfs_format_mac(buf, ndev->dev_addr, ndev->addr_len);
152 2 : read_unlock(&dev_base_lock);
153 2 : return ret;
154 : }
155 : static DEVICE_ATTR_RO(address);
156 :
157 0 : static ssize_t broadcast_show(struct device *dev,
158 : struct device_attribute *attr, char *buf)
159 : {
160 0 : struct net_device *ndev = to_net_dev(dev);
161 :
162 0 : if (dev_isalive(ndev))
163 0 : return sysfs_format_mac(buf, ndev->broadcast, ndev->addr_len);
164 : return -EINVAL;
165 : }
166 : static DEVICE_ATTR_RO(broadcast);
167 :
168 0 : static int change_carrier(struct net_device *dev, unsigned long new_carrier)
169 : {
170 0 : if (!netif_running(dev))
171 : return -EINVAL;
172 0 : return dev_change_carrier(dev, (bool)new_carrier);
173 : }
174 :
175 0 : static ssize_t carrier_store(struct device *dev, struct device_attribute *attr,
176 : const char *buf, size_t len)
177 : {
178 0 : return netdev_store(dev, attr, buf, len, change_carrier);
179 : }
180 :
181 0 : static ssize_t carrier_show(struct device *dev,
182 : struct device_attribute *attr, char *buf)
183 : {
184 0 : struct net_device *netdev = to_net_dev(dev);
185 :
186 0 : if (netif_running(netdev))
187 0 : return sprintf(buf, fmt_dec, !!netif_carrier_ok(netdev));
188 :
189 : return -EINVAL;
190 : }
191 : static DEVICE_ATTR_RW(carrier);
192 :
193 0 : static ssize_t speed_show(struct device *dev,
194 : struct device_attribute *attr, char *buf)
195 : {
196 0 : struct net_device *netdev = to_net_dev(dev);
197 0 : int ret = -EINVAL;
198 :
199 0 : if (!rtnl_trylock())
200 0 : return restart_syscall();
201 :
202 0 : if (netif_running(netdev)) {
203 0 : struct ethtool_link_ksettings cmd;
204 :
205 0 : if (!__ethtool_get_link_ksettings(netdev, &cmd))
206 0 : ret = sprintf(buf, fmt_dec, cmd.base.speed);
207 : }
208 0 : rtnl_unlock();
209 0 : return ret;
210 : }
211 : static DEVICE_ATTR_RO(speed);
212 :
213 0 : static ssize_t duplex_show(struct device *dev,
214 : struct device_attribute *attr, char *buf)
215 : {
216 0 : struct net_device *netdev = to_net_dev(dev);
217 0 : int ret = -EINVAL;
218 :
219 0 : if (!rtnl_trylock())
220 0 : return restart_syscall();
221 :
222 0 : if (netif_running(netdev)) {
223 0 : struct ethtool_link_ksettings cmd;
224 :
225 0 : if (!__ethtool_get_link_ksettings(netdev, &cmd)) {
226 0 : const char *duplex;
227 :
228 0 : switch (cmd.base.duplex) {
229 : case DUPLEX_HALF:
230 : duplex = "half";
231 : break;
232 0 : case DUPLEX_FULL:
233 0 : duplex = "full";
234 0 : break;
235 0 : default:
236 0 : duplex = "unknown";
237 0 : break;
238 : }
239 0 : ret = sprintf(buf, "%s\n", duplex);
240 : }
241 : }
242 0 : rtnl_unlock();
243 0 : return ret;
244 : }
245 : static DEVICE_ATTR_RO(duplex);
246 :
247 0 : static ssize_t testing_show(struct device *dev,
248 : struct device_attribute *attr, char *buf)
249 : {
250 0 : struct net_device *netdev = to_net_dev(dev);
251 :
252 0 : if (netif_running(netdev))
253 0 : return sprintf(buf, fmt_dec, !!netif_testing(netdev));
254 :
255 : return -EINVAL;
256 : }
257 : static DEVICE_ATTR_RO(testing);
258 :
259 0 : static ssize_t dormant_show(struct device *dev,
260 : struct device_attribute *attr, char *buf)
261 : {
262 0 : struct net_device *netdev = to_net_dev(dev);
263 :
264 0 : if (netif_running(netdev))
265 0 : return sprintf(buf, fmt_dec, !!netif_dormant(netdev));
266 :
267 : return -EINVAL;
268 : }
269 : static DEVICE_ATTR_RO(dormant);
270 :
271 : static const char *const operstates[] = {
272 : "unknown",
273 : "notpresent", /* currently unused */
274 : "down",
275 : "lowerlayerdown",
276 : "testing",
277 : "dormant",
278 : "up"
279 : };
280 :
281 0 : static ssize_t operstate_show(struct device *dev,
282 : struct device_attribute *attr, char *buf)
283 : {
284 0 : const struct net_device *netdev = to_net_dev(dev);
285 0 : unsigned char operstate;
286 :
287 0 : read_lock(&dev_base_lock);
288 0 : operstate = netdev->operstate;
289 0 : if (!netif_running(netdev))
290 0 : operstate = IF_OPER_DOWN;
291 0 : read_unlock(&dev_base_lock);
292 :
293 0 : if (operstate >= ARRAY_SIZE(operstates))
294 : return -EINVAL; /* should not happen */
295 :
296 0 : return sprintf(buf, "%s\n", operstates[operstate]);
297 : }
298 : static DEVICE_ATTR_RO(operstate);
299 :
300 0 : static ssize_t carrier_changes_show(struct device *dev,
301 : struct device_attribute *attr,
302 : char *buf)
303 : {
304 0 : struct net_device *netdev = to_net_dev(dev);
305 :
306 0 : return sprintf(buf, fmt_dec,
307 0 : atomic_read(&netdev->carrier_up_count) +
308 0 : atomic_read(&netdev->carrier_down_count));
309 : }
310 : static DEVICE_ATTR_RO(carrier_changes);
311 :
312 0 : static ssize_t carrier_up_count_show(struct device *dev,
313 : struct device_attribute *attr,
314 : char *buf)
315 : {
316 0 : struct net_device *netdev = to_net_dev(dev);
317 :
318 0 : return sprintf(buf, fmt_dec, atomic_read(&netdev->carrier_up_count));
319 : }
320 : static DEVICE_ATTR_RO(carrier_up_count);
321 :
322 0 : static ssize_t carrier_down_count_show(struct device *dev,
323 : struct device_attribute *attr,
324 : char *buf)
325 : {
326 0 : struct net_device *netdev = to_net_dev(dev);
327 :
328 0 : return sprintf(buf, fmt_dec, atomic_read(&netdev->carrier_down_count));
329 : }
330 : static DEVICE_ATTR_RO(carrier_down_count);
331 :
332 : /* read-write attributes */
333 :
334 0 : static int change_mtu(struct net_device *dev, unsigned long new_mtu)
335 : {
336 0 : return dev_set_mtu(dev, (int)new_mtu);
337 : }
338 :
339 0 : static ssize_t mtu_store(struct device *dev, struct device_attribute *attr,
340 : const char *buf, size_t len)
341 : {
342 0 : return netdev_store(dev, attr, buf, len, change_mtu);
343 : }
344 0 : NETDEVICE_SHOW_RW(mtu, fmt_dec);
345 :
346 0 : static int change_flags(struct net_device *dev, unsigned long new_flags)
347 : {
348 0 : return dev_change_flags(dev, (unsigned int)new_flags, NULL);
349 : }
350 :
351 0 : static ssize_t flags_store(struct device *dev, struct device_attribute *attr,
352 : const char *buf, size_t len)
353 : {
354 0 : return netdev_store(dev, attr, buf, len, change_flags);
355 : }
356 0 : NETDEVICE_SHOW_RW(flags, fmt_hex);
357 :
358 0 : static ssize_t tx_queue_len_store(struct device *dev,
359 : struct device_attribute *attr,
360 : const char *buf, size_t len)
361 : {
362 0 : if (!capable(CAP_NET_ADMIN))
363 : return -EPERM;
364 :
365 0 : return netdev_store(dev, attr, buf, len, dev_change_tx_queue_len);
366 : }
367 0 : NETDEVICE_SHOW_RW(tx_queue_len, fmt_dec);
368 :
369 0 : static int change_gro_flush_timeout(struct net_device *dev, unsigned long val)
370 : {
371 0 : WRITE_ONCE(dev->gro_flush_timeout, val);
372 0 : return 0;
373 : }
374 :
375 0 : static ssize_t gro_flush_timeout_store(struct device *dev,
376 : struct device_attribute *attr,
377 : const char *buf, size_t len)
378 : {
379 0 : if (!capable(CAP_NET_ADMIN))
380 : return -EPERM;
381 :
382 0 : return netdev_store(dev, attr, buf, len, change_gro_flush_timeout);
383 : }
384 0 : NETDEVICE_SHOW_RW(gro_flush_timeout, fmt_ulong);
385 :
386 0 : static int change_napi_defer_hard_irqs(struct net_device *dev, unsigned long val)
387 : {
388 0 : WRITE_ONCE(dev->napi_defer_hard_irqs, val);
389 0 : return 0;
390 : }
391 :
392 0 : static ssize_t napi_defer_hard_irqs_store(struct device *dev,
393 : struct device_attribute *attr,
394 : const char *buf, size_t len)
395 : {
396 0 : if (!capable(CAP_NET_ADMIN))
397 : return -EPERM;
398 :
399 0 : return netdev_store(dev, attr, buf, len, change_napi_defer_hard_irqs);
400 : }
401 0 : NETDEVICE_SHOW_RW(napi_defer_hard_irqs, fmt_dec);
402 :
403 0 : static ssize_t ifalias_store(struct device *dev, struct device_attribute *attr,
404 : const char *buf, size_t len)
405 : {
406 0 : struct net_device *netdev = to_net_dev(dev);
407 0 : struct net *net = dev_net(netdev);
408 0 : size_t count = len;
409 0 : ssize_t ret = 0;
410 :
411 0 : if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
412 : return -EPERM;
413 :
414 : /* ignore trailing newline */
415 0 : if (len > 0 && buf[len - 1] == '\n')
416 0 : --count;
417 :
418 0 : if (!rtnl_trylock())
419 0 : return restart_syscall();
420 :
421 0 : if (dev_isalive(netdev)) {
422 0 : ret = dev_set_alias(netdev, buf, count);
423 0 : if (ret < 0)
424 0 : goto err;
425 0 : ret = len;
426 0 : netdev_state_change(netdev);
427 : }
428 0 : err:
429 0 : rtnl_unlock();
430 :
431 0 : return ret;
432 : }
433 :
434 0 : static ssize_t ifalias_show(struct device *dev,
435 : struct device_attribute *attr, char *buf)
436 : {
437 0 : const struct net_device *netdev = to_net_dev(dev);
438 0 : char tmp[IFALIASZ];
439 0 : ssize_t ret = 0;
440 :
441 0 : ret = dev_get_alias(netdev, tmp, sizeof(tmp));
442 0 : if (ret > 0)
443 0 : ret = sprintf(buf, "%s\n", tmp);
444 0 : return ret;
445 : }
446 : static DEVICE_ATTR_RW(ifalias);
447 :
448 0 : static int change_group(struct net_device *dev, unsigned long new_group)
449 : {
450 0 : dev_set_group(dev, (int)new_group);
451 0 : return 0;
452 : }
453 :
454 0 : static ssize_t group_store(struct device *dev, struct device_attribute *attr,
455 : const char *buf, size_t len)
456 : {
457 0 : return netdev_store(dev, attr, buf, len, change_group);
458 : }
459 0 : NETDEVICE_SHOW(group, fmt_dec);
460 : static DEVICE_ATTR(netdev_group, 0644, group_show, group_store);
461 :
462 0 : static int change_proto_down(struct net_device *dev, unsigned long proto_down)
463 : {
464 0 : return dev_change_proto_down(dev, (bool)proto_down);
465 : }
466 :
467 0 : static ssize_t proto_down_store(struct device *dev,
468 : struct device_attribute *attr,
469 : const char *buf, size_t len)
470 : {
471 0 : return netdev_store(dev, attr, buf, len, change_proto_down);
472 : }
473 0 : NETDEVICE_SHOW_RW(proto_down, fmt_dec);
474 :
475 0 : static ssize_t phys_port_id_show(struct device *dev,
476 : struct device_attribute *attr, char *buf)
477 : {
478 0 : struct net_device *netdev = to_net_dev(dev);
479 0 : ssize_t ret = -EINVAL;
480 :
481 0 : if (!rtnl_trylock())
482 0 : return restart_syscall();
483 :
484 0 : if (dev_isalive(netdev)) {
485 0 : struct netdev_phys_item_id ppid;
486 :
487 0 : ret = dev_get_phys_port_id(netdev, &ppid);
488 0 : if (!ret)
489 0 : ret = sprintf(buf, "%*phN\n", ppid.id_len, ppid.id);
490 : }
491 0 : rtnl_unlock();
492 :
493 0 : return ret;
494 : }
495 : static DEVICE_ATTR_RO(phys_port_id);
496 :
497 0 : static ssize_t phys_port_name_show(struct device *dev,
498 : struct device_attribute *attr, char *buf)
499 : {
500 0 : struct net_device *netdev = to_net_dev(dev);
501 0 : ssize_t ret = -EINVAL;
502 :
503 0 : if (!rtnl_trylock())
504 0 : return restart_syscall();
505 :
506 0 : if (dev_isalive(netdev)) {
507 0 : char name[IFNAMSIZ];
508 :
509 0 : ret = dev_get_phys_port_name(netdev, name, sizeof(name));
510 0 : if (!ret)
511 0 : ret = sprintf(buf, "%s\n", name);
512 : }
513 0 : rtnl_unlock();
514 :
515 0 : return ret;
516 : }
517 : static DEVICE_ATTR_RO(phys_port_name);
518 :
519 0 : static ssize_t phys_switch_id_show(struct device *dev,
520 : struct device_attribute *attr, char *buf)
521 : {
522 0 : struct net_device *netdev = to_net_dev(dev);
523 0 : ssize_t ret = -EINVAL;
524 :
525 0 : if (!rtnl_trylock())
526 0 : return restart_syscall();
527 :
528 0 : if (dev_isalive(netdev)) {
529 0 : struct netdev_phys_item_id ppid = { };
530 :
531 0 : ret = dev_get_port_parent_id(netdev, &ppid, false);
532 0 : if (!ret)
533 0 : ret = sprintf(buf, "%*phN\n", ppid.id_len, ppid.id);
534 : }
535 0 : rtnl_unlock();
536 :
537 0 : return ret;
538 : }
539 : static DEVICE_ATTR_RO(phys_switch_id);
540 :
541 0 : static ssize_t threaded_show(struct device *dev,
542 : struct device_attribute *attr, char *buf)
543 : {
544 0 : struct net_device *netdev = to_net_dev(dev);
545 0 : ssize_t ret = -EINVAL;
546 :
547 0 : if (!rtnl_trylock())
548 0 : return restart_syscall();
549 :
550 0 : if (dev_isalive(netdev))
551 0 : ret = sprintf(buf, fmt_dec, netdev->threaded);
552 :
553 0 : rtnl_unlock();
554 0 : return ret;
555 : }
556 :
557 0 : static int modify_napi_threaded(struct net_device *dev, unsigned long val)
558 : {
559 0 : int ret;
560 :
561 0 : if (list_empty(&dev->napi_list))
562 : return -EOPNOTSUPP;
563 :
564 0 : if (val != 0 && val != 1)
565 : return -EOPNOTSUPP;
566 :
567 0 : ret = dev_set_threaded(dev, val);
568 :
569 0 : return ret;
570 : }
571 :
572 0 : static ssize_t threaded_store(struct device *dev,
573 : struct device_attribute *attr,
574 : const char *buf, size_t len)
575 : {
576 0 : return netdev_store(dev, attr, buf, len, modify_napi_threaded);
577 : }
578 : static DEVICE_ATTR_RW(threaded);
579 :
580 : static struct attribute *net_class_attrs[] __ro_after_init = {
581 : &dev_attr_netdev_group.attr,
582 : &dev_attr_type.attr,
583 : &dev_attr_dev_id.attr,
584 : &dev_attr_dev_port.attr,
585 : &dev_attr_iflink.attr,
586 : &dev_attr_ifindex.attr,
587 : &dev_attr_name_assign_type.attr,
588 : &dev_attr_addr_assign_type.attr,
589 : &dev_attr_addr_len.attr,
590 : &dev_attr_link_mode.attr,
591 : &dev_attr_address.attr,
592 : &dev_attr_broadcast.attr,
593 : &dev_attr_speed.attr,
594 : &dev_attr_duplex.attr,
595 : &dev_attr_dormant.attr,
596 : &dev_attr_testing.attr,
597 : &dev_attr_operstate.attr,
598 : &dev_attr_carrier_changes.attr,
599 : &dev_attr_ifalias.attr,
600 : &dev_attr_carrier.attr,
601 : &dev_attr_mtu.attr,
602 : &dev_attr_flags.attr,
603 : &dev_attr_tx_queue_len.attr,
604 : &dev_attr_gro_flush_timeout.attr,
605 : &dev_attr_napi_defer_hard_irqs.attr,
606 : &dev_attr_phys_port_id.attr,
607 : &dev_attr_phys_port_name.attr,
608 : &dev_attr_phys_switch_id.attr,
609 : &dev_attr_proto_down.attr,
610 : &dev_attr_carrier_up_count.attr,
611 : &dev_attr_carrier_down_count.attr,
612 : &dev_attr_threaded.attr,
613 : NULL,
614 : };
615 : ATTRIBUTE_GROUPS(net_class);
616 :
617 : /* Show a given an attribute in the statistics group */
618 0 : static ssize_t netstat_show(const struct device *d,
619 : struct device_attribute *attr, char *buf,
620 : unsigned long offset)
621 : {
622 0 : struct net_device *dev = to_net_dev(d);
623 0 : ssize_t ret = -EINVAL;
624 :
625 0 : WARN_ON(offset > sizeof(struct rtnl_link_stats64) ||
626 : offset % sizeof(u64) != 0);
627 :
628 0 : read_lock(&dev_base_lock);
629 0 : if (dev_isalive(dev)) {
630 0 : struct rtnl_link_stats64 temp;
631 0 : const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);
632 :
633 0 : ret = sprintf(buf, fmt_u64, *(u64 *)(((u8 *)stats) + offset));
634 : }
635 0 : read_unlock(&dev_base_lock);
636 0 : return ret;
637 : }
638 :
639 : /* generate a read-only statistics attribute */
640 : #define NETSTAT_ENTRY(name) \
641 : static ssize_t name##_show(struct device *d, \
642 : struct device_attribute *attr, char *buf) \
643 : { \
644 : return netstat_show(d, attr, buf, \
645 : offsetof(struct rtnl_link_stats64, name)); \
646 : } \
647 : static DEVICE_ATTR_RO(name)
648 :
649 0 : NETSTAT_ENTRY(rx_packets);
650 0 : NETSTAT_ENTRY(tx_packets);
651 0 : NETSTAT_ENTRY(rx_bytes);
652 0 : NETSTAT_ENTRY(tx_bytes);
653 0 : NETSTAT_ENTRY(rx_errors);
654 0 : NETSTAT_ENTRY(tx_errors);
655 0 : NETSTAT_ENTRY(rx_dropped);
656 0 : NETSTAT_ENTRY(tx_dropped);
657 0 : NETSTAT_ENTRY(multicast);
658 0 : NETSTAT_ENTRY(collisions);
659 0 : NETSTAT_ENTRY(rx_length_errors);
660 0 : NETSTAT_ENTRY(rx_over_errors);
661 0 : NETSTAT_ENTRY(rx_crc_errors);
662 0 : NETSTAT_ENTRY(rx_frame_errors);
663 0 : NETSTAT_ENTRY(rx_fifo_errors);
664 0 : NETSTAT_ENTRY(rx_missed_errors);
665 0 : NETSTAT_ENTRY(tx_aborted_errors);
666 0 : NETSTAT_ENTRY(tx_carrier_errors);
667 0 : NETSTAT_ENTRY(tx_fifo_errors);
668 0 : NETSTAT_ENTRY(tx_heartbeat_errors);
669 0 : NETSTAT_ENTRY(tx_window_errors);
670 0 : NETSTAT_ENTRY(rx_compressed);
671 0 : NETSTAT_ENTRY(tx_compressed);
672 0 : NETSTAT_ENTRY(rx_nohandler);
673 :
674 : static struct attribute *netstat_attrs[] __ro_after_init = {
675 : &dev_attr_rx_packets.attr,
676 : &dev_attr_tx_packets.attr,
677 : &dev_attr_rx_bytes.attr,
678 : &dev_attr_tx_bytes.attr,
679 : &dev_attr_rx_errors.attr,
680 : &dev_attr_tx_errors.attr,
681 : &dev_attr_rx_dropped.attr,
682 : &dev_attr_tx_dropped.attr,
683 : &dev_attr_multicast.attr,
684 : &dev_attr_collisions.attr,
685 : &dev_attr_rx_length_errors.attr,
686 : &dev_attr_rx_over_errors.attr,
687 : &dev_attr_rx_crc_errors.attr,
688 : &dev_attr_rx_frame_errors.attr,
689 : &dev_attr_rx_fifo_errors.attr,
690 : &dev_attr_rx_missed_errors.attr,
691 : &dev_attr_tx_aborted_errors.attr,
692 : &dev_attr_tx_carrier_errors.attr,
693 : &dev_attr_tx_fifo_errors.attr,
694 : &dev_attr_tx_heartbeat_errors.attr,
695 : &dev_attr_tx_window_errors.attr,
696 : &dev_attr_rx_compressed.attr,
697 : &dev_attr_tx_compressed.attr,
698 : &dev_attr_rx_nohandler.attr,
699 : NULL
700 : };
701 :
702 : static const struct attribute_group netstat_group = {
703 : .name = "statistics",
704 : .attrs = netstat_attrs,
705 : };
706 :
707 : #if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211)
708 : static struct attribute *wireless_attrs[] = {
709 : NULL
710 : };
711 :
712 : static const struct attribute_group wireless_group = {
713 : .name = "wireless",
714 : .attrs = wireless_attrs,
715 : };
716 : #endif
717 :
718 : #else /* CONFIG_SYSFS */
719 : #define net_class_groups NULL
720 : #endif /* CONFIG_SYSFS */
721 :
722 : #ifdef CONFIG_SYSFS
723 : #define to_rx_queue_attr(_attr) \
724 : container_of(_attr, struct rx_queue_attribute, attr)
725 :
726 : #define to_rx_queue(obj) container_of(obj, struct netdev_rx_queue, kobj)
727 :
728 0 : static ssize_t rx_queue_attr_show(struct kobject *kobj, struct attribute *attr,
729 : char *buf)
730 : {
731 0 : const struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
732 0 : struct netdev_rx_queue *queue = to_rx_queue(kobj);
733 :
734 0 : if (!attribute->show)
735 : return -EIO;
736 :
737 0 : return attribute->show(queue, buf);
738 : }
739 :
740 0 : static ssize_t rx_queue_attr_store(struct kobject *kobj, struct attribute *attr,
741 : const char *buf, size_t count)
742 : {
743 0 : const struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
744 0 : struct netdev_rx_queue *queue = to_rx_queue(kobj);
745 :
746 0 : if (!attribute->store)
747 : return -EIO;
748 :
749 0 : return attribute->store(queue, buf, count);
750 : }
751 :
752 : static const struct sysfs_ops rx_queue_sysfs_ops = {
753 : .show = rx_queue_attr_show,
754 : .store = rx_queue_attr_store,
755 : };
756 :
757 : #ifdef CONFIG_RPS
758 0 : static ssize_t show_rps_map(struct netdev_rx_queue *queue, char *buf)
759 : {
760 0 : struct rps_map *map;
761 0 : cpumask_var_t mask;
762 0 : int i, len;
763 :
764 0 : if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
765 : return -ENOMEM;
766 :
767 0 : rcu_read_lock();
768 0 : map = rcu_dereference(queue->rps_map);
769 0 : if (map)
770 0 : for (i = 0; i < map->len; i++)
771 0 : cpumask_set_cpu(map->cpus[i], mask);
772 :
773 0 : len = snprintf(buf, PAGE_SIZE, "%*pb\n", cpumask_pr_args(mask));
774 0 : rcu_read_unlock();
775 0 : free_cpumask_var(mask);
776 :
777 0 : return len < PAGE_SIZE ? len : -EINVAL;
778 : }
779 :
780 0 : static ssize_t store_rps_map(struct netdev_rx_queue *queue,
781 : const char *buf, size_t len)
782 : {
783 0 : struct rps_map *old_map, *map;
784 0 : cpumask_var_t mask;
785 0 : int err, cpu, i, hk_flags;
786 0 : static DEFINE_MUTEX(rps_map_mutex);
787 :
788 0 : if (!capable(CAP_NET_ADMIN))
789 : return -EPERM;
790 :
791 0 : if (!alloc_cpumask_var(&mask, GFP_KERNEL))
792 : return -ENOMEM;
793 :
794 0 : err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
795 0 : if (err) {
796 0 : free_cpumask_var(mask);
797 : return err;
798 : }
799 :
800 0 : if (!cpumask_empty(mask)) {
801 0 : hk_flags = HK_FLAG_DOMAIN | HK_FLAG_WQ;
802 0 : cpumask_and(mask, mask, housekeeping_cpumask(hk_flags));
803 0 : if (cpumask_empty(mask)) {
804 0 : free_cpumask_var(mask);
805 : return -EINVAL;
806 : }
807 : }
808 :
809 0 : map = kzalloc(max_t(unsigned int,
810 : RPS_MAP_SIZE(cpumask_weight(mask)), L1_CACHE_BYTES),
811 : GFP_KERNEL);
812 0 : if (!map) {
813 0 : free_cpumask_var(mask);
814 : return -ENOMEM;
815 : }
816 :
817 : i = 0;
818 0 : for_each_cpu_and(cpu, mask, cpu_online_mask)
819 0 : map->cpus[i++] = cpu;
820 :
821 0 : if (i) {
822 0 : map->len = i;
823 : } else {
824 0 : kfree(map);
825 0 : map = NULL;
826 : }
827 :
828 0 : mutex_lock(&rps_map_mutex);
829 0 : old_map = rcu_dereference_protected(queue->rps_map,
830 : mutex_is_locked(&rps_map_mutex));
831 0 : rcu_assign_pointer(queue->rps_map, map);
832 :
833 0 : if (map)
834 0 : static_branch_inc(&rps_needed);
835 0 : if (old_map)
836 0 : static_branch_dec(&rps_needed);
837 :
838 0 : mutex_unlock(&rps_map_mutex);
839 :
840 0 : if (old_map)
841 0 : kfree_rcu(old_map, rcu);
842 :
843 0 : free_cpumask_var(mask);
844 0 : return len;
845 : }
846 :
847 0 : static ssize_t show_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
848 : char *buf)
849 : {
850 0 : struct rps_dev_flow_table *flow_table;
851 0 : unsigned long val = 0;
852 :
853 0 : rcu_read_lock();
854 0 : flow_table = rcu_dereference(queue->rps_flow_table);
855 0 : if (flow_table)
856 0 : val = (unsigned long)flow_table->mask + 1;
857 0 : rcu_read_unlock();
858 :
859 0 : return sprintf(buf, "%lu\n", val);
860 : }
861 :
862 0 : static void rps_dev_flow_table_release(struct rcu_head *rcu)
863 : {
864 0 : struct rps_dev_flow_table *table = container_of(rcu,
865 : struct rps_dev_flow_table, rcu);
866 0 : vfree(table);
867 0 : }
868 :
869 0 : static ssize_t store_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
870 : const char *buf, size_t len)
871 : {
872 0 : unsigned long mask, count;
873 0 : struct rps_dev_flow_table *table, *old_table;
874 0 : static DEFINE_SPINLOCK(rps_dev_flow_lock);
875 0 : int rc;
876 :
877 0 : if (!capable(CAP_NET_ADMIN))
878 : return -EPERM;
879 :
880 0 : rc = kstrtoul(buf, 0, &count);
881 0 : if (rc < 0)
882 0 : return rc;
883 :
884 0 : if (count) {
885 0 : mask = count - 1;
886 : /* mask = roundup_pow_of_two(count) - 1;
887 : * without overflows...
888 : */
889 0 : while ((mask | (mask >> 1)) != mask)
890 : mask |= (mask >> 1);
891 : /* On 64 bit arches, must check mask fits in table->mask (u32),
892 : * and on 32bit arches, must check
893 : * RPS_DEV_FLOW_TABLE_SIZE(mask + 1) doesn't overflow.
894 : */
895 : #if BITS_PER_LONG > 32
896 0 : if (mask > (unsigned long)(u32)mask)
897 : return -EINVAL;
898 : #else
899 : if (mask > (ULONG_MAX - RPS_DEV_FLOW_TABLE_SIZE(1))
900 : / sizeof(struct rps_dev_flow)) {
901 : /* Enforce a limit to prevent overflow */
902 : return -EINVAL;
903 : }
904 : #endif
905 0 : table = vmalloc(RPS_DEV_FLOW_TABLE_SIZE(mask + 1));
906 0 : if (!table)
907 : return -ENOMEM;
908 :
909 0 : table->mask = mask;
910 0 : for (count = 0; count <= mask; count++)
911 0 : table->flows[count].cpu = RPS_NO_CPU;
912 : } else {
913 : table = NULL;
914 : }
915 :
916 0 : spin_lock(&rps_dev_flow_lock);
917 0 : old_table = rcu_dereference_protected(queue->rps_flow_table,
918 : lockdep_is_held(&rps_dev_flow_lock));
919 0 : rcu_assign_pointer(queue->rps_flow_table, table);
920 0 : spin_unlock(&rps_dev_flow_lock);
921 :
922 0 : if (old_table)
923 0 : call_rcu(&old_table->rcu, rps_dev_flow_table_release);
924 :
925 0 : return len;
926 : }
927 :
928 : static struct rx_queue_attribute rps_cpus_attribute __ro_after_init
929 : = __ATTR(rps_cpus, 0644, show_rps_map, store_rps_map);
930 :
931 : static struct rx_queue_attribute rps_dev_flow_table_cnt_attribute __ro_after_init
932 : = __ATTR(rps_flow_cnt, 0644,
933 : show_rps_dev_flow_table_cnt, store_rps_dev_flow_table_cnt);
934 : #endif /* CONFIG_RPS */
935 :
936 : static struct attribute *rx_queue_default_attrs[] __ro_after_init = {
937 : #ifdef CONFIG_RPS
938 : &rps_cpus_attribute.attr,
939 : &rps_dev_flow_table_cnt_attribute.attr,
940 : #endif
941 : NULL
942 : };
943 : ATTRIBUTE_GROUPS(rx_queue_default);
944 :
945 0 : static void rx_queue_release(struct kobject *kobj)
946 : {
947 0 : struct netdev_rx_queue *queue = to_rx_queue(kobj);
948 : #ifdef CONFIG_RPS
949 0 : struct rps_map *map;
950 0 : struct rps_dev_flow_table *flow_table;
951 :
952 0 : map = rcu_dereference_protected(queue->rps_map, 1);
953 0 : if (map) {
954 0 : RCU_INIT_POINTER(queue->rps_map, NULL);
955 0 : kfree_rcu(map, rcu);
956 : }
957 :
958 0 : flow_table = rcu_dereference_protected(queue->rps_flow_table, 1);
959 0 : if (flow_table) {
960 0 : RCU_INIT_POINTER(queue->rps_flow_table, NULL);
961 0 : call_rcu(&flow_table->rcu, rps_dev_flow_table_release);
962 : }
963 : #endif
964 :
965 0 : memset(kobj, 0, sizeof(*kobj));
966 0 : dev_put(queue->dev);
967 0 : }
968 :
969 7 : static const void *rx_queue_namespace(struct kobject *kobj)
970 : {
971 7 : struct netdev_rx_queue *queue = to_rx_queue(kobj);
972 7 : struct device *dev = &queue->dev->dev;
973 7 : const void *ns = NULL;
974 :
975 7 : if (dev->class && dev->class->ns_type)
976 7 : ns = dev->class->namespace(dev);
977 :
978 7 : return ns;
979 : }
980 :
981 5 : static void rx_queue_get_ownership(struct kobject *kobj,
982 : kuid_t *uid, kgid_t *gid)
983 : {
984 5 : const struct net *net = rx_queue_namespace(kobj);
985 :
986 5 : net_ns_get_ownership(net, uid, gid);
987 5 : }
988 :
989 : static struct kobj_type rx_queue_ktype __ro_after_init = {
990 : .sysfs_ops = &rx_queue_sysfs_ops,
991 : .release = rx_queue_release,
992 : .default_groups = rx_queue_default_groups,
993 : .namespace = rx_queue_namespace,
994 : .get_ownership = rx_queue_get_ownership,
995 : };
996 :
997 2 : static int rx_queue_add_kobject(struct net_device *dev, int index)
998 : {
999 2 : struct netdev_rx_queue *queue = dev->_rx + index;
1000 2 : struct kobject *kobj = &queue->kobj;
1001 2 : int error = 0;
1002 :
1003 : /* Kobject_put later will trigger rx_queue_release call which
1004 : * decreases dev refcount: Take that reference here
1005 : */
1006 2 : dev_hold(queue->dev);
1007 :
1008 2 : kobj->kset = dev->queues_kset;
1009 2 : error = kobject_init_and_add(kobj, &rx_queue_ktype, NULL,
1010 : "rx-%u", index);
1011 2 : if (error)
1012 0 : goto err;
1013 :
1014 2 : if (dev->sysfs_rx_queue_group) {
1015 1 : error = sysfs_create_group(kobj, dev->sysfs_rx_queue_group);
1016 1 : if (error)
1017 0 : goto err;
1018 : }
1019 :
1020 2 : kobject_uevent(kobj, KOBJ_ADD);
1021 :
1022 2 : return error;
1023 :
1024 0 : err:
1025 0 : kobject_put(kobj);
1026 0 : return error;
1027 : }
1028 :
1029 : static int rx_queue_change_owner(struct net_device *dev, int index, kuid_t kuid,
1030 : kgid_t kgid)
1031 : {
1032 : struct netdev_rx_queue *queue = dev->_rx + index;
1033 : struct kobject *kobj = &queue->kobj;
1034 : int error;
1035 :
1036 : error = sysfs_change_owner(kobj, kuid, kgid);
1037 : if (error)
1038 : return error;
1039 :
1040 : if (dev->sysfs_rx_queue_group)
1041 : error = sysfs_group_change_owner(
1042 : kobj, dev->sysfs_rx_queue_group, kuid, kgid);
1043 :
1044 : return error;
1045 : }
1046 : #endif /* CONFIG_SYSFS */
1047 :
1048 : int
1049 2 : net_rx_queue_update_kobjects(struct net_device *dev, int old_num, int new_num)
1050 : {
1051 : #ifdef CONFIG_SYSFS
1052 2 : int i;
1053 2 : int error = 0;
1054 :
1055 : #ifndef CONFIG_RPS
1056 : if (!dev->sysfs_rx_queue_group)
1057 : return 0;
1058 : #endif
1059 4 : for (i = old_num; i < new_num; i++) {
1060 2 : error = rx_queue_add_kobject(dev, i);
1061 2 : if (error) {
1062 2 : new_num = old_num;
1063 : break;
1064 : }
1065 : }
1066 :
1067 2 : while (--i >= new_num) {
1068 0 : struct kobject *kobj = &dev->_rx[i].kobj;
1069 :
1070 0 : if (!refcount_read(&dev_net(dev)->ns.count))
1071 0 : kobj->uevent_suppress = 1;
1072 0 : if (dev->sysfs_rx_queue_group)
1073 0 : sysfs_remove_group(kobj, dev->sysfs_rx_queue_group);
1074 0 : kobject_put(kobj);
1075 : }
1076 :
1077 2 : return error;
1078 : #else
1079 : return 0;
1080 : #endif
1081 : }
1082 :
1083 : static int net_rx_queue_change_owner(struct net_device *dev, int num,
1084 : kuid_t kuid, kgid_t kgid)
1085 : {
1086 : #ifdef CONFIG_SYSFS
1087 : int error = 0;
1088 : int i;
1089 :
1090 : #ifndef CONFIG_RPS
1091 : if (!dev->sysfs_rx_queue_group)
1092 : return 0;
1093 : #endif
1094 : for (i = 0; i < num; i++) {
1095 : error = rx_queue_change_owner(dev, i, kuid, kgid);
1096 : if (error)
1097 : break;
1098 : }
1099 :
1100 : return error;
1101 : #else
1102 : return 0;
1103 : #endif
1104 : }
1105 :
1106 : #ifdef CONFIG_SYSFS
1107 : /*
1108 : * netdev_queue sysfs structures and functions.
1109 : */
1110 : struct netdev_queue_attribute {
1111 : struct attribute attr;
1112 : ssize_t (*show)(struct netdev_queue *queue, char *buf);
1113 : ssize_t (*store)(struct netdev_queue *queue,
1114 : const char *buf, size_t len);
1115 : };
1116 : #define to_netdev_queue_attr(_attr) \
1117 : container_of(_attr, struct netdev_queue_attribute, attr)
1118 :
1119 : #define to_netdev_queue(obj) container_of(obj, struct netdev_queue, kobj)
1120 :
1121 0 : static ssize_t netdev_queue_attr_show(struct kobject *kobj,
1122 : struct attribute *attr, char *buf)
1123 : {
1124 0 : const struct netdev_queue_attribute *attribute
1125 0 : = to_netdev_queue_attr(attr);
1126 0 : struct netdev_queue *queue = to_netdev_queue(kobj);
1127 :
1128 0 : if (!attribute->show)
1129 : return -EIO;
1130 :
1131 0 : return attribute->show(queue, buf);
1132 : }
1133 :
1134 0 : static ssize_t netdev_queue_attr_store(struct kobject *kobj,
1135 : struct attribute *attr,
1136 : const char *buf, size_t count)
1137 : {
1138 0 : const struct netdev_queue_attribute *attribute
1139 0 : = to_netdev_queue_attr(attr);
1140 0 : struct netdev_queue *queue = to_netdev_queue(kobj);
1141 :
1142 0 : if (!attribute->store)
1143 : return -EIO;
1144 :
1145 0 : return attribute->store(queue, buf, count);
1146 : }
1147 :
1148 : static const struct sysfs_ops netdev_queue_sysfs_ops = {
1149 : .show = netdev_queue_attr_show,
1150 : .store = netdev_queue_attr_store,
1151 : };
1152 :
1153 0 : static ssize_t tx_timeout_show(struct netdev_queue *queue, char *buf)
1154 : {
1155 0 : unsigned long trans_timeout;
1156 :
1157 0 : spin_lock_irq(&queue->_xmit_lock);
1158 0 : trans_timeout = queue->trans_timeout;
1159 0 : spin_unlock_irq(&queue->_xmit_lock);
1160 :
1161 0 : return sprintf(buf, fmt_ulong, trans_timeout);
1162 : }
1163 :
1164 0 : static unsigned int get_netdev_queue_index(struct netdev_queue *queue)
1165 : {
1166 0 : struct net_device *dev = queue->dev;
1167 0 : unsigned int i;
1168 :
1169 0 : i = queue - dev->_tx;
1170 0 : BUG_ON(i >= dev->num_tx_queues);
1171 :
1172 0 : return i;
1173 : }
1174 :
1175 0 : static ssize_t traffic_class_show(struct netdev_queue *queue,
1176 : char *buf)
1177 : {
1178 0 : struct net_device *dev = queue->dev;
1179 0 : int num_tc, tc;
1180 0 : int index;
1181 :
1182 0 : if (!netif_is_multiqueue(dev))
1183 : return -ENOENT;
1184 :
1185 0 : if (!rtnl_trylock())
1186 0 : return restart_syscall();
1187 :
1188 0 : index = get_netdev_queue_index(queue);
1189 :
1190 : /* If queue belongs to subordinate dev use its TC mapping */
1191 0 : dev = netdev_get_tx_queue(dev, index)->sb_dev ? : dev;
1192 :
1193 0 : num_tc = dev->num_tc;
1194 0 : tc = netdev_txq_to_tc(dev, index);
1195 :
1196 0 : rtnl_unlock();
1197 :
1198 0 : if (tc < 0)
1199 : return -EINVAL;
1200 :
1201 : /* We can report the traffic class one of two ways:
1202 : * Subordinate device traffic classes are reported with the traffic
1203 : * class first, and then the subordinate class so for example TC0 on
1204 : * subordinate device 2 will be reported as "0-2". If the queue
1205 : * belongs to the root device it will be reported with just the
1206 : * traffic class, so just "0" for TC 0 for example.
1207 : */
1208 0 : return num_tc < 0 ? sprintf(buf, "%d%d\n", tc, num_tc) :
1209 0 : sprintf(buf, "%d\n", tc);
1210 : }
1211 :
1212 : #ifdef CONFIG_XPS
1213 0 : static ssize_t tx_maxrate_show(struct netdev_queue *queue,
1214 : char *buf)
1215 : {
1216 0 : return sprintf(buf, "%lu\n", queue->tx_maxrate);
1217 : }
1218 :
1219 0 : static ssize_t tx_maxrate_store(struct netdev_queue *queue,
1220 : const char *buf, size_t len)
1221 : {
1222 0 : struct net_device *dev = queue->dev;
1223 0 : int err, index = get_netdev_queue_index(queue);
1224 0 : u32 rate = 0;
1225 :
1226 0 : if (!capable(CAP_NET_ADMIN))
1227 : return -EPERM;
1228 :
1229 0 : err = kstrtou32(buf, 10, &rate);
1230 0 : if (err < 0)
1231 0 : return err;
1232 :
1233 0 : if (!rtnl_trylock())
1234 0 : return restart_syscall();
1235 :
1236 0 : err = -EOPNOTSUPP;
1237 0 : if (dev->netdev_ops->ndo_set_tx_maxrate)
1238 0 : err = dev->netdev_ops->ndo_set_tx_maxrate(dev, index, rate);
1239 :
1240 0 : rtnl_unlock();
1241 0 : if (!err) {
1242 0 : queue->tx_maxrate = rate;
1243 0 : return len;
1244 : }
1245 0 : return err;
1246 : }
1247 :
1248 : static struct netdev_queue_attribute queue_tx_maxrate __ro_after_init
1249 : = __ATTR_RW(tx_maxrate);
1250 : #endif
1251 :
1252 : static struct netdev_queue_attribute queue_trans_timeout __ro_after_init
1253 : = __ATTR_RO(tx_timeout);
1254 :
1255 : static struct netdev_queue_attribute queue_traffic_class __ro_after_init
1256 : = __ATTR_RO(traffic_class);
1257 :
1258 : #ifdef CONFIG_BQL
1259 : /*
1260 : * Byte queue limits sysfs structures and functions.
1261 : */
1262 0 : static ssize_t bql_show(char *buf, unsigned int value)
1263 : {
1264 0 : return sprintf(buf, "%u\n", value);
1265 : }
1266 :
1267 0 : static ssize_t bql_set(const char *buf, const size_t count,
1268 : unsigned int *pvalue)
1269 : {
1270 0 : unsigned int value;
1271 0 : int err;
1272 :
1273 0 : if (!strcmp(buf, "max") || !strcmp(buf, "max\n")) {
1274 0 : value = DQL_MAX_LIMIT;
1275 : } else {
1276 0 : err = kstrtouint(buf, 10, &value);
1277 0 : if (err < 0)
1278 0 : return err;
1279 0 : if (value > DQL_MAX_LIMIT)
1280 : return -EINVAL;
1281 : }
1282 :
1283 0 : *pvalue = value;
1284 :
1285 0 : return count;
1286 : }
1287 :
1288 0 : static ssize_t bql_show_hold_time(struct netdev_queue *queue,
1289 : char *buf)
1290 : {
1291 0 : struct dql *dql = &queue->dql;
1292 :
1293 0 : return sprintf(buf, "%u\n", jiffies_to_msecs(dql->slack_hold_time));
1294 : }
1295 :
1296 0 : static ssize_t bql_set_hold_time(struct netdev_queue *queue,
1297 : const char *buf, size_t len)
1298 : {
1299 0 : struct dql *dql = &queue->dql;
1300 0 : unsigned int value;
1301 0 : int err;
1302 :
1303 0 : err = kstrtouint(buf, 10, &value);
1304 0 : if (err < 0)
1305 0 : return err;
1306 :
1307 0 : dql->slack_hold_time = msecs_to_jiffies(value);
1308 :
1309 0 : return len;
1310 : }
1311 :
1312 : static struct netdev_queue_attribute bql_hold_time_attribute __ro_after_init
1313 : = __ATTR(hold_time, 0644,
1314 : bql_show_hold_time, bql_set_hold_time);
1315 :
1316 0 : static ssize_t bql_show_inflight(struct netdev_queue *queue,
1317 : char *buf)
1318 : {
1319 0 : struct dql *dql = &queue->dql;
1320 :
1321 0 : return sprintf(buf, "%u\n", dql->num_queued - dql->num_completed);
1322 : }
1323 :
1324 : static struct netdev_queue_attribute bql_inflight_attribute __ro_after_init =
1325 : __ATTR(inflight, 0444, bql_show_inflight, NULL);
1326 :
1327 : #define BQL_ATTR(NAME, FIELD) \
1328 : static ssize_t bql_show_ ## NAME(struct netdev_queue *queue, \
1329 : char *buf) \
1330 : { \
1331 : return bql_show(buf, queue->dql.FIELD); \
1332 : } \
1333 : \
1334 : static ssize_t bql_set_ ## NAME(struct netdev_queue *queue, \
1335 : const char *buf, size_t len) \
1336 : { \
1337 : return bql_set(buf, len, &queue->dql.FIELD); \
1338 : } \
1339 : \
1340 : static struct netdev_queue_attribute bql_ ## NAME ## _attribute __ro_after_init \
1341 : = __ATTR(NAME, 0644, \
1342 : bql_show_ ## NAME, bql_set_ ## NAME)
1343 :
1344 0 : BQL_ATTR(limit, limit);
1345 0 : BQL_ATTR(limit_max, max_limit);
1346 0 : BQL_ATTR(limit_min, min_limit);
1347 :
1348 : static struct attribute *dql_attrs[] __ro_after_init = {
1349 : &bql_limit_attribute.attr,
1350 : &bql_limit_max_attribute.attr,
1351 : &bql_limit_min_attribute.attr,
1352 : &bql_hold_time_attribute.attr,
1353 : &bql_inflight_attribute.attr,
1354 : NULL
1355 : };
1356 :
1357 : static const struct attribute_group dql_group = {
1358 : .name = "byte_queue_limits",
1359 : .attrs = dql_attrs,
1360 : };
1361 : #endif /* CONFIG_BQL */
1362 :
1363 : #ifdef CONFIG_XPS
1364 0 : static ssize_t xps_cpus_show(struct netdev_queue *queue,
1365 : char *buf)
1366 : {
1367 0 : int cpu, len, ret, num_tc = 1, tc = 0;
1368 0 : struct net_device *dev = queue->dev;
1369 0 : struct xps_dev_maps *dev_maps;
1370 0 : cpumask_var_t mask;
1371 0 : unsigned long index;
1372 :
1373 0 : if (!netif_is_multiqueue(dev))
1374 : return -ENOENT;
1375 :
1376 0 : index = get_netdev_queue_index(queue);
1377 :
1378 0 : if (!rtnl_trylock())
1379 0 : return restart_syscall();
1380 :
1381 0 : if (dev->num_tc) {
1382 : /* Do not allow XPS on subordinate device directly */
1383 0 : num_tc = dev->num_tc;
1384 0 : if (num_tc < 0) {
1385 0 : ret = -EINVAL;
1386 0 : goto err_rtnl_unlock;
1387 : }
1388 :
1389 : /* If queue belongs to subordinate dev use its map */
1390 0 : dev = netdev_get_tx_queue(dev, index)->sb_dev ? : dev;
1391 :
1392 0 : tc = netdev_txq_to_tc(dev, index);
1393 0 : if (tc < 0) {
1394 0 : ret = -EINVAL;
1395 0 : goto err_rtnl_unlock;
1396 : }
1397 : }
1398 :
1399 0 : if (!zalloc_cpumask_var(&mask, GFP_KERNEL)) {
1400 : ret = -ENOMEM;
1401 : goto err_rtnl_unlock;
1402 : }
1403 :
1404 0 : rcu_read_lock();
1405 0 : dev_maps = rcu_dereference(dev->xps_cpus_map);
1406 0 : if (dev_maps) {
1407 0 : for_each_possible_cpu(cpu) {
1408 0 : int i, tci = cpu * num_tc + tc;
1409 0 : struct xps_map *map;
1410 :
1411 0 : map = rcu_dereference(dev_maps->attr_map[tci]);
1412 0 : if (!map)
1413 0 : continue;
1414 :
1415 0 : for (i = map->len; i--;) {
1416 0 : if (map->queues[i] == index) {
1417 0 : cpumask_set_cpu(cpu, mask);
1418 : break;
1419 : }
1420 : }
1421 : }
1422 : }
1423 0 : rcu_read_unlock();
1424 :
1425 0 : rtnl_unlock();
1426 :
1427 0 : len = snprintf(buf, PAGE_SIZE, "%*pb\n", cpumask_pr_args(mask));
1428 0 : free_cpumask_var(mask);
1429 0 : return len < PAGE_SIZE ? len : -EINVAL;
1430 :
1431 0 : err_rtnl_unlock:
1432 0 : rtnl_unlock();
1433 0 : return ret;
1434 : }
1435 :
1436 0 : static ssize_t xps_cpus_store(struct netdev_queue *queue,
1437 : const char *buf, size_t len)
1438 : {
1439 0 : struct net_device *dev = queue->dev;
1440 0 : unsigned long index;
1441 0 : cpumask_var_t mask;
1442 0 : int err;
1443 :
1444 0 : if (!netif_is_multiqueue(dev))
1445 : return -ENOENT;
1446 :
1447 0 : if (!capable(CAP_NET_ADMIN))
1448 : return -EPERM;
1449 :
1450 0 : if (!alloc_cpumask_var(&mask, GFP_KERNEL))
1451 : return -ENOMEM;
1452 :
1453 0 : index = get_netdev_queue_index(queue);
1454 :
1455 0 : err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
1456 0 : if (err) {
1457 0 : free_cpumask_var(mask);
1458 0 : return err;
1459 : }
1460 :
1461 0 : if (!rtnl_trylock()) {
1462 0 : free_cpumask_var(mask);
1463 0 : return restart_syscall();
1464 : }
1465 :
1466 0 : err = netif_set_xps_queue(dev, mask, index);
1467 0 : rtnl_unlock();
1468 :
1469 0 : free_cpumask_var(mask);
1470 :
1471 0 : return err ? : len;
1472 : }
1473 :
1474 : static struct netdev_queue_attribute xps_cpus_attribute __ro_after_init
1475 : = __ATTR_RW(xps_cpus);
1476 :
1477 0 : static ssize_t xps_rxqs_show(struct netdev_queue *queue, char *buf)
1478 : {
1479 0 : int j, len, ret, num_tc = 1, tc = 0;
1480 0 : struct net_device *dev = queue->dev;
1481 0 : struct xps_dev_maps *dev_maps;
1482 0 : unsigned long *mask, index;
1483 :
1484 0 : index = get_netdev_queue_index(queue);
1485 :
1486 0 : if (!rtnl_trylock())
1487 0 : return restart_syscall();
1488 :
1489 0 : if (dev->num_tc) {
1490 0 : num_tc = dev->num_tc;
1491 0 : tc = netdev_txq_to_tc(dev, index);
1492 0 : if (tc < 0) {
1493 0 : ret = -EINVAL;
1494 0 : goto err_rtnl_unlock;
1495 : }
1496 : }
1497 0 : mask = bitmap_zalloc(dev->num_rx_queues, GFP_KERNEL);
1498 0 : if (!mask) {
1499 0 : ret = -ENOMEM;
1500 0 : goto err_rtnl_unlock;
1501 : }
1502 :
1503 0 : rcu_read_lock();
1504 0 : dev_maps = rcu_dereference(dev->xps_rxqs_map);
1505 0 : if (!dev_maps)
1506 0 : goto out_no_maps;
1507 :
1508 0 : for (j = -1; j = netif_attrmask_next(j, NULL, dev->num_rx_queues),
1509 : j < dev->num_rx_queues;) {
1510 0 : int i, tci = j * num_tc + tc;
1511 0 : struct xps_map *map;
1512 :
1513 0 : map = rcu_dereference(dev_maps->attr_map[tci]);
1514 0 : if (!map)
1515 0 : continue;
1516 :
1517 0 : for (i = map->len; i--;) {
1518 0 : if (map->queues[i] == index) {
1519 0 : set_bit(j, mask);
1520 0 : break;
1521 : }
1522 : }
1523 : }
1524 0 : out_no_maps:
1525 0 : rcu_read_unlock();
1526 :
1527 0 : rtnl_unlock();
1528 :
1529 0 : len = bitmap_print_to_pagebuf(false, buf, mask, dev->num_rx_queues);
1530 0 : bitmap_free(mask);
1531 :
1532 0 : return len < PAGE_SIZE ? len : -EINVAL;
1533 :
1534 0 : err_rtnl_unlock:
1535 0 : rtnl_unlock();
1536 0 : return ret;
1537 : }
1538 :
1539 0 : static ssize_t xps_rxqs_store(struct netdev_queue *queue, const char *buf,
1540 : size_t len)
1541 : {
1542 0 : struct net_device *dev = queue->dev;
1543 0 : struct net *net = dev_net(dev);
1544 0 : unsigned long *mask, index;
1545 0 : int err;
1546 :
1547 0 : if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1548 : return -EPERM;
1549 :
1550 0 : mask = bitmap_zalloc(dev->num_rx_queues, GFP_KERNEL);
1551 0 : if (!mask)
1552 : return -ENOMEM;
1553 :
1554 0 : index = get_netdev_queue_index(queue);
1555 :
1556 0 : err = bitmap_parse(buf, len, mask, dev->num_rx_queues);
1557 0 : if (err) {
1558 0 : bitmap_free(mask);
1559 0 : return err;
1560 : }
1561 :
1562 0 : if (!rtnl_trylock()) {
1563 0 : bitmap_free(mask);
1564 0 : return restart_syscall();
1565 : }
1566 :
1567 0 : cpus_read_lock();
1568 0 : err = __netif_set_xps_queue(dev, mask, index, true);
1569 0 : cpus_read_unlock();
1570 :
1571 0 : rtnl_unlock();
1572 :
1573 0 : bitmap_free(mask);
1574 0 : return err ? : len;
1575 : }
1576 :
1577 : static struct netdev_queue_attribute xps_rxqs_attribute __ro_after_init
1578 : = __ATTR_RW(xps_rxqs);
1579 : #endif /* CONFIG_XPS */
1580 :
1581 : static struct attribute *netdev_queue_default_attrs[] __ro_after_init = {
1582 : &queue_trans_timeout.attr,
1583 : &queue_traffic_class.attr,
1584 : #ifdef CONFIG_XPS
1585 : &xps_cpus_attribute.attr,
1586 : &xps_rxqs_attribute.attr,
1587 : &queue_tx_maxrate.attr,
1588 : #endif
1589 : NULL
1590 : };
1591 : ATTRIBUTE_GROUPS(netdev_queue_default);
1592 :
1593 0 : static void netdev_queue_release(struct kobject *kobj)
1594 : {
1595 0 : struct netdev_queue *queue = to_netdev_queue(kobj);
1596 :
1597 0 : memset(kobj, 0, sizeof(*kobj));
1598 0 : dev_put(queue->dev);
1599 0 : }
1600 :
1601 8 : static const void *netdev_queue_namespace(struct kobject *kobj)
1602 : {
1603 8 : struct netdev_queue *queue = to_netdev_queue(kobj);
1604 8 : struct device *dev = &queue->dev->dev;
1605 8 : const void *ns = NULL;
1606 :
1607 8 : if (dev->class && dev->class->ns_type)
1608 8 : ns = dev->class->namespace(dev);
1609 :
1610 8 : return ns;
1611 : }
1612 :
1613 6 : static void netdev_queue_get_ownership(struct kobject *kobj,
1614 : kuid_t *uid, kgid_t *gid)
1615 : {
1616 6 : const struct net *net = netdev_queue_namespace(kobj);
1617 :
1618 6 : net_ns_get_ownership(net, uid, gid);
1619 6 : }
1620 :
1621 : static struct kobj_type netdev_queue_ktype __ro_after_init = {
1622 : .sysfs_ops = &netdev_queue_sysfs_ops,
1623 : .release = netdev_queue_release,
1624 : .default_groups = netdev_queue_default_groups,
1625 : .namespace = netdev_queue_namespace,
1626 : .get_ownership = netdev_queue_get_ownership,
1627 : };
1628 :
1629 2 : static int netdev_queue_add_kobject(struct net_device *dev, int index)
1630 : {
1631 2 : struct netdev_queue *queue = dev->_tx + index;
1632 2 : struct kobject *kobj = &queue->kobj;
1633 2 : int error = 0;
1634 :
1635 : /* Kobject_put later will trigger netdev_queue_release call
1636 : * which decreases dev refcount: Take that reference here
1637 : */
1638 2 : dev_hold(queue->dev);
1639 :
1640 2 : kobj->kset = dev->queues_kset;
1641 2 : error = kobject_init_and_add(kobj, &netdev_queue_ktype, NULL,
1642 : "tx-%u", index);
1643 2 : if (error)
1644 0 : goto err;
1645 :
1646 : #ifdef CONFIG_BQL
1647 2 : error = sysfs_create_group(kobj, &dql_group);
1648 2 : if (error)
1649 0 : goto err;
1650 : #endif
1651 :
1652 2 : kobject_uevent(kobj, KOBJ_ADD);
1653 2 : return 0;
1654 :
1655 0 : err:
1656 0 : kobject_put(kobj);
1657 0 : return error;
1658 : }
1659 :
1660 : static int tx_queue_change_owner(struct net_device *ndev, int index,
1661 : kuid_t kuid, kgid_t kgid)
1662 : {
1663 : struct netdev_queue *queue = ndev->_tx + index;
1664 : struct kobject *kobj = &queue->kobj;
1665 : int error;
1666 :
1667 : error = sysfs_change_owner(kobj, kuid, kgid);
1668 : if (error)
1669 : return error;
1670 :
1671 : #ifdef CONFIG_BQL
1672 : error = sysfs_group_change_owner(kobj, &dql_group, kuid, kgid);
1673 : #endif
1674 : return error;
1675 : }
1676 : #endif /* CONFIG_SYSFS */
1677 :
1678 : int
1679 2 : netdev_queue_update_kobjects(struct net_device *dev, int old_num, int new_num)
1680 : {
1681 : #ifdef CONFIG_SYSFS
1682 2 : int i;
1683 2 : int error = 0;
1684 :
1685 4 : for (i = old_num; i < new_num; i++) {
1686 2 : error = netdev_queue_add_kobject(dev, i);
1687 2 : if (error) {
1688 2 : new_num = old_num;
1689 : break;
1690 : }
1691 : }
1692 :
1693 2 : while (--i >= new_num) {
1694 0 : struct netdev_queue *queue = dev->_tx + i;
1695 :
1696 0 : if (!refcount_read(&dev_net(dev)->ns.count))
1697 0 : queue->kobj.uevent_suppress = 1;
1698 : #ifdef CONFIG_BQL
1699 0 : sysfs_remove_group(&queue->kobj, &dql_group);
1700 : #endif
1701 0 : kobject_put(&queue->kobj);
1702 : }
1703 :
1704 2 : return error;
1705 : #else
1706 : return 0;
1707 : #endif /* CONFIG_SYSFS */
1708 : }
1709 :
1710 : static int net_tx_queue_change_owner(struct net_device *dev, int num,
1711 : kuid_t kuid, kgid_t kgid)
1712 : {
1713 : #ifdef CONFIG_SYSFS
1714 : int error = 0;
1715 : int i;
1716 :
1717 : for (i = 0; i < num; i++) {
1718 : error = tx_queue_change_owner(dev, i, kuid, kgid);
1719 : if (error)
1720 : break;
1721 : }
1722 :
1723 : return error;
1724 : #else
1725 : return 0;
1726 : #endif /* CONFIG_SYSFS */
1727 : }
1728 :
1729 2 : static int register_queue_kobjects(struct net_device *dev)
1730 : {
1731 2 : int error = 0, txq = 0, rxq = 0, real_rx = 0, real_tx = 0;
1732 :
1733 : #ifdef CONFIG_SYSFS
1734 2 : dev->queues_kset = kset_create_and_add("queues",
1735 : NULL, &dev->dev.kobj);
1736 2 : if (!dev->queues_kset)
1737 : return -ENOMEM;
1738 2 : real_rx = dev->real_num_rx_queues;
1739 : #endif
1740 2 : real_tx = dev->real_num_tx_queues;
1741 :
1742 2 : error = net_rx_queue_update_kobjects(dev, 0, real_rx);
1743 2 : if (error)
1744 0 : goto error;
1745 2 : rxq = real_rx;
1746 :
1747 2 : error = netdev_queue_update_kobjects(dev, 0, real_tx);
1748 2 : if (error)
1749 0 : goto error;
1750 2 : txq = real_tx;
1751 :
1752 : return 0;
1753 :
1754 0 : error:
1755 0 : netdev_queue_update_kobjects(dev, txq, 0);
1756 0 : net_rx_queue_update_kobjects(dev, rxq, 0);
1757 : #ifdef CONFIG_SYSFS
1758 0 : kset_unregister(dev->queues_kset);
1759 : #endif
1760 0 : return error;
1761 : }
1762 :
1763 : static int queue_change_owner(struct net_device *ndev, kuid_t kuid, kgid_t kgid)
1764 : {
1765 : int error = 0, real_rx = 0, real_tx = 0;
1766 :
1767 : #ifdef CONFIG_SYSFS
1768 : if (ndev->queues_kset) {
1769 : error = sysfs_change_owner(&ndev->queues_kset->kobj, kuid, kgid);
1770 : if (error)
1771 : return error;
1772 : }
1773 : real_rx = ndev->real_num_rx_queues;
1774 : #endif
1775 : real_tx = ndev->real_num_tx_queues;
1776 :
1777 : error = net_rx_queue_change_owner(ndev, real_rx, kuid, kgid);
1778 : if (error)
1779 : return error;
1780 :
1781 : error = net_tx_queue_change_owner(ndev, real_tx, kuid, kgid);
1782 : if (error)
1783 : return error;
1784 :
1785 : return 0;
1786 : }
1787 :
1788 0 : static void remove_queue_kobjects(struct net_device *dev)
1789 : {
1790 0 : int real_rx = 0, real_tx = 0;
1791 :
1792 : #ifdef CONFIG_SYSFS
1793 0 : real_rx = dev->real_num_rx_queues;
1794 : #endif
1795 0 : real_tx = dev->real_num_tx_queues;
1796 :
1797 0 : net_rx_queue_update_kobjects(dev, real_rx, 0);
1798 0 : netdev_queue_update_kobjects(dev, real_tx, 0);
1799 : #ifdef CONFIG_SYSFS
1800 0 : kset_unregister(dev->queues_kset);
1801 : #endif
1802 0 : }
1803 :
1804 2 : static bool net_current_may_mount(void)
1805 : {
1806 2 : struct net *net = current->nsproxy->net_ns;
1807 :
1808 2 : return ns_capable(net->user_ns, CAP_SYS_ADMIN);
1809 : }
1810 :
1811 2 : static void *net_grab_current_ns(void)
1812 : {
1813 2 : struct net *ns = current->nsproxy->net_ns;
1814 : #ifdef CONFIG_NET_NS
1815 : if (ns)
1816 : refcount_inc(&ns->passive);
1817 : #endif
1818 2 : return ns;
1819 : }
1820 :
1821 0 : static const void *net_initial_ns(void)
1822 : {
1823 0 : return &init_net;
1824 : }
1825 :
1826 0 : static const void *net_netlink_ns(struct sock *sk)
1827 : {
1828 0 : return sock_net(sk);
1829 : }
1830 :
1831 : const struct kobj_ns_type_operations net_ns_type_operations = {
1832 : .type = KOBJ_NS_TYPE_NET,
1833 : .current_may_mount = net_current_may_mount,
1834 : .grab_current_ns = net_grab_current_ns,
1835 : .netlink_ns = net_netlink_ns,
1836 : .initial_ns = net_initial_ns,
1837 : .drop_ns = net_drop_ns,
1838 : };
1839 : EXPORT_SYMBOL_GPL(net_ns_type_operations);
1840 :
1841 9 : static int netdev_uevent(struct device *d, struct kobj_uevent_env *env)
1842 : {
1843 9 : struct net_device *dev = to_net_dev(d);
1844 9 : int retval;
1845 :
1846 : /* pass interface to uevent. */
1847 9 : retval = add_uevent_var(env, "INTERFACE=%s", dev->name);
1848 9 : if (retval)
1849 0 : goto exit;
1850 :
1851 : /* pass ifindex to uevent.
1852 : * ifindex is useful as it won't change (interface name may change)
1853 : * and is what RtNetlink uses natively.
1854 : */
1855 9 : retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex);
1856 :
1857 9 : exit:
1858 9 : return retval;
1859 : }
1860 :
1861 : /*
1862 : * netdev_release -- destroy and free a dead device.
1863 : * Called when last reference to device kobject is gone.
1864 : */
1865 0 : static void netdev_release(struct device *d)
1866 : {
1867 0 : struct net_device *dev = to_net_dev(d);
1868 :
1869 0 : BUG_ON(dev->reg_state != NETREG_RELEASED);
1870 :
1871 : /* no need to wait for rcu grace period:
1872 : * device is dead and about to be freed.
1873 : */
1874 0 : kfree(rcu_access_pointer(dev->ifalias));
1875 0 : netdev_freemem(dev);
1876 0 : }
1877 :
1878 21 : static const void *net_namespace(struct device *d)
1879 : {
1880 21 : struct net_device *dev = to_net_dev(d);
1881 :
1882 21 : return dev_net(dev);
1883 : }
1884 :
1885 10 : static void net_get_ownership(struct device *d, kuid_t *uid, kgid_t *gid)
1886 : {
1887 10 : struct net_device *dev = to_net_dev(d);
1888 10 : const struct net *net = dev_net(dev);
1889 :
1890 10 : net_ns_get_ownership(net, uid, gid);
1891 10 : }
1892 :
1893 : static struct class net_class __ro_after_init = {
1894 : .name = "net",
1895 : .dev_release = netdev_release,
1896 : .dev_groups = net_class_groups,
1897 : .dev_uevent = netdev_uevent,
1898 : .ns_type = &net_ns_type_operations,
1899 : .namespace = net_namespace,
1900 : .get_ownership = net_get_ownership,
1901 : };
1902 :
1903 : #ifdef CONFIG_OF_NET
1904 : static int of_dev_node_match(struct device *dev, const void *data)
1905 : {
1906 : for (; dev; dev = dev->parent) {
1907 : if (dev->of_node == data)
1908 : return 1;
1909 : }
1910 :
1911 : return 0;
1912 : }
1913 :
1914 : /*
1915 : * of_find_net_device_by_node - lookup the net device for the device node
1916 : * @np: OF device node
1917 : *
1918 : * Looks up the net_device structure corresponding with the device node.
1919 : * If successful, returns a pointer to the net_device with the embedded
1920 : * struct device refcount incremented by one, or NULL on failure. The
1921 : * refcount must be dropped when done with the net_device.
1922 : */
1923 : struct net_device *of_find_net_device_by_node(struct device_node *np)
1924 : {
1925 : struct device *dev;
1926 :
1927 : dev = class_find_device(&net_class, NULL, np, of_dev_node_match);
1928 : if (!dev)
1929 : return NULL;
1930 :
1931 : return to_net_dev(dev);
1932 : }
1933 : EXPORT_SYMBOL(of_find_net_device_by_node);
1934 : #endif
1935 :
1936 : /* Delete sysfs entries but hold kobject reference until after all
1937 : * netdev references are gone.
1938 : */
1939 0 : void netdev_unregister_kobject(struct net_device *ndev)
1940 : {
1941 0 : struct device *dev = &ndev->dev;
1942 :
1943 0 : if (!refcount_read(&dev_net(ndev)->ns.count))
1944 0 : dev_set_uevent_suppress(dev, 1);
1945 :
1946 0 : kobject_get(&dev->kobj);
1947 :
1948 0 : remove_queue_kobjects(ndev);
1949 :
1950 0 : pm_runtime_set_memalloc_noio(dev, false);
1951 :
1952 0 : device_del(dev);
1953 0 : }
1954 :
1955 : /* Create sysfs entries for network device. */
1956 2 : int netdev_register_kobject(struct net_device *ndev)
1957 : {
1958 2 : struct device *dev = &ndev->dev;
1959 2 : const struct attribute_group **groups = ndev->sysfs_groups;
1960 2 : int error = 0;
1961 :
1962 2 : device_initialize(dev);
1963 2 : dev->class = &net_class;
1964 2 : dev->platform_data = ndev;
1965 2 : dev->groups = groups;
1966 :
1967 2 : dev_set_name(dev, "%s", ndev->name);
1968 :
1969 : #ifdef CONFIG_SYSFS
1970 : /* Allow for a device specific group */
1971 2 : if (*groups)
1972 0 : groups++;
1973 :
1974 2 : *groups++ = &netstat_group;
1975 :
1976 : #if IS_ENABLED(CONFIG_WIRELESS_EXT) || IS_ENABLED(CONFIG_CFG80211)
1977 : if (ndev->ieee80211_ptr)
1978 : *groups++ = &wireless_group;
1979 : #if IS_ENABLED(CONFIG_WIRELESS_EXT)
1980 : else if (ndev->wireless_handlers)
1981 : *groups++ = &wireless_group;
1982 : #endif
1983 : #endif
1984 : #endif /* CONFIG_SYSFS */
1985 :
1986 2 : error = device_add(dev);
1987 2 : if (error)
1988 : return error;
1989 :
1990 2 : error = register_queue_kobjects(ndev);
1991 2 : if (error) {
1992 0 : device_del(dev);
1993 0 : return error;
1994 : }
1995 :
1996 2 : pm_runtime_set_memalloc_noio(dev, true);
1997 :
1998 : return error;
1999 : }
2000 :
2001 : /* Change owner for sysfs entries when moving network devices across network
2002 : * namespaces owned by different user namespaces.
2003 : */
2004 0 : int netdev_change_owner(struct net_device *ndev, const struct net *net_old,
2005 : const struct net *net_new)
2006 : {
2007 0 : struct device *dev = &ndev->dev;
2008 0 : kuid_t old_uid, new_uid;
2009 0 : kgid_t old_gid, new_gid;
2010 0 : int error;
2011 :
2012 0 : net_ns_get_ownership(net_old, &old_uid, &old_gid);
2013 0 : net_ns_get_ownership(net_new, &new_uid, &new_gid);
2014 :
2015 : /* The network namespace was changed but the owning user namespace is
2016 : * identical so there's no need to change the owner of sysfs entries.
2017 : */
2018 0 : if (uid_eq(old_uid, new_uid) && gid_eq(old_gid, new_gid))
2019 0 : return 0;
2020 :
2021 : error = device_change_owner(dev, new_uid, new_gid);
2022 : if (error)
2023 : return error;
2024 :
2025 : error = queue_change_owner(ndev, new_uid, new_gid);
2026 : if (error)
2027 : return error;
2028 :
2029 : return 0;
2030 : }
2031 :
2032 0 : int netdev_class_create_file_ns(const struct class_attribute *class_attr,
2033 : const void *ns)
2034 : {
2035 0 : return class_create_file_ns(&net_class, class_attr, ns);
2036 : }
2037 : EXPORT_SYMBOL(netdev_class_create_file_ns);
2038 :
2039 0 : void netdev_class_remove_file_ns(const struct class_attribute *class_attr,
2040 : const void *ns)
2041 : {
2042 0 : class_remove_file_ns(&net_class, class_attr, ns);
2043 0 : }
2044 : EXPORT_SYMBOL(netdev_class_remove_file_ns);
2045 :
2046 1 : int __init netdev_kobject_init(void)
2047 : {
2048 1 : kobj_ns_type_register(&net_ns_type_operations);
2049 1 : return class_register(&net_class);
2050 : }
|
