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