1 /* 2 * Sysfs attributes of bridge ports 3 * Linux ethernet bridge 4 * 5 * Authors: 6 * Stephen Hemminger <shemminger@osdl.org> 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License 10 * as published by the Free Software Foundation; either version 11 * 2 of the License, or (at your option) any later version. 12 */ 13 14 #include <linux/capability.h> 15 #include <linux/kernel.h> 16 #include <linux/netdevice.h> 17 #include <linux/if_bridge.h> 18 #include <linux/rtnetlink.h> 19 #include <linux/spinlock.h> 20 #include <linux/times.h> 21 22 #include "br_private.h" 23 24 #define to_dev(obj) container_of(obj, struct device, kobj) 25 #define to_bridge(cd) ((struct net_bridge *)netdev_priv(to_net_dev(cd))) 26 27 /* 28 * Common code for storing bridge parameters. 29 */ 30 static ssize_t store_bridge_parm(struct device *d, 31 const char *buf, size_t len, 32 int (*set)(struct net_bridge *, unsigned long)) 33 { 34 struct net_bridge *br = to_bridge(d); 35 char *endp; 36 unsigned long val; 37 int err; 38 39 if (!capable(CAP_NET_ADMIN)) 40 return -EPERM; 41 42 val = simple_strtoul(buf, &endp, 0); 43 if (endp == buf) 44 return -EINVAL; 45 46 err = (*set)(br, val); 47 return err ? err : len; 48 } 49 50 51 static ssize_t show_forward_delay(struct device *d, 52 struct device_attribute *attr, char *buf) 53 { 54 struct net_bridge *br = to_bridge(d); 55 return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->forward_delay)); 56 } 57 58 static ssize_t store_forward_delay(struct device *d, 59 struct device_attribute *attr, 60 const char *buf, size_t len) 61 { 62 return store_bridge_parm(d, buf, len, br_set_forward_delay); 63 } 64 static DEVICE_ATTR(forward_delay, S_IRUGO | S_IWUSR, 65 show_forward_delay, store_forward_delay); 66 67 static ssize_t show_hello_time(struct device *d, struct device_attribute *attr, 68 char *buf) 69 { 70 return sprintf(buf, "%lu\n", 71 jiffies_to_clock_t(to_bridge(d)->hello_time)); 72 } 73 74 static ssize_t store_hello_time(struct device *d, 75 struct device_attribute *attr, const char *buf, 76 size_t len) 77 { 78 return store_bridge_parm(d, buf, len, br_set_hello_time); 79 } 80 static DEVICE_ATTR(hello_time, S_IRUGO | S_IWUSR, show_hello_time, 81 store_hello_time); 82 83 static ssize_t show_max_age(struct device *d, struct device_attribute *attr, 84 char *buf) 85 { 86 return sprintf(buf, "%lu\n", 87 jiffies_to_clock_t(to_bridge(d)->max_age)); 88 } 89 90 static ssize_t store_max_age(struct device *d, struct device_attribute *attr, 91 const char *buf, size_t len) 92 { 93 return store_bridge_parm(d, buf, len, br_set_max_age); 94 } 95 static DEVICE_ATTR(max_age, S_IRUGO | S_IWUSR, show_max_age, store_max_age); 96 97 static ssize_t show_ageing_time(struct device *d, 98 struct device_attribute *attr, char *buf) 99 { 100 struct net_bridge *br = to_bridge(d); 101 return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->ageing_time)); 102 } 103 104 static int set_ageing_time(struct net_bridge *br, unsigned long val) 105 { 106 br->ageing_time = clock_t_to_jiffies(val); 107 return 0; 108 } 109 110 static ssize_t store_ageing_time(struct device *d, 111 struct device_attribute *attr, 112 const char *buf, size_t len) 113 { 114 return store_bridge_parm(d, buf, len, set_ageing_time); 115 } 116 static DEVICE_ATTR(ageing_time, S_IRUGO | S_IWUSR, show_ageing_time, 117 store_ageing_time); 118 119 static ssize_t show_stp_state(struct device *d, 120 struct device_attribute *attr, char *buf) 121 { 122 struct net_bridge *br = to_bridge(d); 123 return sprintf(buf, "%d\n", br->stp_enabled); 124 } 125 126 127 static ssize_t store_stp_state(struct device *d, 128 struct device_attribute *attr, const char *buf, 129 size_t len) 130 { 131 struct net_bridge *br = to_bridge(d); 132 char *endp; 133 unsigned long val; 134 135 if (!capable(CAP_NET_ADMIN)) 136 return -EPERM; 137 138 val = simple_strtoul(buf, &endp, 0); 139 if (endp == buf) 140 return -EINVAL; 141 142 if (!rtnl_trylock()) 143 return restart_syscall(); 144 br_stp_set_enabled(br, val); 145 rtnl_unlock(); 146 147 return len; 148 } 149 static DEVICE_ATTR(stp_state, S_IRUGO | S_IWUSR, show_stp_state, 150 store_stp_state); 151 152 static ssize_t show_priority(struct device *d, struct device_attribute *attr, 153 char *buf) 154 { 155 struct net_bridge *br = to_bridge(d); 156 return sprintf(buf, "%d\n", 157 (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1]); 158 } 159 160 static int set_priority(struct net_bridge *br, unsigned long val) 161 { 162 br_stp_set_bridge_priority(br, (u16) val); 163 return 0; 164 } 165 166 static ssize_t store_priority(struct device *d, struct device_attribute *attr, 167 const char *buf, size_t len) 168 { 169 return store_bridge_parm(d, buf, len, set_priority); 170 } 171 static DEVICE_ATTR(priority, S_IRUGO | S_IWUSR, show_priority, store_priority); 172 173 static ssize_t show_root_id(struct device *d, struct device_attribute *attr, 174 char *buf) 175 { 176 return br_show_bridge_id(buf, &to_bridge(d)->designated_root); 177 } 178 static DEVICE_ATTR(root_id, S_IRUGO, show_root_id, NULL); 179 180 static ssize_t show_bridge_id(struct device *d, struct device_attribute *attr, 181 char *buf) 182 { 183 return br_show_bridge_id(buf, &to_bridge(d)->bridge_id); 184 } 185 static DEVICE_ATTR(bridge_id, S_IRUGO, show_bridge_id, NULL); 186 187 static ssize_t show_root_port(struct device *d, struct device_attribute *attr, 188 char *buf) 189 { 190 return sprintf(buf, "%d\n", to_bridge(d)->root_port); 191 } 192 static DEVICE_ATTR(root_port, S_IRUGO, show_root_port, NULL); 193 194 static ssize_t show_root_path_cost(struct device *d, 195 struct device_attribute *attr, char *buf) 196 { 197 return sprintf(buf, "%d\n", to_bridge(d)->root_path_cost); 198 } 199 static DEVICE_ATTR(root_path_cost, S_IRUGO, show_root_path_cost, NULL); 200 201 static ssize_t show_topology_change(struct device *d, 202 struct device_attribute *attr, char *buf) 203 { 204 return sprintf(buf, "%d\n", to_bridge(d)->topology_change); 205 } 206 static DEVICE_ATTR(topology_change, S_IRUGO, show_topology_change, NULL); 207 208 static ssize_t show_topology_change_detected(struct device *d, 209 struct device_attribute *attr, 210 char *buf) 211 { 212 struct net_bridge *br = to_bridge(d); 213 return sprintf(buf, "%d\n", br->topology_change_detected); 214 } 215 static DEVICE_ATTR(topology_change_detected, S_IRUGO, 216 show_topology_change_detected, NULL); 217 218 static ssize_t show_hello_timer(struct device *d, 219 struct device_attribute *attr, char *buf) 220 { 221 struct net_bridge *br = to_bridge(d); 222 return sprintf(buf, "%ld\n", br_timer_value(&br->hello_timer)); 223 } 224 static DEVICE_ATTR(hello_timer, S_IRUGO, show_hello_timer, NULL); 225 226 static ssize_t show_tcn_timer(struct device *d, struct device_attribute *attr, 227 char *buf) 228 { 229 struct net_bridge *br = to_bridge(d); 230 return sprintf(buf, "%ld\n", br_timer_value(&br->tcn_timer)); 231 } 232 static DEVICE_ATTR(tcn_timer, S_IRUGO, show_tcn_timer, NULL); 233 234 static ssize_t show_topology_change_timer(struct device *d, 235 struct device_attribute *attr, 236 char *buf) 237 { 238 struct net_bridge *br = to_bridge(d); 239 return sprintf(buf, "%ld\n", br_timer_value(&br->topology_change_timer)); 240 } 241 static DEVICE_ATTR(topology_change_timer, S_IRUGO, show_topology_change_timer, 242 NULL); 243 244 static ssize_t show_gc_timer(struct device *d, struct device_attribute *attr, 245 char *buf) 246 { 247 struct net_bridge *br = to_bridge(d); 248 return sprintf(buf, "%ld\n", br_timer_value(&br->gc_timer)); 249 } 250 static DEVICE_ATTR(gc_timer, S_IRUGO, show_gc_timer, NULL); 251 252 static ssize_t show_group_addr(struct device *d, 253 struct device_attribute *attr, char *buf) 254 { 255 struct net_bridge *br = to_bridge(d); 256 return sprintf(buf, "%x:%x:%x:%x:%x:%x\n", 257 br->group_addr[0], br->group_addr[1], 258 br->group_addr[2], br->group_addr[3], 259 br->group_addr[4], br->group_addr[5]); 260 } 261 262 static ssize_t store_group_addr(struct device *d, 263 struct device_attribute *attr, 264 const char *buf, size_t len) 265 { 266 struct net_bridge *br = to_bridge(d); 267 unsigned new_addr[6]; 268 int i; 269 270 if (!capable(CAP_NET_ADMIN)) 271 return -EPERM; 272 273 if (sscanf(buf, "%x:%x:%x:%x:%x:%x", 274 &new_addr[0], &new_addr[1], &new_addr[2], 275 &new_addr[3], &new_addr[4], &new_addr[5]) != 6) 276 return -EINVAL; 277 278 /* Must be 01:80:c2:00:00:0X */ 279 for (i = 0; i < 5; i++) 280 if (new_addr[i] != br_group_address[i]) 281 return -EINVAL; 282 283 if (new_addr[5] & ~0xf) 284 return -EINVAL; 285 286 if (new_addr[5] == 1 || /* 802.3x Pause address */ 287 new_addr[5] == 2 || /* 802.3ad Slow protocols */ 288 new_addr[5] == 3) /* 802.1X PAE address */ 289 return -EINVAL; 290 291 spin_lock_bh(&br->lock); 292 for (i = 0; i < 6; i++) 293 br->group_addr[i] = new_addr[i]; 294 spin_unlock_bh(&br->lock); 295 return len; 296 } 297 298 static DEVICE_ATTR(group_addr, S_IRUGO | S_IWUSR, 299 show_group_addr, store_group_addr); 300 301 static ssize_t store_flush(struct device *d, 302 struct device_attribute *attr, 303 const char *buf, size_t len) 304 { 305 struct net_bridge *br = to_bridge(d); 306 307 if (!capable(CAP_NET_ADMIN)) 308 return -EPERM; 309 310 br_fdb_flush(br); 311 return len; 312 } 313 static DEVICE_ATTR(flush, S_IWUSR, NULL, store_flush); 314 315 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING 316 static ssize_t show_multicast_router(struct device *d, 317 struct device_attribute *attr, char *buf) 318 { 319 struct net_bridge *br = to_bridge(d); 320 return sprintf(buf, "%d\n", br->multicast_router); 321 } 322 323 static ssize_t store_multicast_router(struct device *d, 324 struct device_attribute *attr, 325 const char *buf, size_t len) 326 { 327 return store_bridge_parm(d, buf, len, br_multicast_set_router); 328 } 329 static DEVICE_ATTR(multicast_router, S_IRUGO | S_IWUSR, show_multicast_router, 330 store_multicast_router); 331 332 static ssize_t show_multicast_snooping(struct device *d, 333 struct device_attribute *attr, 334 char *buf) 335 { 336 struct net_bridge *br = to_bridge(d); 337 return sprintf(buf, "%d\n", !br->multicast_disabled); 338 } 339 340 static ssize_t store_multicast_snooping(struct device *d, 341 struct device_attribute *attr, 342 const char *buf, size_t len) 343 { 344 return store_bridge_parm(d, buf, len, br_multicast_toggle); 345 } 346 static DEVICE_ATTR(multicast_snooping, S_IRUGO | S_IWUSR, 347 show_multicast_snooping, store_multicast_snooping); 348 349 static ssize_t show_hash_elasticity(struct device *d, 350 struct device_attribute *attr, char *buf) 351 { 352 struct net_bridge *br = to_bridge(d); 353 return sprintf(buf, "%u\n", br->hash_elasticity); 354 } 355 356 static int set_elasticity(struct net_bridge *br, unsigned long val) 357 { 358 br->hash_elasticity = val; 359 return 0; 360 } 361 362 static ssize_t store_hash_elasticity(struct device *d, 363 struct device_attribute *attr, 364 const char *buf, size_t len) 365 { 366 return store_bridge_parm(d, buf, len, set_elasticity); 367 } 368 static DEVICE_ATTR(hash_elasticity, S_IRUGO | S_IWUSR, show_hash_elasticity, 369 store_hash_elasticity); 370 371 static ssize_t show_hash_max(struct device *d, struct device_attribute *attr, 372 char *buf) 373 { 374 struct net_bridge *br = to_bridge(d); 375 return sprintf(buf, "%u\n", br->hash_max); 376 } 377 378 static ssize_t store_hash_max(struct device *d, struct device_attribute *attr, 379 const char *buf, size_t len) 380 { 381 return store_bridge_parm(d, buf, len, br_multicast_set_hash_max); 382 } 383 static DEVICE_ATTR(hash_max, S_IRUGO | S_IWUSR, show_hash_max, 384 store_hash_max); 385 386 static ssize_t show_multicast_last_member_count(struct device *d, 387 struct device_attribute *attr, 388 char *buf) 389 { 390 struct net_bridge *br = to_bridge(d); 391 return sprintf(buf, "%u\n", br->multicast_last_member_count); 392 } 393 394 static int set_last_member_count(struct net_bridge *br, unsigned long val) 395 { 396 br->multicast_last_member_count = val; 397 return 0; 398 } 399 400 static ssize_t store_multicast_last_member_count(struct device *d, 401 struct device_attribute *attr, 402 const char *buf, size_t len) 403 { 404 return store_bridge_parm(d, buf, len, set_last_member_count); 405 } 406 static DEVICE_ATTR(multicast_last_member_count, S_IRUGO | S_IWUSR, 407 show_multicast_last_member_count, 408 store_multicast_last_member_count); 409 410 static ssize_t show_multicast_startup_query_count( 411 struct device *d, struct device_attribute *attr, char *buf) 412 { 413 struct net_bridge *br = to_bridge(d); 414 return sprintf(buf, "%u\n", br->multicast_startup_query_count); 415 } 416 417 static int set_startup_query_count(struct net_bridge *br, unsigned long val) 418 { 419 br->multicast_startup_query_count = val; 420 return 0; 421 } 422 423 static ssize_t store_multicast_startup_query_count( 424 struct device *d, struct device_attribute *attr, const char *buf, 425 size_t len) 426 { 427 return store_bridge_parm(d, buf, len, set_startup_query_count); 428 } 429 static DEVICE_ATTR(multicast_startup_query_count, S_IRUGO | S_IWUSR, 430 show_multicast_startup_query_count, 431 store_multicast_startup_query_count); 432 433 static ssize_t show_multicast_last_member_interval( 434 struct device *d, struct device_attribute *attr, char *buf) 435 { 436 struct net_bridge *br = to_bridge(d); 437 return sprintf(buf, "%lu\n", 438 jiffies_to_clock_t(br->multicast_last_member_interval)); 439 } 440 441 static int set_last_member_interval(struct net_bridge *br, unsigned long val) 442 { 443 br->multicast_last_member_interval = clock_t_to_jiffies(val); 444 return 0; 445 } 446 447 static ssize_t store_multicast_last_member_interval( 448 struct device *d, struct device_attribute *attr, const char *buf, 449 size_t len) 450 { 451 return store_bridge_parm(d, buf, len, set_last_member_interval); 452 } 453 static DEVICE_ATTR(multicast_last_member_interval, S_IRUGO | S_IWUSR, 454 show_multicast_last_member_interval, 455 store_multicast_last_member_interval); 456 457 static ssize_t show_multicast_membership_interval( 458 struct device *d, struct device_attribute *attr, char *buf) 459 { 460 struct net_bridge *br = to_bridge(d); 461 return sprintf(buf, "%lu\n", 462 jiffies_to_clock_t(br->multicast_membership_interval)); 463 } 464 465 static int set_membership_interval(struct net_bridge *br, unsigned long val) 466 { 467 br->multicast_membership_interval = clock_t_to_jiffies(val); 468 return 0; 469 } 470 471 static ssize_t store_multicast_membership_interval( 472 struct device *d, struct device_attribute *attr, const char *buf, 473 size_t len) 474 { 475 return store_bridge_parm(d, buf, len, set_membership_interval); 476 } 477 static DEVICE_ATTR(multicast_membership_interval, S_IRUGO | S_IWUSR, 478 show_multicast_membership_interval, 479 store_multicast_membership_interval); 480 481 static ssize_t show_multicast_querier_interval(struct device *d, 482 struct device_attribute *attr, 483 char *buf) 484 { 485 struct net_bridge *br = to_bridge(d); 486 return sprintf(buf, "%lu\n", 487 jiffies_to_clock_t(br->multicast_querier_interval)); 488 } 489 490 static int set_querier_interval(struct net_bridge *br, unsigned long val) 491 { 492 br->multicast_querier_interval = clock_t_to_jiffies(val); 493 return 0; 494 } 495 496 static ssize_t store_multicast_querier_interval(struct device *d, 497 struct device_attribute *attr, 498 const char *buf, size_t len) 499 { 500 return store_bridge_parm(d, buf, len, set_querier_interval); 501 } 502 static DEVICE_ATTR(multicast_querier_interval, S_IRUGO | S_IWUSR, 503 show_multicast_querier_interval, 504 store_multicast_querier_interval); 505 506 static ssize_t show_multicast_query_interval(struct device *d, 507 struct device_attribute *attr, 508 char *buf) 509 { 510 struct net_bridge *br = to_bridge(d); 511 return sprintf(buf, "%lu\n", 512 jiffies_to_clock_t(br->multicast_query_interval)); 513 } 514 515 static int set_query_interval(struct net_bridge *br, unsigned long val) 516 { 517 br->multicast_query_interval = clock_t_to_jiffies(val); 518 return 0; 519 } 520 521 static ssize_t store_multicast_query_interval(struct device *d, 522 struct device_attribute *attr, 523 const char *buf, size_t len) 524 { 525 return store_bridge_parm(d, buf, len, set_query_interval); 526 } 527 static DEVICE_ATTR(multicast_query_interval, S_IRUGO | S_IWUSR, 528 show_multicast_query_interval, 529 store_multicast_query_interval); 530 531 static ssize_t show_multicast_query_response_interval( 532 struct device *d, struct device_attribute *attr, char *buf) 533 { 534 struct net_bridge *br = to_bridge(d); 535 return sprintf( 536 buf, "%lu\n", 537 jiffies_to_clock_t(br->multicast_query_response_interval)); 538 } 539 540 static int set_query_response_interval(struct net_bridge *br, unsigned long val) 541 { 542 br->multicast_query_response_interval = clock_t_to_jiffies(val); 543 return 0; 544 } 545 546 static ssize_t store_multicast_query_response_interval( 547 struct device *d, struct device_attribute *attr, const char *buf, 548 size_t len) 549 { 550 return store_bridge_parm(d, buf, len, set_query_response_interval); 551 } 552 static DEVICE_ATTR(multicast_query_response_interval, S_IRUGO | S_IWUSR, 553 show_multicast_query_response_interval, 554 store_multicast_query_response_interval); 555 556 static ssize_t show_multicast_startup_query_interval( 557 struct device *d, struct device_attribute *attr, char *buf) 558 { 559 struct net_bridge *br = to_bridge(d); 560 return sprintf( 561 buf, "%lu\n", 562 jiffies_to_clock_t(br->multicast_startup_query_interval)); 563 } 564 565 static int set_startup_query_interval(struct net_bridge *br, unsigned long val) 566 { 567 br->multicast_startup_query_interval = clock_t_to_jiffies(val); 568 return 0; 569 } 570 571 static ssize_t store_multicast_startup_query_interval( 572 struct device *d, struct device_attribute *attr, const char *buf, 573 size_t len) 574 { 575 return store_bridge_parm(d, buf, len, set_startup_query_interval); 576 } 577 static DEVICE_ATTR(multicast_startup_query_interval, S_IRUGO | S_IWUSR, 578 show_multicast_startup_query_interval, 579 store_multicast_startup_query_interval); 580 #endif 581 #ifdef CONFIG_BRIDGE_NETFILTER 582 static ssize_t show_nf_call_iptables( 583 struct device *d, struct device_attribute *attr, char *buf) 584 { 585 struct net_bridge *br = to_bridge(d); 586 return sprintf(buf, "%u\n", br->nf_call_iptables); 587 } 588 589 static int set_nf_call_iptables(struct net_bridge *br, unsigned long val) 590 { 591 br->nf_call_iptables = val ? true : false; 592 return 0; 593 } 594 595 static ssize_t store_nf_call_iptables( 596 struct device *d, struct device_attribute *attr, const char *buf, 597 size_t len) 598 { 599 return store_bridge_parm(d, buf, len, set_nf_call_iptables); 600 } 601 static DEVICE_ATTR(nf_call_iptables, S_IRUGO | S_IWUSR, 602 show_nf_call_iptables, store_nf_call_iptables); 603 604 static ssize_t show_nf_call_ip6tables( 605 struct device *d, struct device_attribute *attr, char *buf) 606 { 607 struct net_bridge *br = to_bridge(d); 608 return sprintf(buf, "%u\n", br->nf_call_ip6tables); 609 } 610 611 static int set_nf_call_ip6tables(struct net_bridge *br, unsigned long val) 612 { 613 br->nf_call_ip6tables = val ? true : false; 614 return 0; 615 } 616 617 static ssize_t store_nf_call_ip6tables( 618 struct device *d, struct device_attribute *attr, const char *buf, 619 size_t len) 620 { 621 return store_bridge_parm(d, buf, len, set_nf_call_ip6tables); 622 } 623 static DEVICE_ATTR(nf_call_ip6tables, S_IRUGO | S_IWUSR, 624 show_nf_call_ip6tables, store_nf_call_ip6tables); 625 626 static ssize_t show_nf_call_arptables( 627 struct device *d, struct device_attribute *attr, char *buf) 628 { 629 struct net_bridge *br = to_bridge(d); 630 return sprintf(buf, "%u\n", br->nf_call_arptables); 631 } 632 633 static int set_nf_call_arptables(struct net_bridge *br, unsigned long val) 634 { 635 br->nf_call_arptables = val ? true : false; 636 return 0; 637 } 638 639 static ssize_t store_nf_call_arptables( 640 struct device *d, struct device_attribute *attr, const char *buf, 641 size_t len) 642 { 643 return store_bridge_parm(d, buf, len, set_nf_call_arptables); 644 } 645 static DEVICE_ATTR(nf_call_arptables, S_IRUGO | S_IWUSR, 646 show_nf_call_arptables, store_nf_call_arptables); 647 #endif 648 649 static struct attribute *bridge_attrs[] = { 650 &dev_attr_forward_delay.attr, 651 &dev_attr_hello_time.attr, 652 &dev_attr_max_age.attr, 653 &dev_attr_ageing_time.attr, 654 &dev_attr_stp_state.attr, 655 &dev_attr_priority.attr, 656 &dev_attr_bridge_id.attr, 657 &dev_attr_root_id.attr, 658 &dev_attr_root_path_cost.attr, 659 &dev_attr_root_port.attr, 660 &dev_attr_topology_change.attr, 661 &dev_attr_topology_change_detected.attr, 662 &dev_attr_hello_timer.attr, 663 &dev_attr_tcn_timer.attr, 664 &dev_attr_topology_change_timer.attr, 665 &dev_attr_gc_timer.attr, 666 &dev_attr_group_addr.attr, 667 &dev_attr_flush.attr, 668 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING 669 &dev_attr_multicast_router.attr, 670 &dev_attr_multicast_snooping.attr, 671 &dev_attr_hash_elasticity.attr, 672 &dev_attr_hash_max.attr, 673 &dev_attr_multicast_last_member_count.attr, 674 &dev_attr_multicast_startup_query_count.attr, 675 &dev_attr_multicast_last_member_interval.attr, 676 &dev_attr_multicast_membership_interval.attr, 677 &dev_attr_multicast_querier_interval.attr, 678 &dev_attr_multicast_query_interval.attr, 679 &dev_attr_multicast_query_response_interval.attr, 680 &dev_attr_multicast_startup_query_interval.attr, 681 #endif 682 #ifdef CONFIG_BRIDGE_NETFILTER 683 &dev_attr_nf_call_iptables.attr, 684 &dev_attr_nf_call_ip6tables.attr, 685 &dev_attr_nf_call_arptables.attr, 686 #endif 687 NULL 688 }; 689 690 static struct attribute_group bridge_group = { 691 .name = SYSFS_BRIDGE_ATTR, 692 .attrs = bridge_attrs, 693 }; 694 695 /* 696 * Export the forwarding information table as a binary file 697 * The records are struct __fdb_entry. 698 * 699 * Returns the number of bytes read. 700 */ 701 static ssize_t brforward_read(struct file *filp, struct kobject *kobj, 702 struct bin_attribute *bin_attr, 703 char *buf, loff_t off, size_t count) 704 { 705 struct device *dev = to_dev(kobj); 706 struct net_bridge *br = to_bridge(dev); 707 int n; 708 709 /* must read whole records */ 710 if (off % sizeof(struct __fdb_entry) != 0) 711 return -EINVAL; 712 713 n = br_fdb_fillbuf(br, buf, 714 count / sizeof(struct __fdb_entry), 715 off / sizeof(struct __fdb_entry)); 716 717 if (n > 0) 718 n *= sizeof(struct __fdb_entry); 719 720 return n; 721 } 722 723 static struct bin_attribute bridge_forward = { 724 .attr = { .name = SYSFS_BRIDGE_FDB, 725 .mode = S_IRUGO, }, 726 .read = brforward_read, 727 }; 728 729 /* 730 * Add entries in sysfs onto the existing network class device 731 * for the bridge. 732 * Adds a attribute group "bridge" containing tuning parameters. 733 * Binary attribute containing the forward table 734 * Sub directory to hold links to interfaces. 735 * 736 * Note: the ifobj exists only to be a subdirectory 737 * to hold links. The ifobj exists in same data structure 738 * as it's parent the bridge so reference counting works. 739 */ 740 int br_sysfs_addbr(struct net_device *dev) 741 { 742 struct kobject *brobj = &dev->dev.kobj; 743 struct net_bridge *br = netdev_priv(dev); 744 int err; 745 746 err = sysfs_create_group(brobj, &bridge_group); 747 if (err) { 748 pr_info("%s: can't create group %s/%s\n", 749 __func__, dev->name, bridge_group.name); 750 goto out1; 751 } 752 753 err = sysfs_create_bin_file(brobj, &bridge_forward); 754 if (err) { 755 pr_info("%s: can't create attribute file %s/%s\n", 756 __func__, dev->name, bridge_forward.attr.name); 757 goto out2; 758 } 759 760 br->ifobj = kobject_create_and_add(SYSFS_BRIDGE_PORT_SUBDIR, brobj); 761 if (!br->ifobj) { 762 pr_info("%s: can't add kobject (directory) %s/%s\n", 763 __func__, dev->name, SYSFS_BRIDGE_PORT_SUBDIR); 764 goto out3; 765 } 766 return 0; 767 out3: 768 sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward); 769 out2: 770 sysfs_remove_group(&dev->dev.kobj, &bridge_group); 771 out1: 772 return err; 773 774 } 775 776 void br_sysfs_delbr(struct net_device *dev) 777 { 778 struct kobject *kobj = &dev->dev.kobj; 779 struct net_bridge *br = netdev_priv(dev); 780 781 kobject_put(br->ifobj); 782 sysfs_remove_bin_file(kobj, &bridge_forward); 783 sysfs_remove_group(kobj, &bridge_group); 784 } 785