net/core/net-sysfs.c

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