drivers/infiniband/sw/rdmavt/mcast.c

   1 /*
   2  * Copyright(c) 2016 Intel Corporation.
   3  *
   4  * This file is provided under a dual BSD/GPLv2 license.  When using or
   5  * redistributing this file, you may do so under either license.
   6  *
   7  * GPL LICENSE SUMMARY
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of version 2 of the GNU General Public License as
  11  * published by the Free Software Foundation.
  12  *
  13  * This program is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * General Public License for more details.
  17  *
  18  * BSD LICENSE
  19  *
  20  * Redistribution and use in source and binary forms, with or without
  21  * modification, are permitted provided that the following conditions
  22  * are met:
  23  *
  24  *  - Redistributions of source code must retain the above copyright
  25  *    notice, this list of conditions and the following disclaimer.
  26  *  - Redistributions in binary form must reproduce the above copyright
  27  *    notice, this list of conditions and the following disclaimer in
  28  *    the documentation and/or other materials provided with the
  29  *    distribution.
  30  *  - Neither the name of Intel Corporation nor the names of its
  31  *    contributors may be used to endorse or promote products derived
  32  *    from this software without specific prior written permission.
  33  *
  34  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  35  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  36  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  37  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  38  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  39  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  40  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  41  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  42  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  43  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  44  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  45  *
  46  */
  47
  48 #include <linux/slab.h>
  49 #include <linux/sched.h>
  50 #include <linux/rculist.h>
  51 #include <rdma/rdma_vt.h>
  52 #include <rdma/rdmavt_qp.h>
  53
  54 #include "mcast.h"
  55
  56 /**
  57  * rvt_driver_mcast - init resources for multicast
  58  * @rdi: rvt dev struct
  59  *
  60  * This is per device that registers with rdmavt
  61  */
  62 void rvt_driver_mcast_init(struct rvt_dev_info *rdi)
  63 {
  64         /*
  65          * Anything that needs setup for multicast on a per driver or per rdi
  66          * basis should be done in here.
  67          */
  68         spin_lock_init(&rdi->n_mcast_grps_lock);
  69 }
  70
  71 /**
  72  * mcast_qp_alloc - alloc a struct to link a QP to mcast GID struct
  73  * @qp: the QP to link
  74  */
  75 static struct rvt_mcast_qp *rvt_mcast_qp_alloc(struct rvt_qp *qp)
  76 {
  77         struct rvt_mcast_qp *mqp;
  78
  79         mqp = kmalloc(sizeof(*mqp), GFP_KERNEL);
  80         if (!mqp)
  81                 goto bail;
  82
  83         mqp->qp = qp;
  84         atomic_inc(&qp->refcount);
  85
  86 bail:
  87         return mqp;
  88 }
  89
  90 static void rvt_mcast_qp_free(struct rvt_mcast_qp *mqp)
  91 {
  92         struct rvt_qp *qp = mqp->qp;
  93
  94         /* Notify hfi1_destroy_qp() if it is waiting. */
  95         if (atomic_dec_and_test(&qp->refcount))
  96                 wake_up(&qp->wait);
  97
  98         kfree(mqp);
  99 }
 100
 101 /**
 102  * mcast_alloc - allocate the multicast GID structure
 103  * @mgid: the multicast GID
 104  *
 105  * A list of QPs will be attached to this structure.
 106  */
 107 static struct rvt_mcast *rvt_mcast_alloc(union ib_gid *mgid)
 108 {
 109         struct rvt_mcast *mcast;
 110
 111         mcast = kzalloc(sizeof(*mcast), GFP_KERNEL);
 112         if (!mcast)
 113                 goto bail;
 114
 115         mcast->mgid = *mgid;
 116         INIT_LIST_HEAD(&mcast->qp_list);
 117         init_waitqueue_head(&mcast->wait);
 118         atomic_set(&mcast->refcount, 0);
 119
 120 bail:
 121         return mcast;
 122 }
 123
 124 static void rvt_mcast_free(struct rvt_mcast *mcast)
 125 {
 126         struct rvt_mcast_qp *p, *tmp;
 127
 128         list_for_each_entry_safe(p, tmp, &mcast->qp_list, list)
 129                 rvt_mcast_qp_free(p);
 130
 131         kfree(mcast);
 132 }
 133
 134 /**
 135  * rvt_mcast_find - search the global table for the given multicast GID
 136  * @ibp: the IB port structure
 137  * @mgid: the multicast GID to search for
 138  *
 139  * The caller is responsible for decrementing the reference count if found.
 140  *
 141  * Return: NULL if not found.
 142  */
 143 struct rvt_mcast *rvt_mcast_find(struct rvt_ibport *ibp, union ib_gid *mgid)
 144 {
 145         struct rb_node *n;
 146         unsigned long flags;
 147         struct rvt_mcast *found = NULL;
 148
 149         spin_lock_irqsave(&ibp->lock, flags);
 150         n = ibp->mcast_tree.rb_node;
 151         while (n) {
 152                 int ret;
 153                 struct rvt_mcast *mcast;
 154
 155                 mcast = rb_entry(n, struct rvt_mcast, rb_node);
 156
 157                 ret = memcmp(mgid->raw, mcast->mgid.raw,
 158                              sizeof(union ib_gid));
 159                 if (ret < 0) {
 160                         n = n->rb_left;
 161                 } else if (ret > 0) {
 162                         n = n->rb_right;
 163                 } else {
 164                         atomic_inc(&mcast->refcount);
 165                         found = mcast;
 166                         break;
 167                 }
 168         }
 169         spin_unlock_irqrestore(&ibp->lock, flags);
 170         return found;
 171 }
 172 EXPORT_SYMBOL(rvt_mcast_find);
 173
 174 /**
 175  * mcast_add - insert mcast GID into table and attach QP struct
 176  * @mcast: the mcast GID table
 177  * @mqp: the QP to attach
 178  *
 179  * Return: zero if both were added.  Return EEXIST if the GID was already in
 180  * the table but the QP was added.  Return ESRCH if the QP was already
 181  * attached and neither structure was added.
 182  */
 183 static int rvt_mcast_add(struct rvt_dev_info *rdi, struct rvt_ibport *ibp,
 184                          struct rvt_mcast *mcast, struct rvt_mcast_qp *mqp)
 185 {
 186         struct rb_node **n = &ibp->mcast_tree.rb_node;
 187         struct rb_node *pn = NULL;
 188         int ret;
 189
 190         spin_lock_irq(&ibp->lock);
 191
 192         while (*n) {
 193                 struct rvt_mcast *tmcast;
 194                 struct rvt_mcast_qp *p;
 195
 196                 pn = *n;
 197                 tmcast = rb_entry(pn, struct rvt_mcast, rb_node);
 198
 199                 ret = memcmp(mcast->mgid.raw, tmcast->mgid.raw,
 200                              sizeof(union ib_gid));
 201                 if (ret < 0) {
 202                         n = &pn->rb_left;
 203                         continue;
 204                 }
 205                 if (ret > 0) {
 206                         n = &pn->rb_right;
 207                         continue;
 208                 }
 209
 210                 /* Search the QP list to see if this is already there. */
 211                 list_for_each_entry_rcu(p, &tmcast->qp_list, list) {
 212                         if (p->qp == mqp->qp) {
 213                                 ret = ESRCH;
 214                                 goto bail;
 215                         }
 216                 }
 217                 if (tmcast->n_attached ==
 218                     rdi->dparms.props.max_mcast_qp_attach) {
 219                         ret = ENOMEM;
 220                         goto bail;
 221                 }
 222
 223                 tmcast->n_attached++;
 224
 225                 list_add_tail_rcu(&mqp->list, &tmcast->qp_list);
 226                 ret = EEXIST;
 227                 goto bail;
 228         }
 229
 230         spin_lock(&rdi->n_mcast_grps_lock);
 231         if (rdi->n_mcast_grps_allocated == rdi->dparms.props.max_mcast_grp) {
 232                 spin_unlock(&rdi->n_mcast_grps_lock);
 233                 ret = ENOMEM;
 234                 goto bail;
 235         }
 236
 237         rdi->n_mcast_grps_allocated++;
 238         spin_unlock(&rdi->n_mcast_grps_lock);
 239
 240         mcast->n_attached++;
 241
 242         list_add_tail_rcu(&mqp->list, &mcast->qp_list);
 243
 244         atomic_inc(&mcast->refcount);
 245         rb_link_node(&mcast->rb_node, pn, n);
 246         rb_insert_color(&mcast->rb_node, &ibp->mcast_tree);
 247
 248         ret = 0;
 249
 250 bail:
 251         spin_unlock_irq(&ibp->lock);
 252
 253         return ret;
 254 }
 255
 256 /**
 257  * rvt_attach_mcast - attach a qp to a multicast group
 258  * @ibqp: Infiniband qp
 259  * @igd: multicast guid
 260  * @lid: multicast lid
 261  *
 262  * Return: 0 on success
 263  */
 264 int rvt_attach_mcast(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 265 {
 266         struct rvt_qp *qp = ibqp_to_rvtqp(ibqp);
 267         struct rvt_dev_info *rdi = ib_to_rvt(ibqp->device);
 268         struct rvt_ibport *ibp = rdi->ports[qp->port_num - 1];
 269         struct rvt_mcast *mcast;
 270         struct rvt_mcast_qp *mqp;
 271         int ret = -ENOMEM;
 272
 273         if (ibqp->qp_num <= 1 || qp->state == IB_QPS_RESET)
 274                 return -EINVAL;
 275
 276         /*
 277          * Allocate data structures since its better to do this outside of
 278          * spin locks and it will most likely be needed.
 279          */
 280         mcast = rvt_mcast_alloc(gid);
 281         if (!mcast)
 282                 return -ENOMEM;
 283
 284         mqp = rvt_mcast_qp_alloc(qp);
 285         if (!mqp)
 286                 goto bail_mcast;
 287
 288         switch (rvt_mcast_add(rdi, ibp, mcast, mqp)) {
 289         case ESRCH:
 290                 /* Neither was used: OK to attach the same QP twice. */
 291                 ret = 0;
 292                 goto bail_mqp;
 293         case EEXIST: /* The mcast wasn't used */
 294                 ret = 0;
 295                 goto bail_mcast;
 296         case ENOMEM:
 297                 /* Exceeded the maximum number of mcast groups. */
 298                 ret = -ENOMEM;
 299                 goto bail_mqp;
 300         default:
 301                 break;
 302         }
 303
 304         return 0;
 305
 306 bail_mqp:
 307         rvt_mcast_qp_free(mqp);
 308
 309 bail_mcast:
 310         rvt_mcast_free(mcast);
 311
 312         return ret;
 313 }
 314
 315 /**
 316  * rvt_detach_mcast - remove a qp from a multicast group
 317  * @ibqp: Infiniband qp
 318  * @igd: multicast guid
 319  * @lid: multicast lid
 320  *
 321  * Return: 0 on success
 322  */
 323 int rvt_detach_mcast(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 324 {
 325         struct rvt_qp *qp = ibqp_to_rvtqp(ibqp);
 326         struct rvt_dev_info *rdi = ib_to_rvt(ibqp->device);
 327         struct rvt_ibport *ibp = rdi->ports[qp->port_num - 1];
 328         struct rvt_mcast *mcast = NULL;
 329         struct rvt_mcast_qp *p, *tmp, *delp = NULL;
 330         struct rb_node *n;
 331         int last = 0;
 332         int ret = 0;
 333
 334         if (ibqp->qp_num <= 1 || qp->state == IB_QPS_RESET)
 335                 return -EINVAL;
 336
 337         spin_lock_irq(&ibp->lock);
 338
 339         /* Find the GID in the mcast table. */
 340         n = ibp->mcast_tree.rb_node;
 341         while (1) {
 342                 if (!n) {
 343                         spin_unlock_irq(&ibp->lock);
 344                         return -EINVAL;
 345                 }
 346
 347                 mcast = rb_entry(n, struct rvt_mcast, rb_node);
 348                 ret = memcmp(gid->raw, mcast->mgid.raw,
 349                              sizeof(union ib_gid));
 350                 if (ret < 0)
 351                         n = n->rb_left;
 352                 else if (ret > 0)
 353                         n = n->rb_right;
 354                 else
 355                         break;
 356         }
 357
 358         /* Search the QP list. */
 359         list_for_each_entry_safe(p, tmp, &mcast->qp_list, list) {
 360                 if (p->qp != qp)
 361                         continue;
 362                 /*
 363                  * We found it, so remove it, but don't poison the forward
 364                  * link until we are sure there are no list walkers.
 365                  */
 366                 list_del_rcu(&p->list);
 367                 mcast->n_attached--;
 368                 delp = p;
 369
 370                 /* If this was the last attached QP, remove the GID too. */
 371                 if (list_empty(&mcast->qp_list)) {
 372                         rb_erase(&mcast->rb_node, &ibp->mcast_tree);
 373                         last = 1;
 374                 }
 375                 break;
 376         }
 377
 378         spin_unlock_irq(&ibp->lock);
 379         /* QP not attached */
 380         if (!delp)
 381                 return -EINVAL;
 382
 383         /*
 384          * Wait for any list walkers to finish before freeing the
 385          * list element.
 386          */
 387         wait_event(mcast->wait, atomic_read(&mcast->refcount) <= 1);
 388         rvt_mcast_qp_free(delp);
 389
 390         if (last) {
 391                 atomic_dec(&mcast->refcount);
 392                 wait_event(mcast->wait, !atomic_read(&mcast->refcount));
 393                 rvt_mcast_free(mcast);
 394                 spin_lock_irq(&rdi->n_mcast_grps_lock);
 395                 rdi->n_mcast_grps_allocated--;
 396                 spin_unlock_irq(&rdi->n_mcast_grps_lock);
 397         }
 398
 399         return 0;
 400 }
 401
 402 /**
 403  *rvt_mast_tree_empty - determine if any qps are attached to any mcast group
 404  *@rdi: rvt dev struct
 405  *
 406  * Return: in use count
 407  */
 408 int rvt_mcast_tree_empty(struct rvt_dev_info *rdi)
 409 {
 410         int i;
 411         int in_use = 0;
 412
 413         for (i = 0; i < rdi->dparms.nports; i++)
 414                 if (rdi->ports[i]->mcast_tree.rb_node)
 415                         in_use++;
 416         return in_use;
 417 }