file.c 108.8 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4
/*
 *   fs/cifs/file.c
 *
 *   vfs operations that deal with files
S
Steve French 已提交
5
 *
6
 *   Copyright (C) International Business Machines  Corp., 2002,2010
L
Linus Torvalds 已提交
7
 *   Author(s): Steve French (sfrench@us.ibm.com)
J
[CIFS]  
Jeremy Allison 已提交
8
 *              Jeremy Allison (jra@samba.org)
L
Linus Torvalds 已提交
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24
 *
 *   This library is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as published
 *   by the Free Software Foundation; either version 2.1 of the License, or
 *   (at your option) any later version.
 *
 *   This library is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
 *   the GNU Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public License
 *   along with this library; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 */
#include <linux/fs.h>
25
#include <linux/backing-dev.h>
L
Linus Torvalds 已提交
26 27 28 29
#include <linux/stat.h>
#include <linux/fcntl.h>
#include <linux/pagemap.h>
#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>
L
Linus Torvalds 已提交
36 37 38 39 40 41 42 43
#include <asm/div64.h>
#include "cifsfs.h"
#include "cifspdu.h"
#include "cifsglob.h"
#include "cifsproto.h"
#include "cifs_unicode.h"
#include "cifs_debug.h"
#include "cifs_fs_sb.h"
44
#include "fscache.h"
45
#include "smbdirect.h"
46

L
Linus Torvalds 已提交
47 48 49 50 51 52 53 54 55 56 57 58 59
static inline int cifs_convert_flags(unsigned int flags)
{
	if ((flags & O_ACCMODE) == O_RDONLY)
		return GENERIC_READ;
	else if ((flags & O_ACCMODE) == O_WRONLY)
		return GENERIC_WRITE;
	else if ((flags & O_ACCMODE) == O_RDWR) {
		/* GENERIC_ALL is too much permission to request
		   can cause unnecessary access denied on create */
		/* return GENERIC_ALL; */
		return (GENERIC_READ | GENERIC_WRITE);
	}

60 61 62
	return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
		FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
		FILE_READ_DATA);
63
}
64

65
static u32 cifs_posix_convert_flags(unsigned int flags)
66
{
67
	u32 posix_flags = 0;
68

69
	if ((flags & O_ACCMODE) == O_RDONLY)
70
		posix_flags = SMB_O_RDONLY;
71
	else if ((flags & O_ACCMODE) == O_WRONLY)
72 73 74 75
		posix_flags = SMB_O_WRONLY;
	else if ((flags & O_ACCMODE) == O_RDWR)
		posix_flags = SMB_O_RDWR;

76
	if (flags & O_CREAT) {
77
		posix_flags |= SMB_O_CREAT;
78 79 80
		if (flags & O_EXCL)
			posix_flags |= SMB_O_EXCL;
	} else if (flags & O_EXCL)
81 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",
			 current->comm, current->tgid);
83

84 85 86
	if (flags & O_TRUNC)
		posix_flags |= SMB_O_TRUNC;
	/* be safe and imply O_SYNC for O_DSYNC */
87
	if (flags & O_DSYNC)
88
		posix_flags |= SMB_O_SYNC;
89
	if (flags & O_DIRECTORY)
90
		posix_flags |= SMB_O_DIRECTORY;
91
	if (flags & O_NOFOLLOW)
92
		posix_flags |= SMB_O_NOFOLLOW;
93
	if (flags & O_DIRECT)
94
		posix_flags |= SMB_O_DIRECT;
95 96

	return posix_flags;
L
Linus Torvalds 已提交
97 98 99 100 101 102 103 104 105 106
}

static inline int cifs_get_disposition(unsigned int flags)
{
	if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
		return FILE_CREATE;
	else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
		return FILE_OVERWRITE_IF;
	else if ((flags & O_CREAT) == O_CREAT)
		return FILE_OPEN_IF;
107 108
	else if ((flags & O_TRUNC) == O_TRUNC)
		return FILE_OVERWRITE;
L
Linus Torvalds 已提交
109 110 111 112
	else
		return FILE_OPEN;
}

113 114
int cifs_posix_open(char *full_path, struct inode **pinode,
			struct super_block *sb, int mode, unsigned int f_flags,
115
			__u32 *poplock, __u16 *pnetfid, unsigned int xid)
116 117 118 119 120 121 122
{
	int rc;
	FILE_UNIX_BASIC_INFO *presp_data;
	__u32 posix_flags = 0;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
	struct cifs_fattr fattr;
	struct tcon_link *tlink;
123
	struct cifs_tcon *tcon;
124

125
	cifs_dbg(FYI, "posix open %s\n", full_path);
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142

	presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
	if (presp_data == NULL)
		return -ENOMEM;

	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink)) {
		rc = PTR_ERR(tlink);
		goto posix_open_ret;
	}

	tcon = tlink_tcon(tlink);
	mode &= ~current_umask();

	posix_flags = cifs_posix_convert_flags(f_flags);
	rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
			     poplock, full_path, cifs_sb->local_nls,
143
			     cifs_remap(cifs_sb));
144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173
	cifs_put_tlink(tlink);

	if (rc)
		goto posix_open_ret;

	if (presp_data->Type == cpu_to_le32(-1))
		goto posix_open_ret; /* open ok, caller does qpathinfo */

	if (!pinode)
		goto posix_open_ret; /* caller does not need info */

	cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);

	/* get new inode and set it up */
	if (*pinode == NULL) {
		cifs_fill_uniqueid(sb, &fattr);
		*pinode = cifs_iget(sb, &fattr);
		if (!*pinode) {
			rc = -ENOMEM;
			goto posix_open_ret;
		}
	} else {
		cifs_fattr_to_inode(*pinode, &fattr);
	}

posix_open_ret:
	kfree(presp_data);
	return rc;
}

174 175
static int
cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
176 177
	     struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
	     struct cifs_fid *fid, unsigned int xid)
178 179
{
	int rc;
180
	int desired_access;
181
	int disposition;
182
	int create_options = CREATE_NOT_DIR;
183
	FILE_ALL_INFO *buf;
P
Pavel Shilovsky 已提交
184
	struct TCP_Server_Info *server = tcon->ses->server;
185
	struct cifs_open_parms oparms;
186

P
Pavel Shilovsky 已提交
187
	if (!server->ops->open)
188 189 190
		return -ENOSYS;

	desired_access = cifs_convert_flags(f_flags);
191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223

/*********************************************************************
 *  open flag mapping table:
 *
 *	POSIX Flag            CIFS Disposition
 *	----------            ----------------
 *	O_CREAT               FILE_OPEN_IF
 *	O_CREAT | O_EXCL      FILE_CREATE
 *	O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
 *	O_TRUNC               FILE_OVERWRITE
 *	none of the above     FILE_OPEN
 *
 *	Note that there is not a direct match between disposition
 *	FILE_SUPERSEDE (ie create whether or not file exists although
 *	O_CREAT | O_TRUNC is similar but truncates the existing
 *	file rather than creating a new file as FILE_SUPERSEDE does
 *	(which uses the attributes / metadata passed in on open call)
 *?
 *?  O_SYNC is a reasonable match to CIFS writethrough flag
 *?  and the read write flags match reasonably.  O_LARGEFILE
 *?  is irrelevant because largefile support is always used
 *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
 *	 O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
 *********************************************************************/

	disposition = cifs_get_disposition(f_flags);

	/* BB pass O_SYNC flag through on file attributes .. BB */

	buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
	if (!buf)
		return -ENOMEM;

224 225 226
	if (backup_cred(cifs_sb))
		create_options |= CREATE_OPEN_BACKUP_INTENT;

227 228 229 230 231 232 233
	/* O_SYNC also has bit for O_DSYNC so following check picks up either */
	if (f_flags & O_SYNC)
		create_options |= CREATE_WRITE_THROUGH;

	if (f_flags & O_DIRECT)
		create_options |= CREATE_NO_BUFFER;

234 235 236 237 238 239 240
	oparms.tcon = tcon;
	oparms.cifs_sb = cifs_sb;
	oparms.desired_access = desired_access;
	oparms.create_options = create_options;
	oparms.disposition = disposition;
	oparms.path = full_path;
	oparms.fid = fid;
241
	oparms.reconnect = false;
242 243

	rc = server->ops->open(xid, &oparms, oplock, buf);
244 245 246 247 248 249 250 251 252

	if (rc)
		goto out;

	if (tcon->unix_ext)
		rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
					      xid);
	else
		rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
253
					 xid, fid);
254

255 256 257 258 259 260
	if (rc) {
		server->ops->close(xid, tcon, fid);
		if (rc == -ESTALE)
			rc = -EOPENSTALE;
	}

261 262 263 264 265
out:
	kfree(buf);
	return rc;
}

266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
static bool
cifs_has_mand_locks(struct cifsInodeInfo *cinode)
{
	struct cifs_fid_locks *cur;
	bool has_locks = false;

	down_read(&cinode->lock_sem);
	list_for_each_entry(cur, &cinode->llist, llist) {
		if (!list_empty(&cur->locks)) {
			has_locks = true;
			break;
		}
	}
	up_read(&cinode->lock_sem);
	return has_locks;
}

283
struct cifsFileInfo *
284
cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
285 286
		  struct tcon_link *tlink, __u32 oplock)
{
G
Goldwyn Rodrigues 已提交
287
	struct dentry *dentry = file_dentry(file);
288
	struct inode *inode = d_inode(dentry);
289 290
	struct cifsInodeInfo *cinode = CIFS_I(inode);
	struct cifsFileInfo *cfile;
291
	struct cifs_fid_locks *fdlocks;
292
	struct cifs_tcon *tcon = tlink_tcon(tlink);
293
	struct TCP_Server_Info *server = tcon->ses->server;
294 295 296 297 298

	cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
	if (cfile == NULL)
		return cfile;

299 300 301 302 303 304 305 306 307
	fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
	if (!fdlocks) {
		kfree(cfile);
		return NULL;
	}

	INIT_LIST_HEAD(&fdlocks->locks);
	fdlocks->cfile = cfile;
	cfile->llist = fdlocks;
308
	down_write(&cinode->lock_sem);
309
	list_add(&fdlocks->llist, &cinode->llist);
310
	up_write(&cinode->lock_sem);
311

312 313 314 315 316 317 318 319
	cfile->count = 1;
	cfile->pid = current->tgid;
	cfile->uid = current_fsuid();
	cfile->dentry = dget(dentry);
	cfile->f_flags = file->f_flags;
	cfile->invalidHandle = false;
	cfile->tlink = cifs_get_tlink(tlink);
	INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
320
	mutex_init(&cfile->fh_mutex);
321
	spin_lock_init(&cfile->file_info_lock);
322

323 324
	cifs_sb_active(inode->i_sb);

325 326 327 328
	/*
	 * If the server returned a read oplock and we have mandatory brlocks,
	 * set oplock level to None.
	 */
329
	if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
330
		cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
331 332 333
		oplock = 0;
	}

334
	spin_lock(&tcon->open_file_lock);
335
	if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
336 337 338
		oplock = fid->pending_open->oplock;
	list_del(&fid->pending_open->olist);

339
	fid->purge_cache = false;
340
	server->ops->set_fid(cfile, fid, oplock);
341 342

	list_add(&cfile->tlist, &tcon->openFileList);
343

344
	/* if readable file instance put first in list*/
345
	spin_lock(&cinode->open_file_lock);
346
	if (file->f_mode & FMODE_READ)
347
		list_add(&cfile->flist, &cinode->openFileList);
348
	else
349
		list_add_tail(&cfile->flist, &cinode->openFileList);
350
	spin_unlock(&cinode->open_file_lock);
351
	spin_unlock(&tcon->open_file_lock);
352

353
	if (fid->purge_cache)
354
		cifs_zap_mapping(inode);
355

356 357
	file->private_data = cfile;
	return cfile;
358 359
}

360 361 362
struct cifsFileInfo *
cifsFileInfo_get(struct cifsFileInfo *cifs_file)
{
363
	spin_lock(&cifs_file->file_info_lock);
364
	cifsFileInfo_get_locked(cifs_file);
365
	spin_unlock(&cifs_file->file_info_lock);
366 367 368
	return cifs_file;
}

369 370 371 372
/**
 * cifsFileInfo_put - release a reference of file priv data
 *
 * Always potentially wait for oplock handler. See _cifsFileInfo_put().
373
 */
374
void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392
{
	_cifsFileInfo_put(cifs_file, true);
}

/**
 * _cifsFileInfo_put - release a reference of file priv data
 *
 * This may involve closing the filehandle @cifs_file out on the
 * server. Must be called without holding tcon->open_file_lock and
 * cifs_file->file_info_lock.
 *
 * If @wait_for_oplock_handler is true and we are releasing the last
 * reference, wait for any running oplock break handler of the file
 * and cancel any pending one. If calling this function from the
 * oplock break handler, you need to pass false.
 *
 */
void _cifsFileInfo_put(struct cifsFileInfo *cifs_file, bool wait_oplock_handler)
393
{
394
	struct inode *inode = d_inode(cifs_file->dentry);
395
	struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
396
	struct TCP_Server_Info *server = tcon->ses->server;
P
Pavel Shilovsky 已提交
397
	struct cifsInodeInfo *cifsi = CIFS_I(inode);
398 399
	struct super_block *sb = inode->i_sb;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
400
	struct cifsLockInfo *li, *tmp;
401 402
	struct cifs_fid fid;
	struct cifs_pending_open open;
403
	bool oplock_break_cancelled;
404

405 406 407
	spin_lock(&tcon->open_file_lock);

	spin_lock(&cifs_file->file_info_lock);
408
	if (--cifs_file->count > 0) {
409 410
		spin_unlock(&cifs_file->file_info_lock);
		spin_unlock(&tcon->open_file_lock);
411 412
		return;
	}
413
	spin_unlock(&cifs_file->file_info_lock);
414

415 416 417 418 419 420
	if (server->ops->get_lease_key)
		server->ops->get_lease_key(inode, &fid);

	/* store open in pending opens to make sure we don't miss lease break */
	cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);

421
	/* remove it from the lists */
422
	spin_lock(&cifsi->open_file_lock);
423
	list_del(&cifs_file->flist);
424
	spin_unlock(&cifsi->open_file_lock);
425 426 427
	list_del(&cifs_file->tlist);

	if (list_empty(&cifsi->openFileList)) {
428
		cifs_dbg(FYI, "closing last open instance for inode %p\n",
429
			 d_inode(cifs_file->dentry));
430 431 432 433 434
		/*
		 * In strict cache mode we need invalidate mapping on the last
		 * close  because it may cause a error when we open this file
		 * again and get at least level II oplock.
		 */
435
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
436
			set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
437
		cifs_set_oplock_level(cifsi, 0);
438
	}
439 440

	spin_unlock(&tcon->open_file_lock);
441

442 443
	oplock_break_cancelled = wait_oplock_handler ?
		cancel_work_sync(&cifs_file->oplock_break) : false;
444

445
	if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
446
		struct TCP_Server_Info *server = tcon->ses->server;
447
		unsigned int xid;
448

449
		xid = get_xid();
450
		if (server->ops->close)
451 452
			server->ops->close(xid, tcon, &cifs_file->fid);
		_free_xid(xid);
453 454
	}

455 456 457
	if (oplock_break_cancelled)
		cifs_done_oplock_break(cifsi);

458 459
	cifs_del_pending_open(&open);

460 461
	/*
	 * Delete any outstanding lock records. We'll lose them when the file
462 463
	 * is closed anyway.
	 */
464
	down_write(&cifsi->lock_sem);
465
	list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
466
		list_del(&li->llist);
467
		cifs_del_lock_waiters(li);
468
		kfree(li);
469
	}
470 471
	list_del(&cifs_file->llist->llist);
	kfree(cifs_file->llist);
472
	up_write(&cifsi->lock_sem);
473 474 475

	cifs_put_tlink(cifs_file->tlink);
	dput(cifs_file->dentry);
476
	cifs_sb_deactive(sb);
477
	kfree(cifs_file);
478 479
}

L
Linus Torvalds 已提交
480
int cifs_open(struct inode *inode, struct file *file)
481

L
Linus Torvalds 已提交
482 483
{
	int rc = -EACCES;
484
	unsigned int xid;
485
	__u32 oplock;
L
Linus Torvalds 已提交
486
	struct cifs_sb_info *cifs_sb;
P
Pavel Shilovsky 已提交
487
	struct TCP_Server_Info *server;
488
	struct cifs_tcon *tcon;
489
	struct tcon_link *tlink;
490
	struct cifsFileInfo *cfile = NULL;
L
Linus Torvalds 已提交
491
	char *full_path = NULL;
P
Pavel Shilovsky 已提交
492
	bool posix_open_ok = false;
493
	struct cifs_fid fid;
494
	struct cifs_pending_open open;
L
Linus Torvalds 已提交
495

496
	xid = get_xid();
L
Linus Torvalds 已提交
497 498

	cifs_sb = CIFS_SB(inode->i_sb);
499 500
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink)) {
501
		free_xid(xid);
502 503 504
		return PTR_ERR(tlink);
	}
	tcon = tlink_tcon(tlink);
P
Pavel Shilovsky 已提交
505
	server = tcon->ses->server;
L
Linus Torvalds 已提交
506

G
Goldwyn Rodrigues 已提交
507
	full_path = build_path_from_dentry(file_dentry(file));
L
Linus Torvalds 已提交
508
	if (full_path == NULL) {
509
		rc = -ENOMEM;
510
		goto out;
L
Linus Torvalds 已提交
511 512
	}

513
	cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
514
		 inode, file->f_flags, full_path);
515

516 517 518 519 520 521 522 523
	if (file->f_flags & O_DIRECT &&
	    cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
			file->f_op = &cifs_file_direct_nobrl_ops;
		else
			file->f_op = &cifs_file_direct_ops;
	}

524
	if (server->oplocks)
525 526 527 528
		oplock = REQ_OPLOCK;
	else
		oplock = 0;

529
	if (!tcon->broken_posix_open && tcon->unix_ext &&
530 531
	    cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
532
		/* can not refresh inode info since size could be stale */
533
		rc = cifs_posix_open(full_path, &inode, inode->i_sb,
534
				cifs_sb->mnt_file_mode /* ignored */,
535
				file->f_flags, &oplock, &fid.netfid, xid);
536
		if (rc == 0) {
537
			cifs_dbg(FYI, "posix open succeeded\n");
P
Pavel Shilovsky 已提交
538
			posix_open_ok = true;
539 540
		} else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
			if (tcon->ses->serverNOS)
541 542 543
				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",
					 tcon->ses->serverName,
					 tcon->ses->serverNOS);
544
			tcon->broken_posix_open = true;
545 546 547
		} else if ((rc != -EIO) && (rc != -EREMOTE) &&
			 (rc != -EOPNOTSUPP)) /* path not found or net err */
			goto out;
548 549 550 551
		/*
		 * Else fallthrough to retry open the old way on network i/o
		 * or DFS errors.
		 */
552 553
	}

554 555 556 557 558
	if (server->ops->get_lease_key)
		server->ops->get_lease_key(inode, &fid);

	cifs_add_pending_open(&fid, tlink, &open);

P
Pavel Shilovsky 已提交
559
	if (!posix_open_ok) {
P
Pavel Shilovsky 已提交
560 561 562
		if (server->ops->get_lease_key)
			server->ops->get_lease_key(inode, &fid);

P
Pavel Shilovsky 已提交
563
		rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
564
				  file->f_flags, &oplock, &fid, xid);
565 566
		if (rc) {
			cifs_del_pending_open(&open);
P
Pavel Shilovsky 已提交
567
			goto out;
568
		}
P
Pavel Shilovsky 已提交
569
	}
570

571 572
	cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
	if (cfile == NULL) {
P
Pavel Shilovsky 已提交
573 574
		if (server->ops->close)
			server->ops->close(xid, tcon, &fid);
575
		cifs_del_pending_open(&open);
L
Linus Torvalds 已提交
576 577 578 579
		rc = -ENOMEM;
		goto out;
	}

580 581
	cifs_fscache_set_inode_cookie(inode, file);

P
Pavel Shilovsky 已提交
582
	if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
583 584 585 586
		/*
		 * Time to set mode which we can not set earlier due to
		 * problems creating new read-only files.
		 */
P
Pavel Shilovsky 已提交
587 588
		struct cifs_unix_set_info_args args = {
			.mode	= inode->i_mode,
589 590
			.uid	= INVALID_UID, /* no change */
			.gid	= INVALID_GID, /* no change */
P
Pavel Shilovsky 已提交
591 592 593 594 595
			.ctime	= NO_CHANGE_64,
			.atime	= NO_CHANGE_64,
			.mtime	= NO_CHANGE_64,
			.device	= 0,
		};
596 597
		CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
				       cfile->pid);
L
Linus Torvalds 已提交
598 599 600 601
	}

out:
	kfree(full_path);
602
	free_xid(xid);
603
	cifs_put_tlink(tlink);
L
Linus Torvalds 已提交
604 605 606
	return rc;
}

P
Pavel Shilovsky 已提交
607 608
static int cifs_push_posix_locks(struct cifsFileInfo *cfile);

609 610
/*
 * Try to reacquire byte range locks that were released when session
P
Pavel Shilovsky 已提交
611
 * to server was lost.
612
 */
P
Pavel Shilovsky 已提交
613 614
static int
cifs_relock_file(struct cifsFileInfo *cfile)
L
Linus Torvalds 已提交
615
{
P
Pavel Shilovsky 已提交
616
	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
617
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
P
Pavel Shilovsky 已提交
618
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
L
Linus Torvalds 已提交
619 620
	int rc = 0;

621
	down_read_nested(&cinode->lock_sem, SINGLE_DEPTH_NESTING);
P
Pavel Shilovsky 已提交
622
	if (cinode->can_cache_brlcks) {
623 624
		/* can cache locks - no need to relock */
		up_read(&cinode->lock_sem);
P
Pavel Shilovsky 已提交
625 626 627 628 629 630 631 632 633
		return rc;
	}

	if (cap_unix(tcon->ses) &&
	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
		rc = cifs_push_posix_locks(cfile);
	else
		rc = tcon->ses->server->ops->push_mand_locks(cfile);
L
Linus Torvalds 已提交
634

635
	up_read(&cinode->lock_sem);
L
Linus Torvalds 已提交
636 637 638
	return rc;
}

639 640
static int
cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
L
Linus Torvalds 已提交
641 642
{
	int rc = -EACCES;
643
	unsigned int xid;
644
	__u32 oplock;
L
Linus Torvalds 已提交
645
	struct cifs_sb_info *cifs_sb;
646
	struct cifs_tcon *tcon;
647 648
	struct TCP_Server_Info *server;
	struct cifsInodeInfo *cinode;
S
Steve French 已提交
649
	struct inode *inode;
L
Linus Torvalds 已提交
650
	char *full_path = NULL;
651
	int desired_access;
L
Linus Torvalds 已提交
652
	int disposition = FILE_OPEN;
653
	int create_options = CREATE_NOT_DIR;
654
	struct cifs_open_parms oparms;
L
Linus Torvalds 已提交
655

656
	xid = get_xid();
657 658 659
	mutex_lock(&cfile->fh_mutex);
	if (!cfile->invalidHandle) {
		mutex_unlock(&cfile->fh_mutex);
660
		rc = 0;
661
		free_xid(xid);
662
		return rc;
L
Linus Torvalds 已提交
663 664
	}

665
	inode = d_inode(cfile->dentry);
L
Linus Torvalds 已提交
666
	cifs_sb = CIFS_SB(inode->i_sb);
667 668 669 670 671 672 673 674 675 676
	tcon = tlink_tcon(cfile->tlink);
	server = tcon->ses->server;

	/*
	 * Can not grab rename sem here because various ops, including those
	 * that already have the rename sem can end up causing writepage to get
	 * called and if the server was down that means we end up here, and we
	 * can never tell if the caller already has the rename_sem.
	 */
	full_path = build_path_from_dentry(cfile->dentry);
L
Linus Torvalds 已提交
677
	if (full_path == NULL) {
678
		rc = -ENOMEM;
679
		mutex_unlock(&cfile->fh_mutex);
680
		free_xid(xid);
681
		return rc;
L
Linus Torvalds 已提交
682 683
	}

684 685
	cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
		 inode, cfile->f_flags, full_path);
L
Linus Torvalds 已提交
686

687
	if (tcon->ses->server->oplocks)
L
Linus Torvalds 已提交
688 689
		oplock = REQ_OPLOCK;
	else
690
		oplock = 0;
L
Linus Torvalds 已提交
691

692
	if (tcon->unix_ext && cap_unix(tcon->ses) &&
693
	    (CIFS_UNIX_POSIX_PATH_OPS_CAP &
694
				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
695 696 697 698
		/*
		 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
		 * original open. Must mask them off for a reopen.
		 */
699
		unsigned int oflags = cfile->f_flags &
J
Jeff Layton 已提交
700
						~(O_CREAT | O_EXCL | O_TRUNC);
701

702
		rc = cifs_posix_open(full_path, NULL, inode->i_sb,
703
				     cifs_sb->mnt_file_mode /* ignored */,
704
				     oflags, &oplock, &cfile->fid.netfid, xid);
705
		if (rc == 0) {
706
			cifs_dbg(FYI, "posix reopen succeeded\n");
707
			oparms.reconnect = true;
708 709
			goto reopen_success;
		}
710 711 712 713
		/*
		 * fallthrough to retry open the old way on errors, especially
		 * in the reconnect path it is important to retry hard
		 */
714 715
	}

716
	desired_access = cifs_convert_flags(cfile->f_flags);
717

718 719 720
	if (backup_cred(cifs_sb))
		create_options |= CREATE_OPEN_BACKUP_INTENT;

P
Pavel Shilovsky 已提交
721
	if (server->ops->get_lease_key)
722
		server->ops->get_lease_key(inode, &cfile->fid);
P
Pavel Shilovsky 已提交
723

724 725 726 727 728 729
	oparms.tcon = tcon;
	oparms.cifs_sb = cifs_sb;
	oparms.desired_access = desired_access;
	oparms.create_options = create_options;
	oparms.disposition = disposition;
	oparms.path = full_path;
730 731
	oparms.fid = &cfile->fid;
	oparms.reconnect = true;
732

733 734
	/*
	 * Can not refresh inode by passing in file_info buf to be returned by
735
	 * ops->open and then calling get_inode_info with returned buf since
736 737 738 739
	 * file might have write behind data that needs to be flushed and server
	 * version of file size can be stale. If we knew for sure that inode was
	 * not dirty locally we could do this.
	 */
740
	rc = server->ops->open(xid, &oparms, &oplock, NULL);
741 742 743 744 745 746 747
	if (rc == -ENOENT && oparms.reconnect == false) {
		/* durable handle timeout is expired - open the file again */
		rc = server->ops->open(xid, &oparms, &oplock, NULL);
		/* indicate that we need to relock the file */
		oparms.reconnect = true;
	}

L
Linus Torvalds 已提交
748
	if (rc) {
749
		mutex_unlock(&cfile->fh_mutex);
750 751
		cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
		cifs_dbg(FYI, "oplock: %d\n", oplock);
J
Jeff Layton 已提交
752 753 754
		goto reopen_error_exit;
	}

755
reopen_success:
756 757 758
	cfile->invalidHandle = false;
	mutex_unlock(&cfile->fh_mutex);
	cinode = CIFS_I(inode);
J
Jeff Layton 已提交
759 760 761

	if (can_flush) {
		rc = filemap_write_and_wait(inode->i_mapping);
762 763
		if (!is_interrupt_error(rc))
			mapping_set_error(inode->i_mapping, rc);
J
Jeff Layton 已提交
764 765

		if (tcon->unix_ext)
766 767
			rc = cifs_get_inode_info_unix(&inode, full_path,
						      inode->i_sb, xid);
J
Jeff Layton 已提交
768
		else
769 770 771 772 773 774 775 776 777 778
			rc = cifs_get_inode_info(&inode, full_path, NULL,
						 inode->i_sb, xid, NULL);
	}
	/*
	 * Else we are writing out data to server already and could deadlock if
	 * we tried to flush data, and since we do not know if we have data that
	 * would invalidate the current end of file on the server we can not go
	 * to the server to get the new inode info.
	 */

779 780 781 782 783 784 785 786 787
	/*
	 * If the server returned a read oplock and we have mandatory brlocks,
	 * set oplock level to None.
	 */
	if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
		cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
		oplock = 0;
	}

788 789 790
	server->ops->set_fid(cfile, &cfile->fid, oplock);
	if (oparms.reconnect)
		cifs_relock_file(cfile);
J
Jeff Layton 已提交
791 792

reopen_error_exit:
L
Linus Torvalds 已提交
793
	kfree(full_path);
794
	free_xid(xid);
L
Linus Torvalds 已提交
795 796 797 798 799
	return rc;
}

int cifs_close(struct inode *inode, struct file *file)
{
800 801 802 803
	if (file->private_data != NULL) {
		cifsFileInfo_put(file->private_data);
		file->private_data = NULL;
	}
J
[CIFS]  
Jeremy Allison 已提交
804

805 806
	/* return code from the ->release op is always ignored */
	return 0;
L
Linus Torvalds 已提交
807 808
}

809 810 811
void
cifs_reopen_persistent_handles(struct cifs_tcon *tcon)
{
812
	struct cifsFileInfo *open_file;
813 814
	struct list_head *tmp;
	struct list_head *tmp1;
815 816
	struct list_head tmp_list;

817 818 819 820 821
	if (!tcon->use_persistent || !tcon->need_reopen_files)
		return;

	tcon->need_reopen_files = false;

822 823
	cifs_dbg(FYI, "Reopen persistent handles");
	INIT_LIST_HEAD(&tmp_list);
824 825 826

	/* list all files open on tree connection, reopen resilient handles  */
	spin_lock(&tcon->open_file_lock);
827
	list_for_each(tmp, &tcon->openFileList) {
828
		open_file = list_entry(tmp, struct cifsFileInfo, tlist);
829 830 831 832
		if (!open_file->invalidHandle)
			continue;
		cifsFileInfo_get(open_file);
		list_add_tail(&open_file->rlist, &tmp_list);
833 834
	}
	spin_unlock(&tcon->open_file_lock);
835 836 837

	list_for_each_safe(tmp, tmp1, &tmp_list) {
		open_file = list_entry(tmp, struct cifsFileInfo, rlist);
838 839
		if (cifs_reopen_file(open_file, false /* do not flush */))
			tcon->need_reopen_files = true;
840 841 842
		list_del_init(&open_file->rlist);
		cifsFileInfo_put(open_file);
	}
843 844
}

L
Linus Torvalds 已提交
845 846 847
int cifs_closedir(struct inode *inode, struct file *file)
{
	int rc = 0;
848
	unsigned int xid;
849
	struct cifsFileInfo *cfile = file->private_data;
850 851 852
	struct cifs_tcon *tcon;
	struct TCP_Server_Info *server;
	char *buf;
L
Linus Torvalds 已提交
853

854
	cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
L
Linus Torvalds 已提交
855

856 857 858
	if (cfile == NULL)
		return rc;

859
	xid = get_xid();
860 861
	tcon = tlink_tcon(cfile->tlink);
	server = tcon->ses->server;
L
Linus Torvalds 已提交
862

863
	cifs_dbg(FYI, "Freeing private data in close dir\n");
864
	spin_lock(&cfile->file_info_lock);
865
	if (server->ops->dir_needs_close(cfile)) {
866
		cfile->invalidHandle = true;
867
		spin_unlock(&cfile->file_info_lock);
868 869 870 871
		if (server->ops->close_dir)
			rc = server->ops->close_dir(xid, tcon, &cfile->fid);
		else
			rc = -ENOSYS;
872
		cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
873 874 875
		/* not much we can do if it fails anyway, ignore rc */
		rc = 0;
	} else
876
		spin_unlock(&cfile->file_info_lock);
877 878 879

	buf = cfile->srch_inf.ntwrk_buf_start;
	if (buf) {
880
		cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
881 882 883 884 885
		cfile->srch_inf.ntwrk_buf_start = NULL;
		if (cfile->srch_inf.smallBuf)
			cifs_small_buf_release(buf);
		else
			cifs_buf_release(buf);
L
Linus Torvalds 已提交
886
	}
887 888 889 890

	cifs_put_tlink(cfile->tlink);
	kfree(file->private_data);
	file->private_data = NULL;
L
Linus Torvalds 已提交
891
	/* BB can we lock the filestruct while this is going on? */
892
	free_xid(xid);
L
Linus Torvalds 已提交
893 894 895
	return rc;
}

896
static struct cifsLockInfo *
897
cifs_lock_init(__u64 offset, __u64 length, __u8 type)
J
[CIFS]  
Jeremy Allison 已提交
898
{
899
	struct cifsLockInfo *lock =
S
Steve French 已提交
900
		kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
901 902 903 904 905 906 907 908 909
	if (!lock)
		return lock;
	lock->offset = offset;
	lock->length = length;
	lock->type = type;
	lock->pid = current->tgid;
	INIT_LIST_HEAD(&lock->blist);
	init_waitqueue_head(&lock->block_q);
	return lock;
910 911
}

912
void
913 914 915 916 917 918 919 920 921
cifs_del_lock_waiters(struct cifsLockInfo *lock)
{
	struct cifsLockInfo *li, *tmp;
	list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
		list_del_init(&li->blist);
		wake_up(&li->block_q);
	}
}

922 923 924 925 926
#define CIFS_LOCK_OP	0
#define CIFS_READ_OP	1
#define CIFS_WRITE_OP	2

/* @rw_check : 0 - no op, 1 - read, 2 - write */
927
static bool
928 929
cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
			    __u64 length, __u8 type, struct cifsFileInfo *cfile,
930
			    struct cifsLockInfo **conf_lock, int rw_check)
931
{
932
	struct cifsLockInfo *li;
933
	struct cifsFileInfo *cur_cfile = fdlocks->cfile;
934
	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
935

936
	list_for_each_entry(li, &fdlocks->locks, llist) {
937 938 939
		if (offset + length <= li->offset ||
		    offset >= li->offset + li->length)
			continue;
940 941 942 943 944 945 946
		if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
		    server->ops->compare_fids(cfile, cur_cfile)) {
			/* shared lock prevents write op through the same fid */
			if (!(li->type & server->vals->shared_lock_type) ||
			    rw_check != CIFS_WRITE_OP)
				continue;
		}
947 948 949
		if ((type & server->vals->shared_lock_type) &&
		    ((server->ops->compare_fids(cfile, cur_cfile) &&
		     current->tgid == li->pid) || type == li->type))
950
			continue;
951 952
		if (conf_lock)
			*conf_lock = li;
953
		return true;
954 955 956 957
	}
	return false;
}

958
bool
959
cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
960
			__u8 type, struct cifsLockInfo **conf_lock,
961
			int rw_check)
962
{
963
	bool rc = false;
964
	struct cifs_fid_locks *cur;
965
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
966

967 968
	list_for_each_entry(cur, &cinode->llist, llist) {
		rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
969
						 cfile, conf_lock, rw_check);
970 971 972 973 974
		if (rc)
			break;
	}

	return rc;
975 976
}

977 978 979 980 981 982 983
/*
 * Check if there is another lock that prevents us to set the lock (mandatory
 * style). If such a lock exists, update the flock structure with its
 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
 * or leave it the same if we can't. Returns 0 if we don't need to request to
 * the server or 1 otherwise.
 */
984
static int
985 986
cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
	       __u8 type, struct file_lock *flock)
987 988 989
{
	int rc = 0;
	struct cifsLockInfo *conf_lock;
990
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
991
	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
992 993
	bool exist;

994
	down_read(&cinode->lock_sem);
995

996
	exist = cifs_find_lock_conflict(cfile, offset, length, type,
997
					&conf_lock, CIFS_LOCK_OP);
998 999 1000 1001
	if (exist) {
		flock->fl_start = conf_lock->offset;
		flock->fl_end = conf_lock->offset + conf_lock->length - 1;
		flock->fl_pid = conf_lock->pid;
1002
		if (conf_lock->type & server->vals->shared_lock_type)
1003 1004 1005 1006 1007 1008 1009 1010
			flock->fl_type = F_RDLCK;
		else
			flock->fl_type = F_WRLCK;
	} else if (!cinode->can_cache_brlcks)
		rc = 1;
	else
		flock->fl_type = F_UNLCK;

1011
	up_read(&cinode->lock_sem);
1012 1013 1014
	return rc;
}

1015
static void
1016
cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
1017
{
1018
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1019
	down_write(&cinode->lock_sem);
1020
	list_add_tail(&lock->llist, &cfile->llist->locks);
1021
	up_write(&cinode->lock_sem);
J
[CIFS]  
Jeremy Allison 已提交
1022 1023
}

1024 1025 1026 1027 1028 1029
/*
 * Set the byte-range lock (mandatory style). Returns:
 * 1) 0, if we set the lock and don't need to request to the server;
 * 2) 1, if no locks prevent us but we need to request to the server;
 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
 */
1030
static int
1031
cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
1032
		 bool wait)
1033
{
1034
	struct cifsLockInfo *conf_lock;
1035
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1036 1037 1038 1039 1040
	bool exist;
	int rc = 0;

try_again:
	exist = false;
1041
	down_write(&cinode->lock_sem);
1042

1043
	exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
1044
					lock->type, &conf_lock, CIFS_LOCK_OP);
1045
	if (!exist && cinode->can_cache_brlcks) {
1046
		list_add_tail(&lock->llist, &cfile->llist->locks);
1047
		up_write(&cinode->lock_sem);
1048 1049 1050 1051 1052 1053 1054 1055 1056
		return rc;
	}

	if (!exist)
		rc = 1;
	else if (!wait)
		rc = -EACCES;
	else {
		list_add_tail(&lock->blist, &conf_lock->blist);
1057
		up_write(&cinode->lock_sem);
1058 1059 1060 1061 1062
		rc = wait_event_interruptible(lock->block_q,
					(lock->blist.prev == &lock->blist) &&
					(lock->blist.next == &lock->blist));
		if (!rc)
			goto try_again;
1063
		down_write(&cinode->lock_sem);
1064
		list_del_init(&lock->blist);
1065 1066
	}

1067
	up_write(&cinode->lock_sem);
1068 1069 1070
	return rc;
}

1071 1072 1073 1074 1075 1076 1077
/*
 * Check if there is another lock that prevents us to set the lock (posix
 * style). If such a lock exists, update the flock structure with its
 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
 * or leave it the same if we can't. Returns 0 if we don't need to request to
 * the server or 1 otherwise.
 */
1078
static int
1079 1080 1081
cifs_posix_lock_test(struct file *file, struct file_lock *flock)
{
	int rc = 0;
A
Al Viro 已提交
1082
	struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1083 1084
	unsigned char saved_type = flock->fl_type;

1085 1086 1087
	if ((flock->fl_flags & FL_POSIX) == 0)
		return 1;

1088
	down_read(&cinode->lock_sem);
1089 1090 1091 1092 1093 1094 1095
	posix_test_lock(file, flock);

	if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
		flock->fl_type = saved_type;
		rc = 1;
	}

1096
	up_read(&cinode->lock_sem);
1097 1098 1099
	return rc;
}

1100 1101 1102 1103 1104 1105
/*
 * Set the byte-range lock (posix style). Returns:
 * 1) 0, if we set the lock and don't need to request to the server;
 * 2) 1, if we need to request to the server;
 * 3) <0, if the error occurs while setting the lock.
 */
1106 1107 1108
static int
cifs_posix_lock_set(struct file *file, struct file_lock *flock)
{
A
Al Viro 已提交
1109
	struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1110 1111 1112 1113
	int rc = 1;

	if ((flock->fl_flags & FL_POSIX) == 0)
		return rc;
1114

1115
try_again:
1116
	down_write(&cinode->lock_sem);
1117
	if (!cinode->can_cache_brlcks) {
1118
		up_write(&cinode->lock_sem);
1119
		return rc;
1120
	}
1121 1122

	rc = posix_lock_file(file, flock, NULL);
1123
	up_write(&cinode->lock_sem);
1124 1125 1126 1127
	if (rc == FILE_LOCK_DEFERRED) {
		rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
		if (!rc)
			goto try_again;
1128
		posix_unblock_lock(flock);
1129
	}
1130
	return rc;
1131 1132
}

1133
int
1134
cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1135
{
1136 1137
	unsigned int xid;
	int rc = 0, stored_rc;
1138 1139
	struct cifsLockInfo *li, *tmp;
	struct cifs_tcon *tcon;
1140
	unsigned int num, max_num, max_buf;
1141
	LOCKING_ANDX_RANGE *buf, *cur;
1142 1143 1144 1145
	static const int types[] = {
		LOCKING_ANDX_LARGE_FILES,
		LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
	};
1146
	int i;
1147

1148
	xid = get_xid();
1149 1150
	tcon = tlink_tcon(cfile->tlink);

1151 1152
	/*
	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1153
	 * and check it before using.
1154 1155
	 */
	max_buf = tcon->ses->server->maxBuf;
1156
	if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) {
1157
		free_xid(xid);
1158 1159 1160
		return -EINVAL;
	}

1161 1162 1163 1164
	BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
		     PAGE_SIZE);
	max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
			PAGE_SIZE);
1165 1166
	max_num = (max_buf - sizeof(struct smb_hdr)) /
						sizeof(LOCKING_ANDX_RANGE);
1167
	buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1168
	if (!buf) {
1169
		free_xid(xid);
1170
		return -ENOMEM;
1171 1172 1173 1174 1175
	}

	for (i = 0; i < 2; i++) {
		cur = buf;
		num = 0;
1176
		list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1177 1178 1179 1180 1181 1182 1183 1184
			if (li->type != types[i])
				continue;
			cur->Pid = cpu_to_le16(li->pid);
			cur->LengthLow = cpu_to_le32((u32)li->length);
			cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
			cur->OffsetLow = cpu_to_le32((u32)li->offset);
			cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
			if (++num == max_num) {
1185 1186
				stored_rc = cifs_lockv(xid, tcon,
						       cfile->fid.netfid,
1187 1188
						       (__u8)li->type, 0, num,
						       buf);
1189 1190 1191 1192 1193 1194 1195 1196 1197
				if (stored_rc)
					rc = stored_rc;
				cur = buf;
				num = 0;
			} else
				cur++;
		}

		if (num) {
1198
			stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1199
					       (__u8)types[i], 0, num, buf);
1200 1201 1202
			if (stored_rc)
				rc = stored_rc;
		}
1203 1204
	}

1205
	kfree(buf);
1206
	free_xid(xid);
1207 1208 1209
	return rc;
}

1210 1211 1212 1213 1214 1215
static __u32
hash_lockowner(fl_owner_t owner)
{
	return cifs_lock_secret ^ hash32_ptr((const void *)owner);
}

1216 1217 1218 1219 1220 1221 1222 1223 1224
struct lock_to_push {
	struct list_head llist;
	__u64 offset;
	__u64 length;
	__u32 pid;
	__u16 netfid;
	__u8 type;
};

1225
static int
1226
cifs_push_posix_locks(struct cifsFileInfo *cfile)
1227
{
1228
	struct inode *inode = d_inode(cfile->dentry);
1229
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1230 1231
	struct file_lock *flock;
	struct file_lock_context *flctx = inode->i_flctx;
1232
	unsigned int count = 0, i;
1233
	int rc = 0, xid, type;
1234 1235
	struct list_head locks_to_send, *el;
	struct lock_to_push *lck, *tmp;
1236 1237
	__u64 length;

1238
	xid = get_xid();
1239

1240 1241
	if (!flctx)
		goto out;
1242

1243 1244 1245 1246 1247 1248
	spin_lock(&flctx->flc_lock);
	list_for_each(el, &flctx->flc_posix) {
		count++;
	}
	spin_unlock(&flctx->flc_lock);

1249 1250
	INIT_LIST_HEAD(&locks_to_send);

1251
	/*
1252 1253
	 * Allocating count locks is enough because no FL_POSIX locks can be
	 * added to the list while we are holding cinode->lock_sem that
1254
	 * protects locking operations of this inode.
1255
	 */
1256
	for (i = 0; i < count; i++) {
1257 1258 1259 1260 1261 1262 1263 1264 1265
		lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
		if (!lck) {
			rc = -ENOMEM;
			goto err_out;
		}
		list_add_tail(&lck->llist, &locks_to_send);
	}

	el = locks_to_send.next;
1266
	spin_lock(&flctx->flc_lock);
1267
	list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
1268
		if (el == &locks_to_send) {
1269 1270 1271 1272
			/*
			 * The list ended. We don't have enough allocated
			 * structures - something is really wrong.
			 */
1273
			cifs_dbg(VFS, "Can't push all brlocks!\n");
1274 1275
			break;
		}
1276 1277 1278 1279 1280
		length = 1 + flock->fl_end - flock->fl_start;
		if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
			type = CIFS_RDLCK;
		else
			type = CIFS_WRLCK;
1281
		lck = list_entry(el, struct lock_to_push, llist);
1282
		lck->pid = hash_lockowner(flock->fl_owner);
1283
		lck->netfid = cfile->fid.netfid;
1284 1285 1286
		lck->length = length;
		lck->type = type;
		lck->offset = flock->fl_start;
1287
	}
1288
	spin_unlock(&flctx->flc_lock);
1289 1290 1291 1292 1293

	list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
		int stored_rc;

		stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1294
					     lck->offset, lck->length, NULL,
1295 1296 1297 1298 1299 1300 1301
					     lck->type, 0);
		if (stored_rc)
			rc = stored_rc;
		list_del(&lck->llist);
		kfree(lck);
	}

1302
out:
1303
	free_xid(xid);
1304
	return rc;
1305 1306 1307 1308 1309 1310
err_out:
	list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
		list_del(&lck->llist);
		kfree(lck);
	}
	goto out;
1311 1312
}

1313
static int
1314
cifs_push_locks(struct cifsFileInfo *cfile)
1315
{
1316
	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1317
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1318
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1319 1320 1321 1322 1323 1324 1325 1326
	int rc = 0;

	/* we are going to update can_cache_brlcks here - need a write access */
	down_write(&cinode->lock_sem);
	if (!cinode->can_cache_brlcks) {
		up_write(&cinode->lock_sem);
		return rc;
	}
1327

1328
	if (cap_unix(tcon->ses) &&
1329 1330
	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1331 1332 1333
		rc = cifs_push_posix_locks(cfile);
	else
		rc = tcon->ses->server->ops->push_mand_locks(cfile);
1334

1335 1336 1337
	cinode->can_cache_brlcks = false;
	up_write(&cinode->lock_sem);
	return rc;
1338 1339
}

1340
static void
1341
cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1342
		bool *wait_flag, struct TCP_Server_Info *server)
L
Linus Torvalds 已提交
1343
{
1344
	if (flock->fl_flags & FL_POSIX)
1345
		cifs_dbg(FYI, "Posix\n");
1346
	if (flock->fl_flags & FL_FLOCK)
1347
		cifs_dbg(FYI, "Flock\n");
1348
	if (flock->fl_flags & FL_SLEEP) {
1349
		cifs_dbg(FYI, "Blocking lock\n");
1350
		*wait_flag = true;
L
Linus Torvalds 已提交
1351
	}
1352
	if (flock->fl_flags & FL_ACCESS)
1353
		cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1354
	if (flock->fl_flags & FL_LEASE)
1355
		cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1356
	if (flock->fl_flags &
1357 1358
	    (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
	       FL_ACCESS | FL_LEASE | FL_CLOSE)))
1359
		cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
L
Linus Torvalds 已提交
1360

1361
	*type = server->vals->large_lock_type;
1362
	if (flock->fl_type == F_WRLCK) {
1363
		cifs_dbg(FYI, "F_WRLCK\n");
1364
		*type |= server->vals->exclusive_lock_type;
1365 1366
		*lock = 1;
	} else if (flock->fl_type == F_UNLCK) {
1367
		cifs_dbg(FYI, "F_UNLCK\n");
1368
		*type |= server->vals->unlock_lock_type;
1369 1370 1371
		*unlock = 1;
		/* Check if unlock includes more than one lock range */
	} else if (flock->fl_type == F_RDLCK) {
1372
		cifs_dbg(FYI, "F_RDLCK\n");
1373
		*type |= server->vals->shared_lock_type;
1374 1375
		*lock = 1;
	} else if (flock->fl_type == F_EXLCK) {
1376
		cifs_dbg(FYI, "F_EXLCK\n");
1377
		*type |= server->vals->exclusive_lock_type;
1378 1379
		*lock = 1;
	} else if (flock->fl_type == F_SHLCK) {
1380
		cifs_dbg(FYI, "F_SHLCK\n");
1381
		*type |= server->vals->shared_lock_type;
1382
		*lock = 1;
L
Linus Torvalds 已提交
1383
	} else
1384
		cifs_dbg(FYI, "Unknown type of lock\n");
1385
}
L
Linus Torvalds 已提交
1386

1387
static int
1388
cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1389
	   bool wait_flag, bool posix_lck, unsigned int xid)
1390 1391 1392
{
	int rc = 0;
	__u64 length = 1 + flock->fl_end - flock->fl_start;
1393 1394
	struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1395
	struct TCP_Server_Info *server = tcon->ses->server;
1396
	__u16 netfid = cfile->fid.netfid;
1397

1398 1399
	if (posix_lck) {
		int posix_lock_type;
1400 1401 1402 1403 1404

		rc = cifs_posix_lock_test(file, flock);
		if (!rc)
			return rc;

1405
		if (type & server->vals->shared_lock_type)
1406 1407 1408
			posix_lock_type = CIFS_RDLCK;
		else
			posix_lock_type = CIFS_WRLCK;
1409 1410
		rc = CIFSSMBPosixLock(xid, tcon, netfid,
				      hash_lockowner(flock->fl_owner),
1411
				      flock->fl_start, length, flock,
1412
				      posix_lock_type, wait_flag);
1413 1414
		return rc;
	}
L
Linus Torvalds 已提交
1415

1416
	rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1417 1418 1419
	if (!rc)
		return rc;

1420
	/* BB we could chain these into one lock request BB */
1421 1422
	rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
				    1, 0, false);
1423
	if (rc == 0) {
1424 1425
		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
					    type, 0, 1, false);
1426 1427
		flock->fl_type = F_UNLCK;
		if (rc != 0)
1428 1429
			cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
				 rc);
1430
		return 0;
L
Linus Torvalds 已提交
1431
	}
J
[CIFS]  
Jeremy Allison 已提交
1432

1433
	if (type & server->vals->shared_lock_type) {
1434
		flock->fl_type = F_WRLCK;
1435
		return 0;
J
[CIFS]  
Jeremy Allison 已提交
1436 1437
	}

1438 1439 1440 1441 1442
	type &= ~server->vals->exclusive_lock_type;

	rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
				    type | server->vals->shared_lock_type,
				    1, 0, false);
1443
	if (rc == 0) {
1444 1445
		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
			type | server->vals->shared_lock_type, 0, 1, false);
1446 1447
		flock->fl_type = F_RDLCK;
		if (rc != 0)
1448 1449
			cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
				 rc);
1450 1451 1452
	} else
		flock->fl_type = F_WRLCK;

1453
	return 0;
1454 1455
}

1456
void
1457 1458 1459 1460 1461 1462 1463
cifs_move_llist(struct list_head *source, struct list_head *dest)
{
	struct list_head *li, *tmp;
	list_for_each_safe(li, tmp, source)
		list_move(li, dest);
}

1464
void
1465 1466 1467 1468 1469 1470 1471 1472 1473 1474
cifs_free_llist(struct list_head *llist)
{
	struct cifsLockInfo *li, *tmp;
	list_for_each_entry_safe(li, tmp, llist, llist) {
		cifs_del_lock_waiters(li);
		list_del(&li->llist);
		kfree(li);
	}
}

1475
int
1476 1477
cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
		  unsigned int xid)
1478 1479
{
	int rc = 0, stored_rc;
1480 1481 1482 1483
	static const int types[] = {
		LOCKING_ANDX_LARGE_FILES,
		LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
	};
1484
	unsigned int i;
1485
	unsigned int max_num, num, max_buf;
1486 1487
	LOCKING_ANDX_RANGE *buf, *cur;
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1488
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1489 1490 1491 1492 1493 1494
	struct cifsLockInfo *li, *tmp;
	__u64 length = 1 + flock->fl_end - flock->fl_start;
	struct list_head tmp_llist;

	INIT_LIST_HEAD(&tmp_llist);

1495 1496
	/*
	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1497
	 * and check it before using.
1498 1499
	 */
	max_buf = tcon->ses->server->maxBuf;
1500
	if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE)))
1501 1502
		return -EINVAL;

1503 1504 1505 1506
	BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
		     PAGE_SIZE);
	max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
			PAGE_SIZE);
1507 1508
	max_num = (max_buf - sizeof(struct smb_hdr)) /
						sizeof(LOCKING_ANDX_RANGE);
1509
	buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1510 1511 1512
	if (!buf)
		return -ENOMEM;

1513
	down_write(&cinode->lock_sem);
1514 1515 1516
	for (i = 0; i < 2; i++) {
		cur = buf;
		num = 0;
1517
		list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1518 1519 1520 1521 1522 1523 1524 1525
			if (flock->fl_start > li->offset ||
			    (flock->fl_start + length) <
			    (li->offset + li->length))
				continue;
			if (current->tgid != li->pid)
				continue;
			if (types[i] != li->type)
				continue;
1526
			if (cinode->can_cache_brlcks) {
1527 1528
				/*
				 * We can cache brlock requests - simply remove
1529
				 * a lock from the file's list.
1530 1531 1532 1533
				 */
				list_del(&li->llist);
				cifs_del_lock_waiters(li);
				kfree(li);
1534
				continue;
1535
			}
1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547
			cur->Pid = cpu_to_le16(li->pid);
			cur->LengthLow = cpu_to_le32((u32)li->length);
			cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
			cur->OffsetLow = cpu_to_le32((u32)li->offset);
			cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
			/*
			 * We need to save a lock here to let us add it again to
			 * the file's list if the unlock range request fails on
			 * the server.
			 */
			list_move(&li->llist, &tmp_llist);
			if (++num == max_num) {
1548 1549
				stored_rc = cifs_lockv(xid, tcon,
						       cfile->fid.netfid,
1550 1551 1552 1553 1554 1555 1556 1557
						       li->type, num, 0, buf);
				if (stored_rc) {
					/*
					 * We failed on the unlock range
					 * request - add all locks from the tmp
					 * list to the head of the file's list.
					 */
					cifs_move_llist(&tmp_llist,
1558
							&cfile->llist->locks);
1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569
					rc = stored_rc;
				} else
					/*
					 * The unlock range request succeed -
					 * free the tmp list.
					 */
					cifs_free_llist(&tmp_llist);
				cur = buf;
				num = 0;
			} else
				cur++;
1570 1571
		}
		if (num) {
1572
			stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1573 1574
					       types[i], num, 0, buf);
			if (stored_rc) {
1575 1576
				cifs_move_llist(&tmp_llist,
						&cfile->llist->locks);
1577 1578 1579 1580 1581 1582
				rc = stored_rc;
			} else
				cifs_free_llist(&tmp_llist);
		}
	}

1583
	up_write(&cinode->lock_sem);
1584 1585 1586 1587
	kfree(buf);
	return rc;
}

1588
static int
1589
cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1590 1591
	   bool wait_flag, bool posix_lck, int lock, int unlock,
	   unsigned int xid)
1592 1593 1594 1595 1596
{
	int rc = 0;
	__u64 length = 1 + flock->fl_end - flock->fl_start;
	struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1597
	struct TCP_Server_Info *server = tcon->ses->server;
1598
	struct inode *inode = d_inode(cfile->dentry);
1599 1600

	if (posix_lck) {
1601
		int posix_lock_type;
1602 1603 1604 1605 1606

		rc = cifs_posix_lock_set(file, flock);
		if (!rc || rc < 0)
			return rc;

1607
		if (type & server->vals->shared_lock_type)
1608 1609 1610
			posix_lock_type = CIFS_RDLCK;
		else
			posix_lock_type = CIFS_WRLCK;
1611

1612
		if (unlock == 1)
1613
			posix_lock_type = CIFS_UNLCK;
J
[CIFS]  
Jeremy Allison 已提交
1614

1615
		rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1616 1617
				      hash_lockowner(flock->fl_owner),
				      flock->fl_start, length,
1618
				      NULL, posix_lock_type, wait_flag);
1619 1620
		goto out;
	}
J
[CIFS]  
Jeremy Allison 已提交
1621

1622
	if (lock) {
1623 1624
		struct cifsLockInfo *lock;

1625
		lock = cifs_lock_init(flock->fl_start, length, type);
1626 1627 1628
		if (!lock)
			return -ENOMEM;

1629
		rc = cifs_lock_add_if(cfile, lock, wait_flag);
1630
		if (rc < 0) {
1631
			kfree(lock);
1632 1633 1634
			return rc;
		}
		if (!rc)
1635 1636
			goto out;

1637 1638 1639 1640 1641 1642 1643
		/*
		 * Windows 7 server can delay breaking lease from read to None
		 * if we set a byte-range lock on a file - break it explicitly
		 * before sending the lock to the server to be sure the next
		 * read won't conflict with non-overlapted locks due to
		 * pagereading.
		 */
1644 1645
		if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
					CIFS_CACHE_READ(CIFS_I(inode))) {
1646
			cifs_zap_mapping(inode);
1647 1648
			cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
				 inode);
1649
			CIFS_I(inode)->oplock = 0;
1650 1651
		}

1652 1653
		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
					    type, 1, 0, wait_flag);
1654 1655
		if (rc) {
			kfree(lock);
1656
			return rc;
1657
		}
1658

1659
		cifs_lock_add(cfile, lock);
1660
	} else if (unlock)
1661
		rc = server->ops->mand_unlock_range(cfile, flock, xid);
1662 1663

out:
1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675
	if (flock->fl_flags & FL_POSIX) {
		/*
		 * If this is a request to remove all locks because we
		 * are closing the file, it doesn't matter if the
		 * unlocking failed as both cifs.ko and the SMB server
		 * remove the lock on file close
		 */
		if (rc) {
			cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc);
			if (!(flock->fl_flags & FL_CLOSE))
				return rc;
		}
1676
		rc = locks_lock_file_wait(file, flock);
1677
	}
1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691
	return rc;
}

int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
{
	int rc, xid;
	int lock = 0, unlock = 0;
	bool wait_flag = false;
	bool posix_lck = false;
	struct cifs_sb_info *cifs_sb;
	struct cifs_tcon *tcon;
	struct cifsInodeInfo *cinode;
	struct cifsFileInfo *cfile;
	__u16 netfid;
1692
	__u32 type;
1693 1694

	rc = -EACCES;
1695
	xid = get_xid();
1696

1697 1698 1699
	cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
		 cmd, flock->fl_flags, flock->fl_type,
		 flock->fl_start, flock->fl_end);
1700 1701 1702

	cfile = (struct cifsFileInfo *)file->private_data;
	tcon = tlink_tcon(cfile->tlink);
1703 1704 1705 1706

	cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
			tcon->ses->server);

1707
	cifs_sb = CIFS_FILE_SB(file);
1708
	netfid = cfile->fid.netfid;
A
Al Viro 已提交
1709
	cinode = CIFS_I(file_inode(file));
1710

1711
	if (cap_unix(tcon->ses) &&
1712 1713 1714 1715 1716 1717 1718 1719
	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
		posix_lck = true;
	/*
	 * BB add code here to normalize offset and length to account for
	 * negative length which we can not accept over the wire.
	 */
	if (IS_GETLK(cmd)) {
1720
		rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1721
		free_xid(xid);
1722 1723 1724 1725 1726 1727 1728 1729
		return rc;
	}

	if (!lock && !unlock) {
		/*
		 * if no lock or unlock then nothing to do since we do not
		 * know what it is
		 */
1730
		free_xid(xid);
1731
		return -EOPNOTSUPP;
J
[CIFS]  
Jeremy Allison 已提交
1732 1733
	}

1734 1735
	rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
			xid);
1736
	free_xid(xid);
L
Linus Torvalds 已提交
1737 1738 1739
	return rc;
}

1740 1741 1742 1743
/*
 * update the file size (if needed) after a write. Should be called with
 * the inode->i_lock held
 */
1744
void
1745 1746 1747 1748 1749 1750 1751 1752 1753
cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
		      unsigned int bytes_written)
{
	loff_t end_of_write = offset + bytes_written;

	if (end_of_write > cifsi->server_eof)
		cifsi->server_eof = end_of_write;
}

1754 1755 1756
static ssize_t
cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
	   size_t write_size, loff_t *offset)
L
Linus Torvalds 已提交
1757 1758 1759 1760 1761
{
	int rc = 0;
	unsigned int bytes_written = 0;
	unsigned int total_written;
	struct cifs_sb_info *cifs_sb;
1762 1763
	struct cifs_tcon *tcon;
	struct TCP_Server_Info *server;
1764
	unsigned int xid;
1765
	struct dentry *dentry = open_file->dentry;
1766
	struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
1767
	struct cifs_io_parms io_parms;
L
Linus Torvalds 已提交
1768

1769
	cifs_sb = CIFS_SB(dentry->d_sb);
L
Linus Torvalds 已提交
1770

A
Al Viro 已提交
1771 1772
	cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
		 write_size, *offset, dentry);
L
Linus Torvalds 已提交
1773

1774 1775 1776 1777 1778
	tcon = tlink_tcon(open_file->tlink);
	server = tcon->ses->server;

	if (!server->ops->sync_write)
		return -ENOSYS;
1779

1780
	xid = get_xid();
L
Linus Torvalds 已提交
1781 1782 1783 1784 1785

	for (total_written = 0; write_size > total_written;
	     total_written += bytes_written) {
		rc = -EAGAIN;
		while (rc == -EAGAIN) {
1786 1787 1788
			struct kvec iov[2];
			unsigned int len;

L
Linus Torvalds 已提交
1789 1790 1791
			if (open_file->invalidHandle) {
				/* we could deadlock if we called
				   filemap_fdatawait from here so tell
S
Steve French 已提交
1792
				   reopen_file not to flush data to
L
Linus Torvalds 已提交
1793
				   server now */
J
Jeff Layton 已提交
1794
				rc = cifs_reopen_file(open_file, false);
L
Linus Torvalds 已提交
1795 1796 1797
				if (rc != 0)
					break;
			}
1798

1799
			len = min(server->ops->wp_retry_size(d_inode(dentry)),
1800
				  (unsigned int)write_size - total_written);
1801 1802 1803
			/* iov[0] is reserved for smb header */
			iov[1].iov_base = (char *)write_data + total_written;
			iov[1].iov_len = len;
1804
			io_parms.pid = pid;
1805 1806
			io_parms.tcon = tcon;
			io_parms.offset = *offset;
1807
			io_parms.length = len;
1808 1809
			rc = server->ops->sync_write(xid, &open_file->fid,
					&io_parms, &bytes_written, iov, 1);
L
Linus Torvalds 已提交
1810 1811 1812 1813 1814
		}
		if (rc || (bytes_written == 0)) {
			if (total_written)
				break;
			else {
1815
				free_xid(xid);
L
Linus Torvalds 已提交
1816 1817
				return rc;
			}
1818
		} else {
1819
			spin_lock(&d_inode(dentry)->i_lock);
1820
			cifs_update_eof(cifsi, *offset, bytes_written);
1821
			spin_unlock(&d_inode(dentry)->i_lock);
1822
			*offset += bytes_written;
1823
		}
L
Linus Torvalds 已提交
1824 1825
	}

1826
	cifs_stats_bytes_written(tcon, total_written);
L
Linus Torvalds 已提交
1827

1828
	if (total_written > 0) {
1829 1830 1831 1832
		spin_lock(&d_inode(dentry)->i_lock);
		if (*offset > d_inode(dentry)->i_size)
			i_size_write(d_inode(dentry), *offset);
		spin_unlock(&d_inode(dentry)->i_lock);
L
Linus Torvalds 已提交
1833
	}
1834
	mark_inode_dirty_sync(d_inode(dentry));
1835
	free_xid(xid);
L
Linus Torvalds 已提交
1836 1837 1838
	return total_written;
}

1839 1840
struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
					bool fsuid_only)
S
Steve French 已提交
1841 1842
{
	struct cifsFileInfo *open_file = NULL;
1843
	struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1844
	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1845 1846 1847 1848

	/* only filter by fsuid on multiuser mounts */
	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
		fsuid_only = false;
S
Steve French 已提交
1849

1850
	spin_lock(&tcon->open_file_lock);
S
Steve French 已提交
1851 1852 1853 1854
	/* we could simply get the first_list_entry since write-only entries
	   are always at the end of the list but since the first entry might
	   have a close pending, we go through the whole list */
	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1855
		if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1856
			continue;
1857
		if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
S
Steve French 已提交
1858 1859 1860
			if (!open_file->invalidHandle) {
				/* found a good file */
				/* lock it so it will not be closed on us */
1861 1862
				cifsFileInfo_get(open_file);
				spin_unlock(&tcon->open_file_lock);
S
Steve French 已提交
1863 1864 1865 1866 1867 1868 1869
				return open_file;
			} /* else might as well continue, and look for
			     another, or simply have the caller reopen it
			     again rather than trying to fix this handle */
		} else /* write only file */
			break; /* write only files are last so must be done */
	}
1870
	spin_unlock(&tcon->open_file_lock);
S
Steve French 已提交
1871 1872 1873
	return NULL;
}

1874 1875
struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
					bool fsuid_only)
1876
{
1877
	struct cifsFileInfo *open_file, *inv_file = NULL;
1878
	struct cifs_sb_info *cifs_sb;
1879
	struct cifs_tcon *tcon;
1880
	bool any_available = false;
1881
	int rc;
1882
	unsigned int refind = 0;
1883

1884 1885 1886 1887
	/* Having a null inode here (because mapping->host was set to zero by
	the VFS or MM) should not happen but we had reports of on oops (due to
	it being zero) during stress testcases so we need to check for it */

S
Steve French 已提交
1888
	if (cifs_inode == NULL) {
1889
		cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1890 1891 1892 1893
		dump_stack();
		return NULL;
	}

1894
	cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1895
	tcon = cifs_sb_master_tcon(cifs_sb);
1896

1897 1898 1899 1900
	/* only filter by fsuid on multiuser mounts */
	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
		fsuid_only = false;

1901
	spin_lock(&tcon->open_file_lock);
1902
refind_writable:
1903
	if (refind > MAX_REOPEN_ATT) {
1904
		spin_unlock(&tcon->open_file_lock);
1905 1906
		return NULL;
	}
1907
	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1908 1909
		if (!any_available && open_file->pid != current->tgid)
			continue;
1910
		if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1911
			continue;
1912
		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1913 1914
			if (!open_file->invalidHandle) {
				/* found a good writable file */
1915 1916
				cifsFileInfo_get(open_file);
				spin_unlock(&tcon->open_file_lock);
1917
				return open_file;
1918 1919 1920
			} else {
				if (!inv_file)
					inv_file = open_file;
1921
			}
1922 1923
		}
	}
1924 1925 1926 1927 1928
	/* couldn't find useable FH with same pid, try any available */
	if (!any_available) {
		any_available = true;
		goto refind_writable;
	}
1929 1930 1931

	if (inv_file) {
		any_available = false;
1932
		cifsFileInfo_get(inv_file);
1933 1934
	}

1935
	spin_unlock(&tcon->open_file_lock);
1936 1937 1938 1939 1940 1941

	if (inv_file) {
		rc = cifs_reopen_file(inv_file, false);
		if (!rc)
			return inv_file;
		else {
1942
			spin_lock(&cifs_inode->open_file_lock);
1943 1944
			list_move_tail(&inv_file->flist,
					&cifs_inode->openFileList);
1945
			spin_unlock(&cifs_inode->open_file_lock);
1946 1947
			cifsFileInfo_put(inv_file);
			++refind;
1948
			inv_file = NULL;
1949
			spin_lock(&tcon->open_file_lock);
1950 1951 1952 1953
			goto refind_writable;
		}
	}

1954 1955 1956
	return NULL;
}

L
Linus Torvalds 已提交
1957 1958 1959
static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
{
	struct address_space *mapping = page->mapping;
1960
	loff_t offset = (loff_t)page->index << PAGE_SHIFT;
L
Linus Torvalds 已提交
1961 1962 1963 1964
	char *write_data;
	int rc = -EFAULT;
	int bytes_written = 0;
	struct inode *inode;
1965
	struct cifsFileInfo *open_file;
L
Linus Torvalds 已提交
1966 1967 1968 1969 1970 1971 1972 1973 1974 1975

	if (!mapping || !mapping->host)
		return -EFAULT;

	inode = page->mapping->host;

	offset += (loff_t)from;
	write_data = kmap(page);
	write_data += from;

1976
	if ((to > PAGE_SIZE) || (from > to)) {
L
Linus Torvalds 已提交
1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988
		kunmap(page);
		return -EIO;
	}

	/* racing with truncate? */
	if (offset > mapping->host->i_size) {
		kunmap(page);
		return 0; /* don't care */
	}

	/* check to make sure that we are not extending the file */
	if (mapping->host->i_size - offset < (loff_t)to)
S
Steve French 已提交
1989
		to = (unsigned)(mapping->host->i_size - offset);
L
Linus Torvalds 已提交
1990

1991
	open_file = find_writable_file(CIFS_I(mapping->host), false);
1992
	if (open_file) {
1993 1994
		bytes_written = cifs_write(open_file, open_file->pid,
					   write_data, to - from, &offset);
1995
		cifsFileInfo_put(open_file);
L
Linus Torvalds 已提交
1996
		/* Does mm or vfs already set times? */
1997
		inode->i_atime = inode->i_mtime = current_time(inode);
1998
		if ((bytes_written > 0) && (offset))
1999
			rc = 0;
2000 2001
		else if (bytes_written < 0)
			rc = bytes_written;
2002
	} else {
2003
		cifs_dbg(FYI, "No writeable filehandles for inode\n");
L
Linus Torvalds 已提交
2004 2005 2006 2007 2008 2009 2010
		rc = -EIO;
	}

	kunmap(page);
	return rc;
}

2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022
static struct cifs_writedata *
wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
			  pgoff_t end, pgoff_t *index,
			  unsigned int *found_pages)
{
	struct cifs_writedata *wdata;

	wdata = cifs_writedata_alloc((unsigned int)tofind,
				     cifs_writev_complete);
	if (!wdata)
		return NULL;

J
Jan Kara 已提交
2023 2024
	*found_pages = find_get_pages_range_tag(mapping, index, end,
				PAGECACHE_TAG_DIRTY, tofind, wdata->pages);
2025 2026 2027
	return wdata;
}

2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039
static unsigned int
wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
		    struct address_space *mapping,
		    struct writeback_control *wbc,
		    pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
{
	unsigned int nr_pages = 0, i;
	struct page *page;

	for (i = 0; i < found_pages; i++) {
		page = wdata->pages[i];
		/*
M
Matthew Wilcox 已提交
2040 2041 2042 2043
		 * At this point we hold neither the i_pages lock nor the
		 * page lock: the page may be truncated or invalidated
		 * (changing page->mapping to NULL), or even swizzled
		 * back from swapper_space to tmpfs file mapping
2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099
		 */

		if (nr_pages == 0)
			lock_page(page);
		else if (!trylock_page(page))
			break;

		if (unlikely(page->mapping != mapping)) {
			unlock_page(page);
			break;
		}

		if (!wbc->range_cyclic && page->index > end) {
			*done = true;
			unlock_page(page);
			break;
		}

		if (*next && (page->index != *next)) {
			/* Not next consecutive page */
			unlock_page(page);
			break;
		}

		if (wbc->sync_mode != WB_SYNC_NONE)
			wait_on_page_writeback(page);

		if (PageWriteback(page) ||
				!clear_page_dirty_for_io(page)) {
			unlock_page(page);
			break;
		}

		/*
		 * This actually clears the dirty bit in the radix tree.
		 * See cifs_writepage() for more commentary.
		 */
		set_page_writeback(page);
		if (page_offset(page) >= i_size_read(mapping->host)) {
			*done = true;
			unlock_page(page);
			end_page_writeback(page);
			break;
		}

		wdata->pages[i] = page;
		*next = page->index + 1;
		++nr_pages;
	}

	/* reset index to refind any pages skipped */
	if (nr_pages == 0)
		*index = wdata->pages[0]->index + 1;

	/* put any pages we aren't going to use */
	for (i = nr_pages; i < found_pages; i++) {
2100
		put_page(wdata->pages[i]);
2101 2102 2103 2104 2105 2106
		wdata->pages[i] = NULL;
	}

	return nr_pages;
}

2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117
static int
wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
		 struct address_space *mapping, struct writeback_control *wbc)
{
	int rc = 0;
	struct TCP_Server_Info *server;
	unsigned int i;

	wdata->sync_mode = wbc->sync_mode;
	wdata->nr_pages = nr_pages;
	wdata->offset = page_offset(wdata->pages[0]);
2118
	wdata->pagesz = PAGE_SIZE;
2119 2120
	wdata->tailsz = min(i_size_read(mapping->host) -
			page_offset(wdata->pages[nr_pages - 1]),
2121 2122
			(loff_t)PAGE_SIZE);
	wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2123

2124 2125 2126 2127 2128 2129 2130
	if (wdata->cfile != NULL)
		cifsFileInfo_put(wdata->cfile);
	wdata->cfile = find_writable_file(CIFS_I(mapping->host), false);
	if (!wdata->cfile) {
		cifs_dbg(VFS, "No writable handles for inode\n");
		rc = -EBADF;
	} else {
2131 2132 2133
		wdata->pid = wdata->cfile->pid;
		server = tlink_tcon(wdata->cfile->tlink)->ses->server;
		rc = server->ops->async_writev(wdata, cifs_writedata_release);
2134
	}
2135 2136 2137 2138 2139 2140 2141

	for (i = 0; i < nr_pages; ++i)
		unlock_page(wdata->pages[i]);

	return rc;
}

L
Linus Torvalds 已提交
2142
static int cifs_writepages(struct address_space *mapping,
2143
			   struct writeback_control *wbc)
L
Linus Torvalds 已提交
2144
{
2145
	struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
2146
	struct TCP_Server_Info *server;
2147 2148 2149
	bool done = false, scanned = false, range_whole = false;
	pgoff_t end, index;
	struct cifs_writedata *wdata;
2150
	int rc = 0;
2151
	int saved_rc = 0;
2152

2153
	/*
2154
	 * If wsize is smaller than the page cache size, default to writing
2155 2156
	 * one page at a time via cifs_writepage
	 */
2157
	if (cifs_sb->wsize < PAGE_SIZE)
2158 2159
		return generic_writepages(mapping, wbc);

2160
	if (wbc->range_cyclic) {
2161
		index = mapping->writeback_index; /* Start from prev offset */
2162 2163
		end = -1;
	} else {
2164 2165
		index = wbc->range_start >> PAGE_SHIFT;
		end = wbc->range_end >> PAGE_SHIFT;
2166
		if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2167 2168
			range_whole = true;
		scanned = true;
2169
	}
2170
	server = cifs_sb_master_tcon(cifs_sb)->ses->server;
2171
retry:
2172
	while (!done && index <= end) {
2173
		unsigned int i, nr_pages, found_pages, wsize, credits;
2174
		pgoff_t next = 0, tofind, saved_index = index;
2175

2176 2177
		rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
						   &wsize, &credits);
2178 2179
		if (rc != 0) {
			done = true;
2180
			break;
2181
		}
2182

2183
		tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2184

2185 2186
		wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
						  &found_pages);
2187 2188
		if (!wdata) {
			rc = -ENOMEM;
2189
			done = true;
2190
			add_credits_and_wake_if(server, credits, 0);
2191 2192 2193 2194 2195
			break;
		}

		if (found_pages == 0) {
			kref_put(&wdata->refcount, cifs_writedata_release);
2196
			add_credits_and_wake_if(server, credits, 0);
2197 2198 2199
			break;
		}

2200 2201
		nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
					       end, &index, &next, &done);
2202

2203 2204 2205
		/* nothing to write? */
		if (nr_pages == 0) {
			kref_put(&wdata->refcount, cifs_writedata_release);
2206
			add_credits_and_wake_if(server, credits, 0);
2207
			continue;
2208
		}
2209

2210
		wdata->credits = credits;
2211

2212
		rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2213

2214 2215
		/* send failure -- clean up the mess */
		if (rc != 0) {
2216
			add_credits_and_wake_if(server, wdata->credits, 0);
2217
			for (i = 0; i < nr_pages; ++i) {
2218
				if (is_retryable_error(rc))
2219 2220 2221 2222 2223
					redirty_page_for_writepage(wbc,
							   wdata->pages[i]);
				else
					SetPageError(wdata->pages[i]);
				end_page_writeback(wdata->pages[i]);
2224
				put_page(wdata->pages[i]);
2225
			}
2226
			if (!is_retryable_error(rc))
2227
				mapping_set_error(mapping, rc);
2228 2229
		}
		kref_put(&wdata->refcount, cifs_writedata_release);
2230

2231 2232 2233 2234 2235
		if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
			index = saved_index;
			continue;
		}

2236 2237 2238 2239 2240 2241 2242 2243 2244
		/* Return immediately if we received a signal during writing */
		if (is_interrupt_error(rc)) {
			done = true;
			break;
		}

		if (rc != 0 && saved_rc == 0)
			saved_rc = rc;

2245 2246 2247
		wbc->nr_to_write -= nr_pages;
		if (wbc->nr_to_write <= 0)
			done = true;
2248

2249
		index = next;
2250
	}
2251

2252 2253 2254 2255 2256
	if (!scanned && !done) {
		/*
		 * We hit the last page and there is more work to be done: wrap
		 * back to the start of the file
		 */
2257
		scanned = true;
2258 2259 2260
		index = 0;
		goto retry;
	}
2261

2262 2263 2264
	if (saved_rc != 0)
		rc = saved_rc;

2265
	if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2266 2267
		mapping->writeback_index = index;

L
Linus Torvalds 已提交
2268 2269 2270
	return rc;
}

2271 2272
static int
cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
L
Linus Torvalds 已提交
2273
{
2274
	int rc;
2275
	unsigned int xid;
L
Linus Torvalds 已提交
2276

2277
	xid = get_xid();
L
Linus Torvalds 已提交
2278
/* BB add check for wbc flags */
2279
	get_page(page);
S
Steve French 已提交
2280
	if (!PageUptodate(page))
2281
		cifs_dbg(FYI, "ppw - page not up to date\n");
2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292

	/*
	 * Set the "writeback" flag, and clear "dirty" in the radix tree.
	 *
	 * A writepage() implementation always needs to do either this,
	 * or re-dirty the page with "redirty_page_for_writepage()" in
	 * the case of a failure.
	 *
	 * Just unlocking the page will cause the radix tree tag-bits
	 * to fail to update with the state of the page correctly.
	 */
S
Steve French 已提交
2293
	set_page_writeback(page);
2294
retry_write:
2295
	rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2296 2297
	if (is_retryable_error(rc)) {
		if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN)
2298
			goto retry_write;
2299
		redirty_page_for_writepage(wbc, page);
2300
	} else if (rc != 0) {
2301
		SetPageError(page);
2302 2303
		mapping_set_error(page->mapping, rc);
	} else {
2304
		SetPageUptodate(page);
2305
	}
2306
	end_page_writeback(page);
2307
	put_page(page);
2308
	free_xid(xid);
L
Linus Torvalds 已提交
2309 2310 2311
	return rc;
}

2312 2313 2314 2315 2316 2317 2318
static int cifs_writepage(struct page *page, struct writeback_control *wbc)
{
	int rc = cifs_writepage_locked(page, wbc);
	unlock_page(page);
	return rc;
}

N
Nick Piggin 已提交
2319 2320 2321
static int cifs_write_end(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned copied,
			struct page *page, void *fsdata)
L
Linus Torvalds 已提交
2322
{
N
Nick Piggin 已提交
2323 2324
	int rc;
	struct inode *inode = mapping->host;
2325 2326 2327 2328 2329 2330 2331 2332
	struct cifsFileInfo *cfile = file->private_data;
	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
	__u32 pid;

	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = cfile->pid;
	else
		pid = current->tgid;
L
Linus Torvalds 已提交
2333

2334
	cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2335
		 page, pos, copied);
N
Nick Piggin 已提交
2336

2337 2338 2339 2340
	if (PageChecked(page)) {
		if (copied == len)
			SetPageUptodate(page);
		ClearPageChecked(page);
2341
	} else if (!PageUptodate(page) && copied == PAGE_SIZE)
N
Nick Piggin 已提交
2342
		SetPageUptodate(page);
S
Steve French 已提交
2343

L
Linus Torvalds 已提交
2344
	if (!PageUptodate(page)) {
N
Nick Piggin 已提交
2345
		char *page_data;
2346
		unsigned offset = pos & (PAGE_SIZE - 1);
2347
		unsigned int xid;
N
Nick Piggin 已提交
2348

2349
		xid = get_xid();
L
Linus Torvalds 已提交
2350 2351 2352 2353 2354 2355
		/* this is probably better than directly calling
		   partialpage_write since in this function the file handle is
		   known which we might as well	leverage */
		/* BB check if anything else missing out of ppw
		   such as updating last write time */
		page_data = kmap(page);
2356
		rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
N
Nick Piggin 已提交
2357
		/* if (rc < 0) should we set writebehind rc? */
L
Linus Torvalds 已提交
2358
		kunmap(page);
N
Nick Piggin 已提交
2359

2360
		free_xid(xid);
S
Steve French 已提交
2361
	} else {
N
Nick Piggin 已提交
2362 2363
		rc = copied;
		pos += copied;
2364
		set_page_dirty(page);
L
Linus Torvalds 已提交
2365 2366
	}

N
Nick Piggin 已提交
2367 2368 2369 2370 2371 2372 2373 2374
	if (rc > 0) {
		spin_lock(&inode->i_lock);
		if (pos > inode->i_size)
			i_size_write(inode, pos);
		spin_unlock(&inode->i_lock);
	}

	unlock_page(page);
2375
	put_page(page);
N
Nick Piggin 已提交
2376

L
Linus Torvalds 已提交
2377 2378 2379
	return rc;
}

2380 2381
int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
		      int datasync)
L
Linus Torvalds 已提交
2382
{
2383
	unsigned int xid;
L
Linus Torvalds 已提交
2384
	int rc = 0;
2385
	struct cifs_tcon *tcon;
2386
	struct TCP_Server_Info *server;
2387
	struct cifsFileInfo *smbfile = file->private_data;
A
Al Viro 已提交
2388
	struct inode *inode = file_inode(file);
2389
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
L
Linus Torvalds 已提交
2390

2391
	rc = file_write_and_wait_range(file, start, end);
2392 2393
	if (rc)
		return rc;
A
Al Viro 已提交
2394
	inode_lock(inode);
2395

2396
	xid = get_xid();
L
Linus Torvalds 已提交
2397

A
Al Viro 已提交
2398 2399
	cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
		 file, datasync);
2400

2401
	if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2402
		rc = cifs_zap_mapping(inode);
2403
		if (rc) {
2404
			cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2405 2406 2407
			rc = 0; /* don't care about it in fsync */
		}
	}
2408

2409
	tcon = tlink_tcon(smbfile->tlink);
2410 2411 2412 2413 2414 2415 2416
	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
		server = tcon->ses->server;
		if (server->ops->flush)
			rc = server->ops->flush(xid, tcon, &smbfile->fid);
		else
			rc = -ENOSYS;
	}
2417

2418
	free_xid(xid);
A
Al Viro 已提交
2419
	inode_unlock(inode);
2420 2421 2422
	return rc;
}

2423
int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2424
{
2425
	unsigned int xid;
2426
	int rc = 0;
2427
	struct cifs_tcon *tcon;
2428
	struct TCP_Server_Info *server;
2429
	struct cifsFileInfo *smbfile = file->private_data;
2430
	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2431 2432
	struct inode *inode = file->f_mapping->host;

2433
	rc = file_write_and_wait_range(file, start, end);
2434 2435
	if (rc)
		return rc;
A
Al Viro 已提交
2436
	inode_lock(inode);
2437

2438
	xid = get_xid();
2439

A
Al Viro 已提交
2440 2441
	cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
		 file, datasync);
2442 2443

	tcon = tlink_tcon(smbfile->tlink);
2444 2445 2446 2447 2448 2449 2450
	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
		server = tcon->ses->server;
		if (server->ops->flush)
			rc = server->ops->flush(xid, tcon, &smbfile->fid);
		else
			rc = -ENOSYS;
	}
2451

2452
	free_xid(xid);
A
Al Viro 已提交
2453
	inode_unlock(inode);
L
Linus Torvalds 已提交
2454 2455 2456 2457 2458 2459 2460
	return rc;
}

/*
 * As file closes, flush all cached write data for this inode checking
 * for write behind errors.
 */
2461
int cifs_flush(struct file *file, fl_owner_t id)
L
Linus Torvalds 已提交
2462
{
A
Al Viro 已提交
2463
	struct inode *inode = file_inode(file);
L
Linus Torvalds 已提交
2464 2465
	int rc = 0;

2466
	if (file->f_mode & FMODE_WRITE)
2467
		rc = filemap_write_and_wait(inode->i_mapping);
2468

2469
	cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
L
Linus Torvalds 已提交
2470 2471 2472 2473

	return rc;
}

2474 2475 2476 2477 2478 2479 2480
static int
cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
{
	int rc = 0;
	unsigned long i;

	for (i = 0; i < num_pages; i++) {
2481
		pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2482 2483 2484 2485 2486 2487 2488
		if (!pages[i]) {
			/*
			 * save number of pages we have already allocated and
			 * return with ENOMEM error
			 */
			num_pages = i;
			rc = -ENOMEM;
2489
			break;
2490 2491 2492
		}
	}

2493 2494 2495 2496
	if (rc) {
		for (i = 0; i < num_pages; i++)
			put_page(pages[i]);
	}
2497 2498 2499 2500 2501 2502 2503 2504 2505 2506
	return rc;
}

static inline
size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
{
	size_t num_pages;
	size_t clen;

	clen = min_t(const size_t, len, wsize);
J
Jeff Layton 已提交
2507
	num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2508 2509 2510 2511 2512 2513 2514

	if (cur_len)
		*cur_len = clen;

	return num_pages;
}

2515
static void
2516
cifs_uncached_writedata_release(struct kref *refcount)
2517 2518
{
	int i;
2519 2520 2521
	struct cifs_writedata *wdata = container_of(refcount,
					struct cifs_writedata, refcount);

2522
	kref_put(&wdata->ctx->refcount, cifs_aio_ctx_release);
2523 2524 2525 2526 2527
	for (i = 0; i < wdata->nr_pages; i++)
		put_page(wdata->pages[i]);
	cifs_writedata_release(refcount);
}

2528 2529
static void collect_uncached_write_data(struct cifs_aio_ctx *ctx);

2530 2531 2532
static void
cifs_uncached_writev_complete(struct work_struct *work)
{
2533 2534
	struct cifs_writedata *wdata = container_of(work,
					struct cifs_writedata, work);
2535
	struct inode *inode = d_inode(wdata->cfile->dentry);
2536 2537 2538 2539 2540 2541 2542 2543 2544
	struct cifsInodeInfo *cifsi = CIFS_I(inode);

	spin_lock(&inode->i_lock);
	cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
	if (cifsi->server_eof > inode->i_size)
		i_size_write(inode, cifsi->server_eof);
	spin_unlock(&inode->i_lock);

	complete(&wdata->done);
2545 2546
	collect_uncached_write_data(wdata->ctx);
	/* the below call can possibly free the last ref to aio ctx */
2547
	kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2548 2549 2550
}

static int
2551 2552
wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
		      size_t *len, unsigned long *num_pages)
2553
{
2554 2555
	size_t save_len, copied, bytes, cur_len = *len;
	unsigned long i, nr_pages = *num_pages;
2556

2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573
	save_len = cur_len;
	for (i = 0; i < nr_pages; i++) {
		bytes = min_t(const size_t, cur_len, PAGE_SIZE);
		copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
		cur_len -= copied;
		/*
		 * If we didn't copy as much as we expected, then that
		 * may mean we trod into an unmapped area. Stop copying
		 * at that point. On the next pass through the big
		 * loop, we'll likely end up getting a zero-length
		 * write and bailing out of it.
		 */
		if (copied < bytes)
			break;
	}
	cur_len = save_len - cur_len;
	*len = cur_len;
2574

2575 2576 2577 2578 2579 2580 2581 2582
	/*
	 * If we have no data to send, then that probably means that
	 * the copy above failed altogether. That's most likely because
	 * the address in the iovec was bogus. Return -EFAULT and let
	 * the caller free anything we allocated and bail out.
	 */
	if (!cur_len)
		return -EFAULT;
2583

2584 2585 2586 2587 2588 2589
	/*
	 * i + 1 now represents the number of pages we actually used in
	 * the copy phase above.
	 */
	*num_pages = i + 1;
	return 0;
2590 2591
}

2592 2593 2594
static int
cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
		     struct cifsFileInfo *open_file,
2595 2596
		     struct cifs_sb_info *cifs_sb, struct list_head *wdata_list,
		     struct cifs_aio_ctx *ctx)
2597
{
2598 2599
	int rc = 0;
	size_t cur_len;
2600
	unsigned long nr_pages, num_pages, i;
2601
	struct cifs_writedata *wdata;
2602
	struct iov_iter saved_from = *from;
2603
	loff_t saved_offset = offset;
2604
	pid_t pid;
2605
	struct TCP_Server_Info *server;
2606 2607 2608 2609 2610 2611

	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

2612 2613
	server = tlink_tcon(open_file->tlink)->ses->server;

2614
	do {
2615 2616 2617 2618 2619 2620
		unsigned int wsize, credits;

		rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
						   &wsize, &credits);
		if (rc)
			break;
2621

2622
		nr_pages = get_numpages(wsize, len, &cur_len);
2623 2624 2625 2626
		wdata = cifs_writedata_alloc(nr_pages,
					     cifs_uncached_writev_complete);
		if (!wdata) {
			rc = -ENOMEM;
2627
			add_credits_and_wake_if(server, credits, 0);
2628 2629 2630 2631 2632 2633
			break;
		}

		rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
		if (rc) {
			kfree(wdata);
2634
			add_credits_and_wake_if(server, credits, 0);
2635 2636 2637
			break;
		}

2638 2639 2640
		num_pages = nr_pages;
		rc = wdata_fill_from_iovec(wdata, from, &cur_len, &num_pages);
		if (rc) {
2641 2642 2643
			for (i = 0; i < nr_pages; i++)
				put_page(wdata->pages[i]);
			kfree(wdata);
2644
			add_credits_and_wake_if(server, credits, 0);
2645 2646 2647 2648
			break;
		}

		/*
2649 2650
		 * Bring nr_pages down to the number of pages we actually used,
		 * and free any pages that we didn't use.
2651
		 */
2652
		for ( ; nr_pages > num_pages; nr_pages--)
2653 2654
			put_page(wdata->pages[nr_pages - 1]);

2655 2656 2657 2658 2659 2660
		wdata->sync_mode = WB_SYNC_ALL;
		wdata->nr_pages = nr_pages;
		wdata->offset = (__u64)offset;
		wdata->cfile = cifsFileInfo_get(open_file);
		wdata->pid = pid;
		wdata->bytes = cur_len;
2661 2662
		wdata->pagesz = PAGE_SIZE;
		wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2663
		wdata->credits = credits;
2664 2665
		wdata->ctx = ctx;
		kref_get(&ctx->refcount);
2666 2667

		if (!wdata->cfile->invalidHandle ||
2668
		    !(rc = cifs_reopen_file(wdata->cfile, false)))
2669 2670
			rc = server->ops->async_writev(wdata,
					cifs_uncached_writedata_release);
2671
		if (rc) {
2672
			add_credits_and_wake_if(server, wdata->credits, 0);
2673 2674
			kref_put(&wdata->refcount,
				 cifs_uncached_writedata_release);
2675
			if (rc == -EAGAIN) {
2676
				*from = saved_from;
2677 2678 2679
				iov_iter_advance(from, offset - saved_offset);
				continue;
			}
2680 2681 2682
			break;
		}

2683
		list_add_tail(&wdata->list, wdata_list);
2684 2685
		offset += cur_len;
		len -= cur_len;
2686 2687
	} while (len > 0);

2688 2689 2690
	return rc;
}

2691
static void collect_uncached_write_data(struct cifs_aio_ctx *ctx)
2692
{
2693
	struct cifs_writedata *wdata, *tmp;
2694 2695
	struct cifs_tcon *tcon;
	struct cifs_sb_info *cifs_sb;
2696 2697
	struct dentry *dentry = ctx->cfile->dentry;
	unsigned int i;
2698 2699
	int rc;

2700 2701
	tcon = tlink_tcon(ctx->cfile->tlink);
	cifs_sb = CIFS_SB(dentry->d_sb);
2702

2703
	mutex_lock(&ctx->aio_mutex);
2704

2705 2706 2707 2708
	if (list_empty(&ctx->list)) {
		mutex_unlock(&ctx->aio_mutex);
		return;
	}
2709

2710
	rc = ctx->rc;
2711 2712
	/*
	 * Wait for and collect replies for any successful sends in order of
2713 2714
	 * increasing offset. Once an error is hit, then return without waiting
	 * for any more replies.
2715 2716
	 */
restart_loop:
2717
	list_for_each_entry_safe(wdata, tmp, &ctx->list, list) {
2718
		if (!rc) {
2719 2720 2721 2722 2723 2724
			if (!try_wait_for_completion(&wdata->done)) {
				mutex_unlock(&ctx->aio_mutex);
				return;
			}

			if (wdata->result)
2725 2726
				rc = wdata->result;
			else
2727
				ctx->total_len += wdata->bytes;
2728 2729 2730

			/* resend call if it's a retryable error */
			if (rc == -EAGAIN) {
2731
				struct list_head tmp_list;
2732
				struct iov_iter tmp_from = ctx->iter;
2733 2734 2735 2736 2737

				INIT_LIST_HEAD(&tmp_list);
				list_del_init(&wdata->list);

				iov_iter_advance(&tmp_from,
2738
						 wdata->offset - ctx->pos);
2739 2740 2741

				rc = cifs_write_from_iter(wdata->offset,
						wdata->bytes, &tmp_from,
2742 2743
						ctx->cfile, cifs_sb, &tmp_list,
						ctx);
2744

2745
				list_splice(&tmp_list, &ctx->list);
2746 2747 2748

				kref_put(&wdata->refcount,
					 cifs_uncached_writedata_release);
2749 2750 2751 2752
				goto restart_loop;
			}
		}
		list_del_init(&wdata->list);
2753
		kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2754 2755
	}

2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856
	for (i = 0; i < ctx->npages; i++)
		put_page(ctx->bv[i].bv_page);

	cifs_stats_bytes_written(tcon, ctx->total_len);
	set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(dentry->d_inode)->flags);

	ctx->rc = (rc == 0) ? ctx->total_len : rc;

	mutex_unlock(&ctx->aio_mutex);

	if (ctx->iocb && ctx->iocb->ki_complete)
		ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
	else
		complete(&ctx->done);
}

ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
{
	struct file *file = iocb->ki_filp;
	ssize_t total_written = 0;
	struct cifsFileInfo *cfile;
	struct cifs_tcon *tcon;
	struct cifs_sb_info *cifs_sb;
	struct cifs_aio_ctx *ctx;
	struct iov_iter saved_from = *from;
	int rc;

	/*
	 * BB - optimize the way when signing is disabled. We can drop this
	 * extra memory-to-memory copying and use iovec buffers for constructing
	 * write request.
	 */

	rc = generic_write_checks(iocb, from);
	if (rc <= 0)
		return rc;

	cifs_sb = CIFS_FILE_SB(file);
	cfile = file->private_data;
	tcon = tlink_tcon(cfile->tlink);

	if (!tcon->ses->server->ops->async_writev)
		return -ENOSYS;

	ctx = cifs_aio_ctx_alloc();
	if (!ctx)
		return -ENOMEM;

	ctx->cfile = cifsFileInfo_get(cfile);

	if (!is_sync_kiocb(iocb))
		ctx->iocb = iocb;

	ctx->pos = iocb->ki_pos;

	rc = setup_aio_ctx_iter(ctx, from, WRITE);
	if (rc) {
		kref_put(&ctx->refcount, cifs_aio_ctx_release);
		return rc;
	}

	/* grab a lock here due to read response handlers can access ctx */
	mutex_lock(&ctx->aio_mutex);

	rc = cifs_write_from_iter(iocb->ki_pos, ctx->len, &saved_from,
				  cfile, cifs_sb, &ctx->list, ctx);

	/*
	 * If at least one write was successfully sent, then discard any rc
	 * value from the later writes. If the other write succeeds, then
	 * we'll end up returning whatever was written. If it fails, then
	 * we'll get a new rc value from that.
	 */
	if (!list_empty(&ctx->list))
		rc = 0;

	mutex_unlock(&ctx->aio_mutex);

	if (rc) {
		kref_put(&ctx->refcount, cifs_aio_ctx_release);
		return rc;
	}

	if (!is_sync_kiocb(iocb)) {
		kref_put(&ctx->refcount, cifs_aio_ctx_release);
		return -EIOCBQUEUED;
	}

	rc = wait_for_completion_killable(&ctx->done);
	if (rc) {
		mutex_lock(&ctx->aio_mutex);
		ctx->rc = rc = -EINTR;
		total_written = ctx->total_len;
		mutex_unlock(&ctx->aio_mutex);
	} else {
		rc = ctx->rc;
		total_written = ctx->total_len;
	}

	kref_put(&ctx->refcount, cifs_aio_ctx_release);

2857 2858
	if (unlikely(!total_written))
		return rc;
2859

2860 2861
	iocb->ki_pos += total_written;
	return total_written;
2862 2863
}

2864
static ssize_t
A
Al Viro 已提交
2865
cifs_writev(struct kiocb *iocb, struct iov_iter *from)
2866
{
2867 2868 2869 2870 2871
	struct file *file = iocb->ki_filp;
	struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
	struct inode *inode = file->f_mapping->host;
	struct cifsInodeInfo *cinode = CIFS_I(inode);
	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2872
	ssize_t rc;
2873

2874
	inode_lock(inode);
2875 2876 2877 2878 2879
	/*
	 * We need to hold the sem to be sure nobody modifies lock list
	 * with a brlock that prevents writing.
	 */
	down_read(&cinode->lock_sem);
2880

2881 2882
	rc = generic_write_checks(iocb, from);
	if (rc <= 0)
2883 2884 2885
		goto out;

	if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
2886
				     server->vals->exclusive_lock_type, NULL,
2887
				     CIFS_WRITE_OP))
A
Al Viro 已提交
2888
		rc = __generic_file_write_iter(iocb, from);
2889 2890 2891
	else
		rc = -EACCES;
out:
2892
	up_read(&cinode->lock_sem);
A
Al Viro 已提交
2893
	inode_unlock(inode);
A
Al Viro 已提交
2894

2895 2896
	if (rc > 0)
		rc = generic_write_sync(iocb, rc);
2897 2898 2899 2900
	return rc;
}

ssize_t
A
Al Viro 已提交
2901
cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
2902
{
A
Al Viro 已提交
2903
	struct inode *inode = file_inode(iocb->ki_filp);
2904 2905 2906 2907 2908
	struct cifsInodeInfo *cinode = CIFS_I(inode);
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
	struct cifsFileInfo *cfile = (struct cifsFileInfo *)
						iocb->ki_filp->private_data;
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2909
	ssize_t written;
2910

2911 2912 2913 2914
	written = cifs_get_writer(cinode);
	if (written)
		return written;

2915
	if (CIFS_CACHE_WRITE(cinode)) {
2916 2917
		if (cap_unix(tcon->ses) &&
		(CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
2918
		  && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
A
Al Viro 已提交
2919
			written = generic_file_write_iter(iocb, from);
2920 2921
			goto out;
		}
A
Al Viro 已提交
2922
		written = cifs_writev(iocb, from);
2923
		goto out;
2924 2925
	}
	/*
2926 2927 2928 2929
	 * For non-oplocked files in strict cache mode we need to write the data
	 * to the server exactly from the pos to pos+len-1 rather than flush all
	 * affected pages because it may cause a error with mandatory locks on
	 * these pages but not on the region from pos to ppos+len-1.
2930
	 */
A
Al Viro 已提交
2931
	written = cifs_user_writev(iocb, from);
2932
	if (CIFS_CACHE_READ(cinode)) {
2933
		/*
2934 2935 2936 2937 2938
		 * We have read level caching and we have just sent a write
		 * request to the server thus making data in the cache stale.
		 * Zap the cache and set oplock/lease level to NONE to avoid
		 * reading stale data from the cache. All subsequent read
		 * operations will read new data from the server.
2939
		 */
2940
		cifs_zap_mapping(inode);
2941
		cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
2942
			 inode);
2943
		cinode->oplock = 0;
2944
	}
2945 2946
out:
	cifs_put_writer(cinode);
2947
	return written;
2948 2949
}

2950
static struct cifs_readdata *
2951
cifs_readdata_direct_alloc(struct page **pages, work_func_t complete)
2952 2953
{
	struct cifs_readdata *rdata;
2954

2955
	rdata = kzalloc(sizeof(*rdata), GFP_KERNEL);
2956
	if (rdata != NULL) {
2957
		rdata->pages = pages;
2958
		kref_init(&rdata->refcount);
2959 2960
		INIT_LIST_HEAD(&rdata->list);
		init_completion(&rdata->done);
2961 2962
		INIT_WORK(&rdata->work, complete);
	}
2963

2964 2965 2966
	return rdata;
}

2967 2968 2969 2970
static struct cifs_readdata *
cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
{
	struct page **pages =
K
Kees Cook 已提交
2971
		kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982
	struct cifs_readdata *ret = NULL;

	if (pages) {
		ret = cifs_readdata_direct_alloc(pages, complete);
		if (!ret)
			kfree(pages);
	}

	return ret;
}

2983 2984
void
cifs_readdata_release(struct kref *refcount)
2985
{
2986 2987
	struct cifs_readdata *rdata = container_of(refcount,
					struct cifs_readdata, refcount);
2988 2989 2990 2991 2992 2993
#ifdef CONFIG_CIFS_SMB_DIRECT
	if (rdata->mr) {
		smbd_deregister_mr(rdata->mr);
		rdata->mr = NULL;
	}
#endif
2994 2995 2996
	if (rdata->cfile)
		cifsFileInfo_put(rdata->cfile);

2997
	kvfree(rdata->pages);
2998 2999 3000
	kfree(rdata);
}

3001
static int
3002
cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
3003 3004
{
	int rc = 0;
3005
	struct page *page;
3006 3007
	unsigned int i;

3008
	for (i = 0; i < nr_pages; i++) {
3009 3010 3011 3012 3013
		page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
		if (!page) {
			rc = -ENOMEM;
			break;
		}
3014
		rdata->pages[i] = page;
3015 3016 3017
	}

	if (rc) {
3018 3019 3020
		unsigned int nr_page_failed = i;

		for (i = 0; i < nr_page_failed; i++) {
3021 3022
			put_page(rdata->pages[i]);
			rdata->pages[i] = NULL;
3023 3024 3025 3026 3027 3028 3029 3030 3031 3032
		}
	}
	return rc;
}

static void
cifs_uncached_readdata_release(struct kref *refcount)
{
	struct cifs_readdata *rdata = container_of(refcount,
					struct cifs_readdata, refcount);
3033
	unsigned int i;
3034

3035
	kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
3036 3037 3038
	for (i = 0; i < rdata->nr_pages; i++) {
		put_page(rdata->pages[i]);
		rdata->pages[i] = NULL;
3039 3040 3041 3042 3043 3044 3045
	}
	cifs_readdata_release(refcount);
}

/**
 * cifs_readdata_to_iov - copy data from pages in response to an iovec
 * @rdata:	the readdata response with list of pages holding data
3046
 * @iter:	destination for our data
3047 3048 3049 3050 3051
 *
 * This function copies data from a list of pages in a readdata response into
 * an array of iovecs. It will first calculate where the data should go
 * based on the info in the readdata and then copy the data into that spot.
 */
3052 3053
static int
cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
3054
{
3055
	size_t remaining = rdata->got_bytes;
3056
	unsigned int i;
3057

3058 3059
	for (i = 0; i < rdata->nr_pages; i++) {
		struct page *page = rdata->pages[i];
3060
		size_t copy = min_t(size_t, remaining, PAGE_SIZE);
3061 3062 3063 3064 3065 3066 3067 3068 3069
		size_t written;

		if (unlikely(iter->type & ITER_PIPE)) {
			void *addr = kmap_atomic(page);

			written = copy_to_iter(addr, copy, iter);
			kunmap_atomic(addr);
		} else
			written = copy_page_to_iter(page, 0, copy, iter);
3070 3071 3072
		remaining -= written;
		if (written < copy && iov_iter_count(iter) > 0)
			break;
3073
	}
3074
	return remaining ? -EFAULT : 0;
3075 3076
}

3077 3078
static void collect_uncached_read_data(struct cifs_aio_ctx *ctx);

3079 3080 3081 3082 3083 3084 3085
static void
cifs_uncached_readv_complete(struct work_struct *work)
{
	struct cifs_readdata *rdata = container_of(work,
						struct cifs_readdata, work);

	complete(&rdata->done);
3086 3087
	collect_uncached_read_data(rdata->ctx);
	/* the below call can possibly free the last ref to aio ctx */
3088 3089 3090 3091
	kref_put(&rdata->refcount, cifs_uncached_readdata_release);
}

static int
3092 3093 3094
uncached_fill_pages(struct TCP_Server_Info *server,
		    struct cifs_readdata *rdata, struct iov_iter *iter,
		    unsigned int len)
3095
{
3096
	int result = 0;
3097 3098
	unsigned int i;
	unsigned int nr_pages = rdata->nr_pages;
L
Long Li 已提交
3099
	unsigned int page_offset = rdata->page_offset;
3100

3101
	rdata->got_bytes = 0;
3102
	rdata->tailsz = PAGE_SIZE;
3103 3104
	for (i = 0; i < nr_pages; i++) {
		struct page *page = rdata->pages[i];
3105
		size_t n;
L
Long Li 已提交
3106 3107 3108 3109 3110 3111 3112
		unsigned int segment_size = rdata->pagesz;

		if (i == 0)
			segment_size -= page_offset;
		else
			page_offset = 0;

3113

3114
		if (len <= 0) {
3115
			/* no need to hold page hostage */
3116 3117
			rdata->pages[i] = NULL;
			rdata->nr_pages--;
3118
			put_page(page);
3119
			continue;
3120
		}
L
Long Li 已提交
3121

3122
		n = len;
L
Long Li 已提交
3123
		if (len >= segment_size)
3124
			/* enough data to fill the page */
L
Long Li 已提交
3125 3126
			n = segment_size;
		else
3127
			rdata->tailsz = len;
L
Long Li 已提交
3128 3129
		len -= n;

3130
		if (iter)
L
Long Li 已提交
3131 3132
			result = copy_page_from_iter(
					page, page_offset, n, iter);
3133 3134 3135 3136
#ifdef CONFIG_CIFS_SMB_DIRECT
		else if (rdata->mr)
			result = n;
#endif
3137
		else
L
Long Li 已提交
3138 3139
			result = cifs_read_page_from_socket(
					server, page, page_offset, n);
3140 3141 3142
		if (result < 0)
			break;

3143
		rdata->got_bytes += result;
3144 3145
	}

3146 3147
	return rdata->got_bytes > 0 && result != -ECONNABORTED ?
						rdata->got_bytes : result;
3148 3149
}

3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164
static int
cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
			      struct cifs_readdata *rdata, unsigned int len)
{
	return uncached_fill_pages(server, rdata, NULL, len);
}

static int
cifs_uncached_copy_into_pages(struct TCP_Server_Info *server,
			      struct cifs_readdata *rdata,
			      struct iov_iter *iter)
{
	return uncached_fill_pages(server, rdata, iter, iter->count);
}

3165 3166
static int
cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
3167 3168
		     struct cifs_sb_info *cifs_sb, struct list_head *rdata_list,
		     struct cifs_aio_ctx *ctx)
L
Linus Torvalds 已提交
3169
{
3170
	struct cifs_readdata *rdata;
3171
	unsigned int npages, rsize, credits;
3172 3173
	size_t cur_len;
	int rc;
3174
	pid_t pid;
3175
	struct TCP_Server_Info *server;
3176

3177
	server = tlink_tcon(open_file->tlink)->ses->server;
3178

3179 3180 3181 3182 3183
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

3184
	do {
3185 3186 3187 3188 3189 3190
		rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
						   &rsize, &credits);
		if (rc)
			break;

		cur_len = min_t(const size_t, len, rsize);
3191
		npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
3192

3193 3194 3195 3196
		/* allocate a readdata struct */
		rdata = cifs_readdata_alloc(npages,
					    cifs_uncached_readv_complete);
		if (!rdata) {
3197
			add_credits_and_wake_if(server, credits, 0);
3198
			rc = -ENOMEM;
3199
			break;
L
Linus Torvalds 已提交
3200
		}
3201

3202
		rc = cifs_read_allocate_pages(rdata, npages);
3203 3204 3205 3206
		if (rc)
			goto error;

		rdata->cfile = cifsFileInfo_get(open_file);
3207
		rdata->nr_pages = npages;
3208 3209 3210
		rdata->offset = offset;
		rdata->bytes = cur_len;
		rdata->pid = pid;
3211
		rdata->pagesz = PAGE_SIZE;
L
Long Li 已提交
3212
		rdata->tailsz = PAGE_SIZE;
3213
		rdata->read_into_pages = cifs_uncached_read_into_pages;
3214
		rdata->copy_into_pages = cifs_uncached_copy_into_pages;
3215
		rdata->credits = credits;
3216 3217
		rdata->ctx = ctx;
		kref_get(&ctx->refcount);
3218

3219
		if (!rdata->cfile->invalidHandle ||
3220
		    !(rc = cifs_reopen_file(rdata->cfile, true)))
3221
			rc = server->ops->async_readv(rdata);
3222 3223
error:
		if (rc) {
3224
			add_credits_and_wake_if(server, rdata->credits, 0);
3225 3226
			kref_put(&rdata->refcount,
				 cifs_uncached_readdata_release);
3227 3228
			if (rc == -EAGAIN)
				continue;
3229 3230 3231
			break;
		}

3232
		list_add_tail(&rdata->list, rdata_list);
3233 3234 3235 3236
		offset += cur_len;
		len -= cur_len;
	} while (len > 0);

3237 3238 3239
	return rc;
}

3240 3241
static void
collect_uncached_read_data(struct cifs_aio_ctx *ctx)
3242
{
3243 3244
	struct cifs_readdata *rdata, *tmp;
	struct iov_iter *to = &ctx->iter;
3245 3246
	struct cifs_sb_info *cifs_sb;
	struct cifs_tcon *tcon;
3247 3248
	unsigned int i;
	int rc;
3249

3250 3251
	tcon = tlink_tcon(ctx->cfile->tlink);
	cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb);
3252

3253
	mutex_lock(&ctx->aio_mutex);
3254

3255 3256 3257 3258
	if (list_empty(&ctx->list)) {
		mutex_unlock(&ctx->aio_mutex);
		return;
	}
3259

3260
	rc = ctx->rc;
3261
	/* the loop below should proceed in the order of increasing offsets */
3262
again:
3263
	list_for_each_entry_safe(rdata, tmp, &ctx->list, list) {
3264
		if (!rc) {
3265 3266 3267 3268 3269 3270
			if (!try_wait_for_completion(&rdata->done)) {
				mutex_unlock(&ctx->aio_mutex);
				return;
			}

			if (rdata->result == -EAGAIN) {
3271
				/* resend call if it's a retryable error */
3272
				struct list_head tmp_list;
3273
				unsigned int got_bytes = rdata->got_bytes;
3274

3275 3276
				list_del_init(&rdata->list);
				INIT_LIST_HEAD(&tmp_list);
3277

3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289
				/*
				 * Got a part of data and then reconnect has
				 * happened -- fill the buffer and continue
				 * reading.
				 */
				if (got_bytes && got_bytes < rdata->bytes) {
					rc = cifs_readdata_to_iov(rdata, to);
					if (rc) {
						kref_put(&rdata->refcount,
						cifs_uncached_readdata_release);
						continue;
					}
3290
				}
3291 3292 3293 3294 3295

				rc = cifs_send_async_read(
						rdata->offset + got_bytes,
						rdata->bytes - got_bytes,
						rdata->cfile, cifs_sb,
3296
						&tmp_list, ctx);
3297

3298
				list_splice(&tmp_list, &ctx->list);
3299

3300 3301 3302 3303 3304 3305
				kref_put(&rdata->refcount,
					 cifs_uncached_readdata_release);
				goto again;
			} else if (rdata->result)
				rc = rdata->result;
			else
A
Al Viro 已提交
3306
				rc = cifs_readdata_to_iov(rdata, to);
3307

3308 3309 3310
			/* if there was a short read -- discard anything left */
			if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
				rc = -ENODATA;
L
Linus Torvalds 已提交
3311
		}
3312 3313
		list_del_init(&rdata->list);
		kref_put(&rdata->refcount, cifs_uncached_readdata_release);
L
Linus Torvalds 已提交
3314
	}
3315

3316 3317 3318 3319 3320
	for (i = 0; i < ctx->npages; i++) {
		if (ctx->should_dirty)
			set_page_dirty(ctx->bv[i].bv_page);
		put_page(ctx->bv[i].bv_page);
	}
3321

3322 3323 3324
	ctx->total_len = ctx->len - iov_iter_count(to);

	cifs_stats_bytes_read(tcon, ctx->total_len);
3325

3326 3327 3328 3329
	/* mask nodata case */
	if (rc == -ENODATA)
		rc = 0;

3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374
	ctx->rc = (rc == 0) ? ctx->total_len : rc;

	mutex_unlock(&ctx->aio_mutex);

	if (ctx->iocb && ctx->iocb->ki_complete)
		ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
	else
		complete(&ctx->done);
}

ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
{
	struct file *file = iocb->ki_filp;
	ssize_t rc;
	size_t len;
	ssize_t total_read = 0;
	loff_t offset = iocb->ki_pos;
	struct cifs_sb_info *cifs_sb;
	struct cifs_tcon *tcon;
	struct cifsFileInfo *cfile;
	struct cifs_aio_ctx *ctx;

	len = iov_iter_count(to);
	if (!len)
		return 0;

	cifs_sb = CIFS_FILE_SB(file);
	cfile = file->private_data;
	tcon = tlink_tcon(cfile->tlink);

	if (!tcon->ses->server->ops->async_readv)
		return -ENOSYS;

	if ((file->f_flags & O_ACCMODE) == O_WRONLY)
		cifs_dbg(FYI, "attempting read on write only file instance\n");

	ctx = cifs_aio_ctx_alloc();
	if (!ctx)
		return -ENOMEM;

	ctx->cfile = cifsFileInfo_get(cfile);

	if (!is_sync_kiocb(iocb))
		ctx->iocb = iocb;

3375
	if (to->type == ITER_IOVEC)
3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419
		ctx->should_dirty = true;

	rc = setup_aio_ctx_iter(ctx, to, READ);
	if (rc) {
		kref_put(&ctx->refcount, cifs_aio_ctx_release);
		return rc;
	}

	len = ctx->len;

	/* grab a lock here due to read response handlers can access ctx */
	mutex_lock(&ctx->aio_mutex);

	rc = cifs_send_async_read(offset, len, cfile, cifs_sb, &ctx->list, ctx);

	/* if at least one read request send succeeded, then reset rc */
	if (!list_empty(&ctx->list))
		rc = 0;

	mutex_unlock(&ctx->aio_mutex);

	if (rc) {
		kref_put(&ctx->refcount, cifs_aio_ctx_release);
		return rc;
	}

	if (!is_sync_kiocb(iocb)) {
		kref_put(&ctx->refcount, cifs_aio_ctx_release);
		return -EIOCBQUEUED;
	}

	rc = wait_for_completion_killable(&ctx->done);
	if (rc) {
		mutex_lock(&ctx->aio_mutex);
		ctx->rc = rc = -EINTR;
		total_read = ctx->total_len;
		mutex_unlock(&ctx->aio_mutex);
	} else {
		rc = ctx->rc;
		total_read = ctx->total_len;
	}

	kref_put(&ctx->refcount, cifs_aio_ctx_release);

3420
	if (total_read) {
A
Al Viro 已提交
3421
		iocb->ki_pos += total_read;
3422 3423 3424
		return total_read;
	}
	return rc;
3425 3426
}

3427
ssize_t
A
Al Viro 已提交
3428
cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3429
{
A
Al Viro 已提交
3430
	struct inode *inode = file_inode(iocb->ki_filp);
3431 3432 3433 3434 3435 3436
	struct cifsInodeInfo *cinode = CIFS_I(inode);
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
	struct cifsFileInfo *cfile = (struct cifsFileInfo *)
						iocb->ki_filp->private_data;
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
	int rc = -EACCES;
3437 3438 3439 3440 3441 3442 3443 3444 3445

	/*
	 * In strict cache mode we need to read from the server all the time
	 * if we don't have level II oplock because the server can delay mtime
	 * change - so we can't make a decision about inode invalidating.
	 * And we can also fail with pagereading if there are mandatory locks
	 * on pages affected by this read but not on the region from pos to
	 * pos+len-1.
	 */
3446
	if (!CIFS_CACHE_READ(cinode))
A
Al Viro 已提交
3447
		return cifs_user_readv(iocb, to);
3448

3449 3450 3451
	if (cap_unix(tcon->ses) &&
	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
A
Al Viro 已提交
3452
		return generic_file_read_iter(iocb, to);
3453 3454 3455 3456 3457 3458

	/*
	 * We need to hold the sem to be sure nobody modifies lock list
	 * with a brlock that prevents reading.
	 */
	down_read(&cinode->lock_sem);
A
Al Viro 已提交
3459
	if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3460
				     tcon->ses->server->vals->shared_lock_type,
3461
				     NULL, CIFS_READ_OP))
A
Al Viro 已提交
3462
		rc = generic_file_read_iter(iocb, to);
3463 3464
	up_read(&cinode->lock_sem);
	return rc;
3465
}
L
Linus Torvalds 已提交
3466

3467 3468
static ssize_t
cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
L
Linus Torvalds 已提交
3469 3470 3471 3472 3473
{
	int rc = -EACCES;
	unsigned int bytes_read = 0;
	unsigned int total_read;
	unsigned int current_read_size;
3474
	unsigned int rsize;
L
Linus Torvalds 已提交
3475
	struct cifs_sb_info *cifs_sb;
3476
	struct cifs_tcon *tcon;
3477
	struct TCP_Server_Info *server;
3478
	unsigned int xid;
3479
	char *cur_offset;
L
Linus Torvalds 已提交
3480
	struct cifsFileInfo *open_file;
3481
	struct cifs_io_parms io_parms;
3482
	int buf_type = CIFS_NO_BUFFER;
3483
	__u32 pid;
L
Linus Torvalds 已提交
3484

3485
	xid = get_xid();
3486
	cifs_sb = CIFS_FILE_SB(file);
L
Linus Torvalds 已提交
3487

3488 3489 3490
	/* FIXME: set up handlers for larger reads and/or convert to async */
	rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);

L
Linus Torvalds 已提交
3491
	if (file->private_data == NULL) {
3492
		rc = -EBADF;
3493
		free_xid(xid);
3494
		return rc;
L
Linus Torvalds 已提交
3495
	}
3496
	open_file = file->private_data;
3497
	tcon = tlink_tcon(open_file->tlink);
3498 3499 3500 3501 3502 3503
	server = tcon->ses->server;

	if (!server->ops->sync_read) {
		free_xid(xid);
		return -ENOSYS;
	}
L
Linus Torvalds 已提交
3504

3505 3506 3507 3508 3509
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

L
Linus Torvalds 已提交
3510
	if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3511
		cifs_dbg(FYI, "attempting read on write only file instance\n");
L
Linus Torvalds 已提交
3512

3513 3514
	for (total_read = 0, cur_offset = read_data; read_size > total_read;
	     total_read += bytes_read, cur_offset += bytes_read) {
3515 3516 3517 3518 3519 3520 3521 3522 3523
		do {
			current_read_size = min_t(uint, read_size - total_read,
						  rsize);
			/*
			 * For windows me and 9x we do not want to request more
			 * than it negotiated since it will refuse the read
			 * then.
			 */
			if ((tcon->ses) && !(tcon->ses->capabilities &
3524
				tcon->ses->server->vals->cap_large_files)) {
3525 3526 3527
				current_read_size = min_t(uint,
					current_read_size, CIFSMaxBufSize);
			}
3528
			if (open_file->invalidHandle) {
J
Jeff Layton 已提交
3529
				rc = cifs_reopen_file(open_file, true);
L
Linus Torvalds 已提交
3530 3531 3532
				if (rc != 0)
					break;
			}
3533
			io_parms.pid = pid;
3534
			io_parms.tcon = tcon;
3535
			io_parms.offset = *offset;
3536
			io_parms.length = current_read_size;
3537
			rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
3538 3539
						    &bytes_read, &cur_offset,
						    &buf_type);
3540 3541
		} while (rc == -EAGAIN);

L
Linus Torvalds 已提交
3542 3543 3544 3545
		if (rc || (bytes_read == 0)) {
			if (total_read) {
				break;
			} else {
3546
				free_xid(xid);
L
Linus Torvalds 已提交
3547 3548 3549
				return rc;
			}
		} else {
3550
			cifs_stats_bytes_read(tcon, total_read);
3551
			*offset += bytes_read;
L
Linus Torvalds 已提交
3552 3553
		}
	}
3554
	free_xid(xid);
L
Linus Torvalds 已提交
3555 3556 3557
	return total_read;
}

3558 3559 3560 3561
/*
 * If the page is mmap'ed into a process' page tables, then we need to make
 * sure that it doesn't change while being written back.
 */
3562
static vm_fault_t
3563
cifs_page_mkwrite(struct vm_fault *vmf)
3564 3565 3566 3567 3568 3569 3570
{
	struct page *page = vmf->page;

	lock_page(page);
	return VM_FAULT_LOCKED;
}

3571
static const struct vm_operations_struct cifs_file_vm_ops = {
3572
	.fault = filemap_fault,
3573
	.map_pages = filemap_map_pages,
3574 3575 3576
	.page_mkwrite = cifs_page_mkwrite,
};

3577 3578
int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
{
3579
	int xid, rc = 0;
A
Al Viro 已提交
3580
	struct inode *inode = file_inode(file);
3581

3582
	xid = get_xid();
3583

3584
	if (!CIFS_CACHE_READ(CIFS_I(inode)))
3585
		rc = cifs_zap_mapping(inode);
3586 3587 3588
	if (!rc)
		rc = generic_file_mmap(file, vma);
	if (!rc)
3589
		vma->vm_ops = &cifs_file_vm_ops;
3590

3591
	free_xid(xid);
3592 3593 3594
	return rc;
}

L
Linus Torvalds 已提交
3595 3596 3597 3598
int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
{
	int rc, xid;

3599
	xid = get_xid();
3600

J
Jeff Layton 已提交
3601
	rc = cifs_revalidate_file(file);
3602
	if (rc)
3603 3604
		cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
			 rc);
3605 3606 3607
	if (!rc)
		rc = generic_file_mmap(file, vma);
	if (!rc)
3608
		vma->vm_ops = &cifs_file_vm_ops;
3609

3610
	free_xid(xid);
L
Linus Torvalds 已提交
3611 3612 3613
	return rc;
}

3614 3615 3616
static void
cifs_readv_complete(struct work_struct *work)
{
3617
	unsigned int i, got_bytes;
3618 3619 3620
	struct cifs_readdata *rdata = container_of(work,
						struct cifs_readdata, work);

3621
	got_bytes = rdata->got_bytes;
3622 3623 3624
	for (i = 0; i < rdata->nr_pages; i++) {
		struct page *page = rdata->pages[i];

3625 3626
		lru_cache_add_file(page);

3627 3628
		if (rdata->result == 0 ||
		    (rdata->result == -EAGAIN && got_bytes)) {
3629 3630 3631 3632 3633 3634
			flush_dcache_page(page);
			SetPageUptodate(page);
		}

		unlock_page(page);

3635 3636
		if (rdata->result == 0 ||
		    (rdata->result == -EAGAIN && got_bytes))
3637 3638
			cifs_readpage_to_fscache(rdata->mapping->host, page);

3639
		got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
3640

3641
		put_page(page);
3642
		rdata->pages[i] = NULL;
3643
	}
3644
	kref_put(&rdata->refcount, cifs_readdata_release);
3645 3646
}

3647
static int
3648 3649 3650
readpages_fill_pages(struct TCP_Server_Info *server,
		     struct cifs_readdata *rdata, struct iov_iter *iter,
		     unsigned int len)
3651
{
3652
	int result = 0;
3653
	unsigned int i;
3654 3655
	u64 eof;
	pgoff_t eof_index;
3656
	unsigned int nr_pages = rdata->nr_pages;
L
Long Li 已提交
3657
	unsigned int page_offset = rdata->page_offset;
3658 3659 3660

	/* determine the eof that the server (probably) has */
	eof = CIFS_I(rdata->mapping->host)->server_eof;
3661
	eof_index = eof ? (eof - 1) >> PAGE_SHIFT : 0;
3662
	cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
3663

3664
	rdata->got_bytes = 0;
3665
	rdata->tailsz = PAGE_SIZE;
3666 3667
	for (i = 0; i < nr_pages; i++) {
		struct page *page = rdata->pages[i];
L
Long Li 已提交
3668 3669 3670 3671 3672 3673 3674 3675 3676
		unsigned int to_read = rdata->pagesz;
		size_t n;

		if (i == 0)
			to_read -= page_offset;
		else
			page_offset = 0;

		n = to_read;
3677

L
Long Li 已提交
3678 3679
		if (len >= to_read) {
			len -= to_read;
3680
		} else if (len > 0) {
3681
			/* enough for partial page, fill and zero the rest */
L
Long Li 已提交
3682
			zero_user(page, len + page_offset, to_read - len);
3683
			n = rdata->tailsz = len;
3684
			len = 0;
3685 3686 3687 3688 3689 3690 3691 3692 3693
		} else if (page->index > eof_index) {
			/*
			 * The VFS will not try to do readahead past the
			 * i_size, but it's possible that we have outstanding
			 * writes with gaps in the middle and the i_size hasn't
			 * caught up yet. Populate those with zeroed out pages
			 * to prevent the VFS from repeatedly attempting to
			 * fill them until the writes are flushed.
			 */
3694
			zero_user(page, 0, PAGE_SIZE);
3695 3696 3697 3698
			lru_cache_add_file(page);
			flush_dcache_page(page);
			SetPageUptodate(page);
			unlock_page(page);
3699
			put_page(page);
3700 3701
			rdata->pages[i] = NULL;
			rdata->nr_pages--;
3702
			continue;
3703 3704 3705 3706
		} else {
			/* no need to hold page hostage */
			lru_cache_add_file(page);
			unlock_page(page);
3707
			put_page(page);
3708 3709
			rdata->pages[i] = NULL;
			rdata->nr_pages--;
3710
			continue;
3711
		}
3712

3713
		if (iter)
L
Long Li 已提交
3714 3715
			result = copy_page_from_iter(
					page, page_offset, n, iter);
3716 3717 3718 3719
#ifdef CONFIG_CIFS_SMB_DIRECT
		else if (rdata->mr)
			result = n;
#endif
3720
		else
L
Long Li 已提交
3721 3722
			result = cifs_read_page_from_socket(
					server, page, page_offset, n);
3723 3724 3725
		if (result < 0)
			break;

3726
		rdata->got_bytes += result;
3727 3728
	}

3729 3730
	return rdata->got_bytes > 0 && result != -ECONNABORTED ?
						rdata->got_bytes : result;
3731 3732
}

3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747
static int
cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
			       struct cifs_readdata *rdata, unsigned int len)
{
	return readpages_fill_pages(server, rdata, NULL, len);
}

static int
cifs_readpages_copy_into_pages(struct TCP_Server_Info *server,
			       struct cifs_readdata *rdata,
			       struct iov_iter *iter)
{
	return readpages_fill_pages(server, rdata, iter, iter->count);
}

3748 3749 3750 3751 3752 3753 3754 3755
static int
readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
		    unsigned int rsize, struct list_head *tmplist,
		    unsigned int *nr_pages, loff_t *offset, unsigned int *bytes)
{
	struct page *page, *tpage;
	unsigned int expected_index;
	int rc;
3756
	gfp_t gfp = readahead_gfp_mask(mapping);
3757

3758 3759
	INIT_LIST_HEAD(tmplist);

3760 3761 3762 3763 3764 3765 3766
	page = list_entry(page_list->prev, struct page, lru);

	/*
	 * Lock the page and put it in the cache. Since no one else
	 * should have access to this page, we're safe to simply set
	 * PG_locked without checking it first.
	 */
3767
	__SetPageLocked(page);
3768
	rc = add_to_page_cache_locked(page, mapping,
3769
				      page->index, gfp);
3770 3771 3772

	/* give up if we can't stick it in the cache */
	if (rc) {
3773
		__ClearPageLocked(page);
3774 3775 3776 3777
		return rc;
	}

	/* move first page to the tmplist */
3778 3779
	*offset = (loff_t)page->index << PAGE_SHIFT;
	*bytes = PAGE_SIZE;
3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790
	*nr_pages = 1;
	list_move_tail(&page->lru, tmplist);

	/* now try and add more pages onto the request */
	expected_index = page->index + 1;
	list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
		/* discontinuity ? */
		if (page->index != expected_index)
			break;

		/* would this page push the read over the rsize? */
3791
		if (*bytes + PAGE_SIZE > rsize)
3792 3793
			break;

3794
		__SetPageLocked(page);
3795
		if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
3796
			__ClearPageLocked(page);
3797 3798 3799
			break;
		}
		list_move_tail(&page->lru, tmplist);
3800
		(*bytes) += PAGE_SIZE;
3801 3802 3803 3804
		expected_index++;
		(*nr_pages)++;
	}
	return rc;
3805 3806
}

L
Linus Torvalds 已提交
3807 3808 3809
static int cifs_readpages(struct file *file, struct address_space *mapping,
	struct list_head *page_list, unsigned num_pages)
{
3810 3811 3812
	int rc;
	struct list_head tmplist;
	struct cifsFileInfo *open_file = file->private_data;
3813
	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
3814
	struct TCP_Server_Info *server;
3815
	pid_t pid;
L
Linus Torvalds 已提交
3816

3817 3818 3819
	/*
	 * Reads as many pages as possible from fscache. Returns -ENOBUFS
	 * immediately if the cookie is negative
3820 3821 3822
	 *
	 * After this point, every page in the list might have PG_fscache set,
	 * so we will need to clean that up off of every page we don't use.
3823 3824 3825 3826
	 */
	rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
					 &num_pages);
	if (rc == 0)
3827
		return rc;
3828

3829 3830 3831 3832 3833
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

3834
	rc = 0;
3835
	server = tlink_tcon(open_file->tlink)->ses->server;
L
Linus Torvalds 已提交
3836

3837 3838
	cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
		 __func__, file, mapping, num_pages);
3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851

	/*
	 * Start with the page at end of list and move it to private
	 * list. Do the same with any following pages until we hit
	 * the rsize limit, hit an index discontinuity, or run out of
	 * pages. Issue the async read and then start the loop again
	 * until the list is empty.
	 *
	 * Note that list order is important. The page_list is in
	 * the order of declining indexes. When we put the pages in
	 * the rdata->pages, then we want them in increasing order.
	 */
	while (!list_empty(page_list)) {
3852
		unsigned int i, nr_pages, bytes, rsize;
3853 3854 3855
		loff_t offset;
		struct page *page, *tpage;
		struct cifs_readdata *rdata;
3856
		unsigned credits;
L
Linus Torvalds 已提交
3857

3858 3859 3860 3861
		rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
						   &rsize, &credits);
		if (rc)
			break;
3862 3863

		/*
3864 3865 3866 3867
		 * Give up immediately if rsize is too small to read an entire
		 * page. The VFS will fall back to readpage. We should never
		 * reach this point however since we set ra_pages to 0 when the
		 * rsize is smaller than a cache page.
3868
		 */
3869
		if (unlikely(rsize < PAGE_SIZE)) {
3870
			add_credits_and_wake_if(server, credits, 0);
3871
			return 0;
3872
		}
3873

3874 3875
		rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
					 &nr_pages, &offset, &bytes);
3876
		if (rc) {
3877
			add_credits_and_wake_if(server, credits, 0);
3878 3879 3880
			break;
		}

3881
		rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3882 3883 3884 3885 3886 3887
		if (!rdata) {
			/* best to give up if we're out of mem */
			list_for_each_entry_safe(page, tpage, &tmplist, lru) {
				list_del(&page->lru);
				lru_cache_add_file(page);
				unlock_page(page);
3888
				put_page(page);
3889 3890
			}
			rc = -ENOMEM;
3891
			add_credits_and_wake_if(server, credits, 0);
3892 3893 3894
			break;
		}

3895
		rdata->cfile = cifsFileInfo_get(open_file);
3896 3897 3898 3899
		rdata->mapping = mapping;
		rdata->offset = offset;
		rdata->bytes = bytes;
		rdata->pid = pid;
3900
		rdata->pagesz = PAGE_SIZE;
L
Long Li 已提交
3901
		rdata->tailsz = PAGE_SIZE;
3902
		rdata->read_into_pages = cifs_readpages_read_into_pages;
3903
		rdata->copy_into_pages = cifs_readpages_copy_into_pages;
3904
		rdata->credits = credits;
3905 3906 3907 3908 3909

		list_for_each_entry_safe(page, tpage, &tmplist, lru) {
			list_del(&page->lru);
			rdata->pages[rdata->nr_pages++] = page;
		}
3910

3911
		if (!rdata->cfile->invalidHandle ||
3912
		    !(rc = cifs_reopen_file(rdata->cfile, true)))
3913 3914
			rc = server->ops->async_readv(rdata);
		if (rc) {
3915
			add_credits_and_wake_if(server, rdata->credits, 0);
3916 3917
			for (i = 0; i < rdata->nr_pages; i++) {
				page = rdata->pages[i];
3918 3919
				lru_cache_add_file(page);
				unlock_page(page);
3920
				put_page(page);
L
Linus Torvalds 已提交
3921
			}
3922
			/* Fallback to the readpage in error/reconnect cases */
3923
			kref_put(&rdata->refcount, cifs_readdata_release);
L
Linus Torvalds 已提交
3924 3925
			break;
		}
3926 3927

		kref_put(&rdata->refcount, cifs_readdata_release);
L
Linus Torvalds 已提交
3928 3929
	}

3930 3931 3932 3933 3934
	/* Any pages that have been shown to fscache but didn't get added to
	 * the pagecache must be uncached before they get returned to the
	 * allocator.
	 */
	cifs_fscache_readpages_cancel(mapping->host, page_list);
L
Linus Torvalds 已提交
3935 3936 3937
	return rc;
}

3938 3939 3940
/*
 * cifs_readpage_worker must be called with the page pinned
 */
L
Linus Torvalds 已提交
3941 3942 3943 3944 3945 3946
static int cifs_readpage_worker(struct file *file, struct page *page,
	loff_t *poffset)
{
	char *read_data;
	int rc;

3947
	/* Is the page cached? */
A
Al Viro 已提交
3948
	rc = cifs_readpage_from_fscache(file_inode(file), page);
3949 3950 3951
	if (rc == 0)
		goto read_complete;

L
Linus Torvalds 已提交
3952 3953
	read_data = kmap(page);
	/* for reads over a certain size could initiate async read ahead */
S
Steve French 已提交
3954

3955
	rc = cifs_read(file, read_data, PAGE_SIZE, poffset);
S
Steve French 已提交
3956

L
Linus Torvalds 已提交
3957 3958 3959
	if (rc < 0)
		goto io_error;
	else
3960
		cifs_dbg(FYI, "Bytes read %d\n", rc);
S
Steve French 已提交
3961

A
Al Viro 已提交
3962
	file_inode(file)->i_atime =
3963
		current_time(file_inode(file));
S
Steve French 已提交
3964

3965 3966
	if (PAGE_SIZE > rc)
		memset(read_data + rc, 0, PAGE_SIZE - rc);
L
Linus Torvalds 已提交
3967 3968 3969

	flush_dcache_page(page);
	SetPageUptodate(page);
3970 3971

	/* send this page to the cache */
A
Al Viro 已提交
3972
	cifs_readpage_to_fscache(file_inode(file), page);
3973

L
Linus Torvalds 已提交
3974
	rc = 0;
S
Steve French 已提交
3975

L
Linus Torvalds 已提交
3976
io_error:
S
Steve French 已提交
3977
	kunmap(page);
3978
	unlock_page(page);
3979 3980

read_complete:
L
Linus Torvalds 已提交
3981 3982 3983 3984 3985
	return rc;
}

static int cifs_readpage(struct file *file, struct page *page)
{
3986
	loff_t offset = (loff_t)page->index << PAGE_SHIFT;
L
Linus Torvalds 已提交
3987
	int rc = -EACCES;
3988
	unsigned int xid;
L
Linus Torvalds 已提交
3989

3990
	xid = get_xid();
L
Linus Torvalds 已提交
3991 3992

	if (file->private_data == NULL) {
3993
		rc = -EBADF;
3994
		free_xid(xid);
3995
		return rc;
L
Linus Torvalds 已提交
3996 3997
	}

3998
	cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
3999
		 page, (int)offset, (int)offset);
L
Linus Torvalds 已提交
4000 4001 4002

	rc = cifs_readpage_worker(file, page, &offset);

4003
	free_xid(xid);
L
Linus Torvalds 已提交
4004 4005 4006
	return rc;
}

4007 4008 4009
static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
{
	struct cifsFileInfo *open_file;
4010 4011
	struct cifs_tcon *tcon =
		cifs_sb_master_tcon(CIFS_SB(cifs_inode->vfs_inode.i_sb));
4012

4013
	spin_lock(&tcon->open_file_lock);
4014
	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
4015
		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
4016
			spin_unlock(&tcon->open_file_lock);
4017 4018 4019
			return 1;
		}
	}
4020
	spin_unlock(&tcon->open_file_lock);
4021 4022 4023
	return 0;
}

L
Linus Torvalds 已提交
4024 4025 4026
/* We do not want to update the file size from server for inodes
   open for write - to avoid races with writepage extending
   the file - in the future we could consider allowing
S
Steve French 已提交
4027
   refreshing the inode only on increases in the file size
L
Linus Torvalds 已提交
4028 4029
   but this is tricky to do without racing with writebehind
   page caching in the current Linux kernel design */
4030
bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
L
Linus Torvalds 已提交
4031
{
4032
	if (!cifsInode)
4033
		return true;
4034

4035 4036
	if (is_inode_writable(cifsInode)) {
		/* This inode is open for write at least once */
4037 4038 4039
		struct cifs_sb_info *cifs_sb;

		cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
S
Steve French 已提交
4040
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
S
Steve French 已提交
4041
			/* since no page cache to corrupt on directio
4042
			we can change size safely */
4043
			return true;
4044 4045
		}

S
Steve French 已提交
4046
		if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
4047
			return true;
4048

4049
		return false;
4050
	} else
4051
		return true;
L
Linus Torvalds 已提交
4052 4053
}

N
Nick Piggin 已提交
4054 4055 4056
static int cifs_write_begin(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned flags,
			struct page **pagep, void **fsdata)
L
Linus Torvalds 已提交
4057
{
4058
	int oncethru = 0;
4059 4060
	pgoff_t index = pos >> PAGE_SHIFT;
	loff_t offset = pos & (PAGE_SIZE - 1);
4061 4062 4063 4064
	loff_t page_start = pos & PAGE_MASK;
	loff_t i_size;
	struct page *page;
	int rc = 0;
N
Nick Piggin 已提交
4065

4066
	cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
N
Nick Piggin 已提交
4067

4068
start:
4069
	page = grab_cache_page_write_begin(mapping, index, flags);
4070 4071 4072 4073
	if (!page) {
		rc = -ENOMEM;
		goto out;
	}
4074

4075 4076
	if (PageUptodate(page))
		goto out;
4077

4078 4079 4080 4081 4082
	/*
	 * If we write a full page it will be up to date, no need to read from
	 * the server. If the write is short, we'll end up doing a sync write
	 * instead.
	 */
4083
	if (len == PAGE_SIZE)
4084
		goto out;
4085

4086 4087 4088 4089 4090 4091
	/*
	 * optimize away the read when we have an oplock, and we're not
	 * expecting to use any of the data we'd be reading in. That
	 * is, when the page lies beyond the EOF, or straddles the EOF
	 * and the write will cover all of the existing data.
	 */
4092
	if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
4093 4094 4095 4096 4097
		i_size = i_size_read(mapping->host);
		if (page_start >= i_size ||
		    (offset == 0 && (pos + len) >= i_size)) {
			zero_user_segments(page, 0, offset,
					   offset + len,
4098
					   PAGE_SIZE);
4099 4100 4101 4102 4103 4104 4105 4106 4107 4108
			/*
			 * PageChecked means that the parts of the page
			 * to which we're not writing are considered up
			 * to date. Once the data is copied to the
			 * page, it can be set uptodate.
			 */
			SetPageChecked(page);
			goto out;
		}
	}
N
Nick Piggin 已提交
4109

4110
	if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
4111 4112 4113 4114 4115 4116
		/*
		 * might as well read a page, it is fast enough. If we get
		 * an error, we don't need to return it. cifs_write_end will
		 * do a sync write instead since PG_uptodate isn't set.
		 */
		cifs_readpage_worker(file, page, &page_start);
4117
		put_page(page);
4118 4119
		oncethru = 1;
		goto start;
4120 4121 4122 4123
	} else {
		/* we could try using another file handle if there is one -
		   but how would we lock it to prevent close of that handle
		   racing with this read? In any case
N
Nick Piggin 已提交
4124
		   this will be written out by write_end so is fine */
L
Linus Torvalds 已提交
4125
	}
4126 4127 4128
out:
	*pagep = page;
	return rc;
L
Linus Torvalds 已提交
4129 4130
}

4131 4132 4133 4134 4135 4136 4137 4138
static int cifs_release_page(struct page *page, gfp_t gfp)
{
	if (PagePrivate(page))
		return 0;

	return cifs_fscache_release_page(page, gfp);
}

4139 4140
static void cifs_invalidate_page(struct page *page, unsigned int offset,
				 unsigned int length)
4141 4142 4143
{
	struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);

4144
	if (offset == 0 && length == PAGE_SIZE)
4145 4146 4147
		cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
}

4148 4149 4150 4151
static int cifs_launder_page(struct page *page)
{
	int rc = 0;
	loff_t range_start = page_offset(page);
4152
	loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
4153 4154 4155 4156 4157 4158 4159
	struct writeback_control wbc = {
		.sync_mode = WB_SYNC_ALL,
		.nr_to_write = 0,
		.range_start = range_start,
		.range_end = range_end,
	};

4160
	cifs_dbg(FYI, "Launder page: %p\n", page);
4161 4162 4163 4164 4165 4166 4167 4168

	if (clear_page_dirty_for_io(page))
		rc = cifs_writepage_locked(page, &wbc);

	cifs_fscache_invalidate_page(page, page->mapping->host);
	return rc;
}

4169
void cifs_oplock_break(struct work_struct *work)
4170 4171 4172
{
	struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
						  oplock_break);
4173
	struct inode *inode = d_inode(cfile->dentry);
4174
	struct cifsInodeInfo *cinode = CIFS_I(inode);
4175
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4176
	struct TCP_Server_Info *server = tcon->ses->server;
4177
	int rc = 0;
4178

4179
	wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
4180
			TASK_UNINTERRUPTIBLE);
4181 4182 4183 4184

	server->ops->downgrade_oplock(server, cinode,
		test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2, &cinode->flags));

4185
	if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
4186
						cifs_has_mand_locks(cinode)) {
4187 4188
		cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
			 inode);
4189
		cinode->oplock = 0;
4190 4191
	}

4192
	if (inode && S_ISREG(inode->i_mode)) {
4193
		if (CIFS_CACHE_READ(cinode))
4194
			break_lease(inode, O_RDONLY);
S
Steve French 已提交
4195
		else
4196
			break_lease(inode, O_WRONLY);
4197
		rc = filemap_fdatawrite(inode->i_mapping);
4198
		if (!CIFS_CACHE_READ(cinode)) {
4199 4200
			rc = filemap_fdatawait(inode->i_mapping);
			mapping_set_error(inode->i_mapping, rc);
4201
			cifs_zap_mapping(inode);
4202
		}
4203
		cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
4204 4205
	}

4206 4207
	rc = cifs_push_locks(cfile);
	if (rc)
4208
		cifs_dbg(VFS, "Push locks rc = %d\n", rc);
4209

4210 4211 4212 4213 4214 4215
	/*
	 * releasing stale oplock after recent reconnect of smb session using
	 * a now incorrect file handle is not a data integrity issue but do
	 * not bother sending an oplock release if session to server still is
	 * disconnected since oplock already released by the server
	 */
4216
	if (!cfile->oplock_break_cancelled) {
4217 4218
		rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
							     cinode);
4219
		cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
4220
	}
4221
	_cifsFileInfo_put(cfile, false /* do not wait for ourself */);
4222
	cifs_done_oplock_break(cinode);
4223 4224
}

4225 4226 4227 4228 4229 4230 4231 4232 4233 4234
/*
 * The presence of cifs_direct_io() in the address space ops vector
 * allowes open() O_DIRECT flags which would have failed otherwise.
 *
 * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
 * so this method should never be called.
 *
 * Direct IO is not yet supported in the cached mode. 
 */
static ssize_t
4235
cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
4236 4237 4238 4239 4240 4241 4242 4243 4244
{
        /*
         * FIXME
         * Eventually need to support direct IO for non forcedirectio mounts
         */
        return -EINVAL;
}


4245
const struct address_space_operations cifs_addr_ops = {
L
Linus Torvalds 已提交
4246 4247 4248
	.readpage = cifs_readpage,
	.readpages = cifs_readpages,
	.writepage = cifs_writepage,
4249
	.writepages = cifs_writepages,
N
Nick Piggin 已提交
4250 4251
	.write_begin = cifs_write_begin,
	.write_end = cifs_write_end,
L
Linus Torvalds 已提交
4252
	.set_page_dirty = __set_page_dirty_nobuffers,
4253
	.releasepage = cifs_release_page,
4254
	.direct_IO = cifs_direct_io,
4255
	.invalidatepage = cifs_invalidate_page,
4256
	.launder_page = cifs_launder_page,
L
Linus Torvalds 已提交
4257
};
D
Dave Kleikamp 已提交
4258 4259 4260 4261 4262 4263

/*
 * cifs_readpages requires the server to support a buffer large enough to
 * contain the header plus one complete page of data.  Otherwise, we need
 * to leave cifs_readpages out of the address space operations.
 */
4264
const struct address_space_operations cifs_addr_ops_smallbuf = {
D
Dave Kleikamp 已提交
4265 4266 4267
	.readpage = cifs_readpage,
	.writepage = cifs_writepage,
	.writepages = cifs_writepages,
N
Nick Piggin 已提交
4268 4269
	.write_begin = cifs_write_begin,
	.write_end = cifs_write_end,
D
Dave Kleikamp 已提交
4270
	.set_page_dirty = __set_page_dirty_nobuffers,
4271 4272
	.releasepage = cifs_release_page,
	.invalidatepage = cifs_invalidate_page,
4273
	.launder_page = cifs_launder_page,
D
Dave Kleikamp 已提交
4274
};