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