[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / cifs / smb2ops.c

/*
 *  SMB2 version specific operations
 *
 *  Copyright (c) 2012, Jeff Layton <jlayton@redhat.com>
 *
 *  This library is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License v2 as published
 *  by the Free Software Foundation.
 *
 *  This library is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 *  the GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with this library; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */

#include <linux/pagemap.h>
#include "cifsglob.h"
#include "smb2pdu.h"
#include "smb2proto.h"
#include "cifsproto.h"
#include "cifs_debug.h"

static int
change_conf(struct TCP_Server_Info *server)
{
	server->credits += server->echo_credits + server->oplock_credits;
	server->oplock_credits = server->echo_credits = 0;
	switch (server->credits) {
	case 0:
		return -1;
	case 1:
		server->echoes = false;
		server->oplocks = false;
		cERROR(1, "disabling echoes and oplocks");
		break;
	case 2:
		server->echoes = true;
		server->oplocks = false;
		server->echo_credits = 1;
		cFYI(1, "disabling oplocks");
		break;
	default:
		server->echoes = true;
		server->oplocks = true;
		server->echo_credits = 1;
		server->oplock_credits = 1;
	}
	server->credits -= server->echo_credits + server->oplock_credits;
	return 0;
}

static void
smb2_add_credits(struct TCP_Server_Info *server, const unsigned int add,
		 const int optype)
{
	int *val, rc = 0;
	spin_lock(&server->req_lock);
	val = server->ops->get_credits_field(server, optype);
	*val += add;
	server->in_flight--;
	if (server->in_flight == 0 && (optype & CIFS_OP_MASK) != CIFS_NEG_OP)
		rc = change_conf(server);
	spin_unlock(&server->req_lock);
	wake_up(&server->request_q);
	if (rc)
		cifs_reconnect(server);
}

static void
smb2_set_credits(struct TCP_Server_Info *server, const int val)
{
	spin_lock(&server->req_lock);
	server->credits = val;
	spin_unlock(&server->req_lock);
}

static int *
smb2_get_credits_field(struct TCP_Server_Info *server, const int optype)
{
	switch (optype) {
	case CIFS_ECHO_OP:
		return &server->echo_credits;
	case CIFS_OBREAK_OP:
		return &server->oplock_credits;
	default:
		return &server->credits;
	}
}

static unsigned int
smb2_get_credits(struct mid_q_entry *mid)
{
	return le16_to_cpu(((struct smb2_hdr *)mid->resp_buf)->CreditRequest);
}

static __u64
smb2_get_next_mid(struct TCP_Server_Info *server)
{
	__u64 mid;
	/* for SMB2 we need the current value */
	spin_lock(&GlobalMid_Lock);
	mid = server->CurrentMid++;
	spin_unlock(&GlobalMid_Lock);
	return mid;
}

static struct mid_q_entry *
smb2_find_mid(struct TCP_Server_Info *server, char *buf)
{
	struct mid_q_entry *mid;
	struct smb2_hdr *hdr = (struct smb2_hdr *)buf;

	spin_lock(&GlobalMid_Lock);
	list_for_each_entry(mid, &server->pending_mid_q, qhead) {
		if ((mid->mid == hdr->MessageId) &&
		    (mid->mid_state == MID_REQUEST_SUBMITTED) &&
		    (mid->command == hdr->Command)) {
			spin_unlock(&GlobalMid_Lock);
			return mid;
		}
	}
	spin_unlock(&GlobalMid_Lock);
	return NULL;
}

static void
smb2_dump_detail(void *buf)
{
#ifdef CONFIG_CIFS_DEBUG2
	struct smb2_hdr *smb = (struct smb2_hdr *)buf;

	cERROR(1, "Cmd: %d Err: 0x%x Flags: 0x%x Mid: %llu Pid: %d",
		  smb->Command, smb->Status, smb->Flags, smb->MessageId,
		  smb->ProcessId);
	cERROR(1, "smb buf %p len %u", smb, smb2_calc_size(smb));
#endif
}

static bool
smb2_need_neg(struct TCP_Server_Info *server)
{
	return server->max_read == 0;
}

static int
smb2_negotiate(const unsigned int xid, struct cifs_ses *ses)
{
	int rc;
	ses->server->CurrentMid = 0;
	rc = SMB2_negotiate(xid, ses);
	/* BB we probably don't need to retry with modern servers */
	if (rc == -EAGAIN)
		rc = -EHOSTDOWN;
	return rc;
}

static unsigned int
smb2_negotiate_wsize(struct cifs_tcon *tcon, struct smb_vol *volume_info)
{
	struct TCP_Server_Info *server = tcon->ses->server;
	unsigned int wsize;

	/* start with specified wsize, or default */
	wsize = volume_info->wsize ? volume_info->wsize : CIFS_DEFAULT_IOSIZE;
	wsize = min_t(unsigned int, wsize, server->max_write);
	/*
	 * limit write size to 2 ** 16, because we don't support multicredit
	 * requests now.
	 */
	wsize = min_t(unsigned int, wsize, 2 << 15);

	/* limit to the amount that we can kmap at once */
	wsize = min_t(unsigned int, wsize, CIFS_KMAP_SIZE_LIMIT);

	return wsize;
}

static unsigned int
smb2_negotiate_rsize(struct cifs_tcon *tcon, struct smb_vol *volume_info)
{
	struct TCP_Server_Info *server = tcon->ses->server;
	unsigned int rsize;

	/* start with specified rsize, or default */
	rsize = volume_info->rsize ? volume_info->rsize : CIFS_DEFAULT_IOSIZE;
	rsize = min_t(unsigned int, rsize, server->max_read);
	/*
	 * limit write size to 2 ** 16, because we don't support multicredit
	 * requests now.
	 */
	rsize = min_t(unsigned int, rsize, 2 << 15);

	/* limit to the amount that we can kmap at once */
	rsize = min_t(unsigned int, rsize, CIFS_KMAP_SIZE_LIMIT);

	return rsize;
}

static int
smb2_is_path_accessible(const unsigned int xid, struct cifs_tcon *tcon,
			struct cifs_sb_info *cifs_sb, const char *full_path)
{
	int rc;
	__u64 persistent_fid, volatile_fid;
	__le16 *utf16_path;

	utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
	if (!utf16_path)
		return -ENOMEM;

	rc = SMB2_open(xid, tcon, utf16_path, &persistent_fid, &volatile_fid,
		       FILE_READ_ATTRIBUTES, FILE_OPEN, 0, 0, NULL);
	if (rc) {
		kfree(utf16_path);
		return rc;
	}

	rc = SMB2_close(xid, tcon, persistent_fid, volatile_fid);
	kfree(utf16_path);
	return rc;
}

static int
smb2_get_srv_inum(const unsigned int xid, struct cifs_tcon *tcon,
		  struct cifs_sb_info *cifs_sb, const char *full_path,
		  u64 *uniqueid, FILE_ALL_INFO *data)
{
	*uniqueid = le64_to_cpu(data->IndexNumber);
	return 0;
}

static int
smb2_query_file_info(const unsigned int xid, struct cifs_tcon *tcon,
		     struct cifs_fid *fid, FILE_ALL_INFO *data)
{
	int rc;
	struct smb2_file_all_info *smb2_data;

	smb2_data = kzalloc(sizeof(struct smb2_file_all_info) + MAX_NAME * 2,
			    GFP_KERNEL);
	if (smb2_data == NULL)
		return -ENOMEM;

	rc = SMB2_query_info(xid, tcon, fid->persistent_fid, fid->volatile_fid,
			     smb2_data);
	if (!rc)
		move_smb2_info_to_cifs(data, smb2_data);
	kfree(smb2_data);
	return rc;
}

static char *
smb2_build_path_to_root(struct smb_vol *vol, struct cifs_sb_info *cifs_sb,
			struct cifs_tcon *tcon)
{
	int pplen = vol->prepath ? strlen(vol->prepath) : 0;
	char *full_path = NULL;

	/* if no prefix path, simply set path to the root of share to "" */
	if (pplen == 0) {
		full_path = kzalloc(2, GFP_KERNEL);
		return full_path;
	}

	cERROR(1, "prefixpath is not supported for SMB2 now");
	return NULL;
}

static bool
smb2_can_echo(struct TCP_Server_Info *server)
{
	return server->echoes;
}

static void
smb2_clear_stats(struct cifs_tcon *tcon)
{
#ifdef CONFIG_CIFS_STATS
	int i;
	for (i = 0; i < NUMBER_OF_SMB2_COMMANDS; i++) {
		atomic_set(&tcon->stats.smb2_stats.smb2_com_sent[i], 0);
		atomic_set(&tcon->stats.smb2_stats.smb2_com_failed[i], 0);
	}
#endif
}

static void
smb2_print_stats(struct seq_file *m, struct cifs_tcon *tcon)
{
#ifdef CONFIG_CIFS_STATS
	atomic_t *sent = tcon->stats.smb2_stats.smb2_com_sent;
	atomic_t *failed = tcon->stats.smb2_stats.smb2_com_failed;
	seq_printf(m, "\nNegotiates: %d sent %d failed",
		   atomic_read(&sent[SMB2_NEGOTIATE_HE]),
		   atomic_read(&failed[SMB2_NEGOTIATE_HE]));
	seq_printf(m, "\nSessionSetups: %d sent %d failed",
		   atomic_read(&sent[SMB2_SESSION_SETUP_HE]),
		   atomic_read(&failed[SMB2_SESSION_SETUP_HE]));
#define SMB2LOGOFF		0x0002 /* trivial request/resp */
	seq_printf(m, "\nLogoffs: %d sent %d failed",
		   atomic_read(&sent[SMB2_LOGOFF_HE]),
		   atomic_read(&failed[SMB2_LOGOFF_HE]));
	seq_printf(m, "\nTreeConnects: %d sent %d failed",
		   atomic_read(&sent[SMB2_TREE_CONNECT_HE]),
		   atomic_read(&failed[SMB2_TREE_CONNECT_HE]));
	seq_printf(m, "\nTreeDisconnects: %d sent %d failed",
		   atomic_read(&sent[SMB2_TREE_DISCONNECT_HE]),
		   atomic_read(&failed[SMB2_TREE_DISCONNECT_HE]));
	seq_printf(m, "\nCreates: %d sent %d failed",
		   atomic_read(&sent[SMB2_CREATE_HE]),
		   atomic_read(&failed[SMB2_CREATE_HE]));
	seq_printf(m, "\nCloses: %d sent %d failed",
		   atomic_read(&sent[SMB2_CLOSE_HE]),
		   atomic_read(&failed[SMB2_CLOSE_HE]));
	seq_printf(m, "\nFlushes: %d sent %d failed",
		   atomic_read(&sent[SMB2_FLUSH_HE]),
		   atomic_read(&failed[SMB2_FLUSH_HE]));
	seq_printf(m, "\nReads: %d sent %d failed",
		   atomic_read(&sent[SMB2_READ_HE]),
		   atomic_read(&failed[SMB2_READ_HE]));
	seq_printf(m, "\nWrites: %d sent %d failed",
		   atomic_read(&sent[SMB2_WRITE_HE]),
		   atomic_read(&failed[SMB2_WRITE_HE]));
	seq_printf(m, "\nLocks: %d sent %d failed",
		   atomic_read(&sent[SMB2_LOCK_HE]),
		   atomic_read(&failed[SMB2_LOCK_HE]));
	seq_printf(m, "\nIOCTLs: %d sent %d failed",
		   atomic_read(&sent[SMB2_IOCTL_HE]),
		   atomic_read(&failed[SMB2_IOCTL_HE]));
	seq_printf(m, "\nCancels: %d sent %d failed",
		   atomic_read(&sent[SMB2_CANCEL_HE]),
		   atomic_read(&failed[SMB2_CANCEL_HE]));
	seq_printf(m, "\nEchos: %d sent %d failed",
		   atomic_read(&sent[SMB2_ECHO_HE]),
		   atomic_read(&failed[SMB2_ECHO_HE]));
	seq_printf(m, "\nQueryDirectories: %d sent %d failed",
		   atomic_read(&sent[SMB2_QUERY_DIRECTORY_HE]),
		   atomic_read(&failed[SMB2_QUERY_DIRECTORY_HE]));
	seq_printf(m, "\nChangeNotifies: %d sent %d failed",
		   atomic_read(&sent[SMB2_CHANGE_NOTIFY_HE]),
		   atomic_read(&failed[SMB2_CHANGE_NOTIFY_HE]));
	seq_printf(m, "\nQueryInfos: %d sent %d failed",
		   atomic_read(&sent[SMB2_QUERY_INFO_HE]),
		   atomic_read(&failed[SMB2_QUERY_INFO_HE]));
	seq_printf(m, "\nSetInfos: %d sent %d failed",
		   atomic_read(&sent[SMB2_SET_INFO_HE]),
		   atomic_read(&failed[SMB2_SET_INFO_HE]));
	seq_printf(m, "\nOplockBreaks: %d sent %d failed",
		   atomic_read(&sent[SMB2_OPLOCK_BREAK_HE]),
		   atomic_read(&failed[SMB2_OPLOCK_BREAK_HE]));
#endif
}

static void
smb2_set_fid(struct cifsFileInfo *cfile, struct cifs_fid *fid, __u32 oplock)
{
	/* struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode); */
	cfile->fid.persistent_fid = fid->persistent_fid;
	cfile->fid.volatile_fid = fid->volatile_fid;
	/* cifs_set_oplock_level(cinode, oplock); */
	/* cinode->can_cache_brlcks = cinode->clientCanCacheAll; */
}

static int
smb2_close_file(const unsigned int xid, struct cifs_tcon *tcon,
		struct cifs_fid *fid)
{
	return SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
}

static int
smb2_flush_file(const unsigned int xid, struct cifs_tcon *tcon,
		struct cifs_fid *fid)
{
	return SMB2_flush(xid, tcon, fid->persistent_fid, fid->volatile_fid);
}

static unsigned int
smb2_read_data_offset(char *buf)
{
	struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf;
	return rsp->DataOffset;
}

static unsigned int
smb2_read_data_length(char *buf)
{
	struct smb2_read_rsp *rsp = (struct smb2_read_rsp *)buf;
	return le32_to_cpu(rsp->DataLength);
}


static int
smb2_sync_read(const unsigned int xid, struct cifsFileInfo *cfile,
	       struct cifs_io_parms *parms, unsigned int *bytes_read,
	       char **buf, int *buf_type)
{
	parms->persistent_fid = cfile->fid.persistent_fid;
	parms->volatile_fid = cfile->fid.volatile_fid;
	return SMB2_read(xid, parms, bytes_read, buf, buf_type);
}

static int
smb2_sync_write(const unsigned int xid, struct cifsFileInfo *cfile,
		struct cifs_io_parms *parms, unsigned int *written,
		struct kvec *iov, unsigned long nr_segs)
{

	parms->persistent_fid = cfile->fid.persistent_fid;
	parms->volatile_fid = cfile->fid.volatile_fid;
	return SMB2_write(xid, parms, written, iov, nr_segs);
}

struct smb_version_operations smb21_operations = {
	.setup_request = smb2_setup_request,
	.setup_async_request = smb2_setup_async_request,
	.check_receive = smb2_check_receive,
	.add_credits = smb2_add_credits,
	.set_credits = smb2_set_credits,
	.get_credits_field = smb2_get_credits_field,
	.get_credits = smb2_get_credits,
	.get_next_mid = smb2_get_next_mid,
	.read_data_offset = smb2_read_data_offset,
	.read_data_length = smb2_read_data_length,
	.map_error = map_smb2_to_linux_error,
	.find_mid = smb2_find_mid,
	.check_message = smb2_check_message,
	.dump_detail = smb2_dump_detail,
	.clear_stats = smb2_clear_stats,
	.print_stats = smb2_print_stats,
	.need_neg = smb2_need_neg,
	.negotiate = smb2_negotiate,
	.negotiate_wsize = smb2_negotiate_wsize,
	.negotiate_rsize = smb2_negotiate_rsize,
	.sess_setup = SMB2_sess_setup,
	.logoff = SMB2_logoff,
	.tree_connect = SMB2_tcon,
	.tree_disconnect = SMB2_tdis,
	.is_path_accessible = smb2_is_path_accessible,
	.can_echo = smb2_can_echo,
	.echo = SMB2_echo,
	.query_path_info = smb2_query_path_info,
	.get_srv_inum = smb2_get_srv_inum,
	.query_file_info = smb2_query_file_info,
	.build_path_to_root = smb2_build_path_to_root,
	.mkdir = smb2_mkdir,
	.mkdir_setinfo = smb2_mkdir_setinfo,
	.rmdir = smb2_rmdir,
	.unlink = smb2_unlink,
	.open = smb2_open_file,
	.set_fid = smb2_set_fid,
	.close = smb2_close_file,
	.flush = smb2_flush_file,
	.async_readv = smb2_async_readv,
	.async_writev = smb2_async_writev,
	.sync_read = smb2_sync_read,
	.sync_write = smb2_sync_write,
};

struct smb_version_values smb21_values = {
	.version_string = SMB21_VERSION_STRING,
	.header_size = sizeof(struct smb2_hdr),
	.max_header_size = MAX_SMB2_HDR_SIZE,
	.read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
	.lock_cmd = SMB2_LOCK,
	.cap_unix = 0,
	.cap_nt_find = SMB2_NT_FIND,
	.cap_large_files = SMB2_LARGE_FILES,
};
Commit	Line	Data
1080ef75 SF	1	/*
	2	* SMB2 version specific operations
	3	*
	4	* Copyright (c) 2012, Jeff Layton <jlayton@redhat.com>
	5	*
	6	* This library is free software; you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License v2 as published
	8	* by the Free Software Foundation.
	9	*
	10	* This library is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
	13	* the GNU Lesser General Public License for more details.
	14	*
	15	* You should have received a copy of the GNU Lesser General Public License
	16	* along with this library; if not, write to the Free Software
	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	18	*/
	19
3a3bab50	20	#include <linux/pagemap.h>
1080ef75	21	#include "cifsglob.h"
2dc7e1c0 PS	22	#include "smb2pdu.h"
2dc7e1c0 PS	23	#include "smb2proto.h"
28ea5290 PS	24	#include "cifsproto.h"
	25	#include "cifs_debug.h"
	26
	27	static int
	28	change_conf(struct TCP_Server_Info *server)
	29	{
	30	server->credits += server->echo_credits + server->oplock_credits;
	31	server->oplock_credits = server->echo_credits = 0;
	32	switch (server->credits) {
	33	case 0:
	34	return -1;
	35	case 1:
	36	server->echoes = false;
	37	server->oplocks = false;
	38	cERROR(1, "disabling echoes and oplocks");
	39	break;
	40	case 2:
	41	server->echoes = true;
	42	server->oplocks = false;
	43	server->echo_credits = 1;
	44	cFYI(1, "disabling oplocks");
	45	break;
	46	default:
	47	server->echoes = true;
	48	server->oplocks = true;
	49	server->echo_credits = 1;
	50	server->oplock_credits = 1;
	51	}
	52	server->credits -= server->echo_credits + server->oplock_credits;
	53	return 0;
	54	}
	55
	56	static void
	57	smb2_add_credits(struct TCP_Server_Info *server, const unsigned int add,
	58	const int optype)
	59	{
	60	int *val, rc = 0;
	61	spin_lock(&server->req_lock);
	62	val = server->ops->get_credits_field(server, optype);
	63	*val += add;
	64	server->in_flight--;
ec2e4523	65	if (server->in_flight == 0 && (optype & CIFS_OP_MASK) != CIFS_NEG_OP)
28ea5290 PS	66	rc = change_conf(server);
	67	spin_unlock(&server->req_lock);
	68	wake_up(&server->request_q);
	69	if (rc)
	70	cifs_reconnect(server);
	71	}
	72
	73	static void
	74	smb2_set_credits(struct TCP_Server_Info *server, const int val)
	75	{
	76	spin_lock(&server->req_lock);
	77	server->credits = val;
	78	spin_unlock(&server->req_lock);
	79	}
	80
	81	static int *
	82	smb2_get_credits_field(struct TCP_Server_Info *server, const int optype)
	83	{
	84	switch (optype) {
	85	case CIFS_ECHO_OP:
	86	return &server->echo_credits;
	87	case CIFS_OBREAK_OP:
	88	return &server->oplock_credits;
	89	default:
	90	return &server->credits;
	91	}
	92	}
	93
	94	static unsigned int
	95	smb2_get_credits(struct mid_q_entry *mid)
	96	{
	97	return le16_to_cpu(((struct smb2_hdr *)mid->resp_buf)->CreditRequest);
	98	}
2dc7e1c0 PS	99
	100	static __u64
	101	smb2_get_next_mid(struct TCP_Server_Info *server)
	102	{
	103	__u64 mid;
	104	/* for SMB2 we need the current value */
	105	spin_lock(&GlobalMid_Lock);
	106	mid = server->CurrentMid++;
	107	spin_unlock(&GlobalMid_Lock);
	108	return mid;
	109	}
1080ef75	110
093b2bda PS	111	static struct mid_q_entry *
	112	smb2_find_mid(struct TCP_Server_Info server, char buf)
	113	{
	114	struct mid_q_entry *mid;
	115	struct smb2_hdr hdr = (struct smb2_hdr )buf;
	116
	117	spin_lock(&GlobalMid_Lock);
	118	list_for_each_entry(mid, &server->pending_mid_q, qhead) {
	119	if ((mid->mid == hdr->MessageId) &&
	120	(mid->mid_state == MID_REQUEST_SUBMITTED) &&
	121	(mid->command == hdr->Command)) {
	122	spin_unlock(&GlobalMid_Lock);
	123	return mid;
	124	}
	125	}
	126	spin_unlock(&GlobalMid_Lock);
	127	return NULL;
	128	}
	129
	130	static void
	131	smb2_dump_detail(void *buf)
	132	{
	133	#ifdef CONFIG_CIFS_DEBUG2
	134	struct smb2_hdr smb = (struct smb2_hdr )buf;
	135
	136	cERROR(1, "Cmd: %d Err: 0x%x Flags: 0x%x Mid: %llu Pid: %d",
	137	smb->Command, smb->Status, smb->Flags, smb->MessageId,
	138	smb->ProcessId);
	139	cERROR(1, "smb buf %p len %u", smb, smb2_calc_size(smb));
	140	#endif
	141	}
	142
ec2e4523 PS	143	static bool
	144	smb2_need_neg(struct TCP_Server_Info *server)
	145	{
	146	return server->max_read == 0;
	147	}
	148
	149	static int
	150	smb2_negotiate(const unsigned int xid, struct cifs_ses *ses)
	151	{
	152	int rc;
	153	ses->server->CurrentMid = 0;
	154	rc = SMB2_negotiate(xid, ses);
	155	/* BB we probably don't need to retry with modern servers */
	156	if (rc == -EAGAIN)
	157	rc = -EHOSTDOWN;
	158	return rc;
	159	}
	160
3a3bab50 PS	161	static unsigned int
	162	smb2_negotiate_wsize(struct cifs_tcon tcon, struct smb_vol volume_info)
	163	{
	164	struct TCP_Server_Info *server = tcon->ses->server;
	165	unsigned int wsize;
	166
	167	/* start with specified wsize, or default */
	168	wsize = volume_info->wsize ? volume_info->wsize : CIFS_DEFAULT_IOSIZE;
	169	wsize = min_t(unsigned int, wsize, server->max_write);
	170	/*
	171	* limit write size to 2 ** 16, because we don't support multicredit
	172	* requests now.
	173	*/
	174	wsize = min_t(unsigned int, wsize, 2 << 15);
	175
	176	/* limit to the amount that we can kmap at once */
	177	wsize = min_t(unsigned int, wsize, CIFS_KMAP_SIZE_LIMIT);
	178
	179	return wsize;
	180	}
	181
	182	static unsigned int
	183	smb2_negotiate_rsize(struct cifs_tcon tcon, struct smb_vol volume_info)
	184	{
	185	struct TCP_Server_Info *server = tcon->ses->server;
	186	unsigned int rsize;
	187
	188	/* start with specified rsize, or default */
	189	rsize = volume_info->rsize ? volume_info->rsize : CIFS_DEFAULT_IOSIZE;
	190	rsize = min_t(unsigned int, rsize, server->max_read);
	191	/*
	192	* limit write size to 2 ** 16, because we don't support multicredit
	193	* requests now.
	194	*/
	195	rsize = min_t(unsigned int, rsize, 2 << 15);
	196
	197	/* limit to the amount that we can kmap at once */
	198	rsize = min_t(unsigned int, rsize, CIFS_KMAP_SIZE_LIMIT);
	199
	200	return rsize;
	201	}
	202
2503a0db PS	203	static int
	204	smb2_is_path_accessible(const unsigned int xid, struct cifs_tcon *tcon,
	205	struct cifs_sb_info cifs_sb, const char full_path)
	206	{
	207	int rc;
	208	__u64 persistent_fid, volatile_fid;
	209	__le16 *utf16_path;
	210
	211	utf16_path = cifs_convert_path_to_utf16(full_path, cifs_sb);
	212	if (!utf16_path)
	213	return -ENOMEM;
	214
	215	rc = SMB2_open(xid, tcon, utf16_path, &persistent_fid, &volatile_fid,
f0df737e	216	FILE_READ_ATTRIBUTES, FILE_OPEN, 0, 0, NULL);
2503a0db PS	217	if (rc) {
	218	kfree(utf16_path);
	219	return rc;
	220	}
	221
	222	rc = SMB2_close(xid, tcon, persistent_fid, volatile_fid);
	223	kfree(utf16_path);
	224	return rc;
	225	}
	226
be4cb9e3 PS	227	static int
	228	smb2_get_srv_inum(const unsigned int xid, struct cifs_tcon *tcon,
	229	struct cifs_sb_info cifs_sb, const char full_path,
	230	u64 uniqueid, FILE_ALL_INFO data)
	231	{
	232	*uniqueid = le64_to_cpu(data->IndexNumber);
	233	return 0;
	234	}
	235
b7546bc5 PS	236	static int
	237	smb2_query_file_info(const unsigned int xid, struct cifs_tcon *tcon,
	238	struct cifs_fid fid, FILE_ALL_INFO data)
	239	{
	240	int rc;
	241	struct smb2_file_all_info *smb2_data;
	242
	243	smb2_data = kzalloc(sizeof(struct smb2_file_all_info) + MAX_NAME * 2,
	244	GFP_KERNEL);
	245	if (smb2_data == NULL)
	246	return -ENOMEM;
	247
	248	rc = SMB2_query_info(xid, tcon, fid->persistent_fid, fid->volatile_fid,
	249	smb2_data);
	250	if (!rc)
	251	move_smb2_info_to_cifs(data, smb2_data);
	252	kfree(smb2_data);
	253	return rc;
	254	}
	255
25e26632 PS	256	static char *
	257	smb2_build_path_to_root(struct smb_vol vol, struct cifs_sb_info cifs_sb,
	258	struct cifs_tcon *tcon)
	259	{
	260	int pplen = vol->prepath ? strlen(vol->prepath) : 0;
	261	char *full_path = NULL;
	262
	263	/* if no prefix path, simply set path to the root of share to "" */
	264	if (pplen == 0) {
	265	full_path = kzalloc(2, GFP_KERNEL);
	266	return full_path;
	267	}
	268
	269	cERROR(1, "prefixpath is not supported for SMB2 now");
	270	return NULL;
	271	}
	272
9094fad1 PS	273	static bool
	274	smb2_can_echo(struct TCP_Server_Info *server)
	275	{
	276	return server->echoes;
	277	}
	278
d60622eb PS	279	static void
	280	smb2_clear_stats(struct cifs_tcon *tcon)
	281	{
	282	#ifdef CONFIG_CIFS_STATS
	283	int i;
	284	for (i = 0; i < NUMBER_OF_SMB2_COMMANDS; i++) {
	285	atomic_set(&tcon->stats.smb2_stats.smb2_com_sent[i], 0);
	286	atomic_set(&tcon->stats.smb2_stats.smb2_com_failed[i], 0);
	287	}
	288	#endif
	289	}
	290
	291	static void
	292	smb2_print_stats(struct seq_file m, struct cifs_tcon tcon)
	293	{
	294	#ifdef CONFIG_CIFS_STATS
	295	atomic_t *sent = tcon->stats.smb2_stats.smb2_com_sent;
	296	atomic_t *failed = tcon->stats.smb2_stats.smb2_com_failed;
	297	seq_printf(m, "\nNegotiates: %d sent %d failed",
	298	atomic_read(&sent[SMB2_NEGOTIATE_HE]),
	299	atomic_read(&failed[SMB2_NEGOTIATE_HE]));
	300	seq_printf(m, "\nSessionSetups: %d sent %d failed",
	301	atomic_read(&sent[SMB2_SESSION_SETUP_HE]),
	302	atomic_read(&failed[SMB2_SESSION_SETUP_HE]));
	303	#define SMB2LOGOFF 0x0002 /* trivial request/resp */
	304	seq_printf(m, "\nLogoffs: %d sent %d failed",
	305	atomic_read(&sent[SMB2_LOGOFF_HE]),
	306	atomic_read(&failed[SMB2_LOGOFF_HE]));
	307	seq_printf(m, "\nTreeConnects: %d sent %d failed",
	308	atomic_read(&sent[SMB2_TREE_CONNECT_HE]),
	309	atomic_read(&failed[SMB2_TREE_CONNECT_HE]));
	310	seq_printf(m, "\nTreeDisconnects: %d sent %d failed",
	311	atomic_read(&sent[SMB2_TREE_DISCONNECT_HE]),
	312	atomic_read(&failed[SMB2_TREE_DISCONNECT_HE]));
	313	seq_printf(m, "\nCreates: %d sent %d failed",
	314	atomic_read(&sent[SMB2_CREATE_HE]),
	315	atomic_read(&failed[SMB2_CREATE_HE]));
	316	seq_printf(m, "\nCloses: %d sent %d failed",
	317	atomic_read(&sent[SMB2_CLOSE_HE]),
	318	atomic_read(&failed[SMB2_CLOSE_HE]));
	319	seq_printf(m, "\nFlushes: %d sent %d failed",
	320	atomic_read(&sent[SMB2_FLUSH_HE]),
	321	atomic_read(&failed[SMB2_FLUSH_HE]));
	322	seq_printf(m, "\nReads: %d sent %d failed",
	323	atomic_read(&sent[SMB2_READ_HE]),
	324	atomic_read(&failed[SMB2_READ_HE]));
	325	seq_printf(m, "\nWrites: %d sent %d failed",
	326	atomic_read(&sent[SMB2_WRITE_HE]),
	327	atomic_read(&failed[SMB2_WRITE_HE]));
	328	seq_printf(m, "\nLocks: %d sent %d failed",
	329	atomic_read(&sent[SMB2_LOCK_HE]),
	330	atomic_read(&failed[SMB2_LOCK_HE]));
	331	seq_printf(m, "\nIOCTLs: %d sent %d failed",
	332	atomic_read(&sent[SMB2_IOCTL_HE]),
	333	atomic_read(&failed[SMB2_IOCTL_HE]));
	334	seq_printf(m, "\nCancels: %d sent %d failed",
	335	atomic_read(&sent[SMB2_CANCEL_HE]),
	336	atomic_read(&failed[SMB2_CANCEL_HE]));
	337	seq_printf(m, "\nEchos: %d sent %d failed",
	338	atomic_read(&sent[SMB2_ECHO_HE]),
	339	atomic_read(&failed[SMB2_ECHO_HE]));
	340	seq_printf(m, "\nQueryDirectories: %d sent %d failed",
	341	atomic_read(&sent[SMB2_QUERY_DIRECTORY_HE]),
	342	atomic_read(&failed[SMB2_QUERY_DIRECTORY_HE]));
343	seq_printf(m, "\nChangeNotifies: %d sent %d failed",
344	atomic_read(&sent[SMB2_CHANGE_NOTIFY_HE]),
345	atomic_read(&failed[SMB2_CHANGE_NOTIFY_HE]));
346	seq_printf(m, "\nQueryInfos: %d sent %d failed",
347	atomic_read(&sent[SMB2_QUERY_INFO_HE]),
348	atomic_read(&failed[SMB2_QUERY_INFO_HE]));
349	seq_printf(m, "\nSetInfos: %d sent %d failed",
350	atomic_read(&sent[SMB2_SET_INFO_HE]),
351	atomic_read(&failed[SMB2_SET_INFO_HE]));
352	seq_printf(m, "\nOplockBreaks: %d sent %d failed",
353	atomic_read(&sent[SMB2_OPLOCK_BREAK_HE]),
354	atomic_read(&failed[SMB2_OPLOCK_BREAK_HE]));
355	#endif
356	}
357
f0df737e PS	358	static void
	359	smb2_set_fid(struct cifsFileInfo cfile, struct cifs_fid fid, __u32 oplock)
	360	{
	361	/* struct cifsInodeInfo cinode = CIFS_I(cfile->dentry->d_inode); /
	362	cfile->fid.persistent_fid = fid->persistent_fid;
	363	cfile->fid.volatile_fid = fid->volatile_fid;
	364	/* cifs_set_oplock_level(cinode, oplock); */
	365	/* cinode->can_cache_brlcks = cinode->clientCanCacheAll; */
	366	}
	367
	368	static int
	369	smb2_close_file(const unsigned int xid, struct cifs_tcon *tcon,
	370	struct cifs_fid *fid)
	371	{
	372	return SMB2_close(xid, tcon, fid->persistent_fid, fid->volatile_fid);
	373	}
	374
7a5cfb19 PS	375	static int
	376	smb2_flush_file(const unsigned int xid, struct cifs_tcon *tcon,
	377	struct cifs_fid *fid)
	378	{
	379	return SMB2_flush(xid, tcon, fid->persistent_fid, fid->volatile_fid);
	380	}
	381
09a4707e PS	382	static unsigned int
	383	smb2_read_data_offset(char *buf)
	384	{
	385	struct smb2_read_rsp rsp = (struct smb2_read_rsp )buf;
	386	return rsp->DataOffset;
	387	}
	388
	389	static unsigned int
	390	smb2_read_data_length(char *buf)
	391	{
	392	struct smb2_read_rsp rsp = (struct smb2_read_rsp )buf;
	393	return le32_to_cpu(rsp->DataLength);
	394	}
	395
d8e05039 PS	396
	397	static int
	398	smb2_sync_read(const unsigned int xid, struct cifsFileInfo *cfile,
	399	struct cifs_io_parms parms, unsigned int bytes_read,
	400	char *buf, int buf_type)
	401	{
	402	parms->persistent_fid = cfile->fid.persistent_fid;
	403	parms->volatile_fid = cfile->fid.volatile_fid;
	404	return SMB2_read(xid, parms, bytes_read, buf, buf_type);
	405	}
	406
009d3443 PS	407	static int
	408	smb2_sync_write(const unsigned int xid, struct cifsFileInfo *cfile,
	409	struct cifs_io_parms parms, unsigned int written,
	410	struct kvec *iov, unsigned long nr_segs)
	411	{
	412
	413	parms->persistent_fid = cfile->fid.persistent_fid;
	414	parms->volatile_fid = cfile->fid.volatile_fid;
	415	return SMB2_write(xid, parms, written, iov, nr_segs);
	416	}
	417
1080ef75	418	struct smb_version_operations smb21_operations = {
2dc7e1c0	419	.setup_request = smb2_setup_request,
c95b8eed	420	.setup_async_request = smb2_setup_async_request,
2dc7e1c0	421	.check_receive = smb2_check_receive,
28ea5290 PS	422	.add_credits = smb2_add_credits,
	423	.set_credits = smb2_set_credits,
	424	.get_credits_field = smb2_get_credits_field,
	425	.get_credits = smb2_get_credits,
2dc7e1c0	426	.get_next_mid = smb2_get_next_mid,
09a4707e PS	427	.read_data_offset = smb2_read_data_offset,
	428	.read_data_length = smb2_read_data_length,
	429	.map_error = map_smb2_to_linux_error,
093b2bda PS	430	.find_mid = smb2_find_mid,
	431	.check_message = smb2_check_message,
	432	.dump_detail = smb2_dump_detail,
d60622eb PS	433	.clear_stats = smb2_clear_stats,
d60622eb PS	434	.print_stats = smb2_print_stats,
ec2e4523 PS	435	.need_neg = smb2_need_neg,
ec2e4523 PS	436	.negotiate = smb2_negotiate,
3a3bab50 PS	437	.negotiate_wsize = smb2_negotiate_wsize,
3a3bab50 PS	438	.negotiate_rsize = smb2_negotiate_rsize,
5478f9ba PS	439	.sess_setup = SMB2_sess_setup,
5478f9ba PS	440	.logoff = SMB2_logoff,
faaf946a PS	441	.tree_connect = SMB2_tcon,
faaf946a PS	442	.tree_disconnect = SMB2_tdis,
2503a0db	443	.is_path_accessible = smb2_is_path_accessible,
9094fad1 PS	444	.can_echo = smb2_can_echo,
9094fad1 PS	445	.echo = SMB2_echo,
be4cb9e3 PS	446	.query_path_info = smb2_query_path_info,
be4cb9e3 PS	447	.get_srv_inum = smb2_get_srv_inum,
b7546bc5	448	.query_file_info = smb2_query_file_info,
25e26632	449	.build_path_to_root = smb2_build_path_to_root,
a0e73183 PS	450	.mkdir = smb2_mkdir,
a0e73183 PS	451	.mkdir_setinfo = smb2_mkdir_setinfo,
1a500f01	452	.rmdir = smb2_rmdir,
cbe6f439	453	.unlink = smb2_unlink,
f0df737e PS	454	.open = smb2_open_file,
	455	.set_fid = smb2_set_fid,
	456	.close = smb2_close_file,
7a5cfb19	457	.flush = smb2_flush_file,
09a4707e	458	.async_readv = smb2_async_readv,
33319141	459	.async_writev = smb2_async_writev,
d8e05039	460	.sync_read = smb2_sync_read,
009d3443	461	.sync_write = smb2_sync_write,
1080ef75 SF	462	};
	463
	464	struct smb_version_values smb21_values = {
	465	.version_string = SMB21_VERSION_STRING,
093b2bda PS	466	.header_size = sizeof(struct smb2_hdr),
093b2bda PS	467	.max_header_size = MAX_SMB2_HDR_SIZE,
09a4707e	468	.read_rsp_size = sizeof(struct smb2_read_rsp) - 1,
2dc7e1c0	469	.lock_cmd = SMB2_LOCK,
29e20f9c PS	470	.cap_unix = 0,
	471	.cap_nt_find = SMB2_NT_FIND,
	472	.cap_large_files = SMB2_LARGE_FILES,
1080ef75	473	};