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 } 444