net/bridge/br_sysfs_br.c

   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 }