2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* NET3 IP device support routines.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version
|
|
|
|
* 2 of the License, or (at your option) any later version.
|
|
|
|
*
|
|
|
|
* Derived from the IP parts of dev.c 1.0.19
|
2005-05-05 17:16:16 -06:00
|
|
|
* Authors: Ross Biro
|
2005-04-16 16:20:36 -06:00
|
|
|
* Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
|
|
|
|
* Mark Evans, <evansmp@uhura.aston.ac.uk>
|
|
|
|
*
|
|
|
|
* Additional Authors:
|
|
|
|
* Alan Cox, <gw4pts@gw4pts.ampr.org>
|
|
|
|
* Alexey Kuznetsov, <kuznet@ms2.inr.ac.ru>
|
|
|
|
*
|
|
|
|
* Changes:
|
|
|
|
* Alexey Kuznetsov: pa_* fields are replaced with ifaddr
|
|
|
|
* lists.
|
|
|
|
* Cyrus Durgin: updated for kmod
|
|
|
|
* Matthias Andree: in devinet_ioctl, compare label and
|
|
|
|
* address (4.4BSD alias style support),
|
|
|
|
* fall back to comparing just the label
|
|
|
|
* if no match found.
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#include <asm/uaccess.h>
|
|
|
|
#include <linux/bitops.h>
|
2006-01-11 13:17:47 -07:00
|
|
|
#include <linux/capability.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/types.h>
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/string.h>
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/socket.h>
|
|
|
|
#include <linux/sockios.h>
|
|
|
|
#include <linux/in.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/interrupt.h>
|
2006-08-05 00:04:54 -06:00
|
|
|
#include <linux/if_addr.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/if_ether.h>
|
|
|
|
#include <linux/inet.h>
|
|
|
|
#include <linux/netdevice.h>
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
#include <linux/skbuff.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/notifier.h>
|
|
|
|
#include <linux/inetdevice.h>
|
|
|
|
#include <linux/igmp.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 02:04:11 -06:00
|
|
|
#include <linux/slab.h>
|
2011-02-18 13:42:28 -07:00
|
|
|
#include <linux/hash.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_SYSCTL
|
|
|
|
#include <linux/sysctl.h>
|
|
|
|
#endif
|
|
|
|
#include <linux/kmod.h>
|
|
|
|
|
2005-12-26 21:43:12 -07:00
|
|
|
#include <net/arp.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <net/ip.h>
|
|
|
|
#include <net/route.h>
|
|
|
|
#include <net/ip_fib.h>
|
2007-03-22 12:55:17 -06:00
|
|
|
#include <net/rtnetlink.h>
|
2007-12-16 14:31:47 -07:00
|
|
|
#include <net/net_namespace.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-03-22 22:56:23 -06:00
|
|
|
#include "fib_lookup.h"
|
|
|
|
|
2008-01-31 18:17:31 -07:00
|
|
|
static struct ipv4_devconf ipv4_devconf = {
|
2007-06-05 00:34:44 -06:00
|
|
|
.data = {
|
2010-02-13 20:25:51 -07:00
|
|
|
[IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
|
|
|
|
[IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
|
|
|
|
[IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
|
|
|
|
[IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
|
2007-06-05 00:34:44 -06:00
|
|
|
},
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
|
|
|
static struct ipv4_devconf ipv4_devconf_dflt = {
|
2007-06-05 00:34:44 -06:00
|
|
|
.data = {
|
2010-02-13 20:25:51 -07:00
|
|
|
[IPV4_DEVCONF_ACCEPT_REDIRECTS - 1] = 1,
|
|
|
|
[IPV4_DEVCONF_SEND_REDIRECTS - 1] = 1,
|
|
|
|
[IPV4_DEVCONF_SECURE_REDIRECTS - 1] = 1,
|
|
|
|
[IPV4_DEVCONF_SHARED_MEDIA - 1] = 1,
|
|
|
|
[IPV4_DEVCONF_ACCEPT_SOURCE_ROUTE - 1] = 1,
|
2007-06-05 00:34:44 -06:00
|
|
|
},
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2007-12-16 14:32:16 -07:00
|
|
|
#define IPV4_DEVCONF_DFLT(net, attr) \
|
|
|
|
IPV4_DEVCONF((*net->ipv4.devconf_dflt), attr)
|
2007-06-05 00:34:44 -06:00
|
|
|
|
2007-06-05 13:38:30 -06:00
|
|
|
static const struct nla_policy ifa_ipv4_policy[IFA_MAX+1] = {
|
2006-08-05 00:03:53 -06:00
|
|
|
[IFA_LOCAL] = { .type = NLA_U32 },
|
|
|
|
[IFA_ADDRESS] = { .type = NLA_U32 },
|
|
|
|
[IFA_BROADCAST] = { .type = NLA_U32 },
|
2006-08-26 21:13:18 -06:00
|
|
|
[IFA_LABEL] = { .type = NLA_STRING, .len = IFNAMSIZ - 1 },
|
2006-08-05 00:03:53 -06:00
|
|
|
};
|
|
|
|
|
2011-02-18 13:42:28 -07:00
|
|
|
/* inet_addr_hash's shifting is dependent upon this IN4_ADDR_HSIZE
|
|
|
|
* value. So if you change this define, make appropriate changes to
|
|
|
|
* inet_addr_hash as well.
|
|
|
|
*/
|
|
|
|
#define IN4_ADDR_HSIZE 256
|
|
|
|
static struct hlist_head inet_addr_lst[IN4_ADDR_HSIZE];
|
|
|
|
static DEFINE_SPINLOCK(inet_addr_hash_lock);
|
|
|
|
|
|
|
|
static inline unsigned int inet_addr_hash(struct net *net, __be32 addr)
|
|
|
|
{
|
|
|
|
u32 val = (__force u32) addr ^ hash_ptr(net, 8);
|
|
|
|
|
|
|
|
return ((val ^ (val >> 8) ^ (val >> 16) ^ (val >> 24)) &
|
|
|
|
(IN4_ADDR_HSIZE - 1));
|
|
|
|
}
|
|
|
|
|
|
|
|
static void inet_hash_insert(struct net *net, struct in_ifaddr *ifa)
|
|
|
|
{
|
2011-03-03 12:24:19 -07:00
|
|
|
unsigned int hash = inet_addr_hash(net, ifa->ifa_local);
|
2011-02-18 13:42:28 -07:00
|
|
|
|
|
|
|
spin_lock(&inet_addr_hash_lock);
|
|
|
|
hlist_add_head_rcu(&ifa->hash, &inet_addr_lst[hash]);
|
|
|
|
spin_unlock(&inet_addr_hash_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void inet_hash_remove(struct in_ifaddr *ifa)
|
|
|
|
{
|
|
|
|
spin_lock(&inet_addr_hash_lock);
|
|
|
|
hlist_del_init_rcu(&ifa->hash);
|
|
|
|
spin_unlock(&inet_addr_hash_lock);
|
|
|
|
}
|
|
|
|
|
2011-02-18 13:43:09 -07:00
|
|
|
/**
|
|
|
|
* __ip_dev_find - find the first device with a given source address.
|
|
|
|
* @net: the net namespace
|
|
|
|
* @addr: the source address
|
|
|
|
* @devref: if true, take a reference on the found device
|
|
|
|
*
|
|
|
|
* If a caller uses devref=false, it should be protected by RCU, or RTNL
|
|
|
|
*/
|
|
|
|
struct net_device *__ip_dev_find(struct net *net, __be32 addr, bool devref)
|
|
|
|
{
|
|
|
|
unsigned int hash = inet_addr_hash(net, addr);
|
|
|
|
struct net_device *result = NULL;
|
|
|
|
struct in_ifaddr *ifa;
|
|
|
|
struct hlist_node *node;
|
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
hlist_for_each_entry_rcu(ifa, node, &inet_addr_lst[hash], hash) {
|
|
|
|
struct net_device *dev = ifa->ifa_dev->dev;
|
|
|
|
|
|
|
|
if (!net_eq(dev_net(dev), net))
|
|
|
|
continue;
|
2011-03-03 12:24:19 -07:00
|
|
|
if (ifa->ifa_local == addr) {
|
2011-02-18 13:43:09 -07:00
|
|
|
result = dev;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2011-03-22 22:56:23 -06:00
|
|
|
if (!result) {
|
|
|
|
struct flowi4 fl4 = { .daddr = addr };
|
|
|
|
struct fib_result res = { 0 };
|
|
|
|
struct fib_table *local;
|
|
|
|
|
|
|
|
/* Fallback to FIB local table so that communication
|
|
|
|
* over loopback subnets work.
|
|
|
|
*/
|
|
|
|
local = fib_get_table(net, RT_TABLE_LOCAL);
|
|
|
|
if (local &&
|
|
|
|
!fib_table_lookup(local, &fl4, &res, FIB_LOOKUP_NOREF) &&
|
|
|
|
res.type == RTN_LOCAL)
|
|
|
|
result = FIB_RES_DEV(res);
|
|
|
|
}
|
2011-02-18 13:43:09 -07:00
|
|
|
if (result && devref)
|
|
|
|
dev_hold(result);
|
|
|
|
rcu_read_unlock();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL(__ip_dev_find);
|
|
|
|
|
2006-08-15 01:33:59 -06:00
|
|
|
static void rtmsg_ifa(int event, struct in_ifaddr *, struct nlmsghdr *, u32);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
[PATCH] Notifier chain update: API changes
The kernel's implementation of notifier chains is unsafe. There is no
protection against entries being added to or removed from a chain while the
chain is in use. The issues were discussed in this thread:
http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
We noticed that notifier chains in the kernel fall into two basic usage
classes:
"Blocking" chains are always called from a process context
and the callout routines are allowed to sleep;
"Atomic" chains can be called from an atomic context and
the callout routines are not allowed to sleep.
We decided to codify this distinction and make it part of the API. Therefore
this set of patches introduces three new, parallel APIs: one for blocking
notifiers, one for atomic notifiers, and one for "raw" notifiers (which is
really just the old API under a new name). New kinds of data structures are
used for the heads of the chains, and new routines are defined for
registration, unregistration, and calling a chain. The three APIs are
explained in include/linux/notifier.h and their implementation is in
kernel/sys.c.
With atomic and blocking chains, the implementation guarantees that the chain
links will not be corrupted and that chain callers will not get messed up by
entries being added or removed. For raw chains the implementation provides no
guarantees at all; users of this API must provide their own protections. (The
idea was that situations may come up where the assumptions of the atomic and
blocking APIs are not appropriate, so it should be possible for users to
handle these things in their own way.)
There are some limitations, which should not be too hard to live with. For
atomic/blocking chains, registration and unregistration must always be done in
a process context since the chain is protected by a mutex/rwsem. Also, a
callout routine for a non-raw chain must not try to register or unregister
entries on its own chain. (This did happen in a couple of places and the code
had to be changed to avoid it.)
Since atomic chains may be called from within an NMI handler, they cannot use
spinlocks for synchronization. Instead we use RCU. The overhead falls almost
entirely in the unregister routine, which is okay since unregistration is much
less frequent that calling a chain.
Here is the list of chains that we adjusted and their classifications. None
of them use the raw API, so for the moment it is only a placeholder.
ATOMIC CHAINS
-------------
arch/i386/kernel/traps.c: i386die_chain
arch/ia64/kernel/traps.c: ia64die_chain
arch/powerpc/kernel/traps.c: powerpc_die_chain
arch/sparc64/kernel/traps.c: sparc64die_chain
arch/x86_64/kernel/traps.c: die_chain
drivers/char/ipmi/ipmi_si_intf.c: xaction_notifier_list
kernel/panic.c: panic_notifier_list
kernel/profile.c: task_free_notifier
net/bluetooth/hci_core.c: hci_notifier
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_chain
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_expect_chain
net/ipv6/addrconf.c: inet6addr_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_expect_chain
net/netlink/af_netlink.c: netlink_chain
BLOCKING CHAINS
---------------
arch/powerpc/platforms/pseries/reconfig.c: pSeries_reconfig_chain
arch/s390/kernel/process.c: idle_chain
arch/x86_64/kernel/process.c idle_notifier
drivers/base/memory.c: memory_chain
drivers/cpufreq/cpufreq.c cpufreq_policy_notifier_list
drivers/cpufreq/cpufreq.c cpufreq_transition_notifier_list
drivers/macintosh/adb.c: adb_client_list
drivers/macintosh/via-pmu.c sleep_notifier_list
drivers/macintosh/via-pmu68k.c sleep_notifier_list
drivers/macintosh/windfarm_core.c wf_client_list
drivers/usb/core/notify.c usb_notifier_list
drivers/video/fbmem.c fb_notifier_list
kernel/cpu.c cpu_chain
kernel/module.c module_notify_list
kernel/profile.c munmap_notifier
kernel/profile.c task_exit_notifier
kernel/sys.c reboot_notifier_list
net/core/dev.c netdev_chain
net/decnet/dn_dev.c: dnaddr_chain
net/ipv4/devinet.c: inetaddr_chain
It's possible that some of these classifications are wrong. If they are,
please let us know or submit a patch to fix them. Note that any chain that
gets called very frequently should be atomic, because the rwsem read-locking
used for blocking chains is very likely to incur cache misses on SMP systems.
(However, if the chain's callout routines may sleep then the chain cannot be
atomic.)
The patch set was written by Alan Stern and Chandra Seetharaman, incorporating
material written by Keith Owens and suggestions from Paul McKenney and Andrew
Morton.
[jes@sgi.com: restructure the notifier chain initialization macros]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Signed-off-by: Jes Sorensen <jes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-27 02:16:30 -07:00
|
|
|
static BLOCKING_NOTIFIER_HEAD(inetaddr_chain);
|
2005-04-16 16:20:36 -06:00
|
|
|
static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
|
|
|
|
int destroy);
|
|
|
|
#ifdef CONFIG_SYSCTL
|
2007-12-01 06:55:54 -07:00
|
|
|
static void devinet_sysctl_register(struct in_device *idev);
|
2007-12-11 03:17:40 -07:00
|
|
|
static void devinet_sysctl_unregister(struct in_device *idev);
|
|
|
|
#else
|
|
|
|
static inline void devinet_sysctl_register(struct in_device *idev)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
static inline void devinet_sysctl_unregister(struct in_device *idev)
|
|
|
|
{
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Locks all the inet devices. */
|
|
|
|
|
|
|
|
static struct in_ifaddr *inet_alloc_ifa(void)
|
|
|
|
{
|
2008-10-28 14:25:09 -06:00
|
|
|
return kzalloc(sizeof(struct in_ifaddr), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void inet_rcu_free_ifa(struct rcu_head *head)
|
|
|
|
{
|
|
|
|
struct in_ifaddr *ifa = container_of(head, struct in_ifaddr, rcu_head);
|
|
|
|
if (ifa->ifa_dev)
|
|
|
|
in_dev_put(ifa->ifa_dev);
|
|
|
|
kfree(ifa);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void inet_free_ifa(struct in_ifaddr *ifa)
|
|
|
|
{
|
|
|
|
call_rcu(&ifa->rcu_head, inet_rcu_free_ifa);
|
|
|
|
}
|
|
|
|
|
|
|
|
void in_dev_finish_destroy(struct in_device *idev)
|
|
|
|
{
|
|
|
|
struct net_device *dev = idev->dev;
|
|
|
|
|
2008-07-25 22:43:18 -06:00
|
|
|
WARN_ON(idev->ifa_list);
|
|
|
|
WARN_ON(idev->mc_list);
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef NET_REFCNT_DEBUG
|
2012-05-15 08:11:54 -06:00
|
|
|
pr_debug("%s: %p=%s\n", __func__, idev, dev ? dev->name : "NIL");
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
dev_put(dev);
|
|
|
|
if (!idev->dead)
|
2009-11-04 23:05:10 -07:00
|
|
|
pr_err("Freeing alive in_device %p\n", idev);
|
|
|
|
else
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(idev);
|
|
|
|
}
|
2009-11-04 23:05:10 -07:00
|
|
|
EXPORT_SYMBOL(in_dev_finish_destroy);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-06-05 00:36:06 -06:00
|
|
|
static struct in_device *inetdev_init(struct net_device *dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct in_device *in_dev;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2006-07-21 15:51:30 -06:00
|
|
|
in_dev = kzalloc(sizeof(*in_dev), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!in_dev)
|
|
|
|
goto out;
|
2008-03-25 06:47:49 -06:00
|
|
|
memcpy(&in_dev->cnf, dev_net(dev)->ipv4.devconf_dflt,
|
2007-12-16 14:32:16 -07:00
|
|
|
sizeof(in_dev->cnf));
|
2005-04-16 16:20:36 -06:00
|
|
|
in_dev->cnf.sysctl = NULL;
|
|
|
|
in_dev->dev = dev;
|
2009-11-04 23:05:10 -07:00
|
|
|
in_dev->arp_parms = neigh_parms_alloc(dev, &arp_tbl);
|
|
|
|
if (!in_dev->arp_parms)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out_kfree;
|
2008-06-19 17:15:47 -06:00
|
|
|
if (IPV4_DEVCONF(in_dev->cnf, FORWARDING))
|
|
|
|
dev_disable_lro(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Reference in_dev->dev */
|
|
|
|
dev_hold(dev);
|
2007-01-04 13:31:14 -07:00
|
|
|
/* Account for reference dev->ip_ptr (below) */
|
2005-04-16 16:20:36 -06:00
|
|
|
in_dev_hold(in_dev);
|
|
|
|
|
2007-12-01 06:55:54 -07:00
|
|
|
devinet_sysctl_register(in_dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
ip_mc_init_dev(in_dev);
|
|
|
|
if (dev->flags & IFF_UP)
|
|
|
|
ip_mc_up(in_dev);
|
2007-01-09 15:38:31 -07:00
|
|
|
|
2007-01-04 13:31:14 -07:00
|
|
|
/* we can receive as soon as ip_ptr is set -- do this last */
|
2012-01-11 21:41:32 -07:00
|
|
|
rcu_assign_pointer(dev->ip_ptr, in_dev);
|
2007-01-09 15:38:31 -07:00
|
|
|
out:
|
2005-04-16 16:20:36 -06:00
|
|
|
return in_dev;
|
|
|
|
out_kfree:
|
|
|
|
kfree(in_dev);
|
|
|
|
in_dev = NULL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void in_dev_rcu_put(struct rcu_head *head)
|
|
|
|
{
|
|
|
|
struct in_device *idev = container_of(head, struct in_device, rcu_head);
|
|
|
|
in_dev_put(idev);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void inetdev_destroy(struct in_device *in_dev)
|
|
|
|
{
|
|
|
|
struct in_ifaddr *ifa;
|
|
|
|
struct net_device *dev;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
dev = in_dev->dev;
|
|
|
|
|
|
|
|
in_dev->dead = 1;
|
|
|
|
|
|
|
|
ip_mc_destroy_dev(in_dev);
|
|
|
|
|
|
|
|
while ((ifa = in_dev->ifa_list) != NULL) {
|
|
|
|
inet_del_ifa(in_dev, &in_dev->ifa_list, 0);
|
|
|
|
inet_free_ifa(ifa);
|
|
|
|
}
|
|
|
|
|
2011-08-01 10:19:00 -06:00
|
|
|
RCU_INIT_POINTER(dev->ip_ptr, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-12-11 03:17:40 -07:00
|
|
|
devinet_sysctl_unregister(in_dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
neigh_parms_release(&arp_tbl, in_dev->arp_parms);
|
|
|
|
arp_ifdown(dev);
|
|
|
|
|
|
|
|
call_rcu(&in_dev->rcu_head, in_dev_rcu_put);
|
|
|
|
}
|
|
|
|
|
2006-09-26 23:13:35 -06:00
|
|
|
int inet_addr_onlink(struct in_device *in_dev, __be32 a, __be32 b)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
rcu_read_lock();
|
|
|
|
for_primary_ifa(in_dev) {
|
|
|
|
if (inet_ifa_match(a, ifa)) {
|
|
|
|
if (!b || inet_ifa_match(b, ifa)) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} endfor_ifa(in_dev);
|
|
|
|
rcu_read_unlock();
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-15 01:33:59 -06:00
|
|
|
static void __inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
|
|
|
|
int destroy, struct nlmsghdr *nlh, u32 pid)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2005-05-29 21:23:46 -06:00
|
|
|
struct in_ifaddr *promote = NULL;
|
2005-11-22 15:47:37 -07:00
|
|
|
struct in_ifaddr *ifa, *ifa1 = *ifap;
|
|
|
|
struct in_ifaddr *last_prim = in_dev->ifa_list;
|
|
|
|
struct in_ifaddr *prev_prom = NULL;
|
|
|
|
int do_promote = IN_DEV_PROMOTE_SECONDARIES(in_dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2007-02-09 07:24:47 -07:00
|
|
|
/* 1. Deleting primary ifaddr forces deletion all secondaries
|
2005-05-29 21:23:46 -06:00
|
|
|
* unless alias promotion is set
|
|
|
|
**/
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (!(ifa1->ifa_flags & IFA_F_SECONDARY)) {
|
|
|
|
struct in_ifaddr **ifap1 = &ifa1->ifa_next;
|
|
|
|
|
|
|
|
while ((ifa = *ifap1) != NULL) {
|
2007-02-09 07:24:47 -07:00
|
|
|
if (!(ifa->ifa_flags & IFA_F_SECONDARY) &&
|
2005-11-22 15:47:37 -07:00
|
|
|
ifa1->ifa_scope <= ifa->ifa_scope)
|
|
|
|
last_prim = ifa;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!(ifa->ifa_flags & IFA_F_SECONDARY) ||
|
|
|
|
ifa1->ifa_mask != ifa->ifa_mask ||
|
|
|
|
!inet_ifa_match(ifa1->ifa_address, ifa)) {
|
|
|
|
ifap1 = &ifa->ifa_next;
|
2005-11-22 15:47:37 -07:00
|
|
|
prev_prom = ifa;
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2005-11-22 15:47:37 -07:00
|
|
|
if (!do_promote) {
|
2011-02-18 13:42:28 -07:00
|
|
|
inet_hash_remove(ifa);
|
2005-05-29 21:23:46 -06:00
|
|
|
*ifap1 = ifa->ifa_next;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-15 01:33:59 -06:00
|
|
|
rtmsg_ifa(RTM_DELADDR, ifa, nlh, pid);
|
[PATCH] Notifier chain update: API changes
The kernel's implementation of notifier chains is unsafe. There is no
protection against entries being added to or removed from a chain while the
chain is in use. The issues were discussed in this thread:
http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
We noticed that notifier chains in the kernel fall into two basic usage
classes:
"Blocking" chains are always called from a process context
and the callout routines are allowed to sleep;
"Atomic" chains can be called from an atomic context and
the callout routines are not allowed to sleep.
We decided to codify this distinction and make it part of the API. Therefore
this set of patches introduces three new, parallel APIs: one for blocking
notifiers, one for atomic notifiers, and one for "raw" notifiers (which is
really just the old API under a new name). New kinds of data structures are
used for the heads of the chains, and new routines are defined for
registration, unregistration, and calling a chain. The three APIs are
explained in include/linux/notifier.h and their implementation is in
kernel/sys.c.
With atomic and blocking chains, the implementation guarantees that the chain
links will not be corrupted and that chain callers will not get messed up by
entries being added or removed. For raw chains the implementation provides no
guarantees at all; users of this API must provide their own protections. (The
idea was that situations may come up where the assumptions of the atomic and
blocking APIs are not appropriate, so it should be possible for users to
handle these things in their own way.)
There are some limitations, which should not be too hard to live with. For
atomic/blocking chains, registration and unregistration must always be done in
a process context since the chain is protected by a mutex/rwsem. Also, a
callout routine for a non-raw chain must not try to register or unregister
entries on its own chain. (This did happen in a couple of places and the code
had to be changed to avoid it.)
Since atomic chains may be called from within an NMI handler, they cannot use
spinlocks for synchronization. Instead we use RCU. The overhead falls almost
entirely in the unregister routine, which is okay since unregistration is much
less frequent that calling a chain.
Here is the list of chains that we adjusted and their classifications. None
of them use the raw API, so for the moment it is only a placeholder.
ATOMIC CHAINS
-------------
arch/i386/kernel/traps.c: i386die_chain
arch/ia64/kernel/traps.c: ia64die_chain
arch/powerpc/kernel/traps.c: powerpc_die_chain
arch/sparc64/kernel/traps.c: sparc64die_chain
arch/x86_64/kernel/traps.c: die_chain
drivers/char/ipmi/ipmi_si_intf.c: xaction_notifier_list
kernel/panic.c: panic_notifier_list
kernel/profile.c: task_free_notifier
net/bluetooth/hci_core.c: hci_notifier
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_chain
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_expect_chain
net/ipv6/addrconf.c: inet6addr_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_expect_chain
net/netlink/af_netlink.c: netlink_chain
BLOCKING CHAINS
---------------
arch/powerpc/platforms/pseries/reconfig.c: pSeries_reconfig_chain
arch/s390/kernel/process.c: idle_chain
arch/x86_64/kernel/process.c idle_notifier
drivers/base/memory.c: memory_chain
drivers/cpufreq/cpufreq.c cpufreq_policy_notifier_list
drivers/cpufreq/cpufreq.c cpufreq_transition_notifier_list
drivers/macintosh/adb.c: adb_client_list
drivers/macintosh/via-pmu.c sleep_notifier_list
drivers/macintosh/via-pmu68k.c sleep_notifier_list
drivers/macintosh/windfarm_core.c wf_client_list
drivers/usb/core/notify.c usb_notifier_list
drivers/video/fbmem.c fb_notifier_list
kernel/cpu.c cpu_chain
kernel/module.c module_notify_list
kernel/profile.c munmap_notifier
kernel/profile.c task_exit_notifier
kernel/sys.c reboot_notifier_list
net/core/dev.c netdev_chain
net/decnet/dn_dev.c: dnaddr_chain
net/ipv4/devinet.c: inetaddr_chain
It's possible that some of these classifications are wrong. If they are,
please let us know or submit a patch to fix them. Note that any chain that
gets called very frequently should be atomic, because the rwsem read-locking
used for blocking chains is very likely to incur cache misses on SMP systems.
(However, if the chain's callout routines may sleep then the chain cannot be
atomic.)
The patch set was written by Alan Stern and Chandra Seetharaman, incorporating
material written by Keith Owens and suggestions from Paul McKenney and Andrew
Morton.
[jes@sgi.com: restructure the notifier chain initialization macros]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Signed-off-by: Jes Sorensen <jes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-27 02:16:30 -07:00
|
|
|
blocking_notifier_call_chain(&inetaddr_chain,
|
|
|
|
NETDEV_DOWN, ifa);
|
2005-05-29 21:23:46 -06:00
|
|
|
inet_free_ifa(ifa);
|
|
|
|
} else {
|
|
|
|
promote = ifa;
|
|
|
|
break;
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-03-19 06:13:52 -06:00
|
|
|
/* On promotion all secondaries from subnet are changing
|
|
|
|
* the primary IP, we must remove all their routes silently
|
|
|
|
* and later to add them back with new prefsrc. Do this
|
|
|
|
* while all addresses are on the device list.
|
|
|
|
*/
|
|
|
|
for (ifa = promote; ifa; ifa = ifa->ifa_next) {
|
|
|
|
if (ifa1->ifa_mask == ifa->ifa_mask &&
|
|
|
|
inet_ifa_match(ifa1->ifa_address, ifa))
|
|
|
|
fib_del_ifaddr(ifa, ifa1);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* 2. Unlink it */
|
|
|
|
|
|
|
|
*ifap = ifa1->ifa_next;
|
2011-02-18 13:42:28 -07:00
|
|
|
inet_hash_remove(ifa1);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* 3. Announce address deletion */
|
|
|
|
|
|
|
|
/* Send message first, then call notifier.
|
|
|
|
At first sight, FIB update triggered by notifier
|
|
|
|
will refer to already deleted ifaddr, that could confuse
|
|
|
|
netlink listeners. It is not true: look, gated sees
|
|
|
|
that route deleted and if it still thinks that ifaddr
|
|
|
|
is valid, it will try to restore deleted routes... Grr.
|
|
|
|
So that, this order is correct.
|
|
|
|
*/
|
2006-08-15 01:33:59 -06:00
|
|
|
rtmsg_ifa(RTM_DELADDR, ifa1, nlh, pid);
|
[PATCH] Notifier chain update: API changes
The kernel's implementation of notifier chains is unsafe. There is no
protection against entries being added to or removed from a chain while the
chain is in use. The issues were discussed in this thread:
http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
We noticed that notifier chains in the kernel fall into two basic usage
classes:
"Blocking" chains are always called from a process context
and the callout routines are allowed to sleep;
"Atomic" chains can be called from an atomic context and
the callout routines are not allowed to sleep.
We decided to codify this distinction and make it part of the API. Therefore
this set of patches introduces three new, parallel APIs: one for blocking
notifiers, one for atomic notifiers, and one for "raw" notifiers (which is
really just the old API under a new name). New kinds of data structures are
used for the heads of the chains, and new routines are defined for
registration, unregistration, and calling a chain. The three APIs are
explained in include/linux/notifier.h and their implementation is in
kernel/sys.c.
With atomic and blocking chains, the implementation guarantees that the chain
links will not be corrupted and that chain callers will not get messed up by
entries being added or removed. For raw chains the implementation provides no
guarantees at all; users of this API must provide their own protections. (The
idea was that situations may come up where the assumptions of the atomic and
blocking APIs are not appropriate, so it should be possible for users to
handle these things in their own way.)
There are some limitations, which should not be too hard to live with. For
atomic/blocking chains, registration and unregistration must always be done in
a process context since the chain is protected by a mutex/rwsem. Also, a
callout routine for a non-raw chain must not try to register or unregister
entries on its own chain. (This did happen in a couple of places and the code
had to be changed to avoid it.)
Since atomic chains may be called from within an NMI handler, they cannot use
spinlocks for synchronization. Instead we use RCU. The overhead falls almost
entirely in the unregister routine, which is okay since unregistration is much
less frequent that calling a chain.
Here is the list of chains that we adjusted and their classifications. None
of them use the raw API, so for the moment it is only a placeholder.
ATOMIC CHAINS
-------------
arch/i386/kernel/traps.c: i386die_chain
arch/ia64/kernel/traps.c: ia64die_chain
arch/powerpc/kernel/traps.c: powerpc_die_chain
arch/sparc64/kernel/traps.c: sparc64die_chain
arch/x86_64/kernel/traps.c: die_chain
drivers/char/ipmi/ipmi_si_intf.c: xaction_notifier_list
kernel/panic.c: panic_notifier_list
kernel/profile.c: task_free_notifier
net/bluetooth/hci_core.c: hci_notifier
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_chain
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_expect_chain
net/ipv6/addrconf.c: inet6addr_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_expect_chain
net/netlink/af_netlink.c: netlink_chain
BLOCKING CHAINS
---------------
arch/powerpc/platforms/pseries/reconfig.c: pSeries_reconfig_chain
arch/s390/kernel/process.c: idle_chain
arch/x86_64/kernel/process.c idle_notifier
drivers/base/memory.c: memory_chain
drivers/cpufreq/cpufreq.c cpufreq_policy_notifier_list
drivers/cpufreq/cpufreq.c cpufreq_transition_notifier_list
drivers/macintosh/adb.c: adb_client_list
drivers/macintosh/via-pmu.c sleep_notifier_list
drivers/macintosh/via-pmu68k.c sleep_notifier_list
drivers/macintosh/windfarm_core.c wf_client_list
drivers/usb/core/notify.c usb_notifier_list
drivers/video/fbmem.c fb_notifier_list
kernel/cpu.c cpu_chain
kernel/module.c module_notify_list
kernel/profile.c munmap_notifier
kernel/profile.c task_exit_notifier
kernel/sys.c reboot_notifier_list
net/core/dev.c netdev_chain
net/decnet/dn_dev.c: dnaddr_chain
net/ipv4/devinet.c: inetaddr_chain
It's possible that some of these classifications are wrong. If they are,
please let us know or submit a patch to fix them. Note that any chain that
gets called very frequently should be atomic, because the rwsem read-locking
used for blocking chains is very likely to incur cache misses on SMP systems.
(However, if the chain's callout routines may sleep then the chain cannot be
atomic.)
The patch set was written by Alan Stern and Chandra Seetharaman, incorporating
material written by Keith Owens and suggestions from Paul McKenney and Andrew
Morton.
[jes@sgi.com: restructure the notifier chain initialization macros]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Signed-off-by: Jes Sorensen <jes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-27 02:16:30 -07:00
|
|
|
blocking_notifier_call_chain(&inetaddr_chain, NETDEV_DOWN, ifa1);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2005-11-22 15:47:37 -07:00
|
|
|
if (promote) {
|
2011-03-19 06:13:54 -06:00
|
|
|
struct in_ifaddr *next_sec = promote->ifa_next;
|
2005-11-22 15:47:37 -07:00
|
|
|
|
|
|
|
if (prev_prom) {
|
|
|
|
prev_prom->ifa_next = promote->ifa_next;
|
|
|
|
promote->ifa_next = last_prim->ifa_next;
|
|
|
|
last_prim->ifa_next = promote;
|
|
|
|
}
|
2005-05-29 21:23:46 -06:00
|
|
|
|
|
|
|
promote->ifa_flags &= ~IFA_F_SECONDARY;
|
2006-08-15 01:33:59 -06:00
|
|
|
rtmsg_ifa(RTM_NEWADDR, promote, nlh, pid);
|
[PATCH] Notifier chain update: API changes
The kernel's implementation of notifier chains is unsafe. There is no
protection against entries being added to or removed from a chain while the
chain is in use. The issues were discussed in this thread:
http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
We noticed that notifier chains in the kernel fall into two basic usage
classes:
"Blocking" chains are always called from a process context
and the callout routines are allowed to sleep;
"Atomic" chains can be called from an atomic context and
the callout routines are not allowed to sleep.
We decided to codify this distinction and make it part of the API. Therefore
this set of patches introduces three new, parallel APIs: one for blocking
notifiers, one for atomic notifiers, and one for "raw" notifiers (which is
really just the old API under a new name). New kinds of data structures are
used for the heads of the chains, and new routines are defined for
registration, unregistration, and calling a chain. The three APIs are
explained in include/linux/notifier.h and their implementation is in
kernel/sys.c.
With atomic and blocking chains, the implementation guarantees that the chain
links will not be corrupted and that chain callers will not get messed up by
entries being added or removed. For raw chains the implementation provides no
guarantees at all; users of this API must provide their own protections. (The
idea was that situations may come up where the assumptions of the atomic and
blocking APIs are not appropriate, so it should be possible for users to
handle these things in their own way.)
There are some limitations, which should not be too hard to live with. For
atomic/blocking chains, registration and unregistration must always be done in
a process context since the chain is protected by a mutex/rwsem. Also, a
callout routine for a non-raw chain must not try to register or unregister
entries on its own chain. (This did happen in a couple of places and the code
had to be changed to avoid it.)
Since atomic chains may be called from within an NMI handler, they cannot use
spinlocks for synchronization. Instead we use RCU. The overhead falls almost
entirely in the unregister routine, which is okay since unregistration is much
less frequent that calling a chain.
Here is the list of chains that we adjusted and their classifications. None
of them use the raw API, so for the moment it is only a placeholder.
ATOMIC CHAINS
-------------
arch/i386/kernel/traps.c: i386die_chain
arch/ia64/kernel/traps.c: ia64die_chain
arch/powerpc/kernel/traps.c: powerpc_die_chain
arch/sparc64/kernel/traps.c: sparc64die_chain
arch/x86_64/kernel/traps.c: die_chain
drivers/char/ipmi/ipmi_si_intf.c: xaction_notifier_list
kernel/panic.c: panic_notifier_list
kernel/profile.c: task_free_notifier
net/bluetooth/hci_core.c: hci_notifier
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_chain
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_expect_chain
net/ipv6/addrconf.c: inet6addr_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_expect_chain
net/netlink/af_netlink.c: netlink_chain
BLOCKING CHAINS
---------------
arch/powerpc/platforms/pseries/reconfig.c: pSeries_reconfig_chain
arch/s390/kernel/process.c: idle_chain
arch/x86_64/kernel/process.c idle_notifier
drivers/base/memory.c: memory_chain
drivers/cpufreq/cpufreq.c cpufreq_policy_notifier_list
drivers/cpufreq/cpufreq.c cpufreq_transition_notifier_list
drivers/macintosh/adb.c: adb_client_list
drivers/macintosh/via-pmu.c sleep_notifier_list
drivers/macintosh/via-pmu68k.c sleep_notifier_list
drivers/macintosh/windfarm_core.c wf_client_list
drivers/usb/core/notify.c usb_notifier_list
drivers/video/fbmem.c fb_notifier_list
kernel/cpu.c cpu_chain
kernel/module.c module_notify_list
kernel/profile.c munmap_notifier
kernel/profile.c task_exit_notifier
kernel/sys.c reboot_notifier_list
net/core/dev.c netdev_chain
net/decnet/dn_dev.c: dnaddr_chain
net/ipv4/devinet.c: inetaddr_chain
It's possible that some of these classifications are wrong. If they are,
please let us know or submit a patch to fix them. Note that any chain that
gets called very frequently should be atomic, because the rwsem read-locking
used for blocking chains is very likely to incur cache misses on SMP systems.
(However, if the chain's callout routines may sleep then the chain cannot be
atomic.)
The patch set was written by Alan Stern and Chandra Seetharaman, incorporating
material written by Keith Owens and suggestions from Paul McKenney and Andrew
Morton.
[jes@sgi.com: restructure the notifier chain initialization macros]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Signed-off-by: Jes Sorensen <jes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-27 02:16:30 -07:00
|
|
|
blocking_notifier_call_chain(&inetaddr_chain,
|
|
|
|
NETDEV_UP, promote);
|
2011-03-19 06:13:54 -06:00
|
|
|
for (ifa = next_sec; ifa; ifa = ifa->ifa_next) {
|
2005-11-22 15:47:37 -07:00
|
|
|
if (ifa1->ifa_mask != ifa->ifa_mask ||
|
|
|
|
!inet_ifa_match(ifa1->ifa_address, ifa))
|
|
|
|
continue;
|
|
|
|
fib_add_ifaddr(ifa);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2007-06-07 19:35:38 -06:00
|
|
|
if (destroy)
|
2005-11-22 15:47:37 -07:00
|
|
|
inet_free_ifa(ifa1);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2006-08-15 01:33:59 -06:00
|
|
|
static void inet_del_ifa(struct in_device *in_dev, struct in_ifaddr **ifap,
|
|
|
|
int destroy)
|
|
|
|
{
|
|
|
|
__inet_del_ifa(in_dev, ifap, destroy, NULL, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int __inet_insert_ifa(struct in_ifaddr *ifa, struct nlmsghdr *nlh,
|
|
|
|
u32 pid)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct in_device *in_dev = ifa->ifa_dev;
|
|
|
|
struct in_ifaddr *ifa1, **ifap, **last_primary;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
if (!ifa->ifa_local) {
|
|
|
|
inet_free_ifa(ifa);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
ifa->ifa_flags &= ~IFA_F_SECONDARY;
|
|
|
|
last_primary = &in_dev->ifa_list;
|
|
|
|
|
|
|
|
for (ifap = &in_dev->ifa_list; (ifa1 = *ifap) != NULL;
|
|
|
|
ifap = &ifa1->ifa_next) {
|
|
|
|
if (!(ifa1->ifa_flags & IFA_F_SECONDARY) &&
|
|
|
|
ifa->ifa_scope <= ifa1->ifa_scope)
|
|
|
|
last_primary = &ifa1->ifa_next;
|
|
|
|
if (ifa1->ifa_mask == ifa->ifa_mask &&
|
|
|
|
inet_ifa_match(ifa1->ifa_address, ifa)) {
|
|
|
|
if (ifa1->ifa_local == ifa->ifa_local) {
|
|
|
|
inet_free_ifa(ifa);
|
|
|
|
return -EEXIST;
|
|
|
|
}
|
|
|
|
if (ifa1->ifa_scope != ifa->ifa_scope) {
|
|
|
|
inet_free_ifa(ifa);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
ifa->ifa_flags |= IFA_F_SECONDARY;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(ifa->ifa_flags & IFA_F_SECONDARY)) {
|
|
|
|
net_srandom(ifa->ifa_local);
|
|
|
|
ifap = last_primary;
|
|
|
|
}
|
|
|
|
|
|
|
|
ifa->ifa_next = *ifap;
|
|
|
|
*ifap = ifa;
|
|
|
|
|
2011-02-18 13:42:28 -07:00
|
|
|
inet_hash_insert(dev_net(in_dev->dev), ifa);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Send message first, then call notifier.
|
|
|
|
Notifier will trigger FIB update, so that
|
|
|
|
listeners of netlink will know about new ifaddr */
|
2006-08-15 01:33:59 -06:00
|
|
|
rtmsg_ifa(RTM_NEWADDR, ifa, nlh, pid);
|
[PATCH] Notifier chain update: API changes
The kernel's implementation of notifier chains is unsafe. There is no
protection against entries being added to or removed from a chain while the
chain is in use. The issues were discussed in this thread:
http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
We noticed that notifier chains in the kernel fall into two basic usage
classes:
"Blocking" chains are always called from a process context
and the callout routines are allowed to sleep;
"Atomic" chains can be called from an atomic context and
the callout routines are not allowed to sleep.
We decided to codify this distinction and make it part of the API. Therefore
this set of patches introduces three new, parallel APIs: one for blocking
notifiers, one for atomic notifiers, and one for "raw" notifiers (which is
really just the old API under a new name). New kinds of data structures are
used for the heads of the chains, and new routines are defined for
registration, unregistration, and calling a chain. The three APIs are
explained in include/linux/notifier.h and their implementation is in
kernel/sys.c.
With atomic and blocking chains, the implementation guarantees that the chain
links will not be corrupted and that chain callers will not get messed up by
entries being added or removed. For raw chains the implementation provides no
guarantees at all; users of this API must provide their own protections. (The
idea was that situations may come up where the assumptions of the atomic and
blocking APIs are not appropriate, so it should be possible for users to
handle these things in their own way.)
There are some limitations, which should not be too hard to live with. For
atomic/blocking chains, registration and unregistration must always be done in
a process context since the chain is protected by a mutex/rwsem. Also, a
callout routine for a non-raw chain must not try to register or unregister
entries on its own chain. (This did happen in a couple of places and the code
had to be changed to avoid it.)
Since atomic chains may be called from within an NMI handler, they cannot use
spinlocks for synchronization. Instead we use RCU. The overhead falls almost
entirely in the unregister routine, which is okay since unregistration is much
less frequent that calling a chain.
Here is the list of chains that we adjusted and their classifications. None
of them use the raw API, so for the moment it is only a placeholder.
ATOMIC CHAINS
-------------
arch/i386/kernel/traps.c: i386die_chain
arch/ia64/kernel/traps.c: ia64die_chain
arch/powerpc/kernel/traps.c: powerpc_die_chain
arch/sparc64/kernel/traps.c: sparc64die_chain
arch/x86_64/kernel/traps.c: die_chain
drivers/char/ipmi/ipmi_si_intf.c: xaction_notifier_list
kernel/panic.c: panic_notifier_list
kernel/profile.c: task_free_notifier
net/bluetooth/hci_core.c: hci_notifier
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_chain
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_expect_chain
net/ipv6/addrconf.c: inet6addr_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_expect_chain
net/netlink/af_netlink.c: netlink_chain
BLOCKING CHAINS
---------------
arch/powerpc/platforms/pseries/reconfig.c: pSeries_reconfig_chain
arch/s390/kernel/process.c: idle_chain
arch/x86_64/kernel/process.c idle_notifier
drivers/base/memory.c: memory_chain
drivers/cpufreq/cpufreq.c cpufreq_policy_notifier_list
drivers/cpufreq/cpufreq.c cpufreq_transition_notifier_list
drivers/macintosh/adb.c: adb_client_list
drivers/macintosh/via-pmu.c sleep_notifier_list
drivers/macintosh/via-pmu68k.c sleep_notifier_list
drivers/macintosh/windfarm_core.c wf_client_list
drivers/usb/core/notify.c usb_notifier_list
drivers/video/fbmem.c fb_notifier_list
kernel/cpu.c cpu_chain
kernel/module.c module_notify_list
kernel/profile.c munmap_notifier
kernel/profile.c task_exit_notifier
kernel/sys.c reboot_notifier_list
net/core/dev.c netdev_chain
net/decnet/dn_dev.c: dnaddr_chain
net/ipv4/devinet.c: inetaddr_chain
It's possible that some of these classifications are wrong. If they are,
please let us know or submit a patch to fix them. Note that any chain that
gets called very frequently should be atomic, because the rwsem read-locking
used for blocking chains is very likely to incur cache misses on SMP systems.
(However, if the chain's callout routines may sleep then the chain cannot be
atomic.)
The patch set was written by Alan Stern and Chandra Seetharaman, incorporating
material written by Keith Owens and suggestions from Paul McKenney and Andrew
Morton.
[jes@sgi.com: restructure the notifier chain initialization macros]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Signed-off-by: Jes Sorensen <jes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-27 02:16:30 -07:00
|
|
|
blocking_notifier_call_chain(&inetaddr_chain, NETDEV_UP, ifa);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2006-08-15 01:33:59 -06:00
|
|
|
static int inet_insert_ifa(struct in_ifaddr *ifa)
|
|
|
|
{
|
|
|
|
return __inet_insert_ifa(ifa, NULL, 0);
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int inet_set_ifa(struct net_device *dev, struct in_ifaddr *ifa)
|
|
|
|
{
|
2005-10-03 15:35:55 -06:00
|
|
|
struct in_device *in_dev = __in_dev_get_rtnl(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
if (!in_dev) {
|
2007-06-05 00:36:06 -06:00
|
|
|
inet_free_ifa(ifa);
|
|
|
|
return -ENOBUFS;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2007-06-05 00:36:06 -06:00
|
|
|
ipv4_devconf_setall(in_dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (ifa->ifa_dev != in_dev) {
|
2008-07-25 22:43:18 -06:00
|
|
|
WARN_ON(ifa->ifa_dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
in_dev_hold(in_dev);
|
|
|
|
ifa->ifa_dev = in_dev;
|
|
|
|
}
|
2007-12-16 14:45:43 -07:00
|
|
|
if (ipv4_is_loopback(ifa->ifa_local))
|
2005-04-16 16:20:36 -06:00
|
|
|
ifa->ifa_scope = RT_SCOPE_HOST;
|
|
|
|
return inet_insert_ifa(ifa);
|
|
|
|
}
|
|
|
|
|
2010-10-18 18:39:26 -06:00
|
|
|
/* Caller must hold RCU or RTNL :
|
|
|
|
* We dont take a reference on found in_device
|
|
|
|
*/
|
2008-01-21 18:32:38 -07:00
|
|
|
struct in_device *inetdev_by_index(struct net *net, int ifindex)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct net_device *dev;
|
|
|
|
struct in_device *in_dev = NULL;
|
2009-11-01 12:23:04 -07:00
|
|
|
|
|
|
|
rcu_read_lock();
|
|
|
|
dev = dev_get_by_index_rcu(net, ifindex);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (dev)
|
2010-10-18 18:39:26 -06:00
|
|
|
in_dev = rcu_dereference_rtnl(dev->ip_ptr);
|
2009-11-01 12:23:04 -07:00
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
return in_dev;
|
|
|
|
}
|
2009-11-04 23:05:10 -07:00
|
|
|
EXPORT_SYMBOL(inetdev_by_index);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Called only from RTNL semaphored context. No locks. */
|
|
|
|
|
2006-09-26 23:17:09 -06:00
|
|
|
struct in_ifaddr *inet_ifa_byprefix(struct in_device *in_dev, __be32 prefix,
|
|
|
|
__be32 mask)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
for_primary_ifa(in_dev) {
|
|
|
|
if (ifa->ifa_mask == mask && inet_ifa_match(prefix, ifa))
|
|
|
|
return ifa;
|
|
|
|
} endfor_ifa(in_dev);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int inet_rtm_deladdr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
|
|
|
|
{
|
2008-03-25 11:26:21 -06:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2006-08-05 00:04:17 -06:00
|
|
|
struct nlattr *tb[IFA_MAX+1];
|
2005-04-16 16:20:36 -06:00
|
|
|
struct in_device *in_dev;
|
2006-08-05 00:04:17 -06:00
|
|
|
struct ifaddrmsg *ifm;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct in_ifaddr *ifa, **ifap;
|
2006-08-05 00:04:17 -06:00
|
|
|
int err = -EINVAL;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2006-08-05 00:04:17 -06:00
|
|
|
err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
|
|
|
|
if (err < 0)
|
|
|
|
goto errout;
|
|
|
|
|
|
|
|
ifm = nlmsg_data(nlh);
|
2008-01-21 18:32:38 -07:00
|
|
|
in_dev = inetdev_by_index(net, ifm->ifa_index);
|
2006-08-05 00:04:17 -06:00
|
|
|
if (in_dev == NULL) {
|
|
|
|
err = -ENODEV;
|
|
|
|
goto errout;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
|
|
|
|
ifap = &ifa->ifa_next) {
|
2006-08-05 00:04:17 -06:00
|
|
|
if (tb[IFA_LOCAL] &&
|
2006-09-26 23:16:43 -06:00
|
|
|
ifa->ifa_local != nla_get_be32(tb[IFA_LOCAL]))
|
2006-08-05 00:04:17 -06:00
|
|
|
continue;
|
|
|
|
|
|
|
|
if (tb[IFA_LABEL] && nla_strcmp(tb[IFA_LABEL], ifa->ifa_label))
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
2006-08-05 00:04:17 -06:00
|
|
|
|
|
|
|
if (tb[IFA_ADDRESS] &&
|
|
|
|
(ifm->ifa_prefixlen != ifa->ifa_prefixlen ||
|
2006-09-26 23:16:43 -06:00
|
|
|
!inet_ifa_match(nla_get_be32(tb[IFA_ADDRESS]), ifa)))
|
2006-08-05 00:04:17 -06:00
|
|
|
continue;
|
|
|
|
|
2006-08-15 01:33:59 -06:00
|
|
|
__inet_del_ifa(in_dev, ifap, 1, nlh, NETLINK_CB(skb).pid);
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
}
|
2006-08-05 00:04:17 -06:00
|
|
|
|
|
|
|
err = -EADDRNOTAVAIL;
|
|
|
|
errout:
|
|
|
|
return err;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-01-31 19:47:40 -07:00
|
|
|
static struct in_ifaddr *rtm_to_ifaddr(struct net *net, struct nlmsghdr *nlh)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-08-05 00:03:53 -06:00
|
|
|
struct nlattr *tb[IFA_MAX+1];
|
|
|
|
struct in_ifaddr *ifa;
|
|
|
|
struct ifaddrmsg *ifm;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct net_device *dev;
|
|
|
|
struct in_device *in_dev;
|
2008-01-31 19:47:00 -07:00
|
|
|
int err;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-05 00:03:53 -06:00
|
|
|
err = nlmsg_parse(nlh, sizeof(*ifm), tb, IFA_MAX, ifa_ipv4_policy);
|
|
|
|
if (err < 0)
|
|
|
|
goto errout;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-05 00:03:53 -06:00
|
|
|
ifm = nlmsg_data(nlh);
|
2008-01-31 19:47:00 -07:00
|
|
|
err = -EINVAL;
|
|
|
|
if (ifm->ifa_prefixlen > 32 || tb[IFA_LOCAL] == NULL)
|
2006-08-05 00:03:53 -06:00
|
|
|
goto errout;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-31 19:47:40 -07:00
|
|
|
dev = __dev_get_by_index(net, ifm->ifa_index);
|
2008-01-31 19:47:00 -07:00
|
|
|
err = -ENODEV;
|
|
|
|
if (dev == NULL)
|
2006-08-05 00:03:53 -06:00
|
|
|
goto errout;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-05 00:03:53 -06:00
|
|
|
in_dev = __in_dev_get_rtnl(dev);
|
2008-01-31 19:47:00 -07:00
|
|
|
err = -ENOBUFS;
|
|
|
|
if (in_dev == NULL)
|
2007-06-05 00:36:06 -06:00
|
|
|
goto errout;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-05 00:03:53 -06:00
|
|
|
ifa = inet_alloc_ifa();
|
2008-01-31 19:47:00 -07:00
|
|
|
if (ifa == NULL)
|
2006-08-05 00:03:53 -06:00
|
|
|
/*
|
|
|
|
* A potential indev allocation can be left alive, it stays
|
|
|
|
* assigned to its device and is destroy with it.
|
|
|
|
*/
|
|
|
|
goto errout;
|
|
|
|
|
2007-12-08 00:55:43 -07:00
|
|
|
ipv4_devconf_setall(in_dev);
|
2006-08-05 00:03:53 -06:00
|
|
|
in_dev_hold(in_dev);
|
|
|
|
|
|
|
|
if (tb[IFA_ADDRESS] == NULL)
|
|
|
|
tb[IFA_ADDRESS] = tb[IFA_LOCAL];
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2011-02-18 13:42:28 -07:00
|
|
|
INIT_HLIST_NODE(&ifa->hash);
|
2005-04-16 16:20:36 -06:00
|
|
|
ifa->ifa_prefixlen = ifm->ifa_prefixlen;
|
|
|
|
ifa->ifa_mask = inet_make_mask(ifm->ifa_prefixlen);
|
|
|
|
ifa->ifa_flags = ifm->ifa_flags;
|
|
|
|
ifa->ifa_scope = ifm->ifa_scope;
|
2006-08-05 00:03:53 -06:00
|
|
|
ifa->ifa_dev = in_dev;
|
|
|
|
|
2006-09-26 23:16:43 -06:00
|
|
|
ifa->ifa_local = nla_get_be32(tb[IFA_LOCAL]);
|
|
|
|
ifa->ifa_address = nla_get_be32(tb[IFA_ADDRESS]);
|
2006-08-05 00:03:53 -06:00
|
|
|
|
|
|
|
if (tb[IFA_BROADCAST])
|
2006-09-26 23:16:43 -06:00
|
|
|
ifa->ifa_broadcast = nla_get_be32(tb[IFA_BROADCAST]);
|
2006-08-05 00:03:53 -06:00
|
|
|
|
|
|
|
if (tb[IFA_LABEL])
|
|
|
|
nla_strlcpy(ifa->ifa_label, tb[IFA_LABEL], IFNAMSIZ);
|
2005-04-16 16:20:36 -06:00
|
|
|
else
|
|
|
|
memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
|
|
|
|
|
2006-08-05 00:03:53 -06:00
|
|
|
return ifa;
|
|
|
|
|
|
|
|
errout:
|
|
|
|
return ERR_PTR(err);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int inet_rtm_newaddr(struct sk_buff *skb, struct nlmsghdr *nlh, void *arg)
|
|
|
|
{
|
2008-03-25 11:26:21 -06:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2006-08-05 00:03:53 -06:00
|
|
|
struct in_ifaddr *ifa;
|
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
2008-01-31 19:47:40 -07:00
|
|
|
ifa = rtm_to_ifaddr(net, nlh);
|
2006-08-05 00:03:53 -06:00
|
|
|
if (IS_ERR(ifa))
|
|
|
|
return PTR_ERR(ifa);
|
|
|
|
|
2006-08-15 01:33:59 -06:00
|
|
|
return __inet_insert_ifa(ifa, nlh, NETLINK_CB(skb).pid);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Determine a default network mask, based on the IP address.
|
|
|
|
*/
|
|
|
|
|
2009-11-04 23:05:10 -07:00
|
|
|
static inline int inet_abc_len(__be32 addr)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int rc = -1; /* Something else, probably a multicast. */
|
|
|
|
|
2007-12-16 14:45:43 -07:00
|
|
|
if (ipv4_is_zeronet(addr))
|
2007-02-09 07:24:47 -07:00
|
|
|
rc = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
else {
|
2006-11-14 21:51:49 -07:00
|
|
|
__u32 haddr = ntohl(addr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-11-14 21:51:49 -07:00
|
|
|
if (IN_CLASSA(haddr))
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = 8;
|
2006-11-14 21:51:49 -07:00
|
|
|
else if (IN_CLASSB(haddr))
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = 16;
|
2006-11-14 21:51:49 -07:00
|
|
|
else if (IN_CLASSC(haddr))
|
2005-04-16 16:20:36 -06:00
|
|
|
rc = 24;
|
|
|
|
}
|
|
|
|
|
2007-02-09 07:24:47 -07:00
|
|
|
return rc;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-02-28 21:51:43 -07:00
|
|
|
int devinet_ioctl(struct net *net, unsigned int cmd, void __user *arg)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ifreq ifr;
|
|
|
|
struct sockaddr_in sin_orig;
|
|
|
|
struct sockaddr_in *sin = (struct sockaddr_in *)&ifr.ifr_addr;
|
|
|
|
struct in_device *in_dev;
|
|
|
|
struct in_ifaddr **ifap = NULL;
|
|
|
|
struct in_ifaddr *ifa = NULL;
|
|
|
|
struct net_device *dev;
|
|
|
|
char *colon;
|
|
|
|
int ret = -EFAULT;
|
|
|
|
int tryaddrmatch = 0;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Fetch the caller's info block into kernel space
|
|
|
|
*/
|
|
|
|
|
|
|
|
if (copy_from_user(&ifr, arg, sizeof(struct ifreq)))
|
|
|
|
goto out;
|
|
|
|
ifr.ifr_name[IFNAMSIZ - 1] = 0;
|
|
|
|
|
|
|
|
/* save original address for comparison */
|
|
|
|
memcpy(&sin_orig, sin, sizeof(*sin));
|
|
|
|
|
|
|
|
colon = strchr(ifr.ifr_name, ':');
|
|
|
|
if (colon)
|
|
|
|
*colon = 0;
|
|
|
|
|
2008-02-28 21:51:43 -07:00
|
|
|
dev_load(net, ifr.ifr_name);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-03-08 21:44:43 -07:00
|
|
|
switch (cmd) {
|
2005-04-16 16:20:36 -06:00
|
|
|
case SIOCGIFADDR: /* Get interface address */
|
|
|
|
case SIOCGIFBRDADDR: /* Get the broadcast address */
|
|
|
|
case SIOCGIFDSTADDR: /* Get the destination address */
|
|
|
|
case SIOCGIFNETMASK: /* Get the netmask for the interface */
|
|
|
|
/* Note that these ioctls will not sleep,
|
|
|
|
so that we do not impose a lock.
|
|
|
|
One day we will be forced to put shlock here (I mean SMP)
|
|
|
|
*/
|
|
|
|
tryaddrmatch = (sin_orig.sin_family == AF_INET);
|
|
|
|
memset(sin, 0, sizeof(*sin));
|
|
|
|
sin->sin_family = AF_INET;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SIOCSIFFLAGS:
|
|
|
|
ret = -EACCES;
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
|
|
|
goto out;
|
|
|
|
break;
|
|
|
|
case SIOCSIFADDR: /* Set interface address (and family) */
|
|
|
|
case SIOCSIFBRDADDR: /* Set the broadcast address */
|
|
|
|
case SIOCSIFDSTADDR: /* Set the destination address */
|
|
|
|
case SIOCSIFNETMASK: /* Set the netmask for the interface */
|
|
|
|
ret = -EACCES;
|
|
|
|
if (!capable(CAP_NET_ADMIN))
|
|
|
|
goto out;
|
|
|
|
ret = -EINVAL;
|
|
|
|
if (sin->sin_family != AF_INET)
|
|
|
|
goto out;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
rtnl_lock();
|
|
|
|
|
|
|
|
ret = -ENODEV;
|
2009-11-04 23:05:10 -07:00
|
|
|
dev = __dev_get_by_name(net, ifr.ifr_name);
|
|
|
|
if (!dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto done;
|
|
|
|
|
|
|
|
if (colon)
|
|
|
|
*colon = ':';
|
|
|
|
|
2009-11-04 23:05:10 -07:00
|
|
|
in_dev = __in_dev_get_rtnl(dev);
|
|
|
|
if (in_dev) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (tryaddrmatch) {
|
|
|
|
/* Matthias Andree */
|
|
|
|
/* compare label and address (4.4BSD style) */
|
|
|
|
/* note: we only do this for a limited set of ioctls
|
|
|
|
and only if the original address family was AF_INET.
|
|
|
|
This is checked above. */
|
|
|
|
for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
|
|
|
|
ifap = &ifa->ifa_next) {
|
|
|
|
if (!strcmp(ifr.ifr_name, ifa->ifa_label) &&
|
|
|
|
sin_orig.sin_addr.s_addr ==
|
2011-03-09 14:27:16 -07:00
|
|
|
ifa->ifa_local) {
|
2005-04-16 16:20:36 -06:00
|
|
|
break; /* found */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
/* we didn't get a match, maybe the application is
|
|
|
|
4.3BSD-style and passed in junk so we fall back to
|
|
|
|
comparing just the label */
|
|
|
|
if (!ifa) {
|
|
|
|
for (ifap = &in_dev->ifa_list; (ifa = *ifap) != NULL;
|
|
|
|
ifap = &ifa->ifa_next)
|
|
|
|
if (!strcmp(ifr.ifr_name, ifa->ifa_label))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ret = -EADDRNOTAVAIL;
|
|
|
|
if (!ifa && cmd != SIOCSIFADDR && cmd != SIOCSIFFLAGS)
|
|
|
|
goto done;
|
|
|
|
|
2007-03-08 21:44:43 -07:00
|
|
|
switch (cmd) {
|
2005-04-16 16:20:36 -06:00
|
|
|
case SIOCGIFADDR: /* Get interface address */
|
|
|
|
sin->sin_addr.s_addr = ifa->ifa_local;
|
|
|
|
goto rarok;
|
|
|
|
|
|
|
|
case SIOCGIFBRDADDR: /* Get the broadcast address */
|
|
|
|
sin->sin_addr.s_addr = ifa->ifa_broadcast;
|
|
|
|
goto rarok;
|
|
|
|
|
|
|
|
case SIOCGIFDSTADDR: /* Get the destination address */
|
|
|
|
sin->sin_addr.s_addr = ifa->ifa_address;
|
|
|
|
goto rarok;
|
|
|
|
|
|
|
|
case SIOCGIFNETMASK: /* Get the netmask for the interface */
|
|
|
|
sin->sin_addr.s_addr = ifa->ifa_mask;
|
|
|
|
goto rarok;
|
|
|
|
|
|
|
|
case SIOCSIFFLAGS:
|
|
|
|
if (colon) {
|
|
|
|
ret = -EADDRNOTAVAIL;
|
|
|
|
if (!ifa)
|
|
|
|
break;
|
|
|
|
ret = 0;
|
|
|
|
if (!(ifr.ifr_flags & IFF_UP))
|
|
|
|
inet_del_ifa(in_dev, ifap, 1);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
ret = dev_change_flags(dev, ifr.ifr_flags);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SIOCSIFADDR: /* Set interface address (and family) */
|
|
|
|
ret = -EINVAL;
|
|
|
|
if (inet_abc_len(sin->sin_addr.s_addr) < 0)
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (!ifa) {
|
|
|
|
ret = -ENOBUFS;
|
2009-11-04 23:05:10 -07:00
|
|
|
ifa = inet_alloc_ifa();
|
2011-02-18 13:42:28 -07:00
|
|
|
INIT_HLIST_NODE(&ifa->hash);
|
2009-11-04 23:05:10 -07:00
|
|
|
if (!ifa)
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
if (colon)
|
|
|
|
memcpy(ifa->ifa_label, ifr.ifr_name, IFNAMSIZ);
|
|
|
|
else
|
|
|
|
memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
|
|
|
|
} else {
|
|
|
|
ret = 0;
|
|
|
|
if (ifa->ifa_local == sin->sin_addr.s_addr)
|
|
|
|
break;
|
|
|
|
inet_del_ifa(in_dev, ifap, 0);
|
|
|
|
ifa->ifa_broadcast = 0;
|
2008-02-26 19:17:53 -07:00
|
|
|
ifa->ifa_scope = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
ifa->ifa_address = ifa->ifa_local = sin->sin_addr.s_addr;
|
|
|
|
|
|
|
|
if (!(dev->flags & IFF_POINTOPOINT)) {
|
|
|
|
ifa->ifa_prefixlen = inet_abc_len(ifa->ifa_address);
|
|
|
|
ifa->ifa_mask = inet_make_mask(ifa->ifa_prefixlen);
|
|
|
|
if ((dev->flags & IFF_BROADCAST) &&
|
|
|
|
ifa->ifa_prefixlen < 31)
|
|
|
|
ifa->ifa_broadcast = ifa->ifa_address |
|
|
|
|
~ifa->ifa_mask;
|
|
|
|
} else {
|
|
|
|
ifa->ifa_prefixlen = 32;
|
|
|
|
ifa->ifa_mask = inet_make_mask(32);
|
|
|
|
}
|
|
|
|
ret = inet_set_ifa(dev, ifa);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SIOCSIFBRDADDR: /* Set the broadcast address */
|
|
|
|
ret = 0;
|
|
|
|
if (ifa->ifa_broadcast != sin->sin_addr.s_addr) {
|
|
|
|
inet_del_ifa(in_dev, ifap, 0);
|
|
|
|
ifa->ifa_broadcast = sin->sin_addr.s_addr;
|
|
|
|
inet_insert_ifa(ifa);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SIOCSIFDSTADDR: /* Set the destination address */
|
|
|
|
ret = 0;
|
|
|
|
if (ifa->ifa_address == sin->sin_addr.s_addr)
|
|
|
|
break;
|
|
|
|
ret = -EINVAL;
|
|
|
|
if (inet_abc_len(sin->sin_addr.s_addr) < 0)
|
|
|
|
break;
|
|
|
|
ret = 0;
|
|
|
|
inet_del_ifa(in_dev, ifap, 0);
|
|
|
|
ifa->ifa_address = sin->sin_addr.s_addr;
|
|
|
|
inet_insert_ifa(ifa);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SIOCSIFNETMASK: /* Set the netmask for the interface */
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The mask we set must be legal.
|
|
|
|
*/
|
|
|
|
ret = -EINVAL;
|
|
|
|
if (bad_mask(sin->sin_addr.s_addr, 0))
|
|
|
|
break;
|
|
|
|
ret = 0;
|
|
|
|
if (ifa->ifa_mask != sin->sin_addr.s_addr) {
|
2006-09-28 19:00:55 -06:00
|
|
|
__be32 old_mask = ifa->ifa_mask;
|
2005-04-16 16:20:36 -06:00
|
|
|
inet_del_ifa(in_dev, ifap, 0);
|
|
|
|
ifa->ifa_mask = sin->sin_addr.s_addr;
|
|
|
|
ifa->ifa_prefixlen = inet_mask_len(ifa->ifa_mask);
|
|
|
|
|
|
|
|
/* See if current broadcast address matches
|
|
|
|
* with current netmask, then recalculate
|
|
|
|
* the broadcast address. Otherwise it's a
|
|
|
|
* funny address, so don't touch it since
|
|
|
|
* the user seems to know what (s)he's doing...
|
|
|
|
*/
|
|
|
|
if ((dev->flags & IFF_BROADCAST) &&
|
|
|
|
(ifa->ifa_prefixlen < 31) &&
|
|
|
|
(ifa->ifa_broadcast ==
|
2005-10-21 21:09:16 -06:00
|
|
|
(ifa->ifa_local|~old_mask))) {
|
2005-04-16 16:20:36 -06:00
|
|
|
ifa->ifa_broadcast = (ifa->ifa_local |
|
|
|
|
~sin->sin_addr.s_addr);
|
|
|
|
}
|
|
|
|
inet_insert_ifa(ifa);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
done:
|
|
|
|
rtnl_unlock();
|
|
|
|
out:
|
|
|
|
return ret;
|
|
|
|
rarok:
|
|
|
|
rtnl_unlock();
|
|
|
|
ret = copy_to_user(arg, &ifr, sizeof(struct ifreq)) ? -EFAULT : 0;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int inet_gifconf(struct net_device *dev, char __user *buf, int len)
|
|
|
|
{
|
2005-10-03 15:35:55 -06:00
|
|
|
struct in_device *in_dev = __in_dev_get_rtnl(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
struct in_ifaddr *ifa;
|
|
|
|
struct ifreq ifr;
|
|
|
|
int done = 0;
|
|
|
|
|
2009-11-04 23:05:10 -07:00
|
|
|
if (!in_dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
goto out;
|
|
|
|
|
2009-11-04 23:05:10 -07:00
|
|
|
for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!buf) {
|
|
|
|
done += sizeof(ifr);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (len < (int) sizeof(ifr))
|
|
|
|
break;
|
|
|
|
memset(&ifr, 0, sizeof(struct ifreq));
|
|
|
|
if (ifa->ifa_label)
|
|
|
|
strcpy(ifr.ifr_name, ifa->ifa_label);
|
|
|
|
else
|
|
|
|
strcpy(ifr.ifr_name, dev->name);
|
|
|
|
|
|
|
|
(*(struct sockaddr_in *)&ifr.ifr_addr).sin_family = AF_INET;
|
|
|
|
(*(struct sockaddr_in *)&ifr.ifr_addr).sin_addr.s_addr =
|
|
|
|
ifa->ifa_local;
|
|
|
|
|
|
|
|
if (copy_to_user(buf, &ifr, sizeof(struct ifreq))) {
|
|
|
|
done = -EFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
buf += sizeof(struct ifreq);
|
|
|
|
len -= sizeof(struct ifreq);
|
|
|
|
done += sizeof(struct ifreq);
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return done;
|
|
|
|
}
|
|
|
|
|
2006-09-26 22:27:54 -06:00
|
|
|
__be32 inet_select_addr(const struct net_device *dev, __be32 dst, int scope)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-09-26 22:27:54 -06:00
|
|
|
__be32 addr = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct in_device *in_dev;
|
2008-03-25 06:47:49 -06:00
|
|
|
struct net *net = dev_net(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
rcu_read_lock();
|
2005-10-03 15:35:55 -06:00
|
|
|
in_dev = __in_dev_get_rcu(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!in_dev)
|
|
|
|
goto no_in_dev;
|
|
|
|
|
|
|
|
for_primary_ifa(in_dev) {
|
|
|
|
if (ifa->ifa_scope > scope)
|
|
|
|
continue;
|
|
|
|
if (!dst || inet_ifa_match(dst, ifa)) {
|
|
|
|
addr = ifa->ifa_local;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!addr)
|
|
|
|
addr = ifa->ifa_local;
|
|
|
|
} endfor_ifa(in_dev);
|
|
|
|
|
|
|
|
if (addr)
|
2009-11-04 06:43:23 -07:00
|
|
|
goto out_unlock;
|
2009-11-04 23:05:10 -07:00
|
|
|
no_in_dev:
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Not loopback addresses on loopback should be preferred
|
|
|
|
in this case. It is importnat that lo is the first interface
|
|
|
|
in dev_base list.
|
|
|
|
*/
|
2009-11-04 06:43:23 -07:00
|
|
|
for_each_netdev_rcu(net, dev) {
|
2009-11-04 23:05:10 -07:00
|
|
|
in_dev = __in_dev_get_rcu(dev);
|
|
|
|
if (!in_dev)
|
2005-04-16 16:20:36 -06:00
|
|
|
continue;
|
|
|
|
|
|
|
|
for_primary_ifa(in_dev) {
|
|
|
|
if (ifa->ifa_scope != RT_SCOPE_LINK &&
|
|
|
|
ifa->ifa_scope <= scope) {
|
|
|
|
addr = ifa->ifa_local;
|
2009-11-04 06:43:23 -07:00
|
|
|
goto out_unlock;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
} endfor_ifa(in_dev);
|
|
|
|
}
|
2009-11-04 06:43:23 -07:00
|
|
|
out_unlock:
|
2005-04-16 16:20:36 -06:00
|
|
|
rcu_read_unlock();
|
|
|
|
return addr;
|
|
|
|
}
|
2009-11-04 23:05:10 -07:00
|
|
|
EXPORT_SYMBOL(inet_select_addr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-09-26 23:17:09 -06:00
|
|
|
static __be32 confirm_addr_indev(struct in_device *in_dev, __be32 dst,
|
|
|
|
__be32 local, int scope)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int same = 0;
|
2006-09-28 19:00:55 -06:00
|
|
|
__be32 addr = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
for_ifa(in_dev) {
|
|
|
|
if (!addr &&
|
|
|
|
(local == ifa->ifa_local || !local) &&
|
|
|
|
ifa->ifa_scope <= scope) {
|
|
|
|
addr = ifa->ifa_local;
|
|
|
|
if (same)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!same) {
|
|
|
|
same = (!local || inet_ifa_match(local, ifa)) &&
|
|
|
|
(!dst || inet_ifa_match(dst, ifa));
|
|
|
|
if (same && addr) {
|
|
|
|
if (local || !dst)
|
|
|
|
break;
|
|
|
|
/* Is the selected addr into dst subnet? */
|
|
|
|
if (inet_ifa_match(addr, ifa))
|
|
|
|
break;
|
|
|
|
/* No, then can we use new local src? */
|
|
|
|
if (ifa->ifa_scope <= scope) {
|
|
|
|
addr = ifa->ifa_local;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* search for large dst subnet for addr */
|
|
|
|
same = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} endfor_ifa(in_dev);
|
|
|
|
|
2009-11-04 23:05:10 -07:00
|
|
|
return same ? addr : 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Confirm that local IP address exists using wildcards:
|
2008-01-15 00:05:55 -07:00
|
|
|
* - in_dev: only on this interface, 0=any interface
|
2005-04-16 16:20:36 -06:00
|
|
|
* - dst: only in the same subnet as dst, 0=any dst
|
|
|
|
* - local: address, 0=autoselect the local address
|
|
|
|
* - scope: maximum allowed scope value for the local address
|
|
|
|
*/
|
2008-01-15 00:05:55 -07:00
|
|
|
__be32 inet_confirm_addr(struct in_device *in_dev,
|
|
|
|
__be32 dst, __be32 local, int scope)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-09-26 23:17:09 -06:00
|
|
|
__be32 addr = 0;
|
2008-01-15 00:05:55 -07:00
|
|
|
struct net_device *dev;
|
2008-01-15 00:06:19 -07:00
|
|
|
struct net *net;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-15 00:06:19 -07:00
|
|
|
if (scope != RT_SCOPE_LINK)
|
2008-01-15 00:05:55 -07:00
|
|
|
return confirm_addr_indev(in_dev, dst, local, scope);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-03-25 06:47:49 -06:00
|
|
|
net = dev_net(in_dev->dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
rcu_read_lock();
|
2009-11-04 06:43:23 -07:00
|
|
|
for_each_netdev_rcu(net, dev) {
|
2009-11-04 23:05:10 -07:00
|
|
|
in_dev = __in_dev_get_rcu(dev);
|
|
|
|
if (in_dev) {
|
2005-04-16 16:20:36 -06:00
|
|
|
addr = confirm_addr_indev(in_dev, dst, local, scope);
|
|
|
|
if (addr)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
|
|
|
|
|
|
|
return addr;
|
|
|
|
}
|
2012-03-22 10:14:29 -06:00
|
|
|
EXPORT_SYMBOL(inet_confirm_addr);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Device notifier
|
|
|
|
*/
|
|
|
|
|
|
|
|
int register_inetaddr_notifier(struct notifier_block *nb)
|
|
|
|
{
|
[PATCH] Notifier chain update: API changes
The kernel's implementation of notifier chains is unsafe. There is no
protection against entries being added to or removed from a chain while the
chain is in use. The issues were discussed in this thread:
http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
We noticed that notifier chains in the kernel fall into two basic usage
classes:
"Blocking" chains are always called from a process context
and the callout routines are allowed to sleep;
"Atomic" chains can be called from an atomic context and
the callout routines are not allowed to sleep.
We decided to codify this distinction and make it part of the API. Therefore
this set of patches introduces three new, parallel APIs: one for blocking
notifiers, one for atomic notifiers, and one for "raw" notifiers (which is
really just the old API under a new name). New kinds of data structures are
used for the heads of the chains, and new routines are defined for
registration, unregistration, and calling a chain. The three APIs are
explained in include/linux/notifier.h and their implementation is in
kernel/sys.c.
With atomic and blocking chains, the implementation guarantees that the chain
links will not be corrupted and that chain callers will not get messed up by
entries being added or removed. For raw chains the implementation provides no
guarantees at all; users of this API must provide their own protections. (The
idea was that situations may come up where the assumptions of the atomic and
blocking APIs are not appropriate, so it should be possible for users to
handle these things in their own way.)
There are some limitations, which should not be too hard to live with. For
atomic/blocking chains, registration and unregistration must always be done in
a process context since the chain is protected by a mutex/rwsem. Also, a
callout routine for a non-raw chain must not try to register or unregister
entries on its own chain. (This did happen in a couple of places and the code
had to be changed to avoid it.)
Since atomic chains may be called from within an NMI handler, they cannot use
spinlocks for synchronization. Instead we use RCU. The overhead falls almost
entirely in the unregister routine, which is okay since unregistration is much
less frequent that calling a chain.
Here is the list of chains that we adjusted and their classifications. None
of them use the raw API, so for the moment it is only a placeholder.
ATOMIC CHAINS
-------------
arch/i386/kernel/traps.c: i386die_chain
arch/ia64/kernel/traps.c: ia64die_chain
arch/powerpc/kernel/traps.c: powerpc_die_chain
arch/sparc64/kernel/traps.c: sparc64die_chain
arch/x86_64/kernel/traps.c: die_chain
drivers/char/ipmi/ipmi_si_intf.c: xaction_notifier_list
kernel/panic.c: panic_notifier_list
kernel/profile.c: task_free_notifier
net/bluetooth/hci_core.c: hci_notifier
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_chain
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_expect_chain
net/ipv6/addrconf.c: inet6addr_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_expect_chain
net/netlink/af_netlink.c: netlink_chain
BLOCKING CHAINS
---------------
arch/powerpc/platforms/pseries/reconfig.c: pSeries_reconfig_chain
arch/s390/kernel/process.c: idle_chain
arch/x86_64/kernel/process.c idle_notifier
drivers/base/memory.c: memory_chain
drivers/cpufreq/cpufreq.c cpufreq_policy_notifier_list
drivers/cpufreq/cpufreq.c cpufreq_transition_notifier_list
drivers/macintosh/adb.c: adb_client_list
drivers/macintosh/via-pmu.c sleep_notifier_list
drivers/macintosh/via-pmu68k.c sleep_notifier_list
drivers/macintosh/windfarm_core.c wf_client_list
drivers/usb/core/notify.c usb_notifier_list
drivers/video/fbmem.c fb_notifier_list
kernel/cpu.c cpu_chain
kernel/module.c module_notify_list
kernel/profile.c munmap_notifier
kernel/profile.c task_exit_notifier
kernel/sys.c reboot_notifier_list
net/core/dev.c netdev_chain
net/decnet/dn_dev.c: dnaddr_chain
net/ipv4/devinet.c: inetaddr_chain
It's possible that some of these classifications are wrong. If they are,
please let us know or submit a patch to fix them. Note that any chain that
gets called very frequently should be atomic, because the rwsem read-locking
used for blocking chains is very likely to incur cache misses on SMP systems.
(However, if the chain's callout routines may sleep then the chain cannot be
atomic.)
The patch set was written by Alan Stern and Chandra Seetharaman, incorporating
material written by Keith Owens and suggestions from Paul McKenney and Andrew
Morton.
[jes@sgi.com: restructure the notifier chain initialization macros]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Signed-off-by: Jes Sorensen <jes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-27 02:16:30 -07:00
|
|
|
return blocking_notifier_chain_register(&inetaddr_chain, nb);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-11-04 23:05:10 -07:00
|
|
|
EXPORT_SYMBOL(register_inetaddr_notifier);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
int unregister_inetaddr_notifier(struct notifier_block *nb)
|
|
|
|
{
|
[PATCH] Notifier chain update: API changes
The kernel's implementation of notifier chains is unsafe. There is no
protection against entries being added to or removed from a chain while the
chain is in use. The issues were discussed in this thread:
http://marc.theaimsgroup.com/?l=linux-kernel&m=113018709002036&w=2
We noticed that notifier chains in the kernel fall into two basic usage
classes:
"Blocking" chains are always called from a process context
and the callout routines are allowed to sleep;
"Atomic" chains can be called from an atomic context and
the callout routines are not allowed to sleep.
We decided to codify this distinction and make it part of the API. Therefore
this set of patches introduces three new, parallel APIs: one for blocking
notifiers, one for atomic notifiers, and one for "raw" notifiers (which is
really just the old API under a new name). New kinds of data structures are
used for the heads of the chains, and new routines are defined for
registration, unregistration, and calling a chain. The three APIs are
explained in include/linux/notifier.h and their implementation is in
kernel/sys.c.
With atomic and blocking chains, the implementation guarantees that the chain
links will not be corrupted and that chain callers will not get messed up by
entries being added or removed. For raw chains the implementation provides no
guarantees at all; users of this API must provide their own protections. (The
idea was that situations may come up where the assumptions of the atomic and
blocking APIs are not appropriate, so it should be possible for users to
handle these things in their own way.)
There are some limitations, which should not be too hard to live with. For
atomic/blocking chains, registration and unregistration must always be done in
a process context since the chain is protected by a mutex/rwsem. Also, a
callout routine for a non-raw chain must not try to register or unregister
entries on its own chain. (This did happen in a couple of places and the code
had to be changed to avoid it.)
Since atomic chains may be called from within an NMI handler, they cannot use
spinlocks for synchronization. Instead we use RCU. The overhead falls almost
entirely in the unregister routine, which is okay since unregistration is much
less frequent that calling a chain.
Here is the list of chains that we adjusted and their classifications. None
of them use the raw API, so for the moment it is only a placeholder.
ATOMIC CHAINS
-------------
arch/i386/kernel/traps.c: i386die_chain
arch/ia64/kernel/traps.c: ia64die_chain
arch/powerpc/kernel/traps.c: powerpc_die_chain
arch/sparc64/kernel/traps.c: sparc64die_chain
arch/x86_64/kernel/traps.c: die_chain
drivers/char/ipmi/ipmi_si_intf.c: xaction_notifier_list
kernel/panic.c: panic_notifier_list
kernel/profile.c: task_free_notifier
net/bluetooth/hci_core.c: hci_notifier
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_chain
net/ipv4/netfilter/ip_conntrack_core.c: ip_conntrack_expect_chain
net/ipv6/addrconf.c: inet6addr_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_chain
net/netfilter/nf_conntrack_core.c: nf_conntrack_expect_chain
net/netlink/af_netlink.c: netlink_chain
BLOCKING CHAINS
---------------
arch/powerpc/platforms/pseries/reconfig.c: pSeries_reconfig_chain
arch/s390/kernel/process.c: idle_chain
arch/x86_64/kernel/process.c idle_notifier
drivers/base/memory.c: memory_chain
drivers/cpufreq/cpufreq.c cpufreq_policy_notifier_list
drivers/cpufreq/cpufreq.c cpufreq_transition_notifier_list
drivers/macintosh/adb.c: adb_client_list
drivers/macintosh/via-pmu.c sleep_notifier_list
drivers/macintosh/via-pmu68k.c sleep_notifier_list
drivers/macintosh/windfarm_core.c wf_client_list
drivers/usb/core/notify.c usb_notifier_list
drivers/video/fbmem.c fb_notifier_list
kernel/cpu.c cpu_chain
kernel/module.c module_notify_list
kernel/profile.c munmap_notifier
kernel/profile.c task_exit_notifier
kernel/sys.c reboot_notifier_list
net/core/dev.c netdev_chain
net/decnet/dn_dev.c: dnaddr_chain
net/ipv4/devinet.c: inetaddr_chain
It's possible that some of these classifications are wrong. If they are,
please let us know or submit a patch to fix them. Note that any chain that
gets called very frequently should be atomic, because the rwsem read-locking
used for blocking chains is very likely to incur cache misses on SMP systems.
(However, if the chain's callout routines may sleep then the chain cannot be
atomic.)
The patch set was written by Alan Stern and Chandra Seetharaman, incorporating
material written by Keith Owens and suggestions from Paul McKenney and Andrew
Morton.
[jes@sgi.com: restructure the notifier chain initialization macros]
Signed-off-by: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: Chandra Seetharaman <sekharan@us.ibm.com>
Signed-off-by: Jes Sorensen <jes@sgi.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-03-27 02:16:30 -07:00
|
|
|
return blocking_notifier_chain_unregister(&inetaddr_chain, nb);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
2009-11-04 23:05:10 -07:00
|
|
|
EXPORT_SYMBOL(unregister_inetaddr_notifier);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-11-04 23:05:10 -07:00
|
|
|
/* Rename ifa_labels for a device name change. Make some effort to preserve
|
|
|
|
* existing alias numbering and to create unique labels if possible.
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
static void inetdev_changename(struct net_device *dev, struct in_device *in_dev)
|
2007-02-09 07:24:47 -07:00
|
|
|
{
|
2005-04-16 16:20:36 -06:00
|
|
|
struct in_ifaddr *ifa;
|
|
|
|
int named = 0;
|
|
|
|
|
2007-02-09 07:24:47 -07:00
|
|
|
for (ifa = in_dev->ifa_list; ifa; ifa = ifa->ifa_next) {
|
|
|
|
char old[IFNAMSIZ], *dot;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
memcpy(old, ifa->ifa_label, IFNAMSIZ);
|
2007-02-09 07:24:47 -07:00
|
|
|
memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (named++ == 0)
|
2008-06-10 16:40:04 -06:00
|
|
|
goto skip;
|
2008-01-04 01:56:25 -07:00
|
|
|
dot = strchr(old, ':');
|
2007-02-09 07:24:47 -07:00
|
|
|
if (dot == NULL) {
|
|
|
|
sprintf(old, ":%d", named);
|
2005-04-16 16:20:36 -06:00
|
|
|
dot = old;
|
|
|
|
}
|
2009-11-04 23:05:10 -07:00
|
|
|
if (strlen(dot) + strlen(dev->name) < IFNAMSIZ)
|
2007-02-09 07:24:47 -07:00
|
|
|
strcat(ifa->ifa_label, dot);
|
2009-11-04 23:05:10 -07:00
|
|
|
else
|
2007-02-09 07:24:47 -07:00
|
|
|
strcpy(ifa->ifa_label + (IFNAMSIZ - strlen(dot) - 1), dot);
|
2008-06-10 16:40:04 -06:00
|
|
|
skip:
|
|
|
|
rtmsg_ifa(RTM_NEWADDR, ifa, NULL, 0);
|
2007-02-09 07:24:47 -07:00
|
|
|
}
|
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-04-14 23:58:06 -06:00
|
|
|
static inline bool inetdev_valid_mtu(unsigned int mtu)
|
2008-09-02 18:28:58 -06:00
|
|
|
{
|
|
|
|
return mtu >= 68;
|
|
|
|
}
|
|
|
|
|
2011-02-11 00:44:16 -07:00
|
|
|
static void inetdev_send_gratuitous_arp(struct net_device *dev,
|
|
|
|
struct in_device *in_dev)
|
|
|
|
|
|
|
|
{
|
2011-07-24 07:09:30 -06:00
|
|
|
struct in_ifaddr *ifa;
|
2011-02-11 00:44:16 -07:00
|
|
|
|
2011-07-24 07:09:30 -06:00
|
|
|
for (ifa = in_dev->ifa_list; ifa;
|
|
|
|
ifa = ifa->ifa_next) {
|
|
|
|
arp_send(ARPOP_REQUEST, ETH_P_ARP,
|
|
|
|
ifa->ifa_local, dev,
|
|
|
|
ifa->ifa_local, NULL,
|
|
|
|
dev->dev_addr, NULL);
|
|
|
|
}
|
2011-02-11 00:44:16 -07:00
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Called only under RTNL semaphore */
|
|
|
|
|
|
|
|
static int inetdev_event(struct notifier_block *this, unsigned long event,
|
|
|
|
void *ptr)
|
|
|
|
{
|
|
|
|
struct net_device *dev = ptr;
|
2005-10-03 15:35:55 -06:00
|
|
|
struct in_device *in_dev = __in_dev_get_rtnl(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
ASSERT_RTNL();
|
|
|
|
|
|
|
|
if (!in_dev) {
|
2007-02-21 09:53:47 -07:00
|
|
|
if (event == NETDEV_REGISTER) {
|
2005-04-16 16:20:36 -06:00
|
|
|
in_dev = inetdev_init(dev);
|
2007-07-30 18:04:52 -06:00
|
|
|
if (!in_dev)
|
|
|
|
return notifier_from_errno(-ENOMEM);
|
2007-09-26 23:10:06 -06:00
|
|
|
if (dev->flags & IFF_LOOPBACK) {
|
2007-06-05 00:34:44 -06:00
|
|
|
IN_DEV_CONF_SET(in_dev, NOXFRM, 1);
|
|
|
|
IN_DEV_CONF_SET(in_dev, NOPOLICY, 1);
|
2007-02-21 09:53:47 -07:00
|
|
|
}
|
2008-09-02 18:28:58 -06:00
|
|
|
} else if (event == NETDEV_CHANGEMTU) {
|
|
|
|
/* Re-enabling IP */
|
|
|
|
if (inetdev_valid_mtu(dev->mtu))
|
|
|
|
in_dev = inetdev_init(dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (event) {
|
|
|
|
case NETDEV_REGISTER:
|
2012-05-15 08:11:54 -06:00
|
|
|
pr_debug("%s: bug\n", __func__);
|
2011-08-01 10:19:00 -06:00
|
|
|
RCU_INIT_POINTER(dev->ip_ptr, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case NETDEV_UP:
|
2008-09-02 18:28:58 -06:00
|
|
|
if (!inetdev_valid_mtu(dev->mtu))
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2007-09-26 23:10:06 -06:00
|
|
|
if (dev->flags & IFF_LOOPBACK) {
|
2009-11-04 23:05:10 -07:00
|
|
|
struct in_ifaddr *ifa = inet_alloc_ifa();
|
|
|
|
|
|
|
|
if (ifa) {
|
2011-02-18 13:42:28 -07:00
|
|
|
INIT_HLIST_NODE(&ifa->hash);
|
2005-04-16 16:20:36 -06:00
|
|
|
ifa->ifa_local =
|
|
|
|
ifa->ifa_address = htonl(INADDR_LOOPBACK);
|
|
|
|
ifa->ifa_prefixlen = 8;
|
|
|
|
ifa->ifa_mask = inet_make_mask(8);
|
|
|
|
in_dev_hold(in_dev);
|
|
|
|
ifa->ifa_dev = in_dev;
|
|
|
|
ifa->ifa_scope = RT_SCOPE_HOST;
|
|
|
|
memcpy(ifa->ifa_label, dev->name, IFNAMSIZ);
|
|
|
|
inet_insert_ifa(ifa);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
ip_mc_up(in_dev);
|
2009-02-01 02:04:33 -07:00
|
|
|
/* fall through */
|
|
|
|
case NETDEV_CHANGEADDR:
|
2011-02-11 00:44:16 -07:00
|
|
|
if (!IN_DEV_ARP_NOTIFY(in_dev))
|
|
|
|
break;
|
|
|
|
/* fall through */
|
|
|
|
case NETDEV_NOTIFY_PEERS:
|
2009-10-07 04:18:17 -06:00
|
|
|
/* Send gratuitous ARP to notify of link change */
|
2011-02-11 00:44:16 -07:00
|
|
|
inetdev_send_gratuitous_arp(dev, in_dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
case NETDEV_DOWN:
|
|
|
|
ip_mc_down(in_dev);
|
|
|
|
break;
|
2010-03-10 03:28:56 -07:00
|
|
|
case NETDEV_PRE_TYPE_CHANGE:
|
2009-09-15 03:37:40 -06:00
|
|
|
ip_mc_unmap(in_dev);
|
|
|
|
break;
|
2010-03-10 03:28:56 -07:00
|
|
|
case NETDEV_POST_TYPE_CHANGE:
|
2009-09-15 03:37:40 -06:00
|
|
|
ip_mc_remap(in_dev);
|
|
|
|
break;
|
2005-04-16 16:20:36 -06:00
|
|
|
case NETDEV_CHANGEMTU:
|
2008-09-02 18:28:58 -06:00
|
|
|
if (inetdev_valid_mtu(dev->mtu))
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
2008-09-02 18:28:58 -06:00
|
|
|
/* disable IP when MTU is not enough */
|
2005-04-16 16:20:36 -06:00
|
|
|
case NETDEV_UNREGISTER:
|
|
|
|
inetdev_destroy(in_dev);
|
|
|
|
break;
|
|
|
|
case NETDEV_CHANGENAME:
|
|
|
|
/* Do not notify about label change, this event is
|
|
|
|
* not interesting to applications using netlink.
|
|
|
|
*/
|
|
|
|
inetdev_changename(dev, in_dev);
|
|
|
|
|
2007-12-11 03:17:40 -07:00
|
|
|
devinet_sysctl_unregister(in_dev);
|
2007-12-01 06:55:54 -07:00
|
|
|
devinet_sysctl_register(in_dev);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
out:
|
|
|
|
return NOTIFY_DONE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct notifier_block ip_netdev_notifier = {
|
2008-11-03 03:48:48 -07:00
|
|
|
.notifier_call = inetdev_event,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2006-11-10 15:10:15 -07:00
|
|
|
static inline size_t inet_nlmsg_size(void)
|
|
|
|
{
|
|
|
|
return NLMSG_ALIGN(sizeof(struct ifaddrmsg))
|
|
|
|
+ nla_total_size(4) /* IFA_ADDRESS */
|
|
|
|
+ nla_total_size(4) /* IFA_LOCAL */
|
|
|
|
+ nla_total_size(4) /* IFA_BROADCAST */
|
|
|
|
+ nla_total_size(IFNAMSIZ); /* IFA_LABEL */
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int inet_fill_ifaddr(struct sk_buff *skb, struct in_ifaddr *ifa,
|
2005-06-18 23:54:12 -06:00
|
|
|
u32 pid, u32 seq, int event, unsigned int flags)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct ifaddrmsg *ifm;
|
|
|
|
struct nlmsghdr *nlh;
|
|
|
|
|
2006-08-05 00:04:36 -06:00
|
|
|
nlh = nlmsg_put(skb, pid, seq, event, sizeof(*ifm), flags);
|
|
|
|
if (nlh == NULL)
|
2007-02-01 00:16:40 -07:00
|
|
|
return -EMSGSIZE;
|
2006-08-05 00:04:36 -06:00
|
|
|
|
|
|
|
ifm = nlmsg_data(nlh);
|
2005-04-16 16:20:36 -06:00
|
|
|
ifm->ifa_family = AF_INET;
|
|
|
|
ifm->ifa_prefixlen = ifa->ifa_prefixlen;
|
|
|
|
ifm->ifa_flags = ifa->ifa_flags|IFA_F_PERMANENT;
|
|
|
|
ifm->ifa_scope = ifa->ifa_scope;
|
|
|
|
ifm->ifa_index = ifa->ifa_dev->dev->ifindex;
|
2006-08-05 00:04:36 -06:00
|
|
|
|
2012-04-01 18:39:02 -06:00
|
|
|
if ((ifa->ifa_address &&
|
|
|
|
nla_put_be32(skb, IFA_ADDRESS, ifa->ifa_address)) ||
|
|
|
|
(ifa->ifa_local &&
|
|
|
|
nla_put_be32(skb, IFA_LOCAL, ifa->ifa_local)) ||
|
|
|
|
(ifa->ifa_broadcast &&
|
|
|
|
nla_put_be32(skb, IFA_BROADCAST, ifa->ifa_broadcast)) ||
|
|
|
|
(ifa->ifa_label[0] &&
|
|
|
|
nla_put_string(skb, IFA_LABEL, ifa->ifa_label)))
|
|
|
|
goto nla_put_failure;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2006-08-05 00:04:36 -06:00
|
|
|
return nlmsg_end(skb, nlh);
|
|
|
|
|
|
|
|
nla_put_failure:
|
2007-02-01 00:16:40 -07:00
|
|
|
nlmsg_cancel(skb, nlh);
|
|
|
|
return -EMSGSIZE;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int inet_dump_ifaddr(struct sk_buff *skb, struct netlink_callback *cb)
|
|
|
|
{
|
2008-03-25 11:26:21 -06:00
|
|
|
struct net *net = sock_net(skb->sk);
|
2009-11-12 00:44:25 -07:00
|
|
|
int h, s_h;
|
|
|
|
int idx, s_idx;
|
|
|
|
int ip_idx, s_ip_idx;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct net_device *dev;
|
|
|
|
struct in_device *in_dev;
|
|
|
|
struct in_ifaddr *ifa;
|
2009-11-12 00:44:25 -07:00
|
|
|
struct hlist_head *head;
|
|
|
|
struct hlist_node *node;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-11-12 00:44:25 -07:00
|
|
|
s_h = cb->args[0];
|
|
|
|
s_idx = idx = cb->args[1];
|
|
|
|
s_ip_idx = ip_idx = cb->args[2];
|
|
|
|
|
|
|
|
for (h = s_h; h < NETDEV_HASHENTRIES; h++, s_idx = 0) {
|
|
|
|
idx = 0;
|
|
|
|
head = &net->dev_index_head[h];
|
|
|
|
rcu_read_lock();
|
|
|
|
hlist_for_each_entry_rcu(dev, node, head, index_hlist) {
|
|
|
|
if (idx < s_idx)
|
|
|
|
goto cont;
|
2010-03-26 21:27:49 -06:00
|
|
|
if (h > s_h || idx > s_idx)
|
2009-11-12 00:44:25 -07:00
|
|
|
s_ip_idx = 0;
|
|
|
|
in_dev = __in_dev_get_rcu(dev);
|
|
|
|
if (!in_dev)
|
|
|
|
goto cont;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-11-12 00:44:25 -07:00
|
|
|
for (ifa = in_dev->ifa_list, ip_idx = 0; ifa;
|
|
|
|
ifa = ifa->ifa_next, ip_idx++) {
|
|
|
|
if (ip_idx < s_ip_idx)
|
|
|
|
continue;
|
|
|
|
if (inet_fill_ifaddr(skb, ifa,
|
|
|
|
NETLINK_CB(cb->skb).pid,
|
2005-04-16 16:20:36 -06:00
|
|
|
cb->nlh->nlmsg_seq,
|
2009-11-12 00:44:25 -07:00
|
|
|
RTM_NEWADDR, NLM_F_MULTI) <= 0) {
|
|
|
|
rcu_read_unlock();
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
2007-05-03 16:13:45 -06:00
|
|
|
cont:
|
2009-11-12 00:44:25 -07:00
|
|
|
idx++;
|
|
|
|
}
|
|
|
|
rcu_read_unlock();
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
2009-11-12 00:44:25 -07:00
|
|
|
cb->args[0] = h;
|
|
|
|
cb->args[1] = idx;
|
|
|
|
cb->args[2] = ip_idx;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return skb->len;
|
|
|
|
}
|
|
|
|
|
2008-11-03 03:48:48 -07:00
|
|
|
static void rtmsg_ifa(int event, struct in_ifaddr *ifa, struct nlmsghdr *nlh,
|
2006-08-15 01:33:59 -06:00
|
|
|
u32 pid)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2006-08-05 00:04:36 -06:00
|
|
|
struct sk_buff *skb;
|
2006-08-15 01:33:59 -06:00
|
|
|
u32 seq = nlh ? nlh->nlmsg_seq : 0;
|
|
|
|
int err = -ENOBUFS;
|
2008-01-31 19:47:40 -07:00
|
|
|
struct net *net;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-03-25 06:47:49 -06:00
|
|
|
net = dev_net(ifa->ifa_dev->dev);
|
2006-11-10 15:10:15 -07:00
|
|
|
skb = nlmsg_new(inet_nlmsg_size(), GFP_KERNEL);
|
2006-08-05 00:04:36 -06:00
|
|
|
if (skb == NULL)
|
2006-08-15 01:33:59 -06:00
|
|
|
goto errout;
|
|
|
|
|
|
|
|
err = inet_fill_ifaddr(skb, ifa, pid, seq, event, 0);
|
2007-02-01 00:16:40 -07:00
|
|
|
if (err < 0) {
|
|
|
|
/* -EMSGSIZE implies BUG in inet_nlmsg_size() */
|
|
|
|
WARN_ON(err == -EMSGSIZE);
|
|
|
|
kfree_skb(skb);
|
|
|
|
goto errout;
|
|
|
|
}
|
2009-02-25 00:18:28 -07:00
|
|
|
rtnl_notify(skb, net, pid, RTNLGRP_IPV4_IFADDR, nlh, GFP_KERNEL);
|
|
|
|
return;
|
2006-08-15 01:33:59 -06:00
|
|
|
errout:
|
|
|
|
if (err < 0)
|
2008-01-31 19:47:40 -07:00
|
|
|
rtnl_set_sk_err(net, RTNLGRP_IPV4_IFADDR, err);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2010-11-15 21:32:48 -07:00
|
|
|
static size_t inet_get_link_af_size(const struct net_device *dev)
|
|
|
|
{
|
2011-05-09 21:55:03 -06:00
|
|
|
struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
|
2010-11-15 21:32:48 -07:00
|
|
|
|
|
|
|
if (!in_dev)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
return nla_total_size(IPV4_DEVCONF_MAX * 4); /* IFLA_INET_CONF */
|
|
|
|
}
|
|
|
|
|
|
|
|
static int inet_fill_link_af(struct sk_buff *skb, const struct net_device *dev)
|
|
|
|
{
|
2011-05-09 21:55:03 -06:00
|
|
|
struct in_device *in_dev = rcu_dereference_rtnl(dev->ip_ptr);
|
2010-11-15 21:32:48 -07:00
|
|
|
struct nlattr *nla;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
if (!in_dev)
|
|
|
|
return -ENODATA;
|
|
|
|
|
|
|
|
nla = nla_reserve(skb, IFLA_INET_CONF, IPV4_DEVCONF_MAX * 4);
|
|
|
|
if (nla == NULL)
|
|
|
|
return -EMSGSIZE;
|
|
|
|
|
|
|
|
for (i = 0; i < IPV4_DEVCONF_MAX; i++)
|
|
|
|
((u32 *) nla_data(nla))[i] = in_dev->cnf.data[i];
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static const struct nla_policy inet_af_policy[IFLA_INET_MAX+1] = {
|
|
|
|
[IFLA_INET_CONF] = { .type = NLA_NESTED },
|
|
|
|
};
|
|
|
|
|
2010-11-21 18:31:54 -07:00
|
|
|
static int inet_validate_link_af(const struct net_device *dev,
|
|
|
|
const struct nlattr *nla)
|
2010-11-15 21:32:48 -07:00
|
|
|
{
|
|
|
|
struct nlattr *a, *tb[IFLA_INET_MAX+1];
|
|
|
|
int err, rem;
|
|
|
|
|
2010-11-30 23:03:06 -07:00
|
|
|
if (dev && !__in_dev_get_rtnl(dev))
|
2010-11-21 18:31:54 -07:00
|
|
|
return -EAFNOSUPPORT;
|
2010-11-15 21:32:48 -07:00
|
|
|
|
|
|
|
err = nla_parse_nested(tb, IFLA_INET_MAX, nla, inet_af_policy);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
if (tb[IFLA_INET_CONF]) {
|
|
|
|
nla_for_each_nested(a, tb[IFLA_INET_CONF], rem) {
|
|
|
|
int cfgid = nla_type(a);
|
|
|
|
|
|
|
|
if (nla_len(a) < 4)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (cfgid <= 0 || cfgid > IPV4_DEVCONF_MAX)
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-11-21 18:31:54 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int inet_set_link_af(struct net_device *dev, const struct nlattr *nla)
|
|
|
|
{
|
2010-11-30 23:03:06 -07:00
|
|
|
struct in_device *in_dev = __in_dev_get_rtnl(dev);
|
2010-11-21 18:31:54 -07:00
|
|
|
struct nlattr *a, *tb[IFLA_INET_MAX+1];
|
|
|
|
int rem;
|
|
|
|
|
|
|
|
if (!in_dev)
|
|
|
|
return -EAFNOSUPPORT;
|
|
|
|
|
|
|
|
if (nla_parse_nested(tb, IFLA_INET_MAX, nla, NULL) < 0)
|
|
|
|
BUG();
|
|
|
|
|
2010-11-15 21:32:48 -07:00
|
|
|
if (tb[IFLA_INET_CONF]) {
|
|
|
|
nla_for_each_nested(a, tb[IFLA_INET_CONF], rem)
|
|
|
|
ipv4_devconf_set(in_dev, nla_type(a), nla_get_u32(a));
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
#ifdef CONFIG_SYSCTL
|
|
|
|
|
2007-12-16 14:31:14 -07:00
|
|
|
static void devinet_copy_dflt_conf(struct net *net, int i)
|
2007-06-05 00:35:37 -06:00
|
|
|
{
|
|
|
|
struct net_device *dev;
|
|
|
|
|
2009-11-04 06:43:23 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
for_each_netdev_rcu(net, dev) {
|
2007-06-05 00:35:37 -06:00
|
|
|
struct in_device *in_dev;
|
2009-11-04 06:43:23 -07:00
|
|
|
|
2007-06-05 00:35:37 -06:00
|
|
|
in_dev = __in_dev_get_rcu(dev);
|
|
|
|
if (in_dev && !test_bit(i, in_dev->cnf.state))
|
2007-12-16 14:32:16 -07:00
|
|
|
in_dev->cnf.data[i] = net->ipv4.devconf_dflt->data[i];
|
2007-06-05 00:35:37 -06:00
|
|
|
}
|
2009-11-04 06:43:23 -07:00
|
|
|
rcu_read_unlock();
|
2007-06-05 00:35:37 -06:00
|
|
|
}
|
|
|
|
|
2009-11-04 06:43:23 -07:00
|
|
|
/* called with RTNL locked */
|
2007-12-16 14:31:14 -07:00
|
|
|
static void inet_forward_change(struct net *net)
|
2007-12-05 02:44:58 -07:00
|
|
|
{
|
|
|
|
struct net_device *dev;
|
2007-12-16 14:32:48 -07:00
|
|
|
int on = IPV4_DEVCONF_ALL(net, FORWARDING);
|
2007-12-05 02:44:58 -07:00
|
|
|
|
2007-12-16 14:32:48 -07:00
|
|
|
IPV4_DEVCONF_ALL(net, ACCEPT_REDIRECTS) = !on;
|
2007-12-16 14:32:16 -07:00
|
|
|
IPV4_DEVCONF_DFLT(net, FORWARDING) = on;
|
2007-12-05 02:44:58 -07:00
|
|
|
|
2007-12-16 14:31:14 -07:00
|
|
|
for_each_netdev(net, dev) {
|
2007-12-05 02:44:58 -07:00
|
|
|
struct in_device *in_dev;
|
2008-06-19 17:15:47 -06:00
|
|
|
if (on)
|
|
|
|
dev_disable_lro(dev);
|
2007-12-05 02:44:58 -07:00
|
|
|
rcu_read_lock();
|
|
|
|
in_dev = __in_dev_get_rcu(dev);
|
|
|
|
if (in_dev)
|
|
|
|
IN_DEV_CONF_SET(in_dev, FORWARDING, on);
|
|
|
|
rcu_read_unlock();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-06-05 00:35:37 -06:00
|
|
|
static int devinet_conf_proc(ctl_table *ctl, int write,
|
2009-09-23 16:57:19 -06:00
|
|
|
void __user *buffer,
|
2007-06-05 00:35:37 -06:00
|
|
|
size_t *lenp, loff_t *ppos)
|
|
|
|
{
|
2011-12-01 08:47:06 -07:00
|
|
|
int old_value = *(int *)ctl->data;
|
2009-09-23 16:57:19 -06:00
|
|
|
int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
|
2011-12-01 08:47:06 -07:00
|
|
|
int new_value = *(int *)ctl->data;
|
2007-06-05 00:35:37 -06:00
|
|
|
|
|
|
|
if (write) {
|
|
|
|
struct ipv4_devconf *cnf = ctl->extra1;
|
2007-12-16 14:31:14 -07:00
|
|
|
struct net *net = ctl->extra2;
|
2007-06-05 00:35:37 -06:00
|
|
|
int i = (int *)ctl->data - cnf->data;
|
|
|
|
|
|
|
|
set_bit(i, cnf->state);
|
|
|
|
|
2007-12-16 14:32:16 -07:00
|
|
|
if (cnf == net->ipv4.devconf_dflt)
|
2007-12-16 14:31:14 -07:00
|
|
|
devinet_copy_dflt_conf(net, i);
|
2011-12-01 08:47:06 -07:00
|
|
|
if (i == IPV4_DEVCONF_ACCEPT_LOCAL - 1)
|
|
|
|
if ((new_value == 0) && (old_value != 0))
|
|
|
|
rt_cache_flush(net, 0);
|
2007-06-05 00:35:37 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static int devinet_sysctl_forward(ctl_table *ctl, int write,
|
2009-09-23 16:57:19 -06:00
|
|
|
void __user *buffer,
|
2005-04-16 16:20:36 -06:00
|
|
|
size_t *lenp, loff_t *ppos)
|
|
|
|
{
|
|
|
|
int *valp = ctl->data;
|
|
|
|
int val = *valp;
|
2010-02-19 06:22:59 -07:00
|
|
|
loff_t pos = *ppos;
|
2009-09-23 16:57:19 -06:00
|
|
|
int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (write && *valp != val) {
|
2007-12-16 14:31:14 -07:00
|
|
|
struct net *net = ctl->extra2;
|
|
|
|
|
2008-06-19 17:15:47 -06:00
|
|
|
if (valp != &IPV4_DEVCONF_DFLT(net, FORWARDING)) {
|
2010-02-19 06:22:59 -07:00
|
|
|
if (!rtnl_trylock()) {
|
|
|
|
/* Restore the original values before restarting */
|
|
|
|
*valp = val;
|
|
|
|
*ppos = pos;
|
2009-05-13 10:59:21 -06:00
|
|
|
return restart_syscall();
|
2010-02-19 06:22:59 -07:00
|
|
|
}
|
2008-06-19 17:15:47 -06:00
|
|
|
if (valp == &IPV4_DEVCONF_ALL(net, FORWARDING)) {
|
|
|
|
inet_forward_change(net);
|
|
|
|
} else if (*valp) {
|
|
|
|
struct ipv4_devconf *cnf = ctl->extra1;
|
|
|
|
struct in_device *idev =
|
|
|
|
container_of(cnf, struct in_device, cnf);
|
|
|
|
dev_disable_lro(idev->dev);
|
|
|
|
}
|
|
|
|
rtnl_unlock();
|
2008-07-05 20:00:44 -06:00
|
|
|
rt_cache_flush(net, 0);
|
2008-06-19 17:15:47 -06:00
|
|
|
}
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-12-12 22:55:08 -07:00
|
|
|
static int ipv4_doint_and_flush(ctl_table *ctl, int write,
|
|
|
|
void __user *buffer,
|
|
|
|
size_t *lenp, loff_t *ppos)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int *valp = ctl->data;
|
|
|
|
int val = *valp;
|
2009-09-23 16:57:19 -06:00
|
|
|
int ret = proc_dointvec(ctl, write, buffer, lenp, ppos);
|
2008-07-05 20:00:44 -06:00
|
|
|
struct net *net = ctl->extra2;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (write && *valp != val)
|
2008-07-05 20:00:44 -06:00
|
|
|
rt_cache_flush(net, 0);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2009-11-05 14:32:03 -07:00
|
|
|
#define DEVINET_SYSCTL_ENTRY(attr, name, mval, proc) \
|
2007-06-05 00:34:44 -06:00
|
|
|
{ \
|
|
|
|
.procname = name, \
|
|
|
|
.data = ipv4_devconf.data + \
|
2010-02-13 20:25:51 -07:00
|
|
|
IPV4_DEVCONF_ ## attr - 1, \
|
2007-06-05 00:34:44 -06:00
|
|
|
.maxlen = sizeof(int), \
|
|
|
|
.mode = mval, \
|
|
|
|
.proc_handler = proc, \
|
2007-06-05 00:35:37 -06:00
|
|
|
.extra1 = &ipv4_devconf, \
|
2007-06-05 00:34:44 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
#define DEVINET_SYSCTL_RW_ENTRY(attr, name) \
|
2009-11-05 14:32:03 -07:00
|
|
|
DEVINET_SYSCTL_ENTRY(attr, name, 0644, devinet_conf_proc)
|
2007-06-05 00:34:44 -06:00
|
|
|
|
|
|
|
#define DEVINET_SYSCTL_RO_ENTRY(attr, name) \
|
2009-11-05 14:32:03 -07:00
|
|
|
DEVINET_SYSCTL_ENTRY(attr, name, 0444, devinet_conf_proc)
|
2007-06-05 00:34:44 -06:00
|
|
|
|
2009-11-05 14:32:03 -07:00
|
|
|
#define DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, proc) \
|
|
|
|
DEVINET_SYSCTL_ENTRY(attr, name, 0644, proc)
|
2007-06-05 00:34:44 -06:00
|
|
|
|
|
|
|
#define DEVINET_SYSCTL_FLUSHING_ENTRY(attr, name) \
|
2009-11-05 14:32:03 -07:00
|
|
|
DEVINET_SYSCTL_COMPLEX_ENTRY(attr, name, ipv4_doint_and_flush)
|
2007-06-05 00:34:44 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
static struct devinet_sysctl_table {
|
|
|
|
struct ctl_table_header *sysctl_header;
|
2010-02-13 20:25:51 -07:00
|
|
|
struct ctl_table devinet_vars[__IPV4_DEVCONF_MAX];
|
2005-04-16 16:20:36 -06:00
|
|
|
} devinet_sysctl = {
|
|
|
|
.devinet_vars = {
|
2007-06-05 00:34:44 -06:00
|
|
|
DEVINET_SYSCTL_COMPLEX_ENTRY(FORWARDING, "forwarding",
|
2009-11-05 14:32:03 -07:00
|
|
|
devinet_sysctl_forward),
|
2007-06-05 00:34:44 -06:00
|
|
|
DEVINET_SYSCTL_RO_ENTRY(MC_FORWARDING, "mc_forwarding"),
|
|
|
|
|
|
|
|
DEVINET_SYSCTL_RW_ENTRY(ACCEPT_REDIRECTS, "accept_redirects"),
|
|
|
|
DEVINET_SYSCTL_RW_ENTRY(SECURE_REDIRECTS, "secure_redirects"),
|
|
|
|
DEVINET_SYSCTL_RW_ENTRY(SHARED_MEDIA, "shared_media"),
|
|
|
|
DEVINET_SYSCTL_RW_ENTRY(RP_FILTER, "rp_filter"),
|
|
|
|
DEVINET_SYSCTL_RW_ENTRY(SEND_REDIRECTS, "send_redirects"),
|
|
|
|
DEVINET_SYSCTL_RW_ENTRY(ACCEPT_SOURCE_ROUTE,
|
|
|
|
"accept_source_route"),
|
2009-12-02 18:25:58 -07:00
|
|
|
DEVINET_SYSCTL_RW_ENTRY(ACCEPT_LOCAL, "accept_local"),
|
2009-12-25 18:30:22 -07:00
|
|
|
DEVINET_SYSCTL_RW_ENTRY(SRC_VMARK, "src_valid_mark"),
|
2007-06-05 00:34:44 -06:00
|
|
|
DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP, "proxy_arp"),
|
|
|
|
DEVINET_SYSCTL_RW_ENTRY(MEDIUM_ID, "medium_id"),
|
|
|
|
DEVINET_SYSCTL_RW_ENTRY(BOOTP_RELAY, "bootp_relay"),
|
|
|
|
DEVINET_SYSCTL_RW_ENTRY(LOG_MARTIANS, "log_martians"),
|
|
|
|
DEVINET_SYSCTL_RW_ENTRY(TAG, "tag"),
|
|
|
|
DEVINET_SYSCTL_RW_ENTRY(ARPFILTER, "arp_filter"),
|
|
|
|
DEVINET_SYSCTL_RW_ENTRY(ARP_ANNOUNCE, "arp_announce"),
|
|
|
|
DEVINET_SYSCTL_RW_ENTRY(ARP_IGNORE, "arp_ignore"),
|
|
|
|
DEVINET_SYSCTL_RW_ENTRY(ARP_ACCEPT, "arp_accept"),
|
2009-02-01 02:04:33 -07:00
|
|
|
DEVINET_SYSCTL_RW_ENTRY(ARP_NOTIFY, "arp_notify"),
|
2010-01-04 22:50:47 -07:00
|
|
|
DEVINET_SYSCTL_RW_ENTRY(PROXY_ARP_PVLAN, "proxy_arp_pvlan"),
|
2007-06-05 00:34:44 -06:00
|
|
|
|
|
|
|
DEVINET_SYSCTL_FLUSHING_ENTRY(NOXFRM, "disable_xfrm"),
|
|
|
|
DEVINET_SYSCTL_FLUSHING_ENTRY(NOPOLICY, "disable_policy"),
|
|
|
|
DEVINET_SYSCTL_FLUSHING_ENTRY(FORCE_IGMP_VERSION,
|
|
|
|
"force_igmp_version"),
|
|
|
|
DEVINET_SYSCTL_FLUSHING_ENTRY(PROMOTE_SECONDARIES,
|
|
|
|
"promote_secondaries"),
|
2005-04-16 16:20:36 -06:00
|
|
|
},
|
|
|
|
};
|
|
|
|
|
2007-12-16 14:30:07 -07:00
|
|
|
static int __devinet_sysctl_register(struct net *net, char *dev_name,
|
2009-11-05 14:32:03 -07:00
|
|
|
struct ipv4_devconf *p)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int i;
|
2007-12-01 06:17:46 -07:00
|
|
|
struct devinet_sysctl_table *t;
|
2012-04-19 07:42:09 -06:00
|
|
|
char path[sizeof("net/ipv4/conf/") + IFNAMSIZ];
|
2007-12-01 06:57:08 -07:00
|
|
|
|
2007-12-01 06:17:46 -07:00
|
|
|
t = kmemdup(&devinet_sysctl, sizeof(*t), GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!t)
|
2007-12-01 06:17:46 -07:00
|
|
|
goto out;
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
for (i = 0; i < ARRAY_SIZE(t->devinet_vars) - 1; i++) {
|
|
|
|
t->devinet_vars[i].data += (char *)p - (char *)&ipv4_devconf;
|
2007-06-05 00:35:37 -06:00
|
|
|
t->devinet_vars[i].extra1 = p;
|
2007-12-16 14:31:14 -07:00
|
|
|
t->devinet_vars[i].extra2 = net;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2012-04-19 07:42:09 -06:00
|
|
|
snprintf(path, sizeof(path), "net/ipv4/conf/%s", dev_name);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2012-04-19 07:42:09 -06:00
|
|
|
t->sysctl_header = register_net_sysctl(net, path, t->devinet_vars);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!t->sysctl_header)
|
2012-04-19 07:42:09 -06:00
|
|
|
goto free;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
p->sysctl = t;
|
2007-12-16 14:30:07 -07:00
|
|
|
return 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2007-12-01 06:17:46 -07:00
|
|
|
free:
|
2005-04-16 16:20:36 -06:00
|
|
|
kfree(t);
|
2007-12-01 06:17:46 -07:00
|
|
|
out:
|
2007-12-16 14:30:07 -07:00
|
|
|
return -ENOBUFS;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-12-11 03:17:40 -07:00
|
|
|
static void __devinet_sysctl_unregister(struct ipv4_devconf *cnf)
|
|
|
|
{
|
|
|
|
struct devinet_sysctl_table *t = cnf->sysctl;
|
|
|
|
|
|
|
|
if (t == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
cnf->sysctl = NULL;
|
2011-04-30 19:44:01 -06:00
|
|
|
unregister_net_sysctl_table(t->sysctl_header);
|
2007-12-11 03:17:40 -07:00
|
|
|
kfree(t);
|
|
|
|
}
|
|
|
|
|
2007-12-01 06:55:54 -07:00
|
|
|
static void devinet_sysctl_register(struct in_device *idev)
|
|
|
|
{
|
2010-02-13 20:27:03 -07:00
|
|
|
neigh_sysctl_register(idev->dev, idev->arp_parms, "ipv4", NULL);
|
2008-03-25 06:47:49 -06:00
|
|
|
__devinet_sysctl_register(dev_net(idev->dev), idev->dev->name,
|
2009-11-05 14:32:03 -07:00
|
|
|
&idev->cnf);
|
2007-12-01 06:55:54 -07:00
|
|
|
}
|
|
|
|
|
2007-12-11 03:17:40 -07:00
|
|
|
static void devinet_sysctl_unregister(struct in_device *idev)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2007-12-11 03:17:40 -07:00
|
|
|
__devinet_sysctl_unregister(&idev->cnf);
|
|
|
|
neigh_sysctl_unregister(idev->arp_parms);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2007-12-05 02:44:58 -07:00
|
|
|
static struct ctl_table ctl_forward_entry[] = {
|
|
|
|
{
|
|
|
|
.procname = "ip_forward",
|
|
|
|
.data = &ipv4_devconf.data[
|
2010-02-13 20:25:51 -07:00
|
|
|
IPV4_DEVCONF_FORWARDING - 1],
|
2007-12-05 02:44:58 -07:00
|
|
|
.maxlen = sizeof(int),
|
|
|
|
.mode = 0644,
|
|
|
|
.proc_handler = devinet_sysctl_forward,
|
|
|
|
.extra1 = &ipv4_devconf,
|
2007-12-16 14:31:14 -07:00
|
|
|
.extra2 = &init_net,
|
2007-12-05 02:44:58 -07:00
|
|
|
},
|
|
|
|
{ },
|
|
|
|
};
|
2008-01-06 00:08:49 -07:00
|
|
|
#endif
|
2007-12-05 02:44:58 -07:00
|
|
|
|
2007-12-16 14:31:47 -07:00
|
|
|
static __net_init int devinet_init_net(struct net *net)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
struct ipv4_devconf *all, *dflt;
|
2008-01-06 00:08:49 -07:00
|
|
|
#ifdef CONFIG_SYSCTL
|
|
|
|
struct ctl_table *tbl = ctl_forward_entry;
|
2007-12-16 14:31:47 -07:00
|
|
|
struct ctl_table_header *forw_hdr;
|
2008-01-06 00:08:49 -07:00
|
|
|
#endif
|
2007-12-16 14:31:47 -07:00
|
|
|
|
|
|
|
err = -ENOMEM;
|
|
|
|
all = &ipv4_devconf;
|
|
|
|
dflt = &ipv4_devconf_dflt;
|
|
|
|
|
2009-11-25 16:14:13 -07:00
|
|
|
if (!net_eq(net, &init_net)) {
|
2007-12-16 14:31:47 -07:00
|
|
|
all = kmemdup(all, sizeof(ipv4_devconf), GFP_KERNEL);
|
|
|
|
if (all == NULL)
|
|
|
|
goto err_alloc_all;
|
|
|
|
|
|
|
|
dflt = kmemdup(dflt, sizeof(ipv4_devconf_dflt), GFP_KERNEL);
|
|
|
|
if (dflt == NULL)
|
|
|
|
goto err_alloc_dflt;
|
|
|
|
|
2008-01-06 00:08:49 -07:00
|
|
|
#ifdef CONFIG_SYSCTL
|
2007-12-16 14:31:47 -07:00
|
|
|
tbl = kmemdup(tbl, sizeof(ctl_forward_entry), GFP_KERNEL);
|
|
|
|
if (tbl == NULL)
|
|
|
|
goto err_alloc_ctl;
|
|
|
|
|
2010-02-13 20:25:51 -07:00
|
|
|
tbl[0].data = &all->data[IPV4_DEVCONF_FORWARDING - 1];
|
2007-12-16 14:31:47 -07:00
|
|
|
tbl[0].extra1 = all;
|
|
|
|
tbl[0].extra2 = net;
|
2008-01-06 00:08:49 -07:00
|
|
|
#endif
|
2007-12-16 14:31:47 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef CONFIG_SYSCTL
|
2009-11-05 14:32:03 -07:00
|
|
|
err = __devinet_sysctl_register(net, "all", all);
|
2007-12-16 14:31:47 -07:00
|
|
|
if (err < 0)
|
|
|
|
goto err_reg_all;
|
|
|
|
|
2009-11-05 14:32:03 -07:00
|
|
|
err = __devinet_sysctl_register(net, "default", dflt);
|
2007-12-16 14:31:47 -07:00
|
|
|
if (err < 0)
|
|
|
|
goto err_reg_dflt;
|
|
|
|
|
|
|
|
err = -ENOMEM;
|
2012-04-19 07:42:09 -06:00
|
|
|
forw_hdr = register_net_sysctl(net, "net/ipv4", tbl);
|
2007-12-16 14:31:47 -07:00
|
|
|
if (forw_hdr == NULL)
|
|
|
|
goto err_reg_ctl;
|
2008-01-06 00:08:49 -07:00
|
|
|
net->ipv4.forw_hdr = forw_hdr;
|
2007-12-16 14:31:47 -07:00
|
|
|
#endif
|
|
|
|
|
|
|
|
net->ipv4.devconf_all = all;
|
|
|
|
net->ipv4.devconf_dflt = dflt;
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
#ifdef CONFIG_SYSCTL
|
|
|
|
err_reg_ctl:
|
|
|
|
__devinet_sysctl_unregister(dflt);
|
|
|
|
err_reg_dflt:
|
|
|
|
__devinet_sysctl_unregister(all);
|
|
|
|
err_reg_all:
|
|
|
|
if (tbl != ctl_forward_entry)
|
|
|
|
kfree(tbl);
|
|
|
|
err_alloc_ctl:
|
2008-01-06 00:08:49 -07:00
|
|
|
#endif
|
2007-12-16 14:31:47 -07:00
|
|
|
if (dflt != &ipv4_devconf_dflt)
|
|
|
|
kfree(dflt);
|
|
|
|
err_alloc_dflt:
|
|
|
|
if (all != &ipv4_devconf)
|
|
|
|
kfree(all);
|
|
|
|
err_alloc_all:
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __net_exit void devinet_exit_net(struct net *net)
|
|
|
|
{
|
2008-01-06 00:08:49 -07:00
|
|
|
#ifdef CONFIG_SYSCTL
|
2007-12-16 14:31:47 -07:00
|
|
|
struct ctl_table *tbl;
|
|
|
|
|
|
|
|
tbl = net->ipv4.forw_hdr->ctl_table_arg;
|
|
|
|
unregister_net_sysctl_table(net->ipv4.forw_hdr);
|
|
|
|
__devinet_sysctl_unregister(net->ipv4.devconf_dflt);
|
|
|
|
__devinet_sysctl_unregister(net->ipv4.devconf_all);
|
|
|
|
kfree(tbl);
|
2008-01-06 00:08:49 -07:00
|
|
|
#endif
|
2007-12-16 14:31:47 -07:00
|
|
|
kfree(net->ipv4.devconf_dflt);
|
|
|
|
kfree(net->ipv4.devconf_all);
|
|
|
|
}
|
|
|
|
|
|
|
|
static __net_initdata struct pernet_operations devinet_ops = {
|
|
|
|
.init = devinet_init_net,
|
|
|
|
.exit = devinet_exit_net,
|
|
|
|
};
|
|
|
|
|
2010-11-15 21:32:48 -07:00
|
|
|
static struct rtnl_af_ops inet_af_ops = {
|
|
|
|
.family = AF_INET,
|
|
|
|
.fill_link_af = inet_fill_link_af,
|
|
|
|
.get_link_af_size = inet_get_link_af_size,
|
2010-11-21 18:31:54 -07:00
|
|
|
.validate_link_af = inet_validate_link_af,
|
|
|
|
.set_link_af = inet_set_link_af,
|
2010-11-15 21:32:48 -07:00
|
|
|
};
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
void __init devinet_init(void)
|
|
|
|
{
|
2011-02-18 13:42:28 -07:00
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < IN4_ADDR_HSIZE; i++)
|
|
|
|
INIT_HLIST_HEAD(&inet_addr_lst[i]);
|
|
|
|
|
2007-12-16 14:31:47 -07:00
|
|
|
register_pernet_subsys(&devinet_ops);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
register_gifconf(PF_INET, inet_gifconf);
|
|
|
|
register_netdevice_notifier(&ip_netdev_notifier);
|
2007-03-22 12:55:17 -06:00
|
|
|
|
2010-11-15 21:32:48 -07:00
|
|
|
rtnl_af_register(&inet_af_ops);
|
|
|
|
|
2011-06-09 19:27:09 -06:00
|
|
|
rtnl_register(PF_INET, RTM_NEWADDR, inet_rtm_newaddr, NULL, NULL);
|
|
|
|
rtnl_register(PF_INET, RTM_DELADDR, inet_rtm_deladdr, NULL, NULL);
|
|
|
|
rtnl_register(PF_INET, RTM_GETADDR, NULL, inet_dump_ifaddr, NULL);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|