projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
WorkStruct: Pass the work_struct pointer instead of context data
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / infiniband / core / cma.c
CommitLineData
e51060f0
SH		 1/*
2 * Copyright (c) 2005 Voltaire Inc. All rights reserved.
3 * Copyright (c) 2002-2005, Network Appliance, Inc. All rights reserved.
4 * Copyright (c) 1999-2005, Mellanox Technologies, Inc. All rights reserved.
5 * Copyright (c) 2005-2006 Intel Corporation. All rights reserved.
6 *
7 * This Software is licensed under one of the following licenses:
8 *
9 * 1) under the terms of the "Common Public License 1.0" a copy of which is
10 * available from the Open Source Initiative, see
11 * http://www.opensource.org/licenses/cpl.php.
12 *
13 * 2) under the terms of the "The BSD License" a copy of which is
14 * available from the Open Source Initiative, see
15 * http://www.opensource.org/licenses/bsd-license.php.
16 *
17 * 3) under the terms of the "GNU General Public License (GPL) Version 2" a
18 * copy of which is available from the Open Source Initiative, see
19 * http://www.opensource.org/licenses/gpl-license.php.
20 *
21 * Licensee has the right to choose one of the above licenses.
22 *
23 * Redistributions of source code must retain the above copyright
24 * notice and one of the license notices.
25 *
26 * Redistributions in binary form must reproduce both the above copyright
27 * notice, one of the license notices in the documentation
28 * and/or other materials provided with the distribution.
29 *
30 */
31
32#include <linux/completion.h>
33#include <linux/in.h>
34#include <linux/in6.h>
35#include <linux/mutex.h>
36#include <linux/random.h>
37#include <linux/idr.h>
07ebafba 38#include <linux/inetdevice.h>
e51060f0
SH		 39
40#include <net/tcp.h>
41
42#include <rdma/rdma_cm.h>
43#include <rdma/rdma_cm_ib.h>
44#include <rdma/ib_cache.h>
45#include <rdma/ib_cm.h>
46#include <rdma/ib_sa.h>
07ebafba 47#include <rdma/iw_cm.h>
e51060f0
SH		 48
49MODULE_AUTHOR("Sean Hefty");
50MODULE_DESCRIPTION("Generic RDMA CM Agent");
51MODULE_LICENSE("Dual BSD/GPL");
52
53#define CMA_CM_RESPONSE_TIMEOUT 20
d5bb7599 54#define CMA_MAX_CM_RETRIES 15
e51060f0
SH		 55
56static void cma_add_one(struct ib_device *device);
57static void cma_remove_one(struct ib_device *device);
58
59static struct ib_client cma_client = {
60 .name = "cma",
61 .add = cma_add_one,
62 .remove = cma_remove_one
63};
64
c1a0b23b 65static struct ib_sa_client sa_client;
7a118df3 66static struct rdma_addr_client addr_client;
e51060f0
SH		 67static LIST_HEAD(dev_list);
68static LIST_HEAD(listen_any_list);
69static DEFINE_MUTEX(lock);
70static struct workqueue_struct *cma_wq;
71static DEFINE_IDR(sdp_ps);
72static DEFINE_IDR(tcp_ps);
73
74struct cma_device {
75 struct list_head list;
76 struct ib_device *device;
77 __be64 node_guid;
78 struct completion comp;
79 atomic_t refcount;
80 struct list_head id_list;
81};
82
83enum cma_state {
84 CMA_IDLE,
85 CMA_ADDR_QUERY,
86 CMA_ADDR_RESOLVED,
87 CMA_ROUTE_QUERY,
88 CMA_ROUTE_RESOLVED,
89 CMA_CONNECT,
90 CMA_DISCONNECT,
91 CMA_ADDR_BOUND,
92 CMA_LISTEN,
93 CMA_DEVICE_REMOVAL,
94 CMA_DESTROYING
95};
96
97struct rdma_bind_list {
98 struct idr *ps;
99 struct hlist_head owners;
100 unsigned short port;
101};
102
103/*
104 * Device removal can occur at anytime, so we need extra handling to
105 * serialize notifying the user of device removal with other callbacks.
106 * We do this by disabling removal notification while a callback is in process,
107 * and reporting it after the callback completes.
108 */
109struct rdma_id_private {
110 struct rdma_cm_id id;
111
112 struct rdma_bind_list *bind_list;
113 struct hlist_node node;
114 struct list_head list;
115 struct list_head listen_list;
116 struct cma_device *cma_dev;
117
118 enum cma_state state;
119 spinlock_t lock;
120 struct completion comp;
121 atomic_t refcount;
122 wait_queue_head_t wait_remove;
123 atomic_t dev_remove;
124
125 int backlog;
126 int timeout_ms;
127 struct ib_sa_query *query;
128 int query_id;
129 union {
130 struct ib_cm_id *ib;
07ebafba 131 struct iw_cm_id *iw;
e51060f0
SH		 132 } cm_id;
133
134 u32 seq_num;
135 u32 qp_num;
136 enum ib_qp_type qp_type;
137 u8 srq;
138};
139
140struct cma_work {
141 struct work_struct work;
142 struct rdma_id_private *id;
143 enum cma_state old_state;
144 enum cma_state new_state;
145 struct rdma_cm_event event;
146};
147
148union cma_ip_addr {
149 struct in6_addr ip6;
150 struct {
151 __u32 pad[3];
152 __u32 addr;
153 } ip4;
154};
155
156struct cma_hdr {
157 u8 cma_version;
158 u8 ip_version; /* IP version: 7:4 */
159 __u16 port;
160 union cma_ip_addr src_addr;
161 union cma_ip_addr dst_addr;
162};
163
164struct sdp_hh {
165 u8 bsdh[16];
166 u8 sdp_version; /* Major version: 7:4 */
167 u8 ip_version; /* IP version: 7:4 */
168 u8 sdp_specific1[10];
169 __u16 port;
170 __u16 sdp_specific2;
171 union cma_ip_addr src_addr;
172 union cma_ip_addr dst_addr;
173};
174
175struct sdp_hah {
176 u8 bsdh[16];
177 u8 sdp_version;
178};
179
180#define CMA_VERSION 0x00
181#define SDP_MAJ_VERSION 0x2
182
183static int cma_comp(struct rdma_id_private *id_priv, enum cma_state comp)
184{
185 unsigned long flags;
186 int ret;
187
188 spin_lock_irqsave(&id_priv->lock, flags);
189 ret = (id_priv->state == comp);
190 spin_unlock_irqrestore(&id_priv->lock, flags);
191 return ret;
192}
193
194static int cma_comp_exch(struct rdma_id_private *id_priv,
195 enum cma_state comp, enum cma_state exch)
196{
197 unsigned long flags;
198 int ret;
199
200 spin_lock_irqsave(&id_priv->lock, flags);
201 if ((ret = (id_priv->state == comp)))
202 id_priv->state = exch;
203 spin_unlock_irqrestore(&id_priv->lock, flags);
204 return ret;
205}
206
207static enum cma_state cma_exch(struct rdma_id_private *id_priv,
208 enum cma_state exch)
209{
210 unsigned long flags;
211 enum cma_state old;
212
213 spin_lock_irqsave(&id_priv->lock, flags);
214 old = id_priv->state;
215 id_priv->state = exch;
216 spin_unlock_irqrestore(&id_priv->lock, flags);
217 return old;
218}
219
220static inline u8 cma_get_ip_ver(struct cma_hdr *hdr)
221{
222 return hdr->ip_version >> 4;
223}
224
225static inline void cma_set_ip_ver(struct cma_hdr *hdr, u8 ip_ver)
226{
227 hdr->ip_version = (ip_ver << 4) | (hdr->ip_version & 0xF);
228}
229
230static inline u8 sdp_get_majv(u8 sdp_version)
231{
232 return sdp_version >> 4;
233}
234
235static inline u8 sdp_get_ip_ver(struct sdp_hh *hh)
236{
237 return hh->ip_version >> 4;
238}
239
240static inline void sdp_set_ip_ver(struct sdp_hh *hh, u8 ip_ver)
241{
242 hh->ip_version = (ip_ver << 4) | (hh->ip_version & 0xF);
243}
244
245static void cma_attach_to_dev(struct rdma_id_private *id_priv,
246 struct cma_device *cma_dev)
247{
248 atomic_inc(&cma_dev->refcount);
249 id_priv->cma_dev = cma_dev;
250 id_priv->id.device = cma_dev->device;
251 list_add_tail(&id_priv->list, &cma_dev->id_list);
252}
253
254static inline void cma_deref_dev(struct cma_device *cma_dev)
255{
256 if (atomic_dec_and_test(&cma_dev->refcount))
257 complete(&cma_dev->comp);
258}
259
260static void cma_detach_from_dev(struct rdma_id_private *id_priv)
261{
262 list_del(&id_priv->list);
263 cma_deref_dev(id_priv->cma_dev);
264 id_priv->cma_dev = NULL;
265}
266
07ebafba 267static int cma_acquire_dev(struct rdma_id_private *id_priv)
e51060f0 268{
07ebafba 269 enum rdma_node_type dev_type = id_priv->id.route.addr.dev_addr.dev_type;
e51060f0 270 struct cma_device *cma_dev;
f0ee3404 271 union ib_gid gid;
e51060f0
SH		 272 int ret = -ENODEV;
273
07ebafba
TT		 274 switch (rdma_node_get_transport(dev_type)) {
275 case RDMA_TRANSPORT_IB:
276 ib_addr_get_sgid(&id_priv->id.route.addr.dev_addr, &gid);
277 break;
278 case RDMA_TRANSPORT_IWARP:
279 iw_addr_get_sgid(&id_priv->id.route.addr.dev_addr, &gid);
280 break;
281 default:
282 return -ENODEV;
283 }
61a73c70 284
e51060f0 285 list_for_each_entry(cma_dev, &dev_list, list) {
f0ee3404 286 ret = ib_find_cached_gid(cma_dev->device, &gid,
e51060f0
SH		 287 &id_priv->id.port_num, NULL);
288 if (!ret) {
289 cma_attach_to_dev(id_priv, cma_dev);
290 break;
291 }
292 }
e51060f0
SH		 293 return ret;
294}
295
e51060f0
SH		 296static void cma_deref_id(struct rdma_id_private *id_priv)
297{
298 if (atomic_dec_and_test(&id_priv->refcount))
299 complete(&id_priv->comp);
300}
301
302static void cma_release_remove(struct rdma_id_private *id_priv)
303{
304 if (atomic_dec_and_test(&id_priv->dev_remove))
305 wake_up(&id_priv->wait_remove);
306}
307
308struct rdma_cm_id *rdma_create_id(rdma_cm_event_handler event_handler,
309 void *context, enum rdma_port_space ps)
310{
311 struct rdma_id_private *id_priv;
312
313 id_priv = kzalloc(sizeof *id_priv, GFP_KERNEL);
314 if (!id_priv)
315 return ERR_PTR(-ENOMEM);
316
317 id_priv->state = CMA_IDLE;
318 id_priv->id.context = context;
319 id_priv->id.event_handler = event_handler;
320 id_priv->id.ps = ps;
321 spin_lock_init(&id_priv->lock);
322 init_completion(&id_priv->comp);
323 atomic_set(&id_priv->refcount, 1);
324 init_waitqueue_head(&id_priv->wait_remove);
325 atomic_set(&id_priv->dev_remove, 0);
326 INIT_LIST_HEAD(&id_priv->listen_list);
327 get_random_bytes(&id_priv->seq_num, sizeof id_priv->seq_num);
328
329 return &id_priv->id;
330}
331EXPORT_SYMBOL(rdma_create_id);
332
333static int cma_init_ib_qp(struct rdma_id_private *id_priv, struct ib_qp *qp)
334{
335 struct ib_qp_attr qp_attr;
336 struct rdma_dev_addr *dev_addr;
337 int ret;
338
339 dev_addr = &id_priv->id.route.addr.dev_addr;
340 ret = ib_find_cached_pkey(id_priv->id.device, id_priv->id.port_num,
341 ib_addr_get_pkey(dev_addr),
342 &qp_attr.pkey_index);
343 if (ret)
344 return ret;
345
346 qp_attr.qp_state = IB_QPS_INIT;
347 qp_attr.qp_access_flags = IB_ACCESS_LOCAL_WRITE;
348 qp_attr.port_num = id_priv->id.port_num;
349 return ib_modify_qp(qp, &qp_attr, IB_QP_STATE | IB_QP_ACCESS_FLAGS |
350 IB_QP_PKEY_INDEX | IB_QP_PORT);
351}
352
07ebafba
TT		 353static int cma_init_iw_qp(struct rdma_id_private *id_priv, struct ib_qp *qp)
354{
355 struct ib_qp_attr qp_attr;
356
357 qp_attr.qp_state = IB_QPS_INIT;
358 qp_attr.qp_access_flags = IB_ACCESS_LOCAL_WRITE;
359
360 return ib_modify_qp(qp, &qp_attr, IB_QP_STATE | IB_QP_ACCESS_FLAGS);
361}
362
e51060f0
SH		 363int rdma_create_qp(struct rdma_cm_id *id, struct ib_pd *pd,
364 struct ib_qp_init_attr *qp_init_attr)
365{
366 struct rdma_id_private *id_priv;
367 struct ib_qp *qp;
368 int ret;
369
370 id_priv = container_of(id, struct rdma_id_private, id);
371 if (id->device != pd->device)
372 return -EINVAL;
373
374 qp = ib_create_qp(pd, qp_init_attr);
375 if (IS_ERR(qp))
376 return PTR_ERR(qp);
377
07ebafba
TT		 378 switch (rdma_node_get_transport(id->device->node_type)) {
379 case RDMA_TRANSPORT_IB:
e51060f0
SH		 380 ret = cma_init_ib_qp(id_priv, qp);
381 break;
07ebafba
TT		 382 case RDMA_TRANSPORT_IWARP:
383 ret = cma_init_iw_qp(id_priv, qp);
384 break;
e51060f0
SH		 385 default:
386 ret = -ENOSYS;
387 break;
388 }
389
390 if (ret)
391 goto err;
392
393 id->qp = qp;
394 id_priv->qp_num = qp->qp_num;
395 id_priv->qp_type = qp->qp_type;
396 id_priv->srq = (qp->srq != NULL);
397 return 0;
398err:
399 ib_destroy_qp(qp);
400 return ret;
401}
402EXPORT_SYMBOL(rdma_create_qp);
403
404void rdma_destroy_qp(struct rdma_cm_id *id)
405{
406 ib_destroy_qp(id->qp);
407}
408EXPORT_SYMBOL(rdma_destroy_qp);
409
410static int cma_modify_qp_rtr(struct rdma_cm_id *id)
411{
412 struct ib_qp_attr qp_attr;
413 int qp_attr_mask, ret;
414
415 if (!id->qp)
416 return 0;
417
418 /* Need to update QP attributes from default values. */
419 qp_attr.qp_state = IB_QPS_INIT;
420 ret = rdma_init_qp_attr(id, &qp_attr, &qp_attr_mask);
421 if (ret)
422 return ret;
423
424 ret = ib_modify_qp(id->qp, &qp_attr, qp_attr_mask);
425 if (ret)
426 return ret;
427
428 qp_attr.qp_state = IB_QPS_RTR;
429 ret = rdma_init_qp_attr(id, &qp_attr, &qp_attr_mask);
430 if (ret)
431 return ret;
432
433 return ib_modify_qp(id->qp, &qp_attr, qp_attr_mask);
434}
435
436static int cma_modify_qp_rts(struct rdma_cm_id *id)
437{
438 struct ib_qp_attr qp_attr;
439 int qp_attr_mask, ret;
440
441 if (!id->qp)
442 return 0;
443
444 qp_attr.qp_state = IB_QPS_RTS;
445 ret = rdma_init_qp_attr(id, &qp_attr, &qp_attr_mask);
446 if (ret)
447 return ret;
448
449 return ib_modify_qp(id->qp, &qp_attr, qp_attr_mask);
450}
451
452static int cma_modify_qp_err(struct rdma_cm_id *id)
453{
454 struct ib_qp_attr qp_attr;
455
456 if (!id->qp)
457 return 0;
458
459 qp_attr.qp_state = IB_QPS_ERR;
460 return ib_modify_qp(id->qp, &qp_attr, IB_QP_STATE);
461}
462
463int rdma_init_qp_attr(struct rdma_cm_id *id, struct ib_qp_attr *qp_attr,
464 int *qp_attr_mask)
465{
466 struct rdma_id_private *id_priv;
467 int ret;
468
469 id_priv = container_of(id, struct rdma_id_private, id);
07ebafba
TT		 470 switch (rdma_node_get_transport(id_priv->id.device->node_type)) {
471 case RDMA_TRANSPORT_IB:
e51060f0
SH		 472 ret = ib_cm_init_qp_attr(id_priv->cm_id.ib, qp_attr,
473 qp_attr_mask);
474 if (qp_attr->qp_state == IB_QPS_RTR)
475 qp_attr->rq_psn = id_priv->seq_num;
476 break;
07ebafba
TT		 477 case RDMA_TRANSPORT_IWARP:
478 ret = iw_cm_init_qp_attr(id_priv->cm_id.iw, qp_attr,
479 qp_attr_mask);
480 break;
e51060f0
SH		 481 default:
482 ret = -ENOSYS;
483 break;
484 }
485
486 return ret;
487}
488EXPORT_SYMBOL(rdma_init_qp_attr);
489
490static inline int cma_zero_addr(struct sockaddr *addr)
491{
492 struct in6_addr *ip6;
493
494 if (addr->sa_family == AF_INET)
495 return ZERONET(((struct sockaddr_in *) addr)->sin_addr.s_addr);
496 else {
497 ip6 = &((struct sockaddr_in6 *) addr)->sin6_addr;
498 return (ip6->s6_addr32[0] | ip6->s6_addr32[1] |
5fd571cb 499 ip6->s6_addr32[2] | ip6->s6_addr32[3]) == 0;
e51060f0
SH		 500 }
501}
502
503static inline int cma_loopback_addr(struct sockaddr *addr)
504{
505 return LOOPBACK(((struct sockaddr_in *) addr)->sin_addr.s_addr);
506}
507
508static inline int cma_any_addr(struct sockaddr *addr)
509{
510 return cma_zero_addr(addr) || cma_loopback_addr(addr);
511}
512
513static inline int cma_any_port(struct sockaddr *addr)
514{
515 return !((struct sockaddr_in *) addr)->sin_port;
516}
517
518static int cma_get_net_info(void *hdr, enum rdma_port_space ps,
519 u8 *ip_ver, __u16 *port,
520 union cma_ip_addr **src, union cma_ip_addr **dst)
521{
522 switch (ps) {
523 case RDMA_PS_SDP:
524 if (sdp_get_majv(((struct sdp_hh *) hdr)->sdp_version) !=
525 SDP_MAJ_VERSION)
526 return -EINVAL;
527
528 *ip_ver = sdp_get_ip_ver(hdr);
529 *port = ((struct sdp_hh *) hdr)->port;
530 *src = &((struct sdp_hh *) hdr)->src_addr;
531 *dst = &((struct sdp_hh *) hdr)->dst_addr;
532 break;
533 default:
534 if (((struct cma_hdr *) hdr)->cma_version != CMA_VERSION)
535 return -EINVAL;
536
537 *ip_ver = cma_get_ip_ver(hdr);
538 *port = ((struct cma_hdr *) hdr)->port;
539 *src = &((struct cma_hdr *) hdr)->src_addr;
540 *dst = &((struct cma_hdr *) hdr)->dst_addr;
541 break;
542 }
543
544 if (*ip_ver != 4 && *ip_ver != 6)
545 return -EINVAL;
546 return 0;
547}
548
549static void cma_save_net_info(struct rdma_addr *addr,
550 struct rdma_addr *listen_addr,
551 u8 ip_ver, __u16 port,
552 union cma_ip_addr *src, union cma_ip_addr *dst)
553{
554 struct sockaddr_in *listen4, *ip4;
555 struct sockaddr_in6 *listen6, *ip6;
556
557 switch (ip_ver) {
558 case 4:
559 listen4 = (struct sockaddr_in *) &listen_addr->src_addr;
560 ip4 = (struct sockaddr_in *) &addr->src_addr;
561 ip4->sin_family = listen4->sin_family;
562 ip4->sin_addr.s_addr = dst->ip4.addr;
563 ip4->sin_port = listen4->sin_port;
564
565 ip4 = (struct sockaddr_in *) &addr->dst_addr;
566 ip4->sin_family = listen4->sin_family;
567 ip4->sin_addr.s_addr = src->ip4.addr;
568 ip4->sin_port = port;
569 break;
570 case 6:
571 listen6 = (struct sockaddr_in6 *) &listen_addr->src_addr;
572 ip6 = (struct sockaddr_in6 *) &addr->src_addr;
573 ip6->sin6_family = listen6->sin6_family;
574 ip6->sin6_addr = dst->ip6;
575 ip6->sin6_port = listen6->sin6_port;
576
577 ip6 = (struct sockaddr_in6 *) &addr->dst_addr;
578 ip6->sin6_family = listen6->sin6_family;
579 ip6->sin6_addr = src->ip6;
580 ip6->sin6_port = port;
581 break;
582 default:
583 break;
584 }
585}
586
587static inline int cma_user_data_offset(enum rdma_port_space ps)
588{
589 switch (ps) {
590 case RDMA_PS_SDP:
591 return 0;
592 default:
593 return sizeof(struct cma_hdr);
594 }
595}
596
597static int cma_notify_user(struct rdma_id_private *id_priv,
598 enum rdma_cm_event_type type, int status,
599 void *data, u8 data_len)
600{
601 struct rdma_cm_event event;
602
603 event.event = type;
604 event.status = status;
605 event.private_data = data;
606 event.private_data_len = data_len;
607
608 return id_priv->id.event_handler(&id_priv->id, &event);
609}
610
611static void cma_cancel_route(struct rdma_id_private *id_priv)
612{
07ebafba
TT		 613 switch (rdma_node_get_transport(id_priv->id.device->node_type)) {
614 case RDMA_TRANSPORT_IB:
e51060f0
SH		 615 if (id_priv->query)
616 ib_sa_cancel_query(id_priv->query_id, id_priv->query);
617 break;
618 default:
619 break;
620 }
621}
622
623static inline int cma_internal_listen(struct rdma_id_private *id_priv)
624{
625 return (id_priv->state == CMA_LISTEN) && id_priv->cma_dev &&
626 cma_any_addr(&id_priv->id.route.addr.src_addr);
627}
628
629static void cma_destroy_listen(struct rdma_id_private *id_priv)
630{
631 cma_exch(id_priv, CMA_DESTROYING);
632
633 if (id_priv->cma_dev) {
07ebafba
TT		 634 switch (rdma_node_get_transport(id_priv->id.device->node_type)) {
635 case RDMA_TRANSPORT_IB:
3cd96564 636 if (id_priv->cm_id.ib && !IS_ERR(id_priv->cm_id.ib))
e51060f0
SH		 637 ib_destroy_cm_id(id_priv->cm_id.ib);
638 break;
07ebafba
TT		 639 case RDMA_TRANSPORT_IWARP:
640 if (id_priv->cm_id.iw && !IS_ERR(id_priv->cm_id.iw))
641 iw_destroy_cm_id(id_priv->cm_id.iw);
642 break;
e51060f0
SH		 643 default:
644 break;
645 }
646 cma_detach_from_dev(id_priv);
647 }
648 list_del(&id_priv->listen_list);
649
650 cma_deref_id(id_priv);
651 wait_for_completion(&id_priv->comp);
652
653 kfree(id_priv);
654}
655
656static void cma_cancel_listens(struct rdma_id_private *id_priv)
657{
658 struct rdma_id_private *dev_id_priv;
659
660 mutex_lock(&lock);
661 list_del(&id_priv->list);
662
663 while (!list_empty(&id_priv->listen_list)) {
664 dev_id_priv = list_entry(id_priv->listen_list.next,
665 struct rdma_id_private, listen_list);
666 cma_destroy_listen(dev_id_priv);
667 }
668 mutex_unlock(&lock);
669}
670
671static void cma_cancel_operation(struct rdma_id_private *id_priv,
672 enum cma_state state)
673{
674 switch (state) {
675 case CMA_ADDR_QUERY:
676 rdma_addr_cancel(&id_priv->id.route.addr.dev_addr);
677 break;
678 case CMA_ROUTE_QUERY:
679 cma_cancel_route(id_priv);
680 break;
681 case CMA_LISTEN:
682 if (cma_any_addr(&id_priv->id.route.addr.src_addr) &&
683 !id_priv->cma_dev)
684 cma_cancel_listens(id_priv);
685 break;
686 default:
687 break;
688 }
689}
690
691static void cma_release_port(struct rdma_id_private *id_priv)
692{
693 struct rdma_bind_list *bind_list = id_priv->bind_list;
694
695 if (!bind_list)
696 return;
697
698 mutex_lock(&lock);
699 hlist_del(&id_priv->node);
700 if (hlist_empty(&bind_list->owners)) {
701 idr_remove(bind_list->ps, bind_list->port);
702 kfree(bind_list);
703 }
704 mutex_unlock(&lock);
705}
706
707void rdma_destroy_id(struct rdma_cm_id *id)
708{
709 struct rdma_id_private *id_priv;
710 enum cma_state state;
711
712 id_priv = container_of(id, struct rdma_id_private, id);
713 state = cma_exch(id_priv, CMA_DESTROYING);
714 cma_cancel_operation(id_priv, state);
715
61a73c70 716 mutex_lock(&lock);
e51060f0 717 if (id_priv->cma_dev) {
61a73c70 718 mutex_unlock(&lock);
07ebafba
TT		 719 switch (rdma_node_get_transport(id->device->node_type)) {
720 case RDMA_TRANSPORT_IB:
3cd96564 721 if (id_priv->cm_id.ib && !IS_ERR(id_priv->cm_id.ib))
e51060f0
SH		 722 ib_destroy_cm_id(id_priv->cm_id.ib);
723 break;
07ebafba
TT		 724 case RDMA_TRANSPORT_IWARP:
725 if (id_priv->cm_id.iw && !IS_ERR(id_priv->cm_id.iw))
726 iw_destroy_cm_id(id_priv->cm_id.iw);
727 break;
e51060f0
SH		 728 default:
729 break;
730 }
3cd96564 731 mutex_lock(&lock);
e51060f0 732 cma_detach_from_dev(id_priv);
e51060f0 733 }
61a73c70 734 mutex_unlock(&lock);
e51060f0
SH		 735
736 cma_release_port(id_priv);
737 cma_deref_id(id_priv);
738 wait_for_completion(&id_priv->comp);
739
740 kfree(id_priv->id.route.path_rec);
741 kfree(id_priv);
742}
743EXPORT_SYMBOL(rdma_destroy_id);
744
745static int cma_rep_recv(struct rdma_id_private *id_priv)
746{
747 int ret;
748
749 ret = cma_modify_qp_rtr(&id_priv->id);
750 if (ret)
751 goto reject;
752
753 ret = cma_modify_qp_rts(&id_priv->id);
754 if (ret)
755 goto reject;
756
757 ret = ib_send_cm_rtu(id_priv->cm_id.ib, NULL, 0);
758 if (ret)
759 goto reject;
760
761 return 0;
762reject:
763 cma_modify_qp_err(&id_priv->id);
764 ib_send_cm_rej(id_priv->cm_id.ib, IB_CM_REJ_CONSUMER_DEFINED,
765 NULL, 0, NULL, 0);
766 return ret;
767}
768
769static int cma_verify_rep(struct rdma_id_private *id_priv, void *data)
770{
771 if (id_priv->id.ps == RDMA_PS_SDP &&
772 sdp_get_majv(((struct sdp_hah *) data)->sdp_version) !=
773 SDP_MAJ_VERSION)
774 return -EINVAL;
775
776 return 0;
777}
778
779static int cma_rtu_recv(struct rdma_id_private *id_priv)
780{
781 int ret;
782
783 ret = cma_modify_qp_rts(&id_priv->id);
784 if (ret)
785 goto reject;
786
787 return 0;
788reject:
789 cma_modify_qp_err(&id_priv->id);
790 ib_send_cm_rej(id_priv->cm_id.ib, IB_CM_REJ_CONSUMER_DEFINED,
791 NULL, 0, NULL, 0);
792 return ret;
793}
794
795static int cma_ib_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event)
796{
797 struct rdma_id_private *id_priv = cm_id->context;
798 enum rdma_cm_event_type event;
799 u8 private_data_len = 0;
800 int ret = 0, status = 0;
801
802 atomic_inc(&id_priv->dev_remove);
803 if (!cma_comp(id_priv, CMA_CONNECT))
804 goto out;
805
806 switch (ib_event->event) {
807 case IB_CM_REQ_ERROR:
808 case IB_CM_REP_ERROR:
809 event = RDMA_CM_EVENT_UNREACHABLE;
810 status = -ETIMEDOUT;
811 break;
812 case IB_CM_REP_RECEIVED:
813 status = cma_verify_rep(id_priv, ib_event->private_data);
814 if (status)
815 event = RDMA_CM_EVENT_CONNECT_ERROR;
816 else if (id_priv->id.qp && id_priv->id.ps != RDMA_PS_SDP) {
817 status = cma_rep_recv(id_priv);
818 event = status ? RDMA_CM_EVENT_CONNECT_ERROR :
819 RDMA_CM_EVENT_ESTABLISHED;
820 } else
821 event = RDMA_CM_EVENT_CONNECT_RESPONSE;
822 private_data_len = IB_CM_REP_PRIVATE_DATA_SIZE;
823 break;
824 case IB_CM_RTU_RECEIVED:
825 status = cma_rtu_recv(id_priv);
826 event = status ? RDMA_CM_EVENT_CONNECT_ERROR :
827 RDMA_CM_EVENT_ESTABLISHED;
828 break;
829 case IB_CM_DREQ_ERROR:
830 status = -ETIMEDOUT; /* fall through */
831 case IB_CM_DREQ_RECEIVED:
832 case IB_CM_DREP_RECEIVED:
833 if (!cma_comp_exch(id_priv, CMA_CONNECT, CMA_DISCONNECT))
834 goto out;
835 event = RDMA_CM_EVENT_DISCONNECTED;
836 break;
837 case IB_CM_TIMEWAIT_EXIT:
838 case IB_CM_MRA_RECEIVED:
839 /* ignore event */
840 goto out;
841 case IB_CM_REJ_RECEIVED:
842 cma_modify_qp_err(&id_priv->id);
843 status = ib_event->param.rej_rcvd.reason;
844 event = RDMA_CM_EVENT_REJECTED;
74f76fba 845 private_data_len = IB_CM_REJ_PRIVATE_DATA_SIZE;
e51060f0
SH		 846 break;
847 default:
848 printk(KERN_ERR "RDMA CMA: unexpected IB CM event: %d",
849 ib_event->event);
850 goto out;
851 }
852
853 ret = cma_notify_user(id_priv, event, status, ib_event->private_data,
854 private_data_len);
855 if (ret) {
856 /* Destroy the CM ID by returning a non-zero value. */
857 id_priv->cm_id.ib = NULL;
858 cma_exch(id_priv, CMA_DESTROYING);
859 cma_release_remove(id_priv);
860 rdma_destroy_id(&id_priv->id);
861 return ret;
862 }
863out:
864 cma_release_remove(id_priv);
865 return ret;
866}
867
868static struct rdma_id_private *cma_new_id(struct rdma_cm_id *listen_id,
869 struct ib_cm_event *ib_event)
870{
871 struct rdma_id_private *id_priv;
872 struct rdma_cm_id *id;
873 struct rdma_route *rt;
874 union cma_ip_addr *src, *dst;
875 __u16 port;
876 u8 ip_ver;
877
3f168d2b
KK		 878 if (cma_get_net_info(ib_event->private_data, listen_id->ps,
879 &ip_ver, &port, &src, &dst))
880 goto err;
881
e51060f0
SH		 882 id = rdma_create_id(listen_id->event_handler, listen_id->context,
883 listen_id->ps);
884 if (IS_ERR(id))
3f168d2b
KK		 885 goto err;
886
887 cma_save_net_info(&id->route.addr, &listen_id->route.addr,
888 ip_ver, port, src, dst);
e51060f0
SH		 889
890 rt = &id->route;
891 rt->num_paths = ib_event->param.req_rcvd.alternate_path ? 2 : 1;
3f168d2b
KK		 892 rt->path_rec = kmalloc(sizeof *rt->path_rec * rt->num_paths,
893 GFP_KERNEL);
e51060f0 894 if (!rt->path_rec)
3f168d2b 895 goto destroy_id;
e51060f0 896
e51060f0
SH		 897 rt->path_rec[0] = *ib_event->param.req_rcvd.primary_path;
898 if (rt->num_paths == 2)
899 rt->path_rec[1] = *ib_event->param.req_rcvd.alternate_path;
900
901 ib_addr_set_sgid(&rt->addr.dev_addr, &rt->path_rec[0].sgid);
902 ib_addr_set_dgid(&rt->addr.dev_addr, &rt->path_rec[0].dgid);
903 ib_addr_set_pkey(&rt->addr.dev_addr, be16_to_cpu(rt->path_rec[0].pkey));
07ebafba 904 rt->addr.dev_addr.dev_type = RDMA_NODE_IB_CA;
e51060f0
SH		 905
906 id_priv = container_of(id, struct rdma_id_private, id);
907 id_priv->state = CMA_CONNECT;
908 return id_priv;
3f168d2b
KK		 909
910destroy_id:
e51060f0 911 rdma_destroy_id(id);
3f168d2b 912err:
e51060f0
SH		 913 return NULL;
914}
915
916static int cma_req_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event)
917{
918 struct rdma_id_private *listen_id, *conn_id;
919 int offset, ret;
920
921 listen_id = cm_id->context;
922 atomic_inc(&listen_id->dev_remove);
923 if (!cma_comp(listen_id, CMA_LISTEN)) {
924 ret = -ECONNABORTED;
925 goto out;
926 }
927
928 conn_id = cma_new_id(&listen_id->id, ib_event);
929 if (!conn_id) {
930 ret = -ENOMEM;
931 goto out;
932 }
933
934 atomic_inc(&conn_id->dev_remove);
61a73c70 935 mutex_lock(&lock);
07ebafba 936 ret = cma_acquire_dev(conn_id);
61a73c70 937 mutex_unlock(&lock);
e51060f0
SH		 938 if (ret) {
939 ret = -ENODEV;
6e35aabe 940 cma_exch(conn_id, CMA_DESTROYING);
e51060f0
SH		 941 cma_release_remove(conn_id);
942 rdma_destroy_id(&conn_id->id);
943 goto out;
944 }
945
946 conn_id->cm_id.ib = cm_id;
947 cm_id->context = conn_id;
948 cm_id->cm_handler = cma_ib_handler;
949
950 offset = cma_user_data_offset(listen_id->id.ps);
951 ret = cma_notify_user(conn_id, RDMA_CM_EVENT_CONNECT_REQUEST, 0,
952 ib_event->private_data + offset,
953 IB_CM_REQ_PRIVATE_DATA_SIZE - offset);
954 if (ret) {
955 /* Destroy the CM ID by returning a non-zero value. */
956 conn_id->cm_id.ib = NULL;
957 cma_exch(conn_id, CMA_DESTROYING);
958 cma_release_remove(conn_id);
959 rdma_destroy_id(&conn_id->id);
960 }
961out:
962 cma_release_remove(listen_id);
963 return ret;
964}
965
966static __be64 cma_get_service_id(enum rdma_port_space ps, struct sockaddr *addr)
967{
968 return cpu_to_be64(((u64)ps << 16) +
969 be16_to_cpu(((struct sockaddr_in *) addr)->sin_port));
970}
971
972static void cma_set_compare_data(enum rdma_port_space ps, struct sockaddr *addr,
973 struct ib_cm_compare_data *compare)
974{
975 struct cma_hdr *cma_data, *cma_mask;
976 struct sdp_hh *sdp_data, *sdp_mask;
977 __u32 ip4_addr;
978 struct in6_addr ip6_addr;
979
980 memset(compare, 0, sizeof *compare);
981 cma_data = (void *) compare->data;
982 cma_mask = (void *) compare->mask;
983 sdp_data = (void *) compare->data;
984 sdp_mask = (void *) compare->mask;
985
986 switch (addr->sa_family) {
987 case AF_INET:
988 ip4_addr = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
989 if (ps == RDMA_PS_SDP) {
990 sdp_set_ip_ver(sdp_data, 4);
991 sdp_set_ip_ver(sdp_mask, 0xF);
992 sdp_data->dst_addr.ip4.addr = ip4_addr;
993 sdp_mask->dst_addr.ip4.addr = ~0;
994 } else {
995 cma_set_ip_ver(cma_data, 4);
996 cma_set_ip_ver(cma_mask, 0xF);
997 cma_data->dst_addr.ip4.addr = ip4_addr;
998 cma_mask->dst_addr.ip4.addr = ~0;
999 }
1000 break;
1001 case AF_INET6:
1002 ip6_addr = ((struct sockaddr_in6 *) addr)->sin6_addr;
1003 if (ps == RDMA_PS_SDP) {
1004 sdp_set_ip_ver(sdp_data, 6);
1005 sdp_set_ip_ver(sdp_mask, 0xF);
1006 sdp_data->dst_addr.ip6 = ip6_addr;
1007 memset(&sdp_mask->dst_addr.ip6, 0xFF,
1008 sizeof sdp_mask->dst_addr.ip6);
1009 } else {
1010 cma_set_ip_ver(cma_data, 6);
1011 cma_set_ip_ver(cma_mask, 0xF);
1012 cma_data->dst_addr.ip6 = ip6_addr;
1013 memset(&cma_mask->dst_addr.ip6, 0xFF,
1014 sizeof cma_mask->dst_addr.ip6);
1015 }
1016 break;
1017 default:
1018 break;
1019 }
1020}
1021
07ebafba
TT		 1022static int cma_iw_handler(struct iw_cm_id *iw_id, struct iw_cm_event *iw_event)
1023{
1024 struct rdma_id_private *id_priv = iw_id->context;
1025 enum rdma_cm_event_type event = 0;
1026 struct sockaddr_in *sin;
1027 int ret = 0;
1028
1029 atomic_inc(&id_priv->dev_remove);
1030
1031 switch (iw_event->event) {
1032 case IW_CM_EVENT_CLOSE:
1033 event = RDMA_CM_EVENT_DISCONNECTED;
1034 break;
1035 case IW_CM_EVENT_CONNECT_REPLY:
1036 sin = (struct sockaddr_in *) &id_priv->id.route.addr.src_addr;
1037 *sin = iw_event->local_addr;
1038 sin = (struct sockaddr_in *) &id_priv->id.route.addr.dst_addr;
1039 *sin = iw_event->remote_addr;
1040 if (iw_event->status)
1041 event = RDMA_CM_EVENT_REJECTED;
1042 else
1043 event = RDMA_CM_EVENT_ESTABLISHED;
1044 break;
1045 case IW_CM_EVENT_ESTABLISHED:
1046 event = RDMA_CM_EVENT_ESTABLISHED;
1047 break;
1048 default:
1049 BUG_ON(1);
1050 }
1051
1052 ret = cma_notify_user(id_priv, event, iw_event->status,
1053 iw_event->private_data,
1054 iw_event->private_data_len);
1055 if (ret) {
1056 /* Destroy the CM ID by returning a non-zero value. */
1057 id_priv->cm_id.iw = NULL;
1058 cma_exch(id_priv, CMA_DESTROYING);
1059 cma_release_remove(id_priv);
1060 rdma_destroy_id(&id_priv->id);
1061 return ret;
1062 }
1063
1064 cma_release_remove(id_priv);
1065 return ret;
1066}
1067
1068static int iw_conn_req_handler(struct iw_cm_id *cm_id,
1069 struct iw_cm_event *iw_event)
1070{
1071 struct rdma_cm_id *new_cm_id;
1072 struct rdma_id_private *listen_id, *conn_id;
1073 struct sockaddr_in *sin;
1074 struct net_device *dev = NULL;
1075 int ret;
1076
1077 listen_id = cm_id->context;
1078 atomic_inc(&listen_id->dev_remove);
1079 if (!cma_comp(listen_id, CMA_LISTEN)) {
1080 ret = -ECONNABORTED;
1081 goto out;
1082 }
1083
1084 /* Create a new RDMA id for the new IW CM ID */
1085 new_cm_id = rdma_create_id(listen_id->id.event_handler,
1086 listen_id->id.context,
1087 RDMA_PS_TCP);
1088 if (!new_cm_id) {
1089 ret = -ENOMEM;
1090 goto out;
1091 }
1092 conn_id = container_of(new_cm_id, struct rdma_id_private, id);
1093 atomic_inc(&conn_id->dev_remove);
1094 conn_id->state = CMA_CONNECT;
1095
1096 dev = ip_dev_find(iw_event->local_addr.sin_addr.s_addr);
1097 if (!dev) {
1098 ret = -EADDRNOTAVAIL;
1099 cma_release_remove(conn_id);
1100 rdma_destroy_id(new_cm_id);
1101 goto out;
1102 }
1103 ret = rdma_copy_addr(&conn_id->id.route.addr.dev_addr, dev, NULL);
1104 if (ret) {
1105 cma_release_remove(conn_id);
1106 rdma_destroy_id(new_cm_id);
1107 goto out;
1108 }
1109
61a73c70 1110 mutex_lock(&lock);
07ebafba 1111 ret = cma_acquire_dev(conn_id);
61a73c70 1112 mutex_unlock(&lock);
07ebafba
TT		 1113 if (ret) {
1114 cma_release_remove(conn_id);
1115 rdma_destroy_id(new_cm_id);
1116 goto out;
1117 }
1118
1119 conn_id->cm_id.iw = cm_id;
1120 cm_id->context = conn_id;
1121 cm_id->cm_handler = cma_iw_handler;
1122
1123 sin = (struct sockaddr_in *) &new_cm_id->route.addr.src_addr;
1124 *sin = iw_event->local_addr;
1125 sin = (struct sockaddr_in *) &new_cm_id->route.addr.dst_addr;
1126 *sin = iw_event->remote_addr;
1127
1128 ret = cma_notify_user(conn_id, RDMA_CM_EVENT_CONNECT_REQUEST, 0,
1129 iw_event->private_data,
1130 iw_event->private_data_len);
1131 if (ret) {
1132 /* User wants to destroy the CM ID */
1133 conn_id->cm_id.iw = NULL;
1134 cma_exch(conn_id, CMA_DESTROYING);
1135 cma_release_remove(conn_id);
1136 rdma_destroy_id(&conn_id->id);
1137 }
1138
1139out:
1140 if (dev)
1141 dev_put(dev);
1142 cma_release_remove(listen_id);
1143 return ret;
1144}
1145
e51060f0
SH		 1146static int cma_ib_listen(struct rdma_id_private *id_priv)
1147{
1148 struct ib_cm_compare_data compare_data;
1149 struct sockaddr *addr;
1150 __be64 svc_id;
1151 int ret;
1152
1153 id_priv->cm_id.ib = ib_create_cm_id(id_priv->id.device, cma_req_handler,
1154 id_priv);
1155 if (IS_ERR(id_priv->cm_id.ib))
1156 return PTR_ERR(id_priv->cm_id.ib);
1157
1158 addr = &id_priv->id.route.addr.src_addr;
1159 svc_id = cma_get_service_id(id_priv->id.ps, addr);
1160 if (cma_any_addr(addr))
1161 ret = ib_cm_listen(id_priv->cm_id.ib, svc_id, 0, NULL);
1162 else {
1163 cma_set_compare_data(id_priv->id.ps, addr, &compare_data);
1164 ret = ib_cm_listen(id_priv->cm_id.ib, svc_id, 0, &compare_data);
1165 }
1166
1167 if (ret) {
1168 ib_destroy_cm_id(id_priv->cm_id.ib);
1169 id_priv->cm_id.ib = NULL;
1170 }
1171
1172 return ret;
1173}
1174
07ebafba
TT		 1175static int cma_iw_listen(struct rdma_id_private *id_priv, int backlog)
1176{
1177 int ret;
1178 struct sockaddr_in *sin;
1179
1180 id_priv->cm_id.iw = iw_create_cm_id(id_priv->id.device,
1181 iw_conn_req_handler,
1182 id_priv);
1183 if (IS_ERR(id_priv->cm_id.iw))
1184 return PTR_ERR(id_priv->cm_id.iw);
1185
1186 sin = (struct sockaddr_in *) &id_priv->id.route.addr.src_addr;
1187 id_priv->cm_id.iw->local_addr = *sin;
1188
1189 ret = iw_cm_listen(id_priv->cm_id.iw, backlog);
1190
1191 if (ret) {
1192 iw_destroy_cm_id(id_priv->cm_id.iw);
1193 id_priv->cm_id.iw = NULL;
1194 }
1195
1196 return ret;
1197}
1198
e51060f0
SH		 1199static int cma_listen_handler(struct rdma_cm_id *id,
1200 struct rdma_cm_event *event)
1201{
1202 struct rdma_id_private *id_priv = id->context;
1203
1204 id->context = id_priv->id.context;
1205 id->event_handler = id_priv->id.event_handler;
1206 return id_priv->id.event_handler(id, event);
1207}
1208
1209static void cma_listen_on_dev(struct rdma_id_private *id_priv,
1210 struct cma_device *cma_dev)
1211{
1212 struct rdma_id_private *dev_id_priv;
1213 struct rdma_cm_id *id;
1214 int ret;
1215
1216 id = rdma_create_id(cma_listen_handler, id_priv, id_priv->id.ps);
1217 if (IS_ERR(id))
1218 return;
1219
1220 dev_id_priv = container_of(id, struct rdma_id_private, id);
1221
1222 dev_id_priv->state = CMA_ADDR_BOUND;
1223 memcpy(&id->route.addr.src_addr, &id_priv->id.route.addr.src_addr,
1224 ip_addr_size(&id_priv->id.route.addr.src_addr));
1225
1226 cma_attach_to_dev(dev_id_priv, cma_dev);
1227 list_add_tail(&dev_id_priv->listen_list, &id_priv->listen_list);
1228
1229 ret = rdma_listen(id, id_priv->backlog);
1230 if (ret)
1231 goto err;
1232
1233 return;
1234err:
1235 cma_destroy_listen(dev_id_priv);
1236}
1237
1238static void cma_listen_on_all(struct rdma_id_private *id_priv)
1239{
1240 struct cma_device *cma_dev;
1241
1242 mutex_lock(&lock);
1243 list_add_tail(&id_priv->list, &listen_any_list);
1244 list_for_each_entry(cma_dev, &dev_list, list)
1245 cma_listen_on_dev(id_priv, cma_dev);
1246 mutex_unlock(&lock);
1247}
1248
1249static int cma_bind_any(struct rdma_cm_id *id, sa_family_t af)
1250{
1251 struct sockaddr_in addr_in;
1252
1253 memset(&addr_in, 0, sizeof addr_in);
1254 addr_in.sin_family = af;
1255 return rdma_bind_addr(id, (struct sockaddr *) &addr_in);
1256}
1257
1258int rdma_listen(struct rdma_cm_id *id, int backlog)
1259{
1260 struct rdma_id_private *id_priv;
1261 int ret;
1262
1263 id_priv = container_of(id, struct rdma_id_private, id);
1264 if (id_priv->state == CMA_IDLE) {
1265 ret = cma_bind_any(id, AF_INET);
1266 if (ret)
1267 return ret;
1268 }
1269
1270 if (!cma_comp_exch(id_priv, CMA_ADDR_BOUND, CMA_LISTEN))
1271 return -EINVAL;
1272
1273 id_priv->backlog = backlog;
1274 if (id->device) {
07ebafba
TT		 1275 switch (rdma_node_get_transport(id->device->node_type)) {
1276 case RDMA_TRANSPORT_IB:
e51060f0
SH		 1277 ret = cma_ib_listen(id_priv);
1278 if (ret)
1279 goto err;
1280 break;
07ebafba
TT		 1281 case RDMA_TRANSPORT_IWARP:
1282 ret = cma_iw_listen(id_priv, backlog);
1283 if (ret)
1284 goto err;
1285 break;
e51060f0
SH		 1286 default:
1287 ret = -ENOSYS;
1288 goto err;
1289 }
1290 } else
1291 cma_listen_on_all(id_priv);
1292
1293 return 0;
1294err:
1295 id_priv->backlog = 0;
1296 cma_comp_exch(id_priv, CMA_LISTEN, CMA_ADDR_BOUND);
1297 return ret;
1298}
1299EXPORT_SYMBOL(rdma_listen);
1300
1301static void cma_query_handler(int status, struct ib_sa_path_rec *path_rec,
1302 void *context)
1303{
1304 struct cma_work *work = context;
1305 struct rdma_route *route;
1306
1307 route = &work->id->id.route;
1308
1309 if (!status) {
1310 route->num_paths = 1;
1311 *route->path_rec = *path_rec;
1312 } else {
1313 work->old_state = CMA_ROUTE_QUERY;
1314 work->new_state = CMA_ADDR_RESOLVED;
1315 work->event.event = RDMA_CM_EVENT_ROUTE_ERROR;
8f0472d3 1316 work->event.status = status;
e51060f0
SH		 1317 }
1318
1319 queue_work(cma_wq, &work->work);
1320}
1321
1322static int cma_query_ib_route(struct rdma_id_private *id_priv, int timeout_ms,
1323 struct cma_work *work)
1324{
1325 struct rdma_dev_addr *addr = &id_priv->id.route.addr.dev_addr;
1326 struct ib_sa_path_rec path_rec;
1327
1328 memset(&path_rec, 0, sizeof path_rec);
f0ee3404
MT		 1329 ib_addr_get_sgid(addr, &path_rec.sgid);
1330 ib_addr_get_dgid(addr, &path_rec.dgid);
e51060f0
SH		 1331 path_rec.pkey = cpu_to_be16(ib_addr_get_pkey(addr));
1332 path_rec.numb_path = 1;
1333
c1a0b23b 1334 id_priv->query_id = ib_sa_path_rec_get(&sa_client, id_priv->id.device,
e51060f0
SH		 1335 id_priv->id.port_num, &path_rec,
1336 IB_SA_PATH_REC_DGID | IB_SA_PATH_REC_SGID |
1337 IB_SA_PATH_REC_PKEY | IB_SA_PATH_REC_NUMB_PATH,
1338 timeout_ms, GFP_KERNEL,
1339 cma_query_handler, work, &id_priv->query);
1340
1341 return (id_priv->query_id < 0) ? id_priv->query_id : 0;
1342}
1343
1344static void cma_work_handler(void *data)
1345{
1346 struct cma_work *work = data;
1347 struct rdma_id_private *id_priv = work->id;
1348 int destroy = 0;
1349
1350 atomic_inc(&id_priv->dev_remove);
1351 if (!cma_comp_exch(id_priv, work->old_state, work->new_state))
1352 goto out;
1353
1354 if (id_priv->id.event_handler(&id_priv->id, &work->event)) {
1355 cma_exch(id_priv, CMA_DESTROYING);
1356 destroy = 1;
1357 }
1358out:
1359 cma_release_remove(id_priv);
1360 cma_deref_id(id_priv);
1361 if (destroy)
1362 rdma_destroy_id(&id_priv->id);
1363 kfree(work);
1364}
1365
1366static int cma_resolve_ib_route(struct rdma_id_private *id_priv, int timeout_ms)
1367{
1368 struct rdma_route *route = &id_priv->id.route;
1369 struct cma_work *work;
1370 int ret;
1371
1372 work = kzalloc(sizeof *work, GFP_KERNEL);
1373 if (!work)
1374 return -ENOMEM;
1375
1376 work->id = id_priv;
1377 INIT_WORK(&work->work, cma_work_handler, work);
1378 work->old_state = CMA_ROUTE_QUERY;
1379 work->new_state = CMA_ROUTE_RESOLVED;
1380 work->event.event = RDMA_CM_EVENT_ROUTE_RESOLVED;
1381
1382 route->path_rec = kmalloc(sizeof *route->path_rec, GFP_KERNEL);
1383 if (!route->path_rec) {
1384 ret = -ENOMEM;
1385 goto err1;
1386 }
1387
1388 ret = cma_query_ib_route(id_priv, timeout_ms, work);
1389 if (ret)
1390 goto err2;
1391
1392 return 0;
1393err2:
1394 kfree(route->path_rec);
1395 route->path_rec = NULL;
1396err1:
1397 kfree(work);
1398 return ret;
1399}
1400
1401int rdma_set_ib_paths(struct rdma_cm_id *id,
1402 struct ib_sa_path_rec *path_rec, int num_paths)
1403{
1404 struct rdma_id_private *id_priv;
1405 int ret;
1406
1407 id_priv = container_of(id, struct rdma_id_private, id);
1408 if (!cma_comp_exch(id_priv, CMA_ADDR_RESOLVED, CMA_ROUTE_RESOLVED))
1409 return -EINVAL;
1410
1411 id->route.path_rec = kmalloc(sizeof *path_rec * num_paths, GFP_KERNEL);
1412 if (!id->route.path_rec) {
1413 ret = -ENOMEM;
1414 goto err;
1415 }
1416
1417 memcpy(id->route.path_rec, path_rec, sizeof *path_rec * num_paths);
1418 return 0;
1419err:
1420 cma_comp_exch(id_priv, CMA_ROUTE_RESOLVED, CMA_ADDR_RESOLVED);
1421 return ret;
1422}
1423EXPORT_SYMBOL(rdma_set_ib_paths);
1424
07ebafba
TT		 1425static int cma_resolve_iw_route(struct rdma_id_private *id_priv, int timeout_ms)
1426{
1427 struct cma_work *work;
1428
1429 work = kzalloc(sizeof *work, GFP_KERNEL);
1430 if (!work)
1431 return -ENOMEM;
1432
1433 work->id = id_priv;
1434 INIT_WORK(&work->work, cma_work_handler, work);
1435 work->old_state = CMA_ROUTE_QUERY;
1436 work->new_state = CMA_ROUTE_RESOLVED;
1437 work->event.event = RDMA_CM_EVENT_ROUTE_RESOLVED;
1438 queue_work(cma_wq, &work->work);
1439 return 0;
1440}
1441
e51060f0
SH		 1442int rdma_resolve_route(struct rdma_cm_id *id, int timeout_ms)
1443{
1444 struct rdma_id_private *id_priv;
1445 int ret;
1446
1447 id_priv = container_of(id, struct rdma_id_private, id);
1448 if (!cma_comp_exch(id_priv, CMA_ADDR_RESOLVED, CMA_ROUTE_QUERY))
1449 return -EINVAL;
1450
1451 atomic_inc(&id_priv->refcount);
07ebafba
TT		 1452 switch (rdma_node_get_transport(id->device->node_type)) {
1453 case RDMA_TRANSPORT_IB:
e51060f0
SH		 1454 ret = cma_resolve_ib_route(id_priv, timeout_ms);
1455 break;
07ebafba
TT		 1456 case RDMA_TRANSPORT_IWARP:
1457 ret = cma_resolve_iw_route(id_priv, timeout_ms);
1458 break;
e51060f0
SH		 1459 default:
1460 ret = -ENOSYS;
1461 break;
1462 }
1463 if (ret)
1464 goto err;
1465
1466 return 0;
1467err:
1468 cma_comp_exch(id_priv, CMA_ROUTE_QUERY, CMA_ADDR_RESOLVED);
1469 cma_deref_id(id_priv);
1470 return ret;
1471}
1472EXPORT_SYMBOL(rdma_resolve_route);
1473
1474static int cma_bind_loopback(struct rdma_id_private *id_priv)
1475{
1476 struct cma_device *cma_dev;
1477 struct ib_port_attr port_attr;
f0ee3404 1478 union ib_gid gid;
e51060f0
SH		 1479 u16 pkey;
1480 int ret;
1481 u8 p;
1482
1483 mutex_lock(&lock);
1484 list_for_each_entry(cma_dev, &dev_list, list)
1485 for (p = 1; p <= cma_dev->device->phys_port_cnt; ++p)
1486 if (!ib_query_port (cma_dev->device, p, &port_attr) &&
1487 port_attr.state == IB_PORT_ACTIVE)
1488 goto port_found;
1489
1490 if (!list_empty(&dev_list)) {
1491 p = 1;
1492 cma_dev = list_entry(dev_list.next, struct cma_device, list);
1493 } else {
1494 ret = -ENODEV;
1495 goto out;
1496 }
1497
1498port_found:
f0ee3404 1499 ret = ib_get_cached_gid(cma_dev->device, p, 0, &gid);
e51060f0
SH		 1500 if (ret)
1501 goto out;
1502
1503 ret = ib_get_cached_pkey(cma_dev->device, p, 0, &pkey);
1504 if (ret)
1505 goto out;
1506
f0ee3404 1507 ib_addr_set_sgid(&id_priv->id.route.addr.dev_addr, &gid);
e51060f0
SH		 1508 ib_addr_set_pkey(&id_priv->id.route.addr.dev_addr, pkey);
1509 id_priv->id.port_num = p;
1510 cma_attach_to_dev(id_priv, cma_dev);
1511out:
1512 mutex_unlock(&lock);
1513 return ret;
1514}
1515
1516static void addr_handler(int status, struct sockaddr *src_addr,
1517 struct rdma_dev_addr *dev_addr, void *context)
1518{
1519 struct rdma_id_private *id_priv = context;
1520 enum rdma_cm_event_type event;
1521
1522 atomic_inc(&id_priv->dev_remove);
61a73c70
SH		 1523
1524 /*
1525 * Grab mutex to block rdma_destroy_id() from removing the device while
1526 * we're trying to acquire it.
1527 */
1528 mutex_lock(&lock);
1529 if (!cma_comp_exch(id_priv, CMA_ADDR_QUERY, CMA_ADDR_RESOLVED)) {
1530 mutex_unlock(&lock);
1531 goto out;
1532 }
1533
1534 if (!status && !id_priv->cma_dev)
e51060f0 1535 status = cma_acquire_dev(id_priv);
61a73c70 1536 mutex_unlock(&lock);
e51060f0
SH		 1537
1538 if (status) {
61a73c70 1539 if (!cma_comp_exch(id_priv, CMA_ADDR_RESOLVED, CMA_ADDR_BOUND))
e51060f0
SH		 1540 goto out;
1541 event = RDMA_CM_EVENT_ADDR_ERROR;
1542 } else {
e51060f0
SH		 1543 memcpy(&id_priv->id.route.addr.src_addr, src_addr,
1544 ip_addr_size(src_addr));
1545 event = RDMA_CM_EVENT_ADDR_RESOLVED;
1546 }
1547
1548 if (cma_notify_user(id_priv, event, status, NULL, 0)) {
1549 cma_exch(id_priv, CMA_DESTROYING);
1550 cma_release_remove(id_priv);
1551 cma_deref_id(id_priv);
1552 rdma_destroy_id(&id_priv->id);
1553 return;
1554 }
1555out:
1556 cma_release_remove(id_priv);
1557 cma_deref_id(id_priv);
1558}
1559
1560static int cma_resolve_loopback(struct rdma_id_private *id_priv)
1561{
1562 struct cma_work *work;
1563 struct sockaddr_in *src_in, *dst_in;
f0ee3404 1564 union ib_gid gid;
e51060f0
SH		 1565 int ret;
1566
1567 work = kzalloc(sizeof *work, GFP_KERNEL);
1568 if (!work)
1569 return -ENOMEM;
1570
1571 if (!id_priv->cma_dev) {
1572 ret = cma_bind_loopback(id_priv);
1573 if (ret)
1574 goto err;
1575 }
1576
f0ee3404
MT		 1577 ib_addr_get_sgid(&id_priv->id.route.addr.dev_addr, &gid);
1578 ib_addr_set_dgid(&id_priv->id.route.addr.dev_addr, &gid);
e51060f0
SH		 1579
1580 if (cma_zero_addr(&id_priv->id.route.addr.src_addr)) {
1581 src_in = (struct sockaddr_in *)&id_priv->id.route.addr.src_addr;
1582 dst_in = (struct sockaddr_in *)&id_priv->id.route.addr.dst_addr;
1583 src_in->sin_family = dst_in->sin_family;
1584 src_in->sin_addr.s_addr = dst_in->sin_addr.s_addr;
1585 }
1586
1587 work->id = id_priv;
1588 INIT_WORK(&work->work, cma_work_handler, work);
1589 work->old_state = CMA_ADDR_QUERY;
1590 work->new_state = CMA_ADDR_RESOLVED;
1591 work->event.event = RDMA_CM_EVENT_ADDR_RESOLVED;
1592 queue_work(cma_wq, &work->work);
1593 return 0;
1594err:
1595 kfree(work);
1596 return ret;
1597}
1598
1599static int cma_bind_addr(struct rdma_cm_id *id, struct sockaddr *src_addr,
1600 struct sockaddr *dst_addr)
1601{
1602 if (src_addr && src_addr->sa_family)
1603 return rdma_bind_addr(id, src_addr);
1604 else
1605 return cma_bind_any(id, dst_addr->sa_family);
1606}
1607
1608int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr,
1609 struct sockaddr *dst_addr, int timeout_ms)
1610{
1611 struct rdma_id_private *id_priv;
1612 int ret;
1613
1614 id_priv = container_of(id, struct rdma_id_private, id);
1615 if (id_priv->state == CMA_IDLE) {
1616 ret = cma_bind_addr(id, src_addr, dst_addr);
1617 if (ret)
1618 return ret;
1619 }
1620
1621 if (!cma_comp_exch(id_priv, CMA_ADDR_BOUND, CMA_ADDR_QUERY))
1622 return -EINVAL;
1623
1624 atomic_inc(&id_priv->refcount);
1625 memcpy(&id->route.addr.dst_addr, dst_addr, ip_addr_size(dst_addr));
1626 if (cma_any_addr(dst_addr))
1627 ret = cma_resolve_loopback(id_priv);
1628 else
7a118df3
SH		 1629 ret = rdma_resolve_ip(&addr_client, &id->route.addr.src_addr,
1630 dst_addr, &id->route.addr.dev_addr,
e51060f0
SH		 1631 timeout_ms, addr_handler, id_priv);
1632 if (ret)
1633 goto err;
1634
1635 return 0;
1636err:
1637 cma_comp_exch(id_priv, CMA_ADDR_QUERY, CMA_ADDR_BOUND);
1638 cma_deref_id(id_priv);
1639 return ret;
1640}
1641EXPORT_SYMBOL(rdma_resolve_addr);
1642
1643static void cma_bind_port(struct rdma_bind_list *bind_list,
1644 struct rdma_id_private *id_priv)
1645{
1646 struct sockaddr_in *sin;
1647
1648 sin = (struct sockaddr_in *) &id_priv->id.route.addr.src_addr;
1649 sin->sin_port = htons(bind_list->port);
1650 id_priv->bind_list = bind_list;
1651 hlist_add_head(&id_priv->node, &bind_list->owners);
1652}
1653
1654static int cma_alloc_port(struct idr *ps, struct rdma_id_private *id_priv,
1655 unsigned short snum)
1656{
1657 struct rdma_bind_list *bind_list;
1658 int port, start, ret;
1659
1660 bind_list = kzalloc(sizeof *bind_list, GFP_KERNEL);
1661 if (!bind_list)
1662 return -ENOMEM;
1663
1664 start = snum ? snum : sysctl_local_port_range[0];
1665
1666 do {
1667 ret = idr_get_new_above(ps, bind_list, start, &port);
1668 } while ((ret == -EAGAIN) && idr_pre_get(ps, GFP_KERNEL));
1669
1670 if (ret)
1671 goto err;
1672
1673 if ((snum && port != snum) ||
1674 (!snum && port > sysctl_local_port_range[1])) {
1675 idr_remove(ps, port);
1676 ret = -EADDRNOTAVAIL;
1677 goto err;
1678 }
1679
1680 bind_list->ps = ps;
1681 bind_list->port = (unsigned short) port;
1682 cma_bind_port(bind_list, id_priv);
1683 return 0;
1684err:
1685 kfree(bind_list);
1686 return ret;
1687}
1688
1689static int cma_use_port(struct idr *ps, struct rdma_id_private *id_priv)
1690{
1691 struct rdma_id_private *cur_id;
1692 struct sockaddr_in *sin, *cur_sin;
1693 struct rdma_bind_list *bind_list;
1694 struct hlist_node *node;
1695 unsigned short snum;
1696
1697 sin = (struct sockaddr_in *) &id_priv->id.route.addr.src_addr;
1698 snum = ntohs(sin->sin_port);
1699 if (snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))
1700 return -EACCES;
1701
1702 bind_list = idr_find(ps, snum);
1703 if (!bind_list)
1704 return cma_alloc_port(ps, id_priv, snum);
1705
1706 /*
1707 * We don't support binding to any address if anyone is bound to
1708 * a specific address on the same port.
1709 */
1710 if (cma_any_addr(&id_priv->id.route.addr.src_addr))
1711 return -EADDRNOTAVAIL;
1712
1713 hlist_for_each_entry(cur_id, node, &bind_list->owners, node) {
1714 if (cma_any_addr(&cur_id->id.route.addr.src_addr))
1715 return -EADDRNOTAVAIL;
3cd96564 1716
e51060f0
SH		 1717 cur_sin = (struct sockaddr_in *) &cur_id->id.route.addr.src_addr;
1718 if (sin->sin_addr.s_addr == cur_sin->sin_addr.s_addr)
1719 return -EADDRINUSE;
1720 }
1721
1722 cma_bind_port(bind_list, id_priv);
1723 return 0;
1724}
1725
1726static int cma_get_port(struct rdma_id_private *id_priv)
1727{
1728 struct idr *ps;
1729 int ret;
1730
1731 switch (id_priv->id.ps) {
1732 case RDMA_PS_SDP:
1733 ps = &sdp_ps;
1734 break;
1735 case RDMA_PS_TCP:
1736 ps = &tcp_ps;
1737 break;
1738 default:
1739 return -EPROTONOSUPPORT;
1740 }
1741
1742 mutex_lock(&lock);
1743 if (cma_any_port(&id_priv->id.route.addr.src_addr))
1744 ret = cma_alloc_port(ps, id_priv, 0);
1745 else
1746 ret = cma_use_port(ps, id_priv);
1747 mutex_unlock(&lock);
1748
1749 return ret;
1750}
1751
1752int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr)
1753{
1754 struct rdma_id_private *id_priv;
1755 int ret;
1756
1757 if (addr->sa_family != AF_INET)
1758 return -EAFNOSUPPORT;
1759
1760 id_priv = container_of(id, struct rdma_id_private, id);
1761 if (!cma_comp_exch(id_priv, CMA_IDLE, CMA_ADDR_BOUND))
1762 return -EINVAL;
1763
1764 if (!cma_any_addr(addr)) {
1765 ret = rdma_translate_ip(addr, &id->route.addr.dev_addr);
e51060f0 1766 if (ret)
255d0c14
KK		 1767 goto err1;
1768
1769 mutex_lock(&lock);
1770 ret = cma_acquire_dev(id_priv);
1771 mutex_unlock(&lock);
1772 if (ret)
1773 goto err1;
e51060f0
SH		 1774 }
1775
1776 memcpy(&id->route.addr.src_addr, addr, ip_addr_size(addr));
1777 ret = cma_get_port(id_priv);
1778 if (ret)
255d0c14 1779 goto err2;
e51060f0
SH		 1780
1781 return 0;
255d0c14
KK		 1782err2:
1783 if (!cma_any_addr(addr)) {
1784 mutex_lock(&lock);
1785 cma_detach_from_dev(id_priv);
1786 mutex_unlock(&lock);
1787 }
1788err1:
e51060f0
SH		 1789 cma_comp_exch(id_priv, CMA_ADDR_BOUND, CMA_IDLE);
1790 return ret;
1791}
1792EXPORT_SYMBOL(rdma_bind_addr);
1793
1794static int cma_format_hdr(void *hdr, enum rdma_port_space ps,
1795 struct rdma_route *route)
1796{
1797 struct sockaddr_in *src4, *dst4;
1798 struct cma_hdr *cma_hdr;
1799 struct sdp_hh *sdp_hdr;
1800
1801 src4 = (struct sockaddr_in *) &route->addr.src_addr;
1802 dst4 = (struct sockaddr_in *) &route->addr.dst_addr;
1803
1804 switch (ps) {
1805 case RDMA_PS_SDP:
1806 sdp_hdr = hdr;
1807 if (sdp_get_majv(sdp_hdr->sdp_version) != SDP_MAJ_VERSION)
1808 return -EINVAL;
1809 sdp_set_ip_ver(sdp_hdr, 4);
1810 sdp_hdr->src_addr.ip4.addr = src4->sin_addr.s_addr;
1811 sdp_hdr->dst_addr.ip4.addr = dst4->sin_addr.s_addr;
1812 sdp_hdr->port = src4->sin_port;
1813 break;
1814 default:
1815 cma_hdr = hdr;
1816 cma_hdr->cma_version = CMA_VERSION;
1817 cma_set_ip_ver(cma_hdr, 4);
1818 cma_hdr->src_addr.ip4.addr = src4->sin_addr.s_addr;
1819 cma_hdr->dst_addr.ip4.addr = dst4->sin_addr.s_addr;
1820 cma_hdr->port = src4->sin_port;
1821 break;
1822 }
1823 return 0;
1824}
1825
1826static int cma_connect_ib(struct rdma_id_private *id_priv,
1827 struct rdma_conn_param *conn_param)
1828{
1829 struct ib_cm_req_param req;
1830 struct rdma_route *route;
1831 void *private_data;
1832 int offset, ret;
1833
1834 memset(&req, 0, sizeof req);
1835 offset = cma_user_data_offset(id_priv->id.ps);
1836 req.private_data_len = offset + conn_param->private_data_len;
1837 private_data = kzalloc(req.private_data_len, GFP_ATOMIC);
1838 if (!private_data)
1839 return -ENOMEM;
1840
1841 if (conn_param->private_data && conn_param->private_data_len)
1842 memcpy(private_data + offset, conn_param->private_data,
1843 conn_param->private_data_len);
1844
1845 id_priv->cm_id.ib = ib_create_cm_id(id_priv->id.device, cma_ib_handler,
1846 id_priv);
1847 if (IS_ERR(id_priv->cm_id.ib)) {
1848 ret = PTR_ERR(id_priv->cm_id.ib);
1849 goto out;
1850 }
1851
1852 route = &id_priv->id.route;
1853 ret = cma_format_hdr(private_data, id_priv->id.ps, route);
1854 if (ret)
1855 goto out;
1856 req.private_data = private_data;
1857
1858 req.primary_path = &route->path_rec[0];
1859 if (route->num_paths == 2)
1860 req.alternate_path = &route->path_rec[1];
1861
1862 req.service_id = cma_get_service_id(id_priv->id.ps,
1863 &route->addr.dst_addr);
1864 req.qp_num = id_priv->qp_num;
1865 req.qp_type = id_priv->qp_type;
1866 req.starting_psn = id_priv->seq_num;
1867 req.responder_resources = conn_param->responder_resources;
1868 req.initiator_depth = conn_param->initiator_depth;
1869 req.flow_control = conn_param->flow_control;
1870 req.retry_count = conn_param->retry_count;
1871 req.rnr_retry_count = conn_param->rnr_retry_count;
1872 req.remote_cm_response_timeout = CMA_CM_RESPONSE_TIMEOUT;
1873 req.local_cm_response_timeout = CMA_CM_RESPONSE_TIMEOUT;
1874 req.max_cm_retries = CMA_MAX_CM_RETRIES;
1875 req.srq = id_priv->srq ? 1 : 0;
1876
1877 ret = ib_send_cm_req(id_priv->cm_id.ib, &req);
1878out:
675a027c
KK		 1879 if (ret && !IS_ERR(id_priv->cm_id.ib)) {
1880 ib_destroy_cm_id(id_priv->cm_id.ib);
1881 id_priv->cm_id.ib = NULL;
1882 }
1883
e51060f0
SH		 1884 kfree(private_data);
1885 return ret;
1886}
1887
07ebafba
TT		 1888static int cma_connect_iw(struct rdma_id_private *id_priv,
1889 struct rdma_conn_param *conn_param)
1890{
1891 struct iw_cm_id *cm_id;
1892 struct sockaddr_in* sin;
1893 int ret;
1894 struct iw_cm_conn_param iw_param;
1895
1896 cm_id = iw_create_cm_id(id_priv->id.device, cma_iw_handler, id_priv);
1897 if (IS_ERR(cm_id)) {
1898 ret = PTR_ERR(cm_id);
1899 goto out;
1900 }
1901
1902 id_priv->cm_id.iw = cm_id;
1903
1904 sin = (struct sockaddr_in*) &id_priv->id.route.addr.src_addr;
1905 cm_id->local_addr = *sin;
1906
1907 sin = (struct sockaddr_in*) &id_priv->id.route.addr.dst_addr;
1908 cm_id->remote_addr = *sin;
1909
1910 ret = cma_modify_qp_rtr(&id_priv->id);
675a027c
KK		 1911 if (ret)
1912 goto out;
07ebafba
TT		 1913
1914 iw_param.ord = conn_param->initiator_depth;
1915 iw_param.ird = conn_param->responder_resources;
1916 iw_param.private_data = conn_param->private_data;
1917 iw_param.private_data_len = conn_param->private_data_len;
1918 if (id_priv->id.qp)
1919 iw_param.qpn = id_priv->qp_num;
1920 else
1921 iw_param.qpn = conn_param->qp_num;
1922 ret = iw_cm_connect(cm_id, &iw_param);
1923out:
675a027c
KK		 1924 if (ret && !IS_ERR(cm_id)) {
1925 iw_destroy_cm_id(cm_id);
1926 id_priv->cm_id.iw = NULL;
1927 }
07ebafba
TT		 1928 return ret;
1929}
1930
e51060f0
SH		 1931int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param)
1932{
1933 struct rdma_id_private *id_priv;
1934 int ret;
1935
1936 id_priv = container_of(id, struct rdma_id_private, id);
1937 if (!cma_comp_exch(id_priv, CMA_ROUTE_RESOLVED, CMA_CONNECT))
1938 return -EINVAL;
1939
1940 if (!id->qp) {
1941 id_priv->qp_num = conn_param->qp_num;
1942 id_priv->qp_type = conn_param->qp_type;
1943 id_priv->srq = conn_param->srq;
1944 }
1945
07ebafba
TT		 1946 switch (rdma_node_get_transport(id->device->node_type)) {
1947 case RDMA_TRANSPORT_IB:
e51060f0
SH		 1948 ret = cma_connect_ib(id_priv, conn_param);
1949 break;
07ebafba
TT		 1950 case RDMA_TRANSPORT_IWARP:
1951 ret = cma_connect_iw(id_priv, conn_param);
1952 break;
e51060f0
SH		 1953 default:
1954 ret = -ENOSYS;
1955 break;
1956 }
1957 if (ret)
1958 goto err;
1959
1960 return 0;
1961err:
1962 cma_comp_exch(id_priv, CMA_CONNECT, CMA_ROUTE_RESOLVED);
1963 return ret;
1964}
1965EXPORT_SYMBOL(rdma_connect);
1966
1967static int cma_accept_ib(struct rdma_id_private *id_priv,
1968 struct rdma_conn_param *conn_param)
1969{
1970 struct ib_cm_rep_param rep;
1971 int ret;
1972
1973 ret = cma_modify_qp_rtr(&id_priv->id);
1974 if (ret)
1975 return ret;
1976
1977 memset(&rep, 0, sizeof rep);
1978 rep.qp_num = id_priv->qp_num;
1979 rep.starting_psn = id_priv->seq_num;
1980 rep.private_data = conn_param->private_data;
1981 rep.private_data_len = conn_param->private_data_len;
1982 rep.responder_resources = conn_param->responder_resources;
1983 rep.initiator_depth = conn_param->initiator_depth;
1984 rep.target_ack_delay = CMA_CM_RESPONSE_TIMEOUT;
1985 rep.failover_accepted = 0;
1986 rep.flow_control = conn_param->flow_control;
1987 rep.rnr_retry_count = conn_param->rnr_retry_count;
1988 rep.srq = id_priv->srq ? 1 : 0;
1989
1990 return ib_send_cm_rep(id_priv->cm_id.ib, &rep);
1991}
1992
07ebafba
TT		 1993static int cma_accept_iw(struct rdma_id_private *id_priv,
1994 struct rdma_conn_param *conn_param)
1995{
1996 struct iw_cm_conn_param iw_param;
1997 int ret;
1998
1999 ret = cma_modify_qp_rtr(&id_priv->id);
2000 if (ret)
2001 return ret;
2002
2003 iw_param.ord = conn_param->initiator_depth;
2004 iw_param.ird = conn_param->responder_resources;
2005 iw_param.private_data = conn_param->private_data;
2006 iw_param.private_data_len = conn_param->private_data_len;
2007 if (id_priv->id.qp) {
2008 iw_param.qpn = id_priv->qp_num;
2009 } else
2010 iw_param.qpn = conn_param->qp_num;
2011
2012 return iw_cm_accept(id_priv->cm_id.iw, &iw_param);
2013}
2014
e51060f0
SH		 2015int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param)
2016{
2017 struct rdma_id_private *id_priv;
2018 int ret;
2019
2020 id_priv = container_of(id, struct rdma_id_private, id);
2021 if (!cma_comp(id_priv, CMA_CONNECT))
2022 return -EINVAL;
2023
2024 if (!id->qp && conn_param) {
2025 id_priv->qp_num = conn_param->qp_num;
2026 id_priv->qp_type = conn_param->qp_type;
2027 id_priv->srq = conn_param->srq;
2028 }
2029
07ebafba
TT		 2030 switch (rdma_node_get_transport(id->device->node_type)) {
2031 case RDMA_TRANSPORT_IB:
e51060f0
SH		 2032 if (conn_param)
2033 ret = cma_accept_ib(id_priv, conn_param);
2034 else
2035 ret = cma_rep_recv(id_priv);
2036 break;
07ebafba
TT		 2037 case RDMA_TRANSPORT_IWARP:
2038 ret = cma_accept_iw(id_priv, conn_param);
2039 break;
e51060f0
SH		 2040 default:
2041 ret = -ENOSYS;
2042 break;
2043 }
2044
2045 if (ret)
2046 goto reject;
2047
2048 return 0;
2049reject:
2050 cma_modify_qp_err(id);
2051 rdma_reject(id, NULL, 0);
2052 return ret;
2053}
2054EXPORT_SYMBOL(rdma_accept);
2055
2056int rdma_reject(struct rdma_cm_id *id, const void *private_data,
2057 u8 private_data_len)
2058{
2059 struct rdma_id_private *id_priv;
2060 int ret;
2061
2062 id_priv = container_of(id, struct rdma_id_private, id);
2063 if (!cma_comp(id_priv, CMA_CONNECT))
2064 return -EINVAL;
2065
07ebafba
TT		 2066 switch (rdma_node_get_transport(id->device->node_type)) {
2067 case RDMA_TRANSPORT_IB:
e51060f0
SH		 2068 ret = ib_send_cm_rej(id_priv->cm_id.ib,
2069 IB_CM_REJ_CONSUMER_DEFINED, NULL, 0,
2070 private_data, private_data_len);
2071 break;
07ebafba
TT		 2072 case RDMA_TRANSPORT_IWARP:
2073 ret = iw_cm_reject(id_priv->cm_id.iw,
2074 private_data, private_data_len);
2075 break;
e51060f0
SH		 2076 default:
2077 ret = -ENOSYS;
2078 break;
2079 }
2080 return ret;
2081}
2082EXPORT_SYMBOL(rdma_reject);
2083
2084int rdma_disconnect(struct rdma_cm_id *id)
2085{
2086 struct rdma_id_private *id_priv;
2087 int ret;
2088
2089 id_priv = container_of(id, struct rdma_id_private, id);
2090 if (!cma_comp(id_priv, CMA_CONNECT) &&
2091 !cma_comp(id_priv, CMA_DISCONNECT))
2092 return -EINVAL;
2093
07ebafba
TT		 2094 switch (rdma_node_get_transport(id->device->node_type)) {
2095 case RDMA_TRANSPORT_IB:
2096 ret = cma_modify_qp_err(id);
2097 if (ret)
2098 goto out;
e51060f0
SH		 2099 /* Initiate or respond to a disconnect. */
2100 if (ib_send_cm_dreq(id_priv->cm_id.ib, NULL, 0))
2101 ib_send_cm_drep(id_priv->cm_id.ib, NULL, 0);
2102 break;
07ebafba
TT		 2103 case RDMA_TRANSPORT_IWARP:
2104 ret = iw_cm_disconnect(id_priv->cm_id.iw, 0);
2105 break;
e51060f0 2106 default:
07ebafba 2107 ret = -EINVAL;
e51060f0
SH		 2108 break;
2109 }
2110out:
2111 return ret;
2112}
2113EXPORT_SYMBOL(rdma_disconnect);
2114
2115static void cma_add_one(struct ib_device *device)
2116{
2117 struct cma_device *cma_dev;
2118 struct rdma_id_private *id_priv;
2119
2120 cma_dev = kmalloc(sizeof *cma_dev, GFP_KERNEL);
2121 if (!cma_dev)
2122 return;
2123
2124 cma_dev->device = device;
2125 cma_dev->node_guid = device->node_guid;
2126 if (!cma_dev->node_guid)
2127 goto err;
2128
2129 init_completion(&cma_dev->comp);
2130 atomic_set(&cma_dev->refcount, 1);
2131 INIT_LIST_HEAD(&cma_dev->id_list);
2132 ib_set_client_data(device, &cma_client, cma_dev);
2133
2134 mutex_lock(&lock);
2135 list_add_tail(&cma_dev->list, &dev_list);
2136 list_for_each_entry(id_priv, &listen_any_list, list)
2137 cma_listen_on_dev(id_priv, cma_dev);
2138 mutex_unlock(&lock);
2139 return;
2140err:
2141 kfree(cma_dev);
2142}
2143
2144static int cma_remove_id_dev(struct rdma_id_private *id_priv)
2145{
2146 enum cma_state state;
2147
2148 /* Record that we want to remove the device */
2149 state = cma_exch(id_priv, CMA_DEVICE_REMOVAL);
2150 if (state == CMA_DESTROYING)
2151 return 0;
2152
2153 cma_cancel_operation(id_priv, state);
2154 wait_event(id_priv->wait_remove, !atomic_read(&id_priv->dev_remove));
2155
2156 /* Check for destruction from another callback. */
2157 if (!cma_comp(id_priv, CMA_DEVICE_REMOVAL))
2158 return 0;
2159
2160 return cma_notify_user(id_priv, RDMA_CM_EVENT_DEVICE_REMOVAL,
2161 0, NULL, 0);
2162}
2163
2164static void cma_process_remove(struct cma_device *cma_dev)
2165{
e51060f0
SH		 2166 struct rdma_id_private *id_priv;
2167 int ret;
2168
e51060f0
SH		 2169 mutex_lock(&lock);
2170 while (!list_empty(&cma_dev->id_list)) {
2171 id_priv = list_entry(cma_dev->id_list.next,
2172 struct rdma_id_private, list);
2173
2174 if (cma_internal_listen(id_priv)) {
2175 cma_destroy_listen(id_priv);
2176 continue;
2177 }
2178
94de178a 2179 list_del_init(&id_priv->list);
e51060f0
SH		 2180 atomic_inc(&id_priv->refcount);
2181 mutex_unlock(&lock);
2182
2183 ret = cma_remove_id_dev(id_priv);
2184 cma_deref_id(id_priv);
2185 if (ret)
2186 rdma_destroy_id(&id_priv->id);
2187
2188 mutex_lock(&lock);
2189 }
2190 mutex_unlock(&lock);
2191
2192 cma_deref_dev(cma_dev);
2193 wait_for_completion(&cma_dev->comp);
2194}
2195
2196static void cma_remove_one(struct ib_device *device)
2197{
2198 struct cma_device *cma_dev;
2199
2200 cma_dev = ib_get_client_data(device, &cma_client);
2201 if (!cma_dev)
2202 return;
2203
2204 mutex_lock(&lock);
2205 list_del(&cma_dev->list);
2206 mutex_unlock(&lock);
2207
2208 cma_process_remove(cma_dev);
2209 kfree(cma_dev);
2210}
2211
2212static int cma_init(void)
2213{
2214 int ret;
2215
2216 cma_wq = create_singlethread_workqueue("rdma_cm_wq");
2217 if (!cma_wq)
2218 return -ENOMEM;
2219
c1a0b23b 2220 ib_sa_register_client(&sa_client);
7a118df3 2221 rdma_addr_register_client(&addr_client);
c1a0b23b 2222
e51060f0
SH		 2223 ret = ib_register_client(&cma_client);
2224 if (ret)
2225 goto err;
2226 return 0;
2227
2228err:
7a118df3 2229 rdma_addr_unregister_client(&addr_client);
c1a0b23b 2230 ib_sa_unregister_client(&sa_client);
e51060f0
SH		 2231 destroy_workqueue(cma_wq);
2232 return ret;
2233}
2234
2235static void cma_cleanup(void)
2236{
2237 ib_unregister_client(&cma_client);
7a118df3 2238 rdma_addr_unregister_client(&addr_client);
c1a0b23b 2239 ib_sa_unregister_client(&sa_client);
e51060f0
SH		 2240 destroy_workqueue(cma_wq);
2241 idr_destroy(&sdp_ps);
2242 idr_destroy(&tcp_ps);
2243}
2244
2245module_init(cma_init);
2246module_exit(cma_cleanup);
kernel source for telekom puls (alcatel/mediatek)