[Xen-devel] [PATCH net-next 7/8] xen-netback: add support for a multi-queue hash mapping table

[Paul Durrant <paul.durrant@xxxxxxxxxx>]

Advertise the capability to handle a hash mapping specified by the
frontend (see netif.h for details).

Add an ndo_select() entry point so that, of the frontend does specify a
hash mapping, the skb hash is extracted and mapped to a queue. If no
mapping is specified then the fallback queue selection function is
called so there is no change in behaviour.

Signed-off-by: Paul Durrant <paul.durrant@xxxxxxxxxx>
Cc: Ian Campbell <ian.campbell@xxxxxxxxxx>
Cc: Wei Liu <wei.liu2@xxxxxxxxxx>
---
 drivers/net/xen-netback/common.h    |   7 ++
 drivers/net/xen-netback/interface.c |  14 ++++
 drivers/net/xen-netback/xenbus.c    | 154 ++++++++++++++++++++++++++++++------
 3 files changed, 152 insertions(+), 23 deletions(-)

diff --git a/drivers/net/xen-netback/common.h b/drivers/net/xen-netback/common.h
index 1bce5a5..23f2275 100644
--- a/drivers/net/xen-netback/common.h
+++ b/drivers/net/xen-netback/common.h
@@ -212,6 +212,8 @@ struct xenvif_mcast_addr {
 
 #define XEN_NETBK_MCAST_MAX 64
 
+#define XEN_NETBK_MAX_HASH_MAPPING_SIZE 128
+
 struct xenvif {
        /* Unique identifier for this interface. */
        domid_t          domid;
@@ -244,7 +246,12 @@ struct xenvif {
        unsigned int num_queues; /* active queues, resource allocated */
        unsigned int stalled_queues;
 
+       struct {
+               unsigned int table[XEN_NETBK_MAX_HASH_MAPPING_SIZE];
+               unsigned int length;
+       } hash_mapping;
        struct xenbus_watch credit_watch;
+       struct xenbus_watch hash_mapping_watch;
 
        spinlock_t lock;
 
diff --git a/drivers/net/xen-netback/interface.c 
b/drivers/net/xen-netback/interface.c
index e7bd63e..0c7da7b 100644
--- a/drivers/net/xen-netback/interface.c
+++ b/drivers/net/xen-netback/interface.c
@@ -142,6 +142,19 @@ void xenvif_wake_queue(struct xenvif_queue *queue)
        netif_tx_wake_queue(netdev_get_tx_queue(dev, id));
 }
 
+static u16 xenvif_select_queue(struct net_device *dev, struct sk_buff *skb,
+                              void *accel_priv,
+                              select_queue_fallback_t fallback)
+{
+       struct xenvif *vif = netdev_priv(dev);
+
+       if (vif->hash_mapping.length == 0)
+               return fallback(dev, skb) % dev->real_num_tx_queues;
+
+       return vif->hash_mapping.table[skb_get_hash_raw(skb) %
+                                      vif->hash_mapping.length];
+}
+
 static int xenvif_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
        struct xenvif *vif = netdev_priv(dev);
@@ -386,6 +399,7 @@ static const struct ethtool_ops xenvif_ethtool_ops = {
 };
 
 static const struct net_device_ops xenvif_netdev_ops = {
+       .ndo_select_queue = xenvif_select_queue,
        .ndo_start_xmit = xenvif_start_xmit,
        .ndo_get_stats  = xenvif_get_stats,
        .ndo_open       = xenvif_open,
diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c
index a31bcee..f5ed945 100644
--- a/drivers/net/xen-netback/xenbus.c
+++ b/drivers/net/xen-netback/xenbus.c
@@ -367,6 +367,13 @@ static int netback_probe(struct xenbus_device *dev,
        if (err)
                pr_debug("Error writing multi-queue-max-queues\n");
 
+       /* Multi-queue mapping support: This is an optional feature. */
+       err = xenbus_printf(XBT_NIL, dev->nodename,
+                           "multi-queue-max-hash-mapping-length", "%u",
+                           XEN_NETBK_MAX_HASH_MAPPING_SIZE);
+       if (err)
+               pr_debug("Error writing multi-queue-max-hash-mapping-length\n");
+
        script = xenbus_read(XBT_NIL, dev->nodename, "script", NULL);
        if (IS_ERR(script)) {
                err = PTR_ERR(script);
@@ -691,38 +698,139 @@ static void xen_net_rate_changed(struct xenbus_watch 
*watch,
        }
 }
 
-static int xen_register_watchers(struct xenbus_device *dev, struct xenvif *vif)
+static void xen_net_read_multi_queue_hash_mapping(struct xenvif *vif)
+{
+       struct xenbus_device *dev = xenvif_to_xenbus_device(vif);
+       char *str, *token;
+       unsigned int *table;
+       unsigned int n, i;
+
+       str = xenbus_read(XBT_NIL, dev->otherend,
+                         "multi-queue-hash-mapping", NULL);
+       if (IS_ERR(str))
+               goto fail1;
+
+       table = kcalloc(ARRAY_SIZE(vif->hash_mapping.table),
+                       sizeof(unsigned int),
+                       GFP_KERNEL);
+       if (!table) {
+               pr_err("%s: failed to allocate mapping table\n",
+                      dev->nodename);
+               goto fail2;
+       }
+
+       n = 0;
+       while ((token = strsep(&str, ",")) != NULL) {
+               int rc;
+
+               if (n >= ARRAY_SIZE(vif->hash_mapping.table)) {
+                       pr_err("%s: mapping table too big\n",
+                              dev->nodename);
+                       goto fail3;
+               }
+
+               rc = kstrtouint(token, 0, &table[n]);
+               if (rc < 0) {
+                       pr_err("%s: invalid mapping table value (%s at index 
%u)\n",
+                              dev->nodename, token, n);
+                       goto fail3;
+               }
+
+               n++;
+       }
+
+       if (n == 0) {
+               pr_err("%s: invalid mapping table\n", dev->nodename);
+               goto fail3;
+       }
+
+       vif->hash_mapping.length = n;
+
+       for (i = 0; i < n; i++)
+               vif->hash_mapping.table[i] =
+                       (table[i] < vif->num_queues) ? table[i] : 0;
+
+       kfree(table);
+       kfree(str);
+       return;
+
+fail3:
+       kfree(table);
+fail2:
+       kfree(str);
+fail1:
+       vif->hash_mapping.length = 0;
+}
+
+static void xen_hash_mapping_changed(struct xenbus_watch *watch,
+                                    const char **vec, unsigned int len)
+{
+       struct xenvif *vif = container_of(watch, struct xenvif,
+                                         hash_mapping_watch);
+
+       xen_net_read_multi_queue_hash_mapping(vif);
+}
+
+static int xenvif_register_watch(const char *prefix, const char *name,
+                                void (*callback)(struct xenbus_watch *,
+                                                 const char **vec,
+                                                 unsigned int len),
+                                struct xenbus_watch *watch)
 {
-       int err = 0;
+       unsigned int len;
        char *node;
-       unsigned maxlen = strlen(dev->nodename) + sizeof("/rate");
+       int err;
 
-       if (vif->credit_watch.node)
+       if (watch->node)
                return -EADDRINUSE;
 
-       node = kmalloc(maxlen, GFP_KERNEL);
+       len = strlen(prefix) + 1 + strlen(name) + 1;
+
+       node = kmalloc(len, GFP_KERNEL);
        if (!node)
                return -ENOMEM;
-       snprintf(node, maxlen, "%s/rate", dev->nodename);
-       vif->credit_watch.node = node;
-       vif->credit_watch.callback = xen_net_rate_changed;
-       err = register_xenbus_watch(&vif->credit_watch);
+
+       snprintf(node, len, "%s/%s", prefix, name);
+       watch->node = node;
+       watch->callback = callback;
+       err = register_xenbus_watch(watch);
        if (err) {
-               pr_err("Failed to set watcher %s\n", vif->credit_watch.node);
+               pr_err("Failed to set watch %s\n", node);
                kfree(node);
-               vif->credit_watch.node = NULL;
-               vif->credit_watch.callback = NULL;
+               watch->node = NULL;
+               watch->callback = NULL;
        }
        return err;
 }
 
+static void xenvif_unregister_watch(struct xenbus_watch *watch)
+{
+       if (!watch->node)
+               return;
+
+       unregister_xenbus_watch(watch);
+       kfree(watch->node);
+
+       watch->node = NULL;
+       watch->callback = NULL;
+}
+
+static void xen_register_watchers(struct xenbus_device *dev, struct xenvif 
*vif)
+{
+       xenvif_register_watch(dev->nodename, "rate",
+                             xen_net_rate_changed,
+                             &vif->credit_watch);
+
+       xenvif_register_watch(dev->otherend,
+                             "multi-queue-hash-mapping",
+                             xen_hash_mapping_changed,
+                             &vif->hash_mapping_watch);
+}
+
 static void xen_unregister_watchers(struct xenvif *vif)
 {
-       if (vif->credit_watch.node) {
-               unregister_xenbus_watch(&vif->credit_watch);
-               kfree(vif->credit_watch.node);
-               vif->credit_watch.node = NULL;
-       }
+       xenvif_unregister_watch(&vif->hash_mapping_watch);
+       xenvif_unregister_watch(&vif->credit_watch);
 }
 
 static void unregister_hotplug_status_watch(struct backend_info *be)
@@ -782,6 +890,12 @@ static void connect(struct backend_info *be)
                return;
        }
 
+       /* Use the number of queues requested by the frontend */
+       be->vif->queues = vzalloc(requested_num_queues *
+                                 sizeof(struct xenvif_queue));
+       be->vif->num_queues = requested_num_queues;
+       be->vif->stalled_queues = requested_num_queues;
+
        err = xen_net_read_mac(dev, be->vif->fe_dev_addr);
        if (err) {
                xenbus_dev_fatal(dev, err, "parsing %s/mac", dev->nodename);
@@ -793,12 +907,6 @@ static void connect(struct backend_info *be)
        xen_register_watchers(dev, be->vif);
        read_xenbus_vif_flags(be);
 
-       /* Use the number of queues requested by the frontend */
-       be->vif->queues = vzalloc(requested_num_queues *
-                                 sizeof(struct xenvif_queue));
-       be->vif->num_queues = requested_num_queues;
-       be->vif->stalled_queues = requested_num_queues;
-
        for (queue_index = 0; queue_index < requested_num_queues; 
++queue_index) {
                queue = &be->vif->queues[queue_index];
                queue->vif = be->vif;
-- 
2.1.4


_______________________________________________
Xen-devel mailing list
Xen-devel@xxxxxxxxxxxxx
http://lists.xen.org/xen-devel