Lines Matching refs:cep
37 struct erdma_cep *cep = sk_to_cep(sk);
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;
46 static void erdma_sk_restore_upcalls(struct sock *sk, struct erdma_cep *cep)
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;
57 struct erdma_cep *cep;
61 cep = sk_to_cep(sk);
62 if (cep) {
63 erdma_sk_restore_upcalls(sk, cep);
64 erdma_cep_put(cep);
74 static void erdma_cep_socket_assoc(struct erdma_cep *cep, struct socket *s)
76 cep->sock = s;
77 erdma_cep_get(cep);
78 s->sk->sk_user_data = cep;
84 static void erdma_disassoc_listen_cep(struct erdma_cep *cep)
86 if (cep->listen_cep) {
87 erdma_cep_put(cep->listen_cep);
88 cep->listen_cep = NULL;
94 struct erdma_cep *cep = kzalloc(sizeof(*cep), GFP_KERNEL);
97 if (!cep)
100 INIT_LIST_HEAD(&cep->listenq);
101 INIT_LIST_HEAD(&cep->devq);
102 INIT_LIST_HEAD(&cep->work_freelist);
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;
111 list_add_tail(&cep->devq, &dev->cep_list);
114 return cep;
117 static void erdma_cm_free_work(struct erdma_cep *cep)
122 list_for_each_safe(w, tmp, &cep->work_freelist) {
129 static void erdma_cancel_mpatimer(struct erdma_cep *cep)
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);
137 cep->mpa_timer = NULL;
139 spin_unlock_bh(&cep->lock);
145 spin_lock_bh(&work->cep->lock);
146 list_add(&work->list, &work->cep->work_freelist);
147 spin_unlock_bh(&work->cep->lock);
150 static void erdma_cep_set_inuse(struct erdma_cep *cep)
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);
161 spin_lock_irqsave(&cep->lock, flags);
164 cep->in_use = 1;
165 spin_unlock_irqrestore(&cep->lock, flags);
168 static void erdma_cep_set_free(struct erdma_cep *cep)
172 spin_lock_irqsave(&cep->lock, flags);
173 cep->in_use = 0;
174 spin_unlock_irqrestore(&cep->lock, flags);
176 wake_up(&cep->waitq);
181 struct erdma_cep *cep = container_of(ref, struct erdma_cep, ref);
182 struct erdma_dev *dev = cep->dev;
185 WARN_ON(cep->listen_cep);
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);
195 list_del(&cep->devq);
197 kfree(cep);
200 static struct erdma_cm_work *erdma_get_work(struct erdma_cep *cep)
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,
211 spin_unlock_bh(&cep->lock);
215 static int erdma_cm_alloc_work(struct erdma_cep *cep, int num)
222 if (!(list_empty(&cep->work_freelist)))
223 erdma_cm_free_work(cep);
226 work->cep = cep;
228 list_add(&work->list, &cep->work_freelist);
234 static int erdma_cm_upcall(struct erdma_cep *cep, enum iw_cm_event_type reason,
245 event.provider_data = cep;
246 cm_id = cep->listen_cep->cm_id;
248 event.ird = cep->dev->attrs.max_ird;
249 event.ord = cep->dev->attrs.max_ord;
251 cm_id = cep->cm_id;
256 u16 pd_len = be16_to_cpu(cep->mpa.hdr.params.pd_len);
258 if (pd_len && cep->mpa.pdata) {
260 event.private_data = cep->mpa.pdata;
263 getname_local(cep->sock, &event.local_addr);
264 getname_peer(cep->sock, &event.remote_addr);
272 struct erdma_cep *cep = qp->cep;
274 if (!qp->cep)
277 erdma_cep_set_inuse(cep);
280 if (cep->state == ERDMA_EPSTATE_CLOSED)
283 if (cep->cm_id) {
284 switch (cep->state) {
286 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY,
290 erdma_cm_upcall(cep, IW_CM_EVENT_CLOSE, 0);
301 cep->cm_id->rem_ref(cep->cm_id);
302 cep->cm_id = NULL;
303 erdma_cep_put(cep);
305 cep->state = ERDMA_EPSTATE_CLOSED;
307 if (cep->sock) {
308 erdma_socket_disassoc(cep->sock);
309 sock_release(cep->sock);
310 cep->sock = NULL;
313 if (cep->qp) {
314 cep->qp = NULL;
318 erdma_cep_set_free(cep);
321 void erdma_cep_put(struct erdma_cep *cep)
323 WARN_ON(kref_read(&cep->ref) < 1);
324 kref_put(&cep->ref, __erdma_cep_dealloc);
327 void erdma_cep_get(struct erdma_cep *cep)
329 kref_get(&cep->ref);
332 static int erdma_send_mpareqrep(struct erdma_cep *cep, const void *pdata,
335 struct socket *s = cep->sock;
336 struct mpa_rr *rr = &cep->mpa.hdr;
352 iov[iovec_num].iov_base = &cep->mpa.ext_data;
353 iov[iovec_num].iov_len = sizeof(cep->mpa.ext_data);
355 mpa_len += sizeof(cep->mpa.ext_data);
378 static int __recv_mpa_hdr(struct erdma_cep *cep, int hdr_rcvd, char *hdr,
381 struct socket *s = cep->sock;
439 static int erdma_recv_mpa_rr(struct erdma_cep *cep)
441 struct mpa_rr *hdr = &cep->mpa.hdr;
442 struct socket *s = cep->sock;
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,
450 cep->mpa.bytes_rcvd += rcvd;
459 if (cep->mpa.bytes_rcvd - sizeof(struct mpa_rr) <
462 cep, cep->mpa.bytes_rcvd - sizeof(struct mpa_rr),
463 (char *)&cep->mpa.ext_data,
465 cep->mpa.bytes_rcvd += rcvd;
471 pd_rcvd = cep->mpa.bytes_rcvd - sizeof(struct mpa_rr) -
482 ret = __recv_mpa_hdr(cep, 0, (char *)&word, sizeof(word),
497 if (!cep->mpa.pdata) {
498 cep->mpa.pdata = kmalloc(pd_len + 4, GFP_KERNEL);
499 if (!cep->mpa.pdata)
503 rcvd = ksock_recv(s, cep->mpa.pdata + pd_rcvd, to_rcv + 4,
511 cep->mpa.bytes_rcvd += rcvd;
525 static int erdma_proc_mpareq(struct erdma_cep *cep)
530 ret = erdma_recv_mpa_rr(cep);
534 req = &cep->mpa.hdr;
546 cep->state = ERDMA_EPSTATE_RECVD_MPAREQ;
549 erdma_cep_get(cep);
550 ret = erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REQUEST, 0);
552 erdma_cep_put(cep);
561 kfree(cep->mpa.pdata);
562 cep->mpa.pdata = NULL;
563 erdma_send_mpareqrep(cep, NULL, 0);
568 static int erdma_proc_mpareply(struct erdma_cep *cep)
571 struct erdma_qp *qp = cep->qp;
575 ret = erdma_recv_mpa_rr(cep);
579 erdma_cancel_mpatimer(cep);
581 rep = &cep->mpa.hdr;
589 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY, -ECONNRESET);
596 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY, -ECONNREFUSED);
601 qp_attrs.irq_size = cep->ird;
602 qp_attrs.orq_size = cep->ord;
613 if (__mpa_ext_cc(cep->mpa.ext_data.bits) != qp->attrs.cc)
624 ret = erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY, 0);
626 cep->state = ERDMA_EPSTATE_RDMA_MODE;
633 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY, -EINVAL);
638 static void erdma_accept_newconn(struct erdma_cep *cep)
640 struct socket *s = cep->sock;
645 if (cep->state != ERDMA_EPSTATE_LISTENING)
648 new_cep = erdma_cep_alloc(cep->dev);
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;
683 new_cep->listen_cep = cep;
684 erdma_cep_get(cep);
691 erdma_cep_put(cep);
717 static int erdma_newconn_connected(struct erdma_cep *cep)
721 cep->mpa.hdr.params.bits = 0;
722 __mpa_rr_set_revision(&cep->mpa.hdr.params.bits, MPA_REVISION_EXT_1);
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);
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;
733 ret = erdma_cm_queue_work(cep, ERDMA_CM_WORK_MPATIMEOUT);
741 struct erdma_cep *cep;
745 cep = work->cep;
747 erdma_cep_set_inuse(cep);
751 erdma_cancel_mpatimer(cep);
752 if (cep->state == ERDMA_EPSTATE_CONNECTING) {
753 ret = erdma_newconn_connected(cep);
755 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY,
762 if (cep->state == ERDMA_EPSTATE_CONNECTING) {
763 cep->mpa_timer = NULL;
764 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY,
770 erdma_accept_newconn(cep);
773 if (cep->state == ERDMA_EPSTATE_AWAIT_MPAREQ) {
774 if (cep->listen_cep) {
775 erdma_cep_set_inuse(cep->listen_cep);
777 if (cep->listen_cep->state ==
779 ret = erdma_proc_mpareq(cep);
783 erdma_cep_set_free(cep->listen_cep);
786 erdma_cep_put(cep->listen_cep);
787 cep->listen_cep = NULL;
789 erdma_cep_put(cep);
792 } else if (cep->state == ERDMA_EPSTATE_AWAIT_MPAREP) {
793 ret = erdma_proc_mpareply(cep);
800 if (cep->cm_id)
801 erdma_cm_upcall(cep, IW_CM_EVENT_CLOSE, 0);
805 if (cep->cm_id) {
806 if (cep->state == ERDMA_EPSTATE_CONNECTING ||
807 cep->state == ERDMA_EPSTATE_AWAIT_MPAREP) {
811 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY,
813 } else if (cep->state == ERDMA_EPSTATE_RDMA_MODE) {
818 erdma_cm_upcall(cep, IW_CM_EVENT_DISCONNECT, 0);
819 erdma_cm_upcall(cep, IW_CM_EVENT_CLOSE, 0);
821 } else if (cep->state == ERDMA_EPSTATE_AWAIT_MPAREQ) {
823 erdma_disassoc_listen_cep(cep);
824 erdma_cep_put(cep);
829 cep->mpa_timer = NULL;
830 if (cep->state == ERDMA_EPSTATE_AWAIT_MPAREP) {
836 cep->mpa.hdr.params.pd_len = 0;
838 if (cep->cm_id)
839 erdma_cm_upcall(cep, IW_CM_EVENT_CONNECT_REPLY,
842 } else if (cep->state == ERDMA_EPSTATE_AWAIT_MPAREQ) {
844 erdma_disassoc_listen_cep(cep);
846 erdma_cep_put(cep);
855 erdma_cancel_mpatimer(cep);
856 cep->state = ERDMA_EPSTATE_CLOSED;
857 if (cep->qp) {
858 struct erdma_qp *qp = cep->qp;
864 erdma_cep_set_free(cep);
869 erdma_cep_set_inuse(cep);
870 cep->qp = NULL;
874 if (cep->sock) {
875 erdma_socket_disassoc(cep->sock);
876 sock_release(cep->sock);
877 cep->sock = NULL;
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);
887 erdma_cep_set_free(cep);
889 erdma_cep_put(cep);
892 int erdma_cm_queue_work(struct erdma_cep *cep, enum erdma_work_type type)
894 struct erdma_cm_work *work = erdma_get_work(cep);
901 work->cep = cep;
903 erdma_cep_get(cep);
908 cep->mpa_timer = work;
910 if (cep->state == ERDMA_EPSTATE_AWAIT_MPAREP)
915 cep->mpa_timer = work;
927 struct erdma_cep *cep;
933 cep = sk_to_cep(sk);
934 if (!cep)
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);
947 struct erdma_cep *cep = sk_to_cep(sk);
949 if (cep)
950 cep->sk_error_report(sk);
955 struct erdma_cep *cep;
960 cep = sk_to_cep(sk);
961 if (!cep) {
965 orig_state_change = cep->sk_state_change;
969 if (cep->state == ERDMA_EPSTATE_CONNECTING)
970 erdma_cm_queue_work(cep, ERDMA_CM_WORK_CONNECTED);
972 erdma_cm_queue_work(cep, ERDMA_CM_WORK_ACCEPT);
976 if (cep->state != ERDMA_EPSTATE_LISTENING)
977 erdma_cm_queue_work(cep, ERDMA_CM_WORK_PEER_CLOSE);
1004 struct erdma_cep *cep = NULL;
1030 cep = erdma_cep_alloc(dev);
1031 if (!cep) {
1036 erdma_cep_set_inuse(cep);
1039 erdma_cep_get(cep);
1040 qp->cep = cep;
1041 cep->qp = qp;
1045 cep->cm_id = id;
1053 ret = erdma_cm_alloc_work(cep, 6);
1059 cep->ird = params->ird;
1060 cep->ord = params->ord;
1061 cep->state = ERDMA_EPSTATE_CONNECTING;
1063 erdma_cep_socket_assoc(cep, s);
1066 cep->pd_len = pd_len;
1067 cep->private_data = kmalloc(pd_len, GFP_KERNEL);
1068 if (!cep->private_data) {
1073 memcpy(cep->private_data, params->private_data,
1082 ret = erdma_cm_queue_work(cep, ERDMA_CM_WORK_CONNECTED);
1086 ret = erdma_cm_queue_work(cep, ERDMA_CM_WORK_CONNECTTIMEOUT);
1091 erdma_cep_set_free(cep);
1095 kfree(cep->private_data);
1096 cep->private_data = NULL;
1097 cep->pd_len = 0;
1103 cep->cm_id = NULL;
1107 qp->cep = NULL;
1108 erdma_cep_put(cep);
1109 cep->qp = NULL;
1111 cep->state = ERDMA_EPSTATE_CLOSED;
1113 erdma_cep_set_free(cep);
1115 /* release the cep. */
1116 erdma_cep_put(cep);
1130 struct erdma_cep *cep = (struct erdma_cep *)id->provider_data;
1135 erdma_cep_set_inuse(cep);
1136 erdma_cep_put(cep);
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;
1144 erdma_cancel_mpatimer(cep);
1146 if (cep->state != ERDMA_EPSTATE_RECVD_MPAREQ) {
1147 erdma_cep_set_free(cep);
1148 erdma_cep_put(cep);
1178 cep->ird = params->ird;
1179 cep->ord = params->ord;
1181 cep->cm_id = id;
1191 erdma_cep_get(cep);
1192 qp->cep = cep;
1193 cep->qp = qp;
1195 cep->state = ERDMA_EPSTATE_RDMA_MODE;
1200 if (qp->attrs.cc != __mpa_ext_cc(cep->mpa.ext_data.bits))
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);
1219 ret = erdma_send_mpareqrep(cep, params->private_data,
1222 ret = erdma_cm_upcall(cep, IW_CM_EVENT_ESTABLISHED, 0);
1226 erdma_cep_set_free(cep);
1232 erdma_socket_disassoc(cep->sock);
1233 sock_release(cep->sock);
1234 cep->sock = NULL;
1236 cep->state = ERDMA_EPSTATE_CLOSED;
1238 if (cep->cm_id) {
1239 cep->cm_id->rem_ref(id);
1240 cep->cm_id = NULL;
1243 if (qp->cep) {
1244 erdma_cep_put(cep);
1245 qp->cep = NULL;
1248 cep->qp = NULL;
1251 erdma_cep_set_free(cep);
1252 erdma_cep_put(cep);
1259 struct erdma_cep *cep = (struct erdma_cep *)id->provider_data;
1261 erdma_cep_set_inuse(cep);
1262 erdma_cep_put(cep);
1264 erdma_cancel_mpatimer(cep);
1266 if (cep->state != ERDMA_EPSTATE_RECVD_MPAREQ) {
1267 erdma_cep_set_free(cep);
1268 erdma_cep_put(cep);
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);
1278 erdma_socket_disassoc(cep->sock);
1279 sock_release(cep->sock);
1280 cep->sock = NULL;
1282 cep->state = ERDMA_EPSTATE_CLOSED;
1284 erdma_cep_set_free(cep);
1285 erdma_cep_put(cep);
1293 struct erdma_cep *cep = NULL;
1317 cep = erdma_cep_alloc(dev);
1318 if (!cep) {
1322 erdma_cep_socket_assoc(cep, s);
1324 ret = erdma_cm_alloc_work(cep, backlog);
1332 cep->cm_id = id;
1345 list_add_tail(&cep->listenq, (struct list_head *)id->provider_data);
1346 cep->state = ERDMA_EPSTATE_LISTENING;
1351 if (cep) {
1352 erdma_cep_set_inuse(cep);
1354 if (cep->cm_id) {
1355 cep->cm_id->rem_ref(cep->cm_id);
1356 cep->cm_id = NULL;
1358 cep->sock = NULL;
1360 cep->state = ERDMA_EPSTATE_CLOSED;
1362 erdma_cep_set_free(cep);
1363 erdma_cep_put(cep);
1378 struct erdma_cep *cep =
1383 erdma_cep_set_inuse(cep);
1385 if (cep->cm_id) {
1386 cep->cm_id->rem_ref(cep->cm_id);
1387 cep->cm_id = NULL;
1389 if (cep->sock) {
1390 erdma_socket_disassoc(cep->sock);
1391 sock_release(cep->sock);
1392 cep->sock = NULL;
1394 cep->state = ERDMA_EPSTATE_CLOSED;
1395 erdma_cep_set_free(cep);
1396 erdma_cep_put(cep);