Commit a9401710 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'v6.18-rc-part1-smb3-common' of git://git.samba.org/ksmbd 

Pull smb restructuring updates from Steve French:
 "Large set of small restructuring smbdirect related patches for cifs.ko
  and ksmbd.ko.

  This is the next step in order to use common structures for smbdirect
  handling across both modules. And also includes improved handling of
  broken connections, as well as fixed negotiation as rdma resources.

  Moving to common functions is planned for 6.19, as well as also
  providing smbdirect via sockets to userspace (e.g. for samba to also
  be able to use smbdirect for userspace server and userspace client
  tools).

  This was heavily reviewed and tested at the recent SMB3.1.1 test event
  at SDC"

* tag 'v6.18-rc-part1-smb3-common' of git://git.samba.org/ksmbd: (159 commits)
  smb: server: let smb_direct_flush_send_list() invalidate a remote key first
  smb: server: make use of ib_alloc_cq_any() instead of ib_alloc_cq()
  smb: server: make consitent use of spin_lock_irq{save,restore}() in transport_rdma.c
  smb: server: let {free_transport,smb_direct_disconnect_rdma_{work,connection}}() wake up all wait queues
  smb: server: let smb_direct_disconnect_rdma_connection() disable all work but disconnect_work
  smb: server: fill in smbdirect_socket.first_error on error
  smb: server: let smb_direct_disconnect_rdma_connection() set SMBDIRECT_SOCKET_ERROR...
  smb: server: pass struct smbdirect_socket to smb_direct_send_negotiate_response()
  smb: server: pass struct smbdirect_socket to {enqueue,get_first}_reassembly()
  smb: server: pass struct smbdirect_socket to smb_direct_post_send_data()
  smb: server: pass struct smbdirect_socket to post_sendmsg()
  smb: server: pass struct smbdirect_socket to smb_direct_create_header()
  smb: server: pass struct smbdirect_socket to manage_keep_alive_before_sending()
  smb: server: pass struct smbdirect_socket to manage_credits_prior_sending()
  smb: server: pass struct smbdirect_socket to calc_rw_credits()
  smb: server: pass struct smbdirect_socket to wait_for_rw_credits()
  smb: server: pass struct smbdirect_socket to wait_for_send_credits()
  smb: server: pass struct smbdirect_socket to wait_for_credits()
  smb: server: pass struct smbdirect_socket to smb_direct_flush_send_list()
  smb: server: pass struct smbdirect_socket to smb_direct_post_send()
  ...
parents e445fba2 1b534263

fs/smb/client/cifs_debug.c

+40 −41
Original line number Diff line number Diff line
@@ -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"
@@ -456,57 +457,55 @@ 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",

			server->smbd_conn->protocol,

			server->smbd_conn->socket.status);

		seq_printf(m, "\nConn receive_credit_max: %x "

			"send_credit_target: %x max_send_size: %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: %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->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, "\nRead Queue count_reassembly_queue: %x "

			"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,

			server->rdma_readwrite_threshold);

		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: %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",

			atomic_read(&server->smbd_conn->send_credits),

			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));

		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,

			server->smbd_conn->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),

			atomic_read(&server->smbd_conn->mr_used_count));

		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: %u ",

			atomic_read(&sc->send_io.pending.count));

		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: %u mr_used_count: %u",

			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",

fs/smb/client/cifsglob.h

+8 −1
Original line number Diff line number Diff line
@@ -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*/
@@ -1540,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;

};

fs/smb/client/file.c

+12 −4
Original line number Diff line number Diff line
@@ -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;

}

fs/smb/client/smb2ops.c

+4 −4
Original line number Diff line number Diff line
@@ -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)

			/*

fs/smb/client/smb2pdu.c

+1 −1
Original line number Diff line number Diff line
@@ -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;