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