forked from Minki/linux
a0a400d79e
The method drivers currently use to synchronize multicast lists is not very pretty: - walk the multicast list - search each entry on a copy of the previous list - if new add to lower device - walk the copy of the previous list - search each entry on the current list - if removed delete from lower device - copy entire list This patch adds a new field to struct dev_addr_list to store the synchronization state and adds two helper functions for synchronization and cleanup. Signed-off-by: Patrick McHardy <kaber@trash.net> Signed-off-by: David S. Miller <davem@davemloft.net>
268 lines
6.3 KiB
C
268 lines
6.3 KiB
C
/*
|
|
* Linux NET3: Multicast List maintenance.
|
|
*
|
|
* Authors:
|
|
* Tim Kordas <tjk@nostromo.eeap.cwru.edu>
|
|
* Richard Underwood <richard@wuzz.demon.co.uk>
|
|
*
|
|
* Stir fried together from the IP multicast and CAP patches above
|
|
* Alan Cox <Alan.Cox@linux.org>
|
|
*
|
|
* Fixes:
|
|
* Alan Cox : Update the device on a real delete
|
|
* rather than any time but...
|
|
* Alan Cox : IFF_ALLMULTI support.
|
|
* Alan Cox : New format set_multicast_list() calls.
|
|
* Gleb Natapov : Remove dev_mc_lock.
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation; either version
|
|
* 2 of the License, or (at your option) any later version.
|
|
*/
|
|
|
|
#include <linux/module.h>
|
|
#include <asm/uaccess.h>
|
|
#include <asm/system.h>
|
|
#include <linux/bitops.h>
|
|
#include <linux/types.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/string.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/socket.h>
|
|
#include <linux/sockios.h>
|
|
#include <linux/in.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/if_ether.h>
|
|
#include <linux/inet.h>
|
|
#include <linux/netdevice.h>
|
|
#include <linux/etherdevice.h>
|
|
#include <linux/proc_fs.h>
|
|
#include <linux/seq_file.h>
|
|
#include <linux/init.h>
|
|
#include <net/ip.h>
|
|
#include <net/route.h>
|
|
#include <linux/skbuff.h>
|
|
#include <net/sock.h>
|
|
#include <net/arp.h>
|
|
|
|
|
|
/*
|
|
* Device multicast list maintenance.
|
|
*
|
|
* This is used both by IP and by the user level maintenance functions.
|
|
* Unlike BSD we maintain a usage count on a given multicast address so
|
|
* that a casual user application can add/delete multicasts used by
|
|
* protocols without doing damage to the protocols when it deletes the
|
|
* entries. It also helps IP as it tracks overlapping maps.
|
|
*
|
|
* Device mc lists are changed by bh at least if IPv6 is enabled,
|
|
* so that it must be bh protected.
|
|
*
|
|
* We block accesses to device mc filters with netif_tx_lock.
|
|
*/
|
|
|
|
/*
|
|
* Delete a device level multicast
|
|
*/
|
|
|
|
int dev_mc_delete(struct net_device *dev, void *addr, int alen, int glbl)
|
|
{
|
|
int err;
|
|
|
|
netif_tx_lock_bh(dev);
|
|
err = __dev_addr_delete(&dev->mc_list, &dev->mc_count,
|
|
addr, alen, glbl);
|
|
if (!err) {
|
|
/*
|
|
* We have altered the list, so the card
|
|
* loaded filter is now wrong. Fix it
|
|
*/
|
|
|
|
__dev_set_rx_mode(dev);
|
|
}
|
|
netif_tx_unlock_bh(dev);
|
|
return err;
|
|
}
|
|
|
|
/*
|
|
* Add a device level multicast
|
|
*/
|
|
|
|
int dev_mc_add(struct net_device *dev, void *addr, int alen, int glbl)
|
|
{
|
|
int err;
|
|
|
|
netif_tx_lock_bh(dev);
|
|
err = __dev_addr_add(&dev->mc_list, &dev->mc_count, addr, alen, glbl);
|
|
if (!err)
|
|
__dev_set_rx_mode(dev);
|
|
netif_tx_unlock_bh(dev);
|
|
return err;
|
|
}
|
|
|
|
/**
|
|
* 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_tx_lock_bh.
|
|
*
|
|
* This function is intended to be called from the dev->set_multicast_list
|
|
* function of layered software devices.
|
|
*/
|
|
int dev_mc_sync(struct net_device *to, struct net_device *from)
|
|
{
|
|
struct dev_addr_list *da;
|
|
int err = 0;
|
|
|
|
netif_tx_lock_bh(to);
|
|
for (da = from->mc_list; da != NULL; da = da->next) {
|
|
if (!da->da_synced) {
|
|
err = __dev_addr_add(&to->mc_list, &to->mc_count,
|
|
da->da_addr, da->da_addrlen, 0);
|
|
if (err < 0)
|
|
break;
|
|
da->da_synced = 1;
|
|
da->da_users++;
|
|
} else if (da->da_users == 1) {
|
|
__dev_addr_delete(&to->mc_list, &to->mc_count,
|
|
da->da_addr, da->da_addrlen, 0);
|
|
__dev_addr_delete(&from->mc_list, &from->mc_count,
|
|
da->da_addr, da->da_addrlen, 0);
|
|
}
|
|
}
|
|
if (!err)
|
|
__dev_set_rx_mode(to);
|
|
netif_tx_unlock_bh(to);
|
|
|
|
return err;
|
|
}
|
|
EXPORT_SYMBOL(dev_mc_sync);
|
|
|
|
|
|
/**
|
|
* 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)
|
|
{
|
|
struct dev_addr_list *da;
|
|
|
|
netif_tx_lock_bh(from);
|
|
netif_tx_lock_bh(to);
|
|
|
|
for (da = from->mc_list; da != NULL; da = da->next) {
|
|
if (!da->da_synced)
|
|
continue;
|
|
__dev_addr_delete(&to->mc_list, &to->mc_count,
|
|
da->da_addr, da->da_addrlen, 0);
|
|
da->da_synced = 0;
|
|
__dev_addr_delete(&from->mc_list, &from->mc_count,
|
|
da->da_addr, da->da_addrlen, 0);
|
|
}
|
|
__dev_set_rx_mode(to);
|
|
|
|
netif_tx_unlock_bh(to);
|
|
netif_tx_unlock_bh(from);
|
|
}
|
|
EXPORT_SYMBOL(dev_mc_unsync);
|
|
|
|
/*
|
|
* Discard multicast list when a device is downed
|
|
*/
|
|
|
|
void dev_mc_discard(struct net_device *dev)
|
|
{
|
|
netif_tx_lock_bh(dev);
|
|
__dev_addr_discard(&dev->mc_list);
|
|
dev->mc_count = 0;
|
|
netif_tx_unlock_bh(dev);
|
|
}
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
static void *dev_mc_seq_start(struct seq_file *seq, loff_t *pos)
|
|
{
|
|
struct net_device *dev;
|
|
loff_t off = 0;
|
|
|
|
read_lock(&dev_base_lock);
|
|
for_each_netdev(dev) {
|
|
if (off++ == *pos)
|
|
return dev;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static void *dev_mc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
|
{
|
|
++*pos;
|
|
return next_net_device((struct net_device *)v);
|
|
}
|
|
|
|
static void dev_mc_seq_stop(struct seq_file *seq, void *v)
|
|
{
|
|
read_unlock(&dev_base_lock);
|
|
}
|
|
|
|
|
|
static int dev_mc_seq_show(struct seq_file *seq, void *v)
|
|
{
|
|
struct dev_addr_list *m;
|
|
struct net_device *dev = v;
|
|
|
|
netif_tx_lock_bh(dev);
|
|
for (m = dev->mc_list; m; m = m->next) {
|
|
int i;
|
|
|
|
seq_printf(seq, "%-4d %-15s %-5d %-5d ", dev->ifindex,
|
|
dev->name, m->dmi_users, m->dmi_gusers);
|
|
|
|
for (i = 0; i < m->dmi_addrlen; i++)
|
|
seq_printf(seq, "%02x", m->dmi_addr[i]);
|
|
|
|
seq_putc(seq, '\n');
|
|
}
|
|
netif_tx_unlock_bh(dev);
|
|
return 0;
|
|
}
|
|
|
|
static const struct seq_operations dev_mc_seq_ops = {
|
|
.start = dev_mc_seq_start,
|
|
.next = dev_mc_seq_next,
|
|
.stop = dev_mc_seq_stop,
|
|
.show = dev_mc_seq_show,
|
|
};
|
|
|
|
static int dev_mc_seq_open(struct inode *inode, struct file *file)
|
|
{
|
|
return seq_open(file, &dev_mc_seq_ops);
|
|
}
|
|
|
|
static const struct file_operations dev_mc_seq_fops = {
|
|
.owner = THIS_MODULE,
|
|
.open = dev_mc_seq_open,
|
|
.read = seq_read,
|
|
.llseek = seq_lseek,
|
|
.release = seq_release,
|
|
};
|
|
|
|
#endif
|
|
|
|
void __init dev_mcast_init(void)
|
|
{
|
|
proc_net_fops_create("dev_mcast", 0, &dev_mc_seq_fops);
|
|
}
|
|
|
|
EXPORT_SYMBOL(dev_mc_add);
|
|
EXPORT_SYMBOL(dev_mc_delete);
|