IB/qib: Add new qib driver for QLogic PCIe InfiniBand adapters
[linux-2.6.git] / drivers / infiniband / hw / qib / qib_verbs_mcast.c
1 /*
2  * Copyright (c) 2006, 2007, 2008, 2009 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
36 #include "qib.h"
37
38 /**
39  * qib_mcast_qp_alloc - alloc a struct to link a QP to mcast GID struct
40  * @qp: the QP to link
41  */
42 static struct qib_mcast_qp *qib_mcast_qp_alloc(struct qib_qp *qp)
43 {
44         struct qib_mcast_qp *mqp;
45
46         mqp = kmalloc(sizeof *mqp, GFP_KERNEL);
47         if (!mqp)
48                 goto bail;
49
50         mqp->qp = qp;
51         atomic_inc(&qp->refcount);
52
53 bail:
54         return mqp;
55 }
56
57 static void qib_mcast_qp_free(struct qib_mcast_qp *mqp)
58 {
59         struct qib_qp *qp = mqp->qp;
60
61         /* Notify qib_destroy_qp() if it is waiting. */
62         if (atomic_dec_and_test(&qp->refcount))
63                 wake_up(&qp->wait);
64
65         kfree(mqp);
66 }
67
68 /**
69  * qib_mcast_alloc - allocate the multicast GID structure
70  * @mgid: the multicast GID
71  *
72  * A list of QPs will be attached to this structure.
73  */
74 static struct qib_mcast *qib_mcast_alloc(union ib_gid *mgid)
75 {
76         struct qib_mcast *mcast;
77
78         mcast = kmalloc(sizeof *mcast, GFP_KERNEL);
79         if (!mcast)
80                 goto bail;
81
82         mcast->mgid = *mgid;
83         INIT_LIST_HEAD(&mcast->qp_list);
84         init_waitqueue_head(&mcast->wait);
85         atomic_set(&mcast->refcount, 0);
86         mcast->n_attached = 0;
87
88 bail:
89         return mcast;
90 }
91
92 static void qib_mcast_free(struct qib_mcast *mcast)
93 {
94         struct qib_mcast_qp *p, *tmp;
95
96         list_for_each_entry_safe(p, tmp, &mcast->qp_list, list)
97                 qib_mcast_qp_free(p);
98
99         kfree(mcast);
100 }
101
102 /**
103  * qib_mcast_find - search the global table for the given multicast GID
104  * @ibp: the IB port structure
105  * @mgid: the multicast GID to search for
106  *
107  * Returns NULL if not found.
108  *
109  * The caller is responsible for decrementing the reference count if found.
110  */
111 struct qib_mcast *qib_mcast_find(struct qib_ibport *ibp, union ib_gid *mgid)
112 {
113         struct rb_node *n;
114         unsigned long flags;
115         struct qib_mcast *mcast;
116
117         spin_lock_irqsave(&ibp->lock, flags);
118         n = ibp->mcast_tree.rb_node;
119         while (n) {
120                 int ret;
121
122                 mcast = rb_entry(n, struct qib_mcast, rb_node);
123
124                 ret = memcmp(mgid->raw, mcast->mgid.raw,
125                              sizeof(union ib_gid));
126                 if (ret < 0)
127                         n = n->rb_left;
128                 else if (ret > 0)
129                         n = n->rb_right;
130                 else {
131                         atomic_inc(&mcast->refcount);
132                         spin_unlock_irqrestore(&ibp->lock, flags);
133                         goto bail;
134                 }
135         }
136         spin_unlock_irqrestore(&ibp->lock, flags);
137
138         mcast = NULL;
139
140 bail:
141         return mcast;
142 }
143
144 /**
145  * qib_mcast_add - insert mcast GID into table and attach QP struct
146  * @mcast: the mcast GID table
147  * @mqp: the QP to attach
148  *
149  * Return zero if both were added.  Return EEXIST if the GID was already in
150  * the table but the QP was added.  Return ESRCH if the QP was already
151  * attached and neither structure was added.
152  */
153 static int qib_mcast_add(struct qib_ibdev *dev, struct qib_ibport *ibp,
154                          struct qib_mcast *mcast, struct qib_mcast_qp *mqp)
155 {
156         struct rb_node **n = &ibp->mcast_tree.rb_node;
157         struct rb_node *pn = NULL;
158         int ret;
159
160         spin_lock_irq(&ibp->lock);
161
162         while (*n) {
163                 struct qib_mcast *tmcast;
164                 struct qib_mcast_qp *p;
165
166                 pn = *n;
167                 tmcast = rb_entry(pn, struct qib_mcast, rb_node);
168
169                 ret = memcmp(mcast->mgid.raw, tmcast->mgid.raw,
170                              sizeof(union ib_gid));
171                 if (ret < 0) {
172                         n = &pn->rb_left;
173                         continue;
174                 }
175                 if (ret > 0) {
176                         n = &pn->rb_right;
177                         continue;
178                 }
179
180                 /* Search the QP list to see if this is already there. */
181                 list_for_each_entry_rcu(p, &tmcast->qp_list, list) {
182                         if (p->qp == mqp->qp) {
183                                 ret = ESRCH;
184                                 goto bail;
185                         }
186                 }
187                 if (tmcast->n_attached == ib_qib_max_mcast_qp_attached) {
188                         ret = ENOMEM;
189                         goto bail;
190                 }
191
192                 tmcast->n_attached++;
193
194                 list_add_tail_rcu(&mqp->list, &tmcast->qp_list);
195                 ret = EEXIST;
196                 goto bail;
197         }
198
199         spin_lock(&dev->n_mcast_grps_lock);
200         if (dev->n_mcast_grps_allocated == ib_qib_max_mcast_grps) {
201                 spin_unlock(&dev->n_mcast_grps_lock);
202                 ret = ENOMEM;
203                 goto bail;
204         }
205
206         dev->n_mcast_grps_allocated++;
207         spin_unlock(&dev->n_mcast_grps_lock);
208
209         mcast->n_attached++;
210
211         list_add_tail_rcu(&mqp->list, &mcast->qp_list);
212
213         atomic_inc(&mcast->refcount);
214         rb_link_node(&mcast->rb_node, pn, n);
215         rb_insert_color(&mcast->rb_node, &ibp->mcast_tree);
216
217         ret = 0;
218
219 bail:
220         spin_unlock_irq(&ibp->lock);
221
222         return ret;
223 }
224
225 int qib_multicast_attach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
226 {
227         struct qib_qp *qp = to_iqp(ibqp);
228         struct qib_ibdev *dev = to_idev(ibqp->device);
229         struct qib_ibport *ibp;
230         struct qib_mcast *mcast;
231         struct qib_mcast_qp *mqp;
232         int ret;
233
234         if (ibqp->qp_num <= 1 || qp->state == IB_QPS_RESET) {
235                 ret = -EINVAL;
236                 goto bail;
237         }
238
239         /*
240          * Allocate data structures since its better to do this outside of
241          * spin locks and it will most likely be needed.
242          */
243         mcast = qib_mcast_alloc(gid);
244         if (mcast == NULL) {
245                 ret = -ENOMEM;
246                 goto bail;
247         }
248         mqp = qib_mcast_qp_alloc(qp);
249         if (mqp == NULL) {
250                 qib_mcast_free(mcast);
251                 ret = -ENOMEM;
252                 goto bail;
253         }
254         ibp = to_iport(ibqp->device, qp->port_num);
255         switch (qib_mcast_add(dev, ibp, mcast, mqp)) {
256         case ESRCH:
257                 /* Neither was used: OK to attach the same QP twice. */
258                 qib_mcast_qp_free(mqp);
259                 qib_mcast_free(mcast);
260                 break;
261
262         case EEXIST:            /* The mcast wasn't used */
263                 qib_mcast_free(mcast);
264                 break;
265
266         case ENOMEM:
267                 /* Exceeded the maximum number of mcast groups. */
268                 qib_mcast_qp_free(mqp);
269                 qib_mcast_free(mcast);
270                 ret = -ENOMEM;
271                 goto bail;
272
273         default:
274                 break;
275         }
276
277         ret = 0;
278
279 bail:
280         return ret;
281 }
282
283 int qib_multicast_detach(struct ib_qp *ibqp, union ib_gid *gid, u16 lid)
284 {
285         struct qib_qp *qp = to_iqp(ibqp);
286         struct qib_ibdev *dev = to_idev(ibqp->device);
287         struct qib_ibport *ibp = to_iport(ibqp->device, qp->port_num);
288         struct qib_mcast *mcast = NULL;
289         struct qib_mcast_qp *p, *tmp;
290         struct rb_node *n;
291         int last = 0;
292         int ret;
293
294         if (ibqp->qp_num <= 1 || qp->state == IB_QPS_RESET) {
295                 ret = -EINVAL;
296                 goto bail;
297         }
298
299         spin_lock_irq(&ibp->lock);
300
301         /* Find the GID in the mcast table. */
302         n = ibp->mcast_tree.rb_node;
303         while (1) {
304                 if (n == NULL) {
305                         spin_unlock_irq(&ibp->lock);
306                         ret = -EINVAL;
307                         goto bail;
308                 }
309
310                 mcast = rb_entry(n, struct qib_mcast, rb_node);
311                 ret = memcmp(gid->raw, mcast->mgid.raw,
312                              sizeof(union ib_gid));
313                 if (ret < 0)
314                         n = n->rb_left;
315                 else if (ret > 0)
316                         n = n->rb_right;
317                 else
318                         break;
319         }
320
321         /* Search the QP list. */
322         list_for_each_entry_safe(p, tmp, &mcast->qp_list, list) {
323                 if (p->qp != qp)
324                         continue;
325                 /*
326                  * We found it, so remove it, but don't poison the forward
327                  * link until we are sure there are no list walkers.
328                  */
329                 list_del_rcu(&p->list);
330                 mcast->n_attached--;
331
332                 /* If this was the last attached QP, remove the GID too. */
333                 if (list_empty(&mcast->qp_list)) {
334                         rb_erase(&mcast->rb_node, &ibp->mcast_tree);
335                         last = 1;
336                 }
337                 break;
338         }
339
340         spin_unlock_irq(&ibp->lock);
341
342         if (p) {
343                 /*
344                  * Wait for any list walkers to finish before freeing the
345                  * list element.
346                  */
347                 wait_event(mcast->wait, atomic_read(&mcast->refcount) <= 1);
348                 qib_mcast_qp_free(p);
349         }
350         if (last) {
351                 atomic_dec(&mcast->refcount);
352                 wait_event(mcast->wait, !atomic_read(&mcast->refcount));
353                 qib_mcast_free(mcast);
354                 spin_lock_irq(&dev->n_mcast_grps_lock);
355                 dev->n_mcast_grps_allocated--;
356                 spin_unlock_irq(&dev->n_mcast_grps_lock);
357         }
358
359         ret = 0;
360
361 bail:
362         return ret;
363 }
364
365 int qib_mcast_tree_empty(struct qib_ibport *ibp)
366 {
367         return ibp->mcast_tree.rb_node == NULL;
368 }