net/core/net-sysfs.c

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