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 #include <linux/sched/signal.h> 23 24 #include "br_private.h" 25 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 if (!rtnl_trylock()) 48 return restart_syscall(); 49 50 err = (*set)(br, val); 51 if (!err) 52 netdev_state_change(br->dev); 53 rtnl_unlock(); 54 55 return err ? err : len; 56 } 57 58 59 static ssize_t forward_delay_show(struct device *d, 60 struct device_attribute *attr, char *buf) 61 { 62 struct net_bridge *br = to_bridge(d); 63 return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->forward_delay)); 64 } 65 66 static ssize_t forward_delay_store(struct device *d, 67 struct device_attribute *attr, 68 const char *buf, size_t len) 69 { 70 return store_bridge_parm(d, buf, len, br_set_forward_delay); 71 } 72 static DEVICE_ATTR_RW(forward_delay); 73 74 static ssize_t hello_time_show(struct device *d, struct device_attribute *attr, 75 char *buf) 76 { 77 return sprintf(buf, "%lu\n", 78 jiffies_to_clock_t(to_bridge(d)->hello_time)); 79 } 80 81 static ssize_t hello_time_store(struct device *d, 82 struct device_attribute *attr, const char *buf, 83 size_t len) 84 { 85 return store_bridge_parm(d, buf, len, br_set_hello_time); 86 } 87 static DEVICE_ATTR_RW(hello_time); 88 89 static ssize_t max_age_show(struct device *d, struct device_attribute *attr, 90 char *buf) 91 { 92 return sprintf(buf, "%lu\n", 93 jiffies_to_clock_t(to_bridge(d)->max_age)); 94 } 95 96 static ssize_t max_age_store(struct device *d, struct device_attribute *attr, 97 const char *buf, size_t len) 98 { 99 return store_bridge_parm(d, buf, len, br_set_max_age); 100 } 101 static DEVICE_ATTR_RW(max_age); 102 103 static ssize_t ageing_time_show(struct device *d, 104 struct device_attribute *attr, char *buf) 105 { 106 struct net_bridge *br = to_bridge(d); 107 return sprintf(buf, "%lu\n", jiffies_to_clock_t(br->ageing_time)); 108 } 109 110 static int set_ageing_time(struct net_bridge *br, unsigned long val) 111 { 112 return br_set_ageing_time(br, val); 113 } 114 115 static ssize_t ageing_time_store(struct device *d, 116 struct device_attribute *attr, 117 const char *buf, size_t len) 118 { 119 return store_bridge_parm(d, buf, len, set_ageing_time); 120 } 121 static DEVICE_ATTR_RW(ageing_time); 122 123 static ssize_t stp_state_show(struct device *d, 124 struct device_attribute *attr, char *buf) 125 { 126 struct net_bridge *br = to_bridge(d); 127 return sprintf(buf, "%d\n", br->stp_enabled); 128 } 129 130 131 static int set_stp_state(struct net_bridge *br, unsigned long val) 132 { 133 br_stp_set_enabled(br, val); 134 135 return 0; 136 } 137 138 static ssize_t stp_state_store(struct device *d, 139 struct device_attribute *attr, const char *buf, 140 size_t len) 141 { 142 return store_bridge_parm(d, buf, len, set_stp_state); 143 } 144 static DEVICE_ATTR_RW(stp_state); 145 146 static ssize_t group_fwd_mask_show(struct device *d, 147 struct device_attribute *attr, 148 char *buf) 149 { 150 struct net_bridge *br = to_bridge(d); 151 return sprintf(buf, "%#x\n", br->group_fwd_mask); 152 } 153 154 static int set_group_fwd_mask(struct net_bridge *br, unsigned long val) 155 { 156 if (val & BR_GROUPFWD_RESTRICTED) 157 return -EINVAL; 158 159 br->group_fwd_mask = val; 160 161 return 0; 162 } 163 164 static ssize_t group_fwd_mask_store(struct device *d, 165 struct device_attribute *attr, 166 const char *buf, 167 size_t len) 168 { 169 return store_bridge_parm(d, buf, len, set_group_fwd_mask); 170 } 171 static DEVICE_ATTR_RW(group_fwd_mask); 172 173 static ssize_t priority_show(struct device *d, struct device_attribute *attr, 174 char *buf) 175 { 176 struct net_bridge *br = to_bridge(d); 177 return sprintf(buf, "%d\n", 178 (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1]); 179 } 180 181 static int set_priority(struct net_bridge *br, unsigned long val) 182 { 183 br_stp_set_bridge_priority(br, (u16) val); 184 return 0; 185 } 186 187 static ssize_t priority_store(struct device *d, struct device_attribute *attr, 188 const char *buf, size_t len) 189 { 190 return store_bridge_parm(d, buf, len, set_priority); 191 } 192 static DEVICE_ATTR_RW(priority); 193 194 static ssize_t root_id_show(struct device *d, struct device_attribute *attr, 195 char *buf) 196 { 197 return br_show_bridge_id(buf, &to_bridge(d)->designated_root); 198 } 199 static DEVICE_ATTR_RO(root_id); 200 201 static ssize_t bridge_id_show(struct device *d, struct device_attribute *attr, 202 char *buf) 203 { 204 return br_show_bridge_id(buf, &to_bridge(d)->bridge_id); 205 } 206 static DEVICE_ATTR_RO(bridge_id); 207 208 static ssize_t root_port_show(struct device *d, struct device_attribute *attr, 209 char *buf) 210 { 211 return sprintf(buf, "%d\n", to_bridge(d)->root_port); 212 } 213 static DEVICE_ATTR_RO(root_port); 214 215 static ssize_t root_path_cost_show(struct device *d, 216 struct device_attribute *attr, char *buf) 217 { 218 return sprintf(buf, "%d\n", to_bridge(d)->root_path_cost); 219 } 220 static DEVICE_ATTR_RO(root_path_cost); 221 222 static ssize_t topology_change_show(struct device *d, 223 struct device_attribute *attr, char *buf) 224 { 225 return sprintf(buf, "%d\n", to_bridge(d)->topology_change); 226 } 227 static DEVICE_ATTR_RO(topology_change); 228 229 static ssize_t topology_change_detected_show(struct device *d, 230 struct device_attribute *attr, 231 char *buf) 232 { 233 struct net_bridge *br = to_bridge(d); 234 return sprintf(buf, "%d\n", br->topology_change_detected); 235 } 236 static DEVICE_ATTR_RO(topology_change_detected); 237 238 static ssize_t hello_timer_show(struct device *d, 239 struct device_attribute *attr, char *buf) 240 { 241 struct net_bridge *br = to_bridge(d); 242 return sprintf(buf, "%ld\n", br_timer_value(&br->hello_timer)); 243 } 244 static DEVICE_ATTR_RO(hello_timer); 245 246 static ssize_t tcn_timer_show(struct device *d, struct device_attribute *attr, 247 char *buf) 248 { 249 struct net_bridge *br = to_bridge(d); 250 return sprintf(buf, "%ld\n", br_timer_value(&br->tcn_timer)); 251 } 252 static DEVICE_ATTR_RO(tcn_timer); 253 254 static ssize_t topology_change_timer_show(struct device *d, 255 struct device_attribute *attr, 256 char *buf) 257 { 258 struct net_bridge *br = to_bridge(d); 259 return sprintf(buf, "%ld\n", br_timer_value(&br->topology_change_timer)); 260 } 261 static DEVICE_ATTR_RO(topology_change_timer); 262 263 static ssize_t gc_timer_show(struct device *d, struct device_attribute *attr, 264 char *buf) 265 { 266 struct net_bridge *br = to_bridge(d); 267 return sprintf(buf, "%ld\n", br_timer_value(&br->gc_work.timer)); 268 } 269 static DEVICE_ATTR_RO(gc_timer); 270 271 static ssize_t group_addr_show(struct device *d, 272 struct device_attribute *attr, char *buf) 273 { 274 struct net_bridge *br = to_bridge(d); 275 return sprintf(buf, "%x:%x:%x:%x:%x:%x\n", 276 br->group_addr[0], br->group_addr[1], 277 br->group_addr[2], br->group_addr[3], 278 br->group_addr[4], br->group_addr[5]); 279 } 280 281 static ssize_t group_addr_store(struct device *d, 282 struct device_attribute *attr, 283 const char *buf, size_t len) 284 { 285 struct net_bridge *br = to_bridge(d); 286 u8 new_addr[6]; 287 int i; 288 289 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN)) 290 return -EPERM; 291 292 if (sscanf(buf, "%hhx:%hhx:%hhx:%hhx:%hhx:%hhx", 293 &new_addr[0], &new_addr[1], &new_addr[2], 294 &new_addr[3], &new_addr[4], &new_addr[5]) != 6) 295 return -EINVAL; 296 297 if (!is_link_local_ether_addr(new_addr)) 298 return -EINVAL; 299 300 if (new_addr[5] == 1 || /* 802.3x Pause address */ 301 new_addr[5] == 2 || /* 802.3ad Slow protocols */ 302 new_addr[5] == 3) /* 802.1X PAE address */ 303 return -EINVAL; 304 305 if (!rtnl_trylock()) 306 return restart_syscall(); 307 308 spin_lock_bh(&br->lock); 309 for (i = 0; i < 6; i++) 310 br->group_addr[i] = new_addr[i]; 311 spin_unlock_bh(&br->lock); 312 313 br->group_addr_set = true; 314 br_recalculate_fwd_mask(br); 315 netdev_state_change(br->dev); 316 317 rtnl_unlock(); 318 319 return len; 320 } 321 322 static DEVICE_ATTR_RW(group_addr); 323 324 static int set_flush(struct net_bridge *br, unsigned long val) 325 { 326 br_fdb_flush(br); 327 return 0; 328 } 329 330 static ssize_t flush_store(struct device *d, 331 struct device_attribute *attr, 332 const char *buf, size_t len) 333 { 334 return store_bridge_parm(d, buf, len, set_flush); 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_igmp_version_show(struct device *d, 445 struct device_attribute *attr, 446 char *buf) 447 { 448 struct net_bridge *br = to_bridge(d); 449 450 return sprintf(buf, "%u\n", br->multicast_igmp_version); 451 } 452 453 static ssize_t multicast_igmp_version_store(struct device *d, 454 struct device_attribute *attr, 455 const char *buf, size_t len) 456 { 457 return store_bridge_parm(d, buf, len, br_multicast_set_igmp_version); 458 } 459 static DEVICE_ATTR_RW(multicast_igmp_version); 460 461 static ssize_t multicast_last_member_count_show(struct device *d, 462 struct device_attribute *attr, 463 char *buf) 464 { 465 struct net_bridge *br = to_bridge(d); 466 return sprintf(buf, "%u\n", br->multicast_last_member_count); 467 } 468 469 static int set_last_member_count(struct net_bridge *br, unsigned long val) 470 { 471 br->multicast_last_member_count = val; 472 return 0; 473 } 474 475 static ssize_t multicast_last_member_count_store(struct device *d, 476 struct device_attribute *attr, 477 const char *buf, size_t len) 478 { 479 return store_bridge_parm(d, buf, len, set_last_member_count); 480 } 481 static DEVICE_ATTR_RW(multicast_last_member_count); 482 483 static ssize_t multicast_startup_query_count_show( 484 struct device *d, struct device_attribute *attr, char *buf) 485 { 486 struct net_bridge *br = to_bridge(d); 487 return sprintf(buf, "%u\n", br->multicast_startup_query_count); 488 } 489 490 static int set_startup_query_count(struct net_bridge *br, unsigned long val) 491 { 492 br->multicast_startup_query_count = val; 493 return 0; 494 } 495 496 static ssize_t multicast_startup_query_count_store( 497 struct device *d, struct device_attribute *attr, const char *buf, 498 size_t len) 499 { 500 return store_bridge_parm(d, buf, len, set_startup_query_count); 501 } 502 static DEVICE_ATTR_RW(multicast_startup_query_count); 503 504 static ssize_t multicast_last_member_interval_show( 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 multicast_last_member_interval_store( 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_RW(multicast_last_member_interval); 525 526 static ssize_t multicast_membership_interval_show( 527 struct device *d, struct device_attribute *attr, char *buf) 528 { 529 struct net_bridge *br = to_bridge(d); 530 return sprintf(buf, "%lu\n", 531 jiffies_to_clock_t(br->multicast_membership_interval)); 532 } 533 534 static int set_membership_interval(struct net_bridge *br, unsigned long val) 535 { 536 br->multicast_membership_interval = clock_t_to_jiffies(val); 537 return 0; 538 } 539 540 static ssize_t multicast_membership_interval_store( 541 struct device *d, struct device_attribute *attr, const char *buf, 542 size_t len) 543 { 544 return store_bridge_parm(d, buf, len, set_membership_interval); 545 } 546 static DEVICE_ATTR_RW(multicast_membership_interval); 547 548 static ssize_t multicast_querier_interval_show(struct device *d, 549 struct device_attribute *attr, 550 char *buf) 551 { 552 struct net_bridge *br = to_bridge(d); 553 return sprintf(buf, "%lu\n", 554 jiffies_to_clock_t(br->multicast_querier_interval)); 555 } 556 557 static int set_querier_interval(struct net_bridge *br, unsigned long val) 558 { 559 br->multicast_querier_interval = clock_t_to_jiffies(val); 560 return 0; 561 } 562 563 static ssize_t multicast_querier_interval_store(struct device *d, 564 struct device_attribute *attr, 565 const char *buf, size_t len) 566 { 567 return store_bridge_parm(d, buf, len, set_querier_interval); 568 } 569 static DEVICE_ATTR_RW(multicast_querier_interval); 570 571 static ssize_t multicast_query_interval_show(struct device *d, 572 struct device_attribute *attr, 573 char *buf) 574 { 575 struct net_bridge *br = to_bridge(d); 576 return sprintf(buf, "%lu\n", 577 jiffies_to_clock_t(br->multicast_query_interval)); 578 } 579 580 static int set_query_interval(struct net_bridge *br, unsigned long val) 581 { 582 br->multicast_query_interval = clock_t_to_jiffies(val); 583 return 0; 584 } 585 586 static ssize_t multicast_query_interval_store(struct device *d, 587 struct device_attribute *attr, 588 const char *buf, size_t len) 589 { 590 return store_bridge_parm(d, buf, len, set_query_interval); 591 } 592 static DEVICE_ATTR_RW(multicast_query_interval); 593 594 static ssize_t multicast_query_response_interval_show( 595 struct device *d, struct device_attribute *attr, char *buf) 596 { 597 struct net_bridge *br = to_bridge(d); 598 return sprintf( 599 buf, "%lu\n", 600 jiffies_to_clock_t(br->multicast_query_response_interval)); 601 } 602 603 static int set_query_response_interval(struct net_bridge *br, unsigned long val) 604 { 605 br->multicast_query_response_interval = clock_t_to_jiffies(val); 606 return 0; 607 } 608 609 static ssize_t multicast_query_response_interval_store( 610 struct device *d, struct device_attribute *attr, const char *buf, 611 size_t len) 612 { 613 return store_bridge_parm(d, buf, len, set_query_response_interval); 614 } 615 static DEVICE_ATTR_RW(multicast_query_response_interval); 616 617 static ssize_t multicast_startup_query_interval_show( 618 struct device *d, struct device_attribute *attr, char *buf) 619 { 620 struct net_bridge *br = to_bridge(d); 621 return sprintf( 622 buf, "%lu\n", 623 jiffies_to_clock_t(br->multicast_startup_query_interval)); 624 } 625 626 static int set_startup_query_interval(struct net_bridge *br, unsigned long val) 627 { 628 br->multicast_startup_query_interval = clock_t_to_jiffies(val); 629 return 0; 630 } 631 632 static ssize_t multicast_startup_query_interval_store( 633 struct device *d, struct device_attribute *attr, const char *buf, 634 size_t len) 635 { 636 return store_bridge_parm(d, buf, len, set_startup_query_interval); 637 } 638 static DEVICE_ATTR_RW(multicast_startup_query_interval); 639 640 static ssize_t multicast_stats_enabled_show(struct device *d, 641 struct device_attribute *attr, 642 char *buf) 643 { 644 struct net_bridge *br = to_bridge(d); 645 646 return sprintf(buf, "%u\n", br->multicast_stats_enabled); 647 } 648 649 static int set_stats_enabled(struct net_bridge *br, unsigned long val) 650 { 651 br->multicast_stats_enabled = !!val; 652 return 0; 653 } 654 655 static ssize_t multicast_stats_enabled_store(struct device *d, 656 struct device_attribute *attr, 657 const char *buf, 658 size_t len) 659 { 660 return store_bridge_parm(d, buf, len, set_stats_enabled); 661 } 662 static DEVICE_ATTR_RW(multicast_stats_enabled); 663 664 #if IS_ENABLED(CONFIG_IPV6) 665 static ssize_t multicast_mld_version_show(struct device *d, 666 struct device_attribute *attr, 667 char *buf) 668 { 669 struct net_bridge *br = to_bridge(d); 670 671 return sprintf(buf, "%u\n", br->multicast_mld_version); 672 } 673 674 static ssize_t multicast_mld_version_store(struct device *d, 675 struct device_attribute *attr, 676 const char *buf, size_t len) 677 { 678 return store_bridge_parm(d, buf, len, br_multicast_set_mld_version); 679 } 680 static DEVICE_ATTR_RW(multicast_mld_version); 681 #endif 682 #endif 683 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER) 684 static ssize_t nf_call_iptables_show( 685 struct device *d, struct device_attribute *attr, char *buf) 686 { 687 struct net_bridge *br = to_bridge(d); 688 return sprintf(buf, "%u\n", br->nf_call_iptables); 689 } 690 691 static int set_nf_call_iptables(struct net_bridge *br, unsigned long val) 692 { 693 br->nf_call_iptables = val ? true : false; 694 return 0; 695 } 696 697 static ssize_t nf_call_iptables_store( 698 struct device *d, struct device_attribute *attr, const char *buf, 699 size_t len) 700 { 701 return store_bridge_parm(d, buf, len, set_nf_call_iptables); 702 } 703 static DEVICE_ATTR_RW(nf_call_iptables); 704 705 static ssize_t nf_call_ip6tables_show( 706 struct device *d, struct device_attribute *attr, char *buf) 707 { 708 struct net_bridge *br = to_bridge(d); 709 return sprintf(buf, "%u\n", br->nf_call_ip6tables); 710 } 711 712 static int set_nf_call_ip6tables(struct net_bridge *br, unsigned long val) 713 { 714 br->nf_call_ip6tables = val ? true : false; 715 return 0; 716 } 717 718 static ssize_t nf_call_ip6tables_store( 719 struct device *d, struct device_attribute *attr, const char *buf, 720 size_t len) 721 { 722 return store_bridge_parm(d, buf, len, set_nf_call_ip6tables); 723 } 724 static DEVICE_ATTR_RW(nf_call_ip6tables); 725 726 static ssize_t nf_call_arptables_show( 727 struct device *d, struct device_attribute *attr, char *buf) 728 { 729 struct net_bridge *br = to_bridge(d); 730 return sprintf(buf, "%u\n", br->nf_call_arptables); 731 } 732 733 static int set_nf_call_arptables(struct net_bridge *br, unsigned long val) 734 { 735 br->nf_call_arptables = val ? true : false; 736 return 0; 737 } 738 739 static ssize_t nf_call_arptables_store( 740 struct device *d, struct device_attribute *attr, const char *buf, 741 size_t len) 742 { 743 return store_bridge_parm(d, buf, len, set_nf_call_arptables); 744 } 745 static DEVICE_ATTR_RW(nf_call_arptables); 746 #endif 747 #ifdef CONFIG_BRIDGE_VLAN_FILTERING 748 static ssize_t vlan_filtering_show(struct device *d, 749 struct device_attribute *attr, 750 char *buf) 751 { 752 struct net_bridge *br = to_bridge(d); 753 return sprintf(buf, "%d\n", br->vlan_enabled); 754 } 755 756 static ssize_t vlan_filtering_store(struct device *d, 757 struct device_attribute *attr, 758 const char *buf, size_t len) 759 { 760 return store_bridge_parm(d, buf, len, br_vlan_filter_toggle); 761 } 762 static DEVICE_ATTR_RW(vlan_filtering); 763 764 static ssize_t vlan_protocol_show(struct device *d, 765 struct device_attribute *attr, 766 char *buf) 767 { 768 struct net_bridge *br = to_bridge(d); 769 return sprintf(buf, "%#06x\n", ntohs(br->vlan_proto)); 770 } 771 772 static ssize_t vlan_protocol_store(struct device *d, 773 struct device_attribute *attr, 774 const char *buf, size_t len) 775 { 776 return store_bridge_parm(d, buf, len, br_vlan_set_proto); 777 } 778 static DEVICE_ATTR_RW(vlan_protocol); 779 780 static ssize_t default_pvid_show(struct device *d, 781 struct device_attribute *attr, 782 char *buf) 783 { 784 struct net_bridge *br = to_bridge(d); 785 return sprintf(buf, "%d\n", br->default_pvid); 786 } 787 788 static ssize_t default_pvid_store(struct device *d, 789 struct device_attribute *attr, 790 const char *buf, size_t len) 791 { 792 return store_bridge_parm(d, buf, len, br_vlan_set_default_pvid); 793 } 794 static DEVICE_ATTR_RW(default_pvid); 795 796 static ssize_t vlan_stats_enabled_show(struct device *d, 797 struct device_attribute *attr, 798 char *buf) 799 { 800 struct net_bridge *br = to_bridge(d); 801 return sprintf(buf, "%u\n", br->vlan_stats_enabled); 802 } 803 804 static ssize_t vlan_stats_enabled_store(struct device *d, 805 struct device_attribute *attr, 806 const char *buf, size_t len) 807 { 808 return store_bridge_parm(d, buf, len, br_vlan_set_stats); 809 } 810 static DEVICE_ATTR_RW(vlan_stats_enabled); 811 #endif 812 813 static struct attribute *bridge_attrs[] = { 814 &dev_attr_forward_delay.attr, 815 &dev_attr_hello_time.attr, 816 &dev_attr_max_age.attr, 817 &dev_attr_ageing_time.attr, 818 &dev_attr_stp_state.attr, 819 &dev_attr_group_fwd_mask.attr, 820 &dev_attr_priority.attr, 821 &dev_attr_bridge_id.attr, 822 &dev_attr_root_id.attr, 823 &dev_attr_root_path_cost.attr, 824 &dev_attr_root_port.attr, 825 &dev_attr_topology_change.attr, 826 &dev_attr_topology_change_detected.attr, 827 &dev_attr_hello_timer.attr, 828 &dev_attr_tcn_timer.attr, 829 &dev_attr_topology_change_timer.attr, 830 &dev_attr_gc_timer.attr, 831 &dev_attr_group_addr.attr, 832 &dev_attr_flush.attr, 833 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING 834 &dev_attr_multicast_router.attr, 835 &dev_attr_multicast_snooping.attr, 836 &dev_attr_multicast_querier.attr, 837 &dev_attr_multicast_query_use_ifaddr.attr, 838 &dev_attr_hash_elasticity.attr, 839 &dev_attr_hash_max.attr, 840 &dev_attr_multicast_last_member_count.attr, 841 &dev_attr_multicast_startup_query_count.attr, 842 &dev_attr_multicast_last_member_interval.attr, 843 &dev_attr_multicast_membership_interval.attr, 844 &dev_attr_multicast_querier_interval.attr, 845 &dev_attr_multicast_query_interval.attr, 846 &dev_attr_multicast_query_response_interval.attr, 847 &dev_attr_multicast_startup_query_interval.attr, 848 &dev_attr_multicast_stats_enabled.attr, 849 &dev_attr_multicast_igmp_version.attr, 850 #if IS_ENABLED(CONFIG_IPV6) 851 &dev_attr_multicast_mld_version.attr, 852 #endif 853 #endif 854 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER) 855 &dev_attr_nf_call_iptables.attr, 856 &dev_attr_nf_call_ip6tables.attr, 857 &dev_attr_nf_call_arptables.attr, 858 #endif 859 #ifdef CONFIG_BRIDGE_VLAN_FILTERING 860 &dev_attr_vlan_filtering.attr, 861 &dev_attr_vlan_protocol.attr, 862 &dev_attr_default_pvid.attr, 863 &dev_attr_vlan_stats_enabled.attr, 864 #endif 865 NULL 866 }; 867 868 static const struct attribute_group bridge_group = { 869 .name = SYSFS_BRIDGE_ATTR, 870 .attrs = bridge_attrs, 871 }; 872 873 /* 874 * Export the forwarding information table as a binary file 875 * The records are struct __fdb_entry. 876 * 877 * Returns the number of bytes read. 878 */ 879 static ssize_t brforward_read(struct file *filp, struct kobject *kobj, 880 struct bin_attribute *bin_attr, 881 char *buf, loff_t off, size_t count) 882 { 883 struct device *dev = kobj_to_dev(kobj); 884 struct net_bridge *br = to_bridge(dev); 885 int n; 886 887 /* must read whole records */ 888 if (off % sizeof(struct __fdb_entry) != 0) 889 return -EINVAL; 890 891 n = br_fdb_fillbuf(br, buf, 892 count / sizeof(struct __fdb_entry), 893 off / sizeof(struct __fdb_entry)); 894 895 if (n > 0) 896 n *= sizeof(struct __fdb_entry); 897 898 return n; 899 } 900 901 static struct bin_attribute bridge_forward = { 902 .attr = { .name = SYSFS_BRIDGE_FDB, 903 .mode = S_IRUGO, }, 904 .read = brforward_read, 905 }; 906 907 /* 908 * Add entries in sysfs onto the existing network class device 909 * for the bridge. 910 * Adds a attribute group "bridge" containing tuning parameters. 911 * Binary attribute containing the forward table 912 * Sub directory to hold links to interfaces. 913 * 914 * Note: the ifobj exists only to be a subdirectory 915 * to hold links. The ifobj exists in same data structure 916 * as it's parent the bridge so reference counting works. 917 */ 918 int br_sysfs_addbr(struct net_device *dev) 919 { 920 struct kobject *brobj = &dev->dev.kobj; 921 struct net_bridge *br = netdev_priv(dev); 922 int err; 923 924 err = sysfs_create_group(brobj, &bridge_group); 925 if (err) { 926 pr_info("%s: can't create group %s/%s\n", 927 __func__, dev->name, bridge_group.name); 928 goto out1; 929 } 930 931 err = sysfs_create_bin_file(brobj, &bridge_forward); 932 if (err) { 933 pr_info("%s: can't create attribute file %s/%s\n", 934 __func__, dev->name, bridge_forward.attr.name); 935 goto out2; 936 } 937 938 br->ifobj = kobject_create_and_add(SYSFS_BRIDGE_PORT_SUBDIR, brobj); 939 if (!br->ifobj) { 940 pr_info("%s: can't add kobject (directory) %s/%s\n", 941 __func__, dev->name, SYSFS_BRIDGE_PORT_SUBDIR); 942 err = -ENOMEM; 943 goto out3; 944 } 945 return 0; 946 out3: 947 sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward); 948 out2: 949 sysfs_remove_group(&dev->dev.kobj, &bridge_group); 950 out1: 951 return err; 952 953 } 954 955 void br_sysfs_delbr(struct net_device *dev) 956 { 957 struct kobject *kobj = &dev->dev.kobj; 958 struct net_bridge *br = netdev_priv(dev); 959 960 kobject_put(br->ifobj); 961 sysfs_remove_bin_file(kobj, &bridge_forward); 962 sysfs_remove_group(kobj, &bridge_group); 963 } 964