2019-05-27 14:55:01 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
* IP multicast routing support for mrouted 3.6/3.8
|
|
|
|
*
|
2008-10-14 10:01:08 +08:00
|
|
|
* (c) 1995 Alan Cox, <alan@lxorguk.ukuu.org.uk>
|
2005-04-17 06:20:36 +08:00
|
|
|
* Linux Consultancy and Custom Driver Development
|
|
|
|
*
|
|
|
|
* 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 21:41:47 +08:00
|
|
|
* Relax this requirement to work with older peers.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
2016-12-25 03:46:01 +08:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/types.h>
|
2018-02-25 02:20:33 +08:00
|
|
|
#include <linux/cache.h>
|
2006-01-12 04:17:47 +08:00
|
|
|
#include <linux/capability.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/errno.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-06 08:35:42 +08: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 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2007-09-12 18:01:34 +08:00
|
|
|
#include <net/net_namespace.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <net/ip.h>
|
|
|
|
#include <net/protocol.h>
|
|
|
|
#include <linux/skbuff.h>
|
2005-12-27 12:43:12 +08:00
|
|
|
#include <net/route.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#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-30 00:15:56 +08:00
|
|
|
#include <linux/compat.h>
|
2011-07-15 23:47:34 +08:00
|
|
|
#include <linux/export.h>
|
2018-06-18 10:52:50 +08:00
|
|
|
#include <linux/rhashtable.h>
|
2013-03-25 22:49:35 +08:00
|
|
|
#include <net/ip_tunnels.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <net/checksum.h>
|
2007-03-26 14:06:12 +08: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-13 13:03:23 +08:00
|
|
|
#include <net/fib_rules.h>
|
2012-12-04 09:13:35 +08:00
|
|
|
#include <linux/netconf.h>
|
2019-04-21 00:28:20 +08:00
|
|
|
#include <net/rtnh.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2018-12-11 02:41:24 +08:00
|
|
|
#include <linux/nospec.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-13 13:03:23 +08:00
|
|
|
struct ipmr_rule {
|
|
|
|
struct fib_rule common;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct ipmr_result {
|
|
|
|
struct mr_table *mrt;
|
|
|
|
};
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Big lock, protecting vif table, mrt cache and mroute socket state.
|
2010-10-02 00:15:29 +08:00
|
|
|
* Note that the changes are semaphored via rtnl_lock.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
2022-06-23 12:34:48 +08:00
|
|
|
static DEFINE_SPINLOCK(mrt_lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2022-06-23 12:34:32 +08:00
|
|
|
static struct net_device *vif_dev_read(const struct vif_device *vif)
|
|
|
|
{
|
2022-06-23 12:34:48 +08:00
|
|
|
return rcu_dereference(vif->dev);
|
2022-06-23 12:34:32 +08:00
|
|
|
}
|
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Multicast router control variables */
|
2005-04-17 06:20:36 +08: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-02 00:15:29 +08: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-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
2018-02-25 02:20:33 +08:00
|
|
|
static struct kmem_cache *mrt_cachep __ro_after_init;
|
2005-04-17 06:20:36 +08: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-13 13:03:23 +08:00
|
|
|
static struct mr_table *ipmr_new_table(struct net *net, u32 id);
|
2012-08-24 15:38:35 +08:00
|
|
|
static void ipmr_free_table(struct mr_table *mrt);
|
|
|
|
|
2013-07-20 20:09:28 +08:00
|
|
|
static void ip_mr_forward(struct net *net, struct mr_table *mrt,
|
2017-06-11 04:30:17 +08:00
|
|
|
struct net_device *dev, struct sk_buff *skb,
|
|
|
|
struct mfc_cache *cache, int local);
|
2022-06-23 12:34:34 +08:00
|
|
|
static int ipmr_cache_report(const struct mr_table *mrt,
|
2009-01-22 12:56:23 +08:00
|
|
|
struct sk_buff *pkt, vifi_t vifi, int assert);
|
2012-12-04 09:13:40 +08:00
|
|
|
static void mroute_netlink_event(struct mr_table *mrt, struct mfc_cache *mfc,
|
|
|
|
int cmd);
|
2022-06-23 12:34:33 +08:00
|
|
|
static void igmpmsg_netlink_event(const struct mr_table *mrt, struct sk_buff *pkt);
|
2019-02-18 05:07:52 +08:00
|
|
|
static void mroute_clean_tables(struct mr_table *mrt, int flags);
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-17 05:43:17 +08:00
|
|
|
static void ipmr_expire_process(struct timer_list *t);
|
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-13 13:03:23 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
|
2020-05-15 02:01:03 +08:00
|
|
|
#define ipmr_for_each_table(mrt, net) \
|
|
|
|
list_for_each_entry_rcu(mrt, &net->ipv4.mr_tables, list, \
|
|
|
|
lockdep_rtnl_is_held() || \
|
|
|
|
list_empty(&net->ipv4.mr_tables))
|
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-13 13:03:23 +08:00
|
|
|
|
2018-03-01 05:29:39 +08:00
|
|
|
static struct mr_table *ipmr_mr_table_iter(struct net *net,
|
|
|
|
struct mr_table *mrt)
|
|
|
|
{
|
|
|
|
struct mr_table *ret;
|
|
|
|
|
|
|
|
if (!mrt)
|
|
|
|
ret = list_entry_rcu(net->ipv4.mr_tables.next,
|
|
|
|
struct mr_table, list);
|
|
|
|
else
|
|
|
|
ret = list_entry_rcu(mrt->list.next,
|
|
|
|
struct mr_table, list);
|
|
|
|
|
|
|
|
if (&ret->list == &net->ipv4.mr_tables)
|
|
|
|
return NULL;
|
|
|
|
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-13 13:03:23 +08:00
|
|
|
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 15:04:50 +08: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-13 13:03:23 +08:00
|
|
|
struct mr_table **mrt)
|
|
|
|
{
|
|
|
|
int err;
|
2014-01-13 09:45:22 +08:00
|
|
|
struct ipmr_result res;
|
|
|
|
struct fib_lookup_arg arg = {
|
|
|
|
.result = &res,
|
|
|
|
.flags = FIB_LOOKUP_NOREF,
|
|
|
|
};
|
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-13 13:03:23 +08:00
|
|
|
|
2016-11-01 06:54:00 +08:00
|
|
|
/* update flow if oif or iif point to device enslaved to l3mdev */
|
|
|
|
l3mdev_update_flow(net, flowi4_to_flowi(flp4));
|
|
|
|
|
2011-03-12 15:04:50 +08: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-13 13:03:23 +08: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-17 06:20:36 +08: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-13 13:03:23 +08: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;
|
|
|
|
}
|
|
|
|
|
2016-11-01 06:54:00 +08:00
|
|
|
arg->table = fib_rule_get_table(rule, arg);
|
|
|
|
|
|
|
|
mrt = ipmr_get_table(rule->fr_net, arg->table);
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!mrt)
|
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-13 13:03:23 +08:00
|
|
|
return -EAGAIN;
|
|
|
|
res->mrt = mrt;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ipmr_rule_match(struct fib_rule *rule, struct flowi *fl, int flags)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ipmr_rule_configure(struct fib_rule *rule, struct sk_buff *skb,
|
2018-04-22 00:41:31 +08:00
|
|
|
struct fib_rule_hdr *frh, struct nlattr **tb,
|
|
|
|
struct netlink_ext_ack *extack)
|
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-13 13:03:23 +08:00
|
|
|
{
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2012-10-05 08:12:11 +08:00
|
|
|
static const struct fib_rules_ops __net_initconst ipmr_rules_ops_template = {
|
2010-04-26 22:02:05 +08: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-13 13:03:23 +08: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,
|
|
|
|
.fill = ipmr_rule_fill,
|
|
|
|
.nlgroup = RTNLGRP_IPV4_RULE,
|
|
|
|
.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);
|
2015-11-21 22:57:24 +08:00
|
|
|
if (IS_ERR(mrt)) {
|
|
|
|
err = PTR_ERR(mrt);
|
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-13 13:03:23 +08:00
|
|
|
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:
|
2022-02-08 13:34:51 +08:00
|
|
|
rtnl_lock();
|
2015-03-26 05:45:03 +08:00
|
|
|
ipmr_free_table(mrt);
|
2022-02-08 13:34:51 +08:00
|
|
|
rtnl_unlock();
|
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-13 13:03:23 +08:00
|
|
|
err1:
|
|
|
|
fib_rules_unregister(ops);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit ipmr_rules_exit(struct net *net)
|
|
|
|
{
|
|
|
|
struct mr_table *mrt, *next;
|
|
|
|
|
2022-02-08 12:50:35 +08:00
|
|
|
ASSERT_RTNL();
|
2010-06-07 07:48:40 +08:00
|
|
|
list_for_each_entry_safe(mrt, next, &net->ipv4.mr_tables, list) {
|
|
|
|
list_del(&mrt->list);
|
2012-08-24 15:38:35 +08:00
|
|
|
ipmr_free_table(mrt);
|
2010-06-07 07:48:40 +08: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-13 13:03:23 +08:00
|
|
|
fib_rules_unregister(net->ipv4.mr_rules_ops);
|
|
|
|
}
|
2017-09-27 14:23:13 +08:00
|
|
|
|
2019-10-03 17:49:30 +08:00
|
|
|
static int ipmr_rules_dump(struct net *net, struct notifier_block *nb,
|
|
|
|
struct netlink_ext_ack *extack)
|
2017-09-27 14:23:13 +08:00
|
|
|
{
|
2019-10-03 17:49:30 +08:00
|
|
|
return fib_rules_dump(net, nb, RTNL_FAMILY_IPMR, extack);
|
2017-09-27 14:23:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int ipmr_rules_seq_read(struct net *net)
|
|
|
|
{
|
|
|
|
return fib_rules_seq_read(net, RTNL_FAMILY_IPMR);
|
|
|
|
}
|
2017-09-27 14:23:16 +08:00
|
|
|
|
|
|
|
bool ipmr_rule_default(const struct fib_rule *rule)
|
|
|
|
{
|
|
|
|
return fib_rule_matchall(rule) && rule->table == RT_TABLE_DEFAULT;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ipmr_rule_default);
|
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-13 13:03:23 +08:00
|
|
|
#else
|
|
|
|
#define ipmr_for_each_table(mrt, net) \
|
|
|
|
for (mrt = net->ipv4.mrt; mrt; mrt = NULL)
|
|
|
|
|
2018-03-01 05:29:39 +08:00
|
|
|
static struct mr_table *ipmr_mr_table_iter(struct net *net,
|
|
|
|
struct mr_table *mrt)
|
|
|
|
{
|
|
|
|
if (!mrt)
|
|
|
|
return net->ipv4.mrt;
|
|
|
|
return 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-13 13:03:23 +08:00
|
|
|
static struct mr_table *ipmr_get_table(struct net *net, u32 id)
|
|
|
|
{
|
|
|
|
return net->ipv4.mrt;
|
|
|
|
}
|
|
|
|
|
2011-03-12 15:04:50 +08: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-13 13:03:23 +08:00
|
|
|
struct mr_table **mrt)
|
|
|
|
{
|
|
|
|
*mrt = net->ipv4.mrt;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __net_init ipmr_rules_init(struct net *net)
|
|
|
|
{
|
2015-11-21 22:57:24 +08:00
|
|
|
struct mr_table *mrt;
|
|
|
|
|
|
|
|
mrt = ipmr_new_table(net, RT_TABLE_DEFAULT);
|
|
|
|
if (IS_ERR(mrt))
|
|
|
|
return PTR_ERR(mrt);
|
|
|
|
net->ipv4.mrt = mrt;
|
|
|
|
return 0;
|
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-13 13:03:23 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit ipmr_rules_exit(struct net *net)
|
|
|
|
{
|
2022-02-08 12:50:35 +08:00
|
|
|
ASSERT_RTNL();
|
2012-08-24 15:38:35 +08:00
|
|
|
ipmr_free_table(net->ipv4.mrt);
|
2015-04-01 02:01:45 +08:00
|
|
|
net->ipv4.mrt = 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-13 13:03:23 +08:00
|
|
|
}
|
2017-09-27 14:23:13 +08:00
|
|
|
|
2019-10-03 17:49:30 +08:00
|
|
|
static int ipmr_rules_dump(struct net *net, struct notifier_block *nb,
|
|
|
|
struct netlink_ext_ack *extack)
|
2017-09-27 14:23:13 +08:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static unsigned int ipmr_rules_seq_read(struct net *net)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
2017-09-27 14:23:16 +08:00
|
|
|
|
|
|
|
bool ipmr_rule_default(const struct fib_rule *rule)
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(ipmr_rule_default);
|
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-13 13:03:23 +08:00
|
|
|
#endif
|
|
|
|
|
2017-01-12 22:53:33 +08:00
|
|
|
static inline int ipmr_hash_cmp(struct rhashtable_compare_arg *arg,
|
|
|
|
const void *ptr)
|
|
|
|
{
|
|
|
|
const struct mfc_cache_cmp_arg *cmparg = arg->key;
|
2022-04-29 10:14:04 +08:00
|
|
|
const struct mfc_cache *c = ptr;
|
2017-01-12 22:53:33 +08:00
|
|
|
|
|
|
|
return cmparg->mfc_mcastgrp != c->mfc_mcastgrp ||
|
|
|
|
cmparg->mfc_origin != c->mfc_origin;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct rhashtable_params ipmr_rht_params = {
|
2018-03-01 05:29:34 +08:00
|
|
|
.head_offset = offsetof(struct mr_mfc, mnode),
|
2017-01-12 22:53:33 +08:00
|
|
|
.key_offset = offsetof(struct mfc_cache, cmparg),
|
|
|
|
.key_len = sizeof(struct mfc_cache_cmp_arg),
|
|
|
|
.nelem_hint = 3,
|
|
|
|
.obj_cmpfn = ipmr_hash_cmp,
|
|
|
|
.automatic_shrinking = true,
|
|
|
|
};
|
|
|
|
|
2018-03-01 05:29:33 +08:00
|
|
|
static void ipmr_new_table_set(struct mr_table *mrt,
|
|
|
|
struct net *net)
|
|
|
|
{
|
|
|
|
#ifdef CONFIG_IP_MROUTE_MULTIPLE_TABLES
|
|
|
|
list_add_tail_rcu(&mrt->list, &net->ipv4.mr_tables);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2018-03-01 05:29:35 +08:00
|
|
|
static struct mfc_cache_cmp_arg ipmr_mr_table_ops_cmparg_any = {
|
|
|
|
.mfc_mcastgrp = htonl(INADDR_ANY),
|
|
|
|
.mfc_origin = htonl(INADDR_ANY),
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct mr_table_ops ipmr_mr_table_ops = {
|
|
|
|
.rht_params = &ipmr_rht_params,
|
|
|
|
.cmparg_any = &ipmr_mr_table_ops_cmparg_any,
|
|
|
|
};
|
|
|
|
|
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-13 13:03:23 +08:00
|
|
|
static struct mr_table *ipmr_new_table(struct net *net, u32 id)
|
|
|
|
{
|
|
|
|
struct mr_table *mrt;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-11-21 22:57:24 +08:00
|
|
|
/* "pimreg%u" should not exceed 16 bytes (IFNAMSIZ) */
|
|
|
|
if (id != RT_TABLE_DEFAULT && id >= 1000000000)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
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-13 13:03:23 +08:00
|
|
|
mrt = ipmr_get_table(net, id);
|
2015-04-03 16:17:27 +08:00
|
|
|
if (mrt)
|
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-13 13:03:23 +08:00
|
|
|
return mrt;
|
|
|
|
|
2018-03-01 05:29:35 +08:00
|
|
|
return mr_table_alloc(net, id, &ipmr_mr_table_ops,
|
2018-03-01 05:29:33 +08:00
|
|
|
ipmr_expire_process, ipmr_new_table_set);
|
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-13 13:03:23 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-08-24 15:38:35 +08:00
|
|
|
static void ipmr_free_table(struct mr_table *mrt)
|
|
|
|
{
|
2022-12-21 02:45:19 +08:00
|
|
|
timer_shutdown_sync(&mrt->ipmr_expire_timer);
|
2019-02-18 05:07:52 +08:00
|
|
|
mroute_clean_tables(mrt, MRT_FLUSH_VIFS | MRT_FLUSH_VIFS_STATIC |
|
|
|
|
MRT_FLUSH_MFC | MRT_FLUSH_MFC_STATIC);
|
2017-01-12 22:53:33 +08:00
|
|
|
rhltable_destroy(&mrt->mfc_hash);
|
2012-08-24 15:38:35 +08:00
|
|
|
kfree(mrt);
|
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Service routines creating virtual interfaces: DVMRP tunnels and PIMREG */
|
|
|
|
|
2015-11-21 22:57:32 +08:00
|
|
|
/* Initialize ipmr pimreg/tunnel in_device */
|
|
|
|
static bool ipmr_init_vif_indev(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
struct in_device *in_dev;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
in_dev = __in_dev_get_rtnl(dev);
|
|
|
|
if (!in_dev)
|
|
|
|
return false;
|
|
|
|
ipv4_devconf_setall(in_dev);
|
|
|
|
neigh_parms_data_state_setall(in_dev->arp_parms);
|
|
|
|
IPV4_DEVCONF(in_dev->cnf, RP_FILTER) = 0;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
static struct net_device *ipmr_new_tunnel(struct net *net, struct vifctl *v)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2020-05-19 21:03:11 +08:00
|
|
|
struct net_device *tunnel_dev, *new_dev;
|
|
|
|
struct ip_tunnel_parm p = { };
|
|
|
|
int err;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2020-05-19 21:03:11 +08:00
|
|
|
tunnel_dev = __dev_get_by_name(net, "tunl0");
|
|
|
|
if (!tunnel_dev)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
2020-05-19 21:03:14 +08:00
|
|
|
if (!tunnel_dev->netdev_ops->ndo_tunnel_ctl)
|
2020-05-19 21:03:11 +08:00
|
|
|
goto out;
|
2020-05-19 21:03:14 +08:00
|
|
|
err = tunnel_dev->netdev_ops->ndo_tunnel_ctl(tunnel_dev, &p,
|
2020-05-19 21:03:11 +08:00
|
|
|
SIOCADDTUNNEL);
|
|
|
|
if (err)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
new_dev = __dev_get_by_name(net, p.name);
|
|
|
|
if (!new_dev)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
new_dev->flags |= IFF_MULTICAST;
|
|
|
|
if (!ipmr_init_vif_indev(new_dev))
|
|
|
|
goto out_unregister;
|
|
|
|
if (dev_open(new_dev, NULL))
|
|
|
|
goto out_unregister;
|
|
|
|
dev_hold(new_dev);
|
2020-05-19 21:03:12 +08:00
|
|
|
err = dev_set_allmulti(new_dev, 1);
|
|
|
|
if (err) {
|
|
|
|
dev_close(new_dev);
|
2020-05-19 21:03:14 +08:00
|
|
|
tunnel_dev->netdev_ops->ndo_tunnel_ctl(tunnel_dev, &p,
|
2020-05-19 21:03:12 +08:00
|
|
|
SIOCDELTUNNEL);
|
|
|
|
dev_put(new_dev);
|
|
|
|
new_dev = ERR_PTR(err);
|
|
|
|
}
|
2020-05-19 21:03:11 +08:00
|
|
|
return new_dev;
|
|
|
|
|
|
|
|
out_unregister:
|
|
|
|
unregister_netdevice(new_dev);
|
|
|
|
out:
|
2020-05-19 21:03:12 +08:00
|
|
|
return ERR_PTR(-ENOBUFS);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2015-11-21 22:57:26 +08:00
|
|
|
#if defined(CONFIG_IP_PIMSM_V1) || defined(CONFIG_IP_PIMSM_V2)
|
2009-09-01 03:50:41 +08:00
|
|
|
static netdev_tx_t reg_vif_xmit(struct sk_buff *skb, struct net_device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-01-22 12:56:23 +08: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-13 13:03:23 +08:00
|
|
|
struct mr_table *mrt;
|
2011-03-12 15:04:50 +08:00
|
|
|
struct flowi4 fl4 = {
|
|
|
|
.flowi4_oif = dev->ifindex,
|
ipv4, fib: pass LOOPBACK_IFINDEX instead of 0 to flowi4_iif
As suggested by Julian:
Simply, flowi4_iif must not contain 0, it does not
look logical to ignore all ip rules with specified iif.
because in fib_rule_match() we do:
if (rule->iifindex && (rule->iifindex != fl->flowi_iif))
goto out;
flowi4_iif should be LOOPBACK_IFINDEX by default.
We need to move LOOPBACK_IFINDEX to include/net/flow.h:
1) It is mostly used by flowi_iif
2) Fix the following compile error if we use it in flow.h
by the patches latter:
In file included from include/linux/netfilter.h:277:0,
from include/net/netns/netfilter.h:5,
from include/net/net_namespace.h:21,
from include/linux/netdevice.h:43,
from include/linux/icmpv6.h:12,
from include/linux/ipv6.h:61,
from include/net/ipv6.h:16,
from include/linux/sunrpc/clnt.h:27,
from include/linux/nfs_fs.h:30,
from init/do_mounts.c:32:
include/net/flow.h: In function ‘flowi4_init_output’:
include/net/flow.h:84:32: error: ‘LOOPBACK_IFINDEX’ undeclared (first use in this function)
Cc: Eric Biederman <ebiederm@xmission.com>
Cc: Julian Anastasov <ja@ssi.bg>
Cc: David S. Miller <davem@davemloft.net>
Signed-off-by: Cong Wang <xiyou.wangcong@gmail.com>
Signed-off-by: Cong Wang <cwang@twopensource.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-04-16 07:25:34 +08:00
|
|
|
.flowi4_iif = skb->skb_iif ? : LOOPBACK_IFINDEX,
|
2011-03-12 15:04:50 +08:00
|
|
|
.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-13 13:03:23 +08:00
|
|
|
};
|
|
|
|
int err;
|
|
|
|
|
2011-03-12 15:04:50 +08:00
|
|
|
err = ipmr_fib_lookup(net, &fl4, &mrt);
|
2010-07-15 21:22:33 +08: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-13 13:03:23 +08:00
|
|
|
return err;
|
2010-07-15 21:22:33 +08:00
|
|
|
}
|
2009-01-22 12:56:23 +08:00
|
|
|
|
2022-11-15 16:53:58 +08:00
|
|
|
DEV_STATS_ADD(dev, tx_bytes, skb->len);
|
|
|
|
DEV_STATS_INC(dev, tx_packets);
|
2022-06-23 12:34:34 +08:00
|
|
|
rcu_read_lock();
|
|
|
|
|
|
|
|
/* Pairs with WRITE_ONCE() in vif_add() and vif_delete() */
|
|
|
|
ipmr_cache_report(mrt, skb, READ_ONCE(mrt->mroute_reg_vif_num),
|
|
|
|
IGMPMSG_WHOLEPKT);
|
|
|
|
|
|
|
|
rcu_read_unlock();
|
2005-04-17 06:20:36 +08:00
|
|
|
kfree_skb(skb);
|
2009-06-23 14:03:08 +08:00
|
|
|
return NETDEV_TX_OK;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2015-04-02 23:07:03 +08:00
|
|
|
static int reg_vif_get_iflink(const struct net_device *dev)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-11-21 12:28:35 +08:00
|
|
|
static const struct net_device_ops reg_vif_netdev_ops = {
|
|
|
|
.ndo_start_xmit = reg_vif_xmit,
|
2015-04-02 23:07:03 +08:00
|
|
|
.ndo_get_iflink = reg_vif_get_iflink,
|
2008-11-21 12:28:35 +08:00
|
|
|
};
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static void reg_vif_setup(struct net_device *dev)
|
|
|
|
{
|
|
|
|
dev->type = ARPHRD_PIMREG;
|
2006-01-06 08:35:42 +08:00
|
|
|
dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr) - 8;
|
2005-04-17 06:20:36 +08:00
|
|
|
dev->flags = IFF_NOARP;
|
2014-05-30 23:40:48 +08:00
|
|
|
dev->netdev_ops = ®_vif_netdev_ops;
|
net: Fix inconsistent teardown and release of private netdev state.
Network devices can allocate reasources and private memory using
netdev_ops->ndo_init(). However, the release of these resources
can occur in one of two different places.
Either netdev_ops->ndo_uninit() or netdev->destructor().
The decision of which operation frees the resources depends upon
whether it is necessary for all netdev refs to be released before it
is safe to perform the freeing.
netdev_ops->ndo_uninit() presumably can occur right after the
NETDEV_UNREGISTER notifier completes and the unicast and multicast
address lists are flushed.
netdev->destructor(), on the other hand, does not run until the
netdev references all go away.
Further complicating the situation is that netdev->destructor()
almost universally does also a free_netdev().
This creates a problem for the logic in register_netdevice().
Because all callers of register_netdevice() manage the freeing
of the netdev, and invoke free_netdev(dev) if register_netdevice()
fails.
If netdev_ops->ndo_init() succeeds, but something else fails inside
of register_netdevice(), it does call ndo_ops->ndo_uninit(). But
it is not able to invoke netdev->destructor().
This is because netdev->destructor() will do a free_netdev() and
then the caller of register_netdevice() will do the same.
However, this means that the resources that would normally be released
by netdev->destructor() will not be.
Over the years drivers have added local hacks to deal with this, by
invoking their destructor parts by hand when register_netdevice()
fails.
Many drivers do not try to deal with this, and instead we have leaks.
Let's close this hole by formalizing the distinction between what
private things need to be freed up by netdev->destructor() and whether
the driver needs unregister_netdevice() to perform the free_netdev().
netdev->priv_destructor() performs all actions to free up the private
resources that used to be freed by netdev->destructor(), except for
free_netdev().
netdev->needs_free_netdev is a boolean that indicates whether
free_netdev() should be done at the end of unregister_netdevice().
Now, register_netdevice() can sanely release all resources after
ndo_ops->ndo_init() succeeds, by invoking both ndo_ops->ndo_uninit()
and netdev->priv_destructor().
And at the end of unregister_netdevice(), we invoke
netdev->priv_destructor() and optionally call free_netdev().
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-05-09 00:52:56 +08:00
|
|
|
dev->needs_free_netdev = true;
|
2009-06-14 18:16:13 +08:00
|
|
|
dev->features |= NETIF_F_NETNS_LOCAL;
|
2005-04-17 06:20:36 +08: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-13 13:03:23 +08:00
|
|
|
static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct net_device *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-13 13:03:23 +08:00
|
|
|
char name[IFNAMSIZ];
|
2005-04-17 06:20:36 +08: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-13 13:03:23 +08:00
|
|
|
if (mrt->id == RT_TABLE_DEFAULT)
|
|
|
|
sprintf(name, "pimreg");
|
|
|
|
else
|
|
|
|
sprintf(name, "pimreg%u", mrt->id);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
net: set name_assign_type in alloc_netdev()
Extend alloc_netdev{,_mq{,s}}() to take name_assign_type as argument, and convert
all users to pass NET_NAME_UNKNOWN.
Coccinelle patch:
@@
expression sizeof_priv, name, setup, txqs, rxqs, count;
@@
(
-alloc_netdev_mqs(sizeof_priv, name, setup, txqs, rxqs)
+alloc_netdev_mqs(sizeof_priv, name, NET_NAME_UNKNOWN, setup, txqs, rxqs)
|
-alloc_netdev_mq(sizeof_priv, name, setup, count)
+alloc_netdev_mq(sizeof_priv, name, NET_NAME_UNKNOWN, setup, count)
|
-alloc_netdev(sizeof_priv, name, setup)
+alloc_netdev(sizeof_priv, name, NET_NAME_UNKNOWN, setup)
)
v9: move comments here from the wrong commit
Signed-off-by: Tom Gundersen <teg@jklm.no>
Reviewed-by: David Herrmann <dh.herrmann@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2014-07-14 22:37:24 +08:00
|
|
|
dev = alloc_netdev(0, name, NET_NAME_UNKNOWN, reg_vif_setup);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
return NULL;
|
|
|
|
|
2009-06-14 18:16:13 +08:00
|
|
|
dev_net_set(dev, net);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (register_netdevice(dev)) {
|
|
|
|
free_netdev(dev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2015-11-21 22:57:32 +08:00
|
|
|
if (!ipmr_init_vif_indev(dev))
|
2005-04-17 06:20:36 +08:00
|
|
|
goto failure;
|
2018-12-07 01:05:36 +08:00
|
|
|
if (dev_open(dev, NULL))
|
2005-04-17 06:20:36 +08:00
|
|
|
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-15 11:56:34 +08:00
|
|
|
dev_hold(dev);
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return dev;
|
|
|
|
|
|
|
|
failure:
|
|
|
|
unregister_netdevice(dev);
|
|
|
|
return NULL;
|
|
|
|
}
|
2015-11-21 22:57:26 +08:00
|
|
|
|
|
|
|
/* called with rcu_read_lock() */
|
|
|
|
static int __pim_rcv(struct mr_table *mrt, struct sk_buff *skb,
|
|
|
|
unsigned int pimlen)
|
|
|
|
{
|
|
|
|
struct net_device *reg_dev = NULL;
|
|
|
|
struct iphdr *encap;
|
2022-06-23 12:34:35 +08:00
|
|
|
int vif_num;
|
2015-11-21 22:57:26 +08:00
|
|
|
|
|
|
|
encap = (struct iphdr *)(skb_transport_header(skb) + pimlen);
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Check that:
|
2015-11-21 22:57:26 +08:00
|
|
|
* a. packet is really sent 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) + pimlen > skb->len)
|
|
|
|
return 1;
|
|
|
|
|
2022-06-23 12:34:35 +08:00
|
|
|
/* Pairs with WRITE_ONCE() in vif_add()/vid_delete() */
|
|
|
|
vif_num = READ_ONCE(mrt->mroute_reg_vif_num);
|
|
|
|
if (vif_num >= 0)
|
|
|
|
reg_dev = vif_dev_read(&mrt->vif_table[vif_num]);
|
2015-11-21 22:57:26 +08:00
|
|
|
if (!reg_dev)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
skb->mac_header = skb->network_header;
|
|
|
|
skb_pull(skb, (u8 *)encap - skb->data);
|
|
|
|
skb_reset_network_header(skb);
|
|
|
|
skb->protocol = htons(ETH_P_IP);
|
|
|
|
skb->ip_summed = CHECKSUM_NONE;
|
|
|
|
|
|
|
|
skb_tunnel_rx(skb, reg_dev, dev_net(reg_dev));
|
|
|
|
|
|
|
|
netif_rx(skb);
|
|
|
|
|
|
|
|
return NET_RX_SUCCESS;
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static struct net_device *ipmr_reg_vif(struct net *net, struct mr_table *mrt)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
#endif
|
|
|
|
|
2017-09-27 14:23:14 +08:00
|
|
|
static int call_ipmr_vif_entry_notifiers(struct net *net,
|
|
|
|
enum fib_event_type event_type,
|
|
|
|
struct vif_device *vif,
|
2022-06-23 12:34:32 +08:00
|
|
|
struct net_device *vif_dev,
|
2017-09-27 14:23:14 +08:00
|
|
|
vifi_t vif_index, u32 tb_id)
|
|
|
|
{
|
2018-03-26 20:01:31 +08:00
|
|
|
return mr_call_vif_notifiers(net, RTNL_FAMILY_IPMR, event_type,
|
2022-06-23 12:34:32 +08:00
|
|
|
vif, vif_dev, vif_index, tb_id,
|
2018-03-26 20:01:31 +08:00
|
|
|
&net->ipv4.ipmr_seq);
|
2017-09-27 14:23:14 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int call_ipmr_mfc_entry_notifiers(struct net *net,
|
|
|
|
enum fib_event_type event_type,
|
|
|
|
struct mfc_cache *mfc, u32 tb_id)
|
|
|
|
{
|
2018-03-26 20:01:32 +08:00
|
|
|
return mr_call_mfc_notifiers(net, RTNL_FAMILY_IPMR, event_type,
|
|
|
|
&mfc->_c, tb_id, &net->ipv4.ipmr_seq);
|
2017-09-27 14:23:14 +08:00
|
|
|
}
|
|
|
|
|
2012-07-10 18:55:09 +08:00
|
|
|
/**
|
|
|
|
* vif_delete - Delete a VIF entry
|
2020-07-13 07:15:02 +08:00
|
|
|
* @mrt: Table to delete from
|
|
|
|
* @vifi: VIF identifier to delete
|
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-15 11:56:34 +08:00
|
|
|
* @notify: Set to 1, if the caller is a notifier_call
|
2020-07-13 07:15:02 +08:00
|
|
|
* @head: if unregistering the VIF, place it on this queue
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2010-04-13 13:03:22 +08:00
|
|
|
static int vif_delete(struct mr_table *mrt, int vifi, int notify,
|
2009-10-28 13:21:38 +08:00
|
|
|
struct list_head *head)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2017-09-27 14:23:14 +08:00
|
|
|
struct net *net = read_pnet(&mrt->net);
|
2005-04-17 06:20:36 +08:00
|
|
|
struct vif_device *v;
|
|
|
|
struct net_device *dev;
|
|
|
|
struct in_device *in_dev;
|
|
|
|
|
2010-04-13 13:03:22 +08:00
|
|
|
if (vifi < 0 || vifi >= mrt->maxvif)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
|
2010-04-13 13:03:22 +08:00
|
|
|
v = &mrt->vif_table[vifi];
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2022-06-23 12:34:32 +08:00
|
|
|
dev = rtnl_dereference(v->dev);
|
|
|
|
if (!dev)
|
|
|
|
return -EADDRNOTAVAIL;
|
2017-09-27 14:23:14 +08:00
|
|
|
|
2022-06-23 12:34:48 +08:00
|
|
|
spin_lock(&mrt_lock);
|
2022-06-23 12:34:32 +08:00
|
|
|
call_ipmr_vif_entry_notifiers(net, FIB_EVENT_VIF_DEL, v, dev,
|
|
|
|
vifi, mrt->id);
|
|
|
|
RCU_INIT_POINTER(v->dev, NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2022-06-23 12:34:34 +08:00
|
|
|
if (vifi == mrt->mroute_reg_vif_num) {
|
|
|
|
/* Pairs with READ_ONCE() in ipmr_cache_report() and reg_vif_xmit() */
|
|
|
|
WRITE_ONCE(mrt->mroute_reg_vif_num, -1);
|
|
|
|
}
|
2010-10-02 00:15:29 +08:00
|
|
|
if (vifi + 1 == mrt->maxvif) {
|
2005-04-17 06:20:36 +08:00
|
|
|
int tmp;
|
2010-10-02 00:15:29 +08:00
|
|
|
|
|
|
|
for (tmp = vifi - 1; tmp >= 0; tmp--) {
|
2010-04-13 13:03:22 +08:00
|
|
|
if (VIF_EXISTS(mrt, tmp))
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
}
|
2022-06-23 12:34:37 +08:00
|
|
|
WRITE_ONCE(mrt->maxvif, tmp + 1);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2022-06-23 12:34:48 +08:00
|
|
|
spin_unlock(&mrt_lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
dev_set_allmulti(dev, -1);
|
|
|
|
|
2010-10-02 00:15:29 +08:00
|
|
|
in_dev = __in_dev_get_rtnl(dev);
|
|
|
|
if (in_dev) {
|
2007-06-05 14:34:44 +08:00
|
|
|
IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)--;
|
2017-03-29 05:28:02 +08:00
|
|
|
inet_netconf_notify_devconf(dev_net(dev), RTM_NEWNETCONF,
|
2012-12-04 09:13:35 +08:00
|
|
|
NETCONFA_MC_FORWARDING,
|
|
|
|
dev->ifindex, &in_dev->cnf);
|
2005-04-17 06:20:36 +08:00
|
|
|
ip_rt_multicast_event(in_dev);
|
|
|
|
}
|
|
|
|
|
2010-10-02 00:15:29 +08:00
|
|
|
if (v->flags & (VIFF_TUNNEL | VIFF_REGISTER) && !notify)
|
2009-10-28 13:21:38 +08:00
|
|
|
unregister_netdevice_queue(dev, head);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2022-06-08 12:39:55 +08:00
|
|
|
netdev_put(dev, &v->dev_tracker);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-02 00:15:08 +08:00
|
|
|
static void ipmr_cache_free_rcu(struct rcu_head *head)
|
2009-01-22 12:56:17 +08:00
|
|
|
{
|
2018-03-01 05:29:34 +08:00
|
|
|
struct mr_mfc *c = container_of(head, struct mr_mfc, rcu);
|
2010-10-02 00:15:08 +08:00
|
|
|
|
2018-03-01 05:29:34 +08:00
|
|
|
kmem_cache_free(mrt_cachep, (struct mfc_cache *)c);
|
2009-01-22 12:56:17 +08:00
|
|
|
}
|
|
|
|
|
2018-03-26 20:01:36 +08:00
|
|
|
static void ipmr_cache_free(struct mfc_cache *c)
|
2010-10-02 00:15:08 +08:00
|
|
|
{
|
2018-03-01 05:29:34 +08:00
|
|
|
call_rcu(&c->_c.rcu, ipmr_cache_free_rcu);
|
2010-10-02 00:15:08 +08:00
|
|
|
}
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Destroy an unresolved cache entry, killing queued skbs
|
2010-10-02 00:15:29 +08:00
|
|
|
* and reporting error to netlink readers.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2010-04-13 13:03:22 +08:00
|
|
|
static void ipmr_destroy_unres(struct mr_table *mrt, struct mfc_cache *c)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-04-15 19:29:28 +08:00
|
|
|
struct net *net = read_pnet(&mrt->net);
|
2005-04-17 06:20:36 +08:00
|
|
|
struct sk_buff *skb;
|
2005-06-29 03:55:30 +08:00
|
|
|
struct nlmsgerr *e;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-04-13 13:03:22 +08:00
|
|
|
atomic_dec(&mrt->cache_resolve_queue_len);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2018-03-01 05:29:34 +08:00
|
|
|
while ((skb = skb_dequeue(&c->_c.mfc_un.unres.unresolved))) {
|
2007-04-21 13:47:35 +08:00
|
|
|
if (ip_hdr(skb)->version == 0) {
|
networking: make skb_pull & friends return void pointers
It seems like a historic accident that these return unsigned char *,
and in many places that means casts are required, more often than not.
Make these functions return void * and remove all the casts across
the tree, adding a (u8 *) cast only where the unsigned char pointer
was used directly, all done with the following spatch:
@@
expression SKB, LEN;
typedef u8;
identifier fn = {
skb_pull,
__skb_pull,
skb_pull_inline,
__pskb_pull_tail,
__pskb_pull,
pskb_pull
};
@@
- *(fn(SKB, LEN))
+ *(u8 *)fn(SKB, LEN)
@@
expression E, SKB, LEN;
identifier fn = {
skb_pull,
__skb_pull,
skb_pull_inline,
__pskb_pull_tail,
__pskb_pull,
pskb_pull
};
type T;
@@
- E = ((T *)(fn(SKB, LEN)))
+ E = fn(SKB, LEN)
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-06-16 20:29:22 +08:00
|
|
|
struct nlmsghdr *nlh = skb_pull(skb,
|
|
|
|
sizeof(struct iphdr));
|
2005-04-17 06:20:36 +08:00
|
|
|
nlh->nlmsg_type = NLMSG_ERROR;
|
2013-03-27 14:47:04 +08:00
|
|
|
nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
|
2005-04-17 06:20:36 +08:00
|
|
|
skb_trim(skb, nlh->nlmsg_len);
|
2013-03-27 14:47:04 +08:00
|
|
|
e = nlmsg_data(nlh);
|
2005-06-29 03:55:30 +08:00
|
|
|
e->error = -ETIMEDOUT;
|
|
|
|
memset(&e->msg, 0, sizeof(e->msg));
|
2006-08-15 15:30:25 +08:00
|
|
|
|
2012-09-08 04:12:54 +08:00
|
|
|
rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
|
2010-10-02 00:15:29 +08:00
|
|
|
} else {
|
2005-04-17 06:20:36 +08:00
|
|
|
kfree_skb(skb);
|
2010-10-02 00:15:29 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2009-01-22 12:56:17 +08:00
|
|
|
ipmr_cache_free(c);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-04-13 13:03:19 +08:00
|
|
|
/* Timer process for the unresolved queue. */
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-17 05:43:17 +08:00
|
|
|
static void ipmr_expire_process(struct timer_list *t)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
treewide: setup_timer() -> timer_setup()
This converts all remaining cases of the old setup_timer() API into using
timer_setup(), where the callback argument is the structure already
holding the struct timer_list. These should have no behavioral changes,
since they just change which pointer is passed into the callback with
the same available pointers after conversion. It handles the following
examples, in addition to some other variations.
Casting from unsigned long:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
setup_timer(&ptr->my_timer, my_callback, ptr);
and forced object casts:
void my_callback(struct something *ptr)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, (unsigned long)ptr);
become:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
Direct function assignments:
void my_callback(unsigned long data)
{
struct something *ptr = (struct something *)data;
...
}
...
ptr->my_timer.function = my_callback;
have a temporary cast added, along with converting the args:
void my_callback(struct timer_list *t)
{
struct something *ptr = from_timer(ptr, t, my_timer);
...
}
...
ptr->my_timer.function = (TIMER_FUNC_TYPE)my_callback;
And finally, callbacks without a data assignment:
void my_callback(unsigned long data)
{
...
}
...
setup_timer(&ptr->my_timer, my_callback, 0);
have their argument renamed to verify they're unused during conversion:
void my_callback(struct timer_list *unused)
{
...
}
...
timer_setup(&ptr->my_timer, my_callback, 0);
The conversion is done with the following Coccinelle script:
spatch --very-quiet --all-includes --include-headers \
-I ./arch/x86/include -I ./arch/x86/include/generated \
-I ./include -I ./arch/x86/include/uapi \
-I ./arch/x86/include/generated/uapi -I ./include/uapi \
-I ./include/generated/uapi --include ./include/linux/kconfig.h \
--dir . \
--cocci-file ~/src/data/timer_setup.cocci
@fix_address_of@
expression e;
@@
setup_timer(
-&(e)
+&e
, ...)
// Update any raw setup_timer() usages that have a NULL callback, but
// would otherwise match change_timer_function_usage, since the latter
// will update all function assignments done in the face of a NULL
// function initialization in setup_timer().
@change_timer_function_usage_NULL@
expression _E;
identifier _timer;
type _cast_data;
@@
(
-setup_timer(&_E->_timer, NULL, _E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E->_timer, NULL, (_cast_data)_E);
+timer_setup(&_E->_timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, &_E);
+timer_setup(&_E._timer, NULL, 0);
|
-setup_timer(&_E._timer, NULL, (_cast_data)&_E);
+timer_setup(&_E._timer, NULL, 0);
)
@change_timer_function_usage@
expression _E;
identifier _timer;
struct timer_list _stl;
identifier _callback;
type _cast_func, _cast_data;
@@
(
-setup_timer(&_E->_timer, _callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, &_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, _E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, &_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)_E);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, (_cast_func)&_callback, (_cast_data)&_E);
+timer_setup(&_E._timer, _callback, 0);
|
_E->_timer@_stl.function = _callback;
|
_E->_timer@_stl.function = &_callback;
|
_E->_timer@_stl.function = (_cast_func)_callback;
|
_E->_timer@_stl.function = (_cast_func)&_callback;
|
_E._timer@_stl.function = _callback;
|
_E._timer@_stl.function = &_callback;
|
_E._timer@_stl.function = (_cast_func)_callback;
|
_E._timer@_stl.function = (_cast_func)&_callback;
)
// callback(unsigned long arg)
@change_callback_handle_cast
depends on change_timer_function_usage@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
identifier _handle;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
(
... when != _origarg
_handletype *_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(_handletype *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
|
... when != _origarg
_handletype *_handle;
... when != _handle
_handle =
-(void *)_origarg;
+from_timer(_handle, t, _timer);
... when != _origarg
)
}
// callback(unsigned long arg) without existing variable
@change_callback_handle_cast_no_arg
depends on change_timer_function_usage &&
!change_callback_handle_cast@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _origtype;
identifier _origarg;
type _handletype;
@@
void _callback(
-_origtype _origarg
+struct timer_list *t
)
{
+ _handletype *_origarg = from_timer(_origarg, t, _timer);
+
... when != _origarg
- (_handletype *)_origarg
+ _origarg
... when != _origarg
}
// Avoid already converted callbacks.
@match_callback_converted
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier t;
@@
void _callback(struct timer_list *t)
{ ... }
// callback(struct something *handle)
@change_callback_handle_arg
depends on change_timer_function_usage &&
!match_callback_converted &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
@@
void _callback(
-_handletype *_handle
+struct timer_list *t
)
{
+ _handletype *_handle = from_timer(_handle, t, _timer);
...
}
// If change_callback_handle_arg ran on an empty function, remove
// the added handler.
@unchange_callback_handle_arg
depends on change_timer_function_usage &&
change_callback_handle_arg@
identifier change_timer_function_usage._callback;
identifier change_timer_function_usage._timer;
type _handletype;
identifier _handle;
identifier t;
@@
void _callback(struct timer_list *t)
{
- _handletype *_handle = from_timer(_handle, t, _timer);
}
// We only want to refactor the setup_timer() data argument if we've found
// the matching callback. This undoes changes in change_timer_function_usage.
@unchange_timer_function_usage
depends on change_timer_function_usage &&
!change_callback_handle_cast &&
!change_callback_handle_cast_no_arg &&
!change_callback_handle_arg@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type change_timer_function_usage._cast_data;
@@
(
-timer_setup(&_E->_timer, _callback, 0);
+setup_timer(&_E->_timer, _callback, (_cast_data)_E);
|
-timer_setup(&_E._timer, _callback, 0);
+setup_timer(&_E._timer, _callback, (_cast_data)&_E);
)
// If we fixed a callback from a .function assignment, fix the
// assignment cast now.
@change_timer_function_assignment
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression change_timer_function_usage._E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_func;
typedef TIMER_FUNC_TYPE;
@@
(
_E->_timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E->_timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-&_callback;
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)_callback
+(TIMER_FUNC_TYPE)_callback
;
|
_E._timer.function =
-(_cast_func)&_callback
+(TIMER_FUNC_TYPE)_callback
;
)
// Sometimes timer functions are called directly. Replace matched args.
@change_timer_function_calls
depends on change_timer_function_usage &&
(change_callback_handle_cast ||
change_callback_handle_cast_no_arg ||
change_callback_handle_arg)@
expression _E;
identifier change_timer_function_usage._timer;
identifier change_timer_function_usage._callback;
type _cast_data;
@@
_callback(
(
-(_cast_data)_E
+&_E->_timer
|
-(_cast_data)&_E
+&_E._timer
|
-_E
+&_E->_timer
)
)
// If a timer has been configured without a data argument, it can be
// converted without regard to the callback argument, since it is unused.
@match_timer_function_unused_data@
expression _E;
identifier _timer;
identifier _callback;
@@
(
-setup_timer(&_E->_timer, _callback, 0);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0L);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E->_timer, _callback, 0UL);
+timer_setup(&_E->_timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0L);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_E._timer, _callback, 0UL);
+timer_setup(&_E._timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0L);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(&_timer, _callback, 0UL);
+timer_setup(&_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0L);
+timer_setup(_timer, _callback, 0);
|
-setup_timer(_timer, _callback, 0UL);
+timer_setup(_timer, _callback, 0);
)
@change_callback_unused_data
depends on match_timer_function_unused_data@
identifier match_timer_function_unused_data._callback;
type _origtype;
identifier _origarg;
@@
void _callback(
-_origtype _origarg
+struct timer_list *unused
)
{
... when != _origarg
}
Signed-off-by: Kees Cook <keescook@chromium.org>
2017-10-17 05:43:17 +08:00
|
|
|
struct mr_table *mrt = from_timer(mrt, t, ipmr_expire_timer);
|
2018-03-01 05:29:34 +08:00
|
|
|
struct mr_mfc *c, *next;
|
2005-04-17 06:20:36 +08:00
|
|
|
unsigned long expires;
|
2018-03-01 05:29:34 +08:00
|
|
|
unsigned long now;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (!spin_trylock(&mfc_unres_lock)) {
|
2010-04-13 13:03:22 +08:00
|
|
|
mod_timer(&mrt->ipmr_expire_timer, jiffies+HZ/10);
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-04-13 13:03:22 +08:00
|
|
|
if (list_empty(&mrt->mfc_unres_queue))
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out;
|
|
|
|
|
|
|
|
now = jiffies;
|
|
|
|
expires = 10*HZ;
|
|
|
|
|
2010-04-13 13:03:22 +08:00
|
|
|
list_for_each_entry_safe(c, next, &mrt->mfc_unres_queue, list) {
|
2005-04-17 06:20:36 +08: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-13 13:03:21 +08:00
|
|
|
list_del(&c->list);
|
2018-03-01 05:29:34 +08:00
|
|
|
mroute_netlink_event(mrt, (struct mfc_cache *)c, RTM_DELROUTE);
|
|
|
|
ipmr_destroy_unres(mrt, (struct mfc_cache *)c);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-04-13 13:03:22 +08:00
|
|
|
if (!list_empty(&mrt->mfc_unres_queue))
|
|
|
|
mod_timer(&mrt->ipmr_expire_timer, jiffies + expires);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
out:
|
|
|
|
spin_unlock(&mfc_unres_lock);
|
|
|
|
}
|
|
|
|
|
2022-06-23 12:34:48 +08:00
|
|
|
/* Fill oifs list. It is called under locked mrt_lock. */
|
2018-03-01 05:29:34 +08:00
|
|
|
static void ipmr_update_thresholds(struct mr_table *mrt, struct mr_mfc *cache,
|
2010-04-13 13:03:20 +08:00
|
|
|
unsigned char *ttls)
|
2005-04-17 06:20:36 +08: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-13 13:03:22 +08:00
|
|
|
for (vifi = 0; vifi < mrt->maxvif; vifi++) {
|
|
|
|
if (VIF_EXISTS(mrt, vifi) &&
|
2009-01-22 12:56:16 +08:00
|
|
|
ttls[vifi] && ttls[vifi] < 255) {
|
2005-04-17 06:20:36 +08: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;
|
|
|
|
}
|
|
|
|
}
|
2016-07-27 00:54:52 +08:00
|
|
|
cache->mfc_un.res.lastuse = jiffies;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-04-13 13:03:22 +08:00
|
|
|
static int vif_add(struct net *net, struct mr_table *mrt,
|
|
|
|
struct vifctl *vifc, int mrtsock)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2019-02-07 01:45:46 +08:00
|
|
|
struct netdev_phys_item_id ppid = { };
|
2005-04-17 06:20:36 +08:00
|
|
|
int vifi = vifc->vifc_vifi;
|
2010-04-13 13:03:22 +08:00
|
|
|
struct vif_device *v = &mrt->vif_table[vifi];
|
2005-04-17 06:20:36 +08:00
|
|
|
struct net_device *dev;
|
|
|
|
struct in_device *in_dev;
|
2008-07-15 11:55:26 +08:00
|
|
|
int err;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Is vif busy ? */
|
2010-04-13 13:03:22 +08:00
|
|
|
if (VIF_EXISTS(mrt, vifi))
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EADDRINUSE;
|
|
|
|
|
|
|
|
switch (vifc->vifc_flags) {
|
|
|
|
case VIFF_REGISTER:
|
2015-11-26 22:23:48 +08:00
|
|
|
if (!ipmr_pimsm_enabled())
|
2015-11-21 22:57:26 +08:00
|
|
|
return -EINVAL;
|
|
|
|
/* Special Purpose VIF in PIM
|
2005-04-17 06:20:36 +08:00
|
|
|
* All the packets will be sent to the daemon
|
|
|
|
*/
|
2010-04-13 13:03:22 +08:00
|
|
|
if (mrt->mroute_reg_vif_num >= 0)
|
2005-04-17 06:20:36 +08: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-13 13:03:23 +08:00
|
|
|
dev = ipmr_reg_vif(net, mrt);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!dev)
|
|
|
|
return -ENOBUFS;
|
2008-07-15 11:55:26 +08: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-15 11:56:34 +08:00
|
|
|
dev_put(dev);
|
2008-07-15 11:55:26 +08:00
|
|
|
return err;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
2007-02-09 22:24:47 +08:00
|
|
|
case VIFF_TUNNEL:
|
2009-01-22 12:56:23 +08:00
|
|
|
dev = ipmr_new_tunnel(net, vifc);
|
2020-05-19 21:03:12 +08:00
|
|
|
if (IS_ERR(dev))
|
|
|
|
return PTR_ERR(dev);
|
2005-04-17 06:20:36 +08: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-16 13:53:07 +08:00
|
|
|
case VIFF_USE_IFINDEX:
|
2005-04-17 06:20:36 +08: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-16 13:53:07 +08:00
|
|
|
if (vifc->vifc_flags == VIFF_USE_IFINDEX) {
|
|
|
|
dev = dev_get_by_index(net, vifc->vifc_lcl_ifindex);
|
2015-04-03 16:17:26 +08:00
|
|
|
if (dev && !__in_dev_get_rtnl(dev)) {
|
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-16 13:53:07 +08:00
|
|
|
dev_put(dev);
|
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
}
|
2010-10-02 00:15:29 +08: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-16 13:53:07 +08:00
|
|
|
dev = ip_dev_find(net, vifc->vifc_lcl_addr.s_addr);
|
2010-10-02 00:15:29 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!dev)
|
|
|
|
return -EADDRNOTAVAIL;
|
2008-07-15 11:55:26 +08: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-15 11:56:34 +08:00
|
|
|
if (err) {
|
|
|
|
dev_put(dev);
|
2008-07-15 11:55:26 +08: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-15 11:56:34 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2010-10-02 00:15:29 +08:00
|
|
|
in_dev = __in_dev_get_rtnl(dev);
|
|
|
|
if (!in_dev) {
|
2009-11-11 10:03:54 +08:00
|
|
|
dev_put(dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EADDRNOTAVAIL;
|
2009-11-11 10:03:54 +08:00
|
|
|
}
|
2007-06-05 14:34:44 +08:00
|
|
|
IPV4_DEVCONF(in_dev->cnf, MC_FORWARDING)++;
|
2017-03-29 05:28:02 +08:00
|
|
|
inet_netconf_notify_devconf(net, RTM_NEWNETCONF, NETCONFA_MC_FORWARDING,
|
|
|
|
dev->ifindex, &in_dev->cnf);
|
2005-04-17 06:20:36 +08:00
|
|
|
ip_rt_multicast_event(in_dev);
|
|
|
|
|
2010-10-02 00:15:29 +08:00
|
|
|
/* Fill in the VIF structures */
|
2018-03-01 05:29:29 +08:00
|
|
|
vif_device_init(v, dev, vifc->vifc_rate_limit,
|
|
|
|
vifc->vifc_threshold,
|
|
|
|
vifc->vifc_flags | (!mrtsock ? VIFF_STATIC : 0),
|
|
|
|
(VIFF_TUNNEL | VIFF_REGISTER));
|
2010-10-02 00:15:29 +08:00
|
|
|
|
2019-02-07 01:45:46 +08:00
|
|
|
err = dev_get_port_parent_id(dev, &ppid, true);
|
|
|
|
if (err == 0) {
|
|
|
|
memcpy(v->dev_parent_id.id, ppid.id, ppid.id_len);
|
|
|
|
v->dev_parent_id.id_len = ppid.id_len;
|
2017-10-03 15:58:07 +08:00
|
|
|
} else {
|
|
|
|
v->dev_parent_id.id_len = 0;
|
|
|
|
}
|
2018-03-01 05:29:29 +08:00
|
|
|
|
2008-11-03 16:28:02 +08:00
|
|
|
v->local = vifc->vifc_lcl_addr.s_addr;
|
|
|
|
v->remote = vifc->vifc_rmt_addr.s_addr;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* And finish update writing critical data */
|
2022-06-23 12:34:48 +08:00
|
|
|
spin_lock(&mrt_lock);
|
2022-06-23 12:34:32 +08:00
|
|
|
rcu_assign_pointer(v->dev, dev);
|
2021-12-05 12:22:16 +08:00
|
|
|
netdev_tracker_alloc(dev, &v->dev_tracker, GFP_ATOMIC);
|
2022-06-23 12:34:34 +08:00
|
|
|
if (v->flags & VIFF_REGISTER) {
|
|
|
|
/* Pairs with READ_ONCE() in ipmr_cache_report() and reg_vif_xmit() */
|
|
|
|
WRITE_ONCE(mrt->mroute_reg_vif_num, vifi);
|
|
|
|
}
|
2010-04-13 13:03:22 +08:00
|
|
|
if (vifi+1 > mrt->maxvif)
|
2022-06-23 12:34:37 +08:00
|
|
|
WRITE_ONCE(mrt->maxvif, vifi + 1);
|
2022-06-23 12:34:48 +08:00
|
|
|
spin_unlock(&mrt_lock);
|
2022-06-23 12:34:32 +08:00
|
|
|
call_ipmr_vif_entry_notifiers(net, FIB_EVENT_VIF_ADD, v, dev,
|
|
|
|
vifi, mrt->id);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-10-02 00:15:08 +08:00
|
|
|
/* called with rcu_read_lock() */
|
2010-04-13 13:03:22 +08:00
|
|
|
static struct mfc_cache *ipmr_cache_find(struct mr_table *mrt,
|
2009-01-22 12:56:23 +08:00
|
|
|
__be32 origin,
|
|
|
|
__be32 mcastgrp)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2017-01-12 22:53:33 +08:00
|
|
|
struct mfc_cache_cmp_arg arg = {
|
|
|
|
.mfc_mcastgrp = mcastgrp,
|
|
|
|
.mfc_origin = origin
|
|
|
|
};
|
2013-01-21 14:00:26 +08:00
|
|
|
|
2018-03-01 05:29:35 +08:00
|
|
|
return mr_mfc_find(mrt, &arg);
|
2013-01-21 14:00:26 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Look for a (*,G) entry */
|
|
|
|
static struct mfc_cache *ipmr_cache_find_any(struct mr_table *mrt,
|
|
|
|
__be32 mcastgrp, int vifi)
|
|
|
|
{
|
2017-01-12 22:53:33 +08:00
|
|
|
struct mfc_cache_cmp_arg arg = {
|
|
|
|
.mfc_mcastgrp = mcastgrp,
|
|
|
|
.mfc_origin = htonl(INADDR_ANY)
|
|
|
|
};
|
2013-01-21 14:00:26 +08:00
|
|
|
|
2013-01-22 18:18:03 +08:00
|
|
|
if (mcastgrp == htonl(INADDR_ANY))
|
2018-03-01 05:29:35 +08:00
|
|
|
return mr_mfc_find_any_parent(mrt, vifi);
|
|
|
|
return mr_mfc_find_any(mrt, vifi, &arg);
|
2013-01-21 14:00:26 +08:00
|
|
|
}
|
|
|
|
|
2017-01-12 22:53:33 +08:00
|
|
|
/* Look for a (S,G,iif) entry if parent != -1 */
|
|
|
|
static struct mfc_cache *ipmr_cache_find_parent(struct mr_table *mrt,
|
|
|
|
__be32 origin, __be32 mcastgrp,
|
|
|
|
int parent)
|
|
|
|
{
|
|
|
|
struct mfc_cache_cmp_arg arg = {
|
|
|
|
.mfc_mcastgrp = mcastgrp,
|
|
|
|
.mfc_origin = origin,
|
|
|
|
};
|
|
|
|
|
2018-03-01 05:29:35 +08:00
|
|
|
return mr_mfc_find_parent(mrt, &arg, parent);
|
2017-01-12 22:53:33 +08:00
|
|
|
}
|
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Allocate a multicast cache entry */
|
2010-04-13 13:03:20 +08:00
|
|
|
static struct mfc_cache *ipmr_cache_alloc(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-11-03 16:28:02 +08:00
|
|
|
struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_KERNEL);
|
2010-10-02 00:15:08 +08:00
|
|
|
|
2016-06-24 04:11:57 +08:00
|
|
|
if (c) {
|
2018-03-01 05:29:34 +08:00
|
|
|
c->_c.mfc_un.res.last_assert = jiffies - MFC_ASSERT_THRESH - 1;
|
|
|
|
c->_c.mfc_un.res.minvif = MAXVIFS;
|
2018-03-26 20:01:36 +08:00
|
|
|
c->_c.free = ipmr_cache_free_rcu;
|
2018-03-01 05:29:34 +08:00
|
|
|
refcount_set(&c->_c.mfc_un.res.refcount, 1);
|
2016-06-24 04:11:57 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
2010-04-13 13:03:20 +08:00
|
|
|
static struct mfc_cache *ipmr_cache_alloc_unres(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-11-03 16:28:02 +08:00
|
|
|
struct mfc_cache *c = kmem_cache_zalloc(mrt_cachep, GFP_ATOMIC);
|
2010-10-02 00:15:08 +08:00
|
|
|
|
|
|
|
if (c) {
|
2018-03-01 05:29:34 +08:00
|
|
|
skb_queue_head_init(&c->_c.mfc_un.unres.unresolved);
|
|
|
|
c->_c.mfc_un.unres.expires = jiffies + 10 * HZ;
|
2010-10-02 00:15:08 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
return c;
|
|
|
|
}
|
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* A cache entry has gone into a resolved state from queued */
|
2010-04-13 13:03:22 +08:00
|
|
|
static void ipmr_cache_resolve(struct net *net, struct mr_table *mrt,
|
|
|
|
struct mfc_cache *uc, struct mfc_cache *c)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct sk_buff *skb;
|
2005-06-29 03:55:30 +08:00
|
|
|
struct nlmsgerr *e;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-10-02 00:15:29 +08:00
|
|
|
/* Play the pending entries through our router */
|
2018-03-01 05:29:34 +08:00
|
|
|
while ((skb = __skb_dequeue(&uc->_c.mfc_un.unres.unresolved))) {
|
2007-04-21 13:47:35 +08:00
|
|
|
if (ip_hdr(skb)->version == 0) {
|
networking: make skb_pull & friends return void pointers
It seems like a historic accident that these return unsigned char *,
and in many places that means casts are required, more often than not.
Make these functions return void * and remove all the casts across
the tree, adding a (u8 *) cast only where the unsigned char pointer
was used directly, all done with the following spatch:
@@
expression SKB, LEN;
typedef u8;
identifier fn = {
skb_pull,
__skb_pull,
skb_pull_inline,
__pskb_pull_tail,
__pskb_pull,
pskb_pull
};
@@
- *(fn(SKB, LEN))
+ *(u8 *)fn(SKB, LEN)
@@
expression E, SKB, LEN;
identifier fn = {
skb_pull,
__skb_pull,
skb_pull_inline,
__pskb_pull_tail,
__pskb_pull,
pskb_pull
};
type T;
@@
- E = ((T *)(fn(SKB, LEN)))
+ E = fn(SKB, LEN)
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-06-16 20:29:22 +08:00
|
|
|
struct nlmsghdr *nlh = skb_pull(skb,
|
|
|
|
sizeof(struct iphdr));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2018-03-01 05:29:39 +08:00
|
|
|
if (mr_fill_mroute(mrt, skb, &c->_c,
|
|
|
|
nlmsg_data(nlh)) > 0) {
|
2010-10-02 00:15:29 +08:00
|
|
|
nlh->nlmsg_len = skb_tail_pointer(skb) -
|
|
|
|
(u8 *)nlh;
|
2005-04-17 06:20:36 +08:00
|
|
|
} else {
|
|
|
|
nlh->nlmsg_type = NLMSG_ERROR;
|
2013-03-27 14:47:04 +08:00
|
|
|
nlh->nlmsg_len = nlmsg_msg_size(sizeof(struct nlmsgerr));
|
2005-04-17 06:20:36 +08:00
|
|
|
skb_trim(skb, nlh->nlmsg_len);
|
2013-03-27 14:47:04 +08:00
|
|
|
e = nlmsg_data(nlh);
|
2005-06-29 03:55:30 +08:00
|
|
|
e->error = -EMSGSIZE;
|
|
|
|
memset(&e->msg, 0, sizeof(e->msg));
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-08-15 15:30:25 +08:00
|
|
|
|
2012-09-08 04:12:54 +08:00
|
|
|
rtnl_unicast(skb, net, NETLINK_CB(skb).portid);
|
2010-10-02 00:15:29 +08:00
|
|
|
} else {
|
ipmr: Always call ip{,6}_mr_forward() from RCU read-side critical section
These functions expect to be called from RCU read-side critical section,
but this only happens when invoked from the data path via
ip{,6}_mr_input(). They can also be invoked from process context in
response to user space adding a multicast route which resolves a cache
entry with queued packets [1][2].
Fix by adding missing rcu_read_lock() / rcu_read_unlock() in these call
paths.
[1]
WARNING: suspicious RCU usage
6.0.0-rc3-custom-15969-g049d233c8bcc-dirty #1387 Not tainted
-----------------------------
net/ipv4/ipmr.c:84 suspicious rcu_dereference_check() usage!
other info that might help us debug this:
rcu_scheduler_active = 2, debug_locks = 1
1 lock held by smcrouted/246:
#0: ffffffff862389b0 (rtnl_mutex){+.+.}-{3:3}, at: ip_mroute_setsockopt+0x11c/0x1420
stack backtrace:
CPU: 0 PID: 246 Comm: smcrouted Not tainted 6.0.0-rc3-custom-15969-g049d233c8bcc-dirty #1387
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.0-1.fc36 04/01/2014
Call Trace:
<TASK>
dump_stack_lvl+0x91/0xb9
vif_dev_read+0xbf/0xd0
ipmr_queue_xmit+0x135/0x1ab0
ip_mr_forward+0xe7b/0x13d0
ipmr_mfc_add+0x1a06/0x2ad0
ip_mroute_setsockopt+0x5c1/0x1420
do_ip_setsockopt+0x23d/0x37f0
ip_setsockopt+0x56/0x80
raw_setsockopt+0x219/0x290
__sys_setsockopt+0x236/0x4d0
__x64_sys_setsockopt+0xbe/0x160
do_syscall_64+0x34/0x80
entry_SYSCALL_64_after_hwframe+0x63/0xcd
[2]
WARNING: suspicious RCU usage
6.0.0-rc3-custom-15969-g049d233c8bcc-dirty #1387 Not tainted
-----------------------------
net/ipv6/ip6mr.c:69 suspicious rcu_dereference_check() usage!
other info that might help us debug this:
rcu_scheduler_active = 2, debug_locks = 1
1 lock held by smcrouted/246:
#0: ffffffff862389b0 (rtnl_mutex){+.+.}-{3:3}, at: ip6_mroute_setsockopt+0x6b9/0x2630
stack backtrace:
CPU: 1 PID: 246 Comm: smcrouted Not tainted 6.0.0-rc3-custom-15969-g049d233c8bcc-dirty #1387
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.0-1.fc36 04/01/2014
Call Trace:
<TASK>
dump_stack_lvl+0x91/0xb9
vif_dev_read+0xbf/0xd0
ip6mr_forward2.isra.0+0xc9/0x1160
ip6_mr_forward+0xef0/0x13f0
ip6mr_mfc_add+0x1ff2/0x31f0
ip6_mroute_setsockopt+0x1825/0x2630
do_ipv6_setsockopt+0x462/0x4440
ipv6_setsockopt+0x105/0x140
rawv6_setsockopt+0xd8/0x690
__sys_setsockopt+0x236/0x4d0
__x64_sys_setsockopt+0xbe/0x160
do_syscall_64+0x34/0x80
entry_SYSCALL_64_after_hwframe+0x63/0xcd
Fixes: ebc3197963fc ("ipmr: add rcu protection over (struct vif_device)->dev")
Signed-off-by: Ido Schimmel <idosch@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2022-09-14 15:53:38 +08:00
|
|
|
rcu_read_lock();
|
2017-06-11 04:30:17 +08:00
|
|
|
ip_mr_forward(net, mrt, skb->dev, skb, c, 0);
|
ipmr: Always call ip{,6}_mr_forward() from RCU read-side critical section
These functions expect to be called from RCU read-side critical section,
but this only happens when invoked from the data path via
ip{,6}_mr_input(). They can also be invoked from process context in
response to user space adding a multicast route which resolves a cache
entry with queued packets [1][2].
Fix by adding missing rcu_read_lock() / rcu_read_unlock() in these call
paths.
[1]
WARNING: suspicious RCU usage
6.0.0-rc3-custom-15969-g049d233c8bcc-dirty #1387 Not tainted
-----------------------------
net/ipv4/ipmr.c:84 suspicious rcu_dereference_check() usage!
other info that might help us debug this:
rcu_scheduler_active = 2, debug_locks = 1
1 lock held by smcrouted/246:
#0: ffffffff862389b0 (rtnl_mutex){+.+.}-{3:3}, at: ip_mroute_setsockopt+0x11c/0x1420
stack backtrace:
CPU: 0 PID: 246 Comm: smcrouted Not tainted 6.0.0-rc3-custom-15969-g049d233c8bcc-dirty #1387
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.0-1.fc36 04/01/2014
Call Trace:
<TASK>
dump_stack_lvl+0x91/0xb9
vif_dev_read+0xbf/0xd0
ipmr_queue_xmit+0x135/0x1ab0
ip_mr_forward+0xe7b/0x13d0
ipmr_mfc_add+0x1a06/0x2ad0
ip_mroute_setsockopt+0x5c1/0x1420
do_ip_setsockopt+0x23d/0x37f0
ip_setsockopt+0x56/0x80
raw_setsockopt+0x219/0x290
__sys_setsockopt+0x236/0x4d0
__x64_sys_setsockopt+0xbe/0x160
do_syscall_64+0x34/0x80
entry_SYSCALL_64_after_hwframe+0x63/0xcd
[2]
WARNING: suspicious RCU usage
6.0.0-rc3-custom-15969-g049d233c8bcc-dirty #1387 Not tainted
-----------------------------
net/ipv6/ip6mr.c:69 suspicious rcu_dereference_check() usage!
other info that might help us debug this:
rcu_scheduler_active = 2, debug_locks = 1
1 lock held by smcrouted/246:
#0: ffffffff862389b0 (rtnl_mutex){+.+.}-{3:3}, at: ip6_mroute_setsockopt+0x6b9/0x2630
stack backtrace:
CPU: 1 PID: 246 Comm: smcrouted Not tainted 6.0.0-rc3-custom-15969-g049d233c8bcc-dirty #1387
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.16.0-1.fc36 04/01/2014
Call Trace:
<TASK>
dump_stack_lvl+0x91/0xb9
vif_dev_read+0xbf/0xd0
ip6mr_forward2.isra.0+0xc9/0x1160
ip6_mr_forward+0xef0/0x13f0
ip6mr_mfc_add+0x1ff2/0x31f0
ip6_mroute_setsockopt+0x1825/0x2630
do_ipv6_setsockopt+0x462/0x4440
ipv6_setsockopt+0x105/0x140
rawv6_setsockopt+0xd8/0x690
__sys_setsockopt+0x236/0x4d0
__x64_sys_setsockopt+0xbe/0x160
do_syscall_64+0x34/0x80
entry_SYSCALL_64_after_hwframe+0x63/0xcd
Fixes: ebc3197963fc ("ipmr: add rcu protection over (struct vif_device)->dev")
Signed-off-by: Ido Schimmel <idosch@nvidia.com>
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2022-09-14 15:53:38 +08:00
|
|
|
rcu_read_unlock();
|
2010-10-02 00:15:29 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-06-21 04:54:17 +08:00
|
|
|
/* Bounce a cache query up to mrouted and netlink.
|
2005-04-17 06:20:36 +08:00
|
|
|
*
|
2022-06-23 12:34:34 +08:00
|
|
|
* Called under rcu_read_lock().
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2022-06-23 12:34:34 +08:00
|
|
|
static int ipmr_cache_report(const struct mr_table *mrt,
|
2009-01-22 12:56:23 +08:00
|
|
|
struct sk_buff *pkt, vifi_t vifi, int assert)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2007-03-13 07:09:15 +08:00
|
|
|
const int ihl = ip_hdrlen(pkt);
|
2015-11-21 22:57:26 +08:00
|
|
|
struct sock *mroute_sk;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct igmphdr *igmp;
|
|
|
|
struct igmpmsg *msg;
|
2015-11-21 22:57:26 +08:00
|
|
|
struct sk_buff *skb;
|
2005-04-17 06:20:36 +08:00
|
|
|
int ret;
|
|
|
|
|
2018-07-13 17:16:43 +08:00
|
|
|
if (assert == IGMPMSG_WHOLEPKT || assert == IGMPMSG_WRVIFWHOLE)
|
2005-04-17 06:20:36 +08:00
|
|
|
skb = skb_realloc_headroom(pkt, sizeof(struct iphdr));
|
|
|
|
else
|
|
|
|
skb = alloc_skb(128, GFP_ATOMIC);
|
|
|
|
|
2007-03-09 12:44:43 +08:00
|
|
|
if (!skb)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENOBUFS;
|
|
|
|
|
2018-07-13 17:16:43 +08:00
|
|
|
if (assert == IGMPMSG_WHOLEPKT || assert == IGMPMSG_WRVIFWHOLE) {
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Ugly, but we have no choice with this interface.
|
2010-10-02 00:15:29 +08: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-17 06:20:36 +08:00
|
|
|
*/
|
2007-03-12 09:38:29 +08:00
|
|
|
skb_push(skb, sizeof(struct iphdr));
|
|
|
|
skb_reset_network_header(skb);
|
2007-03-14 00:06:52 +08:00
|
|
|
skb_reset_transport_header(skb);
|
2007-03-13 07:05:39 +08:00
|
|
|
msg = (struct igmpmsg *)skb_network_header(skb);
|
2007-04-11 11:50:43 +08:00
|
|
|
memcpy(msg, skb_network_header(pkt), sizeof(struct iphdr));
|
2018-07-13 17:16:43 +08:00
|
|
|
msg->im_msgtype = assert;
|
2005-04-17 06:20:36 +08:00
|
|
|
msg->im_mbz = 0;
|
2020-09-08 06:04:07 +08:00
|
|
|
if (assert == IGMPMSG_WRVIFWHOLE) {
|
2018-07-13 17:16:43 +08:00
|
|
|
msg->im_vif = vifi;
|
2020-09-08 06:04:07 +08:00
|
|
|
msg->im_vif_hi = vifi >> 8;
|
|
|
|
} else {
|
2022-06-23 12:34:34 +08:00
|
|
|
/* Pairs with WRITE_ONCE() in vif_add() and vif_delete() */
|
|
|
|
int vif_num = READ_ONCE(mrt->mroute_reg_vif_num);
|
|
|
|
|
|
|
|
msg->im_vif = vif_num;
|
|
|
|
msg->im_vif_hi = vif_num >> 8;
|
2020-09-08 06:04:07 +08:00
|
|
|
}
|
2007-04-21 13:47:35 +08:00
|
|
|
ip_hdr(skb)->ihl = sizeof(struct iphdr) >> 2;
|
|
|
|
ip_hdr(skb)->tot_len = htons(ntohs(ip_hdr(pkt)->tot_len) +
|
|
|
|
sizeof(struct iphdr));
|
2015-11-21 22:57:26 +08:00
|
|
|
} else {
|
|
|
|
/* Copy the IP header */
|
|
|
|
skb_set_network_header(skb, skb->len);
|
|
|
|
skb_put(skb, ihl);
|
|
|
|
skb_copy_to_linear_data(skb, pkt->data, ihl);
|
|
|
|
/* Flag to the kernel this is a route add */
|
|
|
|
ip_hdr(skb)->protocol = 0;
|
|
|
|
msg = (struct igmpmsg *)skb_network_header(skb);
|
|
|
|
msg->im_vif = vifi;
|
2020-09-08 06:04:07 +08:00
|
|
|
msg->im_vif_hi = vifi >> 8;
|
2015-11-21 22:57:26 +08:00
|
|
|
skb_dst_set(skb, dst_clone(skb_dst(pkt)));
|
|
|
|
/* Add our header */
|
networking: make skb_put & friends return void pointers
It seems like a historic accident that these return unsigned char *,
and in many places that means casts are required, more often than not.
Make these functions (skb_put, __skb_put and pskb_put) return void *
and remove all the casts across the tree, adding a (u8 *) cast only
where the unsigned char pointer was used directly, all done with the
following spatch:
@@
expression SKB, LEN;
typedef u8;
identifier fn = { skb_put, __skb_put };
@@
- *(fn(SKB, LEN))
+ *(u8 *)fn(SKB, LEN)
@@
expression E, SKB, LEN;
identifier fn = { skb_put, __skb_put };
type T;
@@
- E = ((T *)(fn(SKB, LEN)))
+ E = fn(SKB, LEN)
which actually doesn't cover pskb_put since there are only three
users overall.
A handful of stragglers were converted manually, notably a macro in
drivers/isdn/i4l/isdn_bsdcomp.c and, oddly enough, one of the many
instances in net/bluetooth/hci_sock.c. In the former file, I also
had to fix one whitespace problem spatch introduced.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2017-06-16 20:29:21 +08:00
|
|
|
igmp = skb_put(skb, sizeof(struct igmphdr));
|
2015-11-21 22:57:26 +08:00
|
|
|
igmp->type = assert;
|
|
|
|
msg->im_msgtype = assert;
|
|
|
|
igmp->code = 0;
|
|
|
|
ip_hdr(skb)->tot_len = htons(skb->len); /* Fix the length */
|
|
|
|
skb->transport_header = skb->network_header;
|
2007-02-09 22:24:47 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-10-02 00:15:01 +08:00
|
|
|
mroute_sk = rcu_dereference(mrt->mroute_sk);
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!mroute_sk) {
|
2005-04-17 06:20:36 +08:00
|
|
|
kfree_skb(skb);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2017-06-21 04:54:17 +08:00
|
|
|
igmpmsg_netlink_event(mrt, skb);
|
|
|
|
|
2010-10-02 00:15:29 +08:00
|
|
|
/* Deliver to mrouted */
|
2010-10-02 00:15:01 +08:00
|
|
|
ret = sock_queue_rcv_skb(mroute_sk, skb);
|
2022-06-23 12:34:34 +08:00
|
|
|
|
2009-01-22 12:56:15 +08:00
|
|
|
if (ret < 0) {
|
2012-05-14 05:56:26 +08:00
|
|
|
net_warn_ratelimited("mroute: pending queue full, dropping entries\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Queue a packet for resolution. It gets locked cache entry! */
|
2022-06-23 12:34:34 +08:00
|
|
|
/* Called under rcu_read_lock() */
|
2015-11-21 22:57:27 +08:00
|
|
|
static int ipmr_cache_unresolved(struct mr_table *mrt, vifi_t vifi,
|
2017-06-11 04:30:17 +08:00
|
|
|
struct sk_buff *skb, struct net_device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2017-01-12 22:53:33 +08:00
|
|
|
const struct iphdr *iph = ip_hdr(skb);
|
|
|
|
struct mfc_cache *c;
|
2010-04-13 13:03:21 +08:00
|
|
|
bool found = false;
|
2005-04-17 06:20:36 +08:00
|
|
|
int err;
|
|
|
|
|
|
|
|
spin_lock_bh(&mfc_unres_lock);
|
2018-03-01 05:29:34 +08:00
|
|
|
list_for_each_entry(c, &mrt->mfc_unres_queue, _c.list) {
|
2010-04-13 13:03:19 +08:00
|
|
|
if (c->mfc_mcastgrp == iph->daddr &&
|
2010-04-13 13:03:21 +08:00
|
|
|
c->mfc_origin == iph->saddr) {
|
|
|
|
found = true;
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
2010-04-13 13:03:21 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-04-13 13:03:21 +08:00
|
|
|
if (!found) {
|
2010-10-02 00:15:29 +08:00
|
|
|
/* Create a new entry if allowable */
|
ipmr: remove hard code cache_resolve_queue_len limit
This is a re-post of previous patch wrote by David Miller[1].
Phil Karn reported[2] that on busy networks with lots of unresolved
multicast routing entries, the creation of new multicast group routes
can be extremely slow and unreliable.
The reason is we hard-coded multicast route entries with unresolved source
addresses(cache_resolve_queue_len) to 10. If some multicast route never
resolves and the unresolved source addresses increased, there will
be no ability to create new multicast route cache.
To resolve this issue, we need either add a sysctl entry to make the
cache_resolve_queue_len configurable, or just remove cache_resolve_queue_len
limit directly, as we already have the socket receive queue limits of mrouted
socket, pointed by David.
>From my side, I'd perfer to remove the cache_resolve_queue_len limit instead
of creating two more(IPv4 and IPv6 version) sysctl entry.
[1] https://lkml.org/lkml/2018/7/22/11
[2] https://lkml.org/lkml/2018/7/21/343
v3: instead of remove cache_resolve_queue_len totally, let's only remove
the hard code limit when allocate the unresolved cache, as Eric Dumazet
suggested, so we don't need to re-count it in other places.
v2: hold the mfc_unres_lock while walking the unresolved list in
queue_count(), as Nikolay Aleksandrov remind.
Reported-by: Phil Karn <karn@ka9q.net>
Signed-off-by: Hangbin Liu <liuhangbin@gmail.com>
Reviewed-by: Nikolay Aleksandrov <nikolay@cumulusnetworks.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-09-06 15:36:01 +08:00
|
|
|
c = ipmr_cache_alloc_unres();
|
|
|
|
if (!c) {
|
2005-04-17 06:20:36 +08:00
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
return -ENOBUFS;
|
|
|
|
}
|
|
|
|
|
2010-10-02 00:15:29 +08:00
|
|
|
/* Fill in the new cache entry */
|
2018-03-01 05:29:34 +08:00
|
|
|
c->_c.mfc_parent = -1;
|
2007-04-21 13:47:35 +08:00
|
|
|
c->mfc_origin = iph->saddr;
|
|
|
|
c->mfc_mcastgrp = iph->daddr;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-10-02 00:15:29 +08:00
|
|
|
/* Reflect first query at mrouted. */
|
2010-04-13 13:03:22 +08:00
|
|
|
err = ipmr_cache_report(mrt, skb, vifi, IGMPMSG_NOCACHE);
|
2018-03-01 05:29:34 +08:00
|
|
|
|
2009-01-22 12:56:23 +08:00
|
|
|
if (err < 0) {
|
2007-02-09 22:24:47 +08:00
|
|
|
/* If the report failed throw the cache entry
|
2005-04-17 06:20:36 +08:00
|
|
|
out - Brad Parker
|
|
|
|
*/
|
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
|
2009-01-22 12:56:17 +08:00
|
|
|
ipmr_cache_free(c);
|
2005-04-17 06:20:36 +08:00
|
|
|
kfree_skb(skb);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-04-13 13:03:22 +08:00
|
|
|
atomic_inc(&mrt->cache_resolve_queue_len);
|
2018-03-01 05:29:34 +08:00
|
|
|
list_add(&c->_c.list, &mrt->mfc_unres_queue);
|
2012-12-04 09:13:40 +08:00
|
|
|
mroute_netlink_event(mrt, c, RTM_NEWROUTE);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-05-12 15:05:35 +08:00
|
|
|
if (atomic_read(&mrt->cache_resolve_queue_len) == 1)
|
2018-03-01 05:29:34 +08:00
|
|
|
mod_timer(&mrt->ipmr_expire_timer,
|
|
|
|
c->_c.mfc_un.unres.expires);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-10-02 00:15:29 +08:00
|
|
|
/* See if we can append the packet */
|
2018-03-01 05:29:34 +08:00
|
|
|
if (c->_c.mfc_un.unres.unresolved.qlen > 3) {
|
2005-04-17 06:20:36 +08:00
|
|
|
kfree_skb(skb);
|
|
|
|
err = -ENOBUFS;
|
|
|
|
} else {
|
2017-06-11 04:30:17 +08:00
|
|
|
if (dev) {
|
|
|
|
skb->dev = dev;
|
|
|
|
skb->skb_iif = dev->ifindex;
|
|
|
|
}
|
2018-03-01 05:29:34 +08:00
|
|
|
skb_queue_tail(&c->_c.mfc_un.unres.unresolved, skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
err = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* MFC cache manipulation by user space mroute daemon */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-01-21 14:00:26 +08:00
|
|
|
static int ipmr_mfc_delete(struct mr_table *mrt, struct mfcctl *mfc, int parent)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2017-09-27 14:23:14 +08:00
|
|
|
struct net *net = read_pnet(&mrt->net);
|
2017-01-12 22:53:33 +08:00
|
|
|
struct mfc_cache *c;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-01-12 22:53:33 +08:00
|
|
|
/* The entries are added/deleted only under RTNL */
|
|
|
|
rcu_read_lock();
|
|
|
|
c = ipmr_cache_find_parent(mrt, mfc->mfcc_origin.s_addr,
|
|
|
|
mfc->mfcc_mcastgrp.s_addr, parent);
|
|
|
|
rcu_read_unlock();
|
|
|
|
if (!c)
|
|
|
|
return -ENOENT;
|
2018-03-01 05:29:34 +08:00
|
|
|
rhltable_remove(&mrt->mfc_hash, &c->_c.mnode, ipmr_rht_params);
|
|
|
|
list_del_rcu(&c->_c.list);
|
2017-09-27 14:23:14 +08:00
|
|
|
call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_DEL, c, mrt->id);
|
2017-01-12 22:53:33 +08:00
|
|
|
mroute_netlink_event(mrt, c, RTM_DELROUTE);
|
2018-03-26 20:01:36 +08:00
|
|
|
mr_cache_put(&c->_c);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2017-01-12 22:53:33 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-04-13 13:03:22 +08:00
|
|
|
static int ipmr_mfc_add(struct net *net, struct mr_table *mrt,
|
2013-01-21 14:00:26 +08:00
|
|
|
struct mfcctl *mfc, int mrtsock, int parent)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-04-13 13:03:21 +08:00
|
|
|
struct mfc_cache *uc, *c;
|
2018-03-01 05:29:34 +08:00
|
|
|
struct mr_mfc *_uc;
|
2017-01-12 22:53:33 +08:00
|
|
|
bool found;
|
|
|
|
int ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-03-17 14:04:14 +08:00
|
|
|
if (mfc->mfcc_parent >= MAXVIFS)
|
|
|
|
return -ENFILE;
|
|
|
|
|
2017-01-12 22:53:33 +08:00
|
|
|
/* The entries are added/deleted only under RTNL */
|
|
|
|
rcu_read_lock();
|
|
|
|
c = ipmr_cache_find_parent(mrt, mfc->mfcc_origin.s_addr,
|
|
|
|
mfc->mfcc_mcastgrp.s_addr, parent);
|
|
|
|
rcu_read_unlock();
|
|
|
|
if (c) {
|
2022-06-23 12:34:48 +08:00
|
|
|
spin_lock(&mrt_lock);
|
2018-03-01 05:29:34 +08:00
|
|
|
c->_c.mfc_parent = mfc->mfcc_parent;
|
|
|
|
ipmr_update_thresholds(mrt, &c->_c, mfc->mfcc_ttls);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!mrtsock)
|
2018-03-01 05:29:34 +08:00
|
|
|
c->_c.mfc_flags |= MFC_STATIC;
|
2022-06-23 12:34:48 +08:00
|
|
|
spin_unlock(&mrt_lock);
|
2017-09-27 14:23:14 +08:00
|
|
|
call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_REPLACE, c,
|
|
|
|
mrt->id);
|
2012-12-04 09:13:40 +08:00
|
|
|
mroute_netlink_event(mrt, c, RTM_NEWROUTE);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-01-22 18:18:03 +08:00
|
|
|
if (mfc->mfcc_mcastgrp.s_addr != htonl(INADDR_ANY) &&
|
2013-01-21 14:00:26 +08:00
|
|
|
!ipv4_is_multicast(mfc->mfcc_mcastgrp.s_addr))
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EINVAL;
|
|
|
|
|
2010-04-13 13:03:20 +08:00
|
|
|
c = ipmr_cache_alloc();
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!c)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2008-11-03 16:28:02 +08:00
|
|
|
c->mfc_origin = mfc->mfcc_origin.s_addr;
|
|
|
|
c->mfc_mcastgrp = mfc->mfcc_mcastgrp.s_addr;
|
2018-03-01 05:29:34 +08:00
|
|
|
c->_c.mfc_parent = mfc->mfcc_parent;
|
|
|
|
ipmr_update_thresholds(mrt, &c->_c, mfc->mfcc_ttls);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!mrtsock)
|
2018-03-01 05:29:34 +08:00
|
|
|
c->_c.mfc_flags |= MFC_STATIC;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2018-03-01 05:29:34 +08:00
|
|
|
ret = rhltable_insert_key(&mrt->mfc_hash, &c->cmparg, &c->_c.mnode,
|
2017-01-12 22:53:33 +08:00
|
|
|
ipmr_rht_params);
|
|
|
|
if (ret) {
|
|
|
|
pr_err("ipmr: rhtable insert error %d\n", ret);
|
|
|
|
ipmr_cache_free(c);
|
|
|
|
return ret;
|
|
|
|
}
|
2018-03-01 05:29:34 +08:00
|
|
|
list_add_tail_rcu(&c->_c.list, &mrt->mfc_cache_list);
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Check to see if we resolved a queued list. If so we
|
|
|
|
* need to send on the frames and tidy up.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2010-04-15 19:29:28 +08:00
|
|
|
found = false;
|
2005-04-17 06:20:36 +08:00
|
|
|
spin_lock_bh(&mfc_unres_lock);
|
2018-03-01 05:29:34 +08:00
|
|
|
list_for_each_entry(_uc, &mrt->mfc_unres_queue, list) {
|
|
|
|
uc = (struct mfc_cache *)_uc;
|
2010-04-13 13:03:19 +08:00
|
|
|
if (uc->mfc_origin == c->mfc_origin &&
|
2005-04-17 06:20:36 +08:00
|
|
|
uc->mfc_mcastgrp == c->mfc_mcastgrp) {
|
2018-03-01 05:29:34 +08:00
|
|
|
list_del(&_uc->list);
|
2010-04-13 13:03:22 +08:00
|
|
|
atomic_dec(&mrt->cache_resolve_queue_len);
|
2010-04-15 19:29:28 +08:00
|
|
|
found = true;
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-04-13 13:03:22 +08:00
|
|
|
if (list_empty(&mrt->mfc_unres_queue))
|
|
|
|
del_timer(&mrt->ipmr_expire_timer);
|
2005-04-17 06:20:36 +08:00
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
|
|
|
|
2010-04-15 19:29:28 +08:00
|
|
|
if (found) {
|
2010-04-13 13:03:22 +08:00
|
|
|
ipmr_cache_resolve(net, mrt, uc, c);
|
2009-01-22 12:56:17 +08:00
|
|
|
ipmr_cache_free(uc);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2017-09-27 14:23:14 +08:00
|
|
|
call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_ADD, c, mrt->id);
|
2012-12-04 09:13:40 +08:00
|
|
|
mroute_netlink_event(mrt, c, RTM_NEWROUTE);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Close the multicast socket, and clear the vif tables etc */
|
2019-02-18 05:07:52 +08:00
|
|
|
static void mroute_clean_tables(struct mr_table *mrt, int flags)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2017-09-27 14:23:14 +08:00
|
|
|
struct net *net = read_pnet(&mrt->net);
|
2018-03-01 05:29:34 +08:00
|
|
|
struct mr_mfc *c, *tmp;
|
|
|
|
struct mfc_cache *cache;
|
2009-10-28 13:21:38 +08:00
|
|
|
LIST_HEAD(list);
|
2017-01-12 22:53:33 +08:00
|
|
|
int i;
|
2007-02-09 22:24:47 +08:00
|
|
|
|
2010-10-02 00:15:29 +08:00
|
|
|
/* Shut down all active vif entries */
|
2019-02-18 05:07:52 +08:00
|
|
|
if (flags & (MRT_FLUSH_VIFS | MRT_FLUSH_VIFS_STATIC)) {
|
|
|
|
for (i = 0; i < mrt->maxvif; i++) {
|
|
|
|
if (((mrt->vif_table[i].flags & VIFF_STATIC) &&
|
|
|
|
!(flags & MRT_FLUSH_VIFS_STATIC)) ||
|
|
|
|
(!(mrt->vif_table[i].flags & VIFF_STATIC) && !(flags & MRT_FLUSH_VIFS)))
|
|
|
|
continue;
|
|
|
|
vif_delete(mrt, i, 0, &list);
|
|
|
|
}
|
|
|
|
unregister_netdevice_many(&list);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-10-02 00:15:29 +08:00
|
|
|
/* Wipe the cache */
|
2019-02-18 05:07:52 +08:00
|
|
|
if (flags & (MRT_FLUSH_MFC | MRT_FLUSH_MFC_STATIC)) {
|
|
|
|
list_for_each_entry_safe(c, tmp, &mrt->mfc_cache_list, list) {
|
|
|
|
if (((c->mfc_flags & MFC_STATIC) && !(flags & MRT_FLUSH_MFC_STATIC)) ||
|
|
|
|
(!(c->mfc_flags & MFC_STATIC) && !(flags & MRT_FLUSH_MFC)))
|
|
|
|
continue;
|
|
|
|
rhltable_remove(&mrt->mfc_hash, &c->mnode, ipmr_rht_params);
|
|
|
|
list_del_rcu(&c->list);
|
2018-03-01 05:29:34 +08:00
|
|
|
cache = (struct mfc_cache *)c;
|
2019-02-18 05:07:52 +08:00
|
|
|
call_ipmr_mfc_entry_notifiers(net, FIB_EVENT_ENTRY_DEL, cache,
|
|
|
|
mrt->id);
|
2018-03-01 05:29:34 +08:00
|
|
|
mroute_netlink_event(mrt, cache, RTM_DELROUTE);
|
2019-02-18 05:07:52 +08:00
|
|
|
mr_cache_put(c);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flags & MRT_FLUSH_MFC) {
|
|
|
|
if (atomic_read(&mrt->cache_resolve_queue_len) != 0) {
|
|
|
|
spin_lock_bh(&mfc_unres_lock);
|
|
|
|
list_for_each_entry_safe(c, tmp, &mrt->mfc_unres_queue, list) {
|
|
|
|
list_del(&c->list);
|
|
|
|
cache = (struct mfc_cache *)c;
|
|
|
|
mroute_netlink_event(mrt, cache, RTM_DELROUTE);
|
|
|
|
ipmr_destroy_unres(mrt, cache);
|
|
|
|
}
|
|
|
|
spin_unlock_bh(&mfc_unres_lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-10-02 00:15:01 +08:00
|
|
|
/* called from ip_ra_control(), before an RCU grace period,
|
2021-06-07 23:01:09 +08:00
|
|
|
* we don't need to call synchronize_rcu() here
|
2010-10-02 00:15:01 +08:00
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
static void mrtsock_destruct(struct sock *sk)
|
|
|
|
{
|
2009-01-22 12:56:23 +08: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-13 13:03:23 +08:00
|
|
|
struct mr_table *mrt;
|
2009-01-22 12:56:23 +08:00
|
|
|
|
2018-03-22 17:45:22 +08: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-13 13:03:23 +08:00
|
|
|
ipmr_for_each_table(mrt, net) {
|
2010-10-02 00:15:01 +08: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-13 13:03:23 +08:00
|
|
|
IPV4_DEVCONF_ALL(net, MC_FORWARDING)--;
|
2017-03-29 05:28:02 +08:00
|
|
|
inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
|
|
|
|
NETCONFA_MC_FORWARDING,
|
2012-12-04 09:13:35 +08:00
|
|
|
NETCONFA_IFINDEX_ALL,
|
|
|
|
net->ipv4.devconf_all);
|
2011-08-02 00:19:00 +08:00
|
|
|
RCU_INIT_POINTER(mrt->mroute_sk, NULL);
|
2019-02-18 05:07:52 +08:00
|
|
|
mroute_clean_tables(mrt, MRT_FLUSH_VIFS | MRT_FLUSH_MFC);
|
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-13 13:03:23 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2018-03-22 17:45:22 +08:00
|
|
|
rtnl_unlock();
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* 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.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2007-02-09 22:24:47 +08:00
|
|
|
|
2020-07-23 14:08:56 +08:00
|
|
|
int ip_mroute_setsockopt(struct sock *sk, int optname, sockptr_t optval,
|
2015-11-21 22:57:31 +08:00
|
|
|
unsigned int optlen)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-01-22 12:56:23 +08:00
|
|
|
struct net *net = sock_net(sk);
|
2015-11-21 22:57:31 +08:00
|
|
|
int val, ret = 0, parent = 0;
|
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-13 13:03:23 +08:00
|
|
|
struct mr_table *mrt;
|
2015-11-21 22:57:31 +08:00
|
|
|
struct vifctl vif;
|
|
|
|
struct mfcctl mfc;
|
2018-07-13 17:16:43 +08:00
|
|
|
bool do_wrvifwhole;
|
2015-11-21 22:57:31 +08:00
|
|
|
u32 uval;
|
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-13 13:03:23 +08:00
|
|
|
|
2015-11-21 22:57:31 +08:00
|
|
|
/* There's one exception to the lock - MRT_DONE which needs to unlock */
|
|
|
|
rtnl_lock();
|
2012-11-25 14:41:45 +08:00
|
|
|
if (sk->sk_type != SOCK_RAW ||
|
2015-11-21 22:57:31 +08:00
|
|
|
inet_sk(sk)->inet_num != IPPROTO_IGMP) {
|
|
|
|
ret = -EOPNOTSUPP;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2012-11-25 14:41:45 +08: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-13 13:03:23 +08:00
|
|
|
mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
|
2015-11-21 22:57:31 +08:00
|
|
|
if (!mrt) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2007-03-09 12:44:43 +08:00
|
|
|
if (optname != MRT_INIT) {
|
2011-08-12 03:30:52 +08:00
|
|
|
if (sk != rcu_access_pointer(mrt->mroute_sk) &&
|
2015-11-21 22:57:31 +08:00
|
|
|
!ns_capable(net->user_ns, CAP_NET_ADMIN)) {
|
|
|
|
ret = -EACCES;
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2007-03-09 12:44:43 +08:00
|
|
|
switch (optname) {
|
|
|
|
case MRT_INIT:
|
2015-11-26 22:23:49 +08:00
|
|
|
if (optlen != sizeof(int)) {
|
2015-11-21 22:57:31 +08:00
|
|
|
ret = -EINVAL;
|
2015-11-26 22:23:49 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (rtnl_dereference(mrt->mroute_sk)) {
|
2015-11-21 22:57:31 +08:00
|
|
|
ret = -EADDRINUSE;
|
|
|
|
break;
|
2015-11-26 22:23:49 +08:00
|
|
|
}
|
2007-03-09 12:44:43 +08:00
|
|
|
|
|
|
|
ret = ip_ra_control(sk, 1, mrtsock_destruct);
|
|
|
|
if (ret == 0) {
|
2012-01-12 12:41:32 +08:00
|
|
|
rcu_assign_pointer(mrt->mroute_sk, sk);
|
2009-01-22 12:56:23 +08:00
|
|
|
IPV4_DEVCONF_ALL(net, MC_FORWARDING)++;
|
2017-03-29 05:28:02 +08:00
|
|
|
inet_netconf_notify_devconf(net, RTM_NEWNETCONF,
|
|
|
|
NETCONFA_MC_FORWARDING,
|
2012-12-04 09:13:35 +08:00
|
|
|
NETCONFA_IFINDEX_ALL,
|
|
|
|
net->ipv4.devconf_all);
|
2007-03-09 12:44:43 +08:00
|
|
|
}
|
2015-11-21 22:57:31 +08:00
|
|
|
break;
|
2007-03-09 12:44:43 +08:00
|
|
|
case MRT_DONE:
|
2015-11-21 22:57:31 +08:00
|
|
|
if (sk != rcu_access_pointer(mrt->mroute_sk)) {
|
|
|
|
ret = -EACCES;
|
|
|
|
} else {
|
2018-03-22 17:45:22 +08:00
|
|
|
/* We need to unlock here because mrtsock_destruct takes
|
|
|
|
* care of rtnl itself and we can't change that due to
|
|
|
|
* the IP_ROUTER_ALERT setsockopt which runs without it.
|
|
|
|
*/
|
|
|
|
rtnl_unlock();
|
2015-11-21 22:57:31 +08:00
|
|
|
ret = ip_ra_control(sk, 0, NULL);
|
2018-03-22 17:45:22 +08:00
|
|
|
goto out;
|
2015-11-21 22:57:31 +08:00
|
|
|
}
|
|
|
|
break;
|
2007-03-09 12:44:43 +08:00
|
|
|
case MRT_ADD_VIF:
|
|
|
|
case MRT_DEL_VIF:
|
2015-11-21 22:57:31 +08:00
|
|
|
if (optlen != sizeof(vif)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2020-07-23 14:08:56 +08:00
|
|
|
if (copy_from_sockptr(&vif, optval, sizeof(vif))) {
|
2015-11-21 22:57:31 +08:00
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (vif.vifc_vifi >= MAXVIFS) {
|
|
|
|
ret = -ENFILE;
|
|
|
|
break;
|
|
|
|
}
|
2008-11-03 16:28:02 +08:00
|
|
|
if (optname == MRT_ADD_VIF) {
|
2010-10-02 00:15:01 +08:00
|
|
|
ret = vif_add(net, mrt, &vif,
|
|
|
|
sk == rtnl_dereference(mrt->mroute_sk));
|
2007-03-09 12:44:43 +08:00
|
|
|
} else {
|
2010-04-13 13:03:22 +08:00
|
|
|
ret = vif_delete(mrt, vif.vifc_vifi, 0, NULL);
|
2007-03-09 12:44:43 +08:00
|
|
|
}
|
2015-11-21 22:57:31 +08:00
|
|
|
break;
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Manipulate the forwarding caches. These live
|
|
|
|
* in a sort of kernel/user symbiosis.
|
|
|
|
*/
|
2007-03-09 12:44:43 +08:00
|
|
|
case MRT_ADD_MFC:
|
|
|
|
case MRT_DEL_MFC:
|
2013-01-21 14:00:26 +08:00
|
|
|
parent = -1;
|
2020-03-13 06:50:22 +08:00
|
|
|
fallthrough;
|
2013-01-21 14:00:26 +08:00
|
|
|
case MRT_ADD_MFC_PROXY:
|
|
|
|
case MRT_DEL_MFC_PROXY:
|
2015-11-21 22:57:31 +08:00
|
|
|
if (optlen != sizeof(mfc)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2020-07-27 15:18:34 +08:00
|
|
|
if (copy_from_sockptr(&mfc, optval, sizeof(mfc))) {
|
2015-11-21 22:57:31 +08:00
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
2013-01-21 14:00:26 +08:00
|
|
|
if (parent == 0)
|
|
|
|
parent = mfc.mfcc_parent;
|
|
|
|
if (optname == MRT_DEL_MFC || optname == MRT_DEL_MFC_PROXY)
|
|
|
|
ret = ipmr_mfc_delete(mrt, &mfc, parent);
|
2007-03-09 12:44:43 +08:00
|
|
|
else
|
2010-10-02 00:15:01 +08:00
|
|
|
ret = ipmr_mfc_add(net, mrt, &mfc,
|
2013-01-21 14:00:26 +08:00
|
|
|
sk == rtnl_dereference(mrt->mroute_sk),
|
|
|
|
parent);
|
2015-11-21 22:57:31 +08:00
|
|
|
break;
|
2019-02-18 05:07:52 +08:00
|
|
|
case MRT_FLUSH:
|
|
|
|
if (optlen != sizeof(val)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2020-07-23 14:08:56 +08:00
|
|
|
if (copy_from_sockptr(&val, optval, sizeof(val))) {
|
2019-02-18 05:07:52 +08:00
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mroute_clean_tables(mrt, val);
|
|
|
|
break;
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Control PIM assert. */
|
2007-03-09 12:44:43 +08:00
|
|
|
case MRT_ASSERT:
|
2015-11-21 22:57:31 +08:00
|
|
|
if (optlen != sizeof(val)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2020-07-23 14:08:56 +08:00
|
|
|
if (copy_from_sockptr(&val, optval, sizeof(val))) {
|
2015-11-21 22:57:31 +08:00
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
mrt->mroute_do_assert = val;
|
|
|
|
break;
|
2007-03-09 12:44:43 +08:00
|
|
|
case MRT_PIM:
|
2015-11-26 22:23:48 +08:00
|
|
|
if (!ipmr_pimsm_enabled()) {
|
2015-11-21 22:57:31 +08:00
|
|
|
ret = -ENOPROTOOPT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (optlen != sizeof(val)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2020-07-23 14:08:56 +08:00
|
|
|
if (copy_from_sockptr(&val, optval, sizeof(val))) {
|
2015-11-21 22:57:31 +08:00
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
2008-01-22 09:28:59 +08:00
|
|
|
|
2018-07-13 17:16:43 +08:00
|
|
|
do_wrvifwhole = (val == IGMPMSG_WRVIFWHOLE);
|
2015-11-21 22:57:31 +08:00
|
|
|
val = !!val;
|
|
|
|
if (val != mrt->mroute_do_pim) {
|
|
|
|
mrt->mroute_do_pim = val;
|
|
|
|
mrt->mroute_do_assert = val;
|
2018-07-13 17:16:43 +08:00
|
|
|
mrt->mroute_do_wrvifwhole = do_wrvifwhole;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2015-11-21 22:57:31 +08:00
|
|
|
break;
|
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-13 13:03:23 +08:00
|
|
|
case MRT_TABLE:
|
2015-11-21 22:57:31 +08:00
|
|
|
if (!IS_BUILTIN(CONFIG_IP_MROUTE_MULTIPLE_TABLES)) {
|
|
|
|
ret = -ENOPROTOOPT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (optlen != sizeof(uval)) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2020-07-23 14:08:56 +08:00
|
|
|
if (copy_from_sockptr(&uval, optval, sizeof(uval))) {
|
2015-11-21 22:57:31 +08:00
|
|
|
ret = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
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-13 13:03:23 +08:00
|
|
|
|
2010-10-02 00:15:01 +08:00
|
|
|
if (sk == rtnl_dereference(mrt->mroute_sk)) {
|
|
|
|
ret = -EBUSY;
|
|
|
|
} else {
|
2015-11-21 22:57:31 +08:00
|
|
|
mrt = ipmr_new_table(net, uval);
|
2015-11-21 22:57:24 +08:00
|
|
|
if (IS_ERR(mrt))
|
|
|
|
ret = PTR_ERR(mrt);
|
2012-11-25 14:41:45 +08:00
|
|
|
else
|
2015-11-21 22:57:31 +08:00
|
|
|
raw_sk(sk)->ipmr_table = uval;
|
2010-10-02 00:15:01 +08:00
|
|
|
}
|
2015-11-21 22:57:31 +08:00
|
|
|
break;
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Spurious command, or MRT_VERSION which you cannot set. */
|
2007-03-09 12:44:43 +08:00
|
|
|
default:
|
2015-11-21 22:57:31 +08:00
|
|
|
ret = -ENOPROTOOPT;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2015-11-21 22:57:31 +08:00
|
|
|
out_unlock:
|
|
|
|
rtnl_unlock();
|
2018-03-22 17:45:22 +08:00
|
|
|
out:
|
2015-11-21 22:57:31 +08:00
|
|
|
return ret;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
net: ioctl: Use kernel memory on protocol ioctl callbacks
Most of the ioctls to net protocols operates directly on userspace
argument (arg). Usually doing get_user()/put_user() directly in the
ioctl callback. This is not flexible, because it is hard to reuse these
functions without passing userspace buffers.
Change the "struct proto" ioctls to avoid touching userspace memory and
operate on kernel buffers, i.e., all protocol's ioctl callbacks is
adapted to operate on a kernel memory other than on userspace (so, no
more {put,get}_user() and friends being called in the ioctl callback).
This changes the "struct proto" ioctl format in the following way:
int (*ioctl)(struct sock *sk, int cmd,
- unsigned long arg);
+ int *karg);
(Important to say that this patch does not touch the "struct proto_ops"
protocols)
So, the "karg" argument, which is passed to the ioctl callback, is a
pointer allocated to kernel space memory (inside a function wrapper).
This buffer (karg) may contain input argument (copied from userspace in
a prep function) and it might return a value/buffer, which is copied
back to userspace if necessary. There is not one-size-fits-all format
(that is I am using 'may' above), but basically, there are three type of
ioctls:
1) Do not read from userspace, returns a result to userspace
2) Read an input parameter from userspace, and does not return anything
to userspace
3) Read an input from userspace, and return a buffer to userspace.
The default case (1) (where no input parameter is given, and an "int" is
returned to userspace) encompasses more than 90% of the cases, but there
are two other exceptions. Here is a list of exceptions:
* Protocol RAW:
* cmd = SIOCGETVIFCNT:
* input and output = struct sioc_vif_req
* cmd = SIOCGETSGCNT
* input and output = struct sioc_sg_req
* Explanation: for the SIOCGETVIFCNT case, userspace passes the input
argument, which is struct sioc_vif_req. Then the callback populates
the struct, which is copied back to userspace.
* Protocol RAW6:
* cmd = SIOCGETMIFCNT_IN6
* input and output = struct sioc_mif_req6
* cmd = SIOCGETSGCNT_IN6
* input and output = struct sioc_sg_req6
* Protocol PHONET:
* cmd == SIOCPNADDRESOURCE | SIOCPNDELRESOURCE
* input int (4 bytes)
* Nothing is copied back to userspace.
For the exception cases, functions sock_sk_ioctl_inout() will
copy the userspace input, and copy it back to kernel space.
The wrapper that prepare the buffer and put the buffer back to user is
sk_ioctl(), so, instead of calling sk->sk_prot->ioctl(), the callee now
calls sk_ioctl(), which will handle all cases.
Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Willem de Bruijn <willemb@google.com>
Reviewed-by: David Ahern <dsahern@kernel.org>
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Link: https://lore.kernel.org/r/20230609152800.830401-1-leitao@debian.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2023-06-09 23:27:42 +08:00
|
|
|
/* Execute if this ioctl is a special mroute ioctl */
|
|
|
|
int ipmr_sk_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
|
|
|
|
{
|
|
|
|
switch (cmd) {
|
|
|
|
/* These userspace buffers will be consumed by ipmr_ioctl() */
|
|
|
|
case SIOCGETVIFCNT: {
|
|
|
|
struct sioc_vif_req buffer;
|
|
|
|
|
|
|
|
return sock_ioctl_inout(sk, cmd, arg, &buffer,
|
|
|
|
sizeof(buffer));
|
|
|
|
}
|
|
|
|
case SIOCGETSGCNT: {
|
|
|
|
struct sioc_sg_req buffer;
|
|
|
|
|
|
|
|
return sock_ioctl_inout(sk, cmd, arg, &buffer,
|
|
|
|
sizeof(buffer));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* return code > 0 means that the ioctl was not executed */
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Getsock opt support for the multicast routing system. */
|
2022-09-02 08:28:28 +08:00
|
|
|
int ip_mroute_getsockopt(struct sock *sk, int optname, sockptr_t optval,
|
|
|
|
sockptr_t optlen)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int olr;
|
|
|
|
int val;
|
2009-01-22 12:56:23 +08: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-13 13:03:23 +08:00
|
|
|
struct mr_table *mrt;
|
|
|
|
|
2012-11-25 14:41:45 +08:00
|
|
|
if (sk->sk_type != SOCK_RAW ||
|
|
|
|
inet_sk(sk)->inet_num != IPPROTO_IGMP)
|
|
|
|
return -EOPNOTSUPP;
|
|
|
|
|
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-13 13:03:23 +08:00
|
|
|
mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!mrt)
|
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-13 13:03:23 +08:00
|
|
|
return -ENOENT;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-11-21 22:57:28 +08:00
|
|
|
switch (optname) {
|
|
|
|
case MRT_VERSION:
|
|
|
|
val = 0x0305;
|
|
|
|
break;
|
|
|
|
case MRT_PIM:
|
2015-11-26 22:23:48 +08:00
|
|
|
if (!ipmr_pimsm_enabled())
|
2015-11-21 22:57:28 +08:00
|
|
|
return -ENOPROTOOPT;
|
|
|
|
val = mrt->mroute_do_pim;
|
|
|
|
break;
|
|
|
|
case MRT_ASSERT:
|
|
|
|
val = mrt->mroute_do_assert;
|
|
|
|
break;
|
|
|
|
default:
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENOPROTOOPT;
|
2015-11-21 22:57:28 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2022-09-02 08:28:28 +08:00
|
|
|
if (copy_from_sockptr(&olr, optlen, sizeof(int)))
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EFAULT;
|
|
|
|
olr = min_t(unsigned int, olr, sizeof(int));
|
|
|
|
if (olr < 0)
|
|
|
|
return -EINVAL;
|
2022-09-02 08:28:28 +08:00
|
|
|
if (copy_to_sockptr(optlen, &olr, sizeof(int)))
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EFAULT;
|
2022-09-02 08:28:28 +08:00
|
|
|
if (copy_to_sockptr(optval, &val, olr))
|
2005-04-17 06:20:36 +08:00
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* The IP multicast ioctl support routines. */
|
net: ioctl: Use kernel memory on protocol ioctl callbacks
Most of the ioctls to net protocols operates directly on userspace
argument (arg). Usually doing get_user()/put_user() directly in the
ioctl callback. This is not flexible, because it is hard to reuse these
functions without passing userspace buffers.
Change the "struct proto" ioctls to avoid touching userspace memory and
operate on kernel buffers, i.e., all protocol's ioctl callbacks is
adapted to operate on a kernel memory other than on userspace (so, no
more {put,get}_user() and friends being called in the ioctl callback).
This changes the "struct proto" ioctl format in the following way:
int (*ioctl)(struct sock *sk, int cmd,
- unsigned long arg);
+ int *karg);
(Important to say that this patch does not touch the "struct proto_ops"
protocols)
So, the "karg" argument, which is passed to the ioctl callback, is a
pointer allocated to kernel space memory (inside a function wrapper).
This buffer (karg) may contain input argument (copied from userspace in
a prep function) and it might return a value/buffer, which is copied
back to userspace if necessary. There is not one-size-fits-all format
(that is I am using 'may' above), but basically, there are three type of
ioctls:
1) Do not read from userspace, returns a result to userspace
2) Read an input parameter from userspace, and does not return anything
to userspace
3) Read an input from userspace, and return a buffer to userspace.
The default case (1) (where no input parameter is given, and an "int" is
returned to userspace) encompasses more than 90% of the cases, but there
are two other exceptions. Here is a list of exceptions:
* Protocol RAW:
* cmd = SIOCGETVIFCNT:
* input and output = struct sioc_vif_req
* cmd = SIOCGETSGCNT
* input and output = struct sioc_sg_req
* Explanation: for the SIOCGETVIFCNT case, userspace passes the input
argument, which is struct sioc_vif_req. Then the callback populates
the struct, which is copied back to userspace.
* Protocol RAW6:
* cmd = SIOCGETMIFCNT_IN6
* input and output = struct sioc_mif_req6
* cmd = SIOCGETSGCNT_IN6
* input and output = struct sioc_sg_req6
* Protocol PHONET:
* cmd == SIOCPNADDRESOURCE | SIOCPNDELRESOURCE
* input int (4 bytes)
* Nothing is copied back to userspace.
For the exception cases, functions sock_sk_ioctl_inout() will
copy the userspace input, and copy it back to kernel space.
The wrapper that prepare the buffer and put the buffer back to user is
sk_ioctl(), so, instead of calling sk->sk_prot->ioctl(), the callee now
calls sk_ioctl(), which will handle all cases.
Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Willem de Bruijn <willemb@google.com>
Reviewed-by: David Ahern <dsahern@kernel.org>
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Link: https://lore.kernel.org/r/20230609152800.830401-1-leitao@debian.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2023-06-09 23:27:42 +08:00
|
|
|
int ipmr_ioctl(struct sock *sk, int cmd, void *arg)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct vif_device *vif;
|
|
|
|
struct mfc_cache *c;
|
2009-01-22 12:56:23 +08:00
|
|
|
struct net *net = sock_net(sk);
|
net: ioctl: Use kernel memory on protocol ioctl callbacks
Most of the ioctls to net protocols operates directly on userspace
argument (arg). Usually doing get_user()/put_user() directly in the
ioctl callback. This is not flexible, because it is hard to reuse these
functions without passing userspace buffers.
Change the "struct proto" ioctls to avoid touching userspace memory and
operate on kernel buffers, i.e., all protocol's ioctl callbacks is
adapted to operate on a kernel memory other than on userspace (so, no
more {put,get}_user() and friends being called in the ioctl callback).
This changes the "struct proto" ioctl format in the following way:
int (*ioctl)(struct sock *sk, int cmd,
- unsigned long arg);
+ int *karg);
(Important to say that this patch does not touch the "struct proto_ops"
protocols)
So, the "karg" argument, which is passed to the ioctl callback, is a
pointer allocated to kernel space memory (inside a function wrapper).
This buffer (karg) may contain input argument (copied from userspace in
a prep function) and it might return a value/buffer, which is copied
back to userspace if necessary. There is not one-size-fits-all format
(that is I am using 'may' above), but basically, there are three type of
ioctls:
1) Do not read from userspace, returns a result to userspace
2) Read an input parameter from userspace, and does not return anything
to userspace
3) Read an input from userspace, and return a buffer to userspace.
The default case (1) (where no input parameter is given, and an "int" is
returned to userspace) encompasses more than 90% of the cases, but there
are two other exceptions. Here is a list of exceptions:
* Protocol RAW:
* cmd = SIOCGETVIFCNT:
* input and output = struct sioc_vif_req
* cmd = SIOCGETSGCNT
* input and output = struct sioc_sg_req
* Explanation: for the SIOCGETVIFCNT case, userspace passes the input
argument, which is struct sioc_vif_req. Then the callback populates
the struct, which is copied back to userspace.
* Protocol RAW6:
* cmd = SIOCGETMIFCNT_IN6
* input and output = struct sioc_mif_req6
* cmd = SIOCGETSGCNT_IN6
* input and output = struct sioc_sg_req6
* Protocol PHONET:
* cmd == SIOCPNADDRESOURCE | SIOCPNDELRESOURCE
* input int (4 bytes)
* Nothing is copied back to userspace.
For the exception cases, functions sock_sk_ioctl_inout() will
copy the userspace input, and copy it back to kernel space.
The wrapper that prepare the buffer and put the buffer back to user is
sk_ioctl(), so, instead of calling sk->sk_prot->ioctl(), the callee now
calls sk_ioctl(), which will handle all cases.
Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Willem de Bruijn <willemb@google.com>
Reviewed-by: David Ahern <dsahern@kernel.org>
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Link: https://lore.kernel.org/r/20230609152800.830401-1-leitao@debian.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2023-06-09 23:27:42 +08:00
|
|
|
struct sioc_vif_req *vr;
|
|
|
|
struct sioc_sg_req *sr;
|
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-13 13:03:23 +08:00
|
|
|
struct mr_table *mrt;
|
|
|
|
|
|
|
|
mrt = ipmr_get_table(net, raw_sk(sk)->ipmr_table ? : RT_TABLE_DEFAULT);
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!mrt)
|
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-13 13:03:23 +08:00
|
|
|
return -ENOENT;
|
2007-02-09 22:24:47 +08:00
|
|
|
|
2007-03-09 12:44:43 +08:00
|
|
|
switch (cmd) {
|
|
|
|
case SIOCGETVIFCNT:
|
net: ioctl: Use kernel memory on protocol ioctl callbacks
Most of the ioctls to net protocols operates directly on userspace
argument (arg). Usually doing get_user()/put_user() directly in the
ioctl callback. This is not flexible, because it is hard to reuse these
functions without passing userspace buffers.
Change the "struct proto" ioctls to avoid touching userspace memory and
operate on kernel buffers, i.e., all protocol's ioctl callbacks is
adapted to operate on a kernel memory other than on userspace (so, no
more {put,get}_user() and friends being called in the ioctl callback).
This changes the "struct proto" ioctl format in the following way:
int (*ioctl)(struct sock *sk, int cmd,
- unsigned long arg);
+ int *karg);
(Important to say that this patch does not touch the "struct proto_ops"
protocols)
So, the "karg" argument, which is passed to the ioctl callback, is a
pointer allocated to kernel space memory (inside a function wrapper).
This buffer (karg) may contain input argument (copied from userspace in
a prep function) and it might return a value/buffer, which is copied
back to userspace if necessary. There is not one-size-fits-all format
(that is I am using 'may' above), but basically, there are three type of
ioctls:
1) Do not read from userspace, returns a result to userspace
2) Read an input parameter from userspace, and does not return anything
to userspace
3) Read an input from userspace, and return a buffer to userspace.
The default case (1) (where no input parameter is given, and an "int" is
returned to userspace) encompasses more than 90% of the cases, but there
are two other exceptions. Here is a list of exceptions:
* Protocol RAW:
* cmd = SIOCGETVIFCNT:
* input and output = struct sioc_vif_req
* cmd = SIOCGETSGCNT
* input and output = struct sioc_sg_req
* Explanation: for the SIOCGETVIFCNT case, userspace passes the input
argument, which is struct sioc_vif_req. Then the callback populates
the struct, which is copied back to userspace.
* Protocol RAW6:
* cmd = SIOCGETMIFCNT_IN6
* input and output = struct sioc_mif_req6
* cmd = SIOCGETSGCNT_IN6
* input and output = struct sioc_sg_req6
* Protocol PHONET:
* cmd == SIOCPNADDRESOURCE | SIOCPNDELRESOURCE
* input int (4 bytes)
* Nothing is copied back to userspace.
For the exception cases, functions sock_sk_ioctl_inout() will
copy the userspace input, and copy it back to kernel space.
The wrapper that prepare the buffer and put the buffer back to user is
sk_ioctl(), so, instead of calling sk->sk_prot->ioctl(), the callee now
calls sk_ioctl(), which will handle all cases.
Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Willem de Bruijn <willemb@google.com>
Reviewed-by: David Ahern <dsahern@kernel.org>
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Link: https://lore.kernel.org/r/20230609152800.830401-1-leitao@debian.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2023-06-09 23:27:42 +08:00
|
|
|
vr = (struct sioc_vif_req *)arg;
|
|
|
|
if (vr->vifi >= mrt->maxvif)
|
2007-03-09 12:44:43 +08:00
|
|
|
return -EINVAL;
|
net: ioctl: Use kernel memory on protocol ioctl callbacks
Most of the ioctls to net protocols operates directly on userspace
argument (arg). Usually doing get_user()/put_user() directly in the
ioctl callback. This is not flexible, because it is hard to reuse these
functions without passing userspace buffers.
Change the "struct proto" ioctls to avoid touching userspace memory and
operate on kernel buffers, i.e., all protocol's ioctl callbacks is
adapted to operate on a kernel memory other than on userspace (so, no
more {put,get}_user() and friends being called in the ioctl callback).
This changes the "struct proto" ioctl format in the following way:
int (*ioctl)(struct sock *sk, int cmd,
- unsigned long arg);
+ int *karg);
(Important to say that this patch does not touch the "struct proto_ops"
protocols)
So, the "karg" argument, which is passed to the ioctl callback, is a
pointer allocated to kernel space memory (inside a function wrapper).
This buffer (karg) may contain input argument (copied from userspace in
a prep function) and it might return a value/buffer, which is copied
back to userspace if necessary. There is not one-size-fits-all format
(that is I am using 'may' above), but basically, there are three type of
ioctls:
1) Do not read from userspace, returns a result to userspace
2) Read an input parameter from userspace, and does not return anything
to userspace
3) Read an input from userspace, and return a buffer to userspace.
The default case (1) (where no input parameter is given, and an "int" is
returned to userspace) encompasses more than 90% of the cases, but there
are two other exceptions. Here is a list of exceptions:
* Protocol RAW:
* cmd = SIOCGETVIFCNT:
* input and output = struct sioc_vif_req
* cmd = SIOCGETSGCNT
* input and output = struct sioc_sg_req
* Explanation: for the SIOCGETVIFCNT case, userspace passes the input
argument, which is struct sioc_vif_req. Then the callback populates
the struct, which is copied back to userspace.
* Protocol RAW6:
* cmd = SIOCGETMIFCNT_IN6
* input and output = struct sioc_mif_req6
* cmd = SIOCGETSGCNT_IN6
* input and output = struct sioc_sg_req6
* Protocol PHONET:
* cmd == SIOCPNADDRESOURCE | SIOCPNDELRESOURCE
* input int (4 bytes)
* Nothing is copied back to userspace.
For the exception cases, functions sock_sk_ioctl_inout() will
copy the userspace input, and copy it back to kernel space.
The wrapper that prepare the buffer and put the buffer back to user is
sk_ioctl(), so, instead of calling sk->sk_prot->ioctl(), the callee now
calls sk_ioctl(), which will handle all cases.
Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Willem de Bruijn <willemb@google.com>
Reviewed-by: David Ahern <dsahern@kernel.org>
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Link: https://lore.kernel.org/r/20230609152800.830401-1-leitao@debian.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2023-06-09 23:27:42 +08:00
|
|
|
vr->vifi = array_index_nospec(vr->vifi, mrt->maxvif);
|
2022-06-23 12:34:36 +08:00
|
|
|
rcu_read_lock();
|
net: ioctl: Use kernel memory on protocol ioctl callbacks
Most of the ioctls to net protocols operates directly on userspace
argument (arg). Usually doing get_user()/put_user() directly in the
ioctl callback. This is not flexible, because it is hard to reuse these
functions without passing userspace buffers.
Change the "struct proto" ioctls to avoid touching userspace memory and
operate on kernel buffers, i.e., all protocol's ioctl callbacks is
adapted to operate on a kernel memory other than on userspace (so, no
more {put,get}_user() and friends being called in the ioctl callback).
This changes the "struct proto" ioctl format in the following way:
int (*ioctl)(struct sock *sk, int cmd,
- unsigned long arg);
+ int *karg);
(Important to say that this patch does not touch the "struct proto_ops"
protocols)
So, the "karg" argument, which is passed to the ioctl callback, is a
pointer allocated to kernel space memory (inside a function wrapper).
This buffer (karg) may contain input argument (copied from userspace in
a prep function) and it might return a value/buffer, which is copied
back to userspace if necessary. There is not one-size-fits-all format
(that is I am using 'may' above), but basically, there are three type of
ioctls:
1) Do not read from userspace, returns a result to userspace
2) Read an input parameter from userspace, and does not return anything
to userspace
3) Read an input from userspace, and return a buffer to userspace.
The default case (1) (where no input parameter is given, and an "int" is
returned to userspace) encompasses more than 90% of the cases, but there
are two other exceptions. Here is a list of exceptions:
* Protocol RAW:
* cmd = SIOCGETVIFCNT:
* input and output = struct sioc_vif_req
* cmd = SIOCGETSGCNT
* input and output = struct sioc_sg_req
* Explanation: for the SIOCGETVIFCNT case, userspace passes the input
argument, which is struct sioc_vif_req. Then the callback populates
the struct, which is copied back to userspace.
* Protocol RAW6:
* cmd = SIOCGETMIFCNT_IN6
* input and output = struct sioc_mif_req6
* cmd = SIOCGETSGCNT_IN6
* input and output = struct sioc_sg_req6
* Protocol PHONET:
* cmd == SIOCPNADDRESOURCE | SIOCPNDELRESOURCE
* input int (4 bytes)
* Nothing is copied back to userspace.
For the exception cases, functions sock_sk_ioctl_inout() will
copy the userspace input, and copy it back to kernel space.
The wrapper that prepare the buffer and put the buffer back to user is
sk_ioctl(), so, instead of calling sk->sk_prot->ioctl(), the callee now
calls sk_ioctl(), which will handle all cases.
Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Willem de Bruijn <willemb@google.com>
Reviewed-by: David Ahern <dsahern@kernel.org>
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Link: https://lore.kernel.org/r/20230609152800.830401-1-leitao@debian.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2023-06-09 23:27:42 +08:00
|
|
|
vif = &mrt->vif_table[vr->vifi];
|
|
|
|
if (VIF_EXISTS(mrt, vr->vifi)) {
|
|
|
|
vr->icount = READ_ONCE(vif->pkt_in);
|
|
|
|
vr->ocount = READ_ONCE(vif->pkt_out);
|
|
|
|
vr->ibytes = READ_ONCE(vif->bytes_in);
|
|
|
|
vr->obytes = READ_ONCE(vif->bytes_out);
|
2022-06-23 12:34:36 +08:00
|
|
|
rcu_read_unlock();
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-03-09 12:44:43 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2022-06-23 12:34:36 +08:00
|
|
|
rcu_read_unlock();
|
2007-03-09 12:44:43 +08:00
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
case SIOCGETSGCNT:
|
net: ioctl: Use kernel memory on protocol ioctl callbacks
Most of the ioctls to net protocols operates directly on userspace
argument (arg). Usually doing get_user()/put_user() directly in the
ioctl callback. This is not flexible, because it is hard to reuse these
functions without passing userspace buffers.
Change the "struct proto" ioctls to avoid touching userspace memory and
operate on kernel buffers, i.e., all protocol's ioctl callbacks is
adapted to operate on a kernel memory other than on userspace (so, no
more {put,get}_user() and friends being called in the ioctl callback).
This changes the "struct proto" ioctl format in the following way:
int (*ioctl)(struct sock *sk, int cmd,
- unsigned long arg);
+ int *karg);
(Important to say that this patch does not touch the "struct proto_ops"
protocols)
So, the "karg" argument, which is passed to the ioctl callback, is a
pointer allocated to kernel space memory (inside a function wrapper).
This buffer (karg) may contain input argument (copied from userspace in
a prep function) and it might return a value/buffer, which is copied
back to userspace if necessary. There is not one-size-fits-all format
(that is I am using 'may' above), but basically, there are three type of
ioctls:
1) Do not read from userspace, returns a result to userspace
2) Read an input parameter from userspace, and does not return anything
to userspace
3) Read an input from userspace, and return a buffer to userspace.
The default case (1) (where no input parameter is given, and an "int" is
returned to userspace) encompasses more than 90% of the cases, but there
are two other exceptions. Here is a list of exceptions:
* Protocol RAW:
* cmd = SIOCGETVIFCNT:
* input and output = struct sioc_vif_req
* cmd = SIOCGETSGCNT
* input and output = struct sioc_sg_req
* Explanation: for the SIOCGETVIFCNT case, userspace passes the input
argument, which is struct sioc_vif_req. Then the callback populates
the struct, which is copied back to userspace.
* Protocol RAW6:
* cmd = SIOCGETMIFCNT_IN6
* input and output = struct sioc_mif_req6
* cmd = SIOCGETSGCNT_IN6
* input and output = struct sioc_sg_req6
* Protocol PHONET:
* cmd == SIOCPNADDRESOURCE | SIOCPNDELRESOURCE
* input int (4 bytes)
* Nothing is copied back to userspace.
For the exception cases, functions sock_sk_ioctl_inout() will
copy the userspace input, and copy it back to kernel space.
The wrapper that prepare the buffer and put the buffer back to user is
sk_ioctl(), so, instead of calling sk->sk_prot->ioctl(), the callee now
calls sk_ioctl(), which will handle all cases.
Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Willem de Bruijn <willemb@google.com>
Reviewed-by: David Ahern <dsahern@kernel.org>
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Link: https://lore.kernel.org/r/20230609152800.830401-1-leitao@debian.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2023-06-09 23:27:42 +08:00
|
|
|
sr = (struct sioc_sg_req *)arg;
|
2007-03-09 12:44:43 +08:00
|
|
|
|
2010-10-02 00:15:08 +08:00
|
|
|
rcu_read_lock();
|
net: ioctl: Use kernel memory on protocol ioctl callbacks
Most of the ioctls to net protocols operates directly on userspace
argument (arg). Usually doing get_user()/put_user() directly in the
ioctl callback. This is not flexible, because it is hard to reuse these
functions without passing userspace buffers.
Change the "struct proto" ioctls to avoid touching userspace memory and
operate on kernel buffers, i.e., all protocol's ioctl callbacks is
adapted to operate on a kernel memory other than on userspace (so, no
more {put,get}_user() and friends being called in the ioctl callback).
This changes the "struct proto" ioctl format in the following way:
int (*ioctl)(struct sock *sk, int cmd,
- unsigned long arg);
+ int *karg);
(Important to say that this patch does not touch the "struct proto_ops"
protocols)
So, the "karg" argument, which is passed to the ioctl callback, is a
pointer allocated to kernel space memory (inside a function wrapper).
This buffer (karg) may contain input argument (copied from userspace in
a prep function) and it might return a value/buffer, which is copied
back to userspace if necessary. There is not one-size-fits-all format
(that is I am using 'may' above), but basically, there are three type of
ioctls:
1) Do not read from userspace, returns a result to userspace
2) Read an input parameter from userspace, and does not return anything
to userspace
3) Read an input from userspace, and return a buffer to userspace.
The default case (1) (where no input parameter is given, and an "int" is
returned to userspace) encompasses more than 90% of the cases, but there
are two other exceptions. Here is a list of exceptions:
* Protocol RAW:
* cmd = SIOCGETVIFCNT:
* input and output = struct sioc_vif_req
* cmd = SIOCGETSGCNT
* input and output = struct sioc_sg_req
* Explanation: for the SIOCGETVIFCNT case, userspace passes the input
argument, which is struct sioc_vif_req. Then the callback populates
the struct, which is copied back to userspace.
* Protocol RAW6:
* cmd = SIOCGETMIFCNT_IN6
* input and output = struct sioc_mif_req6
* cmd = SIOCGETSGCNT_IN6
* input and output = struct sioc_sg_req6
* Protocol PHONET:
* cmd == SIOCPNADDRESOURCE | SIOCPNDELRESOURCE
* input int (4 bytes)
* Nothing is copied back to userspace.
For the exception cases, functions sock_sk_ioctl_inout() will
copy the userspace input, and copy it back to kernel space.
The wrapper that prepare the buffer and put the buffer back to user is
sk_ioctl(), so, instead of calling sk->sk_prot->ioctl(), the callee now
calls sk_ioctl(), which will handle all cases.
Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Willem de Bruijn <willemb@google.com>
Reviewed-by: David Ahern <dsahern@kernel.org>
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Link: https://lore.kernel.org/r/20230609152800.830401-1-leitao@debian.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2023-06-09 23:27:42 +08:00
|
|
|
c = ipmr_cache_find(mrt, sr->src.s_addr, sr->grp.s_addr);
|
2007-03-09 12:44:43 +08:00
|
|
|
if (c) {
|
net: ioctl: Use kernel memory on protocol ioctl callbacks
Most of the ioctls to net protocols operates directly on userspace
argument (arg). Usually doing get_user()/put_user() directly in the
ioctl callback. This is not flexible, because it is hard to reuse these
functions without passing userspace buffers.
Change the "struct proto" ioctls to avoid touching userspace memory and
operate on kernel buffers, i.e., all protocol's ioctl callbacks is
adapted to operate on a kernel memory other than on userspace (so, no
more {put,get}_user() and friends being called in the ioctl callback).
This changes the "struct proto" ioctl format in the following way:
int (*ioctl)(struct sock *sk, int cmd,
- unsigned long arg);
+ int *karg);
(Important to say that this patch does not touch the "struct proto_ops"
protocols)
So, the "karg" argument, which is passed to the ioctl callback, is a
pointer allocated to kernel space memory (inside a function wrapper).
This buffer (karg) may contain input argument (copied from userspace in
a prep function) and it might return a value/buffer, which is copied
back to userspace if necessary. There is not one-size-fits-all format
(that is I am using 'may' above), but basically, there are three type of
ioctls:
1) Do not read from userspace, returns a result to userspace
2) Read an input parameter from userspace, and does not return anything
to userspace
3) Read an input from userspace, and return a buffer to userspace.
The default case (1) (where no input parameter is given, and an "int" is
returned to userspace) encompasses more than 90% of the cases, but there
are two other exceptions. Here is a list of exceptions:
* Protocol RAW:
* cmd = SIOCGETVIFCNT:
* input and output = struct sioc_vif_req
* cmd = SIOCGETSGCNT
* input and output = struct sioc_sg_req
* Explanation: for the SIOCGETVIFCNT case, userspace passes the input
argument, which is struct sioc_vif_req. Then the callback populates
the struct, which is copied back to userspace.
* Protocol RAW6:
* cmd = SIOCGETMIFCNT_IN6
* input and output = struct sioc_mif_req6
* cmd = SIOCGETSGCNT_IN6
* input and output = struct sioc_sg_req6
* Protocol PHONET:
* cmd == SIOCPNADDRESOURCE | SIOCPNDELRESOURCE
* input int (4 bytes)
* Nothing is copied back to userspace.
For the exception cases, functions sock_sk_ioctl_inout() will
copy the userspace input, and copy it back to kernel space.
The wrapper that prepare the buffer and put the buffer back to user is
sk_ioctl(), so, instead of calling sk->sk_prot->ioctl(), the callee now
calls sk_ioctl(), which will handle all cases.
Signed-off-by: Breno Leitao <leitao@debian.org>
Reviewed-by: Willem de Bruijn <willemb@google.com>
Reviewed-by: David Ahern <dsahern@kernel.org>
Reviewed-by: Kuniyuki Iwashima <kuniyu@amazon.com>
Link: https://lore.kernel.org/r/20230609152800.830401-1-leitao@debian.org
Signed-off-by: Jakub Kicinski <kuba@kernel.org>
2023-06-09 23:27:42 +08:00
|
|
|
sr->pktcnt = c->_c.mfc_un.res.pkt;
|
|
|
|
sr->bytecnt = c->_c.mfc_un.res.bytes;
|
|
|
|
sr->wrong_if = c->_c.mfc_un.res.wrong_if;
|
2010-10-02 00:15:08 +08:00
|
|
|
rcu_read_unlock();
|
2007-03-09 12:44:43 +08:00
|
|
|
return 0;
|
|
|
|
}
|
2010-10-02 00:15:08 +08:00
|
|
|
rcu_read_unlock();
|
2007-03-09 12:44:43 +08:00
|
|
|
return -EADDRNOTAVAIL;
|
|
|
|
default:
|
|
|
|
return -ENOIOCTLCMD;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-30 00:15:56 +08: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-04 09:24:28 +08: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-30 00:15:56 +08:00
|
|
|
int ipmr_compat_ioctl(struct sock *sk, unsigned int cmd, void __user *arg)
|
|
|
|
{
|
2011-02-04 09:21:31 +08:00
|
|
|
struct compat_sioc_sg_req sr;
|
2011-02-04 09:24:28 +08:00
|
|
|
struct compat_sioc_vif_req vr;
|
|
|
|
struct vif_device *vif;
|
2011-01-30 00:15:56 +08: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);
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!mrt)
|
2011-01-30 00:15:56 +08:00
|
|
|
return -ENOENT;
|
|
|
|
|
|
|
|
switch (cmd) {
|
2011-02-04 09:24:28 +08:00
|
|
|
case SIOCGETVIFCNT:
|
|
|
|
if (copy_from_user(&vr, arg, sizeof(vr)))
|
|
|
|
return -EFAULT;
|
|
|
|
if (vr.vifi >= mrt->maxvif)
|
|
|
|
return -EINVAL;
|
2018-12-11 02:41:24 +08:00
|
|
|
vr.vifi = array_index_nospec(vr.vifi, mrt->maxvif);
|
2022-06-23 12:34:36 +08:00
|
|
|
rcu_read_lock();
|
2011-02-04 09:24:28 +08:00
|
|
|
vif = &mrt->vif_table[vr.vifi];
|
|
|
|
if (VIF_EXISTS(mrt, vr.vifi)) {
|
2022-06-23 12:34:36 +08:00
|
|
|
vr.icount = READ_ONCE(vif->pkt_in);
|
|
|
|
vr.ocount = READ_ONCE(vif->pkt_out);
|
|
|
|
vr.ibytes = READ_ONCE(vif->bytes_in);
|
|
|
|
vr.obytes = READ_ONCE(vif->bytes_out);
|
|
|
|
rcu_read_unlock();
|
2011-02-04 09:24:28 +08:00
|
|
|
|
|
|
|
if (copy_to_user(arg, &vr, sizeof(vr)))
|
|
|
|
return -EFAULT;
|
|
|
|
return 0;
|
|
|
|
}
|
2022-06-23 12:34:36 +08:00
|
|
|
rcu_read_unlock();
|
2011-02-04 09:24:28 +08:00
|
|
|
return -EADDRNOTAVAIL;
|
2011-01-30 00:15:56 +08: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) {
|
2018-03-01 05:29:34 +08:00
|
|
|
sr.pktcnt = c->_c.mfc_un.res.pkt;
|
|
|
|
sr.bytecnt = c->_c.mfc_un.res.bytes;
|
|
|
|
sr.wrong_if = c->_c.mfc_un.res.wrong_if;
|
2011-01-30 00:15:56 +08:00
|
|
|
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-17 06:20:36 +08:00
|
|
|
static int ipmr_device_event(struct notifier_block *this, unsigned long event, void *ptr)
|
|
|
|
{
|
2013-05-28 09:30:21 +08:00
|
|
|
struct net_device *dev = netdev_notifier_info_to_dev(ptr);
|
2009-01-22 12:56:23 +08: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-13 13:03:23 +08:00
|
|
|
struct mr_table *mrt;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct vif_device *v;
|
|
|
|
int ct;
|
2007-09-12 19:02:17 +08:00
|
|
|
|
2005-04-17 06:20:36 +08: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-13 13:03:23 +08:00
|
|
|
|
|
|
|
ipmr_for_each_table(mrt, net) {
|
|
|
|
v = &mrt->vif_table[0];
|
|
|
|
for (ct = 0; ct < mrt->maxvif; ct++, v++) {
|
2022-06-23 12:34:32 +08:00
|
|
|
if (rcu_access_pointer(v->dev) == dev)
|
2011-11-24 07:10:52 +08: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-13 13:03:23 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
2008-11-03 16:28:02 +08:00
|
|
|
static struct notifier_block ip_mr_notifier = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.notifier_call = ipmr_device_event,
|
|
|
|
};
|
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Encapsulate a packet by attaching a valid IPIP header to it.
|
|
|
|
* This avoids tunnel drivers and other mess and gives us the speed so
|
|
|
|
* important for multicast video.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2015-03-26 00:07:44 +08:00
|
|
|
static void ip_encap(struct net *net, struct sk_buff *skb,
|
|
|
|
__be32 saddr, __be32 daddr)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2007-03-11 06:40:39 +08:00
|
|
|
struct iphdr *iph;
|
2011-04-22 12:53:02 +08:00
|
|
|
const struct iphdr *old_iph = ip_hdr(skb);
|
2007-03-11 06:40:39 +08:00
|
|
|
|
|
|
|
skb_push(skb, sizeof(struct iphdr));
|
2007-04-11 12:21:55 +08:00
|
|
|
skb->transport_header = skb->network_header;
|
2007-03-11 06:40:39 +08:00
|
|
|
skb_reset_network_header(skb);
|
2007-04-21 13:47:35 +08:00
|
|
|
iph = ip_hdr(skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-10-02 00:15:29 +08:00
|
|
|
iph->version = 4;
|
2007-03-13 07:09:36 +08:00
|
|
|
iph->tos = old_iph->tos;
|
|
|
|
iph->ttl = old_iph->ttl;
|
2005-04-17 06:20:36 +08:00
|
|
|
iph->frag_off = 0;
|
|
|
|
iph->daddr = daddr;
|
|
|
|
iph->saddr = saddr;
|
|
|
|
iph->protocol = IPPROTO_IPIP;
|
|
|
|
iph->ihl = 5;
|
|
|
|
iph->tot_len = htons(skb->len);
|
2015-03-26 00:07:44 +08:00
|
|
|
ip_select_ident(net, skb, NULL);
|
2005-04-17 06:20:36 +08:00
|
|
|
ip_send_check(iph);
|
|
|
|
|
|
|
|
memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
|
2019-09-30 02:54:03 +08:00
|
|
|
nf_reset_ct(skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2015-09-16 09:04:18 +08:00
|
|
|
static inline int ipmr_forward_finish(struct net *net, struct sock *sk,
|
|
|
|
struct sk_buff *skb)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2010-10-02 00:15:29 +08:00
|
|
|
struct ip_options *opt = &(IPCB(skb)->opt);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-11-04 02:41:45 +08:00
|
|
|
IP_INC_STATS(net, IPSTATS_MIB_OUTFORWDATAGRAMS);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (unlikely(opt->optlen))
|
|
|
|
ip_forward_options(skb);
|
|
|
|
|
2015-10-08 05:48:35 +08:00
|
|
|
return dst_output(net, sk, skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2017-10-03 15:58:08 +08:00
|
|
|
#ifdef CONFIG_NET_SWITCHDEV
|
|
|
|
static bool ipmr_forward_offloaded(struct sk_buff *skb, struct mr_table *mrt,
|
|
|
|
int in_vifi, int out_vifi)
|
|
|
|
{
|
|
|
|
struct vif_device *out_vif = &mrt->vif_table[out_vifi];
|
|
|
|
struct vif_device *in_vif = &mrt->vif_table[in_vifi];
|
|
|
|
|
2018-12-04 16:15:10 +08:00
|
|
|
if (!skb->offload_l3_fwd_mark)
|
2017-10-03 15:58:08 +08:00
|
|
|
return false;
|
|
|
|
if (!out_vif->dev_parent_id.id_len || !in_vif->dev_parent_id.id_len)
|
|
|
|
return false;
|
|
|
|
return netdev_phys_item_id_same(&out_vif->dev_parent_id,
|
|
|
|
&in_vif->dev_parent_id);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
static bool ipmr_forward_offloaded(struct sk_buff *skb, struct mr_table *mrt,
|
|
|
|
int in_vifi, int out_vifi)
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2022-06-23 12:34:38 +08:00
|
|
|
/* Processing handlers for ipmr_forward, under rcu_read_lock() */
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-04-13 13:03:22 +08:00
|
|
|
static void ipmr_queue_xmit(struct net *net, struct mr_table *mrt,
|
2018-12-18 07:34:48 +08:00
|
|
|
int in_vifi, struct sk_buff *skb, int vifi)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2007-04-21 13:47:35 +08:00
|
|
|
const struct iphdr *iph = ip_hdr(skb);
|
2010-04-13 13:03:22 +08:00
|
|
|
struct vif_device *vif = &mrt->vif_table[vifi];
|
2022-06-23 12:34:32 +08:00
|
|
|
struct net_device *vif_dev;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct net_device *dev;
|
|
|
|
struct rtable *rt;
|
2011-05-04 11:25:42 +08:00
|
|
|
struct flowi4 fl4;
|
2005-04-17 06:20:36 +08:00
|
|
|
int encap = 0;
|
|
|
|
|
2022-06-23 12:34:32 +08:00
|
|
|
vif_dev = vif_dev_read(vif);
|
|
|
|
if (!vif_dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_free;
|
|
|
|
|
|
|
|
if (vif->flags & VIFF_REGISTER) {
|
2022-06-23 12:34:36 +08:00
|
|
|
WRITE_ONCE(vif->pkt_out, vif->pkt_out + 1);
|
|
|
|
WRITE_ONCE(vif->bytes_out, vif->bytes_out + skb->len);
|
2022-11-15 16:53:58 +08:00
|
|
|
DEV_STATS_ADD(vif_dev, tx_bytes, skb->len);
|
|
|
|
DEV_STATS_INC(vif_dev, tx_packets);
|
2010-04-13 13:03:22 +08:00
|
|
|
ipmr_cache_report(mrt, skb, vifi, IGMPMSG_WHOLEPKT);
|
2009-02-07 15:46:51 +08:00
|
|
|
goto out_free;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2017-10-03 15:58:08 +08:00
|
|
|
if (ipmr_forward_offloaded(skb, mrt, in_vifi, vifi))
|
|
|
|
goto out_free;
|
|
|
|
|
2010-10-02 00:15:29 +08:00
|
|
|
if (vif->flags & VIFF_TUNNEL) {
|
2011-05-04 11:25:42 +08:00
|
|
|
rt = ip_route_output_ports(net, &fl4, NULL,
|
2011-03-12 13:00:52 +08:00
|
|
|
vif->remote, vif->local,
|
|
|
|
0, 0,
|
|
|
|
IPPROTO_IPIP,
|
|
|
|
RT_TOS(iph->tos), vif->link);
|
2011-03-03 06:31:35 +08:00
|
|
|
if (IS_ERR(rt))
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_free;
|
|
|
|
encap = sizeof(struct iphdr);
|
|
|
|
} else {
|
2011-05-04 11:25:42 +08:00
|
|
|
rt = ip_route_output_ports(net, &fl4, NULL, iph->daddr, 0,
|
2011-03-12 13:00:52 +08:00
|
|
|
0, 0,
|
|
|
|
IPPROTO_IPIP,
|
|
|
|
RT_TOS(iph->tos), vif->link);
|
2011-03-03 06:31:35 +08:00
|
|
|
if (IS_ERR(rt))
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
2010-06-11 14:31:35 +08:00
|
|
|
dev = rt->dst.dev;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-06-11 14:31:35 +08:00
|
|
|
if (skb->len+encap > dst_mtu(&rt->dst) && (ntohs(iph->frag_off) & IP_DF)) {
|
2005-04-17 06:20:36 +08:00
|
|
|
/* Do not fragment multicasts. Alas, IPv4 does not
|
2010-10-02 00:15:29 +08:00
|
|
|
* allow to send ICMP, so that packets will disappear
|
|
|
|
* to blackhole.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2015-11-04 02:41:45 +08:00
|
|
|
IP_INC_STATS(net, IPSTATS_MIB_FRAGFAILS);
|
2005-04-17 06:20:36 +08:00
|
|
|
ip_rt_put(rt);
|
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
2010-06-11 14:31:35 +08:00
|
|
|
encap += LL_RESERVED_SPACE(dev) + rt->dst.header_len;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
if (skb_cow(skb, encap)) {
|
2007-02-09 22:24:47 +08:00
|
|
|
ip_rt_put(rt);
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out_free;
|
|
|
|
}
|
|
|
|
|
2022-06-23 12:34:36 +08:00
|
|
|
WRITE_ONCE(vif->pkt_out, vif->pkt_out + 1);
|
|
|
|
WRITE_ONCE(vif->bytes_out, vif->bytes_out + skb->len);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-06-02 13:19:30 +08:00
|
|
|
skb_dst_drop(skb);
|
2010-06-11 14:31:35 +08:00
|
|
|
skb_dst_set(skb, &rt->dst);
|
2007-04-21 13:47:35 +08:00
|
|
|
ip_decrease_ttl(ip_hdr(skb));
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* FIXME: forward and output firewalls used to be called here.
|
2010-10-02 00:15:29 +08:00
|
|
|
* What do we do with netfilter? -- RR
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
if (vif->flags & VIFF_TUNNEL) {
|
2015-03-26 00:07:44 +08:00
|
|
|
ip_encap(net, skb, vif->local, vif->remote);
|
2005-04-17 06:20:36 +08:00
|
|
|
/* FIXME: extra output firewall step used to be here. --RR */
|
2022-11-15 16:53:58 +08:00
|
|
|
DEV_STATS_INC(vif_dev, tx_packets);
|
|
|
|
DEV_STATS_ADD(vif_dev, tx_bytes, skb->len);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2016-11-03 04:36:17 +08:00
|
|
|
IPCB(skb)->flags |= IPSKB_FORWARDED;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* RFC1584 teaches, that DVMRP/PIM router must deliver packets locally
|
2005-04-17 06:20:36 +08:00
|
|
|
* 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.
|
|
|
|
*/
|
2015-09-16 09:04:16 +08:00
|
|
|
NF_HOOK(NFPROTO_IPV4, NF_INET_FORWARD,
|
|
|
|
net, NULL, skb, skb->dev, dev,
|
2005-04-17 06:20:36 +08:00
|
|
|
ipmr_forward_finish);
|
|
|
|
return;
|
|
|
|
|
|
|
|
out_free:
|
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
|
|
|
|
2022-06-23 12:34:37 +08:00
|
|
|
/* Called with mrt_lock or rcu_read_lock() */
|
|
|
|
static int ipmr_find_vif(const struct mr_table *mrt, struct net_device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
int ct;
|
2022-06-23 12:34:37 +08:00
|
|
|
/* Pairs with WRITE_ONCE() in vif_delete()/vif_add() */
|
|
|
|
for (ct = READ_ONCE(mrt->maxvif) - 1; ct >= 0; ct--) {
|
2022-06-23 12:34:32 +08:00
|
|
|
if (rcu_access_pointer(mrt->vif_table[ct].dev) == dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ct;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* "local" means that we should preserve one skb (for local delivery) */
|
2022-06-23 12:34:38 +08:00
|
|
|
/* Called uner rcu_read_lock() */
|
2013-07-20 20:09:28 +08:00
|
|
|
static void ip_mr_forward(struct net *net, struct mr_table *mrt,
|
2017-06-11 04:30:17 +08:00
|
|
|
struct net_device *dev, struct sk_buff *skb,
|
2018-03-01 05:29:34 +08:00
|
|
|
struct mfc_cache *c, int local)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2017-06-11 04:30:17 +08:00
|
|
|
int true_vifi = ipmr_find_vif(mrt, dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
int psend = -1;
|
|
|
|
int vif, ct;
|
|
|
|
|
2018-03-01 05:29:34 +08:00
|
|
|
vif = c->_c.mfc_parent;
|
|
|
|
c->_c.mfc_un.res.pkt++;
|
|
|
|
c->_c.mfc_un.res.bytes += skb->len;
|
|
|
|
c->_c.mfc_un.res.lastuse = jiffies;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2018-03-01 05:29:34 +08:00
|
|
|
if (c->mfc_origin == htonl(INADDR_ANY) && true_vifi >= 0) {
|
2013-01-21 14:00:26 +08:00
|
|
|
struct mfc_cache *cache_proxy;
|
|
|
|
|
2021-06-07 23:01:09 +08:00
|
|
|
/* For an (*,G) entry, we only check that the incoming
|
2013-01-21 14:00:26 +08:00
|
|
|
* interface is part of the static tree.
|
|
|
|
*/
|
2018-03-01 05:29:35 +08:00
|
|
|
cache_proxy = mr_mfc_find_any_parent(mrt, vif);
|
2013-01-21 14:00:26 +08:00
|
|
|
if (cache_proxy &&
|
2018-03-01 05:29:34 +08:00
|
|
|
cache_proxy->_c.mfc_un.res.ttls[true_vifi] < 255)
|
2013-01-21 14:00:26 +08:00
|
|
|
goto forward;
|
|
|
|
}
|
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Wrong interface: drop packet and (maybe) send PIM assert. */
|
2022-06-23 12:34:32 +08:00
|
|
|
if (rcu_access_pointer(mrt->vif_table[vif].dev) != dev) {
|
2010-11-12 09:07:48 +08:00
|
|
|
if (rt_is_output_route(skb_rtable(skb))) {
|
2005-04-17 06:20:36 +08:00
|
|
|
/* It is our own packet, looped back.
|
2010-10-02 00:15:29 +08: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-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
goto dont_forward;
|
|
|
|
}
|
|
|
|
|
2018-03-01 05:29:34 +08:00
|
|
|
c->_c.mfc_un.res.wrong_if++;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-04-13 13:03:22 +08:00
|
|
|
if (true_vifi >= 0 && mrt->mroute_do_assert &&
|
2005-04-17 06:20:36 +08:00
|
|
|
/* pimsm uses asserts, when switching from RPT to SPT,
|
2010-10-02 00:15:29 +08: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-17 06:20:36 +08:00
|
|
|
*/
|
2010-04-13 13:03:22 +08:00
|
|
|
(mrt->mroute_do_pim ||
|
2018-03-01 05:29:34 +08:00
|
|
|
c->_c.mfc_un.res.ttls[true_vifi] < 255) &&
|
2007-02-09 22:24:47 +08:00
|
|
|
time_after(jiffies,
|
2018-03-01 05:29:34 +08:00
|
|
|
c->_c.mfc_un.res.last_assert +
|
|
|
|
MFC_ASSERT_THRESH)) {
|
|
|
|
c->_c.mfc_un.res.last_assert = jiffies;
|
2010-04-13 13:03:22 +08:00
|
|
|
ipmr_cache_report(mrt, skb, true_vifi, IGMPMSG_WRONGVIF);
|
2018-07-13 17:16:43 +08:00
|
|
|
if (mrt->mroute_do_wrvifwhole)
|
|
|
|
ipmr_cache_report(mrt, skb, true_vifi,
|
|
|
|
IGMPMSG_WRVIFWHOLE);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
goto dont_forward;
|
|
|
|
}
|
|
|
|
|
2013-01-21 14:00:26 +08:00
|
|
|
forward:
|
2022-06-23 12:34:36 +08:00
|
|
|
WRITE_ONCE(mrt->vif_table[vif].pkt_in,
|
|
|
|
mrt->vif_table[vif].pkt_in + 1);
|
|
|
|
WRITE_ONCE(mrt->vif_table[vif].bytes_in,
|
|
|
|
mrt->vif_table[vif].bytes_in + skb->len);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Forward the frame */
|
2018-03-01 05:29:34 +08:00
|
|
|
if (c->mfc_origin == htonl(INADDR_ANY) &&
|
|
|
|
c->mfc_mcastgrp == htonl(INADDR_ANY)) {
|
2013-01-21 14:00:26 +08:00
|
|
|
if (true_vifi >= 0 &&
|
2018-03-01 05:29:34 +08:00
|
|
|
true_vifi != c->_c.mfc_parent &&
|
2013-01-21 14:00:26 +08:00
|
|
|
ip_hdr(skb)->ttl >
|
2018-03-01 05:29:34 +08:00
|
|
|
c->_c.mfc_un.res.ttls[c->_c.mfc_parent]) {
|
2013-01-21 14:00:26 +08:00
|
|
|
/* It's an (*,*) entry and the packet is not coming from
|
|
|
|
* the upstream: forward the packet to the upstream
|
|
|
|
* only.
|
|
|
|
*/
|
2018-03-01 05:29:34 +08:00
|
|
|
psend = c->_c.mfc_parent;
|
2013-01-21 14:00:26 +08:00
|
|
|
goto last_forward;
|
|
|
|
}
|
|
|
|
goto dont_forward;
|
|
|
|
}
|
2018-03-01 05:29:34 +08:00
|
|
|
for (ct = c->_c.mfc_un.res.maxvif - 1;
|
|
|
|
ct >= c->_c.mfc_un.res.minvif; ct--) {
|
2013-01-21 14:00:26 +08:00
|
|
|
/* For (*,G) entry, don't forward to the incoming interface */
|
2018-03-01 05:29:34 +08:00
|
|
|
if ((c->mfc_origin != htonl(INADDR_ANY) ||
|
2013-01-22 18:18:03 +08:00
|
|
|
ct != true_vifi) &&
|
2018-03-01 05:29:34 +08:00
|
|
|
ip_hdr(skb)->ttl > c->_c.mfc_un.res.ttls[ct]) {
|
2005-04-17 06:20:36 +08:00
|
|
|
if (psend != -1) {
|
|
|
|
struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
|
2010-10-02 00:15:29 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (skb2)
|
2017-10-03 15:58:08 +08:00
|
|
|
ipmr_queue_xmit(net, mrt, true_vifi,
|
2018-12-18 07:34:48 +08:00
|
|
|
skb2, psend);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-11-03 16:28:02 +08:00
|
|
|
psend = ct;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
2013-01-21 14:00:26 +08:00
|
|
|
last_forward:
|
2005-04-17 06:20:36 +08:00
|
|
|
if (psend != -1) {
|
|
|
|
if (local) {
|
|
|
|
struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
|
2010-10-02 00:15:29 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (skb2)
|
2017-10-03 15:58:08 +08:00
|
|
|
ipmr_queue_xmit(net, mrt, true_vifi, skb2,
|
2018-12-18 07:34:48 +08:00
|
|
|
psend);
|
2005-04-17 06:20:36 +08:00
|
|
|
} else {
|
2018-12-18 07:34:48 +08:00
|
|
|
ipmr_queue_xmit(net, mrt, true_vifi, skb, psend);
|
2013-07-20 20:09:28 +08:00
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dont_forward:
|
|
|
|
if (!local)
|
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
|
|
|
|
2011-05-04 10:42:43 +08:00
|
|
|
static struct mr_table *ipmr_rt_fib_lookup(struct net *net, struct sk_buff *skb)
|
2011-03-10 06:06:20 +08:00
|
|
|
{
|
2011-05-04 10:42:43 +08:00
|
|
|
struct rtable *rt = skb_rtable(skb);
|
|
|
|
struct iphdr *iph = ip_hdr(skb);
|
2011-03-12 15:04:50 +08:00
|
|
|
struct flowi4 fl4 = {
|
2011-05-04 10:42:43 +08:00
|
|
|
.daddr = iph->daddr,
|
|
|
|
.saddr = iph->saddr,
|
2011-07-23 10:00:41 +08:00
|
|
|
.flowi4_tos = RT_TOS(iph->tos),
|
2012-07-18 05:39:44 +08:00
|
|
|
.flowi4_oif = (rt_is_output_route(rt) ?
|
|
|
|
skb->dev->ifindex : 0),
|
|
|
|
.flowi4_iif = (rt_is_output_route(rt) ?
|
2012-08-09 05:53:36 +08:00
|
|
|
LOOPBACK_IFINDEX :
|
2012-07-18 05:39:44 +08:00
|
|
|
skb->dev->ifindex),
|
2012-07-01 10:03:01 +08:00
|
|
|
.flowi4_mark = skb->mark,
|
2011-03-10 06:06:20 +08:00
|
|
|
};
|
|
|
|
struct mr_table *mrt;
|
|
|
|
int err;
|
|
|
|
|
2011-03-12 15:04:50 +08:00
|
|
|
err = ipmr_fib_lookup(net, &fl4, &mrt);
|
2011-03-10 06:06:20 +08:00
|
|
|
if (err)
|
|
|
|
return ERR_PTR(err);
|
|
|
|
return mrt;
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Multicast packets for forwarding arrive here
|
|
|
|
* Called with rcu_read_lock();
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
int ip_mr_input(struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
struct mfc_cache *cache;
|
2009-01-22 12:56:23 +08:00
|
|
|
struct net *net = dev_net(skb->dev);
|
2009-06-02 13:14:27 +08: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-13 13:03:23 +08:00
|
|
|
struct mr_table *mrt;
|
2017-05-16 06:14:44 +08:00
|
|
|
struct net_device *dev;
|
|
|
|
|
|
|
|
/* skb->dev passed in is the loX master dev for vrfs.
|
|
|
|
* As there are no vifs associated with loopback devices,
|
|
|
|
* get the proper interface that does have a vif associated with it.
|
|
|
|
*/
|
|
|
|
dev = skb->dev;
|
|
|
|
if (netif_is_l3_master(skb->dev)) {
|
|
|
|
dev = dev_get_by_index_rcu(net, IPCB(skb)->iif);
|
|
|
|
if (!dev) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
/* Packet is looped back after forward, it should not be
|
2010-10-02 00:15:29 +08:00
|
|
|
* forwarded second time, but still can be delivered locally.
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
2010-10-02 00:15:01 +08:00
|
|
|
if (IPCB(skb)->flags & IPSKB_FORWARDED)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto dont_forward;
|
|
|
|
|
2011-05-04 10:42:43 +08:00
|
|
|
mrt = ipmr_rt_fib_lookup(net, skb);
|
2011-03-10 06:06:20 +08:00
|
|
|
if (IS_ERR(mrt)) {
|
|
|
|
kfree_skb(skb);
|
|
|
|
return PTR_ERR(mrt);
|
2010-07-15 21:22:33 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!local) {
|
2010-10-02 00:15:01 +08: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) {
|
2019-09-30 02:54:03 +08:00
|
|
|
nf_reset_ct(skb);
|
2010-10-02 00:15:01 +08:00
|
|
|
raw_rcv(mroute_sk, skb);
|
|
|
|
return 0;
|
|
|
|
}
|
2021-07-08 02:18:33 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
2010-10-02 00:15:08 +08:00
|
|
|
/* already under rcu_read_lock() */
|
2010-04-13 13:03:22 +08:00
|
|
|
cache = ipmr_cache_find(mrt, ip_hdr(skb)->saddr, ip_hdr(skb)->daddr);
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!cache) {
|
2017-05-16 06:14:44 +08:00
|
|
|
int vif = ipmr_find_vif(mrt, dev);
|
2013-01-21 14:00:26 +08:00
|
|
|
|
|
|
|
if (vif >= 0)
|
|
|
|
cache = ipmr_cache_find_any(mrt, ip_hdr(skb)->daddr,
|
|
|
|
vif);
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* No usable cache entry */
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!cache) {
|
2005-04-17 06:20:36 +08:00
|
|
|
int vif;
|
|
|
|
|
|
|
|
if (local) {
|
|
|
|
struct sk_buff *skb2 = skb_clone(skb, GFP_ATOMIC);
|
|
|
|
ip_local_deliver(skb);
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!skb2)
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENOBUFS;
|
|
|
|
skb = skb2;
|
|
|
|
}
|
|
|
|
|
2017-05-16 06:14:44 +08:00
|
|
|
vif = ipmr_find_vif(mrt, dev);
|
2022-06-23 12:34:37 +08:00
|
|
|
if (vif >= 0)
|
|
|
|
return ipmr_cache_unresolved(mrt, vif, skb, dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
kfree_skb(skb);
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2017-06-11 04:30:17 +08:00
|
|
|
ip_mr_forward(net, mrt, dev, skb, cache, local);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
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 17:15:11 +08:00
|
|
|
#ifdef CONFIG_IP_PIMSM_V1
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Handle IGMP messages of PIMv1 */
|
2010-10-02 00:15:29 +08: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 17:15:11 +08:00
|
|
|
{
|
|
|
|
struct igmphdr *pim;
|
2009-01-22 12:56:23 +08: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-13 13:03:23 +08: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 17:15:11 +08:00
|
|
|
|
|
|
|
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
|
|
|
|
goto drop;
|
|
|
|
|
|
|
|
pim = igmp_hdr(skb);
|
|
|
|
|
2011-05-04 10:42:43 +08:00
|
|
|
mrt = ipmr_rt_fib_lookup(net, skb);
|
2011-03-10 06:06:20 +08:00
|
|
|
if (IS_ERR(mrt))
|
|
|
|
goto drop;
|
2010-04-13 13:03:22 +08: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 17:15:11 +08: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-13 13:03:23 +08: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 17:15:11 +08:00
|
|
|
drop:
|
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_IP_PIMSM_V2
|
2010-10-02 00:15:29 +08:00
|
|
|
static int pim_rcv(struct sk_buff *skb)
|
2005-04-17 06:20:36 +08: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-13 13:03:23 +08:00
|
|
|
struct net *net = dev_net(skb->dev);
|
|
|
|
struct mr_table *mrt;
|
2005-04-17 06:20:36 +08: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 17:15:11 +08:00
|
|
|
if (!pskb_may_pull(skb, sizeof(*pim) + sizeof(struct iphdr)))
|
2005-04-17 06:20:36 +08:00
|
|
|
goto drop;
|
|
|
|
|
2007-04-26 09:04:18 +08:00
|
|
|
pim = (struct pimreghdr *)skb_transport_header(skb);
|
2016-10-31 20:21:04 +08:00
|
|
|
if (pim->type != ((PIM_VERSION << 4) | (PIM_TYPE_REGISTER)) ||
|
2010-10-02 00:15:29 +08:00
|
|
|
(pim->flags & PIM_NULL_REGISTER) ||
|
2007-02-09 22:24:47 +08:00
|
|
|
(ip_compute_csum((void *)pim, sizeof(*pim)) != 0 &&
|
2006-11-15 13:24:49 +08:00
|
|
|
csum_fold(skb_checksum(skb, 0, skb->len, 0))))
|
2005-04-17 06:20:36 +08:00
|
|
|
goto drop;
|
|
|
|
|
2011-05-04 10:42:43 +08:00
|
|
|
mrt = ipmr_rt_fib_lookup(net, skb);
|
2011-03-10 06:06:20 +08: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-13 13:03:23 +08: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 17:15:11 +08:00
|
|
|
drop:
|
|
|
|
kfree_skb(skb);
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2011-05-05 03:18:54 +08:00
|
|
|
int ipmr_get_route(struct net *net, struct sk_buff *skb,
|
|
|
|
__be32 saddr, __be32 daddr,
|
2017-01-07 09:39:06 +08:00
|
|
|
struct rtmsg *rtm, u32 portid)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
struct mfc_cache *cache;
|
2011-05-05 03:18:54 +08:00
|
|
|
struct mr_table *mrt;
|
|
|
|
int err;
|
2005-04-17 06:20:36 +08: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-13 13:03:23 +08:00
|
|
|
mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!mrt)
|
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-13 13:03:23 +08:00
|
|
|
return -ENOENT;
|
|
|
|
|
2010-10-02 00:15:08 +08:00
|
|
|
rcu_read_lock();
|
2011-05-05 03:18:54 +08:00
|
|
|
cache = ipmr_cache_find(mrt, saddr, daddr);
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!cache && skb->dev) {
|
2013-01-21 14:00:26 +08:00
|
|
|
int vif = ipmr_find_vif(mrt, skb->dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2013-01-21 14:00:26 +08:00
|
|
|
if (vif >= 0)
|
|
|
|
cache = ipmr_cache_find_any(mrt, daddr, vif);
|
|
|
|
}
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!cache) {
|
2006-07-26 07:45:12 +08:00
|
|
|
struct sk_buff *skb2;
|
2007-04-21 13:47:35 +08:00
|
|
|
struct iphdr *iph;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct net_device *dev;
|
2010-10-02 00:15:29 +08:00
|
|
|
int vif = -1;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
dev = skb->dev;
|
2010-10-02 00:15:29 +08:00
|
|
|
if (dev)
|
|
|
|
vif = ipmr_find_vif(mrt, dev);
|
|
|
|
if (vif < 0) {
|
2010-10-02 00:15:08 +08:00
|
|
|
rcu_read_unlock();
|
2005-04-17 06:20:36 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
ipmr: Fix skb headroom in ipmr_get_route().
In route.c, inet_rtm_getroute_build_skb() creates an skb with no
headroom. This skb is then used by inet_rtm_getroute() which may pass
it to rt_fill_info() and, from there, to ipmr_get_route(). The later
might try to reuse this skb by cloning it and prepending an IPv4
header. But since the original skb has no headroom, skb_push() triggers
skb_under_panic():
skbuff: skb_under_panic: text:00000000ca46ad8a len:80 put:20 head:00000000cd28494e data:000000009366fd6b tail:0x3c end:0xec0 dev:veth0
------------[ cut here ]------------
kernel BUG at net/core/skbuff.c:108!
invalid opcode: 0000 [#1] SMP KASAN PTI
CPU: 6 PID: 587 Comm: ip Not tainted 5.4.0-rc6+ #1
Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.12.0-2.fc30 04/01/2014
RIP: 0010:skb_panic+0xbf/0xd0
Code: 41 a2 ff 8b 4b 70 4c 8b 4d d0 48 c7 c7 20 76 f5 8b 44 8b 45 bc 48 8b 55 c0 48 8b 75 c8 41 54 41 57 41 56 41 55 e8 75 dc 7a ff <0f> 0b 0f 1f 44 00 00 66 2e 0f 1f 84 00 00 00 00 00 0f 1f 44 00 00
RSP: 0018:ffff888059ddf0b0 EFLAGS: 00010286
RAX: 0000000000000086 RBX: ffff888060a315c0 RCX: ffffffff8abe4822
RDX: 0000000000000000 RSI: 0000000000000008 RDI: ffff88806c9a79cc
RBP: ffff888059ddf118 R08: ffffed100d9361b1 R09: ffffed100d9361b0
R10: ffff88805c68aee3 R11: ffffed100d9361b1 R12: ffff88805d218000
R13: ffff88805c689fec R14: 000000000000003c R15: 0000000000000ec0
FS: 00007f6af184b700(0000) GS:ffff88806c980000(0000) knlGS:0000000000000000
CS: 0010 DS: 0000 ES: 0000 CR0: 0000000080050033
CR2: 00007ffc8204a000 CR3: 0000000057b40006 CR4: 0000000000360ee0
DR0: 0000000000000000 DR1: 0000000000000000 DR2: 0000000000000000
DR3: 0000000000000000 DR6: 00000000fffe0ff0 DR7: 0000000000000400
Call Trace:
skb_push+0x7e/0x80
ipmr_get_route+0x459/0x6fa
rt_fill_info+0x692/0x9f0
inet_rtm_getroute+0xd26/0xf20
rtnetlink_rcv_msg+0x45d/0x630
netlink_rcv_skb+0x1a5/0x220
rtnetlink_rcv+0x15/0x20
netlink_unicast+0x305/0x3a0
netlink_sendmsg+0x575/0x730
sock_sendmsg+0xb5/0xc0
___sys_sendmsg+0x497/0x4f0
__sys_sendmsg+0xcb/0x150
__x64_sys_sendmsg+0x48/0x50
do_syscall_64+0xd2/0xac0
entry_SYSCALL_64_after_hwframe+0x49/0xbe
Actually the original skb used to have enough headroom, but the
reserve_skb() call was lost with the introduction of
inet_rtm_getroute_build_skb() by commit 404eb77ea766 ("ipv4: support
sport, dport and ip_proto in RTM_GETROUTE").
We could reserve some headroom again in inet_rtm_getroute_build_skb(),
but this function shouldn't be responsible for handling the special
case of ipmr_get_route(). Let's handle that directly in
ipmr_get_route() by calling skb_realloc_headroom() instead of
skb_clone().
Fixes: 404eb77ea766 ("ipv4: support sport, dport and ip_proto in RTM_GETROUTE")
Signed-off-by: Guillaume Nault <gnault@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-11-16 01:29:52 +08:00
|
|
|
|
|
|
|
skb2 = skb_realloc_headroom(skb, sizeof(struct iphdr));
|
2006-07-26 07:45:12 +08:00
|
|
|
if (!skb2) {
|
2010-10-02 00:15:08 +08:00
|
|
|
rcu_read_unlock();
|
2006-07-26 07:45:12 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
|
2016-09-26 05:08:31 +08:00
|
|
|
NETLINK_CB(skb2).portid = portid;
|
2007-04-11 11:46:21 +08:00
|
|
|
skb_push(skb2, sizeof(struct iphdr));
|
|
|
|
skb_reset_network_header(skb2);
|
2007-04-21 13:47:35 +08:00
|
|
|
iph = ip_hdr(skb2);
|
|
|
|
iph->ihl = sizeof(struct iphdr) >> 2;
|
2011-05-05 03:18:54 +08:00
|
|
|
iph->saddr = saddr;
|
|
|
|
iph->daddr = daddr;
|
2007-04-21 13:47:35 +08:00
|
|
|
iph->version = 0;
|
2017-06-11 04:30:17 +08:00
|
|
|
err = ipmr_cache_unresolved(mrt, vif, skb2, dev);
|
2010-10-02 00:15:08 +08:00
|
|
|
rcu_read_unlock();
|
2005-04-17 06:20:36 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2018-03-01 05:29:39 +08:00
|
|
|
err = mr_fill_mroute(mrt, skb, &cache->_c, rtm);
|
2010-10-02 00:15:08 +08:00
|
|
|
rcu_read_unlock();
|
2005-04-17 06:20:36 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2010-04-26 22:02:08 +08:00
|
|
|
static int ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
|
2014-03-20 00:47:50 +08:00
|
|
|
u32 portid, u32 seq, struct mfc_cache *c, int cmd,
|
|
|
|
int flags)
|
2010-04-26 22:02:08 +08:00
|
|
|
{
|
|
|
|
struct nlmsghdr *nlh;
|
|
|
|
struct rtmsg *rtm;
|
2012-12-04 09:13:39 +08:00
|
|
|
int err;
|
2010-04-26 22:02:08 +08:00
|
|
|
|
2014-03-20 00:47:50 +08:00
|
|
|
nlh = nlmsg_put(skb, portid, seq, cmd, sizeof(*rtm), flags);
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!nlh)
|
2010-04-26 22:02:08 +08:00
|
|
|
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-02 08:39:02 +08:00
|
|
|
if (nla_put_u32(skb, RTA_TABLE, mrt->id))
|
|
|
|
goto nla_put_failure;
|
2010-04-26 22:02:08 +08:00
|
|
|
rtm->rtm_type = RTN_MULTICAST;
|
|
|
|
rtm->rtm_scope = RT_SCOPE_UNIVERSE;
|
2018-03-01 05:29:34 +08:00
|
|
|
if (c->_c.mfc_flags & MFC_STATIC)
|
2012-12-04 09:13:38 +08:00
|
|
|
rtm->rtm_protocol = RTPROT_STATIC;
|
|
|
|
else
|
|
|
|
rtm->rtm_protocol = RTPROT_MROUTED;
|
2010-04-26 22:02:08 +08:00
|
|
|
rtm->rtm_flags = 0;
|
|
|
|
|
2015-03-29 22:59:25 +08:00
|
|
|
if (nla_put_in_addr(skb, RTA_SRC, c->mfc_origin) ||
|
|
|
|
nla_put_in_addr(skb, RTA_DST, c->mfc_mcastgrp))
|
2012-04-02 08:39:02 +08:00
|
|
|
goto nla_put_failure;
|
2018-03-01 05:29:39 +08:00
|
|
|
err = mr_fill_mroute(mrt, skb, &c->_c, rtm);
|
2012-12-04 09:13:39 +08:00
|
|
|
/* do not break the dump if cache is unresolved */
|
|
|
|
if (err < 0 && err != -ENOENT)
|
2010-04-26 22:02:08 +08:00
|
|
|
goto nla_put_failure;
|
|
|
|
|
2015-01-17 05:09:00 +08:00
|
|
|
nlmsg_end(skb, nlh);
|
|
|
|
return 0;
|
2010-04-26 22:02:08 +08:00
|
|
|
|
|
|
|
nla_put_failure:
|
|
|
|
nlmsg_cancel(skb, nlh);
|
|
|
|
return -EMSGSIZE;
|
|
|
|
}
|
|
|
|
|
2018-03-01 05:29:39 +08:00
|
|
|
static int _ipmr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
|
|
|
|
u32 portid, u32 seq, struct mr_mfc *c, int cmd,
|
|
|
|
int flags)
|
|
|
|
{
|
|
|
|
return ipmr_fill_mroute(mrt, skb, portid, seq, (struct mfc_cache *)c,
|
|
|
|
cmd, flags);
|
|
|
|
}
|
|
|
|
|
2012-12-04 09:13:40 +08:00
|
|
|
static size_t mroute_msgsize(bool unresolved, int maxvif)
|
|
|
|
{
|
|
|
|
size_t len =
|
|
|
|
NLMSG_ALIGN(sizeof(struct rtmsg))
|
|
|
|
+ nla_total_size(4) /* RTA_TABLE */
|
|
|
|
+ nla_total_size(4) /* RTA_SRC */
|
|
|
|
+ nla_total_size(4) /* RTA_DST */
|
|
|
|
;
|
|
|
|
|
|
|
|
if (!unresolved)
|
|
|
|
len = len
|
|
|
|
+ nla_total_size(4) /* RTA_IIF */
|
|
|
|
+ nla_total_size(0) /* RTA_MULTIPATH */
|
|
|
|
+ maxvif * NLA_ALIGN(sizeof(struct rtnexthop))
|
|
|
|
/* RTA_MFC_STATS */
|
2016-04-22 00:58:26 +08:00
|
|
|
+ nla_total_size_64bit(sizeof(struct rta_mfc_stats))
|
2012-12-04 09:13:40 +08:00
|
|
|
;
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void mroute_netlink_event(struct mr_table *mrt, struct mfc_cache *mfc,
|
|
|
|
int cmd)
|
|
|
|
{
|
|
|
|
struct net *net = read_pnet(&mrt->net);
|
|
|
|
struct sk_buff *skb;
|
|
|
|
int err = -ENOBUFS;
|
|
|
|
|
2018-03-01 05:29:34 +08:00
|
|
|
skb = nlmsg_new(mroute_msgsize(mfc->_c.mfc_parent >= MAXVIFS,
|
|
|
|
mrt->maxvif),
|
2012-12-04 09:13:40 +08:00
|
|
|
GFP_ATOMIC);
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!skb)
|
2012-12-04 09:13:40 +08:00
|
|
|
goto errout;
|
|
|
|
|
2014-03-20 00:47:50 +08:00
|
|
|
err = ipmr_fill_mroute(mrt, skb, 0, 0, mfc, cmd, 0);
|
2012-12-04 09:13:40 +08:00
|
|
|
if (err < 0)
|
|
|
|
goto errout;
|
|
|
|
|
|
|
|
rtnl_notify(skb, net, 0, RTNLGRP_IPV4_MROUTE, NULL, GFP_ATOMIC);
|
|
|
|
return;
|
|
|
|
|
|
|
|
errout:
|
|
|
|
kfree_skb(skb);
|
|
|
|
if (err < 0)
|
|
|
|
rtnl_set_sk_err(net, RTNLGRP_IPV4_MROUTE, err);
|
|
|
|
}
|
|
|
|
|
2017-06-21 04:54:17 +08:00
|
|
|
static size_t igmpmsg_netlink_msgsize(size_t payloadlen)
|
|
|
|
{
|
|
|
|
size_t len =
|
|
|
|
NLMSG_ALIGN(sizeof(struct rtgenmsg))
|
|
|
|
+ nla_total_size(1) /* IPMRA_CREPORT_MSGTYPE */
|
|
|
|
+ nla_total_size(4) /* IPMRA_CREPORT_VIF_ID */
|
|
|
|
+ nla_total_size(4) /* IPMRA_CREPORT_SRC_ADDR */
|
|
|
|
+ nla_total_size(4) /* IPMRA_CREPORT_DST_ADDR */
|
2020-09-08 06:04:06 +08:00
|
|
|
+ nla_total_size(4) /* IPMRA_CREPORT_TABLE */
|
2017-06-21 04:54:17 +08:00
|
|
|
/* IPMRA_CREPORT_PKT */
|
|
|
|
+ nla_total_size(payloadlen)
|
|
|
|
;
|
|
|
|
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2022-06-23 12:34:33 +08:00
|
|
|
static void igmpmsg_netlink_event(const struct mr_table *mrt, struct sk_buff *pkt)
|
2017-06-21 04:54:17 +08:00
|
|
|
{
|
|
|
|
struct net *net = read_pnet(&mrt->net);
|
|
|
|
struct nlmsghdr *nlh;
|
|
|
|
struct rtgenmsg *rtgenm;
|
|
|
|
struct igmpmsg *msg;
|
|
|
|
struct sk_buff *skb;
|
|
|
|
struct nlattr *nla;
|
|
|
|
int payloadlen;
|
|
|
|
|
|
|
|
payloadlen = pkt->len - sizeof(struct igmpmsg);
|
|
|
|
msg = (struct igmpmsg *)skb_network_header(pkt);
|
|
|
|
|
|
|
|
skb = nlmsg_new(igmpmsg_netlink_msgsize(payloadlen), GFP_ATOMIC);
|
|
|
|
if (!skb)
|
|
|
|
goto errout;
|
|
|
|
|
|
|
|
nlh = nlmsg_put(skb, 0, 0, RTM_NEWCACHEREPORT,
|
|
|
|
sizeof(struct rtgenmsg), 0);
|
|
|
|
if (!nlh)
|
|
|
|
goto errout;
|
|
|
|
rtgenm = nlmsg_data(nlh);
|
|
|
|
rtgenm->rtgen_family = RTNL_FAMILY_IPMR;
|
|
|
|
if (nla_put_u8(skb, IPMRA_CREPORT_MSGTYPE, msg->im_msgtype) ||
|
2020-09-08 06:04:08 +08:00
|
|
|
nla_put_u32(skb, IPMRA_CREPORT_VIF_ID, msg->im_vif | (msg->im_vif_hi << 8)) ||
|
2017-06-21 04:54:17 +08:00
|
|
|
nla_put_in_addr(skb, IPMRA_CREPORT_SRC_ADDR,
|
|
|
|
msg->im_src.s_addr) ||
|
|
|
|
nla_put_in_addr(skb, IPMRA_CREPORT_DST_ADDR,
|
2020-09-08 06:04:06 +08:00
|
|
|
msg->im_dst.s_addr) ||
|
|
|
|
nla_put_u32(skb, IPMRA_CREPORT_TABLE, mrt->id))
|
2017-06-21 04:54:17 +08:00
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
|
|
nla = nla_reserve(skb, IPMRA_CREPORT_PKT, payloadlen);
|
|
|
|
if (!nla || skb_copy_bits(pkt, sizeof(struct igmpmsg),
|
|
|
|
nla_data(nla), payloadlen))
|
|
|
|
goto nla_put_failure;
|
|
|
|
|
|
|
|
nlmsg_end(skb, nlh);
|
|
|
|
|
|
|
|
rtnl_notify(skb, net, 0, RTNLGRP_IPV4_MROUTE_R, NULL, GFP_ATOMIC);
|
|
|
|
return;
|
|
|
|
|
|
|
|
nla_put_failure:
|
|
|
|
nlmsg_cancel(skb, nlh);
|
|
|
|
errout:
|
|
|
|
kfree_skb(skb);
|
|
|
|
rtnl_set_sk_err(net, RTNLGRP_IPV4_MROUTE_R, -ENOBUFS);
|
|
|
|
}
|
|
|
|
|
2019-01-19 02:46:20 +08:00
|
|
|
static int ipmr_rtm_valid_getroute_req(struct sk_buff *skb,
|
|
|
|
const struct nlmsghdr *nlh,
|
|
|
|
struct nlattr **tb,
|
|
|
|
struct netlink_ext_ack *extack)
|
|
|
|
{
|
|
|
|
struct rtmsg *rtm;
|
|
|
|
int i, err;
|
|
|
|
|
|
|
|
if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*rtm))) {
|
|
|
|
NL_SET_ERR_MSG(extack, "ipv4: Invalid header for multicast route get request");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!netlink_strict_get_check(skb))
|
netlink: make validation more configurable for future strictness
We currently have two levels of strict validation:
1) liberal (default)
- undefined (type >= max) & NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
- garbage at end of message accepted
2) strict (opt-in)
- NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
Split out parsing strictness into four different options:
* TRAILING - check that there's no trailing data after parsing
attributes (in message or nested)
* MAXTYPE - reject attrs > max known type
* UNSPEC - reject attributes with NLA_UNSPEC policy entries
* STRICT_ATTRS - strictly validate attribute size
The default for future things should be *everything*.
The current *_strict() is a combination of TRAILING and MAXTYPE,
and is renamed to _deprecated_strict().
The current regular parsing has none of this, and is renamed to
*_parse_deprecated().
Additionally it allows us to selectively set one of the new flags
even on old policies. Notably, the UNSPEC flag could be useful in
this case, since it can be arranged (by filling in the policy) to
not be an incompatible userspace ABI change, but would then going
forward prevent forgetting attribute entries. Similar can apply
to the POLICY flag.
We end up with the following renames:
* nla_parse -> nla_parse_deprecated
* nla_parse_strict -> nla_parse_deprecated_strict
* nlmsg_parse -> nlmsg_parse_deprecated
* nlmsg_parse_strict -> nlmsg_parse_deprecated_strict
* nla_parse_nested -> nla_parse_nested_deprecated
* nla_validate_nested -> nla_validate_nested_deprecated
Using spatch, of course:
@@
expression TB, MAX, HEAD, LEN, POL, EXT;
@@
-nla_parse(TB, MAX, HEAD, LEN, POL, EXT)
+nla_parse_deprecated(TB, MAX, HEAD, LEN, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression TB, MAX, NLA, POL, EXT;
@@
-nla_parse_nested(TB, MAX, NLA, POL, EXT)
+nla_parse_nested_deprecated(TB, MAX, NLA, POL, EXT)
@@
expression START, MAX, POL, EXT;
@@
-nla_validate_nested(START, MAX, POL, EXT)
+nla_validate_nested_deprecated(START, MAX, POL, EXT)
@@
expression NLH, HDRLEN, MAX, POL, EXT;
@@
-nlmsg_validate(NLH, HDRLEN, MAX, POL, EXT)
+nlmsg_validate_deprecated(NLH, HDRLEN, MAX, POL, EXT)
For this patch, don't actually add the strict, non-renamed versions
yet so that it breaks compile if I get it wrong.
Also, while at it, make nla_validate and nla_parse go down to a
common __nla_validate_parse() function to avoid code duplication.
Ultimately, this allows us to have very strict validation for every
new caller of nla_parse()/nlmsg_parse() etc as re-introduced in the
next patch, while existing things will continue to work as is.
In effect then, this adds fully strict validation for any new command.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-04-26 20:07:28 +08:00
|
|
|
return nlmsg_parse_deprecated(nlh, sizeof(*rtm), tb, RTA_MAX,
|
|
|
|
rtm_ipv4_policy, extack);
|
2019-01-19 02:46:20 +08:00
|
|
|
|
|
|
|
rtm = nlmsg_data(nlh);
|
|
|
|
if ((rtm->rtm_src_len && rtm->rtm_src_len != 32) ||
|
|
|
|
(rtm->rtm_dst_len && rtm->rtm_dst_len != 32) ||
|
|
|
|
rtm->rtm_tos || rtm->rtm_table || rtm->rtm_protocol ||
|
|
|
|
rtm->rtm_scope || rtm->rtm_type || rtm->rtm_flags) {
|
|
|
|
NL_SET_ERR_MSG(extack, "ipv4: Invalid values in header for multicast route get request");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
netlink: make validation more configurable for future strictness
We currently have two levels of strict validation:
1) liberal (default)
- undefined (type >= max) & NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
- garbage at end of message accepted
2) strict (opt-in)
- NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
Split out parsing strictness into four different options:
* TRAILING - check that there's no trailing data after parsing
attributes (in message or nested)
* MAXTYPE - reject attrs > max known type
* UNSPEC - reject attributes with NLA_UNSPEC policy entries
* STRICT_ATTRS - strictly validate attribute size
The default for future things should be *everything*.
The current *_strict() is a combination of TRAILING and MAXTYPE,
and is renamed to _deprecated_strict().
The current regular parsing has none of this, and is renamed to
*_parse_deprecated().
Additionally it allows us to selectively set one of the new flags
even on old policies. Notably, the UNSPEC flag could be useful in
this case, since it can be arranged (by filling in the policy) to
not be an incompatible userspace ABI change, but would then going
forward prevent forgetting attribute entries. Similar can apply
to the POLICY flag.
We end up with the following renames:
* nla_parse -> nla_parse_deprecated
* nla_parse_strict -> nla_parse_deprecated_strict
* nlmsg_parse -> nlmsg_parse_deprecated
* nlmsg_parse_strict -> nlmsg_parse_deprecated_strict
* nla_parse_nested -> nla_parse_nested_deprecated
* nla_validate_nested -> nla_validate_nested_deprecated
Using spatch, of course:
@@
expression TB, MAX, HEAD, LEN, POL, EXT;
@@
-nla_parse(TB, MAX, HEAD, LEN, POL, EXT)
+nla_parse_deprecated(TB, MAX, HEAD, LEN, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression TB, MAX, NLA, POL, EXT;
@@
-nla_parse_nested(TB, MAX, NLA, POL, EXT)
+nla_parse_nested_deprecated(TB, MAX, NLA, POL, EXT)
@@
expression START, MAX, POL, EXT;
@@
-nla_validate_nested(START, MAX, POL, EXT)
+nla_validate_nested_deprecated(START, MAX, POL, EXT)
@@
expression NLH, HDRLEN, MAX, POL, EXT;
@@
-nlmsg_validate(NLH, HDRLEN, MAX, POL, EXT)
+nlmsg_validate_deprecated(NLH, HDRLEN, MAX, POL, EXT)
For this patch, don't actually add the strict, non-renamed versions
yet so that it breaks compile if I get it wrong.
Also, while at it, make nla_validate and nla_parse go down to a
common __nla_validate_parse() function to avoid code duplication.
Ultimately, this allows us to have very strict validation for every
new caller of nla_parse()/nlmsg_parse() etc as re-introduced in the
next patch, while existing things will continue to work as is.
In effect then, this adds fully strict validation for any new command.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-04-26 20:07:28 +08:00
|
|
|
err = nlmsg_parse_deprecated_strict(nlh, sizeof(*rtm), tb, RTA_MAX,
|
|
|
|
rtm_ipv4_policy, extack);
|
2019-01-19 02:46:20 +08:00
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if ((tb[RTA_SRC] && !rtm->rtm_src_len) ||
|
|
|
|
(tb[RTA_DST] && !rtm->rtm_dst_len)) {
|
|
|
|
NL_SET_ERR_MSG(extack, "ipv4: rtm_src_len and rtm_dst_len must be 32 for IPv4");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i <= RTA_MAX; i++) {
|
|
|
|
if (!tb[i])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
switch (i) {
|
|
|
|
case RTA_SRC:
|
|
|
|
case RTA_DST:
|
|
|
|
case RTA_TABLE:
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
NL_SET_ERR_MSG(extack, "ipv4: Unsupported attribute in multicast route get request");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-06-29 01:58:57 +08:00
|
|
|
static int ipmr_rtm_getroute(struct sk_buff *in_skb, struct nlmsghdr *nlh,
|
|
|
|
struct netlink_ext_ack *extack)
|
|
|
|
{
|
|
|
|
struct net *net = sock_net(in_skb->sk);
|
|
|
|
struct nlattr *tb[RTA_MAX + 1];
|
|
|
|
struct sk_buff *skb = NULL;
|
|
|
|
struct mfc_cache *cache;
|
|
|
|
struct mr_table *mrt;
|
|
|
|
__be32 src, grp;
|
|
|
|
u32 tableid;
|
|
|
|
int err;
|
|
|
|
|
2019-01-19 02:46:20 +08:00
|
|
|
err = ipmr_rtm_valid_getroute_req(in_skb, nlh, tb, extack);
|
2017-06-29 01:58:57 +08:00
|
|
|
if (err < 0)
|
|
|
|
goto errout;
|
|
|
|
|
|
|
|
src = tb[RTA_SRC] ? nla_get_in_addr(tb[RTA_SRC]) : 0;
|
|
|
|
grp = tb[RTA_DST] ? nla_get_in_addr(tb[RTA_DST]) : 0;
|
|
|
|
tableid = tb[RTA_TABLE] ? nla_get_u32(tb[RTA_TABLE]) : 0;
|
|
|
|
|
|
|
|
mrt = ipmr_get_table(net, tableid ? tableid : RT_TABLE_DEFAULT);
|
2017-07-12 15:56:47 +08:00
|
|
|
if (!mrt) {
|
|
|
|
err = -ENOENT;
|
2017-06-29 01:58:57 +08:00
|
|
|
goto errout_free;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* entries are added/deleted only under RTNL */
|
|
|
|
rcu_read_lock();
|
|
|
|
cache = ipmr_cache_find(mrt, src, grp);
|
|
|
|
rcu_read_unlock();
|
|
|
|
if (!cache) {
|
|
|
|
err = -ENOENT;
|
|
|
|
goto errout_free;
|
|
|
|
}
|
|
|
|
|
|
|
|
skb = nlmsg_new(mroute_msgsize(false, mrt->maxvif), GFP_KERNEL);
|
|
|
|
if (!skb) {
|
|
|
|
err = -ENOBUFS;
|
|
|
|
goto errout_free;
|
|
|
|
}
|
|
|
|
|
|
|
|
err = ipmr_fill_mroute(mrt, skb, NETLINK_CB(in_skb).portid,
|
|
|
|
nlh->nlmsg_seq, cache,
|
|
|
|
RTM_NEWROUTE, 0);
|
|
|
|
if (err < 0)
|
|
|
|
goto errout_free;
|
|
|
|
|
|
|
|
err = rtnl_unicast(skb, net, NETLINK_CB(in_skb).portid);
|
|
|
|
|
|
|
|
errout:
|
|
|
|
return err;
|
|
|
|
|
|
|
|
errout_free:
|
|
|
|
kfree_skb(skb);
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
|
2010-04-26 22:02:08 +08:00
|
|
|
static int ipmr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
{
|
2018-10-16 09:56:42 +08:00
|
|
|
struct fib_dump_filter filter = {};
|
2018-10-16 09:56:47 +08:00
|
|
|
int err;
|
2018-10-16 09:56:42 +08:00
|
|
|
|
2018-10-08 11:16:35 +08:00
|
|
|
if (cb->strict_check) {
|
2018-10-16 09:56:42 +08:00
|
|
|
err = ip_valid_fib_dump_req(sock_net(skb->sk), cb->nlh,
|
2018-10-16 09:56:48 +08:00
|
|
|
&filter, cb);
|
2018-10-08 11:16:35 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2018-10-16 09:56:47 +08:00
|
|
|
if (filter.table_id) {
|
|
|
|
struct mr_table *mrt;
|
|
|
|
|
|
|
|
mrt = ipmr_get_table(sock_net(skb->sk), filter.table_id);
|
|
|
|
if (!mrt) {
|
net: don't return invalid table id error when we fall back to PF_UNSPEC
In case we can't find a ->dumpit callback for the requested
(family,type) pair, we fall back to (PF_UNSPEC,type). In effect, we're
in the same situation as if userspace had requested a PF_UNSPEC
dump. For RTM_GETROUTE, that handler is rtnl_dump_all, which calls all
the registered RTM_GETROUTE handlers.
The requested table id may or may not exist for all of those
families. commit ae677bbb4441 ("net: Don't return invalid table id
error when dumping all families") fixed the problem when userspace
explicitly requests a PF_UNSPEC dump, but missed the fallback case.
For example, when we pass ipv6.disable=1 to a kernel with
CONFIG_IP_MROUTE=y and CONFIG_IP_MROUTE_MULTIPLE_TABLES=y,
the (PF_INET6, RTM_GETROUTE) handler isn't registered, so we end up in
rtnl_dump_all, and listing IPv6 routes will unexpectedly print:
# ip -6 r
Error: ipv4: MR table does not exist.
Dump terminated
commit ae677bbb4441 introduced the dump_all_families variable, which
gets set when userspace requests a PF_UNSPEC dump. However, we can't
simply set the family to PF_UNSPEC in rtnetlink_rcv_msg in the
fallback case to get dump_all_families == true, because some messages
types (for example RTM_GETRULE and RTM_GETNEIGH) only register the
PF_UNSPEC handler and use the family to filter in the kernel what is
dumped to userspace. We would then export more entries, that userspace
would have to filter. iproute does that, but other programs may not.
Instead, this patch removes dump_all_families and updates the
RTM_GETROUTE handlers to check if the family that is being dumped is
their own. When it's not, which covers both the intentional PF_UNSPEC
dumps (as dump_all_families did) and the fallback case, ignore the
missing table id error.
Fixes: cb167893f41e ("net: Plumb support for filtering ipv4 and ipv6 multicast route dumps")
Signed-off-by: Sabrina Dubroca <sd@queasysnail.net>
Reviewed-by: David Ahern <dsahern@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2020-05-20 17:15:46 +08:00
|
|
|
if (rtnl_msg_family(cb->nlh) != RTNL_FAMILY_IPMR)
|
2018-10-25 03:59:01 +08:00
|
|
|
return skb->len;
|
|
|
|
|
2018-10-16 09:56:47 +08:00
|
|
|
NL_SET_ERR_MSG(cb->extack, "ipv4: MR table does not exist");
|
|
|
|
return -ENOENT;
|
|
|
|
}
|
|
|
|
err = mr_table_dump(mrt, skb, cb, _ipmr_fill_mroute,
|
|
|
|
&mfc_unres_lock, &filter);
|
|
|
|
return skb->len ? : err;
|
|
|
|
}
|
|
|
|
|
2018-03-01 05:29:39 +08:00
|
|
|
return mr_rtm_dumproute(skb, cb, ipmr_mr_table_iter,
|
2018-10-16 09:56:47 +08:00
|
|
|
_ipmr_fill_mroute, &mfc_unres_lock, &filter);
|
2010-04-26 22:02:08 +08:00
|
|
|
}
|
|
|
|
|
2015-11-26 22:23:50 +08:00
|
|
|
static const struct nla_policy rtm_ipmr_policy[RTA_MAX + 1] = {
|
|
|
|
[RTA_SRC] = { .type = NLA_U32 },
|
|
|
|
[RTA_DST] = { .type = NLA_U32 },
|
|
|
|
[RTA_IIF] = { .type = NLA_U32 },
|
|
|
|
[RTA_TABLE] = { .type = NLA_U32 },
|
|
|
|
[RTA_MULTIPATH] = { .len = sizeof(struct rtnexthop) },
|
|
|
|
};
|
|
|
|
|
|
|
|
static bool ipmr_rtm_validate_proto(unsigned char rtm_protocol)
|
|
|
|
{
|
|
|
|
switch (rtm_protocol) {
|
|
|
|
case RTPROT_STATIC:
|
|
|
|
case RTPROT_MROUTED:
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int ipmr_nla_get_ttls(const struct nlattr *nla, struct mfcctl *mfcc)
|
|
|
|
{
|
|
|
|
struct rtnexthop *rtnh = nla_data(nla);
|
|
|
|
int remaining = nla_len(nla), vifi = 0;
|
|
|
|
|
|
|
|
while (rtnh_ok(rtnh, remaining)) {
|
|
|
|
mfcc->mfcc_ttls[vifi] = rtnh->rtnh_hops;
|
|
|
|
if (++vifi == MAXVIFS)
|
|
|
|
break;
|
|
|
|
rtnh = rtnh_next(rtnh, &remaining);
|
|
|
|
}
|
|
|
|
|
|
|
|
return remaining > 0 ? -EINVAL : vifi;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* returns < 0 on error, 0 for ADD_MFC and 1 for ADD_MFC_PROXY */
|
|
|
|
static int rtm_to_ipmr_mfcc(struct net *net, struct nlmsghdr *nlh,
|
|
|
|
struct mfcctl *mfcc, int *mrtsock,
|
2017-04-17 00:48:24 +08:00
|
|
|
struct mr_table **mrtret,
|
|
|
|
struct netlink_ext_ack *extack)
|
2015-11-26 22:23:50 +08:00
|
|
|
{
|
|
|
|
struct net_device *dev = NULL;
|
|
|
|
u32 tblid = RT_TABLE_DEFAULT;
|
|
|
|
struct mr_table *mrt;
|
|
|
|
struct nlattr *attr;
|
|
|
|
struct rtmsg *rtm;
|
|
|
|
int ret, rem;
|
|
|
|
|
netlink: make validation more configurable for future strictness
We currently have two levels of strict validation:
1) liberal (default)
- undefined (type >= max) & NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
- garbage at end of message accepted
2) strict (opt-in)
- NLA_UNSPEC attributes accepted
- attribute length >= expected accepted
Split out parsing strictness into four different options:
* TRAILING - check that there's no trailing data after parsing
attributes (in message or nested)
* MAXTYPE - reject attrs > max known type
* UNSPEC - reject attributes with NLA_UNSPEC policy entries
* STRICT_ATTRS - strictly validate attribute size
The default for future things should be *everything*.
The current *_strict() is a combination of TRAILING and MAXTYPE,
and is renamed to _deprecated_strict().
The current regular parsing has none of this, and is renamed to
*_parse_deprecated().
Additionally it allows us to selectively set one of the new flags
even on old policies. Notably, the UNSPEC flag could be useful in
this case, since it can be arranged (by filling in the policy) to
not be an incompatible userspace ABI change, but would then going
forward prevent forgetting attribute entries. Similar can apply
to the POLICY flag.
We end up with the following renames:
* nla_parse -> nla_parse_deprecated
* nla_parse_strict -> nla_parse_deprecated_strict
* nlmsg_parse -> nlmsg_parse_deprecated
* nlmsg_parse_strict -> nlmsg_parse_deprecated_strict
* nla_parse_nested -> nla_parse_nested_deprecated
* nla_validate_nested -> nla_validate_nested_deprecated
Using spatch, of course:
@@
expression TB, MAX, HEAD, LEN, POL, EXT;
@@
-nla_parse(TB, MAX, HEAD, LEN, POL, EXT)
+nla_parse_deprecated(TB, MAX, HEAD, LEN, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression NLH, HDRLEN, TB, MAX, POL, EXT;
@@
-nlmsg_parse_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
+nlmsg_parse_deprecated_strict(NLH, HDRLEN, TB, MAX, POL, EXT)
@@
expression TB, MAX, NLA, POL, EXT;
@@
-nla_parse_nested(TB, MAX, NLA, POL, EXT)
+nla_parse_nested_deprecated(TB, MAX, NLA, POL, EXT)
@@
expression START, MAX, POL, EXT;
@@
-nla_validate_nested(START, MAX, POL, EXT)
+nla_validate_nested_deprecated(START, MAX, POL, EXT)
@@
expression NLH, HDRLEN, MAX, POL, EXT;
@@
-nlmsg_validate(NLH, HDRLEN, MAX, POL, EXT)
+nlmsg_validate_deprecated(NLH, HDRLEN, MAX, POL, EXT)
For this patch, don't actually add the strict, non-renamed versions
yet so that it breaks compile if I get it wrong.
Also, while at it, make nla_validate and nla_parse go down to a
common __nla_validate_parse() function to avoid code duplication.
Ultimately, this allows us to have very strict validation for every
new caller of nla_parse()/nlmsg_parse() etc as re-introduced in the
next patch, while existing things will continue to work as is.
In effect then, this adds fully strict validation for any new command.
Signed-off-by: Johannes Berg <johannes.berg@intel.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2019-04-26 20:07:28 +08:00
|
|
|
ret = nlmsg_validate_deprecated(nlh, sizeof(*rtm), RTA_MAX,
|
|
|
|
rtm_ipmr_policy, extack);
|
2015-11-26 22:23:50 +08:00
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
rtm = nlmsg_data(nlh);
|
|
|
|
|
|
|
|
ret = -EINVAL;
|
|
|
|
if (rtm->rtm_family != RTNL_FAMILY_IPMR || rtm->rtm_dst_len != 32 ||
|
|
|
|
rtm->rtm_type != RTN_MULTICAST ||
|
|
|
|
rtm->rtm_scope != RT_SCOPE_UNIVERSE ||
|
|
|
|
!ipmr_rtm_validate_proto(rtm->rtm_protocol))
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
memset(mfcc, 0, sizeof(*mfcc));
|
|
|
|
mfcc->mfcc_parent = -1;
|
|
|
|
ret = 0;
|
|
|
|
nlmsg_for_each_attr(attr, nlh, sizeof(struct rtmsg), rem) {
|
|
|
|
switch (nla_type(attr)) {
|
|
|
|
case RTA_SRC:
|
|
|
|
mfcc->mfcc_origin.s_addr = nla_get_be32(attr);
|
|
|
|
break;
|
|
|
|
case RTA_DST:
|
|
|
|
mfcc->mfcc_mcastgrp.s_addr = nla_get_be32(attr);
|
|
|
|
break;
|
|
|
|
case RTA_IIF:
|
|
|
|
dev = __dev_get_by_index(net, nla_get_u32(attr));
|
|
|
|
if (!dev) {
|
|
|
|
ret = -ENODEV;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case RTA_MULTIPATH:
|
|
|
|
if (ipmr_nla_get_ttls(attr, mfcc) < 0) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case RTA_PREFSRC:
|
|
|
|
ret = 1;
|
|
|
|
break;
|
|
|
|
case RTA_TABLE:
|
|
|
|
tblid = nla_get_u32(attr);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
mrt = ipmr_get_table(net, tblid);
|
|
|
|
if (!mrt) {
|
|
|
|
ret = -ENOENT;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
*mrtret = mrt;
|
|
|
|
*mrtsock = rtm->rtm_protocol == RTPROT_MROUTED ? 1 : 0;
|
|
|
|
if (dev)
|
|
|
|
mfcc->mfcc_parent = ipmr_find_vif(mrt, dev);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* takes care of both newroute and delroute */
|
2017-04-17 00:48:24 +08:00
|
|
|
static int ipmr_rtm_route(struct sk_buff *skb, struct nlmsghdr *nlh,
|
|
|
|
struct netlink_ext_ack *extack)
|
2015-11-26 22:23:50 +08:00
|
|
|
{
|
|
|
|
struct net *net = sock_net(skb->sk);
|
|
|
|
int ret, mrtsock, parent;
|
|
|
|
struct mr_table *tbl;
|
|
|
|
struct mfcctl mfcc;
|
|
|
|
|
|
|
|
mrtsock = 0;
|
|
|
|
tbl = NULL;
|
2017-04-17 00:48:24 +08:00
|
|
|
ret = rtm_to_ipmr_mfcc(net, nlh, &mfcc, &mrtsock, &tbl, extack);
|
2015-11-26 22:23:50 +08:00
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
parent = ret ? mfcc.mfcc_parent : -1;
|
|
|
|
if (nlh->nlmsg_type == RTM_NEWROUTE)
|
|
|
|
return ipmr_mfc_add(net, tbl, &mfcc, mrtsock, parent);
|
|
|
|
else
|
|
|
|
return ipmr_mfc_delete(tbl, &mfcc, parent);
|
|
|
|
}
|
|
|
|
|
2017-06-07 23:02:32 +08:00
|
|
|
static bool ipmr_fill_table(struct mr_table *mrt, struct sk_buff *skb)
|
|
|
|
{
|
|
|
|
u32 queue_len = atomic_read(&mrt->cache_resolve_queue_len);
|
|
|
|
|
|
|
|
if (nla_put_u32(skb, IPMRA_TABLE_ID, mrt->id) ||
|
|
|
|
nla_put_u32(skb, IPMRA_TABLE_CACHE_RES_QUEUE_LEN, queue_len) ||
|
|
|
|
nla_put_s32(skb, IPMRA_TABLE_MROUTE_REG_VIF_NUM,
|
|
|
|
mrt->mroute_reg_vif_num) ||
|
|
|
|
nla_put_u8(skb, IPMRA_TABLE_MROUTE_DO_ASSERT,
|
|
|
|
mrt->mroute_do_assert) ||
|
2018-07-13 17:16:43 +08:00
|
|
|
nla_put_u8(skb, IPMRA_TABLE_MROUTE_DO_PIM, mrt->mroute_do_pim) ||
|
|
|
|
nla_put_u8(skb, IPMRA_TABLE_MROUTE_DO_WRVIFWHOLE,
|
|
|
|
mrt->mroute_do_wrvifwhole))
|
2017-06-07 23:02:32 +08:00
|
|
|
return false;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool ipmr_fill_vif(struct mr_table *mrt, u32 vifid, struct sk_buff *skb)
|
|
|
|
{
|
2022-06-23 12:34:32 +08:00
|
|
|
struct net_device *vif_dev;
|
2017-06-07 23:02:32 +08:00
|
|
|
struct nlattr *vif_nest;
|
|
|
|
struct vif_device *vif;
|
|
|
|
|
2022-06-23 12:34:32 +08:00
|
|
|
vif = &mrt->vif_table[vifid];
|
2022-06-25 14:47:22 +08:00
|
|
|
vif_dev = rtnl_dereference(vif->dev);
|
2017-06-07 23:02:32 +08:00
|
|
|
/* if the VIF doesn't exist just continue */
|
2022-06-23 12:34:32 +08:00
|
|
|
if (!vif_dev)
|
2017-06-07 23:02:32 +08:00
|
|
|
return true;
|
|
|
|
|
2019-04-26 17:13:06 +08:00
|
|
|
vif_nest = nla_nest_start_noflag(skb, IPMRA_VIF);
|
2017-06-07 23:02:32 +08:00
|
|
|
if (!vif_nest)
|
|
|
|
return false;
|
2022-06-23 12:34:32 +08:00
|
|
|
|
|
|
|
if (nla_put_u32(skb, IPMRA_VIFA_IFINDEX, vif_dev->ifindex) ||
|
2017-06-07 23:02:32 +08:00
|
|
|
nla_put_u32(skb, IPMRA_VIFA_VIF_ID, vifid) ||
|
|
|
|
nla_put_u16(skb, IPMRA_VIFA_FLAGS, vif->flags) ||
|
|
|
|
nla_put_u64_64bit(skb, IPMRA_VIFA_BYTES_IN, vif->bytes_in,
|
|
|
|
IPMRA_VIFA_PAD) ||
|
|
|
|
nla_put_u64_64bit(skb, IPMRA_VIFA_BYTES_OUT, vif->bytes_out,
|
|
|
|
IPMRA_VIFA_PAD) ||
|
|
|
|
nla_put_u64_64bit(skb, IPMRA_VIFA_PACKETS_IN, vif->pkt_in,
|
|
|
|
IPMRA_VIFA_PAD) ||
|
|
|
|
nla_put_u64_64bit(skb, IPMRA_VIFA_PACKETS_OUT, vif->pkt_out,
|
|
|
|
IPMRA_VIFA_PAD) ||
|
|
|
|
nla_put_be32(skb, IPMRA_VIFA_LOCAL_ADDR, vif->local) ||
|
|
|
|
nla_put_be32(skb, IPMRA_VIFA_REMOTE_ADDR, vif->remote)) {
|
|
|
|
nla_nest_cancel(skb, vif_nest);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
nla_nest_end(skb, vif_nest);
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2018-10-08 11:16:34 +08:00
|
|
|
static int ipmr_valid_dumplink(const struct nlmsghdr *nlh,
|
|
|
|
struct netlink_ext_ack *extack)
|
|
|
|
{
|
|
|
|
struct ifinfomsg *ifm;
|
|
|
|
|
|
|
|
if (nlh->nlmsg_len < nlmsg_msg_size(sizeof(*ifm))) {
|
|
|
|
NL_SET_ERR_MSG(extack, "ipv4: Invalid header for ipmr link dump");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (nlmsg_attrlen(nlh, sizeof(*ifm))) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Invalid data after header in ipmr link dump");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
ifm = nlmsg_data(nlh);
|
|
|
|
if (ifm->__ifi_pad || ifm->ifi_type || ifm->ifi_flags ||
|
|
|
|
ifm->ifi_change || ifm->ifi_index) {
|
|
|
|
NL_SET_ERR_MSG(extack, "Invalid values in header for ipmr link dump request");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2017-06-07 23:02:32 +08:00
|
|
|
static int ipmr_rtm_dumplink(struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
{
|
|
|
|
struct net *net = sock_net(skb->sk);
|
|
|
|
struct nlmsghdr *nlh = NULL;
|
|
|
|
unsigned int t = 0, s_t;
|
|
|
|
unsigned int e = 0, s_e;
|
|
|
|
struct mr_table *mrt;
|
|
|
|
|
2018-10-08 11:16:34 +08:00
|
|
|
if (cb->strict_check) {
|
|
|
|
int err = ipmr_valid_dumplink(cb->nlh, cb->extack);
|
|
|
|
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2017-06-07 23:02:32 +08:00
|
|
|
s_t = cb->args[0];
|
|
|
|
s_e = cb->args[1];
|
|
|
|
|
|
|
|
ipmr_for_each_table(mrt, net) {
|
|
|
|
struct nlattr *vifs, *af;
|
|
|
|
struct ifinfomsg *hdr;
|
|
|
|
u32 i;
|
|
|
|
|
|
|
|
if (t < s_t)
|
|
|
|
goto skip_table;
|
|
|
|
nlh = nlmsg_put(skb, NETLINK_CB(cb->skb).portid,
|
|
|
|
cb->nlh->nlmsg_seq, RTM_NEWLINK,
|
|
|
|
sizeof(*hdr), NLM_F_MULTI);
|
|
|
|
if (!nlh)
|
|
|
|
break;
|
|
|
|
|
|
|
|
hdr = nlmsg_data(nlh);
|
|
|
|
memset(hdr, 0, sizeof(*hdr));
|
|
|
|
hdr->ifi_family = RTNL_FAMILY_IPMR;
|
|
|
|
|
2019-04-26 17:13:06 +08:00
|
|
|
af = nla_nest_start_noflag(skb, IFLA_AF_SPEC);
|
2017-06-07 23:02:32 +08:00
|
|
|
if (!af) {
|
|
|
|
nlmsg_cancel(skb, nlh);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!ipmr_fill_table(mrt, skb)) {
|
|
|
|
nlmsg_cancel(skb, nlh);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
2019-04-26 17:13:06 +08:00
|
|
|
vifs = nla_nest_start_noflag(skb, IPMRA_TABLE_VIFS);
|
2017-06-07 23:02:32 +08:00
|
|
|
if (!vifs) {
|
|
|
|
nla_nest_end(skb, af);
|
|
|
|
nlmsg_end(skb, nlh);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
for (i = 0; i < mrt->maxvif; i++) {
|
|
|
|
if (e < s_e)
|
|
|
|
goto skip_entry;
|
|
|
|
if (!ipmr_fill_vif(mrt, i, skb)) {
|
|
|
|
nla_nest_end(skb, vifs);
|
|
|
|
nla_nest_end(skb, af);
|
|
|
|
nlmsg_end(skb, nlh);
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
skip_entry:
|
|
|
|
e++;
|
|
|
|
}
|
|
|
|
s_e = 0;
|
|
|
|
e = 0;
|
|
|
|
nla_nest_end(skb, vifs);
|
|
|
|
nla_nest_end(skb, af);
|
|
|
|
nlmsg_end(skb, nlh);
|
|
|
|
skip_table:
|
|
|
|
t++;
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
|
|
|
cb->args[1] = e;
|
|
|
|
cb->args[0] = t;
|
|
|
|
|
|
|
|
return skb->len;
|
|
|
|
}
|
|
|
|
|
2007-02-09 22:24:47 +08:00
|
|
|
#ifdef CONFIG_PROC_FS
|
2015-11-21 22:57:27 +08:00
|
|
|
/* The /proc interfaces to multicast routing :
|
|
|
|
* /proc/net/ip_mr_cache & /proc/net/ip_mr_vif
|
2005-04-17 06:20:36 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
static void *ipmr_vif_seq_start(struct seq_file *seq, loff_t *pos)
|
2022-06-23 12:34:47 +08:00
|
|
|
__acquires(RCU)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2018-03-01 05:29:37 +08:00
|
|
|
struct mr_vif_iter *iter = seq->private;
|
2009-01-22 12:56:22 +08: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-13 13:03:23 +08:00
|
|
|
struct mr_table *mrt;
|
|
|
|
|
|
|
|
mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!mrt)
|
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-13 13:03:23 +08:00
|
|
|
return ERR_PTR(-ENOENT);
|
|
|
|
|
|
|
|
iter->mrt = mrt;
|
2009-01-22 12:56:22 +08:00
|
|
|
|
2022-06-23 12:34:47 +08:00
|
|
|
rcu_read_lock();
|
2018-03-01 05:29:37 +08:00
|
|
|
return mr_vif_seq_start(seq, pos);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void ipmr_vif_seq_stop(struct seq_file *seq, void *v)
|
2022-06-23 12:34:47 +08:00
|
|
|
__releases(RCU)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2022-06-23 12:34:47 +08:00
|
|
|
rcu_read_unlock();
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ipmr_vif_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
2018-03-01 05:29:37 +08:00
|
|
|
struct mr_vif_iter *iter = 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-13 13:03:23 +08:00
|
|
|
struct mr_table *mrt = iter->mrt;
|
2009-01-22 12:56:22 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (v == SEQ_START_TOKEN) {
|
2007-02-09 22:24:47 +08:00
|
|
|
seq_puts(seq,
|
2005-04-17 06:20:36 +08:00
|
|
|
"Interface BytesIn PktsIn BytesOut PktsOut Flags Local Remote\n");
|
|
|
|
} else {
|
|
|
|
const struct vif_device *vif = v;
|
2022-06-23 12:34:32 +08:00
|
|
|
const struct net_device *vif_dev;
|
|
|
|
const char *name;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2022-06-23 12:34:32 +08:00
|
|
|
vif_dev = vif_dev_read(vif);
|
|
|
|
name = vif_dev ? vif_dev->name : "none";
|
2005-04-17 06:20:36 +08:00
|
|
|
seq_printf(seq,
|
2018-01-30 17:48:02 +08:00
|
|
|
"%2td %-10s %8ld %7ld %8ld %7ld %05X %08X %08X\n",
|
2010-04-13 13:03:22 +08:00
|
|
|
vif - mrt->vif_table,
|
2007-02-09 22:24:47 +08:00
|
|
|
name, vif->bytes_in, vif->pkt_in,
|
2005-04-17 06:20:36 +08:00
|
|
|
vif->bytes_out, vif->pkt_out,
|
|
|
|
vif->flags, vif->local, vif->remote);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-13 05:34:29 +08:00
|
|
|
static const struct seq_operations ipmr_vif_seq_ops = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.start = ipmr_vif_seq_start,
|
2018-03-01 05:29:37 +08:00
|
|
|
.next = mr_vif_seq_next,
|
2005-04-17 06:20:36 +08:00
|
|
|
.stop = ipmr_vif_seq_stop,
|
|
|
|
.show = ipmr_vif_seq_show,
|
|
|
|
};
|
|
|
|
|
|
|
|
static void *ipmr_mfc_seq_start(struct seq_file *seq, loff_t *pos)
|
|
|
|
{
|
2009-01-22 12:56:22 +08: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-13 13:03:23 +08:00
|
|
|
struct mr_table *mrt;
|
2009-01-22 12:56:22 +08: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-13 13:03:23 +08:00
|
|
|
mrt = ipmr_get_table(net, RT_TABLE_DEFAULT);
|
2015-04-03 16:17:26 +08:00
|
|
|
if (!mrt)
|
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-13 13:03:23 +08:00
|
|
|
return ERR_PTR(-ENOENT);
|
2009-01-22 12:56:22 +08:00
|
|
|
|
2018-03-01 05:29:36 +08:00
|
|
|
return mr_mfc_seq_start(seq, pos, mrt, &mfc_unres_lock);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static int ipmr_mfc_seq_show(struct seq_file *seq, void *v)
|
|
|
|
{
|
|
|
|
int n;
|
|
|
|
|
|
|
|
if (v == SEQ_START_TOKEN) {
|
2007-02-09 22:24:47 +08:00
|
|
|
seq_puts(seq,
|
2005-04-17 06:20:36 +08:00
|
|
|
"Group Origin Iif Pkts Bytes Wrong Oifs\n");
|
|
|
|
} else {
|
|
|
|
const struct mfc_cache *mfc = v;
|
2018-03-01 05:29:36 +08:00
|
|
|
const struct mr_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-13 13:03:23 +08:00
|
|
|
const struct mr_table *mrt = it->mrt;
|
2007-02-09 22:24:47 +08:00
|
|
|
|
2010-04-21 10:06:52 +08:00
|
|
|
seq_printf(seq, "%08X %08X %-3hd",
|
|
|
|
(__force u32) mfc->mfc_mcastgrp,
|
|
|
|
(__force u32) mfc->mfc_origin,
|
2018-03-01 05:29:34 +08:00
|
|
|
mfc->_c.mfc_parent);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-04-13 13:03:22 +08:00
|
|
|
if (it->cache != &mrt->mfc_unres_queue) {
|
2008-12-04 14:21:47 +08:00
|
|
|
seq_printf(seq, " %8lu %8lu %8lu",
|
2018-03-01 05:29:34 +08:00
|
|
|
mfc->_c.mfc_un.res.pkt,
|
|
|
|
mfc->_c.mfc_un.res.bytes,
|
|
|
|
mfc->_c.mfc_un.res.wrong_if);
|
|
|
|
for (n = mfc->_c.mfc_un.res.minvif;
|
|
|
|
n < mfc->_c.mfc_un.res.maxvif; n++) {
|
2010-04-13 13:03:22 +08:00
|
|
|
if (VIF_EXISTS(mrt, n) &&
|
2018-03-01 05:29:34 +08:00
|
|
|
mfc->_c.mfc_un.res.ttls[n] < 255)
|
2009-01-22 12:56:16 +08:00
|
|
|
seq_printf(seq,
|
2007-02-09 22:24:47 +08:00
|
|
|
" %2d:%-3d",
|
2018-03-01 05:29:34 +08:00
|
|
|
n, mfc->_c.mfc_un.res.ttls[n]);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2008-12-04 14:21:47 +08: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-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
seq_putc(seq, '\n');
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-03-13 05:34:29 +08:00
|
|
|
static const struct seq_operations ipmr_mfc_seq_ops = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.start = ipmr_mfc_seq_start,
|
2018-03-01 05:29:36 +08:00
|
|
|
.next = mr_mfc_seq_next,
|
|
|
|
.stop = mr_mfc_seq_stop,
|
2005-04-17 06:20:36 +08:00
|
|
|
.show = ipmr_mfc_seq_show,
|
|
|
|
};
|
2007-02-09 22:24:47 +08:00
|
|
|
#endif
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_IP_PIMSM_V2
|
2009-09-14 20:21:47 +08:00
|
|
|
static const struct net_protocol pim_protocol = {
|
2005-04-17 06:20:36 +08:00
|
|
|
.handler = pim_rcv,
|
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2017-09-27 14:23:13 +08:00
|
|
|
static unsigned int ipmr_seq_read(struct net *net)
|
|
|
|
{
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
return net->ipv4.ipmr_seq + ipmr_rules_seq_read(net);
|
|
|
|
}
|
|
|
|
|
2019-10-03 17:49:30 +08:00
|
|
|
static int ipmr_dump(struct net *net, struct notifier_block *nb,
|
|
|
|
struct netlink_ext_ack *extack)
|
2017-09-27 14:23:13 +08:00
|
|
|
{
|
2018-03-26 20:01:33 +08:00
|
|
|
return mr_dump(net, nb, RTNL_FAMILY_IPMR, ipmr_rules_dump,
|
2022-06-23 12:34:46 +08:00
|
|
|
ipmr_mr_table_iter, extack);
|
2017-09-27 14:23:13 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct fib_notifier_ops ipmr_notifier_ops_template = {
|
|
|
|
.family = RTNL_FAMILY_IPMR,
|
|
|
|
.fib_seq_read = ipmr_seq_read,
|
|
|
|
.fib_dump = ipmr_dump,
|
|
|
|
.owner = THIS_MODULE,
|
|
|
|
};
|
|
|
|
|
2017-09-29 21:34:22 +08:00
|
|
|
static int __net_init ipmr_notifier_init(struct net *net)
|
2017-09-27 14:23:13 +08:00
|
|
|
{
|
|
|
|
struct fib_notifier_ops *ops;
|
|
|
|
|
|
|
|
net->ipv4.ipmr_seq = 0;
|
|
|
|
|
|
|
|
ops = fib_notifier_ops_register(&ipmr_notifier_ops_template, net);
|
|
|
|
if (IS_ERR(ops))
|
|
|
|
return PTR_ERR(ops);
|
|
|
|
net->ipv4.ipmr_notifier_ops = ops;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit ipmr_notifier_exit(struct net *net)
|
|
|
|
{
|
|
|
|
fib_notifier_ops_unregister(net->ipv4.ipmr_notifier_ops);
|
|
|
|
net->ipv4.ipmr_notifier_ops = NULL;
|
|
|
|
}
|
|
|
|
|
2015-11-21 22:57:27 +08:00
|
|
|
/* Setup for IP multicast routing */
|
2009-01-22 12:56:16 +08: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-13 13:03:23 +08:00
|
|
|
int err;
|
2009-01-22 12:56:16 +08:00
|
|
|
|
2017-09-27 14:23:13 +08:00
|
|
|
err = ipmr_notifier_init(net);
|
|
|
|
if (err)
|
|
|
|
goto ipmr_notifier_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-13 13:03:23 +08:00
|
|
|
err = ipmr_rules_init(net);
|
|
|
|
if (err < 0)
|
2017-09-27 14:23:13 +08:00
|
|
|
goto ipmr_rules_fail;
|
2009-01-22 12:56:22 +08:00
|
|
|
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
err = -ENOMEM;
|
2018-04-11 01:42:55 +08:00
|
|
|
if (!proc_create_net("ip_mr_vif", 0, net->proc_net, &ipmr_vif_seq_ops,
|
|
|
|
sizeof(struct mr_vif_iter)))
|
2009-01-22 12:56:22 +08:00
|
|
|
goto proc_vif_fail;
|
2018-04-11 01:42:55 +08:00
|
|
|
if (!proc_create_net("ip_mr_cache", 0, net->proc_net, &ipmr_mfc_seq_ops,
|
|
|
|
sizeof(struct mr_mfc_iter)))
|
2009-01-22 12:56:22 +08:00
|
|
|
goto proc_cache_fail;
|
|
|
|
#endif
|
2009-01-22 12:56:18 +08:00
|
|
|
return 0;
|
|
|
|
|
2009-01-22 12:56:22 +08:00
|
|
|
#ifdef CONFIG_PROC_FS
|
|
|
|
proc_cache_fail:
|
2013-02-18 09:34:56 +08:00
|
|
|
remove_proc_entry("ip_mr_vif", net->proc_net);
|
2009-01-22 12:56:22 +08:00
|
|
|
proc_vif_fail:
|
2022-02-08 12:50:35 +08: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-13 13:03:23 +08:00
|
|
|
ipmr_rules_exit(net);
|
2022-02-08 12:50:35 +08:00
|
|
|
rtnl_unlock();
|
2009-01-22 12:56:22 +08:00
|
|
|
#endif
|
2017-09-27 14:23:13 +08:00
|
|
|
ipmr_rules_fail:
|
|
|
|
ipmr_notifier_exit(net);
|
|
|
|
ipmr_notifier_fail:
|
2009-01-22 12:56:16 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit ipmr_net_exit(struct net *net)
|
|
|
|
{
|
2009-01-22 12:56:22 +08:00
|
|
|
#ifdef CONFIG_PROC_FS
|
2013-02-18 09:34:56 +08:00
|
|
|
remove_proc_entry("ip_mr_cache", net->proc_net);
|
|
|
|
remove_proc_entry("ip_mr_vif", net->proc_net);
|
2009-01-22 12:56:22 +08:00
|
|
|
#endif
|
2017-09-27 14:23:13 +08:00
|
|
|
ipmr_notifier_exit(net);
|
2022-02-08 12:50:35 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void __net_exit ipmr_net_exit_batch(struct list_head *net_list)
|
|
|
|
{
|
|
|
|
struct net *net;
|
|
|
|
|
|
|
|
rtnl_lock();
|
|
|
|
list_for_each_entry(net, net_list, exit_list)
|
|
|
|
ipmr_rules_exit(net);
|
|
|
|
rtnl_unlock();
|
2009-01-22 12:56:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct pernet_operations ipmr_net_ops = {
|
|
|
|
.init = ipmr_net_init,
|
|
|
|
.exit = ipmr_net_exit,
|
2022-02-08 12:50:35 +08:00
|
|
|
.exit_batch = ipmr_net_exit_batch,
|
2009-01-22 12:56:16 +08:00
|
|
|
};
|
2007-02-09 22:24:47 +08:00
|
|
|
|
2008-07-03 12:13:36 +08:00
|
|
|
int __init ip_mr_init(void)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2008-07-03 12:13:36 +08:00
|
|
|
int err;
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
mrt_cachep = kmem_cache_create("ip_mrt_cache",
|
|
|
|
sizeof(struct mfc_cache),
|
2010-10-02 00:15:08 +08:00
|
|
|
0, SLAB_HWCACHE_ALIGN | SLAB_PANIC,
|
2007-07-20 09:11:58 +08:00
|
|
|
NULL);
|
2008-07-03 12:13:36 +08:00
|
|
|
|
2009-01-22 12:56:16 +08:00
|
|
|
err = register_pernet_subsys(&ipmr_net_ops);
|
|
|
|
if (err)
|
|
|
|
goto reg_pernet_fail;
|
|
|
|
|
2008-07-03 12:13:36 +08:00
|
|
|
err = register_netdevice_notifier(&ip_mr_notifier);
|
|
|
|
if (err)
|
|
|
|
goto reg_notif_fail;
|
2009-06-14 18:16:13 +08:00
|
|
|
#ifdef CONFIG_IP_PIMSM_V2
|
|
|
|
if (inet_add_protocol(&pim_protocol, IPPROTO_PIM) < 0) {
|
2012-03-12 02:36:11 +08:00
|
|
|
pr_err("%s: can't add PIM protocol\n", __func__);
|
2009-06-14 18:16:13 +08:00
|
|
|
err = -EAGAIN;
|
|
|
|
goto add_proto_fail;
|
|
|
|
}
|
|
|
|
#endif
|
2011-06-10 09:27:09 +08:00
|
|
|
rtnl_register(RTNL_FAMILY_IPMR, RTM_GETROUTE,
|
2017-08-10 02:41:48 +08:00
|
|
|
ipmr_rtm_getroute, ipmr_rtm_dumproute, 0);
|
2015-11-26 22:23:50 +08:00
|
|
|
rtnl_register(RTNL_FAMILY_IPMR, RTM_NEWROUTE,
|
2017-08-10 02:41:48 +08:00
|
|
|
ipmr_rtm_route, NULL, 0);
|
2015-11-26 22:23:50 +08:00
|
|
|
rtnl_register(RTNL_FAMILY_IPMR, RTM_DELROUTE,
|
2017-08-10 02:41:48 +08:00
|
|
|
ipmr_rtm_route, NULL, 0);
|
2017-06-07 23:02:32 +08:00
|
|
|
|
|
|
|
rtnl_register(RTNL_FAMILY_IPMR, RTM_GETLINK,
|
2017-08-10 02:41:48 +08:00
|
|
|
NULL, ipmr_rtm_dumplink, 0);
|
2008-07-03 12:13:36 +08:00
|
|
|
return 0;
|
2009-01-22 12:56:22 +08:00
|
|
|
|
2009-06-14 18:16:13 +08:00
|
|
|
#ifdef CONFIG_IP_PIMSM_V2
|
|
|
|
add_proto_fail:
|
|
|
|
unregister_netdevice_notifier(&ip_mr_notifier);
|
|
|
|
#endif
|
2008-11-20 06:07:41 +08:00
|
|
|
reg_notif_fail:
|
2009-01-22 12:56:16 +08:00
|
|
|
unregister_pernet_subsys(&ipmr_net_ops);
|
|
|
|
reg_pernet_fail:
|
2008-11-20 06:07:41 +08:00
|
|
|
kmem_cache_destroy(mrt_cachep);
|
2008-07-03 12:13:36 +08:00
|
|
|
return err;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|