mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-05 10:04:12 +08:00
881d966b48
This patch makes most of the generic device layer network namespace safe. This patch makes dev_base_head a network namespace variable, and then it picks up a few associated variables. The functions: dev_getbyhwaddr dev_getfirsthwbytype dev_get_by_flags dev_get_by_name __dev_get_by_name dev_get_by_index __dev_get_by_index dev_ioctl dev_ethtool dev_load wireless_process_ioctl were modified to take a network namespace argument, and deal with it. vlan_ioctl_set and brioctl_set were modified so their hooks will receive a network namespace argument. So basically anthing in the core of the network stack that was affected to by the change of dev_base was modified to handle multiple network namespaces. The rest of the network stack was simply modified to explicitly use &init_net the initial network namespace. This can be fixed when those components of the network stack are modified to handle multiple network namespaces. For now the ifindex generator is left global. Fundametally ifindex numbers are per namespace, or else we will have corner case problems with migration when we get that far. At the same time there are assumptions in the network stack that the ifindex of a network device won't change. Making the ifindex number global seems a good compromise until the network stack can cope with ifindex changes when you change namespaces, and the like. Signed-off-by: Eric W. Biederman <ebiederm@xmission.com> Signed-off-by: David S. Miller <davem@davemloft.net>
845 lines
19 KiB
C
845 lines
19 KiB
C
/*
|
|
* 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>
|
|
#include <linux/if_arp.h>
|
|
#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)
|
|
|
|
static struct sk_buff_head skb_pool;
|
|
|
|
static atomic_t trapped;
|
|
|
|
#define USEC_PER_POLL 50
|
|
#define NETPOLL_RX_ENABLED 1
|
|
#define NETPOLL_RX_DROP 2
|
|
|
|
#define MAX_SKB_SIZE \
|
|
(MAX_UDP_CHUNK + sizeof(struct udphdr) + \
|
|
sizeof(struct iphdr) + sizeof(struct ethhdr))
|
|
|
|
static void zap_completion_queue(void);
|
|
static void arp_reply(struct sk_buff *skb);
|
|
|
|
static void queue_process(struct work_struct *work)
|
|
{
|
|
struct netpoll_info *npinfo =
|
|
container_of(work, struct netpoll_info, tx_work.work);
|
|
struct sk_buff *skb;
|
|
unsigned long flags;
|
|
|
|
while ((skb = skb_dequeue(&npinfo->txq))) {
|
|
struct net_device *dev = skb->dev;
|
|
|
|
if (!netif_device_present(dev) || !netif_running(dev)) {
|
|
__kfree_skb(skb);
|
|
continue;
|
|
}
|
|
|
|
local_irq_save(flags);
|
|
netif_tx_lock(dev);
|
|
if ((netif_queue_stopped(dev) ||
|
|
netif_subqueue_stopped(dev, skb->queue_mapping)) ||
|
|
dev->hard_start_xmit(skb, dev) != NETDEV_TX_OK) {
|
|
skb_queue_head(&npinfo->txq, skb);
|
|
netif_tx_unlock(dev);
|
|
local_irq_restore(flags);
|
|
|
|
schedule_delayed_work(&npinfo->tx_work, HZ/10);
|
|
return;
|
|
}
|
|
netif_tx_unlock(dev);
|
|
local_irq_restore(flags);
|
|
}
|
|
}
|
|
|
|
static __sum16 checksum_udp(struct sk_buff *skb, struct udphdr *uh,
|
|
unsigned short ulen, __be32 saddr, __be32 daddr)
|
|
{
|
|
__wsum psum;
|
|
|
|
if (uh->check == 0 || skb_csum_unnecessary(skb))
|
|
return 0;
|
|
|
|
psum = csum_tcpudp_nofold(saddr, daddr, ulen, IPPROTO_UDP, 0);
|
|
|
|
if (skb->ip_summed == CHECKSUM_COMPLETE &&
|
|
!csum_fold(csum_add(psum, skb->csum)))
|
|
return 0;
|
|
|
|
skb->csum = psum;
|
|
|
|
return __skb_checksum_complete(skb);
|
|
}
|
|
|
|
/*
|
|
* 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.
|
|
*/
|
|
static void poll_napi(struct netpoll *np)
|
|
{
|
|
struct netpoll_info *npinfo = np->dev->npinfo;
|
|
struct napi_struct *napi;
|
|
int budget = 16;
|
|
|
|
list_for_each_entry(napi, &np->dev->napi_list, dev_list) {
|
|
if (test_bit(NAPI_STATE_SCHED, &napi->state) &&
|
|
napi->poll_owner != smp_processor_id() &&
|
|
spin_trylock(&napi->poll_lock)) {
|
|
npinfo->rx_flags |= NETPOLL_RX_DROP;
|
|
atomic_inc(&trapped);
|
|
|
|
napi->poll(napi, budget);
|
|
|
|
atomic_dec(&trapped);
|
|
npinfo->rx_flags &= ~NETPOLL_RX_DROP;
|
|
spin_unlock(&napi->poll_lock);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void service_arp_queue(struct netpoll_info *npi)
|
|
{
|
|
struct sk_buff *skb;
|
|
|
|
if (unlikely(!npi))
|
|
return;
|
|
|
|
skb = skb_dequeue(&npi->arp_tx);
|
|
|
|
while (skb != NULL) {
|
|
arp_reply(skb);
|
|
skb = skb_dequeue(&npi->arp_tx);
|
|
}
|
|
}
|
|
|
|
void netpoll_poll(struct netpoll *np)
|
|
{
|
|
if (!np->dev || !netif_running(np->dev) || !np->dev->poll_controller)
|
|
return;
|
|
|
|
/* Process pending work on NIC */
|
|
np->dev->poll_controller(np->dev);
|
|
if (!list_empty(&np->dev->napi_list))
|
|
poll_napi(np);
|
|
|
|
service_arp_queue(np->dev->npinfo);
|
|
|
|
zap_completion_queue();
|
|
}
|
|
|
|
static void refill_skbs(void)
|
|
{
|
|
struct sk_buff *skb;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&skb_pool.lock, flags);
|
|
while (skb_pool.qlen < MAX_SKBS) {
|
|
skb = alloc_skb(MAX_SKB_SIZE, GFP_ATOMIC);
|
|
if (!skb)
|
|
break;
|
|
|
|
__skb_queue_tail(&skb_pool, skb);
|
|
}
|
|
spin_unlock_irqrestore(&skb_pool.lock, flags);
|
|
}
|
|
|
|
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)
|
|
dev_kfree_skb_any(skb); /* put this one back */
|
|
else
|
|
__kfree_skb(skb);
|
|
}
|
|
}
|
|
|
|
put_cpu_var(softnet_data);
|
|
}
|
|
|
|
static struct sk_buff *find_skb(struct netpoll *np, int len, int reserve)
|
|
{
|
|
int count = 0;
|
|
struct sk_buff *skb;
|
|
|
|
zap_completion_queue();
|
|
refill_skbs();
|
|
repeat:
|
|
|
|
skb = alloc_skb(len, GFP_ATOMIC);
|
|
if (!skb)
|
|
skb = skb_dequeue(&skb_pool);
|
|
|
|
if (!skb) {
|
|
if (++count < 10) {
|
|
netpoll_poll(np);
|
|
goto repeat;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
atomic_set(&skb->users, 1);
|
|
skb_reserve(skb, reserve);
|
|
return skb;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
static void netpoll_send_skb(struct netpoll *np, struct sk_buff *skb)
|
|
{
|
|
int status = NETDEV_TX_BUSY;
|
|
unsigned long tries;
|
|
struct net_device *dev = np->dev;
|
|
struct netpoll_info *npinfo = np->dev->npinfo;
|
|
|
|
if (!npinfo || !netif_running(dev) || !netif_device_present(dev)) {
|
|
__kfree_skb(skb);
|
|
return;
|
|
}
|
|
|
|
/* don't get messages out of order, and no recursion */
|
|
if (skb_queue_len(&npinfo->txq) == 0 && !netpoll_owner_active(dev)) {
|
|
unsigned long flags;
|
|
|
|
local_irq_save(flags);
|
|
/* try until next clock tick */
|
|
for (tries = jiffies_to_usecs(1)/USEC_PER_POLL;
|
|
tries > 0; --tries) {
|
|
if (netif_tx_trylock(dev)) {
|
|
if (!netif_queue_stopped(dev) &&
|
|
!netif_subqueue_stopped(dev, skb->queue_mapping))
|
|
status = dev->hard_start_xmit(skb, dev);
|
|
netif_tx_unlock(dev);
|
|
|
|
if (status == NETDEV_TX_OK)
|
|
break;
|
|
|
|
}
|
|
|
|
/* tickle device maybe there is some cleanup */
|
|
netpoll_poll(np);
|
|
|
|
udelay(USEC_PER_POLL);
|
|
}
|
|
local_irq_restore(flags);
|
|
}
|
|
|
|
if (status != NETDEV_TX_OK) {
|
|
skb_queue_tail(&npinfo->txq, skb);
|
|
schedule_delayed_work(&npinfo->tx_work,0);
|
|
}
|
|
}
|
|
|
|
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;
|
|
|
|
skb_copy_to_linear_data(skb, msg, len);
|
|
skb->len += len;
|
|
|
|
skb_push(skb, sizeof(*udph));
|
|
skb_reset_transport_header(skb);
|
|
udph = udp_hdr(skb);
|
|
udph->source = htons(np->local_port);
|
|
udph->dest = htons(np->remote_port);
|
|
udph->len = htons(udp_len);
|
|
udph->check = 0;
|
|
udph->check = csum_tcpudp_magic(htonl(np->local_ip),
|
|
htonl(np->remote_ip),
|
|
udp_len, IPPROTO_UDP,
|
|
csum_partial((unsigned char *)udph, udp_len, 0));
|
|
if (udph->check == 0)
|
|
udph->check = CSUM_MANGLED_0;
|
|
|
|
skb_push(skb, sizeof(*iph));
|
|
skb_reset_network_header(skb);
|
|
iph = ip_hdr(skb);
|
|
|
|
/* 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;
|
|
put_unaligned(htonl(np->local_ip), &(iph->saddr));
|
|
put_unaligned(htonl(np->remote_ip), &(iph->daddr));
|
|
iph->check = ip_fast_csum((unsigned char *)iph, iph->ihl);
|
|
|
|
eth = (struct ethhdr *) skb_push(skb, ETH_HLEN);
|
|
skb_reset_mac_header(skb);
|
|
skb->protocol = eth->h_proto = htons(ETH_P_IP);
|
|
memcpy(eth->h_source, np->local_mac, 6);
|
|
memcpy(eth->h_dest, np->remote_mac, 6);
|
|
|
|
skb->dev = np->dev;
|
|
|
|
netpoll_send_skb(np, skb);
|
|
}
|
|
|
|
static void arp_reply(struct sk_buff *skb)
|
|
{
|
|
struct netpoll_info *npinfo = skb->dev->npinfo;
|
|
struct arphdr *arp;
|
|
unsigned char *arp_ptr;
|
|
int size, type = ARPOP_REPLY, ptype = ETH_P_ARP;
|
|
__be32 sip, tip;
|
|
unsigned char *sha;
|
|
struct sk_buff *send_skb;
|
|
struct netpoll *np = NULL;
|
|
|
|
if (npinfo->rx_np && npinfo->rx_np->dev == skb->dev)
|
|
np = npinfo->rx_np;
|
|
if (!np)
|
|
return;
|
|
|
|
/* No arp on this interface */
|
|
if (skb->dev->flags & IFF_NOARP)
|
|
return;
|
|
|
|
if (!pskb_may_pull(skb, (sizeof(struct arphdr) +
|
|
(2 * skb->dev->addr_len) +
|
|
(2 * sizeof(u32)))))
|
|
return;
|
|
|
|
skb_reset_network_header(skb);
|
|
skb_reset_transport_header(skb);
|
|
arp = arp_hdr(skb);
|
|
|
|
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;
|
|
|
|
arp_ptr = (unsigned char *)(arp+1);
|
|
/* save the location of the src hw addr */
|
|
sha = arp_ptr;
|
|
arp_ptr += skb->dev->addr_len;
|
|
memcpy(&sip, arp_ptr, 4);
|
|
arp_ptr += 4;
|
|
/* if we actually cared about dst hw addr, it would get copied here */
|
|
arp_ptr += skb->dev->addr_len;
|
|
memcpy(&tip, arp_ptr, 4);
|
|
|
|
/* Should we ignore arp? */
|
|
if (tip != htonl(np->local_ip) || LOOPBACK(tip) || MULTICAST(tip))
|
|
return;
|
|
|
|
size = sizeof(struct arphdr) + 2 * (skb->dev->addr_len + 4);
|
|
send_skb = find_skb(np, size + LL_RESERVED_SPACE(np->dev),
|
|
LL_RESERVED_SPACE(np->dev));
|
|
|
|
if (!send_skb)
|
|
return;
|
|
|
|
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);
|
|
|
|
/* Fill the device header for the ARP frame */
|
|
|
|
if (np->dev->hard_header &&
|
|
np->dev->hard_header(send_skb, skb->dev, ptype,
|
|
sha, np->local_mac,
|
|
send_skb->len) < 0) {
|
|
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;
|
|
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);
|
|
}
|
|
|
|
int __netpoll_rx(struct sk_buff *skb)
|
|
{
|
|
int proto, len, ulen;
|
|
struct iphdr *iph;
|
|
struct udphdr *uh;
|
|
struct netpoll_info *npi = skb->dev->npinfo;
|
|
struct netpoll *np = npi->rx_np;
|
|
|
|
if (!np)
|
|
goto out;
|
|
if (skb->dev->type != ARPHRD_ETHER)
|
|
goto out;
|
|
|
|
/* check if netpoll clients need ARP */
|
|
if (skb->protocol == htons(ETH_P_ARP) &&
|
|
atomic_read(&trapped)) {
|
|
skb_queue_tail(&npi->arp_tx, skb);
|
|
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;
|
|
|
|
/*
|
|
* 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;
|
|
|
|
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;
|
|
if (checksum_udp(skb, uh, ulen, iph->saddr, iph->daddr))
|
|
goto out;
|
|
if (np->local_ip && np->local_ip != ntohl(iph->daddr))
|
|
goto out;
|
|
if (np->remote_ip && np->remote_ip != ntohl(iph->saddr))
|
|
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;
|
|
}
|
|
|
|
void netpoll_print_options(struct netpoll *np)
|
|
{
|
|
printk(KERN_INFO "%s: local port %d\n",
|
|
np->name, np->local_port);
|
|
printk(KERN_INFO "%s: local IP %d.%d.%d.%d\n",
|
|
np->name, HIPQUAD(np->local_ip));
|
|
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);
|
|
printk(KERN_INFO "%s: remote IP %d.%d.%d.%d\n",
|
|
np->name, HIPQUAD(np->remote_ip));
|
|
printk(KERN_INFO "%s: remote ethernet address "
|
|
"%02x:%02x:%02x:%02x:%02x:%02x\n",
|
|
np->name,
|
|
np->remote_mac[0],
|
|
np->remote_mac[1],
|
|
np->remote_mac[2],
|
|
np->remote_mac[3],
|
|
np->remote_mac[4],
|
|
np->remote_mac[5]);
|
|
}
|
|
|
|
int netpoll_parse_options(struct netpoll *np, char *opt)
|
|
{
|
|
char *cur=opt, *delim;
|
|
|
|
if (*cur != '@') {
|
|
if ((delim = strchr(cur, '@')) == NULL)
|
|
goto parse_failed;
|
|
*delim = 0;
|
|
np->local_port = simple_strtol(cur, NULL, 10);
|
|
cur = delim;
|
|
}
|
|
cur++;
|
|
|
|
if (*cur != '/') {
|
|
if ((delim = strchr(cur, '/')) == NULL)
|
|
goto parse_failed;
|
|
*delim = 0;
|
|
np->local_ip = ntohl(in_aton(cur));
|
|
cur = delim;
|
|
}
|
|
cur++;
|
|
|
|
if (*cur != ',') {
|
|
/* parse out dev name */
|
|
if ((delim = strchr(cur, ',')) == NULL)
|
|
goto parse_failed;
|
|
*delim = 0;
|
|
strlcpy(np->dev_name, cur, sizeof(np->dev_name));
|
|
cur = delim;
|
|
}
|
|
cur++;
|
|
|
|
if (*cur != '@') {
|
|
/* dst port */
|
|
if ((delim = strchr(cur, '@')) == NULL)
|
|
goto parse_failed;
|
|
*delim = 0;
|
|
np->remote_port = simple_strtol(cur, NULL, 10);
|
|
cur = delim;
|
|
}
|
|
cur++;
|
|
|
|
/* dst ip */
|
|
if ((delim = strchr(cur, '/')) == NULL)
|
|
goto parse_failed;
|
|
*delim = 0;
|
|
np->remote_ip = ntohl(in_aton(cur));
|
|
cur = delim + 1;
|
|
|
|
if (*cur != 0) {
|
|
/* MAC address */
|
|
if ((delim = strchr(cur, ':')) == NULL)
|
|
goto parse_failed;
|
|
*delim = 0;
|
|
np->remote_mac[0] = simple_strtol(cur, NULL, 16);
|
|
cur = delim + 1;
|
|
if ((delim = strchr(cur, ':')) == NULL)
|
|
goto parse_failed;
|
|
*delim = 0;
|
|
np->remote_mac[1] = simple_strtol(cur, NULL, 16);
|
|
cur = delim + 1;
|
|
if ((delim = strchr(cur, ':')) == NULL)
|
|
goto parse_failed;
|
|
*delim = 0;
|
|
np->remote_mac[2] = simple_strtol(cur, NULL, 16);
|
|
cur = delim + 1;
|
|
if ((delim = strchr(cur, ':')) == NULL)
|
|
goto parse_failed;
|
|
*delim = 0;
|
|
np->remote_mac[3] = simple_strtol(cur, NULL, 16);
|
|
cur = delim + 1;
|
|
if ((delim = strchr(cur, ':')) == NULL)
|
|
goto parse_failed;
|
|
*delim = 0;
|
|
np->remote_mac[4] = simple_strtol(cur, NULL, 16);
|
|
cur = delim + 1;
|
|
np->remote_mac[5] = simple_strtol(cur, NULL, 16);
|
|
}
|
|
|
|
netpoll_print_options(np);
|
|
|
|
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;
|
|
struct netpoll_info *npinfo;
|
|
unsigned long flags;
|
|
int err;
|
|
|
|
if (np->dev_name)
|
|
ndev = dev_get_by_name(&init_net, np->dev_name);
|
|
if (!ndev) {
|
|
printk(KERN_ERR "%s: %s doesn't exist, aborting.\n",
|
|
np->name, np->dev_name);
|
|
return -ENODEV;
|
|
}
|
|
|
|
np->dev = ndev;
|
|
if (!ndev->npinfo) {
|
|
npinfo = kmalloc(sizeof(*npinfo), GFP_KERNEL);
|
|
if (!npinfo) {
|
|
err = -ENOMEM;
|
|
goto release;
|
|
}
|
|
|
|
npinfo->rx_flags = 0;
|
|
npinfo->rx_np = NULL;
|
|
|
|
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);
|
|
} else {
|
|
npinfo = ndev->npinfo;
|
|
atomic_inc(&npinfo->refcnt);
|
|
}
|
|
|
|
if (!ndev->poll_controller) {
|
|
printk(KERN_ERR "%s: %s doesn't support polling, aborting.\n",
|
|
np->name, np->dev_name);
|
|
err = -ENOTSUPP;
|
|
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);
|
|
|
|
rtnl_lock();
|
|
err = dev_open(ndev);
|
|
rtnl_unlock();
|
|
|
|
if (err) {
|
|
printk(KERN_ERR "%s: failed to open %s\n",
|
|
np->name, ndev->name);
|
|
goto release;
|
|
}
|
|
|
|
atleast = jiffies + HZ/10;
|
|
atmost = jiffies + 4*HZ;
|
|
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 (is_zero_ether_addr(np->local_mac) && ndev->dev_addr)
|
|
memcpy(np->local_mac, ndev->dev_addr, 6);
|
|
|
|
if (!np->local_ip) {
|
|
rcu_read_lock();
|
|
in_dev = __in_dev_get_rcu(ndev);
|
|
|
|
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);
|
|
err = -EDESTADDRREQ;
|
|
goto release;
|
|
}
|
|
|
|
np->local_ip = ntohl(in_dev->ifa_list->ifa_local);
|
|
rcu_read_unlock();
|
|
printk(KERN_INFO "%s: local IP %d.%d.%d.%d\n",
|
|
np->name, HIPQUAD(np->local_ip));
|
|
}
|
|
|
|
if (np->rx_hook) {
|
|
spin_lock_irqsave(&npinfo->rx_lock, flags);
|
|
npinfo->rx_flags |= NETPOLL_RX_ENABLED;
|
|
npinfo->rx_np = np;
|
|
spin_unlock_irqrestore(&npinfo->rx_lock, flags);
|
|
}
|
|
|
|
/* fill up the skb queue */
|
|
refill_skbs();
|
|
|
|
/* last thing to do is link it to the net device structure */
|
|
ndev->npinfo = npinfo;
|
|
|
|
/* avoid racing with NAPI reading npinfo */
|
|
synchronize_rcu();
|
|
|
|
return 0;
|
|
|
|
release:
|
|
if (!ndev->npinfo)
|
|
kfree(npinfo);
|
|
np->dev = NULL;
|
|
dev_put(ndev);
|
|
return err;
|
|
}
|
|
|
|
static int __init netpoll_init(void)
|
|
{
|
|
skb_queue_head_init(&skb_pool);
|
|
return 0;
|
|
}
|
|
core_initcall(netpoll_init);
|
|
|
|
void netpoll_cleanup(struct netpoll *np)
|
|
{
|
|
struct netpoll_info *npinfo;
|
|
unsigned long flags;
|
|
|
|
if (np->dev) {
|
|
npinfo = np->dev->npinfo;
|
|
if (npinfo) {
|
|
if (npinfo->rx_np == np) {
|
|
spin_lock_irqsave(&npinfo->rx_lock, flags);
|
|
npinfo->rx_np = NULL;
|
|
npinfo->rx_flags &= ~NETPOLL_RX_ENABLED;
|
|
spin_unlock_irqrestore(&npinfo->rx_lock, flags);
|
|
}
|
|
|
|
if (atomic_dec_and_test(&npinfo->refcnt)) {
|
|
skb_queue_purge(&npinfo->arp_tx);
|
|
skb_queue_purge(&npinfo->txq);
|
|
cancel_rearming_delayed_work(&npinfo->tx_work);
|
|
|
|
/* clean after last, unfinished work */
|
|
if (!skb_queue_empty(&npinfo->txq)) {
|
|
struct sk_buff *skb;
|
|
skb = __skb_dequeue(&npinfo->txq);
|
|
kfree_skb(skb);
|
|
}
|
|
kfree(npinfo);
|
|
np->dev->npinfo = NULL;
|
|
}
|
|
}
|
|
|
|
dev_put(np->dev);
|
|
}
|
|
|
|
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);
|
|
EXPORT_SYMBOL(netpoll_print_options);
|
|
EXPORT_SYMBOL(netpoll_parse_options);
|
|
EXPORT_SYMBOL(netpoll_setup);
|
|
EXPORT_SYMBOL(netpoll_cleanup);
|
|
EXPORT_SYMBOL(netpoll_send_udp);
|
|
EXPORT_SYMBOL(netpoll_poll);
|