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 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 * 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 * 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_mast_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 }