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