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.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#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 <net/tcp.h>
|
|
|
|
|
#include <net/udp.h>
|
|
|
|
|
#include <asm/unaligned.h>
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* 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
|
|
|
|
|
#define MAX_QUEUE_DEPTH (MAX_SKBS / 2)
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
#define MAX_SKB_SIZE \
|
|
|
|
|
(MAX_UDP_CHUNK + sizeof(struct udphdr) + \
|
|
|
|
|
sizeof(struct iphdr) + sizeof(struct ethhdr))
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
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());
|
|
|
|
|
if (netif_tx_queue_stopped(txq) ||
|
2008-08-01 07:58:50 +08:00
|
|
|
netif_tx_queue_frozen(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);
|
|
|
|
|
|
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;
|
|
|
|
|
|
2007-11-20 11:18:11 +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
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
void netpoll_poll(struct netpoll *np)
|
|
|
|
|
{
|
2007-11-20 11:18:11 +08:00
|
|
|
struct net_device *dev = np->dev;
|
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
|
|
|
|
2007-11-20 11:18:11 +08:00
|
|
|
service_arp_queue(dev->npinfo);
|
2006-06-26 15:04:27 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
zap_completion_queue();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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;
|
2008-03-21 07:07:27 +08:00
|
|
|
if (skb->destructor) {
|
|
|
|
|
atomic_inc(&skb->users);
|
2005-04-17 06:20:36 +08:00
|
|
|
dev_kfree_skb_any(skb); /* put this one back */
|
2008-03-21 07:07:27 +08:00
|
|
|
} else {
|
2005-04-17 06:20:36 +08:00
|
|
|
__kfree_skb(skb);
|
2008-03-21 07:07:27 +08:00
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
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) {
|
|
|
|
|
netpoll_poll(np);
|
|
|
|
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
static void netpoll_send_skb(struct netpoll *np, struct sk_buff *skb)
|
|
|
|
|
{
|
2006-10-27 06:46:54 +08:00
|
|
|
int status = NETDEV_TX_BUSY;
|
|
|
|
|
unsigned long tries;
|
2007-02-09 22:24:36 +08:00
|
|
|
struct net_device *dev = np->dev;
|
2008-11-21 12:14:53 +08:00
|
|
|
const struct net_device_ops *ops = dev->netdev_ops;
|
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)) {
|
|
|
|
|
if (!netif_tx_queue_stopped(txq))
|
2008-11-21 12:14:53 +08:00
|
|
|
status = ops->ndo_start_xmit(skb, dev);
|
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 */
|
|
|
|
|
netpoll_poll(np);
|
|
|
|
|
|
|
|
|
|
udelay(USEC_PER_POLL);
|
2005-08-12 10:25:54 +08:00
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void netpoll_send_udp(struct netpoll *np, const char *msg, int len)
|
|
|
|
|
{
|
|
|
|
|
int total_len, eth_len, ip_len, udp_len;
|
|
|
|
|
struct sk_buff *skb;
|
|
|
|
|
struct udphdr *udph;
|
|
|
|
|
struct iphdr *iph;
|
|
|
|
|
struct ethhdr *eth;
|
|
|
|
|
|
|
|
|
|
udp_len = len + sizeof(*udph);
|
|
|
|
|
ip_len = eth_len = udp_len + sizeof(*iph);
|
|
|
|
|
total_len = eth_len + ETH_HLEN + NET_IP_ALIGN;
|
|
|
|
|
|
|
|
|
|
skb = find_skb(np, total_len, total_len - len);
|
|
|
|
|
if (!skb)
|
|
|
|
|
return;
|
|
|
|
|
|
2007-03-31 22:55:19 +08:00
|
|
|
skb_copy_to_linear_data(skb, msg, len);
|
2005-04-17 06:20:36 +08:00
|
|
|
skb->len += len;
|
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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;
|
2005-06-23 13:05:31 +08:00
|
|
|
struct netpoll *np = NULL;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-06-23 13:05:59 +08:00
|
|
|
if (npinfo->rx_np && npinfo->rx_np->dev == skb->dev)
|
|
|
|
|
np = npinfo->rx_np;
|
2005-06-23 13:05:31 +08:00
|
|
|
if (!np)
|
|
|
|
|
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;
|
|
|
|
|
/* if we actually cared about dst hw addr, it would get copied here */
|
|
|
|
|
arp_ptr += skb->dev->addr_len;
|
2005-04-17 06:20:36 +08:00
|
|
|
memcpy(&tip, arp_ptr, 4);
|
|
|
|
|
|
|
|
|
|
/* Should we ignore arp? */
|
2009-03-28 23:38:31 +08:00
|
|
|
if (tip != np->local_ip ||
|
2007-12-17 05:44:00 +08:00
|
|
|
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);
|
2008-05-13 11:48:31 +08:00
|
|
|
send_skb = find_skb(np, size + LL_ALLOCATED_SPACE(np->dev),
|
2005-04-17 06:20:36 +08:00
|
|
|
LL_RESERVED_SPACE(np->dev));
|
|
|
|
|
|
|
|
|
|
if (!send_skb)
|
|
|
|
|
return;
|
|
|
|
|
|
2007-04-11 11:45:18 +08:00
|
|
|
skb_reset_network_header(send_skb);
|
2005-04-17 06:20:36 +08:00
|
|
|
arp = (struct arphdr *) skb_put(send_skb, size);
|
|
|
|
|
send_skb->dev = skb->dev;
|
|
|
|
|
send_skb->protocol = htons(ETH_P_ARP);
|
|
|
|
|
|
|
|
|
|
/* Fill the device header for the ARP frame */
|
2007-10-09 16:36:32 +08:00
|
|
|
if (dev_hard_header(send_skb, skb->dev, ptype,
|
2007-11-20 11:23:29 +08:00
|
|
|
sha, np->dev->dev_addr,
|
2007-10-09 16:36:32 +08:00
|
|
|
send_skb->len) < 0) {
|
2005-04-17 06:20:36 +08:00
|
|
|
kfree_skb(send_skb);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Fill out the arp protocol part.
|
|
|
|
|
*
|
|
|
|
|
* we only support ethernet device type,
|
|
|
|
|
* which (according to RFC 1390) should always equal 1 (Ethernet).
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
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;
|
2006-12-08 16:05:55 +08:00
|
|
|
memcpy(arp_ptr, sha, np->dev->addr_len);
|
2005-04-17 06:20:36 +08:00
|
|
|
arp_ptr += np->dev->addr_len;
|
|
|
|
|
memcpy(arp_ptr, &sip, 4);
|
|
|
|
|
|
|
|
|
|
netpoll_send_skb(np, send_skb);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int __netpoll_rx(struct sk_buff *skb)
|
|
|
|
|
{
|
|
|
|
|
int proto, len, ulen;
|
|
|
|
|
struct iphdr *iph;
|
|
|
|
|
struct udphdr *uh;
|
2006-06-26 15:04:27 +08:00
|
|
|
struct netpoll_info *npi = skb->dev->npinfo;
|
|
|
|
|
struct netpoll *np = npi->rx_np;
|
|
|
|
|
|
2005-06-23 13:05:59 +08:00
|
|
|
if (!np)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out;
|
|
|
|
|
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)) {
|
2006-06-26 15:04:27 +08:00
|
|
|
skb_queue_tail(&npi->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;
|
|
|
|
|
|
|
|
|
|
iph = (struct iphdr *)skb->data;
|
|
|
|
|
if (!pskb_may_pull(skb, sizeof(struct iphdr)))
|
|
|
|
|
goto out;
|
|
|
|
|
if (iph->ihl < 5 || iph->version != 4)
|
|
|
|
|
goto out;
|
|
|
|
|
if (!pskb_may_pull(skb, iph->ihl*4))
|
|
|
|
|
goto out;
|
|
|
|
|
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;
|
|
|
|
|
|
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;
|
2009-03-28 23:38:31 +08:00
|
|
|
if (np->local_ip && np->local_ip != iph->daddr)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out;
|
2009-03-28 23:38:31 +08:00
|
|
|
if (np->remote_ip && np->remote_ip != iph->saddr)
|
2005-04-17 06:20:36 +08:00
|
|
|
goto out;
|
|
|
|
|
if (np->local_port && np->local_port != ntohs(uh->dest))
|
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
|
|
np->rx_hook(np, ntohs(uh->source),
|
|
|
|
|
(char *)(uh+1),
|
|
|
|
|
ulen - sizeof(struct udphdr));
|
|
|
|
|
|
|
|
|
|
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)
|
|
|
|
|
{
|
|
|
|
|
printk(KERN_INFO "%s: local port %d\n",
|
|
|
|
|
np->name, np->local_port);
|
2009-03-28 23:38:31 +08:00
|
|
|
printk(KERN_INFO "%s: local IP %pI4\n",
|
|
|
|
|
np->name, &np->local_ip);
|
[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
|
|
|
printk(KERN_INFO "%s: interface %s\n",
|
|
|
|
|
np->name, np->dev_name);
|
|
|
|
|
printk(KERN_INFO "%s: remote port %d\n",
|
|
|
|
|
np->name, np->remote_port);
|
2009-03-28 23:38:31 +08:00
|
|
|
printk(KERN_INFO "%s: remote IP %pI4\n",
|
|
|
|
|
np->name, &np->remote_ip);
|
2008-10-28 06:59:26 +08:00
|
|
|
printk(KERN_INFO "%s: remote ethernet address %pM\n",
|
|
|
|
|
np->name, 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
|
|
|
}
|
|
|
|
|
|
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;
|
|
|
|
|
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 */
|
|
|
|
|
if ((delim = strchr(cur, ':')) == NULL)
|
|
|
|
|
goto parse_failed;
|
2006-11-15 12:40:49 +08:00
|
|
|
*delim = 0;
|
|
|
|
|
np->remote_mac[0] = simple_strtol(cur, NULL, 16);
|
|
|
|
|
cur = delim + 1;
|
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->remote_mac[1] = simple_strtol(cur, NULL, 16);
|
|
|
|
|
cur = delim + 1;
|
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->remote_mac[2] = simple_strtol(cur, NULL, 16);
|
|
|
|
|
cur = delim + 1;
|
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->remote_mac[3] = simple_strtol(cur, NULL, 16);
|
|
|
|
|
cur = delim + 1;
|
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->remote_mac[4] = simple_strtol(cur, NULL, 16);
|
|
|
|
|
cur = delim + 1;
|
|
|
|
|
np->remote_mac[5] = simple_strtol(cur, NULL, 16);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
[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:
|
|
|
|
|
printk(KERN_INFO "%s: couldn't parse config at %s!\n",
|
|
|
|
|
np->name, cur);
|
|
|
|
|
return -1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int netpoll_setup(struct netpoll *np)
|
|
|
|
|
{
|
|
|
|
|
struct net_device *ndev = NULL;
|
|
|
|
|
struct in_device *in_dev;
|
2005-06-23 13:05:31 +08:00
|
|
|
struct netpoll_info *npinfo;
|
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
|
|
|
|
|
|
|
|
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) {
|
|
|
|
|
printk(KERN_ERR "%s: %s doesn't exist, aborting.\n",
|
|
|
|
|
np->name, np->dev_name);
|
2006-10-27 06:46:52 +08:00
|
|
|
return -ENODEV;
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
np->dev = ndev;
|
2005-06-23 13:05:31 +08:00
|
|
|
if (!ndev->npinfo) {
|
|
|
|
|
npinfo = kmalloc(sizeof(*npinfo), GFP_KERNEL);
|
2006-10-27 06:46:52 +08:00
|
|
|
if (!npinfo) {
|
|
|
|
|
err = -ENOMEM;
|
2005-06-23 13:05:31 +08:00
|
|
|
goto release;
|
2006-10-27 06:46:52 +08:00
|
|
|
}
|
2005-06-23 13:05:31 +08:00
|
|
|
|
2008-03-05 04:28:49 +08:00
|
|
|
npinfo->rx_flags = 0;
|
2005-06-23 13:05:59 +08:00
|
|
|
npinfo->rx_np = NULL;
|
2006-10-27 06:46:54 +08:00
|
|
|
|
2005-09-10 04:10:41 +08:00
|
|
|
spin_lock_init(&npinfo->rx_lock);
|
2006-06-26 15:04:27 +08:00
|
|
|
skb_queue_head_init(&npinfo->arp_tx);
|
2006-10-27 06:46:51 +08:00
|
|
|
skb_queue_head_init(&npinfo->txq);
|
2006-12-05 22:37:56 +08:00
|
|
|
INIT_DELAYED_WORK(&npinfo->tx_work, queue_process);
|
2006-10-27 06:46:51 +08:00
|
|
|
|
2006-10-27 06:46:50 +08:00
|
|
|
atomic_set(&npinfo->refcnt, 1);
|
|
|
|
|
} else {
|
2005-06-23 13:05:31 +08:00
|
|
|
npinfo = ndev->npinfo;
|
2006-10-27 06:46:50 +08:00
|
|
|
atomic_inc(&npinfo->refcnt);
|
|
|
|
|
}
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2008-11-20 13:32:24 +08:00
|
|
|
if (!ndev->netdev_ops->ndo_poll_controller) {
|
2005-04-17 06:20:36 +08:00
|
|
|
printk(KERN_ERR "%s: %s doesn't support polling, aborting.\n",
|
|
|
|
|
np->name, np->dev_name);
|
2006-10-27 06:46:52 +08:00
|
|
|
err = -ENOTSUPP;
|
2005-04-17 06:20:36 +08:00
|
|
|
goto release;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!netif_running(ndev)) {
|
|
|
|
|
unsigned long atmost, atleast;
|
|
|
|
|
|
|
|
|
|
printk(KERN_INFO "%s: device %s not up yet, forcing it\n",
|
|
|
|
|
np->name, np->dev_name);
|
|
|
|
|
|
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) {
|
2005-04-17 06:20:36 +08:00
|
|
|
printk(KERN_ERR "%s: failed to open %s\n",
|
2006-10-27 06:46:52 +08:00
|
|
|
np->name, ndev->name);
|
2005-04-17 06:20:36 +08:00
|
|
|
goto release;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
atleast = jiffies + HZ/10;
|
2007-02-09 22:24:36 +08:00
|
|
|
atmost = jiffies + 4*HZ;
|
2005-04-17 06:20:36 +08:00
|
|
|
while (!netif_carrier_ok(ndev)) {
|
|
|
|
|
if (time_after(jiffies, atmost)) {
|
|
|
|
|
printk(KERN_NOTICE
|
|
|
|
|
"%s: timeout waiting for carrier\n",
|
|
|
|
|
np->name);
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
cond_resched();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 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)) {
|
|
|
|
|
printk(KERN_NOTICE "%s: carrier detect appears"
|
|
|
|
|
" untrustworthy, waiting 4 seconds\n",
|
|
|
|
|
np->name);
|
|
|
|
|
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();
|
|
|
|
|
printk(KERN_ERR "%s: no IP address for %s, aborting\n",
|
|
|
|
|
np->name, np->dev_name);
|
2006-10-27 06:46:52 +08:00
|
|
|
err = -EDESTADDRREQ;
|
2005-04-17 06:20:36 +08:00
|
|
|
goto release;
|
|
|
|
|
}
|
|
|
|
|
|
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();
|
2009-03-28 23:38:31 +08:00
|
|
|
printk(KERN_INFO "%s: local IP %pI4\n", np->name, &np->local_ip);
|
2005-04-17 06:20:36 +08:00
|
|
|
}
|
|
|
|
|
|
2005-06-23 13:05:59 +08:00
|
|
|
if (np->rx_hook) {
|
|
|
|
|
spin_lock_irqsave(&npinfo->rx_lock, flags);
|
2008-03-05 04:28:49 +08:00
|
|
|
npinfo->rx_flags |= NETPOLL_RX_ENABLED;
|
2005-06-23 13:05:59 +08:00
|
|
|
npinfo->rx_np = np;
|
|
|
|
|
spin_unlock_irqrestore(&npinfo->rx_lock, flags);
|
|
|
|
|
}
|
2005-08-12 10:26:42 +08:00
|
|
|
|
|
|
|
|
/* fill up the skb queue */
|
|
|
|
|
refill_skbs();
|
|
|
|
|
|
2005-06-23 13:05:59 +08:00
|
|
|
/* last thing to do is link it to the net device structure */
|
2005-06-23 13:05:31 +08:00
|
|
|
ndev->npinfo = npinfo;
|
2005-04-17 06:20:36 +08:00
|
|
|
|
2005-08-12 10:27:43 +08:00
|
|
|
/* avoid racing with NAPI reading npinfo */
|
|
|
|
|
synchronize_rcu();
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
release:
|
2005-06-23 13:05:31 +08:00
|
|
|
if (!ndev->npinfo)
|
|
|
|
|
kfree(npinfo);
|
2005-04-17 06:20:36 +08:00
|
|
|
np->dev = NULL;
|
|
|
|
|
dev_put(ndev);
|
2006-10-27 06:46:52 +08:00
|
|
|
return err;
|
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);
|
|
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
void netpoll_cleanup(struct netpoll *np)
|
|
|
|
|
{
|
2005-06-23 13:05:59 +08:00
|
|
|
struct netpoll_info *npinfo;
|
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
2005-06-23 13:05:31 +08:00
|
|
|
if (np->dev) {
|
2005-06-23 13:05:59 +08:00
|
|
|
npinfo = np->dev->npinfo;
|
2006-10-27 06:46:50 +08:00
|
|
|
if (npinfo) {
|
|
|
|
|
if (npinfo->rx_np == np) {
|
|
|
|
|
spin_lock_irqsave(&npinfo->rx_lock, flags);
|
|
|
|
|
npinfo->rx_np = NULL;
|
2008-03-05 04:28:49 +08:00
|
|
|
npinfo->rx_flags &= ~NETPOLL_RX_ENABLED;
|
2006-10-27 06:46:50 +08:00
|
|
|
spin_unlock_irqrestore(&npinfo->rx_lock, flags);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (atomic_dec_and_test(&npinfo->refcnt)) {
|
|
|
|
|
skb_queue_purge(&npinfo->arp_tx);
|
2007-02-09 22:24:36 +08:00
|
|
|
skb_queue_purge(&npinfo->txq);
|
2007-07-06 08:42:44 +08:00
|
|
|
cancel_rearming_delayed_work(&npinfo->tx_work);
|
2006-10-27 06:46:50 +08:00
|
|
|
|
2007-06-29 13:11:47 +08:00
|
|
|
/* clean after last, unfinished work */
|
2007-11-20 11:15:03 +08:00
|
|
|
__skb_queue_purge(&npinfo->txq);
|
2006-10-27 06:46:50 +08:00
|
|
|
kfree(npinfo);
|
2007-07-10 06:22:23 +08:00
|
|
|
np->dev->npinfo = NULL;
|
2006-10-27 06:46:50 +08:00
|
|
|
}
|
2005-06-23 13:05:59 +08:00
|
|
|
}
|
2006-10-27 06:46:50 +08:00
|
|
|
|
2005-06-23 13:05:31 +08:00
|
|
|
dev_put(np->dev);
|
|
|
|
|
}
|
2005-06-23 13:05:59 +08:00
|
|
|
|
2005-04-17 06:20:36 +08:00
|
|
|
np->dev = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int netpoll_trap(void)
|
|
|
|
|
{
|
|
|
|
|
return atomic_read(&trapped);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void netpoll_set_trap(int trap)
|
|
|
|
|
{
|
|
|
|
|
if (trap)
|
|
|
|
|
atomic_inc(&trapped);
|
|
|
|
|
else
|
|
|
|
|
atomic_dec(&trapped);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
EXPORT_SYMBOL(netpoll_set_trap);
|
|
|
|
|
EXPORT_SYMBOL(netpoll_trap);
|
[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
|
|
|
EXPORT_SYMBOL(netpoll_print_options);
|
2005-04-17 06:20:36 +08:00
|
|
|
EXPORT_SYMBOL(netpoll_parse_options);
|
|
|
|
|
EXPORT_SYMBOL(netpoll_setup);
|
|
|
|
|
EXPORT_SYMBOL(netpoll_cleanup);
|
|
|
|
|
EXPORT_SYMBOL(netpoll_send_udp);
|
|
|
|
|
EXPORT_SYMBOL(netpoll_poll);
|