2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* IP multicast routing support for mrouted 3.6/3.8
|
|
|
|
*
|
2008-10-13 20:01:08 -06:00
|
|
|
* (c) 1995 Alan Cox, <alan@lxorguk.ukuu.org.uk>
|
2005-04-16 16:20:36 -06:00
|
|
|
* Linux Consultancy and Custom Driver Development
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* Fixes:
|
|
|
|
* Michael Chastain : Incorrect size of copying.
|
|
|
|
* Alan Cox : Added the cache manager code
|
|
|
|
* Alan Cox : Fixed the clone/copy bug and device race.
|
|
|
|
* Mike McLagan : Routing by source
|
|
|
|
* Malcolm Beattie : Buffer handling fixes.
|
|
|
|
* Alexey Kuznetsov : Double buffer free and other fixes.
|
|
|
|
* SVR Anand : Fixed several multicast bugs and problems.
|
|
|
|
* Alexey Kuznetsov : Status, optimisations and more.
|
|
|
|
* Brad Parker : Better behaviour on mrouted upcall
|
|
|
|
* overflow.
|
|
|
|
* Carlos Picoto : PIMv1 Support
|
|
|
|
* Pavlin Ivanov Radoslavov: PIMv2 Registers must checksum only PIM header
|
2010-03-29 07:41:47 -06:00
|
|
|
* Relax this requirement to work with older peers.
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <linux/types.h>
|
2006-01-11 13:17:47 -07:00
|
|
|
#include <linux/capability.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/timer.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/fcntl.h>
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/socket.h>
|
|
|
|
#include <linux/in.h>
|
|
|
|
#include <linux/inet.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/inetdevice.h>
|
|
|
|
#include <linux/igmp.h>
|
|
|
|
#include <linux/proc_fs.h>
|
|
|
|
#include <linux/seq_file.h>
|
|
|
|
#include <linux/mroute.h>
|
|
|
|
#include <linux/init.h>
|
2006-01-05 17:35:42 -07:00
|
|
|
#include <linux/if_ether.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2007-09-12 04:01:34 -06:00
|
|
|
#include <net/net_namespace.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <net/ip.h>
|
|
|
|
#include <net/protocol.h>
|
|
|
|
#include <linux/skbuff.h>
|
2005-12-26 21:43:12 -07:00
|
|
|
#include <net/route.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <net/sock.h>
|
|
|
|
#include <net/icmp.h>
|
|
|
|
#include <net/udp.h>
|
|
|
|
#include <net/raw.h>
|
|
|
|
#include <linux/notifier.h>
|
|
|
|
#include <linux/if_arp.h>
|
|
|
|
#include <linux/netfilter_ipv4.h>
|
2011-01-29 09:15:56 -07:00
|
|
|
#include <linux/compat.h>
|
2011-07-15 09:47:34 -06:00
|
|
|
#include <linux/export.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <net/ipip.h>
|
|
|
|
#include <net/checksum.h>
|
2007-03-26 00:06:12 -06:00
|
|
|
#include <net/netlink.h>
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
#include <net/fib_rules.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
|
|
|
|
#define CONFIG_IP_PIMSM 1
|
|
|
|
#endif
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
struct mr_table {
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct list_head list;
|
2010-04-15 05:29:28 -06:00
|
|
|
#ifdef CONFIG_NET_NS
|
|
|
|
struct net *net;
|
|
|
|
#endif
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
u32 id;
|
2010-10-01 10:15:01 -06:00
|
|
|
struct sock __rcu *mroute_sk;
|
2010-04-12 23:03:22 -06:00
|
|
|
struct timer_list ipmr_expire_timer;
|
|
|
|
struct list_head mfc_unres_queue;
|
|
|
|
struct list_head mfc_cache_array[MFC_LINES];
|
|
|
|
struct vif_device vif_table[MAXVIFS];
|
|
|
|
int maxvif;
|
|
|
|
atomic_t cache_resolve_queue_len;
|
|
|
|
int mroute_do_assert;
|
|
|
|
int mroute_do_pim;
|
|
|
|
#if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
|
|
|
|
int mroute_reg_vif_num;
|
|
|
|
#endif
|
|
|
|
};
|
|
|
|
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct ipmr_rule {
|
|
|
|
struct fib_rule common;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ipmr_result {
|
|
|
|
struct mr_table *mrt;
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Big lock, protecting vif table, mrt cache and mroute socket state.
|
2010-10-01 10:15:29 -06:00
|
|
|
* Note that the changes are semaphored via rtnl_lock.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
static DEFINE_RWLOCK(mrt_lock);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Multicast router control variables
|
|
|
|
*/
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
#define VIF_EXISTS(_mrt, _idx) ((_mrt)->vif_table[_idx].dev != NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Special spinlock for queue of unresolved entries */
|
|
|
|
static DEFINE_SPINLOCK(mfc_unres_lock);
|
|
|
|
|
|
|
|
/* We return to original Alan's scheme. Hash table of resolved
|
2010-10-01 10:15:29 -06:00
|
|
|
* entries is changed only in process context and protected
|
|
|
|
* with weak lock mrt_lock. Queue of unresolved entries is protected
|
|
|
|
* with strong spinlock mfc_unres_lock.
|
|
|
|
*
|
|
|
|
* In this case data path is free of exclusive locks at all.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2006-12-06 21:33:20 -07:00
|
|
|
static struct kmem_cache *mrt_cachep __read_mostly;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
static struct mr_table *ipmr_new_table(struct net *net, u32 id);
|
2010-04-12 23:03:22 -06:00
|
|
|
static int ip_mr_forward(struct net *net, struct mr_table *mrt,
|
|
|
|
struct sk_buff *skb, struct mfc_cache *cache,
|
|
|
|
int local);
|
|
|
|
static int ipmr_cache_report(struct mr_table *mrt,
|
2009-01-21 21:56:23 -07:00
|
|
|
struct sk_buff *pkt, vifi_t vifi, int assert);
|
2010-04-26 08:02:08 -06:00
|
|
|
static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
|
|
|
|
struct mfc_cache *c, struct rtmsg *rtm);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
static void ipmr_expire_process(unsigned long arg);
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
|
|
|
|
#define ipmr_for_each_table(mrt, net) \
|
|
|
|
list_for_each_entry_rcu(mrt, &net->ipv4.mr_tables, list)
|
|
|
|
|
|
|
|
static struct mr_table *ipmr_get_table(struct net *net, u32 id)
|
|
|
|
{
|
|
|
|
struct mr_table *mrt;
|
|
|
|
|
|
|
|
ipmr_for_each_table(mrt, net) {
|
|
|
|
if (mrt->id == id)
|
|
|
|
return mrt;
|
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-03-12 00:04:50 -07:00
|
|
|
static int ipmr_fib_lookup(struct net *net, struct flowi4 *flp4,
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table **mrt)
|
|
|
|
{
|
|
|
|
struct ipmr_result res;
|
|
|
|
struct fib_lookup_arg arg = { .result = &res, };
|
|
|
|
int err;
|
|
|
|
|
2011-03-12 00:04:50 -07:00
|
|
|
err = fib_rules_lookup(net->ipv4.mr_rules_ops,
|
|
|
|
flowi4_to_flowi(flp4), 0, &arg);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
*mrt = res.mrt;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ipmr_rule_action(struct fib_rule *rule, struct flowi *flp,
|
|
|
|
int flags, struct fib_lookup_arg *arg)
|
|
|
|
{
|
|
|
|
struct ipmr_result *res = arg->result;
|
|
|
|
struct mr_table *mrt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
switch (rule->action) {
|
|
|
|
case FR_ACT_TO_TBL:
|
|
|
|
break;
|
|
|
|
case FR_ACT_UNREACHABLE:
|
|
|
|
return -ENETUNREACH;
|
|
|
|
case FR_ACT_PROHIBIT:
|
|
|
|
return -EACCES;
|
|
|
|
case FR_ACT_BLACKHOLE:
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
mrt = ipmr_get_table(rule->fr_net, rule->table);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return -EAGAIN;
|
|
|
|
res->mrt = mrt;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ipmr_rule_match(struct fib_rule *rule, struct flowi *fl, int flags)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct nla_policy ipmr_rule_policy[FRA_MAX + 1] = {
|
|
|
|
FRA_GENERIC_POLICY,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int ipmr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
|
|
|
|
struct fib_rule_hdr *frh, struct nlattr **tb)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ipmr_rule_compare(struct fib_rule *rule, struct fib_rule_hdr *frh,
|
|
|
|
struct nlattr **tb)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ipmr_rule_fill(struct fib_rule *rule, struct sk_buff *skb,
|
|
|
|
struct fib_rule_hdr *frh)
|
|
|
|
{
|
|
|
|
frh->dst_len = 0;
|
|
|
|
frh->src_len = 0;
|
|
|
|
frh->tos = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-04-26 08:02:04 -06:00
|
|
|
static const struct fib_rules_ops __net_initdata ipmr_rules_ops_template = {
|
2010-04-26 08:02:05 -06:00
|
|
|
.family = RTNL_FAMILY_IPMR,
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
.rule_size = sizeof(struct ipmr_rule),
|
|
|
|
.addr_size = sizeof(u32),
|
|
|
|
.action = ipmr_rule_action,
|
|
|
|
.match = ipmr_rule_match,
|
|
|
|
.configure = ipmr_rule_configure,
|
|
|
|
.compare = ipmr_rule_compare,
|
|
|
|
.default_pref = fib_default_rule_pref,
|
|
|
|
.fill = ipmr_rule_fill,
|
|
|
|
.nlgroup = RTNLGRP_IPV4_RULE,
|
|
|
|
.policy = ipmr_rule_policy,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int __net_init ipmr_rules_init(struct net *net)
|
|
|
|
{
|
|
|
|
struct fib_rules_ops *ops;
|
|
|
|
struct mr_table *mrt;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
ops = fib_rules_register(&ipmr_rules_ops_template, net);
|
|
|
|
if (IS_ERR(ops))
|
|
|
|
return PTR_ERR(ops);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&net->ipv4.mr_tables);
|
|
|
|
|
|
|
|
mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
|
|
|
|
if (mrt == NULL) {
|
|
|
|
err = -ENOMEM;
|
|
|
|
goto err1;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = fib_default_rule_add(ops, 0x7fff, RT_TABLE_DEFAULT, 0);
|
|
|
|
if (err < 0)
|
|
|
|
goto err2;
|
|
|
|
|
|
|
|
net->ipv4.mr_rules_ops = ops;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err2:
|
|
|
|
kfree(mrt);
|
|
|
|
err1:
|
|
|
|
fib_rules_unregister(ops);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit ipmr_rules_exit(struct net *net)
|
|
|
|
{
|
|
|
|
struct mr_table *mrt, *next;
|
|
|
|
|
2010-06-06 17:48:40 -06:00
|
|
|
list_for_each_entry_safe(mrt, next, &net->ipv4.mr_tables, list) {
|
|
|
|
list_del(&mrt->list);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
kfree(mrt);
|
2010-06-06 17:48:40 -06:00
|
|
|
}
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
fib_rules_unregister(net->ipv4.mr_rules_ops);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
#define ipmr_for_each_table(mrt, net) \
|
|
|
|
for (mrt = net->ipv4.mrt; mrt; mrt = NULL)
|
|
|
|
|
|
|
|
static struct mr_table *ipmr_get_table(struct net *net, u32 id)
|
|
|
|
{
|
|
|
|
return net->ipv4.mrt;
|
|
|
|
}
|
|
|
|
|
2011-03-12 00:04:50 -07:00
|
|
|
static int ipmr_fib_lookup(struct net *net, struct flowi4 *flp4,
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table **mrt)
|
|
|
|
{
|
|
|
|
*mrt = net->ipv4.mrt;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __net_init ipmr_rules_init(struct net *net)
|
|
|
|
{
|
|
|
|
net->ipv4.mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
|
|
|
|
return net->ipv4.mrt ? 0 : -ENOMEM;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit ipmr_rules_exit(struct net *net)
|
|
|
|
{
|
|
|
|
kfree(net->ipv4.mrt);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static struct mr_table *ipmr_new_table(struct net *net, u32 id)
|
|
|
|
{
|
|
|
|
struct mr_table *mrt;
|
|
|
|
unsigned int i;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
mrt = ipmr_get_table(net, id);
|
|
|
|
if (mrt != NULL)
|
|
|
|
return mrt;
|
|
|
|
|
|
|
|
mrt = kzalloc(sizeof(*mrt), GFP_KERNEL);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return NULL;
|
2010-04-15 05:29:28 -06:00
|
|
|
write_pnet(&mrt->net, net);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
mrt->id = id;
|
|
|
|
|
|
|
|
/* Forwarding cache */
|
|
|
|
for (i = 0; i < MFC_LINES; i++)
|
|
|
|
INIT_LIST_HEAD(&mrt->mfc_cache_array[i]);
|
|
|
|
|
|
|
|
INIT_LIST_HEAD(&mrt->mfc_unres_queue);
|
|
|
|
|
|
|
|
setup_timer(&mrt->ipmr_expire_timer, ipmr_expire_process,
|
|
|
|
(unsigned long)mrt);
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_PIMSM
|
|
|
|
mrt->mroute_reg_vif_num = -1;
|
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
|
|
|
|
list_add_tail_rcu(&mrt->list, &net->ipv4.mr_tables);
|
|
|
|
#endif
|
|
|
|
return mrt;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
|
|
|
|
|
2008-07-14 21:55:26 -06:00
|
|
|
static void ipmr_del_tunnel(struct net_device *dev, struct vifctl *v)
|
|
|
|
{
|
2009-01-21 21:56:23 -07:00
|
|
|
struct net *net = dev_net(dev);
|
|
|
|
|
2008-07-14 21:55:26 -06:00
|
|
|
dev_close(dev);
|
|
|
|
|
2009-01-21 21:56:23 -07:00
|
|
|
dev = __dev_get_by_name(net, "tunl0");
|
2008-07-14 21:55:26 -06:00
|
|
|
if (dev) {
|
2008-11-19 22:52:05 -07:00
|
|
|
const struct net_device_ops *ops = dev->netdev_ops;
|
2008-07-14 21:55:26 -06:00
|
|
|
struct ifreq ifr;
|
|
|
|
struct ip_tunnel_parm p;
|
|
|
|
|
|
|
|
memset(&p, 0, sizeof(p));
|
|
|
|
p.iph.daddr = v->vifc_rmt_addr.s_addr;
|
|
|
|
p.iph.saddr = v->vifc_lcl_addr.s_addr;
|
|
|
|
p.iph.version = 4;
|
|
|
|
p.iph.ihl = 5;
|
|
|
|
p.iph.protocol = IPPROTO_IPIP;
|
|
|
|
sprintf(p.name, "dvmrp%d", v->vifc_vifi);
|
|
|
|
ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
|
|
|
|
|
2008-11-19 22:52:05 -07:00
|
|
|
if (ops->ndo_do_ioctl) {
|
|
|
|
mm_segment_t oldfs = get_fs();
|
|
|
|
|
|
|
|
set_fs(KERNEL_DS);
|
|
|
|
ops->ndo_do_ioctl(dev, &ifr, SIOCDELTUNNEL);
|
|
|
|
set_fs(oldfs);
|
|
|
|
}
|
2008-07-14 21:55:26 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static
|
2009-01-21 21:56:23 -07:00
|
|
|
struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct net_device *dev;
|
|
|
|
|
2009-01-21 21:56:23 -07:00
|
|
|
dev = __dev_get_by_name(net, "tunl0");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (dev) {
|
2008-11-19 22:52:05 -07:00
|
|
|
const struct net_device_ops *ops = dev->netdev_ops;
|
2005-04-16 16:20:36 -06:00
|
|
|
int err;
|
|
|
|
struct ifreq ifr;
|
|
|
|
struct ip_tunnel_parm p;
|
|
|
|
struct in_device *in_dev;
|
|
|
|
|
|
|
|
memset(&p, 0, sizeof(p));
|
|
|
|
p.iph.daddr = v->vifc_rmt_addr.s_addr;
|
|
|
|
p.iph.saddr = v->vifc_lcl_addr.s_addr;
|
|
|
|
p.iph.version = 4;
|
|
|
|
p.iph.ihl = 5;
|
|
|
|
p.iph.protocol = IPPROTO_IPIP;
|
|
|
|
sprintf(p.name, "dvmrp%d", v->vifc_vifi);
|
2008-01-21 18:28:59 -07:00
|
|
|
ifr.ifr_ifru.ifru_data = (__force void __user *)&p;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-11-19 22:52:05 -07:00
|
|
|
if (ops->ndo_do_ioctl) {
|
|
|
|
mm_segment_t oldfs = get_fs();
|
|
|
|
|
|
|
|
set_fs(KERNEL_DS);
|
|
|
|
err = ops->ndo_do_ioctl(dev, &ifr, SIOCADDTUNNEL);
|
|
|
|
set_fs(oldfs);
|
2010-10-01 10:15:29 -06:00
|
|
|
} else {
|
2008-11-19 22:52:05 -07:00
|
|
|
err = -EOPNOTSUPP;
|
2010-10-01 10:15:29 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
dev = NULL;
|
|
|
|
|
2009-01-21 21:56:23 -07:00
|
|
|
if (err == 0 &&
|
|
|
|
(dev = __dev_get_by_name(net, p.name)) != NULL) {
|
2005-04-16 16:20:36 -06:00
|
|
|
dev->flags |= IFF_MULTICAST;
|
|
|
|
|
2005-10-03 15:35:55 -06:00
|
|
|
in_dev = __in_dev_get_rtnl(dev);
|
2007-06-05 00:36:06 -06:00
|
|
|
if (in_dev == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto failure;
|
2007-06-05 00:36:06 -06:00
|
|
|
|
|
|
|
ipv4_devconf_setall(in_dev);
|
|
|
|
IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (dev_open(dev))
|
|
|
|
goto failure;
|
ipv4: Fix ipmr unregister device oops
An oops happens during device unregister.
The following oops happened when I add two tunnels, which
use a same device, and then delete one tunnel.
Obviously deleting tunnel "A" causes device unregister, which
send a notification, and after receiving notification, ipmr do
unregister again for tunnel "B" which also use same device.
That is wrong.
After receiving notification, ipmr only needs to decrease reference
count and don't do duplicated unregister.
Fortunately, IPv6 side doesn't add tunnel in ip6mr, so it's clean.
This patch fixs:
- unregister device oops
- using after dev_put()
Here is the oops:
===
Jul 11 15:39:29 wangchen kernel: ------------[ cut here ]------------
Jul 11 15:39:29 wangchen kernel: kernel BUG at net/core/dev.c:3651!
Jul 11 15:39:29 wangchen kernel: invalid opcode: 0000 [#1]
Jul 11 15:39:29 wangchen kernel: Modules linked in: ipip tunnel4 nfsd lockd nfs_acl auth_rpcgss sunrpc exportfs ipv6 snd_pcm_oss snd_mixer_oss snd_seq snd_seq_device af_packet binfmt_misc button battery ac loop dm_mod usbhid ff_memless pcmcia firmware_class ohci1394 8139too mii ieee1394 yenta_socket rsrc_nonstatic pcmcia_core ide_cd_mod cdrom snd_intel8x0 snd_ac97_codec ac97_bus snd_pcm i2c_i801 snd_timer snd i2c_core soundcore snd_page_alloc rng_core shpchp ehci_hcd uhci_hcd pci_hotplug intel_agp agpgart usbcore ext3 jbd ata_piix ahci libata dock edd fan thermal processor thermal_sys piix sd_mod scsi_mod ide_disk ide_core [last unloaded: freq_table]
Jul 11 15:39:29 wangchen kernel:
Jul 11 15:39:29 wangchen kernel: Pid: 4102, comm: mroute Not tainted (2.6.26-rc9-default #69)
Jul 11 15:39:29 wangchen kernel: EIP: 0060:[<c024636b>] EFLAGS: 00010202 CPU: 0
Jul 11 15:39:29 wangchen kernel: EIP is at rollback_registered+0x61/0xe3
Jul 11 15:39:29 wangchen kernel: EAX: 00000001 EBX: ecba6000 ECX: 00000000 EDX: ffffffff
Jul 11 15:39:29 wangchen kernel: ESI: 00000001 EDI: ecba6000 EBP: c03de2e8 ESP: ed8e7c3c
Jul 11 15:39:29 wangchen kernel: DS: 007b ES: 007b FS: 0000 GS: 0033 SS: 0068
Jul 11 15:39:29 wangchen kernel: Process mroute (pid: 4102, ti=ed8e6000 task=ed41e830 task.ti=ed8e6000)
Jul 11 15:39:29 wangchen kernel: Stack: ecba6000 c024641c 00000028 c0284e1a 00000001 c03de2e8 ecba6000 eecff360
Jul 11 15:39:29 wangchen kernel: c0284e4c c03536f4 fffffff8 00000000 c029a819 ecba6000 00000006 ecba6000
Jul 11 15:39:29 wangchen kernel: 00000000 ecba6000 c03de2c0 c012841b ffffffff 00000000 c024639f ecba6000
Jul 11 15:39:29 wangchen kernel: Call Trace:
Jul 11 15:39:29 wangchen kernel: [<c024641c>] unregister_netdevice+0x2f/0x51
Jul 11 15:39:29 wangchen kernel: [<c0284e1a>] vif_delete+0xaf/0xc3
Jul 11 15:39:29 wangchen kernel: [<c0284e4c>] ipmr_device_event+0x1e/0x30
Jul 11 15:39:29 wangchen kernel: [<c029a819>] notifier_call_chain+0x2a/0x47
Jul 11 15:39:29 wangchen kernel: [<c012841b>] raw_notifier_call_chain+0x9/0xc
Jul 11 15:39:29 wangchen kernel: [<c024639f>] rollback_registered+0x95/0xe3
Jul 11 15:39:29 wangchen kernel: [<c024641c>] unregister_netdevice+0x2f/0x51
Jul 11 15:39:29 wangchen kernel: [<c0284e1a>] vif_delete+0xaf/0xc3
Jul 11 15:39:29 wangchen kernel: [<c0285eee>] ip_mroute_setsockopt+0x47a/0x801
Jul 11 15:39:29 wangchen kernel: [<eea5a70c>] do_get_write_access+0x2df/0x313 [jbd]
Jul 11 15:39:29 wangchen kernel: [<c01727c4>] __find_get_block_slow+0xda/0xe4
Jul 11 15:39:29 wangchen kernel: [<c0172a7f>] __find_get_block+0xf8/0x122
Jul 11 15:39:29 wangchen kernel: [<c0172a7f>] __find_get_block+0xf8/0x122
Jul 11 15:39:29 wangchen kernel: [<eea5d563>] journal_cancel_revoke+0xda/0x110 [jbd]
Jul 11 15:39:29 wangchen kernel: [<c0263501>] ip_setsockopt+0xa9/0x9ee
Jul 11 15:39:29 wangchen kernel: [<eea5d563>] journal_cancel_revoke+0xda/0x110 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea5a70c>] do_get_write_access+0x2df/0x313 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea69287>] __ext3_get_inode_loc+0xcf/0x271 [ext3]
Jul 11 15:39:29 wangchen kernel: [<eea743c7>] __ext3_journal_dirty_metadata+0x13/0x32 [ext3]
Jul 11 15:39:29 wangchen kernel: [<c0116434>] __wake_up+0xf/0x15
Jul 11 15:39:29 wangchen kernel: [<eea5a424>] journal_stop+0x1bd/0x1c6 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea703a7>] __ext3_journal_stop+0x19/0x34 [ext3]
Jul 11 15:39:29 wangchen kernel: [<c014291e>] get_page_from_freelist+0x94/0x369
Jul 11 15:39:29 wangchen kernel: [<c01408f2>] filemap_fault+0x1ac/0x2fe
Jul 11 15:39:29 wangchen kernel: [<c01a605e>] security_sk_alloc+0xd/0xf
Jul 11 15:39:29 wangchen kernel: [<c023edea>] sk_prot_alloc+0x36/0x78
Jul 11 15:39:29 wangchen kernel: [<c0240037>] sk_alloc+0x3a/0x40
Jul 11 15:39:29 wangchen kernel: [<c0276062>] raw_hash_sk+0x46/0x4e
Jul 11 15:39:29 wangchen kernel: [<c0166aff>] d_alloc+0x1b/0x157
Jul 11 15:39:29 wangchen kernel: [<c023e4d1>] sock_common_setsockopt+0x12/0x16
Jul 11 15:39:29 wangchen kernel: [<c023cb1e>] sys_setsockopt+0x6f/0x8e
Jul 11 15:39:29 wangchen kernel: [<c023e105>] sys_socketcall+0x15c/0x19e
Jul 11 15:39:29 wangchen kernel: [<c0103611>] sysenter_past_esp+0x6a/0x99
Jul 11 15:39:29 wangchen kernel: [<c0290000>] unix_poll+0x69/0x78
Jul 11 15:39:29 wangchen kernel: =======================
Jul 11 15:39:29 wangchen kernel: Code: 83 e0 01 00 00 85 c0 75 1f 53 53 68 12 81 31 c0 e8 3c 30 ed ff ba 3f 0e 00 00 b8 b9 7f 31 c0 83 c4 0c 5b e9 f5 26 ed ff 48 74 04 <0f> 0b eb fe 89 d8 e8 21 ff ff ff 89 d8 e8 62 ea ff ff c7 83 e0
Jul 11 15:39:29 wangchen kernel: EIP: [<c024636b>] rollback_registered+0x61/0xe3 SS:ESP 0068:ed8e7c3c
Jul 11 15:39:29 wangchen kernel: ---[ end trace c311acf85d169786 ]---
===
Signed-off-by: Wang Chen <wangchen@cn.fujitsu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-07-14 21:56:34 -06:00
|
|
|
dev_hold(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return dev;
|
|
|
|
|
|
|
|
failure:
|
|
|
|
/* allow the register to be completed before unregistering. */
|
|
|
|
rtnl_unlock();
|
|
|
|
rtnl_lock();
|
|
|
|
|
|
|
|
unregister_netdevice(dev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_PIMSM
|
|
|
|
|
2009-08-31 13:50:41 -06:00
|
|
|
static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2009-01-21 21:56:23 -07:00
|
|
|
struct net *net = dev_net(dev);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt;
|
2011-03-12 00:04:50 -07:00
|
|
|
struct flowi4 fl4 = {
|
|
|
|
.flowi4_oif = dev->ifindex,
|
|
|
|
.flowi4_iif = skb->skb_iif,
|
|
|
|
.flowi4_mark = skb->mark,
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
};
|
|
|
|
int err;
|
|
|
|
|
2011-03-12 00:04:50 -07:00
|
|
|
err = ipmr_fib_lookup(net, &fl4, &mrt);
|
2010-07-15 07:22:33 -06:00
|
|
|
if (err < 0) {
|
|
|
|
kfree_skb(skb);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
return err;
|
2010-07-15 07:22:33 -06:00
|
|
|
}
|
2009-01-21 21:56:23 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
read_lock(&mrt_lock);
|
2008-05-21 15:17:33 -06:00
|
|
|
dev->stats.tx_bytes += skb->len;
|
|
|
|
dev->stats.tx_packets++;
|
2010-04-12 23:03:22 -06:00
|
|
|
ipmr_cache_report(mrt, skb, mrt->mroute_reg_vif_num, IGMPMSG_WHOLEPKT);
|
2005-04-16 16:20:36 -06:00
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
kfree_skb(skb);
|
2009-06-23 00:03:08 -06:00
|
|
|
return NETDEV_TX_OK;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-11-20 21:28:35 -07:00
|
|
|
static const struct net_device_ops reg_vif_netdev_ops = {
|
|
|
|
.ndo_start_xmit = reg_vif_xmit,
|
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static void reg_vif_setup(struct net_device *dev)
|
|
|
|
{
|
|
|
|
dev->type = ARPHRD_PIMREG;
|
2006-01-05 17:35:42 -07:00
|
|
|
dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8;
|
2005-04-16 16:20:36 -06:00
|
|
|
dev->flags = IFF_NOARP;
|
2008-11-20 21:28:35 -07:00
|
|
|
dev->netdev_ops = ®_vif_netdev_ops,
|
2005-04-16 16:20:36 -06:00
|
|
|
dev->destructor = free_netdev;
|
2009-06-14 04:16:13 -06:00
|
|
|
dev->features |= NETIF_F_NETNS_LOCAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct net_device *dev;
|
|
|
|
struct in_device *in_dev;
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
char name[IFNAMSIZ];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
if (mrt->id == RT_TABLE_DEFAULT)
|
|
|
|
sprintf(name, "pimreg");
|
|
|
|
else
|
|
|
|
sprintf(name, "pimreg%u", mrt->id);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
dev = alloc_netdev(0, name, reg_vif_setup);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (dev == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
2009-06-14 04:16:13 -06:00
|
|
|
dev_net_set(dev, net);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (register_netdevice(dev)) {
|
|
|
|
free_netdev(dev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
dev->iflink = 0;
|
|
|
|
|
2007-06-05 00:36:06 -06:00
|
|
|
rcu_read_lock();
|
2010-10-01 10:15:29 -06:00
|
|
|
in_dev = __in_dev_get_rcu(dev);
|
|
|
|
if (!in_dev) {
|
2007-06-05 00:36:06 -06:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
goto failure;
|
2007-06-05 00:36:06 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-06-05 00:36:06 -06:00
|
|
|
ipv4_devconf_setall(in_dev);
|
|
|
|
IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
|
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (dev_open(dev))
|
|
|
|
goto failure;
|
|
|
|
|
ipv4: Fix ipmr unregister device oops
An oops happens during device unregister.
The following oops happened when I add two tunnels, which
use a same device, and then delete one tunnel.
Obviously deleting tunnel "A" causes device unregister, which
send a notification, and after receiving notification, ipmr do
unregister again for tunnel "B" which also use same device.
That is wrong.
After receiving notification, ipmr only needs to decrease reference
count and don't do duplicated unregister.
Fortunately, IPv6 side doesn't add tunnel in ip6mr, so it's clean.
This patch fixs:
- unregister device oops
- using after dev_put()
Here is the oops:
===
Jul 11 15:39:29 wangchen kernel: ------------[ cut here ]------------
Jul 11 15:39:29 wangchen kernel: kernel BUG at net/core/dev.c:3651!
Jul 11 15:39:29 wangchen kernel: invalid opcode: 0000 [#1]
Jul 11 15:39:29 wangchen kernel: Modules linked in: ipip tunnel4 nfsd lockd nfs_acl auth_rpcgss sunrpc exportfs ipv6 snd_pcm_oss snd_mixer_oss snd_seq snd_seq_device af_packet binfmt_misc button battery ac loop dm_mod usbhid ff_memless pcmcia firmware_class ohci1394 8139too mii ieee1394 yenta_socket rsrc_nonstatic pcmcia_core ide_cd_mod cdrom snd_intel8x0 snd_ac97_codec ac97_bus snd_pcm i2c_i801 snd_timer snd i2c_core soundcore snd_page_alloc rng_core shpchp ehci_hcd uhci_hcd pci_hotplug intel_agp agpgart usbcore ext3 jbd ata_piix ahci libata dock edd fan thermal processor thermal_sys piix sd_mod scsi_mod ide_disk ide_core [last unloaded: freq_table]
Jul 11 15:39:29 wangchen kernel:
Jul 11 15:39:29 wangchen kernel: Pid: 4102, comm: mroute Not tainted (2.6.26-rc9-default #69)
Jul 11 15:39:29 wangchen kernel: EIP: 0060:[<c024636b>] EFLAGS: 00010202 CPU: 0
Jul 11 15:39:29 wangchen kernel: EIP is at rollback_registered+0x61/0xe3
Jul 11 15:39:29 wangchen kernel: EAX: 00000001 EBX: ecba6000 ECX: 00000000 EDX: ffffffff
Jul 11 15:39:29 wangchen kernel: ESI: 00000001 EDI: ecba6000 EBP: c03de2e8 ESP: ed8e7c3c
Jul 11 15:39:29 wangchen kernel: DS: 007b ES: 007b FS: 0000 GS: 0033 SS: 0068
Jul 11 15:39:29 wangchen kernel: Process mroute (pid: 4102, ti=ed8e6000 task=ed41e830 task.ti=ed8e6000)
Jul 11 15:39:29 wangchen kernel: Stack: ecba6000 c024641c 00000028 c0284e1a 00000001 c03de2e8 ecba6000 eecff360
Jul 11 15:39:29 wangchen kernel: c0284e4c c03536f4 fffffff8 00000000 c029a819 ecba6000 00000006 ecba6000
Jul 11 15:39:29 wangchen kernel: 00000000 ecba6000 c03de2c0 c012841b ffffffff 00000000 c024639f ecba6000
Jul 11 15:39:29 wangchen kernel: Call Trace:
Jul 11 15:39:29 wangchen kernel: [<c024641c>] unregister_netdevice+0x2f/0x51
Jul 11 15:39:29 wangchen kernel: [<c0284e1a>] vif_delete+0xaf/0xc3
Jul 11 15:39:29 wangchen kernel: [<c0284e4c>] ipmr_device_event+0x1e/0x30
Jul 11 15:39:29 wangchen kernel: [<c029a819>] notifier_call_chain+0x2a/0x47
Jul 11 15:39:29 wangchen kernel: [<c012841b>] raw_notifier_call_chain+0x9/0xc
Jul 11 15:39:29 wangchen kernel: [<c024639f>] rollback_registered+0x95/0xe3
Jul 11 15:39:29 wangchen kernel: [<c024641c>] unregister_netdevice+0x2f/0x51
Jul 11 15:39:29 wangchen kernel: [<c0284e1a>] vif_delete+0xaf/0xc3
Jul 11 15:39:29 wangchen kernel: [<c0285eee>] ip_mroute_setsockopt+0x47a/0x801
Jul 11 15:39:29 wangchen kernel: [<eea5a70c>] do_get_write_access+0x2df/0x313 [jbd]
Jul 11 15:39:29 wangchen kernel: [<c01727c4>] __find_get_block_slow+0xda/0xe4
Jul 11 15:39:29 wangchen kernel: [<c0172a7f>] __find_get_block+0xf8/0x122
Jul 11 15:39:29 wangchen kernel: [<c0172a7f>] __find_get_block+0xf8/0x122
Jul 11 15:39:29 wangchen kernel: [<eea5d563>] journal_cancel_revoke+0xda/0x110 [jbd]
Jul 11 15:39:29 wangchen kernel: [<c0263501>] ip_setsockopt+0xa9/0x9ee
Jul 11 15:39:29 wangchen kernel: [<eea5d563>] journal_cancel_revoke+0xda/0x110 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea5a70c>] do_get_write_access+0x2df/0x313 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea69287>] __ext3_get_inode_loc+0xcf/0x271 [ext3]
Jul 11 15:39:29 wangchen kernel: [<eea743c7>] __ext3_journal_dirty_metadata+0x13/0x32 [ext3]
Jul 11 15:39:29 wangchen kernel: [<c0116434>] __wake_up+0xf/0x15
Jul 11 15:39:29 wangchen kernel: [<eea5a424>] journal_stop+0x1bd/0x1c6 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea703a7>] __ext3_journal_stop+0x19/0x34 [ext3]
Jul 11 15:39:29 wangchen kernel: [<c014291e>] get_page_from_freelist+0x94/0x369
Jul 11 15:39:29 wangchen kernel: [<c01408f2>] filemap_fault+0x1ac/0x2fe
Jul 11 15:39:29 wangchen kernel: [<c01a605e>] security_sk_alloc+0xd/0xf
Jul 11 15:39:29 wangchen kernel: [<c023edea>] sk_prot_alloc+0x36/0x78
Jul 11 15:39:29 wangchen kernel: [<c0240037>] sk_alloc+0x3a/0x40
Jul 11 15:39:29 wangchen kernel: [<c0276062>] raw_hash_sk+0x46/0x4e
Jul 11 15:39:29 wangchen kernel: [<c0166aff>] d_alloc+0x1b/0x157
Jul 11 15:39:29 wangchen kernel: [<c023e4d1>] sock_common_setsockopt+0x12/0x16
Jul 11 15:39:29 wangchen kernel: [<c023cb1e>] sys_setsockopt+0x6f/0x8e
Jul 11 15:39:29 wangchen kernel: [<c023e105>] sys_socketcall+0x15c/0x19e
Jul 11 15:39:29 wangchen kernel: [<c0103611>] sysenter_past_esp+0x6a/0x99
Jul 11 15:39:29 wangchen kernel: [<c0290000>] unix_poll+0x69/0x78
Jul 11 15:39:29 wangchen kernel: =======================
Jul 11 15:39:29 wangchen kernel: Code: 83 e0 01 00 00 85 c0 75 1f 53 53 68 12 81 31 c0 e8 3c 30 ed ff ba 3f 0e 00 00 b8 b9 7f 31 c0 83 c4 0c 5b e9 f5 26 ed ff 48 74 04 <0f> 0b eb fe 89 d8 e8 21 ff ff ff 89 d8 e8 62 ea ff ff c7 83 e0
Jul 11 15:39:29 wangchen kernel: EIP: [<c024636b>] rollback_registered+0x61/0xe3 SS:ESP 0068:ed8e7c3c
Jul 11 15:39:29 wangchen kernel: ---[ end trace c311acf85d169786 ]---
===
Signed-off-by: Wang Chen <wangchen@cn.fujitsu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-07-14 21:56:34 -06:00
|
|
|
dev_hold(dev);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
return dev;
|
|
|
|
|
|
|
|
failure:
|
|
|
|
/* allow the register to be completed before unregistering. */
|
|
|
|
rtnl_unlock();
|
|
|
|
rtnl_lock();
|
|
|
|
|
|
|
|
unregister_netdevice(dev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Delete a VIF entry
|
ipv4: Fix ipmr unregister device oops
An oops happens during device unregister.
The following oops happened when I add two tunnels, which
use a same device, and then delete one tunnel.
Obviously deleting tunnel "A" causes device unregister, which
send a notification, and after receiving notification, ipmr do
unregister again for tunnel "B" which also use same device.
That is wrong.
After receiving notification, ipmr only needs to decrease reference
count and don't do duplicated unregister.
Fortunately, IPv6 side doesn't add tunnel in ip6mr, so it's clean.
This patch fixs:
- unregister device oops
- using after dev_put()
Here is the oops:
===
Jul 11 15:39:29 wangchen kernel: ------------[ cut here ]------------
Jul 11 15:39:29 wangchen kernel: kernel BUG at net/core/dev.c:3651!
Jul 11 15:39:29 wangchen kernel: invalid opcode: 0000 [#1]
Jul 11 15:39:29 wangchen kernel: Modules linked in: ipip tunnel4 nfsd lockd nfs_acl auth_rpcgss sunrpc exportfs ipv6 snd_pcm_oss snd_mixer_oss snd_seq snd_seq_device af_packet binfmt_misc button battery ac loop dm_mod usbhid ff_memless pcmcia firmware_class ohci1394 8139too mii ieee1394 yenta_socket rsrc_nonstatic pcmcia_core ide_cd_mod cdrom snd_intel8x0 snd_ac97_codec ac97_bus snd_pcm i2c_i801 snd_timer snd i2c_core soundcore snd_page_alloc rng_core shpchp ehci_hcd uhci_hcd pci_hotplug intel_agp agpgart usbcore ext3 jbd ata_piix ahci libata dock edd fan thermal processor thermal_sys piix sd_mod scsi_mod ide_disk ide_core [last unloaded: freq_table]
Jul 11 15:39:29 wangchen kernel:
Jul 11 15:39:29 wangchen kernel: Pid: 4102, comm: mroute Not tainted (2.6.26-rc9-default #69)
Jul 11 15:39:29 wangchen kernel: EIP: 0060:[<c024636b>] EFLAGS: 00010202 CPU: 0
Jul 11 15:39:29 wangchen kernel: EIP is at rollback_registered+0x61/0xe3
Jul 11 15:39:29 wangchen kernel: EAX: 00000001 EBX: ecba6000 ECX: 00000000 EDX: ffffffff
Jul 11 15:39:29 wangchen kernel: ESI: 00000001 EDI: ecba6000 EBP: c03de2e8 ESP: ed8e7c3c
Jul 11 15:39:29 wangchen kernel: DS: 007b ES: 007b FS: 0000 GS: 0033 SS: 0068
Jul 11 15:39:29 wangchen kernel: Process mroute (pid: 4102, ti=ed8e6000 task=ed41e830 task.ti=ed8e6000)
Jul 11 15:39:29 wangchen kernel: Stack: ecba6000 c024641c 00000028 c0284e1a 00000001 c03de2e8 ecba6000 eecff360
Jul 11 15:39:29 wangchen kernel: c0284e4c c03536f4 fffffff8 00000000 c029a819 ecba6000 00000006 ecba6000
Jul 11 15:39:29 wangchen kernel: 00000000 ecba6000 c03de2c0 c012841b ffffffff 00000000 c024639f ecba6000
Jul 11 15:39:29 wangchen kernel: Call Trace:
Jul 11 15:39:29 wangchen kernel: [<c024641c>] unregister_netdevice+0x2f/0x51
Jul 11 15:39:29 wangchen kernel: [<c0284e1a>] vif_delete+0xaf/0xc3
Jul 11 15:39:29 wangchen kernel: [<c0284e4c>] ipmr_device_event+0x1e/0x30
Jul 11 15:39:29 wangchen kernel: [<c029a819>] notifier_call_chain+0x2a/0x47
Jul 11 15:39:29 wangchen kernel: [<c012841b>] raw_notifier_call_chain+0x9/0xc
Jul 11 15:39:29 wangchen kernel: [<c024639f>] rollback_registered+0x95/0xe3
Jul 11 15:39:29 wangchen kernel: [<c024641c>] unregister_netdevice+0x2f/0x51
Jul 11 15:39:29 wangchen kernel: [<c0284e1a>] vif_delete+0xaf/0xc3
Jul 11 15:39:29 wangchen kernel: [<c0285eee>] ip_mroute_setsockopt+0x47a/0x801
Jul 11 15:39:29 wangchen kernel: [<eea5a70c>] do_get_write_access+0x2df/0x313 [jbd]
Jul 11 15:39:29 wangchen kernel: [<c01727c4>] __find_get_block_slow+0xda/0xe4
Jul 11 15:39:29 wangchen kernel: [<c0172a7f>] __find_get_block+0xf8/0x122
Jul 11 15:39:29 wangchen kernel: [<c0172a7f>] __find_get_block+0xf8/0x122
Jul 11 15:39:29 wangchen kernel: [<eea5d563>] journal_cancel_revoke+0xda/0x110 [jbd]
Jul 11 15:39:29 wangchen kernel: [<c0263501>] ip_setsockopt+0xa9/0x9ee
Jul 11 15:39:29 wangchen kernel: [<eea5d563>] journal_cancel_revoke+0xda/0x110 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea5a70c>] do_get_write_access+0x2df/0x313 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea69287>] __ext3_get_inode_loc+0xcf/0x271 [ext3]
Jul 11 15:39:29 wangchen kernel: [<eea743c7>] __ext3_journal_dirty_metadata+0x13/0x32 [ext3]
Jul 11 15:39:29 wangchen kernel: [<c0116434>] __wake_up+0xf/0x15
Jul 11 15:39:29 wangchen kernel: [<eea5a424>] journal_stop+0x1bd/0x1c6 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea703a7>] __ext3_journal_stop+0x19/0x34 [ext3]
Jul 11 15:39:29 wangchen kernel: [<c014291e>] get_page_from_freelist+0x94/0x369
Jul 11 15:39:29 wangchen kernel: [<c01408f2>] filemap_fault+0x1ac/0x2fe
Jul 11 15:39:29 wangchen kernel: [<c01a605e>] security_sk_alloc+0xd/0xf
Jul 11 15:39:29 wangchen kernel: [<c023edea>] sk_prot_alloc+0x36/0x78
Jul 11 15:39:29 wangchen kernel: [<c0240037>] sk_alloc+0x3a/0x40
Jul 11 15:39:29 wangchen kernel: [<c0276062>] raw_hash_sk+0x46/0x4e
Jul 11 15:39:29 wangchen kernel: [<c0166aff>] d_alloc+0x1b/0x157
Jul 11 15:39:29 wangchen kernel: [<c023e4d1>] sock_common_setsockopt+0x12/0x16
Jul 11 15:39:29 wangchen kernel: [<c023cb1e>] sys_setsockopt+0x6f/0x8e
Jul 11 15:39:29 wangchen kernel: [<c023e105>] sys_socketcall+0x15c/0x19e
Jul 11 15:39:29 wangchen kernel: [<c0103611>] sysenter_past_esp+0x6a/0x99
Jul 11 15:39:29 wangchen kernel: [<c0290000>] unix_poll+0x69/0x78
Jul 11 15:39:29 wangchen kernel: =======================
Jul 11 15:39:29 wangchen kernel: Code: 83 e0 01 00 00 85 c0 75 1f 53 53 68 12 81 31 c0 e8 3c 30 ed ff ba 3f 0e 00 00 b8 b9 7f 31 c0 83 c4 0c 5b e9 f5 26 ed ff 48 74 04 <0f> 0b eb fe 89 d8 e8 21 ff ff ff 89 d8 e8 62 ea ff ff c7 83 e0
Jul 11 15:39:29 wangchen kernel: EIP: [<c024636b>] rollback_registered+0x61/0xe3 SS:ESP 0068:ed8e7c3c
Jul 11 15:39:29 wangchen kernel: ---[ end trace c311acf85d169786 ]---
===
Signed-off-by: Wang Chen <wangchen@cn.fujitsu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-07-14 21:56:34 -06:00
|
|
|
* @notify: Set to 1, if the caller is a notifier_call
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
static int vif_delete(struct mr_table *mrt, int vifi, int notify,
|
2009-10-27 23:21:38 -06:00
|
|
|
struct list_head *head)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct vif_device *v;
|
|
|
|
struct net_device *dev;
|
|
|
|
struct in_device *in_dev;
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
if (vifi < 0 || vifi >= mrt->maxvif)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
v = &mrt->vif_table[vifi];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
write_lock_bh(&mrt_lock);
|
|
|
|
dev = v->dev;
|
|
|
|
v->dev = NULL;
|
|
|
|
|
|
|
|
if (!dev) {
|
|
|
|
write_unlock_bh(&mrt_lock);
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_PIMSM
|
2010-04-12 23:03:22 -06:00
|
|
|
if (vifi == mrt->mroute_reg_vif_num)
|
|
|
|
mrt->mroute_reg_vif_num = -1;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
if (vifi + 1 == mrt->maxvif) {
|
2005-04-16 16:20:36 -06:00
|
|
|
int tmp;
|
2010-10-01 10:15:29 -06:00
|
|
|
|
|
|
|
for (tmp = vifi - 1; tmp >= 0; tmp--) {
|
2010-04-12 23:03:22 -06:00
|
|
|
if (VIF_EXISTS(mrt, tmp))
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
2010-04-12 23:03:22 -06:00
|
|
|
mrt->maxvif = tmp+1;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
write_unlock_bh(&mrt_lock);
|
|
|
|
|
|
|
|
dev_set_allmulti(dev, -1);
|
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
in_dev = __in_dev_get_rtnl(dev);
|
|
|
|
if (in_dev) {
|
2007-06-05 00:34:44 -06:00
|
|
|
IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--;
|
2005-04-16 16:20:36 -06:00
|
|
|
ip_rt_multicast_event(in_dev);
|
|
|
|
}
|
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER) && !notify)
|
2009-10-27 23:21:38 -06:00
|
|
|
unregister_netdevice_queue(dev, head);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
dev_put(dev);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-01 10:15:08 -06:00
|
|
|
static void ipmr_cache_free_rcu(struct rcu_head *head)
|
2009-01-21 21:56:17 -07:00
|
|
|
{
|
2010-10-01 10:15:08 -06:00
|
|
|
struct mfc_cache *c = container_of(head, struct mfc_cache, rcu);
|
|
|
|
|
2009-01-21 21:56:17 -07:00
|
|
|
kmem_cache_free(mrt_cachep, c);
|
|
|
|
}
|
|
|
|
|
2010-10-01 10:15:08 -06:00
|
|
|
static inline void ipmr_cache_free(struct mfc_cache *c)
|
|
|
|
{
|
|
|
|
call_rcu(&c->rcu, ipmr_cache_free_rcu);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Destroy an unresolved cache entry, killing queued skbs
|
2010-10-01 10:15:29 -06:00
|
|
|
* and reporting error to netlink readers.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
static void ipmr_destroy_unres(struct mr_table *mrt, struct mfc_cache *c)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-04-15 05:29:28 -06:00
|
|
|
struct net *net = read_pnet(&mrt->net);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct sk_buff *skb;
|
2005-06-28 13:55:30 -06:00
|
|
|
struct nlmsgerr *e;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
atomic_dec(&mrt->cache_resolve_queue_len);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-11-03 01:28:02 -07:00
|
|
|
while ((skb = skb_dequeue(&c->mfc_un.unres.unresolved))) {
|
2007-04-20 23:47:35 -06:00
|
|
|
if (ip_hdr(skb)->version == 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
|
|
|
|
nlh->nlmsg_type = NLMSG_ERROR;
|
|
|
|
nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
|
|
|
|
skb_trim(skb, nlh->nlmsg_len);
|
2005-06-28 13:55:30 -06:00
|
|
|
e = NLMSG_DATA(nlh);
|
|
|
|
e->error = -ETIMEDOUT;
|
|
|
|
memset(&e->msg, 0, sizeof(e->msg));
|
2006-08-15 01:30:25 -06:00
|
|
|
|
2009-01-21 21:56:23 -07:00
|
|
|
rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
|
2010-10-01 10:15:29 -06:00
|
|
|
} else {
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree_skb(skb);
|
2010-10-01 10:15:29 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2009-01-21 21:56:17 -07:00
|
|
|
ipmr_cache_free(c);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-04-12 23:03:19 -06:00
|
|
|
/* Timer process for the unresolved queue. */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-12 23:03:19 -06:00
|
|
|
static void ipmr_expire_process(unsigned long arg)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-04-12 23:03:22 -06:00
|
|
|
struct mr_table *mrt = (struct mr_table *)arg;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long now;
|
|
|
|
unsigned long expires;
|
2010-04-12 23:03:21 -06:00
|
|
|
struct mfc_cache *c, *next;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!spin_trylock(&mfc_unres_lock)) {
|
2010-04-12 23:03:22 -06:00
|
|
|
mod_timer(&mrt->ipmr_expire_timer, jiffies+HZ/10);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
if (list_empty(&mrt->mfc_unres_queue))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
now = jiffies;
|
|
|
|
expires = 10*HZ;
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (time_after(c->mfc_un.unres.expires, now)) {
|
|
|
|
unsigned long interval = c->mfc_un.unres.expires - now;
|
|
|
|
if (interval < expires)
|
|
|
|
expires = interval;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2010-04-12 23:03:21 -06:00
|
|
|
list_del(&c->list);
|
2010-04-12 23:03:22 -06:00
|
|
|
ipmr_destroy_unres(mrt, c);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
if (!list_empty(&mrt->mfc_unres_queue))
|
|
|
|
mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock(&mfc_unres_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Fill oifs list. It is called under write locked mrt_lock. */
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
static void ipmr_update_thresholds(struct mr_table *mrt, struct mfc_cache *cache,
|
2010-04-12 23:03:20 -06:00
|
|
|
unsigned char *ttls)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int vifi;
|
|
|
|
|
|
|
|
cache->mfc_un.res.minvif = MAXVIFS;
|
|
|
|
cache->mfc_un.res.maxvif = 0;
|
|
|
|
memset(cache->mfc_un.res.ttls, 255, MAXVIFS);
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
for (vifi = 0; vifi < mrt->maxvif; vifi++) {
|
|
|
|
if (VIF_EXISTS(mrt, vifi) &&
|
2009-01-21 21:56:16 -07:00
|
|
|
ttls[vifi] && ttls[vifi] < 255) {
|
2005-04-16 16:20:36 -06:00
|
|
|
cache->mfc_un.res.ttls[vifi] = ttls[vifi];
|
|
|
|
if (cache->mfc_un.res.minvif > vifi)
|
|
|
|
cache->mfc_un.res.minvif = vifi;
|
|
|
|
if (cache->mfc_un.res.maxvif <= vifi)
|
|
|
|
cache->mfc_un.res.maxvif = vifi + 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
static int vif_add(struct net *net, struct mr_table *mrt,
|
|
|
|
struct vifctl *vifc, int mrtsock)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int vifi = vifc->vifc_vifi;
|
2010-04-12 23:03:22 -06:00
|
|
|
struct vif_device *v = &mrt->vif_table[vifi];
|
2005-04-16 16:20:36 -06:00
|
|
|
struct net_device *dev;
|
|
|
|
struct in_device *in_dev;
|
2008-07-14 21:55:26 -06:00
|
|
|
int err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Is vif busy ? */
|
2010-04-12 23:03:22 -06:00
|
|
|
if (VIF_EXISTS(mrt, vifi))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EADDRINUSE;
|
|
|
|
|
|
|
|
switch (vifc->vifc_flags) {
|
|
|
|
#ifdef CONFIG_IP_PIMSM
|
|
|
|
case VIFF_REGISTER:
|
|
|
|
/*
|
|
|
|
* Special Purpose VIF in PIM
|
|
|
|
* All the packets will be sent to the daemon
|
|
|
|
*/
|
2010-04-12 23:03:22 -06:00
|
|
|
if (mrt->mroute_reg_vif_num >= 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EADDRINUSE;
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
dev = ipmr_reg_vif(net, mrt);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!dev)
|
|
|
|
return -ENOBUFS;
|
2008-07-14 21:55:26 -06:00
|
|
|
err = dev_set_allmulti(dev, 1);
|
|
|
|
if (err) {
|
|
|
|
unregister_netdevice(dev);
|
ipv4: Fix ipmr unregister device oops
An oops happens during device unregister.
The following oops happened when I add two tunnels, which
use a same device, and then delete one tunnel.
Obviously deleting tunnel "A" causes device unregister, which
send a notification, and after receiving notification, ipmr do
unregister again for tunnel "B" which also use same device.
That is wrong.
After receiving notification, ipmr only needs to decrease reference
count and don't do duplicated unregister.
Fortunately, IPv6 side doesn't add tunnel in ip6mr, so it's clean.
This patch fixs:
- unregister device oops
- using after dev_put()
Here is the oops:
===
Jul 11 15:39:29 wangchen kernel: ------------[ cut here ]------------
Jul 11 15:39:29 wangchen kernel: kernel BUG at net/core/dev.c:3651!
Jul 11 15:39:29 wangchen kernel: invalid opcode: 0000 [#1]
Jul 11 15:39:29 wangchen kernel: Modules linked in: ipip tunnel4 nfsd lockd nfs_acl auth_rpcgss sunrpc exportfs ipv6 snd_pcm_oss snd_mixer_oss snd_seq snd_seq_device af_packet binfmt_misc button battery ac loop dm_mod usbhid ff_memless pcmcia firmware_class ohci1394 8139too mii ieee1394 yenta_socket rsrc_nonstatic pcmcia_core ide_cd_mod cdrom snd_intel8x0 snd_ac97_codec ac97_bus snd_pcm i2c_i801 snd_timer snd i2c_core soundcore snd_page_alloc rng_core shpchp ehci_hcd uhci_hcd pci_hotplug intel_agp agpgart usbcore ext3 jbd ata_piix ahci libata dock edd fan thermal processor thermal_sys piix sd_mod scsi_mod ide_disk ide_core [last unloaded: freq_table]
Jul 11 15:39:29 wangchen kernel:
Jul 11 15:39:29 wangchen kernel: Pid: 4102, comm: mroute Not tainted (2.6.26-rc9-default #69)
Jul 11 15:39:29 wangchen kernel: EIP: 0060:[<c024636b>] EFLAGS: 00010202 CPU: 0
Jul 11 15:39:29 wangchen kernel: EIP is at rollback_registered+0x61/0xe3
Jul 11 15:39:29 wangchen kernel: EAX: 00000001 EBX: ecba6000 ECX: 00000000 EDX: ffffffff
Jul 11 15:39:29 wangchen kernel: ESI: 00000001 EDI: ecba6000 EBP: c03de2e8 ESP: ed8e7c3c
Jul 11 15:39:29 wangchen kernel: DS: 007b ES: 007b FS: 0000 GS: 0033 SS: 0068
Jul 11 15:39:29 wangchen kernel: Process mroute (pid: 4102, ti=ed8e6000 task=ed41e830 task.ti=ed8e6000)
Jul 11 15:39:29 wangchen kernel: Stack: ecba6000 c024641c 00000028 c0284e1a 00000001 c03de2e8 ecba6000 eecff360
Jul 11 15:39:29 wangchen kernel: c0284e4c c03536f4 fffffff8 00000000 c029a819 ecba6000 00000006 ecba6000
Jul 11 15:39:29 wangchen kernel: 00000000 ecba6000 c03de2c0 c012841b ffffffff 00000000 c024639f ecba6000
Jul 11 15:39:29 wangchen kernel: Call Trace:
Jul 11 15:39:29 wangchen kernel: [<c024641c>] unregister_netdevice+0x2f/0x51
Jul 11 15:39:29 wangchen kernel: [<c0284e1a>] vif_delete+0xaf/0xc3
Jul 11 15:39:29 wangchen kernel: [<c0284e4c>] ipmr_device_event+0x1e/0x30
Jul 11 15:39:29 wangchen kernel: [<c029a819>] notifier_call_chain+0x2a/0x47
Jul 11 15:39:29 wangchen kernel: [<c012841b>] raw_notifier_call_chain+0x9/0xc
Jul 11 15:39:29 wangchen kernel: [<c024639f>] rollback_registered+0x95/0xe3
Jul 11 15:39:29 wangchen kernel: [<c024641c>] unregister_netdevice+0x2f/0x51
Jul 11 15:39:29 wangchen kernel: [<c0284e1a>] vif_delete+0xaf/0xc3
Jul 11 15:39:29 wangchen kernel: [<c0285eee>] ip_mroute_setsockopt+0x47a/0x801
Jul 11 15:39:29 wangchen kernel: [<eea5a70c>] do_get_write_access+0x2df/0x313 [jbd]
Jul 11 15:39:29 wangchen kernel: [<c01727c4>] __find_get_block_slow+0xda/0xe4
Jul 11 15:39:29 wangchen kernel: [<c0172a7f>] __find_get_block+0xf8/0x122
Jul 11 15:39:29 wangchen kernel: [<c0172a7f>] __find_get_block+0xf8/0x122
Jul 11 15:39:29 wangchen kernel: [<eea5d563>] journal_cancel_revoke+0xda/0x110 [jbd]
Jul 11 15:39:29 wangchen kernel: [<c0263501>] ip_setsockopt+0xa9/0x9ee
Jul 11 15:39:29 wangchen kernel: [<eea5d563>] journal_cancel_revoke+0xda/0x110 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea5a70c>] do_get_write_access+0x2df/0x313 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea69287>] __ext3_get_inode_loc+0xcf/0x271 [ext3]
Jul 11 15:39:29 wangchen kernel: [<eea743c7>] __ext3_journal_dirty_metadata+0x13/0x32 [ext3]
Jul 11 15:39:29 wangchen kernel: [<c0116434>] __wake_up+0xf/0x15
Jul 11 15:39:29 wangchen kernel: [<eea5a424>] journal_stop+0x1bd/0x1c6 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea703a7>] __ext3_journal_stop+0x19/0x34 [ext3]
Jul 11 15:39:29 wangchen kernel: [<c014291e>] get_page_from_freelist+0x94/0x369
Jul 11 15:39:29 wangchen kernel: [<c01408f2>] filemap_fault+0x1ac/0x2fe
Jul 11 15:39:29 wangchen kernel: [<c01a605e>] security_sk_alloc+0xd/0xf
Jul 11 15:39:29 wangchen kernel: [<c023edea>] sk_prot_alloc+0x36/0x78
Jul 11 15:39:29 wangchen kernel: [<c0240037>] sk_alloc+0x3a/0x40
Jul 11 15:39:29 wangchen kernel: [<c0276062>] raw_hash_sk+0x46/0x4e
Jul 11 15:39:29 wangchen kernel: [<c0166aff>] d_alloc+0x1b/0x157
Jul 11 15:39:29 wangchen kernel: [<c023e4d1>] sock_common_setsockopt+0x12/0x16
Jul 11 15:39:29 wangchen kernel: [<c023cb1e>] sys_setsockopt+0x6f/0x8e
Jul 11 15:39:29 wangchen kernel: [<c023e105>] sys_socketcall+0x15c/0x19e
Jul 11 15:39:29 wangchen kernel: [<c0103611>] sysenter_past_esp+0x6a/0x99
Jul 11 15:39:29 wangchen kernel: [<c0290000>] unix_poll+0x69/0x78
Jul 11 15:39:29 wangchen kernel: =======================
Jul 11 15:39:29 wangchen kernel: Code: 83 e0 01 00 00 85 c0 75 1f 53 53 68 12 81 31 c0 e8 3c 30 ed ff ba 3f 0e 00 00 b8 b9 7f 31 c0 83 c4 0c 5b e9 f5 26 ed ff 48 74 04 <0f> 0b eb fe 89 d8 e8 21 ff ff ff 89 d8 e8 62 ea ff ff c7 83 e0
Jul 11 15:39:29 wangchen kernel: EIP: [<c024636b>] rollback_registered+0x61/0xe3 SS:ESP 0068:ed8e7c3c
Jul 11 15:39:29 wangchen kernel: ---[ end trace c311acf85d169786 ]---
===
Signed-off-by: Wang Chen <wangchen@cn.fujitsu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-07-14 21:56:34 -06:00
|
|
|
dev_put(dev);
|
2008-07-14 21:55:26 -06:00
|
|
|
return err;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
#endif
|
2007-02-09 07:24:47 -07:00
|
|
|
case VIFF_TUNNEL:
|
2009-01-21 21:56:23 -07:00
|
|
|
dev = ipmr_new_tunnel(net, vifc);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!dev)
|
|
|
|
return -ENOBUFS;
|
2008-07-14 21:55:26 -06:00
|
|
|
err = dev_set_allmulti(dev, 1);
|
|
|
|
if (err) {
|
|
|
|
ipmr_del_tunnel(dev, vifc);
|
ipv4: Fix ipmr unregister device oops
An oops happens during device unregister.
The following oops happened when I add two tunnels, which
use a same device, and then delete one tunnel.
Obviously deleting tunnel "A" causes device unregister, which
send a notification, and after receiving notification, ipmr do
unregister again for tunnel "B" which also use same device.
That is wrong.
After receiving notification, ipmr only needs to decrease reference
count and don't do duplicated unregister.
Fortunately, IPv6 side doesn't add tunnel in ip6mr, so it's clean.
This patch fixs:
- unregister device oops
- using after dev_put()
Here is the oops:
===
Jul 11 15:39:29 wangchen kernel: ------------[ cut here ]------------
Jul 11 15:39:29 wangchen kernel: kernel BUG at net/core/dev.c:3651!
Jul 11 15:39:29 wangchen kernel: invalid opcode: 0000 [#1]
Jul 11 15:39:29 wangchen kernel: Modules linked in: ipip tunnel4 nfsd lockd nfs_acl auth_rpcgss sunrpc exportfs ipv6 snd_pcm_oss snd_mixer_oss snd_seq snd_seq_device af_packet binfmt_misc button battery ac loop dm_mod usbhid ff_memless pcmcia firmware_class ohci1394 8139too mii ieee1394 yenta_socket rsrc_nonstatic pcmcia_core ide_cd_mod cdrom snd_intel8x0 snd_ac97_codec ac97_bus snd_pcm i2c_i801 snd_timer snd i2c_core soundcore snd_page_alloc rng_core shpchp ehci_hcd uhci_hcd pci_hotplug intel_agp agpgart usbcore ext3 jbd ata_piix ahci libata dock edd fan thermal processor thermal_sys piix sd_mod scsi_mod ide_disk ide_core [last unloaded: freq_table]
Jul 11 15:39:29 wangchen kernel:
Jul 11 15:39:29 wangchen kernel: Pid: 4102, comm: mroute Not tainted (2.6.26-rc9-default #69)
Jul 11 15:39:29 wangchen kernel: EIP: 0060:[<c024636b>] EFLAGS: 00010202 CPU: 0
Jul 11 15:39:29 wangchen kernel: EIP is at rollback_registered+0x61/0xe3
Jul 11 15:39:29 wangchen kernel: EAX: 00000001 EBX: ecba6000 ECX: 00000000 EDX: ffffffff
Jul 11 15:39:29 wangchen kernel: ESI: 00000001 EDI: ecba6000 EBP: c03de2e8 ESP: ed8e7c3c
Jul 11 15:39:29 wangchen kernel: DS: 007b ES: 007b FS: 0000 GS: 0033 SS: 0068
Jul 11 15:39:29 wangchen kernel: Process mroute (pid: 4102, ti=ed8e6000 task=ed41e830 task.ti=ed8e6000)
Jul 11 15:39:29 wangchen kernel: Stack: ecba6000 c024641c 00000028 c0284e1a 00000001 c03de2e8 ecba6000 eecff360
Jul 11 15:39:29 wangchen kernel: c0284e4c c03536f4 fffffff8 00000000 c029a819 ecba6000 00000006 ecba6000
Jul 11 15:39:29 wangchen kernel: 00000000 ecba6000 c03de2c0 c012841b ffffffff 00000000 c024639f ecba6000
Jul 11 15:39:29 wangchen kernel: Call Trace:
Jul 11 15:39:29 wangchen kernel: [<c024641c>] unregister_netdevice+0x2f/0x51
Jul 11 15:39:29 wangchen kernel: [<c0284e1a>] vif_delete+0xaf/0xc3
Jul 11 15:39:29 wangchen kernel: [<c0284e4c>] ipmr_device_event+0x1e/0x30
Jul 11 15:39:29 wangchen kernel: [<c029a819>] notifier_call_chain+0x2a/0x47
Jul 11 15:39:29 wangchen kernel: [<c012841b>] raw_notifier_call_chain+0x9/0xc
Jul 11 15:39:29 wangchen kernel: [<c024639f>] rollback_registered+0x95/0xe3
Jul 11 15:39:29 wangchen kernel: [<c024641c>] unregister_netdevice+0x2f/0x51
Jul 11 15:39:29 wangchen kernel: [<c0284e1a>] vif_delete+0xaf/0xc3
Jul 11 15:39:29 wangchen kernel: [<c0285eee>] ip_mroute_setsockopt+0x47a/0x801
Jul 11 15:39:29 wangchen kernel: [<eea5a70c>] do_get_write_access+0x2df/0x313 [jbd]
Jul 11 15:39:29 wangchen kernel: [<c01727c4>] __find_get_block_slow+0xda/0xe4
Jul 11 15:39:29 wangchen kernel: [<c0172a7f>] __find_get_block+0xf8/0x122
Jul 11 15:39:29 wangchen kernel: [<c0172a7f>] __find_get_block+0xf8/0x122
Jul 11 15:39:29 wangchen kernel: [<eea5d563>] journal_cancel_revoke+0xda/0x110 [jbd]
Jul 11 15:39:29 wangchen kernel: [<c0263501>] ip_setsockopt+0xa9/0x9ee
Jul 11 15:39:29 wangchen kernel: [<eea5d563>] journal_cancel_revoke+0xda/0x110 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea5a70c>] do_get_write_access+0x2df/0x313 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea69287>] __ext3_get_inode_loc+0xcf/0x271 [ext3]
Jul 11 15:39:29 wangchen kernel: [<eea743c7>] __ext3_journal_dirty_metadata+0x13/0x32 [ext3]
Jul 11 15:39:29 wangchen kernel: [<c0116434>] __wake_up+0xf/0x15
Jul 11 15:39:29 wangchen kernel: [<eea5a424>] journal_stop+0x1bd/0x1c6 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea703a7>] __ext3_journal_stop+0x19/0x34 [ext3]
Jul 11 15:39:29 wangchen kernel: [<c014291e>] get_page_from_freelist+0x94/0x369
Jul 11 15:39:29 wangchen kernel: [<c01408f2>] filemap_fault+0x1ac/0x2fe
Jul 11 15:39:29 wangchen kernel: [<c01a605e>] security_sk_alloc+0xd/0xf
Jul 11 15:39:29 wangchen kernel: [<c023edea>] sk_prot_alloc+0x36/0x78
Jul 11 15:39:29 wangchen kernel: [<c0240037>] sk_alloc+0x3a/0x40
Jul 11 15:39:29 wangchen kernel: [<c0276062>] raw_hash_sk+0x46/0x4e
Jul 11 15:39:29 wangchen kernel: [<c0166aff>] d_alloc+0x1b/0x157
Jul 11 15:39:29 wangchen kernel: [<c023e4d1>] sock_common_setsockopt+0x12/0x16
Jul 11 15:39:29 wangchen kernel: [<c023cb1e>] sys_setsockopt+0x6f/0x8e
Jul 11 15:39:29 wangchen kernel: [<c023e105>] sys_socketcall+0x15c/0x19e
Jul 11 15:39:29 wangchen kernel: [<c0103611>] sysenter_past_esp+0x6a/0x99
Jul 11 15:39:29 wangchen kernel: [<c0290000>] unix_poll+0x69/0x78
Jul 11 15:39:29 wangchen kernel: =======================
Jul 11 15:39:29 wangchen kernel: Code: 83 e0 01 00 00 85 c0 75 1f 53 53 68 12 81 31 c0 e8 3c 30 ed ff ba 3f 0e 00 00 b8 b9 7f 31 c0 83 c4 0c 5b e9 f5 26 ed ff 48 74 04 <0f> 0b eb fe 89 d8 e8 21 ff ff ff 89 d8 e8 62 ea ff ff c7 83 e0
Jul 11 15:39:29 wangchen kernel: EIP: [<c024636b>] rollback_registered+0x61/0xe3 SS:ESP 0068:ed8e7c3c
Jul 11 15:39:29 wangchen kernel: ---[ end trace c311acf85d169786 ]---
===
Signed-off-by: Wang Chen <wangchen@cn.fujitsu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-07-14 21:56:34 -06:00
|
|
|
dev_put(dev);
|
2008-07-14 21:55:26 -06:00
|
|
|
return err;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
add vif using local interface index instead of IP
When routing daemon wants to enable forwarding of multicast traffic it
performs something like:
struct vifctl vc = {
.vifc_vifi = 1,
.vifc_flags = 0,
.vifc_threshold = 1,
.vifc_rate_limit = 0,
.vifc_lcl_addr = ip, /* <--- ip address of physical
interface, e.g. eth0 */
.vifc_rmt_addr.s_addr = htonl(INADDR_ANY),
};
setsockopt(fd, IPPROTO_IP, MRT_ADD_VIF, &vc, sizeof(vc));
This leads (in the kernel) to calling vif_add() function call which
search the (physical) device using assigned IP address:
dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
The current API (struct vifctl) does not allow to specify an
interface other way than using it's IP, and if there are more than a
single interface with specified IP only the first one will be found.
The attached patch (against 2.6.30.4) allows to specify an interface
by its index, instead of IP address:
struct vifctl vc = {
.vifc_vifi = 1,
.vifc_flags = VIFF_USE_IFINDEX, /* NEW */
.vifc_threshold = 1,
.vifc_rate_limit = 0,
.vifc_lcl_ifindex = if_nametoindex("eth0"), /* NEW */
.vifc_rmt_addr.s_addr = htonl(INADDR_ANY),
};
setsockopt(fd, IPPROTO_IP, MRT_ADD_VIF, &vc, sizeof(vc));
Signed-off-by: Ilia K. <mail4ilia@gmail.com>
=== modified file 'include/linux/mroute.h'
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-09-15 23:53:07 -06:00
|
|
|
|
|
|
|
case VIFF_USE_IFINDEX:
|
2005-04-16 16:20:36 -06:00
|
|
|
case 0:
|
add vif using local interface index instead of IP
When routing daemon wants to enable forwarding of multicast traffic it
performs something like:
struct vifctl vc = {
.vifc_vifi = 1,
.vifc_flags = 0,
.vifc_threshold = 1,
.vifc_rate_limit = 0,
.vifc_lcl_addr = ip, /* <--- ip address of physical
interface, e.g. eth0 */
.vifc_rmt_addr.s_addr = htonl(INADDR_ANY),
};
setsockopt(fd, IPPROTO_IP, MRT_ADD_VIF, &vc, sizeof(vc));
This leads (in the kernel) to calling vif_add() function call which
search the (physical) device using assigned IP address:
dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
The current API (struct vifctl) does not allow to specify an
interface other way than using it's IP, and if there are more than a
single interface with specified IP only the first one will be found.
The attached patch (against 2.6.30.4) allows to specify an interface
by its index, instead of IP address:
struct vifctl vc = {
.vifc_vifi = 1,
.vifc_flags = VIFF_USE_IFINDEX, /* NEW */
.vifc_threshold = 1,
.vifc_rate_limit = 0,
.vifc_lcl_ifindex = if_nametoindex("eth0"), /* NEW */
.vifc_rmt_addr.s_addr = htonl(INADDR_ANY),
};
setsockopt(fd, IPPROTO_IP, MRT_ADD_VIF, &vc, sizeof(vc));
Signed-off-by: Ilia K. <mail4ilia@gmail.com>
=== modified file 'include/linux/mroute.h'
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-09-15 23:53:07 -06:00
|
|
|
if (vifc->vifc_flags == VIFF_USE_IFINDEX) {
|
|
|
|
dev = dev_get_by_index(net, vifc->vifc_lcl_ifindex);
|
2010-09-14 22:04:31 -06:00
|
|
|
if (dev && __in_dev_get_rtnl(dev) == NULL) {
|
add vif using local interface index instead of IP
When routing daemon wants to enable forwarding of multicast traffic it
performs something like:
struct vifctl vc = {
.vifc_vifi = 1,
.vifc_flags = 0,
.vifc_threshold = 1,
.vifc_rate_limit = 0,
.vifc_lcl_addr = ip, /* <--- ip address of physical
interface, e.g. eth0 */
.vifc_rmt_addr.s_addr = htonl(INADDR_ANY),
};
setsockopt(fd, IPPROTO_IP, MRT_ADD_VIF, &vc, sizeof(vc));
This leads (in the kernel) to calling vif_add() function call which
search the (physical) device using assigned IP address:
dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
The current API (struct vifctl) does not allow to specify an
interface other way than using it's IP, and if there are more than a
single interface with specified IP only the first one will be found.
The attached patch (against 2.6.30.4) allows to specify an interface
by its index, instead of IP address:
struct vifctl vc = {
.vifc_vifi = 1,
.vifc_flags = VIFF_USE_IFINDEX, /* NEW */
.vifc_threshold = 1,
.vifc_rate_limit = 0,
.vifc_lcl_ifindex = if_nametoindex("eth0"), /* NEW */
.vifc_rmt_addr.s_addr = htonl(INADDR_ANY),
};
setsockopt(fd, IPPROTO_IP, MRT_ADD_VIF, &vc, sizeof(vc));
Signed-off-by: Ilia K. <mail4ilia@gmail.com>
=== modified file 'include/linux/mroute.h'
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-09-15 23:53:07 -06:00
|
|
|
dev_put(dev);
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
}
|
2010-10-01 10:15:29 -06:00
|
|
|
} else {
|
add vif using local interface index instead of IP
When routing daemon wants to enable forwarding of multicast traffic it
performs something like:
struct vifctl vc = {
.vifc_vifi = 1,
.vifc_flags = 0,
.vifc_threshold = 1,
.vifc_rate_limit = 0,
.vifc_lcl_addr = ip, /* <--- ip address of physical
interface, e.g. eth0 */
.vifc_rmt_addr.s_addr = htonl(INADDR_ANY),
};
setsockopt(fd, IPPROTO_IP, MRT_ADD_VIF, &vc, sizeof(vc));
This leads (in the kernel) to calling vif_add() function call which
search the (physical) device using assigned IP address:
dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
The current API (struct vifctl) does not allow to specify an
interface other way than using it's IP, and if there are more than a
single interface with specified IP only the first one will be found.
The attached patch (against 2.6.30.4) allows to specify an interface
by its index, instead of IP address:
struct vifctl vc = {
.vifc_vifi = 1,
.vifc_flags = VIFF_USE_IFINDEX, /* NEW */
.vifc_threshold = 1,
.vifc_rate_limit = 0,
.vifc_lcl_ifindex = if_nametoindex("eth0"), /* NEW */
.vifc_rmt_addr.s_addr = htonl(INADDR_ANY),
};
setsockopt(fd, IPPROTO_IP, MRT_ADD_VIF, &vc, sizeof(vc));
Signed-off-by: Ilia K. <mail4ilia@gmail.com>
=== modified file 'include/linux/mroute.h'
Signed-off-by: David S. Miller <davem@davemloft.net>
2009-09-15 23:53:07 -06:00
|
|
|
dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
|
2010-10-01 10:15:29 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!dev)
|
|
|
|
return -EADDRNOTAVAIL;
|
2008-07-14 21:55:26 -06:00
|
|
|
err = dev_set_allmulti(dev, 1);
|
ipv4: Fix ipmr unregister device oops
An oops happens during device unregister.
The following oops happened when I add two tunnels, which
use a same device, and then delete one tunnel.
Obviously deleting tunnel "A" causes device unregister, which
send a notification, and after receiving notification, ipmr do
unregister again for tunnel "B" which also use same device.
That is wrong.
After receiving notification, ipmr only needs to decrease reference
count and don't do duplicated unregister.
Fortunately, IPv6 side doesn't add tunnel in ip6mr, so it's clean.
This patch fixs:
- unregister device oops
- using after dev_put()
Here is the oops:
===
Jul 11 15:39:29 wangchen kernel: ------------[ cut here ]------------
Jul 11 15:39:29 wangchen kernel: kernel BUG at net/core/dev.c:3651!
Jul 11 15:39:29 wangchen kernel: invalid opcode: 0000 [#1]
Jul 11 15:39:29 wangchen kernel: Modules linked in: ipip tunnel4 nfsd lockd nfs_acl auth_rpcgss sunrpc exportfs ipv6 snd_pcm_oss snd_mixer_oss snd_seq snd_seq_device af_packet binfmt_misc button battery ac loop dm_mod usbhid ff_memless pcmcia firmware_class ohci1394 8139too mii ieee1394 yenta_socket rsrc_nonstatic pcmcia_core ide_cd_mod cdrom snd_intel8x0 snd_ac97_codec ac97_bus snd_pcm i2c_i801 snd_timer snd i2c_core soundcore snd_page_alloc rng_core shpchp ehci_hcd uhci_hcd pci_hotplug intel_agp agpgart usbcore ext3 jbd ata_piix ahci libata dock edd fan thermal processor thermal_sys piix sd_mod scsi_mod ide_disk ide_core [last unloaded: freq_table]
Jul 11 15:39:29 wangchen kernel:
Jul 11 15:39:29 wangchen kernel: Pid: 4102, comm: mroute Not tainted (2.6.26-rc9-default #69)
Jul 11 15:39:29 wangchen kernel: EIP: 0060:[<c024636b>] EFLAGS: 00010202 CPU: 0
Jul 11 15:39:29 wangchen kernel: EIP is at rollback_registered+0x61/0xe3
Jul 11 15:39:29 wangchen kernel: EAX: 00000001 EBX: ecba6000 ECX: 00000000 EDX: ffffffff
Jul 11 15:39:29 wangchen kernel: ESI: 00000001 EDI: ecba6000 EBP: c03de2e8 ESP: ed8e7c3c
Jul 11 15:39:29 wangchen kernel: DS: 007b ES: 007b FS: 0000 GS: 0033 SS: 0068
Jul 11 15:39:29 wangchen kernel: Process mroute (pid: 4102, ti=ed8e6000 task=ed41e830 task.ti=ed8e6000)
Jul 11 15:39:29 wangchen kernel: Stack: ecba6000 c024641c 00000028 c0284e1a 00000001 c03de2e8 ecba6000 eecff360
Jul 11 15:39:29 wangchen kernel: c0284e4c c03536f4 fffffff8 00000000 c029a819 ecba6000 00000006 ecba6000
Jul 11 15:39:29 wangchen kernel: 00000000 ecba6000 c03de2c0 c012841b ffffffff 00000000 c024639f ecba6000
Jul 11 15:39:29 wangchen kernel: Call Trace:
Jul 11 15:39:29 wangchen kernel: [<c024641c>] unregister_netdevice+0x2f/0x51
Jul 11 15:39:29 wangchen kernel: [<c0284e1a>] vif_delete+0xaf/0xc3
Jul 11 15:39:29 wangchen kernel: [<c0284e4c>] ipmr_device_event+0x1e/0x30
Jul 11 15:39:29 wangchen kernel: [<c029a819>] notifier_call_chain+0x2a/0x47
Jul 11 15:39:29 wangchen kernel: [<c012841b>] raw_notifier_call_chain+0x9/0xc
Jul 11 15:39:29 wangchen kernel: [<c024639f>] rollback_registered+0x95/0xe3
Jul 11 15:39:29 wangchen kernel: [<c024641c>] unregister_netdevice+0x2f/0x51
Jul 11 15:39:29 wangchen kernel: [<c0284e1a>] vif_delete+0xaf/0xc3
Jul 11 15:39:29 wangchen kernel: [<c0285eee>] ip_mroute_setsockopt+0x47a/0x801
Jul 11 15:39:29 wangchen kernel: [<eea5a70c>] do_get_write_access+0x2df/0x313 [jbd]
Jul 11 15:39:29 wangchen kernel: [<c01727c4>] __find_get_block_slow+0xda/0xe4
Jul 11 15:39:29 wangchen kernel: [<c0172a7f>] __find_get_block+0xf8/0x122
Jul 11 15:39:29 wangchen kernel: [<c0172a7f>] __find_get_block+0xf8/0x122
Jul 11 15:39:29 wangchen kernel: [<eea5d563>] journal_cancel_revoke+0xda/0x110 [jbd]
Jul 11 15:39:29 wangchen kernel: [<c0263501>] ip_setsockopt+0xa9/0x9ee
Jul 11 15:39:29 wangchen kernel: [<eea5d563>] journal_cancel_revoke+0xda/0x110 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea5a70c>] do_get_write_access+0x2df/0x313 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea69287>] __ext3_get_inode_loc+0xcf/0x271 [ext3]
Jul 11 15:39:29 wangchen kernel: [<eea743c7>] __ext3_journal_dirty_metadata+0x13/0x32 [ext3]
Jul 11 15:39:29 wangchen kernel: [<c0116434>] __wake_up+0xf/0x15
Jul 11 15:39:29 wangchen kernel: [<eea5a424>] journal_stop+0x1bd/0x1c6 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea703a7>] __ext3_journal_stop+0x19/0x34 [ext3]
Jul 11 15:39:29 wangchen kernel: [<c014291e>] get_page_from_freelist+0x94/0x369
Jul 11 15:39:29 wangchen kernel: [<c01408f2>] filemap_fault+0x1ac/0x2fe
Jul 11 15:39:29 wangchen kernel: [<c01a605e>] security_sk_alloc+0xd/0xf
Jul 11 15:39:29 wangchen kernel: [<c023edea>] sk_prot_alloc+0x36/0x78
Jul 11 15:39:29 wangchen kernel: [<c0240037>] sk_alloc+0x3a/0x40
Jul 11 15:39:29 wangchen kernel: [<c0276062>] raw_hash_sk+0x46/0x4e
Jul 11 15:39:29 wangchen kernel: [<c0166aff>] d_alloc+0x1b/0x157
Jul 11 15:39:29 wangchen kernel: [<c023e4d1>] sock_common_setsockopt+0x12/0x16
Jul 11 15:39:29 wangchen kernel: [<c023cb1e>] sys_setsockopt+0x6f/0x8e
Jul 11 15:39:29 wangchen kernel: [<c023e105>] sys_socketcall+0x15c/0x19e
Jul 11 15:39:29 wangchen kernel: [<c0103611>] sysenter_past_esp+0x6a/0x99
Jul 11 15:39:29 wangchen kernel: [<c0290000>] unix_poll+0x69/0x78
Jul 11 15:39:29 wangchen kernel: =======================
Jul 11 15:39:29 wangchen kernel: Code: 83 e0 01 00 00 85 c0 75 1f 53 53 68 12 81 31 c0 e8 3c 30 ed ff ba 3f 0e 00 00 b8 b9 7f 31 c0 83 c4 0c 5b e9 f5 26 ed ff 48 74 04 <0f> 0b eb fe 89 d8 e8 21 ff ff ff 89 d8 e8 62 ea ff ff c7 83 e0
Jul 11 15:39:29 wangchen kernel: EIP: [<c024636b>] rollback_registered+0x61/0xe3 SS:ESP 0068:ed8e7c3c
Jul 11 15:39:29 wangchen kernel: ---[ end trace c311acf85d169786 ]---
===
Signed-off-by: Wang Chen <wangchen@cn.fujitsu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-07-14 21:56:34 -06:00
|
|
|
if (err) {
|
|
|
|
dev_put(dev);
|
2008-07-14 21:55:26 -06:00
|
|
|
return err;
|
ipv4: Fix ipmr unregister device oops
An oops happens during device unregister.
The following oops happened when I add two tunnels, which
use a same device, and then delete one tunnel.
Obviously deleting tunnel "A" causes device unregister, which
send a notification, and after receiving notification, ipmr do
unregister again for tunnel "B" which also use same device.
That is wrong.
After receiving notification, ipmr only needs to decrease reference
count and don't do duplicated unregister.
Fortunately, IPv6 side doesn't add tunnel in ip6mr, so it's clean.
This patch fixs:
- unregister device oops
- using after dev_put()
Here is the oops:
===
Jul 11 15:39:29 wangchen kernel: ------------[ cut here ]------------
Jul 11 15:39:29 wangchen kernel: kernel BUG at net/core/dev.c:3651!
Jul 11 15:39:29 wangchen kernel: invalid opcode: 0000 [#1]
Jul 11 15:39:29 wangchen kernel: Modules linked in: ipip tunnel4 nfsd lockd nfs_acl auth_rpcgss sunrpc exportfs ipv6 snd_pcm_oss snd_mixer_oss snd_seq snd_seq_device af_packet binfmt_misc button battery ac loop dm_mod usbhid ff_memless pcmcia firmware_class ohci1394 8139too mii ieee1394 yenta_socket rsrc_nonstatic pcmcia_core ide_cd_mod cdrom snd_intel8x0 snd_ac97_codec ac97_bus snd_pcm i2c_i801 snd_timer snd i2c_core soundcore snd_page_alloc rng_core shpchp ehci_hcd uhci_hcd pci_hotplug intel_agp agpgart usbcore ext3 jbd ata_piix ahci libata dock edd fan thermal processor thermal_sys piix sd_mod scsi_mod ide_disk ide_core [last unloaded: freq_table]
Jul 11 15:39:29 wangchen kernel:
Jul 11 15:39:29 wangchen kernel: Pid: 4102, comm: mroute Not tainted (2.6.26-rc9-default #69)
Jul 11 15:39:29 wangchen kernel: EIP: 0060:[<c024636b>] EFLAGS: 00010202 CPU: 0
Jul 11 15:39:29 wangchen kernel: EIP is at rollback_registered+0x61/0xe3
Jul 11 15:39:29 wangchen kernel: EAX: 00000001 EBX: ecba6000 ECX: 00000000 EDX: ffffffff
Jul 11 15:39:29 wangchen kernel: ESI: 00000001 EDI: ecba6000 EBP: c03de2e8 ESP: ed8e7c3c
Jul 11 15:39:29 wangchen kernel: DS: 007b ES: 007b FS: 0000 GS: 0033 SS: 0068
Jul 11 15:39:29 wangchen kernel: Process mroute (pid: 4102, ti=ed8e6000 task=ed41e830 task.ti=ed8e6000)
Jul 11 15:39:29 wangchen kernel: Stack: ecba6000 c024641c 00000028 c0284e1a 00000001 c03de2e8 ecba6000 eecff360
Jul 11 15:39:29 wangchen kernel: c0284e4c c03536f4 fffffff8 00000000 c029a819 ecba6000 00000006 ecba6000
Jul 11 15:39:29 wangchen kernel: 00000000 ecba6000 c03de2c0 c012841b ffffffff 00000000 c024639f ecba6000
Jul 11 15:39:29 wangchen kernel: Call Trace:
Jul 11 15:39:29 wangchen kernel: [<c024641c>] unregister_netdevice+0x2f/0x51
Jul 11 15:39:29 wangchen kernel: [<c0284e1a>] vif_delete+0xaf/0xc3
Jul 11 15:39:29 wangchen kernel: [<c0284e4c>] ipmr_device_event+0x1e/0x30
Jul 11 15:39:29 wangchen kernel: [<c029a819>] notifier_call_chain+0x2a/0x47
Jul 11 15:39:29 wangchen kernel: [<c012841b>] raw_notifier_call_chain+0x9/0xc
Jul 11 15:39:29 wangchen kernel: [<c024639f>] rollback_registered+0x95/0xe3
Jul 11 15:39:29 wangchen kernel: [<c024641c>] unregister_netdevice+0x2f/0x51
Jul 11 15:39:29 wangchen kernel: [<c0284e1a>] vif_delete+0xaf/0xc3
Jul 11 15:39:29 wangchen kernel: [<c0285eee>] ip_mroute_setsockopt+0x47a/0x801
Jul 11 15:39:29 wangchen kernel: [<eea5a70c>] do_get_write_access+0x2df/0x313 [jbd]
Jul 11 15:39:29 wangchen kernel: [<c01727c4>] __find_get_block_slow+0xda/0xe4
Jul 11 15:39:29 wangchen kernel: [<c0172a7f>] __find_get_block+0xf8/0x122
Jul 11 15:39:29 wangchen kernel: [<c0172a7f>] __find_get_block+0xf8/0x122
Jul 11 15:39:29 wangchen kernel: [<eea5d563>] journal_cancel_revoke+0xda/0x110 [jbd]
Jul 11 15:39:29 wangchen kernel: [<c0263501>] ip_setsockopt+0xa9/0x9ee
Jul 11 15:39:29 wangchen kernel: [<eea5d563>] journal_cancel_revoke+0xda/0x110 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea5a70c>] do_get_write_access+0x2df/0x313 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea69287>] __ext3_get_inode_loc+0xcf/0x271 [ext3]
Jul 11 15:39:29 wangchen kernel: [<eea743c7>] __ext3_journal_dirty_metadata+0x13/0x32 [ext3]
Jul 11 15:39:29 wangchen kernel: [<c0116434>] __wake_up+0xf/0x15
Jul 11 15:39:29 wangchen kernel: [<eea5a424>] journal_stop+0x1bd/0x1c6 [jbd]
Jul 11 15:39:29 wangchen kernel: [<eea703a7>] __ext3_journal_stop+0x19/0x34 [ext3]
Jul 11 15:39:29 wangchen kernel: [<c014291e>] get_page_from_freelist+0x94/0x369
Jul 11 15:39:29 wangchen kernel: [<c01408f2>] filemap_fault+0x1ac/0x2fe
Jul 11 15:39:29 wangchen kernel: [<c01a605e>] security_sk_alloc+0xd/0xf
Jul 11 15:39:29 wangchen kernel: [<c023edea>] sk_prot_alloc+0x36/0x78
Jul 11 15:39:29 wangchen kernel: [<c0240037>] sk_alloc+0x3a/0x40
Jul 11 15:39:29 wangchen kernel: [<c0276062>] raw_hash_sk+0x46/0x4e
Jul 11 15:39:29 wangchen kernel: [<c0166aff>] d_alloc+0x1b/0x157
Jul 11 15:39:29 wangchen kernel: [<c023e4d1>] sock_common_setsockopt+0x12/0x16
Jul 11 15:39:29 wangchen kernel: [<c023cb1e>] sys_setsockopt+0x6f/0x8e
Jul 11 15:39:29 wangchen kernel: [<c023e105>] sys_socketcall+0x15c/0x19e
Jul 11 15:39:29 wangchen kernel: [<c0103611>] sysenter_past_esp+0x6a/0x99
Jul 11 15:39:29 wangchen kernel: [<c0290000>] unix_poll+0x69/0x78
Jul 11 15:39:29 wangchen kernel: =======================
Jul 11 15:39:29 wangchen kernel: Code: 83 e0 01 00 00 85 c0 75 1f 53 53 68 12 81 31 c0 e8 3c 30 ed ff ba 3f 0e 00 00 b8 b9 7f 31 c0 83 c4 0c 5b e9 f5 26 ed ff 48 74 04 <0f> 0b eb fe 89 d8 e8 21 ff ff ff 89 d8 e8 62 ea ff ff c7 83 e0
Jul 11 15:39:29 wangchen kernel: EIP: [<c024636b>] rollback_registered+0x61/0xe3 SS:ESP 0068:ed8e7c3c
Jul 11 15:39:29 wangchen kernel: ---[ end trace c311acf85d169786 ]---
===
Signed-off-by: Wang Chen <wangchen@cn.fujitsu.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-07-14 21:56:34 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
in_dev = __in_dev_get_rtnl(dev);
|
|
|
|
if (!in_dev) {
|
2009-11-10 19:03:54 -07:00
|
|
|
dev_put(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EADDRNOTAVAIL;
|
2009-11-10 19:03:54 -07:00
|
|
|
}
|
2007-06-05 00:34:44 -06:00
|
|
|
IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++;
|
2005-04-16 16:20:36 -06:00
|
|
|
ip_rt_multicast_event(in_dev);
|
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
/* Fill in the VIF structures */
|
|
|
|
|
2008-11-03 01:28:02 -07:00
|
|
|
v->rate_limit = vifc->vifc_rate_limit;
|
|
|
|
v->local = vifc->vifc_lcl_addr.s_addr;
|
|
|
|
v->remote = vifc->vifc_rmt_addr.s_addr;
|
|
|
|
v->flags = vifc->vifc_flags;
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!mrtsock)
|
|
|
|
v->flags |= VIFF_STATIC;
|
2008-11-03 01:28:02 -07:00
|
|
|
v->threshold = vifc->vifc_threshold;
|
2005-04-16 16:20:36 -06:00
|
|
|
v->bytes_in = 0;
|
|
|
|
v->bytes_out = 0;
|
|
|
|
v->pkt_in = 0;
|
|
|
|
v->pkt_out = 0;
|
|
|
|
v->link = dev->ifindex;
|
2010-10-01 10:15:29 -06:00
|
|
|
if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER))
|
2005-04-16 16:20:36 -06:00
|
|
|
v->link = dev->iflink;
|
|
|
|
|
|
|
|
/* And finish update writing critical data */
|
|
|
|
write_lock_bh(&mrt_lock);
|
2008-11-03 01:28:02 -07:00
|
|
|
v->dev = dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_IP_PIMSM
|
2010-10-01 10:15:29 -06:00
|
|
|
if (v->flags & VIFF_REGISTER)
|
2010-04-12 23:03:22 -06:00
|
|
|
mrt->mroute_reg_vif_num = vifi;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2010-04-12 23:03:22 -06:00
|
|
|
if (vifi+1 > mrt->maxvif)
|
|
|
|
mrt->maxvif = vifi+1;
|
2005-04-16 16:20:36 -06:00
|
|
|
write_unlock_bh(&mrt_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-01 10:15:08 -06:00
|
|
|
/* called with rcu_read_lock() */
|
2010-04-12 23:03:22 -06:00
|
|
|
static struct mfc_cache *ipmr_cache_find(struct mr_table *mrt,
|
2009-01-21 21:56:23 -07:00
|
|
|
__be32 origin,
|
|
|
|
__be32 mcastgrp)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-11-03 01:28:02 -07:00
|
|
|
int line = MFC_HASH(mcastgrp, origin);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct mfc_cache *c;
|
|
|
|
|
2010-10-01 10:15:08 -06:00
|
|
|
list_for_each_entry_rcu(c, &mrt->mfc_cache_array[line], list) {
|
2010-04-12 23:03:21 -06:00
|
|
|
if (c->mfc_origin == origin && c->mfc_mcastgrp == mcastgrp)
|
|
|
|
return c;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2010-04-12 23:03:21 -06:00
|
|
|
return NULL;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Allocate a multicast cache entry
|
|
|
|
*/
|
2010-04-12 23:03:20 -06:00
|
|
|
static struct mfc_cache *ipmr_cache_alloc(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-11-03 01:28:02 -07:00
|
|
|
struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
|
2010-10-01 10:15:08 -06:00
|
|
|
|
|
|
|
if (c)
|
|
|
|
c->mfc_un.res.minvif = MAXVIFS;
|
2005-04-16 16:20:36 -06:00
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
2010-04-12 23:03:20 -06:00
|
|
|
static struct mfc_cache *ipmr_cache_alloc_unres(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-11-03 01:28:02 -07:00
|
|
|
struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
|
2010-10-01 10:15:08 -06:00
|
|
|
|
|
|
|
if (c) {
|
|
|
|
skb_queue_head_init(&c->mfc_un.unres.unresolved);
|
|
|
|
c->mfc_un.unres.expires = jiffies + 10*HZ;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A cache entry has gone into a resolved state from queued
|
|
|
|
*/
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
static void ipmr_cache_resolve(struct net *net, struct mr_table *mrt,
|
|
|
|
struct mfc_cache *uc, struct mfc_cache *c)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
2005-06-28 13:55:30 -06:00
|
|
|
struct nlmsgerr *e;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
/* Play the pending entries through our router */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-11-03 01:28:02 -07:00
|
|
|
while ((skb = __skb_dequeue(&uc->mfc_un.unres.unresolved))) {
|
2007-04-20 23:47:35 -06:00
|
|
|
if (ip_hdr(skb)->version == 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
struct nlmsghdr *nlh = (struct nlmsghdr *)skb_pull(skb, sizeof(struct iphdr));
|
|
|
|
|
2010-04-26 08:02:08 -06:00
|
|
|
if (__ipmr_fill_mroute(mrt, skb, c, NLMSG_DATA(nlh)) > 0) {
|
2010-10-01 10:15:29 -06:00
|
|
|
nlh->nlmsg_len = skb_tail_pointer(skb) -
|
|
|
|
(u8 *)nlh;
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
|
|
|
nlh->nlmsg_type = NLMSG_ERROR;
|
|
|
|
nlh->nlmsg_len = NLMSG_LENGTH(sizeof(struct nlmsgerr));
|
|
|
|
skb_trim(skb, nlh->nlmsg_len);
|
2005-06-28 13:55:30 -06:00
|
|
|
e = NLMSG_DATA(nlh);
|
|
|
|
e->error = -EMSGSIZE;
|
|
|
|
memset(&e->msg, 0, sizeof(e->msg));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2006-08-15 01:30:25 -06:00
|
|
|
|
2010-04-12 23:03:20 -06:00
|
|
|
rtnl_unicast(skb, net, NETLINK_CB(skb).pid);
|
2010-10-01 10:15:29 -06:00
|
|
|
} else {
|
2010-04-12 23:03:22 -06:00
|
|
|
ip_mr_forward(net, mrt, skb, c, 0);
|
2010-10-01 10:15:29 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Bounce a cache query up to mrouted. We could use netlink for this but mrouted
|
|
|
|
* expects the following bizarre scheme.
|
|
|
|
*
|
|
|
|
* Called under mrt_lock.
|
|
|
|
*/
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
static int ipmr_cache_report(struct mr_table *mrt,
|
2009-01-21 21:56:23 -07:00
|
|
|
struct sk_buff *pkt, vifi_t vifi, int assert)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
2007-03-12 17:09:15 -06:00
|
|
|
const int ihl = ip_hdrlen(pkt);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct igmphdr *igmp;
|
|
|
|
struct igmpmsg *msg;
|
2010-10-01 10:15:01 -06:00
|
|
|
struct sock *mroute_sk;
|
2005-04-16 16:20:36 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_PIMSM
|
|
|
|
if (assert == IGMPMSG_WHOLEPKT)
|
|
|
|
skb = skb_realloc_headroom(pkt, sizeof(struct iphdr));
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
skb = alloc_skb(128, GFP_ATOMIC);
|
|
|
|
|
2007-03-08 21:44:43 -07:00
|
|
|
if (!skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOBUFS;
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_PIMSM
|
|
|
|
if (assert == IGMPMSG_WHOLEPKT) {
|
|
|
|
/* Ugly, but we have no choice with this interface.
|
2010-10-01 10:15:29 -06:00
|
|
|
* Duplicate old header, fix ihl, length etc.
|
|
|
|
* And all this only to mangle msg->im_msgtype and
|
|
|
|
* to set msg->im_mbz to "mbz" :-)
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-03-11 19:38:29 -06:00
|
|
|
skb_push(skb, sizeof(struct iphdr));
|
|
|
|
skb_reset_network_header(skb);
|
2007-03-13 10:06:52 -06:00
|
|
|
skb_reset_transport_header(skb);
|
2007-03-12 17:05:39 -06:00
|
|
|
msg = (struct igmpmsg *)skb_network_header(skb);
|
2007-04-10 21:50:43 -06:00
|
|
|
memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
|
2005-04-16 16:20:36 -06:00
|
|
|
msg->im_msgtype = IGMPMSG_WHOLEPKT;
|
|
|
|
msg->im_mbz = 0;
|
2010-04-12 23:03:22 -06:00
|
|
|
msg->im_vif = mrt->mroute_reg_vif_num;
|
2007-04-20 23:47:35 -06:00
|
|
|
ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
|
|
|
|
ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
|
|
|
|
sizeof(struct iphdr));
|
2007-02-09 07:24:47 -07:00
|
|
|
} else
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-02-09 07:24:47 -07:00
|
|
|
{
|
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
/* Copy the IP header */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-04-19 21:29:13 -06:00
|
|
|
skb->network_header = skb->tail;
|
2007-03-15 18:42:27 -06:00
|
|
|
skb_put(skb, ihl);
|
2007-03-31 08:55:19 -06:00
|
|
|
skb_copy_to_linear_data(skb, pkt->data, ihl);
|
2010-10-01 10:15:29 -06:00
|
|
|
ip_hdr(skb)->protocol = 0; /* Flag to the kernel this is a route add */
|
2007-04-20 23:47:35 -06:00
|
|
|
msg = (struct igmpmsg *)skb_network_header(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
msg->im_vif = vifi;
|
2009-06-01 23:19:30 -06:00
|
|
|
skb_dst_set(skb, dst_clone(skb_dst(pkt)));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
/* Add our header */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
igmp = (struct igmphdr *)skb_put(skb, sizeof(struct igmphdr));
|
2005-04-16 16:20:36 -06:00
|
|
|
igmp->type =
|
|
|
|
msg->im_msgtype = assert;
|
2010-10-01 10:15:29 -06:00
|
|
|
igmp->code = 0;
|
|
|
|
ip_hdr(skb)->tot_len = htons(skb->len); /* Fix the length */
|
2007-04-10 22:21:55 -06:00
|
|
|
skb->transport_header = skb->network_header;
|
2007-02-09 07:24:47 -07:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-10-01 10:15:01 -06:00
|
|
|
rcu_read_lock();
|
|
|
|
mroute_sk = rcu_dereference(mrt->mroute_sk);
|
|
|
|
if (mroute_sk == NULL) {
|
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree_skb(skb);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
/* Deliver to mrouted */
|
|
|
|
|
2010-10-01 10:15:01 -06:00
|
|
|
ret = sock_queue_rcv_skb(mroute_sk, skb);
|
|
|
|
rcu_read_unlock();
|
2009-01-21 21:56:15 -07:00
|
|
|
if (ret < 0) {
|
2012-05-13 15:56:26 -06:00
|
|
|
net_warn_ratelimited("mroute: pending queue full, dropping entries\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Queue a packet for resolution. It gets locked cache entry!
|
|
|
|
*/
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int
|
2010-04-12 23:03:22 -06:00
|
|
|
ipmr_cache_unresolved(struct mr_table *mrt, vifi_t vifi, struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-04-12 23:03:21 -06:00
|
|
|
bool found = false;
|
2005-04-16 16:20:36 -06:00
|
|
|
int err;
|
|
|
|
struct mfc_cache *c;
|
2007-04-20 23:47:35 -06:00
|
|
|
const struct iphdr *iph = ip_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
spin_lock_bh(&mfc_unres_lock);
|
2010-04-12 23:03:22 -06:00
|
|
|
list_for_each_entry(c, &mrt->mfc_unres_queue, list) {
|
2010-04-12 23:03:19 -06:00
|
|
|
if (c->mfc_mcastgrp == iph->daddr &&
|
2010-04-12 23:03:21 -06:00
|
|
|
c->mfc_origin == iph->saddr) {
|
|
|
|
found = true;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2010-04-12 23:03:21 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-04-12 23:03:21 -06:00
|
|
|
if (!found) {
|
2010-10-01 10:15:29 -06:00
|
|
|
/* Create a new entry if allowable */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
if (atomic_read(&mrt->cache_resolve_queue_len) >= 10 ||
|
2010-04-12 23:03:20 -06:00
|
|
|
(c = ipmr_cache_alloc_unres()) == NULL) {
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
return -ENOBUFS;
|
|
|
|
}
|
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
/* Fill in the new cache entry */
|
|
|
|
|
2007-04-20 23:47:35 -06:00
|
|
|
c->mfc_parent = -1;
|
|
|
|
c->mfc_origin = iph->saddr;
|
|
|
|
c->mfc_mcastgrp = iph->daddr;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
/* Reflect first query at mrouted. */
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
err = ipmr_cache_report(mrt, skb, vifi, IGMPMSG_NOCACHE);
|
2009-01-21 21:56:23 -07:00
|
|
|
if (err < 0) {
|
2007-02-09 07:24:47 -07:00
|
|
|
/* If the report failed throw the cache entry
|
2005-04-16 16:20:36 -06:00
|
|
|
out - Brad Parker
|
|
|
|
*/
|
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
|
2009-01-21 21:56:17 -07:00
|
|
|
ipmr_cache_free(c);
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree_skb(skb);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
atomic_inc(&mrt->cache_resolve_queue_len);
|
|
|
|
list_add(&c->list, &mrt->mfc_unres_queue);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-05-12 01:05:35 -06:00
|
|
|
if (atomic_read(&mrt->cache_resolve_queue_len) == 1)
|
|
|
|
mod_timer(&mrt->ipmr_expire_timer, c->mfc_un.unres.expires);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
/* See if we can append the packet */
|
|
|
|
|
|
|
|
if (c->mfc_un.unres.unresolved.qlen > 3) {
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree_skb(skb);
|
|
|
|
err = -ENOBUFS;
|
|
|
|
} else {
|
2008-11-03 01:28:02 -07:00
|
|
|
skb_queue_tail(&c->mfc_un.unres.unresolved, skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
err = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* MFC cache manipulation by user space mroute daemon
|
|
|
|
*/
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
static int ipmr_mfc_delete(struct mr_table *mrt, struct mfcctl *mfc)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int line;
|
2010-04-12 23:03:21 -06:00
|
|
|
struct mfc_cache *c, *next;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-11-03 01:28:02 -07:00
|
|
|
line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
list_for_each_entry_safe(c, next, &mrt->mfc_cache_array[line], list) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
|
|
|
|
c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
|
2010-10-01 10:15:08 -06:00
|
|
|
list_del_rcu(&c->list);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-01-21 21:56:17 -07:00
|
|
|
ipmr_cache_free(c);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
static int ipmr_mfc_add(struct net *net, struct mr_table *mrt,
|
|
|
|
struct mfcctl *mfc, int mrtsock)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2010-04-12 23:03:21 -06:00
|
|
|
bool found = false;
|
2005-04-16 16:20:36 -06:00
|
|
|
int line;
|
2010-04-12 23:03:21 -06:00
|
|
|
struct mfc_cache *uc, *c;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-03-17 00:04:14 -06:00
|
|
|
if (mfc->mfcc_parent >= MAXVIFS)
|
|
|
|
return -ENFILE;
|
|
|
|
|
2008-11-03 01:28:02 -07:00
|
|
|
line = MFC_HASH(mfc->mfcc_mcastgrp.s_addr, mfc->mfcc_origin.s_addr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
list_for_each_entry(c, &mrt->mfc_cache_array[line], list) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (c->mfc_origin == mfc->mfcc_origin.s_addr &&
|
2010-04-12 23:03:21 -06:00
|
|
|
c->mfc_mcastgrp == mfc->mfcc_mcastgrp.s_addr) {
|
|
|
|
found = true;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2010-04-12 23:03:21 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-04-12 23:03:21 -06:00
|
|
|
if (found) {
|
2005-04-16 16:20:36 -06:00
|
|
|
write_lock_bh(&mrt_lock);
|
|
|
|
c->mfc_parent = mfc->mfcc_parent;
|
2010-04-12 23:03:22 -06:00
|
|
|
ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!mrtsock)
|
|
|
|
c->mfc_flags |= MFC_STATIC;
|
|
|
|
write_unlock_bh(&mrt_lock);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-12-16 14:45:43 -07:00
|
|
|
if (!ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2010-04-12 23:03:20 -06:00
|
|
|
c = ipmr_cache_alloc();
|
2008-11-03 01:28:02 -07:00
|
|
|
if (c == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-11-03 01:28:02 -07:00
|
|
|
c->mfc_origin = mfc->mfcc_origin.s_addr;
|
|
|
|
c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr;
|
|
|
|
c->mfc_parent = mfc->mfcc_parent;
|
2010-04-12 23:03:22 -06:00
|
|
|
ipmr_update_thresholds(mrt, c, mfc->mfcc_ttls);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!mrtsock)
|
|
|
|
c->mfc_flags |= MFC_STATIC;
|
|
|
|
|
2010-10-01 10:15:08 -06:00
|
|
|
list_add_rcu(&c->list, &mrt->mfc_cache_array[line]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Check to see if we resolved a queued list. If so we
|
|
|
|
* need to send on the frames and tidy up.
|
|
|
|
*/
|
2010-04-15 05:29:28 -06:00
|
|
|
found = false;
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_lock_bh(&mfc_unres_lock);
|
2010-04-12 23:03:22 -06:00
|
|
|
list_for_each_entry(uc, &mrt->mfc_unres_queue, list) {
|
2010-04-12 23:03:19 -06:00
|
|
|
if (uc->mfc_origin == c->mfc_origin &&
|
2005-04-16 16:20:36 -06:00
|
|
|
uc->mfc_mcastgrp == c->mfc_mcastgrp) {
|
2010-04-12 23:03:21 -06:00
|
|
|
list_del(&uc->list);
|
2010-04-12 23:03:22 -06:00
|
|
|
atomic_dec(&mrt->cache_resolve_queue_len);
|
2010-04-15 05:29:28 -06:00
|
|
|
found = true;
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-04-12 23:03:22 -06:00
|
|
|
if (list_empty(&mrt->mfc_unres_queue))
|
|
|
|
del_timer(&mrt->ipmr_expire_timer);
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
|
2010-04-15 05:29:28 -06:00
|
|
|
if (found) {
|
2010-04-12 23:03:22 -06:00
|
|
|
ipmr_cache_resolve(net, mrt, uc, c);
|
2009-01-21 21:56:17 -07:00
|
|
|
ipmr_cache_free(uc);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Close the multicast socket, and clear the vif tables etc
|
|
|
|
*/
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
static void mroute_clean_tables(struct mr_table *mrt)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int i;
|
2009-10-27 23:21:38 -06:00
|
|
|
LIST_HEAD(list);
|
2010-04-12 23:03:21 -06:00
|
|
|
struct mfc_cache *c, *next;
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
/* Shut down all active vif entries */
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
for (i = 0; i < mrt->maxvif; i++) {
|
2010-10-01 10:15:29 -06:00
|
|
|
if (!(mrt->vif_table[i].flags & VIFF_STATIC))
|
2010-04-12 23:03:22 -06:00
|
|
|
vif_delete(mrt, i, 0, &list);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-10-27 23:21:38 -06:00
|
|
|
unregister_netdevice_many(&list);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
/* Wipe the cache */
|
|
|
|
|
2010-04-12 23:03:21 -06:00
|
|
|
for (i = 0; i < MFC_LINES; i++) {
|
2010-04-12 23:03:22 -06:00
|
|
|
list_for_each_entry_safe(c, next, &mrt->mfc_cache_array[i], list) {
|
2010-10-01 10:15:08 -06:00
|
|
|
if (c->mfc_flags & MFC_STATIC)
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
2010-10-01 10:15:08 -06:00
|
|
|
list_del_rcu(&c->list);
|
2009-01-21 21:56:17 -07:00
|
|
|
ipmr_cache_free(c);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_lock_bh(&mfc_unres_lock);
|
2010-04-12 23:03:22 -06:00
|
|
|
list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
|
2010-04-12 23:03:21 -06:00
|
|
|
list_del(&c->list);
|
2010-04-12 23:03:22 -06:00
|
|
|
ipmr_destroy_unres(mrt, c);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-01 10:15:01 -06:00
|
|
|
/* called from ip_ra_control(), before an RCU grace period,
|
|
|
|
* we dont need to call synchronize_rcu() here
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
static void mrtsock_destruct(struct sock *sk)
|
|
|
|
{
|
2009-01-21 21:56:23 -07:00
|
|
|
struct net *net = sock_net(sk);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt;
|
2009-01-21 21:56:23 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
rtnl_lock();
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
ipmr_for_each_table(mrt, net) {
|
2010-10-01 10:15:01 -06:00
|
|
|
if (sk == rtnl_dereference(mrt->mroute_sk)) {
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
|
2011-08-01 10:19:00 -06:00
|
|
|
RCU_INIT_POINTER(mrt->mroute_sk, NULL);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
mroute_clean_tables(mrt);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
rtnl_unlock();
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Socket options and virtual interface manipulation. The whole
|
|
|
|
* virtual interface system is a complete heap, but unfortunately
|
|
|
|
* that's how BSD mrouted happens to think. Maybe one day with a proper
|
|
|
|
* MOSPF/PIM router set up we can clean this up.
|
|
|
|
*/
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2009-09-30 17:12:20 -06:00
|
|
|
int ip_mroute_setsockopt(struct sock *sk, int optname, char __user *optval, unsigned int optlen)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
struct vifctl vif;
|
|
|
|
struct mfcctl mfc;
|
2009-01-21 21:56:23 -07:00
|
|
|
struct net *net = sock_net(sk);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt;
|
|
|
|
|
|
|
|
mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return -ENOENT;
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2007-03-08 21:44:43 -07:00
|
|
|
if (optname != MRT_INIT) {
|
2011-08-11 13:30:52 -06:00
|
|
|
if (sk != rcu_access_pointer(mrt->mroute_sk) &&
|
2010-10-01 10:15:01 -06:00
|
|
|
!capable(CAP_NET_ADMIN))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EACCES;
|
|
|
|
}
|
|
|
|
|
2007-03-08 21:44:43 -07:00
|
|
|
switch (optname) {
|
|
|
|
case MRT_INIT:
|
|
|
|
if (sk->sk_type != SOCK_RAW ||
|
2009-10-15 00:30:45 -06:00
|
|
|
inet_sk(sk)->inet_num != IPPROTO_IGMP)
|
2007-03-08 21:44:43 -07:00
|
|
|
return -EOPNOTSUPP;
|
2008-11-03 01:28:02 -07:00
|
|
|
if (optlen != sizeof(int))
|
2007-03-08 21:44:43 -07:00
|
|
|
return -ENOPROTOOPT;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-03-08 21:44:43 -07:00
|
|
|
rtnl_lock();
|
2010-10-01 10:15:01 -06:00
|
|
|
if (rtnl_dereference(mrt->mroute_sk)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
rtnl_unlock();
|
2007-03-08 21:44:43 -07:00
|
|
|
return -EADDRINUSE;
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = ip_ra_control(sk, 1, mrtsock_destruct);
|
|
|
|
if (ret == 0) {
|
2012-01-11 21:41:32 -07:00
|
|
|
rcu_assign_pointer(mrt->mroute_sk, sk);
|
2009-01-21 21:56:23 -07:00
|
|
|
IPV4_DEVCONF_ALL(net, MC_FORWARDING)++;
|
2007-03-08 21:44:43 -07:00
|
|
|
}
|
|
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
|
|
|
case MRT_DONE:
|
2011-08-11 13:30:52 -06:00
|
|
|
if (sk != rcu_access_pointer(mrt->mroute_sk))
|
2007-03-08 21:44:43 -07:00
|
|
|
return -EACCES;
|
|
|
|
return ip_ra_control(sk, 0, NULL);
|
|
|
|
case MRT_ADD_VIF:
|
|
|
|
case MRT_DEL_VIF:
|
2008-11-03 01:28:02 -07:00
|
|
|
if (optlen != sizeof(vif))
|
2007-03-08 21:44:43 -07:00
|
|
|
return -EINVAL;
|
2008-11-03 01:28:02 -07:00
|
|
|
if (copy_from_user(&vif, optval, sizeof(vif)))
|
2007-03-08 21:44:43 -07:00
|
|
|
return -EFAULT;
|
|
|
|
if (vif.vifc_vifi >= MAXVIFS)
|
|
|
|
return -ENFILE;
|
|
|
|
rtnl_lock();
|
2008-11-03 01:28:02 -07:00
|
|
|
if (optname == MRT_ADD_VIF) {
|
2010-10-01 10:15:01 -06:00
|
|
|
ret = vif_add(net, mrt, &vif,
|
|
|
|
sk == rtnl_dereference(mrt->mroute_sk));
|
2007-03-08 21:44:43 -07:00
|
|
|
} else {
|
2010-04-12 23:03:22 -06:00
|
|
|
ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL);
|
2007-03-08 21:44:43 -07:00
|
|
|
}
|
|
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Manipulate the forwarding caches. These live
|
|
|
|
* in a sort of kernel/user symbiosis.
|
|
|
|
*/
|
2007-03-08 21:44:43 -07:00
|
|
|
case MRT_ADD_MFC:
|
|
|
|
case MRT_DEL_MFC:
|
2008-11-03 01:28:02 -07:00
|
|
|
if (optlen != sizeof(mfc))
|
2007-03-08 21:44:43 -07:00
|
|
|
return -EINVAL;
|
2008-11-03 01:28:02 -07:00
|
|
|
if (copy_from_user(&mfc, optval, sizeof(mfc)))
|
2007-03-08 21:44:43 -07:00
|
|
|
return -EFAULT;
|
|
|
|
rtnl_lock();
|
2008-11-03 01:28:02 -07:00
|
|
|
if (optname == MRT_DEL_MFC)
|
2010-04-12 23:03:22 -06:00
|
|
|
ret = ipmr_mfc_delete(mrt, &mfc);
|
2007-03-08 21:44:43 -07:00
|
|
|
else
|
2010-10-01 10:15:01 -06:00
|
|
|
ret = ipmr_mfc_add(net, mrt, &mfc,
|
|
|
|
sk == rtnl_dereference(mrt->mroute_sk));
|
2007-03-08 21:44:43 -07:00
|
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Control PIM assert.
|
|
|
|
*/
|
2007-03-08 21:44:43 -07:00
|
|
|
case MRT_ASSERT:
|
|
|
|
{
|
|
|
|
int v;
|
2010-10-01 10:15:29 -06:00
|
|
|
if (get_user(v, (int __user *)optval))
|
2007-03-08 21:44:43 -07:00
|
|
|
return -EFAULT;
|
2010-04-12 23:03:22 -06:00
|
|
|
mrt->mroute_do_assert = (v) ? 1 : 0;
|
2007-03-08 21:44:43 -07:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_IP_PIMSM
|
2007-03-08 21:44:43 -07:00
|
|
|
case MRT_PIM:
|
|
|
|
{
|
2008-01-21 18:28:59 -07:00
|
|
|
int v;
|
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
if (get_user(v, (int __user *)optval))
|
2007-03-08 21:44:43 -07:00
|
|
|
return -EFAULT;
|
2008-01-21 18:28:59 -07:00
|
|
|
v = (v) ? 1 : 0;
|
|
|
|
|
2007-03-08 21:44:43 -07:00
|
|
|
rtnl_lock();
|
|
|
|
ret = 0;
|
2010-04-12 23:03:22 -06:00
|
|
|
if (v != mrt->mroute_do_pim) {
|
|
|
|
mrt->mroute_do_pim = v;
|
|
|
|
mrt->mroute_do_assert = v;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-03-08 21:44:43 -07:00
|
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
|
|
|
}
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
#endif
|
|
|
|
#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
|
|
|
|
case MRT_TABLE:
|
|
|
|
{
|
|
|
|
u32 v;
|
|
|
|
|
|
|
|
if (optlen != sizeof(u32))
|
|
|
|
return -EINVAL;
|
|
|
|
if (get_user(v, (u32 __user *)optval))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
rtnl_lock();
|
|
|
|
ret = 0;
|
2010-10-01 10:15:01 -06:00
|
|
|
if (sk == rtnl_dereference(mrt->mroute_sk)) {
|
|
|
|
ret = -EBUSY;
|
|
|
|
} else {
|
|
|
|
if (!ipmr_new_table(net, v))
|
|
|
|
ret = -ENOMEM;
|
|
|
|
raw_sk(sk)->ipmr_table = v;
|
|
|
|
}
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
rtnl_unlock();
|
|
|
|
return ret;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2007-03-08 21:44:43 -07:00
|
|
|
/*
|
|
|
|
* Spurious command, or MRT_VERSION which you cannot
|
|
|
|
* set.
|
|
|
|
*/
|
|
|
|
default:
|
|
|
|
return -ENOPROTOOPT;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Getsock opt support for the multicast routing system.
|
|
|
|
*/
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2008-11-03 01:28:02 -07:00
|
|
|
int ip_mroute_getsockopt(struct sock *sk, int optname, char __user *optval, int __user *optlen)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int olr;
|
|
|
|
int val;
|
2009-01-21 21:56:23 -07:00
|
|
|
struct net *net = sock_net(sk);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt;
|
|
|
|
|
|
|
|
mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return -ENOENT;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-11-03 01:28:02 -07:00
|
|
|
if (optname != MRT_VERSION &&
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_IP_PIMSM
|
2010-10-01 10:15:29 -06:00
|
|
|
optname != MRT_PIM &&
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
2010-10-01 10:15:29 -06:00
|
|
|
optname != MRT_ASSERT)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOPROTOOPT;
|
|
|
|
|
|
|
|
if (get_user(olr, optlen))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
olr = min_t(unsigned int, olr, sizeof(int));
|
|
|
|
if (olr < 0)
|
|
|
|
return -EINVAL;
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2008-11-03 01:28:02 -07:00
|
|
|
if (put_user(olr, optlen))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
2008-11-03 01:28:02 -07:00
|
|
|
if (optname == MRT_VERSION)
|
|
|
|
val = 0x0305;
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_IP_PIMSM
|
2008-11-03 01:28:02 -07:00
|
|
|
else if (optname == MRT_PIM)
|
2010-04-12 23:03:22 -06:00
|
|
|
val = mrt->mroute_do_pim;
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
else
|
2010-04-12 23:03:22 -06:00
|
|
|
val = mrt->mroute_do_assert;
|
2008-11-03 01:28:02 -07:00
|
|
|
if (copy_to_user(optval, &val, olr))
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The IP multicast ioctl support routines.
|
|
|
|
*/
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
int ipmr_ioctl(struct sock *sk, int cmd, void __user *arg)
|
|
|
|
{
|
|
|
|
struct sioc_sg_req sr;
|
|
|
|
struct sioc_vif_req vr;
|
|
|
|
struct vif_device *vif;
|
|
|
|
struct mfc_cache *c;
|
2009-01-21 21:56:23 -07:00
|
|
|
struct net *net = sock_net(sk);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt;
|
|
|
|
|
|
|
|
mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return -ENOENT;
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2007-03-08 21:44:43 -07:00
|
|
|
switch (cmd) {
|
|
|
|
case SIOCGETVIFCNT:
|
2008-11-03 01:28:02 -07:00
|
|
|
if (copy_from_user(&vr, arg, sizeof(vr)))
|
2007-03-08 21:44:43 -07:00
|
|
|
return -EFAULT;
|
2010-04-12 23:03:22 -06:00
|
|
|
if (vr.vifi >= mrt->maxvif)
|
2007-03-08 21:44:43 -07:00
|
|
|
return -EINVAL;
|
|
|
|
read_lock(&mrt_lock);
|
2010-04-12 23:03:22 -06:00
|
|
|
vif = &mrt->vif_table[vr.vifi];
|
|
|
|
if (VIF_EXISTS(mrt, vr.vifi)) {
|
2008-11-03 01:28:02 -07:00
|
|
|
vr.icount = vif->pkt_in;
|
|
|
|
vr.ocount = vif->pkt_out;
|
|
|
|
vr.ibytes = vif->bytes_in;
|
|
|
|
vr.obytes = vif->bytes_out;
|
2005-04-16 16:20:36 -06:00
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
|
2008-11-03 01:28:02 -07:00
|
|
|
if (copy_to_user(arg, &vr, sizeof(vr)))
|
2007-03-08 21:44:43 -07:00
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
case SIOCGETSGCNT:
|
2008-11-03 01:28:02 -07:00
|
|
|
if (copy_from_user(&sr, arg, sizeof(sr)))
|
2007-03-08 21:44:43 -07:00
|
|
|
return -EFAULT;
|
|
|
|
|
2010-10-01 10:15:08 -06:00
|
|
|
rcu_read_lock();
|
2010-04-12 23:03:22 -06:00
|
|
|
c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
|
2007-03-08 21:44:43 -07:00
|
|
|
if (c) {
|
|
|
|
sr.pktcnt = c->mfc_un.res.pkt;
|
|
|
|
sr.bytecnt = c->mfc_un.res.bytes;
|
|
|
|
sr.wrong_if = c->mfc_un.res.wrong_if;
|
2010-10-01 10:15:08 -06:00
|
|
|
rcu_read_unlock();
|
2007-03-08 21:44:43 -07:00
|
|
|
|
2008-11-03 01:28:02 -07:00
|
|
|
if (copy_to_user(arg, &sr, sizeof(sr)))
|
2007-03-08 21:44:43 -07:00
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
2010-10-01 10:15:08 -06:00
|
|
|
rcu_read_unlock();
|
2007-03-08 21:44:43 -07:00
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
default:
|
|
|
|
return -ENOIOCTLCMD;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-29 09:15:56 -07:00
|
|
|
#ifdef CONFIG_COMPAT
|
|
|
|
struct compat_sioc_sg_req {
|
|
|
|
struct in_addr src;
|
|
|
|
struct in_addr grp;
|
|
|
|
compat_ulong_t pktcnt;
|
|
|
|
compat_ulong_t bytecnt;
|
|
|
|
compat_ulong_t wrong_if;
|
|
|
|
};
|
|
|
|
|
2011-02-03 18:24:28 -07:00
|
|
|
struct compat_sioc_vif_req {
|
|
|
|
vifi_t vifi; /* Which iface */
|
|
|
|
compat_ulong_t icount;
|
|
|
|
compat_ulong_t ocount;
|
|
|
|
compat_ulong_t ibytes;
|
|
|
|
compat_ulong_t obytes;
|
|
|
|
};
|
|
|
|
|
2011-01-29 09:15:56 -07:00
|
|
|
int ipmr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
|
|
|
|
{
|
2011-02-03 18:21:31 -07:00
|
|
|
struct compat_sioc_sg_req sr;
|
2011-02-03 18:24:28 -07:00
|
|
|
struct compat_sioc_vif_req vr;
|
|
|
|
struct vif_device *vif;
|
2011-01-29 09:15:56 -07:00
|
|
|
struct mfc_cache *c;
|
|
|
|
struct net *net = sock_net(sk);
|
|
|
|
struct mr_table *mrt;
|
|
|
|
|
|
|
|
mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
switch (cmd) {
|
2011-02-03 18:24:28 -07:00
|
|
|
case SIOCGETVIFCNT:
|
|
|
|
if (copy_from_user(&vr, arg, sizeof(vr)))
|
|
|
|
return -EFAULT;
|
|
|
|
if (vr.vifi >= mrt->maxvif)
|
|
|
|
return -EINVAL;
|
|
|
|
read_lock(&mrt_lock);
|
|
|
|
vif = &mrt->vif_table[vr.vifi];
|
|
|
|
if (VIF_EXISTS(mrt, vr.vifi)) {
|
|
|
|
vr.icount = vif->pkt_in;
|
|
|
|
vr.ocount = vif->pkt_out;
|
|
|
|
vr.ibytes = vif->bytes_in;
|
|
|
|
vr.obytes = vif->bytes_out;
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
|
|
|
|
if (copy_to_user(arg, &vr, sizeof(vr)))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
return -EADDRNOTAVAIL;
|
2011-01-29 09:15:56 -07:00
|
|
|
case SIOCGETSGCNT:
|
|
|
|
if (copy_from_user(&sr, arg, sizeof(sr)))
|
|
|
|
return -EFAULT;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
c = ipmr_cache_find(mrt, sr.src.s_addr, sr.grp.s_addr);
|
|
|
|
if (c) {
|
|
|
|
sr.pktcnt = c->mfc_un.res.pkt;
|
|
|
|
sr.bytecnt = c->mfc_un.res.bytes;
|
|
|
|
sr.wrong_if = c->mfc_un.res.wrong_if;
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
if (copy_to_user(arg, &sr, sizeof(sr)))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
default:
|
|
|
|
return -ENOIOCTLCMD;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
|
|
|
|
{
|
2007-09-12 05:02:17 -06:00
|
|
|
struct net_device *dev = ptr;
|
2009-01-21 21:56:23 -07:00
|
|
|
struct net *net = dev_net(dev);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct vif_device *v;
|
|
|
|
int ct;
|
2007-09-12 05:02:17 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (event != NETDEV_UNREGISTER)
|
|
|
|
return NOTIFY_DONE;
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
|
|
|
|
ipmr_for_each_table(mrt, net) {
|
|
|
|
v = &mrt->vif_table[0];
|
|
|
|
for (ct = 0; ct < mrt->maxvif; ct++, v++) {
|
|
|
|
if (v->dev == dev)
|
2011-11-23 16:10:52 -07:00
|
|
|
vif_delete(mrt, ct, 1, NULL);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-11-03 01:28:02 -07:00
|
|
|
static struct notifier_block ip_mr_notifier = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.notifier_call = ipmr_device_event,
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
2010-10-01 10:15:29 -06:00
|
|
|
* Encapsulate a packet by attaching a valid IPIP header to it.
|
2005-04-16 16:20:36 -06:00
|
|
|
* This avoids tunnel drivers and other mess and gives us the speed so
|
|
|
|
* important for multicast video.
|
|
|
|
*/
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2006-09-27 19:39:29 -06:00
|
|
|
static void ip_encap(struct sk_buff *skb, __be32 saddr, __be32 daddr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-03-10 15:40:39 -07:00
|
|
|
struct iphdr *iph;
|
2011-04-21 22:53:02 -06:00
|
|
|
const struct iphdr *old_iph = ip_hdr(skb);
|
2007-03-10 15:40:39 -07:00
|
|
|
|
|
|
|
skb_push(skb, sizeof(struct iphdr));
|
2007-04-10 22:21:55 -06:00
|
|
|
skb->transport_header = skb->network_header;
|
2007-03-10 15:40:39 -07:00
|
|
|
skb_reset_network_header(skb);
|
2007-04-20 23:47:35 -06:00
|
|
|
iph = ip_hdr(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
iph->version = 4;
|
2007-03-12 17:09:36 -06:00
|
|
|
iph->tos = old_iph->tos;
|
|
|
|
iph->ttl = old_iph->ttl;
|
2005-04-16 16:20:36 -06:00
|
|
|
iph->frag_off = 0;
|
|
|
|
iph->daddr = daddr;
|
|
|
|
iph->saddr = saddr;
|
|
|
|
iph->protocol = IPPROTO_IPIP;
|
|
|
|
iph->ihl = 5;
|
|
|
|
iph->tot_len = htons(skb->len);
|
2009-06-01 23:19:30 -06:00
|
|
|
ip_select_ident(iph, skb_dst(skb), NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
ip_send_check(iph);
|
|
|
|
|
|
|
|
memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
|
|
|
|
nf_reset(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int ipmr_forward_finish(struct sk_buff *skb)
|
|
|
|
{
|
2010-10-01 10:15:29 -06:00
|
|
|
struct ip_options *opt = &(IPCB(skb)->opt);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-06-01 23:19:30 -06:00
|
|
|
IP_INC_STATS_BH(dev_net(skb_dst(skb)->dev), IPSTATS_MIB_OUTFORWDATAGRAMS);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (unlikely(opt->optlen))
|
|
|
|
ip_forward_options(skb);
|
|
|
|
|
|
|
|
return dst_output(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Processing handlers for ipmr_forward
|
|
|
|
*/
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
static void ipmr_queue_xmit(struct net *net, struct mr_table *mrt,
|
|
|
|
struct sk_buff *skb, struct mfc_cache *c, int vifi)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-04-20 23:47:35 -06:00
|
|
|
const struct iphdr *iph = ip_hdr(skb);
|
2010-04-12 23:03:22 -06:00
|
|
|
struct vif_device *vif = &mrt->vif_table[vifi];
|
2005-04-16 16:20:36 -06:00
|
|
|
struct net_device *dev;
|
|
|
|
struct rtable *rt;
|
2011-05-03 21:25:42 -06:00
|
|
|
struct flowi4 fl4;
|
2005-04-16 16:20:36 -06:00
|
|
|
int encap = 0;
|
|
|
|
|
|
|
|
if (vif->dev == NULL)
|
|
|
|
goto out_free;
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_PIMSM
|
|
|
|
if (vif->flags & VIFF_REGISTER) {
|
|
|
|
vif->pkt_out++;
|
2008-11-03 01:28:02 -07:00
|
|
|
vif->bytes_out += skb->len;
|
2008-05-21 15:17:33 -06:00
|
|
|
vif->dev->stats.tx_bytes += skb->len;
|
|
|
|
vif->dev->stats.tx_packets++;
|
2010-04-12 23:03:22 -06:00
|
|
|
ipmr_cache_report(mrt, skb, vifi, IGMPMSG_WHOLEPKT);
|
2009-02-07 00:46:51 -07:00
|
|
|
goto out_free;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
if (vif->flags & VIFF_TUNNEL) {
|
2011-05-03 21:25:42 -06:00
|
|
|
rt = ip_route_output_ports(net, &fl4, NULL,
|
2011-03-11 22:00:52 -07:00
|
|
|
vif->remote, vif->local,
|
|
|
|
0, 0,
|
|
|
|
IPPROTO_IPIP,
|
|
|
|
RT_TOS(iph->tos), vif->link);
|
2011-03-02 15:31:35 -07:00
|
|
|
if (IS_ERR(rt))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out_free;
|
|
|
|
encap = sizeof(struct iphdr);
|
|
|
|
} else {
|
2011-05-03 21:25:42 -06:00
|
|
|
rt = ip_route_output_ports(net, &fl4, NULL, iph->daddr, 0,
|
2011-03-11 22:00:52 -07:00
|
|
|
0, 0,
|
|
|
|
IPPROTO_IPIP,
|
|
|
|
RT_TOS(iph->tos), vif->link);
|
2011-03-02 15:31:35 -07:00
|
|
|
if (IS_ERR(rt))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
2010-06-11 00:31:35 -06:00
|
|
|
dev = rt->dst.dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-06-11 00:31:35 -06:00
|
|
|
if (skb->len+encap > dst_mtu(&rt->dst) && (ntohs(iph->frag_off) & IP_DF)) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Do not fragment multicasts. Alas, IPv4 does not
|
2010-10-01 10:15:29 -06:00
|
|
|
* allow to send ICMP, so that packets will disappear
|
|
|
|
* to blackhole.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
2008-07-16 21:20:11 -06:00
|
|
|
IP_INC_STATS_BH(dev_net(dev), IPSTATS_MIB_FRAGFAILS);
|
2005-04-16 16:20:36 -06:00
|
|
|
ip_rt_put(rt);
|
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
2010-06-11 00:31:35 -06:00
|
|
|
encap += LL_RESERVED_SPACE(dev) + rt->dst.header_len;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (skb_cow(skb, encap)) {
|
2007-02-09 07:24:47 -07:00
|
|
|
ip_rt_put(rt);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
|
|
|
vif->pkt_out++;
|
2008-11-03 01:28:02 -07:00
|
|
|
vif->bytes_out += skb->len;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-06-01 23:19:30 -06:00
|
|
|
skb_dst_drop(skb);
|
2010-06-11 00:31:35 -06:00
|
|
|
skb_dst_set(skb, &rt->dst);
|
2007-04-20 23:47:35 -06:00
|
|
|
ip_decrease_ttl(ip_hdr(skb));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* FIXME: forward and output firewalls used to be called here.
|
2010-10-01 10:15:29 -06:00
|
|
|
* What do we do with netfilter? -- RR
|
|
|
|
*/
|
2005-04-16 16:20:36 -06:00
|
|
|
if (vif->flags & VIFF_TUNNEL) {
|
|
|
|
ip_encap(skb, vif->local, vif->remote);
|
|
|
|
/* FIXME: extra output firewall step used to be here. --RR */
|
2008-05-21 15:16:14 -06:00
|
|
|
vif->dev->stats.tx_packets++;
|
|
|
|
vif->dev->stats.tx_bytes += skb->len;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
IPCB(skb)->flags |= IPSKB_FORWARDED;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
|
|
|
|
* not only before forwarding, but after forwarding on all output
|
|
|
|
* interfaces. It is clear, if mrouter runs a multicasting
|
|
|
|
* program, it should receive packets not depending to what interface
|
|
|
|
* program is joined.
|
|
|
|
* If we will not make it, the program will have to join on all
|
|
|
|
* interfaces. On the other hand, multihoming host (or router, but
|
|
|
|
* not mrouter) cannot join to more than one interface - it will
|
|
|
|
* result in receiving multiple packets.
|
|
|
|
*/
|
2010-03-22 21:07:29 -06:00
|
|
|
NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD, skb, skb->dev, dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
ipmr_forward_finish);
|
|
|
|
return;
|
|
|
|
|
|
|
|
out_free:
|
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
static int ipmr_find_vif(struct mr_table *mrt, struct net_device *dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int ct;
|
2010-04-12 23:03:22 -06:00
|
|
|
|
|
|
|
for (ct = mrt->maxvif-1; ct >= 0; ct--) {
|
|
|
|
if (mrt->vif_table[ct].dev == dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ct;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* "local" means that we should preserve one skb (for local delivery) */
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
static int ip_mr_forward(struct net *net, struct mr_table *mrt,
|
|
|
|
struct sk_buff *skb, struct mfc_cache *cache,
|
|
|
|
int local)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int psend = -1;
|
|
|
|
int vif, ct;
|
|
|
|
|
|
|
|
vif = cache->mfc_parent;
|
|
|
|
cache->mfc_un.res.pkt++;
|
|
|
|
cache->mfc_un.res.bytes += skb->len;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Wrong interface: drop packet and (maybe) send PIM assert.
|
|
|
|
*/
|
2010-04-12 23:03:22 -06:00
|
|
|
if (mrt->vif_table[vif].dev != skb->dev) {
|
2005-04-16 16:20:36 -06:00
|
|
|
int true_vifi;
|
|
|
|
|
2010-11-11 18:07:48 -07:00
|
|
|
if (rt_is_output_route(skb_rtable(skb))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
/* It is our own packet, looped back.
|
2010-10-01 10:15:29 -06:00
|
|
|
* Very complicated situation...
|
|
|
|
*
|
|
|
|
* The best workaround until routing daemons will be
|
|
|
|
* fixed is not to redistribute packet, if it was
|
|
|
|
* send through wrong interface. It means, that
|
|
|
|
* multicast applications WILL NOT work for
|
|
|
|
* (S,G), which have default multicast route pointing
|
|
|
|
* to wrong oif. In any case, it is not a good
|
|
|
|
* idea to use multicasting applications on router.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
goto dont_forward;
|
|
|
|
}
|
|
|
|
|
|
|
|
cache->mfc_un.res.wrong_if++;
|
2010-04-12 23:03:22 -06:00
|
|
|
true_vifi = ipmr_find_vif(mrt, skb->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
if (true_vifi >= 0 && mrt->mroute_do_assert &&
|
2005-04-16 16:20:36 -06:00
|
|
|
/* pimsm uses asserts, when switching from RPT to SPT,
|
2010-10-01 10:15:29 -06:00
|
|
|
* so that we cannot check that packet arrived on an oif.
|
|
|
|
* It is bad, but otherwise we would need to move pretty
|
|
|
|
* large chunk of pimd to kernel. Ough... --ANK
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2010-04-12 23:03:22 -06:00
|
|
|
(mrt->mroute_do_pim ||
|
2009-01-21 21:56:20 -07:00
|
|
|
cache->mfc_un.res.ttls[true_vifi] < 255) &&
|
2007-02-09 07:24:47 -07:00
|
|
|
time_after(jiffies,
|
2005-04-16 16:20:36 -06:00
|
|
|
cache->mfc_un.res.last_assert + MFC_ASSERT_THRESH)) {
|
|
|
|
cache->mfc_un.res.last_assert = jiffies;
|
2010-04-12 23:03:22 -06:00
|
|
|
ipmr_cache_report(mrt, skb, true_vifi, IGMPMSG_WRONGVIF);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
goto dont_forward;
|
|
|
|
}
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
mrt->vif_table[vif].pkt_in++;
|
|
|
|
mrt->vif_table[vif].bytes_in += skb->len;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Forward the frame
|
|
|
|
*/
|
2010-10-01 10:15:29 -06:00
|
|
|
for (ct = cache->mfc_un.res.maxvif - 1;
|
|
|
|
ct >= cache->mfc_un.res.minvif; ct--) {
|
2007-04-20 23:47:35 -06:00
|
|
|
if (ip_hdr(skb)->ttl > cache->mfc_un.res.ttls[ct]) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (psend != -1) {
|
|
|
|
struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
|
2010-10-01 10:15:29 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (skb2)
|
2010-04-12 23:03:22 -06:00
|
|
|
ipmr_queue_xmit(net, mrt, skb2, cache,
|
|
|
|
psend);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2008-11-03 01:28:02 -07:00
|
|
|
psend = ct;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (psend != -1) {
|
|
|
|
if (local) {
|
|
|
|
struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
|
2010-10-01 10:15:29 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (skb2)
|
2010-04-12 23:03:22 -06:00
|
|
|
ipmr_queue_xmit(net, mrt, skb2, cache, psend);
|
2005-04-16 16:20:36 -06:00
|
|
|
} else {
|
2010-04-12 23:03:22 -06:00
|
|
|
ipmr_queue_xmit(net, mrt, skb, cache, psend);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dont_forward:
|
|
|
|
if (!local)
|
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-05-03 20:42:43 -06:00
|
|
|
static struct mr_table *ipmr_rt_fib_lookup(struct net *net, struct sk_buff *skb)
|
2011-03-09 15:06:20 -07:00
|
|
|
{
|
2011-05-03 20:42:43 -06:00
|
|
|
struct rtable *rt = skb_rtable(skb);
|
|
|
|
struct iphdr *iph = ip_hdr(skb);
|
2011-03-12 00:04:50 -07:00
|
|
|
struct flowi4 fl4 = {
|
2011-05-03 20:42:43 -06:00
|
|
|
.daddr = iph->daddr,
|
|
|
|
.saddr = iph->saddr,
|
2011-07-22 20:00:41 -06:00
|
|
|
.flowi4_tos = RT_TOS(iph->tos),
|
2011-03-12 00:04:50 -07:00
|
|
|
.flowi4_oif = rt->rt_oif,
|
|
|
|
.flowi4_iif = rt->rt_iif,
|
|
|
|
.flowi4_mark = rt->rt_mark,
|
2011-03-09 15:06:20 -07:00
|
|
|
};
|
|
|
|
struct mr_table *mrt;
|
|
|
|
int err;
|
|
|
|
|
2011-03-12 00:04:50 -07:00
|
|
|
err = ipmr_fib_lookup(net, &fl4, &mrt);
|
2011-03-09 15:06:20 -07:00
|
|
|
if (err)
|
|
|
|
return ERR_PTR(err);
|
|
|
|
return mrt;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Multicast packets for forwarding arrive here
|
2010-10-01 10:15:01 -06:00
|
|
|
* Called with rcu_read_lock();
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
int ip_mr_input(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct mfc_cache *cache;
|
2009-01-21 21:56:23 -07:00
|
|
|
struct net *net = dev_net(skb->dev);
|
2009-06-01 23:14:27 -06:00
|
|
|
int local = skb_rtable(skb)->rt_flags & RTCF_LOCAL;
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Packet is looped back after forward, it should not be
|
2010-10-01 10:15:29 -06:00
|
|
|
* forwarded second time, but still can be delivered locally.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2010-10-01 10:15:01 -06:00
|
|
|
if (IPCB(skb)->flags & IPSKB_FORWARDED)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto dont_forward;
|
|
|
|
|
2011-05-03 20:42:43 -06:00
|
|
|
mrt = ipmr_rt_fib_lookup(net, skb);
|
2011-03-09 15:06:20 -07:00
|
|
|
if (IS_ERR(mrt)) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return PTR_ERR(mrt);
|
2010-07-15 07:22:33 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!local) {
|
2010-10-01 10:15:01 -06:00
|
|
|
if (IPCB(skb)->opt.router_alert) {
|
|
|
|
if (ip_call_ra_chain(skb))
|
|
|
|
return 0;
|
|
|
|
} else if (ip_hdr(skb)->protocol == IPPROTO_IGMP) {
|
|
|
|
/* IGMPv1 (and broken IGMPv2 implementations sort of
|
|
|
|
* Cisco IOS <= 11.2(8)) do not put router alert
|
|
|
|
* option to IGMP packets destined to routable
|
|
|
|
* groups. It is very bad, because it means
|
|
|
|
* that we can forward NO IGMP messages.
|
|
|
|
*/
|
|
|
|
struct sock *mroute_sk;
|
|
|
|
|
|
|
|
mroute_sk = rcu_dereference(mrt->mroute_sk);
|
|
|
|
if (mroute_sk) {
|
|
|
|
nf_reset(skb);
|
|
|
|
raw_rcv(mroute_sk, skb);
|
|
|
|
return 0;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-01 10:15:08 -06:00
|
|
|
/* already under rcu_read_lock() */
|
2010-04-12 23:03:22 -06:00
|
|
|
cache = ipmr_cache_find(mrt, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* No usable cache entry
|
|
|
|
*/
|
2008-11-03 01:28:02 -07:00
|
|
|
if (cache == NULL) {
|
2005-04-16 16:20:36 -06:00
|
|
|
int vif;
|
|
|
|
|
|
|
|
if (local) {
|
|
|
|
struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
|
|
|
|
ip_local_deliver(skb);
|
2010-10-01 10:15:08 -06:00
|
|
|
if (skb2 == NULL)
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENOBUFS;
|
|
|
|
skb = skb2;
|
|
|
|
}
|
|
|
|
|
2010-10-01 10:15:08 -06:00
|
|
|
read_lock(&mrt_lock);
|
2010-04-12 23:03:22 -06:00
|
|
|
vif = ipmr_find_vif(mrt, skb->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (vif >= 0) {
|
2010-04-20 20:06:52 -06:00
|
|
|
int err2 = ipmr_cache_unresolved(mrt, vif, skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
|
2010-04-20 20:06:52 -06:00
|
|
|
return err2;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
kfree_skb(skb);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2010-10-01 10:15:08 -06:00
|
|
|
read_lock(&mrt_lock);
|
2010-04-12 23:03:22 -06:00
|
|
|
ip_mr_forward(net, mrt, skb, cache, local);
|
2005-04-16 16:20:36 -06:00
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
|
|
|
|
if (local)
|
|
|
|
return ip_local_deliver(skb);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
dont_forward:
|
|
|
|
if (local)
|
|
|
|
return ip_local_deliver(skb);
|
|
|
|
kfree_skb(skb);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
ipmr: merge common code
Also removes redundant skb->len < x check which can't
be true once pskb_may_pull(skb, x) succeeded.
$ diff-funcs pim_rcv ipmr.c ipmr.c pim_rcv_v1
--- ipmr.c:pim_rcv()
+++ ipmr.c:pim_rcv_v1()
@@ -1,22 +1,27 @@
-static int pim_rcv(struct sk_buff * skb)
+int pim_rcv_v1(struct sk_buff * skb)
{
- struct pimreghdr *pim;
+ struct igmphdr *pim;
struct iphdr *encap;
struct net_device *reg_dev = NULL;
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
goto drop;
- pim = (struct pimreghdr *)skb_transport_header(skb);
- if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
- (pim->flags&PIM_NULL_REGISTER) ||
- (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
- csum_fold(skb_checksum(skb, 0, skb->len, 0))))
+ pim = igmp_hdr(skb);
+
+ if (!mroute_do_pim ||
+ skb->len < sizeof(*pim) + sizeof(*encap) ||
+ pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
goto drop;
- /* check if the inner packet is destined to mcast group */
encap = (struct iphdr *)(skb_transport_header(skb) +
- sizeof(struct pimreghdr));
+ sizeof(struct igmphdr));
+ /*
+ Check that:
+ a. packet is really destinted to a multicast group
+ b. packet is not a NULL-REGISTER
+ c. packet is not truncated
+ */
if (!ipv4_is_multicast(encap->daddr) ||
encap->tot_len == 0 ||
ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
@@ -40,9 +45,9 @@
skb->ip_summed = 0;
skb->pkt_type = PACKET_HOST;
dst_release(skb->dst);
+ skb->dst = NULL;
reg_dev->stats.rx_bytes += skb->len;
reg_dev->stats.rx_packets++;
- skb->dst = NULL;
nf_reset(skb);
netif_rx(skb);
dev_put(reg_dev);
$ codiff net/ipv4/ipmr.o.old net/ipv4/ipmr.o.new
net/ipv4/ipmr.c:
pim_rcv_v1 | -283
pim_rcv | -284
2 functions changed, 567 bytes removed
net/ipv4/ipmr.c:
__pim_rcv | +307
1 function changed, 307 bytes added
net/ipv4/ipmr.o.new:
3 functions changed, 307 bytes added, 567 bytes removed, diff: -260
(Tested on x86_64).
It seems that pimlen arg could be left out as well and
eq-sizedness of structs trapped with BUILD_BUG_ON but
I don't think that's more than a cosmetic flaw since there
aren't that many args anyway.
Compile tested.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-12-16 02:15:11 -07:00
|
|
|
#ifdef CONFIG_IP_PIMSM
|
2010-10-01 10:14:55 -06:00
|
|
|
/* called with rcu_read_lock() */
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
static int __pim_rcv(struct mr_table *mrt, struct sk_buff *skb,
|
|
|
|
unsigned int pimlen)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
ipmr: merge common code
Also removes redundant skb->len < x check which can't
be true once pskb_may_pull(skb, x) succeeded.
$ diff-funcs pim_rcv ipmr.c ipmr.c pim_rcv_v1
--- ipmr.c:pim_rcv()
+++ ipmr.c:pim_rcv_v1()
@@ -1,22 +1,27 @@
-static int pim_rcv(struct sk_buff * skb)
+int pim_rcv_v1(struct sk_buff * skb)
{
- struct pimreghdr *pim;
+ struct igmphdr *pim;
struct iphdr *encap;
struct net_device *reg_dev = NULL;
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
goto drop;
- pim = (struct pimreghdr *)skb_transport_header(skb);
- if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
- (pim->flags&PIM_NULL_REGISTER) ||
- (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
- csum_fold(skb_checksum(skb, 0, skb->len, 0))))
+ pim = igmp_hdr(skb);
+
+ if (!mroute_do_pim ||
+ skb->len < sizeof(*pim) + sizeof(*encap) ||
+ pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
goto drop;
- /* check if the inner packet is destined to mcast group */
encap = (struct iphdr *)(skb_transport_header(skb) +
- sizeof(struct pimreghdr));
+ sizeof(struct igmphdr));
+ /*
+ Check that:
+ a. packet is really destinted to a multicast group
+ b. packet is not a NULL-REGISTER
+ c. packet is not truncated
+ */
if (!ipv4_is_multicast(encap->daddr) ||
encap->tot_len == 0 ||
ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
@@ -40,9 +45,9 @@
skb->ip_summed = 0;
skb->pkt_type = PACKET_HOST;
dst_release(skb->dst);
+ skb->dst = NULL;
reg_dev->stats.rx_bytes += skb->len;
reg_dev->stats.rx_packets++;
- skb->dst = NULL;
nf_reset(skb);
netif_rx(skb);
dev_put(reg_dev);
$ codiff net/ipv4/ipmr.o.old net/ipv4/ipmr.o.new
net/ipv4/ipmr.c:
pim_rcv_v1 | -283
pim_rcv | -284
2 functions changed, 567 bytes removed
net/ipv4/ipmr.c:
__pim_rcv | +307
1 function changed, 307 bytes added
net/ipv4/ipmr.o.new:
3 functions changed, 307 bytes added, 567 bytes removed, diff: -260
(Tested on x86_64).
It seems that pimlen arg could be left out as well and
eq-sizedness of structs trapped with BUILD_BUG_ON but
I don't think that's more than a cosmetic flaw since there
aren't that many args anyway.
Compile tested.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-12-16 02:15:11 -07:00
|
|
|
struct net_device *reg_dev = NULL;
|
|
|
|
struct iphdr *encap;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ipmr: merge common code
Also removes redundant skb->len < x check which can't
be true once pskb_may_pull(skb, x) succeeded.
$ diff-funcs pim_rcv ipmr.c ipmr.c pim_rcv_v1
--- ipmr.c:pim_rcv()
+++ ipmr.c:pim_rcv_v1()
@@ -1,22 +1,27 @@
-static int pim_rcv(struct sk_buff * skb)
+int pim_rcv_v1(struct sk_buff * skb)
{
- struct pimreghdr *pim;
+ struct igmphdr *pim;
struct iphdr *encap;
struct net_device *reg_dev = NULL;
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
goto drop;
- pim = (struct pimreghdr *)skb_transport_header(skb);
- if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
- (pim->flags&PIM_NULL_REGISTER) ||
- (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
- csum_fold(skb_checksum(skb, 0, skb->len, 0))))
+ pim = igmp_hdr(skb);
+
+ if (!mroute_do_pim ||
+ skb->len < sizeof(*pim) + sizeof(*encap) ||
+ pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
goto drop;
- /* check if the inner packet is destined to mcast group */
encap = (struct iphdr *)(skb_transport_header(skb) +
- sizeof(struct pimreghdr));
+ sizeof(struct igmphdr));
+ /*
+ Check that:
+ a. packet is really destinted to a multicast group
+ b. packet is not a NULL-REGISTER
+ c. packet is not truncated
+ */
if (!ipv4_is_multicast(encap->daddr) ||
encap->tot_len == 0 ||
ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
@@ -40,9 +45,9 @@
skb->ip_summed = 0;
skb->pkt_type = PACKET_HOST;
dst_release(skb->dst);
+ skb->dst = NULL;
reg_dev->stats.rx_bytes += skb->len;
reg_dev->stats.rx_packets++;
- skb->dst = NULL;
nf_reset(skb);
netif_rx(skb);
dev_put(reg_dev);
$ codiff net/ipv4/ipmr.o.old net/ipv4/ipmr.o.new
net/ipv4/ipmr.c:
pim_rcv_v1 | -283
pim_rcv | -284
2 functions changed, 567 bytes removed
net/ipv4/ipmr.c:
__pim_rcv | +307
1 function changed, 307 bytes added
net/ipv4/ipmr.o.new:
3 functions changed, 307 bytes added, 567 bytes removed, diff: -260
(Tested on x86_64).
It seems that pimlen arg could be left out as well and
eq-sizedness of structs trapped with BUILD_BUG_ON but
I don't think that's more than a cosmetic flaw since there
aren't that many args anyway.
Compile tested.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-12-16 02:15:11 -07:00
|
|
|
encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2010-10-01 10:15:29 -06:00
|
|
|
* Check that:
|
|
|
|
* a. packet is really sent to a multicast group
|
|
|
|
* b. packet is not a NULL-REGISTER
|
|
|
|
* c. packet is not truncated
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
2007-12-16 14:45:43 -07:00
|
|
|
if (!ipv4_is_multicast(encap->daddr) ||
|
2005-04-16 16:20:36 -06:00
|
|
|
encap->tot_len == 0 ||
|
ipmr: merge common code
Also removes redundant skb->len < x check which can't
be true once pskb_may_pull(skb, x) succeeded.
$ diff-funcs pim_rcv ipmr.c ipmr.c pim_rcv_v1
--- ipmr.c:pim_rcv()
+++ ipmr.c:pim_rcv_v1()
@@ -1,22 +1,27 @@
-static int pim_rcv(struct sk_buff * skb)
+int pim_rcv_v1(struct sk_buff * skb)
{
- struct pimreghdr *pim;
+ struct igmphdr *pim;
struct iphdr *encap;
struct net_device *reg_dev = NULL;
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
goto drop;
- pim = (struct pimreghdr *)skb_transport_header(skb);
- if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
- (pim->flags&PIM_NULL_REGISTER) ||
- (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
- csum_fold(skb_checksum(skb, 0, skb->len, 0))))
+ pim = igmp_hdr(skb);
+
+ if (!mroute_do_pim ||
+ skb->len < sizeof(*pim) + sizeof(*encap) ||
+ pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
goto drop;
- /* check if the inner packet is destined to mcast group */
encap = (struct iphdr *)(skb_transport_header(skb) +
- sizeof(struct pimreghdr));
+ sizeof(struct igmphdr));
+ /*
+ Check that:
+ a. packet is really destinted to a multicast group
+ b. packet is not a NULL-REGISTER
+ c. packet is not truncated
+ */
if (!ipv4_is_multicast(encap->daddr) ||
encap->tot_len == 0 ||
ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
@@ -40,9 +45,9 @@
skb->ip_summed = 0;
skb->pkt_type = PACKET_HOST;
dst_release(skb->dst);
+ skb->dst = NULL;
reg_dev->stats.rx_bytes += skb->len;
reg_dev->stats.rx_packets++;
- skb->dst = NULL;
nf_reset(skb);
netif_rx(skb);
dev_put(reg_dev);
$ codiff net/ipv4/ipmr.o.old net/ipv4/ipmr.o.new
net/ipv4/ipmr.c:
pim_rcv_v1 | -283
pim_rcv | -284
2 functions changed, 567 bytes removed
net/ipv4/ipmr.c:
__pim_rcv | +307
1 function changed, 307 bytes added
net/ipv4/ipmr.o.new:
3 functions changed, 307 bytes added, 567 bytes removed, diff: -260
(Tested on x86_64).
It seems that pimlen arg could be left out as well and
eq-sizedness of structs trapped with BUILD_BUG_ON but
I don't think that's more than a cosmetic flaw since there
aren't that many args anyway.
Compile tested.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-12-16 02:15:11 -07:00
|
|
|
ntohs(encap->tot_len) + pimlen > skb->len)
|
|
|
|
return 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
read_lock(&mrt_lock);
|
2010-04-12 23:03:22 -06:00
|
|
|
if (mrt->mroute_reg_vif_num >= 0)
|
|
|
|
reg_dev = mrt->vif_table[mrt->mroute_reg_vif_num].dev;
|
2005-04-16 16:20:36 -06:00
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
|
2007-02-09 07:24:47 -07:00
|
|
|
if (reg_dev == NULL)
|
ipmr: merge common code
Also removes redundant skb->len < x check which can't
be true once pskb_may_pull(skb, x) succeeded.
$ diff-funcs pim_rcv ipmr.c ipmr.c pim_rcv_v1
--- ipmr.c:pim_rcv()
+++ ipmr.c:pim_rcv_v1()
@@ -1,22 +1,27 @@
-static int pim_rcv(struct sk_buff * skb)
+int pim_rcv_v1(struct sk_buff * skb)
{
- struct pimreghdr *pim;
+ struct igmphdr *pim;
struct iphdr *encap;
struct net_device *reg_dev = NULL;
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
goto drop;
- pim = (struct pimreghdr *)skb_transport_header(skb);
- if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
- (pim->flags&PIM_NULL_REGISTER) ||
- (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
- csum_fold(skb_checksum(skb, 0, skb->len, 0))))
+ pim = igmp_hdr(skb);
+
+ if (!mroute_do_pim ||
+ skb->len < sizeof(*pim) + sizeof(*encap) ||
+ pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
goto drop;
- /* check if the inner packet is destined to mcast group */
encap = (struct iphdr *)(skb_transport_header(skb) +
- sizeof(struct pimreghdr));
+ sizeof(struct igmphdr));
+ /*
+ Check that:
+ a. packet is really destinted to a multicast group
+ b. packet is not a NULL-REGISTER
+ c. packet is not truncated
+ */
if (!ipv4_is_multicast(encap->daddr) ||
encap->tot_len == 0 ||
ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
@@ -40,9 +45,9 @@
skb->ip_summed = 0;
skb->pkt_type = PACKET_HOST;
dst_release(skb->dst);
+ skb->dst = NULL;
reg_dev->stats.rx_bytes += skb->len;
reg_dev->stats.rx_packets++;
- skb->dst = NULL;
nf_reset(skb);
netif_rx(skb);
dev_put(reg_dev);
$ codiff net/ipv4/ipmr.o.old net/ipv4/ipmr.o.new
net/ipv4/ipmr.c:
pim_rcv_v1 | -283
pim_rcv | -284
2 functions changed, 567 bytes removed
net/ipv4/ipmr.c:
__pim_rcv | +307
1 function changed, 307 bytes added
net/ipv4/ipmr.o.new:
3 functions changed, 307 bytes added, 567 bytes removed, diff: -260
(Tested on x86_64).
It seems that pimlen arg could be left out as well and
eq-sizedness of structs trapped with BUILD_BUG_ON but
I don't think that's more than a cosmetic flaw since there
aren't that many args anyway.
Compile tested.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-12-16 02:15:11 -07:00
|
|
|
return 1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-04-10 22:21:55 -06:00
|
|
|
skb->mac_header = skb->network_header;
|
2010-10-01 10:14:55 -06:00
|
|
|
skb_pull(skb, (u8 *)encap - skb->data);
|
2007-03-10 15:04:55 -07:00
|
|
|
skb_reset_network_header(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
skb->protocol = htons(ETH_P_IP);
|
2010-10-01 10:14:55 -06:00
|
|
|
skb->ip_summed = CHECKSUM_NONE;
|
2005-04-16 16:20:36 -06:00
|
|
|
skb->pkt_type = PACKET_HOST;
|
2010-05-17 23:36:55 -06:00
|
|
|
|
|
|
|
skb_tunnel_rx(skb, reg_dev);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
netif_rx(skb);
|
ipmr: merge common code
Also removes redundant skb->len < x check which can't
be true once pskb_may_pull(skb, x) succeeded.
$ diff-funcs pim_rcv ipmr.c ipmr.c pim_rcv_v1
--- ipmr.c:pim_rcv()
+++ ipmr.c:pim_rcv_v1()
@@ -1,22 +1,27 @@
-static int pim_rcv(struct sk_buff * skb)
+int pim_rcv_v1(struct sk_buff * skb)
{
- struct pimreghdr *pim;
+ struct igmphdr *pim;
struct iphdr *encap;
struct net_device *reg_dev = NULL;
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
goto drop;
- pim = (struct pimreghdr *)skb_transport_header(skb);
- if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
- (pim->flags&PIM_NULL_REGISTER) ||
- (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
- csum_fold(skb_checksum(skb, 0, skb->len, 0))))
+ pim = igmp_hdr(skb);
+
+ if (!mroute_do_pim ||
+ skb->len < sizeof(*pim) + sizeof(*encap) ||
+ pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
goto drop;
- /* check if the inner packet is destined to mcast group */
encap = (struct iphdr *)(skb_transport_header(skb) +
- sizeof(struct pimreghdr));
+ sizeof(struct igmphdr));
+ /*
+ Check that:
+ a. packet is really destinted to a multicast group
+ b. packet is not a NULL-REGISTER
+ c. packet is not truncated
+ */
if (!ipv4_is_multicast(encap->daddr) ||
encap->tot_len == 0 ||
ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
@@ -40,9 +45,9 @@
skb->ip_summed = 0;
skb->pkt_type = PACKET_HOST;
dst_release(skb->dst);
+ skb->dst = NULL;
reg_dev->stats.rx_bytes += skb->len;
reg_dev->stats.rx_packets++;
- skb->dst = NULL;
nf_reset(skb);
netif_rx(skb);
dev_put(reg_dev);
$ codiff net/ipv4/ipmr.o.old net/ipv4/ipmr.o.new
net/ipv4/ipmr.c:
pim_rcv_v1 | -283
pim_rcv | -284
2 functions changed, 567 bytes removed
net/ipv4/ipmr.c:
__pim_rcv | +307
1 function changed, 307 bytes added
net/ipv4/ipmr.o.new:
3 functions changed, 307 bytes added, 567 bytes removed, diff: -260
(Tested on x86_64).
It seems that pimlen arg could be left out as well and
eq-sizedness of structs trapped with BUILD_BUG_ON but
I don't think that's more than a cosmetic flaw since there
aren't that many args anyway.
Compile tested.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-12-16 02:15:11 -07:00
|
|
|
|
2010-10-01 10:14:55 -06:00
|
|
|
return NET_RX_SUCCESS;
|
ipmr: merge common code
Also removes redundant skb->len < x check which can't
be true once pskb_may_pull(skb, x) succeeded.
$ diff-funcs pim_rcv ipmr.c ipmr.c pim_rcv_v1
--- ipmr.c:pim_rcv()
+++ ipmr.c:pim_rcv_v1()
@@ -1,22 +1,27 @@
-static int pim_rcv(struct sk_buff * skb)
+int pim_rcv_v1(struct sk_buff * skb)
{
- struct pimreghdr *pim;
+ struct igmphdr *pim;
struct iphdr *encap;
struct net_device *reg_dev = NULL;
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
goto drop;
- pim = (struct pimreghdr *)skb_transport_header(skb);
- if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
- (pim->flags&PIM_NULL_REGISTER) ||
- (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
- csum_fold(skb_checksum(skb, 0, skb->len, 0))))
+ pim = igmp_hdr(skb);
+
+ if (!mroute_do_pim ||
+ skb->len < sizeof(*pim) + sizeof(*encap) ||
+ pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
goto drop;
- /* check if the inner packet is destined to mcast group */
encap = (struct iphdr *)(skb_transport_header(skb) +
- sizeof(struct pimreghdr));
+ sizeof(struct igmphdr));
+ /*
+ Check that:
+ a. packet is really destinted to a multicast group
+ b. packet is not a NULL-REGISTER
+ c. packet is not truncated
+ */
if (!ipv4_is_multicast(encap->daddr) ||
encap->tot_len == 0 ||
ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
@@ -40,9 +45,9 @@
skb->ip_summed = 0;
skb->pkt_type = PACKET_HOST;
dst_release(skb->dst);
+ skb->dst = NULL;
reg_dev->stats.rx_bytes += skb->len;
reg_dev->stats.rx_packets++;
- skb->dst = NULL;
nf_reset(skb);
netif_rx(skb);
dev_put(reg_dev);
$ codiff net/ipv4/ipmr.o.old net/ipv4/ipmr.o.new
net/ipv4/ipmr.c:
pim_rcv_v1 | -283
pim_rcv | -284
2 functions changed, 567 bytes removed
net/ipv4/ipmr.c:
__pim_rcv | +307
1 function changed, 307 bytes added
net/ipv4/ipmr.o.new:
3 functions changed, 307 bytes added, 567 bytes removed, diff: -260
(Tested on x86_64).
It seems that pimlen arg could be left out as well and
eq-sizedness of structs trapped with BUILD_BUG_ON but
I don't think that's more than a cosmetic flaw since there
aren't that many args anyway.
Compile tested.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-12-16 02:15:11 -07:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_PIMSM_V1
|
|
|
|
/*
|
|
|
|
* Handle IGMP messages of PIMv1
|
|
|
|
*/
|
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
int pim_rcv_v1(struct sk_buff *skb)
|
ipmr: merge common code
Also removes redundant skb->len < x check which can't
be true once pskb_may_pull(skb, x) succeeded.
$ diff-funcs pim_rcv ipmr.c ipmr.c pim_rcv_v1
--- ipmr.c:pim_rcv()
+++ ipmr.c:pim_rcv_v1()
@@ -1,22 +1,27 @@
-static int pim_rcv(struct sk_buff * skb)
+int pim_rcv_v1(struct sk_buff * skb)
{
- struct pimreghdr *pim;
+ struct igmphdr *pim;
struct iphdr *encap;
struct net_device *reg_dev = NULL;
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
goto drop;
- pim = (struct pimreghdr *)skb_transport_header(skb);
- if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
- (pim->flags&PIM_NULL_REGISTER) ||
- (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
- csum_fold(skb_checksum(skb, 0, skb->len, 0))))
+ pim = igmp_hdr(skb);
+
+ if (!mroute_do_pim ||
+ skb->len < sizeof(*pim) + sizeof(*encap) ||
+ pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
goto drop;
- /* check if the inner packet is destined to mcast group */
encap = (struct iphdr *)(skb_transport_header(skb) +
- sizeof(struct pimreghdr));
+ sizeof(struct igmphdr));
+ /*
+ Check that:
+ a. packet is really destinted to a multicast group
+ b. packet is not a NULL-REGISTER
+ c. packet is not truncated
+ */
if (!ipv4_is_multicast(encap->daddr) ||
encap->tot_len == 0 ||
ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
@@ -40,9 +45,9 @@
skb->ip_summed = 0;
skb->pkt_type = PACKET_HOST;
dst_release(skb->dst);
+ skb->dst = NULL;
reg_dev->stats.rx_bytes += skb->len;
reg_dev->stats.rx_packets++;
- skb->dst = NULL;
nf_reset(skb);
netif_rx(skb);
dev_put(reg_dev);
$ codiff net/ipv4/ipmr.o.old net/ipv4/ipmr.o.new
net/ipv4/ipmr.c:
pim_rcv_v1 | -283
pim_rcv | -284
2 functions changed, 567 bytes removed
net/ipv4/ipmr.c:
__pim_rcv | +307
1 function changed, 307 bytes added
net/ipv4/ipmr.o.new:
3 functions changed, 307 bytes added, 567 bytes removed, diff: -260
(Tested on x86_64).
It seems that pimlen arg could be left out as well and
eq-sizedness of structs trapped with BUILD_BUG_ON but
I don't think that's more than a cosmetic flaw since there
aren't that many args anyway.
Compile tested.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-12-16 02:15:11 -07:00
|
|
|
{
|
|
|
|
struct igmphdr *pim;
|
2009-01-21 21:56:23 -07:00
|
|
|
struct net *net = dev_net(skb->dev);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt;
|
ipmr: merge common code
Also removes redundant skb->len < x check which can't
be true once pskb_may_pull(skb, x) succeeded.
$ diff-funcs pim_rcv ipmr.c ipmr.c pim_rcv_v1
--- ipmr.c:pim_rcv()
+++ ipmr.c:pim_rcv_v1()
@@ -1,22 +1,27 @@
-static int pim_rcv(struct sk_buff * skb)
+int pim_rcv_v1(struct sk_buff * skb)
{
- struct pimreghdr *pim;
+ struct igmphdr *pim;
struct iphdr *encap;
struct net_device *reg_dev = NULL;
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
goto drop;
- pim = (struct pimreghdr *)skb_transport_header(skb);
- if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
- (pim->flags&PIM_NULL_REGISTER) ||
- (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
- csum_fold(skb_checksum(skb, 0, skb->len, 0))))
+ pim = igmp_hdr(skb);
+
+ if (!mroute_do_pim ||
+ skb->len < sizeof(*pim) + sizeof(*encap) ||
+ pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
goto drop;
- /* check if the inner packet is destined to mcast group */
encap = (struct iphdr *)(skb_transport_header(skb) +
- sizeof(struct pimreghdr));
+ sizeof(struct igmphdr));
+ /*
+ Check that:
+ a. packet is really destinted to a multicast group
+ b. packet is not a NULL-REGISTER
+ c. packet is not truncated
+ */
if (!ipv4_is_multicast(encap->daddr) ||
encap->tot_len == 0 ||
ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
@@ -40,9 +45,9 @@
skb->ip_summed = 0;
skb->pkt_type = PACKET_HOST;
dst_release(skb->dst);
+ skb->dst = NULL;
reg_dev->stats.rx_bytes += skb->len;
reg_dev->stats.rx_packets++;
- skb->dst = NULL;
nf_reset(skb);
netif_rx(skb);
dev_put(reg_dev);
$ codiff net/ipv4/ipmr.o.old net/ipv4/ipmr.o.new
net/ipv4/ipmr.c:
pim_rcv_v1 | -283
pim_rcv | -284
2 functions changed, 567 bytes removed
net/ipv4/ipmr.c:
__pim_rcv | +307
1 function changed, 307 bytes added
net/ipv4/ipmr.o.new:
3 functions changed, 307 bytes added, 567 bytes removed, diff: -260
(Tested on x86_64).
It seems that pimlen arg could be left out as well and
eq-sizedness of structs trapped with BUILD_BUG_ON but
I don't think that's more than a cosmetic flaw since there
aren't that many args anyway.
Compile tested.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-12-16 02:15:11 -07:00
|
|
|
|
|
|
|
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
|
|
|
|
goto drop;
|
|
|
|
|
|
|
|
pim = igmp_hdr(skb);
|
|
|
|
|
2011-05-03 20:42:43 -06:00
|
|
|
mrt = ipmr_rt_fib_lookup(net, skb);
|
2011-03-09 15:06:20 -07:00
|
|
|
if (IS_ERR(mrt))
|
|
|
|
goto drop;
|
2010-04-12 23:03:22 -06:00
|
|
|
if (!mrt->mroute_do_pim ||
|
ipmr: merge common code
Also removes redundant skb->len < x check which can't
be true once pskb_may_pull(skb, x) succeeded.
$ diff-funcs pim_rcv ipmr.c ipmr.c pim_rcv_v1
--- ipmr.c:pim_rcv()
+++ ipmr.c:pim_rcv_v1()
@@ -1,22 +1,27 @@
-static int pim_rcv(struct sk_buff * skb)
+int pim_rcv_v1(struct sk_buff * skb)
{
- struct pimreghdr *pim;
+ struct igmphdr *pim;
struct iphdr *encap;
struct net_device *reg_dev = NULL;
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
goto drop;
- pim = (struct pimreghdr *)skb_transport_header(skb);
- if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
- (pim->flags&PIM_NULL_REGISTER) ||
- (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
- csum_fold(skb_checksum(skb, 0, skb->len, 0))))
+ pim = igmp_hdr(skb);
+
+ if (!mroute_do_pim ||
+ skb->len < sizeof(*pim) + sizeof(*encap) ||
+ pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
goto drop;
- /* check if the inner packet is destined to mcast group */
encap = (struct iphdr *)(skb_transport_header(skb) +
- sizeof(struct pimreghdr));
+ sizeof(struct igmphdr));
+ /*
+ Check that:
+ a. packet is really destinted to a multicast group
+ b. packet is not a NULL-REGISTER
+ c. packet is not truncated
+ */
if (!ipv4_is_multicast(encap->daddr) ||
encap->tot_len == 0 ||
ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
@@ -40,9 +45,9 @@
skb->ip_summed = 0;
skb->pkt_type = PACKET_HOST;
dst_release(skb->dst);
+ skb->dst = NULL;
reg_dev->stats.rx_bytes += skb->len;
reg_dev->stats.rx_packets++;
- skb->dst = NULL;
nf_reset(skb);
netif_rx(skb);
dev_put(reg_dev);
$ codiff net/ipv4/ipmr.o.old net/ipv4/ipmr.o.new
net/ipv4/ipmr.c:
pim_rcv_v1 | -283
pim_rcv | -284
2 functions changed, 567 bytes removed
net/ipv4/ipmr.c:
__pim_rcv | +307
1 function changed, 307 bytes added
net/ipv4/ipmr.o.new:
3 functions changed, 307 bytes added, 567 bytes removed, diff: -260
(Tested on x86_64).
It seems that pimlen arg could be left out as well and
eq-sizedness of structs trapped with BUILD_BUG_ON but
I don't think that's more than a cosmetic flaw since there
aren't that many args anyway.
Compile tested.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-12-16 02:15:11 -07:00
|
|
|
pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
|
|
|
|
goto drop;
|
|
|
|
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
if (__pim_rcv(mrt, skb, sizeof(*pim))) {
|
ipmr: merge common code
Also removes redundant skb->len < x check which can't
be true once pskb_may_pull(skb, x) succeeded.
$ diff-funcs pim_rcv ipmr.c ipmr.c pim_rcv_v1
--- ipmr.c:pim_rcv()
+++ ipmr.c:pim_rcv_v1()
@@ -1,22 +1,27 @@
-static int pim_rcv(struct sk_buff * skb)
+int pim_rcv_v1(struct sk_buff * skb)
{
- struct pimreghdr *pim;
+ struct igmphdr *pim;
struct iphdr *encap;
struct net_device *reg_dev = NULL;
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
goto drop;
- pim = (struct pimreghdr *)skb_transport_header(skb);
- if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
- (pim->flags&PIM_NULL_REGISTER) ||
- (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
- csum_fold(skb_checksum(skb, 0, skb->len, 0))))
+ pim = igmp_hdr(skb);
+
+ if (!mroute_do_pim ||
+ skb->len < sizeof(*pim) + sizeof(*encap) ||
+ pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
goto drop;
- /* check if the inner packet is destined to mcast group */
encap = (struct iphdr *)(skb_transport_header(skb) +
- sizeof(struct pimreghdr));
+ sizeof(struct igmphdr));
+ /*
+ Check that:
+ a. packet is really destinted to a multicast group
+ b. packet is not a NULL-REGISTER
+ c. packet is not truncated
+ */
if (!ipv4_is_multicast(encap->daddr) ||
encap->tot_len == 0 ||
ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
@@ -40,9 +45,9 @@
skb->ip_summed = 0;
skb->pkt_type = PACKET_HOST;
dst_release(skb->dst);
+ skb->dst = NULL;
reg_dev->stats.rx_bytes += skb->len;
reg_dev->stats.rx_packets++;
- skb->dst = NULL;
nf_reset(skb);
netif_rx(skb);
dev_put(reg_dev);
$ codiff net/ipv4/ipmr.o.old net/ipv4/ipmr.o.new
net/ipv4/ipmr.c:
pim_rcv_v1 | -283
pim_rcv | -284
2 functions changed, 567 bytes removed
net/ipv4/ipmr.c:
__pim_rcv | +307
1 function changed, 307 bytes added
net/ipv4/ipmr.o.new:
3 functions changed, 307 bytes added, 567 bytes removed, diff: -260
(Tested on x86_64).
It seems that pimlen arg could be left out as well and
eq-sizedness of structs trapped with BUILD_BUG_ON but
I don't think that's more than a cosmetic flaw since there
aren't that many args anyway.
Compile tested.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-12-16 02:15:11 -07:00
|
|
|
drop:
|
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_PIMSM_V2
|
2010-10-01 10:15:29 -06:00
|
|
|
static int pim_rcv(struct sk_buff *skb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct pimreghdr *pim;
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct net *net = dev_net(skb->dev);
|
|
|
|
struct mr_table *mrt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ipmr: merge common code
Also removes redundant skb->len < x check which can't
be true once pskb_may_pull(skb, x) succeeded.
$ diff-funcs pim_rcv ipmr.c ipmr.c pim_rcv_v1
--- ipmr.c:pim_rcv()
+++ ipmr.c:pim_rcv_v1()
@@ -1,22 +1,27 @@
-static int pim_rcv(struct sk_buff * skb)
+int pim_rcv_v1(struct sk_buff * skb)
{
- struct pimreghdr *pim;
+ struct igmphdr *pim;
struct iphdr *encap;
struct net_device *reg_dev = NULL;
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
goto drop;
- pim = (struct pimreghdr *)skb_transport_header(skb);
- if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
- (pim->flags&PIM_NULL_REGISTER) ||
- (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
- csum_fold(skb_checksum(skb, 0, skb->len, 0))))
+ pim = igmp_hdr(skb);
+
+ if (!mroute_do_pim ||
+ skb->len < sizeof(*pim) + sizeof(*encap) ||
+ pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
goto drop;
- /* check if the inner packet is destined to mcast group */
encap = (struct iphdr *)(skb_transport_header(skb) +
- sizeof(struct pimreghdr));
+ sizeof(struct igmphdr));
+ /*
+ Check that:
+ a. packet is really destinted to a multicast group
+ b. packet is not a NULL-REGISTER
+ c. packet is not truncated
+ */
if (!ipv4_is_multicast(encap->daddr) ||
encap->tot_len == 0 ||
ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
@@ -40,9 +45,9 @@
skb->ip_summed = 0;
skb->pkt_type = PACKET_HOST;
dst_release(skb->dst);
+ skb->dst = NULL;
reg_dev->stats.rx_bytes += skb->len;
reg_dev->stats.rx_packets++;
- skb->dst = NULL;
nf_reset(skb);
netif_rx(skb);
dev_put(reg_dev);
$ codiff net/ipv4/ipmr.o.old net/ipv4/ipmr.o.new
net/ipv4/ipmr.c:
pim_rcv_v1 | -283
pim_rcv | -284
2 functions changed, 567 bytes removed
net/ipv4/ipmr.c:
__pim_rcv | +307
1 function changed, 307 bytes added
net/ipv4/ipmr.o.new:
3 functions changed, 307 bytes added, 567 bytes removed, diff: -260
(Tested on x86_64).
It seems that pimlen arg could be left out as well and
eq-sizedness of structs trapped with BUILD_BUG_ON but
I don't think that's more than a cosmetic flaw since there
aren't that many args anyway.
Compile tested.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-12-16 02:15:11 -07:00
|
|
|
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto drop;
|
|
|
|
|
2007-04-25 19:04:18 -06:00
|
|
|
pim = (struct pimreghdr *)skb_transport_header(skb);
|
2010-10-01 10:15:29 -06:00
|
|
|
if (pim->type != ((PIM_VERSION << 4) | (PIM_REGISTER)) ||
|
|
|
|
(pim->flags & PIM_NULL_REGISTER) ||
|
2007-02-09 07:24:47 -07:00
|
|
|
(ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
|
2006-11-14 22:24:49 -07:00
|
|
|
csum_fold(skb_checksum(skb, 0, skb->len, 0))))
|
2005-04-16 16:20:36 -06:00
|
|
|
goto drop;
|
|
|
|
|
2011-05-03 20:42:43 -06:00
|
|
|
mrt = ipmr_rt_fib_lookup(net, skb);
|
2011-03-09 15:06:20 -07:00
|
|
|
if (IS_ERR(mrt))
|
|
|
|
goto drop;
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
if (__pim_rcv(mrt, skb, sizeof(*pim))) {
|
ipmr: merge common code
Also removes redundant skb->len < x check which can't
be true once pskb_may_pull(skb, x) succeeded.
$ diff-funcs pim_rcv ipmr.c ipmr.c pim_rcv_v1
--- ipmr.c:pim_rcv()
+++ ipmr.c:pim_rcv_v1()
@@ -1,22 +1,27 @@
-static int pim_rcv(struct sk_buff * skb)
+int pim_rcv_v1(struct sk_buff * skb)
{
- struct pimreghdr *pim;
+ struct igmphdr *pim;
struct iphdr *encap;
struct net_device *reg_dev = NULL;
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(*encap)))
goto drop;
- pim = (struct pimreghdr *)skb_transport_header(skb);
- if (pim->type != ((PIM_VERSION<<4)|(PIM_REGISTER)) ||
- (pim->flags&PIM_NULL_REGISTER) ||
- (ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
- csum_fold(skb_checksum(skb, 0, skb->len, 0))))
+ pim = igmp_hdr(skb);
+
+ if (!mroute_do_pim ||
+ skb->len < sizeof(*pim) + sizeof(*encap) ||
+ pim->group != PIM_V1_VERSION || pim->code != PIM_V1_REGISTER)
goto drop;
- /* check if the inner packet is destined to mcast group */
encap = (struct iphdr *)(skb_transport_header(skb) +
- sizeof(struct pimreghdr));
+ sizeof(struct igmphdr));
+ /*
+ Check that:
+ a. packet is really destinted to a multicast group
+ b. packet is not a NULL-REGISTER
+ c. packet is not truncated
+ */
if (!ipv4_is_multicast(encap->daddr) ||
encap->tot_len == 0 ||
ntohs(encap->tot_len) + sizeof(*pim) > skb->len)
@@ -40,9 +45,9 @@
skb->ip_summed = 0;
skb->pkt_type = PACKET_HOST;
dst_release(skb->dst);
+ skb->dst = NULL;
reg_dev->stats.rx_bytes += skb->len;
reg_dev->stats.rx_packets++;
- skb->dst = NULL;
nf_reset(skb);
netif_rx(skb);
dev_put(reg_dev);
$ codiff net/ipv4/ipmr.o.old net/ipv4/ipmr.o.new
net/ipv4/ipmr.c:
pim_rcv_v1 | -283
pim_rcv | -284
2 functions changed, 567 bytes removed
net/ipv4/ipmr.c:
__pim_rcv | +307
1 function changed, 307 bytes added
net/ipv4/ipmr.o.new:
3 functions changed, 307 bytes added, 567 bytes removed, diff: -260
(Tested on x86_64).
It seems that pimlen arg could be left out as well and
eq-sizedness of structs trapped with BUILD_BUG_ON but
I don't think that's more than a cosmetic flaw since there
aren't that many args anyway.
Compile tested.
Signed-off-by: Ilpo Järvinen <ilpo.jarvinen@helsinki.fi>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-12-16 02:15:11 -07:00
|
|
|
drop:
|
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-04-26 08:02:08 -06:00
|
|
|
static int __ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
|
|
|
|
struct mfc_cache *c, struct rtmsg *rtm)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int ct;
|
|
|
|
struct rtnexthop *nhp;
|
2007-04-19 21:29:13 -06:00
|
|
|
u8 *b = skb_tail_pointer(skb);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct rtattr *mp_head;
|
|
|
|
|
2010-03-25 17:45:35 -06:00
|
|
|
/* If cache is unresolved, don't try to parse IIF and OIF */
|
2010-05-26 01:38:56 -06:00
|
|
|
if (c->mfc_parent >= MAXVIFS)
|
2010-03-25 17:45:35 -06:00
|
|
|
return -ENOENT;
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
if (VIF_EXISTS(mrt, c->mfc_parent))
|
|
|
|
RTA_PUT(skb, RTA_IIF, 4, &mrt->vif_table[c->mfc_parent].dev->ifindex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-11-03 01:28:02 -07:00
|
|
|
mp_head = (struct rtattr *)skb_put(skb, RTA_LENGTH(0));
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
for (ct = c->mfc_un.res.minvif; ct < c->mfc_un.res.maxvif; ct++) {
|
2010-04-12 23:03:22 -06:00
|
|
|
if (VIF_EXISTS(mrt, ct) && c->mfc_un.res.ttls[ct] < 255) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (skb_tailroom(skb) < RTA_ALIGN(RTA_ALIGN(sizeof(*nhp)) + 4))
|
|
|
|
goto rtattr_failure;
|
2008-11-03 01:28:02 -07:00
|
|
|
nhp = (struct rtnexthop *)skb_put(skb, RTA_ALIGN(sizeof(*nhp)));
|
2005-04-16 16:20:36 -06:00
|
|
|
nhp->rtnh_flags = 0;
|
|
|
|
nhp->rtnh_hops = c->mfc_un.res.ttls[ct];
|
2010-04-12 23:03:22 -06:00
|
|
|
nhp->rtnh_ifindex = mrt->vif_table[ct].dev->ifindex;
|
2005-04-16 16:20:36 -06:00
|
|
|
nhp->rtnh_len = sizeof(*nhp);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mp_head->rta_type = RTA_MULTIPATH;
|
2007-04-19 21:29:13 -06:00
|
|
|
mp_head->rta_len = skb_tail_pointer(skb) - (u8 *)mp_head;
|
2005-04-16 16:20:36 -06:00
|
|
|
rtm->rtm_type = RTN_MULTICAST;
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
rtattr_failure:
|
2007-03-26 00:06:12 -06:00
|
|
|
nlmsg_trim(skb, b);
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
|
|
|
|
2011-05-04 13:18:54 -06:00
|
|
|
int ipmr_get_route(struct net *net, struct sk_buff *skb,
|
|
|
|
__be32 saddr, __be32 daddr,
|
|
|
|
struct rtmsg *rtm, int nowait)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct mfc_cache *cache;
|
2011-05-04 13:18:54 -06:00
|
|
|
struct mr_table *mrt;
|
|
|
|
int err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return -ENOENT;
|
|
|
|
|
2010-10-01 10:15:08 -06:00
|
|
|
rcu_read_lock();
|
2011-05-04 13:18:54 -06:00
|
|
|
cache = ipmr_cache_find(mrt, saddr, daddr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-11-03 01:28:02 -07:00
|
|
|
if (cache == NULL) {
|
2006-07-25 17:45:12 -06:00
|
|
|
struct sk_buff *skb2;
|
2007-04-20 23:47:35 -06:00
|
|
|
struct iphdr *iph;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct net_device *dev;
|
2010-10-01 10:15:29 -06:00
|
|
|
int vif = -1;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (nowait) {
|
2010-10-01 10:15:08 -06:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
return -EAGAIN;
|
|
|
|
}
|
|
|
|
|
|
|
|
dev = skb->dev;
|
2010-10-01 10:15:08 -06:00
|
|
|
read_lock(&mrt_lock);
|
2010-10-01 10:15:29 -06:00
|
|
|
if (dev)
|
|
|
|
vif = ipmr_find_vif(mrt, dev);
|
|
|
|
if (vif < 0) {
|
2005-04-16 16:20:36 -06:00
|
|
|
read_unlock(&mrt_lock);
|
2010-10-01 10:15:08 -06:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
2006-07-25 17:45:12 -06:00
|
|
|
skb2 = skb_clone(skb, GFP_ATOMIC);
|
|
|
|
if (!skb2) {
|
|
|
|
read_unlock(&mrt_lock);
|
2010-10-01 10:15:08 -06:00
|
|
|
rcu_read_unlock();
|
2006-07-25 17:45:12 -06:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2007-04-10 21:46:21 -06:00
|
|
|
skb_push(skb2, sizeof(struct iphdr));
|
|
|
|
skb_reset_network_header(skb2);
|
2007-04-20 23:47:35 -06:00
|
|
|
iph = ip_hdr(skb2);
|
|
|
|
iph->ihl = sizeof(struct iphdr) >> 2;
|
2011-05-04 13:18:54 -06:00
|
|
|
iph->saddr = saddr;
|
|
|
|
iph->daddr = daddr;
|
2007-04-20 23:47:35 -06:00
|
|
|
iph->version = 0;
|
2010-04-12 23:03:22 -06:00
|
|
|
err = ipmr_cache_unresolved(mrt, vif, skb2);
|
2005-04-16 16:20:36 -06:00
|
|
|
read_unlock(&mrt_lock);
|
2010-10-01 10:15:08 -06:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-10-01 10:15:08 -06:00
|
|
|
read_lock(&mrt_lock);
|
|
|
|
if (!nowait && (rtm->rtm_flags & RTM_F_NOTIFY))
|
2005-04-16 16:20:36 -06:00
|
|
|
cache->mfc_flags |= MFC_NOTIFY;
|
2010-04-26 08:02:08 -06:00
|
|
|
err = __ipmr_fill_mroute(mrt, skb, cache, rtm);
|
2005-04-16 16:20:36 -06:00
|
|
|
read_unlock(&mrt_lock);
|
2010-10-01 10:15:08 -06:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-04-26 08:02:08 -06:00
|
|
|
static int ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
|
|
|
|
u32 pid, u32 seq, struct mfc_cache *c)
|
|
|
|
{
|
|
|
|
struct nlmsghdr *nlh;
|
|
|
|
struct rtmsg *rtm;
|
|
|
|
|
|
|
|
nlh = nlmsg_put(skb, pid, seq, RTM_NEWROUTE, sizeof(*rtm), NLM_F_MULTI);
|
|
|
|
if (nlh == NULL)
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
rtm = nlmsg_data(nlh);
|
|
|
|
rtm->rtm_family = RTNL_FAMILY_IPMR;
|
|
|
|
rtm->rtm_dst_len = 32;
|
|
|
|
rtm->rtm_src_len = 32;
|
|
|
|
rtm->rtm_tos = 0;
|
|
|
|
rtm->rtm_table = mrt->id;
|
2012-04-01 18:39:02 -06:00
|
|
|
if (nla_put_u32(skb, RTA_TABLE, mrt->id))
|
|
|
|
goto nla_put_failure;
|
2010-04-26 08:02:08 -06:00
|
|
|
rtm->rtm_type = RTN_MULTICAST;
|
|
|
|
rtm->rtm_scope = RT_SCOPE_UNIVERSE;
|
|
|
|
rtm->rtm_protocol = RTPROT_UNSPEC;
|
|
|
|
rtm->rtm_flags = 0;
|
|
|
|
|
2012-04-01 18:39:02 -06:00
|
|
|
if (nla_put_be32(skb, RTA_SRC, c->mfc_origin) ||
|
|
|
|
nla_put_be32(skb, RTA_DST, c->mfc_mcastgrp))
|
|
|
|
goto nla_put_failure;
|
2010-04-26 08:02:08 -06:00
|
|
|
if (__ipmr_fill_mroute(mrt, skb, c, rtm) < 0)
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
|
|
return nlmsg_end(skb, nlh);
|
|
|
|
|
|
|
|
nla_put_failure:
|
|
|
|
nlmsg_cancel(skb, nlh);
|
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ipmr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
{
|
|
|
|
struct net *net = sock_net(skb->sk);
|
|
|
|
struct mr_table *mrt;
|
|
|
|
struct mfc_cache *mfc;
|
|
|
|
unsigned int t = 0, s_t;
|
|
|
|
unsigned int h = 0, s_h;
|
|
|
|
unsigned int e = 0, s_e;
|
|
|
|
|
|
|
|
s_t = cb->args[0];
|
|
|
|
s_h = cb->args[1];
|
|
|
|
s_e = cb->args[2];
|
|
|
|
|
2010-10-01 10:15:08 -06:00
|
|
|
rcu_read_lock();
|
2010-04-26 08:02:08 -06:00
|
|
|
ipmr_for_each_table(mrt, net) {
|
|
|
|
if (t < s_t)
|
|
|
|
goto next_table;
|
|
|
|
if (t > s_t)
|
|
|
|
s_h = 0;
|
|
|
|
for (h = s_h; h < MFC_LINES; h++) {
|
2010-10-01 10:15:08 -06:00
|
|
|
list_for_each_entry_rcu(mfc, &mrt->mfc_cache_array[h], list) {
|
2010-04-26 08:02:08 -06:00
|
|
|
if (e < s_e)
|
|
|
|
goto next_entry;
|
|
|
|
if (ipmr_fill_mroute(mrt, skb,
|
|
|
|
NETLINK_CB(cb->skb).pid,
|
|
|
|
cb->nlh->nlmsg_seq,
|
|
|
|
mfc) < 0)
|
|
|
|
goto done;
|
|
|
|
next_entry:
|
|
|
|
e++;
|
|
|
|
}
|
|
|
|
e = s_e = 0;
|
|
|
|
}
|
|
|
|
s_h = 0;
|
|
|
|
next_table:
|
|
|
|
t++;
|
|
|
|
}
|
|
|
|
done:
|
2010-10-01 10:15:08 -06:00
|
|
|
rcu_read_unlock();
|
2010-04-26 08:02:08 -06:00
|
|
|
|
|
|
|
cb->args[2] = e;
|
|
|
|
cb->args[1] = h;
|
|
|
|
cb->args[0] = t;
|
|
|
|
|
|
|
|
return skb->len;
|
|
|
|
}
|
|
|
|
|
2007-02-09 07:24:47 -07:00
|
|
|
#ifdef CONFIG_PROC_FS
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
2010-10-01 10:15:29 -06:00
|
|
|
* The /proc interfaces to multicast routing :
|
|
|
|
* /proc/net/ip_mr_cache & /proc/net/ip_mr_vif
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
struct ipmr_vif_iter {
|
2009-01-21 21:56:22 -07:00
|
|
|
struct seq_net_private p;
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt;
|
2005-04-16 16:20:36 -06:00
|
|
|
int ct;
|
|
|
|
};
|
|
|
|
|
2009-01-21 21:56:22 -07:00
|
|
|
static struct vif_device *ipmr_vif_seq_idx(struct net *net,
|
|
|
|
struct ipmr_vif_iter *iter,
|
2005-04-16 16:20:36 -06:00
|
|
|
loff_t pos)
|
|
|
|
{
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt = iter->mrt;
|
2010-04-12 23:03:22 -06:00
|
|
|
|
|
|
|
for (iter->ct = 0; iter->ct < mrt->maxvif; ++iter->ct) {
|
|
|
|
if (!VIF_EXISTS(mrt, iter->ct))
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
2007-02-09 07:24:47 -07:00
|
|
|
if (pos-- == 0)
|
2010-04-12 23:03:22 -06:00
|
|
|
return &mrt->vif_table[iter->ct];
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
|
2008-01-21 18:28:59 -07:00
|
|
|
__acquires(mrt_lock)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct ipmr_vif_iter *iter = seq->private;
|
2009-01-21 21:56:22 -07:00
|
|
|
struct net *net = seq_file_net(seq);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt;
|
|
|
|
|
|
|
|
mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
|
|
|
|
iter->mrt = mrt;
|
2009-01-21 21:56:22 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
read_lock(&mrt_lock);
|
2009-01-21 21:56:22 -07:00
|
|
|
return *pos ? ipmr_vif_seq_idx(net, seq->private, *pos - 1)
|
2005-04-16 16:20:36 -06:00
|
|
|
: SEQ_START_TOKEN;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *ipmr_vif_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct ipmr_vif_iter *iter = seq->private;
|
2009-01-21 21:56:22 -07:00
|
|
|
struct net *net = seq_file_net(seq);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt = iter->mrt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
++*pos;
|
|
|
|
if (v == SEQ_START_TOKEN)
|
2009-01-21 21:56:22 -07:00
|
|
|
return ipmr_vif_seq_idx(net, iter, 0);
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
while (++iter->ct < mrt->maxvif) {
|
|
|
|
if (!VIF_EXISTS(mrt, iter->ct))
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
2010-04-12 23:03:22 -06:00
|
|
|
return &mrt->vif_table[iter->ct];
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
|
2008-01-21 18:28:59 -07:00
|
|
|
__releases(mrt_lock)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
read_unlock(&mrt_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct ipmr_vif_iter *iter = seq->private;
|
|
|
|
struct mr_table *mrt = iter->mrt;
|
2009-01-21 21:56:22 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (v == SEQ_START_TOKEN) {
|
2007-02-09 07:24:47 -07:00
|
|
|
seq_puts(seq,
|
2005-04-16 16:20:36 -06:00
|
|
|
"Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
|
|
|
|
} else {
|
|
|
|
const struct vif_device *vif = v;
|
|
|
|
const char *name = vif->dev ? vif->dev->name : "none";
|
|
|
|
|
|
|
|
seq_printf(seq,
|
|
|
|
"%2Zd %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
|
2010-04-12 23:03:22 -06:00
|
|
|
vif - mrt->vif_table,
|
2007-02-09 07:24:47 -07:00
|
|
|
name, vif->bytes_in, vif->pkt_in,
|
2005-04-16 16:20:36 -06:00
|
|
|
vif->bytes_out, vif->pkt_out,
|
|
|
|
vif->flags, vif->local, vif->remote);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-12 15:34:29 -06:00
|
|
|
static const struct seq_operations ipmr_vif_seq_ops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.start = ipmr_vif_seq_start,
|
|
|
|
.next = ipmr_vif_seq_next,
|
|
|
|
.stop = ipmr_vif_seq_stop,
|
|
|
|
.show = ipmr_vif_seq_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int ipmr_vif_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2009-01-21 21:56:22 -07:00
|
|
|
return seq_open_net(inode, file, &ipmr_vif_seq_ops,
|
|
|
|
sizeof(struct ipmr_vif_iter));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-12 01:55:35 -07:00
|
|
|
static const struct file_operations ipmr_vif_fops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = ipmr_vif_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2009-01-21 21:56:22 -07:00
|
|
|
.release = seq_release_net,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ipmr_mfc_iter {
|
2009-01-21 21:56:22 -07:00
|
|
|
struct seq_net_private p;
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt;
|
2010-04-12 23:03:21 -06:00
|
|
|
struct list_head *cache;
|
2005-04-16 16:20:36 -06:00
|
|
|
int ct;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2009-01-21 21:56:22 -07:00
|
|
|
static struct mfc_cache *ipmr_mfc_seq_idx(struct net *net,
|
|
|
|
struct ipmr_mfc_iter *it, loff_t pos)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt = it->mrt;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct mfc_cache *mfc;
|
|
|
|
|
2010-10-01 10:15:08 -06:00
|
|
|
rcu_read_lock();
|
2010-04-12 23:03:21 -06:00
|
|
|
for (it->ct = 0; it->ct < MFC_LINES; it->ct++) {
|
2010-04-12 23:03:22 -06:00
|
|
|
it->cache = &mrt->mfc_cache_array[it->ct];
|
2010-10-01 10:15:08 -06:00
|
|
|
list_for_each_entry_rcu(mfc, it->cache, list)
|
2007-02-09 07:24:47 -07:00
|
|
|
if (pos-- == 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return mfc;
|
2010-04-12 23:03:21 -06:00
|
|
|
}
|
2010-10-01 10:15:08 -06:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
spin_lock_bh(&mfc_unres_lock);
|
2010-04-12 23:03:22 -06:00
|
|
|
it->cache = &mrt->mfc_unres_queue;
|
2010-04-12 23:03:21 -06:00
|
|
|
list_for_each_entry(mfc, it->cache, list)
|
2010-04-12 23:03:19 -06:00
|
|
|
if (pos-- == 0)
|
2005-04-16 16:20:36 -06:00
|
|
|
return mfc;
|
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
|
|
|
|
it->cache = NULL;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct ipmr_mfc_iter *it = seq->private;
|
2009-01-21 21:56:22 -07:00
|
|
|
struct net *net = seq_file_net(seq);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt;
|
2009-01-21 21:56:22 -07:00
|
|
|
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
|
|
|
|
if (mrt == NULL)
|
|
|
|
return ERR_PTR(-ENOENT);
|
2009-01-21 21:56:22 -07:00
|
|
|
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
it->mrt = mrt;
|
2005-04-16 16:20:36 -06:00
|
|
|
it->cache = NULL;
|
|
|
|
it->ct = 0;
|
2009-01-21 21:56:22 -07:00
|
|
|
return *pos ? ipmr_mfc_seq_idx(net, seq->private, *pos - 1)
|
2005-04-16 16:20:36 -06:00
|
|
|
: SEQ_START_TOKEN;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void *ipmr_mfc_seq_next(struct seq_file *seq, void *v, loff_t *pos)
|
|
|
|
{
|
|
|
|
struct mfc_cache *mfc = v;
|
|
|
|
struct ipmr_mfc_iter *it = seq->private;
|
2009-01-21 21:56:22 -07:00
|
|
|
struct net *net = seq_file_net(seq);
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt = it->mrt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
++*pos;
|
|
|
|
|
|
|
|
if (v == SEQ_START_TOKEN)
|
2009-01-21 21:56:22 -07:00
|
|
|
return ipmr_mfc_seq_idx(net, seq->private, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-12 23:03:21 -06:00
|
|
|
if (mfc->list.next != it->cache)
|
|
|
|
return list_entry(mfc->list.next, struct mfc_cache, list);
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
if (it->cache == &mrt->mfc_unres_queue)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto end_of_list;
|
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
BUG_ON(it->cache != &mrt->mfc_cache_array[it->ct]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
while (++it->ct < MFC_LINES) {
|
2010-04-12 23:03:22 -06:00
|
|
|
it->cache = &mrt->mfc_cache_array[it->ct];
|
2010-04-12 23:03:21 -06:00
|
|
|
if (list_empty(it->cache))
|
|
|
|
continue;
|
|
|
|
return list_first_entry(it->cache, struct mfc_cache, list);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/* exhausted cache_array, show unresolved */
|
2010-10-01 10:15:08 -06:00
|
|
|
rcu_read_unlock();
|
2010-04-12 23:03:22 -06:00
|
|
|
it->cache = &mrt->mfc_unres_queue;
|
2005-04-16 16:20:36 -06:00
|
|
|
it->ct = 0;
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_lock_bh(&mfc_unres_lock);
|
2010-04-12 23:03:21 -06:00
|
|
|
if (!list_empty(it->cache))
|
|
|
|
return list_first_entry(it->cache, struct mfc_cache, list);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-10-01 10:15:29 -06:00
|
|
|
end_of_list:
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
it->cache = NULL;
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void ipmr_mfc_seq_stop(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
struct ipmr_mfc_iter *it = seq->private;
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
struct mr_table *mrt = it->mrt;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
if (it->cache == &mrt->mfc_unres_queue)
|
2005-04-16 16:20:36 -06:00
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
2010-04-12 23:03:22 -06:00
|
|
|
else if (it->cache == &mrt->mfc_cache_array[it->ct])
|
2010-10-01 10:15:08 -06:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
if (v == SEQ_START_TOKEN) {
|
2007-02-09 07:24:47 -07:00
|
|
|
seq_puts(seq,
|
2005-04-16 16:20:36 -06:00
|
|
|
"Group Origin Iif Pkts Bytes Wrong Oifs\n");
|
|
|
|
} else {
|
|
|
|
const struct mfc_cache *mfc = v;
|
|
|
|
const struct ipmr_mfc_iter *it = seq->private;
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
const struct mr_table *mrt = it->mrt;
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2010-04-20 20:06:52 -06:00
|
|
|
seq_printf(seq, "%08X %08X %-3hd",
|
|
|
|
(__force u32) mfc->mfc_mcastgrp,
|
|
|
|
(__force u32) mfc->mfc_origin,
|
2008-12-03 23:21:47 -07:00
|
|
|
mfc->mfc_parent);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2010-04-12 23:03:22 -06:00
|
|
|
if (it->cache != &mrt->mfc_unres_queue) {
|
2008-12-03 23:21:47 -07:00
|
|
|
seq_printf(seq, " %8lu %8lu %8lu",
|
|
|
|
mfc->mfc_un.res.pkt,
|
|
|
|
mfc->mfc_un.res.bytes,
|
|
|
|
mfc->mfc_un.res.wrong_if);
|
2007-03-08 21:44:43 -07:00
|
|
|
for (n = mfc->mfc_un.res.minvif;
|
2010-10-01 10:15:29 -06:00
|
|
|
n < mfc->mfc_un.res.maxvif; n++) {
|
2010-04-12 23:03:22 -06:00
|
|
|
if (VIF_EXISTS(mrt, n) &&
|
2009-01-21 21:56:16 -07:00
|
|
|
mfc->mfc_un.res.ttls[n] < 255)
|
|
|
|
seq_printf(seq,
|
2007-02-09 07:24:47 -07:00
|
|
|
" %2d:%-3d",
|
2005-04-16 16:20:36 -06:00
|
|
|
n, mfc->mfc_un.res.ttls[n]);
|
|
|
|
}
|
2008-12-03 23:21:47 -07:00
|
|
|
} else {
|
|
|
|
/* unresolved mfc_caches don't contain
|
|
|
|
* pkt, bytes and wrong_if values
|
|
|
|
*/
|
|
|
|
seq_printf(seq, " %8lu %8lu %8lu", 0ul, 0ul, 0ul);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
seq_putc(seq, '\n');
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-12 15:34:29 -06:00
|
|
|
static const struct seq_operations ipmr_mfc_seq_ops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.start = ipmr_mfc_seq_start,
|
|
|
|
.next = ipmr_mfc_seq_next,
|
|
|
|
.stop = ipmr_mfc_seq_stop,
|
|
|
|
.show = ipmr_mfc_seq_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
static int ipmr_mfc_open(struct inode *inode, struct file *file)
|
|
|
|
{
|
2009-01-21 21:56:22 -07:00
|
|
|
return seq_open_net(inode, file, &ipmr_mfc_seq_ops,
|
|
|
|
sizeof(struct ipmr_mfc_iter));
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-02-12 01:55:35 -07:00
|
|
|
static const struct file_operations ipmr_mfc_fops = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.owner = THIS_MODULE,
|
|
|
|
.open = ipmr_mfc_open,
|
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
2009-01-21 21:56:22 -07:00
|
|
|
.release = seq_release_net,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
2007-02-09 07:24:47 -07:00
|
|
|
#endif
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
#ifdef CONFIG_IP_PIMSM_V2
|
2009-09-14 06:21:47 -06:00
|
|
|
static const struct net_protocol pim_protocol = {
|
2005-04-16 16:20:36 -06:00
|
|
|
.handler = pim_rcv,
|
2009-06-14 04:16:13 -06:00
|
|
|
.netns_ok = 1,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Setup for IP multicast routing
|
|
|
|
*/
|
2009-01-21 21:56:16 -07:00
|
|
|
static int __net_init ipmr_net_init(struct net *net)
|
|
|
|
{
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
int err;
|
2009-01-21 21:56:16 -07:00
|
|
|
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
err = ipmr_rules_init(net);
|
|
|
|
if (err < 0)
|
2009-01-21 21:56:16 -07:00
|
|
|
goto fail;
|
2009-01-21 21:56:22 -07:00
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
err = -ENOMEM;
|
|
|
|
if (!proc_net_fops_create(net, "ip_mr_vif", 0, &ipmr_vif_fops))
|
|
|
|
goto proc_vif_fail;
|
|
|
|
if (!proc_net_fops_create(net, "ip_mr_cache", 0, &ipmr_mfc_fops))
|
|
|
|
goto proc_cache_fail;
|
|
|
|
#endif
|
2009-01-21 21:56:18 -07:00
|
|
|
return 0;
|
|
|
|
|
2009-01-21 21:56:22 -07:00
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
proc_cache_fail:
|
|
|
|
proc_net_remove(net, "ip_mr_vif");
|
|
|
|
proc_vif_fail:
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
ipmr_rules_exit(net);
|
2009-01-21 21:56:22 -07:00
|
|
|
#endif
|
2009-01-21 21:56:16 -07:00
|
|
|
fail:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit ipmr_net_exit(struct net *net)
|
|
|
|
{
|
2009-01-21 21:56:22 -07:00
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
proc_net_remove(net, "ip_mr_cache");
|
|
|
|
proc_net_remove(net, "ip_mr_vif");
|
|
|
|
#endif
|
ipv4: ipmr: support multiple tables
This patch adds support for multiple independant multicast routing instances,
named "tables".
Userspace multicast routing daemons can bind to a specific table instance by
issuing a setsockopt call using a new option MRT_TABLE. The table number is
stored in the raw socket data and affects all following ipmr setsockopt(),
getsockopt() and ioctl() calls. By default, a single table (RT_TABLE_DEFAULT)
is created with a default routing rule pointing to it. Newly created pimreg
devices have the table number appended ("pimregX"), with the exception of
devices created in the default table, which are named just "pimreg" for
compatibility reasons.
Packets are directed to a specific table instance using routing rules,
similar to how regular routing rules work. Currently iif, oif and mark
are supported as keys, source and destination addresses could be supported
additionally.
Example usage:
- bind pimd/xorp/... to a specific table:
uint32_t table = 123;
setsockopt(fd, IPPROTO_IP, MRT_TABLE, &table, sizeof(table));
- create routing rules directing packets to the new table:
# ip mrule add iif eth0 lookup 123
# ip mrule add oif eth0 lookup 123
Signed-off-by: Patrick McHardy <kaber@trash.net>
Signed-off-by: David S. Miller <davem@davemloft.net>
2010-04-12 23:03:23 -06:00
|
|
|
ipmr_rules_exit(net);
|
2009-01-21 21:56:16 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct pernet_operations ipmr_net_ops = {
|
|
|
|
.init = ipmr_net_init,
|
|
|
|
.exit = ipmr_net_exit,
|
|
|
|
};
|
2007-02-09 07:24:47 -07:00
|
|
|
|
2008-07-02 22:13:36 -06:00
|
|
|
int __init ip_mr_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-07-02 22:13:36 -06:00
|
|
|
int err;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
mrt_cachep = kmem_cache_create("ip_mrt_cache",
|
|
|
|
sizeof(struct mfc_cache),
|
2010-10-01 10:15:08 -06:00
|
|
|
0, SLAB_HWCACHE_ALIGN | SLAB_PANIC,
|
2007-07-19 19:11:58 -06:00
|
|
|
NULL);
|
2008-07-02 22:13:36 -06:00
|
|
|
if (!mrt_cachep)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2009-01-21 21:56:16 -07:00
|
|
|
err = register_pernet_subsys(&ipmr_net_ops);
|
|
|
|
if (err)
|
|
|
|
goto reg_pernet_fail;
|
|
|
|
|
2008-07-02 22:13:36 -06:00
|
|
|
err = register_netdevice_notifier(&ip_mr_notifier);
|
|
|
|
if (err)
|
|
|
|
goto reg_notif_fail;
|
2009-06-14 04:16:13 -06:00
|
|
|
#ifdef CONFIG_IP_PIMSM_V2
|
|
|
|
if (inet_add_protocol(&pim_protocol, IPPROTO_PIM) < 0) {
|
2012-03-11 12:36:11 -06:00
|
|
|
pr_err("%s: can't add PIM protocol\n", __func__);
|
2009-06-14 04:16:13 -06:00
|
|
|
err = -EAGAIN;
|
|
|
|
goto add_proto_fail;
|
|
|
|
}
|
|
|
|
#endif
|
2011-06-09 19:27:09 -06:00
|
|
|
rtnl_register(RTNL_FAMILY_IPMR, RTM_GETROUTE,
|
|
|
|
NULL, ipmr_rtm_dumproute, NULL);
|
2008-07-02 22:13:36 -06:00
|
|
|
return 0;
|
2009-01-21 21:56:22 -07:00
|
|
|
|
2009-06-14 04:16:13 -06:00
|
|
|
#ifdef CONFIG_IP_PIMSM_V2
|
|
|
|
add_proto_fail:
|
|
|
|
unregister_netdevice_notifier(&ip_mr_notifier);
|
|
|
|
#endif
|
2008-11-19 15:07:41 -07:00
|
|
|
reg_notif_fail:
|
2009-01-21 21:56:16 -07:00
|
|
|
unregister_pernet_subsys(&ipmr_net_ops);
|
|
|
|
reg_pernet_fail:
|
2008-11-19 15:07:41 -07:00
|
|
|
kmem_cache_destroy(mrt_cachep);
|
2008-07-02 22:13:36 -06:00
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|