Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * net-sysfs.c - network device class and attributes
0004  *
0005  * Copyright (c) 2003 Stephen Hemminger <shemminger@osdl.org>
0006  */
0007 
0008 #include <linux/capability.h>
0009 #include <linux/kernel.h>
0010 #include <linux/netdevice.h>
0011 #include <linux/if_arp.h>
0012 #include <linux/slab.h>
0013 #include <linux/sched/signal.h>
0014 #include <linux/sched/isolation.h>
0015 #include <linux/nsproxy.h>
0016 #include <net/sock.h>
0017 #include <net/net_namespace.h>
0018 #include <linux/rtnetlink.h>
0019 #include <linux/vmalloc.h>
0020 #include <linux/export.h>
0021 #include <linux/jiffies.h>
0022 #include <linux/pm_runtime.h>
0023 #include <linux/of.h>
0024 #include <linux/of_net.h>
0025 #include <linux/cpu.h>
0026 
0027 #include "dev.h"
0028 #include "net-sysfs.h"
0029 
0030 #ifdef CONFIG_SYSFS
0031 static const char fmt_hex[] = "%#x\n";
0032 static const char fmt_dec[] = "%d\n";
0033 static const char fmt_ulong[] = "%lu\n";
0034 static const char fmt_u64[] = "%llu\n";
0035 
0036 /* Caller holds RTNL or dev_base_lock */
0037 static inline int dev_isalive(const struct net_device *dev)
0038 {
0039     return dev->reg_state <= NETREG_REGISTERED;
0040 }
0041 
0042 /* use same locking rules as GIF* ioctl's */
0043 static ssize_t netdev_show(const struct device *dev,
0044                struct device_attribute *attr, char *buf,
0045                ssize_t (*format)(const struct net_device *, char *))
0046 {
0047     struct net_device *ndev = to_net_dev(dev);
0048     ssize_t ret = -EINVAL;
0049 
0050     read_lock(&dev_base_lock);
0051     if (dev_isalive(ndev))
0052         ret = (*format)(ndev, buf);
0053     read_unlock(&dev_base_lock);
0054 
0055     return ret;
0056 }
0057 
0058 /* generate a show function for simple field */
0059 #define NETDEVICE_SHOW(field, format_string)                \
0060 static ssize_t format_##field(const struct net_device *dev, char *buf)  \
0061 {                                   \
0062     return sprintf(buf, format_string, dev->field);         \
0063 }                                   \
0064 static ssize_t field##_show(struct device *dev,             \
0065                 struct device_attribute *attr, char *buf)   \
0066 {                                   \
0067     return netdev_show(dev, attr, buf, format_##field);     \
0068 }                                   \
0069 
0070 #define NETDEVICE_SHOW_RO(field, format_string)             \
0071 NETDEVICE_SHOW(field, format_string);                   \
0072 static DEVICE_ATTR_RO(field)
0073 
0074 #define NETDEVICE_SHOW_RW(field, format_string)             \
0075 NETDEVICE_SHOW(field, format_string);                   \
0076 static DEVICE_ATTR_RW(field)
0077 
0078 /* use same locking and permission rules as SIF* ioctl's */
0079 static ssize_t netdev_store(struct device *dev, struct device_attribute *attr,
0080                 const char *buf, size_t len,
0081                 int (*set)(struct net_device *, unsigned long))
0082 {
0083     struct net_device *netdev = to_net_dev(dev);
0084     struct net *net = dev_net(netdev);
0085     unsigned long new;
0086     int ret;
0087 
0088     if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
0089         return -EPERM;
0090 
0091     ret = kstrtoul(buf, 0, &new);
0092     if (ret)
0093         goto err;
0094 
0095     if (!rtnl_trylock())
0096         return restart_syscall();
0097 
0098     if (dev_isalive(netdev)) {
0099         ret = (*set)(netdev, new);
0100         if (ret == 0)
0101             ret = len;
0102     }
0103     rtnl_unlock();
0104  err:
0105     return ret;
0106 }
0107 
0108 NETDEVICE_SHOW_RO(dev_id, fmt_hex);
0109 NETDEVICE_SHOW_RO(dev_port, fmt_dec);
0110 NETDEVICE_SHOW_RO(addr_assign_type, fmt_dec);
0111 NETDEVICE_SHOW_RO(addr_len, fmt_dec);
0112 NETDEVICE_SHOW_RO(ifindex, fmt_dec);
0113 NETDEVICE_SHOW_RO(type, fmt_dec);
0114 NETDEVICE_SHOW_RO(link_mode, fmt_dec);
0115 
0116 static ssize_t iflink_show(struct device *dev, struct device_attribute *attr,
0117                char *buf)
0118 {
0119     struct net_device *ndev = to_net_dev(dev);
0120 
0121     return sprintf(buf, fmt_dec, dev_get_iflink(ndev));
0122 }
0123 static DEVICE_ATTR_RO(iflink);
0124 
0125 static ssize_t format_name_assign_type(const struct net_device *dev, char *buf)
0126 {
0127     return sprintf(buf, fmt_dec, dev->name_assign_type);
0128 }
0129 
0130 static ssize_t name_assign_type_show(struct device *dev,
0131                      struct device_attribute *attr,
0132                      char *buf)
0133 {
0134     struct net_device *ndev = to_net_dev(dev);
0135     ssize_t ret = -EINVAL;
0136 
0137     if (ndev->name_assign_type != NET_NAME_UNKNOWN)
0138         ret = netdev_show(dev, attr, buf, format_name_assign_type);
0139 
0140     return ret;
0141 }
0142 static DEVICE_ATTR_RO(name_assign_type);
0143 
0144 /* use same locking rules as GIFHWADDR ioctl's */
0145 static ssize_t address_show(struct device *dev, struct device_attribute *attr,
0146                 char *buf)
0147 {
0148     struct net_device *ndev = to_net_dev(dev);
0149     ssize_t ret = -EINVAL;
0150 
0151     read_lock(&dev_base_lock);
0152     if (dev_isalive(ndev))
0153         ret = sysfs_format_mac(buf, ndev->dev_addr, ndev->addr_len);
0154     read_unlock(&dev_base_lock);
0155     return ret;
0156 }
0157 static DEVICE_ATTR_RO(address);
0158 
0159 static ssize_t broadcast_show(struct device *dev,
0160                   struct device_attribute *attr, char *buf)
0161 {
0162     struct net_device *ndev = to_net_dev(dev);
0163 
0164     if (dev_isalive(ndev))
0165         return sysfs_format_mac(buf, ndev->broadcast, ndev->addr_len);
0166     return -EINVAL;
0167 }
0168 static DEVICE_ATTR_RO(broadcast);
0169 
0170 static int change_carrier(struct net_device *dev, unsigned long new_carrier)
0171 {
0172     if (!netif_running(dev))
0173         return -EINVAL;
0174     return dev_change_carrier(dev, (bool)new_carrier);
0175 }
0176 
0177 static ssize_t carrier_store(struct device *dev, struct device_attribute *attr,
0178                  const char *buf, size_t len)
0179 {
0180     struct net_device *netdev = to_net_dev(dev);
0181 
0182     /* The check is also done in change_carrier; this helps returning early
0183      * without hitting the trylock/restart in netdev_store.
0184      */
0185     if (!netdev->netdev_ops->ndo_change_carrier)
0186         return -EOPNOTSUPP;
0187 
0188     return netdev_store(dev, attr, buf, len, change_carrier);
0189 }
0190 
0191 static ssize_t carrier_show(struct device *dev,
0192                 struct device_attribute *attr, char *buf)
0193 {
0194     struct net_device *netdev = to_net_dev(dev);
0195 
0196     if (netif_running(netdev))
0197         return sprintf(buf, fmt_dec, !!netif_carrier_ok(netdev));
0198 
0199     return -EINVAL;
0200 }
0201 static DEVICE_ATTR_RW(carrier);
0202 
0203 static ssize_t speed_show(struct device *dev,
0204               struct device_attribute *attr, char *buf)
0205 {
0206     struct net_device *netdev = to_net_dev(dev);
0207     int ret = -EINVAL;
0208 
0209     /* The check is also done in __ethtool_get_link_ksettings; this helps
0210      * returning early without hitting the trylock/restart below.
0211      */
0212     if (!netdev->ethtool_ops->get_link_ksettings)
0213         return ret;
0214 
0215     if (!rtnl_trylock())
0216         return restart_syscall();
0217 
0218     if (netif_running(netdev) && netif_device_present(netdev)) {
0219         struct ethtool_link_ksettings cmd;
0220 
0221         if (!__ethtool_get_link_ksettings(netdev, &cmd))
0222             ret = sprintf(buf, fmt_dec, cmd.base.speed);
0223     }
0224     rtnl_unlock();
0225     return ret;
0226 }
0227 static DEVICE_ATTR_RO(speed);
0228 
0229 static ssize_t duplex_show(struct device *dev,
0230                struct device_attribute *attr, char *buf)
0231 {
0232     struct net_device *netdev = to_net_dev(dev);
0233     int ret = -EINVAL;
0234 
0235     /* The check is also done in __ethtool_get_link_ksettings; this helps
0236      * returning early without hitting the trylock/restart below.
0237      */
0238     if (!netdev->ethtool_ops->get_link_ksettings)
0239         return ret;
0240 
0241     if (!rtnl_trylock())
0242         return restart_syscall();
0243 
0244     if (netif_running(netdev)) {
0245         struct ethtool_link_ksettings cmd;
0246 
0247         if (!__ethtool_get_link_ksettings(netdev, &cmd)) {
0248             const char *duplex;
0249 
0250             switch (cmd.base.duplex) {
0251             case DUPLEX_HALF:
0252                 duplex = "half";
0253                 break;
0254             case DUPLEX_FULL:
0255                 duplex = "full";
0256                 break;
0257             default:
0258                 duplex = "unknown";
0259                 break;
0260             }
0261             ret = sprintf(buf, "%s\n", duplex);
0262         }
0263     }
0264     rtnl_unlock();
0265     return ret;
0266 }
0267 static DEVICE_ATTR_RO(duplex);
0268 
0269 static ssize_t testing_show(struct device *dev,
0270                 struct device_attribute *attr, char *buf)
0271 {
0272     struct net_device *netdev = to_net_dev(dev);
0273 
0274     if (netif_running(netdev))
0275         return sprintf(buf, fmt_dec, !!netif_testing(netdev));
0276 
0277     return -EINVAL;
0278 }
0279 static DEVICE_ATTR_RO(testing);
0280 
0281 static ssize_t dormant_show(struct device *dev,
0282                 struct device_attribute *attr, char *buf)
0283 {
0284     struct net_device *netdev = to_net_dev(dev);
0285 
0286     if (netif_running(netdev))
0287         return sprintf(buf, fmt_dec, !!netif_dormant(netdev));
0288 
0289     return -EINVAL;
0290 }
0291 static DEVICE_ATTR_RO(dormant);
0292 
0293 static const char *const operstates[] = {
0294     "unknown",
0295     "notpresent", /* currently unused */
0296     "down",
0297     "lowerlayerdown",
0298     "testing",
0299     "dormant",
0300     "up"
0301 };
0302 
0303 static ssize_t operstate_show(struct device *dev,
0304                   struct device_attribute *attr, char *buf)
0305 {
0306     const struct net_device *netdev = to_net_dev(dev);
0307     unsigned char operstate;
0308 
0309     read_lock(&dev_base_lock);
0310     operstate = netdev->operstate;
0311     if (!netif_running(netdev))
0312         operstate = IF_OPER_DOWN;
0313     read_unlock(&dev_base_lock);
0314 
0315     if (operstate >= ARRAY_SIZE(operstates))
0316         return -EINVAL; /* should not happen */
0317 
0318     return sprintf(buf, "%s\n", operstates[operstate]);
0319 }
0320 static DEVICE_ATTR_RO(operstate);
0321 
0322 static ssize_t carrier_changes_show(struct device *dev,
0323                     struct device_attribute *attr,
0324                     char *buf)
0325 {
0326     struct net_device *netdev = to_net_dev(dev);
0327 
0328     return sprintf(buf, fmt_dec,
0329                atomic_read(&netdev->carrier_up_count) +
0330                atomic_read(&netdev->carrier_down_count));
0331 }
0332 static DEVICE_ATTR_RO(carrier_changes);
0333 
0334 static ssize_t carrier_up_count_show(struct device *dev,
0335                      struct device_attribute *attr,
0336                      char *buf)
0337 {
0338     struct net_device *netdev = to_net_dev(dev);
0339 
0340     return sprintf(buf, fmt_dec, atomic_read(&netdev->carrier_up_count));
0341 }
0342 static DEVICE_ATTR_RO(carrier_up_count);
0343 
0344 static ssize_t carrier_down_count_show(struct device *dev,
0345                        struct device_attribute *attr,
0346                        char *buf)
0347 {
0348     struct net_device *netdev = to_net_dev(dev);
0349 
0350     return sprintf(buf, fmt_dec, atomic_read(&netdev->carrier_down_count));
0351 }
0352 static DEVICE_ATTR_RO(carrier_down_count);
0353 
0354 /* read-write attributes */
0355 
0356 static int change_mtu(struct net_device *dev, unsigned long new_mtu)
0357 {
0358     return dev_set_mtu(dev, (int)new_mtu);
0359 }
0360 
0361 static ssize_t mtu_store(struct device *dev, struct device_attribute *attr,
0362              const char *buf, size_t len)
0363 {
0364     return netdev_store(dev, attr, buf, len, change_mtu);
0365 }
0366 NETDEVICE_SHOW_RW(mtu, fmt_dec);
0367 
0368 static int change_flags(struct net_device *dev, unsigned long new_flags)
0369 {
0370     return dev_change_flags(dev, (unsigned int)new_flags, NULL);
0371 }
0372 
0373 static ssize_t flags_store(struct device *dev, struct device_attribute *attr,
0374                const char *buf, size_t len)
0375 {
0376     return netdev_store(dev, attr, buf, len, change_flags);
0377 }
0378 NETDEVICE_SHOW_RW(flags, fmt_hex);
0379 
0380 static ssize_t tx_queue_len_store(struct device *dev,
0381                   struct device_attribute *attr,
0382                   const char *buf, size_t len)
0383 {
0384     if (!capable(CAP_NET_ADMIN))
0385         return -EPERM;
0386 
0387     return netdev_store(dev, attr, buf, len, dev_change_tx_queue_len);
0388 }
0389 NETDEVICE_SHOW_RW(tx_queue_len, fmt_dec);
0390 
0391 static int change_gro_flush_timeout(struct net_device *dev, unsigned long val)
0392 {
0393     WRITE_ONCE(dev->gro_flush_timeout, val);
0394     return 0;
0395 }
0396 
0397 static ssize_t gro_flush_timeout_store(struct device *dev,
0398                        struct device_attribute *attr,
0399                        const char *buf, size_t len)
0400 {
0401     if (!capable(CAP_NET_ADMIN))
0402         return -EPERM;
0403 
0404     return netdev_store(dev, attr, buf, len, change_gro_flush_timeout);
0405 }
0406 NETDEVICE_SHOW_RW(gro_flush_timeout, fmt_ulong);
0407 
0408 static int change_napi_defer_hard_irqs(struct net_device *dev, unsigned long val)
0409 {
0410     WRITE_ONCE(dev->napi_defer_hard_irqs, val);
0411     return 0;
0412 }
0413 
0414 static ssize_t napi_defer_hard_irqs_store(struct device *dev,
0415                       struct device_attribute *attr,
0416                       const char *buf, size_t len)
0417 {
0418     if (!capable(CAP_NET_ADMIN))
0419         return -EPERM;
0420 
0421     return netdev_store(dev, attr, buf, len, change_napi_defer_hard_irqs);
0422 }
0423 NETDEVICE_SHOW_RW(napi_defer_hard_irqs, fmt_dec);
0424 
0425 static ssize_t ifalias_store(struct device *dev, struct device_attribute *attr,
0426                  const char *buf, size_t len)
0427 {
0428     struct net_device *netdev = to_net_dev(dev);
0429     struct net *net = dev_net(netdev);
0430     size_t count = len;
0431     ssize_t ret = 0;
0432 
0433     if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
0434         return -EPERM;
0435 
0436     /* ignore trailing newline */
0437     if (len >  0 && buf[len - 1] == '\n')
0438         --count;
0439 
0440     if (!rtnl_trylock())
0441         return restart_syscall();
0442 
0443     if (dev_isalive(netdev)) {
0444         ret = dev_set_alias(netdev, buf, count);
0445         if (ret < 0)
0446             goto err;
0447         ret = len;
0448         netdev_state_change(netdev);
0449     }
0450 err:
0451     rtnl_unlock();
0452 
0453     return ret;
0454 }
0455 
0456 static ssize_t ifalias_show(struct device *dev,
0457                 struct device_attribute *attr, char *buf)
0458 {
0459     const struct net_device *netdev = to_net_dev(dev);
0460     char tmp[IFALIASZ];
0461     ssize_t ret = 0;
0462 
0463     ret = dev_get_alias(netdev, tmp, sizeof(tmp));
0464     if (ret > 0)
0465         ret = sprintf(buf, "%s\n", tmp);
0466     return ret;
0467 }
0468 static DEVICE_ATTR_RW(ifalias);
0469 
0470 static int change_group(struct net_device *dev, unsigned long new_group)
0471 {
0472     dev_set_group(dev, (int)new_group);
0473     return 0;
0474 }
0475 
0476 static ssize_t group_store(struct device *dev, struct device_attribute *attr,
0477                const char *buf, size_t len)
0478 {
0479     return netdev_store(dev, attr, buf, len, change_group);
0480 }
0481 NETDEVICE_SHOW(group, fmt_dec);
0482 static DEVICE_ATTR(netdev_group, 0644, group_show, group_store);
0483 
0484 static int change_proto_down(struct net_device *dev, unsigned long proto_down)
0485 {
0486     return dev_change_proto_down(dev, (bool)proto_down);
0487 }
0488 
0489 static ssize_t proto_down_store(struct device *dev,
0490                 struct device_attribute *attr,
0491                 const char *buf, size_t len)
0492 {
0493     return netdev_store(dev, attr, buf, len, change_proto_down);
0494 }
0495 NETDEVICE_SHOW_RW(proto_down, fmt_dec);
0496 
0497 static ssize_t phys_port_id_show(struct device *dev,
0498                  struct device_attribute *attr, char *buf)
0499 {
0500     struct net_device *netdev = to_net_dev(dev);
0501     ssize_t ret = -EINVAL;
0502 
0503     /* The check is also done in dev_get_phys_port_id; this helps returning
0504      * early without hitting the trylock/restart below.
0505      */
0506     if (!netdev->netdev_ops->ndo_get_phys_port_id)
0507         return -EOPNOTSUPP;
0508 
0509     if (!rtnl_trylock())
0510         return restart_syscall();
0511 
0512     if (dev_isalive(netdev)) {
0513         struct netdev_phys_item_id ppid;
0514 
0515         ret = dev_get_phys_port_id(netdev, &ppid);
0516         if (!ret)
0517             ret = sprintf(buf, "%*phN\n", ppid.id_len, ppid.id);
0518     }
0519     rtnl_unlock();
0520 
0521     return ret;
0522 }
0523 static DEVICE_ATTR_RO(phys_port_id);
0524 
0525 static ssize_t phys_port_name_show(struct device *dev,
0526                    struct device_attribute *attr, char *buf)
0527 {
0528     struct net_device *netdev = to_net_dev(dev);
0529     ssize_t ret = -EINVAL;
0530 
0531     /* The checks are also done in dev_get_phys_port_name; this helps
0532      * returning early without hitting the trylock/restart below.
0533      */
0534     if (!netdev->netdev_ops->ndo_get_phys_port_name &&
0535         !netdev->netdev_ops->ndo_get_devlink_port)
0536         return -EOPNOTSUPP;
0537 
0538     if (!rtnl_trylock())
0539         return restart_syscall();
0540 
0541     if (dev_isalive(netdev)) {
0542         char name[IFNAMSIZ];
0543 
0544         ret = dev_get_phys_port_name(netdev, name, sizeof(name));
0545         if (!ret)
0546             ret = sprintf(buf, "%s\n", name);
0547     }
0548     rtnl_unlock();
0549 
0550     return ret;
0551 }
0552 static DEVICE_ATTR_RO(phys_port_name);
0553 
0554 static ssize_t phys_switch_id_show(struct device *dev,
0555                    struct device_attribute *attr, char *buf)
0556 {
0557     struct net_device *netdev = to_net_dev(dev);
0558     ssize_t ret = -EINVAL;
0559 
0560     /* The checks are also done in dev_get_phys_port_name; this helps
0561      * returning early without hitting the trylock/restart below. This works
0562      * because recurse is false when calling dev_get_port_parent_id.
0563      */
0564     if (!netdev->netdev_ops->ndo_get_port_parent_id &&
0565         !netdev->netdev_ops->ndo_get_devlink_port)
0566         return -EOPNOTSUPP;
0567 
0568     if (!rtnl_trylock())
0569         return restart_syscall();
0570 
0571     if (dev_isalive(netdev)) {
0572         struct netdev_phys_item_id ppid = { };
0573 
0574         ret = dev_get_port_parent_id(netdev, &ppid, false);
0575         if (!ret)
0576             ret = sprintf(buf, "%*phN\n", ppid.id_len, ppid.id);
0577     }
0578     rtnl_unlock();
0579 
0580     return ret;
0581 }
0582 static DEVICE_ATTR_RO(phys_switch_id);
0583 
0584 static ssize_t threaded_show(struct device *dev,
0585                  struct device_attribute *attr, char *buf)
0586 {
0587     struct net_device *netdev = to_net_dev(dev);
0588     ssize_t ret = -EINVAL;
0589 
0590     if (!rtnl_trylock())
0591         return restart_syscall();
0592 
0593     if (dev_isalive(netdev))
0594         ret = sprintf(buf, fmt_dec, netdev->threaded);
0595 
0596     rtnl_unlock();
0597     return ret;
0598 }
0599 
0600 static int modify_napi_threaded(struct net_device *dev, unsigned long val)
0601 {
0602     int ret;
0603 
0604     if (list_empty(&dev->napi_list))
0605         return -EOPNOTSUPP;
0606 
0607     if (val != 0 && val != 1)
0608         return -EOPNOTSUPP;
0609 
0610     ret = dev_set_threaded(dev, val);
0611 
0612     return ret;
0613 }
0614 
0615 static ssize_t threaded_store(struct device *dev,
0616                   struct device_attribute *attr,
0617                   const char *buf, size_t len)
0618 {
0619     return netdev_store(dev, attr, buf, len, modify_napi_threaded);
0620 }
0621 static DEVICE_ATTR_RW(threaded);
0622 
0623 static struct attribute *net_class_attrs[] __ro_after_init = {
0624     &dev_attr_netdev_group.attr,
0625     &dev_attr_type.attr,
0626     &dev_attr_dev_id.attr,
0627     &dev_attr_dev_port.attr,
0628     &dev_attr_iflink.attr,
0629     &dev_attr_ifindex.attr,
0630     &dev_attr_name_assign_type.attr,
0631     &dev_attr_addr_assign_type.attr,
0632     &dev_attr_addr_len.attr,
0633     &dev_attr_link_mode.attr,
0634     &dev_attr_address.attr,
0635     &dev_attr_broadcast.attr,
0636     &dev_attr_speed.attr,
0637     &dev_attr_duplex.attr,
0638     &dev_attr_dormant.attr,
0639     &dev_attr_testing.attr,
0640     &dev_attr_operstate.attr,
0641     &dev_attr_carrier_changes.attr,
0642     &dev_attr_ifalias.attr,
0643     &dev_attr_carrier.attr,
0644     &dev_attr_mtu.attr,
0645     &dev_attr_flags.attr,
0646     &dev_attr_tx_queue_len.attr,
0647     &dev_attr_gro_flush_timeout.attr,
0648     &dev_attr_napi_defer_hard_irqs.attr,
0649     &dev_attr_phys_port_id.attr,
0650     &dev_attr_phys_port_name.attr,
0651     &dev_attr_phys_switch_id.attr,
0652     &dev_attr_proto_down.attr,
0653     &dev_attr_carrier_up_count.attr,
0654     &dev_attr_carrier_down_count.attr,
0655     &dev_attr_threaded.attr,
0656     NULL,
0657 };
0658 ATTRIBUTE_GROUPS(net_class);
0659 
0660 /* Show a given an attribute in the statistics group */
0661 static ssize_t netstat_show(const struct device *d,
0662                 struct device_attribute *attr, char *buf,
0663                 unsigned long offset)
0664 {
0665     struct net_device *dev = to_net_dev(d);
0666     ssize_t ret = -EINVAL;
0667 
0668     WARN_ON(offset > sizeof(struct rtnl_link_stats64) ||
0669         offset % sizeof(u64) != 0);
0670 
0671     read_lock(&dev_base_lock);
0672     if (dev_isalive(dev)) {
0673         struct rtnl_link_stats64 temp;
0674         const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp);
0675 
0676         ret = sprintf(buf, fmt_u64, *(u64 *)(((u8 *)stats) + offset));
0677     }
0678     read_unlock(&dev_base_lock);
0679     return ret;
0680 }
0681 
0682 /* generate a read-only statistics attribute */
0683 #define NETSTAT_ENTRY(name)                     \
0684 static ssize_t name##_show(struct device *d,                \
0685                struct device_attribute *attr, char *buf)    \
0686 {                                   \
0687     return netstat_show(d, attr, buf,               \
0688                 offsetof(struct rtnl_link_stats64, name));  \
0689 }                                   \
0690 static DEVICE_ATTR_RO(name)
0691 
0692 NETSTAT_ENTRY(rx_packets);
0693 NETSTAT_ENTRY(tx_packets);
0694 NETSTAT_ENTRY(rx_bytes);
0695 NETSTAT_ENTRY(tx_bytes);
0696 NETSTAT_ENTRY(rx_errors);
0697 NETSTAT_ENTRY(tx_errors);
0698 NETSTAT_ENTRY(rx_dropped);
0699 NETSTAT_ENTRY(tx_dropped);
0700 NETSTAT_ENTRY(multicast);
0701 NETSTAT_ENTRY(collisions);
0702 NETSTAT_ENTRY(rx_length_errors);
0703 NETSTAT_ENTRY(rx_over_errors);
0704 NETSTAT_ENTRY(rx_crc_errors);
0705 NETSTAT_ENTRY(rx_frame_errors);
0706 NETSTAT_ENTRY(rx_fifo_errors);
0707 NETSTAT_ENTRY(rx_missed_errors);
0708 NETSTAT_ENTRY(tx_aborted_errors);
0709 NETSTAT_ENTRY(tx_carrier_errors);
0710 NETSTAT_ENTRY(tx_fifo_errors);
0711 NETSTAT_ENTRY(tx_heartbeat_errors);
0712 NETSTAT_ENTRY(tx_window_errors);
0713 NETSTAT_ENTRY(rx_compressed);
0714 NETSTAT_ENTRY(tx_compressed);
0715 NETSTAT_ENTRY(rx_nohandler);
0716 
0717 static struct attribute *netstat_attrs[] __ro_after_init = {
0718     &dev_attr_rx_packets.attr,
0719     &dev_attr_tx_packets.attr,
0720     &dev_attr_rx_bytes.attr,
0721     &dev_attr_tx_bytes.attr,
0722     &dev_attr_rx_errors.attr,
0723     &dev_attr_tx_errors.attr,
0724     &dev_attr_rx_dropped.attr,
0725     &dev_attr_tx_dropped.attr,
0726     &dev_attr_multicast.attr,
0727     &dev_attr_collisions.attr,
0728     &dev_attr_rx_length_errors.attr,
0729     &dev_attr_rx_over_errors.attr,
0730     &dev_attr_rx_crc_errors.attr,
0731     &dev_attr_rx_frame_errors.attr,
0732     &dev_attr_rx_fifo_errors.attr,
0733     &dev_attr_rx_missed_errors.attr,
0734     &dev_attr_tx_aborted_errors.attr,
0735     &dev_attr_tx_carrier_errors.attr,
0736     &dev_attr_tx_fifo_errors.attr,
0737     &dev_attr_tx_heartbeat_errors.attr,
0738     &dev_attr_tx_window_errors.attr,
0739     &dev_attr_rx_compressed.attr,
0740     &dev_attr_tx_compressed.attr,
0741     &dev_attr_rx_nohandler.attr,
0742     NULL
0743 };
0744 
0745 static const struct attribute_group netstat_group = {
0746     .name  = "statistics",
0747     .attrs  = netstat_attrs,
0748 };
0749 
0750 static struct attribute *wireless_attrs[] = {
0751     NULL
0752 };
0753 
0754 static const struct attribute_group wireless_group = {
0755     .name = "wireless",
0756     .attrs = wireless_attrs,
0757 };
0758 
0759 static bool wireless_group_needed(struct net_device *ndev)
0760 {
0761 #if IS_ENABLED(CONFIG_CFG80211)
0762     if (ndev->ieee80211_ptr)
0763         return true;
0764 #endif
0765 #if IS_ENABLED(CONFIG_WIRELESS_EXT)
0766     if (ndev->wireless_handlers)
0767         return true;
0768 #endif
0769     return false;
0770 }
0771 
0772 #else /* CONFIG_SYSFS */
0773 #define net_class_groups    NULL
0774 #endif /* CONFIG_SYSFS */
0775 
0776 #ifdef CONFIG_SYSFS
0777 #define to_rx_queue_attr(_attr) \
0778     container_of(_attr, struct rx_queue_attribute, attr)
0779 
0780 #define to_rx_queue(obj) container_of(obj, struct netdev_rx_queue, kobj)
0781 
0782 static ssize_t rx_queue_attr_show(struct kobject *kobj, struct attribute *attr,
0783                   char *buf)
0784 {
0785     const struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
0786     struct netdev_rx_queue *queue = to_rx_queue(kobj);
0787 
0788     if (!attribute->show)
0789         return -EIO;
0790 
0791     return attribute->show(queue, buf);
0792 }
0793 
0794 static ssize_t rx_queue_attr_store(struct kobject *kobj, struct attribute *attr,
0795                    const char *buf, size_t count)
0796 {
0797     const struct rx_queue_attribute *attribute = to_rx_queue_attr(attr);
0798     struct netdev_rx_queue *queue = to_rx_queue(kobj);
0799 
0800     if (!attribute->store)
0801         return -EIO;
0802 
0803     return attribute->store(queue, buf, count);
0804 }
0805 
0806 static const struct sysfs_ops rx_queue_sysfs_ops = {
0807     .show = rx_queue_attr_show,
0808     .store = rx_queue_attr_store,
0809 };
0810 
0811 #ifdef CONFIG_RPS
0812 static ssize_t show_rps_map(struct netdev_rx_queue *queue, char *buf)
0813 {
0814     struct rps_map *map;
0815     cpumask_var_t mask;
0816     int i, len;
0817 
0818     if (!zalloc_cpumask_var(&mask, GFP_KERNEL))
0819         return -ENOMEM;
0820 
0821     rcu_read_lock();
0822     map = rcu_dereference(queue->rps_map);
0823     if (map)
0824         for (i = 0; i < map->len; i++)
0825             cpumask_set_cpu(map->cpus[i], mask);
0826 
0827     len = snprintf(buf, PAGE_SIZE, "%*pb\n", cpumask_pr_args(mask));
0828     rcu_read_unlock();
0829     free_cpumask_var(mask);
0830 
0831     return len < PAGE_SIZE ? len : -EINVAL;
0832 }
0833 
0834 static ssize_t store_rps_map(struct netdev_rx_queue *queue,
0835                  const char *buf, size_t len)
0836 {
0837     struct rps_map *old_map, *map;
0838     cpumask_var_t mask;
0839     int err, cpu, i;
0840     static DEFINE_MUTEX(rps_map_mutex);
0841 
0842     if (!capable(CAP_NET_ADMIN))
0843         return -EPERM;
0844 
0845     if (!alloc_cpumask_var(&mask, GFP_KERNEL))
0846         return -ENOMEM;
0847 
0848     err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
0849     if (err) {
0850         free_cpumask_var(mask);
0851         return err;
0852     }
0853 
0854     if (!cpumask_empty(mask)) {
0855         cpumask_and(mask, mask, housekeeping_cpumask(HK_TYPE_DOMAIN));
0856         cpumask_and(mask, mask, housekeeping_cpumask(HK_TYPE_WQ));
0857         if (cpumask_empty(mask)) {
0858             free_cpumask_var(mask);
0859             return -EINVAL;
0860         }
0861     }
0862 
0863     map = kzalloc(max_t(unsigned int,
0864                 RPS_MAP_SIZE(cpumask_weight(mask)), L1_CACHE_BYTES),
0865               GFP_KERNEL);
0866     if (!map) {
0867         free_cpumask_var(mask);
0868         return -ENOMEM;
0869     }
0870 
0871     i = 0;
0872     for_each_cpu_and(cpu, mask, cpu_online_mask)
0873         map->cpus[i++] = cpu;
0874 
0875     if (i) {
0876         map->len = i;
0877     } else {
0878         kfree(map);
0879         map = NULL;
0880     }
0881 
0882     mutex_lock(&rps_map_mutex);
0883     old_map = rcu_dereference_protected(queue->rps_map,
0884                         mutex_is_locked(&rps_map_mutex));
0885     rcu_assign_pointer(queue->rps_map, map);
0886 
0887     if (map)
0888         static_branch_inc(&rps_needed);
0889     if (old_map)
0890         static_branch_dec(&rps_needed);
0891 
0892     mutex_unlock(&rps_map_mutex);
0893 
0894     if (old_map)
0895         kfree_rcu(old_map, rcu);
0896 
0897     free_cpumask_var(mask);
0898     return len;
0899 }
0900 
0901 static ssize_t show_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
0902                        char *buf)
0903 {
0904     struct rps_dev_flow_table *flow_table;
0905     unsigned long val = 0;
0906 
0907     rcu_read_lock();
0908     flow_table = rcu_dereference(queue->rps_flow_table);
0909     if (flow_table)
0910         val = (unsigned long)flow_table->mask + 1;
0911     rcu_read_unlock();
0912 
0913     return sprintf(buf, "%lu\n", val);
0914 }
0915 
0916 static void rps_dev_flow_table_release(struct rcu_head *rcu)
0917 {
0918     struct rps_dev_flow_table *table = container_of(rcu,
0919         struct rps_dev_flow_table, rcu);
0920     vfree(table);
0921 }
0922 
0923 static ssize_t store_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue,
0924                         const char *buf, size_t len)
0925 {
0926     unsigned long mask, count;
0927     struct rps_dev_flow_table *table, *old_table;
0928     static DEFINE_SPINLOCK(rps_dev_flow_lock);
0929     int rc;
0930 
0931     if (!capable(CAP_NET_ADMIN))
0932         return -EPERM;
0933 
0934     rc = kstrtoul(buf, 0, &count);
0935     if (rc < 0)
0936         return rc;
0937 
0938     if (count) {
0939         mask = count - 1;
0940         /* mask = roundup_pow_of_two(count) - 1;
0941          * without overflows...
0942          */
0943         while ((mask | (mask >> 1)) != mask)
0944             mask |= (mask >> 1);
0945         /* On 64 bit arches, must check mask fits in table->mask (u32),
0946          * and on 32bit arches, must check
0947          * RPS_DEV_FLOW_TABLE_SIZE(mask + 1) doesn't overflow.
0948          */
0949 #if BITS_PER_LONG > 32
0950         if (mask > (unsigned long)(u32)mask)
0951             return -EINVAL;
0952 #else
0953         if (mask > (ULONG_MAX - RPS_DEV_FLOW_TABLE_SIZE(1))
0954                 / sizeof(struct rps_dev_flow)) {
0955             /* Enforce a limit to prevent overflow */
0956             return -EINVAL;
0957         }
0958 #endif
0959         table = vmalloc(RPS_DEV_FLOW_TABLE_SIZE(mask + 1));
0960         if (!table)
0961             return -ENOMEM;
0962 
0963         table->mask = mask;
0964         for (count = 0; count <= mask; count++)
0965             table->flows[count].cpu = RPS_NO_CPU;
0966     } else {
0967         table = NULL;
0968     }
0969 
0970     spin_lock(&rps_dev_flow_lock);
0971     old_table = rcu_dereference_protected(queue->rps_flow_table,
0972                           lockdep_is_held(&rps_dev_flow_lock));
0973     rcu_assign_pointer(queue->rps_flow_table, table);
0974     spin_unlock(&rps_dev_flow_lock);
0975 
0976     if (old_table)
0977         call_rcu(&old_table->rcu, rps_dev_flow_table_release);
0978 
0979     return len;
0980 }
0981 
0982 static struct rx_queue_attribute rps_cpus_attribute __ro_after_init
0983     = __ATTR(rps_cpus, 0644, show_rps_map, store_rps_map);
0984 
0985 static struct rx_queue_attribute rps_dev_flow_table_cnt_attribute __ro_after_init
0986     = __ATTR(rps_flow_cnt, 0644,
0987          show_rps_dev_flow_table_cnt, store_rps_dev_flow_table_cnt);
0988 #endif /* CONFIG_RPS */
0989 
0990 static struct attribute *rx_queue_default_attrs[] __ro_after_init = {
0991 #ifdef CONFIG_RPS
0992     &rps_cpus_attribute.attr,
0993     &rps_dev_flow_table_cnt_attribute.attr,
0994 #endif
0995     NULL
0996 };
0997 ATTRIBUTE_GROUPS(rx_queue_default);
0998 
0999 static void rx_queue_release(struct kobject *kobj)
1000 {
1001     struct netdev_rx_queue *queue = to_rx_queue(kobj);
1002 #ifdef CONFIG_RPS
1003     struct rps_map *map;
1004     struct rps_dev_flow_table *flow_table;
1005 
1006     map = rcu_dereference_protected(queue->rps_map, 1);
1007     if (map) {
1008         RCU_INIT_POINTER(queue->rps_map, NULL);
1009         kfree_rcu(map, rcu);
1010     }
1011 
1012     flow_table = rcu_dereference_protected(queue->rps_flow_table, 1);
1013     if (flow_table) {
1014         RCU_INIT_POINTER(queue->rps_flow_table, NULL);
1015         call_rcu(&flow_table->rcu, rps_dev_flow_table_release);
1016     }
1017 #endif
1018 
1019     memset(kobj, 0, sizeof(*kobj));
1020     netdev_put(queue->dev, &queue->dev_tracker);
1021 }
1022 
1023 static const void *rx_queue_namespace(struct kobject *kobj)
1024 {
1025     struct netdev_rx_queue *queue = to_rx_queue(kobj);
1026     struct device *dev = &queue->dev->dev;
1027     const void *ns = NULL;
1028 
1029     if (dev->class && dev->class->ns_type)
1030         ns = dev->class->namespace(dev);
1031 
1032     return ns;
1033 }
1034 
1035 static void rx_queue_get_ownership(struct kobject *kobj,
1036                    kuid_t *uid, kgid_t *gid)
1037 {
1038     const struct net *net = rx_queue_namespace(kobj);
1039 
1040     net_ns_get_ownership(net, uid, gid);
1041 }
1042 
1043 static struct kobj_type rx_queue_ktype __ro_after_init = {
1044     .sysfs_ops = &rx_queue_sysfs_ops,
1045     .release = rx_queue_release,
1046     .default_groups = rx_queue_default_groups,
1047     .namespace = rx_queue_namespace,
1048     .get_ownership = rx_queue_get_ownership,
1049 };
1050 
1051 static int rx_queue_add_kobject(struct net_device *dev, int index)
1052 {
1053     struct netdev_rx_queue *queue = dev->_rx + index;
1054     struct kobject *kobj = &queue->kobj;
1055     int error = 0;
1056 
1057     /* Kobject_put later will trigger rx_queue_release call which
1058      * decreases dev refcount: Take that reference here
1059      */
1060     netdev_hold(queue->dev, &queue->dev_tracker, GFP_KERNEL);
1061 
1062     kobj->kset = dev->queues_kset;
1063     error = kobject_init_and_add(kobj, &rx_queue_ktype, NULL,
1064                      "rx-%u", index);
1065     if (error)
1066         goto err;
1067 
1068     if (dev->sysfs_rx_queue_group) {
1069         error = sysfs_create_group(kobj, dev->sysfs_rx_queue_group);
1070         if (error)
1071             goto err;
1072     }
1073 
1074     kobject_uevent(kobj, KOBJ_ADD);
1075 
1076     return error;
1077 
1078 err:
1079     kobject_put(kobj);
1080     return error;
1081 }
1082 
1083 static int rx_queue_change_owner(struct net_device *dev, int index, kuid_t kuid,
1084                  kgid_t kgid)
1085 {
1086     struct netdev_rx_queue *queue = dev->_rx + index;
1087     struct kobject *kobj = &queue->kobj;
1088     int error;
1089 
1090     error = sysfs_change_owner(kobj, kuid, kgid);
1091     if (error)
1092         return error;
1093 
1094     if (dev->sysfs_rx_queue_group)
1095         error = sysfs_group_change_owner(
1096             kobj, dev->sysfs_rx_queue_group, kuid, kgid);
1097 
1098     return error;
1099 }
1100 #endif /* CONFIG_SYSFS */
1101 
1102 int
1103 net_rx_queue_update_kobjects(struct net_device *dev, int old_num, int new_num)
1104 {
1105 #ifdef CONFIG_SYSFS
1106     int i;
1107     int error = 0;
1108 
1109 #ifndef CONFIG_RPS
1110     if (!dev->sysfs_rx_queue_group)
1111         return 0;
1112 #endif
1113     for (i = old_num; i < new_num; i++) {
1114         error = rx_queue_add_kobject(dev, i);
1115         if (error) {
1116             new_num = old_num;
1117             break;
1118         }
1119     }
1120 
1121     while (--i >= new_num) {
1122         struct kobject *kobj = &dev->_rx[i].kobj;
1123 
1124         if (!refcount_read(&dev_net(dev)->ns.count))
1125             kobj->uevent_suppress = 1;
1126         if (dev->sysfs_rx_queue_group)
1127             sysfs_remove_group(kobj, dev->sysfs_rx_queue_group);
1128         kobject_put(kobj);
1129     }
1130 
1131     return error;
1132 #else
1133     return 0;
1134 #endif
1135 }
1136 
1137 static int net_rx_queue_change_owner(struct net_device *dev, int num,
1138                      kuid_t kuid, kgid_t kgid)
1139 {
1140 #ifdef CONFIG_SYSFS
1141     int error = 0;
1142     int i;
1143 
1144 #ifndef CONFIG_RPS
1145     if (!dev->sysfs_rx_queue_group)
1146         return 0;
1147 #endif
1148     for (i = 0; i < num; i++) {
1149         error = rx_queue_change_owner(dev, i, kuid, kgid);
1150         if (error)
1151             break;
1152     }
1153 
1154     return error;
1155 #else
1156     return 0;
1157 #endif
1158 }
1159 
1160 #ifdef CONFIG_SYSFS
1161 /*
1162  * netdev_queue sysfs structures and functions.
1163  */
1164 struct netdev_queue_attribute {
1165     struct attribute attr;
1166     ssize_t (*show)(struct netdev_queue *queue, char *buf);
1167     ssize_t (*store)(struct netdev_queue *queue,
1168              const char *buf, size_t len);
1169 };
1170 #define to_netdev_queue_attr(_attr) \
1171     container_of(_attr, struct netdev_queue_attribute, attr)
1172 
1173 #define to_netdev_queue(obj) container_of(obj, struct netdev_queue, kobj)
1174 
1175 static ssize_t netdev_queue_attr_show(struct kobject *kobj,
1176                       struct attribute *attr, char *buf)
1177 {
1178     const struct netdev_queue_attribute *attribute
1179         = to_netdev_queue_attr(attr);
1180     struct netdev_queue *queue = to_netdev_queue(kobj);
1181 
1182     if (!attribute->show)
1183         return -EIO;
1184 
1185     return attribute->show(queue, buf);
1186 }
1187 
1188 static ssize_t netdev_queue_attr_store(struct kobject *kobj,
1189                        struct attribute *attr,
1190                        const char *buf, size_t count)
1191 {
1192     const struct netdev_queue_attribute *attribute
1193         = to_netdev_queue_attr(attr);
1194     struct netdev_queue *queue = to_netdev_queue(kobj);
1195 
1196     if (!attribute->store)
1197         return -EIO;
1198 
1199     return attribute->store(queue, buf, count);
1200 }
1201 
1202 static const struct sysfs_ops netdev_queue_sysfs_ops = {
1203     .show = netdev_queue_attr_show,
1204     .store = netdev_queue_attr_store,
1205 };
1206 
1207 static ssize_t tx_timeout_show(struct netdev_queue *queue, char *buf)
1208 {
1209     unsigned long trans_timeout = atomic_long_read(&queue->trans_timeout);
1210 
1211     return sprintf(buf, fmt_ulong, trans_timeout);
1212 }
1213 
1214 static unsigned int get_netdev_queue_index(struct netdev_queue *queue)
1215 {
1216     struct net_device *dev = queue->dev;
1217     unsigned int i;
1218 
1219     i = queue - dev->_tx;
1220     BUG_ON(i >= dev->num_tx_queues);
1221 
1222     return i;
1223 }
1224 
1225 static ssize_t traffic_class_show(struct netdev_queue *queue,
1226                   char *buf)
1227 {
1228     struct net_device *dev = queue->dev;
1229     int num_tc, tc;
1230     int index;
1231 
1232     if (!netif_is_multiqueue(dev))
1233         return -ENOENT;
1234 
1235     if (!rtnl_trylock())
1236         return restart_syscall();
1237 
1238     index = get_netdev_queue_index(queue);
1239 
1240     /* If queue belongs to subordinate dev use its TC mapping */
1241     dev = netdev_get_tx_queue(dev, index)->sb_dev ? : dev;
1242 
1243     num_tc = dev->num_tc;
1244     tc = netdev_txq_to_tc(dev, index);
1245 
1246     rtnl_unlock();
1247 
1248     if (tc < 0)
1249         return -EINVAL;
1250 
1251     /* We can report the traffic class one of two ways:
1252      * Subordinate device traffic classes are reported with the traffic
1253      * class first, and then the subordinate class so for example TC0 on
1254      * subordinate device 2 will be reported as "0-2". If the queue
1255      * belongs to the root device it will be reported with just the
1256      * traffic class, so just "0" for TC 0 for example.
1257      */
1258     return num_tc < 0 ? sprintf(buf, "%d%d\n", tc, num_tc) :
1259                 sprintf(buf, "%d\n", tc);
1260 }
1261 
1262 #ifdef CONFIG_XPS
1263 static ssize_t tx_maxrate_show(struct netdev_queue *queue,
1264                    char *buf)
1265 {
1266     return sprintf(buf, "%lu\n", queue->tx_maxrate);
1267 }
1268 
1269 static ssize_t tx_maxrate_store(struct netdev_queue *queue,
1270                 const char *buf, size_t len)
1271 {
1272     struct net_device *dev = queue->dev;
1273     int err, index = get_netdev_queue_index(queue);
1274     u32 rate = 0;
1275 
1276     if (!capable(CAP_NET_ADMIN))
1277         return -EPERM;
1278 
1279     /* The check is also done later; this helps returning early without
1280      * hitting the trylock/restart below.
1281      */
1282     if (!dev->netdev_ops->ndo_set_tx_maxrate)
1283         return -EOPNOTSUPP;
1284 
1285     err = kstrtou32(buf, 10, &rate);
1286     if (err < 0)
1287         return err;
1288 
1289     if (!rtnl_trylock())
1290         return restart_syscall();
1291 
1292     err = -EOPNOTSUPP;
1293     if (dev->netdev_ops->ndo_set_tx_maxrate)
1294         err = dev->netdev_ops->ndo_set_tx_maxrate(dev, index, rate);
1295 
1296     rtnl_unlock();
1297     if (!err) {
1298         queue->tx_maxrate = rate;
1299         return len;
1300     }
1301     return err;
1302 }
1303 
1304 static struct netdev_queue_attribute queue_tx_maxrate __ro_after_init
1305     = __ATTR_RW(tx_maxrate);
1306 #endif
1307 
1308 static struct netdev_queue_attribute queue_trans_timeout __ro_after_init
1309     = __ATTR_RO(tx_timeout);
1310 
1311 static struct netdev_queue_attribute queue_traffic_class __ro_after_init
1312     = __ATTR_RO(traffic_class);
1313 
1314 #ifdef CONFIG_BQL
1315 /*
1316  * Byte queue limits sysfs structures and functions.
1317  */
1318 static ssize_t bql_show(char *buf, unsigned int value)
1319 {
1320     return sprintf(buf, "%u\n", value);
1321 }
1322 
1323 static ssize_t bql_set(const char *buf, const size_t count,
1324                unsigned int *pvalue)
1325 {
1326     unsigned int value;
1327     int err;
1328 
1329     if (!strcmp(buf, "max") || !strcmp(buf, "max\n")) {
1330         value = DQL_MAX_LIMIT;
1331     } else {
1332         err = kstrtouint(buf, 10, &value);
1333         if (err < 0)
1334             return err;
1335         if (value > DQL_MAX_LIMIT)
1336             return -EINVAL;
1337     }
1338 
1339     *pvalue = value;
1340 
1341     return count;
1342 }
1343 
1344 static ssize_t bql_show_hold_time(struct netdev_queue *queue,
1345                   char *buf)
1346 {
1347     struct dql *dql = &queue->dql;
1348 
1349     return sprintf(buf, "%u\n", jiffies_to_msecs(dql->slack_hold_time));
1350 }
1351 
1352 static ssize_t bql_set_hold_time(struct netdev_queue *queue,
1353                  const char *buf, size_t len)
1354 {
1355     struct dql *dql = &queue->dql;
1356     unsigned int value;
1357     int err;
1358 
1359     err = kstrtouint(buf, 10, &value);
1360     if (err < 0)
1361         return err;
1362 
1363     dql->slack_hold_time = msecs_to_jiffies(value);
1364 
1365     return len;
1366 }
1367 
1368 static struct netdev_queue_attribute bql_hold_time_attribute __ro_after_init
1369     = __ATTR(hold_time, 0644,
1370          bql_show_hold_time, bql_set_hold_time);
1371 
1372 static ssize_t bql_show_inflight(struct netdev_queue *queue,
1373                  char *buf)
1374 {
1375     struct dql *dql = &queue->dql;
1376 
1377     return sprintf(buf, "%u\n", dql->num_queued - dql->num_completed);
1378 }
1379 
1380 static struct netdev_queue_attribute bql_inflight_attribute __ro_after_init =
1381     __ATTR(inflight, 0444, bql_show_inflight, NULL);
1382 
1383 #define BQL_ATTR(NAME, FIELD)                       \
1384 static ssize_t bql_show_ ## NAME(struct netdev_queue *queue,        \
1385                  char *buf)             \
1386 {                                   \
1387     return bql_show(buf, queue->dql.FIELD);             \
1388 }                                   \
1389                                     \
1390 static ssize_t bql_set_ ## NAME(struct netdev_queue *queue,     \
1391                 const char *buf, size_t len)        \
1392 {                                   \
1393     return bql_set(buf, len, &queue->dql.FIELD);            \
1394 }                                   \
1395                                     \
1396 static struct netdev_queue_attribute bql_ ## NAME ## _attribute __ro_after_init \
1397     = __ATTR(NAME, 0644,                \
1398          bql_show_ ## NAME, bql_set_ ## NAME)
1399 
1400 BQL_ATTR(limit, limit);
1401 BQL_ATTR(limit_max, max_limit);
1402 BQL_ATTR(limit_min, min_limit);
1403 
1404 static struct attribute *dql_attrs[] __ro_after_init = {
1405     &bql_limit_attribute.attr,
1406     &bql_limit_max_attribute.attr,
1407     &bql_limit_min_attribute.attr,
1408     &bql_hold_time_attribute.attr,
1409     &bql_inflight_attribute.attr,
1410     NULL
1411 };
1412 
1413 static const struct attribute_group dql_group = {
1414     .name  = "byte_queue_limits",
1415     .attrs  = dql_attrs,
1416 };
1417 #endif /* CONFIG_BQL */
1418 
1419 #ifdef CONFIG_XPS
1420 static ssize_t xps_queue_show(struct net_device *dev, unsigned int index,
1421                   int tc, char *buf, enum xps_map_type type)
1422 {
1423     struct xps_dev_maps *dev_maps;
1424     unsigned long *mask;
1425     unsigned int nr_ids;
1426     int j, len;
1427 
1428     rcu_read_lock();
1429     dev_maps = rcu_dereference(dev->xps_maps[type]);
1430 
1431     /* Default to nr_cpu_ids/dev->num_rx_queues and do not just return 0
1432      * when dev_maps hasn't been allocated yet, to be backward compatible.
1433      */
1434     nr_ids = dev_maps ? dev_maps->nr_ids :
1435          (type == XPS_CPUS ? nr_cpu_ids : dev->num_rx_queues);
1436 
1437     mask = bitmap_zalloc(nr_ids, GFP_NOWAIT);
1438     if (!mask) {
1439         rcu_read_unlock();
1440         return -ENOMEM;
1441     }
1442 
1443     if (!dev_maps || tc >= dev_maps->num_tc)
1444         goto out_no_maps;
1445 
1446     for (j = 0; j < nr_ids; j++) {
1447         int i, tci = j * dev_maps->num_tc + tc;
1448         struct xps_map *map;
1449 
1450         map = rcu_dereference(dev_maps->attr_map[tci]);
1451         if (!map)
1452             continue;
1453 
1454         for (i = map->len; i--;) {
1455             if (map->queues[i] == index) {
1456                 __set_bit(j, mask);
1457                 break;
1458             }
1459         }
1460     }
1461 out_no_maps:
1462     rcu_read_unlock();
1463 
1464     len = bitmap_print_to_pagebuf(false, buf, mask, nr_ids);
1465     bitmap_free(mask);
1466 
1467     return len < PAGE_SIZE ? len : -EINVAL;
1468 }
1469 
1470 static ssize_t xps_cpus_show(struct netdev_queue *queue, char *buf)
1471 {
1472     struct net_device *dev = queue->dev;
1473     unsigned int index;
1474     int len, tc;
1475 
1476     if (!netif_is_multiqueue(dev))
1477         return -ENOENT;
1478 
1479     index = get_netdev_queue_index(queue);
1480 
1481     if (!rtnl_trylock())
1482         return restart_syscall();
1483 
1484     /* If queue belongs to subordinate dev use its map */
1485     dev = netdev_get_tx_queue(dev, index)->sb_dev ? : dev;
1486 
1487     tc = netdev_txq_to_tc(dev, index);
1488     if (tc < 0) {
1489         rtnl_unlock();
1490         return -EINVAL;
1491     }
1492 
1493     /* Make sure the subordinate device can't be freed */
1494     get_device(&dev->dev);
1495     rtnl_unlock();
1496 
1497     len = xps_queue_show(dev, index, tc, buf, XPS_CPUS);
1498 
1499     put_device(&dev->dev);
1500     return len;
1501 }
1502 
1503 static ssize_t xps_cpus_store(struct netdev_queue *queue,
1504                   const char *buf, size_t len)
1505 {
1506     struct net_device *dev = queue->dev;
1507     unsigned int index;
1508     cpumask_var_t mask;
1509     int err;
1510 
1511     if (!netif_is_multiqueue(dev))
1512         return -ENOENT;
1513 
1514     if (!capable(CAP_NET_ADMIN))
1515         return -EPERM;
1516 
1517     if (!alloc_cpumask_var(&mask, GFP_KERNEL))
1518         return -ENOMEM;
1519 
1520     index = get_netdev_queue_index(queue);
1521 
1522     err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits);
1523     if (err) {
1524         free_cpumask_var(mask);
1525         return err;
1526     }
1527 
1528     if (!rtnl_trylock()) {
1529         free_cpumask_var(mask);
1530         return restart_syscall();
1531     }
1532 
1533     err = netif_set_xps_queue(dev, mask, index);
1534     rtnl_unlock();
1535 
1536     free_cpumask_var(mask);
1537 
1538     return err ? : len;
1539 }
1540 
1541 static struct netdev_queue_attribute xps_cpus_attribute __ro_after_init
1542     = __ATTR_RW(xps_cpus);
1543 
1544 static ssize_t xps_rxqs_show(struct netdev_queue *queue, char *buf)
1545 {
1546     struct net_device *dev = queue->dev;
1547     unsigned int index;
1548     int tc;
1549 
1550     index = get_netdev_queue_index(queue);
1551 
1552     if (!rtnl_trylock())
1553         return restart_syscall();
1554 
1555     tc = netdev_txq_to_tc(dev, index);
1556     rtnl_unlock();
1557     if (tc < 0)
1558         return -EINVAL;
1559 
1560     return xps_queue_show(dev, index, tc, buf, XPS_RXQS);
1561 }
1562 
1563 static ssize_t xps_rxqs_store(struct netdev_queue *queue, const char *buf,
1564                   size_t len)
1565 {
1566     struct net_device *dev = queue->dev;
1567     struct net *net = dev_net(dev);
1568     unsigned long *mask;
1569     unsigned int index;
1570     int err;
1571 
1572     if (!ns_capable(net->user_ns, CAP_NET_ADMIN))
1573         return -EPERM;
1574 
1575     mask = bitmap_zalloc(dev->num_rx_queues, GFP_KERNEL);
1576     if (!mask)
1577         return -ENOMEM;
1578 
1579     index = get_netdev_queue_index(queue);
1580 
1581     err = bitmap_parse(buf, len, mask, dev->num_rx_queues);
1582     if (err) {
1583         bitmap_free(mask);
1584         return err;
1585     }
1586 
1587     if (!rtnl_trylock()) {
1588         bitmap_free(mask);
1589         return restart_syscall();
1590     }
1591 
1592     cpus_read_lock();
1593     err = __netif_set_xps_queue(dev, mask, index, XPS_RXQS);
1594     cpus_read_unlock();
1595 
1596     rtnl_unlock();
1597 
1598     bitmap_free(mask);
1599     return err ? : len;
1600 }
1601 
1602 static struct netdev_queue_attribute xps_rxqs_attribute __ro_after_init
1603     = __ATTR_RW(xps_rxqs);
1604 #endif /* CONFIG_XPS */
1605 
1606 static struct attribute *netdev_queue_default_attrs[] __ro_after_init = {
1607     &queue_trans_timeout.attr,
1608     &queue_traffic_class.attr,
1609 #ifdef CONFIG_XPS
1610     &xps_cpus_attribute.attr,
1611     &xps_rxqs_attribute.attr,
1612     &queue_tx_maxrate.attr,
1613 #endif
1614     NULL
1615 };
1616 ATTRIBUTE_GROUPS(netdev_queue_default);
1617 
1618 static void netdev_queue_release(struct kobject *kobj)
1619 {
1620     struct netdev_queue *queue = to_netdev_queue(kobj);
1621 
1622     memset(kobj, 0, sizeof(*kobj));
1623     netdev_put(queue->dev, &queue->dev_tracker);
1624 }
1625 
1626 static const void *netdev_queue_namespace(struct kobject *kobj)
1627 {
1628     struct netdev_queue *queue = to_netdev_queue(kobj);
1629     struct device *dev = &queue->dev->dev;
1630     const void *ns = NULL;
1631 
1632     if (dev->class && dev->class->ns_type)
1633         ns = dev->class->namespace(dev);
1634 
1635     return ns;
1636 }
1637 
1638 static void netdev_queue_get_ownership(struct kobject *kobj,
1639                        kuid_t *uid, kgid_t *gid)
1640 {
1641     const struct net *net = netdev_queue_namespace(kobj);
1642 
1643     net_ns_get_ownership(net, uid, gid);
1644 }
1645 
1646 static struct kobj_type netdev_queue_ktype __ro_after_init = {
1647     .sysfs_ops = &netdev_queue_sysfs_ops,
1648     .release = netdev_queue_release,
1649     .default_groups = netdev_queue_default_groups,
1650     .namespace = netdev_queue_namespace,
1651     .get_ownership = netdev_queue_get_ownership,
1652 };
1653 
1654 static int netdev_queue_add_kobject(struct net_device *dev, int index)
1655 {
1656     struct netdev_queue *queue = dev->_tx + index;
1657     struct kobject *kobj = &queue->kobj;
1658     int error = 0;
1659 
1660     /* Kobject_put later will trigger netdev_queue_release call
1661      * which decreases dev refcount: Take that reference here
1662      */
1663     netdev_hold(queue->dev, &queue->dev_tracker, GFP_KERNEL);
1664 
1665     kobj->kset = dev->queues_kset;
1666     error = kobject_init_and_add(kobj, &netdev_queue_ktype, NULL,
1667                      "tx-%u", index);
1668     if (error)
1669         goto err;
1670 
1671 #ifdef CONFIG_BQL
1672     error = sysfs_create_group(kobj, &dql_group);
1673     if (error)
1674         goto err;
1675 #endif
1676 
1677     kobject_uevent(kobj, KOBJ_ADD);
1678     return 0;
1679 
1680 err:
1681     kobject_put(kobj);
1682     return error;
1683 }
1684 
1685 static int tx_queue_change_owner(struct net_device *ndev, int index,
1686                  kuid_t kuid, kgid_t kgid)
1687 {
1688     struct netdev_queue *queue = ndev->_tx + index;
1689     struct kobject *kobj = &queue->kobj;
1690     int error;
1691 
1692     error = sysfs_change_owner(kobj, kuid, kgid);
1693     if (error)
1694         return error;
1695 
1696 #ifdef CONFIG_BQL
1697     error = sysfs_group_change_owner(kobj, &dql_group, kuid, kgid);
1698 #endif
1699     return error;
1700 }
1701 #endif /* CONFIG_SYSFS */
1702 
1703 int
1704 netdev_queue_update_kobjects(struct net_device *dev, int old_num, int new_num)
1705 {
1706 #ifdef CONFIG_SYSFS
1707     int i;
1708     int error = 0;
1709 
1710     /* Tx queue kobjects are allowed to be updated when a device is being
1711      * unregistered, but solely to remove queues from qdiscs. Any path
1712      * adding queues should be fixed.
1713      */
1714     WARN(dev->reg_state == NETREG_UNREGISTERING && new_num > old_num,
1715          "New queues can't be registered after device unregistration.");
1716 
1717     for (i = old_num; i < new_num; i++) {
1718         error = netdev_queue_add_kobject(dev, i);
1719         if (error) {
1720             new_num = old_num;
1721             break;
1722         }
1723     }
1724 
1725     while (--i >= new_num) {
1726         struct netdev_queue *queue = dev->_tx + i;
1727 
1728         if (!refcount_read(&dev_net(dev)->ns.count))
1729             queue->kobj.uevent_suppress = 1;
1730 #ifdef CONFIG_BQL
1731         sysfs_remove_group(&queue->kobj, &dql_group);
1732 #endif
1733         kobject_put(&queue->kobj);
1734     }
1735 
1736     return error;
1737 #else
1738     return 0;
1739 #endif /* CONFIG_SYSFS */
1740 }
1741 
1742 static int net_tx_queue_change_owner(struct net_device *dev, int num,
1743                      kuid_t kuid, kgid_t kgid)
1744 {
1745 #ifdef CONFIG_SYSFS
1746     int error = 0;
1747     int i;
1748 
1749     for (i = 0; i < num; i++) {
1750         error = tx_queue_change_owner(dev, i, kuid, kgid);
1751         if (error)
1752             break;
1753     }
1754 
1755     return error;
1756 #else
1757     return 0;
1758 #endif /* CONFIG_SYSFS */
1759 }
1760 
1761 static int register_queue_kobjects(struct net_device *dev)
1762 {
1763     int error = 0, txq = 0, rxq = 0, real_rx = 0, real_tx = 0;
1764 
1765 #ifdef CONFIG_SYSFS
1766     dev->queues_kset = kset_create_and_add("queues",
1767                            NULL, &dev->dev.kobj);
1768     if (!dev->queues_kset)
1769         return -ENOMEM;
1770     real_rx = dev->real_num_rx_queues;
1771 #endif
1772     real_tx = dev->real_num_tx_queues;
1773 
1774     error = net_rx_queue_update_kobjects(dev, 0, real_rx);
1775     if (error)
1776         goto error;
1777     rxq = real_rx;
1778 
1779     error = netdev_queue_update_kobjects(dev, 0, real_tx);
1780     if (error)
1781         goto error;
1782     txq = real_tx;
1783 
1784     return 0;
1785 
1786 error:
1787     netdev_queue_update_kobjects(dev, txq, 0);
1788     net_rx_queue_update_kobjects(dev, rxq, 0);
1789 #ifdef CONFIG_SYSFS
1790     kset_unregister(dev->queues_kset);
1791 #endif
1792     return error;
1793 }
1794 
1795 static int queue_change_owner(struct net_device *ndev, kuid_t kuid, kgid_t kgid)
1796 {
1797     int error = 0, real_rx = 0, real_tx = 0;
1798 
1799 #ifdef CONFIG_SYSFS
1800     if (ndev->queues_kset) {
1801         error = sysfs_change_owner(&ndev->queues_kset->kobj, kuid, kgid);
1802         if (error)
1803             return error;
1804     }
1805     real_rx = ndev->real_num_rx_queues;
1806 #endif
1807     real_tx = ndev->real_num_tx_queues;
1808 
1809     error = net_rx_queue_change_owner(ndev, real_rx, kuid, kgid);
1810     if (error)
1811         return error;
1812 
1813     error = net_tx_queue_change_owner(ndev, real_tx, kuid, kgid);
1814     if (error)
1815         return error;
1816 
1817     return 0;
1818 }
1819 
1820 static void remove_queue_kobjects(struct net_device *dev)
1821 {
1822     int real_rx = 0, real_tx = 0;
1823 
1824 #ifdef CONFIG_SYSFS
1825     real_rx = dev->real_num_rx_queues;
1826 #endif
1827     real_tx = dev->real_num_tx_queues;
1828 
1829     net_rx_queue_update_kobjects(dev, real_rx, 0);
1830     netdev_queue_update_kobjects(dev, real_tx, 0);
1831 
1832     dev->real_num_rx_queues = 0;
1833     dev->real_num_tx_queues = 0;
1834 #ifdef CONFIG_SYSFS
1835     kset_unregister(dev->queues_kset);
1836 #endif
1837 }
1838 
1839 static bool net_current_may_mount(void)
1840 {
1841     struct net *net = current->nsproxy->net_ns;
1842 
1843     return ns_capable(net->user_ns, CAP_SYS_ADMIN);
1844 }
1845 
1846 static void *net_grab_current_ns(void)
1847 {
1848     struct net *ns = current->nsproxy->net_ns;
1849 #ifdef CONFIG_NET_NS
1850     if (ns)
1851         refcount_inc(&ns->passive);
1852 #endif
1853     return ns;
1854 }
1855 
1856 static const void *net_initial_ns(void)
1857 {
1858     return &init_net;
1859 }
1860 
1861 static const void *net_netlink_ns(struct sock *sk)
1862 {
1863     return sock_net(sk);
1864 }
1865 
1866 const struct kobj_ns_type_operations net_ns_type_operations = {
1867     .type = KOBJ_NS_TYPE_NET,
1868     .current_may_mount = net_current_may_mount,
1869     .grab_current_ns = net_grab_current_ns,
1870     .netlink_ns = net_netlink_ns,
1871     .initial_ns = net_initial_ns,
1872     .drop_ns = net_drop_ns,
1873 };
1874 EXPORT_SYMBOL_GPL(net_ns_type_operations);
1875 
1876 static int netdev_uevent(struct device *d, struct kobj_uevent_env *env)
1877 {
1878     struct net_device *dev = to_net_dev(d);
1879     int retval;
1880 
1881     /* pass interface to uevent. */
1882     retval = add_uevent_var(env, "INTERFACE=%s", dev->name);
1883     if (retval)
1884         goto exit;
1885 
1886     /* pass ifindex to uevent.
1887      * ifindex is useful as it won't change (interface name may change)
1888      * and is what RtNetlink uses natively.
1889      */
1890     retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex);
1891 
1892 exit:
1893     return retval;
1894 }
1895 
1896 /*
1897  *  netdev_release -- destroy and free a dead device.
1898  *  Called when last reference to device kobject is gone.
1899  */
1900 static void netdev_release(struct device *d)
1901 {
1902     struct net_device *dev = to_net_dev(d);
1903 
1904     BUG_ON(dev->reg_state != NETREG_RELEASED);
1905 
1906     /* no need to wait for rcu grace period:
1907      * device is dead and about to be freed.
1908      */
1909     kfree(rcu_access_pointer(dev->ifalias));
1910     netdev_freemem(dev);
1911 }
1912 
1913 static const void *net_namespace(struct device *d)
1914 {
1915     struct net_device *dev = to_net_dev(d);
1916 
1917     return dev_net(dev);
1918 }
1919 
1920 static void net_get_ownership(struct device *d, kuid_t *uid, kgid_t *gid)
1921 {
1922     struct net_device *dev = to_net_dev(d);
1923     const struct net *net = dev_net(dev);
1924 
1925     net_ns_get_ownership(net, uid, gid);
1926 }
1927 
1928 static struct class net_class __ro_after_init = {
1929     .name = "net",
1930     .dev_release = netdev_release,
1931     .dev_groups = net_class_groups,
1932     .dev_uevent = netdev_uevent,
1933     .ns_type = &net_ns_type_operations,
1934     .namespace = net_namespace,
1935     .get_ownership = net_get_ownership,
1936 };
1937 
1938 #ifdef CONFIG_OF
1939 static int of_dev_node_match(struct device *dev, const void *data)
1940 {
1941     for (; dev; dev = dev->parent) {
1942         if (dev->of_node == data)
1943             return 1;
1944     }
1945 
1946     return 0;
1947 }
1948 
1949 /*
1950  * of_find_net_device_by_node - lookup the net device for the device node
1951  * @np: OF device node
1952  *
1953  * Looks up the net_device structure corresponding with the device node.
1954  * If successful, returns a pointer to the net_device with the embedded
1955  * struct device refcount incremented by one, or NULL on failure. The
1956  * refcount must be dropped when done with the net_device.
1957  */
1958 struct net_device *of_find_net_device_by_node(struct device_node *np)
1959 {
1960     struct device *dev;
1961 
1962     dev = class_find_device(&net_class, NULL, np, of_dev_node_match);
1963     if (!dev)
1964         return NULL;
1965 
1966     return to_net_dev(dev);
1967 }
1968 EXPORT_SYMBOL(of_find_net_device_by_node);
1969 #endif
1970 
1971 /* Delete sysfs entries but hold kobject reference until after all
1972  * netdev references are gone.
1973  */
1974 void netdev_unregister_kobject(struct net_device *ndev)
1975 {
1976     struct device *dev = &ndev->dev;
1977 
1978     if (!refcount_read(&dev_net(ndev)->ns.count))
1979         dev_set_uevent_suppress(dev, 1);
1980 
1981     kobject_get(&dev->kobj);
1982 
1983     remove_queue_kobjects(ndev);
1984 
1985     pm_runtime_set_memalloc_noio(dev, false);
1986 
1987     device_del(dev);
1988 }
1989 
1990 /* Create sysfs entries for network device. */
1991 int netdev_register_kobject(struct net_device *ndev)
1992 {
1993     struct device *dev = &ndev->dev;
1994     const struct attribute_group **groups = ndev->sysfs_groups;
1995     int error = 0;
1996 
1997     device_initialize(dev);
1998     dev->class = &net_class;
1999     dev->platform_data = ndev;
2000     dev->groups = groups;
2001 
2002     dev_set_name(dev, "%s", ndev->name);
2003 
2004 #ifdef CONFIG_SYSFS
2005     /* Allow for a device specific group */
2006     if (*groups)
2007         groups++;
2008 
2009     *groups++ = &netstat_group;
2010 
2011     if (wireless_group_needed(ndev))
2012         *groups++ = &wireless_group;
2013 #endif /* CONFIG_SYSFS */
2014 
2015     error = device_add(dev);
2016     if (error)
2017         return error;
2018 
2019     error = register_queue_kobjects(ndev);
2020     if (error) {
2021         device_del(dev);
2022         return error;
2023     }
2024 
2025     pm_runtime_set_memalloc_noio(dev, true);
2026 
2027     return error;
2028 }
2029 
2030 /* Change owner for sysfs entries when moving network devices across network
2031  * namespaces owned by different user namespaces.
2032  */
2033 int netdev_change_owner(struct net_device *ndev, const struct net *net_old,
2034             const struct net *net_new)
2035 {
2036     kuid_t old_uid = GLOBAL_ROOT_UID, new_uid = GLOBAL_ROOT_UID;
2037     kgid_t old_gid = GLOBAL_ROOT_GID, new_gid = GLOBAL_ROOT_GID;
2038     struct device *dev = &ndev->dev;
2039     int error;
2040 
2041     net_ns_get_ownership(net_old, &old_uid, &old_gid);
2042     net_ns_get_ownership(net_new, &new_uid, &new_gid);
2043 
2044     /* The network namespace was changed but the owning user namespace is
2045      * identical so there's no need to change the owner of sysfs entries.
2046      */
2047     if (uid_eq(old_uid, new_uid) && gid_eq(old_gid, new_gid))
2048         return 0;
2049 
2050     error = device_change_owner(dev, new_uid, new_gid);
2051     if (error)
2052         return error;
2053 
2054     error = queue_change_owner(ndev, new_uid, new_gid);
2055     if (error)
2056         return error;
2057 
2058     return 0;
2059 }
2060 
2061 int netdev_class_create_file_ns(const struct class_attribute *class_attr,
2062                 const void *ns)
2063 {
2064     return class_create_file_ns(&net_class, class_attr, ns);
2065 }
2066 EXPORT_SYMBOL(netdev_class_create_file_ns);
2067 
2068 void netdev_class_remove_file_ns(const struct class_attribute *class_attr,
2069                  const void *ns)
2070 {
2071     class_remove_file_ns(&net_class, class_attr, ns);
2072 }
2073 EXPORT_SYMBOL(netdev_class_remove_file_ns);
2074 
2075 int __init netdev_kobject_init(void)
2076 {
2077     kobj_ns_type_register(&net_ns_type_operations);
2078     return class_register(&net_class);
2079 }
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!