From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from mx0a-001b2d01.pphosted.com (mx0a-001b2d01.pphosted.com [148.163.156.1]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id AA3B05644E; Mon, 26 Aug 2024 19:25:00 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=148.163.156.1 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1724700305; cv=none; b=gLxLWphUdx+i4/8gF0xOI04i+chG6mQ5ym2EQlnQQ7CNctyvD/vzeh/fOSRHQD7ez9T2IYpRrSJm2WVbhuV89ZjwV0+oIzA16nmbe2Xg/Ug2Y/YCjzZu5t+2WTDZXfl5QMUUCJiq89aw15IGWY3BhIT4ULZrXyk2/WeSYsbpuu8= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1724700305; c=relaxed/simple; bh=qrEPfKHAadjmsr8d7rk7uTXZUSLxQTaeQnWOQvN0PMc=; h=Message-ID:Date:MIME-Version:Subject:To:Cc:References:From: In-Reply-To:Content-Type; b=m0XVbH37MHs4bhrubGMxM93XObG0MhCHS6/eESjAq2H7bDWWNqn6rT/tFrFelqlpvkHnKaj4hUFU8QojX2XAK/jivAbYYH1gmMUJLljI425cWsIbDDl+sc84X6VKYaDAN+jHqvsq3Vt9z+4aUIEsC19/dmJBJtyy9/PP+RqjSPI= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.ibm.com; spf=pass smtp.mailfrom=linux.ibm.com; dkim=pass (2048-bit key) header.d=ibm.com header.i=@ibm.com header.b=ScVojoA5; arc=none smtp.client-ip=148.163.156.1 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=linux.ibm.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=linux.ibm.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=ibm.com header.i=@ibm.com header.b="ScVojoA5" Received: from pps.filterd (m0360083.ppops.net [127.0.0.1]) by mx0a-001b2d01.pphosted.com (8.18.1.2/8.18.1.2) with ESMTP id 47QGAdvw023994; Mon, 26 Aug 2024 19:24:54 GMT DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=ibm.com; h= message-id:date:mime-version:subject:to:cc:references:from :in-reply-to:content-type:content-transfer-encoding; s=pp1; bh=t 146EI4mfJBDnZPm8fdvg2CHXQKJcameeUorHB/A9OM=; b=ScVojoA5f+Z40PK4T 7H5jzOuDHPiH1ycq2GY4xrFoCDNxva7Otkp0FlXD3lyay9BAmGWsjgqGC2rvMJYf xH2s2WRBzGPwtl49OpM1GLADOJkApaFbVCZlPSfKmZl3Qxm5LtlwvrTvWMlhtSD5 p+2juaOWaZC5o5wCltVWxQIGcSGc7uQwpY4XnSgVUHUri+MbWHbHmYDaa1uRvXNh S4o0RJ9bP+TBqXeArN5ki57FdJ46CeArFwlxWxlHOiP/HPP1lEME9xUPPSmlwK08 WoPulh+5yfQcFrp+5zOxrP9uWpPkvf0uzC+EsnbX9Ej0jrM0MGwnucbiSYnHqumW 4KuqQ== Received: from pps.reinject (localhost [127.0.0.1]) by mx0a-001b2d01.pphosted.com (PPS) with ESMTPS id 417g51gdgj-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 26 Aug 2024 19:24:54 +0000 (GMT) Received: from m0360083.ppops.net (m0360083.ppops.net [127.0.0.1]) by pps.reinject (8.18.0.8/8.18.0.8) with ESMTP id 47QJOrL1030285; Mon, 26 Aug 2024 19:24:53 GMT Received: from ppma12.dal12v.mail.ibm.com (dc.9e.1632.ip4.static.sl-reverse.com [50.22.158.220]) by mx0a-001b2d01.pphosted.com (PPS) with ESMTPS id 417g51gdga-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 26 Aug 2024 19:24:53 +0000 (GMT) Received: from pps.filterd (ppma12.dal12v.mail.ibm.com [127.0.0.1]) by ppma12.dal12v.mail.ibm.com (8.18.1.2/8.18.1.2) with ESMTP id 47QG8Mh5021752; Mon, 26 Aug 2024 19:24:52 GMT Received: from smtprelay07.fra02v.mail.ibm.com ([9.218.2.229]) by ppma12.dal12v.mail.ibm.com (PPS) with ESMTPS id 417suu7qdh-1 (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256 verify=NOT); Mon, 26 Aug 2024 19:24:52 +0000 Received: from smtpav05.fra02v.mail.ibm.com (smtpav05.fra02v.mail.ibm.com [10.20.54.104]) by smtprelay07.fra02v.mail.ibm.com (8.14.9/8.14.9/NCO v10.0) with ESMTP id 47QJOmJN45875466 (version=TLSv1/SSLv3 cipher=DHE-RSA-AES256-GCM-SHA384 bits=256 verify=OK); Mon, 26 Aug 2024 19:24:48 GMT Received: from smtpav05.fra02v.mail.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 49E1F2004B; Mon, 26 Aug 2024 19:24:48 +0000 (GMT) Received: from smtpav05.fra02v.mail.ibm.com (unknown [127.0.0.1]) by IMSVA (Postfix) with ESMTP id 3144420040; Mon, 26 Aug 2024 19:24:47 +0000 (GMT) Received: from [9.171.82.113] (unknown [9.171.82.113]) by smtpav05.fra02v.mail.ibm.com (Postfix) with ESMTP; Mon, 26 Aug 2024 19:24:47 +0000 (GMT) Message-ID: Date: Mon, 26 Aug 2024 21:24:46 +0200 Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Subject: Re: [PATCH net,v5,2/2] net/smc: modify smc_sock structure To: "D. Wythe" , Jeongjun Park Cc: davem@davemloft.net, dust.li@linux.alibaba.com, edumazet@google.com, guwen@linux.alibaba.com, kuba@kernel.org, linux-kernel@vger.kernel.org, linux-s390@vger.kernel.org, netdev@vger.kernel.org, pabeni@redhat.com, tonylu@linux.alibaba.com, ubraun@linux.vnet.ibm.com, utz.bacher@de.ibm.com, wenjia@linux.ibm.com References: <42f2d707-cf7e-4cb7-a10b-8bd2e851879e@linux.ibm.com> <20240821110625.49755-1-aha310510@gmail.com> <245f02d5-43ea-46d7-9cc9-c80385dbb062@linux.ibm.com> From: Jan Karcher Organization: IBM - Network Linux on Z In-Reply-To: Content-Type: text/plain; charset=UTF-8; format=flowed Content-Transfer-Encoding: 8bit X-TM-AS-GCONF: 00 X-Proofpoint-ORIG-GUID: uBu0ZSCo8kZKIxBn4Fy3PjmnY0LPIEcT X-Proofpoint-GUID: -hWxBveXO0dXTiU53KxhdBR1vf0gd0qD X-Proofpoint-Virus-Version: vendor=baseguard engine=ICAP:2.0.293,Aquarius:18.0.1039,Hydra:6.0.680,FMLib:17.12.28.16 definitions=2024-08-26_14,2024-08-26_01,2024-05-17_01 X-Proofpoint-Spam-Details: rule=outbound_notspam policy=outbound score=0 mlxlogscore=999 lowpriorityscore=0 impostorscore=0 adultscore=0 spamscore=0 priorityscore=1501 malwarescore=0 suspectscore=0 clxscore=1015 phishscore=0 bulkscore=0 mlxscore=0 classifier=spam adjust=0 reason=mlx scancount=1 engine=8.19.0-2407110000 definitions=main-2408260145 On 26/08/2024 04:56, D. Wythe wrote: > > > On 8/22/24 3:19 PM, Jan Karcher wrote: >> >> >> On 21/08/2024 13:06, Jeongjun Park wrote: >>> Jan Karcher wrote: >>>> >>>> >> >> [...] >> >>>> >>>> If so would you mind adding a helper for this check as Paolo suggested >>>> and send it? >>>> This way we see which change is better for the future. >>> >>> This is the patch I tested. Except for smc.h and smc_inet.c, the rest is >>> just a patch that changes smc->sk to smc->inet.sk. When I tested using >>> this patch and c repro, the vulnerability was not triggered. >>> >>> Regards, >>> Jeongjun Park >> >> Thank you for providing your changes. TBH, I do like only having the >> inet socket in our structure. >> I did not review it completley since there are, obviously, a lot of >> changes. >> Testing looks good so far but needs some more time. >> >> @D. Wythe are there any concerns from your side regarding this solution? >> >> Thanks, >> Jan >> > > Well, I really don't think this is a good idea. As we've mentioned, for > AF_SMC, smc_sock should not be treated as inet_sock. > While in terms of actual running logic, this approach yields the same > result as using a union, but the use of a union clearly indicates > that it includes two distinct types of socks. Fair. I understand both sides here and i do not have a strong opinion. One is kinda implicit, the other defines fields we do not use... Of course there would be a compromise to define another struct something like this: struct smc_sock_types { struct sock sk; #if IS_ENABLED(CONFIG_IPV6) struct ipv6_pinfo *pinet6; #endif }; struct smc_sock { /* smc sock container */ struct smc_sock_types socks; [...] That said, don't know if i like this either. Thanks - Jan > > Also, if you have to make this change, perhaps you can give it a try > > #define smc->sk smc->inet.sk > > This will save lots of modifications. > > Thanks, > D. Wythe > >>> >>>> >>>> The statement that SMC would be more aligned with other AFs is >>>> already a >>>>    big win in my book. >>>> >>>> Thanks >>>> - Jan >>>> >>>>> >>>>> Thanks, >>>>> >>>>> Paolo >>>>> >>> >>> --- >>>   net/smc/af_smc.c         | 176 +++++++++++++++++++-------------------- >>>   net/smc/smc.h            |   4 +- >>>   net/smc/smc_cdc.c        |  40 ++++----- >>>   net/smc/smc_clc.c        |  28 +++---- >>>   net/smc/smc_close.c      |  16 ++-- >>>   net/smc/smc_core.c       |  68 +++++++-------- >>>   net/smc/smc_inet.c       |   8 +- >>>   net/smc/smc_rx.c         |  16 ++-- >>>   net/smc/smc_stats.h      |  10 +-- >>>   net/smc/smc_tracepoint.h |   4 +- >>>   net/smc/smc_tx.c         |  28 +++---- >>>   11 files changed, 202 insertions(+), 196 deletions(-) >>> >>> diff --git a/net/smc/af_smc.c b/net/smc/af_smc.c >>> index 8e3093938cd2..d2783e715604 100644 >>> --- a/net/smc/af_smc.c >>> +++ b/net/smc/af_smc.c >>> @@ -132,7 +132,7 @@ static struct sock *smc_tcp_syn_recv_sock(const >>> struct sock *sk, >>>                   sk->sk_max_ack_backlog) >>>           goto drop; >>>   -    if (sk_acceptq_is_full(&smc->sk)) { >>> +    if (sk_acceptq_is_full(&smc->inet.sk)) { >>>           NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS); >>>           goto drop; >>>       } >>> @@ -262,7 +262,7 @@ static void smc_fback_restore_callbacks(struct >>> smc_sock *smc) >>>   static void smc_restore_fallback_changes(struct smc_sock *smc) >>>   { >>>       if (smc->clcsock->file) { /* non-accepted sockets have no file >>> yet */ >>> -        smc->clcsock->file->private_data = smc->sk.sk_socket; >>> +        smc->clcsock->file->private_data = smc->inet.sk.sk_socket; >>>           smc->clcsock->file = NULL; >>>           smc_fback_restore_callbacks(smc); >>>       } >>> @@ -270,7 +270,7 @@ static void smc_restore_fallback_changes(struct >>> smc_sock *smc) >>>     static int __smc_release(struct smc_sock *smc) >>>   { >>> -    struct sock *sk = &smc->sk; >>> +    struct sock *sk = &smc->inet.sk; >>>       int rc = 0; >>>         if (!smc->use_fallback) { >>> @@ -327,7 +327,7 @@ int smc_release(struct socket *sock) >>>           tcp_abort(smc->clcsock->sk, ECONNABORTED); >>>         if (cancel_work_sync(&smc->connect_work)) >>> -        sock_put(&smc->sk); /* sock_hold in smc_connect for passive >>> closing */ >>> +        sock_put(&smc->inet.sk); /* sock_hold in smc_connect for >>> passive closing */ >>>         if (sk->sk_state == SMC_LISTEN) >>>           /* smc_close_non_accepted() is called and acquires >>> @@ -496,7 +496,7 @@ static void smc_copy_sock_settings(struct sock >>> *nsk, struct sock *osk, >>>     static void smc_copy_sock_settings_to_clc(struct smc_sock *smc) >>>   { >>> -    smc_copy_sock_settings(smc->clcsock->sk, &smc->sk, >>> SK_FLAGS_SMC_TO_CLC); >>> +    smc_copy_sock_settings(smc->clcsock->sk, &smc->inet.sk, >>> SK_FLAGS_SMC_TO_CLC); >>>   } >>>     #define SK_FLAGS_CLC_TO_SMC ((1UL << SOCK_URGINLINE) | \ >>> @@ -506,7 +506,7 @@ static void smc_copy_sock_settings_to_clc(struct >>> smc_sock *smc) >>>   /* copy only settings and flags relevant for smc from clc to smc >>> socket */ >>>   static void smc_copy_sock_settings_to_smc(struct smc_sock *smc) >>>   { >>> -    smc_copy_sock_settings(&smc->sk, smc->clcsock->sk, >>> SK_FLAGS_CLC_TO_SMC); >>> +    smc_copy_sock_settings(&smc->inet.sk, smc->clcsock->sk, >>> SK_FLAGS_CLC_TO_SMC); >>>   } >>>     /* register the new vzalloced sndbuf on all links */ >>> @@ -757,7 +757,7 @@ static void smc_stat_inc_fback_rsn_cnt(struct >>> smc_sock *smc, >>>     static void smc_stat_fallback(struct smc_sock *smc) >>>   { >>> -    struct net *net = sock_net(&smc->sk); >>> +    struct net *net = sock_net(&smc->inet.sk); >>>         mutex_lock(&net->smc.mutex_fback_rsn); >>>       if (smc->listen_smc) { >>> @@ -776,7 +776,7 @@ static void smc_fback_wakeup_waitqueue(struct >>> smc_sock *smc, void *key) >>>       struct socket_wq *wq; >>>       __poll_t flags; >>>   -    wq = rcu_dereference(smc->sk.sk_wq); >>> +    wq = rcu_dereference(smc->inet.sk.sk_wq); >>>       if (!skwq_has_sleeper(wq)) >>>           return; >>>   @@ -909,12 +909,12 @@ static int smc_switch_to_fallback(struct >>> smc_sock *smc, int reason_code) >>>       smc->fallback_rsn = reason_code; >>>       smc_stat_fallback(smc); >>>       trace_smc_switch_to_fallback(smc, reason_code); >>> -    if (smc->sk.sk_socket && smc->sk.sk_socket->file) { >>> -        smc->clcsock->file = smc->sk.sk_socket->file; >>> +    if (smc->inet.sk.sk_socket && smc->inet.sk.sk_socket->file) { >>> +        smc->clcsock->file = smc->inet.sk.sk_socket->file; >>>           smc->clcsock->file->private_data = smc->clcsock; >>>           smc->clcsock->wq.fasync_list = >>> -            smc->sk.sk_socket->wq.fasync_list; >>> -        smc->sk.sk_socket->wq.fasync_list = NULL; >>> +            smc->inet.sk.sk_socket->wq.fasync_list; >>> +        smc->inet.sk.sk_socket->wq.fasync_list = NULL; >>>             /* There might be some wait entries remaining >>>            * in smc sk->sk_wq and they should be woken up >>> @@ -930,20 +930,20 @@ static int smc_switch_to_fallback(struct >>> smc_sock *smc, int reason_code) >>>   /* fall back during connect */ >>>   static int smc_connect_fallback(struct smc_sock *smc, int reason_code) >>>   { >>> -    struct net *net = sock_net(&smc->sk); >>> +    struct net *net = sock_net(&smc->inet.sk); >>>       int rc = 0; >>>         rc = smc_switch_to_fallback(smc, reason_code); >>>       if (rc) { /* fallback fails */ >>> this_cpu_inc(net->smc.smc_stats->clnt_hshake_err_cnt); >>> -        if (smc->sk.sk_state == SMC_INIT) >>> -            sock_put(&smc->sk); /* passive closing */ >>> +        if (smc->inet.sk.sk_state == SMC_INIT) >>> +            sock_put(&smc->inet.sk); /* passive closing */ >>>           return rc; >>>       } >>>       smc_copy_sock_settings_to_clc(smc); >>>       smc->connect_nonblock = 0; >>> -    if (smc->sk.sk_state == SMC_INIT) >>> -        smc->sk.sk_state = SMC_ACTIVE; >>> +    if (smc->inet.sk.sk_state == SMC_INIT) >>> +        smc->inet.sk.sk_state = SMC_ACTIVE; >>>       return 0; >>>   } >>>   @@ -951,21 +951,21 @@ static int smc_connect_fallback(struct >>> smc_sock *smc, int reason_code) >>>   static int smc_connect_decline_fallback(struct smc_sock *smc, int >>> reason_code, >>>                       u8 version) >>>   { >>> -    struct net *net = sock_net(&smc->sk); >>> +    struct net *net = sock_net(&smc->inet.sk); >>>       int rc; >>>         if (reason_code < 0) { /* error, fallback is not possible */ >>> this_cpu_inc(net->smc.smc_stats->clnt_hshake_err_cnt); >>> -        if (smc->sk.sk_state == SMC_INIT) >>> -            sock_put(&smc->sk); /* passive closing */ >>> +        if (smc->inet.sk.sk_state == SMC_INIT) >>> +            sock_put(&smc->inet.sk); /* passive closing */ >>>           return reason_code; >>>       } >>>       if (reason_code != SMC_CLC_DECL_PEERDECL) { >>>           rc = smc_clc_send_decline(smc, reason_code, version); >>>           if (rc < 0) { >>> this_cpu_inc(net->smc.smc_stats->clnt_hshake_err_cnt); >>> -            if (smc->sk.sk_state == SMC_INIT) >>> -                sock_put(&smc->sk); /* passive closing */ >>> +            if (smc->inet.sk.sk_state == SMC_INIT) >>> +                sock_put(&smc->inet.sk); /* passive closing */ >>>               return rc; >>>           } >>>       } >>> @@ -1050,7 +1050,7 @@ static int smc_find_ism_v2_device_clnt(struct >>> smc_sock *smc, >>>               continue; >>>           is_emulated = __smc_ism_is_emulated(chid); >>>           if (!smc_pnet_is_pnetid_set(smcd->pnetid) || >>> -            smc_pnet_is_ndev_pnetid(sock_net(&smc->sk), >>> smcd->pnetid)) { >>> + smc_pnet_is_ndev_pnetid(sock_net(&smc->inet.sk), smcd->pnetid)) { >>>               if (is_emulated && entry == SMCD_CLC_MAX_V2_GID_ENTRIES) >>>                   /* It's the last GID-CHID entry left in CLC >>>                    * Proposal SMC-Dv2 extension, but an Emulated- >>> @@ -1200,7 +1200,7 @@ static int smc_connect_rdma_v2_prepare(struct >>> smc_sock *smc, >>>   { >>>       struct smc_clc_first_contact_ext *fce = >>>           smc_get_clc_first_contact_ext(aclc, false); >>> -    struct net *net = sock_net(&smc->sk); >>> +    struct net *net = sock_net(&smc->inet.sk); >>>       int rc; >>>         if (!ini->first_contact_peer || aclc->hdr.version == SMC_V1) >>> @@ -1347,8 +1347,8 @@ static int smc_connect_rdma(struct smc_sock *smc, >>>         smc_copy_sock_settings_to_clc(smc); >>>       smc->connect_nonblock = 0; >>> -    if (smc->sk.sk_state == SMC_INIT) >>> -        smc->sk.sk_state = SMC_ACTIVE; >>> +    if (smc->inet.sk.sk_state == SMC_INIT) >>> +        smc->inet.sk.sk_state = SMC_ACTIVE; >>>         return 0; >>>   connect_abort: >>> @@ -1450,8 +1450,8 @@ static int smc_connect_ism(struct smc_sock *smc, >>>         smc_copy_sock_settings_to_clc(smc); >>>       smc->connect_nonblock = 0; >>> -    if (smc->sk.sk_state == SMC_INIT) >>> -        smc->sk.sk_state = SMC_ACTIVE; >>> +    if (smc->inet.sk.sk_state == SMC_INIT) >>> +        smc->inet.sk.sk_state = SMC_ACTIVE; >>>         return 0; >>>   connect_abort: >>> @@ -1546,7 +1546,7 @@ static int __smc_connect(struct smc_sock *smc) >>>           /* -EAGAIN on timeout, see tcp_recvmsg() */ >>>           if (rc == -EAGAIN) { >>>               rc = -ETIMEDOUT; >>> -            smc->sk.sk_err = ETIMEDOUT; >>> +            smc->inet.sk.sk_err = ETIMEDOUT; >>>           } >>>           goto vlan_cleanup; >>>       } >>> @@ -1586,14 +1586,14 @@ static void smc_connect_work(struct >>> work_struct *work) >>>   { >>>       struct smc_sock *smc = container_of(work, struct smc_sock, >>>                           connect_work); >>> -    long timeo = smc->sk.sk_sndtimeo; >>> +    long timeo = smc->inet.sk.sk_sndtimeo; >>>       int rc = 0; >>>         if (!timeo) >>>           timeo = MAX_SCHEDULE_TIMEOUT; >>>       lock_sock(smc->clcsock->sk); >>>       if (smc->clcsock->sk->sk_err) { >>> -        smc->sk.sk_err = smc->clcsock->sk->sk_err; >>> +        smc->inet.sk.sk_err = smc->clcsock->sk->sk_err; >>>       } else if ((1 << smc->clcsock->sk->sk_state) & >>>                       (TCPF_SYN_SENT | TCPF_SYN_RECV)) { >>>           rc = sk_stream_wait_connect(smc->clcsock->sk, &timeo); >>> @@ -1603,33 +1603,33 @@ static void smc_connect_work(struct >>> work_struct *work) >>>               rc = 0; >>>       } >>>       release_sock(smc->clcsock->sk); >>> -    lock_sock(&smc->sk); >>> -    if (rc != 0 || smc->sk.sk_err) { >>> -        smc->sk.sk_state = SMC_CLOSED; >>> +    lock_sock(&smc->inet.sk); >>> +    if (rc != 0 || smc->inet.sk.sk_err) { >>> +        smc->inet.sk.sk_state = SMC_CLOSED; >>>           if (rc == -EPIPE || rc == -EAGAIN) >>> -            smc->sk.sk_err = EPIPE; >>> +            smc->inet.sk.sk_err = EPIPE; >>>           else if (rc == -ECONNREFUSED) >>> -            smc->sk.sk_err = ECONNREFUSED; >>> +            smc->inet.sk.sk_err = ECONNREFUSED; >>>           else if (signal_pending(current)) >>> -            smc->sk.sk_err = -sock_intr_errno(timeo); >>> -        sock_put(&smc->sk); /* passive closing */ >>> +            smc->inet.sk.sk_err = -sock_intr_errno(timeo); >>> +        sock_put(&smc->inet.sk); /* passive closing */ >>>           goto out; >>>       } >>>         rc = __smc_connect(smc); >>>       if (rc < 0) >>> -        smc->sk.sk_err = -rc; >>> +        smc->inet.sk.sk_err = -rc; >>>     out: >>> -    if (!sock_flag(&smc->sk, SOCK_DEAD)) { >>> -        if (smc->sk.sk_err) { >>> -            smc->sk.sk_state_change(&smc->sk); >>> +    if (!sock_flag(&smc->inet.sk, SOCK_DEAD)) { >>> +        if (smc->inet.sk.sk_err) { >>> + smc->inet.sk.sk_state_change(&smc->inet.sk); >>>           } else { /* allow polling before and after fallback >>> decision */ >>> smc->clcsock->sk->sk_write_space(smc->clcsock->sk); >>> -            smc->sk.sk_write_space(&smc->sk); >>> + smc->inet.sk.sk_write_space(&smc->inet.sk); >>>           } >>>       } >>> -    release_sock(&smc->sk); >>> +    release_sock(&smc->inet.sk); >>>   } >>>     int smc_connect(struct socket *sock, struct sockaddr *addr, >>> @@ -1692,7 +1692,7 @@ int smc_connect(struct socket *sock, struct >>> sockaddr *addr, >>>           sock->state = rc ? SS_CONNECTING : SS_CONNECTED; >>>           goto out; >>>       } >>> -    sock_hold(&smc->sk); /* sock put in passive closing */ >>> +    sock_hold(&smc->inet.sk); /* sock put in passive closing */ >>>       if (flags & O_NONBLOCK) { >>>           if (queue_work(smc_hs_wq, &smc->connect_work)) >>>               smc->connect_nonblock = 1; >>> @@ -1716,7 +1716,7 @@ int smc_connect(struct socket *sock, struct >>> sockaddr *addr, >>>   static int smc_clcsock_accept(struct smc_sock *lsmc, struct >>> smc_sock **new_smc) >>>   { >>>       struct socket *new_clcsock = NULL; >>> -    struct sock *lsk = &lsmc->sk; >>> +    struct sock *lsk = &lsmc->inet.sk; >>>       struct sock *new_sk; >>>       int rc = -EINVAL; >>>   @@ -1793,7 +1793,7 @@ static void smc_accept_unlink(struct sock *sk) >>>       spin_lock(&par->accept_q_lock); >>>       list_del_init(&smc_sk(sk)->accept_q); >>>       spin_unlock(&par->accept_q_lock); >>> -    sk_acceptq_removed(&smc_sk(sk)->listen_smc->sk); >>> + sk_acceptq_removed(&smc_sk(sk)->listen_smc->inet.sk); >>>       sock_put(sk); /* sock_hold in smc_accept_enqueue */ >>>   } >>>   @@ -1904,28 +1904,28 @@ static int smcr_serv_conf_first_link(struct >>> smc_sock *smc) >>>   static void smc_listen_out(struct smc_sock *new_smc) >>>   { >>>       struct smc_sock *lsmc = new_smc->listen_smc; >>> -    struct sock *newsmcsk = &new_smc->sk; >>> +    struct sock *newsmcsk = &new_smc->inet.sk; >>>         if (tcp_sk(new_smc->clcsock->sk)->syn_smc) >>>           atomic_dec(&lsmc->queued_smc_hs); >>>   -    if (lsmc->sk.sk_state == SMC_LISTEN) { >>> -        lock_sock_nested(&lsmc->sk, SINGLE_DEPTH_NESTING); >>> -        smc_accept_enqueue(&lsmc->sk, newsmcsk); >>> -        release_sock(&lsmc->sk); >>> +    if (lsmc->inet.sk.sk_state == SMC_LISTEN) { >>> +        lock_sock_nested(&lsmc->inet.sk, SINGLE_DEPTH_NESTING); >>> +        smc_accept_enqueue(&lsmc->inet.sk, newsmcsk); >>> +        release_sock(&lsmc->inet.sk); >>>       } else { /* no longer listening */ >>>           smc_close_non_accepted(newsmcsk); >>>       } >>>         /* Wake up accept */ >>> -    lsmc->sk.sk_data_ready(&lsmc->sk); >>> -    sock_put(&lsmc->sk); /* sock_hold in smc_tcp_listen_work */ >>> +    lsmc->inet.sk.sk_data_ready(&lsmc->inet.sk); >>> +    sock_put(&lsmc->inet.sk); /* sock_hold in smc_tcp_listen_work */ >>>   } >>>     /* listen worker: finish in state connected */ >>>   static void smc_listen_out_connected(struct smc_sock *new_smc) >>>   { >>> -    struct sock *newsmcsk = &new_smc->sk; >>> +    struct sock *newsmcsk = &new_smc->inet.sk; >>>         if (newsmcsk->sk_state == SMC_INIT) >>>           newsmcsk->sk_state = SMC_ACTIVE; >>> @@ -1936,12 +1936,12 @@ static void smc_listen_out_connected(struct >>> smc_sock *new_smc) >>>   /* listen worker: finish in error state */ >>>   static void smc_listen_out_err(struct smc_sock *new_smc) >>>   { >>> -    struct sock *newsmcsk = &new_smc->sk; >>> +    struct sock *newsmcsk = &new_smc->inet.sk; >>>       struct net *net = sock_net(newsmcsk); >>> this_cpu_inc(net->smc.smc_stats->srv_hshake_err_cnt); >>>       if (newsmcsk->sk_state == SMC_INIT) >>> -        sock_put(&new_smc->sk); /* passive closing */ >>> +        sock_put(&new_smc->inet.sk); /* passive closing */ >>>       newsmcsk->sk_state = SMC_CLOSED; >>>         smc_listen_out(new_smc); >>> @@ -2430,7 +2430,7 @@ static void smc_listen_work(struct work_struct >>> *work) >>>       u8 accept_version; >>>       int rc = 0; >>>   -    if (new_smc->listen_smc->sk.sk_state != SMC_LISTEN) >>> +    if (new_smc->listen_smc->inet.sk.sk_state != SMC_LISTEN) >>>           return smc_listen_out_err(new_smc); >>>         if (new_smc->use_fallback) { >>> @@ -2565,7 +2565,7 @@ static void smc_tcp_listen_work(struct >>> work_struct *work) >>>   { >>>       struct smc_sock *lsmc = container_of(work, struct smc_sock, >>>                            tcp_listen_work); >>> -    struct sock *lsk = &lsmc->sk; >>> +    struct sock *lsk = &lsmc->inet.sk; >>>       struct smc_sock *new_smc; >>>       int rc = 0; >>>   @@ -2586,14 +2586,14 @@ static void smc_tcp_listen_work(struct >>> work_struct *work) >>>           sock_hold(lsk); /* sock_put in smc_listen_work */ >>>           INIT_WORK(&new_smc->smc_listen_work, smc_listen_work); >>>           smc_copy_sock_settings_to_smc(new_smc); >>> -        sock_hold(&new_smc->sk); /* sock_put in passive closing */ >>> +        sock_hold(&new_smc->inet.sk); /* sock_put in passive closing */ >>>           if (!queue_work(smc_hs_wq, &new_smc->smc_listen_work)) >>> -            sock_put(&new_smc->sk); >>> +            sock_put(&new_smc->inet.sk); >>>       } >>>     out: >>>       release_sock(lsk); >>> -    sock_put(&lsmc->sk); /* sock_hold in smc_clcsock_data_ready() */ >>> +    sock_put(&lsmc->inet.sk); /* sock_hold in >>> smc_clcsock_data_ready() */ >>>   } >>>     static void smc_clcsock_data_ready(struct sock *listen_clcsock) >>> @@ -2605,10 +2605,10 @@ static void smc_clcsock_data_ready(struct >>> sock *listen_clcsock) >>>       if (!lsmc) >>>           goto out; >>>       lsmc->clcsk_data_ready(listen_clcsock); >>> -    if (lsmc->sk.sk_state == SMC_LISTEN) { >>> -        sock_hold(&lsmc->sk); /* sock_put in smc_tcp_listen_work() */ >>> +    if (lsmc->inet.sk.sk_state == SMC_LISTEN) { >>> +        sock_hold(&lsmc->inet.sk); /* sock_put in >>> smc_tcp_listen_work() */ >>>           if (!queue_work(smc_tcp_ls_wq, &lsmc->tcp_listen_work)) >>> -            sock_put(&lsmc->sk); >>> +            sock_put(&lsmc->inet.sk); >>>       } >>>   out: >>>       read_unlock_bh(&listen_clcsock->sk_callback_lock); >>> @@ -2692,7 +2692,7 @@ int smc_accept(struct socket *sock, struct >>> socket *new_sock, >>>       sock_hold(sk); /* sock_put below */ >>>       lock_sock(sk); >>>   -    if (lsmc->sk.sk_state != SMC_LISTEN) { >>> +    if (lsmc->inet.sk.sk_state != SMC_LISTEN) { >>>           rc = -EINVAL; >>>           release_sock(sk); >>>           goto out; >>> @@ -3167,36 +3167,36 @@ int smc_ioctl(struct socket *sock, unsigned >>> int cmd, >>>         smc = smc_sk(sock->sk); >>>       conn = &smc->conn; >>> -    lock_sock(&smc->sk); >>> +    lock_sock(&smc->inet.sk); >>>       if (smc->use_fallback) { >>>           if (!smc->clcsock) { >>> -            release_sock(&smc->sk); >>> +            release_sock(&smc->inet.sk); >>>               return -EBADF; >>>           } >>>           answ = smc->clcsock->ops->ioctl(smc->clcsock, cmd, arg); >>> -        release_sock(&smc->sk); >>> +        release_sock(&smc->inet.sk); >>>           return answ; >>>       } >>>       switch (cmd) { >>>       case SIOCINQ: /* same as FIONREAD */ >>> -        if (smc->sk.sk_state == SMC_LISTEN) { >>> -            release_sock(&smc->sk); >>> +        if (smc->inet.sk.sk_state == SMC_LISTEN) { >>> +            release_sock(&smc->inet.sk); >>>               return -EINVAL; >>>           } >>> -        if (smc->sk.sk_state == SMC_INIT || >>> -            smc->sk.sk_state == SMC_CLOSED) >>> +        if (smc->inet.sk.sk_state == SMC_INIT || >>> +            smc->inet.sk.sk_state == SMC_CLOSED) >>>               answ = 0; >>>           else >>>               answ = atomic_read(&smc->conn.bytes_to_rcv); >>>           break; >>>       case SIOCOUTQ: >>>           /* output queue size (not send + not acked) */ >>> -        if (smc->sk.sk_state == SMC_LISTEN) { >>> -            release_sock(&smc->sk); >>> +        if (smc->inet.sk.sk_state == SMC_LISTEN) { >>> +            release_sock(&smc->inet.sk); >>>               return -EINVAL; >>>           } >>> -        if (smc->sk.sk_state == SMC_INIT || >>> -            smc->sk.sk_state == SMC_CLOSED) >>> +        if (smc->inet.sk.sk_state == SMC_INIT || >>> +            smc->inet.sk.sk_state == SMC_CLOSED) >>>               answ = 0; >>>           else >>>               answ = smc->conn.sndbuf_desc->len - >>> @@ -3204,23 +3204,23 @@ int smc_ioctl(struct socket *sock, unsigned >>> int cmd, >>>           break; >>>       case SIOCOUTQNSD: >>>           /* output queue size (not send only) */ >>> -        if (smc->sk.sk_state == SMC_LISTEN) { >>> -            release_sock(&smc->sk); >>> +        if (smc->inet.sk.sk_state == SMC_LISTEN) { >>> +            release_sock(&smc->inet.sk); >>>               return -EINVAL; >>>           } >>> -        if (smc->sk.sk_state == SMC_INIT || >>> -            smc->sk.sk_state == SMC_CLOSED) >>> +        if (smc->inet.sk.sk_state == SMC_INIT || >>> +            smc->inet.sk.sk_state == SMC_CLOSED) >>>               answ = 0; >>>           else >>>               answ = smc_tx_prepared_sends(&smc->conn); >>>           break; >>>       case SIOCATMARK: >>> -        if (smc->sk.sk_state == SMC_LISTEN) { >>> -            release_sock(&smc->sk); >>> +        if (smc->inet.sk.sk_state == SMC_LISTEN) { >>> +            release_sock(&smc->inet.sk); >>>               return -EINVAL; >>>           } >>> -        if (smc->sk.sk_state == SMC_INIT || >>> -            smc->sk.sk_state == SMC_CLOSED) { >>> +        if (smc->inet.sk.sk_state == SMC_INIT || >>> +            smc->inet.sk.sk_state == SMC_CLOSED) { >>>               answ = 0; >>>           } else { >>>               smc_curs_copy(&cons, &conn->local_tx_ctrl.cons, conn); >>> @@ -3230,10 +3230,10 @@ int smc_ioctl(struct socket *sock, unsigned >>> int cmd, >>>           } >>>           break; >>>       default: >>> -        release_sock(&smc->sk); >>> +        release_sock(&smc->inet.sk); >>>           return -ENOIOCTLCMD; >>>       } >>> -    release_sock(&smc->sk); >>> +    release_sock(&smc->inet.sk); >>>         return put_user(answ, (int __user *)arg); >>>   } >>> @@ -3324,7 +3324,7 @@ int smc_create_clcsk(struct net *net, struct >>> sock *sk, int family) >>>         /* smc_clcsock_release() does not wait smc->clcsock->sk's >>>        * destruction;  its sk_state might not be TCP_CLOSE after >>> -     * smc->sk is close()d, and TCP timers can be fired later, >>> +     * smc->inet.sk is close()d, and TCP timers can be fired later, >>>        * which need net ref. >>>        */ >>>       sk = smc->clcsock->sk; >>> diff --git a/net/smc/smc.h b/net/smc/smc.h >>> index 34b781e463c4..7dd76dbea245 100644 >>> --- a/net/smc/smc.h >>> +++ b/net/smc/smc.h >>> @@ -283,7 +283,7 @@ struct smc_connection { >>>   }; >>>     struct smc_sock {                /* smc sock container */ >>> -    struct sock        sk; >>> +    struct inet_sock        inet;    /* inet_sock has to be the >>> first member of smc_sock */ >>>       struct socket        *clcsock;    /* internal tcp socket */ >>>       void            (*clcsk_state_change)(struct sock *sk); >>>                           /* original stat_change fct. */ >>> @@ -327,7 +327,7 @@ struct smc_sock {                /* smc sock >>> container */ >>>                            * */ >>>   }; >>>   -#define smc_sk(ptr) container_of_const(ptr, struct smc_sock, sk) >>> +#define smc_sk(ptr) container_of_const(ptr, struct smc_sock, inet.sk) >>>     static inline void smc_init_saved_callbacks(struct smc_sock *smc) >>>   { >>> diff --git a/net/smc/smc_cdc.c b/net/smc/smc_cdc.c >>> index 619b3bab3824..45d81c87b398 100644 >>> --- a/net/smc/smc_cdc.c >>> +++ b/net/smc/smc_cdc.c >>> @@ -35,7 +35,7 @@ static void smc_cdc_tx_handler(struct >>> smc_wr_tx_pend_priv *pnd_snd, >>>         sndbuf_desc = conn->sndbuf_desc; >>>       smc = container_of(conn, struct smc_sock, conn); >>> -    bh_lock_sock(&smc->sk); >>> +    bh_lock_sock(&smc->inet.sk); >>>       if (!wc_status && sndbuf_desc) { >>>           diff = smc_curs_diff(sndbuf_desc->len, >>>                        &cdcpend->conn->tx_curs_fin, >>> @@ -56,7 +56,7 @@ static void smc_cdc_tx_handler(struct >>> smc_wr_tx_pend_priv *pnd_snd, >>>            * User context will later try to send when it release >>> sock_lock >>>            * in smc_release_cb() >>>            */ >>> -        if (sock_owned_by_user(&smc->sk)) >>> +        if (sock_owned_by_user(&smc->inet.sk)) >>>               conn->tx_in_release_sock = true; >>>           else >>>               smc_tx_pending(conn); >>> @@ -67,7 +67,7 @@ static void smc_cdc_tx_handler(struct >>> smc_wr_tx_pend_priv *pnd_snd, >>>       WARN_ON(atomic_read(&conn->cdc_pend_tx_wr) < 0); >>>         smc_tx_sndbuf_nonfull(smc); >>> -    bh_unlock_sock(&smc->sk); >>> +    bh_unlock_sock(&smc->inet.sk); >>>   } >>>     int smc_cdc_get_free_slot(struct smc_connection *conn, >>> @@ -294,7 +294,7 @@ static void >>> smc_cdc_handle_urg_data_arrival(struct smc_sock *smc, >>>       /* new data included urgent business */ >>>       smc_curs_copy(&conn->urg_curs, &conn->local_rx_ctrl.prod, conn); >>>       conn->urg_state = SMC_URG_VALID; >>> -    if (!sock_flag(&smc->sk, SOCK_URGINLINE)) >>> +    if (!sock_flag(&smc->inet.sk, SOCK_URGINLINE)) >>>           /* we'll skip the urgent byte, so don't account for it */ >>>           (*diff_prod)--; >>>       base = (char *)conn->rmb_desc->cpu_addr + conn->rx_off; >>> @@ -302,7 +302,7 @@ static void >>> smc_cdc_handle_urg_data_arrival(struct smc_sock *smc, >>>           conn->urg_rx_byte = *(base + conn->urg_curs.count - 1); >>>       else >>>           conn->urg_rx_byte = *(base + conn->rmb_desc->len - 1); >>> -    sk_send_sigurg(&smc->sk); >>> +    sk_send_sigurg(&smc->inet.sk); >>>   } >>>     static void smc_cdc_msg_validate(struct smc_sock *smc, struct >>> smc_cdc_msg *cdc, >>> @@ -321,9 +321,9 @@ static void smc_cdc_msg_validate(struct smc_sock >>> *smc, struct smc_cdc_msg *cdc, >>> conn->local_tx_ctrl.conn_state_flags.peer_conn_abort = 1; >>>           conn->lnk = link; >>>           spin_unlock_bh(&conn->send_lock); >>> -        sock_hold(&smc->sk); /* sock_put in abort_work */ >>> +        sock_hold(&smc->inet.sk); /* sock_put in abort_work */ >>>           if (!queue_work(smc_close_wq, &conn->abort_work)) >>> -            sock_put(&smc->sk); >>> +            sock_put(&smc->inet.sk); >>>       } >>>   } >>>   @@ -383,10 +383,10 @@ static void smc_cdc_msg_recv_action(struct >>> smc_sock *smc, >>>           atomic_add(diff_prod, &conn->bytes_to_rcv); >>>           /* guarantee 0 <= bytes_to_rcv <= rmb_desc->len */ >>>           smp_mb__after_atomic(); >>> -        smc->sk.sk_data_ready(&smc->sk); >>> +        smc->inet.sk.sk_data_ready(&smc->inet.sk); >>>       } else { >>>           if (conn->local_rx_ctrl.prod_flags.write_blocked) >>> -            smc->sk.sk_data_ready(&smc->sk); >>> + smc->inet.sk.sk_data_ready(&smc->inet.sk); >>>           if (conn->local_rx_ctrl.prod_flags.urg_data_pending) >>>               conn->urg_state = SMC_URG_NOTYET; >>>       } >>> @@ -395,7 +395,7 @@ static void smc_cdc_msg_recv_action(struct >>> smc_sock *smc, >>>       if ((diff_cons && smc_tx_prepared_sends(conn)) || >>>           conn->local_rx_ctrl.prod_flags.cons_curs_upd_req || >>>           conn->local_rx_ctrl.prod_flags.urg_data_pending) { >>> -        if (!sock_owned_by_user(&smc->sk)) >>> +        if (!sock_owned_by_user(&smc->inet.sk)) >>>               smc_tx_pending(conn); >>>           else >>>               conn->tx_in_release_sock = true; >>> @@ -405,32 +405,32 @@ static void smc_cdc_msg_recv_action(struct >>> smc_sock *smc, >>>           atomic_read(&conn->peer_rmbe_space) == conn->peer_rmbe_size) { >>>           /* urg data confirmed by peer, indicate we're ready for >>> more */ >>>           conn->urg_tx_pend = false; >>> -        smc->sk.sk_write_space(&smc->sk); >>> +        smc->inet.sk.sk_write_space(&smc->inet.sk); >>>       } >>>         if (conn->local_rx_ctrl.conn_state_flags.peer_conn_abort) { >>> -        smc->sk.sk_err = ECONNRESET; >>> +        smc->inet.sk.sk_err = ECONNRESET; >>> conn->local_tx_ctrl.conn_state_flags.peer_conn_abort = 1; >>>       } >>>       if (smc_cdc_rxed_any_close_or_senddone(conn)) { >>> -        smc->sk.sk_shutdown |= RCV_SHUTDOWN; >>> +        smc->inet.sk.sk_shutdown |= RCV_SHUTDOWN; >>>           if (smc->clcsock && smc->clcsock->sk) >>>               smc->clcsock->sk->sk_shutdown |= RCV_SHUTDOWN; >>> -        smc_sock_set_flag(&smc->sk, SOCK_DONE); >>> -        sock_hold(&smc->sk); /* sock_put in close_work */ >>> +        smc_sock_set_flag(&smc->inet.sk, SOCK_DONE); >>> +        sock_hold(&smc->inet.sk); /* sock_put in close_work */ >>>           if (!queue_work(smc_close_wq, &conn->close_work)) >>> -            sock_put(&smc->sk); >>> +            sock_put(&smc->inet.sk); >>>       } >>>   } >>>     /* called under tasklet context */ >>>   static void smc_cdc_msg_recv(struct smc_sock *smc, struct >>> smc_cdc_msg *cdc) >>>   { >>> -    sock_hold(&smc->sk); >>> -    bh_lock_sock(&smc->sk); >>> +    sock_hold(&smc->inet.sk); >>> +    bh_lock_sock(&smc->inet.sk); >>>       smc_cdc_msg_recv_action(smc, cdc); >>> -    bh_unlock_sock(&smc->sk); >>> -    sock_put(&smc->sk); /* no free sk in softirq-context */ >>> +    bh_unlock_sock(&smc->inet.sk); >>> +    sock_put(&smc->inet.sk); /* no free sk in softirq-context */ >>>   } >>>     /* Schedule a tasklet for this connection. Triggered from the ISM >>> device IRQ >>> diff --git a/net/smc/smc_clc.c b/net/smc/smc_clc.c >>> index 33fa787c28eb..c08ebc55f2ad 100644 >>> --- a/net/smc/smc_clc.c >>> +++ b/net/smc/smc_clc.c >>> @@ -704,7 +704,7 @@ int smc_clc_wait_msg(struct smc_sock *smc, void >>> *buf, int buflen, >>>       if (signal_pending(current)) { >>>           reason_code = -EINTR; >>>           clc_sk->sk_err = EINTR; >>> -        smc->sk.sk_err = EINTR; >>> +        smc->inet.sk.sk_err = EINTR; >>>           goto out; >>>       } >>>       if (clc_sk->sk_err) { >>> @@ -713,17 +713,17 @@ int smc_clc_wait_msg(struct smc_sock *smc, void >>> *buf, int buflen, >>>               expected_type == SMC_CLC_DECLINE) >>>               clc_sk->sk_err = 0; /* reset for fallback usage */ >>>           else >>> -            smc->sk.sk_err = clc_sk->sk_err; >>> +            smc->inet.sk.sk_err = clc_sk->sk_err; >>>           goto out; >>>       } >>>       if (!len) { /* peer has performed orderly shutdown */ >>> -        smc->sk.sk_err = ECONNRESET; >>> +        smc->inet.sk.sk_err = ECONNRESET; >>>           reason_code = -ECONNRESET; >>>           goto out; >>>       } >>>       if (len < 0) { >>>           if (len != -EAGAIN || expected_type != SMC_CLC_DECLINE) >>> -            smc->sk.sk_err = -len; >>> +            smc->inet.sk.sk_err = -len; >>>           reason_code = len; >>>           goto out; >>>       } >>> @@ -732,7 +732,7 @@ int smc_clc_wait_msg(struct smc_sock *smc, void >>> *buf, int buflen, >>>           (clcm->version < SMC_V1) || >>>           ((clcm->type != SMC_CLC_DECLINE) && >>>            (clcm->type != expected_type))) { >>> -        smc->sk.sk_err = EPROTO; >>> +        smc->inet.sk.sk_err = EPROTO; >>>           reason_code = -EPROTO; >>>           goto out; >>>       } >>> @@ -749,7 +749,7 @@ int smc_clc_wait_msg(struct smc_sock *smc, void >>> *buf, int buflen, >>>       krflags = MSG_WAITALL; >>>       len = sock_recvmsg(smc->clcsock, &msg, krflags); >>>       if (len < recvlen || !smc_clc_msg_hdr_valid(clcm, check_trl)) { >>> -        smc->sk.sk_err = EPROTO; >>> +        smc->inet.sk.sk_err = EPROTO; >>>           reason_code = -EPROTO; >>>           goto out; >>>       } >>> @@ -835,7 +835,7 @@ int smc_clc_send_proposal(struct smc_sock *smc, >>> struct smc_init_info *ini) >>>       struct smc_clc_smcd_gid_chid *gidchids; >>>       struct smc_clc_msg_proposal_area *pclc; >>>       struct smc_clc_ipv6_prefix *ipv6_prfx; >>> -    struct net *net = sock_net(&smc->sk); >>> +    struct net *net = sock_net(&smc->inet.sk); >>>       struct smc_clc_v2_extension *v2_ext; >>>       struct smc_clc_msg_smcd *pclc_smcd; >>>       struct smc_clc_msg_trail *trl; >>> @@ -1015,11 +1015,11 @@ int smc_clc_send_proposal(struct smc_sock >>> *smc, struct smc_init_info *ini) >>>       /* due to the few bytes needed for clc-handshake this cannot >>> block */ >>>       len = kernel_sendmsg(smc->clcsock, &msg, vec, i, plen); >>>       if (len < 0) { >>> -        smc->sk.sk_err = smc->clcsock->sk->sk_err; >>> -        reason_code = -smc->sk.sk_err; >>> +        smc->inet.sk.sk_err = smc->clcsock->sk->sk_err; >>> +        reason_code = -smc->inet.sk.sk_err; >>>       } else if (len < ntohs(pclc_base->hdr.length)) { >>>           reason_code = -ENETUNREACH; >>> -        smc->sk.sk_err = -reason_code; >>> +        smc->inet.sk.sk_err = -reason_code; >>>       } >>>         kfree(pclc); >>> @@ -1208,10 +1208,10 @@ int smc_clc_send_confirm(struct smc_sock >>> *smc, bool clnt_first_contact, >>>       if (len < ntohs(cclc.hdr.length)) { >>>           if (len >= 0) { >>>               reason_code = -ENETUNREACH; >>> -            smc->sk.sk_err = -reason_code; >>> +            smc->inet.sk.sk_err = -reason_code; >>>           } else { >>> -            smc->sk.sk_err = smc->clcsock->sk->sk_err; >>> -            reason_code = -smc->sk.sk_err; >>> +            smc->inet.sk.sk_err = smc->clcsock->sk->sk_err; >>> +            reason_code = -smc->inet.sk.sk_err; >>>           } >>>       } >>>       return reason_code; >>> @@ -1239,7 +1239,7 @@ int smc_clc_srv_v2x_features_validate(struct >>> smc_sock *smc, >>>                         struct smc_init_info *ini) >>>   { >>>       struct smc_clc_v2_extension *pclc_v2_ext; >>> -    struct net *net = sock_net(&smc->sk); >>> +    struct net *net = sock_net(&smc->inet.sk); >>>         ini->max_conns = SMC_CONN_PER_LGR_MAX; >>>       ini->max_links = SMC_LINKS_ADD_LNK_MAX; >>> diff --git a/net/smc/smc_close.c b/net/smc/smc_close.c >>> index 10219f55aad1..74020e9eba1b 100644 >>> --- a/net/smc/smc_close.c >>> +++ b/net/smc/smc_close.c >>> @@ -49,7 +49,7 @@ static void smc_close_cleanup_listen(struct sock >>> *parent) >>>   static void smc_close_stream_wait(struct smc_sock *smc, long timeout) >>>   { >>>       DEFINE_WAIT_FUNC(wait, woken_wake_function); >>> -    struct sock *sk = &smc->sk; >>> +    struct sock *sk = &smc->inet.sk; >>>         if (!timeout) >>>           return; >>> @@ -82,7 +82,7 @@ void smc_close_wake_tx_prepared(struct smc_sock *smc) >>>   { >>>       if (smc->wait_close_tx_prepared) >>>           /* wake up socket closing */ >>> -        smc->sk.sk_state_change(&smc->sk); >>> +        smc->inet.sk.sk_state_change(&smc->inet.sk); >>>   } >>>     static int smc_close_wr(struct smc_connection *conn) >>> @@ -113,7 +113,7 @@ int smc_close_abort(struct smc_connection *conn) >>>     static void smc_close_cancel_work(struct smc_sock *smc) >>>   { >>> -    struct sock *sk = &smc->sk; >>> +    struct sock *sk = &smc->inet.sk; >>>         release_sock(sk); >>>       if (cancel_work_sync(&smc->conn.close_work)) >>> @@ -127,7 +127,7 @@ static void smc_close_cancel_work(struct smc_sock >>> *smc) >>>    */ >>>   void smc_close_active_abort(struct smc_sock *smc) >>>   { >>> -    struct sock *sk = &smc->sk; >>> +    struct sock *sk = &smc->inet.sk; >>>       bool release_clcsock = false; >>>         if (sk->sk_state != SMC_INIT && smc->clcsock && >>> smc->clcsock->sk) { >>> @@ -195,7 +195,7 @@ int smc_close_active(struct smc_sock *smc) >>>       struct smc_cdc_conn_state_flags *txflags = >>>           &smc->conn.local_tx_ctrl.conn_state_flags; >>>       struct smc_connection *conn = &smc->conn; >>> -    struct sock *sk = &smc->sk; >>> +    struct sock *sk = &smc->inet.sk; >>>       int old_state; >>>       long timeout; >>>       int rc = 0; >>> @@ -313,7 +313,7 @@ static void >>> smc_close_passive_abort_received(struct smc_sock *smc) >>>   { >>>       struct smc_cdc_conn_state_flags *txflags = >>>           &smc->conn.local_tx_ctrl.conn_state_flags; >>> -    struct sock *sk = &smc->sk; >>> +    struct sock *sk = &smc->inet.sk; >>>         switch (sk->sk_state) { >>>       case SMC_INIT: >>> @@ -361,7 +361,7 @@ static void smc_close_passive_work(struct >>> work_struct *work) >>>       struct smc_sock *smc = container_of(conn, struct smc_sock, conn); >>>       struct smc_cdc_conn_state_flags *rxflags; >>>       bool release_clcsock = false; >>> -    struct sock *sk = &smc->sk; >>> +    struct sock *sk = &smc->inet.sk; >>>       int old_state; >>>         lock_sock(sk); >>> @@ -447,7 +447,7 @@ static void smc_close_passive_work(struct >>> work_struct *work) >>>   int smc_close_shutdown_write(struct smc_sock *smc) >>>   { >>>       struct smc_connection *conn = &smc->conn; >>> -    struct sock *sk = &smc->sk; >>> +    struct sock *sk = &smc->inet.sk; >>>       int old_state; >>>       long timeout; >>>       int rc = 0; >>> diff --git a/net/smc/smc_core.c b/net/smc/smc_core.c >>> index 3b95828d9976..86430ab7c0ef 100644 >>> --- a/net/smc/smc_core.c >>> +++ b/net/smc/smc_core.c >>> @@ -180,7 +180,7 @@ static int smc_lgr_register_conn(struct >>> smc_connection *conn, bool first) >>>       /* find a new alert_token_local value not yet used by some >>> connection >>>        * in this link group >>>        */ >>> -    sock_hold(&smc->sk); /* sock_put in smc_lgr_unregister_conn() */ >>> +    sock_hold(&smc->inet.sk); /* sock_put in >>> smc_lgr_unregister_conn() */ >>>       while (!conn->alert_token_local) { >>>           conn->alert_token_local = atomic_inc_return(&nexttoken); >>>           if (smc_lgr_find_conn(conn->alert_token_local, conn->lgr)) >>> @@ -203,7 +203,7 @@ static void __smc_lgr_unregister_conn(struct >>> smc_connection *conn) >>>           atomic_dec(&conn->lnk->conn_cnt); >>>       lgr->conns_num--; >>>       conn->alert_token_local = 0; >>> -    sock_put(&smc->sk); /* sock_hold in smc_lgr_register_conn() */ >>> +    sock_put(&smc->inet.sk); /* sock_hold in smc_lgr_register_conn() */ >>>   } >>>     /* Unregister connection from lgr >>> @@ -1010,12 +1010,12 @@ static int smc_switch_cursor(struct smc_sock >>> *smc, struct smc_cdc_tx_pend *pend, >>>       /* recalculate, value is used by tx_rdma_writes() */ >>>       atomic_set(&smc->conn.peer_rmbe_space, smc_write_space(conn)); >>>   -    if (smc->sk.sk_state != SMC_INIT && >>> -        smc->sk.sk_state != SMC_CLOSED) { >>> +    if (smc->inet.sk.sk_state != SMC_INIT && >>> +        smc->inet.sk.sk_state != SMC_CLOSED) { >>>           rc = smcr_cdc_msg_send_validation(conn, pend, wr_buf); >>>           if (!rc) { >>>               queue_delayed_work(conn->lgr->tx_wq, &conn->tx_work, 0); >>> -            smc->sk.sk_data_ready(&smc->sk); >>> + smc->inet.sk.sk_data_ready(&smc->inet.sk); >>>           } >>>       } else { >>>           smc_wr_tx_put_slot(conn->lnk, >>> @@ -1072,23 +1072,23 @@ struct smc_link *smc_switch_conns(struct >>> smc_link_group *lgr, >>>               continue; >>>           smc = container_of(conn, struct smc_sock, conn); >>>           /* conn->lnk not yet set in SMC_INIT state */ >>> -        if (smc->sk.sk_state == SMC_INIT) >>> +        if (smc->inet.sk.sk_state == SMC_INIT) >>>               continue; >>> -        if (smc->sk.sk_state == SMC_CLOSED || >>> -            smc->sk.sk_state == SMC_PEERCLOSEWAIT1 || >>> -            smc->sk.sk_state == SMC_PEERCLOSEWAIT2 || >>> -            smc->sk.sk_state == SMC_APPFINCLOSEWAIT || >>> -            smc->sk.sk_state == SMC_APPCLOSEWAIT1 || >>> -            smc->sk.sk_state == SMC_APPCLOSEWAIT2 || >>> -            smc->sk.sk_state == SMC_PEERFINCLOSEWAIT || >>> -            smc->sk.sk_state == SMC_PEERABORTWAIT || >>> -            smc->sk.sk_state == SMC_PROCESSABORT) { >>> +        if (smc->inet.sk.sk_state == SMC_CLOSED || >>> +            smc->inet.sk.sk_state == SMC_PEERCLOSEWAIT1 || >>> +            smc->inet.sk.sk_state == SMC_PEERCLOSEWAIT2 || >>> +            smc->inet.sk.sk_state == SMC_APPFINCLOSEWAIT || >>> +            smc->inet.sk.sk_state == SMC_APPCLOSEWAIT1 || >>> +            smc->inet.sk.sk_state == SMC_APPCLOSEWAIT2 || >>> +            smc->inet.sk.sk_state == SMC_PEERFINCLOSEWAIT || >>> +            smc->inet.sk.sk_state == SMC_PEERABORTWAIT || >>> +            smc->inet.sk.sk_state == SMC_PROCESSABORT) { >>>               spin_lock_bh(&conn->send_lock); >>>               smc_switch_link_and_count(conn, to_lnk); >>>               spin_unlock_bh(&conn->send_lock); >>>               continue; >>>           } >>> -        sock_hold(&smc->sk); >>> +        sock_hold(&smc->inet.sk); >>>           read_unlock_bh(&lgr->conns_lock); >>>           /* pre-fetch buffer outside of send_lock, might sleep */ >>>           rc = smc_cdc_get_free_slot(conn, to_lnk, &wr_buf, NULL, >>> &pend); >>> @@ -1099,7 +1099,7 @@ struct smc_link *smc_switch_conns(struct >>> smc_link_group *lgr, >>>           smc_switch_link_and_count(conn, to_lnk); >>>           rc = smc_switch_cursor(smc, pend, wr_buf); >>>           spin_unlock_bh(&conn->send_lock); >>> -        sock_put(&smc->sk); >>> +        sock_put(&smc->inet.sk); >>>           if (rc) >>>               goto err_out; >>>           goto again; >>> @@ -1442,9 +1442,9 @@ void smc_lgr_put(struct smc_link_group *lgr) >>>     static void smc_sk_wake_ups(struct smc_sock *smc) >>>   { >>> -    smc->sk.sk_write_space(&smc->sk); >>> -    smc->sk.sk_data_ready(&smc->sk); >>> -    smc->sk.sk_state_change(&smc->sk); >>> +    smc->inet.sk.sk_write_space(&smc->inet.sk); >>> +    smc->inet.sk.sk_data_ready(&smc->inet.sk); >>> +    smc->inet.sk.sk_state_change(&smc->inet.sk); >>>   } >>>     /* kill a connection */ >>> @@ -1457,7 +1457,7 @@ static void smc_conn_kill(struct smc_connection >>> *conn, bool soft) >>>       else >>>           smc_close_abort(conn); >>>       conn->killed = 1; >>> -    smc->sk.sk_err = ECONNABORTED; >>> +    smc->inet.sk.sk_err = ECONNABORTED; >>>       smc_sk_wake_ups(smc); >>>       if (conn->lgr->is_smcd) { >>>           smc_ism_unset_conn(conn); >>> @@ -1511,11 +1511,11 @@ static void __smc_lgr_terminate(struct >>> smc_link_group *lgr, bool soft) >>>           read_unlock_bh(&lgr->conns_lock); >>>           conn = rb_entry(node, struct smc_connection, alert_node); >>>           smc = container_of(conn, struct smc_sock, conn); >>> -        sock_hold(&smc->sk); /* sock_put below */ >>> -        lock_sock(&smc->sk); >>> +        sock_hold(&smc->inet.sk); /* sock_put below */ >>> +        lock_sock(&smc->inet.sk); >>>           smc_conn_kill(conn, soft); >>> -        release_sock(&smc->sk); >>> -        sock_put(&smc->sk); /* sock_hold above */ >>> +        release_sock(&smc->inet.sk); >>> +        sock_put(&smc->inet.sk); /* sock_hold above */ >>>           read_lock_bh(&lgr->conns_lock); >>>           node = rb_first(&lgr->conns_all); >>>       } >>> @@ -1684,10 +1684,10 @@ static void smc_conn_abort_work(struct >>> work_struct *work) >>>                              abort_work); >>>       struct smc_sock *smc = container_of(conn, struct smc_sock, conn); >>>   -    lock_sock(&smc->sk); >>> +    lock_sock(&smc->inet.sk); >>>       smc_conn_kill(conn, true); >>> -    release_sock(&smc->sk); >>> -    sock_put(&smc->sk); /* sock_hold done by schedulers of >>> abort_work */ >>> +    release_sock(&smc->inet.sk); >>> +    sock_put(&smc->inet.sk); /* sock_hold done by schedulers of >>> abort_work */ >>>   } >>>     void smcr_port_add(struct smc_ib_device *smcibdev, u8 ibport) >>> @@ -1910,7 +1910,7 @@ static bool smcd_lgr_match(struct >>> smc_link_group *lgr, >>>   int smc_conn_create(struct smc_sock *smc, struct smc_init_info *ini) >>>   { >>>       struct smc_connection *conn = &smc->conn; >>> -    struct net *net = sock_net(&smc->sk); >>> +    struct net *net = sock_net(&smc->inet.sk); >>>       struct list_head *lgr_list; >>>       struct smc_link_group *lgr; >>>       enum smc_lgr_role role; >>> @@ -2370,10 +2370,10 @@ static int __smc_buf_create(struct smc_sock >>> *smc, bool is_smcd, bool is_rmb) >>>         if (is_rmb) >>>           /* use socket recv buffer size (w/o overhead) as start >>> value */ >>> -        bufsize = smc->sk.sk_rcvbuf / 2; >>> +        bufsize = smc->inet.sk.sk_rcvbuf / 2; >>>       else >>>           /* use socket send buffer size (w/o overhead) as start >>> value */ >>> -        bufsize = smc->sk.sk_sndbuf / 2; >>> +        bufsize = smc->inet.sk.sk_sndbuf / 2; >>>         for (bufsize_comp = smc_compress_bufsize(bufsize, is_smcd, >>> is_rmb); >>>            bufsize_comp >= 0; bufsize_comp--) { >>> @@ -2432,7 +2432,7 @@ static int __smc_buf_create(struct smc_sock >>> *smc, bool is_smcd, bool is_rmb) >>>       if (is_rmb) { >>>           conn->rmb_desc = buf_desc; >>>           conn->rmbe_size_comp = bufsize_comp; >>> -        smc->sk.sk_rcvbuf = bufsize * 2; >>> +        smc->inet.sk.sk_rcvbuf = bufsize * 2; >>>           atomic_set(&conn->bytes_to_rcv, 0); >>>           conn->rmbe_update_limit = >>>               smc_rmb_wnd_update_limit(buf_desc->len); >>> @@ -2440,7 +2440,7 @@ static int __smc_buf_create(struct smc_sock >>> *smc, bool is_smcd, bool is_rmb) >>>               smc_ism_set_conn(conn); /* map RMB/smcd_dev to conn */ >>>       } else { >>>           conn->sndbuf_desc = buf_desc; >>> -        smc->sk.sk_sndbuf = bufsize * 2; >>> +        smc->inet.sk.sk_sndbuf = bufsize * 2; >>>           atomic_set(&conn->sndbuf_space, bufsize); >>>       } >>>       return 0; >>> @@ -2525,7 +2525,7 @@ int smcd_buf_attach(struct smc_sock *smc) >>>       if (rc) >>>           goto free; >>>   -    smc->sk.sk_sndbuf = buf_desc->len; >>> +    smc->inet.sk.sk_sndbuf = buf_desc->len; >>>       buf_desc->cpu_addr = >>>           (u8 *)buf_desc->cpu_addr + sizeof(struct smcd_cdc_msg); >>>       buf_desc->len -= sizeof(struct smcd_cdc_msg); >>> diff --git a/net/smc/smc_inet.c b/net/smc/smc_inet.c >>> index bece346dd8e9..9e5eff8f5226 100644 >>> --- a/net/smc/smc_inet.c >>> +++ b/net/smc/smc_inet.c >>> @@ -60,6 +60,11 @@ static struct inet_protosw smc_inet_protosw = { >>>   }; >>>     #if IS_ENABLED(CONFIG_IPV6) >>> +struct smc6_sock { >>> +    struct smc_sock smc; >>> +    struct ipv6_pinfo inet6; >>> +}; >>> + >>>   static struct proto smc_inet6_prot = { >>>       .name        = "INET6_SMC", >>>       .owner        = THIS_MODULE, >>> @@ -67,9 +72,10 @@ static struct proto smc_inet6_prot = { >>>       .hash        = smc_hash_sk, >>>       .unhash        = smc_unhash_sk, >>>       .release_cb    = smc_release_cb, >>> -    .obj_size    = sizeof(struct smc_sock), >>> +    .obj_size    = sizeof(struct smc6_sock), >>>       .h.smc_hash    = &smc_v6_hashinfo, >>>       .slab_flags    = SLAB_TYPESAFE_BY_RCU, >>> +    .ipv6_pinfo_offset    = offsetof(struct smc6_sock, inet6), >>>   }; >>>     static const struct proto_ops smc_inet6_stream_ops = { >>> diff --git a/net/smc/smc_rx.c b/net/smc/smc_rx.c >>> index f0cbe77a80b4..f713d3180d67 100644 >>> --- a/net/smc/smc_rx.c >>> +++ b/net/smc/smc_rx.c >>> @@ -60,7 +60,7 @@ static int smc_rx_update_consumer(struct smc_sock >>> *smc, >>>                     union smc_host_cursor cons, size_t len) >>>   { >>>       struct smc_connection *conn = &smc->conn; >>> -    struct sock *sk = &smc->sk; >>> +    struct sock *sk = &smc->inet.sk; >>>       bool force = false; >>>       int diff, rc = 0; >>>   @@ -117,7 +117,7 @@ static void smc_rx_pipe_buf_release(struct >>> pipe_inode_info *pipe, >>>       struct smc_spd_priv *priv = (struct smc_spd_priv *)buf->private; >>>       struct smc_sock *smc = priv->smc; >>>       struct smc_connection *conn; >>> -    struct sock *sk = &smc->sk; >>> +    struct sock *sk = &smc->inet.sk; >>>         if (sk->sk_state == SMC_CLOSED || >>>           sk->sk_state == SMC_PEERFINCLOSEWAIT || >>> @@ -211,7 +211,7 @@ static int smc_rx_splice(struct pipe_inode_info >>> *pipe, char *src, size_t len, >>>         bytes = splice_to_pipe(pipe, &spd); >>>       if (bytes > 0) { >>> -        sock_hold(&smc->sk); >>> +        sock_hold(&smc->inet.sk); >>>           if (!lgr->is_smcd && smc->conn.rmb_desc->is_vm) { >>>               for (i = 0; i < PAGE_ALIGN(bytes + offset) / PAGE_SIZE; >>> i++) >>>                   get_page(pages[i]); >>> @@ -259,7 +259,7 @@ int smc_rx_wait(struct smc_sock *smc, long *timeo, >>>       struct smc_connection *conn = &smc->conn; >>>       struct smc_cdc_conn_state_flags *cflags = >>> &conn->local_tx_ctrl.conn_state_flags; >>> -    struct sock *sk = &smc->sk; >>> +    struct sock *sk = &smc->inet.sk; >>>       int rc; >>>         if (fcrit(conn)) >>> @@ -283,7 +283,7 @@ static int smc_rx_recv_urg(struct smc_sock *smc, >>> struct msghdr *msg, int len, >>>   { >>>       struct smc_connection *conn = &smc->conn; >>>       union smc_host_cursor cons; >>> -    struct sock *sk = &smc->sk; >>> +    struct sock *sk = &smc->inet.sk; >>>       int rc = 0; >>>         if (sock_flag(sk, SOCK_URGINLINE) || >>> @@ -360,7 +360,7 @@ int smc_rx_recvmsg(struct smc_sock *smc, struct >>> msghdr *msg, >>>       if (unlikely(flags & MSG_ERRQUEUE)) >>>           return -EINVAL; /* future work for sk.sk_family == AF_SMC */ >>>   -    sk = &smc->sk; >>> +    sk = &smc->inet.sk; >>>       if (sk->sk_state == SMC_LISTEN) >>>           return -ENOTCONN; >>>       if (flags & MSG_OOB) >>> @@ -449,7 +449,7 @@ int smc_rx_recvmsg(struct smc_sock *smc, struct >>> msghdr *msg, >>>           if (splbytes) >>>               smc_curs_add(conn->rmb_desc->len, &cons, splbytes); >>>           if (conn->urg_state == SMC_URG_VALID && >>> -            sock_flag(&smc->sk, SOCK_URGINLINE) && >>> +            sock_flag(&smc->inet.sk, SOCK_URGINLINE) && >>>               readable > 1) >>>               readable--;    /* always stop at urgent Byte */ >>>           /* not more than what user space asked for */ >>> @@ -509,7 +509,7 @@ int smc_rx_recvmsg(struct smc_sock *smc, struct >>> msghdr *msg, >>>   /* Initialize receive properties on connection establishment. NB: >>> not __init! */ >>>   void smc_rx_init(struct smc_sock *smc) >>>   { >>> -    smc->sk.sk_data_ready = smc_rx_wake_up; >>> +    smc->inet.sk.sk_data_ready = smc_rx_wake_up; >>>       atomic_set(&smc->conn.splice_pending, 0); >>>       smc->conn.urg_state = SMC_URG_READ; >>>   } >>> diff --git a/net/smc/smc_stats.h b/net/smc/smc_stats.h >>> index e19177ce4092..baaac41a8974 100644 >>> --- a/net/smc/smc_stats.h >>> +++ b/net/smc/smc_stats.h >>> @@ -108,7 +108,7 @@ while (0) >>>   #define SMC_STAT_TX_PAYLOAD(_smc, length, rcode) \ >>>   do { \ >>>       typeof(_smc) __smc = _smc; \ >>> -    struct net *_net = sock_net(&__smc->sk); \ >>> +    struct net *_net = sock_net(&__smc->inet.sk); \ >>>       struct smc_stats __percpu *_smc_stats = _net->smc.smc_stats; \ >>>       typeof(length) _len = (length); \ >>>       typeof(rcode) _rc = (rcode); \ >>> @@ -123,7 +123,7 @@ while (0) >>>   #define SMC_STAT_RX_PAYLOAD(_smc, length, rcode) \ >>>   do { \ >>>       typeof(_smc) __smc = _smc; \ >>> -    struct net *_net = sock_net(&__smc->sk); \ >>> +    struct net *_net = sock_net(&__smc->inet.sk); \ >>>       struct smc_stats __percpu *_smc_stats = _net->smc.smc_stats; \ >>>       typeof(length) _len = (length); \ >>>       typeof(rcode) _rc = (rcode); \ >>> @@ -154,7 +154,7 @@ while (0) >>>     #define SMC_STAT_RMB_SIZE(_smc, _is_smcd, _is_rx, _len) \ >>>   do { \ >>> -    struct net *_net = sock_net(&(_smc)->sk); \ >>> +    struct net *_net = sock_net(&(_smc)->inet.sk); \ >>>       struct smc_stats __percpu *_smc_stats = _net->smc.smc_stats; \ >>>       typeof(_is_smcd) is_d = (_is_smcd); \ >>>       typeof(_is_rx) is_r = (_is_rx); \ >>> @@ -172,7 +172,7 @@ while (0) >>>     #define SMC_STAT_RMB(_smc, type, _is_smcd, _is_rx) \ >>>   do { \ >>> -    struct net *net = sock_net(&(_smc)->sk); \ >>> +    struct net *net = sock_net(&(_smc)->inet.sk); \ >>>       struct smc_stats __percpu *_smc_stats = net->smc.smc_stats; \ >>>       typeof(_is_smcd) is_d = (_is_smcd); \ >>>       typeof(_is_rx) is_r = (_is_rx); \ >>> @@ -218,7 +218,7 @@ while (0) >>>   do { \ >>>       typeof(_smc) __smc = _smc; \ >>>       bool is_smcd = !(__smc)->conn.lnk; \ >>> -    struct net *net = sock_net(&(__smc)->sk); \ >>> +    struct net *net = sock_net(&(__smc)->inet.sk); \ >>>       struct smc_stats __percpu *smc_stats = net->smc.smc_stats; \ >>>       if ((is_smcd)) \ >>>           this_cpu_inc(smc_stats->smc[SMC_TYPE_D].type); \ >>> diff --git a/net/smc/smc_tracepoint.h b/net/smc/smc_tracepoint.h >>> index a9a6e3c1113a..243fb8647cfe 100644 >>> --- a/net/smc/smc_tracepoint.h >>> +++ b/net/smc/smc_tracepoint.h >>> @@ -27,7 +27,7 @@ TRACE_EVENT(smc_switch_to_fallback, >>>           ), >>>             TP_fast_assign( >>> -               const struct sock *sk = &smc->sk; >>> +               const struct sock *sk = &smc->inet.sk; >>>                  const struct sock *clcsk = smc->clcsock->sk; >>>                    __entry->sk = sk; >>> @@ -55,7 +55,7 @@ DECLARE_EVENT_CLASS(smc_msg_event, >>>               ), >>>                 TP_fast_assign( >>> -                   const struct sock *sk = &smc->sk; >>> +                   const struct sock *sk = &smc->inet.sk; >>>                        __entry->smc = smc; >>>                      __entry->net_cookie = sock_net(sk)->net_cookie; >>> diff --git a/net/smc/smc_tx.c b/net/smc/smc_tx.c >>> index 214ac3cbcf9a..29e780aee677 100644 >>> --- a/net/smc/smc_tx.c >>> +++ b/net/smc/smc_tx.c >>> @@ -66,9 +66,9 @@ static void smc_tx_write_space(struct sock *sk) >>>    */ >>>   void smc_tx_sndbuf_nonfull(struct smc_sock *smc) >>>   { >>> -    if (smc->sk.sk_socket && >>> -        test_bit(SOCK_NOSPACE, &smc->sk.sk_socket->flags)) >>> -        smc->sk.sk_write_space(&smc->sk); >>> +    if (smc->inet.sk.sk_socket && >>> +        test_bit(SOCK_NOSPACE, &smc->inet.sk.sk_socket->flags)) >>> +        smc->inet.sk.sk_write_space(&smc->inet.sk); >>>   } >>>     /* blocks sndbuf producer until at least one byte of free space >>> available >>> @@ -78,7 +78,7 @@ static int smc_tx_wait(struct smc_sock *smc, int >>> flags) >>>   { >>>       DEFINE_WAIT_FUNC(wait, woken_wake_function); >>>       struct smc_connection *conn = &smc->conn; >>> -    struct sock *sk = &smc->sk; >>> +    struct sock *sk = &smc->inet.sk; >>>       long timeo; >>>       int rc = 0; >>>   @@ -148,7 +148,7 @@ static bool smc_should_autocork(struct smc_sock >>> *smc) >>>       int corking_size; >>>         corking_size = min_t(unsigned int, conn->sndbuf_desc->len >> 1, >>> - sock_net(&smc->sk)->smc.sysctl_autocorking_size); >>> + sock_net(&smc->inet.sk)->smc.sysctl_autocorking_size); >>>         if (atomic_read(&conn->cdc_pend_tx_wr) == 0 || >>>           smc_tx_prepared_sends(conn) > corking_size) >>> @@ -184,7 +184,7 @@ int smc_tx_sendmsg(struct smc_sock *smc, struct >>> msghdr *msg, size_t len) >>>       size_t chunk_len, chunk_off, chunk_len_sum; >>>       struct smc_connection *conn = &smc->conn; >>>       union smc_host_cursor prep; >>> -    struct sock *sk = &smc->sk; >>> +    struct sock *sk = &smc->inet.sk; >>>       char *sndbuf_base; >>>       int tx_cnt_prep; >>>       int writespace; >>> @@ -211,8 +211,8 @@ int smc_tx_sendmsg(struct smc_sock *smc, struct >>> msghdr *msg, size_t len) >>>           SMC_STAT_INC(smc, urg_data_cnt); >>>         while (msg_data_left(msg)) { >>> -        if (smc->sk.sk_shutdown & SEND_SHUTDOWN || >>> -            (smc->sk.sk_err == ECONNABORTED) || >>> +        if (smc->inet.sk.sk_shutdown & SEND_SHUTDOWN || >>> +            (smc->inet.sk.sk_err == ECONNABORTED) || >>>               conn->killed) >>>               return -EPIPE; >>>           if (smc_cdc_rxed_any_close(conn)) >>> @@ -562,8 +562,8 @@ static int smcr_tx_sndbuf_nonempty(struct >>> smc_connection *conn) >>>               struct smc_sock *smc = >>>                   container_of(conn, struct smc_sock, conn); >>>   -            if (smc->sk.sk_err == ECONNABORTED) >>> -                return sock_error(&smc->sk); >>> +            if (smc->inet.sk.sk_err == ECONNABORTED) >>> +                return sock_error(&smc->inet.sk); >>>               if (conn->killed) >>>                   return -EPIPE; >>>               rc = 0; >>> @@ -664,7 +664,7 @@ void smc_tx_pending(struct smc_connection *conn) >>>       struct smc_sock *smc = container_of(conn, struct smc_sock, conn); >>>       int rc; >>>   -    if (smc->sk.sk_err) >>> +    if (smc->inet.sk.sk_err) >>>           return; >>>         rc = smc_tx_sndbuf_nonempty(conn); >>> @@ -684,9 +684,9 @@ void smc_tx_work(struct work_struct *work) >>>                              tx_work); >>>       struct smc_sock *smc = container_of(conn, struct smc_sock, conn); >>>   -    lock_sock(&smc->sk); >>> +    lock_sock(&smc->inet.sk); >>>       smc_tx_pending(conn); >>> -    release_sock(&smc->sk); >>> +    release_sock(&smc->inet.sk); >>>   } >>>     void smc_tx_consumer_update(struct smc_connection *conn, bool force) >>> @@ -730,5 +730,5 @@ void smc_tx_consumer_update(struct smc_connection >>> *conn, bool force) >>>   /* Initialize send properties on connection establishment. NB: not >>> __init! */ >>>   void smc_tx_init(struct smc_sock *smc) >>>   { >>> -    smc->sk.sk_write_space = smc_tx_write_space; >>> +    smc->inet.sk.sk_write_space = smc_tx_write_space; >>>   } >>> -- >