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