8fb134da0346ef02629f03e690afa8bda4fda0f1
[linux-2.6.git] / net / core / netpoll.c
1 /*
2  * Common framework for low-level network console, dump, and debugger code
3  *
4  * Sep 8 2003  Matt Mackall <mpm@selenic.com>
5  *
6  * based on the netconsole code from:
7  *
8  * Copyright (C) 2001  Ingo Molnar <mingo@redhat.com>
9  * Copyright (C) 2002  Red Hat, Inc.
10  */
11
12 #include <linux/netdevice.h>
13 #include <linux/etherdevice.h>
14 #include <linux/string.h>
15 #include <linux/if_arp.h>
16 #include <linux/inetdevice.h>
17 #include <linux/inet.h>
18 #include <linux/interrupt.h>
19 #include <linux/netpoll.h>
20 #include <linux/sched.h>
21 #include <linux/delay.h>
22 #include <linux/rcupdate.h>
23 #include <linux/workqueue.h>
24 #include <net/tcp.h>
25 #include <net/udp.h>
26 #include <asm/unaligned.h>
27
28 /*
29  * We maintain a small pool of fully-sized skbs, to make sure the
30  * message gets out even in extreme OOM situations.
31  */
32
33 #define MAX_UDP_CHUNK 1460
34 #define MAX_SKBS 32
35 #define MAX_QUEUE_DEPTH (MAX_SKBS / 2)
36
37 static struct sk_buff_head skb_pool;
38
39 static atomic_t trapped;
40
41 #define USEC_PER_POLL   50
42 #define NETPOLL_RX_ENABLED  1
43 #define NETPOLL_RX_DROP     2
44
45 #define MAX_SKB_SIZE \
46                 (MAX_UDP_CHUNK + sizeof(struct udphdr) + \
47                                 sizeof(struct iphdr) + sizeof(struct ethhdr))
48
49 static void zap_completion_queue(void);
50 static void arp_reply(struct sk_buff *skb);
51
52 static void queue_process(struct work_struct *work)
53 {
54         struct netpoll_info *npinfo =
55                 container_of(work, struct netpoll_info, tx_work.work);
56         struct sk_buff *skb;
57         unsigned long flags;
58
59         while ((skb = skb_dequeue(&npinfo->txq))) {
60                 struct net_device *dev = skb->dev;
61
62                 if (!netif_device_present(dev) || !netif_running(dev)) {
63                         __kfree_skb(skb);
64                         continue;
65                 }
66
67                 local_irq_save(flags);
68                 netif_tx_lock(dev);
69                 if ((netif_queue_stopped(dev) ||
70                      netif_subqueue_stopped(dev, skb)) ||
71                      dev->hard_start_xmit(skb, dev) != NETDEV_TX_OK) {
72                         skb_queue_head(&npinfo->txq, skb);
73                         netif_tx_unlock(dev);
74                         local_irq_restore(flags);
75
76                         schedule_delayed_work(&npinfo->tx_work, HZ/10);
77                         return;
78                 }
79                 netif_tx_unlock(dev);
80                 local_irq_restore(flags);
81         }
82 }
83
84 static __sum16 checksum_udp(struct sk_buff *skb, struct udphdr *uh,
85                             unsigned short ulen, __be32 saddr, __be32 daddr)
86 {
87         __wsum psum;
88
89         if (uh->check == 0 || skb_csum_unnecessary(skb))
90                 return 0;
91
92         psum = csum_tcpudp_nofold(saddr, daddr, ulen, IPPROTO_UDP, 0);
93
94         if (skb->ip_summed == CHECKSUM_COMPLETE &&
95             !csum_fold(csum_add(psum, skb->csum)))
96                 return 0;
97
98         skb->csum = psum;
99
100         return __skb_checksum_complete(skb);
101 }
102
103 /*
104  * Check whether delayed processing was scheduled for our NIC. If so,
105  * we attempt to grab the poll lock and use ->poll() to pump the card.
106  * If this fails, either we've recursed in ->poll() or it's already
107  * running on another CPU.
108  *
109  * Note: we don't mask interrupts with this lock because we're using
110  * trylock here and interrupts are already disabled in the softirq
111  * case. Further, we test the poll_owner to avoid recursion on UP
112  * systems where the lock doesn't exist.
113  *
114  * In cases where there is bi-directional communications, reading only
115  * one message at a time can lead to packets being dropped by the
116  * network adapter, forcing superfluous retries and possibly timeouts.
117  * Thus, we set our budget to greater than 1.
118  */
119 static int poll_one_napi(struct netpoll_info *npinfo,
120                          struct napi_struct *napi, int budget)
121 {
122         int work;
123
124         /* net_rx_action's ->poll() invocations and our's are
125          * synchronized by this test which is only made while
126          * holding the napi->poll_lock.
127          */
128         if (!test_bit(NAPI_STATE_SCHED, &napi->state))
129                 return budget;
130
131         npinfo->rx_flags |= NETPOLL_RX_DROP;
132         atomic_inc(&trapped);
133
134         work = napi->poll(napi, budget);
135
136         atomic_dec(&trapped);
137         npinfo->rx_flags &= ~NETPOLL_RX_DROP;
138
139         return budget - work;
140 }
141
142 static void poll_napi(struct net_device *dev)
143 {
144         struct napi_struct *napi;
145         int budget = 16;
146
147         list_for_each_entry(napi, &dev->napi_list, dev_list) {
148                 if (napi->poll_owner != smp_processor_id() &&
149                     spin_trylock(&napi->poll_lock)) {
150                         budget = poll_one_napi(dev->npinfo, napi, budget);
151                         spin_unlock(&napi->poll_lock);
152
153                         if (!budget)
154                                 break;
155                 }
156         }
157 }
158
159 static void service_arp_queue(struct netpoll_info *npi)
160 {
161         if (npi) {
162                 struct sk_buff *skb;
163
164                 while ((skb = skb_dequeue(&npi->arp_tx)))
165                         arp_reply(skb);
166         }
167 }
168
169 void netpoll_poll(struct netpoll *np)
170 {
171         struct net_device *dev = np->dev;
172
173         if (!dev || !netif_running(dev) || !dev->poll_controller)
174                 return;
175
176         /* Process pending work on NIC */
177         dev->poll_controller(dev);
178
179         poll_napi(dev);
180
181         service_arp_queue(dev->npinfo);
182
183         zap_completion_queue();
184 }
185
186 static void refill_skbs(void)
187 {
188         struct sk_buff *skb;
189         unsigned long flags;
190
191         spin_lock_irqsave(&skb_pool.lock, flags);
192         while (skb_pool.qlen < MAX_SKBS) {
193                 skb = alloc_skb(MAX_SKB_SIZE, GFP_ATOMIC);
194                 if (!skb)
195                         break;
196
197                 __skb_queue_tail(&skb_pool, skb);
198         }
199         spin_unlock_irqrestore(&skb_pool.lock, flags);
200 }
201
202 static void zap_completion_queue(void)
203 {
204         unsigned long flags;
205         struct softnet_data *sd = &get_cpu_var(softnet_data);
206
207         if (sd->completion_queue) {
208                 struct sk_buff *clist;
209
210                 local_irq_save(flags);
211                 clist = sd->completion_queue;
212                 sd->completion_queue = NULL;
213                 local_irq_restore(flags);
214
215                 while (clist != NULL) {
216                         struct sk_buff *skb = clist;
217                         clist = clist->next;
218                         if (skb->destructor) {
219                                 atomic_inc(&skb->users);
220                                 dev_kfree_skb_any(skb); /* put this one back */
221                         } else {
222                                 __kfree_skb(skb);
223                         }
224                 }
225         }
226
227         put_cpu_var(softnet_data);
228 }
229
230 static struct sk_buff *find_skb(struct netpoll *np, int len, int reserve)
231 {
232         int count = 0;
233         struct sk_buff *skb;
234
235         zap_completion_queue();
236         refill_skbs();
237 repeat:
238
239         skb = alloc_skb(len, GFP_ATOMIC);
240         if (!skb)
241                 skb = skb_dequeue(&skb_pool);
242
243         if (!skb) {
244                 if (++count < 10) {
245                         netpoll_poll(np);
246                         goto repeat;
247                 }
248                 return NULL;
249         }
250
251         atomic_set(&skb->users, 1);
252         skb_reserve(skb, reserve);
253         return skb;
254 }
255
256 static int netpoll_owner_active(struct net_device *dev)
257 {
258         struct napi_struct *napi;
259
260         list_for_each_entry(napi, &dev->napi_list, dev_list) {
261                 if (napi->poll_owner == smp_processor_id())
262                         return 1;
263         }
264         return 0;
265 }
266
267 static void netpoll_send_skb(struct netpoll *np, struct sk_buff *skb)
268 {
269         int status = NETDEV_TX_BUSY;
270         unsigned long tries;
271         struct net_device *dev = np->dev;
272         struct netpoll_info *npinfo = np->dev->npinfo;
273
274         if (!npinfo || !netif_running(dev) || !netif_device_present(dev)) {
275                 __kfree_skb(skb);
276                 return;
277         }
278
279         /* don't get messages out of order, and no recursion */
280         if (skb_queue_len(&npinfo->txq) == 0 && !netpoll_owner_active(dev)) {
281                 unsigned long flags;
282
283                 local_irq_save(flags);
284                 /* try until next clock tick */
285                 for (tries = jiffies_to_usecs(1)/USEC_PER_POLL;
286                      tries > 0; --tries) {
287                         if (netif_tx_trylock(dev)) {
288                                 if (!netif_queue_stopped(dev) &&
289                                     !netif_subqueue_stopped(dev, skb))
290                                         status = dev->hard_start_xmit(skb, dev);
291                                 netif_tx_unlock(dev);
292
293                                 if (status == NETDEV_TX_OK)
294                                         break;
295
296                         }
297
298                         /* tickle device maybe there is some cleanup */
299                         netpoll_poll(np);
300
301                         udelay(USEC_PER_POLL);
302                 }
303                 local_irq_restore(flags);
304         }
305
306         if (status != NETDEV_TX_OK) {
307                 skb_queue_tail(&npinfo->txq, skb);
308                 schedule_delayed_work(&npinfo->tx_work,0);
309         }
310 }
311
312 void netpoll_send_udp(struct netpoll *np, const char *msg, int len)
313 {
314         int total_len, eth_len, ip_len, udp_len;
315         struct sk_buff *skb;
316         struct udphdr *udph;
317         struct iphdr *iph;
318         struct ethhdr *eth;
319
320         udp_len = len + sizeof(*udph);
321         ip_len = eth_len = udp_len + sizeof(*iph);
322         total_len = eth_len + ETH_HLEN + NET_IP_ALIGN;
323
324         skb = find_skb(np, total_len, total_len - len);
325         if (!skb)
326                 return;
327
328         skb_copy_to_linear_data(skb, msg, len);
329         skb->len += len;
330
331         skb_push(skb, sizeof(*udph));
332         skb_reset_transport_header(skb);
333         udph = udp_hdr(skb);
334         udph->source = htons(np->local_port);
335         udph->dest = htons(np->remote_port);
336         udph->len = htons(udp_len);
337         udph->check = 0;
338         udph->check = csum_tcpudp_magic(htonl(np->local_ip),
339                                         htonl(np->remote_ip),
340                                         udp_len, IPPROTO_UDP,
341                                         csum_partial((unsigned char *)udph, udp_len, 0));
342         if (udph->check == 0)
343                 udph->check = CSUM_MANGLED_0;
344
345         skb_push(skb, sizeof(*iph));
346         skb_reset_network_header(skb);
347         iph = ip_hdr(skb);
348
349         /* iph->version = 4; iph->ihl = 5; */
350         put_unaligned(0x45, (unsigned char *)iph);
351         iph->tos      = 0;
352         put_unaligned(htons(ip_len), &(iph->tot_len));
353         iph->id       = 0;
354         iph->frag_off = 0;
355         iph->ttl      = 64;
356         iph->protocol = IPPROTO_UDP;
357         iph->check    = 0;
358         put_unaligned(htonl(np->local_ip), &(iph->saddr));
359         put_unaligned(htonl(np->remote_ip), &(iph->daddr));
360         iph->check    = ip_fast_csum((unsigned char *)iph, iph->ihl);
361
362         eth = (struct ethhdr *) skb_push(skb, ETH_HLEN);
363         skb_reset_mac_header(skb);
364         skb->protocol = eth->h_proto = htons(ETH_P_IP);
365         memcpy(eth->h_source, np->dev->dev_addr, ETH_ALEN);
366         memcpy(eth->h_dest, np->remote_mac, ETH_ALEN);
367
368         skb->dev = np->dev;
369
370         netpoll_send_skb(np, skb);
371 }
372
373 static void arp_reply(struct sk_buff *skb)
374 {
375         struct netpoll_info *npinfo = skb->dev->npinfo;
376         struct arphdr *arp;
377         unsigned char *arp_ptr;
378         int size, type = ARPOP_REPLY, ptype = ETH_P_ARP;
379         __be32 sip, tip;
380         unsigned char *sha;
381         struct sk_buff *send_skb;
382         struct netpoll *np = NULL;
383
384         if (npinfo->rx_np && npinfo->rx_np->dev == skb->dev)
385                 np = npinfo->rx_np;
386         if (!np)
387                 return;
388
389         /* No arp on this interface */
390         if (skb->dev->flags & IFF_NOARP)
391                 return;
392
393         if (!pskb_may_pull(skb, arp_hdr_len(skb->dev)))
394                 return;
395
396         skb_reset_network_header(skb);
397         skb_reset_transport_header(skb);
398         arp = arp_hdr(skb);
399
400         if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
401              arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
402             arp->ar_pro != htons(ETH_P_IP) ||
403             arp->ar_op != htons(ARPOP_REQUEST))
404                 return;
405
406         arp_ptr = (unsigned char *)(arp+1);
407         /* save the location of the src hw addr */
408         sha = arp_ptr;
409         arp_ptr += skb->dev->addr_len;
410         memcpy(&sip, arp_ptr, 4);
411         arp_ptr += 4;
412         /* if we actually cared about dst hw addr, it would get copied here */
413         arp_ptr += skb->dev->addr_len;
414         memcpy(&tip, arp_ptr, 4);
415
416         /* Should we ignore arp? */
417         if (tip != htonl(np->local_ip) ||
418             ipv4_is_loopback(tip) || ipv4_is_multicast(tip))
419                 return;
420
421         size = arp_hdr_len(skb->dev);
422         send_skb = find_skb(np, size + LL_ALLOCATED_SPACE(np->dev),
423                             LL_RESERVED_SPACE(np->dev));
424
425         if (!send_skb)
426                 return;
427
428         skb_reset_network_header(send_skb);
429         arp = (struct arphdr *) skb_put(send_skb, size);
430         send_skb->dev = skb->dev;
431         send_skb->protocol = htons(ETH_P_ARP);
432
433         /* Fill the device header for the ARP frame */
434         if (dev_hard_header(send_skb, skb->dev, ptype,
435                             sha, np->dev->dev_addr,
436                             send_skb->len) < 0) {
437                 kfree_skb(send_skb);
438                 return;
439         }
440
441         /*
442          * Fill out the arp protocol part.
443          *
444          * we only support ethernet device type,
445          * which (according to RFC 1390) should always equal 1 (Ethernet).
446          */
447
448         arp->ar_hrd = htons(np->dev->type);
449         arp->ar_pro = htons(ETH_P_IP);
450         arp->ar_hln = np->dev->addr_len;
451         arp->ar_pln = 4;
452         arp->ar_op = htons(type);
453
454         arp_ptr=(unsigned char *)(arp + 1);
455         memcpy(arp_ptr, np->dev->dev_addr, np->dev->addr_len);
456         arp_ptr += np->dev->addr_len;
457         memcpy(arp_ptr, &tip, 4);
458         arp_ptr += 4;
459         memcpy(arp_ptr, sha, np->dev->addr_len);
460         arp_ptr += np->dev->addr_len;
461         memcpy(arp_ptr, &sip, 4);
462
463         netpoll_send_skb(np, send_skb);
464 }
465
466 int __netpoll_rx(struct sk_buff *skb)
467 {
468         int proto, len, ulen;
469         struct iphdr *iph;
470         struct udphdr *uh;
471         struct netpoll_info *npi = skb->dev->npinfo;
472         struct netpoll *np = npi->rx_np;
473
474         if (!np)
475                 goto out;
476         if (skb->dev->type != ARPHRD_ETHER)
477                 goto out;
478
479         /* check if netpoll clients need ARP */
480         if (skb->protocol == htons(ETH_P_ARP) &&
481             atomic_read(&trapped)) {
482                 skb_queue_tail(&npi->arp_tx, skb);
483                 return 1;
484         }
485
486         proto = ntohs(eth_hdr(skb)->h_proto);
487         if (proto != ETH_P_IP)
488                 goto out;
489         if (skb->pkt_type == PACKET_OTHERHOST)
490                 goto out;
491         if (skb_shared(skb))
492                 goto out;
493
494         iph = (struct iphdr *)skb->data;
495         if (!pskb_may_pull(skb, sizeof(struct iphdr)))
496                 goto out;
497         if (iph->ihl < 5 || iph->version != 4)
498                 goto out;
499         if (!pskb_may_pull(skb, iph->ihl*4))
500                 goto out;
501         if (ip_fast_csum((u8 *)iph, iph->ihl) != 0)
502                 goto out;
503
504         len = ntohs(iph->tot_len);
505         if (skb->len < len || len < iph->ihl*4)
506                 goto out;
507
508         /*
509          * Our transport medium may have padded the buffer out.
510          * Now We trim to the true length of the frame.
511          */
512         if (pskb_trim_rcsum(skb, len))
513                 goto out;
514
515         if (iph->protocol != IPPROTO_UDP)
516                 goto out;
517
518         len -= iph->ihl*4;
519         uh = (struct udphdr *)(((char *)iph) + iph->ihl*4);
520         ulen = ntohs(uh->len);
521
522         if (ulen != len)
523                 goto out;
524         if (checksum_udp(skb, uh, ulen, iph->saddr, iph->daddr))
525                 goto out;
526         if (np->local_ip && np->local_ip != ntohl(iph->daddr))
527                 goto out;
528         if (np->remote_ip && np->remote_ip != ntohl(iph->saddr))
529                 goto out;
530         if (np->local_port && np->local_port != ntohs(uh->dest))
531                 goto out;
532
533         np->rx_hook(np, ntohs(uh->source),
534                     (char *)(uh+1),
535                     ulen - sizeof(struct udphdr));
536
537         kfree_skb(skb);
538         return 1;
539
540 out:
541         if (atomic_read(&trapped)) {
542                 kfree_skb(skb);
543                 return 1;
544         }
545
546         return 0;
547 }
548
549 void netpoll_print_options(struct netpoll *np)
550 {
551         DECLARE_MAC_BUF(mac);
552         printk(KERN_INFO "%s: local port %d\n",
553                          np->name, np->local_port);
554         printk(KERN_INFO "%s: local IP %d.%d.%d.%d\n",
555                          np->name, HIPQUAD(np->local_ip));
556         printk(KERN_INFO "%s: interface %s\n",
557                          np->name, np->dev_name);
558         printk(KERN_INFO "%s: remote port %d\n",
559                          np->name, np->remote_port);
560         printk(KERN_INFO "%s: remote IP %d.%d.%d.%d\n",
561                          np->name, HIPQUAD(np->remote_ip));
562         printk(KERN_INFO "%s: remote ethernet address %s\n",
563                          np->name, print_mac(mac, np->remote_mac));
564 }
565
566 int netpoll_parse_options(struct netpoll *np, char *opt)
567 {
568         char *cur=opt, *delim;
569
570         if (*cur != '@') {
571                 if ((delim = strchr(cur, '@')) == NULL)
572                         goto parse_failed;
573                 *delim = 0;
574                 np->local_port = simple_strtol(cur, NULL, 10);
575                 cur = delim;
576         }
577         cur++;
578
579         if (*cur != '/') {
580                 if ((delim = strchr(cur, '/')) == NULL)
581                         goto parse_failed;
582                 *delim = 0;
583                 np->local_ip = ntohl(in_aton(cur));
584                 cur = delim;
585         }
586         cur++;
587
588         if (*cur != ',') {
589                 /* parse out dev name */
590                 if ((delim = strchr(cur, ',')) == NULL)
591                         goto parse_failed;
592                 *delim = 0;
593                 strlcpy(np->dev_name, cur, sizeof(np->dev_name));
594                 cur = delim;
595         }
596         cur++;
597
598         if (*cur != '@') {
599                 /* dst port */
600                 if ((delim = strchr(cur, '@')) == NULL)
601                         goto parse_failed;
602                 *delim = 0;
603                 np->remote_port = simple_strtol(cur, NULL, 10);
604                 cur = delim;
605         }
606         cur++;
607
608         /* dst ip */
609         if ((delim = strchr(cur, '/')) == NULL)
610                 goto parse_failed;
611         *delim = 0;
612         np->remote_ip = ntohl(in_aton(cur));
613         cur = delim + 1;
614
615         if (*cur != 0) {
616                 /* MAC address */
617                 if ((delim = strchr(cur, ':')) == NULL)
618                         goto parse_failed;
619                 *delim = 0;
620                 np->remote_mac[0] = simple_strtol(cur, NULL, 16);
621                 cur = delim + 1;
622                 if ((delim = strchr(cur, ':')) == NULL)
623                         goto parse_failed;
624                 *delim = 0;
625                 np->remote_mac[1] = simple_strtol(cur, NULL, 16);
626                 cur = delim + 1;
627                 if ((delim = strchr(cur, ':')) == NULL)
628                         goto parse_failed;
629                 *delim = 0;
630                 np->remote_mac[2] = simple_strtol(cur, NULL, 16);
631                 cur = delim + 1;
632                 if ((delim = strchr(cur, ':')) == NULL)
633                         goto parse_failed;
634                 *delim = 0;
635                 np->remote_mac[3] = simple_strtol(cur, NULL, 16);
636                 cur = delim + 1;
637                 if ((delim = strchr(cur, ':')) == NULL)
638                         goto parse_failed;
639                 *delim = 0;
640                 np->remote_mac[4] = simple_strtol(cur, NULL, 16);
641                 cur = delim + 1;
642                 np->remote_mac[5] = simple_strtol(cur, NULL, 16);
643         }
644
645         netpoll_print_options(np);
646
647         return 0;
648
649  parse_failed:
650         printk(KERN_INFO "%s: couldn't parse config at %s!\n",
651                np->name, cur);
652         return -1;
653 }
654
655 int netpoll_setup(struct netpoll *np)
656 {
657         struct net_device *ndev = NULL;
658         struct in_device *in_dev;
659         struct netpoll_info *npinfo;
660         unsigned long flags;
661         int err;
662
663         if (np->dev_name)
664                 ndev = dev_get_by_name(&init_net, np->dev_name);
665         if (!ndev) {
666                 printk(KERN_ERR "%s: %s doesn't exist, aborting.\n",
667                        np->name, np->dev_name);
668                 return -ENODEV;
669         }
670
671         np->dev = ndev;
672         if (!ndev->npinfo) {
673                 npinfo = kmalloc(sizeof(*npinfo), GFP_KERNEL);
674                 if (!npinfo) {
675                         err = -ENOMEM;
676                         goto release;
677                 }
678
679                 npinfo->rx_flags = 0;
680                 npinfo->rx_np = NULL;
681
682                 spin_lock_init(&npinfo->rx_lock);
683                 skb_queue_head_init(&npinfo->arp_tx);
684                 skb_queue_head_init(&npinfo->txq);
685                 INIT_DELAYED_WORK(&npinfo->tx_work, queue_process);
686
687                 atomic_set(&npinfo->refcnt, 1);
688         } else {
689                 npinfo = ndev->npinfo;
690                 atomic_inc(&npinfo->refcnt);
691         }
692
693         if (!ndev->poll_controller) {
694                 printk(KERN_ERR "%s: %s doesn't support polling, aborting.\n",
695                        np->name, np->dev_name);
696                 err = -ENOTSUPP;
697                 goto release;
698         }
699
700         if (!netif_running(ndev)) {
701                 unsigned long atmost, atleast;
702
703                 printk(KERN_INFO "%s: device %s not up yet, forcing it\n",
704                        np->name, np->dev_name);
705
706                 rtnl_lock();
707                 err = dev_open(ndev);
708                 rtnl_unlock();
709
710                 if (err) {
711                         printk(KERN_ERR "%s: failed to open %s\n",
712                                np->name, ndev->name);
713                         goto release;
714                 }
715
716                 atleast = jiffies + HZ/10;
717                 atmost = jiffies + 4*HZ;
718                 while (!netif_carrier_ok(ndev)) {
719                         if (time_after(jiffies, atmost)) {
720                                 printk(KERN_NOTICE
721                                        "%s: timeout waiting for carrier\n",
722                                        np->name);
723                                 break;
724                         }
725                         cond_resched();
726                 }
727
728                 /* If carrier appears to come up instantly, we don't
729                  * trust it and pause so that we don't pump all our
730                  * queued console messages into the bitbucket.
731                  */
732
733                 if (time_before(jiffies, atleast)) {
734                         printk(KERN_NOTICE "%s: carrier detect appears"
735                                " untrustworthy, waiting 4 seconds\n",
736                                np->name);
737                         msleep(4000);
738                 }
739         }
740
741         if (!np->local_ip) {
742                 rcu_read_lock();
743                 in_dev = __in_dev_get_rcu(ndev);
744
745                 if (!in_dev || !in_dev->ifa_list) {
746                         rcu_read_unlock();
747                         printk(KERN_ERR "%s: no IP address for %s, aborting\n",
748                                np->name, np->dev_name);
749                         err = -EDESTADDRREQ;
750                         goto release;
751                 }
752
753                 np->local_ip = ntohl(in_dev->ifa_list->ifa_local);
754                 rcu_read_unlock();
755                 printk(KERN_INFO "%s: local IP %d.%d.%d.%d\n",
756                        np->name, HIPQUAD(np->local_ip));
757         }
758
759         if (np->rx_hook) {
760                 spin_lock_irqsave(&npinfo->rx_lock, flags);
761                 npinfo->rx_flags |= NETPOLL_RX_ENABLED;
762                 npinfo->rx_np = np;
763                 spin_unlock_irqrestore(&npinfo->rx_lock, flags);
764         }
765
766         /* fill up the skb queue */
767         refill_skbs();
768
769         /* last thing to do is link it to the net device structure */
770         ndev->npinfo = npinfo;
771
772         /* avoid racing with NAPI reading npinfo */
773         synchronize_rcu();
774
775         return 0;
776
777  release:
778         if (!ndev->npinfo)
779                 kfree(npinfo);
780         np->dev = NULL;
781         dev_put(ndev);
782         return err;
783 }
784
785 static int __init netpoll_init(void)
786 {
787         skb_queue_head_init(&skb_pool);
788         return 0;
789 }
790 core_initcall(netpoll_init);
791
792 void netpoll_cleanup(struct netpoll *np)
793 {
794         struct netpoll_info *npinfo;
795         unsigned long flags;
796
797         if (np->dev) {
798                 npinfo = np->dev->npinfo;
799                 if (npinfo) {
800                         if (npinfo->rx_np == np) {
801                                 spin_lock_irqsave(&npinfo->rx_lock, flags);
802                                 npinfo->rx_np = NULL;
803                                 npinfo->rx_flags &= ~NETPOLL_RX_ENABLED;
804                                 spin_unlock_irqrestore(&npinfo->rx_lock, flags);
805                         }
806
807                         if (atomic_dec_and_test(&npinfo->refcnt)) {
808                                 skb_queue_purge(&npinfo->arp_tx);
809                                 skb_queue_purge(&npinfo->txq);
810                                 cancel_rearming_delayed_work(&npinfo->tx_work);
811
812                                 /* clean after last, unfinished work */
813                                 __skb_queue_purge(&npinfo->txq);
814                                 kfree(npinfo);
815                                 np->dev->npinfo = NULL;
816                         }
817                 }
818
819                 dev_put(np->dev);
820         }
821
822         np->dev = NULL;
823 }
824
825 int netpoll_trap(void)
826 {
827         return atomic_read(&trapped);
828 }
829
830 void netpoll_set_trap(int trap)
831 {
832         if (trap)
833                 atomic_inc(&trapped);
834         else
835                 atomic_dec(&trapped);
836 }
837
838 EXPORT_SYMBOL(netpoll_set_trap);
839 EXPORT_SYMBOL(netpoll_trap);
840 EXPORT_SYMBOL(netpoll_print_options);
841 EXPORT_SYMBOL(netpoll_parse_options);
842 EXPORT_SYMBOL(netpoll_setup);
843 EXPORT_SYMBOL(netpoll_cleanup);
844 EXPORT_SYMBOL(netpoll_send_udp);
845 EXPORT_SYMBOL(netpoll_poll);