[linux-block.git] / fs / cifs / smb2file.c

// SPDX-License-Identifier: LGPL-2.1
/*
 *
 *   Copyright (C) International Business Machines  Corp., 2002, 2011
 *   Author(s): Steve French (sfrench@us.ibm.com),
 *              Pavel Shilovsky ((pshilovsky@samba.org) 2012
 *
 */
#include <linux/fs.h>
#include <linux/filelock.h>
#include <linux/stat.h>
#include <linux/slab.h>
#include <linux/pagemap.h>
#include <asm/div64.h>
#include "cifsfs.h"
#include "cifspdu.h"
#include "cifsglob.h"
#include "cifsproto.h"
#include "cifs_debug.h"
#include "cifs_fs_sb.h"
#include "cifs_unicode.h"
#include "fscache.h"
#include "smb2proto.h"
#include "smb2status.h"

static struct smb2_symlink_err_rsp *symlink_data(const struct kvec *iov)
{
	struct smb2_err_rsp *err = iov->iov_base;
	struct smb2_symlink_err_rsp *sym = ERR_PTR(-EINVAL);
	u32 len;

	if (err->ErrorContextCount) {
		struct smb2_error_context_rsp *p, *end;

		len = (u32)err->ErrorContextCount * (offsetof(struct smb2_error_context_rsp,
							      ErrorContextData) +
						     sizeof(struct smb2_symlink_err_rsp));
		if (le32_to_cpu(err->ByteCount) < len || iov->iov_len < len + sizeof(*err) + 1)
			return ERR_PTR(-EINVAL);

		p = (struct smb2_error_context_rsp *)err->ErrorData;
		end = (struct smb2_error_context_rsp *)((u8 *)err + iov->iov_len);
		do {
			if (le32_to_cpu(p->ErrorId) == SMB2_ERROR_ID_DEFAULT) {
				sym = (struct smb2_symlink_err_rsp *)&p->ErrorContextData;
				break;
			}
			cifs_dbg(FYI, "%s: skipping unhandled error context: 0x%x\n",
				 __func__, le32_to_cpu(p->ErrorId));

			len = ALIGN(le32_to_cpu(p->ErrorDataLength), 8);
			p = (struct smb2_error_context_rsp *)((u8 *)&p->ErrorContextData + len);
		} while (p < end);
	} else if (le32_to_cpu(err->ByteCount) >= sizeof(*sym) &&
		   iov->iov_len >= SMB2_SYMLINK_STRUCT_SIZE) {
		sym = (struct smb2_symlink_err_rsp *)err->ErrorData;
	}

	if (!IS_ERR(sym) && (le32_to_cpu(sym->SymLinkErrorTag) != SYMLINK_ERROR_TAG ||
			     le32_to_cpu(sym->ReparseTag) != IO_REPARSE_TAG_SYMLINK))
		sym = ERR_PTR(-EINVAL);

	return sym;
}

int smb2_parse_symlink_response(struct cifs_sb_info *cifs_sb, const struct kvec *iov, char **path)
{
	struct smb2_symlink_err_rsp *sym;
	unsigned int sub_offs, sub_len;
	unsigned int print_offs, print_len;
	char *s;

	if (!cifs_sb || !iov || !iov->iov_base || !iov->iov_len || !path)
		return -EINVAL;

	sym = symlink_data(iov);
	if (IS_ERR(sym))
		return PTR_ERR(sym);

	sub_len = le16_to_cpu(sym->SubstituteNameLength);
	sub_offs = le16_to_cpu(sym->SubstituteNameOffset);
	print_len = le16_to_cpu(sym->PrintNameLength);
	print_offs = le16_to_cpu(sym->PrintNameOffset);

	if (iov->iov_len < SMB2_SYMLINK_STRUCT_SIZE + sub_offs + sub_len ||
	    iov->iov_len < SMB2_SYMLINK_STRUCT_SIZE + print_offs + print_len)
		return -EINVAL;

	s = cifs_strndup_from_utf16((char *)sym->PathBuffer + sub_offs, sub_len, true,
				    cifs_sb->local_nls);
	if (!s)
		return -ENOMEM;
	convert_delimiter(s, '/');
	cifs_dbg(FYI, "%s: symlink target: %s\n", __func__, s);

	*path = s;
	return 0;
}

int smb2_open_file(const unsigned int xid, struct cifs_open_parms *oparms, __u32 *oplock, void *buf)
{
	int rc;
	__le16 *smb2_path;
	__u8 smb2_oplock;
	struct cifs_open_info_data *data = buf;
	struct smb2_file_all_info file_info = {};
	struct smb2_file_all_info *smb2_data = data ? &file_info : NULL;
	struct kvec err_iov = {};
	int err_buftype = CIFS_NO_BUFFER;
	struct cifs_fid *fid = oparms->fid;
	struct network_resiliency_req nr_ioctl_req;

	smb2_path = cifs_convert_path_to_utf16(oparms->path, oparms->cifs_sb);
	if (smb2_path == NULL)
		return -ENOMEM;

	oparms->desired_access |= FILE_READ_ATTRIBUTES;
	smb2_oplock = SMB2_OPLOCK_LEVEL_BATCH;

	rc = SMB2_open(xid, oparms, smb2_path, &smb2_oplock, smb2_data, NULL, &err_iov,
		       &err_buftype);
	if (rc && data) {
		struct smb2_hdr *hdr = err_iov.iov_base;

		if (unlikely(!err_iov.iov_base || err_buftype == CIFS_NO_BUFFER))
			goto out;
		if (hdr->Status == STATUS_STOPPED_ON_SYMLINK) {
			rc = smb2_parse_symlink_response(oparms->cifs_sb, &err_iov,
							 &data->symlink_target);
			if (!rc) {
				memset(smb2_data, 0, sizeof(*smb2_data));
				oparms->create_options |= OPEN_REPARSE_POINT;
				rc = SMB2_open(xid, oparms, smb2_path, &smb2_oplock, smb2_data,
					       NULL, NULL, NULL);
				oparms->create_options &= ~OPEN_REPARSE_POINT;
			}
		}
	}

	if (rc)
		goto out;

	if (oparms->tcon->use_resilient) {
		/* default timeout is 0, servers pick default (120 seconds) */
		nr_ioctl_req.Timeout =
			cpu_to_le32(oparms->tcon->handle_timeout);
		nr_ioctl_req.Reserved = 0;
		rc = SMB2_ioctl(xid, oparms->tcon, fid->persistent_fid,
			fid->volatile_fid, FSCTL_LMR_REQUEST_RESILIENCY,
			(char *)&nr_ioctl_req, sizeof(nr_ioctl_req),
			CIFSMaxBufSize, NULL, NULL /* no return info */);
		if (rc == -EOPNOTSUPP) {
			cifs_dbg(VFS,
			     "resiliency not supported by server, disabling\n");
			oparms->tcon->use_resilient = false;
		} else if (rc)
			cifs_dbg(FYI, "error %d setting resiliency\n", rc);

		rc = 0;
	}

	if (smb2_data) {
		/* if open response does not have IndexNumber field - get it */
		if (smb2_data->IndexNumber == 0) {
			rc = SMB2_get_srv_num(xid, oparms->tcon,
				      fid->persistent_fid,
				      fid->volatile_fid,
				      &smb2_data->IndexNumber);
			if (rc) {
				/*
				 * let get_inode_info disable server inode
				 * numbers
				 */
				smb2_data->IndexNumber = 0;
				rc = 0;
			}
		}
		memcpy(&data->fi, smb2_data, sizeof(data->fi));
	}

	*oplock = smb2_oplock;
out:
	free_rsp_buf(err_buftype, err_iov.iov_base);
	kfree(smb2_path);
	return rc;
}

int
smb2_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
		  const unsigned int xid)
{
	int rc = 0, stored_rc;
	unsigned int max_num, num = 0, max_buf;
	struct smb2_lock_element *buf, *cur;
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
	struct cifsLockInfo *li, *tmp;
	__u64 length = 1 + flock->fl_end - flock->fl_start;
	struct list_head tmp_llist;

	INIT_LIST_HEAD(&tmp_llist);

	/*
	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
	 * and check it before using.
	 */
	max_buf = tcon->ses->server->maxBuf;
	if (max_buf < sizeof(struct smb2_lock_element))
		return -EINVAL;

	BUILD_BUG_ON(sizeof(struct smb2_lock_element) > PAGE_SIZE);
	max_buf = min_t(unsigned int, max_buf, PAGE_SIZE);
	max_num = max_buf / sizeof(struct smb2_lock_element);
	buf = kcalloc(max_num, sizeof(struct smb2_lock_element), GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

	cur = buf;

	cifs_down_write(&cinode->lock_sem);
	list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
		if (flock->fl_start > li->offset ||
		    (flock->fl_start + length) <
		    (li->offset + li->length))
			continue;
		if (current->tgid != li->pid)
			/*
			 * flock and OFD lock are associated with an open
			 * file description, not the process.
			 */
			if (!(flock->fl_flags & (FL_FLOCK | FL_OFDLCK)))
				continue;
		if (cinode->can_cache_brlcks) {
			/*
			 * We can cache brlock requests - simply remove a lock
			 * from the file's list.
			 */
			list_del(&li->llist);
			cifs_del_lock_waiters(li);
			kfree(li);
			continue;
		}
		cur->Length = cpu_to_le64(li->length);
		cur->Offset = cpu_to_le64(li->offset);
		cur->Flags = cpu_to_le32(SMB2_LOCKFLAG_UNLOCK);
		/*
		 * We need to save a lock here to let us add it again to the
		 * file's list if the unlock range request fails on the server.
		 */
		list_move(&li->llist, &tmp_llist);
		if (++num == max_num) {
			stored_rc = smb2_lockv(xid, tcon,
					       cfile->fid.persistent_fid,
					       cfile->fid.volatile_fid,
					       current->tgid, num, buf);
			if (stored_rc) {
				/*
				 * We failed on the unlock range request - add
				 * all locks from the tmp list to the head of
				 * the file's list.
				 */
				cifs_move_llist(&tmp_llist,
						&cfile->llist->locks);
				rc = stored_rc;
			} else
				/*
				 * The unlock range request succeed - free the
				 * tmp list.
				 */
				cifs_free_llist(&tmp_llist);
			cur = buf;
			num = 0;
		} else
			cur++;
	}
	if (num) {
		stored_rc = smb2_lockv(xid, tcon, cfile->fid.persistent_fid,
				       cfile->fid.volatile_fid, current->tgid,
				       num, buf);
		if (stored_rc) {
			cifs_move_llist(&tmp_llist, &cfile->llist->locks);
			rc = stored_rc;
		} else
			cifs_free_llist(&tmp_llist);
	}
	up_write(&cinode->lock_sem);

	kfree(buf);
	return rc;
}

static int
smb2_push_mand_fdlocks(struct cifs_fid_locks *fdlocks, const unsigned int xid,
		       struct smb2_lock_element *buf, unsigned int max_num)
{
	int rc = 0, stored_rc;
	struct cifsFileInfo *cfile = fdlocks->cfile;
	struct cifsLockInfo *li;
	unsigned int num = 0;
	struct smb2_lock_element *cur = buf;
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);

	list_for_each_entry(li, &fdlocks->locks, llist) {
		cur->Length = cpu_to_le64(li->length);
		cur->Offset = cpu_to_le64(li->offset);
		cur->Flags = cpu_to_le32(li->type |
						SMB2_LOCKFLAG_FAIL_IMMEDIATELY);
		if (++num == max_num) {
			stored_rc = smb2_lockv(xid, tcon,
					       cfile->fid.persistent_fid,
					       cfile->fid.volatile_fid,
					       current->tgid, num, buf);
			if (stored_rc)
				rc = stored_rc;
			cur = buf;
			num = 0;
		} else
			cur++;
	}
	if (num) {
		stored_rc = smb2_lockv(xid, tcon,
				       cfile->fid.persistent_fid,
				       cfile->fid.volatile_fid,
				       current->tgid, num, buf);
		if (stored_rc)
			rc = stored_rc;
	}

	return rc;
}

int
smb2_push_mandatory_locks(struct cifsFileInfo *cfile)
{
	int rc = 0, stored_rc;
	unsigned int xid;
	unsigned int max_num, max_buf;
	struct smb2_lock_element *buf;
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
	struct cifs_fid_locks *fdlocks;

	xid = get_xid();

	/*
	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
	 * and check it for zero before using.
	 */
	max_buf = tlink_tcon(cfile->tlink)->ses->server->maxBuf;
	if (max_buf < sizeof(struct smb2_lock_element)) {
		free_xid(xid);
		return -EINVAL;
	}

	BUILD_BUG_ON(sizeof(struct smb2_lock_element) > PAGE_SIZE);
	max_buf = min_t(unsigned int, max_buf, PAGE_SIZE);
	max_num = max_buf / sizeof(struct smb2_lock_element);
	buf = kcalloc(max_num, sizeof(struct smb2_lock_element), GFP_KERNEL);
	if (!buf) {
		free_xid(xid);
		return -ENOMEM;
	}

	list_for_each_entry(fdlocks, &cinode->llist, llist) {
		stored_rc = smb2_push_mand_fdlocks(fdlocks, xid, buf, max_num);
		if (stored_rc)
			rc = stored_rc;
	}

	kfree(buf);
	free_xid(xid);
	return rc;
}
Commit	Line	Data
929be906	1	// SPDX-License-Identifier: LGPL-2.1
f0df737e	2	/*
f0df737e PS	3	*
	4	* Copyright (C) International Business Machines Corp., 2002, 2011
	5	* Author(s): Steve French (sfrench@us.ibm.com),
	6	* Pavel Shilovsky ((pshilovsky@samba.org) 2012
	7	*
f0df737e PS	8	*/
f0df737e PS	9	#include <linux/fs.h>
5970e15d	10	#include <linux/filelock.h>
f0df737e PS	11	#include <linux/stat.h>
	12	#include <linux/slab.h>
	13	#include <linux/pagemap.h>
	14	#include <asm/div64.h>
	15	#include "cifsfs.h"
	16	#include "cifspdu.h"
	17	#include "cifsglob.h"
	18	#include "cifsproto.h"
	19	#include "cifs_debug.h"
	20	#include "cifs_fs_sb.h"
	21	#include "cifs_unicode.h"
	22	#include "fscache.h"
	23	#include "smb2proto.h"
76894f3e	24	#include "smb2status.h"
f0df737e	25
76894f3e PA	26	static struct smb2_symlink_err_rsp symlink_data(const struct kvec iov)
	27	{
	28	struct smb2_err_rsp *err = iov->iov_base;
	29	struct smb2_symlink_err_rsp *sym = ERR_PTR(-EINVAL);
	30	u32 len;
	31
	32	if (err->ErrorContextCount) {
	33	struct smb2_error_context_rsp p, end;
	34
	35	len = (u32)err->ErrorContextCount * (offsetof(struct smb2_error_context_rsp,
	36	ErrorContextData) +
	37	sizeof(struct smb2_symlink_err_rsp));
eb3e28c1	38	if (le32_to_cpu(err->ByteCount) < len \|\| iov->iov_len < len + sizeof(*err) + 1)
76894f3e PA	39	return ERR_PTR(-EINVAL);
	40
	41	p = (struct smb2_error_context_rsp *)err->ErrorData;
	42	end = (struct smb2_error_context_rsp )((u8 )err + iov->iov_len);
	43	do {
	44	if (le32_to_cpu(p->ErrorId) == SMB2_ERROR_ID_DEFAULT) {
	45	sym = (struct smb2_symlink_err_rsp *)&p->ErrorContextData;
	46	break;
	47	}
	48	cifs_dbg(FYI, "%s: skipping unhandled error context: 0x%x\n",
	49	__func__, le32_to_cpu(p->ErrorId));
	50
	51	len = ALIGN(le32_to_cpu(p->ErrorDataLength), 8);
	52	p = (struct smb2_error_context_rsp )((u8 )&p->ErrorContextData + len);
	53	} while (p < end);
	54	} else if (le32_to_cpu(err->ByteCount) >= sizeof(*sym) &&
	55	iov->iov_len >= SMB2_SYMLINK_STRUCT_SIZE) {
	56	sym = (struct smb2_symlink_err_rsp *)err->ErrorData;
	57	}
	58
	59	if (!IS_ERR(sym) && (le32_to_cpu(sym->SymLinkErrorTag) != SYMLINK_ERROR_TAG \|\|
	60	le32_to_cpu(sym->ReparseTag) != IO_REPARSE_TAG_SYMLINK))
	61	sym = ERR_PTR(-EINVAL);
	62
	63	return sym;
	64	}
	65
	66	int smb2_parse_symlink_response(struct cifs_sb_info cifs_sb, const struct kvec iov, char **path)
	67	{
	68	struct smb2_symlink_err_rsp *sym;
	69	unsigned int sub_offs, sub_len;
	70	unsigned int print_offs, print_len;
	71	char *s;
	72
	73	if (!cifs_sb \|\| !iov \|\| !iov->iov_base \|\| !iov->iov_len \|\| !path)
	74	return -EINVAL;
	75
	76	sym = symlink_data(iov);
	77	if (IS_ERR(sym))
	78	return PTR_ERR(sym);
	79
	80	sub_len = le16_to_cpu(sym->SubstituteNameLength);
	81	sub_offs = le16_to_cpu(sym->SubstituteNameOffset);
	82	print_len = le16_to_cpu(sym->PrintNameLength);
	83	print_offs = le16_to_cpu(sym->PrintNameOffset);
	84
	85	if (iov->iov_len < SMB2_SYMLINK_STRUCT_SIZE + sub_offs + sub_len \|\|
	86	iov->iov_len < SMB2_SYMLINK_STRUCT_SIZE + print_offs + print_len)
	87	return -EINVAL;
	88
	89	s = cifs_strndup_from_utf16((char *)sym->PathBuffer + sub_offs, sub_len, true,
	90	cifs_sb->local_nls);
	91	if (!s)
	92	return -ENOMEM;
	93	convert_delimiter(s, '/');
	94	cifs_dbg(FYI, "%s: symlink target: %s\n", __func__, s);
	95
	96	*path = s;
	97	return 0;
	98	}
	99
	100	int smb2_open_file(const unsigned int xid, struct cifs_open_parms oparms, __u32 oplock, void *buf)
f0df737e PS	101	{
	102	int rc;
	103	__le16 *smb2_path;
729c0c9d	104	__u8 smb2_oplock;
76894f3e PA	105	struct cifs_open_info_data *data = buf;
	106	struct smb2_file_all_info file_info = {};
	107	struct smb2_file_all_info *smb2_data = data ? &file_info : NULL;
	108	struct kvec err_iov = {};
	109	int err_buftype = CIFS_NO_BUFFER;
226730b4	110	struct cifs_fid *fid = oparms->fid;
592fafe6	111	struct network_resiliency_req nr_ioctl_req;
f0df737e	112
226730b4	113	smb2_path = cifs_convert_path_to_utf16(oparms->path, oparms->cifs_sb);
76894f3e PA	114	if (smb2_path == NULL)
76894f3e PA	115	return -ENOMEM;
f0df737e	116
226730b4	117	oparms->desired_access \|= FILE_READ_ATTRIBUTES;
729c0c9d	118	smb2_oplock = SMB2_OPLOCK_LEVEL_BATCH;
b8c32dbb	119
76894f3e PA	120	rc = SMB2_open(xid, oparms, smb2_path, &smb2_oplock, smb2_data, NULL, &err_iov,
	121	&err_buftype);
	122	if (rc && data) {
	123	struct smb2_hdr *hdr = err_iov.iov_base;
	124
	125	if (unlikely(!err_iov.iov_base \|\| err_buftype == CIFS_NO_BUFFER))
f60ffa66 PA	126	goto out;
f60ffa66 PA	127	if (hdr->Status == STATUS_STOPPED_ON_SYMLINK) {
76894f3e PA	128	rc = smb2_parse_symlink_response(oparms->cifs_sb, &err_iov,
	129	&data->symlink_target);
	130	if (!rc) {
	131	memset(smb2_data, 0, sizeof(*smb2_data));
	132	oparms->create_options \|= OPEN_REPARSE_POINT;
	133	rc = SMB2_open(xid, oparms, smb2_path, &smb2_oplock, smb2_data,
	134	NULL, NULL, NULL);
	135	oparms->create_options &= ~OPEN_REPARSE_POINT;
	136	}
	137	}
	138	}
	139
f0df737e PS	140	if (rc)
	141	goto out;
	142
7935799e	143	if (oparms->tcon->use_resilient) {
ca567eb2 SF	144	/* default timeout is 0, servers pick default (120 seconds) */
	145	nr_ioctl_req.Timeout =
	146	cpu_to_le32(oparms->tcon->handle_timeout);
592fafe6 SF	147	nr_ioctl_req.Reserved = 0;
592fafe6 SF	148	rc = SMB2_ioctl(xid, oparms->tcon, fid->persistent_fid,
51146625	149	fid->volatile_fid, FSCTL_LMR_REQUEST_RESILIENCY,
592fafe6	150	(char *)&nr_ioctl_req, sizeof(nr_ioctl_req),
153322f7	151	CIFSMaxBufSize, NULL, NULL /* no return info */);
592fafe6 SF	152	if (rc == -EOPNOTSUPP) {
	153	cifs_dbg(VFS,
	154	"resiliency not supported by server, disabling\n");
	155	oparms->tcon->use_resilient = false;
	156	} else if (rc)
	157	cifs_dbg(FYI, "error %d setting resiliency\n", rc);
	158
	159	rc = 0;
	160	}
	161
76894f3e	162	if (smb2_data) {
89a5bfa3 SF	163	/* if open response does not have IndexNumber field - get it */
	164	if (smb2_data->IndexNumber == 0) {
	165	rc = SMB2_get_srv_num(xid, oparms->tcon,
	166	fid->persistent_fid,
f0df737e PS	167	fid->volatile_fid,
f0df737e PS	168	&smb2_data->IndexNumber);
89a5bfa3 SF	169	if (rc) {
	170	/*
	171	* let get_inode_info disable server inode
	172	* numbers
	173	*/
	174	smb2_data->IndexNumber = 0;
	175	rc = 0;
	176	}
f0df737e	177	}
76894f3e	178	memcpy(&data->fi, smb2_data, sizeof(data->fi));
f0df737e PS	179	}
f0df737e PS	180
729c0c9d	181	*oplock = smb2_oplock;
f0df737e	182	out:
76894f3e	183	free_rsp_buf(err_buftype, err_iov.iov_base);
f0df737e PS	184	kfree(smb2_path);
	185	return rc;
	186	}
f7ba7fe6 PS	187
	188	int
	189	smb2_unlock_range(struct cifsFileInfo cfile, struct file_lock flock,
	190	const unsigned int xid)
	191	{
	192	int rc = 0, stored_rc;
	193	unsigned int max_num, num = 0, max_buf;
	194	struct smb2_lock_element buf, cur;
	195	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2b0143b5	196	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
f7ba7fe6 PS	197	struct cifsLockInfo li, tmp;
	198	__u64 length = 1 + flock->fl_end - flock->fl_start;
	199	struct list_head tmp_llist;
	200
	201	INIT_LIST_HEAD(&tmp_llist);
	202
	203	/*
	204	* Accessing maxBuf is racy with cifs_reconnect - need to store value
b9a74cde	205	* and check it before using.
f7ba7fe6 PS	206	*/
f7ba7fe6 PS	207	max_buf = tcon->ses->server->maxBuf;
b9a74cde	208	if (max_buf < sizeof(struct smb2_lock_element))
f7ba7fe6 PS	209	return -EINVAL;
f7ba7fe6 PS	210
92a8109e RL	211	BUILD_BUG_ON(sizeof(struct smb2_lock_element) > PAGE_SIZE);
92a8109e RL	212	max_buf = min_t(unsigned int, max_buf, PAGE_SIZE);
f7ba7fe6	213	max_num = max_buf / sizeof(struct smb2_lock_element);
662e9b2b	214	buf = kcalloc(max_num, sizeof(struct smb2_lock_element), GFP_KERNEL);
f7ba7fe6 PS	215	if (!buf)
	216	return -ENOMEM;
	217
	218	cur = buf;
	219
d46b0da7	220	cifs_down_write(&cinode->lock_sem);
f7ba7fe6 PS	221	list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
	222	if (flock->fl_start > li->offset \|\|
	223	(flock->fl_start + length) <
	224	(li->offset + li->length))
	225	continue;
	226	if (current->tgid != li->pid)
0667059d MZ	227	/*
	228	* flock and OFD lock are associated with an open
	229	* file description, not the process.
	230	*/
	231	if (!(flock->fl_flags & (FL_FLOCK \| FL_OFDLCK)))
	232	continue;
f7ba7fe6 PS	233	if (cinode->can_cache_brlcks) {
	234	/*
	235	* We can cache brlock requests - simply remove a lock
	236	* from the file's list.
	237	*/
	238	list_del(&li->llist);
	239	cifs_del_lock_waiters(li);
	240	kfree(li);
	241	continue;
	242	}
	243	cur->Length = cpu_to_le64(li->length);
	244	cur->Offset = cpu_to_le64(li->offset);
	245	cur->Flags = cpu_to_le32(SMB2_LOCKFLAG_UNLOCK);
	246	/*
	247	* We need to save a lock here to let us add it again to the
	248	* file's list if the unlock range request fails on the server.
	249	*/
	250	list_move(&li->llist, &tmp_llist);
	251	if (++num == max_num) {
	252	stored_rc = smb2_lockv(xid, tcon,
	253	cfile->fid.persistent_fid,
	254	cfile->fid.volatile_fid,
	255	current->tgid, num, buf);
	256	if (stored_rc) {
	257	/*
	258	* We failed on the unlock range request - add
	259	* all locks from the tmp list to the head of
	260	* the file's list.
	261	*/
	262	cifs_move_llist(&tmp_llist,
	263	&cfile->llist->locks);
	264	rc = stored_rc;
	265	} else
	266	/*
	267	* The unlock range request succeed - free the
	268	* tmp list.
	269	*/
	270	cifs_free_llist(&tmp_llist);
	271	cur = buf;
	272	num = 0;
	273	} else
	274	cur++;
	275	}
	276	if (num) {
	277	stored_rc = smb2_lockv(xid, tcon, cfile->fid.persistent_fid,
	278	cfile->fid.volatile_fid, current->tgid,
	279	num, buf);
	280	if (stored_rc) {
	281	cifs_move_llist(&tmp_llist, &cfile->llist->locks);
	282	rc = stored_rc;
	283	} else
	284	cifs_free_llist(&tmp_llist);
	285	}
1b4b55a1	286	up_write(&cinode->lock_sem);
f7ba7fe6 PS	287
	288	kfree(buf);
	289	return rc;
	290	}
b140799a PS	291
	292	static int
	293	smb2_push_mand_fdlocks(struct cifs_fid_locks *fdlocks, const unsigned int xid,
	294	struct smb2_lock_element *buf, unsigned int max_num)
	295	{
	296	int rc = 0, stored_rc;
	297	struct cifsFileInfo *cfile = fdlocks->cfile;
	298	struct cifsLockInfo *li;
	299	unsigned int num = 0;
	300	struct smb2_lock_element *cur = buf;
	301	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
	302
	303	list_for_each_entry(li, &fdlocks->locks, llist) {
	304	cur->Length = cpu_to_le64(li->length);
	305	cur->Offset = cpu_to_le64(li->offset);
	306	cur->Flags = cpu_to_le32(li->type \|
	307	SMB2_LOCKFLAG_FAIL_IMMEDIATELY);
	308	if (++num == max_num) {
	309	stored_rc = smb2_lockv(xid, tcon,
	310	cfile->fid.persistent_fid,
	311	cfile->fid.volatile_fid,
	312	current->tgid, num, buf);
	313	if (stored_rc)
	314	rc = stored_rc;
	315	cur = buf;
	316	num = 0;
	317	} else
	318	cur++;
	319	}
	320	if (num) {
	321	stored_rc = smb2_lockv(xid, tcon,
	322	cfile->fid.persistent_fid,
	323	cfile->fid.volatile_fid,
	324	current->tgid, num, buf);
	325	if (stored_rc)
	326	rc = stored_rc;
	327	}
	328
	329	return rc;
	330	}
	331
	332	int
	333	smb2_push_mandatory_locks(struct cifsFileInfo *cfile)
	334	{
	335	int rc = 0, stored_rc;
	336	unsigned int xid;
	337	unsigned int max_num, max_buf;
	338	struct smb2_lock_element *buf;
2b0143b5	339	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
b140799a PS	340	struct cifs_fid_locks *fdlocks;
	341
	342	xid = get_xid();
b140799a PS	343
	344	/*
	345	* Accessing maxBuf is racy with cifs_reconnect - need to store value
	346	* and check it for zero before using.
	347	*/
	348	max_buf = tlink_tcon(cfile->tlink)->ses->server->maxBuf;
e3d240e9	349	if (max_buf < sizeof(struct smb2_lock_element)) {
b140799a PS	350	free_xid(xid);
	351	return -EINVAL;
	352	}
	353
92a8109e RL	354	BUILD_BUG_ON(sizeof(struct smb2_lock_element) > PAGE_SIZE);
92a8109e RL	355	max_buf = min_t(unsigned int, max_buf, PAGE_SIZE);
b140799a	356	max_num = max_buf / sizeof(struct smb2_lock_element);
662e9b2b	357	buf = kcalloc(max_num, sizeof(struct smb2_lock_element), GFP_KERNEL);
b140799a	358	if (!buf) {
b140799a PS	359	free_xid(xid);
	360	return -ENOMEM;
	361	}
	362
	363	list_for_each_entry(fdlocks, &cinode->llist, llist) {
	364	stored_rc = smb2_push_mand_fdlocks(fdlocks, xid, buf, max_num);
	365	if (stored_rc)
	366	rc = stored_rc;
	367	}
	368
b140799a	369	kfree(buf);
b140799a PS	370	free_xid(xid);
	371	return rc;
	372	}