2005-04-17 06:20:36 +08:00
|
|
|
/*
|
|
|
|
|
* Common framework for low-level network console, dump, and debugger code
|
|
|
|
|
*
|
|
|
|
|
* Sep 8 2003 Matt Mackall <mpm@selenic.com>
|
|
|
|
|
*
|
|
|
|
|
* based on the netconsole code from:
|
|
|
|
|
*
|
|
|
|
|
* Copyright (C) 2001 Ingo Molnar <mingo@redhat.com>
|
|
|
|
|
* Copyright (C) 2002 Red Hat, Inc.
|
|
|
|
|
*/
|
|
|
|
|
|
2012-01-29 23:50:43 +08:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
|
2009-07-09 02:10:56 +08:00
|
|
|
#include <linux/moduleparam.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/netdevice.h>
|
|
|
|
|
#include <linux/etherdevice.h>
|
|
|
|
|
#include <linux/string.h>
|
2005-12-27 12:43:12 +08:00
|
|
|
#include <linux/if_arp.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <linux/inetdevice.h>
|
|
|
|
|
#include <linux/inet.h>
|
|
|
|
|
#include <linux/interrupt.h>
|
|
|
|
|
#include <linux/netpoll.h>
|
|
|
|
|
#include <linux/sched.h>
|
|
|
|
|
#include <linux/delay.h>
|
|
|
|
|
#include <linux/rcupdate.h>
|
|
|
|
|
#include <linux/workqueue.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2011-07-15 23:47:34 +08:00
|
|
|
#include <linux/export.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
#include <net/tcp.h>
|
|
|
|
|
#include <net/udp.h>
|
|
|
|
|
#include <asm/unaligned.h>
|
2009-06-15 18:02:23 +08:00
|
|
|
#include <trace/events/napi.h>
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* We maintain a small pool of fully-sized skbs, to make sure the
|
|
|
|
|
* message gets out even in extreme OOM situations.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#define MAX_UDP_CHUNK 1460
|
|
|
|
|
#define MAX_SKBS 32
|
|
|
|
|
|
2006-11-15 02:43:58 +08:00
|
|
|
static struct sk_buff_head skb_pool;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
static atomic_t trapped;
|
|
|
|
|
|
2006-10-27 06:46:54 +08:00
|
|
|
#define USEC_PER_POLL 50
|
2008-03-05 04:28:49 +08:00
|
|
|
#define NETPOLL_RX_ENABLED 1
|
|
|
|
|
#define NETPOLL_RX_DROP 2
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-01-29 23:50:44 +08:00
|
|
|
#define MAX_SKB_SIZE \
|
|
|
|
|
(sizeof(struct ethhdr) + \
|
|
|
|
|
sizeof(struct iphdr) + \
|
|
|
|
|
sizeof(struct udphdr) + \
|
|
|
|
|
MAX_UDP_CHUNK)
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-08-03 15:24:04 +08:00
|
|
|
static void zap_completion_queue(void);
|
2006-06-26 15:04:27 +08:00
|
|
|
static void arp_reply(struct sk_buff *skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2009-07-09 02:10:56 +08:00
|
|
|
static unsigned int carrier_timeout = 4;
|
|
|
|
|
module_param(carrier_timeout, uint, 0644);
|
|
|
|
|
|
2012-01-29 23:50:43 +08:00
|
|
|
#define np_info(np, fmt, ...) \
|
|
|
|
|
pr_info("%s: " fmt, np->name, ##__VA_ARGS__)
|
|
|
|
|
#define np_err(np, fmt, ...) \
|
|
|
|
|
pr_err("%s: " fmt, np->name, ##__VA_ARGS__)
|
|
|
|
|
#define np_notice(np, fmt, ...) \
|
|
|
|
|
pr_notice("%s: " fmt, np->name, ##__VA_ARGS__)
|
|
|
|
|
|
2006-11-22 22:57:56 +08:00
|
|
|
static void queue_process(struct work_struct *work)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-12-05 22:37:56 +08:00
|
|
|
struct netpoll_info *npinfo =
|
|
|
|
|
container_of(work, struct netpoll_info, tx_work.work);
|
2005-04-17 06:20:36 +08:00
|
|
|
struct sk_buff *skb;
|
2006-12-13 00:20:42 +08:00
|
|
|
unsigned long flags;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-10-27 06:46:53 +08:00
|
|
|
while ((skb = skb_dequeue(&npinfo->txq))) {
|
|
|
|
|
struct net_device *dev = skb->dev;
|
2008-11-21 12:14:53 +08:00
|
|
|
const struct net_device_ops *ops = dev->netdev_ops;
|
2008-07-17 16:56:23 +08:00
|
|
|
struct netdev_queue *txq;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-10-27 06:46:53 +08:00
|
|
|
if (!netif_device_present(dev) || !netif_running(dev)) {
|
|
|
|
|
__kfree_skb(skb);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-07-17 16:56:23 +08:00
|
|
|
txq = netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
|
|
|
|
|
|
2006-12-13 00:20:42 +08:00
|
|
|
local_irq_save(flags);
|
2008-07-17 16:56:23 +08:00
|
|
|
__netif_tx_lock(txq, smp_processor_id());
|
2011-11-29 00:32:44 +08:00
|
|
|
if (netif_xmit_frozen_or_stopped(txq) ||
|
2008-11-21 12:14:53 +08:00
|
|
|
ops->ndo_start_xmit(skb, dev) != NETDEV_TX_OK) {
|
2006-10-27 06:46:53 +08:00
|
|
|
skb_queue_head(&npinfo->txq, skb);
|
2008-07-17 16:56:23 +08:00
|
|
|
__netif_tx_unlock(txq);
|
2006-12-13 00:20:42 +08:00
|
|
|
local_irq_restore(flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-07-06 08:42:44 +08:00
|
|
|
schedule_delayed_work(&npinfo->tx_work, HZ/10);
|
2006-10-27 06:46:53 +08:00
|
|
|
return;
|
|
|
|
|
}
|
2008-07-17 16:56:23 +08:00
|
|
|
__netif_tx_unlock(txq);
|
2006-12-13 00:20:42 +08:00
|
|
|
local_irq_restore(flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-11-15 13:40:42 +08:00
|
|
|
static __sum16 checksum_udp(struct sk_buff *skb, struct udphdr *uh,
|
|
|
|
|
unsigned short ulen, __be32 saddr, __be32 daddr)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-11-15 13:26:08 +08:00
|
|
|
__wsum psum;
|
2005-11-11 05:01:24 +08:00
|
|
|
|
2007-04-10 02:59:39 +08:00
|
|
|
if (uh->check == 0 || skb_csum_unnecessary(skb))
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
|
|
2005-11-11 05:01:24 +08:00
|
|
|
psum = csum_tcpudp_nofold(saddr, daddr, ulen, IPPROTO_UDP, 0);
|
|
|
|
|
|
2006-08-30 07:44:56 +08:00
|
|
|
if (skb->ip_summed == CHECKSUM_COMPLETE &&
|
2006-11-15 13:24:49 +08:00
|
|
|
!csum_fold(csum_add(psum, skb->csum)))
|
2005-11-11 05:01:24 +08:00
|
|
|
return 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-11-11 05:01:24 +08:00
|
|
|
skb->csum = psum;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-11-11 05:01:24 +08:00
|
|
|
return __skb_checksum_complete(skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Check whether delayed processing was scheduled for our NIC. If so,
|
|
|
|
|
* we attempt to grab the poll lock and use ->poll() to pump the card.
|
|
|
|
|
* If this fails, either we've recursed in ->poll() or it's already
|
|
|
|
|
* running on another CPU.
|
|
|
|
|
*
|
|
|
|
|
* Note: we don't mask interrupts with this lock because we're using
|
|
|
|
|
* trylock here and interrupts are already disabled in the softirq
|
|
|
|
|
* case. Further, we test the poll_owner to avoid recursion on UP
|
|
|
|
|
* systems where the lock doesn't exist.
|
|
|
|
|
*
|
|
|
|
|
* In cases where there is bi-directional communications, reading only
|
|
|
|
|
* one message at a time can lead to packets being dropped by the
|
|
|
|
|
* network adapter, forcing superfluous retries and possibly timeouts.
|
|
|
|
|
* Thus, we set our budget to greater than 1.
|
|
|
|
|
*/
|
2007-10-30 12:28:47 +08:00
|
|
|
static int poll_one_napi(struct netpoll_info *npinfo,
|
|
|
|
|
struct napi_struct *napi, int budget)
|
|
|
|
|
{
|
|
|
|
|
int work;
|
|
|
|
|
|
|
|
|
|
/* net_rx_action's ->poll() invocations and our's are
|
|
|
|
|
* synchronized by this test which is only made while
|
|
|
|
|
* holding the napi->poll_lock.
|
|
|
|
|
*/
|
|
|
|
|
if (!test_bit(NAPI_STATE_SCHED, &napi->state))
|
|
|
|
|
return budget;
|
|
|
|
|
|
2008-03-05 04:28:49 +08:00
|
|
|
npinfo->rx_flags |= NETPOLL_RX_DROP;
|
2007-10-30 12:28:47 +08:00
|
|
|
atomic_inc(&trapped);
|
netpoll: fix race on poll_list resulting in garbage entry
A few months back a race was discused between the netpoll napi service
path, and the fast path through net_rx_action:
http://kerneltrap.org/mailarchive/linux-netdev/2007/10/16/345470
A patch was submitted for that bug, but I think we missed a case.
Consider the following scenario:
INITIAL STATE
CPU0 has one napi_struct A on its poll_list
CPU1 is calling netpoll_send_skb and needs to call poll_napi on the same
napi_struct A that CPU0 has on its list
CPU0 CPU1
net_rx_action poll_napi
!list_empty (returns true) locks poll_lock for A
poll_one_napi
napi->poll
netif_rx_complete
__napi_complete
(removes A from poll_list)
list_entry(list->next)
In the above scenario, net_rx_action assumes that the per-cpu poll_list is
exclusive to that cpu. netpoll of course violates that, and because the netpoll
path can dequeue from the poll list, its possible for CPU0 to detect a non-empty
list at the top of the while loop in net_rx_action, but have it become empty by
the time it calls list_entry. Since the poll_list isn't surrounded by any other
structure, the returned data from that list_entry call in this situation is
garbage, and any number of crashes can result based on what exactly that garbage
is.
Given that its not fasible for performance reasons to place exclusive locks
arround each cpus poll list to provide that mutal exclusion, I think the best
solution is modify the netpoll path in such a way that we continue to guarantee
that the poll_list for a cpu is in fact exclusive to that cpu. To do this I've
implemented the patch below. It adds an additional bit to the state field in
the napi_struct. When executing napi->poll from the netpoll_path, this bit will
be set. When a driver calls netif_rx_complete, if that bit is set, it will not
remove the napi_struct from the poll_list. That work will be saved for the next
iteration of net_rx_action.
I've tested this and it seems to work well. About the biggest drawback I can
see to it is the fact that it might result in an extra loop through
net_rx_action in the event that the device is actually contended for (i.e. the
netpoll path actually preforms all the needed work no the device, and the call
to net_rx_action winds up doing nothing, except removing the napi_struct from
the poll_list. However I think this is probably a small price to pay, given
that the alternative is a crash.
Signed-off-by: Neil Horman <nhorman@tuxdriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-12-10 15:22:26 +08:00
|
|
|
set_bit(NAPI_STATE_NPSVC, &napi->state);
|
2007-10-30 12:28:47 +08:00
|
|
|
|
|
|
|
|
work = napi->poll(napi, budget);
|
2009-05-22 14:30:09 +08:00
|
|
|
trace_napi_poll(napi);
|
2007-10-30 12:28:47 +08:00
|
|
|
|
netpoll: fix race on poll_list resulting in garbage entry
A few months back a race was discused between the netpoll napi service
path, and the fast path through net_rx_action:
http://kerneltrap.org/mailarchive/linux-netdev/2007/10/16/345470
A patch was submitted for that bug, but I think we missed a case.
Consider the following scenario:
INITIAL STATE
CPU0 has one napi_struct A on its poll_list
CPU1 is calling netpoll_send_skb and needs to call poll_napi on the same
napi_struct A that CPU0 has on its list
CPU0 CPU1
net_rx_action poll_napi
!list_empty (returns true) locks poll_lock for A
poll_one_napi
napi->poll
netif_rx_complete
__napi_complete
(removes A from poll_list)
list_entry(list->next)
In the above scenario, net_rx_action assumes that the per-cpu poll_list is
exclusive to that cpu. netpoll of course violates that, and because the netpoll
path can dequeue from the poll list, its possible for CPU0 to detect a non-empty
list at the top of the while loop in net_rx_action, but have it become empty by
the time it calls list_entry. Since the poll_list isn't surrounded by any other
structure, the returned data from that list_entry call in this situation is
garbage, and any number of crashes can result based on what exactly that garbage
is.
Given that its not fasible for performance reasons to place exclusive locks
arround each cpus poll list to provide that mutal exclusion, I think the best
solution is modify the netpoll path in such a way that we continue to guarantee
that the poll_list for a cpu is in fact exclusive to that cpu. To do this I've
implemented the patch below. It adds an additional bit to the state field in
the napi_struct. When executing napi->poll from the netpoll_path, this bit will
be set. When a driver calls netif_rx_complete, if that bit is set, it will not
remove the napi_struct from the poll_list. That work will be saved for the next
iteration of net_rx_action.
I've tested this and it seems to work well. About the biggest drawback I can
see to it is the fact that it might result in an extra loop through
net_rx_action in the event that the device is actually contended for (i.e. the
netpoll path actually preforms all the needed work no the device, and the call
to net_rx_action winds up doing nothing, except removing the napi_struct from
the poll_list. However I think this is probably a small price to pay, given
that the alternative is a crash.
Signed-off-by: Neil Horman <nhorman@tuxdriver.com>
Signed-off-by: David S. Miller <davem@davemloft.net>
2008-12-10 15:22:26 +08:00
|
|
|
clear_bit(NAPI_STATE_NPSVC, &napi->state);
|
2007-10-30 12:28:47 +08:00
|
|
|
atomic_dec(&trapped);
|
2008-03-05 04:28:49 +08:00
|
|
|
npinfo->rx_flags &= ~NETPOLL_RX_DROP;
|
2007-10-30 12:28:47 +08:00
|
|
|
|
|
|
|
|
return budget - work;
|
|
|
|
|
}
|
|
|
|
|
|
2007-11-20 11:18:11 +08:00
|
|
|
static void poll_napi(struct net_device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-04 07:41:36 +08:00
|
|
|
struct napi_struct *napi;
|
2005-04-17 06:20:36 +08:00
|
|
|
int budget = 16;
|
|
|
|
|
|
2010-10-19 15:04:26 +08:00
|
|
|
list_for_each_entry(napi, &dev->napi_list, dev_list) {
|
2007-10-30 12:28:47 +08:00
|
|
|
if (napi->poll_owner != smp_processor_id() &&
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-04 07:41:36 +08:00
|
|
|
spin_trylock(&napi->poll_lock)) {
|
2007-11-20 11:18:11 +08:00
|
|
|
budget = poll_one_napi(dev->npinfo, napi, budget);
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-04 07:41:36 +08:00
|
|
|
spin_unlock(&napi->poll_lock);
|
2007-10-30 12:28:47 +08:00
|
|
|
|
|
|
|
|
if (!budget)
|
|
|
|
|
break;
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-04 07:41:36 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2006-06-26 15:04:27 +08:00
|
|
|
static void service_arp_queue(struct netpoll_info *npi)
|
|
|
|
|
{
|
2007-11-20 11:18:11 +08:00
|
|
|
if (npi) {
|
|
|
|
|
struct sk_buff *skb;
|
2006-06-26 15:04:27 +08:00
|
|
|
|
2007-11-20 11:18:11 +08:00
|
|
|
while ((skb = skb_dequeue(&npi->arp_tx)))
|
|
|
|
|
arp_reply(skb);
|
2006-06-26 15:04:27 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-06-30 23:08:57 +08:00
|
|
|
static void netpoll_poll_dev(struct net_device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2009-05-11 08:36:35 +08:00
|
|
|
const struct net_device_ops *ops;
|
2007-11-20 11:18:11 +08:00
|
|
|
|
2009-05-11 08:36:35 +08:00
|
|
|
if (!dev || !netif_running(dev))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
ops = dev->netdev_ops;
|
|
|
|
|
if (!ops->ndo_poll_controller)
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* Process pending work on NIC */
|
2008-11-20 13:32:24 +08:00
|
|
|
ops->ndo_poll_controller(dev);
|
2007-11-20 11:18:11 +08:00
|
|
|
|
|
|
|
|
poll_napi(dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-02-14 18:11:59 +08:00
|
|
|
if (dev->flags & IFF_SLAVE) {
|
2011-02-18 07:43:34 +08:00
|
|
|
if (dev->npinfo) {
|
|
|
|
|
struct net_device *bond_dev = dev->master;
|
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
while ((skb = skb_dequeue(&dev->npinfo->arp_tx))) {
|
|
|
|
|
skb->dev = bond_dev;
|
|
|
|
|
skb_queue_tail(&bond_dev->npinfo->arp_tx, skb);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2007-11-20 11:18:11 +08:00
|
|
|
service_arp_queue(dev->npinfo);
|
2006-06-26 15:04:27 +08:00
|
|
|
|
2010-08-03 15:24:04 +08:00
|
|
|
zap_completion_queue();
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void refill_skbs(void)
|
|
|
|
|
{
|
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
2006-11-15 02:43:58 +08:00
|
|
|
spin_lock_irqsave(&skb_pool.lock, flags);
|
|
|
|
|
while (skb_pool.qlen < MAX_SKBS) {
|
2005-04-17 06:20:36 +08:00
|
|
|
skb = alloc_skb(MAX_SKB_SIZE, GFP_ATOMIC);
|
|
|
|
|
if (!skb)
|
|
|
|
|
break;
|
|
|
|
|
|
2006-11-15 02:43:58 +08:00
|
|
|
__skb_queue_tail(&skb_pool, skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-11-15 02:43:58 +08:00
|
|
|
spin_unlock_irqrestore(&skb_pool.lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2010-08-03 15:24:04 +08:00
|
|
|
static void zap_completion_queue(void)
|
|
|
|
|
{
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
struct softnet_data *sd = &get_cpu_var(softnet_data);
|
|
|
|
|
|
|
|
|
|
if (sd->completion_queue) {
|
|
|
|
|
struct sk_buff *clist;
|
|
|
|
|
|
|
|
|
|
local_irq_save(flags);
|
|
|
|
|
clist = sd->completion_queue;
|
|
|
|
|
sd->completion_queue = NULL;
|
|
|
|
|
local_irq_restore(flags);
|
|
|
|
|
|
|
|
|
|
while (clist != NULL) {
|
|
|
|
|
struct sk_buff *skb = clist;
|
|
|
|
|
clist = clist->next;
|
|
|
|
|
if (skb->destructor) {
|
|
|
|
|
atomic_inc(&skb->users);
|
|
|
|
|
dev_kfree_skb_any(skb); /* put this one back */
|
|
|
|
|
} else {
|
|
|
|
|
__kfree_skb(skb);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
put_cpu_var(softnet_data);
|
|
|
|
|
}
|
|
|
|
|
|
2006-11-15 02:43:58 +08:00
|
|
|
static struct sk_buff *find_skb(struct netpoll *np, int len, int reserve)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-11-15 02:43:58 +08:00
|
|
|
int count = 0;
|
|
|
|
|
struct sk_buff *skb;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-08-03 15:24:04 +08:00
|
|
|
zap_completion_queue();
|
2006-11-15 02:43:58 +08:00
|
|
|
refill_skbs();
|
2005-04-17 06:20:36 +08:00
|
|
|
repeat:
|
|
|
|
|
|
|
|
|
|
skb = alloc_skb(len, GFP_ATOMIC);
|
2006-11-15 02:43:58 +08:00
|
|
|
if (!skb)
|
|
|
|
|
skb = skb_dequeue(&skb_pool);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
if (!skb) {
|
2006-11-15 02:43:58 +08:00
|
|
|
if (++count < 10) {
|
2011-06-30 23:08:58 +08:00
|
|
|
netpoll_poll_dev(np->dev);
|
2006-11-15 02:43:58 +08:00
|
|
|
goto repeat;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2006-11-15 02:43:58 +08:00
|
|
|
return NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
atomic_set(&skb->users, 1);
|
|
|
|
|
skb_reserve(skb, reserve);
|
|
|
|
|
return skb;
|
|
|
|
|
}
|
|
|
|
|
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-04 07:41:36 +08:00
|
|
|
static int netpoll_owner_active(struct net_device *dev)
|
|
|
|
|
{
|
|
|
|
|
struct napi_struct *napi;
|
|
|
|
|
|
|
|
|
|
list_for_each_entry(napi, &dev->napi_list, dev_list) {
|
|
|
|
|
if (napi->poll_owner == smp_processor_id())
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
2010-10-14 00:01:49 +08:00
|
|
|
void netpoll_send_skb_on_dev(struct netpoll *np, struct sk_buff *skb,
|
|
|
|
|
struct net_device *dev)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2006-10-27 06:46:54 +08:00
|
|
|
int status = NETDEV_TX_BUSY;
|
|
|
|
|
unsigned long tries;
|
2008-11-21 12:14:53 +08:00
|
|
|
const struct net_device_ops *ops = dev->netdev_ops;
|
2010-06-11 00:12:44 +08:00
|
|
|
/* It is up to the caller to keep npinfo alive. */
|
2007-02-09 22:24:36 +08:00
|
|
|
struct netpoll_info *npinfo = np->dev->npinfo;
|
2006-10-27 06:46:54 +08:00
|
|
|
|
2007-02-09 22:24:36 +08:00
|
|
|
if (!npinfo || !netif_running(dev) || !netif_device_present(dev)) {
|
|
|
|
|
__kfree_skb(skb);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2006-10-27 06:46:54 +08:00
|
|
|
|
|
|
|
|
/* don't get messages out of order, and no recursion */
|
[NET]: Make NAPI polling independent of struct net_device objects.
Several devices have multiple independant RX queues per net
device, and some have a single interrupt doorbell for several
queues.
In either case, it's easier to support layouts like that if the
structure representing the poll is independant from the net
device itself.
The signature of the ->poll() call back goes from:
int foo_poll(struct net_device *dev, int *budget)
to
int foo_poll(struct napi_struct *napi, int budget)
The caller is returned the number of RX packets processed (or
the number of "NAPI credits" consumed if you want to get
abstract). The callee no longer messes around bumping
dev->quota, *budget, etc. because that is all handled in the
caller upon return.
The napi_struct is to be embedded in the device driver private data
structures.
Furthermore, it is the driver's responsibility to disable all NAPI
instances in it's ->stop() device close handler. Since the
napi_struct is privatized into the driver's private data structures,
only the driver knows how to get at all of the napi_struct instances
it may have per-device.
With lots of help and suggestions from Rusty Russell, Roland Dreier,
Michael Chan, Jeff Garzik, and Jamal Hadi Salim.
Bug fixes from Thomas Graf, Roland Dreier, Peter Zijlstra,
Joseph Fannin, Scott Wood, Hans J. Koch, and Michael Chan.
[ Ported to current tree and all drivers converted. Integrated
Stephen's follow-on kerneldoc additions, and restored poll_list
handling to the old style to fix mutual exclusion issues. -DaveM ]
Signed-off-by: Stephen Hemminger <shemminger@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-10-04 07:41:36 +08:00
|
|
|
if (skb_queue_len(&npinfo->txq) == 0 && !netpoll_owner_active(dev)) {
|
2008-07-17 16:56:23 +08:00
|
|
|
struct netdev_queue *txq;
|
2006-12-12 09:24:46 +08:00
|
|
|
unsigned long flags;
|
|
|
|
|
|
2008-07-17 16:56:23 +08:00
|
|
|
txq = netdev_get_tx_queue(dev, skb_get_queue_mapping(skb));
|
|
|
|
|
|
2006-12-12 09:24:46 +08:00
|
|
|
local_irq_save(flags);
|
2007-06-27 15:39:42 +08:00
|
|
|
/* try until next clock tick */
|
|
|
|
|
for (tries = jiffies_to_usecs(1)/USEC_PER_POLL;
|
|
|
|
|
tries > 0; --tries) {
|
2008-07-17 16:56:23 +08:00
|
|
|
if (__netif_tx_trylock(txq)) {
|
2011-11-29 00:32:44 +08:00
|
|
|
if (!netif_xmit_stopped(txq)) {
|
2008-11-21 12:14:53 +08:00
|
|
|
status = ops->ndo_start_xmit(skb, dev);
|
2009-05-26 13:58:01 +08:00
|
|
|
if (status == NETDEV_TX_OK)
|
|
|
|
|
txq_trans_update(txq);
|
|
|
|
|
}
|
2008-07-17 16:56:23 +08:00
|
|
|
__netif_tx_unlock(txq);
|
2006-12-10 06:01:49 +08:00
|
|
|
|
|
|
|
|
if (status == NETDEV_TX_OK)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
}
|
2007-06-27 15:39:42 +08:00
|
|
|
|
|
|
|
|
/* tickle device maybe there is some cleanup */
|
2011-06-30 23:08:58 +08:00
|
|
|
netpoll_poll_dev(np->dev);
|
2007-06-27 15:39:42 +08:00
|
|
|
|
|
|
|
|
udelay(USEC_PER_POLL);
|
2005-08-12 10:25:54 +08:00
|
|
|
}
|
2009-08-21 11:33:36 +08:00
|
|
|
|
|
|
|
|
WARN_ONCE(!irqs_disabled(),
|
|
|
|
|
"netpoll_send_skb(): %s enabled interrupts in poll (%pF)\n",
|
|
|
|
|
dev->name, ops->ndo_start_xmit);
|
|
|
|
|
|
2006-12-12 09:24:46 +08:00
|
|
|
local_irq_restore(flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2006-10-27 06:46:54 +08:00
|
|
|
if (status != NETDEV_TX_OK) {
|
2006-10-27 06:46:55 +08:00
|
|
|
skb_queue_tail(&npinfo->txq, skb);
|
2006-12-05 22:37:56 +08:00
|
|
|
schedule_delayed_work(&npinfo->tx_work,0);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
2010-10-14 00:01:49 +08:00
|
|
|
EXPORT_SYMBOL(netpoll_send_skb_on_dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
void netpoll_send_udp(struct netpoll *np, const char *msg, int len)
|
|
|
|
|
{
|
2012-06-13 03:30:21 +08:00
|
|
|
int total_len, ip_len, udp_len;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct sk_buff *skb;
|
|
|
|
|
struct udphdr *udph;
|
|
|
|
|
struct iphdr *iph;
|
|
|
|
|
struct ethhdr *eth;
|
|
|
|
|
|
|
|
|
|
udp_len = len + sizeof(*udph);
|
2012-06-13 03:30:21 +08:00
|
|
|
ip_len = udp_len + sizeof(*iph);
|
|
|
|
|
total_len = ip_len + LL_RESERVED_SPACE(np->dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-06-13 03:30:21 +08:00
|
|
|
skb = find_skb(np, total_len + np->dev->needed_tailroom,
|
|
|
|
|
total_len - len);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!skb)
|
|
|
|
|
return;
|
|
|
|
|
|
2007-03-31 22:55:19 +08:00
|
|
|
skb_copy_to_linear_data(skb, msg, len);
|
2012-06-13 03:30:21 +08:00
|
|
|
skb_put(skb, len);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-03-14 01:28:48 +08:00
|
|
|
skb_push(skb, sizeof(*udph));
|
|
|
|
|
skb_reset_transport_header(skb);
|
|
|
|
|
udph = udp_hdr(skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
udph->source = htons(np->local_port);
|
|
|
|
|
udph->dest = htons(np->remote_port);
|
|
|
|
|
udph->len = htons(udp_len);
|
|
|
|
|
udph->check = 0;
|
2009-03-28 23:38:31 +08:00
|
|
|
udph->check = csum_tcpudp_magic(np->local_ip,
|
|
|
|
|
np->remote_ip,
|
2006-11-08 06:56:19 +08:00
|
|
|
udp_len, IPPROTO_UDP,
|
2008-11-20 07:44:53 +08:00
|
|
|
csum_partial(udph, udp_len, 0));
|
2006-11-08 06:56:19 +08:00
|
|
|
if (udph->check == 0)
|
2006-11-21 10:08:13 +08:00
|
|
|
udph->check = CSUM_MANGLED_0;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2007-04-11 11:46:21 +08:00
|
|
|
skb_push(skb, sizeof(*iph));
|
|
|
|
|
skb_reset_network_header(skb);
|
2007-04-21 13:47:35 +08:00
|
|
|
iph = ip_hdr(skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* iph->version = 4; iph->ihl = 5; */
|
|
|
|
|
put_unaligned(0x45, (unsigned char *)iph);
|
|
|
|
|
iph->tos = 0;
|
|
|
|
|
put_unaligned(htons(ip_len), &(iph->tot_len));
|
|
|
|
|
iph->id = 0;
|
|
|
|
|
iph->frag_off = 0;
|
|
|
|
|
iph->ttl = 64;
|
|
|
|
|
iph->protocol = IPPROTO_UDP;
|
|
|
|
|
iph->check = 0;
|
2009-03-28 23:38:31 +08:00
|
|
|
put_unaligned(np->local_ip, &(iph->saddr));
|
|
|
|
|
put_unaligned(np->remote_ip, &(iph->daddr));
|
2005-04-17 06:20:36 +08:00
|
|
|
iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
|
|
|
|
|
|
|
|
|
|
eth = (struct ethhdr *) skb_push(skb, ETH_HLEN);
|
2007-03-20 06:30:44 +08:00
|
|
|
skb_reset_mac_header(skb);
|
2006-10-20 14:58:23 +08:00
|
|
|
skb->protocol = eth->h_proto = htons(ETH_P_IP);
|
2007-11-20 11:23:29 +08:00
|
|
|
memcpy(eth->h_source, np->dev->dev_addr, ETH_ALEN);
|
|
|
|
|
memcpy(eth->h_dest, np->remote_mac, ETH_ALEN);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
skb->dev = np->dev;
|
|
|
|
|
|
|
|
|
|
netpoll_send_skb(np, skb);
|
|
|
|
|
}
|
2010-07-10 05:22:04 +08:00
|
|
|
EXPORT_SYMBOL(netpoll_send_udp);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
static void arp_reply(struct sk_buff *skb)
|
|
|
|
|
{
|
2005-06-23 13:05:31 +08:00
|
|
|
struct netpoll_info *npinfo = skb->dev->npinfo;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct arphdr *arp;
|
|
|
|
|
unsigned char *arp_ptr;
|
|
|
|
|
int size, type = ARPOP_REPLY, ptype = ETH_P_ARP;
|
2006-11-15 12:48:11 +08:00
|
|
|
__be32 sip, tip;
|
2006-12-08 16:05:55 +08:00
|
|
|
unsigned char *sha;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct sk_buff *send_skb;
|
2010-01-12 22:27:30 +08:00
|
|
|
struct netpoll *np, *tmp;
|
|
|
|
|
unsigned long flags;
|
2011-11-18 10:20:04 +08:00
|
|
|
int hlen, tlen;
|
2010-01-12 22:27:30 +08:00
|
|
|
int hits = 0;
|
|
|
|
|
|
|
|
|
|
if (list_empty(&npinfo->rx_np))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
/* Before checking the packet, we do some early
|
|
|
|
|
inspection whether this is interesting at all */
|
|
|
|
|
spin_lock_irqsave(&npinfo->rx_lock, flags);
|
|
|
|
|
list_for_each_entry_safe(np, tmp, &npinfo->rx_np, rx) {
|
|
|
|
|
if (np->dev == skb->dev)
|
|
|
|
|
hits++;
|
|
|
|
|
}
|
|
|
|
|
spin_unlock_irqrestore(&npinfo->rx_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-01-12 22:27:30 +08:00
|
|
|
/* No netpoll struct is using this dev */
|
|
|
|
|
if (!hits)
|
2005-06-23 13:05:31 +08:00
|
|
|
return;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
/* No arp on this interface */
|
|
|
|
|
if (skb->dev->flags & IFF_NOARP)
|
|
|
|
|
return;
|
|
|
|
|
|
2008-03-04 04:20:57 +08:00
|
|
|
if (!pskb_may_pull(skb, arp_hdr_len(skb->dev)))
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
|
|
2007-04-11 11:45:18 +08:00
|
|
|
skb_reset_network_header(skb);
|
2007-03-14 00:06:52 +08:00
|
|
|
skb_reset_transport_header(skb);
|
2007-03-13 07:56:31 +08:00
|
|
|
arp = arp_hdr(skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
|
|
|
|
|
arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
|
|
|
|
|
arp->ar_pro != htons(ETH_P_IP) ||
|
|
|
|
|
arp->ar_op != htons(ARPOP_REQUEST))
|
|
|
|
|
return;
|
|
|
|
|
|
2006-12-08 16:05:55 +08:00
|
|
|
arp_ptr = (unsigned char *)(arp+1);
|
|
|
|
|
/* save the location of the src hw addr */
|
|
|
|
|
sha = arp_ptr;
|
|
|
|
|
arp_ptr += skb->dev->addr_len;
|
2005-04-17 06:20:36 +08:00
|
|
|
memcpy(&sip, arp_ptr, 4);
|
2006-12-08 16:05:55 +08:00
|
|
|
arp_ptr += 4;
|
2010-01-12 22:27:30 +08:00
|
|
|
/* If we actually cared about dst hw addr,
|
|
|
|
|
it would get copied here */
|
2006-12-08 16:05:55 +08:00
|
|
|
arp_ptr += skb->dev->addr_len;
|
2005-04-17 06:20:36 +08:00
|
|
|
memcpy(&tip, arp_ptr, 4);
|
|
|
|
|
|
|
|
|
|
/* Should we ignore arp? */
|
2010-01-12 22:27:30 +08:00
|
|
|
if (ipv4_is_loopback(tip) || ipv4_is_multicast(tip))
|
2005-04-17 06:20:36 +08:00
|
|
|
return;
|
|
|
|
|
|
2008-03-04 04:20:57 +08:00
|
|
|
size = arp_hdr_len(skb->dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-01-12 22:27:30 +08:00
|
|
|
spin_lock_irqsave(&npinfo->rx_lock, flags);
|
|
|
|
|
list_for_each_entry_safe(np, tmp, &npinfo->rx_np, rx) {
|
|
|
|
|
if (tip != np->local_ip)
|
|
|
|
|
continue;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2011-11-18 10:20:04 +08:00
|
|
|
hlen = LL_RESERVED_SPACE(np->dev);
|
|
|
|
|
tlen = np->dev->needed_tailroom;
|
|
|
|
|
send_skb = find_skb(np, size + hlen + tlen, hlen);
|
2010-01-12 22:27:30 +08:00
|
|
|
if (!send_skb)
|
|
|
|
|
continue;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-01-12 22:27:30 +08:00
|
|
|
skb_reset_network_header(send_skb);
|
|
|
|
|
arp = (struct arphdr *) skb_put(send_skb, size);
|
|
|
|
|
send_skb->dev = skb->dev;
|
|
|
|
|
send_skb->protocol = htons(ETH_P_ARP);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-01-12 22:27:30 +08:00
|
|
|
/* Fill the device header for the ARP frame */
|
|
|
|
|
if (dev_hard_header(send_skb, skb->dev, ptype,
|
|
|
|
|
sha, np->dev->dev_addr,
|
|
|
|
|
send_skb->len) < 0) {
|
|
|
|
|
kfree_skb(send_skb);
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-01-12 22:27:30 +08:00
|
|
|
/*
|
|
|
|
|
* Fill out the arp protocol part.
|
|
|
|
|
*
|
|
|
|
|
* we only support ethernet device type,
|
|
|
|
|
* which (according to RFC 1390) should
|
|
|
|
|
* always equal 1 (Ethernet).
|
|
|
|
|
*/
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2010-01-12 22:27:30 +08:00
|
|
|
arp->ar_hrd = htons(np->dev->type);
|
|
|
|
|
arp->ar_pro = htons(ETH_P_IP);
|
|
|
|
|
arp->ar_hln = np->dev->addr_len;
|
|
|
|
|
arp->ar_pln = 4;
|
|
|
|
|
arp->ar_op = htons(type);
|
|
|
|
|
|
|
|
|
|
arp_ptr = (unsigned char *)(arp + 1);
|
|
|
|
|
memcpy(arp_ptr, np->dev->dev_addr, np->dev->addr_len);
|
|
|
|
|
arp_ptr += np->dev->addr_len;
|
|
|
|
|
memcpy(arp_ptr, &tip, 4);
|
|
|
|
|
arp_ptr += 4;
|
|
|
|
|
memcpy(arp_ptr, sha, np->dev->addr_len);
|
|
|
|
|
arp_ptr += np->dev->addr_len;
|
|
|
|
|
memcpy(arp_ptr, &sip, 4);
|
|
|
|
|
|
|
|
|
|
netpoll_send_skb(np, send_skb);
|
|
|
|
|
|
|
|
|
|
/* If there are several rx_hooks for the same address,
|
|
|
|
|
we're fine by sending a single reply */
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
spin_unlock_irqrestore(&npinfo->rx_lock, flags);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2012-08-10 09:24:40 +08:00
|
|
|
int __netpoll_rx(struct sk_buff *skb, struct netpoll_info *npinfo)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
|
|
|
|
int proto, len, ulen;
|
2010-01-12 22:27:30 +08:00
|
|
|
int hits = 0;
|
2011-04-22 12:53:02 +08:00
|
|
|
const struct iphdr *iph;
|
2005-04-17 06:20:36 +08:00
|
|
|
struct udphdr *uh;
|
2010-01-12 22:27:30 +08:00
|
|
|
struct netpoll *np, *tmp;
|
2006-06-26 15:04:27 +08:00
|
|
|
|
2010-01-12 22:27:30 +08:00
|
|
|
if (list_empty(&npinfo->rx_np))
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out;
|
2010-01-12 22:27:30 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (skb->dev->type != ARPHRD_ETHER)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2008-03-05 04:28:49 +08:00
|
|
|
/* check if netpoll clients need ARP */
|
2007-03-26 11:13:04 +08:00
|
|
|
if (skb->protocol == htons(ETH_P_ARP) &&
|
2005-04-17 06:20:36 +08:00
|
|
|
atomic_read(&trapped)) {
|
2010-01-12 22:27:30 +08:00
|
|
|
skb_queue_tail(&npinfo->arp_tx, skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
proto = ntohs(eth_hdr(skb)->h_proto);
|
|
|
|
|
if (proto != ETH_P_IP)
|
|
|
|
|
goto out;
|
|
|
|
|
if (skb->pkt_type == PACKET_OTHERHOST)
|
|
|
|
|
goto out;
|
|
|
|
|
if (skb_shared(skb))
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
if (!pskb_may_pull(skb, sizeof(struct iphdr)))
|
|
|
|
|
goto out;
|
2011-08-26 14:26:15 +08:00
|
|
|
iph = (struct iphdr *)skb->data;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (iph->ihl < 5 || iph->version != 4)
|
|
|
|
|
goto out;
|
|
|
|
|
if (!pskb_may_pull(skb, iph->ihl*4))
|
|
|
|
|
goto out;
|
2011-08-26 14:26:15 +08:00
|
|
|
iph = (struct iphdr *)skb->data;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (ip_fast_csum((u8 *)iph, iph->ihl) != 0)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
len = ntohs(iph->tot_len);
|
|
|
|
|
if (skb->len < len || len < iph->ihl*4)
|
|
|
|
|
goto out;
|
|
|
|
|
|
2007-04-18 03:40:20 +08:00
|
|
|
/*
|
|
|
|
|
* Our transport medium may have padded the buffer out.
|
|
|
|
|
* Now We trim to the true length of the frame.
|
|
|
|
|
*/
|
|
|
|
|
if (pskb_trim_rcsum(skb, len))
|
|
|
|
|
goto out;
|
|
|
|
|
|
2011-08-26 14:26:15 +08:00
|
|
|
iph = (struct iphdr *)skb->data;
|
2005-04-17 06:20:36 +08:00
|
|
|
if (iph->protocol != IPPROTO_UDP)
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
len -= iph->ihl*4;
|
|
|
|
|
uh = (struct udphdr *)(((char *)iph) + iph->ihl*4);
|
|
|
|
|
ulen = ntohs(uh->len);
|
|
|
|
|
|
|
|
|
|
if (ulen != len)
|
|
|
|
|
goto out;
|
2005-11-11 05:01:24 +08:00
|
|
|
if (checksum_udp(skb, uh, ulen, iph->saddr, iph->daddr))
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out;
|
|
|
|
|
|
2010-01-12 22:27:30 +08:00
|
|
|
list_for_each_entry_safe(np, tmp, &npinfo->rx_np, rx) {
|
|
|
|
|
if (np->local_ip && np->local_ip != iph->daddr)
|
|
|
|
|
continue;
|
|
|
|
|
if (np->remote_ip && np->remote_ip != iph->saddr)
|
|
|
|
|
continue;
|
|
|
|
|
if (np->local_port && np->local_port != ntohs(uh->dest))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
np->rx_hook(np, ntohs(uh->source),
|
|
|
|
|
(char *)(uh+1),
|
|
|
|
|
ulen - sizeof(struct udphdr));
|
|
|
|
|
hits++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!hits)
|
|
|
|
|
goto out;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
|
|
out:
|
|
|
|
|
if (atomic_read(&trapped)) {
|
|
|
|
|
kfree_skb(skb);
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
|
[NET] netconsole: Support dynamic reconfiguration using configfs
Based upon initial work by Keiichi Kii <k-keiichi@bx.jp.nec.com>.
This patch introduces support for dynamic reconfiguration (adding, removing
and/or modifying parameters of netconsole targets at runtime) using a
userspace interface exported via configfs. Documentation is also updated
accordingly.
Issues and brief design overview:
(1) Kernel-initiated creation / destruction of kernel objects is not
possible with configfs -- the lifetimes of the "config items" is managed
exclusively from userspace. But netconsole must support boot/module
params too, and these are parsed in kernel and hence netpolls must be
setup from the kernel. Joel Becker suggested to separately manage the
lifetimes of the two kinds of netconsole_target objects -- those created
via configfs mkdir(2) from userspace and those specified from the
boot/module option string. This adds complexity and some redundancy here
and also means that boot/module param-created targets are not exposed
through the configfs namespace (and hence cannot be updated / destroyed
dynamically). However, this saves us from locking / refcounting
complexities that would need to be introduced in configfs to support
kernel-initiated item creation / destroy there.
(2) In configfs, item creation takes place in the call chain of the
mkdir(2) syscall in the driver subsystem. If we used an ioctl(2) to
create / destroy objects from userspace, the special userspace program is
able to fill out the structure to be passed into the ioctl and hence
specify attributes such as local interface that are required at the time
we set up the netpoll. For configfs, this information is not available at
the time of mkdir(2). So, we keep all newly-created targets (via
configfs) disabled by default. The user is expected to set various
attributes appropriately (including the local network interface if
required) and then write(2) "1" to the "enabled" attribute. Thus,
netpoll_setup() is then called on the set parameters in the context of
_this_ write(2) on the "enabled" attribute itself. This design enables
the user to reconfigure existing netconsole targets at runtime to be
attached to newly-come-up interfaces that may not have existed when
netconsole was loaded or when the targets were actually created. All this
effectively enables us to get rid of custom ioctls.
(3) Ultra-paranoid configfs attribute show() and store() operations, with
sanity and input range checking, using only safe string primitives, and
compliant with the recommendations in Documentation/filesystems/sysfs.txt.
(4) A new function netpoll_print_options() is created in the netpoll API,
that just prints out the configured parameters for a netpoll structure.
netpoll_parse_options() is modified to use that and it is also exported to
be used from netconsole.
Signed-off-by: Satyam Sharma <satyam@infradead.org>
Acked-by: Keiichi Kii <k-keiichi@bx.jp.nec.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-08-11 06:35:05 +08:00
|
|
|
void netpoll_print_options(struct netpoll *np)
|
|
|
|
|
{
|
2012-01-29 23:50:43 +08:00
|
|
|
np_info(np, "local port %d\n", np->local_port);
|
|
|
|
|
np_info(np, "local IP %pI4\n", &np->local_ip);
|
|
|
|
|
np_info(np, "interface '%s'\n", np->dev_name);
|
|
|
|
|
np_info(np, "remote port %d\n", np->remote_port);
|
|
|
|
|
np_info(np, "remote IP %pI4\n", &np->remote_ip);
|
|
|
|
|
np_info(np, "remote ethernet address %pM\n", np->remote_mac);
|
[NET] netconsole: Support dynamic reconfiguration using configfs
Based upon initial work by Keiichi Kii <k-keiichi@bx.jp.nec.com>.
This patch introduces support for dynamic reconfiguration (adding, removing
and/or modifying parameters of netconsole targets at runtime) using a
userspace interface exported via configfs. Documentation is also updated
accordingly.
Issues and brief design overview:
(1) Kernel-initiated creation / destruction of kernel objects is not
possible with configfs -- the lifetimes of the "config items" is managed
exclusively from userspace. But netconsole must support boot/module
params too, and these are parsed in kernel and hence netpolls must be
setup from the kernel. Joel Becker suggested to separately manage the
lifetimes of the two kinds of netconsole_target objects -- those created
via configfs mkdir(2) from userspace and those specified from the
boot/module option string. This adds complexity and some redundancy here
and also means that boot/module param-created targets are not exposed
through the configfs namespace (and hence cannot be updated / destroyed
dynamically). However, this saves us from locking / refcounting
complexities that would need to be introduced in configfs to support
kernel-initiated item creation / destroy there.
(2) In configfs, item creation takes place in the call chain of the
mkdir(2) syscall in the driver subsystem. If we used an ioctl(2) to
create / destroy objects from userspace, the special userspace program is
able to fill out the structure to be passed into the ioctl and hence
specify attributes such as local interface that are required at the time
we set up the netpoll. For configfs, this information is not available at
the time of mkdir(2). So, we keep all newly-created targets (via
configfs) disabled by default. The user is expected to set various
attributes appropriately (including the local network interface if
required) and then write(2) "1" to the "enabled" attribute. Thus,
netpoll_setup() is then called on the set parameters in the context of
_this_ write(2) on the "enabled" attribute itself. This design enables
the user to reconfigure existing netconsole targets at runtime to be
attached to newly-come-up interfaces that may not have existed when
netconsole was loaded or when the targets were actually created. All this
effectively enables us to get rid of custom ioctls.
(3) Ultra-paranoid configfs attribute show() and store() operations, with
sanity and input range checking, using only safe string primitives, and
compliant with the recommendations in Documentation/filesystems/sysfs.txt.
(4) A new function netpoll_print_options() is created in the netpoll API,
that just prints out the configured parameters for a netpoll structure.
netpoll_parse_options() is modified to use that and it is also exported to
be used from netconsole.
Signed-off-by: Satyam Sharma <satyam@infradead.org>
Acked-by: Keiichi Kii <k-keiichi@bx.jp.nec.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-08-11 06:35:05 +08:00
|
|
|
}
|
2010-07-10 05:22:04 +08:00
|
|
|
EXPORT_SYMBOL(netpoll_print_options);
|
[NET] netconsole: Support dynamic reconfiguration using configfs
Based upon initial work by Keiichi Kii <k-keiichi@bx.jp.nec.com>.
This patch introduces support for dynamic reconfiguration (adding, removing
and/or modifying parameters of netconsole targets at runtime) using a
userspace interface exported via configfs. Documentation is also updated
accordingly.
Issues and brief design overview:
(1) Kernel-initiated creation / destruction of kernel objects is not
possible with configfs -- the lifetimes of the "config items" is managed
exclusively from userspace. But netconsole must support boot/module
params too, and these are parsed in kernel and hence netpolls must be
setup from the kernel. Joel Becker suggested to separately manage the
lifetimes of the two kinds of netconsole_target objects -- those created
via configfs mkdir(2) from userspace and those specified from the
boot/module option string. This adds complexity and some redundancy here
and also means that boot/module param-created targets are not exposed
through the configfs namespace (and hence cannot be updated / destroyed
dynamically). However, this saves us from locking / refcounting
complexities that would need to be introduced in configfs to support
kernel-initiated item creation / destroy there.
(2) In configfs, item creation takes place in the call chain of the
mkdir(2) syscall in the driver subsystem. If we used an ioctl(2) to
create / destroy objects from userspace, the special userspace program is
able to fill out the structure to be passed into the ioctl and hence
specify attributes such as local interface that are required at the time
we set up the netpoll. For configfs, this information is not available at
the time of mkdir(2). So, we keep all newly-created targets (via
configfs) disabled by default. The user is expected to set various
attributes appropriately (including the local network interface if
required) and then write(2) "1" to the "enabled" attribute. Thus,
netpoll_setup() is then called on the set parameters in the context of
_this_ write(2) on the "enabled" attribute itself. This design enables
the user to reconfigure existing netconsole targets at runtime to be
attached to newly-come-up interfaces that may not have existed when
netconsole was loaded or when the targets were actually created. All this
effectively enables us to get rid of custom ioctls.
(3) Ultra-paranoid configfs attribute show() and store() operations, with
sanity and input range checking, using only safe string primitives, and
compliant with the recommendations in Documentation/filesystems/sysfs.txt.
(4) A new function netpoll_print_options() is created in the netpoll API,
that just prints out the configured parameters for a netpoll structure.
netpoll_parse_options() is modified to use that and it is also exported to
be used from netconsole.
Signed-off-by: Satyam Sharma <satyam@infradead.org>
Acked-by: Keiichi Kii <k-keiichi@bx.jp.nec.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-08-11 06:35:05 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
int netpoll_parse_options(struct netpoll *np, char *opt)
|
|
|
|
|
{
|
|
|
|
|
char *cur=opt, *delim;
|
|
|
|
|
|
2006-11-15 12:40:49 +08:00
|
|
|
if (*cur != '@') {
|
2005-04-17 06:20:36 +08:00
|
|
|
if ((delim = strchr(cur, '@')) == NULL)
|
|
|
|
|
goto parse_failed;
|
2006-11-15 12:40:49 +08:00
|
|
|
*delim = 0;
|
|
|
|
|
np->local_port = simple_strtol(cur, NULL, 10);
|
|
|
|
|
cur = delim;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
cur++;
|
|
|
|
|
|
2006-11-15 12:40:49 +08:00
|
|
|
if (*cur != '/') {
|
2005-04-17 06:20:36 +08:00
|
|
|
if ((delim = strchr(cur, '/')) == NULL)
|
|
|
|
|
goto parse_failed;
|
2006-11-15 12:40:49 +08:00
|
|
|
*delim = 0;
|
2009-03-28 23:38:31 +08:00
|
|
|
np->local_ip = in_aton(cur);
|
2006-11-15 12:40:49 +08:00
|
|
|
cur = delim;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
cur++;
|
|
|
|
|
|
2006-11-15 12:40:49 +08:00
|
|
|
if (*cur != ',') {
|
2005-04-17 06:20:36 +08:00
|
|
|
/* parse out dev name */
|
|
|
|
|
if ((delim = strchr(cur, ',')) == NULL)
|
|
|
|
|
goto parse_failed;
|
2006-11-15 12:40:49 +08:00
|
|
|
*delim = 0;
|
2005-04-17 06:20:36 +08:00
|
|
|
strlcpy(np->dev_name, cur, sizeof(np->dev_name));
|
2006-11-15 12:40:49 +08:00
|
|
|
cur = delim;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
cur++;
|
|
|
|
|
|
2006-11-15 12:40:49 +08:00
|
|
|
if (*cur != '@') {
|
2005-04-17 06:20:36 +08:00
|
|
|
/* dst port */
|
|
|
|
|
if ((delim = strchr(cur, '@')) == NULL)
|
|
|
|
|
goto parse_failed;
|
2006-11-15 12:40:49 +08:00
|
|
|
*delim = 0;
|
2010-03-22 06:59:58 +08:00
|
|
|
if (*cur == ' ' || *cur == '\t')
|
2012-01-29 23:50:43 +08:00
|
|
|
np_info(np, "warning: whitespace is not allowed\n");
|
2006-11-15 12:40:49 +08:00
|
|
|
np->remote_port = simple_strtol(cur, NULL, 10);
|
|
|
|
|
cur = delim;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
cur++;
|
|
|
|
|
|
|
|
|
|
/* dst ip */
|
|
|
|
|
if ((delim = strchr(cur, '/')) == NULL)
|
|
|
|
|
goto parse_failed;
|
2006-11-15 12:40:49 +08:00
|
|
|
*delim = 0;
|
2009-03-28 23:38:31 +08:00
|
|
|
np->remote_ip = in_aton(cur);
|
2006-11-15 12:40:49 +08:00
|
|
|
cur = delim + 1;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-11-15 12:40:49 +08:00
|
|
|
if (*cur != 0) {
|
2005-04-17 06:20:36 +08:00
|
|
|
/* MAC address */
|
2011-05-08 07:00:07 +08:00
|
|
|
if (!mac_pton(cur, np->remote_mac))
|
2005-04-17 06:20:36 +08:00
|
|
|
goto parse_failed;
|
|
|
|
|
}
|
|
|
|
|
|
[NET] netconsole: Support dynamic reconfiguration using configfs
Based upon initial work by Keiichi Kii <k-keiichi@bx.jp.nec.com>.
This patch introduces support for dynamic reconfiguration (adding, removing
and/or modifying parameters of netconsole targets at runtime) using a
userspace interface exported via configfs. Documentation is also updated
accordingly.
Issues and brief design overview:
(1) Kernel-initiated creation / destruction of kernel objects is not
possible with configfs -- the lifetimes of the "config items" is managed
exclusively from userspace. But netconsole must support boot/module
params too, and these are parsed in kernel and hence netpolls must be
setup from the kernel. Joel Becker suggested to separately manage the
lifetimes of the two kinds of netconsole_target objects -- those created
via configfs mkdir(2) from userspace and those specified from the
boot/module option string. This adds complexity and some redundancy here
and also means that boot/module param-created targets are not exposed
through the configfs namespace (and hence cannot be updated / destroyed
dynamically). However, this saves us from locking / refcounting
complexities that would need to be introduced in configfs to support
kernel-initiated item creation / destroy there.
(2) In configfs, item creation takes place in the call chain of the
mkdir(2) syscall in the driver subsystem. If we used an ioctl(2) to
create / destroy objects from userspace, the special userspace program is
able to fill out the structure to be passed into the ioctl and hence
specify attributes such as local interface that are required at the time
we set up the netpoll. For configfs, this information is not available at
the time of mkdir(2). So, we keep all newly-created targets (via
configfs) disabled by default. The user is expected to set various
attributes appropriately (including the local network interface if
required) and then write(2) "1" to the "enabled" attribute. Thus,
netpoll_setup() is then called on the set parameters in the context of
_this_ write(2) on the "enabled" attribute itself. This design enables
the user to reconfigure existing netconsole targets at runtime to be
attached to newly-come-up interfaces that may not have existed when
netconsole was loaded or when the targets were actually created. All this
effectively enables us to get rid of custom ioctls.
(3) Ultra-paranoid configfs attribute show() and store() operations, with
sanity and input range checking, using only safe string primitives, and
compliant with the recommendations in Documentation/filesystems/sysfs.txt.
(4) A new function netpoll_print_options() is created in the netpoll API,
that just prints out the configured parameters for a netpoll structure.
netpoll_parse_options() is modified to use that and it is also exported to
be used from netconsole.
Signed-off-by: Satyam Sharma <satyam@infradead.org>
Acked-by: Keiichi Kii <k-keiichi@bx.jp.nec.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: David S. Miller <davem@davemloft.net>
2007-08-11 06:35:05 +08:00
|
|
|
netpoll_print_options(np);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
parse_failed:
|
2012-01-29 23:50:43 +08:00
|
|
|
np_info(np, "couldn't parse config at '%s'!\n", cur);
|
2005-04-17 06:20:36 +08:00
|
|
|
return -1;
|
|
|
|
|
}
|
2010-07-10 05:22:04 +08:00
|
|
|
EXPORT_SYMBOL(netpoll_parse_options);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-08-10 09:24:37 +08:00
|
|
|
int __netpoll_setup(struct netpoll *np, struct net_device *ndev, gfp_t gfp)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-06-23 13:05:31 +08:00
|
|
|
struct netpoll_info *npinfo;
|
2010-06-11 00:12:47 +08:00
|
|
|
const struct net_device_ops *ops;
|
2005-06-23 13:05:59 +08:00
|
|
|
unsigned long flags;
|
2006-10-27 06:46:52 +08:00
|
|
|
int err;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2012-07-17 13:22:35 +08:00
|
|
|
np->dev = ndev;
|
|
|
|
|
strlcpy(np->dev_name, ndev->name, IFNAMSIZ);
|
|
|
|
|
|
2010-06-11 00:12:48 +08:00
|
|
|
if ((ndev->priv_flags & IFF_DISABLE_NETPOLL) ||
|
|
|
|
|
!ndev->netdev_ops->ndo_poll_controller) {
|
2012-01-29 23:50:43 +08:00
|
|
|
np_err(np, "%s doesn't support polling, aborting\n",
|
|
|
|
|
np->dev_name);
|
2010-06-11 00:12:48 +08:00
|
|
|
err = -ENOTSUPP;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!ndev->npinfo) {
|
2012-08-10 09:24:37 +08:00
|
|
|
npinfo = kmalloc(sizeof(*npinfo), gfp);
|
2010-06-11 00:12:48 +08:00
|
|
|
if (!npinfo) {
|
|
|
|
|
err = -ENOMEM;
|
|
|
|
|
goto out;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
npinfo->rx_flags = 0;
|
|
|
|
|
INIT_LIST_HEAD(&npinfo->rx_np);
|
|
|
|
|
|
|
|
|
|
spin_lock_init(&npinfo->rx_lock);
|
|
|
|
|
skb_queue_head_init(&npinfo->arp_tx);
|
|
|
|
|
skb_queue_head_init(&npinfo->txq);
|
|
|
|
|
INIT_DELAYED_WORK(&npinfo->tx_work, queue_process);
|
|
|
|
|
|
|
|
|
|
atomic_set(&npinfo->refcnt, 1);
|
|
|
|
|
|
|
|
|
|
ops = np->dev->netdev_ops;
|
|
|
|
|
if (ops->ndo_netpoll_setup) {
|
2012-08-10 09:24:37 +08:00
|
|
|
err = ops->ndo_netpoll_setup(ndev, npinfo, gfp);
|
2010-06-11 00:12:48 +08:00
|
|
|
if (err)
|
|
|
|
|
goto free_npinfo;
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
npinfo = ndev->npinfo;
|
|
|
|
|
atomic_inc(&npinfo->refcnt);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
npinfo->netpoll = np;
|
|
|
|
|
|
|
|
|
|
if (np->rx_hook) {
|
|
|
|
|
spin_lock_irqsave(&npinfo->rx_lock, flags);
|
|
|
|
|
npinfo->rx_flags |= NETPOLL_RX_ENABLED;
|
|
|
|
|
list_add_tail(&np->rx, &npinfo->rx_np);
|
|
|
|
|
spin_unlock_irqrestore(&npinfo->rx_lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* last thing to do is link it to the net device structure */
|
2012-01-12 12:41:32 +08:00
|
|
|
rcu_assign_pointer(ndev->npinfo, npinfo);
|
2010-06-11 00:12:48 +08:00
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
free_npinfo:
|
|
|
|
|
kfree(npinfo);
|
|
|
|
|
out:
|
|
|
|
|
return err;
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(__netpoll_setup);
|
|
|
|
|
|
|
|
|
|
int netpoll_setup(struct netpoll *np)
|
|
|
|
|
{
|
|
|
|
|
struct net_device *ndev = NULL;
|
|
|
|
|
struct in_device *in_dev;
|
|
|
|
|
int err;
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (np->dev_name)
|
2007-09-18 02:56:21 +08:00
|
|
|
ndev = dev_get_by_name(&init_net, np->dev_name);
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!ndev) {
|
2012-01-29 23:50:43 +08:00
|
|
|
np_err(np, "%s doesn't exist, aborting\n", np->dev_name);
|
2006-10-27 06:46:52 +08:00
|
|
|
return -ENODEV;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2011-06-09 15:28:13 +08:00
|
|
|
if (ndev->master) {
|
2012-01-29 23:50:43 +08:00
|
|
|
np_err(np, "%s is a slave device, aborting\n", np->dev_name);
|
2011-06-12 09:55:22 +08:00
|
|
|
err = -EBUSY;
|
|
|
|
|
goto put;
|
2011-06-09 15:28:13 +08:00
|
|
|
}
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
if (!netif_running(ndev)) {
|
|
|
|
|
unsigned long atmost, atleast;
|
|
|
|
|
|
2012-01-29 23:50:43 +08:00
|
|
|
np_info(np, "device %s not up yet, forcing it\n", np->dev_name);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-03-21 14:23:58 +08:00
|
|
|
rtnl_lock();
|
2006-10-27 06:46:52 +08:00
|
|
|
err = dev_open(ndev);
|
|
|
|
|
rtnl_unlock();
|
|
|
|
|
|
|
|
|
|
if (err) {
|
2012-01-29 23:50:43 +08:00
|
|
|
np_err(np, "failed to open %s\n", ndev->name);
|
2010-06-11 00:12:46 +08:00
|
|
|
goto put;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
atleast = jiffies + HZ/10;
|
2009-07-09 02:10:56 +08:00
|
|
|
atmost = jiffies + carrier_timeout * HZ;
|
2005-04-17 06:20:36 +08:00
|
|
|
while (!netif_carrier_ok(ndev)) {
|
|
|
|
|
if (time_after(jiffies, atmost)) {
|
2012-01-29 23:50:43 +08:00
|
|
|
np_notice(np, "timeout waiting for carrier\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
break;
|
|
|
|
|
}
|
2009-07-09 11:09:44 +08:00
|
|
|
msleep(1);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If carrier appears to come up instantly, we don't
|
|
|
|
|
* trust it and pause so that we don't pump all our
|
|
|
|
|
* queued console messages into the bitbucket.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
if (time_before(jiffies, atleast)) {
|
2012-01-29 23:50:43 +08:00
|
|
|
np_notice(np, "carrier detect appears untrustworthy, waiting 4 seconds\n");
|
2005-04-17 06:20:36 +08:00
|
|
|
msleep(4000);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!np->local_ip) {
|
|
|
|
|
rcu_read_lock();
|
2005-10-04 05:35:55 +08:00
|
|
|
in_dev = __in_dev_get_rcu(ndev);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
if (!in_dev || !in_dev->ifa_list) {
|
|
|
|
|
rcu_read_unlock();
|
2012-01-29 23:50:43 +08:00
|
|
|
np_err(np, "no IP address for %s, aborting\n",
|
|
|
|
|
np->dev_name);
|
2006-10-27 06:46:52 +08:00
|
|
|
err = -EDESTADDRREQ;
|
2010-06-11 00:12:46 +08:00
|
|
|
goto put;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2009-03-28 23:38:31 +08:00
|
|
|
np->local_ip = in_dev->ifa_list->ifa_local;
|
2005-04-17 06:20:36 +08:00
|
|
|
rcu_read_unlock();
|
2012-01-29 23:50:43 +08:00
|
|
|
np_info(np, "local IP %pI4\n", &np->local_ip);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2010-06-11 00:12:46 +08:00
|
|
|
/* fill up the skb queue */
|
|
|
|
|
refill_skbs();
|
|
|
|
|
|
|
|
|
|
rtnl_lock();
|
2012-08-10 09:24:37 +08:00
|
|
|
err = __netpoll_setup(np, ndev, GFP_KERNEL);
|
2010-06-11 00:12:46 +08:00
|
|
|
rtnl_unlock();
|
2005-08-12 10:27:43 +08:00
|
|
|
|
2010-06-11 00:12:48 +08:00
|
|
|
if (err)
|
|
|
|
|
goto put;
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
|
|
2010-03-16 13:29:54 +08:00
|
|
|
put:
|
2005-04-17 06:20:36 +08:00
|
|
|
dev_put(ndev);
|
2006-10-27 06:46:52 +08:00
|
|
|
return err;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
2010-07-10 05:22:04 +08:00
|
|
|
EXPORT_SYMBOL(netpoll_setup);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2006-11-15 12:40:49 +08:00
|
|
|
static int __init netpoll_init(void)
|
|
|
|
|
{
|
2006-11-15 02:43:58 +08:00
|
|
|
skb_queue_head_init(&skb_pool);
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
core_initcall(netpoll_init);
|
|
|
|
|
|
2012-08-10 09:24:38 +08:00
|
|
|
static void rcu_cleanup_netpoll_info(struct rcu_head *rcu_head)
|
|
|
|
|
{
|
|
|
|
|
struct netpoll_info *npinfo =
|
|
|
|
|
container_of(rcu_head, struct netpoll_info, rcu);
|
|
|
|
|
|
|
|
|
|
skb_queue_purge(&npinfo->arp_tx);
|
|
|
|
|
skb_queue_purge(&npinfo->txq);
|
|
|
|
|
|
|
|
|
|
/* we can't call cancel_delayed_work_sync here, as we are in softirq */
|
|
|
|
|
cancel_delayed_work(&npinfo->tx_work);
|
|
|
|
|
|
|
|
|
|
/* clean after last, unfinished work */
|
|
|
|
|
__skb_queue_purge(&npinfo->txq);
|
|
|
|
|
/* now cancel it again */
|
|
|
|
|
cancel_delayed_work(&npinfo->tx_work);
|
|
|
|
|
kfree(npinfo);
|
|
|
|
|
}
|
|
|
|
|
|
2010-06-11 00:12:48 +08:00
|
|
|
void __netpoll_cleanup(struct netpoll *np)
|
2005-04-17 06:20:36 +08:00
|
|
|
{
|
2005-06-23 13:05:59 +08:00
|
|
|
struct netpoll_info *npinfo;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
2010-06-11 00:12:48 +08:00
|
|
|
npinfo = np->dev->npinfo;
|
|
|
|
|
if (!npinfo)
|
2010-06-11 00:12:46 +08:00
|
|
|
return;
|
2006-10-27 06:46:50 +08:00
|
|
|
|
2010-06-11 00:12:48 +08:00
|
|
|
if (!list_empty(&npinfo->rx_np)) {
|
|
|
|
|
spin_lock_irqsave(&npinfo->rx_lock, flags);
|
|
|
|
|
list_del(&np->rx);
|
|
|
|
|
if (list_empty(&npinfo->rx_np))
|
|
|
|
|
npinfo->rx_flags &= ~NETPOLL_RX_ENABLED;
|
|
|
|
|
spin_unlock_irqrestore(&npinfo->rx_lock, flags);
|
|
|
|
|
}
|
2010-06-11 00:12:44 +08:00
|
|
|
|
2010-06-11 00:12:48 +08:00
|
|
|
if (atomic_dec_and_test(&npinfo->refcnt)) {
|
|
|
|
|
const struct net_device_ops *ops;
|
2010-06-11 00:12:44 +08:00
|
|
|
|
2010-06-11 00:12:48 +08:00
|
|
|
ops = np->dev->netdev_ops;
|
|
|
|
|
if (ops->ndo_netpoll_cleanup)
|
|
|
|
|
ops->ndo_netpoll_cleanup(np->dev);
|
2010-06-11 00:12:44 +08:00
|
|
|
|
2011-08-02 00:19:00 +08:00
|
|
|
RCU_INIT_POINTER(np->dev->npinfo, NULL);
|
2012-08-10 09:24:38 +08:00
|
|
|
call_rcu_bh(&npinfo->rcu, rcu_cleanup_netpoll_info);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL_GPL(__netpoll_cleanup);
|
2010-06-11 00:12:44 +08:00
|
|
|
|
2012-08-10 09:24:38 +08:00
|
|
|
static void rcu_cleanup_netpoll(struct rcu_head *rcu_head)
|
|
|
|
|
{
|
|
|
|
|
struct netpoll *np = container_of(rcu_head, struct netpoll, rcu);
|
2006-10-27 06:46:50 +08:00
|
|
|
|
2012-08-10 09:24:38 +08:00
|
|
|
__netpoll_cleanup(np);
|
|
|
|
|
kfree(np);
|
|
|
|
|
}
|
2006-10-27 06:46:50 +08:00
|
|
|
|
2012-08-10 09:24:38 +08:00
|
|
|
void __netpoll_free_rcu(struct netpoll *np)
|
|
|
|
|
{
|
|
|
|
|
call_rcu_bh(&np->rcu, rcu_cleanup_netpoll);
|
2010-06-11 00:12:48 +08:00
|
|
|
}
|
2012-08-10 09:24:38 +08:00
|
|
|
EXPORT_SYMBOL_GPL(__netpoll_free_rcu);
|
2005-06-23 13:05:59 +08:00
|
|
|
|
2010-06-11 00:12:48 +08:00
|
|
|
void netpoll_cleanup(struct netpoll *np)
|
|
|
|
|
{
|
|
|
|
|
if (!np->dev)
|
|
|
|
|
return;
|
2010-06-11 00:12:46 +08:00
|
|
|
|
2010-06-11 00:12:48 +08:00
|
|
|
rtnl_lock();
|
|
|
|
|
__netpoll_cleanup(np);
|
|
|
|
|
rtnl_unlock();
|
|
|
|
|
|
|
|
|
|
dev_put(np->dev);
|
2005-04-17 06:20:36 +08:00
|
|
|
np->dev = NULL;
|
|
|
|
|
}
|
2010-07-10 05:22:04 +08:00
|
|
|
EXPORT_SYMBOL(netpoll_cleanup);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
int netpoll_trap(void)
|
|
|
|
|
{
|
|
|
|
|
return atomic_read(&trapped);
|
|
|
|
|
}
|
2010-07-10 05:22:04 +08:00
|
|
|
EXPORT_SYMBOL(netpoll_trap);
|
2005-04-17 06:20:36 +08:00
|
|
|
|
|
|
|
|
void netpoll_set_trap(int trap)
|
|
|
|
|
{
|
|
|
|
|
if (trap)
|
|
|
|
|
atomic_inc(&trapped);
|
|
|
|
|
else
|
|
|
|
|
atomic_dec(&trapped);
|
|
|
|
|
}
|
|
|
|
|
EXPORT_SYMBOL(netpoll_set_trap);
|
