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

//.........这里部分代码省略.........    case -ENOENT:    case -ECONNRESET:    case -ENODEV:    case -ESHUTDOWN:        goto free;    default:        break;    }resubmit:    usb_anchor_urb(_urb, &rtlusb->rx_submitted);    err = usb_submit_urb(_urb, GFP_ATOMIC);    if (unlikely(err)) {        usb_unanchor_urb(_urb);        goto free;    }    return;free:    /* On some architectures, usb_free_coherent must not be called from     * hardirq context. Queue urb to cleanup list.     */    usb_anchor_urb(_urb, &rtlusb->rx_cleanup_urbs);}#undef __RADIO_TAP_SIZE_RSVstatic void _rtl_usb_cleanup_rx(struct ieee80211_hw *hw){    struct rtl_priv *rtlpriv = rtl_priv(hw);    struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));    struct urb *urb;    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);    destroy_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);    }}static int _rtl_usb_receive(struct ieee80211_hw *hw){    struct urb *urb;    int err;    int i;    struct rtl_priv *rtlpriv = rtl_priv(hw);    struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));    WARN_ON(0 == rtlusb->rx_urb_num);    /* 1600 == 1514 + max WLAN header + rtk info */    WARN_ON(rtlusb->rx_max_size < 1600);    for (i = 0; i < rtlusb->rx_urb_num; i++) {        err = -ENOMEM;        urb = usb_alloc_urb(0, GFP_KERNEL);        if (!urb) {

static void btusb_stop_traffic(struct btusb_data *data){	usb_kill_anchored_urbs(&data->intr_anchor);	usb_kill_anchored_urbs(&data->bulk_anchor);	usb_kill_anchored_urbs(&data->isoc_anchor);}

static void usblp_unlink_urbs(struct usblp *usblp){	usb_kill_anchored_urbs(&usblp->urbs);}

static int rmnet_usb_ctrl_write(struct rmnet_ctrl_dev *dev,		struct ctrl_pkt *cpkt, size_t size){	int			result;	struct urb		*sndurb;	struct usb_ctrlrequest	*out_ctlreq;	struct usb_device	*udev;	if (!test_bit(RMNET_CTRL_DEV_READY, &dev->status))		return -ENETRESET;	udev = interface_to_usbdev(dev->intf);	sndurb = usb_alloc_urb(0, GFP_KERNEL);	if (!sndurb) {		dev_err(dev->devicep, "Error allocating read urb/n");		return -ENOMEM;	}	out_ctlreq = kmalloc(sizeof(*out_ctlreq), GFP_KERNEL);	if (!out_ctlreq) {		usb_free_urb(sndurb);		dev_err(dev->devicep, "Error allocating setup packet buffer/n");		return -ENOMEM;	}	/* CDC Send Encapsulated Request packet */	out_ctlreq->bRequestType = (USB_DIR_OUT | USB_TYPE_CLASS |			     USB_RECIP_INTERFACE);	out_ctlreq->bRequest = USB_CDC_SEND_ENCAPSULATED_COMMAND;	out_ctlreq->wValue = 0;	out_ctlreq->wIndex = dev->intf->cur_altsetting->desc.bInterfaceNumber;	out_ctlreq->wLength = cpu_to_le16(cpkt->data_size);	usb_fill_control_urb(sndurb, udev,			     usb_sndctrlpipe(udev, 0),			     (unsigned char *)out_ctlreq, (void *)cpkt->data,			     cpkt->data_size, ctrl_write_callback, cpkt);	result = usb_autopm_get_interface(dev->intf);	if (result < 0) {		dev_dbg(dev->devicep, "%s: Unable to resume interface: %d/n",			__func__, result);		/*		* Revisit:  if (result == -EPERM)		*		rmnet_usb_suspend(dev->intf, PMSG_SUSPEND);		*/		usb_free_urb(sndurb);		kfree(out_ctlreq);		return result;	}	usb_anchor_urb(sndurb, &dev->tx_submitted);	dev->snd_encap_cmd_cnt++;	result = usb_submit_urb(sndurb, GFP_KERNEL);	if (result < 0) {		if (result != -ENODEV)			dev_err(dev->devicep,			"%s: Submit URB error %d/n",			__func__, result);		dev->snd_encap_cmd_cnt--;		usb_autopm_put_interface(dev->intf);		usb_unanchor_urb(sndurb);		usb_free_urb(sndurb);		kfree(out_ctlreq);		return result;	}	if (usb_wait_anchor_empty_timeout(&dev->tx_submitted, 1000) > 0)		return size;	else {		usb_kill_anchored_urbs(&dev->tx_submitted);		return -EAGAIN;	}}

//.........这里部分代码省略.........free:	dev_kfree_skb_irq(skb);}static int _rtl_usb_receive(struct ieee80211_hw *hw){	struct urb *urb;	struct sk_buff *skb;	int err;	int i;	struct rtl_priv *rtlpriv = rtl_priv(hw);	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));	WARN_ON(0 == rtlusb->rx_urb_num);	/* 1600 == 1514 + max WLAN header + rtk info */	WARN_ON(rtlusb->rx_max_size < 1600);	for (i = 0; i < rtlusb->rx_urb_num; i++) {		err = -ENOMEM;		urb = usb_alloc_urb(0, GFP_KERNEL);		if (!urb) {			RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,				 "Failed to alloc URB!!/n");			goto err_out;		}		skb = _rtl_prep_rx_urb(hw, rtlusb, urb, GFP_KERNEL);		if (IS_ERR(skb)) {			RT_TRACE(rtlpriv, COMP_USB, DBG_EMERG,				 "Failed to prep_rx_urb!!/n");			err = PTR_ERR(skb);			goto err_out;		}		usb_anchor_urb(urb, &rtlusb->rx_submitted);		err = usb_submit_urb(urb, GFP_KERNEL);		if (err)			goto err_out;		usb_free_urb(urb);	}	return 0;err_out:	usb_kill_anchored_urbs(&rtlusb->rx_submitted);	return err;}static int rtl_usb_start(struct ieee80211_hw *hw){	int err;	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));	err = rtlpriv->cfg->ops->hw_init(hw);	if (!err) {		rtl_init_rx_config(hw);		/* Enable software */		SET_USB_START(rtlusb);		/* should after adapter start and interrupt enable. */		set_hal_start(rtlhal);		/* Start bulk IN */		_rtl_usb_receive(hw);	}	return err;}/** * * *//*=======================  tx =========================================*/static void rtl_usb_cleanup(struct ieee80211_hw *hw){	u32 i;	struct sk_buff *_skb;	struct rtl_usb *rtlusb = rtl_usbdev(rtl_usbpriv(hw));	struct ieee80211_tx_info *txinfo;	SET_USB_STOP(rtlusb);	/* clean up rx stuff. */	usb_kill_anchored_urbs(&rtlusb->rx_submitted);	/* clean up tx stuff */	for (i = 0; i < RTL_USB_MAX_EP_NUM; i++) {		while ((_skb = skb_dequeue(&rtlusb->tx_skb_queue[i]))) {			rtlusb->usb_tx_cleanup(hw, _skb);			txinfo = IEEE80211_SKB_CB(_skb);			ieee80211_tx_info_clear_status(txinfo);			txinfo->flags |= IEEE80211_TX_STAT_ACK;			ieee80211_tx_status_irqsafe(hw, _skb);		}		usb_kill_anchored_urbs(&rtlusb->tx_pending[i]);	}	usb_kill_anchored_urbs(&rtlusb->tx_submitted);}

static int rmnet_usb_suspend(struct usb_interface *iface, pm_message_t message){	struct usbnet		*unet = usb_get_intfdata(iface);	struct rmnet_ctrl_dev	*dev;	int			i, n, rdev_cnt, unet_id;	int			retval = 0;	rdev_cnt = unet->data[4] ? no_rmnet_insts_per_dev : 1;	for (n = 0; n < rdev_cnt; n++) {		unet_id = n + unet->driver_info->data * no_rmnet_insts_per_dev;		unet =		unet->data[4] ? unet_list[unet_id] : usb_get_intfdata(iface);		dev = (struct rmnet_ctrl_dev *)unet->data[1];		spin_lock_irq(&unet->txq.lock);		if (work_busy(&dev->get_encap_work) || unet->txq.qlen) {			spin_unlock_irq(&unet->txq.lock);			retval = -EBUSY;			goto abort_suspend;		}		set_bit(EVENT_DEV_ASLEEP, &unet->flags);		spin_unlock_irq(&unet->txq.lock);		usb_kill_anchored_urbs(&dev->rx_submitted);		if (work_busy(&dev->get_encap_work)) {			spin_lock_irq(&unet->txq.lock);			clear_bit(EVENT_DEV_ASLEEP, &unet->flags);			spin_unlock_irq(&unet->txq.lock);			retval = -EBUSY;			goto abort_suspend;		}	}	for (n = 0; n < rdev_cnt; n++) {		unet_id = n + unet->driver_info->data * no_rmnet_insts_per_dev;		unet =		unet->data[4] ? unet_list[unet_id] : usb_get_intfdata(iface);		dev = (struct rmnet_ctrl_dev *)unet->data[1];		netif_device_detach(unet->net);		usbnet_terminate_urbs(unet);		netif_device_attach(unet->net);	}	return 0;abort_suspend:	for (i = 0; i < n; i++) {		unet_id = i + unet->driver_info->data * no_rmnet_insts_per_dev;		unet =		unet->data[4] ? unet_list[unet_id] : usb_get_intfdata(iface);		dev = (struct rmnet_ctrl_dev *)unet->data[1];		rmnet_usb_ctrl_start_rx(dev);		spin_lock_irq(&unet->txq.lock);		clear_bit(EVENT_DEV_ASLEEP, &unet->flags);		spin_unlock_irq(&unet->txq.lock);	}	return retval;}

static int gs_usb_probe(struct usb_interface *intf,			const struct usb_device_id *id){	struct gs_usb *dev;	int rc = -ENOMEM;	unsigned int icount, i;	struct gs_host_config *hconf;	struct gs_device_config *dconf;	hconf = kmalloc(sizeof(*hconf), GFP_KERNEL);	if (!hconf)		return -ENOMEM;	hconf->byte_order = 0x0000beef;	/* send host config */	rc = usb_control_msg(interface_to_usbdev(intf),			     usb_sndctrlpipe(interface_to_usbdev(intf), 0),			     GS_USB_BREQ_HOST_FORMAT,			     USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,			     1,			     intf->altsetting[0].desc.bInterfaceNumber,			     hconf,			     sizeof(*hconf),			     1000);	kfree(hconf);	if (rc < 0) {		dev_err(&intf->dev, "Couldn't send data format (err=%d)/n",			rc);		return rc;	}	dconf = kmalloc(sizeof(*dconf), GFP_KERNEL);	if (!dconf)		return -ENOMEM;	/* read device config */	rc = usb_control_msg(interface_to_usbdev(intf),			     usb_rcvctrlpipe(interface_to_usbdev(intf), 0),			     GS_USB_BREQ_DEVICE_CONFIG,			     USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_INTERFACE,			     1,			     intf->altsetting[0].desc.bInterfaceNumber,			     dconf,			     sizeof(*dconf),			     1000);	if (rc < 0) {		dev_err(&intf->dev, "Couldn't get device config: (err=%d)/n",			rc);		kfree(dconf);		return rc;	}	icount = dconf->icount + 1;	dev_info(&intf->dev, "Configuring for %d interfaces/n", icount);	if (icount > GS_MAX_INTF) {		dev_err(&intf->dev,			"Driver cannot handle more that %d CAN interfaces/n",			GS_MAX_INTF);		kfree(dconf);		return -EINVAL;	}	dev = kzalloc(sizeof(*dev), GFP_KERNEL);	if (!dev) {		kfree(dconf);		return -ENOMEM;	}	init_usb_anchor(&dev->rx_submitted);	atomic_set(&dev->active_channels, 0);	usb_set_intfdata(intf, dev);	dev->udev = interface_to_usbdev(intf);	for (i = 0; i < icount; i++) {		dev->canch[i] = gs_make_candev(i, intf, dconf);		if (IS_ERR_OR_NULL(dev->canch[i])) {			/* save error code to return later */			rc = PTR_ERR(dev->canch[i]);			/* on failure destroy previously created candevs */			icount = i;			for (i = 0; i < icount; i++)				gs_destroy_candev(dev->canch[i]);			usb_kill_anchored_urbs(&dev->rx_submitted);			kfree(dconf);			kfree(dev);			return rc;		}		dev->canch[i]->parent = dev;	}	kfree(dconf);//.........这里部分代码省略.........

static void gs_destroy_candev(struct gs_can *dev){	unregister_candev(dev->netdev);	usb_kill_anchored_urbs(&dev->tx_submitted);	free_candev(dev->netdev);}

static void unlink_all_urbs(struct sam4e_usb *dev){	usb_kill_anchored_urbs(&dev->rx_submitted);	usb_kill_anchored_urbs(&dev->tx_submitted);	atomic_set(&dev->active_tx_urbs, 0);}