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

static void play_delayed(struct usb_serial_port *port){	struct hsictty_intf_private *data;	struct hsictty_port_private *portdata;	struct urb *urb;	int err;	portdata = usb_get_serial_port_data(port);	data = usb_get_serial_data(port->serial);	while ((urb = usb_get_from_anchor(&portdata->delayed_urb))) {		err = usb_submit_urb(urb, GFP_ATOMIC);		if (!err) {			hsictty_dbg			    ("%s re-submit URB %p, write data may lost/n",			     __func__, urb);			data->in_flight++;		} else {			/* we have to throw away the rest */			hsictty_error			    ("%s re-submit flight URB error, write data may lost/n",			     __func__);			do {				unbusy_queued_urb(urb, portdata);				usb_autopm_put_interface_no_suspend				    (port->serial->interface);			} while ((urb =				  usb_get_from_anchor(&portdata->delayed_urb)));			break;		}	}}

static void rtl_usb_stop(struct ieee80211_hw *hw){	struct rtl_priv *rtlpriv = rtl_priv(hw);	struct rtl_hal *rtlhal = rtl_hal(rtl_priv(hw));	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));	struct urb *urb;	/* should after adapter start and interrupt enable. */	set_hal_stop(rtlhal);	cancel_work_sync(&rtlpriv->works.fill_h2c_cmd);	/* Enable software */	SET_USB_STOP(rtlusb);	rtl_usb_deinit(hw);	/* free pre-allocated URBs from rtl_usb_start() */	usb_kill_anchored_urbs(&rtlusb->rx_submitted);	tasklet_kill(&rtlusb->rx_work_tasklet);	cancel_work_sync(&rtlpriv->works.lps_change_work);	flush_workqueue(rtlpriv->works.rtl_wq);	skb_queue_purge(&rtlusb->rx_queue);	while ((urb = usb_get_from_anchor(&rtlusb->rx_cleanup_urbs))) {		usb_free_coherent(urb->dev, urb->transfer_buffer_length,				urb->transfer_buffer, urb->transfer_dma);		usb_free_urb(urb);	}	rtlpriv->cfg->ops->hw_disable(hw);}

static void acm_port_shutdown(struct tty_port *port){	struct acm *acm = container_of(port, struct acm, port);	struct urb *urb;	struct acm_wb *wb;	int i;	int pm_err;	dev_dbg(&acm->control->dev, "%s/n", __func__);	mutex_lock(&acm->mutex);	if (!acm->disconnected) {		pm_err = usb_autopm_get_interface(acm->control);		acm_set_control(acm, acm->ctrlout = 0);		for (;;) {			urb = usb_get_from_anchor(&acm->delayed);			if (!urb)				break;			wb = urb->context;			wb->use = 0;			usb_autopm_put_interface_async(acm->control);		}		usb_kill_urb(acm->ctrlurb);		for (i = 0; i < ACM_NW; i++)			usb_kill_urb(acm->wb[i].urb);		for (i = 0; i < acm->rx_buflimit; i++)			usb_kill_urb(acm->read_urbs[i]);		acm->control->needs_remote_wakeup = 0;		if (!pm_err)			usb_autopm_put_interface(acm->control);	}	mutex_unlock(&acm->mutex);}

int usbnet_resume (struct usb_interface *intf){	struct usbnet		*dev = usb_get_intfdata(intf);	struct sk_buff          *skb;	struct urb              *res;	int                     retval;	if (!--dev->suspend_count) {		spin_lock_irq(&dev->txq.lock);		while ((res = usb_get_from_anchor(&dev->deferred))) {			printk(KERN_INFO"%s has delayed data/n", __func__);			skb = (struct sk_buff *)res->context;			retval = usb_submit_urb(res, GFP_ATOMIC);			if (retval < 0) {				dev_kfree_skb_any(skb);				usb_free_urb(res);				usb_autopm_put_interface_async(dev->intf);			} else {				dev->net->trans_start = jiffies;				__skb_queue_tail(&dev->txq, skb);			}		}		smp_mb();		clear_bit(EVENT_DEV_ASLEEP, &dev->flags);		spin_unlock_irq(&dev->txq.lock);		if (!(dev->txq.qlen >= TX_QLEN(dev)))			netif_start_queue(dev->net);		tasklet_schedule (&dev->bh);	}	return 0;}

static void r92su_tx_schedule(struct r92su *r92su){	struct urb *urb;	int err;	if (atomic_inc_return(&r92su->tx_pending_urbs) >	    RTL_USB_MAX_TX_URBS_NUM)		goto err_acc;	urb = usb_get_from_anchor(&r92su->tx_wait);	if (!urb)		goto err_acc;	usb_anchor_urb(urb, &r92su->tx_submitted);	err = usb_submit_urb(urb, GFP_ATOMIC);	if (err) {		WARN_ONCE(err, "can't handle urb submit error %d", err);		usb_unanchor_urb(urb);		r92su_mark_dead(r92su);		dev_kfree_skb_any(urb->context);	}	usb_free_urb(urb);	if (likely(err == 0))		return;err_acc:	atomic_dec(&r92su->tx_pending_urbs);}

static int ar9170_usb_flush(struct ar9170 *ar){	struct ar9170_usb *aru = (void *) ar;	struct urb *urb;	int ret, err = 0;	if (IS_STARTED(ar))		aru->common.state = AR9170_IDLE;	usb_wait_anchor_empty_timeout(&aru->tx_pending,					    msecs_to_jiffies(800));	while ((urb = usb_get_from_anchor(&aru->tx_pending))) {		ar9170_tx_callback(&aru->common, (void *) urb->context);		usb_free_urb(urb);	}	/* lets wait a while until the tx - queues are dried out */	ret = usb_wait_anchor_empty_timeout(&aru->tx_submitted,					    msecs_to_jiffies(100));	if (ret == 0)		err = -ETIMEDOUT;	usb_kill_anchored_urbs(&aru->tx_submitted);	if (IS_ACCEPTING_CMD(ar))		aru->common.state = AR9170_STARTED;	return err;}

static int carl9170_usb_submit_cmd_urb(struct ar9170 *ar){	struct urb *urb;	int err;	if (atomic_inc_return(&ar->tx_cmd_urbs) != 1) {		atomic_dec(&ar->tx_cmd_urbs);		return 0;	}	urb = usb_get_from_anchor(&ar->tx_cmd);	if (!urb) {		atomic_dec(&ar->tx_cmd_urbs);		return 0;	}	usb_anchor_urb(urb, &ar->tx_anch);	err = usb_submit_urb(urb, GFP_ATOMIC);	if (unlikely(err)) {		usb_unanchor_urb(urb);		atomic_dec(&ar->tx_cmd_urbs);	}	usb_free_urb(urb);	return err;}

static int carl9170_usb_flush(struct ar9170 *ar){	struct urb *urb;	int ret, err = 0;	while ((urb = usb_get_from_anchor(&ar->tx_wait))) {		struct sk_buff *skb = (void *)urb->context;		carl9170_tx_drop(ar, skb);		carl9170_tx_callback(ar, skb);		usb_free_urb(urb);	}	ret = usb_wait_anchor_empty_timeout(&ar->tx_cmd, 1000);	if (ret == 0)		err = -ETIMEDOUT;	/* lets wait a while until the tx - queues are dried out */	ret = usb_wait_anchor_empty_timeout(&ar->tx_anch, 1000);	if (ret == 0)		err = -ETIMEDOUT;	usb_kill_anchored_urbs(&ar->tx_anch);	carl9170_usb_handle_tx_err(ar);	return err;}

static int carl9170_usb_submit_rx_urb(struct ar9170 *ar, gfp_t gfp){	struct urb *urb;	int err = 0, runs = 0;	while ((atomic_read(&ar->rx_anch_urbs) < AR9170_NUM_RX_URBS) &&		(runs++ < AR9170_NUM_RX_URBS)) {		err = -ENOSPC;		urb = usb_get_from_anchor(&ar->rx_pool);		if (urb) {			usb_anchor_urb(urb, &ar->rx_anch);			err = usb_submit_urb(urb, gfp);			if (unlikely(err)) {				usb_unanchor_urb(urb);				usb_anchor_urb(urb, &ar->rx_pool);			} else {				atomic_dec(&ar->rx_pool_urbs);				atomic_inc(&ar->rx_anch_urbs);			}			usb_free_urb(urb);		}	}	return err;}

static void carl9170_usb_submit_data_urb(struct ar9170 *ar){	struct urb *urb;	int err;	if (atomic_inc_return(&ar->tx_anch_urbs) > AR9170_NUM_TX_URBS)		goto err_acc;	urb = usb_get_from_anchor(&ar->tx_wait);	if (!urb)		goto err_acc;	usb_anchor_urb(urb, &ar->tx_anch);	err = usb_submit_urb(urb, GFP_ATOMIC);	if (unlikely(err)) {		if (net_ratelimit()) {			dev_err(&ar->udev->dev, "tx submit failed (%d)/n",				urb->status);		}		usb_unanchor_urb(urb);		usb_anchor_urb(urb, &ar->tx_err);	}	usb_free_urb(urb);	if (likely(err == 0))		return;err_acc:	atomic_dec(&ar->tx_anch_urbs);}

static void acm_port_down(struct acm *acm){	struct urb *urb;	struct acm_wb *wb;	int i;	if (acm->dev) {		usb_autopm_get_interface(acm->control);		acm_set_control(acm, acm->ctrlout = 0);		for (;;) {			urb = usb_get_from_anchor(&acm->delayed);			if (!urb)				break;			wb = urb->context;			wb->use = 0;			usb_autopm_put_interface_async(acm->control);		}		usb_kill_urb(acm->ctrlurb);		for (i = 0; i < ACM_NW; i++)			usb_kill_urb(acm->wb[i].urb);		for (i = 0; i < acm->rx_buflimit; i++)			usb_kill_urb(acm->read_urbs[i]);		acm->control->needs_remote_wakeup = 0;		usb_autopm_put_interface(acm->control);	}}

static void baseband_usb_driver_disconnect(struct usb_interface *intf){	int i, j;	struct urb *urb;	pr_debug("%s intf %p/n", __func__, intf);	for (i = 0; i < max_intfs; i++) {		pr_debug("[%d]/n", i);		if (!baseband_usb_net[i])			continue;		if (baseband_usb_net[i]->usb.interface != intf) {			pr_debug("%p != %p/n",				baseband_usb_net[i]->usb.interface, intf);			continue;		}		/* acquire semaphore */		if (down_interruptible(&baseband_usb_net[i]->sem)) {			pr_err("%s: cannot acquire semaphore/n", __func__);			continue;		}		/* kill usb tx */		while ((urb = usb_get_from_anchor(&baseband_usb_net[i]->			usb.tx_urb_deferred)) != (struct urb *) 0) {			pr_info("%s: kill deferred tx urb %p/n",				__func__, urb);			/* decrement count from usb_get_from_anchor() */			usb_free_urb(urb);			/* kill tx urb */			usb_kill_urb(urb);			/* free tx urb + tx urb transfer buffer */			if (urb->transfer_buffer) {				kfree(urb->transfer_buffer);				urb->transfer_buffer = (void *) 0;			}			usb_free_urb(urb);		}		if (baseband_usb_net[i]->usb.tx_workqueue) {			flush_workqueue(baseband_usb_net[i]				->usb.tx_workqueue);		}		if (baseband_usb_net[i]->usb.tx_urb) {			usb_kill_urb(baseband_usb_net[i]->usb.tx_urb);			baseband_usb_net[i]->usb.tx_urb				= (struct urb *) 0;		}		/* kill usb rx */		for (j = 0; j < RAWIP_RX_BUFS; j++)			usb_kill_urb(baseband_usb_net[i]->urb_r[j]);		baseband_usb_net[i]->usb.rx_urb	= (struct urb *) 0;		/* mark interface as disconnected */		baseband_usb_net[i]->usb.interface			= (struct usb_interface *) 0;		/* release semaphore */		up(&baseband_usb_net[i]->sem);	}}

void carl9170_usb_handle_tx_err(struct ar9170 *ar){	struct urb *urb;	while ((urb = usb_get_from_anchor(&ar->tx_err))) {		struct sk_buff *skb = (void *)urb->context;		carl9170_tx_drop(ar, skb);		carl9170_tx_callback(ar, skb);		usb_free_urb(urb);	}}

static void atusb_free_urbs(struct atusb *atusb){	struct urb *urb;	while (1) {		urb = usb_get_from_anchor(&atusb->idle_urbs);		if (!urb)			break;		kfree_skb(urb->context);		usb_free_urb(urb);	}}

static void play_deferred(struct btusb_data *data){	struct urb *urb;	int err;	while ((urb = usb_get_from_anchor(&data->deferred))) {		err = usb_submit_urb(urb, GFP_ATOMIC);		if (err < 0)			break;		data->tx_in_flight++;	}	usb_scuttle_anchored_urbs(&data->deferred);}

static voidusb_free_urbs(struct usb_link_device *usb_ld, struct if_usb_devdata *pipe){	struct usb_device *usbdev = usb_ld->usbdev;	struct urb *urb;	while ((urb = usb_get_from_anchor(&pipe->urbs))) {		usb_poison_urb(urb);		usb_free_coherent(usbdev, pipe->rx_buf_size,				urb->transfer_buffer, urb->transfer_dma);		urb->transfer_buffer = NULL;		usb_put_urb(urb);		usb_free_urb(urb);	}}

/** * free_anchored_buffers - free device's anchored items * @mdev: the device * @channel: channel ID * @status: status of MBO termination */static void free_anchored_buffers(struct most_dev *mdev, unsigned int channel,				  enum mbo_status_flags status){	struct mbo *mbo;	struct urb *urb;	while ((urb = usb_get_from_anchor(&mdev->busy_urbs[channel]))) {		mbo = urb->context;		usb_kill_urb(urb);		if (mbo && mbo->complete) {			mbo->status = status;			mbo->processed_length = 0;			mbo->complete(mbo);		}		usb_free_urb(urb);	}}

int usbnet_resume (struct usb_interface *intf){	struct usbnet		*dev = usb_get_intfdata(intf);	struct sk_buff          *skb;	struct urb              *res;	int                     retval;	if (!--dev->suspend_count) {		/* resume interrupt URBs */		if (dev->interrupt && test_bit(EVENT_DEV_OPEN, &dev->flags))			usb_submit_urb(dev->interrupt, GFP_NOIO);		spin_lock_irq(&dev->txq.lock);		while ((res = usb_get_from_anchor(&dev->deferred))) {			//HTC +++			// refer to acm_write_start() and usb_net_raw_ip_tx_urb_work(), need to			// decrement urb ref count after usb_get_from_anchor() to prevent memory leak			usb_put_urb(res);			//HTC ---			skb = (struct sk_buff *)res->context;			retval = usb_submit_urb(res, GFP_ATOMIC);			if (retval < 0) {				dev_kfree_skb_any(skb);				usb_free_urb(res);				usb_autopm_put_interface_async(dev->intf);			} else {				dev->net->trans_start = jiffies;				__skb_queue_tail(&dev->txq, skb);			}		}		smp_mb();		clear_bit(EVENT_DEV_ASLEEP, &dev->flags);		spin_unlock_irq(&dev->txq.lock);		if (test_bit(EVENT_DEV_OPEN, &dev->flags)) {			if (!(dev->txq.qlen >= TX_QLEN(dev)))				netif_start_queue(dev->net);			tasklet_schedule (&dev->bh);		}	}	return 0;}

int ctrl_bridge_resume(unsigned int id){    struct ctrl_bridge	*dev;    struct urb		*urb;    unsigned long		flags;    int			ret;    if (id >= MAX_BRIDGE_DEVICES)        return -EINVAL;    dev = __dev[id];    if (!dev)        return -ENODEV;    if (!dev->int_pipe)        return 0;    if (!test_bit(SUSPENDED, &dev->flags))        return 0;    spin_lock_irqsave(&dev->lock, flags);    /* submit pending write requests */    while ((urb = usb_get_from_anchor(&dev->tx_deferred))) {        spin_unlock_irqrestore(&dev->lock, flags);        /*         * usb_get_from_anchor() does not drop the         * ref count incremented by the usb_anchro_urb()         * called in Tx submission path. Let us do it.         */        usb_put_urb(urb);        usb_anchor_urb(urb, &dev->tx_submitted);        ret = usb_submit_urb(urb, GFP_ATOMIC);        if (ret < 0) {            usb_unanchor_urb(urb);            kfree(urb->setup_packet);            kfree(urb->transfer_buffer);            usb_free_urb(urb);            usb_autopm_put_interface_async(dev->intf);        }        spin_lock_irqsave(&dev->lock, flags);    }    clear_bit(SUSPENDED, &dev->flags);    spin_unlock_irqrestore(&dev->lock, flags);    return ctrl_bridge_start_read(dev, GFP_KERNEL);}

static void ar9170_usb_submit_urb(struct ar9170_usb *aru){	struct urb *urb;	unsigned long flags;	int err;	if (unlikely(!IS_STARTED(&aru->common)))		return ;	spin_lock_irqsave(&aru->tx_urb_lock, flags);	if (atomic_read(&aru->tx_submitted_urbs) >= AR9170_NUM_TX_URBS) {		spin_unlock_irqrestore(&aru->tx_urb_lock, flags);		return ;	}	atomic_inc(&aru->tx_submitted_urbs);	urb = usb_get_from_anchor(&aru->tx_pending);	if (!urb) {		atomic_dec(&aru->tx_submitted_urbs);		spin_unlock_irqrestore(&aru->tx_urb_lock, flags);		return ;	}	spin_unlock_irqrestore(&aru->tx_urb_lock, flags);	aru->tx_pending_urbs--;	usb_anchor_urb(urb, &aru->tx_submitted);	err = usb_submit_urb(urb, GFP_ATOMIC);	if (unlikely(err)) {		if (ar9170_nag_limiter(&aru->common))			dev_err(&aru->udev->dev, "submit_urb failed (%d)./n",				err);		usb_unanchor_urb(urb);		atomic_dec(&aru->tx_submitted_urbs);		ar9170_tx_callback(&aru->common, urb->context);	}	usb_free_urb(urb);}

static void sierra_close(struct usb_serial_port *port){	int i;	struct usb_serial *serial = port->serial;	struct sierra_port_private *portdata;	struct sierra_intf_private *intfdata = usb_get_serial_data(serial);	struct urb *urb;	portdata = usb_get_serial_port_data(port);	/*	 * Need to take susp_lock to make sure port is not already being	 * resumed, but no need to hold it due to initialized	 */	spin_lock_irq(&intfdata->susp_lock);	if (--intfdata->open_ports == 0)		serial->interface->needs_remote_wakeup = 0;	spin_unlock_irq(&intfdata->susp_lock);	for (;;) {		urb = usb_get_from_anchor(&portdata->delayed);		if (!urb)			break;		kfree(urb->transfer_buffer);		usb_free_urb(urb);		usb_autopm_put_interface_async(serial->interface);		spin_lock(&portdata->lock);		portdata->outstanding_urbs--;		spin_unlock(&portdata->lock);	}	sierra_stop_rx_urbs(port);	usb_kill_anchored_urbs(&portdata->active);	for (i = 0; i < portdata->num_in_urbs; i++) {		sierra_release_urb(portdata->in_urbs[i]);		portdata->in_urbs[i] = NULL;	}	usb_autopm_get_interface_no_resume(serial->interface);}