: Multiqueue network device support
Subsystems (4)
cover : Multiqueue network device support
This is a redesign and repost of the multiqueue network device support patches. The new API for base drivers allows multiqueue-capable devices to manage their individual queues in the network stack. The stack now handles both
non-multiqueue and multiqueue devices on the same codepath. Also, allocation
and deallocation of the queues is handled by the kernel instead of the driver.
Fixes have been integrated into this patchset based on community feedback. A patched version of e1000 using the multiqueue API has also been included. NOTE that this version of e1000 is *only* for testing purposes, and is not intended to be integrated into the kernel at this time. It is only for demonstration purposes.
The e1000 patch will only work with MAC types of 82571 and higher.
Documentation is also included describing in more detail how this works, as well as how a base driver can use the API to implement multiple queues.
These patches can also be pulled from my git repository at:
git-pull git://lost.foo-projects.org/~ppwaskie/git/net-2.6.22 mq
--
Peter P. Waskiewicz Jr.
<[email protected]>
PATCH 1/3 NET: Multiqueue network device support documentation.
From: Peter P Waskiewicz Jr <[email protected]>
Adding documentation for the new multiqueue API.
---
Documentation/networking/multiqueue.txt | 97 +++++++++++++++++++++++++++++++ 1 files changed, 97 insertions(+), 0 deletions(-)
Documentation/networking/multiqueue.txt new file +97 -0
@@ -0,0 +1,97 @@ + + HOWTO for multiqueue network device support + =========================================== + +Section 1: Base driver requirements for implementing multiqueue support +Section 2: Qdisc support for multiqueue devices +Section 3: Brief howto using PRIO for multiqueue devices + + +Intro: Kernel support for multiqueue devices +--------------------------------------------------------- + +Kernel support for multiqueue devices is only an API that is presented to the +netdevice layer for base drivers to implement. This feature is part of the +core networking stack, and all network devices will be running on the +multiqueue-aware stack. If a base driver only has one queue, then these +changes are transparent to that driver. + + +Section 2: Base driver requirements for implementing multiqueue support +----------------------------------------------------------------------- + +Base drivers are required to use the new alloc_etherdev_mq() or +alloc_netdev_mq() functions to allocate the subqueues for the device. The +underlying kernel API will take care of the allocation and deallocation of +the subqueue memory, as well as netdev configuration of where the queues +exist in memory. + +The base driver will also need to manage the queues as it does the global +netdev->queue_lock today. Therefore base drivers should use the +netif_{start|stop|wake}_subqueue() functions to manage each queue while the +device is still operational. netdev->queue_lock is still used when the device +comes online or when it's completely shut down (unregister_netdev(), etc.). + +Finally, the base driver should indicate that it is a multiqueue device. The +feature flag NETIF_F_MULTI_QUEUE should be added to the netdev->features +bitmap on device initialization. Below is an example from e1000: + +#ifdef CONFIG_E1000_MQ + if ( (adapter->hw.mac.type == e1000_82571) || + (adapter->hw.mac.type == e1000_82572) || + (adapter->hw.mac.type == e1000_80003es2lan)) + netdev->features |= NETIF_F_MULTI_QUEUE; +#endif + + +Section 3: Qdisc support for multiqueue devices +----------------------------------------------- + +Currently two qdiscs support multiqueue devices. The default qdisc, pfifo_fast, +and the PRIO qdisc. The qdisc is responsible for classifying the skb's to +bands and queues, and will store the queue mapping into skb->queue_mapping. +Use this field in the base driver to determine which queue to send the skb +to. + +pfifo_fast, being the default qdisc when a device is brought online, will not +assign a queue mapping, therefore the skb will have a value of zero. We +cannot assume anything about the device itself, how many queues it really has, +etc. Therefore sending all traffic to queue 0 is the safest thing to do here. + +The PRIO qdisc naturally plugs into a multiqueue device. Upon load of the +qdisc, PRIO will make a best-effort assignment of queue to PRIO band to evenly +distribute traffic flows. The algorithm can be found in prio_tune() in +net/sched/sch_prio.c. Once the association is made, any skb that is +classified will have skb->queue_mapping set, which will allow the driver to +properly queue skb's to multiple queues. + + +Section 4: Brief howto using PRIO for multiqueue devices +-------------------------------------------------------- + +The userspace command 'tc,' part of the iproute2 package, is used to configure +qdiscs. To add the PRIO qdisc to your network device, assuming the device is +called eth0, run the following command: + +# tc qdisc add dev eth0 root handle 1: prio + +This will create 3 bands, 0 being highest priority, and associate those bands +to the queues on your NIC. Assuming eth0 has 2 Tx queues, the band mapping +would look like: + +band 0 => queue 0 +band 1 => queue 1 +band 2 => queue 1 + +Traffic will begin flowing through each queue if your TOS values are assigning +traffic across the various bands. For example, ssh traffic will always try to +go out band 0 based on TOS -> Linux priority conversion (realtime traffic), +so it will be sent out queue 0. ICMP traffic (pings) fall into the "normal" +traffic classification, which is band 1. Therefore pings will be send out +queue 1 on the NIC. + +The behavior of tc filters remains the same, where it will override TOS priority +classification. + + +Author: Peter P. Waskiewicz Jr. <[email protected]>
PATCH 2/3 NET: [UPDATED] Multiqueue network device support implementation.
In reply to Peter P Waskiewicz JrFrom: Peter P Waskiewicz Jr <[email protected]>
Update: Removed unnecessary whitespace removals. Reset skb->queue_mapping to zero prior to enqueueing to a qdisc. Fixed band2queue mapping algorithm for bands less than queues.
Added an API and associated supporting routines for multiqueue network devices. This allows network devices supporting multiple TX queues to configure each queue within the netdevice and manage each queue independantly. Changes to the PRIO Qdisc also allow a user to map multiple flows to individual TX queues, taking advantage of each queue on the device.
---
include/linux/etherdevice.h | 3 +- include/linux/netdevice.h | 62 ++++++++++++++++++++++++++++++++++++++++++- include/linux/skbuff.h | 2 + net/core/dev.c | 27 +++++++++++++++---- net/core/skbuff.c | 3 ++ net/ethernet/eth.c | 9 +++--- net/sched/sch_generic.c | 3 +- net/sched/sch_prio.c | 54 +++++++++++++++++++++++++++++++++---- 8 files changed, 144 insertions(+), 19 deletions(-)
include/linux/etherdevice.h +2 -1
@@ -39,7 +39,8 @@ extern void eth_header_cache_update(struct hh_cache *hh, struct net_device *devextern int eth_header_cache (struct neighbour *neigh,struct hh_cache *hh); -extern struct net_device *alloc_etherdev (int sizeof_priv); +extern struct net_device *alloc_etherdev_mq (int sizeof_priv,int queue_count); +#define alloc_etherdev (sizeof_priv) alloc_etherdev_mq(sizeof_priv, 1)static inline void eth_copy_and_sum (struct sk_buff *dest,const unsigned char *src,int len,int base)
include/linux/netdevice.h +60 -2
92 lines not on this page · raw message
include/linux/skbuff.h +2 -0
@@ -212,6 +212,7 @@ typedef unsigned char *sk_buff_data_t;* @pkt_type: Packet class * @fclone: skbuff clone status * @ip_summed: Driver fed us an IP checksum +* @queue_mapping: Queue mapping for multiqueue devices * @priority: Packet queueing priority * @users: User count - see {datagram,tcp}.c * @protocol: Packet protocol from driver
@@ -264,6 +265,7 @@ struct sk_buff {__wsum csum;__u32 csum_offset; }; +__u16 queue_mapping;__u32 priority; __u8 local_df:1, cloned:1,
net/core/dev.c +22 -5
@@ -1471,6 +1471,8 @@ gso: q = dev->qdisc;if (q->enqueue) { rc = q->enqueue (skb, q); +/* reset queue_mapping to zero */ + skb->queue_mapping =0 ;qdisc_run (dev);spin_unlock (&dev->queue_lock);
@@ -3292,16 +3294,18 @@ static struct net_device_stats *maybe_internal_stats(struct net_device *dev) }/** -* alloc_netdev - allocate network device +* alloc_netdev_mq - allocate network device * @sizeof_priv: size of private data to allocate space for * @name: device name format string * @setup: callback to initialize device +* @queue_count: the number of subqueues to allocate * * Allocates a struct net_device with private data area for driver use -* and performs basic initialization. +* and performs basic initialization. Also allocates subqueue structs +* for each queue on the device. */ -struct net_device *alloc_netdev (int sizeof_priv,const char *name, -void (*setup)(struct net_device *)) +struct net_device *alloc_netdev_mq (int sizeof_priv,const char *name, +void (*setup)(struct net_device *),int queue_count) {void *p;struct net_device *dev;
@@ -3326,12 +3330,23 @@ struct net_device *alloc_netdev(int sizeof_priv, const char *name,if (sizeof_priv) dev->priv =netdev_priv (dev); + alloc_size = (sizeof (struct net_device_subqueue ) * queue_count); + + p =kzalloc (alloc_size,GFP_KERNEL ); +if (!p) { +printk (KERN_ERR "alloc_netdev: Unable to allocate queues.\n" ); +return NULL ; + } + + dev->egress_subqueue = p; + dev->egress_subqueue_count = queue_count; + dev->get_stats = maybe_internal_stats;setup (dev);strcpy (dev->name, name);return dev; } -EXPORT_SYMBOL (alloc_netdev); +EXPORT_SYMBOL (alloc_netdev_mq);/** * free_netdev - free network device
@@ -3345,6 +3360,7 @@ void free_netdev(struct net_device *dev) {#ifdef CONFIG_SYSFS /* Compatibility with error handling in drivers */ +kfree (dev->egress_subqueue);if (dev->reg_state ==NETREG_UNINITIALIZED ) {kfree ((char *)dev - dev->padded);return ;
@@ -3356,6 +3372,7 @@ void free_netdev(struct net_device *dev)/* will free via device release */ put_device (&dev->dev);#else +kfree (dev->egress_subqueue);kfree ((char *)dev - dev->padded);#endif }
net/core/skbuff.c +3 -0
@@ -474,6 +474,7 @@ struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t gfp_mask) n->nohdr =0 ;C (pkt_type);C (ip_summed); +C (queue_mapping);C (priority);#if defined(CONFIG_IP_VS ) || defined(CONFIG_IP_VS_MODULE )C (ipvs_property);
@@ -516,6 +517,7 @@ static void copy_skb_header(struct sk_buff *new, const struct sk_buff *old)#endif new->sk =NULL ; new->dev = old->dev; + new->queue_mapping = old->queue_mapping; new->priority = old->priority; new->protocol = old->protocol; new->dst =dst_clone (old->dst);
@@ -1974,6 +1976,7 @@ struct sk_buff *skb_segment(struct sk_buff *skb, int features) tail = nskb; nskb->dev = skb->dev; + nskb->queue_mapping = skb->queue_mapping; nskb->priority = skb->priority; nskb->protocol = skb->protocol; nskb->dst =dst_clone (skb->dst);
net/ethernet/eth.c +5 -4
@@ -316,9 +316,10 @@ void ether_setup(struct net_device *dev)EXPORT_SYMBOL (ether_setup);/** -* alloc_etherdev - Allocates and sets up an Ethernet device +* alloc_etherdev_mq - Allocates and sets up an Ethernet device * @sizeof_priv: Size of additional driver-private structure to be allocated * for this Ethernet device +* @queue_count: The number of queues this device has. * * Fill in the fields of the device structure with Ethernet-generic * values. Basically does everything except registering the device.
@@ -328,8 +329,8 @@ EXPORT_SYMBOL(ether_setup);* this private data area. */ -struct net_device *alloc_etherdev (int sizeof_priv) +struct net_device *alloc_etherdev_mq (int sizeof_priv,int queue_count) { -return alloc_netdev (sizeof_priv,"eth%d" , ether_setup); +return alloc_netdev_mq (sizeof_priv,"eth%d" , ether_setup, queue_count); } -EXPORT_SYMBOL (alloc_etherdev); +EXPORT_SYMBOL (alloc_etherdev_mq);
net/sched/sch_generic.c +2 -1
@@ -133,7 +133,8 @@ static inline int qdisc_restart(struct net_device *dev)/* And release queue */ spin_unlock (&dev->queue_lock); -if (!netif_queue_stopped (dev)) { +if (!netif_queue_stopped (dev) && + !netif_subqueue_stopped (dev, skb->queue_mapping)) {int ret; ret =dev_hard_start_xmit (skb, dev);
net/sched/sch_prio.c +48 -6
90 lines not on this page · raw message
Re: [PATCH 2/3] NET: [UPDATED] Multiqueue network device support implementation.
net/core/dev.c gso: · line 1475
Quoted 10 lines · Peter P Waskiewicz Jr
net/core/dev.c +2
-0@@ -1471,6 +1471,8 @@ gso: q = dev->qdisc;if (q->enqueue) { rc = q->enqueue (skb, q); +/* reset queue_mapping to zero */ + skb->queue_mapping =0 ;
This must be done before enqueueing. At this point you don't even have a valid reference to the skb anymore.
net/core/dev.c struct net_device *alloc_netdev(int sizeof_priv, const char *name, · line 3338
Quoted 10 lines
net/core/dev.c +6
-0@@ -3326,12 +3330,23 @@ struct net_device *alloc_netdev(int sizeof_priv, const char *name,if (sizeof_priv) dev->priv =netdev_priv (dev); + alloc_size = (sizeof (struct net_device_subqueue ) * queue_count); + + p =kzalloc (alloc_size,GFP_KERNEL ); +if (!p) { +printk (KERN_ERR "alloc_netdev: Unable to allocate queues.\n" ); +return NULL ;
Still leaks the device
Quoted 58 lines
net/sched/sch_prio.c +31
-5@@ -144,11 +152,17 @@ prio_dequeue(struct Qdisc* sch)struct Qdisc *qdisc;for (prio =0 ; prio < q->bands; prio++) { - qdisc = q->queues[prio]; - skb = qdisc->dequeue (qdisc); -if (skb) { - sch->q.qlen--; -return skb; +/* Check if the target subqueue is available before +* pulling an skb. This way we avoid excessive requeues +* for slower queues. +*/ +if (!netif_subqueue_stopped (sch->dev, q->band2queue[prio])) { + qdisc = q->queues[prio]; + skb = qdisc->dequeue (qdisc); +if (skb) { + sch->q.qlen--; +return skb; + } } }return NULL ;@@ -200,6 +214,10 @@ static int prio_tune(struct Qdisc *sch, struct rtattr *opt)struct prio_sched_data *q =qdisc_priv (sch);struct tc_prio_qopt *qopt =RTA_DATA (opt);int i; +int queue; +int qmapoffset; +int offset; +int mod;if (opt->rta_len <RTA_LENGTH (sizeof (*qopt)))return -EINVAL ;@@ -242,6 +260,30 @@ static int prio_tune(struct Qdisc *sch, struct rtattr *opt) } } } +/* setup queue to band mapping */ +if (q->bands < sch->dev->egress_subqueue_count) { + qmapoffset =1 ; + mod = sch->dev->egress_subqueue_count; + }else { + mod = q->bands % sch->dev->egress_subqueue_count; + qmapoffset = q->bands / sch->dev->egress_subqueue_count + + ((mod) ?1 :0 ); + } + + queue =0 ; + offset =0 ; +for (i =0 ; i < q->bands; i++) { + q->band2queue[i] = queue; +if ( ((i +1 ) - offset) == qmapoffset) { + queue++;
net/sched/sch_prio.c static int prio_tune(struct Qdisc *sch, struct rtattr *opt) · line 288
Quoted 10 lines
net/sched/sch_prio.c +8
-0+ offset += qmapoffset; +if (mod) + mod--; + qmapoffset = q->bands / + sch->dev->egress_subqueue_count + + ((mod) ?1 :0 ); + } + }return 0 ; }
I stand by my point, this needs to be explicitly enabled by the user since it changes the behaviour of prio on multiqueue capable device.
RE: [PATCH 2/3] NET: [UPDATED] Multiqueue network device support implementation.
Quoted 11 lines
-----Original Message-----
From: Patrick McHardy [mailto:[email protected]]
Sent: Thursday, April 12, 2007 5:16 PM
To: Waskiewicz Jr, Peter P
Cc: [email protected]; [email protected]; [email protected]; [email protected]; cramerj; Kok, Auke-jan H; Leech, Christopher
Subject: Re: [PATCH 2/3] NET: [UPDATED] Multiqueue network device support implementation.Peter P Waskiewicz Jr wrote:
Quoted 14 lines
net/core/dev.c gso: · line 1475
Quoted 10 lines
net/core/dev.c index 219a57f..3ce449e renamed from net/core/dev.c +0
-0100644
net/core/dev.c +2
-0@@ -1471,6 +1471,8 @@ gso: q = dev->qdisc;if (q->enqueue) { rc = q->enqueue (skb, q); +/* reset queue_mapping to zero */ + skb->queue_mapping =0 ;This must be done before enqueueing. At this point you don't even have a valid reference to the skb anymore.
Agreed, this is a transcription error on my part between my dev box and this tree.
Quoted 11 lines
net/core/dev.c struct net_device *alloc_netdev(int
Quoted 2 lines
net/core/dev.c +0
-0@@ -3326,12 +3330,23 @@ struct net_device *alloc_netdev(int
sizeof_priv, const char *name,net/core/dev.c struct net_device *alloc_netdev(int sizeof_priv, const char *name,
Quoted 8 lines
net/core/dev.c +5
-0if (sizeof_priv) dev->priv =netdev_priv (dev); + alloc_size = (sizeof (struct net_device_subqueue ) * queue_count); + + p =kzalloc (alloc_size,GFP_KERNEL ); + if (!p) { + printk(KERN_ERR "alloc_netdev: Unable to
Quoted 5 lines
allocate queues.\n");
net/core/dev.c struct net_device *alloc_netdev(int sizeof_priv, const char *name, · line 3338
Quoted 1 line
net/core/dev.c +1
-0+return NULL ;Still leaks the device
I explained this in a previous response, and you seemed to be ok with the explanation. Can you elaborate if this is still an issue?
Quoted 70 lines
Quoted 9 lines
net/sched/sch_prio.c index renamed from net/sched/sch_prio.c +0
-05cfe60b..6a38905 100644
net/sched/sch_prio.c +0
-0@@ -144,11 +152,17 @@ prio_dequeue(struct Qdisc* sch)struct Qdisc *qdisc;for (prio =0 ; prio < q->bands; prio++) {net/sched/sch_prio.c prio_dequeue(struct Qdisc* sch) · line 159
Quoted 10 lines
net/sched/sch_prio.c +5
-5- qdisc = q->queues[prio]; - skb = qdisc->dequeue (qdisc); -if (skb) { - sch->q.qlen--; -return skb; +/* Check if the target subqueue is available before +* pulling an skb. This way we avoid excessive requeues +* for slower queues. +*/ + if (!netif_subqueue_stopped(sch->dev,q->band2queue[prio])) {
net/sched/sch_prio.c static int prio_tune(struct Qdisc
Quoted 10 lines
net/sched/sch_prio.c +6
-0+ qdisc = q->queues[prio]; + skb = qdisc->dequeue (qdisc); +if (skb) { + sch->q.qlen--; +return skb; + } } }return NULL ;@@ -200,6 +214,10 @@ static int prio_tune(struct Qdisc*sch, struct rtattr *opt)
net/sched/sch_prio.c static int prio_tune(struct Qdisc
Quoted 11 lines
net/sched/sch_prio.c +4
-0struct prio_sched_data *q =qdisc_priv (sch);struct tc_prio_qopt *qopt =RTA_DATA (opt);int i; +int queue; +int qmapoffset; +int offset; +int mod;if (opt->rta_len <RTA_LENGTH (sizeof (*qopt)))return -EINVAL ;@@ -242,6 +260,30 @@ static int prio_tune(struct Qdisc*sch, struct rtattr *opt)
net/sched/sch_prio.c static int prio_tune(struct Qdisc *sch, struct rtattr *opt) · line 282
Quoted 10 lines
net/sched/sch_prio.c +7
-0} } } +/* setup queue to band mapping */ +if (q->bands < sch->dev->egress_subqueue_count) { + qmapoffset =1 ; + mod = sch->dev->egress_subqueue_count; + }else { + mod = q->bands % sch->dev->egress_subqueue_count; + qmapoffset = q->bands /
sch->dev->egress_subqueue_count+Quoted 16 lines
net/sched/sch_prio.c +16
-0+ ((mod) ?1 :0 ); + } + + queue =0 ; + offset =0 ; +for (i =0 ; i < q->bands; i++) { + q->band2queue[i] = queue; +if ( ((i +1 ) - offset) == qmapoffset) { + queue++; + offset += qmapoffset; +if (mod) + mod--; + qmapoffset = q->bands / + sch->dev->egress_subqueue_count + + ((mod) ?1 :0 ); + }
Quoted 9 lines
net/sched/sch_prio.c static int prio_tune(struct Qdisc *sch, struct rtattr *opt) · line 288
Quoted 3 lines
net/sched/sch_prio.c +1
-0+ }return 0 ; }I stand by my point, this needs to be explicitly enabled by the user since it changes the behaviour of prio on multiqueue capable device.
The user can enable this by using TC filters. I do understand what you mean that PRIO's behavior somewhat changes because of how the queues turn off and on, but how is this different than today? Today, if the queue on the NIC shuts down, all the PRIO queues are down. This way it's actually helping get traffic out. I don't see how the user can control which queue is shut down; that is a function of how congested the network is. So if I can clarify what you're saying, are you asking that the user actually setup the band to queue mapping? Because if so, I don't see how that would help since queues today don't have any priority, and you would have no control which one stops over another one.
Re: [PATCH 2/3] NET: [UPDATED] Multiqueue network device support implementation.
Quoted 5 lines · Peter P
Quoted 1 line
Still leaks the device
I explained this in a previous response, and you seemed to be ok with the explanation. Can you elaborate if this is still an issue?
I'm OK with allocating subqueues even for single queue devices, not with leaking memory on error.
Quoted 9 lines
Quoted 3 lines
I stand by my point, this needs to be explicitly enabled by the user since it changes the behaviour of prio on multiqueue capable device.
The user can enable this by using TC filters. I do understand what you mean that PRIO's behavior somewhat changes because of how the queues turn off and on, but how is this different than today? Today, if the queue on the NIC shuts down, all the PRIO queues are down.
Right. And if the queue is enabled again, bands continue to be dequeued in strict priority order.
Quoted 8 lines
This way
it's actually helping get traffic out. I don't see how the user can control which queue is shut down; that is a function of how congested the network is. So if I can clarify what you're saying, are you asking that the user actually setup the band to queue mapping? Because if so, I don't see how that would help since queues today don't have any priority, and you would have no control which one stops over another one.
No, I'm asking that the users explicitly states that he wants the driver to control which bands are dequeued (by stopping and starting subqueues) and not the established strict priority order. You assume everyone using prio on e1000 wants to use multiple HW queues, which is not necessarily true. Additionally the prio qdisc might be used as child of a classful qdisc that assumes it can always dequeue packets as long as q.qlen > 0 (HFSC for example will complain if it can't since that is a configuration error).
So I'm asking that you only enable this behaviour if the user does something like this:
tc qdisc add dev eth0 root handle 1: prio bands N multiqueue
Ideally the band2queue mapping would be supplied by userspace as well, but currently that doesn't seem to be possible in a clean way since userspace has no way of finding out how many queues the HW supports.
PATCH 3/3 NET: [e1000] Example implementation of multiqueue network device API
In reply to Peter P Waskiewicz JrFrom: Peter P Waskiewicz Jr <[email protected]>
This patch is *not* intended to be integrated into any tree please. This is fulfilling a request to demonstrate the proposed multiqueue network device API in a driver. The necessary updates to the e1000 driver will come in a more official release. This is an as-is patch to this version of e1000, and should not be used outside of testing purposes only.
---
drivers/net/e1000/e1000.h | 8 ++ drivers/net/e1000/e1000_ethtool.c | 47 ++++++++++- drivers/net/e1000/e1000_main.c | 164 ++++++++++++++++++++++++++++++++----- 3 files changed, 194 insertions(+), 25 deletions(-)
drivers/net/e1000/e1000.h +8 -0
@@ -168,6 +168,10 @@ struct e1000_buffer {uint16_t next_to_watch; }; +struct e1000_queue_stats { +u64 packets; +u64 bytes; +};struct e1000_ps_page {struct page *ps_page[PS_PAGE_BUFFERS ]; };struct e1000_ps_page_dma {uint64_t ps_page_dma[PS_PAGE_BUFFERS ]; };
@@ -188,9 +192,11 @@ struct e1000_tx_ring {/* array of buffer information structs */ struct e1000_buffer *buffer_info; +spinlock_t tx_queue_lock;spinlock_t tx_lock;uint16_t tdh;uint16_t tdt; +struct e1000_queue_stats tx_stats;boolean_t last_tx_tso; };
@@ -218,6 +224,7 @@ struct e1000_rx_ring {uint16_t rdh;uint16_t rdt; +struct e1000_queue_stats rx_stats; };#define E1000_DESC_UNUSED (R ) \
@@ -271,6 +278,7 @@ struct e1000_adapter {/* TX */ struct e1000_tx_ring *tx_ring;/* One per active queue */ +struct e1000_tx_ring **cpu_tx_ring;unsigned int restart_queue;unsigned long tx_queue_len;uint32_t txd_cmd;
drivers/net/e1000/e1000_ethtool.c +45 -2
84 lines not on this page · raw message
drivers/net/e1000/e1000_main.c +141 -23
326 lines not on this page · raw message