自学教程：C++ waitqueue_active函数代码示例

/* * abort_exclusive_wait - abort exclusive waiting in a queue * @q: waitqueue waited on * @wait: wait descriptor * @state: runstate of the waiter to be woken * @key: key to identify a wait bit queue or %NULL * * Sets current thread back to running state and removes * the wait descriptor from the given waitqueue if still * queued. * * Wakes up the next waiter if the caller is concurrently * woken up through the queue. * * This prevents waiter starvation where an exclusive waiter * aborts and is woken up concurrently and noone wakes up * the next waiter. */void abort_exclusive_wait(wait_queue_head_t *q, wait_queue_t *wait,			unsigned int mode, void *key){	unsigned long flags;	__set_current_state(TASK_RUNNING);	spin_lock_irqsave(&q->lock, flags);	if (!list_empty(&wait->task_list))		list_del_init(&wait->task_list);	else if (waitqueue_active(q))		__wake_up_common(q, mode, 1, 0, key);	spin_unlock_irqrestore(&q->lock, flags);}

void _mali_osk_wait_queue_wake_up( _mali_osk_wait_queue_t *queue ){	MALI_DEBUG_ASSERT_POINTER( queue );	/* if queue is empty, don't attempt to wake up its elements */	if (!waitqueue_active(&queue->wait_queue)) return;	MALI_DEBUG_PRINT(6, ("Waking up elements in wait queue %p ..../n", queue));	wake_up_all(&queue->wait_queue);	MALI_DEBUG_PRINT(6, ("... elements in wait queue %p woken up/n", queue));}

/** * sk_stream_write_space - stream socket write_space callback. * @sk: socket * * FIXME: write proper description */void sk_stream_write_space(struct sock *sk){	struct socket *sock = sk->sk_socket;	if (sk_stream_wspace(sk) >= sk_stream_min_wspace(sk) && sock) {		clear_bit(SOCK_NOSPACE, &sock->flags);		if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))			wake_up_interruptible(sk->sk_sleep);		if (sock->fasync_list && !(sk->sk_shutdown & SEND_SHUTDOWN))			sock_wake_async(sock, 2, POLL_OUT);	}}

/* * wake up sync - echo event was catched */voidsnd_seq_oss_writeq_wakeup(seq_oss_writeq_t *q, abstime_t time){	unsigned long flags;	spin_lock_irqsave(&q->sync_lock, flags);	q->sync_time = time;	q->sync_event_put = 0;	if (waitqueue_active(&q->sync_sleep)) {		wake_up(&q->sync_sleep);	}	spin_unlock_irqrestore(&q->sync_lock, flags);}

/** * Free a buffer. * * /param dev DRM device. * /param buf buffer to free. *  * Resets the fields of /p buf. */void drm_free_buffer(drm_device_t *dev, drm_buf_t *buf){	if (!buf) return;	buf->waiting  = 0;	buf->pending  = 0;	buf->filp     = NULL;	buf->used     = 0;	if (drm_core_check_feature(dev, DRIVER_DMA_QUEUE) && waitqueue_active(&buf->dma_wait)) {		wake_up_interruptible(&buf->dma_wait);	}}

/** * shutdown - shutdown socket connection * @sock: socket structure * @how: direction to close (must be SHUT_RDWR) * * Terminates connection (if necessary), then purges socket's receive queue. * * Returns 0 on success, errno otherwise */static int shutdown(struct socket *sock, int how){	struct sock *sk = sock->sk;	struct tipc_port *tport = tipc_sk_port(sk);	struct sk_buff *buf;	int res;	if (how != SHUT_RDWR)		return -EINVAL;	lock_sock(sk);	switch (sock->state) {	case SS_CONNECTING:	case SS_CONNECTED:restart:		/* Disconnect and send a 'FIN+' or 'FIN-' message to peer */		buf = __skb_dequeue(&sk->sk_receive_queue);		if (buf) {			atomic_dec(&tipc_queue_size);			if (TIPC_SKB_CB(buf)->handle != 0) {				kfree_skb(buf);				goto restart;			}			tipc_disconnect(tport->ref);			tipc_reject_msg(buf, TIPC_CONN_SHUTDOWN);		} else {			tipc_shutdown(tport->ref);		}		sock->state = SS_DISCONNECTING;		/* fall through */	case SS_DISCONNECTING:		/* Discard any unreceived messages; wake up sleeping tasks */		discard_rx_queue(sk);		if (waitqueue_active(sk_sleep(sk)))			wake_up_interruptible(sk_sleep(sk));		res = 0;		break;	default:		res = -ENOTCONN;	}	release_sock(sk);	return res;}

/** * eventfd_signal - Adds @n to the eventfd counter. * @ctx: [in] Pointer to the eventfd context. * @n: [in] Value of the counter to be added to the eventfd internal counter. *          The value cannot be negative. * * This function is supposed to be called by the kernel in paths that do not * allow sleeping. In this function we allow the counter to reach the ULLONG_MAX * value, and we signal this as overflow condition by returining a POLLERR * to poll(2). * * Returns the amount by which the counter was incrememnted.  This will be less * than @n if the counter has overflowed. */__u64 eventfd_signal(struct eventfd_ctx *ctx, __u64 n){	unsigned long flags;	spin_lock_irqsave(&ctx->wqh.lock, flags);	if (ULLONG_MAX - ctx->count < n)		n = ULLONG_MAX - ctx->count;	ctx->count += n;	if (waitqueue_active(&ctx->wqh))		wake_up_locked_poll(&ctx->wqh, POLLIN);	spin_unlock_irqrestore(&ctx->wqh.lock, flags);	return n;}

/* * This gets called when the timer event triggers. We set the "expired" * flag, but we do not re-arm the timer (in case it's necessary, * interval.tv64 != 0) until the timer is accessed. */enum hrtimer_restart timerfd_callback(struct hrtimer *timer){  struct timerfd_ctx *ctx = container_of(timer, struct timerfd_ctx, timer);  unsigned long flags;  spin_lock_irqsave(&ctx->wqh.lock, flags);  ctx->expired = 1;  ctx->ticks++;  if (waitqueue_active(&ctx->wqh))    __wake_up_locked_keyPtr(&ctx->wqh, TASK_NORMAL, (void *) (POLLIN));  spin_unlock_irqrestore(&ctx->wqh.lock, flags);  return HRTIMER_NORESTART;}

void RESET_EVENT( EVENT_HNDL* pEvent ){	DWORD LockFlag;	// clear the event flag	ACQUIRE_LOCK( &pEvent->FlagLock, LockFlag );	pEvent->SetFlag = FALSE;	// empty out the queue	while ( waitqueue_active( &pEvent->WaitQue ) )		interruptible_sleep_on( &pEvent->WaitQue );	RELEASE_LOCK( &pEvent->FlagLock, LockFlag );}

void kvm_vcpu_kick(struct kvm_vcpu *vcpu){	int me;	int cpu = vcpu->cpu;	me = get_cpu();	if (waitqueue_active(vcpu->arch.wqp)) {		wake_up_interruptible(vcpu->arch.wqp);		vcpu->stat.halt_wakeup++;	} else if (cpu != me && cpu != -1) {		smp_send_reschedule(vcpu->cpu);	}	put_cpu();}

static irqreturn_t tmio_irq(int irq, void *__tmio){	struct tmio_nand *tmio = __tmio;	struct nand_chip *nand_chip = &tmio->chip;	/* disable RDYREQ interrupt */	tmio_iowrite8(0x00, tmio->fcr + FCR_IMR);	if (unlikely(!waitqueue_active(&nand_chip->controller->wq)))		dev_warn(&tmio->dev->dev, "spurious interrupt/n");	wake_up(&nand_chip->controller->wq);	return IRQ_HANDLED;}

void signalfd_cleanup(struct sighand_struct *sighand){	wait_queue_head_t *wqh = &sighand->signalfd_wqh;	/*                                                                                                                                                                                                           */	if (likely(!waitqueue_active(wqh)))		return;	/*                                                            */	wake_up_poll(wqh, POLLHUP | POLLFREE);}

/** * eventfd_ctx_remove_wait_queue - Read the current counter and removes wait queue. * @ctx: [in] Pointer to eventfd context. * @wait: [in] Wait queue to be removed. * @cnt: [out] Pointer to the 64-bit counter value. * * Returns %0 if successful, or the following error codes: * * -EAGAIN      : The operation would have blocked. * * This is used to atomically remove a wait queue entry from the eventfd wait * queue head, and read/reset the counter value. */int eventfd_ctx_remove_wait_queue(struct eventfd_ctx *ctx, wait_queue_t *wait,				  __u64 *cnt){	unsigned long flags;	spin_lock_irqsave(&ctx->wqh.lock, flags);	eventfd_ctx_do_read(ctx, cnt);	__remove_wait_queue(&ctx->wqh, wait);	if (*cnt != 0 && waitqueue_active(&ctx->wqh))		wake_up_locked_poll(&ctx->wqh, POLLOUT);	spin_unlock_irqrestore(&ctx->wqh.lock, flags);	return *cnt != 0 ? 0 : -EAGAIN;}

static voidkni_sk_write_space(struct sock *sk){	wait_queue_head_t *wqueue;	if (!sock_writeable(sk) ||	    !test_and_clear_bit(SOCK_ASYNC_NOSPACE,				&sk->sk_socket->flags))		return;	wqueue = sk_sleep(sk);	if (wqueue && waitqueue_active(wqueue))		wake_up_interruptible_poll(			wqueue, POLLOUT | POLLWRNORM | POLLWRBAND);}

void signalfd_cleanup(struct sighand_struct *sighand){	wait_queue_head_t *wqh = &sighand->signalfd_wqh;	/*	 * The lockless check can race with remove_wait_queue() in progress,	 * but in this case its caller should run under rcu_read_lock() and	 * sighand_cachep is SLAB_DESTROY_BY_RCU, we can safely return.	 */	if (likely(!waitqueue_active(wqh)))		return;	/* wait_queue_t->func(POLLFREE) should do remove_wait_queue() */	wake_up_poll(wqh, POLLHUP | POLLFREE);}

static ssize_t vloopback_write(struct file *f, const char *buf,		size_t count, loff_t *offset){	struct video_device *loopdev=video_devdata(f);#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27)	priv_ptr ptr=(priv_ptr)video_get_drvdata(loopdev);#else	priv_ptr ptr=(priv_ptr)loopdev->priv;#endif		int nr=ptr->pipenr;	unsigned long realcount=count;		if (!ptr->in)		return -EINVAL;	if (loops[nr]->zerocopy)		return -EINVAL;		if (loops[nr]->buffer==NULL) {		return -EINVAL;	}	/* Anybody want some pictures??? */	if (!waitqueue_active(&loops[nr]->wait)) {		/* No, waiting this makes the write op blocking */		wait_event_interruptible(loops[nr]->wait, loops[nr]->pendingread);	}		down(&loops[nr]->lock);	if (!loops[nr]->buffer) {		up(&loops[nr]->lock);		return -EINVAL;	}	if (realcount > loops[nr]->buflength) {		realcount = loops[nr]->buflength;		info("Too much data! Only %ld bytes used.", realcount);	}		if (copy_from_user(	    loops[nr]->buffer+loops[nr]->frame*loops[nr]->buflength,	    buf, realcount	)) return -EFAULT;	loops[nr]->frame=0;	up(&loops[nr]->lock);	loops[nr]->frameswrite++;	wake_up(&loops[nr]->wait);	return realcount;}

int kvm_vcpu_ioctl_interrupt(struct kvm_vcpu *vcpu, struct kvm_interrupt *irq){	if (irq->irq == KVM_INTERRUPT_UNSET)		kvmppc_core_dequeue_external(vcpu, irq);	else		kvmppc_core_queue_external(vcpu, irq);	if (waitqueue_active(&vcpu->wq)) {		wake_up_interruptible(&vcpu->wq);		vcpu->stat.halt_wakeup++;	}	return 0;}

static int osprd_close_last(struct inode *inode, struct file *filp){	int r;	r = 0;	if (filp) {		osprd_info_t *d = file2osprd(filp);		int filp_writable = filp->f_mode & FMODE_WRITE;		// EXERCISE: If the user closes a ramdisk file that holds		// a lock, release the lock.  Also wake up blocked processes		// as appropriate.		//r = osprd_ioctl (inode, filp, OSPRDIOCRELEASE, 0);		// Your code here.		// This line avoids compiler warnings; you may remove it.		(void) filp_writable, (void) d;		if (!(filp->f_flags & F_OSPRD_LOCKED))			{r = -EINVAL; }				// Otherwise, clear the lock from filp->f_flags, wake up		// the wait queue, perform any additional accounting steps		// you need, and return 0.		else 		{			osp_spin_lock(&(d->mutex));			// Clear lock flag.			filp->f_flags &= ~F_OSPRD_LOCKED;			//d->mutex.lock = 0;			d->n_writel = 0;			d->n_readl = 0;			d->dead = 0;							// Wake queue.			if(waitqueue_active(&d->blockq) == 0){				//eprintk("Tail: %d head: %d/n", d->ticket_tail, d->ticket_head);								//d->ticket_head = d->ticket_tail;				d->ticket_tail += d->desync;				d->desync = 0;			}			osp_spin_unlock(&(d->mutex));				wake_up_all(&d->blockq);									r = 0;		}	}	return r;}

static bool dna_e1000e_clean_rx_irq(struct e1000_adapter *adapter) {  bool ret;  int i, debug = 0;  struct e1000_ring *rx_ring = adapter->rx_ring;  union e1000_rx_desc_extended *rx_desc;  struct e1000_buffer *buffer_info;  struct e1000_hw *hw = &adapter->hw;  u32 staterr;  /* The register contains the last packet that we have read */  i = E1000_READ_REG(hw, E1000_RDT(0));  if(++i == rx_ring->count)    i = 0;  rx_ring->next_to_clean = i;   rx_desc = E1000_RX_DESC_EXT(*rx_ring, i);  staterr = le32_to_cpu(rx_desc->wb.upper.status_error);  buffer_info = &rx_ring->buffer_info[i];    if(unlikely(debug))    printk(KERN_INFO	   "DNA: dna_e1000_clean_rx_irq(%s)[id=%d][status=%d][rx_reg=%u]/n",	   adapter->netdev->name, i, staterr,	   E1000_READ_REG(&adapter->hw, E1000_RDT(0)));  if(staterr & E1000_RXD_STAT_DD) {    if(!adapter->dna.interrupt_received) {      if(waitqueue_active(&adapter->dna.packet_waitqueue)) {	wake_up_interruptible(&adapter->dna.packet_waitqueue);	adapter->dna.interrupt_received = 1;	if(unlikely(debug))	  printk(KERN_WARNING "DNA: dna_e1000_clean_rx_irq(%s): "		 "woken up [slot=%d] XXXX/n", adapter->netdev->name, i);      }    }    if(unlikely(debug))      printk(KERN_WARNING "DNA: dna_e1000_clean_rx_irq(%s): "	     "woken up [slot=%d][interrupt_received=%d]/n",	     adapter->netdev->name, i, adapter->dna.interrupt_received);    ret = TRUE;  } else    ret = FALSE;  return(ret);		}

static ssize_t tier_attr_internals_show(struct tier_device *dev,                                               char *buf){        char *iotype;        char *iopending;        char *qlock;        char *aiowq;        char *discard;#ifndef MAX_PERFORMANCE        char *debug_state;#endif        int res = 0;               if (atomic_read(&dev->migrate) == MIGRATION_IO)             iotype = as_sprintf("iotype (normal or migration) : migration_io/n");        else if (atomic_read(&dev->wqlock))            iotype = as_sprintf("iotype (normal or migration) : normal_io/n");        else            iotype = as_sprintf("iotype (normal or migration) : no activity/n");        iopending =  as_sprintf("async random ios pending     : %i/n", atomic_read(&dev->aio_pending));        if ( mutex_is_locked(&dev->qlock))             qlock = as_sprintf("main mutex                   : locked/n");        else qlock = as_sprintf("main mutex                   : unlocked/n");        if (waitqueue_active(&dev->aio_event))              aiowq = as_sprintf("waiting on asynchrounous io  : True/n");        else              aiowq = as_sprintf("waiting on asynchrounous io  : False/n");#ifndef MAX_PERFORMANCE        spin_lock(&dev->dbg_lock);        if (dev->debug_state & DISCARD)           discard = as_sprintf("discard request is pending   : True/n");        else            discard = as_sprintf("discard request is pending   : False/n");        debug_state = as_sprintf("debug state                  : %i/n", dev->debug_state);        spin_unlock(&dev->dbg_lock);        res = sprintf(buf, "%s%s%s%s%s%s", iotype, iopending, qlock, aiowq, discard, debug_state);#else        res = sprintf(buf, "%s%s%s%s", iotype, iopending, qlock, aiowq);#endif        kfree(iotype);        kfree(iopending);        kfree(qlock);        kfree(aiowq);#ifndef MAX_PERFORMANCE        kfree(discard);        kfree(debug_state);#endif        return res;}

/* Select who will handle tx completion: * - a write is pending - wake it up and let it do the poll + post * - post handler is taken - taker will do the poll + post * else return 1 and let the caller do it */static int sdp_tx_handler_select(struct sdp_sock *ssk){	struct sock *sk = sk_ssk(ssk);	if (sk->sk_write_pending) {		/* Do the TX posts from sender context */		if (sdp_sk_sleep(sk) && waitqueue_active(sdp_sk_sleep(sk))) {			sdp_prf1(sk, NULL, "Waking up pending sendmsg");			wake_up_interruptible(sdp_sk_sleep(sk));			return 0;		} else			sdp_prf1(sk, NULL, "Unexpected: sk_sleep=%p, "				"waitqueue_active: %d/n",				sdp_sk_sleep(sk), waitqueue_active(sdp_sk_sleep(sk)));	}	if (posts_handler(ssk)) {		/* Somebody else available to check for completion */		sdp_prf1(sk, NULL, "Somebody else will call do_posts");		return 0;	}	return 1;}

static void __kaio_queue_fsync_req(struct ploop_request * preq, int prio){    struct ploop_device * plo   = preq->plo;    struct ploop_delta  * delta = ploop_top_delta(plo);    struct ploop_io     * io    = &delta->io;    if (prio)        list_add(&preq->list, &io->fsync_queue);    else        list_add_tail(&preq->list, &io->fsync_queue);    io->fsync_qlen++;    if (waitqueue_active(&io->fsync_waitq))        wake_up_interruptible(&io->fsync_waitq);}

int btrfs_tree_unlock(struct extent_buffer *eb){	/*	 * if we were a blocking owner, we don't have the spinlock held	 * just clear the bit and look for waiters	 */	if (test_and_clear_bit(EXTENT_BUFFER_BLOCKING, &eb->bflags))		smp_mb__after_clear_bit();	else		spin_unlock(&eb->lock);	if (waitqueue_active(&eb->lock_wq))		wake_up(&eb->lock_wq);	return 0;}

_mali_osk_wait_queue_t *_mali_osk_wait_queue_init(void){	_mali_osk_wait_queue_t *ret = NULL;	ret = kmalloc(sizeof(_mali_osk_wait_queue_t), GFP_KERNEL);	if (NULL == ret) {		return ret;	}	init_waitqueue_head(&ret->wait_queue);	MALI_DEBUG_ASSERT(!waitqueue_active(&ret->wait_queue));	return ret;}

static irqreturn_t aml_demod_isr(int irq, void *dev_id){    if (demod_sta.dvb_mode == 0) {	//dvbc_isr(&demod_sta);	if(dvbc_isr_islock()){		printk("sync4/n");		if(waitqueue_active(&lock_wq))			wake_up_interruptible(&lock_wq);	}    }    else {	dvbt_isr(&demod_sta);    }    return IRQ_HANDLED;}

static ssize_t eventfd_write(struct file *file, const char __user *buf, size_t count,			     loff_t *ppos){	struct eventfd_ctx *ctx = file->private_data;	ssize_t res;	__u64 ucnt;	DECLARE_WAITQUEUE(wait, current);	if (count < sizeof(ucnt))		return -EINVAL;	if (copy_from_user(&ucnt, buf, sizeof(ucnt)))		return -EFAULT;	if (ucnt == ULLONG_MAX)		return -EINVAL;	spin_lock_irq(&ctx->wqh.lock);	res = -EAGAIN;	if (ULLONG_MAX - ctx->count > ucnt)		res = sizeof(ucnt);	else if (!(file->f_flags & O_NONBLOCK)) {		__add_wait_queue(&ctx->wqh, &wait);		for (res = 0;;) {			set_current_state(TASK_INTERRUPTIBLE);			if (ULLONG_MAX - ctx->count > ucnt) {				res = sizeof(ucnt);				break;			}			if (signal_pending(current)) {				res = -ERESTARTSYS;				break;			}			spin_unlock_irq(&ctx->wqh.lock);			schedule();			spin_lock_irq(&ctx->wqh.lock);		}		__remove_wait_queue(&ctx->wqh, &wait);		__set_current_state(TASK_RUNNING);	}	if (likely(res > 0)) {		ctx->count += ucnt;		if (waitqueue_active(&ctx->wqh))			wake_up_locked_poll(&ctx->wqh, POLLIN);	}	spin_unlock_irq(&ctx->wqh.lock);	return res;}

void ext4_free_io_end(ext4_io_end_t *io){	int i;	wait_queue_head_t *wq;	BUG_ON(!io);	if (io->page)		put_page(io->page);	for (i = 0; i < io->num_io_pages; i++)		put_io_page(io->pages[i]);	io->num_io_pages = 0;	wq = ext4_ioend_wq(io->inode);	if (atomic_dec_and_test(&EXT4_I(io->inode)->i_ioend_count) &&	    waitqueue_active(wq))		wake_up_all(wq);	kmem_cache_free(io_end_cachep, io);}

static ssize_t eventfd_read(struct file *file, char __user *buf, size_t count,			    loff_t *ppos){	struct eventfd_ctx *ctx = file->private_data;	ssize_t res;	__u64 ucnt;	DECLARE_WAITQUEUE(wait, current);	if (count < sizeof(ucnt))		return -EINVAL;	spin_lock_irq(&ctx->wqh.lock);	res = -EAGAIN;	ucnt = ctx->count;	if (ucnt > 0)		res = sizeof(ucnt);	else if (!(file->f_flags & O_NONBLOCK)) {		__add_wait_queue(&ctx->wqh, &wait);		for (res = 0;;) {			set_current_state(TASK_INTERRUPTIBLE);			if (ctx->count > 0) {				ucnt = ctx->count;				res = sizeof(ucnt);				break;			}			if (signal_pending(current)) {				res = -ERESTARTSYS;				break;			}			spin_unlock_irq(&ctx->wqh.lock);			schedule();			spin_lock_irq(&ctx->wqh.lock);		}		__remove_wait_queue(&ctx->wqh, &wait);		__set_current_state(TASK_RUNNING);	}	if (res > 0) {		ctx->count = 0;		if (waitqueue_active(&ctx->wqh))			wake_up_locked(&ctx->wqh);	}	spin_unlock_irq(&ctx->wqh.lock);	if (res > 0 && put_user(ucnt, (__u64 __user *) buf))		return -EFAULT;	return res;}