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