1 /* 2 * net-sysfs.c - network device class and attributes 3 * 4 * Copyright (c) 2003 Stephen Hemminger <shemminger@osdl.org> 5 * 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 12 #include <linux/capability.h> 13 #include <linux/kernel.h> 14 #include <linux/netdevice.h> 15 #include <linux/if_arp.h> 16 #include <net/sock.h> 17 #include <linux/rtnetlink.h> 18 #include <linux/wireless.h> 19 #include <net/iw_handler.h> 20 21 #include "net-sysfs.h" 22 23 #ifdef CONFIG_SYSFS 24 static const char fmt_hex[] = "%#x\n"; 25 static const char fmt_long_hex[] = "%#lx\n"; 26 static const char fmt_dec[] = "%d\n"; 27 static const char fmt_ulong[] = "%lu\n"; 28 29 static inline int dev_isalive(const struct net_device *dev) 30 { 31 return dev->reg_state <= NETREG_REGISTERED; 32 } 33 34 /* use same locking rules as GIF* ioctl's */ 35 static ssize_t netdev_show(const struct device *dev, 36 struct device_attribute *attr, char *buf, 37 ssize_t (*format)(const struct net_device *, char *)) 38 { 39 struct net_device *net = to_net_dev(dev); 40 ssize_t ret = -EINVAL; 41 42 read_lock(&dev_base_lock); 43 if (dev_isalive(net)) 44 ret = (*format)(net, buf); 45 read_unlock(&dev_base_lock); 46 47 return ret; 48 } 49 50 /* generate a show function for simple field */ 51 #define NETDEVICE_SHOW(field, format_string) \ 52 static ssize_t format_##field(const struct net_device *net, char *buf) \ 53 { \ 54 return sprintf(buf, format_string, net->field); \ 55 } \ 56 static ssize_t show_##field(struct device *dev, \ 57 struct device_attribute *attr, char *buf) \ 58 { \ 59 return netdev_show(dev, attr, buf, format_##field); \ 60 } 61 62 63 /* use same locking and permission rules as SIF* ioctl's */ 64 static ssize_t netdev_store(struct device *dev, struct device_attribute *attr, 65 const char *buf, size_t len, 66 int (*set)(struct net_device *, unsigned long)) 67 { 68 struct net_device *net = to_net_dev(dev); 69 char *endp; 70 unsigned long new; 71 int ret = -EINVAL; 72 73 if (!capable(CAP_NET_ADMIN)) 74 return -EPERM; 75 76 new = simple_strtoul(buf, &endp, 0); 77 if (endp == buf) 78 goto err; 79 80 rtnl_lock(); 81 if (dev_isalive(net)) { 82 if ((ret = (*set)(net, new)) == 0) 83 ret = len; 84 } 85 rtnl_unlock(); 86 err: 87 return ret; 88 } 89 90 NETDEVICE_SHOW(addr_len, fmt_dec); 91 NETDEVICE_SHOW(iflink, fmt_dec); 92 NETDEVICE_SHOW(ifindex, fmt_dec); 93 NETDEVICE_SHOW(features, fmt_long_hex); 94 NETDEVICE_SHOW(type, fmt_dec); 95 NETDEVICE_SHOW(link_mode, fmt_dec); 96 97 /* use same locking rules as GIFHWADDR ioctl's */ 98 static ssize_t show_address(struct device *dev, struct device_attribute *attr, 99 char *buf) 100 { 101 struct net_device *net = to_net_dev(dev); 102 ssize_t ret = -EINVAL; 103 104 read_lock(&dev_base_lock); 105 if (dev_isalive(net)) 106 ret = sysfs_format_mac(buf, net->dev_addr, net->addr_len); 107 read_unlock(&dev_base_lock); 108 return ret; 109 } 110 111 static ssize_t show_broadcast(struct device *dev, 112 struct device_attribute *attr, char *buf) 113 { 114 struct net_device *net = to_net_dev(dev); 115 if (dev_isalive(net)) 116 return sysfs_format_mac(buf, net->broadcast, net->addr_len); 117 return -EINVAL; 118 } 119 120 static ssize_t show_carrier(struct device *dev, 121 struct device_attribute *attr, char *buf) 122 { 123 struct net_device *netdev = to_net_dev(dev); 124 if (netif_running(netdev)) { 125 return sprintf(buf, fmt_dec, !!netif_carrier_ok(netdev)); 126 } 127 return -EINVAL; 128 } 129 130 static ssize_t show_dormant(struct device *dev, 131 struct device_attribute *attr, char *buf) 132 { 133 struct net_device *netdev = to_net_dev(dev); 134 135 if (netif_running(netdev)) 136 return sprintf(buf, fmt_dec, !!netif_dormant(netdev)); 137 138 return -EINVAL; 139 } 140 141 static const char *operstates[] = { 142 "unknown", 143 "notpresent", /* currently unused */ 144 "down", 145 "lowerlayerdown", 146 "testing", /* currently unused */ 147 "dormant", 148 "up" 149 }; 150 151 static ssize_t show_operstate(struct device *dev, 152 struct device_attribute *attr, char *buf) 153 { 154 const struct net_device *netdev = to_net_dev(dev); 155 unsigned char operstate; 156 157 read_lock(&dev_base_lock); 158 operstate = netdev->operstate; 159 if (!netif_running(netdev)) 160 operstate = IF_OPER_DOWN; 161 read_unlock(&dev_base_lock); 162 163 if (operstate >= ARRAY_SIZE(operstates)) 164 return -EINVAL; /* should not happen */ 165 166 return sprintf(buf, "%s\n", operstates[operstate]); 167 } 168 169 /* read-write attributes */ 170 NETDEVICE_SHOW(mtu, fmt_dec); 171 172 static int change_mtu(struct net_device *net, unsigned long new_mtu) 173 { 174 return dev_set_mtu(net, (int) new_mtu); 175 } 176 177 static ssize_t store_mtu(struct device *dev, struct device_attribute *attr, 178 const char *buf, size_t len) 179 { 180 return netdev_store(dev, attr, buf, len, change_mtu); 181 } 182 183 NETDEVICE_SHOW(flags, fmt_hex); 184 185 static int change_flags(struct net_device *net, unsigned long new_flags) 186 { 187 return dev_change_flags(net, (unsigned) new_flags); 188 } 189 190 static ssize_t store_flags(struct device *dev, struct device_attribute *attr, 191 const char *buf, size_t len) 192 { 193 return netdev_store(dev, attr, buf, len, change_flags); 194 } 195 196 NETDEVICE_SHOW(tx_queue_len, fmt_ulong); 197 198 static int change_tx_queue_len(struct net_device *net, unsigned long new_len) 199 { 200 net->tx_queue_len = new_len; 201 return 0; 202 } 203 204 static ssize_t store_tx_queue_len(struct device *dev, 205 struct device_attribute *attr, 206 const char *buf, size_t len) 207 { 208 return netdev_store(dev, attr, buf, len, change_tx_queue_len); 209 } 210 211 static struct device_attribute net_class_attributes[] = { 212 __ATTR(addr_len, S_IRUGO, show_addr_len, NULL), 213 __ATTR(iflink, S_IRUGO, show_iflink, NULL), 214 __ATTR(ifindex, S_IRUGO, show_ifindex, NULL), 215 __ATTR(features, S_IRUGO, show_features, NULL), 216 __ATTR(type, S_IRUGO, show_type, NULL), 217 __ATTR(link_mode, S_IRUGO, show_link_mode, NULL), 218 __ATTR(address, S_IRUGO, show_address, NULL), 219 __ATTR(broadcast, S_IRUGO, show_broadcast, NULL), 220 __ATTR(carrier, S_IRUGO, show_carrier, NULL), 221 __ATTR(dormant, S_IRUGO, show_dormant, NULL), 222 __ATTR(operstate, S_IRUGO, show_operstate, NULL), 223 __ATTR(mtu, S_IRUGO | S_IWUSR, show_mtu, store_mtu), 224 __ATTR(flags, S_IRUGO | S_IWUSR, show_flags, store_flags), 225 __ATTR(tx_queue_len, S_IRUGO | S_IWUSR, show_tx_queue_len, 226 store_tx_queue_len), 227 {} 228 }; 229 230 /* Show a given an attribute in the statistics group */ 231 static ssize_t netstat_show(const struct device *d, 232 struct device_attribute *attr, char *buf, 233 unsigned long offset) 234 { 235 struct net_device *dev = to_net_dev(d); 236 struct net_device_stats *stats; 237 ssize_t ret = -EINVAL; 238 239 WARN_ON(offset > sizeof(struct net_device_stats) || 240 offset % sizeof(unsigned long) != 0); 241 242 read_lock(&dev_base_lock); 243 if (dev_isalive(dev) && dev->get_stats && 244 (stats = (*dev->get_stats)(dev))) 245 ret = sprintf(buf, fmt_ulong, 246 *(unsigned long *)(((u8 *) stats) + offset)); 247 248 read_unlock(&dev_base_lock); 249 return ret; 250 } 251 252 /* generate a read-only statistics attribute */ 253 #define NETSTAT_ENTRY(name) \ 254 static ssize_t show_##name(struct device *d, \ 255 struct device_attribute *attr, char *buf) \ 256 { \ 257 return netstat_show(d, attr, buf, \ 258 offsetof(struct net_device_stats, name)); \ 259 } \ 260 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL) 261 262 NETSTAT_ENTRY(rx_packets); 263 NETSTAT_ENTRY(tx_packets); 264 NETSTAT_ENTRY(rx_bytes); 265 NETSTAT_ENTRY(tx_bytes); 266 NETSTAT_ENTRY(rx_errors); 267 NETSTAT_ENTRY(tx_errors); 268 NETSTAT_ENTRY(rx_dropped); 269 NETSTAT_ENTRY(tx_dropped); 270 NETSTAT_ENTRY(multicast); 271 NETSTAT_ENTRY(collisions); 272 NETSTAT_ENTRY(rx_length_errors); 273 NETSTAT_ENTRY(rx_over_errors); 274 NETSTAT_ENTRY(rx_crc_errors); 275 NETSTAT_ENTRY(rx_frame_errors); 276 NETSTAT_ENTRY(rx_fifo_errors); 277 NETSTAT_ENTRY(rx_missed_errors); 278 NETSTAT_ENTRY(tx_aborted_errors); 279 NETSTAT_ENTRY(tx_carrier_errors); 280 NETSTAT_ENTRY(tx_fifo_errors); 281 NETSTAT_ENTRY(tx_heartbeat_errors); 282 NETSTAT_ENTRY(tx_window_errors); 283 NETSTAT_ENTRY(rx_compressed); 284 NETSTAT_ENTRY(tx_compressed); 285 286 static struct attribute *netstat_attrs[] = { 287 &dev_attr_rx_packets.attr, 288 &dev_attr_tx_packets.attr, 289 &dev_attr_rx_bytes.attr, 290 &dev_attr_tx_bytes.attr, 291 &dev_attr_rx_errors.attr, 292 &dev_attr_tx_errors.attr, 293 &dev_attr_rx_dropped.attr, 294 &dev_attr_tx_dropped.attr, 295 &dev_attr_multicast.attr, 296 &dev_attr_collisions.attr, 297 &dev_attr_rx_length_errors.attr, 298 &dev_attr_rx_over_errors.attr, 299 &dev_attr_rx_crc_errors.attr, 300 &dev_attr_rx_frame_errors.attr, 301 &dev_attr_rx_fifo_errors.attr, 302 &dev_attr_rx_missed_errors.attr, 303 &dev_attr_tx_aborted_errors.attr, 304 &dev_attr_tx_carrier_errors.attr, 305 &dev_attr_tx_fifo_errors.attr, 306 &dev_attr_tx_heartbeat_errors.attr, 307 &dev_attr_tx_window_errors.attr, 308 &dev_attr_rx_compressed.attr, 309 &dev_attr_tx_compressed.attr, 310 NULL 311 }; 312 313 314 static struct attribute_group netstat_group = { 315 .name = "statistics", 316 .attrs = netstat_attrs, 317 }; 318 319 #ifdef CONFIG_WIRELESS_EXT 320 /* helper function that does all the locking etc for wireless stats */ 321 static ssize_t wireless_show(struct device *d, char *buf, 322 ssize_t (*format)(const struct iw_statistics *, 323 char *)) 324 { 325 struct net_device *dev = to_net_dev(d); 326 const struct iw_statistics *iw = NULL; 327 ssize_t ret = -EINVAL; 328 329 read_lock(&dev_base_lock); 330 if (dev_isalive(dev)) { 331 if (dev->wireless_handlers && 332 dev->wireless_handlers->get_wireless_stats) 333 iw = dev->wireless_handlers->get_wireless_stats(dev); 334 if (iw != NULL) 335 ret = (*format)(iw, buf); 336 } 337 read_unlock(&dev_base_lock); 338 339 return ret; 340 } 341 342 /* show function template for wireless fields */ 343 #define WIRELESS_SHOW(name, field, format_string) \ 344 static ssize_t format_iw_##name(const struct iw_statistics *iw, char *buf) \ 345 { \ 346 return sprintf(buf, format_string, iw->field); \ 347 } \ 348 static ssize_t show_iw_##name(struct device *d, \ 349 struct device_attribute *attr, char *buf) \ 350 { \ 351 return wireless_show(d, buf, format_iw_##name); \ 352 } \ 353 static DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL) 354 355 WIRELESS_SHOW(status, status, fmt_hex); 356 WIRELESS_SHOW(link, qual.qual, fmt_dec); 357 WIRELESS_SHOW(level, qual.level, fmt_dec); 358 WIRELESS_SHOW(noise, qual.noise, fmt_dec); 359 WIRELESS_SHOW(nwid, discard.nwid, fmt_dec); 360 WIRELESS_SHOW(crypt, discard.code, fmt_dec); 361 WIRELESS_SHOW(fragment, discard.fragment, fmt_dec); 362 WIRELESS_SHOW(misc, discard.misc, fmt_dec); 363 WIRELESS_SHOW(retries, discard.retries, fmt_dec); 364 WIRELESS_SHOW(beacon, miss.beacon, fmt_dec); 365 366 static struct attribute *wireless_attrs[] = { 367 &dev_attr_status.attr, 368 &dev_attr_link.attr, 369 &dev_attr_level.attr, 370 &dev_attr_noise.attr, 371 &dev_attr_nwid.attr, 372 &dev_attr_crypt.attr, 373 &dev_attr_fragment.attr, 374 &dev_attr_retries.attr, 375 &dev_attr_misc.attr, 376 &dev_attr_beacon.attr, 377 NULL 378 }; 379 380 static struct attribute_group wireless_group = { 381 .name = "wireless", 382 .attrs = wireless_attrs, 383 }; 384 #endif 385 386 #endif /* CONFIG_SYSFS */ 387 388 #ifdef CONFIG_HOTPLUG 389 static int netdev_uevent(struct device *d, struct kobj_uevent_env *env) 390 { 391 struct net_device *dev = to_net_dev(d); 392 int retval; 393 394 /* pass interface to uevent. */ 395 retval = add_uevent_var(env, "INTERFACE=%s", dev->name); 396 if (retval) 397 goto exit; 398 399 /* pass ifindex to uevent. 400 * ifindex is useful as it won't change (interface name may change) 401 * and is what RtNetlink uses natively. */ 402 retval = add_uevent_var(env, "IFINDEX=%d", dev->ifindex); 403 404 exit: 405 return retval; 406 } 407 #endif 408 409 /* 410 * netdev_release -- destroy and free a dead device. 411 * Called when last reference to device kobject is gone. 412 */ 413 static void netdev_release(struct device *d) 414 { 415 struct net_device *dev = to_net_dev(d); 416 417 BUG_ON(dev->reg_state != NETREG_RELEASED); 418 419 kfree((char *)dev - dev->padded); 420 } 421 422 static struct class net_class = { 423 .name = "net", 424 .dev_release = netdev_release, 425 #ifdef CONFIG_SYSFS 426 .dev_attrs = net_class_attributes, 427 #endif /* CONFIG_SYSFS */ 428 #ifdef CONFIG_HOTPLUG 429 .dev_uevent = netdev_uevent, 430 #endif 431 }; 432 433 /* Delete sysfs entries but hold kobject reference until after all 434 * netdev references are gone. 435 */ 436 void netdev_unregister_kobject(struct net_device * net) 437 { 438 struct device *dev = &(net->dev); 439 440 kobject_get(&dev->kobj); 441 device_del(dev); 442 } 443 444 /* Create sysfs entries for network device. */ 445 int netdev_register_kobject(struct net_device *net) 446 { 447 struct device *dev = &(net->dev); 448 struct attribute_group **groups = net->sysfs_groups; 449 450 device_initialize(dev); 451 dev->class = &net_class; 452 dev->platform_data = net; 453 dev->groups = groups; 454 455 BUILD_BUG_ON(BUS_ID_SIZE < IFNAMSIZ); 456 strlcpy(dev->bus_id, net->name, BUS_ID_SIZE); 457 458 #ifdef CONFIG_SYSFS 459 if (net->get_stats) 460 *groups++ = &netstat_group; 461 462 #ifdef CONFIG_WIRELESS_EXT 463 if (net->wireless_handlers && net->wireless_handlers->get_wireless_stats) 464 *groups++ = &wireless_group; 465 #endif 466 #endif /* CONFIG_SYSFS */ 467 468 return device_add(dev); 469 } 470 471 int netdev_kobject_init(void) 472 { 473 return class_register(&net_class); 474 } 475