netpoll.c 18 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * 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/smp_lock.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/string.h>
16
#include <linux/if_arp.h>
Linus Torvalds's avatar
Linus Torvalds committed
17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
#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)

38
static struct sk_buff_head skb_pool;
Linus Torvalds's avatar
Linus Torvalds committed
39 40 41

static atomic_t trapped;

Stephen Hemminger's avatar
Stephen Hemminger committed
42
#define USEC_PER_POLL	50
Linus Torvalds's avatar
Linus Torvalds committed
43 44 45 46 47 48 49 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);
51
static void arp_reply(struct sk_buff *skb);
Linus Torvalds's avatar
Linus Torvalds committed
52 53 54

static void queue_process(void *p)
{
Stephen Hemminger's avatar
Stephen Hemminger committed
55
	struct netpoll_info *npinfo = p;
Linus Torvalds's avatar
Linus Torvalds committed
56 57
	struct sk_buff *skb;

58 59
	while ((skb = skb_dequeue(&npinfo->txq))) {
		struct net_device *dev = skb->dev;
Linus Torvalds's avatar
Linus Torvalds committed
60

61 62 63 64 65 66 67 68 69 70 71 72 73 74
		if (!netif_device_present(dev) || !netif_running(dev)) {
			__kfree_skb(skb);
			continue;
		}

		netif_tx_lock_bh(dev);
		if (netif_queue_stopped(dev) ||
		    dev->hard_start_xmit(skb, dev) != NETDEV_TX_OK) {
			skb_queue_head(&npinfo->txq, skb);
			netif_tx_unlock_bh(dev);

			schedule_delayed_work(&npinfo->tx_work, HZ/10);
			return;
		}
Stephen Hemminger's avatar
Stephen Hemminger committed
75

76 77
		netif_tx_unlock_bh(dev);
	}
Stephen Hemminger's avatar
Stephen Hemminger committed
78
}
Linus Torvalds's avatar
Linus Torvalds committed
79 80

static int checksum_udp(struct sk_buff *skb, struct udphdr *uh,
81
			unsigned short ulen, u32 saddr, u32 daddr)
Linus Torvalds's avatar
Linus Torvalds committed
82
{
83 84 85
	unsigned int psum;

	if (uh->check == 0 || skb->ip_summed == CHECKSUM_UNNECESSARY)
Linus Torvalds's avatar
Linus Torvalds committed
86 87
		return 0;

88 89
	psum = csum_tcpudp_nofold(saddr, daddr, ulen, IPPROTO_UDP, 0);

90
	if (skb->ip_summed == CHECKSUM_COMPLETE &&
91 92
	    !(u16)csum_fold(csum_add(psum, skb->csum)))
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
93

94
	skb->csum = psum;
Linus Torvalds's avatar
Linus Torvalds committed
95

96
	return __skb_checksum_complete(skb);
Linus Torvalds's avatar
Linus Torvalds committed
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116
}

/*
 * 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)
{
117
	struct netpoll_info *npinfo = np->dev->npinfo;
Linus Torvalds's avatar
Linus Torvalds committed
118 119 120
	int budget = 16;

	if (test_bit(__LINK_STATE_RX_SCHED, &np->dev->state) &&
121 122 123
	    npinfo->poll_owner != smp_processor_id() &&
	    spin_trylock(&npinfo->poll_lock)) {
		npinfo->rx_flags |= NETPOLL_RX_DROP;
Linus Torvalds's avatar
Linus Torvalds committed
124 125 126 127 128
		atomic_inc(&trapped);

		np->dev->poll(np->dev, &budget);

		atomic_dec(&trapped);
129 130
		npinfo->rx_flags &= ~NETPOLL_RX_DROP;
		spin_unlock(&npinfo->poll_lock);
Linus Torvalds's avatar
Linus Torvalds committed
131 132 133
	}
}

134 135 136 137 138 139 140 141 142 143 144 145 146 147 148
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);
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
149 150
void netpoll_poll(struct netpoll *np)
{
151
	if (!np->dev || !netif_running(np->dev) || !np->dev->poll_controller)
Linus Torvalds's avatar
Linus Torvalds committed
152 153 154 155 156 157 158
		return;

	/* Process pending work on NIC */
	np->dev->poll_controller(np->dev);
	if (np->dev->poll)
		poll_napi(np);

159 160
	service_arp_queue(np->dev->npinfo);

Linus Torvalds's avatar
Linus Torvalds committed
161 162 163 164 165 166 167 168
	zap_completion_queue();
}

static void refill_skbs(void)
{
	struct sk_buff *skb;
	unsigned long flags;

169 170
	spin_lock_irqsave(&skb_pool.lock, flags);
	while (skb_pool.qlen < MAX_SKBS) {
Linus Torvalds's avatar
Linus Torvalds committed
171 172 173 174
		skb = alloc_skb(MAX_SKB_SIZE, GFP_ATOMIC);
		if (!skb)
			break;

175
		__skb_queue_tail(&skb_pool, skb);
Linus Torvalds's avatar
Linus Torvalds committed
176
	}
177
	spin_unlock_irqrestore(&skb_pool.lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
}

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;
196
			if (skb->destructor)
Linus Torvalds's avatar
Linus Torvalds committed
197 198 199 200 201 202 203 204 205
				dev_kfree_skb_any(skb); /* put this one back */
			else
				__kfree_skb(skb);
		}
	}

	put_cpu_var(softnet_data);
}

206
static struct sk_buff *find_skb(struct netpoll *np, int len, int reserve)
Linus Torvalds's avatar
Linus Torvalds committed
207
{
208 209
	int count = 0;
	struct sk_buff *skb;
Linus Torvalds's avatar
Linus Torvalds committed
210 211

	zap_completion_queue();
212
	refill_skbs();
Linus Torvalds's avatar
Linus Torvalds committed
213 214 215
repeat:

	skb = alloc_skb(len, GFP_ATOMIC);
216 217
	if (!skb)
		skb = skb_dequeue(&skb_pool);
Linus Torvalds's avatar
Linus Torvalds committed
218

219
	if (!skb) {
220 221 222
		if (++count < 10) {
			netpoll_poll(np);
			goto repeat;
Linus Torvalds's avatar
Linus Torvalds committed
223
		}
224
		return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
225 226 227 228 229 230 231 232 233
	}

	atomic_set(&skb->users, 1);
	skb_reserve(skb, reserve);
	return skb;
}

static void netpoll_send_skb(struct netpoll *np, struct sk_buff *skb)
{
Stephen Hemminger's avatar
Stephen Hemminger committed
234 235 236 237 238 239 240 241 242 243 244
	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 */
245 246 247
	if (skb_queue_len(&npinfo->txq) == 0 &&
	    npinfo->poll_owner != smp_processor_id() &&
	    netif_tx_trylock(dev)) {
Stephen Hemminger's avatar
Stephen Hemminger committed
248
		/* try until next clock tick */
249
		for (tries = jiffies_to_usecs(1)/USEC_PER_POLL; tries > 0; --tries) {
Stephen Hemminger's avatar
Stephen Hemminger committed
250 251 252 253 254 255 256 257
			if (!netif_queue_stopped(dev))
				status = dev->hard_start_xmit(skb, dev);

			if (status == NETDEV_TX_OK)
				break;

			/* tickle device maybe there is some cleanup */
			netpoll_poll(np);
Linus Torvalds's avatar
Linus Torvalds committed
258

Stephen Hemminger's avatar
Stephen Hemminger committed
259 260 261
			udelay(USEC_PER_POLL);
		}
		netif_tx_unlock(dev);
Linus Torvalds's avatar
Linus Torvalds committed
262 263
	}

Stephen Hemminger's avatar
Stephen Hemminger committed
264
	if (status != NETDEV_TX_OK) {
Stephen Hemminger's avatar
Stephen Hemminger committed
265 266
		skb_queue_tail(&npinfo->txq, skb);
		schedule_work(&npinfo->tx_work);
Linus Torvalds's avatar
Linus Torvalds committed
267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
	}
}

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;

	memcpy(skb->data, msg, len);
	skb->len += len;

289
	skb->h.uh = udph = (struct udphdr *) skb_push(skb, sizeof(*udph));
Linus Torvalds's avatar
Linus Torvalds committed
290 291 292 293
	udph->source = htons(np->local_port);
	udph->dest = htons(np->remote_port);
	udph->len = htons(udp_len);
	udph->check = 0;
294 295 296 297 298 299
	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 = -1;
Linus Torvalds's avatar
Linus Torvalds committed
300

301
	skb->nh.iph = iph = (struct iphdr *)skb_push(skb, sizeof(*iph));
Linus Torvalds's avatar
Linus Torvalds committed
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316

	/* 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);
317 318
	skb->mac.raw = skb->data;
	skb->protocol = eth->h_proto = htons(ETH_P_IP);
Linus Torvalds's avatar
Linus Torvalds committed
319 320 321 322 323 324 325 326 327 328
	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)
{
329
	struct netpoll_info *npinfo = skb->dev->npinfo;
Linus Torvalds's avatar
Linus Torvalds committed
330 331 332
	struct arphdr *arp;
	unsigned char *arp_ptr;
	int size, type = ARPOP_REPLY, ptype = ETH_P_ARP;
Al Viro's avatar
Al Viro committed
333
	__be32 sip, tip;
Linus Torvalds's avatar
Linus Torvalds committed
334
	struct sk_buff *send_skb;
335
	struct netpoll *np = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
336

337 338
	if (npinfo->rx_np && npinfo->rx_np->dev == skb->dev)
		np = npinfo->rx_np;
339 340
	if (!np)
		return;
Linus Torvalds's avatar
Linus Torvalds committed
341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384

	/* 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->h.raw = skb->nh.raw = skb->data;
	arp = skb->nh.arph;

	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) + skb->dev->addr_len;
	memcpy(&sip, arp_ptr, 4);
	arp_ptr += 4 + 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;

	send_skb->nh.raw = send_skb->data;
	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,
385 386
				 np->remote_mac, np->local_mac,
				 send_skb->len) < 0) {
Linus Torvalds's avatar
Linus Torvalds committed
387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
		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, np->remote_mac, 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;
421 422 423
	struct netpoll_info *npi = skb->dev->npinfo;
	struct netpoll *np = npi->rx_np;

424
	if (!np)
Linus Torvalds's avatar
Linus Torvalds committed
425 426 427 428 429 430 431
		goto out;
	if (skb->dev->type != ARPHRD_ETHER)
		goto out;

	/* check if netpoll clients need ARP */
	if (skb->protocol == __constant_htons(ETH_P_ARP) &&
	    atomic_read(&trapped)) {
432
		skb_queue_tail(&npi->arp_tx, skb);
Linus Torvalds's avatar
Linus Torvalds committed
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466
		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;

	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;
467
	if (checksum_udp(skb, uh, ulen, iph->saddr, iph->daddr))
Linus Torvalds's avatar
Linus Torvalds committed
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
		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;
}

int netpoll_parse_options(struct netpoll *np, char *opt)
{
	char *cur=opt, *delim;

496
	if (*cur != '@') {
Linus Torvalds's avatar
Linus Torvalds committed
497 498
		if ((delim = strchr(cur, '@')) == NULL)
			goto parse_failed;
499 500 501
		*delim = 0;
		np->local_port = simple_strtol(cur, NULL, 10);
		cur = delim;
Linus Torvalds's avatar
Linus Torvalds committed
502 503 504 505
	}
	cur++;
	printk(KERN_INFO "%s: local port %d\n", np->name, np->local_port);

506
	if (*cur != '/') {
Linus Torvalds's avatar
Linus Torvalds committed
507 508
		if ((delim = strchr(cur, '/')) == NULL)
			goto parse_failed;
509 510 511
		*delim = 0;
		np->local_ip = ntohl(in_aton(cur));
		cur = delim;
Linus Torvalds's avatar
Linus Torvalds committed
512 513 514 515 516 517

		printk(KERN_INFO "%s: local IP %d.%d.%d.%d\n",
		       np->name, HIPQUAD(np->local_ip));
	}
	cur++;

518
	if (*cur != ',') {
Linus Torvalds's avatar
Linus Torvalds committed
519 520 521
		/* parse out dev name */
		if ((delim = strchr(cur, ',')) == NULL)
			goto parse_failed;
522
		*delim = 0;
Linus Torvalds's avatar
Linus Torvalds committed
523
		strlcpy(np->dev_name, cur, sizeof(np->dev_name));
524
		cur = delim;
Linus Torvalds's avatar
Linus Torvalds committed
525 526 527 528 529
	}
	cur++;

	printk(KERN_INFO "%s: interface %s\n", np->name, np->dev_name);

530
	if (*cur != '@') {
Linus Torvalds's avatar
Linus Torvalds committed
531 532 533
		/* dst port */
		if ((delim = strchr(cur, '@')) == NULL)
			goto parse_failed;
534 535 536
		*delim = 0;
		np->remote_port = simple_strtol(cur, NULL, 10);
		cur = delim;
Linus Torvalds's avatar
Linus Torvalds committed
537 538 539 540 541 542 543
	}
	cur++;
	printk(KERN_INFO "%s: remote port %d\n", np->name, np->remote_port);

	/* dst ip */
	if ((delim = strchr(cur, '/')) == NULL)
		goto parse_failed;
544 545 546
	*delim = 0;
	np->remote_ip = ntohl(in_aton(cur));
	cur = delim + 1;
Linus Torvalds's avatar
Linus Torvalds committed
547 548

	printk(KERN_INFO "%s: remote IP %d.%d.%d.%d\n",
549
	       np->name, HIPQUAD(np->remote_ip));
Linus Torvalds's avatar
Linus Torvalds committed
550

551
	if (*cur != 0) {
Linus Torvalds's avatar
Linus Torvalds committed
552 553 554
		/* MAC address */
		if ((delim = strchr(cur, ':')) == NULL)
			goto parse_failed;
555 556 557
		*delim = 0;
		np->remote_mac[0] = simple_strtol(cur, NULL, 16);
		cur = delim + 1;
Linus Torvalds's avatar
Linus Torvalds committed
558 559
		if ((delim = strchr(cur, ':')) == NULL)
			goto parse_failed;
560 561 562
		*delim = 0;
		np->remote_mac[1] = simple_strtol(cur, NULL, 16);
		cur = delim + 1;
Linus Torvalds's avatar
Linus Torvalds committed
563 564
		if ((delim = strchr(cur, ':')) == NULL)
			goto parse_failed;
565 566 567
		*delim = 0;
		np->remote_mac[2] = simple_strtol(cur, NULL, 16);
		cur = delim + 1;
Linus Torvalds's avatar
Linus Torvalds committed
568 569
		if ((delim = strchr(cur, ':')) == NULL)
			goto parse_failed;
570 571 572
		*delim = 0;
		np->remote_mac[3] = simple_strtol(cur, NULL, 16);
		cur = delim + 1;
Linus Torvalds's avatar
Linus Torvalds committed
573 574
		if ((delim = strchr(cur, ':')) == NULL)
			goto parse_failed;
575 576 577 578
		*delim = 0;
		np->remote_mac[4] = simple_strtol(cur, NULL, 16);
		cur = delim + 1;
		np->remote_mac[5] = simple_strtol(cur, NULL, 16);
Linus Torvalds's avatar
Linus Torvalds committed
579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602
	}

	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]);

	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;
603
	struct netpoll_info *npinfo;
604
	unsigned long flags;
605
	int err;
Linus Torvalds's avatar
Linus Torvalds committed
606 607 608 609 610 611

	if (np->dev_name)
		ndev = dev_get_by_name(np->dev_name);
	if (!ndev) {
		printk(KERN_ERR "%s: %s doesn't exist, aborting.\n",
		       np->name, np->dev_name);
612
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
613 614 615
	}

	np->dev = ndev;
616 617
	if (!ndev->npinfo) {
		npinfo = kmalloc(sizeof(*npinfo), GFP_KERNEL);
618 619
		if (!npinfo) {
			err = -ENOMEM;
620
			goto release;
621
		}
622

Jeff Moyer's avatar
Jeff Moyer committed
623
		npinfo->rx_flags = 0;
624
		npinfo->rx_np = NULL;
625
		spin_lock_init(&npinfo->poll_lock);
626
		npinfo->poll_owner = -1;
Stephen Hemminger's avatar
Stephen Hemminger committed
627

628
		spin_lock_init(&npinfo->rx_lock);
629
		skb_queue_head_init(&npinfo->arp_tx);
Stephen Hemminger's avatar
Stephen Hemminger committed
630 631 632
		skb_queue_head_init(&npinfo->txq);
		INIT_WORK(&npinfo->tx_work, queue_process, npinfo);

Stephen Hemminger's avatar
Stephen Hemminger committed
633 634
		atomic_set(&npinfo->refcnt, 1);
	} else {
635
		npinfo = ndev->npinfo;
Stephen Hemminger's avatar
Stephen Hemminger committed
636 637
		atomic_inc(&npinfo->refcnt);
	}
Linus Torvalds's avatar
Linus Torvalds committed
638 639 640 641

	if (!ndev->poll_controller) {
		printk(KERN_ERR "%s: %s doesn't support polling, aborting.\n",
		       np->name, np->dev_name);
642
		err = -ENOTSUPP;
Linus Torvalds's avatar
Linus Torvalds committed
643 644 645 646 647 648 649 650 651
		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);

652
		rtnl_lock();
653 654 655 656
		err = dev_open(ndev);
		rtnl_unlock();

		if (err) {
Linus Torvalds's avatar
Linus Torvalds committed
657
			printk(KERN_ERR "%s: failed to open %s\n",
658
			       np->name, ndev->name);
Linus Torvalds's avatar
Linus Torvalds committed
659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686
			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);
		}
	}

687
	if (is_zero_ether_addr(np->local_mac) && ndev->dev_addr)
Linus Torvalds's avatar
Linus Torvalds committed
688 689 690 691
		memcpy(np->local_mac, ndev->dev_addr, 6);

	if (!np->local_ip) {
		rcu_read_lock();
692
		in_dev = __in_dev_get_rcu(ndev);
Linus Torvalds's avatar
Linus Torvalds committed
693 694 695 696 697

		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);
698
			err = -EDESTADDRREQ;
Linus Torvalds's avatar
Linus Torvalds committed
699 700 701 702 703 704 705 706 707
			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));
	}

708 709 710 711 712 713
	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);
	}
Ingo Molnar's avatar
Ingo Molnar committed
714 715 716 717

	/* fill up the skb queue */
	refill_skbs();

718
	/* last thing to do is link it to the net device structure */
719
	ndev->npinfo = npinfo;
Linus Torvalds's avatar
Linus Torvalds committed
720

721 722 723
	/* avoid racing with NAPI reading npinfo */
	synchronize_rcu();

Linus Torvalds's avatar
Linus Torvalds committed
724 725 726
	return 0;

 release:
727 728
	if (!ndev->npinfo)
		kfree(npinfo);
Linus Torvalds's avatar
Linus Torvalds committed
729 730
	np->dev = NULL;
	dev_put(ndev);
731
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
732 733
}

734 735
static int __init netpoll_init(void)
{
736 737 738 739 740
	skb_queue_head_init(&skb_pool);
	return 0;
}
core_initcall(netpoll_init);

Linus Torvalds's avatar
Linus Torvalds committed
741 742
void netpoll_cleanup(struct netpoll *np)
{
743 744 745
	struct netpoll_info *npinfo;
	unsigned long flags;

746
	if (np->dev) {
747
		npinfo = np->dev->npinfo;
Stephen Hemminger's avatar
Stephen Hemminger committed
748 749 750 751 752 753 754 755 756 757 758
		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);
			}

			np->dev->npinfo = NULL;
			if (atomic_dec_and_test(&npinfo->refcnt)) {
				skb_queue_purge(&npinfo->arp_tx);
Stephen Hemminger's avatar
Stephen Hemminger committed
759
 				skb_queue_purge(&npinfo->txq);
760
				cancel_rearming_delayed_work(&npinfo->tx_work);
Stephen Hemminger's avatar
Stephen Hemminger committed
761
 				flush_scheduled_work();
Stephen Hemminger's avatar
Stephen Hemminger committed
762 763 764

				kfree(npinfo);
			}
765
		}
Stephen Hemminger's avatar
Stephen Hemminger committed
766

767 768
		dev_put(np->dev);
	}
769

Linus Torvalds's avatar
Linus Torvalds committed
770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792
	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_parse_options);
EXPORT_SYMBOL(netpoll_setup);
EXPORT_SYMBOL(netpoll_cleanup);
EXPORT_SYMBOL(netpoll_send_udp);
EXPORT_SYMBOL(netpoll_poll);