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.
The PRIO qdisc is now modified to run in single-queue mode on multiqueue devices by default. A modification to tc is in another patchset being sent that allows multiqueue behavior to be turned on for PRIO.
Documentation is also included describing in more detail how this works, as wellas 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/netdev-2.6.22 mq
--
Peter P. Waskiewicz Jr.
<[email protected]>
PATCH 1/2 Adding documentation for the new multiqueue API.
From: Peter P Waskiewicz Jr <[email protected]>
Signed-off-by Peter P. Waskiewicz Jr <[email protected]>
Signed-off-by Auke Kok <[email protected]>
---
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 multiqueue + +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 0 +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/2 NET: [UPDATED] Multiqueue network device support implementation.
In reply to Peter P Waskiewicz JrFrom: Peter P Waskiewicz Jr <[email protected]>
Update: Fixed band2queue mapping logic - it was reveresed with prio2band. Added support in the PRIO qdisc to allow tc to turn on multiqueue behavior, while keeping original PRIO behavior by default. Fixed where skb->queue_mapping is being reset (prior to q->enqueue() ).
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.
Signed-off-by Peter P. Waskiewicz Jr <[email protected]>
Signed-off-by Auke Kok <[email protected]>
---
include/linux/etherdevice.h | 3 +- include/linux/netdevice.h | 66 ++++++++++++++++++++++++++++++++++++++++++- include/linux/pkt_sched.h | 1 + include/linux/skbuff.h | 2 + net/core/dev.c | 28 +++++++++++++++--- net/core/skbuff.c | 3 ++ net/ethernet/eth.c | 9 +++--- net/sched/sch_generic.c | 4 +-- net/sched/sch_prio.c | 66 +++++++++++++++++++++++++++++++++++++++---- 9 files changed, 162 insertions(+), 20 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 +64 -2
96 lines not on this page · raw message
include/linux/pkt_sched.h +1 -0
@@ -99,6 +99,7 @@ struct tc_prio_qopt {int bands;/* Number of bands */ __u8 priomap[TC_PRIO_MAX +1 ];/* Map: logical priority -> PRIO band */ +unsigned short multiqueue;/* 0 for non-mq, 1 for mq */ };/* TBF section */
include/linux/skbuff.h +2 -0
@@ -215,6 +215,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
@@ -269,6 +270,7 @@ struct sk_buff {__u16 csum_offset; }; }; +__u16 queue_mapping;__u32 priority; __u8 local_df:1, cloned:1,
net/core/dev.c +23 -5
@@ -1464,6 +1464,8 @@ gso:spin_lock (&dev->queue_lock); q = dev->qdisc;if (q->enqueue) { +/* reset queue_mapping to zero */ + skb->queue_mapping =0 ; rc = q->enqueue (skb, q);qdisc_run (dev);spin_unlock (&dev->queue_lock);
@@ -3291,16 +3293,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;
@@ -3325,12 +3329,24 @@ 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" ); +kfree ((char *)dev - dev->padded); +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
@@ -3344,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 ;
@@ -3355,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
@@ -418,6 +418,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);
@@ -459,6 +460,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);
@@ -1926,6 +1928,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 -2
@@ -126,7 +126,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);
@@ -142,7 +143,6 @@ static inline int qdisc_restart(struct net_device *dev) goto collision; } } -/* NETDEV_TX_BUSY - we need to requeue */ /* Release the driver */ if (!nolock) {
net/sched/sch_prio.c +60 -6
108 lines not on this page · raw message