[PATCH v4 000/142] smb: smbdirect/client/server: make use of common structures

[PATCH v4 000/142] smb: smbdirect/client/server: make use of common structures

[Stefan Metzmacher]

Hi,

this is the next step towards a common smbdirect layer
between cifs.ko and ksmbd.ko, with the aim to provide
a socket layer for userspace usage at the end of the road.

Note the patchset is based on v6.17-rc3 plus the following
patches from sfrench-cifs-2.6/for-next:
21d14611210d0bdf6b0c6db45c2361e96e6673d4
smb3 client: fix return code mapping of remap_file_range
a21e20edf966db8d3e0e0748a9201fbd62fd961a
smb: client: Fix mount deadlock by avoiding super block iteration in DFS reconnect
plus the client and server fixes for the IRD/ORD negotiation:
https://lore.kernel.org/linux-cifs/20250821093113.36212-1-metze@samba.org/
https://lore.kernel.org/linux-cifs/20250821092751.35815-1-metze@samba.org/
But only the IRD/ORD patches are really required in order to
apply the patchset. It can also be found as branch for-6.18/fs-smb-20250825-v4
in https://git.samba.org/metze/linux/wip.git, see
https://git.samba.org/?p=metze/linux/wip.git;a=shortlog;h=refs/heads/for-6.18/fs-smb-20250825-v4

This patchset introduces more common structures and elements
to struct smbdirect_socket[_parameters]. (Patches 001-018)

The client side is modified in tiny steps in order
to use the new common structures. At the end
struct smbd_connection is only a simple container
arround struct smbdirect_socket. For now I left
it that way in order to avoid changing the smb layer
to use struct smbdirect_socket. In the end I'd like to
expose only an anonymous structure to the smb layer
and struct smbdirect_socket will become a private structure.
(Patches 019-075). In between there are some fixes for
the keepalive and timeout handling.

Note that 047 smb: client: make use of smbdirect_socket.statistics
generates the following warnings from scripts/checkpatch.pl --quiet
 WARNING: quoted string split across lines
 #40: FILE: fs/smb/client/cifs_debug.c:464:
 +               seq_printf(m, "\nDebug count_get_receive_buffer: %llx "
 +                       "count_put_receive_buffer: %llx count_send_empty: %llx",
 
 WARNING: quoted string split across lines
 #47: FILE: fs/smb/client/cifs_debug.c:469:
                 seq_printf(m, "\nRead Queue "
 +                       "count_enqueue_reassembly_queue: %llx "
 
 WARNING: quoted string split across lines
 #48: FILE: fs/smb/client/cifs_debug.c:470:
 +                       "count_enqueue_reassembly_queue: %llx "
 +                       "count_dequeue_reassembly_queue: %llx "

 total: 0 errors, 3 warnings, 83 lines checked
 scripts/checkpatch.pl: FAILED

But I left them in in order to keep the strange style like
the other code before and after...

The server is also changed in tiny steps in order to
make use of the common structures only. Patches 076-142.
We only have this left at the end of the patchset:

   struct smb_direct_transport {
        struct ksmbd_transport  transport;

        struct smbdirect_socket socket;
   };

The server also got patches to implement keepalive and timeout
handling in order to match the client code.

The client patches and server patches are independent
from each other, but both need their own IRD/ORD negotiation
fix plus the common smbdirect patches.

From here I'll start to split out common functions.
In the first step as static __maybe_unused functions in a
common smbdirect_connection.c file that will be included
in client/smbdirect.c and server/transport_rdma.c.
This is strange, but it will allow me to continue in tiny
steps until only common code it used.
If it's too strange I can use a smbdirect_connection.h
and rename it later from .h to .c

At that point I'll introduce an smbdirect.ko and export some
public functions which will replace the include of the .c.
Then I can finally start to add the struct socket/sock glue
in order to provide smbdirect support to userspace.

I used the following xfstests as regression tests:
cifs/001 generic/001 generic/002 generic/005 generic/006 generic/007 generic/010 generic/011

Between cifs.ko against ksmbd.ko via siw.ko and also
the client via siw.ko against Windows 2025 using
a Chelsio T520-BT card. I tested the modules once
before and after the applied patches and also the
combination.

V4:
rebased on v6.17-rc3 and current sfrench-cifs-2.6/for-next
A lot of additional patches are added in order to
use struct smbdirect_socket almost everywhere.

V3:
smbd_disconnect_rdma_work() needed to handle more
than SMBDIRECT_SOCKET_CONNECTED in order to call
rdma_disconnect.

V2:
init_waitqueue_head(&info->status_wait); was moved
to the beginning so that it is correctly initialized
in smbd_create_id().

Stefan Metzmacher (142):
  smb: smbdirect: introduce smbdirect_socket.status_wait
  smb: smbdirect: introduce smbdirect_socket_init()
  smb: smbdirect: introduce smbdirect_socket.disconnect_work
  smb: smbdirect: introduce
    smbdirect_socket.send_io.pending.{count,wait_queue}
  smb: smbdirect: introduce
    smbdirect_socket.send_io.credits.{count,wait_queue}
  smb: smbdirect: introduce struct smbdirect_send_batch
  smb: smbdirect: introduce smbdirect_socket.rw_io.credits
  smb: smbdirect: introduce struct smbdirect_rw_io
  smb: smbdirect: introduce smbdirect_socket.recv_io.{posted,credits}
  smb: smbdirect: introduce
    smbdirect_socket_parameters.{resolve_{addr,route},rdma_connect,negotiate}_timeout_msec
  smb: smbdirect: introduce
    smbdirect_socket_parameters.{initiator_depth,responder_resources}
  smb: smbdirect: introduce smbdirect_socket.rdma.legacy_iwarp
  smb: smbdirect: introduce
    smbdirect_socket.idle.{keepalive,immediate_work,timer_work}
  smb: smbdirect: introduce smbdirect_socket.statistics
  smb: smbdirect: introduce smbdirect_socket.workqueue
  smb: smbdirect: introduce struct smbdirect_mr_io
  smb: smbdirect: introduce smbdirect_socket_parameters.max_frmr_depth
  smb: smbdirect: introduce smbdirect_socket.mr_io.*
  smb: client/smbdirect: replace SMBDIRECT_SOCKET_CONNECTING with more
    detailed states
  smb: client: use status_wait and SMBDIRECT_SOCKET_NEGOTIATE_RUNNING
    for completion
  smb: client: use status_wait and
    SMBDIRECT_SOCKET_RESOLVE_{ADDR,ROUTE}_RUNNING for completion
  smb: client: make use of smbdirect_socket.status_wait
  smb: client: make only use of wake_up[_all]() in smbdirect.c
  smb: client: make use of smbdirect_socket_init()
  smb: client: make use of smbdirect_socket.disconnect_work
  smb: client: make use of
    smbdirect_socket.send_io.pending.{count,wait_queue}
  smb: client: make use of
    smbdirect_socket.send_io.credits.{count,wait_queue}
  smb: client: make sure smbd_disconnect_rdma_work() doesn't run after
    smbd_destroy() took over
  smb: client: use disable[_delayed]_work_sync in smbdirect.c
  smb: client: let smbd_destroy() call
    disable_work_sync(&info->post_send_credits_work)
  smb: client: queue post_recv_credits_work also if the peer raises the
    credit target
  smb: client: make use of ib_wc_status_msg() and skip
    IB_WC_WR_FLUSH_ERR logging
  smb: client: remove info->wait_receive_queues handling in
    smbd_destroy()
  smb: client: limit the range of info->receive_credit_target
  smb: client: count the number of posted recv_io messages in order to
    calculated credits
  smb: client: make use of smbdirect_socket.recv_io.{posted,credits}
  smb: client: remove useless smbd_connection.send_immediate
  smb: client: fill smbdirect_socket_parameters at the beginning and use
    the values from there
  smb: client: make use of
    smbdirect_socket_parameters.{resolve_{addr,route},rdma_connect,negotiate}_timeout_msec
  smb: client: make use of
    smbdirect_socket_parameters.{initiator_depth,responder_resources}
  smb: client: make use of smbdirect_socket.rdma.legacy_iwarp
  smb: client: send empty packets via send_immediate_work
  smb: client: fix smbdirect keep alive handling to match the
    documentation
  smb: client: make use of
    smbdirect_socket.idle.{keepalive,immediate_work,timer_work}
  smb: client: remove unused smbd_connection->protocol
  smb: client: remove unused smbd_connection.count_reassembly_queue
  smb: client: make use of smbdirect_socket.statistics
  smb: client: don't check sc->send_io.pending.count is below
    sp->send_credit_target
  smb: client: move rdma_readwrite_threshold from smbd_connection to
    TCP_Server_Info
  smb: client: make use of smbdirect_socket.workqueue
  smb: client: add and use smbd_get_parameters()
  smb: client: make use of struct smbdirect_mr_io
  smb: client: make use of smbdirect_socket_parameters.max_frmr_depth
  smb: client: make use of smbdirect_socket.mr_io
  smb: client: pass struct smbdirect_socket to
    {get,put}_receive_buffer()
  smb: client: pass struct smbdirect_socket to
    {allocate,destroy}_receive_buffers()
  smb: client: pass struct smbdirect_socket to
    {allocate,destroy}_caches_and_workqueue()
  smb: client: pass struct smbdirect_socket to
    {enqueue,_get_first}_reassembly()
  smb: client: pass struct smbdirect_socket to
    {allocate,destroy}_mr_list()
  smb: client: pass struct smbdirect_socket to
    smbd_disconnect_rdma_connection()
  smb: client: pass struct smbdirect_socket to smbd_post_recv()
  smb: client: pass struct smbdirect_socket to
    manage_credits_prior_sending()
  smb: client: pass struct smbdirect_socket to smbd_post_send()
  smb: client: pass struct smbdirect_socket to
    manage_keep_alive_before_sending()
  smb: client: pass struct smbdirect_socket to smbd_post_send_iter()
  smb: client: pass struct smbdirect_socket to smbd_post_send_empty()
  smb: client: pass struct smbdirect_socket to
    smbd_post_send_full_iter()
  smb: client: pass struct smbdirect_socket to smbd_conn_upcall()
  smb: client: pass struct smbdirect_socket to
    smbd_qp_async_error_upcall()
  smb: client: pass struct smbdirect_socket to smbd_create_id()
  smb: client: pass struct smbdirect_socket to smbd_ia_open()
  smb: client: pass struct smbdirect_socket to
    smbd_post_send_negotiate_req()
  smb: client: pass struct smbdirect_socket to smbd_negotiate()
  smb: client: pass struct smbdirect_socket to get_mr()
  smb: client: remove unused struct smbdirect_socket argument of
    smbd_iter_to_mr()
  smb: server: make use of common smbdirect_pdu.h
  smb: server: make use of common smbdirect.h
  smb: server: make use of common smbdirect_socket
  smb: server: make use of common smbdirect_socket_parameters
  smb: server: make use of smbdirect_socket->recv_io.expected
  smb: server: make use of struct smbdirect_recv_io
  smb: server: make use of smbdirect_socket.recv_io.free.{list,lock}
  smb: server: make use of smbdirect_socket.recv_io.reassembly.*
  smb: server: make use of SMBDIRECT_RECV_IO_MAX_SGE
  smb: server: make use of struct smbdirect_send_io
  smb: server: make use of
    smbdirect_socket.{send,recv}_io.mem.{cache,pool}
  smb: server: make only use of wake_up[_all]() in transport_rdma.c
  smb: server: add a pr_info() when the server starts running
  smb: server: don't use delayed_work for post_recv_credits_work
  smb: server: queue post_recv_credits_work in put_recvmsg() and avoid
    count_avail_recvmsg
  smb: server: make use of smbdirect_socket.status_wait
  smb: server: only turn into SMBDIRECT_SOCKET_CONNECTED when
    negotiation is done
  smb: server: use disable_work_sync in transport_rdma.c
  smb: server: move smb_direct_disconnect_rdma_work() into
    free_transport()
  smb: server: don't wait for info->send_pending == 0 on error
  smb: server: make use of smbdirect_socket_init()
  smb: server: make use of smbdirect_socket.disconnect_work
  smb: server: make use of
    smbdirect_socket.send_io.pending.{count,wait_queue}
  smb: server: make use of
    smbdirect_socket.send_io.credits.{count,wait_queue}
  smb: server: make use of struct smbdirect_send_batch
  smb: server: make use smbdirect_socket.rw_io.credits
  smb: server: make use of struct smbdirect_rw_io
  smb: server: take the recv_credit_target from the negotiate req and
    always limit the range
  smb: server: manage recv credits by counting posted recv_io and
    granted credits
  smb: server: make use of smbdirect_socket.recv_io.{posted,credits}
  smb: server: replace smb_trans_direct_transfort() with SMBD_TRANS()
  smb: server: remove useless casts from KSMBD_TRANS/SMBD_TRANS
  smb: server: pass ksmbd_transport to get_smbd_max_read_write_size()
  smb: server: fill smbdirect_socket_parameters at the beginning and use
    the values from there
  smb: server: make use of
    smbdirect_socket_parameters.negotiate_timeout_msec and change to 5s
  smb: server: make use of
    smbdirect_socket_parameters.{initiator_depth,responder_resources}
  smb: server: make use of smbdirect_socket.rdma.legacy_iwarp
  smb: server: make use of smbdirect_socket.idle.immediate_work
  smb: server: implement correct keepalive and timeout handling for
    smbdirect
  smb: server: make use of smbdirect_socket.workqueue
  smb: server: pass struct smbdirect_socket to {get_free,put}_recvmsg()
  smb: server: pass struct smbdirect_socket to
    smb_direct_{create,destroy}_pools()
  smb: server: pass struct smbdirect_socket to
    smb_direct_get_max_fr_pages()
  smb: server: pass struct smbdirect_socket to smb_direct_init_params()
  smb: server: pass struct smbdirect_socket to
    smb_direct_disconnect_rdma_connection()
  smb: server: pass struct smbdirect_socket to smb_direct_cm_handler()
  smb: server: pass struct smbdirect_socket to
    smb_direct_qpair_handler()
  smb: server: pass struct smbdirect_socket to smb_direct_create_qpair()
  smb: server: pass struct smbdirect_socket to smb_direct_post_recv()
  smb: server: pass struct smbdirect_socket to
    smb_direct_accept_client()
  smb: server: pass struct smbdirect_socket to
    smb_direct_prepare_negotiation()
  smb: server: pass struct smbdirect_socket to smb_direct_connect()
  smb: server: pass struct smbdirect_socket to
    smb_direct_{alloc,free}_sendmsg()
  smb: server: remove unused struct struct smb_direct_transport argument
    from smb_direct_send_ctx_init()
  smb: server: pass struct smbdirect_socket to smb_direct_post_send()
  smb: server: pass struct smbdirect_socket to
    smb_direct_flush_send_list()
  smb: server: pass struct smbdirect_socket to wait_for_credits()
  smb: server: pass struct smbdirect_socket to wait_for_send_credits()
  smb: server: pass struct smbdirect_socket to wait_for_rw_credits()
  smb: server: pass struct smbdirect_socket to calc_rw_credits()
  smb: server: pass struct smbdirect_socket to
    manage_credits_prior_sending()
  smb: server: pass struct smbdirect_socket to
    manage_keep_alive_before_sending()
  smb: server: pass struct smbdirect_socket to
    smb_direct_create_header()
  smb: server: pass struct smbdirect_socket to post_sendmsg()
  smb: server: pass struct smbdirect_socket to
    smb_direct_post_send_data()
  smb: server: pass struct smbdirect_socket to
    {enqueue,get_first}_reassembly()
  smb: server: pass struct smbdirect_socket to
    smb_direct_send_negotiate_response()

 fs/smb/client/cifs_debug.c                 |   48 +-
 fs/smb/client/cifsglob.h                   |    9 +-
 fs/smb/client/file.c                       |   16 +-
 fs/smb/client/smb2ops.c                    |    8 +-
 fs/smb/client/smb2pdu.c                    |    2 +-
 fs/smb/client/smbdirect.c                  |  943 +++++++------
 fs/smb/client/smbdirect.h                  |  104 +-
 fs/smb/common/smbdirect/smbdirect.h        |    7 +
 fs/smb/common/smbdirect/smbdirect_socket.h |  242 +++-
 fs/smb/server/connection.c                 |    4 +-
 fs/smb/server/connection.h                 |   10 +-
 fs/smb/server/server.c                     |    1 +
 fs/smb/server/smb2pdu.c                    |   23 +-
 fs/smb/server/smb2pdu.h                    |    6 -
 fs/smb/server/transport_rdma.c             | 1434 ++++++++++----------
 fs/smb/server/transport_rdma.h             |   45 +-
 16 files changed, 1565 insertions(+), 1337 deletions(-)

-- 
2.43.0

[PATCH v4 001/142] smb: smbdirect: introduce smbdirect_socket.status_wait

[Stefan Metzmacher]

This will be used by server and client soon.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/common/smbdirect/smbdirect_socket.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index 3c4a8d627aa3..80c3b712804c 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -18,6 +18,7 @@ enum smbdirect_socket_status {
 
 struct smbdirect_socket {
 	enum smbdirect_socket_status status;
+	wait_queue_head_t status_wait;
 
 	/* RDMA related */
 	struct {
-- 
2.43.0

[PATCH v4 002/142] smb: smbdirect: introduce smbdirect_socket_init()

[Stefan Metzmacher]

This will make it easier to keep the initialization
in a single place.

For now it's an __always_inline function as we only
share the header files. Once move to common functions
we'll have a dedicated smbdirect.ko that exports functions...

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect_socket.h | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index 80c3b712804c..5c94e668b8ae 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -113,6 +113,22 @@ struct smbdirect_socket {
 	} recv_io;
 };
 
+static __always_inline void smbdirect_socket_init(struct smbdirect_socket *sc)
+{
+	*sc = (struct smbdirect_socket) {
+		.status = SMBDIRECT_SOCKET_CREATED,
+	};
+
+	init_waitqueue_head(&sc->status_wait);
+
+	INIT_LIST_HEAD(&sc->recv_io.free.list);
+	spin_lock_init(&sc->recv_io.free.lock);
+
+	INIT_LIST_HEAD(&sc->recv_io.reassembly.list);
+	spin_lock_init(&sc->recv_io.reassembly.lock);
+	init_waitqueue_head(&sc->recv_io.reassembly.wait_queue);
+}
+
 struct smbdirect_send_io {
 	struct smbdirect_socket *socket;
 	struct ib_cqe cqe;
-- 
2.43.0

[PATCH v4 003/142] smb: smbdirect: introduce smbdirect_socket.disconnect_work

[Stefan Metzmacher]

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect_socket.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index 5c94e668b8ae..79eb99ba984e 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -20,6 +20,8 @@ struct smbdirect_socket {
 	enum smbdirect_socket_status status;
 	wait_queue_head_t status_wait;
 
+	struct work_struct disconnect_work;
+
 	/* RDMA related */
 	struct {
 		struct rdma_cm_id *cm_id;
-- 
2.43.0

[PATCH v4 004/142] smb: smbdirect: introduce smbdirect_socket.send_io.pending.{count,wait_queue}

[Stefan Metzmacher]

This will be shared between client and server soon.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect_socket.h | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index 79eb99ba984e..bfae68177e50 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -54,6 +54,14 @@ struct smbdirect_socket {
 			struct kmem_cache	*cache;
 			mempool_t		*pool;
 		} mem;
+
+		/*
+		 * The state about posted/pending sends
+		 */
+		struct {
+			atomic_t count;
+			wait_queue_head_t wait_queue;
+		} pending;
 	} send_io;
 
 	/*
@@ -123,6 +131,9 @@ static __always_inline void smbdirect_socket_init(struct smbdirect_socket *sc)
 
 	init_waitqueue_head(&sc->status_wait);
 
+	atomic_set(&sc->send_io.pending.count, 0);
+	init_waitqueue_head(&sc->send_io.pending.wait_queue);
+
 	INIT_LIST_HEAD(&sc->recv_io.free.list);
 	spin_lock_init(&sc->recv_io.free.lock);
 
-- 
2.43.0

Re: [PATCH v4 004/142] smb: smbdirect: introduce smbdirect_socket.send_io.pending.{count, wait_queue}

[Stefan Metzmacher]

Am 25.08.25 um 22:39 schrieb Stefan Metzmacher via samba-technical:
> This will be shared between client and server soon.
> 
> Cc: Steve French <smfrench@gmail.com>
> Cc: Tom Talpey <tom@talpey.com>
> Cc: Long Li <longli@microsoft.com>
> Cc: Namjae Jeon <linkinjeon@kernel.org>
> Cc: linux-cifs@vger.kernel.org
> Cc: samba-technical@lists.samba.org
> Signed-off-by: Stefan Metzmacher <metze@samba.org>
> ---
>   fs/smb/common/smbdirect/smbdirect_socket.h | 11 +++++++++++
>   1 file changed, 11 insertions(+)
> 
> diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
> index 79eb99ba984e..bfae68177e50 100644
> --- a/fs/smb/common/smbdirect/smbdirect_socket.h
> +++ b/fs/smb/common/smbdirect/smbdirect_socket.h
> @@ -54,6 +54,14 @@ struct smbdirect_socket {
>   			struct kmem_cache	*cache;
>   			mempool_t		*pool;
>   		} mem;
> +
> +		/*
> +		 * The state about posted/pending sends
> +		 */
> +		struct {
> +			atomic_t count;
> +			wait_queue_head_t wait_queue;

While doing the rebase on "smb: server: let smb_direct_writev() respect SMB_DIRECT_MAX_SEND_SGES"
I'll change 'pending.wait_queue' into 'pending.zero_wait_queue' to indicate it's woken
when count reached 0. And I'll add a 'pending.dec_wait_queue' in addition that is woken
when count is decremented. I realized that this in needed for the client changes in order
to avoid changing the logic for now.

metze

[PATCH v4 005/142] smb: smbdirect: introduce smbdirect_socket.send_io.credits.{count,wait_queue}

[Stefan Metzmacher]

This will be shared between client and server soon.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect_socket.h | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index bfae68177e50..fc52c85a32fe 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -55,6 +55,14 @@ struct smbdirect_socket {
 			mempool_t		*pool;
 		} mem;
 
+		/*
+		 * The credit state for the send side
+		 */
+		struct {
+			atomic_t count;
+			wait_queue_head_t wait_queue;
+		} credits;
+
 		/*
 		 * The state about posted/pending sends
 		 */
@@ -131,6 +139,9 @@ static __always_inline void smbdirect_socket_init(struct smbdirect_socket *sc)
 
 	init_waitqueue_head(&sc->status_wait);
 
+	atomic_set(&sc->send_io.credits.count, 0);
+	init_waitqueue_head(&sc->send_io.credits.wait_queue);
+
 	atomic_set(&sc->send_io.pending.count, 0);
 	init_waitqueue_head(&sc->send_io.pending.wait_queue);
 
-- 
2.43.0

[PATCH v4 006/142] smb: smbdirect: introduce struct smbdirect_send_batch

[Stefan Metzmacher]

This will replace struct smb_direct_send_ctx in the server
and allow us move code to the common smbdirect layer soon.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect_socket.h | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index fc52c85a32fe..ef6f330ba7d4 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -177,6 +177,23 @@ struct smbdirect_send_io {
 	u8 packet[];
 };
 
+struct smbdirect_send_batch {
+	/*
+	 * List of smbdirect_send_io messages
+	 */
+	struct list_head msg_list;
+	/*
+	 * Number of list entries
+	 */
+	size_t wr_cnt;
+
+	/*
+	 * Possible remote key invalidation state
+	 */
+	bool need_invalidate_rkey;
+	u32 remote_key;
+};
+
 struct smbdirect_recv_io {
 	struct smbdirect_socket *socket;
 	struct ib_cqe cqe;
-- 
2.43.0

[PATCH v4 007/142] smb: smbdirect: introduce smbdirect_socket.rw_io.credits

[Stefan Metzmacher]

This will be used by the server to manage the state
for RDMA read/write requests.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect_socket.h | 24 ++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index ef6f330ba7d4..001193799e16 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -129,6 +129,27 @@ struct smbdirect_socket {
 			bool full_packet_received;
 		} reassembly;
 	} recv_io;
+
+	/*
+	 * The state for RDMA read/write requests on the server
+	 */
+	struct {
+		/*
+		 * The credit state for the send side
+		 */
+		struct {
+			/*
+			 * The maximum number of rw credits
+			 */
+			size_t max;
+			/*
+			 * The number of pages per credit
+			 */
+			size_t num_pages;
+			atomic_t count;
+			wait_queue_head_t wait_queue;
+		} credits;
+	} rw_io;
 };
 
 static __always_inline void smbdirect_socket_init(struct smbdirect_socket *sc)
@@ -151,6 +172,9 @@ static __always_inline void smbdirect_socket_init(struct smbdirect_socket *sc)
 	INIT_LIST_HEAD(&sc->recv_io.reassembly.list);
 	spin_lock_init(&sc->recv_io.reassembly.lock);
 	init_waitqueue_head(&sc->recv_io.reassembly.wait_queue);
+
+	atomic_set(&sc->rw_io.credits.count, 0);
+	init_waitqueue_head(&sc->rw_io.credits.wait_queue);
 }
 
 struct smbdirect_send_io {
-- 
2.43.0

[PATCH v4 008/142] smb: smbdirect: introduce struct smbdirect_rw_io

[Stefan Metzmacher]

This will be used by the server in order to manage
RDMA reads and writes.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect_socket.h | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index 001193799e16..ff7b9f20b1ac 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -6,6 +6,8 @@
 #ifndef __FS_SMB_COMMON_SMBDIRECT_SMBDIRECT_SOCKET_H__
 #define __FS_SMB_COMMON_SMBDIRECT_SMBDIRECT_SOCKET_H__
 
+#include <rdma/rw.h>
+
 enum smbdirect_socket_status {
 	SMBDIRECT_SOCKET_CREATED,
 	SMBDIRECT_SOCKET_CONNECTING,
@@ -240,4 +242,18 @@ struct smbdirect_recv_io {
 	u8 packet[];
 };
 
+struct smbdirect_rw_io {
+	struct smbdirect_socket *socket;
+	struct ib_cqe cqe;
+
+	struct list_head list;
+
+	int error;
+	struct completion *completion;
+
+	struct rdma_rw_ctx rdma_ctx;
+	struct sg_table sgt;
+	struct scatterlist sg_list[];
+};
+
 #endif /* __FS_SMB_COMMON_SMBDIRECT_SMBDIRECT_SOCKET_H__ */
-- 
2.43.0

[PATCH v4 009/142] smb: smbdirect: introduce smbdirect_socket.recv_io.{posted,credits}

[Stefan Metzmacher]

This will be used by client and server soon in order to maintain
the state of posted recv_io messages and granted credits.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect_socket.h | 21 +++++++++++++++++++++
 1 file changed, 21 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index ff7b9f20b1ac..09834e8db853 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -105,6 +105,23 @@ struct smbdirect_socket {
 			spinlock_t lock;
 		} free;
 
+		/*
+		 * The state for posted recv_io messages
+		 * and the refill work struct.
+		 */
+		struct {
+			atomic_t count;
+			struct work_struct refill_work;
+		} posted;
+
+		/*
+		 * The credit state for the recv side
+		 */
+		struct {
+			u16 target;
+			atomic_t count;
+		} credits;
+
 		/*
 		 * The list of arrived non-empty smbdirect_recv_io
 		 * structures
@@ -171,6 +188,10 @@ static __always_inline void smbdirect_socket_init(struct smbdirect_socket *sc)
 	INIT_LIST_HEAD(&sc->recv_io.free.list);
 	spin_lock_init(&sc->recv_io.free.lock);
 
+	atomic_set(&sc->recv_io.posted.count, 0);
+
+	atomic_set(&sc->recv_io.credits.count, 0);
+
 	INIT_LIST_HEAD(&sc->recv_io.reassembly.list);
 	spin_lock_init(&sc->recv_io.reassembly.lock);
 	init_waitqueue_head(&sc->recv_io.reassembly.wait_queue);
-- 
2.43.0

[PATCH v4 010/142] smb: smbdirect: introduce smbdirect_socket_parameters.{resolve_{addr,route},rdma_connect,negotiate}_timeout_msec

[Stefan Metzmacher]

These will be used instead of hardcoded values in client and server.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect.h b/fs/smb/common/smbdirect/smbdirect.h
index b9a385344ff3..17aa08dd6aba 100644
--- a/fs/smb/common/smbdirect/smbdirect.h
+++ b/fs/smb/common/smbdirect/smbdirect.h
@@ -23,6 +23,10 @@ struct smbdirect_buffer_descriptor_v1 {
  * Some values are important for the upper layer.
  */
 struct smbdirect_socket_parameters {
+	__u32 resolve_addr_timeout_msec;
+	__u32 resolve_route_timeout_msec;
+	__u32 rdma_connect_timeout_msec;
+	__u32 negotiate_timeout_msec;
 	__u16 recv_credit_max;
 	__u16 send_credit_target;
 	__u32 max_send_size;
-- 
2.43.0

[PATCH v4 011/142] smb: smbdirect: introduce smbdirect_socket_parameters.{initiator_depth,responder_resources}

[Stefan Metzmacher]

This will make it easier to specify these from the outside of the core
code later.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect.h | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect.h b/fs/smb/common/smbdirect/smbdirect.h
index 17aa08dd6aba..c3274bbb3c02 100644
--- a/fs/smb/common/smbdirect/smbdirect.h
+++ b/fs/smb/common/smbdirect/smbdirect.h
@@ -27,6 +27,8 @@ struct smbdirect_socket_parameters {
 	__u32 resolve_route_timeout_msec;
 	__u32 rdma_connect_timeout_msec;
 	__u32 negotiate_timeout_msec;
+	__u8  initiator_depth;
+	__u8  responder_resources;
 	__u16 recv_credit_max;
 	__u16 send_credit_target;
 	__u32 max_send_size;
-- 
2.43.0

[PATCH v4 012/142] smb: smbdirect: introduce smbdirect_socket.rdma.legacy_iwarp

[Stefan Metzmacher]

This will be used by client and server soon.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect_socket.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index 09834e8db853..11f43a501c33 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -27,6 +27,10 @@ struct smbdirect_socket {
 	/* RDMA related */
 	struct {
 		struct rdma_cm_id *cm_id;
+		/*
+		 * This is for iWarp MPA v1
+		 */
+		bool legacy_iwarp;
 	} rdma;
 
 	/* IB verbs related */
-- 
2.43.0

[PATCH v4 013/142] smb: smbdirect: introduce smbdirect_socket.idle.{keepalive,immediate_work,timer_work}

[Stefan Metzmacher]

This will allow client and server to use the common structures in order
to share common functions later.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect_socket.h | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index 11f43a501c33..fade09dfc63d 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -18,6 +18,12 @@ enum smbdirect_socket_status {
 	SMBDIRECT_SOCKET_DESTROYED
 };
 
+enum smbdirect_keepalive_status {
+	SMBDIRECT_KEEPALIVE_NONE,
+	SMBDIRECT_KEEPALIVE_PENDING,
+	SMBDIRECT_KEEPALIVE_SENT
+};
+
 struct smbdirect_socket {
 	enum smbdirect_socket_status status;
 	wait_queue_head_t status_wait;
@@ -48,6 +54,15 @@ struct smbdirect_socket {
 
 	struct smbdirect_socket_parameters parameters;
 
+	/*
+	 * The state for keepalive and timeout handling
+	 */
+	struct {
+		enum smbdirect_keepalive_status keepalive;
+		struct work_struct immediate_work;
+		struct delayed_work timer_work;
+	} idle;
+
 	/*
 	 * The state for posted send buffers
 	 */
-- 
2.43.0

[PATCH v4 014/142] smb: smbdirect: introduce smbdirect_socket.statistics

[Stefan Metzmacher]

These will be used by the client and maybe shared code in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect_socket.h | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index fade09dfc63d..5df0143ccd6a 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -188,6 +188,17 @@ struct smbdirect_socket {
 			wait_queue_head_t wait_queue;
 		} credits;
 	} rw_io;
+
+	/*
+	 * For debug purposes
+	 */
+	struct {
+		u64 get_receive_buffer;
+		u64 put_receive_buffer;
+		u64 enqueue_reassembly_queue;
+		u64 dequeue_reassembly_queue;
+		u64 send_empty;
+	} statistics;
 };
 
 static __always_inline void smbdirect_socket_init(struct smbdirect_socket *sc)
-- 
2.43.0

[PATCH v4 015/142] smb: smbdirect: introduce smbdirect_socket.workqueue

[Stefan Metzmacher]

The client currently used a per socket workqueue
because it can block in a work function
waiting for credits.

So we use a per socket pointer in order to prepare
common code.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect_socket.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index 5df0143ccd6a..c4e37c156f46 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -28,6 +28,14 @@ struct smbdirect_socket {
 	enum smbdirect_socket_status status;
 	wait_queue_head_t status_wait;
 
+	/*
+	 * This points to the workqueue to
+	 * be used for this socket.
+	 * It can be per socket (on the client)
+	 * or point to a global workqueue (on the server)
+	 */
+	struct workqueue_struct *workqueue;
+
 	struct work_struct disconnect_work;
 
 	/* RDMA related */
-- 
2.43.0

[PATCH v4 016/142] smb: smbdirect: introduce struct smbdirect_mr_io

[Stefan Metzmacher]

This will be used by the client in order to maintain
memory registrations.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect_socket.h | 26 ++++++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index c4e37c156f46..588501a0a706 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -301,6 +301,32 @@ struct smbdirect_recv_io {
 	u8 packet[];
 };
 
+enum smbdirect_mr_state {
+	SMBDIRECT_MR_READY,
+	SMBDIRECT_MR_REGISTERED,
+	SMBDIRECT_MR_INVALIDATED,
+	SMBDIRECT_MR_ERROR
+};
+
+struct smbdirect_mr_io {
+	struct smbdirect_socket *socket;
+	struct ib_cqe cqe;
+
+	struct list_head list;
+
+	enum smbdirect_mr_state state;
+	struct ib_mr *mr;
+	struct sg_table sgt;
+	enum dma_data_direction dir;
+	union {
+		struct ib_reg_wr wr;
+		struct ib_send_wr inv_wr;
+	};
+
+	bool need_invalidate;
+	struct completion invalidate_done;
+};
+
 struct smbdirect_rw_io {
 	struct smbdirect_socket *socket;
 	struct ib_cqe cqe;
-- 
2.43.0

[PATCH v4 017/142] smb: smbdirect: introduce smbdirect_socket_parameters.max_frmr_depth

[Stefan Metzmacher]

This will be used by the client...

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs/smb/common/smbdirect/smbdirect.h b/fs/smb/common/smbdirect/smbdirect.h
index c3274bbb3c02..05cc6a9d0ccd 100644
--- a/fs/smb/common/smbdirect/smbdirect.h
+++ b/fs/smb/common/smbdirect/smbdirect.h
@@ -36,6 +36,7 @@ struct smbdirect_socket_parameters {
 	__u32 max_recv_size;
 	__u32 max_fragmented_recv_size;
 	__u32 max_read_write_size;
+	__u32 max_frmr_depth;
 	__u32 keepalive_interval_msec;
 	__u32 keepalive_timeout_msec;
 } __packed;
-- 
2.43.0

[PATCH v4 018/142] smb: smbdirect: introduce smbdirect_socket.mr_io.*

[Stefan Metzmacher]

This will be used by the client and will allow us to move to
common code...

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/common/smbdirect/smbdirect_socket.h | 45 ++++++++++++++++++++++
 1 file changed, 45 insertions(+)

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index 588501a0a706..350ccb362718 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -176,6 +176,44 @@ struct smbdirect_socket {
 		} reassembly;
 	} recv_io;
 
+	/*
+	 * The state for Memory registrations on the client
+	 */
+	struct {
+		enum ib_mr_type type;
+
+		/*
+		 * The list of free smbdirect_mr_io
+		 * structures
+		 */
+		struct {
+			struct list_head list;
+			spinlock_t lock;
+		} all;
+
+		/*
+		 * The number of available MRs ready for memory registration
+		 */
+		struct {
+			atomic_t count;
+			wait_queue_head_t wait_queue;
+		} ready;
+
+		/*
+		 * The number of used MRs
+		 */
+		struct {
+			atomic_t count;
+		} used;
+
+		struct work_struct recovery_work;
+
+		/* Used by transport to wait until all MRs are returned */
+		struct {
+			wait_queue_head_t wait_queue;
+		} cleanup;
+	} mr_io;
+
 	/*
 	 * The state for RDMA read/write requests on the server
 	 */
@@ -236,6 +274,13 @@ static __always_inline void smbdirect_socket_init(struct smbdirect_socket *sc)
 
 	atomic_set(&sc->rw_io.credits.count, 0);
 	init_waitqueue_head(&sc->rw_io.credits.wait_queue);
+
+	spin_lock_init(&sc->mr_io.all.lock);
+	INIT_LIST_HEAD(&sc->mr_io.all.list);
+	atomic_set(&sc->mr_io.ready.count, 0);
+	init_waitqueue_head(&sc->mr_io.ready.wait_queue);
+	atomic_set(&sc->mr_io.used.count, 0);
+	init_waitqueue_head(&sc->mr_io.cleanup.wait_queue);
 }
 
 struct smbdirect_send_io {
-- 
2.43.0

[PATCH v4 019/142] smb: client/smbdirect: replace SMBDIRECT_SOCKET_CONNECTING with more detailed states

[Stefan Metzmacher]

The process of reaching a functional connection represented by
SMBDIRECT_SOCKET_CONNECTED, is more complex than using a single
SMBDIRECT_SOCKET_CONNECTING state.

This will allow us to remove a lot of special variables and
completions in the following commits.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/client/smbdirect.c                  | 73 ++++++++++++++++++++--
 fs/smb/common/smbdirect/smbdirect_socket.h | 14 ++++-
 2 files changed, 79 insertions(+), 8 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 669408b113cb..cfc5e17bc055 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -161,9 +161,36 @@ static void smbd_disconnect_rdma_work(struct work_struct *work)
 		container_of(work, struct smbd_connection, disconnect_work);
 	struct smbdirect_socket *sc = &info->socket;
 
-	if (sc->status == SMBDIRECT_SOCKET_CONNECTED) {
+	switch (sc->status) {
+	case SMBDIRECT_SOCKET_NEGOTIATE_NEEDED:
+	case SMBDIRECT_SOCKET_NEGOTIATE_RUNNING:
+	case SMBDIRECT_SOCKET_NEGOTIATE_FAILED:
+	case SMBDIRECT_SOCKET_CONNECTED:
 		sc->status = SMBDIRECT_SOCKET_DISCONNECTING;
 		rdma_disconnect(sc->rdma.cm_id);
+		break;
+
+	case SMBDIRECT_SOCKET_CREATED:
+	case SMBDIRECT_SOCKET_RESOLVE_ADDR_NEEDED:
+	case SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING:
+	case SMBDIRECT_SOCKET_RESOLVE_ADDR_FAILED:
+	case SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED:
+	case SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING:
+	case SMBDIRECT_SOCKET_RESOLVE_ROUTE_FAILED:
+	case SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED:
+	case SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING:
+	case SMBDIRECT_SOCKET_RDMA_CONNECT_FAILED:
+		/*
+		 * rdma_connect() never reached
+		 * RDMA_CM_EVENT_ESTABLISHED
+		 */
+		sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
+		break;
+
+	case SMBDIRECT_SOCKET_DISCONNECTING:
+	case SMBDIRECT_SOCKET_DISCONNECTED:
+	case SMBDIRECT_SOCKET_DESTROYED:
+		break;
 	}
 }
 
@@ -187,19 +214,31 @@ static int smbd_conn_upcall(
 
 	switch (event->event) {
 	case RDMA_CM_EVENT_ADDR_RESOLVED:
+		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING);
+		sc->status = SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED;
+		info->ri_rc = 0;
+		complete(&info->ri_done);
+		break;
+
 	case RDMA_CM_EVENT_ROUTE_RESOLVED:
+		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING);
+		sc->status = SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED;
 		info->ri_rc = 0;
 		complete(&info->ri_done);
 		break;
 
 	case RDMA_CM_EVENT_ADDR_ERROR:
 		log_rdma_event(ERR, "connecting failed event=%s\n", event_name);
+		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING);
+		sc->status = SMBDIRECT_SOCKET_RESOLVE_ADDR_FAILED;
 		info->ri_rc = -EHOSTUNREACH;
 		complete(&info->ri_done);
 		break;
 
 	case RDMA_CM_EVENT_ROUTE_ERROR:
 		log_rdma_event(ERR, "connecting failed event=%s\n", event_name);
+		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING);
+		sc->status = SMBDIRECT_SOCKET_RESOLVE_ROUTE_FAILED;
 		info->ri_rc = -ENETUNREACH;
 		complete(&info->ri_done);
 		break;
@@ -259,7 +298,8 @@ static int smbd_conn_upcall(
 				min_t(u8, info->responder_resources,
 				      peer_responder_resources);
 
-		sc->status = SMBDIRECT_SOCKET_CONNECTED;
+		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING);
+		sc->status = SMBDIRECT_SOCKET_NEGOTIATE_NEEDED;
 		wake_up_interruptible(&info->status_wait);
 		break;
 
@@ -267,7 +307,8 @@ static int smbd_conn_upcall(
 	case RDMA_CM_EVENT_UNREACHABLE:
 	case RDMA_CM_EVENT_REJECTED:
 		log_rdma_event(ERR, "connecting failed event=%s\n", event_name);
-		sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
+		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING);
+		sc->status = SMBDIRECT_SOCKET_RDMA_CONNECT_FAILED;
 		wake_up_interruptible(&info->status_wait);
 		break;
 
@@ -536,6 +577,12 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		info->negotiate_done =
 			process_negotiation_response(response, wc->byte_len);
 		put_receive_buffer(info, response);
+		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_NEGOTIATE_RUNNING);
+		if (!info->negotiate_done)
+			sc->status = SMBDIRECT_SOCKET_NEGOTIATE_FAILED;
+		else
+			sc->status = SMBDIRECT_SOCKET_CONNECTED;
+
 		complete(&info->negotiate_completion);
 		return;
 
@@ -611,6 +658,7 @@ static struct rdma_cm_id *smbd_create_id(
 		struct smbd_connection *info,
 		struct sockaddr *dstaddr, int port)
 {
+	struct smbdirect_socket *sc = &info->socket;
 	struct rdma_cm_id *id;
 	int rc;
 	__be16 *sport;
@@ -633,6 +681,8 @@ static struct rdma_cm_id *smbd_create_id(
 	init_completion(&info->ri_done);
 	info->ri_rc = -ETIMEDOUT;
 
+	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ADDR_NEEDED);
+	sc->status = SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING;
 	rc = rdma_resolve_addr(id, NULL, (struct sockaddr *)dstaddr,
 		RDMA_RESOLVE_TIMEOUT);
 	if (rc) {
@@ -653,6 +703,8 @@ static struct rdma_cm_id *smbd_create_id(
 	}
 
 	info->ri_rc = -ETIMEDOUT;
+	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED);
+	sc->status = SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING;
 	rc = rdma_resolve_route(id, RDMA_RESOLVE_TIMEOUT);
 	if (rc) {
 		log_rdma_event(ERR, "rdma_resolve_route() failed %i\n", rc);
@@ -699,6 +751,9 @@ static int smbd_ia_open(
 	struct smbdirect_socket *sc = &info->socket;
 	int rc;
 
+	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_CREATED);
+	sc->status = SMBDIRECT_SOCKET_RESOLVE_ADDR_NEEDED;
+
 	sc->rdma.cm_id = smbd_create_id(info, dstaddr, port);
 	if (IS_ERR(sc->rdma.cm_id)) {
 		rc = PTR_ERR(sc->rdma.cm_id);
@@ -1140,6 +1195,9 @@ static int smbd_negotiate(struct smbd_connection *info)
 	int rc;
 	struct smbdirect_recv_io *response = get_receive_buffer(info);
 
+	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_NEGOTIATE_NEEDED);
+	sc->status = SMBDIRECT_SOCKET_NEGOTIATE_RUNNING;
+
 	sc->recv_io.expected = SMBDIRECT_EXPECT_NEGOTIATE_REP;
 	rc = smbd_post_recv(info, response);
 	log_rdma_event(INFO, "smbd_post_recv rc=%d iov.addr=0x%llx iov.length=%u iov.lkey=0x%x\n",
@@ -1594,7 +1652,7 @@ static struct smbd_connection *_smbd_get_connection(
 	info->initiator_depth = 1;
 	info->responder_resources = SMBD_CM_RESPONDER_RESOURCES;
 
-	sc->status = SMBDIRECT_SOCKET_CONNECTING;
+	sc->status = SMBDIRECT_SOCKET_CREATED;
 	rc = smbd_ia_open(info, dstaddr, port);
 	if (rc) {
 		log_rdma_event(INFO, "smbd_ia_open rc=%d\n", rc);
@@ -1706,6 +1764,9 @@ static struct smbd_connection *_smbd_get_connection(
 
 	init_waitqueue_head(&info->status_wait);
 	init_waitqueue_head(&sc->recv_io.reassembly.wait_queue);
+
+	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED);
+	sc->status = SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING;
 	rc = rdma_connect(sc->rdma.cm_id, &conn_param);
 	if (rc) {
 		log_rdma_event(ERR, "rdma_connect() failed with %i\n", rc);
@@ -1714,10 +1775,10 @@ static struct smbd_connection *_smbd_get_connection(
 
 	wait_event_interruptible_timeout(
 		info->status_wait,
-		sc->status != SMBDIRECT_SOCKET_CONNECTING,
+		sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING,
 		msecs_to_jiffies(RDMA_RESOLVE_TIMEOUT));
 
-	if (sc->status != SMBDIRECT_SOCKET_CONNECTED) {
+	if (sc->status != SMBDIRECT_SOCKET_NEGOTIATE_NEEDED) {
 		log_rdma_event(ERR, "rdma_connect failed port=%d\n", port);
 		goto rdma_connect_failed;
 	}
diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index 350ccb362718..64abe6932fef 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -10,9 +10,19 @@
 
 enum smbdirect_socket_status {
 	SMBDIRECT_SOCKET_CREATED,
-	SMBDIRECT_SOCKET_CONNECTING,
-	SMBDIRECT_SOCKET_CONNECTED,
+	SMBDIRECT_SOCKET_RESOLVE_ADDR_NEEDED,
+	SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING,
+	SMBDIRECT_SOCKET_RESOLVE_ADDR_FAILED,
+	SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED,
+	SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING,
+	SMBDIRECT_SOCKET_RESOLVE_ROUTE_FAILED,
+	SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED,
+	SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING,
+	SMBDIRECT_SOCKET_RDMA_CONNECT_FAILED,
+	SMBDIRECT_SOCKET_NEGOTIATE_NEEDED,
+	SMBDIRECT_SOCKET_NEGOTIATE_RUNNING,
 	SMBDIRECT_SOCKET_NEGOTIATE_FAILED,
+	SMBDIRECT_SOCKET_CONNECTED,
 	SMBDIRECT_SOCKET_DISCONNECTING,
 	SMBDIRECT_SOCKET_DISCONNECTED,
 	SMBDIRECT_SOCKET_DESTROYED
-- 
2.43.0

[PATCH v4 020/142] smb: client: use status_wait and SMBDIRECT_SOCKET_NEGOTIATE_RUNNING for completion

[Stefan Metzmacher]

We can use the state change from SMBDIRECT_SOCKET_NEGOTIATE_RUNNING to
SMBDIRECT_SOCKET_CONNECTED or SMBDIRECT_SOCKET_NEGOTIATE_FAILED in order
to notify the caller if the negotiation is over.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/client/smbdirect.c | 19 ++++++++++---------
 fs/smb/client/smbdirect.h |  3 ---
 2 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index cfc5e17bc055..c94b7d4f2dc2 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -552,6 +552,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	struct smbd_connection *info =
 		container_of(sc, struct smbd_connection, socket);
 	int data_length = 0;
+	bool negotiate_done = false;
 
 	log_rdma_recv(INFO, "response=0x%p type=%d wc status=%d wc opcode %d byte_len=%d pkey_index=%u\n",
 		      response, sc->recv_io.expected, wc->status, wc->opcode,
@@ -574,16 +575,16 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	case SMBDIRECT_EXPECT_NEGOTIATE_REP:
 		dump_smbdirect_negotiate_resp(smbdirect_recv_io_payload(response));
 		sc->recv_io.reassembly.full_packet_received = true;
-		info->negotiate_done =
+		negotiate_done =
 			process_negotiation_response(response, wc->byte_len);
 		put_receive_buffer(info, response);
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_NEGOTIATE_RUNNING);
-		if (!info->negotiate_done)
+		if (!negotiate_done)
 			sc->status = SMBDIRECT_SOCKET_NEGOTIATE_FAILED;
 		else
 			sc->status = SMBDIRECT_SOCKET_CONNECTED;
 
-		complete(&info->negotiate_completion);
+		wake_up_interruptible(&info->status_wait);
 		return;
 
 	/* SMBD data transfer packet */
@@ -1206,17 +1207,17 @@ static int smbd_negotiate(struct smbd_connection *info)
 	if (rc)
 		return rc;
 
-	init_completion(&info->negotiate_completion);
-	info->negotiate_done = false;
 	rc = smbd_post_send_negotiate_req(info);
 	if (rc)
 		return rc;
 
-	rc = wait_for_completion_interruptible_timeout(
-		&info->negotiate_completion, SMBD_NEGOTIATE_TIMEOUT * HZ);
-	log_rdma_event(INFO, "wait_for_completion_timeout rc=%d\n", rc);
+	rc = wait_event_interruptible_timeout(
+		info->status_wait,
+		sc->status != SMBDIRECT_SOCKET_NEGOTIATE_RUNNING,
+		secs_to_jiffies(SMBD_NEGOTIATE_TIMEOUT));
+	log_rdma_event(INFO, "wait_event_interruptible_timeout rc=%d\n", rc);
 
-	if (info->negotiate_done)
+	if (sc->status == SMBDIRECT_SOCKET_CONNECTED)
 		return 0;
 
 	if (rc == 0)
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 4ca9b2b2c57f..c9b0c6b61e7e 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -49,9 +49,6 @@ struct smbd_connection {
 	struct completion ri_done;
 	wait_queue_head_t status_wait;
 
-	struct completion negotiate_completion;
-	bool negotiate_done;
-
 	struct work_struct disconnect_work;
 	struct work_struct post_send_credits_work;
 
-- 
2.43.0

[PATCH v4 021/142] smb: client: use status_wait and SMBDIRECT_SOCKET_RESOLVE_{ADDR,ROUTE}_RUNNING for completion

[Stefan Metzmacher]

We can use the state change from
SMBDIRECT_SOCKET_RESOLVE_{ADDR,ROUTE}_RUNNING
to the next state in order to wake the caller to do the next step.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/client/smbdirect.c | 49 ++++++++++++++++++++++-----------------
 fs/smb/client/smbdirect.h |  2 --
 2 files changed, 28 insertions(+), 23 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index c94b7d4f2dc2..8d1b6e36412c 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -216,31 +216,27 @@ static int smbd_conn_upcall(
 	case RDMA_CM_EVENT_ADDR_RESOLVED:
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED;
-		info->ri_rc = 0;
-		complete(&info->ri_done);
+		wake_up_interruptible(&info->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_ROUTE_RESOLVED:
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED;
-		info->ri_rc = 0;
-		complete(&info->ri_done);
+		wake_up_interruptible(&info->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_ADDR_ERROR:
 		log_rdma_event(ERR, "connecting failed event=%s\n", event_name);
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_RESOLVE_ADDR_FAILED;
-		info->ri_rc = -EHOSTUNREACH;
-		complete(&info->ri_done);
+		wake_up_interruptible(&info->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_ROUTE_ERROR:
 		log_rdma_event(ERR, "connecting failed event=%s\n", event_name);
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_RESOLVE_ROUTE_FAILED;
-		info->ri_rc = -ENETUNREACH;
-		complete(&info->ri_done);
+		wake_up_interruptible(&info->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_ESTABLISHED:
@@ -679,9 +675,6 @@ static struct rdma_cm_id *smbd_create_id(
 
 	*sport = htons(port);
 
-	init_completion(&info->ri_done);
-	info->ri_rc = -ETIMEDOUT;
-
 	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ADDR_NEEDED);
 	sc->status = SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING;
 	rc = rdma_resolve_addr(id, NULL, (struct sockaddr *)dstaddr,
@@ -690,20 +683,26 @@ static struct rdma_cm_id *smbd_create_id(
 		log_rdma_event(ERR, "rdma_resolve_addr() failed %i\n", rc);
 		goto out;
 	}
-	rc = wait_for_completion_interruptible_timeout(
-		&info->ri_done, msecs_to_jiffies(RDMA_RESOLVE_TIMEOUT));
+	rc = wait_event_interruptible_timeout(
+		info->status_wait,
+		sc->status != SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING,
+		msecs_to_jiffies(RDMA_RESOLVE_TIMEOUT));
 	/* e.g. if interrupted returns -ERESTARTSYS */
 	if (rc < 0) {
 		log_rdma_event(ERR, "rdma_resolve_addr timeout rc: %i\n", rc);
 		goto out;
 	}
-	rc = info->ri_rc;
-	if (rc) {
+	if (sc->status == SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING) {
+		rc = -ETIMEDOUT;
+		log_rdma_event(ERR, "rdma_resolve_addr() completed %i\n", rc);
+		goto out;
+	}
+	if (sc->status != SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED) {
+		rc = -EHOSTUNREACH;
 		log_rdma_event(ERR, "rdma_resolve_addr() completed %i\n", rc);
 		goto out;
 	}
 
-	info->ri_rc = -ETIMEDOUT;
 	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED);
 	sc->status = SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING;
 	rc = rdma_resolve_route(id, RDMA_RESOLVE_TIMEOUT);
@@ -711,15 +710,22 @@ static struct rdma_cm_id *smbd_create_id(
 		log_rdma_event(ERR, "rdma_resolve_route() failed %i\n", rc);
 		goto out;
 	}
-	rc = wait_for_completion_interruptible_timeout(
-		&info->ri_done, msecs_to_jiffies(RDMA_RESOLVE_TIMEOUT));
+	rc = wait_event_interruptible_timeout(
+		info->status_wait,
+		sc->status != SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING,
+		msecs_to_jiffies(RDMA_RESOLVE_TIMEOUT));
 	/* e.g. if interrupted returns -ERESTARTSYS */
 	if (rc < 0)  {
 		log_rdma_event(ERR, "rdma_resolve_addr timeout rc: %i\n", rc);
 		goto out;
 	}
-	rc = info->ri_rc;
-	if (rc) {
+	if (sc->status == SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING) {
+		rc = -ETIMEDOUT;
+		log_rdma_event(ERR, "rdma_resolve_route() completed %i\n", rc);
+		goto out;
+	}
+	if (sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED) {
+		rc = -ENETUNREACH;
 		log_rdma_event(ERR, "rdma_resolve_route() completed %i\n", rc);
 		goto out;
 	}
@@ -1653,6 +1659,8 @@ static struct smbd_connection *_smbd_get_connection(
 	info->initiator_depth = 1;
 	info->responder_resources = SMBD_CM_RESPONDER_RESOURCES;
 
+	init_waitqueue_head(&info->status_wait);
+
 	sc->status = SMBDIRECT_SOCKET_CREATED;
 	rc = smbd_ia_open(info, dstaddr, port);
 	if (rc) {
@@ -1763,7 +1771,6 @@ static struct smbd_connection *_smbd_get_connection(
 	log_rdma_event(INFO, "connecting to IP %pI4 port %d\n",
 		&addr_in->sin_addr, port);
 
-	init_waitqueue_head(&info->status_wait);
 	init_waitqueue_head(&sc->recv_io.reassembly.wait_queue);
 
 	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED);
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index c9b0c6b61e7e..82b1d936e800 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -45,8 +45,6 @@ enum keep_alive_status {
 struct smbd_connection {
 	struct smbdirect_socket socket;
 
-	int ri_rc;
-	struct completion ri_done;
 	wait_queue_head_t status_wait;
 
 	struct work_struct disconnect_work;
-- 
2.43.0

[PATCH v4 022/142] smb: client: make use of smbdirect_socket.status_wait

[Stefan Metzmacher]

This will allow us to have common helper functions soon.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/client/smbdirect.c | 32 ++++++++++++++++----------------
 fs/smb/client/smbdirect.h |  2 --
 2 files changed, 16 insertions(+), 18 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 8d1b6e36412c..f28110c7a30f 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -216,27 +216,27 @@ static int smbd_conn_upcall(
 	case RDMA_CM_EVENT_ADDR_RESOLVED:
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED;
-		wake_up_interruptible(&info->status_wait);
+		wake_up_interruptible(&sc->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_ROUTE_RESOLVED:
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED;
-		wake_up_interruptible(&info->status_wait);
+		wake_up_interruptible(&sc->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_ADDR_ERROR:
 		log_rdma_event(ERR, "connecting failed event=%s\n", event_name);
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_RESOLVE_ADDR_FAILED;
-		wake_up_interruptible(&info->status_wait);
+		wake_up_interruptible(&sc->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_ROUTE_ERROR:
 		log_rdma_event(ERR, "connecting failed event=%s\n", event_name);
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_RESOLVE_ROUTE_FAILED;
-		wake_up_interruptible(&info->status_wait);
+		wake_up_interruptible(&sc->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_ESTABLISHED:
@@ -296,7 +296,7 @@ static int smbd_conn_upcall(
 
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_NEGOTIATE_NEEDED;
-		wake_up_interruptible(&info->status_wait);
+		wake_up_interruptible(&sc->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_CONNECT_ERROR:
@@ -305,7 +305,7 @@ static int smbd_conn_upcall(
 		log_rdma_event(ERR, "connecting failed event=%s\n", event_name);
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_RDMA_CONNECT_FAILED;
-		wake_up_interruptible(&info->status_wait);
+		wake_up_interruptible(&sc->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_DEVICE_REMOVAL:
@@ -314,12 +314,12 @@ static int smbd_conn_upcall(
 		if (sc->status == SMBDIRECT_SOCKET_NEGOTIATE_FAILED) {
 			log_rdma_event(ERR, "event=%s during negotiation\n", event_name);
 			sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
-			wake_up(&info->status_wait);
+			wake_up(&sc->status_wait);
 			break;
 		}
 
 		sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
-		wake_up_interruptible(&info->status_wait);
+		wake_up_interruptible(&sc->status_wait);
 		wake_up_interruptible(&sc->recv_io.reassembly.wait_queue);
 		wake_up_interruptible_all(&info->wait_send_queue);
 		break;
@@ -580,7 +580,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		else
 			sc->status = SMBDIRECT_SOCKET_CONNECTED;
 
-		wake_up_interruptible(&info->status_wait);
+		wake_up_interruptible(&sc->status_wait);
 		return;
 
 	/* SMBD data transfer packet */
@@ -684,7 +684,7 @@ static struct rdma_cm_id *smbd_create_id(
 		goto out;
 	}
 	rc = wait_event_interruptible_timeout(
-		info->status_wait,
+		sc->status_wait,
 		sc->status != SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING,
 		msecs_to_jiffies(RDMA_RESOLVE_TIMEOUT));
 	/* e.g. if interrupted returns -ERESTARTSYS */
@@ -711,7 +711,7 @@ static struct rdma_cm_id *smbd_create_id(
 		goto out;
 	}
 	rc = wait_event_interruptible_timeout(
-		info->status_wait,
+		sc->status_wait,
 		sc->status != SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING,
 		msecs_to_jiffies(RDMA_RESOLVE_TIMEOUT));
 	/* e.g. if interrupted returns -ERESTARTSYS */
@@ -1218,7 +1218,7 @@ static int smbd_negotiate(struct smbd_connection *info)
 		return rc;
 
 	rc = wait_event_interruptible_timeout(
-		info->status_wait,
+		sc->status_wait,
 		sc->status != SMBDIRECT_SOCKET_NEGOTIATE_RUNNING,
 		secs_to_jiffies(SMBD_NEGOTIATE_TIMEOUT));
 	log_rdma_event(INFO, "wait_event_interruptible_timeout rc=%d\n", rc);
@@ -1445,7 +1445,7 @@ void smbd_destroy(struct TCP_Server_Info *server)
 		rdma_disconnect(sc->rdma.cm_id);
 		log_rdma_event(INFO, "wait for transport being disconnected\n");
 		wait_event_interruptible(
-			info->status_wait,
+			sc->status_wait,
 			sc->status == SMBDIRECT_SOCKET_DISCONNECTED);
 	}
 
@@ -1659,7 +1659,7 @@ static struct smbd_connection *_smbd_get_connection(
 	info->initiator_depth = 1;
 	info->responder_resources = SMBD_CM_RESPONDER_RESOURCES;
 
-	init_waitqueue_head(&info->status_wait);
+	init_waitqueue_head(&sc->status_wait);
 
 	sc->status = SMBDIRECT_SOCKET_CREATED;
 	rc = smbd_ia_open(info, dstaddr, port);
@@ -1782,7 +1782,7 @@ static struct smbd_connection *_smbd_get_connection(
 	}
 
 	wait_event_interruptible_timeout(
-		info->status_wait,
+		sc->status_wait,
 		sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING,
 		msecs_to_jiffies(RDMA_RESOLVE_TIMEOUT));
 
@@ -1839,7 +1839,7 @@ static struct smbd_connection *_smbd_get_connection(
 	destroy_caches_and_workqueue(info);
 	sc->status = SMBDIRECT_SOCKET_NEGOTIATE_FAILED;
 	rdma_disconnect(sc->rdma.cm_id);
-	wait_event(info->status_wait,
+	wait_event(sc->status_wait,
 		sc->status == SMBDIRECT_SOCKET_DISCONNECTED);
 
 allocate_cache_failed:
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 82b1d936e800..f250241d2d24 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -45,8 +45,6 @@ enum keep_alive_status {
 struct smbd_connection {
 	struct smbdirect_socket socket;
 
-	wait_queue_head_t status_wait;
-
 	struct work_struct disconnect_work;
 	struct work_struct post_send_credits_work;
 
-- 
2.43.0

[PATCH v4 023/142] smb: client: make only use of wake_up[_all]() in smbdirect.c

[Stefan Metzmacher]

wake_up_interruptible[_all]() doesn't wake up tasks waiting
with wait_event().

So we better wake_up[_all]() in order to wake up all tasks in order
to simplify the logic.

As we currently don't use any wait_event_*_exclusive() it
doesn't really matter if we use wake_up() or wake_up_all().
But in this patch I try to use wake_up() for expected situations
and wake_up_all() for situations of a broken connection.
So don't need to adjust things in future when we
may use wait_event_*_exclusive() in order to wake up
only one process that should make progress.

Changing the wait_event_*() code in order to keep
wait_event(), wait_event_interruptible() and
wait_event_interruptible_timeout() or
changing them to wait_event_killable(),
wait_event_killable_timeout(),
wait_event_killable_exclusive()
is something to think about in a future patch.

The goal here is to avoid that some tasks are not
woken and freeze forever.

Also note that this patch only changes the existing
wake_up*() calls. Adding more wake_up*() calls for
other wait queues is also deferred to a future patch.

Link: https://lore.kernel.org/linux-cifs/13851363-0dc9-465c-9ced-3ede4904eef0@samba.org/T/#t
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 40 ++++++++++++++++++++-------------------
 1 file changed, 21 insertions(+), 19 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index f28110c7a30f..b67a264a6030 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -216,27 +216,27 @@ static int smbd_conn_upcall(
 	case RDMA_CM_EVENT_ADDR_RESOLVED:
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED;
-		wake_up_interruptible(&sc->status_wait);
+		wake_up(&sc->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_ROUTE_RESOLVED:
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED;
-		wake_up_interruptible(&sc->status_wait);
+		wake_up(&sc->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_ADDR_ERROR:
 		log_rdma_event(ERR, "connecting failed event=%s\n", event_name);
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_RESOLVE_ADDR_FAILED;
-		wake_up_interruptible(&sc->status_wait);
+		wake_up_all(&sc->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_ROUTE_ERROR:
 		log_rdma_event(ERR, "connecting failed event=%s\n", event_name);
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_RESOLVE_ROUTE_FAILED;
-		wake_up_interruptible(&sc->status_wait);
+		wake_up_all(&sc->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_ESTABLISHED:
@@ -296,7 +296,7 @@ static int smbd_conn_upcall(
 
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_NEGOTIATE_NEEDED;
-		wake_up_interruptible(&sc->status_wait);
+		wake_up(&sc->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_CONNECT_ERROR:
@@ -305,7 +305,7 @@ static int smbd_conn_upcall(
 		log_rdma_event(ERR, "connecting failed event=%s\n", event_name);
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING);
 		sc->status = SMBDIRECT_SOCKET_RDMA_CONNECT_FAILED;
-		wake_up_interruptible(&sc->status_wait);
+		wake_up_all(&sc->status_wait);
 		break;
 
 	case RDMA_CM_EVENT_DEVICE_REMOVAL:
@@ -314,14 +314,14 @@ static int smbd_conn_upcall(
 		if (sc->status == SMBDIRECT_SOCKET_NEGOTIATE_FAILED) {
 			log_rdma_event(ERR, "event=%s during negotiation\n", event_name);
 			sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
-			wake_up(&sc->status_wait);
+			wake_up_all(&sc->status_wait);
 			break;
 		}
 
 		sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
-		wake_up_interruptible(&sc->status_wait);
-		wake_up_interruptible(&sc->recv_io.reassembly.wait_queue);
-		wake_up_interruptible_all(&info->wait_send_queue);
+		wake_up_all(&sc->status_wait);
+		wake_up_all(&sc->recv_io.reassembly.wait_queue);
+		wake_up_all(&info->wait_send_queue);
 		break;
 
 	default:
@@ -498,7 +498,7 @@ static void smbd_post_send_credits(struct work_struct *work)
 	struct smbdirect_socket *sc = &info->socket;
 
 	if (sc->status != SMBDIRECT_SOCKET_CONNECTED) {
-		wake_up(&info->wait_receive_queues);
+		wake_up_all(&info->wait_receive_queues);
 		return;
 	}
 
@@ -575,12 +575,14 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			process_negotiation_response(response, wc->byte_len);
 		put_receive_buffer(info, response);
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_NEGOTIATE_RUNNING);
-		if (!negotiate_done)
+		if (!negotiate_done) {
 			sc->status = SMBDIRECT_SOCKET_NEGOTIATE_FAILED;
-		else
+			wake_up_all(&sc->status_wait);
+		} else {
 			sc->status = SMBDIRECT_SOCKET_CONNECTED;
+			wake_up(&sc->status_wait);
+		}
 
-		wake_up_interruptible(&sc->status_wait);
 		return;
 
 	/* SMBD data transfer packet */
@@ -608,7 +610,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			 * We have new send credits granted from remote peer
 			 * If any sender is waiting for credits, unblock it
 			 */
-			wake_up_interruptible(&info->wait_send_queue);
+			wake_up(&info->wait_send_queue);
 		}
 
 		log_incoming(INFO, "data flags %d data_offset %d data_length %d remaining_data_length %d\n",
@@ -630,7 +632,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		 */
 		if (data_length) {
 			enqueue_reassembly(info, response, data_length);
-			wake_up_interruptible(&sc->recv_io.reassembly.wait_queue);
+			wake_up(&sc->recv_io.reassembly.wait_queue);
 		} else
 			put_receive_buffer(info, response);
 
@@ -1486,7 +1488,7 @@ void smbd_destroy(struct TCP_Server_Info *server)
 	 * path when sending data, and then release memory registrations.
 	 */
 	log_rdma_event(INFO, "freeing mr list\n");
-	wake_up_interruptible_all(&info->wait_mr);
+	wake_up_all(&info->wait_mr);
 	while (atomic_read(&info->mr_used_count)) {
 		cifs_server_unlock(server);
 		msleep(1000);
@@ -2185,7 +2187,7 @@ static void smbd_mr_recovery_work(struct work_struct *work)
 		 * get_mr() from the I/O issuing CPUs
 		 */
 		if (atomic_inc_return(&info->mr_ready_count) == 1)
-			wake_up_interruptible(&info->wait_mr);
+			wake_up(&info->wait_mr);
 	}
 }
 
@@ -2496,7 +2498,7 @@ int smbd_deregister_mr(struct smbd_mr *smbdirect_mr)
 			smbdirect_mr->dir);
 		smbdirect_mr->state = MR_READY;
 		if (atomic_inc_return(&info->mr_ready_count) == 1)
-			wake_up_interruptible(&info->wait_mr);
+			wake_up(&info->wait_mr);
 	} else
 		/*
 		 * Schedule the work to do MR recovery for future I/Os MR
-- 
2.43.0

[PATCH v4 024/142] smb: client: make use of smbdirect_socket_init()

[Stefan Metzmacher]

It's much safer to initialize the whole structure at
the beginning than doing it all over the place
and then miss to move it if code changes.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 13 +------------
 1 file changed, 1 insertion(+), 12 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index b67a264a6030..ded912e904f0 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -1351,13 +1351,6 @@ static int allocate_receive_buffers(struct smbd_connection *info, int num_buf)
 	struct smbdirect_recv_io *response;
 	int i;
 
-	INIT_LIST_HEAD(&sc->recv_io.reassembly.list);
-	spin_lock_init(&sc->recv_io.reassembly.lock);
-	sc->recv_io.reassembly.data_length = 0;
-	sc->recv_io.reassembly.queue_length = 0;
-
-	INIT_LIST_HEAD(&sc->recv_io.free.list);
-	spin_lock_init(&sc->recv_io.free.lock);
 	info->count_receive_queue = 0;
 
 	init_waitqueue_head(&info->wait_receive_queues);
@@ -1656,14 +1649,12 @@ static struct smbd_connection *_smbd_get_connection(
 	if (!info)
 		return NULL;
 	sc = &info->socket;
+	smbdirect_socket_init(sc);
 	sp = &sc->parameters;
 
 	info->initiator_depth = 1;
 	info->responder_resources = SMBD_CM_RESPONDER_RESOURCES;
 
-	init_waitqueue_head(&sc->status_wait);
-
-	sc->status = SMBDIRECT_SOCKET_CREATED;
 	rc = smbd_ia_open(info, dstaddr, port);
 	if (rc) {
 		log_rdma_event(INFO, "smbd_ia_open rc=%d\n", rc);
@@ -1773,8 +1764,6 @@ static struct smbd_connection *_smbd_get_connection(
 	log_rdma_event(INFO, "connecting to IP %pI4 port %d\n",
 		&addr_in->sin_addr, port);
 
-	init_waitqueue_head(&sc->recv_io.reassembly.wait_queue);
-
 	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED);
 	sc->status = SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING;
 	rc = rdma_connect(sc->rdma.cm_id, &conn_param);
-- 
2.43.0

[PATCH v4 025/142] smb: client: make use of smbdirect_socket.disconnect_work

[Stefan Metzmacher]

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 12 +++++++-----
 fs/smb/client/smbdirect.h |  1 -
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index ded912e904f0..58db3e7d4de3 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -157,9 +157,8 @@ do {									\
 
 static void smbd_disconnect_rdma_work(struct work_struct *work)
 {
-	struct smbd_connection *info =
-		container_of(work, struct smbd_connection, disconnect_work);
-	struct smbdirect_socket *sc = &info->socket;
+	struct smbdirect_socket *sc =
+		container_of(work, struct smbdirect_socket, disconnect_work);
 
 	switch (sc->status) {
 	case SMBDIRECT_SOCKET_NEGOTIATE_NEEDED:
@@ -196,7 +195,9 @@ static void smbd_disconnect_rdma_work(struct work_struct *work)
 
 static void smbd_disconnect_rdma_connection(struct smbd_connection *info)
 {
-	queue_work(info->workqueue, &info->disconnect_work);
+	struct smbdirect_socket *sc = &info->socket;
+
+	queue_work(info->workqueue, &sc->disconnect_work);
 }
 
 /* Upcall from RDMA CM */
@@ -1655,6 +1656,8 @@ static struct smbd_connection *_smbd_get_connection(
 	info->initiator_depth = 1;
 	info->responder_resources = SMBD_CM_RESPONDER_RESOURCES;
 
+	INIT_WORK(&sc->disconnect_work, smbd_disconnect_rdma_work);
+
 	rc = smbd_ia_open(info, dstaddr, port);
 	if (rc) {
 		log_rdma_event(INFO, "smbd_ia_open rc=%d\n", rc);
@@ -1800,7 +1803,6 @@ static struct smbd_connection *_smbd_get_connection(
 
 	init_waitqueue_head(&info->wait_post_send);
 
-	INIT_WORK(&info->disconnect_work, smbd_disconnect_rdma_work);
 	INIT_WORK(&info->post_send_credits_work, smbd_post_send_credits);
 	info->new_credits_offered = 0;
 	spin_lock_init(&info->lock_new_credits_offered);
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index f250241d2d24..1c63188664df 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -45,7 +45,6 @@ enum keep_alive_status {
 struct smbd_connection {
 	struct smbdirect_socket socket;
 
-	struct work_struct disconnect_work;
 	struct work_struct post_send_credits_work;
 
 	spinlock_t lock_new_credits_offered;
-- 
2.43.0

[PATCH v4 026/142] smb: client: make use of smbdirect_socket.send_io.pending.{count,wait_queue}

[Stefan Metzmacher]

This will be used by the server too and will allow to create
common helper functions.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/cifs_debug.c |  2 +-
 fs/smb/client/smbdirect.c  | 25 +++++++++++--------------
 fs/smb/client/smbdirect.h  |  2 --
 3 files changed, 12 insertions(+), 17 deletions(-)

diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
index beb4f18f05ef..7df82aa49e48 100644
--- a/fs/smb/client/cifs_debug.c
+++ b/fs/smb/client/cifs_debug.c
@@ -480,7 +480,7 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
 			atomic_read(&server->smbd_conn->receive_credits),
 			server->smbd_conn->receive_credit_target);
 		seq_printf(m, "\nPending send_pending: %x ",
-			atomic_read(&server->smbd_conn->send_pending));
+			atomic_read(&sc->send_io.pending.count));
 		seq_printf(m, "\nReceive buffers count_receive_queue: %x ",
 			server->smbd_conn->count_receive_queue);
 		seq_printf(m, "\nMR responder_resources: %x "
diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 58db3e7d4de3..dd0e1d27e3aa 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -391,8 +391,8 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
 		return;
 	}
 
-	if (atomic_dec_and_test(&info->send_pending))
-		wake_up(&info->wait_send_pending);
+	if (atomic_dec_and_test(&sc->send_io.pending.count))
+		wake_up(&sc->send_io.pending.wait_queue);
 
 	wake_up(&info->wait_post_send);
 
@@ -863,14 +863,14 @@ static int smbd_post_send_negotiate_req(struct smbd_connection *info)
 		request->sge[0].addr,
 		request->sge[0].length, request->sge[0].lkey);
 
-	atomic_inc(&info->send_pending);
+	atomic_inc(&sc->send_io.pending.count);
 	rc = ib_post_send(sc->ib.qp, &send_wr, NULL);
 	if (!rc)
 		return 0;
 
 	/* if we reach here, post send failed */
 	log_rdma_send(ERR, "ib_post_send failed rc=%d\n", rc);
-	atomic_dec(&info->send_pending);
+	atomic_dec(&sc->send_io.pending.count);
 	ib_dma_unmap_single(sc->ib.dev, request->sge[0].addr,
 		request->sge[0].length, DMA_TO_DEVICE);
 
@@ -994,7 +994,7 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 
 wait_send_queue:
 	wait_event(info->wait_post_send,
-		atomic_read(&info->send_pending) < sp->send_credit_target ||
+		atomic_read(&sc->send_io.pending.count) < sp->send_credit_target ||
 		sc->status != SMBDIRECT_SOCKET_CONNECTED);
 
 	if (sc->status != SMBDIRECT_SOCKET_CONNECTED) {
@@ -1003,9 +1003,9 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 		goto err_wait_send_queue;
 	}
 
-	if (unlikely(atomic_inc_return(&info->send_pending) >
+	if (unlikely(atomic_inc_return(&sc->send_io.pending.count) >
 				sp->send_credit_target)) {
-		atomic_dec(&info->send_pending);
+		atomic_dec(&sc->send_io.pending.count);
 		goto wait_send_queue;
 	}
 
@@ -1112,8 +1112,8 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 	atomic_sub(new_credits, &info->receive_credits);
 
 err_alloc:
-	if (atomic_dec_and_test(&info->send_pending))
-		wake_up(&info->wait_send_pending);
+	if (atomic_dec_and_test(&sc->send_io.pending.count))
+		wake_up(&sc->send_io.pending.wait_queue);
 
 err_wait_send_queue:
 	/* roll back send credits and pending */
@@ -1798,9 +1798,6 @@ static struct smbd_connection *_smbd_get_connection(
 	queue_delayed_work(info->workqueue, &info->idle_timer_work,
 		msecs_to_jiffies(sp->keepalive_interval_msec));
 
-	init_waitqueue_head(&info->wait_send_pending);
-	atomic_set(&info->send_pending, 0);
-
 	init_waitqueue_head(&info->wait_post_send);
 
 	INIT_WORK(&info->post_send_credits_work, smbd_post_send_credits);
@@ -2101,8 +2098,8 @@ int smbd_send(struct TCP_Server_Info *server,
 	 * that means all the I/Os have been out and we are good to return
 	 */
 
-	wait_event(info->wait_send_pending,
-		atomic_read(&info->send_pending) == 0 ||
+	wait_event(sc->send_io.pending.wait_queue,
+		atomic_read(&sc->send_io.pending.count) == 0 ||
 		sc->status != SMBDIRECT_SOCKET_CONNECTED);
 
 	if (sc->status != SMBDIRECT_SOCKET_CONNECTED && rc == 0)
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 1c63188664df..3dbe17e8e424 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -83,8 +83,6 @@ struct smbd_connection {
 	wait_queue_head_t wait_for_mr_cleanup;
 
 	/* Activity accounting */
-	atomic_t send_pending;
-	wait_queue_head_t wait_send_pending;
 	wait_queue_head_t wait_post_send;
 
 	/* Receive queue */
-- 
2.43.0

Re: [PATCH v4 026/142] smb: client: make use of smbdirect_socket.send_io.pending.{count,wait_queue}

[Stefan Metzmacher]

Am 25.08.25 um 22:39 schrieb Stefan Metzmacher:
> This will be used by the server too and will allow to create
> common helper functions.
> 
> Cc: Steve French <smfrench@gmail.com>
> Cc: Tom Talpey <tom@talpey.com>
> Cc: Long Li <longli@microsoft.com>
> Cc: linux-cifs@vger.kernel.org
> Cc: samba-technical@lists.samba.org
> Signed-off-by: Stefan Metzmacher <metze@samba.org>
> ---
>   fs/smb/client/cifs_debug.c |  2 +-
>   fs/smb/client/smbdirect.c  | 25 +++++++++++--------------
>   fs/smb/client/smbdirect.h  |  2 --
>   3 files changed, 12 insertions(+), 17 deletions(-)
> 
> diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
> index beb4f18f05ef..7df82aa49e48 100644
> --- a/fs/smb/client/cifs_debug.c
> +++ b/fs/smb/client/cifs_debug.c
> @@ -480,7 +480,7 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
>   			atomic_read(&server->smbd_conn->receive_credits),
>   			server->smbd_conn->receive_credit_target);
>   		seq_printf(m, "\nPending send_pending: %x ",
> -			atomic_read(&server->smbd_conn->send_pending));
> +			atomic_read(&sc->send_io.pending.count));
>   		seq_printf(m, "\nReceive buffers count_receive_queue: %x ",
>   			server->smbd_conn->count_receive_queue);
>   		seq_printf(m, "\nMR responder_resources: %x "
> diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
> index 58db3e7d4de3..dd0e1d27e3aa 100644
> --- a/fs/smb/client/smbdirect.c
> +++ b/fs/smb/client/smbdirect.c
> @@ -391,8 +391,8 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
>   		return;
>   	}
>   
> -	if (atomic_dec_and_test(&info->send_pending))
> -		wake_up(&info->wait_send_pending);
> +	if (atomic_dec_and_test(&sc->send_io.pending.count))
> +		wake_up(&sc->send_io.pending.wait_queue);
>   
>   	wake_up(&info->wait_post_send);


In the rebase on "smb: server: let smb_direct_writev() respect SMB_DIRECT_MAX_SEND_SGES"
I'll change wait_send_pending to become 'pending.zero_wait_queue' that is woken when
'pending.count' reaches 0 and change wait_post_send to 'pending.dec_wait_queue'
that is woken on any decrement.

[PATCH v4 027/142] smb: client: make use of smbdirect_socket.send_io.credits.{count,wait_queue}

[Stefan Metzmacher]

This will be used by the server too and will allow to create
common helper functions.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/cifs_debug.c |  2 +-
 fs/smb/client/smbdirect.c  | 19 +++++++++----------
 fs/smb/client/smbdirect.h  |  3 ---
 3 files changed, 10 insertions(+), 14 deletions(-)

diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
index 7df82aa49e48..b80ddacd8c8f 100644
--- a/fs/smb/client/cifs_debug.c
+++ b/fs/smb/client/cifs_debug.c
@@ -476,7 +476,7 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
 			sc->recv_io.reassembly.queue_length);
 		seq_printf(m, "\nCurrent Credits send_credits: %x "
 			"receive_credits: %x receive_credit_target: %x",
-			atomic_read(&server->smbd_conn->send_credits),
+			atomic_read(&sc->send_io.credits.count),
 			atomic_read(&server->smbd_conn->receive_credits),
 			server->smbd_conn->receive_credit_target);
 		seq_printf(m, "\nPending send_pending: %x ",
diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index dd0e1d27e3aa..b9ee819aea79 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -322,7 +322,7 @@ static int smbd_conn_upcall(
 		sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
 		wake_up_all(&sc->status_wait);
 		wake_up_all(&sc->recv_io.reassembly.wait_queue);
-		wake_up_all(&info->wait_send_queue);
+		wake_up_all(&sc->send_io.credits.wait_queue);
 		break;
 
 	default:
@@ -446,7 +446,7 @@ static bool process_negotiation_response(
 		log_rdma_event(ERR, "error: credits_granted==0\n");
 		return false;
 	}
-	atomic_set(&info->send_credits, le16_to_cpu(packet->credits_granted));
+	atomic_set(&sc->send_io.credits.count, le16_to_cpu(packet->credits_granted));
 
 	atomic_set(&info->receive_credits, 0);
 
@@ -606,12 +606,12 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			le16_to_cpu(data_transfer->credits_requested);
 		if (le16_to_cpu(data_transfer->credits_granted)) {
 			atomic_add(le16_to_cpu(data_transfer->credits_granted),
-				&info->send_credits);
+				&sc->send_io.credits.count);
 			/*
 			 * We have new send credits granted from remote peer
 			 * If any sender is waiting for credits, unblock it
 			 */
-			wake_up(&info->wait_send_queue);
+			wake_up(&sc->send_io.credits.wait_queue);
 		}
 
 		log_incoming(INFO, "data flags %d data_offset %d data_length %d remaining_data_length %d\n",
@@ -976,8 +976,8 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 
 wait_credit:
 	/* Wait for send credits. A SMBD packet needs one credit */
-	rc = wait_event_interruptible(info->wait_send_queue,
-		atomic_read(&info->send_credits) > 0 ||
+	rc = wait_event_interruptible(sc->send_io.credits.wait_queue,
+		atomic_read(&sc->send_io.credits.count) > 0 ||
 		sc->status != SMBDIRECT_SOCKET_CONNECTED);
 	if (rc)
 		goto err_wait_credit;
@@ -987,8 +987,8 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 		rc = -EAGAIN;
 		goto err_wait_credit;
 	}
-	if (unlikely(atomic_dec_return(&info->send_credits) < 0)) {
-		atomic_inc(&info->send_credits);
+	if (unlikely(atomic_dec_return(&sc->send_io.credits.count) < 0)) {
+		atomic_inc(&sc->send_io.credits.count);
 		goto wait_credit;
 	}
 
@@ -1117,7 +1117,7 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 
 err_wait_send_queue:
 	/* roll back send credits and pending */
-	atomic_inc(&info->send_credits);
+	atomic_inc(&sc->send_io.credits.count);
 
 err_wait_credit:
 	return rc;
@@ -1793,7 +1793,6 @@ static struct smbd_connection *_smbd_get_connection(
 		goto allocate_cache_failed;
 	}
 
-	init_waitqueue_head(&info->wait_send_queue);
 	INIT_DELAYED_WORK(&info->idle_timer_work, idle_connection_timer);
 	queue_delayed_work(info->workqueue, &info->idle_timer_work,
 		msecs_to_jiffies(sp->keepalive_interval_msec));
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 3dbe17e8e424..1c4e03491964 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -53,7 +53,6 @@ struct smbd_connection {
 	/* dynamic connection parameters defined in [MS-SMBD] 3.1.1.1 */
 	enum keep_alive_status keep_alive_requested;
 	int protocol;
-	atomic_t send_credits;
 	atomic_t receive_credits;
 	int receive_credit_target;
 
@@ -91,8 +90,6 @@ struct smbd_connection {
 
 	bool send_immediate;
 
-	wait_queue_head_t wait_send_queue;
-
 	struct workqueue_struct *workqueue;
 	struct delayed_work idle_timer_work;
 
-- 
2.43.0

[PATCH v4 028/142] smb: client: make sure smbd_disconnect_rdma_work() doesn't run after smbd_destroy() took over

[Stefan Metzmacher]

If we're already disconnecting we don't need to queue the
disconnect_work again. disable_work() turns the next queue_work()
into a no-op.

Also let smbd_destroy() cancel(and disable) queued disconnect_work and
call smbd_disconnect_rdma_work() inline.

The makes it more obvious that disconnect_work is never queued
again after smbd_destroy() called smbd_disconnect_rdma_work().

It also means we have a single place to call rdma_disconnect().

While there we better also disable all other [delayed_]work.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 21 +++++++++++++++++++--
 1 file changed, 19 insertions(+), 2 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index b9ee819aea79..eab8433a518c 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -159,6 +159,18 @@ static void smbd_disconnect_rdma_work(struct work_struct *work)
 {
 	struct smbdirect_socket *sc =
 		container_of(work, struct smbdirect_socket, disconnect_work);
+	struct smbd_connection *info =
+		container_of(sc, struct smbd_connection, socket);
+
+	/*
+	 * make sure this and other work is not queued again
+	 * but here we don't block and avoid
+	 * disable[_delayed]_work_ync()
+	 */
+	disable_work(&sc->disconnect_work);
+	disable_work(&info->post_send_credits_work);
+	disable_work(&info->mr_recovery_work);
+	disable_delayed_work(&info->idle_timer_work);
 
 	switch (sc->status) {
 	case SMBDIRECT_SOCKET_NEGOTIATE_NEEDED:
@@ -315,11 +327,13 @@ static int smbd_conn_upcall(
 		if (sc->status == SMBDIRECT_SOCKET_NEGOTIATE_FAILED) {
 			log_rdma_event(ERR, "event=%s during negotiation\n", event_name);
 			sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
+			smbd_disconnect_rdma_work(&sc->disconnect_work);
 			wake_up_all(&sc->status_wait);
 			break;
 		}
 
 		sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
+		smbd_disconnect_rdma_work(&sc->disconnect_work);
 		wake_up_all(&sc->status_wait);
 		wake_up_all(&sc->recv_io.reassembly.wait_queue);
 		wake_up_all(&sc->send_io.credits.wait_queue);
@@ -1436,9 +1450,12 @@ void smbd_destroy(struct TCP_Server_Info *server)
 	sc = &info->socket;
 	sp = &sc->parameters;
 
+	log_rdma_event(INFO, "cancelling and disable disconnect_work\n");
+	disable_work_sync(&sc->disconnect_work);
+
 	log_rdma_event(INFO, "destroying rdma session\n");
-	if (sc->status != SMBDIRECT_SOCKET_DISCONNECTED) {
-		rdma_disconnect(sc->rdma.cm_id);
+	if (sc->status < SMBDIRECT_SOCKET_DISCONNECTING) {
+		smbd_disconnect_rdma_work(&sc->disconnect_work);
 		log_rdma_event(INFO, "wait for transport being disconnected\n");
 		wait_event_interruptible(
 			sc->status_wait,
-- 
2.43.0

[PATCH v4 029/142] smb: client: use disable[_delayed]_work_sync in smbdirect.c

[Stefan Metzmacher]

This makes it safer during the disconnect and avoids
requeueing.

It's ok to call disable[delayed_]work[_sync]() more than once.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index eab8433a518c..d36556fab357 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -1468,7 +1468,7 @@ void smbd_destroy(struct TCP_Server_Info *server)
 	sc->ib.qp = NULL;
 
 	log_rdma_event(INFO, "cancelling idle timer\n");
-	cancel_delayed_work_sync(&info->idle_timer_work);
+	disable_delayed_work_sync(&info->idle_timer_work);
 
 	/* It's not possible for upper layer to get to reassembly */
 	log_rdma_event(INFO, "drain the reassembly queue\n");
@@ -1841,7 +1841,7 @@ static struct smbd_connection *_smbd_get_connection(
 	return NULL;
 
 negotiation_failed:
-	cancel_delayed_work_sync(&info->idle_timer_work);
+	disable_delayed_work_sync(&info->idle_timer_work);
 	destroy_caches_and_workqueue(info);
 	sc->status = SMBDIRECT_SOCKET_NEGOTIATE_FAILED;
 	rdma_disconnect(sc->rdma.cm_id);
@@ -2200,7 +2200,7 @@ static void destroy_mr_list(struct smbd_connection *info)
 	struct smbdirect_socket *sc = &info->socket;
 	struct smbd_mr *mr, *tmp;
 
-	cancel_work_sync(&info->mr_recovery_work);
+	disable_work_sync(&info->mr_recovery_work);
 	list_for_each_entry_safe(mr, tmp, &info->mr_list, list) {
 		if (mr->state == MR_INVALIDATED)
 			ib_dma_unmap_sg(sc->ib.dev, mr->sgt.sgl,
-- 
2.43.0

[PATCH v4 030/142] smb: client: let smbd_destroy() call disable_work_sync(&info->post_send_credits_work)

[Stefan Metzmacher]

We already called disable_work(&info->post_send_credits_work) in
smbd_disconnect_rdma_work().

But in smbd_destroy() we may destroy the memory so we better
wait until post_send_credits_work is no longer pending.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index d36556fab357..a61c7d2afbdf 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -1462,6 +1462,9 @@ void smbd_destroy(struct TCP_Server_Info *server)
 			sc->status == SMBDIRECT_SOCKET_DISCONNECTED);
 	}
 
+	log_rdma_event(INFO, "cancelling post_send_credits_work\n");
+	disable_work_sync(&info->post_send_credits_work);
+
 	log_rdma_event(INFO, "destroying qp\n");
 	ib_drain_qp(sc->ib.qp);
 	rdma_destroy_qp(sc->rdma.cm_id);
-- 
2.43.0

[PATCH v4 031/142] smb: client: queue post_recv_credits_work also if the peer raises the credit target

[Stefan Metzmacher]

This is already handled in the server, but currently it done
in a very complex way there. So we do it much simpler.

Note that put_receive_buffer() will take care of it
in case data_length is 0.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index a61c7d2afbdf..40aafc606ac8 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -562,6 +562,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	struct smbdirect_socket *sc = response->socket;
 	struct smbd_connection *info =
 		container_of(sc, struct smbd_connection, socket);
+	int old_recv_credit_target;
 	int data_length = 0;
 	bool negotiate_done = false;
 
@@ -616,6 +617,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		}
 
 		atomic_dec(&info->receive_credits);
+		old_recv_credit_target = info->receive_credit_target;
 		info->receive_credit_target =
 			le16_to_cpu(data_transfer->credits_requested);
 		if (le16_to_cpu(data_transfer->credits_granted)) {
@@ -646,6 +648,9 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		 * reassembly queue and wake up the reading thread
 		 */
 		if (data_length) {
+			if (info->receive_credit_target > old_recv_credit_target)
+				queue_work(info->workqueue, &info->post_send_credits_work);
+
 			enqueue_reassembly(info, response, data_length);
 			wake_up(&sc->recv_io.reassembly.wait_queue);
 		} else
-- 
2.43.0

[PATCH v4 032/142] smb: client: make use of ib_wc_status_msg() and skip IB_WC_WR_FLUSH_ERR logging

[Stefan Metzmacher]

There's no need to get log message for every IB_WC_WR_FLUSH_ERR
completion, but any other error should be logged at level ERR.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 20 ++++++++++++--------
 1 file changed, 12 insertions(+), 8 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 40aafc606ac8..ec3ebf6e3c88 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -388,8 +388,8 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
 	struct smbd_connection *info =
 		container_of(sc, struct smbd_connection, socket);
 
-	log_rdma_send(INFO, "smbdirect_send_io 0x%p completed wc->status=%d\n",
-		request, wc->status);
+	log_rdma_send(INFO, "smbdirect_send_io 0x%p completed wc->status=%s\n",
+		request, ib_wc_status_msg(wc->status));
 
 	for (i = 0; i < request->num_sge; i++)
 		ib_dma_unmap_single(sc->ib.dev,
@@ -398,8 +398,9 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
 			DMA_TO_DEVICE);
 
 	if (wc->status != IB_WC_SUCCESS || wc->opcode != IB_WC_SEND) {
-		log_rdma_send(ERR, "wc->status=%d wc->opcode=%d\n",
-			wc->status, wc->opcode);
+		if (wc->status != IB_WC_WR_FLUSH_ERR)
+			log_rdma_send(ERR, "wc->status=%s wc->opcode=%d\n",
+				ib_wc_status_msg(wc->status), wc->opcode);
 		mempool_free(request, sc->send_io.mem.pool);
 		smbd_disconnect_rdma_connection(info);
 		return;
@@ -566,13 +567,16 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	int data_length = 0;
 	bool negotiate_done = false;
 
-	log_rdma_recv(INFO, "response=0x%p type=%d wc status=%d wc opcode %d byte_len=%d pkey_index=%u\n",
-		      response, sc->recv_io.expected, wc->status, wc->opcode,
+	log_rdma_recv(INFO,
+		      "response=0x%p type=%d wc status=%s wc opcode %d byte_len=%d pkey_index=%u\n",
+		      response, sc->recv_io.expected,
+		      ib_wc_status_msg(wc->status), wc->opcode,
 		      wc->byte_len, wc->pkey_index);
 
 	if (wc->status != IB_WC_SUCCESS || wc->opcode != IB_WC_RECV) {
-		log_rdma_recv(INFO, "wc->status=%d opcode=%d\n",
-			wc->status, wc->opcode);
+		if (wc->status != IB_WC_WR_FLUSH_ERR)
+			log_rdma_recv(ERR, "wc->status=%s opcode=%d\n",
+				ib_wc_status_msg(wc->status), wc->opcode);
 		goto error;
 	}
 
-- 
2.43.0

[PATCH v4 033/142] smb: client: remove info->wait_receive_queues handling in smbd_destroy()

[Stefan Metzmacher]

We already call ib_drain_qp() before, which is an sync operation
that only returns in the queues are fully drained.

ib_drain_qp() completes pending requests with IB_WC_WR_FLUSH_ERR
so we have already called put_receive_buffer().

So all smbdirect_recv_io objects are either in the
smbdirect_socket.recv_io.free.list or
smbdirect_socket.recv_io.reassembly.list.

Then we explicitly iterate smbdirect_socket.recv_io.reassembly.list
and call put_receive_buffer(), so every object is
in smbdirect_socket.recv_io.free.list.

It means info->count_receive_queue == sp->recv_credit_max was
already true and calling wait_event(info->wait_receive_queues...
is pointless.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/cifs_debug.c |  2 --
 fs/smb/client/smbdirect.c  | 13 -------------
 fs/smb/client/smbdirect.h  |  4 ----
 3 files changed, 19 deletions(-)

diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
index b80ddacd8c8f..3717a0081847 100644
--- a/fs/smb/client/cifs_debug.c
+++ b/fs/smb/client/cifs_debug.c
@@ -481,8 +481,6 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
 			server->smbd_conn->receive_credit_target);
 		seq_printf(m, "\nPending send_pending: %x ",
 			atomic_read(&sc->send_io.pending.count));
-		seq_printf(m, "\nReceive buffers count_receive_queue: %x ",
-			server->smbd_conn->count_receive_queue);
 		seq_printf(m, "\nMR responder_resources: %x "
 			"max_frmr_depth: %x mr_type: %x",
 			server->smbd_conn->responder_resources,
diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index ec3ebf6e3c88..b1ecfdbbc67d 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -514,7 +514,6 @@ static void smbd_post_send_credits(struct work_struct *work)
 	struct smbdirect_socket *sc = &info->socket;
 
 	if (sc->status != SMBDIRECT_SOCKET_CONNECTED) {
-		wake_up_all(&info->wait_receive_queues);
 		return;
 	}
 
@@ -1331,7 +1330,6 @@ static struct smbdirect_recv_io *get_receive_buffer(struct smbd_connection *info
 			&sc->recv_io.free.list,
 			struct smbdirect_recv_io, list);
 		list_del(&ret->list);
-		info->count_receive_queue--;
 		info->count_get_receive_buffer++;
 	}
 	spin_unlock_irqrestore(&sc->recv_io.free.lock, flags);
@@ -1361,7 +1359,6 @@ static void put_receive_buffer(
 
 	spin_lock_irqsave(&sc->recv_io.free.lock, flags);
 	list_add_tail(&response->list, &sc->recv_io.free.list);
-	info->count_receive_queue++;
 	info->count_put_receive_buffer++;
 	spin_unlock_irqrestore(&sc->recv_io.free.lock, flags);
 
@@ -1375,10 +1372,6 @@ static int allocate_receive_buffers(struct smbd_connection *info, int num_buf)
 	struct smbdirect_recv_io *response;
 	int i;
 
-	info->count_receive_queue = 0;
-
-	init_waitqueue_head(&info->wait_receive_queues);
-
 	for (i = 0; i < num_buf; i++) {
 		response = mempool_alloc(sc->recv_io.mem.pool, GFP_KERNEL);
 		if (!response)
@@ -1387,7 +1380,6 @@ static int allocate_receive_buffers(struct smbd_connection *info, int num_buf)
 		response->socket = sc;
 		response->sge.length = 0;
 		list_add_tail(&response->list, &sc->recv_io.free.list);
-		info->count_receive_queue++;
 	}
 
 	return 0;
@@ -1398,7 +1390,6 @@ static int allocate_receive_buffers(struct smbd_connection *info, int num_buf)
 				&sc->recv_io.free.list,
 				struct smbdirect_recv_io, list);
 		list_del(&response->list);
-		info->count_receive_queue--;
 
 		mempool_free(response, sc->recv_io.mem.pool);
 	}
@@ -1448,7 +1439,6 @@ void smbd_destroy(struct TCP_Server_Info *server)
 {
 	struct smbd_connection *info = server->smbd_conn;
 	struct smbdirect_socket *sc;
-	struct smbdirect_socket_parameters *sp;
 	struct smbdirect_recv_io *response;
 	unsigned long flags;
 
@@ -1457,7 +1447,6 @@ void smbd_destroy(struct TCP_Server_Info *server)
 		return;
 	}
 	sc = &info->socket;
-	sp = &sc->parameters;
 
 	log_rdma_event(INFO, "cancelling and disable disconnect_work\n");
 	disable_work_sync(&sc->disconnect_work);
@@ -1499,8 +1488,6 @@ void smbd_destroy(struct TCP_Server_Info *server)
 	sc->recv_io.reassembly.data_length = 0;
 
 	log_rdma_event(INFO, "free receive buffers\n");
-	wait_event(info->wait_receive_queues,
-		info->count_receive_queue == sp->recv_credit_max);
 	destroy_receive_buffers(info);
 
 	/*
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 1c4e03491964..693876f2d836 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -84,10 +84,6 @@ struct smbd_connection {
 	/* Activity accounting */
 	wait_queue_head_t wait_post_send;
 
-	/* Receive queue */
-	int count_receive_queue;
-	wait_queue_head_t wait_receive_queues;
-
 	bool send_immediate;
 
 	struct workqueue_struct *workqueue;
-- 
2.43.0

[PATCH v4 034/142] smb: client: limit the range of info->receive_credit_target

[Stefan Metzmacher]

This simplifies further changes...

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 8 +++++++-
 fs/smb/client/smbdirect.h | 2 +-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index b1ecfdbbc67d..e567fdc6e223 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -456,6 +456,7 @@ static bool process_negotiation_response(
 		return false;
 	}
 	info->receive_credit_target = le16_to_cpu(packet->credits_requested);
+	info->receive_credit_target = min_t(u16, info->receive_credit_target, sp->recv_credit_max);
 
 	if (packet->credits_granted == 0) {
 		log_rdma_event(ERR, "error: credits_granted==0\n");
@@ -560,9 +561,10 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	struct smbdirect_recv_io *response =
 		container_of(wc->wr_cqe, struct smbdirect_recv_io, cqe);
 	struct smbdirect_socket *sc = response->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct smbd_connection *info =
 		container_of(sc, struct smbd_connection, socket);
-	int old_recv_credit_target;
+	u16 old_recv_credit_target;
 	int data_length = 0;
 	bool negotiate_done = false;
 
@@ -623,6 +625,10 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		old_recv_credit_target = info->receive_credit_target;
 		info->receive_credit_target =
 			le16_to_cpu(data_transfer->credits_requested);
+		info->receive_credit_target =
+			min_t(u16, info->receive_credit_target, sp->recv_credit_max);
+		info->receive_credit_target =
+			max_t(u16, info->receive_credit_target, 1);
 		if (le16_to_cpu(data_transfer->credits_granted)) {
 			atomic_add(le16_to_cpu(data_transfer->credits_granted),
 				&sc->send_io.credits.count);
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 693876f2d836..6f18e4742502 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -54,7 +54,7 @@ struct smbd_connection {
 	enum keep_alive_status keep_alive_requested;
 	int protocol;
 	atomic_t receive_credits;
-	int receive_credit_target;
+	u16 receive_credit_target;
 
 	/* Memory registrations */
 	/* Maximum number of RDMA read/write outstanding on this connection */
-- 
2.43.0

[PATCH v4 035/142] smb: client: count the number of posted recv_io messages in order to calculated credits

[Stefan Metzmacher]

(At least for me) the logic maintaining the count of posted
recv_io messages and the count of granted credits is much easier
to understand.

From there we can easily calculate the number of new_credits we'll
grant to the peer in outgoing send_io messages.

This will simplify the move to common logic that can be
shared between client and server in the following patches.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 30 ++++++++++++++----------------
 fs/smb/client/smbdirect.h |  4 +---
 2 files changed, 15 insertions(+), 19 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index e567fdc6e223..d68d95d1ef37 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -465,6 +465,7 @@ static bool process_negotiation_response(
 	atomic_set(&sc->send_io.credits.count, le16_to_cpu(packet->credits_granted));
 
 	atomic_set(&info->receive_credits, 0);
+	atomic_set(&info->receive_posted, 0);
 
 	if (le32_to_cpu(packet->preferred_send_size) > sp->max_recv_size) {
 		log_rdma_event(ERR, "error: preferred_send_size=%d\n",
@@ -506,7 +507,6 @@ static bool process_negotiation_response(
 
 static void smbd_post_send_credits(struct work_struct *work)
 {
-	int ret = 0;
 	int rc;
 	struct smbdirect_recv_io *response;
 	struct smbd_connection *info =
@@ -534,14 +534,10 @@ static void smbd_post_send_credits(struct work_struct *work)
 				break;
 			}
 
-			ret++;
+			atomic_inc(&info->receive_posted);
 		}
 	}
 
-	spin_lock(&info->lock_new_credits_offered);
-	info->new_credits_offered += ret;
-	spin_unlock(&info->lock_new_credits_offered);
-
 	/* Promptly send an immediate packet as defined in [MS-SMBD] 3.1.1.1 */
 	info->send_immediate = true;
 	if (atomic_read(&info->receive_credits) <
@@ -621,6 +617,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 				sc->recv_io.reassembly.full_packet_received = true;
 		}
 
+		atomic_dec(&info->receive_posted);
 		atomic_dec(&info->receive_credits);
 		old_recv_credit_target = info->receive_credit_target;
 		info->receive_credit_target =
@@ -921,10 +918,16 @@ static int manage_credits_prior_sending(struct smbd_connection *info)
 {
 	int new_credits;
 
-	spin_lock(&info->lock_new_credits_offered);
-	new_credits = info->new_credits_offered;
-	info->new_credits_offered = 0;
-	spin_unlock(&info->lock_new_credits_offered);
+	if (atomic_read(&info->receive_credits) >= info->receive_credit_target)
+		return 0;
+
+	new_credits = atomic_read(&info->receive_posted);
+	if (new_credits == 0)
+		return 0;
+
+	new_credits -= atomic_read(&info->receive_credits);
+	if (new_credits <= 0)
+		return 0;
 
 	return new_credits;
 }
@@ -1133,10 +1136,7 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 					    DMA_TO_DEVICE);
 	mempool_free(request, sc->send_io.mem.pool);
 
-	/* roll back receive credits and credits to be offered */
-	spin_lock(&info->lock_new_credits_offered);
-	info->new_credits_offered += new_credits;
-	spin_unlock(&info->lock_new_credits_offered);
+	/* roll back the granted receive credits */
 	atomic_sub(new_credits, &info->receive_credits);
 
 err_alloc:
@@ -1822,8 +1822,6 @@ static struct smbd_connection *_smbd_get_connection(
 	init_waitqueue_head(&info->wait_post_send);
 
 	INIT_WORK(&info->post_send_credits_work, smbd_post_send_credits);
-	info->new_credits_offered = 0;
-	spin_lock_init(&info->lock_new_credits_offered);
 
 	rc = smbd_negotiate(info);
 	if (rc) {
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 6f18e4742502..b5eeea4ddcf1 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -46,9 +46,7 @@ struct smbd_connection {
 	struct smbdirect_socket socket;
 
 	struct work_struct post_send_credits_work;
-
-	spinlock_t lock_new_credits_offered;
-	int new_credits_offered;
+	atomic_t receive_posted;
 
 	/* dynamic connection parameters defined in [MS-SMBD] 3.1.1.1 */
 	enum keep_alive_status keep_alive_requested;
-- 
2.43.0

[PATCH v4 036/142] smb: client: make use of smbdirect_socket.recv_io.{posted,credits}

[Stefan Metzmacher]

This will make it possible to introduce common helper functions
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/cifs_debug.c |  4 +--
 fs/smb/client/smbdirect.c  | 64 ++++++++++++++++++--------------------
 fs/smb/client/smbdirect.h  |  5 ---
 3 files changed, 33 insertions(+), 40 deletions(-)

diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
index 3717a0081847..e8faa5726b1c 100644
--- a/fs/smb/client/cifs_debug.c
+++ b/fs/smb/client/cifs_debug.c
@@ -477,8 +477,8 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
 		seq_printf(m, "\nCurrent Credits send_credits: %x "
 			"receive_credits: %x receive_credit_target: %x",
 			atomic_read(&sc->send_io.credits.count),
-			atomic_read(&server->smbd_conn->receive_credits),
-			server->smbd_conn->receive_credit_target);
+			atomic_read(&sc->recv_io.credits.count),
+			sc->recv_io.credits.target);
 		seq_printf(m, "\nPending send_pending: %x ",
 			atomic_read(&sc->send_io.pending.count));
 		seq_printf(m, "\nMR responder_resources: %x "
diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index d68d95d1ef37..62c0d27ec8bc 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -168,7 +168,7 @@ static void smbd_disconnect_rdma_work(struct work_struct *work)
 	 * disable[_delayed]_work_ync()
 	 */
 	disable_work(&sc->disconnect_work);
-	disable_work(&info->post_send_credits_work);
+	disable_work(&sc->recv_io.posted.refill_work);
 	disable_work(&info->mr_recovery_work);
 	disable_delayed_work(&info->idle_timer_work);
 
@@ -455,8 +455,8 @@ static bool process_negotiation_response(
 		log_rdma_event(ERR, "error: credits_requested==0\n");
 		return false;
 	}
-	info->receive_credit_target = le16_to_cpu(packet->credits_requested);
-	info->receive_credit_target = min_t(u16, info->receive_credit_target, sp->recv_credit_max);
+	sc->recv_io.credits.target = le16_to_cpu(packet->credits_requested);
+	sc->recv_io.credits.target = min_t(u16, sc->recv_io.credits.target, sp->recv_credit_max);
 
 	if (packet->credits_granted == 0) {
 		log_rdma_event(ERR, "error: credits_granted==0\n");
@@ -464,9 +464,6 @@ static bool process_negotiation_response(
 	}
 	atomic_set(&sc->send_io.credits.count, le16_to_cpu(packet->credits_granted));
 
-	atomic_set(&info->receive_credits, 0);
-	atomic_set(&info->receive_posted, 0);
-
 	if (le32_to_cpu(packet->preferred_send_size) > sp->max_recv_size) {
 		log_rdma_event(ERR, "error: preferred_send_size=%d\n",
 			le32_to_cpu(packet->preferred_send_size));
@@ -509,17 +506,17 @@ static void smbd_post_send_credits(struct work_struct *work)
 {
 	int rc;
 	struct smbdirect_recv_io *response;
+	struct smbdirect_socket *sc =
+		container_of(work, struct smbdirect_socket, recv_io.posted.refill_work);
 	struct smbd_connection *info =
-		container_of(work, struct smbd_connection,
-			post_send_credits_work);
-	struct smbdirect_socket *sc = &info->socket;
+		container_of(sc, struct smbd_connection, socket);
 
 	if (sc->status != SMBDIRECT_SOCKET_CONNECTED) {
 		return;
 	}
 
-	if (info->receive_credit_target >
-		atomic_read(&info->receive_credits)) {
+	if (sc->recv_io.credits.target >
+		atomic_read(&sc->recv_io.credits.count)) {
 		while (true) {
 			response = get_receive_buffer(info);
 			if (!response)
@@ -534,14 +531,14 @@ static void smbd_post_send_credits(struct work_struct *work)
 				break;
 			}
 
-			atomic_inc(&info->receive_posted);
+			atomic_inc(&sc->recv_io.posted.count);
 		}
 	}
 
 	/* Promptly send an immediate packet as defined in [MS-SMBD] 3.1.1.1 */
 	info->send_immediate = true;
-	if (atomic_read(&info->receive_credits) <
-		info->receive_credit_target - 1) {
+	if (atomic_read(&sc->recv_io.credits.count) <
+		sc->recv_io.credits.target - 1) {
 		if (info->keep_alive_requested == KEEP_ALIVE_PENDING ||
 		    info->send_immediate) {
 			log_keep_alive(INFO, "send an empty message\n");
@@ -617,15 +614,15 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 				sc->recv_io.reassembly.full_packet_received = true;
 		}
 
-		atomic_dec(&info->receive_posted);
-		atomic_dec(&info->receive_credits);
-		old_recv_credit_target = info->receive_credit_target;
-		info->receive_credit_target =
+		atomic_dec(&sc->recv_io.posted.count);
+		atomic_dec(&sc->recv_io.credits.count);
+		old_recv_credit_target = sc->recv_io.credits.target;
+		sc->recv_io.credits.target =
 			le16_to_cpu(data_transfer->credits_requested);
-		info->receive_credit_target =
-			min_t(u16, info->receive_credit_target, sp->recv_credit_max);
-		info->receive_credit_target =
-			max_t(u16, info->receive_credit_target, 1);
+		sc->recv_io.credits.target =
+			min_t(u16, sc->recv_io.credits.target, sp->recv_credit_max);
+		sc->recv_io.credits.target =
+			max_t(u16, sc->recv_io.credits.target, 1);
 		if (le16_to_cpu(data_transfer->credits_granted)) {
 			atomic_add(le16_to_cpu(data_transfer->credits_granted),
 				&sc->send_io.credits.count);
@@ -654,8 +651,8 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		 * reassembly queue and wake up the reading thread
 		 */
 		if (data_length) {
-			if (info->receive_credit_target > old_recv_credit_target)
-				queue_work(info->workqueue, &info->post_send_credits_work);
+			if (sc->recv_io.credits.target > old_recv_credit_target)
+				queue_work(info->workqueue, &sc->recv_io.posted.refill_work);
 
 			enqueue_reassembly(info, response, data_length);
 			wake_up(&sc->recv_io.reassembly.wait_queue);
@@ -916,16 +913,17 @@ static int smbd_post_send_negotiate_req(struct smbd_connection *info)
  */
 static int manage_credits_prior_sending(struct smbd_connection *info)
 {
+	struct smbdirect_socket *sc = &info->socket;
 	int new_credits;
 
-	if (atomic_read(&info->receive_credits) >= info->receive_credit_target)
+	if (atomic_read(&sc->recv_io.credits.count) >= sc->recv_io.credits.target)
 		return 0;
 
-	new_credits = atomic_read(&info->receive_posted);
+	new_credits = atomic_read(&sc->recv_io.posted.count);
 	if (new_credits == 0)
 		return 0;
 
-	new_credits -= atomic_read(&info->receive_credits);
+	new_credits -= atomic_read(&sc->recv_io.credits.count);
 	if (new_credits <= 0)
 		return 0;
 
@@ -1079,7 +1077,7 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 	packet->credits_requested = cpu_to_le16(sp->send_credit_target);
 
 	new_credits = manage_credits_prior_sending(info);
-	atomic_add(new_credits, &info->receive_credits);
+	atomic_add(new_credits, &sc->recv_io.credits.count);
 	packet->credits_granted = cpu_to_le16(new_credits);
 
 	info->send_immediate = false;
@@ -1137,7 +1135,7 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 	mempool_free(request, sc->send_io.mem.pool);
 
 	/* roll back the granted receive credits */
-	atomic_sub(new_credits, &info->receive_credits);
+	atomic_sub(new_credits, &sc->recv_io.credits.count);
 
 err_alloc:
 	if (atomic_dec_and_test(&sc->send_io.pending.count))
@@ -1368,7 +1366,7 @@ static void put_receive_buffer(
 	info->count_put_receive_buffer++;
 	spin_unlock_irqrestore(&sc->recv_io.free.lock, flags);
 
-	queue_work(info->workqueue, &info->post_send_credits_work);
+	queue_work(info->workqueue, &sc->recv_io.posted.refill_work);
 }
 
 /* Preallocate all receive buffer on transport establishment */
@@ -1466,8 +1464,8 @@ void smbd_destroy(struct TCP_Server_Info *server)
 			sc->status == SMBDIRECT_SOCKET_DISCONNECTED);
 	}
 
-	log_rdma_event(INFO, "cancelling post_send_credits_work\n");
-	disable_work_sync(&info->post_send_credits_work);
+	log_rdma_event(INFO, "cancelling recv_io.posted.refill_work\n");
+	disable_work_sync(&sc->recv_io.posted.refill_work);
 
 	log_rdma_event(INFO, "destroying qp\n");
 	ib_drain_qp(sc->ib.qp);
@@ -1821,7 +1819,7 @@ static struct smbd_connection *_smbd_get_connection(
 
 	init_waitqueue_head(&info->wait_post_send);
 
-	INIT_WORK(&info->post_send_credits_work, smbd_post_send_credits);
+	INIT_WORK(&sc->recv_io.posted.refill_work, smbd_post_send_credits);
 
 	rc = smbd_negotiate(info);
 	if (rc) {
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index b5eeea4ddcf1..a4b368d14f51 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -45,14 +45,9 @@ enum keep_alive_status {
 struct smbd_connection {
 	struct smbdirect_socket socket;
 
-	struct work_struct post_send_credits_work;
-	atomic_t receive_posted;
-
 	/* dynamic connection parameters defined in [MS-SMBD] 3.1.1.1 */
 	enum keep_alive_status keep_alive_requested;
 	int protocol;
-	atomic_t receive_credits;
-	u16 receive_credit_target;
 
 	/* Memory registrations */
 	/* Maximum number of RDMA read/write outstanding on this connection */
-- 
2.43.0

[PATCH v4 037/142] smb: client: remove useless smbd_connection.send_immediate

[Stefan Metzmacher]

We always set it to true before having an if statement that checks it is
true...

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 10 ++--------
 fs/smb/client/smbdirect.h |  2 --
 2 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 62c0d27ec8bc..a65c3a841985 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -536,14 +536,10 @@ static void smbd_post_send_credits(struct work_struct *work)
 	}
 
 	/* Promptly send an immediate packet as defined in [MS-SMBD] 3.1.1.1 */
-	info->send_immediate = true;
 	if (atomic_read(&sc->recv_io.credits.count) <
 		sc->recv_io.credits.target - 1) {
-		if (info->keep_alive_requested == KEEP_ALIVE_PENDING ||
-		    info->send_immediate) {
-			log_keep_alive(INFO, "send an empty message\n");
-			smbd_post_send_empty(info);
-		}
+		log_keep_alive(INFO, "send an empty message\n");
+		smbd_post_send_empty(info);
 	}
 }
 
@@ -1080,8 +1076,6 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 	atomic_add(new_credits, &sc->recv_io.credits.count);
 	packet->credits_granted = cpu_to_le16(new_credits);
 
-	info->send_immediate = false;
-
 	packet->flags = 0;
 	if (manage_keep_alive_before_sending(info))
 		packet->flags |= cpu_to_le16(SMBDIRECT_FLAG_RESPONSE_REQUESTED);
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index a4b368d14f51..3dd7408329f5 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -77,8 +77,6 @@ struct smbd_connection {
 	/* Activity accounting */
 	wait_queue_head_t wait_post_send;
 
-	bool send_immediate;
-
 	struct workqueue_struct *workqueue;
 	struct delayed_work idle_timer_work;
 
-- 
2.43.0

[PATCH v4 038/142] smb: client: fill smbdirect_socket_parameters at the beginning and use the values from there

[Stefan Metzmacher]

This is what we should do and it also simplifies the following changes.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index a65c3a841985..a1ca18dbb758 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -1672,37 +1672,37 @@ static struct smbd_connection *_smbd_get_connection(
 
 	INIT_WORK(&sc->disconnect_work, smbd_disconnect_rdma_work);
 
+	sp->recv_credit_max = smbd_receive_credit_max;
+	sp->send_credit_target = smbd_send_credit_target;
+	sp->max_send_size = smbd_max_send_size;
+	sp->max_fragmented_recv_size = smbd_max_fragmented_recv_size;
+	sp->max_recv_size = smbd_max_receive_size;
+	sp->keepalive_interval_msec = smbd_keep_alive_interval * 1000;
+
 	rc = smbd_ia_open(info, dstaddr, port);
 	if (rc) {
 		log_rdma_event(INFO, "smbd_ia_open rc=%d\n", rc);
 		goto create_id_failed;
 	}
 
-	if (smbd_send_credit_target > sc->ib.dev->attrs.max_cqe ||
-	    smbd_send_credit_target > sc->ib.dev->attrs.max_qp_wr) {
+	if (sp->send_credit_target > sc->ib.dev->attrs.max_cqe ||
+	    sp->send_credit_target > sc->ib.dev->attrs.max_qp_wr) {
 		log_rdma_event(ERR, "consider lowering send_credit_target = %d. Possible CQE overrun, device reporting max_cqe %d max_qp_wr %d\n",
-			       smbd_send_credit_target,
+			       sp->send_credit_target,
 			       sc->ib.dev->attrs.max_cqe,
 			       sc->ib.dev->attrs.max_qp_wr);
 		goto config_failed;
 	}
 
-	if (smbd_receive_credit_max > sc->ib.dev->attrs.max_cqe ||
-	    smbd_receive_credit_max > sc->ib.dev->attrs.max_qp_wr) {
+	if (sp->recv_credit_max > sc->ib.dev->attrs.max_cqe ||
+	    sp->recv_credit_max > sc->ib.dev->attrs.max_qp_wr) {
 		log_rdma_event(ERR, "consider lowering receive_credit_max = %d. Possible CQE overrun, device reporting max_cqe %d max_qp_wr %d\n",
-			       smbd_receive_credit_max,
+			       sp->recv_credit_max,
 			       sc->ib.dev->attrs.max_cqe,
 			       sc->ib.dev->attrs.max_qp_wr);
 		goto config_failed;
 	}
 
-	sp->recv_credit_max = smbd_receive_credit_max;
-	sp->send_credit_target = smbd_send_credit_target;
-	sp->max_send_size = smbd_max_send_size;
-	sp->max_fragmented_recv_size = smbd_max_fragmented_recv_size;
-	sp->max_recv_size = smbd_max_receive_size;
-	sp->keepalive_interval_msec = smbd_keep_alive_interval * 1000;
-
 	if (sc->ib.dev->attrs.max_send_sge < SMBDIRECT_SEND_IO_MAX_SGE ||
 	    sc->ib.dev->attrs.max_recv_sge < SMBDIRECT_RECV_IO_MAX_SGE) {
 		log_rdma_event(ERR,
-- 
2.43.0

[PATCH v4 039/142] smb: client: make use of smbdirect_socket_parameters.{resolve_{addr,route},rdma_connect,negotiate}_timeout_msec

[Stefan Metzmacher]

This will make future changes to these values much saner.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 22 ++++++++++++++++------
 1 file changed, 16 insertions(+), 6 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index a1ca18dbb758..80d5ca0f10c2 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -57,6 +57,9 @@ static ssize_t smb_extract_iter_to_rdma(struct iov_iter *iter, size_t len,
 /* SMBD negotiation timeout in seconds */
 #define SMBD_NEGOTIATE_TIMEOUT	120
 
+/* The timeout to wait for a keepalive message from peer in seconds */
+#define KEEPALIVE_RECV_TIMEOUT 5
+
 /* SMBD minimum receive size and fragmented sized defined in [MS-SMBD] */
 #define SMBD_MIN_RECEIVE_SIZE		128
 #define SMBD_MIN_FRAGMENTED_SIZE	131072
@@ -677,6 +680,7 @@ static struct rdma_cm_id *smbd_create_id(
 		struct sockaddr *dstaddr, int port)
 {
 	struct smbdirect_socket *sc = &info->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct rdma_cm_id *id;
 	int rc;
 	__be16 *sport;
@@ -699,7 +703,7 @@ static struct rdma_cm_id *smbd_create_id(
 	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ADDR_NEEDED);
 	sc->status = SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING;
 	rc = rdma_resolve_addr(id, NULL, (struct sockaddr *)dstaddr,
-		RDMA_RESOLVE_TIMEOUT);
+		sp->resolve_addr_timeout_msec);
 	if (rc) {
 		log_rdma_event(ERR, "rdma_resolve_addr() failed %i\n", rc);
 		goto out;
@@ -707,7 +711,7 @@ static struct rdma_cm_id *smbd_create_id(
 	rc = wait_event_interruptible_timeout(
 		sc->status_wait,
 		sc->status != SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING,
-		msecs_to_jiffies(RDMA_RESOLVE_TIMEOUT));
+		msecs_to_jiffies(sp->resolve_addr_timeout_msec));
 	/* e.g. if interrupted returns -ERESTARTSYS */
 	if (rc < 0) {
 		log_rdma_event(ERR, "rdma_resolve_addr timeout rc: %i\n", rc);
@@ -726,7 +730,7 @@ static struct rdma_cm_id *smbd_create_id(
 
 	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED);
 	sc->status = SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING;
-	rc = rdma_resolve_route(id, RDMA_RESOLVE_TIMEOUT);
+	rc = rdma_resolve_route(id, sp->resolve_route_timeout_msec);
 	if (rc) {
 		log_rdma_event(ERR, "rdma_resolve_route() failed %i\n", rc);
 		goto out;
@@ -734,7 +738,7 @@ static struct rdma_cm_id *smbd_create_id(
 	rc = wait_event_interruptible_timeout(
 		sc->status_wait,
 		sc->status != SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING,
-		msecs_to_jiffies(RDMA_RESOLVE_TIMEOUT));
+		msecs_to_jiffies(sp->resolve_route_timeout_msec));
 	/* e.g. if interrupted returns -ERESTARTSYS */
 	if (rc < 0)  {
 		log_rdma_event(ERR, "rdma_resolve_addr timeout rc: %i\n", rc);
@@ -1222,6 +1226,7 @@ static int smbd_post_recv(
 static int smbd_negotiate(struct smbd_connection *info)
 {
 	struct smbdirect_socket *sc = &info->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	int rc;
 	struct smbdirect_recv_io *response = get_receive_buffer(info);
 
@@ -1243,7 +1248,7 @@ static int smbd_negotiate(struct smbd_connection *info)
 	rc = wait_event_interruptible_timeout(
 		sc->status_wait,
 		sc->status != SMBDIRECT_SOCKET_NEGOTIATE_RUNNING,
-		secs_to_jiffies(SMBD_NEGOTIATE_TIMEOUT));
+		msecs_to_jiffies(sp->negotiate_timeout_msec));
 	log_rdma_event(INFO, "wait_event_interruptible_timeout rc=%d\n", rc);
 
 	if (sc->status == SMBDIRECT_SOCKET_CONNECTED)
@@ -1672,12 +1677,17 @@ static struct smbd_connection *_smbd_get_connection(
 
 	INIT_WORK(&sc->disconnect_work, smbd_disconnect_rdma_work);
 
+	sp->resolve_addr_timeout_msec = RDMA_RESOLVE_TIMEOUT;
+	sp->resolve_route_timeout_msec = RDMA_RESOLVE_TIMEOUT;
+	sp->rdma_connect_timeout_msec = RDMA_RESOLVE_TIMEOUT;
+	sp->negotiate_timeout_msec = SMBD_NEGOTIATE_TIMEOUT * 1000;
 	sp->recv_credit_max = smbd_receive_credit_max;
 	sp->send_credit_target = smbd_send_credit_target;
 	sp->max_send_size = smbd_max_send_size;
 	sp->max_fragmented_recv_size = smbd_max_fragmented_recv_size;
 	sp->max_recv_size = smbd_max_receive_size;
 	sp->keepalive_interval_msec = smbd_keep_alive_interval * 1000;
+	sp->keepalive_timeout_msec = KEEPALIVE_RECV_TIMEOUT * 1000;
 
 	rc = smbd_ia_open(info, dstaddr, port);
 	if (rc) {
@@ -1792,7 +1802,7 @@ static struct smbd_connection *_smbd_get_connection(
 	wait_event_interruptible_timeout(
 		sc->status_wait,
 		sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING,
-		msecs_to_jiffies(RDMA_RESOLVE_TIMEOUT));
+		msecs_to_jiffies(sp->rdma_connect_timeout_msec));
 
 	if (sc->status != SMBDIRECT_SOCKET_NEGOTIATE_NEEDED) {
 		log_rdma_event(ERR, "rdma_connect failed port=%d\n", port);
-- 
2.43.0

[PATCH v4 040/142] smb: client: make use of smbdirect_socket_parameters.{initiator_depth,responder_resources}

[Stefan Metzmacher]

This will make it easier to specify these from the outside of the core
code first and then negotiate the value with the peer.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/cifs_debug.c |  2 +-
 fs/smb/client/smbdirect.c  | 29 +++++++++++++++--------------
 fs/smb/client/smbdirect.h  |  2 --
 3 files changed, 16 insertions(+), 17 deletions(-)

diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
index e8faa5726b1c..9dadf04508ac 100644
--- a/fs/smb/client/cifs_debug.c
+++ b/fs/smb/client/cifs_debug.c
@@ -483,7 +483,7 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
 			atomic_read(&sc->send_io.pending.count));
 		seq_printf(m, "\nMR responder_resources: %x "
 			"max_frmr_depth: %x mr_type: %x",
-			server->smbd_conn->responder_resources,
+			sp->responder_resources,
 			server->smbd_conn->max_frmr_depth,
 			server->smbd_conn->mr_type);
 		seq_printf(m, "\nMR mr_ready_count: %x mr_used_count: %x",
diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 80d5ca0f10c2..e6c54255192f 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -221,6 +221,7 @@ static int smbd_conn_upcall(
 {
 	struct smbd_connection *info = id->context;
 	struct smbdirect_socket *sc = &info->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	const char *event_name = rdma_event_msg(event->event);
 	u8 peer_initiator_depth;
 	u8 peer_responder_resources;
@@ -303,11 +304,11 @@ static int smbd_conn_upcall(
 			}
 		}
 
-		info->initiator_depth =
-				min_t(u8, info->initiator_depth,
+		sp->initiator_depth =
+				min_t(u8, sp->initiator_depth,
 				      peer_initiator_depth);
-		info->responder_resources =
-				min_t(u8, info->responder_resources,
+		sp->responder_resources =
+				min_t(u8, sp->responder_resources,
 				      peer_responder_resources);
 
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING);
@@ -1672,15 +1673,14 @@ static struct smbd_connection *_smbd_get_connection(
 	smbdirect_socket_init(sc);
 	sp = &sc->parameters;
 
-	info->initiator_depth = 1;
-	info->responder_resources = SMBD_CM_RESPONDER_RESOURCES;
-
 	INIT_WORK(&sc->disconnect_work, smbd_disconnect_rdma_work);
 
 	sp->resolve_addr_timeout_msec = RDMA_RESOLVE_TIMEOUT;
 	sp->resolve_route_timeout_msec = RDMA_RESOLVE_TIMEOUT;
 	sp->rdma_connect_timeout_msec = RDMA_RESOLVE_TIMEOUT;
 	sp->negotiate_timeout_msec = SMBD_NEGOTIATE_TIMEOUT * 1000;
+	sp->initiator_depth = 1;
+	sp->responder_resources = SMBD_CM_RESPONDER_RESOURCES;
 	sp->recv_credit_max = smbd_receive_credit_max;
 	sp->send_credit_target = smbd_send_credit_target;
 	sp->max_send_size = smbd_max_send_size;
@@ -1761,15 +1761,15 @@ static struct smbd_connection *_smbd_get_connection(
 	}
 	sc->ib.qp = sc->rdma.cm_id->qp;
 
-	info->responder_resources =
-		min_t(u8, info->responder_resources,
+	sp->responder_resources =
+		min_t(u8, sp->responder_resources,
 		      sc->ib.dev->attrs.max_qp_rd_atom);
 	log_rdma_mr(INFO, "responder_resources=%d\n",
-		info->responder_resources);
+		sp->responder_resources);
 
 	memset(&conn_param, 0, sizeof(conn_param));
-	conn_param.initiator_depth = info->initiator_depth;
-	conn_param.responder_resources = info->responder_resources;
+	conn_param.initiator_depth = sp->initiator_depth;
+	conn_param.responder_resources = sp->responder_resources;
 
 	/* Need to send IRD/ORD in private data for iWARP */
 	sc->ib.dev->ops.get_port_immutable(
@@ -2226,6 +2226,7 @@ static void destroy_mr_list(struct smbd_connection *info)
 static int allocate_mr_list(struct smbd_connection *info)
 {
 	struct smbdirect_socket *sc = &info->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	int i;
 	struct smbd_mr *smbdirect_mr, *tmp;
 
@@ -2237,13 +2238,13 @@ static int allocate_mr_list(struct smbd_connection *info)
 	init_waitqueue_head(&info->wait_for_mr_cleanup);
 	INIT_WORK(&info->mr_recovery_work, smbd_mr_recovery_work);
 
-	if (info->responder_resources == 0) {
+	if (sp->responder_resources == 0) {
 		log_rdma_mr(ERR, "responder_resources negotiated as 0\n");
 		return -EINVAL;
 	}
 
 	/* Allocate more MRs (2x) than hardware responder_resources */
-	for (i = 0; i < info->responder_resources * 2; i++) {
+	for (i = 0; i < sp->responder_resources * 2; i++) {
 		smbdirect_mr = kzalloc(sizeof(*smbdirect_mr), GFP_KERNEL);
 		if (!smbdirect_mr)
 			goto cleanup_entries;
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 3dd7408329f5..b973943acea3 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -52,8 +52,6 @@ struct smbd_connection {
 	/* Memory registrations */
 	/* Maximum number of RDMA read/write outstanding on this connection */
 	bool legacy_iwarp;
-	u8 initiator_depth;
-	u8 responder_resources;
 	/* Maximum number of pages in a single RDMA write/read on this connection */
 	int max_frmr_depth;
 	/*
-- 
2.43.0

[PATCH v4 041/142] smb: client: make use of smbdirect_socket.rdma.legacy_iwarp

[Stefan Metzmacher]

Currently it's write only for the client, but it will likely be use
for debugging later.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 2 +-
 fs/smb/client/smbdirect.h | 2 --
 2 files changed, 1 insertion(+), 3 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index e6c54255192f..ab1f5050e616 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -298,7 +298,7 @@ static int smbd_conn_upcall(
 				ird32 = min_t(u32, ird32, U8_MAX);
 				ord32 = min_t(u32, ord32, U8_MAX);
 
-				info->legacy_iwarp = true;
+				sc->rdma.legacy_iwarp = true;
 				peer_initiator_depth = (u8)ird32;
 				peer_responder_resources = (u8)ord32;
 			}
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index b973943acea3..f5f4188ad7cd 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -50,8 +50,6 @@ struct smbd_connection {
 	int protocol;
 
 	/* Memory registrations */
-	/* Maximum number of RDMA read/write outstanding on this connection */
-	bool legacy_iwarp;
 	/* Maximum number of pages in a single RDMA write/read on this connection */
 	int max_frmr_depth;
 	/*
-- 
2.43.0

[PATCH v4 042/142] smb: client: send empty packets via send_immediate_work

[Stefan Metzmacher]

This is what the server already does and it makes
refactoring for common structures and functions much easier.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 25 +++++++++++++++++++++----
 fs/smb/client/smbdirect.h |  1 +
 2 files changed, 22 insertions(+), 4 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index ab1f5050e616..b7c5f30fa271 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -173,6 +173,7 @@ static void smbd_disconnect_rdma_work(struct work_struct *work)
 	disable_work(&sc->disconnect_work);
 	disable_work(&sc->recv_io.posted.refill_work);
 	disable_work(&info->mr_recovery_work);
+	disable_work(&info->send_immediate_work);
 	disable_delayed_work(&info->idle_timer_work);
 
 	switch (sc->status) {
@@ -542,8 +543,8 @@ static void smbd_post_send_credits(struct work_struct *work)
 	/* Promptly send an immediate packet as defined in [MS-SMBD] 3.1.1.1 */
 	if (atomic_read(&sc->recv_io.credits.count) <
 		sc->recv_io.credits.target - 1) {
-		log_keep_alive(INFO, "send an empty message\n");
-		smbd_post_send_empty(info);
+		log_keep_alive(INFO, "schedule send of an empty message\n");
+		queue_work(info->workqueue, &info->send_immediate_work);
 	}
 }
 
@@ -1409,6 +1410,19 @@ static void destroy_receive_buffers(struct smbd_connection *info)
 		mempool_free(response, sc->recv_io.mem.pool);
 }
 
+static void send_immediate_empty_message(struct work_struct *work)
+{
+	struct smbd_connection *info =
+		container_of(work, struct smbd_connection, send_immediate_work);
+	struct smbdirect_socket *sc = &info->socket;
+
+	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
+		return;
+
+	log_keep_alive(INFO, "send an empty message\n");
+	smbd_post_send_empty(info);
+}
+
 /* Implement idle connection timer [MS-SMBD] 3.1.6.2 */
 static void idle_connection_timer(struct work_struct *work)
 {
@@ -1426,8 +1440,8 @@ static void idle_connection_timer(struct work_struct *work)
 		return;
 	}
 
-	log_keep_alive(INFO, "about to send an empty idle message\n");
-	smbd_post_send_empty(info);
+	log_keep_alive(INFO, "schedule send of empty idle message\n");
+	queue_work(info->workqueue, &info->send_immediate_work);
 
 	/* Setup the next idle timeout work */
 	queue_delayed_work(info->workqueue, &info->idle_timer_work,
@@ -1474,6 +1488,8 @@ void smbd_destroy(struct TCP_Server_Info *server)
 
 	log_rdma_event(INFO, "cancelling idle timer\n");
 	disable_delayed_work_sync(&info->idle_timer_work);
+	log_rdma_event(INFO, "cancelling send immediate work\n");
+	disable_work_sync(&info->send_immediate_work);
 
 	/* It's not possible for upper layer to get to reassembly */
 	log_rdma_event(INFO, "drain the reassembly queue\n");
@@ -1817,6 +1833,7 @@ static struct smbd_connection *_smbd_get_connection(
 		goto allocate_cache_failed;
 	}
 
+	INIT_WORK(&info->send_immediate_work, send_immediate_empty_message);
 	INIT_DELAYED_WORK(&info->idle_timer_work, idle_connection_timer);
 	queue_delayed_work(info->workqueue, &info->idle_timer_work,
 		msecs_to_jiffies(sp->keepalive_interval_msec));
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index f5f4188ad7cd..d51ec4d01be7 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -74,6 +74,7 @@ struct smbd_connection {
 	wait_queue_head_t wait_post_send;
 
 	struct workqueue_struct *workqueue;
+	struct work_struct send_immediate_work;
 	struct delayed_work idle_timer_work;
 
 	/* for debug purposes */
-- 
2.43.0

[PATCH v4 043/142] smb: client: fix smbdirect keep alive handling to match the documentation

[Stefan Metzmacher]

We setup the first timer with the negotiate timeout and set
KEEP_ALIVE_PENDING, so that the expired timer disconnects.

On every incoming message we need to reset the timer to the keepalive
interval (120s).

On SMBDIRECT_FLAG_RESPONSE_REQUESTED we need to schedule a response
instead of setting KEEP_ALIVE_PENDING. Doing both would mean
we would also set SMBDIRECT_FLAG_RESPONSE_REQUESTED in that
response. If both ends would do that we'd play ping pong in
a busy loop.

If we move to KEEP_ALIVE_SENT and send the keepalive request
with SMBDIRECT_FLAG_RESPONSE_REQUESTED, we need to setup the
timer with keepalive timeout (5s) in order to disconnect
if no incoming message reset the timer.

The fired timer sets KEEP_ALIVE_PENDING and also
setup timer with keepalive timeout (5s) in order to disconnect
if no incoming message reset the timer.
We do that before queueing the send_immediate_work
and have that timer in case we didn't reach the send code
that typically sets the timer to keepalive timeout.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 52 ++++++++++++++++++++++++++++-----------
 1 file changed, 38 insertions(+), 14 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index b7c5f30fa271..cd00b4801795 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -581,6 +581,14 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		response->sge.length,
 		DMA_FROM_DEVICE);
 
+	/*
+	 * Reset timer to the keepalive interval in
+	 * order to trigger our next keepalive message.
+	 */
+	info->keep_alive_requested = KEEP_ALIVE_NONE;
+	mod_delayed_work(info->workqueue, &info->idle_timer_work,
+			 msecs_to_jiffies(sp->keepalive_interval_msec));
+
 	switch (sc->recv_io.expected) {
 	/* SMBD negotiation response */
 	case SMBDIRECT_EXPECT_NEGOTIATE_REP:
@@ -640,11 +648,11 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			     le32_to_cpu(data_transfer->data_length),
 			     le32_to_cpu(data_transfer->remaining_data_length));
 
-		/* Send a KEEP_ALIVE response right away if requested */
-		info->keep_alive_requested = KEEP_ALIVE_NONE;
+		/* Send an immediate response right away if requested */
 		if (le16_to_cpu(data_transfer->flags) &
 				SMBDIRECT_FLAG_RESPONSE_REQUESTED) {
-			info->keep_alive_requested = KEEP_ALIVE_PENDING;
+			log_keep_alive(INFO, "schedule send of immediate response\n");
+			queue_work(info->workqueue, &info->send_immediate_work);
 		}
 
 		/*
@@ -943,8 +951,17 @@ static int manage_credits_prior_sending(struct smbd_connection *info)
  */
 static int manage_keep_alive_before_sending(struct smbd_connection *info)
 {
+	struct smbdirect_socket *sc = &info->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
+
 	if (info->keep_alive_requested == KEEP_ALIVE_PENDING) {
 		info->keep_alive_requested = KEEP_ALIVE_SENT;
+		/*
+		 * Now use the keepalive timeout (instead of keepalive interval)
+		 * in order to wait for a response
+		 */
+		mod_delayed_work(info->workqueue, &info->idle_timer_work,
+				 msecs_to_jiffies(sp->keepalive_timeout_msec));
 		return 1;
 	}
 	return 0;
@@ -955,7 +972,6 @@ static int smbd_post_send(struct smbd_connection *info,
 		struct smbdirect_send_io *request)
 {
 	struct smbdirect_socket *sc = &info->socket;
-	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct ib_send_wr send_wr;
 	int rc, i;
 
@@ -984,10 +1000,7 @@ static int smbd_post_send(struct smbd_connection *info,
 		log_rdma_send(ERR, "ib_post_send failed rc=%d\n", rc);
 		smbd_disconnect_rdma_connection(info);
 		rc = -EAGAIN;
-	} else
-		/* Reset timer for idle connection after packet is sent */
-		mod_delayed_work(info->workqueue, &info->idle_timer_work,
-			msecs_to_jiffies(sp->keepalive_interval_msec));
+	}
 
 	return rc;
 }
@@ -1440,12 +1453,18 @@ static void idle_connection_timer(struct work_struct *work)
 		return;
 	}
 
+	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
+		return;
+
+	/*
+	 * Now use the keepalive timeout (instead of keepalive interval)
+	 * in order to wait for a response
+	 */
+	info->keep_alive_requested = KEEP_ALIVE_PENDING;
+	mod_delayed_work(info->workqueue, &info->idle_timer_work,
+			 msecs_to_jiffies(sp->keepalive_timeout_msec));
 	log_keep_alive(INFO, "schedule send of empty idle message\n");
 	queue_work(info->workqueue, &info->send_immediate_work);
-
-	/* Setup the next idle timeout work */
-	queue_delayed_work(info->workqueue, &info->idle_timer_work,
-			msecs_to_jiffies(sp->keepalive_interval_msec));
 }
 
 /*
@@ -1835,8 +1854,13 @@ static struct smbd_connection *_smbd_get_connection(
 
 	INIT_WORK(&info->send_immediate_work, send_immediate_empty_message);
 	INIT_DELAYED_WORK(&info->idle_timer_work, idle_connection_timer);
-	queue_delayed_work(info->workqueue, &info->idle_timer_work,
-		msecs_to_jiffies(sp->keepalive_interval_msec));
+	/*
+	 * start with the negotiate timeout and KEEP_ALIVE_PENDING
+	 * so that the timer will cause a disconnect.
+	 */
+	info->keep_alive_requested = KEEP_ALIVE_PENDING;
+	mod_delayed_work(info->workqueue, &info->idle_timer_work,
+			 msecs_to_jiffies(sp->negotiate_timeout_msec));
 
 	init_waitqueue_head(&info->wait_post_send);
 
-- 
2.43.0

[PATCH v4 044/142] smb: client: make use of smbdirect_socket.idle.{keepalive,immediate_work,timer_work}

[Stefan Metzmacher]

This will allow client and server to use the common structures in order
to share common functions later.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 59 ++++++++++++++++++++-------------------
 fs/smb/client/smbdirect.h |  9 ------
 2 files changed, 30 insertions(+), 38 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index cd00b4801795..450e43f1fe39 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -173,8 +173,8 @@ static void smbd_disconnect_rdma_work(struct work_struct *work)
 	disable_work(&sc->disconnect_work);
 	disable_work(&sc->recv_io.posted.refill_work);
 	disable_work(&info->mr_recovery_work);
-	disable_work(&info->send_immediate_work);
-	disable_delayed_work(&info->idle_timer_work);
+	disable_work(&sc->idle.immediate_work);
+	disable_delayed_work(&sc->idle.timer_work);
 
 	switch (sc->status) {
 	case SMBDIRECT_SOCKET_NEGOTIATE_NEEDED:
@@ -544,7 +544,7 @@ static void smbd_post_send_credits(struct work_struct *work)
 	if (atomic_read(&sc->recv_io.credits.count) <
 		sc->recv_io.credits.target - 1) {
 		log_keep_alive(INFO, "schedule send of an empty message\n");
-		queue_work(info->workqueue, &info->send_immediate_work);
+		queue_work(info->workqueue, &sc->idle.immediate_work);
 	}
 }
 
@@ -585,8 +585,8 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	 * Reset timer to the keepalive interval in
 	 * order to trigger our next keepalive message.
 	 */
-	info->keep_alive_requested = KEEP_ALIVE_NONE;
-	mod_delayed_work(info->workqueue, &info->idle_timer_work,
+	sc->idle.keepalive = SMBDIRECT_KEEPALIVE_NONE;
+	mod_delayed_work(info->workqueue, &sc->idle.timer_work,
 			 msecs_to_jiffies(sp->keepalive_interval_msec));
 
 	switch (sc->recv_io.expected) {
@@ -652,7 +652,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		if (le16_to_cpu(data_transfer->flags) &
 				SMBDIRECT_FLAG_RESPONSE_REQUESTED) {
 			log_keep_alive(INFO, "schedule send of immediate response\n");
-			queue_work(info->workqueue, &info->send_immediate_work);
+			queue_work(info->workqueue, &sc->idle.immediate_work);
 		}
 
 		/*
@@ -954,13 +954,13 @@ static int manage_keep_alive_before_sending(struct smbd_connection *info)
 	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 
-	if (info->keep_alive_requested == KEEP_ALIVE_PENDING) {
-		info->keep_alive_requested = KEEP_ALIVE_SENT;
+	if (sc->idle.keepalive == SMBDIRECT_KEEPALIVE_PENDING) {
+		sc->idle.keepalive = SMBDIRECT_KEEPALIVE_SENT;
 		/*
 		 * Now use the keepalive timeout (instead of keepalive interval)
 		 * in order to wait for a response
 		 */
-		mod_delayed_work(info->workqueue, &info->idle_timer_work,
+		mod_delayed_work(info->workqueue, &sc->idle.timer_work,
 				 msecs_to_jiffies(sp->keepalive_timeout_msec));
 		return 1;
 	}
@@ -1425,9 +1425,10 @@ static void destroy_receive_buffers(struct smbd_connection *info)
 
 static void send_immediate_empty_message(struct work_struct *work)
 {
+	struct smbdirect_socket *sc =
+		container_of(work, struct smbdirect_socket, idle.immediate_work);
 	struct smbd_connection *info =
-		container_of(work, struct smbd_connection, send_immediate_work);
-	struct smbdirect_socket *sc = &info->socket;
+		container_of(sc, struct smbd_connection, socket);
 
 	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
 		return;
@@ -1439,16 +1440,16 @@ static void send_immediate_empty_message(struct work_struct *work)
 /* Implement idle connection timer [MS-SMBD] 3.1.6.2 */
 static void idle_connection_timer(struct work_struct *work)
 {
-	struct smbd_connection *info = container_of(
-					work, struct smbd_connection,
-					idle_timer_work.work);
-	struct smbdirect_socket *sc = &info->socket;
+	struct smbdirect_socket *sc =
+		container_of(work, struct smbdirect_socket, idle.timer_work.work);
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
+	struct smbd_connection *info =
+		container_of(sc, struct smbd_connection, socket);
 
-	if (info->keep_alive_requested != KEEP_ALIVE_NONE) {
+	if (sc->idle.keepalive != SMBDIRECT_KEEPALIVE_NONE) {
 		log_keep_alive(ERR,
-			"error status info->keep_alive_requested=%d\n",
-			info->keep_alive_requested);
+			"error status sc->idle.keepalive=%d\n",
+			sc->idle.keepalive);
 		smbd_disconnect_rdma_connection(info);
 		return;
 	}
@@ -1460,11 +1461,11 @@ static void idle_connection_timer(struct work_struct *work)
 	 * Now use the keepalive timeout (instead of keepalive interval)
 	 * in order to wait for a response
 	 */
-	info->keep_alive_requested = KEEP_ALIVE_PENDING;
-	mod_delayed_work(info->workqueue, &info->idle_timer_work,
+	sc->idle.keepalive = SMBDIRECT_KEEPALIVE_PENDING;
+	mod_delayed_work(info->workqueue, &sc->idle.timer_work,
 			 msecs_to_jiffies(sp->keepalive_timeout_msec));
 	log_keep_alive(INFO, "schedule send of empty idle message\n");
-	queue_work(info->workqueue, &info->send_immediate_work);
+	queue_work(info->workqueue, &sc->idle.immediate_work);
 }
 
 /*
@@ -1506,9 +1507,9 @@ void smbd_destroy(struct TCP_Server_Info *server)
 	sc->ib.qp = NULL;
 
 	log_rdma_event(INFO, "cancelling idle timer\n");
-	disable_delayed_work_sync(&info->idle_timer_work);
+	disable_delayed_work_sync(&sc->idle.timer_work);
 	log_rdma_event(INFO, "cancelling send immediate work\n");
-	disable_work_sync(&info->send_immediate_work);
+	disable_work_sync(&sc->idle.immediate_work);
 
 	/* It's not possible for upper layer to get to reassembly */
 	log_rdma_event(INFO, "drain the reassembly queue\n");
@@ -1852,14 +1853,14 @@ static struct smbd_connection *_smbd_get_connection(
 		goto allocate_cache_failed;
 	}
 
-	INIT_WORK(&info->send_immediate_work, send_immediate_empty_message);
-	INIT_DELAYED_WORK(&info->idle_timer_work, idle_connection_timer);
+	INIT_WORK(&sc->idle.immediate_work, send_immediate_empty_message);
+	INIT_DELAYED_WORK(&sc->idle.timer_work, idle_connection_timer);
 	/*
-	 * start with the negotiate timeout and KEEP_ALIVE_PENDING
+	 * start with the negotiate timeout and SMBDIRECT_KEEPALIVE_PENDING
 	 * so that the timer will cause a disconnect.
 	 */
-	info->keep_alive_requested = KEEP_ALIVE_PENDING;
-	mod_delayed_work(info->workqueue, &info->idle_timer_work,
+	sc->idle.keepalive = SMBDIRECT_KEEPALIVE_PENDING;
+	mod_delayed_work(info->workqueue, &sc->idle.timer_work,
 			 msecs_to_jiffies(sp->negotiate_timeout_msec));
 
 	init_waitqueue_head(&info->wait_post_send);
@@ -1887,7 +1888,7 @@ static struct smbd_connection *_smbd_get_connection(
 	return NULL;
 
 negotiation_failed:
-	disable_delayed_work_sync(&info->idle_timer_work);
+	disable_delayed_work_sync(&sc->idle.timer_work);
 	destroy_caches_and_workqueue(info);
 	sc->status = SMBDIRECT_SOCKET_NEGOTIATE_FAILED;
 	rdma_disconnect(sc->rdma.cm_id);
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index d51ec4d01be7..0197a9da294e 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -27,12 +27,6 @@ extern int smbd_max_send_size;
 extern int smbd_send_credit_target;
 extern int smbd_receive_credit_max;
 
-enum keep_alive_status {
-	KEEP_ALIVE_NONE,
-	KEEP_ALIVE_PENDING,
-	KEEP_ALIVE_SENT,
-};
-
 /*
  * The context for the SMBDirect transport
  * Everything related to the transport is here. It has several logical parts
@@ -46,7 +40,6 @@ struct smbd_connection {
 	struct smbdirect_socket socket;
 
 	/* dynamic connection parameters defined in [MS-SMBD] 3.1.1.1 */
-	enum keep_alive_status keep_alive_requested;
 	int protocol;
 
 	/* Memory registrations */
@@ -74,8 +67,6 @@ struct smbd_connection {
 	wait_queue_head_t wait_post_send;
 
 	struct workqueue_struct *workqueue;
-	struct work_struct send_immediate_work;
-	struct delayed_work idle_timer_work;
 
 	/* for debug purposes */
 	unsigned int count_get_receive_buffer;
-- 
2.43.0

[PATCH v4 045/142] smb: client: remove unused smbd_connection->protocol

[Stefan Metzmacher]

There is only one protocol version for smbdirect yet and
this variable is write only.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/cifs_debug.c | 5 +++--
 fs/smb/client/smbdirect.c  | 1 -
 fs/smb/client/smbdirect.h  | 2 --
 3 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
index 9dadf04508ac..8f1ad9cb6208 100644
--- a/fs/smb/client/cifs_debug.c
+++ b/fs/smb/client/cifs_debug.c
@@ -24,6 +24,7 @@
 #endif
 #ifdef CONFIG_CIFS_SMB_DIRECT
 #include "smbdirect.h"
+#include "../common/smbdirect/smbdirect_pdu.h"
 #endif
 #include "cifs_swn.h"
 #include "cached_dir.h"
@@ -442,8 +443,8 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
 
 		seq_printf(m, "\nSMBDirect (in hex) protocol version: %x "
 			"transport status: %x",
-			server->smbd_conn->protocol,
-			server->smbd_conn->socket.status);
+			SMBDIRECT_V1,
+			sc->status);
 		seq_printf(m, "\nConn receive_credit_max: %x "
 			"send_credit_target: %x max_send_size: %x",
 			sp->recv_credit_max,
diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 450e43f1fe39..68450489c5d1 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -454,7 +454,6 @@ static bool process_negotiation_response(
 			le16_to_cpu(packet->negotiated_version));
 		return false;
 	}
-	info->protocol = le16_to_cpu(packet->negotiated_version);
 
 	if (packet->credits_requested == 0) {
 		log_rdma_event(ERR, "error: credits_requested==0\n");
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 0197a9da294e..3963fd27d8b6 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -39,8 +39,6 @@ extern int smbd_receive_credit_max;
 struct smbd_connection {
 	struct smbdirect_socket socket;
 
-	/* dynamic connection parameters defined in [MS-SMBD] 3.1.1.1 */
-	int protocol;
 
 	/* Memory registrations */
 	/* Maximum number of pages in a single RDMA write/read on this connection */
-- 
2.43.0

[PATCH v4 046/142] smb: client: remove unused smbd_connection.count_reassembly_queue

[Stefan Metzmacher]

This basically represents the same information as
sc->recv_io.reassembly.queue_length.

The only thing that's different is that
smbd_connection.count_reassembly_queue was updated in each
loop step, while sc->recv_io.reassembly.queue_length is only
updated once after the loop in smbd_recv.
Also sc->recv_io.reassembly.queue_length is updated under
a spinlock.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/cifs_debug.c | 3 +--
 fs/smb/client/smbdirect.c  | 2 --
 fs/smb/client/smbdirect.h  | 1 -
 3 files changed, 1 insertion(+), 5 deletions(-)

diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
index 8f1ad9cb6208..35c90d494cd9 100644
--- a/fs/smb/client/cifs_debug.c
+++ b/fs/smb/client/cifs_debug.c
@@ -465,12 +465,11 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
 			server->smbd_conn->count_get_receive_buffer,
 			server->smbd_conn->count_put_receive_buffer,
 			server->smbd_conn->count_send_empty);
-		seq_printf(m, "\nRead Queue count_reassembly_queue: %x "
+		seq_printf(m, "\nRead Queue "
 			"count_enqueue_reassembly_queue: %x "
 			"count_dequeue_reassembly_queue: %x "
 			"reassembly_data_length: %x "
 			"reassembly_queue_length: %x",
-			server->smbd_conn->count_reassembly_queue,
 			server->smbd_conn->count_enqueue_reassembly_queue,
 			server->smbd_conn->count_dequeue_reassembly_queue,
 			sc->recv_io.reassembly.data_length,
diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 68450489c5d1..a597b0bbd521 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -1307,7 +1307,6 @@ static void enqueue_reassembly(
 	virt_wmb();
 	sc->recv_io.reassembly.data_length += data_length;
 	spin_unlock(&sc->recv_io.reassembly.lock);
-	info->count_reassembly_queue++;
 	info->count_enqueue_reassembly_queue++;
 }
 
@@ -2035,7 +2034,6 @@ int smbd_recv(struct smbd_connection *info, struct msghdr *msg)
 						&sc->recv_io.reassembly.lock);
 				}
 				queue_removed++;
-				info->count_reassembly_queue--;
 				info->count_dequeue_reassembly_queue++;
 				put_receive_buffer(info, response);
 				offset = 0;
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 3963fd27d8b6..bc72634f5433 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -69,7 +69,6 @@ struct smbd_connection {
 	/* for debug purposes */
 	unsigned int count_get_receive_buffer;
 	unsigned int count_put_receive_buffer;
-	unsigned int count_reassembly_queue;
 	unsigned int count_enqueue_reassembly_queue;
 	unsigned int count_dequeue_reassembly_queue;
 	unsigned int count_send_empty;
-- 
2.43.0

[PATCH v4 047/142] smb: client: make use of smbdirect_socket.statistics

[Stefan Metzmacher]

This will allow us to use common functions soon.

Note this generates the following warnings from
scripts/checkpatch.pl --quiet:

 WARNING: quoted string split across lines
 #40: FILE: fs/smb/client/cifs_debug.c:464:
 +               seq_printf(m, "\nDebug count_get_receive_buffer: %llx "
 +                       "count_put_receive_buffer: %llx count_send_empty: %llx",

 WARNING: quoted string split across lines
 #47: FILE: fs/smb/client/cifs_debug.c:469:
                 seq_printf(m, "\nRead Queue "
 +                       "count_enqueue_reassembly_queue: %llx "

 WARNING: quoted string split across lines
 #48: FILE: fs/smb/client/cifs_debug.c:470:
 +                       "count_enqueue_reassembly_queue: %llx "
 +                       "count_dequeue_reassembly_queue: %llx "

 total: 0 errors, 3 warnings, 83 lines checked
 scripts/checkpatch.pl: FAILED

But I left them in there, because it matches the code
arround it...

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/cifs_debug.c | 18 +++++++++---------
 fs/smb/client/smbdirect.c  | 11 ++++++-----
 fs/smb/client/smbdirect.h  |  7 -------
 3 files changed, 15 insertions(+), 21 deletions(-)

diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
index 35c90d494cd9..bb6bb1e3b723 100644
--- a/fs/smb/client/cifs_debug.c
+++ b/fs/smb/client/cifs_debug.c
@@ -460,18 +460,18 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
 			sp->keepalive_interval_msec * 1000,
 			sp->max_read_write_size,
 			server->smbd_conn->rdma_readwrite_threshold);
-		seq_printf(m, "\nDebug count_get_receive_buffer: %x "
-			"count_put_receive_buffer: %x count_send_empty: %x",
-			server->smbd_conn->count_get_receive_buffer,
-			server->smbd_conn->count_put_receive_buffer,
-			server->smbd_conn->count_send_empty);
+		seq_printf(m, "\nDebug count_get_receive_buffer: %llx "
+			"count_put_receive_buffer: %llx count_send_empty: %llx",
+			sc->statistics.get_receive_buffer,
+			sc->statistics.put_receive_buffer,
+			sc->statistics.send_empty);
 		seq_printf(m, "\nRead Queue "
-			"count_enqueue_reassembly_queue: %x "
-			"count_dequeue_reassembly_queue: %x "
+			"count_enqueue_reassembly_queue: %llx "
+			"count_dequeue_reassembly_queue: %llx "
 			"reassembly_data_length: %x "
 			"reassembly_queue_length: %x",
-			server->smbd_conn->count_enqueue_reassembly_queue,
-			server->smbd_conn->count_dequeue_reassembly_queue,
+			sc->statistics.enqueue_reassembly_queue,
+			sc->statistics.dequeue_reassembly_queue,
 			sc->recv_io.reassembly.data_length,
 			sc->recv_io.reassembly.queue_length);
 		seq_printf(m, "\nCurrent Credits send_credits: %x "
diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index a597b0bbd521..2eaddf190354 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -1168,9 +1168,10 @@ static int smbd_post_send_iter(struct smbd_connection *info,
  */
 static int smbd_post_send_empty(struct smbd_connection *info)
 {
+	struct smbdirect_socket *sc = &info->socket;
 	int remaining_data_length = 0;
 
-	info->count_send_empty++;
+	sc->statistics.send_empty++;
 	return smbd_post_send_iter(info, NULL, &remaining_data_length);
 }
 
@@ -1307,7 +1308,7 @@ static void enqueue_reassembly(
 	virt_wmb();
 	sc->recv_io.reassembly.data_length += data_length;
 	spin_unlock(&sc->recv_io.reassembly.lock);
-	info->count_enqueue_reassembly_queue++;
+	sc->statistics.enqueue_reassembly_queue++;
 }
 
 /*
@@ -1346,7 +1347,7 @@ static struct smbdirect_recv_io *get_receive_buffer(struct smbd_connection *info
 			&sc->recv_io.free.list,
 			struct smbdirect_recv_io, list);
 		list_del(&ret->list);
-		info->count_get_receive_buffer++;
+		sc->statistics.get_receive_buffer++;
 	}
 	spin_unlock_irqrestore(&sc->recv_io.free.lock, flags);
 
@@ -1375,7 +1376,7 @@ static void put_receive_buffer(
 
 	spin_lock_irqsave(&sc->recv_io.free.lock, flags);
 	list_add_tail(&response->list, &sc->recv_io.free.list);
-	info->count_put_receive_buffer++;
+	sc->statistics.put_receive_buffer++;
 	spin_unlock_irqrestore(&sc->recv_io.free.lock, flags);
 
 	queue_work(info->workqueue, &sc->recv_io.posted.refill_work);
@@ -2034,7 +2035,7 @@ int smbd_recv(struct smbd_connection *info, struct msghdr *msg)
 						&sc->recv_io.reassembly.lock);
 				}
 				queue_removed++;
-				info->count_dequeue_reassembly_queue++;
+				sc->statistics.dequeue_reassembly_queue++;
 				put_receive_buffer(info, response);
 				offset = 0;
 				log_read(INFO, "put_receive_buffer offset=0\n");
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index bc72634f5433..39a56a54f8b6 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -65,13 +65,6 @@ struct smbd_connection {
 	wait_queue_head_t wait_post_send;
 
 	struct workqueue_struct *workqueue;
-
-	/* for debug purposes */
-	unsigned int count_get_receive_buffer;
-	unsigned int count_put_receive_buffer;
-	unsigned int count_enqueue_reassembly_queue;
-	unsigned int count_dequeue_reassembly_queue;
-	unsigned int count_send_empty;
 };
 
 /* Create a SMBDirect session */
-- 
2.43.0

[PATCH v4 048/142] smb: client: don't check sc->send_io.pending.count is below sp->send_credit_target

[Stefan Metzmacher]

If we were able to get a credit we don't need to prove and wait
that sc->send_io.pending.count is below sp->send_credit_target.

This just adds useless complixity. The same code on the server
also doesn't do this, so we should remove it from the client.

This will make it easier to momve to common code later.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 28 ++++------------------------
 fs/smb/client/smbdirect.h |  3 ---
 2 files changed, 4 insertions(+), 27 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 2eaddf190354..220ebd00a9d7 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -414,8 +414,6 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
 	if (atomic_dec_and_test(&sc->send_io.pending.count))
 		wake_up(&sc->send_io.pending.wait_queue);
 
-	wake_up(&info->wait_post_send);
-
 	mempool_free(request, sc->send_io.mem.pool);
 }
 
@@ -1035,23 +1033,6 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 		goto wait_credit;
 	}
 
-wait_send_queue:
-	wait_event(info->wait_post_send,
-		atomic_read(&sc->send_io.pending.count) < sp->send_credit_target ||
-		sc->status != SMBDIRECT_SOCKET_CONNECTED);
-
-	if (sc->status != SMBDIRECT_SOCKET_CONNECTED) {
-		log_outgoing(ERR, "disconnected not sending on wait_send_queue\n");
-		rc = -EAGAIN;
-		goto err_wait_send_queue;
-	}
-
-	if (unlikely(atomic_inc_return(&sc->send_io.pending.count) >
-				sp->send_credit_target)) {
-		atomic_dec(&sc->send_io.pending.count);
-		goto wait_send_queue;
-	}
-
 	request = mempool_alloc(sc->send_io.mem.pool, GFP_KERNEL);
 	if (!request) {
 		rc = -ENOMEM;
@@ -1133,10 +1114,14 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 	request->sge[0].length = header_length;
 	request->sge[0].lkey = sc->ib.pd->local_dma_lkey;
 
+	atomic_inc(&sc->send_io.pending.count);
 	rc = smbd_post_send(info, request);
 	if (!rc)
 		return 0;
 
+	if (atomic_dec_and_test(&sc->send_io.pending.count))
+		wake_up(&sc->send_io.pending.wait_queue);
+
 err_dma:
 	for (i = 0; i < request->num_sge; i++)
 		if (request->sge[i].addr)
@@ -1150,10 +1135,7 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 	atomic_sub(new_credits, &sc->recv_io.credits.count);
 
 err_alloc:
-	if (atomic_dec_and_test(&sc->send_io.pending.count))
-		wake_up(&sc->send_io.pending.wait_queue);
 
-err_wait_send_queue:
 	/* roll back send credits and pending */
 	atomic_inc(&sc->send_io.credits.count);
 
@@ -1862,8 +1844,6 @@ static struct smbd_connection *_smbd_get_connection(
 	mod_delayed_work(info->workqueue, &sc->idle.timer_work,
 			 msecs_to_jiffies(sp->negotiate_timeout_msec));
 
-	init_waitqueue_head(&info->wait_post_send);
-
 	INIT_WORK(&sc->recv_io.posted.refill_work, smbd_post_send_credits);
 
 	rc = smbd_negotiate(info);
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 39a56a54f8b6..8ebbbc0b0499 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -61,9 +61,6 @@ struct smbd_connection {
 	/* Used by transport to wait until all MRs are returned */
 	wait_queue_head_t wait_for_mr_cleanup;
 
-	/* Activity accounting */
-	wait_queue_head_t wait_post_send;
-
 	struct workqueue_struct *workqueue;
 };
 
-- 
2.43.0

Re: [PATCH v4 048/142] smb: client: don't check sc->send_io.pending.count is below sp->send_credit_target

[Stefan Metzmacher]

Am 25.08.25 um 22:40 schrieb Stefan Metzmacher:
> If we were able to get a credit we don't need to prove and wait
> that sc->send_io.pending.count is below sp->send_credit_target.
> 
> This just adds useless complixity. The same code on the server
> also doesn't do this, so we should remove it from the client.
> 
> This will make it easier to momve to common code later.
> 
> Cc: Steve French <smfrench@gmail.com>
> Cc: Tom Talpey <tom@talpey.com>
> Cc: Long Li <longli@microsoft.com>
> Cc: linux-cifs@vger.kernel.org
> Cc: samba-technical@lists.samba.org
> Signed-off-by: Stefan Metzmacher <metze@samba.org>
> ---
>   fs/smb/client/smbdirect.c | 28 ++++------------------------
>   fs/smb/client/smbdirect.h |  3 ---
>   2 files changed, 4 insertions(+), 27 deletions(-)
> 
> diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
> index 2eaddf190354..220ebd00a9d7 100644
> --- a/fs/smb/client/smbdirect.c
> +++ b/fs/smb/client/smbdirect.c
> @@ -414,8 +414,6 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
>   	if (atomic_dec_and_test(&sc->send_io.pending.count))
>   		wake_up(&sc->send_io.pending.wait_queue);
>   
> -	wake_up(&info->wait_post_send);
> -
>   	mempool_free(request, sc->send_io.mem.pool);
>   }
>   
> @@ -1035,23 +1033,6 @@ static int smbd_post_send_iter(struct smbd_connection *info,
>   		goto wait_credit;
>   	}
>   
> -wait_send_queue:
> -	wait_event(info->wait_post_send,
> -		atomic_read(&sc->send_io.pending.count) < sp->send_credit_target ||
> -		sc->status != SMBDIRECT_SOCKET_CONNECTED);
> -
> -	if (sc->status != SMBDIRECT_SOCKET_CONNECTED) {
> -		log_outgoing(ERR, "disconnected not sending on wait_send_queue\n");
> -		rc = -EAGAIN;
> -		goto err_wait_send_queue;
> -	}
> -
> -	if (unlikely(atomic_inc_return(&sc->send_io.pending.count) >
> -				sp->send_credit_target)) {
> -		atomic_dec(&sc->send_io.pending.count);
> -		goto wait_send_queue;
> -	}
> -

I'll drop this change for now, as I found commit 3ffbe78aff93
("cifs: smbd: Check send queue size before posting a send")

Instead I'll change info->wait_post_send into sc->pending.dec_wait_queue.

I'll look at it again when moving to common functions, but for now
I better try to avoid changing the logic here and we may need to
add something like this to the server too.

While debugging the problem that lead to these fixes:
smb: server: let smb_direct_writev() respect SMB_DIRECT_MAX_SEND_SGES
https://lore.kernel.org/linux-cifs/20250904181059.1594876-1-metze@samba.org/
and RDMA/siw: avoid hiding errors in siw_post_send()
https://lore.kernel.org/linux-rdma/20250904173608.1590444-1-metze@samba.org/
I first thought that exactly the above logic was missing in the server...

metze

[PATCH v4 049/142] smb: client: move rdma_readwrite_threshold from smbd_connection to TCP_Server_Info

[Stefan Metzmacher]

This belongs to the SMB layer not to the transport layer, it
just uses the negotiated transport parameters to adjust the
value if needed.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/cifs_debug.c |  2 +-
 fs/smb/client/cifsglob.h   |  7 +++++++
 fs/smb/client/smb2pdu.c    |  2 +-
 fs/smb/client/smbdirect.c  | 15 +++++++++++----
 fs/smb/client/smbdirect.h  |  7 -------
 5 files changed, 20 insertions(+), 13 deletions(-)

diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
index bb6bb1e3b723..eca7bd0df7d3 100644
--- a/fs/smb/client/cifs_debug.c
+++ b/fs/smb/client/cifs_debug.c
@@ -459,7 +459,7 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
 			"max_readwrite_size: %x rdma_readwrite_threshold: %x",
 			sp->keepalive_interval_msec * 1000,
 			sp->max_read_write_size,
-			server->smbd_conn->rdma_readwrite_threshold);
+			server->rdma_readwrite_threshold);
 		seq_printf(m, "\nDebug count_get_receive_buffer: %llx "
 			"count_put_receive_buffer: %llx count_send_empty: %llx",
 			sc->statistics.get_receive_buffer,
diff --git a/fs/smb/client/cifsglob.h b/fs/smb/client/cifsglob.h
index 1e64a4fb6af0..f87a1ca33592 100644
--- a/fs/smb/client/cifsglob.h
+++ b/fs/smb/client/cifsglob.h
@@ -814,6 +814,13 @@ struct TCP_Server_Info {
 	unsigned int	max_read;
 	unsigned int	max_write;
 	unsigned int	min_offload;
+	/*
+	 * If payload is less than or equal to the threshold,
+	 * use RDMA send/recv to send upper layer I/O.
+	 * If payload is more than the threshold,
+	 * use RDMA read/write through memory registration for I/O.
+	 */
+	unsigned int	rdma_readwrite_threshold;
 	unsigned int	retrans;
 	struct {
 		bool requested; /* "compress" mount option set*/
diff --git a/fs/smb/client/smb2pdu.c b/fs/smb/client/smb2pdu.c
index 2df93a75e3b8..0dedea47bf96 100644
--- a/fs/smb/client/smb2pdu.c
+++ b/fs/smb/client/smb2pdu.c
@@ -4411,7 +4411,7 @@ static inline bool smb3_use_rdma_offload(struct cifs_io_parms *io_parms)
 		return false;
 
 	/* offload also has its overhead, so only do it if desired */
-	if (io_parms->length < server->smbd_conn->rdma_readwrite_threshold)
+	if (io_parms->length < server->rdma_readwrite_threshold)
 		return false;
 
 	return true;
diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 220ebd00a9d7..0eb46b01da32 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -489,10 +489,6 @@ static bool process_negotiation_response(
 	}
 	sp->max_fragmented_send_size =
 		le32_to_cpu(packet->max_fragmented_size);
-	info->rdma_readwrite_threshold =
-		rdma_readwrite_threshold > sp->max_fragmented_send_size ?
-		sp->max_fragmented_send_size :
-		rdma_readwrite_threshold;
 
 
 	sp->max_read_write_size = min_t(u32,
@@ -1898,6 +1894,7 @@ struct smbd_connection *smbd_get_connection(
 	struct TCP_Server_Info *server, struct sockaddr *dstaddr)
 {
 	struct smbd_connection *ret;
+	const struct smbdirect_socket_parameters *sp;
 	int port = SMBD_PORT;
 
 try_again:
@@ -1908,6 +1905,16 @@ struct smbd_connection *smbd_get_connection(
 		port = SMB_PORT;
 		goto try_again;
 	}
+	if (!ret)
+		return NULL;
+
+	sp = &ret->socket.parameters;
+
+	server->rdma_readwrite_threshold =
+		rdma_readwrite_threshold > sp->max_fragmented_send_size ?
+		sp->max_fragmented_send_size :
+		rdma_readwrite_threshold;
+
 	return ret;
 }
 
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 8ebbbc0b0499..4eec2ac4ba80 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -43,13 +43,6 @@ struct smbd_connection {
 	/* Memory registrations */
 	/* Maximum number of pages in a single RDMA write/read on this connection */
 	int max_frmr_depth;
-	/*
-	 * If payload is less than or equal to the threshold,
-	 * use RDMA send/recv to send upper layer I/O.
-	 * If payload is more than the threshold,
-	 * use RDMA read/write through memory registration for I/O.
-	 */
-	int rdma_readwrite_threshold;
 	enum ib_mr_type mr_type;
 	struct list_head mr_list;
 	spinlock_t mr_list_lock;
-- 
2.43.0

[PATCH v4 050/142] smb: client: make use of smbdirect_socket.workqueue

[Stefan Metzmacher]

This will simplify the move to common code...

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 32 ++++++++++++++++----------------
 fs/smb/client/smbdirect.h |  2 --
 2 files changed, 16 insertions(+), 18 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 0eb46b01da32..7a1ae4704ab0 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -213,7 +213,7 @@ static void smbd_disconnect_rdma_connection(struct smbd_connection *info)
 {
 	struct smbdirect_socket *sc = &info->socket;
 
-	queue_work(info->workqueue, &sc->disconnect_work);
+	queue_work(sc->workqueue, &sc->disconnect_work);
 }
 
 /* Upcall from RDMA CM */
@@ -537,7 +537,7 @@ static void smbd_post_send_credits(struct work_struct *work)
 	if (atomic_read(&sc->recv_io.credits.count) <
 		sc->recv_io.credits.target - 1) {
 		log_keep_alive(INFO, "schedule send of an empty message\n");
-		queue_work(info->workqueue, &sc->idle.immediate_work);
+		queue_work(sc->workqueue, &sc->idle.immediate_work);
 	}
 }
 
@@ -579,7 +579,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	 * order to trigger our next keepalive message.
 	 */
 	sc->idle.keepalive = SMBDIRECT_KEEPALIVE_NONE;
-	mod_delayed_work(info->workqueue, &sc->idle.timer_work,
+	mod_delayed_work(sc->workqueue, &sc->idle.timer_work,
 			 msecs_to_jiffies(sp->keepalive_interval_msec));
 
 	switch (sc->recv_io.expected) {
@@ -645,7 +645,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		if (le16_to_cpu(data_transfer->flags) &
 				SMBDIRECT_FLAG_RESPONSE_REQUESTED) {
 			log_keep_alive(INFO, "schedule send of immediate response\n");
-			queue_work(info->workqueue, &sc->idle.immediate_work);
+			queue_work(sc->workqueue, &sc->idle.immediate_work);
 		}
 
 		/*
@@ -654,7 +654,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		 */
 		if (data_length) {
 			if (sc->recv_io.credits.target > old_recv_credit_target)
-				queue_work(info->workqueue, &sc->recv_io.posted.refill_work);
+				queue_work(sc->workqueue, &sc->recv_io.posted.refill_work);
 
 			enqueue_reassembly(info, response, data_length);
 			wake_up(&sc->recv_io.reassembly.wait_queue);
@@ -953,7 +953,7 @@ static int manage_keep_alive_before_sending(struct smbd_connection *info)
 		 * Now use the keepalive timeout (instead of keepalive interval)
 		 * in order to wait for a response
 		 */
-		mod_delayed_work(info->workqueue, &sc->idle.timer_work,
+		mod_delayed_work(sc->workqueue, &sc->idle.timer_work,
 				 msecs_to_jiffies(sp->keepalive_timeout_msec));
 		return 1;
 	}
@@ -1357,7 +1357,7 @@ static void put_receive_buffer(
 	sc->statistics.put_receive_buffer++;
 	spin_unlock_irqrestore(&sc->recv_io.free.lock, flags);
 
-	queue_work(info->workqueue, &sc->recv_io.posted.refill_work);
+	queue_work(sc->workqueue, &sc->recv_io.posted.refill_work);
 }
 
 /* Preallocate all receive buffer on transport establishment */
@@ -1439,10 +1439,10 @@ static void idle_connection_timer(struct work_struct *work)
 	 * in order to wait for a response
 	 */
 	sc->idle.keepalive = SMBDIRECT_KEEPALIVE_PENDING;
-	mod_delayed_work(info->workqueue, &sc->idle.timer_work,
+	mod_delayed_work(sc->workqueue, &sc->idle.timer_work,
 			 msecs_to_jiffies(sp->keepalive_timeout_msec));
 	log_keep_alive(INFO, "schedule send of empty idle message\n");
-	queue_work(info->workqueue, &sc->idle.immediate_work);
+	queue_work(sc->workqueue, &sc->idle.immediate_work);
 }
 
 /*
@@ -1537,7 +1537,7 @@ void smbd_destroy(struct TCP_Server_Info *server)
 
 	sc->status = SMBDIRECT_SOCKET_DESTROYED;
 
-	destroy_workqueue(info->workqueue);
+	destroy_workqueue(sc->workqueue);
 	log_rdma_event(INFO,  "rdma session destroyed\n");
 	kfree(info);
 	server->smbd_conn = NULL;
@@ -1584,7 +1584,7 @@ static void destroy_caches_and_workqueue(struct smbd_connection *info)
 	struct smbdirect_socket *sc = &info->socket;
 
 	destroy_receive_buffers(info);
-	destroy_workqueue(info->workqueue);
+	destroy_workqueue(sc->workqueue);
 	mempool_destroy(sc->recv_io.mem.pool);
 	kmem_cache_destroy(sc->recv_io.mem.cache);
 	mempool_destroy(sc->send_io.mem.pool);
@@ -1640,8 +1640,8 @@ static int allocate_caches_and_workqueue(struct smbd_connection *info)
 		goto out3;
 
 	scnprintf(name, MAX_NAME_LEN, "smbd_%p", info);
-	info->workqueue = create_workqueue(name);
-	if (!info->workqueue)
+	sc->workqueue = create_workqueue(name);
+	if (!sc->workqueue)
 		goto out4;
 
 	rc = allocate_receive_buffers(info, sp->recv_credit_max);
@@ -1653,7 +1653,7 @@ static int allocate_caches_and_workqueue(struct smbd_connection *info)
 	return 0;
 
 out5:
-	destroy_workqueue(info->workqueue);
+	destroy_workqueue(sc->workqueue);
 out4:
 	mempool_destroy(sc->recv_io.mem.pool);
 out3:
@@ -1837,7 +1837,7 @@ static struct smbd_connection *_smbd_get_connection(
 	 * so that the timer will cause a disconnect.
 	 */
 	sc->idle.keepalive = SMBDIRECT_KEEPALIVE_PENDING;
-	mod_delayed_work(info->workqueue, &sc->idle.timer_work,
+	mod_delayed_work(sc->workqueue, &sc->idle.timer_work,
 			 msecs_to_jiffies(sp->negotiate_timeout_msec));
 
 	INIT_WORK(&sc->recv_io.posted.refill_work, smbd_post_send_credits);
@@ -2541,7 +2541,7 @@ int smbd_deregister_mr(struct smbd_mr *smbdirect_mr)
 		 * Schedule the work to do MR recovery for future I/Os MR
 		 * recovery is slow and don't want it to block current I/O
 		 */
-		queue_work(info->workqueue, &info->mr_recovery_work);
+		queue_work(sc->workqueue, &info->mr_recovery_work);
 
 done:
 	if (atomic_dec_and_test(&info->mr_used_count))
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 4eec2ac4ba80..455618e676f5 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -53,8 +53,6 @@ struct smbd_connection {
 	struct work_struct mr_recovery_work;
 	/* Used by transport to wait until all MRs are returned */
 	wait_queue_head_t wait_for_mr_cleanup;
-
-	struct workqueue_struct *workqueue;
 };
 
 /* Create a SMBDirect session */
-- 
2.43.0

[PATCH v4 051/142] smb: client: add and use smbd_get_parameters()

[Stefan Metzmacher]

In future struct smbdirect_socket_parameters will be the only
public structure for the smb layer. This prepares this...

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smb2ops.c   | 8 ++++----
 fs/smb/client/smbdirect.c | 7 +++++++
 fs/smb/client/smbdirect.h | 2 ++
 3 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/fs/smb/client/smb2ops.c b/fs/smb/client/smb2ops.c
index 94b1d7a395d5..87b6254e1e73 100644
--- a/fs/smb/client/smb2ops.c
+++ b/fs/smb/client/smb2ops.c
@@ -504,8 +504,8 @@ smb3_negotiate_wsize(struct cifs_tcon *tcon, struct smb3_fs_context *ctx)
 	wsize = min_t(unsigned int, wsize, server->max_write);
 #ifdef CONFIG_CIFS_SMB_DIRECT
 	if (server->rdma) {
-		struct smbdirect_socket_parameters *sp =
-			&server->smbd_conn->socket.parameters;
+		const struct smbdirect_socket_parameters *sp =
+			smbd_get_parameters(server->smbd_conn);
 
 		if (server->sign)
 			/*
@@ -555,8 +555,8 @@ smb3_negotiate_rsize(struct cifs_tcon *tcon, struct smb3_fs_context *ctx)
 	rsize = min_t(unsigned int, rsize, server->max_read);
 #ifdef CONFIG_CIFS_SMB_DIRECT
 	if (server->rdma) {
-		struct smbdirect_socket_parameters *sp =
-			&server->smbd_conn->socket.parameters;
+		const struct smbdirect_socket_parameters *sp =
+			smbd_get_parameters(server->smbd_conn);
 
 		if (server->sign)
 			/*
diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 7a1ae4704ab0..be4e90755a6c 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -13,6 +13,13 @@
 #include "cifsproto.h"
 #include "smb2proto.h"
 
+const struct smbdirect_socket_parameters *smbd_get_parameters(struct smbd_connection *conn)
+{
+	struct smbdirect_socket *sc = &conn->socket;
+
+	return &sc->parameters;
+}
+
 static struct smbdirect_recv_io *get_receive_buffer(
 		struct smbd_connection *info);
 static void put_receive_buffer(
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 455618e676f5..7773939db5f2 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -59,6 +59,8 @@ struct smbd_connection {
 struct smbd_connection *smbd_get_connection(
 	struct TCP_Server_Info *server, struct sockaddr *dstaddr);
 
+const struct smbdirect_socket_parameters *smbd_get_parameters(struct smbd_connection *conn);
+
 /* Reconnect SMBDirect session */
 int smbd_reconnect(struct TCP_Server_Info *server);
 /* Destroy SMBDirect session */
-- 
2.43.0

[PATCH v4 052/142] smb: client: make use of struct smbdirect_mr_io

[Stefan Metzmacher]

This will allow us to move to common functions in future too.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/cifsglob.h  |  2 +-
 fs/smb/client/smbdirect.c | 66 ++++++++++++++++++++-------------------
 fs/smb/client/smbdirect.h | 27 ++--------------
 3 files changed, 37 insertions(+), 58 deletions(-)

diff --git a/fs/smb/client/cifsglob.h b/fs/smb/client/cifsglob.h
index f87a1ca33592..6df6acb7617f 100644
--- a/fs/smb/client/cifsglob.h
+++ b/fs/smb/client/cifsglob.h
@@ -1547,7 +1547,7 @@ struct cifs_io_subrequest {
 	struct kvec			iov[2];
 	struct TCP_Server_Info		*server;
 #ifdef CONFIG_CIFS_SMB_DIRECT
-	struct smbd_mr			*mr;
+	struct smbdirect_mr_io		*mr;
 #endif
 	struct cifs_credits		credits;
 };
diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index be4e90755a6c..1a1acc0ee4b0 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -2165,14 +2165,15 @@ int smbd_send(struct TCP_Server_Info *server,
 
 static void register_mr_done(struct ib_cq *cq, struct ib_wc *wc)
 {
-	struct smbd_mr *mr;
-	struct ib_cqe *cqe;
+	struct smbdirect_mr_io *mr =
+		container_of(wc->wr_cqe, struct smbdirect_mr_io, cqe);
+	struct smbdirect_socket *sc = mr->socket;
+	struct smbd_connection *info =
+		container_of(sc, struct smbd_connection, socket);
 
 	if (wc->status) {
 		log_rdma_mr(ERR, "status=%d\n", wc->status);
-		cqe = wc->wr_cqe;
-		mr = container_of(cqe, struct smbd_mr, cqe);
-		smbd_disconnect_rdma_connection(mr->conn);
+		smbd_disconnect_rdma_connection(info);
 	}
 }
 
@@ -2190,11 +2191,11 @@ static void smbd_mr_recovery_work(struct work_struct *work)
 	struct smbd_connection *info =
 		container_of(work, struct smbd_connection, mr_recovery_work);
 	struct smbdirect_socket *sc = &info->socket;
-	struct smbd_mr *smbdirect_mr;
+	struct smbdirect_mr_io *smbdirect_mr;
 	int rc;
 
 	list_for_each_entry(smbdirect_mr, &info->mr_list, list) {
-		if (smbdirect_mr->state == MR_ERROR) {
+		if (smbdirect_mr->state == SMBDIRECT_MR_ERROR) {
 
 			/* recover this MR entry */
 			rc = ib_dereg_mr(smbdirect_mr->mr);
@@ -2220,7 +2221,7 @@ static void smbd_mr_recovery_work(struct work_struct *work)
 			/* This MR is being used, don't recover it */
 			continue;
 
-		smbdirect_mr->state = MR_READY;
+		smbdirect_mr->state = SMBDIRECT_MR_READY;
 
 		/* smbdirect_mr->state is updated by this function
 		 * and is read and updated by I/O issuing CPUs trying
@@ -2237,11 +2238,11 @@ static void smbd_mr_recovery_work(struct work_struct *work)
 static void destroy_mr_list(struct smbd_connection *info)
 {
 	struct smbdirect_socket *sc = &info->socket;
-	struct smbd_mr *mr, *tmp;
+	struct smbdirect_mr_io *mr, *tmp;
 
 	disable_work_sync(&info->mr_recovery_work);
 	list_for_each_entry_safe(mr, tmp, &info->mr_list, list) {
-		if (mr->state == MR_INVALIDATED)
+		if (mr->state == SMBDIRECT_MR_INVALIDATED)
 			ib_dma_unmap_sg(sc->ib.dev, mr->sgt.sgl,
 				mr->sgt.nents, mr->dir);
 		ib_dereg_mr(mr->mr);
@@ -2262,7 +2263,7 @@ static int allocate_mr_list(struct smbd_connection *info)
 	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	int i;
-	struct smbd_mr *smbdirect_mr, *tmp;
+	struct smbdirect_mr_io *smbdirect_mr, *tmp;
 
 	INIT_LIST_HEAD(&info->mr_list);
 	init_waitqueue_head(&info->wait_mr);
@@ -2297,8 +2298,8 @@ static int allocate_mr_list(struct smbd_connection *info)
 			ib_dereg_mr(smbdirect_mr->mr);
 			goto out;
 		}
-		smbdirect_mr->state = MR_READY;
-		smbdirect_mr->conn = info;
+		smbdirect_mr->state = SMBDIRECT_MR_READY;
+		smbdirect_mr->socket = sc;
 
 		list_add_tail(&smbdirect_mr->list, &info->mr_list);
 		atomic_inc(&info->mr_ready_count);
@@ -2325,10 +2326,10 @@ static int allocate_mr_list(struct smbd_connection *info)
  * issuing I/O trying to get MR at the same time, mr_list_lock is used to
  * protect this situation.
  */
-static struct smbd_mr *get_mr(struct smbd_connection *info)
+static struct smbdirect_mr_io *get_mr(struct smbd_connection *info)
 {
 	struct smbdirect_socket *sc = &info->socket;
-	struct smbd_mr *ret;
+	struct smbdirect_mr_io *ret;
 	int rc;
 again:
 	rc = wait_event_interruptible(info->wait_mr,
@@ -2346,8 +2347,8 @@ static struct smbd_mr *get_mr(struct smbd_connection *info)
 
 	spin_lock(&info->mr_list_lock);
 	list_for_each_entry(ret, &info->mr_list, list) {
-		if (ret->state == MR_READY) {
-			ret->state = MR_REGISTERED;
+		if (ret->state == SMBDIRECT_MR_READY) {
+			ret->state = SMBDIRECT_MR_REGISTERED;
 			spin_unlock(&info->mr_list_lock);
 			atomic_dec(&info->mr_ready_count);
 			atomic_inc(&info->mr_used_count);
@@ -2389,12 +2390,12 @@ static int smbd_iter_to_mr(struct smbd_connection *info,
  * need_invalidate: true if this MR needs to be locally invalidated after I/O
  * return value: the MR registered, NULL if failed.
  */
-struct smbd_mr *smbd_register_mr(struct smbd_connection *info,
+struct smbdirect_mr_io *smbd_register_mr(struct smbd_connection *info,
 				 struct iov_iter *iter,
 				 bool writing, bool need_invalidate)
 {
 	struct smbdirect_socket *sc = &info->socket;
-	struct smbd_mr *smbdirect_mr;
+	struct smbdirect_mr_io *smbdirect_mr;
 	int rc, num_pages;
 	enum dma_data_direction dir;
 	struct ib_reg_wr *reg_wr;
@@ -2466,13 +2467,13 @@ struct smbd_mr *smbd_register_mr(struct smbd_connection *info,
 	log_rdma_mr(ERR, "ib_post_send failed rc=%x reg_wr->key=%x\n",
 		rc, reg_wr->key);
 
-	/* If all failed, attempt to recover this MR by setting it MR_ERROR*/
+	/* If all failed, attempt to recover this MR by setting it SMBDIRECT_MR_ERROR*/
 map_mr_error:
 	ib_dma_unmap_sg(sc->ib.dev, smbdirect_mr->sgt.sgl,
 			smbdirect_mr->sgt.nents, smbdirect_mr->dir);
 
 dma_map_error:
-	smbdirect_mr->state = MR_ERROR;
+	smbdirect_mr->state = SMBDIRECT_MR_ERROR;
 	if (atomic_dec_and_test(&info->mr_used_count))
 		wake_up(&info->wait_for_mr_cleanup);
 
@@ -2483,15 +2484,15 @@ struct smbd_mr *smbd_register_mr(struct smbd_connection *info,
 
 static void local_inv_done(struct ib_cq *cq, struct ib_wc *wc)
 {
-	struct smbd_mr *smbdirect_mr;
+	struct smbdirect_mr_io *smbdirect_mr;
 	struct ib_cqe *cqe;
 
 	cqe = wc->wr_cqe;
-	smbdirect_mr = container_of(cqe, struct smbd_mr, cqe);
-	smbdirect_mr->state = MR_INVALIDATED;
+	smbdirect_mr = container_of(cqe, struct smbdirect_mr_io, cqe);
+	smbdirect_mr->state = SMBDIRECT_MR_INVALIDATED;
 	if (wc->status != IB_WC_SUCCESS) {
 		log_rdma_mr(ERR, "invalidate failed status=%x\n", wc->status);
-		smbdirect_mr->state = MR_ERROR;
+		smbdirect_mr->state = SMBDIRECT_MR_ERROR;
 	}
 	complete(&smbdirect_mr->invalidate_done);
 }
@@ -2502,11 +2503,12 @@ static void local_inv_done(struct ib_cq *cq, struct ib_wc *wc)
  * and we have to locally invalidate the buffer to prevent data is being
  * modified by remote peer after upper layer consumes it
  */
-int smbd_deregister_mr(struct smbd_mr *smbdirect_mr)
+int smbd_deregister_mr(struct smbdirect_mr_io *smbdirect_mr)
 {
 	struct ib_send_wr *wr;
-	struct smbd_connection *info = smbdirect_mr->conn;
-	struct smbdirect_socket *sc = &info->socket;
+	struct smbdirect_socket *sc = smbdirect_mr->socket;
+	struct smbd_connection *info =
+		container_of(sc, struct smbd_connection, socket);
 	int rc = 0;
 
 	if (smbdirect_mr->need_invalidate) {
@@ -2530,17 +2532,17 @@ int smbd_deregister_mr(struct smbd_mr *smbdirect_mr)
 		smbdirect_mr->need_invalidate = false;
 	} else
 		/*
-		 * For remote invalidation, just set it to MR_INVALIDATED
+		 * For remote invalidation, just set it to SMBDIRECT_MR_INVALIDATED
 		 * and defer to mr_recovery_work to recover the MR for next use
 		 */
-		smbdirect_mr->state = MR_INVALIDATED;
+		smbdirect_mr->state = SMBDIRECT_MR_INVALIDATED;
 
-	if (smbdirect_mr->state == MR_INVALIDATED) {
+	if (smbdirect_mr->state == SMBDIRECT_MR_INVALIDATED) {
 		ib_dma_unmap_sg(
 			sc->ib.dev, smbdirect_mr->sgt.sgl,
 			smbdirect_mr->sgt.nents,
 			smbdirect_mr->dir);
-		smbdirect_mr->state = MR_READY;
+		smbdirect_mr->state = SMBDIRECT_MR_READY;
 		if (atomic_inc_return(&info->mr_ready_count) == 1)
 			wake_up(&info->wait_mr);
 	} else
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 7773939db5f2..83e726967b2f 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -71,34 +71,11 @@ int smbd_recv(struct smbd_connection *info, struct msghdr *msg);
 int smbd_send(struct TCP_Server_Info *server,
 	int num_rqst, struct smb_rqst *rqst);
 
-enum mr_state {
-	MR_READY,
-	MR_REGISTERED,
-	MR_INVALIDATED,
-	MR_ERROR
-};
-
-struct smbd_mr {
-	struct smbd_connection	*conn;
-	struct list_head	list;
-	enum mr_state		state;
-	struct ib_mr		*mr;
-	struct sg_table		sgt;
-	enum dma_data_direction	dir;
-	union {
-		struct ib_reg_wr	wr;
-		struct ib_send_wr	inv_wr;
-	};
-	struct ib_cqe		cqe;
-	bool			need_invalidate;
-	struct completion	invalidate_done;
-};
-
 /* Interfaces to register and deregister MR for RDMA read/write */
-struct smbd_mr *smbd_register_mr(
+struct smbdirect_mr_io *smbd_register_mr(
 	struct smbd_connection *info, struct iov_iter *iter,
 	bool writing, bool need_invalidate);
-int smbd_deregister_mr(struct smbd_mr *mr);
+int smbd_deregister_mr(struct smbdirect_mr_io *mr);
 
 #else
 #define cifs_rdma_enabled(server)	0
-- 
2.43.0

[PATCH v4 053/142] smb: client: make use of smbdirect_socket_parameters.max_frmr_depth

[Stefan Metzmacher]

This make it easier to have common code later.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/cifs_debug.c |  2 +-
 fs/smb/client/file.c       | 16 ++++++++++++----
 fs/smb/client/smbdirect.c  | 34 ++++++++++++++++++----------------
 fs/smb/client/smbdirect.h  |  2 --
 4 files changed, 31 insertions(+), 23 deletions(-)

diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
index eca7bd0df7d3..060d47ccec2a 100644
--- a/fs/smb/client/cifs_debug.c
+++ b/fs/smb/client/cifs_debug.c
@@ -484,7 +484,7 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
 		seq_printf(m, "\nMR responder_resources: %x "
 			"max_frmr_depth: %x mr_type: %x",
 			sp->responder_resources,
-			server->smbd_conn->max_frmr_depth,
+			sp->max_frmr_depth,
 			server->smbd_conn->mr_type);
 		seq_printf(m, "\nMR mr_ready_count: %x mr_used_count: %x",
 			atomic_read(&server->smbd_conn->mr_ready_count),
diff --git a/fs/smb/client/file.c b/fs/smb/client/file.c
index 186e061068be..f9a8790d3fe8 100644
--- a/fs/smb/client/file.c
+++ b/fs/smb/client/file.c
@@ -97,8 +97,12 @@ static void cifs_prepare_write(struct netfs_io_subrequest *subreq)
 			      cifs_trace_rw_credits_write_prepare);
 
 #ifdef CONFIG_CIFS_SMB_DIRECT
-	if (server->smbd_conn)
-		stream->sreq_max_segs = server->smbd_conn->max_frmr_depth;
+	if (server->smbd_conn) {
+		const struct smbdirect_socket_parameters *sp =
+			smbd_get_parameters(server->smbd_conn);
+
+		stream->sreq_max_segs = sp->max_frmr_depth;
+	}
 #endif
 }
 
@@ -187,8 +191,12 @@ static int cifs_prepare_read(struct netfs_io_subrequest *subreq)
 			      cifs_trace_rw_credits_read_submit);
 
 #ifdef CONFIG_CIFS_SMB_DIRECT
-	if (server->smbd_conn)
-		rreq->io_streams[0].sreq_max_segs = server->smbd_conn->max_frmr_depth;
+	if (server->smbd_conn) {
+		const struct smbdirect_socket_parameters *sp =
+			smbd_get_parameters(server->smbd_conn);
+
+		rreq->io_streams[0].sreq_max_segs = sp->max_frmr_depth;
+	}
 #endif
 	return 0;
 }
diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 1a1acc0ee4b0..db6e8b5e8352 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -443,8 +443,6 @@ static bool process_negotiation_response(
 		struct smbdirect_recv_io *response, int packet_length)
 {
 	struct smbdirect_socket *sc = response->socket;
-	struct smbd_connection *info =
-		container_of(sc, struct smbd_connection, socket);
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct smbdirect_negotiate_resp *packet = smbdirect_recv_io_payload(response);
 
@@ -500,8 +498,8 @@ static bool process_negotiation_response(
 
 	sp->max_read_write_size = min_t(u32,
 			le32_to_cpu(packet->max_readwrite_size),
-			info->max_frmr_depth * PAGE_SIZE);
-	info->max_frmr_depth = sp->max_read_write_size / PAGE_SIZE;
+			sp->max_frmr_depth * PAGE_SIZE);
+	sp->max_frmr_depth = sp->max_read_write_size / PAGE_SIZE;
 
 	sc->recv_io.expected = SMBDIRECT_EXPECT_DATA_TRANSFER;
 	return true;
@@ -791,6 +789,7 @@ static int smbd_ia_open(
 		struct sockaddr *dstaddr, int port)
 {
 	struct smbdirect_socket *sc = &info->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	int rc;
 
 	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_CREATED);
@@ -811,8 +810,8 @@ static int smbd_ia_open(
 		rc = -EPROTONOSUPPORT;
 		goto out2;
 	}
-	info->max_frmr_depth = min_t(int,
-		smbd_max_frmr_depth,
+	sp->max_frmr_depth = min_t(u32,
+		sp->max_frmr_depth,
 		sc->ib.dev->attrs.max_fast_reg_page_list_len);
 	info->mr_type = IB_MR_TYPE_MEM_REG;
 	if (sc->ib.dev->attrs.kernel_cap_flags & IBK_SG_GAPS_REG)
@@ -1706,6 +1705,7 @@ static struct smbd_connection *_smbd_get_connection(
 	sp->max_send_size = smbd_max_send_size;
 	sp->max_fragmented_recv_size = smbd_max_fragmented_recv_size;
 	sp->max_recv_size = smbd_max_receive_size;
+	sp->max_frmr_depth = smbd_max_frmr_depth;
 	sp->keepalive_interval_msec = smbd_keep_alive_interval * 1000;
 	sp->keepalive_timeout_msec = KEEPALIVE_RECV_TIMEOUT * 1000;
 
@@ -2191,6 +2191,7 @@ static void smbd_mr_recovery_work(struct work_struct *work)
 	struct smbd_connection *info =
 		container_of(work, struct smbd_connection, mr_recovery_work);
 	struct smbdirect_socket *sc = &info->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct smbdirect_mr_io *smbdirect_mr;
 	int rc;
 
@@ -2209,11 +2210,11 @@ static void smbd_mr_recovery_work(struct work_struct *work)
 
 			smbdirect_mr->mr = ib_alloc_mr(
 				sc->ib.pd, info->mr_type,
-				info->max_frmr_depth);
+				sp->max_frmr_depth);
 			if (IS_ERR(smbdirect_mr->mr)) {
 				log_rdma_mr(ERR, "ib_alloc_mr failed mr_type=%x max_frmr_depth=%x\n",
 					    info->mr_type,
-					    info->max_frmr_depth);
+					    sp->max_frmr_depth);
 				smbd_disconnect_rdma_connection(info);
 				continue;
 			}
@@ -2284,13 +2285,13 @@ static int allocate_mr_list(struct smbd_connection *info)
 		if (!smbdirect_mr)
 			goto cleanup_entries;
 		smbdirect_mr->mr = ib_alloc_mr(sc->ib.pd, info->mr_type,
-					info->max_frmr_depth);
+					sp->max_frmr_depth);
 		if (IS_ERR(smbdirect_mr->mr)) {
 			log_rdma_mr(ERR, "ib_alloc_mr failed mr_type=%x max_frmr_depth=%x\n",
-				    info->mr_type, info->max_frmr_depth);
+				    info->mr_type, sp->max_frmr_depth);
 			goto out;
 		}
-		smbdirect_mr->sgt.sgl = kcalloc(info->max_frmr_depth,
+		smbdirect_mr->sgt.sgl = kcalloc(sp->max_frmr_depth,
 						sizeof(struct scatterlist),
 						GFP_KERNEL);
 		if (!smbdirect_mr->sgt.sgl) {
@@ -2395,15 +2396,16 @@ struct smbdirect_mr_io *smbd_register_mr(struct smbd_connection *info,
 				 bool writing, bool need_invalidate)
 {
 	struct smbdirect_socket *sc = &info->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct smbdirect_mr_io *smbdirect_mr;
 	int rc, num_pages;
 	enum dma_data_direction dir;
 	struct ib_reg_wr *reg_wr;
 
-	num_pages = iov_iter_npages(iter, info->max_frmr_depth + 1);
-	if (num_pages > info->max_frmr_depth) {
+	num_pages = iov_iter_npages(iter, sp->max_frmr_depth + 1);
+	if (num_pages > sp->max_frmr_depth) {
 		log_rdma_mr(ERR, "num_pages=%d max_frmr_depth=%d\n",
-			num_pages, info->max_frmr_depth);
+			num_pages, sp->max_frmr_depth);
 		WARN_ON_ONCE(1);
 		return NULL;
 	}
@@ -2421,8 +2423,8 @@ struct smbdirect_mr_io *smbd_register_mr(struct smbd_connection *info,
 	smbdirect_mr->sgt.orig_nents = 0;
 
 	log_rdma_mr(INFO, "num_pages=0x%x count=0x%zx depth=%u\n",
-		    num_pages, iov_iter_count(iter), info->max_frmr_depth);
-	smbd_iter_to_mr(info, iter, &smbdirect_mr->sgt, info->max_frmr_depth);
+		    num_pages, iov_iter_count(iter), sp->max_frmr_depth);
+	smbd_iter_to_mr(info, iter, &smbdirect_mr->sgt, sp->max_frmr_depth);
 
 	rc = ib_dma_map_sg(sc->ib.dev, smbdirect_mr->sgt.sgl,
 			   smbdirect_mr->sgt.nents, dir);
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index 83e726967b2f..c88ba6e11dd1 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -41,8 +41,6 @@ struct smbd_connection {
 
 
 	/* Memory registrations */
-	/* Maximum number of pages in a single RDMA write/read on this connection */
-	int max_frmr_depth;
 	enum ib_mr_type mr_type;
 	struct list_head mr_list;
 	spinlock_t mr_list_lock;
-- 
2.43.0

[PATCH v4 054/142] smb: client: make use of smbdirect_socket.mr_io

[Stefan Metzmacher]

Now struct smbd_connection only contains struct smbdirect_socket,
this is an important step towards having common functions as well.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/cifs_debug.c |  6 +--
 fs/smb/client/smbdirect.c  | 81 +++++++++++++++++---------------------
 fs/smb/client/smbdirect.h  | 13 ------
 3 files changed, 40 insertions(+), 60 deletions(-)

diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
index 060d47ccec2a..69343bf9cf1b 100644
--- a/fs/smb/client/cifs_debug.c
+++ b/fs/smb/client/cifs_debug.c
@@ -485,10 +485,10 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
 			"max_frmr_depth: %x mr_type: %x",
 			sp->responder_resources,
 			sp->max_frmr_depth,
-			server->smbd_conn->mr_type);
+			sc->mr_io.type);
 		seq_printf(m, "\nMR mr_ready_count: %x mr_used_count: %x",
-			atomic_read(&server->smbd_conn->mr_ready_count),
-			atomic_read(&server->smbd_conn->mr_used_count));
+			atomic_read(&sc->mr_io.ready.count),
+			atomic_read(&sc->mr_io.used.count));
 skip_rdma:
 #endif
 		seq_printf(m, "\nNumber of credits: %d,%d,%d Dialect 0x%x",
diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index db6e8b5e8352..205fd57272fa 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -169,8 +169,6 @@ static void smbd_disconnect_rdma_work(struct work_struct *work)
 {
 	struct smbdirect_socket *sc =
 		container_of(work, struct smbdirect_socket, disconnect_work);
-	struct smbd_connection *info =
-		container_of(sc, struct smbd_connection, socket);
 
 	/*
 	 * make sure this and other work is not queued again
@@ -179,7 +177,7 @@ static void smbd_disconnect_rdma_work(struct work_struct *work)
 	 */
 	disable_work(&sc->disconnect_work);
 	disable_work(&sc->recv_io.posted.refill_work);
-	disable_work(&info->mr_recovery_work);
+	disable_work(&sc->mr_io.recovery_work);
 	disable_work(&sc->idle.immediate_work);
 	disable_delayed_work(&sc->idle.timer_work);
 
@@ -813,9 +811,9 @@ static int smbd_ia_open(
 	sp->max_frmr_depth = min_t(u32,
 		sp->max_frmr_depth,
 		sc->ib.dev->attrs.max_fast_reg_page_list_len);
-	info->mr_type = IB_MR_TYPE_MEM_REG;
+	sc->mr_io.type = IB_MR_TYPE_MEM_REG;
 	if (sc->ib.dev->attrs.kernel_cap_flags & IBK_SG_GAPS_REG)
-		info->mr_type = IB_MR_TYPE_SG_GAPS;
+		sc->mr_io.type = IB_MR_TYPE_SG_GAPS;
 
 	sc->ib.pd = ib_alloc_pd(sc->ib.dev, 0);
 	if (IS_ERR(sc->ib.pd)) {
@@ -1521,8 +1519,8 @@ void smbd_destroy(struct TCP_Server_Info *server)
 	 * path when sending data, and then release memory registrations.
 	 */
 	log_rdma_event(INFO, "freeing mr list\n");
-	wake_up_all(&info->wait_mr);
-	while (atomic_read(&info->mr_used_count)) {
+	wake_up_all(&sc->mr_io.ready.wait_queue);
+	while (atomic_read(&sc->mr_io.used.count)) {
 		cifs_server_unlock(server);
 		msleep(1000);
 		cifs_server_lock(server);
@@ -2188,14 +2186,15 @@ static void register_mr_done(struct ib_cq *cq, struct ib_wc *wc)
  */
 static void smbd_mr_recovery_work(struct work_struct *work)
 {
-	struct smbd_connection *info =
-		container_of(work, struct smbd_connection, mr_recovery_work);
-	struct smbdirect_socket *sc = &info->socket;
+	struct smbdirect_socket *sc =
+		container_of(work, struct smbdirect_socket, mr_io.recovery_work);
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
+	struct smbd_connection *info =
+		container_of(sc, struct smbd_connection, socket);
 	struct smbdirect_mr_io *smbdirect_mr;
 	int rc;
 
-	list_for_each_entry(smbdirect_mr, &info->mr_list, list) {
+	list_for_each_entry(smbdirect_mr, &sc->mr_io.all.list, list) {
 		if (smbdirect_mr->state == SMBDIRECT_MR_ERROR) {
 
 			/* recover this MR entry */
@@ -2209,11 +2208,11 @@ static void smbd_mr_recovery_work(struct work_struct *work)
 			}
 
 			smbdirect_mr->mr = ib_alloc_mr(
-				sc->ib.pd, info->mr_type,
+				sc->ib.pd, sc->mr_io.type,
 				sp->max_frmr_depth);
 			if (IS_ERR(smbdirect_mr->mr)) {
 				log_rdma_mr(ERR, "ib_alloc_mr failed mr_type=%x max_frmr_depth=%x\n",
-					    info->mr_type,
+					    sc->mr_io.type,
 					    sp->max_frmr_depth);
 				smbd_disconnect_rdma_connection(info);
 				continue;
@@ -2231,8 +2230,8 @@ static void smbd_mr_recovery_work(struct work_struct *work)
 		 * value is updated before waking up any calls to
 		 * get_mr() from the I/O issuing CPUs
 		 */
-		if (atomic_inc_return(&info->mr_ready_count) == 1)
-			wake_up(&info->wait_mr);
+		if (atomic_inc_return(&sc->mr_io.ready.count) == 1)
+			wake_up(&sc->mr_io.ready.wait_queue);
 	}
 }
 
@@ -2241,8 +2240,8 @@ static void destroy_mr_list(struct smbd_connection *info)
 	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_mr_io *mr, *tmp;
 
-	disable_work_sync(&info->mr_recovery_work);
-	list_for_each_entry_safe(mr, tmp, &info->mr_list, list) {
+	disable_work_sync(&sc->mr_io.recovery_work);
+	list_for_each_entry_safe(mr, tmp, &sc->mr_io.all.list, list) {
 		if (mr->state == SMBDIRECT_MR_INVALIDATED)
 			ib_dma_unmap_sg(sc->ib.dev, mr->sgt.sgl,
 				mr->sgt.nents, mr->dir);
@@ -2266,13 +2265,7 @@ static int allocate_mr_list(struct smbd_connection *info)
 	int i;
 	struct smbdirect_mr_io *smbdirect_mr, *tmp;
 
-	INIT_LIST_HEAD(&info->mr_list);
-	init_waitqueue_head(&info->wait_mr);
-	spin_lock_init(&info->mr_list_lock);
-	atomic_set(&info->mr_ready_count, 0);
-	atomic_set(&info->mr_used_count, 0);
-	init_waitqueue_head(&info->wait_for_mr_cleanup);
-	INIT_WORK(&info->mr_recovery_work, smbd_mr_recovery_work);
+	INIT_WORK(&sc->mr_io.recovery_work, smbd_mr_recovery_work);
 
 	if (sp->responder_resources == 0) {
 		log_rdma_mr(ERR, "responder_resources negotiated as 0\n");
@@ -2284,11 +2277,11 @@ static int allocate_mr_list(struct smbd_connection *info)
 		smbdirect_mr = kzalloc(sizeof(*smbdirect_mr), GFP_KERNEL);
 		if (!smbdirect_mr)
 			goto cleanup_entries;
-		smbdirect_mr->mr = ib_alloc_mr(sc->ib.pd, info->mr_type,
+		smbdirect_mr->mr = ib_alloc_mr(sc->ib.pd, sc->mr_io.type,
 					sp->max_frmr_depth);
 		if (IS_ERR(smbdirect_mr->mr)) {
 			log_rdma_mr(ERR, "ib_alloc_mr failed mr_type=%x max_frmr_depth=%x\n",
-				    info->mr_type, sp->max_frmr_depth);
+				    sc->mr_io.type, sp->max_frmr_depth);
 			goto out;
 		}
 		smbdirect_mr->sgt.sgl = kcalloc(sp->max_frmr_depth,
@@ -2302,15 +2295,15 @@ static int allocate_mr_list(struct smbd_connection *info)
 		smbdirect_mr->state = SMBDIRECT_MR_READY;
 		smbdirect_mr->socket = sc;
 
-		list_add_tail(&smbdirect_mr->list, &info->mr_list);
-		atomic_inc(&info->mr_ready_count);
+		list_add_tail(&smbdirect_mr->list, &sc->mr_io.all.list);
+		atomic_inc(&sc->mr_io.ready.count);
 	}
 	return 0;
 
 out:
 	kfree(smbdirect_mr);
 cleanup_entries:
-	list_for_each_entry_safe(smbdirect_mr, tmp, &info->mr_list, list) {
+	list_for_each_entry_safe(smbdirect_mr, tmp, &sc->mr_io.all.list, list) {
 		list_del(&smbdirect_mr->list);
 		ib_dereg_mr(smbdirect_mr->mr);
 		kfree(smbdirect_mr->sgt.sgl);
@@ -2333,8 +2326,8 @@ static struct smbdirect_mr_io *get_mr(struct smbd_connection *info)
 	struct smbdirect_mr_io *ret;
 	int rc;
 again:
-	rc = wait_event_interruptible(info->wait_mr,
-		atomic_read(&info->mr_ready_count) ||
+	rc = wait_event_interruptible(sc->mr_io.ready.wait_queue,
+		atomic_read(&sc->mr_io.ready.count) ||
 		sc->status != SMBDIRECT_SOCKET_CONNECTED);
 	if (rc) {
 		log_rdma_mr(ERR, "wait_event_interruptible rc=%x\n", rc);
@@ -2346,18 +2339,18 @@ static struct smbdirect_mr_io *get_mr(struct smbd_connection *info)
 		return NULL;
 	}
 
-	spin_lock(&info->mr_list_lock);
-	list_for_each_entry(ret, &info->mr_list, list) {
+	spin_lock(&sc->mr_io.all.lock);
+	list_for_each_entry(ret, &sc->mr_io.all.list, list) {
 		if (ret->state == SMBDIRECT_MR_READY) {
 			ret->state = SMBDIRECT_MR_REGISTERED;
-			spin_unlock(&info->mr_list_lock);
-			atomic_dec(&info->mr_ready_count);
-			atomic_inc(&info->mr_used_count);
+			spin_unlock(&sc->mr_io.all.lock);
+			atomic_dec(&sc->mr_io.ready.count);
+			atomic_inc(&sc->mr_io.used.count);
 			return ret;
 		}
 	}
 
-	spin_unlock(&info->mr_list_lock);
+	spin_unlock(&sc->mr_io.all.lock);
 	/*
 	 * It is possible that we could fail to get MR because other processes may
 	 * try to acquire a MR at the same time. If this is the case, retry it.
@@ -2476,8 +2469,8 @@ struct smbdirect_mr_io *smbd_register_mr(struct smbd_connection *info,
 
 dma_map_error:
 	smbdirect_mr->state = SMBDIRECT_MR_ERROR;
-	if (atomic_dec_and_test(&info->mr_used_count))
-		wake_up(&info->wait_for_mr_cleanup);
+	if (atomic_dec_and_test(&sc->mr_io.used.count))
+		wake_up(&sc->mr_io.cleanup.wait_queue);
 
 	smbd_disconnect_rdma_connection(info);
 
@@ -2545,18 +2538,18 @@ int smbd_deregister_mr(struct smbdirect_mr_io *smbdirect_mr)
 			smbdirect_mr->sgt.nents,
 			smbdirect_mr->dir);
 		smbdirect_mr->state = SMBDIRECT_MR_READY;
-		if (atomic_inc_return(&info->mr_ready_count) == 1)
-			wake_up(&info->wait_mr);
+		if (atomic_inc_return(&sc->mr_io.ready.count) == 1)
+			wake_up(&sc->mr_io.ready.wait_queue);
 	} else
 		/*
 		 * Schedule the work to do MR recovery for future I/Os MR
 		 * recovery is slow and don't want it to block current I/O
 		 */
-		queue_work(sc->workqueue, &info->mr_recovery_work);
+		queue_work(sc->workqueue, &sc->mr_io.recovery_work);
 
 done:
-	if (atomic_dec_and_test(&info->mr_used_count))
-		wake_up(&info->wait_for_mr_cleanup);
+	if (atomic_dec_and_test(&sc->mr_io.used.count))
+		wake_up(&sc->mr_io.cleanup.wait_queue);
 
 	return rc;
 }
diff --git a/fs/smb/client/smbdirect.h b/fs/smb/client/smbdirect.h
index c88ba6e11dd1..d67ac5ddaff4 100644
--- a/fs/smb/client/smbdirect.h
+++ b/fs/smb/client/smbdirect.h
@@ -38,19 +38,6 @@ extern int smbd_receive_credit_max;
  */
 struct smbd_connection {
 	struct smbdirect_socket socket;
-
-
-	/* Memory registrations */
-	enum ib_mr_type mr_type;
-	struct list_head mr_list;
-	spinlock_t mr_list_lock;
-	/* The number of available MRs ready for memory registration */
-	atomic_t mr_ready_count;
-	atomic_t mr_used_count;
-	wait_queue_head_t wait_mr;
-	struct work_struct mr_recovery_work;
-	/* Used by transport to wait until all MRs are returned */
-	wait_queue_head_t wait_for_mr_cleanup;
 };
 
 /* Create a SMBDirect session */
-- 
2.43.0

[PATCH v4 055/142] smb: client: pass struct smbdirect_socket to {get,put}_receive_buffer()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 205fd57272fa..01f4b1ee727a 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -21,9 +21,9 @@ const struct smbdirect_socket_parameters *smbd_get_parameters(struct smbd_connec
 }
 
 static struct smbdirect_recv_io *get_receive_buffer(
-		struct smbd_connection *info);
+		struct smbdirect_socket *sc);
 static void put_receive_buffer(
-		struct smbd_connection *info,
+		struct smbdirect_socket *sc,
 		struct smbdirect_recv_io *response);
 static int allocate_receive_buffers(struct smbd_connection *info, int num_buf);
 static void destroy_receive_buffers(struct smbd_connection *info);
@@ -519,7 +519,7 @@ static void smbd_post_send_credits(struct work_struct *work)
 	if (sc->recv_io.credits.target >
 		atomic_read(&sc->recv_io.credits.count)) {
 		while (true) {
-			response = get_receive_buffer(info);
+			response = get_receive_buffer(sc);
 			if (!response)
 				break;
 
@@ -528,7 +528,7 @@ static void smbd_post_send_credits(struct work_struct *work)
 			if (rc) {
 				log_rdma_recv(ERR,
 					"post_recv failed rc=%d\n", rc);
-				put_receive_buffer(info, response);
+				put_receive_buffer(sc, response);
 				break;
 			}
 
@@ -592,7 +592,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		sc->recv_io.reassembly.full_packet_received = true;
 		negotiate_done =
 			process_negotiation_response(response, wc->byte_len);
-		put_receive_buffer(info, response);
+		put_receive_buffer(sc, response);
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_NEGOTIATE_RUNNING);
 		if (!negotiate_done) {
 			sc->status = SMBDIRECT_SOCKET_NEGOTIATE_FAILED;
@@ -662,7 +662,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			enqueue_reassembly(info, response, data_length);
 			wake_up(&sc->recv_io.reassembly.wait_queue);
 		} else
-			put_receive_buffer(info, response);
+			put_receive_buffer(sc, response);
 
 		return;
 
@@ -677,7 +677,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	log_rdma_recv(ERR, "unexpected response type=%d\n", sc->recv_io.expected);
 	WARN_ON_ONCE(sc->recv_io.expected != SMBDIRECT_EXPECT_DATA_TRANSFER);
 error:
-	put_receive_buffer(info, response);
+	put_receive_buffer(sc, response);
 	smbd_disconnect_rdma_connection(info);
 }
 
@@ -1225,7 +1225,7 @@ static int smbd_negotiate(struct smbd_connection *info)
 	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	int rc;
-	struct smbdirect_recv_io *response = get_receive_buffer(info);
+	struct smbdirect_recv_io *response = get_receive_buffer(sc);
 
 	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_NEGOTIATE_NEEDED);
 	sc->status = SMBDIRECT_SOCKET_NEGOTIATE_RUNNING;
@@ -1317,9 +1317,8 @@ static struct smbdirect_recv_io *_get_first_reassembly(struct smbd_connection *i
  * pre-allocated in advance.
  * return value: the receive buffer, NULL if none is available
  */
-static struct smbdirect_recv_io *get_receive_buffer(struct smbd_connection *info)
+static struct smbdirect_recv_io *get_receive_buffer(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_recv_io *ret = NULL;
 	unsigned long flags;
 
@@ -1343,9 +1342,8 @@ static struct smbdirect_recv_io *get_receive_buffer(struct smbd_connection *info
  * receive buffer is returned.
  */
 static void put_receive_buffer(
-	struct smbd_connection *info, struct smbdirect_recv_io *response)
+	struct smbdirect_socket *sc, struct smbdirect_recv_io *response)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	unsigned long flags;
 
 	if (likely(response->sge.length != 0)) {
@@ -1400,7 +1398,7 @@ static void destroy_receive_buffers(struct smbd_connection *info)
 	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_recv_io *response;
 
-	while ((response = get_receive_buffer(info)))
+	while ((response = get_receive_buffer(sc)))
 		mempool_free(response, sc->recv_io.mem.pool);
 }
 
@@ -1501,7 +1499,7 @@ void smbd_destroy(struct TCP_Server_Info *server)
 			list_del(&response->list);
 			spin_unlock_irqrestore(
 				&sc->recv_io.reassembly.lock, flags);
-			put_receive_buffer(info, response);
+			put_receive_buffer(sc, response);
 		} else
 			spin_unlock_irqrestore(
 				&sc->recv_io.reassembly.lock, flags);
@@ -2028,7 +2026,7 @@ int smbd_recv(struct smbd_connection *info, struct msghdr *msg)
 				}
 				queue_removed++;
 				sc->statistics.dequeue_reassembly_queue++;
-				put_receive_buffer(info, response);
+				put_receive_buffer(sc, response);
 				offset = 0;
 				log_read(INFO, "put_receive_buffer offset=0\n");
 			} else
-- 
2.43.0

[PATCH v4 056/142] smb: client: pass struct smbdirect_socket to {allocate,destroy}_receive_buffers()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 01f4b1ee727a..b23e9d8fd9c4 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -25,8 +25,8 @@ static struct smbdirect_recv_io *get_receive_buffer(
 static void put_receive_buffer(
 		struct smbdirect_socket *sc,
 		struct smbdirect_recv_io *response);
-static int allocate_receive_buffers(struct smbd_connection *info, int num_buf);
-static void destroy_receive_buffers(struct smbd_connection *info);
+static int allocate_receive_buffers(struct smbdirect_socket *sc, int num_buf);
+static void destroy_receive_buffers(struct smbdirect_socket *sc);
 
 static void enqueue_reassembly(
 		struct smbd_connection *info,
@@ -1363,9 +1363,8 @@ static void put_receive_buffer(
 }
 
 /* Preallocate all receive buffer on transport establishment */
-static int allocate_receive_buffers(struct smbd_connection *info, int num_buf)
+static int allocate_receive_buffers(struct smbdirect_socket *sc, int num_buf)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_recv_io *response;
 	int i;
 
@@ -1393,9 +1392,8 @@ static int allocate_receive_buffers(struct smbd_connection *info, int num_buf)
 	return -ENOMEM;
 }
 
-static void destroy_receive_buffers(struct smbd_connection *info)
+static void destroy_receive_buffers(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_recv_io *response;
 
 	while ((response = get_receive_buffer(sc)))
@@ -1507,7 +1505,7 @@ void smbd_destroy(struct TCP_Server_Info *server)
 	sc->recv_io.reassembly.data_length = 0;
 
 	log_rdma_event(INFO, "free receive buffers\n");
-	destroy_receive_buffers(info);
+	destroy_receive_buffers(sc);
 
 	/*
 	 * For performance reasons, memory registration and deregistration
@@ -1585,7 +1583,7 @@ static void destroy_caches_and_workqueue(struct smbd_connection *info)
 {
 	struct smbdirect_socket *sc = &info->socket;
 
-	destroy_receive_buffers(info);
+	destroy_receive_buffers(sc);
 	destroy_workqueue(sc->workqueue);
 	mempool_destroy(sc->recv_io.mem.pool);
 	kmem_cache_destroy(sc->recv_io.mem.cache);
@@ -1646,7 +1644,7 @@ static int allocate_caches_and_workqueue(struct smbd_connection *info)
 	if (!sc->workqueue)
 		goto out4;
 
-	rc = allocate_receive_buffers(info, sp->recv_credit_max);
+	rc = allocate_receive_buffers(sc, sp->recv_credit_max);
 	if (rc) {
 		log_rdma_event(ERR, "failed to allocate receive buffers\n");
 		goto out5;
-- 
2.43.0

[PATCH v4 057/142] smb: client: pass struct smbdirect_socket to {allocate,destroy}_caches_and_workqueue()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index b23e9d8fd9c4..d7ed5534669a 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -1579,10 +1579,8 @@ int smbd_reconnect(struct TCP_Server_Info *server)
 	return -ENOENT;
 }
 
-static void destroy_caches_and_workqueue(struct smbd_connection *info)
+static void destroy_caches_and_workqueue(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &info->socket;
-
 	destroy_receive_buffers(sc);
 	destroy_workqueue(sc->workqueue);
 	mempool_destroy(sc->recv_io.mem.pool);
@@ -1592,9 +1590,8 @@ static void destroy_caches_and_workqueue(struct smbd_connection *info)
 }
 
 #define MAX_NAME_LEN	80
-static int allocate_caches_and_workqueue(struct smbd_connection *info)
+static int allocate_caches_and_workqueue(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	char name[MAX_NAME_LEN];
 	int rc;
@@ -1602,7 +1599,7 @@ static int allocate_caches_and_workqueue(struct smbd_connection *info)
 	if (WARN_ON_ONCE(sp->max_recv_size < sizeof(struct smbdirect_data_transfer)))
 		return -ENOMEM;
 
-	scnprintf(name, MAX_NAME_LEN, "smbdirect_send_io_%p", info);
+	scnprintf(name, MAX_NAME_LEN, "smbdirect_send_io_%p", sc);
 	sc->send_io.mem.cache =
 		kmem_cache_create(
 			name,
@@ -1618,7 +1615,7 @@ static int allocate_caches_and_workqueue(struct smbd_connection *info)
 	if (!sc->send_io.mem.pool)
 		goto out1;
 
-	scnprintf(name, MAX_NAME_LEN, "smbdirect_recv_io_%p", info);
+	scnprintf(name, MAX_NAME_LEN, "smbdirect_recv_io_%p", sc);
 
 	struct kmem_cache_args response_args = {
 		.align		= __alignof__(struct smbdirect_recv_io),
@@ -1639,7 +1636,7 @@ static int allocate_caches_and_workqueue(struct smbd_connection *info)
 	if (!sc->recv_io.mem.pool)
 		goto out3;
 
-	scnprintf(name, MAX_NAME_LEN, "smbd_%p", info);
+	scnprintf(name, MAX_NAME_LEN, "smbd_%p", sc);
 	sc->workqueue = create_workqueue(name);
 	if (!sc->workqueue)
 		goto out4;
@@ -1825,7 +1822,7 @@ static struct smbd_connection *_smbd_get_connection(
 
 	log_rdma_event(INFO, "rdma_connect connected\n");
 
-	rc = allocate_caches_and_workqueue(info);
+	rc = allocate_caches_and_workqueue(sc);
 	if (rc) {
 		log_rdma_event(ERR, "cache allocation failed\n");
 		goto allocate_cache_failed;
@@ -1865,7 +1862,7 @@ static struct smbd_connection *_smbd_get_connection(
 
 negotiation_failed:
 	disable_delayed_work_sync(&sc->idle.timer_work);
-	destroy_caches_and_workqueue(info);
+	destroy_caches_and_workqueue(sc);
 	sc->status = SMBDIRECT_SOCKET_NEGOTIATE_FAILED;
 	rdma_disconnect(sc->rdma.cm_id);
 	wait_event(sc->status_wait,
-- 
2.43.0

[PATCH v4 058/142] smb: client: pass struct smbdirect_socket to {enqueue,_get_first}_reassembly()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index d7ed5534669a..0f68c35bef2a 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -29,10 +29,10 @@ static int allocate_receive_buffers(struct smbdirect_socket *sc, int num_buf);
 static void destroy_receive_buffers(struct smbdirect_socket *sc);
 
 static void enqueue_reassembly(
-		struct smbd_connection *info,
+		struct smbdirect_socket *sc,
 		struct smbdirect_recv_io *response, int data_length);
 static struct smbdirect_recv_io *_get_first_reassembly(
-		struct smbd_connection *info);
+		struct smbdirect_socket *sc);
 
 static int smbd_post_recv(
 		struct smbd_connection *info,
@@ -659,7 +659,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			if (sc->recv_io.credits.target > old_recv_credit_target)
 				queue_work(sc->workqueue, &sc->recv_io.posted.refill_work);
 
-			enqueue_reassembly(info, response, data_length);
+			enqueue_reassembly(sc, response, data_length);
 			wake_up(&sc->recv_io.reassembly.wait_queue);
 		} else
 			put_receive_buffer(sc, response);
@@ -1272,12 +1272,10 @@ static int smbd_negotiate(struct smbd_connection *info)
  * data_length: the size of payload in this packet
  */
 static void enqueue_reassembly(
-	struct smbd_connection *info,
+	struct smbdirect_socket *sc,
 	struct smbdirect_recv_io *response,
 	int data_length)
 {
-	struct smbdirect_socket *sc = &info->socket;
-
 	spin_lock(&sc->recv_io.reassembly.lock);
 	list_add_tail(&response->list, &sc->recv_io.reassembly.list);
 	sc->recv_io.reassembly.queue_length++;
@@ -1298,9 +1296,8 @@ static void enqueue_reassembly(
  * Caller is responsible for locking
  * return value: the first entry if any, NULL if queue is empty
  */
-static struct smbdirect_recv_io *_get_first_reassembly(struct smbd_connection *info)
+static struct smbdirect_recv_io *_get_first_reassembly(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_recv_io *ret = NULL;
 
 	if (!list_empty(&sc->recv_io.reassembly.list)) {
@@ -1492,7 +1489,7 @@ void smbd_destroy(struct TCP_Server_Info *server)
 	log_rdma_event(INFO, "drain the reassembly queue\n");
 	do {
 		spin_lock_irqsave(&sc->recv_io.reassembly.lock, flags);
-		response = _get_first_reassembly(info);
+		response = _get_first_reassembly(sc);
 		if (response) {
 			list_del(&response->list);
 			spin_unlock_irqrestore(
@@ -1968,7 +1965,7 @@ int smbd_recv(struct smbd_connection *info, struct msghdr *msg)
 		to_read = size;
 		offset = sc->recv_io.reassembly.first_entry_offset;
 		while (data_read < size) {
-			response = _get_first_reassembly(info);
+			response = _get_first_reassembly(sc);
 			data_transfer = smbdirect_recv_io_payload(response);
 			data_length = le32_to_cpu(data_transfer->data_length);
 			remaining_data_length =
-- 
2.43.0

[PATCH v4 059/142] smb: client: pass struct smbdirect_socket to {allocate,destroy}_mr_list()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 0f68c35bef2a..4db70c2c369a 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -40,8 +40,8 @@ static int smbd_post_recv(
 
 static int smbd_post_send_empty(struct smbd_connection *info);
 
-static void destroy_mr_list(struct smbd_connection *info);
-static int allocate_mr_list(struct smbd_connection *info);
+static void destroy_mr_list(struct smbdirect_socket *sc);
+static int allocate_mr_list(struct smbdirect_socket *sc);
 
 struct smb_extract_to_rdma {
 	struct ib_sge		*sge;
@@ -1518,7 +1518,7 @@ void smbd_destroy(struct TCP_Server_Info *server)
 		msleep(1000);
 		cifs_server_lock(server);
 	}
-	destroy_mr_list(info);
+	destroy_mr_list(sc);
 
 	ib_free_cq(sc->ib.send_cq);
 	ib_free_cq(sc->ib.recv_cq);
@@ -1843,7 +1843,7 @@ static struct smbd_connection *_smbd_get_connection(
 		goto negotiation_failed;
 	}
 
-	rc = allocate_mr_list(info);
+	rc = allocate_mr_list(sc);
 	if (rc) {
 		log_rdma_mr(ERR, "memory registration allocation failed\n");
 		goto allocate_mr_failed;
@@ -2225,9 +2225,8 @@ static void smbd_mr_recovery_work(struct work_struct *work)
 	}
 }
 
-static void destroy_mr_list(struct smbd_connection *info)
+static void destroy_mr_list(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_mr_io *mr, *tmp;
 
 	disable_work_sync(&sc->mr_io.recovery_work);
@@ -2248,9 +2247,8 @@ static void destroy_mr_list(struct smbd_connection *info)
  * Recovery is done in smbd_mr_recovery_work. The content of list entry changes
  * as MRs are used and recovered for I/O, but the list links will not change
  */
-static int allocate_mr_list(struct smbd_connection *info)
+static int allocate_mr_list(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	int i;
 	struct smbdirect_mr_io *smbdirect_mr, *tmp;
-- 
2.43.0

[PATCH v4 060/142] smb: client: pass struct smbdirect_socket to smbd_disconnect_rdma_connection()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 41 +++++++++++++--------------------------
 1 file changed, 14 insertions(+), 27 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 4db70c2c369a..31b9b398b6e5 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -214,10 +214,8 @@ static void smbd_disconnect_rdma_work(struct work_struct *work)
 	}
 }
 
-static void smbd_disconnect_rdma_connection(struct smbd_connection *info)
+static void smbd_disconnect_rdma_connection(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &info->socket;
-
 	queue_work(sc->workqueue, &sc->disconnect_work);
 }
 
@@ -363,6 +361,7 @@ static void
 smbd_qp_async_error_upcall(struct ib_event *event, void *context)
 {
 	struct smbd_connection *info = context;
+	struct smbdirect_socket *sc = &info->socket;
 
 	log_rdma_event(ERR, "%s on device %s info %p\n",
 		ib_event_msg(event->event), event->device->name, info);
@@ -370,7 +369,7 @@ smbd_qp_async_error_upcall(struct ib_event *event, void *context)
 	switch (event->event) {
 	case IB_EVENT_CQ_ERR:
 	case IB_EVENT_QP_FATAL:
-		smbd_disconnect_rdma_connection(info);
+		smbd_disconnect_rdma_connection(sc);
 		break;
 
 	default:
@@ -395,8 +394,6 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
 	struct smbdirect_send_io *request =
 		container_of(wc->wr_cqe, struct smbdirect_send_io, cqe);
 	struct smbdirect_socket *sc = request->socket;
-	struct smbd_connection *info =
-		container_of(sc, struct smbd_connection, socket);
 
 	log_rdma_send(INFO, "smbdirect_send_io 0x%p completed wc->status=%s\n",
 		request, ib_wc_status_msg(wc->status));
@@ -412,7 +409,7 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
 			log_rdma_send(ERR, "wc->status=%s wc->opcode=%d\n",
 				ib_wc_status_msg(wc->status), wc->opcode);
 		mempool_free(request, sc->send_io.mem.pool);
-		smbd_disconnect_rdma_connection(info);
+		smbd_disconnect_rdma_connection(sc);
 		return;
 	}
 
@@ -552,8 +549,6 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		container_of(wc->wr_cqe, struct smbdirect_recv_io, cqe);
 	struct smbdirect_socket *sc = response->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
-	struct smbd_connection *info =
-		container_of(sc, struct smbd_connection, socket);
 	u16 old_recv_credit_target;
 	int data_length = 0;
 	bool negotiate_done = false;
@@ -678,7 +673,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	WARN_ON_ONCE(sc->recv_io.expected != SMBDIRECT_EXPECT_DATA_TRANSFER);
 error:
 	put_receive_buffer(sc, response);
-	smbd_disconnect_rdma_connection(info);
+	smbd_disconnect_rdma_connection(sc);
 }
 
 static struct rdma_cm_id *smbd_create_id(
@@ -903,7 +898,7 @@ static int smbd_post_send_negotiate_req(struct smbd_connection *info)
 	ib_dma_unmap_single(sc->ib.dev, request->sge[0].addr,
 		request->sge[0].length, DMA_TO_DEVICE);
 
-	smbd_disconnect_rdma_connection(info);
+	smbd_disconnect_rdma_connection(sc);
 
 dma_mapping_failed:
 	mempool_free(request, sc->send_io.mem.pool);
@@ -995,7 +990,7 @@ static int smbd_post_send(struct smbd_connection *info,
 	rc = ib_post_send(sc->ib.qp, &send_wr, NULL);
 	if (rc) {
 		log_rdma_send(ERR, "ib_post_send failed rc=%d\n", rc);
-		smbd_disconnect_rdma_connection(info);
+		smbd_disconnect_rdma_connection(sc);
 		rc = -EAGAIN;
 	}
 
@@ -1212,7 +1207,7 @@ static int smbd_post_recv(
 		ib_dma_unmap_single(sc->ib.dev, response->sge.addr,
 				    response->sge.length, DMA_FROM_DEVICE);
 		response->sge.length = 0;
-		smbd_disconnect_rdma_connection(info);
+		smbd_disconnect_rdma_connection(sc);
 		log_rdma_recv(ERR, "ib_post_recv failed rc=%d\n", rc);
 	}
 
@@ -1417,14 +1412,12 @@ static void idle_connection_timer(struct work_struct *work)
 	struct smbdirect_socket *sc =
 		container_of(work, struct smbdirect_socket, idle.timer_work.work);
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
-	struct smbd_connection *info =
-		container_of(sc, struct smbd_connection, socket);
 
 	if (sc->idle.keepalive != SMBDIRECT_KEEPALIVE_NONE) {
 		log_keep_alive(ERR,
 			"error status sc->idle.keepalive=%d\n",
 			sc->idle.keepalive);
-		smbd_disconnect_rdma_connection(info);
+		smbd_disconnect_rdma_connection(sc);
 		return;
 	}
 
@@ -2156,12 +2149,10 @@ static void register_mr_done(struct ib_cq *cq, struct ib_wc *wc)
 	struct smbdirect_mr_io *mr =
 		container_of(wc->wr_cqe, struct smbdirect_mr_io, cqe);
 	struct smbdirect_socket *sc = mr->socket;
-	struct smbd_connection *info =
-		container_of(sc, struct smbd_connection, socket);
 
 	if (wc->status) {
 		log_rdma_mr(ERR, "status=%d\n", wc->status);
-		smbd_disconnect_rdma_connection(info);
+		smbd_disconnect_rdma_connection(sc);
 	}
 }
 
@@ -2179,8 +2170,6 @@ static void smbd_mr_recovery_work(struct work_struct *work)
 	struct smbdirect_socket *sc =
 		container_of(work, struct smbdirect_socket, mr_io.recovery_work);
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
-	struct smbd_connection *info =
-		container_of(sc, struct smbd_connection, socket);
 	struct smbdirect_mr_io *smbdirect_mr;
 	int rc;
 
@@ -2193,7 +2182,7 @@ static void smbd_mr_recovery_work(struct work_struct *work)
 				log_rdma_mr(ERR,
 					"ib_dereg_mr failed rc=%x\n",
 					rc);
-				smbd_disconnect_rdma_connection(info);
+				smbd_disconnect_rdma_connection(sc);
 				continue;
 			}
 
@@ -2204,7 +2193,7 @@ static void smbd_mr_recovery_work(struct work_struct *work)
 				log_rdma_mr(ERR, "ib_alloc_mr failed mr_type=%x max_frmr_depth=%x\n",
 					    sc->mr_io.type,
 					    sp->max_frmr_depth);
-				smbd_disconnect_rdma_connection(info);
+				smbd_disconnect_rdma_connection(sc);
 				continue;
 			}
 		} else
@@ -2460,7 +2449,7 @@ struct smbdirect_mr_io *smbd_register_mr(struct smbd_connection *info,
 	if (atomic_dec_and_test(&sc->mr_io.used.count))
 		wake_up(&sc->mr_io.cleanup.wait_queue);
 
-	smbd_disconnect_rdma_connection(info);
+	smbd_disconnect_rdma_connection(sc);
 
 	return NULL;
 }
@@ -2490,8 +2479,6 @@ int smbd_deregister_mr(struct smbdirect_mr_io *smbdirect_mr)
 {
 	struct ib_send_wr *wr;
 	struct smbdirect_socket *sc = smbdirect_mr->socket;
-	struct smbd_connection *info =
-		container_of(sc, struct smbd_connection, socket);
 	int rc = 0;
 
 	if (smbdirect_mr->need_invalidate) {
@@ -2508,7 +2495,7 @@ int smbd_deregister_mr(struct smbdirect_mr_io *smbdirect_mr)
 		rc = ib_post_send(sc->ib.qp, wr, NULL);
 		if (rc) {
 			log_rdma_mr(ERR, "ib_post_send failed rc=%x\n", rc);
-			smbd_disconnect_rdma_connection(info);
+			smbd_disconnect_rdma_connection(sc);
 			goto done;
 		}
 		wait_for_completion(&smbdirect_mr->invalidate_done);
-- 
2.43.0

[PATCH v4 061/142] smb: client: pass struct smbdirect_socket to smbd_post_recv()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 31b9b398b6e5..e00a70125ca8 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -35,7 +35,7 @@ static struct smbdirect_recv_io *_get_first_reassembly(
 		struct smbdirect_socket *sc);
 
 static int smbd_post_recv(
-		struct smbd_connection *info,
+		struct smbdirect_socket *sc,
 		struct smbdirect_recv_io *response);
 
 static int smbd_post_send_empty(struct smbd_connection *info);
@@ -506,8 +506,6 @@ static void smbd_post_send_credits(struct work_struct *work)
 	struct smbdirect_recv_io *response;
 	struct smbdirect_socket *sc =
 		container_of(work, struct smbdirect_socket, recv_io.posted.refill_work);
-	struct smbd_connection *info =
-		container_of(sc, struct smbd_connection, socket);
 
 	if (sc->status != SMBDIRECT_SOCKET_CONNECTED) {
 		return;
@@ -521,7 +519,7 @@ static void smbd_post_send_credits(struct work_struct *work)
 				break;
 
 			response->first_segment = false;
-			rc = smbd_post_recv(info, response);
+			rc = smbd_post_recv(sc, response);
 			if (rc) {
 				log_rdma_recv(ERR,
 					"post_recv failed rc=%d\n", rc);
@@ -1179,9 +1177,8 @@ static int smbd_post_send_full_iter(struct smbd_connection *info,
  * The interaction is controlled by send/receive credit system
  */
 static int smbd_post_recv(
-		struct smbd_connection *info, struct smbdirect_recv_io *response)
+		struct smbdirect_socket *sc, struct smbdirect_recv_io *response)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct ib_recv_wr recv_wr;
 	int rc = -EIO;
@@ -1226,7 +1223,7 @@ static int smbd_negotiate(struct smbd_connection *info)
 	sc->status = SMBDIRECT_SOCKET_NEGOTIATE_RUNNING;
 
 	sc->recv_io.expected = SMBDIRECT_EXPECT_NEGOTIATE_REP;
-	rc = smbd_post_recv(info, response);
+	rc = smbd_post_recv(sc, response);
 	log_rdma_event(INFO, "smbd_post_recv rc=%d iov.addr=0x%llx iov.length=%u iov.lkey=0x%x\n",
 		       rc, response->sge.addr,
 		       response->sge.length, response->sge.lkey);
-- 
2.43.0

[PATCH v4 062/142] smb: client: pass struct smbdirect_socket to manage_credits_prior_sending()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index e00a70125ca8..148ba5449b66 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -911,9 +911,8 @@ static int smbd_post_send_negotiate_req(struct smbd_connection *info)
  * buffer as possible, and extend the receive credits to remote peer
  * return value: the new credtis being granted.
  */
-static int manage_credits_prior_sending(struct smbd_connection *info)
+static int manage_credits_prior_sending(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	int new_credits;
 
 	if (atomic_read(&sc->recv_io.credits.count) >= sc->recv_io.credits.target)
@@ -1064,7 +1063,7 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 	packet = smbdirect_send_io_payload(request);
 	packet->credits_requested = cpu_to_le16(sp->send_credit_target);
 
-	new_credits = manage_credits_prior_sending(info);
+	new_credits = manage_credits_prior_sending(sc);
 	atomic_add(new_credits, &sc->recv_io.credits.count);
 	packet->credits_granted = cpu_to_le16(new_credits);
 
-- 
2.43.0

[PATCH v4 063/142] smb: client: pass struct smbdirect_socket to smbd_post_send()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 148ba5449b66..552eb3d29dfc 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -957,10 +957,9 @@ static int manage_keep_alive_before_sending(struct smbd_connection *info)
 }
 
 /* Post the send request */
-static int smbd_post_send(struct smbd_connection *info,
+static int smbd_post_send(struct smbdirect_socket *sc,
 		struct smbdirect_send_io *request)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct ib_send_wr send_wr;
 	int rc, i;
 
@@ -1107,7 +1106,7 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 	request->sge[0].lkey = sc->ib.pd->local_dma_lkey;
 
 	atomic_inc(&sc->send_io.pending.count);
-	rc = smbd_post_send(info, request);
+	rc = smbd_post_send(sc, request);
 	if (!rc)
 		return 0;
 
-- 
2.43.0

[PATCH v4 064/142] smb: client: pass struct smbdirect_socket to manage_keep_alive_before_sending()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 552eb3d29dfc..782621a844f1 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -938,9 +938,8 @@ static int manage_credits_prior_sending(struct smbdirect_socket *sc)
  * 1 if SMBDIRECT_FLAG_RESPONSE_REQUESTED needs to be set
  * 0: otherwise
  */
-static int manage_keep_alive_before_sending(struct smbd_connection *info)
+static int manage_keep_alive_before_sending(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 
 	if (sc->idle.keepalive == SMBDIRECT_KEEPALIVE_PENDING) {
@@ -1067,7 +1066,7 @@ static int smbd_post_send_iter(struct smbd_connection *info,
 	packet->credits_granted = cpu_to_le16(new_credits);
 
 	packet->flags = 0;
-	if (manage_keep_alive_before_sending(info))
+	if (manage_keep_alive_before_sending(sc))
 		packet->flags |= cpu_to_le16(SMBDIRECT_FLAG_RESPONSE_REQUESTED);
 
 	packet->reserved = 0;
-- 
2.43.0

[PATCH v4 065/142] smb: client: pass struct smbdirect_socket to smbd_post_send_iter()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 782621a844f1..40d0233f41df 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -992,11 +992,10 @@ static int smbd_post_send(struct smbdirect_socket *sc,
 	return rc;
 }
 
-static int smbd_post_send_iter(struct smbd_connection *info,
+static int smbd_post_send_iter(struct smbdirect_socket *sc,
 			       struct iov_iter *iter,
 			       int *_remaining_data_length)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	int i, rc;
 	int header_length;
@@ -1144,13 +1143,14 @@ static int smbd_post_send_empty(struct smbd_connection *info)
 	int remaining_data_length = 0;
 
 	sc->statistics.send_empty++;
-	return smbd_post_send_iter(info, NULL, &remaining_data_length);
+	return smbd_post_send_iter(sc, NULL, &remaining_data_length);
 }
 
 static int smbd_post_send_full_iter(struct smbd_connection *info,
 				    struct iov_iter *iter,
 				    int *_remaining_data_length)
 {
+	struct smbdirect_socket *sc = &info->socket;
 	int rc = 0;
 
 	/*
@@ -1160,7 +1160,7 @@ static int smbd_post_send_full_iter(struct smbd_connection *info,
 	 */
 
 	while (iov_iter_count(iter) > 0) {
-		rc = smbd_post_send_iter(info, iter, _remaining_data_length);
+		rc = smbd_post_send_iter(sc, iter, _remaining_data_length);
 		if (rc < 0)
 			break;
 	}
-- 
2.43.0

[PATCH v4 066/142] smb: client: pass struct smbdirect_socket to smbd_post_send_empty()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 40d0233f41df..b9ea58e8db46 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -38,7 +38,7 @@ static int smbd_post_recv(
 		struct smbdirect_socket *sc,
 		struct smbdirect_recv_io *response);
 
-static int smbd_post_send_empty(struct smbd_connection *info);
+static int smbd_post_send_empty(struct smbdirect_socket *sc);
 
 static void destroy_mr_list(struct smbdirect_socket *sc);
 static int allocate_mr_list(struct smbdirect_socket *sc);
@@ -1137,9 +1137,8 @@ static int smbd_post_send_iter(struct smbdirect_socket *sc,
  * Empty message is used to extend credits to peer to for keep live
  * while there is no upper layer payload to send at the time
  */
-static int smbd_post_send_empty(struct smbd_connection *info)
+static int smbd_post_send_empty(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	int remaining_data_length = 0;
 
 	sc->statistics.send_empty++;
@@ -1390,14 +1389,12 @@ static void send_immediate_empty_message(struct work_struct *work)
 {
 	struct smbdirect_socket *sc =
 		container_of(work, struct smbdirect_socket, idle.immediate_work);
-	struct smbd_connection *info =
-		container_of(sc, struct smbd_connection, socket);
 
 	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
 		return;
 
 	log_keep_alive(INFO, "send an empty message\n");
-	smbd_post_send_empty(info);
+	smbd_post_send_empty(sc);
 }
 
 /* Implement idle connection timer [MS-SMBD] 3.1.6.2 */
-- 
2.43.0

[PATCH v4 067/142] smb: client: pass struct smbdirect_socket to smbd_post_send_full_iter()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index b9ea58e8db46..baeda2192a27 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -1145,11 +1145,10 @@ static int smbd_post_send_empty(struct smbdirect_socket *sc)
 	return smbd_post_send_iter(sc, NULL, &remaining_data_length);
 }
 
-static int smbd_post_send_full_iter(struct smbd_connection *info,
+static int smbd_post_send_full_iter(struct smbdirect_socket *sc,
 				    struct iov_iter *iter,
 				    int *_remaining_data_length)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	int rc = 0;
 
 	/*
@@ -2104,13 +2103,13 @@ int smbd_send(struct TCP_Server_Info *server,
 			klen += rqst->rq_iov[i].iov_len;
 		iov_iter_kvec(&iter, ITER_SOURCE, rqst->rq_iov, rqst->rq_nvec, klen);
 
-		rc = smbd_post_send_full_iter(info, &iter, &remaining_data_length);
+		rc = smbd_post_send_full_iter(sc, &iter, &remaining_data_length);
 		if (rc < 0)
 			break;
 
 		if (iov_iter_count(&rqst->rq_iter) > 0) {
 			/* And then the data pages if there are any */
-			rc = smbd_post_send_full_iter(info, &rqst->rq_iter,
+			rc = smbd_post_send_full_iter(sc, &rqst->rq_iter,
 						      &remaining_data_length);
 			if (rc < 0)
 				break;
-- 
2.43.0

[PATCH v4 068/142] smb: client: pass struct smbdirect_socket to smbd_conn_upcall()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index baeda2192a27..8ef4d8319833 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -223,8 +223,7 @@ static void smbd_disconnect_rdma_connection(struct smbdirect_socket *sc)
 static int smbd_conn_upcall(
 		struct rdma_cm_id *id, struct rdma_cm_event *event)
 {
-	struct smbd_connection *info = id->context;
-	struct smbdirect_socket *sc = &info->socket;
+	struct smbdirect_socket *sc = id->context;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	const char *event_name = rdma_event_msg(event->event);
 	u8 peer_initiator_depth;
@@ -684,7 +683,7 @@ static struct rdma_cm_id *smbd_create_id(
 	int rc;
 	__be16 *sport;
 
-	id = rdma_create_id(&init_net, smbd_conn_upcall, info,
+	id = rdma_create_id(&init_net, smbd_conn_upcall, sc,
 		RDMA_PS_TCP, IB_QPT_RC);
 	if (IS_ERR(id)) {
 		rc = PTR_ERR(id);
-- 
2.43.0

[PATCH v4 069/142] smb: client: pass struct smbdirect_socket to smbd_qp_async_error_upcall()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 8ef4d8319833..660edf02afee 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -359,11 +359,10 @@ static int smbd_conn_upcall(
 static void
 smbd_qp_async_error_upcall(struct ib_event *event, void *context)
 {
-	struct smbd_connection *info = context;
-	struct smbdirect_socket *sc = &info->socket;
+	struct smbdirect_socket *sc = context;
 
-	log_rdma_event(ERR, "%s on device %s info %p\n",
-		ib_event_msg(event->event), event->device->name, info);
+	log_rdma_event(ERR, "%s on device %s socket %p\n",
+		ib_event_msg(event->event), event->device->name, sc);
 
 	switch (event->event) {
 	case IB_EVENT_CQ_ERR:
@@ -1715,7 +1714,7 @@ static struct smbd_connection *_smbd_get_connection(
 	}
 
 	sc->ib.send_cq =
-		ib_alloc_cq_any(sc->ib.dev, info,
+		ib_alloc_cq_any(sc->ib.dev, sc,
 				sp->send_credit_target, IB_POLL_SOFTIRQ);
 	if (IS_ERR(sc->ib.send_cq)) {
 		sc->ib.send_cq = NULL;
@@ -1723,7 +1722,7 @@ static struct smbd_connection *_smbd_get_connection(
 	}
 
 	sc->ib.recv_cq =
-		ib_alloc_cq_any(sc->ib.dev, info,
+		ib_alloc_cq_any(sc->ib.dev, sc,
 				sp->recv_credit_max, IB_POLL_SOFTIRQ);
 	if (IS_ERR(sc->ib.recv_cq)) {
 		sc->ib.recv_cq = NULL;
@@ -1732,7 +1731,7 @@ static struct smbd_connection *_smbd_get_connection(
 
 	memset(&qp_attr, 0, sizeof(qp_attr));
 	qp_attr.event_handler = smbd_qp_async_error_upcall;
-	qp_attr.qp_context = info;
+	qp_attr.qp_context = sc;
 	qp_attr.cap.max_send_wr = sp->send_credit_target;
 	qp_attr.cap.max_recv_wr = sp->recv_credit_max;
 	qp_attr.cap.max_send_sge = SMBDIRECT_SEND_IO_MAX_SGE;
-- 
2.43.0

[PATCH v4 070/142] smb: client: pass struct smbdirect_socket to smbd_create_id()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 660edf02afee..3a0b5e3d3142 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -673,10 +673,9 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 }
 
 static struct rdma_cm_id *smbd_create_id(
-		struct smbd_connection *info,
+		struct smbdirect_socket *sc,
 		struct sockaddr *dstaddr, int port)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct rdma_cm_id *id;
 	int rc;
@@ -784,7 +783,7 @@ static int smbd_ia_open(
 	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_CREATED);
 	sc->status = SMBDIRECT_SOCKET_RESOLVE_ADDR_NEEDED;
 
-	sc->rdma.cm_id = smbd_create_id(info, dstaddr, port);
+	sc->rdma.cm_id = smbd_create_id(sc, dstaddr, port);
 	if (IS_ERR(sc->rdma.cm_id)) {
 		rc = PTR_ERR(sc->rdma.cm_id);
 		goto out1;
-- 
2.43.0

[PATCH v4 071/142] smb: client: pass struct smbdirect_socket to smbd_ia_open()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 3a0b5e3d3142..9fef01ed6320 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -773,10 +773,9 @@ static bool frwr_is_supported(struct ib_device_attr *attrs)
 }
 
 static int smbd_ia_open(
-		struct smbd_connection *info,
+		struct smbdirect_socket *sc,
 		struct sockaddr *dstaddr, int port)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	int rc;
 
@@ -1677,7 +1676,7 @@ static struct smbd_connection *_smbd_get_connection(
 	sp->keepalive_interval_msec = smbd_keep_alive_interval * 1000;
 	sp->keepalive_timeout_msec = KEEPALIVE_RECV_TIMEOUT * 1000;
 
-	rc = smbd_ia_open(info, dstaddr, port);
+	rc = smbd_ia_open(sc, dstaddr, port);
 	if (rc) {
 		log_rdma_event(INFO, "smbd_ia_open rc=%d\n", rc);
 		goto create_id_failed;
-- 
2.43.0

[PATCH v4 072/142] smb: client: pass struct smbdirect_socket to smbd_post_send_negotiate_req()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 9fef01ed6320..e5219b9c0c8a 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -827,9 +827,8 @@ static int smbd_ia_open(
  * After negotiation, the transport is connected and ready for
  * carrying upper layer SMB payload
  */
-static int smbd_post_send_negotiate_req(struct smbd_connection *info)
+static int smbd_post_send_negotiate_req(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct ib_send_wr send_wr;
 	int rc = -ENOMEM;
@@ -1221,7 +1220,7 @@ static int smbd_negotiate(struct smbd_connection *info)
 	if (rc)
 		return rc;
 
-	rc = smbd_post_send_negotiate_req(info);
+	rc = smbd_post_send_negotiate_req(sc);
 	if (rc)
 		return rc;
 
-- 
2.43.0

[PATCH v4 073/142] smb: client: pass struct smbdirect_socket to smbd_negotiate()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index e5219b9c0c8a..04f86fde11fe 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -1202,9 +1202,8 @@ static int smbd_post_recv(
 }
 
 /* Perform SMBD negotiate according to [MS-SMBD] 3.1.5.2 */
-static int smbd_negotiate(struct smbd_connection *info)
+static int smbd_negotiate(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	int rc;
 	struct smbdirect_recv_io *response = get_receive_buffer(sc);
@@ -1815,7 +1814,7 @@ static struct smbd_connection *_smbd_get_connection(
 
 	INIT_WORK(&sc->recv_io.posted.refill_work, smbd_post_send_credits);
 
-	rc = smbd_negotiate(info);
+	rc = smbd_negotiate(sc);
 	if (rc) {
 		log_rdma_event(ERR, "smbd_negotiate rc=%d\n", rc);
 		goto negotiation_failed;
-- 
2.43.0

[PATCH v4 074/142] smb: client: pass struct smbdirect_socket to get_mr()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 04f86fde11fe..8033be07bc77 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -2281,9 +2281,8 @@ static int allocate_mr_list(struct smbdirect_socket *sc)
  * issuing I/O trying to get MR at the same time, mr_list_lock is used to
  * protect this situation.
  */
-static struct smbdirect_mr_io *get_mr(struct smbd_connection *info)
+static struct smbdirect_mr_io *get_mr(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &info->socket;
 	struct smbdirect_mr_io *ret;
 	int rc;
 again:
@@ -2364,7 +2363,7 @@ struct smbdirect_mr_io *smbd_register_mr(struct smbd_connection *info,
 		return NULL;
 	}
 
-	smbdirect_mr = get_mr(info);
+	smbdirect_mr = get_mr(sc);
 	if (!smbdirect_mr) {
 		log_rdma_mr(ERR, "get_mr returning NULL\n");
 		return NULL;
-- 
2.43.0

[PATCH v4 075/142] smb: client: remove unused struct smbdirect_socket argument of smbd_iter_to_mr()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/client/smbdirect.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 8033be07bc77..d3cd89bd2cc7 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -2321,8 +2321,7 @@ static struct smbdirect_mr_io *get_mr(struct smbdirect_socket *sc)
 /*
  * Transcribe the pages from an iterator into an MR scatterlist.
  */
-static int smbd_iter_to_mr(struct smbd_connection *info,
-			   struct iov_iter *iter,
+static int smbd_iter_to_mr(struct iov_iter *iter,
 			   struct sg_table *sgt,
 			   unsigned int max_sg)
 {
@@ -2377,7 +2376,7 @@ struct smbdirect_mr_io *smbd_register_mr(struct smbd_connection *info,
 
 	log_rdma_mr(INFO, "num_pages=0x%x count=0x%zx depth=%u\n",
 		    num_pages, iov_iter_count(iter), sp->max_frmr_depth);
-	smbd_iter_to_mr(info, iter, &smbdirect_mr->sgt, sp->max_frmr_depth);
+	smbd_iter_to_mr(iter, &smbdirect_mr->sgt, sp->max_frmr_depth);
 
 	rc = ib_dma_map_sg(sc->ib.dev, smbdirect_mr->sgt.sgl,
 			   smbdirect_mr->sgt.nents, dir);
-- 
2.43.0

[PATCH v4 076/142] smb: server: make use of common smbdirect_pdu.h

[Stefan Metzmacher]

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Hyunchul Lee <hyc.lee@gmail.com>
Cc: Meetakshi Setiya <meetakshisetiyaoss@gmail.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Acked-by: Namjae Jeon <linkinjeon@kernel.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/server/transport_rdma.c | 49 +++++++++++++++++-----------------
 fs/smb/server/transport_rdma.h | 41 ----------------------------
 2 files changed, 25 insertions(+), 65 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 20d1f53ca989..ce6f2197d8d5 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -23,12 +23,13 @@
 #include "connection.h"
 #include "smb_common.h"
 #include "../common/smb2status.h"
+#include "../common/smbdirect/smbdirect_pdu.h"
 #include "transport_rdma.h"
 
 #define SMB_DIRECT_PORT_IWARP		5445
 #define SMB_DIRECT_PORT_INFINIBAND	445
 
-#define SMB_DIRECT_VERSION_LE		cpu_to_le16(0x0100)
+#define SMB_DIRECT_VERSION_LE		cpu_to_le16(SMBDIRECT_V1)
 
 /* SMB_DIRECT negotiation timeout in seconds */
 #define SMB_DIRECT_NEGOTIATE_TIMEOUT		120
@@ -479,8 +480,8 @@ static int smb_direct_check_recvmsg(struct smb_direct_recvmsg *recvmsg)
 {
 	switch (recvmsg->type) {
 	case SMB_DIRECT_MSG_DATA_TRANSFER: {
-		struct smb_direct_data_transfer *req =
-			(struct smb_direct_data_transfer *)recvmsg->packet;
+		struct smbdirect_data_transfer *req =
+			(struct smbdirect_data_transfer *)recvmsg->packet;
 		struct smb2_hdr *hdr = (struct smb2_hdr *)(recvmsg->packet
 				+ le32_to_cpu(req->data_offset));
 		ksmbd_debug(RDMA,
@@ -492,8 +493,8 @@ static int smb_direct_check_recvmsg(struct smb_direct_recvmsg *recvmsg)
 		break;
 	}
 	case SMB_DIRECT_MSG_NEGOTIATE_REQ: {
-		struct smb_direct_negotiate_req *req =
-			(struct smb_direct_negotiate_req *)recvmsg->packet;
+		struct smbdirect_negotiate_req *req =
+			(struct smbdirect_negotiate_req *)recvmsg->packet;
 		ksmbd_debug(RDMA,
 			    "MinVersion: %u, MaxVersion: %u, CreditRequested: %u, MaxSendSize: %u, MaxRecvSize: %u, MaxFragmentedSize: %u\n",
 			    le16_to_cpu(req->min_version),
@@ -547,7 +548,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 
 	switch (recvmsg->type) {
 	case SMB_DIRECT_MSG_NEGOTIATE_REQ:
-		if (wc->byte_len < sizeof(struct smb_direct_negotiate_req)) {
+		if (wc->byte_len < sizeof(struct smbdirect_negotiate_req)) {
 			put_recvmsg(t, recvmsg);
 			smb_direct_disconnect_rdma_connection(t);
 			return;
@@ -559,13 +560,13 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		wake_up_interruptible(&t->wait_status);
 		return;
 	case SMB_DIRECT_MSG_DATA_TRANSFER: {
-		struct smb_direct_data_transfer *data_transfer =
-			(struct smb_direct_data_transfer *)recvmsg->packet;
+		struct smbdirect_data_transfer *data_transfer =
+			(struct smbdirect_data_transfer *)recvmsg->packet;
 		unsigned int data_length;
 		int avail_recvmsg_count, receive_credits;
 
 		if (wc->byte_len <
-		    offsetof(struct smb_direct_data_transfer, padding)) {
+		    offsetof(struct smbdirect_data_transfer, padding)) {
 			put_recvmsg(t, recvmsg);
 			smb_direct_disconnect_rdma_connection(t);
 			return;
@@ -573,7 +574,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 
 		data_length = le32_to_cpu(data_transfer->data_length);
 		if (data_length) {
-			if (wc->byte_len < sizeof(struct smb_direct_data_transfer) +
+			if (wc->byte_len < sizeof(struct smbdirect_data_transfer) +
 			    (u64)data_length) {
 				put_recvmsg(t, recvmsg);
 				smb_direct_disconnect_rdma_connection(t);
@@ -605,7 +606,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			   &t->send_credits);
 
 		if (le16_to_cpu(data_transfer->flags) &
-		    SMB_DIRECT_RESPONSE_REQUESTED)
+		    SMBDIRECT_FLAG_RESPONSE_REQUESTED)
 			queue_work(smb_direct_wq, &t->send_immediate_work);
 
 		if (atomic_read(&t->send_credits) > 0)
@@ -671,7 +672,7 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 			   unsigned int size, int unused)
 {
 	struct smb_direct_recvmsg *recvmsg;
-	struct smb_direct_data_transfer *data_transfer;
+	struct smbdirect_data_transfer *data_transfer;
 	int to_copy, to_read, data_read, offset;
 	u32 data_length, remaining_data_length, data_offset;
 	int rc;
@@ -1008,7 +1009,7 @@ static int smb_direct_create_header(struct smb_direct_transport *t,
 				    struct smb_direct_sendmsg **sendmsg_out)
 {
 	struct smb_direct_sendmsg *sendmsg;
-	struct smb_direct_data_transfer *packet;
+	struct smbdirect_data_transfer *packet;
 	int header_length;
 	int ret;
 
@@ -1017,7 +1018,7 @@ static int smb_direct_create_header(struct smb_direct_transport *t,
 		return PTR_ERR(sendmsg);
 
 	/* Fill in the packet header */
-	packet = (struct smb_direct_data_transfer *)sendmsg->packet;
+	packet = (struct smbdirect_data_transfer *)sendmsg->packet;
 	packet->credits_requested = cpu_to_le16(t->send_credit_target);
 	packet->credits_granted = cpu_to_le16(manage_credits_prior_sending(t));
 
@@ -1040,11 +1041,11 @@ static int smb_direct_create_header(struct smb_direct_transport *t,
 		    le32_to_cpu(packet->remaining_data_length));
 
 	/* Map the packet to DMA */
-	header_length = sizeof(struct smb_direct_data_transfer);
+	header_length = sizeof(struct smbdirect_data_transfer);
 	/* If this is a packet without payload, don't send padding */
 	if (!size)
 		header_length =
-			offsetof(struct smb_direct_data_transfer, padding);
+			offsetof(struct smbdirect_data_transfer, padding);
 
 	sendmsg->sge[0].addr = ib_dma_map_single(t->cm_id->device,
 						 (void *)packet,
@@ -1219,7 +1220,7 @@ static int smb_direct_writev(struct ksmbd_transport *t,
 	int remaining_data_length;
 	int start, i, j;
 	int max_iov_size = st->max_send_size -
-			sizeof(struct smb_direct_data_transfer);
+			sizeof(struct smbdirect_data_transfer);
 	int ret;
 	struct kvec vec;
 	struct smb_direct_send_ctx send_ctx;
@@ -1567,18 +1568,18 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 					      int failed)
 {
 	struct smb_direct_sendmsg *sendmsg;
-	struct smb_direct_negotiate_resp *resp;
+	struct smbdirect_negotiate_resp *resp;
 	int ret;
 
 	sendmsg = smb_direct_alloc_sendmsg(t);
 	if (IS_ERR(sendmsg))
 		return -ENOMEM;
 
-	resp = (struct smb_direct_negotiate_resp *)sendmsg->packet;
+	resp = (struct smbdirect_negotiate_resp *)sendmsg->packet;
 	if (failed) {
 		memset(resp, 0, sizeof(*resp));
-		resp->min_version = cpu_to_le16(0x0100);
-		resp->max_version = cpu_to_le16(0x0100);
+		resp->min_version = SMB_DIRECT_VERSION_LE;
+		resp->max_version = SMB_DIRECT_VERSION_LE;
 		resp->status = STATUS_NOT_SUPPORTED;
 	} else {
 		resp->status = STATUS_SUCCESS;
@@ -1810,7 +1811,7 @@ static int smb_direct_create_pools(struct smb_direct_transport *t)
 	snprintf(name, sizeof(name), "smb_direct_rqst_pool_%p", t);
 	t->sendmsg_cache = kmem_cache_create(name,
 					     sizeof(struct smb_direct_sendmsg) +
-					      sizeof(struct smb_direct_negotiate_resp),
+					      sizeof(struct smbdirect_negotiate_resp),
 					     0, SLAB_HWCACHE_ALIGN, NULL);
 	if (!t->sendmsg_cache)
 		return -ENOMEM;
@@ -1943,7 +1944,7 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 {
 	struct smb_direct_transport *st = smb_trans_direct_transfort(t);
 	struct smb_direct_recvmsg *recvmsg;
-	struct smb_direct_negotiate_req *req;
+	struct smbdirect_negotiate_req *req;
 	int ret;
 
 	ksmbd_debug(RDMA, "Waiting for SMB_DIRECT negotiate request\n");
@@ -1962,7 +1963,7 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 	if (ret == -ECONNABORTED)
 		goto out;
 
-	req = (struct smb_direct_negotiate_req *)recvmsg->packet;
+	req = (struct smbdirect_negotiate_req *)recvmsg->packet;
 	st->max_recv_size = min_t(int, st->max_recv_size,
 				  le32_to_cpu(req->preferred_send_size));
 	st->max_send_size = min_t(int, st->max_send_size,
diff --git a/fs/smb/server/transport_rdma.h b/fs/smb/server/transport_rdma.h
index a2291b77488a..63eab9f8f13d 100644
--- a/fs/smb/server/transport_rdma.h
+++ b/fs/smb/server/transport_rdma.h
@@ -11,47 +11,6 @@
 #define SMBD_MIN_IOSIZE (512 * 1024)
 #define SMBD_MAX_IOSIZE (16 * 1024 * 1024)
 
-/* SMB DIRECT negotiation request packet [MS-SMBD] 2.2.1 */
-struct smb_direct_negotiate_req {
-	__le16 min_version;
-	__le16 max_version;
-	__le16 reserved;
-	__le16 credits_requested;
-	__le32 preferred_send_size;
-	__le32 max_receive_size;
-	__le32 max_fragmented_size;
-} __packed;
-
-/* SMB DIRECT negotiation response packet [MS-SMBD] 2.2.2 */
-struct smb_direct_negotiate_resp {
-	__le16 min_version;
-	__le16 max_version;
-	__le16 negotiated_version;
-	__le16 reserved;
-	__le16 credits_requested;
-	__le16 credits_granted;
-	__le32 status;
-	__le32 max_readwrite_size;
-	__le32 preferred_send_size;
-	__le32 max_receive_size;
-	__le32 max_fragmented_size;
-} __packed;
-
-#define SMB_DIRECT_RESPONSE_REQUESTED 0x0001
-
-/* SMB DIRECT data transfer packet with payload [MS-SMBD] 2.2.3 */
-struct smb_direct_data_transfer {
-	__le16 credits_requested;
-	__le16 credits_granted;
-	__le16 flags;
-	__le16 reserved;
-	__le32 remaining_data_length;
-	__le32 data_offset;
-	__le32 data_length;
-	__le32 padding;
-	__u8 buffer[];
-} __packed;
-
 #ifdef CONFIG_SMB_SERVER_SMBDIRECT
 int ksmbd_rdma_init(void);
 void ksmbd_rdma_stop_listening(void);
-- 
2.43.0

[PATCH v4 077/142] smb: server: make use of common smbdirect.h

[Stefan Metzmacher]

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Hyunchul Lee <hyc.lee@gmail.com>
Cc: Meetakshi Setiya <meetakshisetiyaoss@gmail.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Acked-by: Namjae Jeon <linkinjeon@kernel.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/server/connection.c     |  4 ++--
 fs/smb/server/connection.h     | 10 ++++++----
 fs/smb/server/smb2pdu.c        | 11 ++++++-----
 fs/smb/server/smb2pdu.h        |  6 ------
 fs/smb/server/transport_rdma.c |  7 ++++---
 5 files changed, 18 insertions(+), 20 deletions(-)

diff --git a/fs/smb/server/connection.c b/fs/smb/server/connection.c
index 67c4f73398df..91a934411134 100644
--- a/fs/smb/server/connection.c
+++ b/fs/smb/server/connection.c
@@ -243,7 +243,7 @@ int ksmbd_conn_write(struct ksmbd_work *work)
 
 int ksmbd_conn_rdma_read(struct ksmbd_conn *conn,
 			 void *buf, unsigned int buflen,
-			 struct smb2_buffer_desc_v1 *desc,
+			 struct smbdirect_buffer_descriptor_v1 *desc,
 			 unsigned int desc_len)
 {
 	int ret = -EINVAL;
@@ -257,7 +257,7 @@ int ksmbd_conn_rdma_read(struct ksmbd_conn *conn,
 
 int ksmbd_conn_rdma_write(struct ksmbd_conn *conn,
 			  void *buf, unsigned int buflen,
-			  struct smb2_buffer_desc_v1 *desc,
+			  struct smbdirect_buffer_descriptor_v1 *desc,
 			  unsigned int desc_len)
 {
 	int ret = -EINVAL;
diff --git a/fs/smb/server/connection.h b/fs/smb/server/connection.h
index 2aa8084bb593..07b43634262a 100644
--- a/fs/smb/server/connection.h
+++ b/fs/smb/server/connection.h
@@ -19,6 +19,8 @@
 #include "smb_common.h"
 #include "ksmbd_work.h"
 
+struct smbdirect_buffer_descriptor_v1;
+
 #define KSMBD_SOCKET_BACKLOG		16
 
 enum {
@@ -133,11 +135,11 @@ struct ksmbd_transport_ops {
 		      unsigned int remote_key);
 	int (*rdma_read)(struct ksmbd_transport *t,
 			 void *buf, unsigned int len,
-			 struct smb2_buffer_desc_v1 *desc,
+			 struct smbdirect_buffer_descriptor_v1 *desc,
 			 unsigned int desc_len);
 	int (*rdma_write)(struct ksmbd_transport *t,
 			  void *buf, unsigned int len,
-			  struct smb2_buffer_desc_v1 *desc,
+			  struct smbdirect_buffer_descriptor_v1 *desc,
 			  unsigned int desc_len);
 	void (*free_transport)(struct ksmbd_transport *kt);
 };
@@ -163,11 +165,11 @@ bool ksmbd_conn_lookup_dialect(struct ksmbd_conn *c);
 int ksmbd_conn_write(struct ksmbd_work *work);
 int ksmbd_conn_rdma_read(struct ksmbd_conn *conn,
 			 void *buf, unsigned int buflen,
-			 struct smb2_buffer_desc_v1 *desc,
+			 struct smbdirect_buffer_descriptor_v1 *desc,
 			 unsigned int desc_len);
 int ksmbd_conn_rdma_write(struct ksmbd_conn *conn,
 			  void *buf, unsigned int buflen,
-			  struct smb2_buffer_desc_v1 *desc,
+			  struct smbdirect_buffer_descriptor_v1 *desc,
 			  unsigned int desc_len);
 void ksmbd_conn_enqueue_request(struct ksmbd_work *work);
 void ksmbd_conn_try_dequeue_request(struct ksmbd_work *work);
diff --git a/fs/smb/server/smb2pdu.c b/fs/smb/server/smb2pdu.c
index 0d92ce49aed7..a0ffd49d611a 100644
--- a/fs/smb/server/smb2pdu.c
+++ b/fs/smb/server/smb2pdu.c
@@ -23,6 +23,7 @@
 #include "asn1.h"
 #include "connection.h"
 #include "transport_ipc.h"
+#include "../common/smbdirect/smbdirect.h"
 #include "transport_rdma.h"
 #include "vfs.h"
 #include "vfs_cache.h"
@@ -6662,7 +6663,7 @@ static noinline int smb2_read_pipe(struct ksmbd_work *work)
 }
 
 static int smb2_set_remote_key_for_rdma(struct ksmbd_work *work,
-					struct smb2_buffer_desc_v1 *desc,
+					struct smbdirect_buffer_descriptor_v1 *desc,
 					__le32 Channel,
 					__le16 ChannelInfoLength)
 {
@@ -6698,7 +6699,7 @@ static ssize_t smb2_read_rdma_channel(struct ksmbd_work *work,
 	int err;
 
 	err = ksmbd_conn_rdma_write(work->conn, data_buf, length,
-				    (struct smb2_buffer_desc_v1 *)
+				    (struct smbdirect_buffer_descriptor_v1 *)
 				    ((char *)req + le16_to_cpu(req->ReadChannelInfoOffset)),
 				    le16_to_cpu(req->ReadChannelInfoLength));
 	if (err)
@@ -6769,7 +6770,7 @@ int smb2_read(struct ksmbd_work *work)
 			goto out;
 		}
 		err = smb2_set_remote_key_for_rdma(work,
-						   (struct smb2_buffer_desc_v1 *)
+						   (struct smbdirect_buffer_descriptor_v1 *)
 						   ((char *)req + ch_offset),
 						   req->Channel,
 						   req->ReadChannelInfoLength);
@@ -6964,7 +6965,7 @@ static ssize_t smb2_write_rdma_channel(struct ksmbd_work *work,
 		return -ENOMEM;
 
 	ret = ksmbd_conn_rdma_read(work->conn, data_buf, length,
-				   (struct smb2_buffer_desc_v1 *)
+				   (struct smbdirect_buffer_descriptor_v1 *)
 				   ((char *)req + le16_to_cpu(req->WriteChannelInfoOffset)),
 				   le16_to_cpu(req->WriteChannelInfoLength));
 	if (ret < 0) {
@@ -7029,7 +7030,7 @@ int smb2_write(struct ksmbd_work *work)
 			goto out;
 		}
 		err = smb2_set_remote_key_for_rdma(work,
-						   (struct smb2_buffer_desc_v1 *)
+						   (struct smbdirect_buffer_descriptor_v1 *)
 						   ((char *)req + ch_offset),
 						   req->Channel,
 						   req->WriteChannelInfoLength);
diff --git a/fs/smb/server/smb2pdu.h b/fs/smb/server/smb2pdu.h
index 16ae8a10490b..5163d5241b90 100644
--- a/fs/smb/server/smb2pdu.h
+++ b/fs/smb/server/smb2pdu.h
@@ -136,12 +136,6 @@ struct create_posix_rsp {
 	u8 SidBuffer[44];
 } __packed;
 
-struct smb2_buffer_desc_v1 {
-	__le64 offset;
-	__le32 token;
-	__le32 length;
-} __packed;
-
 #define SMB2_0_IOCTL_IS_FSCTL 0x00000001
 
 struct smb_sockaddr_in {
diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index ce6f2197d8d5..68b50804032b 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -23,6 +23,7 @@
 #include "connection.h"
 #include "smb_common.h"
 #include "../common/smb2status.h"
+#include "../common/smbdirect/smbdirect.h"
 #include "../common/smbdirect/smbdirect_pdu.h"
 #include "transport_rdma.h"
 
@@ -1342,7 +1343,7 @@ static void write_done(struct ib_cq *cq, struct ib_wc *wc)
 
 static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 				void *buf, int buf_len,
-				struct smb2_buffer_desc_v1 *desc,
+				struct smbdirect_buffer_descriptor_v1 *desc,
 				unsigned int desc_len,
 				bool is_read)
 {
@@ -1472,7 +1473,7 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 
 static int smb_direct_rdma_write(struct ksmbd_transport *t,
 				 void *buf, unsigned int buflen,
-				 struct smb2_buffer_desc_v1 *desc,
+				 struct smbdirect_buffer_descriptor_v1 *desc,
 				 unsigned int desc_len)
 {
 	return smb_direct_rdma_xmit(smb_trans_direct_transfort(t), buf, buflen,
@@ -1481,7 +1482,7 @@ static int smb_direct_rdma_write(struct ksmbd_transport *t,
 
 static int smb_direct_rdma_read(struct ksmbd_transport *t,
 				void *buf, unsigned int buflen,
-				struct smb2_buffer_desc_v1 *desc,
+				struct smbdirect_buffer_descriptor_v1 *desc,
 				unsigned int desc_len)
 {
 	return smb_direct_rdma_xmit(smb_trans_direct_transfort(t), buf, buflen,
-- 
2.43.0

[PATCH v4 078/142] smb: server: make use of common smbdirect_socket

[Stefan Metzmacher]

This is the next step in the direction of a common smbdirect layer.
Currently only structures are shared, but that will change
over time until everything is shared.

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Hyunchul Lee <hyc.lee@gmail.com>
Cc: Meetakshi Setiya <meetakshisetiyaoss@gmail.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Acked-by: Namjae Jeon <linkinjeon@kernel.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/server/transport_rdma.c | 241 ++++++++++++++++++---------------
 1 file changed, 133 insertions(+), 108 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 68b50804032b..a7b6c618353e 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -25,6 +25,7 @@
 #include "../common/smb2status.h"
 #include "../common/smbdirect/smbdirect.h"
 #include "../common/smbdirect/smbdirect_pdu.h"
+#include "../common/smbdirect/smbdirect_socket.h"
 #include "transport_rdma.h"
 
 #define SMB_DIRECT_PORT_IWARP		5445
@@ -89,26 +90,14 @@ static struct smb_direct_listener {
 
 static struct workqueue_struct *smb_direct_wq;
 
-enum smb_direct_status {
-	SMB_DIRECT_CS_NEW = 0,
-	SMB_DIRECT_CS_CONNECTED,
-	SMB_DIRECT_CS_DISCONNECTING,
-	SMB_DIRECT_CS_DISCONNECTED,
-};
-
 struct smb_direct_transport {
 	struct ksmbd_transport	transport;
 
-	enum smb_direct_status	status;
+	struct smbdirect_socket socket;
+
 	bool			full_packet_received;
 	wait_queue_head_t	wait_status;
 
-	struct rdma_cm_id	*cm_id;
-	struct ib_cq		*send_cq;
-	struct ib_cq		*recv_cq;
-	struct ib_pd		*pd;
-	struct ib_qp		*qp;
-
 	int			max_send_size;
 	int			max_recv_size;
 	int			max_fragmented_send_size;
@@ -271,8 +260,10 @@ smb_direct_recvmsg *get_free_recvmsg(struct smb_direct_transport *t)
 static void put_recvmsg(struct smb_direct_transport *t,
 			struct smb_direct_recvmsg *recvmsg)
 {
+	struct smbdirect_socket *sc = &t->socket;
+
 	if (likely(recvmsg->sge.length != 0)) {
-		ib_dma_unmap_single(t->cm_id->device,
+		ib_dma_unmap_single(sc->ib.dev,
 				    recvmsg->sge.addr,
 				    recvmsg->sge.length,
 				    DMA_FROM_DEVICE);
@@ -316,17 +307,20 @@ static void smb_direct_disconnect_rdma_work(struct work_struct *work)
 	struct smb_direct_transport *t =
 		container_of(work, struct smb_direct_transport,
 			     disconnect_work);
+	struct smbdirect_socket *sc = &t->socket;
 
-	if (t->status == SMB_DIRECT_CS_CONNECTED) {
-		t->status = SMB_DIRECT_CS_DISCONNECTING;
-		rdma_disconnect(t->cm_id);
+	if (sc->status == SMBDIRECT_SOCKET_CONNECTED) {
+		sc->status = SMBDIRECT_SOCKET_DISCONNECTING;
+		rdma_disconnect(sc->rdma.cm_id);
 	}
 }
 
 static void
 smb_direct_disconnect_rdma_connection(struct smb_direct_transport *t)
 {
-	if (t->status == SMB_DIRECT_CS_CONNECTED)
+	struct smbdirect_socket *sc = &t->socket;
+
+	if (sc->status == SMBDIRECT_SOCKET_CONNECTED)
 		queue_work(smb_direct_wq, &t->disconnect_work);
 }
 
@@ -334,8 +328,9 @@ static void smb_direct_send_immediate_work(struct work_struct *work)
 {
 	struct smb_direct_transport *t = container_of(work,
 			struct smb_direct_transport, send_immediate_work);
+	struct smbdirect_socket *sc = &t->socket;
 
-	if (t->status != SMB_DIRECT_CS_CONNECTED)
+	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
 		return;
 
 	smb_direct_post_send_data(t, NULL, NULL, 0, 0);
@@ -344,19 +339,23 @@ static void smb_direct_send_immediate_work(struct work_struct *work)
 static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 {
 	struct smb_direct_transport *t;
+	struct smbdirect_socket *sc;
 	struct ksmbd_conn *conn;
 
 	t = kzalloc(sizeof(*t), KSMBD_DEFAULT_GFP);
 	if (!t)
 		return NULL;
+	sc = &t->socket;
 
-	t->cm_id = cm_id;
+	sc->rdma.cm_id = cm_id;
 	cm_id->context = t;
 
 	t->initiator_depth = SMB_DIRECT_CM_INITIATOR_DEPTH;
 	t->responder_resources = 1;
 
-	t->status = SMB_DIRECT_CS_NEW;
+	sc->ib.dev = sc->rdma.cm_id->device;
+
+	sc->status = SMBDIRECT_SOCKET_CREATED;
 	init_waitqueue_head(&t->wait_status);
 
 	spin_lock_init(&t->reassembly_queue_lock);
@@ -400,6 +399,7 @@ static void smb_direct_free_transport(struct ksmbd_transport *kt)
 
 static void free_transport(struct smb_direct_transport *t)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	struct smb_direct_recvmsg *recvmsg;
 
 	wake_up_interruptible(&t->wait_send_credits);
@@ -412,11 +412,11 @@ static void free_transport(struct smb_direct_transport *t)
 	cancel_delayed_work_sync(&t->post_recv_credits_work);
 	cancel_work_sync(&t->send_immediate_work);
 
-	if (t->qp) {
-		ib_drain_qp(t->qp);
-		ib_mr_pool_destroy(t->qp, &t->qp->rdma_mrs);
-		t->qp = NULL;
-		rdma_destroy_qp(t->cm_id);
+	if (sc->ib.qp) {
+		ib_drain_qp(sc->ib.qp);
+		ib_mr_pool_destroy(sc->ib.qp, &sc->ib.qp->rdma_mrs);
+		sc->ib.qp = NULL;
+		rdma_destroy_qp(sc->rdma.cm_id);
 	}
 
 	ksmbd_debug(RDMA, "drain the reassembly queue\n");
@@ -433,14 +433,14 @@ static void free_transport(struct smb_direct_transport *t)
 	} while (recvmsg);
 	t->reassembly_data_length = 0;
 
-	if (t->send_cq)
-		ib_free_cq(t->send_cq);
-	if (t->recv_cq)
-		ib_free_cq(t->recv_cq);
-	if (t->pd)
-		ib_dealloc_pd(t->pd);
-	if (t->cm_id)
-		rdma_destroy_id(t->cm_id);
+	if (sc->ib.send_cq)
+		ib_free_cq(sc->ib.send_cq);
+	if (sc->ib.recv_cq)
+		ib_free_cq(sc->ib.recv_cq);
+	if (sc->ib.pd)
+		ib_dealloc_pd(sc->ib.pd);
+	if (sc->rdma.cm_id)
+		rdma_destroy_id(sc->rdma.cm_id);
 
 	smb_direct_destroy_pools(t);
 	ksmbd_conn_free(KSMBD_TRANS(t)->conn);
@@ -463,14 +463,15 @@ static struct smb_direct_sendmsg
 static void smb_direct_free_sendmsg(struct smb_direct_transport *t,
 				    struct smb_direct_sendmsg *msg)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	int i;
 
 	if (msg->num_sge > 0) {
-		ib_dma_unmap_single(t->cm_id->device,
+		ib_dma_unmap_single(sc->ib.dev,
 				    msg->sge[0].addr, msg->sge[0].length,
 				    DMA_TO_DEVICE);
 		for (i = 1; i < msg->num_sge; i++)
-			ib_dma_unmap_page(t->cm_id->device,
+			ib_dma_unmap_page(sc->ib.dev,
 					  msg->sge[i].addr, msg->sge[i].length,
 					  DMA_TO_DEVICE);
 	}
@@ -525,9 +526,11 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 {
 	struct smb_direct_recvmsg *recvmsg;
 	struct smb_direct_transport *t;
+	struct smbdirect_socket *sc;
 
 	recvmsg = container_of(wc->wr_cqe, struct smb_direct_recvmsg, cqe);
 	t = recvmsg->transport;
+	sc = &t->socket;
 
 	if (wc->status != IB_WC_SUCCESS || wc->opcode != IB_WC_RECV) {
 		put_recvmsg(t, recvmsg);
@@ -556,7 +559,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		}
 		t->negotiation_requested = true;
 		t->full_packet_received = true;
-		t->status = SMB_DIRECT_CS_CONNECTED;
+		sc->status = SMBDIRECT_SOCKET_CONNECTED;
 		enqueue_reassembly(t, recvmsg, 0);
 		wake_up_interruptible(&t->wait_status);
 		return;
@@ -638,17 +641,18 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 static int smb_direct_post_recv(struct smb_direct_transport *t,
 				struct smb_direct_recvmsg *recvmsg)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	struct ib_recv_wr wr;
 	int ret;
 
-	recvmsg->sge.addr = ib_dma_map_single(t->cm_id->device,
+	recvmsg->sge.addr = ib_dma_map_single(sc->ib.dev,
 					      recvmsg->packet, t->max_recv_size,
 					      DMA_FROM_DEVICE);
-	ret = ib_dma_mapping_error(t->cm_id->device, recvmsg->sge.addr);
+	ret = ib_dma_mapping_error(sc->ib.dev, recvmsg->sge.addr);
 	if (ret)
 		return ret;
 	recvmsg->sge.length = t->max_recv_size;
-	recvmsg->sge.lkey = t->pd->local_dma_lkey;
+	recvmsg->sge.lkey = sc->ib.pd->local_dma_lkey;
 	recvmsg->cqe.done = recv_done;
 
 	wr.wr_cqe = &recvmsg->cqe;
@@ -656,10 +660,10 @@ static int smb_direct_post_recv(struct smb_direct_transport *t,
 	wr.sg_list = &recvmsg->sge;
 	wr.num_sge = 1;
 
-	ret = ib_post_recv(t->qp, &wr, NULL);
+	ret = ib_post_recv(sc->ib.qp, &wr, NULL);
 	if (ret) {
 		pr_err("Can't post recv: %d\n", ret);
-		ib_dma_unmap_single(t->cm_id->device,
+		ib_dma_unmap_single(sc->ib.dev,
 				    recvmsg->sge.addr, recvmsg->sge.length,
 				    DMA_FROM_DEVICE);
 		recvmsg->sge.length = 0;
@@ -678,9 +682,10 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 	u32 data_length, remaining_data_length, data_offset;
 	int rc;
 	struct smb_direct_transport *st = smb_trans_direct_transfort(t);
+	struct smbdirect_socket *sc = &st->socket;
 
 again:
-	if (st->status != SMB_DIRECT_CS_CONNECTED) {
+	if (sc->status != SMBDIRECT_SOCKET_CONNECTED) {
 		pr_err("disconnected\n");
 		return -ENOTCONN;
 	}
@@ -790,7 +795,7 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 	ksmbd_debug(RDMA, "wait_event on more data\n");
 	rc = wait_event_interruptible(st->wait_reassembly_queue,
 				      st->reassembly_data_length >= size ||
-				       st->status != SMB_DIRECT_CS_CONNECTED);
+				       sc->status != SMBDIRECT_SOCKET_CONNECTED);
 	if (rc)
 		return -EINTR;
 
@@ -892,10 +897,11 @@ static int manage_credits_prior_sending(struct smb_direct_transport *t)
 static int smb_direct_post_send(struct smb_direct_transport *t,
 				struct ib_send_wr *wr)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	int ret;
 
 	atomic_inc(&t->send_pending);
-	ret = ib_post_send(t->qp, wr, NULL);
+	ret = ib_post_send(sc->ib.qp, wr, NULL);
 	if (ret) {
 		pr_err("failed to post send: %d\n", ret);
 		if (atomic_dec_and_test(&t->send_pending))
@@ -960,6 +966,7 @@ static int wait_for_credits(struct smb_direct_transport *t,
 			    wait_queue_head_t *waitq, atomic_t *total_credits,
 			    int needed)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	int ret;
 
 	do {
@@ -969,9 +976,9 @@ static int wait_for_credits(struct smb_direct_transport *t,
 		atomic_add(needed, total_credits);
 		ret = wait_event_interruptible(*waitq,
 					       atomic_read(total_credits) >= needed ||
-					       t->status != SMB_DIRECT_CS_CONNECTED);
+					       sc->status != SMBDIRECT_SOCKET_CONNECTED);
 
-		if (t->status != SMB_DIRECT_CS_CONNECTED)
+		if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
 			return -ENOTCONN;
 		else if (ret < 0)
 			return ret;
@@ -1009,6 +1016,7 @@ static int smb_direct_create_header(struct smb_direct_transport *t,
 				    int size, int remaining_data_length,
 				    struct smb_direct_sendmsg **sendmsg_out)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	struct smb_direct_sendmsg *sendmsg;
 	struct smbdirect_data_transfer *packet;
 	int header_length;
@@ -1048,11 +1056,11 @@ static int smb_direct_create_header(struct smb_direct_transport *t,
 		header_length =
 			offsetof(struct smbdirect_data_transfer, padding);
 
-	sendmsg->sge[0].addr = ib_dma_map_single(t->cm_id->device,
+	sendmsg->sge[0].addr = ib_dma_map_single(sc->ib.dev,
 						 (void *)packet,
 						 header_length,
 						 DMA_TO_DEVICE);
-	ret = ib_dma_mapping_error(t->cm_id->device, sendmsg->sge[0].addr);
+	ret = ib_dma_mapping_error(sc->ib.dev, sendmsg->sge[0].addr);
 	if (ret) {
 		smb_direct_free_sendmsg(t, sendmsg);
 		return ret;
@@ -1060,7 +1068,7 @@ static int smb_direct_create_header(struct smb_direct_transport *t,
 
 	sendmsg->num_sge = 1;
 	sendmsg->sge[0].length = header_length;
-	sendmsg->sge[0].lkey = t->pd->local_dma_lkey;
+	sendmsg->sge[0].lkey = sc->ib.pd->local_dma_lkey;
 
 	*sendmsg_out = sendmsg;
 	return 0;
@@ -1114,10 +1122,11 @@ static int post_sendmsg(struct smb_direct_transport *t,
 			struct smb_direct_send_ctx *send_ctx,
 			struct smb_direct_sendmsg *msg)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	int i;
 
 	for (i = 0; i < msg->num_sge; i++)
-		ib_dma_sync_single_for_device(t->cm_id->device,
+		ib_dma_sync_single_for_device(sc->ib.dev,
 					      msg->sge[i].addr, msg->sge[i].length,
 					      DMA_TO_DEVICE);
 
@@ -1153,6 +1162,7 @@ static int smb_direct_post_send_data(struct smb_direct_transport *t,
 				     struct kvec *iov, int niov,
 				     int remaining_data_length)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	int i, j, ret;
 	struct smb_direct_sendmsg *msg;
 	int data_length;
@@ -1178,7 +1188,7 @@ static int smb_direct_post_send_data(struct smb_direct_transport *t,
 		int sg_cnt;
 
 		sg_init_table(sg, SMB_DIRECT_MAX_SEND_SGES - 1);
-		sg_cnt = get_mapped_sg_list(t->cm_id->device,
+		sg_cnt = get_mapped_sg_list(sc->ib.dev,
 					    iov[i].iov_base, iov[i].iov_len,
 					    sg, SMB_DIRECT_MAX_SEND_SGES - 1,
 					    DMA_TO_DEVICE);
@@ -1189,7 +1199,7 @@ static int smb_direct_post_send_data(struct smb_direct_transport *t,
 		} else if (sg_cnt + msg->num_sge > SMB_DIRECT_MAX_SEND_SGES) {
 			pr_err("buffer not fitted into sges\n");
 			ret = -E2BIG;
-			ib_dma_unmap_sg(t->cm_id->device, sg, sg_cnt,
+			ib_dma_unmap_sg(sc->ib.dev, sg, sg_cnt,
 					DMA_TO_DEVICE);
 			goto err;
 		}
@@ -1198,7 +1208,7 @@ static int smb_direct_post_send_data(struct smb_direct_transport *t,
 			sge = &msg->sge[msg->num_sge];
 			sge->addr = sg_dma_address(&sg[j]);
 			sge->length = sg_dma_len(&sg[j]);
-			sge->lkey  = t->pd->local_dma_lkey;
+			sge->lkey  = sc->ib.pd->local_dma_lkey;
 			msg->num_sge++;
 		}
 	}
@@ -1218,6 +1228,7 @@ static int smb_direct_writev(struct ksmbd_transport *t,
 			     bool need_invalidate, unsigned int remote_key)
 {
 	struct smb_direct_transport *st = smb_trans_direct_transfort(t);
+	struct smbdirect_socket *sc = &st->socket;
 	int remaining_data_length;
 	int start, i, j;
 	int max_iov_size = st->max_send_size -
@@ -1226,7 +1237,7 @@ static int smb_direct_writev(struct ksmbd_transport *t,
 	struct kvec vec;
 	struct smb_direct_send_ctx send_ctx;
 
-	if (st->status != SMB_DIRECT_CS_CONNECTED)
+	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
 		return -ENOTCONN;
 
 	//FIXME: skip RFC1002 header..
@@ -1307,7 +1318,9 @@ static void smb_direct_free_rdma_rw_msg(struct smb_direct_transport *t,
 					struct smb_direct_rdma_rw_msg *msg,
 					enum dma_data_direction dir)
 {
-	rdma_rw_ctx_destroy(&msg->rw_ctx, t->qp, t->qp->port,
+	struct smbdirect_socket *sc = &t->socket;
+
+	rdma_rw_ctx_destroy(&msg->rw_ctx, sc->ib.qp, sc->ib.qp->port,
 			    msg->sgt.sgl, msg->sgt.nents, dir);
 	sg_free_table_chained(&msg->sgt, SG_CHUNK_SIZE);
 	kfree(msg);
@@ -1347,6 +1360,7 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 				unsigned int desc_len,
 				bool is_read)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	struct smb_direct_rdma_rw_msg *msg, *next_msg;
 	int i, ret;
 	DECLARE_COMPLETION_ONSTACK(completion);
@@ -1356,7 +1370,7 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 	int credits_needed;
 	unsigned int desc_buf_len, desc_num = 0;
 
-	if (t->status != SMB_DIRECT_CS_CONNECTED)
+	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
 		return -ENOTCONN;
 
 	if (buf_len > t->max_rdma_rw_size)
@@ -1426,7 +1440,7 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 			goto out;
 		}
 
-		ret = rdma_rw_ctx_init(&msg->rw_ctx, t->qp, t->qp->port,
+		ret = rdma_rw_ctx_init(&msg->rw_ctx, sc->ib.qp, sc->ib.qp->port,
 				       msg->sgt.sgl,
 				       get_buf_page_count(desc_buf, desc_buf_len),
 				       0,
@@ -1447,11 +1461,11 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 	/* concatenate work requests of rdma_rw_ctxs */
 	first_wr = NULL;
 	list_for_each_entry_reverse(msg, &msg_list, list) {
-		first_wr = rdma_rw_ctx_wrs(&msg->rw_ctx, t->qp, t->qp->port,
+		first_wr = rdma_rw_ctx_wrs(&msg->rw_ctx, sc->ib.qp, sc->ib.qp->port,
 					   &msg->cqe, first_wr);
 	}
 
-	ret = ib_post_send(t->qp, first_wr, NULL);
+	ret = ib_post_send(sc->ib.qp, first_wr, NULL);
 	if (ret) {
 		pr_err("failed to post send wr for RDMA R/W: %d\n", ret);
 		goto out;
@@ -1492,20 +1506,22 @@ static int smb_direct_rdma_read(struct ksmbd_transport *t,
 static void smb_direct_disconnect(struct ksmbd_transport *t)
 {
 	struct smb_direct_transport *st = smb_trans_direct_transfort(t);
+	struct smbdirect_socket *sc = &st->socket;
 
-	ksmbd_debug(RDMA, "Disconnecting cm_id=%p\n", st->cm_id);
+	ksmbd_debug(RDMA, "Disconnecting cm_id=%p\n", sc->rdma.cm_id);
 
 	smb_direct_disconnect_rdma_work(&st->disconnect_work);
 	wait_event_interruptible(st->wait_status,
-				 st->status == SMB_DIRECT_CS_DISCONNECTED);
+				 sc->status == SMBDIRECT_SOCKET_DISCONNECTED);
 	free_transport(st);
 }
 
 static void smb_direct_shutdown(struct ksmbd_transport *t)
 {
 	struct smb_direct_transport *st = smb_trans_direct_transfort(t);
+	struct smbdirect_socket *sc = &st->socket;
 
-	ksmbd_debug(RDMA, "smb-direct shutdown cm_id=%p\n", st->cm_id);
+	ksmbd_debug(RDMA, "smb-direct shutdown cm_id=%p\n", sc->rdma.cm_id);
 
 	smb_direct_disconnect_rdma_work(&st->disconnect_work);
 }
@@ -1514,28 +1530,29 @@ static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
 				 struct rdma_cm_event *event)
 {
 	struct smb_direct_transport *t = cm_id->context;
+	struct smbdirect_socket *sc = &t->socket;
 
 	ksmbd_debug(RDMA, "RDMA CM event. cm_id=%p event=%s (%d)\n",
 		    cm_id, rdma_event_msg(event->event), event->event);
 
 	switch (event->event) {
 	case RDMA_CM_EVENT_ESTABLISHED: {
-		t->status = SMB_DIRECT_CS_CONNECTED;
+		sc->status = SMBDIRECT_SOCKET_CONNECTED;
 		wake_up_interruptible(&t->wait_status);
 		break;
 	}
 	case RDMA_CM_EVENT_DEVICE_REMOVAL:
 	case RDMA_CM_EVENT_DISCONNECTED: {
-		ib_drain_qp(t->qp);
+		ib_drain_qp(sc->ib.qp);
 
-		t->status = SMB_DIRECT_CS_DISCONNECTED;
+		sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
 		wake_up_interruptible(&t->wait_status);
 		wake_up_interruptible(&t->wait_reassembly_queue);
 		wake_up(&t->wait_send_credits);
 		break;
 	}
 	case RDMA_CM_EVENT_CONNECT_ERROR: {
-		t->status = SMB_DIRECT_CS_DISCONNECTED;
+		sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
 		wake_up_interruptible(&t->wait_status);
 		break;
 	}
@@ -1551,9 +1568,10 @@ static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
 static void smb_direct_qpair_handler(struct ib_event *event, void *context)
 {
 	struct smb_direct_transport *t = context;
+	struct smbdirect_socket *sc = &t->socket;
 
 	ksmbd_debug(RDMA, "Received QP event. cm_id=%p, event=%s (%d)\n",
-		    t->cm_id, ib_event_msg(event->event), event->event);
+		    sc->rdma.cm_id, ib_event_msg(event->event), event->event);
 
 	switch (event->event) {
 	case IB_EVENT_CQ_ERR:
@@ -1568,6 +1586,7 @@ static void smb_direct_qpair_handler(struct ib_event *event, void *context)
 static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 					      int failed)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	struct smb_direct_sendmsg *sendmsg;
 	struct smbdirect_negotiate_resp *resp;
 	int ret;
@@ -1598,10 +1617,10 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 				cpu_to_le32(t->max_fragmented_recv_size);
 	}
 
-	sendmsg->sge[0].addr = ib_dma_map_single(t->cm_id->device,
+	sendmsg->sge[0].addr = ib_dma_map_single(sc->ib.dev,
 						 (void *)resp, sizeof(*resp),
 						 DMA_TO_DEVICE);
-	ret = ib_dma_mapping_error(t->cm_id->device, sendmsg->sge[0].addr);
+	ret = ib_dma_mapping_error(sc->ib.dev, sendmsg->sge[0].addr);
 	if (ret) {
 		smb_direct_free_sendmsg(t, sendmsg);
 		return ret;
@@ -1609,7 +1628,7 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 
 	sendmsg->num_sge = 1;
 	sendmsg->sge[0].length = sizeof(*resp);
-	sendmsg->sge[0].lkey = t->pd->local_dma_lkey;
+	sendmsg->sge[0].lkey = sc->ib.pd->local_dma_lkey;
 
 	ret = post_sendmsg(t, NULL, sendmsg);
 	if (ret) {
@@ -1624,6 +1643,7 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 
 static int smb_direct_accept_client(struct smb_direct_transport *t)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	struct rdma_conn_param conn_param;
 	__be32 ird_ord_hdr[2];
 	int ret;
@@ -1650,7 +1670,7 @@ static int smb_direct_accept_client(struct smb_direct_transport *t)
 	conn_param.rnr_retry_count = SMB_DIRECT_CM_RNR_RETRY;
 	conn_param.flow_control = 0;
 
-	ret = rdma_accept(t->cm_id, &conn_param);
+	ret = rdma_accept(sc->rdma.cm_id, &conn_param);
 	if (ret) {
 		pr_err("error at rdma_accept: %d\n", ret);
 		return ret;
@@ -1690,15 +1710,18 @@ static int smb_direct_prepare_negotiation(struct smb_direct_transport *t)
 
 static unsigned int smb_direct_get_max_fr_pages(struct smb_direct_transport *t)
 {
+	struct smbdirect_socket *sc = &t->socket;
+
 	return min_t(unsigned int,
-		     t->cm_id->device->attrs.max_fast_reg_page_list_len,
+		     sc->ib.dev->attrs.max_fast_reg_page_list_len,
 		     256);
 }
 
 static int smb_direct_init_params(struct smb_direct_transport *t,
 				  struct ib_qp_cap *cap)
 {
-	struct ib_device *device = t->cm_id->device;
+	struct smbdirect_socket *sc = &t->socket;
+	struct ib_device *device = sc->ib.dev;
 	int max_send_sges, max_rw_wrs, max_send_wrs;
 	unsigned int max_sge_per_wr, wrs_per_credit;
 
@@ -1858,34 +1881,35 @@ static int smb_direct_create_pools(struct smb_direct_transport *t)
 static int smb_direct_create_qpair(struct smb_direct_transport *t,
 				   struct ib_qp_cap *cap)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	int ret;
 	struct ib_qp_init_attr qp_attr;
 	int pages_per_rw;
 
-	t->pd = ib_alloc_pd(t->cm_id->device, 0);
-	if (IS_ERR(t->pd)) {
+	sc->ib.pd = ib_alloc_pd(sc->ib.dev, 0);
+	if (IS_ERR(sc->ib.pd)) {
 		pr_err("Can't create RDMA PD\n");
-		ret = PTR_ERR(t->pd);
-		t->pd = NULL;
+		ret = PTR_ERR(sc->ib.pd);
+		sc->ib.pd = NULL;
 		return ret;
 	}
 
-	t->send_cq = ib_alloc_cq(t->cm_id->device, t,
+	sc->ib.send_cq = ib_alloc_cq(sc->ib.dev, t,
 				 smb_direct_send_credit_target + cap->max_rdma_ctxs,
 				 0, IB_POLL_WORKQUEUE);
-	if (IS_ERR(t->send_cq)) {
+	if (IS_ERR(sc->ib.send_cq)) {
 		pr_err("Can't create RDMA send CQ\n");
-		ret = PTR_ERR(t->send_cq);
-		t->send_cq = NULL;
+		ret = PTR_ERR(sc->ib.send_cq);
+		sc->ib.send_cq = NULL;
 		goto err;
 	}
 
-	t->recv_cq = ib_alloc_cq(t->cm_id->device, t,
+	sc->ib.recv_cq = ib_alloc_cq(sc->ib.dev, t,
 				 t->recv_credit_max, 0, IB_POLL_WORKQUEUE);
-	if (IS_ERR(t->recv_cq)) {
+	if (IS_ERR(sc->ib.recv_cq)) {
 		pr_err("Can't create RDMA recv CQ\n");
-		ret = PTR_ERR(t->recv_cq);
-		t->recv_cq = NULL;
+		ret = PTR_ERR(sc->ib.recv_cq);
+		sc->ib.recv_cq = NULL;
 		goto err;
 	}
 
@@ -1895,22 +1919,22 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 	qp_attr.cap = *cap;
 	qp_attr.sq_sig_type = IB_SIGNAL_REQ_WR;
 	qp_attr.qp_type = IB_QPT_RC;
-	qp_attr.send_cq = t->send_cq;
-	qp_attr.recv_cq = t->recv_cq;
+	qp_attr.send_cq = sc->ib.send_cq;
+	qp_attr.recv_cq = sc->ib.recv_cq;
 	qp_attr.port_num = ~0;
 
-	ret = rdma_create_qp(t->cm_id, t->pd, &qp_attr);
+	ret = rdma_create_qp(sc->rdma.cm_id, sc->ib.pd, &qp_attr);
 	if (ret) {
 		pr_err("Can't create RDMA QP: %d\n", ret);
 		goto err;
 	}
 
-	t->qp = t->cm_id->qp;
-	t->cm_id->event_handler = smb_direct_cm_handler;
+	sc->ib.qp = sc->rdma.cm_id->qp;
+	sc->rdma.cm_id->event_handler = smb_direct_cm_handler;
 
 	pages_per_rw = DIV_ROUND_UP(t->max_rdma_rw_size, PAGE_SIZE) + 1;
-	if (pages_per_rw > t->cm_id->device->attrs.max_sgl_rd) {
-		ret = ib_mr_pool_init(t->qp, &t->qp->rdma_mrs,
+	if (pages_per_rw > sc->ib.dev->attrs.max_sgl_rd) {
+		ret = ib_mr_pool_init(sc->ib.qp, &sc->ib.qp->rdma_mrs,
 				      t->max_rw_credits, IB_MR_TYPE_MEM_REG,
 				      t->pages_per_rw_credit, 0);
 		if (ret) {
@@ -1922,21 +1946,21 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 
 	return 0;
 err:
-	if (t->qp) {
-		t->qp = NULL;
-		rdma_destroy_qp(t->cm_id);
+	if (sc->ib.qp) {
+		sc->ib.qp = NULL;
+		rdma_destroy_qp(sc->rdma.cm_id);
 	}
-	if (t->recv_cq) {
-		ib_destroy_cq(t->recv_cq);
-		t->recv_cq = NULL;
+	if (sc->ib.recv_cq) {
+		ib_destroy_cq(sc->ib.recv_cq);
+		sc->ib.recv_cq = NULL;
 	}
-	if (t->send_cq) {
-		ib_destroy_cq(t->send_cq);
-		t->send_cq = NULL;
+	if (sc->ib.send_cq) {
+		ib_destroy_cq(sc->ib.send_cq);
+		sc->ib.send_cq = NULL;
 	}
-	if (t->pd) {
-		ib_dealloc_pd(t->pd);
-		t->pd = NULL;
+	if (sc->ib.pd) {
+		ib_dealloc_pd(sc->ib.pd);
+		sc->ib.pd = NULL;
 	}
 	return ret;
 }
@@ -1944,6 +1968,7 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 static int smb_direct_prepare(struct ksmbd_transport *t)
 {
 	struct smb_direct_transport *st = smb_trans_direct_transfort(t);
+	struct smbdirect_socket *sc = &st->socket;
 	struct smb_direct_recvmsg *recvmsg;
 	struct smbdirect_negotiate_req *req;
 	int ret;
@@ -1951,9 +1976,9 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 	ksmbd_debug(RDMA, "Waiting for SMB_DIRECT negotiate request\n");
 	ret = wait_event_interruptible_timeout(st->wait_status,
 					       st->negotiation_requested ||
-					       st->status == SMB_DIRECT_CS_DISCONNECTED,
+					       sc->status == SMBDIRECT_SOCKET_DISCONNECTED,
 					       SMB_DIRECT_NEGOTIATE_TIMEOUT * HZ);
-	if (ret <= 0 || st->status == SMB_DIRECT_CS_DISCONNECTED)
+	if (ret <= 0 || sc->status == SMBDIRECT_SOCKET_DISCONNECTED)
 		return ret < 0 ? ret : -ETIMEDOUT;
 
 	recvmsg = get_first_reassembly(st);
-- 
2.43.0

[PATCH v4 079/142] smb: server: make use of common smbdirect_socket_parameters

[Stefan Metzmacher]

Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: Long Li <longli@microsoft.com>
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Hyunchul Lee <hyc.lee@gmail.com>
Cc: Meetakshi Setiya <meetakshisetiyaoss@gmail.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Acked-by: Namjae Jeon <linkinjeon@kernel.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/server/transport_rdma.c | 85 ++++++++++++++++++----------------
 1 file changed, 44 insertions(+), 41 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index a7b6c618353e..9f2a0c94988e 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -98,12 +98,6 @@ struct smb_direct_transport {
 	bool			full_packet_received;
 	wait_queue_head_t	wait_status;
 
-	int			max_send_size;
-	int			max_recv_size;
-	int			max_fragmented_send_size;
-	int			max_fragmented_recv_size;
-	int			max_rdma_rw_size;
-
 	spinlock_t		reassembly_queue_lock;
 	struct list_head	reassembly_queue;
 	int			reassembly_data_length;
@@ -114,13 +108,11 @@ struct smb_direct_transport {
 	spinlock_t		receive_credit_lock;
 	int			recv_credits;
 	int			count_avail_recvmsg;
-	int			recv_credit_max;
 	int			recv_credit_target;
 
 	spinlock_t		recvmsg_queue_lock;
 	struct list_head	recvmsg_queue;
 
-	int			send_credit_target;
 	atomic_t		send_credits;
 	spinlock_t		lock_new_recv_credits;
 	int			new_recv_credits;
@@ -642,16 +634,18 @@ static int smb_direct_post_recv(struct smb_direct_transport *t,
 				struct smb_direct_recvmsg *recvmsg)
 {
 	struct smbdirect_socket *sc = &t->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct ib_recv_wr wr;
 	int ret;
 
 	recvmsg->sge.addr = ib_dma_map_single(sc->ib.dev,
-					      recvmsg->packet, t->max_recv_size,
+					      recvmsg->packet,
+					      sp->max_recv_size,
 					      DMA_FROM_DEVICE);
 	ret = ib_dma_mapping_error(sc->ib.dev, recvmsg->sge.addr);
 	if (ret)
 		return ret;
-	recvmsg->sge.length = t->max_recv_size;
+	recvmsg->sge.length = sp->max_recv_size;
 	recvmsg->sge.lkey = sc->ib.pd->local_dma_lkey;
 	recvmsg->cqe.done = recv_done;
 
@@ -1017,6 +1011,7 @@ static int smb_direct_create_header(struct smb_direct_transport *t,
 				    struct smb_direct_sendmsg **sendmsg_out)
 {
 	struct smbdirect_socket *sc = &t->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct smb_direct_sendmsg *sendmsg;
 	struct smbdirect_data_transfer *packet;
 	int header_length;
@@ -1028,7 +1023,7 @@ static int smb_direct_create_header(struct smb_direct_transport *t,
 
 	/* Fill in the packet header */
 	packet = (struct smbdirect_data_transfer *)sendmsg->packet;
-	packet->credits_requested = cpu_to_le16(t->send_credit_target);
+	packet->credits_requested = cpu_to_le16(sp->send_credit_target);
 	packet->credits_granted = cpu_to_le16(manage_credits_prior_sending(t));
 
 	packet->flags = 0;
@@ -1229,9 +1224,10 @@ static int smb_direct_writev(struct ksmbd_transport *t,
 {
 	struct smb_direct_transport *st = smb_trans_direct_transfort(t);
 	struct smbdirect_socket *sc = &st->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	int remaining_data_length;
 	int start, i, j;
-	int max_iov_size = st->max_send_size -
+	int max_iov_size = sp->max_send_size -
 			sizeof(struct smbdirect_data_transfer);
 	int ret;
 	struct kvec vec;
@@ -1361,6 +1357,7 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 				bool is_read)
 {
 	struct smbdirect_socket *sc = &t->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct smb_direct_rdma_rw_msg *msg, *next_msg;
 	int i, ret;
 	DECLARE_COMPLETION_ONSTACK(completion);
@@ -1373,7 +1370,7 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
 		return -ENOTCONN;
 
-	if (buf_len > t->max_rdma_rw_size)
+	if (buf_len > sp->max_read_write_size)
 		return -EINVAL;
 
 	/* calculate needed credits */
@@ -1587,6 +1584,7 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 					      int failed)
 {
 	struct smbdirect_socket *sc = &t->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct smb_direct_sendmsg *sendmsg;
 	struct smbdirect_negotiate_resp *resp;
 	int ret;
@@ -1608,13 +1606,13 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 		resp->negotiated_version = SMB_DIRECT_VERSION_LE;
 		resp->reserved = 0;
 		resp->credits_requested =
-				cpu_to_le16(t->send_credit_target);
+				cpu_to_le16(sp->send_credit_target);
 		resp->credits_granted = cpu_to_le16(manage_credits_prior_sending(t));
-		resp->max_readwrite_size = cpu_to_le32(t->max_rdma_rw_size);
-		resp->preferred_send_size = cpu_to_le32(t->max_send_size);
-		resp->max_receive_size = cpu_to_le32(t->max_recv_size);
+		resp->max_readwrite_size = cpu_to_le32(sp->max_read_write_size);
+		resp->preferred_send_size = cpu_to_le32(sp->max_send_size);
+		resp->max_receive_size = cpu_to_le32(sp->max_recv_size);
 		resp->max_fragmented_size =
-				cpu_to_le32(t->max_fragmented_recv_size);
+				cpu_to_le32(sp->max_fragmented_recv_size);
 	}
 
 	sendmsg->sge[0].addr = ib_dma_map_single(sc->ib.dev,
@@ -1721,6 +1719,7 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 				  struct ib_qp_cap *cap)
 {
 	struct smbdirect_socket *sc = &t->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct ib_device *device = sc->ib.dev;
 	int max_send_sges, max_rw_wrs, max_send_wrs;
 	unsigned int max_sge_per_wr, wrs_per_credit;
@@ -1728,10 +1727,10 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	/* need 3 more sge. because a SMB_DIRECT header, SMB2 header,
 	 * SMB2 response could be mapped.
 	 */
-	t->max_send_size = smb_direct_max_send_size;
-	max_send_sges = DIV_ROUND_UP(t->max_send_size, PAGE_SIZE) + 3;
+	sp->max_send_size = smb_direct_max_send_size;
+	max_send_sges = DIV_ROUND_UP(sp->max_send_size, PAGE_SIZE) + 3;
 	if (max_send_sges > SMB_DIRECT_MAX_SEND_SGES) {
-		pr_err("max_send_size %d is too large\n", t->max_send_size);
+		pr_err("max_send_size %d is too large\n", sp->max_send_size);
 		return -EINVAL;
 	}
 
@@ -1742,9 +1741,9 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	 * are needed for MR registration, RDMA R/W, local & remote
 	 * MR invalidation.
 	 */
-	t->max_rdma_rw_size = smb_direct_max_read_write_size;
+	sp->max_read_write_size = smb_direct_max_read_write_size;
 	t->pages_per_rw_credit = smb_direct_get_max_fr_pages(t);
-	t->max_rw_credits = DIV_ROUND_UP(t->max_rdma_rw_size,
+	t->max_rw_credits = DIV_ROUND_UP(sp->max_read_write_size,
 					 (t->pages_per_rw_credit - 1) *
 					 PAGE_SIZE);
 
@@ -1785,20 +1784,20 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	t->recv_credits = 0;
 	t->count_avail_recvmsg = 0;
 
-	t->recv_credit_max = smb_direct_receive_credit_max;
+	sp->recv_credit_max = smb_direct_receive_credit_max;
 	t->recv_credit_target = 10;
 	t->new_recv_credits = 0;
 
-	t->send_credit_target = smb_direct_send_credit_target;
+	sp->send_credit_target = smb_direct_send_credit_target;
 	atomic_set(&t->send_credits, 0);
 	atomic_set(&t->rw_credits, t->max_rw_credits);
 
-	t->max_send_size = smb_direct_max_send_size;
-	t->max_recv_size = smb_direct_max_receive_size;
-	t->max_fragmented_recv_size = smb_direct_max_fragmented_recv_size;
+	sp->max_send_size = smb_direct_max_send_size;
+	sp->max_recv_size = smb_direct_max_receive_size;
+	sp->max_fragmented_recv_size = smb_direct_max_fragmented_recv_size;
 
 	cap->max_send_wr = max_send_wrs;
-	cap->max_recv_wr = t->recv_credit_max;
+	cap->max_recv_wr = sp->recv_credit_max;
 	cap->max_send_sge = max_sge_per_wr;
 	cap->max_recv_sge = SMB_DIRECT_MAX_RECV_SGES;
 	cap->max_inline_data = 0;
@@ -1828,6 +1827,8 @@ static void smb_direct_destroy_pools(struct smb_direct_transport *t)
 
 static int smb_direct_create_pools(struct smb_direct_transport *t)
 {
+	struct smbdirect_socket *sc = &t->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	char name[80];
 	int i;
 	struct smb_direct_recvmsg *recvmsg;
@@ -1840,7 +1841,7 @@ static int smb_direct_create_pools(struct smb_direct_transport *t)
 	if (!t->sendmsg_cache)
 		return -ENOMEM;
 
-	t->sendmsg_mempool = mempool_create(t->send_credit_target,
+	t->sendmsg_mempool = mempool_create(sp->send_credit_target,
 					    mempool_alloc_slab, mempool_free_slab,
 					    t->sendmsg_cache);
 	if (!t->sendmsg_mempool)
@@ -1849,20 +1850,20 @@ static int smb_direct_create_pools(struct smb_direct_transport *t)
 	snprintf(name, sizeof(name), "smb_direct_resp_%p", t);
 	t->recvmsg_cache = kmem_cache_create(name,
 					     sizeof(struct smb_direct_recvmsg) +
-					      t->max_recv_size,
+					     sp->max_recv_size,
 					     0, SLAB_HWCACHE_ALIGN, NULL);
 	if (!t->recvmsg_cache)
 		goto err;
 
 	t->recvmsg_mempool =
-		mempool_create(t->recv_credit_max, mempool_alloc_slab,
+		mempool_create(sp->recv_credit_max, mempool_alloc_slab,
 			       mempool_free_slab, t->recvmsg_cache);
 	if (!t->recvmsg_mempool)
 		goto err;
 
 	INIT_LIST_HEAD(&t->recvmsg_queue);
 
-	for (i = 0; i < t->recv_credit_max; i++) {
+	for (i = 0; i < sp->recv_credit_max; i++) {
 		recvmsg = mempool_alloc(t->recvmsg_mempool, KSMBD_DEFAULT_GFP);
 		if (!recvmsg)
 			goto err;
@@ -1870,7 +1871,7 @@ static int smb_direct_create_pools(struct smb_direct_transport *t)
 		recvmsg->sge.length = 0;
 		list_add(&recvmsg->list, &t->recvmsg_queue);
 	}
-	t->count_avail_recvmsg = t->recv_credit_max;
+	t->count_avail_recvmsg = sp->recv_credit_max;
 
 	return 0;
 err:
@@ -1882,6 +1883,7 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 				   struct ib_qp_cap *cap)
 {
 	struct smbdirect_socket *sc = &t->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	int ret;
 	struct ib_qp_init_attr qp_attr;
 	int pages_per_rw;
@@ -1905,7 +1907,7 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 	}
 
 	sc->ib.recv_cq = ib_alloc_cq(sc->ib.dev, t,
-				 t->recv_credit_max, 0, IB_POLL_WORKQUEUE);
+				     sp->recv_credit_max, 0, IB_POLL_WORKQUEUE);
 	if (IS_ERR(sc->ib.recv_cq)) {
 		pr_err("Can't create RDMA recv CQ\n");
 		ret = PTR_ERR(sc->ib.recv_cq);
@@ -1932,7 +1934,7 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 	sc->ib.qp = sc->rdma.cm_id->qp;
 	sc->rdma.cm_id->event_handler = smb_direct_cm_handler;
 
-	pages_per_rw = DIV_ROUND_UP(t->max_rdma_rw_size, PAGE_SIZE) + 1;
+	pages_per_rw = DIV_ROUND_UP(sp->max_read_write_size, PAGE_SIZE) + 1;
 	if (pages_per_rw > sc->ib.dev->attrs.max_sgl_rd) {
 		ret = ib_mr_pool_init(sc->ib.qp, &sc->ib.qp->rdma_mrs,
 				      t->max_rw_credits, IB_MR_TYPE_MEM_REG,
@@ -1969,6 +1971,7 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 {
 	struct smb_direct_transport *st = smb_trans_direct_transfort(t);
 	struct smbdirect_socket *sc = &st->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct smb_direct_recvmsg *recvmsg;
 	struct smbdirect_negotiate_req *req;
 	int ret;
@@ -1990,14 +1993,14 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 		goto out;
 
 	req = (struct smbdirect_negotiate_req *)recvmsg->packet;
-	st->max_recv_size = min_t(int, st->max_recv_size,
+	sp->max_recv_size = min_t(int, sp->max_recv_size,
 				  le32_to_cpu(req->preferred_send_size));
-	st->max_send_size = min_t(int, st->max_send_size,
+	sp->max_send_size = min_t(int, sp->max_send_size,
 				  le32_to_cpu(req->max_receive_size));
-	st->max_fragmented_send_size =
+	sp->max_fragmented_send_size =
 		le32_to_cpu(req->max_fragmented_size);
-	st->max_fragmented_recv_size =
-		(st->recv_credit_max * st->max_recv_size) / 2;
+	sp->max_fragmented_recv_size =
+		(sp->recv_credit_max * sp->max_recv_size) / 2;
 
 	ret = smb_direct_send_negotiate_response(st, ret);
 out:
-- 
2.43.0

[PATCH v4 080/142] smb: server: make use of smbdirect_socket->recv_io.expected

[Stefan Metzmacher]

The expected incoming message type can be per connection.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Acked-by: Namjae Jeon <linkinjeon@kernel.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/server/transport_rdma.c | 44 +++++++++++++++++++---------------
 1 file changed, 25 insertions(+), 19 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 9f2a0c94988e..2cf6941a643d 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -145,10 +145,6 @@ struct smb_direct_transport {
 #define KSMBD_TRANS(t) ((struct ksmbd_transport *)&((t)->transport))
 #define SMBD_TRANS(t)	((struct smb_direct_transport *)container_of(t, \
 				struct smb_direct_transport, transport))
-enum {
-	SMB_DIRECT_MSG_NEGOTIATE_REQ = 0,
-	SMB_DIRECT_MSG_DATA_TRANSFER
-};
 
 static const struct ksmbd_transport_ops ksmbd_smb_direct_transport_ops;
 
@@ -172,7 +168,6 @@ struct smb_direct_sendmsg {
 struct smb_direct_recvmsg {
 	struct smb_direct_transport	*transport;
 	struct list_head	list;
-	int			type;
 	struct ib_sge		sge;
 	struct ib_cqe		cqe;
 	bool			first_segment;
@@ -472,8 +467,10 @@ static void smb_direct_free_sendmsg(struct smb_direct_transport *t,
 
 static int smb_direct_check_recvmsg(struct smb_direct_recvmsg *recvmsg)
 {
-	switch (recvmsg->type) {
-	case SMB_DIRECT_MSG_DATA_TRANSFER: {
+	struct smbdirect_socket *sc = &recvmsg->transport->socket;
+
+	switch (sc->recv_io.expected) {
+	case SMBDIRECT_EXPECT_DATA_TRANSFER: {
 		struct smbdirect_data_transfer *req =
 			(struct smbdirect_data_transfer *)recvmsg->packet;
 		struct smb2_hdr *hdr = (struct smb2_hdr *)(recvmsg->packet
@@ -484,9 +481,9 @@ static int smb_direct_check_recvmsg(struct smb_direct_recvmsg *recvmsg)
 			    le16_to_cpu(req->credits_requested),
 			    req->data_length, req->remaining_data_length,
 			    hdr->ProtocolId, hdr->Command);
-		break;
+		return 0;
 	}
-	case SMB_DIRECT_MSG_NEGOTIATE_REQ: {
+	case SMBDIRECT_EXPECT_NEGOTIATE_REQ: {
 		struct smbdirect_negotiate_req *req =
 			(struct smbdirect_negotiate_req *)recvmsg->packet;
 		ksmbd_debug(RDMA,
@@ -506,12 +503,15 @@ static int smb_direct_check_recvmsg(struct smb_direct_recvmsg *recvmsg)
 					128 * 1024)
 			return -ECONNABORTED;
 
-		break;
+		return 0;
 	}
-	default:
-		return -EINVAL;
+	case SMBDIRECT_EXPECT_NEGOTIATE_REP:
+		/* client only */
+		break;
 	}
-	return 0;
+
+	/* This is an internal error */
+	return -EINVAL;
 }
 
 static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
@@ -542,8 +542,8 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	ib_dma_sync_single_for_cpu(wc->qp->device, recvmsg->sge.addr,
 				   recvmsg->sge.length, DMA_FROM_DEVICE);
 
-	switch (recvmsg->type) {
-	case SMB_DIRECT_MSG_NEGOTIATE_REQ:
+	switch (sc->recv_io.expected) {
+	case SMBDIRECT_EXPECT_NEGOTIATE_REQ:
 		if (wc->byte_len < sizeof(struct smbdirect_negotiate_req)) {
 			put_recvmsg(t, recvmsg);
 			smb_direct_disconnect_rdma_connection(t);
@@ -555,7 +555,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		enqueue_reassembly(t, recvmsg, 0);
 		wake_up_interruptible(&t->wait_status);
 		return;
-	case SMB_DIRECT_MSG_DATA_TRANSFER: {
+	case SMBDIRECT_EXPECT_DATA_TRANSFER: {
 		struct smbdirect_data_transfer *data_transfer =
 			(struct smbdirect_data_transfer *)recvmsg->packet;
 		unsigned int data_length;
@@ -620,12 +620,15 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 
 		return;
 	}
+	case SMBDIRECT_EXPECT_NEGOTIATE_REP:
+		/* client only */
+		break;
 	}
 
 	/*
 	 * This is an internal error!
 	 */
-	WARN_ON_ONCE(recvmsg->type != SMB_DIRECT_MSG_DATA_TRANSFER);
+	WARN_ON_ONCE(sc->recv_io.expected != SMBDIRECT_EXPECT_DATA_TRANSFER);
 	put_recvmsg(t, recvmsg);
 	smb_direct_disconnect_rdma_connection(t);
 }
@@ -814,7 +817,6 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
 			if (!recvmsg)
 				break;
 
-			recvmsg->type = SMB_DIRECT_MSG_DATA_TRANSFER;
 			recvmsg->first_segment = false;
 
 			ret = smb_direct_post_recv(t, recvmsg);
@@ -1613,6 +1615,8 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 		resp->max_receive_size = cpu_to_le32(sp->max_recv_size);
 		resp->max_fragmented_size =
 				cpu_to_le32(sp->max_fragmented_recv_size);
+
+		sc->recv_io.expected = SMBDIRECT_EXPECT_DATA_TRANSFER;
 	}
 
 	sendmsg->sge[0].addr = ib_dma_map_single(sc->ib.dev,
@@ -1678,13 +1682,15 @@ static int smb_direct_accept_client(struct smb_direct_transport *t)
 
 static int smb_direct_prepare_negotiation(struct smb_direct_transport *t)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	int ret;
 	struct smb_direct_recvmsg *recvmsg;
 
+	sc->recv_io.expected = SMBDIRECT_EXPECT_NEGOTIATE_REQ;
+
 	recvmsg = get_free_recvmsg(t);
 	if (!recvmsg)
 		return -ENOMEM;
-	recvmsg->type = SMB_DIRECT_MSG_NEGOTIATE_REQ;
 
 	ret = smb_direct_post_recv(t, recvmsg);
 	if (ret) {
-- 
2.43.0

[PATCH v4 081/142] smb: server: make use of struct smbdirect_recv_io

[Stefan Metzmacher]

This will allow us to move helper functions into common code soon
as the client already uses smbdirect_recv_io.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Acked-by: Namjae Jeon <linkinjeon@kernel.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/server/transport_rdma.c | 61 +++++++++++++++-------------------
 1 file changed, 26 insertions(+), 35 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 2cf6941a643d..edc7968d46fc 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -165,15 +165,6 @@ struct smb_direct_sendmsg {
 	u8			packet[];
 };
 
-struct smb_direct_recvmsg {
-	struct smb_direct_transport	*transport;
-	struct list_head	list;
-	struct ib_sge		sge;
-	struct ib_cqe		cqe;
-	bool			first_segment;
-	u8			packet[];
-};
-
 struct smb_direct_rdma_rw_msg {
 	struct smb_direct_transport	*t;
 	struct ib_cqe		cqe;
@@ -216,7 +207,7 @@ smb_trans_direct_transfort(struct ksmbd_transport *t)
 }
 
 static inline void
-*smb_direct_recvmsg_payload(struct smb_direct_recvmsg *recvmsg)
+*smbdirect_recv_io_payload(struct smbdirect_recv_io *recvmsg)
 {
 	return (void *)recvmsg->packet;
 }
@@ -229,14 +220,14 @@ static inline bool is_receive_credit_post_required(int receive_credits,
 }
 
 static struct
-smb_direct_recvmsg *get_free_recvmsg(struct smb_direct_transport *t)
+smbdirect_recv_io *get_free_recvmsg(struct smb_direct_transport *t)
 {
-	struct smb_direct_recvmsg *recvmsg = NULL;
+	struct smbdirect_recv_io *recvmsg = NULL;
 
 	spin_lock(&t->recvmsg_queue_lock);
 	if (!list_empty(&t->recvmsg_queue)) {
 		recvmsg = list_first_entry(&t->recvmsg_queue,
-					   struct smb_direct_recvmsg,
+					   struct smbdirect_recv_io,
 					   list);
 		list_del(&recvmsg->list);
 	}
@@ -245,7 +236,7 @@ smb_direct_recvmsg *get_free_recvmsg(struct smb_direct_transport *t)
 }
 
 static void put_recvmsg(struct smb_direct_transport *t,
-			struct smb_direct_recvmsg *recvmsg)
+			struct smbdirect_recv_io *recvmsg)
 {
 	struct smbdirect_socket *sc = &t->socket;
 
@@ -263,7 +254,7 @@ static void put_recvmsg(struct smb_direct_transport *t,
 }
 
 static void enqueue_reassembly(struct smb_direct_transport *t,
-			       struct smb_direct_recvmsg *recvmsg,
+			       struct smbdirect_recv_io *recvmsg,
 			       int data_length)
 {
 	spin_lock(&t->reassembly_queue_lock);
@@ -280,11 +271,11 @@ static void enqueue_reassembly(struct smb_direct_transport *t,
 	spin_unlock(&t->reassembly_queue_lock);
 }
 
-static struct smb_direct_recvmsg *get_first_reassembly(struct smb_direct_transport *t)
+static struct smbdirect_recv_io *get_first_reassembly(struct smb_direct_transport *t)
 {
 	if (!list_empty(&t->reassembly_queue))
 		return list_first_entry(&t->reassembly_queue,
-				struct smb_direct_recvmsg, list);
+				struct smbdirect_recv_io, list);
 	else
 		return NULL;
 }
@@ -387,7 +378,7 @@ static void smb_direct_free_transport(struct ksmbd_transport *kt)
 static void free_transport(struct smb_direct_transport *t)
 {
 	struct smbdirect_socket *sc = &t->socket;
-	struct smb_direct_recvmsg *recvmsg;
+	struct smbdirect_recv_io *recvmsg;
 
 	wake_up_interruptible(&t->wait_send_credits);
 
@@ -465,9 +456,9 @@ static void smb_direct_free_sendmsg(struct smb_direct_transport *t,
 	mempool_free(msg, t->sendmsg_mempool);
 }
 
-static int smb_direct_check_recvmsg(struct smb_direct_recvmsg *recvmsg)
+static int smb_direct_check_recvmsg(struct smbdirect_recv_io *recvmsg)
 {
-	struct smbdirect_socket *sc = &recvmsg->transport->socket;
+	struct smbdirect_socket *sc = recvmsg->socket;
 
 	switch (sc->recv_io.expected) {
 	case SMBDIRECT_EXPECT_DATA_TRANSFER: {
@@ -516,13 +507,13 @@ static int smb_direct_check_recvmsg(struct smb_direct_recvmsg *recvmsg)
 
 static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 {
-	struct smb_direct_recvmsg *recvmsg;
+	struct smbdirect_recv_io *recvmsg;
 	struct smb_direct_transport *t;
 	struct smbdirect_socket *sc;
 
-	recvmsg = container_of(wc->wr_cqe, struct smb_direct_recvmsg, cqe);
-	t = recvmsg->transport;
-	sc = &t->socket;
+	recvmsg = container_of(wc->wr_cqe, struct smbdirect_recv_io, cqe);
+	sc = recvmsg->socket;
+	t = container_of(sc, struct smb_direct_transport, socket);
 
 	if (wc->status != IB_WC_SUCCESS || wc->opcode != IB_WC_RECV) {
 		put_recvmsg(t, recvmsg);
@@ -634,7 +625,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 }
 
 static int smb_direct_post_recv(struct smb_direct_transport *t,
-				struct smb_direct_recvmsg *recvmsg)
+				struct smbdirect_recv_io *recvmsg)
 {
 	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
@@ -673,7 +664,7 @@ static int smb_direct_post_recv(struct smb_direct_transport *t,
 static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 			   unsigned int size, int unused)
 {
-	struct smb_direct_recvmsg *recvmsg;
+	struct smbdirect_recv_io *recvmsg;
 	struct smbdirect_data_transfer *data_transfer;
 	int to_copy, to_read, data_read, offset;
 	u32 data_length, remaining_data_length, data_offset;
@@ -710,7 +701,7 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 		offset = st->first_entry_offset;
 		while (data_read < size) {
 			recvmsg = get_first_reassembly(st);
-			data_transfer = smb_direct_recvmsg_payload(recvmsg);
+			data_transfer = smbdirect_recv_io_payload(recvmsg);
 			data_length = le32_to_cpu(data_transfer->data_length);
 			remaining_data_length =
 				le32_to_cpu(data_transfer->remaining_data_length);
@@ -803,7 +794,7 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
 {
 	struct smb_direct_transport *t = container_of(work,
 		struct smb_direct_transport, post_recv_credits_work.work);
-	struct smb_direct_recvmsg *recvmsg;
+	struct smbdirect_recv_io *recvmsg;
 	int receive_credits, credits = 0;
 	int ret;
 
@@ -1684,7 +1675,7 @@ static int smb_direct_prepare_negotiation(struct smb_direct_transport *t)
 {
 	struct smbdirect_socket *sc = &t->socket;
 	int ret;
-	struct smb_direct_recvmsg *recvmsg;
+	struct smbdirect_recv_io *recvmsg;
 
 	sc->recv_io.expected = SMBDIRECT_EXPECT_NEGOTIATE_REQ;
 
@@ -1813,7 +1804,7 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 
 static void smb_direct_destroy_pools(struct smb_direct_transport *t)
 {
-	struct smb_direct_recvmsg *recvmsg;
+	struct smbdirect_recv_io *recvmsg;
 
 	while ((recvmsg = get_free_recvmsg(t)))
 		mempool_free(recvmsg, t->recvmsg_mempool);
@@ -1837,7 +1828,7 @@ static int smb_direct_create_pools(struct smb_direct_transport *t)
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	char name[80];
 	int i;
-	struct smb_direct_recvmsg *recvmsg;
+	struct smbdirect_recv_io *recvmsg;
 
 	snprintf(name, sizeof(name), "smb_direct_rqst_pool_%p", t);
 	t->sendmsg_cache = kmem_cache_create(name,
@@ -1853,9 +1844,9 @@ static int smb_direct_create_pools(struct smb_direct_transport *t)
 	if (!t->sendmsg_mempool)
 		goto err;
 
-	snprintf(name, sizeof(name), "smb_direct_resp_%p", t);
+	snprintf(name, sizeof(name), "smbdirect_recv_io_pool_%p", t);
 	t->recvmsg_cache = kmem_cache_create(name,
-					     sizeof(struct smb_direct_recvmsg) +
+					     sizeof(struct smbdirect_recv_io) +
 					     sp->max_recv_size,
 					     0, SLAB_HWCACHE_ALIGN, NULL);
 	if (!t->recvmsg_cache)
@@ -1873,7 +1864,7 @@ static int smb_direct_create_pools(struct smb_direct_transport *t)
 		recvmsg = mempool_alloc(t->recvmsg_mempool, KSMBD_DEFAULT_GFP);
 		if (!recvmsg)
 			goto err;
-		recvmsg->transport = t;
+		recvmsg->socket = sc;
 		recvmsg->sge.length = 0;
 		list_add(&recvmsg->list, &t->recvmsg_queue);
 	}
@@ -1978,7 +1969,7 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 	struct smb_direct_transport *st = smb_trans_direct_transfort(t);
 	struct smbdirect_socket *sc = &st->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
-	struct smb_direct_recvmsg *recvmsg;
+	struct smbdirect_recv_io *recvmsg;
 	struct smbdirect_negotiate_req *req;
 	int ret;
 
-- 
2.43.0

[PATCH v4 082/142] smb: server: make use of smbdirect_socket.recv_io.free.{list,lock}

[Stefan Metzmacher]

This is already used by the client and will allow us to
add common helper functions soon.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Acked-by: Namjae Jeon <linkinjeon@kernel.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/server/transport_rdma.c | 27 ++++++++++++---------------
 1 file changed, 12 insertions(+), 15 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index edc7968d46fc..38af9a8b014c 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -110,9 +110,6 @@ struct smb_direct_transport {
 	int			count_avail_recvmsg;
 	int			recv_credit_target;
 
-	spinlock_t		recvmsg_queue_lock;
-	struct list_head	recvmsg_queue;
-
 	atomic_t		send_credits;
 	spinlock_t		lock_new_recv_credits;
 	int			new_recv_credits;
@@ -222,16 +219,17 @@ static inline bool is_receive_credit_post_required(int receive_credits,
 static struct
 smbdirect_recv_io *get_free_recvmsg(struct smb_direct_transport *t)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_recv_io *recvmsg = NULL;
 
-	spin_lock(&t->recvmsg_queue_lock);
-	if (!list_empty(&t->recvmsg_queue)) {
-		recvmsg = list_first_entry(&t->recvmsg_queue,
+	spin_lock(&sc->recv_io.free.lock);
+	if (!list_empty(&sc->recv_io.free.list)) {
+		recvmsg = list_first_entry(&sc->recv_io.free.list,
 					   struct smbdirect_recv_io,
 					   list);
 		list_del(&recvmsg->list);
 	}
-	spin_unlock(&t->recvmsg_queue_lock);
+	spin_unlock(&sc->recv_io.free.lock);
 	return recvmsg;
 }
 
@@ -248,9 +246,9 @@ static void put_recvmsg(struct smb_direct_transport *t,
 		recvmsg->sge.length = 0;
 	}
 
-	spin_lock(&t->recvmsg_queue_lock);
-	list_add(&recvmsg->list, &t->recvmsg_queue);
-	spin_unlock(&t->recvmsg_queue_lock);
+	spin_lock(&sc->recv_io.free.lock);
+	list_add(&recvmsg->list, &sc->recv_io.free.list);
+	spin_unlock(&sc->recv_io.free.lock);
 }
 
 static void enqueue_reassembly(struct smb_direct_transport *t,
@@ -333,6 +331,9 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 
 	sc->ib.dev = sc->rdma.cm_id->device;
 
+	INIT_LIST_HEAD(&sc->recv_io.free.list);
+	spin_lock_init(&sc->recv_io.free.lock);
+
 	sc->status = SMBDIRECT_SOCKET_CREATED;
 	init_waitqueue_head(&t->wait_status);
 
@@ -345,8 +346,6 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 	init_waitqueue_head(&t->wait_rw_credits);
 
 	spin_lock_init(&t->receive_credit_lock);
-	spin_lock_init(&t->recvmsg_queue_lock);
-	INIT_LIST_HEAD(&t->recvmsg_queue);
 
 	init_waitqueue_head(&t->wait_send_pending);
 	atomic_set(&t->send_pending, 0);
@@ -1858,15 +1857,13 @@ static int smb_direct_create_pools(struct smb_direct_transport *t)
 	if (!t->recvmsg_mempool)
 		goto err;
 
-	INIT_LIST_HEAD(&t->recvmsg_queue);
-
 	for (i = 0; i < sp->recv_credit_max; i++) {
 		recvmsg = mempool_alloc(t->recvmsg_mempool, KSMBD_DEFAULT_GFP);
 		if (!recvmsg)
 			goto err;
 		recvmsg->socket = sc;
 		recvmsg->sge.length = 0;
-		list_add(&recvmsg->list, &t->recvmsg_queue);
+		list_add(&recvmsg->list, &sc->recv_io.free.list);
 	}
 	t->count_avail_recvmsg = sp->recv_credit_max;
 
-- 
2.43.0

[PATCH v4 083/142] smb: server: make use of smbdirect_socket.recv_io.reassembly.*

[Stefan Metzmacher]

This is also used by the client and will allow us to introduce
common helper functions soon.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Acked-by: Namjae Jeon <linkinjeon@kernel.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/server/transport_rdma.c | 90 ++++++++++++++++------------------
 1 file changed, 43 insertions(+), 47 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 38af9a8b014c..d8274bd9a020 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -95,16 +95,8 @@ struct smb_direct_transport {
 
 	struct smbdirect_socket socket;
 
-	bool			full_packet_received;
 	wait_queue_head_t	wait_status;
 
-	spinlock_t		reassembly_queue_lock;
-	struct list_head	reassembly_queue;
-	int			reassembly_data_length;
-	int			reassembly_queue_length;
-	int			first_entry_offset;
-	wait_queue_head_t	wait_reassembly_queue;
-
 	spinlock_t		receive_credit_lock;
 	int			recv_credits;
 	int			count_avail_recvmsg;
@@ -255,9 +247,11 @@ static void enqueue_reassembly(struct smb_direct_transport *t,
 			       struct smbdirect_recv_io *recvmsg,
 			       int data_length)
 {
-	spin_lock(&t->reassembly_queue_lock);
-	list_add_tail(&recvmsg->list, &t->reassembly_queue);
-	t->reassembly_queue_length++;
+	struct smbdirect_socket *sc = &t->socket;
+
+	spin_lock(&sc->recv_io.reassembly.lock);
+	list_add_tail(&recvmsg->list, &sc->recv_io.reassembly.list);
+	sc->recv_io.reassembly.queue_length++;
 	/*
 	 * Make sure reassembly_data_length is updated after list and
 	 * reassembly_queue_length are updated. On the dequeue side
@@ -265,14 +259,16 @@ static void enqueue_reassembly(struct smb_direct_transport *t,
 	 * if reassembly_queue_length and list is up to date
 	 */
 	virt_wmb();
-	t->reassembly_data_length += data_length;
-	spin_unlock(&t->reassembly_queue_lock);
+	sc->recv_io.reassembly.data_length += data_length;
+	spin_unlock(&sc->recv_io.reassembly.lock);
 }
 
 static struct smbdirect_recv_io *get_first_reassembly(struct smb_direct_transport *t)
 {
-	if (!list_empty(&t->reassembly_queue))
-		return list_first_entry(&t->reassembly_queue,
+	struct smbdirect_socket *sc = &t->socket;
+
+	if (!list_empty(&sc->recv_io.reassembly.list))
+		return list_first_entry(&sc->recv_io.reassembly.list,
 				struct smbdirect_recv_io, list);
 	else
 		return NULL;
@@ -337,11 +333,11 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 	sc->status = SMBDIRECT_SOCKET_CREATED;
 	init_waitqueue_head(&t->wait_status);
 
-	spin_lock_init(&t->reassembly_queue_lock);
-	INIT_LIST_HEAD(&t->reassembly_queue);
-	t->reassembly_data_length = 0;
-	t->reassembly_queue_length = 0;
-	init_waitqueue_head(&t->wait_reassembly_queue);
+	spin_lock_init(&sc->recv_io.reassembly.lock);
+	INIT_LIST_HEAD(&sc->recv_io.reassembly.list);
+	sc->recv_io.reassembly.data_length = 0;
+	sc->recv_io.reassembly.queue_length = 0;
+	init_waitqueue_head(&sc->recv_io.reassembly.wait_queue);
 	init_waitqueue_head(&t->wait_send_credits);
 	init_waitqueue_head(&t->wait_rw_credits);
 
@@ -398,17 +394,17 @@ static void free_transport(struct smb_direct_transport *t)
 
 	ksmbd_debug(RDMA, "drain the reassembly queue\n");
 	do {
-		spin_lock(&t->reassembly_queue_lock);
+		spin_lock(&sc->recv_io.reassembly.lock);
 		recvmsg = get_first_reassembly(t);
 		if (recvmsg) {
 			list_del(&recvmsg->list);
-			spin_unlock(&t->reassembly_queue_lock);
+			spin_unlock(&sc->recv_io.reassembly.lock);
 			put_recvmsg(t, recvmsg);
 		} else {
-			spin_unlock(&t->reassembly_queue_lock);
+			spin_unlock(&sc->recv_io.reassembly.lock);
 		}
 	} while (recvmsg);
-	t->reassembly_data_length = 0;
+	sc->recv_io.reassembly.data_length = 0;
 
 	if (sc->ib.send_cq)
 		ib_free_cq(sc->ib.send_cq);
@@ -540,7 +536,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			return;
 		}
 		t->negotiation_requested = true;
-		t->full_packet_received = true;
+		sc->recv_io.reassembly.full_packet_received = true;
 		sc->status = SMBDIRECT_SOCKET_CONNECTED;
 		enqueue_reassembly(t, recvmsg, 0);
 		wake_up_interruptible(&t->wait_status);
@@ -567,13 +563,13 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 				return;
 			}
 
-			if (t->full_packet_received)
+			if (sc->recv_io.reassembly.full_packet_received)
 				recvmsg->first_segment = true;
 
 			if (le32_to_cpu(data_transfer->remaining_data_length))
-				t->full_packet_received = false;
+				sc->recv_io.reassembly.full_packet_received = false;
 			else
-				t->full_packet_received = true;
+				sc->recv_io.reassembly.full_packet_received = true;
 
 			spin_lock(&t->receive_credit_lock);
 			receive_credits = --(t->recv_credits);
@@ -604,7 +600,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 
 		if (data_length) {
 			enqueue_reassembly(t, recvmsg, (int)data_length);
-			wake_up_interruptible(&t->wait_reassembly_queue);
+			wake_up_interruptible(&sc->recv_io.reassembly.wait_queue);
 		} else
 			put_recvmsg(t, recvmsg);
 
@@ -682,7 +678,7 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 	 * the only one reading from the front of the queue. The transport
 	 * may add more entries to the back of the queue at the same time
 	 */
-	if (st->reassembly_data_length >= size) {
+	if (sc->recv_io.reassembly.data_length >= size) {
 		int queue_length;
 		int queue_removed = 0;
 
@@ -694,10 +690,10 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 		 * updated in SOFTIRQ as more data is received
 		 */
 		virt_rmb();
-		queue_length = st->reassembly_queue_length;
+		queue_length = sc->recv_io.reassembly.queue_length;
 		data_read = 0;
 		to_read = size;
-		offset = st->first_entry_offset;
+		offset = sc->recv_io.reassembly.first_entry_offset;
 		while (data_read < size) {
 			recvmsg = get_first_reassembly(st);
 			data_transfer = smbdirect_recv_io_payload(recvmsg);
@@ -740,9 +736,9 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 				if (queue_length) {
 					list_del(&recvmsg->list);
 				} else {
-					spin_lock_irq(&st->reassembly_queue_lock);
+					spin_lock_irq(&sc->recv_io.reassembly.lock);
 					list_del(&recvmsg->list);
-					spin_unlock_irq(&st->reassembly_queue_lock);
+					spin_unlock_irq(&sc->recv_io.reassembly.lock);
 				}
 				queue_removed++;
 				put_recvmsg(st, recvmsg);
@@ -755,10 +751,10 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 			data_read += to_copy;
 		}
 
-		spin_lock_irq(&st->reassembly_queue_lock);
-		st->reassembly_data_length -= data_read;
-		st->reassembly_queue_length -= queue_removed;
-		spin_unlock_irq(&st->reassembly_queue_lock);
+		spin_lock_irq(&sc->recv_io.reassembly.lock);
+		sc->recv_io.reassembly.data_length -= data_read;
+		sc->recv_io.reassembly.queue_length -= queue_removed;
+		spin_unlock_irq(&sc->recv_io.reassembly.lock);
 
 		spin_lock(&st->receive_credit_lock);
 		st->count_avail_recvmsg += queue_removed;
@@ -770,18 +766,18 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 			spin_unlock(&st->receive_credit_lock);
 		}
 
-		st->first_entry_offset = offset;
+		sc->recv_io.reassembly.first_entry_offset = offset;
 		ksmbd_debug(RDMA,
 			    "returning to thread data_read=%d reassembly_data_length=%d first_entry_offset=%d\n",
-			    data_read, st->reassembly_data_length,
-			    st->first_entry_offset);
+			    data_read, sc->recv_io.reassembly.data_length,
+			    sc->recv_io.reassembly.first_entry_offset);
 read_rfc1002_done:
 		return data_read;
 	}
 
 	ksmbd_debug(RDMA, "wait_event on more data\n");
-	rc = wait_event_interruptible(st->wait_reassembly_queue,
-				      st->reassembly_data_length >= size ||
+	rc = wait_event_interruptible(sc->recv_io.reassembly.wait_queue,
+				      sc->recv_io.reassembly.data_length >= size ||
 				       sc->status != SMBDIRECT_SOCKET_CONNECTED);
 	if (rc)
 		return -EINTR;
@@ -1536,7 +1532,7 @@ static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
 
 		sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
 		wake_up_interruptible(&t->wait_status);
-		wake_up_interruptible(&t->wait_reassembly_queue);
+		wake_up_interruptible(&sc->recv_io.reassembly.wait_queue);
 		wake_up(&t->wait_send_credits);
 		break;
 	}
@@ -1998,10 +1994,10 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 
 	ret = smb_direct_send_negotiate_response(st, ret);
 out:
-	spin_lock_irq(&st->reassembly_queue_lock);
-	st->reassembly_queue_length--;
+	spin_lock_irq(&sc->recv_io.reassembly.lock);
+	sc->recv_io.reassembly.queue_length--;
 	list_del(&recvmsg->list);
-	spin_unlock_irq(&st->reassembly_queue_lock);
+	spin_unlock_irq(&sc->recv_io.reassembly.lock);
 	put_recvmsg(st, recvmsg);
 
 	return ret;
-- 
2.43.0

[PATCH v4 084/142] smb: server: make use of SMBDIRECT_RECV_IO_MAX_SGE

[Stefan Metzmacher]

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Acked-by: Namjae Jeon <linkinjeon@kernel.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/server/transport_rdma.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index d8274bd9a020..c56cbd6ab0af 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -37,7 +37,6 @@
 #define SMB_DIRECT_NEGOTIATE_TIMEOUT		120
 
 #define SMB_DIRECT_MAX_SEND_SGES		6
-#define SMB_DIRECT_MAX_RECV_SGES		1
 
 /*
  * Default maximum number of RDMA read/write outstanding on this connection
@@ -1767,7 +1766,7 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 		return -EINVAL;
 	}
 
-	if (device->attrs.max_recv_sge < SMB_DIRECT_MAX_RECV_SGES) {
+	if (device->attrs.max_recv_sge < SMBDIRECT_RECV_IO_MAX_SGE) {
 		pr_err("warning: device max_recv_sge = %d too small\n",
 		       device->attrs.max_recv_sge);
 		return -EINVAL;
@@ -1791,7 +1790,7 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	cap->max_send_wr = max_send_wrs;
 	cap->max_recv_wr = sp->recv_credit_max;
 	cap->max_send_sge = max_sge_per_wr;
-	cap->max_recv_sge = SMB_DIRECT_MAX_RECV_SGES;
+	cap->max_recv_sge = SMBDIRECT_RECV_IO_MAX_SGE;
 	cap->max_inline_data = 0;
 	cap->max_rdma_ctxs = t->max_rw_credits;
 	return 0;
-- 
2.43.0

[PATCH v4 085/142] smb: server: make use of struct smbdirect_send_io

[Stefan Metzmacher]

This is already used by the client and will allow us
to use common helper functions soon.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Acked-by: Namjae Jeon <linkinjeon@kernel.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/server/transport_rdma.c | 81 +++++++++++++++-------------------
 1 file changed, 36 insertions(+), 45 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index c56cbd6ab0af..57e1140d488e 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -36,8 +36,6 @@
 /* SMB_DIRECT negotiation timeout in seconds */
 #define SMB_DIRECT_NEGOTIATE_TIMEOUT		120
 
-#define SMB_DIRECT_MAX_SEND_SGES		6
-
 /*
  * Default maximum number of RDMA read/write outstanding on this connection
  * This value is possibly decreased during QP creation on hardware limit
@@ -143,16 +141,6 @@ struct smb_direct_send_ctx {
 	unsigned int		remote_key;
 };
 
-struct smb_direct_sendmsg {
-	struct smb_direct_transport	*transport;
-	struct ib_send_wr	wr;
-	struct list_head	list;
-	int			num_sge;
-	struct ib_sge		sge[SMB_DIRECT_MAX_SEND_SGES];
-	struct ib_cqe		cqe;
-	u8			packet[];
-};
-
 struct smb_direct_rdma_rw_msg {
 	struct smb_direct_transport	*t;
 	struct ib_cqe		cqe;
@@ -418,22 +406,23 @@ static void free_transport(struct smb_direct_transport *t)
 	ksmbd_conn_free(KSMBD_TRANS(t)->conn);
 }
 
-static struct smb_direct_sendmsg
+static struct smbdirect_send_io
 *smb_direct_alloc_sendmsg(struct smb_direct_transport *t)
 {
-	struct smb_direct_sendmsg *msg;
+	struct smbdirect_socket *sc = &t->socket;
+	struct smbdirect_send_io *msg;
 
 	msg = mempool_alloc(t->sendmsg_mempool, KSMBD_DEFAULT_GFP);
 	if (!msg)
 		return ERR_PTR(-ENOMEM);
-	msg->transport = t;
-	INIT_LIST_HEAD(&msg->list);
+	msg->socket = sc;
+	INIT_LIST_HEAD(&msg->sibling_list);
 	msg->num_sge = 0;
 	return msg;
 }
 
 static void smb_direct_free_sendmsg(struct smb_direct_transport *t,
-				    struct smb_direct_sendmsg *msg)
+				    struct smbdirect_send_io *msg)
 {
 	struct smbdirect_socket *sc = &t->socket;
 	int i;
@@ -829,12 +818,14 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
 
 static void send_done(struct ib_cq *cq, struct ib_wc *wc)
 {
-	struct smb_direct_sendmsg *sendmsg, *sibling;
+	struct smbdirect_send_io *sendmsg, *sibling;
 	struct smb_direct_transport *t;
+	struct smbdirect_socket *sc;
 	struct list_head *pos, *prev, *end;
 
-	sendmsg = container_of(wc->wr_cqe, struct smb_direct_sendmsg, cqe);
-	t = sendmsg->transport;
+	sendmsg = container_of(wc->wr_cqe, struct smbdirect_send_io, cqe);
+	sc = sendmsg->socket;
+	t = container_of(sc, struct smb_direct_transport, socket);
 
 	ksmbd_debug(RDMA, "Send completed. status='%s (%d)', opcode=%d\n",
 		    ib_wc_status_msg(wc->status), wc->status,
@@ -853,13 +844,13 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
 	/* iterate and free the list of messages in reverse. the list's head
 	 * is invalid.
 	 */
-	for (pos = &sendmsg->list, prev = pos->prev, end = sendmsg->list.next;
+	for (pos = &sendmsg->sibling_list, prev = pos->prev, end = sendmsg->sibling_list.next;
 	     prev != end; pos = prev, prev = prev->prev) {
-		sibling = container_of(pos, struct smb_direct_sendmsg, list);
+		sibling = container_of(pos, struct smbdirect_send_io, sibling_list);
 		smb_direct_free_sendmsg(t, sibling);
 	}
 
-	sibling = container_of(pos, struct smb_direct_sendmsg, list);
+	sibling = container_of(pos, struct smbdirect_send_io, sibling_list);
 	smb_direct_free_sendmsg(t, sibling);
 }
 
@@ -907,18 +898,18 @@ static int smb_direct_flush_send_list(struct smb_direct_transport *t,
 				      struct smb_direct_send_ctx *send_ctx,
 				      bool is_last)
 {
-	struct smb_direct_sendmsg *first, *last;
+	struct smbdirect_send_io *first, *last;
 	int ret;
 
 	if (list_empty(&send_ctx->msg_list))
 		return 0;
 
 	first = list_first_entry(&send_ctx->msg_list,
-				 struct smb_direct_sendmsg,
-				 list);
+				 struct smbdirect_send_io,
+				 sibling_list);
 	last = list_last_entry(&send_ctx->msg_list,
-			       struct smb_direct_sendmsg,
-			       list);
+			       struct smbdirect_send_io,
+			       sibling_list);
 
 	last->wr.send_flags = IB_SEND_SIGNALED;
 	last->wr.wr_cqe = &last->cqe;
@@ -936,7 +927,7 @@ static int smb_direct_flush_send_list(struct smb_direct_transport *t,
 		atomic_add(send_ctx->wr_cnt, &t->send_credits);
 		wake_up(&t->wait_send_credits);
 		list_for_each_entry_safe(first, last, &send_ctx->msg_list,
-					 list) {
+					 sibling_list) {
 			smb_direct_free_sendmsg(t, first);
 		}
 	}
@@ -995,11 +986,11 @@ static int calc_rw_credits(struct smb_direct_transport *t,
 
 static int smb_direct_create_header(struct smb_direct_transport *t,
 				    int size, int remaining_data_length,
-				    struct smb_direct_sendmsg **sendmsg_out)
+				    struct smbdirect_send_io **sendmsg_out)
 {
 	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
-	struct smb_direct_sendmsg *sendmsg;
+	struct smbdirect_send_io *sendmsg;
 	struct smbdirect_data_transfer *packet;
 	int header_length;
 	int ret;
@@ -1102,7 +1093,7 @@ static int get_mapped_sg_list(struct ib_device *device, void *buf, int size,
 
 static int post_sendmsg(struct smb_direct_transport *t,
 			struct smb_direct_send_ctx *send_ctx,
-			struct smb_direct_sendmsg *msg)
+			struct smbdirect_send_io *msg)
 {
 	struct smbdirect_socket *sc = &t->socket;
 	int i;
@@ -1122,14 +1113,14 @@ static int post_sendmsg(struct smb_direct_transport *t,
 		msg->wr.wr_cqe = NULL;
 		msg->wr.send_flags = 0;
 		if (!list_empty(&send_ctx->msg_list)) {
-			struct smb_direct_sendmsg *last;
+			struct smbdirect_send_io *last;
 
 			last = list_last_entry(&send_ctx->msg_list,
-					       struct smb_direct_sendmsg,
-					       list);
+					       struct smbdirect_send_io,
+					       sibling_list);
 			last->wr.next = &msg->wr;
 		}
-		list_add_tail(&msg->list, &send_ctx->msg_list);
+		list_add_tail(&msg->sibling_list, &send_ctx->msg_list);
 		send_ctx->wr_cnt++;
 		return 0;
 	}
@@ -1146,9 +1137,9 @@ static int smb_direct_post_send_data(struct smb_direct_transport *t,
 {
 	struct smbdirect_socket *sc = &t->socket;
 	int i, j, ret;
-	struct smb_direct_sendmsg *msg;
+	struct smbdirect_send_io *msg;
 	int data_length;
-	struct scatterlist sg[SMB_DIRECT_MAX_SEND_SGES - 1];
+	struct scatterlist sg[SMBDIRECT_SEND_IO_MAX_SGE - 1];
 
 	ret = wait_for_send_credits(t, send_ctx);
 	if (ret)
@@ -1169,16 +1160,16 @@ static int smb_direct_post_send_data(struct smb_direct_transport *t,
 		struct ib_sge *sge;
 		int sg_cnt;
 
-		sg_init_table(sg, SMB_DIRECT_MAX_SEND_SGES - 1);
+		sg_init_table(sg, SMBDIRECT_SEND_IO_MAX_SGE - 1);
 		sg_cnt = get_mapped_sg_list(sc->ib.dev,
 					    iov[i].iov_base, iov[i].iov_len,
-					    sg, SMB_DIRECT_MAX_SEND_SGES - 1,
+					    sg, SMBDIRECT_SEND_IO_MAX_SGE - 1,
 					    DMA_TO_DEVICE);
 		if (sg_cnt <= 0) {
 			pr_err("failed to map buffer\n");
 			ret = -ENOMEM;
 			goto err;
-		} else if (sg_cnt + msg->num_sge > SMB_DIRECT_MAX_SEND_SGES) {
+		} else if (sg_cnt + msg->num_sge > SMBDIRECT_SEND_IO_MAX_SGE) {
 			pr_err("buffer not fitted into sges\n");
 			ret = -E2BIG;
 			ib_dma_unmap_sg(sc->ib.dev, sg, sg_cnt,
@@ -1572,7 +1563,7 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 {
 	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
-	struct smb_direct_sendmsg *sendmsg;
+	struct smbdirect_send_io *sendmsg;
 	struct smbdirect_negotiate_resp *resp;
 	int ret;
 
@@ -1720,7 +1711,7 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	 */
 	sp->max_send_size = smb_direct_max_send_size;
 	max_send_sges = DIV_ROUND_UP(sp->max_send_size, PAGE_SIZE) + 3;
-	if (max_send_sges > SMB_DIRECT_MAX_SEND_SGES) {
+	if (max_send_sges > SMBDIRECT_SEND_IO_MAX_SGE) {
 		pr_err("max_send_size %d is too large\n", sp->max_send_size);
 		return -EINVAL;
 	}
@@ -1824,9 +1815,9 @@ static int smb_direct_create_pools(struct smb_direct_transport *t)
 	int i;
 	struct smbdirect_recv_io *recvmsg;
 
-	snprintf(name, sizeof(name), "smb_direct_rqst_pool_%p", t);
+	snprintf(name, sizeof(name), "smbdirect_send_io_pool_%p", t);
 	t->sendmsg_cache = kmem_cache_create(name,
-					     sizeof(struct smb_direct_sendmsg) +
+					     sizeof(struct smbdirect_send_io) +
 					      sizeof(struct smbdirect_negotiate_resp),
 					     0, SLAB_HWCACHE_ALIGN, NULL);
 	if (!t->sendmsg_cache)
-- 
2.43.0

[PATCH v4 086/142] smb: server: make use of smbdirect_socket.{send,recv}_io.mem.{cache,pool}

[Stefan Metzmacher]

This will allow common helper functions to be created later.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
Acked-by: Namjae Jeon <linkinjeon@kernel.org>
Signed-off-by: Steve French <stfrench@microsoft.com>
---
 fs/smb/server/transport_rdma.c | 50 ++++++++++++++++------------------
 1 file changed, 23 insertions(+), 27 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 57e1140d488e..c20052093b36 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -109,11 +109,6 @@ struct smb_direct_transport {
 	wait_queue_head_t	wait_send_credits;
 	wait_queue_head_t	wait_rw_credits;
 
-	mempool_t		*sendmsg_mempool;
-	struct kmem_cache	*sendmsg_cache;
-	mempool_t		*recvmsg_mempool;
-	struct kmem_cache	*recvmsg_cache;
-
 	wait_queue_head_t	wait_send_pending;
 	atomic_t		send_pending;
 
@@ -412,7 +407,7 @@ static struct smbdirect_send_io
 	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_send_io *msg;
 
-	msg = mempool_alloc(t->sendmsg_mempool, KSMBD_DEFAULT_GFP);
+	msg = mempool_alloc(sc->send_io.mem.pool, KSMBD_DEFAULT_GFP);
 	if (!msg)
 		return ERR_PTR(-ENOMEM);
 	msg->socket = sc;
@@ -436,7 +431,7 @@ static void smb_direct_free_sendmsg(struct smb_direct_transport *t,
 					  msg->sge[i].addr, msg->sge[i].length,
 					  DMA_TO_DEVICE);
 	}
-	mempool_free(msg, t->sendmsg_mempool);
+	mempool_free(msg, sc->send_io.mem.pool);
 }
 
 static int smb_direct_check_recvmsg(struct smbdirect_recv_io *recvmsg)
@@ -1789,22 +1784,23 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 
 static void smb_direct_destroy_pools(struct smb_direct_transport *t)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_recv_io *recvmsg;
 
 	while ((recvmsg = get_free_recvmsg(t)))
-		mempool_free(recvmsg, t->recvmsg_mempool);
+		mempool_free(recvmsg, sc->recv_io.mem.pool);
 
-	mempool_destroy(t->recvmsg_mempool);
-	t->recvmsg_mempool = NULL;
+	mempool_destroy(sc->recv_io.mem.pool);
+	sc->recv_io.mem.pool = NULL;
 
-	kmem_cache_destroy(t->recvmsg_cache);
-	t->recvmsg_cache = NULL;
+	kmem_cache_destroy(sc->recv_io.mem.cache);
+	sc->recv_io.mem.cache = NULL;
 
-	mempool_destroy(t->sendmsg_mempool);
-	t->sendmsg_mempool = NULL;
+	mempool_destroy(sc->send_io.mem.pool);
+	sc->send_io.mem.pool = NULL;
 
-	kmem_cache_destroy(t->sendmsg_cache);
-	t->sendmsg_cache = NULL;
+	kmem_cache_destroy(sc->send_io.mem.cache);
+	sc->send_io.mem.cache = NULL;
 }
 
 static int smb_direct_create_pools(struct smb_direct_transport *t)
@@ -1816,35 +1812,35 @@ static int smb_direct_create_pools(struct smb_direct_transport *t)
 	struct smbdirect_recv_io *recvmsg;
 
 	snprintf(name, sizeof(name), "smbdirect_send_io_pool_%p", t);
-	t->sendmsg_cache = kmem_cache_create(name,
+	sc->send_io.mem.cache = kmem_cache_create(name,
 					     sizeof(struct smbdirect_send_io) +
 					      sizeof(struct smbdirect_negotiate_resp),
 					     0, SLAB_HWCACHE_ALIGN, NULL);
-	if (!t->sendmsg_cache)
+	if (!sc->send_io.mem.cache)
 		return -ENOMEM;
 
-	t->sendmsg_mempool = mempool_create(sp->send_credit_target,
+	sc->send_io.mem.pool = mempool_create(sp->send_credit_target,
 					    mempool_alloc_slab, mempool_free_slab,
-					    t->sendmsg_cache);
-	if (!t->sendmsg_mempool)
+					    sc->send_io.mem.cache);
+	if (!sc->send_io.mem.pool)
 		goto err;
 
 	snprintf(name, sizeof(name), "smbdirect_recv_io_pool_%p", t);
-	t->recvmsg_cache = kmem_cache_create(name,
+	sc->recv_io.mem.cache = kmem_cache_create(name,
 					     sizeof(struct smbdirect_recv_io) +
 					     sp->max_recv_size,
 					     0, SLAB_HWCACHE_ALIGN, NULL);
-	if (!t->recvmsg_cache)
+	if (!sc->recv_io.mem.cache)
 		goto err;
 
-	t->recvmsg_mempool =
+	sc->recv_io.mem.pool =
 		mempool_create(sp->recv_credit_max, mempool_alloc_slab,
-			       mempool_free_slab, t->recvmsg_cache);
-	if (!t->recvmsg_mempool)
+			       mempool_free_slab, sc->recv_io.mem.cache);
+	if (!sc->recv_io.mem.pool)
 		goto err;
 
 	for (i = 0; i < sp->recv_credit_max; i++) {
-		recvmsg = mempool_alloc(t->recvmsg_mempool, KSMBD_DEFAULT_GFP);
+		recvmsg = mempool_alloc(sc->recv_io.mem.pool, KSMBD_DEFAULT_GFP);
 		if (!recvmsg)
 			goto err;
 		recvmsg->socket = sc;
-- 
2.43.0

[PATCH v4 087/142] smb: server: make only use of wake_up[_all]() in transport_rdma.c

[Stefan Metzmacher]

wake_up_interruptible(() doesn't wake up tasks waiting with wait_event().

So we better wake_up[_all]() in order to wake up all tasks in order
to simplify the logic.

As we currently don't use any wait_event_*_exclusive() it
doesn't really matter if we use wake_up() or wake_up_all().
But in this patch I try to use wake_up() for expected situations
and wake_up_all() for situations of a broken connection.
So don't need to adjust things in future when we
may use wait_event_*_exclusive() in order to wake up
only one process that should make progress.

Changing the wait_event_*() code in order to keep
wait_event(), wait_event_interruptible() and
wait_event_interruptible_timeout() or
changing them to wait_event_killable(),
wait_event_killable_timeout(),
wait_event_killable_exclusive()
is something to think about in a future patch.

The goal here is to avoid that some tasks are not
woken and freeze forever.

Also note that this patch only changes the existing
wake_up*() calls. Adding more wake_up*() calls for
other wait queues is also deferred to a future patch.

Link: https://lore.kernel.org/linux-cifs/13851363-0dc9-465c-9ced-3ede4904eef0@samba.org/T/#t
Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index c20052093b36..5e773da90316 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -357,7 +357,7 @@ static void free_transport(struct smb_direct_transport *t)
 	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_recv_io *recvmsg;
 
-	wake_up_interruptible(&t->wait_send_credits);
+	wake_up_all(&t->wait_send_credits);
 
 	ksmbd_debug(RDMA, "wait for all send posted to IB to finish\n");
 	wait_event(t->wait_send_pending,
@@ -522,7 +522,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		sc->recv_io.reassembly.full_packet_received = true;
 		sc->status = SMBDIRECT_SOCKET_CONNECTED;
 		enqueue_reassembly(t, recvmsg, 0);
-		wake_up_interruptible(&t->wait_status);
+		wake_up(&t->wait_status);
 		return;
 	case SMBDIRECT_EXPECT_DATA_TRANSFER: {
 		struct smbdirect_data_transfer *data_transfer =
@@ -575,7 +575,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			queue_work(smb_direct_wq, &t->send_immediate_work);
 
 		if (atomic_read(&t->send_credits) > 0)
-			wake_up_interruptible(&t->wait_send_credits);
+			wake_up(&t->wait_send_credits);
 
 		if (is_receive_credit_post_required(receive_credits, avail_recvmsg_count))
 			mod_delayed_work(smb_direct_wq,
@@ -583,7 +583,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 
 		if (data_length) {
 			enqueue_reassembly(t, recvmsg, (int)data_length);
-			wake_up_interruptible(&sc->recv_io.reassembly.wait_queue);
+			wake_up(&sc->recv_io.reassembly.wait_queue);
 		} else
 			put_recvmsg(t, recvmsg);
 
@@ -1508,7 +1508,7 @@ static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
 	switch (event->event) {
 	case RDMA_CM_EVENT_ESTABLISHED: {
 		sc->status = SMBDIRECT_SOCKET_CONNECTED;
-		wake_up_interruptible(&t->wait_status);
+		wake_up(&t->wait_status);
 		break;
 	}
 	case RDMA_CM_EVENT_DEVICE_REMOVAL:
@@ -1516,14 +1516,14 @@ static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
 		ib_drain_qp(sc->ib.qp);
 
 		sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
-		wake_up_interruptible(&t->wait_status);
-		wake_up_interruptible(&sc->recv_io.reassembly.wait_queue);
-		wake_up(&t->wait_send_credits);
+		wake_up_all(&t->wait_status);
+		wake_up_all(&sc->recv_io.reassembly.wait_queue);
+		wake_up_all(&t->wait_send_credits);
 		break;
 	}
 	case RDMA_CM_EVENT_CONNECT_ERROR: {
 		sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
-		wake_up_interruptible(&t->wait_status);
+		wake_up_all(&t->wait_status);
 		break;
 	}
 	default:
-- 
2.43.0

[PATCH v4 088/142] smb: server: add a pr_info() when the server starts running

[Stefan Metzmacher]

We already have a message like:
ksmbd: kill command received
when the server stops running.

This makes it easier for debugging in order to match any possible
warnings/errors in dmesg with restarted server.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/server.c | 1 +
 1 file changed, 1 insertion(+)

diff --git a/fs/smb/server/server.c b/fs/smb/server/server.c
index 8c9c49c3a0a4..40420544cc25 100644
--- a/fs/smb/server/server.c
+++ b/fs/smb/server/server.c
@@ -365,6 +365,7 @@ static void server_ctrl_handle_init(struct server_ctrl_struct *ctrl)
 		return;
 	}
 
+	pr_info("running\n");
 	WRITE_ONCE(server_conf.state, SERVER_STATE_RUNNING);
 }
 
-- 
2.43.0

[PATCH v4 089/142] smb: server: don't use delayed_work for post_recv_credits_work

[Stefan Metzmacher]

If we are using a hardcoded delay of 0 there's no point in
using delayed_work it only adds confusion.

The client also uses a normal work_struct and now
it is easier to move it to the common smbdirect_socket.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 5e773da90316..85e0d2ea37ec 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -112,7 +112,7 @@ struct smb_direct_transport {
 	wait_queue_head_t	wait_send_pending;
 	atomic_t		send_pending;
 
-	struct delayed_work	post_recv_credits_work;
+	struct work_struct	post_recv_credits_work;
 	struct work_struct	send_immediate_work;
 	struct work_struct	disconnect_work;
 
@@ -330,8 +330,8 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 
 	spin_lock_init(&t->lock_new_recv_credits);
 
-	INIT_DELAYED_WORK(&t->post_recv_credits_work,
-			  smb_direct_post_recv_credits);
+	INIT_WORK(&t->post_recv_credits_work,
+		  smb_direct_post_recv_credits);
 	INIT_WORK(&t->send_immediate_work, smb_direct_send_immediate_work);
 	INIT_WORK(&t->disconnect_work, smb_direct_disconnect_rdma_work);
 
@@ -364,7 +364,7 @@ static void free_transport(struct smb_direct_transport *t)
 		   atomic_read(&t->send_pending) == 0);
 
 	cancel_work_sync(&t->disconnect_work);
-	cancel_delayed_work_sync(&t->post_recv_credits_work);
+	cancel_work_sync(&t->post_recv_credits_work);
 	cancel_work_sync(&t->send_immediate_work);
 
 	if (sc->ib.qp) {
@@ -578,8 +578,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			wake_up(&t->wait_send_credits);
 
 		if (is_receive_credit_post_required(receive_credits, avail_recvmsg_count))
-			mod_delayed_work(smb_direct_wq,
-					 &t->post_recv_credits_work, 0);
+			queue_work(smb_direct_wq, &t->post_recv_credits_work);
 
 		if (data_length) {
 			enqueue_reassembly(t, recvmsg, (int)data_length);
@@ -743,8 +742,7 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 		st->count_avail_recvmsg += queue_removed;
 		if (is_receive_credit_post_required(st->recv_credits, st->count_avail_recvmsg)) {
 			spin_unlock(&st->receive_credit_lock);
-			mod_delayed_work(smb_direct_wq,
-					 &st->post_recv_credits_work, 0);
+			queue_work(smb_direct_wq, &st->post_recv_credits_work);
 		} else {
 			spin_unlock(&st->receive_credit_lock);
 		}
@@ -771,7 +769,7 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 static void smb_direct_post_recv_credits(struct work_struct *work)
 {
 	struct smb_direct_transport *t = container_of(work,
-		struct smb_direct_transport, post_recv_credits_work.work);
+		struct smb_direct_transport, post_recv_credits_work);
 	struct smbdirect_recv_io *recvmsg;
 	int receive_credits, credits = 0;
 	int ret;
@@ -1676,7 +1674,7 @@ static int smb_direct_prepare_negotiation(struct smb_direct_transport *t)
 		goto out_err;
 	}
 
-	smb_direct_post_recv_credits(&t->post_recv_credits_work.work);
+	smb_direct_post_recv_credits(&t->post_recv_credits_work);
 	return 0;
 out_err:
 	put_recvmsg(t, recvmsg);
-- 
2.43.0

[PATCH v4 090/142] smb: server: queue post_recv_credits_work in put_recvmsg() and avoid count_avail_recvmsg

[Stefan Metzmacher]

This is basically what the client is doing in put_receive_buffer().

It means we don't need complicated work to maintain count_avail_recvmsg.

But we keep the logic to queue post_recv_credits_work if the
peer raises the requested credit_target and put_receive_buffer()
is not called.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 45 +++++++++-------------------------
 1 file changed, 11 insertions(+), 34 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 85e0d2ea37ec..4f0c7c8cb041 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -96,7 +96,6 @@ struct smb_direct_transport {
 
 	spinlock_t		receive_credit_lock;
 	int			recv_credits;
-	int			count_avail_recvmsg;
 	int			recv_credit_target;
 
 	atomic_t		send_credits;
@@ -183,13 +182,6 @@ static inline void
 	return (void *)recvmsg->packet;
 }
 
-static inline bool is_receive_credit_post_required(int receive_credits,
-						   int avail_recvmsg_count)
-{
-	return receive_credits <= (smb_direct_receive_credit_max >> 3) &&
-		avail_recvmsg_count >= (receive_credits >> 2);
-}
-
 static struct
 smbdirect_recv_io *get_free_recvmsg(struct smb_direct_transport *t)
 {
@@ -223,6 +215,8 @@ static void put_recvmsg(struct smb_direct_transport *t,
 	spin_lock(&sc->recv_io.free.lock);
 	list_add(&recvmsg->list, &sc->recv_io.free.list);
 	spin_unlock(&sc->recv_io.free.lock);
+
+	queue_work(smb_direct_wq, &t->post_recv_credits_work);
 }
 
 static void enqueue_reassembly(struct smb_direct_transport *t,
@@ -528,7 +522,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		struct smbdirect_data_transfer *data_transfer =
 			(struct smbdirect_data_transfer *)recvmsg->packet;
 		unsigned int data_length;
-		int avail_recvmsg_count, receive_credits;
+		int old_recv_credit_target;
 
 		if (wc->byte_len <
 		    offsetof(struct smbdirect_data_transfer, padding)) {
@@ -553,18 +547,13 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 				sc->recv_io.reassembly.full_packet_received = false;
 			else
 				sc->recv_io.reassembly.full_packet_received = true;
-
-			spin_lock(&t->receive_credit_lock);
-			receive_credits = --(t->recv_credits);
-			avail_recvmsg_count = t->count_avail_recvmsg;
-			spin_unlock(&t->receive_credit_lock);
-		} else {
-			spin_lock(&t->receive_credit_lock);
-			receive_credits = --(t->recv_credits);
-			avail_recvmsg_count = ++(t->count_avail_recvmsg);
-			spin_unlock(&t->receive_credit_lock);
 		}
 
+		spin_lock(&t->receive_credit_lock);
+		t->recv_credits -= 1;
+		spin_unlock(&t->receive_credit_lock);
+
+		old_recv_credit_target = t->recv_credit_target;
 		t->recv_credit_target =
 				le16_to_cpu(data_transfer->credits_requested);
 		atomic_add(le16_to_cpu(data_transfer->credits_granted),
@@ -577,10 +566,10 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		if (atomic_read(&t->send_credits) > 0)
 			wake_up(&t->wait_send_credits);
 
-		if (is_receive_credit_post_required(receive_credits, avail_recvmsg_count))
-			queue_work(smb_direct_wq, &t->post_recv_credits_work);
-
 		if (data_length) {
+			if (t->recv_credit_target > old_recv_credit_target)
+				queue_work(smb_direct_wq, &t->post_recv_credits_work);
+
 			enqueue_reassembly(t, recvmsg, (int)data_length);
 			wake_up(&sc->recv_io.reassembly.wait_queue);
 		} else
@@ -738,15 +727,6 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 		sc->recv_io.reassembly.queue_length -= queue_removed;
 		spin_unlock_irq(&sc->recv_io.reassembly.lock);
 
-		spin_lock(&st->receive_credit_lock);
-		st->count_avail_recvmsg += queue_removed;
-		if (is_receive_credit_post_required(st->recv_credits, st->count_avail_recvmsg)) {
-			spin_unlock(&st->receive_credit_lock);
-			queue_work(smb_direct_wq, &st->post_recv_credits_work);
-		} else {
-			spin_unlock(&st->receive_credit_lock);
-		}
-
 		sc->recv_io.reassembly.first_entry_offset = offset;
 		ksmbd_debug(RDMA,
 			    "returning to thread data_read=%d reassembly_data_length=%d first_entry_offset=%d\n",
@@ -798,7 +778,6 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
 
 	spin_lock(&t->receive_credit_lock);
 	t->recv_credits += credits;
-	t->count_avail_recvmsg -= credits;
 	spin_unlock(&t->receive_credit_lock);
 
 	spin_lock(&t->lock_new_recv_credits);
@@ -1757,7 +1736,6 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	}
 
 	t->recv_credits = 0;
-	t->count_avail_recvmsg = 0;
 
 	sp->recv_credit_max = smb_direct_receive_credit_max;
 	t->recv_credit_target = 10;
@@ -1845,7 +1823,6 @@ static int smb_direct_create_pools(struct smb_direct_transport *t)
 		recvmsg->sge.length = 0;
 		list_add(&recvmsg->list, &sc->recv_io.free.list);
 	}
-	t->count_avail_recvmsg = sp->recv_credit_max;
 
 	return 0;
 err:
-- 
2.43.0

[PATCH v4 091/142] smb: server: make use of smbdirect_socket.status_wait

[Stefan Metzmacher]

This will allow us to have common helper functions soon.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 16 +++++++---------
 1 file changed, 7 insertions(+), 9 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 4f0c7c8cb041..adab3f0e19e5 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -92,8 +92,6 @@ struct smb_direct_transport {
 
 	struct smbdirect_socket socket;
 
-	wait_queue_head_t	wait_status;
-
 	spinlock_t		receive_credit_lock;
 	int			recv_credits;
 	int			recv_credit_target;
@@ -307,7 +305,7 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 	spin_lock_init(&sc->recv_io.free.lock);
 
 	sc->status = SMBDIRECT_SOCKET_CREATED;
-	init_waitqueue_head(&t->wait_status);
+	init_waitqueue_head(&sc->status_wait);
 
 	spin_lock_init(&sc->recv_io.reassembly.lock);
 	INIT_LIST_HEAD(&sc->recv_io.reassembly.list);
@@ -516,7 +514,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		sc->recv_io.reassembly.full_packet_received = true;
 		sc->status = SMBDIRECT_SOCKET_CONNECTED;
 		enqueue_reassembly(t, recvmsg, 0);
-		wake_up(&t->wait_status);
+		wake_up(&sc->status_wait);
 		return;
 	case SMBDIRECT_EXPECT_DATA_TRANSFER: {
 		struct smbdirect_data_transfer *data_transfer =
@@ -1458,7 +1456,7 @@ static void smb_direct_disconnect(struct ksmbd_transport *t)
 	ksmbd_debug(RDMA, "Disconnecting cm_id=%p\n", sc->rdma.cm_id);
 
 	smb_direct_disconnect_rdma_work(&st->disconnect_work);
-	wait_event_interruptible(st->wait_status,
+	wait_event_interruptible(sc->status_wait,
 				 sc->status == SMBDIRECT_SOCKET_DISCONNECTED);
 	free_transport(st);
 }
@@ -1485,7 +1483,7 @@ static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
 	switch (event->event) {
 	case RDMA_CM_EVENT_ESTABLISHED: {
 		sc->status = SMBDIRECT_SOCKET_CONNECTED;
-		wake_up(&t->wait_status);
+		wake_up(&sc->status_wait);
 		break;
 	}
 	case RDMA_CM_EVENT_DEVICE_REMOVAL:
@@ -1493,14 +1491,14 @@ static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
 		ib_drain_qp(sc->ib.qp);
 
 		sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
-		wake_up_all(&t->wait_status);
+		wake_up_all(&sc->status_wait);
 		wake_up_all(&sc->recv_io.reassembly.wait_queue);
 		wake_up_all(&t->wait_send_credits);
 		break;
 	}
 	case RDMA_CM_EVENT_CONNECT_ERROR: {
 		sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
-		wake_up_all(&t->wait_status);
+		wake_up_all(&sc->status_wait);
 		break;
 	}
 	default:
@@ -1928,7 +1926,7 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 	int ret;
 
 	ksmbd_debug(RDMA, "Waiting for SMB_DIRECT negotiate request\n");
-	ret = wait_event_interruptible_timeout(st->wait_status,
+	ret = wait_event_interruptible_timeout(sc->status_wait,
 					       st->negotiation_requested ||
 					       sc->status == SMBDIRECT_SOCKET_DISCONNECTED,
 					       SMB_DIRECT_NEGOTIATE_TIMEOUT * HZ);
-- 
2.43.0

[PATCH v4 092/142] smb: server: only turn into SMBDIRECT_SOCKET_CONNECTED when negotiation is done

[Stefan Metzmacher]

From SMBDIRECT_SOCKET_CREATED we now go via the following
stages:

1. SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED
   This indicated rdma_accept needs to be called

2. SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING
   This waits for RDMA_CM_EVENT_ESTABLISHED to
   arrive

3. SMBDIRECT_SOCKET_NEGOTIATE_NEEDED
   This waits for the negotiate request to
   arrive

4. SMBDIRECT_SOCKET_NEGOTIATE_RUNNING
   This indicates the negotiate request
   arrived and needs to be processed

5. SMBDIRECT_SOCKET_CONNECTED
   The connection is ready to use

This avoids the extra 'bool negotiation_requested'
and makes the steps more clear.

In future we may want to add trace points when
changing the states, which would be useful for
debugging.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 83 ++++++++++++++++++++++++++++------
 1 file changed, 68 insertions(+), 15 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index adab3f0e19e5..5a64139c1961 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -113,8 +113,6 @@ struct smb_direct_transport {
 	struct work_struct	send_immediate_work;
 	struct work_struct	disconnect_work;
 
-	bool			negotiation_requested;
-
 	bool			legacy_iwarp;
 	u8			initiator_depth;
 	u8			responder_resources;
@@ -255,19 +253,52 @@ static void smb_direct_disconnect_rdma_work(struct work_struct *work)
 			     disconnect_work);
 	struct smbdirect_socket *sc = &t->socket;
 
-	if (sc->status == SMBDIRECT_SOCKET_CONNECTED) {
+	/*
+	 * make sure this and other work is not queued again
+	 * but here we don't block and avoid
+	 * disable[_delayed]_work_sync()
+	 */
+	disable_work(&t->disconnect_work);
+	disable_work(&t->post_recv_credits_work);
+	disable_work(&t->send_immediate_work);
+
+	switch (sc->status) {
+	case SMBDIRECT_SOCKET_NEGOTIATE_NEEDED:
+	case SMBDIRECT_SOCKET_NEGOTIATE_RUNNING:
+	case SMBDIRECT_SOCKET_NEGOTIATE_FAILED:
+	case SMBDIRECT_SOCKET_CONNECTED:
 		sc->status = SMBDIRECT_SOCKET_DISCONNECTING;
 		rdma_disconnect(sc->rdma.cm_id);
+		break;
+
+	case SMBDIRECT_SOCKET_CREATED:
+	case SMBDIRECT_SOCKET_RESOLVE_ADDR_NEEDED:
+	case SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING:
+	case SMBDIRECT_SOCKET_RESOLVE_ADDR_FAILED:
+	case SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED:
+	case SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING:
+	case SMBDIRECT_SOCKET_RESOLVE_ROUTE_FAILED:
+	case SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED:
+	case SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING:
+	case SMBDIRECT_SOCKET_RDMA_CONNECT_FAILED:
+		/*
+		 * rdma_accept() never reached
+		 * RDMA_CM_EVENT_ESTABLISHED
+		 */
+		sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
+		break;
+
+	case SMBDIRECT_SOCKET_DISCONNECTING:
+	case SMBDIRECT_SOCKET_DISCONNECTED:
+	case SMBDIRECT_SOCKET_DESTROYED:
+		break;
 	}
 }
 
 static void
 smb_direct_disconnect_rdma_connection(struct smb_direct_transport *t)
 {
-	struct smbdirect_socket *sc = &t->socket;
-
-	if (sc->status == SMBDIRECT_SOCKET_CONNECTED)
-		queue_work(smb_direct_wq, &t->disconnect_work);
+	queue_work(smb_direct_wq, &t->disconnect_work);
 }
 
 static void smb_direct_send_immediate_work(struct work_struct *work)
@@ -510,9 +541,9 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			smb_direct_disconnect_rdma_connection(t);
 			return;
 		}
-		t->negotiation_requested = true;
 		sc->recv_io.reassembly.full_packet_received = true;
-		sc->status = SMBDIRECT_SOCKET_CONNECTED;
+		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_NEGOTIATE_NEEDED);
+		sc->status = SMBDIRECT_SOCKET_NEGOTIATE_RUNNING;
 		enqueue_reassembly(t, recvmsg, 0);
 		wake_up(&sc->status_wait);
 		return;
@@ -1482,7 +1513,8 @@ static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
 
 	switch (event->event) {
 	case RDMA_CM_EVENT_ESTABLISHED: {
-		sc->status = SMBDIRECT_SOCKET_CONNECTED;
+		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING);
+		sc->status = SMBDIRECT_SOCKET_NEGOTIATE_NEEDED;
 		wake_up(&sc->status_wait);
 		break;
 	}
@@ -1491,6 +1523,7 @@ static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
 		ib_drain_qp(sc->ib.qp);
 
 		sc->status = SMBDIRECT_SOCKET_DISCONNECTED;
+		smb_direct_disconnect_rdma_work(&sc->disconnect_work);
 		wake_up_all(&sc->status_wait);
 		wake_up_all(&sc->recv_io.reassembly.wait_queue);
 		wake_up_all(&t->wait_send_credits);
@@ -1547,6 +1580,8 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 		resp->min_version = SMB_DIRECT_VERSION_LE;
 		resp->max_version = SMB_DIRECT_VERSION_LE;
 		resp->status = STATUS_NOT_SUPPORTED;
+
+		sc->status = SMBDIRECT_SOCKET_NEGOTIATE_FAILED;
 	} else {
 		resp->status = STATUS_SUCCESS;
 		resp->min_version = SMB_DIRECT_VERSION_LE;
@@ -1563,6 +1598,7 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 				cpu_to_le32(sp->max_fragmented_recv_size);
 
 		sc->recv_io.expected = SMBDIRECT_EXPECT_DATA_TRANSFER;
+		sc->status = SMBDIRECT_SOCKET_CONNECTED;
 	}
 
 	sendmsg->sge[0].addr = ib_dma_map_single(sc->ib.dev,
@@ -1618,6 +1654,8 @@ static int smb_direct_accept_client(struct smb_direct_transport *t)
 	conn_param.rnr_retry_count = SMB_DIRECT_CM_RNR_RETRY;
 	conn_param.flow_control = 0;
 
+	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED);
+	sc->status = SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING;
 	ret = rdma_accept(sc->rdma.cm_id, &conn_param);
 	if (ret) {
 		pr_err("error at rdma_accept: %d\n", ret);
@@ -1632,6 +1670,9 @@ static int smb_direct_prepare_negotiation(struct smb_direct_transport *t)
 	int ret;
 	struct smbdirect_recv_io *recvmsg;
 
+	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_CREATED);
+	sc->status = SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED;
+
 	sc->recv_io.expected = SMBDIRECT_EXPECT_NEGOTIATE_REQ;
 
 	recvmsg = get_free_recvmsg(t);
@@ -1644,7 +1685,6 @@ static int smb_direct_prepare_negotiation(struct smb_direct_transport *t)
 		goto out_err;
 	}
 
-	t->negotiation_requested = false;
 	ret = smb_direct_accept_client(t);
 	if (ret) {
 		pr_err("Can't accept client\n");
@@ -1925,12 +1965,25 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 	struct smbdirect_negotiate_req *req;
 	int ret;
 
+	/*
+	 * We are waiting to pass the following states:
+	 *
+	 * SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED
+	 * SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING
+	 * SMBDIRECT_SOCKET_NEGOTIATE_NEEDED
+	 *
+	 * To finally get to SMBDIRECT_SOCKET_NEGOTIATE_RUNNING
+	 * in order to continue below.
+	 *
+	 * Everything else is unexpected and an error.
+	 */
 	ksmbd_debug(RDMA, "Waiting for SMB_DIRECT negotiate request\n");
 	ret = wait_event_interruptible_timeout(sc->status_wait,
-					       st->negotiation_requested ||
-					       sc->status == SMBDIRECT_SOCKET_DISCONNECTED,
-					       SMB_DIRECT_NEGOTIATE_TIMEOUT * HZ);
-	if (ret <= 0 || sc->status == SMBDIRECT_SOCKET_DISCONNECTED)
+					sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED &&
+					sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING &&
+					sc->status != SMBDIRECT_SOCKET_NEGOTIATE_NEEDED,
+					SMB_DIRECT_NEGOTIATE_TIMEOUT * HZ);
+	if (ret <= 0 || sc->status != SMBDIRECT_SOCKET_NEGOTIATE_RUNNING)
 		return ret < 0 ? ret : -ETIMEDOUT;
 
 	recvmsg = get_first_reassembly(st);
-- 
2.43.0

[PATCH v4 093/142] smb: server: use disable_work_sync in transport_rdma.c

[Stefan Metzmacher]

This makes it safer during the disconnect and avoids
requeueing.

It's ok to call disable_work[_sync]() more than once.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 5a64139c1961..fdcf53856665 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -386,9 +386,9 @@ static void free_transport(struct smb_direct_transport *t)
 	wait_event(t->wait_send_pending,
 		   atomic_read(&t->send_pending) == 0);
 
-	cancel_work_sync(&t->disconnect_work);
-	cancel_work_sync(&t->post_recv_credits_work);
-	cancel_work_sync(&t->send_immediate_work);
+	disable_work_sync(&t->disconnect_work);
+	disable_work_sync(&t->post_recv_credits_work);
+	disable_work_sync(&t->send_immediate_work);
 
 	if (sc->ib.qp) {
 		ib_drain_qp(sc->ib.qp);
-- 
2.43.0

[PATCH v4 094/142] smb: server: move smb_direct_disconnect_rdma_work() into free_transport()

[Stefan Metzmacher]

The logic is also needed when smb_direct_handle_connect_request()
calls free_transport(), because rdma_accept() and RDMA_CM_EVENT_ESTABLISHED
could already be reached.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index fdcf53856665..741b5b62b7d6 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -380,13 +380,19 @@ static void free_transport(struct smb_direct_transport *t)
 	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_recv_io *recvmsg;
 
+	disable_work_sync(&t->disconnect_work);
+	if (sc->status < SMBDIRECT_SOCKET_DISCONNECTING) {
+		smb_direct_disconnect_rdma_work(&t->disconnect_work);
+		wait_event_interruptible(sc->status_wait,
+					 sc->status == SMBDIRECT_SOCKET_DISCONNECTED);
+	}
+
 	wake_up_all(&t->wait_send_credits);
 
 	ksmbd_debug(RDMA, "wait for all send posted to IB to finish\n");
 	wait_event(t->wait_send_pending,
 		   atomic_read(&t->send_pending) == 0);
 
-	disable_work_sync(&t->disconnect_work);
 	disable_work_sync(&t->post_recv_credits_work);
 	disable_work_sync(&t->send_immediate_work);
 
@@ -1486,9 +1492,6 @@ static void smb_direct_disconnect(struct ksmbd_transport *t)
 
 	ksmbd_debug(RDMA, "Disconnecting cm_id=%p\n", sc->rdma.cm_id);
 
-	smb_direct_disconnect_rdma_work(&st->disconnect_work);
-	wait_event_interruptible(sc->status_wait,
-				 sc->status == SMBDIRECT_SOCKET_DISCONNECTED);
 	free_transport(st);
 }
 
-- 
2.43.0

[PATCH v4 095/142] smb: server: don't wait for info->send_pending == 0 on error

[Stefan Metzmacher]

Instead we just wake up the waiters and let them return -ENOTCONN.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 741b5b62b7d6..d5b01748f0c4 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -388,10 +388,7 @@ static void free_transport(struct smb_direct_transport *t)
 	}
 
 	wake_up_all(&t->wait_send_credits);
-
-	ksmbd_debug(RDMA, "wait for all send posted to IB to finish\n");
-	wait_event(t->wait_send_pending,
-		   atomic_read(&t->send_pending) == 0);
+	wake_up_all(&t->wait_send_pending);
 
 	disable_work_sync(&t->post_recv_credits_work);
 	disable_work_sync(&t->send_immediate_work);
@@ -1291,7 +1288,11 @@ static int smb_direct_writev(struct ksmbd_transport *t,
 	 */
 
 	wait_event(st->wait_send_pending,
-		   atomic_read(&st->send_pending) == 0);
+		   atomic_read(&st->send_pending) == 0 ||
+		   sc->status != SMBDIRECT_SOCKET_CONNECTED);
+	if (sc->status != SMBDIRECT_SOCKET_CONNECTED && ret == 0)
+		ret = -ENOTCONN;
+
 	return ret;
 }
 
@@ -1624,7 +1625,11 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 	}
 
 	wait_event(t->wait_send_pending,
-		   atomic_read(&t->send_pending) == 0);
+		   atomic_read(&t->send_pending) == 0 ||
+		   sc->status != SMBDIRECT_SOCKET_CONNECTED);
+	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
+		return -ENOTCONN;
+
 	return 0;
 }
 
-- 
2.43.0

[PATCH v4 096/142] smb: server: make use of smbdirect_socket_init()

[Stefan Metzmacher]

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 12 +-----------
 1 file changed, 1 insertion(+), 11 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index d5b01748f0c4..f41c82598e3c 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -323,6 +323,7 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 	if (!t)
 		return NULL;
 	sc = &t->socket;
+	smbdirect_socket_init(sc);
 
 	sc->rdma.cm_id = cm_id;
 	cm_id->context = t;
@@ -332,17 +333,6 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 
 	sc->ib.dev = sc->rdma.cm_id->device;
 
-	INIT_LIST_HEAD(&sc->recv_io.free.list);
-	spin_lock_init(&sc->recv_io.free.lock);
-
-	sc->status = SMBDIRECT_SOCKET_CREATED;
-	init_waitqueue_head(&sc->status_wait);
-
-	spin_lock_init(&sc->recv_io.reassembly.lock);
-	INIT_LIST_HEAD(&sc->recv_io.reassembly.list);
-	sc->recv_io.reassembly.data_length = 0;
-	sc->recv_io.reassembly.queue_length = 0;
-	init_waitqueue_head(&sc->recv_io.reassembly.wait_queue);
 	init_waitqueue_head(&t->wait_send_credits);
 	init_waitqueue_head(&t->wait_rw_credits);
 
-- 
2.43.0

[PATCH v4 097/142] smb: server: make use of smbdirect_socket.disconnect_work

[Stefan Metzmacher]

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index f41c82598e3c..62e13112a2b6 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -111,7 +111,6 @@ struct smb_direct_transport {
 
 	struct work_struct	post_recv_credits_work;
 	struct work_struct	send_immediate_work;
-	struct work_struct	disconnect_work;
 
 	bool			legacy_iwarp;
 	u8			initiator_depth;
@@ -248,17 +247,17 @@ static struct smbdirect_recv_io *get_first_reassembly(struct smb_direct_transpor
 
 static void smb_direct_disconnect_rdma_work(struct work_struct *work)
 {
+	struct smbdirect_socket *sc =
+		container_of(work, struct smbdirect_socket, disconnect_work);
 	struct smb_direct_transport *t =
-		container_of(work, struct smb_direct_transport,
-			     disconnect_work);
-	struct smbdirect_socket *sc = &t->socket;
+		container_of(sc, struct smb_direct_transport, socket);
 
 	/*
 	 * make sure this and other work is not queued again
 	 * but here we don't block and avoid
 	 * disable[_delayed]_work_sync()
 	 */
-	disable_work(&t->disconnect_work);
+	disable_work(&sc->disconnect_work);
 	disable_work(&t->post_recv_credits_work);
 	disable_work(&t->send_immediate_work);
 
@@ -298,7 +297,9 @@ static void smb_direct_disconnect_rdma_work(struct work_struct *work)
 static void
 smb_direct_disconnect_rdma_connection(struct smb_direct_transport *t)
 {
-	queue_work(smb_direct_wq, &t->disconnect_work);
+	struct smbdirect_socket *sc = &t->socket;
+
+	queue_work(smb_direct_wq, &sc->disconnect_work);
 }
 
 static void smb_direct_send_immediate_work(struct work_struct *work)
@@ -325,6 +326,8 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 	sc = &t->socket;
 	smbdirect_socket_init(sc);
 
+	INIT_WORK(&sc->disconnect_work, smb_direct_disconnect_rdma_work);
+
 	sc->rdma.cm_id = cm_id;
 	cm_id->context = t;
 
@@ -346,7 +349,6 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 	INIT_WORK(&t->post_recv_credits_work,
 		  smb_direct_post_recv_credits);
 	INIT_WORK(&t->send_immediate_work, smb_direct_send_immediate_work);
-	INIT_WORK(&t->disconnect_work, smb_direct_disconnect_rdma_work);
 
 	conn = ksmbd_conn_alloc();
 	if (!conn)
@@ -370,9 +372,9 @@ static void free_transport(struct smb_direct_transport *t)
 	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_recv_io *recvmsg;
 
-	disable_work_sync(&t->disconnect_work);
+	disable_work_sync(&sc->disconnect_work);
 	if (sc->status < SMBDIRECT_SOCKET_DISCONNECTING) {
-		smb_direct_disconnect_rdma_work(&t->disconnect_work);
+		smb_direct_disconnect_rdma_work(&sc->disconnect_work);
 		wait_event_interruptible(sc->status_wait,
 					 sc->status == SMBDIRECT_SOCKET_DISCONNECTED);
 	}
@@ -1493,7 +1495,7 @@ static void smb_direct_shutdown(struct ksmbd_transport *t)
 
 	ksmbd_debug(RDMA, "smb-direct shutdown cm_id=%p\n", sc->rdma.cm_id);
 
-	smb_direct_disconnect_rdma_work(&st->disconnect_work);
+	smb_direct_disconnect_rdma_work(&sc->disconnect_work);
 }
 
 static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
-- 
2.43.0

[PATCH v4 098/142] smb: server: make use of smbdirect_socket.send_io.pending.{count,wait_queue}

[Stefan Metzmacher]

This will is used by the client already and will allow to create
common helper functions.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 26 ++++++++++----------------
 1 file changed, 10 insertions(+), 16 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 62e13112a2b6..fd8d3fbdfa6c 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -106,9 +106,6 @@ struct smb_direct_transport {
 	wait_queue_head_t	wait_send_credits;
 	wait_queue_head_t	wait_rw_credits;
 
-	wait_queue_head_t	wait_send_pending;
-	atomic_t		send_pending;
-
 	struct work_struct	post_recv_credits_work;
 	struct work_struct	send_immediate_work;
 
@@ -341,9 +338,6 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 
 	spin_lock_init(&t->receive_credit_lock);
 
-	init_waitqueue_head(&t->wait_send_pending);
-	atomic_set(&t->send_pending, 0);
-
 	spin_lock_init(&t->lock_new_recv_credits);
 
 	INIT_WORK(&t->post_recv_credits_work,
@@ -380,7 +374,7 @@ static void free_transport(struct smb_direct_transport *t)
 	}
 
 	wake_up_all(&t->wait_send_credits);
-	wake_up_all(&t->wait_send_pending);
+	wake_up_all(&sc->send_io.pending.wait_queue);
 
 	disable_work_sync(&t->post_recv_credits_work);
 	disable_work_sync(&t->send_immediate_work);
@@ -834,8 +828,8 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
 		smb_direct_disconnect_rdma_connection(t);
 	}
 
-	if (atomic_dec_and_test(&t->send_pending))
-		wake_up(&t->wait_send_pending);
+	if (atomic_dec_and_test(&sc->send_io.pending.count))
+		wake_up(&sc->send_io.pending.wait_queue);
 
 	/* iterate and free the list of messages in reverse. the list's head
 	 * is invalid.
@@ -868,12 +862,12 @@ static int smb_direct_post_send(struct smb_direct_transport *t,
 	struct smbdirect_socket *sc = &t->socket;
 	int ret;
 
-	atomic_inc(&t->send_pending);
+	atomic_inc(&sc->send_io.pending.count);
 	ret = ib_post_send(sc->ib.qp, wr, NULL);
 	if (ret) {
 		pr_err("failed to post send: %d\n", ret);
-		if (atomic_dec_and_test(&t->send_pending))
-			wake_up(&t->wait_send_pending);
+		if (atomic_dec_and_test(&sc->send_io.pending.count))
+			wake_up(&sc->send_io.pending.wait_queue);
 		smb_direct_disconnect_rdma_connection(t);
 	}
 	return ret;
@@ -1279,8 +1273,8 @@ static int smb_direct_writev(struct ksmbd_transport *t,
 	 * that means all the I/Os have been out and we are good to return
 	 */
 
-	wait_event(st->wait_send_pending,
-		   atomic_read(&st->send_pending) == 0 ||
+	wait_event(sc->send_io.pending.wait_queue,
+		   atomic_read(&sc->send_io.pending.count) == 0 ||
 		   sc->status != SMBDIRECT_SOCKET_CONNECTED);
 	if (sc->status != SMBDIRECT_SOCKET_CONNECTED && ret == 0)
 		ret = -ENOTCONN;
@@ -1616,8 +1610,8 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 		return ret;
 	}
 
-	wait_event(t->wait_send_pending,
-		   atomic_read(&t->send_pending) == 0 ||
+	wait_event(sc->send_io.pending.wait_queue,
+		   atomic_read(&sc->send_io.pending.count) == 0 ||
 		   sc->status != SMBDIRECT_SOCKET_CONNECTED);
 	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
 		return -ENOTCONN;
-- 
2.43.0

Re: [PATCH v4 098/142] smb: server: make use of smbdirect_socket.send_io.pending.{count,wait_queue}

[Stefan Metzmacher]

Am 25.08.25 um 22:40 schrieb Stefan Metzmacher:
> This will is used by the client already and will allow to create
> common helper functions.
> 
> Cc: Namjae Jeon <linkinjeon@kernel.org>
> Cc: Steve French <smfrench@gmail.com>
> Cc: Tom Talpey <tom@talpey.com>
> Cc: linux-cifs@vger.kernel.org
> Cc: samba-technical@lists.samba.org
> Signed-off-by: Stefan Metzmacher <metze@samba.org>
> ---
>   fs/smb/server/transport_rdma.c | 26 ++++++++++----------------
>   1 file changed, 10 insertions(+), 16 deletions(-)
> 
> diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
> index 62e13112a2b6..fd8d3fbdfa6c 100644
> --- a/fs/smb/server/transport_rdma.c
> +++ b/fs/smb/server/transport_rdma.c
> @@ -106,9 +106,6 @@ struct smb_direct_transport {
>   	wait_queue_head_t	wait_send_credits;
>   	wait_queue_head_t	wait_rw_credits;
>   
> -	wait_queue_head_t	wait_send_pending;
> -	atomic_t		send_pending;
> -
>   	struct work_struct	post_recv_credits_work;
>   	struct work_struct	send_immediate_work;
>   
> @@ -341,9 +338,6 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
>   
>   	spin_lock_init(&t->receive_credit_lock);
>   
> -	init_waitqueue_head(&t->wait_send_pending);
> -	atomic_set(&t->send_pending, 0);
> -
>   	spin_lock_init(&t->lock_new_recv_credits);
>   
>   	INIT_WORK(&t->post_recv_credits_work,
> @@ -380,7 +374,7 @@ static void free_transport(struct smb_direct_transport *t)
>   	}
>   
>   	wake_up_all(&t->wait_send_credits);
> -	wake_up_all(&t->wait_send_pending);
> +	wake_up_all(&sc->send_io.pending.wait_queue);
>   
>   	disable_work_sync(&t->post_recv_credits_work);
>   	disable_work_sync(&t->send_immediate_work);
> @@ -834,8 +828,8 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
>   		smb_direct_disconnect_rdma_connection(t);
>   	}
>   
> -	if (atomic_dec_and_test(&t->send_pending))
> -		wake_up(&t->wait_send_pending);
> +	if (atomic_dec_and_test(&sc->send_io.pending.count))
> +		wake_up(&sc->send_io.pending.wait_queue);

In the rebase on top of "smb: server: let smb_direct_writev() respect SMB_DIRECT_MAX_SEND_SGES"
sc->send_io.pending.wait_queue will become sc->send_io.pending.zero_wait_queue in
order to make it clear it's woken when count reaches 0.

metze

[PATCH v4 099/142] smb: server: make use of smbdirect_socket.send_io.credits.{count,wait_queue}

[Stefan Metzmacher]

This will is used by the client already and will allow to create
common helper functions.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 28 +++++++++++++---------------
 1 file changed, 13 insertions(+), 15 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index fd8d3fbdfa6c..d4bc737a9882 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -96,14 +96,12 @@ struct smb_direct_transport {
 	int			recv_credits;
 	int			recv_credit_target;
 
-	atomic_t		send_credits;
 	spinlock_t		lock_new_recv_credits;
 	int			new_recv_credits;
 	int			max_rw_credits;
 	int			pages_per_rw_credit;
 	atomic_t		rw_credits;
 
-	wait_queue_head_t	wait_send_credits;
 	wait_queue_head_t	wait_rw_credits;
 
 	struct work_struct	post_recv_credits_work;
@@ -333,7 +331,6 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 
 	sc->ib.dev = sc->rdma.cm_id->device;
 
-	init_waitqueue_head(&t->wait_send_credits);
 	init_waitqueue_head(&t->wait_rw_credits);
 
 	spin_lock_init(&t->receive_credit_lock);
@@ -373,7 +370,7 @@ static void free_transport(struct smb_direct_transport *t)
 					 sc->status == SMBDIRECT_SOCKET_DISCONNECTED);
 	}
 
-	wake_up_all(&t->wait_send_credits);
+	wake_up_all(&sc->send_io.credits.wait_queue);
 	wake_up_all(&sc->send_io.pending.wait_queue);
 
 	disable_work_sync(&t->post_recv_credits_work);
@@ -575,14 +572,14 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		t->recv_credit_target =
 				le16_to_cpu(data_transfer->credits_requested);
 		atomic_add(le16_to_cpu(data_transfer->credits_granted),
-			   &t->send_credits);
+			   &sc->send_io.credits.count);
 
 		if (le16_to_cpu(data_transfer->flags) &
 		    SMBDIRECT_FLAG_RESPONSE_REQUESTED)
 			queue_work(smb_direct_wq, &t->send_immediate_work);
 
-		if (atomic_read(&t->send_credits) > 0)
-			wake_up(&t->wait_send_credits);
+		if (atomic_read(&sc->send_io.credits.count) > 0)
+			wake_up(&sc->send_io.credits.wait_queue);
 
 		if (data_length) {
 			if (t->recv_credit_target > old_recv_credit_target)
@@ -888,6 +885,7 @@ static int smb_direct_flush_send_list(struct smb_direct_transport *t,
 				      struct smb_direct_send_ctx *send_ctx,
 				      bool is_last)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_send_io *first, *last;
 	int ret;
 
@@ -914,8 +912,8 @@ static int smb_direct_flush_send_list(struct smb_direct_transport *t,
 					 send_ctx->need_invalidate_rkey,
 					 send_ctx->remote_key);
 	} else {
-		atomic_add(send_ctx->wr_cnt, &t->send_credits);
-		wake_up(&t->wait_send_credits);
+		atomic_add(send_ctx->wr_cnt, &sc->send_io.credits.count);
+		wake_up(&sc->send_io.credits.wait_queue);
 		list_for_each_entry_safe(first, last, &send_ctx->msg_list,
 					 sibling_list) {
 			smb_direct_free_sendmsg(t, first);
@@ -950,16 +948,17 @@ static int wait_for_credits(struct smb_direct_transport *t,
 static int wait_for_send_credits(struct smb_direct_transport *t,
 				 struct smb_direct_send_ctx *send_ctx)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	int ret;
 
 	if (send_ctx &&
-	    (send_ctx->wr_cnt >= 16 || atomic_read(&t->send_credits) <= 1)) {
+	    (send_ctx->wr_cnt >= 16 || atomic_read(&sc->send_io.credits.count) <= 1)) {
 		ret = smb_direct_flush_send_list(t, send_ctx, false);
 		if (ret)
 			return ret;
 	}
 
-	return wait_for_credits(t, &t->wait_send_credits, &t->send_credits, 1);
+	return wait_for_credits(t, &sc->send_io.credits.wait_queue, &sc->send_io.credits.count, 1);
 }
 
 static int wait_for_rw_credits(struct smb_direct_transport *t, int credits)
@@ -1142,7 +1141,7 @@ static int smb_direct_post_send_data(struct smb_direct_transport *t,
 	ret = smb_direct_create_header(t, data_length, remaining_data_length,
 				       &msg);
 	if (ret) {
-		atomic_inc(&t->send_credits);
+		atomic_inc(&sc->send_io.credits.count);
 		return ret;
 	}
 
@@ -1182,7 +1181,7 @@ static int smb_direct_post_send_data(struct smb_direct_transport *t,
 	return 0;
 err:
 	smb_direct_free_sendmsg(t, msg);
-	atomic_inc(&t->send_credits);
+	atomic_inc(&sc->send_io.credits.count);
 	return ret;
 }
 
@@ -1516,7 +1515,7 @@ static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
 		smb_direct_disconnect_rdma_work(&sc->disconnect_work);
 		wake_up_all(&sc->status_wait);
 		wake_up_all(&sc->recv_io.reassembly.wait_queue);
-		wake_up_all(&t->wait_send_credits);
+		wake_up_all(&sc->send_io.credits.wait_queue);
 		break;
 	}
 	case RDMA_CM_EVENT_CONNECT_ERROR: {
@@ -1774,7 +1773,6 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	t->new_recv_credits = 0;
 
 	sp->send_credit_target = smb_direct_send_credit_target;
-	atomic_set(&t->send_credits, 0);
 	atomic_set(&t->rw_credits, t->max_rw_credits);
 
 	sp->max_send_size = smb_direct_max_send_size;
-- 
2.43.0

[PATCH v4 100/142] smb: server: make use of struct smbdirect_send_batch

[Stefan Metzmacher]

This makes it easier to move functions to the common
smbdirect code in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 21 +++++++--------------
 1 file changed, 7 insertions(+), 14 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index d4bc737a9882..cca926ad2677 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -118,13 +118,6 @@ struct smb_direct_transport {
 
 static const struct ksmbd_transport_ops ksmbd_smb_direct_transport_ops;
 
-struct smb_direct_send_ctx {
-	struct list_head	msg_list;
-	int			wr_cnt;
-	bool			need_invalidate_rkey;
-	unsigned int		remote_key;
-};
-
 struct smb_direct_rdma_rw_msg {
 	struct smb_direct_transport	*t;
 	struct ib_cqe		cqe;
@@ -156,7 +149,7 @@ static inline int get_buf_page_count(void *buf, int size)
 static void smb_direct_destroy_pools(struct smb_direct_transport *transport);
 static void smb_direct_post_recv_credits(struct work_struct *work);
 static int smb_direct_post_send_data(struct smb_direct_transport *t,
-				     struct smb_direct_send_ctx *send_ctx,
+				     struct smbdirect_send_batch *send_ctx,
 				     struct kvec *iov, int niov,
 				     int remaining_data_length);
 
@@ -871,7 +864,7 @@ static int smb_direct_post_send(struct smb_direct_transport *t,
 }
 
 static void smb_direct_send_ctx_init(struct smb_direct_transport *t,
-				     struct smb_direct_send_ctx *send_ctx,
+				     struct smbdirect_send_batch *send_ctx,
 				     bool need_invalidate_rkey,
 				     unsigned int remote_key)
 {
@@ -882,7 +875,7 @@ static void smb_direct_send_ctx_init(struct smb_direct_transport *t,
 }
 
 static int smb_direct_flush_send_list(struct smb_direct_transport *t,
-				      struct smb_direct_send_ctx *send_ctx,
+				      struct smbdirect_send_batch *send_ctx,
 				      bool is_last)
 {
 	struct smbdirect_socket *sc = &t->socket;
@@ -946,7 +939,7 @@ static int wait_for_credits(struct smb_direct_transport *t,
 }
 
 static int wait_for_send_credits(struct smb_direct_transport *t,
-				 struct smb_direct_send_ctx *send_ctx)
+				 struct smbdirect_send_batch *send_ctx)
 {
 	struct smbdirect_socket *sc = &t->socket;
 	int ret;
@@ -1081,7 +1074,7 @@ static int get_mapped_sg_list(struct ib_device *device, void *buf, int size,
 }
 
 static int post_sendmsg(struct smb_direct_transport *t,
-			struct smb_direct_send_ctx *send_ctx,
+			struct smbdirect_send_batch *send_ctx,
 			struct smbdirect_send_io *msg)
 {
 	struct smbdirect_socket *sc = &t->socket;
@@ -1120,7 +1113,7 @@ static int post_sendmsg(struct smb_direct_transport *t,
 }
 
 static int smb_direct_post_send_data(struct smb_direct_transport *t,
-				     struct smb_direct_send_ctx *send_ctx,
+				     struct smbdirect_send_batch *send_ctx,
 				     struct kvec *iov, int niov,
 				     int remaining_data_length)
 {
@@ -1198,7 +1191,7 @@ static int smb_direct_writev(struct ksmbd_transport *t,
 			sizeof(struct smbdirect_data_transfer);
 	int ret;
 	struct kvec vec;
-	struct smb_direct_send_ctx send_ctx;
+	struct smbdirect_send_batch send_ctx;
 
 	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
 		return -ENOTCONN;
-- 
2.43.0

[PATCH v4 101/142] smb: server: make use smbdirect_socket.rw_io.credits

[Stefan Metzmacher]

This will allow to us to have functions moved into
common code in future (even if it's only used by the server).

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 44 +++++++++++++++++-----------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index cca926ad2677..f04a3d1d0395 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -98,11 +98,6 @@ struct smb_direct_transport {
 
 	spinlock_t		lock_new_recv_credits;
 	int			new_recv_credits;
-	int			max_rw_credits;
-	int			pages_per_rw_credit;
-	atomic_t		rw_credits;
-
-	wait_queue_head_t	wait_rw_credits;
 
 	struct work_struct	post_recv_credits_work;
 	struct work_struct	send_immediate_work;
@@ -324,8 +319,6 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 
 	sc->ib.dev = sc->rdma.cm_id->device;
 
-	init_waitqueue_head(&t->wait_rw_credits);
-
 	spin_lock_init(&t->receive_credit_lock);
 
 	spin_lock_init(&t->lock_new_recv_credits);
@@ -956,14 +949,21 @@ static int wait_for_send_credits(struct smb_direct_transport *t,
 
 static int wait_for_rw_credits(struct smb_direct_transport *t, int credits)
 {
-	return wait_for_credits(t, &t->wait_rw_credits, &t->rw_credits, credits);
+	struct smbdirect_socket *sc = &t->socket;
+
+	return wait_for_credits(t,
+				&sc->rw_io.credits.wait_queue,
+				&sc->rw_io.credits.count,
+				credits);
 }
 
 static int calc_rw_credits(struct smb_direct_transport *t,
 			   char *buf, unsigned int len)
 {
+	struct smbdirect_socket *sc = &t->socket;
+
 	return DIV_ROUND_UP(get_buf_page_count(buf, len),
-			    t->pages_per_rw_credit);
+			    sc->rw_io.credits.num_pages);
 }
 
 static int smb_direct_create_header(struct smb_direct_transport *t,
@@ -1441,8 +1441,8 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 		smb_direct_free_rdma_rw_msg(t, msg,
 					    is_read ? DMA_FROM_DEVICE : DMA_TO_DEVICE);
 	}
-	atomic_add(credits_needed, &t->rw_credits);
-	wake_up(&t->wait_rw_credits);
+	atomic_add(credits_needed, &sc->rw_io.credits.count);
+	wake_up(&sc->rw_io.credits.wait_queue);
 	return ret;
 }
 
@@ -1720,9 +1720,9 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	 * MR invalidation.
 	 */
 	sp->max_read_write_size = smb_direct_max_read_write_size;
-	t->pages_per_rw_credit = smb_direct_get_max_fr_pages(t);
-	t->max_rw_credits = DIV_ROUND_UP(sp->max_read_write_size,
-					 (t->pages_per_rw_credit - 1) *
+	sc->rw_io.credits.num_pages = smb_direct_get_max_fr_pages(t);
+	sc->rw_io.credits.max = DIV_ROUND_UP(sp->max_read_write_size,
+					 (sc->rw_io.credits.num_pages - 1) *
 					 PAGE_SIZE);
 
 	max_sge_per_wr = min_t(unsigned int, device->attrs.max_send_sge,
@@ -1730,9 +1730,9 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	max_sge_per_wr = max_t(unsigned int, max_sge_per_wr,
 			       max_send_sges);
 	wrs_per_credit = max_t(unsigned int, 4,
-			       DIV_ROUND_UP(t->pages_per_rw_credit,
+			       DIV_ROUND_UP(sc->rw_io.credits.num_pages,
 					    max_sge_per_wr) + 1);
-	max_rw_wrs = t->max_rw_credits * wrs_per_credit;
+	max_rw_wrs = sc->rw_io.credits.max * wrs_per_credit;
 
 	max_send_wrs = smb_direct_send_credit_target + max_rw_wrs;
 	if (max_send_wrs > device->attrs.max_cqe ||
@@ -1766,7 +1766,7 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	t->new_recv_credits = 0;
 
 	sp->send_credit_target = smb_direct_send_credit_target;
-	atomic_set(&t->rw_credits, t->max_rw_credits);
+	atomic_set(&sc->rw_io.credits.count, sc->rw_io.credits.max);
 
 	sp->max_send_size = smb_direct_max_send_size;
 	sp->max_recv_size = smb_direct_max_receive_size;
@@ -1777,7 +1777,7 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	cap->max_send_sge = max_sge_per_wr;
 	cap->max_recv_sge = SMBDIRECT_RECV_IO_MAX_SGE;
 	cap->max_inline_data = 0;
-	cap->max_rdma_ctxs = t->max_rw_credits;
+	cap->max_rdma_ctxs = sc->rw_io.credits.max;
 	return 0;
 }
 
@@ -1911,11 +1911,11 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 	pages_per_rw = DIV_ROUND_UP(sp->max_read_write_size, PAGE_SIZE) + 1;
 	if (pages_per_rw > sc->ib.dev->attrs.max_sgl_rd) {
 		ret = ib_mr_pool_init(sc->ib.qp, &sc->ib.qp->rdma_mrs,
-				      t->max_rw_credits, IB_MR_TYPE_MEM_REG,
-				      t->pages_per_rw_credit, 0);
+				      sc->rw_io.credits.max, IB_MR_TYPE_MEM_REG,
+				      sc->rw_io.credits.num_pages, 0);
 		if (ret) {
-			pr_err("failed to init mr pool count %d pages %d\n",
-			       t->max_rw_credits, t->pages_per_rw_credit);
+			pr_err("failed to init mr pool count %zu pages %zu\n",
+			       sc->rw_io.credits.max, sc->rw_io.credits.num_pages);
 			goto err;
 		}
 	}
-- 
2.43.0

[PATCH v4 102/142] smb: server: make use of struct smbdirect_rw_io

[Stefan Metzmacher]

This will allow us to create functions in the common
smbdirect code to be used by the server in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 37 +++++++++++++---------------------
 1 file changed, 14 insertions(+), 23 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index f04a3d1d0395..3a0244943dc7 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -113,17 +113,6 @@ struct smb_direct_transport {
 
 static const struct ksmbd_transport_ops ksmbd_smb_direct_transport_ops;
 
-struct smb_direct_rdma_rw_msg {
-	struct smb_direct_transport	*t;
-	struct ib_cqe		cqe;
-	int			status;
-	struct completion	*completion;
-	struct list_head	list;
-	struct rdma_rw_ctx	rw_ctx;
-	struct sg_table		sgt;
-	struct scatterlist	sg_list[];
-};
-
 void init_smbd_max_io_size(unsigned int sz)
 {
 	sz = clamp_val(sz, SMBD_MIN_IOSIZE, SMBD_MAX_IOSIZE);
@@ -1275,12 +1264,12 @@ static int smb_direct_writev(struct ksmbd_transport *t,
 }
 
 static void smb_direct_free_rdma_rw_msg(struct smb_direct_transport *t,
-					struct smb_direct_rdma_rw_msg *msg,
+					struct smbdirect_rw_io *msg,
 					enum dma_data_direction dir)
 {
 	struct smbdirect_socket *sc = &t->socket;
 
-	rdma_rw_ctx_destroy(&msg->rw_ctx, sc->ib.qp, sc->ib.qp->port,
+	rdma_rw_ctx_destroy(&msg->rdma_ctx, sc->ib.qp, sc->ib.qp->port,
 			    msg->sgt.sgl, msg->sgt.nents, dir);
 	sg_free_table_chained(&msg->sgt, SG_CHUNK_SIZE);
 	kfree(msg);
@@ -1289,12 +1278,14 @@ static void smb_direct_free_rdma_rw_msg(struct smb_direct_transport *t,
 static void read_write_done(struct ib_cq *cq, struct ib_wc *wc,
 			    enum dma_data_direction dir)
 {
-	struct smb_direct_rdma_rw_msg *msg = container_of(wc->wr_cqe,
-							  struct smb_direct_rdma_rw_msg, cqe);
-	struct smb_direct_transport *t = msg->t;
+	struct smbdirect_rw_io *msg =
+		container_of(wc->wr_cqe, struct smbdirect_rw_io, cqe);
+	struct smbdirect_socket *sc = msg->socket;
+	struct smb_direct_transport *t =
+		container_of(sc, struct smb_direct_transport, socket);
 
 	if (wc->status != IB_WC_SUCCESS) {
-		msg->status = -EIO;
+		msg->error = -EIO;
 		pr_err("read/write error. opcode = %d, status = %s(%d)\n",
 		       wc->opcode, ib_wc_status_msg(wc->status), wc->status);
 		if (wc->status != IB_WC_WR_FLUSH_ERR)
@@ -1322,7 +1313,7 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 {
 	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
-	struct smb_direct_rdma_rw_msg *msg, *next_msg;
+	struct smbdirect_rw_io *msg, *next_msg;
 	int i, ret;
 	DECLARE_COMPLETION_ONSTACK(completion);
 	struct ib_send_wr *first_wr;
@@ -1379,7 +1370,7 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 
 		desc_buf_len = le32_to_cpu(desc[i].length);
 
-		msg->t = t;
+		msg->socket = sc;
 		msg->cqe.done = is_read ? read_done : write_done;
 		msg->completion = &completion;
 
@@ -1401,7 +1392,7 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 			goto out;
 		}
 
-		ret = rdma_rw_ctx_init(&msg->rw_ctx, sc->ib.qp, sc->ib.qp->port,
+		ret = rdma_rw_ctx_init(&msg->rdma_ctx, sc->ib.qp, sc->ib.qp->port,
 				       msg->sgt.sgl,
 				       get_buf_page_count(desc_buf, desc_buf_len),
 				       0,
@@ -1422,7 +1413,7 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 	/* concatenate work requests of rdma_rw_ctxs */
 	first_wr = NULL;
 	list_for_each_entry_reverse(msg, &msg_list, list) {
-		first_wr = rdma_rw_ctx_wrs(&msg->rw_ctx, sc->ib.qp, sc->ib.qp->port,
+		first_wr = rdma_rw_ctx_wrs(&msg->rdma_ctx, sc->ib.qp, sc->ib.qp->port,
 					   &msg->cqe, first_wr);
 	}
 
@@ -1432,9 +1423,9 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 		goto out;
 	}
 
-	msg = list_last_entry(&msg_list, struct smb_direct_rdma_rw_msg, list);
+	msg = list_last_entry(&msg_list, struct smbdirect_rw_io, list);
 	wait_for_completion(&completion);
-	ret = msg->status;
+	ret = msg->error;
 out:
 	list_for_each_entry_safe(msg, next_msg, &msg_list, list) {
 		list_del(&msg->list);
-- 
2.43.0

[PATCH v4 103/142] smb: server: take the recv_credit_target from the negotiate req and always limit the range

[Stefan Metzmacher]

The clients sends the initial recv_credit_target in the negotiate req,
so we should use that.

We also limit the range between 1 and our local defined
sp->recv_credit_max. This will simplify further logic changes.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 3a0244943dc7..6046ebdc1317 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -94,7 +94,7 @@ struct smb_direct_transport {
 
 	spinlock_t		receive_credit_lock;
 	int			recv_credits;
-	int			recv_credit_target;
+	u16			recv_credit_target;
 
 	spinlock_t		lock_new_recv_credits;
 	int			new_recv_credits;
@@ -472,9 +472,11 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	struct smbdirect_recv_io *recvmsg;
 	struct smb_direct_transport *t;
 	struct smbdirect_socket *sc;
+	struct smbdirect_socket_parameters *sp;
 
 	recvmsg = container_of(wc->wr_cqe, struct smbdirect_recv_io, cqe);
 	sc = recvmsg->socket;
+	sp = &sc->parameters;
 	t = container_of(sc, struct smb_direct_transport, socket);
 
 	if (wc->status != IB_WC_SUCCESS || wc->opcode != IB_WC_RECV) {
@@ -512,7 +514,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		struct smbdirect_data_transfer *data_transfer =
 			(struct smbdirect_data_transfer *)recvmsg->packet;
 		unsigned int data_length;
-		int old_recv_credit_target;
+		u16 old_recv_credit_target;
 
 		if (wc->byte_len <
 		    offsetof(struct smbdirect_data_transfer, padding)) {
@@ -546,6 +548,10 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		old_recv_credit_target = t->recv_credit_target;
 		t->recv_credit_target =
 				le16_to_cpu(data_transfer->credits_requested);
+		t->recv_credit_target =
+			min_t(u16, t->recv_credit_target, sp->recv_credit_max);
+		t->recv_credit_target =
+			max_t(u16, t->recv_credit_target, 1);
 		atomic_add(le16_to_cpu(data_transfer->credits_granted),
 			   &sc->send_io.credits.count);
 
@@ -1753,7 +1759,7 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	t->recv_credits = 0;
 
 	sp->recv_credit_max = smb_direct_receive_credit_max;
-	t->recv_credit_target = 10;
+	t->recv_credit_target = 1;
 	t->new_recv_credits = 0;
 
 	sp->send_credit_target = smb_direct_send_credit_target;
@@ -1979,6 +1985,9 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 		le32_to_cpu(req->max_fragmented_size);
 	sp->max_fragmented_recv_size =
 		(sp->recv_credit_max * sp->max_recv_size) / 2;
+	st->recv_credit_target = le16_to_cpu(req->credits_requested);
+	st->recv_credit_target = min_t(u16, st->recv_credit_target, sp->recv_credit_max);
+	st->recv_credit_target = max_t(u16, st->recv_credit_target, 1);
 
 	ret = smb_direct_send_negotiate_response(st, ret);
 out:
-- 
2.43.0

[PATCH v4 104/142] smb: server: manage recv credits by counting posted recv_io and granted credits

[Stefan Metzmacher]

(At least for me) the logic maintaining the count of posted
recv_io messages and the count of granted credits is much
easier to understand.

From there we can easily calculate the number of new_credits we'll
grant to the peer in outgoing send_io messages.

This will simplify the move to common logic that can be
shared between client and server in the following patches.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 53 ++++++++++++++--------------------
 1 file changed, 21 insertions(+), 32 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 6046ebdc1317..2bbf18e0906d 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -92,13 +92,10 @@ struct smb_direct_transport {
 
 	struct smbdirect_socket socket;
 
-	spinlock_t		receive_credit_lock;
-	int			recv_credits;
+	atomic_t		recv_credits;
 	u16			recv_credit_target;
 
-	spinlock_t		lock_new_recv_credits;
-	int			new_recv_credits;
-
+	atomic_t		recv_posted;
 	struct work_struct	post_recv_credits_work;
 	struct work_struct	send_immediate_work;
 
@@ -308,9 +305,8 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 
 	sc->ib.dev = sc->rdma.cm_id->device;
 
-	spin_lock_init(&t->receive_credit_lock);
-
-	spin_lock_init(&t->lock_new_recv_credits);
+	atomic_set(&t->recv_posted, 0);
+	atomic_set(&t->recv_credits, 0);
 
 	INIT_WORK(&t->post_recv_credits_work,
 		  smb_direct_post_recv_credits);
@@ -541,9 +537,8 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 				sc->recv_io.reassembly.full_packet_received = true;
 		}
 
-		spin_lock(&t->receive_credit_lock);
-		t->recv_credits -= 1;
-		spin_unlock(&t->receive_credit_lock);
+		atomic_dec(&t->recv_posted);
+		atomic_dec(&t->recv_credits);
 
 		old_recv_credit_target = t->recv_credit_target;
 		t->recv_credit_target =
@@ -747,14 +742,10 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
 	struct smb_direct_transport *t = container_of(work,
 		struct smb_direct_transport, post_recv_credits_work);
 	struct smbdirect_recv_io *recvmsg;
-	int receive_credits, credits = 0;
+	int credits = 0;
 	int ret;
 
-	spin_lock(&t->receive_credit_lock);
-	receive_credits = t->recv_credits;
-	spin_unlock(&t->receive_credit_lock);
-
-	if (receive_credits < t->recv_credit_target) {
+	if (atomic_read(&t->recv_credits) < t->recv_credit_target) {
 		while (true) {
 			recvmsg = get_free_recvmsg(t);
 			if (!recvmsg)
@@ -769,17 +760,11 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
 				break;
 			}
 			credits++;
+
+			atomic_inc(&t->recv_posted);
 		}
 	}
 
-	spin_lock(&t->receive_credit_lock);
-	t->recv_credits += credits;
-	spin_unlock(&t->receive_credit_lock);
-
-	spin_lock(&t->lock_new_recv_credits);
-	t->new_recv_credits += credits;
-	spin_unlock(&t->lock_new_recv_credits);
-
 	if (credits)
 		queue_work(smb_direct_wq, &t->send_immediate_work);
 }
@@ -826,11 +811,18 @@ static int manage_credits_prior_sending(struct smb_direct_transport *t)
 {
 	int new_credits;
 
-	spin_lock(&t->lock_new_recv_credits);
-	new_credits = t->new_recv_credits;
-	t->new_recv_credits = 0;
-	spin_unlock(&t->lock_new_recv_credits);
+	if (atomic_read(&t->recv_credits) >= t->recv_credit_target)
+		return 0;
+
+	new_credits = atomic_read(&t->recv_posted);
+	if (new_credits == 0)
+		return 0;
 
+	new_credits -= atomic_read(&t->recv_credits);
+	if (new_credits <= 0)
+		return 0;
+
+	atomic_add(new_credits, &t->recv_credits);
 	return new_credits;
 }
 
@@ -1756,11 +1748,8 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 		return -EINVAL;
 	}
 
-	t->recv_credits = 0;
-
 	sp->recv_credit_max = smb_direct_receive_credit_max;
 	t->recv_credit_target = 1;
-	t->new_recv_credits = 0;
 
 	sp->send_credit_target = smb_direct_send_credit_target;
 	atomic_set(&sc->rw_io.credits.count, sc->rw_io.credits.max);
-- 
2.43.0

[PATCH v4 105/142] smb: server: make use of smbdirect_socket.recv_io.{posted,credits}

[Stefan Metzmacher]

This will make it possible to introduce common helper functions
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 65 ++++++++++++++++------------------
 1 file changed, 30 insertions(+), 35 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 2bbf18e0906d..02300d14bc2f 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -92,11 +92,6 @@ struct smb_direct_transport {
 
 	struct smbdirect_socket socket;
 
-	atomic_t		recv_credits;
-	u16			recv_credit_target;
-
-	atomic_t		recv_posted;
-	struct work_struct	post_recv_credits_work;
 	struct work_struct	send_immediate_work;
 
 	bool			legacy_iwarp;
@@ -180,7 +175,7 @@ static void put_recvmsg(struct smb_direct_transport *t,
 	list_add(&recvmsg->list, &sc->recv_io.free.list);
 	spin_unlock(&sc->recv_io.free.lock);
 
-	queue_work(smb_direct_wq, &t->post_recv_credits_work);
+	queue_work(smb_direct_wq, &sc->recv_io.posted.refill_work);
 }
 
 static void enqueue_reassembly(struct smb_direct_transport *t,
@@ -227,7 +222,7 @@ static void smb_direct_disconnect_rdma_work(struct work_struct *work)
 	 * disable[_delayed]_work_sync()
 	 */
 	disable_work(&sc->disconnect_work);
-	disable_work(&t->post_recv_credits_work);
+	disable_work(&sc->recv_io.posted.refill_work);
 	disable_work(&t->send_immediate_work);
 
 	switch (sc->status) {
@@ -305,10 +300,7 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 
 	sc->ib.dev = sc->rdma.cm_id->device;
 
-	atomic_set(&t->recv_posted, 0);
-	atomic_set(&t->recv_credits, 0);
-
-	INIT_WORK(&t->post_recv_credits_work,
+	INIT_WORK(&sc->recv_io.posted.refill_work,
 		  smb_direct_post_recv_credits);
 	INIT_WORK(&t->send_immediate_work, smb_direct_send_immediate_work);
 
@@ -344,7 +336,7 @@ static void free_transport(struct smb_direct_transport *t)
 	wake_up_all(&sc->send_io.credits.wait_queue);
 	wake_up_all(&sc->send_io.pending.wait_queue);
 
-	disable_work_sync(&t->post_recv_credits_work);
+	disable_work_sync(&sc->recv_io.posted.refill_work);
 	disable_work_sync(&t->send_immediate_work);
 
 	if (sc->ib.qp) {
@@ -537,16 +529,16 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 				sc->recv_io.reassembly.full_packet_received = true;
 		}
 
-		atomic_dec(&t->recv_posted);
-		atomic_dec(&t->recv_credits);
+		atomic_dec(&sc->recv_io.posted.count);
+		atomic_dec(&sc->recv_io.credits.count);
 
-		old_recv_credit_target = t->recv_credit_target;
-		t->recv_credit_target =
+		old_recv_credit_target = sc->recv_io.credits.target;
+		sc->recv_io.credits.target =
 				le16_to_cpu(data_transfer->credits_requested);
-		t->recv_credit_target =
-			min_t(u16, t->recv_credit_target, sp->recv_credit_max);
-		t->recv_credit_target =
-			max_t(u16, t->recv_credit_target, 1);
+		sc->recv_io.credits.target =
+			min_t(u16, sc->recv_io.credits.target, sp->recv_credit_max);
+		sc->recv_io.credits.target =
+			max_t(u16, sc->recv_io.credits.target, 1);
 		atomic_add(le16_to_cpu(data_transfer->credits_granted),
 			   &sc->send_io.credits.count);
 
@@ -558,8 +550,8 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			wake_up(&sc->send_io.credits.wait_queue);
 
 		if (data_length) {
-			if (t->recv_credit_target > old_recv_credit_target)
-				queue_work(smb_direct_wq, &t->post_recv_credits_work);
+			if (sc->recv_io.credits.target > old_recv_credit_target)
+				queue_work(smb_direct_wq, &sc->recv_io.posted.refill_work);
 
 			enqueue_reassembly(t, recvmsg, (int)data_length);
 			wake_up(&sc->recv_io.reassembly.wait_queue);
@@ -739,13 +731,15 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 
 static void smb_direct_post_recv_credits(struct work_struct *work)
 {
-	struct smb_direct_transport *t = container_of(work,
-		struct smb_direct_transport, post_recv_credits_work);
+	struct smbdirect_socket *sc =
+		container_of(work, struct smbdirect_socket, recv_io.posted.refill_work);
+	struct smb_direct_transport *t =
+		container_of(sc, struct smb_direct_transport, socket);
 	struct smbdirect_recv_io *recvmsg;
 	int credits = 0;
 	int ret;
 
-	if (atomic_read(&t->recv_credits) < t->recv_credit_target) {
+	if (atomic_read(&sc->recv_io.credits.count) < sc->recv_io.credits.target) {
 		while (true) {
 			recvmsg = get_free_recvmsg(t);
 			if (!recvmsg)
@@ -761,7 +755,7 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
 			}
 			credits++;
 
-			atomic_inc(&t->recv_posted);
+			atomic_inc(&sc->recv_io.posted.count);
 		}
 	}
 
@@ -809,20 +803,21 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
 
 static int manage_credits_prior_sending(struct smb_direct_transport *t)
 {
+	struct smbdirect_socket *sc = &t->socket;
 	int new_credits;
 
-	if (atomic_read(&t->recv_credits) >= t->recv_credit_target)
+	if (atomic_read(&sc->recv_io.credits.count) >= sc->recv_io.credits.target)
 		return 0;
 
-	new_credits = atomic_read(&t->recv_posted);
+	new_credits = atomic_read(&sc->recv_io.posted.count);
 	if (new_credits == 0)
 		return 0;
 
-	new_credits -= atomic_read(&t->recv_credits);
+	new_credits -= atomic_read(&sc->recv_io.credits.count);
 	if (new_credits <= 0)
 		return 0;
 
-	atomic_add(new_credits, &t->recv_credits);
+	atomic_add(new_credits, &sc->recv_io.credits.count);
 	return new_credits;
 }
 
@@ -1666,7 +1661,7 @@ static int smb_direct_prepare_negotiation(struct smb_direct_transport *t)
 		goto out_err;
 	}
 
-	smb_direct_post_recv_credits(&t->post_recv_credits_work);
+	smb_direct_post_recv_credits(&sc->recv_io.posted.refill_work);
 	return 0;
 out_err:
 	put_recvmsg(t, recvmsg);
@@ -1749,7 +1744,7 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	}
 
 	sp->recv_credit_max = smb_direct_receive_credit_max;
-	t->recv_credit_target = 1;
+	sc->recv_io.credits.target = 1;
 
 	sp->send_credit_target = smb_direct_send_credit_target;
 	atomic_set(&sc->rw_io.credits.count, sc->rw_io.credits.max);
@@ -1974,9 +1969,9 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 		le32_to_cpu(req->max_fragmented_size);
 	sp->max_fragmented_recv_size =
 		(sp->recv_credit_max * sp->max_recv_size) / 2;
-	st->recv_credit_target = le16_to_cpu(req->credits_requested);
-	st->recv_credit_target = min_t(u16, st->recv_credit_target, sp->recv_credit_max);
-	st->recv_credit_target = max_t(u16, st->recv_credit_target, 1);
+	sc->recv_io.credits.target = le16_to_cpu(req->credits_requested);
+	sc->recv_io.credits.target = min_t(u16, sc->recv_io.credits.target, sp->recv_credit_max);
+	sc->recv_io.credits.target = max_t(u16, sc->recv_io.credits.target, 1);
 
 	ret = smb_direct_send_negotiate_response(st, ret);
 out:
-- 
2.43.0

[PATCH v4 106/142] smb: server: replace smb_trans_direct_transfort() with SMBD_TRANS()

[Stefan Metzmacher]

The spelling of smb_trans_direct_transfort was wrong anyway
and we don't need the logic twice.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 02300d14bc2f..133898b0cd08 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -129,12 +129,6 @@ static int smb_direct_post_send_data(struct smb_direct_transport *t,
 				     struct kvec *iov, int niov,
 				     int remaining_data_length);
 
-static inline struct smb_direct_transport *
-smb_trans_direct_transfort(struct ksmbd_transport *t)
-{
-	return container_of(t, struct smb_direct_transport, transport);
-}
-
 static inline void
 *smbdirect_recv_io_payload(struct smbdirect_recv_io *recvmsg)
 {
@@ -618,7 +612,7 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 	int to_copy, to_read, data_read, offset;
 	u32 data_length, remaining_data_length, data_offset;
 	int rc;
-	struct smb_direct_transport *st = smb_trans_direct_transfort(t);
+	struct smb_direct_transport *st = SMBD_TRANS(t);
 	struct smbdirect_socket *sc = &st->socket;
 
 again:
@@ -1164,7 +1158,7 @@ static int smb_direct_writev(struct ksmbd_transport *t,
 			     struct kvec *iov, int niovs, int buflen,
 			     bool need_invalidate, unsigned int remote_key)
 {
-	struct smb_direct_transport *st = smb_trans_direct_transfort(t);
+	struct smb_direct_transport *st = SMBD_TRANS(t);
 	struct smbdirect_socket *sc = &st->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	int remaining_data_length;
@@ -1435,7 +1429,7 @@ static int smb_direct_rdma_write(struct ksmbd_transport *t,
 				 struct smbdirect_buffer_descriptor_v1 *desc,
 				 unsigned int desc_len)
 {
-	return smb_direct_rdma_xmit(smb_trans_direct_transfort(t), buf, buflen,
+	return smb_direct_rdma_xmit(SMBD_TRANS(t), buf, buflen,
 				    desc, desc_len, false);
 }
 
@@ -1444,13 +1438,13 @@ static int smb_direct_rdma_read(struct ksmbd_transport *t,
 				struct smbdirect_buffer_descriptor_v1 *desc,
 				unsigned int desc_len)
 {
-	return smb_direct_rdma_xmit(smb_trans_direct_transfort(t), buf, buflen,
+	return smb_direct_rdma_xmit(SMBD_TRANS(t), buf, buflen,
 				    desc, desc_len, true);
 }
 
 static void smb_direct_disconnect(struct ksmbd_transport *t)
 {
-	struct smb_direct_transport *st = smb_trans_direct_transfort(t);
+	struct smb_direct_transport *st = SMBD_TRANS(t);
 	struct smbdirect_socket *sc = &st->socket;
 
 	ksmbd_debug(RDMA, "Disconnecting cm_id=%p\n", sc->rdma.cm_id);
@@ -1460,7 +1454,7 @@ static void smb_direct_disconnect(struct ksmbd_transport *t)
 
 static void smb_direct_shutdown(struct ksmbd_transport *t)
 {
-	struct smb_direct_transport *st = smb_trans_direct_transfort(t);
+	struct smb_direct_transport *st = SMBD_TRANS(t);
 	struct smbdirect_socket *sc = &st->socket;
 
 	ksmbd_debug(RDMA, "smb-direct shutdown cm_id=%p\n", sc->rdma.cm_id);
@@ -1924,7 +1918,7 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 
 static int smb_direct_prepare(struct ksmbd_transport *t)
 {
-	struct smb_direct_transport *st = smb_trans_direct_transfort(t);
+	struct smb_direct_transport *st = SMBD_TRANS(t);
 	struct smbdirect_socket *sc = &st->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct smbdirect_recv_io *recvmsg;
-- 
2.43.0

[PATCH v4 107/142] smb: server: remove useless casts from KSMBD_TRANS/SMBD_TRANS

[Stefan Metzmacher]

At best they gain nothing, at worst we procude real bugs.
Note container_of() already casts to a pointer of the
given type.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 133898b0cd08..09838efa12bd 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -99,8 +99,8 @@ struct smb_direct_transport {
 	u8			responder_resources;
 };
 
-#define KSMBD_TRANS(t) ((struct ksmbd_transport *)&((t)->transport))
-#define SMBD_TRANS(t)	((struct smb_direct_transport *)container_of(t, \
+#define KSMBD_TRANS(t) (&(t)->transport)
+#define SMBD_TRANS(t)	(container_of(t, \
 				struct smb_direct_transport, transport))
 
 static const struct ksmbd_transport_ops ksmbd_smb_direct_transport_ops;
-- 
2.43.0

[PATCH v4 108/142] smb: server: pass ksmbd_transport to get_smbd_max_read_write_size()

[Stefan Metzmacher]

We should use the per connection value.

And for TCP return NT_STATUS_INVALID_PARAMETER if any
SMB2_CHANNEL_RDMA_V1* is used.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/smb2pdu.c        | 12 ++++++++++--
 fs/smb/server/transport_rdma.c | 15 +++++++++++++--
 fs/smb/server/transport_rdma.h |  4 ++--
 3 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/fs/smb/server/smb2pdu.c b/fs/smb/server/smb2pdu.c
index a0ffd49d611a..8cc747a4c6c6 100644
--- a/fs/smb/server/smb2pdu.c
+++ b/fs/smb/server/smb2pdu.c
@@ -6759,7 +6759,11 @@ int smb2_read(struct ksmbd_work *work)
 	if (req->Channel == SMB2_CHANNEL_RDMA_V1_INVALIDATE ||
 	    req->Channel == SMB2_CHANNEL_RDMA_V1) {
 		is_rdma_channel = true;
-		max_read_size = get_smbd_max_read_write_size();
+		max_read_size = get_smbd_max_read_write_size(work->conn->transport);
+		if (max_read_size == 0) {
+			err = -EINVAL;
+			goto out;
+		}
 	}
 
 	if (is_rdma_channel == true) {
@@ -7017,7 +7021,11 @@ int smb2_write(struct ksmbd_work *work)
 	if (req->Channel == SMB2_CHANNEL_RDMA_V1 ||
 	    req->Channel == SMB2_CHANNEL_RDMA_V1_INVALIDATE) {
 		is_rdma_channel = true;
-		max_write_size = get_smbd_max_read_write_size();
+		max_write_size = get_smbd_max_read_write_size(work->conn->transport);
+		if (max_write_size == 0) {
+			err = -EINVAL;
+			goto out;
+		}
 		length = le32_to_cpu(req->RemainingBytes);
 	}
 
diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 09838efa12bd..b65215b4dd76 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -111,9 +111,20 @@ void init_smbd_max_io_size(unsigned int sz)
 	smb_direct_max_read_write_size = sz;
 }
 
-unsigned int get_smbd_max_read_write_size(void)
+unsigned int get_smbd_max_read_write_size(struct ksmbd_transport *kt)
 {
-	return smb_direct_max_read_write_size;
+	struct smb_direct_transport *t;
+	struct smbdirect_socket *sc;
+	struct smbdirect_socket_parameters *sp;
+
+	if (kt->ops != &ksmbd_smb_direct_transport_ops)
+		return 0;
+
+	t = SMBD_TRANS(kt);
+	sc = &t->socket;
+	sp = &sc->parameters;
+
+	return sp->max_read_write_size;
 }
 
 static inline int get_buf_page_count(void *buf, int size)
diff --git a/fs/smb/server/transport_rdma.h b/fs/smb/server/transport_rdma.h
index 63eab9f8f13d..3f93c6a9f7e4 100644
--- a/fs/smb/server/transport_rdma.h
+++ b/fs/smb/server/transport_rdma.h
@@ -17,14 +17,14 @@ void ksmbd_rdma_stop_listening(void);
 void ksmbd_rdma_destroy(void);
 bool ksmbd_rdma_capable_netdev(struct net_device *netdev);
 void init_smbd_max_io_size(unsigned int sz);
-unsigned int get_smbd_max_read_write_size(void);
+unsigned int get_smbd_max_read_write_size(struct ksmbd_transport *kt);
 #else
 static inline int ksmbd_rdma_init(void) { return 0; }
 static inline void ksmbd_rdma_stop_listening(void) { }
 static inline void ksmbd_rdma_destroy(void) { }
 static inline bool ksmbd_rdma_capable_netdev(struct net_device *netdev) { return false; }
 static inline void init_smbd_max_io_size(unsigned int sz) { }
-static inline unsigned int get_smbd_max_read_write_size(void) { return 0; }
+static inline unsigned int get_smbd_max_read_write_size(struct ksmbd_transport *kt) { return 0; }
 #endif
 
 #endif /* __KSMBD_TRANSPORT_RDMA_H__ */
-- 
2.43.0

[PATCH v4 109/142] smb: server: fill smbdirect_socket_parameters at the beginning and use the values from there

[Stefan Metzmacher]

This is what we should do and it also simplifies the following changes.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 29 +++++++++++++++--------------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index b65215b4dd76..dfafb4f2218e 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -287,6 +287,7 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 {
 	struct smb_direct_transport *t;
 	struct smbdirect_socket *sc;
+	struct smbdirect_socket_parameters *sp;
 	struct ksmbd_conn *conn;
 
 	t = kzalloc(sizeof(*t), KSMBD_DEFAULT_GFP);
@@ -294,9 +295,17 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 		return NULL;
 	sc = &t->socket;
 	smbdirect_socket_init(sc);
+	sp = &sc->parameters;
 
 	INIT_WORK(&sc->disconnect_work, smb_direct_disconnect_rdma_work);
 
+	sp->recv_credit_max = smb_direct_receive_credit_max;
+	sp->send_credit_target = smb_direct_send_credit_target;
+	sp->max_send_size = smb_direct_max_send_size;
+	sp->max_fragmented_recv_size = smb_direct_max_fragmented_recv_size;
+	sp->max_recv_size = smb_direct_max_receive_size;
+	sp->max_read_write_size = smb_direct_max_read_write_size;
+
 	sc->rdma.cm_id = cm_id;
 	cm_id->context = t;
 
@@ -1694,7 +1703,6 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	/* need 3 more sge. because a SMB_DIRECT header, SMB2 header,
 	 * SMB2 response could be mapped.
 	 */
-	sp->max_send_size = smb_direct_max_send_size;
 	max_send_sges = DIV_ROUND_UP(sp->max_send_size, PAGE_SIZE) + 3;
 	if (max_send_sges > SMBDIRECT_SEND_IO_MAX_SGE) {
 		pr_err("max_send_size %d is too large\n", sp->max_send_size);
@@ -1708,7 +1716,6 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	 * are needed for MR registration, RDMA R/W, local & remote
 	 * MR invalidation.
 	 */
-	sp->max_read_write_size = smb_direct_max_read_write_size;
 	sc->rw_io.credits.num_pages = smb_direct_get_max_fr_pages(t);
 	sc->rw_io.credits.max = DIV_ROUND_UP(sp->max_read_write_size,
 					 (sc->rw_io.credits.num_pages - 1) *
@@ -1723,20 +1730,20 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 					    max_sge_per_wr) + 1);
 	max_rw_wrs = sc->rw_io.credits.max * wrs_per_credit;
 
-	max_send_wrs = smb_direct_send_credit_target + max_rw_wrs;
+	max_send_wrs = sp->send_credit_target + max_rw_wrs;
 	if (max_send_wrs > device->attrs.max_cqe ||
 	    max_send_wrs > device->attrs.max_qp_wr) {
 		pr_err("consider lowering send_credit_target = %d\n",
-		       smb_direct_send_credit_target);
+		       sp->send_credit_target);
 		pr_err("Possible CQE overrun, device reporting max_cqe %d max_qp_wr %d\n",
 		       device->attrs.max_cqe, device->attrs.max_qp_wr);
 		return -EINVAL;
 	}
 
-	if (smb_direct_receive_credit_max > device->attrs.max_cqe ||
-	    smb_direct_receive_credit_max > device->attrs.max_qp_wr) {
+	if (sp->recv_credit_max > device->attrs.max_cqe ||
+	    sp->recv_credit_max > device->attrs.max_qp_wr) {
 		pr_err("consider lowering receive_credit_max = %d\n",
-		       smb_direct_receive_credit_max);
+		       sp->recv_credit_max);
 		pr_err("Possible CQE overrun, device reporting max_cpe %d max_qp_wr %d\n",
 		       device->attrs.max_cqe, device->attrs.max_qp_wr);
 		return -EINVAL;
@@ -1748,16 +1755,10 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 		return -EINVAL;
 	}
 
-	sp->recv_credit_max = smb_direct_receive_credit_max;
 	sc->recv_io.credits.target = 1;
 
-	sp->send_credit_target = smb_direct_send_credit_target;
 	atomic_set(&sc->rw_io.credits.count, sc->rw_io.credits.max);
 
-	sp->max_send_size = smb_direct_max_send_size;
-	sp->max_recv_size = smb_direct_max_receive_size;
-	sp->max_fragmented_recv_size = smb_direct_max_fragmented_recv_size;
-
 	cap->max_send_wr = max_send_wrs;
 	cap->max_recv_wr = sp->recv_credit_max;
 	cap->max_send_sge = max_sge_per_wr;
@@ -1857,7 +1858,7 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 	}
 
 	sc->ib.send_cq = ib_alloc_cq(sc->ib.dev, t,
-				 smb_direct_send_credit_target + cap->max_rdma_ctxs,
+				 sp->send_credit_target + cap->max_rdma_ctxs,
 				 0, IB_POLL_WORKQUEUE);
 	if (IS_ERR(sc->ib.send_cq)) {
 		pr_err("Can't create RDMA send CQ\n");
-- 
2.43.0

[PATCH v4 110/142] smb: server: make use of smbdirect_socket_parameters.negotiate_timeout_msec and change to 5s

[Stefan Metzmacher]

The server negotiations timer is just 5 seconds in Windows, so use the
same. See [MS-SMBD] 3.1.7.2 Connection Arrival.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index dfafb4f2218e..9bc8431821b6 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -33,8 +33,8 @@
 
 #define SMB_DIRECT_VERSION_LE		cpu_to_le16(SMBDIRECT_V1)
 
-/* SMB_DIRECT negotiation timeout in seconds */
-#define SMB_DIRECT_NEGOTIATE_TIMEOUT		120
+/* SMB_DIRECT negotiation timeout (for the server) in seconds */
+#define SMB_DIRECT_NEGOTIATE_TIMEOUT		5
 
 /*
  * Default maximum number of RDMA read/write outstanding on this connection
@@ -299,6 +299,7 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 
 	INIT_WORK(&sc->disconnect_work, smb_direct_disconnect_rdma_work);
 
+	sp->negotiate_timeout_msec = SMB_DIRECT_NEGOTIATE_TIMEOUT * 1000;
 	sp->recv_credit_max = smb_direct_receive_credit_max;
 	sp->send_credit_target = smb_direct_send_credit_target;
 	sp->max_send_size = smb_direct_max_send_size;
@@ -1954,7 +1955,7 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 					sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED &&
 					sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING &&
 					sc->status != SMBDIRECT_SOCKET_NEGOTIATE_NEEDED,
-					SMB_DIRECT_NEGOTIATE_TIMEOUT * HZ);
+					msecs_to_jiffies(sp->negotiate_timeout_msec));
 	if (ret <= 0 || sc->status != SMBDIRECT_SOCKET_NEGOTIATE_RUNNING)
 		return ret < 0 ? ret : -ETIMEDOUT;
 
-- 
2.43.0

[PATCH v4 111/142] smb: server: make use of smbdirect_socket_parameters.{initiator_depth,responder_resources}

[Stefan Metzmacher]

This will make it easier to specify these from the outside of the core
code first and then negotiate the value with the peer.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 9bc8431821b6..100ac189b47e 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -95,8 +95,6 @@ struct smb_direct_transport {
 	struct work_struct	send_immediate_work;
 
 	bool			legacy_iwarp;
-	u8			initiator_depth;
-	u8			responder_resources;
 };
 
 #define KSMBD_TRANS(t) (&(t)->transport)
@@ -300,6 +298,8 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 	INIT_WORK(&sc->disconnect_work, smb_direct_disconnect_rdma_work);
 
 	sp->negotiate_timeout_msec = SMB_DIRECT_NEGOTIATE_TIMEOUT * 1000;
+	sp->initiator_depth = SMB_DIRECT_CM_INITIATOR_DEPTH;
+	sp->responder_resources = 1;
 	sp->recv_credit_max = smb_direct_receive_credit_max;
 	sp->send_credit_target = smb_direct_send_credit_target;
 	sp->max_send_size = smb_direct_max_send_size;
@@ -310,9 +310,6 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 	sc->rdma.cm_id = cm_id;
 	cm_id->context = t;
 
-	t->initiator_depth = SMB_DIRECT_CM_INITIATOR_DEPTH;
-	t->responder_resources = 1;
-
 	sc->ib.dev = sc->rdma.cm_id->device;
 
 	INIT_WORK(&sc->recv_io.posted.refill_work,
@@ -1613,18 +1610,19 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 static int smb_direct_accept_client(struct smb_direct_transport *t)
 {
 	struct smbdirect_socket *sc = &t->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct rdma_conn_param conn_param;
 	__be32 ird_ord_hdr[2];
 	int ret;
 
 	/*
 	 * smb_direct_handle_connect_request()
-	 * already negotiated t->initiator_depth
-	 * and t->responder_resources
+	 * already negotiated sp->initiator_depth
+	 * and sp->responder_resources
 	 */
 	memset(&conn_param, 0, sizeof(conn_param));
-	conn_param.initiator_depth = t->initiator_depth;
-	conn_param.responder_resources = t->responder_resources;
+	conn_param.initiator_depth = sp->initiator_depth;
+	conn_param.responder_resources = sp->responder_resources;
 
 	if (t->legacy_iwarp) {
 		ird_ord_hdr[0] = cpu_to_be32(conn_param.responder_resources);
@@ -2035,6 +2033,8 @@ static int smb_direct_handle_connect_request(struct rdma_cm_id *new_cm_id,
 					     struct rdma_cm_event *event)
 {
 	struct smb_direct_transport *t;
+	struct smbdirect_socket *sc;
+	struct smbdirect_socket_parameters *sp;
 	struct task_struct *handler;
 	u8 peer_initiator_depth;
 	u8 peer_responder_resources;
@@ -2050,6 +2050,8 @@ static int smb_direct_handle_connect_request(struct rdma_cm_id *new_cm_id,
 	t = alloc_transport(new_cm_id);
 	if (!t)
 		return -ENOMEM;
+	sc = &t->socket;
+	sp = &sc->parameters;
 
 	peer_initiator_depth = event->param.conn.initiator_depth;
 	peer_responder_resources = event->param.conn.responder_resources;
@@ -2099,7 +2101,7 @@ static int smb_direct_handle_connect_request(struct rdma_cm_id *new_cm_id,
 	/*
 	 * First set what the we as server are able to support
 	 */
-	t->initiator_depth = min_t(u8, t->initiator_depth,
+	sp->initiator_depth = min_t(u8, sp->initiator_depth,
 				   new_cm_id->device->attrs.max_qp_rd_atom);
 
 	/*
@@ -2108,10 +2110,10 @@ static int smb_direct_handle_connect_request(struct rdma_cm_id *new_cm_id,
 	 * non 0 values.
 	 */
 	if (peer_initiator_depth != 0)
-		t->initiator_depth = min_t(u8, t->initiator_depth,
+		sp->initiator_depth = min_t(u8, sp->initiator_depth,
 					   peer_initiator_depth);
 	if (peer_responder_resources != 0)
-		t->responder_resources = min_t(u8, t->responder_resources,
+		sp->responder_resources = min_t(u8, sp->responder_resources,
 					       peer_responder_resources);
 
 	ret = smb_direct_connect(t);
-- 
2.43.0

[PATCH v4 112/142] smb: server: make use of smbdirect_socket.rdma.legacy_iwarp

[Stefan Metzmacher]

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 100ac189b47e..8e1df4eb39d6 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -93,8 +93,6 @@ struct smb_direct_transport {
 	struct smbdirect_socket socket;
 
 	struct work_struct	send_immediate_work;
-
-	bool			legacy_iwarp;
 };
 
 #define KSMBD_TRANS(t) (&(t)->transport)
@@ -1624,7 +1622,7 @@ static int smb_direct_accept_client(struct smb_direct_transport *t)
 	conn_param.initiator_depth = sp->initiator_depth;
 	conn_param.responder_resources = sp->responder_resources;
 
-	if (t->legacy_iwarp) {
+	if (sc->rdma.legacy_iwarp) {
 		ird_ord_hdr[0] = cpu_to_be32(conn_param.responder_resources);
 		ird_ord_hdr[1] = cpu_to_be32(conn_param.initiator_depth);
 		conn_param.private_data = ird_ord_hdr;
@@ -2092,7 +2090,7 @@ static int smb_direct_handle_connect_request(struct rdma_cm_id *new_cm_id,
 			ird32 = min_t(u32, ird32, U8_MAX);
 			ord32 = min_t(u32, ord32, U8_MAX);
 
-			t->legacy_iwarp = true;
+			sc->rdma.legacy_iwarp = true;
 			peer_initiator_depth = (u8)ird32;
 			peer_responder_resources = (u8)ord32;
 		}
-- 
2.43.0

[PATCH v4 113/142] smb: server: make use of smbdirect_socket.idle.immediate_work

[Stefan Metzmacher]

With this commit the server only uses struct smbdirect_socket!

It doesn't use the idle timer yet, but it will be added soon,
from there we'll be ready split common functions.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 8e1df4eb39d6..cca8e37a10ec 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -91,8 +91,6 @@ struct smb_direct_transport {
 	struct ksmbd_transport	transport;
 
 	struct smbdirect_socket socket;
-
-	struct work_struct	send_immediate_work;
 };
 
 #define KSMBD_TRANS(t) (&(t)->transport)
@@ -214,8 +212,6 @@ static void smb_direct_disconnect_rdma_work(struct work_struct *work)
 {
 	struct smbdirect_socket *sc =
 		container_of(work, struct smbdirect_socket, disconnect_work);
-	struct smb_direct_transport *t =
-		container_of(sc, struct smb_direct_transport, socket);
 
 	/*
 	 * make sure this and other work is not queued again
@@ -224,7 +220,7 @@ static void smb_direct_disconnect_rdma_work(struct work_struct *work)
 	 */
 	disable_work(&sc->disconnect_work);
 	disable_work(&sc->recv_io.posted.refill_work);
-	disable_work(&t->send_immediate_work);
+	disable_work(&sc->idle.immediate_work);
 
 	switch (sc->status) {
 	case SMBDIRECT_SOCKET_NEGOTIATE_NEEDED:
@@ -269,9 +265,10 @@ smb_direct_disconnect_rdma_connection(struct smb_direct_transport *t)
 
 static void smb_direct_send_immediate_work(struct work_struct *work)
 {
-	struct smb_direct_transport *t = container_of(work,
-			struct smb_direct_transport, send_immediate_work);
-	struct smbdirect_socket *sc = &t->socket;
+	struct smbdirect_socket *sc =
+		container_of(work, struct smbdirect_socket, idle.immediate_work);
+	struct smb_direct_transport *t =
+		container_of(sc, struct smb_direct_transport, socket);
 
 	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
 		return;
@@ -312,7 +309,7 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 
 	INIT_WORK(&sc->recv_io.posted.refill_work,
 		  smb_direct_post_recv_credits);
-	INIT_WORK(&t->send_immediate_work, smb_direct_send_immediate_work);
+	INIT_WORK(&sc->idle.immediate_work, smb_direct_send_immediate_work);
 
 	conn = ksmbd_conn_alloc();
 	if (!conn)
@@ -347,7 +344,7 @@ static void free_transport(struct smb_direct_transport *t)
 	wake_up_all(&sc->send_io.pending.wait_queue);
 
 	disable_work_sync(&sc->recv_io.posted.refill_work);
-	disable_work_sync(&t->send_immediate_work);
+	disable_work_sync(&sc->idle.immediate_work);
 
 	if (sc->ib.qp) {
 		ib_drain_qp(sc->ib.qp);
@@ -554,7 +551,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 
 		if (le16_to_cpu(data_transfer->flags) &
 		    SMBDIRECT_FLAG_RESPONSE_REQUESTED)
-			queue_work(smb_direct_wq, &t->send_immediate_work);
+			queue_work(smb_direct_wq, &sc->idle.immediate_work);
 
 		if (atomic_read(&sc->send_io.credits.count) > 0)
 			wake_up(&sc->send_io.credits.wait_queue);
@@ -770,7 +767,7 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
 	}
 
 	if (credits)
-		queue_work(smb_direct_wq, &t->send_immediate_work);
+		queue_work(smb_direct_wq, &sc->idle.immediate_work);
 }
 
 static void send_done(struct ib_cq *cq, struct ib_wc *wc)
-- 
2.43.0

[PATCH v4 114/142] smb: server: implement correct keepalive and timeout handling for smbdirect

[Stefan Metzmacher]

Now client and server behave in the same way and we can start to
share common functions.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 74 ++++++++++++++++++++++++++++++++++
 1 file changed, 74 insertions(+)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index cca8e37a10ec..fb007963e281 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -36,6 +36,12 @@
 /* SMB_DIRECT negotiation timeout (for the server) in seconds */
 #define SMB_DIRECT_NEGOTIATE_TIMEOUT		5
 
+/* The timeout to wait for a keepalive message from peer in seconds */
+#define SMB_DIRECT_KEEPALIVE_SEND_INTERVAL	120
+
+/* The timeout to wait for a keepalive message from peer in seconds */
+#define SMB_DIRECT_KEEPALIVE_RECV_TIMEOUT	5
+
 /*
  * Default maximum number of RDMA read/write outstanding on this connection
  * This value is possibly decreased during QP creation on hardware limit
@@ -220,6 +226,7 @@ static void smb_direct_disconnect_rdma_work(struct work_struct *work)
 	 */
 	disable_work(&sc->disconnect_work);
 	disable_work(&sc->recv_io.posted.refill_work);
+	disable_delayed_work(&sc->idle.timer_work);
 	disable_work(&sc->idle.immediate_work);
 
 	switch (sc->status) {
@@ -276,6 +283,32 @@ static void smb_direct_send_immediate_work(struct work_struct *work)
 	smb_direct_post_send_data(t, NULL, NULL, 0, 0);
 }
 
+static void smb_direct_idle_connection_timer(struct work_struct *work)
+{
+	struct smbdirect_socket *sc =
+		container_of(work, struct smbdirect_socket, idle.timer_work.work);
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
+	struct smb_direct_transport *t =
+		container_of(sc, struct smb_direct_transport, socket);
+
+	if (sc->idle.keepalive != SMBDIRECT_KEEPALIVE_NONE) {
+		smb_direct_disconnect_rdma_connection(t);
+		return;
+	}
+
+	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
+		return;
+
+	/*
+	 * Now use the keepalive timeout (instead of keepalive interval)
+	 * in order to wait for a response
+	 */
+	sc->idle.keepalive = SMBDIRECT_KEEPALIVE_PENDING;
+	mod_delayed_work(smb_direct_wq, &sc->idle.timer_work,
+			 msecs_to_jiffies(sp->keepalive_timeout_msec));
+	queue_work(smb_direct_wq, &sc->idle.immediate_work);
+}
+
 static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 {
 	struct smb_direct_transport *t;
@@ -301,6 +334,8 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 	sp->max_fragmented_recv_size = smb_direct_max_fragmented_recv_size;
 	sp->max_recv_size = smb_direct_max_receive_size;
 	sp->max_read_write_size = smb_direct_max_read_write_size;
+	sp->keepalive_interval_msec = SMB_DIRECT_KEEPALIVE_SEND_INTERVAL * 1000;
+	sp->keepalive_timeout_msec = SMB_DIRECT_KEEPALIVE_RECV_TIMEOUT * 1000;
 
 	sc->rdma.cm_id = cm_id;
 	cm_id->context = t;
@@ -310,6 +345,7 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 	INIT_WORK(&sc->recv_io.posted.refill_work,
 		  smb_direct_post_recv_credits);
 	INIT_WORK(&sc->idle.immediate_work, smb_direct_send_immediate_work);
+	INIT_DELAYED_WORK(&sc->idle.timer_work, smb_direct_idle_connection_timer);
 
 	conn = ksmbd_conn_alloc();
 	if (!conn)
@@ -344,6 +380,7 @@ static void free_transport(struct smb_direct_transport *t)
 	wake_up_all(&sc->send_io.pending.wait_queue);
 
 	disable_work_sync(&sc->recv_io.posted.refill_work);
+	disable_delayed_work_sync(&sc->idle.timer_work);
 	disable_work_sync(&sc->idle.immediate_work);
 
 	if (sc->ib.qp) {
@@ -492,6 +529,14 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	ib_dma_sync_single_for_cpu(wc->qp->device, recvmsg->sge.addr,
 				   recvmsg->sge.length, DMA_FROM_DEVICE);
 
+	/*
+	 * Reset timer to the keepalive interval in
+	 * order to trigger our next keepalive message.
+	 */
+	sc->idle.keepalive = SMBDIRECT_KEEPALIVE_NONE;
+	mod_delayed_work(smb_direct_wq, &sc->idle.timer_work,
+			 msecs_to_jiffies(sp->keepalive_interval_msec));
+
 	switch (sc->recv_io.expected) {
 	case SMBDIRECT_EXPECT_NEGOTIATE_REQ:
 		if (wc->byte_len < sizeof(struct smbdirect_negotiate_req)) {
@@ -828,6 +873,24 @@ static int manage_credits_prior_sending(struct smb_direct_transport *t)
 	return new_credits;
 }
 
+static int manage_keep_alive_before_sending(struct smb_direct_transport *t)
+{
+	struct smbdirect_socket *sc = &t->socket;
+	struct smbdirect_socket_parameters *sp = &sc->parameters;
+
+	if (sc->idle.keepalive == SMBDIRECT_KEEPALIVE_PENDING) {
+		sc->idle.keepalive = SMBDIRECT_KEEPALIVE_SENT;
+		/*
+		 * Now use the keepalive timeout (instead of keepalive interval)
+		 * in order to wait for a response
+		 */
+		mod_delayed_work(smb_direct_wq, &sc->idle.timer_work,
+				 msecs_to_jiffies(sp->keepalive_timeout_msec));
+		return 1;
+	}
+	return 0;
+}
+
 static int smb_direct_post_send(struct smb_direct_transport *t,
 				struct ib_send_wr *wr)
 {
@@ -976,6 +1039,9 @@ static int smb_direct_create_header(struct smb_direct_transport *t,
 	packet->credits_granted = cpu_to_le16(manage_credits_prior_sending(t));
 
 	packet->flags = 0;
+	if (manage_keep_alive_before_sending(t))
+		packet->flags |= cpu_to_le16(SMBDIRECT_FLAG_RESPONSE_REQUESTED);
+
 	packet->reserved = 0;
 	if (!size)
 		packet->data_offset = 0;
@@ -1632,6 +1698,14 @@ static int smb_direct_accept_client(struct smb_direct_transport *t)
 	conn_param.rnr_retry_count = SMB_DIRECT_CM_RNR_RETRY;
 	conn_param.flow_control = 0;
 
+	/*
+	 * start with the negotiate timeout and SMBDIRECT_KEEPALIVE_PENDING
+	 * so that the timer will cause a disconnect.
+	 */
+	sc->idle.keepalive = SMBDIRECT_KEEPALIVE_PENDING;
+	mod_delayed_work(smb_direct_wq, &sc->idle.timer_work,
+			 msecs_to_jiffies(sp->negotiate_timeout_msec));
+
 	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED);
 	sc->status = SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING;
 	ret = rdma_accept(sc->rdma.cm_id, &conn_param);
-- 
2.43.0

[PATCH v4 115/142] smb: server: make use of smbdirect_socket.workqueue

[Stefan Metzmacher]

We still use the single global workqueue, but this
will allow us to share common code soon.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index fb007963e281..9c2f0edab604 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -180,7 +180,7 @@ static void put_recvmsg(struct smb_direct_transport *t,
 	list_add(&recvmsg->list, &sc->recv_io.free.list);
 	spin_unlock(&sc->recv_io.free.lock);
 
-	queue_work(smb_direct_wq, &sc->recv_io.posted.refill_work);
+	queue_work(sc->workqueue, &sc->recv_io.posted.refill_work);
 }
 
 static void enqueue_reassembly(struct smb_direct_transport *t,
@@ -267,7 +267,7 @@ smb_direct_disconnect_rdma_connection(struct smb_direct_transport *t)
 {
 	struct smbdirect_socket *sc = &t->socket;
 
-	queue_work(smb_direct_wq, &sc->disconnect_work);
+	queue_work(sc->workqueue, &sc->disconnect_work);
 }
 
 static void smb_direct_send_immediate_work(struct work_struct *work)
@@ -304,9 +304,9 @@ static void smb_direct_idle_connection_timer(struct work_struct *work)
 	 * in order to wait for a response
 	 */
 	sc->idle.keepalive = SMBDIRECT_KEEPALIVE_PENDING;
-	mod_delayed_work(smb_direct_wq, &sc->idle.timer_work,
+	mod_delayed_work(sc->workqueue, &sc->idle.timer_work,
 			 msecs_to_jiffies(sp->keepalive_timeout_msec));
-	queue_work(smb_direct_wq, &sc->idle.immediate_work);
+	queue_work(sc->workqueue, &sc->idle.immediate_work);
 }
 
 static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
@@ -323,6 +323,8 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 	smbdirect_socket_init(sc);
 	sp = &sc->parameters;
 
+	sc->workqueue = smb_direct_wq;
+
 	INIT_WORK(&sc->disconnect_work, smb_direct_disconnect_rdma_work);
 
 	sp->negotiate_timeout_msec = SMB_DIRECT_NEGOTIATE_TIMEOUT * 1000;
@@ -534,7 +536,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	 * order to trigger our next keepalive message.
 	 */
 	sc->idle.keepalive = SMBDIRECT_KEEPALIVE_NONE;
-	mod_delayed_work(smb_direct_wq, &sc->idle.timer_work,
+	mod_delayed_work(sc->workqueue, &sc->idle.timer_work,
 			 msecs_to_jiffies(sp->keepalive_interval_msec));
 
 	switch (sc->recv_io.expected) {
@@ -596,14 +598,14 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 
 		if (le16_to_cpu(data_transfer->flags) &
 		    SMBDIRECT_FLAG_RESPONSE_REQUESTED)
-			queue_work(smb_direct_wq, &sc->idle.immediate_work);
+			queue_work(sc->workqueue, &sc->idle.immediate_work);
 
 		if (atomic_read(&sc->send_io.credits.count) > 0)
 			wake_up(&sc->send_io.credits.wait_queue);
 
 		if (data_length) {
 			if (sc->recv_io.credits.target > old_recv_credit_target)
-				queue_work(smb_direct_wq, &sc->recv_io.posted.refill_work);
+				queue_work(sc->workqueue, &sc->recv_io.posted.refill_work);
 
 			enqueue_reassembly(t, recvmsg, (int)data_length);
 			wake_up(&sc->recv_io.reassembly.wait_queue);
@@ -812,7 +814,7 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
 	}
 
 	if (credits)
-		queue_work(smb_direct_wq, &sc->idle.immediate_work);
+		queue_work(sc->workqueue, &sc->idle.immediate_work);
 }
 
 static void send_done(struct ib_cq *cq, struct ib_wc *wc)
@@ -884,7 +886,7 @@ static int manage_keep_alive_before_sending(struct smb_direct_transport *t)
 		 * Now use the keepalive timeout (instead of keepalive interval)
 		 * in order to wait for a response
 		 */
-		mod_delayed_work(smb_direct_wq, &sc->idle.timer_work,
+		mod_delayed_work(sc->workqueue, &sc->idle.timer_work,
 				 msecs_to_jiffies(sp->keepalive_timeout_msec));
 		return 1;
 	}
@@ -1703,7 +1705,7 @@ static int smb_direct_accept_client(struct smb_direct_transport *t)
 	 * so that the timer will cause a disconnect.
 	 */
 	sc->idle.keepalive = SMBDIRECT_KEEPALIVE_PENDING;
-	mod_delayed_work(smb_direct_wq, &sc->idle.timer_work,
+	mod_delayed_work(sc->workqueue, &sc->idle.timer_work,
 			 msecs_to_jiffies(sp->negotiate_timeout_msec));
 
 	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED);
-- 
2.43.0

[PATCH v4 116/142] smb: server: pass struct smbdirect_socket to {get_free,put}_recvmsg()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 35 ++++++++++++++++------------------
 1 file changed, 16 insertions(+), 19 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 9c2f0edab604..a998f6c04aab 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -147,9 +147,8 @@ static inline void
 }
 
 static struct
-smbdirect_recv_io *get_free_recvmsg(struct smb_direct_transport *t)
+smbdirect_recv_io *get_free_recvmsg(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_recv_io *recvmsg = NULL;
 
 	spin_lock(&sc->recv_io.free.lock);
@@ -163,11 +162,9 @@ smbdirect_recv_io *get_free_recvmsg(struct smb_direct_transport *t)
 	return recvmsg;
 }
 
-static void put_recvmsg(struct smb_direct_transport *t,
+static void put_recvmsg(struct smbdirect_socket *sc,
 			struct smbdirect_recv_io *recvmsg)
 {
-	struct smbdirect_socket *sc = &t->socket;
-
 	if (likely(recvmsg->sge.length != 0)) {
 		ib_dma_unmap_single(sc->ib.dev,
 				    recvmsg->sge.addr,
@@ -399,7 +396,7 @@ static void free_transport(struct smb_direct_transport *t)
 		if (recvmsg) {
 			list_del(&recvmsg->list);
 			spin_unlock(&sc->recv_io.reassembly.lock);
-			put_recvmsg(t, recvmsg);
+			put_recvmsg(sc, recvmsg);
 		} else {
 			spin_unlock(&sc->recv_io.reassembly.lock);
 		}
@@ -514,7 +511,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	t = container_of(sc, struct smb_direct_transport, socket);
 
 	if (wc->status != IB_WC_SUCCESS || wc->opcode != IB_WC_RECV) {
-		put_recvmsg(t, recvmsg);
+		put_recvmsg(sc, recvmsg);
 		if (wc->status != IB_WC_WR_FLUSH_ERR) {
 			pr_err("Recv error. status='%s (%d)' opcode=%d\n",
 			       ib_wc_status_msg(wc->status), wc->status,
@@ -542,7 +539,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	switch (sc->recv_io.expected) {
 	case SMBDIRECT_EXPECT_NEGOTIATE_REQ:
 		if (wc->byte_len < sizeof(struct smbdirect_negotiate_req)) {
-			put_recvmsg(t, recvmsg);
+			put_recvmsg(sc, recvmsg);
 			smb_direct_disconnect_rdma_connection(t);
 			return;
 		}
@@ -560,7 +557,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 
 		if (wc->byte_len <
 		    offsetof(struct smbdirect_data_transfer, padding)) {
-			put_recvmsg(t, recvmsg);
+			put_recvmsg(sc, recvmsg);
 			smb_direct_disconnect_rdma_connection(t);
 			return;
 		}
@@ -569,7 +566,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		if (data_length) {
 			if (wc->byte_len < sizeof(struct smbdirect_data_transfer) +
 			    (u64)data_length) {
-				put_recvmsg(t, recvmsg);
+				put_recvmsg(sc, recvmsg);
 				smb_direct_disconnect_rdma_connection(t);
 				return;
 			}
@@ -610,7 +607,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			enqueue_reassembly(t, recvmsg, (int)data_length);
 			wake_up(&sc->recv_io.reassembly.wait_queue);
 		} else
-			put_recvmsg(t, recvmsg);
+			put_recvmsg(sc, recvmsg);
 
 		return;
 	}
@@ -623,7 +620,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	 * This is an internal error!
 	 */
 	WARN_ON_ONCE(sc->recv_io.expected != SMBDIRECT_EXPECT_DATA_TRANSFER);
-	put_recvmsg(t, recvmsg);
+	put_recvmsg(sc, recvmsg);
 	smb_direct_disconnect_rdma_connection(t);
 }
 
@@ -749,7 +746,7 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 					spin_unlock_irq(&sc->recv_io.reassembly.lock);
 				}
 				queue_removed++;
-				put_recvmsg(st, recvmsg);
+				put_recvmsg(sc, recvmsg);
 				offset = 0;
 			} else {
 				offset += to_copy;
@@ -795,7 +792,7 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
 
 	if (atomic_read(&sc->recv_io.credits.count) < sc->recv_io.credits.target) {
 		while (true) {
-			recvmsg = get_free_recvmsg(t);
+			recvmsg = get_free_recvmsg(sc);
 			if (!recvmsg)
 				break;
 
@@ -804,7 +801,7 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
 			ret = smb_direct_post_recv(t, recvmsg);
 			if (ret) {
 				pr_err("Can't post recv: %d\n", ret);
-				put_recvmsg(t, recvmsg);
+				put_recvmsg(sc, recvmsg);
 				break;
 			}
 			credits++;
@@ -1729,7 +1726,7 @@ static int smb_direct_prepare_negotiation(struct smb_direct_transport *t)
 
 	sc->recv_io.expected = SMBDIRECT_EXPECT_NEGOTIATE_REQ;
 
-	recvmsg = get_free_recvmsg(t);
+	recvmsg = get_free_recvmsg(sc);
 	if (!recvmsg)
 		return -ENOMEM;
 
@@ -1748,7 +1745,7 @@ static int smb_direct_prepare_negotiation(struct smb_direct_transport *t)
 	smb_direct_post_recv_credits(&sc->recv_io.posted.refill_work);
 	return 0;
 out_err:
-	put_recvmsg(t, recvmsg);
+	put_recvmsg(sc, recvmsg);
 	return ret;
 }
 
@@ -1843,7 +1840,7 @@ static void smb_direct_destroy_pools(struct smb_direct_transport *t)
 	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_recv_io *recvmsg;
 
-	while ((recvmsg = get_free_recvmsg(t)))
+	while ((recvmsg = get_free_recvmsg(sc)))
 		mempool_free(recvmsg, sc->recv_io.mem.pool);
 
 	mempool_destroy(sc->recv_io.mem.pool);
@@ -2055,7 +2052,7 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 	sc->recv_io.reassembly.queue_length--;
 	list_del(&recvmsg->list);
 	spin_unlock_irq(&sc->recv_io.reassembly.lock);
-	put_recvmsg(st, recvmsg);
+	put_recvmsg(sc, recvmsg);
 
 	return ret;
 }
-- 
2.43.0

[PATCH v4 117/142] smb: server: pass struct smbdirect_socket to smb_direct_{create,destroy}_pools()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index a998f6c04aab..1aabd617c6ec 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -133,7 +133,7 @@ static inline int get_buf_page_count(void *buf, int size)
 		(uintptr_t)buf / PAGE_SIZE;
 }
 
-static void smb_direct_destroy_pools(struct smb_direct_transport *transport);
+static void smb_direct_destroy_pools(struct smbdirect_socket *sc);
 static void smb_direct_post_recv_credits(struct work_struct *work);
 static int smb_direct_post_send_data(struct smb_direct_transport *t,
 				     struct smbdirect_send_batch *send_ctx,
@@ -412,7 +412,7 @@ static void free_transport(struct smb_direct_transport *t)
 	if (sc->rdma.cm_id)
 		rdma_destroy_id(sc->rdma.cm_id);
 
-	smb_direct_destroy_pools(t);
+	smb_direct_destroy_pools(sc);
 	ksmbd_conn_free(KSMBD_TRANS(t)->conn);
 }
 
@@ -1835,9 +1835,8 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	return 0;
 }
 
-static void smb_direct_destroy_pools(struct smb_direct_transport *t)
+static void smb_direct_destroy_pools(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_recv_io *recvmsg;
 
 	while ((recvmsg = get_free_recvmsg(sc)))
@@ -1856,15 +1855,14 @@ static void smb_direct_destroy_pools(struct smb_direct_transport *t)
 	sc->send_io.mem.cache = NULL;
 }
 
-static int smb_direct_create_pools(struct smb_direct_transport *t)
+static int smb_direct_create_pools(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	char name[80];
 	int i;
 	struct smbdirect_recv_io *recvmsg;
 
-	snprintf(name, sizeof(name), "smbdirect_send_io_pool_%p", t);
+	snprintf(name, sizeof(name), "smbdirect_send_io_pool_%p", sc);
 	sc->send_io.mem.cache = kmem_cache_create(name,
 					     sizeof(struct smbdirect_send_io) +
 					      sizeof(struct smbdirect_negotiate_resp),
@@ -1878,7 +1876,7 @@ static int smb_direct_create_pools(struct smb_direct_transport *t)
 	if (!sc->send_io.mem.pool)
 		goto err;
 
-	snprintf(name, sizeof(name), "smbdirect_recv_io_pool_%p", t);
+	snprintf(name, sizeof(name), "smbdirect_recv_io_pool_%p", sc);
 	sc->recv_io.mem.cache = kmem_cache_create(name,
 					     sizeof(struct smbdirect_recv_io) +
 					     sp->max_recv_size,
@@ -1903,7 +1901,7 @@ static int smb_direct_create_pools(struct smb_direct_transport *t)
 
 	return 0;
 err:
-	smb_direct_destroy_pools(t);
+	smb_direct_destroy_pools(sc);
 	return -ENOMEM;
 }
 
@@ -2059,6 +2057,7 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 
 static int smb_direct_connect(struct smb_direct_transport *st)
 {
+	struct smbdirect_socket *sc = &st->socket;
 	int ret;
 	struct ib_qp_cap qp_cap;
 
@@ -2068,7 +2067,7 @@ static int smb_direct_connect(struct smb_direct_transport *st)
 		return ret;
 	}
 
-	ret = smb_direct_create_pools(st);
+	ret = smb_direct_create_pools(sc);
 	if (ret) {
 		pr_err("Can't init RDMA pool: %d\n", ret);
 		return ret;
-- 
2.43.0

[PATCH v4 118/142] smb: server: pass struct smbdirect_socket to smb_direct_get_max_fr_pages()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 1aabd617c6ec..08f0128c804c 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -1749,10 +1749,8 @@ static int smb_direct_prepare_negotiation(struct smb_direct_transport *t)
 	return ret;
 }
 
-static unsigned int smb_direct_get_max_fr_pages(struct smb_direct_transport *t)
+static unsigned int smb_direct_get_max_fr_pages(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &t->socket;
-
 	return min_t(unsigned int,
 		     sc->ib.dev->attrs.max_fast_reg_page_list_len,
 		     256);
@@ -1783,7 +1781,7 @@ static int smb_direct_init_params(struct smb_direct_transport *t,
 	 * are needed for MR registration, RDMA R/W, local & remote
 	 * MR invalidation.
 	 */
-	sc->rw_io.credits.num_pages = smb_direct_get_max_fr_pages(t);
+	sc->rw_io.credits.num_pages = smb_direct_get_max_fr_pages(sc);
 	sc->rw_io.credits.max = DIV_ROUND_UP(sp->max_read_write_size,
 					 (sc->rw_io.credits.num_pages - 1) *
 					 PAGE_SIZE);
-- 
2.43.0

[PATCH v4 119/142] smb: server: pass struct smbdirect_socket to smb_direct_init_params()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 08f0128c804c..64af3e3b373a 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -1756,10 +1756,9 @@ static unsigned int smb_direct_get_max_fr_pages(struct smbdirect_socket *sc)
 		     256);
 }
 
-static int smb_direct_init_params(struct smb_direct_transport *t,
+static int smb_direct_init_params(struct smbdirect_socket *sc,
 				  struct ib_qp_cap *cap)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct ib_device *device = sc->ib.dev;
 	int max_send_sges, max_rw_wrs, max_send_wrs;
@@ -2059,7 +2058,7 @@ static int smb_direct_connect(struct smb_direct_transport *st)
 	int ret;
 	struct ib_qp_cap qp_cap;
 
-	ret = smb_direct_init_params(st, &qp_cap);
+	ret = smb_direct_init_params(sc, &qp_cap);
 	if (ret) {
 		pr_err("Can't configure RDMA parameters\n");
 		return ret;
-- 
2.43.0

[PATCH v4 120/142] smb: server: pass struct smbdirect_socket to smb_direct_disconnect_rdma_connection()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 30 ++++++++++++------------------
 1 file changed, 12 insertions(+), 18 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 64af3e3b373a..8b6de0a6bf9d 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -260,10 +260,8 @@ static void smb_direct_disconnect_rdma_work(struct work_struct *work)
 }
 
 static void
-smb_direct_disconnect_rdma_connection(struct smb_direct_transport *t)
+smb_direct_disconnect_rdma_connection(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &t->socket;
-
 	queue_work(sc->workqueue, &sc->disconnect_work);
 }
 
@@ -285,11 +283,9 @@ static void smb_direct_idle_connection_timer(struct work_struct *work)
 	struct smbdirect_socket *sc =
 		container_of(work, struct smbdirect_socket, idle.timer_work.work);
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
-	struct smb_direct_transport *t =
-		container_of(sc, struct smb_direct_transport, socket);
 
 	if (sc->idle.keepalive != SMBDIRECT_KEEPALIVE_NONE) {
-		smb_direct_disconnect_rdma_connection(t);
+		smb_direct_disconnect_rdma_connection(sc);
 		return;
 	}
 
@@ -516,7 +512,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			pr_err("Recv error. status='%s (%d)' opcode=%d\n",
 			       ib_wc_status_msg(wc->status), wc->status,
 			       wc->opcode);
-			smb_direct_disconnect_rdma_connection(t);
+			smb_direct_disconnect_rdma_connection(sc);
 		}
 		return;
 	}
@@ -540,7 +536,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	case SMBDIRECT_EXPECT_NEGOTIATE_REQ:
 		if (wc->byte_len < sizeof(struct smbdirect_negotiate_req)) {
 			put_recvmsg(sc, recvmsg);
-			smb_direct_disconnect_rdma_connection(t);
+			smb_direct_disconnect_rdma_connection(sc);
 			return;
 		}
 		sc->recv_io.reassembly.full_packet_received = true;
@@ -558,7 +554,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		if (wc->byte_len <
 		    offsetof(struct smbdirect_data_transfer, padding)) {
 			put_recvmsg(sc, recvmsg);
-			smb_direct_disconnect_rdma_connection(t);
+			smb_direct_disconnect_rdma_connection(sc);
 			return;
 		}
 
@@ -567,7 +563,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			if (wc->byte_len < sizeof(struct smbdirect_data_transfer) +
 			    (u64)data_length) {
 				put_recvmsg(sc, recvmsg);
-				smb_direct_disconnect_rdma_connection(t);
+				smb_direct_disconnect_rdma_connection(sc);
 				return;
 			}
 
@@ -621,7 +617,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	 */
 	WARN_ON_ONCE(sc->recv_io.expected != SMBDIRECT_EXPECT_DATA_TRANSFER);
 	put_recvmsg(sc, recvmsg);
-	smb_direct_disconnect_rdma_connection(t);
+	smb_direct_disconnect_rdma_connection(sc);
 }
 
 static int smb_direct_post_recv(struct smb_direct_transport *t,
@@ -655,7 +651,7 @@ static int smb_direct_post_recv(struct smb_direct_transport *t,
 				    recvmsg->sge.addr, recvmsg->sge.length,
 				    DMA_FROM_DEVICE);
 		recvmsg->sge.length = 0;
-		smb_direct_disconnect_rdma_connection(t);
+		smb_direct_disconnect_rdma_connection(sc);
 		return ret;
 	}
 	return ret;
@@ -833,7 +829,7 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
 		pr_err("Send error. status='%s (%d)', opcode=%d\n",
 		       ib_wc_status_msg(wc->status), wc->status,
 		       wc->opcode);
-		smb_direct_disconnect_rdma_connection(t);
+		smb_direct_disconnect_rdma_connection(sc);
 	}
 
 	if (atomic_dec_and_test(&sc->send_io.pending.count))
@@ -902,7 +898,7 @@ static int smb_direct_post_send(struct smb_direct_transport *t,
 		pr_err("failed to post send: %d\n", ret);
 		if (atomic_dec_and_test(&sc->send_io.pending.count))
 			wake_up(&sc->send_io.pending.wait_queue);
-		smb_direct_disconnect_rdma_connection(t);
+		smb_direct_disconnect_rdma_connection(sc);
 	}
 	return ret;
 }
@@ -1346,15 +1342,13 @@ static void read_write_done(struct ib_cq *cq, struct ib_wc *wc,
 	struct smbdirect_rw_io *msg =
 		container_of(wc->wr_cqe, struct smbdirect_rw_io, cqe);
 	struct smbdirect_socket *sc = msg->socket;
-	struct smb_direct_transport *t =
-		container_of(sc, struct smb_direct_transport, socket);
 
 	if (wc->status != IB_WC_SUCCESS) {
 		msg->error = -EIO;
 		pr_err("read/write error. opcode = %d, status = %s(%d)\n",
 		       wc->opcode, ib_wc_status_msg(wc->status), wc->status);
 		if (wc->status != IB_WC_WR_FLUSH_ERR)
-			smb_direct_disconnect_rdma_connection(t);
+			smb_direct_disconnect_rdma_connection(sc);
 	}
 
 	complete(msg->completion);
@@ -1592,7 +1586,7 @@ static void smb_direct_qpair_handler(struct ib_event *event, void *context)
 	switch (event->event) {
 	case IB_EVENT_CQ_ERR:
 	case IB_EVENT_QP_FATAL:
-		smb_direct_disconnect_rdma_connection(t);
+		smb_direct_disconnect_rdma_connection(sc);
 		break;
 	default:
 		break;
-- 
2.43.0

[PATCH v4 121/142] smb: server: pass struct smbdirect_socket to smb_direct_cm_handler()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 8b6de0a6bf9d..bcfe0e62714c 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -333,7 +333,7 @@ static struct smb_direct_transport *alloc_transport(struct rdma_cm_id *cm_id)
 	sp->keepalive_timeout_msec = SMB_DIRECT_KEEPALIVE_RECV_TIMEOUT * 1000;
 
 	sc->rdma.cm_id = cm_id;
-	cm_id->context = t;
+	cm_id->context = sc;
 
 	sc->ib.dev = sc->rdma.cm_id->device;
 
@@ -1537,8 +1537,7 @@ static void smb_direct_shutdown(struct ksmbd_transport *t)
 static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
 				 struct rdma_cm_event *event)
 {
-	struct smb_direct_transport *t = cm_id->context;
-	struct smbdirect_socket *sc = &t->socket;
+	struct smbdirect_socket *sc = cm_id->context;
 
 	ksmbd_debug(RDMA, "RDMA CM event. cm_id=%p event=%s (%d)\n",
 		    cm_id, rdma_event_msg(event->event), event->event);
-- 
2.43.0

[PATCH v4 122/142] smb: server: pass struct smbdirect_socket to smb_direct_qpair_handler()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index bcfe0e62714c..c3be52f251c4 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -1576,8 +1576,7 @@ static int smb_direct_cm_handler(struct rdma_cm_id *cm_id,
 
 static void smb_direct_qpair_handler(struct ib_event *event, void *context)
 {
-	struct smb_direct_transport *t = context;
-	struct smbdirect_socket *sc = &t->socket;
+	struct smbdirect_socket *sc = context;
 
 	ksmbd_debug(RDMA, "Received QP event. cm_id=%p, event=%s (%d)\n",
 		    sc->rdma.cm_id, ib_event_msg(event->event), event->event);
@@ -1912,7 +1911,7 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 		return ret;
 	}
 
-	sc->ib.send_cq = ib_alloc_cq(sc->ib.dev, t,
+	sc->ib.send_cq = ib_alloc_cq(sc->ib.dev, sc,
 				 sp->send_credit_target + cap->max_rdma_ctxs,
 				 0, IB_POLL_WORKQUEUE);
 	if (IS_ERR(sc->ib.send_cq)) {
@@ -1922,7 +1921,7 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 		goto err;
 	}
 
-	sc->ib.recv_cq = ib_alloc_cq(sc->ib.dev, t,
+	sc->ib.recv_cq = ib_alloc_cq(sc->ib.dev, sc,
 				     sp->recv_credit_max, 0, IB_POLL_WORKQUEUE);
 	if (IS_ERR(sc->ib.recv_cq)) {
 		pr_err("Can't create RDMA recv CQ\n");
@@ -1933,7 +1932,7 @@ static int smb_direct_create_qpair(struct smb_direct_transport *t,
 
 	memset(&qp_attr, 0, sizeof(qp_attr));
 	qp_attr.event_handler = smb_direct_qpair_handler;
-	qp_attr.qp_context = t;
+	qp_attr.qp_context = sc;
 	qp_attr.cap = *cap;
 	qp_attr.sq_sig_type = IB_SIGNAL_REQ_WR;
 	qp_attr.qp_type = IB_QPT_RC;
-- 
2.43.0

[PATCH v4 123/142] smb: server: pass struct smbdirect_socket to smb_direct_create_qpair()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index c3be52f251c4..2650c6c5e1af 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -1894,10 +1894,9 @@ static int smb_direct_create_pools(struct smbdirect_socket *sc)
 	return -ENOMEM;
 }
 
-static int smb_direct_create_qpair(struct smb_direct_transport *t,
+static int smb_direct_create_qpair(struct smbdirect_socket *sc,
 				   struct ib_qp_cap *cap)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	int ret;
 	struct ib_qp_init_attr qp_attr;
@@ -2062,7 +2061,7 @@ static int smb_direct_connect(struct smb_direct_transport *st)
 		return ret;
 	}
 
-	ret = smb_direct_create_qpair(st, &qp_cap);
+	ret = smb_direct_create_qpair(sc, &qp_cap);
 	if (ret) {
 		pr_err("Can't accept RDMA client: %d\n", ret);
 		return ret;
-- 
2.43.0

[PATCH v4 124/142] smb: server: pass struct smbdirect_socket to smb_direct_post_recv()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 9 +++------
 1 file changed, 3 insertions(+), 6 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 2650c6c5e1af..21271c8a9573 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -620,10 +620,9 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 	smb_direct_disconnect_rdma_connection(sc);
 }
 
-static int smb_direct_post_recv(struct smb_direct_transport *t,
+static int smb_direct_post_recv(struct smbdirect_socket *sc,
 				struct smbdirect_recv_io *recvmsg)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct ib_recv_wr wr;
 	int ret;
@@ -780,8 +779,6 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
 {
 	struct smbdirect_socket *sc =
 		container_of(work, struct smbdirect_socket, recv_io.posted.refill_work);
-	struct smb_direct_transport *t =
-		container_of(sc, struct smb_direct_transport, socket);
 	struct smbdirect_recv_io *recvmsg;
 	int credits = 0;
 	int ret;
@@ -794,7 +791,7 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
 
 			recvmsg->first_segment = false;
 
-			ret = smb_direct_post_recv(t, recvmsg);
+			ret = smb_direct_post_recv(sc, recvmsg);
 			if (ret) {
 				pr_err("Can't post recv: %d\n", ret);
 				put_recvmsg(sc, recvmsg);
@@ -1722,7 +1719,7 @@ static int smb_direct_prepare_negotiation(struct smb_direct_transport *t)
 	if (!recvmsg)
 		return -ENOMEM;
 
-	ret = smb_direct_post_recv(t, recvmsg);
+	ret = smb_direct_post_recv(sc, recvmsg);
 	if (ret) {
 		pr_err("Can't post recv: %d\n", ret);
 		goto out_err;
-- 
2.43.0

[PATCH v4 125/142] smb: server: pass struct smbdirect_socket to smb_direct_accept_client()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 21271c8a9573..99a8e1b1860d 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -1656,9 +1656,8 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 	return 0;
 }
 
-static int smb_direct_accept_client(struct smb_direct_transport *t)
+static int smb_direct_accept_client(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct rdma_conn_param conn_param;
 	__be32 ird_ord_hdr[2];
@@ -1725,7 +1724,7 @@ static int smb_direct_prepare_negotiation(struct smb_direct_transport *t)
 		goto out_err;
 	}
 
-	ret = smb_direct_accept_client(t);
+	ret = smb_direct_accept_client(sc);
 	if (ret) {
 		pr_err("Can't accept client\n");
 		goto out_err;
-- 
2.43.0

[PATCH v4 126/142] smb: server: pass struct smbdirect_socket to smb_direct_prepare_negotiation()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 99a8e1b1860d..48f739af65e9 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -1703,11 +1703,10 @@ static int smb_direct_accept_client(struct smbdirect_socket *sc)
 	return 0;
 }
 
-static int smb_direct_prepare_negotiation(struct smb_direct_transport *t)
+static int smb_direct_prepare_negotiation(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &t->socket;
-	int ret;
 	struct smbdirect_recv_io *recvmsg;
+	int ret;
 
 	WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_CREATED);
 	sc->status = SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED;
@@ -2063,7 +2062,7 @@ static int smb_direct_connect(struct smb_direct_transport *st)
 		return ret;
 	}
 
-	ret = smb_direct_prepare_negotiation(st);
+	ret = smb_direct_prepare_negotiation(sc);
 	if (ret) {
 		pr_err("Can't negotiate: %d\n", ret);
 		return ret;
-- 
2.43.0

[PATCH v4 127/142] smb: server: pass struct smbdirect_socket to smb_direct_connect()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 48f739af65e9..4551abb7bf92 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -2038,11 +2038,10 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 	return ret;
 }
 
-static int smb_direct_connect(struct smb_direct_transport *st)
+static int smb_direct_connect(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &st->socket;
-	int ret;
 	struct ib_qp_cap qp_cap;
+	int ret;
 
 	ret = smb_direct_init_params(sc, &qp_cap);
 	if (ret) {
@@ -2166,7 +2165,7 @@ static int smb_direct_handle_connect_request(struct rdma_cm_id *new_cm_id,
 		sp->responder_resources = min_t(u8, sp->responder_resources,
 					       peer_responder_resources);
 
-	ret = smb_direct_connect(t);
+	ret = smb_direct_connect(sc);
 	if (ret)
 		goto out_err;
 
-- 
2.43.0

[PATCH v4 128/142] smb: server: pass struct smbdirect_socket to smb_direct_{alloc,free}_sendmsg()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 26 +++++++++++---------------
 1 file changed, 11 insertions(+), 15 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 4551abb7bf92..95f9552ef843 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -413,9 +413,8 @@ static void free_transport(struct smb_direct_transport *t)
 }
 
 static struct smbdirect_send_io
-*smb_direct_alloc_sendmsg(struct smb_direct_transport *t)
+*smb_direct_alloc_sendmsg(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_send_io *msg;
 
 	msg = mempool_alloc(sc->send_io.mem.pool, KSMBD_DEFAULT_GFP);
@@ -427,10 +426,9 @@ static struct smbdirect_send_io
 	return msg;
 }
 
-static void smb_direct_free_sendmsg(struct smb_direct_transport *t,
+static void smb_direct_free_sendmsg(struct smbdirect_socket *sc,
 				    struct smbdirect_send_io *msg)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	int i;
 
 	if (msg->num_sge > 0) {
@@ -810,13 +808,11 @@ static void smb_direct_post_recv_credits(struct work_struct *work)
 static void send_done(struct ib_cq *cq, struct ib_wc *wc)
 {
 	struct smbdirect_send_io *sendmsg, *sibling;
-	struct smb_direct_transport *t;
 	struct smbdirect_socket *sc;
 	struct list_head *pos, *prev, *end;
 
 	sendmsg = container_of(wc->wr_cqe, struct smbdirect_send_io, cqe);
 	sc = sendmsg->socket;
-	t = container_of(sc, struct smb_direct_transport, socket);
 
 	ksmbd_debug(RDMA, "Send completed. status='%s (%d)', opcode=%d\n",
 		    ib_wc_status_msg(wc->status), wc->status,
@@ -838,11 +834,11 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
 	for (pos = &sendmsg->sibling_list, prev = pos->prev, end = sendmsg->sibling_list.next;
 	     prev != end; pos = prev, prev = prev->prev) {
 		sibling = container_of(pos, struct smbdirect_send_io, sibling_list);
-		smb_direct_free_sendmsg(t, sibling);
+		smb_direct_free_sendmsg(sc, sibling);
 	}
 
 	sibling = container_of(pos, struct smbdirect_send_io, sibling_list);
-	smb_direct_free_sendmsg(t, sibling);
+	smb_direct_free_sendmsg(sc, sibling);
 }
 
 static int manage_credits_prior_sending(struct smb_direct_transport *t)
@@ -946,7 +942,7 @@ static int smb_direct_flush_send_list(struct smb_direct_transport *t,
 		wake_up(&sc->send_io.credits.wait_queue);
 		list_for_each_entry_safe(first, last, &send_ctx->msg_list,
 					 sibling_list) {
-			smb_direct_free_sendmsg(t, first);
+			smb_direct_free_sendmsg(sc, first);
 		}
 	}
 	return ret;
@@ -1021,7 +1017,7 @@ static int smb_direct_create_header(struct smb_direct_transport *t,
 	int header_length;
 	int ret;
 
-	sendmsg = smb_direct_alloc_sendmsg(t);
+	sendmsg = smb_direct_alloc_sendmsg(sc);
 	if (IS_ERR(sendmsg))
 		return PTR_ERR(sendmsg);
 
@@ -1064,7 +1060,7 @@ static int smb_direct_create_header(struct smb_direct_transport *t,
 						 DMA_TO_DEVICE);
 	ret = ib_dma_mapping_error(sc->ib.dev, sendmsg->sge[0].addr);
 	if (ret) {
-		smb_direct_free_sendmsg(t, sendmsg);
+		smb_direct_free_sendmsg(sc, sendmsg);
 		return ret;
 	}
 
@@ -1220,7 +1216,7 @@ static int smb_direct_post_send_data(struct smb_direct_transport *t,
 		goto err;
 	return 0;
 err:
-	smb_direct_free_sendmsg(t, msg);
+	smb_direct_free_sendmsg(sc, msg);
 	atomic_inc(&sc->send_io.credits.count);
 	return ret;
 }
@@ -1597,7 +1593,7 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 	struct smbdirect_negotiate_resp *resp;
 	int ret;
 
-	sendmsg = smb_direct_alloc_sendmsg(t);
+	sendmsg = smb_direct_alloc_sendmsg(sc);
 	if (IS_ERR(sendmsg))
 		return -ENOMEM;
 
@@ -1633,7 +1629,7 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 						 DMA_TO_DEVICE);
 	ret = ib_dma_mapping_error(sc->ib.dev, sendmsg->sge[0].addr);
 	if (ret) {
-		smb_direct_free_sendmsg(t, sendmsg);
+		smb_direct_free_sendmsg(sc, sendmsg);
 		return ret;
 	}
 
@@ -1643,7 +1639,7 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 
 	ret = post_sendmsg(t, NULL, sendmsg);
 	if (ret) {
-		smb_direct_free_sendmsg(t, sendmsg);
+		smb_direct_free_sendmsg(sc, sendmsg);
 		return ret;
 	}
 
-- 
2.43.0

[PATCH v4 129/142] smb: server: remove unused struct struct smb_direct_transport argument from smb_direct_send_ctx_init()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 95f9552ef843..d2e587ae3931 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -896,8 +896,7 @@ static int smb_direct_post_send(struct smb_direct_transport *t,
 	return ret;
 }
 
-static void smb_direct_send_ctx_init(struct smb_direct_transport *t,
-				     struct smbdirect_send_batch *send_ctx,
+static void smb_direct_send_ctx_init(struct smbdirect_send_batch *send_ctx,
 				     bool need_invalidate_rkey,
 				     unsigned int remote_key)
 {
@@ -934,7 +933,7 @@ static int smb_direct_flush_send_list(struct smb_direct_transport *t,
 
 	ret = smb_direct_post_send(t, &first->wr);
 	if (!ret) {
-		smb_direct_send_ctx_init(t, send_ctx,
+		smb_direct_send_ctx_init(send_ctx,
 					 send_ctx->need_invalidate_rkey,
 					 send_ctx->remote_key);
 	} else {
@@ -1245,7 +1244,7 @@ static int smb_direct_writev(struct ksmbd_transport *t,
 	remaining_data_length = buflen;
 	ksmbd_debug(RDMA, "Sending smb (RDMA): smb_len=%u\n", buflen);
 
-	smb_direct_send_ctx_init(st, &send_ctx, need_invalidate, remote_key);
+	smb_direct_send_ctx_init(&send_ctx, need_invalidate, remote_key);
 	start = i = 1;
 	buflen = 0;
 	while (true) {
-- 
2.43.0

[PATCH v4 130/142] smb: server: pass struct smbdirect_socket to smb_direct_post_send()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index d2e587ae3931..d29afc4be6a7 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -879,10 +879,9 @@ static int manage_keep_alive_before_sending(struct smb_direct_transport *t)
 	return 0;
 }
 
-static int smb_direct_post_send(struct smb_direct_transport *t,
+static int smb_direct_post_send(struct smbdirect_socket *sc,
 				struct ib_send_wr *wr)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	int ret;
 
 	atomic_inc(&sc->send_io.pending.count);
@@ -931,7 +930,7 @@ static int smb_direct_flush_send_list(struct smb_direct_transport *t,
 		last->wr.ex.invalidate_rkey = send_ctx->remote_key;
 	}
 
-	ret = smb_direct_post_send(t, &first->wr);
+	ret = smb_direct_post_send(sc, &first->wr);
 	if (!ret) {
 		smb_direct_send_ctx_init(send_ctx,
 					 send_ctx->need_invalidate_rkey,
@@ -1151,7 +1150,7 @@ static int post_sendmsg(struct smb_direct_transport *t,
 
 	msg->wr.wr_cqe = &msg->cqe;
 	msg->wr.send_flags = IB_SEND_SIGNALED;
-	return smb_direct_post_send(t, &msg->wr);
+	return smb_direct_post_send(sc, &msg->wr);
 }
 
 static int smb_direct_post_send_data(struct smb_direct_transport *t,
-- 
2.43.0

[PATCH v4 131/142] smb: server: pass struct smbdirect_socket to smb_direct_flush_send_list()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index d29afc4be6a7..39ea9c51a24b 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -905,11 +905,10 @@ static void smb_direct_send_ctx_init(struct smbdirect_send_batch *send_ctx,
 	send_ctx->remote_key = remote_key;
 }
 
-static int smb_direct_flush_send_list(struct smb_direct_transport *t,
+static int smb_direct_flush_send_list(struct smbdirect_socket *sc,
 				      struct smbdirect_send_batch *send_ctx,
 				      bool is_last)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_send_io *first, *last;
 	int ret;
 
@@ -977,7 +976,7 @@ static int wait_for_send_credits(struct smb_direct_transport *t,
 
 	if (send_ctx &&
 	    (send_ctx->wr_cnt >= 16 || atomic_read(&sc->send_io.credits.count) <= 1)) {
-		ret = smb_direct_flush_send_list(t, send_ctx, false);
+		ret = smb_direct_flush_send_list(sc, send_ctx, false);
 		if (ret)
 			return ret;
 	}
@@ -1297,7 +1296,7 @@ static int smb_direct_writev(struct ksmbd_transport *t,
 	}
 
 done:
-	ret = smb_direct_flush_send_list(st, &send_ctx, true);
+	ret = smb_direct_flush_send_list(sc, &send_ctx, true);
 
 	/*
 	 * As an optimization, we don't wait for individual I/O to finish
-- 
2.43.0

[PATCH v4 132/142] smb: server: pass struct smbdirect_socket to wait_for_credits()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 39ea9c51a24b..370e27bbcf12 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -945,11 +945,10 @@ static int smb_direct_flush_send_list(struct smbdirect_socket *sc,
 	return ret;
 }
 
-static int wait_for_credits(struct smb_direct_transport *t,
+static int wait_for_credits(struct smbdirect_socket *sc,
 			    wait_queue_head_t *waitq, atomic_t *total_credits,
 			    int needed)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	int ret;
 
 	do {
@@ -981,14 +980,14 @@ static int wait_for_send_credits(struct smb_direct_transport *t,
 			return ret;
 	}
 
-	return wait_for_credits(t, &sc->send_io.credits.wait_queue, &sc->send_io.credits.count, 1);
+	return wait_for_credits(sc, &sc->send_io.credits.wait_queue, &sc->send_io.credits.count, 1);
 }
 
 static int wait_for_rw_credits(struct smb_direct_transport *t, int credits)
 {
 	struct smbdirect_socket *sc = &t->socket;
 
-	return wait_for_credits(t,
+	return wait_for_credits(sc,
 				&sc->rw_io.credits.wait_queue,
 				&sc->rw_io.credits.count,
 				credits);
-- 
2.43.0

[PATCH v4 133/142] smb: server: pass struct smbdirect_socket to wait_for_send_credits()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 370e27bbcf12..defebe773b8a 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -967,10 +967,9 @@ static int wait_for_credits(struct smbdirect_socket *sc,
 	} while (true);
 }
 
-static int wait_for_send_credits(struct smb_direct_transport *t,
+static int wait_for_send_credits(struct smbdirect_socket *sc,
 				 struct smbdirect_send_batch *send_ctx)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	int ret;
 
 	if (send_ctx &&
@@ -1162,7 +1161,7 @@ static int smb_direct_post_send_data(struct smb_direct_transport *t,
 	int data_length;
 	struct scatterlist sg[SMBDIRECT_SEND_IO_MAX_SGE - 1];
 
-	ret = wait_for_send_credits(t, send_ctx);
+	ret = wait_for_send_credits(sc, send_ctx);
 	if (ret)
 		return ret;
 
-- 
2.43.0

[PATCH v4 134/142] smb: server: pass struct smbdirect_socket to wait_for_rw_credits()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index defebe773b8a..e47ff55af2e0 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -982,10 +982,8 @@ static int wait_for_send_credits(struct smbdirect_socket *sc,
 	return wait_for_credits(sc, &sc->send_io.credits.wait_queue, &sc->send_io.credits.count, 1);
 }
 
-static int wait_for_rw_credits(struct smb_direct_transport *t, int credits)
+static int wait_for_rw_credits(struct smbdirect_socket *sc, int credits)
 {
-	struct smbdirect_socket *sc = &t->socket;
-
 	return wait_for_credits(sc,
 				&sc->rw_io.credits.wait_queue,
 				&sc->rw_io.credits.count,
@@ -1401,7 +1399,7 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 	ksmbd_debug(RDMA, "RDMA %s, len %#x, needed credits %#x\n",
 		    str_read_write(is_read), buf_len, credits_needed);
 
-	ret = wait_for_rw_credits(t, credits_needed);
+	ret = wait_for_rw_credits(sc, credits_needed);
 	if (ret < 0)
 		return ret;
 
-- 
2.43.0

[PATCH v4 135/142] smb: server: pass struct smbdirect_socket to calc_rw_credits()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index e47ff55af2e0..da48b2ec6dd3 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -990,11 +990,9 @@ static int wait_for_rw_credits(struct smbdirect_socket *sc, int credits)
 				credits);
 }
 
-static int calc_rw_credits(struct smb_direct_transport *t,
+static int calc_rw_credits(struct smbdirect_socket *sc,
 			   char *buf, unsigned int len)
 {
-	struct smbdirect_socket *sc = &t->socket;
-
 	return DIV_ROUND_UP(get_buf_page_count(buf, len),
 			    sc->rw_io.credits.num_pages);
 }
@@ -1390,7 +1388,7 @@ static int smb_direct_rdma_xmit(struct smb_direct_transport *t,
 			buf_len = 0;
 		}
 
-		credits_needed += calc_rw_credits(t, desc_buf, desc_buf_len);
+		credits_needed += calc_rw_credits(sc, desc_buf, desc_buf_len);
 		desc_buf += desc_buf_len;
 		buf_len -= desc_buf_len;
 		desc_num++;
-- 
2.43.0

[PATCH v4 136/142] smb: server: pass struct smbdirect_socket to manage_credits_prior_sending()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index da48b2ec6dd3..8a57da09091c 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -841,9 +841,8 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
 	smb_direct_free_sendmsg(sc, sibling);
 }
 
-static int manage_credits_prior_sending(struct smb_direct_transport *t)
+static int manage_credits_prior_sending(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	int new_credits;
 
 	if (atomic_read(&sc->recv_io.credits.count) >= sc->recv_io.credits.target)
@@ -1015,7 +1014,7 @@ static int smb_direct_create_header(struct smb_direct_transport *t,
 	/* Fill in the packet header */
 	packet = (struct smbdirect_data_transfer *)sendmsg->packet;
 	packet->credits_requested = cpu_to_le16(sp->send_credit_target);
-	packet->credits_granted = cpu_to_le16(manage_credits_prior_sending(t));
+	packet->credits_granted = cpu_to_le16(manage_credits_prior_sending(sc));
 
 	packet->flags = 0;
 	if (manage_keep_alive_before_sending(t))
@@ -1604,7 +1603,7 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 		resp->reserved = 0;
 		resp->credits_requested =
 				cpu_to_le16(sp->send_credit_target);
-		resp->credits_granted = cpu_to_le16(manage_credits_prior_sending(t));
+		resp->credits_granted = cpu_to_le16(manage_credits_prior_sending(sc));
 		resp->max_readwrite_size = cpu_to_le32(sp->max_read_write_size);
 		resp->preferred_send_size = cpu_to_le32(sp->max_send_size);
 		resp->max_receive_size = cpu_to_le32(sp->max_recv_size);
-- 
2.43.0

[PATCH v4 137/142] smb: server: pass struct smbdirect_socket to manage_keep_alive_before_sending()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 8a57da09091c..600c541a919b 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -860,9 +860,8 @@ static int manage_credits_prior_sending(struct smbdirect_socket *sc)
 	return new_credits;
 }
 
-static int manage_keep_alive_before_sending(struct smb_direct_transport *t)
+static int manage_keep_alive_before_sending(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 
 	if (sc->idle.keepalive == SMBDIRECT_KEEPALIVE_PENDING) {
@@ -1017,7 +1016,7 @@ static int smb_direct_create_header(struct smb_direct_transport *t,
 	packet->credits_granted = cpu_to_le16(manage_credits_prior_sending(sc));
 
 	packet->flags = 0;
-	if (manage_keep_alive_before_sending(t))
+	if (manage_keep_alive_before_sending(sc))
 		packet->flags |= cpu_to_le16(SMBDIRECT_FLAG_RESPONSE_REQUESTED);
 
 	packet->reserved = 0;
-- 
2.43.0

[PATCH v4 138/142] smb: server: pass struct smbdirect_socket to smb_direct_create_header()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 600c541a919b..0c11855a2a8a 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -995,11 +995,10 @@ static int calc_rw_credits(struct smbdirect_socket *sc,
 			    sc->rw_io.credits.num_pages);
 }
 
-static int smb_direct_create_header(struct smb_direct_transport *t,
+static int smb_direct_create_header(struct smbdirect_socket *sc,
 				    int size, int remaining_data_length,
 				    struct smbdirect_send_io **sendmsg_out)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct smbdirect_send_io *sendmsg;
 	struct smbdirect_data_transfer *packet;
@@ -1163,7 +1162,7 @@ static int smb_direct_post_send_data(struct smb_direct_transport *t,
 	for (i = 0; i < niov; i++)
 		data_length += iov[i].iov_len;
 
-	ret = smb_direct_create_header(t, data_length, remaining_data_length,
+	ret = smb_direct_create_header(sc, data_length, remaining_data_length,
 				       &msg);
 	if (ret) {
 		atomic_inc(&sc->send_io.credits.count);
-- 
2.43.0

[PATCH v4 139/142] smb: server: pass struct smbdirect_socket to post_sendmsg()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 0c11855a2a8a..289325640a04 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -1104,11 +1104,10 @@ static int get_mapped_sg_list(struct ib_device *device, void *buf, int size,
 	return ib_dma_map_sg(device, sg_list, npages, dir);
 }
 
-static int post_sendmsg(struct smb_direct_transport *t,
+static int post_sendmsg(struct smbdirect_socket *sc,
 			struct smbdirect_send_batch *send_ctx,
 			struct smbdirect_send_io *msg)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	int i;
 
 	for (i = 0; i < msg->num_sge; i++)
@@ -1199,7 +1198,7 @@ static int smb_direct_post_send_data(struct smb_direct_transport *t,
 		}
 	}
 
-	ret = post_sendmsg(t, send_ctx, msg);
+	ret = post_sendmsg(sc, send_ctx, msg);
 	if (ret)
 		goto err;
 	return 0;
@@ -1625,7 +1624,7 @@ static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
 	sendmsg->sge[0].length = sizeof(*resp);
 	sendmsg->sge[0].lkey = sc->ib.pd->local_dma_lkey;
 
-	ret = post_sendmsg(t, NULL, sendmsg);
+	ret = post_sendmsg(sc, NULL, sendmsg);
 	if (ret) {
 		smb_direct_free_sendmsg(sc, sendmsg);
 		return ret;
-- 
2.43.0

[PATCH v4 140/142] smb: server: pass struct smbdirect_socket to smb_direct_post_send_data()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 289325640a04..7f7c31326226 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -135,7 +135,7 @@ static inline int get_buf_page_count(void *buf, int size)
 
 static void smb_direct_destroy_pools(struct smbdirect_socket *sc);
 static void smb_direct_post_recv_credits(struct work_struct *work);
-static int smb_direct_post_send_data(struct smb_direct_transport *t,
+static int smb_direct_post_send_data(struct smbdirect_socket *sc,
 				     struct smbdirect_send_batch *send_ctx,
 				     struct kvec *iov, int niov,
 				     int remaining_data_length);
@@ -269,13 +269,11 @@ static void smb_direct_send_immediate_work(struct work_struct *work)
 {
 	struct smbdirect_socket *sc =
 		container_of(work, struct smbdirect_socket, idle.immediate_work);
-	struct smb_direct_transport *t =
-		container_of(sc, struct smb_direct_transport, socket);
 
 	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
 		return;
 
-	smb_direct_post_send_data(t, NULL, NULL, 0, 0);
+	smb_direct_post_send_data(sc, NULL, NULL, 0, 0);
 }
 
 static void smb_direct_idle_connection_timer(struct work_struct *work)
@@ -1142,12 +1140,11 @@ static int post_sendmsg(struct smbdirect_socket *sc,
 	return smb_direct_post_send(sc, &msg->wr);
 }
 
-static int smb_direct_post_send_data(struct smb_direct_transport *t,
+static int smb_direct_post_send_data(struct smbdirect_socket *sc,
 				     struct smbdirect_send_batch *send_ctx,
 				     struct kvec *iov, int niov,
 				     int remaining_data_length)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	int i, j, ret;
 	struct smbdirect_send_io *msg;
 	int data_length;
@@ -1241,7 +1238,7 @@ static int smb_direct_writev(struct ksmbd_transport *t,
 			if (i > start) {
 				remaining_data_length -=
 					(buflen - iov[i].iov_len);
-				ret = smb_direct_post_send_data(st, &send_ctx,
+				ret = smb_direct_post_send_data(sc, &send_ctx,
 								&iov[start], i - start,
 								remaining_data_length);
 				if (ret)
@@ -1259,7 +1256,7 @@ static int smb_direct_writev(struct ksmbd_transport *t,
 						min_t(int, max_iov_size,
 						      buflen - max_iov_size * j);
 					remaining_data_length -= vec.iov_len;
-					ret = smb_direct_post_send_data(st, &send_ctx, &vec, 1,
+					ret = smb_direct_post_send_data(sc, &send_ctx, &vec, 1,
 									remaining_data_length);
 					if (ret)
 						goto done;
@@ -1275,7 +1272,7 @@ static int smb_direct_writev(struct ksmbd_transport *t,
 			if (i == niovs) {
 				/* send out all remaining vecs */
 				remaining_data_length -= buflen;
-				ret = smb_direct_post_send_data(st, &send_ctx,
+				ret = smb_direct_post_send_data(sc, &send_ctx,
 								&iov[start], i - start,
 								remaining_data_length);
 				if (ret)
-- 
2.43.0

[PATCH v4 141/142] smb: server: pass struct smbdirect_socket to {enqueue,get_first}_reassembly()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 20 +++++++-------------
 1 file changed, 7 insertions(+), 13 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 7f7c31326226..4c9d33ee67b5 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -180,12 +180,10 @@ static void put_recvmsg(struct smbdirect_socket *sc,
 	queue_work(sc->workqueue, &sc->recv_io.posted.refill_work);
 }
 
-static void enqueue_reassembly(struct smb_direct_transport *t,
+static void enqueue_reassembly(struct smbdirect_socket *sc,
 			       struct smbdirect_recv_io *recvmsg,
 			       int data_length)
 {
-	struct smbdirect_socket *sc = &t->socket;
-
 	spin_lock(&sc->recv_io.reassembly.lock);
 	list_add_tail(&recvmsg->list, &sc->recv_io.reassembly.list);
 	sc->recv_io.reassembly.queue_length++;
@@ -200,10 +198,8 @@ static void enqueue_reassembly(struct smb_direct_transport *t,
 	spin_unlock(&sc->recv_io.reassembly.lock);
 }
 
-static struct smbdirect_recv_io *get_first_reassembly(struct smb_direct_transport *t)
+static struct smbdirect_recv_io *get_first_reassembly(struct smbdirect_socket *sc)
 {
-	struct smbdirect_socket *sc = &t->socket;
-
 	if (!list_empty(&sc->recv_io.reassembly.list))
 		return list_first_entry(&sc->recv_io.reassembly.list,
 				struct smbdirect_recv_io, list);
@@ -386,7 +382,7 @@ static void free_transport(struct smb_direct_transport *t)
 	ksmbd_debug(RDMA, "drain the reassembly queue\n");
 	do {
 		spin_lock(&sc->recv_io.reassembly.lock);
-		recvmsg = get_first_reassembly(t);
+		recvmsg = get_first_reassembly(sc);
 		if (recvmsg) {
 			list_del(&recvmsg->list);
 			spin_unlock(&sc->recv_io.reassembly.lock);
@@ -493,14 +489,12 @@ static int smb_direct_check_recvmsg(struct smbdirect_recv_io *recvmsg)
 static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 {
 	struct smbdirect_recv_io *recvmsg;
-	struct smb_direct_transport *t;
 	struct smbdirect_socket *sc;
 	struct smbdirect_socket_parameters *sp;
 
 	recvmsg = container_of(wc->wr_cqe, struct smbdirect_recv_io, cqe);
 	sc = recvmsg->socket;
 	sp = &sc->parameters;
-	t = container_of(sc, struct smb_direct_transport, socket);
 
 	if (wc->status != IB_WC_SUCCESS || wc->opcode != IB_WC_RECV) {
 		put_recvmsg(sc, recvmsg);
@@ -538,7 +532,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 		sc->recv_io.reassembly.full_packet_received = true;
 		WARN_ON_ONCE(sc->status != SMBDIRECT_SOCKET_NEGOTIATE_NEEDED);
 		sc->status = SMBDIRECT_SOCKET_NEGOTIATE_RUNNING;
-		enqueue_reassembly(t, recvmsg, 0);
+		enqueue_reassembly(sc, recvmsg, 0);
 		wake_up(&sc->status_wait);
 		return;
 	case SMBDIRECT_EXPECT_DATA_TRANSFER: {
@@ -596,7 +590,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
 			if (sc->recv_io.credits.target > old_recv_credit_target)
 				queue_work(sc->workqueue, &sc->recv_io.posted.refill_work);
 
-			enqueue_reassembly(t, recvmsg, (int)data_length);
+			enqueue_reassembly(sc, recvmsg, (int)data_length);
 			wake_up(&sc->recv_io.reassembly.wait_queue);
 		} else
 			put_recvmsg(sc, recvmsg);
@@ -691,7 +685,7 @@ static int smb_direct_read(struct ksmbd_transport *t, char *buf,
 		to_read = size;
 		offset = sc->recv_io.reassembly.first_entry_offset;
 		while (data_read < size) {
-			recvmsg = get_first_reassembly(st);
+			recvmsg = get_first_reassembly(sc);
 			data_transfer = smbdirect_recv_io_payload(recvmsg);
 			data_length = le32_to_cpu(data_transfer->data_length);
 			remaining_data_length =
@@ -1986,7 +1980,7 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 	if (ret <= 0 || sc->status != SMBDIRECT_SOCKET_NEGOTIATE_RUNNING)
 		return ret < 0 ? ret : -ETIMEDOUT;
 
-	recvmsg = get_first_reassembly(st);
+	recvmsg = get_first_reassembly(sc);
 	if (!recvmsg)
 		return -ECONNABORTED;
 
-- 
2.43.0

[PATCH v4 142/142] smb: server: pass struct smbdirect_socket to smb_direct_send_negotiate_response()

[Stefan Metzmacher]

This will make it easier to move function to the common code
in future.

Cc: Namjae Jeon <linkinjeon@kernel.org>
Cc: Steve French <smfrench@gmail.com>
Cc: Tom Talpey <tom@talpey.com>
Cc: linux-cifs@vger.kernel.org
Cc: samba-technical@lists.samba.org
Signed-off-by: Stefan Metzmacher <metze@samba.org>
---
 fs/smb/server/transport_rdma.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 4c9d33ee67b5..6e4c2bf7dd93 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -1562,10 +1562,9 @@ static void smb_direct_qpair_handler(struct ib_event *event, void *context)
 	}
 }
 
-static int smb_direct_send_negotiate_response(struct smb_direct_transport *t,
+static int smb_direct_send_negotiate_response(struct smbdirect_socket *sc,
 					      int failed)
 {
-	struct smbdirect_socket *sc = &t->socket;
 	struct smbdirect_socket_parameters *sp = &sc->parameters;
 	struct smbdirect_send_io *sendmsg;
 	struct smbdirect_negotiate_resp *resp;
@@ -2001,7 +2000,7 @@ static int smb_direct_prepare(struct ksmbd_transport *t)
 	sc->recv_io.credits.target = min_t(u16, sc->recv_io.credits.target, sp->recv_credit_max);
 	sc->recv_io.credits.target = max_t(u16, sc->recv_io.credits.target, 1);
 
-	ret = smb_direct_send_negotiate_response(st, ret);
+	ret = smb_direct_send_negotiate_response(sc, ret);
 out:
 	spin_lock_irq(&sc->recv_io.reassembly.lock);
 	sc->recv_io.reassembly.queue_length--;
-- 
2.43.0

Re: [PATCH v4 000/142] smb: smbdirect/client/server: make use of common structures

[Namjae Jeon]

On Tue, Aug 26, 2025 at 5:42 AM Stefan Metzmacher <metze@samba.org> wrote:
>
> Hi,
>
> this is the next step towards a common smbdirect layer
> between cifs.ko and ksmbd.ko, with the aim to provide
> a socket layer for userspace usage at the end of the road.
>
> Note the patchset is based on v6.17-rc3 plus the following
> patches from sfrench-cifs-2.6/for-next:
> 21d14611210d0bdf6b0c6db45c2361e96e6673d4
> smb3 client: fix return code mapping of remap_file_range
> a21e20edf966db8d3e0e0748a9201fbd62fd961a
> smb: client: Fix mount deadlock by avoiding super block iteration in DFS reconnect
> plus the client and server fixes for the IRD/ORD negotiation:
> https://lore.kernel.org/linux-cifs/20250821093113.36212-1-metze@samba.org/
> https://lore.kernel.org/linux-cifs/20250821092751.35815-1-metze@samba.org/
> But only the IRD/ORD patches are really required in order to
> apply the patchset. It can also be found as branch for-6.18/fs-smb-20250825-v4
> in https://git.samba.org/metze/linux/wip.git, see
> https://git.samba.org/?p=metze/linux/wip.git;a=shortlog;h=refs/heads/for-6.18/fs-smb-20250825-v4
>
> This patchset introduces more common structures and elements
> to struct smbdirect_socket[_parameters]. (Patches 001-018)
>
> The client side is modified in tiny steps in order
> to use the new common structures. At the end
> struct smbd_connection is only a simple container
> arround struct smbdirect_socket. For now I left
> it that way in order to avoid changing the smb layer
> to use struct smbdirect_socket. In the end I'd like to
> expose only an anonymous structure to the smb layer
> and struct smbdirect_socket will become a private structure.
> (Patches 019-075). In between there are some fixes for
> the keepalive and timeout handling.
>
> Note that 047 smb: client: make use of smbdirect_socket.statistics
> generates the following warnings from scripts/checkpatch.pl --quiet
>  WARNING: quoted string split across lines
>  #40: FILE: fs/smb/client/cifs_debug.c:464:
>  +               seq_printf(m, "\nDebug count_get_receive_buffer: %llx "
>  +                       "count_put_receive_buffer: %llx count_send_empty: %llx",
>
>  WARNING: quoted string split across lines
>  #47: FILE: fs/smb/client/cifs_debug.c:469:
>                  seq_printf(m, "\nRead Queue "
>  +                       "count_enqueue_reassembly_queue: %llx "
>
>  WARNING: quoted string split across lines
>  #48: FILE: fs/smb/client/cifs_debug.c:470:
>  +                       "count_enqueue_reassembly_queue: %llx "
>  +                       "count_dequeue_reassembly_queue: %llx "
>
>  total: 0 errors, 3 warnings, 83 lines checked
>  scripts/checkpatch.pl: FAILED
>
> But I left them in in order to keep the strange style like
> the other code before and after...
>
> The server is also changed in tiny steps in order to
> make use of the common structures only. Patches 076-142.
> We only have this left at the end of the patchset:
>
>    struct smb_direct_transport {
>         struct ksmbd_transport  transport;
>
>         struct smbdirect_socket socket;
>    };
>
> The server also got patches to implement keepalive and timeout
> handling in order to match the client code.
>
> The client patches and server patches are independent
> from each other, but both need their own IRD/ORD negotiation
> fix plus the common smbdirect patches.
>
> From here I'll start to split out common functions.
> In the first step as static __maybe_unused functions in a
> common smbdirect_connection.c file that will be included
> in client/smbdirect.c and server/transport_rdma.c.
> This is strange, but it will allow me to continue in tiny
> steps until only common code it used.
> If it's too strange I can use a smbdirect_connection.h
> and rename it later from .h to .c
>
> At that point I'll introduce an smbdirect.ko and export some
> public functions which will replace the include of the .c.
> Then I can finally start to add the struct socket/sock glue
> in order to provide smbdirect support to userspace.
>
> I used the following xfstests as regression tests:
> cifs/001 generic/001 generic/002 generic/005 generic/006 generic/007 generic/010 generic/011
>
> Between cifs.ko against ksmbd.ko via siw.ko and also
> the client via siw.ko against Windows 2025 using
> a Chelsio T520-BT card. I tested the modules once
> before and after the applied patches and also the
> combination.
Acked-by: Namjae Jeon <linkinjeon@kernel.org> for 087~142 patches.

Thanks!
>
> V4:
> rebased on v6.17-rc3 and current sfrench-cifs-2.6/for-next
> A lot of additional patches are added in order to
> use struct smbdirect_socket almost everywhere.
>
> V3:
> smbd_disconnect_rdma_work() needed to handle more
> than SMBDIRECT_SOCKET_CONNECTED in order to call
> rdma_disconnect.
>
> V2:
> init_waitqueue_head(&info->status_wait); was moved
> to the beginning so that it is correctly initialized
> in smbd_create_id().
>
> Stefan Metzmacher (142):
>   smb: smbdirect: introduce smbdirect_socket.status_wait
>   smb: smbdirect: introduce smbdirect_socket_init()
>   smb: smbdirect: introduce smbdirect_socket.disconnect_work
>   smb: smbdirect: introduce
>     smbdirect_socket.send_io.pending.{count,wait_queue}
>   smb: smbdirect: introduce
>     smbdirect_socket.send_io.credits.{count,wait_queue}
>   smb: smbdirect: introduce struct smbdirect_send_batch
>   smb: smbdirect: introduce smbdirect_socket.rw_io.credits
>   smb: smbdirect: introduce struct smbdirect_rw_io
>   smb: smbdirect: introduce smbdirect_socket.recv_io.{posted,credits}
>   smb: smbdirect: introduce
>     smbdirect_socket_parameters.{resolve_{addr,route},rdma_connect,negotiate}_timeout_msec
>   smb: smbdirect: introduce
>     smbdirect_socket_parameters.{initiator_depth,responder_resources}
>   smb: smbdirect: introduce smbdirect_socket.rdma.legacy_iwarp
>   smb: smbdirect: introduce
>     smbdirect_socket.idle.{keepalive,immediate_work,timer_work}
>   smb: smbdirect: introduce smbdirect_socket.statistics
>   smb: smbdirect: introduce smbdirect_socket.workqueue
>   smb: smbdirect: introduce struct smbdirect_mr_io
>   smb: smbdirect: introduce smbdirect_socket_parameters.max_frmr_depth
>   smb: smbdirect: introduce smbdirect_socket.mr_io.*
>   smb: client/smbdirect: replace SMBDIRECT_SOCKET_CONNECTING with more
>     detailed states
>   smb: client: use status_wait and SMBDIRECT_SOCKET_NEGOTIATE_RUNNING
>     for completion
>   smb: client: use status_wait and
>     SMBDIRECT_SOCKET_RESOLVE_{ADDR,ROUTE}_RUNNING for completion
>   smb: client: make use of smbdirect_socket.status_wait
>   smb: client: make only use of wake_up[_all]() in smbdirect.c
>   smb: client: make use of smbdirect_socket_init()
>   smb: client: make use of smbdirect_socket.disconnect_work
>   smb: client: make use of
>     smbdirect_socket.send_io.pending.{count,wait_queue}
>   smb: client: make use of
>     smbdirect_socket.send_io.credits.{count,wait_queue}
>   smb: client: make sure smbd_disconnect_rdma_work() doesn't run after
>     smbd_destroy() took over
>   smb: client: use disable[_delayed]_work_sync in smbdirect.c
>   smb: client: let smbd_destroy() call
>     disable_work_sync(&info->post_send_credits_work)
>   smb: client: queue post_recv_credits_work also if the peer raises the
>     credit target
>   smb: client: make use of ib_wc_status_msg() and skip
>     IB_WC_WR_FLUSH_ERR logging
>   smb: client: remove info->wait_receive_queues handling in
>     smbd_destroy()
>   smb: client: limit the range of info->receive_credit_target
>   smb: client: count the number of posted recv_io messages in order to
>     calculated credits
>   smb: client: make use of smbdirect_socket.recv_io.{posted,credits}
>   smb: client: remove useless smbd_connection.send_immediate
>   smb: client: fill smbdirect_socket_parameters at the beginning and use
>     the values from there
>   smb: client: make use of
>     smbdirect_socket_parameters.{resolve_{addr,route},rdma_connect,negotiate}_timeout_msec
>   smb: client: make use of
>     smbdirect_socket_parameters.{initiator_depth,responder_resources}
>   smb: client: make use of smbdirect_socket.rdma.legacy_iwarp
>   smb: client: send empty packets via send_immediate_work
>   smb: client: fix smbdirect keep alive handling to match the
>     documentation
>   smb: client: make use of
>     smbdirect_socket.idle.{keepalive,immediate_work,timer_work}
>   smb: client: remove unused smbd_connection->protocol
>   smb: client: remove unused smbd_connection.count_reassembly_queue
>   smb: client: make use of smbdirect_socket.statistics
>   smb: client: don't check sc->send_io.pending.count is below
>     sp->send_credit_target
>   smb: client: move rdma_readwrite_threshold from smbd_connection to
>     TCP_Server_Info
>   smb: client: make use of smbdirect_socket.workqueue
>   smb: client: add and use smbd_get_parameters()
>   smb: client: make use of struct smbdirect_mr_io
>   smb: client: make use of smbdirect_socket_parameters.max_frmr_depth
>   smb: client: make use of smbdirect_socket.mr_io
>   smb: client: pass struct smbdirect_socket to
>     {get,put}_receive_buffer()
>   smb: client: pass struct smbdirect_socket to
>     {allocate,destroy}_receive_buffers()
>   smb: client: pass struct smbdirect_socket to
>     {allocate,destroy}_caches_and_workqueue()
>   smb: client: pass struct smbdirect_socket to
>     {enqueue,_get_first}_reassembly()
>   smb: client: pass struct smbdirect_socket to
>     {allocate,destroy}_mr_list()
>   smb: client: pass struct smbdirect_socket to
>     smbd_disconnect_rdma_connection()
>   smb: client: pass struct smbdirect_socket to smbd_post_recv()
>   smb: client: pass struct smbdirect_socket to
>     manage_credits_prior_sending()
>   smb: client: pass struct smbdirect_socket to smbd_post_send()
>   smb: client: pass struct smbdirect_socket to
>     manage_keep_alive_before_sending()
>   smb: client: pass struct smbdirect_socket to smbd_post_send_iter()
>   smb: client: pass struct smbdirect_socket to smbd_post_send_empty()
>   smb: client: pass struct smbdirect_socket to
>     smbd_post_send_full_iter()
>   smb: client: pass struct smbdirect_socket to smbd_conn_upcall()
>   smb: client: pass struct smbdirect_socket to
>     smbd_qp_async_error_upcall()
>   smb: client: pass struct smbdirect_socket to smbd_create_id()
>   smb: client: pass struct smbdirect_socket to smbd_ia_open()
>   smb: client: pass struct smbdirect_socket to
>     smbd_post_send_negotiate_req()
>   smb: client: pass struct smbdirect_socket to smbd_negotiate()
>   smb: client: pass struct smbdirect_socket to get_mr()
>   smb: client: remove unused struct smbdirect_socket argument of
>     smbd_iter_to_mr()
>   smb: server: make use of common smbdirect_pdu.h
>   smb: server: make use of common smbdirect.h
>   smb: server: make use of common smbdirect_socket
>   smb: server: make use of common smbdirect_socket_parameters
>   smb: server: make use of smbdirect_socket->recv_io.expected
>   smb: server: make use of struct smbdirect_recv_io
>   smb: server: make use of smbdirect_socket.recv_io.free.{list,lock}
>   smb: server: make use of smbdirect_socket.recv_io.reassembly.*
>   smb: server: make use of SMBDIRECT_RECV_IO_MAX_SGE
>   smb: server: make use of struct smbdirect_send_io
>   smb: server: make use of
>     smbdirect_socket.{send,recv}_io.mem.{cache,pool}
>   smb: server: make only use of wake_up[_all]() in transport_rdma.c
>   smb: server: add a pr_info() when the server starts running
>   smb: server: don't use delayed_work for post_recv_credits_work
>   smb: server: queue post_recv_credits_work in put_recvmsg() and avoid
>     count_avail_recvmsg
>   smb: server: make use of smbdirect_socket.status_wait
>   smb: server: only turn into SMBDIRECT_SOCKET_CONNECTED when
>     negotiation is done
>   smb: server: use disable_work_sync in transport_rdma.c
>   smb: server: move smb_direct_disconnect_rdma_work() into
>     free_transport()
>   smb: server: don't wait for info->send_pending == 0 on error
>   smb: server: make use of smbdirect_socket_init()
>   smb: server: make use of smbdirect_socket.disconnect_work
>   smb: server: make use of
>     smbdirect_socket.send_io.pending.{count,wait_queue}
>   smb: server: make use of
>     smbdirect_socket.send_io.credits.{count,wait_queue}
>   smb: server: make use of struct smbdirect_send_batch
>   smb: server: make use smbdirect_socket.rw_io.credits
>   smb: server: make use of struct smbdirect_rw_io
>   smb: server: take the recv_credit_target from the negotiate req and
>     always limit the range
>   smb: server: manage recv credits by counting posted recv_io and
>     granted credits
>   smb: server: make use of smbdirect_socket.recv_io.{posted,credits}
>   smb: server: replace smb_trans_direct_transfort() with SMBD_TRANS()
>   smb: server: remove useless casts from KSMBD_TRANS/SMBD_TRANS
>   smb: server: pass ksmbd_transport to get_smbd_max_read_write_size()
>   smb: server: fill smbdirect_socket_parameters at the beginning and use
>     the values from there
>   smb: server: make use of
>     smbdirect_socket_parameters.negotiate_timeout_msec and change to 5s
>   smb: server: make use of
>     smbdirect_socket_parameters.{initiator_depth,responder_resources}
>   smb: server: make use of smbdirect_socket.rdma.legacy_iwarp
>   smb: server: make use of smbdirect_socket.idle.immediate_work
>   smb: server: implement correct keepalive and timeout handling for
>     smbdirect
>   smb: server: make use of smbdirect_socket.workqueue
>   smb: server: pass struct smbdirect_socket to {get_free,put}_recvmsg()
>   smb: server: pass struct smbdirect_socket to
>     smb_direct_{create,destroy}_pools()
>   smb: server: pass struct smbdirect_socket to
>     smb_direct_get_max_fr_pages()
>   smb: server: pass struct smbdirect_socket to smb_direct_init_params()
>   smb: server: pass struct smbdirect_socket to
>     smb_direct_disconnect_rdma_connection()
>   smb: server: pass struct smbdirect_socket to smb_direct_cm_handler()
>   smb: server: pass struct smbdirect_socket to
>     smb_direct_qpair_handler()
>   smb: server: pass struct smbdirect_socket to smb_direct_create_qpair()
>   smb: server: pass struct smbdirect_socket to smb_direct_post_recv()
>   smb: server: pass struct smbdirect_socket to
>     smb_direct_accept_client()
>   smb: server: pass struct smbdirect_socket to
>     smb_direct_prepare_negotiation()
>   smb: server: pass struct smbdirect_socket to smb_direct_connect()
>   smb: server: pass struct smbdirect_socket to
>     smb_direct_{alloc,free}_sendmsg()
>   smb: server: remove unused struct struct smb_direct_transport argument
>     from smb_direct_send_ctx_init()
>   smb: server: pass struct smbdirect_socket to smb_direct_post_send()
>   smb: server: pass struct smbdirect_socket to
>     smb_direct_flush_send_list()
>   smb: server: pass struct smbdirect_socket to wait_for_credits()
>   smb: server: pass struct smbdirect_socket to wait_for_send_credits()
>   smb: server: pass struct smbdirect_socket to wait_for_rw_credits()
>   smb: server: pass struct smbdirect_socket to calc_rw_credits()
>   smb: server: pass struct smbdirect_socket to
>     manage_credits_prior_sending()
>   smb: server: pass struct smbdirect_socket to
>     manage_keep_alive_before_sending()
>   smb: server: pass struct smbdirect_socket to
>     smb_direct_create_header()
>   smb: server: pass struct smbdirect_socket to post_sendmsg()
>   smb: server: pass struct smbdirect_socket to
>     smb_direct_post_send_data()
>   smb: server: pass struct smbdirect_socket to
>     {enqueue,get_first}_reassembly()
>   smb: server: pass struct smbdirect_socket to
>     smb_direct_send_negotiate_response()
>
>  fs/smb/client/cifs_debug.c                 |   48 +-
>  fs/smb/client/cifsglob.h                   |    9 +-
>  fs/smb/client/file.c                       |   16 +-
>  fs/smb/client/smb2ops.c                    |    8 +-
>  fs/smb/client/smb2pdu.c                    |    2 +-
>  fs/smb/client/smbdirect.c                  |  943 +++++++------
>  fs/smb/client/smbdirect.h                  |  104 +-
>  fs/smb/common/smbdirect/smbdirect.h        |    7 +
>  fs/smb/common/smbdirect/smbdirect_socket.h |  242 +++-
>  fs/smb/server/connection.c                 |    4 +-
>  fs/smb/server/connection.h                 |   10 +-
>  fs/smb/server/server.c                     |    1 +
>  fs/smb/server/smb2pdu.c                    |   23 +-
>  fs/smb/server/smb2pdu.h                    |    6 -
>  fs/smb/server/transport_rdma.c             | 1434 ++++++++++----------
>  fs/smb/server/transport_rdma.h             |   45 +-
>  16 files changed, 1565 insertions(+), 1337 deletions(-)
>
> --
> 2.43.0
>

replace for-next-next... Re: [PATCH v4 000/142] smb: smbdirect/client/server: make use of common structures

[Stefan Metzmacher]

Hi Steve,

here's the branch that could replace your
for-next-next (6eede6a6805fb50e3131b4b8182e10a17c9005b1)

git fetch https://git.samba.org/metze/linux/wip.git for-6.18/fs-smb-20250908-v5
(d762704985c3bd93e2d2e9ab224f5795baea63e1)

https://git.samba.org/?p=metze/linux/wip.git;a=shortlog;h=refs/heads/for-6.18/fs-smb-20250908-v5

The first 3 patches are the main reason why the rebase is needed.
7a9cd9e986c1f6ce3a64f4329b2e795bf24752ae smb: server: let smb_direct_writev() respect SMB_DIRECT_MAX_SEND_SGES
329efe5eb73f7b7604dab6b08f16bb6c3e500690 smb: smbdirect: introduce smbdirect_socket_status_string()
ab7a3a9ece72bce4f601d6224aa9243b7e090ca9 smb: client: adjust smbdirect related output of cifs_debug_data_proc_show()

In addition send_io.pending.wait_queue is changed to send_io.pending.zero_wait_queue to indicate
it's woken when count gets zero.

send_io.pending.dec_wait_queue is introduced to replace info->wait_post_send instead of dropping
the logic around it, that gets woken on every decrement.

The diff between the branches below:

Please replace your for-next-next if you're happy.

Thanks!
metze

  fs/smb/client/cifs_debug.c                 |  41 +++----
  fs/smb/client/smbdirect.c                  |  30 ++++--
  fs/smb/common/smbdirect/smbdirect_socket.h |  55 +++++++++-
  fs/smb/server/transport_rdma.c             | 167 +++++++++++++++++++----------
  4 files changed, 210 insertions(+), 83 deletions(-)

diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
index b4d70b51c456..35c4d27d2cc0 100644
--- a/fs/smb/client/cifs_debug.c
+++ b/fs/smb/client/cifs_debug.c
@@ -457,52 +457,53 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
  		sc = &server->smbd_conn->socket;
  		sp = &sc->parameters;

-		seq_printf(m, "\nSMBDirect (in hex) protocol version: %x "
-			"transport status: %x",
+		seq_printf(m, "\nSMBDirect protocol version: 0x%x "
+			"transport status: %s (%u)",
  			SMBDIRECT_V1,
+			smbdirect_socket_status_string(sc->status),
  			sc->status);
-		seq_printf(m, "\nConn receive_credit_max: %x "
-			"send_credit_target: %x max_send_size: %x",
+		seq_printf(m, "\nConn receive_credit_max: %u "
+			"send_credit_target: %u max_send_size: %u",
  			sp->recv_credit_max,
  			sp->send_credit_target,
  			sp->max_send_size);
-		seq_printf(m, "\nConn max_fragmented_recv_size: %x "
-			"max_fragmented_send_size: %x max_receive_size:%x",
+		seq_printf(m, "\nConn max_fragmented_recv_size: %u "
+			"max_fragmented_send_size: %u max_receive_size:%u",
  			sp->max_fragmented_recv_size,
  			sp->max_fragmented_send_size,
  			sp->max_recv_size);
-		seq_printf(m, "\nConn keep_alive_interval: %x "
-			"max_readwrite_size: %x rdma_readwrite_threshold: %x",
+		seq_printf(m, "\nConn keep_alive_interval: %u "
+			"max_readwrite_size: %u rdma_readwrite_threshold: %u",
  			sp->keepalive_interval_msec * 1000,
  			sp->max_read_write_size,
  			server->rdma_readwrite_threshold);
-		seq_printf(m, "\nDebug count_get_receive_buffer: %llx "
-			"count_put_receive_buffer: %llx count_send_empty: %llx",
+		seq_printf(m, "\nDebug count_get_receive_buffer: %llu "
+			"count_put_receive_buffer: %llu count_send_empty: %llu",
  			sc->statistics.get_receive_buffer,
  			sc->statistics.put_receive_buffer,
  			sc->statistics.send_empty);
  		seq_printf(m, "\nRead Queue "
-			"count_enqueue_reassembly_queue: %llx "
-			"count_dequeue_reassembly_queue: %llx "
-			"reassembly_data_length: %x "
-			"reassembly_queue_length: %x",
+			"count_enqueue_reassembly_queue: %llu "
+			"count_dequeue_reassembly_queue: %llu "
+			"reassembly_data_length: %u "
+			"reassembly_queue_length: %u",
  			sc->statistics.enqueue_reassembly_queue,
  			sc->statistics.dequeue_reassembly_queue,
  			sc->recv_io.reassembly.data_length,
  			sc->recv_io.reassembly.queue_length);
-		seq_printf(m, "\nCurrent Credits send_credits: %x "
-			"receive_credits: %x receive_credit_target: %x",
+		seq_printf(m, "\nCurrent Credits send_credits: %u "
+			"receive_credits: %u receive_credit_target: %u",
  			atomic_read(&sc->send_io.credits.count),
  			atomic_read(&sc->recv_io.credits.count),
  			sc->recv_io.credits.target);
-		seq_printf(m, "\nPending send_pending: %x ",
+		seq_printf(m, "\nPending send_pending: %u ",
  			atomic_read(&sc->send_io.pending.count));
-		seq_printf(m, "\nMR responder_resources: %x "
-			"max_frmr_depth: %x mr_type: %x",
+		seq_printf(m, "\nMR responder_resources: %u "
+			"max_frmr_depth: %u mr_type: 0x%x",
  			sp->responder_resources,
  			sp->max_frmr_depth,
  			sc->mr_io.type);
-		seq_printf(m, "\nMR mr_ready_count: %x mr_used_count: %x",
+		seq_printf(m, "\nMR mr_ready_count: %u mr_used_count: %u",
  			atomic_read(&sc->mr_io.ready.count),
  			atomic_read(&sc->mr_io.used.count));
  skip_rdma:
diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index d3cd89bd2cc7..322334097e30 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -412,7 +412,9 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
  	}

  	if (atomic_dec_and_test(&sc->send_io.pending.count))
-		wake_up(&sc->send_io.pending.wait_queue);
+		wake_up(&sc->send_io.pending.zero_wait_queue);
+
+	wake_up(&sc->send_io.pending.dec_wait_queue);

  	mempool_free(request, sc->send_io.mem.pool);
  }
@@ -1017,6 +1019,23 @@ static int smbd_post_send_iter(struct smbdirect_socket *sc,
  		goto wait_credit;
  	}

+wait_send_queue:
+	wait_event(sc->send_io.pending.dec_wait_queue,
+		atomic_read(&sc->send_io.pending.count) < sp->send_credit_target ||
+		sc->status != SMBDIRECT_SOCKET_CONNECTED);
+
+	if (sc->status != SMBDIRECT_SOCKET_CONNECTED) {
+		log_outgoing(ERR, "disconnected not sending on wait_send_queue\n");
+		rc = -EAGAIN;
+		goto err_wait_send_queue;
+	}
+
+	if (unlikely(atomic_inc_return(&sc->send_io.pending.count) >
+				sp->send_credit_target)) {
+		atomic_dec(&sc->send_io.pending.count);
+		goto wait_send_queue;
+	}
+
  	request = mempool_alloc(sc->send_io.mem.pool, GFP_KERNEL);
  	if (!request) {
  		rc = -ENOMEM;
@@ -1098,14 +1117,10 @@ static int smbd_post_send_iter(struct smbdirect_socket *sc,
  	request->sge[0].length = header_length;
  	request->sge[0].lkey = sc->ib.pd->local_dma_lkey;

-	atomic_inc(&sc->send_io.pending.count);
  	rc = smbd_post_send(sc, request);
  	if (!rc)
  		return 0;

-	if (atomic_dec_and_test(&sc->send_io.pending.count))
-		wake_up(&sc->send_io.pending.wait_queue);
-
  err_dma:
  	for (i = 0; i < request->num_sge; i++)
  		if (request->sge[i].addr)
@@ -1119,7 +1134,10 @@ static int smbd_post_send_iter(struct smbdirect_socket *sc,
  	atomic_sub(new_credits, &sc->recv_io.credits.count);

  err_alloc:
+	if (atomic_dec_and_test(&sc->send_io.pending.count))
+		wake_up(&sc->send_io.pending.zero_wait_queue);

+err_wait_send_queue:
  	/* roll back send credits and pending */
  	atomic_inc(&sc->send_io.credits.count);

@@ -2118,7 +2136,7 @@ int smbd_send(struct TCP_Server_Info *server,
  	 * that means all the I/Os have been out and we are good to return
  	 */

-	wait_event(sc->send_io.pending.wait_queue,
+	wait_event(sc->send_io.pending.zero_wait_queue,
  		atomic_read(&sc->send_io.pending.count) == 0 ||
  		sc->status != SMBDIRECT_SOCKET_CONNECTED);

diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index c62d12f63e13..8542de12002a 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -28,6 +28,49 @@ enum smbdirect_socket_status {
  	SMBDIRECT_SOCKET_DESTROYED
  };

+static __always_inline
+const char *smbdirect_socket_status_string(enum smbdirect_socket_status status)
+{
+	switch (status) {
+	case SMBDIRECT_SOCKET_CREATED:
+		return "CREATED";
+	case SMBDIRECT_SOCKET_RESOLVE_ADDR_NEEDED:
+		return "RESOLVE_ADDR_NEEDED";
+	case SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING:
+		return "RESOLVE_ADDR_RUNNING";
+	case SMBDIRECT_SOCKET_RESOLVE_ADDR_FAILED:
+		return "RESOLVE_ADDR_FAILED";
+	case SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED:
+		return "RESOLVE_ROUTE_NEEDED";
+	case SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING:
+		return "RESOLVE_ROUTE_RUNNING";
+	case SMBDIRECT_SOCKET_RESOLVE_ROUTE_FAILED:
+		return "RESOLVE_ROUTE_FAILED";
+	case SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED:
+		return "RDMA_CONNECT_NEEDED";
+	case SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING:
+		return "RDMA_CONNECT_RUNNING";
+	case SMBDIRECT_SOCKET_RDMA_CONNECT_FAILED:
+		return "RDMA_CONNECT_FAILED";
+	case SMBDIRECT_SOCKET_NEGOTIATE_NEEDED:
+		return "NEGOTIATE_NEEDED";
+	case SMBDIRECT_SOCKET_NEGOTIATE_RUNNING:
+		return "NEGOTIATE_RUNNING";
+	case SMBDIRECT_SOCKET_NEGOTIATE_FAILED:
+		return "NEGOTIATE_FAILED";
+	case SMBDIRECT_SOCKET_CONNECTED:
+		return "CONNECTED";
+	case SMBDIRECT_SOCKET_DISCONNECTING:
+		return "DISCONNECTING";
+	case SMBDIRECT_SOCKET_DISCONNECTED:
+		return "DISCONNECTED,";
+	case SMBDIRECT_SOCKET_DESTROYED:
+		return "DESTROYED";
+	}
+
+	return "<unknown>";
+}
+
  enum smbdirect_keepalive_status {
  	SMBDIRECT_KEEPALIVE_NONE,
  	SMBDIRECT_KEEPALIVE_PENDING,
@@ -107,7 +150,14 @@ struct smbdirect_socket {
  		 */
  		struct {
  			atomic_t count;
-			wait_queue_head_t wait_queue;
+			/*
+			 * woken when count is decremented
+			 */
+			wait_queue_head_t dec_wait_queue;
+			/*
+			 * woken when count reached zero
+			 */
+			wait_queue_head_t zero_wait_queue;
  		} pending;
  	} send_io;

@@ -271,7 +321,8 @@ static __always_inline void smbdirect_socket_init(struct smbdirect_socket *sc)
  	init_waitqueue_head(&sc->send_io.credits.wait_queue);

  	atomic_set(&sc->send_io.pending.count, 0);
-	init_waitqueue_head(&sc->send_io.pending.wait_queue);
+	init_waitqueue_head(&sc->send_io.pending.dec_wait_queue);
+	init_waitqueue_head(&sc->send_io.pending.zero_wait_queue);

  	INIT_LIST_HEAD(&sc->recv_io.free.list);
  	spin_lock_init(&sc->recv_io.free.lock);
diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 6e4c2bf7dd93..33d2f5bdb827 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -366,7 +366,7 @@ static void free_transport(struct smb_direct_transport *t)
  	}

  	wake_up_all(&sc->send_io.credits.wait_queue);
-	wake_up_all(&sc->send_io.pending.wait_queue);
+	wake_up_all(&sc->send_io.pending.zero_wait_queue);

  	disable_work_sync(&sc->recv_io.posted.refill_work);
  	disable_delayed_work_sync(&sc->idle.timer_work);
@@ -818,7 +818,7 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
  	}

  	if (atomic_dec_and_test(&sc->send_io.pending.count))
-		wake_up(&sc->send_io.pending.wait_queue);
+		wake_up(&sc->send_io.pending.zero_wait_queue);

  	/* iterate and free the list of messages in reverse. the list's head
  	 * is invalid.
@@ -879,7 +879,7 @@ static int smb_direct_post_send(struct smbdirect_socket *sc,
  	if (ret) {
  		pr_err("failed to post send: %d\n", ret);
  		if (atomic_dec_and_test(&sc->send_io.pending.count))
-			wake_up(&sc->send_io.pending.wait_queue);
+			wake_up(&sc->send_io.pending.zero_wait_queue);
  		smb_direct_disconnect_rdma_connection(sc);
  	}
  	return ret;
@@ -1206,78 +1206,130 @@ static int smb_direct_writev(struct ksmbd_transport *t,
  	struct smb_direct_transport *st = SMBD_TRANS(t);
  	struct smbdirect_socket *sc = &st->socket;
  	struct smbdirect_socket_parameters *sp = &sc->parameters;
-	int remaining_data_length;
-	int start, i, j;
-	int max_iov_size = sp->max_send_size -
+	size_t remaining_data_length;
+	size_t iov_idx;
+	size_t iov_ofs;
+	size_t max_iov_size = sp->max_send_size -
  			sizeof(struct smbdirect_data_transfer);
  	int ret;
-	struct kvec vec;
  	struct smbdirect_send_batch send_ctx;
+	int error = 0;

  	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
  		return -ENOTCONN;

  	//FIXME: skip RFC1002 header..
+	if (WARN_ON_ONCE(niovs <= 1 || iov[0].iov_len != 4))
+		return -EINVAL;
  	buflen -= 4;
+	iov_idx = 1;
+	iov_ofs = 0;

  	remaining_data_length = buflen;
  	ksmbd_debug(RDMA, "Sending smb (RDMA): smb_len=%u\n", buflen);

  	smb_direct_send_ctx_init(&send_ctx, need_invalidate, remote_key);
-	start = i = 1;
-	buflen = 0;
-	while (true) {
-		buflen += iov[i].iov_len;
-		if (buflen > max_iov_size) {
-			if (i > start) {
-				remaining_data_length -=
-					(buflen - iov[i].iov_len);
-				ret = smb_direct_post_send_data(sc, &send_ctx,
-								&iov[start], i - start,
-								remaining_data_length);
-				if (ret)
+	while (remaining_data_length) {
+		struct kvec vecs[SMBDIRECT_SEND_IO_MAX_SGE - 1]; /* minus smbdirect hdr */
+		size_t possible_bytes = max_iov_size;
+		size_t possible_vecs;
+		size_t bytes = 0;
+		size_t nvecs = 0;
+
+		/*
+		 * For the last message remaining_data_length should be
+		 * have been 0 already!
+		 */
+		if (WARN_ON_ONCE(iov_idx >= niovs)) {
+			error = -EINVAL;
+			goto done;
+		}
+
+		/*
+		 * We have 2 factors which limit the arguments we pass
+		 * to smb_direct_post_send_data():
+		 *
+		 * 1. The number of supported sges for the send,
+		 *    while one is reserved for the smbdirect header.
+		 *    And we currently need one SGE per page.
+		 * 2. The number of negotiated payload bytes per send.
+		 */
+		possible_vecs = min_t(size_t, ARRAY_SIZE(vecs), niovs - iov_idx);
+
+		while (iov_idx < niovs && possible_vecs && possible_bytes) {
+			struct kvec *v = &vecs[nvecs];
+			int page_count;
+
+			v->iov_base = ((u8 *)iov[iov_idx].iov_base) + iov_ofs;
+			v->iov_len = min_t(size_t,
+					   iov[iov_idx].iov_len - iov_ofs,
+					   possible_bytes);
+			page_count = get_buf_page_count(v->iov_base, v->iov_len);
+			if (page_count > possible_vecs) {
+				/*
+				 * If the number of pages in the buffer
+				 * is to much (because we currently require
+				 * one SGE per page), we need to limit the
+				 * length.
+				 *
+				 * We know possible_vecs is at least 1,
+				 * so we always keep the first page.
+				 *
+				 * We need to calculate the number extra
+				 * pages (epages) we can also keep.
+				 *
+				 * We calculate the number of bytes in the
+				 * first page (fplen), this should never be
+				 * larger than v->iov_len because page_count is
+				 * at least 2, but adding a limitation feels
+				 * better.
+				 *
+				 * Then we calculate the number of bytes (elen)
+				 * we can keep for the extra pages.
+				 */
+				size_t epages = possible_vecs - 1;
+				size_t fpofs = offset_in_page(v->iov_base);
+				size_t fplen = min_t(size_t, PAGE_SIZE - fpofs, v->iov_len);
+				size_t elen = min_t(size_t, v->iov_len - fplen, epages*PAGE_SIZE);
+
+				v->iov_len = fplen + elen;
+				page_count = get_buf_page_count(v->iov_base, v->iov_len);
+				if (WARN_ON_ONCE(page_count > possible_vecs)) {
+					/*
+					 * Something went wrong in the above
+					 * logic...
+					 */
+					error = -EINVAL;
  					goto done;
-			} else {
-				/* iov[start] is too big, break it */
-				int nvec  = (buflen + max_iov_size - 1) /
-						max_iov_size;
-
-				for (j = 0; j < nvec; j++) {
-					vec.iov_base =
-						(char *)iov[start].iov_base +
-						j * max_iov_size;
-					vec.iov_len =
-						min_t(int, max_iov_size,
-						      buflen - max_iov_size * j);
-					remaining_data_length -= vec.iov_len;
-					ret = smb_direct_post_send_data(sc, &send_ctx, &vec, 1,
-									remaining_data_length);
-					if (ret)
-						goto done;
  				}
-				i++;
-				if (i == niovs)
-					break;
  			}
-			start = i;
-			buflen = 0;
-		} else {
-			i++;
-			if (i == niovs) {
-				/* send out all remaining vecs */
-				remaining_data_length -= buflen;
-				ret = smb_direct_post_send_data(sc, &send_ctx,
-								&iov[start], i - start,
-								remaining_data_length);
-				if (ret)
-					goto done;
-				break;
+			possible_vecs -= page_count;
+			nvecs += 1;
+			possible_bytes -= v->iov_len;
+			bytes += v->iov_len;
+
+			iov_ofs += v->iov_len;
+			if (iov_ofs >= iov[iov_idx].iov_len) {
+				iov_idx += 1;
+				iov_ofs = 0;
  			}
  		}
+
+		remaining_data_length -= bytes;
+
+		ret = smb_direct_post_send_data(sc, &send_ctx,
+						vecs, nvecs,
+						remaining_data_length);
+		if (unlikely(ret)) {
+			error = ret;
+			goto done;
+		}
  	}

  done:
  	ret = smb_direct_flush_send_list(sc, &send_ctx, true);
+	if (unlikely(!ret && error))
+		ret = error;

  	/*
  	 * As an optimization, we don't wait for individual I/O to finish
@@ -1286,7 +1338,7 @@ static int smb_direct_writev(struct ksmbd_transport *t,
  	 * that means all the I/Os have been out and we are good to return
  	 */

-	wait_event(sc->send_io.pending.wait_queue,
+	wait_event(sc->send_io.pending.zero_wait_queue,
  		   atomic_read(&sc->send_io.pending.count) == 0 ||
  		   sc->status != SMBDIRECT_SOCKET_CONNECTED);
  	if (sc->status != SMBDIRECT_SOCKET_CONNECTED && ret == 0)
@@ -1620,7 +1672,7 @@ static int smb_direct_send_negotiate_response(struct smbdirect_socket *sc,
  		return ret;
  	}

-	wait_event(sc->send_io.pending.wait_queue,
+	wait_event(sc->send_io.pending.zero_wait_queue,
  		   atomic_read(&sc->send_io.pending.count) == 0 ||
  		   sc->status != SMBDIRECT_SOCKET_CONNECTED);
  	if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
@@ -1773,6 +1825,11 @@ static int smb_direct_init_params(struct smbdirect_socket *sc,
  		return -EINVAL;
  	}

+	if (device->attrs.max_send_sge < SMBDIRECT_SEND_IO_MAX_SGE) {
+		pr_err("warning: device max_send_sge = %d too small\n",
+		       device->attrs.max_send_sge);
+		return -EINVAL;
+	}
  	if (device->attrs.max_recv_sge < SMBDIRECT_RECV_IO_MAX_SGE) {
  		pr_err("warning: device max_recv_sge = %d too small\n",
  		       device->attrs.max_recv_sge);
@@ -1785,7 +1842,7 @@ static int smb_direct_init_params(struct smbdirect_socket *sc,

  	cap->max_send_wr = max_send_wrs;
  	cap->max_recv_wr = sp->recv_credit_max;
-	cap->max_send_sge = max_sge_per_wr;
+	cap->max_send_sge = SMBDIRECT_SEND_IO_MAX_SGE;
  	cap->max_recv_sge = SMBDIRECT_RECV_IO_MAX_SGE;
  	cap->max_inline_data = 0;
  	cap->max_rdma_ctxs = sc->rw_io.credits.max;

Re: replace for-next-next... Re: [PATCH v4 000/142] smb: smbdirect/client/server: make use of common structures

[Namjae Jeon]

On Tue, Sep 9, 2025 at 1:08 AM Stefan Metzmacher <metze@samba.org> wrote:
>
> Hi Steve,
>
> here's the branch that could replace your
> for-next-next (6eede6a6805fb50e3131b4b8182e10a17c9005b1)
>
> git fetch https://git.samba.org/metze/linux/wip.git for-6.18/fs-smb-20250908-v5
> (d762704985c3bd93e2d2e9ab224f5795baea63e1)
>
> https://git.samba.org/?p=metze/linux/wip.git;a=shortlog;h=refs/heads/for-6.18/fs-smb-20250908-v5
Very nice. It will make it easier to review your patches also.
And please Cc me on your smb client patches too.
Thanks.
>
> The first 3 patches are the main reason why the rebase is needed.
> 7a9cd9e986c1f6ce3a64f4329b2e795bf24752ae smb: server: let smb_direct_writev() respect SMB_DIRECT_MAX_SEND_SGES
> 329efe5eb73f7b7604dab6b08f16bb6c3e500690 smb: smbdirect: introduce smbdirect_socket_status_string()
> ab7a3a9ece72bce4f601d6224aa9243b7e090ca9 smb: client: adjust smbdirect related output of cifs_debug_data_proc_show()
>
> In addition send_io.pending.wait_queue is changed to send_io.pending.zero_wait_queue to indicate
> it's woken when count gets zero.
>
> send_io.pending.dec_wait_queue is introduced to replace info->wait_post_send instead of dropping
> the logic around it, that gets woken on every decrement.
>
> The diff between the branches below:
>
> Please replace your for-next-next if you're happy.
>
> Thanks!
> metze
>
>   fs/smb/client/cifs_debug.c                 |  41 +++----
>   fs/smb/client/smbdirect.c                  |  30 ++++--
>   fs/smb/common/smbdirect/smbdirect_socket.h |  55 +++++++++-
>   fs/smb/server/transport_rdma.c             | 167 +++++++++++++++++++----------
>   4 files changed, 210 insertions(+), 83 deletions(-)
>
> diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
> index b4d70b51c456..35c4d27d2cc0 100644
> --- a/fs/smb/client/cifs_debug.c
> +++ b/fs/smb/client/cifs_debug.c
> @@ -457,52 +457,53 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
>                 sc = &server->smbd_conn->socket;
>                 sp = &sc->parameters;
>
> -               seq_printf(m, "\nSMBDirect (in hex) protocol version: %x "
> -                       "transport status: %x",
> +               seq_printf(m, "\nSMBDirect protocol version: 0x%x "
> +                       "transport status: %s (%u)",
>                         SMBDIRECT_V1,
> +                       smbdirect_socket_status_string(sc->status),
>                         sc->status);
> -               seq_printf(m, "\nConn receive_credit_max: %x "
> -                       "send_credit_target: %x max_send_size: %x",
> +               seq_printf(m, "\nConn receive_credit_max: %u "
> +                       "send_credit_target: %u max_send_size: %u",
>                         sp->recv_credit_max,
>                         sp->send_credit_target,
>                         sp->max_send_size);
> -               seq_printf(m, "\nConn max_fragmented_recv_size: %x "
> -                       "max_fragmented_send_size: %x max_receive_size:%x",
> +               seq_printf(m, "\nConn max_fragmented_recv_size: %u "
> +                       "max_fragmented_send_size: %u max_receive_size:%u",
>                         sp->max_fragmented_recv_size,
>                         sp->max_fragmented_send_size,
>                         sp->max_recv_size);
> -               seq_printf(m, "\nConn keep_alive_interval: %x "
> -                       "max_readwrite_size: %x rdma_readwrite_threshold: %x",
> +               seq_printf(m, "\nConn keep_alive_interval: %u "
> +                       "max_readwrite_size: %u rdma_readwrite_threshold: %u",
>                         sp->keepalive_interval_msec * 1000,
>                         sp->max_read_write_size,
>                         server->rdma_readwrite_threshold);
> -               seq_printf(m, "\nDebug count_get_receive_buffer: %llx "
> -                       "count_put_receive_buffer: %llx count_send_empty: %llx",
> +               seq_printf(m, "\nDebug count_get_receive_buffer: %llu "
> +                       "count_put_receive_buffer: %llu count_send_empty: %llu",
>                         sc->statistics.get_receive_buffer,
>                         sc->statistics.put_receive_buffer,
>                         sc->statistics.send_empty);
>                 seq_printf(m, "\nRead Queue "
> -                       "count_enqueue_reassembly_queue: %llx "
> -                       "count_dequeue_reassembly_queue: %llx "
> -                       "reassembly_data_length: %x "
> -                       "reassembly_queue_length: %x",
> +                       "count_enqueue_reassembly_queue: %llu "
> +                       "count_dequeue_reassembly_queue: %llu "
> +                       "reassembly_data_length: %u "
> +                       "reassembly_queue_length: %u",
>                         sc->statistics.enqueue_reassembly_queue,
>                         sc->statistics.dequeue_reassembly_queue,
>                         sc->recv_io.reassembly.data_length,
>                         sc->recv_io.reassembly.queue_length);
> -               seq_printf(m, "\nCurrent Credits send_credits: %x "
> -                       "receive_credits: %x receive_credit_target: %x",
> +               seq_printf(m, "\nCurrent Credits send_credits: %u "
> +                       "receive_credits: %u receive_credit_target: %u",
>                         atomic_read(&sc->send_io.credits.count),
>                         atomic_read(&sc->recv_io.credits.count),
>                         sc->recv_io.credits.target);
> -               seq_printf(m, "\nPending send_pending: %x ",
> +               seq_printf(m, "\nPending send_pending: %u ",
>                         atomic_read(&sc->send_io.pending.count));
> -               seq_printf(m, "\nMR responder_resources: %x "
> -                       "max_frmr_depth: %x mr_type: %x",
> +               seq_printf(m, "\nMR responder_resources: %u "
> +                       "max_frmr_depth: %u mr_type: 0x%x",
>                         sp->responder_resources,
>                         sp->max_frmr_depth,
>                         sc->mr_io.type);
> -               seq_printf(m, "\nMR mr_ready_count: %x mr_used_count: %x",
> +               seq_printf(m, "\nMR mr_ready_count: %u mr_used_count: %u",
>                         atomic_read(&sc->mr_io.ready.count),
>                         atomic_read(&sc->mr_io.used.count));
>   skip_rdma:
> diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
> index d3cd89bd2cc7..322334097e30 100644
> --- a/fs/smb/client/smbdirect.c
> +++ b/fs/smb/client/smbdirect.c
> @@ -412,7 +412,9 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
>         }
>
>         if (atomic_dec_and_test(&sc->send_io.pending.count))
> -               wake_up(&sc->send_io.pending.wait_queue);
> +               wake_up(&sc->send_io.pending.zero_wait_queue);
> +
> +       wake_up(&sc->send_io.pending.dec_wait_queue);
>
>         mempool_free(request, sc->send_io.mem.pool);
>   }
> @@ -1017,6 +1019,23 @@ static int smbd_post_send_iter(struct smbdirect_socket *sc,
>                 goto wait_credit;
>         }
>
> +wait_send_queue:
> +       wait_event(sc->send_io.pending.dec_wait_queue,
> +               atomic_read(&sc->send_io.pending.count) < sp->send_credit_target ||
> +               sc->status != SMBDIRECT_SOCKET_CONNECTED);
> +
> +       if (sc->status != SMBDIRECT_SOCKET_CONNECTED) {
> +               log_outgoing(ERR, "disconnected not sending on wait_send_queue\n");
> +               rc = -EAGAIN;
> +               goto err_wait_send_queue;
> +       }
> +
> +       if (unlikely(atomic_inc_return(&sc->send_io.pending.count) >
> +                               sp->send_credit_target)) {
> +               atomic_dec(&sc->send_io.pending.count);
> +               goto wait_send_queue;
> +       }
> +
>         request = mempool_alloc(sc->send_io.mem.pool, GFP_KERNEL);
>         if (!request) {
>                 rc = -ENOMEM;
> @@ -1098,14 +1117,10 @@ static int smbd_post_send_iter(struct smbdirect_socket *sc,
>         request->sge[0].length = header_length;
>         request->sge[0].lkey = sc->ib.pd->local_dma_lkey;
>
> -       atomic_inc(&sc->send_io.pending.count);
>         rc = smbd_post_send(sc, request);
>         if (!rc)
>                 return 0;
>
> -       if (atomic_dec_and_test(&sc->send_io.pending.count))
> -               wake_up(&sc->send_io.pending.wait_queue);
> -
>   err_dma:
>         for (i = 0; i < request->num_sge; i++)
>                 if (request->sge[i].addr)
> @@ -1119,7 +1134,10 @@ static int smbd_post_send_iter(struct smbdirect_socket *sc,
>         atomic_sub(new_credits, &sc->recv_io.credits.count);
>
>   err_alloc:
> +       if (atomic_dec_and_test(&sc->send_io.pending.count))
> +               wake_up(&sc->send_io.pending.zero_wait_queue);
>
> +err_wait_send_queue:
>         /* roll back send credits and pending */
>         atomic_inc(&sc->send_io.credits.count);
>
> @@ -2118,7 +2136,7 @@ int smbd_send(struct TCP_Server_Info *server,
>          * that means all the I/Os have been out and we are good to return
>          */
>
> -       wait_event(sc->send_io.pending.wait_queue,
> +       wait_event(sc->send_io.pending.zero_wait_queue,
>                 atomic_read(&sc->send_io.pending.count) == 0 ||
>                 sc->status != SMBDIRECT_SOCKET_CONNECTED);
>
> diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
> index c62d12f63e13..8542de12002a 100644
> --- a/fs/smb/common/smbdirect/smbdirect_socket.h
> +++ b/fs/smb/common/smbdirect/smbdirect_socket.h
> @@ -28,6 +28,49 @@ enum smbdirect_socket_status {
>         SMBDIRECT_SOCKET_DESTROYED
>   };
>
> +static __always_inline
> +const char *smbdirect_socket_status_string(enum smbdirect_socket_status status)
> +{
> +       switch (status) {
> +       case SMBDIRECT_SOCKET_CREATED:
> +               return "CREATED";
> +       case SMBDIRECT_SOCKET_RESOLVE_ADDR_NEEDED:
> +               return "RESOLVE_ADDR_NEEDED";
> +       case SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING:
> +               return "RESOLVE_ADDR_RUNNING";
> +       case SMBDIRECT_SOCKET_RESOLVE_ADDR_FAILED:
> +               return "RESOLVE_ADDR_FAILED";
> +       case SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED:
> +               return "RESOLVE_ROUTE_NEEDED";
> +       case SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING:
> +               return "RESOLVE_ROUTE_RUNNING";
> +       case SMBDIRECT_SOCKET_RESOLVE_ROUTE_FAILED:
> +               return "RESOLVE_ROUTE_FAILED";
> +       case SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED:
> +               return "RDMA_CONNECT_NEEDED";
> +       case SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING:
> +               return "RDMA_CONNECT_RUNNING";
> +       case SMBDIRECT_SOCKET_RDMA_CONNECT_FAILED:
> +               return "RDMA_CONNECT_FAILED";
> +       case SMBDIRECT_SOCKET_NEGOTIATE_NEEDED:
> +               return "NEGOTIATE_NEEDED";
> +       case SMBDIRECT_SOCKET_NEGOTIATE_RUNNING:
> +               return "NEGOTIATE_RUNNING";
> +       case SMBDIRECT_SOCKET_NEGOTIATE_FAILED:
> +               return "NEGOTIATE_FAILED";
> +       case SMBDIRECT_SOCKET_CONNECTED:
> +               return "CONNECTED";
> +       case SMBDIRECT_SOCKET_DISCONNECTING:
> +               return "DISCONNECTING";
> +       case SMBDIRECT_SOCKET_DISCONNECTED:
> +               return "DISCONNECTED,";
> +       case SMBDIRECT_SOCKET_DESTROYED:
> +               return "DESTROYED";
> +       }
> +
> +       return "<unknown>";
> +}
> +
>   enum smbdirect_keepalive_status {
>         SMBDIRECT_KEEPALIVE_NONE,
>         SMBDIRECT_KEEPALIVE_PENDING,
> @@ -107,7 +150,14 @@ struct smbdirect_socket {
>                  */
>                 struct {
>                         atomic_t count;
> -                       wait_queue_head_t wait_queue;
> +                       /*
> +                        * woken when count is decremented
> +                        */
> +                       wait_queue_head_t dec_wait_queue;
> +                       /*
> +                        * woken when count reached zero
> +                        */
> +                       wait_queue_head_t zero_wait_queue;
>                 } pending;
>         } send_io;
>
> @@ -271,7 +321,8 @@ static __always_inline void smbdirect_socket_init(struct smbdirect_socket *sc)
>         init_waitqueue_head(&sc->send_io.credits.wait_queue);
>
>         atomic_set(&sc->send_io.pending.count, 0);
> -       init_waitqueue_head(&sc->send_io.pending.wait_queue);
> +       init_waitqueue_head(&sc->send_io.pending.dec_wait_queue);
> +       init_waitqueue_head(&sc->send_io.pending.zero_wait_queue);
>
>         INIT_LIST_HEAD(&sc->recv_io.free.list);
>         spin_lock_init(&sc->recv_io.free.lock);
> diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
> index 6e4c2bf7dd93..33d2f5bdb827 100644
> --- a/fs/smb/server/transport_rdma.c
> +++ b/fs/smb/server/transport_rdma.c
> @@ -366,7 +366,7 @@ static void free_transport(struct smb_direct_transport *t)
>         }
>
>         wake_up_all(&sc->send_io.credits.wait_queue);
> -       wake_up_all(&sc->send_io.pending.wait_queue);
> +       wake_up_all(&sc->send_io.pending.zero_wait_queue);
>
>         disable_work_sync(&sc->recv_io.posted.refill_work);
>         disable_delayed_work_sync(&sc->idle.timer_work);
> @@ -818,7 +818,7 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
>         }
>
>         if (atomic_dec_and_test(&sc->send_io.pending.count))
> -               wake_up(&sc->send_io.pending.wait_queue);
> +               wake_up(&sc->send_io.pending.zero_wait_queue);
>
>         /* iterate and free the list of messages in reverse. the list's head
>          * is invalid.
> @@ -879,7 +879,7 @@ static int smb_direct_post_send(struct smbdirect_socket *sc,
>         if (ret) {
>                 pr_err("failed to post send: %d\n", ret);
>                 if (atomic_dec_and_test(&sc->send_io.pending.count))
> -                       wake_up(&sc->send_io.pending.wait_queue);
> +                       wake_up(&sc->send_io.pending.zero_wait_queue);
>                 smb_direct_disconnect_rdma_connection(sc);
>         }
>         return ret;
> @@ -1206,78 +1206,130 @@ static int smb_direct_writev(struct ksmbd_transport *t,
>         struct smb_direct_transport *st = SMBD_TRANS(t);
>         struct smbdirect_socket *sc = &st->socket;
>         struct smbdirect_socket_parameters *sp = &sc->parameters;
> -       int remaining_data_length;
> -       int start, i, j;
> -       int max_iov_size = sp->max_send_size -
> +       size_t remaining_data_length;
> +       size_t iov_idx;
> +       size_t iov_ofs;
> +       size_t max_iov_size = sp->max_send_size -
>                         sizeof(struct smbdirect_data_transfer);
>         int ret;
> -       struct kvec vec;
>         struct smbdirect_send_batch send_ctx;
> +       int error = 0;
>
>         if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
>                 return -ENOTCONN;
>
>         //FIXME: skip RFC1002 header..
> +       if (WARN_ON_ONCE(niovs <= 1 || iov[0].iov_len != 4))
> +               return -EINVAL;
>         buflen -= 4;
> +       iov_idx = 1;
> +       iov_ofs = 0;
>
>         remaining_data_length = buflen;
>         ksmbd_debug(RDMA, "Sending smb (RDMA): smb_len=%u\n", buflen);
>
>         smb_direct_send_ctx_init(&send_ctx, need_invalidate, remote_key);
> -       start = i = 1;
> -       buflen = 0;
> -       while (true) {
> -               buflen += iov[i].iov_len;
> -               if (buflen > max_iov_size) {
> -                       if (i > start) {
> -                               remaining_data_length -=
> -                                       (buflen - iov[i].iov_len);
> -                               ret = smb_direct_post_send_data(sc, &send_ctx,
> -                                                               &iov[start], i - start,
> -                                                               remaining_data_length);
> -                               if (ret)
> +       while (remaining_data_length) {
> +               struct kvec vecs[SMBDIRECT_SEND_IO_MAX_SGE - 1]; /* minus smbdirect hdr */
> +               size_t possible_bytes = max_iov_size;
> +               size_t possible_vecs;
> +               size_t bytes = 0;
> +               size_t nvecs = 0;
> +
> +               /*
> +                * For the last message remaining_data_length should be
> +                * have been 0 already!
> +                */
> +               if (WARN_ON_ONCE(iov_idx >= niovs)) {
> +                       error = -EINVAL;
> +                       goto done;
> +               }
> +
> +               /*
> +                * We have 2 factors which limit the arguments we pass
> +                * to smb_direct_post_send_data():
> +                *
> +                * 1. The number of supported sges for the send,
> +                *    while one is reserved for the smbdirect header.
> +                *    And we currently need one SGE per page.
> +                * 2. The number of negotiated payload bytes per send.
> +                */
> +               possible_vecs = min_t(size_t, ARRAY_SIZE(vecs), niovs - iov_idx);
> +
> +               while (iov_idx < niovs && possible_vecs && possible_bytes) {
> +                       struct kvec *v = &vecs[nvecs];
> +                       int page_count;
> +
> +                       v->iov_base = ((u8 *)iov[iov_idx].iov_base) + iov_ofs;
> +                       v->iov_len = min_t(size_t,
> +                                          iov[iov_idx].iov_len - iov_ofs,
> +                                          possible_bytes);
> +                       page_count = get_buf_page_count(v->iov_base, v->iov_len);
> +                       if (page_count > possible_vecs) {
> +                               /*
> +                                * If the number of pages in the buffer
> +                                * is to much (because we currently require
> +                                * one SGE per page), we need to limit the
> +                                * length.
> +                                *
> +                                * We know possible_vecs is at least 1,
> +                                * so we always keep the first page.
> +                                *
> +                                * We need to calculate the number extra
> +                                * pages (epages) we can also keep.
> +                                *
> +                                * We calculate the number of bytes in the
> +                                * first page (fplen), this should never be
> +                                * larger than v->iov_len because page_count is
> +                                * at least 2, but adding a limitation feels
> +                                * better.
> +                                *
> +                                * Then we calculate the number of bytes (elen)
> +                                * we can keep for the extra pages.
> +                                */
> +                               size_t epages = possible_vecs - 1;
> +                               size_t fpofs = offset_in_page(v->iov_base);
> +                               size_t fplen = min_t(size_t, PAGE_SIZE - fpofs, v->iov_len);
> +                               size_t elen = min_t(size_t, v->iov_len - fplen, epages*PAGE_SIZE);
> +
> +                               v->iov_len = fplen + elen;
> +                               page_count = get_buf_page_count(v->iov_base, v->iov_len);
> +                               if (WARN_ON_ONCE(page_count > possible_vecs)) {
> +                                       /*
> +                                        * Something went wrong in the above
> +                                        * logic...
> +                                        */
> +                                       error = -EINVAL;
>                                         goto done;
> -                       } else {
> -                               /* iov[start] is too big, break it */
> -                               int nvec  = (buflen + max_iov_size - 1) /
> -                                               max_iov_size;
> -
> -                               for (j = 0; j < nvec; j++) {
> -                                       vec.iov_base =
> -                                               (char *)iov[start].iov_base +
> -                                               j * max_iov_size;
> -                                       vec.iov_len =
> -                                               min_t(int, max_iov_size,
> -                                                     buflen - max_iov_size * j);
> -                                       remaining_data_length -= vec.iov_len;
> -                                       ret = smb_direct_post_send_data(sc, &send_ctx, &vec, 1,
> -                                                                       remaining_data_length);
> -                                       if (ret)
> -                                               goto done;
>                                 }
> -                               i++;
> -                               if (i == niovs)
> -                                       break;
>                         }
> -                       start = i;
> -                       buflen = 0;
> -               } else {
> -                       i++;
> -                       if (i == niovs) {
> -                               /* send out all remaining vecs */
> -                               remaining_data_length -= buflen;
> -                               ret = smb_direct_post_send_data(sc, &send_ctx,
> -                                                               &iov[start], i - start,
> -                                                               remaining_data_length);
> -                               if (ret)
> -                                       goto done;
> -                               break;
> +                       possible_vecs -= page_count;
> +                       nvecs += 1;
> +                       possible_bytes -= v->iov_len;
> +                       bytes += v->iov_len;
> +
> +                       iov_ofs += v->iov_len;
> +                       if (iov_ofs >= iov[iov_idx].iov_len) {
> +                               iov_idx += 1;
> +                               iov_ofs = 0;
>                         }
>                 }
> +
> +               remaining_data_length -= bytes;
> +
> +               ret = smb_direct_post_send_data(sc, &send_ctx,
> +                                               vecs, nvecs,
> +                                               remaining_data_length);
> +               if (unlikely(ret)) {
> +                       error = ret;
> +                       goto done;
> +               }
>         }
>
>   done:
>         ret = smb_direct_flush_send_list(sc, &send_ctx, true);
> +       if (unlikely(!ret && error))
> +               ret = error;
>
>         /*
>          * As an optimization, we don't wait for individual I/O to finish
> @@ -1286,7 +1338,7 @@ static int smb_direct_writev(struct ksmbd_transport *t,
>          * that means all the I/Os have been out and we are good to return
>          */
>
> -       wait_event(sc->send_io.pending.wait_queue,
> +       wait_event(sc->send_io.pending.zero_wait_queue,
>                    atomic_read(&sc->send_io.pending.count) == 0 ||
>                    sc->status != SMBDIRECT_SOCKET_CONNECTED);
>         if (sc->status != SMBDIRECT_SOCKET_CONNECTED && ret == 0)
> @@ -1620,7 +1672,7 @@ static int smb_direct_send_negotiate_response(struct smbdirect_socket *sc,
>                 return ret;
>         }
>
> -       wait_event(sc->send_io.pending.wait_queue,
> +       wait_event(sc->send_io.pending.zero_wait_queue,
>                    atomic_read(&sc->send_io.pending.count) == 0 ||
>                    sc->status != SMBDIRECT_SOCKET_CONNECTED);
>         if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
> @@ -1773,6 +1825,11 @@ static int smb_direct_init_params(struct smbdirect_socket *sc,
>                 return -EINVAL;
>         }
>
> +       if (device->attrs.max_send_sge < SMBDIRECT_SEND_IO_MAX_SGE) {
> +               pr_err("warning: device max_send_sge = %d too small\n",
> +                      device->attrs.max_send_sge);
> +               return -EINVAL;
> +       }
>         if (device->attrs.max_recv_sge < SMBDIRECT_RECV_IO_MAX_SGE) {
>                 pr_err("warning: device max_recv_sge = %d too small\n",
>                        device->attrs.max_recv_sge);
> @@ -1785,7 +1842,7 @@ static int smb_direct_init_params(struct smbdirect_socket *sc,
>
>         cap->max_send_wr = max_send_wrs;
>         cap->max_recv_wr = sp->recv_credit_max;
> -       cap->max_send_sge = max_sge_per_wr;
> +       cap->max_send_sge = SMBDIRECT_SEND_IO_MAX_SGE;
>         cap->max_recv_sge = SMBDIRECT_RECV_IO_MAX_SGE;
>         cap->max_inline_data = 0;
>         cap->max_rdma_ctxs = sc->rw_io.credits.max;
>
>

Re: replace for-next-next... Re: [PATCH v4 000/142] smb: smbdirect/client/server: make use of common structures

[Steve French]

updated for-next-next

Let me know if any problems, or if note any client patches to send for rc6

On Mon, Sep 8, 2025 at 11:08 AM Stefan Metzmacher <metze@samba.org> wrote:
>
> Hi Steve,
>
> here's the branch that could replace your
> for-next-next (6eede6a6805fb50e3131b4b8182e10a17c9005b1)
>
> git fetch https://git.samba.org/metze/linux/wip.git for-6.18/fs-smb-20250908-v5
> (d762704985c3bd93e2d2e9ab224f5795baea63e1)
>
> https://git.samba.org/?p=metze/linux/wip.git;a=shortlog;h=refs/heads/for-6.18/fs-smb-20250908-v5
>
> The first 3 patches are the main reason why the rebase is needed.
> 7a9cd9e986c1f6ce3a64f4329b2e795bf24752ae smb: server: let smb_direct_writev() respect SMB_DIRECT_MAX_SEND_SGES
> 329efe5eb73f7b7604dab6b08f16bb6c3e500690 smb: smbdirect: introduce smbdirect_socket_status_string()
> ab7a3a9ece72bce4f601d6224aa9243b7e090ca9 smb: client: adjust smbdirect related output of cifs_debug_data_proc_show()
>
> In addition send_io.pending.wait_queue is changed to send_io.pending.zero_wait_queue to indicate
> it's woken when count gets zero.
>
> send_io.pending.dec_wait_queue is introduced to replace info->wait_post_send instead of dropping
> the logic around it, that gets woken on every decrement.
>
> The diff between the branches below:
>
> Please replace your for-next-next if you're happy.
>
> Thanks!
> metze
>
>   fs/smb/client/cifs_debug.c                 |  41 +++----
>   fs/smb/client/smbdirect.c                  |  30 ++++--
>   fs/smb/common/smbdirect/smbdirect_socket.h |  55 +++++++++-
>   fs/smb/server/transport_rdma.c             | 167 +++++++++++++++++++----------
>   4 files changed, 210 insertions(+), 83 deletions(-)
>
> diff --git a/fs/smb/client/cifs_debug.c b/fs/smb/client/cifs_debug.c
> index b4d70b51c456..35c4d27d2cc0 100644
> --- a/fs/smb/client/cifs_debug.c
> +++ b/fs/smb/client/cifs_debug.c
> @@ -457,52 +457,53 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v)
>                 sc = &server->smbd_conn->socket;
>                 sp = &sc->parameters;
>
> -               seq_printf(m, "\nSMBDirect (in hex) protocol version: %x "
> -                       "transport status: %x",
> +               seq_printf(m, "\nSMBDirect protocol version: 0x%x "
> +                       "transport status: %s (%u)",
>                         SMBDIRECT_V1,
> +                       smbdirect_socket_status_string(sc->status),
>                         sc->status);
> -               seq_printf(m, "\nConn receive_credit_max: %x "
> -                       "send_credit_target: %x max_send_size: %x",
> +               seq_printf(m, "\nConn receive_credit_max: %u "
> +                       "send_credit_target: %u max_send_size: %u",
>                         sp->recv_credit_max,
>                         sp->send_credit_target,
>                         sp->max_send_size);
> -               seq_printf(m, "\nConn max_fragmented_recv_size: %x "
> -                       "max_fragmented_send_size: %x max_receive_size:%x",
> +               seq_printf(m, "\nConn max_fragmented_recv_size: %u "
> +                       "max_fragmented_send_size: %u max_receive_size:%u",
>                         sp->max_fragmented_recv_size,
>                         sp->max_fragmented_send_size,
>                         sp->max_recv_size);
> -               seq_printf(m, "\nConn keep_alive_interval: %x "
> -                       "max_readwrite_size: %x rdma_readwrite_threshold: %x",
> +               seq_printf(m, "\nConn keep_alive_interval: %u "
> +                       "max_readwrite_size: %u rdma_readwrite_threshold: %u",
>                         sp->keepalive_interval_msec * 1000,
>                         sp->max_read_write_size,
>                         server->rdma_readwrite_threshold);
> -               seq_printf(m, "\nDebug count_get_receive_buffer: %llx "
> -                       "count_put_receive_buffer: %llx count_send_empty: %llx",
> +               seq_printf(m, "\nDebug count_get_receive_buffer: %llu "
> +                       "count_put_receive_buffer: %llu count_send_empty: %llu",
>                         sc->statistics.get_receive_buffer,
>                         sc->statistics.put_receive_buffer,
>                         sc->statistics.send_empty);
>                 seq_printf(m, "\nRead Queue "
> -                       "count_enqueue_reassembly_queue: %llx "
> -                       "count_dequeue_reassembly_queue: %llx "
> -                       "reassembly_data_length: %x "
> -                       "reassembly_queue_length: %x",
> +                       "count_enqueue_reassembly_queue: %llu "
> +                       "count_dequeue_reassembly_queue: %llu "
> +                       "reassembly_data_length: %u "
> +                       "reassembly_queue_length: %u",
>                         sc->statistics.enqueue_reassembly_queue,
>                         sc->statistics.dequeue_reassembly_queue,
>                         sc->recv_io.reassembly.data_length,
>                         sc->recv_io.reassembly.queue_length);
> -               seq_printf(m, "\nCurrent Credits send_credits: %x "
> -                       "receive_credits: %x receive_credit_target: %x",
> +               seq_printf(m, "\nCurrent Credits send_credits: %u "
> +                       "receive_credits: %u receive_credit_target: %u",
>                         atomic_read(&sc->send_io.credits.count),
>                         atomic_read(&sc->recv_io.credits.count),
>                         sc->recv_io.credits.target);
> -               seq_printf(m, "\nPending send_pending: %x ",
> +               seq_printf(m, "\nPending send_pending: %u ",
>                         atomic_read(&sc->send_io.pending.count));
> -               seq_printf(m, "\nMR responder_resources: %x "
> -                       "max_frmr_depth: %x mr_type: %x",
> +               seq_printf(m, "\nMR responder_resources: %u "
> +                       "max_frmr_depth: %u mr_type: 0x%x",
>                         sp->responder_resources,
>                         sp->max_frmr_depth,
>                         sc->mr_io.type);
> -               seq_printf(m, "\nMR mr_ready_count: %x mr_used_count: %x",
> +               seq_printf(m, "\nMR mr_ready_count: %u mr_used_count: %u",
>                         atomic_read(&sc->mr_io.ready.count),
>                         atomic_read(&sc->mr_io.used.count));
>   skip_rdma:
> diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
> index d3cd89bd2cc7..322334097e30 100644
> --- a/fs/smb/client/smbdirect.c
> +++ b/fs/smb/client/smbdirect.c
> @@ -412,7 +412,9 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
>         }
>
>         if (atomic_dec_and_test(&sc->send_io.pending.count))
> -               wake_up(&sc->send_io.pending.wait_queue);
> +               wake_up(&sc->send_io.pending.zero_wait_queue);
> +
> +       wake_up(&sc->send_io.pending.dec_wait_queue);
>
>         mempool_free(request, sc->send_io.mem.pool);
>   }
> @@ -1017,6 +1019,23 @@ static int smbd_post_send_iter(struct smbdirect_socket *sc,
>                 goto wait_credit;
>         }
>
> +wait_send_queue:
> +       wait_event(sc->send_io.pending.dec_wait_queue,
> +               atomic_read(&sc->send_io.pending.count) < sp->send_credit_target ||
> +               sc->status != SMBDIRECT_SOCKET_CONNECTED);
> +
> +       if (sc->status != SMBDIRECT_SOCKET_CONNECTED) {
> +               log_outgoing(ERR, "disconnected not sending on wait_send_queue\n");
> +               rc = -EAGAIN;
> +               goto err_wait_send_queue;
> +       }
> +
> +       if (unlikely(atomic_inc_return(&sc->send_io.pending.count) >
> +                               sp->send_credit_target)) {
> +               atomic_dec(&sc->send_io.pending.count);
> +               goto wait_send_queue;
> +       }
> +
>         request = mempool_alloc(sc->send_io.mem.pool, GFP_KERNEL);
>         if (!request) {
>                 rc = -ENOMEM;
> @@ -1098,14 +1117,10 @@ static int smbd_post_send_iter(struct smbdirect_socket *sc,
>         request->sge[0].length = header_length;
>         request->sge[0].lkey = sc->ib.pd->local_dma_lkey;
>
> -       atomic_inc(&sc->send_io.pending.count);
>         rc = smbd_post_send(sc, request);
>         if (!rc)
>                 return 0;
>
> -       if (atomic_dec_and_test(&sc->send_io.pending.count))
> -               wake_up(&sc->send_io.pending.wait_queue);
> -
>   err_dma:
>         for (i = 0; i < request->num_sge; i++)
>                 if (request->sge[i].addr)
> @@ -1119,7 +1134,10 @@ static int smbd_post_send_iter(struct smbdirect_socket *sc,
>         atomic_sub(new_credits, &sc->recv_io.credits.count);
>
>   err_alloc:
> +       if (atomic_dec_and_test(&sc->send_io.pending.count))
> +               wake_up(&sc->send_io.pending.zero_wait_queue);
>
> +err_wait_send_queue:
>         /* roll back send credits and pending */
>         atomic_inc(&sc->send_io.credits.count);
>
> @@ -2118,7 +2136,7 @@ int smbd_send(struct TCP_Server_Info *server,
>          * that means all the I/Os have been out and we are good to return
>          */
>
> -       wait_event(sc->send_io.pending.wait_queue,
> +       wait_event(sc->send_io.pending.zero_wait_queue,
>                 atomic_read(&sc->send_io.pending.count) == 0 ||
>                 sc->status != SMBDIRECT_SOCKET_CONNECTED);
>
> diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
> index c62d12f63e13..8542de12002a 100644
> --- a/fs/smb/common/smbdirect/smbdirect_socket.h
> +++ b/fs/smb/common/smbdirect/smbdirect_socket.h
> @@ -28,6 +28,49 @@ enum smbdirect_socket_status {
>         SMBDIRECT_SOCKET_DESTROYED
>   };
>
> +static __always_inline
> +const char *smbdirect_socket_status_string(enum smbdirect_socket_status status)
> +{
> +       switch (status) {
> +       case SMBDIRECT_SOCKET_CREATED:
> +               return "CREATED";
> +       case SMBDIRECT_SOCKET_RESOLVE_ADDR_NEEDED:
> +               return "RESOLVE_ADDR_NEEDED";
> +       case SMBDIRECT_SOCKET_RESOLVE_ADDR_RUNNING:
> +               return "RESOLVE_ADDR_RUNNING";
> +       case SMBDIRECT_SOCKET_RESOLVE_ADDR_FAILED:
> +               return "RESOLVE_ADDR_FAILED";
> +       case SMBDIRECT_SOCKET_RESOLVE_ROUTE_NEEDED:
> +               return "RESOLVE_ROUTE_NEEDED";
> +       case SMBDIRECT_SOCKET_RESOLVE_ROUTE_RUNNING:
> +               return "RESOLVE_ROUTE_RUNNING";
> +       case SMBDIRECT_SOCKET_RESOLVE_ROUTE_FAILED:
> +               return "RESOLVE_ROUTE_FAILED";
> +       case SMBDIRECT_SOCKET_RDMA_CONNECT_NEEDED:
> +               return "RDMA_CONNECT_NEEDED";
> +       case SMBDIRECT_SOCKET_RDMA_CONNECT_RUNNING:
> +               return "RDMA_CONNECT_RUNNING";
> +       case SMBDIRECT_SOCKET_RDMA_CONNECT_FAILED:
> +               return "RDMA_CONNECT_FAILED";
> +       case SMBDIRECT_SOCKET_NEGOTIATE_NEEDED:
> +               return "NEGOTIATE_NEEDED";
> +       case SMBDIRECT_SOCKET_NEGOTIATE_RUNNING:
> +               return "NEGOTIATE_RUNNING";
> +       case SMBDIRECT_SOCKET_NEGOTIATE_FAILED:
> +               return "NEGOTIATE_FAILED";
> +       case SMBDIRECT_SOCKET_CONNECTED:
> +               return "CONNECTED";
> +       case SMBDIRECT_SOCKET_DISCONNECTING:
> +               return "DISCONNECTING";
> +       case SMBDIRECT_SOCKET_DISCONNECTED:
> +               return "DISCONNECTED,";
> +       case SMBDIRECT_SOCKET_DESTROYED:
> +               return "DESTROYED";
> +       }
> +
> +       return "<unknown>";
> +}
> +
>   enum smbdirect_keepalive_status {
>         SMBDIRECT_KEEPALIVE_NONE,
>         SMBDIRECT_KEEPALIVE_PENDING,
> @@ -107,7 +150,14 @@ struct smbdirect_socket {
>                  */
>                 struct {
>                         atomic_t count;
> -                       wait_queue_head_t wait_queue;
> +                       /*
> +                        * woken when count is decremented
> +                        */
> +                       wait_queue_head_t dec_wait_queue;
> +                       /*
> +                        * woken when count reached zero
> +                        */
> +                       wait_queue_head_t zero_wait_queue;
>                 } pending;
>         } send_io;
>
> @@ -271,7 +321,8 @@ static __always_inline void smbdirect_socket_init(struct smbdirect_socket *sc)
>         init_waitqueue_head(&sc->send_io.credits.wait_queue);
>
>         atomic_set(&sc->send_io.pending.count, 0);
> -       init_waitqueue_head(&sc->send_io.pending.wait_queue);
> +       init_waitqueue_head(&sc->send_io.pending.dec_wait_queue);
> +       init_waitqueue_head(&sc->send_io.pending.zero_wait_queue);
>
>         INIT_LIST_HEAD(&sc->recv_io.free.list);
>         spin_lock_init(&sc->recv_io.free.lock);
> diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
> index 6e4c2bf7dd93..33d2f5bdb827 100644
> --- a/fs/smb/server/transport_rdma.c
> +++ b/fs/smb/server/transport_rdma.c
> @@ -366,7 +366,7 @@ static void free_transport(struct smb_direct_transport *t)
>         }
>
>         wake_up_all(&sc->send_io.credits.wait_queue);
> -       wake_up_all(&sc->send_io.pending.wait_queue);
> +       wake_up_all(&sc->send_io.pending.zero_wait_queue);
>
>         disable_work_sync(&sc->recv_io.posted.refill_work);
>         disable_delayed_work_sync(&sc->idle.timer_work);
> @@ -818,7 +818,7 @@ static void send_done(struct ib_cq *cq, struct ib_wc *wc)
>         }
>
>         if (atomic_dec_and_test(&sc->send_io.pending.count))
> -               wake_up(&sc->send_io.pending.wait_queue);
> +               wake_up(&sc->send_io.pending.zero_wait_queue);
>
>         /* iterate and free the list of messages in reverse. the list's head
>          * is invalid.
> @@ -879,7 +879,7 @@ static int smb_direct_post_send(struct smbdirect_socket *sc,
>         if (ret) {
>                 pr_err("failed to post send: %d\n", ret);
>                 if (atomic_dec_and_test(&sc->send_io.pending.count))
> -                       wake_up(&sc->send_io.pending.wait_queue);
> +                       wake_up(&sc->send_io.pending.zero_wait_queue);
>                 smb_direct_disconnect_rdma_connection(sc);
>         }
>         return ret;
> @@ -1206,78 +1206,130 @@ static int smb_direct_writev(struct ksmbd_transport *t,
>         struct smb_direct_transport *st = SMBD_TRANS(t);
>         struct smbdirect_socket *sc = &st->socket;
>         struct smbdirect_socket_parameters *sp = &sc->parameters;
> -       int remaining_data_length;
> -       int start, i, j;
> -       int max_iov_size = sp->max_send_size -
> +       size_t remaining_data_length;
> +       size_t iov_idx;
> +       size_t iov_ofs;
> +       size_t max_iov_size = sp->max_send_size -
>                         sizeof(struct smbdirect_data_transfer);
>         int ret;
> -       struct kvec vec;
>         struct smbdirect_send_batch send_ctx;
> +       int error = 0;
>
>         if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
>                 return -ENOTCONN;
>
>         //FIXME: skip RFC1002 header..
> +       if (WARN_ON_ONCE(niovs <= 1 || iov[0].iov_len != 4))
> +               return -EINVAL;
>         buflen -= 4;
> +       iov_idx = 1;
> +       iov_ofs = 0;
>
>         remaining_data_length = buflen;
>         ksmbd_debug(RDMA, "Sending smb (RDMA): smb_len=%u\n", buflen);
>
>         smb_direct_send_ctx_init(&send_ctx, need_invalidate, remote_key);
> -       start = i = 1;
> -       buflen = 0;
> -       while (true) {
> -               buflen += iov[i].iov_len;
> -               if (buflen > max_iov_size) {
> -                       if (i > start) {
> -                               remaining_data_length -=
> -                                       (buflen - iov[i].iov_len);
> -                               ret = smb_direct_post_send_data(sc, &send_ctx,
> -                                                               &iov[start], i - start,
> -                                                               remaining_data_length);
> -                               if (ret)
> +       while (remaining_data_length) {
> +               struct kvec vecs[SMBDIRECT_SEND_IO_MAX_SGE - 1]; /* minus smbdirect hdr */
> +               size_t possible_bytes = max_iov_size;
> +               size_t possible_vecs;
> +               size_t bytes = 0;
> +               size_t nvecs = 0;
> +
> +               /*
> +                * For the last message remaining_data_length should be
> +                * have been 0 already!
> +                */
> +               if (WARN_ON_ONCE(iov_idx >= niovs)) {
> +                       error = -EINVAL;
> +                       goto done;
> +               }
> +
> +               /*
> +                * We have 2 factors which limit the arguments we pass
> +                * to smb_direct_post_send_data():
> +                *
> +                * 1. The number of supported sges for the send,
> +                *    while one is reserved for the smbdirect header.
> +                *    And we currently need one SGE per page.
> +                * 2. The number of negotiated payload bytes per send.
> +                */
> +               possible_vecs = min_t(size_t, ARRAY_SIZE(vecs), niovs - iov_idx);
> +
> +               while (iov_idx < niovs && possible_vecs && possible_bytes) {
> +                       struct kvec *v = &vecs[nvecs];
> +                       int page_count;
> +
> +                       v->iov_base = ((u8 *)iov[iov_idx].iov_base) + iov_ofs;
> +                       v->iov_len = min_t(size_t,
> +                                          iov[iov_idx].iov_len - iov_ofs,
> +                                          possible_bytes);
> +                       page_count = get_buf_page_count(v->iov_base, v->iov_len);
> +                       if (page_count > possible_vecs) {
> +                               /*
> +                                * If the number of pages in the buffer
> +                                * is to much (because we currently require
> +                                * one SGE per page), we need to limit the
> +                                * length.
> +                                *
> +                                * We know possible_vecs is at least 1,
> +                                * so we always keep the first page.
> +                                *
> +                                * We need to calculate the number extra
> +                                * pages (epages) we can also keep.
> +                                *
> +                                * We calculate the number of bytes in the
> +                                * first page (fplen), this should never be
> +                                * larger than v->iov_len because page_count is
> +                                * at least 2, but adding a limitation feels
> +                                * better.
> +                                *
> +                                * Then we calculate the number of bytes (elen)
> +                                * we can keep for the extra pages.
> +                                */
> +                               size_t epages = possible_vecs - 1;
> +                               size_t fpofs = offset_in_page(v->iov_base);
> +                               size_t fplen = min_t(size_t, PAGE_SIZE - fpofs, v->iov_len);
> +                               size_t elen = min_t(size_t, v->iov_len - fplen, epages*PAGE_SIZE);
> +
> +                               v->iov_len = fplen + elen;
> +                               page_count = get_buf_page_count(v->iov_base, v->iov_len);
> +                               if (WARN_ON_ONCE(page_count > possible_vecs)) {
> +                                       /*
> +                                        * Something went wrong in the above
> +                                        * logic...
> +                                        */
> +                                       error = -EINVAL;
>                                         goto done;
> -                       } else {
> -                               /* iov[start] is too big, break it */
> -                               int nvec  = (buflen + max_iov_size - 1) /
> -                                               max_iov_size;
> -
> -                               for (j = 0; j < nvec; j++) {
> -                                       vec.iov_base =
> -                                               (char *)iov[start].iov_base +
> -                                               j * max_iov_size;
> -                                       vec.iov_len =
> -                                               min_t(int, max_iov_size,
> -                                                     buflen - max_iov_size * j);
> -                                       remaining_data_length -= vec.iov_len;
> -                                       ret = smb_direct_post_send_data(sc, &send_ctx, &vec, 1,
> -                                                                       remaining_data_length);
> -                                       if (ret)
> -                                               goto done;
>                                 }
> -                               i++;
> -                               if (i == niovs)
> -                                       break;
>                         }
> -                       start = i;
> -                       buflen = 0;
> -               } else {
> -                       i++;
> -                       if (i == niovs) {
> -                               /* send out all remaining vecs */
> -                               remaining_data_length -= buflen;
> -                               ret = smb_direct_post_send_data(sc, &send_ctx,
> -                                                               &iov[start], i - start,
> -                                                               remaining_data_length);
> -                               if (ret)
> -                                       goto done;
> -                               break;
> +                       possible_vecs -= page_count;
> +                       nvecs += 1;
> +                       possible_bytes -= v->iov_len;
> +                       bytes += v->iov_len;
> +
> +                       iov_ofs += v->iov_len;
> +                       if (iov_ofs >= iov[iov_idx].iov_len) {
> +                               iov_idx += 1;
> +                               iov_ofs = 0;
>                         }
>                 }
> +
> +               remaining_data_length -= bytes;
> +
> +               ret = smb_direct_post_send_data(sc, &send_ctx,
> +                                               vecs, nvecs,
> +                                               remaining_data_length);
> +               if (unlikely(ret)) {
> +                       error = ret;
> +                       goto done;
> +               }
>         }
>
>   done:
>         ret = smb_direct_flush_send_list(sc, &send_ctx, true);
> +       if (unlikely(!ret && error))
> +               ret = error;
>
>         /*
>          * As an optimization, we don't wait for individual I/O to finish
> @@ -1286,7 +1338,7 @@ static int smb_direct_writev(struct ksmbd_transport *t,
>          * that means all the I/Os have been out and we are good to return
>          */
>
> -       wait_event(sc->send_io.pending.wait_queue,
> +       wait_event(sc->send_io.pending.zero_wait_queue,
>                    atomic_read(&sc->send_io.pending.count) == 0 ||
>                    sc->status != SMBDIRECT_SOCKET_CONNECTED);
>         if (sc->status != SMBDIRECT_SOCKET_CONNECTED && ret == 0)
> @@ -1620,7 +1672,7 @@ static int smb_direct_send_negotiate_response(struct smbdirect_socket *sc,
>                 return ret;
>         }
>
> -       wait_event(sc->send_io.pending.wait_queue,
> +       wait_event(sc->send_io.pending.zero_wait_queue,
>                    atomic_read(&sc->send_io.pending.count) == 0 ||
>                    sc->status != SMBDIRECT_SOCKET_CONNECTED);
>         if (sc->status != SMBDIRECT_SOCKET_CONNECTED)
> @@ -1773,6 +1825,11 @@ static int smb_direct_init_params(struct smbdirect_socket *sc,
>                 return -EINVAL;
>         }
>
> +       if (device->attrs.max_send_sge < SMBDIRECT_SEND_IO_MAX_SGE) {
> +               pr_err("warning: device max_send_sge = %d too small\n",
> +                      device->attrs.max_send_sge);
> +               return -EINVAL;
> +       }
>         if (device->attrs.max_recv_sge < SMBDIRECT_RECV_IO_MAX_SGE) {
>                 pr_err("warning: device max_recv_sge = %d too small\n",
>                        device->attrs.max_recv_sge);
> @@ -1785,7 +1842,7 @@ static int smb_direct_init_params(struct smbdirect_socket *sc,
>
>         cap->max_send_wr = max_send_wrs;
>         cap->max_recv_wr = sp->recv_credit_max;
> -       cap->max_send_sge = max_sge_per_wr;
> +       cap->max_send_sge = SMBDIRECT_SEND_IO_MAX_SGE;
>         cap->max_recv_sge = SMBDIRECT_RECV_IO_MAX_SGE;
>         cap->max_inline_data = 0;
>         cap->max_rdma_ctxs = sc->rw_io.credits.max;
>
>


-- 
Thanks,

Steve

Re: replace for-next-next... Re: [PATCH v4 000/142] smb: smbdirect/client/server: make use of common structures

[Stefan Metzmacher]

Hi Steve, hi Namjae,

I found "ksmbd: smbdirect: validate data_offset and data_length field of smb_direct_data_transfer"
https://git.samba.org/?p=ksmbd.git;a=commitdiff;h=927f8fe05e334d016c598d2cc965161c2808d9ba
in ksmbd-for-next-next.

I added a Fixes and Reviewed-by tag
https://git.samba.org/?p=metze/linux/wip.git;a=commitdiff;h=fa36db4e8d62aa9c3ba1200323d8e01e4eb88b19
and two additional patches:
ksmbd: smbdirect: verify remaining_data_length respects max_fragmented_recv_size
https://git.samba.org/?p=metze/linux/wip.git;a=commitdiff;h=9e881174900e53dd2b17c0c0933cc4395ceb47a6
smb: client: let recv_done verify data_offset, data_length and remaining_data_length
https://git.samba.org/?p=metze/linux/wip.git;a=commitdiff;h=174faeea9ee496b724206d405b74db8b05729f11

I think these should go into 6.17.

As there as conflicts with for-next-next I rebased it again
and made sure each commit compiles and the result still passes
the tests I made last time.

The result can be found under
git fetch https://git.samba.org/metze/linux/wip.git for-6.18/fs-smb-20250910-v6
https://git.samba.org/?p=metze/linux/wip.git;a=shortlog;h=refs/heads/for-6.18/fs-smb-20250910-v6

Please have a look and replace for-next-next again...
The diff against the current for-next-next (e2e99af785ee91ce20c6d583e396660494db77a2)
and for-6.18/fs-smb-20250910-v6 (1fb2a52741e836f54a4691cbd74d9d70d736e506) follows below.

Thanks!
metze

  fs/smb/client/smbdirect.c                  | 19 ++++++++++++++++++-
  fs/smb/common/smbdirect/smbdirect_socket.h |  2 +-
  fs/smb/server/transport_rdma.c             | 25 +++++++++++++++++--------
  3 files changed, 36 insertions(+), 10 deletions(-)

diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
index 322334097e30..6215a6e91c67 100644
--- a/fs/smb/client/smbdirect.c
+++ b/fs/smb/client/smbdirect.c
@@ -548,7 +548,9 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
  	struct smbdirect_socket *sc = response->socket;
  	struct smbdirect_socket_parameters *sp = &sc->parameters;
  	u16 old_recv_credit_target;
-	int data_length = 0;
+	u32 data_offset = 0;
+	u32 data_length = 0;
+	u32 remaining_data_length = 0;
  	bool negotiate_done = false;

  	log_rdma_recv(INFO,
@@ -600,7 +602,22 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
  	/* SMBD data transfer packet */
  	case SMBDIRECT_EXPECT_DATA_TRANSFER:
  		data_transfer = smbdirect_recv_io_payload(response);
+
+		if (wc->byte_len <
+		    offsetof(struct smbdirect_data_transfer, padding))
+			goto error;
+
+		remaining_data_length = le32_to_cpu(data_transfer->remaining_data_length);
+		data_offset = le32_to_cpu(data_transfer->data_offset);
  		data_length = le32_to_cpu(data_transfer->data_length);
+		if (wc->byte_len < data_offset ||
+		    wc->byte_len < (u64)data_offset + data_length)
+			goto error;
+
+		if (remaining_data_length > sp->max_fragmented_recv_size ||
+		    data_length > sp->max_fragmented_recv_size ||
+		    (u64)remaining_data_length + (u64)data_length > (u64)sp->max_fragmented_recv_size)
+			goto error;

  		if (data_length) {
  			if (sc->recv_io.reassembly.full_packet_received)
diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
index 8542de12002a..91eb02fb1600 100644
--- a/fs/smb/common/smbdirect/smbdirect_socket.h
+++ b/fs/smb/common/smbdirect/smbdirect_socket.h
@@ -63,7 +63,7 @@ const char *smbdirect_socket_status_string(enum smbdirect_socket_status status)
  	case SMBDIRECT_SOCKET_DISCONNECTING:
  		return "DISCONNECTING";
  	case SMBDIRECT_SOCKET_DISCONNECTED:
-		return "DISCONNECTED,";
+		return "DISCONNECTED";
  	case SMBDIRECT_SOCKET_DESTROYED:
  		return "DESTROYED";
  	}
diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
index 33d2f5bdb827..e371d8f4c80b 100644
--- a/fs/smb/server/transport_rdma.c
+++ b/fs/smb/server/transport_rdma.c
@@ -538,7 +538,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
  	case SMBDIRECT_EXPECT_DATA_TRANSFER: {
  		struct smbdirect_data_transfer *data_transfer =
  			(struct smbdirect_data_transfer *)recvmsg->packet;
-		unsigned int data_length;
+		u32 remaining_data_length, data_offset, data_length;
  		u16 old_recv_credit_target;

  		if (wc->byte_len <
@@ -548,15 +548,24 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
  			return;
  		}

+		remaining_data_length = le32_to_cpu(data_transfer->remaining_data_length);
  		data_length = le32_to_cpu(data_transfer->data_length);
-		if (data_length) {
-			if (wc->byte_len < sizeof(struct smbdirect_data_transfer) +
-			    (u64)data_length) {
-				put_recvmsg(sc, recvmsg);
-				smb_direct_disconnect_rdma_connection(sc);
-				return;
-			}
+		data_offset = le32_to_cpu(data_transfer->data_offset);
+		if (wc->byte_len < data_offset ||
+		    wc->byte_len < (u64)data_offset + data_length) {
+			put_recvmsg(sc, recvmsg);
+			smb_direct_disconnect_rdma_connection(sc);
+			return;
+		}
+		if (remaining_data_length > sp->max_fragmented_recv_size ||
+		    data_length > sp->max_fragmented_recv_size ||
+		    (u64)remaining_data_length + (u64)data_length > (u64)sp->max_fragmented_recv_size) {
+			put_recvmsg(sc, recvmsg);
+			smb_direct_disconnect_rdma_connection(sc);
+			return;
+		}

+		if (data_length) {
  			if (sc->recv_io.reassembly.full_packet_received)
  				recvmsg->first_segment = true;

Re: replace for-next-next... Re: [PATCH v4 000/142] smb: smbdirect/client/server: make use of common structures

[Namjae Jeon]

On Thu, Sep 11, 2025 at 4:05 AM Stefan Metzmacher <metze@samba.org> wrote:
>
> Hi Steve, hi Namjae,
Hi Metze,
>
> I found "ksmbd: smbdirect: validate data_offset and data_length field of smb_direct_data_transfer"
> https://git.samba.org/?p=ksmbd.git;a=commitdiff;h=927f8fe05e334d016c598d2cc965161c2808d9ba
> in ksmbd-for-next-next.
>
> I added a Fixes and Reviewed-by tag
> https://git.samba.org/?p=metze/linux/wip.git;a=commitdiff;h=fa36db4e8d62aa9c3ba1200323d8e01e4eb88b19
> and two additional patches:
I will update it with your tags.
> ksmbd: smbdirect: verify remaining_data_length respects max_fragmented_recv_size
> https://git.samba.org/?p=metze/linux/wip.git;a=commitdiff;h=9e881174900e53dd2b17c0c0933cc4395ceb47a6
Looks good to me. I will apply it to #ksmbd-for-next-next.

> smb: client: let recv_done verify data_offset, data_length and remaining_data_length
> https://git.samba.org/?p=metze/linux/wip.git;a=commitdiff;h=174faeea9ee496b724206d405b74db8b05729f11
Looks good to me. Reviewed-by: Namjae Jeon <linkinjeon@kernel.org> for
this client patch.

Thanks!
>
> I think these should go into 6.17.
>
> As there as conflicts with for-next-next I rebased it again
> and made sure each commit compiles and the result still passes
> the tests I made last time.
>
> The result can be found under
> git fetch https://git.samba.org/metze/linux/wip.git for-6.18/fs-smb-20250910-v6
> https://git.samba.org/?p=metze/linux/wip.git;a=shortlog;h=refs/heads/for-6.18/fs-smb-20250910-v6
>
> Please have a look and replace for-next-next again...
> The diff against the current for-next-next (e2e99af785ee91ce20c6d583e396660494db77a2)
> and for-6.18/fs-smb-20250910-v6 (1fb2a52741e836f54a4691cbd74d9d70d736e506) follows below.
>
> Thanks!
> metze
>
>   fs/smb/client/smbdirect.c                  | 19 ++++++++++++++++++-
>   fs/smb/common/smbdirect/smbdirect_socket.h |  2 +-
>   fs/smb/server/transport_rdma.c             | 25 +++++++++++++++++--------
>   3 files changed, 36 insertions(+), 10 deletions(-)
>
> diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
> index 322334097e30..6215a6e91c67 100644
> --- a/fs/smb/client/smbdirect.c
> +++ b/fs/smb/client/smbdirect.c
> @@ -548,7 +548,9 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
>         struct smbdirect_socket *sc = response->socket;
>         struct smbdirect_socket_parameters *sp = &sc->parameters;
>         u16 old_recv_credit_target;
> -       int data_length = 0;
> +       u32 data_offset = 0;
> +       u32 data_length = 0;
> +       u32 remaining_data_length = 0;
>         bool negotiate_done = false;
>
>         log_rdma_recv(INFO,
> @@ -600,7 +602,22 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
>         /* SMBD data transfer packet */
>         case SMBDIRECT_EXPECT_DATA_TRANSFER:
>                 data_transfer = smbdirect_recv_io_payload(response);
> +
> +               if (wc->byte_len <
> +                   offsetof(struct smbdirect_data_transfer, padding))
> +                       goto error;
> +
> +               remaining_data_length = le32_to_cpu(data_transfer->remaining_data_length);
> +               data_offset = le32_to_cpu(data_transfer->data_offset);
>                 data_length = le32_to_cpu(data_transfer->data_length);
> +               if (wc->byte_len < data_offset ||
> +                   wc->byte_len < (u64)data_offset + data_length)
> +                       goto error;
> +
> +               if (remaining_data_length > sp->max_fragmented_recv_size ||
> +                   data_length > sp->max_fragmented_recv_size ||
> +                   (u64)remaining_data_length + (u64)data_length > (u64)sp->max_fragmented_recv_size)
> +                       goto error;
>
>                 if (data_length) {
>                         if (sc->recv_io.reassembly.full_packet_received)
> diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
> index 8542de12002a..91eb02fb1600 100644
> --- a/fs/smb/common/smbdirect/smbdirect_socket.h
> +++ b/fs/smb/common/smbdirect/smbdirect_socket.h
> @@ -63,7 +63,7 @@ const char *smbdirect_socket_status_string(enum smbdirect_socket_status status)
>         case SMBDIRECT_SOCKET_DISCONNECTING:
>                 return "DISCONNECTING";
>         case SMBDIRECT_SOCKET_DISCONNECTED:
> -               return "DISCONNECTED,";
> +               return "DISCONNECTED";
>         case SMBDIRECT_SOCKET_DESTROYED:
>                 return "DESTROYED";
>         }
> diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
> index 33d2f5bdb827..e371d8f4c80b 100644
> --- a/fs/smb/server/transport_rdma.c
> +++ b/fs/smb/server/transport_rdma.c
> @@ -538,7 +538,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
>         case SMBDIRECT_EXPECT_DATA_TRANSFER: {
>                 struct smbdirect_data_transfer *data_transfer =
>                         (struct smbdirect_data_transfer *)recvmsg->packet;
> -               unsigned int data_length;
> +               u32 remaining_data_length, data_offset, data_length;
>                 u16 old_recv_credit_target;
>
>                 if (wc->byte_len <
> @@ -548,15 +548,24 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
>                         return;
>                 }
>
> +               remaining_data_length = le32_to_cpu(data_transfer->remaining_data_length);
>                 data_length = le32_to_cpu(data_transfer->data_length);
> -               if (data_length) {
> -                       if (wc->byte_len < sizeof(struct smbdirect_data_transfer) +
> -                           (u64)data_length) {
> -                               put_recvmsg(sc, recvmsg);
> -                               smb_direct_disconnect_rdma_connection(sc);
> -                               return;
> -                       }
> +               data_offset = le32_to_cpu(data_transfer->data_offset);
> +               if (wc->byte_len < data_offset ||
> +                   wc->byte_len < (u64)data_offset + data_length) {
> +                       put_recvmsg(sc, recvmsg);
> +                       smb_direct_disconnect_rdma_connection(sc);
> +                       return;
> +               }
> +               if (remaining_data_length > sp->max_fragmented_recv_size ||
> +                   data_length > sp->max_fragmented_recv_size ||
> +                   (u64)remaining_data_length + (u64)data_length > (u64)sp->max_fragmented_recv_size) {
> +                       put_recvmsg(sc, recvmsg);
> +                       smb_direct_disconnect_rdma_connection(sc);
> +                       return;
> +               }
>
> +               if (data_length) {
>                         if (sc->recv_io.reassembly.full_packet_received)
>                                 recvmsg->first_segment = true;
>
>
>
>

Re: replace for-next-next... Re: [PATCH v4 000/142] smb: smbdirect/client/server: make use of common structures

[Steve French]

updated cifs-2.6.git for-next with the client patch

On Wed, Sep 10, 2025 at 6:36 PM Namjae Jeon <linkinjeon@kernel.org> wrote:
>
> On Thu, Sep 11, 2025 at 4:05 AM Stefan Metzmacher <metze@samba.org> wrote:
> >
> > Hi Steve, hi Namjae,
> Hi Metze,
> >
> > I found "ksmbd: smbdirect: validate data_offset and data_length field of smb_direct_data_transfer"
> > https://git.samba.org/?p=ksmbd.git;a=commitdiff;h=927f8fe05e334d016c598d2cc965161c2808d9ba
> > in ksmbd-for-next-next.
> >
> > I added a Fixes and Reviewed-by tag
> > https://git.samba.org/?p=metze/linux/wip.git;a=commitdiff;h=fa36db4e8d62aa9c3ba1200323d8e01e4eb88b19
> > and two additional patches:
> I will update it with your tags.
> > ksmbd: smbdirect: verify remaining_data_length respects max_fragmented_recv_size
> > https://git.samba.org/?p=metze/linux/wip.git;a=commitdiff;h=9e881174900e53dd2b17c0c0933cc4395ceb47a6
> Looks good to me. I will apply it to #ksmbd-for-next-next.
>
> > smb: client: let recv_done verify data_offset, data_length and remaining_data_length
> > https://git.samba.org/?p=metze/linux/wip.git;a=commitdiff;h=174faeea9ee496b724206d405b74db8b05729f11
> Looks good to me. Reviewed-by: Namjae Jeon <linkinjeon@kernel.org> for
> this client patch.
>
> Thanks!
> >
> > I think these should go into 6.17.
> >
> > As there as conflicts with for-next-next I rebased it again
> > and made sure each commit compiles and the result still passes
> > the tests I made last time.
> >
> > The result can be found under
> > git fetch https://git.samba.org/metze/linux/wip.git for-6.18/fs-smb-20250910-v6
> > https://git.samba.org/?p=metze/linux/wip.git;a=shortlog;h=refs/heads/for-6.18/fs-smb-20250910-v6
> >
> > Please have a look and replace for-next-next again...
> > The diff against the current for-next-next (e2e99af785ee91ce20c6d583e396660494db77a2)
> > and for-6.18/fs-smb-20250910-v6 (1fb2a52741e836f54a4691cbd74d9d70d736e506) follows below.
> >
> > Thanks!
> > metze
> >
> >   fs/smb/client/smbdirect.c                  | 19 ++++++++++++++++++-
> >   fs/smb/common/smbdirect/smbdirect_socket.h |  2 +-
> >   fs/smb/server/transport_rdma.c             | 25 +++++++++++++++++--------
> >   3 files changed, 36 insertions(+), 10 deletions(-)
> >
> > diff --git a/fs/smb/client/smbdirect.c b/fs/smb/client/smbdirect.c
> > index 322334097e30..6215a6e91c67 100644
> > --- a/fs/smb/client/smbdirect.c
> > +++ b/fs/smb/client/smbdirect.c
> > @@ -548,7 +548,9 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
> >         struct smbdirect_socket *sc = response->socket;
> >         struct smbdirect_socket_parameters *sp = &sc->parameters;
> >         u16 old_recv_credit_target;
> > -       int data_length = 0;
> > +       u32 data_offset = 0;
> > +       u32 data_length = 0;
> > +       u32 remaining_data_length = 0;
> >         bool negotiate_done = false;
> >
> >         log_rdma_recv(INFO,
> > @@ -600,7 +602,22 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
> >         /* SMBD data transfer packet */
> >         case SMBDIRECT_EXPECT_DATA_TRANSFER:
> >                 data_transfer = smbdirect_recv_io_payload(response);
> > +
> > +               if (wc->byte_len <
> > +                   offsetof(struct smbdirect_data_transfer, padding))
> > +                       goto error;
> > +
> > +               remaining_data_length = le32_to_cpu(data_transfer->remaining_data_length);
> > +               data_offset = le32_to_cpu(data_transfer->data_offset);
> >                 data_length = le32_to_cpu(data_transfer->data_length);
> > +               if (wc->byte_len < data_offset ||
> > +                   wc->byte_len < (u64)data_offset + data_length)
> > +                       goto error;
> > +
> > +               if (remaining_data_length > sp->max_fragmented_recv_size ||
> > +                   data_length > sp->max_fragmented_recv_size ||
> > +                   (u64)remaining_data_length + (u64)data_length > (u64)sp->max_fragmented_recv_size)
> > +                       goto error;
> >
> >                 if (data_length) {
> >                         if (sc->recv_io.reassembly.full_packet_received)
> > diff --git a/fs/smb/common/smbdirect/smbdirect_socket.h b/fs/smb/common/smbdirect/smbdirect_socket.h
> > index 8542de12002a..91eb02fb1600 100644
> > --- a/fs/smb/common/smbdirect/smbdirect_socket.h
> > +++ b/fs/smb/common/smbdirect/smbdirect_socket.h
> > @@ -63,7 +63,7 @@ const char *smbdirect_socket_status_string(enum smbdirect_socket_status status)
> >         case SMBDIRECT_SOCKET_DISCONNECTING:
> >                 return "DISCONNECTING";
> >         case SMBDIRECT_SOCKET_DISCONNECTED:
> > -               return "DISCONNECTED,";
> > +               return "DISCONNECTED";
> >         case SMBDIRECT_SOCKET_DESTROYED:
> >                 return "DESTROYED";
> >         }
> > diff --git a/fs/smb/server/transport_rdma.c b/fs/smb/server/transport_rdma.c
> > index 33d2f5bdb827..e371d8f4c80b 100644
> > --- a/fs/smb/server/transport_rdma.c
> > +++ b/fs/smb/server/transport_rdma.c
> > @@ -538,7 +538,7 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
> >         case SMBDIRECT_EXPECT_DATA_TRANSFER: {
> >                 struct smbdirect_data_transfer *data_transfer =
> >                         (struct smbdirect_data_transfer *)recvmsg->packet;
> > -               unsigned int data_length;
> > +               u32 remaining_data_length, data_offset, data_length;
> >                 u16 old_recv_credit_target;
> >
> >                 if (wc->byte_len <
> > @@ -548,15 +548,24 @@ static void recv_done(struct ib_cq *cq, struct ib_wc *wc)
> >                         return;
> >                 }
> >
> > +               remaining_data_length = le32_to_cpu(data_transfer->remaining_data_length);
> >                 data_length = le32_to_cpu(data_transfer->data_length);
> > -               if (data_length) {
> > -                       if (wc->byte_len < sizeof(struct smbdirect_data_transfer) +
> > -                           (u64)data_length) {
> > -                               put_recvmsg(sc, recvmsg);
> > -                               smb_direct_disconnect_rdma_connection(sc);
> > -                               return;
> > -                       }
> > +               data_offset = le32_to_cpu(data_transfer->data_offset);
> > +               if (wc->byte_len < data_offset ||
> > +                   wc->byte_len < (u64)data_offset + data_length) {
> > +                       put_recvmsg(sc, recvmsg);
> > +                       smb_direct_disconnect_rdma_connection(sc);
> > +                       return;
> > +               }
> > +               if (remaining_data_length > sp->max_fragmented_recv_size ||
> > +                   data_length > sp->max_fragmented_recv_size ||
> > +                   (u64)remaining_data_length + (u64)data_length > (u64)sp->max_fragmented_recv_size) {
> > +                       put_recvmsg(sc, recvmsg);
> > +                       smb_direct_disconnect_rdma_connection(sc);
> > +                       return;
> > +               }
> >
> > +               if (data_length) {
> >                         if (sc->recv_io.reassembly.full_packet_received)
> >                                 recvmsg->first_segment = true;
> >
> >
> >
> >



-- 
Thanks,

Steve