drivers/infiniband/hw/ipath/ipath_verbs_mcast.c

   1 /*
   2  * Copyright (c) 2006, 2007 QLogic Corporation. All rights reserved.
   3  * Copyright (c) 2005, 2006 PathScale, Inc. All rights reserved.
   4  *
   5  * This software is available to you under a choice of one of two
   6  * licenses.  You may choose to be licensed under the terms of the GNU
   7  * General Public License (GPL) Version 2, available from the file
   8  * COPYING in the main directory of this source tree, or the
   9  * OpenIB.org BSD license below:
  10  *
  11  *     Redistribution and use in source and binary forms, with or
  12  *     without modification, are permitted provided that the following
  13  *     conditions are met:
  14  *
  15  *      - Redistributions of source code must retain the above
  16  *        copyright notice, this list of conditions and the following
  17  *        disclaimer.
  18  *
  19  *      - Redistributions in binary form must reproduce the above
  20  *        copyright notice, this list of conditions and the following
  21  *        disclaimer in the documentation and/or other materials
  22  *        provided with the distribution.
  23  *
  24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  31  * SOFTWARE.
  32  */
  33
  34 #include <linux/rculist.h>
  35
  36 #include "ipath_verbs.h"
  37
  38 /*
  39  * Global table of GID to attached QPs.
  40  * The table is global to all ipath devices since a send from one QP/device
  41  * needs to be locally routed to any locally attached QPs on the same
  42  * or different device.
  43  */
  44 static struct rb_root mcast_tree;
  45 static DEFINE_SPINLOCK(mcast_lock);
  46
  47 /**
  48  * ipath_mcast_qp_alloc - alloc a struct to link a QP to mcast GID struct
  49  * @qp: the QP to link
  50  */
  51 static struct ipath_mcast_qp *ipath_mcast_qp_alloc(struct ipath_qp *qp)
  52 {
  53         struct ipath_mcast_qp *mqp;
  54
  55         mqp = kmalloc(sizeof *mqp, GFP_KERNEL);
  56         if (!mqp)
  57                 goto bail;
  58
  59         mqp->qp = qp;
  60         atomic_inc(&qp->refcount);
  61
  62 bail:
  63         return mqp;
  64 }
  65
  66 static void ipath_mcast_qp_free(struct ipath_mcast_qp *mqp)
  67 {
  68         struct ipath_qp *qp = mqp->qp;
  69
  70         /* Notify ipath_destroy_qp() if it is waiting. */
  71         if (atomic_dec_and_test(&qp->refcount))
  72                 wake_up(&qp->wait);
  73
  74         kfree(mqp);
  75 }
  76
  77 /**
  78  * ipath_mcast_alloc - allocate the multicast GID structure
  79  * @mgid: the multicast GID
  80  *
  81  * A list of QPs will be attached to this structure.
  82  */
  83 static struct ipath_mcast *ipath_mcast_alloc(union ib_gid *mgid)
  84 {
  85         struct ipath_mcast *mcast;
  86
  87         mcast = kmalloc(sizeof *mcast, GFP_KERNEL);
  88         if (!mcast)
  89                 goto bail;
  90
  91         mcast->mgid = *mgid;
  92         INIT_LIST_HEAD(&mcast->qp_list);
  93         init_waitqueue_head(&mcast->wait);
  94         atomic_set(&mcast->refcount, 0);
  95         mcast->n_attached = 0;
  96
  97 bail:
  98         return mcast;
  99 }
 100
 101 static void ipath_mcast_free(struct ipath_mcast *mcast)
 102 {
 103         struct ipath_mcast_qp *p, *tmp;
 104
 105         list_for_each_entry_safe(p, tmp, &mcast->qp_list, list)
 106                 ipath_mcast_qp_free(p);
 107
 108         kfree(mcast);
 109 }
 110
 111 /**
 112  * ipath_mcast_find - search the global table for the given multicast GID
 113  * @mgid: the multicast GID to search for
 114  *
 115  * Returns NULL if not found.
 116  *
 117  * The caller is responsible for decrementing the reference count if found.
 118  */
 119 struct ipath_mcast *ipath_mcast_find(union ib_gid *mgid)
 120 {
 121         struct rb_node *n;
 122         unsigned long flags;
 123         struct ipath_mcast *mcast;
 124
 125         spin_lock_irqsave(&mcast_lock, flags);
 126         n = mcast_tree.rb_node;
 127         while (n) {
 128                 int ret;
 129
 130                 mcast = rb_entry(n, struct ipath_mcast, rb_node);
 131
 132                 ret = memcmp(mgid->raw, mcast->mgid.raw,
 133                              sizeof(union ib_gid));
 134                 if (ret < 0)
 135                         n = n->rb_left;
 136                 else if (ret > 0)
 137                         n = n->rb_right;
 138                 else {
 139                         atomic_inc(&mcast->refcount);
 140                         spin_unlock_irqrestore(&mcast_lock, flags);
 141                         goto bail;
 142                 }
 143         }
 144         spin_unlock_irqrestore(&mcast_lock, flags);
 145
 146         mcast = NULL;
 147
 148 bail:
 149         return mcast;
 150 }
 151
 152 /**
 153  * ipath_mcast_add - insert mcast GID into table and attach QP struct
 154  * @mcast: the mcast GID table
 155  * @mqp: the QP to attach
 156  *
 157  * Return zero if both were added.  Return EEXIST if the GID was already in
 158  * the table but the QP was added.  Return ESRCH if the QP was already
 159  * attached and neither structure was added.
 160  */
 161 static int ipath_mcast_add(struct ipath_ibdev *dev,
 162                            struct ipath_mcast *mcast,
 163                            struct ipath_mcast_qp *mqp)
 164 {
 165         struct rb_node **n = &mcast_tree.rb_node;
 166         struct rb_node *pn = NULL;
 167         int ret;
 168
 169         spin_lock_irq(&mcast_lock);
 170
 171         while (*n) {
 172                 struct ipath_mcast *tmcast;
 173                 struct ipath_mcast_qp *p;
 174
 175                 pn = *n;
 176                 tmcast = rb_entry(pn, struct ipath_mcast, rb_node);
 177
 178                 ret = memcmp(mcast->mgid.raw, tmcast->mgid.raw,
 179                              sizeof(union ib_gid));
 180                 if (ret < 0) {
 181                         n = &pn->rb_left;
 182                         continue;
 183                 }
 184                 if (ret > 0) {
 185                         n = &pn->rb_right;
 186                         continue;
 187                 }
 188
 189                 /* Search the QP list to see if this is already there. */
 190                 list_for_each_entry_rcu(p, &tmcast->qp_list, list) {
 191                         if (p->qp == mqp->qp) {
 192                                 ret = ESRCH;
 193                                 goto bail;
 194                         }
 195                 }
 196                 if (tmcast->n_attached == ib_ipath_max_mcast_qp_attached) {
 197                         ret = ENOMEM;
 198                         goto bail;
 199                 }
 200
 201                 tmcast->n_attached++;
 202
 203                 list_add_tail_rcu(&mqp->list, &tmcast->qp_list);
 204                 ret = EEXIST;
 205                 goto bail;
 206         }
 207
 208         spin_lock(&dev->n_mcast_grps_lock);
 209         if (dev->n_mcast_grps_allocated == ib_ipath_max_mcast_grps) {
 210                 spin_unlock(&dev->n_mcast_grps_lock);
 211                 ret = ENOMEM;
 212                 goto bail;
 213         }
 214
 215         dev->n_mcast_grps_allocated++;
 216         spin_unlock(&dev->n_mcast_grps_lock);
 217
 218         mcast->n_attached++;
 219
 220         list_add_tail_rcu(&mqp->list, &mcast->qp_list);
 221
 222         atomic_inc(&mcast->refcount);
 223         rb_link_node(&mcast->rb_node, pn, n);
 224         rb_insert_color(&mcast->rb_node, &mcast_tree);
 225
 226         ret = 0;
 227
 228 bail:
 229         spin_unlock_irq(&mcast_lock);
 230
 231         return ret;
 232 }
 233
 234 int ipath_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 235 {
 236         struct ipath_qp *qp = to_iqp(ibqp);
 237         struct ipath_ibdev *dev = to_idev(ibqp->device);
 238         struct ipath_mcast *mcast;
 239         struct ipath_mcast_qp *mqp;
 240         int ret;
 241
 242         /*
 243          * Allocate data structures since its better to do this outside of
 244          * spin locks and it will most likely be needed.
 245          */
 246         mcast = ipath_mcast_alloc(gid);
 247         if (mcast == NULL) {
 248                 ret = -ENOMEM;
 249                 goto bail;
 250         }
 251         mqp = ipath_mcast_qp_alloc(qp);
 252         if (mqp == NULL) {
 253                 ipath_mcast_free(mcast);
 254                 ret = -ENOMEM;
 255                 goto bail;
 256         }
 257         switch (ipath_mcast_add(dev, mcast, mqp)) {
 258         case ESRCH:
 259                 /* Neither was used: can't attach the same QP twice. */
 260                 ipath_mcast_qp_free(mqp);
 261                 ipath_mcast_free(mcast);
 262                 ret = -EINVAL;
 263                 goto bail;
 264         case EEXIST:            /* The mcast wasn't used */
 265                 ipath_mcast_free(mcast);
 266                 break;
 267         case ENOMEM:
 268                 /* Exceeded the maximum number of mcast groups. */
 269                 ipath_mcast_qp_free(mqp);
 270                 ipath_mcast_free(mcast);
 271                 ret = -ENOMEM;
 272                 goto bail;
 273         default:
 274                 break;
 275         }
 276
 277         ret = 0;
 278
 279 bail:
 280         return ret;
 281 }
 282
 283 int ipath_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 284 {
 285         struct ipath_qp *qp = to_iqp(ibqp);
 286         struct ipath_ibdev *dev = to_idev(ibqp->device);
 287         struct ipath_mcast *mcast = NULL;
 288         struct ipath_mcast_qp *p, *tmp;
 289         struct rb_node *n;
 290         int last = 0;
 291         int ret;
 292
 293         spin_lock_irq(&mcast_lock);
 294
 295         /* Find the GID in the mcast table. */
 296         n = mcast_tree.rb_node;
 297         while (1) {
 298                 if (n == NULL) {
 299                         spin_unlock_irq(&mcast_lock);
 300                         ret = -EINVAL;
 301                         goto bail;
 302                 }
 303
 304                 mcast = rb_entry(n, struct ipath_mcast, rb_node);
 305                 ret = memcmp(gid->raw, mcast->mgid.raw,
 306                              sizeof(union ib_gid));
 307                 if (ret < 0)
 308                         n = n->rb_left;
 309                 else if (ret > 0)
 310                         n = n->rb_right;
 311                 else
 312                         break;
 313         }
 314
 315         /* Search the QP list. */
 316         list_for_each_entry_safe(p, tmp, &mcast->qp_list, list) {
 317                 if (p->qp != qp)
 318                         continue;
 319                 /*
 320                  * We found it, so remove it, but don't poison the forward
 321                  * link until we are sure there are no list walkers.
 322                  */
 323                 list_del_rcu(&p->list);
 324                 mcast->n_attached--;
 325
 326                 /* If this was the last attached QP, remove the GID too. */
 327                 if (list_empty(&mcast->qp_list)) {
 328                         rb_erase(&mcast->rb_node, &mcast_tree);
 329                         last = 1;
 330                 }
 331                 break;
 332         }
 333
 334         spin_unlock_irq(&mcast_lock);
 335
 336         if (p) {
 337                 /*
 338                  * Wait for any list walkers to finish before freeing the
 339                  * list element.
 340                  */
 341                 wait_event(mcast->wait, atomic_read(&mcast->refcount) <= 1);
 342                 ipath_mcast_qp_free(p);
 343         }
 344         if (last) {
 345                 atomic_dec(&mcast->refcount);
 346                 wait_event(mcast->wait, !atomic_read(&mcast->refcount));
 347                 ipath_mcast_free(mcast);
 348                 spin_lock_irq(&dev->n_mcast_grps_lock);
 349                 dev->n_mcast_grps_allocated--;
 350                 spin_unlock_irq(&dev->n_mcast_grps_lock);
 351         }
 352
 353         ret = 0;
 354
 355 bail:
 356         return ret;
 357 }
 358
 359 int ipath_mcast_tree_empty(void)
 360 {
 361         return mcast_tree.rb_node == NULL;
 362 }