1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Sysfs attributes of bridge 4 * Linux ethernet bridge 5 * 6 * Authors: 7 * Stephen Hemminger <shemminger@osdl.org> 8 */ 9 10 #include <linux/capability.h> 11 #include <linux/kernel.h> 12 #include <linux/netdevice.h> 13 #include <linux/etherdevice.h> 14 #include <linux/if_bridge.h> 15 #include <linux/rtnetlink.h> 16 #include <linux/spinlock.h> 17 #include <linux/times.h> 18 #include <linux/sched/signal.h> 19 20 #include "br_private.h" 21 22 /* IMPORTANT: new bridge options must be added with netlink support only 23 * please do not add new sysfs entries 24 */ 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 return br_stp_set_enabled(br, val, NULL); 134 } 135 136 static ssize_t stp_state_store(struct device *d, 137 struct device_attribute *attr, const char *buf, 138 size_t len) 139 { 140 return store_bridge_parm(d, buf, len, set_stp_state); 141 } 142 static DEVICE_ATTR_RW(stp_state); 143 144 static ssize_t group_fwd_mask_show(struct device *d, 145 struct device_attribute *attr, 146 char *buf) 147 { 148 struct net_bridge *br = to_bridge(d); 149 return sprintf(buf, "%#x\n", br->group_fwd_mask); 150 } 151 152 static int set_group_fwd_mask(struct net_bridge *br, unsigned long val) 153 { 154 if (val & BR_GROUPFWD_RESTRICTED) 155 return -EINVAL; 156 157 br->group_fwd_mask = val; 158 159 return 0; 160 } 161 162 static ssize_t group_fwd_mask_store(struct device *d, 163 struct device_attribute *attr, 164 const char *buf, 165 size_t len) 166 { 167 return store_bridge_parm(d, buf, len, set_group_fwd_mask); 168 } 169 static DEVICE_ATTR_RW(group_fwd_mask); 170 171 static ssize_t priority_show(struct device *d, struct device_attribute *attr, 172 char *buf) 173 { 174 struct net_bridge *br = to_bridge(d); 175 return sprintf(buf, "%d\n", 176 (br->bridge_id.prio[0] << 8) | br->bridge_id.prio[1]); 177 } 178 179 static int set_priority(struct net_bridge *br, unsigned long val) 180 { 181 br_stp_set_bridge_priority(br, (u16) val); 182 return 0; 183 } 184 185 static ssize_t priority_store(struct device *d, struct device_attribute *attr, 186 const char *buf, size_t len) 187 { 188 return store_bridge_parm(d, buf, len, set_priority); 189 } 190 static DEVICE_ATTR_RW(priority); 191 192 static ssize_t root_id_show(struct device *d, struct device_attribute *attr, 193 char *buf) 194 { 195 return br_show_bridge_id(buf, &to_bridge(d)->designated_root); 196 } 197 static DEVICE_ATTR_RO(root_id); 198 199 static ssize_t bridge_id_show(struct device *d, struct device_attribute *attr, 200 char *buf) 201 { 202 return br_show_bridge_id(buf, &to_bridge(d)->bridge_id); 203 } 204 static DEVICE_ATTR_RO(bridge_id); 205 206 static ssize_t root_port_show(struct device *d, struct device_attribute *attr, 207 char *buf) 208 { 209 return sprintf(buf, "%d\n", to_bridge(d)->root_port); 210 } 211 static DEVICE_ATTR_RO(root_port); 212 213 static ssize_t root_path_cost_show(struct device *d, 214 struct device_attribute *attr, char *buf) 215 { 216 return sprintf(buf, "%d\n", to_bridge(d)->root_path_cost); 217 } 218 static DEVICE_ATTR_RO(root_path_cost); 219 220 static ssize_t topology_change_show(struct device *d, 221 struct device_attribute *attr, char *buf) 222 { 223 return sprintf(buf, "%d\n", to_bridge(d)->topology_change); 224 } 225 static DEVICE_ATTR_RO(topology_change); 226 227 static ssize_t topology_change_detected_show(struct device *d, 228 struct device_attribute *attr, 229 char *buf) 230 { 231 struct net_bridge *br = to_bridge(d); 232 return sprintf(buf, "%d\n", br->topology_change_detected); 233 } 234 static DEVICE_ATTR_RO(topology_change_detected); 235 236 static ssize_t hello_timer_show(struct device *d, 237 struct device_attribute *attr, char *buf) 238 { 239 struct net_bridge *br = to_bridge(d); 240 return sprintf(buf, "%ld\n", br_timer_value(&br->hello_timer)); 241 } 242 static DEVICE_ATTR_RO(hello_timer); 243 244 static ssize_t tcn_timer_show(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->tcn_timer)); 249 } 250 static DEVICE_ATTR_RO(tcn_timer); 251 252 static ssize_t topology_change_timer_show(struct device *d, 253 struct device_attribute *attr, 254 char *buf) 255 { 256 struct net_bridge *br = to_bridge(d); 257 return sprintf(buf, "%ld\n", br_timer_value(&br->topology_change_timer)); 258 } 259 static DEVICE_ATTR_RO(topology_change_timer); 260 261 static ssize_t gc_timer_show(struct device *d, struct device_attribute *attr, 262 char *buf) 263 { 264 struct net_bridge *br = to_bridge(d); 265 return sprintf(buf, "%ld\n", br_timer_value(&br->gc_work.timer)); 266 } 267 static DEVICE_ATTR_RO(gc_timer); 268 269 static ssize_t group_addr_show(struct device *d, 270 struct device_attribute *attr, char *buf) 271 { 272 struct net_bridge *br = to_bridge(d); 273 return sprintf(buf, "%pM\n", br->group_addr); 274 } 275 276 static ssize_t group_addr_store(struct device *d, 277 struct device_attribute *attr, 278 const char *buf, size_t len) 279 { 280 struct net_bridge *br = to_bridge(d); 281 u8 new_addr[6]; 282 283 if (!ns_capable(dev_net(br->dev)->user_ns, CAP_NET_ADMIN)) 284 return -EPERM; 285 286 if (!mac_pton(buf, new_addr)) 287 return -EINVAL; 288 289 if (!is_link_local_ether_addr(new_addr)) 290 return -EINVAL; 291 292 if (new_addr[5] == 1 || /* 802.3x Pause address */ 293 new_addr[5] == 2 || /* 802.3ad Slow protocols */ 294 new_addr[5] == 3) /* 802.1X PAE address */ 295 return -EINVAL; 296 297 if (!rtnl_trylock()) 298 return restart_syscall(); 299 300 spin_lock_bh(&br->lock); 301 ether_addr_copy(br->group_addr, new_addr); 302 spin_unlock_bh(&br->lock); 303 304 br_opt_toggle(br, BROPT_GROUP_ADDR_SET, true); 305 br_recalculate_fwd_mask(br); 306 netdev_state_change(br->dev); 307 308 rtnl_unlock(); 309 310 return len; 311 } 312 313 static DEVICE_ATTR_RW(group_addr); 314 315 static int set_flush(struct net_bridge *br, unsigned long val) 316 { 317 br_fdb_flush(br); 318 return 0; 319 } 320 321 static ssize_t flush_store(struct device *d, 322 struct device_attribute *attr, 323 const char *buf, size_t len) 324 { 325 return store_bridge_parm(d, buf, len, set_flush); 326 } 327 static DEVICE_ATTR_WO(flush); 328 329 static ssize_t no_linklocal_learn_show(struct device *d, 330 struct device_attribute *attr, 331 char *buf) 332 { 333 struct net_bridge *br = to_bridge(d); 334 return sprintf(buf, "%d\n", br_boolopt_get(br, BR_BOOLOPT_NO_LL_LEARN)); 335 } 336 337 static int set_no_linklocal_learn(struct net_bridge *br, unsigned long val) 338 { 339 return br_boolopt_toggle(br, BR_BOOLOPT_NO_LL_LEARN, !!val, NULL); 340 } 341 342 static ssize_t no_linklocal_learn_store(struct device *d, 343 struct device_attribute *attr, 344 const char *buf, size_t len) 345 { 346 return store_bridge_parm(d, buf, len, set_no_linklocal_learn); 347 } 348 static DEVICE_ATTR_RW(no_linklocal_learn); 349 350 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING 351 static ssize_t multicast_router_show(struct device *d, 352 struct device_attribute *attr, char *buf) 353 { 354 struct net_bridge *br = to_bridge(d); 355 return sprintf(buf, "%d\n", br->multicast_router); 356 } 357 358 static ssize_t multicast_router_store(struct device *d, 359 struct device_attribute *attr, 360 const char *buf, size_t len) 361 { 362 return store_bridge_parm(d, buf, len, br_multicast_set_router); 363 } 364 static DEVICE_ATTR_RW(multicast_router); 365 366 static ssize_t multicast_snooping_show(struct device *d, 367 struct device_attribute *attr, 368 char *buf) 369 { 370 struct net_bridge *br = to_bridge(d); 371 return sprintf(buf, "%d\n", br_opt_get(br, BROPT_MULTICAST_ENABLED)); 372 } 373 374 static ssize_t multicast_snooping_store(struct device *d, 375 struct device_attribute *attr, 376 const char *buf, size_t len) 377 { 378 return store_bridge_parm(d, buf, len, br_multicast_toggle); 379 } 380 static DEVICE_ATTR_RW(multicast_snooping); 381 382 static ssize_t multicast_query_use_ifaddr_show(struct device *d, 383 struct device_attribute *attr, 384 char *buf) 385 { 386 struct net_bridge *br = to_bridge(d); 387 return sprintf(buf, "%d\n", 388 br_opt_get(br, BROPT_MULTICAST_QUERY_USE_IFADDR)); 389 } 390 391 static int set_query_use_ifaddr(struct net_bridge *br, unsigned long val) 392 { 393 br_opt_toggle(br, BROPT_MULTICAST_QUERY_USE_IFADDR, !!val); 394 return 0; 395 } 396 397 static ssize_t 398 multicast_query_use_ifaddr_store(struct device *d, 399 struct device_attribute *attr, 400 const char *buf, size_t len) 401 { 402 return store_bridge_parm(d, buf, len, set_query_use_ifaddr); 403 } 404 static DEVICE_ATTR_RW(multicast_query_use_ifaddr); 405 406 static ssize_t multicast_querier_show(struct device *d, 407 struct device_attribute *attr, 408 char *buf) 409 { 410 struct net_bridge *br = to_bridge(d); 411 return sprintf(buf, "%d\n", br_opt_get(br, BROPT_MULTICAST_QUERIER)); 412 } 413 414 static ssize_t multicast_querier_store(struct device *d, 415 struct device_attribute *attr, 416 const char *buf, size_t len) 417 { 418 return store_bridge_parm(d, buf, len, br_multicast_set_querier); 419 } 420 static DEVICE_ATTR_RW(multicast_querier); 421 422 static ssize_t hash_elasticity_show(struct device *d, 423 struct device_attribute *attr, char *buf) 424 { 425 return sprintf(buf, "%u\n", RHT_ELASTICITY); 426 } 427 428 static int set_elasticity(struct net_bridge *br, unsigned long val) 429 { 430 br_warn(br, "the hash_elasticity option has been deprecated and is always %u\n", 431 RHT_ELASTICITY); 432 return 0; 433 } 434 435 static ssize_t hash_elasticity_store(struct device *d, 436 struct device_attribute *attr, 437 const char *buf, size_t len) 438 { 439 return store_bridge_parm(d, buf, len, set_elasticity); 440 } 441 static DEVICE_ATTR_RW(hash_elasticity); 442 443 static ssize_t hash_max_show(struct device *d, struct device_attribute *attr, 444 char *buf) 445 { 446 struct net_bridge *br = to_bridge(d); 447 return sprintf(buf, "%u\n", br->hash_max); 448 } 449 450 static int set_hash_max(struct net_bridge *br, unsigned long val) 451 { 452 br->hash_max = val; 453 return 0; 454 } 455 456 static ssize_t hash_max_store(struct device *d, struct device_attribute *attr, 457 const char *buf, size_t len) 458 { 459 return store_bridge_parm(d, buf, len, set_hash_max); 460 } 461 static DEVICE_ATTR_RW(hash_max); 462 463 static ssize_t multicast_igmp_version_show(struct device *d, 464 struct device_attribute *attr, 465 char *buf) 466 { 467 struct net_bridge *br = to_bridge(d); 468 469 return sprintf(buf, "%u\n", br->multicast_igmp_version); 470 } 471 472 static ssize_t multicast_igmp_version_store(struct device *d, 473 struct device_attribute *attr, 474 const char *buf, size_t len) 475 { 476 return store_bridge_parm(d, buf, len, br_multicast_set_igmp_version); 477 } 478 static DEVICE_ATTR_RW(multicast_igmp_version); 479 480 static ssize_t multicast_last_member_count_show(struct device *d, 481 struct device_attribute *attr, 482 char *buf) 483 { 484 struct net_bridge *br = to_bridge(d); 485 return sprintf(buf, "%u\n", br->multicast_last_member_count); 486 } 487 488 static int set_last_member_count(struct net_bridge *br, unsigned long val) 489 { 490 br->multicast_last_member_count = val; 491 return 0; 492 } 493 494 static ssize_t multicast_last_member_count_store(struct device *d, 495 struct device_attribute *attr, 496 const char *buf, size_t len) 497 { 498 return store_bridge_parm(d, buf, len, set_last_member_count); 499 } 500 static DEVICE_ATTR_RW(multicast_last_member_count); 501 502 static ssize_t multicast_startup_query_count_show( 503 struct device *d, struct device_attribute *attr, char *buf) 504 { 505 struct net_bridge *br = to_bridge(d); 506 return sprintf(buf, "%u\n", br->multicast_startup_query_count); 507 } 508 509 static int set_startup_query_count(struct net_bridge *br, unsigned long val) 510 { 511 br->multicast_startup_query_count = val; 512 return 0; 513 } 514 515 static ssize_t multicast_startup_query_count_store( 516 struct device *d, struct device_attribute *attr, const char *buf, 517 size_t len) 518 { 519 return store_bridge_parm(d, buf, len, set_startup_query_count); 520 } 521 static DEVICE_ATTR_RW(multicast_startup_query_count); 522 523 static ssize_t multicast_last_member_interval_show( 524 struct device *d, struct device_attribute *attr, char *buf) 525 { 526 struct net_bridge *br = to_bridge(d); 527 return sprintf(buf, "%lu\n", 528 jiffies_to_clock_t(br->multicast_last_member_interval)); 529 } 530 531 static int set_last_member_interval(struct net_bridge *br, unsigned long val) 532 { 533 br->multicast_last_member_interval = clock_t_to_jiffies(val); 534 return 0; 535 } 536 537 static ssize_t multicast_last_member_interval_store( 538 struct device *d, struct device_attribute *attr, const char *buf, 539 size_t len) 540 { 541 return store_bridge_parm(d, buf, len, set_last_member_interval); 542 } 543 static DEVICE_ATTR_RW(multicast_last_member_interval); 544 545 static ssize_t multicast_membership_interval_show( 546 struct device *d, struct device_attribute *attr, char *buf) 547 { 548 struct net_bridge *br = to_bridge(d); 549 return sprintf(buf, "%lu\n", 550 jiffies_to_clock_t(br->multicast_membership_interval)); 551 } 552 553 static int set_membership_interval(struct net_bridge *br, unsigned long val) 554 { 555 br->multicast_membership_interval = clock_t_to_jiffies(val); 556 return 0; 557 } 558 559 static ssize_t multicast_membership_interval_store( 560 struct device *d, struct device_attribute *attr, const char *buf, 561 size_t len) 562 { 563 return store_bridge_parm(d, buf, len, set_membership_interval); 564 } 565 static DEVICE_ATTR_RW(multicast_membership_interval); 566 567 static ssize_t multicast_querier_interval_show(struct device *d, 568 struct device_attribute *attr, 569 char *buf) 570 { 571 struct net_bridge *br = to_bridge(d); 572 return sprintf(buf, "%lu\n", 573 jiffies_to_clock_t(br->multicast_querier_interval)); 574 } 575 576 static int set_querier_interval(struct net_bridge *br, unsigned long val) 577 { 578 br->multicast_querier_interval = clock_t_to_jiffies(val); 579 return 0; 580 } 581 582 static ssize_t multicast_querier_interval_store(struct device *d, 583 struct device_attribute *attr, 584 const char *buf, size_t len) 585 { 586 return store_bridge_parm(d, buf, len, set_querier_interval); 587 } 588 static DEVICE_ATTR_RW(multicast_querier_interval); 589 590 static ssize_t multicast_query_interval_show(struct device *d, 591 struct device_attribute *attr, 592 char *buf) 593 { 594 struct net_bridge *br = to_bridge(d); 595 return sprintf(buf, "%lu\n", 596 jiffies_to_clock_t(br->multicast_query_interval)); 597 } 598 599 static int set_query_interval(struct net_bridge *br, unsigned long val) 600 { 601 br->multicast_query_interval = clock_t_to_jiffies(val); 602 return 0; 603 } 604 605 static ssize_t multicast_query_interval_store(struct device *d, 606 struct device_attribute *attr, 607 const char *buf, size_t len) 608 { 609 return store_bridge_parm(d, buf, len, set_query_interval); 610 } 611 static DEVICE_ATTR_RW(multicast_query_interval); 612 613 static ssize_t multicast_query_response_interval_show( 614 struct device *d, struct device_attribute *attr, char *buf) 615 { 616 struct net_bridge *br = to_bridge(d); 617 return sprintf( 618 buf, "%lu\n", 619 jiffies_to_clock_t(br->multicast_query_response_interval)); 620 } 621 622 static int set_query_response_interval(struct net_bridge *br, unsigned long val) 623 { 624 br->multicast_query_response_interval = clock_t_to_jiffies(val); 625 return 0; 626 } 627 628 static ssize_t multicast_query_response_interval_store( 629 struct device *d, struct device_attribute *attr, const char *buf, 630 size_t len) 631 { 632 return store_bridge_parm(d, buf, len, set_query_response_interval); 633 } 634 static DEVICE_ATTR_RW(multicast_query_response_interval); 635 636 static ssize_t multicast_startup_query_interval_show( 637 struct device *d, struct device_attribute *attr, char *buf) 638 { 639 struct net_bridge *br = to_bridge(d); 640 return sprintf( 641 buf, "%lu\n", 642 jiffies_to_clock_t(br->multicast_startup_query_interval)); 643 } 644 645 static int set_startup_query_interval(struct net_bridge *br, unsigned long val) 646 { 647 br->multicast_startup_query_interval = clock_t_to_jiffies(val); 648 return 0; 649 } 650 651 static ssize_t multicast_startup_query_interval_store( 652 struct device *d, struct device_attribute *attr, const char *buf, 653 size_t len) 654 { 655 return store_bridge_parm(d, buf, len, set_startup_query_interval); 656 } 657 static DEVICE_ATTR_RW(multicast_startup_query_interval); 658 659 static ssize_t multicast_stats_enabled_show(struct device *d, 660 struct device_attribute *attr, 661 char *buf) 662 { 663 struct net_bridge *br = to_bridge(d); 664 665 return sprintf(buf, "%d\n", 666 br_opt_get(br, BROPT_MULTICAST_STATS_ENABLED)); 667 } 668 669 static int set_stats_enabled(struct net_bridge *br, unsigned long val) 670 { 671 br_opt_toggle(br, BROPT_MULTICAST_STATS_ENABLED, !!val); 672 return 0; 673 } 674 675 static ssize_t multicast_stats_enabled_store(struct device *d, 676 struct device_attribute *attr, 677 const char *buf, 678 size_t len) 679 { 680 return store_bridge_parm(d, buf, len, set_stats_enabled); 681 } 682 static DEVICE_ATTR_RW(multicast_stats_enabled); 683 684 #if IS_ENABLED(CONFIG_IPV6) 685 static ssize_t multicast_mld_version_show(struct device *d, 686 struct device_attribute *attr, 687 char *buf) 688 { 689 struct net_bridge *br = to_bridge(d); 690 691 return sprintf(buf, "%u\n", br->multicast_mld_version); 692 } 693 694 static ssize_t multicast_mld_version_store(struct device *d, 695 struct device_attribute *attr, 696 const char *buf, size_t len) 697 { 698 return store_bridge_parm(d, buf, len, br_multicast_set_mld_version); 699 } 700 static DEVICE_ATTR_RW(multicast_mld_version); 701 #endif 702 #endif 703 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER) 704 static ssize_t nf_call_iptables_show( 705 struct device *d, struct device_attribute *attr, char *buf) 706 { 707 struct net_bridge *br = to_bridge(d); 708 return sprintf(buf, "%u\n", br_opt_get(br, BROPT_NF_CALL_IPTABLES)); 709 } 710 711 static int set_nf_call_iptables(struct net_bridge *br, unsigned long val) 712 { 713 br_opt_toggle(br, BROPT_NF_CALL_IPTABLES, !!val); 714 return 0; 715 } 716 717 static ssize_t nf_call_iptables_store( 718 struct device *d, struct device_attribute *attr, const char *buf, 719 size_t len) 720 { 721 return store_bridge_parm(d, buf, len, set_nf_call_iptables); 722 } 723 static DEVICE_ATTR_RW(nf_call_iptables); 724 725 static ssize_t nf_call_ip6tables_show( 726 struct device *d, struct device_attribute *attr, char *buf) 727 { 728 struct net_bridge *br = to_bridge(d); 729 return sprintf(buf, "%u\n", br_opt_get(br, BROPT_NF_CALL_IP6TABLES)); 730 } 731 732 static int set_nf_call_ip6tables(struct net_bridge *br, unsigned long val) 733 { 734 br_opt_toggle(br, BROPT_NF_CALL_IP6TABLES, !!val); 735 return 0; 736 } 737 738 static ssize_t nf_call_ip6tables_store( 739 struct device *d, struct device_attribute *attr, const char *buf, 740 size_t len) 741 { 742 return store_bridge_parm(d, buf, len, set_nf_call_ip6tables); 743 } 744 static DEVICE_ATTR_RW(nf_call_ip6tables); 745 746 static ssize_t nf_call_arptables_show( 747 struct device *d, struct device_attribute *attr, char *buf) 748 { 749 struct net_bridge *br = to_bridge(d); 750 return sprintf(buf, "%u\n", br_opt_get(br, BROPT_NF_CALL_ARPTABLES)); 751 } 752 753 static int set_nf_call_arptables(struct net_bridge *br, unsigned long val) 754 { 755 br_opt_toggle(br, BROPT_NF_CALL_ARPTABLES, !!val); 756 return 0; 757 } 758 759 static ssize_t nf_call_arptables_store( 760 struct device *d, struct device_attribute *attr, const char *buf, 761 size_t len) 762 { 763 return store_bridge_parm(d, buf, len, set_nf_call_arptables); 764 } 765 static DEVICE_ATTR_RW(nf_call_arptables); 766 #endif 767 #ifdef CONFIG_BRIDGE_VLAN_FILTERING 768 static ssize_t vlan_filtering_show(struct device *d, 769 struct device_attribute *attr, 770 char *buf) 771 { 772 struct net_bridge *br = to_bridge(d); 773 return sprintf(buf, "%d\n", br_opt_get(br, BROPT_VLAN_ENABLED)); 774 } 775 776 static ssize_t vlan_filtering_store(struct device *d, 777 struct device_attribute *attr, 778 const char *buf, size_t len) 779 { 780 return store_bridge_parm(d, buf, len, br_vlan_filter_toggle); 781 } 782 static DEVICE_ATTR_RW(vlan_filtering); 783 784 static ssize_t vlan_protocol_show(struct device *d, 785 struct device_attribute *attr, 786 char *buf) 787 { 788 struct net_bridge *br = to_bridge(d); 789 return sprintf(buf, "%#06x\n", ntohs(br->vlan_proto)); 790 } 791 792 static ssize_t vlan_protocol_store(struct device *d, 793 struct device_attribute *attr, 794 const char *buf, size_t len) 795 { 796 return store_bridge_parm(d, buf, len, br_vlan_set_proto); 797 } 798 static DEVICE_ATTR_RW(vlan_protocol); 799 800 static ssize_t default_pvid_show(struct device *d, 801 struct device_attribute *attr, 802 char *buf) 803 { 804 struct net_bridge *br = to_bridge(d); 805 return sprintf(buf, "%d\n", br->default_pvid); 806 } 807 808 static ssize_t default_pvid_store(struct device *d, 809 struct device_attribute *attr, 810 const char *buf, size_t len) 811 { 812 return store_bridge_parm(d, buf, len, br_vlan_set_default_pvid); 813 } 814 static DEVICE_ATTR_RW(default_pvid); 815 816 static ssize_t vlan_stats_enabled_show(struct device *d, 817 struct device_attribute *attr, 818 char *buf) 819 { 820 struct net_bridge *br = to_bridge(d); 821 return sprintf(buf, "%u\n", br_opt_get(br, BROPT_VLAN_STATS_ENABLED)); 822 } 823 824 static ssize_t vlan_stats_enabled_store(struct device *d, 825 struct device_attribute *attr, 826 const char *buf, size_t len) 827 { 828 return store_bridge_parm(d, buf, len, br_vlan_set_stats); 829 } 830 static DEVICE_ATTR_RW(vlan_stats_enabled); 831 832 static ssize_t vlan_stats_per_port_show(struct device *d, 833 struct device_attribute *attr, 834 char *buf) 835 { 836 struct net_bridge *br = to_bridge(d); 837 return sprintf(buf, "%u\n", br_opt_get(br, BROPT_VLAN_STATS_PER_PORT)); 838 } 839 840 static ssize_t vlan_stats_per_port_store(struct device *d, 841 struct device_attribute *attr, 842 const char *buf, size_t len) 843 { 844 return store_bridge_parm(d, buf, len, br_vlan_set_stats_per_port); 845 } 846 static DEVICE_ATTR_RW(vlan_stats_per_port); 847 #endif 848 849 static struct attribute *bridge_attrs[] = { 850 &dev_attr_forward_delay.attr, 851 &dev_attr_hello_time.attr, 852 &dev_attr_max_age.attr, 853 &dev_attr_ageing_time.attr, 854 &dev_attr_stp_state.attr, 855 &dev_attr_group_fwd_mask.attr, 856 &dev_attr_priority.attr, 857 &dev_attr_bridge_id.attr, 858 &dev_attr_root_id.attr, 859 &dev_attr_root_path_cost.attr, 860 &dev_attr_root_port.attr, 861 &dev_attr_topology_change.attr, 862 &dev_attr_topology_change_detected.attr, 863 &dev_attr_hello_timer.attr, 864 &dev_attr_tcn_timer.attr, 865 &dev_attr_topology_change_timer.attr, 866 &dev_attr_gc_timer.attr, 867 &dev_attr_group_addr.attr, 868 &dev_attr_flush.attr, 869 &dev_attr_no_linklocal_learn.attr, 870 #ifdef CONFIG_BRIDGE_IGMP_SNOOPING 871 &dev_attr_multicast_router.attr, 872 &dev_attr_multicast_snooping.attr, 873 &dev_attr_multicast_querier.attr, 874 &dev_attr_multicast_query_use_ifaddr.attr, 875 &dev_attr_hash_elasticity.attr, 876 &dev_attr_hash_max.attr, 877 &dev_attr_multicast_last_member_count.attr, 878 &dev_attr_multicast_startup_query_count.attr, 879 &dev_attr_multicast_last_member_interval.attr, 880 &dev_attr_multicast_membership_interval.attr, 881 &dev_attr_multicast_querier_interval.attr, 882 &dev_attr_multicast_query_interval.attr, 883 &dev_attr_multicast_query_response_interval.attr, 884 &dev_attr_multicast_startup_query_interval.attr, 885 &dev_attr_multicast_stats_enabled.attr, 886 &dev_attr_multicast_igmp_version.attr, 887 #if IS_ENABLED(CONFIG_IPV6) 888 &dev_attr_multicast_mld_version.attr, 889 #endif 890 #endif 891 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER) 892 &dev_attr_nf_call_iptables.attr, 893 &dev_attr_nf_call_ip6tables.attr, 894 &dev_attr_nf_call_arptables.attr, 895 #endif 896 #ifdef CONFIG_BRIDGE_VLAN_FILTERING 897 &dev_attr_vlan_filtering.attr, 898 &dev_attr_vlan_protocol.attr, 899 &dev_attr_default_pvid.attr, 900 &dev_attr_vlan_stats_enabled.attr, 901 &dev_attr_vlan_stats_per_port.attr, 902 #endif 903 NULL 904 }; 905 906 static const struct attribute_group bridge_group = { 907 .name = SYSFS_BRIDGE_ATTR, 908 .attrs = bridge_attrs, 909 }; 910 911 /* 912 * Export the forwarding information table as a binary file 913 * The records are struct __fdb_entry. 914 * 915 * Returns the number of bytes read. 916 */ 917 static ssize_t brforward_read(struct file *filp, struct kobject *kobj, 918 struct bin_attribute *bin_attr, 919 char *buf, loff_t off, size_t count) 920 { 921 struct device *dev = kobj_to_dev(kobj); 922 struct net_bridge *br = to_bridge(dev); 923 int n; 924 925 /* must read whole records */ 926 if (off % sizeof(struct __fdb_entry) != 0) 927 return -EINVAL; 928 929 n = br_fdb_fillbuf(br, buf, 930 count / sizeof(struct __fdb_entry), 931 off / sizeof(struct __fdb_entry)); 932 933 if (n > 0) 934 n *= sizeof(struct __fdb_entry); 935 936 return n; 937 } 938 939 static struct bin_attribute bridge_forward = { 940 .attr = { .name = SYSFS_BRIDGE_FDB, 941 .mode = 0444, }, 942 .read = brforward_read, 943 }; 944 945 /* 946 * Add entries in sysfs onto the existing network class device 947 * for the bridge. 948 * Adds a attribute group "bridge" containing tuning parameters. 949 * Binary attribute containing the forward table 950 * Sub directory to hold links to interfaces. 951 * 952 * Note: the ifobj exists only to be a subdirectory 953 * to hold links. The ifobj exists in same data structure 954 * as it's parent the bridge so reference counting works. 955 */ 956 int br_sysfs_addbr(struct net_device *dev) 957 { 958 struct kobject *brobj = &dev->dev.kobj; 959 struct net_bridge *br = netdev_priv(dev); 960 int err; 961 962 err = sysfs_create_group(brobj, &bridge_group); 963 if (err) { 964 pr_info("%s: can't create group %s/%s\n", 965 __func__, dev->name, bridge_group.name); 966 goto out1; 967 } 968 969 err = sysfs_create_bin_file(brobj, &bridge_forward); 970 if (err) { 971 pr_info("%s: can't create attribute file %s/%s\n", 972 __func__, dev->name, bridge_forward.attr.name); 973 goto out2; 974 } 975 976 br->ifobj = kobject_create_and_add(SYSFS_BRIDGE_PORT_SUBDIR, brobj); 977 if (!br->ifobj) { 978 pr_info("%s: can't add kobject (directory) %s/%s\n", 979 __func__, dev->name, SYSFS_BRIDGE_PORT_SUBDIR); 980 err = -ENOMEM; 981 goto out3; 982 } 983 return 0; 984 out3: 985 sysfs_remove_bin_file(&dev->dev.kobj, &bridge_forward); 986 out2: 987 sysfs_remove_group(&dev->dev.kobj, &bridge_group); 988 out1: 989 return err; 990 991 } 992 993 void br_sysfs_delbr(struct net_device *dev) 994 { 995 struct kobject *kobj = &dev->dev.kobj; 996 struct net_bridge *br = netdev_priv(dev); 997 998 kobject_put(br->ifobj); 999 sysfs_remove_bin_file(kobj, &bridge_forward); 1000 sysfs_remove_group(kobj, &bridge_group); 1001 } 1002