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