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