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