Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 2 | * net-sysfs.c - network device class and attributes |
| 3 | * |
| 4 | * Copyright (c) 2003 Stephen Hemminger <shemminger@osdl.org> |
YOSHIFUJI Hideaki | 4ec93ed | 2007-02-09 23:24:36 +0900 | [diff] [blame] | 5 | * |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 6 | * This program is free software; you can redistribute it and/or |
| 7 | * modify it under the terms of the GNU General Public License |
| 8 | * as published by the Free Software Foundation; either version |
| 9 | * 2 of the License, or (at your option) any later version. |
| 10 | */ |
| 11 | |
Randy Dunlap | 4fc268d | 2006-01-11 12:17:47 -0800 | [diff] [blame] | 12 | #include <linux/capability.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include <linux/kernel.h> |
| 14 | #include <linux/netdevice.h> |
| 15 | #include <linux/if_arp.h> |
Tejun Heo | 5a0e3ad | 2010-03-24 17:04:11 +0900 | [diff] [blame] | 16 | #include <linux/slab.h> |
Eric W. Biederman | 608b4b9 | 2010-05-04 17:36:45 -0700 | [diff] [blame] | 17 | #include <linux/nsproxy.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 18 | #include <net/sock.h> |
Eric W. Biederman | 608b4b9 | 2010-05-04 17:36:45 -0700 | [diff] [blame] | 19 | #include <net/net_namespace.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 20 | #include <linux/rtnetlink.h> |
| 21 | #include <linux/wireless.h> |
Tom Herbert | fec5e65 | 2010-04-16 16:01:27 -0700 | [diff] [blame] | 22 | #include <linux/vmalloc.h> |
Johannes Berg | 8f1546c | 2009-09-28 15:26:43 +0200 | [diff] [blame] | 23 | #include <net/wext.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 24 | |
Pavel Emelyanov | 342709e | 2007-10-23 21:14:45 -0700 | [diff] [blame] | 25 | #include "net-sysfs.h" |
| 26 | |
Eric W. Biederman | 8b41d18 | 2007-09-26 22:02:53 -0700 | [diff] [blame] | 27 | #ifdef CONFIG_SYSFS |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 28 | static const char fmt_hex[] = "%#x\n"; |
David S. Miller | d1102b5 | 2005-05-29 20:28:25 -0700 | [diff] [blame] | 29 | static const char fmt_long_hex[] = "%#lx\n"; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | static const char fmt_dec[] = "%d\n"; |
| 31 | static const char fmt_ulong[] = "%lu\n"; |
Ben Hutchings | be1f3c2 | 2010-06-08 07:19:54 +0000 | [diff] [blame] | 32 | static const char fmt_u64[] = "%llu\n"; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 33 | |
YOSHIFUJI Hideaki | 4ec93ed | 2007-02-09 23:24:36 +0900 | [diff] [blame] | 34 | static inline int dev_isalive(const struct net_device *dev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 35 | { |
Stephen Hemminger | fe9925b | 2006-05-06 17:56:03 -0700 | [diff] [blame] | 36 | return dev->reg_state <= NETREG_REGISTERED; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | } |
| 38 | |
| 39 | /* use same locking rules as GIF* ioctl's */ |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 40 | static ssize_t netdev_show(const struct device *dev, |
| 41 | struct device_attribute *attr, char *buf, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 42 | ssize_t (*format)(const struct net_device *, char *)) |
| 43 | { |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 44 | struct net_device *net = to_net_dev(dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 45 | ssize_t ret = -EINVAL; |
| 46 | |
| 47 | read_lock(&dev_base_lock); |
| 48 | if (dev_isalive(net)) |
| 49 | ret = (*format)(net, buf); |
| 50 | read_unlock(&dev_base_lock); |
| 51 | |
| 52 | return ret; |
| 53 | } |
| 54 | |
| 55 | /* generate a show function for simple field */ |
| 56 | #define NETDEVICE_SHOW(field, format_string) \ |
| 57 | static ssize_t format_##field(const struct net_device *net, char *buf) \ |
| 58 | { \ |
| 59 | return sprintf(buf, format_string, net->field); \ |
| 60 | } \ |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 61 | static ssize_t show_##field(struct device *dev, \ |
| 62 | struct device_attribute *attr, char *buf) \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 63 | { \ |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 64 | return netdev_show(dev, attr, buf, format_##field); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 65 | } |
| 66 | |
| 67 | |
| 68 | /* use same locking and permission rules as SIF* ioctl's */ |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 69 | static ssize_t netdev_store(struct device *dev, struct device_attribute *attr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 70 | const char *buf, size_t len, |
| 71 | int (*set)(struct net_device *, unsigned long)) |
| 72 | { |
| 73 | struct net_device *net = to_net_dev(dev); |
| 74 | char *endp; |
| 75 | unsigned long new; |
| 76 | int ret = -EINVAL; |
| 77 | |
| 78 | if (!capable(CAP_NET_ADMIN)) |
| 79 | return -EPERM; |
| 80 | |
| 81 | new = simple_strtoul(buf, &endp, 0); |
| 82 | if (endp == buf) |
| 83 | goto err; |
| 84 | |
Stephen Hemminger | 5a5990d | 2009-02-26 06:49:24 +0000 | [diff] [blame] | 85 | if (!rtnl_trylock()) |
Eric W. Biederman | 336ca57 | 2009-05-13 16:57:25 +0000 | [diff] [blame] | 86 | return restart_syscall(); |
Stephen Hemminger | 5a5990d | 2009-02-26 06:49:24 +0000 | [diff] [blame] | 87 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 88 | if (dev_isalive(net)) { |
| 89 | if ((ret = (*set)(net, new)) == 0) |
| 90 | ret = len; |
| 91 | } |
| 92 | rtnl_unlock(); |
| 93 | err: |
| 94 | return ret; |
| 95 | } |
| 96 | |
David Woodhouse | 9d29672 | 2008-04-20 16:07:43 -0700 | [diff] [blame] | 97 | NETDEVICE_SHOW(dev_id, fmt_hex); |
Stefan Assmann | c1f7942 | 2010-07-22 02:50:21 +0000 | [diff] [blame] | 98 | NETDEVICE_SHOW(addr_assign_type, fmt_dec); |
Kay Sievers | fd586ba | 2005-12-19 01:42:56 +0100 | [diff] [blame] | 99 | NETDEVICE_SHOW(addr_len, fmt_dec); |
| 100 | NETDEVICE_SHOW(iflink, fmt_dec); |
| 101 | NETDEVICE_SHOW(ifindex, fmt_dec); |
| 102 | NETDEVICE_SHOW(features, fmt_long_hex); |
| 103 | NETDEVICE_SHOW(type, fmt_dec); |
Stefan Rompf | b00055a | 2006-03-20 17:09:11 -0800 | [diff] [blame] | 104 | NETDEVICE_SHOW(link_mode, fmt_dec); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 105 | |
| 106 | /* use same locking rules as GIFHWADDR ioctl's */ |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 107 | static ssize_t show_address(struct device *dev, struct device_attribute *attr, |
| 108 | char *buf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 109 | { |
| 110 | struct net_device *net = to_net_dev(dev); |
| 111 | ssize_t ret = -EINVAL; |
| 112 | |
| 113 | read_lock(&dev_base_lock); |
| 114 | if (dev_isalive(net)) |
Michael Chan | 7ffc49a | 2007-12-24 21:28:09 -0800 | [diff] [blame] | 115 | ret = sysfs_format_mac(buf, net->dev_addr, net->addr_len); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 116 | read_unlock(&dev_base_lock); |
| 117 | return ret; |
| 118 | } |
| 119 | |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 120 | static ssize_t show_broadcast(struct device *dev, |
| 121 | struct device_attribute *attr, char *buf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 122 | { |
| 123 | struct net_device *net = to_net_dev(dev); |
| 124 | if (dev_isalive(net)) |
Michael Chan | 7ffc49a | 2007-12-24 21:28:09 -0800 | [diff] [blame] | 125 | return sysfs_format_mac(buf, net->broadcast, net->addr_len); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | return -EINVAL; |
| 127 | } |
| 128 | |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 129 | static ssize_t show_carrier(struct device *dev, |
| 130 | struct device_attribute *attr, char *buf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 131 | { |
| 132 | struct net_device *netdev = to_net_dev(dev); |
| 133 | if (netif_running(netdev)) { |
| 134 | return sprintf(buf, fmt_dec, !!netif_carrier_ok(netdev)); |
| 135 | } |
| 136 | return -EINVAL; |
| 137 | } |
| 138 | |
Andy Gospodarek | d519e17 | 2009-10-02 09:26:12 +0000 | [diff] [blame] | 139 | static ssize_t show_speed(struct device *dev, |
| 140 | struct device_attribute *attr, char *buf) |
| 141 | { |
| 142 | struct net_device *netdev = to_net_dev(dev); |
| 143 | int ret = -EINVAL; |
| 144 | |
| 145 | if (!rtnl_trylock()) |
| 146 | return restart_syscall(); |
| 147 | |
Eric Dumazet | ac5e3af | 2009-10-26 01:23:33 +0000 | [diff] [blame] | 148 | if (netif_running(netdev) && |
| 149 | netdev->ethtool_ops && |
| 150 | netdev->ethtool_ops->get_settings) { |
Andy Gospodarek | d519e17 | 2009-10-02 09:26:12 +0000 | [diff] [blame] | 151 | struct ethtool_cmd cmd = { ETHTOOL_GSET }; |
| 152 | |
| 153 | if (!netdev->ethtool_ops->get_settings(netdev, &cmd)) |
| 154 | ret = sprintf(buf, fmt_dec, ethtool_cmd_speed(&cmd)); |
| 155 | } |
| 156 | rtnl_unlock(); |
| 157 | return ret; |
| 158 | } |
| 159 | |
| 160 | static ssize_t show_duplex(struct device *dev, |
| 161 | struct device_attribute *attr, char *buf) |
| 162 | { |
| 163 | struct net_device *netdev = to_net_dev(dev); |
| 164 | int ret = -EINVAL; |
| 165 | |
| 166 | if (!rtnl_trylock()) |
| 167 | return restart_syscall(); |
| 168 | |
Eric Dumazet | ac5e3af | 2009-10-26 01:23:33 +0000 | [diff] [blame] | 169 | if (netif_running(netdev) && |
| 170 | netdev->ethtool_ops && |
| 171 | netdev->ethtool_ops->get_settings) { |
Andy Gospodarek | d519e17 | 2009-10-02 09:26:12 +0000 | [diff] [blame] | 172 | struct ethtool_cmd cmd = { ETHTOOL_GSET }; |
| 173 | |
| 174 | if (!netdev->ethtool_ops->get_settings(netdev, &cmd)) |
| 175 | ret = sprintf(buf, "%s\n", cmd.duplex ? "full" : "half"); |
| 176 | } |
| 177 | rtnl_unlock(); |
| 178 | return ret; |
| 179 | } |
| 180 | |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 181 | static ssize_t show_dormant(struct device *dev, |
| 182 | struct device_attribute *attr, char *buf) |
Stefan Rompf | b00055a | 2006-03-20 17:09:11 -0800 | [diff] [blame] | 183 | { |
| 184 | struct net_device *netdev = to_net_dev(dev); |
| 185 | |
| 186 | if (netif_running(netdev)) |
| 187 | return sprintf(buf, fmt_dec, !!netif_dormant(netdev)); |
| 188 | |
| 189 | return -EINVAL; |
| 190 | } |
| 191 | |
Jan Engelhardt | 36cbd3d | 2009-08-05 10:42:58 -0700 | [diff] [blame] | 192 | static const char *const operstates[] = { |
Stefan Rompf | b00055a | 2006-03-20 17:09:11 -0800 | [diff] [blame] | 193 | "unknown", |
| 194 | "notpresent", /* currently unused */ |
| 195 | "down", |
| 196 | "lowerlayerdown", |
| 197 | "testing", /* currently unused */ |
| 198 | "dormant", |
| 199 | "up" |
| 200 | }; |
| 201 | |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 202 | static ssize_t show_operstate(struct device *dev, |
| 203 | struct device_attribute *attr, char *buf) |
Stefan Rompf | b00055a | 2006-03-20 17:09:11 -0800 | [diff] [blame] | 204 | { |
| 205 | const struct net_device *netdev = to_net_dev(dev); |
| 206 | unsigned char operstate; |
| 207 | |
| 208 | read_lock(&dev_base_lock); |
| 209 | operstate = netdev->operstate; |
| 210 | if (!netif_running(netdev)) |
| 211 | operstate = IF_OPER_DOWN; |
| 212 | read_unlock(&dev_base_lock); |
| 213 | |
Adrian Bunk | e3a5cd9 | 2006-04-05 22:19:47 -0700 | [diff] [blame] | 214 | if (operstate >= ARRAY_SIZE(operstates)) |
Stefan Rompf | b00055a | 2006-03-20 17:09:11 -0800 | [diff] [blame] | 215 | return -EINVAL; /* should not happen */ |
| 216 | |
| 217 | return sprintf(buf, "%s\n", operstates[operstate]); |
| 218 | } |
| 219 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 220 | /* read-write attributes */ |
| 221 | NETDEVICE_SHOW(mtu, fmt_dec); |
| 222 | |
| 223 | static int change_mtu(struct net_device *net, unsigned long new_mtu) |
| 224 | { |
| 225 | return dev_set_mtu(net, (int) new_mtu); |
| 226 | } |
| 227 | |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 228 | static ssize_t store_mtu(struct device *dev, struct device_attribute *attr, |
| 229 | const char *buf, size_t len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 230 | { |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 231 | return netdev_store(dev, attr, buf, len, change_mtu); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 232 | } |
| 233 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 234 | NETDEVICE_SHOW(flags, fmt_hex); |
| 235 | |
| 236 | static int change_flags(struct net_device *net, unsigned long new_flags) |
| 237 | { |
| 238 | return dev_change_flags(net, (unsigned) new_flags); |
| 239 | } |
| 240 | |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 241 | static ssize_t store_flags(struct device *dev, struct device_attribute *attr, |
| 242 | const char *buf, size_t len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 243 | { |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 244 | return netdev_store(dev, attr, buf, len, change_flags); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 245 | } |
| 246 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 247 | NETDEVICE_SHOW(tx_queue_len, fmt_ulong); |
| 248 | |
| 249 | static int change_tx_queue_len(struct net_device *net, unsigned long new_len) |
| 250 | { |
| 251 | net->tx_queue_len = new_len; |
| 252 | return 0; |
| 253 | } |
| 254 | |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 255 | static ssize_t store_tx_queue_len(struct device *dev, |
| 256 | struct device_attribute *attr, |
| 257 | const char *buf, size_t len) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 258 | { |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 259 | return netdev_store(dev, attr, buf, len, change_tx_queue_len); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 260 | } |
| 261 | |
Stephen Hemminger | 0b815a1 | 2008-09-22 21:28:11 -0700 | [diff] [blame] | 262 | static ssize_t store_ifalias(struct device *dev, struct device_attribute *attr, |
| 263 | const char *buf, size_t len) |
| 264 | { |
| 265 | struct net_device *netdev = to_net_dev(dev); |
| 266 | size_t count = len; |
| 267 | ssize_t ret; |
| 268 | |
| 269 | if (!capable(CAP_NET_ADMIN)) |
| 270 | return -EPERM; |
| 271 | |
| 272 | /* ignore trailing newline */ |
| 273 | if (len > 0 && buf[len - 1] == '\n') |
| 274 | --count; |
| 275 | |
Eric W. Biederman | 336ca57 | 2009-05-13 16:57:25 +0000 | [diff] [blame] | 276 | if (!rtnl_trylock()) |
| 277 | return restart_syscall(); |
Stephen Hemminger | 0b815a1 | 2008-09-22 21:28:11 -0700 | [diff] [blame] | 278 | ret = dev_set_alias(netdev, buf, count); |
| 279 | rtnl_unlock(); |
| 280 | |
| 281 | return ret < 0 ? ret : len; |
| 282 | } |
| 283 | |
| 284 | static ssize_t show_ifalias(struct device *dev, |
| 285 | struct device_attribute *attr, char *buf) |
| 286 | { |
| 287 | const struct net_device *netdev = to_net_dev(dev); |
| 288 | ssize_t ret = 0; |
| 289 | |
Eric W. Biederman | 336ca57 | 2009-05-13 16:57:25 +0000 | [diff] [blame] | 290 | if (!rtnl_trylock()) |
| 291 | return restart_syscall(); |
Stephen Hemminger | 0b815a1 | 2008-09-22 21:28:11 -0700 | [diff] [blame] | 292 | if (netdev->ifalias) |
| 293 | ret = sprintf(buf, "%s\n", netdev->ifalias); |
| 294 | rtnl_unlock(); |
| 295 | return ret; |
| 296 | } |
| 297 | |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 298 | static struct device_attribute net_class_attributes[] = { |
Stefan Assmann | c1f7942 | 2010-07-22 02:50:21 +0000 | [diff] [blame] | 299 | __ATTR(addr_assign_type, S_IRUGO, show_addr_assign_type, NULL), |
Kay Sievers | fd586ba | 2005-12-19 01:42:56 +0100 | [diff] [blame] | 300 | __ATTR(addr_len, S_IRUGO, show_addr_len, NULL), |
David Woodhouse | 9d29672 | 2008-04-20 16:07:43 -0700 | [diff] [blame] | 301 | __ATTR(dev_id, S_IRUGO, show_dev_id, NULL), |
Stephen Hemminger | 0b815a1 | 2008-09-22 21:28:11 -0700 | [diff] [blame] | 302 | __ATTR(ifalias, S_IRUGO | S_IWUSR, show_ifalias, store_ifalias), |
Kay Sievers | fd586ba | 2005-12-19 01:42:56 +0100 | [diff] [blame] | 303 | __ATTR(iflink, S_IRUGO, show_iflink, NULL), |
| 304 | __ATTR(ifindex, S_IRUGO, show_ifindex, NULL), |
| 305 | __ATTR(features, S_IRUGO, show_features, NULL), |
| 306 | __ATTR(type, S_IRUGO, show_type, NULL), |
Stefan Rompf | b00055a | 2006-03-20 17:09:11 -0800 | [diff] [blame] | 307 | __ATTR(link_mode, S_IRUGO, show_link_mode, NULL), |
Kay Sievers | fd586ba | 2005-12-19 01:42:56 +0100 | [diff] [blame] | 308 | __ATTR(address, S_IRUGO, show_address, NULL), |
| 309 | __ATTR(broadcast, S_IRUGO, show_broadcast, NULL), |
| 310 | __ATTR(carrier, S_IRUGO, show_carrier, NULL), |
Andy Gospodarek | d519e17 | 2009-10-02 09:26:12 +0000 | [diff] [blame] | 311 | __ATTR(speed, S_IRUGO, show_speed, NULL), |
| 312 | __ATTR(duplex, S_IRUGO, show_duplex, NULL), |
Stefan Rompf | b00055a | 2006-03-20 17:09:11 -0800 | [diff] [blame] | 313 | __ATTR(dormant, S_IRUGO, show_dormant, NULL), |
| 314 | __ATTR(operstate, S_IRUGO, show_operstate, NULL), |
Kay Sievers | fd586ba | 2005-12-19 01:42:56 +0100 | [diff] [blame] | 315 | __ATTR(mtu, S_IRUGO | S_IWUSR, show_mtu, store_mtu), |
| 316 | __ATTR(flags, S_IRUGO | S_IWUSR, show_flags, store_flags), |
| 317 | __ATTR(tx_queue_len, S_IRUGO | S_IWUSR, show_tx_queue_len, |
| 318 | store_tx_queue_len), |
Kay Sievers | fd586ba | 2005-12-19 01:42:56 +0100 | [diff] [blame] | 319 | {} |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 320 | }; |
| 321 | |
| 322 | /* Show a given an attribute in the statistics group */ |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 323 | static ssize_t netstat_show(const struct device *d, |
| 324 | struct device_attribute *attr, char *buf, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 325 | unsigned long offset) |
| 326 | { |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 327 | struct net_device *dev = to_net_dev(d); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 328 | ssize_t ret = -EINVAL; |
| 329 | |
Ben Hutchings | be1f3c2 | 2010-06-08 07:19:54 +0000 | [diff] [blame] | 330 | WARN_ON(offset > sizeof(struct rtnl_link_stats64) || |
| 331 | offset % sizeof(u64) != 0); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 332 | |
| 333 | read_lock(&dev_base_lock); |
Pavel Emelyanov | 96e7408 | 2008-05-21 14:12:46 -0700 | [diff] [blame] | 334 | if (dev_isalive(dev)) { |
Eric Dumazet | 2817273 | 2010-07-07 14:58:56 -0700 | [diff] [blame] | 335 | struct rtnl_link_stats64 temp; |
| 336 | const struct rtnl_link_stats64 *stats = dev_get_stats(dev, &temp); |
| 337 | |
Ben Hutchings | be1f3c2 | 2010-06-08 07:19:54 +0000 | [diff] [blame] | 338 | ret = sprintf(buf, fmt_u64, *(u64 *)(((u8 *) stats) + offset)); |
Pavel Emelyanov | 96e7408 | 2008-05-21 14:12:46 -0700 | [diff] [blame] | 339 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 340 | read_unlock(&dev_base_lock); |
| 341 | return ret; |
| 342 | } |
| 343 | |
| 344 | /* generate a read-only statistics attribute */ |
| 345 | #define NETSTAT_ENTRY(name) \ |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 346 | static ssize_t show_##name(struct device *d, \ |
| 347 | struct device_attribute *attr, char *buf) \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 348 | { \ |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 349 | return netstat_show(d, attr, buf, \ |
Ben Hutchings | be1f3c2 | 2010-06-08 07:19:54 +0000 | [diff] [blame] | 350 | offsetof(struct rtnl_link_stats64, name)); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 351 | } \ |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 352 | static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 353 | |
| 354 | NETSTAT_ENTRY(rx_packets); |
| 355 | NETSTAT_ENTRY(tx_packets); |
| 356 | NETSTAT_ENTRY(rx_bytes); |
| 357 | NETSTAT_ENTRY(tx_bytes); |
| 358 | NETSTAT_ENTRY(rx_errors); |
| 359 | NETSTAT_ENTRY(tx_errors); |
| 360 | NETSTAT_ENTRY(rx_dropped); |
| 361 | NETSTAT_ENTRY(tx_dropped); |
| 362 | NETSTAT_ENTRY(multicast); |
| 363 | NETSTAT_ENTRY(collisions); |
| 364 | NETSTAT_ENTRY(rx_length_errors); |
| 365 | NETSTAT_ENTRY(rx_over_errors); |
| 366 | NETSTAT_ENTRY(rx_crc_errors); |
| 367 | NETSTAT_ENTRY(rx_frame_errors); |
| 368 | NETSTAT_ENTRY(rx_fifo_errors); |
| 369 | NETSTAT_ENTRY(rx_missed_errors); |
| 370 | NETSTAT_ENTRY(tx_aborted_errors); |
| 371 | NETSTAT_ENTRY(tx_carrier_errors); |
| 372 | NETSTAT_ENTRY(tx_fifo_errors); |
| 373 | NETSTAT_ENTRY(tx_heartbeat_errors); |
| 374 | NETSTAT_ENTRY(tx_window_errors); |
| 375 | NETSTAT_ENTRY(rx_compressed); |
| 376 | NETSTAT_ENTRY(tx_compressed); |
| 377 | |
| 378 | static struct attribute *netstat_attrs[] = { |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 379 | &dev_attr_rx_packets.attr, |
| 380 | &dev_attr_tx_packets.attr, |
| 381 | &dev_attr_rx_bytes.attr, |
| 382 | &dev_attr_tx_bytes.attr, |
| 383 | &dev_attr_rx_errors.attr, |
| 384 | &dev_attr_tx_errors.attr, |
| 385 | &dev_attr_rx_dropped.attr, |
| 386 | &dev_attr_tx_dropped.attr, |
| 387 | &dev_attr_multicast.attr, |
| 388 | &dev_attr_collisions.attr, |
| 389 | &dev_attr_rx_length_errors.attr, |
| 390 | &dev_attr_rx_over_errors.attr, |
| 391 | &dev_attr_rx_crc_errors.attr, |
| 392 | &dev_attr_rx_frame_errors.attr, |
| 393 | &dev_attr_rx_fifo_errors.attr, |
| 394 | &dev_attr_rx_missed_errors.attr, |
| 395 | &dev_attr_tx_aborted_errors.attr, |
| 396 | &dev_attr_tx_carrier_errors.attr, |
| 397 | &dev_attr_tx_fifo_errors.attr, |
| 398 | &dev_attr_tx_heartbeat_errors.attr, |
| 399 | &dev_attr_tx_window_errors.attr, |
| 400 | &dev_attr_rx_compressed.attr, |
| 401 | &dev_attr_tx_compressed.attr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 402 | NULL |
| 403 | }; |
| 404 | |
| 405 | |
| 406 | static struct attribute_group netstat_group = { |
| 407 | .name = "statistics", |
| 408 | .attrs = netstat_attrs, |
| 409 | }; |
| 410 | |
Johannes Berg | 22bb1be | 2008-07-10 11:16:47 +0200 | [diff] [blame] | 411 | #ifdef CONFIG_WIRELESS_EXT_SYSFS |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 412 | /* helper function that does all the locking etc for wireless stats */ |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 413 | static ssize_t wireless_show(struct device *d, char *buf, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 414 | ssize_t (*format)(const struct iw_statistics *, |
| 415 | char *)) |
| 416 | { |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 417 | struct net_device *dev = to_net_dev(d); |
Johannes Berg | 8f1546c | 2009-09-28 15:26:43 +0200 | [diff] [blame] | 418 | const struct iw_statistics *iw; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 419 | ssize_t ret = -EINVAL; |
YOSHIFUJI Hideaki | 4ec93ed | 2007-02-09 23:24:36 +0900 | [diff] [blame] | 420 | |
Eric W. Biederman | b8afe64 | 2010-02-19 13:23:47 +0000 | [diff] [blame] | 421 | if (!rtnl_trylock()) |
| 422 | return restart_syscall(); |
Andrey Borzenkov | 6dd214b | 2006-01-09 20:51:28 -0800 | [diff] [blame] | 423 | if (dev_isalive(dev)) { |
Johannes Berg | 8f1546c | 2009-09-28 15:26:43 +0200 | [diff] [blame] | 424 | iw = get_wireless_stats(dev); |
| 425 | if (iw) |
Andrey Borzenkov | 6dd214b | 2006-01-09 20:51:28 -0800 | [diff] [blame] | 426 | ret = (*format)(iw, buf); |
| 427 | } |
Johannes Berg | a160ee6 | 2009-10-05 02:22:23 -0700 | [diff] [blame] | 428 | rtnl_unlock(); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 429 | |
| 430 | return ret; |
| 431 | } |
| 432 | |
| 433 | /* show function template for wireless fields */ |
| 434 | #define WIRELESS_SHOW(name, field, format_string) \ |
| 435 | static ssize_t format_iw_##name(const struct iw_statistics *iw, char *buf) \ |
| 436 | { \ |
| 437 | return sprintf(buf, format_string, iw->field); \ |
| 438 | } \ |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 439 | static ssize_t show_iw_##name(struct device *d, \ |
| 440 | struct device_attribute *attr, char *buf) \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 441 | { \ |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 442 | return wireless_show(d, buf, format_iw_##name); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 443 | } \ |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 444 | static DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 445 | |
| 446 | WIRELESS_SHOW(status, status, fmt_hex); |
| 447 | WIRELESS_SHOW(link, qual.qual, fmt_dec); |
| 448 | WIRELESS_SHOW(level, qual.level, fmt_dec); |
| 449 | WIRELESS_SHOW(noise, qual.noise, fmt_dec); |
| 450 | WIRELESS_SHOW(nwid, discard.nwid, fmt_dec); |
| 451 | WIRELESS_SHOW(crypt, discard.code, fmt_dec); |
| 452 | WIRELESS_SHOW(fragment, discard.fragment, fmt_dec); |
| 453 | WIRELESS_SHOW(misc, discard.misc, fmt_dec); |
| 454 | WIRELESS_SHOW(retries, discard.retries, fmt_dec); |
| 455 | WIRELESS_SHOW(beacon, miss.beacon, fmt_dec); |
| 456 | |
| 457 | static struct attribute *wireless_attrs[] = { |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 458 | &dev_attr_status.attr, |
| 459 | &dev_attr_link.attr, |
| 460 | &dev_attr_level.attr, |
| 461 | &dev_attr_noise.attr, |
| 462 | &dev_attr_nwid.attr, |
| 463 | &dev_attr_crypt.attr, |
| 464 | &dev_attr_fragment.attr, |
| 465 | &dev_attr_retries.attr, |
| 466 | &dev_attr_misc.attr, |
| 467 | &dev_attr_beacon.attr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 468 | NULL |
| 469 | }; |
| 470 | |
| 471 | static struct attribute_group wireless_group = { |
| 472 | .name = "wireless", |
| 473 | .attrs = wireless_attrs, |
| 474 | }; |
| 475 | #endif |
Eric W. Biederman | d6523dd | 2010-05-16 21:59:45 -0700 | [diff] [blame] | 476 | #endif /* CONFIG_SYSFS */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 477 | |
Stephen Rothwell | 30bde1f | 2010-03-29 01:00:44 -0700 | [diff] [blame] | 478 | #ifdef CONFIG_RPS |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 479 | /* |
| 480 | * RX queue sysfs structures and functions. |
| 481 | */ |
| 482 | struct rx_queue_attribute { |
| 483 | struct attribute attr; |
| 484 | ssize_t (*show)(struct netdev_rx_queue *queue, |
| 485 | struct rx_queue_attribute *attr, char *buf); |
| 486 | ssize_t (*store)(struct netdev_rx_queue *queue, |
| 487 | struct rx_queue_attribute *attr, const char *buf, size_t len); |
| 488 | }; |
| 489 | #define to_rx_queue_attr(_attr) container_of(_attr, \ |
| 490 | struct rx_queue_attribute, attr) |
| 491 | |
| 492 | #define to_rx_queue(obj) container_of(obj, struct netdev_rx_queue, kobj) |
| 493 | |
| 494 | static ssize_t rx_queue_attr_show(struct kobject *kobj, struct attribute *attr, |
| 495 | char *buf) |
| 496 | { |
| 497 | struct rx_queue_attribute *attribute = to_rx_queue_attr(attr); |
| 498 | struct netdev_rx_queue *queue = to_rx_queue(kobj); |
| 499 | |
| 500 | if (!attribute->show) |
| 501 | return -EIO; |
| 502 | |
| 503 | return attribute->show(queue, attribute, buf); |
| 504 | } |
| 505 | |
| 506 | static ssize_t rx_queue_attr_store(struct kobject *kobj, struct attribute *attr, |
| 507 | const char *buf, size_t count) |
| 508 | { |
| 509 | struct rx_queue_attribute *attribute = to_rx_queue_attr(attr); |
| 510 | struct netdev_rx_queue *queue = to_rx_queue(kobj); |
| 511 | |
| 512 | if (!attribute->store) |
| 513 | return -EIO; |
| 514 | |
| 515 | return attribute->store(queue, attribute, buf, count); |
| 516 | } |
| 517 | |
stephen hemminger | fa50d64 | 2010-08-31 12:14:13 +0000 | [diff] [blame] | 518 | static const struct sysfs_ops rx_queue_sysfs_ops = { |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 519 | .show = rx_queue_attr_show, |
| 520 | .store = rx_queue_attr_store, |
| 521 | }; |
| 522 | |
| 523 | static ssize_t show_rps_map(struct netdev_rx_queue *queue, |
| 524 | struct rx_queue_attribute *attribute, char *buf) |
| 525 | { |
| 526 | struct rps_map *map; |
| 527 | cpumask_var_t mask; |
| 528 | size_t len = 0; |
| 529 | int i; |
| 530 | |
| 531 | if (!zalloc_cpumask_var(&mask, GFP_KERNEL)) |
| 532 | return -ENOMEM; |
| 533 | |
| 534 | rcu_read_lock(); |
| 535 | map = rcu_dereference(queue->rps_map); |
| 536 | if (map) |
| 537 | for (i = 0; i < map->len; i++) |
| 538 | cpumask_set_cpu(map->cpus[i], mask); |
| 539 | |
| 540 | len += cpumask_scnprintf(buf + len, PAGE_SIZE, mask); |
| 541 | if (PAGE_SIZE - len < 3) { |
| 542 | rcu_read_unlock(); |
| 543 | free_cpumask_var(mask); |
| 544 | return -EINVAL; |
| 545 | } |
| 546 | rcu_read_unlock(); |
| 547 | |
| 548 | free_cpumask_var(mask); |
| 549 | len += sprintf(buf + len, "\n"); |
| 550 | return len; |
| 551 | } |
| 552 | |
| 553 | static void rps_map_release(struct rcu_head *rcu) |
| 554 | { |
| 555 | struct rps_map *map = container_of(rcu, struct rps_map, rcu); |
| 556 | |
| 557 | kfree(map); |
| 558 | } |
| 559 | |
Eric Dumazet | f5acb90 | 2010-04-19 14:40:57 -0700 | [diff] [blame] | 560 | static ssize_t store_rps_map(struct netdev_rx_queue *queue, |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 561 | struct rx_queue_attribute *attribute, |
| 562 | const char *buf, size_t len) |
| 563 | { |
| 564 | struct rps_map *old_map, *map; |
| 565 | cpumask_var_t mask; |
| 566 | int err, cpu, i; |
| 567 | static DEFINE_SPINLOCK(rps_map_lock); |
| 568 | |
| 569 | if (!capable(CAP_NET_ADMIN)) |
| 570 | return -EPERM; |
| 571 | |
| 572 | if (!alloc_cpumask_var(&mask, GFP_KERNEL)) |
| 573 | return -ENOMEM; |
| 574 | |
| 575 | err = bitmap_parse(buf, len, cpumask_bits(mask), nr_cpumask_bits); |
| 576 | if (err) { |
| 577 | free_cpumask_var(mask); |
| 578 | return err; |
| 579 | } |
| 580 | |
| 581 | map = kzalloc(max_t(unsigned, |
| 582 | RPS_MAP_SIZE(cpumask_weight(mask)), L1_CACHE_BYTES), |
| 583 | GFP_KERNEL); |
| 584 | if (!map) { |
| 585 | free_cpumask_var(mask); |
| 586 | return -ENOMEM; |
| 587 | } |
| 588 | |
| 589 | i = 0; |
| 590 | for_each_cpu_and(cpu, mask, cpu_online_mask) |
| 591 | map->cpus[i++] = cpu; |
| 592 | |
| 593 | if (i) |
| 594 | map->len = i; |
| 595 | else { |
| 596 | kfree(map); |
| 597 | map = NULL; |
| 598 | } |
| 599 | |
| 600 | spin_lock(&rps_map_lock); |
| 601 | old_map = queue->rps_map; |
| 602 | rcu_assign_pointer(queue->rps_map, map); |
| 603 | spin_unlock(&rps_map_lock); |
| 604 | |
| 605 | if (old_map) |
| 606 | call_rcu(&old_map->rcu, rps_map_release); |
| 607 | |
| 608 | free_cpumask_var(mask); |
| 609 | return len; |
| 610 | } |
| 611 | |
Tom Herbert | fec5e65 | 2010-04-16 16:01:27 -0700 | [diff] [blame] | 612 | static ssize_t show_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue, |
| 613 | struct rx_queue_attribute *attr, |
| 614 | char *buf) |
| 615 | { |
| 616 | struct rps_dev_flow_table *flow_table; |
| 617 | unsigned int val = 0; |
| 618 | |
| 619 | rcu_read_lock(); |
| 620 | flow_table = rcu_dereference(queue->rps_flow_table); |
| 621 | if (flow_table) |
| 622 | val = flow_table->mask + 1; |
| 623 | rcu_read_unlock(); |
| 624 | |
| 625 | return sprintf(buf, "%u\n", val); |
| 626 | } |
| 627 | |
| 628 | static void rps_dev_flow_table_release_work(struct work_struct *work) |
| 629 | { |
| 630 | struct rps_dev_flow_table *table = container_of(work, |
| 631 | struct rps_dev_flow_table, free_work); |
| 632 | |
| 633 | vfree(table); |
| 634 | } |
| 635 | |
| 636 | static void rps_dev_flow_table_release(struct rcu_head *rcu) |
| 637 | { |
| 638 | struct rps_dev_flow_table *table = container_of(rcu, |
| 639 | struct rps_dev_flow_table, rcu); |
| 640 | |
| 641 | INIT_WORK(&table->free_work, rps_dev_flow_table_release_work); |
| 642 | schedule_work(&table->free_work); |
| 643 | } |
| 644 | |
Eric Dumazet | f5acb90 | 2010-04-19 14:40:57 -0700 | [diff] [blame] | 645 | static ssize_t store_rps_dev_flow_table_cnt(struct netdev_rx_queue *queue, |
Tom Herbert | fec5e65 | 2010-04-16 16:01:27 -0700 | [diff] [blame] | 646 | struct rx_queue_attribute *attr, |
| 647 | const char *buf, size_t len) |
| 648 | { |
| 649 | unsigned int count; |
| 650 | char *endp; |
| 651 | struct rps_dev_flow_table *table, *old_table; |
| 652 | static DEFINE_SPINLOCK(rps_dev_flow_lock); |
| 653 | |
| 654 | if (!capable(CAP_NET_ADMIN)) |
| 655 | return -EPERM; |
| 656 | |
| 657 | count = simple_strtoul(buf, &endp, 0); |
| 658 | if (endp == buf) |
| 659 | return -EINVAL; |
| 660 | |
| 661 | if (count) { |
| 662 | int i; |
| 663 | |
| 664 | if (count > 1<<30) { |
| 665 | /* Enforce a limit to prevent overflow */ |
| 666 | return -EINVAL; |
| 667 | } |
| 668 | count = roundup_pow_of_two(count); |
| 669 | table = vmalloc(RPS_DEV_FLOW_TABLE_SIZE(count)); |
| 670 | if (!table) |
| 671 | return -ENOMEM; |
| 672 | |
| 673 | table->mask = count - 1; |
| 674 | for (i = 0; i < count; i++) |
| 675 | table->flows[i].cpu = RPS_NO_CPU; |
| 676 | } else |
| 677 | table = NULL; |
| 678 | |
| 679 | spin_lock(&rps_dev_flow_lock); |
| 680 | old_table = queue->rps_flow_table; |
| 681 | rcu_assign_pointer(queue->rps_flow_table, table); |
| 682 | spin_unlock(&rps_dev_flow_lock); |
| 683 | |
| 684 | if (old_table) |
| 685 | call_rcu(&old_table->rcu, rps_dev_flow_table_release); |
| 686 | |
| 687 | return len; |
| 688 | } |
| 689 | |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 690 | static struct rx_queue_attribute rps_cpus_attribute = |
| 691 | __ATTR(rps_cpus, S_IRUGO | S_IWUSR, show_rps_map, store_rps_map); |
| 692 | |
Tom Herbert | fec5e65 | 2010-04-16 16:01:27 -0700 | [diff] [blame] | 693 | |
| 694 | static struct rx_queue_attribute rps_dev_flow_table_cnt_attribute = |
| 695 | __ATTR(rps_flow_cnt, S_IRUGO | S_IWUSR, |
| 696 | show_rps_dev_flow_table_cnt, store_rps_dev_flow_table_cnt); |
| 697 | |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 698 | static struct attribute *rx_queue_default_attrs[] = { |
| 699 | &rps_cpus_attribute.attr, |
Tom Herbert | fec5e65 | 2010-04-16 16:01:27 -0700 | [diff] [blame] | 700 | &rps_dev_flow_table_cnt_attribute.attr, |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 701 | NULL |
| 702 | }; |
| 703 | |
| 704 | static void rx_queue_release(struct kobject *kobj) |
| 705 | { |
| 706 | struct netdev_rx_queue *queue = to_rx_queue(kobj); |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 707 | struct netdev_rx_queue *first = queue->first; |
| 708 | |
Tom Herbert | fec5e65 | 2010-04-16 16:01:27 -0700 | [diff] [blame] | 709 | if (queue->rps_map) |
| 710 | call_rcu(&queue->rps_map->rcu, rps_map_release); |
| 711 | |
| 712 | if (queue->rps_flow_table) |
| 713 | call_rcu(&queue->rps_flow_table->rcu, |
| 714 | rps_dev_flow_table_release); |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 715 | |
| 716 | if (atomic_dec_and_test(&first->count)) |
| 717 | kfree(first); |
| 718 | } |
| 719 | |
| 720 | static struct kobj_type rx_queue_ktype = { |
| 721 | .sysfs_ops = &rx_queue_sysfs_ops, |
| 722 | .release = rx_queue_release, |
| 723 | .default_attrs = rx_queue_default_attrs, |
| 724 | }; |
| 725 | |
| 726 | static int rx_queue_add_kobject(struct net_device *net, int index) |
| 727 | { |
| 728 | struct netdev_rx_queue *queue = net->_rx + index; |
Tom Herbert | 4315d83 | 2010-10-07 10:09:10 +0000 | [diff] [blame^] | 729 | struct netdev_rx_queue *first = queue->first; |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 730 | struct kobject *kobj = &queue->kobj; |
| 731 | int error = 0; |
| 732 | |
| 733 | kobj->kset = net->queues_kset; |
| 734 | error = kobject_init_and_add(kobj, &rx_queue_ktype, NULL, |
| 735 | "rx-%u", index); |
| 736 | if (error) { |
| 737 | kobject_put(kobj); |
| 738 | return error; |
| 739 | } |
| 740 | |
| 741 | kobject_uevent(kobj, KOBJ_ADD); |
Tom Herbert | 4315d83 | 2010-10-07 10:09:10 +0000 | [diff] [blame^] | 742 | atomic_inc(&first->count); |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 743 | |
| 744 | return error; |
| 745 | } |
| 746 | |
Ben Hutchings | 62fe0b4 | 2010-09-27 08:24:33 +0000 | [diff] [blame] | 747 | int |
| 748 | net_rx_queue_update_kobjects(struct net_device *net, int old_num, int new_num) |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 749 | { |
| 750 | int i; |
| 751 | int error = 0; |
| 752 | |
Ben Hutchings | 62fe0b4 | 2010-09-27 08:24:33 +0000 | [diff] [blame] | 753 | for (i = old_num; i < new_num; i++) { |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 754 | error = rx_queue_add_kobject(net, i); |
Ben Hutchings | 62fe0b4 | 2010-09-27 08:24:33 +0000 | [diff] [blame] | 755 | if (error) { |
| 756 | new_num = old_num; |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 757 | break; |
Ben Hutchings | 62fe0b4 | 2010-09-27 08:24:33 +0000 | [diff] [blame] | 758 | } |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 759 | } |
| 760 | |
Ben Hutchings | 62fe0b4 | 2010-09-27 08:24:33 +0000 | [diff] [blame] | 761 | while (--i >= new_num) |
| 762 | kobject_put(&net->_rx[i].kobj); |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 763 | |
| 764 | return error; |
| 765 | } |
| 766 | |
Ben Hutchings | 62fe0b4 | 2010-09-27 08:24:33 +0000 | [diff] [blame] | 767 | static int rx_queue_register_kobjects(struct net_device *net) |
| 768 | { |
| 769 | net->queues_kset = kset_create_and_add("queues", |
| 770 | NULL, &net->dev.kobj); |
| 771 | if (!net->queues_kset) |
| 772 | return -ENOMEM; |
| 773 | return net_rx_queue_update_kobjects(net, 0, net->real_num_rx_queues); |
| 774 | } |
| 775 | |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 776 | static void rx_queue_remove_kobjects(struct net_device *net) |
| 777 | { |
Ben Hutchings | 62fe0b4 | 2010-09-27 08:24:33 +0000 | [diff] [blame] | 778 | net_rx_queue_update_kobjects(net, net->real_num_rx_queues, 0); |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 779 | kset_unregister(net->queues_kset); |
| 780 | } |
Stephen Rothwell | 30bde1f | 2010-03-29 01:00:44 -0700 | [diff] [blame] | 781 | #endif /* CONFIG_RPS */ |
Eric W. Biederman | 608b4b9 | 2010-05-04 17:36:45 -0700 | [diff] [blame] | 782 | |
| 783 | static const void *net_current_ns(void) |
| 784 | { |
| 785 | return current->nsproxy->net_ns; |
| 786 | } |
| 787 | |
| 788 | static const void *net_initial_ns(void) |
| 789 | { |
| 790 | return &init_net; |
| 791 | } |
| 792 | |
| 793 | static const void *net_netlink_ns(struct sock *sk) |
| 794 | { |
| 795 | return sock_net(sk); |
| 796 | } |
| 797 | |
Johannes Berg | 0460079 | 2010-08-05 17:45:15 +0200 | [diff] [blame] | 798 | struct kobj_ns_type_operations net_ns_type_operations = { |
Eric W. Biederman | 608b4b9 | 2010-05-04 17:36:45 -0700 | [diff] [blame] | 799 | .type = KOBJ_NS_TYPE_NET, |
| 800 | .current_ns = net_current_ns, |
| 801 | .netlink_ns = net_netlink_ns, |
| 802 | .initial_ns = net_initial_ns, |
| 803 | }; |
Johannes Berg | 0460079 | 2010-08-05 17:45:15 +0200 | [diff] [blame] | 804 | EXPORT_SYMBOL_GPL(net_ns_type_operations); |
Eric W. Biederman | 608b4b9 | 2010-05-04 17:36:45 -0700 | [diff] [blame] | 805 | |
| 806 | static void net_kobj_ns_exit(struct net *net) |
| 807 | { |
| 808 | kobj_ns_exit(KOBJ_NS_TYPE_NET, net); |
| 809 | } |
| 810 | |
Eric W. Biederman | d6523dd | 2010-05-16 21:59:45 -0700 | [diff] [blame] | 811 | static struct pernet_operations kobj_net_ops = { |
Eric W. Biederman | 608b4b9 | 2010-05-04 17:36:45 -0700 | [diff] [blame] | 812 | .exit = net_kobj_ns_exit, |
| 813 | }; |
| 814 | |
Eric W. Biederman | 8b41d18 | 2007-09-26 22:02:53 -0700 | [diff] [blame] | 815 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 816 | #ifdef CONFIG_HOTPLUG |
Kay Sievers | 7eff2e7 | 2007-08-14 15:15:12 +0200 | [diff] [blame] | 817 | static int netdev_uevent(struct device *d, struct kobj_uevent_env *env) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 818 | { |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 819 | struct net_device *dev = to_net_dev(d); |
Kay Sievers | 7eff2e7 | 2007-08-14 15:15:12 +0200 | [diff] [blame] | 820 | int retval; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 821 | |
Kay Sievers | 312c004 | 2005-11-16 09:00:00 +0100 | [diff] [blame] | 822 | /* pass interface to uevent. */ |
Kay Sievers | 7eff2e7 | 2007-08-14 15:15:12 +0200 | [diff] [blame] | 823 | retval = add_uevent_var(env, "INTERFACE=%s", dev->name); |
Eric Rannaud | bf62456 | 2007-03-30 22:23:12 -0700 | [diff] [blame] | 824 | if (retval) |
| 825 | goto exit; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 826 | |
Jean Tourrilhes | ca2f37d | 2007-03-07 10:49:30 -0800 | [diff] [blame] | 827 | /* pass ifindex to uevent. |
| 828 | * ifindex is useful as it won't change (interface name may change) |
| 829 | * and is what RtNetlink uses natively. */ |
Kay Sievers | 7eff2e7 | 2007-08-14 15:15:12 +0200 | [diff] [blame] | 830 | retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex); |
Jean Tourrilhes | ca2f37d | 2007-03-07 10:49:30 -0800 | [diff] [blame] | 831 | |
Eric Rannaud | bf62456 | 2007-03-30 22:23:12 -0700 | [diff] [blame] | 832 | exit: |
Eric Rannaud | bf62456 | 2007-03-30 22:23:12 -0700 | [diff] [blame] | 833 | return retval; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 834 | } |
| 835 | #endif |
| 836 | |
| 837 | /* |
YOSHIFUJI Hideaki | 4ec93ed | 2007-02-09 23:24:36 +0900 | [diff] [blame] | 838 | * netdev_release -- destroy and free a dead device. |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 839 | * Called when last reference to device kobject is gone. |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 840 | */ |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 841 | static void netdev_release(struct device *d) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 842 | { |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 843 | struct net_device *dev = to_net_dev(d); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 844 | |
| 845 | BUG_ON(dev->reg_state != NETREG_RELEASED); |
| 846 | |
Stephen Hemminger | 0b815a1 | 2008-09-22 21:28:11 -0700 | [diff] [blame] | 847 | kfree(dev->ifalias); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 848 | kfree((char *)dev - dev->padded); |
| 849 | } |
| 850 | |
Eric W. Biederman | 608b4b9 | 2010-05-04 17:36:45 -0700 | [diff] [blame] | 851 | static const void *net_namespace(struct device *d) |
| 852 | { |
| 853 | struct net_device *dev; |
| 854 | dev = container_of(d, struct net_device, dev); |
| 855 | return dev_net(dev); |
| 856 | } |
| 857 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 858 | static struct class net_class = { |
| 859 | .name = "net", |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 860 | .dev_release = netdev_release, |
Eric W. Biederman | 8b41d18 | 2007-09-26 22:02:53 -0700 | [diff] [blame] | 861 | #ifdef CONFIG_SYSFS |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 862 | .dev_attrs = net_class_attributes, |
Eric W. Biederman | 8b41d18 | 2007-09-26 22:02:53 -0700 | [diff] [blame] | 863 | #endif /* CONFIG_SYSFS */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 864 | #ifdef CONFIG_HOTPLUG |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 865 | .dev_uevent = netdev_uevent, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 866 | #endif |
Eric W. Biederman | 608b4b9 | 2010-05-04 17:36:45 -0700 | [diff] [blame] | 867 | .ns_type = &net_ns_type_operations, |
| 868 | .namespace = net_namespace, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 869 | }; |
| 870 | |
Stephen Hemminger | 9093bbb | 2007-05-19 15:39:25 -0700 | [diff] [blame] | 871 | /* Delete sysfs entries but hold kobject reference until after all |
| 872 | * netdev references are gone. |
| 873 | */ |
Eric W. Biederman | 8b41d18 | 2007-09-26 22:02:53 -0700 | [diff] [blame] | 874 | void netdev_unregister_kobject(struct net_device * net) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 875 | { |
Stephen Hemminger | 9093bbb | 2007-05-19 15:39:25 -0700 | [diff] [blame] | 876 | struct device *dev = &(net->dev); |
| 877 | |
| 878 | kobject_get(&dev->kobj); |
Eric W. Biederman | 3891845 | 2008-10-27 17:51:47 -0700 | [diff] [blame] | 879 | |
Stephen Rothwell | 30bde1f | 2010-03-29 01:00:44 -0700 | [diff] [blame] | 880 | #ifdef CONFIG_RPS |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 881 | rx_queue_remove_kobjects(net); |
Tom Herbert | e880eb6 | 2010-03-22 18:06:47 -0700 | [diff] [blame] | 882 | #endif |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 883 | |
Stephen Hemminger | 9093bbb | 2007-05-19 15:39:25 -0700 | [diff] [blame] | 884 | device_del(dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 885 | } |
| 886 | |
| 887 | /* Create sysfs entries for network device. */ |
Eric W. Biederman | 8b41d18 | 2007-09-26 22:02:53 -0700 | [diff] [blame] | 888 | int netdev_register_kobject(struct net_device *net) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 889 | { |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 890 | struct device *dev = &(net->dev); |
David Brownell | a4dbd67 | 2009-06-24 10:06:31 -0700 | [diff] [blame] | 891 | const struct attribute_group **groups = net->sysfs_groups; |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 892 | int error = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 893 | |
Eric W. Biederman | a1b3f59 | 2010-05-04 17:36:49 -0700 | [diff] [blame] | 894 | device_initialize(dev); |
Greg Kroah-Hartman | 43cb76d | 2002-04-09 12:14:34 -0700 | [diff] [blame] | 895 | dev->class = &net_class; |
| 896 | dev->platform_data = net; |
| 897 | dev->groups = groups; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 898 | |
Stephen Hemminger | a220547 | 2009-03-09 13:51:55 +0000 | [diff] [blame] | 899 | dev_set_name(dev, "%s", net->name); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 900 | |
Eric W. Biederman | 8b41d18 | 2007-09-26 22:02:53 -0700 | [diff] [blame] | 901 | #ifdef CONFIG_SYSFS |
Eric W. Biederman | 0c509a6 | 2009-10-29 14:18:21 +0000 | [diff] [blame] | 902 | /* Allow for a device specific group */ |
| 903 | if (*groups) |
| 904 | groups++; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 905 | |
Eric W. Biederman | 0c509a6 | 2009-10-29 14:18:21 +0000 | [diff] [blame] | 906 | *groups++ = &netstat_group; |
Johannes Berg | 22bb1be | 2008-07-10 11:16:47 +0200 | [diff] [blame] | 907 | #ifdef CONFIG_WIRELESS_EXT_SYSFS |
Johannes Berg | 3d23e34 | 2009-09-29 23:27:28 +0200 | [diff] [blame] | 908 | if (net->ieee80211_ptr) |
Stephen Hemminger | fe9925b | 2006-05-06 17:56:03 -0700 | [diff] [blame] | 909 | *groups++ = &wireless_group; |
Johannes Berg | 3d23e34 | 2009-09-29 23:27:28 +0200 | [diff] [blame] | 910 | #ifdef CONFIG_WIRELESS_EXT |
| 911 | else if (net->wireless_handlers) |
| 912 | *groups++ = &wireless_group; |
| 913 | #endif |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 914 | #endif |
Eric W. Biederman | 8b41d18 | 2007-09-26 22:02:53 -0700 | [diff] [blame] | 915 | #endif /* CONFIG_SYSFS */ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 916 | |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 917 | error = device_add(dev); |
| 918 | if (error) |
| 919 | return error; |
| 920 | |
Stephen Rothwell | 30bde1f | 2010-03-29 01:00:44 -0700 | [diff] [blame] | 921 | #ifdef CONFIG_RPS |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 922 | error = rx_queue_register_kobjects(net); |
| 923 | if (error) { |
| 924 | device_del(dev); |
| 925 | return error; |
| 926 | } |
Tom Herbert | e880eb6 | 2010-03-22 18:06:47 -0700 | [diff] [blame] | 927 | #endif |
Tom Herbert | 0a9627f | 2010-03-16 08:03:29 +0000 | [diff] [blame] | 928 | |
| 929 | return error; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 930 | } |
| 931 | |
Jay Vosburgh | b8a9787 | 2008-06-13 18:12:04 -0700 | [diff] [blame] | 932 | int netdev_class_create_file(struct class_attribute *class_attr) |
| 933 | { |
| 934 | return class_create_file(&net_class, class_attr); |
| 935 | } |
Eric Dumazet | 9e34a5b | 2010-07-09 21:22:04 +0000 | [diff] [blame] | 936 | EXPORT_SYMBOL(netdev_class_create_file); |
Jay Vosburgh | b8a9787 | 2008-06-13 18:12:04 -0700 | [diff] [blame] | 937 | |
| 938 | void netdev_class_remove_file(struct class_attribute *class_attr) |
| 939 | { |
| 940 | class_remove_file(&net_class, class_attr); |
| 941 | } |
Jay Vosburgh | b8a9787 | 2008-06-13 18:12:04 -0700 | [diff] [blame] | 942 | EXPORT_SYMBOL(netdev_class_remove_file); |
| 943 | |
Eric W. Biederman | 8b41d18 | 2007-09-26 22:02:53 -0700 | [diff] [blame] | 944 | int netdev_kobject_init(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 945 | { |
Eric W. Biederman | 608b4b9 | 2010-05-04 17:36:45 -0700 | [diff] [blame] | 946 | kobj_ns_type_register(&net_ns_type_operations); |
Eric W. Biederman | d6523dd | 2010-05-16 21:59:45 -0700 | [diff] [blame] | 947 | register_pernet_subsys(&kobj_net_ops); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 948 | return class_register(&net_class); |
| 949 | } |