Linux Audio

Check our new training course

Loading...
v6.2
   1// SPDX-License-Identifier: LGPL-2.1
   2/*
 
   3 *
   4 *   vfs operations that deal with files
   5 *
   6 *   Copyright (C) International Business Machines  Corp., 2002,2010
   7 *   Author(s): Steve French (sfrench@us.ibm.com)
   8 *              Jeremy Allison (jra@samba.org)
   9 *
 
 
 
 
 
 
 
 
 
 
 
 
 
  10 */
  11#include <linux/fs.h>
  12#include <linux/backing-dev.h>
  13#include <linux/stat.h>
  14#include <linux/fcntl.h>
  15#include <linux/pagemap.h>
  16#include <linux/pagevec.h>
  17#include <linux/writeback.h>
  18#include <linux/task_io_accounting_ops.h>
  19#include <linux/delay.h>
  20#include <linux/mount.h>
  21#include <linux/slab.h>
  22#include <linux/swap.h>
  23#include <linux/mm.h>
  24#include <asm/div64.h>
  25#include "cifsfs.h"
  26#include "cifspdu.h"
  27#include "cifsglob.h"
  28#include "cifsproto.h"
  29#include "smb2proto.h"
  30#include "cifs_unicode.h"
  31#include "cifs_debug.h"
  32#include "cifs_fs_sb.h"
  33#include "fscache.h"
  34#include "smbdirect.h"
  35#include "fs_context.h"
  36#include "cifs_ioctl.h"
  37#include "cached_dir.h"
  38
  39/*
  40 * Mark as invalid, all open files on tree connections since they
  41 * were closed when session to server was lost.
  42 */
  43void
  44cifs_mark_open_files_invalid(struct cifs_tcon *tcon)
  45{
  46	struct cifsFileInfo *open_file = NULL;
  47	struct list_head *tmp;
  48	struct list_head *tmp1;
  49
  50	/* only send once per connect */
  51	spin_lock(&tcon->ses->ses_lock);
  52	if ((tcon->ses->ses_status != SES_GOOD) || (tcon->status != TID_NEED_RECON)) {
  53		spin_unlock(&tcon->ses->ses_lock);
  54		return;
  55	}
  56	tcon->status = TID_IN_FILES_INVALIDATE;
  57	spin_unlock(&tcon->ses->ses_lock);
  58
  59	/* list all files open on tree connection and mark them invalid */
  60	spin_lock(&tcon->open_file_lock);
  61	list_for_each_safe(tmp, tmp1, &tcon->openFileList) {
  62		open_file = list_entry(tmp, struct cifsFileInfo, tlist);
  63		open_file->invalidHandle = true;
  64		open_file->oplock_break_cancelled = true;
  65	}
  66	spin_unlock(&tcon->open_file_lock);
  67
  68	invalidate_all_cached_dirs(tcon);
  69	spin_lock(&tcon->tc_lock);
  70	if (tcon->status == TID_IN_FILES_INVALIDATE)
  71		tcon->status = TID_NEED_TCON;
  72	spin_unlock(&tcon->tc_lock);
  73
  74	/*
  75	 * BB Add call to invalidate_inodes(sb) for all superblocks mounted
  76	 * to this tcon.
  77	 */
  78}
  79
  80static inline int cifs_convert_flags(unsigned int flags)
  81{
  82	if ((flags & O_ACCMODE) == O_RDONLY)
  83		return GENERIC_READ;
  84	else if ((flags & O_ACCMODE) == O_WRONLY)
  85		return GENERIC_WRITE;
  86	else if ((flags & O_ACCMODE) == O_RDWR) {
  87		/* GENERIC_ALL is too much permission to request
  88		   can cause unnecessary access denied on create */
  89		/* return GENERIC_ALL; */
  90		return (GENERIC_READ | GENERIC_WRITE);
  91	}
  92
  93	return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
  94		FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
  95		FILE_READ_DATA);
  96}
  97
  98#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
  99static u32 cifs_posix_convert_flags(unsigned int flags)
 100{
 101	u32 posix_flags = 0;
 102
 103	if ((flags & O_ACCMODE) == O_RDONLY)
 104		posix_flags = SMB_O_RDONLY;
 105	else if ((flags & O_ACCMODE) == O_WRONLY)
 106		posix_flags = SMB_O_WRONLY;
 107	else if ((flags & O_ACCMODE) == O_RDWR)
 108		posix_flags = SMB_O_RDWR;
 109
 110	if (flags & O_CREAT) {
 111		posix_flags |= SMB_O_CREAT;
 112		if (flags & O_EXCL)
 113			posix_flags |= SMB_O_EXCL;
 114	} else if (flags & O_EXCL)
 115		cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
 116			 current->comm, current->tgid);
 117
 118	if (flags & O_TRUNC)
 119		posix_flags |= SMB_O_TRUNC;
 120	/* be safe and imply O_SYNC for O_DSYNC */
 121	if (flags & O_DSYNC)
 122		posix_flags |= SMB_O_SYNC;
 123	if (flags & O_DIRECTORY)
 124		posix_flags |= SMB_O_DIRECTORY;
 125	if (flags & O_NOFOLLOW)
 126		posix_flags |= SMB_O_NOFOLLOW;
 127	if (flags & O_DIRECT)
 128		posix_flags |= SMB_O_DIRECT;
 129
 130	return posix_flags;
 131}
 132#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 133
 134static inline int cifs_get_disposition(unsigned int flags)
 135{
 136	if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 137		return FILE_CREATE;
 138	else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
 139		return FILE_OVERWRITE_IF;
 140	else if ((flags & O_CREAT) == O_CREAT)
 141		return FILE_OPEN_IF;
 142	else if ((flags & O_TRUNC) == O_TRUNC)
 143		return FILE_OVERWRITE;
 144	else
 145		return FILE_OPEN;
 146}
 147
 148#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 149int cifs_posix_open(const char *full_path, struct inode **pinode,
 150			struct super_block *sb, int mode, unsigned int f_flags,
 151			__u32 *poplock, __u16 *pnetfid, unsigned int xid)
 152{
 153	int rc;
 154	FILE_UNIX_BASIC_INFO *presp_data;
 155	__u32 posix_flags = 0;
 156	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 157	struct cifs_fattr fattr;
 158	struct tcon_link *tlink;
 159	struct cifs_tcon *tcon;
 160
 161	cifs_dbg(FYI, "posix open %s\n", full_path);
 162
 163	presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
 164	if (presp_data == NULL)
 165		return -ENOMEM;
 166
 167	tlink = cifs_sb_tlink(cifs_sb);
 168	if (IS_ERR(tlink)) {
 169		rc = PTR_ERR(tlink);
 170		goto posix_open_ret;
 171	}
 172
 173	tcon = tlink_tcon(tlink);
 174	mode &= ~current_umask();
 175
 176	posix_flags = cifs_posix_convert_flags(f_flags);
 177	rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
 178			     poplock, full_path, cifs_sb->local_nls,
 179			     cifs_remap(cifs_sb));
 180	cifs_put_tlink(tlink);
 181
 182	if (rc)
 183		goto posix_open_ret;
 184
 185	if (presp_data->Type == cpu_to_le32(-1))
 186		goto posix_open_ret; /* open ok, caller does qpathinfo */
 187
 188	if (!pinode)
 189		goto posix_open_ret; /* caller does not need info */
 190
 191	cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
 192
 193	/* get new inode and set it up */
 194	if (*pinode == NULL) {
 195		cifs_fill_uniqueid(sb, &fattr);
 196		*pinode = cifs_iget(sb, &fattr);
 197		if (!*pinode) {
 198			rc = -ENOMEM;
 199			goto posix_open_ret;
 200		}
 201	} else {
 202		cifs_revalidate_mapping(*pinode);
 203		rc = cifs_fattr_to_inode(*pinode, &fattr);
 204	}
 205
 206posix_open_ret:
 207	kfree(presp_data);
 208	return rc;
 209}
 210#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 211
 212static int cifs_nt_open(const char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
 213			struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
 214			struct cifs_fid *fid, unsigned int xid, struct cifs_open_info_data *buf)
 
 215{
 216	int rc;
 217	int desired_access;
 218	int disposition;
 219	int create_options = CREATE_NOT_DIR;
 
 220	struct TCP_Server_Info *server = tcon->ses->server;
 221	struct cifs_open_parms oparms;
 222
 223	if (!server->ops->open)
 224		return -ENOSYS;
 225
 226	desired_access = cifs_convert_flags(f_flags);
 227
 228/*********************************************************************
 229 *  open flag mapping table:
 230 *
 231 *	POSIX Flag            CIFS Disposition
 232 *	----------            ----------------
 233 *	O_CREAT               FILE_OPEN_IF
 234 *	O_CREAT | O_EXCL      FILE_CREATE
 235 *	O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
 236 *	O_TRUNC               FILE_OVERWRITE
 237 *	none of the above     FILE_OPEN
 238 *
 239 *	Note that there is not a direct match between disposition
 240 *	FILE_SUPERSEDE (ie create whether or not file exists although
 241 *	O_CREAT | O_TRUNC is similar but truncates the existing
 242 *	file rather than creating a new file as FILE_SUPERSEDE does
 243 *	(which uses the attributes / metadata passed in on open call)
 244 *?
 245 *?  O_SYNC is a reasonable match to CIFS writethrough flag
 246 *?  and the read write flags match reasonably.  O_LARGEFILE
 247 *?  is irrelevant because largefile support is always used
 248 *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
 249 *	 O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
 250 *********************************************************************/
 251
 252	disposition = cifs_get_disposition(f_flags);
 253
 254	/* BB pass O_SYNC flag through on file attributes .. BB */
 255
 
 
 
 
 
 
 
 256	/* O_SYNC also has bit for O_DSYNC so following check picks up either */
 257	if (f_flags & O_SYNC)
 258		create_options |= CREATE_WRITE_THROUGH;
 259
 260	if (f_flags & O_DIRECT)
 261		create_options |= CREATE_NO_BUFFER;
 262
 263	oparms.tcon = tcon;
 264	oparms.cifs_sb = cifs_sb;
 265	oparms.desired_access = desired_access;
 266	oparms.create_options = cifs_create_options(cifs_sb, create_options);
 267	oparms.disposition = disposition;
 268	oparms.path = full_path;
 269	oparms.fid = fid;
 270	oparms.reconnect = false;
 271
 272	rc = server->ops->open(xid, &oparms, oplock, buf);
 
 273	if (rc)
 274		return rc;
 275
 276	/* TODO: Add support for calling posix query info but with passing in fid */
 277	if (tcon->unix_ext)
 278		rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
 279					      xid);
 280	else
 281		rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
 282					 xid, fid);
 283
 284	if (rc) {
 285		server->ops->close(xid, tcon, fid);
 286		if (rc == -ESTALE)
 287			rc = -EOPENSTALE;
 288	}
 289
 
 
 290	return rc;
 291}
 292
 293static bool
 294cifs_has_mand_locks(struct cifsInodeInfo *cinode)
 295{
 296	struct cifs_fid_locks *cur;
 297	bool has_locks = false;
 298
 299	down_read(&cinode->lock_sem);
 300	list_for_each_entry(cur, &cinode->llist, llist) {
 301		if (!list_empty(&cur->locks)) {
 302			has_locks = true;
 303			break;
 304		}
 305	}
 306	up_read(&cinode->lock_sem);
 307	return has_locks;
 308}
 309
 310void
 311cifs_down_write(struct rw_semaphore *sem)
 312{
 313	while (!down_write_trylock(sem))
 314		msleep(10);
 315}
 316
 317static void cifsFileInfo_put_work(struct work_struct *work);
 318
 319struct cifsFileInfo *cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
 320				       struct tcon_link *tlink, __u32 oplock,
 321				       const char *symlink_target)
 322{
 323	struct dentry *dentry = file_dentry(file);
 324	struct inode *inode = d_inode(dentry);
 325	struct cifsInodeInfo *cinode = CIFS_I(inode);
 326	struct cifsFileInfo *cfile;
 327	struct cifs_fid_locks *fdlocks;
 328	struct cifs_tcon *tcon = tlink_tcon(tlink);
 329	struct TCP_Server_Info *server = tcon->ses->server;
 330
 331	cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
 332	if (cfile == NULL)
 333		return cfile;
 334
 335	fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
 336	if (!fdlocks) {
 337		kfree(cfile);
 338		return NULL;
 339	}
 340
 341	if (symlink_target) {
 342		cfile->symlink_target = kstrdup(symlink_target, GFP_KERNEL);
 343		if (!cfile->symlink_target) {
 344			kfree(fdlocks);
 345			kfree(cfile);
 346			return NULL;
 347		}
 348	}
 349
 350	INIT_LIST_HEAD(&fdlocks->locks);
 351	fdlocks->cfile = cfile;
 352	cfile->llist = fdlocks;
 
 
 
 353
 354	cfile->count = 1;
 355	cfile->pid = current->tgid;
 356	cfile->uid = current_fsuid();
 357	cfile->dentry = dget(dentry);
 358	cfile->f_flags = file->f_flags;
 359	cfile->invalidHandle = false;
 360	cfile->deferred_close_scheduled = false;
 361	cfile->tlink = cifs_get_tlink(tlink);
 362	INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
 363	INIT_WORK(&cfile->put, cifsFileInfo_put_work);
 364	INIT_DELAYED_WORK(&cfile->deferred, smb2_deferred_work_close);
 365	mutex_init(&cfile->fh_mutex);
 366	spin_lock_init(&cfile->file_info_lock);
 367
 368	cifs_sb_active(inode->i_sb);
 369
 370	/*
 371	 * If the server returned a read oplock and we have mandatory brlocks,
 372	 * set oplock level to None.
 373	 */
 374	if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
 375		cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
 376		oplock = 0;
 377	}
 378
 379	cifs_down_write(&cinode->lock_sem);
 380	list_add(&fdlocks->llist, &cinode->llist);
 381	up_write(&cinode->lock_sem);
 382
 383	spin_lock(&tcon->open_file_lock);
 384	if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
 385		oplock = fid->pending_open->oplock;
 386	list_del(&fid->pending_open->olist);
 387
 388	fid->purge_cache = false;
 389	server->ops->set_fid(cfile, fid, oplock);
 390
 391	list_add(&cfile->tlist, &tcon->openFileList);
 392	atomic_inc(&tcon->num_local_opens);
 393
 394	/* if readable file instance put first in list*/
 395	spin_lock(&cinode->open_file_lock);
 396	if (file->f_mode & FMODE_READ)
 397		list_add(&cfile->flist, &cinode->openFileList);
 398	else
 399		list_add_tail(&cfile->flist, &cinode->openFileList);
 400	spin_unlock(&cinode->open_file_lock);
 401	spin_unlock(&tcon->open_file_lock);
 402
 403	if (fid->purge_cache)
 404		cifs_zap_mapping(inode);
 405
 406	file->private_data = cfile;
 407	return cfile;
 408}
 409
 410struct cifsFileInfo *
 411cifsFileInfo_get(struct cifsFileInfo *cifs_file)
 412{
 413	spin_lock(&cifs_file->file_info_lock);
 414	cifsFileInfo_get_locked(cifs_file);
 415	spin_unlock(&cifs_file->file_info_lock);
 416	return cifs_file;
 417}
 418
 419static void cifsFileInfo_put_final(struct cifsFileInfo *cifs_file)
 420{
 421	struct inode *inode = d_inode(cifs_file->dentry);
 422	struct cifsInodeInfo *cifsi = CIFS_I(inode);
 423	struct cifsLockInfo *li, *tmp;
 424	struct super_block *sb = inode->i_sb;
 425
 426	/*
 427	 * Delete any outstanding lock records. We'll lose them when the file
 428	 * is closed anyway.
 429	 */
 430	cifs_down_write(&cifsi->lock_sem);
 431	list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
 432		list_del(&li->llist);
 433		cifs_del_lock_waiters(li);
 434		kfree(li);
 435	}
 436	list_del(&cifs_file->llist->llist);
 437	kfree(cifs_file->llist);
 438	up_write(&cifsi->lock_sem);
 439
 440	cifs_put_tlink(cifs_file->tlink);
 441	dput(cifs_file->dentry);
 442	cifs_sb_deactive(sb);
 443	kfree(cifs_file->symlink_target);
 444	kfree(cifs_file);
 445}
 446
 447static void cifsFileInfo_put_work(struct work_struct *work)
 448{
 449	struct cifsFileInfo *cifs_file = container_of(work,
 450			struct cifsFileInfo, put);
 451
 452	cifsFileInfo_put_final(cifs_file);
 453}
 454
 455/**
 456 * cifsFileInfo_put - release a reference of file priv data
 457 *
 458 * Always potentially wait for oplock handler. See _cifsFileInfo_put().
 459 *
 460 * @cifs_file:	cifs/smb3 specific info (eg refcounts) for an open file
 461 */
 462void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 463{
 464	_cifsFileInfo_put(cifs_file, true, true);
 465}
 466
 467/**
 468 * _cifsFileInfo_put - release a reference of file priv data
 469 *
 470 * This may involve closing the filehandle @cifs_file out on the
 471 * server. Must be called without holding tcon->open_file_lock,
 472 * cinode->open_file_lock and cifs_file->file_info_lock.
 473 *
 474 * If @wait_for_oplock_handler is true and we are releasing the last
 475 * reference, wait for any running oplock break handler of the file
 476 * and cancel any pending one.
 477 *
 478 * @cifs_file:	cifs/smb3 specific info (eg refcounts) for an open file
 479 * @wait_oplock_handler: must be false if called from oplock_break_handler
 480 * @offload:	not offloaded on close and oplock breaks
 481 *
 482 */
 483void _cifsFileInfo_put(struct cifsFileInfo *cifs_file,
 484		       bool wait_oplock_handler, bool offload)
 485{
 486	struct inode *inode = d_inode(cifs_file->dentry);
 487	struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
 488	struct TCP_Server_Info *server = tcon->ses->server;
 489	struct cifsInodeInfo *cifsi = CIFS_I(inode);
 490	struct super_block *sb = inode->i_sb;
 491	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 492	struct cifs_fid fid = {};
 
 493	struct cifs_pending_open open;
 494	bool oplock_break_cancelled;
 495
 496	spin_lock(&tcon->open_file_lock);
 497	spin_lock(&cifsi->open_file_lock);
 498	spin_lock(&cifs_file->file_info_lock);
 499	if (--cifs_file->count > 0) {
 500		spin_unlock(&cifs_file->file_info_lock);
 501		spin_unlock(&cifsi->open_file_lock);
 502		spin_unlock(&tcon->open_file_lock);
 503		return;
 504	}
 505	spin_unlock(&cifs_file->file_info_lock);
 506
 507	if (server->ops->get_lease_key)
 508		server->ops->get_lease_key(inode, &fid);
 509
 510	/* store open in pending opens to make sure we don't miss lease break */
 511	cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
 512
 513	/* remove it from the lists */
 514	list_del(&cifs_file->flist);
 515	list_del(&cifs_file->tlist);
 516	atomic_dec(&tcon->num_local_opens);
 517
 518	if (list_empty(&cifsi->openFileList)) {
 519		cifs_dbg(FYI, "closing last open instance for inode %p\n",
 520			 d_inode(cifs_file->dentry));
 521		/*
 522		 * In strict cache mode we need invalidate mapping on the last
 523		 * close  because it may cause a error when we open this file
 524		 * again and get at least level II oplock.
 525		 */
 526		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 527			set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
 528		cifs_set_oplock_level(cifsi, 0);
 529	}
 530
 531	spin_unlock(&cifsi->open_file_lock);
 532	spin_unlock(&tcon->open_file_lock);
 533
 534	oplock_break_cancelled = wait_oplock_handler ?
 535		cancel_work_sync(&cifs_file->oplock_break) : false;
 536
 537	if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
 538		struct TCP_Server_Info *server = tcon->ses->server;
 539		unsigned int xid;
 540
 541		xid = get_xid();
 542		if (server->ops->close_getattr)
 543			server->ops->close_getattr(xid, tcon, cifs_file);
 544		else if (server->ops->close)
 545			server->ops->close(xid, tcon, &cifs_file->fid);
 546		_free_xid(xid);
 547	}
 548
 549	if (oplock_break_cancelled)
 550		cifs_done_oplock_break(cifsi);
 551
 552	cifs_del_pending_open(&open);
 553
 554	if (offload)
 555		queue_work(fileinfo_put_wq, &cifs_file->put);
 556	else
 557		cifsFileInfo_put_final(cifs_file);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 558}
 559
 560int cifs_open(struct inode *inode, struct file *file)
 561
 562{
 563	int rc = -EACCES;
 564	unsigned int xid;
 565	__u32 oplock;
 566	struct cifs_sb_info *cifs_sb;
 567	struct TCP_Server_Info *server;
 568	struct cifs_tcon *tcon;
 569	struct tcon_link *tlink;
 570	struct cifsFileInfo *cfile = NULL;
 571	void *page;
 572	const char *full_path;
 573	bool posix_open_ok = false;
 574	struct cifs_fid fid = {};
 575	struct cifs_pending_open open;
 576	struct cifs_open_info_data data = {};
 577
 578	xid = get_xid();
 579
 580	cifs_sb = CIFS_SB(inode->i_sb);
 581	if (unlikely(cifs_forced_shutdown(cifs_sb))) {
 582		free_xid(xid);
 583		return -EIO;
 584	}
 585
 586	tlink = cifs_sb_tlink(cifs_sb);
 587	if (IS_ERR(tlink)) {
 588		free_xid(xid);
 589		return PTR_ERR(tlink);
 590	}
 591	tcon = tlink_tcon(tlink);
 592	server = tcon->ses->server;
 593
 594	page = alloc_dentry_path();
 595	full_path = build_path_from_dentry(file_dentry(file), page);
 596	if (IS_ERR(full_path)) {
 597		rc = PTR_ERR(full_path);
 598		goto out;
 599	}
 600
 601	cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
 602		 inode, file->f_flags, full_path);
 603
 604	if (file->f_flags & O_DIRECT &&
 605	    cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
 606		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 607			file->f_op = &cifs_file_direct_nobrl_ops;
 608		else
 609			file->f_op = &cifs_file_direct_ops;
 610	}
 611
 612	/* Get the cached handle as SMB2 close is deferred */
 613	rc = cifs_get_readable_path(tcon, full_path, &cfile);
 614	if (rc == 0) {
 615		if (file->f_flags == cfile->f_flags) {
 616			file->private_data = cfile;
 617			spin_lock(&CIFS_I(inode)->deferred_lock);
 618			cifs_del_deferred_close(cfile);
 619			spin_unlock(&CIFS_I(inode)->deferred_lock);
 620			goto use_cache;
 621		} else {
 622			_cifsFileInfo_put(cfile, true, false);
 623		}
 624	}
 625
 626	if (server->oplocks)
 627		oplock = REQ_OPLOCK;
 628	else
 629		oplock = 0;
 630
 631#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 632	if (!tcon->broken_posix_open && tcon->unix_ext &&
 633	    cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 634				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 635		/* can not refresh inode info since size could be stale */
 636		rc = cifs_posix_open(full_path, &inode, inode->i_sb,
 637				cifs_sb->ctx->file_mode /* ignored */,
 638				file->f_flags, &oplock, &fid.netfid, xid);
 639		if (rc == 0) {
 640			cifs_dbg(FYI, "posix open succeeded\n");
 641			posix_open_ok = true;
 642		} else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
 643			if (tcon->ses->serverNOS)
 644				cifs_dbg(VFS, "server %s of type %s returned unexpected error on SMB posix open, disabling posix open support. Check if server update available.\n",
 645					 tcon->ses->ip_addr,
 646					 tcon->ses->serverNOS);
 647			tcon->broken_posix_open = true;
 648		} else if ((rc != -EIO) && (rc != -EREMOTE) &&
 649			 (rc != -EOPNOTSUPP)) /* path not found or net err */
 650			goto out;
 651		/*
 652		 * Else fallthrough to retry open the old way on network i/o
 653		 * or DFS errors.
 654		 */
 655	}
 656#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 657
 658	if (server->ops->get_lease_key)
 659		server->ops->get_lease_key(inode, &fid);
 660
 661	cifs_add_pending_open(&fid, tlink, &open);
 662
 663	if (!posix_open_ok) {
 664		if (server->ops->get_lease_key)
 665			server->ops->get_lease_key(inode, &fid);
 666
 667		rc = cifs_nt_open(full_path, inode, cifs_sb, tcon, file->f_flags, &oplock, &fid,
 668				  xid, &data);
 669		if (rc) {
 670			cifs_del_pending_open(&open);
 671			goto out;
 672		}
 673	}
 674
 675	cfile = cifs_new_fileinfo(&fid, file, tlink, oplock, data.symlink_target);
 676	if (cfile == NULL) {
 677		if (server->ops->close)
 678			server->ops->close(xid, tcon, &fid);
 679		cifs_del_pending_open(&open);
 680		rc = -ENOMEM;
 681		goto out;
 682	}
 683
 684#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 
 685	if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
 686		/*
 687		 * Time to set mode which we can not set earlier due to
 688		 * problems creating new read-only files.
 689		 */
 690		struct cifs_unix_set_info_args args = {
 691			.mode	= inode->i_mode,
 692			.uid	= INVALID_UID, /* no change */
 693			.gid	= INVALID_GID, /* no change */
 694			.ctime	= NO_CHANGE_64,
 695			.atime	= NO_CHANGE_64,
 696			.mtime	= NO_CHANGE_64,
 697			.device	= 0,
 698		};
 699		CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
 700				       cfile->pid);
 701	}
 702#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 703
 704use_cache:
 705	fscache_use_cookie(cifs_inode_cookie(file_inode(file)),
 706			   file->f_mode & FMODE_WRITE);
 707	if (file->f_flags & O_DIRECT &&
 708	    (!((file->f_flags & O_ACCMODE) != O_RDONLY) ||
 709	     file->f_flags & O_APPEND))
 710		cifs_invalidate_cache(file_inode(file),
 711				      FSCACHE_INVAL_DIO_WRITE);
 712
 713out:
 714	free_dentry_path(page);
 715	free_xid(xid);
 716	cifs_put_tlink(tlink);
 717	cifs_free_open_info(&data);
 718	return rc;
 719}
 720
 721#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 722static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
 723#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 724
 725/*
 726 * Try to reacquire byte range locks that were released when session
 727 * to server was lost.
 728 */
 729static int
 730cifs_relock_file(struct cifsFileInfo *cfile)
 731{
 
 732	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 733	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 734	int rc = 0;
 735#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 736	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
 737#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 738
 739	down_read_nested(&cinode->lock_sem, SINGLE_DEPTH_NESTING);
 740	if (cinode->can_cache_brlcks) {
 741		/* can cache locks - no need to relock */
 742		up_read(&cinode->lock_sem);
 743		return rc;
 744	}
 745
 746#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 747	if (cap_unix(tcon->ses) &&
 748	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
 749	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
 750		rc = cifs_push_posix_locks(cfile);
 751	else
 752#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 753		rc = tcon->ses->server->ops->push_mand_locks(cfile);
 754
 755	up_read(&cinode->lock_sem);
 756	return rc;
 757}
 758
 759static int
 760cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
 761{
 762	int rc = -EACCES;
 763	unsigned int xid;
 764	__u32 oplock;
 765	struct cifs_sb_info *cifs_sb;
 766	struct cifs_tcon *tcon;
 767	struct TCP_Server_Info *server;
 768	struct cifsInodeInfo *cinode;
 769	struct inode *inode;
 770	void *page;
 771	const char *full_path;
 772	int desired_access;
 773	int disposition = FILE_OPEN;
 774	int create_options = CREATE_NOT_DIR;
 775	struct cifs_open_parms oparms;
 776
 777	xid = get_xid();
 778	mutex_lock(&cfile->fh_mutex);
 779	if (!cfile->invalidHandle) {
 780		mutex_unlock(&cfile->fh_mutex);
 
 781		free_xid(xid);
 782		return 0;
 783	}
 784
 785	inode = d_inode(cfile->dentry);
 786	cifs_sb = CIFS_SB(inode->i_sb);
 787	tcon = tlink_tcon(cfile->tlink);
 788	server = tcon->ses->server;
 789
 790	/*
 791	 * Can not grab rename sem here because various ops, including those
 792	 * that already have the rename sem can end up causing writepage to get
 793	 * called and if the server was down that means we end up here, and we
 794	 * can never tell if the caller already has the rename_sem.
 795	 */
 796	page = alloc_dentry_path();
 797	full_path = build_path_from_dentry(cfile->dentry, page);
 798	if (IS_ERR(full_path)) {
 799		mutex_unlock(&cfile->fh_mutex);
 800		free_dentry_path(page);
 801		free_xid(xid);
 802		return PTR_ERR(full_path);
 803	}
 804
 805	cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
 806		 inode, cfile->f_flags, full_path);
 807
 808	if (tcon->ses->server->oplocks)
 809		oplock = REQ_OPLOCK;
 810	else
 811		oplock = 0;
 812
 813#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 814	if (tcon->unix_ext && cap_unix(tcon->ses) &&
 815	    (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 816				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 817		/*
 818		 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
 819		 * original open. Must mask them off for a reopen.
 820		 */
 821		unsigned int oflags = cfile->f_flags &
 822						~(O_CREAT | O_EXCL | O_TRUNC);
 823
 824		rc = cifs_posix_open(full_path, NULL, inode->i_sb,
 825				     cifs_sb->ctx->file_mode /* ignored */,
 826				     oflags, &oplock, &cfile->fid.netfid, xid);
 827		if (rc == 0) {
 828			cifs_dbg(FYI, "posix reopen succeeded\n");
 829			oparms.reconnect = true;
 830			goto reopen_success;
 831		}
 832		/*
 833		 * fallthrough to retry open the old way on errors, especially
 834		 * in the reconnect path it is important to retry hard
 835		 */
 836	}
 837#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 838
 839	desired_access = cifs_convert_flags(cfile->f_flags);
 840
 841	/* O_SYNC also has bit for O_DSYNC so following check picks up either */
 842	if (cfile->f_flags & O_SYNC)
 843		create_options |= CREATE_WRITE_THROUGH;
 844
 845	if (cfile->f_flags & O_DIRECT)
 846		create_options |= CREATE_NO_BUFFER;
 847
 848	if (server->ops->get_lease_key)
 849		server->ops->get_lease_key(inode, &cfile->fid);
 850
 851	oparms.tcon = tcon;
 852	oparms.cifs_sb = cifs_sb;
 853	oparms.desired_access = desired_access;
 854	oparms.create_options = cifs_create_options(cifs_sb, create_options);
 855	oparms.disposition = disposition;
 856	oparms.path = full_path;
 857	oparms.fid = &cfile->fid;
 858	oparms.reconnect = true;
 859
 860	/*
 861	 * Can not refresh inode by passing in file_info buf to be returned by
 862	 * ops->open and then calling get_inode_info with returned buf since
 863	 * file might have write behind data that needs to be flushed and server
 864	 * version of file size can be stale. If we knew for sure that inode was
 865	 * not dirty locally we could do this.
 866	 */
 867	rc = server->ops->open(xid, &oparms, &oplock, NULL);
 868	if (rc == -ENOENT && oparms.reconnect == false) {
 869		/* durable handle timeout is expired - open the file again */
 870		rc = server->ops->open(xid, &oparms, &oplock, NULL);
 871		/* indicate that we need to relock the file */
 872		oparms.reconnect = true;
 873	}
 874
 875	if (rc) {
 876		mutex_unlock(&cfile->fh_mutex);
 877		cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
 878		cifs_dbg(FYI, "oplock: %d\n", oplock);
 879		goto reopen_error_exit;
 880	}
 881
 882#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 883reopen_success:
 884#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 885	cfile->invalidHandle = false;
 886	mutex_unlock(&cfile->fh_mutex);
 887	cinode = CIFS_I(inode);
 888
 889	if (can_flush) {
 890		rc = filemap_write_and_wait(inode->i_mapping);
 891		if (!is_interrupt_error(rc))
 892			mapping_set_error(inode->i_mapping, rc);
 893
 894		if (tcon->posix_extensions)
 895			rc = smb311_posix_get_inode_info(&inode, full_path, inode->i_sb, xid);
 896		else if (tcon->unix_ext)
 897			rc = cifs_get_inode_info_unix(&inode, full_path,
 898						      inode->i_sb, xid);
 899		else
 900			rc = cifs_get_inode_info(&inode, full_path, NULL,
 901						 inode->i_sb, xid, NULL);
 902	}
 903	/*
 904	 * Else we are writing out data to server already and could deadlock if
 905	 * we tried to flush data, and since we do not know if we have data that
 906	 * would invalidate the current end of file on the server we can not go
 907	 * to the server to get the new inode info.
 908	 */
 909
 910	/*
 911	 * If the server returned a read oplock and we have mandatory brlocks,
 912	 * set oplock level to None.
 913	 */
 914	if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
 915		cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
 916		oplock = 0;
 917	}
 918
 919	server->ops->set_fid(cfile, &cfile->fid, oplock);
 920	if (oparms.reconnect)
 921		cifs_relock_file(cfile);
 922
 923reopen_error_exit:
 924	free_dentry_path(page);
 925	free_xid(xid);
 926	return rc;
 927}
 928
 929void smb2_deferred_work_close(struct work_struct *work)
 930{
 931	struct cifsFileInfo *cfile = container_of(work,
 932			struct cifsFileInfo, deferred.work);
 933
 934	spin_lock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock);
 935	cifs_del_deferred_close(cfile);
 936	cfile->deferred_close_scheduled = false;
 937	spin_unlock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock);
 938	_cifsFileInfo_put(cfile, true, false);
 939}
 940
 941int cifs_close(struct inode *inode, struct file *file)
 942{
 943	struct cifsFileInfo *cfile;
 944	struct cifsInodeInfo *cinode = CIFS_I(inode);
 945	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 946	struct cifs_deferred_close *dclose;
 947
 948	cifs_fscache_unuse_inode_cookie(inode, file->f_mode & FMODE_WRITE);
 949
 950	if (file->private_data != NULL) {
 951		cfile = file->private_data;
 952		file->private_data = NULL;
 953		dclose = kmalloc(sizeof(struct cifs_deferred_close), GFP_KERNEL);
 954		if ((cinode->oplock == CIFS_CACHE_RHW_FLG) &&
 955		    cinode->lease_granted &&
 956		    !test_bit(CIFS_INO_CLOSE_ON_LOCK, &cinode->flags) &&
 957		    dclose) {
 958			if (test_and_clear_bit(CIFS_INO_MODIFIED_ATTR, &cinode->flags)) {
 959				inode->i_ctime = inode->i_mtime = current_time(inode);
 960			}
 961			spin_lock(&cinode->deferred_lock);
 962			cifs_add_deferred_close(cfile, dclose);
 963			if (cfile->deferred_close_scheduled &&
 964			    delayed_work_pending(&cfile->deferred)) {
 965				/*
 966				 * If there is no pending work, mod_delayed_work queues new work.
 967				 * So, Increase the ref count to avoid use-after-free.
 968				 */
 969				if (!mod_delayed_work(deferredclose_wq,
 970						&cfile->deferred, cifs_sb->ctx->closetimeo))
 971					cifsFileInfo_get(cfile);
 972			} else {
 973				/* Deferred close for files */
 974				queue_delayed_work(deferredclose_wq,
 975						&cfile->deferred, cifs_sb->ctx->closetimeo);
 976				cfile->deferred_close_scheduled = true;
 977				spin_unlock(&cinode->deferred_lock);
 978				return 0;
 979			}
 980			spin_unlock(&cinode->deferred_lock);
 981			_cifsFileInfo_put(cfile, true, false);
 982		} else {
 983			_cifsFileInfo_put(cfile, true, false);
 984			kfree(dclose);
 985		}
 986	}
 987
 988	/* return code from the ->release op is always ignored */
 989	return 0;
 990}
 991
 992void
 993cifs_reopen_persistent_handles(struct cifs_tcon *tcon)
 994{
 995	struct cifsFileInfo *open_file, *tmp;
 
 
 996	struct list_head tmp_list;
 997
 998	if (!tcon->use_persistent || !tcon->need_reopen_files)
 999		return;
1000
1001	tcon->need_reopen_files = false;
1002
1003	cifs_dbg(FYI, "Reopen persistent handles\n");
1004	INIT_LIST_HEAD(&tmp_list);
1005
1006	/* list all files open on tree connection, reopen resilient handles  */
1007	spin_lock(&tcon->open_file_lock);
1008	list_for_each_entry(open_file, &tcon->openFileList, tlist) {
 
1009		if (!open_file->invalidHandle)
1010			continue;
1011		cifsFileInfo_get(open_file);
1012		list_add_tail(&open_file->rlist, &tmp_list);
1013	}
1014	spin_unlock(&tcon->open_file_lock);
1015
1016	list_for_each_entry_safe(open_file, tmp, &tmp_list, rlist) {
 
1017		if (cifs_reopen_file(open_file, false /* do not flush */))
1018			tcon->need_reopen_files = true;
1019		list_del_init(&open_file->rlist);
1020		cifsFileInfo_put(open_file);
1021	}
1022}
1023
1024int cifs_closedir(struct inode *inode, struct file *file)
1025{
1026	int rc = 0;
1027	unsigned int xid;
1028	struct cifsFileInfo *cfile = file->private_data;
1029	struct cifs_tcon *tcon;
1030	struct TCP_Server_Info *server;
1031	char *buf;
1032
1033	cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
1034
1035	if (cfile == NULL)
1036		return rc;
1037
1038	xid = get_xid();
1039	tcon = tlink_tcon(cfile->tlink);
1040	server = tcon->ses->server;
1041
1042	cifs_dbg(FYI, "Freeing private data in close dir\n");
1043	spin_lock(&cfile->file_info_lock);
1044	if (server->ops->dir_needs_close(cfile)) {
1045		cfile->invalidHandle = true;
1046		spin_unlock(&cfile->file_info_lock);
1047		if (server->ops->close_dir)
1048			rc = server->ops->close_dir(xid, tcon, &cfile->fid);
1049		else
1050			rc = -ENOSYS;
1051		cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
1052		/* not much we can do if it fails anyway, ignore rc */
1053		rc = 0;
1054	} else
1055		spin_unlock(&cfile->file_info_lock);
1056
1057	buf = cfile->srch_inf.ntwrk_buf_start;
1058	if (buf) {
1059		cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
1060		cfile->srch_inf.ntwrk_buf_start = NULL;
1061		if (cfile->srch_inf.smallBuf)
1062			cifs_small_buf_release(buf);
1063		else
1064			cifs_buf_release(buf);
1065	}
1066
1067	cifs_put_tlink(cfile->tlink);
1068	kfree(file->private_data);
1069	file->private_data = NULL;
1070	/* BB can we lock the filestruct while this is going on? */
1071	free_xid(xid);
1072	return rc;
1073}
1074
1075static struct cifsLockInfo *
1076cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 flags)
1077{
1078	struct cifsLockInfo *lock =
1079		kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
1080	if (!lock)
1081		return lock;
1082	lock->offset = offset;
1083	lock->length = length;
1084	lock->type = type;
1085	lock->pid = current->tgid;
1086	lock->flags = flags;
1087	INIT_LIST_HEAD(&lock->blist);
1088	init_waitqueue_head(&lock->block_q);
1089	return lock;
1090}
1091
1092void
1093cifs_del_lock_waiters(struct cifsLockInfo *lock)
1094{
1095	struct cifsLockInfo *li, *tmp;
1096	list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
1097		list_del_init(&li->blist);
1098		wake_up(&li->block_q);
1099	}
1100}
1101
1102#define CIFS_LOCK_OP	0
1103#define CIFS_READ_OP	1
1104#define CIFS_WRITE_OP	2
1105
1106/* @rw_check : 0 - no op, 1 - read, 2 - write */
1107static bool
1108cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
1109			    __u64 length, __u8 type, __u16 flags,
1110			    struct cifsFileInfo *cfile,
1111			    struct cifsLockInfo **conf_lock, int rw_check)
1112{
1113	struct cifsLockInfo *li;
1114	struct cifsFileInfo *cur_cfile = fdlocks->cfile;
1115	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1116
1117	list_for_each_entry(li, &fdlocks->locks, llist) {
1118		if (offset + length <= li->offset ||
1119		    offset >= li->offset + li->length)
1120			continue;
1121		if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
1122		    server->ops->compare_fids(cfile, cur_cfile)) {
1123			/* shared lock prevents write op through the same fid */
1124			if (!(li->type & server->vals->shared_lock_type) ||
1125			    rw_check != CIFS_WRITE_OP)
1126				continue;
1127		}
1128		if ((type & server->vals->shared_lock_type) &&
1129		    ((server->ops->compare_fids(cfile, cur_cfile) &&
1130		     current->tgid == li->pid) || type == li->type))
1131			continue;
1132		if (rw_check == CIFS_LOCK_OP &&
1133		    (flags & FL_OFDLCK) && (li->flags & FL_OFDLCK) &&
1134		    server->ops->compare_fids(cfile, cur_cfile))
1135			continue;
1136		if (conf_lock)
1137			*conf_lock = li;
1138		return true;
1139	}
1140	return false;
1141}
1142
1143bool
1144cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
1145			__u8 type, __u16 flags,
1146			struct cifsLockInfo **conf_lock, int rw_check)
1147{
1148	bool rc = false;
1149	struct cifs_fid_locks *cur;
1150	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1151
1152	list_for_each_entry(cur, &cinode->llist, llist) {
1153		rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
1154						 flags, cfile, conf_lock,
1155						 rw_check);
1156		if (rc)
1157			break;
1158	}
1159
1160	return rc;
1161}
1162
1163/*
1164 * Check if there is another lock that prevents us to set the lock (mandatory
1165 * style). If such a lock exists, update the flock structure with its
1166 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1167 * or leave it the same if we can't. Returns 0 if we don't need to request to
1168 * the server or 1 otherwise.
1169 */
1170static int
1171cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
1172	       __u8 type, struct file_lock *flock)
1173{
1174	int rc = 0;
1175	struct cifsLockInfo *conf_lock;
1176	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1177	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1178	bool exist;
1179
1180	down_read(&cinode->lock_sem);
1181
1182	exist = cifs_find_lock_conflict(cfile, offset, length, type,
1183					flock->fl_flags, &conf_lock,
1184					CIFS_LOCK_OP);
1185	if (exist) {
1186		flock->fl_start = conf_lock->offset;
1187		flock->fl_end = conf_lock->offset + conf_lock->length - 1;
1188		flock->fl_pid = conf_lock->pid;
1189		if (conf_lock->type & server->vals->shared_lock_type)
1190			flock->fl_type = F_RDLCK;
1191		else
1192			flock->fl_type = F_WRLCK;
1193	} else if (!cinode->can_cache_brlcks)
1194		rc = 1;
1195	else
1196		flock->fl_type = F_UNLCK;
1197
1198	up_read(&cinode->lock_sem);
1199	return rc;
1200}
1201
1202static void
1203cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
1204{
1205	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1206	cifs_down_write(&cinode->lock_sem);
1207	list_add_tail(&lock->llist, &cfile->llist->locks);
1208	up_write(&cinode->lock_sem);
1209}
1210
1211/*
1212 * Set the byte-range lock (mandatory style). Returns:
1213 * 1) 0, if we set the lock and don't need to request to the server;
1214 * 2) 1, if no locks prevent us but we need to request to the server;
1215 * 3) -EACCES, if there is a lock that prevents us and wait is false.
1216 */
1217static int
1218cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
1219		 bool wait)
1220{
1221	struct cifsLockInfo *conf_lock;
1222	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1223	bool exist;
1224	int rc = 0;
1225
1226try_again:
1227	exist = false;
1228	cifs_down_write(&cinode->lock_sem);
1229
1230	exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
1231					lock->type, lock->flags, &conf_lock,
1232					CIFS_LOCK_OP);
1233	if (!exist && cinode->can_cache_brlcks) {
1234		list_add_tail(&lock->llist, &cfile->llist->locks);
1235		up_write(&cinode->lock_sem);
1236		return rc;
1237	}
1238
1239	if (!exist)
1240		rc = 1;
1241	else if (!wait)
1242		rc = -EACCES;
1243	else {
1244		list_add_tail(&lock->blist, &conf_lock->blist);
1245		up_write(&cinode->lock_sem);
1246		rc = wait_event_interruptible(lock->block_q,
1247					(lock->blist.prev == &lock->blist) &&
1248					(lock->blist.next == &lock->blist));
1249		if (!rc)
1250			goto try_again;
1251		cifs_down_write(&cinode->lock_sem);
1252		list_del_init(&lock->blist);
1253	}
1254
1255	up_write(&cinode->lock_sem);
1256	return rc;
1257}
1258
1259#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1260/*
1261 * Check if there is another lock that prevents us to set the lock (posix
1262 * style). If such a lock exists, update the flock structure with its
1263 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1264 * or leave it the same if we can't. Returns 0 if we don't need to request to
1265 * the server or 1 otherwise.
1266 */
1267static int
1268cifs_posix_lock_test(struct file *file, struct file_lock *flock)
1269{
1270	int rc = 0;
1271	struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1272	unsigned char saved_type = flock->fl_type;
1273
1274	if ((flock->fl_flags & FL_POSIX) == 0)
1275		return 1;
1276
1277	down_read(&cinode->lock_sem);
1278	posix_test_lock(file, flock);
1279
1280	if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
1281		flock->fl_type = saved_type;
1282		rc = 1;
1283	}
1284
1285	up_read(&cinode->lock_sem);
1286	return rc;
1287}
1288
1289/*
1290 * Set the byte-range lock (posix style). Returns:
1291 * 1) <0, if the error occurs while setting the lock;
1292 * 2) 0, if we set the lock and don't need to request to the server;
1293 * 3) FILE_LOCK_DEFERRED, if we will wait for some other file_lock;
1294 * 4) FILE_LOCK_DEFERRED + 1, if we need to request to the server.
1295 */
1296static int
1297cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1298{
1299	struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1300	int rc = FILE_LOCK_DEFERRED + 1;
1301
1302	if ((flock->fl_flags & FL_POSIX) == 0)
1303		return rc;
1304
 
1305	cifs_down_write(&cinode->lock_sem);
1306	if (!cinode->can_cache_brlcks) {
1307		up_write(&cinode->lock_sem);
1308		return rc;
1309	}
1310
1311	rc = posix_lock_file(file, flock, NULL);
1312	up_write(&cinode->lock_sem);
 
 
 
 
 
 
1313	return rc;
1314}
1315
1316int
1317cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1318{
1319	unsigned int xid;
1320	int rc = 0, stored_rc;
1321	struct cifsLockInfo *li, *tmp;
1322	struct cifs_tcon *tcon;
1323	unsigned int num, max_num, max_buf;
1324	LOCKING_ANDX_RANGE *buf, *cur;
1325	static const int types[] = {
1326		LOCKING_ANDX_LARGE_FILES,
1327		LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
1328	};
1329	int i;
1330
1331	xid = get_xid();
1332	tcon = tlink_tcon(cfile->tlink);
1333
1334	/*
1335	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1336	 * and check it before using.
1337	 */
1338	max_buf = tcon->ses->server->maxBuf;
1339	if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) {
1340		free_xid(xid);
1341		return -EINVAL;
1342	}
1343
1344	BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
1345		     PAGE_SIZE);
1346	max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
1347			PAGE_SIZE);
1348	max_num = (max_buf - sizeof(struct smb_hdr)) /
1349						sizeof(LOCKING_ANDX_RANGE);
1350	buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1351	if (!buf) {
1352		free_xid(xid);
1353		return -ENOMEM;
1354	}
1355
1356	for (i = 0; i < 2; i++) {
1357		cur = buf;
1358		num = 0;
1359		list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1360			if (li->type != types[i])
1361				continue;
1362			cur->Pid = cpu_to_le16(li->pid);
1363			cur->LengthLow = cpu_to_le32((u32)li->length);
1364			cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1365			cur->OffsetLow = cpu_to_le32((u32)li->offset);
1366			cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1367			if (++num == max_num) {
1368				stored_rc = cifs_lockv(xid, tcon,
1369						       cfile->fid.netfid,
1370						       (__u8)li->type, 0, num,
1371						       buf);
1372				if (stored_rc)
1373					rc = stored_rc;
1374				cur = buf;
1375				num = 0;
1376			} else
1377				cur++;
1378		}
1379
1380		if (num) {
1381			stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1382					       (__u8)types[i], 0, num, buf);
1383			if (stored_rc)
1384				rc = stored_rc;
1385		}
1386	}
1387
1388	kfree(buf);
1389	free_xid(xid);
1390	return rc;
1391}
1392
1393static __u32
1394hash_lockowner(fl_owner_t owner)
1395{
1396	return cifs_lock_secret ^ hash32_ptr((const void *)owner);
1397}
1398#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1399
1400struct lock_to_push {
1401	struct list_head llist;
1402	__u64 offset;
1403	__u64 length;
1404	__u32 pid;
1405	__u16 netfid;
1406	__u8 type;
1407};
1408
1409#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1410static int
1411cifs_push_posix_locks(struct cifsFileInfo *cfile)
1412{
1413	struct inode *inode = d_inode(cfile->dentry);
1414	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1415	struct file_lock *flock;
1416	struct file_lock_context *flctx = locks_inode_context(inode);
1417	unsigned int count = 0, i;
1418	int rc = 0, xid, type;
1419	struct list_head locks_to_send, *el;
1420	struct lock_to_push *lck, *tmp;
1421	__u64 length;
1422
1423	xid = get_xid();
1424
1425	if (!flctx)
1426		goto out;
1427
1428	spin_lock(&flctx->flc_lock);
1429	list_for_each(el, &flctx->flc_posix) {
1430		count++;
1431	}
1432	spin_unlock(&flctx->flc_lock);
1433
1434	INIT_LIST_HEAD(&locks_to_send);
1435
1436	/*
1437	 * Allocating count locks is enough because no FL_POSIX locks can be
1438	 * added to the list while we are holding cinode->lock_sem that
1439	 * protects locking operations of this inode.
1440	 */
1441	for (i = 0; i < count; i++) {
1442		lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1443		if (!lck) {
1444			rc = -ENOMEM;
1445			goto err_out;
1446		}
1447		list_add_tail(&lck->llist, &locks_to_send);
1448	}
1449
1450	el = locks_to_send.next;
1451	spin_lock(&flctx->flc_lock);
1452	list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
1453		if (el == &locks_to_send) {
1454			/*
1455			 * The list ended. We don't have enough allocated
1456			 * structures - something is really wrong.
1457			 */
1458			cifs_dbg(VFS, "Can't push all brlocks!\n");
1459			break;
1460		}
1461		length = cifs_flock_len(flock);
1462		if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1463			type = CIFS_RDLCK;
1464		else
1465			type = CIFS_WRLCK;
1466		lck = list_entry(el, struct lock_to_push, llist);
1467		lck->pid = hash_lockowner(flock->fl_owner);
1468		lck->netfid = cfile->fid.netfid;
1469		lck->length = length;
1470		lck->type = type;
1471		lck->offset = flock->fl_start;
1472	}
1473	spin_unlock(&flctx->flc_lock);
1474
1475	list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1476		int stored_rc;
1477
1478		stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1479					     lck->offset, lck->length, NULL,
1480					     lck->type, 0);
1481		if (stored_rc)
1482			rc = stored_rc;
1483		list_del(&lck->llist);
1484		kfree(lck);
1485	}
1486
1487out:
1488	free_xid(xid);
1489	return rc;
1490err_out:
1491	list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1492		list_del(&lck->llist);
1493		kfree(lck);
1494	}
1495	goto out;
1496}
1497#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1498
1499static int
1500cifs_push_locks(struct cifsFileInfo *cfile)
1501{
 
1502	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1503	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1504	int rc = 0;
1505#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1506	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1507#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1508
1509	/* we are going to update can_cache_brlcks here - need a write access */
1510	cifs_down_write(&cinode->lock_sem);
1511	if (!cinode->can_cache_brlcks) {
1512		up_write(&cinode->lock_sem);
1513		return rc;
1514	}
1515
1516#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1517	if (cap_unix(tcon->ses) &&
1518	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1519	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1520		rc = cifs_push_posix_locks(cfile);
1521	else
1522#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1523		rc = tcon->ses->server->ops->push_mand_locks(cfile);
1524
1525	cinode->can_cache_brlcks = false;
1526	up_write(&cinode->lock_sem);
1527	return rc;
1528}
1529
1530static void
1531cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1532		bool *wait_flag, struct TCP_Server_Info *server)
1533{
1534	if (flock->fl_flags & FL_POSIX)
1535		cifs_dbg(FYI, "Posix\n");
1536	if (flock->fl_flags & FL_FLOCK)
1537		cifs_dbg(FYI, "Flock\n");
1538	if (flock->fl_flags & FL_SLEEP) {
1539		cifs_dbg(FYI, "Blocking lock\n");
1540		*wait_flag = true;
1541	}
1542	if (flock->fl_flags & FL_ACCESS)
1543		cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1544	if (flock->fl_flags & FL_LEASE)
1545		cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1546	if (flock->fl_flags &
1547	    (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1548	       FL_ACCESS | FL_LEASE | FL_CLOSE | FL_OFDLCK)))
1549		cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
1550
1551	*type = server->vals->large_lock_type;
1552	if (flock->fl_type == F_WRLCK) {
1553		cifs_dbg(FYI, "F_WRLCK\n");
1554		*type |= server->vals->exclusive_lock_type;
1555		*lock = 1;
1556	} else if (flock->fl_type == F_UNLCK) {
1557		cifs_dbg(FYI, "F_UNLCK\n");
1558		*type |= server->vals->unlock_lock_type;
1559		*unlock = 1;
1560		/* Check if unlock includes more than one lock range */
1561	} else if (flock->fl_type == F_RDLCK) {
1562		cifs_dbg(FYI, "F_RDLCK\n");
1563		*type |= server->vals->shared_lock_type;
1564		*lock = 1;
1565	} else if (flock->fl_type == F_EXLCK) {
1566		cifs_dbg(FYI, "F_EXLCK\n");
1567		*type |= server->vals->exclusive_lock_type;
1568		*lock = 1;
1569	} else if (flock->fl_type == F_SHLCK) {
1570		cifs_dbg(FYI, "F_SHLCK\n");
1571		*type |= server->vals->shared_lock_type;
1572		*lock = 1;
1573	} else
1574		cifs_dbg(FYI, "Unknown type of lock\n");
1575}
1576
1577static int
1578cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1579	   bool wait_flag, bool posix_lck, unsigned int xid)
1580{
1581	int rc = 0;
1582	__u64 length = cifs_flock_len(flock);
1583	struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1584	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1585	struct TCP_Server_Info *server = tcon->ses->server;
1586#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1587	__u16 netfid = cfile->fid.netfid;
1588
1589	if (posix_lck) {
1590		int posix_lock_type;
1591
1592		rc = cifs_posix_lock_test(file, flock);
1593		if (!rc)
1594			return rc;
1595
1596		if (type & server->vals->shared_lock_type)
1597			posix_lock_type = CIFS_RDLCK;
1598		else
1599			posix_lock_type = CIFS_WRLCK;
1600		rc = CIFSSMBPosixLock(xid, tcon, netfid,
1601				      hash_lockowner(flock->fl_owner),
1602				      flock->fl_start, length, flock,
1603				      posix_lock_type, wait_flag);
1604		return rc;
1605	}
1606#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1607
1608	rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1609	if (!rc)
1610		return rc;
1611
1612	/* BB we could chain these into one lock request BB */
1613	rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1614				    1, 0, false);
1615	if (rc == 0) {
1616		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1617					    type, 0, 1, false);
1618		flock->fl_type = F_UNLCK;
1619		if (rc != 0)
1620			cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1621				 rc);
1622		return 0;
1623	}
1624
1625	if (type & server->vals->shared_lock_type) {
1626		flock->fl_type = F_WRLCK;
1627		return 0;
1628	}
1629
1630	type &= ~server->vals->exclusive_lock_type;
1631
1632	rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1633				    type | server->vals->shared_lock_type,
1634				    1, 0, false);
1635	if (rc == 0) {
1636		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1637			type | server->vals->shared_lock_type, 0, 1, false);
1638		flock->fl_type = F_RDLCK;
1639		if (rc != 0)
1640			cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1641				 rc);
1642	} else
1643		flock->fl_type = F_WRLCK;
1644
1645	return 0;
1646}
1647
1648void
1649cifs_move_llist(struct list_head *source, struct list_head *dest)
1650{
1651	struct list_head *li, *tmp;
1652	list_for_each_safe(li, tmp, source)
1653		list_move(li, dest);
1654}
1655
1656void
1657cifs_free_llist(struct list_head *llist)
1658{
1659	struct cifsLockInfo *li, *tmp;
1660	list_for_each_entry_safe(li, tmp, llist, llist) {
1661		cifs_del_lock_waiters(li);
1662		list_del(&li->llist);
1663		kfree(li);
1664	}
1665}
1666
1667#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1668int
1669cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1670		  unsigned int xid)
1671{
1672	int rc = 0, stored_rc;
1673	static const int types[] = {
1674		LOCKING_ANDX_LARGE_FILES,
1675		LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
1676	};
1677	unsigned int i;
1678	unsigned int max_num, num, max_buf;
1679	LOCKING_ANDX_RANGE *buf, *cur;
1680	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1681	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1682	struct cifsLockInfo *li, *tmp;
1683	__u64 length = cifs_flock_len(flock);
1684	struct list_head tmp_llist;
1685
1686	INIT_LIST_HEAD(&tmp_llist);
1687
1688	/*
1689	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1690	 * and check it before using.
1691	 */
1692	max_buf = tcon->ses->server->maxBuf;
1693	if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE)))
1694		return -EINVAL;
1695
1696	BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
1697		     PAGE_SIZE);
1698	max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
1699			PAGE_SIZE);
1700	max_num = (max_buf - sizeof(struct smb_hdr)) /
1701						sizeof(LOCKING_ANDX_RANGE);
1702	buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1703	if (!buf)
1704		return -ENOMEM;
1705
1706	cifs_down_write(&cinode->lock_sem);
1707	for (i = 0; i < 2; i++) {
1708		cur = buf;
1709		num = 0;
1710		list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1711			if (flock->fl_start > li->offset ||
1712			    (flock->fl_start + length) <
1713			    (li->offset + li->length))
1714				continue;
1715			if (current->tgid != li->pid)
1716				continue;
1717			if (types[i] != li->type)
1718				continue;
1719			if (cinode->can_cache_brlcks) {
1720				/*
1721				 * We can cache brlock requests - simply remove
1722				 * a lock from the file's list.
1723				 */
1724				list_del(&li->llist);
1725				cifs_del_lock_waiters(li);
1726				kfree(li);
1727				continue;
1728			}
1729			cur->Pid = cpu_to_le16(li->pid);
1730			cur->LengthLow = cpu_to_le32((u32)li->length);
1731			cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1732			cur->OffsetLow = cpu_to_le32((u32)li->offset);
1733			cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1734			/*
1735			 * We need to save a lock here to let us add it again to
1736			 * the file's list if the unlock range request fails on
1737			 * the server.
1738			 */
1739			list_move(&li->llist, &tmp_llist);
1740			if (++num == max_num) {
1741				stored_rc = cifs_lockv(xid, tcon,
1742						       cfile->fid.netfid,
1743						       li->type, num, 0, buf);
1744				if (stored_rc) {
1745					/*
1746					 * We failed on the unlock range
1747					 * request - add all locks from the tmp
1748					 * list to the head of the file's list.
1749					 */
1750					cifs_move_llist(&tmp_llist,
1751							&cfile->llist->locks);
1752					rc = stored_rc;
1753				} else
1754					/*
1755					 * The unlock range request succeed -
1756					 * free the tmp list.
1757					 */
1758					cifs_free_llist(&tmp_llist);
1759				cur = buf;
1760				num = 0;
1761			} else
1762				cur++;
1763		}
1764		if (num) {
1765			stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1766					       types[i], num, 0, buf);
1767			if (stored_rc) {
1768				cifs_move_llist(&tmp_llist,
1769						&cfile->llist->locks);
1770				rc = stored_rc;
1771			} else
1772				cifs_free_llist(&tmp_llist);
1773		}
1774	}
1775
1776	up_write(&cinode->lock_sem);
1777	kfree(buf);
1778	return rc;
1779}
1780#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1781
1782static int
1783cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1784	   bool wait_flag, bool posix_lck, int lock, int unlock,
1785	   unsigned int xid)
1786{
1787	int rc = 0;
1788	__u64 length = cifs_flock_len(flock);
1789	struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1790	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1791	struct TCP_Server_Info *server = tcon->ses->server;
1792	struct inode *inode = d_inode(cfile->dentry);
1793
1794#ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1795	if (posix_lck) {
1796		int posix_lock_type;
1797
1798		rc = cifs_posix_lock_set(file, flock);
1799		if (rc <= FILE_LOCK_DEFERRED)
1800			return rc;
1801
1802		if (type & server->vals->shared_lock_type)
1803			posix_lock_type = CIFS_RDLCK;
1804		else
1805			posix_lock_type = CIFS_WRLCK;
1806
1807		if (unlock == 1)
1808			posix_lock_type = CIFS_UNLCK;
1809
1810		rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1811				      hash_lockowner(flock->fl_owner),
1812				      flock->fl_start, length,
1813				      NULL, posix_lock_type, wait_flag);
1814		goto out;
1815	}
1816#endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1817	if (lock) {
1818		struct cifsLockInfo *lock;
1819
1820		lock = cifs_lock_init(flock->fl_start, length, type,
1821				      flock->fl_flags);
1822		if (!lock)
1823			return -ENOMEM;
1824
1825		rc = cifs_lock_add_if(cfile, lock, wait_flag);
1826		if (rc < 0) {
1827			kfree(lock);
1828			return rc;
1829		}
1830		if (!rc)
1831			goto out;
1832
1833		/*
1834		 * Windows 7 server can delay breaking lease from read to None
1835		 * if we set a byte-range lock on a file - break it explicitly
1836		 * before sending the lock to the server to be sure the next
1837		 * read won't conflict with non-overlapted locks due to
1838		 * pagereading.
1839		 */
1840		if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1841					CIFS_CACHE_READ(CIFS_I(inode))) {
1842			cifs_zap_mapping(inode);
1843			cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1844				 inode);
1845			CIFS_I(inode)->oplock = 0;
1846		}
1847
1848		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1849					    type, 1, 0, wait_flag);
1850		if (rc) {
1851			kfree(lock);
1852			return rc;
1853		}
1854
1855		cifs_lock_add(cfile, lock);
1856	} else if (unlock)
1857		rc = server->ops->mand_unlock_range(cfile, flock, xid);
1858
1859out:
1860	if ((flock->fl_flags & FL_POSIX) || (flock->fl_flags & FL_FLOCK)) {
1861		/*
1862		 * If this is a request to remove all locks because we
1863		 * are closing the file, it doesn't matter if the
1864		 * unlocking failed as both cifs.ko and the SMB server
1865		 * remove the lock on file close
1866		 */
1867		if (rc) {
1868			cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc);
1869			if (!(flock->fl_flags & FL_CLOSE))
1870				return rc;
1871		}
1872		rc = locks_lock_file_wait(file, flock);
1873	}
1874	return rc;
1875}
1876
1877int cifs_flock(struct file *file, int cmd, struct file_lock *fl)
1878{
1879	int rc, xid;
1880	int lock = 0, unlock = 0;
1881	bool wait_flag = false;
1882	bool posix_lck = false;
1883	struct cifs_sb_info *cifs_sb;
1884	struct cifs_tcon *tcon;
1885	struct cifsFileInfo *cfile;
1886	__u32 type;
1887
1888	xid = get_xid();
1889
1890	if (!(fl->fl_flags & FL_FLOCK)) {
1891		rc = -ENOLCK;
1892		free_xid(xid);
1893		return rc;
1894	}
1895
1896	cfile = (struct cifsFileInfo *)file->private_data;
1897	tcon = tlink_tcon(cfile->tlink);
1898
1899	cifs_read_flock(fl, &type, &lock, &unlock, &wait_flag,
1900			tcon->ses->server);
1901	cifs_sb = CIFS_FILE_SB(file);
1902
1903	if (cap_unix(tcon->ses) &&
1904	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1905	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1906		posix_lck = true;
1907
1908	if (!lock && !unlock) {
1909		/*
1910		 * if no lock or unlock then nothing to do since we do not
1911		 * know what it is
1912		 */
1913		rc = -EOPNOTSUPP;
1914		free_xid(xid);
1915		return rc;
1916	}
1917
1918	rc = cifs_setlk(file, fl, type, wait_flag, posix_lck, lock, unlock,
1919			xid);
1920	free_xid(xid);
1921	return rc;
1922
1923
1924}
1925
1926int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1927{
1928	int rc, xid;
1929	int lock = 0, unlock = 0;
1930	bool wait_flag = false;
1931	bool posix_lck = false;
1932	struct cifs_sb_info *cifs_sb;
1933	struct cifs_tcon *tcon;
1934	struct cifsFileInfo *cfile;
1935	__u32 type;
1936
1937	rc = -EACCES;
1938	xid = get_xid();
1939
1940	cifs_dbg(FYI, "%s: %pD2 cmd=0x%x type=0x%x flags=0x%x r=%lld:%lld\n", __func__, file, cmd,
1941		 flock->fl_flags, flock->fl_type, (long long)flock->fl_start,
1942		 (long long)flock->fl_end);
1943
1944	cfile = (struct cifsFileInfo *)file->private_data;
1945	tcon = tlink_tcon(cfile->tlink);
1946
1947	cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1948			tcon->ses->server);
1949	cifs_sb = CIFS_FILE_SB(file);
1950	set_bit(CIFS_INO_CLOSE_ON_LOCK, &CIFS_I(d_inode(cfile->dentry))->flags);
1951
1952	if (cap_unix(tcon->ses) &&
1953	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1954	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1955		posix_lck = true;
1956	/*
1957	 * BB add code here to normalize offset and length to account for
1958	 * negative length which we can not accept over the wire.
1959	 */
1960	if (IS_GETLK(cmd)) {
1961		rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1962		free_xid(xid);
1963		return rc;
1964	}
1965
1966	if (!lock && !unlock) {
1967		/*
1968		 * if no lock or unlock then nothing to do since we do not
1969		 * know what it is
1970		 */
1971		free_xid(xid);
1972		return -EOPNOTSUPP;
1973	}
1974
1975	rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1976			xid);
1977	free_xid(xid);
1978	return rc;
1979}
1980
1981/*
1982 * update the file size (if needed) after a write. Should be called with
1983 * the inode->i_lock held
1984 */
1985void
1986cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1987		      unsigned int bytes_written)
1988{
1989	loff_t end_of_write = offset + bytes_written;
1990
1991	if (end_of_write > cifsi->server_eof)
1992		cifsi->server_eof = end_of_write;
1993}
1994
1995static ssize_t
1996cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1997	   size_t write_size, loff_t *offset)
1998{
1999	int rc = 0;
2000	unsigned int bytes_written = 0;
2001	unsigned int total_written;
2002	struct cifs_tcon *tcon;
2003	struct TCP_Server_Info *server;
2004	unsigned int xid;
2005	struct dentry *dentry = open_file->dentry;
2006	struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
2007	struct cifs_io_parms io_parms = {0};
2008
2009	cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
2010		 write_size, *offset, dentry);
2011
2012	tcon = tlink_tcon(open_file->tlink);
2013	server = tcon->ses->server;
2014
2015	if (!server->ops->sync_write)
2016		return -ENOSYS;
2017
2018	xid = get_xid();
2019
2020	for (total_written = 0; write_size > total_written;
2021	     total_written += bytes_written) {
2022		rc = -EAGAIN;
2023		while (rc == -EAGAIN) {
2024			struct kvec iov[2];
2025			unsigned int len;
2026
2027			if (open_file->invalidHandle) {
2028				/* we could deadlock if we called
2029				   filemap_fdatawait from here so tell
2030				   reopen_file not to flush data to
2031				   server now */
2032				rc = cifs_reopen_file(open_file, false);
2033				if (rc != 0)
2034					break;
2035			}
2036
2037			len = min(server->ops->wp_retry_size(d_inode(dentry)),
2038				  (unsigned int)write_size - total_written);
2039			/* iov[0] is reserved for smb header */
2040			iov[1].iov_base = (char *)write_data + total_written;
2041			iov[1].iov_len = len;
2042			io_parms.pid = pid;
2043			io_parms.tcon = tcon;
2044			io_parms.offset = *offset;
2045			io_parms.length = len;
2046			rc = server->ops->sync_write(xid, &open_file->fid,
2047					&io_parms, &bytes_written, iov, 1);
2048		}
2049		if (rc || (bytes_written == 0)) {
2050			if (total_written)
2051				break;
2052			else {
2053				free_xid(xid);
2054				return rc;
2055			}
2056		} else {
2057			spin_lock(&d_inode(dentry)->i_lock);
2058			cifs_update_eof(cifsi, *offset, bytes_written);
2059			spin_unlock(&d_inode(dentry)->i_lock);
2060			*offset += bytes_written;
2061		}
2062	}
2063
2064	cifs_stats_bytes_written(tcon, total_written);
2065
2066	if (total_written > 0) {
2067		spin_lock(&d_inode(dentry)->i_lock);
2068		if (*offset > d_inode(dentry)->i_size) {
2069			i_size_write(d_inode(dentry), *offset);
2070			d_inode(dentry)->i_blocks = (512 - 1 + *offset) >> 9;
2071		}
2072		spin_unlock(&d_inode(dentry)->i_lock);
2073	}
2074	mark_inode_dirty_sync(d_inode(dentry));
2075	free_xid(xid);
2076	return total_written;
2077}
2078
2079struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
2080					bool fsuid_only)
2081{
2082	struct cifsFileInfo *open_file = NULL;
2083	struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->netfs.inode.i_sb);
2084
2085	/* only filter by fsuid on multiuser mounts */
2086	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
2087		fsuid_only = false;
2088
2089	spin_lock(&cifs_inode->open_file_lock);
2090	/* we could simply get the first_list_entry since write-only entries
2091	   are always at the end of the list but since the first entry might
2092	   have a close pending, we go through the whole list */
2093	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2094		if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
2095			continue;
2096		if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
2097			if ((!open_file->invalidHandle)) {
2098				/* found a good file */
2099				/* lock it so it will not be closed on us */
2100				cifsFileInfo_get(open_file);
2101				spin_unlock(&cifs_inode->open_file_lock);
2102				return open_file;
2103			} /* else might as well continue, and look for
2104			     another, or simply have the caller reopen it
2105			     again rather than trying to fix this handle */
2106		} else /* write only file */
2107			break; /* write only files are last so must be done */
2108	}
2109	spin_unlock(&cifs_inode->open_file_lock);
2110	return NULL;
2111}
2112
2113/* Return -EBADF if no handle is found and general rc otherwise */
2114int
2115cifs_get_writable_file(struct cifsInodeInfo *cifs_inode, int flags,
2116		       struct cifsFileInfo **ret_file)
2117{
2118	struct cifsFileInfo *open_file, *inv_file = NULL;
2119	struct cifs_sb_info *cifs_sb;
2120	bool any_available = false;
2121	int rc = -EBADF;
2122	unsigned int refind = 0;
2123	bool fsuid_only = flags & FIND_WR_FSUID_ONLY;
2124	bool with_delete = flags & FIND_WR_WITH_DELETE;
2125	*ret_file = NULL;
2126
2127	/*
2128	 * Having a null inode here (because mapping->host was set to zero by
2129	 * the VFS or MM) should not happen but we had reports of on oops (due
2130	 * to it being zero) during stress testcases so we need to check for it
2131	 */
2132
2133	if (cifs_inode == NULL) {
2134		cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
2135		dump_stack();
2136		return rc;
2137	}
2138
2139	cifs_sb = CIFS_SB(cifs_inode->netfs.inode.i_sb);
2140
2141	/* only filter by fsuid on multiuser mounts */
2142	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
2143		fsuid_only = false;
2144
2145	spin_lock(&cifs_inode->open_file_lock);
2146refind_writable:
2147	if (refind > MAX_REOPEN_ATT) {
2148		spin_unlock(&cifs_inode->open_file_lock);
2149		return rc;
2150	}
2151	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2152		if (!any_available && open_file->pid != current->tgid)
2153			continue;
2154		if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
2155			continue;
2156		if (with_delete && !(open_file->fid.access & DELETE))
2157			continue;
2158		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2159			if (!open_file->invalidHandle) {
2160				/* found a good writable file */
2161				cifsFileInfo_get(open_file);
2162				spin_unlock(&cifs_inode->open_file_lock);
2163				*ret_file = open_file;
2164				return 0;
2165			} else {
2166				if (!inv_file)
2167					inv_file = open_file;
2168			}
2169		}
2170	}
2171	/* couldn't find useable FH with same pid, try any available */
2172	if (!any_available) {
2173		any_available = true;
2174		goto refind_writable;
2175	}
2176
2177	if (inv_file) {
2178		any_available = false;
2179		cifsFileInfo_get(inv_file);
2180	}
2181
2182	spin_unlock(&cifs_inode->open_file_lock);
2183
2184	if (inv_file) {
2185		rc = cifs_reopen_file(inv_file, false);
2186		if (!rc) {
2187			*ret_file = inv_file;
2188			return 0;
2189		}
2190
2191		spin_lock(&cifs_inode->open_file_lock);
2192		list_move_tail(&inv_file->flist, &cifs_inode->openFileList);
2193		spin_unlock(&cifs_inode->open_file_lock);
2194		cifsFileInfo_put(inv_file);
2195		++refind;
2196		inv_file = NULL;
2197		spin_lock(&cifs_inode->open_file_lock);
2198		goto refind_writable;
2199	}
2200
2201	return rc;
2202}
2203
2204struct cifsFileInfo *
2205find_writable_file(struct cifsInodeInfo *cifs_inode, int flags)
2206{
2207	struct cifsFileInfo *cfile;
2208	int rc;
2209
2210	rc = cifs_get_writable_file(cifs_inode, flags, &cfile);
2211	if (rc)
2212		cifs_dbg(FYI, "Couldn't find writable handle rc=%d\n", rc);
2213
2214	return cfile;
2215}
2216
2217int
2218cifs_get_writable_path(struct cifs_tcon *tcon, const char *name,
2219		       int flags,
2220		       struct cifsFileInfo **ret_file)
2221{
 
2222	struct cifsFileInfo *cfile;
2223	void *page = alloc_dentry_path();
 
2224
2225	*ret_file = NULL;
2226
2227	spin_lock(&tcon->open_file_lock);
2228	list_for_each_entry(cfile, &tcon->openFileList, tlist) {
2229		struct cifsInodeInfo *cinode;
2230		const char *full_path = build_path_from_dentry(cfile->dentry, page);
2231		if (IS_ERR(full_path)) {
 
2232			spin_unlock(&tcon->open_file_lock);
2233			free_dentry_path(page);
2234			return PTR_ERR(full_path);
2235		}
2236		if (strcmp(full_path, name))
 
2237			continue;
 
2238
 
2239		cinode = CIFS_I(d_inode(cfile->dentry));
2240		spin_unlock(&tcon->open_file_lock);
2241		free_dentry_path(page);
2242		return cifs_get_writable_file(cinode, flags, ret_file);
2243	}
2244
2245	spin_unlock(&tcon->open_file_lock);
2246	free_dentry_path(page);
2247	return -ENOENT;
2248}
2249
2250int
2251cifs_get_readable_path(struct cifs_tcon *tcon, const char *name,
2252		       struct cifsFileInfo **ret_file)
2253{
 
2254	struct cifsFileInfo *cfile;
2255	void *page = alloc_dentry_path();
 
2256
2257	*ret_file = NULL;
2258
2259	spin_lock(&tcon->open_file_lock);
2260	list_for_each_entry(cfile, &tcon->openFileList, tlist) {
2261		struct cifsInodeInfo *cinode;
2262		const char *full_path = build_path_from_dentry(cfile->dentry, page);
2263		if (IS_ERR(full_path)) {
 
2264			spin_unlock(&tcon->open_file_lock);
2265			free_dentry_path(page);
2266			return PTR_ERR(full_path);
2267		}
2268		if (strcmp(full_path, name))
 
2269			continue;
 
2270
 
2271		cinode = CIFS_I(d_inode(cfile->dentry));
2272		spin_unlock(&tcon->open_file_lock);
2273		free_dentry_path(page);
2274		*ret_file = find_readable_file(cinode, 0);
2275		return *ret_file ? 0 : -ENOENT;
2276	}
2277
2278	spin_unlock(&tcon->open_file_lock);
2279	free_dentry_path(page);
2280	return -ENOENT;
2281}
2282
2283void
2284cifs_writedata_release(struct kref *refcount)
2285{
2286	struct cifs_writedata *wdata = container_of(refcount,
2287					struct cifs_writedata, refcount);
2288#ifdef CONFIG_CIFS_SMB_DIRECT
2289	if (wdata->mr) {
2290		smbd_deregister_mr(wdata->mr);
2291		wdata->mr = NULL;
2292	}
2293#endif
2294
2295	if (wdata->cfile)
2296		cifsFileInfo_put(wdata->cfile);
2297
2298	kvfree(wdata->pages);
2299	kfree(wdata);
2300}
2301
2302/*
2303 * Write failed with a retryable error. Resend the write request. It's also
2304 * possible that the page was redirtied so re-clean the page.
2305 */
2306static void
2307cifs_writev_requeue(struct cifs_writedata *wdata)
2308{
2309	int i, rc = 0;
2310	struct inode *inode = d_inode(wdata->cfile->dentry);
2311	struct TCP_Server_Info *server;
2312	unsigned int rest_len;
2313
2314	server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2315	i = 0;
2316	rest_len = wdata->bytes;
2317	do {
2318		struct cifs_writedata *wdata2;
2319		unsigned int j, nr_pages, wsize, tailsz, cur_len;
2320
2321		wsize = server->ops->wp_retry_size(inode);
2322		if (wsize < rest_len) {
2323			nr_pages = wsize / PAGE_SIZE;
2324			if (!nr_pages) {
2325				rc = -EOPNOTSUPP;
2326				break;
2327			}
2328			cur_len = nr_pages * PAGE_SIZE;
2329			tailsz = PAGE_SIZE;
2330		} else {
2331			nr_pages = DIV_ROUND_UP(rest_len, PAGE_SIZE);
2332			cur_len = rest_len;
2333			tailsz = rest_len - (nr_pages - 1) * PAGE_SIZE;
2334		}
2335
2336		wdata2 = cifs_writedata_alloc(nr_pages, cifs_writev_complete);
2337		if (!wdata2) {
2338			rc = -ENOMEM;
2339			break;
2340		}
2341
2342		for (j = 0; j < nr_pages; j++) {
2343			wdata2->pages[j] = wdata->pages[i + j];
2344			lock_page(wdata2->pages[j]);
2345			clear_page_dirty_for_io(wdata2->pages[j]);
2346		}
2347
2348		wdata2->sync_mode = wdata->sync_mode;
2349		wdata2->nr_pages = nr_pages;
2350		wdata2->offset = page_offset(wdata2->pages[0]);
2351		wdata2->pagesz = PAGE_SIZE;
2352		wdata2->tailsz = tailsz;
2353		wdata2->bytes = cur_len;
2354
2355		rc = cifs_get_writable_file(CIFS_I(inode), FIND_WR_ANY,
2356					    &wdata2->cfile);
2357		if (!wdata2->cfile) {
2358			cifs_dbg(VFS, "No writable handle to retry writepages rc=%d\n",
2359				 rc);
2360			if (!is_retryable_error(rc))
2361				rc = -EBADF;
2362		} else {
2363			wdata2->pid = wdata2->cfile->pid;
2364			rc = server->ops->async_writev(wdata2,
2365						       cifs_writedata_release);
2366		}
2367
2368		for (j = 0; j < nr_pages; j++) {
2369			unlock_page(wdata2->pages[j]);
2370			if (rc != 0 && !is_retryable_error(rc)) {
2371				SetPageError(wdata2->pages[j]);
2372				end_page_writeback(wdata2->pages[j]);
2373				put_page(wdata2->pages[j]);
2374			}
2375		}
2376
2377		kref_put(&wdata2->refcount, cifs_writedata_release);
2378		if (rc) {
2379			if (is_retryable_error(rc))
2380				continue;
2381			i += nr_pages;
2382			break;
2383		}
2384
2385		rest_len -= cur_len;
2386		i += nr_pages;
2387	} while (i < wdata->nr_pages);
2388
2389	/* cleanup remaining pages from the original wdata */
2390	for (; i < wdata->nr_pages; i++) {
2391		SetPageError(wdata->pages[i]);
2392		end_page_writeback(wdata->pages[i]);
2393		put_page(wdata->pages[i]);
2394	}
2395
2396	if (rc != 0 && !is_retryable_error(rc))
2397		mapping_set_error(inode->i_mapping, rc);
2398	kref_put(&wdata->refcount, cifs_writedata_release);
2399}
2400
2401void
2402cifs_writev_complete(struct work_struct *work)
2403{
2404	struct cifs_writedata *wdata = container_of(work,
2405						struct cifs_writedata, work);
2406	struct inode *inode = d_inode(wdata->cfile->dentry);
2407	int i = 0;
2408
2409	if (wdata->result == 0) {
2410		spin_lock(&inode->i_lock);
2411		cifs_update_eof(CIFS_I(inode), wdata->offset, wdata->bytes);
2412		spin_unlock(&inode->i_lock);
2413		cifs_stats_bytes_written(tlink_tcon(wdata->cfile->tlink),
2414					 wdata->bytes);
2415	} else if (wdata->sync_mode == WB_SYNC_ALL && wdata->result == -EAGAIN)
2416		return cifs_writev_requeue(wdata);
2417
2418	for (i = 0; i < wdata->nr_pages; i++) {
2419		struct page *page = wdata->pages[i];
2420
2421		if (wdata->result == -EAGAIN)
2422			__set_page_dirty_nobuffers(page);
2423		else if (wdata->result < 0)
2424			SetPageError(page);
2425		end_page_writeback(page);
2426		cifs_readpage_to_fscache(inode, page);
2427		put_page(page);
2428	}
2429	if (wdata->result != -EAGAIN)
2430		mapping_set_error(inode->i_mapping, wdata->result);
2431	kref_put(&wdata->refcount, cifs_writedata_release);
2432}
2433
2434struct cifs_writedata *
2435cifs_writedata_alloc(unsigned int nr_pages, work_func_t complete)
2436{
2437	struct cifs_writedata *writedata = NULL;
2438	struct page **pages =
2439		kcalloc(nr_pages, sizeof(struct page *), GFP_NOFS);
2440	if (pages) {
2441		writedata = cifs_writedata_direct_alloc(pages, complete);
2442		if (!writedata)
2443			kvfree(pages);
2444	}
2445
2446	return writedata;
2447}
2448
2449struct cifs_writedata *
2450cifs_writedata_direct_alloc(struct page **pages, work_func_t complete)
2451{
2452	struct cifs_writedata *wdata;
2453
2454	wdata = kzalloc(sizeof(*wdata), GFP_NOFS);
2455	if (wdata != NULL) {
2456		wdata->pages = pages;
2457		kref_init(&wdata->refcount);
2458		INIT_LIST_HEAD(&wdata->list);
2459		init_completion(&wdata->done);
2460		INIT_WORK(&wdata->work, complete);
2461	}
2462	return wdata;
2463}
2464
2465
2466static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
2467{
2468	struct address_space *mapping = page->mapping;
2469	loff_t offset = (loff_t)page->index << PAGE_SHIFT;
2470	char *write_data;
2471	int rc = -EFAULT;
2472	int bytes_written = 0;
2473	struct inode *inode;
2474	struct cifsFileInfo *open_file;
2475
2476	if (!mapping || !mapping->host)
2477		return -EFAULT;
2478
2479	inode = page->mapping->host;
2480
2481	offset += (loff_t)from;
2482	write_data = kmap(page);
2483	write_data += from;
2484
2485	if ((to > PAGE_SIZE) || (from > to)) {
2486		kunmap(page);
2487		return -EIO;
2488	}
2489
2490	/* racing with truncate? */
2491	if (offset > mapping->host->i_size) {
2492		kunmap(page);
2493		return 0; /* don't care */
2494	}
2495
2496	/* check to make sure that we are not extending the file */
2497	if (mapping->host->i_size - offset < (loff_t)to)
2498		to = (unsigned)(mapping->host->i_size - offset);
2499
2500	rc = cifs_get_writable_file(CIFS_I(mapping->host), FIND_WR_ANY,
2501				    &open_file);
2502	if (!rc) {
2503		bytes_written = cifs_write(open_file, open_file->pid,
2504					   write_data, to - from, &offset);
2505		cifsFileInfo_put(open_file);
2506		/* Does mm or vfs already set times? */
2507		inode->i_atime = inode->i_mtime = current_time(inode);
2508		if ((bytes_written > 0) && (offset))
2509			rc = 0;
2510		else if (bytes_written < 0)
2511			rc = bytes_written;
2512		else
2513			rc = -EFAULT;
2514	} else {
2515		cifs_dbg(FYI, "No writable handle for write page rc=%d\n", rc);
2516		if (!is_retryable_error(rc))
2517			rc = -EIO;
2518	}
2519
2520	kunmap(page);
2521	return rc;
2522}
2523
2524static struct cifs_writedata *
2525wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
2526			  pgoff_t end, pgoff_t *index,
2527			  unsigned int *found_pages)
2528{
2529	struct cifs_writedata *wdata;
2530
2531	wdata = cifs_writedata_alloc((unsigned int)tofind,
2532				     cifs_writev_complete);
2533	if (!wdata)
2534		return NULL;
2535
2536	*found_pages = find_get_pages_range_tag(mapping, index, end,
2537				PAGECACHE_TAG_DIRTY, tofind, wdata->pages);
2538	return wdata;
2539}
2540
2541static unsigned int
2542wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
2543		    struct address_space *mapping,
2544		    struct writeback_control *wbc,
2545		    pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
2546{
2547	unsigned int nr_pages = 0, i;
2548	struct page *page;
2549
2550	for (i = 0; i < found_pages; i++) {
2551		page = wdata->pages[i];
2552		/*
2553		 * At this point we hold neither the i_pages lock nor the
2554		 * page lock: the page may be truncated or invalidated
2555		 * (changing page->mapping to NULL), or even swizzled
2556		 * back from swapper_space to tmpfs file mapping
2557		 */
2558
2559		if (nr_pages == 0)
2560			lock_page(page);
2561		else if (!trylock_page(page))
2562			break;
2563
2564		if (unlikely(page->mapping != mapping)) {
2565			unlock_page(page);
2566			break;
2567		}
2568
2569		if (!wbc->range_cyclic && page->index > end) {
2570			*done = true;
2571			unlock_page(page);
2572			break;
2573		}
2574
2575		if (*next && (page->index != *next)) {
2576			/* Not next consecutive page */
2577			unlock_page(page);
2578			break;
2579		}
2580
2581		if (wbc->sync_mode != WB_SYNC_NONE)
2582			wait_on_page_writeback(page);
2583
2584		if (PageWriteback(page) ||
2585				!clear_page_dirty_for_io(page)) {
2586			unlock_page(page);
2587			break;
2588		}
2589
2590		/*
2591		 * This actually clears the dirty bit in the radix tree.
2592		 * See cifs_writepage() for more commentary.
2593		 */
2594		set_page_writeback(page);
2595		if (page_offset(page) >= i_size_read(mapping->host)) {
2596			*done = true;
2597			unlock_page(page);
2598			end_page_writeback(page);
2599			break;
2600		}
2601
2602		wdata->pages[i] = page;
2603		*next = page->index + 1;
2604		++nr_pages;
2605	}
2606
2607	/* reset index to refind any pages skipped */
2608	if (nr_pages == 0)
2609		*index = wdata->pages[0]->index + 1;
2610
2611	/* put any pages we aren't going to use */
2612	for (i = nr_pages; i < found_pages; i++) {
2613		put_page(wdata->pages[i]);
2614		wdata->pages[i] = NULL;
2615	}
2616
2617	return nr_pages;
2618}
2619
2620static int
2621wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
2622		 struct address_space *mapping, struct writeback_control *wbc)
2623{
2624	int rc;
 
 
2625
2626	wdata->sync_mode = wbc->sync_mode;
2627	wdata->nr_pages = nr_pages;
2628	wdata->offset = page_offset(wdata->pages[0]);
2629	wdata->pagesz = PAGE_SIZE;
2630	wdata->tailsz = min(i_size_read(mapping->host) -
2631			page_offset(wdata->pages[nr_pages - 1]),
2632			(loff_t)PAGE_SIZE);
2633	wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2634	wdata->pid = wdata->cfile->pid;
2635
2636	rc = adjust_credits(wdata->server, &wdata->credits, wdata->bytes);
2637	if (rc)
2638		return rc;
2639
2640	if (wdata->cfile->invalidHandle)
2641		rc = -EAGAIN;
2642	else
2643		rc = wdata->server->ops->async_writev(wdata,
2644						      cifs_writedata_release);
2645
2646	return rc;
2647}
2648
2649static int
2650cifs_writepage_locked(struct page *page, struct writeback_control *wbc);
2651
2652static int cifs_write_one_page(struct page *page, struct writeback_control *wbc,
2653		void *data)
2654{
2655	struct address_space *mapping = data;
2656	int ret;
2657
2658	ret = cifs_writepage_locked(page, wbc);
2659	unlock_page(page);
2660	mapping_set_error(mapping, ret);
2661	return ret;
2662}
2663
2664static int cifs_writepages(struct address_space *mapping,
2665			   struct writeback_control *wbc)
2666{
2667	struct inode *inode = mapping->host;
2668	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2669	struct TCP_Server_Info *server;
2670	bool done = false, scanned = false, range_whole = false;
2671	pgoff_t end, index;
2672	struct cifs_writedata *wdata;
2673	struct cifsFileInfo *cfile = NULL;
2674	int rc = 0;
2675	int saved_rc = 0;
2676	unsigned int xid;
2677
2678	/*
2679	 * If wsize is smaller than the page cache size, default to writing
2680	 * one page at a time.
2681	 */
2682	if (cifs_sb->ctx->wsize < PAGE_SIZE)
2683		return write_cache_pages(mapping, wbc, cifs_write_one_page,
2684				mapping);
2685
2686	xid = get_xid();
2687	if (wbc->range_cyclic) {
2688		index = mapping->writeback_index; /* Start from prev offset */
2689		end = -1;
2690	} else {
2691		index = wbc->range_start >> PAGE_SHIFT;
2692		end = wbc->range_end >> PAGE_SHIFT;
2693		if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2694			range_whole = true;
2695		scanned = true;
2696	}
2697	server = cifs_pick_channel(cifs_sb_master_tcon(cifs_sb)->ses);
2698
2699retry:
2700	while (!done && index <= end) {
2701		unsigned int i, nr_pages, found_pages, wsize;
2702		pgoff_t next = 0, tofind, saved_index = index;
2703		struct cifs_credits credits_on_stack;
2704		struct cifs_credits *credits = &credits_on_stack;
2705		int get_file_rc = 0;
2706
2707		if (cfile)
2708			cifsFileInfo_put(cfile);
2709
2710		rc = cifs_get_writable_file(CIFS_I(inode), FIND_WR_ANY, &cfile);
2711
2712		/* in case of an error store it to return later */
2713		if (rc)
2714			get_file_rc = rc;
2715
2716		rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->wsize,
2717						   &wsize, credits);
2718		if (rc != 0) {
2719			done = true;
2720			break;
2721		}
2722
2723		tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2724
2725		wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
2726						  &found_pages);
2727		if (!wdata) {
2728			rc = -ENOMEM;
2729			done = true;
2730			add_credits_and_wake_if(server, credits, 0);
2731			break;
2732		}
2733
2734		if (found_pages == 0) {
2735			kref_put(&wdata->refcount, cifs_writedata_release);
2736			add_credits_and_wake_if(server, credits, 0);
2737			break;
2738		}
2739
2740		nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
2741					       end, &index, &next, &done);
2742
2743		/* nothing to write? */
2744		if (nr_pages == 0) {
2745			kref_put(&wdata->refcount, cifs_writedata_release);
2746			add_credits_and_wake_if(server, credits, 0);
2747			continue;
2748		}
2749
2750		wdata->credits = credits_on_stack;
2751		wdata->cfile = cfile;
2752		wdata->server = server;
2753		cfile = NULL;
2754
2755		if (!wdata->cfile) {
2756			cifs_dbg(VFS, "No writable handle in writepages rc=%d\n",
2757				 get_file_rc);
2758			if (is_retryable_error(get_file_rc))
2759				rc = get_file_rc;
2760			else
2761				rc = -EBADF;
2762		} else
2763			rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2764
2765		for (i = 0; i < nr_pages; ++i)
2766			unlock_page(wdata->pages[i]);
2767
2768		/* send failure -- clean up the mess */
2769		if (rc != 0) {
2770			add_credits_and_wake_if(server, &wdata->credits, 0);
2771			for (i = 0; i < nr_pages; ++i) {
2772				if (is_retryable_error(rc))
2773					redirty_page_for_writepage(wbc,
2774							   wdata->pages[i]);
2775				else
2776					SetPageError(wdata->pages[i]);
2777				end_page_writeback(wdata->pages[i]);
2778				put_page(wdata->pages[i]);
2779			}
2780			if (!is_retryable_error(rc))
2781				mapping_set_error(mapping, rc);
2782		}
2783		kref_put(&wdata->refcount, cifs_writedata_release);
2784
2785		if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
2786			index = saved_index;
2787			continue;
2788		}
2789
2790		/* Return immediately if we received a signal during writing */
2791		if (is_interrupt_error(rc)) {
2792			done = true;
2793			break;
2794		}
2795
2796		if (rc != 0 && saved_rc == 0)
2797			saved_rc = rc;
2798
2799		wbc->nr_to_write -= nr_pages;
2800		if (wbc->nr_to_write <= 0)
2801			done = true;
2802
2803		index = next;
2804	}
2805
2806	if (!scanned && !done) {
2807		/*
2808		 * We hit the last page and there is more work to be done: wrap
2809		 * back to the start of the file
2810		 */
2811		scanned = true;
2812		index = 0;
2813		goto retry;
2814	}
2815
2816	if (saved_rc != 0)
2817		rc = saved_rc;
2818
2819	if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2820		mapping->writeback_index = index;
2821
2822	if (cfile)
2823		cifsFileInfo_put(cfile);
2824	free_xid(xid);
2825	/* Indication to update ctime and mtime as close is deferred */
2826	set_bit(CIFS_INO_MODIFIED_ATTR, &CIFS_I(inode)->flags);
2827	return rc;
2828}
2829
2830static int
2831cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2832{
2833	int rc;
2834	unsigned int xid;
2835
2836	xid = get_xid();
2837/* BB add check for wbc flags */
2838	get_page(page);
2839	if (!PageUptodate(page))
2840		cifs_dbg(FYI, "ppw - page not up to date\n");
2841
2842	/*
2843	 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2844	 *
2845	 * A writepage() implementation always needs to do either this,
2846	 * or re-dirty the page with "redirty_page_for_writepage()" in
2847	 * the case of a failure.
2848	 *
2849	 * Just unlocking the page will cause the radix tree tag-bits
2850	 * to fail to update with the state of the page correctly.
2851	 */
2852	set_page_writeback(page);
2853retry_write:
2854	rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2855	if (is_retryable_error(rc)) {
2856		if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN)
2857			goto retry_write;
2858		redirty_page_for_writepage(wbc, page);
2859	} else if (rc != 0) {
2860		SetPageError(page);
2861		mapping_set_error(page->mapping, rc);
2862	} else {
2863		SetPageUptodate(page);
2864	}
2865	end_page_writeback(page);
2866	put_page(page);
2867	free_xid(xid);
2868	return rc;
2869}
2870
 
 
 
 
 
 
 
2871static int cifs_write_end(struct file *file, struct address_space *mapping,
2872			loff_t pos, unsigned len, unsigned copied,
2873			struct page *page, void *fsdata)
2874{
2875	int rc;
2876	struct inode *inode = mapping->host;
2877	struct cifsFileInfo *cfile = file->private_data;
2878	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2879	__u32 pid;
2880
2881	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2882		pid = cfile->pid;
2883	else
2884		pid = current->tgid;
2885
2886	cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2887		 page, pos, copied);
2888
2889	if (PageChecked(page)) {
2890		if (copied == len)
2891			SetPageUptodate(page);
2892		ClearPageChecked(page);
2893	} else if (!PageUptodate(page) && copied == PAGE_SIZE)
2894		SetPageUptodate(page);
2895
2896	if (!PageUptodate(page)) {
2897		char *page_data;
2898		unsigned offset = pos & (PAGE_SIZE - 1);
2899		unsigned int xid;
2900
2901		xid = get_xid();
2902		/* this is probably better than directly calling
2903		   partialpage_write since in this function the file handle is
2904		   known which we might as well	leverage */
2905		/* BB check if anything else missing out of ppw
2906		   such as updating last write time */
2907		page_data = kmap(page);
2908		rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2909		/* if (rc < 0) should we set writebehind rc? */
2910		kunmap(page);
2911
2912		free_xid(xid);
2913	} else {
2914		rc = copied;
2915		pos += copied;
2916		set_page_dirty(page);
2917	}
2918
2919	if (rc > 0) {
2920		spin_lock(&inode->i_lock);
2921		if (pos > inode->i_size) {
2922			i_size_write(inode, pos);
2923			inode->i_blocks = (512 - 1 + pos) >> 9;
2924		}
2925		spin_unlock(&inode->i_lock);
2926	}
2927
2928	unlock_page(page);
2929	put_page(page);
2930	/* Indication to update ctime and mtime as close is deferred */
2931	set_bit(CIFS_INO_MODIFIED_ATTR, &CIFS_I(inode)->flags);
2932
2933	return rc;
2934}
2935
2936int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2937		      int datasync)
2938{
2939	unsigned int xid;
2940	int rc = 0;
2941	struct cifs_tcon *tcon;
2942	struct TCP_Server_Info *server;
2943	struct cifsFileInfo *smbfile = file->private_data;
2944	struct inode *inode = file_inode(file);
2945	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2946
2947	rc = file_write_and_wait_range(file, start, end);
2948	if (rc) {
2949		trace_cifs_fsync_err(inode->i_ino, rc);
2950		return rc;
2951	}
2952
2953	xid = get_xid();
2954
2955	cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2956		 file, datasync);
2957
2958	if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2959		rc = cifs_zap_mapping(inode);
2960		if (rc) {
2961			cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2962			rc = 0; /* don't care about it in fsync */
2963		}
2964	}
2965
2966	tcon = tlink_tcon(smbfile->tlink);
2967	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2968		server = tcon->ses->server;
2969		if (server->ops->flush == NULL) {
2970			rc = -ENOSYS;
2971			goto strict_fsync_exit;
2972		}
2973
2974		if ((OPEN_FMODE(smbfile->f_flags) & FMODE_WRITE) == 0) {
2975			smbfile = find_writable_file(CIFS_I(inode), FIND_WR_ANY);
2976			if (smbfile) {
2977				rc = server->ops->flush(xid, tcon, &smbfile->fid);
2978				cifsFileInfo_put(smbfile);
2979			} else
2980				cifs_dbg(FYI, "ignore fsync for file not open for write\n");
2981		} else
2982			rc = server->ops->flush(xid, tcon, &smbfile->fid);
 
 
2983	}
2984
2985strict_fsync_exit:
2986	free_xid(xid);
2987	return rc;
2988}
2989
2990int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2991{
2992	unsigned int xid;
2993	int rc = 0;
2994	struct cifs_tcon *tcon;
2995	struct TCP_Server_Info *server;
2996	struct cifsFileInfo *smbfile = file->private_data;
2997	struct inode *inode = file_inode(file);
2998	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2999
3000	rc = file_write_and_wait_range(file, start, end);
3001	if (rc) {
3002		trace_cifs_fsync_err(file_inode(file)->i_ino, rc);
3003		return rc;
3004	}
3005
3006	xid = get_xid();
3007
3008	cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
3009		 file, datasync);
3010
3011	tcon = tlink_tcon(smbfile->tlink);
3012	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
3013		server = tcon->ses->server;
3014		if (server->ops->flush == NULL) {
3015			rc = -ENOSYS;
3016			goto fsync_exit;
3017		}
3018
3019		if ((OPEN_FMODE(smbfile->f_flags) & FMODE_WRITE) == 0) {
3020			smbfile = find_writable_file(CIFS_I(inode), FIND_WR_ANY);
3021			if (smbfile) {
3022				rc = server->ops->flush(xid, tcon, &smbfile->fid);
3023				cifsFileInfo_put(smbfile);
3024			} else
3025				cifs_dbg(FYI, "ignore fsync for file not open for write\n");
3026		} else
3027			rc = server->ops->flush(xid, tcon, &smbfile->fid);
 
 
3028	}
3029
3030fsync_exit:
3031	free_xid(xid);
3032	return rc;
3033}
3034
3035/*
3036 * As file closes, flush all cached write data for this inode checking
3037 * for write behind errors.
3038 */
3039int cifs_flush(struct file *file, fl_owner_t id)
3040{
3041	struct inode *inode = file_inode(file);
3042	int rc = 0;
3043
3044	if (file->f_mode & FMODE_WRITE)
3045		rc = filemap_write_and_wait(inode->i_mapping);
3046
3047	cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
3048	if (rc) {
3049		/* get more nuanced writeback errors */
3050		rc = filemap_check_wb_err(file->f_mapping, 0);
3051		trace_cifs_flush_err(inode->i_ino, rc);
3052	}
3053	return rc;
3054}
3055
3056static int
3057cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
3058{
3059	int rc = 0;
3060	unsigned long i;
3061
3062	for (i = 0; i < num_pages; i++) {
3063		pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
3064		if (!pages[i]) {
3065			/*
3066			 * save number of pages we have already allocated and
3067			 * return with ENOMEM error
3068			 */
3069			num_pages = i;
3070			rc = -ENOMEM;
3071			break;
3072		}
3073	}
3074
3075	if (rc) {
3076		for (i = 0; i < num_pages; i++)
3077			put_page(pages[i]);
3078	}
3079	return rc;
3080}
3081
3082static inline
3083size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
3084{
3085	size_t num_pages;
3086	size_t clen;
3087
3088	clen = min_t(const size_t, len, wsize);
3089	num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
3090
3091	if (cur_len)
3092		*cur_len = clen;
3093
3094	return num_pages;
3095}
3096
3097static void
3098cifs_uncached_writedata_release(struct kref *refcount)
3099{
3100	int i;
3101	struct cifs_writedata *wdata = container_of(refcount,
3102					struct cifs_writedata, refcount);
3103
3104	kref_put(&wdata->ctx->refcount, cifs_aio_ctx_release);
3105	for (i = 0; i < wdata->nr_pages; i++)
3106		put_page(wdata->pages[i]);
3107	cifs_writedata_release(refcount);
3108}
3109
3110static void collect_uncached_write_data(struct cifs_aio_ctx *ctx);
3111
3112static void
3113cifs_uncached_writev_complete(struct work_struct *work)
3114{
3115	struct cifs_writedata *wdata = container_of(work,
3116					struct cifs_writedata, work);
3117	struct inode *inode = d_inode(wdata->cfile->dentry);
3118	struct cifsInodeInfo *cifsi = CIFS_I(inode);
3119
3120	spin_lock(&inode->i_lock);
3121	cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
3122	if (cifsi->server_eof > inode->i_size)
3123		i_size_write(inode, cifsi->server_eof);
3124	spin_unlock(&inode->i_lock);
3125
3126	complete(&wdata->done);
3127	collect_uncached_write_data(wdata->ctx);
3128	/* the below call can possibly free the last ref to aio ctx */
3129	kref_put(&wdata->refcount, cifs_uncached_writedata_release);
3130}
3131
3132static int
3133wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
3134		      size_t *len, unsigned long *num_pages)
3135{
3136	size_t save_len, copied, bytes, cur_len = *len;
3137	unsigned long i, nr_pages = *num_pages;
3138
3139	save_len = cur_len;
3140	for (i = 0; i < nr_pages; i++) {
3141		bytes = min_t(const size_t, cur_len, PAGE_SIZE);
3142		copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
3143		cur_len -= copied;
3144		/*
3145		 * If we didn't copy as much as we expected, then that
3146		 * may mean we trod into an unmapped area. Stop copying
3147		 * at that point. On the next pass through the big
3148		 * loop, we'll likely end up getting a zero-length
3149		 * write and bailing out of it.
3150		 */
3151		if (copied < bytes)
3152			break;
3153	}
3154	cur_len = save_len - cur_len;
3155	*len = cur_len;
3156
3157	/*
3158	 * If we have no data to send, then that probably means that
3159	 * the copy above failed altogether. That's most likely because
3160	 * the address in the iovec was bogus. Return -EFAULT and let
3161	 * the caller free anything we allocated and bail out.
3162	 */
3163	if (!cur_len)
3164		return -EFAULT;
3165
3166	/*
3167	 * i + 1 now represents the number of pages we actually used in
3168	 * the copy phase above.
3169	 */
3170	*num_pages = i + 1;
3171	return 0;
3172}
3173
3174static int
3175cifs_resend_wdata(struct cifs_writedata *wdata, struct list_head *wdata_list,
3176	struct cifs_aio_ctx *ctx)
3177{
3178	unsigned int wsize;
3179	struct cifs_credits credits;
3180	int rc;
3181	struct TCP_Server_Info *server = wdata->server;
 
3182
3183	do {
3184		if (wdata->cfile->invalidHandle) {
3185			rc = cifs_reopen_file(wdata->cfile, false);
3186			if (rc == -EAGAIN)
3187				continue;
3188			else if (rc)
3189				break;
3190		}
3191
3192
3193		/*
3194		 * Wait for credits to resend this wdata.
3195		 * Note: we are attempting to resend the whole wdata not in
3196		 * segments
3197		 */
3198		do {
3199			rc = server->ops->wait_mtu_credits(server, wdata->bytes,
3200						&wsize, &credits);
3201			if (rc)
3202				goto fail;
3203
3204			if (wsize < wdata->bytes) {
3205				add_credits_and_wake_if(server, &credits, 0);
3206				msleep(1000);
3207			}
3208		} while (wsize < wdata->bytes);
3209		wdata->credits = credits;
3210
3211		rc = adjust_credits(server, &wdata->credits, wdata->bytes);
3212
3213		if (!rc) {
3214			if (wdata->cfile->invalidHandle)
3215				rc = -EAGAIN;
3216			else {
3217#ifdef CONFIG_CIFS_SMB_DIRECT
3218				if (wdata->mr) {
3219					wdata->mr->need_invalidate = true;
3220					smbd_deregister_mr(wdata->mr);
3221					wdata->mr = NULL;
3222				}
3223#endif
3224				rc = server->ops->async_writev(wdata,
3225					cifs_uncached_writedata_release);
3226			}
3227		}
3228
3229		/* If the write was successfully sent, we are done */
3230		if (!rc) {
3231			list_add_tail(&wdata->list, wdata_list);
3232			return 0;
3233		}
3234
3235		/* Roll back credits and retry if needed */
3236		add_credits_and_wake_if(server, &wdata->credits, 0);
3237	} while (rc == -EAGAIN);
3238
3239fail:
3240	kref_put(&wdata->refcount, cifs_uncached_writedata_release);
3241	return rc;
3242}
3243
3244static int
3245cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
3246		     struct cifsFileInfo *open_file,
3247		     struct cifs_sb_info *cifs_sb, struct list_head *wdata_list,
3248		     struct cifs_aio_ctx *ctx)
3249{
3250	int rc = 0;
3251	size_t cur_len;
3252	unsigned long nr_pages, num_pages, i;
3253	struct cifs_writedata *wdata;
3254	struct iov_iter saved_from = *from;
3255	loff_t saved_offset = offset;
3256	pid_t pid;
3257	struct TCP_Server_Info *server;
3258	struct page **pagevec;
3259	size_t start;
3260	unsigned int xid;
3261
3262	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3263		pid = open_file->pid;
3264	else
3265		pid = current->tgid;
3266
3267	server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);
3268	xid = get_xid();
3269
3270	do {
3271		unsigned int wsize;
3272		struct cifs_credits credits_on_stack;
3273		struct cifs_credits *credits = &credits_on_stack;
3274
3275		if (open_file->invalidHandle) {
3276			rc = cifs_reopen_file(open_file, false);
3277			if (rc == -EAGAIN)
3278				continue;
3279			else if (rc)
3280				break;
3281		}
3282
3283		rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->wsize,
3284						   &wsize, credits);
3285		if (rc)
3286			break;
3287
3288		cur_len = min_t(const size_t, len, wsize);
3289
3290		if (ctx->direct_io) {
3291			ssize_t result;
3292
3293			result = iov_iter_get_pages_alloc2(
3294				from, &pagevec, cur_len, &start);
3295			if (result < 0) {
3296				cifs_dbg(VFS,
3297					 "direct_writev couldn't get user pages (rc=%zd) iter type %d iov_offset %zd count %zd\n",
3298					 result, iov_iter_type(from),
3299					 from->iov_offset, from->count);
 
 
3300				dump_stack();
3301
3302				rc = result;
3303				add_credits_and_wake_if(server, credits, 0);
3304				break;
3305			}
3306			cur_len = (size_t)result;
 
3307
3308			nr_pages =
3309				(cur_len + start + PAGE_SIZE - 1) / PAGE_SIZE;
3310
3311			wdata = cifs_writedata_direct_alloc(pagevec,
3312					     cifs_uncached_writev_complete);
3313			if (!wdata) {
3314				rc = -ENOMEM;
3315				for (i = 0; i < nr_pages; i++)
3316					put_page(pagevec[i]);
3317				kvfree(pagevec);
3318				add_credits_and_wake_if(server, credits, 0);
3319				break;
3320			}
3321
3322
3323			wdata->page_offset = start;
3324			wdata->tailsz =
3325				nr_pages > 1 ?
3326					cur_len - (PAGE_SIZE - start) -
3327					(nr_pages - 2) * PAGE_SIZE :
3328					cur_len;
3329		} else {
3330			nr_pages = get_numpages(wsize, len, &cur_len);
3331			wdata = cifs_writedata_alloc(nr_pages,
3332					     cifs_uncached_writev_complete);
3333			if (!wdata) {
3334				rc = -ENOMEM;
3335				add_credits_and_wake_if(server, credits, 0);
3336				break;
3337			}
3338
3339			rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
3340			if (rc) {
3341				kvfree(wdata->pages);
3342				kfree(wdata);
3343				add_credits_and_wake_if(server, credits, 0);
3344				break;
3345			}
3346
3347			num_pages = nr_pages;
3348			rc = wdata_fill_from_iovec(
3349				wdata, from, &cur_len, &num_pages);
3350			if (rc) {
3351				for (i = 0; i < nr_pages; i++)
3352					put_page(wdata->pages[i]);
3353				kvfree(wdata->pages);
3354				kfree(wdata);
3355				add_credits_and_wake_if(server, credits, 0);
3356				break;
3357			}
3358
3359			/*
3360			 * Bring nr_pages down to the number of pages we
3361			 * actually used, and free any pages that we didn't use.
3362			 */
3363			for ( ; nr_pages > num_pages; nr_pages--)
3364				put_page(wdata->pages[nr_pages - 1]);
3365
3366			wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
3367		}
3368
3369		wdata->sync_mode = WB_SYNC_ALL;
3370		wdata->nr_pages = nr_pages;
3371		wdata->offset = (__u64)offset;
3372		wdata->cfile = cifsFileInfo_get(open_file);
3373		wdata->server = server;
3374		wdata->pid = pid;
3375		wdata->bytes = cur_len;
3376		wdata->pagesz = PAGE_SIZE;
3377		wdata->credits = credits_on_stack;
3378		wdata->ctx = ctx;
3379		kref_get(&ctx->refcount);
3380
3381		rc = adjust_credits(server, &wdata->credits, wdata->bytes);
3382
3383		if (!rc) {
3384			if (wdata->cfile->invalidHandle)
3385				rc = -EAGAIN;
3386			else
3387				rc = server->ops->async_writev(wdata,
3388					cifs_uncached_writedata_release);
3389		}
3390
3391		if (rc) {
3392			add_credits_and_wake_if(server, &wdata->credits, 0);
3393			kref_put(&wdata->refcount,
3394				 cifs_uncached_writedata_release);
3395			if (rc == -EAGAIN) {
3396				*from = saved_from;
3397				iov_iter_advance(from, offset - saved_offset);
3398				continue;
3399			}
3400			break;
3401		}
3402
3403		list_add_tail(&wdata->list, wdata_list);
3404		offset += cur_len;
3405		len -= cur_len;
3406	} while (len > 0);
3407
3408	free_xid(xid);
3409	return rc;
3410}
3411
3412static void collect_uncached_write_data(struct cifs_aio_ctx *ctx)
3413{
3414	struct cifs_writedata *wdata, *tmp;
3415	struct cifs_tcon *tcon;
3416	struct cifs_sb_info *cifs_sb;
3417	struct dentry *dentry = ctx->cfile->dentry;
3418	ssize_t rc;
3419
3420	tcon = tlink_tcon(ctx->cfile->tlink);
3421	cifs_sb = CIFS_SB(dentry->d_sb);
3422
3423	mutex_lock(&ctx->aio_mutex);
3424
3425	if (list_empty(&ctx->list)) {
3426		mutex_unlock(&ctx->aio_mutex);
3427		return;
3428	}
3429
3430	rc = ctx->rc;
3431	/*
3432	 * Wait for and collect replies for any successful sends in order of
3433	 * increasing offset. Once an error is hit, then return without waiting
3434	 * for any more replies.
3435	 */
3436restart_loop:
3437	list_for_each_entry_safe(wdata, tmp, &ctx->list, list) {
3438		if (!rc) {
3439			if (!try_wait_for_completion(&wdata->done)) {
3440				mutex_unlock(&ctx->aio_mutex);
3441				return;
3442			}
3443
3444			if (wdata->result)
3445				rc = wdata->result;
3446			else
3447				ctx->total_len += wdata->bytes;
3448
3449			/* resend call if it's a retryable error */
3450			if (rc == -EAGAIN) {
3451				struct list_head tmp_list;
3452				struct iov_iter tmp_from = ctx->iter;
3453
3454				INIT_LIST_HEAD(&tmp_list);
3455				list_del_init(&wdata->list);
3456
3457				if (ctx->direct_io)
3458					rc = cifs_resend_wdata(
3459						wdata, &tmp_list, ctx);
3460				else {
3461					iov_iter_advance(&tmp_from,
3462						 wdata->offset - ctx->pos);
3463
3464					rc = cifs_write_from_iter(wdata->offset,
3465						wdata->bytes, &tmp_from,
3466						ctx->cfile, cifs_sb, &tmp_list,
3467						ctx);
3468
3469					kref_put(&wdata->refcount,
3470						cifs_uncached_writedata_release);
3471				}
3472
3473				list_splice(&tmp_list, &ctx->list);
3474				goto restart_loop;
3475			}
3476		}
3477		list_del_init(&wdata->list);
3478		kref_put(&wdata->refcount, cifs_uncached_writedata_release);
3479	}
3480
3481	cifs_stats_bytes_written(tcon, ctx->total_len);
3482	set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(dentry->d_inode)->flags);
3483
3484	ctx->rc = (rc == 0) ? ctx->total_len : rc;
3485
3486	mutex_unlock(&ctx->aio_mutex);
3487
3488	if (ctx->iocb && ctx->iocb->ki_complete)
3489		ctx->iocb->ki_complete(ctx->iocb, ctx->rc);
3490	else
3491		complete(&ctx->done);
3492}
3493
3494static ssize_t __cifs_writev(
3495	struct kiocb *iocb, struct iov_iter *from, bool direct)
3496{
3497	struct file *file = iocb->ki_filp;
3498	ssize_t total_written = 0;
3499	struct cifsFileInfo *cfile;
3500	struct cifs_tcon *tcon;
3501	struct cifs_sb_info *cifs_sb;
3502	struct cifs_aio_ctx *ctx;
3503	struct iov_iter saved_from = *from;
3504	size_t len = iov_iter_count(from);
3505	int rc;
3506
3507	/*
3508	 * iov_iter_get_pages_alloc doesn't work with ITER_KVEC.
3509	 * In this case, fall back to non-direct write function.
3510	 * this could be improved by getting pages directly in ITER_KVEC
3511	 */
3512	if (direct && iov_iter_is_kvec(from)) {
3513		cifs_dbg(FYI, "use non-direct cifs_writev for kvec I/O\n");
3514		direct = false;
3515	}
3516
3517	rc = generic_write_checks(iocb, from);
3518	if (rc <= 0)
3519		return rc;
3520
3521	cifs_sb = CIFS_FILE_SB(file);
3522	cfile = file->private_data;
3523	tcon = tlink_tcon(cfile->tlink);
3524
3525	if (!tcon->ses->server->ops->async_writev)
3526		return -ENOSYS;
3527
3528	ctx = cifs_aio_ctx_alloc();
3529	if (!ctx)
3530		return -ENOMEM;
3531
3532	ctx->cfile = cifsFileInfo_get(cfile);
3533
3534	if (!is_sync_kiocb(iocb))
3535		ctx->iocb = iocb;
3536
3537	ctx->pos = iocb->ki_pos;
3538
3539	if (direct) {
3540		ctx->direct_io = true;
3541		ctx->iter = *from;
3542		ctx->len = len;
3543	} else {
3544		rc = setup_aio_ctx_iter(ctx, from, ITER_SOURCE);
3545		if (rc) {
3546			kref_put(&ctx->refcount, cifs_aio_ctx_release);
3547			return rc;
3548		}
3549	}
3550
3551	/* grab a lock here due to read response handlers can access ctx */
3552	mutex_lock(&ctx->aio_mutex);
3553
3554	rc = cifs_write_from_iter(iocb->ki_pos, ctx->len, &saved_from,
3555				  cfile, cifs_sb, &ctx->list, ctx);
3556
3557	/*
3558	 * If at least one write was successfully sent, then discard any rc
3559	 * value from the later writes. If the other write succeeds, then
3560	 * we'll end up returning whatever was written. If it fails, then
3561	 * we'll get a new rc value from that.
3562	 */
3563	if (!list_empty(&ctx->list))
3564		rc = 0;
3565
3566	mutex_unlock(&ctx->aio_mutex);
3567
3568	if (rc) {
3569		kref_put(&ctx->refcount, cifs_aio_ctx_release);
3570		return rc;
3571	}
3572
3573	if (!is_sync_kiocb(iocb)) {
3574		kref_put(&ctx->refcount, cifs_aio_ctx_release);
3575		return -EIOCBQUEUED;
3576	}
3577
3578	rc = wait_for_completion_killable(&ctx->done);
3579	if (rc) {
3580		mutex_lock(&ctx->aio_mutex);
3581		ctx->rc = rc = -EINTR;
3582		total_written = ctx->total_len;
3583		mutex_unlock(&ctx->aio_mutex);
3584	} else {
3585		rc = ctx->rc;
3586		total_written = ctx->total_len;
3587	}
3588
3589	kref_put(&ctx->refcount, cifs_aio_ctx_release);
3590
3591	if (unlikely(!total_written))
3592		return rc;
3593
3594	iocb->ki_pos += total_written;
3595	return total_written;
3596}
3597
3598ssize_t cifs_direct_writev(struct kiocb *iocb, struct iov_iter *from)
3599{
3600	struct file *file = iocb->ki_filp;
3601
3602	cifs_revalidate_mapping(file->f_inode);
3603	return __cifs_writev(iocb, from, true);
3604}
3605
3606ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
3607{
3608	return __cifs_writev(iocb, from, false);
3609}
3610
3611static ssize_t
3612cifs_writev(struct kiocb *iocb, struct iov_iter *from)
3613{
3614	struct file *file = iocb->ki_filp;
3615	struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
3616	struct inode *inode = file->f_mapping->host;
3617	struct cifsInodeInfo *cinode = CIFS_I(inode);
3618	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
3619	ssize_t rc;
3620
3621	inode_lock(inode);
3622	/*
3623	 * We need to hold the sem to be sure nobody modifies lock list
3624	 * with a brlock that prevents writing.
3625	 */
3626	down_read(&cinode->lock_sem);
3627
3628	rc = generic_write_checks(iocb, from);
3629	if (rc <= 0)
3630		goto out;
3631
3632	if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
3633				     server->vals->exclusive_lock_type, 0,
3634				     NULL, CIFS_WRITE_OP))
3635		rc = __generic_file_write_iter(iocb, from);
3636	else
3637		rc = -EACCES;
3638out:
3639	up_read(&cinode->lock_sem);
3640	inode_unlock(inode);
3641
3642	if (rc > 0)
3643		rc = generic_write_sync(iocb, rc);
3644	return rc;
3645}
3646
3647ssize_t
3648cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
3649{
3650	struct inode *inode = file_inode(iocb->ki_filp);
3651	struct cifsInodeInfo *cinode = CIFS_I(inode);
3652	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3653	struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3654						iocb->ki_filp->private_data;
3655	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3656	ssize_t written;
3657
3658	written = cifs_get_writer(cinode);
3659	if (written)
3660		return written;
3661
3662	if (CIFS_CACHE_WRITE(cinode)) {
3663		if (cap_unix(tcon->ses) &&
3664		(CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
3665		  && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
3666			written = generic_file_write_iter(iocb, from);
3667			goto out;
3668		}
3669		written = cifs_writev(iocb, from);
3670		goto out;
3671	}
3672	/*
3673	 * For non-oplocked files in strict cache mode we need to write the data
3674	 * to the server exactly from the pos to pos+len-1 rather than flush all
3675	 * affected pages because it may cause a error with mandatory locks on
3676	 * these pages but not on the region from pos to ppos+len-1.
3677	 */
3678	written = cifs_user_writev(iocb, from);
3679	if (CIFS_CACHE_READ(cinode)) {
3680		/*
3681		 * We have read level caching and we have just sent a write
3682		 * request to the server thus making data in the cache stale.
3683		 * Zap the cache and set oplock/lease level to NONE to avoid
3684		 * reading stale data from the cache. All subsequent read
3685		 * operations will read new data from the server.
3686		 */
3687		cifs_zap_mapping(inode);
3688		cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
3689			 inode);
3690		cinode->oplock = 0;
3691	}
3692out:
3693	cifs_put_writer(cinode);
3694	return written;
3695}
3696
3697static struct cifs_readdata *
3698cifs_readdata_direct_alloc(struct page **pages, work_func_t complete)
3699{
3700	struct cifs_readdata *rdata;
3701
3702	rdata = kzalloc(sizeof(*rdata), GFP_KERNEL);
3703	if (rdata != NULL) {
3704		rdata->pages = pages;
3705		kref_init(&rdata->refcount);
3706		INIT_LIST_HEAD(&rdata->list);
3707		init_completion(&rdata->done);
3708		INIT_WORK(&rdata->work, complete);
3709	}
3710
3711	return rdata;
3712}
3713
3714static struct cifs_readdata *
3715cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
3716{
3717	struct page **pages =
3718		kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
3719	struct cifs_readdata *ret = NULL;
3720
3721	if (pages) {
3722		ret = cifs_readdata_direct_alloc(pages, complete);
3723		if (!ret)
3724			kfree(pages);
3725	}
3726
3727	return ret;
3728}
3729
3730void
3731cifs_readdata_release(struct kref *refcount)
3732{
3733	struct cifs_readdata *rdata = container_of(refcount,
3734					struct cifs_readdata, refcount);
3735#ifdef CONFIG_CIFS_SMB_DIRECT
3736	if (rdata->mr) {
3737		smbd_deregister_mr(rdata->mr);
3738		rdata->mr = NULL;
3739	}
3740#endif
3741	if (rdata->cfile)
3742		cifsFileInfo_put(rdata->cfile);
3743
3744	kvfree(rdata->pages);
3745	kfree(rdata);
3746}
3747
3748static int
3749cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
3750{
3751	int rc = 0;
3752	struct page *page;
3753	unsigned int i;
3754
3755	for (i = 0; i < nr_pages; i++) {
3756		page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
3757		if (!page) {
3758			rc = -ENOMEM;
3759			break;
3760		}
3761		rdata->pages[i] = page;
3762	}
3763
3764	if (rc) {
3765		unsigned int nr_page_failed = i;
3766
3767		for (i = 0; i < nr_page_failed; i++) {
3768			put_page(rdata->pages[i]);
3769			rdata->pages[i] = NULL;
3770		}
3771	}
3772	return rc;
3773}
3774
3775static void
3776cifs_uncached_readdata_release(struct kref *refcount)
3777{
3778	struct cifs_readdata *rdata = container_of(refcount,
3779					struct cifs_readdata, refcount);
3780	unsigned int i;
3781
3782	kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
3783	for (i = 0; i < rdata->nr_pages; i++) {
3784		put_page(rdata->pages[i]);
3785	}
3786	cifs_readdata_release(refcount);
3787}
3788
3789/**
3790 * cifs_readdata_to_iov - copy data from pages in response to an iovec
3791 * @rdata:	the readdata response with list of pages holding data
3792 * @iter:	destination for our data
3793 *
3794 * This function copies data from a list of pages in a readdata response into
3795 * an array of iovecs. It will first calculate where the data should go
3796 * based on the info in the readdata and then copy the data into that spot.
3797 */
3798static int
3799cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
3800{
3801	size_t remaining = rdata->got_bytes;
3802	unsigned int i;
3803
3804	for (i = 0; i < rdata->nr_pages; i++) {
3805		struct page *page = rdata->pages[i];
3806		size_t copy = min_t(size_t, remaining, PAGE_SIZE);
3807		size_t written;
3808
3809		if (unlikely(iov_iter_is_pipe(iter))) {
3810			void *addr = kmap_atomic(page);
3811
3812			written = copy_to_iter(addr, copy, iter);
3813			kunmap_atomic(addr);
3814		} else
3815			written = copy_page_to_iter(page, 0, copy, iter);
3816		remaining -= written;
3817		if (written < copy && iov_iter_count(iter) > 0)
3818			break;
3819	}
3820	return remaining ? -EFAULT : 0;
3821}
3822
3823static void collect_uncached_read_data(struct cifs_aio_ctx *ctx);
3824
3825static void
3826cifs_uncached_readv_complete(struct work_struct *work)
3827{
3828	struct cifs_readdata *rdata = container_of(work,
3829						struct cifs_readdata, work);
3830
3831	complete(&rdata->done);
3832	collect_uncached_read_data(rdata->ctx);
3833	/* the below call can possibly free the last ref to aio ctx */
3834	kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3835}
3836
3837static int
3838uncached_fill_pages(struct TCP_Server_Info *server,
3839		    struct cifs_readdata *rdata, struct iov_iter *iter,
3840		    unsigned int len)
3841{
3842	int result = 0;
3843	unsigned int i;
3844	unsigned int nr_pages = rdata->nr_pages;
3845	unsigned int page_offset = rdata->page_offset;
3846
3847	rdata->got_bytes = 0;
3848	rdata->tailsz = PAGE_SIZE;
3849	for (i = 0; i < nr_pages; i++) {
3850		struct page *page = rdata->pages[i];
3851		size_t n;
3852		unsigned int segment_size = rdata->pagesz;
3853
3854		if (i == 0)
3855			segment_size -= page_offset;
3856		else
3857			page_offset = 0;
3858
3859
3860		if (len <= 0) {
3861			/* no need to hold page hostage */
3862			rdata->pages[i] = NULL;
3863			rdata->nr_pages--;
3864			put_page(page);
3865			continue;
3866		}
3867
3868		n = len;
3869		if (len >= segment_size)
3870			/* enough data to fill the page */
3871			n = segment_size;
3872		else
3873			rdata->tailsz = len;
3874		len -= n;
3875
3876		if (iter)
3877			result = copy_page_from_iter(
3878					page, page_offset, n, iter);
3879#ifdef CONFIG_CIFS_SMB_DIRECT
3880		else if (rdata->mr)
3881			result = n;
3882#endif
3883		else
3884			result = cifs_read_page_from_socket(
3885					server, page, page_offset, n);
3886		if (result < 0)
3887			break;
3888
3889		rdata->got_bytes += result;
3890	}
3891
3892	return result != -ECONNABORTED && rdata->got_bytes > 0 ?
3893						rdata->got_bytes : result;
3894}
3895
3896static int
3897cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
3898			      struct cifs_readdata *rdata, unsigned int len)
3899{
3900	return uncached_fill_pages(server, rdata, NULL, len);
3901}
3902
3903static int
3904cifs_uncached_copy_into_pages(struct TCP_Server_Info *server,
3905			      struct cifs_readdata *rdata,
3906			      struct iov_iter *iter)
3907{
3908	return uncached_fill_pages(server, rdata, iter, iter->count);
3909}
3910
3911static int cifs_resend_rdata(struct cifs_readdata *rdata,
3912			struct list_head *rdata_list,
3913			struct cifs_aio_ctx *ctx)
3914{
3915	unsigned int rsize;
3916	struct cifs_credits credits;
3917	int rc;
3918	struct TCP_Server_Info *server;
3919
3920	/* XXX: should we pick a new channel here? */
3921	server = rdata->server;
3922
3923	do {
3924		if (rdata->cfile->invalidHandle) {
3925			rc = cifs_reopen_file(rdata->cfile, true);
3926			if (rc == -EAGAIN)
3927				continue;
3928			else if (rc)
3929				break;
3930		}
3931
3932		/*
3933		 * Wait for credits to resend this rdata.
3934		 * Note: we are attempting to resend the whole rdata not in
3935		 * segments
3936		 */
3937		do {
3938			rc = server->ops->wait_mtu_credits(server, rdata->bytes,
3939						&rsize, &credits);
3940
3941			if (rc)
3942				goto fail;
3943
3944			if (rsize < rdata->bytes) {
3945				add_credits_and_wake_if(server, &credits, 0);
3946				msleep(1000);
3947			}
3948		} while (rsize < rdata->bytes);
3949		rdata->credits = credits;
3950
3951		rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3952		if (!rc) {
3953			if (rdata->cfile->invalidHandle)
3954				rc = -EAGAIN;
3955			else {
3956#ifdef CONFIG_CIFS_SMB_DIRECT
3957				if (rdata->mr) {
3958					rdata->mr->need_invalidate = true;
3959					smbd_deregister_mr(rdata->mr);
3960					rdata->mr = NULL;
3961				}
3962#endif
3963				rc = server->ops->async_readv(rdata);
3964			}
3965		}
3966
3967		/* If the read was successfully sent, we are done */
3968		if (!rc) {
3969			/* Add to aio pending list */
3970			list_add_tail(&rdata->list, rdata_list);
3971			return 0;
3972		}
3973
3974		/* Roll back credits and retry if needed */
3975		add_credits_and_wake_if(server, &rdata->credits, 0);
3976	} while (rc == -EAGAIN);
3977
3978fail:
3979	kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3980	return rc;
3981}
3982
3983static int
3984cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
3985		     struct cifs_sb_info *cifs_sb, struct list_head *rdata_list,
3986		     struct cifs_aio_ctx *ctx)
3987{
3988	struct cifs_readdata *rdata;
3989	unsigned int npages, rsize;
3990	struct cifs_credits credits_on_stack;
3991	struct cifs_credits *credits = &credits_on_stack;
3992	size_t cur_len;
3993	int rc;
3994	pid_t pid;
3995	struct TCP_Server_Info *server;
3996	struct page **pagevec;
3997	size_t start;
3998	struct iov_iter direct_iov = ctx->iter;
3999
4000	server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);
4001
4002	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4003		pid = open_file->pid;
4004	else
4005		pid = current->tgid;
4006
4007	if (ctx->direct_io)
4008		iov_iter_advance(&direct_iov, offset - ctx->pos);
4009
4010	do {
4011		if (open_file->invalidHandle) {
4012			rc = cifs_reopen_file(open_file, true);
4013			if (rc == -EAGAIN)
4014				continue;
4015			else if (rc)
4016				break;
4017		}
4018
4019		if (cifs_sb->ctx->rsize == 0)
4020			cifs_sb->ctx->rsize =
4021				server->ops->negotiate_rsize(tlink_tcon(open_file->tlink),
4022							     cifs_sb->ctx);
4023
4024		rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize,
4025						   &rsize, credits);
4026		if (rc)
4027			break;
4028
4029		cur_len = min_t(const size_t, len, rsize);
4030
4031		if (ctx->direct_io) {
4032			ssize_t result;
4033
4034			result = iov_iter_get_pages_alloc2(
4035					&direct_iov, &pagevec,
4036					cur_len, &start);
4037			if (result < 0) {
4038				cifs_dbg(VFS,
4039					 "Couldn't get user pages (rc=%zd) iter type %d iov_offset %zd count %zd\n",
4040					 result, iov_iter_type(&direct_iov),
4041					 direct_iov.iov_offset,
4042					 direct_iov.count);
 
 
4043				dump_stack();
4044
4045				rc = result;
4046				add_credits_and_wake_if(server, credits, 0);
4047				break;
4048			}
4049			cur_len = (size_t)result;
 
4050
4051			rdata = cifs_readdata_direct_alloc(
4052					pagevec, cifs_uncached_readv_complete);
4053			if (!rdata) {
4054				add_credits_and_wake_if(server, credits, 0);
4055				rc = -ENOMEM;
4056				break;
4057			}
4058
4059			npages = (cur_len + start + PAGE_SIZE-1) / PAGE_SIZE;
4060			rdata->page_offset = start;
4061			rdata->tailsz = npages > 1 ?
4062				cur_len-(PAGE_SIZE-start)-(npages-2)*PAGE_SIZE :
4063				cur_len;
4064
4065		} else {
4066
4067			npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
4068			/* allocate a readdata struct */
4069			rdata = cifs_readdata_alloc(npages,
4070					    cifs_uncached_readv_complete);
4071			if (!rdata) {
4072				add_credits_and_wake_if(server, credits, 0);
4073				rc = -ENOMEM;
4074				break;
4075			}
4076
4077			rc = cifs_read_allocate_pages(rdata, npages);
4078			if (rc) {
4079				kvfree(rdata->pages);
4080				kfree(rdata);
4081				add_credits_and_wake_if(server, credits, 0);
4082				break;
4083			}
4084
4085			rdata->tailsz = PAGE_SIZE;
4086		}
4087
4088		rdata->server = server;
4089		rdata->cfile = cifsFileInfo_get(open_file);
4090		rdata->nr_pages = npages;
4091		rdata->offset = offset;
4092		rdata->bytes = cur_len;
4093		rdata->pid = pid;
4094		rdata->pagesz = PAGE_SIZE;
4095		rdata->read_into_pages = cifs_uncached_read_into_pages;
4096		rdata->copy_into_pages = cifs_uncached_copy_into_pages;
4097		rdata->credits = credits_on_stack;
4098		rdata->ctx = ctx;
4099		kref_get(&ctx->refcount);
4100
4101		rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4102
4103		if (!rc) {
4104			if (rdata->cfile->invalidHandle)
4105				rc = -EAGAIN;
4106			else
4107				rc = server->ops->async_readv(rdata);
4108		}
4109
4110		if (rc) {
4111			add_credits_and_wake_if(server, &rdata->credits, 0);
4112			kref_put(&rdata->refcount,
4113				cifs_uncached_readdata_release);
4114			if (rc == -EAGAIN) {
4115				iov_iter_revert(&direct_iov, cur_len);
4116				continue;
4117			}
4118			break;
4119		}
4120
4121		list_add_tail(&rdata->list, rdata_list);
4122		offset += cur_len;
4123		len -= cur_len;
4124	} while (len > 0);
4125
4126	return rc;
4127}
4128
4129static void
4130collect_uncached_read_data(struct cifs_aio_ctx *ctx)
4131{
4132	struct cifs_readdata *rdata, *tmp;
4133	struct iov_iter *to = &ctx->iter;
4134	struct cifs_sb_info *cifs_sb;
4135	int rc;
4136
4137	cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb);
4138
4139	mutex_lock(&ctx->aio_mutex);
4140
4141	if (list_empty(&ctx->list)) {
4142		mutex_unlock(&ctx->aio_mutex);
4143		return;
4144	}
4145
4146	rc = ctx->rc;
4147	/* the loop below should proceed in the order of increasing offsets */
4148again:
4149	list_for_each_entry_safe(rdata, tmp, &ctx->list, list) {
4150		if (!rc) {
4151			if (!try_wait_for_completion(&rdata->done)) {
4152				mutex_unlock(&ctx->aio_mutex);
4153				return;
4154			}
4155
4156			if (rdata->result == -EAGAIN) {
4157				/* resend call if it's a retryable error */
4158				struct list_head tmp_list;
4159				unsigned int got_bytes = rdata->got_bytes;
4160
4161				list_del_init(&rdata->list);
4162				INIT_LIST_HEAD(&tmp_list);
4163
4164				/*
4165				 * Got a part of data and then reconnect has
4166				 * happened -- fill the buffer and continue
4167				 * reading.
4168				 */
4169				if (got_bytes && got_bytes < rdata->bytes) {
4170					rc = 0;
4171					if (!ctx->direct_io)
4172						rc = cifs_readdata_to_iov(rdata, to);
4173					if (rc) {
4174						kref_put(&rdata->refcount,
4175							cifs_uncached_readdata_release);
4176						continue;
4177					}
4178				}
4179
4180				if (ctx->direct_io) {
4181					/*
4182					 * Re-use rdata as this is a
4183					 * direct I/O
4184					 */
4185					rc = cifs_resend_rdata(
4186						rdata,
4187						&tmp_list, ctx);
4188				} else {
4189					rc = cifs_send_async_read(
4190						rdata->offset + got_bytes,
4191						rdata->bytes - got_bytes,
4192						rdata->cfile, cifs_sb,
4193						&tmp_list, ctx);
4194
4195					kref_put(&rdata->refcount,
4196						cifs_uncached_readdata_release);
4197				}
4198
4199				list_splice(&tmp_list, &ctx->list);
4200
4201				goto again;
4202			} else if (rdata->result)
4203				rc = rdata->result;
4204			else if (!ctx->direct_io)
4205				rc = cifs_readdata_to_iov(rdata, to);
4206
4207			/* if there was a short read -- discard anything left */
4208			if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
4209				rc = -ENODATA;
4210
4211			ctx->total_len += rdata->got_bytes;
4212		}
4213		list_del_init(&rdata->list);
4214		kref_put(&rdata->refcount, cifs_uncached_readdata_release);
4215	}
4216
4217	if (!ctx->direct_io)
4218		ctx->total_len = ctx->len - iov_iter_count(to);
4219
4220	/* mask nodata case */
4221	if (rc == -ENODATA)
4222		rc = 0;
4223
4224	ctx->rc = (rc == 0) ? (ssize_t)ctx->total_len : rc;
4225
4226	mutex_unlock(&ctx->aio_mutex);
4227
4228	if (ctx->iocb && ctx->iocb->ki_complete)
4229		ctx->iocb->ki_complete(ctx->iocb, ctx->rc);
4230	else
4231		complete(&ctx->done);
4232}
4233
4234static ssize_t __cifs_readv(
4235	struct kiocb *iocb, struct iov_iter *to, bool direct)
4236{
4237	size_t len;
4238	struct file *file = iocb->ki_filp;
4239	struct cifs_sb_info *cifs_sb;
4240	struct cifsFileInfo *cfile;
4241	struct cifs_tcon *tcon;
4242	ssize_t rc, total_read = 0;
4243	loff_t offset = iocb->ki_pos;
4244	struct cifs_aio_ctx *ctx;
4245
4246	/*
4247	 * iov_iter_get_pages_alloc() doesn't work with ITER_KVEC,
4248	 * fall back to data copy read path
4249	 * this could be improved by getting pages directly in ITER_KVEC
4250	 */
4251	if (direct && iov_iter_is_kvec(to)) {
4252		cifs_dbg(FYI, "use non-direct cifs_user_readv for kvec I/O\n");
4253		direct = false;
4254	}
4255
4256	len = iov_iter_count(to);
4257	if (!len)
4258		return 0;
4259
4260	cifs_sb = CIFS_FILE_SB(file);
4261	cfile = file->private_data;
4262	tcon = tlink_tcon(cfile->tlink);
4263
4264	if (!tcon->ses->server->ops->async_readv)
4265		return -ENOSYS;
4266
4267	if ((file->f_flags & O_ACCMODE) == O_WRONLY)
4268		cifs_dbg(FYI, "attempting read on write only file instance\n");
4269
4270	ctx = cifs_aio_ctx_alloc();
4271	if (!ctx)
4272		return -ENOMEM;
4273
4274	ctx->cfile = cifsFileInfo_get(cfile);
4275
4276	if (!is_sync_kiocb(iocb))
4277		ctx->iocb = iocb;
4278
4279	if (user_backed_iter(to))
4280		ctx->should_dirty = true;
4281
4282	if (direct) {
4283		ctx->pos = offset;
4284		ctx->direct_io = true;
4285		ctx->iter = *to;
4286		ctx->len = len;
4287	} else {
4288		rc = setup_aio_ctx_iter(ctx, to, ITER_DEST);
4289		if (rc) {
4290			kref_put(&ctx->refcount, cifs_aio_ctx_release);
4291			return rc;
4292		}
4293		len = ctx->len;
4294	}
4295
4296	if (direct) {
4297		rc = filemap_write_and_wait_range(file->f_inode->i_mapping,
4298						  offset, offset + len - 1);
4299		if (rc) {
4300			kref_put(&ctx->refcount, cifs_aio_ctx_release);
4301			return -EAGAIN;
4302		}
4303	}
4304
4305	/* grab a lock here due to read response handlers can access ctx */
4306	mutex_lock(&ctx->aio_mutex);
4307
4308	rc = cifs_send_async_read(offset, len, cfile, cifs_sb, &ctx->list, ctx);
4309
4310	/* if at least one read request send succeeded, then reset rc */
4311	if (!list_empty(&ctx->list))
4312		rc = 0;
4313
4314	mutex_unlock(&ctx->aio_mutex);
4315
4316	if (rc) {
4317		kref_put(&ctx->refcount, cifs_aio_ctx_release);
4318		return rc;
4319	}
4320
4321	if (!is_sync_kiocb(iocb)) {
4322		kref_put(&ctx->refcount, cifs_aio_ctx_release);
4323		return -EIOCBQUEUED;
4324	}
4325
4326	rc = wait_for_completion_killable(&ctx->done);
4327	if (rc) {
4328		mutex_lock(&ctx->aio_mutex);
4329		ctx->rc = rc = -EINTR;
4330		total_read = ctx->total_len;
4331		mutex_unlock(&ctx->aio_mutex);
4332	} else {
4333		rc = ctx->rc;
4334		total_read = ctx->total_len;
4335	}
4336
4337	kref_put(&ctx->refcount, cifs_aio_ctx_release);
4338
4339	if (total_read) {
4340		iocb->ki_pos += total_read;
4341		return total_read;
4342	}
4343	return rc;
4344}
4345
4346ssize_t cifs_direct_readv(struct kiocb *iocb, struct iov_iter *to)
4347{
4348	return __cifs_readv(iocb, to, true);
4349}
4350
4351ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
4352{
4353	return __cifs_readv(iocb, to, false);
4354}
4355
4356ssize_t
4357cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
4358{
4359	struct inode *inode = file_inode(iocb->ki_filp);
4360	struct cifsInodeInfo *cinode = CIFS_I(inode);
4361	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
4362	struct cifsFileInfo *cfile = (struct cifsFileInfo *)
4363						iocb->ki_filp->private_data;
4364	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4365	int rc = -EACCES;
4366
4367	/*
4368	 * In strict cache mode we need to read from the server all the time
4369	 * if we don't have level II oplock because the server can delay mtime
4370	 * change - so we can't make a decision about inode invalidating.
4371	 * And we can also fail with pagereading if there are mandatory locks
4372	 * on pages affected by this read but not on the region from pos to
4373	 * pos+len-1.
4374	 */
4375	if (!CIFS_CACHE_READ(cinode))
4376		return cifs_user_readv(iocb, to);
4377
4378	if (cap_unix(tcon->ses) &&
4379	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
4380	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
4381		return generic_file_read_iter(iocb, to);
4382
4383	/*
4384	 * We need to hold the sem to be sure nobody modifies lock list
4385	 * with a brlock that prevents reading.
4386	 */
4387	down_read(&cinode->lock_sem);
4388	if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
4389				     tcon->ses->server->vals->shared_lock_type,
4390				     0, NULL, CIFS_READ_OP))
4391		rc = generic_file_read_iter(iocb, to);
4392	up_read(&cinode->lock_sem);
4393	return rc;
4394}
4395
4396static ssize_t
4397cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
4398{
4399	int rc = -EACCES;
4400	unsigned int bytes_read = 0;
4401	unsigned int total_read;
4402	unsigned int current_read_size;
4403	unsigned int rsize;
4404	struct cifs_sb_info *cifs_sb;
4405	struct cifs_tcon *tcon;
4406	struct TCP_Server_Info *server;
4407	unsigned int xid;
4408	char *cur_offset;
4409	struct cifsFileInfo *open_file;
4410	struct cifs_io_parms io_parms = {0};
4411	int buf_type = CIFS_NO_BUFFER;
4412	__u32 pid;
4413
4414	xid = get_xid();
4415	cifs_sb = CIFS_FILE_SB(file);
4416
4417	/* FIXME: set up handlers for larger reads and/or convert to async */
4418	rsize = min_t(unsigned int, cifs_sb->ctx->rsize, CIFSMaxBufSize);
4419
4420	if (file->private_data == NULL) {
4421		rc = -EBADF;
4422		free_xid(xid);
4423		return rc;
4424	}
4425	open_file = file->private_data;
4426	tcon = tlink_tcon(open_file->tlink);
4427	server = cifs_pick_channel(tcon->ses);
4428
4429	if (!server->ops->sync_read) {
4430		free_xid(xid);
4431		return -ENOSYS;
4432	}
4433
4434	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4435		pid = open_file->pid;
4436	else
4437		pid = current->tgid;
4438
4439	if ((file->f_flags & O_ACCMODE) == O_WRONLY)
4440		cifs_dbg(FYI, "attempting read on write only file instance\n");
4441
4442	for (total_read = 0, cur_offset = read_data; read_size > total_read;
4443	     total_read += bytes_read, cur_offset += bytes_read) {
4444		do {
4445			current_read_size = min_t(uint, read_size - total_read,
4446						  rsize);
4447			/*
4448			 * For windows me and 9x we do not want to request more
4449			 * than it negotiated since it will refuse the read
4450			 * then.
4451			 */
4452			if (!(tcon->ses->capabilities &
4453				tcon->ses->server->vals->cap_large_files)) {
4454				current_read_size = min_t(uint,
4455					current_read_size, CIFSMaxBufSize);
4456			}
4457			if (open_file->invalidHandle) {
4458				rc = cifs_reopen_file(open_file, true);
4459				if (rc != 0)
4460					break;
4461			}
4462			io_parms.pid = pid;
4463			io_parms.tcon = tcon;
4464			io_parms.offset = *offset;
4465			io_parms.length = current_read_size;
4466			io_parms.server = server;
4467			rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
4468						    &bytes_read, &cur_offset,
4469						    &buf_type);
4470		} while (rc == -EAGAIN);
4471
4472		if (rc || (bytes_read == 0)) {
4473			if (total_read) {
4474				break;
4475			} else {
4476				free_xid(xid);
4477				return rc;
4478			}
4479		} else {
4480			cifs_stats_bytes_read(tcon, total_read);
4481			*offset += bytes_read;
4482		}
4483	}
4484	free_xid(xid);
4485	return total_read;
4486}
4487
4488/*
4489 * If the page is mmap'ed into a process' page tables, then we need to make
4490 * sure that it doesn't change while being written back.
4491 */
4492static vm_fault_t
4493cifs_page_mkwrite(struct vm_fault *vmf)
4494{
4495	struct page *page = vmf->page;
4496
4497	/* Wait for the page to be written to the cache before we allow it to
4498	 * be modified.  We then assume the entire page will need writing back.
4499	 */
4500#ifdef CONFIG_CIFS_FSCACHE
4501	if (PageFsCache(page) &&
4502	    wait_on_page_fscache_killable(page) < 0)
4503		return VM_FAULT_RETRY;
4504#endif
4505
4506	wait_on_page_writeback(page);
4507
4508	if (lock_page_killable(page) < 0)
4509		return VM_FAULT_RETRY;
4510	return VM_FAULT_LOCKED;
4511}
4512
4513static const struct vm_operations_struct cifs_file_vm_ops = {
4514	.fault = filemap_fault,
4515	.map_pages = filemap_map_pages,
4516	.page_mkwrite = cifs_page_mkwrite,
4517};
4518
4519int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
4520{
4521	int xid, rc = 0;
4522	struct inode *inode = file_inode(file);
4523
4524	xid = get_xid();
4525
4526	if (!CIFS_CACHE_READ(CIFS_I(inode)))
4527		rc = cifs_zap_mapping(inode);
4528	if (!rc)
4529		rc = generic_file_mmap(file, vma);
4530	if (!rc)
4531		vma->vm_ops = &cifs_file_vm_ops;
4532
4533	free_xid(xid);
4534	return rc;
4535}
4536
4537int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
4538{
4539	int rc, xid;
4540
4541	xid = get_xid();
4542
4543	rc = cifs_revalidate_file(file);
4544	if (rc)
4545		cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
4546			 rc);
4547	if (!rc)
4548		rc = generic_file_mmap(file, vma);
4549	if (!rc)
4550		vma->vm_ops = &cifs_file_vm_ops;
4551
4552	free_xid(xid);
4553	return rc;
4554}
4555
4556static void
4557cifs_readv_complete(struct work_struct *work)
4558{
4559	unsigned int i, got_bytes;
4560	struct cifs_readdata *rdata = container_of(work,
4561						struct cifs_readdata, work);
4562
4563	got_bytes = rdata->got_bytes;
4564	for (i = 0; i < rdata->nr_pages; i++) {
4565		struct page *page = rdata->pages[i];
4566
 
 
4567		if (rdata->result == 0 ||
4568		    (rdata->result == -EAGAIN && got_bytes)) {
4569			flush_dcache_page(page);
4570			SetPageUptodate(page);
4571		} else
4572			SetPageError(page);
 
4573
4574		if (rdata->result == 0 ||
4575		    (rdata->result == -EAGAIN && got_bytes))
4576			cifs_readpage_to_fscache(rdata->mapping->host, page);
4577
4578		unlock_page(page);
4579
4580		got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
4581
4582		put_page(page);
4583		rdata->pages[i] = NULL;
4584	}
4585	kref_put(&rdata->refcount, cifs_readdata_release);
4586}
4587
4588static int
4589readpages_fill_pages(struct TCP_Server_Info *server,
4590		     struct cifs_readdata *rdata, struct iov_iter *iter,
4591		     unsigned int len)
4592{
4593	int result = 0;
4594	unsigned int i;
4595	u64 eof;
4596	pgoff_t eof_index;
4597	unsigned int nr_pages = rdata->nr_pages;
4598	unsigned int page_offset = rdata->page_offset;
4599
4600	/* determine the eof that the server (probably) has */
4601	eof = CIFS_I(rdata->mapping->host)->server_eof;
4602	eof_index = eof ? (eof - 1) >> PAGE_SHIFT : 0;
4603	cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
4604
4605	rdata->got_bytes = 0;
4606	rdata->tailsz = PAGE_SIZE;
4607	for (i = 0; i < nr_pages; i++) {
4608		struct page *page = rdata->pages[i];
4609		unsigned int to_read = rdata->pagesz;
4610		size_t n;
4611
4612		if (i == 0)
4613			to_read -= page_offset;
4614		else
4615			page_offset = 0;
4616
4617		n = to_read;
4618
4619		if (len >= to_read) {
4620			len -= to_read;
4621		} else if (len > 0) {
4622			/* enough for partial page, fill and zero the rest */
4623			zero_user(page, len + page_offset, to_read - len);
4624			n = rdata->tailsz = len;
4625			len = 0;
4626		} else if (page->index > eof_index) {
4627			/*
4628			 * The VFS will not try to do readahead past the
4629			 * i_size, but it's possible that we have outstanding
4630			 * writes with gaps in the middle and the i_size hasn't
4631			 * caught up yet. Populate those with zeroed out pages
4632			 * to prevent the VFS from repeatedly attempting to
4633			 * fill them until the writes are flushed.
4634			 */
4635			zero_user(page, 0, PAGE_SIZE);
 
4636			flush_dcache_page(page);
4637			SetPageUptodate(page);
4638			unlock_page(page);
4639			put_page(page);
4640			rdata->pages[i] = NULL;
4641			rdata->nr_pages--;
4642			continue;
4643		} else {
4644			/* no need to hold page hostage */
 
4645			unlock_page(page);
4646			put_page(page);
4647			rdata->pages[i] = NULL;
4648			rdata->nr_pages--;
4649			continue;
4650		}
4651
4652		if (iter)
4653			result = copy_page_from_iter(
4654					page, page_offset, n, iter);
4655#ifdef CONFIG_CIFS_SMB_DIRECT
4656		else if (rdata->mr)
4657			result = n;
4658#endif
4659		else
4660			result = cifs_read_page_from_socket(
4661					server, page, page_offset, n);
4662		if (result < 0)
4663			break;
4664
4665		rdata->got_bytes += result;
4666	}
4667
4668	return result != -ECONNABORTED && rdata->got_bytes > 0 ?
4669						rdata->got_bytes : result;
4670}
4671
4672static int
4673cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
4674			       struct cifs_readdata *rdata, unsigned int len)
4675{
4676	return readpages_fill_pages(server, rdata, NULL, len);
4677}
4678
4679static int
4680cifs_readpages_copy_into_pages(struct TCP_Server_Info *server,
4681			       struct cifs_readdata *rdata,
4682			       struct iov_iter *iter)
4683{
4684	return readpages_fill_pages(server, rdata, iter, iter->count);
4685}
4686
4687static void cifs_readahead(struct readahead_control *ractl)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4688{
4689	int rc;
4690	struct cifsFileInfo *open_file = ractl->file->private_data;
4691	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(ractl->file);
 
4692	struct TCP_Server_Info *server;
4693	pid_t pid;
4694	unsigned int xid, nr_pages, last_batch_size = 0, cache_nr_pages = 0;
4695	pgoff_t next_cached = ULONG_MAX;
4696	bool caching = fscache_cookie_enabled(cifs_inode_cookie(ractl->mapping->host)) &&
4697		cifs_inode_cookie(ractl->mapping->host)->cache_priv;
4698	bool check_cache = caching;
4699
4700	xid = get_xid();
 
 
 
 
 
 
 
 
 
 
 
 
 
4701
4702	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4703		pid = open_file->pid;
4704	else
4705		pid = current->tgid;
4706
4707	rc = 0;
4708	server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);
4709
4710	cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
4711		 __func__, ractl->file, ractl->mapping, readahead_count(ractl));
4712
4713	/*
4714	 * Chop the readahead request up into rsize-sized read requests.
 
 
 
 
 
 
 
 
4715	 */
4716	while ((nr_pages = readahead_count(ractl) - last_batch_size)) {
4717		unsigned int i, got, rsize;
4718		struct page *page;
 
4719		struct cifs_readdata *rdata;
4720		struct cifs_credits credits_on_stack;
4721		struct cifs_credits *credits = &credits_on_stack;
4722		pgoff_t index = readahead_index(ractl) + last_batch_size;
4723
4724		/*
4725		 * Find out if we have anything cached in the range of
4726		 * interest, and if so, where the next chunk of cached data is.
4727		 */
4728		if (caching) {
4729			if (check_cache) {
4730				rc = cifs_fscache_query_occupancy(
4731					ractl->mapping->host, index, nr_pages,
4732					&next_cached, &cache_nr_pages);
4733				if (rc < 0)
4734					caching = false;
4735				check_cache = false;
4736			}
4737
4738			if (index == next_cached) {
4739				/*
4740				 * TODO: Send a whole batch of pages to be read
4741				 * by the cache.
4742				 */
4743				struct folio *folio = readahead_folio(ractl);
4744
4745				last_batch_size = folio_nr_pages(folio);
4746				if (cifs_readpage_from_fscache(ractl->mapping->host,
4747							       &folio->page) < 0) {
4748					/*
4749					 * TODO: Deal with cache read failure
4750					 * here, but for the moment, delegate
4751					 * that to readpage.
4752					 */
4753					caching = false;
4754				}
4755				folio_unlock(folio);
4756				next_cached++;
4757				cache_nr_pages--;
4758				if (cache_nr_pages == 0)
4759					check_cache = true;
4760				continue;
4761			}
4762		}
4763
4764		if (open_file->invalidHandle) {
4765			rc = cifs_reopen_file(open_file, true);
4766			if (rc) {
4767				if (rc == -EAGAIN)
4768					continue;
4769				break;
4770			}
4771		}
4772
4773		if (cifs_sb->ctx->rsize == 0)
4774			cifs_sb->ctx->rsize =
4775				server->ops->negotiate_rsize(tlink_tcon(open_file->tlink),
4776							     cifs_sb->ctx);
4777
4778		rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize,
4779						   &rsize, credits);
4780		if (rc)
4781			break;
4782		nr_pages = min_t(size_t, rsize / PAGE_SIZE, readahead_count(ractl));
4783		nr_pages = min_t(size_t, nr_pages, next_cached - index);
4784
4785		/*
4786		 * Give up immediately if rsize is too small to read an entire
4787		 * page. The VFS will fall back to readpage. We should never
4788		 * reach this point however since we set ra_pages to 0 when the
4789		 * rsize is smaller than a cache page.
4790		 */
4791		if (unlikely(!nr_pages)) {
 
 
 
 
 
 
 
 
4792			add_credits_and_wake_if(server, credits, 0);
4793			break;
4794		}
4795
4796		rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
4797		if (!rdata) {
4798			/* best to give up if we're out of mem */
 
 
 
 
 
 
 
4799			add_credits_and_wake_if(server, credits, 0);
4800			break;
4801		}
4802
4803		got = __readahead_batch(ractl, rdata->pages, nr_pages);
4804		if (got != nr_pages) {
4805			pr_warn("__readahead_batch() returned %u/%u\n",
4806				got, nr_pages);
4807			nr_pages = got;
4808		}
4809
4810		rdata->nr_pages = nr_pages;
4811		rdata->bytes	= readahead_batch_length(ractl);
4812		rdata->cfile	= cifsFileInfo_get(open_file);
4813		rdata->server	= server;
4814		rdata->mapping	= ractl->mapping;
4815		rdata->offset	= readahead_pos(ractl);
4816		rdata->pid	= pid;
4817		rdata->pagesz	= PAGE_SIZE;
4818		rdata->tailsz	= PAGE_SIZE;
4819		rdata->read_into_pages = cifs_readpages_read_into_pages;
4820		rdata->copy_into_pages = cifs_readpages_copy_into_pages;
4821		rdata->credits	= credits_on_stack;
 
 
 
 
 
4822
4823		rc = adjust_credits(server, &rdata->credits, rdata->bytes);
 
4824		if (!rc) {
4825			if (rdata->cfile->invalidHandle)
4826				rc = -EAGAIN;
4827			else
4828				rc = server->ops->async_readv(rdata);
4829		}
4830
4831		if (rc) {
4832			add_credits_and_wake_if(server, &rdata->credits, 0);
4833			for (i = 0; i < rdata->nr_pages; i++) {
4834				page = rdata->pages[i];
 
4835				unlock_page(page);
4836				put_page(page);
4837			}
4838			/* Fallback to the readpage in error/reconnect cases */
4839			kref_put(&rdata->refcount, cifs_readdata_release);
4840			break;
4841		}
4842
4843		kref_put(&rdata->refcount, cifs_readdata_release);
4844		last_batch_size = nr_pages;
4845	}
4846
 
 
 
 
 
4847	free_xid(xid);
 
4848}
4849
4850/*
4851 * cifs_readpage_worker must be called with the page pinned
4852 */
4853static int cifs_readpage_worker(struct file *file, struct page *page,
4854	loff_t *poffset)
4855{
4856	char *read_data;
4857	int rc;
4858
4859	/* Is the page cached? */
4860	rc = cifs_readpage_from_fscache(file_inode(file), page);
4861	if (rc == 0)
4862		goto read_complete;
4863
4864	read_data = kmap(page);
4865	/* for reads over a certain size could initiate async read ahead */
4866
4867	rc = cifs_read(file, read_data, PAGE_SIZE, poffset);
4868
4869	if (rc < 0)
4870		goto io_error;
4871	else
4872		cifs_dbg(FYI, "Bytes read %d\n", rc);
4873
4874	/* we do not want atime to be less than mtime, it broke some apps */
4875	file_inode(file)->i_atime = current_time(file_inode(file));
4876	if (timespec64_compare(&(file_inode(file)->i_atime), &(file_inode(file)->i_mtime)))
4877		file_inode(file)->i_atime = file_inode(file)->i_mtime;
4878	else
4879		file_inode(file)->i_atime = current_time(file_inode(file));
4880
4881	if (PAGE_SIZE > rc)
4882		memset(read_data + rc, 0, PAGE_SIZE - rc);
4883
4884	flush_dcache_page(page);
4885	SetPageUptodate(page);
4886
4887	/* send this page to the cache */
4888	cifs_readpage_to_fscache(file_inode(file), page);
4889
4890	rc = 0;
4891
4892io_error:
4893	kunmap(page);
4894	unlock_page(page);
4895
4896read_complete:
4897	return rc;
4898}
4899
4900static int cifs_read_folio(struct file *file, struct folio *folio)
4901{
4902	struct page *page = &folio->page;
4903	loff_t offset = page_file_offset(page);
4904	int rc = -EACCES;
4905	unsigned int xid;
4906
4907	xid = get_xid();
4908
4909	if (file->private_data == NULL) {
4910		rc = -EBADF;
4911		free_xid(xid);
4912		return rc;
4913	}
4914
4915	cifs_dbg(FYI, "read_folio %p at offset %d 0x%x\n",
4916		 page, (int)offset, (int)offset);
4917
4918	rc = cifs_readpage_worker(file, page, &offset);
4919
4920	free_xid(xid);
4921	return rc;
4922}
4923
4924static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
4925{
4926	struct cifsFileInfo *open_file;
4927
4928	spin_lock(&cifs_inode->open_file_lock);
4929	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
4930		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
4931			spin_unlock(&cifs_inode->open_file_lock);
4932			return 1;
4933		}
4934	}
4935	spin_unlock(&cifs_inode->open_file_lock);
4936	return 0;
4937}
4938
4939/* We do not want to update the file size from server for inodes
4940   open for write - to avoid races with writepage extending
4941   the file - in the future we could consider allowing
4942   refreshing the inode only on increases in the file size
4943   but this is tricky to do without racing with writebehind
4944   page caching in the current Linux kernel design */
4945bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
4946{
4947	if (!cifsInode)
4948		return true;
4949
4950	if (is_inode_writable(cifsInode)) {
4951		/* This inode is open for write at least once */
4952		struct cifs_sb_info *cifs_sb;
4953
4954		cifs_sb = CIFS_SB(cifsInode->netfs.inode.i_sb);
4955		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
4956			/* since no page cache to corrupt on directio
4957			we can change size safely */
4958			return true;
4959		}
4960
4961		if (i_size_read(&cifsInode->netfs.inode) < end_of_file)
4962			return true;
4963
4964		return false;
4965	} else
4966		return true;
4967}
4968
4969static int cifs_write_begin(struct file *file, struct address_space *mapping,
4970			loff_t pos, unsigned len,
4971			struct page **pagep, void **fsdata)
4972{
4973	int oncethru = 0;
4974	pgoff_t index = pos >> PAGE_SHIFT;
4975	loff_t offset = pos & (PAGE_SIZE - 1);
4976	loff_t page_start = pos & PAGE_MASK;
4977	loff_t i_size;
4978	struct page *page;
4979	int rc = 0;
4980
4981	cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
4982
4983start:
4984	page = grab_cache_page_write_begin(mapping, index);
4985	if (!page) {
4986		rc = -ENOMEM;
4987		goto out;
4988	}
4989
4990	if (PageUptodate(page))
4991		goto out;
4992
4993	/*
4994	 * If we write a full page it will be up to date, no need to read from
4995	 * the server. If the write is short, we'll end up doing a sync write
4996	 * instead.
4997	 */
4998	if (len == PAGE_SIZE)
4999		goto out;
5000
5001	/*
5002	 * optimize away the read when we have an oplock, and we're not
5003	 * expecting to use any of the data we'd be reading in. That
5004	 * is, when the page lies beyond the EOF, or straddles the EOF
5005	 * and the write will cover all of the existing data.
5006	 */
5007	if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
5008		i_size = i_size_read(mapping->host);
5009		if (page_start >= i_size ||
5010		    (offset == 0 && (pos + len) >= i_size)) {
5011			zero_user_segments(page, 0, offset,
5012					   offset + len,
5013					   PAGE_SIZE);
5014			/*
5015			 * PageChecked means that the parts of the page
5016			 * to which we're not writing are considered up
5017			 * to date. Once the data is copied to the
5018			 * page, it can be set uptodate.
5019			 */
5020			SetPageChecked(page);
5021			goto out;
5022		}
5023	}
5024
5025	if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
5026		/*
5027		 * might as well read a page, it is fast enough. If we get
5028		 * an error, we don't need to return it. cifs_write_end will
5029		 * do a sync write instead since PG_uptodate isn't set.
5030		 */
5031		cifs_readpage_worker(file, page, &page_start);
5032		put_page(page);
5033		oncethru = 1;
5034		goto start;
5035	} else {
5036		/* we could try using another file handle if there is one -
5037		   but how would we lock it to prevent close of that handle
5038		   racing with this read? In any case
5039		   this will be written out by write_end so is fine */
5040	}
5041out:
5042	*pagep = page;
5043	return rc;
5044}
5045
5046static bool cifs_release_folio(struct folio *folio, gfp_t gfp)
5047{
5048	if (folio_test_private(folio))
5049		return 0;
5050	if (folio_test_fscache(folio)) {
5051		if (current_is_kswapd() || !(gfp & __GFP_FS))
5052			return false;
5053		folio_wait_fscache(folio);
5054	}
5055	fscache_note_page_release(cifs_inode_cookie(folio->mapping->host));
5056	return true;
5057}
5058
5059static void cifs_invalidate_folio(struct folio *folio, size_t offset,
5060				 size_t length)
5061{
5062	folio_wait_fscache(folio);
 
 
 
5063}
5064
5065static int cifs_launder_folio(struct folio *folio)
5066{
5067	int rc = 0;
5068	loff_t range_start = folio_pos(folio);
5069	loff_t range_end = range_start + folio_size(folio);
5070	struct writeback_control wbc = {
5071		.sync_mode = WB_SYNC_ALL,
5072		.nr_to_write = 0,
5073		.range_start = range_start,
5074		.range_end = range_end,
5075	};
5076
5077	cifs_dbg(FYI, "Launder page: %lu\n", folio->index);
5078
5079	if (folio_clear_dirty_for_io(folio))
5080		rc = cifs_writepage_locked(&folio->page, &wbc);
5081
5082	folio_wait_fscache(folio);
5083	return rc;
5084}
5085
5086void cifs_oplock_break(struct work_struct *work)
5087{
5088	struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
5089						  oplock_break);
5090	struct inode *inode = d_inode(cfile->dentry);
5091	struct cifsInodeInfo *cinode = CIFS_I(inode);
5092	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
5093	struct TCP_Server_Info *server = tcon->ses->server;
5094	int rc = 0;
5095	bool purge_cache = false;
5096
5097	wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
5098			TASK_UNINTERRUPTIBLE);
5099
5100	server->ops->downgrade_oplock(server, cinode, cfile->oplock_level,
5101				      cfile->oplock_epoch, &purge_cache);
5102
5103	if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
5104						cifs_has_mand_locks(cinode)) {
5105		cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
5106			 inode);
5107		cinode->oplock = 0;
5108	}
5109
5110	if (inode && S_ISREG(inode->i_mode)) {
5111		if (CIFS_CACHE_READ(cinode))
5112			break_lease(inode, O_RDONLY);
5113		else
5114			break_lease(inode, O_WRONLY);
5115		rc = filemap_fdatawrite(inode->i_mapping);
5116		if (!CIFS_CACHE_READ(cinode) || purge_cache) {
5117			rc = filemap_fdatawait(inode->i_mapping);
5118			mapping_set_error(inode->i_mapping, rc);
5119			cifs_zap_mapping(inode);
5120		}
5121		cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
5122		if (CIFS_CACHE_WRITE(cinode))
5123			goto oplock_break_ack;
5124	}
5125
5126	rc = cifs_push_locks(cfile);
5127	if (rc)
5128		cifs_dbg(VFS, "Push locks rc = %d\n", rc);
5129
5130oplock_break_ack:
5131	/*
5132	 * releasing stale oplock after recent reconnect of smb session using
5133	 * a now incorrect file handle is not a data integrity issue but do
5134	 * not bother sending an oplock release if session to server still is
5135	 * disconnected since oplock already released by the server
5136	 */
5137	if (!cfile->oplock_break_cancelled) {
5138		rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
5139							     cinode);
5140		cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
5141	}
5142
5143	_cifsFileInfo_put(cfile, false /* do not wait for ourself */, false);
5144	cifs_done_oplock_break(cinode);
5145}
5146
5147/*
5148 * The presence of cifs_direct_io() in the address space ops vector
5149 * allowes open() O_DIRECT flags which would have failed otherwise.
5150 *
5151 * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
5152 * so this method should never be called.
5153 *
5154 * Direct IO is not yet supported in the cached mode.
5155 */
5156static ssize_t
5157cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
5158{
5159        /*
5160         * FIXME
5161         * Eventually need to support direct IO for non forcedirectio mounts
5162         */
5163        return -EINVAL;
5164}
5165
5166static int cifs_swap_activate(struct swap_info_struct *sis,
5167			      struct file *swap_file, sector_t *span)
5168{
5169	struct cifsFileInfo *cfile = swap_file->private_data;
5170	struct inode *inode = swap_file->f_mapping->host;
5171	unsigned long blocks;
5172	long long isize;
5173
5174	cifs_dbg(FYI, "swap activate\n");
5175
5176	if (!swap_file->f_mapping->a_ops->swap_rw)
5177		/* Cannot support swap */
5178		return -EINVAL;
5179
5180	spin_lock(&inode->i_lock);
5181	blocks = inode->i_blocks;
5182	isize = inode->i_size;
5183	spin_unlock(&inode->i_lock);
5184	if (blocks*512 < isize) {
5185		pr_warn("swap activate: swapfile has holes\n");
5186		return -EINVAL;
5187	}
5188	*span = sis->pages;
5189
5190	pr_warn_once("Swap support over SMB3 is experimental\n");
5191
5192	/*
5193	 * TODO: consider adding ACL (or documenting how) to prevent other
5194	 * users (on this or other systems) from reading it
5195	 */
5196
5197
5198	/* TODO: add sk_set_memalloc(inet) or similar */
5199
5200	if (cfile)
5201		cfile->swapfile = true;
5202	/*
5203	 * TODO: Since file already open, we can't open with DENY_ALL here
5204	 * but we could add call to grab a byte range lock to prevent others
5205	 * from reading or writing the file
5206	 */
5207
5208	sis->flags |= SWP_FS_OPS;
5209	return add_swap_extent(sis, 0, sis->max, 0);
5210}
5211
5212static void cifs_swap_deactivate(struct file *file)
5213{
5214	struct cifsFileInfo *cfile = file->private_data;
5215
5216	cifs_dbg(FYI, "swap deactivate\n");
5217
5218	/* TODO: undo sk_set_memalloc(inet) will eventually be needed */
5219
5220	if (cfile)
5221		cfile->swapfile = false;
5222
5223	/* do we need to unpin (or unlock) the file */
5224}
5225
5226/*
5227 * Mark a page as having been made dirty and thus needing writeback.  We also
5228 * need to pin the cache object to write back to.
5229 */
5230#ifdef CONFIG_CIFS_FSCACHE
5231static bool cifs_dirty_folio(struct address_space *mapping, struct folio *folio)
5232{
5233	return fscache_dirty_folio(mapping, folio,
5234					cifs_inode_cookie(mapping->host));
5235}
5236#else
5237#define cifs_dirty_folio filemap_dirty_folio
5238#endif
5239
5240const struct address_space_operations cifs_addr_ops = {
5241	.read_folio = cifs_read_folio,
5242	.readahead = cifs_readahead,
 
5243	.writepages = cifs_writepages,
5244	.write_begin = cifs_write_begin,
5245	.write_end = cifs_write_end,
5246	.dirty_folio = cifs_dirty_folio,
5247	.release_folio = cifs_release_folio,
5248	.direct_IO = cifs_direct_io,
5249	.invalidate_folio = cifs_invalidate_folio,
5250	.launder_folio = cifs_launder_folio,
5251	.migrate_folio = filemap_migrate_folio,
5252	/*
5253	 * TODO: investigate and if useful we could add an is_dirty_writeback
5254	 * helper if needed
5255	 */
5256	.swap_activate = cifs_swap_activate,
5257	.swap_deactivate = cifs_swap_deactivate,
5258};
5259
5260/*
5261 * cifs_readahead requires the server to support a buffer large enough to
5262 * contain the header plus one complete page of data.  Otherwise, we need
5263 * to leave cifs_readahead out of the address space operations.
5264 */
5265const struct address_space_operations cifs_addr_ops_smallbuf = {
5266	.read_folio = cifs_read_folio,
 
5267	.writepages = cifs_writepages,
5268	.write_begin = cifs_write_begin,
5269	.write_end = cifs_write_end,
5270	.dirty_folio = cifs_dirty_folio,
5271	.release_folio = cifs_release_folio,
5272	.invalidate_folio = cifs_invalidate_folio,
5273	.launder_folio = cifs_launder_folio,
5274	.migrate_folio = filemap_migrate_folio,
5275};
v5.4
 
   1/*
   2 *   fs/cifs/file.c
   3 *
   4 *   vfs operations that deal with files
   5 *
   6 *   Copyright (C) International Business Machines  Corp., 2002,2010
   7 *   Author(s): Steve French (sfrench@us.ibm.com)
   8 *              Jeremy Allison (jra@samba.org)
   9 *
  10 *   This library is free software; you can redistribute it and/or modify
  11 *   it under the terms of the GNU Lesser General Public License as published
  12 *   by the Free Software Foundation; either version 2.1 of the License, or
  13 *   (at your option) any later version.
  14 *
  15 *   This library is distributed in the hope that it will be useful,
  16 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  17 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  18 *   the GNU Lesser General Public License for more details.
  19 *
  20 *   You should have received a copy of the GNU Lesser General Public License
  21 *   along with this library; if not, write to the Free Software
  22 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  23 */
  24#include <linux/fs.h>
  25#include <linux/backing-dev.h>
  26#include <linux/stat.h>
  27#include <linux/fcntl.h>
  28#include <linux/pagemap.h>
  29#include <linux/pagevec.h>
  30#include <linux/writeback.h>
  31#include <linux/task_io_accounting_ops.h>
  32#include <linux/delay.h>
  33#include <linux/mount.h>
  34#include <linux/slab.h>
  35#include <linux/swap.h>
  36#include <linux/mm.h>
  37#include <asm/div64.h>
  38#include "cifsfs.h"
  39#include "cifspdu.h"
  40#include "cifsglob.h"
  41#include "cifsproto.h"
 
  42#include "cifs_unicode.h"
  43#include "cifs_debug.h"
  44#include "cifs_fs_sb.h"
  45#include "fscache.h"
  46#include "smbdirect.h"
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  47
  48static inline int cifs_convert_flags(unsigned int flags)
  49{
  50	if ((flags & O_ACCMODE) == O_RDONLY)
  51		return GENERIC_READ;
  52	else if ((flags & O_ACCMODE) == O_WRONLY)
  53		return GENERIC_WRITE;
  54	else if ((flags & O_ACCMODE) == O_RDWR) {
  55		/* GENERIC_ALL is too much permission to request
  56		   can cause unnecessary access denied on create */
  57		/* return GENERIC_ALL; */
  58		return (GENERIC_READ | GENERIC_WRITE);
  59	}
  60
  61	return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
  62		FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
  63		FILE_READ_DATA);
  64}
  65
 
  66static u32 cifs_posix_convert_flags(unsigned int flags)
  67{
  68	u32 posix_flags = 0;
  69
  70	if ((flags & O_ACCMODE) == O_RDONLY)
  71		posix_flags = SMB_O_RDONLY;
  72	else if ((flags & O_ACCMODE) == O_WRONLY)
  73		posix_flags = SMB_O_WRONLY;
  74	else if ((flags & O_ACCMODE) == O_RDWR)
  75		posix_flags = SMB_O_RDWR;
  76
  77	if (flags & O_CREAT) {
  78		posix_flags |= SMB_O_CREAT;
  79		if (flags & O_EXCL)
  80			posix_flags |= SMB_O_EXCL;
  81	} else if (flags & O_EXCL)
  82		cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
  83			 current->comm, current->tgid);
  84
  85	if (flags & O_TRUNC)
  86		posix_flags |= SMB_O_TRUNC;
  87	/* be safe and imply O_SYNC for O_DSYNC */
  88	if (flags & O_DSYNC)
  89		posix_flags |= SMB_O_SYNC;
  90	if (flags & O_DIRECTORY)
  91		posix_flags |= SMB_O_DIRECTORY;
  92	if (flags & O_NOFOLLOW)
  93		posix_flags |= SMB_O_NOFOLLOW;
  94	if (flags & O_DIRECT)
  95		posix_flags |= SMB_O_DIRECT;
  96
  97	return posix_flags;
  98}
 
  99
 100static inline int cifs_get_disposition(unsigned int flags)
 101{
 102	if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 103		return FILE_CREATE;
 104	else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
 105		return FILE_OVERWRITE_IF;
 106	else if ((flags & O_CREAT) == O_CREAT)
 107		return FILE_OPEN_IF;
 108	else if ((flags & O_TRUNC) == O_TRUNC)
 109		return FILE_OVERWRITE;
 110	else
 111		return FILE_OPEN;
 112}
 113
 114int cifs_posix_open(char *full_path, struct inode **pinode,
 
 115			struct super_block *sb, int mode, unsigned int f_flags,
 116			__u32 *poplock, __u16 *pnetfid, unsigned int xid)
 117{
 118	int rc;
 119	FILE_UNIX_BASIC_INFO *presp_data;
 120	__u32 posix_flags = 0;
 121	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 122	struct cifs_fattr fattr;
 123	struct tcon_link *tlink;
 124	struct cifs_tcon *tcon;
 125
 126	cifs_dbg(FYI, "posix open %s\n", full_path);
 127
 128	presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
 129	if (presp_data == NULL)
 130		return -ENOMEM;
 131
 132	tlink = cifs_sb_tlink(cifs_sb);
 133	if (IS_ERR(tlink)) {
 134		rc = PTR_ERR(tlink);
 135		goto posix_open_ret;
 136	}
 137
 138	tcon = tlink_tcon(tlink);
 139	mode &= ~current_umask();
 140
 141	posix_flags = cifs_posix_convert_flags(f_flags);
 142	rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
 143			     poplock, full_path, cifs_sb->local_nls,
 144			     cifs_remap(cifs_sb));
 145	cifs_put_tlink(tlink);
 146
 147	if (rc)
 148		goto posix_open_ret;
 149
 150	if (presp_data->Type == cpu_to_le32(-1))
 151		goto posix_open_ret; /* open ok, caller does qpathinfo */
 152
 153	if (!pinode)
 154		goto posix_open_ret; /* caller does not need info */
 155
 156	cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
 157
 158	/* get new inode and set it up */
 159	if (*pinode == NULL) {
 160		cifs_fill_uniqueid(sb, &fattr);
 161		*pinode = cifs_iget(sb, &fattr);
 162		if (!*pinode) {
 163			rc = -ENOMEM;
 164			goto posix_open_ret;
 165		}
 166	} else {
 167		cifs_fattr_to_inode(*pinode, &fattr);
 
 168	}
 169
 170posix_open_ret:
 171	kfree(presp_data);
 172	return rc;
 173}
 
 174
 175static int
 176cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
 177	     struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
 178	     struct cifs_fid *fid, unsigned int xid)
 179{
 180	int rc;
 181	int desired_access;
 182	int disposition;
 183	int create_options = CREATE_NOT_DIR;
 184	FILE_ALL_INFO *buf;
 185	struct TCP_Server_Info *server = tcon->ses->server;
 186	struct cifs_open_parms oparms;
 187
 188	if (!server->ops->open)
 189		return -ENOSYS;
 190
 191	desired_access = cifs_convert_flags(f_flags);
 192
 193/*********************************************************************
 194 *  open flag mapping table:
 195 *
 196 *	POSIX Flag            CIFS Disposition
 197 *	----------            ----------------
 198 *	O_CREAT               FILE_OPEN_IF
 199 *	O_CREAT | O_EXCL      FILE_CREATE
 200 *	O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
 201 *	O_TRUNC               FILE_OVERWRITE
 202 *	none of the above     FILE_OPEN
 203 *
 204 *	Note that there is not a direct match between disposition
 205 *	FILE_SUPERSEDE (ie create whether or not file exists although
 206 *	O_CREAT | O_TRUNC is similar but truncates the existing
 207 *	file rather than creating a new file as FILE_SUPERSEDE does
 208 *	(which uses the attributes / metadata passed in on open call)
 209 *?
 210 *?  O_SYNC is a reasonable match to CIFS writethrough flag
 211 *?  and the read write flags match reasonably.  O_LARGEFILE
 212 *?  is irrelevant because largefile support is always used
 213 *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
 214 *	 O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
 215 *********************************************************************/
 216
 217	disposition = cifs_get_disposition(f_flags);
 218
 219	/* BB pass O_SYNC flag through on file attributes .. BB */
 220
 221	buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 222	if (!buf)
 223		return -ENOMEM;
 224
 225	if (backup_cred(cifs_sb))
 226		create_options |= CREATE_OPEN_BACKUP_INTENT;
 227
 228	/* O_SYNC also has bit for O_DSYNC so following check picks up either */
 229	if (f_flags & O_SYNC)
 230		create_options |= CREATE_WRITE_THROUGH;
 231
 232	if (f_flags & O_DIRECT)
 233		create_options |= CREATE_NO_BUFFER;
 234
 235	oparms.tcon = tcon;
 236	oparms.cifs_sb = cifs_sb;
 237	oparms.desired_access = desired_access;
 238	oparms.create_options = create_options;
 239	oparms.disposition = disposition;
 240	oparms.path = full_path;
 241	oparms.fid = fid;
 242	oparms.reconnect = false;
 243
 244	rc = server->ops->open(xid, &oparms, oplock, buf);
 245
 246	if (rc)
 247		goto out;
 248
 
 249	if (tcon->unix_ext)
 250		rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
 251					      xid);
 252	else
 253		rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
 254					 xid, fid);
 255
 256	if (rc) {
 257		server->ops->close(xid, tcon, fid);
 258		if (rc == -ESTALE)
 259			rc = -EOPENSTALE;
 260	}
 261
 262out:
 263	kfree(buf);
 264	return rc;
 265}
 266
 267static bool
 268cifs_has_mand_locks(struct cifsInodeInfo *cinode)
 269{
 270	struct cifs_fid_locks *cur;
 271	bool has_locks = false;
 272
 273	down_read(&cinode->lock_sem);
 274	list_for_each_entry(cur, &cinode->llist, llist) {
 275		if (!list_empty(&cur->locks)) {
 276			has_locks = true;
 277			break;
 278		}
 279	}
 280	up_read(&cinode->lock_sem);
 281	return has_locks;
 282}
 283
 284void
 285cifs_down_write(struct rw_semaphore *sem)
 286{
 287	while (!down_write_trylock(sem))
 288		msleep(10);
 289}
 290
 291struct cifsFileInfo *
 292cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
 293		  struct tcon_link *tlink, __u32 oplock)
 
 
 294{
 295	struct dentry *dentry = file_dentry(file);
 296	struct inode *inode = d_inode(dentry);
 297	struct cifsInodeInfo *cinode = CIFS_I(inode);
 298	struct cifsFileInfo *cfile;
 299	struct cifs_fid_locks *fdlocks;
 300	struct cifs_tcon *tcon = tlink_tcon(tlink);
 301	struct TCP_Server_Info *server = tcon->ses->server;
 302
 303	cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
 304	if (cfile == NULL)
 305		return cfile;
 306
 307	fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
 308	if (!fdlocks) {
 309		kfree(cfile);
 310		return NULL;
 311	}
 312
 
 
 
 
 
 
 
 
 
 313	INIT_LIST_HEAD(&fdlocks->locks);
 314	fdlocks->cfile = cfile;
 315	cfile->llist = fdlocks;
 316	cifs_down_write(&cinode->lock_sem);
 317	list_add(&fdlocks->llist, &cinode->llist);
 318	up_write(&cinode->lock_sem);
 319
 320	cfile->count = 1;
 321	cfile->pid = current->tgid;
 322	cfile->uid = current_fsuid();
 323	cfile->dentry = dget(dentry);
 324	cfile->f_flags = file->f_flags;
 325	cfile->invalidHandle = false;
 
 326	cfile->tlink = cifs_get_tlink(tlink);
 327	INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
 
 
 328	mutex_init(&cfile->fh_mutex);
 329	spin_lock_init(&cfile->file_info_lock);
 330
 331	cifs_sb_active(inode->i_sb);
 332
 333	/*
 334	 * If the server returned a read oplock and we have mandatory brlocks,
 335	 * set oplock level to None.
 336	 */
 337	if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
 338		cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
 339		oplock = 0;
 340	}
 341
 
 
 
 
 342	spin_lock(&tcon->open_file_lock);
 343	if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
 344		oplock = fid->pending_open->oplock;
 345	list_del(&fid->pending_open->olist);
 346
 347	fid->purge_cache = false;
 348	server->ops->set_fid(cfile, fid, oplock);
 349
 350	list_add(&cfile->tlist, &tcon->openFileList);
 351	atomic_inc(&tcon->num_local_opens);
 352
 353	/* if readable file instance put first in list*/
 354	spin_lock(&cinode->open_file_lock);
 355	if (file->f_mode & FMODE_READ)
 356		list_add(&cfile->flist, &cinode->openFileList);
 357	else
 358		list_add_tail(&cfile->flist, &cinode->openFileList);
 359	spin_unlock(&cinode->open_file_lock);
 360	spin_unlock(&tcon->open_file_lock);
 361
 362	if (fid->purge_cache)
 363		cifs_zap_mapping(inode);
 364
 365	file->private_data = cfile;
 366	return cfile;
 367}
 368
 369struct cifsFileInfo *
 370cifsFileInfo_get(struct cifsFileInfo *cifs_file)
 371{
 372	spin_lock(&cifs_file->file_info_lock);
 373	cifsFileInfo_get_locked(cifs_file);
 374	spin_unlock(&cifs_file->file_info_lock);
 375	return cifs_file;
 376}
 377
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 378/**
 379 * cifsFileInfo_put - release a reference of file priv data
 380 *
 381 * Always potentially wait for oplock handler. See _cifsFileInfo_put().
 
 
 382 */
 383void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 384{
 385	_cifsFileInfo_put(cifs_file, true);
 386}
 387
 388/**
 389 * _cifsFileInfo_put - release a reference of file priv data
 390 *
 391 * This may involve closing the filehandle @cifs_file out on the
 392 * server. Must be called without holding tcon->open_file_lock and
 393 * cifs_file->file_info_lock.
 394 *
 395 * If @wait_for_oplock_handler is true and we are releasing the last
 396 * reference, wait for any running oplock break handler of the file
 397 * and cancel any pending one. If calling this function from the
 398 * oplock break handler, you need to pass false.
 
 
 
 399 *
 400 */
 401void _cifsFileInfo_put(struct cifsFileInfo *cifs_file, bool wait_oplock_handler)
 
 402{
 403	struct inode *inode = d_inode(cifs_file->dentry);
 404	struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
 405	struct TCP_Server_Info *server = tcon->ses->server;
 406	struct cifsInodeInfo *cifsi = CIFS_I(inode);
 407	struct super_block *sb = inode->i_sb;
 408	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 409	struct cifsLockInfo *li, *tmp;
 410	struct cifs_fid fid;
 411	struct cifs_pending_open open;
 412	bool oplock_break_cancelled;
 413
 414	spin_lock(&tcon->open_file_lock);
 415	spin_lock(&cifsi->open_file_lock);
 416	spin_lock(&cifs_file->file_info_lock);
 417	if (--cifs_file->count > 0) {
 418		spin_unlock(&cifs_file->file_info_lock);
 419		spin_unlock(&cifsi->open_file_lock);
 420		spin_unlock(&tcon->open_file_lock);
 421		return;
 422	}
 423	spin_unlock(&cifs_file->file_info_lock);
 424
 425	if (server->ops->get_lease_key)
 426		server->ops->get_lease_key(inode, &fid);
 427
 428	/* store open in pending opens to make sure we don't miss lease break */
 429	cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
 430
 431	/* remove it from the lists */
 432	list_del(&cifs_file->flist);
 433	list_del(&cifs_file->tlist);
 434	atomic_dec(&tcon->num_local_opens);
 435
 436	if (list_empty(&cifsi->openFileList)) {
 437		cifs_dbg(FYI, "closing last open instance for inode %p\n",
 438			 d_inode(cifs_file->dentry));
 439		/*
 440		 * In strict cache mode we need invalidate mapping on the last
 441		 * close  because it may cause a error when we open this file
 442		 * again and get at least level II oplock.
 443		 */
 444		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 445			set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
 446		cifs_set_oplock_level(cifsi, 0);
 447	}
 448
 449	spin_unlock(&cifsi->open_file_lock);
 450	spin_unlock(&tcon->open_file_lock);
 451
 452	oplock_break_cancelled = wait_oplock_handler ?
 453		cancel_work_sync(&cifs_file->oplock_break) : false;
 454
 455	if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
 456		struct TCP_Server_Info *server = tcon->ses->server;
 457		unsigned int xid;
 458
 459		xid = get_xid();
 460		if (server->ops->close)
 
 
 461			server->ops->close(xid, tcon, &cifs_file->fid);
 462		_free_xid(xid);
 463	}
 464
 465	if (oplock_break_cancelled)
 466		cifs_done_oplock_break(cifsi);
 467
 468	cifs_del_pending_open(&open);
 469
 470	/*
 471	 * Delete any outstanding lock records. We'll lose them when the file
 472	 * is closed anyway.
 473	 */
 474	cifs_down_write(&cifsi->lock_sem);
 475	list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
 476		list_del(&li->llist);
 477		cifs_del_lock_waiters(li);
 478		kfree(li);
 479	}
 480	list_del(&cifs_file->llist->llist);
 481	kfree(cifs_file->llist);
 482	up_write(&cifsi->lock_sem);
 483
 484	cifs_put_tlink(cifs_file->tlink);
 485	dput(cifs_file->dentry);
 486	cifs_sb_deactive(sb);
 487	kfree(cifs_file);
 488}
 489
 490int cifs_open(struct inode *inode, struct file *file)
 491
 492{
 493	int rc = -EACCES;
 494	unsigned int xid;
 495	__u32 oplock;
 496	struct cifs_sb_info *cifs_sb;
 497	struct TCP_Server_Info *server;
 498	struct cifs_tcon *tcon;
 499	struct tcon_link *tlink;
 500	struct cifsFileInfo *cfile = NULL;
 501	char *full_path = NULL;
 
 502	bool posix_open_ok = false;
 503	struct cifs_fid fid;
 504	struct cifs_pending_open open;
 
 505
 506	xid = get_xid();
 507
 508	cifs_sb = CIFS_SB(inode->i_sb);
 
 
 
 
 
 509	tlink = cifs_sb_tlink(cifs_sb);
 510	if (IS_ERR(tlink)) {
 511		free_xid(xid);
 512		return PTR_ERR(tlink);
 513	}
 514	tcon = tlink_tcon(tlink);
 515	server = tcon->ses->server;
 516
 517	full_path = build_path_from_dentry(file_dentry(file));
 518	if (full_path == NULL) {
 519		rc = -ENOMEM;
 
 520		goto out;
 521	}
 522
 523	cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
 524		 inode, file->f_flags, full_path);
 525
 526	if (file->f_flags & O_DIRECT &&
 527	    cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
 528		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 529			file->f_op = &cifs_file_direct_nobrl_ops;
 530		else
 531			file->f_op = &cifs_file_direct_ops;
 532	}
 533
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 534	if (server->oplocks)
 535		oplock = REQ_OPLOCK;
 536	else
 537		oplock = 0;
 538
 
 539	if (!tcon->broken_posix_open && tcon->unix_ext &&
 540	    cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 541				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 542		/* can not refresh inode info since size could be stale */
 543		rc = cifs_posix_open(full_path, &inode, inode->i_sb,
 544				cifs_sb->mnt_file_mode /* ignored */,
 545				file->f_flags, &oplock, &fid.netfid, xid);
 546		if (rc == 0) {
 547			cifs_dbg(FYI, "posix open succeeded\n");
 548			posix_open_ok = true;
 549		} else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
 550			if (tcon->ses->serverNOS)
 551				cifs_dbg(VFS, "server %s of type %s returned unexpected error on SMB posix open, disabling posix open support. Check if server update available.\n",
 552					 tcon->ses->serverName,
 553					 tcon->ses->serverNOS);
 554			tcon->broken_posix_open = true;
 555		} else if ((rc != -EIO) && (rc != -EREMOTE) &&
 556			 (rc != -EOPNOTSUPP)) /* path not found or net err */
 557			goto out;
 558		/*
 559		 * Else fallthrough to retry open the old way on network i/o
 560		 * or DFS errors.
 561		 */
 562	}
 
 563
 564	if (server->ops->get_lease_key)
 565		server->ops->get_lease_key(inode, &fid);
 566
 567	cifs_add_pending_open(&fid, tlink, &open);
 568
 569	if (!posix_open_ok) {
 570		if (server->ops->get_lease_key)
 571			server->ops->get_lease_key(inode, &fid);
 572
 573		rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
 574				  file->f_flags, &oplock, &fid, xid);
 575		if (rc) {
 576			cifs_del_pending_open(&open);
 577			goto out;
 578		}
 579	}
 580
 581	cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
 582	if (cfile == NULL) {
 583		if (server->ops->close)
 584			server->ops->close(xid, tcon, &fid);
 585		cifs_del_pending_open(&open);
 586		rc = -ENOMEM;
 587		goto out;
 588	}
 589
 590	cifs_fscache_set_inode_cookie(inode, file);
 591
 592	if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
 593		/*
 594		 * Time to set mode which we can not set earlier due to
 595		 * problems creating new read-only files.
 596		 */
 597		struct cifs_unix_set_info_args args = {
 598			.mode	= inode->i_mode,
 599			.uid	= INVALID_UID, /* no change */
 600			.gid	= INVALID_GID, /* no change */
 601			.ctime	= NO_CHANGE_64,
 602			.atime	= NO_CHANGE_64,
 603			.mtime	= NO_CHANGE_64,
 604			.device	= 0,
 605		};
 606		CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
 607				       cfile->pid);
 608	}
 
 
 
 
 
 
 
 
 
 
 609
 610out:
 611	kfree(full_path);
 612	free_xid(xid);
 613	cifs_put_tlink(tlink);
 
 614	return rc;
 615}
 616
 
 617static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
 
 618
 619/*
 620 * Try to reacquire byte range locks that were released when session
 621 * to server was lost.
 622 */
 623static int
 624cifs_relock_file(struct cifsFileInfo *cfile)
 625{
 626	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
 627	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 628	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 629	int rc = 0;
 
 
 
 630
 631	down_read_nested(&cinode->lock_sem, SINGLE_DEPTH_NESTING);
 632	if (cinode->can_cache_brlcks) {
 633		/* can cache locks - no need to relock */
 634		up_read(&cinode->lock_sem);
 635		return rc;
 636	}
 637
 
 638	if (cap_unix(tcon->ses) &&
 639	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
 640	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
 641		rc = cifs_push_posix_locks(cfile);
 642	else
 
 643		rc = tcon->ses->server->ops->push_mand_locks(cfile);
 644
 645	up_read(&cinode->lock_sem);
 646	return rc;
 647}
 648
 649static int
 650cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
 651{
 652	int rc = -EACCES;
 653	unsigned int xid;
 654	__u32 oplock;
 655	struct cifs_sb_info *cifs_sb;
 656	struct cifs_tcon *tcon;
 657	struct TCP_Server_Info *server;
 658	struct cifsInodeInfo *cinode;
 659	struct inode *inode;
 660	char *full_path = NULL;
 
 661	int desired_access;
 662	int disposition = FILE_OPEN;
 663	int create_options = CREATE_NOT_DIR;
 664	struct cifs_open_parms oparms;
 665
 666	xid = get_xid();
 667	mutex_lock(&cfile->fh_mutex);
 668	if (!cfile->invalidHandle) {
 669		mutex_unlock(&cfile->fh_mutex);
 670		rc = 0;
 671		free_xid(xid);
 672		return rc;
 673	}
 674
 675	inode = d_inode(cfile->dentry);
 676	cifs_sb = CIFS_SB(inode->i_sb);
 677	tcon = tlink_tcon(cfile->tlink);
 678	server = tcon->ses->server;
 679
 680	/*
 681	 * Can not grab rename sem here because various ops, including those
 682	 * that already have the rename sem can end up causing writepage to get
 683	 * called and if the server was down that means we end up here, and we
 684	 * can never tell if the caller already has the rename_sem.
 685	 */
 686	full_path = build_path_from_dentry(cfile->dentry);
 687	if (full_path == NULL) {
 688		rc = -ENOMEM;
 689		mutex_unlock(&cfile->fh_mutex);
 
 690		free_xid(xid);
 691		return rc;
 692	}
 693
 694	cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
 695		 inode, cfile->f_flags, full_path);
 696
 697	if (tcon->ses->server->oplocks)
 698		oplock = REQ_OPLOCK;
 699	else
 700		oplock = 0;
 701
 
 702	if (tcon->unix_ext && cap_unix(tcon->ses) &&
 703	    (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 704				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 705		/*
 706		 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
 707		 * original open. Must mask them off for a reopen.
 708		 */
 709		unsigned int oflags = cfile->f_flags &
 710						~(O_CREAT | O_EXCL | O_TRUNC);
 711
 712		rc = cifs_posix_open(full_path, NULL, inode->i_sb,
 713				     cifs_sb->mnt_file_mode /* ignored */,
 714				     oflags, &oplock, &cfile->fid.netfid, xid);
 715		if (rc == 0) {
 716			cifs_dbg(FYI, "posix reopen succeeded\n");
 717			oparms.reconnect = true;
 718			goto reopen_success;
 719		}
 720		/*
 721		 * fallthrough to retry open the old way on errors, especially
 722		 * in the reconnect path it is important to retry hard
 723		 */
 724	}
 
 725
 726	desired_access = cifs_convert_flags(cfile->f_flags);
 727
 728	if (backup_cred(cifs_sb))
 729		create_options |= CREATE_OPEN_BACKUP_INTENT;
 
 
 
 
 730
 731	if (server->ops->get_lease_key)
 732		server->ops->get_lease_key(inode, &cfile->fid);
 733
 734	oparms.tcon = tcon;
 735	oparms.cifs_sb = cifs_sb;
 736	oparms.desired_access = desired_access;
 737	oparms.create_options = create_options;
 738	oparms.disposition = disposition;
 739	oparms.path = full_path;
 740	oparms.fid = &cfile->fid;
 741	oparms.reconnect = true;
 742
 743	/*
 744	 * Can not refresh inode by passing in file_info buf to be returned by
 745	 * ops->open and then calling get_inode_info with returned buf since
 746	 * file might have write behind data that needs to be flushed and server
 747	 * version of file size can be stale. If we knew for sure that inode was
 748	 * not dirty locally we could do this.
 749	 */
 750	rc = server->ops->open(xid, &oparms, &oplock, NULL);
 751	if (rc == -ENOENT && oparms.reconnect == false) {
 752		/* durable handle timeout is expired - open the file again */
 753		rc = server->ops->open(xid, &oparms, &oplock, NULL);
 754		/* indicate that we need to relock the file */
 755		oparms.reconnect = true;
 756	}
 757
 758	if (rc) {
 759		mutex_unlock(&cfile->fh_mutex);
 760		cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
 761		cifs_dbg(FYI, "oplock: %d\n", oplock);
 762		goto reopen_error_exit;
 763	}
 764
 
 765reopen_success:
 
 766	cfile->invalidHandle = false;
 767	mutex_unlock(&cfile->fh_mutex);
 768	cinode = CIFS_I(inode);
 769
 770	if (can_flush) {
 771		rc = filemap_write_and_wait(inode->i_mapping);
 772		if (!is_interrupt_error(rc))
 773			mapping_set_error(inode->i_mapping, rc);
 774
 775		if (tcon->unix_ext)
 
 
 776			rc = cifs_get_inode_info_unix(&inode, full_path,
 777						      inode->i_sb, xid);
 778		else
 779			rc = cifs_get_inode_info(&inode, full_path, NULL,
 780						 inode->i_sb, xid, NULL);
 781	}
 782	/*
 783	 * Else we are writing out data to server already and could deadlock if
 784	 * we tried to flush data, and since we do not know if we have data that
 785	 * would invalidate the current end of file on the server we can not go
 786	 * to the server to get the new inode info.
 787	 */
 788
 789	/*
 790	 * If the server returned a read oplock and we have mandatory brlocks,
 791	 * set oplock level to None.
 792	 */
 793	if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
 794		cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
 795		oplock = 0;
 796	}
 797
 798	server->ops->set_fid(cfile, &cfile->fid, oplock);
 799	if (oparms.reconnect)
 800		cifs_relock_file(cfile);
 801
 802reopen_error_exit:
 803	kfree(full_path);
 804	free_xid(xid);
 805	return rc;
 806}
 807
 
 
 
 
 
 
 
 
 
 
 
 
 808int cifs_close(struct inode *inode, struct file *file)
 809{
 
 
 
 
 
 
 
 810	if (file->private_data != NULL) {
 811		cifsFileInfo_put(file->private_data);
 812		file->private_data = NULL;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 813	}
 814
 815	/* return code from the ->release op is always ignored */
 816	return 0;
 817}
 818
 819void
 820cifs_reopen_persistent_handles(struct cifs_tcon *tcon)
 821{
 822	struct cifsFileInfo *open_file;
 823	struct list_head *tmp;
 824	struct list_head *tmp1;
 825	struct list_head tmp_list;
 826
 827	if (!tcon->use_persistent || !tcon->need_reopen_files)
 828		return;
 829
 830	tcon->need_reopen_files = false;
 831
 832	cifs_dbg(FYI, "Reopen persistent handles");
 833	INIT_LIST_HEAD(&tmp_list);
 834
 835	/* list all files open on tree connection, reopen resilient handles  */
 836	spin_lock(&tcon->open_file_lock);
 837	list_for_each(tmp, &tcon->openFileList) {
 838		open_file = list_entry(tmp, struct cifsFileInfo, tlist);
 839		if (!open_file->invalidHandle)
 840			continue;
 841		cifsFileInfo_get(open_file);
 842		list_add_tail(&open_file->rlist, &tmp_list);
 843	}
 844	spin_unlock(&tcon->open_file_lock);
 845
 846	list_for_each_safe(tmp, tmp1, &tmp_list) {
 847		open_file = list_entry(tmp, struct cifsFileInfo, rlist);
 848		if (cifs_reopen_file(open_file, false /* do not flush */))
 849			tcon->need_reopen_files = true;
 850		list_del_init(&open_file->rlist);
 851		cifsFileInfo_put(open_file);
 852	}
 853}
 854
 855int cifs_closedir(struct inode *inode, struct file *file)
 856{
 857	int rc = 0;
 858	unsigned int xid;
 859	struct cifsFileInfo *cfile = file->private_data;
 860	struct cifs_tcon *tcon;
 861	struct TCP_Server_Info *server;
 862	char *buf;
 863
 864	cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
 865
 866	if (cfile == NULL)
 867		return rc;
 868
 869	xid = get_xid();
 870	tcon = tlink_tcon(cfile->tlink);
 871	server = tcon->ses->server;
 872
 873	cifs_dbg(FYI, "Freeing private data in close dir\n");
 874	spin_lock(&cfile->file_info_lock);
 875	if (server->ops->dir_needs_close(cfile)) {
 876		cfile->invalidHandle = true;
 877		spin_unlock(&cfile->file_info_lock);
 878		if (server->ops->close_dir)
 879			rc = server->ops->close_dir(xid, tcon, &cfile->fid);
 880		else
 881			rc = -ENOSYS;
 882		cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
 883		/* not much we can do if it fails anyway, ignore rc */
 884		rc = 0;
 885	} else
 886		spin_unlock(&cfile->file_info_lock);
 887
 888	buf = cfile->srch_inf.ntwrk_buf_start;
 889	if (buf) {
 890		cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
 891		cfile->srch_inf.ntwrk_buf_start = NULL;
 892		if (cfile->srch_inf.smallBuf)
 893			cifs_small_buf_release(buf);
 894		else
 895			cifs_buf_release(buf);
 896	}
 897
 898	cifs_put_tlink(cfile->tlink);
 899	kfree(file->private_data);
 900	file->private_data = NULL;
 901	/* BB can we lock the filestruct while this is going on? */
 902	free_xid(xid);
 903	return rc;
 904}
 905
 906static struct cifsLockInfo *
 907cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 flags)
 908{
 909	struct cifsLockInfo *lock =
 910		kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
 911	if (!lock)
 912		return lock;
 913	lock->offset = offset;
 914	lock->length = length;
 915	lock->type = type;
 916	lock->pid = current->tgid;
 917	lock->flags = flags;
 918	INIT_LIST_HEAD(&lock->blist);
 919	init_waitqueue_head(&lock->block_q);
 920	return lock;
 921}
 922
 923void
 924cifs_del_lock_waiters(struct cifsLockInfo *lock)
 925{
 926	struct cifsLockInfo *li, *tmp;
 927	list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
 928		list_del_init(&li->blist);
 929		wake_up(&li->block_q);
 930	}
 931}
 932
 933#define CIFS_LOCK_OP	0
 934#define CIFS_READ_OP	1
 935#define CIFS_WRITE_OP	2
 936
 937/* @rw_check : 0 - no op, 1 - read, 2 - write */
 938static bool
 939cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
 940			    __u64 length, __u8 type, __u16 flags,
 941			    struct cifsFileInfo *cfile,
 942			    struct cifsLockInfo **conf_lock, int rw_check)
 943{
 944	struct cifsLockInfo *li;
 945	struct cifsFileInfo *cur_cfile = fdlocks->cfile;
 946	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
 947
 948	list_for_each_entry(li, &fdlocks->locks, llist) {
 949		if (offset + length <= li->offset ||
 950		    offset >= li->offset + li->length)
 951			continue;
 952		if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
 953		    server->ops->compare_fids(cfile, cur_cfile)) {
 954			/* shared lock prevents write op through the same fid */
 955			if (!(li->type & server->vals->shared_lock_type) ||
 956			    rw_check != CIFS_WRITE_OP)
 957				continue;
 958		}
 959		if ((type & server->vals->shared_lock_type) &&
 960		    ((server->ops->compare_fids(cfile, cur_cfile) &&
 961		     current->tgid == li->pid) || type == li->type))
 962			continue;
 963		if (rw_check == CIFS_LOCK_OP &&
 964		    (flags & FL_OFDLCK) && (li->flags & FL_OFDLCK) &&
 965		    server->ops->compare_fids(cfile, cur_cfile))
 966			continue;
 967		if (conf_lock)
 968			*conf_lock = li;
 969		return true;
 970	}
 971	return false;
 972}
 973
 974bool
 975cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
 976			__u8 type, __u16 flags,
 977			struct cifsLockInfo **conf_lock, int rw_check)
 978{
 979	bool rc = false;
 980	struct cifs_fid_locks *cur;
 981	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 982
 983	list_for_each_entry(cur, &cinode->llist, llist) {
 984		rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
 985						 flags, cfile, conf_lock,
 986						 rw_check);
 987		if (rc)
 988			break;
 989	}
 990
 991	return rc;
 992}
 993
 994/*
 995 * Check if there is another lock that prevents us to set the lock (mandatory
 996 * style). If such a lock exists, update the flock structure with its
 997 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
 998 * or leave it the same if we can't. Returns 0 if we don't need to request to
 999 * the server or 1 otherwise.
1000 */
1001static int
1002cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
1003	       __u8 type, struct file_lock *flock)
1004{
1005	int rc = 0;
1006	struct cifsLockInfo *conf_lock;
1007	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1008	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1009	bool exist;
1010
1011	down_read(&cinode->lock_sem);
1012
1013	exist = cifs_find_lock_conflict(cfile, offset, length, type,
1014					flock->fl_flags, &conf_lock,
1015					CIFS_LOCK_OP);
1016	if (exist) {
1017		flock->fl_start = conf_lock->offset;
1018		flock->fl_end = conf_lock->offset + conf_lock->length - 1;
1019		flock->fl_pid = conf_lock->pid;
1020		if (conf_lock->type & server->vals->shared_lock_type)
1021			flock->fl_type = F_RDLCK;
1022		else
1023			flock->fl_type = F_WRLCK;
1024	} else if (!cinode->can_cache_brlcks)
1025		rc = 1;
1026	else
1027		flock->fl_type = F_UNLCK;
1028
1029	up_read(&cinode->lock_sem);
1030	return rc;
1031}
1032
1033static void
1034cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
1035{
1036	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1037	cifs_down_write(&cinode->lock_sem);
1038	list_add_tail(&lock->llist, &cfile->llist->locks);
1039	up_write(&cinode->lock_sem);
1040}
1041
1042/*
1043 * Set the byte-range lock (mandatory style). Returns:
1044 * 1) 0, if we set the lock and don't need to request to the server;
1045 * 2) 1, if no locks prevent us but we need to request to the server;
1046 * 3) -EACCES, if there is a lock that prevents us and wait is false.
1047 */
1048static int
1049cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
1050		 bool wait)
1051{
1052	struct cifsLockInfo *conf_lock;
1053	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1054	bool exist;
1055	int rc = 0;
1056
1057try_again:
1058	exist = false;
1059	cifs_down_write(&cinode->lock_sem);
1060
1061	exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
1062					lock->type, lock->flags, &conf_lock,
1063					CIFS_LOCK_OP);
1064	if (!exist && cinode->can_cache_brlcks) {
1065		list_add_tail(&lock->llist, &cfile->llist->locks);
1066		up_write(&cinode->lock_sem);
1067		return rc;
1068	}
1069
1070	if (!exist)
1071		rc = 1;
1072	else if (!wait)
1073		rc = -EACCES;
1074	else {
1075		list_add_tail(&lock->blist, &conf_lock->blist);
1076		up_write(&cinode->lock_sem);
1077		rc = wait_event_interruptible(lock->block_q,
1078					(lock->blist.prev == &lock->blist) &&
1079					(lock->blist.next == &lock->blist));
1080		if (!rc)
1081			goto try_again;
1082		cifs_down_write(&cinode->lock_sem);
1083		list_del_init(&lock->blist);
1084	}
1085
1086	up_write(&cinode->lock_sem);
1087	return rc;
1088}
1089
 
1090/*
1091 * Check if there is another lock that prevents us to set the lock (posix
1092 * style). If such a lock exists, update the flock structure with its
1093 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1094 * or leave it the same if we can't. Returns 0 if we don't need to request to
1095 * the server or 1 otherwise.
1096 */
1097static int
1098cifs_posix_lock_test(struct file *file, struct file_lock *flock)
1099{
1100	int rc = 0;
1101	struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1102	unsigned char saved_type = flock->fl_type;
1103
1104	if ((flock->fl_flags & FL_POSIX) == 0)
1105		return 1;
1106
1107	down_read(&cinode->lock_sem);
1108	posix_test_lock(file, flock);
1109
1110	if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
1111		flock->fl_type = saved_type;
1112		rc = 1;
1113	}
1114
1115	up_read(&cinode->lock_sem);
1116	return rc;
1117}
1118
1119/*
1120 * Set the byte-range lock (posix style). Returns:
1121 * 1) 0, if we set the lock and don't need to request to the server;
1122 * 2) 1, if we need to request to the server;
1123 * 3) <0, if the error occurs while setting the lock.
 
1124 */
1125static int
1126cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1127{
1128	struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1129	int rc = 1;
1130
1131	if ((flock->fl_flags & FL_POSIX) == 0)
1132		return rc;
1133
1134try_again:
1135	cifs_down_write(&cinode->lock_sem);
1136	if (!cinode->can_cache_brlcks) {
1137		up_write(&cinode->lock_sem);
1138		return rc;
1139	}
1140
1141	rc = posix_lock_file(file, flock, NULL);
1142	up_write(&cinode->lock_sem);
1143	if (rc == FILE_LOCK_DEFERRED) {
1144		rc = wait_event_interruptible(flock->fl_wait, !flock->fl_blocker);
1145		if (!rc)
1146			goto try_again;
1147		locks_delete_block(flock);
1148	}
1149	return rc;
1150}
1151
1152int
1153cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1154{
1155	unsigned int xid;
1156	int rc = 0, stored_rc;
1157	struct cifsLockInfo *li, *tmp;
1158	struct cifs_tcon *tcon;
1159	unsigned int num, max_num, max_buf;
1160	LOCKING_ANDX_RANGE *buf, *cur;
1161	static const int types[] = {
1162		LOCKING_ANDX_LARGE_FILES,
1163		LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
1164	};
1165	int i;
1166
1167	xid = get_xid();
1168	tcon = tlink_tcon(cfile->tlink);
1169
1170	/*
1171	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1172	 * and check it before using.
1173	 */
1174	max_buf = tcon->ses->server->maxBuf;
1175	if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) {
1176		free_xid(xid);
1177		return -EINVAL;
1178	}
1179
1180	BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
1181		     PAGE_SIZE);
1182	max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
1183			PAGE_SIZE);
1184	max_num = (max_buf - sizeof(struct smb_hdr)) /
1185						sizeof(LOCKING_ANDX_RANGE);
1186	buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1187	if (!buf) {
1188		free_xid(xid);
1189		return -ENOMEM;
1190	}
1191
1192	for (i = 0; i < 2; i++) {
1193		cur = buf;
1194		num = 0;
1195		list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1196			if (li->type != types[i])
1197				continue;
1198			cur->Pid = cpu_to_le16(li->pid);
1199			cur->LengthLow = cpu_to_le32((u32)li->length);
1200			cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1201			cur->OffsetLow = cpu_to_le32((u32)li->offset);
1202			cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1203			if (++num == max_num) {
1204				stored_rc = cifs_lockv(xid, tcon,
1205						       cfile->fid.netfid,
1206						       (__u8)li->type, 0, num,
1207						       buf);
1208				if (stored_rc)
1209					rc = stored_rc;
1210				cur = buf;
1211				num = 0;
1212			} else
1213				cur++;
1214		}
1215
1216		if (num) {
1217			stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1218					       (__u8)types[i], 0, num, buf);
1219			if (stored_rc)
1220				rc = stored_rc;
1221		}
1222	}
1223
1224	kfree(buf);
1225	free_xid(xid);
1226	return rc;
1227}
1228
1229static __u32
1230hash_lockowner(fl_owner_t owner)
1231{
1232	return cifs_lock_secret ^ hash32_ptr((const void *)owner);
1233}
 
1234
1235struct lock_to_push {
1236	struct list_head llist;
1237	__u64 offset;
1238	__u64 length;
1239	__u32 pid;
1240	__u16 netfid;
1241	__u8 type;
1242};
1243
 
1244static int
1245cifs_push_posix_locks(struct cifsFileInfo *cfile)
1246{
1247	struct inode *inode = d_inode(cfile->dentry);
1248	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1249	struct file_lock *flock;
1250	struct file_lock_context *flctx = inode->i_flctx;
1251	unsigned int count = 0, i;
1252	int rc = 0, xid, type;
1253	struct list_head locks_to_send, *el;
1254	struct lock_to_push *lck, *tmp;
1255	__u64 length;
1256
1257	xid = get_xid();
1258
1259	if (!flctx)
1260		goto out;
1261
1262	spin_lock(&flctx->flc_lock);
1263	list_for_each(el, &flctx->flc_posix) {
1264		count++;
1265	}
1266	spin_unlock(&flctx->flc_lock);
1267
1268	INIT_LIST_HEAD(&locks_to_send);
1269
1270	/*
1271	 * Allocating count locks is enough because no FL_POSIX locks can be
1272	 * added to the list while we are holding cinode->lock_sem that
1273	 * protects locking operations of this inode.
1274	 */
1275	for (i = 0; i < count; i++) {
1276		lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1277		if (!lck) {
1278			rc = -ENOMEM;
1279			goto err_out;
1280		}
1281		list_add_tail(&lck->llist, &locks_to_send);
1282	}
1283
1284	el = locks_to_send.next;
1285	spin_lock(&flctx->flc_lock);
1286	list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
1287		if (el == &locks_to_send) {
1288			/*
1289			 * The list ended. We don't have enough allocated
1290			 * structures - something is really wrong.
1291			 */
1292			cifs_dbg(VFS, "Can't push all brlocks!\n");
1293			break;
1294		}
1295		length = 1 + flock->fl_end - flock->fl_start;
1296		if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1297			type = CIFS_RDLCK;
1298		else
1299			type = CIFS_WRLCK;
1300		lck = list_entry(el, struct lock_to_push, llist);
1301		lck->pid = hash_lockowner(flock->fl_owner);
1302		lck->netfid = cfile->fid.netfid;
1303		lck->length = length;
1304		lck->type = type;
1305		lck->offset = flock->fl_start;
1306	}
1307	spin_unlock(&flctx->flc_lock);
1308
1309	list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1310		int stored_rc;
1311
1312		stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1313					     lck->offset, lck->length, NULL,
1314					     lck->type, 0);
1315		if (stored_rc)
1316			rc = stored_rc;
1317		list_del(&lck->llist);
1318		kfree(lck);
1319	}
1320
1321out:
1322	free_xid(xid);
1323	return rc;
1324err_out:
1325	list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1326		list_del(&lck->llist);
1327		kfree(lck);
1328	}
1329	goto out;
1330}
 
1331
1332static int
1333cifs_push_locks(struct cifsFileInfo *cfile)
1334{
1335	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1336	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1337	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1338	int rc = 0;
 
 
 
1339
1340	/* we are going to update can_cache_brlcks here - need a write access */
1341	cifs_down_write(&cinode->lock_sem);
1342	if (!cinode->can_cache_brlcks) {
1343		up_write(&cinode->lock_sem);
1344		return rc;
1345	}
1346
 
1347	if (cap_unix(tcon->ses) &&
1348	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1349	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1350		rc = cifs_push_posix_locks(cfile);
1351	else
 
1352		rc = tcon->ses->server->ops->push_mand_locks(cfile);
1353
1354	cinode->can_cache_brlcks = false;
1355	up_write(&cinode->lock_sem);
1356	return rc;
1357}
1358
1359static void
1360cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1361		bool *wait_flag, struct TCP_Server_Info *server)
1362{
1363	if (flock->fl_flags & FL_POSIX)
1364		cifs_dbg(FYI, "Posix\n");
1365	if (flock->fl_flags & FL_FLOCK)
1366		cifs_dbg(FYI, "Flock\n");
1367	if (flock->fl_flags & FL_SLEEP) {
1368		cifs_dbg(FYI, "Blocking lock\n");
1369		*wait_flag = true;
1370	}
1371	if (flock->fl_flags & FL_ACCESS)
1372		cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1373	if (flock->fl_flags & FL_LEASE)
1374		cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1375	if (flock->fl_flags &
1376	    (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1377	       FL_ACCESS | FL_LEASE | FL_CLOSE | FL_OFDLCK)))
1378		cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
1379
1380	*type = server->vals->large_lock_type;
1381	if (flock->fl_type == F_WRLCK) {
1382		cifs_dbg(FYI, "F_WRLCK\n");
1383		*type |= server->vals->exclusive_lock_type;
1384		*lock = 1;
1385	} else if (flock->fl_type == F_UNLCK) {
1386		cifs_dbg(FYI, "F_UNLCK\n");
1387		*type |= server->vals->unlock_lock_type;
1388		*unlock = 1;
1389		/* Check if unlock includes more than one lock range */
1390	} else if (flock->fl_type == F_RDLCK) {
1391		cifs_dbg(FYI, "F_RDLCK\n");
1392		*type |= server->vals->shared_lock_type;
1393		*lock = 1;
1394	} else if (flock->fl_type == F_EXLCK) {
1395		cifs_dbg(FYI, "F_EXLCK\n");
1396		*type |= server->vals->exclusive_lock_type;
1397		*lock = 1;
1398	} else if (flock->fl_type == F_SHLCK) {
1399		cifs_dbg(FYI, "F_SHLCK\n");
1400		*type |= server->vals->shared_lock_type;
1401		*lock = 1;
1402	} else
1403		cifs_dbg(FYI, "Unknown type of lock\n");
1404}
1405
1406static int
1407cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1408	   bool wait_flag, bool posix_lck, unsigned int xid)
1409{
1410	int rc = 0;
1411	__u64 length = 1 + flock->fl_end - flock->fl_start;
1412	struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1413	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1414	struct TCP_Server_Info *server = tcon->ses->server;
 
1415	__u16 netfid = cfile->fid.netfid;
1416
1417	if (posix_lck) {
1418		int posix_lock_type;
1419
1420		rc = cifs_posix_lock_test(file, flock);
1421		if (!rc)
1422			return rc;
1423
1424		if (type & server->vals->shared_lock_type)
1425			posix_lock_type = CIFS_RDLCK;
1426		else
1427			posix_lock_type = CIFS_WRLCK;
1428		rc = CIFSSMBPosixLock(xid, tcon, netfid,
1429				      hash_lockowner(flock->fl_owner),
1430				      flock->fl_start, length, flock,
1431				      posix_lock_type, wait_flag);
1432		return rc;
1433	}
 
1434
1435	rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1436	if (!rc)
1437		return rc;
1438
1439	/* BB we could chain these into one lock request BB */
1440	rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1441				    1, 0, false);
1442	if (rc == 0) {
1443		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1444					    type, 0, 1, false);
1445		flock->fl_type = F_UNLCK;
1446		if (rc != 0)
1447			cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1448				 rc);
1449		return 0;
1450	}
1451
1452	if (type & server->vals->shared_lock_type) {
1453		flock->fl_type = F_WRLCK;
1454		return 0;
1455	}
1456
1457	type &= ~server->vals->exclusive_lock_type;
1458
1459	rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1460				    type | server->vals->shared_lock_type,
1461				    1, 0, false);
1462	if (rc == 0) {
1463		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1464			type | server->vals->shared_lock_type, 0, 1, false);
1465		flock->fl_type = F_RDLCK;
1466		if (rc != 0)
1467			cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1468				 rc);
1469	} else
1470		flock->fl_type = F_WRLCK;
1471
1472	return 0;
1473}
1474
1475void
1476cifs_move_llist(struct list_head *source, struct list_head *dest)
1477{
1478	struct list_head *li, *tmp;
1479	list_for_each_safe(li, tmp, source)
1480		list_move(li, dest);
1481}
1482
1483void
1484cifs_free_llist(struct list_head *llist)
1485{
1486	struct cifsLockInfo *li, *tmp;
1487	list_for_each_entry_safe(li, tmp, llist, llist) {
1488		cifs_del_lock_waiters(li);
1489		list_del(&li->llist);
1490		kfree(li);
1491	}
1492}
1493
 
1494int
1495cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1496		  unsigned int xid)
1497{
1498	int rc = 0, stored_rc;
1499	static const int types[] = {
1500		LOCKING_ANDX_LARGE_FILES,
1501		LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
1502	};
1503	unsigned int i;
1504	unsigned int max_num, num, max_buf;
1505	LOCKING_ANDX_RANGE *buf, *cur;
1506	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1507	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1508	struct cifsLockInfo *li, *tmp;
1509	__u64 length = 1 + flock->fl_end - flock->fl_start;
1510	struct list_head tmp_llist;
1511
1512	INIT_LIST_HEAD(&tmp_llist);
1513
1514	/*
1515	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1516	 * and check it before using.
1517	 */
1518	max_buf = tcon->ses->server->maxBuf;
1519	if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE)))
1520		return -EINVAL;
1521
1522	BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
1523		     PAGE_SIZE);
1524	max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
1525			PAGE_SIZE);
1526	max_num = (max_buf - sizeof(struct smb_hdr)) /
1527						sizeof(LOCKING_ANDX_RANGE);
1528	buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1529	if (!buf)
1530		return -ENOMEM;
1531
1532	cifs_down_write(&cinode->lock_sem);
1533	for (i = 0; i < 2; i++) {
1534		cur = buf;
1535		num = 0;
1536		list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1537			if (flock->fl_start > li->offset ||
1538			    (flock->fl_start + length) <
1539			    (li->offset + li->length))
1540				continue;
1541			if (current->tgid != li->pid)
1542				continue;
1543			if (types[i] != li->type)
1544				continue;
1545			if (cinode->can_cache_brlcks) {
1546				/*
1547				 * We can cache brlock requests - simply remove
1548				 * a lock from the file's list.
1549				 */
1550				list_del(&li->llist);
1551				cifs_del_lock_waiters(li);
1552				kfree(li);
1553				continue;
1554			}
1555			cur->Pid = cpu_to_le16(li->pid);
1556			cur->LengthLow = cpu_to_le32((u32)li->length);
1557			cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1558			cur->OffsetLow = cpu_to_le32((u32)li->offset);
1559			cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1560			/*
1561			 * We need to save a lock here to let us add it again to
1562			 * the file's list if the unlock range request fails on
1563			 * the server.
1564			 */
1565			list_move(&li->llist, &tmp_llist);
1566			if (++num == max_num) {
1567				stored_rc = cifs_lockv(xid, tcon,
1568						       cfile->fid.netfid,
1569						       li->type, num, 0, buf);
1570				if (stored_rc) {
1571					/*
1572					 * We failed on the unlock range
1573					 * request - add all locks from the tmp
1574					 * list to the head of the file's list.
1575					 */
1576					cifs_move_llist(&tmp_llist,
1577							&cfile->llist->locks);
1578					rc = stored_rc;
1579				} else
1580					/*
1581					 * The unlock range request succeed -
1582					 * free the tmp list.
1583					 */
1584					cifs_free_llist(&tmp_llist);
1585				cur = buf;
1586				num = 0;
1587			} else
1588				cur++;
1589		}
1590		if (num) {
1591			stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1592					       types[i], num, 0, buf);
1593			if (stored_rc) {
1594				cifs_move_llist(&tmp_llist,
1595						&cfile->llist->locks);
1596				rc = stored_rc;
1597			} else
1598				cifs_free_llist(&tmp_llist);
1599		}
1600	}
1601
1602	up_write(&cinode->lock_sem);
1603	kfree(buf);
1604	return rc;
1605}
 
1606
1607static int
1608cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1609	   bool wait_flag, bool posix_lck, int lock, int unlock,
1610	   unsigned int xid)
1611{
1612	int rc = 0;
1613	__u64 length = 1 + flock->fl_end - flock->fl_start;
1614	struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1615	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1616	struct TCP_Server_Info *server = tcon->ses->server;
1617	struct inode *inode = d_inode(cfile->dentry);
1618
 
1619	if (posix_lck) {
1620		int posix_lock_type;
1621
1622		rc = cifs_posix_lock_set(file, flock);
1623		if (!rc || rc < 0)
1624			return rc;
1625
1626		if (type & server->vals->shared_lock_type)
1627			posix_lock_type = CIFS_RDLCK;
1628		else
1629			posix_lock_type = CIFS_WRLCK;
1630
1631		if (unlock == 1)
1632			posix_lock_type = CIFS_UNLCK;
1633
1634		rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1635				      hash_lockowner(flock->fl_owner),
1636				      flock->fl_start, length,
1637				      NULL, posix_lock_type, wait_flag);
1638		goto out;
1639	}
1640
1641	if (lock) {
1642		struct cifsLockInfo *lock;
1643
1644		lock = cifs_lock_init(flock->fl_start, length, type,
1645				      flock->fl_flags);
1646		if (!lock)
1647			return -ENOMEM;
1648
1649		rc = cifs_lock_add_if(cfile, lock, wait_flag);
1650		if (rc < 0) {
1651			kfree(lock);
1652			return rc;
1653		}
1654		if (!rc)
1655			goto out;
1656
1657		/*
1658		 * Windows 7 server can delay breaking lease from read to None
1659		 * if we set a byte-range lock on a file - break it explicitly
1660		 * before sending the lock to the server to be sure the next
1661		 * read won't conflict with non-overlapted locks due to
1662		 * pagereading.
1663		 */
1664		if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1665					CIFS_CACHE_READ(CIFS_I(inode))) {
1666			cifs_zap_mapping(inode);
1667			cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1668				 inode);
1669			CIFS_I(inode)->oplock = 0;
1670		}
1671
1672		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1673					    type, 1, 0, wait_flag);
1674		if (rc) {
1675			kfree(lock);
1676			return rc;
1677		}
1678
1679		cifs_lock_add(cfile, lock);
1680	} else if (unlock)
1681		rc = server->ops->mand_unlock_range(cfile, flock, xid);
1682
1683out:
1684	if (flock->fl_flags & FL_POSIX) {
1685		/*
1686		 * If this is a request to remove all locks because we
1687		 * are closing the file, it doesn't matter if the
1688		 * unlocking failed as both cifs.ko and the SMB server
1689		 * remove the lock on file close
1690		 */
1691		if (rc) {
1692			cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc);
1693			if (!(flock->fl_flags & FL_CLOSE))
1694				return rc;
1695		}
1696		rc = locks_lock_file_wait(file, flock);
1697	}
1698	return rc;
1699}
1700
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1701int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1702{
1703	int rc, xid;
1704	int lock = 0, unlock = 0;
1705	bool wait_flag = false;
1706	bool posix_lck = false;
1707	struct cifs_sb_info *cifs_sb;
1708	struct cifs_tcon *tcon;
1709	struct cifsFileInfo *cfile;
1710	__u32 type;
1711
1712	rc = -EACCES;
1713	xid = get_xid();
1714
1715	cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1716		 cmd, flock->fl_flags, flock->fl_type,
1717		 flock->fl_start, flock->fl_end);
1718
1719	cfile = (struct cifsFileInfo *)file->private_data;
1720	tcon = tlink_tcon(cfile->tlink);
1721
1722	cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1723			tcon->ses->server);
1724	cifs_sb = CIFS_FILE_SB(file);
 
1725
1726	if (cap_unix(tcon->ses) &&
1727	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1728	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1729		posix_lck = true;
1730	/*
1731	 * BB add code here to normalize offset and length to account for
1732	 * negative length which we can not accept over the wire.
1733	 */
1734	if (IS_GETLK(cmd)) {
1735		rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1736		free_xid(xid);
1737		return rc;
1738	}
1739
1740	if (!lock && !unlock) {
1741		/*
1742		 * if no lock or unlock then nothing to do since we do not
1743		 * know what it is
1744		 */
1745		free_xid(xid);
1746		return -EOPNOTSUPP;
1747	}
1748
1749	rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1750			xid);
1751	free_xid(xid);
1752	return rc;
1753}
1754
1755/*
1756 * update the file size (if needed) after a write. Should be called with
1757 * the inode->i_lock held
1758 */
1759void
1760cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1761		      unsigned int bytes_written)
1762{
1763	loff_t end_of_write = offset + bytes_written;
1764
1765	if (end_of_write > cifsi->server_eof)
1766		cifsi->server_eof = end_of_write;
1767}
1768
1769static ssize_t
1770cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1771	   size_t write_size, loff_t *offset)
1772{
1773	int rc = 0;
1774	unsigned int bytes_written = 0;
1775	unsigned int total_written;
1776	struct cifs_tcon *tcon;
1777	struct TCP_Server_Info *server;
1778	unsigned int xid;
1779	struct dentry *dentry = open_file->dentry;
1780	struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
1781	struct cifs_io_parms io_parms;
1782
1783	cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
1784		 write_size, *offset, dentry);
1785
1786	tcon = tlink_tcon(open_file->tlink);
1787	server = tcon->ses->server;
1788
1789	if (!server->ops->sync_write)
1790		return -ENOSYS;
1791
1792	xid = get_xid();
1793
1794	for (total_written = 0; write_size > total_written;
1795	     total_written += bytes_written) {
1796		rc = -EAGAIN;
1797		while (rc == -EAGAIN) {
1798			struct kvec iov[2];
1799			unsigned int len;
1800
1801			if (open_file->invalidHandle) {
1802				/* we could deadlock if we called
1803				   filemap_fdatawait from here so tell
1804				   reopen_file not to flush data to
1805				   server now */
1806				rc = cifs_reopen_file(open_file, false);
1807				if (rc != 0)
1808					break;
1809			}
1810
1811			len = min(server->ops->wp_retry_size(d_inode(dentry)),
1812				  (unsigned int)write_size - total_written);
1813			/* iov[0] is reserved for smb header */
1814			iov[1].iov_base = (char *)write_data + total_written;
1815			iov[1].iov_len = len;
1816			io_parms.pid = pid;
1817			io_parms.tcon = tcon;
1818			io_parms.offset = *offset;
1819			io_parms.length = len;
1820			rc = server->ops->sync_write(xid, &open_file->fid,
1821					&io_parms, &bytes_written, iov, 1);
1822		}
1823		if (rc || (bytes_written == 0)) {
1824			if (total_written)
1825				break;
1826			else {
1827				free_xid(xid);
1828				return rc;
1829			}
1830		} else {
1831			spin_lock(&d_inode(dentry)->i_lock);
1832			cifs_update_eof(cifsi, *offset, bytes_written);
1833			spin_unlock(&d_inode(dentry)->i_lock);
1834			*offset += bytes_written;
1835		}
1836	}
1837
1838	cifs_stats_bytes_written(tcon, total_written);
1839
1840	if (total_written > 0) {
1841		spin_lock(&d_inode(dentry)->i_lock);
1842		if (*offset > d_inode(dentry)->i_size)
1843			i_size_write(d_inode(dentry), *offset);
 
 
1844		spin_unlock(&d_inode(dentry)->i_lock);
1845	}
1846	mark_inode_dirty_sync(d_inode(dentry));
1847	free_xid(xid);
1848	return total_written;
1849}
1850
1851struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1852					bool fsuid_only)
1853{
1854	struct cifsFileInfo *open_file = NULL;
1855	struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1856
1857	/* only filter by fsuid on multiuser mounts */
1858	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1859		fsuid_only = false;
1860
1861	spin_lock(&cifs_inode->open_file_lock);
1862	/* we could simply get the first_list_entry since write-only entries
1863	   are always at the end of the list but since the first entry might
1864	   have a close pending, we go through the whole list */
1865	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1866		if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1867			continue;
1868		if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1869			if (!open_file->invalidHandle) {
1870				/* found a good file */
1871				/* lock it so it will not be closed on us */
1872				cifsFileInfo_get(open_file);
1873				spin_unlock(&cifs_inode->open_file_lock);
1874				return open_file;
1875			} /* else might as well continue, and look for
1876			     another, or simply have the caller reopen it
1877			     again rather than trying to fix this handle */
1878		} else /* write only file */
1879			break; /* write only files are last so must be done */
1880	}
1881	spin_unlock(&cifs_inode->open_file_lock);
1882	return NULL;
1883}
1884
1885/* Return -EBADF if no handle is found and general rc otherwise */
1886int
1887cifs_get_writable_file(struct cifsInodeInfo *cifs_inode, bool fsuid_only,
1888		       struct cifsFileInfo **ret_file)
1889{
1890	struct cifsFileInfo *open_file, *inv_file = NULL;
1891	struct cifs_sb_info *cifs_sb;
1892	bool any_available = false;
1893	int rc = -EBADF;
1894	unsigned int refind = 0;
1895
 
1896	*ret_file = NULL;
1897
1898	/*
1899	 * Having a null inode here (because mapping->host was set to zero by
1900	 * the VFS or MM) should not happen but we had reports of on oops (due
1901	 * to it being zero) during stress testcases so we need to check for it
1902	 */
1903
1904	if (cifs_inode == NULL) {
1905		cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1906		dump_stack();
1907		return rc;
1908	}
1909
1910	cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1911
1912	/* only filter by fsuid on multiuser mounts */
1913	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1914		fsuid_only = false;
1915
1916	spin_lock(&cifs_inode->open_file_lock);
1917refind_writable:
1918	if (refind > MAX_REOPEN_ATT) {
1919		spin_unlock(&cifs_inode->open_file_lock);
1920		return rc;
1921	}
1922	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1923		if (!any_available && open_file->pid != current->tgid)
1924			continue;
1925		if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1926			continue;
 
 
1927		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1928			if (!open_file->invalidHandle) {
1929				/* found a good writable file */
1930				cifsFileInfo_get(open_file);
1931				spin_unlock(&cifs_inode->open_file_lock);
1932				*ret_file = open_file;
1933				return 0;
1934			} else {
1935				if (!inv_file)
1936					inv_file = open_file;
1937			}
1938		}
1939	}
1940	/* couldn't find useable FH with same pid, try any available */
1941	if (!any_available) {
1942		any_available = true;
1943		goto refind_writable;
1944	}
1945
1946	if (inv_file) {
1947		any_available = false;
1948		cifsFileInfo_get(inv_file);
1949	}
1950
1951	spin_unlock(&cifs_inode->open_file_lock);
1952
1953	if (inv_file) {
1954		rc = cifs_reopen_file(inv_file, false);
1955		if (!rc) {
1956			*ret_file = inv_file;
1957			return 0;
1958		}
1959
1960		spin_lock(&cifs_inode->open_file_lock);
1961		list_move_tail(&inv_file->flist, &cifs_inode->openFileList);
1962		spin_unlock(&cifs_inode->open_file_lock);
1963		cifsFileInfo_put(inv_file);
1964		++refind;
1965		inv_file = NULL;
1966		spin_lock(&cifs_inode->open_file_lock);
1967		goto refind_writable;
1968	}
1969
1970	return rc;
1971}
1972
1973struct cifsFileInfo *
1974find_writable_file(struct cifsInodeInfo *cifs_inode, bool fsuid_only)
1975{
1976	struct cifsFileInfo *cfile;
1977	int rc;
1978
1979	rc = cifs_get_writable_file(cifs_inode, fsuid_only, &cfile);
1980	if (rc)
1981		cifs_dbg(FYI, "couldn't find writable handle rc=%d", rc);
1982
1983	return cfile;
1984}
1985
1986int
1987cifs_get_writable_path(struct cifs_tcon *tcon, const char *name,
 
1988		       struct cifsFileInfo **ret_file)
1989{
1990	struct list_head *tmp;
1991	struct cifsFileInfo *cfile;
1992	struct cifsInodeInfo *cinode;
1993	char *full_path;
1994
1995	*ret_file = NULL;
1996
1997	spin_lock(&tcon->open_file_lock);
1998	list_for_each(tmp, &tcon->openFileList) {
1999		cfile = list_entry(tmp, struct cifsFileInfo,
2000			     tlist);
2001		full_path = build_path_from_dentry(cfile->dentry);
2002		if (full_path == NULL) {
2003			spin_unlock(&tcon->open_file_lock);
2004			return -ENOMEM;
 
2005		}
2006		if (strcmp(full_path, name)) {
2007			kfree(full_path);
2008			continue;
2009		}
2010
2011		kfree(full_path);
2012		cinode = CIFS_I(d_inode(cfile->dentry));
2013		spin_unlock(&tcon->open_file_lock);
2014		return cifs_get_writable_file(cinode, 0, ret_file);
 
2015	}
2016
2017	spin_unlock(&tcon->open_file_lock);
 
2018	return -ENOENT;
2019}
2020
2021int
2022cifs_get_readable_path(struct cifs_tcon *tcon, const char *name,
2023		       struct cifsFileInfo **ret_file)
2024{
2025	struct list_head *tmp;
2026	struct cifsFileInfo *cfile;
2027	struct cifsInodeInfo *cinode;
2028	char *full_path;
2029
2030	*ret_file = NULL;
2031
2032	spin_lock(&tcon->open_file_lock);
2033	list_for_each(tmp, &tcon->openFileList) {
2034		cfile = list_entry(tmp, struct cifsFileInfo,
2035			     tlist);
2036		full_path = build_path_from_dentry(cfile->dentry);
2037		if (full_path == NULL) {
2038			spin_unlock(&tcon->open_file_lock);
2039			return -ENOMEM;
 
2040		}
2041		if (strcmp(full_path, name)) {
2042			kfree(full_path);
2043			continue;
2044		}
2045
2046		kfree(full_path);
2047		cinode = CIFS_I(d_inode(cfile->dentry));
2048		spin_unlock(&tcon->open_file_lock);
 
2049		*ret_file = find_readable_file(cinode, 0);
2050		return *ret_file ? 0 : -ENOENT;
2051	}
2052
2053	spin_unlock(&tcon->open_file_lock);
 
2054	return -ENOENT;
2055}
2056
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2057static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
2058{
2059	struct address_space *mapping = page->mapping;
2060	loff_t offset = (loff_t)page->index << PAGE_SHIFT;
2061	char *write_data;
2062	int rc = -EFAULT;
2063	int bytes_written = 0;
2064	struct inode *inode;
2065	struct cifsFileInfo *open_file;
2066
2067	if (!mapping || !mapping->host)
2068		return -EFAULT;
2069
2070	inode = page->mapping->host;
2071
2072	offset += (loff_t)from;
2073	write_data = kmap(page);
2074	write_data += from;
2075
2076	if ((to > PAGE_SIZE) || (from > to)) {
2077		kunmap(page);
2078		return -EIO;
2079	}
2080
2081	/* racing with truncate? */
2082	if (offset > mapping->host->i_size) {
2083		kunmap(page);
2084		return 0; /* don't care */
2085	}
2086
2087	/* check to make sure that we are not extending the file */
2088	if (mapping->host->i_size - offset < (loff_t)to)
2089		to = (unsigned)(mapping->host->i_size - offset);
2090
2091	rc = cifs_get_writable_file(CIFS_I(mapping->host), false, &open_file);
 
2092	if (!rc) {
2093		bytes_written = cifs_write(open_file, open_file->pid,
2094					   write_data, to - from, &offset);
2095		cifsFileInfo_put(open_file);
2096		/* Does mm or vfs already set times? */
2097		inode->i_atime = inode->i_mtime = current_time(inode);
2098		if ((bytes_written > 0) && (offset))
2099			rc = 0;
2100		else if (bytes_written < 0)
2101			rc = bytes_written;
2102		else
2103			rc = -EFAULT;
2104	} else {
2105		cifs_dbg(FYI, "No writable handle for write page rc=%d\n", rc);
2106		if (!is_retryable_error(rc))
2107			rc = -EIO;
2108	}
2109
2110	kunmap(page);
2111	return rc;
2112}
2113
2114static struct cifs_writedata *
2115wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
2116			  pgoff_t end, pgoff_t *index,
2117			  unsigned int *found_pages)
2118{
2119	struct cifs_writedata *wdata;
2120
2121	wdata = cifs_writedata_alloc((unsigned int)tofind,
2122				     cifs_writev_complete);
2123	if (!wdata)
2124		return NULL;
2125
2126	*found_pages = find_get_pages_range_tag(mapping, index, end,
2127				PAGECACHE_TAG_DIRTY, tofind, wdata->pages);
2128	return wdata;
2129}
2130
2131static unsigned int
2132wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
2133		    struct address_space *mapping,
2134		    struct writeback_control *wbc,
2135		    pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
2136{
2137	unsigned int nr_pages = 0, i;
2138	struct page *page;
2139
2140	for (i = 0; i < found_pages; i++) {
2141		page = wdata->pages[i];
2142		/*
2143		 * At this point we hold neither the i_pages lock nor the
2144		 * page lock: the page may be truncated or invalidated
2145		 * (changing page->mapping to NULL), or even swizzled
2146		 * back from swapper_space to tmpfs file mapping
2147		 */
2148
2149		if (nr_pages == 0)
2150			lock_page(page);
2151		else if (!trylock_page(page))
2152			break;
2153
2154		if (unlikely(page->mapping != mapping)) {
2155			unlock_page(page);
2156			break;
2157		}
2158
2159		if (!wbc->range_cyclic && page->index > end) {
2160			*done = true;
2161			unlock_page(page);
2162			break;
2163		}
2164
2165		if (*next && (page->index != *next)) {
2166			/* Not next consecutive page */
2167			unlock_page(page);
2168			break;
2169		}
2170
2171		if (wbc->sync_mode != WB_SYNC_NONE)
2172			wait_on_page_writeback(page);
2173
2174		if (PageWriteback(page) ||
2175				!clear_page_dirty_for_io(page)) {
2176			unlock_page(page);
2177			break;
2178		}
2179
2180		/*
2181		 * This actually clears the dirty bit in the radix tree.
2182		 * See cifs_writepage() for more commentary.
2183		 */
2184		set_page_writeback(page);
2185		if (page_offset(page) >= i_size_read(mapping->host)) {
2186			*done = true;
2187			unlock_page(page);
2188			end_page_writeback(page);
2189			break;
2190		}
2191
2192		wdata->pages[i] = page;
2193		*next = page->index + 1;
2194		++nr_pages;
2195	}
2196
2197	/* reset index to refind any pages skipped */
2198	if (nr_pages == 0)
2199		*index = wdata->pages[0]->index + 1;
2200
2201	/* put any pages we aren't going to use */
2202	for (i = nr_pages; i < found_pages; i++) {
2203		put_page(wdata->pages[i]);
2204		wdata->pages[i] = NULL;
2205	}
2206
2207	return nr_pages;
2208}
2209
2210static int
2211wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
2212		 struct address_space *mapping, struct writeback_control *wbc)
2213{
2214	int rc;
2215	struct TCP_Server_Info *server =
2216				tlink_tcon(wdata->cfile->tlink)->ses->server;
2217
2218	wdata->sync_mode = wbc->sync_mode;
2219	wdata->nr_pages = nr_pages;
2220	wdata->offset = page_offset(wdata->pages[0]);
2221	wdata->pagesz = PAGE_SIZE;
2222	wdata->tailsz = min(i_size_read(mapping->host) -
2223			page_offset(wdata->pages[nr_pages - 1]),
2224			(loff_t)PAGE_SIZE);
2225	wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2226	wdata->pid = wdata->cfile->pid;
2227
2228	rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2229	if (rc)
2230		return rc;
2231
2232	if (wdata->cfile->invalidHandle)
2233		rc = -EAGAIN;
2234	else
2235		rc = server->ops->async_writev(wdata, cifs_writedata_release);
 
2236
2237	return rc;
2238}
2239
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2240static int cifs_writepages(struct address_space *mapping,
2241			   struct writeback_control *wbc)
2242{
2243	struct inode *inode = mapping->host;
2244	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2245	struct TCP_Server_Info *server;
2246	bool done = false, scanned = false, range_whole = false;
2247	pgoff_t end, index;
2248	struct cifs_writedata *wdata;
2249	struct cifsFileInfo *cfile = NULL;
2250	int rc = 0;
2251	int saved_rc = 0;
2252	unsigned int xid;
2253
2254	/*
2255	 * If wsize is smaller than the page cache size, default to writing
2256	 * one page at a time via cifs_writepage
2257	 */
2258	if (cifs_sb->wsize < PAGE_SIZE)
2259		return generic_writepages(mapping, wbc);
 
2260
2261	xid = get_xid();
2262	if (wbc->range_cyclic) {
2263		index = mapping->writeback_index; /* Start from prev offset */
2264		end = -1;
2265	} else {
2266		index = wbc->range_start >> PAGE_SHIFT;
2267		end = wbc->range_end >> PAGE_SHIFT;
2268		if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2269			range_whole = true;
2270		scanned = true;
2271	}
2272	server = cifs_sb_master_tcon(cifs_sb)->ses->server;
 
2273retry:
2274	while (!done && index <= end) {
2275		unsigned int i, nr_pages, found_pages, wsize;
2276		pgoff_t next = 0, tofind, saved_index = index;
2277		struct cifs_credits credits_on_stack;
2278		struct cifs_credits *credits = &credits_on_stack;
2279		int get_file_rc = 0;
2280
2281		if (cfile)
2282			cifsFileInfo_put(cfile);
2283
2284		rc = cifs_get_writable_file(CIFS_I(inode), false, &cfile);
2285
2286		/* in case of an error store it to return later */
2287		if (rc)
2288			get_file_rc = rc;
2289
2290		rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2291						   &wsize, credits);
2292		if (rc != 0) {
2293			done = true;
2294			break;
2295		}
2296
2297		tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2298
2299		wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
2300						  &found_pages);
2301		if (!wdata) {
2302			rc = -ENOMEM;
2303			done = true;
2304			add_credits_and_wake_if(server, credits, 0);
2305			break;
2306		}
2307
2308		if (found_pages == 0) {
2309			kref_put(&wdata->refcount, cifs_writedata_release);
2310			add_credits_and_wake_if(server, credits, 0);
2311			break;
2312		}
2313
2314		nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
2315					       end, &index, &next, &done);
2316
2317		/* nothing to write? */
2318		if (nr_pages == 0) {
2319			kref_put(&wdata->refcount, cifs_writedata_release);
2320			add_credits_and_wake_if(server, credits, 0);
2321			continue;
2322		}
2323
2324		wdata->credits = credits_on_stack;
2325		wdata->cfile = cfile;
 
2326		cfile = NULL;
2327
2328		if (!wdata->cfile) {
2329			cifs_dbg(VFS, "No writable handle in writepages rc=%d\n",
2330				 get_file_rc);
2331			if (is_retryable_error(get_file_rc))
2332				rc = get_file_rc;
2333			else
2334				rc = -EBADF;
2335		} else
2336			rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2337
2338		for (i = 0; i < nr_pages; ++i)
2339			unlock_page(wdata->pages[i]);
2340
2341		/* send failure -- clean up the mess */
2342		if (rc != 0) {
2343			add_credits_and_wake_if(server, &wdata->credits, 0);
2344			for (i = 0; i < nr_pages; ++i) {
2345				if (is_retryable_error(rc))
2346					redirty_page_for_writepage(wbc,
2347							   wdata->pages[i]);
2348				else
2349					SetPageError(wdata->pages[i]);
2350				end_page_writeback(wdata->pages[i]);
2351				put_page(wdata->pages[i]);
2352			}
2353			if (!is_retryable_error(rc))
2354				mapping_set_error(mapping, rc);
2355		}
2356		kref_put(&wdata->refcount, cifs_writedata_release);
2357
2358		if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
2359			index = saved_index;
2360			continue;
2361		}
2362
2363		/* Return immediately if we received a signal during writing */
2364		if (is_interrupt_error(rc)) {
2365			done = true;
2366			break;
2367		}
2368
2369		if (rc != 0 && saved_rc == 0)
2370			saved_rc = rc;
2371
2372		wbc->nr_to_write -= nr_pages;
2373		if (wbc->nr_to_write <= 0)
2374			done = true;
2375
2376		index = next;
2377	}
2378
2379	if (!scanned && !done) {
2380		/*
2381		 * We hit the last page and there is more work to be done: wrap
2382		 * back to the start of the file
2383		 */
2384		scanned = true;
2385		index = 0;
2386		goto retry;
2387	}
2388
2389	if (saved_rc != 0)
2390		rc = saved_rc;
2391
2392	if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2393		mapping->writeback_index = index;
2394
2395	if (cfile)
2396		cifsFileInfo_put(cfile);
2397	free_xid(xid);
 
 
2398	return rc;
2399}
2400
2401static int
2402cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2403{
2404	int rc;
2405	unsigned int xid;
2406
2407	xid = get_xid();
2408/* BB add check for wbc flags */
2409	get_page(page);
2410	if (!PageUptodate(page))
2411		cifs_dbg(FYI, "ppw - page not up to date\n");
2412
2413	/*
2414	 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2415	 *
2416	 * A writepage() implementation always needs to do either this,
2417	 * or re-dirty the page with "redirty_page_for_writepage()" in
2418	 * the case of a failure.
2419	 *
2420	 * Just unlocking the page will cause the radix tree tag-bits
2421	 * to fail to update with the state of the page correctly.
2422	 */
2423	set_page_writeback(page);
2424retry_write:
2425	rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2426	if (is_retryable_error(rc)) {
2427		if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN)
2428			goto retry_write;
2429		redirty_page_for_writepage(wbc, page);
2430	} else if (rc != 0) {
2431		SetPageError(page);
2432		mapping_set_error(page->mapping, rc);
2433	} else {
2434		SetPageUptodate(page);
2435	}
2436	end_page_writeback(page);
2437	put_page(page);
2438	free_xid(xid);
2439	return rc;
2440}
2441
2442static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2443{
2444	int rc = cifs_writepage_locked(page, wbc);
2445	unlock_page(page);
2446	return rc;
2447}
2448
2449static int cifs_write_end(struct file *file, struct address_space *mapping,
2450			loff_t pos, unsigned len, unsigned copied,
2451			struct page *page, void *fsdata)
2452{
2453	int rc;
2454	struct inode *inode = mapping->host;
2455	struct cifsFileInfo *cfile = file->private_data;
2456	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2457	__u32 pid;
2458
2459	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2460		pid = cfile->pid;
2461	else
2462		pid = current->tgid;
2463
2464	cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2465		 page, pos, copied);
2466
2467	if (PageChecked(page)) {
2468		if (copied == len)
2469			SetPageUptodate(page);
2470		ClearPageChecked(page);
2471	} else if (!PageUptodate(page) && copied == PAGE_SIZE)
2472		SetPageUptodate(page);
2473
2474	if (!PageUptodate(page)) {
2475		char *page_data;
2476		unsigned offset = pos & (PAGE_SIZE - 1);
2477		unsigned int xid;
2478
2479		xid = get_xid();
2480		/* this is probably better than directly calling
2481		   partialpage_write since in this function the file handle is
2482		   known which we might as well	leverage */
2483		/* BB check if anything else missing out of ppw
2484		   such as updating last write time */
2485		page_data = kmap(page);
2486		rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2487		/* if (rc < 0) should we set writebehind rc? */
2488		kunmap(page);
2489
2490		free_xid(xid);
2491	} else {
2492		rc = copied;
2493		pos += copied;
2494		set_page_dirty(page);
2495	}
2496
2497	if (rc > 0) {
2498		spin_lock(&inode->i_lock);
2499		if (pos > inode->i_size)
2500			i_size_write(inode, pos);
 
 
2501		spin_unlock(&inode->i_lock);
2502	}
2503
2504	unlock_page(page);
2505	put_page(page);
 
 
2506
2507	return rc;
2508}
2509
2510int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2511		      int datasync)
2512{
2513	unsigned int xid;
2514	int rc = 0;
2515	struct cifs_tcon *tcon;
2516	struct TCP_Server_Info *server;
2517	struct cifsFileInfo *smbfile = file->private_data;
2518	struct inode *inode = file_inode(file);
2519	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2520
2521	rc = file_write_and_wait_range(file, start, end);
2522	if (rc)
 
2523		return rc;
 
2524
2525	xid = get_xid();
2526
2527	cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2528		 file, datasync);
2529
2530	if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2531		rc = cifs_zap_mapping(inode);
2532		if (rc) {
2533			cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2534			rc = 0; /* don't care about it in fsync */
2535		}
2536	}
2537
2538	tcon = tlink_tcon(smbfile->tlink);
2539	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2540		server = tcon->ses->server;
2541		if (server->ops->flush)
 
 
 
 
 
 
 
 
 
 
 
 
2542			rc = server->ops->flush(xid, tcon, &smbfile->fid);
2543		else
2544			rc = -ENOSYS;
2545	}
2546
 
2547	free_xid(xid);
2548	return rc;
2549}
2550
2551int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2552{
2553	unsigned int xid;
2554	int rc = 0;
2555	struct cifs_tcon *tcon;
2556	struct TCP_Server_Info *server;
2557	struct cifsFileInfo *smbfile = file->private_data;
 
2558	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2559
2560	rc = file_write_and_wait_range(file, start, end);
2561	if (rc)
 
2562		return rc;
 
2563
2564	xid = get_xid();
2565
2566	cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2567		 file, datasync);
2568
2569	tcon = tlink_tcon(smbfile->tlink);
2570	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2571		server = tcon->ses->server;
2572		if (server->ops->flush)
 
 
 
 
 
 
 
 
 
 
 
 
2573			rc = server->ops->flush(xid, tcon, &smbfile->fid);
2574		else
2575			rc = -ENOSYS;
2576	}
2577
 
2578	free_xid(xid);
2579	return rc;
2580}
2581
2582/*
2583 * As file closes, flush all cached write data for this inode checking
2584 * for write behind errors.
2585 */
2586int cifs_flush(struct file *file, fl_owner_t id)
2587{
2588	struct inode *inode = file_inode(file);
2589	int rc = 0;
2590
2591	if (file->f_mode & FMODE_WRITE)
2592		rc = filemap_write_and_wait(inode->i_mapping);
2593
2594	cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2595
 
 
 
 
2596	return rc;
2597}
2598
2599static int
2600cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2601{
2602	int rc = 0;
2603	unsigned long i;
2604
2605	for (i = 0; i < num_pages; i++) {
2606		pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2607		if (!pages[i]) {
2608			/*
2609			 * save number of pages we have already allocated and
2610			 * return with ENOMEM error
2611			 */
2612			num_pages = i;
2613			rc = -ENOMEM;
2614			break;
2615		}
2616	}
2617
2618	if (rc) {
2619		for (i = 0; i < num_pages; i++)
2620			put_page(pages[i]);
2621	}
2622	return rc;
2623}
2624
2625static inline
2626size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2627{
2628	size_t num_pages;
2629	size_t clen;
2630
2631	clen = min_t(const size_t, len, wsize);
2632	num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2633
2634	if (cur_len)
2635		*cur_len = clen;
2636
2637	return num_pages;
2638}
2639
2640static void
2641cifs_uncached_writedata_release(struct kref *refcount)
2642{
2643	int i;
2644	struct cifs_writedata *wdata = container_of(refcount,
2645					struct cifs_writedata, refcount);
2646
2647	kref_put(&wdata->ctx->refcount, cifs_aio_ctx_release);
2648	for (i = 0; i < wdata->nr_pages; i++)
2649		put_page(wdata->pages[i]);
2650	cifs_writedata_release(refcount);
2651}
2652
2653static void collect_uncached_write_data(struct cifs_aio_ctx *ctx);
2654
2655static void
2656cifs_uncached_writev_complete(struct work_struct *work)
2657{
2658	struct cifs_writedata *wdata = container_of(work,
2659					struct cifs_writedata, work);
2660	struct inode *inode = d_inode(wdata->cfile->dentry);
2661	struct cifsInodeInfo *cifsi = CIFS_I(inode);
2662
2663	spin_lock(&inode->i_lock);
2664	cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2665	if (cifsi->server_eof > inode->i_size)
2666		i_size_write(inode, cifsi->server_eof);
2667	spin_unlock(&inode->i_lock);
2668
2669	complete(&wdata->done);
2670	collect_uncached_write_data(wdata->ctx);
2671	/* the below call can possibly free the last ref to aio ctx */
2672	kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2673}
2674
2675static int
2676wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
2677		      size_t *len, unsigned long *num_pages)
2678{
2679	size_t save_len, copied, bytes, cur_len = *len;
2680	unsigned long i, nr_pages = *num_pages;
2681
2682	save_len = cur_len;
2683	for (i = 0; i < nr_pages; i++) {
2684		bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2685		copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
2686		cur_len -= copied;
2687		/*
2688		 * If we didn't copy as much as we expected, then that
2689		 * may mean we trod into an unmapped area. Stop copying
2690		 * at that point. On the next pass through the big
2691		 * loop, we'll likely end up getting a zero-length
2692		 * write and bailing out of it.
2693		 */
2694		if (copied < bytes)
2695			break;
2696	}
2697	cur_len = save_len - cur_len;
2698	*len = cur_len;
2699
2700	/*
2701	 * If we have no data to send, then that probably means that
2702	 * the copy above failed altogether. That's most likely because
2703	 * the address in the iovec was bogus. Return -EFAULT and let
2704	 * the caller free anything we allocated and bail out.
2705	 */
2706	if (!cur_len)
2707		return -EFAULT;
2708
2709	/*
2710	 * i + 1 now represents the number of pages we actually used in
2711	 * the copy phase above.
2712	 */
2713	*num_pages = i + 1;
2714	return 0;
2715}
2716
2717static int
2718cifs_resend_wdata(struct cifs_writedata *wdata, struct list_head *wdata_list,
2719	struct cifs_aio_ctx *ctx)
2720{
2721	unsigned int wsize;
2722	struct cifs_credits credits;
2723	int rc;
2724	struct TCP_Server_Info *server =
2725		tlink_tcon(wdata->cfile->tlink)->ses->server;
2726
2727	do {
2728		if (wdata->cfile->invalidHandle) {
2729			rc = cifs_reopen_file(wdata->cfile, false);
2730			if (rc == -EAGAIN)
2731				continue;
2732			else if (rc)
2733				break;
2734		}
2735
2736
2737		/*
2738		 * Wait for credits to resend this wdata.
2739		 * Note: we are attempting to resend the whole wdata not in
2740		 * segments
2741		 */
2742		do {
2743			rc = server->ops->wait_mtu_credits(server, wdata->bytes,
2744						&wsize, &credits);
2745			if (rc)
2746				goto fail;
2747
2748			if (wsize < wdata->bytes) {
2749				add_credits_and_wake_if(server, &credits, 0);
2750				msleep(1000);
2751			}
2752		} while (wsize < wdata->bytes);
2753		wdata->credits = credits;
2754
2755		rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2756
2757		if (!rc) {
2758			if (wdata->cfile->invalidHandle)
2759				rc = -EAGAIN;
2760			else
 
 
 
 
 
 
 
2761				rc = server->ops->async_writev(wdata,
2762					cifs_uncached_writedata_release);
 
2763		}
2764
2765		/* If the write was successfully sent, we are done */
2766		if (!rc) {
2767			list_add_tail(&wdata->list, wdata_list);
2768			return 0;
2769		}
2770
2771		/* Roll back credits and retry if needed */
2772		add_credits_and_wake_if(server, &wdata->credits, 0);
2773	} while (rc == -EAGAIN);
2774
2775fail:
2776	kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2777	return rc;
2778}
2779
2780static int
2781cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
2782		     struct cifsFileInfo *open_file,
2783		     struct cifs_sb_info *cifs_sb, struct list_head *wdata_list,
2784		     struct cifs_aio_ctx *ctx)
2785{
2786	int rc = 0;
2787	size_t cur_len;
2788	unsigned long nr_pages, num_pages, i;
2789	struct cifs_writedata *wdata;
2790	struct iov_iter saved_from = *from;
2791	loff_t saved_offset = offset;
2792	pid_t pid;
2793	struct TCP_Server_Info *server;
2794	struct page **pagevec;
2795	size_t start;
2796	unsigned int xid;
2797
2798	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2799		pid = open_file->pid;
2800	else
2801		pid = current->tgid;
2802
2803	server = tlink_tcon(open_file->tlink)->ses->server;
2804	xid = get_xid();
2805
2806	do {
2807		unsigned int wsize;
2808		struct cifs_credits credits_on_stack;
2809		struct cifs_credits *credits = &credits_on_stack;
2810
2811		if (open_file->invalidHandle) {
2812			rc = cifs_reopen_file(open_file, false);
2813			if (rc == -EAGAIN)
2814				continue;
2815			else if (rc)
2816				break;
2817		}
2818
2819		rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2820						   &wsize, credits);
2821		if (rc)
2822			break;
2823
2824		cur_len = min_t(const size_t, len, wsize);
2825
2826		if (ctx->direct_io) {
2827			ssize_t result;
2828
2829			result = iov_iter_get_pages_alloc(
2830				from, &pagevec, cur_len, &start);
2831			if (result < 0) {
2832				cifs_dbg(VFS,
2833					"direct_writev couldn't get user pages "
2834					"(rc=%zd) iter type %d iov_offset %zd "
2835					"count %zd\n",
2836					result, from->type,
2837					from->iov_offset, from->count);
2838				dump_stack();
2839
2840				rc = result;
2841				add_credits_and_wake_if(server, credits, 0);
2842				break;
2843			}
2844			cur_len = (size_t)result;
2845			iov_iter_advance(from, cur_len);
2846
2847			nr_pages =
2848				(cur_len + start + PAGE_SIZE - 1) / PAGE_SIZE;
2849
2850			wdata = cifs_writedata_direct_alloc(pagevec,
2851					     cifs_uncached_writev_complete);
2852			if (!wdata) {
2853				rc = -ENOMEM;
 
 
 
2854				add_credits_and_wake_if(server, credits, 0);
2855				break;
2856			}
2857
2858
2859			wdata->page_offset = start;
2860			wdata->tailsz =
2861				nr_pages > 1 ?
2862					cur_len - (PAGE_SIZE - start) -
2863					(nr_pages - 2) * PAGE_SIZE :
2864					cur_len;
2865		} else {
2866			nr_pages = get_numpages(wsize, len, &cur_len);
2867			wdata = cifs_writedata_alloc(nr_pages,
2868					     cifs_uncached_writev_complete);
2869			if (!wdata) {
2870				rc = -ENOMEM;
2871				add_credits_and_wake_if(server, credits, 0);
2872				break;
2873			}
2874
2875			rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2876			if (rc) {
2877				kvfree(wdata->pages);
2878				kfree(wdata);
2879				add_credits_and_wake_if(server, credits, 0);
2880				break;
2881			}
2882
2883			num_pages = nr_pages;
2884			rc = wdata_fill_from_iovec(
2885				wdata, from, &cur_len, &num_pages);
2886			if (rc) {
2887				for (i = 0; i < nr_pages; i++)
2888					put_page(wdata->pages[i]);
2889				kvfree(wdata->pages);
2890				kfree(wdata);
2891				add_credits_and_wake_if(server, credits, 0);
2892				break;
2893			}
2894
2895			/*
2896			 * Bring nr_pages down to the number of pages we
2897			 * actually used, and free any pages that we didn't use.
2898			 */
2899			for ( ; nr_pages > num_pages; nr_pages--)
2900				put_page(wdata->pages[nr_pages - 1]);
2901
2902			wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2903		}
2904
2905		wdata->sync_mode = WB_SYNC_ALL;
2906		wdata->nr_pages = nr_pages;
2907		wdata->offset = (__u64)offset;
2908		wdata->cfile = cifsFileInfo_get(open_file);
 
2909		wdata->pid = pid;
2910		wdata->bytes = cur_len;
2911		wdata->pagesz = PAGE_SIZE;
2912		wdata->credits = credits_on_stack;
2913		wdata->ctx = ctx;
2914		kref_get(&ctx->refcount);
2915
2916		rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2917
2918		if (!rc) {
2919			if (wdata->cfile->invalidHandle)
2920				rc = -EAGAIN;
2921			else
2922				rc = server->ops->async_writev(wdata,
2923					cifs_uncached_writedata_release);
2924		}
2925
2926		if (rc) {
2927			add_credits_and_wake_if(server, &wdata->credits, 0);
2928			kref_put(&wdata->refcount,
2929				 cifs_uncached_writedata_release);
2930			if (rc == -EAGAIN) {
2931				*from = saved_from;
2932				iov_iter_advance(from, offset - saved_offset);
2933				continue;
2934			}
2935			break;
2936		}
2937
2938		list_add_tail(&wdata->list, wdata_list);
2939		offset += cur_len;
2940		len -= cur_len;
2941	} while (len > 0);
2942
2943	free_xid(xid);
2944	return rc;
2945}
2946
2947static void collect_uncached_write_data(struct cifs_aio_ctx *ctx)
2948{
2949	struct cifs_writedata *wdata, *tmp;
2950	struct cifs_tcon *tcon;
2951	struct cifs_sb_info *cifs_sb;
2952	struct dentry *dentry = ctx->cfile->dentry;
2953	int rc;
2954
2955	tcon = tlink_tcon(ctx->cfile->tlink);
2956	cifs_sb = CIFS_SB(dentry->d_sb);
2957
2958	mutex_lock(&ctx->aio_mutex);
2959
2960	if (list_empty(&ctx->list)) {
2961		mutex_unlock(&ctx->aio_mutex);
2962		return;
2963	}
2964
2965	rc = ctx->rc;
2966	/*
2967	 * Wait for and collect replies for any successful sends in order of
2968	 * increasing offset. Once an error is hit, then return without waiting
2969	 * for any more replies.
2970	 */
2971restart_loop:
2972	list_for_each_entry_safe(wdata, tmp, &ctx->list, list) {
2973		if (!rc) {
2974			if (!try_wait_for_completion(&wdata->done)) {
2975				mutex_unlock(&ctx->aio_mutex);
2976				return;
2977			}
2978
2979			if (wdata->result)
2980				rc = wdata->result;
2981			else
2982				ctx->total_len += wdata->bytes;
2983
2984			/* resend call if it's a retryable error */
2985			if (rc == -EAGAIN) {
2986				struct list_head tmp_list;
2987				struct iov_iter tmp_from = ctx->iter;
2988
2989				INIT_LIST_HEAD(&tmp_list);
2990				list_del_init(&wdata->list);
2991
2992				if (ctx->direct_io)
2993					rc = cifs_resend_wdata(
2994						wdata, &tmp_list, ctx);
2995				else {
2996					iov_iter_advance(&tmp_from,
2997						 wdata->offset - ctx->pos);
2998
2999					rc = cifs_write_from_iter(wdata->offset,
3000						wdata->bytes, &tmp_from,
3001						ctx->cfile, cifs_sb, &tmp_list,
3002						ctx);
3003
3004					kref_put(&wdata->refcount,
3005						cifs_uncached_writedata_release);
3006				}
3007
3008				list_splice(&tmp_list, &ctx->list);
3009				goto restart_loop;
3010			}
3011		}
3012		list_del_init(&wdata->list);
3013		kref_put(&wdata->refcount, cifs_uncached_writedata_release);
3014	}
3015
3016	cifs_stats_bytes_written(tcon, ctx->total_len);
3017	set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(dentry->d_inode)->flags);
3018
3019	ctx->rc = (rc == 0) ? ctx->total_len : rc;
3020
3021	mutex_unlock(&ctx->aio_mutex);
3022
3023	if (ctx->iocb && ctx->iocb->ki_complete)
3024		ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
3025	else
3026		complete(&ctx->done);
3027}
3028
3029static ssize_t __cifs_writev(
3030	struct kiocb *iocb, struct iov_iter *from, bool direct)
3031{
3032	struct file *file = iocb->ki_filp;
3033	ssize_t total_written = 0;
3034	struct cifsFileInfo *cfile;
3035	struct cifs_tcon *tcon;
3036	struct cifs_sb_info *cifs_sb;
3037	struct cifs_aio_ctx *ctx;
3038	struct iov_iter saved_from = *from;
3039	size_t len = iov_iter_count(from);
3040	int rc;
3041
3042	/*
3043	 * iov_iter_get_pages_alloc doesn't work with ITER_KVEC.
3044	 * In this case, fall back to non-direct write function.
3045	 * this could be improved by getting pages directly in ITER_KVEC
3046	 */
3047	if (direct && from->type & ITER_KVEC) {
3048		cifs_dbg(FYI, "use non-direct cifs_writev for kvec I/O\n");
3049		direct = false;
3050	}
3051
3052	rc = generic_write_checks(iocb, from);
3053	if (rc <= 0)
3054		return rc;
3055
3056	cifs_sb = CIFS_FILE_SB(file);
3057	cfile = file->private_data;
3058	tcon = tlink_tcon(cfile->tlink);
3059
3060	if (!tcon->ses->server->ops->async_writev)
3061		return -ENOSYS;
3062
3063	ctx = cifs_aio_ctx_alloc();
3064	if (!ctx)
3065		return -ENOMEM;
3066
3067	ctx->cfile = cifsFileInfo_get(cfile);
3068
3069	if (!is_sync_kiocb(iocb))
3070		ctx->iocb = iocb;
3071
3072	ctx->pos = iocb->ki_pos;
3073
3074	if (direct) {
3075		ctx->direct_io = true;
3076		ctx->iter = *from;
3077		ctx->len = len;
3078	} else {
3079		rc = setup_aio_ctx_iter(ctx, from, WRITE);
3080		if (rc) {
3081			kref_put(&ctx->refcount, cifs_aio_ctx_release);
3082			return rc;
3083		}
3084	}
3085
3086	/* grab a lock here due to read response handlers can access ctx */
3087	mutex_lock(&ctx->aio_mutex);
3088
3089	rc = cifs_write_from_iter(iocb->ki_pos, ctx->len, &saved_from,
3090				  cfile, cifs_sb, &ctx->list, ctx);
3091
3092	/*
3093	 * If at least one write was successfully sent, then discard any rc
3094	 * value from the later writes. If the other write succeeds, then
3095	 * we'll end up returning whatever was written. If it fails, then
3096	 * we'll get a new rc value from that.
3097	 */
3098	if (!list_empty(&ctx->list))
3099		rc = 0;
3100
3101	mutex_unlock(&ctx->aio_mutex);
3102
3103	if (rc) {
3104		kref_put(&ctx->refcount, cifs_aio_ctx_release);
3105		return rc;
3106	}
3107
3108	if (!is_sync_kiocb(iocb)) {
3109		kref_put(&ctx->refcount, cifs_aio_ctx_release);
3110		return -EIOCBQUEUED;
3111	}
3112
3113	rc = wait_for_completion_killable(&ctx->done);
3114	if (rc) {
3115		mutex_lock(&ctx->aio_mutex);
3116		ctx->rc = rc = -EINTR;
3117		total_written = ctx->total_len;
3118		mutex_unlock(&ctx->aio_mutex);
3119	} else {
3120		rc = ctx->rc;
3121		total_written = ctx->total_len;
3122	}
3123
3124	kref_put(&ctx->refcount, cifs_aio_ctx_release);
3125
3126	if (unlikely(!total_written))
3127		return rc;
3128
3129	iocb->ki_pos += total_written;
3130	return total_written;
3131}
3132
3133ssize_t cifs_direct_writev(struct kiocb *iocb, struct iov_iter *from)
3134{
 
 
 
3135	return __cifs_writev(iocb, from, true);
3136}
3137
3138ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
3139{
3140	return __cifs_writev(iocb, from, false);
3141}
3142
3143static ssize_t
3144cifs_writev(struct kiocb *iocb, struct iov_iter *from)
3145{
3146	struct file *file = iocb->ki_filp;
3147	struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
3148	struct inode *inode = file->f_mapping->host;
3149	struct cifsInodeInfo *cinode = CIFS_I(inode);
3150	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
3151	ssize_t rc;
3152
3153	inode_lock(inode);
3154	/*
3155	 * We need to hold the sem to be sure nobody modifies lock list
3156	 * with a brlock that prevents writing.
3157	 */
3158	down_read(&cinode->lock_sem);
3159
3160	rc = generic_write_checks(iocb, from);
3161	if (rc <= 0)
3162		goto out;
3163
3164	if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
3165				     server->vals->exclusive_lock_type, 0,
3166				     NULL, CIFS_WRITE_OP))
3167		rc = __generic_file_write_iter(iocb, from);
3168	else
3169		rc = -EACCES;
3170out:
3171	up_read(&cinode->lock_sem);
3172	inode_unlock(inode);
3173
3174	if (rc > 0)
3175		rc = generic_write_sync(iocb, rc);
3176	return rc;
3177}
3178
3179ssize_t
3180cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
3181{
3182	struct inode *inode = file_inode(iocb->ki_filp);
3183	struct cifsInodeInfo *cinode = CIFS_I(inode);
3184	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3185	struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3186						iocb->ki_filp->private_data;
3187	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3188	ssize_t written;
3189
3190	written = cifs_get_writer(cinode);
3191	if (written)
3192		return written;
3193
3194	if (CIFS_CACHE_WRITE(cinode)) {
3195		if (cap_unix(tcon->ses) &&
3196		(CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
3197		  && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
3198			written = generic_file_write_iter(iocb, from);
3199			goto out;
3200		}
3201		written = cifs_writev(iocb, from);
3202		goto out;
3203	}
3204	/*
3205	 * For non-oplocked files in strict cache mode we need to write the data
3206	 * to the server exactly from the pos to pos+len-1 rather than flush all
3207	 * affected pages because it may cause a error with mandatory locks on
3208	 * these pages but not on the region from pos to ppos+len-1.
3209	 */
3210	written = cifs_user_writev(iocb, from);
3211	if (CIFS_CACHE_READ(cinode)) {
3212		/*
3213		 * We have read level caching and we have just sent a write
3214		 * request to the server thus making data in the cache stale.
3215		 * Zap the cache and set oplock/lease level to NONE to avoid
3216		 * reading stale data from the cache. All subsequent read
3217		 * operations will read new data from the server.
3218		 */
3219		cifs_zap_mapping(inode);
3220		cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
3221			 inode);
3222		cinode->oplock = 0;
3223	}
3224out:
3225	cifs_put_writer(cinode);
3226	return written;
3227}
3228
3229static struct cifs_readdata *
3230cifs_readdata_direct_alloc(struct page **pages, work_func_t complete)
3231{
3232	struct cifs_readdata *rdata;
3233
3234	rdata = kzalloc(sizeof(*rdata), GFP_KERNEL);
3235	if (rdata != NULL) {
3236		rdata->pages = pages;
3237		kref_init(&rdata->refcount);
3238		INIT_LIST_HEAD(&rdata->list);
3239		init_completion(&rdata->done);
3240		INIT_WORK(&rdata->work, complete);
3241	}
3242
3243	return rdata;
3244}
3245
3246static struct cifs_readdata *
3247cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
3248{
3249	struct page **pages =
3250		kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
3251	struct cifs_readdata *ret = NULL;
3252
3253	if (pages) {
3254		ret = cifs_readdata_direct_alloc(pages, complete);
3255		if (!ret)
3256			kfree(pages);
3257	}
3258
3259	return ret;
3260}
3261
3262void
3263cifs_readdata_release(struct kref *refcount)
3264{
3265	struct cifs_readdata *rdata = container_of(refcount,
3266					struct cifs_readdata, refcount);
3267#ifdef CONFIG_CIFS_SMB_DIRECT
3268	if (rdata->mr) {
3269		smbd_deregister_mr(rdata->mr);
3270		rdata->mr = NULL;
3271	}
3272#endif
3273	if (rdata->cfile)
3274		cifsFileInfo_put(rdata->cfile);
3275
3276	kvfree(rdata->pages);
3277	kfree(rdata);
3278}
3279
3280static int
3281cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
3282{
3283	int rc = 0;
3284	struct page *page;
3285	unsigned int i;
3286
3287	for (i = 0; i < nr_pages; i++) {
3288		page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
3289		if (!page) {
3290			rc = -ENOMEM;
3291			break;
3292		}
3293		rdata->pages[i] = page;
3294	}
3295
3296	if (rc) {
3297		unsigned int nr_page_failed = i;
3298
3299		for (i = 0; i < nr_page_failed; i++) {
3300			put_page(rdata->pages[i]);
3301			rdata->pages[i] = NULL;
3302		}
3303	}
3304	return rc;
3305}
3306
3307static void
3308cifs_uncached_readdata_release(struct kref *refcount)
3309{
3310	struct cifs_readdata *rdata = container_of(refcount,
3311					struct cifs_readdata, refcount);
3312	unsigned int i;
3313
3314	kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
3315	for (i = 0; i < rdata->nr_pages; i++) {
3316		put_page(rdata->pages[i]);
3317	}
3318	cifs_readdata_release(refcount);
3319}
3320
3321/**
3322 * cifs_readdata_to_iov - copy data from pages in response to an iovec
3323 * @rdata:	the readdata response with list of pages holding data
3324 * @iter:	destination for our data
3325 *
3326 * This function copies data from a list of pages in a readdata response into
3327 * an array of iovecs. It will first calculate where the data should go
3328 * based on the info in the readdata and then copy the data into that spot.
3329 */
3330static int
3331cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
3332{
3333	size_t remaining = rdata->got_bytes;
3334	unsigned int i;
3335
3336	for (i = 0; i < rdata->nr_pages; i++) {
3337		struct page *page = rdata->pages[i];
3338		size_t copy = min_t(size_t, remaining, PAGE_SIZE);
3339		size_t written;
3340
3341		if (unlikely(iov_iter_is_pipe(iter))) {
3342			void *addr = kmap_atomic(page);
3343
3344			written = copy_to_iter(addr, copy, iter);
3345			kunmap_atomic(addr);
3346		} else
3347			written = copy_page_to_iter(page, 0, copy, iter);
3348		remaining -= written;
3349		if (written < copy && iov_iter_count(iter) > 0)
3350			break;
3351	}
3352	return remaining ? -EFAULT : 0;
3353}
3354
3355static void collect_uncached_read_data(struct cifs_aio_ctx *ctx);
3356
3357static void
3358cifs_uncached_readv_complete(struct work_struct *work)
3359{
3360	struct cifs_readdata *rdata = container_of(work,
3361						struct cifs_readdata, work);
3362
3363	complete(&rdata->done);
3364	collect_uncached_read_data(rdata->ctx);
3365	/* the below call can possibly free the last ref to aio ctx */
3366	kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3367}
3368
3369static int
3370uncached_fill_pages(struct TCP_Server_Info *server,
3371		    struct cifs_readdata *rdata, struct iov_iter *iter,
3372		    unsigned int len)
3373{
3374	int result = 0;
3375	unsigned int i;
3376	unsigned int nr_pages = rdata->nr_pages;
3377	unsigned int page_offset = rdata->page_offset;
3378
3379	rdata->got_bytes = 0;
3380	rdata->tailsz = PAGE_SIZE;
3381	for (i = 0; i < nr_pages; i++) {
3382		struct page *page = rdata->pages[i];
3383		size_t n;
3384		unsigned int segment_size = rdata->pagesz;
3385
3386		if (i == 0)
3387			segment_size -= page_offset;
3388		else
3389			page_offset = 0;
3390
3391
3392		if (len <= 0) {
3393			/* no need to hold page hostage */
3394			rdata->pages[i] = NULL;
3395			rdata->nr_pages--;
3396			put_page(page);
3397			continue;
3398		}
3399
3400		n = len;
3401		if (len >= segment_size)
3402			/* enough data to fill the page */
3403			n = segment_size;
3404		else
3405			rdata->tailsz = len;
3406		len -= n;
3407
3408		if (iter)
3409			result = copy_page_from_iter(
3410					page, page_offset, n, iter);
3411#ifdef CONFIG_CIFS_SMB_DIRECT
3412		else if (rdata->mr)
3413			result = n;
3414#endif
3415		else
3416			result = cifs_read_page_from_socket(
3417					server, page, page_offset, n);
3418		if (result < 0)
3419			break;
3420
3421		rdata->got_bytes += result;
3422	}
3423
3424	return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3425						rdata->got_bytes : result;
3426}
3427
3428static int
3429cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
3430			      struct cifs_readdata *rdata, unsigned int len)
3431{
3432	return uncached_fill_pages(server, rdata, NULL, len);
3433}
3434
3435static int
3436cifs_uncached_copy_into_pages(struct TCP_Server_Info *server,
3437			      struct cifs_readdata *rdata,
3438			      struct iov_iter *iter)
3439{
3440	return uncached_fill_pages(server, rdata, iter, iter->count);
3441}
3442
3443static int cifs_resend_rdata(struct cifs_readdata *rdata,
3444			struct list_head *rdata_list,
3445			struct cifs_aio_ctx *ctx)
3446{
3447	unsigned int rsize;
3448	struct cifs_credits credits;
3449	int rc;
3450	struct TCP_Server_Info *server =
3451		tlink_tcon(rdata->cfile->tlink)->ses->server;
 
 
3452
3453	do {
3454		if (rdata->cfile->invalidHandle) {
3455			rc = cifs_reopen_file(rdata->cfile, true);
3456			if (rc == -EAGAIN)
3457				continue;
3458			else if (rc)
3459				break;
3460		}
3461
3462		/*
3463		 * Wait for credits to resend this rdata.
3464		 * Note: we are attempting to resend the whole rdata not in
3465		 * segments
3466		 */
3467		do {
3468			rc = server->ops->wait_mtu_credits(server, rdata->bytes,
3469						&rsize, &credits);
3470
3471			if (rc)
3472				goto fail;
3473
3474			if (rsize < rdata->bytes) {
3475				add_credits_and_wake_if(server, &credits, 0);
3476				msleep(1000);
3477			}
3478		} while (rsize < rdata->bytes);
3479		rdata->credits = credits;
3480
3481		rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3482		if (!rc) {
3483			if (rdata->cfile->invalidHandle)
3484				rc = -EAGAIN;
3485			else
 
 
 
 
 
 
 
3486				rc = server->ops->async_readv(rdata);
 
3487		}
3488
3489		/* If the read was successfully sent, we are done */
3490		if (!rc) {
3491			/* Add to aio pending list */
3492			list_add_tail(&rdata->list, rdata_list);
3493			return 0;
3494		}
3495
3496		/* Roll back credits and retry if needed */
3497		add_credits_and_wake_if(server, &rdata->credits, 0);
3498	} while (rc == -EAGAIN);
3499
3500fail:
3501	kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3502	return rc;
3503}
3504
3505static int
3506cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
3507		     struct cifs_sb_info *cifs_sb, struct list_head *rdata_list,
3508		     struct cifs_aio_ctx *ctx)
3509{
3510	struct cifs_readdata *rdata;
3511	unsigned int npages, rsize;
3512	struct cifs_credits credits_on_stack;
3513	struct cifs_credits *credits = &credits_on_stack;
3514	size_t cur_len;
3515	int rc;
3516	pid_t pid;
3517	struct TCP_Server_Info *server;
3518	struct page **pagevec;
3519	size_t start;
3520	struct iov_iter direct_iov = ctx->iter;
3521
3522	server = tlink_tcon(open_file->tlink)->ses->server;
3523
3524	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3525		pid = open_file->pid;
3526	else
3527		pid = current->tgid;
3528
3529	if (ctx->direct_io)
3530		iov_iter_advance(&direct_iov, offset - ctx->pos);
3531
3532	do {
3533		if (open_file->invalidHandle) {
3534			rc = cifs_reopen_file(open_file, true);
3535			if (rc == -EAGAIN)
3536				continue;
3537			else if (rc)
3538				break;
3539		}
3540
3541		rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
 
 
 
 
 
3542						   &rsize, credits);
3543		if (rc)
3544			break;
3545
3546		cur_len = min_t(const size_t, len, rsize);
3547
3548		if (ctx->direct_io) {
3549			ssize_t result;
3550
3551			result = iov_iter_get_pages_alloc(
3552					&direct_iov, &pagevec,
3553					cur_len, &start);
3554			if (result < 0) {
3555				cifs_dbg(VFS,
3556					"couldn't get user pages (rc=%zd)"
3557					" iter type %d"
3558					" iov_offset %zd count %zd\n",
3559					result, direct_iov.type,
3560					direct_iov.iov_offset,
3561					direct_iov.count);
3562				dump_stack();
3563
3564				rc = result;
3565				add_credits_and_wake_if(server, credits, 0);
3566				break;
3567			}
3568			cur_len = (size_t)result;
3569			iov_iter_advance(&direct_iov, cur_len);
3570
3571			rdata = cifs_readdata_direct_alloc(
3572					pagevec, cifs_uncached_readv_complete);
3573			if (!rdata) {
3574				add_credits_and_wake_if(server, credits, 0);
3575				rc = -ENOMEM;
3576				break;
3577			}
3578
3579			npages = (cur_len + start + PAGE_SIZE-1) / PAGE_SIZE;
3580			rdata->page_offset = start;
3581			rdata->tailsz = npages > 1 ?
3582				cur_len-(PAGE_SIZE-start)-(npages-2)*PAGE_SIZE :
3583				cur_len;
3584
3585		} else {
3586
3587			npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
3588			/* allocate a readdata struct */
3589			rdata = cifs_readdata_alloc(npages,
3590					    cifs_uncached_readv_complete);
3591			if (!rdata) {
3592				add_credits_and_wake_if(server, credits, 0);
3593				rc = -ENOMEM;
3594				break;
3595			}
3596
3597			rc = cifs_read_allocate_pages(rdata, npages);
3598			if (rc) {
3599				kvfree(rdata->pages);
3600				kfree(rdata);
3601				add_credits_and_wake_if(server, credits, 0);
3602				break;
3603			}
3604
3605			rdata->tailsz = PAGE_SIZE;
3606		}
3607
 
3608		rdata->cfile = cifsFileInfo_get(open_file);
3609		rdata->nr_pages = npages;
3610		rdata->offset = offset;
3611		rdata->bytes = cur_len;
3612		rdata->pid = pid;
3613		rdata->pagesz = PAGE_SIZE;
3614		rdata->read_into_pages = cifs_uncached_read_into_pages;
3615		rdata->copy_into_pages = cifs_uncached_copy_into_pages;
3616		rdata->credits = credits_on_stack;
3617		rdata->ctx = ctx;
3618		kref_get(&ctx->refcount);
3619
3620		rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3621
3622		if (!rc) {
3623			if (rdata->cfile->invalidHandle)
3624				rc = -EAGAIN;
3625			else
3626				rc = server->ops->async_readv(rdata);
3627		}
3628
3629		if (rc) {
3630			add_credits_and_wake_if(server, &rdata->credits, 0);
3631			kref_put(&rdata->refcount,
3632				cifs_uncached_readdata_release);
3633			if (rc == -EAGAIN) {
3634				iov_iter_revert(&direct_iov, cur_len);
3635				continue;
3636			}
3637			break;
3638		}
3639
3640		list_add_tail(&rdata->list, rdata_list);
3641		offset += cur_len;
3642		len -= cur_len;
3643	} while (len > 0);
3644
3645	return rc;
3646}
3647
3648static void
3649collect_uncached_read_data(struct cifs_aio_ctx *ctx)
3650{
3651	struct cifs_readdata *rdata, *tmp;
3652	struct iov_iter *to = &ctx->iter;
3653	struct cifs_sb_info *cifs_sb;
3654	int rc;
3655
3656	cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb);
3657
3658	mutex_lock(&ctx->aio_mutex);
3659
3660	if (list_empty(&ctx->list)) {
3661		mutex_unlock(&ctx->aio_mutex);
3662		return;
3663	}
3664
3665	rc = ctx->rc;
3666	/* the loop below should proceed in the order of increasing offsets */
3667again:
3668	list_for_each_entry_safe(rdata, tmp, &ctx->list, list) {
3669		if (!rc) {
3670			if (!try_wait_for_completion(&rdata->done)) {
3671				mutex_unlock(&ctx->aio_mutex);
3672				return;
3673			}
3674
3675			if (rdata->result == -EAGAIN) {
3676				/* resend call if it's a retryable error */
3677				struct list_head tmp_list;
3678				unsigned int got_bytes = rdata->got_bytes;
3679
3680				list_del_init(&rdata->list);
3681				INIT_LIST_HEAD(&tmp_list);
3682
3683				/*
3684				 * Got a part of data and then reconnect has
3685				 * happened -- fill the buffer and continue
3686				 * reading.
3687				 */
3688				if (got_bytes && got_bytes < rdata->bytes) {
3689					rc = 0;
3690					if (!ctx->direct_io)
3691						rc = cifs_readdata_to_iov(rdata, to);
3692					if (rc) {
3693						kref_put(&rdata->refcount,
3694							cifs_uncached_readdata_release);
3695						continue;
3696					}
3697				}
3698
3699				if (ctx->direct_io) {
3700					/*
3701					 * Re-use rdata as this is a
3702					 * direct I/O
3703					 */
3704					rc = cifs_resend_rdata(
3705						rdata,
3706						&tmp_list, ctx);
3707				} else {
3708					rc = cifs_send_async_read(
3709						rdata->offset + got_bytes,
3710						rdata->bytes - got_bytes,
3711						rdata->cfile, cifs_sb,
3712						&tmp_list, ctx);
3713
3714					kref_put(&rdata->refcount,
3715						cifs_uncached_readdata_release);
3716				}
3717
3718				list_splice(&tmp_list, &ctx->list);
3719
3720				goto again;
3721			} else if (rdata->result)
3722				rc = rdata->result;
3723			else if (!ctx->direct_io)
3724				rc = cifs_readdata_to_iov(rdata, to);
3725
3726			/* if there was a short read -- discard anything left */
3727			if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
3728				rc = -ENODATA;
3729
3730			ctx->total_len += rdata->got_bytes;
3731		}
3732		list_del_init(&rdata->list);
3733		kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3734	}
3735
3736	if (!ctx->direct_io)
3737		ctx->total_len = ctx->len - iov_iter_count(to);
3738
3739	/* mask nodata case */
3740	if (rc == -ENODATA)
3741		rc = 0;
3742
3743	ctx->rc = (rc == 0) ? ctx->total_len : rc;
3744
3745	mutex_unlock(&ctx->aio_mutex);
3746
3747	if (ctx->iocb && ctx->iocb->ki_complete)
3748		ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
3749	else
3750		complete(&ctx->done);
3751}
3752
3753static ssize_t __cifs_readv(
3754	struct kiocb *iocb, struct iov_iter *to, bool direct)
3755{
3756	size_t len;
3757	struct file *file = iocb->ki_filp;
3758	struct cifs_sb_info *cifs_sb;
3759	struct cifsFileInfo *cfile;
3760	struct cifs_tcon *tcon;
3761	ssize_t rc, total_read = 0;
3762	loff_t offset = iocb->ki_pos;
3763	struct cifs_aio_ctx *ctx;
3764
3765	/*
3766	 * iov_iter_get_pages_alloc() doesn't work with ITER_KVEC,
3767	 * fall back to data copy read path
3768	 * this could be improved by getting pages directly in ITER_KVEC
3769	 */
3770	if (direct && to->type & ITER_KVEC) {
3771		cifs_dbg(FYI, "use non-direct cifs_user_readv for kvec I/O\n");
3772		direct = false;
3773	}
3774
3775	len = iov_iter_count(to);
3776	if (!len)
3777		return 0;
3778
3779	cifs_sb = CIFS_FILE_SB(file);
3780	cfile = file->private_data;
3781	tcon = tlink_tcon(cfile->tlink);
3782
3783	if (!tcon->ses->server->ops->async_readv)
3784		return -ENOSYS;
3785
3786	if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3787		cifs_dbg(FYI, "attempting read on write only file instance\n");
3788
3789	ctx = cifs_aio_ctx_alloc();
3790	if (!ctx)
3791		return -ENOMEM;
3792
3793	ctx->cfile = cifsFileInfo_get(cfile);
3794
3795	if (!is_sync_kiocb(iocb))
3796		ctx->iocb = iocb;
3797
3798	if (iter_is_iovec(to))
3799		ctx->should_dirty = true;
3800
3801	if (direct) {
3802		ctx->pos = offset;
3803		ctx->direct_io = true;
3804		ctx->iter = *to;
3805		ctx->len = len;
3806	} else {
3807		rc = setup_aio_ctx_iter(ctx, to, READ);
3808		if (rc) {
3809			kref_put(&ctx->refcount, cifs_aio_ctx_release);
3810			return rc;
3811		}
3812		len = ctx->len;
3813	}
3814
 
 
 
 
 
 
 
 
 
3815	/* grab a lock here due to read response handlers can access ctx */
3816	mutex_lock(&ctx->aio_mutex);
3817
3818	rc = cifs_send_async_read(offset, len, cfile, cifs_sb, &ctx->list, ctx);
3819
3820	/* if at least one read request send succeeded, then reset rc */
3821	if (!list_empty(&ctx->list))
3822		rc = 0;
3823
3824	mutex_unlock(&ctx->aio_mutex);
3825
3826	if (rc) {
3827		kref_put(&ctx->refcount, cifs_aio_ctx_release);
3828		return rc;
3829	}
3830
3831	if (!is_sync_kiocb(iocb)) {
3832		kref_put(&ctx->refcount, cifs_aio_ctx_release);
3833		return -EIOCBQUEUED;
3834	}
3835
3836	rc = wait_for_completion_killable(&ctx->done);
3837	if (rc) {
3838		mutex_lock(&ctx->aio_mutex);
3839		ctx->rc = rc = -EINTR;
3840		total_read = ctx->total_len;
3841		mutex_unlock(&ctx->aio_mutex);
3842	} else {
3843		rc = ctx->rc;
3844		total_read = ctx->total_len;
3845	}
3846
3847	kref_put(&ctx->refcount, cifs_aio_ctx_release);
3848
3849	if (total_read) {
3850		iocb->ki_pos += total_read;
3851		return total_read;
3852	}
3853	return rc;
3854}
3855
3856ssize_t cifs_direct_readv(struct kiocb *iocb, struct iov_iter *to)
3857{
3858	return __cifs_readv(iocb, to, true);
3859}
3860
3861ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
3862{
3863	return __cifs_readv(iocb, to, false);
3864}
3865
3866ssize_t
3867cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3868{
3869	struct inode *inode = file_inode(iocb->ki_filp);
3870	struct cifsInodeInfo *cinode = CIFS_I(inode);
3871	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3872	struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3873						iocb->ki_filp->private_data;
3874	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3875	int rc = -EACCES;
3876
3877	/*
3878	 * In strict cache mode we need to read from the server all the time
3879	 * if we don't have level II oplock because the server can delay mtime
3880	 * change - so we can't make a decision about inode invalidating.
3881	 * And we can also fail with pagereading if there are mandatory locks
3882	 * on pages affected by this read but not on the region from pos to
3883	 * pos+len-1.
3884	 */
3885	if (!CIFS_CACHE_READ(cinode))
3886		return cifs_user_readv(iocb, to);
3887
3888	if (cap_unix(tcon->ses) &&
3889	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
3890	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
3891		return generic_file_read_iter(iocb, to);
3892
3893	/*
3894	 * We need to hold the sem to be sure nobody modifies lock list
3895	 * with a brlock that prevents reading.
3896	 */
3897	down_read(&cinode->lock_sem);
3898	if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3899				     tcon->ses->server->vals->shared_lock_type,
3900				     0, NULL, CIFS_READ_OP))
3901		rc = generic_file_read_iter(iocb, to);
3902	up_read(&cinode->lock_sem);
3903	return rc;
3904}
3905
3906static ssize_t
3907cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
3908{
3909	int rc = -EACCES;
3910	unsigned int bytes_read = 0;
3911	unsigned int total_read;
3912	unsigned int current_read_size;
3913	unsigned int rsize;
3914	struct cifs_sb_info *cifs_sb;
3915	struct cifs_tcon *tcon;
3916	struct TCP_Server_Info *server;
3917	unsigned int xid;
3918	char *cur_offset;
3919	struct cifsFileInfo *open_file;
3920	struct cifs_io_parms io_parms;
3921	int buf_type = CIFS_NO_BUFFER;
3922	__u32 pid;
3923
3924	xid = get_xid();
3925	cifs_sb = CIFS_FILE_SB(file);
3926
3927	/* FIXME: set up handlers for larger reads and/or convert to async */
3928	rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
3929
3930	if (file->private_data == NULL) {
3931		rc = -EBADF;
3932		free_xid(xid);
3933		return rc;
3934	}
3935	open_file = file->private_data;
3936	tcon = tlink_tcon(open_file->tlink);
3937	server = tcon->ses->server;
3938
3939	if (!server->ops->sync_read) {
3940		free_xid(xid);
3941		return -ENOSYS;
3942	}
3943
3944	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3945		pid = open_file->pid;
3946	else
3947		pid = current->tgid;
3948
3949	if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3950		cifs_dbg(FYI, "attempting read on write only file instance\n");
3951
3952	for (total_read = 0, cur_offset = read_data; read_size > total_read;
3953	     total_read += bytes_read, cur_offset += bytes_read) {
3954		do {
3955			current_read_size = min_t(uint, read_size - total_read,
3956						  rsize);
3957			/*
3958			 * For windows me and 9x we do not want to request more
3959			 * than it negotiated since it will refuse the read
3960			 * then.
3961			 */
3962			if ((tcon->ses) && !(tcon->ses->capabilities &
3963				tcon->ses->server->vals->cap_large_files)) {
3964				current_read_size = min_t(uint,
3965					current_read_size, CIFSMaxBufSize);
3966			}
3967			if (open_file->invalidHandle) {
3968				rc = cifs_reopen_file(open_file, true);
3969				if (rc != 0)
3970					break;
3971			}
3972			io_parms.pid = pid;
3973			io_parms.tcon = tcon;
3974			io_parms.offset = *offset;
3975			io_parms.length = current_read_size;
 
3976			rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
3977						    &bytes_read, &cur_offset,
3978						    &buf_type);
3979		} while (rc == -EAGAIN);
3980
3981		if (rc || (bytes_read == 0)) {
3982			if (total_read) {
3983				break;
3984			} else {
3985				free_xid(xid);
3986				return rc;
3987			}
3988		} else {
3989			cifs_stats_bytes_read(tcon, total_read);
3990			*offset += bytes_read;
3991		}
3992	}
3993	free_xid(xid);
3994	return total_read;
3995}
3996
3997/*
3998 * If the page is mmap'ed into a process' page tables, then we need to make
3999 * sure that it doesn't change while being written back.
4000 */
4001static vm_fault_t
4002cifs_page_mkwrite(struct vm_fault *vmf)
4003{
4004	struct page *page = vmf->page;
4005
4006	lock_page(page);
 
 
 
 
 
 
 
 
 
 
 
 
4007	return VM_FAULT_LOCKED;
4008}
4009
4010static const struct vm_operations_struct cifs_file_vm_ops = {
4011	.fault = filemap_fault,
4012	.map_pages = filemap_map_pages,
4013	.page_mkwrite = cifs_page_mkwrite,
4014};
4015
4016int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
4017{
4018	int xid, rc = 0;
4019	struct inode *inode = file_inode(file);
4020
4021	xid = get_xid();
4022
4023	if (!CIFS_CACHE_READ(CIFS_I(inode)))
4024		rc = cifs_zap_mapping(inode);
4025	if (!rc)
4026		rc = generic_file_mmap(file, vma);
4027	if (!rc)
4028		vma->vm_ops = &cifs_file_vm_ops;
4029
4030	free_xid(xid);
4031	return rc;
4032}
4033
4034int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
4035{
4036	int rc, xid;
4037
4038	xid = get_xid();
4039
4040	rc = cifs_revalidate_file(file);
4041	if (rc)
4042		cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
4043			 rc);
4044	if (!rc)
4045		rc = generic_file_mmap(file, vma);
4046	if (!rc)
4047		vma->vm_ops = &cifs_file_vm_ops;
4048
4049	free_xid(xid);
4050	return rc;
4051}
4052
4053static void
4054cifs_readv_complete(struct work_struct *work)
4055{
4056	unsigned int i, got_bytes;
4057	struct cifs_readdata *rdata = container_of(work,
4058						struct cifs_readdata, work);
4059
4060	got_bytes = rdata->got_bytes;
4061	for (i = 0; i < rdata->nr_pages; i++) {
4062		struct page *page = rdata->pages[i];
4063
4064		lru_cache_add_file(page);
4065
4066		if (rdata->result == 0 ||
4067		    (rdata->result == -EAGAIN && got_bytes)) {
4068			flush_dcache_page(page);
4069			SetPageUptodate(page);
4070		}
4071
4072		unlock_page(page);
4073
4074		if (rdata->result == 0 ||
4075		    (rdata->result == -EAGAIN && got_bytes))
4076			cifs_readpage_to_fscache(rdata->mapping->host, page);
4077
 
 
4078		got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
4079
4080		put_page(page);
4081		rdata->pages[i] = NULL;
4082	}
4083	kref_put(&rdata->refcount, cifs_readdata_release);
4084}
4085
4086static int
4087readpages_fill_pages(struct TCP_Server_Info *server,
4088		     struct cifs_readdata *rdata, struct iov_iter *iter,
4089		     unsigned int len)
4090{
4091	int result = 0;
4092	unsigned int i;
4093	u64 eof;
4094	pgoff_t eof_index;
4095	unsigned int nr_pages = rdata->nr_pages;
4096	unsigned int page_offset = rdata->page_offset;
4097
4098	/* determine the eof that the server (probably) has */
4099	eof = CIFS_I(rdata->mapping->host)->server_eof;
4100	eof_index = eof ? (eof - 1) >> PAGE_SHIFT : 0;
4101	cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
4102
4103	rdata->got_bytes = 0;
4104	rdata->tailsz = PAGE_SIZE;
4105	for (i = 0; i < nr_pages; i++) {
4106		struct page *page = rdata->pages[i];
4107		unsigned int to_read = rdata->pagesz;
4108		size_t n;
4109
4110		if (i == 0)
4111			to_read -= page_offset;
4112		else
4113			page_offset = 0;
4114
4115		n = to_read;
4116
4117		if (len >= to_read) {
4118			len -= to_read;
4119		} else if (len > 0) {
4120			/* enough for partial page, fill and zero the rest */
4121			zero_user(page, len + page_offset, to_read - len);
4122			n = rdata->tailsz = len;
4123			len = 0;
4124		} else if (page->index > eof_index) {
4125			/*
4126			 * The VFS will not try to do readahead past the
4127			 * i_size, but it's possible that we have outstanding
4128			 * writes with gaps in the middle and the i_size hasn't
4129			 * caught up yet. Populate those with zeroed out pages
4130			 * to prevent the VFS from repeatedly attempting to
4131			 * fill them until the writes are flushed.
4132			 */
4133			zero_user(page, 0, PAGE_SIZE);
4134			lru_cache_add_file(page);
4135			flush_dcache_page(page);
4136			SetPageUptodate(page);
4137			unlock_page(page);
4138			put_page(page);
4139			rdata->pages[i] = NULL;
4140			rdata->nr_pages--;
4141			continue;
4142		} else {
4143			/* no need to hold page hostage */
4144			lru_cache_add_file(page);
4145			unlock_page(page);
4146			put_page(page);
4147			rdata->pages[i] = NULL;
4148			rdata->nr_pages--;
4149			continue;
4150		}
4151
4152		if (iter)
4153			result = copy_page_from_iter(
4154					page, page_offset, n, iter);
4155#ifdef CONFIG_CIFS_SMB_DIRECT
4156		else if (rdata->mr)
4157			result = n;
4158#endif
4159		else
4160			result = cifs_read_page_from_socket(
4161					server, page, page_offset, n);
4162		if (result < 0)
4163			break;
4164
4165		rdata->got_bytes += result;
4166	}
4167
4168	return rdata->got_bytes > 0 && result != -ECONNABORTED ?
4169						rdata->got_bytes : result;
4170}
4171
4172static int
4173cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
4174			       struct cifs_readdata *rdata, unsigned int len)
4175{
4176	return readpages_fill_pages(server, rdata, NULL, len);
4177}
4178
4179static int
4180cifs_readpages_copy_into_pages(struct TCP_Server_Info *server,
4181			       struct cifs_readdata *rdata,
4182			       struct iov_iter *iter)
4183{
4184	return readpages_fill_pages(server, rdata, iter, iter->count);
4185}
4186
4187static int
4188readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
4189		    unsigned int rsize, struct list_head *tmplist,
4190		    unsigned int *nr_pages, loff_t *offset, unsigned int *bytes)
4191{
4192	struct page *page, *tpage;
4193	unsigned int expected_index;
4194	int rc;
4195	gfp_t gfp = readahead_gfp_mask(mapping);
4196
4197	INIT_LIST_HEAD(tmplist);
4198
4199	page = lru_to_page(page_list);
4200
4201	/*
4202	 * Lock the page and put it in the cache. Since no one else
4203	 * should have access to this page, we're safe to simply set
4204	 * PG_locked without checking it first.
4205	 */
4206	__SetPageLocked(page);
4207	rc = add_to_page_cache_locked(page, mapping,
4208				      page->index, gfp);
4209
4210	/* give up if we can't stick it in the cache */
4211	if (rc) {
4212		__ClearPageLocked(page);
4213		return rc;
4214	}
4215
4216	/* move first page to the tmplist */
4217	*offset = (loff_t)page->index << PAGE_SHIFT;
4218	*bytes = PAGE_SIZE;
4219	*nr_pages = 1;
4220	list_move_tail(&page->lru, tmplist);
4221
4222	/* now try and add more pages onto the request */
4223	expected_index = page->index + 1;
4224	list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
4225		/* discontinuity ? */
4226		if (page->index != expected_index)
4227			break;
4228
4229		/* would this page push the read over the rsize? */
4230		if (*bytes + PAGE_SIZE > rsize)
4231			break;
4232
4233		__SetPageLocked(page);
4234		if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
4235			__ClearPageLocked(page);
4236			break;
4237		}
4238		list_move_tail(&page->lru, tmplist);
4239		(*bytes) += PAGE_SIZE;
4240		expected_index++;
4241		(*nr_pages)++;
4242	}
4243	return rc;
4244}
4245
4246static int cifs_readpages(struct file *file, struct address_space *mapping,
4247	struct list_head *page_list, unsigned num_pages)
4248{
4249	int rc;
4250	struct list_head tmplist;
4251	struct cifsFileInfo *open_file = file->private_data;
4252	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
4253	struct TCP_Server_Info *server;
4254	pid_t pid;
4255	unsigned int xid;
 
 
 
 
4256
4257	xid = get_xid();
4258	/*
4259	 * Reads as many pages as possible from fscache. Returns -ENOBUFS
4260	 * immediately if the cookie is negative
4261	 *
4262	 * After this point, every page in the list might have PG_fscache set,
4263	 * so we will need to clean that up off of every page we don't use.
4264	 */
4265	rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
4266					 &num_pages);
4267	if (rc == 0) {
4268		free_xid(xid);
4269		return rc;
4270	}
4271
4272	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4273		pid = open_file->pid;
4274	else
4275		pid = current->tgid;
4276
4277	rc = 0;
4278	server = tlink_tcon(open_file->tlink)->ses->server;
4279
4280	cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
4281		 __func__, file, mapping, num_pages);
4282
4283	/*
4284	 * Start with the page at end of list and move it to private
4285	 * list. Do the same with any following pages until we hit
4286	 * the rsize limit, hit an index discontinuity, or run out of
4287	 * pages. Issue the async read and then start the loop again
4288	 * until the list is empty.
4289	 *
4290	 * Note that list order is important. The page_list is in
4291	 * the order of declining indexes. When we put the pages in
4292	 * the rdata->pages, then we want them in increasing order.
4293	 */
4294	while (!list_empty(page_list)) {
4295		unsigned int i, nr_pages, bytes, rsize;
4296		loff_t offset;
4297		struct page *page, *tpage;
4298		struct cifs_readdata *rdata;
4299		struct cifs_credits credits_on_stack;
4300		struct cifs_credits *credits = &credits_on_stack;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4301
4302		if (open_file->invalidHandle) {
4303			rc = cifs_reopen_file(open_file, true);
4304			if (rc == -EAGAIN)
4305				continue;
4306			else if (rc)
4307				break;
 
4308		}
4309
4310		rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
 
 
 
 
 
4311						   &rsize, credits);
4312		if (rc)
4313			break;
 
 
4314
4315		/*
4316		 * Give up immediately if rsize is too small to read an entire
4317		 * page. The VFS will fall back to readpage. We should never
4318		 * reach this point however since we set ra_pages to 0 when the
4319		 * rsize is smaller than a cache page.
4320		 */
4321		if (unlikely(rsize < PAGE_SIZE)) {
4322			add_credits_and_wake_if(server, credits, 0);
4323			free_xid(xid);
4324			return 0;
4325		}
4326
4327		rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
4328					 &nr_pages, &offset, &bytes);
4329		if (rc) {
4330			add_credits_and_wake_if(server, credits, 0);
4331			break;
4332		}
4333
4334		rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
4335		if (!rdata) {
4336			/* best to give up if we're out of mem */
4337			list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4338				list_del(&page->lru);
4339				lru_cache_add_file(page);
4340				unlock_page(page);
4341				put_page(page);
4342			}
4343			rc = -ENOMEM;
4344			add_credits_and_wake_if(server, credits, 0);
4345			break;
4346		}
4347
4348		rdata->cfile = cifsFileInfo_get(open_file);
4349		rdata->mapping = mapping;
4350		rdata->offset = offset;
4351		rdata->bytes = bytes;
4352		rdata->pid = pid;
4353		rdata->pagesz = PAGE_SIZE;
4354		rdata->tailsz = PAGE_SIZE;
 
 
 
 
 
 
 
 
 
4355		rdata->read_into_pages = cifs_readpages_read_into_pages;
4356		rdata->copy_into_pages = cifs_readpages_copy_into_pages;
4357		rdata->credits = credits_on_stack;
4358
4359		list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4360			list_del(&page->lru);
4361			rdata->pages[rdata->nr_pages++] = page;
4362		}
4363
4364		rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4365
4366		if (!rc) {
4367			if (rdata->cfile->invalidHandle)
4368				rc = -EAGAIN;
4369			else
4370				rc = server->ops->async_readv(rdata);
4371		}
4372
4373		if (rc) {
4374			add_credits_and_wake_if(server, &rdata->credits, 0);
4375			for (i = 0; i < rdata->nr_pages; i++) {
4376				page = rdata->pages[i];
4377				lru_cache_add_file(page);
4378				unlock_page(page);
4379				put_page(page);
4380			}
4381			/* Fallback to the readpage in error/reconnect cases */
4382			kref_put(&rdata->refcount, cifs_readdata_release);
4383			break;
4384		}
4385
4386		kref_put(&rdata->refcount, cifs_readdata_release);
 
4387	}
4388
4389	/* Any pages that have been shown to fscache but didn't get added to
4390	 * the pagecache must be uncached before they get returned to the
4391	 * allocator.
4392	 */
4393	cifs_fscache_readpages_cancel(mapping->host, page_list);
4394	free_xid(xid);
4395	return rc;
4396}
4397
4398/*
4399 * cifs_readpage_worker must be called with the page pinned
4400 */
4401static int cifs_readpage_worker(struct file *file, struct page *page,
4402	loff_t *poffset)
4403{
4404	char *read_data;
4405	int rc;
4406
4407	/* Is the page cached? */
4408	rc = cifs_readpage_from_fscache(file_inode(file), page);
4409	if (rc == 0)
4410		goto read_complete;
4411
4412	read_data = kmap(page);
4413	/* for reads over a certain size could initiate async read ahead */
4414
4415	rc = cifs_read(file, read_data, PAGE_SIZE, poffset);
4416
4417	if (rc < 0)
4418		goto io_error;
4419	else
4420		cifs_dbg(FYI, "Bytes read %d\n", rc);
4421
4422	/* we do not want atime to be less than mtime, it broke some apps */
4423	file_inode(file)->i_atime = current_time(file_inode(file));
4424	if (timespec64_compare(&(file_inode(file)->i_atime), &(file_inode(file)->i_mtime)))
4425		file_inode(file)->i_atime = file_inode(file)->i_mtime;
4426	else
4427		file_inode(file)->i_atime = current_time(file_inode(file));
4428
4429	if (PAGE_SIZE > rc)
4430		memset(read_data + rc, 0, PAGE_SIZE - rc);
4431
4432	flush_dcache_page(page);
4433	SetPageUptodate(page);
4434
4435	/* send this page to the cache */
4436	cifs_readpage_to_fscache(file_inode(file), page);
4437
4438	rc = 0;
4439
4440io_error:
4441	kunmap(page);
4442	unlock_page(page);
4443
4444read_complete:
4445	return rc;
4446}
4447
4448static int cifs_readpage(struct file *file, struct page *page)
4449{
4450	loff_t offset = (loff_t)page->index << PAGE_SHIFT;
 
4451	int rc = -EACCES;
4452	unsigned int xid;
4453
4454	xid = get_xid();
4455
4456	if (file->private_data == NULL) {
4457		rc = -EBADF;
4458		free_xid(xid);
4459		return rc;
4460	}
4461
4462	cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
4463		 page, (int)offset, (int)offset);
4464
4465	rc = cifs_readpage_worker(file, page, &offset);
4466
4467	free_xid(xid);
4468	return rc;
4469}
4470
4471static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
4472{
4473	struct cifsFileInfo *open_file;
4474
4475	spin_lock(&cifs_inode->open_file_lock);
4476	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
4477		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
4478			spin_unlock(&cifs_inode->open_file_lock);
4479			return 1;
4480		}
4481	}
4482	spin_unlock(&cifs_inode->open_file_lock);
4483	return 0;
4484}
4485
4486/* We do not want to update the file size from server for inodes
4487   open for write - to avoid races with writepage extending
4488   the file - in the future we could consider allowing
4489   refreshing the inode only on increases in the file size
4490   but this is tricky to do without racing with writebehind
4491   page caching in the current Linux kernel design */
4492bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
4493{
4494	if (!cifsInode)
4495		return true;
4496
4497	if (is_inode_writable(cifsInode)) {
4498		/* This inode is open for write at least once */
4499		struct cifs_sb_info *cifs_sb;
4500
4501		cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
4502		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
4503			/* since no page cache to corrupt on directio
4504			we can change size safely */
4505			return true;
4506		}
4507
4508		if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
4509			return true;
4510
4511		return false;
4512	} else
4513		return true;
4514}
4515
4516static int cifs_write_begin(struct file *file, struct address_space *mapping,
4517			loff_t pos, unsigned len, unsigned flags,
4518			struct page **pagep, void **fsdata)
4519{
4520	int oncethru = 0;
4521	pgoff_t index = pos >> PAGE_SHIFT;
4522	loff_t offset = pos & (PAGE_SIZE - 1);
4523	loff_t page_start = pos & PAGE_MASK;
4524	loff_t i_size;
4525	struct page *page;
4526	int rc = 0;
4527
4528	cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
4529
4530start:
4531	page = grab_cache_page_write_begin(mapping, index, flags);
4532	if (!page) {
4533		rc = -ENOMEM;
4534		goto out;
4535	}
4536
4537	if (PageUptodate(page))
4538		goto out;
4539
4540	/*
4541	 * If we write a full page it will be up to date, no need to read from
4542	 * the server. If the write is short, we'll end up doing a sync write
4543	 * instead.
4544	 */
4545	if (len == PAGE_SIZE)
4546		goto out;
4547
4548	/*
4549	 * optimize away the read when we have an oplock, and we're not
4550	 * expecting to use any of the data we'd be reading in. That
4551	 * is, when the page lies beyond the EOF, or straddles the EOF
4552	 * and the write will cover all of the existing data.
4553	 */
4554	if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
4555		i_size = i_size_read(mapping->host);
4556		if (page_start >= i_size ||
4557		    (offset == 0 && (pos + len) >= i_size)) {
4558			zero_user_segments(page, 0, offset,
4559					   offset + len,
4560					   PAGE_SIZE);
4561			/*
4562			 * PageChecked means that the parts of the page
4563			 * to which we're not writing are considered up
4564			 * to date. Once the data is copied to the
4565			 * page, it can be set uptodate.
4566			 */
4567			SetPageChecked(page);
4568			goto out;
4569		}
4570	}
4571
4572	if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
4573		/*
4574		 * might as well read a page, it is fast enough. If we get
4575		 * an error, we don't need to return it. cifs_write_end will
4576		 * do a sync write instead since PG_uptodate isn't set.
4577		 */
4578		cifs_readpage_worker(file, page, &page_start);
4579		put_page(page);
4580		oncethru = 1;
4581		goto start;
4582	} else {
4583		/* we could try using another file handle if there is one -
4584		   but how would we lock it to prevent close of that handle
4585		   racing with this read? In any case
4586		   this will be written out by write_end so is fine */
4587	}
4588out:
4589	*pagep = page;
4590	return rc;
4591}
4592
4593static int cifs_release_page(struct page *page, gfp_t gfp)
4594{
4595	if (PagePrivate(page))
4596		return 0;
4597
4598	return cifs_fscache_release_page(page, gfp);
 
 
 
 
 
4599}
4600
4601static void cifs_invalidate_page(struct page *page, unsigned int offset,
4602				 unsigned int length)
4603{
4604	struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
4605
4606	if (offset == 0 && length == PAGE_SIZE)
4607		cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
4608}
4609
4610static int cifs_launder_page(struct page *page)
4611{
4612	int rc = 0;
4613	loff_t range_start = page_offset(page);
4614	loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
4615	struct writeback_control wbc = {
4616		.sync_mode = WB_SYNC_ALL,
4617		.nr_to_write = 0,
4618		.range_start = range_start,
4619		.range_end = range_end,
4620	};
4621
4622	cifs_dbg(FYI, "Launder page: %p\n", page);
4623
4624	if (clear_page_dirty_for_io(page))
4625		rc = cifs_writepage_locked(page, &wbc);
4626
4627	cifs_fscache_invalidate_page(page, page->mapping->host);
4628	return rc;
4629}
4630
4631void cifs_oplock_break(struct work_struct *work)
4632{
4633	struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
4634						  oplock_break);
4635	struct inode *inode = d_inode(cfile->dentry);
4636	struct cifsInodeInfo *cinode = CIFS_I(inode);
4637	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4638	struct TCP_Server_Info *server = tcon->ses->server;
4639	int rc = 0;
 
4640
4641	wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
4642			TASK_UNINTERRUPTIBLE);
4643
4644	server->ops->downgrade_oplock(server, cinode,
4645		test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2, &cinode->flags));
4646
4647	if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
4648						cifs_has_mand_locks(cinode)) {
4649		cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
4650			 inode);
4651		cinode->oplock = 0;
4652	}
4653
4654	if (inode && S_ISREG(inode->i_mode)) {
4655		if (CIFS_CACHE_READ(cinode))
4656			break_lease(inode, O_RDONLY);
4657		else
4658			break_lease(inode, O_WRONLY);
4659		rc = filemap_fdatawrite(inode->i_mapping);
4660		if (!CIFS_CACHE_READ(cinode)) {
4661			rc = filemap_fdatawait(inode->i_mapping);
4662			mapping_set_error(inode->i_mapping, rc);
4663			cifs_zap_mapping(inode);
4664		}
4665		cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
 
 
4666	}
4667
4668	rc = cifs_push_locks(cfile);
4669	if (rc)
4670		cifs_dbg(VFS, "Push locks rc = %d\n", rc);
4671
 
4672	/*
4673	 * releasing stale oplock after recent reconnect of smb session using
4674	 * a now incorrect file handle is not a data integrity issue but do
4675	 * not bother sending an oplock release if session to server still is
4676	 * disconnected since oplock already released by the server
4677	 */
4678	if (!cfile->oplock_break_cancelled) {
4679		rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
4680							     cinode);
4681		cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
4682	}
4683	_cifsFileInfo_put(cfile, false /* do not wait for ourself */);
 
4684	cifs_done_oplock_break(cinode);
4685}
4686
4687/*
4688 * The presence of cifs_direct_io() in the address space ops vector
4689 * allowes open() O_DIRECT flags which would have failed otherwise.
4690 *
4691 * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
4692 * so this method should never be called.
4693 *
4694 * Direct IO is not yet supported in the cached mode. 
4695 */
4696static ssize_t
4697cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
4698{
4699        /*
4700         * FIXME
4701         * Eventually need to support direct IO for non forcedirectio mounts
4702         */
4703        return -EINVAL;
4704}
4705
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
4706
4707const struct address_space_operations cifs_addr_ops = {
4708	.readpage = cifs_readpage,
4709	.readpages = cifs_readpages,
4710	.writepage = cifs_writepage,
4711	.writepages = cifs_writepages,
4712	.write_begin = cifs_write_begin,
4713	.write_end = cifs_write_end,
4714	.set_page_dirty = __set_page_dirty_nobuffers,
4715	.releasepage = cifs_release_page,
4716	.direct_IO = cifs_direct_io,
4717	.invalidatepage = cifs_invalidate_page,
4718	.launder_page = cifs_launder_page,
 
 
 
 
 
 
 
4719};
4720
4721/*
4722 * cifs_readpages requires the server to support a buffer large enough to
4723 * contain the header plus one complete page of data.  Otherwise, we need
4724 * to leave cifs_readpages out of the address space operations.
4725 */
4726const struct address_space_operations cifs_addr_ops_smallbuf = {
4727	.readpage = cifs_readpage,
4728	.writepage = cifs_writepage,
4729	.writepages = cifs_writepages,
4730	.write_begin = cifs_write_begin,
4731	.write_end = cifs_write_end,
4732	.set_page_dirty = __set_page_dirty_nobuffers,
4733	.releasepage = cifs_release_page,
4734	.invalidatepage = cifs_invalidate_page,
4735	.launder_page = cifs_launder_page,
 
4736};