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