]> nv-tegra.nvidia Code Review - linux-3.10.git/blob - drivers/infiniband/core/iwcm.c
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-3.10.git] / drivers / infiniband / core / iwcm.c
1 /*
2  * Copyright (c) 2004, 2005 Intel Corporation.  All rights reserved.
3  * Copyright (c) 2004 Topspin Corporation.  All rights reserved.
4  * Copyright (c) 2004, 2005 Voltaire Corporation.  All rights reserved.
5  * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
6  * Copyright (c) 2005 Open Grid Computing, Inc. All rights reserved.
7  * Copyright (c) 2005 Network Appliance, Inc. All rights reserved.
8  *
9  * This software is available to you under a choice of one of two
10  * licenses.  You may choose to be licensed under the terms of the GNU
11  * General Public License (GPL) Version 2, available from the file
12  * COPYING in the main directory of this source tree, or the
13  * OpenIB.org BSD license below:
14  *
15  *     Redistribution and use in source and binary forms, with or
16  *     without modification, are permitted provided that the following
17  *     conditions are met:
18  *
19  *      - Redistributions of source code must retain the above
20  *        copyright notice, this list of conditions and the following
21  *        disclaimer.
22  *
23  *      - Redistributions in binary form must reproduce the above
24  *        copyright notice, this list of conditions and the following
25  *        disclaimer in the documentation and/or other materials
26  *        provided with the distribution.
27  *
28  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
29  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
30  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
31  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
32  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
33  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
34  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
35  * SOFTWARE.
36  *
37  */
38 #include <linux/dma-mapping.h>
39 #include <linux/err.h>
40 #include <linux/idr.h>
41 #include <linux/interrupt.h>
42 #include <linux/rbtree.h>
43 #include <linux/sched.h>
44 #include <linux/spinlock.h>
45 #include <linux/workqueue.h>
46 #include <linux/completion.h>
47 #include <linux/slab.h>
48
49 #include <rdma/iw_cm.h>
50 #include <rdma/ib_addr.h>
51
52 #include "iwcm.h"
53
54 MODULE_AUTHOR("Tom Tucker");
55 MODULE_DESCRIPTION("iWARP CM");
56 MODULE_LICENSE("Dual BSD/GPL");
57
58 static struct workqueue_struct *iwcm_wq;
59 struct iwcm_work {
60         struct work_struct work;
61         struct iwcm_id_private *cm_id;
62         struct list_head list;
63         struct iw_cm_event event;
64         struct list_head free_list;
65 };
66
67 /*
68  * The following services provide a mechanism for pre-allocating iwcm_work
69  * elements.  The design pre-allocates them  based on the cm_id type:
70  *      LISTENING IDS:  Get enough elements preallocated to handle the
71  *                      listen backlog.
72  *      ACTIVE IDS:     4: CONNECT_REPLY, ESTABLISHED, DISCONNECT, CLOSE
73  *      PASSIVE IDS:    3: ESTABLISHED, DISCONNECT, CLOSE
74  *
75  * Allocating them in connect and listen avoids having to deal
76  * with allocation failures on the event upcall from the provider (which
77  * is called in the interrupt context).
78  *
79  * One exception is when creating the cm_id for incoming connection requests.
80  * There are two cases:
81  * 1) in the event upcall, cm_event_handler(), for a listening cm_id.  If
82  *    the backlog is exceeded, then no more connection request events will
83  *    be processed.  cm_event_handler() returns -ENOMEM in this case.  Its up
84  *    to the provider to reject the connection request.
85  * 2) in the connection request workqueue handler, cm_conn_req_handler().
86  *    If work elements cannot be allocated for the new connect request cm_id,
87  *    then IWCM will call the provider reject method.  This is ok since
88  *    cm_conn_req_handler() runs in the workqueue thread context.
89  */
90
91 static struct iwcm_work *get_work(struct iwcm_id_private *cm_id_priv)
92 {
93         struct iwcm_work *work;
94
95         if (list_empty(&cm_id_priv->work_free_list))
96                 return NULL;
97         work = list_entry(cm_id_priv->work_free_list.next, struct iwcm_work,
98                           free_list);
99         list_del_init(&work->free_list);
100         return work;
101 }
102
103 static void put_work(struct iwcm_work *work)
104 {
105         list_add(&work->free_list, &work->cm_id->work_free_list);
106 }
107
108 static void dealloc_work_entries(struct iwcm_id_private *cm_id_priv)
109 {
110         struct list_head *e, *tmp;
111
112         list_for_each_safe(e, tmp, &cm_id_priv->work_free_list)
113                 kfree(list_entry(e, struct iwcm_work, free_list));
114 }
115
116 static int alloc_work_entries(struct iwcm_id_private *cm_id_priv, int count)
117 {
118         struct iwcm_work *work;
119
120         BUG_ON(!list_empty(&cm_id_priv->work_free_list));
121         while (count--) {
122                 work = kmalloc(sizeof(struct iwcm_work), GFP_KERNEL);
123                 if (!work) {
124                         dealloc_work_entries(cm_id_priv);
125                         return -ENOMEM;
126                 }
127                 work->cm_id = cm_id_priv;
128                 INIT_LIST_HEAD(&work->list);
129                 put_work(work);
130         }
131         return 0;
132 }
133
134 /*
135  * Save private data from incoming connection requests to
136  * iw_cm_event, so the low level driver doesn't have to. Adjust
137  * the event ptr to point to the local copy.
138  */
139 static int copy_private_data(struct iw_cm_event *event)
140 {
141         void *p;
142
143         p = kmemdup(event->private_data, event->private_data_len, GFP_ATOMIC);
144         if (!p)
145                 return -ENOMEM;
146         event->private_data = p;
147         return 0;
148 }
149
150 static void free_cm_id(struct iwcm_id_private *cm_id_priv)
151 {
152         dealloc_work_entries(cm_id_priv);
153         kfree(cm_id_priv);
154 }
155
156 /*
157  * Release a reference on cm_id. If the last reference is being
158  * released, enable the waiting thread (in iw_destroy_cm_id) to
159  * get woken up, and return 1 if a thread is already waiting.
160  */
161 static int iwcm_deref_id(struct iwcm_id_private *cm_id_priv)
162 {
163         BUG_ON(atomic_read(&cm_id_priv->refcount)==0);
164         if (atomic_dec_and_test(&cm_id_priv->refcount)) {
165                 BUG_ON(!list_empty(&cm_id_priv->work_list));
166                 complete(&cm_id_priv->destroy_comp);
167                 return 1;
168         }
169
170         return 0;
171 }
172
173 static void add_ref(struct iw_cm_id *cm_id)
174 {
175         struct iwcm_id_private *cm_id_priv;
176         cm_id_priv = container_of(cm_id, struct iwcm_id_private, id);
177         atomic_inc(&cm_id_priv->refcount);
178 }
179
180 static void rem_ref(struct iw_cm_id *cm_id)
181 {
182         struct iwcm_id_private *cm_id_priv;
183         cm_id_priv = container_of(cm_id, struct iwcm_id_private, id);
184         if (iwcm_deref_id(cm_id_priv) &&
185             test_bit(IWCM_F_CALLBACK_DESTROY, &cm_id_priv->flags)) {
186                 BUG_ON(!list_empty(&cm_id_priv->work_list));
187                 free_cm_id(cm_id_priv);
188         }
189 }
190
191 static int cm_event_handler(struct iw_cm_id *cm_id, struct iw_cm_event *event);
192
193 struct iw_cm_id *iw_create_cm_id(struct ib_device *device,
194                                  iw_cm_handler cm_handler,
195                                  void *context)
196 {
197         struct iwcm_id_private *cm_id_priv;
198
199         cm_id_priv = kzalloc(sizeof(*cm_id_priv), GFP_KERNEL);
200         if (!cm_id_priv)
201                 return ERR_PTR(-ENOMEM);
202
203         cm_id_priv->state = IW_CM_STATE_IDLE;
204         cm_id_priv->id.device = device;
205         cm_id_priv->id.cm_handler = cm_handler;
206         cm_id_priv->id.context = context;
207         cm_id_priv->id.event_handler = cm_event_handler;
208         cm_id_priv->id.add_ref = add_ref;
209         cm_id_priv->id.rem_ref = rem_ref;
210         spin_lock_init(&cm_id_priv->lock);
211         atomic_set(&cm_id_priv->refcount, 1);
212         init_waitqueue_head(&cm_id_priv->connect_wait);
213         init_completion(&cm_id_priv->destroy_comp);
214         INIT_LIST_HEAD(&cm_id_priv->work_list);
215         INIT_LIST_HEAD(&cm_id_priv->work_free_list);
216
217         return &cm_id_priv->id;
218 }
219 EXPORT_SYMBOL(iw_create_cm_id);
220
221
222 static int iwcm_modify_qp_err(struct ib_qp *qp)
223 {
224         struct ib_qp_attr qp_attr;
225
226         if (!qp)
227                 return -EINVAL;
228
229         qp_attr.qp_state = IB_QPS_ERR;
230         return ib_modify_qp(qp, &qp_attr, IB_QP_STATE);
231 }
232
233 /*
234  * This is really the RDMAC CLOSING state. It is most similar to the
235  * IB SQD QP state.
236  */
237 static int iwcm_modify_qp_sqd(struct ib_qp *qp)
238 {
239         struct ib_qp_attr qp_attr;
240
241         BUG_ON(qp == NULL);
242         qp_attr.qp_state = IB_QPS_SQD;
243         return ib_modify_qp(qp, &qp_attr, IB_QP_STATE);
244 }
245
246 /*
247  * CM_ID <-- CLOSING
248  *
249  * Block if a passive or active connection is currently being processed. Then
250  * process the event as follows:
251  * - If we are ESTABLISHED, move to CLOSING and modify the QP state
252  *   based on the abrupt flag
253  * - If the connection is already in the CLOSING or IDLE state, the peer is
254  *   disconnecting concurrently with us and we've already seen the
255  *   DISCONNECT event -- ignore the request and return 0
256  * - Disconnect on a listening endpoint returns -EINVAL
257  */
258 int iw_cm_disconnect(struct iw_cm_id *cm_id, int abrupt)
259 {
260         struct iwcm_id_private *cm_id_priv;
261         unsigned long flags;
262         int ret = 0;
263         struct ib_qp *qp = NULL;
264
265         cm_id_priv = container_of(cm_id, struct iwcm_id_private, id);
266         /* Wait if we're currently in a connect or accept downcall */
267         wait_event(cm_id_priv->connect_wait,
268                    !test_bit(IWCM_F_CONNECT_WAIT, &cm_id_priv->flags));
269
270         spin_lock_irqsave(&cm_id_priv->lock, flags);
271         switch (cm_id_priv->state) {
272         case IW_CM_STATE_ESTABLISHED:
273                 cm_id_priv->state = IW_CM_STATE_CLOSING;
274
275                 /* QP could be <nul> for user-mode client */
276                 if (cm_id_priv->qp)
277                         qp = cm_id_priv->qp;
278                 else
279                         ret = -EINVAL;
280                 break;
281         case IW_CM_STATE_LISTEN:
282                 ret = -EINVAL;
283                 break;
284         case IW_CM_STATE_CLOSING:
285                 /* remote peer closed first */
286         case IW_CM_STATE_IDLE:
287                 /* accept or connect returned !0 */
288                 break;
289         case IW_CM_STATE_CONN_RECV:
290                 /*
291                  * App called disconnect before/without calling accept after
292                  * connect_request event delivered.
293                  */
294                 break;
295         case IW_CM_STATE_CONN_SENT:
296                 /* Can only get here if wait above fails */
297         default:
298                 BUG();
299         }
300         spin_unlock_irqrestore(&cm_id_priv->lock, flags);
301
302         if (qp) {
303                 if (abrupt)
304                         ret = iwcm_modify_qp_err(qp);
305                 else
306                         ret = iwcm_modify_qp_sqd(qp);
307
308                 /*
309                  * If both sides are disconnecting the QP could
310                  * already be in ERR or SQD states
311                  */
312                 ret = 0;
313         }
314
315         return ret;
316 }
317 EXPORT_SYMBOL(iw_cm_disconnect);
318
319 /*
320  * CM_ID <-- DESTROYING
321  *
322  * Clean up all resources associated with the connection and release
323  * the initial reference taken by iw_create_cm_id.
324  */
325 static void destroy_cm_id(struct iw_cm_id *cm_id)
326 {
327         struct iwcm_id_private *cm_id_priv;
328         unsigned long flags;
329         int ret;
330
331         cm_id_priv = container_of(cm_id, struct iwcm_id_private, id);
332         /*
333          * Wait if we're currently in a connect or accept downcall. A
334          * listening endpoint should never block here.
335          */
336         wait_event(cm_id_priv->connect_wait,
337                    !test_bit(IWCM_F_CONNECT_WAIT, &cm_id_priv->flags));
338
339         spin_lock_irqsave(&cm_id_priv->lock, flags);
340         switch (cm_id_priv->state) {
341         case IW_CM_STATE_LISTEN:
342                 cm_id_priv->state = IW_CM_STATE_DESTROYING;
343                 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
344                 /* destroy the listening endpoint */
345                 ret = cm_id->device->iwcm->destroy_listen(cm_id);
346                 spin_lock_irqsave(&cm_id_priv->lock, flags);
347                 break;
348         case IW_CM_STATE_ESTABLISHED:
349                 cm_id_priv->state = IW_CM_STATE_DESTROYING;
350                 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
351                 /* Abrupt close of the connection */
352                 (void)iwcm_modify_qp_err(cm_id_priv->qp);
353                 spin_lock_irqsave(&cm_id_priv->lock, flags);
354                 break;
355         case IW_CM_STATE_IDLE:
356         case IW_CM_STATE_CLOSING:
357                 cm_id_priv->state = IW_CM_STATE_DESTROYING;
358                 break;
359         case IW_CM_STATE_CONN_RECV:
360                 /*
361                  * App called destroy before/without calling accept after
362                  * receiving connection request event notification or
363                  * returned non zero from the event callback function.
364                  * In either case, must tell the provider to reject.
365                  */
366                 cm_id_priv->state = IW_CM_STATE_DESTROYING;
367                 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
368                 cm_id->device->iwcm->reject(cm_id, NULL, 0);
369                 spin_lock_irqsave(&cm_id_priv->lock, flags);
370                 break;
371         case IW_CM_STATE_CONN_SENT:
372         case IW_CM_STATE_DESTROYING:
373         default:
374                 BUG();
375                 break;
376         }
377         if (cm_id_priv->qp) {
378                 cm_id_priv->id.device->iwcm->rem_ref(cm_id_priv->qp);
379                 cm_id_priv->qp = NULL;
380         }
381         spin_unlock_irqrestore(&cm_id_priv->lock, flags);
382
383         (void)iwcm_deref_id(cm_id_priv);
384 }
385
386 /*
387  * This function is only called by the application thread and cannot
388  * be called by the event thread. The function will wait for all
389  * references to be released on the cm_id and then kfree the cm_id
390  * object.
391  */
392 void iw_destroy_cm_id(struct iw_cm_id *cm_id)
393 {
394         struct iwcm_id_private *cm_id_priv;
395
396         cm_id_priv = container_of(cm_id, struct iwcm_id_private, id);
397         BUG_ON(test_bit(IWCM_F_CALLBACK_DESTROY, &cm_id_priv->flags));
398
399         destroy_cm_id(cm_id);
400
401         wait_for_completion(&cm_id_priv->destroy_comp);
402
403         free_cm_id(cm_id_priv);
404 }
405 EXPORT_SYMBOL(iw_destroy_cm_id);
406
407 /*
408  * CM_ID <-- LISTEN
409  *
410  * Start listening for connect requests. Generates one CONNECT_REQUEST
411  * event for each inbound connect request.
412  */
413 int iw_cm_listen(struct iw_cm_id *cm_id, int backlog)
414 {
415         struct iwcm_id_private *cm_id_priv;
416         unsigned long flags;
417         int ret;
418
419         cm_id_priv = container_of(cm_id, struct iwcm_id_private, id);
420
421         ret = alloc_work_entries(cm_id_priv, backlog);
422         if (ret)
423                 return ret;
424
425         spin_lock_irqsave(&cm_id_priv->lock, flags);
426         switch (cm_id_priv->state) {
427         case IW_CM_STATE_IDLE:
428                 cm_id_priv->state = IW_CM_STATE_LISTEN;
429                 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
430                 ret = cm_id->device->iwcm->create_listen(cm_id, backlog);
431                 if (ret)
432                         cm_id_priv->state = IW_CM_STATE_IDLE;
433                 spin_lock_irqsave(&cm_id_priv->lock, flags);
434                 break;
435         default:
436                 ret = -EINVAL;
437         }
438         spin_unlock_irqrestore(&cm_id_priv->lock, flags);
439
440         return ret;
441 }
442 EXPORT_SYMBOL(iw_cm_listen);
443
444 /*
445  * CM_ID <-- IDLE
446  *
447  * Rejects an inbound connection request. No events are generated.
448  */
449 int iw_cm_reject(struct iw_cm_id *cm_id,
450                  const void *private_data,
451                  u8 private_data_len)
452 {
453         struct iwcm_id_private *cm_id_priv;
454         unsigned long flags;
455         int ret;
456
457         cm_id_priv = container_of(cm_id, struct iwcm_id_private, id);
458         set_bit(IWCM_F_CONNECT_WAIT, &cm_id_priv->flags);
459
460         spin_lock_irqsave(&cm_id_priv->lock, flags);
461         if (cm_id_priv->state != IW_CM_STATE_CONN_RECV) {
462                 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
463                 clear_bit(IWCM_F_CONNECT_WAIT, &cm_id_priv->flags);
464                 wake_up_all(&cm_id_priv->connect_wait);
465                 return -EINVAL;
466         }
467         cm_id_priv->state = IW_CM_STATE_IDLE;
468         spin_unlock_irqrestore(&cm_id_priv->lock, flags);
469
470         ret = cm_id->device->iwcm->reject(cm_id, private_data,
471                                           private_data_len);
472
473         clear_bit(IWCM_F_CONNECT_WAIT, &cm_id_priv->flags);
474         wake_up_all(&cm_id_priv->connect_wait);
475
476         return ret;
477 }
478 EXPORT_SYMBOL(iw_cm_reject);
479
480 /*
481  * CM_ID <-- ESTABLISHED
482  *
483  * Accepts an inbound connection request and generates an ESTABLISHED
484  * event. Callers of iw_cm_disconnect and iw_destroy_cm_id will block
485  * until the ESTABLISHED event is received from the provider.
486  */
487 int iw_cm_accept(struct iw_cm_id *cm_id,
488                  struct iw_cm_conn_param *iw_param)
489 {
490         struct iwcm_id_private *cm_id_priv;
491         struct ib_qp *qp;
492         unsigned long flags;
493         int ret;
494
495         cm_id_priv = container_of(cm_id, struct iwcm_id_private, id);
496         set_bit(IWCM_F_CONNECT_WAIT, &cm_id_priv->flags);
497
498         spin_lock_irqsave(&cm_id_priv->lock, flags);
499         if (cm_id_priv->state != IW_CM_STATE_CONN_RECV) {
500                 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
501                 clear_bit(IWCM_F_CONNECT_WAIT, &cm_id_priv->flags);
502                 wake_up_all(&cm_id_priv->connect_wait);
503                 return -EINVAL;
504         }
505         /* Get the ib_qp given the QPN */
506         qp = cm_id->device->iwcm->get_qp(cm_id->device, iw_param->qpn);
507         if (!qp) {
508                 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
509                 return -EINVAL;
510         }
511         cm_id->device->iwcm->add_ref(qp);
512         cm_id_priv->qp = qp;
513         spin_unlock_irqrestore(&cm_id_priv->lock, flags);
514
515         ret = cm_id->device->iwcm->accept(cm_id, iw_param);
516         if (ret) {
517                 /* An error on accept precludes provider events */
518                 BUG_ON(cm_id_priv->state != IW_CM_STATE_CONN_RECV);
519                 cm_id_priv->state = IW_CM_STATE_IDLE;
520                 spin_lock_irqsave(&cm_id_priv->lock, flags);
521                 if (cm_id_priv->qp) {
522                         cm_id->device->iwcm->rem_ref(qp);
523                         cm_id_priv->qp = NULL;
524                 }
525                 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
526                 clear_bit(IWCM_F_CONNECT_WAIT, &cm_id_priv->flags);
527                 wake_up_all(&cm_id_priv->connect_wait);
528         }
529
530         return ret;
531 }
532 EXPORT_SYMBOL(iw_cm_accept);
533
534 /*
535  * Active Side: CM_ID <-- CONN_SENT
536  *
537  * If successful, results in the generation of a CONNECT_REPLY
538  * event. iw_cm_disconnect and iw_cm_destroy will block until the
539  * CONNECT_REPLY event is received from the provider.
540  */
541 int iw_cm_connect(struct iw_cm_id *cm_id, struct iw_cm_conn_param *iw_param)
542 {
543         struct iwcm_id_private *cm_id_priv;
544         int ret;
545         unsigned long flags;
546         struct ib_qp *qp;
547
548         cm_id_priv = container_of(cm_id, struct iwcm_id_private, id);
549
550         ret = alloc_work_entries(cm_id_priv, 4);
551         if (ret)
552                 return ret;
553
554         set_bit(IWCM_F_CONNECT_WAIT, &cm_id_priv->flags);
555         spin_lock_irqsave(&cm_id_priv->lock, flags);
556
557         if (cm_id_priv->state != IW_CM_STATE_IDLE) {
558                 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
559                 clear_bit(IWCM_F_CONNECT_WAIT, &cm_id_priv->flags);
560                 wake_up_all(&cm_id_priv->connect_wait);
561                 return -EINVAL;
562         }
563
564         /* Get the ib_qp given the QPN */
565         qp = cm_id->device->iwcm->get_qp(cm_id->device, iw_param->qpn);
566         if (!qp) {
567                 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
568                 return -EINVAL;
569         }
570         cm_id->device->iwcm->add_ref(qp);
571         cm_id_priv->qp = qp;
572         cm_id_priv->state = IW_CM_STATE_CONN_SENT;
573         spin_unlock_irqrestore(&cm_id_priv->lock, flags);
574
575         ret = cm_id->device->iwcm->connect(cm_id, iw_param);
576         if (ret) {
577                 spin_lock_irqsave(&cm_id_priv->lock, flags);
578                 if (cm_id_priv->qp) {
579                         cm_id->device->iwcm->rem_ref(qp);
580                         cm_id_priv->qp = NULL;
581                 }
582                 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
583                 BUG_ON(cm_id_priv->state != IW_CM_STATE_CONN_SENT);
584                 cm_id_priv->state = IW_CM_STATE_IDLE;
585                 clear_bit(IWCM_F_CONNECT_WAIT, &cm_id_priv->flags);
586                 wake_up_all(&cm_id_priv->connect_wait);
587         }
588
589         return ret;
590 }
591 EXPORT_SYMBOL(iw_cm_connect);
592
593 /*
594  * Passive Side: new CM_ID <-- CONN_RECV
595  *
596  * Handles an inbound connect request. The function creates a new
597  * iw_cm_id to represent the new connection and inherits the client
598  * callback function and other attributes from the listening parent.
599  *
600  * The work item contains a pointer to the listen_cm_id and the event. The
601  * listen_cm_id contains the client cm_handler, context and
602  * device. These are copied when the device is cloned. The event
603  * contains the new four tuple.
604  *
605  * An error on the child should not affect the parent, so this
606  * function does not return a value.
607  */
608 static void cm_conn_req_handler(struct iwcm_id_private *listen_id_priv,
609                                 struct iw_cm_event *iw_event)
610 {
611         unsigned long flags;
612         struct iw_cm_id *cm_id;
613         struct iwcm_id_private *cm_id_priv;
614         int ret;
615
616         /*
617          * The provider should never generate a connection request
618          * event with a bad status.
619          */
620         BUG_ON(iw_event->status);
621
622         /*
623          * We could be destroying the listening id. If so, ignore this
624          * upcall.
625          */
626         spin_lock_irqsave(&listen_id_priv->lock, flags);
627         if (listen_id_priv->state != IW_CM_STATE_LISTEN) {
628                 spin_unlock_irqrestore(&listen_id_priv->lock, flags);
629                 goto out;
630         }
631         spin_unlock_irqrestore(&listen_id_priv->lock, flags);
632
633         cm_id = iw_create_cm_id(listen_id_priv->id.device,
634                                 listen_id_priv->id.cm_handler,
635                                 listen_id_priv->id.context);
636         /* If the cm_id could not be created, ignore the request */
637         if (IS_ERR(cm_id))
638                 goto out;
639
640         cm_id->provider_data = iw_event->provider_data;
641         cm_id->local_addr = iw_event->local_addr;
642         cm_id->remote_addr = iw_event->remote_addr;
643
644         cm_id_priv = container_of(cm_id, struct iwcm_id_private, id);
645         cm_id_priv->state = IW_CM_STATE_CONN_RECV;
646
647         ret = alloc_work_entries(cm_id_priv, 3);
648         if (ret) {
649                 iw_cm_reject(cm_id, NULL, 0);
650                 iw_destroy_cm_id(cm_id);
651                 goto out;
652         }
653
654         /* Call the client CM handler */
655         ret = cm_id->cm_handler(cm_id, iw_event);
656         if (ret) {
657                 iw_cm_reject(cm_id, NULL, 0);
658                 set_bit(IWCM_F_CALLBACK_DESTROY, &cm_id_priv->flags);
659                 destroy_cm_id(cm_id);
660                 if (atomic_read(&cm_id_priv->refcount)==0)
661                         free_cm_id(cm_id_priv);
662         }
663
664 out:
665         if (iw_event->private_data_len)
666                 kfree(iw_event->private_data);
667 }
668
669 /*
670  * Passive Side: CM_ID <-- ESTABLISHED
671  *
672  * The provider generated an ESTABLISHED event which means that
673  * the MPA negotion has completed successfully and we are now in MPA
674  * FPDU mode.
675  *
676  * This event can only be received in the CONN_RECV state. If the
677  * remote peer closed, the ESTABLISHED event would be received followed
678  * by the CLOSE event. If the app closes, it will block until we wake
679  * it up after processing this event.
680  */
681 static int cm_conn_est_handler(struct iwcm_id_private *cm_id_priv,
682                                struct iw_cm_event *iw_event)
683 {
684         unsigned long flags;
685         int ret;
686
687         spin_lock_irqsave(&cm_id_priv->lock, flags);
688
689         /*
690          * We clear the CONNECT_WAIT bit here to allow the callback
691          * function to call iw_cm_disconnect. Calling iw_destroy_cm_id
692          * from a callback handler is not allowed.
693          */
694         clear_bit(IWCM_F_CONNECT_WAIT, &cm_id_priv->flags);
695         BUG_ON(cm_id_priv->state != IW_CM_STATE_CONN_RECV);
696         cm_id_priv->state = IW_CM_STATE_ESTABLISHED;
697         spin_unlock_irqrestore(&cm_id_priv->lock, flags);
698         ret = cm_id_priv->id.cm_handler(&cm_id_priv->id, iw_event);
699         wake_up_all(&cm_id_priv->connect_wait);
700
701         return ret;
702 }
703
704 /*
705  * Active Side: CM_ID <-- ESTABLISHED
706  *
707  * The app has called connect and is waiting for the established event to
708  * post it's requests to the server. This event will wake up anyone
709  * blocked in iw_cm_disconnect or iw_destroy_id.
710  */
711 static int cm_conn_rep_handler(struct iwcm_id_private *cm_id_priv,
712                                struct iw_cm_event *iw_event)
713 {
714         unsigned long flags;
715         int ret;
716
717         spin_lock_irqsave(&cm_id_priv->lock, flags);
718         /*
719          * Clear the connect wait bit so a callback function calling
720          * iw_cm_disconnect will not wait and deadlock this thread
721          */
722         clear_bit(IWCM_F_CONNECT_WAIT, &cm_id_priv->flags);
723         BUG_ON(cm_id_priv->state != IW_CM_STATE_CONN_SENT);
724         if (iw_event->status == IW_CM_EVENT_STATUS_ACCEPTED) {
725                 cm_id_priv->id.local_addr = iw_event->local_addr;
726                 cm_id_priv->id.remote_addr = iw_event->remote_addr;
727                 cm_id_priv->state = IW_CM_STATE_ESTABLISHED;
728         } else {
729                 /* REJECTED or RESET */
730                 cm_id_priv->id.device->iwcm->rem_ref(cm_id_priv->qp);
731                 cm_id_priv->qp = NULL;
732                 cm_id_priv->state = IW_CM_STATE_IDLE;
733         }
734         spin_unlock_irqrestore(&cm_id_priv->lock, flags);
735         ret = cm_id_priv->id.cm_handler(&cm_id_priv->id, iw_event);
736
737         if (iw_event->private_data_len)
738                 kfree(iw_event->private_data);
739
740         /* Wake up waiters on connect complete */
741         wake_up_all(&cm_id_priv->connect_wait);
742
743         return ret;
744 }
745
746 /*
747  * CM_ID <-- CLOSING
748  *
749  * If in the ESTABLISHED state, move to CLOSING.
750  */
751 static void cm_disconnect_handler(struct iwcm_id_private *cm_id_priv,
752                                   struct iw_cm_event *iw_event)
753 {
754         unsigned long flags;
755
756         spin_lock_irqsave(&cm_id_priv->lock, flags);
757         if (cm_id_priv->state == IW_CM_STATE_ESTABLISHED)
758                 cm_id_priv->state = IW_CM_STATE_CLOSING;
759         spin_unlock_irqrestore(&cm_id_priv->lock, flags);
760 }
761
762 /*
763  * CM_ID <-- IDLE
764  *
765  * If in the ESTBLISHED or CLOSING states, the QP will have have been
766  * moved by the provider to the ERR state. Disassociate the CM_ID from
767  * the QP,  move to IDLE, and remove the 'connected' reference.
768  *
769  * If in some other state, the cm_id was destroyed asynchronously.
770  * This is the last reference that will result in waking up
771  * the app thread blocked in iw_destroy_cm_id.
772  */
773 static int cm_close_handler(struct iwcm_id_private *cm_id_priv,
774                                   struct iw_cm_event *iw_event)
775 {
776         unsigned long flags;
777         int ret = 0;
778         spin_lock_irqsave(&cm_id_priv->lock, flags);
779
780         if (cm_id_priv->qp) {
781                 cm_id_priv->id.device->iwcm->rem_ref(cm_id_priv->qp);
782                 cm_id_priv->qp = NULL;
783         }
784         switch (cm_id_priv->state) {
785         case IW_CM_STATE_ESTABLISHED:
786         case IW_CM_STATE_CLOSING:
787                 cm_id_priv->state = IW_CM_STATE_IDLE;
788                 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
789                 ret = cm_id_priv->id.cm_handler(&cm_id_priv->id, iw_event);
790                 spin_lock_irqsave(&cm_id_priv->lock, flags);
791                 break;
792         case IW_CM_STATE_DESTROYING:
793                 break;
794         default:
795                 BUG();
796         }
797         spin_unlock_irqrestore(&cm_id_priv->lock, flags);
798
799         return ret;
800 }
801
802 static int process_event(struct iwcm_id_private *cm_id_priv,
803                          struct iw_cm_event *iw_event)
804 {
805         int ret = 0;
806
807         switch (iw_event->event) {
808         case IW_CM_EVENT_CONNECT_REQUEST:
809                 cm_conn_req_handler(cm_id_priv, iw_event);
810                 break;
811         case IW_CM_EVENT_CONNECT_REPLY:
812                 ret = cm_conn_rep_handler(cm_id_priv, iw_event);
813                 break;
814         case IW_CM_EVENT_ESTABLISHED:
815                 ret = cm_conn_est_handler(cm_id_priv, iw_event);
816                 break;
817         case IW_CM_EVENT_DISCONNECT:
818                 cm_disconnect_handler(cm_id_priv, iw_event);
819                 break;
820         case IW_CM_EVENT_CLOSE:
821                 ret = cm_close_handler(cm_id_priv, iw_event);
822                 break;
823         default:
824                 BUG();
825         }
826
827         return ret;
828 }
829
830 /*
831  * Process events on the work_list for the cm_id. If the callback
832  * function requests that the cm_id be deleted, a flag is set in the
833  * cm_id flags to indicate that when the last reference is
834  * removed, the cm_id is to be destroyed. This is necessary to
835  * distinguish between an object that will be destroyed by the app
836  * thread asleep on the destroy_comp list vs. an object destroyed
837  * here synchronously when the last reference is removed.
838  */
839 static void cm_work_handler(struct work_struct *_work)
840 {
841         struct iwcm_work *work = container_of(_work, struct iwcm_work, work);
842         struct iw_cm_event levent;
843         struct iwcm_id_private *cm_id_priv = work->cm_id;
844         unsigned long flags;
845         int empty;
846         int ret = 0;
847         int destroy_id;
848
849         spin_lock_irqsave(&cm_id_priv->lock, flags);
850         empty = list_empty(&cm_id_priv->work_list);
851         while (!empty) {
852                 work = list_entry(cm_id_priv->work_list.next,
853                                   struct iwcm_work, list);
854                 list_del_init(&work->list);
855                 empty = list_empty(&cm_id_priv->work_list);
856                 levent = work->event;
857                 put_work(work);
858                 spin_unlock_irqrestore(&cm_id_priv->lock, flags);
859
860                 ret = process_event(cm_id_priv, &levent);
861                 if (ret) {
862                         set_bit(IWCM_F_CALLBACK_DESTROY, &cm_id_priv->flags);
863                         destroy_cm_id(&cm_id_priv->id);
864                 }
865                 BUG_ON(atomic_read(&cm_id_priv->refcount)==0);
866                 destroy_id = test_bit(IWCM_F_CALLBACK_DESTROY, &cm_id_priv->flags);
867                 if (iwcm_deref_id(cm_id_priv)) {
868                         if (destroy_id) {
869                                 BUG_ON(!list_empty(&cm_id_priv->work_list));
870                                 free_cm_id(cm_id_priv);
871                         }
872                         return;
873                 }
874                 spin_lock_irqsave(&cm_id_priv->lock, flags);
875         }
876         spin_unlock_irqrestore(&cm_id_priv->lock, flags);
877 }
878
879 /*
880  * This function is called on interrupt context. Schedule events on
881  * the iwcm_wq thread to allow callback functions to downcall into
882  * the CM and/or block.  Events are queued to a per-CM_ID
883  * work_list. If this is the first event on the work_list, the work
884  * element is also queued on the iwcm_wq thread.
885  *
886  * Each event holds a reference on the cm_id. Until the last posted
887  * event has been delivered and processed, the cm_id cannot be
888  * deleted.
889  *
890  * Returns:
891  *            0 - the event was handled.
892  *      -ENOMEM - the event was not handled due to lack of resources.
893  */
894 static int cm_event_handler(struct iw_cm_id *cm_id,
895                              struct iw_cm_event *iw_event)
896 {
897         struct iwcm_work *work;
898         struct iwcm_id_private *cm_id_priv;
899         unsigned long flags;
900         int ret = 0;
901
902         cm_id_priv = container_of(cm_id, struct iwcm_id_private, id);
903
904         spin_lock_irqsave(&cm_id_priv->lock, flags);
905         work = get_work(cm_id_priv);
906         if (!work) {
907                 ret = -ENOMEM;
908                 goto out;
909         }
910
911         INIT_WORK(&work->work, cm_work_handler);
912         work->cm_id = cm_id_priv;
913         work->event = *iw_event;
914
915         if ((work->event.event == IW_CM_EVENT_CONNECT_REQUEST ||
916              work->event.event == IW_CM_EVENT_CONNECT_REPLY) &&
917             work->event.private_data_len) {
918                 ret = copy_private_data(&work->event);
919                 if (ret) {
920                         put_work(work);
921                         goto out;
922                 }
923         }
924
925         atomic_inc(&cm_id_priv->refcount);
926         if (list_empty(&cm_id_priv->work_list)) {
927                 list_add_tail(&work->list, &cm_id_priv->work_list);
928                 queue_work(iwcm_wq, &work->work);
929         } else
930                 list_add_tail(&work->list, &cm_id_priv->work_list);
931 out:
932         spin_unlock_irqrestore(&cm_id_priv->lock, flags);
933         return ret;
934 }
935
936 static int iwcm_init_qp_init_attr(struct iwcm_id_private *cm_id_priv,
937                                   struct ib_qp_attr *qp_attr,
938                                   int *qp_attr_mask)
939 {
940         unsigned long flags;
941         int ret;
942
943         spin_lock_irqsave(&cm_id_priv->lock, flags);
944         switch (cm_id_priv->state) {
945         case IW_CM_STATE_IDLE:
946         case IW_CM_STATE_CONN_SENT:
947         case IW_CM_STATE_CONN_RECV:
948         case IW_CM_STATE_ESTABLISHED:
949                 *qp_attr_mask = IB_QP_STATE | IB_QP_ACCESS_FLAGS;
950                 qp_attr->qp_access_flags = IB_ACCESS_REMOTE_WRITE|
951                                            IB_ACCESS_REMOTE_READ;
952                 ret = 0;
953                 break;
954         default:
955                 ret = -EINVAL;
956                 break;
957         }
958         spin_unlock_irqrestore(&cm_id_priv->lock, flags);
959         return ret;
960 }
961
962 static int iwcm_init_qp_rts_attr(struct iwcm_id_private *cm_id_priv,
963                                   struct ib_qp_attr *qp_attr,
964                                   int *qp_attr_mask)
965 {
966         unsigned long flags;
967         int ret;
968
969         spin_lock_irqsave(&cm_id_priv->lock, flags);
970         switch (cm_id_priv->state) {
971         case IW_CM_STATE_IDLE:
972         case IW_CM_STATE_CONN_SENT:
973         case IW_CM_STATE_CONN_RECV:
974         case IW_CM_STATE_ESTABLISHED:
975                 *qp_attr_mask = 0;
976                 ret = 0;
977                 break;
978         default:
979                 ret = -EINVAL;
980                 break;
981         }
982         spin_unlock_irqrestore(&cm_id_priv->lock, flags);
983         return ret;
984 }
985
986 int iw_cm_init_qp_attr(struct iw_cm_id *cm_id,
987                        struct ib_qp_attr *qp_attr,
988                        int *qp_attr_mask)
989 {
990         struct iwcm_id_private *cm_id_priv;
991         int ret;
992
993         cm_id_priv = container_of(cm_id, struct iwcm_id_private, id);
994         switch (qp_attr->qp_state) {
995         case IB_QPS_INIT:
996         case IB_QPS_RTR:
997                 ret = iwcm_init_qp_init_attr(cm_id_priv,
998                                              qp_attr, qp_attr_mask);
999                 break;
1000         case IB_QPS_RTS:
1001                 ret = iwcm_init_qp_rts_attr(cm_id_priv,
1002                                             qp_attr, qp_attr_mask);
1003                 break;
1004         default:
1005                 ret = -EINVAL;
1006                 break;
1007         }
1008         return ret;
1009 }
1010 EXPORT_SYMBOL(iw_cm_init_qp_attr);
1011
1012 static int __init iw_cm_init(void)
1013 {
1014         iwcm_wq = create_singlethread_workqueue("iw_cm_wq");
1015         if (!iwcm_wq)
1016                 return -ENOMEM;
1017
1018         return 0;
1019 }
1020
1021 static void __exit iw_cm_cleanup(void)
1022 {
1023         destroy_workqueue(iwcm_wq);
1024 }
1025
1026 module_init(iw_cm_init);
1027 module_exit(iw_cm_cleanup);