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