br_fdb.c

   1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *	Forwarding database
   4 *	Linux ethernet bridge
   5 *
   6 *	Authors:
   7 *	Lennert Buytenhek		<buytenh@gnu.org>
   8 */
   9
  10#include <linux/kernel.h>
  11#include <linux/init.h>
  12#include <linux/rculist.h>
  13#include <linux/spinlock.h>
  14#include <linux/times.h>
  15#include <linux/netdevice.h>
  16#include <linux/etherdevice.h>
  17#include <linux/jhash.h>
  18#include <linux/random.h>
  19#include <linux/slab.h>
  20#include <linux/atomic.h>
  21#include <linux/unaligned.h>
  22#include <linux/if_vlan.h>
  23#include <net/switchdev.h>
  24#include <trace/events/bridge.h>
  25#include "br_private.h"
  26
  27static const struct rhashtable_params br_fdb_rht_params = {
  28	.head_offset = offsetof(struct net_bridge_fdb_entry, rhnode),
  29	.key_offset = offsetof(struct net_bridge_fdb_entry, key),
  30	.key_len = sizeof(struct net_bridge_fdb_key),
  31	.automatic_shrinking = true,
  32};
  33
  34static struct kmem_cache *br_fdb_cache __read_mostly;
  35
  36int __init br_fdb_init(void)
  37{
  38	br_fdb_cache = KMEM_CACHE(net_bridge_fdb_entry, SLAB_HWCACHE_ALIGN);
  39	if (!br_fdb_cache)
  40		return -ENOMEM;
  41
  42	return 0;
  43}
  44
  45void br_fdb_fini(void)
  46{
  47	kmem_cache_destroy(br_fdb_cache);
  48}
  49
  50int br_fdb_hash_init(struct net_bridge *br)
  51{
  52	return rhashtable_init(&br->fdb_hash_tbl, &br_fdb_rht_params);
  53}
  54
  55void br_fdb_hash_fini(struct net_bridge *br)
  56{
  57	rhashtable_destroy(&br->fdb_hash_tbl);
  58}
  59
  60/* if topology_changing then use forward_delay (default 15 sec)
  61 * otherwise keep longer (default 5 minutes)
  62 */
  63static inline unsigned long hold_time(const struct net_bridge *br)
  64{
  65	return br->topology_change ? br->forward_delay : br->ageing_time;
  66}
  67
  68static inline int has_expired(const struct net_bridge *br,
  69				  const struct net_bridge_fdb_entry *fdb)
  70{
  71	return !test_bit(BR_FDB_STATIC, &fdb->flags) &&
  72	       !test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags) &&
  73	       time_before_eq(READ_ONCE(fdb->updated) + hold_time(br), jiffies);
  74}
  75
  76static int fdb_to_nud(const struct net_bridge *br,
  77		      const struct net_bridge_fdb_entry *fdb)
  78{
  79	if (test_bit(BR_FDB_LOCAL, &fdb->flags))
  80		return NUD_PERMANENT;
  81	else if (test_bit(BR_FDB_STATIC, &fdb->flags))
  82		return NUD_NOARP;
  83	else if (has_expired(br, fdb))
  84		return NUD_STALE;
  85	else
  86		return NUD_REACHABLE;
  87}
  88
  89static int fdb_fill_info(struct sk_buff *skb, const struct net_bridge *br,
  90			 const struct net_bridge_fdb_entry *fdb,
  91			 u32 portid, u32 seq, int type, unsigned int flags)
  92{
  93	const struct net_bridge_port *dst = READ_ONCE(fdb->dst);
  94	unsigned long now = jiffies;
  95	struct nda_cacheinfo ci;
  96	struct nlmsghdr *nlh;
  97	struct ndmsg *ndm;
  98	u32 ext_flags = 0;
  99
 100	nlh = nlmsg_put(skb, portid, seq, type, sizeof(*ndm), flags);
 101	if (nlh == NULL)
 102		return -EMSGSIZE;
 103
 104	ndm = nlmsg_data(nlh);
 105	ndm->ndm_family	 = AF_BRIDGE;
 106	ndm->ndm_pad1    = 0;
 107	ndm->ndm_pad2    = 0;
 108	ndm->ndm_flags	 = 0;
 109	ndm->ndm_type	 = 0;
 110	ndm->ndm_ifindex = dst ? dst->dev->ifindex : br->dev->ifindex;
 111	ndm->ndm_state   = fdb_to_nud(br, fdb);
 112
 113	if (test_bit(BR_FDB_OFFLOADED, &fdb->flags))
 114		ndm->ndm_flags |= NTF_OFFLOADED;
 115	if (test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags))
 116		ndm->ndm_flags |= NTF_EXT_LEARNED;
 117	if (test_bit(BR_FDB_STICKY, &fdb->flags))
 118		ndm->ndm_flags |= NTF_STICKY;
 119	if (test_bit(BR_FDB_LOCKED, &fdb->flags))
 120		ext_flags |= NTF_EXT_LOCKED;
 121
 122	if (nla_put(skb, NDA_LLADDR, ETH_ALEN, &fdb->key.addr))
 123		goto nla_put_failure;
 124	if (nla_put_u32(skb, NDA_MASTER, br->dev->ifindex))
 125		goto nla_put_failure;
 126	if (nla_put_u32(skb, NDA_FLAGS_EXT, ext_flags))
 127		goto nla_put_failure;
 128
 129	ci.ndm_used	 = jiffies_to_clock_t(now - READ_ONCE(fdb->used));
 130	ci.ndm_confirmed = 0;
 131	ci.ndm_updated	 = jiffies_to_clock_t(now - READ_ONCE(fdb->updated));
 132	ci.ndm_refcnt	 = 0;
 133	if (nla_put(skb, NDA_CACHEINFO, sizeof(ci), &ci))
 134		goto nla_put_failure;
 135
 136	if (fdb->key.vlan_id && nla_put(skb, NDA_VLAN, sizeof(u16),
 137					&fdb->key.vlan_id))
 138		goto nla_put_failure;
 139
 140	if (test_bit(BR_FDB_NOTIFY, &fdb->flags)) {
 141		struct nlattr *nest = nla_nest_start(skb, NDA_FDB_EXT_ATTRS);
 142		u8 notify_bits = FDB_NOTIFY_BIT;
 143
 144		if (!nest)
 145			goto nla_put_failure;
 146		if (test_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags))
 147			notify_bits |= FDB_NOTIFY_INACTIVE_BIT;
 148
 149		if (nla_put_u8(skb, NFEA_ACTIVITY_NOTIFY, notify_bits)) {
 150			nla_nest_cancel(skb, nest);
 151			goto nla_put_failure;
 152		}
 153
 154		nla_nest_end(skb, nest);
 155	}
 156
 157	nlmsg_end(skb, nlh);
 158	return 0;
 159
 160nla_put_failure:
 161	nlmsg_cancel(skb, nlh);
 162	return -EMSGSIZE;
 163}
 164
 165static inline size_t fdb_nlmsg_size(void)
 166{
 167	return NLMSG_ALIGN(sizeof(struct ndmsg))
 168		+ nla_total_size(ETH_ALEN) /* NDA_LLADDR */
 169		+ nla_total_size(sizeof(u32)) /* NDA_MASTER */
 170		+ nla_total_size(sizeof(u32)) /* NDA_FLAGS_EXT */
 171		+ nla_total_size(sizeof(u16)) /* NDA_VLAN */
 172		+ nla_total_size(sizeof(struct nda_cacheinfo))
 173		+ nla_total_size(0) /* NDA_FDB_EXT_ATTRS */
 174		+ nla_total_size(sizeof(u8)); /* NFEA_ACTIVITY_NOTIFY */
 175}
 176
 177static void fdb_notify(struct net_bridge *br,
 178		       const struct net_bridge_fdb_entry *fdb, int type,
 179		       bool swdev_notify)
 180{
 181	struct net *net = dev_net(br->dev);
 182	struct sk_buff *skb;
 183	int err = -ENOBUFS;
 184
 185	if (swdev_notify)
 186		br_switchdev_fdb_notify(br, fdb, type);
 187
 188	skb = nlmsg_new(fdb_nlmsg_size(), GFP_ATOMIC);
 189	if (skb == NULL)
 190		goto errout;
 191
 192	err = fdb_fill_info(skb, br, fdb, 0, 0, type, 0);
 193	if (err < 0) {
 194		/* -EMSGSIZE implies BUG in fdb_nlmsg_size() */
 195		WARN_ON(err == -EMSGSIZE);
 196		kfree_skb(skb);
 197		goto errout;
 198	}
 199	rtnl_notify(skb, net, 0, RTNLGRP_NEIGH, NULL, GFP_ATOMIC);
 200	return;
 201errout:
 202	rtnl_set_sk_err(net, RTNLGRP_NEIGH, err);
 203}
 204
 205static struct net_bridge_fdb_entry *fdb_find_rcu(struct rhashtable *tbl,
 206						 const unsigned char *addr,
 207						 __u16 vid)
 208{
 209	struct net_bridge_fdb_key key;
 210
 211	WARN_ON_ONCE(!rcu_read_lock_held());
 212
 213	key.vlan_id = vid;
 214	memcpy(key.addr.addr, addr, sizeof(key.addr.addr));
 215
 216	return rhashtable_lookup(tbl, &key, br_fdb_rht_params);
 217}
 218
 219/* requires bridge hash_lock */
 220static struct net_bridge_fdb_entry *br_fdb_find(struct net_bridge *br,
 221						const unsigned char *addr,
 222						__u16 vid)
 223{
 224	struct net_bridge_fdb_entry *fdb;
 225
 226	lockdep_assert_held_once(&br->hash_lock);
 227
 228	rcu_read_lock();
 229	fdb = fdb_find_rcu(&br->fdb_hash_tbl, addr, vid);
 230	rcu_read_unlock();
 231
 232	return fdb;
 233}
 234
 235struct net_device *br_fdb_find_port(const struct net_device *br_dev,
 236				    const unsigned char *addr,
 237				    __u16 vid)
 238{
 239	struct net_bridge_fdb_entry *f;
 240	struct net_device *dev = NULL;
 241	struct net_bridge *br;
 242
 243	ASSERT_RTNL();
 244
 245	if (!netif_is_bridge_master(br_dev))
 246		return NULL;
 247
 248	br = netdev_priv(br_dev);
 249	rcu_read_lock();
 250	f = br_fdb_find_rcu(br, addr, vid);
 251	if (f && f->dst)
 252		dev = f->dst->dev;
 253	rcu_read_unlock();
 254
 255	return dev;
 256}
 257EXPORT_SYMBOL_GPL(br_fdb_find_port);
 258
 259struct net_bridge_fdb_entry *br_fdb_find_rcu(struct net_bridge *br,
 260					     const unsigned char *addr,
 261					     __u16 vid)
 262{
 263	return fdb_find_rcu(&br->fdb_hash_tbl, addr, vid);
 264}
 265
 266/* When a static FDB entry is added, the mac address from the entry is
 267 * added to the bridge private HW address list and all required ports
 268 * are then updated with the new information.
 269 * Called under RTNL.
 270 */
 271static void fdb_add_hw_addr(struct net_bridge *br, const unsigned char *addr)
 272{
 273	int err;
 274	struct net_bridge_port *p;
 275
 276	ASSERT_RTNL();
 277
 278	list_for_each_entry(p, &br->port_list, list) {
 279		if (!br_promisc_port(p)) {
 280			err = dev_uc_add(p->dev, addr);
 281			if (err)
 282				goto undo;
 283		}
 284	}
 285
 286	return;
 287undo:
 288	list_for_each_entry_continue_reverse(p, &br->port_list, list) {
 289		if (!br_promisc_port(p))
 290			dev_uc_del(p->dev, addr);
 291	}
 292}
 293
 294/* When a static FDB entry is deleted, the HW address from that entry is
 295 * also removed from the bridge private HW address list and updates all
 296 * the ports with needed information.
 297 * Called under RTNL.
 298 */
 299static void fdb_del_hw_addr(struct net_bridge *br, const unsigned char *addr)
 300{
 301	struct net_bridge_port *p;
 302
 303	ASSERT_RTNL();
 304
 305	list_for_each_entry(p, &br->port_list, list) {
 306		if (!br_promisc_port(p))
 307			dev_uc_del(p->dev, addr);
 308	}
 309}
 310
 311static void fdb_delete(struct net_bridge *br, struct net_bridge_fdb_entry *f,
 312		       bool swdev_notify)
 313{
 314	trace_fdb_delete(br, f);
 315
 316	if (test_bit(BR_FDB_STATIC, &f->flags))
 317		fdb_del_hw_addr(br, f->key.addr.addr);
 318
 319	hlist_del_init_rcu(&f->fdb_node);
 320	rhashtable_remove_fast(&br->fdb_hash_tbl, &f->rhnode,
 321			       br_fdb_rht_params);
 322	if (test_and_clear_bit(BR_FDB_DYNAMIC_LEARNED, &f->flags))
 323		atomic_dec(&br->fdb_n_learned);
 324	fdb_notify(br, f, RTM_DELNEIGH, swdev_notify);
 325	kfree_rcu(f, rcu);
 326}
 327
 328/* Delete a local entry if no other port had the same address.
 329 *
 330 * This function should only be called on entries with BR_FDB_LOCAL set,
 331 * so even with BR_FDB_ADDED_BY_USER cleared we never need to increase
 332 * the accounting for dynamically learned entries again.
 333 */
 334static void fdb_delete_local(struct net_bridge *br,
 335			     const struct net_bridge_port *p,
 336			     struct net_bridge_fdb_entry *f)
 337{
 338	const unsigned char *addr = f->key.addr.addr;
 339	struct net_bridge_vlan_group *vg;
 340	const struct net_bridge_vlan *v;
 341	struct net_bridge_port *op;
 342	u16 vid = f->key.vlan_id;
 343
 344	/* Maybe another port has same hw addr? */
 345	list_for_each_entry(op, &br->port_list, list) {
 346		vg = nbp_vlan_group(op);
 347		if (op != p && ether_addr_equal(op->dev->dev_addr, addr) &&
 348		    (!vid || br_vlan_find(vg, vid))) {
 349			f->dst = op;
 350			clear_bit(BR_FDB_ADDED_BY_USER, &f->flags);
 351			return;
 352		}
 353	}
 354
 355	vg = br_vlan_group(br);
 356	v = br_vlan_find(vg, vid);
 357	/* Maybe bridge device has same hw addr? */
 358	if (p && ether_addr_equal(br->dev->dev_addr, addr) &&
 359	    (!vid || (v && br_vlan_should_use(v)))) {
 360		f->dst = NULL;
 361		clear_bit(BR_FDB_ADDED_BY_USER, &f->flags);
 362		return;
 363	}
 364
 365	fdb_delete(br, f, true);
 366}
 367
 368void br_fdb_find_delete_local(struct net_bridge *br,
 369			      const struct net_bridge_port *p,
 370			      const unsigned char *addr, u16 vid)
 371{
 372	struct net_bridge_fdb_entry *f;
 373
 374	spin_lock_bh(&br->hash_lock);
 375	f = br_fdb_find(br, addr, vid);
 376	if (f && test_bit(BR_FDB_LOCAL, &f->flags) &&
 377	    !test_bit(BR_FDB_ADDED_BY_USER, &f->flags) && f->dst == p)
 378		fdb_delete_local(br, p, f);
 379	spin_unlock_bh(&br->hash_lock);
 380}
 381
 382static struct net_bridge_fdb_entry *fdb_create(struct net_bridge *br,
 383					       struct net_bridge_port *source,
 384					       const unsigned char *addr,
 385					       __u16 vid,
 386					       unsigned long flags)
 387{
 388	bool learned = !test_bit(BR_FDB_ADDED_BY_USER, &flags) &&
 389		       !test_bit(BR_FDB_LOCAL, &flags);
 390	u32 max_learned = READ_ONCE(br->fdb_max_learned);
 391	struct net_bridge_fdb_entry *fdb;
 392	int err;
 393
 394	if (likely(learned)) {
 395		int n_learned = atomic_read(&br->fdb_n_learned);
 396
 397		if (unlikely(max_learned && n_learned >= max_learned))
 398			return NULL;
 399		__set_bit(BR_FDB_DYNAMIC_LEARNED, &flags);
 400	}
 401
 402	fdb = kmem_cache_alloc(br_fdb_cache, GFP_ATOMIC);
 403	if (!fdb)
 404		return NULL;
 405
 406	memcpy(fdb->key.addr.addr, addr, ETH_ALEN);
 407	WRITE_ONCE(fdb->dst, source);
 408	fdb->key.vlan_id = vid;
 409	fdb->flags = flags;
 410	fdb->updated = fdb->used = jiffies;
 411	err = rhashtable_lookup_insert_fast(&br->fdb_hash_tbl, &fdb->rhnode,
 412					    br_fdb_rht_params);
 413	if (err) {
 414		kmem_cache_free(br_fdb_cache, fdb);
 415		return NULL;
 416	}
 417
 418	if (likely(learned))
 419		atomic_inc(&br->fdb_n_learned);
 420
 421	hlist_add_head_rcu(&fdb->fdb_node, &br->fdb_list);
 422
 423	return fdb;
 424}
 425
 426static int fdb_add_local(struct net_bridge *br, struct net_bridge_port *source,
 427			 const unsigned char *addr, u16 vid)
 428{
 429	struct net_bridge_fdb_entry *fdb;
 430
 431	if (!is_valid_ether_addr(addr))
 432		return -EINVAL;
 433
 434	fdb = br_fdb_find(br, addr, vid);
 435	if (fdb) {
 436		/* it is okay to have multiple ports with same
 437		 * address, just use the first one.
 438		 */
 439		if (test_bit(BR_FDB_LOCAL, &fdb->flags))
 440			return 0;
 441		br_warn(br, "adding interface %s with same address as a received packet (addr:%pM, vlan:%u)\n",
 442			source ? source->dev->name : br->dev->name, addr, vid);
 443		fdb_delete(br, fdb, true);
 444	}
 445
 446	fdb = fdb_create(br, source, addr, vid,
 447			 BIT(BR_FDB_LOCAL) | BIT(BR_FDB_STATIC));
 448	if (!fdb)
 449		return -ENOMEM;
 450
 451	fdb_add_hw_addr(br, addr);
 452	fdb_notify(br, fdb, RTM_NEWNEIGH, true);
 453	return 0;
 454}
 455
 456void br_fdb_changeaddr(struct net_bridge_port *p, const unsigned char *newaddr)
 457{
 458	struct net_bridge_vlan_group *vg;
 459	struct net_bridge_fdb_entry *f;
 460	struct net_bridge *br = p->br;
 461	struct net_bridge_vlan *v;
 462	bool local_vlan_0;
 463
 464	local_vlan_0 = br_opt_get(br, BROPT_FDB_LOCAL_VLAN_0);
 465
 466	spin_lock_bh(&br->hash_lock);
 467	vg = nbp_vlan_group(p);
 468	hlist_for_each_entry(f, &br->fdb_list, fdb_node) {
 469		if (f->dst == p && test_bit(BR_FDB_LOCAL, &f->flags) &&
 470		    !test_bit(BR_FDB_ADDED_BY_USER, &f->flags)) {
 471			/* delete old one */
 472			fdb_delete_local(br, p, f);
 473
 474			/* if this port has no vlan information configured, or
 475			 * local entries are only kept on VLAN 0, we can safely
 476			 * be done at this point.
 477			 */
 478			if (!vg || !vg->num_vlans || local_vlan_0)
 479				goto insert;
 480		}
 481	}
 482
 483insert:
 484	/* insert new address,  may fail if invalid address or dup. */
 485	fdb_add_local(br, p, newaddr, 0);
 486
 487	if (!vg || !vg->num_vlans || local_vlan_0)
 488		goto done;
 489
 490	/* Now add entries for every VLAN configured on the port.
 491	 * This function runs under RTNL so the bitmap will not change
 492	 * from under us.
 493	 */
 494	list_for_each_entry(v, &vg->vlan_list, vlist)
 495		fdb_add_local(br, p, newaddr, v->vid);
 496
 497done:
 498	spin_unlock_bh(&br->hash_lock);
 499}
 500
 501void br_fdb_change_mac_address(struct net_bridge *br, const u8 *newaddr)
 502{
 503	struct net_bridge_vlan_group *vg;
 504	struct net_bridge_fdb_entry *f;
 505	struct net_bridge_vlan *v;
 506	bool local_vlan_0;
 507
 508	local_vlan_0 = br_opt_get(br, BROPT_FDB_LOCAL_VLAN_0);
 509
 510	spin_lock_bh(&br->hash_lock);
 511
 512	/* If old entry was unassociated with any port, then delete it. */
 513	f = br_fdb_find(br, br->dev->dev_addr, 0);
 514	if (f && test_bit(BR_FDB_LOCAL, &f->flags) &&
 515	    !f->dst && !test_bit(BR_FDB_ADDED_BY_USER, &f->flags))
 516		fdb_delete_local(br, NULL, f);
 517
 518	fdb_add_local(br, NULL, newaddr, 0);
 519	vg = br_vlan_group(br);
 520	if (!vg || !vg->num_vlans || local_vlan_0)
 521		goto out;
 522	/* Now remove and add entries for every VLAN configured on the
 523	 * bridge.  This function runs under RTNL so the bitmap will not
 524	 * change from under us.
 525	 */
 526	list_for_each_entry(v, &vg->vlan_list, vlist) {
 527		if (!br_vlan_should_use(v))
 528			continue;
 529		f = br_fdb_find(br, br->dev->dev_addr, v->vid);
 530		if (f && test_bit(BR_FDB_LOCAL, &f->flags) &&
 531		    !f->dst && !test_bit(BR_FDB_ADDED_BY_USER, &f->flags))
 532			fdb_delete_local(br, NULL, f);
 533		fdb_add_local(br, NULL, newaddr, v->vid);
 534	}
 535out:
 536	spin_unlock_bh(&br->hash_lock);
 537}
 538
 539void br_fdb_cleanup(struct work_struct *work)
 540{
 541	struct net_bridge *br = container_of(work, struct net_bridge,
 542					     gc_work.work);
 543	struct net_bridge_fdb_entry *f = NULL;
 544	unsigned long delay = hold_time(br);
 545	unsigned long work_delay = delay;
 546	unsigned long now = jiffies;
 547
 548	/* this part is tricky, in order to avoid blocking learning and
 549	 * consequently forwarding, we rely on rcu to delete objects with
 550	 * delayed freeing allowing us to continue traversing
 551	 */
 552	rcu_read_lock();
 553	hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
 554		unsigned long this_timer = READ_ONCE(f->updated) + delay;
 555
 556		if (test_bit(BR_FDB_STATIC, &f->flags) ||
 557		    test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &f->flags)) {
 558			if (test_bit(BR_FDB_NOTIFY, &f->flags)) {
 559				if (time_after(this_timer, now))
 560					work_delay = min(work_delay,
 561							 this_timer - now);
 562				else if (!test_and_set_bit(BR_FDB_NOTIFY_INACTIVE,
 563							   &f->flags))
 564					fdb_notify(br, f, RTM_NEWNEIGH, false);
 565			}
 566			continue;
 567		}
 568
 569		if (time_after(this_timer, now)) {
 570			work_delay = min(work_delay, this_timer - now);
 571		} else {
 572			spin_lock_bh(&br->hash_lock);
 573			if (!hlist_unhashed(&f->fdb_node))
 574				fdb_delete(br, f, true);
 575			spin_unlock_bh(&br->hash_lock);
 576		}
 577	}
 578	rcu_read_unlock();
 579
 580	/* Cleanup minimum 10 milliseconds apart */
 581	work_delay = max_t(unsigned long, work_delay, msecs_to_jiffies(10));
 582	mod_delayed_work(system_long_wq, &br->gc_work, work_delay);
 583}
 584
 585static void br_fdb_delete_locals_per_vlan_port(struct net_bridge *br,
 586					       struct net_bridge_port *p)
 587{
 588	struct net_bridge_vlan_group *vg;
 589	struct net_bridge_vlan *v;
 590	struct net_device *dev;
 591
 592	if (p) {
 593		vg = nbp_vlan_group(p);
 594		dev = p->dev;
 595	} else {
 596		vg = br_vlan_group(br);
 597		dev = br->dev;
 598	}
 599
 600	if (!vg)
 601		return;
 602
 603	list_for_each_entry(v, &vg->vlan_list, vlist)
 604		br_fdb_find_delete_local(br, p, dev->dev_addr, v->vid);
 605}
 606
 607static void br_fdb_delete_locals_per_vlan(struct net_bridge *br)
 608{
 609	struct net_bridge_port *p;
 610
 611	ASSERT_RTNL();
 612
 613	list_for_each_entry(p, &br->port_list, list)
 614		br_fdb_delete_locals_per_vlan_port(br, p);
 615
 616	br_fdb_delete_locals_per_vlan_port(br, NULL);
 617}
 618
 619static int br_fdb_insert_locals_per_vlan_port(struct net_bridge *br,
 620					      struct net_bridge_port *p,
 621					      struct netlink_ext_ack *extack)
 622{
 623	struct net_bridge_vlan_group *vg;
 624	struct net_bridge_vlan *v;
 625	struct net_device *dev;
 626	int err;
 627
 628	if (p) {
 629		vg = nbp_vlan_group(p);
 630		dev = p->dev;
 631	} else {
 632		vg = br_vlan_group(br);
 633		dev = br->dev;
 634	}
 635
 636	if (!vg)
 637		return 0;
 638
 639	list_for_each_entry(v, &vg->vlan_list, vlist) {
 640		if (!br_vlan_should_use(v))
 641			continue;
 642
 643		err = br_fdb_add_local(br, p, dev->dev_addr, v->vid);
 644		if (err)
 645			return err;
 646	}
 647
 648	return 0;
 649}
 650
 651static int br_fdb_insert_locals_per_vlan(struct net_bridge *br,
 652					 struct netlink_ext_ack *extack)
 653{
 654	struct net_bridge_port *p;
 655	int err;
 656
 657	ASSERT_RTNL();
 658
 659	list_for_each_entry(p, &br->port_list, list) {
 660		err = br_fdb_insert_locals_per_vlan_port(br, p, extack);
 661		if (err)
 662			goto rollback;
 663	}
 664
 665	err = br_fdb_insert_locals_per_vlan_port(br, NULL, extack);
 666	if (err)
 667		goto rollback;
 668
 669	return 0;
 670
 671rollback:
 672	NL_SET_ERR_MSG_MOD(extack, "fdb_local_vlan_0 toggle: FDB entry insertion failed");
 673	br_fdb_delete_locals_per_vlan(br);
 674	return err;
 675}
 676
 677int br_fdb_toggle_local_vlan_0(struct net_bridge *br, bool on,
 678			       struct netlink_ext_ack *extack)
 679{
 680	if (!on)
 681		return br_fdb_insert_locals_per_vlan(br, extack);
 682
 683	br_fdb_delete_locals_per_vlan(br);
 684	return 0;
 685}
 686
 687static bool __fdb_flush_matches(const struct net_bridge *br,
 688				const struct net_bridge_fdb_entry *f,
 689				const struct net_bridge_fdb_flush_desc *desc)
 690{
 691	const struct net_bridge_port *dst = READ_ONCE(f->dst);
 692	int port_ifidx = dst ? dst->dev->ifindex : br->dev->ifindex;
 693
 694	if (desc->vlan_id && desc->vlan_id != f->key.vlan_id)
 695		return false;
 696	if (desc->port_ifindex && desc->port_ifindex != port_ifidx)
 697		return false;
 698	if (desc->flags_mask && (f->flags & desc->flags_mask) != desc->flags)
 699		return false;
 700
 701	return true;
 702}
 703
 704/* Flush forwarding database entries matching the description */
 705void br_fdb_flush(struct net_bridge *br,
 706		  const struct net_bridge_fdb_flush_desc *desc)
 707{
 708	struct net_bridge_fdb_entry *f;
 709
 710	rcu_read_lock();
 711	hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
 712		if (!__fdb_flush_matches(br, f, desc))
 713			continue;
 714
 715		spin_lock_bh(&br->hash_lock);
 716		if (!hlist_unhashed(&f->fdb_node))
 717			fdb_delete(br, f, true);
 718		spin_unlock_bh(&br->hash_lock);
 719	}
 720	rcu_read_unlock();
 721}
 722
 723static unsigned long __ndm_state_to_fdb_flags(u16 ndm_state)
 724{
 725	unsigned long flags = 0;
 726
 727	if (ndm_state & NUD_PERMANENT)
 728		__set_bit(BR_FDB_LOCAL, &flags);
 729	if (ndm_state & NUD_NOARP)
 730		__set_bit(BR_FDB_STATIC, &flags);
 731
 732	return flags;
 733}
 734
 735static unsigned long __ndm_flags_to_fdb_flags(u8 ndm_flags)
 736{
 737	unsigned long flags = 0;
 738
 739	if (ndm_flags & NTF_USE)
 740		__set_bit(BR_FDB_ADDED_BY_USER, &flags);
 741	if (ndm_flags & NTF_EXT_LEARNED)
 742		__set_bit(BR_FDB_ADDED_BY_EXT_LEARN, &flags);
 743	if (ndm_flags & NTF_OFFLOADED)
 744		__set_bit(BR_FDB_OFFLOADED, &flags);
 745	if (ndm_flags & NTF_STICKY)
 746		__set_bit(BR_FDB_STICKY, &flags);
 747
 748	return flags;
 749}
 750
 751static int __fdb_flush_validate_ifindex(const struct net_bridge *br,
 752					int ifindex,
 753					struct netlink_ext_ack *extack)
 754{
 755	const struct net_device *dev;
 756
 757	dev = __dev_get_by_index(dev_net(br->dev), ifindex);
 758	if (!dev) {
 759		NL_SET_ERR_MSG_MOD(extack, "Unknown flush device ifindex");
 760		return -ENODEV;
 761	}
 762	if (!netif_is_bridge_master(dev) && !netif_is_bridge_port(dev)) {
 763		NL_SET_ERR_MSG_MOD(extack, "Flush device is not a bridge or bridge port");
 764		return -EINVAL;
 765	}
 766	if (netif_is_bridge_master(dev) && dev != br->dev) {
 767		NL_SET_ERR_MSG_MOD(extack,
 768				   "Flush bridge device does not match target bridge device");
 769		return -EINVAL;
 770	}
 771	if (netif_is_bridge_port(dev)) {
 772		struct net_bridge_port *p = br_port_get_rtnl(dev);
 773
 774		if (p->br != br) {
 775			NL_SET_ERR_MSG_MOD(extack, "Port belongs to a different bridge device");
 776			return -EINVAL;
 777		}
 778	}
 779
 780	return 0;
 781}
 782
 783static const struct nla_policy br_fdb_del_bulk_policy[NDA_MAX + 1] = {
 784	[NDA_VLAN]	= NLA_POLICY_RANGE(NLA_U16, 1, VLAN_N_VID - 2),
 785	[NDA_IFINDEX]	= NLA_POLICY_MIN(NLA_S32, 1),
 786	[NDA_NDM_STATE_MASK]	= { .type = NLA_U16 },
 787	[NDA_NDM_FLAGS_MASK]	= { .type = NLA_U8 },
 788};
 789
 790int br_fdb_delete_bulk(struct nlmsghdr *nlh, struct net_device *dev,
 791		       struct netlink_ext_ack *extack)
 792{
 793	struct net_bridge_fdb_flush_desc desc = {};
 794	struct ndmsg *ndm = nlmsg_data(nlh);
 795	struct net_bridge_port *p = NULL;
 796	struct nlattr *tb[NDA_MAX + 1];
 797	struct net_bridge *br;
 798	u8 ndm_flags;
 799	int err;
 800
 801	ndm_flags = ndm->ndm_flags & ~FDB_FLUSH_IGNORED_NDM_FLAGS;
 802
 803	err = nlmsg_parse(nlh, sizeof(*ndm), tb, NDA_MAX,
 804			  br_fdb_del_bulk_policy, extack);
 805	if (err)
 806		return err;
 807
 808	if (netif_is_bridge_master(dev)) {
 809		br = netdev_priv(dev);
 810	} else {
 811		p = br_port_get_rtnl(dev);
 812		if (!p) {
 813			NL_SET_ERR_MSG_MOD(extack, "Device is not a bridge port");
 814			return -EINVAL;
 815		}
 816		br = p->br;
 817	}
 818
 819	if (tb[NDA_VLAN])
 820		desc.vlan_id = nla_get_u16(tb[NDA_VLAN]);
 821
 822	if (ndm_flags & ~FDB_FLUSH_ALLOWED_NDM_FLAGS) {
 823		NL_SET_ERR_MSG(extack, "Unsupported fdb flush ndm flag bits set");
 824		return -EINVAL;
 825	}
 826	if (ndm->ndm_state & ~FDB_FLUSH_ALLOWED_NDM_STATES) {
 827		NL_SET_ERR_MSG(extack, "Unsupported fdb flush ndm state bits set");
 828		return -EINVAL;
 829	}
 830
 831	desc.flags |= __ndm_state_to_fdb_flags(ndm->ndm_state);
 832	desc.flags |= __ndm_flags_to_fdb_flags(ndm_flags);
 833	if (tb[NDA_NDM_STATE_MASK]) {
 834		u16 ndm_state_mask = nla_get_u16(tb[NDA_NDM_STATE_MASK]);
 835
 836		desc.flags_mask |= __ndm_state_to_fdb_flags(ndm_state_mask);
 837	}
 838	if (tb[NDA_NDM_FLAGS_MASK]) {
 839		u8 ndm_flags_mask = nla_get_u8(tb[NDA_NDM_FLAGS_MASK]);
 840
 841		desc.flags_mask |= __ndm_flags_to_fdb_flags(ndm_flags_mask);
 842	}
 843	if (tb[NDA_IFINDEX]) {
 844		int ifidx = nla_get_s32(tb[NDA_IFINDEX]);
 845
 846		err = __fdb_flush_validate_ifindex(br, ifidx, extack);
 847		if (err)
 848			return err;
 849		desc.port_ifindex = ifidx;
 850	} else if (p) {
 851		/* flush was invoked with port device and NTF_MASTER */
 852		desc.port_ifindex = p->dev->ifindex;
 853	}
 854
 855	br_debug(br, "flushing port ifindex: %d vlan id: %u flags: 0x%lx flags mask: 0x%lx\n",
 856		 desc.port_ifindex, desc.vlan_id, desc.flags, desc.flags_mask);
 857
 858	br_fdb_flush(br, &desc);
 859
 860	return 0;
 861}
 862
 863/* Flush all entries referring to a specific port.
 864 * if do_all is set also flush static entries
 865 * if vid is set delete all entries that match the vlan_id
 866 */
 867void br_fdb_delete_by_port(struct net_bridge *br,
 868			   const struct net_bridge_port *p,
 869			   u16 vid,
 870			   int do_all)
 871{
 872	struct net_bridge_fdb_entry *f;
 873	struct hlist_node *tmp;
 874
 875	spin_lock_bh(&br->hash_lock);
 876	hlist_for_each_entry_safe(f, tmp, &br->fdb_list, fdb_node) {
 877		if (f->dst != p)
 878			continue;
 879
 880		if (!do_all)
 881			if (test_bit(BR_FDB_STATIC, &f->flags) ||
 882			    (test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &f->flags) &&
 883			     !test_bit(BR_FDB_OFFLOADED, &f->flags)) ||
 884			    (vid && f->key.vlan_id != vid))
 885				continue;
 886
 887		if (test_bit(BR_FDB_LOCAL, &f->flags))
 888			fdb_delete_local(br, p, f);
 889		else
 890			fdb_delete(br, f, true);
 891	}
 892	spin_unlock_bh(&br->hash_lock);
 893}
 894
 895#if IS_ENABLED(CONFIG_ATM_LANE)
 896/* Interface used by ATM LANE hook to test
 897 * if an addr is on some other bridge port */
 898int br_fdb_test_addr(struct net_device *dev, unsigned char *addr)
 899{
 900	struct net_bridge_fdb_entry *fdb;
 901	struct net_bridge_port *port;
 902	int ret;
 903
 904	rcu_read_lock();
 905	port = br_port_get_rcu(dev);
 906	if (!port)
 907		ret = 0;
 908	else {
 909		const struct net_bridge_port *dst = NULL;
 910
 911		fdb = br_fdb_find_rcu(port->br, addr, 0);
 912		if (fdb)
 913			dst = READ_ONCE(fdb->dst);
 914
 915		ret = dst && dst->dev != dev &&
 916		      dst->state == BR_STATE_FORWARDING;
 917	}
 918	rcu_read_unlock();
 919
 920	return ret;
 921}
 922#endif /* CONFIG_ATM_LANE */
 923
 924/*
 925 * Fill buffer with forwarding table records in
 926 * the API format.
 927 */
 928int br_fdb_fillbuf(struct net_bridge *br, void *buf,
 929		   unsigned long maxnum, unsigned long skip)
 930{
 931	struct net_bridge_fdb_entry *f;
 932	struct __fdb_entry *fe = buf;
 933	unsigned long delta;
 934	int num = 0;
 935
 936	memset(buf, 0, maxnum*sizeof(struct __fdb_entry));
 937
 938	rcu_read_lock();
 939	hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
 940		if (num >= maxnum)
 941			break;
 942
 943		if (has_expired(br, f))
 944			continue;
 945
 946		/* ignore pseudo entry for local MAC address */
 947		if (!f->dst)
 948			continue;
 949
 950		if (skip) {
 951			--skip;
 952			continue;
 953		}
 954
 955		/* convert from internal format to API */
 956		memcpy(fe->mac_addr, f->key.addr.addr, ETH_ALEN);
 957
 958		/* due to ABI compat need to split into hi/lo */
 959		fe->port_no = f->dst->port_no;
 960		fe->port_hi = f->dst->port_no >> 8;
 961
 962		fe->is_local = test_bit(BR_FDB_LOCAL, &f->flags);
 963		if (!test_bit(BR_FDB_STATIC, &f->flags)) {
 964			delta = jiffies - READ_ONCE(f->updated);
 965			fe->ageing_timer_value =
 966				jiffies_delta_to_clock_t(delta);
 967		}
 968		++fe;
 969		++num;
 970	}
 971	rcu_read_unlock();
 972
 973	return num;
 974}
 975
 976/* Add entry for local address of interface */
 977int br_fdb_add_local(struct net_bridge *br, struct net_bridge_port *source,
 978		     const unsigned char *addr, u16 vid)
 979{
 980	int ret;
 981
 982	spin_lock_bh(&br->hash_lock);
 983	ret = fdb_add_local(br, source, addr, vid);
 984	spin_unlock_bh(&br->hash_lock);
 985	return ret;
 986}
 987
 988/* returns true if the fdb was modified */
 989static bool __fdb_mark_active(struct net_bridge_fdb_entry *fdb)
 990{
 991	return !!(test_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags) &&
 992		  test_and_clear_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags));
 993}
 994
 995void br_fdb_update(struct net_bridge *br, struct net_bridge_port *source,
 996		   const unsigned char *addr, u16 vid, unsigned long flags)
 997{
 998	struct net_bridge_fdb_entry *fdb;
 999
1000	/* some users want to always flood. */
1001	if (hold_time(br) == 0)
1002		return;
1003
1004	fdb = fdb_find_rcu(&br->fdb_hash_tbl, addr, vid);
1005	if (likely(fdb)) {
1006		/* attempt to update an entry for a local interface */
1007		if (unlikely(test_bit(BR_FDB_LOCAL, &fdb->flags))) {
1008			if (net_ratelimit())
1009				br_warn(br, "received packet on %s with own address as source address (addr:%pM, vlan:%u)\n",
1010					source->dev->name, addr, vid);
1011		} else {
1012			unsigned long now = jiffies;
1013			bool fdb_modified = false;
1014
1015			if (now != READ_ONCE(fdb->updated)) {
1016				WRITE_ONCE(fdb->updated, now);
1017				fdb_modified = __fdb_mark_active(fdb);
1018			}
1019
1020			/* fastpath: update of existing entry */
1021			if (unlikely(source != READ_ONCE(fdb->dst) &&
1022				     !test_bit(BR_FDB_STICKY, &fdb->flags))) {
1023				br_switchdev_fdb_notify(br, fdb, RTM_DELNEIGH);
1024				WRITE_ONCE(fdb->dst, source);
1025				fdb_modified = true;
1026				/* Take over HW learned entry */
1027				if (unlikely(test_bit(BR_FDB_ADDED_BY_EXT_LEARN,
1028						      &fdb->flags)))
1029					clear_bit(BR_FDB_ADDED_BY_EXT_LEARN,
1030						  &fdb->flags);
1031				/* Clear locked flag when roaming to an
1032				 * unlocked port.
1033				 */
1034				if (unlikely(test_bit(BR_FDB_LOCKED, &fdb->flags)))
1035					clear_bit(BR_FDB_LOCKED, &fdb->flags);
1036			}
1037
1038			if (unlikely(test_bit(BR_FDB_ADDED_BY_USER, &flags))) {
1039				set_bit(BR_FDB_ADDED_BY_USER, &fdb->flags);
1040				if (test_and_clear_bit(BR_FDB_DYNAMIC_LEARNED,
1041						       &fdb->flags))
1042					atomic_dec(&br->fdb_n_learned);
1043			}
1044			if (unlikely(fdb_modified)) {
1045				trace_br_fdb_update(br, source, addr, vid, flags);
1046				fdb_notify(br, fdb, RTM_NEWNEIGH, true);
1047			}
1048		}
1049	} else {
1050		spin_lock(&br->hash_lock);
1051		fdb = fdb_create(br, source, addr, vid, flags);
1052		if (fdb) {
1053			trace_br_fdb_update(br, source, addr, vid, flags);
1054			fdb_notify(br, fdb, RTM_NEWNEIGH, true);
1055		}
1056		/* else  we lose race and someone else inserts
1057		 * it first, don't bother updating
1058		 */
1059		spin_unlock(&br->hash_lock);
1060	}
1061}
1062
1063/* Dump information about entries, in response to GETNEIGH */
1064int br_fdb_dump(struct sk_buff *skb,
1065		struct netlink_callback *cb,
1066		struct net_device *dev,
1067		struct net_device *filter_dev,
1068		int *idx)
1069{
1070	struct ndo_fdb_dump_context *ctx = (void *)cb->ctx;
1071	struct net_bridge *br = netdev_priv(dev);
1072	struct net_bridge_fdb_entry *f;
1073	int err = 0;
1074
1075	if (!netif_is_bridge_master(dev))
1076		return err;
1077
1078	if (!filter_dev) {
1079		err = ndo_dflt_fdb_dump(skb, cb, dev, NULL, idx);
1080		if (err < 0)
1081			return err;
1082	}
1083
1084	rcu_read_lock();
1085	hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
1086		if (*idx < ctx->fdb_idx)
1087			goto skip;
1088		if (filter_dev && (!f->dst || f->dst->dev != filter_dev)) {
1089			if (filter_dev != dev)
1090				goto skip;
1091			/* !f->dst is a special case for bridge
1092			 * It means the MAC belongs to the bridge
1093			 * Therefore need a little more filtering
1094			 * we only want to dump the !f->dst case
1095			 */
1096			if (f->dst)
1097				goto skip;
1098		}
1099		if (!filter_dev && f->dst)
1100			goto skip;
1101
1102		err = fdb_fill_info(skb, br, f,
1103				    NETLINK_CB(cb->skb).portid,
1104				    cb->nlh->nlmsg_seq,
1105				    RTM_NEWNEIGH,
1106				    NLM_F_MULTI);
1107		if (err < 0)
1108			break;
1109skip:
1110		*idx += 1;
1111	}
1112	rcu_read_unlock();
1113
1114	return err;
1115}
1116
1117int br_fdb_get(struct sk_buff *skb,
1118	       struct nlattr *tb[],
1119	       struct net_device *dev,
1120	       const unsigned char *addr,
1121	       u16 vid, u32 portid, u32 seq,
1122	       struct netlink_ext_ack *extack)
1123{
1124	struct net_bridge *br = netdev_priv(dev);
1125	struct net_bridge_fdb_entry *f;
1126	int err = 0;
1127
1128	rcu_read_lock();
1129	f = br_fdb_find_rcu(br, addr, vid);
1130	if (!f) {
1131		NL_SET_ERR_MSG(extack, "Fdb entry not found");
1132		err = -ENOENT;
1133		goto errout;
1134	}
1135
1136	err = fdb_fill_info(skb, br, f, portid, seq,
1137			    RTM_NEWNEIGH, 0);
1138errout:
1139	rcu_read_unlock();
1140	return err;
1141}
1142
1143/* returns true if the fdb is modified */
1144static bool fdb_handle_notify(struct net_bridge_fdb_entry *fdb, u8 notify)
1145{
1146	bool modified = false;
1147
1148	/* allow to mark an entry as inactive, usually done on creation */
1149	if ((notify & FDB_NOTIFY_INACTIVE_BIT) &&
1150	    !test_and_set_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags))
1151		modified = true;
1152
1153	if ((notify & FDB_NOTIFY_BIT) &&
1154	    !test_and_set_bit(BR_FDB_NOTIFY, &fdb->flags)) {
1155		/* enabled activity tracking */
1156		modified = true;
1157	} else if (!(notify & FDB_NOTIFY_BIT) &&
1158		   test_and_clear_bit(BR_FDB_NOTIFY, &fdb->flags)) {
1159		/* disabled activity tracking, clear notify state */
1160		clear_bit(BR_FDB_NOTIFY_INACTIVE, &fdb->flags);
1161		modified = true;
1162	}
1163
1164	return modified;
1165}
1166
1167/* Update (create or replace) forwarding database entry */
1168static int fdb_add_entry(struct net_bridge *br, struct net_bridge_port *source,
1169			 const u8 *addr, struct ndmsg *ndm, u16 flags, u16 vid,
1170			 struct nlattr *nfea_tb[])
1171{
1172	bool is_sticky = !!(ndm->ndm_flags & NTF_STICKY);
1173	bool refresh = !nfea_tb[NFEA_DONT_REFRESH];
1174	struct net_bridge_fdb_entry *fdb;
1175	u16 state = ndm->ndm_state;
1176	bool modified = false;
1177	u8 notify = 0;
1178
1179	/* If the port cannot learn allow only local and static entries */
1180	if (source && !(state & NUD_PERMANENT) && !(state & NUD_NOARP) &&
1181	    !(source->state == BR_STATE_LEARNING ||
1182	      source->state == BR_STATE_FORWARDING))
1183		return -EPERM;
1184
1185	if (!source && !(state & NUD_PERMANENT)) {
1186		pr_info("bridge: RTM_NEWNEIGH %s without NUD_PERMANENT\n",
1187			br->dev->name);
1188		return -EINVAL;
1189	}
1190
1191	if (is_sticky && (state & NUD_PERMANENT))
1192		return -EINVAL;
1193
1194	if (nfea_tb[NFEA_ACTIVITY_NOTIFY]) {
1195		notify = nla_get_u8(nfea_tb[NFEA_ACTIVITY_NOTIFY]);
1196		if ((notify & ~BR_FDB_NOTIFY_SETTABLE_BITS) ||
1197		    (notify & BR_FDB_NOTIFY_SETTABLE_BITS) == FDB_NOTIFY_INACTIVE_BIT)
1198			return -EINVAL;
1199	}
1200
1201	fdb = br_fdb_find(br, addr, vid);
1202	if (fdb == NULL) {
1203		if (!(flags & NLM_F_CREATE))
1204			return -ENOENT;
1205
1206		fdb = fdb_create(br, source, addr, vid,
1207				 BIT(BR_FDB_ADDED_BY_USER));
1208		if (!fdb)
1209			return -ENOMEM;
1210
1211		modified = true;
1212	} else {
1213		if (flags & NLM_F_EXCL)
1214			return -EEXIST;
1215
1216		if (READ_ONCE(fdb->dst) != source) {
1217			WRITE_ONCE(fdb->dst, source);
1218			modified = true;
1219		}
1220
1221		set_bit(BR_FDB_ADDED_BY_USER, &fdb->flags);
1222		if (test_and_clear_bit(BR_FDB_DYNAMIC_LEARNED, &fdb->flags))
1223			atomic_dec(&br->fdb_n_learned);
1224	}
1225
1226	if (fdb_to_nud(br, fdb) != state) {
1227		if (state & NUD_PERMANENT) {
1228			set_bit(BR_FDB_LOCAL, &fdb->flags);
1229			if (!test_and_set_bit(BR_FDB_STATIC, &fdb->flags))
1230				fdb_add_hw_addr(br, addr);
1231		} else if (state & NUD_NOARP) {
1232			clear_bit(BR_FDB_LOCAL, &fdb->flags);
1233			if (!test_and_set_bit(BR_FDB_STATIC, &fdb->flags))
1234				fdb_add_hw_addr(br, addr);
1235		} else {
1236			clear_bit(BR_FDB_LOCAL, &fdb->flags);
1237			if (test_and_clear_bit(BR_FDB_STATIC, &fdb->flags))
1238				fdb_del_hw_addr(br, addr);
1239		}
1240
1241		modified = true;
1242	}
1243
1244	if (is_sticky != test_bit(BR_FDB_STICKY, &fdb->flags)) {
1245		change_bit(BR_FDB_STICKY, &fdb->flags);
1246		modified = true;
1247	}
1248
1249	if (test_and_clear_bit(BR_FDB_LOCKED, &fdb->flags))
1250		modified = true;
1251
1252	if (fdb_handle_notify(fdb, notify))
1253		modified = true;
1254
1255	WRITE_ONCE(fdb->used, jiffies);
1256	if (modified) {
1257		if (refresh)
1258			WRITE_ONCE(fdb->updated, jiffies);
1259		fdb_notify(br, fdb, RTM_NEWNEIGH, true);
1260	}
1261
1262	return 0;
1263}
1264
1265static int __br_fdb_add(struct ndmsg *ndm, struct net_bridge *br,
1266			struct net_bridge_port *p, const unsigned char *addr,
1267			u16 nlh_flags, u16 vid, struct nlattr *nfea_tb[],
1268			bool *notified, struct netlink_ext_ack *extack)
1269{
1270	int err = 0;
1271
1272	if (ndm->ndm_flags & NTF_USE) {
1273		if (!p) {
1274			pr_info("bridge: RTM_NEWNEIGH %s with NTF_USE is not supported\n",
1275				br->dev->name);
1276			return -EINVAL;
1277		}
1278		if (!nbp_state_should_learn(p))
1279			return 0;
1280
1281		local_bh_disable();
1282		rcu_read_lock();
1283		br_fdb_update(br, p, addr, vid, BIT(BR_FDB_ADDED_BY_USER));
1284		rcu_read_unlock();
1285		local_bh_enable();
1286	} else if (ndm->ndm_flags & NTF_EXT_LEARNED) {
1287		if (!p && !(ndm->ndm_state & NUD_PERMANENT)) {
1288			NL_SET_ERR_MSG_MOD(extack,
1289					   "FDB entry towards bridge must be permanent");
1290			return -EINVAL;
1291		}
1292		err = br_fdb_external_learn_add(br, p, addr, vid, false, true);
1293	} else {
1294		spin_lock_bh(&br->hash_lock);
1295		err = fdb_add_entry(br, p, addr, ndm, nlh_flags, vid, nfea_tb);
1296		spin_unlock_bh(&br->hash_lock);
1297	}
1298
1299	if (!err)
1300		*notified = true;
1301	return err;
1302}
1303
1304static const struct nla_policy br_nda_fdb_pol[NFEA_MAX + 1] = {
1305	[NFEA_ACTIVITY_NOTIFY]	= { .type = NLA_U8 },
1306	[NFEA_DONT_REFRESH]	= { .type = NLA_FLAG },
1307};
1308
1309/* Add new permanent fdb entry with RTM_NEWNEIGH */
1310int br_fdb_add(struct ndmsg *ndm, struct nlattr *tb[],
1311	       struct net_device *dev,
1312	       const unsigned char *addr, u16 vid, u16 nlh_flags,
1313	       bool *notified, struct netlink_ext_ack *extack)
1314{
1315	struct nlattr *nfea_tb[NFEA_MAX + 1], *attr;
1316	struct net_bridge_vlan_group *vg;
1317	struct net_bridge_port *p = NULL;
1318	struct net_bridge_vlan *v;
1319	struct net_bridge *br = NULL;
1320	u32 ext_flags = 0;
1321	int err = 0;
1322
1323	trace_br_fdb_add(ndm, dev, addr, vid, nlh_flags);
1324
1325	if (!(ndm->ndm_state & (NUD_PERMANENT|NUD_NOARP|NUD_REACHABLE))) {
1326		pr_info("bridge: RTM_NEWNEIGH with invalid state %#x\n", ndm->ndm_state);
1327		return -EINVAL;
1328	}
1329
1330	if (is_zero_ether_addr(addr)) {
1331		pr_info("bridge: RTM_NEWNEIGH with invalid ether address\n");
1332		return -EINVAL;
1333	}
1334
1335	if (netif_is_bridge_master(dev)) {
1336		br = netdev_priv(dev);
1337		vg = br_vlan_group(br);
1338	} else {
1339		p = br_port_get_rtnl(dev);
1340		if (!p) {
1341			pr_info("bridge: RTM_NEWNEIGH %s not a bridge port\n",
1342				dev->name);
1343			return -EINVAL;
1344		}
1345		br = p->br;
1346		vg = nbp_vlan_group(p);
1347	}
1348
1349	if (tb[NDA_FLAGS_EXT])
1350		ext_flags = nla_get_u32(tb[NDA_FLAGS_EXT]);
1351
1352	if (ext_flags & NTF_EXT_LOCKED) {
1353		NL_SET_ERR_MSG_MOD(extack, "Cannot add FDB entry with \"locked\" flag set");
1354		return -EINVAL;
1355	}
1356
1357	if (tb[NDA_FDB_EXT_ATTRS]) {
1358		attr = tb[NDA_FDB_EXT_ATTRS];
1359		err = nla_parse_nested(nfea_tb, NFEA_MAX, attr,
1360				       br_nda_fdb_pol, extack);
1361		if (err)
1362			return err;
1363	} else {
1364		memset(nfea_tb, 0, sizeof(struct nlattr *) * (NFEA_MAX + 1));
1365	}
1366
1367	if (vid) {
1368		v = br_vlan_find(vg, vid);
1369		if (!v || !br_vlan_should_use(v)) {
1370			pr_info("bridge: RTM_NEWNEIGH with unconfigured vlan %d on %s\n", vid, dev->name);
1371			return -EINVAL;
1372		}
1373
1374		/* VID was specified, so use it. */
1375		err = __br_fdb_add(ndm, br, p, addr, nlh_flags, vid, nfea_tb,
1376				   notified, extack);
1377	} else {
1378		err = __br_fdb_add(ndm, br, p, addr, nlh_flags, 0, nfea_tb,
1379				   notified, extack);
1380		if (err || !vg || !vg->num_vlans)
1381			goto out;
1382
1383		/* We have vlans configured on this port and user didn't
1384		 * specify a VLAN.  To be nice, add/update entry for every
1385		 * vlan on this port.
1386		 */
1387		list_for_each_entry(v, &vg->vlan_list, vlist) {
1388			if (!br_vlan_should_use(v))
1389				continue;
1390			err = __br_fdb_add(ndm, br, p, addr, nlh_flags, v->vid,
1391					   nfea_tb, notified, extack);
1392			if (err)
1393				goto out;
1394		}
1395	}
1396
1397out:
1398	return err;
1399}
1400
1401static int fdb_delete_by_addr_and_port(struct net_bridge *br,
1402				       const struct net_bridge_port *p,
1403				       const u8 *addr, u16 vlan, bool *notified)
1404{
1405	struct net_bridge_fdb_entry *fdb;
1406
1407	fdb = br_fdb_find(br, addr, vlan);
1408	if (!fdb || READ_ONCE(fdb->dst) != p)
1409		return -ENOENT;
1410
1411	fdb_delete(br, fdb, true);
1412	*notified = true;
1413
1414	return 0;
1415}
1416
1417static int __br_fdb_delete(struct net_bridge *br,
1418			   const struct net_bridge_port *p,
1419			   const unsigned char *addr, u16 vid, bool *notified)
1420{
1421	int err;
1422
1423	spin_lock_bh(&br->hash_lock);
1424	err = fdb_delete_by_addr_and_port(br, p, addr, vid, notified);
1425	spin_unlock_bh(&br->hash_lock);
1426
1427	return err;
1428}
1429
1430/* Remove neighbor entry with RTM_DELNEIGH */
1431int br_fdb_delete(struct ndmsg *ndm, struct nlattr *tb[],
1432		  struct net_device *dev,
1433		  const unsigned char *addr, u16 vid, bool *notified,
1434		  struct netlink_ext_ack *extack)
1435{
1436	struct net_bridge_vlan_group *vg;
1437	struct net_bridge_port *p = NULL;
1438	struct net_bridge *br;
1439	int err;
1440
1441	if (netif_is_bridge_master(dev)) {
1442		br = netdev_priv(dev);
1443		vg = br_vlan_group(br);
1444	} else {
1445		p = br_port_get_rtnl(dev);
1446		if (!p) {
1447			pr_info("bridge: RTM_DELNEIGH %s not a bridge port\n",
1448				dev->name);
1449			return -EINVAL;
1450		}
1451		vg = nbp_vlan_group(p);
1452		br = p->br;
1453	}
1454
1455	if (vid) {
1456		err = __br_fdb_delete(br, p, addr, vid, notified);
1457	} else {
1458		struct net_bridge_vlan *v;
1459
1460		err = -ENOENT;
1461		err &= __br_fdb_delete(br, p, addr, 0, notified);
1462		if (!vg || !vg->num_vlans)
1463			return err;
1464
1465		list_for_each_entry(v, &vg->vlan_list, vlist) {
1466			if (!br_vlan_should_use(v))
1467				continue;
1468			err &= __br_fdb_delete(br, p, addr, v->vid, notified);
1469		}
1470	}
1471
1472	return err;
1473}
1474
1475int br_fdb_sync_static(struct net_bridge *br, struct net_bridge_port *p)
1476{
1477	struct net_bridge_fdb_entry *f, *tmp;
1478	int err = 0;
1479
1480	ASSERT_RTNL();
1481
1482	/* the key here is that static entries change only under rtnl */
1483	rcu_read_lock();
1484	hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
1485		/* We only care for static entries */
1486		if (!test_bit(BR_FDB_STATIC, &f->flags))
1487			continue;
1488		err = dev_uc_add(p->dev, f->key.addr.addr);
1489		if (err)
1490			goto rollback;
1491	}
1492done:
1493	rcu_read_unlock();
1494
1495	return err;
1496
1497rollback:
1498	hlist_for_each_entry_rcu(tmp, &br->fdb_list, fdb_node) {
1499		/* We only care for static entries */
1500		if (!test_bit(BR_FDB_STATIC, &tmp->flags))
1501			continue;
1502		if (tmp == f)
1503			break;
1504		dev_uc_del(p->dev, tmp->key.addr.addr);
1505	}
1506
1507	goto done;
1508}
1509
1510void br_fdb_unsync_static(struct net_bridge *br, struct net_bridge_port *p)
1511{
1512	struct net_bridge_fdb_entry *f;
1513
1514	ASSERT_RTNL();
1515
1516	rcu_read_lock();
1517	hlist_for_each_entry_rcu(f, &br->fdb_list, fdb_node) {
1518		/* We only care for static entries */
1519		if (!test_bit(BR_FDB_STATIC, &f->flags))
1520			continue;
1521
1522		dev_uc_del(p->dev, f->key.addr.addr);
1523	}
1524	rcu_read_unlock();
1525}
1526
1527int br_fdb_external_learn_add(struct net_bridge *br, struct net_bridge_port *p,
1528			      const unsigned char *addr, u16 vid, bool locked,
1529			      bool swdev_notify)
1530{
1531	struct net_bridge_fdb_entry *fdb;
1532	bool modified = false;
1533	int err = 0;
1534
1535	trace_br_fdb_external_learn_add(br, p, addr, vid);
1536
1537	if (locked && (!p || !(p->flags & BR_PORT_MAB)))
1538		return -EINVAL;
1539
1540	spin_lock_bh(&br->hash_lock);
1541
1542	fdb = br_fdb_find(br, addr, vid);
1543	if (!fdb) {
1544		unsigned long flags = BIT(BR_FDB_ADDED_BY_EXT_LEARN);
1545
1546		if (swdev_notify)
1547			flags |= BIT(BR_FDB_ADDED_BY_USER);
1548
1549		if (!p)
1550			flags |= BIT(BR_FDB_LOCAL);
1551
1552		if (locked)
1553			flags |= BIT(BR_FDB_LOCKED);
1554
1555		fdb = fdb_create(br, p, addr, vid, flags);
1556		if (!fdb) {
1557			err = -ENOMEM;
1558			goto err_unlock;
1559		}
1560		fdb_notify(br, fdb, RTM_NEWNEIGH, swdev_notify);
1561	} else {
1562		if (locked &&
1563		    (!test_bit(BR_FDB_LOCKED, &fdb->flags) ||
1564		     READ_ONCE(fdb->dst) != p)) {
1565			err = -EINVAL;
1566			goto err_unlock;
1567		}
1568
1569		WRITE_ONCE(fdb->updated, jiffies);
1570
1571		if (READ_ONCE(fdb->dst) != p) {
1572			WRITE_ONCE(fdb->dst, p);
1573			modified = true;
1574		}
1575
1576		if (test_and_set_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags)) {
1577			/* Refresh entry */
1578			WRITE_ONCE(fdb->used, jiffies);
1579		} else {
1580			modified = true;
1581		}
1582
1583		if (locked != test_bit(BR_FDB_LOCKED, &fdb->flags)) {
1584			change_bit(BR_FDB_LOCKED, &fdb->flags);
1585			modified = true;
1586		}
1587
1588		if (swdev_notify)
1589			set_bit(BR_FDB_ADDED_BY_USER, &fdb->flags);
1590
1591		if (!p)
1592			set_bit(BR_FDB_LOCAL, &fdb->flags);
1593
1594		if ((swdev_notify || !p) &&
1595		    test_and_clear_bit(BR_FDB_DYNAMIC_LEARNED, &fdb->flags))
1596			atomic_dec(&br->fdb_n_learned);
1597
1598		if (modified)
1599			fdb_notify(br, fdb, RTM_NEWNEIGH, swdev_notify);
1600	}
1601
1602err_unlock:
1603	spin_unlock_bh(&br->hash_lock);
1604
1605	return err;
1606}
1607
1608int br_fdb_external_learn_del(struct net_bridge *br, struct net_bridge_port *p,
1609			      const unsigned char *addr, u16 vid,
1610			      bool swdev_notify)
1611{
1612	struct net_bridge_fdb_entry *fdb;
1613	int err = 0;
1614
1615	spin_lock_bh(&br->hash_lock);
1616
1617	fdb = br_fdb_find(br, addr, vid);
1618	if (fdb && test_bit(BR_FDB_ADDED_BY_EXT_LEARN, &fdb->flags))
1619		fdb_delete(br, fdb, swdev_notify);
1620	else
1621		err = -ENOENT;
1622
1623	spin_unlock_bh(&br->hash_lock);
1624
1625	return err;
1626}
1627
1628void br_fdb_offloaded_set(struct net_bridge *br, struct net_bridge_port *p,
1629			  const unsigned char *addr, u16 vid, bool offloaded)
1630{
1631	struct net_bridge_fdb_entry *fdb;
1632
1633	spin_lock_bh(&br->hash_lock);
1634
1635	fdb = br_fdb_find(br, addr, vid);
1636	if (fdb && offloaded != test_bit(BR_FDB_OFFLOADED, &fdb->flags))
1637		change_bit(BR_FDB_OFFLOADED, &fdb->flags);
1638
1639	spin_unlock_bh(&br->hash_lock);
1640}
1641
1642void br_fdb_clear_offload(const struct net_device *dev, u16 vid)
1643{
1644	struct net_bridge_fdb_entry *f;
1645	struct net_bridge_port *p;
1646
1647	ASSERT_RTNL();
1648
1649	p = br_port_get_rtnl(dev);
1650	if (!p)
1651		return;
1652
1653	spin_lock_bh(&p->br->hash_lock);
1654	hlist_for_each_entry(f, &p->br->fdb_list, fdb_node) {
1655		if (f->dst == p && f->key.vlan_id == vid)
1656			clear_bit(BR_FDB_OFFLOADED, &f->flags);
1657	}
1658	spin_unlock_bh(&p->br->hash_lock);
1659}
1660EXPORT_SYMBOL_GPL(br_fdb_clear_offload);