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

static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags){	struct sk_buff		*skb;	struct skb_data		*entry;	int			retval = 0;	unsigned long		lockflags;	size_t			size = dev->rx_urb_size;	/* prevent rx skb allocation when error ratio is high */	if (test_bit(EVENT_RX_KILL, &dev->flags)) {		usb_free_urb(urb);		return -ENOLINK;	}	skb = __netdev_alloc_skb_ip_align(dev->net, size, flags);	if (!skb) {		netif_dbg(dev, rx_err, dev->net, "no rx skb/n");		usbnet_defer_kevent (dev, EVENT_RX_MEMORY);		usb_free_urb (urb);		return -ENOMEM;	}	entry = (struct skb_data *) skb->cb;	entry->urb = urb;	entry->dev = dev;	entry->length = 0;	usb_fill_bulk_urb (urb, dev->udev, dev->in,		skb->data, size, rx_complete, skb);	spin_lock_irqsave (&dev->rxq.lock, lockflags);	if (netif_running (dev->net) &&	    netif_device_present (dev->net) &&	    !test_bit (EVENT_RX_HALT, &dev->flags) &&	    !test_bit (EVENT_DEV_ASLEEP, &dev->flags)) {		switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) {		case -EPIPE:			usbnet_defer_kevent (dev, EVENT_RX_HALT);			break;		case -ENOMEM:			usbnet_defer_kevent (dev, EVENT_RX_MEMORY);			break;		case -ENODEV:			netif_dbg(dev, ifdown, dev->net, "device gone/n");			netif_device_detach (dev->net);			break;		case -EHOSTUNREACH:			retval = -ENOLINK;			break;		default:			netif_dbg(dev, rx_err, dev->net,				  "rx submit, %d/n", retval);			tasklet_schedule (&dev->bh);			break;		case 0:			__usbnet_queue_skb(&dev->rxq, skb, rx_start);		}	} else {		netif_dbg(dev, ifdown, dev->net, "rx: stopped/n");		retval = -ENOLINK;	}	spin_unlock_irqrestore (&dev->rxq.lock, lockflags);	if (retval) {		dev_kfree_skb_any (skb);		usb_free_urb (urb);	}	return retval;}

static void rx_complete (struct urb *urb){	struct sk_buff		*skb = (struct sk_buff *) urb->context;	struct skb_data		*entry = (struct skb_data *) skb->cb;	struct usbnet		*dev = entry->dev;	int			urb_status = urb->status;	enum skb_state		state;	skb_put (skb, urb->actual_length);	state = rx_done;	entry->urb = NULL;	switch (urb_status) {	/* success */	case 0:		if (skb->len < dev->net->hard_header_len) {			state = rx_cleanup;			dev->net->stats.rx_errors++;			dev->net->stats.rx_length_errors++;			netif_dbg(dev, rx_err, dev->net,				  "rx length %d/n", skb->len);		}		break;	/* stalls need manual reset. this is rare ... except that	 * when going through USB 2.0 TTs, unplug appears this way.	 * we avoid the highspeed version of the ETIMEDOUT/EILSEQ	 * storm, recovering as needed.	 */	case -EPIPE:		dev->net->stats.rx_errors++;		usbnet_defer_kevent (dev, EVENT_RX_HALT);		// FALLTHROUGH	/* software-driven interface shutdown */	case -ECONNRESET:		/* async unlink */	case -ESHUTDOWN:		/* hardware gone */		netif_dbg(dev, ifdown, dev->net,			  "rx shutdown, code %d/n", urb_status);		goto block;	/* we get controller i/o faults during khubd disconnect() delays.	 * throttle down resubmits, to avoid log floods; just temporarily,	 * so we still recover when the fault isn't a khubd delay.	 */	case -EPROTO:	case -ETIME:	case -EILSEQ:		dev->net->stats.rx_errors++;		if (!timer_pending (&dev->delay)) {			mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES);			netif_dbg(dev, link, dev->net,				  "rx throttle %d/n", urb_status);		}block:		state = rx_cleanup;		entry->urb = urb;		urb = NULL;		break;	/* data overrun ... flush fifo? */	case -EOVERFLOW:		dev->net->stats.rx_over_errors++;		// FALLTHROUGH	default:		state = rx_cleanup;		dev->net->stats.rx_errors++;		netif_dbg(dev, rx_err, dev->net, "rx status %d/n", urb_status);		break;	}	/* stop rx if packet error rate is high */	if (++dev->pkt_cnt > 30) {		dev->pkt_cnt = 0;		dev->pkt_err = 0;	} else {		if (state == rx_cleanup)			dev->pkt_err++;		if (dev->pkt_err > 20)			set_bit(EVENT_RX_KILL, &dev->flags);	}	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);			usb_mark_last_busy(dev->udev);			return;		}		usb_free_urb (urb);	}	netif_dbg(dev, rx_err, dev->net, "no read resubmitted/n");}

netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,				     struct net_device *net){	struct usbnet		*dev = netdev_priv(net);	int			length;	struct urb		*urb = NULL;	struct skb_data		*entry;	struct driver_info	*info = dev->driver_info;	unsigned long		flags;	int retval;	// some devices want funky USB-level framing, for	// win32 driver (usually) and/or hardware quirks	if (info->tx_fixup) {		skb = info->tx_fixup (dev, skb, GFP_ATOMIC);		if (!skb) {			if (netif_msg_tx_err(dev)) {				netif_dbg(dev, tx_err, dev->net, "can't tx_fixup skb/n");				goto drop;			} else {				/* cdc_ncm collected packet; waits for more */				goto not_drop;			}		}	}	length = skb->len;	if (!(urb = usb_alloc_urb (0, GFP_ATOMIC))) {		netif_dbg(dev, tx_err, dev->net, "no urb/n");		goto drop;	}	entry = (struct skb_data *) skb->cb;	entry->urb = urb;	entry->dev = dev;	entry->state = tx_start;	entry->length = length;	usb_fill_bulk_urb (urb, dev->udev, dev->out,			skb->data, skb->len, tx_complete, skb);	/* don't assume the hardware handles USB_ZERO_PACKET	 * NOTE:  strictly conforming cdc-ether devices should expect	 * the ZLP here, but ignore the one-byte packet.	 * NOTE2: CDC NCM specification is different from CDC ECM when	 * handling ZLP/short packets, so cdc_ncm driver will make short	 * packet itself if needed.	 */	if (length % dev->maxpacket == 0) {		if (!(info->flags & FLAG_SEND_ZLP)) {			if (!(info->flags & FLAG_MULTI_PACKET)) {				urb->transfer_buffer_length++;				if (skb_tailroom(skb)) {					skb->data[skb->len] = 0;					__skb_put(skb, 1);				}			}		} else			urb->transfer_flags |= URB_ZERO_PACKET;	}	spin_lock_irqsave(&dev->txq.lock, flags);	retval = usb_autopm_get_interface_async(dev->intf);	if (retval < 0) {		spin_unlock_irqrestore(&dev->txq.lock, flags);		goto drop;	}#ifdef CONFIG_PM	/* if this triggers the device is still a sleep */	if (test_bit(EVENT_DEV_ASLEEP, &dev->flags)) {		/* transmission will be done in resume */		usb_anchor_urb(urb, &dev->deferred);		/* no use to process more packets */		netif_stop_queue(net);		spin_unlock_irqrestore(&dev->txq.lock, flags);		netdev_dbg(dev->net, "Delaying transmission for resumption/n");		goto deferred;	}#endif	switch ((retval = usb_submit_urb (urb, GFP_ATOMIC))) {	case -EPIPE:		netif_stop_queue (net);		usbnet_defer_kevent (dev, EVENT_TX_HALT);		usb_autopm_put_interface_async(dev->intf);		break;	default:		usb_autopm_put_interface_async(dev->intf);		netif_dbg(dev, tx_err, dev->net,			  "tx: submit urb err %d/n", retval);		break;	case 0:		net->trans_start = jiffies;		__skb_queue_tail (&dev->txq, skb);		if (dev->txq.qlen >= TX_QLEN (dev))			netif_stop_queue (net);	}	spin_unlock_irqrestore (&dev->txq.lock, flags);//.........这里部分代码省略.........

static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags){	struct sk_buff		*skb;	struct skb_data		*entry;	int			retval = 0;	unsigned long		lockflags;	size_t			size = dev->rx_urb_size;	if ((skb = alloc_skb (size + NET_IP_ALIGN, flags)) == NULL) {		netif_dbg(dev, rx_err, dev->net, "no rx skb/n");		usbnet_defer_kevent (dev, EVENT_RX_MEMORY);		usb_free_urb (urb);		return -ENOMEM;	}	if (dev->net->type != ARPHRD_RAWIP)		skb_reserve(skb, NET_IP_ALIGN);	entry = (struct skb_data *) skb->cb;	entry->urb = urb;	entry->dev = dev;	entry->state = rx_start;	entry->length = 0;	usb_fill_bulk_urb (urb, dev->udev, dev->in,		skb->data, size, rx_complete, skb);	spin_lock_irqsave (&dev->rxq.lock, lockflags);	if (netif_running (dev->net) &&	    netif_device_present (dev->net) &&	    !test_bit (EVENT_RX_HALT, &dev->flags) &&	    !test_bit (EVENT_DEV_ASLEEP, &dev->flags)) {		switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) {		case -EPIPE:			usbnet_defer_kevent (dev, EVENT_RX_HALT);			break;		case -ENOMEM:			usbnet_defer_kevent (dev, EVENT_RX_MEMORY);			break;		case -ENODEV:			netif_dbg(dev, ifdown, dev->net, "device gone/n");			netif_device_detach (dev->net);			break;		case -EHOSTUNREACH:			retval = -ENOLINK;			break;		default:			netif_dbg(dev, rx_err, dev->net,				  "rx submit, %d/n", retval);			queue_work(usbnet_wq, &dev->bh_w);			break;		case 0:			usb_mark_last_busy(dev->udev);			__skb_queue_tail (&dev->rxq, skb);		}	} else {		netif_dbg(dev, ifdown, dev->net, "rx: stopped/n");		retval = -ENOLINK;	}	spin_unlock_irqrestore (&dev->rxq.lock, lockflags);	if (retval) {		dev_kfree_skb_any (skb);		usb_free_urb (urb);	}	return retval;}

netdev_tx_t usbnet_start_xmit (struct sk_buff *skb,				     struct net_device *net){	struct usbnet		*dev = netdev_priv(net);	int			length;	struct urb		*urb = NULL;	struct skb_data		*entry;	struct driver_info	*info = dev->driver_info;	unsigned long		flags;	int retval;	// some devices want funky USB-level framing, for	// win32 driver (usually) and/or hardware quirks	if (info->tx_fixup) {		skb = info->tx_fixup (dev, skb, GFP_ATOMIC);		if (!skb) {			if (netif_msg_tx_err (dev))				devdbg (dev, "can't tx_fixup skb");			goto drop;		}	}	length = skb->len;	if (!(urb = usb_alloc_urb (0, GFP_ATOMIC))) {		if (netif_msg_tx_err (dev))			devdbg (dev, "no urb");		goto drop;	}	entry = (struct skb_data *) skb->cb;	entry->urb = urb;	entry->dev = dev;	entry->state = tx_start;	entry->length = length;	usb_fill_bulk_urb (urb, dev->udev, dev->out,			skb->data, skb->len, tx_complete, skb);	/* don't assume the hardware handles USB_ZERO_PACKET	 * NOTE:  strictly conforming cdc-ether devices should expect	 * the ZLP here, but ignore the one-byte packet.	 */	if (!(info->flags & FLAG_SEND_ZLP) && (length % dev->maxpacket) == 0) {		urb->transfer_buffer_length++;		if (skb_tailroom(skb)) {			skb->data[skb->len] = 0;			__skb_put(skb, 1);		}	}	spin_lock_irqsave (&dev->txq.lock, flags);	switch ((retval = usb_submit_urb (urb, GFP_ATOMIC))) {	case -EPIPE:		netif_stop_queue (net);		usbnet_defer_kevent (dev, EVENT_TX_HALT);		break;	default:		if (netif_msg_tx_err (dev))			devdbg (dev, "tx: submit urb err %d", retval);		break;	case 0:		net->trans_start = jiffies;		__skb_queue_tail (&dev->txq, skb);		if (dev->txq.qlen >= TX_QLEN (dev))			netif_stop_queue (net);	}	spin_unlock_irqrestore (&dev->txq.lock, flags);	if (retval) {		if (netif_msg_tx_err (dev))			devdbg (dev, "drop, code %d", retval);drop:		dev->net->stats.tx_dropped++;		if (skb)			dev_kfree_skb_any (skb);		usb_free_urb (urb);	} else if (netif_msg_tx_queued (dev)) {		devdbg (dev, "> tx, len %d, type 0x%x",			length, skb->protocol);	}	return NETDEV_TX_OK;}

void rx_complete (struct urb *urb){	struct sk_buff		*skb = (struct sk_buff *) urb->context;	struct skb_data		*entry = (struct skb_data *) skb->cb;	struct usbnet		*dev = entry->dev;	int			urb_status = urb->status;	enum skb_state		state;	skb_put (skb, urb->actual_length);	state = rx_done;	entry->urb = NULL;		if (enable_tx_rx_debug && (urb_status != -ECONNRESET))		netdev_info(dev->net, "[RMNET_D]rx_c, status: %d/n", urb_status);		switch (urb_status) {	/* success */	case 0:		break;	case -EPIPE:		dev->net->stats.rx_errors++;		usbnet_defer_kevent (dev, EVENT_RX_HALT);				case -ECONNRESET:			case -ESHUTDOWN:				netif_dbg(dev, ifdown, dev->net,			  "rx shutdown, code %d/n", urb_status);		goto block;	case -EPROTO:	case -ETIME:	case -EILSEQ:		dev->net->stats.rx_errors++;		if (!timer_pending (&dev->delay)) {			mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES);			netif_dbg(dev, link, dev->net,				  "rx throttle %d/n", urb_status);		}block:		state = rx_cleanup;		entry->urb = urb;		urb = NULL;		break;		case -EOVERFLOW:		dev->net->stats.rx_over_errors++;			default:		state = rx_cleanup;		dev->net->stats.rx_errors++;		netif_dbg(dev, rx_err, dev->net, "rx status %d/n", 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);#ifdef HTC_PM_DBG			if (usb_pm_debug_enabled)				usb_mark_intf_last_busy(dev->intf, true);#endif			usb_mark_last_busy(dev->udev);			return;		}		usb_free_urb (urb);	}	netif_dbg(dev, rx_err, dev->net, "no read resubmitted/n");}

static void tx_complete (struct urb *urb){   struct sk_buff		*skb = (struct sk_buff *) urb->context;   struct skb_data		*entry = (struct skb_data *) skb->cb;   struct usbnet		*dev = entry->dev;#ifdef TX_URB_MONITOR	unsigned char b_usb_if_num = 0;    int iRet = get_usb_interface(urb, &b_usb_if_num);#endif //#ifdef TX_URB_MONITOR   if (urb->status == 0)   {      if (!(dev->driver_info->flags & FLAG_MULTI_PACKET))         dev->net->stats.tx_packets++;      dev->net->stats.tx_bytes += entry->length;   }   else   {      dev->net->stats.tx_errors++;      switch (urb->status)      {         case -EPIPE:            usbnet_defer_kevent (dev, EVENT_TX_HALT);            break;                /* software-driven interface shutdown */         case -ECONNRESET:		// async unlink         case -ESHUTDOWN:		// hardware gone            break;                // like rx, tx gets controller i/o faults during khubd delays         // and so it uses the same throttling mechanism.         case -EPROTO:         case -ETIME:         case -EILSEQ:            if (!timer_pending (&dev->delay)) {             mod_timer (&dev->delay,             jiffies + THROTTLE_JIFFIES);            if (netif_msg_link (dev))            #if (LINUX_VERSION_CODE != KERNEL_VERSION( 3,0,6 ))               devdbg (dev, "tx throttle %d",                            urb->status);            #else			         	netif_dbg(dev, link, dev->net,				                  	  "tx throttle %d/n", urb->status);            #endif            }            netif_stop_queue (dev->net);            break;         default:            if (netif_msg_tx_err (dev))            #if (LINUX_VERSION_CODE != KERNEL_VERSION( 3,0,6 ))               devdbg (dev, "tx err %d", entry->urb->status);            #else			          netif_dbg(dev, tx_err, dev->net,				                       "tx err %d/n", entry->urb->status);            #endif            break;    		}  	}   usb_autopm_put_interface_async(dev->intf);   urb->dev = NULL;   entry->state = tx_done;   defer_bh(dev, skb, &dev->txq);#ifdef TX_URB_MONITOR   if ((URB_monitor) && (0==iRet))   {       URB_monitor(false, b_usb_if_num);   }#endif //#ifdef TX_URB_MONITOR}

static void rx_complete (struct urb *urb){	struct sk_buff		*skb = (struct sk_buff *) urb->context;	struct skb_data		*entry = (struct skb_data *) skb->cb;	struct usbnet		*dev = entry->dev;	int			urb_status = urb->status;	skb_put (skb, urb->actual_length);	entry->state = rx_done;	entry->urb = NULL;	switch (urb_status) {	/* success */	case 0:		if (skb->len < dev->net->hard_header_len) {			entry->state = rx_cleanup;			dev->net->stats.rx_errors++;			dev->net->stats.rx_length_errors++;			netif_dbg(dev, rx_err, dev->net,				  "rx length %d/n", skb->len);		}		//HTC+++		usbnet_rx_len += skb->len;		//HTC---		break;	/* stalls need manual reset. this is rare ... except that	 * when going through USB 2.0 TTs, unplug appears this way.	 * we avoid the highspeed version of the ETIMEDOUT/EILSEQ	 * storm, recovering as needed.	 */	case -EPIPE:		dev->net->stats.rx_errors++;		usbnet_defer_kevent (dev, EVENT_RX_HALT);		// FALLTHROUGH	/* software-driven interface shutdown */	case -ECONNRESET:		/* async unlink */	case -ESHUTDOWN:		/* hardware gone */		netif_dbg(dev, ifdown, dev->net,			  "rx shutdown, code %d/n", urb_status);		goto block;	/* we get controller i/o faults during khubd disconnect() delays.	 * throttle down resubmits, to avoid log floods; just temporarily,	 * so we still recover when the fault isn't a khubd delay.	 */	case -EPROTO:	case -ETIME:	case -EILSEQ:		dev->net->stats.rx_errors++;		if (!timer_pending (&dev->delay)) {			mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES);			netif_dbg(dev, link, dev->net,				  "rx throttle %d/n", urb_status);		}block:		entry->state = rx_cleanup;		entry->urb = urb;		urb = NULL;		break;	/* data overrun ... flush fifo? */	case -EOVERFLOW:		dev->net->stats.rx_over_errors++;		// FALLTHROUGH	default:		entry->state = rx_cleanup;		dev->net->stats.rx_errors++;		netif_dbg(dev, rx_err, dev->net, "rx status %d/n", urb_status);		break;	}	defer_bh(dev, skb, &dev->rxq);	if (urb) {		if (netif_running (dev->net) &&		    !test_bit (EVENT_RX_HALT, &dev->flags)) {			rx_submit (dev, urb, GFP_ATOMIC);//--------------------------------------------------------#ifdef CONFIG_HTC_QCT_9K_MDM_HSIC_PM_DBG			usb_mark_intf_last_busy(dev->intf, true);#endif	//CONFIG_HTC_QCT_9K_MDM_HSIC_PM_DBG//--------------------------------------------------------			usb_mark_last_busy(dev->udev);			return;		}		//HTC+++		pr_info("%s(%d) [USBNET] usb_free_urb urb:%p !!!/n", __func__, __LINE__, urb);		//HTC---		usb_free_urb (urb);	}	netif_dbg(dev, rx_err, dev->net, "no read resubmitted/n");}

static void rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags){	struct sk_buff		*skb;	struct skb_data		*entry;	int			retval = 0;	unsigned long		lockflags;	size_t			size = dev->rx_urb_size;#if defined(CONFIG_RA_HW_NAT_PCI) && (defined(CONFIG_RA_HW_NAT) || defined(CONFIG_RA_HW_NAT_MODULE))	if ((skb = alloc_skb (size + NET_IP_ALIGN + FOE_INFO_LEN, flags)) == NULL) {#else	if ((skb = alloc_skb (size + NET_IP_ALIGN, flags)) == NULL) {#endif		if (netif_msg_rx_err (dev))			devdbg (dev, "no rx skb");		usbnet_defer_kevent (dev, EVENT_RX_MEMORY);		usb_free_urb (urb);		return;	}#if defined(CONFIG_RA_HW_NAT_PCI) && (defined(CONFIG_RA_HW_NAT) || defined(CONFIG_RA_HW_NAT_MODULE))	skb_reserve (skb, NET_IP_ALIGN + FOE_INFO_LEN);#else	skb_reserve (skb, NET_IP_ALIGN);#endif	entry = (struct skb_data *) skb->cb;	entry->urb = urb;	entry->dev = dev;	entry->length = 0;	usb_fill_bulk_urb (urb, dev->udev, dev->in,		skb->data, size, rx_complete, skb);	spin_lock_irqsave (&dev->rxq.lock, lockflags);	if (netif_running (dev->net)			&& netif_device_present (dev->net)			&& !test_bit (EVENT_RX_HALT, &dev->flags)) {		switch (retval = usb_submit_urb (urb, GFP_ATOMIC)){		case -EPIPE:			usbnet_defer_kevent (dev, EVENT_RX_HALT);			break;		case -ENOMEM:			usbnet_defer_kevent (dev, EVENT_RX_MEMORY);			break;		case -ENODEV:			if (netif_msg_ifdown (dev))				devdbg (dev, "device gone");			netif_device_detach (dev->net);			break;		default:			if (netif_msg_rx_err (dev))				devdbg (dev, "rx submit, %d", retval);			tasklet_schedule (&dev->bh);			break;		case 0:			__usbnet_queue_skb(&dev->rxq, skb, rx_start);		}	} else {		if (netif_msg_ifdown (dev))			devdbg (dev, "rx: stopped");		retval = -ENOLINK;	}	spin_unlock_irqrestore (&dev->rxq.lock, lockflags);	if (retval) {		dev_kfree_skb_any (skb);		usb_free_urb (urb);	}}/*-------------------------------------------------------------------------*/static inline void rx_process (struct usbnet *dev, struct sk_buff *skb){	if (dev->driver_info->rx_fixup			&& !dev->driver_info->rx_fixup (dev, skb))		goto error;	// else network stack removes extra byte if we forced a short packet	if (skb->len)		usbnet_skb_return (dev, skb);	else {		if (netif_msg_rx_err (dev))			devdbg (dev, "drop");error:		dev->stats.rx_errors++;		skb_queue_tail (&dev->done, skb);	}}/*-------------------------------------------------------------------------*/static void rx_complete (struct urb *urb){	struct sk_buff		*skb = (struct sk_buff *) urb->context;	struct skb_data		*entry = (struct skb_data *) skb->cb;	struct usbnet		*dev = entry->dev;	int			urb_status = urb->status;	enum skb_state		state;//.........这里部分代码省略.........

static int rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags){	struct sk_buff		*skb;	struct skb_data		*entry;	int			retval = 0;	unsigned long		lockflags;	size_t			size = dev->rx_urb_size;#if defined (CONFIG_RA_HW_NAT) || defined (CONFIG_RA_HW_NAT_MODULE)	if ((skb = alloc_skb (size + NET_IP_ALIGN + FOE_INFO_LEN, flags)) == NULL) {#else	if ((skb = alloc_skb (size + NET_IP_ALIGN, flags)) == NULL) {#endif		netif_dbg(dev, rx_err, dev->net, "no rx skb/n");		usbnet_defer_kevent (dev, EVENT_RX_MEMORY);		usb_free_urb (urb);		return -ENOMEM;	}#if defined (CONFIG_RA_HW_NAT) || defined (CONFIG_RA_HW_NAT_MODULE)	skb_reserve (skb, NET_IP_ALIGN + FOE_INFO_LEN);#else	skb_reserve (skb, NET_IP_ALIGN);#endif	entry = (struct skb_data *) skb->cb;	entry->urb = urb;	entry->dev = dev;	entry->state = rx_start;	entry->length = 0;	usb_fill_bulk_urb (urb, dev->udev, dev->in,		skb->data, size, rx_complete, skb);	spin_lock_irqsave (&dev->rxq.lock, lockflags);	if (netif_running (dev->net) &&	    netif_device_present (dev->net) &&	    !test_bit (EVENT_RX_HALT, &dev->flags) &&	    !test_bit (EVENT_DEV_ASLEEP, &dev->flags)) {		switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) {		case -EPIPE:			usbnet_defer_kevent (dev, EVENT_RX_HALT);			break;		case -ENOMEM:			usbnet_defer_kevent (dev, EVENT_RX_MEMORY);			break;		case -ENODEV:			netif_dbg(dev, ifdown, dev->net, "device gone/n");			netif_device_detach (dev->net);			break;		case -EHOSTUNREACH:			retval = -ENOLINK;			break;		default:			netif_dbg(dev, rx_err, dev->net,				  "rx submit, %d/n", retval);			tasklet_schedule (&dev->bh);			break;		case 0:			__skb_queue_tail (&dev->rxq, skb);		}	} else {		netif_dbg(dev, ifdown, dev->net, "rx: stopped/n");		retval = -ENOLINK;	}	spin_unlock_irqrestore (&dev->rxq.lock, lockflags);	if (retval) {		dev_kfree_skb_any (skb);		usb_free_urb (urb);	}	return retval;}/*-------------------------------------------------------------------------*/static inline void rx_process (struct usbnet *dev, struct sk_buff *skb){	if (dev->driver_info->rx_fixup &&	    !dev->driver_info->rx_fixup (dev, skb))		goto error;	// else network stack removes extra byte if we forced a short packet	if (skb->len)		usbnet_skb_return (dev, skb);	else {		netif_dbg(dev, rx_err, dev->net, "drop/n");error:		dev->net->stats.rx_errors++;		skb_queue_tail (&dev->done, skb);	}}/*-------------------------------------------------------------------------*/static void rx_complete (struct urb *urb){	struct sk_buff		*skb = (struct sk_buff *) urb->context;	struct skb_data		*entry = (struct skb_data *) skb->cb;	struct usbnet		*dev = entry->dev;//.........这里部分代码省略.........