Commit cc55f65d authored by Stefan Metzmacher's avatar Stefan Metzmacher Committed by Steve French
Browse files

smb: client: make use of common smbdirect_socket_parameters 



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: default avatarStefan Metzmacher <metze@samba.org>
Signed-off-by: default avatarSteve French <stfrench@microsoft.com>
parent dce8047f

fs/smb/client/cifs_debug.c

+13 −8
Original line number Diff line number Diff line
@@ -362,6 +362,10 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v) 
	c = 0;

	spin_lock(&cifs_tcp_ses_lock);

	list_for_each_entry(server, &cifs_tcp_ses_list, tcp_ses_list) {

#ifdef CONFIG_CIFS_SMB_DIRECT

		struct smbdirect_socket_parameters *sp;

#endif



		/* channel info will be printed as a part of sessions below */

		if (SERVER_IS_CHAN(server))

			continue;
@@ -383,6 +387,7 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v) 
			seq_printf(m, "\nSMBDirect transport not available");

			goto skip_rdma;

		}

		sp = &server->smbd_conn->socket.parameters;



		seq_printf(m, "\nSMBDirect (in hex) protocol version: %x "

			"transport status: %x",
@@ -390,18 +395,18 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v) 
			server->smbd_conn->socket.status);

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

			"send_credit_target: %x max_send_size: %x",

			server->smbd_conn->receive_credit_max,

			server->smbd_conn->send_credit_target,

			server->smbd_conn->max_send_size);

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

			server->smbd_conn->max_fragmented_recv_size,

			server->smbd_conn->max_fragmented_send_size,

			server->smbd_conn->max_receive_size);

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

			server->smbd_conn->keep_alive_interval,

			server->smbd_conn->max_readwrite_size,

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

fs/smb/client/smb2ops.c

+10 −4
Original line number Diff line number Diff line
@@ -504,6 +504,9 @@ 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;



		if (server->sign)

			/*

			 * Account for SMB2 data transfer packet header and
@@ -511,12 +514,12 @@ smb3_negotiate_wsize(struct cifs_tcon *tcon, struct smb3_fs_context *ctx) 
			 */

			wsize = min_t(unsigned int,

				wsize,

				server->smbd_conn->max_fragmented_send_size -

				sp->max_fragmented_send_size -

					SMB2_READWRITE_PDU_HEADER_SIZE -

					sizeof(struct smb2_transform_hdr));

		else

			wsize = min_t(unsigned int,

				wsize, server->smbd_conn->max_readwrite_size);

				wsize, sp->max_read_write_size);

	}

#endif

	if (!(server->capabilities & SMB2_GLOBAL_CAP_LARGE_MTU))
@@ -552,6 +555,9 @@ 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;



		if (server->sign)

			/*

			 * Account for SMB2 data transfer packet header and
@@ -559,12 +565,12 @@ smb3_negotiate_rsize(struct cifs_tcon *tcon, struct smb3_fs_context *ctx) 
			 */

			rsize = min_t(unsigned int,

				rsize,

				server->smbd_conn->max_fragmented_recv_size -

				sp->max_fragmented_recv_size -

					SMB2_READWRITE_PDU_HEADER_SIZE -

					sizeof(struct smb2_transform_hdr));

		else

			rsize = min_t(unsigned int,

				rsize, server->smbd_conn->max_readwrite_size);

				rsize, sp->max_read_write_size);

	}

#endif

fs/smb/client/smbdirect.c

+53 −38
Original line number Diff line number Diff line
@@ -320,6 +320,8 @@ static bool process_negotiation_response( 
		struct smbd_response *response, int packet_length)

{

	struct smbd_connection *info = response->info;

	struct smbdirect_socket *sc = &info->socket;

	struct smbdirect_socket_parameters *sp = &sc->parameters;

	struct smbdirect_negotiate_resp *packet = smbd_response_payload(response);



	if (packet_length < sizeof(struct smbdirect_negotiate_resp)) {
@@ -349,19 +351,19 @@ static bool process_negotiation_response( 


	atomic_set(&info->receive_credits, 0);



	if (le32_to_cpu(packet->preferred_send_size) > info->max_receive_size) {

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

		return false;

	}

	info->max_receive_size = le32_to_cpu(packet->preferred_send_size);

	sp->max_recv_size = le32_to_cpu(packet->preferred_send_size);



	if (le32_to_cpu(packet->max_receive_size) < SMBD_MIN_RECEIVE_SIZE) {

		log_rdma_event(ERR, "error: max_receive_size=%d\n",

			le32_to_cpu(packet->max_receive_size));

		return false;

	}

	info->max_send_size = min_t(int, info->max_send_size,

	sp->max_send_size = min_t(u32, sp->max_send_size,

				  le32_to_cpu(packet->max_receive_size));



	if (le32_to_cpu(packet->max_fragmented_size) <
@@ -370,18 +372,18 @@ static bool process_negotiation_response( 
			le32_to_cpu(packet->max_fragmented_size));

		return false;

	}

	info->max_fragmented_send_size =

	sp->max_fragmented_send_size =

		le32_to_cpu(packet->max_fragmented_size);

	info->rdma_readwrite_threshold =

		rdma_readwrite_threshold > info->max_fragmented_send_size ?

		info->max_fragmented_send_size :

		rdma_readwrite_threshold > sp->max_fragmented_send_size ?

		sp->max_fragmented_send_size :

		rdma_readwrite_threshold;





	info->max_readwrite_size = min_t(u32,

	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 = info->max_readwrite_size / PAGE_SIZE;

	info->max_frmr_depth = sp->max_read_write_size / PAGE_SIZE;



	return true;

}
@@ -689,6 +691,7 @@ static int smbd_ia_open( 
static int smbd_post_send_negotiate_req(struct smbd_connection *info)

{

	struct smbdirect_socket *sc = &info->socket;

	struct smbdirect_socket_parameters *sp = &sc->parameters;

	struct ib_send_wr send_wr;

	int rc = -ENOMEM;

	struct smbd_request *request;
@@ -704,11 +707,11 @@ static int smbd_post_send_negotiate_req(struct smbd_connection *info) 
	packet->min_version = cpu_to_le16(SMBDIRECT_V1);

	packet->max_version = cpu_to_le16(SMBDIRECT_V1);

	packet->reserved = 0;

	packet->credits_requested = cpu_to_le16(info->send_credit_target);

	packet->preferred_send_size = cpu_to_le32(info->max_send_size);

	packet->max_receive_size = cpu_to_le32(info->max_receive_size);

	packet->credits_requested = cpu_to_le16(sp->send_credit_target);

	packet->preferred_send_size = cpu_to_le32(sp->max_send_size);

	packet->max_receive_size = cpu_to_le32(sp->max_recv_size);

	packet->max_fragmented_size =

		cpu_to_le32(info->max_fragmented_recv_size);

		cpu_to_le32(sp->max_fragmented_recv_size);



	request->num_sge = 1;

	request->sge[0].addr = ib_dma_map_single(
@@ -800,6 +803,7 @@ static int smbd_post_send(struct smbd_connection *info, 
		struct smbd_request *request)

{

	struct smbdirect_socket *sc = &info->socket;

	struct smbdirect_socket_parameters *sp = &sc->parameters;

	struct ib_send_wr send_wr;

	int rc, i;
@@ -831,7 +835,7 @@ static int smbd_post_send(struct smbd_connection *info, 
	} else

		/* Reset timer for idle connection after packet is sent */

		mod_delayed_work(info->workqueue, &info->idle_timer_work,

			info->keep_alive_interval*HZ);

			msecs_to_jiffies(sp->keepalive_interval_msec));



	return rc;

}
@@ -841,6 +845,7 @@ static int smbd_post_send_iter(struct smbd_connection *info, 
			       int *_remaining_data_length)

{

	struct smbdirect_socket *sc = &info->socket;

	struct smbdirect_socket_parameters *sp = &sc->parameters;

	int i, rc;

	int header_length;

	int data_length;
@@ -868,7 +873,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) < info->send_credit_target ||

		atomic_read(&info->send_pending) < sp->send_credit_target ||

		sc->status != SMBDIRECT_SOCKET_CONNECTED);



	if (sc->status != SMBDIRECT_SOCKET_CONNECTED) {
@@ -878,7 +883,7 @@ static int smbd_post_send_iter(struct smbd_connection *info, 
	}



	if (unlikely(atomic_inc_return(&info->send_pending) >

				info->send_credit_target)) {

				sp->send_credit_target)) {

		atomic_dec(&info->send_pending);

		goto wait_send_queue;

	}
@@ -917,7 +922,7 @@ static int smbd_post_send_iter(struct smbd_connection *info, 


	/* Fill in the packet header */

	packet = smbd_request_payload(request);

	packet->credits_requested = cpu_to_le16(info->send_credit_target);

	packet->credits_requested = cpu_to_le16(sp->send_credit_target);



	new_credits = manage_credits_prior_sending(info);

	atomic_add(new_credits, &info->receive_credits);
@@ -1017,16 +1022,17 @@ static int smbd_post_recv( 
		struct smbd_connection *info, struct smbd_response *response)

{

	struct smbdirect_socket *sc = &info->socket;

	struct smbdirect_socket_parameters *sp = &sc->parameters;

	struct ib_recv_wr recv_wr;

	int rc = -EIO;



	response->sge.addr = ib_dma_map_single(

				sc->ib.dev, response->packet,

				info->max_receive_size, DMA_FROM_DEVICE);

				sp->max_recv_size, DMA_FROM_DEVICE);

	if (ib_dma_mapping_error(sc->ib.dev, response->sge.addr))

		return rc;



	response->sge.length = info->max_receive_size;

	response->sge.length = sp->max_recv_size;

	response->sge.lkey = sc->ib.pd->local_dma_lkey;



	response->cqe.done = recv_done;
@@ -1274,6 +1280,8 @@ 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_parameters *sp = &sc->parameters;



	if (info->keep_alive_requested != KEEP_ALIVE_NONE) {

		log_keep_alive(ERR,
@@ -1288,7 +1296,7 @@ static void idle_connection_timer(struct work_struct *work) 


	/* Setup the next idle timeout work */

	queue_delayed_work(info->workqueue, &info->idle_timer_work,

			info->keep_alive_interval*HZ);

			msecs_to_jiffies(sp->keepalive_interval_msec));

}



/*
@@ -1300,6 +1308,7 @@ 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 smbd_response *response;

	unsigned long flags;
@@ -1308,6 +1317,7 @@ void smbd_destroy(struct TCP_Server_Info *server) 
		return;

	}

	sc = &info->socket;

	sp = &sc->parameters;



	log_rdma_event(INFO, "destroying rdma session\n");

	if (sc->status != SMBDIRECT_SOCKET_DISCONNECTED) {
@@ -1349,7 +1359,7 @@ void smbd_destroy(struct TCP_Server_Info *server) 
	log_rdma_event(INFO, "free receive buffers\n");

	wait_event(info->wait_receive_queues,

		info->count_receive_queue + info->count_empty_packet_queue

			== info->receive_credit_max);

			== sp->recv_credit_max);

	destroy_receive_buffers(info);



	/*
@@ -1437,6 +1447,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)

{

	struct smbdirect_socket *sc = &info->socket;

	struct smbdirect_socket_parameters *sp = &sc->parameters;

	char name[MAX_NAME_LEN];

	int rc;
@@ -1451,7 +1463,7 @@ static int allocate_caches_and_workqueue(struct smbd_connection *info) 
		return -ENOMEM;



	info->request_mempool =

		mempool_create(info->send_credit_target, mempool_alloc_slab,

		mempool_create(sp->send_credit_target, mempool_alloc_slab,

			mempool_free_slab, info->request_cache);

	if (!info->request_mempool)

		goto out1;
@@ -1461,13 +1473,13 @@ static int allocate_caches_and_workqueue(struct smbd_connection *info) 
		kmem_cache_create(

			name,

			sizeof(struct smbd_response) +

				info->max_receive_size,

				sp->max_recv_size,

			0, SLAB_HWCACHE_ALIGN, NULL);

	if (!info->response_cache)

		goto out2;



	info->response_mempool =

		mempool_create(info->receive_credit_max, mempool_alloc_slab,

		mempool_create(sp->recv_credit_max, mempool_alloc_slab,

		       mempool_free_slab, info->response_cache);

	if (!info->response_mempool)

		goto out3;
@@ -1477,7 +1489,7 @@ static int allocate_caches_and_workqueue(struct smbd_connection *info) 
	if (!info->workqueue)

		goto out4;



	rc = allocate_receive_buffers(info, info->receive_credit_max);

	rc = allocate_receive_buffers(info, sp->recv_credit_max);

	if (rc) {

		log_rdma_event(ERR, "failed to allocate receive buffers\n");

		goto out5;
@@ -1505,6 +1517,7 @@ static struct smbd_connection *_smbd_get_connection( 
	int rc;

	struct smbd_connection *info;

	struct smbdirect_socket *sc;

	struct smbdirect_socket_parameters *sp;

	struct rdma_conn_param conn_param;

	struct ib_qp_init_attr qp_attr;

	struct sockaddr_in *addr_in = (struct sockaddr_in *) dstaddr;
@@ -1515,6 +1528,7 @@ static struct smbd_connection *_smbd_get_connection( 
	if (!info)

		return NULL;

	sc = &info->socket;

	sp = &sc->parameters;



	sc->status = SMBDIRECT_SOCKET_CONNECTING;

	rc = smbd_ia_open(info, dstaddr, port);
@@ -1541,12 +1555,12 @@ static struct smbd_connection *_smbd_get_connection( 
		goto config_failed;

	}



	info->receive_credit_max = smbd_receive_credit_max;

	info->send_credit_target = smbd_send_credit_target;

	info->max_send_size = smbd_max_send_size;

	info->max_fragmented_recv_size = smbd_max_fragmented_recv_size;

	info->max_receive_size = smbd_max_receive_size;

	info->keep_alive_interval = smbd_keep_alive_interval;

	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_MAX_SEND_SGE ||

	    sc->ib.dev->attrs.max_recv_sge < SMBDIRECT_MAX_RECV_SGE) {
@@ -1561,7 +1575,7 @@ static struct smbd_connection *_smbd_get_connection( 


	sc->ib.send_cq =

		ib_alloc_cq_any(sc->ib.dev, info,

				info->send_credit_target, IB_POLL_SOFTIRQ);

				sp->send_credit_target, IB_POLL_SOFTIRQ);

	if (IS_ERR(sc->ib.send_cq)) {

		sc->ib.send_cq = NULL;

		goto alloc_cq_failed;
@@ -1569,7 +1583,7 @@ static struct smbd_connection *_smbd_get_connection( 


	sc->ib.recv_cq =

		ib_alloc_cq_any(sc->ib.dev, info,

				info->receive_credit_max, IB_POLL_SOFTIRQ);

				sp->recv_credit_max, IB_POLL_SOFTIRQ);

	if (IS_ERR(sc->ib.recv_cq)) {

		sc->ib.recv_cq = NULL;

		goto alloc_cq_failed;
@@ -1578,8 +1592,8 @@ 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.cap.max_send_wr = info->send_credit_target;

	qp_attr.cap.max_recv_wr = info->receive_credit_max;

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

	qp_attr.cap.max_recv_sge = SMBDIRECT_MAX_RECV_SGE;

	qp_attr.cap.max_inline_data = 0;
@@ -1654,7 +1668,7 @@ static struct smbd_connection *_smbd_get_connection( 
	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,

		info->keep_alive_interval*HZ);

		msecs_to_jiffies(sp->keepalive_interval_msec));



	init_waitqueue_head(&info->wait_send_pending);

	atomic_set(&info->send_pending, 0);
@@ -1971,6 +1985,7 @@ int smbd_send(struct TCP_Server_Info *server, 
{

	struct smbd_connection *info = server->smbd_conn;

	struct smbdirect_socket *sc = &info->socket;

	struct smbdirect_socket_parameters *sp = &sc->parameters;

	struct smb_rqst *rqst;

	struct iov_iter iter;

	unsigned int remaining_data_length, klen;
@@ -1988,10 +2003,10 @@ int smbd_send(struct TCP_Server_Info *server, 
	for (i = 0; i < num_rqst; i++)

		remaining_data_length += smb_rqst_len(server, &rqst_array[i]);



	if (unlikely(remaining_data_length > info->max_fragmented_send_size)) {

	if (unlikely(remaining_data_length > sp->max_fragmented_send_size)) {

		/* assertion: payload never exceeds negotiated maximum */

		log_write(ERR, "payload size %d > max size %d\n",

			remaining_data_length, info->max_fragmented_send_size);

			remaining_data_length, sp->max_fragmented_send_size);

		return -EINVAL;

	}

fs/smb/client/smbdirect.h

+1 −9
Original line number Diff line number Diff line
@@ -69,15 +69,7 @@ struct smbd_connection { 
	spinlock_t lock_new_credits_offered;

	int new_credits_offered;



	/* Connection parameters defined in [MS-SMBD] 3.1.1.1 */

	int receive_credit_max;

	int send_credit_target;

	int max_send_size;

	int max_fragmented_recv_size;

	int max_fragmented_send_size;

	int max_receive_size;

	int keep_alive_interval;

	int max_readwrite_size;

	/* dynamic connection parameters defined in [MS-SMBD] 3.1.1.1 */

	enum keep_alive_status keep_alive_requested;

	int protocol;

	atomic_t send_credits;