cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

br_sysfs_br.c (30301B)


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