1 /* 2 * Sysfs attributes of bridge 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/etherdevice.h> 18 #include <linux/if_bridge.h> 19 #include <linux/rtnetlink.h> 20 #include <linux/spinlock.h> 21 #include <linux/times.h> 22 23 #include "br_private.h" 24 25 #define to_dev(obj) container_of(obj, struct device, kobj) 26 #define to_bridge(cd) ((struct net_bridge *)netdev_priv(to_net_dev(cd))) 27 28 /* 29 * Common code for storing bridge parameters. 30 */ 31 static ssize_t store_bridge_parm(struct device *d, 32 const char *buf, size_t len, 33 int (*set)(struct net_bridge *, unsigned long)) 34 { 35 struct net_bridge *br = to_bridge(d); 36 char *endp; 37 unsigned long val; 38 int err; 39 40 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN)) 41 return -EPERM; 42 43 val = simple_strtoul(buf, &endp, 0); 44 if (endp == buf) 45 return -EINVAL; 46 47 err = (*set)(br, val); 48 return err ? err : len; 49 } 50 51 52 static ssize_t forward_delay_show(struct device *d, 53 struct device_attribute *attr, char *buf) 54 { 55 struct net_bridge *br = to_bridge(d); 56 return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->forward_delay)); 57 } 58 59 static ssize_t forward_delay_store(struct device *d, 60 struct device_attribute *attr, 61 const char *buf, size_t len) 62 { 63 return store_bridge_parm(d, buf, len, br_set_forward_delay); 64 } 65 static DEVICE_ATTR_RW(forward_delay); 66 67 static ssize_t hello_time_show(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 hello_time_store(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_RW(hello_time); 81 82 static ssize_t max_age_show(struct device *d, struct device_attribute *attr, 83 char *buf) 84 { 85 return sprintf(buf, "%lu\n", 86 jiffies_to_clock_t(to_bridge(d)->max_age)); 87 } 88 89 static ssize_t max_age_store(struct device *d, struct device_attribute *attr, 90 const char *buf, size_t len) 91 { 92 return store_bridge_parm(d, buf, len, br_set_max_age); 93 } 94 static DEVICE_ATTR_RW(max_age); 95 96 static ssize_t ageing_time_show(struct device *d, 97 struct device_attribute *attr, char *buf) 98 { 99 struct net_bridge *br = to_bridge(d); 100 return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->ageing_time)); 101 } 102 103 static int set_ageing_time(struct net_bridge *br, unsigned long val) 104 { 105 br->ageing_time = clock_t_to_jiffies(val); 106 return 0; 107 } 108 109 static ssize_t ageing_time_store(struct device *d, 110 struct device_attribute *attr, 111 const char *buf, size_t len) 112 { 113 return store_bridge_parm(d, buf, len, set_ageing_time); 114 } 115 static DEVICE_ATTR_RW(ageing_time); 116 117 static ssize_t stp_state_show(struct device *d, 118 struct device_attribute *attr, char *buf) 119 { 120 struct net_bridge *br = to_bridge(d); 121 return sprintf(buf, "%d\n", br->stp_enabled); 122 } 123 124 125 static ssize_t stp_state_store(struct device *d, 126 struct device_attribute *attr, const char *buf, 127 size_t len) 128 { 129 struct net_bridge *br = to_bridge(d); 130 char *endp; 131 unsigned long val; 132 133 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN)) 134 return -EPERM; 135 136 val = simple_strtoul(buf, &endp, 0); 137 if (endp == buf) 138 return -EINVAL; 139 140 if (!rtnl_trylock()) 141 return restart_syscall(); 142 br_stp_set_enabled(br, val); 143 rtnl_unlock(); 144 145 return len; 146 } 147 static DEVICE_ATTR_RW(stp_state); 148 149 static ssize_t group_fwd_mask_show(struct device *d, 150 struct device_attribute *attr, 151 char *buf) 152 { 153 struct net_bridge *br = to_bridge(d); 154 return sprintf(buf, "%#x\n", br->group_fwd_mask); 155 } 156 157 158 static ssize_t group_fwd_mask_store(struct device *d, 159 struct device_attribute *attr, 160 const char *buf, 161 size_t len) 162 { 163 struct net_bridge *br = to_bridge(d); 164 char *endp; 165 unsigned long val; 166 167 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN)) 168 return -EPERM; 169 170 val = simple_strtoul(buf, &endp, 0); 171 if (endp == buf) 172 return -EINVAL; 173 174 if (val & BR_GROUPFWD_RESTRICTED) 175 return -EINVAL; 176 177 br->group_fwd_mask = val; 178 179 return len; 180 } 181 static DEVICE_ATTR_RW(group_fwd_mask); 182 183 static ssize_t priority_show(struct device *d, struct device_attribute *attr, 184 char *buf) 185 { 186 struct net_bridge *br = to_bridge(d); 187 return sprintf(buf, "%d\n", 188 (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1]); 189 } 190 191 static int set_priority(struct net_bridge *br, unsigned long val) 192 { 193 br_stp_set_bridge_priority(br, (u16) val); 194 return 0; 195 } 196 197 static ssize_t priority_store(struct device *d, struct device_attribute *attr, 198 const char *buf, size_t len) 199 { 200 return store_bridge_parm(d, buf, len, set_priority); 201 } 202 static DEVICE_ATTR_RW(priority); 203 204 static ssize_t root_id_show(struct device *d, struct device_attribute *attr, 205 char *buf) 206 { 207 return br_show_bridge_id(buf, &to_bridge(d)->designated_root); 208 } 209 static DEVICE_ATTR_RO(root_id); 210 211 static ssize_t bridge_id_show(struct device *d, struct device_attribute *attr, 212 char *buf) 213 { 214 return br_show_bridge_id(buf, &to_bridge(d)->bridge_id); 215 } 216 static DEVICE_ATTR_RO(bridge_id); 217 218 static ssize_t root_port_show(struct device *d, struct device_attribute *attr, 219 char *buf) 220 { 221 return sprintf(buf, "%d\n", to_bridge(d)->root_port); 222 } 223 static DEVICE_ATTR_RO(root_port); 224 225 static ssize_t root_path_cost_show(struct device *d, 226 struct device_attribute *attr, char *buf) 227 { 228 return sprintf(buf, "%d\n", to_bridge(d)->root_path_cost); 229 } 230 static DEVICE_ATTR_RO(root_path_cost); 231 232 static ssize_t topology_change_show(struct device *d, 233 struct device_attribute *attr, char *buf) 234 { 235 return sprintf(buf, "%d\n", to_bridge(d)->topology_change); 236 } 237 static DEVICE_ATTR_RO(topology_change); 238 239 static ssize_t topology_change_detected_show(struct device *d, 240 struct device_attribute *attr, 241 char *buf) 242 { 243 struct net_bridge *br = to_bridge(d); 244 return sprintf(buf, "%d\n", br->topology_change_detected); 245 } 246 static DEVICE_ATTR_RO(topology_change_detected); 247 248 static ssize_t hello_timer_show(struct device *d, 249 struct device_attribute *attr, char *buf) 250 { 251 struct net_bridge *br = to_bridge(d); 252 return sprintf(buf, "%ld\n", br_timer_value(&br->hello_timer)); 253 } 254 static DEVICE_ATTR_RO(hello_timer); 255 256 static ssize_t tcn_timer_show(struct device *d, struct device_attribute *attr, 257 char *buf) 258 { 259 struct net_bridge *br = to_bridge(d); 260 return sprintf(buf, "%ld\n", br_timer_value(&br->tcn_timer)); 261 } 262 static DEVICE_ATTR_RO(tcn_timer); 263 264 static ssize_t topology_change_timer_show(struct device *d, 265 struct device_attribute *attr, 266 char *buf) 267 { 268 struct net_bridge *br = to_bridge(d); 269 return sprintf(buf, "%ld\n", br_timer_value(&br->topology_change_timer)); 270 } 271 static DEVICE_ATTR_RO(topology_change_timer); 272 273 static ssize_t gc_timer_show(struct device *d, struct device_attribute *attr, 274 char *buf) 275 { 276 struct net_bridge *br = to_bridge(d); 277 return sprintf(buf, "%ld\n", br_timer_value(&br->gc_timer)); 278 } 279 static DEVICE_ATTR_RO(gc_timer); 280 281 static ssize_t group_addr_show(struct device *d, 282 struct device_attribute *attr, char *buf) 283 { 284 struct net_bridge *br = to_bridge(d); 285 return sprintf(buf, "%x:%x:%x:%x:%x:%x\n", 286 br->group_addr[0], br->group_addr[1], 287 br->group_addr[2], br->group_addr[3], 288 br->group_addr[4], br->group_addr[5]); 289 } 290 291 static ssize_t group_addr_store(struct device *d, 292 struct device_attribute *attr, 293 const char *buf, size_t len) 294 { 295 struct net_bridge *br = to_bridge(d); 296 u8 new_addr[6]; 297 int i; 298 299 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN)) 300 return -EPERM; 301 302 if (sscanf(buf, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", 303 &new_addr[0], &new_addr[1], &new_addr[2], 304 &new_addr[3], &new_addr[4], &new_addr[5]) != 6) 305 return -EINVAL; 306 307 if (!is_link_local_ether_addr(new_addr)) 308 return -EINVAL; 309 310 if (new_addr[5] == 1 || /* 802.3x Pause address */ 311 new_addr[5] == 2 || /* 802.3ad Slow protocols */ 312 new_addr[5] == 3) /* 802.1X PAE address */ 313 return -EINVAL; 314 315 spin_lock_bh(&br->lock); 316 for (i = 0; i < 6; i++) 317 br->group_addr[i] = new_addr[i]; 318 spin_unlock_bh(&br->lock); 319 return len; 320 } 321 322 static DEVICE_ATTR_RW(group_addr); 323 324 static ssize_t flush_store(struct device *d, 325 struct device_attribute *attr, 326 const char *buf, size_t len) 327 { 328 struct net_bridge *br = to_bridge(d); 329 330 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN)) 331 return -EPERM; 332 333 br_fdb_flush(br); 334 return len; 335 } 336 static DEVICE_ATTR_WO(flush); 337 338 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING 339 static ssize_t multicast_router_show(struct device *d, 340 struct device_attribute *attr, char *buf) 341 { 342 struct net_bridge *br = to_bridge(d); 343 return sprintf(buf, "%d\n", br->multicast_router); 344 } 345 346 static ssize_t multicast_router_store(struct device *d, 347 struct device_attribute *attr, 348 const char *buf, size_t len) 349 { 350 return store_bridge_parm(d, buf, len, br_multicast_set_router); 351 } 352 static DEVICE_ATTR_RW(multicast_router); 353 354 static ssize_t multicast_snooping_show(struct device *d, 355 struct device_attribute *attr, 356 char *buf) 357 { 358 struct net_bridge *br = to_bridge(d); 359 return sprintf(buf, "%d\n", !br->multicast_disabled); 360 } 361 362 static ssize_t multicast_snooping_store(struct device *d, 363 struct device_attribute *attr, 364 const char *buf, size_t len) 365 { 366 return store_bridge_parm(d, buf, len, br_multicast_toggle); 367 } 368 static DEVICE_ATTR_RW(multicast_snooping); 369 370 static ssize_t multicast_query_use_ifaddr_show(struct device *d, 371 struct device_attribute *attr, 372 char *buf) 373 { 374 struct net_bridge *br = to_bridge(d); 375 return sprintf(buf, "%d\n", br->multicast_query_use_ifaddr); 376 } 377 378 static int set_query_use_ifaddr(struct net_bridge *br, unsigned long val) 379 { 380 br->multicast_query_use_ifaddr = !!val; 381 return 0; 382 } 383 384 static ssize_t 385 multicast_query_use_ifaddr_store(struct device *d, 386 struct device_attribute *attr, 387 const char *buf, size_t len) 388 { 389 return store_bridge_parm(d, buf, len, set_query_use_ifaddr); 390 } 391 static DEVICE_ATTR_RW(multicast_query_use_ifaddr); 392 393 static ssize_t multicast_querier_show(struct device *d, 394 struct device_attribute *attr, 395 char *buf) 396 { 397 struct net_bridge *br = to_bridge(d); 398 return sprintf(buf, "%d\n", br->multicast_querier); 399 } 400 401 static ssize_t multicast_querier_store(struct device *d, 402 struct device_attribute *attr, 403 const char *buf, size_t len) 404 { 405 return store_bridge_parm(d, buf, len, br_multicast_set_querier); 406 } 407 static DEVICE_ATTR_RW(multicast_querier); 408 409 static ssize_t hash_elasticity_show(struct device *d, 410 struct device_attribute *attr, char *buf) 411 { 412 struct net_bridge *br = to_bridge(d); 413 return sprintf(buf, "%u\n", br->hash_elasticity); 414 } 415 416 static int set_elasticity(struct net_bridge *br, unsigned long val) 417 { 418 br->hash_elasticity = val; 419 return 0; 420 } 421 422 static ssize_t hash_elasticity_store(struct device *d, 423 struct device_attribute *attr, 424 const char *buf, size_t len) 425 { 426 return store_bridge_parm(d, buf, len, set_elasticity); 427 } 428 static DEVICE_ATTR_RW(hash_elasticity); 429 430 static ssize_t hash_max_show(struct device *d, struct device_attribute *attr, 431 char *buf) 432 { 433 struct net_bridge *br = to_bridge(d); 434 return sprintf(buf, "%u\n", br->hash_max); 435 } 436 437 static ssize_t hash_max_store(struct device *d, struct device_attribute *attr, 438 const char *buf, size_t len) 439 { 440 return store_bridge_parm(d, buf, len, br_multicast_set_hash_max); 441 } 442 static DEVICE_ATTR_RW(hash_max); 443 444 static ssize_t multicast_last_member_count_show(struct device *d, 445 struct device_attribute *attr, 446 char *buf) 447 { 448 struct net_bridge *br = to_bridge(d); 449 return sprintf(buf, "%u\n", br->multicast_last_member_count); 450 } 451 452 static int set_last_member_count(struct net_bridge *br, unsigned long val) 453 { 454 br->multicast_last_member_count = val; 455 return 0; 456 } 457 458 static ssize_t multicast_last_member_count_store(struct device *d, 459 struct device_attribute *attr, 460 const char *buf, size_t len) 461 { 462 return store_bridge_parm(d, buf, len, set_last_member_count); 463 } 464 static DEVICE_ATTR_RW(multicast_last_member_count); 465 466 static ssize_t multicast_startup_query_count_show( 467 struct device *d, struct device_attribute *attr, char *buf) 468 { 469 struct net_bridge *br = to_bridge(d); 470 return sprintf(buf, "%u\n", br->multicast_startup_query_count); 471 } 472 473 static int set_startup_query_count(struct net_bridge *br, unsigned long val) 474 { 475 br->multicast_startup_query_count = val; 476 return 0; 477 } 478 479 static ssize_t multicast_startup_query_count_store( 480 struct device *d, struct device_attribute *attr, const char *buf, 481 size_t len) 482 { 483 return store_bridge_parm(d, buf, len, set_startup_query_count); 484 } 485 static DEVICE_ATTR_RW(multicast_startup_query_count); 486 487 static ssize_t multicast_last_member_interval_show( 488 struct device *d, struct device_attribute *attr, char *buf) 489 { 490 struct net_bridge *br = to_bridge(d); 491 return sprintf(buf, "%lu\n", 492 jiffies_to_clock_t(br->multicast_last_member_interval)); 493 } 494 495 static int set_last_member_interval(struct net_bridge *br, unsigned long val) 496 { 497 br->multicast_last_member_interval = clock_t_to_jiffies(val); 498 return 0; 499 } 500 501 static ssize_t multicast_last_member_interval_store( 502 struct device *d, struct device_attribute *attr, const char *buf, 503 size_t len) 504 { 505 return store_bridge_parm(d, buf, len, set_last_member_interval); 506 } 507 static DEVICE_ATTR_RW(multicast_last_member_interval); 508 509 static ssize_t multicast_membership_interval_show( 510 struct device *d, struct device_attribute *attr, char *buf) 511 { 512 struct net_bridge *br = to_bridge(d); 513 return sprintf(buf, "%lu\n", 514 jiffies_to_clock_t(br->multicast_membership_interval)); 515 } 516 517 static int set_membership_interval(struct net_bridge *br, unsigned long val) 518 { 519 br->multicast_membership_interval = clock_t_to_jiffies(val); 520 return 0; 521 } 522 523 static ssize_t multicast_membership_interval_store( 524 struct device *d, struct device_attribute *attr, const char *buf, 525 size_t len) 526 { 527 return store_bridge_parm(d, buf, len, set_membership_interval); 528 } 529 static DEVICE_ATTR_RW(multicast_membership_interval); 530 531 static ssize_t multicast_querier_interval_show(struct device *d, 532 struct device_attribute *attr, 533 char *buf) 534 { 535 struct net_bridge *br = to_bridge(d); 536 return sprintf(buf, "%lu\n", 537 jiffies_to_clock_t(br->multicast_querier_interval)); 538 } 539 540 static int set_querier_interval(struct net_bridge *br, unsigned long val) 541 { 542 br->multicast_querier_interval = clock_t_to_jiffies(val); 543 return 0; 544 } 545 546 static ssize_t multicast_querier_interval_store(struct device *d, 547 struct device_attribute *attr, 548 const char *buf, size_t len) 549 { 550 return store_bridge_parm(d, buf, len, set_querier_interval); 551 } 552 static DEVICE_ATTR_RW(multicast_querier_interval); 553 554 static ssize_t multicast_query_interval_show(struct device *d, 555 struct device_attribute *attr, 556 char *buf) 557 { 558 struct net_bridge *br = to_bridge(d); 559 return sprintf(buf, "%lu\n", 560 jiffies_to_clock_t(br->multicast_query_interval)); 561 } 562 563 static int set_query_interval(struct net_bridge *br, unsigned long val) 564 { 565 br->multicast_query_interval = clock_t_to_jiffies(val); 566 return 0; 567 } 568 569 static ssize_t multicast_query_interval_store(struct device *d, 570 struct device_attribute *attr, 571 const char *buf, size_t len) 572 { 573 return store_bridge_parm(d, buf, len, set_query_interval); 574 } 575 static DEVICE_ATTR_RW(multicast_query_interval); 576 577 static ssize_t multicast_query_response_interval_show( 578 struct device *d, struct device_attribute *attr, char *buf) 579 { 580 struct net_bridge *br = to_bridge(d); 581 return sprintf( 582 buf, "%lu\n", 583 jiffies_to_clock_t(br->multicast_query_response_interval)); 584 } 585 586 static int set_query_response_interval(struct net_bridge *br, unsigned long val) 587 { 588 br->multicast_query_response_interval = clock_t_to_jiffies(val); 589 return 0; 590 } 591 592 static ssize_t multicast_query_response_interval_store( 593 struct device *d, struct device_attribute *attr, const char *buf, 594 size_t len) 595 { 596 return store_bridge_parm(d, buf, len, set_query_response_interval); 597 } 598 static DEVICE_ATTR_RW(multicast_query_response_interval); 599 600 static ssize_t multicast_startup_query_interval_show( 601 struct device *d, struct device_attribute *attr, char *buf) 602 { 603 struct net_bridge *br = to_bridge(d); 604 return sprintf( 605 buf, "%lu\n", 606 jiffies_to_clock_t(br->multicast_startup_query_interval)); 607 } 608 609 static int set_startup_query_interval(struct net_bridge *br, unsigned long val) 610 { 611 br->multicast_startup_query_interval = clock_t_to_jiffies(val); 612 return 0; 613 } 614 615 static ssize_t multicast_startup_query_interval_store( 616 struct device *d, struct device_attribute *attr, const char *buf, 617 size_t len) 618 { 619 return store_bridge_parm(d, buf, len, set_startup_query_interval); 620 } 621 static DEVICE_ATTR_RW(multicast_startup_query_interval); 622 #endif 623 #ifdef CONFIG_BRIDGE_NETFILTER 624 static ssize_t nf_call_iptables_show( 625 struct device *d, struct device_attribute *attr, char *buf) 626 { 627 struct net_bridge *br = to_bridge(d); 628 return sprintf(buf, "%u\n", br->nf_call_iptables); 629 } 630 631 static int set_nf_call_iptables(struct net_bridge *br, unsigned long val) 632 { 633 br->nf_call_iptables = val ? true : false; 634 return 0; 635 } 636 637 static ssize_t nf_call_iptables_store( 638 struct device *d, struct device_attribute *attr, const char *buf, 639 size_t len) 640 { 641 return store_bridge_parm(d, buf, len, set_nf_call_iptables); 642 } 643 static DEVICE_ATTR_RW(nf_call_iptables); 644 645 static ssize_t nf_call_ip6tables_show( 646 struct device *d, struct device_attribute *attr, char *buf) 647 { 648 struct net_bridge *br = to_bridge(d); 649 return sprintf(buf, "%u\n", br->nf_call_ip6tables); 650 } 651 652 static int set_nf_call_ip6tables(struct net_bridge *br, unsigned long val) 653 { 654 br->nf_call_ip6tables = val ? true : false; 655 return 0; 656 } 657 658 static ssize_t nf_call_ip6tables_store( 659 struct device *d, struct device_attribute *attr, const char *buf, 660 size_t len) 661 { 662 return store_bridge_parm(d, buf, len, set_nf_call_ip6tables); 663 } 664 static DEVICE_ATTR_RW(nf_call_ip6tables); 665 666 static ssize_t nf_call_arptables_show( 667 struct device *d, struct device_attribute *attr, char *buf) 668 { 669 struct net_bridge *br = to_bridge(d); 670 return sprintf(buf, "%u\n", br->nf_call_arptables); 671 } 672 673 static int set_nf_call_arptables(struct net_bridge *br, unsigned long val) 674 { 675 br->nf_call_arptables = val ? true : false; 676 return 0; 677 } 678 679 static ssize_t nf_call_arptables_store( 680 struct device *d, struct device_attribute *attr, const char *buf, 681 size_t len) 682 { 683 return store_bridge_parm(d, buf, len, set_nf_call_arptables); 684 } 685 static DEVICE_ATTR_RW(nf_call_arptables); 686 #endif 687 #ifdef CONFIG_BRIDGE_VLAN_FILTERING 688 static ssize_t vlan_filtering_show(struct device *d, 689 struct device_attribute *attr, 690 char *buf) 691 { 692 struct net_bridge *br = to_bridge(d); 693 return sprintf(buf, "%d\n", br->vlan_enabled); 694 } 695 696 static ssize_t vlan_filtering_store(struct device *d, 697 struct device_attribute *attr, 698 const char *buf, size_t len) 699 { 700 return store_bridge_parm(d, buf, len, br_vlan_filter_toggle); 701 } 702 static DEVICE_ATTR_RW(vlan_filtering); 703 #endif 704 705 static struct attribute *bridge_attrs[] = { 706 &dev_attr_forward_delay.attr, 707 &dev_attr_hello_time.attr, 708 &dev_attr_max_age.attr, 709 &dev_attr_ageing_time.attr, 710 &dev_attr_stp_state.attr, 711 &dev_attr_group_fwd_mask.attr, 712 &dev_attr_priority.attr, 713 &dev_attr_bridge_id.attr, 714 &dev_attr_root_id.attr, 715 &dev_attr_root_path_cost.attr, 716 &dev_attr_root_port.attr, 717 &dev_attr_topology_change.attr, 718 &dev_attr_topology_change_detected.attr, 719 &dev_attr_hello_timer.attr, 720 &dev_attr_tcn_timer.attr, 721 &dev_attr_topology_change_timer.attr, 722 &dev_attr_gc_timer.attr, 723 &dev_attr_group_addr.attr, 724 &dev_attr_flush.attr, 725 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING 726 &dev_attr_multicast_router.attr, 727 &dev_attr_multicast_snooping.attr, 728 &dev_attr_multicast_querier.attr, 729 &dev_attr_multicast_query_use_ifaddr.attr, 730 &dev_attr_hash_elasticity.attr, 731 &dev_attr_hash_max.attr, 732 &dev_attr_multicast_last_member_count.attr, 733 &dev_attr_multicast_startup_query_count.attr, 734 &dev_attr_multicast_last_member_interval.attr, 735 &dev_attr_multicast_membership_interval.attr, 736 &dev_attr_multicast_querier_interval.attr, 737 &dev_attr_multicast_query_interval.attr, 738 &dev_attr_multicast_query_response_interval.attr, 739 &dev_attr_multicast_startup_query_interval.attr, 740 #endif 741 #ifdef CONFIG_BRIDGE_NETFILTER 742 &dev_attr_nf_call_iptables.attr, 743 &dev_attr_nf_call_ip6tables.attr, 744 &dev_attr_nf_call_arptables.attr, 745 #endif 746 #ifdef CONFIG_BRIDGE_VLAN_FILTERING 747 &dev_attr_vlan_filtering.attr, 748 #endif 749 NULL 750 }; 751 752 static struct attribute_group bridge_group = { 753 .name = SYSFS_BRIDGE_ATTR, 754 .attrs = bridge_attrs, 755 }; 756 757 /* 758 * Export the forwarding information table as a binary file 759 * The records are struct __fdb_entry. 760 * 761 * Returns the number of bytes read. 762 */ 763 static ssize_t brforward_read(struct file *filp, struct kobject *kobj, 764 struct bin_attribute *bin_attr, 765 char *buf, loff_t off, size_t count) 766 { 767 struct device *dev = to_dev(kobj); 768 struct net_bridge *br = to_bridge(dev); 769 int n; 770 771 /* must read whole records */ 772 if (off % sizeof(struct __fdb_entry) != 0) 773 return -EINVAL; 774 775 n = br_fdb_fillbuf(br, buf, 776 count / sizeof(struct __fdb_entry), 777 off / sizeof(struct __fdb_entry)); 778 779 if (n > 0) 780 n *= sizeof(struct __fdb_entry); 781 782 return n; 783 } 784 785 static struct bin_attribute bridge_forward = { 786 .attr = { .name = SYSFS_BRIDGE_FDB, 787 .mode = S_IRUGO, }, 788 .read = brforward_read, 789 }; 790 791 /* 792 * Add entries in sysfs onto the existing network class device 793 * for the bridge. 794 * Adds a attribute group "bridge" containing tuning parameters. 795 * Binary attribute containing the forward table 796 * Sub directory to hold links to interfaces. 797 * 798 * Note: the ifobj exists only to be a subdirectory 799 * to hold links. The ifobj exists in same data structure 800 * as it's parent the bridge so reference counting works. 801 */ 802 int br_sysfs_addbr(struct net_device *dev) 803 { 804 struct kobject *brobj = &dev->dev.kobj; 805 struct net_bridge *br = netdev_priv(dev); 806 int err; 807 808 err = sysfs_create_group(brobj, &bridge_group); 809 if (err) { 810 pr_info("%s: can't create group %s/%s\n", 811 __func__, dev->name, bridge_group.name); 812 goto out1; 813 } 814 815 err = sysfs_create_bin_file(brobj, &bridge_forward); 816 if (err) { 817 pr_info("%s: can't create attribute file %s/%s\n", 818 __func__, dev->name, bridge_forward.attr.name); 819 goto out2; 820 } 821 822 br->ifobj = kobject_create_and_add(SYSFS_BRIDGE_PORT_SUBDIR, brobj); 823 if (!br->ifobj) { 824 pr_info("%s: can't add kobject (directory) %s/%s\n", 825 __func__, dev->name, SYSFS_BRIDGE_PORT_SUBDIR); 826 goto out3; 827 } 828 return 0; 829 out3: 830 sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward); 831 out2: 832 sysfs_remove_group(&dev->dev.kobj, &bridge_group); 833 out1: 834 return err; 835 836 } 837 838 void br_sysfs_delbr(struct net_device *dev) 839 { 840 struct kobject *kobj = &dev->dev.kobj; 841 struct net_bridge *br = netdev_priv(dev); 842 843 kobject_put(br->ifobj); 844 sysfs_remove_bin_file(kobj, &bridge_forward); 845 sysfs_remove_group(kobj, &bridge_group); 846 } 847