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