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