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 #define to_class_dev(obj) container_of(obj,struct class_device,kobj) 22 #define to_net_dev(class) container_of(class, struct net_device, class_dev) 23 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 class_device *cd, char *buf, 36 ssize_t (*format)(const struct net_device *, char *)) 37 { 38 struct net_device *net = to_net_dev(cd); 39 ssize_t ret = -EINVAL; 40 41 read_lock(&dev_base_lock); 42 if (dev_isalive(net)) 43 ret = (*format)(net, buf); 44 read_unlock(&dev_base_lock); 45 46 return ret; 47 } 48 49 /* generate a show function for simple field */ 50 #define NETDEVICE_SHOW(field, format_string) \ 51 static ssize_t format_##field(const struct net_device *net, char *buf) \ 52 { \ 53 return sprintf(buf, format_string, net->field); \ 54 } \ 55 static ssize_t show_##field(struct class_device *cd, char *buf) \ 56 { \ 57 return netdev_show(cd, buf, format_##field); \ 58 } 59 60 61 /* use same locking and permission rules as SIF* ioctl's */ 62 static ssize_t netdev_store(struct class_device *dev, 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 class_device *dev, char *buf) 108 { 109 struct net_device *net = to_net_dev(dev); 110 ssize_t ret = -EINVAL; 111 112 read_lock(&dev_base_lock); 113 if (dev_isalive(net)) 114 ret = format_addr(buf, net->dev_addr, net->addr_len); 115 read_unlock(&dev_base_lock); 116 return ret; 117 } 118 119 static ssize_t show_broadcast(struct class_device *dev, char *buf) 120 { 121 struct net_device *net = to_net_dev(dev); 122 if (dev_isalive(net)) 123 return format_addr(buf, net->broadcast, net->addr_len); 124 return -EINVAL; 125 } 126 127 static ssize_t show_carrier(struct class_device *dev, char *buf) 128 { 129 struct net_device *netdev = to_net_dev(dev); 130 if (netif_running(netdev)) { 131 return sprintf(buf, fmt_dec, !!netif_carrier_ok(netdev)); 132 } 133 return -EINVAL; 134 } 135 136 static ssize_t show_dormant(struct class_device *dev, char *buf) 137 { 138 struct net_device *netdev = to_net_dev(dev); 139 140 if (netif_running(netdev)) 141 return sprintf(buf, fmt_dec, !!netif_dormant(netdev)); 142 143 return -EINVAL; 144 } 145 146 static const char *operstates[] = { 147 "unknown", 148 "notpresent", /* currently unused */ 149 "down", 150 "lowerlayerdown", 151 "testing", /* currently unused */ 152 "dormant", 153 "up" 154 }; 155 156 static ssize_t show_operstate(struct class_device *dev, char *buf) 157 { 158 const struct net_device *netdev = to_net_dev(dev); 159 unsigned char operstate; 160 161 read_lock(&dev_base_lock); 162 operstate = netdev->operstate; 163 if (!netif_running(netdev)) 164 operstate = IF_OPER_DOWN; 165 read_unlock(&dev_base_lock); 166 167 if (operstate >= ARRAY_SIZE(operstates)) 168 return -EINVAL; /* should not happen */ 169 170 return sprintf(buf, "%s\n", operstates[operstate]); 171 } 172 173 /* read-write attributes */ 174 NETDEVICE_SHOW(mtu, fmt_dec); 175 176 static int change_mtu(struct net_device *net, unsigned long new_mtu) 177 { 178 return dev_set_mtu(net, (int) new_mtu); 179 } 180 181 static ssize_t store_mtu(struct class_device *dev, const char *buf, size_t len) 182 { 183 return netdev_store(dev, buf, len, change_mtu); 184 } 185 186 NETDEVICE_SHOW(flags, fmt_hex); 187 188 static int change_flags(struct net_device *net, unsigned long new_flags) 189 { 190 return dev_change_flags(net, (unsigned) new_flags); 191 } 192 193 static ssize_t store_flags(struct class_device *dev, const char *buf, size_t len) 194 { 195 return netdev_store(dev, buf, len, change_flags); 196 } 197 198 NETDEVICE_SHOW(tx_queue_len, fmt_ulong); 199 200 static int change_tx_queue_len(struct net_device *net, unsigned long new_len) 201 { 202 net->tx_queue_len = new_len; 203 return 0; 204 } 205 206 static ssize_t store_tx_queue_len(struct class_device *dev, const char *buf, size_t len) 207 { 208 return netdev_store(dev, buf, len, change_tx_queue_len); 209 } 210 211 NETDEVICE_SHOW(weight, fmt_dec); 212 213 static int change_weight(struct net_device *net, unsigned long new_weight) 214 { 215 net->weight = new_weight; 216 return 0; 217 } 218 219 static ssize_t store_weight(struct class_device *dev, const char *buf, size_t len) 220 { 221 return netdev_store(dev, buf, len, change_weight); 222 } 223 224 static struct class_device_attribute net_class_attributes[] = { 225 __ATTR(addr_len, S_IRUGO, show_addr_len, NULL), 226 __ATTR(iflink, S_IRUGO, show_iflink, NULL), 227 __ATTR(ifindex, S_IRUGO, show_ifindex, NULL), 228 __ATTR(features, S_IRUGO, show_features, NULL), 229 __ATTR(type, S_IRUGO, show_type, NULL), 230 __ATTR(link_mode, S_IRUGO, show_link_mode, NULL), 231 __ATTR(address, S_IRUGO, show_address, NULL), 232 __ATTR(broadcast, S_IRUGO, show_broadcast, NULL), 233 __ATTR(carrier, S_IRUGO, show_carrier, NULL), 234 __ATTR(dormant, S_IRUGO, show_dormant, NULL), 235 __ATTR(operstate, S_IRUGO, show_operstate, NULL), 236 __ATTR(mtu, S_IRUGO | S_IWUSR, show_mtu, store_mtu), 237 __ATTR(flags, S_IRUGO | S_IWUSR, show_flags, store_flags), 238 __ATTR(tx_queue_len, S_IRUGO | S_IWUSR, show_tx_queue_len, 239 store_tx_queue_len), 240 __ATTR(weight, S_IRUGO | S_IWUSR, show_weight, store_weight), 241 {} 242 }; 243 244 /* Show a given an attribute in the statistics group */ 245 static ssize_t netstat_show(const struct class_device *cd, char *buf, 246 unsigned long offset) 247 { 248 struct net_device *dev = to_net_dev(cd); 249 struct net_device_stats *stats; 250 ssize_t ret = -EINVAL; 251 252 if (offset > sizeof(struct net_device_stats) || 253 offset % sizeof(unsigned long) != 0) 254 WARN_ON(1); 255 256 read_lock(&dev_base_lock); 257 if (dev_isalive(dev) && dev->get_stats && 258 (stats = (*dev->get_stats)(dev))) 259 ret = sprintf(buf, fmt_ulong, 260 *(unsigned long *)(((u8 *) stats) + offset)); 261 262 read_unlock(&dev_base_lock); 263 return ret; 264 } 265 266 /* generate a read-only statistics attribute */ 267 #define NETSTAT_ENTRY(name) \ 268 static ssize_t show_##name(struct class_device *cd, char *buf) \ 269 { \ 270 return netstat_show(cd, buf, \ 271 offsetof(struct net_device_stats, name)); \ 272 } \ 273 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_##name, NULL) 274 275 NETSTAT_ENTRY(rx_packets); 276 NETSTAT_ENTRY(tx_packets); 277 NETSTAT_ENTRY(rx_bytes); 278 NETSTAT_ENTRY(tx_bytes); 279 NETSTAT_ENTRY(rx_errors); 280 NETSTAT_ENTRY(tx_errors); 281 NETSTAT_ENTRY(rx_dropped); 282 NETSTAT_ENTRY(tx_dropped); 283 NETSTAT_ENTRY(multicast); 284 NETSTAT_ENTRY(collisions); 285 NETSTAT_ENTRY(rx_length_errors); 286 NETSTAT_ENTRY(rx_over_errors); 287 NETSTAT_ENTRY(rx_crc_errors); 288 NETSTAT_ENTRY(rx_frame_errors); 289 NETSTAT_ENTRY(rx_fifo_errors); 290 NETSTAT_ENTRY(rx_missed_errors); 291 NETSTAT_ENTRY(tx_aborted_errors); 292 NETSTAT_ENTRY(tx_carrier_errors); 293 NETSTAT_ENTRY(tx_fifo_errors); 294 NETSTAT_ENTRY(tx_heartbeat_errors); 295 NETSTAT_ENTRY(tx_window_errors); 296 NETSTAT_ENTRY(rx_compressed); 297 NETSTAT_ENTRY(tx_compressed); 298 299 static struct attribute *netstat_attrs[] = { 300 &class_device_attr_rx_packets.attr, 301 &class_device_attr_tx_packets.attr, 302 &class_device_attr_rx_bytes.attr, 303 &class_device_attr_tx_bytes.attr, 304 &class_device_attr_rx_errors.attr, 305 &class_device_attr_tx_errors.attr, 306 &class_device_attr_rx_dropped.attr, 307 &class_device_attr_tx_dropped.attr, 308 &class_device_attr_multicast.attr, 309 &class_device_attr_collisions.attr, 310 &class_device_attr_rx_length_errors.attr, 311 &class_device_attr_rx_over_errors.attr, 312 &class_device_attr_rx_crc_errors.attr, 313 &class_device_attr_rx_frame_errors.attr, 314 &class_device_attr_rx_fifo_errors.attr, 315 &class_device_attr_rx_missed_errors.attr, 316 &class_device_attr_tx_aborted_errors.attr, 317 &class_device_attr_tx_carrier_errors.attr, 318 &class_device_attr_tx_fifo_errors.attr, 319 &class_device_attr_tx_heartbeat_errors.attr, 320 &class_device_attr_tx_window_errors.attr, 321 &class_device_attr_rx_compressed.attr, 322 &class_device_attr_tx_compressed.attr, 323 NULL 324 }; 325 326 327 static struct attribute_group netstat_group = { 328 .name = "statistics", 329 .attrs = netstat_attrs, 330 }; 331 332 #ifdef WIRELESS_EXT 333 /* helper function that does all the locking etc for wireless stats */ 334 static ssize_t wireless_show(struct class_device *cd, char *buf, 335 ssize_t (*format)(const struct iw_statistics *, 336 char *)) 337 { 338 struct net_device *dev = to_net_dev(cd); 339 const struct iw_statistics *iw = NULL; 340 ssize_t ret = -EINVAL; 341 342 read_lock(&dev_base_lock); 343 if (dev_isalive(dev)) { 344 if(dev->wireless_handlers && 345 dev->wireless_handlers->get_wireless_stats) 346 iw = dev->wireless_handlers->get_wireless_stats(dev); 347 else if (dev->get_wireless_stats) 348 iw = dev->get_wireless_stats(dev); 349 if (iw != NULL) 350 ret = (*format)(iw, buf); 351 } 352 read_unlock(&dev_base_lock); 353 354 return ret; 355 } 356 357 /* show function template for wireless fields */ 358 #define WIRELESS_SHOW(name, field, format_string) \ 359 static ssize_t format_iw_##name(const struct iw_statistics *iw, char *buf) \ 360 { \ 361 return sprintf(buf, format_string, iw->field); \ 362 } \ 363 static ssize_t show_iw_##name(struct class_device *cd, char *buf) \ 364 { \ 365 return wireless_show(cd, buf, format_iw_##name); \ 366 } \ 367 static CLASS_DEVICE_ATTR(name, S_IRUGO, show_iw_##name, NULL) 368 369 WIRELESS_SHOW(status, status, fmt_hex); 370 WIRELESS_SHOW(link, qual.qual, fmt_dec); 371 WIRELESS_SHOW(level, qual.level, fmt_dec); 372 WIRELESS_SHOW(noise, qual.noise, fmt_dec); 373 WIRELESS_SHOW(nwid, discard.nwid, fmt_dec); 374 WIRELESS_SHOW(crypt, discard.code, fmt_dec); 375 WIRELESS_SHOW(fragment, discard.fragment, fmt_dec); 376 WIRELESS_SHOW(misc, discard.misc, fmt_dec); 377 WIRELESS_SHOW(retries, discard.retries, fmt_dec); 378 WIRELESS_SHOW(beacon, miss.beacon, fmt_dec); 379 380 static struct attribute *wireless_attrs[] = { 381 &class_device_attr_status.attr, 382 &class_device_attr_link.attr, 383 &class_device_attr_level.attr, 384 &class_device_attr_noise.attr, 385 &class_device_attr_nwid.attr, 386 &class_device_attr_crypt.attr, 387 &class_device_attr_fragment.attr, 388 &class_device_attr_retries.attr, 389 &class_device_attr_misc.attr, 390 &class_device_attr_beacon.attr, 391 NULL 392 }; 393 394 static struct attribute_group wireless_group = { 395 .name = "wireless", 396 .attrs = wireless_attrs, 397 }; 398 #endif 399 400 #ifdef CONFIG_HOTPLUG 401 static int netdev_uevent(struct class_device *cd, char **envp, 402 int num_envp, char *buf, int size) 403 { 404 struct net_device *dev = to_net_dev(cd); 405 int i = 0; 406 int n; 407 408 /* pass interface to uevent. */ 409 envp[i++] = buf; 410 n = snprintf(buf, size, "INTERFACE=%s", dev->name) + 1; 411 buf += n; 412 size -= n; 413 414 if ((size <= 0) || (i >= num_envp)) 415 return -ENOMEM; 416 417 envp[i] = NULL; 418 return 0; 419 } 420 #endif 421 422 /* 423 * netdev_release -- destroy and free a dead device. 424 * Called when last reference to class_device kobject is gone. 425 */ 426 static void netdev_release(struct class_device *cd) 427 { 428 struct net_device *dev 429 = container_of(cd, struct net_device, class_dev); 430 431 BUG_ON(dev->reg_state != NETREG_RELEASED); 432 433 kfree((char *)dev - dev->padded); 434 } 435 436 static struct class net_class = { 437 .name = "net", 438 .release = netdev_release, 439 .class_dev_attrs = net_class_attributes, 440 #ifdef CONFIG_HOTPLUG 441 .uevent = netdev_uevent, 442 #endif 443 }; 444 445 void netdev_unregister_sysfs(struct net_device * net) 446 { 447 class_device_del(&(net->class_dev)); 448 } 449 450 /* Create sysfs entries for network device. */ 451 int netdev_register_sysfs(struct net_device *net) 452 { 453 struct class_device *class_dev = &(net->class_dev); 454 struct attribute_group **groups = net->sysfs_groups; 455 456 class_device_initialize(class_dev); 457 class_dev->class = &net_class; 458 class_dev->class_data = net; 459 class_dev->groups = groups; 460 461 BUILD_BUG_ON(BUS_ID_SIZE < IFNAMSIZ); 462 strlcpy(class_dev->class_id, net->name, BUS_ID_SIZE); 463 464 if (net->get_stats) 465 *groups++ = &netstat_group; 466 467 #ifdef WIRELESS_EXT 468 if (net->get_wireless_stats 469 || (net->wireless_handlers && net->wireless_handlers->get_wireless_stats)) 470 *groups++ = &wireless_group; 471 #endif 472 473 return class_device_add(class_dev); 474 } 475 476 int netdev_sysfs_init(void) 477 { 478 return class_register(&net_class); 479 } 480