?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge tag 'trace-printf-v6.13' of git://git.kernel.org/pub/scm/linux/kernel/git/trace...
[drm/drm-misc.git] / drivers / infiniband / hw / erdma / erdma_cm.c
blob771059a8eb7d7f76eb38652edbce9bfdb5ee89b3
1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
2
3 /* Authors: Cheng Xu <chengyou@linux.alibaba.com> */
4 /* Kai Shen <kaishen@linux.alibaba.com> */
5 /* Copyright (c) 2020-2022, Alibaba Group. */
6
7 /* Authors: Bernard Metzler <bmt@zurich.ibm.com> */
8 /* Fredy Neeser */
9 /* Greg Joyce <greg@opengridcomputing.com> */
10 /* Copyright (c) 2008-2019, IBM Corporation */
11 /* Copyright (c) 2017, Open Grid Computing, Inc. */
12
13 #include <linux/workqueue.h>
14 #include <trace/events/sock.h>
15
16 #include "erdma.h"
17 #include "erdma_cm.h"
18 #include "erdma_verbs.h"
19
20 static struct workqueue_struct *erdma_cm_wq;
21
22 static void erdma_cm_llp_state_change(struct sock *sk);
23 static void erdma_cm_llp_data_ready(struct sock *sk);
24 static void erdma_cm_llp_error_report(struct sock *sk);
25
26 static void erdma_sk_assign_cm_upcalls(struct sock *sk)
27 {
28 write_lock_bh(&sk->sk_callback_lock);
29 sk->sk_state_change = erdma_cm_llp_state_change;
30 sk->sk_data_ready = erdma_cm_llp_data_ready;
31 sk->sk_error_report = erdma_cm_llp_error_report;
32 write_unlock_bh(&sk->sk_callback_lock);
33 }
34
35 static void erdma_sk_save_upcalls(struct sock *sk)
36 {
37 struct erdma_cep *cep = sk_to_cep(sk);
38
39 write_lock_bh(&sk->sk_callback_lock);
40 cep->sk_state_change = sk->sk_state_change;
41 cep->sk_data_ready = sk->sk_data_ready;
42 cep->sk_error_report = sk->sk_error_report;
43 write_unlock_bh(&sk->sk_callback_lock);
44 }
45
46 static void erdma_sk_restore_upcalls(struct sock *sk, struct erdma_cep *cep)
47 {
48 sk->sk_state_change = cep->sk_state_change;
49 sk->sk_data_ready = cep->sk_data_ready;
50 sk->sk_error_report = cep->sk_error_report;
51 sk->sk_user_data = NULL;
52 }
53
54 static void erdma_socket_disassoc(struct socket *s)
55 {
56 struct sock *sk = s->sk;
57 struct erdma_cep *cep;
58
59 if (sk) {
60 write_lock_bh(&sk->sk_callback_lock);
61 cep = sk_to_cep(sk);
62 if (cep) {
63 erdma_sk_restore_upcalls(sk, cep);
64 erdma_cep_put(cep);
65 } else {
66 WARN_ON_ONCE(1);
67 }
68 write_unlock_bh(&sk->sk_callback_lock);
69 } else {
70 WARN_ON_ONCE(1);
71 }
72 }
73
74 static void erdma_cep_socket_assoc(struct erdma_cep *cep, struct socket *s)
75 {
76 cep->sock = s;
77 erdma_cep_get(cep);
78 s->sk->sk_user_data = cep;
79
80 erdma_sk_save_upcalls(s->sk);
81 erdma_sk_assign_cm_upcalls(s->sk);
82 }
83
84 static void erdma_disassoc_listen_cep(struct erdma_cep *cep)
85 {
86 if (cep->listen_cep) {
87 erdma_cep_put(cep->listen_cep);
88 cep->listen_cep = NULL;
89 }
90 }
91
92 static struct erdma_cep *erdma_cep_alloc(struct erdma_dev *dev)
93 {
94 struct erdma_cep *cep = kzalloc(sizeof(*cep), GFP_KERNEL);
95 unsigned long flags;
96
97 if (!cep)
98 return NULL;
99
100 INIT_LIST_HEAD(&cep->listenq);
101 INIT_LIST_HEAD(&cep->devq);
102 INIT_LIST_HEAD(&cep->work_freelist);
103
104 kref_init(&cep->ref);
105 cep->state = ERDMA_EPSTATE_IDLE;
106 init_waitqueue_head(&cep->waitq);
107 spin_lock_init(&cep->lock);
108 cep->dev = dev;
109
110 spin_lock_irqsave(&dev->lock, flags);
111 list_add_tail(&cep->devq, &dev->cep_list);
112 spin_unlock_irqrestore(&dev->lock, flags);
113
114 return cep;
115 }
116
117 static void erdma_cm_free_work(struct erdma_cep *cep)
118 {
119 struct list_head *w, *tmp;
120 struct erdma_cm_work *work;
121
122 list_for_each_safe(w, tmp, &cep->work_freelist) {
123 work = list_entry(w, struct erdma_cm_work, list);
124 list_del(&work->list);
125 kfree(work);
126 }
127 }
128
129 static void erdma_cancel_mpatimer(struct erdma_cep *cep)
130 {
131 spin_lock_bh(&cep->lock);
132 if (cep->mpa_timer) {
133 if (cancel_delayed_work(&cep->mpa_timer->work)) {
134 erdma_cep_put(cep);
135 kfree(cep->mpa_timer);
136 }
137 cep->mpa_timer = NULL;
138 }
139 spin_unlock_bh(&cep->lock);
140 }
141
142 static void erdma_put_work(struct erdma_cm_work *work)
143 {
144 INIT_LIST_HEAD(&work->list);
145 spin_lock_bh(&work->cep->lock);
146 list_add(&work->list, &work->cep->work_freelist);
147 spin_unlock_bh(&work->cep->lock);
148 }
149
150 static void erdma_cep_set_inuse(struct erdma_cep *cep)
151 {
152 unsigned long flags;
153
154 spin_lock_irqsave(&cep->lock, flags);
155 while (cep->in_use) {
156 spin_unlock_irqrestore(&cep->lock, flags);
157 wait_event_interruptible(cep->waitq, !cep->in_use);
158 if (signal_pending(current))
159 flush_signals(current);
160
161 spin_lock_irqsave(&cep->lock, flags);
162 }
163
164 cep->in_use = 1;
165 spin_unlock_irqrestore(&cep->lock, flags);
166 }
167
168 static void erdma_cep_set_free(struct erdma_cep *cep)
169 {
170 unsigned long flags;
171
172 spin_lock_irqsave(&cep->lock, flags);
173 cep->in_use = 0;
174 spin_unlock_irqrestore(&cep->lock, flags);
175
176 wake_up(&cep->waitq);
177 }
178
179 static void __erdma_cep_dealloc(struct kref *ref)
180 {
181 struct erdma_cep *cep = container_of(ref, struct erdma_cep, ref);
182 struct erdma_dev *dev = cep->dev;
183 unsigned long flags;
184
185 WARN_ON(cep->listen_cep);
186
187 kfree(cep->private_data);
188 kfree(cep->mpa.pdata);
189 spin_lock_bh(&cep->lock);
190 if (!list_empty(&cep->work_freelist))
191 erdma_cm_free_work(cep);
192 spin_unlock_bh(&cep->lock);
193
194 spin_lock_irqsave(&dev->lock, flags);
195 list_del(&cep->devq);
196 spin_unlock_irqrestore(&dev->lock, flags);
197 kfree(cep);
198 }
199
200 static struct erdma_cm_work *erdma_get_work(struct erdma_cep *cep)
201 {
202 struct erdma_cm_work *work = NULL;
203
204 spin_lock_bh(&cep->lock);
205 if (!list_empty(&cep->work_freelist)) {
206 work = list_entry(cep->work_freelist.next, struct erdma_cm_work,
207 list);
208 list_del_init(&work->list);
209 }
210
211 spin_unlock_bh(&cep->lock);
212 return work;
213 }
214
215 static int erdma_cm_alloc_work(struct erdma_cep *cep, int num)
216 {
217 struct erdma_cm_work *work;
218
219 while (num--) {
220 work = kmalloc(sizeof(*work), GFP_KERNEL);
221 if (!work) {
222 if (!(list_empty(&cep->work_freelist)))
223 erdma_cm_free_work(cep);
224 return -ENOMEM;
225 }
226 work->cep = cep;
227 INIT_LIST_HEAD(&work->list);
228 list_add(&work->list, &cep->work_freelist);
229 }
230
231 return 0;
232 }
233
234 static int erdma_cm_upcall(struct erdma_cep *cep, enum iw_cm_event_type reason,
235 int status)
236 {
237 struct iw_cm_event event;
238 struct iw_cm_id *cm_id;
239
240 memset(&event, 0, sizeof(event));
241 event.status = status;
242 event.event = reason;
243
244 if (reason == IW_CM_EVENT_CONNECT_REQUEST) {
245 event.provider_data = cep;
246 cm_id = cep->listen_cep->cm_id;
247
248 event.ird = cep->dev->attrs.max_ird;
249 event.ord = cep->dev->attrs.max_ord;
250 } else {
251 cm_id = cep->cm_id;
252 }
253
254 if (reason == IW_CM_EVENT_CONNECT_REQUEST ||
255 reason == IW_CM_EVENT_CONNECT_REPLY) {
256 u16 pd_len = be16_to_cpu(cep->mpa.hdr.params.pd_len);
257
258 if (pd_len && cep->mpa.pdata) {
259 event.private_data_len = pd_len;
260 event.private_data = cep->mpa.pdata;
261 }
262
263 getname_local(cep->sock, &event.local_addr);
264 getname_peer(cep->sock, &event.remote_addr);
265 }
266
267 return cm_id->event_handler(cm_id, &event);
268 }
269
270 void erdma_qp_cm_drop(struct erdma_qp *qp)
271 {
272 struct erdma_cep *cep = qp->cep;
273
274 if (!qp->cep)
275 return;
276
277 erdma_cep_set_inuse(cep);
278
279 /* already closed. */
280 if (cep->state == ERDMA_EPSTATE_CLOSED)
281 goto out;
282
283 if (cep->cm_id) {
284 switch (cep->state) {
285 case ERDMA_EPSTATE_AWAIT_MPAREP:
286 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY,
287 -EINVAL);
288 break;
289 case ERDMA_EPSTATE_RDMA_MODE:
290 erdma_cm_upcall(cep, IW_CM_EVENT_CLOSE, 0);
291 break;
292 case ERDMA_EPSTATE_IDLE:
293 case ERDMA_EPSTATE_LISTENING:
294 case ERDMA_EPSTATE_CONNECTING:
295 case ERDMA_EPSTATE_AWAIT_MPAREQ:
296 case ERDMA_EPSTATE_RECVD_MPAREQ:
297 case ERDMA_EPSTATE_CLOSED:
298 default:
299 break;
300 }
301 cep->cm_id->rem_ref(cep->cm_id);
302 cep->cm_id = NULL;
303 erdma_cep_put(cep);
304 }
305 cep->state = ERDMA_EPSTATE_CLOSED;
306
307 if (cep->sock) {
308 erdma_socket_disassoc(cep->sock);
309 sock_release(cep->sock);
310 cep->sock = NULL;
311 }
312
313 if (cep->qp) {
314 cep->qp = NULL;
315 erdma_qp_put(qp);
316 }
317 out:
318 erdma_cep_set_free(cep);
319 }
320
321 void erdma_cep_put(struct erdma_cep *cep)
322 {
323 WARN_ON(kref_read(&cep->ref) < 1);
324 kref_put(&cep->ref, __erdma_cep_dealloc);
325 }
326
327 void erdma_cep_get(struct erdma_cep *cep)
328 {
329 kref_get(&cep->ref);
330 }
331
332 static int erdma_send_mpareqrep(struct erdma_cep *cep, const void *pdata,
333 u8 pd_len)
334 {
335 struct socket *s = cep->sock;
336 struct mpa_rr *rr = &cep->mpa.hdr;
337 struct kvec iov[3];
338 struct msghdr msg;
339 int iovec_num = 0;
340 int ret;
341 int mpa_len;
342
343 memset(&msg, 0, sizeof(msg));
344
345 rr->params.pd_len = cpu_to_be16(pd_len);
346
347 iov[iovec_num].iov_base = rr;
348 iov[iovec_num].iov_len = sizeof(*rr);
349 iovec_num++;
350 mpa_len = sizeof(*rr);
351
352 iov[iovec_num].iov_base = &cep->mpa.ext_data;
353 iov[iovec_num].iov_len = sizeof(cep->mpa.ext_data);
354 iovec_num++;
355 mpa_len += sizeof(cep->mpa.ext_data);
356
357 if (pd_len) {
358 iov[iovec_num].iov_base = (char *)pdata;
359 iov[iovec_num].iov_len = pd_len;
360 mpa_len += pd_len;
361 iovec_num++;
362 }
363
364 ret = kernel_sendmsg(s, &msg, iov, iovec_num, mpa_len);
365
366 return ret < 0 ? ret : 0;
367 }
368
369 static inline int ksock_recv(struct socket *sock, char *buf, size_t size,
370 int flags)
371 {
372 struct kvec iov = { buf, size };
373 struct msghdr msg = { .msg_name = NULL, .msg_flags = flags };
374
375 return kernel_recvmsg(sock, &msg, &iov, 1, size, flags);
376 }
377
378 static int __recv_mpa_hdr(struct erdma_cep *cep, int hdr_rcvd, char *hdr,
379 int hdr_size, int *rcvd_out)
380 {
381 struct socket *s = cep->sock;
382 int rcvd;
383
384 *rcvd_out = 0;
385 if (hdr_rcvd < hdr_size) {
386 rcvd = ksock_recv(s, hdr + hdr_rcvd, hdr_size - hdr_rcvd,
387 MSG_DONTWAIT);
388 if (rcvd == -EAGAIN)
389 return -EAGAIN;
390
391 if (rcvd <= 0)
392 return -ECONNABORTED;
393
394 hdr_rcvd += rcvd;
395 *rcvd_out = rcvd;
396
397 if (hdr_rcvd < hdr_size)
398 return -EAGAIN;
399 }
400
401 return 0;
402 }
403
404 static void __mpa_rr_set_revision(__be16 *bits, u8 rev)
405 {
406 *bits = (*bits & ~MPA_RR_MASK_REVISION) |
407 (cpu_to_be16(rev) & MPA_RR_MASK_REVISION);
408 }
409
410 static u8 __mpa_rr_revision(__be16 mpa_rr_bits)
411 {
412 __be16 rev = mpa_rr_bits & MPA_RR_MASK_REVISION;
413
414 return (u8)be16_to_cpu(rev);
415 }
416
417 static void __mpa_ext_set_cc(__be32 *bits, u32 cc)
418 {
419 *bits = (*bits & ~MPA_EXT_FLAG_CC) |
420 (cpu_to_be32(cc) & MPA_EXT_FLAG_CC);
421 }
422
423 static u8 __mpa_ext_cc(__be32 mpa_ext_bits)
424 {
425 __be32 cc = mpa_ext_bits & MPA_EXT_FLAG_CC;
426
427 return (u8)be32_to_cpu(cc);
428 }
429
430 /*
431 * Receive MPA Request/Reply header.
432 *
433 * Returns 0 if complete MPA Request/Reply haeder including
434 * eventual private data was received. Returns -EAGAIN if
435 * header was partially received or negative error code otherwise.
436 *
437 * Context: May be called in process context only
438 */
439 static int erdma_recv_mpa_rr(struct erdma_cep *cep)
440 {
441 struct mpa_rr *hdr = &cep->mpa.hdr;
442 struct socket *s = cep->sock;
443 u16 pd_len;
444 int rcvd, to_rcv, ret, pd_rcvd;
445
446 if (cep->mpa.bytes_rcvd < sizeof(struct mpa_rr)) {
447 ret = __recv_mpa_hdr(cep, cep->mpa.bytes_rcvd,
448 (char *)&cep->mpa.hdr,
449 sizeof(struct mpa_rr), &rcvd);
450 cep->mpa.bytes_rcvd += rcvd;
451 if (ret)
452 return ret;
453 }
454
455 if (be16_to_cpu(hdr->params.pd_len) > MPA_MAX_PRIVDATA ||
456 __mpa_rr_revision(hdr->params.bits) != MPA_REVISION_EXT_1)
457 return -EPROTO;
458
459 if (cep->mpa.bytes_rcvd - sizeof(struct mpa_rr) <
460 sizeof(struct erdma_mpa_ext)) {
461 ret = __recv_mpa_hdr(
462 cep, cep->mpa.bytes_rcvd - sizeof(struct mpa_rr),
463 (char *)&cep->mpa.ext_data,
464 sizeof(struct erdma_mpa_ext), &rcvd);
465 cep->mpa.bytes_rcvd += rcvd;
466 if (ret)
467 return ret;
468 }
469
470 pd_len = be16_to_cpu(hdr->params.pd_len);
471 pd_rcvd = cep->mpa.bytes_rcvd - sizeof(struct mpa_rr) -
472 sizeof(struct erdma_mpa_ext);
473 to_rcv = pd_len - pd_rcvd;
474
475 if (!to_rcv) {
476 /*
477 * We have received the whole MPA Request/Reply message.
478 * Check against peer protocol violation.
479 */
480 u32 word;
481
482 ret = __recv_mpa_hdr(cep, 0, (char *)&word, sizeof(word),
483 &rcvd);
484 if (ret == -EAGAIN && rcvd == 0)
485 return 0;
486
487 if (ret)
488 return ret;
489
490 return -EPROTO;
491 }
492
493 /*
494 * At this point, MPA header has been fully received, and pd_len != 0.
495 * So, begin to receive private data.
496 */
497 if (!cep->mpa.pdata) {
498 cep->mpa.pdata = kmalloc(pd_len + 4, GFP_KERNEL);
499 if (!cep->mpa.pdata)
500 return -ENOMEM;
501 }
502
503 rcvd = ksock_recv(s, cep->mpa.pdata + pd_rcvd, to_rcv + 4,
504 MSG_DONTWAIT);
505 if (rcvd < 0)
506 return rcvd;
507
508 if (rcvd > to_rcv)
509 return -EPROTO;
510
511 cep->mpa.bytes_rcvd += rcvd;
512
513 if (to_rcv == rcvd)
514 return 0;
515
516 return -EAGAIN;
517 }
518
519 /*
520 * erdma_proc_mpareq()
521 *
522 * Read MPA Request from socket and signal new connection to IWCM
523 * if success. Caller must hold lock on corresponding listening CEP.
524 */
525 static int erdma_proc_mpareq(struct erdma_cep *cep)
526 {
527 struct mpa_rr *req;
528 int ret;
529
530 ret = erdma_recv_mpa_rr(cep);
531 if (ret)
532 return ret;
533
534 req = &cep->mpa.hdr;
535
536 if (memcmp(req->key, MPA_KEY_REQ, MPA_KEY_SIZE))
537 return -EPROTO;
538
539 memcpy(req->key, MPA_KEY_REP, MPA_KEY_SIZE);
540
541 /* Currently does not support marker and crc. */
542 if (req->params.bits & MPA_RR_FLAG_MARKERS ||
543 req->params.bits & MPA_RR_FLAG_CRC)
544 goto reject_conn;
545
546 cep->state = ERDMA_EPSTATE_RECVD_MPAREQ;
547
548 /* Keep reference until IWCM accepts/rejects */
549 erdma_cep_get(cep);
550 ret = erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REQUEST, 0);
551 if (ret)
552 erdma_cep_put(cep);
553
554 return ret;
555
556 reject_conn:
557 req->params.bits &= ~MPA_RR_FLAG_MARKERS;
558 req->params.bits |= MPA_RR_FLAG_REJECT;
559 req->params.bits &= ~MPA_RR_FLAG_CRC;
560
561 kfree(cep->mpa.pdata);
562 cep->mpa.pdata = NULL;
563 erdma_send_mpareqrep(cep, NULL, 0);
564
565 return -EOPNOTSUPP;
566 }
567
568 static int erdma_proc_mpareply(struct erdma_cep *cep)
569 {
570 struct erdma_qp_attrs qp_attrs;
571 struct erdma_qp *qp = cep->qp;
572 struct mpa_rr *rep;
573 int ret;
574
575 ret = erdma_recv_mpa_rr(cep);
576 if (ret)
577 goto out_err;
578
579 erdma_cancel_mpatimer(cep);
580
581 rep = &cep->mpa.hdr;
582
583 if (memcmp(rep->key, MPA_KEY_REP, MPA_KEY_SIZE)) {
584 ret = -EPROTO;
585 goto out_err;
586 }
587
588 if (rep->params.bits & MPA_RR_FLAG_REJECT) {
589 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY, -ECONNRESET);
590 return -ECONNRESET;
591 }
592
593 /* Currently does not support marker and crc. */
594 if ((rep->params.bits & MPA_RR_FLAG_MARKERS) ||
595 (rep->params.bits & MPA_RR_FLAG_CRC)) {
596 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY, -ECONNREFUSED);
597 return -EINVAL;
598 }
599
600 memset(&qp_attrs, 0, sizeof(qp_attrs));
601 qp_attrs.irq_size = cep->ird;
602 qp_attrs.orq_size = cep->ord;
603 qp_attrs.state = ERDMA_QP_STATE_RTS;
604
605 down_write(&qp->state_lock);
606 if (qp->attrs.state > ERDMA_QP_STATE_RTR) {
607 ret = -EINVAL;
608 up_write(&qp->state_lock);
609 goto out_err;
610 }
611
612 qp->attrs.qp_type = ERDMA_QP_ACTIVE;
613 if (__mpa_ext_cc(cep->mpa.ext_data.bits) != qp->attrs.cc)
614 qp->attrs.cc = COMPROMISE_CC;
615
616 ret = erdma_modify_qp_internal(qp, &qp_attrs,
617 ERDMA_QP_ATTR_STATE |
618 ERDMA_QP_ATTR_LLP_HANDLE |
619 ERDMA_QP_ATTR_MPA);
620
621 up_write(&qp->state_lock);
622
623 if (!ret) {
624 ret = erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY, 0);
625 if (!ret)
626 cep->state = ERDMA_EPSTATE_RDMA_MODE;
627
628 return 0;
629 }
630
631 out_err:
632 if (ret != -EAGAIN)
633 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY, -EINVAL);
634
635 return ret;
636 }
637
638 static void erdma_accept_newconn(struct erdma_cep *cep)
639 {
640 struct socket *s = cep->sock;
641 struct socket *new_s = NULL;
642 struct erdma_cep *new_cep = NULL;
643 int ret = 0;
644
645 if (cep->state != ERDMA_EPSTATE_LISTENING)
646 goto error;
647
648 new_cep = erdma_cep_alloc(cep->dev);
649 if (!new_cep)
650 goto error;
651
652 /*
653 * 4: Allocate a sufficient number of work elements
654 * to allow concurrent handling of local + peer close
655 * events, MPA header processing + MPA timeout.
656 */
657 if (erdma_cm_alloc_work(new_cep, 4) != 0)
658 goto error;
659
660 /*
661 * Copy saved socket callbacks from listening CEP
662 * and assign new socket with new CEP
663 */
664 new_cep->sk_state_change = cep->sk_state_change;
665 new_cep->sk_data_ready = cep->sk_data_ready;
666 new_cep->sk_error_report = cep->sk_error_report;
667
668 ret = kernel_accept(s, &new_s, O_NONBLOCK);
669 if (ret != 0)
670 goto error;
671
672 new_cep->sock = new_s;
673 erdma_cep_get(new_cep);
674 new_s->sk->sk_user_data = new_cep;
675
676 tcp_sock_set_nodelay(new_s->sk);
677 new_cep->state = ERDMA_EPSTATE_AWAIT_MPAREQ;
678
679 ret = erdma_cm_queue_work(new_cep, ERDMA_CM_WORK_MPATIMEOUT);
680 if (ret)
681 goto error;
682
683 new_cep->listen_cep = cep;
684 erdma_cep_get(cep);
685
686 if (atomic_read(&new_s->sk->sk_rmem_alloc)) {
687 /* MPA REQ already queued */
688 erdma_cep_set_inuse(new_cep);
689 ret = erdma_proc_mpareq(new_cep);
690 if (ret != -EAGAIN) {
691 erdma_cep_put(cep);
692 new_cep->listen_cep = NULL;
693 if (ret) {
694 erdma_cep_set_free(new_cep);
695 goto error;
696 }
697 }
698 erdma_cep_set_free(new_cep);
699 }
700 return;
701
702 error:
703 if (new_cep) {
704 new_cep->state = ERDMA_EPSTATE_CLOSED;
705 erdma_cancel_mpatimer(new_cep);
706
707 erdma_cep_put(new_cep);
708 new_cep->sock = NULL;
709 }
710
711 if (new_s) {
712 erdma_socket_disassoc(new_s);
713 sock_release(new_s);
714 }
715 }
716
717 static int erdma_newconn_connected(struct erdma_cep *cep)
718 {
719 int ret = 0;
720
721 cep->mpa.hdr.params.bits = 0;
722 __mpa_rr_set_revision(&cep->mpa.hdr.params.bits, MPA_REVISION_EXT_1);
723
724 memcpy(cep->mpa.hdr.key, MPA_KEY_REQ, MPA_KEY_SIZE);
725 cep->mpa.ext_data.cookie = cpu_to_be32(cep->qp->attrs.cookie);
726 __mpa_ext_set_cc(&cep->mpa.ext_data.bits, cep->qp->attrs.cc);
727
728 ret = erdma_send_mpareqrep(cep, cep->private_data, cep->pd_len);
729 cep->state = ERDMA_EPSTATE_AWAIT_MPAREP;
730 cep->mpa.hdr.params.pd_len = 0;
731
732 if (ret >= 0)
733 ret = erdma_cm_queue_work(cep, ERDMA_CM_WORK_MPATIMEOUT);
734
735 return ret;
736 }
737
738 static void erdma_cm_work_handler(struct work_struct *w)
739 {
740 struct erdma_cm_work *work;
741 struct erdma_cep *cep;
742 int release_cep = 0, ret = 0;
743
744 work = container_of(w, struct erdma_cm_work, work.work);
745 cep = work->cep;
746
747 erdma_cep_set_inuse(cep);
748
749 switch (work->type) {
750 case ERDMA_CM_WORK_CONNECTED:
751 erdma_cancel_mpatimer(cep);
752 if (cep->state == ERDMA_EPSTATE_CONNECTING) {
753 ret = erdma_newconn_connected(cep);
754 if (ret) {
755 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY,
756 -EIO);
757 release_cep = 1;
758 }
759 }
760 break;
761 case ERDMA_CM_WORK_CONNECTTIMEOUT:
762 if (cep->state == ERDMA_EPSTATE_CONNECTING) {
763 cep->mpa_timer = NULL;
764 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY,
765 -ETIMEDOUT);
766 release_cep = 1;
767 }
768 break;
769 case ERDMA_CM_WORK_ACCEPT:
770 erdma_accept_newconn(cep);
771 break;
772 case ERDMA_CM_WORK_READ_MPAHDR:
773 if (cep->state == ERDMA_EPSTATE_AWAIT_MPAREQ) {
774 if (cep->listen_cep) {
775 erdma_cep_set_inuse(cep->listen_cep);
776
777 if (cep->listen_cep->state ==
778 ERDMA_EPSTATE_LISTENING)
779 ret = erdma_proc_mpareq(cep);
780 else
781 ret = -EFAULT;
782
783 erdma_cep_set_free(cep->listen_cep);
784
785 if (ret != -EAGAIN) {
786 erdma_cep_put(cep->listen_cep);
787 cep->listen_cep = NULL;
788 if (ret)
789 erdma_cep_put(cep);
790 }
791 }
792 } else if (cep->state == ERDMA_EPSTATE_AWAIT_MPAREP) {
793 ret = erdma_proc_mpareply(cep);
794 }
795
796 if (ret && ret != -EAGAIN)
797 release_cep = 1;
798 break;
799 case ERDMA_CM_WORK_CLOSE_LLP:
800 if (cep->cm_id)
801 erdma_cm_upcall(cep, IW_CM_EVENT_CLOSE, 0);
802 release_cep = 1;
803 break;
804 case ERDMA_CM_WORK_PEER_CLOSE:
805 if (cep->cm_id) {
806 if (cep->state == ERDMA_EPSTATE_CONNECTING ||
807 cep->state == ERDMA_EPSTATE_AWAIT_MPAREP) {
808 /*
809 * MPA reply not received, but connection drop
810 */
811 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY,
812 -ECONNRESET);
813 } else if (cep->state == ERDMA_EPSTATE_RDMA_MODE) {
814 /*
815 * NOTE: IW_CM_EVENT_DISCONNECT is given just
816 * to transition IWCM into CLOSING.
817 */
818 erdma_cm_upcall(cep, IW_CM_EVENT_DISCONNECT, 0);
819 erdma_cm_upcall(cep, IW_CM_EVENT_CLOSE, 0);
820 }
821 } else if (cep->state == ERDMA_EPSTATE_AWAIT_MPAREQ) {
822 /* Socket close before MPA request received. */
823 erdma_disassoc_listen_cep(cep);
824 erdma_cep_put(cep);
825 }
826 release_cep = 1;
827 break;
828 case ERDMA_CM_WORK_MPATIMEOUT:
829 cep->mpa_timer = NULL;
830 if (cep->state == ERDMA_EPSTATE_AWAIT_MPAREP) {
831 /*
832 * MPA request timed out:
833 * Hide any partially received private data and signal
834 * timeout
835 */
836 cep->mpa.hdr.params.pd_len = 0;
837
838 if (cep->cm_id)
839 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY,
840 -ETIMEDOUT);
841 release_cep = 1;
842 } else if (cep->state == ERDMA_EPSTATE_AWAIT_MPAREQ) {
843 /* No MPA req received after peer TCP stream setup. */
844 erdma_disassoc_listen_cep(cep);
845
846 erdma_cep_put(cep);
847 release_cep = 1;
848 }
849 break;
850 default:
851 WARN(1, "Undefined CM work type: %d\n", work->type);
852 }
853
854 if (release_cep) {
855 erdma_cancel_mpatimer(cep);
856 cep->state = ERDMA_EPSTATE_CLOSED;
857 if (cep->qp) {
858 struct erdma_qp *qp = cep->qp;
859 /*
860 * Serialize a potential race with application
861 * closing the QP and calling erdma_qp_cm_drop()
862 */
863 erdma_qp_get(qp);
864 erdma_cep_set_free(cep);
865
866 erdma_qp_llp_close(qp);
867 erdma_qp_put(qp);
868
869 erdma_cep_set_inuse(cep);
870 cep->qp = NULL;
871 erdma_qp_put(qp);
872 }
873
874 if (cep->sock) {
875 erdma_socket_disassoc(cep->sock);
876 sock_release(cep->sock);
877 cep->sock = NULL;
878 }
879
880 if (cep->cm_id) {
881 cep->cm_id->rem_ref(cep->cm_id);
882 cep->cm_id = NULL;
883 if (cep->state != ERDMA_EPSTATE_LISTENING)
884 erdma_cep_put(cep);
885 }
886 }
887 erdma_cep_set_free(cep);
888 erdma_put_work(work);
889 erdma_cep_put(cep);
890 }
891
892 int erdma_cm_queue_work(struct erdma_cep *cep, enum erdma_work_type type)
893 {
894 struct erdma_cm_work *work = erdma_get_work(cep);
895 unsigned long delay = 0;
896
897 if (!work)
898 return -ENOMEM;
899
900 work->type = type;
901 work->cep = cep;
902
903 erdma_cep_get(cep);
904
905 INIT_DELAYED_WORK(&work->work, erdma_cm_work_handler);
906
907 if (type == ERDMA_CM_WORK_MPATIMEOUT) {
908 cep->mpa_timer = work;
909
910 if (cep->state == ERDMA_EPSTATE_AWAIT_MPAREP)
911 delay = MPAREP_TIMEOUT;
912 else
913 delay = MPAREQ_TIMEOUT;
914 } else if (type == ERDMA_CM_WORK_CONNECTTIMEOUT) {
915 cep->mpa_timer = work;
916
917 delay = CONNECT_TIMEOUT;
918 }
919
920 queue_delayed_work(erdma_cm_wq, &work->work, delay);
921
922 return 0;
923 }
924
925 static void erdma_cm_llp_data_ready(struct sock *sk)
926 {
927 struct erdma_cep *cep;
928
929 trace_sk_data_ready(sk);
930
931 read_lock(&sk->sk_callback_lock);
932
933 cep = sk_to_cep(sk);
934 if (!cep)
935 goto out;
936
937 if (cep->state == ERDMA_EPSTATE_AWAIT_MPAREQ ||
938 cep->state == ERDMA_EPSTATE_AWAIT_MPAREP)
939 erdma_cm_queue_work(cep, ERDMA_CM_WORK_READ_MPAHDR);
940
941 out:
942 read_unlock(&sk->sk_callback_lock);
943 }
944
945 static void erdma_cm_llp_error_report(struct sock *sk)
946 {
947 struct erdma_cep *cep = sk_to_cep(sk);
948
949 if (cep)
950 cep->sk_error_report(sk);
951 }
952
953 static void erdma_cm_llp_state_change(struct sock *sk)
954 {
955 struct erdma_cep *cep;
956 void (*orig_state_change)(struct sock *sk);
957
958 read_lock(&sk->sk_callback_lock);
959
960 cep = sk_to_cep(sk);
961 if (!cep) {
962 read_unlock(&sk->sk_callback_lock);
963 return;
964 }
965 orig_state_change = cep->sk_state_change;
966
967 switch (sk->sk_state) {
968 case TCP_ESTABLISHED:
969 if (cep->state == ERDMA_EPSTATE_CONNECTING)
970 erdma_cm_queue_work(cep, ERDMA_CM_WORK_CONNECTED);
971 else
972 erdma_cm_queue_work(cep, ERDMA_CM_WORK_ACCEPT);
973 break;
974 case TCP_CLOSE:
975 case TCP_CLOSE_WAIT:
976 if (cep->state != ERDMA_EPSTATE_LISTENING)
977 erdma_cm_queue_work(cep, ERDMA_CM_WORK_PEER_CLOSE);
978 break;
979 default:
980 break;
981 }
982 read_unlock(&sk->sk_callback_lock);
983 orig_state_change(sk);
984 }
985
986 static int kernel_bindconnect(struct socket *s, struct sockaddr *laddr,
987 int laddrlen, struct sockaddr *raddr,
988 int raddrlen, int flags)
989 {
990 int ret;
991
992 sock_set_reuseaddr(s->sk);
993 ret = s->ops->bind(s, laddr, laddrlen);
994 if (ret)
995 return ret;
996 ret = s->ops->connect(s, raddr, raddrlen, flags);
997 return ret < 0 ? ret : 0;
998 }
999
1000 int erdma_connect(struct iw_cm_id *id, struct iw_cm_conn_param *params)
1001 {
1002 struct erdma_dev *dev = to_edev(id->device);
1003 struct erdma_qp *qp;
1004 struct erdma_cep *cep = NULL;
1005 struct socket *s = NULL;
1006 struct sockaddr *laddr = (struct sockaddr *)&id->m_local_addr;
1007 struct sockaddr *raddr = (struct sockaddr *)&id->m_remote_addr;
1008 u16 pd_len = params->private_data_len;
1009 int ret;
1010
1011 if (pd_len > MPA_MAX_PRIVDATA)
1012 return -EINVAL;
1013
1014 if (params->ird > dev->attrs.max_ird ||
1015 params->ord > dev->attrs.max_ord)
1016 return -EINVAL;
1017
1018 if (laddr->sa_family != AF_INET || raddr->sa_family != AF_INET)
1019 return -EAFNOSUPPORT;
1020
1021 qp = find_qp_by_qpn(dev, params->qpn);
1022 if (!qp)
1023 return -ENOENT;
1024 erdma_qp_get(qp);
1025
1026 ret = sock_create(AF_INET, SOCK_STREAM, IPPROTO_TCP, &s);
1027 if (ret < 0)
1028 goto error_put_qp;
1029
1030 cep = erdma_cep_alloc(dev);
1031 if (!cep) {
1032 ret = -ENOMEM;
1033 goto error_release_sock;
1034 }
1035
1036 erdma_cep_set_inuse(cep);
1037
1038 /* Associate QP with CEP */
1039 erdma_cep_get(cep);
1040 qp->cep = cep;
1041 cep->qp = qp;
1042
1043 /* Associate cm_id with CEP */
1044 id->add_ref(id);
1045 cep->cm_id = id;
1046
1047 /*
1048 * 6: Allocate a sufficient number of work elements
1049 * to allow concurrent handling of local + peer close
1050 * events, MPA header processing + MPA timeout, connected event
1051 * and connect timeout.
1052 */
1053 ret = erdma_cm_alloc_work(cep, 6);
1054 if (ret != 0) {
1055 ret = -ENOMEM;
1056 goto error_release_cep;
1057 }
1058
1059 cep->ird = params->ird;
1060 cep->ord = params->ord;
1061 cep->state = ERDMA_EPSTATE_CONNECTING;
1062
1063 erdma_cep_socket_assoc(cep, s);
1064
1065 if (pd_len) {
1066 cep->pd_len = pd_len;
1067 cep->private_data = kmalloc(pd_len, GFP_KERNEL);
1068 if (!cep->private_data) {
1069 ret = -ENOMEM;
1070 goto error_disassoc;
1071 }
1072
1073 memcpy(cep->private_data, params->private_data,
1074 params->private_data_len);
1075 }
1076
1077 ret = kernel_bindconnect(s, laddr, sizeof(*laddr), raddr,
1078 sizeof(*raddr), O_NONBLOCK);
1079 if (ret != -EINPROGRESS && ret != 0) {
1080 goto error_disassoc;
1081 } else if (ret == 0) {
1082 ret = erdma_cm_queue_work(cep, ERDMA_CM_WORK_CONNECTED);
1083 if (ret)
1084 goto error_disassoc;
1085 } else {
1086 ret = erdma_cm_queue_work(cep, ERDMA_CM_WORK_CONNECTTIMEOUT);
1087 if (ret)
1088 goto error_disassoc;
1089 }
1090
1091 erdma_cep_set_free(cep);
1092 return 0;
1093
1094 error_disassoc:
1095 kfree(cep->private_data);
1096 cep->private_data = NULL;
1097 cep->pd_len = 0;
1098
1099 erdma_socket_disassoc(s);
1100
1101 error_release_cep:
1102 /* disassoc with cm_id */
1103 cep->cm_id = NULL;
1104 id->rem_ref(id);
1105
1106 /* disassoc with qp */
1107 qp->cep = NULL;
1108 erdma_cep_put(cep);
1109 cep->qp = NULL;
1110
1111 cep->state = ERDMA_EPSTATE_CLOSED;
1112
1113 erdma_cep_set_free(cep);
1114
1115 /* release the cep. */
1116 erdma_cep_put(cep);
1117
1118 error_release_sock:
1119 if (s)
1120 sock_release(s);
1121 error_put_qp:
1122 erdma_qp_put(qp);
1123
1124 return ret;
1125 }
1126
1127 int erdma_accept(struct iw_cm_id *id, struct iw_cm_conn_param *params)
1128 {
1129 struct erdma_dev *dev = to_edev(id->device);
1130 struct erdma_cep *cep = (struct erdma_cep *)id->provider_data;
1131 struct erdma_qp *qp;
1132 struct erdma_qp_attrs qp_attrs;
1133 int ret;
1134
1135 erdma_cep_set_inuse(cep);
1136 erdma_cep_put(cep);
1137
1138 /* Free lingering inbound private data */
1139 if (cep->mpa.hdr.params.pd_len) {
1140 cep->mpa.hdr.params.pd_len = 0;
1141 kfree(cep->mpa.pdata);
1142 cep->mpa.pdata = NULL;
1143 }
1144 erdma_cancel_mpatimer(cep);
1145
1146 if (cep->state != ERDMA_EPSTATE_RECVD_MPAREQ) {
1147 erdma_cep_set_free(cep);
1148 erdma_cep_put(cep);
1149
1150 return -ECONNRESET;
1151 }
1152
1153 qp = find_qp_by_qpn(dev, params->qpn);
1154 if (!qp)
1155 return -ENOENT;
1156 erdma_qp_get(qp);
1157
1158 down_write(&qp->state_lock);
1159 if (qp->attrs.state > ERDMA_QP_STATE_RTR) {
1160 ret = -EINVAL;
1161 up_write(&qp->state_lock);
1162 goto error;
1163 }
1164
1165 if (params->ord > dev->attrs.max_ord ||
1166 params->ird > dev->attrs.max_ord) {
1167 ret = -EINVAL;
1168 up_write(&qp->state_lock);
1169 goto error;
1170 }
1171
1172 if (params->private_data_len > MPA_MAX_PRIVDATA) {
1173 ret = -EINVAL;
1174 up_write(&qp->state_lock);
1175 goto error;
1176 }
1177
1178 cep->ird = params->ird;
1179 cep->ord = params->ord;
1180
1181 cep->cm_id = id;
1182 id->add_ref(id);
1183
1184 memset(&qp_attrs, 0, sizeof(qp_attrs));
1185 qp_attrs.orq_size = params->ord;
1186 qp_attrs.irq_size = params->ird;
1187
1188 qp_attrs.state = ERDMA_QP_STATE_RTS;
1189
1190 /* Associate QP with CEP */
1191 erdma_cep_get(cep);
1192 qp->cep = cep;
1193 cep->qp = qp;
1194
1195 cep->state = ERDMA_EPSTATE_RDMA_MODE;
1196
1197 qp->attrs.qp_type = ERDMA_QP_PASSIVE;
1198 qp->attrs.pd_len = params->private_data_len;
1199
1200 if (qp->attrs.cc != __mpa_ext_cc(cep->mpa.ext_data.bits))
1201 qp->attrs.cc = COMPROMISE_CC;
1202
1203 /* move to rts */
1204 ret = erdma_modify_qp_internal(qp, &qp_attrs,
1205 ERDMA_QP_ATTR_STATE |
1206 ERDMA_QP_ATTR_ORD |
1207 ERDMA_QP_ATTR_LLP_HANDLE |
1208 ERDMA_QP_ATTR_IRD |
1209 ERDMA_QP_ATTR_MPA);
1210 up_write(&qp->state_lock);
1211
1212 if (ret)
1213 goto error;
1214
1215 cep->mpa.ext_data.bits = 0;
1216 __mpa_ext_set_cc(&cep->mpa.ext_data.bits, qp->attrs.cc);
1217 cep->mpa.ext_data.cookie = cpu_to_be32(cep->qp->attrs.cookie);
1218
1219 ret = erdma_send_mpareqrep(cep, params->private_data,
1220 params->private_data_len);
1221 if (!ret) {
1222 ret = erdma_cm_upcall(cep, IW_CM_EVENT_ESTABLISHED, 0);
1223 if (ret)
1224 goto error;
1225
1226 erdma_cep_set_free(cep);
1227
1228 return 0;
1229 }
1230
1231 error:
1232 erdma_socket_disassoc(cep->sock);
1233 sock_release(cep->sock);
1234 cep->sock = NULL;
1235
1236 cep->state = ERDMA_EPSTATE_CLOSED;
1237
1238 if (cep->cm_id) {
1239 cep->cm_id->rem_ref(id);
1240 cep->cm_id = NULL;
1241 }
1242
1243 if (qp->cep) {
1244 erdma_cep_put(cep);
1245 qp->cep = NULL;
1246 }
1247
1248 cep->qp = NULL;
1249 erdma_qp_put(qp);
1250
1251 erdma_cep_set_free(cep);
1252 erdma_cep_put(cep);
1253
1254 return ret;
1255 }
1256
1257 int erdma_reject(struct iw_cm_id *id, const void *pdata, u8 plen)
1258 {
1259 struct erdma_cep *cep = (struct erdma_cep *)id->provider_data;
1260
1261 erdma_cep_set_inuse(cep);
1262 erdma_cep_put(cep);
1263
1264 erdma_cancel_mpatimer(cep);
1265
1266 if (cep->state != ERDMA_EPSTATE_RECVD_MPAREQ) {
1267 erdma_cep_set_free(cep);
1268 erdma_cep_put(cep);
1269
1270 return -ECONNRESET;
1271 }
1272
1273 if (__mpa_rr_revision(cep->mpa.hdr.params.bits) == MPA_REVISION_EXT_1) {
1274 cep->mpa.hdr.params.bits |= MPA_RR_FLAG_REJECT; /* reject */
1275 erdma_send_mpareqrep(cep, pdata, plen);
1276 }
1277
1278 erdma_socket_disassoc(cep->sock);
1279 sock_release(cep->sock);
1280 cep->sock = NULL;
1281
1282 cep->state = ERDMA_EPSTATE_CLOSED;
1283
1284 erdma_cep_set_free(cep);
1285 erdma_cep_put(cep);
1286
1287 return 0;
1288 }
1289
1290 int erdma_create_listen(struct iw_cm_id *id, int backlog)
1291 {
1292 struct socket *s;
1293 struct erdma_cep *cep = NULL;
1294 int ret = 0;
1295 struct erdma_dev *dev = to_edev(id->device);
1296 int addr_family = id->local_addr.ss_family;
1297 struct sockaddr_in *laddr = &to_sockaddr_in(id->local_addr);
1298
1299 if (addr_family != AF_INET)
1300 return -EAFNOSUPPORT;
1301
1302 ret = sock_create(addr_family, SOCK_STREAM, IPPROTO_TCP, &s);
1303 if (ret < 0)
1304 return ret;
1305
1306 sock_set_reuseaddr(s->sk);
1307
1308 /* For wildcard addr, limit binding to current device only */
1309 if (ipv4_is_zeronet(laddr->sin_addr.s_addr))
1310 s->sk->sk_bound_dev_if = dev->netdev->ifindex;
1311
1312 ret = s->ops->bind(s, (struct sockaddr *)laddr,
1313 sizeof(struct sockaddr_in));
1314 if (ret)
1315 goto error;
1316
1317 cep = erdma_cep_alloc(dev);
1318 if (!cep) {
1319 ret = -ENOMEM;
1320 goto error;
1321 }
1322 erdma_cep_socket_assoc(cep, s);
1323
1324 ret = erdma_cm_alloc_work(cep, backlog);
1325 if (ret)
1326 goto error;
1327
1328 ret = s->ops->listen(s, backlog);
1329 if (ret)
1330 goto error;
1331
1332 cep->cm_id = id;
1333 id->add_ref(id);
1334
1335 if (!id->provider_data) {
1336 id->provider_data =
1337 kmalloc(sizeof(struct list_head), GFP_KERNEL);
1338 if (!id->provider_data) {
1339 ret = -ENOMEM;
1340 goto error;
1341 }
1342 INIT_LIST_HEAD((struct list_head *)id->provider_data);
1343 }
1344
1345 list_add_tail(&cep->listenq, (struct list_head *)id->provider_data);
1346 cep->state = ERDMA_EPSTATE_LISTENING;
1347
1348 return 0;
1349
1350 error:
1351 if (cep) {
1352 erdma_cep_set_inuse(cep);
1353
1354 if (cep->cm_id) {
1355 cep->cm_id->rem_ref(cep->cm_id);
1356 cep->cm_id = NULL;
1357 }
1358 cep->sock = NULL;
1359 erdma_socket_disassoc(s);
1360 cep->state = ERDMA_EPSTATE_CLOSED;
1361
1362 erdma_cep_set_free(cep);
1363 erdma_cep_put(cep);
1364 }
1365 sock_release(s);
1366
1367 return ret;
1368 }
1369
1370 static void erdma_drop_listeners(struct iw_cm_id *id)
1371 {
1372 struct list_head *p, *tmp;
1373 /*
1374 * In case of a wildcard rdma_listen on a multi-homed device,
1375 * a listener's IWCM id is associated with more than one listening CEP.
1376 */
1377 list_for_each_safe(p, tmp, (struct list_head *)id->provider_data) {
1378 struct erdma_cep *cep =
1379 list_entry(p, struct erdma_cep, listenq);
1380
1381 list_del(p);
1382
1383 erdma_cep_set_inuse(cep);
1384
1385 if (cep->cm_id) {
1386 cep->cm_id->rem_ref(cep->cm_id);
1387 cep->cm_id = NULL;
1388 }
1389 if (cep->sock) {
1390 erdma_socket_disassoc(cep->sock);
1391 sock_release(cep->sock);
1392 cep->sock = NULL;
1393 }
1394 cep->state = ERDMA_EPSTATE_CLOSED;
1395 erdma_cep_set_free(cep);
1396 erdma_cep_put(cep);
1397 }
1398 }
1399
1400 int erdma_destroy_listen(struct iw_cm_id *id)
1401 {
1402 if (!id->provider_data)
1403 return 0;
1404
1405 erdma_drop_listeners(id);
1406 kfree(id->provider_data);
1407 id->provider_data = NULL;
1408
1409 return 0;
1410 }
1411
1412 int erdma_cm_init(void)
1413 {
1414 erdma_cm_wq = create_singlethread_workqueue("erdma_cm_wq");
1415 if (!erdma_cm_wq)
1416 return -ENOMEM;
1417
1418 return 0;
1419 }
1420
1421 void erdma_cm_exit(void)
1422 {
1423 if (erdma_cm_wq)
1424 destroy_workqueue(erdma_cm_wq);
1425 }
Kernel DRM miscellaneous fixes and cross-tree changes