Whamcloud - gitweb
bd554248ac7e348baecd35a0caba6d12e3a01270
[fs/lustre-release.git] / lustre / kernel_patches / patches / netpoll-core.patch
1  l-mpm/arch/i386/kernel/irq.c    |   15 
2  l-mpm/include/asm-i386/irq.h         |    1 
3  l-mpm/include/linux/netdevice.h |   22 -
4  l-mpm/include/linux/netpoll.h   |   37 ++
5  l-mpm/net/Kconfig               |    3 
6  l-mpm/net/core/Makefile         |    1 
7  l-mpm/net/core/dev.c            |   22 -
8  l-mpm/net/core/netpoll.c        |  632 ++++++++++++++++++++++++++++++++++++++++
9  8 files changed, 707 insertions(+), 26 deletions(-)
10
11 Index: linux-2.6.0-test6/net/core/netpoll.c
12 ===================================================================
13 --- linux-2.6.0-test6.orig/net/core/netpoll.c   2003-10-07 16:08:51.000000000 +0800
14 +++ linux-2.6.0-test6/net/core/netpoll.c        2003-10-09 20:40:07.769057232 +0800
15 @@ -0,0 +1,633 @@
16 +/*
17 + * Common framework for low-level network console, dump, and debugger code
18 + *
19 + * Sep 8 2003  Matt Mackall <mpm@selenic.com>
20 + */
21 +
22 +#include <linux/smp_lock.h>
23 +#include <linux/netdevice.h>
24 +#include <linux/etherdevice.h>
25 +#include <linux/string.h>
26 +#include <linux/inetdevice.h>
27 +#include <linux/inet.h>
28 +#include <linux/interrupt.h>
29 +#include <linux/netpoll.h>
30 +#include <linux/sched.h>
31 +#include <net/tcp.h>
32 +#include <net/udp.h>
33 +
34 +/*
35 + * We maintain a small pool of fully-sized skbs, to make sure the
36 + * message gets out even in extreme OOM situations.
37 + */
38 +
39 +#define MAX_SKBS 32
40 +#define MAX_UDP_CHUNK 1460
41 +
42 +static spinlock_t skb_list_lock = SPIN_LOCK_UNLOCKED;
43 +static int nr_skbs;
44 +static struct sk_buff *skbs;
45 +
46 +static spinlock_t rx_list_lock = SPIN_LOCK_UNLOCKED;
47 +static LIST_HEAD(rx_list);
48 +
49 +static int trapped;
50 +
51 +#define MAX_SKB_SIZE \
52 +               (MAX_UDP_CHUNK + sizeof(struct udphdr) + \
53 +                               sizeof(struct iphdr) + sizeof(struct ethhdr))
54 +
55 +static int checksum_udp(struct sk_buff *skb, struct udphdr *uh,
56 +                            unsigned short ulen, u32 saddr, u32 daddr)
57 +{
58 +       if (uh->check == 0)
59 +               return 0;
60 +
61 +       if (skb->ip_summed == CHECKSUM_HW)
62 +               return csum_tcpudp_magic(
63 +                       saddr, daddr, ulen, IPPROTO_UDP, skb->csum);
64 +
65 +       skb->csum = csum_tcpudp_nofold(saddr, daddr, ulen, IPPROTO_UDP, 0);
66 +
67 +       return csum_fold(skb_checksum(skb, 0, skb->len, skb->csum));
68 +}
69 +
70 +void netpoll_poll(struct netpoll *np)
71 +{
72 +       int budget = 1;
73 +
74 +       if(!np || !np->dev || !(np->dev->flags & IFF_UP))
75 +               return;
76 +
77 +       disable_irq(np->dev->irq);
78 +
79 +       /* Process pending work on NIC */
80 +       np->irqfunc(np->dev->irq, np->dev, 0);
81 +
82 +       /* If scheduling is stopped, tickle NAPI bits */
83 +       if(trapped && np->dev->poll &&
84 +          test_bit(__LINK_STATE_RX_SCHED, &np->dev->state))
85 +               np->dev->poll(np->dev, &budget);
86 +
87 +       enable_irq(np->dev->irq);
88 +}
89 +
90 +static void refill_skbs(void)
91 +{
92 +       struct sk_buff *skb;
93 +       unsigned long flags;
94 +
95 +       spin_lock_irqsave(&skb_list_lock, flags);
96 +       while (nr_skbs < MAX_SKBS) {
97 +               skb = alloc_skb(MAX_SKB_SIZE, GFP_ATOMIC);
98 +               if (!skb)
99 +                       break;
100 +
101 +               skb->next = skbs;
102 +               skbs = skb;
103 +               nr_skbs++;
104 +       }
105 +       spin_unlock_irqrestore(&skb_list_lock, flags);
106 +}
107 +
108 +static void zap_completion_queue(void)
109 +{
110 +       unsigned long flags;
111 +       struct softnet_data *sd = &get_cpu_var(softnet_data);
112 +
113 +       if (sd->completion_queue) {
114 +               struct sk_buff *clist;
115 +
116 +               local_irq_save(flags);
117 +               clist = sd->completion_queue;
118 +               sd->completion_queue = NULL;
119 +               local_irq_restore(flags);
120 +
121 +               while (clist != NULL) {
122 +                       struct sk_buff *skb = clist;
123 +                       clist = clist->next;
124 +                       __kfree_skb(skb);
125 +               }
126 +       }
127 +
128 +       put_cpu_var(softnet_data);
129 +}
130 +
131 +static struct sk_buff * find_skb(struct netpoll *np, int len, int reserve)
132 +{
133 +       int once = 1, count = 0;
134 +       unsigned long flags;
135 +       struct sk_buff *skb = NULL;
136 +
137 +repeat:
138 +       zap_completion_queue();
139 +       if (nr_skbs < MAX_SKBS)
140 +               refill_skbs();
141 +
142 +       skb = alloc_skb(len, GFP_ATOMIC);
143 +
144 +       if (!skb) {
145 +               spin_lock_irqsave(&skb_list_lock, flags);
146 +               skb = skbs;
147 +               if (skb)
148 +                       skbs = skb->next;
149 +               skb->next = NULL;
150 +               nr_skbs--;
151 +               spin_unlock_irqrestore(&skb_list_lock, flags);
152 +       }
153 +
154 +       if(!skb) {
155 +               count++;
156 +               if (once && (count == 1000000)) {
157 +                       printk("out of netpoll skbs!\n");
158 +                       once = 0;
159 +               }
160 +               netpoll_poll(np);
161 +               goto repeat;
162 +       }
163 +
164 +       atomic_set(&skb->users, 1);
165 +       skb_reserve(skb, reserve);
166 +       return skb;
167 +}
168 +
169 +void netpoll_send_skb(struct netpoll *np, struct sk_buff *skb)
170 +{
171 +       int status;
172 +
173 +repeat:
174 +       if(!np || !np->dev || !(np->dev->flags & IFF_UP)) {
175 +               __kfree_skb(skb);
176 +               return;
177 +       }
178 +
179 +       spin_lock(&np->dev->xmit_lock);
180 +       np->dev->xmit_lock_owner = smp_processor_id();
181 +
182 +       if (netif_queue_stopped(np->dev)) {
183 +               np->dev->xmit_lock_owner = -1;
184 +               spin_unlock(&np->dev->xmit_lock);
185 +
186 +               netpoll_poll(np);
187 +               zap_completion_queue();
188 +               goto repeat;
189 +       }
190 +
191 +       status = np->dev->hard_start_xmit(skb, np->dev);
192 +       np->dev->xmit_lock_owner = -1;
193 +       spin_unlock(&np->dev->xmit_lock);
194 +
195 +       /* transmit busy */
196 +       if(status)
197 +               goto repeat;
198 +}
199 +
200 +void netpoll_send_udp(struct netpoll *np, const char *msg, int len)
201 +{
202 +       int total_len, eth_len, ip_len, udp_len;
203 +       struct sk_buff *skb;
204 +       struct udphdr *udph;
205 +       struct iphdr *iph;
206 +       struct ethhdr *eth;
207 +
208 +       udp_len = len + sizeof(*udph);
209 +       ip_len = eth_len = udp_len + sizeof(*iph);
210 +       total_len = eth_len + ETH_HLEN;
211 +
212 +       skb = find_skb(np, total_len, total_len - len);
213 +       if (!skb)
214 +               return;
215 +
216 +       memcpy(skb->data, msg, len);
217 +       skb->len += len;
218 +
219 +       udph = (struct udphdr *) skb_push(skb, sizeof(*udph));
220 +       udph->source = htons(np->local_port);
221 +       udph->dest = htons(np->remote_port);
222 +       udph->len = htons(udp_len);
223 +       udph->check = 0;
224 +
225 +       iph = (struct iphdr *)skb_push(skb, sizeof(*iph));
226 +
227 +       iph->version  = 4;
228 +       iph->ihl      = 5;
229 +       iph->tos      = 0;
230 +       iph->tot_len  = htons(ip_len);
231 +       iph->id       = 0;
232 +       iph->frag_off = 0;
233 +       iph->ttl      = 64;
234 +       iph->protocol = IPPROTO_UDP;
235 +       iph->check    = 0;
236 +       iph->saddr    = htonl(np->local_ip);
237 +       iph->daddr    = htonl(np->remote_ip);
238 +       iph->check    = ip_fast_csum((unsigned char *)iph, iph->ihl);
239 +
240 +       eth = (struct ethhdr *) skb_push(skb, ETH_HLEN);
241 +
242 +       eth->h_proto = htons(ETH_P_IP);
243 +       memcpy(eth->h_source, np->local_mac, 6);
244 +       memcpy(eth->h_dest, np->remote_mac, 6);
245 +
246 +       netpoll_send_skb(np, skb);
247 +}
248 +
249 +static void arp_reply(struct sk_buff *skb)
250 +{
251 +       struct in_device *in_dev = (struct in_device *) skb->dev->ip_ptr;
252 +       struct arphdr *arp;
253 +       unsigned char *arp_ptr, *sha, *tha;
254 +       int size, type = ARPOP_REPLY, ptype = ETH_P_ARP;
255 +       u32 sip, tip;
256 +       struct sk_buff *send_skb;
257 +       unsigned long flags;
258 +       struct list_head *p;
259 +       struct netpoll *np = 0;
260 +
261 +       spin_lock_irqsave(&rx_list_lock, flags);
262 +       list_for_each(p, &rx_list) {
263 +               np = list_entry(p, struct netpoll, rx_list);
264 +               if ( np->dev == skb->dev )
265 +                       break;
266 +               np = 0;
267 +       }
268 +       spin_unlock_irqrestore(&rx_list_lock, flags);
269 +
270 +       if (!np) return;
271 +
272 +       /* No arp on this interface */
273 +       if (!in_dev || skb->dev->flags & IFF_NOARP)
274 +               return;
275 +
276 +       if (!pskb_may_pull(skb, (sizeof(struct arphdr) +
277 +                                (2 * skb->dev->addr_len) +
278 +                                (2 * sizeof(u32)))))
279 +               return;
280 +
281 +       skb->h.raw = skb->nh.raw = skb->data;
282 +       arp = skb->nh.arph;
283 +
284 +       if ((arp->ar_hrd != htons(ARPHRD_ETHER) &&
285 +            arp->ar_hrd != htons(ARPHRD_IEEE802)) ||
286 +           arp->ar_pro != htons(ETH_P_IP) ||
287 +           arp->ar_op != htons(ARPOP_REQUEST))
288 +               return;
289 +
290 +       arp_ptr= (unsigned char *)(arp+1);
291 +       sha = arp_ptr;
292 +       arp_ptr += skb->dev->addr_len;
293 +       memcpy(&sip, arp_ptr, 4);
294 +       arp_ptr += 4;
295 +       tha = arp_ptr;
296 +       arp_ptr += skb->dev->addr_len;
297 +       memcpy(&tip, arp_ptr, 4);
298 +
299 +       /* Should we ignore arp? */
300 +       if (tip != in_dev->ifa_list->ifa_address ||
301 +           LOOPBACK(tip) || MULTICAST(tip))
302 +               return;
303 +
304 +
305 +       size = sizeof(struct arphdr) + 2 * (skb->dev->addr_len + 4);
306 +       send_skb = find_skb(np, size + LL_RESERVED_SPACE(np->dev),
307 +                           LL_RESERVED_SPACE(np->dev));
308 +
309 +       if (!send_skb)
310 +               return;
311 +
312 +       send_skb->nh.raw = send_skb->data;
313 +       arp = (struct arphdr *) skb_put(send_skb, size);
314 +       send_skb->dev = skb->dev;
315 +       send_skb->protocol = htons(ETH_P_ARP);
316 +
317 +       /* Fill the device header for the ARP frame */
318 +
319 +       if (np->dev->hard_header &&
320 +           np->dev->hard_header(send_skb, skb->dev, ptype,
321 +                                      np->remote_mac, np->local_mac,
322 +                                      send_skb->len) < 0) {
323 +               kfree_skb(send_skb);
324 +               return;
325 +       }
326 +
327 +       /*
328 +        * Fill out the arp protocol part.
329 +        *
330 +        * we only support ethernet device type,
331 +        * which (according to RFC 1390) should always equal 1 (Ethernet).
332 +        */
333 +
334 +       arp->ar_hrd = htons(np->dev->type);
335 +       arp->ar_pro = htons(ETH_P_IP);
336 +       arp->ar_hln = np->dev->addr_len;
337 +       arp->ar_pln = 4;
338 +       arp->ar_op = htons(type);
339 +
340 +       arp_ptr=(unsigned char *)(arp + 1);
341 +       memcpy(arp_ptr, np->dev->dev_addr, np->dev->addr_len);
342 +       arp_ptr += np->dev->addr_len;
343 +       memcpy(arp_ptr, &tip, 4);
344 +       arp_ptr += 4;
345 +       memcpy(arp_ptr, np->local_mac, np->dev->addr_len);
346 +       arp_ptr += np->dev->addr_len;
347 +       memcpy(arp_ptr, &sip, 4);
348 +
349 +       netpoll_send_skb(np, send_skb);
350 +}
351 +
352 +static int rx_hook(struct sk_buff *skb)
353 +{
354 +       int proto, len, ulen;
355 +       struct iphdr *iph;
356 +       struct udphdr *uh;
357 +       struct netpoll *np;
358 +       struct list_head *p;
359 +       unsigned long flags;
360 +       int rx_hook_called = 0;
361 +
362 +       if (skb->dev->type != ARPHRD_ETHER)
363 +               goto out;
364 +
365 +       /* check if netpoll clients need ARP */
366 +       if (skb->protocol == __constant_htons(ETH_P_ARP) && trapped) {
367 +               arp_reply(skb);
368 +               return 1;
369 +       }
370 +
371 +       proto = ntohs(skb->mac.ethernet->h_proto);
372 +       if (proto != ETH_P_IP)
373 +               goto out;
374 +       if (skb->pkt_type == PACKET_OTHERHOST)
375 +               goto out;
376 +       if (skb_shared(skb))
377 +               goto out;
378 +
379 +       iph = (struct iphdr *)skb->data;
380 +       if (!pskb_may_pull(skb, sizeof(struct iphdr)))
381 +               goto out;
382 +       if (iph->ihl < 5 || iph->version != 4)
383 +               goto out;
384 +       if (!pskb_may_pull(skb, iph->ihl*4))
385 +               goto out;
386 +       if (ip_fast_csum((u8 *)iph, iph->ihl) != 0)
387 +               goto out;
388 +
389 +       len = ntohs(iph->tot_len);
390 +       if (skb->len < len || len < iph->ihl*4)
391 +               goto out;
392 +
393 +       if (iph->protocol != IPPROTO_UDP)
394 +               goto out;
395 +
396 +       len -= iph->ihl*4;
397 +       uh = (struct udphdr *)(((char *)iph) + iph->ihl*4);
398 +       ulen = ntohs(uh->len);
399 +
400 +       if (ulen != len)
401 +               goto out;
402 +       if (checksum_udp(skb, uh, ulen, iph->saddr, iph->daddr) < 0)
403 +               goto out;
404 +
405 +       spin_lock_irqsave(&rx_list_lock, flags);
406 +       list_for_each(p, &rx_list) {
407 +               np = list_entry(p, struct netpoll, rx_list);
408 +               if (np->dev && np->dev != skb->dev)
409 +                       continue;
410 +               if (np->local_ip && np->local_ip != ntohl(iph->daddr))
411 +                       continue;
412 +               if (np->remote_ip && np->remote_ip != ntohl(iph->saddr))
413 +                       continue;
414 +               if (np->local_port && np->local_port != ntohs(uh->dest))
415 +                       continue;
416 +
417 +               if (np->rx_hook){
418 +                       np->rx_hook(np, ntohs(uh->source),
419 +                                   (char *)(uh+1), ulen-sizeof(uh)-4);
420 +                       rx_hook_called = 1;
421 +               }
422 +       }
423 +       spin_unlock_irqrestore(&rx_list_lock, flags);
424 +       
425 +       if (rx_hook_called)
426 +               return 1;
427 +out:
428 +       return trapped;
429 +}
430 +
431 +int netpoll_parse_options(struct netpoll *np, char *opt)
432 +{
433 +       char *cur=opt, *delim;
434 +
435 +       if(*cur != '@') {
436 +               if ((delim = strchr(cur, '@')) == NULL)
437 +                       goto parse_failed;
438 +               *delim=0;
439 +               np->local_port=simple_strtol(cur, 0, 10);
440 +               cur=delim;
441 +       }
442 +       cur++;
443 +       printk(KERN_INFO "%s: local port %d\n", np->name, np->local_port);
444 +
445 +       if(*cur != '/') {
446 +               if ((delim = strchr(cur, '/')) == NULL)
447 +                       goto parse_failed;
448 +               *delim=0;
449 +               np->local_ip=ntohl(in_aton(cur));
450 +               cur=delim;
451 +
452 +               printk(KERN_INFO "%s: local IP %d.%d.%d.%d\n",
453 +                      np->name, HIPQUAD(np->local_ip));
454 +       }
455 +       cur++;
456 +
457 +       if ( *cur != ',') {
458 +               /* parse out dev name */
459 +               if ((delim = strchr(cur, ',')) == NULL)
460 +                       goto parse_failed;
461 +               *delim=0;
462 +               strlcpy(np->dev_name, cur, sizeof(np->dev_name));
463 +               cur=delim;
464 +       }
465 +       cur++;
466 +
467 +       printk(KERN_INFO "%s: interface %s\n", np->name, np->dev_name);
468 +
469 +       if ( *cur != '@' ) {
470 +               /* dst port */
471 +               if ((delim = strchr(cur, '@')) == NULL)
472 +                       goto parse_failed;
473 +               *delim=0;
474 +               np->remote_port=simple_strtol(cur, 0, 10);
475 +               cur=delim;
476 +       }
477 +       cur++;
478 +       printk(KERN_INFO "%s: remote port %d\n", np->name, np->remote_port);
479 +
480 +       /* dst ip */
481 +       if ((delim = strchr(cur, '/')) == NULL)
482 +               goto parse_failed;
483 +       *delim=0;
484 +       np->remote_ip=ntohl(in_aton(cur));
485 +       cur=delim+1;
486 +
487 +       printk(KERN_INFO "%s: remote IP %d.%d.%d.%d\n",
488 +                      np->name, HIPQUAD(np->remote_ip));
489 +
490 +       if( *cur != 0 )
491 +       {
492 +               /* MAC address */
493 +               if ((delim = strchr(cur, ':')) == NULL)
494 +                       goto parse_failed;
495 +               *delim=0;
496 +               np->remote_mac[0]=simple_strtol(cur, 0, 16);
497 +               cur=delim+1;
498 +               if ((delim = strchr(cur, ':')) == NULL)
499 +                       goto parse_failed;
500 +               *delim=0;
501 +               np->remote_mac[1]=simple_strtol(cur, 0, 16);
502 +               cur=delim+1;
503 +               if ((delim = strchr(cur, ':')) == NULL)
504 +                       goto parse_failed;
505 +               *delim=0;
506 +               np->remote_mac[2]=simple_strtol(cur, 0, 16);
507 +               cur=delim+1;
508 +               if ((delim = strchr(cur, ':')) == NULL)
509 +                       goto parse_failed;
510 +               *delim=0;
511 +               np->remote_mac[3]=simple_strtol(cur, 0, 16);
512 +               cur=delim+1;
513 +               if ((delim = strchr(cur, ':')) == NULL)
514 +                       goto parse_failed;
515 +               *delim=0;
516 +               np->remote_mac[4]=simple_strtol(cur, 0, 16);
517 +               cur=delim+1;
518 +               np->remote_mac[5]=simple_strtol(cur, 0, 16);
519 +       }
520 +
521 +       printk(KERN_INFO "%s: remote ethernet address "
522 +              "%02x:%02x:%02x:%02x:%02x:%02x\n",
523 +              np->name,
524 +              np->remote_mac[0],
525 +              np->remote_mac[1],
526 +              np->remote_mac[2],
527 +              np->remote_mac[3],
528 +              np->remote_mac[4],
529 +              np->remote_mac[5]);
530 +
531 +       return 0;
532 +
533 + parse_failed:
534 +       printk(KERN_INFO "%s: couldn't parse config at %s!\n",
535 +              np->name, cur);
536 +       return -1;
537 +}
538 +
539 +int netpoll_setup(struct netpoll *np)
540 +{
541 +       struct net_device *ndev = NULL;
542 +       struct in_device *in_dev;
543 +       struct irqaction *a;
544 +
545 +       if (np->dev_name)
546 +               ndev = dev_get_by_name(np->dev_name);
547 +       if (!ndev) {
548 +               printk(KERN_ERR "%s: %s doesn't exist, aborting.\n",
549 +                      np->name, np->dev_name);
550 +               return -1;
551 +       }
552 +
553 +       if (!(ndev->flags & IFF_UP)) {
554 +               unsigned short oflags;
555 +               unsigned long jiff;
556 +
557 +               printk(KERN_INFO "%s: device %s not up yet, forcing it\n",
558 +                      np->name, np->dev_name);
559 +
560 +               oflags = ndev->flags;
561 +
562 +               rtnl_shlock();
563 +               if (dev_change_flags(ndev, oflags | IFF_UP) < 0) {
564 +                       printk(KERN_ERR "%s: failed to open %s\n",
565 +                              np->name, np->dev_name);
566 +                       rtnl_shunlock();
567 +                       return -1;
568 +               }
569 +               rtnl_shunlock();
570 +
571 +               jiff = jiffies + 6*HZ;
572 +               while(!netif_carrier_ok(ndev)) {
573 +                       if (!time_before(jiffies, jiff)) {
574 +                               printk(KERN_NOTICE
575 +                                      "%s: timeout waiting for carrier\n",
576 +                                      np->name);
577 +                               break;
578 +                       }
579 +                       cond_resched();
580 +               }
581 +
582 +       }
583 +
584 +       if (!memcmp(np->local_mac, "\0\0\0\0\0\0", 6) && ndev->dev_addr)
585 +               memcpy(np->local_mac, ndev->dev_addr, 6);
586 +
587 +       if (!np->local_ip)
588 +       {
589 +               in_dev = in_dev_get(ndev);
590 +
591 +               if (!in_dev) {
592 +                       printk(KERN_ERR "%s: no IP address for %s, aborting\n",
593 +                              np->name, np->dev_name);
594 +                       return -1;
595 +               }
596 +
597 +               np->local_ip = ntohl(in_dev->ifa_list->ifa_local);
598 +               in_dev_put(in_dev);
599 +               printk(KERN_INFO "%s: local IP %d.%d.%d.%d\n",
600 +                      np->name, HIPQUAD(np->local_ip));
601 +       }
602 +
603 +       a=find_irq_action(ndev->irq, ndev);
604 +       if (!a) {
605 +               printk(KERN_ERR "%s: couldn't find irq handler for %s, "
606 +                      "aborting\n", np->name, np->dev_name);
607 +               return -1;
608 +       }
609 +
610 +       np->irqfunc = a->handler;
611 +       np->dev = ndev;
612 +
613 +       if(np->rx_hook) {
614 +               unsigned long flags;
615 +
616 +               np->dev->rx_hook = rx_hook;
617 +
618 +               spin_lock_irqsave(&rx_list_lock, flags);
619 +               list_add(&np->rx_list, &rx_list);
620 +               spin_unlock_irqrestore(&rx_list_lock, flags);
621 +       }
622 +
623 +       return 0;
624 +}
625 +
626 +void netpoll_cleanup(struct netpoll *np)
627 +{
628 +       if(np->rx_hook) {
629 +               unsigned long flags;
630 +
631 +               spin_lock_irqsave(&rx_list_lock, flags);
632 +               list_del(&np->rx_list);
633 +               np->dev->rx_hook = 0;
634 +               spin_unlock_irqrestore(&rx_list_lock, flags);
635 +       }
636 +
637 +       np->dev = 0;
638 +}
639 +
640 +int netpoll_trap()
641 +{
642 +       return trapped;
643 +}
644 +
645 +void netpoll_set_trap(int trap)
646 +{
647 +       trapped = trap;
648 +}
649 Index: linux-2.6.0-test6/include/linux/netpoll.h
650 ===================================================================
651 --- linux-2.6.0-test6.orig/include/linux/netpoll.h      2003-10-07 16:08:51.000000000 +0800
652 +++ linux-2.6.0-test6/include/linux/netpoll.h   2003-10-07 16:08:51.000000000 +0800
653 @@ -0,0 +1,37 @@
654 +/*
655 + * Common code for low-level network console, dump, and debugger code
656 + *
657 + * Derived from netconsole, kgdb-over-ethernet, and netdump patches
658 + */
659 +
660 +#ifndef _LINUX_NETPOLL_H
661 +#define _LINUX_NETPOLL_H
662 +
663 +#include <linux/netdevice.h>
664 +#include <linux/irq.h>
665 +#include <linux/list.h>
666 +
667 +struct netpoll;
668 +
669 +struct netpoll {
670 +       struct net_device *dev;
671 +       char dev_name[16], *name;
672 +       irqreturn_t (*irqfunc)(int, void *, struct pt_regs *);
673 +       void (*rx_hook)(struct netpoll *, int, char *, int);
674 +       u32 local_ip, remote_ip;
675 +       u16 local_port, remote_port;
676 +       unsigned char local_mac[6], remote_mac[6];
677 +       struct list_head rx_list;
678 +};
679 +
680 +void netpoll_poll(struct netpoll *np);
681 +void netpoll_send_skb(struct netpoll *np, struct sk_buff *skb);
682 +void netpoll_send_udp(struct netpoll *np, const char *msg, int len);
683 +int netpoll_parse_options(struct netpoll *np, char *opt);
684 +int netpoll_setup(struct netpoll *np);
685 +int netpoll_trap(void);
686 +void netpoll_set_trap(int trap);
687 +void netpoll_cleanup(struct netpoll *np);
688 +
689 +
690 +#endif
691 Index: linux-2.6.0-test6/net/core/Makefile
692 ===================================================================
693 --- linux-2.6.0-test6.orig/net/core/Makefile    2003-09-28 08:51:03.000000000 +0800
694 +++ linux-2.6.0-test6/net/core/Makefile 2003-10-07 16:08:51.000000000 +0800
695 @@ -13,3 +13,4 @@
696  obj-$(CONFIG_NET_DIVERT) += dv.o
697  obj-$(CONFIG_NET_PKTGEN) += pktgen.o
698  obj-$(CONFIG_NET_RADIO) += wireless.o
699 +obj-$(CONFIG_NETPOLL) += netpoll.o
700 Index: linux-2.6.0-test6/net/Kconfig
701 ===================================================================
702 --- linux-2.6.0-test6.orig/net/Kconfig  2003-09-28 08:50:07.000000000 +0800
703 +++ linux-2.6.0-test6/net/Kconfig       2003-10-09 20:36:23.429162080 +0800
704 @@ -670,4 +670,7 @@
705  
706  source "net/bluetooth/Kconfig"
707  
708 +config NETPOLL
709 +       def_bool KGDB
710 +
711  endmenu
712 Index: linux-2.6.0-test6/include/linux/netdevice.h
713 ===================================================================
714 --- linux-2.6.0-test6.orig/include/linux/netdevice.h    2003-10-07 16:08:42.000000000 +0800
715 +++ linux-2.6.0-test6/include/linux/netdevice.h 2003-10-07 16:08:51.000000000 +0800
716 @@ -452,13 +452,13 @@
717                                                      unsigned char *haddr);
718         int                     (*neigh_setup)(struct net_device *dev, struct neigh_parms *);
719         int                     (*accept_fastpath)(struct net_device *, struct dst_entry*);
720 +#ifdef CONFIG_NETPOLL
721 +       int                     (*rx_hook)(struct sk_buff *skb);
722 +#endif
723  
724         /* bridge stuff */
725         struct net_bridge_port  *br_port;
726  
727 -#ifdef CONFIG_KGDB
728 -       int                     kgdb_is_trapped;
729 -#endif
730  #ifdef CONFIG_NET_POLL_CONTROLLER
731         void                    (*poll_controller)(struct net_device *);
732  #endif
733 @@ -537,10 +537,8 @@
734  extern struct net_device       *dev_get_by_index(int ifindex);
735  extern struct net_device       *__dev_get_by_index(int ifindex);
736  extern int             dev_restart(struct net_device *dev);
737 -#ifdef CONFIG_KGDB
738 -extern int             kgdb_eth_is_trapped(void);
739 -extern int             kgdb_net_interrupt(struct sk_buff *skb);
740 -extern void            kgdb_send_arp_request(void);
741 +#ifdef CONFIG_NETPOLL
742 +extern int             netpoll_trap(void);
743  #endif
744  
745  typedef int gifconf_func_t(struct net_device * dev, char * bufptr, int len);
746 @@ -600,10 +598,9 @@
747  
748  static inline void netif_wake_queue(struct net_device *dev)
749  {
750 -#ifdef CONFIG_KGDB
751 -       if (kgdb_eth_is_trapped()) {
752 +#ifdef CONFIG_NETPOLL
753 +       if (netpoll_trap())
754                 return;
755 -       }
756  #endif
757         if (test_and_clear_bit(__LINK_STATE_XOFF, &dev->state))
758                 __netif_schedule(dev);
759 @@ -611,10 +608,9 @@
760  
761  static inline void netif_stop_queue(struct net_device *dev)
762  {
763 -#ifdef CONFIG_KGDB
764 -       if (kgdb_eth_is_trapped()) {
765 +#ifdef CONFIG_NETPOLL
766 +       if (netpoll_trap())
767                 return;
768 -       }
769  #endif
770         set_bit(__LINK_STATE_XOFF, &dev->state);
771  }
772 Index: linux-2.6.0-test6/net/core/dev.c
773 ===================================================================
774 --- linux-2.6.0-test6.orig/net/core/dev.c       2003-10-07 16:08:42.000000000 +0800
775 +++ linux-2.6.0-test6/net/core/dev.c    2003-10-09 20:36:23.436161016 +0800
776 @@ -1352,16 +1352,8 @@
777         struct softnet_data *queue;
778         unsigned long flags;
779  
780 -#ifdef CONFIG_KGDB
781 -       /* See if kgdb_eth wants this packet */
782 -       if (!kgdb_net_interrupt(skb)) {
783 -               /* No.. if we're 'trapped' then junk it */
784 -               if (kgdb_eth_is_trapped()) {
785 -                       kfree_skb(skb);
786 -                       return NET_RX_DROP;
787 -               }
788 -       } else {
789 -               /* kgdb_eth ate the packet... drop it silently */
790 +#ifdef CONFIG_NETPOLL
791 +       if (skb->dev->rx_hook && skb->dev->rx_hook(skb)) {
792                 kfree_skb(skb);
793                 return NET_RX_DROP;
794         }
795 @@ -1556,6 +1548,13 @@
796         int ret = NET_RX_DROP;
797         unsigned short type = skb->protocol;
798  
799 +#ifdef CONFIG_NETPOLL
800 +       if (skb->dev->rx_hook && skb->dev->rx_hook(skb)) {
801 +               kfree_skb(skb);
802 +               return NET_RX_DROP;
803 +       }
804 +#endif
805 +
806         if (!skb->stamp.tv_sec)
807                 do_gettimeofday(&skb->stamp);
808  
809 Index: linux-2.6.0-test6/include/asm-i386/irq.h
810 ===================================================================
811 --- linux-2.6.0-test6.orig/include/asm-i386/irq.h       2003-09-28 08:50:36.000000000 +0800
812 +++ linux-2.6.0-test6/include/asm-i386/irq.h    2003-10-07 16:08:51.000000000 +0800
813 @@ -24,6 +24,7 @@
814  extern void disable_irq_nosync(unsigned int);
815  extern void enable_irq(unsigned int);
816  extern void release_x86_irqs(struct task_struct *);
817 +struct irqaction *find_irq_action(unsigned int irq, void *dev_id);
818  
819  #ifdef CONFIG_X86_LOCAL_APIC
820  #define ARCH_HAS_NMI_WATCHDOG          /* See include/linux/nmi.h */
821 Index: linux-2.6.0-test6/arch/i386/kernel/irq.c
822 ===================================================================
823 --- linux-2.6.0-test6.orig/arch/i386/kernel/irq.c       2003-10-07 16:08:34.000000000 +0800
824 +++ linux-2.6.0-test6/arch/i386/kernel/irq.c    2003-10-09 20:36:23.433161472 +0800
825 @@ -396,7 +396,6 @@
826         }
827         spin_unlock_irqrestore(&desc->lock, flags);
828  }
829 -
830  /*
831   * do_IRQ handles all normal device IRQ's (the special
832   * SMP cross-CPU interrupts have their own specific
833 @@ -896,6 +895,21 @@
834         return 0;
835  }
836  
837 +struct irqaction *find_irq_action(unsigned int irq, void *dev_id)
838 +{
839 +       struct irqaction *a, *r=0;
840 +
841 +       spin_lock_irq(&irq_desc[irq].lock);
842 +       for(a=irq_desc[irq].action; a; a=a->next) {
843 +               if(a->dev_id == dev_id) {
844 +                       r=a;
845 +                       break;
846 +               }
847 +       }
848 +       spin_unlock_irq(&irq_desc[irq].lock);
849 +       return r;
850 +}
851 +
852  static struct proc_dir_entry * root_irq_dir;
853  static struct proc_dir_entry * irq_dir [NR_IRQS];
854