2 * Common framework for low-level network console, dump, and debugger code
4 * Sep 8 2003 Matt Mackall <mpm@selenic.com>
6 * based on the netconsole code from:
8 * Copyright (C) 2001 Ingo Molnar <mingo@redhat.com>
9 * Copyright (C) 2002 Red Hat, Inc.
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>
28 #include <asm/unaligned.h>
29 #include <trace/events/napi.h>
32 * We maintain a small pool of fully-sized skbs, to make sure the
33 * message gets out even in extreme OOM situations.
36 #define MAX_UDP_CHUNK 1460
38 #define MAX_QUEUE_DEPTH (MAX_SKBS / 2)
40 static struct sk_buff_head skb_pool
;
42 static atomic_t trapped
;
44 #define USEC_PER_POLL 50
45 #define NETPOLL_RX_ENABLED 1
46 #define NETPOLL_RX_DROP 2
48 #define MAX_SKB_SIZE \
49 (MAX_UDP_CHUNK + sizeof(struct udphdr) + \
50 sizeof(struct iphdr) + sizeof(struct ethhdr))
52 static void zap_completion_queue(void);
53 static void arp_reply(struct sk_buff
*skb
);
55 static unsigned int carrier_timeout
= 4;
56 module_param(carrier_timeout
, uint
, 0644);
58 static void queue_process(struct work_struct
*work
)
60 struct netpoll_info
*npinfo
=
61 container_of(work
, struct netpoll_info
, tx_work
.work
);
65 while ((skb
= skb_dequeue(&npinfo
->txq
))) {
66 struct net_device
*dev
= skb
->dev
;
67 const struct net_device_ops
*ops
= dev
->netdev_ops
;
68 struct netdev_queue
*txq
;
70 if (!netif_device_present(dev
) || !netif_running(dev
)) {
75 txq
= netdev_get_tx_queue(dev
, skb_get_queue_mapping(skb
));
77 local_irq_save(flags
);
78 __netif_tx_lock(txq
, smp_processor_id());
79 if (netif_tx_queue_stopped(txq
) ||
80 netif_tx_queue_frozen(txq
) ||
81 ops
->ndo_start_xmit(skb
, dev
) != NETDEV_TX_OK
) {
82 skb_queue_head(&npinfo
->txq
, skb
);
83 __netif_tx_unlock(txq
);
84 local_irq_restore(flags
);
86 schedule_delayed_work(&npinfo
->tx_work
, HZ
/10);
89 __netif_tx_unlock(txq
);
90 local_irq_restore(flags
);
94 static __sum16
checksum_udp(struct sk_buff
*skb
, struct udphdr
*uh
,
95 unsigned short ulen
, __be32 saddr
, __be32 daddr
)
99 if (uh
->check
== 0 || skb_csum_unnecessary(skb
))
102 psum
= csum_tcpudp_nofold(saddr
, daddr
, ulen
, IPPROTO_UDP
, 0);
104 if (skb
->ip_summed
== CHECKSUM_COMPLETE
&&
105 !csum_fold(csum_add(psum
, skb
->csum
)))
110 return __skb_checksum_complete(skb
);
114 * Check whether delayed processing was scheduled for our NIC. If so,
115 * we attempt to grab the poll lock and use ->poll() to pump the card.
116 * If this fails, either we've recursed in ->poll() or it's already
117 * running on another CPU.
119 * Note: we don't mask interrupts with this lock because we're using
120 * trylock here and interrupts are already disabled in the softirq
121 * case. Further, we test the poll_owner to avoid recursion on UP
122 * systems where the lock doesn't exist.
124 * In cases where there is bi-directional communications, reading only
125 * one message at a time can lead to packets being dropped by the
126 * network adapter, forcing superfluous retries and possibly timeouts.
127 * Thus, we set our budget to greater than 1.
129 static int poll_one_napi(struct netpoll_info
*npinfo
,
130 struct napi_struct
*napi
, int budget
)
134 /* net_rx_action's ->poll() invocations and our's are
135 * synchronized by this test which is only made while
136 * holding the napi->poll_lock.
138 if (!test_bit(NAPI_STATE_SCHED
, &napi
->state
))
141 npinfo
->rx_flags
|= NETPOLL_RX_DROP
;
142 atomic_inc(&trapped
);
143 set_bit(NAPI_STATE_NPSVC
, &napi
->state
);
145 work
= napi
->poll(napi
, budget
);
146 trace_napi_poll(napi
);
148 clear_bit(NAPI_STATE_NPSVC
, &napi
->state
);
149 atomic_dec(&trapped
);
150 npinfo
->rx_flags
&= ~NETPOLL_RX_DROP
;
152 return budget
- work
;
155 static void poll_napi(struct net_device
*dev
)
157 struct napi_struct
*napi
;
160 list_for_each_entry(napi
, &dev
->napi_list
, dev_list
) {
161 if (napi
->poll_owner
!= smp_processor_id() &&
162 spin_trylock(&napi
->poll_lock
)) {
163 budget
= poll_one_napi(dev
->npinfo
, napi
, budget
);
164 spin_unlock(&napi
->poll_lock
);
172 static void service_arp_queue(struct netpoll_info
*npi
)
177 while ((skb
= skb_dequeue(&npi
->arp_tx
)))
182 void netpoll_poll_dev(struct net_device
*dev
)
184 const struct net_device_ops
*ops
;
186 if (!dev
|| !netif_running(dev
))
189 ops
= dev
->netdev_ops
;
190 if (!ops
->ndo_poll_controller
)
193 /* Process pending work on NIC */
194 ops
->ndo_poll_controller(dev
);
198 service_arp_queue(dev
->npinfo
);
200 zap_completion_queue();
202 EXPORT_SYMBOL(netpoll_poll_dev
);
204 void netpoll_poll(struct netpoll
*np
)
206 netpoll_poll_dev(np
->dev
);
208 EXPORT_SYMBOL(netpoll_poll
);
210 static void refill_skbs(void)
215 spin_lock_irqsave(&skb_pool
.lock
, flags
);
216 while (skb_pool
.qlen
< MAX_SKBS
) {
217 skb
= alloc_skb(MAX_SKB_SIZE
, GFP_ATOMIC
);
221 __skb_queue_tail(&skb_pool
, skb
);
223 spin_unlock_irqrestore(&skb_pool
.lock
, flags
);
226 static void zap_completion_queue(void)
229 struct softnet_data
*sd
= &get_cpu_var(softnet_data
);
231 if (sd
->completion_queue
) {
232 struct sk_buff
*clist
;
234 local_irq_save(flags
);
235 clist
= sd
->completion_queue
;
236 sd
->completion_queue
= NULL
;
237 local_irq_restore(flags
);
239 while (clist
!= NULL
) {
240 struct sk_buff
*skb
= clist
;
242 if (skb
->destructor
) {
243 atomic_inc(&skb
->users
);
244 dev_kfree_skb_any(skb
); /* put this one back */
251 put_cpu_var(softnet_data
);
254 static struct sk_buff
*find_skb(struct netpoll
*np
, int len
, int reserve
)
259 zap_completion_queue();
263 skb
= alloc_skb(len
, GFP_ATOMIC
);
265 skb
= skb_dequeue(&skb_pool
);
275 atomic_set(&skb
->users
, 1);
276 skb_reserve(skb
, reserve
);
280 static int netpoll_owner_active(struct net_device
*dev
)
282 struct napi_struct
*napi
;
284 list_for_each_entry(napi
, &dev
->napi_list
, dev_list
) {
285 if (napi
->poll_owner
== smp_processor_id())
291 void netpoll_send_skb_on_dev(struct netpoll
*np
, struct sk_buff
*skb
,
292 struct net_device
*dev
)
294 int status
= NETDEV_TX_BUSY
;
296 const struct net_device_ops
*ops
= dev
->netdev_ops
;
297 /* It is up to the caller to keep npinfo alive. */
298 struct netpoll_info
*npinfo
= np
->dev
->npinfo
;
300 if (!npinfo
|| !netif_running(dev
) || !netif_device_present(dev
)) {
305 /* don't get messages out of order, and no recursion */
306 if (skb_queue_len(&npinfo
->txq
) == 0 && !netpoll_owner_active(dev
)) {
307 struct netdev_queue
*txq
;
310 txq
= netdev_get_tx_queue(dev
, skb_get_queue_mapping(skb
));
312 local_irq_save(flags
);
313 /* try until next clock tick */
314 for (tries
= jiffies_to_usecs(1)/USEC_PER_POLL
;
315 tries
> 0; --tries
) {
316 if (__netif_tx_trylock(txq
)) {
317 if (!netif_tx_queue_stopped(txq
)) {
318 dev
->priv_flags
|= IFF_IN_NETPOLL
;
319 status
= ops
->ndo_start_xmit(skb
, dev
);
320 dev
->priv_flags
&= ~IFF_IN_NETPOLL
;
321 if (status
== NETDEV_TX_OK
)
322 txq_trans_update(txq
);
324 __netif_tx_unlock(txq
);
326 if (status
== NETDEV_TX_OK
)
331 /* tickle device maybe there is some cleanup */
334 udelay(USEC_PER_POLL
);
337 WARN_ONCE(!irqs_disabled(),
338 "netpoll_send_skb(): %s enabled interrupts in poll (%pF)\n",
339 dev
->name
, ops
->ndo_start_xmit
);
341 local_irq_restore(flags
);
344 if (status
!= NETDEV_TX_OK
) {
345 skb_queue_tail(&npinfo
->txq
, skb
);
346 schedule_delayed_work(&npinfo
->tx_work
,0);
349 EXPORT_SYMBOL(netpoll_send_skb_on_dev
);
351 void netpoll_send_udp(struct netpoll
*np
, const char *msg
, int len
)
353 int total_len
, eth_len
, ip_len
, udp_len
;
359 udp_len
= len
+ sizeof(*udph
);
360 ip_len
= eth_len
= udp_len
+ sizeof(*iph
);
361 total_len
= eth_len
+ ETH_HLEN
+ NET_IP_ALIGN
;
363 skb
= find_skb(np
, total_len
, total_len
- len
);
367 skb_copy_to_linear_data(skb
, msg
, len
);
370 skb_push(skb
, sizeof(*udph
));
371 skb_reset_transport_header(skb
);
373 udph
->source
= htons(np
->local_port
);
374 udph
->dest
= htons(np
->remote_port
);
375 udph
->len
= htons(udp_len
);
377 udph
->check
= csum_tcpudp_magic(np
->local_ip
,
379 udp_len
, IPPROTO_UDP
,
380 csum_partial(udph
, udp_len
, 0));
381 if (udph
->check
== 0)
382 udph
->check
= CSUM_MANGLED_0
;
384 skb_push(skb
, sizeof(*iph
));
385 skb_reset_network_header(skb
);
388 /* iph->version = 4; iph->ihl = 5; */
389 put_unaligned(0x45, (unsigned char *)iph
);
391 put_unaligned(htons(ip_len
), &(iph
->tot_len
));
395 iph
->protocol
= IPPROTO_UDP
;
397 put_unaligned(np
->local_ip
, &(iph
->saddr
));
398 put_unaligned(np
->remote_ip
, &(iph
->daddr
));
399 iph
->check
= ip_fast_csum((unsigned char *)iph
, iph
->ihl
);
401 eth
= (struct ethhdr
*) skb_push(skb
, ETH_HLEN
);
402 skb_reset_mac_header(skb
);
403 skb
->protocol
= eth
->h_proto
= htons(ETH_P_IP
);
404 memcpy(eth
->h_source
, np
->dev
->dev_addr
, ETH_ALEN
);
405 memcpy(eth
->h_dest
, np
->remote_mac
, ETH_ALEN
);
409 netpoll_send_skb(np
, skb
);
411 EXPORT_SYMBOL(netpoll_send_udp
);
413 static void arp_reply(struct sk_buff
*skb
)
415 struct netpoll_info
*npinfo
= skb
->dev
->npinfo
;
417 unsigned char *arp_ptr
;
418 int size
, type
= ARPOP_REPLY
, ptype
= ETH_P_ARP
;
421 struct sk_buff
*send_skb
;
422 struct netpoll
*np
, *tmp
;
426 if (list_empty(&npinfo
->rx_np
))
429 /* Before checking the packet, we do some early
430 inspection whether this is interesting at all */
431 spin_lock_irqsave(&npinfo
->rx_lock
, flags
);
432 list_for_each_entry_safe(np
, tmp
, &npinfo
->rx_np
, rx
) {
433 if (np
->dev
== skb
->dev
)
436 spin_unlock_irqrestore(&npinfo
->rx_lock
, flags
);
438 /* No netpoll struct is using this dev */
442 /* No arp on this interface */
443 if (skb
->dev
->flags
& IFF_NOARP
)
446 if (!pskb_may_pull(skb
, arp_hdr_len(skb
->dev
)))
449 skb_reset_network_header(skb
);
450 skb_reset_transport_header(skb
);
453 if ((arp
->ar_hrd
!= htons(ARPHRD_ETHER
) &&
454 arp
->ar_hrd
!= htons(ARPHRD_IEEE802
)) ||
455 arp
->ar_pro
!= htons(ETH_P_IP
) ||
456 arp
->ar_op
!= htons(ARPOP_REQUEST
))
459 arp_ptr
= (unsigned char *)(arp
+1);
460 /* save the location of the src hw addr */
462 arp_ptr
+= skb
->dev
->addr_len
;
463 memcpy(&sip
, arp_ptr
, 4);
465 /* If we actually cared about dst hw addr,
466 it would get copied here */
467 arp_ptr
+= skb
->dev
->addr_len
;
468 memcpy(&tip
, arp_ptr
, 4);
470 /* Should we ignore arp? */
471 if (ipv4_is_loopback(tip
) || ipv4_is_multicast(tip
))
474 size
= arp_hdr_len(skb
->dev
);
476 spin_lock_irqsave(&npinfo
->rx_lock
, flags
);
477 list_for_each_entry_safe(np
, tmp
, &npinfo
->rx_np
, rx
) {
478 if (tip
!= np
->local_ip
)
481 send_skb
= find_skb(np
, size
+ LL_ALLOCATED_SPACE(np
->dev
),
482 LL_RESERVED_SPACE(np
->dev
));
486 skb_reset_network_header(send_skb
);
487 arp
= (struct arphdr
*) skb_put(send_skb
, size
);
488 send_skb
->dev
= skb
->dev
;
489 send_skb
->protocol
= htons(ETH_P_ARP
);
491 /* Fill the device header for the ARP frame */
492 if (dev_hard_header(send_skb
, skb
->dev
, ptype
,
493 sha
, np
->dev
->dev_addr
,
494 send_skb
->len
) < 0) {
500 * Fill out the arp protocol part.
502 * we only support ethernet device type,
503 * which (according to RFC 1390) should
504 * always equal 1 (Ethernet).
507 arp
->ar_hrd
= htons(np
->dev
->type
);
508 arp
->ar_pro
= htons(ETH_P_IP
);
509 arp
->ar_hln
= np
->dev
->addr_len
;
511 arp
->ar_op
= htons(type
);
513 arp_ptr
= (unsigned char *)(arp
+ 1);
514 memcpy(arp_ptr
, np
->dev
->dev_addr
, np
->dev
->addr_len
);
515 arp_ptr
+= np
->dev
->addr_len
;
516 memcpy(arp_ptr
, &tip
, 4);
518 memcpy(arp_ptr
, sha
, np
->dev
->addr_len
);
519 arp_ptr
+= np
->dev
->addr_len
;
520 memcpy(arp_ptr
, &sip
, 4);
522 netpoll_send_skb(np
, send_skb
);
524 /* If there are several rx_hooks for the same address,
525 we're fine by sending a single reply */
528 spin_unlock_irqrestore(&npinfo
->rx_lock
, flags
);
531 int __netpoll_rx(struct sk_buff
*skb
)
533 int proto
, len
, ulen
;
537 struct netpoll_info
*npinfo
= skb
->dev
->npinfo
;
538 struct netpoll
*np
, *tmp
;
540 if (list_empty(&npinfo
->rx_np
))
543 if (skb
->dev
->type
!= ARPHRD_ETHER
)
546 /* check if netpoll clients need ARP */
547 if (skb
->protocol
== htons(ETH_P_ARP
) &&
548 atomic_read(&trapped
)) {
549 skb_queue_tail(&npinfo
->arp_tx
, skb
);
553 proto
= ntohs(eth_hdr(skb
)->h_proto
);
554 if (proto
!= ETH_P_IP
)
556 if (skb
->pkt_type
== PACKET_OTHERHOST
)
561 iph
= (struct iphdr
*)skb
->data
;
562 if (!pskb_may_pull(skb
, sizeof(struct iphdr
)))
564 if (iph
->ihl
< 5 || iph
->version
!= 4)
566 if (!pskb_may_pull(skb
, iph
->ihl
*4))
568 if (ip_fast_csum((u8
*)iph
, iph
->ihl
) != 0)
571 len
= ntohs(iph
->tot_len
);
572 if (skb
->len
< len
|| len
< iph
->ihl
*4)
576 * Our transport medium may have padded the buffer out.
577 * Now We trim to the true length of the frame.
579 if (pskb_trim_rcsum(skb
, len
))
582 if (iph
->protocol
!= IPPROTO_UDP
)
586 uh
= (struct udphdr
*)(((char *)iph
) + iph
->ihl
*4);
587 ulen
= ntohs(uh
->len
);
591 if (checksum_udp(skb
, uh
, ulen
, iph
->saddr
, iph
->daddr
))
594 list_for_each_entry_safe(np
, tmp
, &npinfo
->rx_np
, rx
) {
595 if (np
->local_ip
&& np
->local_ip
!= iph
->daddr
)
597 if (np
->remote_ip
&& np
->remote_ip
!= iph
->saddr
)
599 if (np
->local_port
&& np
->local_port
!= ntohs(uh
->dest
))
602 np
->rx_hook(np
, ntohs(uh
->source
),
604 ulen
- sizeof(struct udphdr
));
615 if (atomic_read(&trapped
)) {
623 void netpoll_print_options(struct netpoll
*np
)
625 printk(KERN_INFO
"%s: local port %d\n",
626 np
->name
, np
->local_port
);
627 printk(KERN_INFO
"%s: local IP %pI4\n",
628 np
->name
, &np
->local_ip
);
629 printk(KERN_INFO
"%s: interface '%s'\n",
630 np
->name
, np
->dev_name
);
631 printk(KERN_INFO
"%s: remote port %d\n",
632 np
->name
, np
->remote_port
);
633 printk(KERN_INFO
"%s: remote IP %pI4\n",
634 np
->name
, &np
->remote_ip
);
635 printk(KERN_INFO
"%s: remote ethernet address %pM\n",
636 np
->name
, np
->remote_mac
);
638 EXPORT_SYMBOL(netpoll_print_options
);
640 int netpoll_parse_options(struct netpoll
*np
, char *opt
)
642 char *cur
=opt
, *delim
;
645 if ((delim
= strchr(cur
, '@')) == NULL
)
648 np
->local_port
= simple_strtol(cur
, NULL
, 10);
654 if ((delim
= strchr(cur
, '/')) == NULL
)
657 np
->local_ip
= in_aton(cur
);
663 /* parse out dev name */
664 if ((delim
= strchr(cur
, ',')) == NULL
)
667 strlcpy(np
->dev_name
, cur
, sizeof(np
->dev_name
));
674 if ((delim
= strchr(cur
, '@')) == NULL
)
677 if (*cur
== ' ' || *cur
== '\t')
678 printk(KERN_INFO
"%s: warning: whitespace"
679 "is not allowed\n", np
->name
);
680 np
->remote_port
= simple_strtol(cur
, NULL
, 10);
686 if ((delim
= strchr(cur
, '/')) == NULL
)
689 np
->remote_ip
= in_aton(cur
);
694 if ((delim
= strchr(cur
, ':')) == NULL
)
697 np
->remote_mac
[0] = simple_strtol(cur
, NULL
, 16);
699 if ((delim
= strchr(cur
, ':')) == NULL
)
702 np
->remote_mac
[1] = simple_strtol(cur
, NULL
, 16);
704 if ((delim
= strchr(cur
, ':')) == NULL
)
707 np
->remote_mac
[2] = simple_strtol(cur
, NULL
, 16);
709 if ((delim
= strchr(cur
, ':')) == NULL
)
712 np
->remote_mac
[3] = simple_strtol(cur
, NULL
, 16);
714 if ((delim
= strchr(cur
, ':')) == NULL
)
717 np
->remote_mac
[4] = simple_strtol(cur
, NULL
, 16);
719 np
->remote_mac
[5] = simple_strtol(cur
, NULL
, 16);
722 netpoll_print_options(np
);
727 printk(KERN_INFO
"%s: couldn't parse config at '%s'!\n",
731 EXPORT_SYMBOL(netpoll_parse_options
);
733 int __netpoll_setup(struct netpoll
*np
)
735 struct net_device
*ndev
= np
->dev
;
736 struct netpoll_info
*npinfo
;
737 const struct net_device_ops
*ops
;
741 if ((ndev
->priv_flags
& IFF_DISABLE_NETPOLL
) ||
742 !ndev
->netdev_ops
->ndo_poll_controller
) {
743 printk(KERN_ERR
"%s: %s doesn't support polling, aborting.\n",
744 np
->name
, np
->dev_name
);
750 npinfo
= kmalloc(sizeof(*npinfo
), GFP_KERNEL
);
756 npinfo
->rx_flags
= 0;
757 INIT_LIST_HEAD(&npinfo
->rx_np
);
759 spin_lock_init(&npinfo
->rx_lock
);
760 skb_queue_head_init(&npinfo
->arp_tx
);
761 skb_queue_head_init(&npinfo
->txq
);
762 INIT_DELAYED_WORK(&npinfo
->tx_work
, queue_process
);
764 atomic_set(&npinfo
->refcnt
, 1);
766 ops
= np
->dev
->netdev_ops
;
767 if (ops
->ndo_netpoll_setup
) {
768 err
= ops
->ndo_netpoll_setup(ndev
, npinfo
);
773 npinfo
= ndev
->npinfo
;
774 atomic_inc(&npinfo
->refcnt
);
777 npinfo
->netpoll
= np
;
780 spin_lock_irqsave(&npinfo
->rx_lock
, flags
);
781 npinfo
->rx_flags
|= NETPOLL_RX_ENABLED
;
782 list_add_tail(&np
->rx
, &npinfo
->rx_np
);
783 spin_unlock_irqrestore(&npinfo
->rx_lock
, flags
);
786 /* last thing to do is link it to the net device structure */
787 rcu_assign_pointer(ndev
->npinfo
, npinfo
);
796 EXPORT_SYMBOL_GPL(__netpoll_setup
);
798 int netpoll_setup(struct netpoll
*np
)
800 struct net_device
*ndev
= NULL
;
801 struct in_device
*in_dev
;
805 ndev
= dev_get_by_name(&init_net
, np
->dev_name
);
807 printk(KERN_ERR
"%s: %s doesn't exist, aborting.\n",
808 np
->name
, np
->dev_name
);
812 if (!netif_running(ndev
)) {
813 unsigned long atmost
, atleast
;
815 printk(KERN_INFO
"%s: device %s not up yet, forcing it\n",
816 np
->name
, np
->dev_name
);
819 err
= dev_open(ndev
);
823 printk(KERN_ERR
"%s: failed to open %s\n",
824 np
->name
, ndev
->name
);
828 atleast
= jiffies
+ HZ
/10;
829 atmost
= jiffies
+ carrier_timeout
* HZ
;
830 while (!netif_carrier_ok(ndev
)) {
831 if (time_after(jiffies
, atmost
)) {
833 "%s: timeout waiting for carrier\n",
840 /* If carrier appears to come up instantly, we don't
841 * trust it and pause so that we don't pump all our
842 * queued console messages into the bitbucket.
845 if (time_before(jiffies
, atleast
)) {
846 printk(KERN_NOTICE
"%s: carrier detect appears"
847 " untrustworthy, waiting 4 seconds\n",
855 in_dev
= __in_dev_get_rcu(ndev
);
857 if (!in_dev
|| !in_dev
->ifa_list
) {
859 printk(KERN_ERR
"%s: no IP address for %s, aborting\n",
860 np
->name
, np
->dev_name
);
865 np
->local_ip
= in_dev
->ifa_list
->ifa_local
;
867 printk(KERN_INFO
"%s: local IP %pI4\n", np
->name
, &np
->local_ip
);
872 /* fill up the skb queue */
876 err
= __netpoll_setup(np
);
888 EXPORT_SYMBOL(netpoll_setup
);
890 static int __init
netpoll_init(void)
892 skb_queue_head_init(&skb_pool
);
895 core_initcall(netpoll_init
);
897 void __netpoll_cleanup(struct netpoll
*np
)
899 struct netpoll_info
*npinfo
;
902 npinfo
= np
->dev
->npinfo
;
906 if (!list_empty(&npinfo
->rx_np
)) {
907 spin_lock_irqsave(&npinfo
->rx_lock
, flags
);
909 if (list_empty(&npinfo
->rx_np
))
910 npinfo
->rx_flags
&= ~NETPOLL_RX_ENABLED
;
911 spin_unlock_irqrestore(&npinfo
->rx_lock
, flags
);
914 if (atomic_dec_and_test(&npinfo
->refcnt
)) {
915 const struct net_device_ops
*ops
;
917 ops
= np
->dev
->netdev_ops
;
918 if (ops
->ndo_netpoll_cleanup
)
919 ops
->ndo_netpoll_cleanup(np
->dev
);
921 rcu_assign_pointer(np
->dev
->npinfo
, NULL
);
923 /* avoid racing with NAPI reading npinfo */
924 synchronize_rcu_bh();
926 skb_queue_purge(&npinfo
->arp_tx
);
927 skb_queue_purge(&npinfo
->txq
);
928 cancel_rearming_delayed_work(&npinfo
->tx_work
);
930 /* clean after last, unfinished work */
931 __skb_queue_purge(&npinfo
->txq
);
935 EXPORT_SYMBOL_GPL(__netpoll_cleanup
);
937 void netpoll_cleanup(struct netpoll
*np
)
943 __netpoll_cleanup(np
);
949 EXPORT_SYMBOL(netpoll_cleanup
);
951 int netpoll_trap(void)
953 return atomic_read(&trapped
);
955 EXPORT_SYMBOL(netpoll_trap
);
957 void netpoll_set_trap(int trap
)
960 atomic_inc(&trapped
);
962 atomic_dec(&trapped
);
964 EXPORT_SYMBOL(netpoll_set_trap
);
This page took 0.049011 seconds and 5 git commands to generate.