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

void __wa_destroy(struct wahc *wa){	if (wa->dti_urb) {		usb_kill_urb(wa->dti_urb);		usb_put_urb(wa->dti_urb);		usb_kill_urb(wa->buf_in_urb);		usb_put_urb(wa->buf_in_urb);	}	kfree(wa->xfer_result);	wa_nep_destroy(wa);	wa_rpipes_destroy(wa);}

static int unlink_urbs (struct usbnet *dev, struct sk_buff_head *q){	unsigned long		flags;	struct sk_buff		*skb;	int			count = 0;	spin_lock_irqsave (&q->lock, flags);	while (!skb_queue_empty(q)) {		struct skb_data		*entry;		struct urb		*urb;		int			retval;		skb_queue_walk(q, skb) {			entry = (struct skb_data *) skb->cb;			if (entry->state != unlink_start)				goto found;		}		break;found:		entry->state = unlink_start;		urb = entry->urb;		usb_get_urb(urb);		spin_unlock_irqrestore(&q->lock, flags);						retval = usb_unlink_urb (urb);		if (retval != -EINPROGRESS && retval != 0)			netdev_dbg(dev->net, "unlink urb err, %d/n", retval);		else			count++;		usb_put_urb(urb);		spin_lock_irqsave(&q->lock, flags);	}

/** * usb_unanchor_urb - unanchors an URB * @urb: pointer to the urb to anchor * * Call this to stop the system keeping track of this URB */void usb_unanchor_urb(struct urb *urb){	unsigned long flags;	struct usb_anchor *anchor;	if (!urb)		return;	anchor = urb->anchor;	if (!anchor)		return;	spin_lock_irqsave(&anchor->lock, flags);	if (unlikely(anchor != urb->anchor)) {		/* we've lost the race to another thread */		spin_unlock_irqrestore(&anchor->lock, flags);		return;	}	urb->anchor = NULL;	list_del(&urb->anchor_list);	spin_unlock_irqrestore(&anchor->lock, flags);	usb_put_urb(urb);	if (list_empty(&anchor->urb_list))		wake_up(&anchor->wait);}

/* Callers must hold anchor->lock */static void __usb_unanchor_urb(struct urb *urb, struct usb_anchor *anchor){	urb->anchor = NULL;	list_del(&urb->anchor_list);	usb_put_urb(urb);	if (usb_anchor_check_wakeup(anchor))		wake_up(&anchor->wait);}

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);	}}

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);}

/** * usb_poison_anchored_urbs - cease all traffic from an anchor * @anchor: anchor the requests are bound to * * this allows all outstanding URBs to be poisoned starting * from the back of the queue. Newly added URBs will also be * poisoned * * This routine should not be called by a driver after its disconnect * method has returned. */void usb_poison_anchored_urbs(struct usb_anchor *anchor){	struct urb *victim;	spin_lock_irq(&anchor->lock);	// anchor->poisoned = 1; /* XXX: Cannot backport */	while (!list_empty(&anchor->urb_list)) {		victim = list_entry(anchor->urb_list.prev, struct urb,				    anchor_list);		/* we must make sure the URB isn't freed before we kill it*/		usb_get_urb(victim);		spin_unlock_irq(&anchor->lock);		/* this will unanchor the URB */		usb_poison_urb(victim);		usb_put_urb(victim);		spin_lock_irq(&anchor->lock);	}	spin_unlock_irq(&anchor->lock);}

void dde_linux26_usb_vhcd_urb_complete(void *urb_handle,                                       dde_kit_size_t data_size, void *data){	LOG("URB %p completed", urb_handle);	struct urb *urb = (struct urb *)urb_handle;	LOG("urb @ %p, urb->setup_packet @ %p data_size %zd data %p hc_priv %p",	    urb, urb->setup_packet, data_size, data, urb->hcpriv);	/* FIXME the URB may have been unlinked */	if (!urb) return;	/* FIXME update URB *///	urb->status         = irq_d_urb->status;//	urb->actual_length  = irq_d_urb->actual_length;//	urb->start_frame    = irq_d_urb->start_frame;//	urb->interval       = irq_d_urb->interval;//	urb->error_count    = irq_d_urb->error_count;//	urb->transfer_flags = irq_d_urb->transfer_flags;	if (urb->setup_packet)		memcpy(urb->setup_packet, data, 8);	/* XXX no ISOC *///	if (urb->number_of_packets)//		memcpy(urb->iso_frame_desc, irq_d_urb->iso_desc,//		       urb->number_of_packets * sizeof(struct usb_iso_packet_descriptor));	struct usb_hcd *hcd = vhcd_to_hcd(urb->hcpriv);	urb->hcpriv = 0;	LOG("hcd %p", hcd);	usb_hcd_giveback_urb(hcd, urb);	usb_put_urb(urb);}

//.........这里部分代码省略.........	    default:		state = rx_cleanup;		dev->stats.rx_errors++;		if (netif_msg_rx_err (dev))			devdbg (dev, "rx status %d", urb_status);		break;	}	state = defer_bh(dev, skb, &dev->rxq, state);	if (urb) {		if (netif_running (dev->net)		    && !test_bit (EVENT_RX_HALT, &dev->flags) &&		    state != unlink_start) {			rx_submit (dev, urb, GFP_ATOMIC);			return;		}		usb_free_urb (urb);	}	if (netif_msg_rx_err (dev))		devdbg (dev, "no read resubmitted");}static void intr_complete (struct urb *urb){	struct usbnet	*dev = urb->context;	int		status = urb->status;	switch (status) {	    /* success */	    case 0:		dev->driver_info->status(dev, urb);		break;	    /* software-driven interface shutdown */	    case -ENOENT:		// urb killed	    case -ESHUTDOWN:		// hardware gone		if (netif_msg_ifdown (dev))			devdbg (dev, "intr shutdown, code %d", status);		return;	    /* NOTE:  not throttling like RX/TX, since this endpoint	     * already polls infrequently	     */	    default:		devdbg (dev, "intr status %d", status);		break;	}	memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);	status = usb_submit_urb (urb, GFP_ATOMIC);	if (status != 0 && netif_msg_timer (dev))		deverr(dev, "intr resubmit --> %d", status);}/*-------------------------------------------------------------------------*/// unlink pending rx/tx; completion handlers do all other cleanupstatic int unlink_urbs (struct usbnet *dev, struct sk_buff_head *q){	unsigned long		flags;	struct sk_buff		*skb;	int			count = 0;	spin_lock_irqsave (&q->lock, flags);	while (!skb_queue_empty(q)) {		struct skb_data		*entry;		struct urb		*urb;		int			retval;		skb_queue_walk(q, skb) {		entry = (struct skb_data *) skb->cb;			if (entry->state != unlink_start)				goto found;		}		break;found:		entry->state = unlink_start;		urb = entry->urb;		/*		 * Get reference count of the URB to avoid it to be		 * freed during usb_unlink_urb, which may trigger		 * use-after-free problem inside usb_unlink_urb since		 * usb_unlink_urb is always racing with .complete		 * handler(include defer_bh).		 */		usb_get_urb(urb);		spin_unlock_irqrestore(&q->lock, flags);		// during some PM-driven resume scenarios,		// these (async) unlinks complete immediately		retval = usb_unlink_urb (urb);		if (retval != -EINPROGRESS && retval != 0)			devdbg (dev, "unlink urb err, %d", retval);		else			count++;		usb_put_urb(urb);		spin_lock_irqsave(&q->lock, flags);	}

static int if_usb_resume(struct usb_interface *intf){	int i, ret;	struct sk_buff *skb;	struct usb_link_device *usb_ld = usb_get_intfdata(intf);	struct if_usb_devdata *pipe;	struct urb *urb;	spin_lock_irq(&usb_ld->lock);	if (!atomic_dec_return(&usb_ld->suspend_count)) {		spin_unlock_irq(&usb_ld->lock);		mif_debug("/n");		wake_lock(&usb_ld->susplock);		/* HACK: Runtime pm does not allow requesting autosuspend from		 * resume callback, delayed it after resume */		queue_delayed_work(system_nrt_wq, &usb_ld->runtime_pm_work,							msecs_to_jiffies(50));		for (i = 0; i < IF_USB_DEVNUM_MAX; i++) {			pipe = &usb_ld->devdata[i];			while ((urb = usb_get_from_anchor(&pipe->urbs))) {				ret = usb_rx_submit(pipe, urb, GFP_KERNEL);				if (ret < 0) {					usb_put_urb(urb);					mif_err(					"usb_rx_submit error with (%d)/n",						ret);					return ret;				}				usb_put_urb(urb);			}		}		while ((urb = usb_get_from_anchor(&usb_ld->deferred))) {			mif_debug("got urb (0x%p) from anchor & resubmit/n",					urb);			ret = usb_submit_urb(urb, GFP_KERNEL);			if (ret < 0) {				mif_err("resubmit failed/n");				skb = urb->context;				dev_kfree_skb_any(skb);				usb_free_urb(urb);				ret = pm_runtime_put_autosuspend(						&usb_ld->usbdev->dev);				if (ret < 0 && ret != -EAGAIN)					mif_debug("pm_runtime_put_autosuspend "							"failed: %d/n", ret);			}		}		SET_SLAVE_WAKEUP(usb_ld->pdata, 1);		udelay(100);		SET_SLAVE_WAKEUP(usb_ld->pdata, 0);		/* if_usb_resume() is atomic. post_resume_work is		 * a kind of bottom halves		 */		queue_delayed_work(system_nrt_wq, &usb_ld->post_resume_work, 0);		return 0;	}	spin_unlock_irq(&usb_ld->lock);	return 0;}

static int usb_tx_urb_with_skb(struct usb_link_device *usb_ld,		struct sk_buff *skb, struct if_usb_devdata *pipe_data){	int ret, cnt = 0;	struct urb *urb;	struct usb_device *usbdev = usb_ld->usbdev;	unsigned long flags;	if (!usbdev || (usbdev->state == USB_STATE_NOTATTACHED) ||			usb_ld->host_wake_timeout_flag)		return -ENODEV;	pm_runtime_get_noresume(&usbdev->dev);	if (usbdev->dev.power.runtime_status == RPM_SUSPENDED ||		usbdev->dev.power.runtime_status == RPM_SUSPENDING) {		usb_ld->resume_status = AP_INITIATED_RESUME;		SET_SLAVE_WAKEUP(usb_ld->pdata, 1);		while (!wait_event_interruptible_timeout(usb_ld->l2_wait,				usbdev->dev.power.runtime_status == RPM_ACTIVE				|| pipe_data->disconnected,				HOST_WAKEUP_TIMEOUT_JIFFIES)) {			if (cnt == MAX_RETRY) {				mif_err("host wakeup timeout !!/n");				SET_SLAVE_WAKEUP(usb_ld->pdata, 0);				pm_runtime_put_autosuspend(&usbdev->dev);				schedule_work(&usb_ld->disconnect_work);				usb_ld->host_wake_timeout_flag = 1;				return -1;			}			mif_err("host wakeup timeout ! retry../n");			SET_SLAVE_WAKEUP(usb_ld->pdata, 0);			udelay(100);			SET_SLAVE_WAKEUP(usb_ld->pdata, 1);			cnt++;		}		if (pipe_data->disconnected) {			SET_SLAVE_WAKEUP(usb_ld->pdata, 0);			pm_runtime_put_autosuspend(&usbdev->dev);			return -ENODEV;		}		mif_debug("wait_q done (runtime_status=%d)/n",				usbdev->dev.power.runtime_status);	}	urb = usb_alloc_urb(0, GFP_KERNEL);	if (!urb) {		mif_err("alloc urb error/n");		if (pm_runtime_put_autosuspend(&usbdev->dev) < 0)			mif_debug("pm_runtime_put_autosuspend fail/n");		return -ENOMEM;	}	urb->transfer_flags = URB_ZERO_PACKET;	usb_fill_bulk_urb(urb, usbdev, pipe_data->tx_pipe, skb->data,			skb->len, usb_tx_complete, (void *)skb);	spin_lock_irqsave(&usb_ld->lock, flags);	if (atomic_read(&usb_ld->suspend_count)) {		/* transmission will be done in resume */		usb_anchor_urb(urb, &usb_ld->deferred);		usb_put_urb(urb);		mif_debug("anchor urb (0x%p)/n", urb);		spin_unlock_irqrestore(&usb_ld->lock, flags);		return 0;	}	spin_unlock_irqrestore(&usb_ld->lock, flags);	ret = usb_submit_urb(urb, GFP_KERNEL);	if (ret < 0) {		mif_err("usb_submit_urb with ret(%d)/n", ret);		if (pm_runtime_put_autosuspend(&usbdev->dev) < 0)			mif_debug("pm_runtime_put_autosuspend fail/n");	}	return ret;}