Commit 6787dc24 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag '4.16-rc-SMB3' of git://git.samba.org/sfrench/cifs-2.6 

Pull cifs updates from Steve French:
 "Some fixes for stable, fixed SMB3 DFS support, SMB3 Direct (RDMA) and
  various bug fixes and cleanup"

* tag '4.16-rc-SMB3' of git://git.samba.org/sfrench/cifs-2.6: (60 commits)
  fs/cifs/cifsacl.c Fixes typo in a comment
  update internal version number for cifs.ko
  cifs: add .splice_write
  CIFS: document tcon/ses/server refcount dance
  move a few externs to smbdirect.h to eliminate warning
  CIFS: zero sensitive data when freeing
  Cleanup some minor endian issues in smb3 rdma
  CIFS: dump IPC tcon in debug proc file
  CIFS: use tcon_ipc instead of use_ipc parameter of SMB2_ioctl
  CIFS: make IPC a regular tcon
  cifs: remove redundant duplicated assignment of pointer 'node'
  CIFS: SMBD: work around gcc -Wmaybe-uninitialized warning
  cifs: Fix autonegotiate security settings mismatch
  CIFS: SMBD: _smbd_get_connection() can be static
  CIFS: SMBD: Disable signing on SMB direct transport
  CIFS: SMBD: Add SMB Direct debug counters
  CIFS: SMBD: Upper layer performs SMB read via RDMA write through memory registration
  CIFS: SMBD: Read correct returned data length for RDMA write (SMB read) I/O
  CIFS: SMBD: Upper layer performs SMB write via RDMA read through memory registration
  CIFS: SMBD: Implement RDMA memory registration
  ...
parents a4b7fd7d 36c7ce4a

fs/cifs/Kconfig

+8 −0
Original line number Diff line number Diff line
@@ -196,6 +196,14 @@ config CIFS_SMB311 
	  This dialect includes improved security negotiation features.

	  If unsure, say N



config CIFS_SMB_DIRECT

	bool "SMB Direct support (Experimental)"

	depends on CIFS=m && INFINIBAND || CIFS=y && INFINIBAND=y

	help

	  Enables SMB Direct experimental support for SMB 3.0, 3.02 and 3.1.1.

	  SMB Direct allows transferring SMB packets over RDMA. If unsure,

	  say N.



config CIFS_FSCACHE

	  bool "Provide CIFS client caching support"

	  depends on CIFS=m && FSCACHE || CIFS=y && FSCACHE=y

fs/cifs/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -19,3 +19,5 @@ cifs-$(CONFIG_CIFS_UPCALL) += cifs_spnego.o 
cifs-$(CONFIG_CIFS_DFS_UPCALL) += dns_resolve.o cifs_dfs_ref.o



cifs-$(CONFIG_CIFS_FSCACHE) += fscache.o cache.o



cifs-$(CONFIG_CIFS_SMB_DIRECT) += smbdirect.o

fs/cifs/cifs_debug.c

+173 −26
Original line number Diff line number Diff line
@@ -30,6 +30,9 @@ 
#include "cifsproto.h"

#include "cifs_debug.h"

#include "cifsfs.h"

#ifdef CONFIG_CIFS_SMB_DIRECT

#include "smbdirect.h"

#endif



void

cifs_dump_mem(char *label, void *data, int length)
@@ -107,6 +110,32 @@ void cifs_dump_mids(struct TCP_Server_Info *server) 
}



#ifdef CONFIG_PROC_FS

static void cifs_debug_tcon(struct seq_file *m, struct cifs_tcon *tcon)

{

	__u32 dev_type = le32_to_cpu(tcon->fsDevInfo.DeviceType);



	seq_printf(m, "%s Mounts: %d ", tcon->treeName, tcon->tc_count);

	if (tcon->nativeFileSystem)

		seq_printf(m, "Type: %s ", tcon->nativeFileSystem);

	seq_printf(m, "DevInfo: 0x%x Attributes: 0x%x\n\tPathComponentMax: %d Status: %d",

		   le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics),

		   le32_to_cpu(tcon->fsAttrInfo.Attributes),

		   le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength),

		   tcon->tidStatus);

	if (dev_type == FILE_DEVICE_DISK)

		seq_puts(m, " type: DISK ");

	else if (dev_type == FILE_DEVICE_CD_ROM)

		seq_puts(m, " type: CDROM ");

	else

		seq_printf(m, " type: %d ", dev_type);

	if (tcon->ses->server->ops->dump_share_caps)

		tcon->ses->server->ops->dump_share_caps(m, tcon);



	if (tcon->need_reconnect)

		seq_puts(m, "\tDISCONNECTED ");

	seq_putc(m, '\n');

}



static int cifs_debug_data_proc_show(struct seq_file *m, void *v)

{

	struct list_head *tmp1, *tmp2, *tmp3;
@@ -115,7 +144,6 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v) 
	struct cifs_ses *ses;

	struct cifs_tcon *tcon;

	int i, j;

	__u32 dev_type;



	seq_puts(m,

		    "Display Internal CIFS Data Structures for Debugging\n"
@@ -152,6 +180,72 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v) 
	list_for_each(tmp1, &cifs_tcp_ses_list) {

		server = list_entry(tmp1, struct TCP_Server_Info,

				    tcp_ses_list);



#ifdef CONFIG_CIFS_SMB_DIRECT

		if (!server->rdma)

			goto skip_rdma;



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

			"transport status: %x",

			server->smbd_conn->protocol,

			server->smbd_conn->transport_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);

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

		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,

			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 "

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

			server->smbd_conn->reassembly_data_length,

			server->smbd_conn->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 send_payload_pending:"

			" %x smbd_send_pending: %x smbd_recv_pending: %x",

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

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

			server->smbd_conn->smbd_send_pending,

			server->smbd_conn->smbd_recv_pending);

		seq_printf(m, "\nReceive buffers count_receive_queue: %x "

			"count_empty_packet_queue: %x",

			server->smbd_conn->count_receive_queue,

			server->smbd_conn->count_empty_packet_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));

skip_rdma:

#endif

		seq_printf(m, "\nNumber of credits: %d", server->credits);

		i++;

		list_for_each(tmp2, &server->smb_ses_list) {
@@ -176,6 +270,8 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v) 
				ses->ses_count, ses->serverOS, ses->serverNOS,

				ses->capabilities, ses->status);

			}

			if (server->rdma)

				seq_printf(m, "RDMA\n\t");

			seq_printf(m, "TCP status: %d\n\tLocal Users To "

				   "Server: %d SecMode: 0x%x Req On Wire: %d",

				   server->tcpStatus, server->srv_count,
@@ -189,35 +285,19 @@ static int cifs_debug_data_proc_show(struct seq_file *m, void *v) 


			seq_puts(m, "\n\tShares:");

			j = 0;



			seq_printf(m, "\n\t%d) IPC: ", j);

			if (ses->tcon_ipc)

				cifs_debug_tcon(m, ses->tcon_ipc);

			else

				seq_puts(m, "none\n");



			list_for_each(tmp3, &ses->tcon_list) {

				tcon = list_entry(tmp3, struct cifs_tcon,

						  tcon_list);

				++j;

				dev_type = le32_to_cpu(tcon->fsDevInfo.DeviceType);

				seq_printf(m, "\n\t%d) %s Mounts: %d ", j,

					   tcon->treeName, tcon->tc_count);

				if (tcon->nativeFileSystem) {

					seq_printf(m, "Type: %s ",

						   tcon->nativeFileSystem);

				}

				seq_printf(m, "DevInfo: 0x%x Attributes: 0x%x"

					"\n\tPathComponentMax: %d Status: %d",

					le32_to_cpu(tcon->fsDevInfo.DeviceCharacteristics),

					le32_to_cpu(tcon->fsAttrInfo.Attributes),

					le32_to_cpu(tcon->fsAttrInfo.MaxPathNameComponentLength),

					tcon->tidStatus);

				if (dev_type == FILE_DEVICE_DISK)

					seq_puts(m, " type: DISK ");

				else if (dev_type == FILE_DEVICE_CD_ROM)

					seq_puts(m, " type: CDROM ");

				else

					seq_printf(m, " type: %d ", dev_type);

				if (server->ops->dump_share_caps)

					server->ops->dump_share_caps(m, tcon);



				if (tcon->need_reconnect)

					seq_puts(m, "\tDISCONNECTED ");

				seq_putc(m, '\n');

				seq_printf(m, "\n\t%d) ", j);

				cifs_debug_tcon(m, tcon);

			}



			seq_puts(m, "\n\tMIDs:\n");
@@ -374,6 +454,45 @@ static const struct file_operations cifs_stats_proc_fops = { 
};

#endif /* STATS */



#ifdef CONFIG_CIFS_SMB_DIRECT

#define PROC_FILE_DEFINE(name) \

static ssize_t name##_write(struct file *file, const char __user *buffer, \

	size_t count, loff_t *ppos) \

{ \

	int rc; \

	rc = kstrtoint_from_user(buffer, count, 10, & name); \

	if (rc) \

		return rc; \

	return count; \

} \

static int name##_proc_show(struct seq_file *m, void *v) \

{ \

	seq_printf(m, "%d\n", name ); \

	return 0; \

} \

static int name##_open(struct inode *inode, struct file *file) \

{ \

	return single_open(file, name##_proc_show, NULL); \

} \

\

static const struct file_operations cifs_##name##_proc_fops = { \

	.open		= name##_open, \

	.read		= seq_read, \

	.llseek		= seq_lseek, \

	.release	= single_release, \

	.write		= name##_write, \

}



PROC_FILE_DEFINE(rdma_readwrite_threshold);

PROC_FILE_DEFINE(smbd_max_frmr_depth);

PROC_FILE_DEFINE(smbd_keep_alive_interval);

PROC_FILE_DEFINE(smbd_max_receive_size);

PROC_FILE_DEFINE(smbd_max_fragmented_recv_size);

PROC_FILE_DEFINE(smbd_max_send_size);

PROC_FILE_DEFINE(smbd_send_credit_target);

PROC_FILE_DEFINE(smbd_receive_credit_max);

#endif



static struct proc_dir_entry *proc_fs_cifs;

static const struct file_operations cifsFYI_proc_fops;

static const struct file_operations cifs_lookup_cache_proc_fops;
@@ -401,6 +520,24 @@ cifs_proc_init(void) 
		    &cifs_security_flags_proc_fops);

	proc_create("LookupCacheEnabled", 0, proc_fs_cifs,

		    &cifs_lookup_cache_proc_fops);

#ifdef CONFIG_CIFS_SMB_DIRECT

	proc_create("rdma_readwrite_threshold", 0, proc_fs_cifs,

		&cifs_rdma_readwrite_threshold_proc_fops);

	proc_create("smbd_max_frmr_depth", 0, proc_fs_cifs,

		&cifs_smbd_max_frmr_depth_proc_fops);

	proc_create("smbd_keep_alive_interval", 0, proc_fs_cifs,

		&cifs_smbd_keep_alive_interval_proc_fops);

	proc_create("smbd_max_receive_size", 0, proc_fs_cifs,

		&cifs_smbd_max_receive_size_proc_fops);

	proc_create("smbd_max_fragmented_recv_size", 0, proc_fs_cifs,

		&cifs_smbd_max_fragmented_recv_size_proc_fops);

	proc_create("smbd_max_send_size", 0, proc_fs_cifs,

		&cifs_smbd_max_send_size_proc_fops);

	proc_create("smbd_send_credit_target", 0, proc_fs_cifs,

		&cifs_smbd_send_credit_target_proc_fops);

	proc_create("smbd_receive_credit_max", 0, proc_fs_cifs,

		&cifs_smbd_receive_credit_max_proc_fops);

#endif

}



void
@@ -418,6 +555,16 @@ cifs_proc_clean(void) 
	remove_proc_entry("SecurityFlags", proc_fs_cifs);

	remove_proc_entry("LinuxExtensionsEnabled", proc_fs_cifs);

	remove_proc_entry("LookupCacheEnabled", proc_fs_cifs);

#ifdef CONFIG_CIFS_SMB_DIRECT

	remove_proc_entry("rdma_readwrite_threshold", proc_fs_cifs);

	remove_proc_entry("smbd_max_frmr_depth", proc_fs_cifs);

	remove_proc_entry("smbd_keep_alive_interval", proc_fs_cifs);

	remove_proc_entry("smbd_max_receive_size", proc_fs_cifs);

	remove_proc_entry("smbd_max_fragmented_recv_size", proc_fs_cifs);

	remove_proc_entry("smbd_max_send_size", proc_fs_cifs);

	remove_proc_entry("smbd_send_credit_target", proc_fs_cifs);

	remove_proc_entry("smbd_receive_credit_max", proc_fs_cifs);

#endif

	remove_proc_entry("fs/cifs", NULL);

}

fs/cifs/cifsacl.c

+1 −1
Original line number Diff line number Diff line
@@ -1125,7 +1125,7 @@ out: 
	return rc;

}



/* Translate the CIFS ACL (simlar to NTFS ACL) for a file into mode bits */

/* Translate the CIFS ACL (similar to NTFS ACL) for a file into mode bits */

int

cifs_acl_to_fattr(struct cifs_sb_info *cifs_sb, struct cifs_fattr *fattr,

		  struct inode *inode, const char *path,

fs/cifs/cifsencrypt.c

+1 −2
Original line number Diff line number Diff line
@@ -325,9 +325,8 @@ int calc_lanman_hash(const char *password, const char *cryptkey, bool encrypt, 
{

	int i;

	int rc;

	char password_with_pad[CIFS_ENCPWD_SIZE];

	char password_with_pad[CIFS_ENCPWD_SIZE] = {0};



	memset(password_with_pad, 0, CIFS_ENCPWD_SIZE);

	if (password)

		strncpy(password_with_pad, password, CIFS_ENCPWD_SIZE);

CRA Git | Maintained and supported by SUSTech CRA and CCSE