1 // SPDX-License-Identifier: GPL-2.0 or BSD-3-Clause
2 /*
3  * Copyright(c) 2016 Intel Corporation.
4  */
5 
6 #include <linux/slab.h>
7 #include <linux/sched.h>
8 #include <linux/rculist.h>
9 #include <rdma/rdma_vt.h>
10 #include <rdma/rdmavt_qp.h>
11 
12 #include "mcast.h"
13 
14 /**
15  * rvt_driver_mcast_init - init resources for multicast
16  * @rdi: rvt dev struct
17  *
18  * This is per device that registers with rdmavt
19  */
20 void rvt_driver_mcast_init(struct rvt_dev_info *rdi)
21 {
22 	/*
23 	 * Anything that needs setup for multicast on a per driver or per rdi
24 	 * basis should be done in here.
25 	 */
26 	spin_lock_init(&rdi->n_mcast_grps_lock);
27 }
28 
29 /**
30  * rvt_mcast_qp_alloc - alloc a struct to link a QP to mcast GID struct
31  * @qp: the QP to link
32  */
33 static struct rvt_mcast_qp *rvt_mcast_qp_alloc(struct rvt_qp *qp)
34 {
35 	struct rvt_mcast_qp *mqp;
36 
37 	mqp = kmalloc(sizeof(*mqp), GFP_KERNEL);
38 	if (!mqp)
39 		goto bail;
40 
41 	mqp->qp = qp;
42 	rvt_get_qp(qp);
43 
44 bail:
45 	return mqp;
46 }
47 
48 static void rvt_mcast_qp_free(struct rvt_mcast_qp *mqp)
49 {
50 	struct rvt_qp *qp = mqp->qp;
51 
52 	/* Notify hfi1_destroy_qp() if it is waiting. */
53 	rvt_put_qp(qp);
54 
55 	kfree(mqp);
56 }
57 
58 /**
59  * rvt_mcast_alloc - allocate the multicast GID structure
60  * @mgid: the multicast GID
61  * @lid: the muilticast LID (host order)
62  *
63  * A list of QPs will be attached to this structure.
64  */
65 static struct rvt_mcast *rvt_mcast_alloc(union ib_gid *mgid, u16 lid)
66 {
67 	struct rvt_mcast *mcast;
68 
69 	mcast = kzalloc(sizeof(*mcast), GFP_KERNEL);
70 	if (!mcast)
71 		goto bail;
72 
73 	mcast->mcast_addr.mgid = *mgid;
74 	mcast->mcast_addr.lid = lid;
75 
76 	INIT_LIST_HEAD(&mcast->qp_list);
77 	init_waitqueue_head(&mcast->wait);
78 	atomic_set(&mcast->refcount, 0);
79 
80 bail:
81 	return mcast;
82 }
83 
84 static void rvt_mcast_free(struct rvt_mcast *mcast)
85 {
86 	struct rvt_mcast_qp *p, *tmp;
87 
88 	list_for_each_entry_safe(p, tmp, &mcast->qp_list, list)
89 		rvt_mcast_qp_free(p);
90 
91 	kfree(mcast);
92 }
93 
94 /**
95  * rvt_mcast_find - search the global table for the given multicast GID/LID
96  * NOTE: It is valid to have 1 MLID with multiple MGIDs.  It is not valid
97  * to have 1 MGID with multiple MLIDs.
98  * @ibp: the IB port structure
99  * @mgid: the multicast GID to search for
100  * @lid: the multicast LID portion of the multicast address (host order)
101  *
102  * The caller is responsible for decrementing the reference count if found.
103  *
104  * Return: NULL if not found.
105  */
106 struct rvt_mcast *rvt_mcast_find(struct rvt_ibport *ibp, union ib_gid *mgid,
107 				 u16 lid)
108 {
109 	struct rb_node *n;
110 	unsigned long flags;
111 	struct rvt_mcast *found = NULL;
112 
113 	spin_lock_irqsave(&ibp->lock, flags);
114 	n = ibp->mcast_tree.rb_node;
115 	while (n) {
116 		int ret;
117 		struct rvt_mcast *mcast;
118 
119 		mcast = rb_entry(n, struct rvt_mcast, rb_node);
120 
121 		ret = memcmp(mgid->raw, mcast->mcast_addr.mgid.raw,
122 			     sizeof(*mgid));
123 		if (ret < 0) {
124 			n = n->rb_left;
125 		} else if (ret > 0) {
126 			n = n->rb_right;
127 		} else {
128 			/* MGID/MLID must match */
129 			if (mcast->mcast_addr.lid == lid) {
130 				atomic_inc(&mcast->refcount);
131 				found = mcast;
132 			}
133 			break;
134 		}
135 	}
136 	spin_unlock_irqrestore(&ibp->lock, flags);
137 	return found;
138 }
139 EXPORT_SYMBOL(rvt_mcast_find);
140 
141 /*
142  * rvt_mcast_add - insert mcast GID into table and attach QP struct
143  * @mcast: the mcast GID table
144  * @mqp: the QP to attach
145  *
146  * Return: zero if both were added.  Return EEXIST if the GID was already in
147  * the table but the QP was added.  Return ESRCH if the QP was already
148  * attached and neither structure was added. Return EINVAL if the MGID was
149  * found, but the MLID did NOT match.
150  */
151 static int rvt_mcast_add(struct rvt_dev_info *rdi, struct rvt_ibport *ibp,
152 			 struct rvt_mcast *mcast, struct rvt_mcast_qp *mqp)
153 {
154 	struct rb_node **n = &ibp->mcast_tree.rb_node;
155 	struct rb_node *pn = NULL;
156 	int ret;
157 
158 	spin_lock_irq(&ibp->lock);
159 
160 	while (*n) {
161 		struct rvt_mcast *tmcast;
162 		struct rvt_mcast_qp *p;
163 
164 		pn = *n;
165 		tmcast = rb_entry(pn, struct rvt_mcast, rb_node);
166 
167 		ret = memcmp(mcast->mcast_addr.mgid.raw,
168 			     tmcast->mcast_addr.mgid.raw,
169 			     sizeof(mcast->mcast_addr.mgid));
170 		if (ret < 0) {
171 			n = &pn->rb_left;
172 			continue;
173 		}
174 		if (ret > 0) {
175 			n = &pn->rb_right;
176 			continue;
177 		}
178 
179 		if (tmcast->mcast_addr.lid != mcast->mcast_addr.lid) {
180 			ret = EINVAL;
181 			goto bail;
182 		}
183 
184 		/* Search the QP list to see if this is already there. */
185 		list_for_each_entry_rcu(p, &tmcast->qp_list, list) {
186 			if (p->qp == mqp->qp) {
187 				ret = ESRCH;
188 				goto bail;
189 			}
190 		}
191 		if (tmcast->n_attached ==
192 		    rdi->dparms.props.max_mcast_qp_attach) {
193 			ret = ENOMEM;
194 			goto bail;
195 		}
196 
197 		tmcast->n_attached++;
198 
199 		list_add_tail_rcu(&mqp->list, &tmcast->qp_list);
200 		ret = EEXIST;
201 		goto bail;
202 	}
203 
204 	spin_lock(&rdi->n_mcast_grps_lock);
205 	if (rdi->n_mcast_grps_allocated == rdi->dparms.props.max_mcast_grp) {
206 		spin_unlock(&rdi->n_mcast_grps_lock);
207 		ret = ENOMEM;
208 		goto bail;
209 	}
210 
211 	rdi->n_mcast_grps_allocated++;
212 	spin_unlock(&rdi->n_mcast_grps_lock);
213 
214 	mcast->n_attached++;
215 
216 	list_add_tail_rcu(&mqp->list, &mcast->qp_list);
217 
218 	atomic_inc(&mcast->refcount);
219 	rb_link_node(&mcast->rb_node, pn, n);
220 	rb_insert_color(&mcast->rb_node, &ibp->mcast_tree);
221 
222 	ret = 0;
223 
224 bail:
225 	spin_unlock_irq(&ibp->lock);
226 
227 	return ret;
228 }
229 
230 /**
231  * rvt_attach_mcast - attach a qp to a multicast group
232  * @ibqp: Infiniband qp
233  * @gid: multicast guid
234  * @lid: multicast lid
235  *
236  * Return: 0 on success
237  */
238 int rvt_attach_mcast(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
239 {
240 	struct rvt_qp *qp = ibqp_to_rvtqp(ibqp);
241 	struct rvt_dev_info *rdi = ib_to_rvt(ibqp->device);
242 	struct rvt_ibport *ibp = rdi->ports[qp->port_num - 1];
243 	struct rvt_mcast *mcast;
244 	struct rvt_mcast_qp *mqp;
245 	int ret = -ENOMEM;
246 
247 	if (ibqp->qp_num <= 1 || qp->state == IB_QPS_RESET)
248 		return -EINVAL;
249 
250 	/*
251 	 * Allocate data structures since its better to do this outside of
252 	 * spin locks and it will most likely be needed.
253 	 */
254 	mcast = rvt_mcast_alloc(gid, lid);
255 	if (!mcast)
256 		return -ENOMEM;
257 
258 	mqp = rvt_mcast_qp_alloc(qp);
259 	if (!mqp)
260 		goto bail_mcast;
261 
262 	switch (rvt_mcast_add(rdi, ibp, mcast, mqp)) {
263 	case ESRCH:
264 		/* Neither was used: OK to attach the same QP twice. */
265 		ret = 0;
266 		goto bail_mqp;
267 	case EEXIST: /* The mcast wasn't used */
268 		ret = 0;
269 		goto bail_mcast;
270 	case ENOMEM:
271 		/* Exceeded the maximum number of mcast groups. */
272 		ret = -ENOMEM;
273 		goto bail_mqp;
274 	case EINVAL:
275 		/* Invalid MGID/MLID pair */
276 		ret = -EINVAL;
277 		goto bail_mqp;
278 	default:
279 		break;
280 	}
281 
282 	return 0;
283 
284 bail_mqp:
285 	rvt_mcast_qp_free(mqp);
286 
287 bail_mcast:
288 	rvt_mcast_free(mcast);
289 
290 	return ret;
291 }
292 
293 /**
294  * rvt_detach_mcast - remove a qp from a multicast group
295  * @ibqp: Infiniband qp
296  * @gid: multicast guid
297  * @lid: multicast lid
298  *
299  * Return: 0 on success
300  */
301 int rvt_detach_mcast(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
302 {
303 	struct rvt_qp *qp = ibqp_to_rvtqp(ibqp);
304 	struct rvt_dev_info *rdi = ib_to_rvt(ibqp->device);
305 	struct rvt_ibport *ibp = rdi->ports[qp->port_num - 1];
306 	struct rvt_mcast *mcast = NULL;
307 	struct rvt_mcast_qp *p, *tmp, *delp = NULL;
308 	struct rb_node *n;
309 	int last = 0;
310 	int ret = 0;
311 
312 	if (ibqp->qp_num <= 1)
313 		return -EINVAL;
314 
315 	spin_lock_irq(&ibp->lock);
316 
317 	/* Find the GID in the mcast table. */
318 	n = ibp->mcast_tree.rb_node;
319 	while (1) {
320 		if (!n) {
321 			spin_unlock_irq(&ibp->lock);
322 			return -EINVAL;
323 		}
324 
325 		mcast = rb_entry(n, struct rvt_mcast, rb_node);
326 		ret = memcmp(gid->raw, mcast->mcast_addr.mgid.raw,
327 			     sizeof(*gid));
328 		if (ret < 0) {
329 			n = n->rb_left;
330 		} else if (ret > 0) {
331 			n = n->rb_right;
332 		} else {
333 			/* MGID/MLID must match */
334 			if (mcast->mcast_addr.lid != lid) {
335 				spin_unlock_irq(&ibp->lock);
336 				return -EINVAL;
337 			}
338 			break;
339 		}
340 	}
341 
342 	/* Search the QP list. */
343 	list_for_each_entry_safe(p, tmp, &mcast->qp_list, list) {
344 		if (p->qp != qp)
345 			continue;
346 		/*
347 		 * We found it, so remove it, but don't poison the forward
348 		 * link until we are sure there are no list walkers.
349 		 */
350 		list_del_rcu(&p->list);
351 		mcast->n_attached--;
352 		delp = p;
353 
354 		/* If this was the last attached QP, remove the GID too. */
355 		if (list_empty(&mcast->qp_list)) {
356 			rb_erase(&mcast->rb_node, &ibp->mcast_tree);
357 			last = 1;
358 		}
359 		break;
360 	}
361 
362 	spin_unlock_irq(&ibp->lock);
363 	/* QP not attached */
364 	if (!delp)
365 		return -EINVAL;
366 
367 	/*
368 	 * Wait for any list walkers to finish before freeing the
369 	 * list element.
370 	 */
371 	wait_event(mcast->wait, atomic_read(&mcast->refcount) <= 1);
372 	rvt_mcast_qp_free(delp);
373 
374 	if (last) {
375 		atomic_dec(&mcast->refcount);
376 		wait_event(mcast->wait, !atomic_read(&mcast->refcount));
377 		rvt_mcast_free(mcast);
378 		spin_lock_irq(&rdi->n_mcast_grps_lock);
379 		rdi->n_mcast_grps_allocated--;
380 		spin_unlock_irq(&rdi->n_mcast_grps_lock);
381 	}
382 
383 	return 0;
384 }
385 
386 /**
387  * rvt_mcast_tree_empty - determine if any qps are attached to any mcast group
388  * @rdi: rvt dev struct
389  *
390  * Return: in use count
391  */
392 int rvt_mcast_tree_empty(struct rvt_dev_info *rdi)
393 {
394 	int i;
395 	int in_use = 0;
396 
397 	for (i = 0; i < rdi->dparms.nports; i++)
398 		if (rdi->ports[i]->mcast_tree.rb_node)
399 			in_use++;
400 	return in_use;
401 }
402