Merge rsync://rsync.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

1 files changed, 333 insertions, 0 deletions

diff --git a/drivers/infiniband/hw/ipath/ipath_verbs_mcast.c b/drivers/infiniband/hw/ipath/ipath_verbs_mcast.c
new file mode 100644
index 000000000000..10b31d2c4f20
--- /dev/null
+++ b/drivers/infiniband/hw/ipath/ipath_verbs_mcast.c
@@ -0,0 +1,333 @@
+/*
+ * Copyright (c) 2005, 2006 PathScale, Inc. All rights reserved.
+ *
+ * This software is available to you under a choice of one of two
+ * licenses.  You may choose to be licensed under the terms of the GNU
+ * General Public License (GPL) Version 2, available from the file
+ * COPYING in the main directory of this source tree, or the
+ * OpenIB.org BSD license below:
+ *
+ *     Redistribution and use in source and binary forms, with or
+ *     without modification, are permitted provided that the following
+ *     conditions are met:
+ *
+ *      - Redistributions of source code must retain the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer.
+ *
+ *      - Redistributions in binary form must reproduce the above
+ *        copyright notice, this list of conditions and the following
+ *        disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+ * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include <linux/list.h>
+#include <linux/rcupdate.h>
+
+#include "ipath_verbs.h"
+
+/*
+ * Global table of GID to attached QPs.
+ * The table is global to all ipath devices since a send from one QP/device
+ * needs to be locally routed to any locally attached QPs on the same
+ * or different device.
+ */
+static struct rb_root mcast_tree;
+static DEFINE_SPINLOCK(mcast_lock);
+
+/**
+ * ipath_mcast_qp_alloc - alloc a struct to link a QP to mcast GID struct
+ * @qp: the QP to link
+ */
+static struct ipath_mcast_qp *ipath_mcast_qp_alloc(struct ipath_qp *qp)
+{
+        struct ipath_mcast_qp *mqp;
+
+        mqp = kmalloc(sizeof *mqp, GFP_KERNEL);
+        if (!mqp)
+                goto bail;
+
+        mqp->qp = qp;
+        atomic_inc(&qp->refcount);
+
+bail:
+        return mqp;
+}
+
+static void ipath_mcast_qp_free(struct ipath_mcast_qp *mqp)
+{
+        struct ipath_qp *qp = mqp->qp;
+
+        /* Notify ipath_destroy_qp() if it is waiting. */
+        if (atomic_dec_and_test(&qp->refcount))
+                wake_up(&qp->wait);
+
+        kfree(mqp);
+}
+
+/**
+ * ipath_mcast_alloc - allocate the multicast GID structure
+ * @mgid: the multicast GID
+ *
+ * A list of QPs will be attached to this structure.
+ */
+static struct ipath_mcast *ipath_mcast_alloc(union ib_gid *mgid)
+{
+        struct ipath_mcast *mcast;
+
+        mcast = kmalloc(sizeof *mcast, GFP_KERNEL);
+        if (!mcast)
+                goto bail;
+
+        mcast->mgid = *mgid;
+        INIT_LIST_HEAD(&mcast->qp_list);
+        init_waitqueue_head(&mcast->wait);
+        atomic_set(&mcast->refcount, 0);
+
+bail:
+        return mcast;
+}
+
+static void ipath_mcast_free(struct ipath_mcast *mcast)
+{
+        struct ipath_mcast_qp *p, *tmp;
+
+        list_for_each_entry_safe(p, tmp, &mcast->qp_list, list)
+                ipath_mcast_qp_free(p);
+
+        kfree(mcast);
+}
+
+/**
+ * ipath_mcast_find - search the global table for the given multicast GID
+ * @mgid: the multicast GID to search for
+ *
+ * Returns NULL if not found.
+ *
+ * The caller is responsible for decrementing the reference count if found.
+ */
+struct ipath_mcast *ipath_mcast_find(union ib_gid *mgid)
+{
+        struct rb_node *n;
+        unsigned long flags;
+        struct ipath_mcast *mcast;
+
+        spin_lock_irqsave(&mcast_lock, flags);
+        n = mcast_tree.rb_node;
+        while (n) {
+                int ret;
+
+                mcast = rb_entry(n, struct ipath_mcast, rb_node);
+
+                ret = memcmp(mgid->raw, mcast->mgid.raw,
+                             sizeof(union ib_gid));
+                if (ret < 0)
+                        n = n->rb_left;
+                else if (ret > 0)
+                        n = n->rb_right;
+                else {
+                        atomic_inc(&mcast->refcount);
+                        spin_unlock_irqrestore(&mcast_lock, flags);
+                        goto bail;
+                }
+        }
+        spin_unlock_irqrestore(&mcast_lock, flags);
+
+        mcast = NULL;
+
+bail:
+        return mcast;
+}
+
+/**
+ * ipath_mcast_add - insert mcast GID into table and attach QP struct
+ * @mcast: the mcast GID table
+ * @mqp: the QP to attach
+ *
+ * Return zero if both were added.  Return EEXIST if the GID was already in
+ * the table but the QP was added.  Return ESRCH if the QP was already
+ * attached and neither structure was added.
+ */
+static int ipath_mcast_add(struct ipath_mcast *mcast,
+                           struct ipath_mcast_qp *mqp)
+{
+        struct rb_node **n = &mcast_tree.rb_node;
+        struct rb_node *pn = NULL;
+        unsigned long flags;
+        int ret;
+
+        spin_lock_irqsave(&mcast_lock, flags);
+
+        while (*n) {
+                struct ipath_mcast *tmcast;
+                struct ipath_mcast_qp *p;
+
+                pn = *n;
+                tmcast = rb_entry(pn, struct ipath_mcast, rb_node);
+
+                ret = memcmp(mcast->mgid.raw, tmcast->mgid.raw,
+                             sizeof(union ib_gid));
+                if (ret < 0) {
+                        n = &pn->rb_left;
+                        continue;
+                }
+                if (ret > 0) {
+                        n = &pn->rb_right;
+                        continue;
+                }
+
+                /* Search the QP list to see if this is already there. */
+                list_for_each_entry_rcu(p, &tmcast->qp_list, list) {
+                        if (p->qp == mqp->qp) {
+                                spin_unlock_irqrestore(&mcast_lock, flags);
+                                ret = ESRCH;
+                                goto bail;
+                        }
+                }
+                list_add_tail_rcu(&mqp->list, &tmcast->qp_list);
+                spin_unlock_irqrestore(&mcast_lock, flags);
+                ret = EEXIST;
+                goto bail;
+        }
+
+        list_add_tail_rcu(&mqp->list, &mcast->qp_list);
+
+        atomic_inc(&mcast->refcount);
+        rb_link_node(&mcast->rb_node, pn, n);
+        rb_insert_color(&mcast->rb_node, &mcast_tree);
+
+        spin_unlock_irqrestore(&mcast_lock, flags);
+
+        ret = 0;
+
+bail:
+        return ret;
+}
+
+int ipath_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
+{
+        struct ipath_qp *qp = to_iqp(ibqp);
+        struct ipath_mcast *mcast;
+        struct ipath_mcast_qp *mqp;
+        int ret;
+
+        /*
+         * Allocate data structures since its better to do this outside of
+         * spin locks and it will most likely be needed.
+         */
+        mcast = ipath_mcast_alloc(gid);
+        if (mcast == NULL) {
+                ret = -ENOMEM;
+                goto bail;
+        }
+        mqp = ipath_mcast_qp_alloc(qp);
+        if (mqp == NULL) {
+                ipath_mcast_free(mcast);
+                ret = -ENOMEM;
+                goto bail;
+        }
+        switch (ipath_mcast_add(mcast, mqp)) {
+        case ESRCH:
+                /* Neither was used: can't attach the same QP twice. */
+                ipath_mcast_qp_free(mqp);
+                ipath_mcast_free(mcast);
+                ret = -EINVAL;
+                goto bail;
+        case EEXIST:            /* The mcast wasn't used */
+                ipath_mcast_free(mcast);
+                break;
+        default:
+                break;
+        }
+
+        ret = 0;
+
+bail:
+        return ret;
+}
+
+int ipath_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
+{
+        struct ipath_qp *qp = to_iqp(ibqp);
+        struct ipath_mcast *mcast = NULL;
+        struct ipath_mcast_qp *p, *tmp;
+        struct rb_node *n;
+        unsigned long flags;
+        int last = 0;
+        int ret;
+
+        spin_lock_irqsave(&mcast_lock, flags);
+
+        /* Find the GID in the mcast table. */
+        n = mcast_tree.rb_node;
+        while (1) {
+                if (n == NULL) {
+                        spin_unlock_irqrestore(&mcast_lock, flags);
+                        ret = 0;
+                        goto bail;
+                }
+
+                mcast = rb_entry(n, struct ipath_mcast, rb_node);
+                ret = memcmp(gid->raw, mcast->mgid.raw,
+                             sizeof(union ib_gid));
+                if (ret < 0)
+                        n = n->rb_left;
+                else if (ret > 0)
+                        n = n->rb_right;
+                else
+                        break;
+        }
+
+        /* Search the QP list. */
+        list_for_each_entry_safe(p, tmp, &mcast->qp_list, list) {
+                if (p->qp != qp)
+                        continue;
+                /*
+                 * We found it, so remove it, but don't poison the forward
+                 * link until we are sure there are no list walkers.
+                 */
+                list_del_rcu(&p->list);
+
+                /* If this was the last attached QP, remove the GID too. */
+                if (list_empty(&mcast->qp_list)) {
+                        rb_erase(&mcast->rb_node, &mcast_tree);
+                        last = 1;
+                }
+                break;
+        }
+
+        spin_unlock_irqrestore(&mcast_lock, flags);
+
+        if (p) {
+                /*
+                 * Wait for any list walkers to finish before freeing the
+                 * list element.
+                 */
+                wait_event(mcast->wait, atomic_read(&mcast->refcount) <= 1);
+                ipath_mcast_qp_free(p);
+        }
+        if (last) {
+                atomic_dec(&mcast->refcount);
+                wait_event(mcast->wait, !atomic_read(&mcast->refcount));
+                ipath_mcast_free(mcast);
+        }
+
+        ret = 0;
+
+bail:
+        return ret;
+}
+
+int ipath_mcast_tree_empty(void)
+{
+        return mcast_tree.rb_node == NULL;
+}