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