net/bridge/br_sysfs_br.c

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