include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-3.10.git] / drivers / infiniband / hw / ipath / ipath_verbs_mcast.c
1 /*
2  * Copyright (c) 2006, 2007 QLogic Corporation. All rights reserved.
3  * Copyright (c) 2005, 2006 PathScale, Inc. All rights reserved.
4  *
5  * This software is available to you under a choice of one of two
6  * licenses.  You may choose to be licensed under the terms of the GNU
7  * General Public License (GPL) Version 2, available from the file
8  * COPYING in the main directory of this source tree, or the
9  * OpenIB.org BSD license below:
10  *
11  *     Redistribution and use in source and binary forms, with or
12  *     without modification, are permitted provided that the following
13  *     conditions are met:
14  *
15  *      - Redistributions of source code must retain the above
16  *        copyright notice, this list of conditions and the following
17  *        disclaimer.
18  *
19  *      - Redistributions in binary form must reproduce the above
20  *        copyright notice, this list of conditions and the following
21  *        disclaimer in the documentation and/or other materials
22  *        provided with the distribution.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31  * SOFTWARE.
32  */
33
34 #include <linux/rculist.h>
35 #include <linux/sched.h>
36 #include <linux/slab.h>
37
38 #include "ipath_verbs.h"
39
40 /*
41  * Global table of GID to attached QPs.
42  * The table is global to all ipath devices since a send from one QP/device
43  * needs to be locally routed to any locally attached QPs on the same
44  * or different device.
45  */
46 static struct rb_root mcast_tree;
47 static DEFINE_SPINLOCK(mcast_lock);
48
49 /**
50  * ipath_mcast_qp_alloc - alloc a struct to link a QP to mcast GID struct
51  * @qp: the QP to link
52  */
53 static struct ipath_mcast_qp *ipath_mcast_qp_alloc(struct ipath_qp *qp)
54 {
55         struct ipath_mcast_qp *mqp;
56
57         mqp = kmalloc(sizeof *mqp, GFP_KERNEL);
58         if (!mqp)
59                 goto bail;
60
61         mqp->qp = qp;
62         atomic_inc(&qp->refcount);
63
64 bail:
65         return mqp;
66 }
67
68 static void ipath_mcast_qp_free(struct ipath_mcast_qp *mqp)
69 {
70         struct ipath_qp *qp = mqp->qp;
71
72         /* Notify ipath_destroy_qp() if it is waiting. */
73         if (atomic_dec_and_test(&qp->refcount))
74                 wake_up(&qp->wait);
75
76         kfree(mqp);
77 }
78
79 /**
80  * ipath_mcast_alloc - allocate the multicast GID structure
81  * @mgid: the multicast GID
82  *
83  * A list of QPs will be attached to this structure.
84  */
85 static struct ipath_mcast *ipath_mcast_alloc(union ib_gid *mgid)
86 {
87         struct ipath_mcast *mcast;
88
89         mcast = kmalloc(sizeof *mcast, GFP_KERNEL);
90         if (!mcast)
91                 goto bail;
92
93         mcast->mgid = *mgid;
94         INIT_LIST_HEAD(&mcast->qp_list);
95         init_waitqueue_head(&mcast->wait);
96         atomic_set(&mcast->refcount, 0);
97         mcast->n_attached = 0;
98
99 bail:
100         return mcast;
101 }
102
103 static void ipath_mcast_free(struct ipath_mcast *mcast)
104 {
105         struct ipath_mcast_qp *p, *tmp;
106
107         list_for_each_entry_safe(p, tmp, &mcast->qp_list, list)
108                 ipath_mcast_qp_free(p);
109
110         kfree(mcast);
111 }
112
113 /**
114  * ipath_mcast_find - search the global table for the given multicast GID
115  * @mgid: the multicast GID to search for
116  *
117  * Returns NULL if not found.
118  *
119  * The caller is responsible for decrementing the reference count if found.
120  */
121 struct ipath_mcast *ipath_mcast_find(union ib_gid *mgid)
122 {
123         struct rb_node *n;
124         unsigned long flags;
125         struct ipath_mcast *mcast;
126
127         spin_lock_irqsave(&mcast_lock, flags);
128         n = mcast_tree.rb_node;
129         while (n) {
130                 int ret;
131
132                 mcast = rb_entry(n, struct ipath_mcast, rb_node);
133
134                 ret = memcmp(mgid->raw, mcast->mgid.raw,
135                              sizeof(union ib_gid));
136                 if (ret < 0)
137                         n = n->rb_left;
138                 else if (ret > 0)
139                         n = n->rb_right;
140                 else {
141                         atomic_inc(&mcast->refcount);
142                         spin_unlock_irqrestore(&mcast_lock, flags);
143                         goto bail;
144                 }
145         }
146         spin_unlock_irqrestore(&mcast_lock, flags);
147
148         mcast = NULL;
149
150 bail:
151         return mcast;
152 }
153
154 /**
155  * ipath_mcast_add - insert mcast GID into table and attach QP struct
156  * @mcast: the mcast GID table
157  * @mqp: the QP to attach
158  *
159  * Return zero if both were added.  Return EEXIST if the GID was already in
160  * the table but the QP was added.  Return ESRCH if the QP was already
161  * attached and neither structure was added.
162  */
163 static int ipath_mcast_add(struct ipath_ibdev *dev,
164                            struct ipath_mcast *mcast,
165                            struct ipath_mcast_qp *mqp)
166 {
167         struct rb_node **n = &mcast_tree.rb_node;
168         struct rb_node *pn = NULL;
169         int ret;
170
171         spin_lock_irq(&mcast_lock);
172
173         while (*n) {
174                 struct ipath_mcast *tmcast;
175                 struct ipath_mcast_qp *p;
176
177                 pn = *n;
178                 tmcast = rb_entry(pn, struct ipath_mcast, rb_node);
179
180                 ret = memcmp(mcast->mgid.raw, tmcast->mgid.raw,
181                              sizeof(union ib_gid));
182                 if (ret < 0) {
183                         n = &pn->rb_left;
184                         continue;
185                 }
186                 if (ret > 0) {
187                         n = &pn->rb_right;
188                         continue;
189                 }
190
191                 /* Search the QP list to see if this is already there. */
192                 list_for_each_entry_rcu(p, &tmcast->qp_list, list) {
193                         if (p->qp == mqp->qp) {
194                                 ret = ESRCH;
195                                 goto bail;
196                         }
197                 }
198                 if (tmcast->n_attached == ib_ipath_max_mcast_qp_attached) {
199                         ret = ENOMEM;
200                         goto bail;
201                 }
202
203                 tmcast->n_attached++;
204
205                 list_add_tail_rcu(&mqp->list, &tmcast->qp_list);
206                 ret = EEXIST;
207                 goto bail;
208         }
209
210         spin_lock(&dev->n_mcast_grps_lock);
211         if (dev->n_mcast_grps_allocated == ib_ipath_max_mcast_grps) {
212                 spin_unlock(&dev->n_mcast_grps_lock);
213                 ret = ENOMEM;
214                 goto bail;
215         }
216
217         dev->n_mcast_grps_allocated++;
218         spin_unlock(&dev->n_mcast_grps_lock);
219
220         mcast->n_attached++;
221
222         list_add_tail_rcu(&mqp->list, &mcast->qp_list);
223
224         atomic_inc(&mcast->refcount);
225         rb_link_node(&mcast->rb_node, pn, n);
226         rb_insert_color(&mcast->rb_node, &mcast_tree);
227
228         ret = 0;
229
230 bail:
231         spin_unlock_irq(&mcast_lock);
232
233         return ret;
234 }
235
236 int ipath_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
237 {
238         struct ipath_qp *qp = to_iqp(ibqp);
239         struct ipath_ibdev *dev = to_idev(ibqp->device);
240         struct ipath_mcast *mcast;
241         struct ipath_mcast_qp *mqp;
242         int ret;
243
244         /*
245          * Allocate data structures since its better to do this outside of
246          * spin locks and it will most likely be needed.
247          */
248         mcast = ipath_mcast_alloc(gid);
249         if (mcast == NULL) {
250                 ret = -ENOMEM;
251                 goto bail;
252         }
253         mqp = ipath_mcast_qp_alloc(qp);
254         if (mqp == NULL) {
255                 ipath_mcast_free(mcast);
256                 ret = -ENOMEM;
257                 goto bail;
258         }
259         switch (ipath_mcast_add(dev, mcast, mqp)) {
260         case ESRCH:
261                 /* Neither was used: can't attach the same QP twice. */
262                 ipath_mcast_qp_free(mqp);
263                 ipath_mcast_free(mcast);
264                 ret = -EINVAL;
265                 goto bail;
266         case EEXIST:            /* The mcast wasn't used */
267                 ipath_mcast_free(mcast);
268                 break;
269         case ENOMEM:
270                 /* Exceeded the maximum number of mcast groups. */
271                 ipath_mcast_qp_free(mqp);
272                 ipath_mcast_free(mcast);
273                 ret = -ENOMEM;
274                 goto bail;
275         default:
276                 break;
277         }
278
279         ret = 0;
280
281 bail:
282         return ret;
283 }
284
285 int ipath_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
286 {
287         struct ipath_qp *qp = to_iqp(ibqp);
288         struct ipath_ibdev *dev = to_idev(ibqp->device);
289         struct ipath_mcast *mcast = NULL;
290         struct ipath_mcast_qp *p, *tmp;
291         struct rb_node *n;
292         int last = 0;
293         int ret;
294
295         spin_lock_irq(&mcast_lock);
296
297         /* Find the GID in the mcast table. */
298         n = mcast_tree.rb_node;
299         while (1) {
300                 if (n == NULL) {
301                         spin_unlock_irq(&mcast_lock);
302                         ret = -EINVAL;
303                         goto bail;
304                 }
305
306                 mcast = rb_entry(n, struct ipath_mcast, rb_node);
307                 ret = memcmp(gid->raw, mcast->mgid.raw,
308                              sizeof(union ib_gid));
309                 if (ret < 0)
310                         n = n->rb_left;
311                 else if (ret > 0)
312                         n = n->rb_right;
313                 else
314                         break;
315         }
316
317         /* Search the QP list. */
318         list_for_each_entry_safe(p, tmp, &mcast->qp_list, list) {
319                 if (p->qp != qp)
320                         continue;
321                 /*
322                  * We found it, so remove it, but don't poison the forward
323                  * link until we are sure there are no list walkers.
324                  */
325                 list_del_rcu(&p->list);
326                 mcast->n_attached--;
327
328                 /* If this was the last attached QP, remove the GID too. */
329                 if (list_empty(&mcast->qp_list)) {
330                         rb_erase(&mcast->rb_node, &mcast_tree);
331                         last = 1;
332                 }
333                 break;
334         }
335
336         spin_unlock_irq(&mcast_lock);
337
338         if (p) {
339                 /*
340                  * Wait for any list walkers to finish before freeing the
341                  * list element.
342                  */
343                 wait_event(mcast->wait, atomic_read(&mcast->refcount) <= 1);
344                 ipath_mcast_qp_free(p);
345         }
346         if (last) {
347                 atomic_dec(&mcast->refcount);
348                 wait_event(mcast->wait, !atomic_read(&mcast->refcount));
349                 ipath_mcast_free(mcast);
350                 spin_lock_irq(&dev->n_mcast_grps_lock);
351                 dev->n_mcast_grps_allocated--;
352                 spin_unlock_irq(&dev->n_mcast_grps_lock);
353         }
354
355         ret = 0;
356
357 bail:
358         return ret;
359 }
360
361 int ipath_mcast_tree_empty(void)
362 {
363         return mcast_tree.rb_node == NULL;
364 }