Lines Matching +full:smc +full:- +full:id
1 // SPDX-License-Identifier: GPL-2.0-only
3 * Shared Memory Communications over RDMA (SMC-R) and RoCE
7 * offers an alternative communication option for TCP-protocol sockets
8 * applicable with RoCE-cards only
11 * - support for alternate links postponed
19 #define KMSG_COMPONENT "smc"
34 #include <net/smc.h>
41 #include "smc.h"
78 if (cb_ctx->pos[0]) in smc_nl_dump_hs_limitation()
81 hdr = genlmsg_put(skb, NETLINK_CB(cb->skb).portid, cb->nlh->nlmsg_seq, in smc_nl_dump_hs_limitation()
85 return -ENOMEM; in smc_nl_dump_hs_limitation()
88 sock_net(skb->sk)->smc.limit_smc_hs)) in smc_nl_dump_hs_limitation()
92 cb_ctx->pos[0] = 1; in smc_nl_dump_hs_limitation()
94 return skb->len; in smc_nl_dump_hs_limitation()
97 return -EMSGSIZE; in smc_nl_dump_hs_limitation()
102 sock_net(skb->sk)->smc.limit_smc_hs = true; in smc_nl_enable_hs_limitation()
108 sock_net(skb->sk)->smc.limit_smc_hs = false; in smc_nl_disable_hs_limitation()
114 struct smc_sock *smc = smc_sk(sk); in smc_set_keepalive() local
116 smc->clcsock->sk->sk_prot->keepalive(smc->clcsock->sk, val); in smc_set_keepalive()
126 struct smc_sock *smc; in smc_tcp_syn_recv_sock() local
129 smc = smc_clcsock_user_data(sk); in smc_tcp_syn_recv_sock()
131 if (READ_ONCE(sk->sk_ack_backlog) + atomic_read(&smc->queued_smc_hs) > in smc_tcp_syn_recv_sock()
132 sk->sk_max_ack_backlog) in smc_tcp_syn_recv_sock()
135 if (sk_acceptq_is_full(&smc->sk)) { in smc_tcp_syn_recv_sock()
141 child = smc->ori_af_ops->syn_recv_sock(sk, skb, req, dst, req_unhash, in smc_tcp_syn_recv_sock()
143 /* child must not inherit smc or its ops */ in smc_tcp_syn_recv_sock()
147 /* v4-mapped sockets don't inherit parent ops. Don't restore. */ in smc_tcp_syn_recv_sock()
148 if (inet_csk(child)->icsk_af_ops == inet_csk(sk)->icsk_af_ops) in smc_tcp_syn_recv_sock()
149 inet_csk(child)->icsk_af_ops = smc->ori_af_ops; in smc_tcp_syn_recv_sock()
161 const struct smc_sock *smc; in smc_hs_congested() local
163 smc = smc_clcsock_user_data(sk); in smc_hs_congested()
165 if (!smc) in smc_hs_congested()
184 struct smc_hashinfo *h = sk->sk_prot->h.smc_hash; in smc_hash_sk()
187 head = &h->ht; in smc_hash_sk()
189 write_lock_bh(&h->lock); in smc_hash_sk()
191 write_unlock_bh(&h->lock); in smc_hash_sk()
192 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, 1); in smc_hash_sk()
199 struct smc_hashinfo *h = sk->sk_prot->h.smc_hash; in smc_unhash_sk()
201 write_lock_bh(&h->lock); in smc_unhash_sk()
203 sock_prot_inuse_add(sock_net(sk), sk->sk_prot, -1); in smc_unhash_sk()
204 write_unlock_bh(&h->lock); in smc_unhash_sk()
213 struct smc_sock *smc = smc_sk(sk); in smc_release_cb() local
215 if (smc->conn.tx_in_release_sock) { in smc_release_cb()
216 smc_tx_pending(&smc->conn); in smc_release_cb()
217 smc->conn.tx_in_release_sock = false; in smc_release_cb()
222 .name = "SMC",
247 static void smc_fback_restore_callbacks(struct smc_sock *smc) in smc_fback_restore_callbacks() argument
249 struct sock *clcsk = smc->clcsock->sk; in smc_fback_restore_callbacks()
251 write_lock_bh(&clcsk->sk_callback_lock); in smc_fback_restore_callbacks()
252 clcsk->sk_user_data = NULL; in smc_fback_restore_callbacks()
254 smc_clcsock_restore_cb(&clcsk->sk_state_change, &smc->clcsk_state_change); in smc_fback_restore_callbacks()
255 smc_clcsock_restore_cb(&clcsk->sk_data_ready, &smc->clcsk_data_ready); in smc_fback_restore_callbacks()
256 smc_clcsock_restore_cb(&clcsk->sk_write_space, &smc->clcsk_write_space); in smc_fback_restore_callbacks()
257 smc_clcsock_restore_cb(&clcsk->sk_error_report, &smc->clcsk_error_report); in smc_fback_restore_callbacks()
259 write_unlock_bh(&clcsk->sk_callback_lock); in smc_fback_restore_callbacks()
262 static void smc_restore_fallback_changes(struct smc_sock *smc) in smc_restore_fallback_changes() argument
264 if (smc->clcsock->file) { /* non-accepted sockets have no file yet */ in smc_restore_fallback_changes()
265 smc->clcsock->file->private_data = smc->sk.sk_socket; in smc_restore_fallback_changes()
266 smc->clcsock->file = NULL; in smc_restore_fallback_changes()
267 smc_fback_restore_callbacks(smc); in smc_restore_fallback_changes()
271 static int __smc_release(struct smc_sock *smc) in __smc_release() argument
273 struct sock *sk = &smc->sk; in __smc_release()
276 if (!smc->use_fallback) { in __smc_release()
277 rc = smc_close_active(smc); in __smc_release()
279 sk->sk_shutdown |= SHUTDOWN_MASK; in __smc_release()
281 if (sk->sk_state != SMC_CLOSED) { in __smc_release()
282 if (sk->sk_state != SMC_LISTEN && in __smc_release()
283 sk->sk_state != SMC_INIT) in __smc_release()
285 if (sk->sk_state == SMC_LISTEN) { in __smc_release()
287 rc = kernel_sock_shutdown(smc->clcsock, in __smc_release()
290 sk->sk_state = SMC_CLOSED; in __smc_release()
291 sk->sk_state_change(sk); in __smc_release()
293 smc_restore_fallback_changes(smc); in __smc_release()
296 sk->sk_prot->unhash(sk); in __smc_release()
298 if (sk->sk_state == SMC_CLOSED) { in __smc_release()
299 if (smc->clcsock) { in __smc_release()
301 smc_clcsock_release(smc); in __smc_release()
304 if (!smc->use_fallback) in __smc_release()
305 smc_conn_free(&smc->conn); in __smc_release()
313 struct sock *sk = sock->sk; in smc_release()
314 struct smc_sock *smc; in smc_release() local
321 smc = smc_sk(sk); in smc_release()
323 old_state = sk->sk_state; in smc_release()
325 /* cleanup for a dangling non-blocking connect */ in smc_release()
326 if (smc->connect_nonblock && old_state == SMC_INIT) in smc_release()
327 tcp_abort(smc->clcsock->sk, ECONNABORTED); in smc_release()
329 if (cancel_work_sync(&smc->connect_work)) in smc_release()
330 sock_put(&smc->sk); /* sock_hold in smc_connect for passive closing */ in smc_release()
332 if (sk->sk_state == SMC_LISTEN) in smc_release()
340 if (old_state == SMC_INIT && sk->sk_state == SMC_ACTIVE && in smc_release()
341 !smc->use_fallback) in smc_release()
342 smc_close_active_abort(smc); in smc_release()
344 rc = __smc_release(smc); in smc_release()
348 sock->sk = NULL; in smc_release()
359 if (sk->sk_state != SMC_CLOSED) in smc_destruct()
370 struct smc_sock *smc = smc_sk(sk); in smc_sk_init() local
372 sk->sk_state = SMC_INIT; in smc_sk_init()
373 sk->sk_destruct = smc_destruct; in smc_sk_init()
374 sk->sk_protocol = protocol; in smc_sk_init()
375 WRITE_ONCE(sk->sk_sndbuf, 2 * READ_ONCE(net->smc.sysctl_wmem)); in smc_sk_init()
376 WRITE_ONCE(sk->sk_rcvbuf, 2 * READ_ONCE(net->smc.sysctl_rmem)); in smc_sk_init()
377 INIT_WORK(&smc->tcp_listen_work, smc_tcp_listen_work); in smc_sk_init()
378 INIT_WORK(&smc->connect_work, smc_connect_work); in smc_sk_init()
379 INIT_DELAYED_WORK(&smc->conn.tx_work, smc_tx_work); in smc_sk_init()
380 INIT_LIST_HEAD(&smc->accept_q); in smc_sk_init()
381 sock_lock_init_class_and_name(sk, "slock-AF_SMC", &smc_slock_key, in smc_sk_init()
382 "sk_lock-AF_SMC", &smc_key); in smc_sk_init()
383 spin_lock_init(&smc->accept_q_lock); in smc_sk_init()
384 spin_lock_init(&smc->conn.send_lock); in smc_sk_init()
385 sk->sk_prot->hash(sk); in smc_sk_init()
386 mutex_init(&smc->clcsock_release_lock); in smc_sk_init()
387 smc_init_saved_callbacks(smc); in smc_sk_init()
388 smc->limit_smc_hs = net->smc.limit_smc_hs; in smc_sk_init()
389 smc->use_fallback = false; /* assume rdma capability first */ in smc_sk_init()
390 smc->fallback_rsn = 0; in smc_sk_init()
391 smc_close_init(smc); in smc_sk_init()
415 struct sock *sk = sock->sk; in smc_bind()
416 struct smc_sock *smc; in smc_bind() local
419 smc = smc_sk(sk); in smc_bind()
422 rc = -EINVAL; in smc_bind()
426 rc = -EAFNOSUPPORT; in smc_bind()
427 if (addr->sin_family != AF_INET && in smc_bind()
428 addr->sin_family != AF_INET6 && in smc_bind()
429 addr->sin_family != AF_UNSPEC) in smc_bind()
432 if (addr->sin_family == AF_UNSPEC && in smc_bind()
433 addr->sin_addr.s_addr != htonl(INADDR_ANY)) in smc_bind()
439 rc = -EINVAL; in smc_bind()
440 if (sk->sk_state != SMC_INIT || smc->connect_nonblock) in smc_bind()
443 smc->clcsock->sk->sk_reuse = sk->sk_reuse; in smc_bind()
444 smc->clcsock->sk->sk_reuseport = sk->sk_reuseport; in smc_bind()
445 rc = kernel_bind(smc->clcsock, uaddr, addr_len); in smc_bind()
453 /* copy only relevant settings and flags of SOL_SOCKET level from smc to
454 * clc socket (since smc is not called for these options from net/core)
473 /* if set, use value set by setsockopt() - else use IPv4 or SMC sysctl value */
477 nsk->sk_userlocks = osk->sk_userlocks; in smc_adjust_sock_bufsizes()
478 if (osk->sk_userlocks & SOCK_SNDBUF_LOCK) in smc_adjust_sock_bufsizes()
479 nsk->sk_sndbuf = osk->sk_sndbuf; in smc_adjust_sock_bufsizes()
480 if (osk->sk_userlocks & SOCK_RCVBUF_LOCK) in smc_adjust_sock_bufsizes()
481 nsk->sk_rcvbuf = osk->sk_rcvbuf; in smc_adjust_sock_bufsizes()
488 nsk->sk_type = osk->sk_type; in smc_copy_sock_settings()
489 nsk->sk_sndtimeo = osk->sk_sndtimeo; in smc_copy_sock_settings()
490 nsk->sk_rcvtimeo = osk->sk_rcvtimeo; in smc_copy_sock_settings()
491 nsk->sk_mark = READ_ONCE(osk->sk_mark); in smc_copy_sock_settings()
492 nsk->sk_priority = READ_ONCE(osk->sk_priority); in smc_copy_sock_settings()
493 nsk->sk_rcvlowat = osk->sk_rcvlowat; in smc_copy_sock_settings()
494 nsk->sk_bound_dev_if = osk->sk_bound_dev_if; in smc_copy_sock_settings()
495 nsk->sk_err = osk->sk_err; in smc_copy_sock_settings()
497 nsk->sk_flags &= ~mask; in smc_copy_sock_settings()
498 nsk->sk_flags |= osk->sk_flags & mask; in smc_copy_sock_settings()
503 static void smc_copy_sock_settings_to_clc(struct smc_sock *smc) in smc_copy_sock_settings_to_clc() argument
505 smc_copy_sock_settings(smc->clcsock->sk, &smc->sk, SK_FLAGS_SMC_TO_CLC); in smc_copy_sock_settings_to_clc()
512 /* copy only settings and flags relevant for smc from clc to smc socket */
513 static void smc_copy_sock_settings_to_smc(struct smc_sock *smc) in smc_copy_sock_settings_to_smc() argument
515 smc_copy_sock_settings(&smc->sk, smc->clcsock->sk, SK_FLAGS_CLC_TO_SMC); in smc_copy_sock_settings_to_smc()
522 struct smc_link_group *lgr = link->lgr; in smcr_lgr_reg_sndbufs()
525 if (!snd_desc->is_vm) in smcr_lgr_reg_sndbufs()
526 return -EINVAL; in smcr_lgr_reg_sndbufs()
529 down_write(&lgr->llc_conf_mutex); in smcr_lgr_reg_sndbufs()
531 if (!smc_link_active(&lgr->lnk[i])) in smcr_lgr_reg_sndbufs()
533 rc = smcr_link_reg_buf(&lgr->lnk[i], snd_desc); in smcr_lgr_reg_sndbufs()
537 up_write(&lgr->llc_conf_mutex); in smcr_lgr_reg_sndbufs()
545 struct smc_link_group *lgr = link->lgr; in smcr_lgr_reg_rmbs()
553 down_read(&lgr->llc_conf_mutex); in smcr_lgr_reg_rmbs()
555 if (!smc_link_active(&lgr->lnk[i])) in smcr_lgr_reg_rmbs()
557 if (!rmb_desc->is_reg_mr[link->link_idx]) { in smcr_lgr_reg_rmbs()
558 up_read(&lgr->llc_conf_mutex); in smcr_lgr_reg_rmbs()
569 down_write(&lgr->llc_conf_mutex); in smcr_lgr_reg_rmbs()
571 if (!smc_link_active(&lgr->lnk[i])) in smcr_lgr_reg_rmbs()
573 rc = smcr_link_reg_buf(&lgr->lnk[i], rmb_desc); in smcr_lgr_reg_rmbs()
581 rc = -EFAULT; in smcr_lgr_reg_rmbs()
584 rmb_desc->is_conf_rkey = true; in smcr_lgr_reg_rmbs()
586 do_slow ? up_write(&lgr->llc_conf_mutex) : up_read(&lgr->llc_conf_mutex); in smcr_lgr_reg_rmbs()
587 smc_llc_flow_stop(lgr, &lgr->llc_flow_lcl); in smcr_lgr_reg_rmbs()
591 static int smcr_clnt_conf_first_link(struct smc_sock *smc) in smcr_clnt_conf_first_link() argument
593 struct smc_link *link = smc->conn.lnk; in smcr_clnt_conf_first_link()
602 qentry = smc_llc_wait(link->lgr, NULL, 2 * SMC_LLC_WAIT_TIME, in smcr_clnt_conf_first_link()
607 rc = smc_clc_wait_msg(smc, &dclc, sizeof(dclc), in smcr_clnt_conf_first_link()
609 return rc == -EAGAIN ? SMC_CLC_DECL_TIMEOUT_CL : rc; in smcr_clnt_conf_first_link()
613 smc_llc_flow_qentry_del(&link->lgr->llc_flow_lcl); in smcr_clnt_conf_first_link()
624 if (smc->conn.sndbuf_desc->is_vm) { in smcr_clnt_conf_first_link()
625 if (smcr_link_reg_buf(link, smc->conn.sndbuf_desc)) in smcr_clnt_conf_first_link()
630 if (smcr_link_reg_buf(link, smc->conn.rmb_desc)) in smcr_clnt_conf_first_link()
634 smc->conn.rmb_desc->is_conf_rkey = true; in smcr_clnt_conf_first_link()
642 smcr_lgr_set_type(link->lgr, SMC_LGR_SINGLE); in smcr_clnt_conf_first_link()
644 if (link->lgr->max_links > 1) { in smcr_clnt_conf_first_link()
646 qentry = smc_llc_wait(link->lgr, NULL, SMC_LLC_WAIT_TIME, in smcr_clnt_conf_first_link()
651 rc = smc_clc_wait_msg(smc, &dclc, sizeof(dclc), in smcr_clnt_conf_first_link()
653 if (rc == -EAGAIN) in smcr_clnt_conf_first_link()
657 smc_llc_flow_qentry_clr(&link->lgr->llc_flow_lcl); in smcr_clnt_conf_first_link()
673 static void smc_conn_save_peer_info_fce(struct smc_sock *smc, in smc_conn_save_peer_info_fce() argument
679 if (clc->hdr.version == SMC_V1 || in smc_conn_save_peer_info_fce()
680 !(clc->hdr.typev2 & SMC_FIRST_CONTACT_MASK)) in smc_conn_save_peer_info_fce()
683 if (smc->conn.lgr->is_smcd) { in smc_conn_save_peer_info_fce()
684 memcpy(smc->conn.lgr->negotiated_eid, clc->d1.eid, in smc_conn_save_peer_info_fce()
688 memcpy(smc->conn.lgr->negotiated_eid, clc->r1.eid, in smc_conn_save_peer_info_fce()
693 smc->conn.lgr->peer_os = fce->os_type; in smc_conn_save_peer_info_fce()
694 smc->conn.lgr->peer_smc_release = fce->release; in smc_conn_save_peer_info_fce()
695 if (smc_isascii(fce->hostname)) in smc_conn_save_peer_info_fce()
696 memcpy(smc->conn.lgr->peer_hostname, fce->hostname, in smc_conn_save_peer_info_fce()
700 static void smcr_conn_save_peer_info(struct smc_sock *smc, in smcr_conn_save_peer_info() argument
703 int bufsize = smc_uncompress_bufsize(clc->r0.rmbe_size); in smcr_conn_save_peer_info()
705 smc->conn.peer_rmbe_idx = clc->r0.rmbe_idx; in smcr_conn_save_peer_info()
706 smc->conn.local_tx_ctrl.token = ntohl(clc->r0.rmbe_alert_token); in smcr_conn_save_peer_info()
707 smc->conn.peer_rmbe_size = bufsize; in smcr_conn_save_peer_info()
708 atomic_set(&smc->conn.peer_rmbe_space, smc->conn.peer_rmbe_size); in smcr_conn_save_peer_info()
709 smc->conn.tx_off = bufsize * (smc->conn.peer_rmbe_idx - 1); in smcr_conn_save_peer_info()
712 static void smcd_conn_save_peer_info(struct smc_sock *smc, in smcd_conn_save_peer_info() argument
715 int bufsize = smc_uncompress_bufsize(clc->d0.dmbe_size); in smcd_conn_save_peer_info()
717 smc->conn.peer_rmbe_idx = clc->d0.dmbe_idx; in smcd_conn_save_peer_info()
718 smc->conn.peer_token = ntohll(clc->d0.token); in smcd_conn_save_peer_info()
720 smc->conn.peer_rmbe_size = bufsize - sizeof(struct smcd_cdc_msg); in smcd_conn_save_peer_info()
721 atomic_set(&smc->conn.peer_rmbe_space, smc->conn.peer_rmbe_size); in smcd_conn_save_peer_info()
722 smc->conn.tx_off = bufsize * smc->conn.peer_rmbe_idx; in smcd_conn_save_peer_info()
725 static void smc_conn_save_peer_info(struct smc_sock *smc, in smc_conn_save_peer_info() argument
728 if (smc->conn.lgr->is_smcd) in smc_conn_save_peer_info()
729 smcd_conn_save_peer_info(smc, clc); in smc_conn_save_peer_info()
731 smcr_conn_save_peer_info(smc, clc); in smc_conn_save_peer_info()
732 smc_conn_save_peer_info_fce(smc, clc); in smc_conn_save_peer_info()
739 link->peer_qpn = ntoh24(clc->r0.qpn); in smc_link_save_peer_info()
740 memcpy(link->peer_gid, ini->peer_gid, SMC_GID_SIZE); in smc_link_save_peer_info()
741 memcpy(link->peer_mac, ini->peer_mac, sizeof(link->peer_mac)); in smc_link_save_peer_info()
742 link->peer_psn = ntoh24(clc->r0.psn); in smc_link_save_peer_info()
743 link->peer_mtu = clc->r0.qp_mtu; in smc_link_save_peer_info()
746 static void smc_stat_inc_fback_rsn_cnt(struct smc_sock *smc, in smc_stat_inc_fback_rsn_cnt() argument
752 if (fback_arr[cnt].fback_code == smc->fallback_rsn) { in smc_stat_inc_fback_rsn_cnt()
757 fback_arr[cnt].fback_code = smc->fallback_rsn; in smc_stat_inc_fback_rsn_cnt()
764 static void smc_stat_fallback(struct smc_sock *smc) in smc_stat_fallback() argument
766 struct net *net = sock_net(&smc->sk); in smc_stat_fallback()
768 mutex_lock(&net->smc.mutex_fback_rsn); in smc_stat_fallback()
769 if (smc->listen_smc) { in smc_stat_fallback()
770 smc_stat_inc_fback_rsn_cnt(smc, net->smc.fback_rsn->srv); in smc_stat_fallback()
771 net->smc.fback_rsn->srv_fback_cnt++; in smc_stat_fallback()
773 smc_stat_inc_fback_rsn_cnt(smc, net->smc.fback_rsn->clnt); in smc_stat_fallback()
774 net->smc.fback_rsn->clnt_fback_cnt++; in smc_stat_fallback()
776 mutex_unlock(&net->smc.mutex_fback_rsn); in smc_stat_fallback()
780 static void smc_fback_wakeup_waitqueue(struct smc_sock *smc, void *key) in smc_fback_wakeup_waitqueue() argument
785 wq = rcu_dereference(smc->sk.sk_wq); in smc_fback_wakeup_waitqueue()
789 /* wake up smc sk->sk_wq */ in smc_fback_wakeup_waitqueue()
792 wake_up_interruptible_all(&wq->wait); in smc_fback_wakeup_waitqueue()
797 wake_up_interruptible_sync_poll(&wq->wait, flags); in smc_fback_wakeup_waitqueue()
800 wake_up_interruptible_poll(&wq->wait, flags); in smc_fback_wakeup_waitqueue()
810 mark->woken = true; in smc_fback_mark_woken()
811 mark->key = key; in smc_fback_mark_woken()
815 static void smc_fback_forward_wakeup(struct smc_sock *smc, struct sock *clcsk, in smc_fback_forward_wakeup() argument
824 wq = rcu_dereference(clcsk->sk_wq); in smc_fback_forward_wakeup()
832 smc_fback_wakeup_waitqueue(smc, mark.key); in smc_fback_forward_wakeup()
839 struct smc_sock *smc; in smc_fback_state_change() local
841 read_lock_bh(&clcsk->sk_callback_lock); in smc_fback_state_change()
842 smc = smc_clcsock_user_data(clcsk); in smc_fback_state_change()
843 if (smc) in smc_fback_state_change()
844 smc_fback_forward_wakeup(smc, clcsk, in smc_fback_state_change()
845 smc->clcsk_state_change); in smc_fback_state_change()
846 read_unlock_bh(&clcsk->sk_callback_lock); in smc_fback_state_change()
851 struct smc_sock *smc; in smc_fback_data_ready() local
853 read_lock_bh(&clcsk->sk_callback_lock); in smc_fback_data_ready()
854 smc = smc_clcsock_user_data(clcsk); in smc_fback_data_ready()
855 if (smc) in smc_fback_data_ready()
856 smc_fback_forward_wakeup(smc, clcsk, in smc_fback_data_ready()
857 smc->clcsk_data_ready); in smc_fback_data_ready()
858 read_unlock_bh(&clcsk->sk_callback_lock); in smc_fback_data_ready()
863 struct smc_sock *smc; in smc_fback_write_space() local
865 read_lock_bh(&clcsk->sk_callback_lock); in smc_fback_write_space()
866 smc = smc_clcsock_user_data(clcsk); in smc_fback_write_space()
867 if (smc) in smc_fback_write_space()
868 smc_fback_forward_wakeup(smc, clcsk, in smc_fback_write_space()
869 smc->clcsk_write_space); in smc_fback_write_space()
870 read_unlock_bh(&clcsk->sk_callback_lock); in smc_fback_write_space()
875 struct smc_sock *smc; in smc_fback_error_report() local
877 read_lock_bh(&clcsk->sk_callback_lock); in smc_fback_error_report()
878 smc = smc_clcsock_user_data(clcsk); in smc_fback_error_report()
879 if (smc) in smc_fback_error_report()
880 smc_fback_forward_wakeup(smc, clcsk, in smc_fback_error_report()
881 smc->clcsk_error_report); in smc_fback_error_report()
882 read_unlock_bh(&clcsk->sk_callback_lock); in smc_fback_error_report()
885 static void smc_fback_replace_callbacks(struct smc_sock *smc) in smc_fback_replace_callbacks() argument
887 struct sock *clcsk = smc->clcsock->sk; in smc_fback_replace_callbacks()
889 write_lock_bh(&clcsk->sk_callback_lock); in smc_fback_replace_callbacks()
890 clcsk->sk_user_data = (void *)((uintptr_t)smc | SK_USER_DATA_NOCOPY); in smc_fback_replace_callbacks()
892 smc_clcsock_replace_cb(&clcsk->sk_state_change, smc_fback_state_change, in smc_fback_replace_callbacks()
893 &smc->clcsk_state_change); in smc_fback_replace_callbacks()
894 smc_clcsock_replace_cb(&clcsk->sk_data_ready, smc_fback_data_ready, in smc_fback_replace_callbacks()
895 &smc->clcsk_data_ready); in smc_fback_replace_callbacks()
896 smc_clcsock_replace_cb(&clcsk->sk_write_space, smc_fback_write_space, in smc_fback_replace_callbacks()
897 &smc->clcsk_write_space); in smc_fback_replace_callbacks()
898 smc_clcsock_replace_cb(&clcsk->sk_error_report, smc_fback_error_report, in smc_fback_replace_callbacks()
899 &smc->clcsk_error_report); in smc_fback_replace_callbacks()
901 write_unlock_bh(&clcsk->sk_callback_lock); in smc_fback_replace_callbacks()
904 static int smc_switch_to_fallback(struct smc_sock *smc, int reason_code) in smc_switch_to_fallback() argument
908 mutex_lock(&smc->clcsock_release_lock); in smc_switch_to_fallback()
909 if (!smc->clcsock) { in smc_switch_to_fallback()
910 rc = -EBADF; in smc_switch_to_fallback()
914 smc->use_fallback = true; in smc_switch_to_fallback()
915 smc->fallback_rsn = reason_code; in smc_switch_to_fallback()
916 smc_stat_fallback(smc); in smc_switch_to_fallback()
917 trace_smc_switch_to_fallback(smc, reason_code); in smc_switch_to_fallback()
918 if (smc->sk.sk_socket && smc->sk.sk_socket->file) { in smc_switch_to_fallback()
919 smc->clcsock->file = smc->sk.sk_socket->file; in smc_switch_to_fallback()
920 smc->clcsock->file->private_data = smc->clcsock; in smc_switch_to_fallback()
921 smc->clcsock->wq.fasync_list = in smc_switch_to_fallback()
922 smc->sk.sk_socket->wq.fasync_list; in smc_switch_to_fallback()
923 smc->sk.sk_socket->wq.fasync_list = NULL; in smc_switch_to_fallback()
926 * in smc sk->sk_wq and they should be woken up in smc_switch_to_fallback()
929 smc_fback_replace_callbacks(smc); in smc_switch_to_fallback()
932 mutex_unlock(&smc->clcsock_release_lock); in smc_switch_to_fallback()
937 static int smc_connect_fallback(struct smc_sock *smc, int reason_code) in smc_connect_fallback() argument
939 struct net *net = sock_net(&smc->sk); in smc_connect_fallback()
942 rc = smc_switch_to_fallback(smc, reason_code); in smc_connect_fallback()
944 this_cpu_inc(net->smc.smc_stats->clnt_hshake_err_cnt); in smc_connect_fallback()
945 if (smc->sk.sk_state == SMC_INIT) in smc_connect_fallback()
946 sock_put(&smc->sk); /* passive closing */ in smc_connect_fallback()
949 smc_copy_sock_settings_to_clc(smc); in smc_connect_fallback()
950 smc->connect_nonblock = 0; in smc_connect_fallback()
951 if (smc->sk.sk_state == SMC_INIT) in smc_connect_fallback()
952 smc->sk.sk_state = SMC_ACTIVE; in smc_connect_fallback()
957 static int smc_connect_decline_fallback(struct smc_sock *smc, int reason_code, in smc_connect_decline_fallback() argument
960 struct net *net = sock_net(&smc->sk); in smc_connect_decline_fallback()
964 this_cpu_inc(net->smc.smc_stats->clnt_hshake_err_cnt); in smc_connect_decline_fallback()
965 if (smc->sk.sk_state == SMC_INIT) in smc_connect_decline_fallback()
966 sock_put(&smc->sk); /* passive closing */ in smc_connect_decline_fallback()
970 rc = smc_clc_send_decline(smc, reason_code, version); in smc_connect_decline_fallback()
972 this_cpu_inc(net->smc.smc_stats->clnt_hshake_err_cnt); in smc_connect_decline_fallback()
973 if (smc->sk.sk_state == SMC_INIT) in smc_connect_decline_fallback()
974 sock_put(&smc->sk); /* passive closing */ in smc_connect_decline_fallback()
978 return smc_connect_fallback(smc, reason_code); in smc_connect_decline_fallback()
981 static void smc_conn_abort(struct smc_sock *smc, int local_first) in smc_conn_abort() argument
983 struct smc_connection *conn = &smc->conn; in smc_conn_abort()
984 struct smc_link_group *lgr = conn->lgr; in smc_conn_abort()
997 static int smc_find_rdma_device(struct smc_sock *smc, struct smc_init_info *ini) in smc_find_rdma_device() argument
1003 smc_pnet_find_roce_resource(smc->clcsock->sk, ini); in smc_find_rdma_device()
1004 if (!ini->check_smcrv2 && !ini->ib_dev) in smc_find_rdma_device()
1006 if (ini->check_smcrv2 && !ini->smcrv2.ib_dev_v2) in smc_find_rdma_device()
1013 static int smc_find_ism_device(struct smc_sock *smc, struct smc_init_info *ini) in smc_find_ism_device() argument
1016 smc_pnet_find_ism_resource(smc->clcsock->sk, ini); in smc_find_ism_device()
1017 if (!ini->ism_dev[0]) in smc_find_ism_device()
1020 ini->ism_chid[0] = smc_ism_get_chid(ini->ism_dev[0]); in smc_find_ism_device()
1028 int i = (!ini->ism_dev[0]) ? 1 : 0; in smc_find_ism_v2_is_unique_chid()
1031 if (ini->ism_chid[i] == chid) in smc_find_ism_v2_is_unique_chid()
1039 static int smc_find_ism_v2_device_clnt(struct smc_sock *smc, in smc_find_ism_v2_device_clnt() argument
1048 if (smcd_indicated(ini->smc_type_v1)) in smc_find_ism_v2_device_clnt()
1052 if (smcd->going_away || smcd == ini->ism_dev[0]) in smc_find_ism_v2_device_clnt()
1058 if (!smc_pnet_is_pnetid_set(smcd->pnetid) || in smc_find_ism_v2_device_clnt()
1059 smc_pnet_is_ndev_pnetid(sock_net(&smc->sk), smcd->pnetid)) { in smc_find_ism_v2_device_clnt()
1061 /* It's the last GID-CHID entry left in CLC in smc_find_ism_v2_device_clnt()
1062 * Proposal SMC-Dv2 extension, but an Emulated- in smc_find_ism_v2_device_clnt()
1067 ini->ism_dev[i] = smcd; in smc_find_ism_v2_device_clnt()
1068 ini->ism_chid[i] = chid; in smc_find_ism_v2_device_clnt()
1069 ini->is_smcd = true; in smc_find_ism_v2_device_clnt()
1078 ini->ism_offered_cnt = i - 1; in smc_find_ism_v2_device_clnt()
1079 if (!ini->ism_dev[0] && !ini->ism_dev[1]) in smc_find_ism_v2_device_clnt()
1080 ini->smcd_version = 0; in smc_find_ism_v2_device_clnt()
1085 /* Check for VLAN ID and register it on ISM device just for CLC handshake */
1086 static int smc_connect_ism_vlan_setup(struct smc_sock *smc, in smc_connect_ism_vlan_setup() argument
1089 if (ini->vlan_id && smc_ism_get_vlan(ini->ism_dev[0], ini->vlan_id)) in smc_connect_ism_vlan_setup()
1094 static int smc_find_proposal_devices(struct smc_sock *smc, in smc_find_proposal_devices() argument
1100 if (!(ini->smcd_version & SMC_V1) || in smc_find_proposal_devices()
1101 smc_find_ism_device(smc, ini) || in smc_find_proposal_devices()
1102 smc_connect_ism_vlan_setup(smc, ini)) in smc_find_proposal_devices()
1103 ini->smcd_version &= ~SMC_V1; in smc_find_proposal_devices()
1107 if (!(ini->smcr_version & SMC_V1) || in smc_find_proposal_devices()
1108 smc_find_rdma_device(smc, ini)) in smc_find_proposal_devices()
1109 ini->smcr_version &= ~SMC_V1; in smc_find_proposal_devices()
1112 ini->smc_type_v1 = smc_indicated_type(ini->smcd_version & SMC_V1, in smc_find_proposal_devices()
1113 ini->smcr_version & SMC_V1); in smc_find_proposal_devices()
1116 if (!(ini->smcd_version & SMC_V2) || in smc_find_proposal_devices()
1118 smc_find_ism_v2_device_clnt(smc, ini)) in smc_find_proposal_devices()
1119 ini->smcd_version &= ~SMC_V2; in smc_find_proposal_devices()
1122 ini->check_smcrv2 = true; in smc_find_proposal_devices()
1123 ini->smcrv2.saddr = smc->clcsock->sk->sk_rcv_saddr; in smc_find_proposal_devices()
1124 if (!(ini->smcr_version & SMC_V2) || in smc_find_proposal_devices()
1126 (smc->clcsock->sk->sk_family == AF_INET6 && in smc_find_proposal_devices()
1127 !ipv6_addr_v4mapped(&smc->clcsock->sk->sk_v6_rcv_saddr)) || in smc_find_proposal_devices()
1130 smc_find_rdma_device(smc, ini)) in smc_find_proposal_devices()
1131 ini->smcr_version &= ~SMC_V2; in smc_find_proposal_devices()
1132 ini->check_smcrv2 = false; in smc_find_proposal_devices()
1134 ini->smc_type_v2 = smc_indicated_type(ini->smcd_version & SMC_V2, in smc_find_proposal_devices()
1135 ini->smcr_version & SMC_V2); in smc_find_proposal_devices()
1138 if (ini->smc_type_v1 == SMC_TYPE_N && ini->smc_type_v2 == SMC_TYPE_N) in smc_find_proposal_devices()
1144 /* cleanup temporary VLAN ID registration used for CLC handshake. If ISM is
1145 * used, the VLAN ID will be registered again during the connection setup.
1147 static int smc_connect_ism_vlan_cleanup(struct smc_sock *smc, in smc_connect_ism_vlan_cleanup() argument
1150 if (!smcd_indicated(ini->smc_type_v1)) in smc_connect_ism_vlan_cleanup()
1152 if (ini->vlan_id && smc_ism_put_vlan(ini->ism_dev[0], ini->vlan_id)) in smc_connect_ism_vlan_cleanup()
1163 static int smc_connect_clc(struct smc_sock *smc, in smc_connect_clc() argument
1170 rc = smc_clc_send_proposal(smc, ini); in smc_connect_clc()
1173 /* receive SMC Accept CLC message */ in smc_connect_clc()
1174 return smc_clc_wait_msg(smc, aclc, SMC_CLC_MAX_ACCEPT_LEN, in smc_connect_clc()
1185 memcpy(gidlist->list[gidlist->len++], known_gid, SMC_GID_SIZE); in smc_fill_gid_list()
1191 alt_ini->vlan_id = lgr->vlan_id; in smc_fill_gid_list()
1192 alt_ini->check_smcrv2 = true; in smc_fill_gid_list()
1193 alt_ini->smcrv2.saddr = lgr->saddr; in smc_fill_gid_list()
1196 if (!alt_ini->smcrv2.ib_dev_v2) in smc_fill_gid_list()
1199 memcpy(gidlist->list[gidlist->len++], alt_ini->smcrv2.ib_gid_v2, in smc_fill_gid_list()
1206 static int smc_connect_rdma_v2_prepare(struct smc_sock *smc, in smc_connect_rdma_v2_prepare() argument
1212 struct net *net = sock_net(&smc->sk); in smc_connect_rdma_v2_prepare()
1215 if (!ini->first_contact_peer || aclc->hdr.version == SMC_V1) in smc_connect_rdma_v2_prepare()
1218 if (fce->v2_direct) { in smc_connect_rdma_v2_prepare()
1219 memcpy(ini->smcrv2.nexthop_mac, &aclc->r0.lcl.mac, ETH_ALEN); in smc_connect_rdma_v2_prepare()
1220 ini->smcrv2.uses_gateway = false; in smc_connect_rdma_v2_prepare()
1222 if (smc_ib_find_route(net, smc->clcsock->sk->sk_rcv_saddr, in smc_connect_rdma_v2_prepare()
1223 smc_ib_gid_to_ipv4(aclc->r0.lcl.gid), in smc_connect_rdma_v2_prepare()
1224 ini->smcrv2.nexthop_mac, in smc_connect_rdma_v2_prepare()
1225 &ini->smcrv2.uses_gateway)) in smc_connect_rdma_v2_prepare()
1227 if (!ini->smcrv2.uses_gateway) { in smc_connect_rdma_v2_prepare()
1233 ini->release_nr = fce->release; in smc_connect_rdma_v2_prepare()
1242 static int smc_connect_rdma(struct smc_sock *smc, in smc_connect_rdma() argument
1250 ini->is_smcd = false; in smc_connect_rdma()
1251 ini->ib_clcqpn = ntoh24(aclc->r0.qpn); in smc_connect_rdma()
1252 ini->first_contact_peer = aclc->hdr.typev2 & SMC_FIRST_CONTACT_MASK; in smc_connect_rdma()
1253 memcpy(ini->peer_systemid, aclc->r0.lcl.id_for_peer, SMC_SYSTEMID_LEN); in smc_connect_rdma()
1254 memcpy(ini->peer_gid, aclc->r0.lcl.gid, SMC_GID_SIZE); in smc_connect_rdma()
1255 memcpy(ini->peer_mac, aclc->r0.lcl.mac, ETH_ALEN); in smc_connect_rdma()
1256 ini->max_conns = SMC_CONN_PER_LGR_MAX; in smc_connect_rdma()
1257 ini->max_links = SMC_LINKS_ADD_LNK_MAX; in smc_connect_rdma()
1259 reason_code = smc_connect_rdma_v2_prepare(smc, aclc, ini); in smc_connect_rdma()
1264 reason_code = smc_conn_create(smc, ini); in smc_connect_rdma()
1270 smc_conn_save_peer_info(smc, aclc); in smc_connect_rdma()
1272 if (ini->first_contact_local) { in smc_connect_rdma()
1273 link = smc->conn.lnk; in smc_connect_rdma()
1278 struct smc_link *l = &smc->conn.lgr->lnk[i]; in smc_connect_rdma()
1280 if (l->peer_qpn == ntoh24(aclc->r0.qpn) && in smc_connect_rdma()
1281 !memcmp(l->peer_gid, &aclc->r0.lcl.gid, in smc_connect_rdma()
1283 (aclc->hdr.version > SMC_V1 || in smc_connect_rdma()
1284 !memcmp(l->peer_mac, &aclc->r0.lcl.mac, in smc_connect_rdma()
1285 sizeof(l->peer_mac)))) { in smc_connect_rdma()
1294 smc_switch_link_and_count(&smc->conn, link); in smc_connect_rdma()
1298 if (smc_buf_create(smc, false)) { in smc_connect_rdma()
1303 if (ini->first_contact_local) in smc_connect_rdma()
1306 if (smc_rmb_rtoken_handling(&smc->conn, link, aclc)) { in smc_connect_rdma()
1311 smc_rx_init(smc); in smc_connect_rdma()
1313 if (ini->first_contact_local) { in smc_connect_rdma()
1320 if (smc->conn.sndbuf_desc->is_vm) { in smc_connect_rdma()
1321 if (smcr_lgr_reg_sndbufs(link, smc->conn.sndbuf_desc)) { in smc_connect_rdma()
1326 if (smcr_lgr_reg_rmbs(link, smc->conn.rmb_desc)) { in smc_connect_rdma()
1332 if (aclc->hdr.version > SMC_V1) { in smc_connect_rdma()
1333 eid = aclc->r1.eid; in smc_connect_rdma()
1334 if (ini->first_contact_local) in smc_connect_rdma()
1335 smc_fill_gid_list(link->lgr, &ini->smcrv2.gidlist, in smc_connect_rdma()
1336 link->smcibdev, link->gid); in smc_connect_rdma()
1339 reason_code = smc_clc_send_confirm(smc, ini->first_contact_local, in smc_connect_rdma()
1340 aclc->hdr.version, eid, ini); in smc_connect_rdma()
1344 smc_tx_init(smc); in smc_connect_rdma()
1346 if (ini->first_contact_local) { in smc_connect_rdma()
1348 smc_llc_flow_initiate(link->lgr, SMC_LLC_FLOW_ADD_LINK); in smc_connect_rdma()
1349 reason_code = smcr_clnt_conf_first_link(smc); in smc_connect_rdma()
1350 smc_llc_flow_stop(link->lgr, &link->lgr->llc_flow_lcl); in smc_connect_rdma()
1356 smc_copy_sock_settings_to_clc(smc); in smc_connect_rdma()
1357 smc->connect_nonblock = 0; in smc_connect_rdma()
1358 if (smc->sk.sk_state == SMC_INIT) in smc_connect_rdma()
1359 smc->sk.sk_state = SMC_ACTIVE; in smc_connect_rdma()
1363 smc_conn_abort(smc, ini->first_contact_local); in smc_connect_rdma()
1365 smc->connect_nonblock = 0; in smc_connect_rdma()
1379 for (i = 0; i < ini->ism_offered_cnt + 1; i++) { in smc_v2_determine_accepted_chid()
1380 if (ini->ism_chid[i] == ntohs(aclc->d1.chid)) { in smc_v2_determine_accepted_chid()
1381 ini->ism_selected = i; in smc_v2_determine_accepted_chid()
1386 return -EPROTO; in smc_v2_determine_accepted_chid()
1390 static int smc_connect_ism(struct smc_sock *smc, in smc_connect_ism() argument
1397 ini->is_smcd = true; in smc_connect_ism()
1398 ini->first_contact_peer = aclc->hdr.typev2 & SMC_FIRST_CONTACT_MASK; in smc_connect_ism()
1400 if (aclc->hdr.version == SMC_V2) { in smc_connect_ism()
1401 if (ini->first_contact_peer) { in smc_connect_ism()
1405 ini->release_nr = fce->release; in smc_connect_ism()
1415 if (__smc_ism_is_emulated(ini->ism_chid[ini->ism_selected])) in smc_connect_ism()
1416 ini->ism_peer_gid[ini->ism_selected].gid_ext = in smc_connect_ism()
1417 ntohll(aclc->d1.gid_ext); in smc_connect_ism()
1418 /* for non-Emulated-ISM devices, peer gid_ext remains 0. */ in smc_connect_ism()
1420 ini->ism_peer_gid[ini->ism_selected].gid = ntohll(aclc->d0.gid); in smc_connect_ism()
1422 /* there is only one lgr role for SMC-D; use server lock */ in smc_connect_ism()
1424 rc = smc_conn_create(smc, ini); in smc_connect_ism()
1431 rc = smc_buf_create(smc, true); in smc_connect_ism()
1433 rc = (rc == -ENOSPC) ? SMC_CLC_DECL_MAX_DMB : SMC_CLC_DECL_MEM; in smc_connect_ism()
1437 smc_conn_save_peer_info(smc, aclc); in smc_connect_ism()
1439 if (smc_ism_support_dmb_nocopy(smc->conn.lgr->smcd)) { in smc_connect_ism()
1440 rc = smcd_buf_attach(smc); in smc_connect_ism()
1446 smc_rx_init(smc); in smc_connect_ism()
1447 smc_tx_init(smc); in smc_connect_ism()
1449 if (aclc->hdr.version > SMC_V1) in smc_connect_ism()
1450 eid = aclc->d1.eid; in smc_connect_ism()
1452 rc = smc_clc_send_confirm(smc, ini->first_contact_local, in smc_connect_ism()
1453 aclc->hdr.version, eid, ini); in smc_connect_ism()
1458 smc_copy_sock_settings_to_clc(smc); in smc_connect_ism()
1459 smc->connect_nonblock = 0; in smc_connect_ism()
1460 if (smc->sk.sk_state == SMC_INIT) in smc_connect_ism()
1461 smc->sk.sk_state = SMC_ACTIVE; in smc_connect_ism()
1465 smc_conn_abort(smc, ini->first_contact_local); in smc_connect_ism()
1467 smc->connect_nonblock = 0; in smc_connect_ism()
1476 if (aclc->hdr.version >= SMC_V2) { in smc_connect_check_aclc()
1477 if ((aclc->hdr.typev1 == SMC_TYPE_R && in smc_connect_check_aclc()
1478 !smcr_indicated(ini->smc_type_v2)) || in smc_connect_check_aclc()
1479 (aclc->hdr.typev1 == SMC_TYPE_D && in smc_connect_check_aclc()
1480 !smcd_indicated(ini->smc_type_v2))) in smc_connect_check_aclc()
1483 if ((aclc->hdr.typev1 == SMC_TYPE_R && in smc_connect_check_aclc()
1484 !smcr_indicated(ini->smc_type_v1)) || in smc_connect_check_aclc()
1485 (aclc->hdr.typev1 == SMC_TYPE_D && in smc_connect_check_aclc()
1486 !smcd_indicated(ini->smc_type_v1))) in smc_connect_check_aclc()
1494 static int __smc_connect(struct smc_sock *smc) in __smc_connect() argument
1502 if (smc->use_fallback) in __smc_connect()
1503 return smc_connect_fallback(smc, smc->fallback_rsn); in __smc_connect()
1505 /* if peer has not signalled SMC-capability, fall back */ in __smc_connect()
1506 if (!tcp_sk(smc->clcsock->sk)->syn_smc) in __smc_connect()
1507 return smc_connect_fallback(smc, SMC_CLC_DECL_PEERNOSMC); in __smc_connect()
1509 /* IPSec connections opt out of SMC optimizations */ in __smc_connect()
1510 if (using_ipsec(smc)) in __smc_connect()
1511 return smc_connect_decline_fallback(smc, SMC_CLC_DECL_IPSEC, in __smc_connect()
1516 return smc_connect_decline_fallback(smc, SMC_CLC_DECL_MEM, in __smc_connect()
1519 ini->smcd_version = SMC_V1 | SMC_V2; in __smc_connect()
1520 ini->smcr_version = SMC_V1 | SMC_V2; in __smc_connect()
1521 ini->smc_type_v1 = SMC_TYPE_B; in __smc_connect()
1522 ini->smc_type_v2 = SMC_TYPE_B; in __smc_connect()
1524 /* get vlan id from IP device */ in __smc_connect()
1525 if (smc_vlan_by_tcpsk(smc->clcsock, ini)) { in __smc_connect()
1526 ini->smcd_version &= ~SMC_V1; in __smc_connect()
1527 ini->smcr_version = 0; in __smc_connect()
1528 ini->smc_type_v1 = SMC_TYPE_N; in __smc_connect()
1531 rc = smc_find_proposal_devices(smc, ini); in __smc_connect()
1543 rc = smc_connect_clc(smc, aclc, ini); in __smc_connect()
1545 /* -EAGAIN on timeout, see tcp_recvmsg() */ in __smc_connect()
1546 if (rc == -EAGAIN) { in __smc_connect()
1547 rc = -ETIMEDOUT; in __smc_connect()
1548 smc->sk.sk_err = ETIMEDOUT; in __smc_connect()
1553 /* check if smc modes and versions of CLC proposal and accept match */ in __smc_connect()
1555 version = aclc->hdr.version == SMC_V1 ? SMC_V1 : SMC_V2; in __smc_connect()
1560 if (aclc->hdr.typev1 == SMC_TYPE_R) { in __smc_connect()
1561 ini->smcr_version = version; in __smc_connect()
1562 rc = smc_connect_rdma(smc, aclc, ini); in __smc_connect()
1563 } else if (aclc->hdr.typev1 == SMC_TYPE_D) { in __smc_connect()
1564 ini->smcd_version = version; in __smc_connect()
1565 rc = smc_connect_ism(smc, aclc, ini); in __smc_connect()
1570 SMC_STAT_CLNT_SUCC_INC(sock_net(smc->clcsock->sk), aclc); in __smc_connect()
1571 smc_connect_ism_vlan_cleanup(smc, ini); in __smc_connect()
1577 smc_connect_ism_vlan_cleanup(smc, ini); in __smc_connect()
1581 return smc_connect_decline_fallback(smc, rc, version); in __smc_connect()
1586 struct smc_sock *smc = container_of(work, struct smc_sock, in smc_connect_work() local
1588 long timeo = smc->sk.sk_sndtimeo; in smc_connect_work()
1593 lock_sock(smc->clcsock->sk); in smc_connect_work()
1594 if (smc->clcsock->sk->sk_err) { in smc_connect_work()
1595 smc->sk.sk_err = smc->clcsock->sk->sk_err; in smc_connect_work()
1596 } else if ((1 << smc->clcsock->sk->sk_state) & in smc_connect_work()
1598 rc = sk_stream_wait_connect(smc->clcsock->sk, &timeo); in smc_connect_work()
1599 if ((rc == -EPIPE) && in smc_connect_work()
1600 ((1 << smc->clcsock->sk->sk_state) & in smc_connect_work()
1604 release_sock(smc->clcsock->sk); in smc_connect_work()
1605 lock_sock(&smc->sk); in smc_connect_work()
1606 if (rc != 0 || smc->sk.sk_err) { in smc_connect_work()
1607 smc->sk.sk_state = SMC_CLOSED; in smc_connect_work()
1608 if (rc == -EPIPE || rc == -EAGAIN) in smc_connect_work()
1609 smc->sk.sk_err = EPIPE; in smc_connect_work()
1610 else if (rc == -ECONNREFUSED) in smc_connect_work()
1611 smc->sk.sk_err = ECONNREFUSED; in smc_connect_work()
1613 smc->sk.sk_err = -sock_intr_errno(timeo); in smc_connect_work()
1614 sock_put(&smc->sk); /* passive closing */ in smc_connect_work()
1618 rc = __smc_connect(smc); in smc_connect_work()
1620 smc->sk.sk_err = -rc; in smc_connect_work()
1623 if (!sock_flag(&smc->sk, SOCK_DEAD)) { in smc_connect_work()
1624 if (smc->sk.sk_err) { in smc_connect_work()
1625 smc->sk.sk_state_change(&smc->sk); in smc_connect_work()
1627 smc->clcsock->sk->sk_write_space(smc->clcsock->sk); in smc_connect_work()
1628 smc->sk.sk_write_space(&smc->sk); in smc_connect_work()
1631 release_sock(&smc->sk); in smc_connect_work()
1637 struct sock *sk = sock->sk; in smc_connect()
1638 struct smc_sock *smc; in smc_connect() local
1639 int rc = -EINVAL; in smc_connect()
1641 smc = smc_sk(sk); in smc_connect()
1643 /* separate smc parameter checking to be safe */ in smc_connect()
1644 if (alen < sizeof(addr->sa_family)) in smc_connect()
1646 if (addr->sa_family != AF_INET && addr->sa_family != AF_INET6) in smc_connect()
1650 switch (sock->state) { in smc_connect()
1652 rc = -EINVAL; in smc_connect()
1655 rc = sk->sk_state == SMC_ACTIVE ? -EISCONN : -EINVAL; in smc_connect()
1658 if (sk->sk_state == SMC_ACTIVE) in smc_connect()
1662 sock->state = SS_CONNECTING; in smc_connect()
1666 switch (sk->sk_state) { in smc_connect()
1670 rc = sock_error(sk) ? : -ECONNABORTED; in smc_connect()
1671 sock->state = SS_UNCONNECTED; in smc_connect()
1674 rc = -EISCONN; in smc_connect()
1680 smc_copy_sock_settings_to_clc(smc); in smc_connect()
1681 tcp_sk(smc->clcsock->sk)->syn_smc = 1; in smc_connect()
1682 if (smc->connect_nonblock) { in smc_connect()
1683 rc = -EALREADY; in smc_connect()
1686 rc = kernel_connect(smc->clcsock, addr, alen, flags); in smc_connect()
1687 if (rc && rc != -EINPROGRESS) in smc_connect()
1690 if (smc->use_fallback) { in smc_connect()
1691 sock->state = rc ? SS_CONNECTING : SS_CONNECTED; in smc_connect()
1694 sock_hold(&smc->sk); /* sock put in passive closing */ in smc_connect()
1696 if (queue_work(smc_hs_wq, &smc->connect_work)) in smc_connect()
1697 smc->connect_nonblock = 1; in smc_connect()
1698 rc = -EINPROGRESS; in smc_connect()
1701 rc = __smc_connect(smc); in smc_connect()
1708 sock->state = SS_CONNECTED; in smc_connect()
1718 struct sock *lsk = &lsmc->sk; in smc_clcsock_accept()
1720 int rc = -EINVAL; in smc_clcsock_accept()
1723 new_sk = smc_sock_alloc(sock_net(lsk), NULL, lsk->sk_protocol); in smc_clcsock_accept()
1725 rc = -ENOMEM; in smc_clcsock_accept()
1726 lsk->sk_err = ENOMEM; in smc_clcsock_accept()
1733 mutex_lock(&lsmc->clcsock_release_lock); in smc_clcsock_accept()
1734 if (lsmc->clcsock) in smc_clcsock_accept()
1735 rc = kernel_accept(lsmc->clcsock, &new_clcsock, SOCK_NONBLOCK); in smc_clcsock_accept()
1736 mutex_unlock(&lsmc->clcsock_release_lock); in smc_clcsock_accept()
1738 if (rc < 0 && rc != -EAGAIN) in smc_clcsock_accept()
1739 lsk->sk_err = -rc; in smc_clcsock_accept()
1740 if (rc < 0 || lsk->sk_state == SMC_CLOSED) { in smc_clcsock_accept()
1741 new_sk->sk_prot->unhash(new_sk); in smc_clcsock_accept()
1744 new_sk->sk_state = SMC_CLOSED; in smc_clcsock_accept()
1751 /* new clcsock has inherited the smc listen-specific sk_data_ready in smc_clcsock_accept()
1754 new_clcsock->sk->sk_data_ready = lsmc->clcsk_data_ready; in smc_clcsock_accept()
1756 /* if new clcsock has also inherited the fallback-specific callback in smc_clcsock_accept()
1759 if (lsmc->use_fallback) { in smc_clcsock_accept()
1760 if (lsmc->clcsk_state_change) in smc_clcsock_accept()
1761 new_clcsock->sk->sk_state_change = lsmc->clcsk_state_change; in smc_clcsock_accept()
1762 if (lsmc->clcsk_write_space) in smc_clcsock_accept()
1763 new_clcsock->sk->sk_write_space = lsmc->clcsk_write_space; in smc_clcsock_accept()
1764 if (lsmc->clcsk_error_report) in smc_clcsock_accept()
1765 new_clcsock->sk->sk_error_report = lsmc->clcsk_error_report; in smc_clcsock_accept()
1768 (*new_smc)->clcsock = new_clcsock; in smc_clcsock_accept()
1781 spin_lock(&par->accept_q_lock); in smc_accept_enqueue()
1782 list_add_tail(&smc_sk(sk)->accept_q, &par->accept_q); in smc_accept_enqueue()
1783 spin_unlock(&par->accept_q_lock); in smc_accept_enqueue()
1790 struct smc_sock *par = smc_sk(sk)->listen_smc; in smc_accept_unlink()
1792 spin_lock(&par->accept_q_lock); in smc_accept_unlink()
1793 list_del_init(&smc_sk(sk)->accept_q); in smc_accept_unlink()
1794 spin_unlock(&par->accept_q_lock); in smc_accept_unlink()
1795 sk_acceptq_removed(&smc_sk(sk)->listen_smc->sk); in smc_accept_unlink()
1808 list_for_each_entry_safe(isk, n, &smc_sk(parent)->accept_q, accept_q) { in smc_accept_dequeue()
1812 if (new_sk->sk_state == SMC_CLOSED) { in smc_accept_dequeue()
1813 new_sk->sk_prot->unhash(new_sk); in smc_accept_dequeue()
1814 if (isk->clcsock) { in smc_accept_dequeue()
1815 sock_release(isk->clcsock); in smc_accept_dequeue()
1816 isk->clcsock = NULL; in smc_accept_dequeue()
1823 new_sock->state = SS_CONNECTED; in smc_accept_dequeue()
1824 if (isk->use_fallback) { in smc_accept_dequeue()
1825 smc_sk(new_sk)->clcsock->file = new_sock->file; in smc_accept_dequeue()
1826 isk->clcsock->file->private_data = isk->clcsock; in smc_accept_dequeue()
1837 struct smc_sock *smc = smc_sk(sk); in smc_close_non_accepted() local
1841 if (!sk->sk_lingertime) in smc_close_non_accepted()
1843 WRITE_ONCE(sk->sk_lingertime, SMC_MAX_STREAM_WAIT_TIMEOUT); in smc_close_non_accepted()
1844 __smc_release(smc); in smc_close_non_accepted()
1850 static int smcr_serv_conf_first_link(struct smc_sock *smc) in smcr_serv_conf_first_link() argument
1852 struct smc_link *link = smc->conn.lnk; in smcr_serv_conf_first_link()
1857 if (smc->conn.sndbuf_desc->is_vm) { in smcr_serv_conf_first_link()
1858 if (smcr_link_reg_buf(link, smc->conn.sndbuf_desc)) in smcr_serv_conf_first_link()
1863 if (smcr_link_reg_buf(link, smc->conn.rmb_desc)) in smcr_serv_conf_first_link()
1872 qentry = smc_llc_wait(link->lgr, link, SMC_LLC_WAIT_TIME, in smcr_serv_conf_first_link()
1877 rc = smc_clc_wait_msg(smc, &dclc, sizeof(dclc), in smcr_serv_conf_first_link()
1879 return rc == -EAGAIN ? SMC_CLC_DECL_TIMEOUT_CL : rc; in smcr_serv_conf_first_link()
1883 smc_llc_flow_qentry_del(&link->lgr->llc_flow_lcl); in smcr_serv_conf_first_link()
1888 smc->conn.rmb_desc->is_conf_rkey = true; in smcr_serv_conf_first_link()
1891 smcr_lgr_set_type(link->lgr, SMC_LGR_SINGLE); in smcr_serv_conf_first_link()
1893 if (link->lgr->max_links > 1) { in smcr_serv_conf_first_link()
1894 down_write(&link->lgr->llc_conf_mutex); in smcr_serv_conf_first_link()
1895 /* initial contact - try to establish second link */ in smcr_serv_conf_first_link()
1897 up_write(&link->lgr->llc_conf_mutex); in smcr_serv_conf_first_link()
1905 struct smc_sock *lsmc = new_smc->listen_smc; in smc_listen_out()
1906 struct sock *newsmcsk = &new_smc->sk; in smc_listen_out()
1908 if (tcp_sk(new_smc->clcsock->sk)->syn_smc) in smc_listen_out()
1909 atomic_dec(&lsmc->queued_smc_hs); in smc_listen_out()
1912 if (lsmc->sk.sk_state == SMC_LISTEN) { in smc_listen_out()
1913 lock_sock_nested(&lsmc->sk, SINGLE_DEPTH_NESTING); in smc_listen_out()
1914 smc_accept_enqueue(&lsmc->sk, newsmcsk); in smc_listen_out()
1915 release_sock(&lsmc->sk); in smc_listen_out()
1921 lsmc->sk.sk_data_ready(&lsmc->sk); in smc_listen_out()
1922 sock_put(&lsmc->sk); /* sock_hold in smc_tcp_listen_work */ in smc_listen_out()
1928 struct sock *newsmcsk = &new_smc->sk; in smc_listen_out_connected()
1930 if (newsmcsk->sk_state == SMC_INIT) in smc_listen_out_connected()
1931 newsmcsk->sk_state = SMC_ACTIVE; in smc_listen_out_connected()
1939 struct sock *newsmcsk = &new_smc->sk; in smc_listen_out_err()
1942 this_cpu_inc(net->smc.smc_stats->srv_hshake_err_cnt); in smc_listen_out_err()
1943 if (newsmcsk->sk_state == SMC_INIT) in smc_listen_out_err()
1944 sock_put(&new_smc->sk); /* passive closing */ in smc_listen_out_err()
1945 newsmcsk->sk_state = SMC_CLOSED; in smc_listen_out_err()
1980 ini->smc_type_v1 = pclc->hdr.typev1; in smc_listen_v2_check()
1981 ini->smc_type_v2 = pclc->hdr.typev2; in smc_listen_v2_check()
1982 ini->smcd_version = smcd_indicated(ini->smc_type_v1) ? SMC_V1 : 0; in smc_listen_v2_check()
1983 ini->smcr_version = smcr_indicated(ini->smc_type_v1) ? SMC_V1 : 0; in smc_listen_v2_check()
1984 if (pclc->hdr.version > SMC_V1) { in smc_listen_v2_check()
1985 if (smcd_indicated(ini->smc_type_v2)) in smc_listen_v2_check()
1986 ini->smcd_version |= SMC_V2; in smc_listen_v2_check()
1987 if (smcr_indicated(ini->smc_type_v2)) in smc_listen_v2_check()
1988 ini->smcr_version |= SMC_V2; in smc_listen_v2_check()
1990 if (!(ini->smcd_version & SMC_V2) && !(ini->smcr_version & SMC_V2)) { in smc_listen_v2_check()
1996 ini->smcd_version &= ~SMC_V2; in smc_listen_v2_check()
1997 ini->smcr_version &= ~SMC_V2; in smc_listen_v2_check()
2002 if (ini->smcd_version & SMC_V2) { in smc_listen_v2_check()
2004 ini->smcd_version &= ~SMC_V2; in smc_listen_v2_check()
2007 ini->smcd_version &= ~SMC_V2; in smc_listen_v2_check()
2009 } else if (!pclc_v2_ext->hdr.eid_cnt && in smc_listen_v2_check()
2010 !pclc_v2_ext->hdr.flag.seid) { in smc_listen_v2_check()
2011 ini->smcd_version &= ~SMC_V2; in smc_listen_v2_check()
2015 if (ini->smcr_version & SMC_V2) { in smc_listen_v2_check()
2016 if (!pclc_v2_ext->hdr.eid_cnt) { in smc_listen_v2_check()
2017 ini->smcr_version &= ~SMC_V2; in smc_listen_v2_check()
2022 ini->release_nr = pclc_v2_ext->hdr.flag.release; in smc_listen_v2_check()
2023 if (pclc_v2_ext->hdr.flag.release > SMC_RELEASE) in smc_listen_v2_check()
2024 ini->release_nr = SMC_RELEASE; in smc_listen_v2_check()
2027 if (!ini->smcd_version && !ini->smcr_version) in smc_listen_v2_check()
2038 struct socket *newclcsock = new_smc->clcsock; in smc_listen_prfx_check()
2040 if (pclc->hdr.typev1 == SMC_TYPE_N) in smc_listen_prfx_check()
2044 return -EPROTO; in smc_listen_prfx_check()
2064 smc_conn_abort(new_smc, ini->first_contact_local); in smc_listen_rdma_init()
2071 /* listen worker: initialize connection and buffers for SMC-D */
2084 smc_conn_abort(new_smc, ini->first_contact_local); in smc_listen_ism_init()
2085 return (rc == -ENOSPC) ? SMC_CLC_DECL_MAX_DMB : in smc_listen_ism_init()
2099 if (smcd == ini->ism_dev[i]) in smc_is_already_selected()
2114 if (smcd->going_away) in smc_check_ism_v2_match()
2120 ini->ism_peer_gid[*matches].gid = proposed_gid->gid; in smc_check_ism_v2_match()
2122 ini->ism_peer_gid[*matches].gid_ext = in smc_check_ism_v2_match()
2123 proposed_gid->gid_ext; in smc_check_ism_v2_match()
2124 /* non-Emulated-ISM's peer gid_ext remains 0. */ in smc_check_ism_v2_match()
2125 ini->ism_dev[*matches] = smcd; in smc_check_ism_v2_match()
2134 if (!ini->rc) in smc_find_ism_store_rc()
2135 ini->rc = rc; in smc_find_ism_store_rc()
2152 if (!(ini->smcd_version & SMC_V2) || !smcd_indicated(ini->smc_type_v2)) in smc_find_ism_v2_device_serv()
2162 if (pclc_smcd->ism.chid) { in smc_find_ism_v2_device_serv()
2164 smcd_gid.gid = ntohll(pclc_smcd->ism.gid); in smc_find_ism_v2_device_serv()
2166 smc_check_ism_v2_match(ini, ntohs(pclc_smcd->ism.chid), in smc_find_ism_v2_device_serv()
2169 for (i = 0; i < smc_v2_ext->hdr.ism_gid_cnt; i++) { in smc_find_ism_v2_device_serv()
2170 /* check for ISM devices matching proposed non-native ISM in smc_find_ism_v2_device_serv()
2173 smcd_gid.gid = ntohll(smcd_v2_ext->gidchid[i].gid); in smc_find_ism_v2_device_serv()
2175 chid = ntohs(smcd_v2_ext->gidchid[i].chid); in smc_find_ism_v2_device_serv()
2177 if ((i + 1) == smc_v2_ext->hdr.ism_gid_cnt || in smc_find_ism_v2_device_serv()
2178 chid != ntohs(smcd_v2_ext->gidchid[i + 1].chid)) in smc_find_ism_v2_device_serv()
2179 /* each Emulated-ISM device takes two GID-CHID in smc_find_ism_v2_device_serv()
2183 * So check if the next GID-CHID entry exists in smc_find_ism_v2_device_serv()
2188 ntohll(smcd_v2_ext->gidchid[++i].gid); in smc_find_ism_v2_device_serv()
2194 if (!ini->ism_dev[0]) { in smc_find_ism_v2_device_serv()
2200 if (!smc_clc_match_eid(ini->negotiated_eid, smc_v2_ext, in smc_find_ism_v2_device_serv()
2201 smcd_v2_ext->system_eid, eid)) in smc_find_ism_v2_device_serv()
2204 /* separate - outside the smcd_dev_list.lock */ in smc_find_ism_v2_device_serv()
2205 smcd_version = ini->smcd_version; in smc_find_ism_v2_device_serv()
2207 ini->smcd_version = SMC_V2; in smc_find_ism_v2_device_serv()
2208 ini->is_smcd = true; in smc_find_ism_v2_device_serv()
2209 ini->ism_selected = i; in smc_find_ism_v2_device_serv()
2219 ini->smcd_version = smcd_version; /* restore original value */ in smc_find_ism_v2_device_serv()
2220 ini->negotiated_eid[0] = 0; in smc_find_ism_v2_device_serv()
2223 ini->smcd_version &= ~SMC_V2; in smc_find_ism_v2_device_serv()
2224 ini->ism_dev[0] = NULL; in smc_find_ism_v2_device_serv()
2225 ini->is_smcd = false; in smc_find_ism_v2_device_serv()
2236 if (!(ini->smcd_version & SMC_V1) || in smc_find_ism_v1_device_serv()
2237 !smcd_indicated(ini->smc_type_v1) || in smc_find_ism_v1_device_serv()
2240 ini->is_smcd = true; /* prepare ISM check */ in smc_find_ism_v1_device_serv()
2241 ini->ism_peer_gid[0].gid = ntohll(pclc_smcd->ism.gid); in smc_find_ism_v1_device_serv()
2242 ini->ism_peer_gid[0].gid_ext = 0; in smc_find_ism_v1_device_serv()
2246 ini->ism_selected = 0; in smc_find_ism_v1_device_serv()
2253 ini->smcd_version &= ~SMC_V1; in smc_find_ism_v1_device_serv()
2254 ini->ism_dev[0] = NULL; in smc_find_ism_v1_device_serv()
2255 ini->is_smcd = false; in smc_find_ism_v1_device_serv()
2261 struct smc_connection *conn = &new_smc->conn; in smc_listen_rdma_reg()
2265 if (conn->sndbuf_desc->is_vm) { in smc_listen_rdma_reg()
2266 if (smcr_lgr_reg_sndbufs(conn->lnk, in smc_listen_rdma_reg()
2267 conn->sndbuf_desc)) in smc_listen_rdma_reg()
2270 if (smcr_lgr_reg_rmbs(conn->lnk, conn->rmb_desc)) in smc_listen_rdma_reg()
2285 if (!(ini->smcr_version & SMC_V2) || !smcr_indicated(ini->smc_type_v2)) in smc_find_rdma_v2_device_serv()
2290 !smc_clc_match_eid(ini->negotiated_eid, smc_v2_ext, NULL, NULL)) in smc_find_rdma_v2_device_serv()
2294 memcpy(ini->peer_systemid, pclc->lcl.id_for_peer, SMC_SYSTEMID_LEN); in smc_find_rdma_v2_device_serv()
2295 memcpy(ini->peer_gid, smc_v2_ext->roce, SMC_GID_SIZE); in smc_find_rdma_v2_device_serv()
2296 memcpy(ini->peer_mac, pclc->lcl.mac, ETH_ALEN); in smc_find_rdma_v2_device_serv()
2297 ini->check_smcrv2 = true; in smc_find_rdma_v2_device_serv()
2298 ini->smcrv2.clc_sk = new_smc->clcsock->sk; in smc_find_rdma_v2_device_serv()
2299 ini->smcrv2.saddr = new_smc->clcsock->sk->sk_rcv_saddr; in smc_find_rdma_v2_device_serv()
2300 ini->smcrv2.daddr = smc_ib_gid_to_ipv4(smc_v2_ext->roce); in smc_find_rdma_v2_device_serv()
2306 if (!ini->smcrv2.uses_gateway) in smc_find_rdma_v2_device_serv()
2307 memcpy(ini->smcrv2.nexthop_mac, pclc->lcl.mac, ETH_ALEN); in smc_find_rdma_v2_device_serv()
2309 smcr_version = ini->smcr_version; in smc_find_rdma_v2_device_serv()
2310 ini->smcr_version = SMC_V2; in smc_find_rdma_v2_device_serv()
2313 rc = smc_listen_rdma_reg(new_smc, ini->first_contact_local); in smc_find_rdma_v2_device_serv()
2315 smc_conn_abort(new_smc, ini->first_contact_local); in smc_find_rdma_v2_device_serv()
2319 ini->smcr_version = smcr_version; in smc_find_rdma_v2_device_serv()
2323 ini->smcr_version &= ~SMC_V2; in smc_find_rdma_v2_device_serv()
2324 ini->smcrv2.ib_dev_v2 = NULL; in smc_find_rdma_v2_device_serv()
2325 ini->check_smcrv2 = false; in smc_find_rdma_v2_device_serv()
2334 if (!(ini->smcr_version & SMC_V1) || !smcr_indicated(ini->smc_type_v1)) in smc_find_rdma_v1_device_serv()
2338 memcpy(ini->peer_systemid, pclc->lcl.id_for_peer, SMC_SYSTEMID_LEN); in smc_find_rdma_v1_device_serv()
2339 memcpy(ini->peer_gid, pclc->lcl.gid, SMC_GID_SIZE); in smc_find_rdma_v1_device_serv()
2340 memcpy(ini->peer_mac, pclc->lcl.mac, ETH_ALEN); in smc_find_rdma_v1_device_serv()
2349 return smc_listen_rdma_reg(new_smc, ini->first_contact_local); in smc_find_rdma_v1_device_serv()
2361 if (ini->ism_dev[0]) in smc_listen_find_device()
2369 /* get vlan id from IP device */ in smc_listen_find_device()
2370 if (smc_vlan_by_tcpsk(new_smc->clcsock, ini)) in smc_listen_find_device()
2371 return ini->rc ?: SMC_CLC_DECL_GETVLANERR; in smc_listen_find_device()
2376 if (ini->ism_dev[0]) in smc_listen_find_device()
2379 if (!smcr_indicated(pclc->hdr.typev1) && in smc_listen_find_device()
2380 !smcr_indicated(pclc->hdr.typev2)) in smc_listen_find_device()
2382 return ini->rc ?: SMC_CLC_DECL_NOSMCDDEV; in smc_listen_find_device()
2386 if (ini->smcrv2.ib_dev_v2) in smc_listen_find_device()
2395 return (!rc) ? 0 : ini->rc; in smc_listen_find_device()
2406 struct smc_link *link = new_smc->conn.lnk; in smc_listen_rdma_finish()
2412 if (smc_rmb_rtoken_handling(&new_smc->conn, link, cclc)) in smc_listen_rdma_finish()
2419 smc_llc_flow_initiate(link->lgr, SMC_LLC_FLOW_ADD_LINK); in smc_listen_rdma_finish()
2421 smc_llc_flow_stop(link->lgr, &link->lgr->llc_flow_lcl); in smc_listen_rdma_finish()
2431 struct socket *newclcsock = new_smc->clcsock; in smc_listen_work()
2440 lock_sock(&new_smc->sk); /* release in smc_listen_out() */ in smc_listen_work()
2441 if (new_smc->listen_smc->sk.sk_state != SMC_LISTEN) in smc_listen_work()
2444 if (new_smc->use_fallback) { in smc_listen_work()
2449 /* check if peer is smc capable */ in smc_listen_work()
2450 if (!tcp_sk(newclcsock->sk)->syn_smc) { in smc_listen_work()
2459 /* do inband token exchange - in smc_listen_work()
2460 * wait for and receive SMC Proposal CLC message in smc_listen_work()
2473 if (pclc->hdr.version > SMC_V1) in smc_listen_work()
2476 /* IPSec connections opt out of SMC optimizations */ in smc_listen_work()
2506 /* send SMC Accept CLC message */ in smc_listen_work()
2507 accept_version = ini->is_smcd ? ini->smcd_version : ini->smcr_version; in smc_listen_work()
2508 rc = smc_clc_send_accept(new_smc, ini->first_contact_local, in smc_listen_work()
2509 accept_version, ini->negotiated_eid, ini); in smc_listen_work()
2513 /* SMC-D does not need this lock any more */ in smc_listen_work()
2514 if (ini->is_smcd) in smc_listen_work()
2517 /* receive SMC Confirm CLC message */ in smc_listen_work()
2523 if (!ini->is_smcd) in smc_listen_work()
2530 if (!ini->is_smcd) in smc_listen_work()
2535 /* fce smc release version is needed in smc_listen_rdma_finish, in smc_listen_work()
2541 if (!ini->is_smcd) { in smc_listen_work()
2543 ini->first_contact_local, ini); in smc_listen_work()
2550 if (ini->is_smcd && in smc_listen_work()
2551 smc_ism_support_dmb_nocopy(new_smc->conn.lgr->smcd)) { in smc_listen_work()
2558 SMC_STAT_SERV_SUCC_INC(sock_net(newclcsock->sk), ini); in smc_listen_work()
2564 smc_listen_decline(new_smc, rc, ini ? ini->first_contact_local : 0, in smc_listen_work()
2575 struct sock *lsk = &lsmc->sk; in smc_tcp_listen_work()
2580 while (lsk->sk_state == SMC_LISTEN) { in smc_tcp_listen_work()
2587 if (tcp_sk(new_smc->clcsock->sk)->syn_smc) in smc_tcp_listen_work()
2588 atomic_inc(&lsmc->queued_smc_hs); in smc_tcp_listen_work()
2590 new_smc->listen_smc = lsmc; in smc_tcp_listen_work()
2591 new_smc->use_fallback = lsmc->use_fallback; in smc_tcp_listen_work()
2592 new_smc->fallback_rsn = lsmc->fallback_rsn; in smc_tcp_listen_work()
2594 INIT_WORK(&new_smc->smc_listen_work, smc_listen_work); in smc_tcp_listen_work()
2596 sock_hold(&new_smc->sk); /* sock_put in passive closing */ in smc_tcp_listen_work()
2597 if (!queue_work(smc_hs_wq, &new_smc->smc_listen_work)) in smc_tcp_listen_work()
2598 sock_put(&new_smc->sk); in smc_tcp_listen_work()
2603 sock_put(&lsmc->sk); /* sock_hold in smc_clcsock_data_ready() */ in smc_tcp_listen_work()
2610 read_lock_bh(&listen_clcsock->sk_callback_lock); in smc_clcsock_data_ready()
2614 lsmc->clcsk_data_ready(listen_clcsock); in smc_clcsock_data_ready()
2615 if (lsmc->sk.sk_state == SMC_LISTEN) { in smc_clcsock_data_ready()
2616 sock_hold(&lsmc->sk); /* sock_put in smc_tcp_listen_work() */ in smc_clcsock_data_ready()
2617 if (!queue_work(smc_tcp_ls_wq, &lsmc->tcp_listen_work)) in smc_clcsock_data_ready()
2618 sock_put(&lsmc->sk); in smc_clcsock_data_ready()
2621 read_unlock_bh(&listen_clcsock->sk_callback_lock); in smc_clcsock_data_ready()
2626 struct sock *sk = sock->sk; in smc_listen()
2627 struct smc_sock *smc; in smc_listen() local
2630 smc = smc_sk(sk); in smc_listen()
2633 rc = -EINVAL; in smc_listen()
2634 if ((sk->sk_state != SMC_INIT && sk->sk_state != SMC_LISTEN) || in smc_listen()
2635 smc->connect_nonblock || sock->state != SS_UNCONNECTED) in smc_listen()
2639 if (sk->sk_state == SMC_LISTEN) { in smc_listen()
2640 sk->sk_max_ack_backlog = backlog; in smc_listen()
2644 * them to the clc socket -- copy smc socket options to clc socket in smc_listen()
2646 smc_copy_sock_settings_to_clc(smc); in smc_listen()
2647 if (!smc->use_fallback) in smc_listen()
2648 tcp_sk(smc->clcsock->sk)->syn_smc = 1; in smc_listen()
2651 * smc-specific sk_data_ready function in smc_listen()
2653 write_lock_bh(&smc->clcsock->sk->sk_callback_lock); in smc_listen()
2654 smc->clcsock->sk->sk_user_data = in smc_listen()
2655 (void *)((uintptr_t)smc | SK_USER_DATA_NOCOPY); in smc_listen()
2656 smc_clcsock_replace_cb(&smc->clcsock->sk->sk_data_ready, in smc_listen()
2657 smc_clcsock_data_ready, &smc->clcsk_data_ready); in smc_listen()
2658 write_unlock_bh(&smc->clcsock->sk->sk_callback_lock); in smc_listen()
2661 smc->ori_af_ops = inet_csk(smc->clcsock->sk)->icsk_af_ops; in smc_listen()
2663 smc->af_ops = *smc->ori_af_ops; in smc_listen()
2664 smc->af_ops.syn_recv_sock = smc_tcp_syn_recv_sock; in smc_listen()
2666 inet_csk(smc->clcsock->sk)->icsk_af_ops = &smc->af_ops; in smc_listen()
2668 if (smc->limit_smc_hs) in smc_listen()
2669 tcp_sk(smc->clcsock->sk)->smc_hs_congested = smc_hs_congested; in smc_listen()
2671 rc = kernel_listen(smc->clcsock, backlog); in smc_listen()
2673 write_lock_bh(&smc->clcsock->sk->sk_callback_lock); in smc_listen()
2674 smc_clcsock_restore_cb(&smc->clcsock->sk->sk_data_ready, in smc_listen()
2675 &smc->clcsk_data_ready); in smc_listen()
2676 smc->clcsock->sk->sk_user_data = NULL; in smc_listen()
2677 write_unlock_bh(&smc->clcsock->sk->sk_callback_lock); in smc_listen()
2680 sk->sk_max_ack_backlog = backlog; in smc_listen()
2681 sk->sk_ack_backlog = 0; in smc_listen()
2682 sk->sk_state = SMC_LISTEN; in smc_listen()
2692 struct sock *sk = sock->sk, *nsk; in smc_accept()
2702 if (lsmc->sk.sk_state != SMC_LISTEN) { in smc_accept()
2703 rc = -EINVAL; in smc_accept()
2709 timeo = sock_rcvtimeo(sk, arg->flags & O_NONBLOCK); in smc_accept()
2714 rc = -EAGAIN; in smc_accept()
2736 if (lsmc->sockopt_defer_accept && !(arg->flags & O_NONBLOCK)) { in smc_accept()
2738 timeo = msecs_to_jiffies(lsmc->sockopt_defer_accept * in smc_accept()
2740 if (smc_sk(nsk)->use_fallback) { in smc_accept()
2741 struct sock *clcsk = smc_sk(nsk)->clcsock->sk; in smc_accept()
2744 if (skb_queue_empty(&clcsk->sk_receive_queue)) in smc_accept()
2747 } else if (!atomic_read(&smc_sk(nsk)->conn.bytes_to_rcv)) { in smc_accept()
2762 struct smc_sock *smc; in smc_getname() local
2764 if (peer && (sock->sk->sk_state != SMC_ACTIVE) && in smc_getname()
2765 (sock->sk->sk_state != SMC_APPCLOSEWAIT1)) in smc_getname()
2766 return -ENOTCONN; in smc_getname()
2768 smc = smc_sk(sock->sk); in smc_getname()
2770 return smc->clcsock->ops->getname(smc->clcsock, addr, peer); in smc_getname()
2775 struct sock *sk = sock->sk; in smc_sendmsg()
2776 struct smc_sock *smc; in smc_sendmsg() local
2779 smc = smc_sk(sk); in smc_sendmsg()
2782 /* SMC does not support connect with fastopen */ in smc_sendmsg()
2783 if (msg->msg_flags & MSG_FASTOPEN) { in smc_sendmsg()
2785 if (sk->sk_state == SMC_INIT && !smc->connect_nonblock) { in smc_sendmsg()
2786 rc = smc_switch_to_fallback(smc, SMC_CLC_DECL_OPTUNSUPP); in smc_sendmsg()
2790 rc = -EINVAL; in smc_sendmsg()
2793 } else if ((sk->sk_state != SMC_ACTIVE) && in smc_sendmsg()
2794 (sk->sk_state != SMC_APPCLOSEWAIT1) && in smc_sendmsg()
2795 (sk->sk_state != SMC_INIT)) { in smc_sendmsg()
2796 rc = -EPIPE; in smc_sendmsg()
2800 if (smc->use_fallback) { in smc_sendmsg()
2801 rc = smc->clcsock->ops->sendmsg(smc->clcsock, msg, len); in smc_sendmsg()
2803 rc = smc_tx_sendmsg(smc, msg, len); in smc_sendmsg()
2804 SMC_STAT_TX_PAYLOAD(smc, len, rc); in smc_sendmsg()
2814 struct sock *sk = sock->sk; in smc_recvmsg()
2815 struct smc_sock *smc; in smc_recvmsg() local
2816 int rc = -ENOTCONN; in smc_recvmsg()
2818 smc = smc_sk(sk); in smc_recvmsg()
2820 if (sk->sk_state == SMC_CLOSED && (sk->sk_shutdown & RCV_SHUTDOWN)) { in smc_recvmsg()
2825 if ((sk->sk_state == SMC_INIT) || in smc_recvmsg()
2826 (sk->sk_state == SMC_LISTEN) || in smc_recvmsg()
2827 (sk->sk_state == SMC_CLOSED)) in smc_recvmsg()
2830 if (sk->sk_state == SMC_PEERFINCLOSEWAIT) { in smc_recvmsg()
2835 if (smc->use_fallback) { in smc_recvmsg()
2836 rc = smc->clcsock->ops->recvmsg(smc->clcsock, msg, len, flags); in smc_recvmsg()
2838 msg->msg_namelen = 0; in smc_recvmsg()
2839 rc = smc_rx_recvmsg(smc, msg, NULL, len, flags); in smc_recvmsg()
2840 SMC_STAT_RX_PAYLOAD(smc, rc, rc); in smc_recvmsg()
2853 spin_lock(&isk->accept_q_lock); in smc_accept_poll()
2854 if (!list_empty(&isk->accept_q)) in smc_accept_poll()
2856 spin_unlock(&isk->accept_q_lock); in smc_accept_poll()
2864 struct sock *sk = sock->sk; in smc_poll()
2865 struct smc_sock *smc; in smc_poll() local
2871 smc = smc_sk(sock->sk); in smc_poll()
2872 if (smc->use_fallback) { in smc_poll()
2874 mask = smc->clcsock->ops->poll(file, smc->clcsock, wait); in smc_poll()
2875 sk->sk_err = smc->clcsock->sk->sk_err; in smc_poll()
2877 if (sk->sk_state != SMC_CLOSED) in smc_poll()
2879 if (sk->sk_err) in smc_poll()
2881 if ((sk->sk_shutdown == SHUTDOWN_MASK) || in smc_poll()
2882 (sk->sk_state == SMC_CLOSED)) in smc_poll()
2884 if (sk->sk_state == SMC_LISTEN) { in smc_poll()
2887 } else if (smc->use_fallback) { /* as result of connect_work()*/ in smc_poll()
2888 mask |= smc->clcsock->ops->poll(file, smc->clcsock, in smc_poll()
2890 sk->sk_err = smc->clcsock->sk->sk_err; in smc_poll()
2892 if ((sk->sk_state != SMC_INIT && in smc_poll()
2893 atomic_read(&smc->conn.sndbuf_space)) || in smc_poll()
2894 sk->sk_shutdown & SEND_SHUTDOWN) { in smc_poll()
2898 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags); in smc_poll()
2900 if (sk->sk_state != SMC_INIT) { in smc_poll()
2903 if (atomic_read(&smc->conn.sndbuf_space)) in smc_poll()
2907 if (atomic_read(&smc->conn.bytes_to_rcv)) in smc_poll()
2909 if (sk->sk_shutdown & RCV_SHUTDOWN) in smc_poll()
2911 if (sk->sk_state == SMC_APPCLOSEWAIT1) in smc_poll()
2913 if (smc->conn.urg_state == SMC_URG_VALID) in smc_poll()
2923 struct sock *sk = sock->sk; in smc_shutdown()
2925 struct smc_sock *smc; in smc_shutdown() local
2926 int rc = -EINVAL; in smc_shutdown()
2930 smc = smc_sk(sk); in smc_shutdown()
2937 if (sock->state == SS_CONNECTING) { in smc_shutdown()
2938 if (sk->sk_state == SMC_ACTIVE) in smc_shutdown()
2939 sock->state = SS_CONNECTED; in smc_shutdown()
2940 else if (sk->sk_state == SMC_PEERCLOSEWAIT1 || in smc_shutdown()
2941 sk->sk_state == SMC_PEERCLOSEWAIT2 || in smc_shutdown()
2942 sk->sk_state == SMC_APPCLOSEWAIT1 || in smc_shutdown()
2943 sk->sk_state == SMC_APPCLOSEWAIT2 || in smc_shutdown()
2944 sk->sk_state == SMC_APPFINCLOSEWAIT) in smc_shutdown()
2945 sock->state = SS_DISCONNECTING; in smc_shutdown()
2948 rc = -ENOTCONN; in smc_shutdown()
2949 if ((sk->sk_state != SMC_ACTIVE) && in smc_shutdown()
2950 (sk->sk_state != SMC_PEERCLOSEWAIT1) && in smc_shutdown()
2951 (sk->sk_state != SMC_PEERCLOSEWAIT2) && in smc_shutdown()
2952 (sk->sk_state != SMC_APPCLOSEWAIT1) && in smc_shutdown()
2953 (sk->sk_state != SMC_APPCLOSEWAIT2) && in smc_shutdown()
2954 (sk->sk_state != SMC_APPFINCLOSEWAIT)) in smc_shutdown()
2956 if (smc->use_fallback) { in smc_shutdown()
2957 rc = kernel_sock_shutdown(smc->clcsock, how); in smc_shutdown()
2958 sk->sk_shutdown = smc->clcsock->sk->sk_shutdown; in smc_shutdown()
2959 if (sk->sk_shutdown == SHUTDOWN_MASK) { in smc_shutdown()
2960 sk->sk_state = SMC_CLOSED; in smc_shutdown()
2961 sk->sk_socket->state = SS_UNCONNECTED; in smc_shutdown()
2968 old_state = sk->sk_state; in smc_shutdown()
2969 rc = smc_close_active(smc); in smc_shutdown()
2971 sk->sk_state == SMC_PEERCLOSEWAIT1) in smc_shutdown()
2975 rc = smc_close_shutdown_write(smc); in smc_shutdown()
2982 if (do_shutdown && smc->clcsock) in smc_shutdown()
2983 rc1 = kernel_sock_shutdown(smc->clcsock, how); in smc_shutdown()
2985 sk->sk_shutdown |= how + 1; in smc_shutdown()
2987 if (sk->sk_state == SMC_CLOSED) in smc_shutdown()
2988 sock->state = SS_UNCONNECTED; in smc_shutdown()
2990 sock->state = SS_DISCONNECTING; in smc_shutdown()
2999 struct smc_sock *smc; in __smc_getsockopt() local
3002 smc = smc_sk(sock->sk); in __smc_getsockopt()
3005 return -EFAULT; in __smc_getsockopt()
3010 return -EINVAL; in __smc_getsockopt()
3014 val = smc->limit_smc_hs; in __smc_getsockopt()
3017 return -EOPNOTSUPP; in __smc_getsockopt()
3021 return -EFAULT; in __smc_getsockopt()
3023 return -EFAULT; in __smc_getsockopt()
3031 struct sock *sk = sock->sk; in __smc_setsockopt()
3032 struct smc_sock *smc; in __smc_setsockopt() local
3035 smc = smc_sk(sk); in __smc_setsockopt()
3041 rc = -EINVAL; in __smc_setsockopt()
3045 rc = -EFAULT; in __smc_setsockopt()
3049 smc->limit_smc_hs = !!val; in __smc_setsockopt()
3053 rc = -EOPNOTSUPP; in __smc_setsockopt()
3064 struct sock *sk = sock->sk; in smc_setsockopt()
3065 struct smc_sock *smc; in smc_setsockopt() local
3069 return -EOPNOTSUPP; in smc_setsockopt()
3073 smc = smc_sk(sk); in smc_setsockopt()
3078 mutex_lock(&smc->clcsock_release_lock); in smc_setsockopt()
3079 if (!smc->clcsock) { in smc_setsockopt()
3080 mutex_unlock(&smc->clcsock_release_lock); in smc_setsockopt()
3081 return -EBADF; in smc_setsockopt()
3083 if (unlikely(!smc->clcsock->ops->setsockopt)) in smc_setsockopt()
3084 rc = -EOPNOTSUPP; in smc_setsockopt()
3086 rc = smc->clcsock->ops->setsockopt(smc->clcsock, level, optname, in smc_setsockopt()
3088 if (smc->clcsock->sk->sk_err) { in smc_setsockopt()
3089 sk->sk_err = smc->clcsock->sk->sk_err; in smc_setsockopt()
3092 mutex_unlock(&smc->clcsock_release_lock); in smc_setsockopt()
3095 return -EINVAL; in smc_setsockopt()
3097 return -EFAULT; in smc_setsockopt()
3100 if (rc || smc->use_fallback) in smc_setsockopt()
3107 /* option not supported by SMC */ in smc_setsockopt()
3108 if (sk->sk_state == SMC_INIT && !smc->connect_nonblock) { in smc_setsockopt()
3109 rc = smc_switch_to_fallback(smc, SMC_CLC_DECL_OPTUNSUPP); in smc_setsockopt()
3111 rc = -EINVAL; in smc_setsockopt()
3115 if (sk->sk_state != SMC_INIT && in smc_setsockopt()
3116 sk->sk_state != SMC_LISTEN && in smc_setsockopt()
3117 sk->sk_state != SMC_CLOSED) { in smc_setsockopt()
3119 SMC_STAT_INC(smc, ndly_cnt); in smc_setsockopt()
3120 smc_tx_pending(&smc->conn); in smc_setsockopt()
3121 cancel_delayed_work(&smc->conn.tx_work); in smc_setsockopt()
3126 if (sk->sk_state != SMC_INIT && in smc_setsockopt()
3127 sk->sk_state != SMC_LISTEN && in smc_setsockopt()
3128 sk->sk_state != SMC_CLOSED) { in smc_setsockopt()
3130 SMC_STAT_INC(smc, cork_cnt); in smc_setsockopt()
3131 smc_tx_pending(&smc->conn); in smc_setsockopt()
3132 cancel_delayed_work(&smc->conn.tx_work); in smc_setsockopt()
3137 smc->sockopt_defer_accept = val; in smc_setsockopt()
3151 struct smc_sock *smc; in smc_getsockopt() local
3157 smc = smc_sk(sock->sk); in smc_getsockopt()
3158 mutex_lock(&smc->clcsock_release_lock); in smc_getsockopt()
3159 if (!smc->clcsock) { in smc_getsockopt()
3160 mutex_unlock(&smc->clcsock_release_lock); in smc_getsockopt()
3161 return -EBADF; in smc_getsockopt()
3164 if (unlikely(!smc->clcsock->ops->getsockopt)) { in smc_getsockopt()
3165 mutex_unlock(&smc->clcsock_release_lock); in smc_getsockopt()
3166 return -EOPNOTSUPP; in smc_getsockopt()
3168 rc = smc->clcsock->ops->getsockopt(smc->clcsock, level, optname, in smc_getsockopt()
3170 mutex_unlock(&smc->clcsock_release_lock); in smc_getsockopt()
3179 struct smc_sock *smc; in smc_ioctl() local
3182 smc = smc_sk(sock->sk); in smc_ioctl()
3183 conn = &smc->conn; in smc_ioctl()
3184 lock_sock(&smc->sk); in smc_ioctl()
3185 if (smc->use_fallback) { in smc_ioctl()
3186 if (!smc->clcsock) { in smc_ioctl()
3187 release_sock(&smc->sk); in smc_ioctl()
3188 return -EBADF; in smc_ioctl()
3190 answ = smc->clcsock->ops->ioctl(smc->clcsock, cmd, arg); in smc_ioctl()
3191 release_sock(&smc->sk); in smc_ioctl()
3196 if (smc->sk.sk_state == SMC_LISTEN) { in smc_ioctl()
3197 release_sock(&smc->sk); in smc_ioctl()
3198 return -EINVAL; in smc_ioctl()
3200 if (smc->sk.sk_state == SMC_INIT || in smc_ioctl()
3201 smc->sk.sk_state == SMC_CLOSED) in smc_ioctl()
3204 answ = atomic_read(&smc->conn.bytes_to_rcv); in smc_ioctl()
3208 if (smc->sk.sk_state == SMC_LISTEN) { in smc_ioctl()
3209 release_sock(&smc->sk); in smc_ioctl()
3210 return -EINVAL; in smc_ioctl()
3212 if (smc->sk.sk_state == SMC_INIT || in smc_ioctl()
3213 smc->sk.sk_state == SMC_CLOSED) in smc_ioctl()
3216 answ = smc->conn.sndbuf_desc->len - in smc_ioctl()
3217 atomic_read(&smc->conn.sndbuf_space); in smc_ioctl()
3221 if (smc->sk.sk_state == SMC_LISTEN) { in smc_ioctl()
3222 release_sock(&smc->sk); in smc_ioctl()
3223 return -EINVAL; in smc_ioctl()
3225 if (smc->sk.sk_state == SMC_INIT || in smc_ioctl()
3226 smc->sk.sk_state == SMC_CLOSED) in smc_ioctl()
3229 answ = smc_tx_prepared_sends(&smc->conn); in smc_ioctl()
3232 if (smc->sk.sk_state == SMC_LISTEN) { in smc_ioctl()
3233 release_sock(&smc->sk); in smc_ioctl()
3234 return -EINVAL; in smc_ioctl()
3236 if (smc->sk.sk_state == SMC_INIT || in smc_ioctl()
3237 smc->sk.sk_state == SMC_CLOSED) { in smc_ioctl()
3240 smc_curs_copy(&cons, &conn->local_tx_ctrl.cons, conn); in smc_ioctl()
3241 smc_curs_copy(&urg, &conn->urg_curs, conn); in smc_ioctl()
3242 answ = smc_curs_diff(conn->rmb_desc->len, in smc_ioctl()
3247 release_sock(&smc->sk); in smc_ioctl()
3248 return -ENOIOCTLCMD; in smc_ioctl()
3250 release_sock(&smc->sk); in smc_ioctl()
3256 * to splice in conn->splice_pending, and press 'go'. Delays consumer cursor
3265 struct sock *sk = sock->sk; in smc_splice_read()
3266 struct smc_sock *smc; in smc_splice_read() local
3267 int rc = -ENOTCONN; in smc_splice_read()
3269 smc = smc_sk(sk); in smc_splice_read()
3271 if (sk->sk_state == SMC_CLOSED && (sk->sk_shutdown & RCV_SHUTDOWN)) { in smc_splice_read()
3276 if (sk->sk_state == SMC_INIT || in smc_splice_read()
3277 sk->sk_state == SMC_LISTEN || in smc_splice_read()
3278 sk->sk_state == SMC_CLOSED) in smc_splice_read()
3281 if (sk->sk_state == SMC_PEERFINCLOSEWAIT) { in smc_splice_read()
3286 if (smc->use_fallback) { in smc_splice_read()
3287 rc = smc->clcsock->ops->splice_read(smc->clcsock, ppos, in smc_splice_read()
3291 rc = -ESPIPE; in smc_splice_read()
3298 SMC_STAT_INC(smc, splice_cnt); in smc_splice_read()
3299 rc = smc_rx_recvmsg(smc, NULL, pipe, len, flags); in smc_splice_read()
3331 struct smc_sock *smc = smc_sk(sk); in smc_create_clcsk() local
3335 &smc->clcsock); in smc_create_clcsk()
3339 /* smc_clcsock_release() does not wait smc->clcsock->sk's in smc_create_clcsk()
3341 * smc->sk is close()d, and TCP timers can be fired later, in smc_create_clcsk()
3344 sk = smc->clcsock->sk; in smc_create_clcsk()
3353 struct smc_sock *smc; in __smc_create() local
3357 rc = -ESOCKTNOSUPPORT; in __smc_create()
3358 if (sock->type != SOCK_STREAM) in __smc_create()
3361 rc = -EPROTONOSUPPORT; in __smc_create()
3365 rc = -ENOBUFS; in __smc_create()
3366 sock->ops = &smc_sock_ops; in __smc_create()
3367 sock->state = SS_UNCONNECTED; in __smc_create()
3373 smc = smc_sk(sk); in __smc_create()
3377 smc->clcsock = clcsock; in __smc_create()
3383 sock->sk = NULL; in __smc_create()
3403 struct socket *tcp = sk->sk_socket; in smc_ulp_init()
3409 if (tcp->type != SOCK_STREAM || sk->sk_protocol != IPPROTO_TCP || in smc_ulp_init()
3410 (sk->sk_family != AF_INET && sk->sk_family != AF_INET6)) in smc_ulp_init()
3411 return -ESOCKTNOSUPPORT; in smc_ulp_init()
3413 if (tcp->state != SS_UNCONNECTED || !tcp->file || tcp->wq.fasync_list) in smc_ulp_init()
3414 return -ENOTCONN; in smc_ulp_init()
3416 if (sk->sk_family == AF_INET) in smc_ulp_init()
3423 return -ENFILE; in smc_ulp_init()
3425 smcsock->type = SOCK_STREAM; in smc_ulp_init()
3433 /* replace tcp socket to smc */ in smc_ulp_init()
3434 smcsock->file = tcp->file; in smc_ulp_init()
3435 smcsock->file->private_data = smcsock; in smc_ulp_init()
3436 smcsock->file->f_inode = SOCK_INODE(smcsock); /* replace inode when sock_close */ in smc_ulp_init()
3437 smcsock->file->f_path.dentry->d_inode = SOCK_INODE(smcsock); /* dput() in __fput */ in smc_ulp_init()
3438 tcp->file = NULL; in smc_ulp_init()
3449 icsk->icsk_ulp_ops = NULL; in smc_ulp_clone()
3453 .name = "smc",
3490 .id = &smc_net_id,
3524 rc = -ENOMEM; in smc_init()
3662 MODULE_DESCRIPTION("smc socket address family");
3665 MODULE_ALIAS_TCP_ULP("smc");