mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-26 19:00:25 +00:00
![Taehee Yoo](/assets/img/avatar_default.png)
This patch is to add a new variable 'nested_level' into the net_device
structure.
This variable will be used as a parameter of spin_lock_nested() of
dev->addr_list_lock.
netif_addr_lock() can be called recursively so spin_lock_nested() is
used instead of spin_lock() and dev->lower_level is used as a parameter
of spin_lock_nested().
But, dev->lower_level value can be updated while it is being used.
So, lockdep would warn a possible deadlock scenario.
When a stacked interface is deleted, netif_{uc | mc}_sync() is
called recursively.
So, spin_lock_nested() is called recursively too.
At this moment, the dev->lower_level variable is used as a parameter of it.
dev->lower_level value is updated when interfaces are being unlinked/linked
immediately.
Thus, After unlinking, dev->lower_level shouldn't be a parameter of
spin_lock_nested().
A (macvlan)
|
B (vlan)
|
C (bridge)
|
D (macvlan)
|
E (vlan)
|
F (bridge)
A->lower_level : 6
B->lower_level : 5
C->lower_level : 4
D->lower_level : 3
E->lower_level : 2
F->lower_level : 1
When an interface 'A' is removed, it releases resources.
At this moment, netif_addr_lock() would be called.
Then, netdev_upper_dev_unlink() is called recursively.
Then dev->lower_level is updated.
There is no problem.
But, when the bridge module is removed, 'C' and 'F' interfaces
are removed at once.
If 'F' is removed first, a lower_level value is like below.
A->lower_level : 5
B->lower_level : 4
C->lower_level : 3
D->lower_level : 2
E->lower_level : 1
F->lower_level : 1
Then, 'C' is removed. at this moment, netif_addr_lock() is called
recursively.
The ordering is like this.
C(3)->D(2)->E(1)->F(1)
At this moment, the lower_level value of 'E' and 'F' are the same.
So, lockdep warns a possible deadlock scenario.
In order to avoid this problem, a new variable 'nested_level' is added.
This value is the same as dev->lower_level - 1.
But this value is updated in rtnl_unlock().
So, this variable can be used as a parameter of spin_lock_nested() safely
in the rtnl context.
Test commands:
ip link add br0 type bridge vlan_filtering 1
ip link add vlan1 link br0 type vlan id 10
ip link add macvlan2 link vlan1 type macvlan
ip link add br3 type bridge vlan_filtering 1
ip link set macvlan2 master br3
ip link add vlan4 link br3 type vlan id 10
ip link add macvlan5 link vlan4 type macvlan
ip link add br6 type bridge vlan_filtering 1
ip link set macvlan5 master br6
ip link add vlan7 link br6 type vlan id 10
ip link add macvlan8 link vlan7 type macvlan
ip link set br0 up
ip link set vlan1 up
ip link set macvlan2 up
ip link set br3 up
ip link set vlan4 up
ip link set macvlan5 up
ip link set br6 up
ip link set vlan7 up
ip link set macvlan8 up
modprobe -rv bridge
Splat looks like:
[ 36.057436][ T744] WARNING: possible recursive locking detected
[ 36.058848][ T744] 5.9.0-rc6+ #728 Not tainted
[ 36.059959][ T744] --------------------------------------------
[ 36.061391][ T744] ip/744 is trying to acquire lock:
[ 36.062590][ T744] ffff8c4767509280 (&vlan_netdev_addr_lock_key){+...}-{2:2}, at: dev_set_rx_mode+0x19/0x30
[ 36.064922][ T744]
[ 36.064922][ T744] but task is already holding lock:
[ 36.066626][ T744] ffff8c4767769280 (&vlan_netdev_addr_lock_key){+...}-{2:2}, at: dev_uc_add+0x1e/0x60
[ 36.068851][ T744]
[ 36.068851][ T744] other info that might help us debug this:
[ 36.070731][ T744] Possible unsafe locking scenario:
[ 36.070731][ T744]
[ 36.072497][ T744] CPU0
[ 36.073238][ T744] ----
[ 36.074007][ T744] lock(&vlan_netdev_addr_lock_key);
[ 36.075290][ T744] lock(&vlan_netdev_addr_lock_key);
[ 36.076590][ T744]
[ 36.076590][ T744] *** DEADLOCK ***
[ 36.076590][ T744]
[ 36.078515][ T744] May be due to missing lock nesting notation
[ 36.078515][ T744]
[ 36.080491][ T744] 3 locks held by ip/744:
[ 36.081471][ T744] #0: ffffffff98571df0 (rtnl_mutex){+.+.}-{3:3}, at: rtnetlink_rcv_msg+0x236/0x490
[ 36.083614][ T744] #1: ffff8c4767769280 (&vlan_netdev_addr_lock_key){+...}-{2:2}, at: dev_uc_add+0x1e/0x60
[ 36.085942][ T744] #2: ffff8c476c8da280 (&bridge_netdev_addr_lock_key/4){+...}-{2:2}, at: dev_uc_sync+0x39/0x80
[ 36.088400][ T744]
[ 36.088400][ T744] stack backtrace:
[ 36.089772][ T744] CPU: 6 PID: 744 Comm: ip Not tainted 5.9.0-rc6+ #728
[ 36.091364][ T744] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.10.2-1ubuntu1 04/01/2014
[ 36.093630][ T744] Call Trace:
[ 36.094416][ T744] dump_stack+0x77/0x9b
[ 36.095385][ T744] __lock_acquire+0xbc3/0x1f40
[ 36.096522][ T744] lock_acquire+0xb4/0x3b0
[ 36.097540][ T744] ? dev_set_rx_mode+0x19/0x30
[ 36.098657][ T744] ? rtmsg_ifinfo+0x1f/0x30
[ 36.099711][ T744] ? __dev_notify_flags+0xa5/0xf0
[ 36.100874][ T744] ? rtnl_is_locked+0x11/0x20
[ 36.101967][ T744] ? __dev_set_promiscuity+0x7b/0x1a0
[ 36.103230][ T744] _raw_spin_lock_bh+0x38/0x70
[ 36.104348][ T744] ? dev_set_rx_mode+0x19/0x30
[ 36.105461][ T744] dev_set_rx_mode+0x19/0x30
[ 36.106532][ T744] dev_set_promiscuity+0x36/0x50
[ 36.107692][ T744] __dev_set_promiscuity+0x123/0x1a0
[ 36.108929][ T744] dev_set_promiscuity+0x1e/0x50
[ 36.110093][ T744] br_port_set_promisc+0x1f/0x40 [bridge]
[ 36.111415][ T744] br_manage_promisc+0x8b/0xe0 [bridge]
[ 36.112728][ T744] __dev_set_promiscuity+0x123/0x1a0
[ 36.113967][ T744] ? __hw_addr_sync_one+0x23/0x50
[ 36.115135][ T744] __dev_set_rx_mode+0x68/0x90
[ 36.116249][ T744] dev_uc_sync+0x70/0x80
[ 36.117244][ T744] dev_uc_add+0x50/0x60
[ 36.118223][ T744] macvlan_open+0x18e/0x1f0 [macvlan]
[ 36.119470][ T744] __dev_open+0xd6/0x170
[ 36.120470][ T744] __dev_change_flags+0x181/0x1d0
[ 36.121644][ T744] dev_change_flags+0x23/0x60
[ 36.122741][ T744] do_setlink+0x30a/0x11e0
[ 36.123778][ T744] ? __lock_acquire+0x92c/0x1f40
[ 36.124929][ T744] ? __nla_validate_parse.part.6+0x45/0x8e0
[ 36.126309][ T744] ? __lock_acquire+0x92c/0x1f40
[ 36.127457][ T744] __rtnl_newlink+0x546/0x8e0
[ 36.128560][ T744] ? lock_acquire+0xb4/0x3b0
[ 36.129623][ T744] ? deactivate_slab.isra.85+0x6a1/0x850
[ 36.130946][ T744] ? __lock_acquire+0x92c/0x1f40
[ 36.132102][ T744] ? lock_acquire+0xb4/0x3b0
[ 36.133176][ T744] ? is_bpf_text_address+0x5/0xe0
[ 36.134364][ T744] ? rtnl_newlink+0x2e/0x70
[ 36.135445][ T744] ? rcu_read_lock_sched_held+0x32/0x60
[ 36.136771][ T744] ? kmem_cache_alloc_trace+0x2d8/0x380
[ 36.138070][ T744] ? rtnl_newlink+0x2e/0x70
[ 36.139164][ T744] rtnl_newlink+0x47/0x70
[ ... ]
Fixes: 845e0ebb44
("net: change addr_list_lock back to static key")
Signed-off-by: Taehee Yoo <ap420073@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
957 lines
24 KiB
C
957 lines
24 KiB
C
// SPDX-License-Identifier: GPL-2.0-or-later
|
|
/*
|
|
* net/core/dev_addr_lists.c - Functions for handling net device lists
|
|
* Copyright (c) 2010 Jiri Pirko <jpirko@redhat.com>
|
|
*
|
|
* This file contains functions for working with unicast, multicast and device
|
|
* addresses lists.
|
|
*/
|
|
|
|
#include <linux/netdevice.h>
|
|
#include <linux/rtnetlink.h>
|
|
#include <linux/export.h>
|
|
#include <linux/list.h>
|
|
|
|
/*
|
|
* General list handling functions
|
|
*/
|
|
|
|
static int __hw_addr_create_ex(struct netdev_hw_addr_list *list,
|
|
const unsigned char *addr, int addr_len,
|
|
unsigned char addr_type, bool global,
|
|
bool sync)
|
|
{
|
|
struct netdev_hw_addr *ha;
|
|
int alloc_size;
|
|
|
|
alloc_size = sizeof(*ha);
|
|
if (alloc_size < L1_CACHE_BYTES)
|
|
alloc_size = L1_CACHE_BYTES;
|
|
ha = kmalloc(alloc_size, GFP_ATOMIC);
|
|
if (!ha)
|
|
return -ENOMEM;
|
|
memcpy(ha->addr, addr, addr_len);
|
|
ha->type = addr_type;
|
|
ha->refcount = 1;
|
|
ha->global_use = global;
|
|
ha->synced = sync ? 1 : 0;
|
|
ha->sync_cnt = 0;
|
|
list_add_tail_rcu(&ha->list, &list->list);
|
|
list->count++;
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int __hw_addr_add_ex(struct netdev_hw_addr_list *list,
|
|
const unsigned char *addr, int addr_len,
|
|
unsigned char addr_type, bool global, bool sync,
|
|
int sync_count)
|
|
{
|
|
struct netdev_hw_addr *ha;
|
|
|
|
if (addr_len > MAX_ADDR_LEN)
|
|
return -EINVAL;
|
|
|
|
list_for_each_entry(ha, &list->list, list) {
|
|
if (ha->type == addr_type &&
|
|
!memcmp(ha->addr, addr, addr_len)) {
|
|
if (global) {
|
|
/* check if addr is already used as global */
|
|
if (ha->global_use)
|
|
return 0;
|
|
else
|
|
ha->global_use = true;
|
|
}
|
|
if (sync) {
|
|
if (ha->synced && sync_count)
|
|
return -EEXIST;
|
|
else
|
|
ha->synced++;
|
|
}
|
|
ha->refcount++;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return __hw_addr_create_ex(list, addr, addr_len, addr_type, global,
|
|
sync);
|
|
}
|
|
|
|
static int __hw_addr_add(struct netdev_hw_addr_list *list,
|
|
const unsigned char *addr, int addr_len,
|
|
unsigned char addr_type)
|
|
{
|
|
return __hw_addr_add_ex(list, addr, addr_len, addr_type, false, false,
|
|
0);
|
|
}
|
|
|
|
static int __hw_addr_del_entry(struct netdev_hw_addr_list *list,
|
|
struct netdev_hw_addr *ha, bool global,
|
|
bool sync)
|
|
{
|
|
if (global && !ha->global_use)
|
|
return -ENOENT;
|
|
|
|
if (sync && !ha->synced)
|
|
return -ENOENT;
|
|
|
|
if (global)
|
|
ha->global_use = false;
|
|
|
|
if (sync)
|
|
ha->synced--;
|
|
|
|
if (--ha->refcount)
|
|
return 0;
|
|
list_del_rcu(&ha->list);
|
|
kfree_rcu(ha, rcu_head);
|
|
list->count--;
|
|
return 0;
|
|
}
|
|
|
|
static int __hw_addr_del_ex(struct netdev_hw_addr_list *list,
|
|
const unsigned char *addr, int addr_len,
|
|
unsigned char addr_type, bool global, bool sync)
|
|
{
|
|
struct netdev_hw_addr *ha;
|
|
|
|
list_for_each_entry(ha, &list->list, list) {
|
|
if (!memcmp(ha->addr, addr, addr_len) &&
|
|
(ha->type == addr_type || !addr_type))
|
|
return __hw_addr_del_entry(list, ha, global, sync);
|
|
}
|
|
return -ENOENT;
|
|
}
|
|
|
|
static int __hw_addr_del(struct netdev_hw_addr_list *list,
|
|
const unsigned char *addr, int addr_len,
|
|
unsigned char addr_type)
|
|
{
|
|
return __hw_addr_del_ex(list, addr, addr_len, addr_type, false, false);
|
|
}
|
|
|
|
static int __hw_addr_sync_one(struct netdev_hw_addr_list *to_list,
|
|
struct netdev_hw_addr *ha,
|
|
int addr_len)
|
|
{
|
|
int err;
|
|
|
|
err = __hw_addr_add_ex(to_list, ha->addr, addr_len, ha->type,
|
|
false, true, ha->sync_cnt);
|
|
if (err && err != -EEXIST)
|
|
return err;
|
|
|
|
if (!err) {
|
|
ha->sync_cnt++;
|
|
ha->refcount++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void __hw_addr_unsync_one(struct netdev_hw_addr_list *to_list,
|
|
struct netdev_hw_addr_list *from_list,
|
|
struct netdev_hw_addr *ha,
|
|
int addr_len)
|
|
{
|
|
int err;
|
|
|
|
err = __hw_addr_del_ex(to_list, ha->addr, addr_len, ha->type,
|
|
false, true);
|
|
if (err)
|
|
return;
|
|
ha->sync_cnt--;
|
|
/* address on from list is not marked synced */
|
|
__hw_addr_del_entry(from_list, ha, false, false);
|
|
}
|
|
|
|
static int __hw_addr_sync_multiple(struct netdev_hw_addr_list *to_list,
|
|
struct netdev_hw_addr_list *from_list,
|
|
int addr_len)
|
|
{
|
|
int err = 0;
|
|
struct netdev_hw_addr *ha, *tmp;
|
|
|
|
list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
|
|
if (ha->sync_cnt == ha->refcount) {
|
|
__hw_addr_unsync_one(to_list, from_list, ha, addr_len);
|
|
} else {
|
|
err = __hw_addr_sync_one(to_list, ha, addr_len);
|
|
if (err)
|
|
break;
|
|
}
|
|
}
|
|
return err;
|
|
}
|
|
|
|
/* This function only works where there is a strict 1-1 relationship
|
|
* between source and destionation of they synch. If you ever need to
|
|
* sync addresses to more then 1 destination, you need to use
|
|
* __hw_addr_sync_multiple().
|
|
*/
|
|
int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
|
|
struct netdev_hw_addr_list *from_list,
|
|
int addr_len)
|
|
{
|
|
int err = 0;
|
|
struct netdev_hw_addr *ha, *tmp;
|
|
|
|
list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
|
|
if (!ha->sync_cnt) {
|
|
err = __hw_addr_sync_one(to_list, ha, addr_len);
|
|
if (err)
|
|
break;
|
|
} else if (ha->refcount == 1)
|
|
__hw_addr_unsync_one(to_list, from_list, ha, addr_len);
|
|
}
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(__hw_addr_sync);
|
|
|
|
void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
|
|
struct netdev_hw_addr_list *from_list,
|
|
int addr_len)
|
|
{
|
|
struct netdev_hw_addr *ha, *tmp;
|
|
|
|
list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
|
|
if (ha->sync_cnt)
|
|
__hw_addr_unsync_one(to_list, from_list, ha, addr_len);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(__hw_addr_unsync);
|
|
|
|
/**
|
|
* __hw_addr_sync_dev - Synchonize device's multicast list
|
|
* @list: address list to syncronize
|
|
* @dev: device to sync
|
|
* @sync: function to call if address should be added
|
|
* @unsync: function to call if address should be removed
|
|
*
|
|
* This funciton is intended to be called from the ndo_set_rx_mode
|
|
* function of devices that require explicit address add/remove
|
|
* notifications. The unsync function may be NULL in which case
|
|
* the addresses requiring removal will simply be removed without
|
|
* any notification to the device.
|
|
**/
|
|
int __hw_addr_sync_dev(struct netdev_hw_addr_list *list,
|
|
struct net_device *dev,
|
|
int (*sync)(struct net_device *, const unsigned char *),
|
|
int (*unsync)(struct net_device *,
|
|
const unsigned char *))
|
|
{
|
|
struct netdev_hw_addr *ha, *tmp;
|
|
int err;
|
|
|
|
/* first go through and flush out any stale entries */
|
|
list_for_each_entry_safe(ha, tmp, &list->list, list) {
|
|
if (!ha->sync_cnt || ha->refcount != 1)
|
|
continue;
|
|
|
|
/* if unsync is defined and fails defer unsyncing address */
|
|
if (unsync && unsync(dev, ha->addr))
|
|
continue;
|
|
|
|
ha->sync_cnt--;
|
|
__hw_addr_del_entry(list, ha, false, false);
|
|
}
|
|
|
|
/* go through and sync new entries to the list */
|
|
list_for_each_entry_safe(ha, tmp, &list->list, list) {
|
|
if (ha->sync_cnt)
|
|
continue;
|
|
|
|
err = sync(dev, ha->addr);
|
|
if (err)
|
|
return err;
|
|
|
|
ha->sync_cnt++;
|
|
ha->refcount++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(__hw_addr_sync_dev);
|
|
|
|
/**
|
|
* __hw_addr_ref_sync_dev - Synchronize device's multicast address list taking
|
|
* into account references
|
|
* @list: address list to synchronize
|
|
* @dev: device to sync
|
|
* @sync: function to call if address or reference on it should be added
|
|
* @unsync: function to call if address or some reference on it should removed
|
|
*
|
|
* This function is intended to be called from the ndo_set_rx_mode
|
|
* function of devices that require explicit address or references on it
|
|
* add/remove notifications. The unsync function may be NULL in which case
|
|
* the addresses or references on it requiring removal will simply be
|
|
* removed without any notification to the device. That is responsibility of
|
|
* the driver to identify and distribute address or references on it between
|
|
* internal address tables.
|
|
**/
|
|
int __hw_addr_ref_sync_dev(struct netdev_hw_addr_list *list,
|
|
struct net_device *dev,
|
|
int (*sync)(struct net_device *,
|
|
const unsigned char *, int),
|
|
int (*unsync)(struct net_device *,
|
|
const unsigned char *, int))
|
|
{
|
|
struct netdev_hw_addr *ha, *tmp;
|
|
int err, ref_cnt;
|
|
|
|
/* first go through and flush out any unsynced/stale entries */
|
|
list_for_each_entry_safe(ha, tmp, &list->list, list) {
|
|
/* sync if address is not used */
|
|
if ((ha->sync_cnt << 1) <= ha->refcount)
|
|
continue;
|
|
|
|
/* if fails defer unsyncing address */
|
|
ref_cnt = ha->refcount - ha->sync_cnt;
|
|
if (unsync && unsync(dev, ha->addr, ref_cnt))
|
|
continue;
|
|
|
|
ha->refcount = (ref_cnt << 1) + 1;
|
|
ha->sync_cnt = ref_cnt;
|
|
__hw_addr_del_entry(list, ha, false, false);
|
|
}
|
|
|
|
/* go through and sync updated/new entries to the list */
|
|
list_for_each_entry_safe(ha, tmp, &list->list, list) {
|
|
/* sync if address added or reused */
|
|
if ((ha->sync_cnt << 1) >= ha->refcount)
|
|
continue;
|
|
|
|
ref_cnt = ha->refcount - ha->sync_cnt;
|
|
err = sync(dev, ha->addr, ref_cnt);
|
|
if (err)
|
|
return err;
|
|
|
|
ha->refcount = ref_cnt << 1;
|
|
ha->sync_cnt = ref_cnt;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL(__hw_addr_ref_sync_dev);
|
|
|
|
/**
|
|
* __hw_addr_ref_unsync_dev - Remove synchronized addresses and references on
|
|
* it from device
|
|
* @list: address list to remove synchronized addresses (references on it) from
|
|
* @dev: device to sync
|
|
* @unsync: function to call if address and references on it should be removed
|
|
*
|
|
* Remove all addresses that were added to the device by
|
|
* __hw_addr_ref_sync_dev(). This function is intended to be called from the
|
|
* ndo_stop or ndo_open functions on devices that require explicit address (or
|
|
* references on it) add/remove notifications. If the unsync function pointer
|
|
* is NULL then this function can be used to just reset the sync_cnt for the
|
|
* addresses in the list.
|
|
**/
|
|
void __hw_addr_ref_unsync_dev(struct netdev_hw_addr_list *list,
|
|
struct net_device *dev,
|
|
int (*unsync)(struct net_device *,
|
|
const unsigned char *, int))
|
|
{
|
|
struct netdev_hw_addr *ha, *tmp;
|
|
|
|
list_for_each_entry_safe(ha, tmp, &list->list, list) {
|
|
if (!ha->sync_cnt)
|
|
continue;
|
|
|
|
/* if fails defer unsyncing address */
|
|
if (unsync && unsync(dev, ha->addr, ha->sync_cnt))
|
|
continue;
|
|
|
|
ha->refcount -= ha->sync_cnt - 1;
|
|
ha->sync_cnt = 0;
|
|
__hw_addr_del_entry(list, ha, false, false);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(__hw_addr_ref_unsync_dev);
|
|
|
|
/**
|
|
* __hw_addr_unsync_dev - Remove synchronized addresses from device
|
|
* @list: address list to remove synchronized addresses from
|
|
* @dev: device to sync
|
|
* @unsync: function to call if address should be removed
|
|
*
|
|
* Remove all addresses that were added to the device by __hw_addr_sync_dev().
|
|
* This function is intended to be called from the ndo_stop or ndo_open
|
|
* functions on devices that require explicit address add/remove
|
|
* notifications. If the unsync function pointer is NULL then this function
|
|
* can be used to just reset the sync_cnt for the addresses in the list.
|
|
**/
|
|
void __hw_addr_unsync_dev(struct netdev_hw_addr_list *list,
|
|
struct net_device *dev,
|
|
int (*unsync)(struct net_device *,
|
|
const unsigned char *))
|
|
{
|
|
struct netdev_hw_addr *ha, *tmp;
|
|
|
|
list_for_each_entry_safe(ha, tmp, &list->list, list) {
|
|
if (!ha->sync_cnt)
|
|
continue;
|
|
|
|
/* if unsync is defined and fails defer unsyncing address */
|
|
if (unsync && unsync(dev, ha->addr))
|
|
continue;
|
|
|
|
ha->sync_cnt--;
|
|
__hw_addr_del_entry(list, ha, false, false);
|
|
}
|
|
}
|
|
EXPORT_SYMBOL(__hw_addr_unsync_dev);
|
|
|
|
static void __hw_addr_flush(struct netdev_hw_addr_list *list)
|
|
{
|
|
struct netdev_hw_addr *ha, *tmp;
|
|
|
|
list_for_each_entry_safe(ha, tmp, &list->list, list) {
|
|
list_del_rcu(&ha->list);
|
|
kfree_rcu(ha, rcu_head);
|
|
}
|
|
list->count = 0;
|
|
}
|
|
|
|
void __hw_addr_init(struct netdev_hw_addr_list *list)
|
|
{
|
|
INIT_LIST_HEAD(&list->list);
|
|
list->count = 0;
|
|
}
|
|
EXPORT_SYMBOL(__hw_addr_init);
|
|
|
|
/*
|
|
* Device addresses handling functions
|
|
*/
|
|
|
|
/**
|
|
* dev_addr_flush - Flush device address list
|
|
* @dev: device
|
|
*
|
|
* Flush device address list and reset ->dev_addr.
|
|
*
|
|
* The caller must hold the rtnl_mutex.
|
|
*/
|
|
void dev_addr_flush(struct net_device *dev)
|
|
{
|
|
/* rtnl_mutex must be held here */
|
|
|
|
__hw_addr_flush(&dev->dev_addrs);
|
|
dev->dev_addr = NULL;
|
|
}
|
|
EXPORT_SYMBOL(dev_addr_flush);
|
|
|
|
/**
|
|
* dev_addr_init - Init device address list
|
|
* @dev: device
|
|
*
|
|
* Init device address list and create the first element,
|
|
* used by ->dev_addr.
|
|
*
|
|
* The caller must hold the rtnl_mutex.
|
|
*/
|
|
int dev_addr_init(struct net_device *dev)
|
|
{
|
|
unsigned char addr[MAX_ADDR_LEN];
|
|
struct netdev_hw_addr *ha;
|
|
int err;
|
|
|
|
/* rtnl_mutex must be held here */
|
|
|
|
__hw_addr_init(&dev->dev_addrs);
|
|
memset(addr, 0, sizeof(addr));
|
|
err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
|
|
NETDEV_HW_ADDR_T_LAN);
|
|
if (!err) {
|
|
/*
|
|
* Get the first (previously created) address from the list
|
|
* and set dev_addr pointer to this location.
|
|
*/
|
|
ha = list_first_entry(&dev->dev_addrs.list,
|
|
struct netdev_hw_addr, list);
|
|
dev->dev_addr = ha->addr;
|
|
}
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(dev_addr_init);
|
|
|
|
/**
|
|
* dev_addr_add - Add a device address
|
|
* @dev: device
|
|
* @addr: address to add
|
|
* @addr_type: address type
|
|
*
|
|
* Add a device address to the device or increase the reference count if
|
|
* it already exists.
|
|
*
|
|
* The caller must hold the rtnl_mutex.
|
|
*/
|
|
int dev_addr_add(struct net_device *dev, const unsigned char *addr,
|
|
unsigned char addr_type)
|
|
{
|
|
int err;
|
|
|
|
ASSERT_RTNL();
|
|
|
|
err = dev_pre_changeaddr_notify(dev, addr, NULL);
|
|
if (err)
|
|
return err;
|
|
err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
|
|
if (!err)
|
|
call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(dev_addr_add);
|
|
|
|
/**
|
|
* dev_addr_del - Release a device address.
|
|
* @dev: device
|
|
* @addr: address to delete
|
|
* @addr_type: address type
|
|
*
|
|
* Release reference to a device address and remove it from the device
|
|
* if the reference count drops to zero.
|
|
*
|
|
* The caller must hold the rtnl_mutex.
|
|
*/
|
|
int dev_addr_del(struct net_device *dev, const unsigned char *addr,
|
|
unsigned char addr_type)
|
|
{
|
|
int err;
|
|
struct netdev_hw_addr *ha;
|
|
|
|
ASSERT_RTNL();
|
|
|
|
/*
|
|
* We can not remove the first address from the list because
|
|
* dev->dev_addr points to that.
|
|
*/
|
|
ha = list_first_entry(&dev->dev_addrs.list,
|
|
struct netdev_hw_addr, list);
|
|
if (!memcmp(ha->addr, addr, dev->addr_len) &&
|
|
ha->type == addr_type && ha->refcount == 1)
|
|
return -ENOENT;
|
|
|
|
err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
|
|
addr_type);
|
|
if (!err)
|
|
call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(dev_addr_del);
|
|
|
|
/*
|
|
* Unicast list handling functions
|
|
*/
|
|
|
|
/**
|
|
* dev_uc_add_excl - Add a global secondary unicast address
|
|
* @dev: device
|
|
* @addr: address to add
|
|
*/
|
|
int dev_uc_add_excl(struct net_device *dev, const unsigned char *addr)
|
|
{
|
|
struct netdev_hw_addr *ha;
|
|
int err;
|
|
|
|
netif_addr_lock_bh(dev);
|
|
list_for_each_entry(ha, &dev->uc.list, list) {
|
|
if (!memcmp(ha->addr, addr, dev->addr_len) &&
|
|
ha->type == NETDEV_HW_ADDR_T_UNICAST) {
|
|
err = -EEXIST;
|
|
goto out;
|
|
}
|
|
}
|
|
err = __hw_addr_create_ex(&dev->uc, addr, dev->addr_len,
|
|
NETDEV_HW_ADDR_T_UNICAST, true, false);
|
|
if (!err)
|
|
__dev_set_rx_mode(dev);
|
|
out:
|
|
netif_addr_unlock_bh(dev);
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(dev_uc_add_excl);
|
|
|
|
/**
|
|
* dev_uc_add - Add a secondary unicast address
|
|
* @dev: device
|
|
* @addr: address to add
|
|
*
|
|
* Add a secondary unicast address to the device or increase
|
|
* the reference count if it already exists.
|
|
*/
|
|
int dev_uc_add(struct net_device *dev, const unsigned char *addr)
|
|
{
|
|
int err;
|
|
|
|
netif_addr_lock_bh(dev);
|
|
err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
|
|
NETDEV_HW_ADDR_T_UNICAST);
|
|
if (!err)
|
|
__dev_set_rx_mode(dev);
|
|
netif_addr_unlock_bh(dev);
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(dev_uc_add);
|
|
|
|
/**
|
|
* dev_uc_del - Release secondary unicast address.
|
|
* @dev: device
|
|
* @addr: address to delete
|
|
*
|
|
* Release reference to a secondary unicast address and remove it
|
|
* from the device if the reference count drops to zero.
|
|
*/
|
|
int dev_uc_del(struct net_device *dev, const unsigned char *addr)
|
|
{
|
|
int err;
|
|
|
|
netif_addr_lock_bh(dev);
|
|
err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
|
|
NETDEV_HW_ADDR_T_UNICAST);
|
|
if (!err)
|
|
__dev_set_rx_mode(dev);
|
|
netif_addr_unlock_bh(dev);
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(dev_uc_del);
|
|
|
|
/**
|
|
* dev_uc_sync - Synchronize device's unicast list to another device
|
|
* @to: destination device
|
|
* @from: source device
|
|
*
|
|
* Add newly added addresses to the destination device and release
|
|
* addresses that have no users left. The source device must be
|
|
* locked by netif_addr_lock_bh.
|
|
*
|
|
* This function is intended to be called from the dev->set_rx_mode
|
|
* function of layered software devices. This function assumes that
|
|
* addresses will only ever be synced to the @to devices and no other.
|
|
*/
|
|
int dev_uc_sync(struct net_device *to, struct net_device *from)
|
|
{
|
|
int err = 0;
|
|
|
|
if (to->addr_len != from->addr_len)
|
|
return -EINVAL;
|
|
|
|
netif_addr_lock(to);
|
|
err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
|
|
if (!err)
|
|
__dev_set_rx_mode(to);
|
|
netif_addr_unlock(to);
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(dev_uc_sync);
|
|
|
|
/**
|
|
* dev_uc_sync_multiple - Synchronize device's unicast list to another
|
|
* device, but allow for multiple calls to sync to multiple devices.
|
|
* @to: destination device
|
|
* @from: source device
|
|
*
|
|
* Add newly added addresses to the destination device and release
|
|
* addresses that have been deleted from the source. The source device
|
|
* must be locked by netif_addr_lock_bh.
|
|
*
|
|
* This function is intended to be called from the dev->set_rx_mode
|
|
* function of layered software devices. It allows for a single source
|
|
* device to be synced to multiple destination devices.
|
|
*/
|
|
int dev_uc_sync_multiple(struct net_device *to, struct net_device *from)
|
|
{
|
|
int err = 0;
|
|
|
|
if (to->addr_len != from->addr_len)
|
|
return -EINVAL;
|
|
|
|
netif_addr_lock(to);
|
|
err = __hw_addr_sync_multiple(&to->uc, &from->uc, to->addr_len);
|
|
if (!err)
|
|
__dev_set_rx_mode(to);
|
|
netif_addr_unlock(to);
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(dev_uc_sync_multiple);
|
|
|
|
/**
|
|
* dev_uc_unsync - Remove synchronized addresses from the destination device
|
|
* @to: destination device
|
|
* @from: source device
|
|
*
|
|
* Remove all addresses that were added to the destination device by
|
|
* dev_uc_sync(). This function is intended to be called from the
|
|
* dev->stop function of layered software devices.
|
|
*/
|
|
void dev_uc_unsync(struct net_device *to, struct net_device *from)
|
|
{
|
|
if (to->addr_len != from->addr_len)
|
|
return;
|
|
|
|
/* netif_addr_lock_bh() uses lockdep subclass 0, this is okay for two
|
|
* reasons:
|
|
* 1) This is always called without any addr_list_lock, so as the
|
|
* outermost one here, it must be 0.
|
|
* 2) This is called by some callers after unlinking the upper device,
|
|
* so the dev->lower_level becomes 1 again.
|
|
* Therefore, the subclass for 'from' is 0, for 'to' is either 1 or
|
|
* larger.
|
|
*/
|
|
netif_addr_lock_bh(from);
|
|
netif_addr_lock(to);
|
|
__hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
|
|
__dev_set_rx_mode(to);
|
|
netif_addr_unlock(to);
|
|
netif_addr_unlock_bh(from);
|
|
}
|
|
EXPORT_SYMBOL(dev_uc_unsync);
|
|
|
|
/**
|
|
* dev_uc_flush - Flush unicast addresses
|
|
* @dev: device
|
|
*
|
|
* Flush unicast addresses.
|
|
*/
|
|
void dev_uc_flush(struct net_device *dev)
|
|
{
|
|
netif_addr_lock_bh(dev);
|
|
__hw_addr_flush(&dev->uc);
|
|
netif_addr_unlock_bh(dev);
|
|
}
|
|
EXPORT_SYMBOL(dev_uc_flush);
|
|
|
|
/**
|
|
* dev_uc_flush - Init unicast address list
|
|
* @dev: device
|
|
*
|
|
* Init unicast address list.
|
|
*/
|
|
void dev_uc_init(struct net_device *dev)
|
|
{
|
|
__hw_addr_init(&dev->uc);
|
|
}
|
|
EXPORT_SYMBOL(dev_uc_init);
|
|
|
|
/*
|
|
* Multicast list handling functions
|
|
*/
|
|
|
|
/**
|
|
* dev_mc_add_excl - Add a global secondary multicast address
|
|
* @dev: device
|
|
* @addr: address to add
|
|
*/
|
|
int dev_mc_add_excl(struct net_device *dev, const unsigned char *addr)
|
|
{
|
|
struct netdev_hw_addr *ha;
|
|
int err;
|
|
|
|
netif_addr_lock_bh(dev);
|
|
list_for_each_entry(ha, &dev->mc.list, list) {
|
|
if (!memcmp(ha->addr, addr, dev->addr_len) &&
|
|
ha->type == NETDEV_HW_ADDR_T_MULTICAST) {
|
|
err = -EEXIST;
|
|
goto out;
|
|
}
|
|
}
|
|
err = __hw_addr_create_ex(&dev->mc, addr, dev->addr_len,
|
|
NETDEV_HW_ADDR_T_MULTICAST, true, false);
|
|
if (!err)
|
|
__dev_set_rx_mode(dev);
|
|
out:
|
|
netif_addr_unlock_bh(dev);
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(dev_mc_add_excl);
|
|
|
|
static int __dev_mc_add(struct net_device *dev, const unsigned char *addr,
|
|
bool global)
|
|
{
|
|
int err;
|
|
|
|
netif_addr_lock_bh(dev);
|
|
err = __hw_addr_add_ex(&dev->mc, addr, dev->addr_len,
|
|
NETDEV_HW_ADDR_T_MULTICAST, global, false, 0);
|
|
if (!err)
|
|
__dev_set_rx_mode(dev);
|
|
netif_addr_unlock_bh(dev);
|
|
return err;
|
|
}
|
|
/**
|
|
* dev_mc_add - Add a multicast address
|
|
* @dev: device
|
|
* @addr: address to add
|
|
*
|
|
* Add a multicast address to the device or increase
|
|
* the reference count if it already exists.
|
|
*/
|
|
int dev_mc_add(struct net_device *dev, const unsigned char *addr)
|
|
{
|
|
return __dev_mc_add(dev, addr, false);
|
|
}
|
|
EXPORT_SYMBOL(dev_mc_add);
|
|
|
|
/**
|
|
* dev_mc_add_global - Add a global multicast address
|
|
* @dev: device
|
|
* @addr: address to add
|
|
*
|
|
* Add a global multicast address to the device.
|
|
*/
|
|
int dev_mc_add_global(struct net_device *dev, const unsigned char *addr)
|
|
{
|
|
return __dev_mc_add(dev, addr, true);
|
|
}
|
|
EXPORT_SYMBOL(dev_mc_add_global);
|
|
|
|
static int __dev_mc_del(struct net_device *dev, const unsigned char *addr,
|
|
bool global)
|
|
{
|
|
int err;
|
|
|
|
netif_addr_lock_bh(dev);
|
|
err = __hw_addr_del_ex(&dev->mc, addr, dev->addr_len,
|
|
NETDEV_HW_ADDR_T_MULTICAST, global, false);
|
|
if (!err)
|
|
__dev_set_rx_mode(dev);
|
|
netif_addr_unlock_bh(dev);
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* dev_mc_del - Delete a multicast address.
|
|
* @dev: device
|
|
* @addr: address to delete
|
|
*
|
|
* Release reference to a multicast address and remove it
|
|
* from the device if the reference count drops to zero.
|
|
*/
|
|
int dev_mc_del(struct net_device *dev, const unsigned char *addr)
|
|
{
|
|
return __dev_mc_del(dev, addr, false);
|
|
}
|
|
EXPORT_SYMBOL(dev_mc_del);
|
|
|
|
/**
|
|
* dev_mc_del_global - Delete a global multicast address.
|
|
* @dev: device
|
|
* @addr: address to delete
|
|
*
|
|
* Release reference to a multicast address and remove it
|
|
* from the device if the reference count drops to zero.
|
|
*/
|
|
int dev_mc_del_global(struct net_device *dev, const unsigned char *addr)
|
|
{
|
|
return __dev_mc_del(dev, addr, true);
|
|
}
|
|
EXPORT_SYMBOL(dev_mc_del_global);
|
|
|
|
/**
|
|
* dev_mc_sync - Synchronize device's multicast list to another device
|
|
* @to: destination device
|
|
* @from: source device
|
|
*
|
|
* Add newly added addresses to the destination device and release
|
|
* addresses that have no users left. The source device must be
|
|
* locked by netif_addr_lock_bh.
|
|
*
|
|
* This function is intended to be called from the ndo_set_rx_mode
|
|
* function of layered software devices.
|
|
*/
|
|
int dev_mc_sync(struct net_device *to, struct net_device *from)
|
|
{
|
|
int err = 0;
|
|
|
|
if (to->addr_len != from->addr_len)
|
|
return -EINVAL;
|
|
|
|
netif_addr_lock(to);
|
|
err = __hw_addr_sync(&to->mc, &from->mc, to->addr_len);
|
|
if (!err)
|
|
__dev_set_rx_mode(to);
|
|
netif_addr_unlock(to);
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(dev_mc_sync);
|
|
|
|
/**
|
|
* dev_mc_sync_multiple - Synchronize device's multicast list to another
|
|
* device, but allow for multiple calls to sync to multiple devices.
|
|
* @to: destination device
|
|
* @from: source device
|
|
*
|
|
* Add newly added addresses to the destination device and release
|
|
* addresses that have no users left. The source device must be
|
|
* locked by netif_addr_lock_bh.
|
|
*
|
|
* This function is intended to be called from the ndo_set_rx_mode
|
|
* function of layered software devices. It allows for a single
|
|
* source device to be synced to multiple destination devices.
|
|
*/
|
|
int dev_mc_sync_multiple(struct net_device *to, struct net_device *from)
|
|
{
|
|
int err = 0;
|
|
|
|
if (to->addr_len != from->addr_len)
|
|
return -EINVAL;
|
|
|
|
netif_addr_lock(to);
|
|
err = __hw_addr_sync_multiple(&to->mc, &from->mc, to->addr_len);
|
|
if (!err)
|
|
__dev_set_rx_mode(to);
|
|
netif_addr_unlock(to);
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(dev_mc_sync_multiple);
|
|
|
|
/**
|
|
* dev_mc_unsync - Remove synchronized addresses from the destination device
|
|
* @to: destination device
|
|
* @from: source device
|
|
*
|
|
* Remove all addresses that were added to the destination device by
|
|
* dev_mc_sync(). This function is intended to be called from the
|
|
* dev->stop function of layered software devices.
|
|
*/
|
|
void dev_mc_unsync(struct net_device *to, struct net_device *from)
|
|
{
|
|
if (to->addr_len != from->addr_len)
|
|
return;
|
|
|
|
/* See the above comments inside dev_uc_unsync(). */
|
|
netif_addr_lock_bh(from);
|
|
netif_addr_lock(to);
|
|
__hw_addr_unsync(&to->mc, &from->mc, to->addr_len);
|
|
__dev_set_rx_mode(to);
|
|
netif_addr_unlock(to);
|
|
netif_addr_unlock_bh(from);
|
|
}
|
|
EXPORT_SYMBOL(dev_mc_unsync);
|
|
|
|
/**
|
|
* dev_mc_flush - Flush multicast addresses
|
|
* @dev: device
|
|
*
|
|
* Flush multicast addresses.
|
|
*/
|
|
void dev_mc_flush(struct net_device *dev)
|
|
{
|
|
netif_addr_lock_bh(dev);
|
|
__hw_addr_flush(&dev->mc);
|
|
netif_addr_unlock_bh(dev);
|
|
}
|
|
EXPORT_SYMBOL(dev_mc_flush);
|
|
|
|
/**
|
|
* dev_mc_init - Init multicast address list
|
|
* @dev: device
|
|
*
|
|
* Init multicast address list.
|
|
*/
|
|
void dev_mc_init(struct net_device *dev)
|
|
{
|
|
__hw_addr_init(&dev->mc);
|
|
}
|
|
EXPORT_SYMBOL(dev_mc_init);
|