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