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