renegade-project/linux-next
2
0
Fork 0
mirror of https://github.com/edk2-porting/linux-next.git synced 2024-11-19 16:14:13 +08:00
Code

net: group address list and its count

Browse Source 
This patch is inspired by patch recently posted by Johannes Berg. Basically what
my patch does is to group list and a count of addresses into newly introduced
structure netdev_hw_addr_list. This brings us two benefits:
1) struct net_device becames a bit nicer.
2) in the future there will be a possibility to operate with lists independently
   on netdevices (with exporting right functions).
I wanted to introduce this patch before I'll post a multicast lists conversion.

Signed-off-by: Jiri Pirko <jpirko@redhat.com>

 drivers/net/bnx2.c              |    4 +-
 drivers/net/e1000/e1000_main.c  |    4 +-
 drivers/net/ixgbe/ixgbe_main.c  |    6 +-
 drivers/net/mv643xx_eth.c       |    2 +-
 drivers/net/niu.c               |    4 +-
 drivers/net/virtio_net.c        |   10 ++--
 drivers/s390/net/qeth_l2_main.c |    2 +-
 include/linux/netdevice.h       |   17 +++--
 net/core/dev.c                  |  130 ++++++++++++++++++--------------------
 9 files changed, 89 insertions(+), 90 deletions(-)
Signed-off-by: David S. Miller <davem@davemloft.net>
This commit is contained in:
Jiri Pirko 2009-06-17 01:12:19 +00:00 committed by David S. Miller
parent 7b85576d15
commit 31278e7147
9 changed files with 89 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
drivers/net/bnx2.c
View File

@ -3552,14 +3552,14 @@ bnx2_set_rx_mode(struct net_device *dev)
sort_mode |= BNX2_RPM_SORT_USER0_MC_HSH_EN; sort_mode |= BNX2_RPM_SORT_USER0_MC_HSH_EN;
} }
if (dev->uc_count > BNX2_MAX_UNICAST_ADDRESSES) { if (dev->uc.count > BNX2_MAX_UNICAST_ADDRESSES) {
rx_mode |= BNX2_EMAC_RX_MODE_PROMISCUOUS; rx_mode |= BNX2_EMAC_RX_MODE_PROMISCUOUS;
sort_mode |= BNX2_RPM_SORT_USER0_PROM_EN | sort_mode |= BNX2_RPM_SORT_USER0_PROM_EN |
BNX2_RPM_SORT_USER0_PROM_VLAN; BNX2_RPM_SORT_USER0_PROM_VLAN;
} else if (!(dev->flags & IFF_PROMISC)) { } else if (!(dev->flags & IFF_PROMISC)) {
/* Add all entries into to the match filter list */ /* Add all entries into to the match filter list */
i = 0; i = 0;
list_for_each_entry(ha, &dev->uc_list, list) { list_for_each_entry(ha, &dev->uc.list, list) {
bnx2_set_mac_addr(bp, ha->addr, bnx2_set_mac_addr(bp, ha->addr,
i + BNX2_START_UNICAST_ADDRESS_INDEX); i + BNX2_START_UNICAST_ADDRESS_INDEX);
sort_mode |= (1 << sort_mode |= (1 <<

4
drivers/net/e1000/e1000_main.c
View File

@ -2370,7 +2370,7 @@ static void e1000_set_rx_mode(struct net_device *netdev)
rctl |= E1000_RCTL_VFE; rctl |= E1000_RCTL_VFE;
} }
if (netdev->uc_count > rar_entries - 1) { if (netdev->uc.count > rar_entries - 1) {
rctl |= E1000_RCTL_UPE; rctl |= E1000_RCTL_UPE;
} else if (!(netdev->flags & IFF_PROMISC)) { } else if (!(netdev->flags & IFF_PROMISC)) {
rctl &= ~E1000_RCTL_UPE; rctl &= ~E1000_RCTL_UPE;
@ -2394,7 +2394,7 @@ static void e1000_set_rx_mode(struct net_device *netdev)
*/ */
i = 1; i = 1;
if (use_uc) if (use_uc)
list_for_each_entry(ha, &netdev->uc_list, list) { list_for_each_entry(ha, &netdev->uc.list, list) {
if (i == rar_entries) if (i == rar_entries)
break; break;
e1000_rar_set(hw, ha->addr, i++); e1000_rar_set(hw, ha->addr, i++);

6
drivers/net/ixgbe/ixgbe_main.c
View File

@ -2321,7 +2321,7 @@ static void ixgbe_set_rx_mode(struct net_device *netdev)
IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, vlnctrl); IXGBE_WRITE_REG(hw, IXGBE_VLNCTRL, vlnctrl);
/* reprogram secondary unicast list */ /* reprogram secondary unicast list */
hw->mac.ops.update_uc_addr_list(hw, &netdev->uc_list); hw->mac.ops.update_uc_addr_list(hw, &netdev->uc.list);
/* reprogram multicast list */ /* reprogram multicast list */
addr_count = netdev->mc_count; addr_count = netdev->mc_count;
@ -5261,7 +5261,7 @@ static int ixgbe_ioctl(struct net_device *netdev, struct ifreq *req, int cmd)
/** /**
* ixgbe_add_sanmac_netdev - Add the SAN MAC address to the corresponding * ixgbe_add_sanmac_netdev - Add the SAN MAC address to the corresponding
* netdev->dev_addr_list * netdev->dev_addrs
* @netdev: network interface device structure * @netdev: network interface device structure
* *
* Returns non-zero on failure * Returns non-zero on failure
@ -5282,7 +5282,7 @@ static int ixgbe_add_sanmac_netdev(struct net_device *dev)
/** /**
* ixgbe_del_sanmac_netdev - Removes the SAN MAC address to the corresponding * ixgbe_del_sanmac_netdev - Removes the SAN MAC address to the corresponding
* netdev->dev_addr_list * netdev->dev_addrs
* @netdev: network interface device structure * @netdev: network interface device structure
* *
* Returns non-zero on failure * Returns non-zero on failure

2
drivers/net/mv643xx_eth.c
View File

@ -1729,7 +1729,7 @@ static u32 uc_addr_filter_mask(struct net_device *dev)
return 0; return 0;
nibbles = 1 << (dev->dev_addr[5] & 0x0f); nibbles = 1 << (dev->dev_addr[5] & 0x0f);
list_for_each_entry(ha, &dev->uc_list, list) { list_for_each_entry(ha, &dev->uc.list, list) {
if (memcmp(dev->dev_addr, ha->addr, 5)) if (memcmp(dev->dev_addr, ha->addr, 5))
return 0; return 0;
if ((dev->dev_addr[5] ^ ha->addr[5]) & 0xf0) if ((dev->dev_addr[5] ^ ha->addr[5]) & 0xf0)

4
drivers/net/niu.c
View File

@ -6376,7 +6376,7 @@ static void niu_set_rx_mode(struct net_device *dev)
if ((dev->flags & IFF_ALLMULTI) || (dev->mc_count > 0)) if ((dev->flags & IFF_ALLMULTI) || (dev->mc_count > 0))
np->flags |= NIU_FLAGS_MCAST; np->flags |= NIU_FLAGS_MCAST;
alt_cnt = dev->uc_count; alt_cnt = dev->uc.count;
if (alt_cnt > niu_num_alt_addr(np)) { if (alt_cnt > niu_num_alt_addr(np)) {
alt_cnt = 0; alt_cnt = 0;
np->flags |= NIU_FLAGS_PROMISC; np->flags |= NIU_FLAGS_PROMISC;
@ -6385,7 +6385,7 @@ static void niu_set_rx_mode(struct net_device *dev)
if (alt_cnt) { if (alt_cnt) {
int index = 0; int index = 0;
list_for_each_entry(ha, &dev->uc_list, list) { list_for_each_entry(ha, &dev->uc.list, list) {
err = niu_set_alt_mac(np, index, ha->addr); err = niu_set_alt_mac(np, index, ha->addr);
if (err) if (err)
printk(KERN_WARNING PFX "%s: Error %d " printk(KERN_WARNING PFX "%s: Error %d "

10
drivers/net/virtio_net.c
View File

@ -709,7 +709,7 @@ static void virtnet_set_rx_mode(struct net_device *dev)
allmulti ? "en" : "dis"); allmulti ? "en" : "dis");
/* MAC filter - use one buffer for both lists */ /* MAC filter - use one buffer for both lists */
mac_data = buf = kzalloc(((dev->uc_count + dev->mc_count) * ETH_ALEN) + mac_data = buf = kzalloc(((dev->uc.count + dev->mc_count) * ETH_ALEN) +
(2 * sizeof(mac_data->entries)), GFP_ATOMIC); (2 * sizeof(mac_data->entries)), GFP_ATOMIC);
if (!buf) { if (!buf) {
dev_warn(&dev->dev, "No memory for MAC address buffer\n"); dev_warn(&dev->dev, "No memory for MAC address buffer\n");
@ -719,16 +719,16 @@ static void virtnet_set_rx_mode(struct net_device *dev)
sg_init_table(sg, 2); sg_init_table(sg, 2);
/* Store the unicast list and count in the front of the buffer */ /* Store the unicast list and count in the front of the buffer */
mac_data->entries = dev->uc_count; mac_data->entries = dev->uc.count;
i = 0; i = 0;
list_for_each_entry(ha, &dev->uc_list, list) list_for_each_entry(ha, &dev->uc.list, list)
memcpy(&mac_data->macs[i++][0], ha->addr, ETH_ALEN); memcpy(&mac_data->macs[i++][0], ha->addr, ETH_ALEN);
sg_set_buf(&sg[0], mac_data, sg_set_buf(&sg[0], mac_data,
sizeof(mac_data->entries) + (dev->uc_count * ETH_ALEN)); sizeof(mac_data->entries) + (dev->uc.count * ETH_ALEN));
/* multicast list and count fill the end */ /* multicast list and count fill the end */
mac_data = (void *)&mac_data->macs[dev->uc_count][0]; mac_data = (void *)&mac_data->macs[dev->uc.count][0];
mac_data->entries = dev->mc_count; mac_data->entries = dev->mc_count;
addr = dev->mc_list; addr = dev->mc_list;

2
drivers/s390/net/qeth_l2_main.c
View File

@ -655,7 +655,7 @@ static void qeth_l2_set_multicast_list(struct net_device *dev)
for (dm = dev->mc_list; dm; dm = dm->next) for (dm = dev->mc_list; dm; dm = dm->next)
qeth_l2_add_mc(card, dm->da_addr, 0); qeth_l2_add_mc(card, dm->da_addr, 0);
list_for_each_entry(ha, &dev->uc_list, list) list_for_each_entry(ha, &dev->uc.list, list)
qeth_l2_add_mc(card, ha->addr, 1); qeth_l2_add_mc(card, ha->addr, 1);
spin_unlock_bh(&card->mclock); spin_unlock_bh(&card->mclock);

17
include/linux/netdevice.h
View File

@ -224,6 +224,11 @@ struct netdev_hw_addr {
struct rcu_head rcu_head; struct rcu_head rcu_head;
}; };
struct netdev_hw_addr_list {
struct list_head list;
int count;
};
struct hh_cache struct hh_cache
{ {
struct hh_cache *hh_next; /* Next entry */ struct hh_cache *hh_next; /* Next entry */
@ -776,9 +781,8 @@ struct net_device
unsigned char addr_len; /* hardware address length */ unsigned char addr_len; /* hardware address length */
unsigned short dev_id; /* for shared network cards */ unsigned short dev_id; /* for shared network cards */
struct list_head uc_list; /* Secondary unicast mac struct netdev_hw_addr_list uc; /* Secondary unicast
addresses */ mac addresses */
int uc_count; /* Number of installed ucasts */
int uc_promisc; int uc_promisc;
spinlock_t addr_list_lock; spinlock_t addr_list_lock;
struct dev_addr_list *mc_list; /* Multicast mac addresses */ struct dev_addr_list *mc_list; /* Multicast mac addresses */
@ -810,7 +814,8 @@ struct net_device
because most packets are because most packets are
unicast) */ unicast) */
struct list_head dev_addr_list; /* list of device hw addresses */ struct netdev_hw_addr_list dev_addrs; /* list of device
hw addresses */
unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */ unsigned char broadcast[MAX_ADDR_LEN]; /* hw bcast add */
@ -1806,11 +1811,11 @@ static inline void netif_addr_unlock_bh(struct net_device *dev)
} }
/* /*
* dev_addr_list walker. Should be used only for read access. Call with * dev_addrs walker. Should be used only for read access. Call with
* rcu_read_lock held. * rcu_read_lock held.
*/ */
#define for_each_dev_addr(dev, ha) \ #define for_each_dev_addr(dev, ha) \
list_for_each_entry_rcu(ha, &dev->dev_addr_list, list) list_for_each_entry_rcu(ha, &dev->dev_addrs.list, list)
/* These functions live elsewhere (drivers/net/net_init.c, but related) */ /* These functions live elsewhere (drivers/net/net_init.c, but related) */

130
net/core/dev.c
View File

@ -3461,10 +3461,10 @@ void __dev_set_rx_mode(struct net_device *dev)
/* Unicast addresses changes may only happen under the rtnl, /* Unicast addresses changes may only happen under the rtnl,
* therefore calling __dev_set_promiscuity here is safe. * therefore calling __dev_set_promiscuity here is safe.
*/ */
if (dev->uc_count > 0 && !dev->uc_promisc) { if (dev->uc.count > 0 && !dev->uc_promisc) {
__dev_set_promiscuity(dev, 1); __dev_set_promiscuity(dev, 1);
dev->uc_promisc = 1; dev->uc_promisc = 1;
} else if (dev->uc_count == 0 && dev->uc_promisc) { } else if (dev->uc.count == 0 && dev->uc_promisc) {
__dev_set_promiscuity(dev, -1); __dev_set_promiscuity(dev, -1);
dev->uc_promisc = 0; dev->uc_promisc = 0;
} }
@ -3483,9 +3483,8 @@ void dev_set_rx_mode(struct net_device *dev)
/* hw addresses list handling functions */ /* hw addresses list handling functions */
static int __hw_addr_add(struct list_head *list, int *delta, static int __hw_addr_add(struct netdev_hw_addr_list *list, unsigned char *addr,
unsigned char *addr, int addr_len, int addr_len, unsigned char addr_type)
unsigned char addr_type)
{ {
struct netdev_hw_addr *ha; struct netdev_hw_addr *ha;
int alloc_size; int alloc_size;
@ -3493,7 +3492,7 @@ static int __hw_addr_add(struct list_head *list, int *delta,
if (addr_len > MAX_ADDR_LEN) if (addr_len > MAX_ADDR_LEN)
return -EINVAL; return -EINVAL;
list_for_each_entry(ha, list, list) { list_for_each_entry(ha, &list->list, list) {
if (!memcmp(ha->addr, addr, addr_len) && if (!memcmp(ha->addr, addr, addr_len) &&
ha->type == addr_type) { ha->type == addr_type) {
ha->refcount++; ha->refcount++;
@ -3512,9 +3511,8 @@ static int __hw_addr_add(struct list_head *list, int *delta,
ha->type = addr_type; ha->type = addr_type;
ha->refcount = 1; ha->refcount = 1;
ha->synced = false; ha->synced = false;
list_add_tail_rcu(&ha->list, list); list_add_tail_rcu(&ha->list, &list->list);
if (delta) list->count++;
(*delta)++;
return 0; return 0;
} }
@ -3526,120 +3524,121 @@ static void ha_rcu_free(struct rcu_head *head)
kfree(ha); kfree(ha);
} }
static int __hw_addr_del(struct list_head *list, int *delta, static int __hw_addr_del(struct netdev_hw_addr_list *list, unsigned char *addr,
unsigned char *addr, int addr_len, int addr_len, unsigned char addr_type)
unsigned char addr_type)
{ {
struct netdev_hw_addr *ha; struct netdev_hw_addr *ha;
list_for_each_entry(ha, list, list) { list_for_each_entry(ha, &list->list, list) {
if (!memcmp(ha->addr, addr, addr_len) && if (!memcmp(ha->addr, addr, addr_len) &&
(ha->type == addr_type || !addr_type)) { (ha->type == addr_type || !addr_type)) {
if (--ha->refcount) if (--ha->refcount)
return 0; return 0;
list_del_rcu(&ha->list); list_del_rcu(&ha->list);
call_rcu(&ha->rcu_head, ha_rcu_free); call_rcu(&ha->rcu_head, ha_rcu_free);
if (delta) list->count--;
(*delta)--;
return 0; return 0;
} }
} }
return -ENOENT; return -ENOENT;
} }
static int __hw_addr_add_multiple(struct list_head *to_list, int *to_delta, static int __hw_addr_add_multiple(struct netdev_hw_addr_list *to_list,
struct list_head *from_list, int addr_len, struct netdev_hw_addr_list *from_list,
int addr_len,
unsigned char addr_type) unsigned char addr_type)
{ {
int err; int err;
struct netdev_hw_addr *ha, *ha2; struct netdev_hw_addr *ha, *ha2;
unsigned char type; unsigned char type;
list_for_each_entry(ha, from_list, list) { list_for_each_entry(ha, &from_list->list, list) {
type = addr_type ? addr_type : ha->type; type = addr_type ? addr_type : ha->type;
err = __hw_addr_add(to_list, to_delta, ha->addr, err = __hw_addr_add(to_list, ha->addr, addr_len, type);
addr_len, type);
if (err) if (err)
goto unroll; goto unroll;
} }
return 0; return 0;
unroll: unroll:
list_for_each_entry(ha2, from_list, list) { list_for_each_entry(ha2, &from_list->list, list) {
if (ha2 == ha) if (ha2 == ha)
break; break;
type = addr_type ? addr_type : ha2->type; type = addr_type ? addr_type : ha2->type;
__hw_addr_del(to_list, to_delta, ha2->addr, __hw_addr_del(to_list, ha2->addr, addr_len, type);
addr_len, type);
} }
return err; return err;
} }
static void __hw_addr_del_multiple(struct list_head *to_list, int *to_delta, static void __hw_addr_del_multiple(struct netdev_hw_addr_list *to_list,
struct list_head *from_list, int addr_len, struct netdev_hw_addr_list *from_list,
int addr_len,
unsigned char addr_type) unsigned char addr_type)
{ {
struct netdev_hw_addr *ha; struct netdev_hw_addr *ha;
unsigned char type; unsigned char type;
list_for_each_entry(ha, from_list, list) { list_for_each_entry(ha, &from_list->list, list) {
type = addr_type ? addr_type : ha->type; type = addr_type ? addr_type : ha->type;
__hw_addr_del(to_list, to_delta, ha->addr, __hw_addr_del(to_list, ha->addr, addr_len, addr_type);
addr_len, addr_type);
} }
} }
static int __hw_addr_sync(struct list_head *to_list, int *to_delta, static int __hw_addr_sync(struct netdev_hw_addr_list *to_list,
struct list_head *from_list, int *from_delta, struct netdev_hw_addr_list *from_list,
int addr_len) int addr_len)
{ {
int err = 0; int err = 0;
struct netdev_hw_addr *ha, *tmp; struct netdev_hw_addr *ha, *tmp;
list_for_each_entry_safe(ha, tmp, from_list, list) { list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
if (!ha->synced) { if (!ha->synced) {
err = __hw_addr_add(to_list, to_delta, ha->addr, err = __hw_addr_add(to_list, ha->addr,
addr_len, ha->type); addr_len, ha->type);
if (err) if (err)
break; break;
ha->synced = true; ha->synced = true;
ha->refcount++; ha->refcount++;
} else if (ha->refcount == 1) { } else if (ha->refcount == 1) {
__hw_addr_del(to_list, to_delta, ha->addr, __hw_addr_del(to_list, ha->addr, addr_len, ha->type);
addr_len, ha->type); __hw_addr_del(from_list, ha->addr, addr_len, ha->type);
__hw_addr_del(from_list, from_delta, ha->addr,
addr_len, ha->type);
} }
} }
return err; return err;
} }
static void __hw_addr_unsync(struct list_head *to_list, int *to_delta, static void __hw_addr_unsync(struct netdev_hw_addr_list *to_list,
struct list_head *from_list, int *from_delta, struct netdev_hw_addr_list *from_list,
int addr_len) int addr_len)
{ {
struct netdev_hw_addr *ha, *tmp; struct netdev_hw_addr *ha, *tmp;
list_for_each_entry_safe(ha, tmp, from_list, list) { list_for_each_entry_safe(ha, tmp, &from_list->list, list) {
if (ha->synced) { if (ha->synced) {
__hw_addr_del(to_list, to_delta, ha->addr, __hw_addr_del(to_list, ha->addr,
addr_len, ha->type); addr_len, ha->type);
ha->synced = false; ha->synced = false;
__hw_addr_del(from_list, from_delta, ha->addr, __hw_addr_del(from_list, ha->addr,
addr_len, ha->type); addr_len, ha->type);
} }
} }
} }
static void __hw_addr_flush(struct netdev_hw_addr_list *list)
static void __hw_addr_flush(struct list_head *list)
{ {
struct netdev_hw_addr *ha, *tmp; struct netdev_hw_addr *ha, *tmp;
list_for_each_entry_safe(ha, tmp, list, list) { list_for_each_entry_safe(ha, tmp, &list->list, list) {
list_del_rcu(&ha->list); list_del_rcu(&ha->list);
call_rcu(&ha->rcu_head, ha_rcu_free); call_rcu(&ha->rcu_head, ha_rcu_free);
} }
list->count = 0;
}
static void __hw_addr_init(struct netdev_hw_addr_list *list)
{
INIT_LIST_HEAD(&list->list);
list->count = 0;
} }
/* Device addresses handling functions */ /* Device addresses handling functions */
@ -3648,7 +3647,7 @@ static void dev_addr_flush(struct net_device *dev)
{ {
/* rtnl_mutex must be held here */ /* rtnl_mutex must be held here */
__hw_addr_flush(&dev->dev_addr_list); __hw_addr_flush(&dev->dev_addrs);
dev->dev_addr = NULL; dev->dev_addr = NULL;
} }
@ -3660,16 +3659,16 @@ static int dev_addr_init(struct net_device *dev)
/* rtnl_mutex must be held here */ /* rtnl_mutex must be held here */
INIT_LIST_HEAD(&dev->dev_addr_list); __hw_addr_init(&dev->dev_addrs);
memset(addr, 0, sizeof(addr)); memset(addr, 0, sizeof(addr));
err = __hw_addr_add(&dev->dev_addr_list, NULL, addr, sizeof(addr), err = __hw_addr_add(&dev->dev_addrs, addr, sizeof(addr),
NETDEV_HW_ADDR_T_LAN); NETDEV_HW_ADDR_T_LAN);
if (!err) { if (!err) {
/* /*
* Get the first (previously created) address from the list * Get the first (previously created) address from the list
* and set dev_addr pointer to this location. * and set dev_addr pointer to this location.
*/ */
ha = list_first_entry(&dev->dev_addr_list, ha = list_first_entry(&dev->dev_addrs.list,
struct netdev_hw_addr, list); struct netdev_hw_addr, list);
dev->dev_addr = ha->addr; dev->dev_addr = ha->addr;
} }
@ -3694,8 +3693,7 @@ int dev_addr_add(struct net_device *dev, unsigned char *addr,
ASSERT_RTNL(); ASSERT_RTNL();
err = __hw_addr_add(&dev->dev_addr_list, NULL, addr, dev->addr_len, err = __hw_addr_add(&dev->dev_addrs, addr, dev->addr_len, addr_type);
addr_type);
if (!err) if (!err)
call_netdevice_notifiers(NETDEV_CHANGEADDR, dev); call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
return err; return err;
@ -3725,11 +3723,12 @@ int dev_addr_del(struct net_device *dev, unsigned char *addr,
* We can not remove the first address from the list because * We can not remove the first address from the list because
* dev->dev_addr points to that. * dev->dev_addr points to that.
*/ */
ha = list_first_entry(&dev->dev_addr_list, struct netdev_hw_addr, list); ha = list_first_entry(&dev->dev_addrs.list,
struct netdev_hw_addr, list);
if (ha->addr == dev->dev_addr && ha->refcount == 1) if (ha->addr == dev->dev_addr && ha->refcount == 1)
return -ENOENT; return -ENOENT;
err = __hw_addr_del(&dev->dev_addr_list, NULL, addr, dev->addr_len, err = __hw_addr_del(&dev->dev_addrs, addr, dev->addr_len,
addr_type); addr_type);
if (!err) if (!err)
call_netdevice_notifiers(NETDEV_CHANGEADDR, dev); call_netdevice_notifiers(NETDEV_CHANGEADDR, dev);
@ -3757,8 +3756,7 @@ int dev_addr_add_multiple(struct net_device *to_dev,
if (from_dev->addr_len != to_dev->addr_len) if (from_dev->addr_len != to_dev->addr_len)
return -EINVAL; return -EINVAL;
err = __hw_addr_add_multiple(&to_dev->dev_addr_list, NULL, err = __hw_addr_add_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
&from_dev->dev_addr_list,
to_dev->addr_len, addr_type); to_dev->addr_len, addr_type);
if (!err) if (!err)
call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev); call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
@ -3784,15 +3782,14 @@ int dev_addr_del_multiple(struct net_device *to_dev,
if (from_dev->addr_len != to_dev->addr_len) if (from_dev->addr_len != to_dev->addr_len)
return -EINVAL; return -EINVAL;
__hw_addr_del_multiple(&to_dev->dev_addr_list, NULL, __hw_addr_del_multiple(&to_dev->dev_addrs, &from_dev->dev_addrs,
&from_dev->dev_addr_list,
to_dev->addr_len, addr_type); to_dev->addr_len, addr_type);
call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev); call_netdevice_notifiers(NETDEV_CHANGEADDR, to_dev);
return 0; return 0;
} }
EXPORT_SYMBOL(dev_addr_del_multiple); EXPORT_SYMBOL(dev_addr_del_multiple);
/* unicast and multicast addresses handling functions */ /* multicast addresses handling functions */
int __dev_addr_delete(struct dev_addr_list **list, int *count, int __dev_addr_delete(struct dev_addr_list **list, int *count,
void *addr, int alen, int glbl) void *addr, int alen, int glbl)
@ -3868,8 +3865,8 @@ int dev_unicast_delete(struct net_device *dev, void *addr)
ASSERT_RTNL(); ASSERT_RTNL();
err = __hw_addr_del(&dev->uc_list, &dev->uc_count, addr, err = __hw_addr_del(&dev->uc, addr, dev->addr_len,
dev->addr_len, NETDEV_HW_ADDR_T_UNICAST); NETDEV_HW_ADDR_T_UNICAST);
if (!err) if (!err)
__dev_set_rx_mode(dev); __dev_set_rx_mode(dev);
return err; return err;
@ -3892,8 +3889,8 @@ int dev_unicast_add(struct net_device *dev, void *addr)
ASSERT_RTNL(); ASSERT_RTNL();
err = __hw_addr_add(&dev->uc_list, &dev->uc_count, addr, err = __hw_addr_add(&dev->uc, addr, dev->addr_len,
dev->addr_len, NETDEV_HW_ADDR_T_UNICAST); NETDEV_HW_ADDR_T_UNICAST);
if (!err) if (!err)
__dev_set_rx_mode(dev); __dev_set_rx_mode(dev);
return err; return err;
@ -3966,8 +3963,7 @@ int dev_unicast_sync(struct net_device *to, struct net_device *from)
if (to->addr_len != from->addr_len) if (to->addr_len != from->addr_len)
return -EINVAL; return -EINVAL;
err = __hw_addr_sync(&to->uc_list, &to->uc_count, err = __hw_addr_sync(&to->uc, &from->uc, to->addr_len);
&from->uc_list, &from->uc_count, to->addr_len);
if (!err) if (!err)
__dev_set_rx_mode(to); __dev_set_rx_mode(to);
return err; return err;
@ -3990,8 +3986,7 @@ void dev_unicast_unsync(struct net_device *to, struct net_device *from)
if (to->addr_len != from->addr_len) if (to->addr_len != from->addr_len)
return; return;
__hw_addr_unsync(&to->uc_list, &to->uc_count, __hw_addr_unsync(&to->uc, &from->uc, to->addr_len);
&from->uc_list, &from->uc_count, to->addr_len);
__dev_set_rx_mode(to); __dev_set_rx_mode(to);
} }
EXPORT_SYMBOL(dev_unicast_unsync); EXPORT_SYMBOL(dev_unicast_unsync);
@ -4000,15 +3995,14 @@ static void dev_unicast_flush(struct net_device *dev)
{ {
/* rtnl_mutex must be held here */ /* rtnl_mutex must be held here */
__hw_addr_flush(&dev->uc_list); __hw_addr_flush(&dev->uc);
dev->uc_count = 0;
} }
static void dev_unicast_init(struct net_device *dev) static void dev_unicast_init(struct net_device *dev)
{ {
/* rtnl_mutex must be held here */ /* rtnl_mutex must be held here */
INIT_LIST_HEAD(&dev->uc_list); __hw_addr_init(&dev->uc);
} }