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 - 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  * rvt_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         rvt_get_qp(qp);
  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         rvt_put_qp(qp);
  96
  97         kfree(mqp);
  98 }
  99
 100 /**
 101  * rvt_mcast_alloc - allocate the multicast GID structure
 102  * @mgid: the multicast GID
 103  * @lid: the muilticast LID (host order)
 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, u16 lid)
 108 {
 109         struct rvt_mcast *mcast;
 110
 111         mcast = kzalloc(sizeof(*mcast), GFP_KERNEL);
 112         if (!mcast)
 113                 goto bail;
 114
 115         mcast->mcast_addr.mgid = *mgid;
 116         mcast->mcast_addr.lid = lid;
 117
 118         INIT_LIST_HEAD(&mcast->qp_list);
 119         init_waitqueue_head(&mcast->wait);
 120         atomic_set(&mcast->refcount, 0);
 121
 122 bail:
 123         return mcast;
 124 }
 125
 126 static void rvt_mcast_free(struct rvt_mcast *mcast)
 127 {
 128         struct rvt_mcast_qp *p, *tmp;
 129
 130         list_for_each_entry_safe(p, tmp, &mcast->qp_list, list)
 131                 rvt_mcast_qp_free(p);
 132
 133         kfree(mcast);
 134 }
 135
 136 /**
 137  * rvt_mcast_find - search the global table for the given multicast GID/LID
 138  * NOTE: It is valid to have 1 MLID with multiple MGIDs.  It is not valid
 139  * to have 1 MGID with multiple MLIDs.
 140  * @ibp: the IB port structure
 141  * @mgid: the multicast GID to search for
 142  * @lid: the multicast LID portion of the multicast address (host order)
 143  *
 144  * The caller is responsible for decrementing the reference count if found.
 145  *
 146  * Return: NULL if not found.
 147  */
 148 struct rvt_mcast *rvt_mcast_find(struct rvt_ibport *ibp, union ib_gid *mgid,
 149                                  u16 lid)
 150 {
 151         struct rb_node *n;
 152         unsigned long flags;
 153         struct rvt_mcast *found = NULL;
 154
 155         spin_lock_irqsave(&ibp->lock, flags);
 156         n = ibp->mcast_tree.rb_node;
 157         while (n) {
 158                 int ret;
 159                 struct rvt_mcast *mcast;
 160
 161                 mcast = rb_entry(n, struct rvt_mcast, rb_node);
 162
 163                 ret = memcmp(mgid->raw, mcast->mcast_addr.mgid.raw,
 164                              sizeof(*mgid));
 165                 if (ret < 0) {
 166                         n = n->rb_left;
 167                 } else if (ret > 0) {
 168                         n = n->rb_right;
 169                 } else {
 170                         /* MGID/MLID must match */
 171                         if (mcast->mcast_addr.lid == lid) {
 172                                 atomic_inc(&mcast->refcount);
 173                                 found = mcast;
 174                         }
 175                         break;
 176                 }
 177         }
 178         spin_unlock_irqrestore(&ibp->lock, flags);
 179         return found;
 180 }
 181 EXPORT_SYMBOL(rvt_mcast_find);
 182
 183 /**
 184  * rvt_mcast_add - insert mcast GID into table and attach QP struct
 185  * @mcast: the mcast GID table
 186  * @mqp: the QP to attach
 187  *
 188  * Return: zero if both were added.  Return EEXIST if the GID was already in
 189  * the table but the QP was added.  Return ESRCH if the QP was already
 190  * attached and neither structure was added. Return EINVAL if the MGID was
 191  * found, but the MLID did NOT match.
 192  */
 193 static int rvt_mcast_add(struct rvt_dev_info *rdi, struct rvt_ibport *ibp,
 194                          struct rvt_mcast *mcast, struct rvt_mcast_qp *mqp)
 195 {
 196         struct rb_node **n = &ibp->mcast_tree.rb_node;
 197         struct rb_node *pn = NULL;
 198         int ret;
 199
 200         spin_lock_irq(&ibp->lock);
 201
 202         while (*n) {
 203                 struct rvt_mcast *tmcast;
 204                 struct rvt_mcast_qp *p;
 205
 206                 pn = *n;
 207                 tmcast = rb_entry(pn, struct rvt_mcast, rb_node);
 208
 209                 ret = memcmp(mcast->mcast_addr.mgid.raw,
 210                              tmcast->mcast_addr.mgid.raw,
 211                              sizeof(mcast->mcast_addr.mgid));
 212                 if (ret < 0) {
 213                         n = &pn->rb_left;
 214                         continue;
 215                 }
 216                 if (ret > 0) {
 217                         n = &pn->rb_right;
 218                         continue;
 219                 }
 220
 221                 if (tmcast->mcast_addr.lid != mcast->mcast_addr.lid) {
 222                         ret = EINVAL;
 223                         goto bail;
 224                 }
 225
 226                 /* Search the QP list to see if this is already there. */
 227                 list_for_each_entry_rcu(p, &tmcast->qp_list, list) {
 228                         if (p->qp == mqp->qp) {
 229                                 ret = ESRCH;
 230                                 goto bail;
 231                         }
 232                 }
 233                 if (tmcast->n_attached ==
 234                     rdi->dparms.props.max_mcast_qp_attach) {
 235                         ret = ENOMEM;
 236                         goto bail;
 237                 }
 238
 239                 tmcast->n_attached++;
 240
 241                 list_add_tail_rcu(&mqp->list, &tmcast->qp_list);
 242                 ret = EEXIST;
 243                 goto bail;
 244         }
 245
 246         spin_lock(&rdi->n_mcast_grps_lock);
 247         if (rdi->n_mcast_grps_allocated == rdi->dparms.props.max_mcast_grp) {
 248                 spin_unlock(&rdi->n_mcast_grps_lock);
 249                 ret = ENOMEM;
 250                 goto bail;
 251         }
 252
 253         rdi->n_mcast_grps_allocated++;
 254         spin_unlock(&rdi->n_mcast_grps_lock);
 255
 256         mcast->n_attached++;
 257
 258         list_add_tail_rcu(&mqp->list, &mcast->qp_list);
 259
 260         atomic_inc(&mcast->refcount);
 261         rb_link_node(&mcast->rb_node, pn, n);
 262         rb_insert_color(&mcast->rb_node, &ibp->mcast_tree);
 263
 264         ret = 0;
 265
 266 bail:
 267         spin_unlock_irq(&ibp->lock);
 268
 269         return ret;
 270 }
 271
 272 /**
 273  * rvt_attach_mcast - attach a qp to a multicast group
 274  * @ibqp: Infiniband qp
 275  * @gid: multicast guid
 276  * @lid: multicast lid
 277  *
 278  * Return: 0 on success
 279  */
 280 int rvt_attach_mcast(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 281 {
 282         struct rvt_qp *qp = ibqp_to_rvtqp(ibqp);
 283         struct rvt_dev_info *rdi = ib_to_rvt(ibqp->device);
 284         struct rvt_ibport *ibp = rdi->ports[qp->port_num - 1];
 285         struct rvt_mcast *mcast;
 286         struct rvt_mcast_qp *mqp;
 287         int ret = -ENOMEM;
 288
 289         if (ibqp->qp_num <= 1 || qp->state == IB_QPS_RESET)
 290                 return -EINVAL;
 291
 292         /*
 293          * Allocate data structures since its better to do this outside of
 294          * spin locks and it will most likely be needed.
 295          */
 296         mcast = rvt_mcast_alloc(gid, lid);
 297         if (!mcast)
 298                 return -ENOMEM;
 299
 300         mqp = rvt_mcast_qp_alloc(qp);
 301         if (!mqp)
 302                 goto bail_mcast;
 303
 304         switch (rvt_mcast_add(rdi, ibp, mcast, mqp)) {
 305         case ESRCH:
 306                 /* Neither was used: OK to attach the same QP twice. */
 307                 ret = 0;
 308                 goto bail_mqp;
 309         case EEXIST: /* The mcast wasn't used */
 310                 ret = 0;
 311                 goto bail_mcast;
 312         case ENOMEM:
 313                 /* Exceeded the maximum number of mcast groups. */
 314                 ret = -ENOMEM;
 315                 goto bail_mqp;
 316         case EINVAL:
 317                 /* Invalid MGID/MLID pair */
 318                 ret = -EINVAL;
 319                 goto bail_mqp;
 320         default:
 321                 break;
 322         }
 323
 324         return 0;
 325
 326 bail_mqp:
 327         rvt_mcast_qp_free(mqp);
 328
 329 bail_mcast:
 330         rvt_mcast_free(mcast);
 331
 332         return ret;
 333 }
 334
 335 /**
 336  * rvt_detach_mcast - remove a qp from a multicast group
 337  * @ibqp: Infiniband qp
 338  * @gid: multicast guid
 339  * @lid: multicast lid
 340  *
 341  * Return: 0 on success
 342  */
 343 int rvt_detach_mcast(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
 344 {
 345         struct rvt_qp *qp = ibqp_to_rvtqp(ibqp);
 346         struct rvt_dev_info *rdi = ib_to_rvt(ibqp->device);
 347         struct rvt_ibport *ibp = rdi->ports[qp->port_num - 1];
 348         struct rvt_mcast *mcast = NULL;
 349         struct rvt_mcast_qp *p, *tmp, *delp = NULL;
 350         struct rb_node *n;
 351         int last = 0;
 352         int ret = 0;
 353
 354         if (ibqp->qp_num <= 1)
 355                 return -EINVAL;
 356
 357         spin_lock_irq(&ibp->lock);
 358
 359         /* Find the GID in the mcast table. */
 360         n = ibp->mcast_tree.rb_node;
 361         while (1) {
 362                 if (!n) {
 363                         spin_unlock_irq(&ibp->lock);
 364                         return -EINVAL;
 365                 }
 366
 367                 mcast = rb_entry(n, struct rvt_mcast, rb_node);
 368                 ret = memcmp(gid->raw, mcast->mcast_addr.mgid.raw,
 369                              sizeof(*gid));
 370                 if (ret < 0) {
 371                         n = n->rb_left;
 372                 } else if (ret > 0) {
 373                         n = n->rb_right;
 374                 } else {
 375                         /* MGID/MLID must match */
 376                         if (mcast->mcast_addr.lid != lid) {
 377                                 spin_unlock_irq(&ibp->lock);
 378                                 return -EINVAL;
 379                         }
 380                         break;
 381                 }
 382         }
 383
 384         /* Search the QP list. */
 385         list_for_each_entry_safe(p, tmp, &mcast->qp_list, list) {
 386                 if (p->qp != qp)
 387                         continue;
 388                 /*
 389                  * We found it, so remove it, but don't poison the forward
 390                  * link until we are sure there are no list walkers.
 391                  */
 392                 list_del_rcu(&p->list);
 393                 mcast->n_attached--;
 394                 delp = p;
 395
 396                 /* If this was the last attached QP, remove the GID too. */
 397                 if (list_empty(&mcast->qp_list)) {
 398                         rb_erase(&mcast->rb_node, &ibp->mcast_tree);
 399                         last = 1;
 400                 }
 401                 break;
 402         }
 403
 404         spin_unlock_irq(&ibp->lock);
 405         /* QP not attached */
 406         if (!delp)
 407                 return -EINVAL;
 408
 409         /*
 410          * Wait for any list walkers to finish before freeing the
 411          * list element.
 412          */
 413         wait_event(mcast->wait, atomic_read(&mcast->refcount) <= 1);
 414         rvt_mcast_qp_free(delp);
 415
 416         if (last) {
 417                 atomic_dec(&mcast->refcount);
 418                 wait_event(mcast->wait, !atomic_read(&mcast->refcount));
 419                 rvt_mcast_free(mcast);
 420                 spin_lock_irq(&rdi->n_mcast_grps_lock);
 421                 rdi->n_mcast_grps_allocated--;
 422                 spin_unlock_irq(&rdi->n_mcast_grps_lock);
 423         }
 424
 425         return 0;
 426 }
 427
 428 /**
 429  * rvt_mcast_tree_empty - determine if any qps are attached to any mcast group
 430  * @rdi: rvt dev struct
 431  *
 432  * Return: in use count
 433  */
 434 int rvt_mcast_tree_empty(struct rvt_dev_info *rdi)
 435 {
 436         int i;
 437         int in_use = 0;
 438
 439         for (i = 0; i < rdi->dparms.nports; i++)
 440                 if (rdi->ports[i]->mcast_tree.rb_node)
 441                         in_use++;
 442         return in_use;
 443 }