file.c 109.0 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 284 285 286 287 288 289
void
cifs_down_write(struct rw_semaphore *sem)
{
	while (!down_write_trylock(sem))
		msleep(10);
}

290
struct cifsFileInfo *
291
cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
292 293
		  struct tcon_link *tlink, __u32 oplock)
{
G
Goldwyn Rodrigues 已提交
294
	struct dentry *dentry = file_dentry(file);
295
	struct inode *inode = d_inode(dentry);
296 297
	struct cifsInodeInfo *cinode = CIFS_I(inode);
	struct cifsFileInfo *cfile;
298
	struct cifs_fid_locks *fdlocks;
299
	struct cifs_tcon *tcon = tlink_tcon(tlink);
300
	struct TCP_Server_Info *server = tcon->ses->server;
301 302 303 304 305

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

306 307 308 309 310 311 312 313 314 315
	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;

316 317 318 319 320 321 322 323
	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);
324
	mutex_init(&cfile->fh_mutex);
325
	spin_lock_init(&cfile->file_info_lock);
326

327 328
	cifs_sb_active(inode->i_sb);

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

338 339 340 341
	cifs_down_write(&cinode->lock_sem);
	list_add(&fdlocks->llist, &cinode->llist);
	up_write(&cinode->lock_sem);

342
	spin_lock(&tcon->open_file_lock);
343
	if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
344 345 346
		oplock = fid->pending_open->oplock;
	list_del(&fid->pending_open->olist);

347
	fid->purge_cache = false;
348
	server->ops->set_fid(cfile, fid, oplock);
349 350

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

352
	/* if readable file instance put first in list*/
353
	spin_lock(&cinode->open_file_lock);
354
	if (file->f_mode & FMODE_READ)
355
		list_add(&cfile->flist, &cinode->openFileList);
356
	else
357
		list_add_tail(&cfile->flist, &cinode->openFileList);
358
	spin_unlock(&cinode->open_file_lock);
359
	spin_unlock(&tcon->open_file_lock);
360

361
	if (fid->purge_cache)
362
		cifs_zap_mapping(inode);
363

364 365
	file->private_data = cfile;
	return cfile;
366 367
}

368 369 370
struct cifsFileInfo *
cifsFileInfo_get(struct cifsFileInfo *cifs_file)
{
371
	spin_lock(&cifs_file->file_info_lock);
372
	cifsFileInfo_get_locked(cifs_file);
373
	spin_unlock(&cifs_file->file_info_lock);
374 375 376
	return cifs_file;
}

377 378 379 380
/**
 * cifsFileInfo_put - release a reference of file priv data
 *
 * Always potentially wait for oplock handler. See _cifsFileInfo_put().
381
 */
382
void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400
{
	_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)
401
{
402
	struct inode *inode = d_inode(cifs_file->dentry);
403
	struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
404
	struct TCP_Server_Info *server = tcon->ses->server;
P
Pavel Shilovsky 已提交
405
	struct cifsInodeInfo *cifsi = CIFS_I(inode);
406 407
	struct super_block *sb = inode->i_sb;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
408
	struct cifsLockInfo *li, *tmp;
409 410
	struct cifs_fid fid;
	struct cifs_pending_open open;
411
	bool oplock_break_cancelled;
412

413
	spin_lock(&tcon->open_file_lock);
414
	spin_lock(&cifsi->open_file_lock);
415
	spin_lock(&cifs_file->file_info_lock);
416
	if (--cifs_file->count > 0) {
417
		spin_unlock(&cifs_file->file_info_lock);
418
		spin_unlock(&cifsi->open_file_lock);
419
		spin_unlock(&tcon->open_file_lock);
420 421
		return;
	}
422
	spin_unlock(&cifs_file->file_info_lock);
423

424 425 426 427 428 429
	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);

430 431 432 433 434
	/* remove it from the lists */
	list_del(&cifs_file->flist);
	list_del(&cifs_file->tlist);

	if (list_empty(&cifsi->openFileList)) {
435
		cifs_dbg(FYI, "closing last open instance for inode %p\n",
436
			 d_inode(cifs_file->dentry));
437 438 439 440 441
		/*
		 * 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.
		 */
442
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
443
			set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
444
		cifs_set_oplock_level(cifsi, 0);
445
	}
446

447
	spin_unlock(&cifsi->open_file_lock);
448
	spin_unlock(&tcon->open_file_lock);
449

450 451
	oplock_break_cancelled = wait_oplock_handler ?
		cancel_work_sync(&cifs_file->oplock_break) : false;
452

453
	if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
454
		struct TCP_Server_Info *server = tcon->ses->server;
455
		unsigned int xid;
456

457
		xid = get_xid();
458
		if (server->ops->close)
459 460
			server->ops->close(xid, tcon, &cifs_file->fid);
		_free_xid(xid);
461 462
	}

463 464 465
	if (oplock_break_cancelled)
		cifs_done_oplock_break(cifsi);

466 467
	cifs_del_pending_open(&open);

468 469
	/*
	 * Delete any outstanding lock records. We'll lose them when the file
470 471
	 * is closed anyway.
	 */
472
	cifs_down_write(&cifsi->lock_sem);
473
	list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
474
		list_del(&li->llist);
475
		cifs_del_lock_waiters(li);
476
		kfree(li);
477
	}
478 479
	list_del(&cifs_file->llist->llist);
	kfree(cifs_file->llist);
480
	up_write(&cifsi->lock_sem);
481 482 483

	cifs_put_tlink(cifs_file->tlink);
	dput(cifs_file->dentry);
484
	cifs_sb_deactive(sb);
485
	kfree(cifs_file);
486 487
}

L
Linus Torvalds 已提交
488
int cifs_open(struct inode *inode, struct file *file)
489

L
Linus Torvalds 已提交
490 491
{
	int rc = -EACCES;
492
	unsigned int xid;
493
	__u32 oplock;
L
Linus Torvalds 已提交
494
	struct cifs_sb_info *cifs_sb;
P
Pavel Shilovsky 已提交
495
	struct TCP_Server_Info *server;
496
	struct cifs_tcon *tcon;
497
	struct tcon_link *tlink;
498
	struct cifsFileInfo *cfile = NULL;
L
Linus Torvalds 已提交
499
	char *full_path = NULL;
P
Pavel Shilovsky 已提交
500
	bool posix_open_ok = false;
501
	struct cifs_fid fid;
502
	struct cifs_pending_open open;
L
Linus Torvalds 已提交
503

504
	xid = get_xid();
L
Linus Torvalds 已提交
505 506

	cifs_sb = CIFS_SB(inode->i_sb);
507 508
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink)) {
509
		free_xid(xid);
510 511 512
		return PTR_ERR(tlink);
	}
	tcon = tlink_tcon(tlink);
P
Pavel Shilovsky 已提交
513
	server = tcon->ses->server;
L
Linus Torvalds 已提交
514

G
Goldwyn Rodrigues 已提交
515
	full_path = build_path_from_dentry(file_dentry(file));
L
Linus Torvalds 已提交
516
	if (full_path == NULL) {
517
		rc = -ENOMEM;
518
		goto out;
L
Linus Torvalds 已提交
519 520
	}

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

524 525 526 527 528 529 530 531
	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;
	}

532
	if (server->oplocks)
533 534 535 536
		oplock = REQ_OPLOCK;
	else
		oplock = 0;

537
	if (!tcon->broken_posix_open && tcon->unix_ext &&
538 539
	    cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
540
		/* can not refresh inode info since size could be stale */
541
		rc = cifs_posix_open(full_path, &inode, inode->i_sb,
542
				cifs_sb->mnt_file_mode /* ignored */,
543
				file->f_flags, &oplock, &fid.netfid, xid);
544
		if (rc == 0) {
545
			cifs_dbg(FYI, "posix open succeeded\n");
P
Pavel Shilovsky 已提交
546
			posix_open_ok = true;
547 548
		} else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
			if (tcon->ses->serverNOS)
549 550 551
				cifs_dbg(VFS, "server %s of type %s returned unexpected error on SMB posix open, disabling posix open support. Check if server update available.\n",
					 tcon->ses->serverName,
					 tcon->ses->serverNOS);
552
			tcon->broken_posix_open = true;
553 554 555
		} else if ((rc != -EIO) && (rc != -EREMOTE) &&
			 (rc != -EOPNOTSUPP)) /* path not found or net err */
			goto out;
556 557 558 559
		/*
		 * Else fallthrough to retry open the old way on network i/o
		 * or DFS errors.
		 */
560 561
	}

562 563 564 565 566
	if (server->ops->get_lease_key)
		server->ops->get_lease_key(inode, &fid);

	cifs_add_pending_open(&fid, tlink, &open);

P
Pavel Shilovsky 已提交
567
	if (!posix_open_ok) {
P
Pavel Shilovsky 已提交
568 569 570
		if (server->ops->get_lease_key)
			server->ops->get_lease_key(inode, &fid);

P
Pavel Shilovsky 已提交
571
		rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
572
				  file->f_flags, &oplock, &fid, xid);
573 574
		if (rc) {
			cifs_del_pending_open(&open);
P
Pavel Shilovsky 已提交
575
			goto out;
576
		}
P
Pavel Shilovsky 已提交
577
	}
578

579 580
	cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
	if (cfile == NULL) {
P
Pavel Shilovsky 已提交
581 582
		if (server->ops->close)
			server->ops->close(xid, tcon, &fid);
583
		cifs_del_pending_open(&open);
L
Linus Torvalds 已提交
584 585 586 587
		rc = -ENOMEM;
		goto out;
	}

588 589
	cifs_fscache_set_inode_cookie(inode, file);

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

out:
	kfree(full_path);
610
	free_xid(xid);
611
	cifs_put_tlink(tlink);
L
Linus Torvalds 已提交
612 613 614
	return rc;
}

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

617 618
/*
 * Try to reacquire byte range locks that were released when session
P
Pavel Shilovsky 已提交
619
 * to server was lost.
620
 */
P
Pavel Shilovsky 已提交
621 622
static int
cifs_relock_file(struct cifsFileInfo *cfile)
L
Linus Torvalds 已提交
623
{
P
Pavel Shilovsky 已提交
624
	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
625
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
P
Pavel Shilovsky 已提交
626
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
L
Linus Torvalds 已提交
627 628
	int rc = 0;

629
	down_read_nested(&cinode->lock_sem, SINGLE_DEPTH_NESTING);
P
Pavel Shilovsky 已提交
630
	if (cinode->can_cache_brlcks) {
631 632
		/* can cache locks - no need to relock */
		up_read(&cinode->lock_sem);
P
Pavel Shilovsky 已提交
633 634 635 636 637 638 639 640 641
		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 已提交
642

643
	up_read(&cinode->lock_sem);
L
Linus Torvalds 已提交
644 645 646
	return rc;
}

647 648
static int
cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
L
Linus Torvalds 已提交
649 650
{
	int rc = -EACCES;
651
	unsigned int xid;
652
	__u32 oplock;
L
Linus Torvalds 已提交
653
	struct cifs_sb_info *cifs_sb;
654
	struct cifs_tcon *tcon;
655 656
	struct TCP_Server_Info *server;
	struct cifsInodeInfo *cinode;
S
Steve French 已提交
657
	struct inode *inode;
L
Linus Torvalds 已提交
658
	char *full_path = NULL;
659
	int desired_access;
L
Linus Torvalds 已提交
660
	int disposition = FILE_OPEN;
661
	int create_options = CREATE_NOT_DIR;
662
	struct cifs_open_parms oparms;
L
Linus Torvalds 已提交
663

664
	xid = get_xid();
665 666 667
	mutex_lock(&cfile->fh_mutex);
	if (!cfile->invalidHandle) {
		mutex_unlock(&cfile->fh_mutex);
668
		rc = 0;
669
		free_xid(xid);
670
		return rc;
L
Linus Torvalds 已提交
671 672
	}

673
	inode = d_inode(cfile->dentry);
L
Linus Torvalds 已提交
674
	cifs_sb = CIFS_SB(inode->i_sb);
675 676 677 678 679 680 681 682 683 684
	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 已提交
685
	if (full_path == NULL) {
686
		rc = -ENOMEM;
687
		mutex_unlock(&cfile->fh_mutex);
688
		free_xid(xid);
689
		return rc;
L
Linus Torvalds 已提交
690 691
	}

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

695
	if (tcon->ses->server->oplocks)
L
Linus Torvalds 已提交
696 697
		oplock = REQ_OPLOCK;
	else
698
		oplock = 0;
L
Linus Torvalds 已提交
699

700
	if (tcon->unix_ext && cap_unix(tcon->ses) &&
701
	    (CIFS_UNIX_POSIX_PATH_OPS_CAP &
702
				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
703 704 705 706
		/*
		 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
		 * original open. Must mask them off for a reopen.
		 */
707
		unsigned int oflags = cfile->f_flags &
J
Jeff Layton 已提交
708
						~(O_CREAT | O_EXCL | O_TRUNC);
709

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

724
	desired_access = cifs_convert_flags(cfile->f_flags);
725

726 727 728
	if (backup_cred(cifs_sb))
		create_options |= CREATE_OPEN_BACKUP_INTENT;

729 730 731 732 733 734 735
	/* O_SYNC also has bit for O_DSYNC so following check picks up either */
	if (cfile->f_flags & O_SYNC)
		create_options |= CREATE_WRITE_THROUGH;

	if (cfile->f_flags & O_DIRECT)
		create_options |= CREATE_NO_BUFFER;

P
Pavel Shilovsky 已提交
736
	if (server->ops->get_lease_key)
737
		server->ops->get_lease_key(inode, &cfile->fid);
P
Pavel Shilovsky 已提交
738

739 740 741 742 743 744
	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;
745 746
	oparms.fid = &cfile->fid;
	oparms.reconnect = true;
747

748 749
	/*
	 * Can not refresh inode by passing in file_info buf to be returned by
750
	 * ops->open and then calling get_inode_info with returned buf since
751 752 753 754
	 * 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.
	 */
755
	rc = server->ops->open(xid, &oparms, &oplock, NULL);
756 757 758 759 760 761 762
	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 已提交
763
	if (rc) {
764
		mutex_unlock(&cfile->fh_mutex);
765 766
		cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
		cifs_dbg(FYI, "oplock: %d\n", oplock);
J
Jeff Layton 已提交
767 768 769
		goto reopen_error_exit;
	}

770
reopen_success:
771 772 773
	cfile->invalidHandle = false;
	mutex_unlock(&cfile->fh_mutex);
	cinode = CIFS_I(inode);
J
Jeff Layton 已提交
774 775 776

	if (can_flush) {
		rc = filemap_write_and_wait(inode->i_mapping);
777 778
		if (!is_interrupt_error(rc))
			mapping_set_error(inode->i_mapping, rc);
J
Jeff Layton 已提交
779 780

		if (tcon->unix_ext)
781 782
			rc = cifs_get_inode_info_unix(&inode, full_path,
						      inode->i_sb, xid);
J
Jeff Layton 已提交
783
		else
784 785 786 787 788 789 790 791 792 793
			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.
	 */

794 795 796 797 798 799 800 801 802
	/*
	 * 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;
	}

803 804 805
	server->ops->set_fid(cfile, &cfile->fid, oplock);
	if (oparms.reconnect)
		cifs_relock_file(cfile);
J
Jeff Layton 已提交
806 807

reopen_error_exit:
L
Linus Torvalds 已提交
808
	kfree(full_path);
809
	free_xid(xid);
L
Linus Torvalds 已提交
810 811 812 813 814
	return rc;
}

int cifs_close(struct inode *inode, struct file *file)
{
815 816 817 818
	if (file->private_data != NULL) {
		cifsFileInfo_put(file->private_data);
		file->private_data = NULL;
	}
J
[CIFS]  
Jeremy Allison 已提交
819

820 821
	/* return code from the ->release op is always ignored */
	return 0;
L
Linus Torvalds 已提交
822 823
}

824 825 826
void
cifs_reopen_persistent_handles(struct cifs_tcon *tcon)
{
827
	struct cifsFileInfo *open_file;
828 829
	struct list_head *tmp;
	struct list_head *tmp1;
830 831
	struct list_head tmp_list;

832 833 834 835 836
	if (!tcon->use_persistent || !tcon->need_reopen_files)
		return;

	tcon->need_reopen_files = false;

837 838
	cifs_dbg(FYI, "Reopen persistent handles");
	INIT_LIST_HEAD(&tmp_list);
839 840 841

	/* list all files open on tree connection, reopen resilient handles  */
	spin_lock(&tcon->open_file_lock);
842
	list_for_each(tmp, &tcon->openFileList) {
843
		open_file = list_entry(tmp, struct cifsFileInfo, tlist);
844 845 846 847
		if (!open_file->invalidHandle)
			continue;
		cifsFileInfo_get(open_file);
		list_add_tail(&open_file->rlist, &tmp_list);
848 849
	}
	spin_unlock(&tcon->open_file_lock);
850 851 852

	list_for_each_safe(tmp, tmp1, &tmp_list) {
		open_file = list_entry(tmp, struct cifsFileInfo, rlist);
853 854
		if (cifs_reopen_file(open_file, false /* do not flush */))
			tcon->need_reopen_files = true;
855 856 857
		list_del_init(&open_file->rlist);
		cifsFileInfo_put(open_file);
	}
858 859
}

L
Linus Torvalds 已提交
860 861 862
int cifs_closedir(struct inode *inode, struct file *file)
{
	int rc = 0;
863
	unsigned int xid;
864
	struct cifsFileInfo *cfile = file->private_data;
865 866 867
	struct cifs_tcon *tcon;
	struct TCP_Server_Info *server;
	char *buf;
L
Linus Torvalds 已提交
868

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

871 872 873
	if (cfile == NULL)
		return rc;

874
	xid = get_xid();
875 876
	tcon = tlink_tcon(cfile->tlink);
	server = tcon->ses->server;
L
Linus Torvalds 已提交
877

878
	cifs_dbg(FYI, "Freeing private data in close dir\n");
879
	spin_lock(&cfile->file_info_lock);
880
	if (server->ops->dir_needs_close(cfile)) {
881
		cfile->invalidHandle = true;
882
		spin_unlock(&cfile->file_info_lock);
883 884 885 886
		if (server->ops->close_dir)
			rc = server->ops->close_dir(xid, tcon, &cfile->fid);
		else
			rc = -ENOSYS;
887
		cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
888 889 890
		/* not much we can do if it fails anyway, ignore rc */
		rc = 0;
	} else
891
		spin_unlock(&cfile->file_info_lock);
892 893 894

	buf = cfile->srch_inf.ntwrk_buf_start;
	if (buf) {
895
		cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
896 897 898 899 900
		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 已提交
901
	}
902 903 904 905

	cifs_put_tlink(cfile->tlink);
	kfree(file->private_data);
	file->private_data = NULL;
L
Linus Torvalds 已提交
906
	/* BB can we lock the filestruct while this is going on? */
907
	free_xid(xid);
L
Linus Torvalds 已提交
908 909 910
	return rc;
}

911
static struct cifsLockInfo *
912
cifs_lock_init(__u64 offset, __u64 length, __u8 type)
J
[CIFS]  
Jeremy Allison 已提交
913
{
914
	struct cifsLockInfo *lock =
S
Steve French 已提交
915
		kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
916 917 918 919 920 921 922 923 924
	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;
925 926
}

927
void
928 929 930 931 932 933 934 935 936
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);
	}
}

937 938 939 940 941
#define CIFS_LOCK_OP	0
#define CIFS_READ_OP	1
#define CIFS_WRITE_OP	2

/* @rw_check : 0 - no op, 1 - read, 2 - write */
942
static bool
943 944
cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
			    __u64 length, __u8 type, struct cifsFileInfo *cfile,
945
			    struct cifsLockInfo **conf_lock, int rw_check)
946
{
947
	struct cifsLockInfo *li;
948
	struct cifsFileInfo *cur_cfile = fdlocks->cfile;
949
	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
950

951
	list_for_each_entry(li, &fdlocks->locks, llist) {
952 953 954
		if (offset + length <= li->offset ||
		    offset >= li->offset + li->length)
			continue;
955 956 957 958 959 960 961
		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;
		}
962 963 964
		if ((type & server->vals->shared_lock_type) &&
		    ((server->ops->compare_fids(cfile, cur_cfile) &&
		     current->tgid == li->pid) || type == li->type))
965
			continue;
966 967
		if (conf_lock)
			*conf_lock = li;
968
		return true;
969 970 971 972
	}
	return false;
}

973
bool
974
cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
975
			__u8 type, struct cifsLockInfo **conf_lock,
976
			int rw_check)
977
{
978
	bool rc = false;
979
	struct cifs_fid_locks *cur;
980
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
981

982 983
	list_for_each_entry(cur, &cinode->llist, llist) {
		rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
984
						 cfile, conf_lock, rw_check);
985 986 987 988 989
		if (rc)
			break;
	}

	return rc;
990 991
}

992 993 994 995 996 997 998
/*
 * 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.
 */
999
static int
1000 1001
cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
	       __u8 type, struct file_lock *flock)
1002 1003 1004
{
	int rc = 0;
	struct cifsLockInfo *conf_lock;
1005
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1006
	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1007 1008
	bool exist;

1009
	down_read(&cinode->lock_sem);
1010

1011
	exist = cifs_find_lock_conflict(cfile, offset, length, type,
1012
					&conf_lock, CIFS_LOCK_OP);
1013 1014 1015 1016
	if (exist) {
		flock->fl_start = conf_lock->offset;
		flock->fl_end = conf_lock->offset + conf_lock->length - 1;
		flock->fl_pid = conf_lock->pid;
1017
		if (conf_lock->type & server->vals->shared_lock_type)
1018 1019 1020 1021 1022 1023 1024 1025
			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;

1026
	up_read(&cinode->lock_sem);
1027 1028 1029
	return rc;
}

1030
static void
1031
cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
1032
{
1033
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1034
	cifs_down_write(&cinode->lock_sem);
1035
	list_add_tail(&lock->llist, &cfile->llist->locks);
1036
	up_write(&cinode->lock_sem);
J
[CIFS]  
Jeremy Allison 已提交
1037 1038
}

1039 1040 1041 1042 1043 1044
/*
 * 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.
 */
1045
static int
1046
cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
1047
		 bool wait)
1048
{
1049
	struct cifsLockInfo *conf_lock;
1050
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1051 1052 1053 1054 1055
	bool exist;
	int rc = 0;

try_again:
	exist = false;
1056
	cifs_down_write(&cinode->lock_sem);
1057

1058
	exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
1059
					lock->type, &conf_lock, CIFS_LOCK_OP);
1060
	if (!exist && cinode->can_cache_brlcks) {
1061
		list_add_tail(&lock->llist, &cfile->llist->locks);
1062
		up_write(&cinode->lock_sem);
1063 1064 1065 1066 1067 1068 1069 1070 1071
		return rc;
	}

	if (!exist)
		rc = 1;
	else if (!wait)
		rc = -EACCES;
	else {
		list_add_tail(&lock->blist, &conf_lock->blist);
1072
		up_write(&cinode->lock_sem);
1073 1074 1075 1076 1077
		rc = wait_event_interruptible(lock->block_q,
					(lock->blist.prev == &lock->blist) &&
					(lock->blist.next == &lock->blist));
		if (!rc)
			goto try_again;
1078
		cifs_down_write(&cinode->lock_sem);
1079
		list_del_init(&lock->blist);
1080 1081
	}

1082
	up_write(&cinode->lock_sem);
1083 1084 1085
	return rc;
}

1086 1087 1088 1089 1090 1091 1092
/*
 * 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.
 */
1093
static int
1094 1095 1096
cifs_posix_lock_test(struct file *file, struct file_lock *flock)
{
	int rc = 0;
A
Al Viro 已提交
1097
	struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1098 1099
	unsigned char saved_type = flock->fl_type;

1100 1101 1102
	if ((flock->fl_flags & FL_POSIX) == 0)
		return 1;

1103
	down_read(&cinode->lock_sem);
1104 1105 1106 1107 1108 1109 1110
	posix_test_lock(file, flock);

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

1111
	up_read(&cinode->lock_sem);
1112 1113 1114
	return rc;
}

1115 1116 1117 1118 1119 1120
/*
 * 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.
 */
1121 1122 1123
static int
cifs_posix_lock_set(struct file *file, struct file_lock *flock)
{
A
Al Viro 已提交
1124
	struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1125 1126 1127 1128
	int rc = 1;

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

1130
try_again:
1131
	cifs_down_write(&cinode->lock_sem);
1132
	if (!cinode->can_cache_brlcks) {
1133
		up_write(&cinode->lock_sem);
1134
		return rc;
1135
	}
1136 1137

	rc = posix_lock_file(file, flock, NULL);
1138
	up_write(&cinode->lock_sem);
1139 1140 1141 1142
	if (rc == FILE_LOCK_DEFERRED) {
		rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
		if (!rc)
			goto try_again;
1143
		posix_unblock_lock(flock);
1144
	}
1145
	return rc;
1146 1147
}

1148
int
1149
cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1150
{
1151 1152
	unsigned int xid;
	int rc = 0, stored_rc;
1153 1154
	struct cifsLockInfo *li, *tmp;
	struct cifs_tcon *tcon;
1155
	unsigned int num, max_num, max_buf;
1156
	LOCKING_ANDX_RANGE *buf, *cur;
1157 1158 1159 1160
	static const int types[] = {
		LOCKING_ANDX_LARGE_FILES,
		LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
	};
1161
	int i;
1162

1163
	xid = get_xid();
1164 1165
	tcon = tlink_tcon(cfile->tlink);

1166 1167
	/*
	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1168
	 * and check it before using.
1169 1170
	 */
	max_buf = tcon->ses->server->maxBuf;
1171
	if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) {
1172
		free_xid(xid);
1173 1174 1175
		return -EINVAL;
	}

1176 1177 1178 1179
	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);
1180 1181
	max_num = (max_buf - sizeof(struct smb_hdr)) /
						sizeof(LOCKING_ANDX_RANGE);
1182
	buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1183
	if (!buf) {
1184
		free_xid(xid);
1185
		return -ENOMEM;
1186 1187 1188 1189 1190
	}

	for (i = 0; i < 2; i++) {
		cur = buf;
		num = 0;
1191
		list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1192 1193 1194 1195 1196 1197 1198 1199
			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) {
1200 1201
				stored_rc = cifs_lockv(xid, tcon,
						       cfile->fid.netfid,
1202 1203
						       (__u8)li->type, 0, num,
						       buf);
1204 1205 1206 1207 1208 1209 1210 1211 1212
				if (stored_rc)
					rc = stored_rc;
				cur = buf;
				num = 0;
			} else
				cur++;
		}

		if (num) {
1213
			stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1214
					       (__u8)types[i], 0, num, buf);
1215 1216 1217
			if (stored_rc)
				rc = stored_rc;
		}
1218 1219
	}

1220
	kfree(buf);
1221
	free_xid(xid);
1222 1223 1224
	return rc;
}

1225 1226 1227 1228 1229 1230
static __u32
hash_lockowner(fl_owner_t owner)
{
	return cifs_lock_secret ^ hash32_ptr((const void *)owner);
}

1231 1232 1233 1234 1235 1236 1237 1238 1239
struct lock_to_push {
	struct list_head llist;
	__u64 offset;
	__u64 length;
	__u32 pid;
	__u16 netfid;
	__u8 type;
};

1240
static int
1241
cifs_push_posix_locks(struct cifsFileInfo *cfile)
1242
{
1243
	struct inode *inode = d_inode(cfile->dentry);
1244
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1245 1246
	struct file_lock *flock;
	struct file_lock_context *flctx = inode->i_flctx;
1247
	unsigned int count = 0, i;
1248
	int rc = 0, xid, type;
1249 1250
	struct list_head locks_to_send, *el;
	struct lock_to_push *lck, *tmp;
1251 1252
	__u64 length;

1253
	xid = get_xid();
1254

1255 1256
	if (!flctx)
		goto out;
1257

1258 1259 1260 1261 1262 1263
	spin_lock(&flctx->flc_lock);
	list_for_each(el, &flctx->flc_posix) {
		count++;
	}
	spin_unlock(&flctx->flc_lock);

1264 1265
	INIT_LIST_HEAD(&locks_to_send);

1266
	/*
1267 1268
	 * Allocating count locks is enough because no FL_POSIX locks can be
	 * added to the list while we are holding cinode->lock_sem that
1269
	 * protects locking operations of this inode.
1270
	 */
1271
	for (i = 0; i < count; i++) {
1272 1273 1274 1275 1276 1277 1278 1279 1280
		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;
1281
	spin_lock(&flctx->flc_lock);
1282
	list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
1283
		if (el == &locks_to_send) {
1284 1285 1286 1287
			/*
			 * The list ended. We don't have enough allocated
			 * structures - something is really wrong.
			 */
1288
			cifs_dbg(VFS, "Can't push all brlocks!\n");
1289 1290
			break;
		}
1291 1292 1293 1294 1295
		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;
1296
		lck = list_entry(el, struct lock_to_push, llist);
1297
		lck->pid = hash_lockowner(flock->fl_owner);
1298
		lck->netfid = cfile->fid.netfid;
1299 1300 1301
		lck->length = length;
		lck->type = type;
		lck->offset = flock->fl_start;
1302
	}
1303
	spin_unlock(&flctx->flc_lock);
1304 1305 1306 1307 1308

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

		stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1309
					     lck->offset, lck->length, NULL,
1310 1311 1312 1313 1314 1315 1316
					     lck->type, 0);
		if (stored_rc)
			rc = stored_rc;
		list_del(&lck->llist);
		kfree(lck);
	}

1317
out:
1318
	free_xid(xid);
1319
	return rc;
1320 1321 1322 1323 1324 1325
err_out:
	list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
		list_del(&lck->llist);
		kfree(lck);
	}
	goto out;
1326 1327
}

1328
static int
1329
cifs_push_locks(struct cifsFileInfo *cfile)
1330
{
1331
	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1332
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1333
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1334 1335 1336
	int rc = 0;

	/* we are going to update can_cache_brlcks here - need a write access */
1337
	cifs_down_write(&cinode->lock_sem);
1338 1339 1340 1341
	if (!cinode->can_cache_brlcks) {
		up_write(&cinode->lock_sem);
		return rc;
	}
1342

1343
	if (cap_unix(tcon->ses) &&
1344 1345
	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1346 1347 1348
		rc = cifs_push_posix_locks(cfile);
	else
		rc = tcon->ses->server->ops->push_mand_locks(cfile);
1349

1350 1351 1352
	cinode->can_cache_brlcks = false;
	up_write(&cinode->lock_sem);
	return rc;
1353 1354
}

1355
static void
1356
cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1357
		bool *wait_flag, struct TCP_Server_Info *server)
L
Linus Torvalds 已提交
1358
{
1359
	if (flock->fl_flags & FL_POSIX)
1360
		cifs_dbg(FYI, "Posix\n");
1361
	if (flock->fl_flags & FL_FLOCK)
1362
		cifs_dbg(FYI, "Flock\n");
1363
	if (flock->fl_flags & FL_SLEEP) {
1364
		cifs_dbg(FYI, "Blocking lock\n");
1365
		*wait_flag = true;
L
Linus Torvalds 已提交
1366
	}
1367
	if (flock->fl_flags & FL_ACCESS)
1368
		cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1369
	if (flock->fl_flags & FL_LEASE)
1370
		cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1371
	if (flock->fl_flags &
1372 1373
	    (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
	       FL_ACCESS | FL_LEASE | FL_CLOSE)))
1374
		cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
L
Linus Torvalds 已提交
1375

1376
	*type = server->vals->large_lock_type;
1377
	if (flock->fl_type == F_WRLCK) {
1378
		cifs_dbg(FYI, "F_WRLCK\n");
1379
		*type |= server->vals->exclusive_lock_type;
1380 1381
		*lock = 1;
	} else if (flock->fl_type == F_UNLCK) {
1382
		cifs_dbg(FYI, "F_UNLCK\n");
1383
		*type |= server->vals->unlock_lock_type;
1384 1385 1386
		*unlock = 1;
		/* Check if unlock includes more than one lock range */
	} else if (flock->fl_type == F_RDLCK) {
1387
		cifs_dbg(FYI, "F_RDLCK\n");
1388
		*type |= server->vals->shared_lock_type;
1389 1390
		*lock = 1;
	} else if (flock->fl_type == F_EXLCK) {
1391
		cifs_dbg(FYI, "F_EXLCK\n");
1392
		*type |= server->vals->exclusive_lock_type;
1393 1394
		*lock = 1;
	} else if (flock->fl_type == F_SHLCK) {
1395
		cifs_dbg(FYI, "F_SHLCK\n");
1396
		*type |= server->vals->shared_lock_type;
1397
		*lock = 1;
L
Linus Torvalds 已提交
1398
	} else
1399
		cifs_dbg(FYI, "Unknown type of lock\n");
1400
}
L
Linus Torvalds 已提交
1401

1402
static int
1403
cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1404
	   bool wait_flag, bool posix_lck, unsigned int xid)
1405 1406 1407
{
	int rc = 0;
	__u64 length = 1 + flock->fl_end - flock->fl_start;
1408 1409
	struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1410
	struct TCP_Server_Info *server = tcon->ses->server;
1411
	__u16 netfid = cfile->fid.netfid;
1412

1413 1414
	if (posix_lck) {
		int posix_lock_type;
1415 1416 1417 1418 1419

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

1420
		if (type & server->vals->shared_lock_type)
1421 1422 1423
			posix_lock_type = CIFS_RDLCK;
		else
			posix_lock_type = CIFS_WRLCK;
1424 1425
		rc = CIFSSMBPosixLock(xid, tcon, netfid,
				      hash_lockowner(flock->fl_owner),
1426
				      flock->fl_start, length, flock,
1427
				      posix_lock_type, wait_flag);
1428 1429
		return rc;
	}
L
Linus Torvalds 已提交
1430

1431
	rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1432 1433 1434
	if (!rc)
		return rc;

1435
	/* BB we could chain these into one lock request BB */
1436 1437
	rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
				    1, 0, false);
1438
	if (rc == 0) {
1439 1440
		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
					    type, 0, 1, false);
1441 1442
		flock->fl_type = F_UNLCK;
		if (rc != 0)
1443 1444
			cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
				 rc);
1445
		return 0;
L
Linus Torvalds 已提交
1446
	}
J
[CIFS]  
Jeremy Allison 已提交
1447

1448
	if (type & server->vals->shared_lock_type) {
1449
		flock->fl_type = F_WRLCK;
1450
		return 0;
J
[CIFS]  
Jeremy Allison 已提交
1451 1452
	}

1453 1454 1455 1456 1457
	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);
1458
	if (rc == 0) {
1459 1460
		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
			type | server->vals->shared_lock_type, 0, 1, false);
1461 1462
		flock->fl_type = F_RDLCK;
		if (rc != 0)
1463 1464
			cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
				 rc);
1465 1466 1467
	} else
		flock->fl_type = F_WRLCK;

1468
	return 0;
1469 1470
}

1471
void
1472 1473 1474 1475 1476 1477 1478
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);
}

1479
void
1480 1481 1482 1483 1484 1485 1486 1487 1488 1489
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);
	}
}

1490
int
1491 1492
cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
		  unsigned int xid)
1493 1494
{
	int rc = 0, stored_rc;
1495 1496 1497 1498
	static const int types[] = {
		LOCKING_ANDX_LARGE_FILES,
		LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
	};
1499
	unsigned int i;
1500
	unsigned int max_num, num, max_buf;
1501 1502
	LOCKING_ANDX_RANGE *buf, *cur;
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1503
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1504 1505 1506 1507 1508 1509
	struct cifsLockInfo *li, *tmp;
	__u64 length = 1 + flock->fl_end - flock->fl_start;
	struct list_head tmp_llist;

	INIT_LIST_HEAD(&tmp_llist);

1510 1511
	/*
	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1512
	 * and check it before using.
1513 1514
	 */
	max_buf = tcon->ses->server->maxBuf;
1515
	if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE)))
1516 1517
		return -EINVAL;

1518 1519 1520 1521
	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);
1522 1523
	max_num = (max_buf - sizeof(struct smb_hdr)) /
						sizeof(LOCKING_ANDX_RANGE);
1524
	buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1525 1526 1527
	if (!buf)
		return -ENOMEM;

1528
	cifs_down_write(&cinode->lock_sem);
1529 1530 1531
	for (i = 0; i < 2; i++) {
		cur = buf;
		num = 0;
1532
		list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1533 1534 1535 1536 1537 1538 1539 1540
			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;
1541
			if (cinode->can_cache_brlcks) {
1542 1543
				/*
				 * We can cache brlock requests - simply remove
1544
				 * a lock from the file's list.
1545 1546 1547 1548
				 */
				list_del(&li->llist);
				cifs_del_lock_waiters(li);
				kfree(li);
1549
				continue;
1550
			}
1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562
			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) {
1563 1564
				stored_rc = cifs_lockv(xid, tcon,
						       cfile->fid.netfid,
1565 1566 1567 1568 1569 1570 1571 1572
						       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,
1573
							&cfile->llist->locks);
1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584
					rc = stored_rc;
				} else
					/*
					 * The unlock range request succeed -
					 * free the tmp list.
					 */
					cifs_free_llist(&tmp_llist);
				cur = buf;
				num = 0;
			} else
				cur++;
1585 1586
		}
		if (num) {
1587
			stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1588 1589
					       types[i], num, 0, buf);
			if (stored_rc) {
1590 1591
				cifs_move_llist(&tmp_llist,
						&cfile->llist->locks);
1592 1593 1594 1595 1596 1597
				rc = stored_rc;
			} else
				cifs_free_llist(&tmp_llist);
		}
	}

1598
	up_write(&cinode->lock_sem);
1599 1600 1601 1602
	kfree(buf);
	return rc;
}

1603
static int
1604
cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1605 1606
	   bool wait_flag, bool posix_lck, int lock, int unlock,
	   unsigned int xid)
1607 1608 1609 1610 1611
{
	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);
1612
	struct TCP_Server_Info *server = tcon->ses->server;
1613
	struct inode *inode = d_inode(cfile->dentry);
1614 1615

	if (posix_lck) {
1616
		int posix_lock_type;
1617 1618 1619 1620 1621

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

1622
		if (type & server->vals->shared_lock_type)
1623 1624 1625
			posix_lock_type = CIFS_RDLCK;
		else
			posix_lock_type = CIFS_WRLCK;
1626

1627
		if (unlock == 1)
1628
			posix_lock_type = CIFS_UNLCK;
J
[CIFS]  
Jeremy Allison 已提交
1629

1630
		rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1631 1632
				      hash_lockowner(flock->fl_owner),
				      flock->fl_start, length,
1633
				      NULL, posix_lock_type, wait_flag);
1634 1635
		goto out;
	}
J
[CIFS]  
Jeremy Allison 已提交
1636

1637
	if (lock) {
1638 1639
		struct cifsLockInfo *lock;

1640
		lock = cifs_lock_init(flock->fl_start, length, type);
1641 1642 1643
		if (!lock)
			return -ENOMEM;

1644
		rc = cifs_lock_add_if(cfile, lock, wait_flag);
1645
		if (rc < 0) {
1646
			kfree(lock);
1647 1648 1649
			return rc;
		}
		if (!rc)
1650 1651
			goto out;

1652 1653 1654 1655 1656 1657 1658
		/*
		 * 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.
		 */
1659 1660
		if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
					CIFS_CACHE_READ(CIFS_I(inode))) {
1661
			cifs_zap_mapping(inode);
1662 1663
			cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
				 inode);
1664
			CIFS_I(inode)->oplock = 0;
1665 1666
		}

1667 1668
		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
					    type, 1, 0, wait_flag);
1669 1670
		if (rc) {
			kfree(lock);
1671
			return rc;
1672
		}
1673

1674
		cifs_lock_add(cfile, lock);
1675
	} else if (unlock)
1676
		rc = server->ops->mand_unlock_range(cfile, flock, xid);
1677 1678

out:
1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690
	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;
		}
1691
		rc = locks_lock_file_wait(file, flock);
1692
	}
1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706
	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;
1707
	__u32 type;
1708 1709

	rc = -EACCES;
1710
	xid = get_xid();
1711

1712 1713 1714
	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);
1715 1716 1717

	cfile = (struct cifsFileInfo *)file->private_data;
	tcon = tlink_tcon(cfile->tlink);
1718 1719 1720 1721

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

1722
	cifs_sb = CIFS_FILE_SB(file);
1723
	netfid = cfile->fid.netfid;
A
Al Viro 已提交
1724
	cinode = CIFS_I(file_inode(file));
1725

1726
	if (cap_unix(tcon->ses) &&
1727 1728 1729 1730 1731 1732 1733 1734
	    (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)) {
1735
		rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1736
		free_xid(xid);
1737 1738 1739 1740 1741 1742 1743 1744
		return rc;
	}

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

1749 1750
	rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
			xid);
1751
	free_xid(xid);
L
Linus Torvalds 已提交
1752 1753 1754
	return rc;
}

1755 1756 1757 1758
/*
 * update the file size (if needed) after a write. Should be called with
 * the inode->i_lock held
 */
1759
void
1760 1761 1762 1763 1764 1765 1766 1767 1768
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;
}

1769 1770 1771
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 已提交
1772 1773 1774 1775 1776
{
	int rc = 0;
	unsigned int bytes_written = 0;
	unsigned int total_written;
	struct cifs_sb_info *cifs_sb;
1777 1778
	struct cifs_tcon *tcon;
	struct TCP_Server_Info *server;
1779
	unsigned int xid;
1780
	struct dentry *dentry = open_file->dentry;
1781
	struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
1782
	struct cifs_io_parms io_parms;
L
Linus Torvalds 已提交
1783

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

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

1789 1790 1791 1792 1793
	tcon = tlink_tcon(open_file->tlink);
	server = tcon->ses->server;

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

1795
	xid = get_xid();
L
Linus Torvalds 已提交
1796 1797 1798 1799 1800

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

L
Linus Torvalds 已提交
1804 1805 1806
			if (open_file->invalidHandle) {
				/* we could deadlock if we called
				   filemap_fdatawait from here so tell
S
Steve French 已提交
1807
				   reopen_file not to flush data to
L
Linus Torvalds 已提交
1808
				   server now */
J
Jeff Layton 已提交
1809
				rc = cifs_reopen_file(open_file, false);
L
Linus Torvalds 已提交
1810 1811 1812
				if (rc != 0)
					break;
			}
1813

1814
			len = min(server->ops->wp_retry_size(d_inode(dentry)),
1815
				  (unsigned int)write_size - total_written);
1816 1817 1818
			/* iov[0] is reserved for smb header */
			iov[1].iov_base = (char *)write_data + total_written;
			iov[1].iov_len = len;
1819
			io_parms.pid = pid;
1820 1821
			io_parms.tcon = tcon;
			io_parms.offset = *offset;
1822
			io_parms.length = len;
1823 1824
			rc = server->ops->sync_write(xid, &open_file->fid,
					&io_parms, &bytes_written, iov, 1);
L
Linus Torvalds 已提交
1825 1826 1827 1828 1829
		}
		if (rc || (bytes_written == 0)) {
			if (total_written)
				break;
			else {
1830
				free_xid(xid);
L
Linus Torvalds 已提交
1831 1832
				return rc;
			}
1833
		} else {
1834
			spin_lock(&d_inode(dentry)->i_lock);
1835
			cifs_update_eof(cifsi, *offset, bytes_written);
1836
			spin_unlock(&d_inode(dentry)->i_lock);
1837
			*offset += bytes_written;
1838
		}
L
Linus Torvalds 已提交
1839 1840
	}

1841
	cifs_stats_bytes_written(tcon, total_written);
L
Linus Torvalds 已提交
1842

1843
	if (total_written > 0) {
1844 1845 1846 1847
		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 已提交
1848
	}
1849
	mark_inode_dirty_sync(d_inode(dentry));
1850
	free_xid(xid);
L
Linus Torvalds 已提交
1851 1852 1853
	return total_written;
}

1854 1855
struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
					bool fsuid_only)
S
Steve French 已提交
1856 1857
{
	struct cifsFileInfo *open_file = NULL;
1858 1859 1860 1861 1862
	struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);

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

1864
	spin_lock(&cifs_inode->open_file_lock);
S
Steve French 已提交
1865 1866 1867 1868
	/* 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) {
1869
		if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1870
			continue;
1871
		if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
S
Steve French 已提交
1872 1873 1874
			if (!open_file->invalidHandle) {
				/* found a good file */
				/* lock it so it will not be closed on us */
1875
				cifsFileInfo_get(open_file);
1876
				spin_unlock(&cifs_inode->open_file_lock);
S
Steve French 已提交
1877 1878 1879 1880 1881 1882 1883
				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 */
	}
1884
	spin_unlock(&cifs_inode->open_file_lock);
S
Steve French 已提交
1885 1886 1887
	return NULL;
}

1888 1889
struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
					bool fsuid_only)
1890
{
1891
	struct cifsFileInfo *open_file, *inv_file = NULL;
1892
	struct cifs_sb_info *cifs_sb;
1893
	bool any_available = false;
1894
	int rc;
1895
	unsigned int refind = 0;
1896

1897 1898 1899 1900
	/* 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 已提交
1901
	if (cifs_inode == NULL) {
1902
		cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1903 1904 1905 1906
		dump_stack();
		return NULL;
	}

1907 1908
	cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);

1909 1910 1911 1912
	/* only filter by fsuid on multiuser mounts */
	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
		fsuid_only = false;

1913
	spin_lock(&cifs_inode->open_file_lock);
1914
refind_writable:
1915
	if (refind > MAX_REOPEN_ATT) {
1916
		spin_unlock(&cifs_inode->open_file_lock);
1917 1918
		return NULL;
	}
1919
	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1920 1921
		if (!any_available && open_file->pid != current->tgid)
			continue;
1922
		if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1923
			continue;
1924
		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1925 1926
			if (!open_file->invalidHandle) {
				/* found a good writable file */
1927
				cifsFileInfo_get(open_file);
1928
				spin_unlock(&cifs_inode->open_file_lock);
1929
				return open_file;
1930 1931 1932
			} else {
				if (!inv_file)
					inv_file = open_file;
1933
			}
1934 1935
		}
	}
1936 1937 1938 1939 1940
	/* couldn't find useable FH with same pid, try any available */
	if (!any_available) {
		any_available = true;
		goto refind_writable;
	}
1941 1942 1943

	if (inv_file) {
		any_available = false;
1944
		cifsFileInfo_get(inv_file);
1945 1946
	}

1947
	spin_unlock(&cifs_inode->open_file_lock);
1948 1949 1950 1951 1952 1953

	if (inv_file) {
		rc = cifs_reopen_file(inv_file, false);
		if (!rc)
			return inv_file;
		else {
1954
			spin_lock(&cifs_inode->open_file_lock);
1955 1956
			list_move_tail(&inv_file->flist,
					&cifs_inode->openFileList);
1957
			spin_unlock(&cifs_inode->open_file_lock);
1958 1959
			cifsFileInfo_put(inv_file);
			++refind;
1960
			inv_file = NULL;
1961
			spin_lock(&cifs_inode->open_file_lock);
1962 1963 1964 1965
			goto refind_writable;
		}
	}

1966 1967 1968
	return NULL;
}

L
Linus Torvalds 已提交
1969 1970 1971
static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
{
	struct address_space *mapping = page->mapping;
1972
	loff_t offset = (loff_t)page->index << PAGE_SHIFT;
L
Linus Torvalds 已提交
1973 1974 1975 1976
	char *write_data;
	int rc = -EFAULT;
	int bytes_written = 0;
	struct inode *inode;
1977
	struct cifsFileInfo *open_file;
L
Linus Torvalds 已提交
1978 1979 1980 1981 1982 1983 1984 1985 1986 1987

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

	inode = page->mapping->host;

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

1988
	if ((to > PAGE_SIZE) || (from > to)) {
L
Linus Torvalds 已提交
1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000
		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 已提交
2001
		to = (unsigned)(mapping->host->i_size - offset);
L
Linus Torvalds 已提交
2002

2003
	open_file = find_writable_file(CIFS_I(mapping->host), false);
2004
	if (open_file) {
2005 2006
		bytes_written = cifs_write(open_file, open_file->pid,
					   write_data, to - from, &offset);
2007
		cifsFileInfo_put(open_file);
L
Linus Torvalds 已提交
2008
		/* Does mm or vfs already set times? */
2009
		inode->i_atime = inode->i_mtime = current_time(inode);
2010
		if ((bytes_written > 0) && (offset))
2011
			rc = 0;
2012 2013
		else if (bytes_written < 0)
			rc = bytes_written;
2014
	} else {
2015
		cifs_dbg(FYI, "No writeable filehandles for inode\n");
L
Linus Torvalds 已提交
2016 2017 2018 2019 2020 2021 2022
		rc = -EIO;
	}

	kunmap(page);
	return rc;
}

2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034
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 已提交
2035 2036
	*found_pages = find_get_pages_range_tag(mapping, index, end,
				PAGECACHE_TAG_DIRTY, tofind, wdata->pages);
2037 2038 2039
	return wdata;
}

2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051
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 已提交
2052 2053 2054 2055
		 * 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
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 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111
		 */

		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++) {
2112
		put_page(wdata->pages[i]);
2113 2114 2115 2116 2117 2118
		wdata->pages[i] = NULL;
	}

	return nr_pages;
}

2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129
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]);
2130
	wdata->pagesz = PAGE_SIZE;
2131 2132
	wdata->tailsz = min(i_size_read(mapping->host) -
			page_offset(wdata->pages[nr_pages - 1]),
2133 2134
			(loff_t)PAGE_SIZE);
	wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2135

2136 2137 2138 2139 2140 2141 2142
	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 {
2143 2144 2145
		wdata->pid = wdata->cfile->pid;
		server = tlink_tcon(wdata->cfile->tlink)->ses->server;
		rc = server->ops->async_writev(wdata, cifs_writedata_release);
2146
	}
2147 2148 2149 2150 2151 2152 2153

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

	return rc;
}

L
Linus Torvalds 已提交
2154
static int cifs_writepages(struct address_space *mapping,
2155
			   struct writeback_control *wbc)
L
Linus Torvalds 已提交
2156
{
2157
	struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
2158
	struct TCP_Server_Info *server;
2159 2160 2161
	bool done = false, scanned = false, range_whole = false;
	pgoff_t end, index;
	struct cifs_writedata *wdata;
2162
	int rc = 0;
2163
	int saved_rc = 0;
2164

2165
	/*
2166
	 * If wsize is smaller than the page cache size, default to writing
2167 2168
	 * one page at a time via cifs_writepage
	 */
2169
	if (cifs_sb->wsize < PAGE_SIZE)
2170 2171
		return generic_writepages(mapping, wbc);

2172
	if (wbc->range_cyclic) {
2173
		index = mapping->writeback_index; /* Start from prev offset */
2174 2175
		end = -1;
	} else {
2176 2177
		index = wbc->range_start >> PAGE_SHIFT;
		end = wbc->range_end >> PAGE_SHIFT;
2178
		if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2179 2180
			range_whole = true;
		scanned = true;
2181
	}
2182
	server = cifs_sb_master_tcon(cifs_sb)->ses->server;
2183
retry:
2184
	while (!done && index <= end) {
2185
		unsigned int i, nr_pages, found_pages, wsize, credits;
2186
		pgoff_t next = 0, tofind, saved_index = index;
2187

2188 2189
		rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
						   &wsize, &credits);
2190 2191
		if (rc != 0) {
			done = true;
2192
			break;
2193
		}
2194

2195
		tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2196

2197 2198
		wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
						  &found_pages);
2199 2200
		if (!wdata) {
			rc = -ENOMEM;
2201
			done = true;
2202
			add_credits_and_wake_if(server, credits, 0);
2203 2204 2205 2206 2207
			break;
		}

		if (found_pages == 0) {
			kref_put(&wdata->refcount, cifs_writedata_release);
2208
			add_credits_and_wake_if(server, credits, 0);
2209 2210 2211
			break;
		}

2212 2213
		nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
					       end, &index, &next, &done);
2214

2215 2216 2217
		/* nothing to write? */
		if (nr_pages == 0) {
			kref_put(&wdata->refcount, cifs_writedata_release);
2218
			add_credits_and_wake_if(server, credits, 0);
2219
			continue;
2220
		}
2221

2222
		wdata->credits = credits;
2223

2224
		rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2225

2226 2227
		/* send failure -- clean up the mess */
		if (rc != 0) {
2228
			add_credits_and_wake_if(server, wdata->credits, 0);
2229
			for (i = 0; i < nr_pages; ++i) {
2230
				if (is_retryable_error(rc))
2231 2232 2233 2234 2235
					redirty_page_for_writepage(wbc,
							   wdata->pages[i]);
				else
					SetPageError(wdata->pages[i]);
				end_page_writeback(wdata->pages[i]);
2236
				put_page(wdata->pages[i]);
2237
			}
2238
			if (!is_retryable_error(rc))
2239
				mapping_set_error(mapping, rc);
2240 2241
		}
		kref_put(&wdata->refcount, cifs_writedata_release);
2242

2243 2244 2245 2246 2247
		if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
			index = saved_index;
			continue;
		}

2248 2249 2250 2251 2252 2253 2254 2255 2256
		/* 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;

2257 2258 2259
		wbc->nr_to_write -= nr_pages;
		if (wbc->nr_to_write <= 0)
			done = true;
2260

2261
		index = next;
2262
	}
2263

2264 2265 2266 2267 2268
	if (!scanned && !done) {
		/*
		 * We hit the last page and there is more work to be done: wrap
		 * back to the start of the file
		 */
2269
		scanned = true;
2270 2271 2272
		index = 0;
		goto retry;
	}
2273

2274 2275 2276
	if (saved_rc != 0)
		rc = saved_rc;

2277
	if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2278 2279
		mapping->writeback_index = index;

L
Linus Torvalds 已提交
2280 2281 2282
	return rc;
}

2283 2284
static int
cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
L
Linus Torvalds 已提交
2285
{
2286
	int rc;
2287
	unsigned int xid;
L
Linus Torvalds 已提交
2288

2289
	xid = get_xid();
L
Linus Torvalds 已提交
2290
/* BB add check for wbc flags */
2291
	get_page(page);
S
Steve French 已提交
2292
	if (!PageUptodate(page))
2293
		cifs_dbg(FYI, "ppw - page not up to date\n");
2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304

	/*
	 * 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 已提交
2305
	set_page_writeback(page);
2306
retry_write:
2307
	rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2308 2309
	if (is_retryable_error(rc)) {
		if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN)
2310
			goto retry_write;
2311
		redirty_page_for_writepage(wbc, page);
2312
	} else if (rc != 0) {
2313
		SetPageError(page);
2314 2315
		mapping_set_error(page->mapping, rc);
	} else {
2316
		SetPageUptodate(page);
2317
	}
2318
	end_page_writeback(page);
2319
	put_page(page);
2320
	free_xid(xid);
L
Linus Torvalds 已提交
2321 2322 2323
	return rc;
}

2324 2325 2326 2327 2328 2329 2330
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 已提交
2331 2332 2333
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 已提交
2334
{
N
Nick Piggin 已提交
2335 2336
	int rc;
	struct inode *inode = mapping->host;
2337 2338 2339 2340 2341 2342 2343 2344
	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 已提交
2345

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

2349 2350 2351 2352
	if (PageChecked(page)) {
		if (copied == len)
			SetPageUptodate(page);
		ClearPageChecked(page);
2353
	} else if (!PageUptodate(page) && copied == PAGE_SIZE)
N
Nick Piggin 已提交
2354
		SetPageUptodate(page);
S
Steve French 已提交
2355

L
Linus Torvalds 已提交
2356
	if (!PageUptodate(page)) {
N
Nick Piggin 已提交
2357
		char *page_data;
2358
		unsigned offset = pos & (PAGE_SIZE - 1);
2359
		unsigned int xid;
N
Nick Piggin 已提交
2360

2361
		xid = get_xid();
L
Linus Torvalds 已提交
2362 2363 2364 2365 2366 2367
		/* 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);
2368
		rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
N
Nick Piggin 已提交
2369
		/* if (rc < 0) should we set writebehind rc? */
L
Linus Torvalds 已提交
2370
		kunmap(page);
N
Nick Piggin 已提交
2371

2372
		free_xid(xid);
S
Steve French 已提交
2373
	} else {
N
Nick Piggin 已提交
2374 2375
		rc = copied;
		pos += copied;
2376
		set_page_dirty(page);
L
Linus Torvalds 已提交
2377 2378
	}

N
Nick Piggin 已提交
2379 2380 2381 2382 2383 2384 2385 2386
	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);
2387
	put_page(page);
N
Nick Piggin 已提交
2388

L
Linus Torvalds 已提交
2389 2390 2391
	return rc;
}

2392 2393
int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
		      int datasync)
L
Linus Torvalds 已提交
2394
{
2395
	unsigned int xid;
L
Linus Torvalds 已提交
2396
	int rc = 0;
2397
	struct cifs_tcon *tcon;
2398
	struct TCP_Server_Info *server;
2399
	struct cifsFileInfo *smbfile = file->private_data;
A
Al Viro 已提交
2400
	struct inode *inode = file_inode(file);
2401
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
L
Linus Torvalds 已提交
2402

2403
	rc = file_write_and_wait_range(file, start, end);
2404 2405
	if (rc)
		return rc;
A
Al Viro 已提交
2406
	inode_lock(inode);
2407

2408
	xid = get_xid();
L
Linus Torvalds 已提交
2409

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

2413
	if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2414
		rc = cifs_zap_mapping(inode);
2415
		if (rc) {
2416
			cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2417 2418 2419
			rc = 0; /* don't care about it in fsync */
		}
	}
2420

2421
	tcon = tlink_tcon(smbfile->tlink);
2422 2423 2424 2425 2426 2427 2428
	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;
	}
2429

2430
	free_xid(xid);
A
Al Viro 已提交
2431
	inode_unlock(inode);
2432 2433 2434
	return rc;
}

2435
int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2436
{
2437
	unsigned int xid;
2438
	int rc = 0;
2439
	struct cifs_tcon *tcon;
2440
	struct TCP_Server_Info *server;
2441
	struct cifsFileInfo *smbfile = file->private_data;
2442
	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2443 2444
	struct inode *inode = file->f_mapping->host;

2445
	rc = file_write_and_wait_range(file, start, end);
2446 2447
	if (rc)
		return rc;
A
Al Viro 已提交
2448
	inode_lock(inode);
2449

2450
	xid = get_xid();
2451

A
Al Viro 已提交
2452 2453
	cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
		 file, datasync);
2454 2455

	tcon = tlink_tcon(smbfile->tlink);
2456 2457 2458 2459 2460 2461 2462
	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;
	}
2463

2464
	free_xid(xid);
A
Al Viro 已提交
2465
	inode_unlock(inode);
L
Linus Torvalds 已提交
2466 2467 2468 2469 2470 2471 2472
	return rc;
}

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

2478
	if (file->f_mode & FMODE_WRITE)
2479
		rc = filemap_write_and_wait(inode->i_mapping);
2480

2481
	cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
L
Linus Torvalds 已提交
2482 2483 2484 2485

	return rc;
}

2486 2487 2488 2489 2490 2491 2492
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++) {
2493
		pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2494 2495 2496 2497 2498 2499 2500
		if (!pages[i]) {
			/*
			 * save number of pages we have already allocated and
			 * return with ENOMEM error
			 */
			num_pages = i;
			rc = -ENOMEM;
2501
			break;
2502 2503 2504
		}
	}

2505 2506 2507 2508
	if (rc) {
		for (i = 0; i < num_pages; i++)
			put_page(pages[i]);
	}
2509 2510 2511 2512 2513 2514 2515 2516 2517 2518
	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 已提交
2519
	num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2520 2521 2522 2523 2524 2525 2526

	if (cur_len)
		*cur_len = clen;

	return num_pages;
}

2527
static void
2528
cifs_uncached_writedata_release(struct kref *refcount)
2529 2530
{
	int i;
2531 2532 2533
	struct cifs_writedata *wdata = container_of(refcount,
					struct cifs_writedata, refcount);

2534
	kref_put(&wdata->ctx->refcount, cifs_aio_ctx_release);
2535 2536 2537 2538 2539
	for (i = 0; i < wdata->nr_pages; i++)
		put_page(wdata->pages[i]);
	cifs_writedata_release(refcount);
}

2540 2541
static void collect_uncached_write_data(struct cifs_aio_ctx *ctx);

2542 2543 2544
static void
cifs_uncached_writev_complete(struct work_struct *work)
{
2545 2546
	struct cifs_writedata *wdata = container_of(work,
					struct cifs_writedata, work);
2547
	struct inode *inode = d_inode(wdata->cfile->dentry);
2548 2549 2550 2551 2552 2553 2554 2555 2556
	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);
2557 2558
	collect_uncached_write_data(wdata->ctx);
	/* the below call can possibly free the last ref to aio ctx */
2559
	kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2560 2561 2562
}

static int
2563 2564
wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
		      size_t *len, unsigned long *num_pages)
2565
{
2566 2567
	size_t save_len, copied, bytes, cur_len = *len;
	unsigned long i, nr_pages = *num_pages;
2568

2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585
	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;
2586

2587 2588 2589 2590 2591 2592 2593 2594
	/*
	 * 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;
2595

2596 2597 2598 2599 2600 2601
	/*
	 * i + 1 now represents the number of pages we actually used in
	 * the copy phase above.
	 */
	*num_pages = i + 1;
	return 0;
2602 2603
}

2604 2605 2606
static int
cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
		     struct cifsFileInfo *open_file,
2607 2608
		     struct cifs_sb_info *cifs_sb, struct list_head *wdata_list,
		     struct cifs_aio_ctx *ctx)
2609
{
2610 2611
	int rc = 0;
	size_t cur_len;
2612
	unsigned long nr_pages, num_pages, i;
2613
	struct cifs_writedata *wdata;
2614
	struct iov_iter saved_from = *from;
2615
	loff_t saved_offset = offset;
2616
	pid_t pid;
2617
	struct TCP_Server_Info *server;
2618 2619 2620 2621 2622 2623

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

2624 2625
	server = tlink_tcon(open_file->tlink)->ses->server;

2626
	do {
2627 2628 2629 2630 2631 2632
		unsigned int wsize, credits;

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

2634
		nr_pages = get_numpages(wsize, len, &cur_len);
2635 2636 2637 2638
		wdata = cifs_writedata_alloc(nr_pages,
					     cifs_uncached_writev_complete);
		if (!wdata) {
			rc = -ENOMEM;
2639
			add_credits_and_wake_if(server, credits, 0);
2640 2641 2642 2643 2644 2645
			break;
		}

		rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
		if (rc) {
			kfree(wdata);
2646
			add_credits_and_wake_if(server, credits, 0);
2647 2648 2649
			break;
		}

2650 2651 2652
		num_pages = nr_pages;
		rc = wdata_fill_from_iovec(wdata, from, &cur_len, &num_pages);
		if (rc) {
2653 2654 2655
			for (i = 0; i < nr_pages; i++)
				put_page(wdata->pages[i]);
			kfree(wdata);
2656
			add_credits_and_wake_if(server, credits, 0);
2657 2658 2659 2660
			break;
		}

		/*
2661 2662
		 * Bring nr_pages down to the number of pages we actually used,
		 * and free any pages that we didn't use.
2663
		 */
2664
		for ( ; nr_pages > num_pages; nr_pages--)
2665 2666
			put_page(wdata->pages[nr_pages - 1]);

2667 2668 2669 2670 2671 2672
		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;
2673 2674
		wdata->pagesz = PAGE_SIZE;
		wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2675
		wdata->credits = credits;
2676 2677
		wdata->ctx = ctx;
		kref_get(&ctx->refcount);
2678 2679

		if (!wdata->cfile->invalidHandle ||
2680
		    !(rc = cifs_reopen_file(wdata->cfile, false)))
2681 2682
			rc = server->ops->async_writev(wdata,
					cifs_uncached_writedata_release);
2683
		if (rc) {
2684
			add_credits_and_wake_if(server, wdata->credits, 0);
2685 2686
			kref_put(&wdata->refcount,
				 cifs_uncached_writedata_release);
2687
			if (rc == -EAGAIN) {
2688
				*from = saved_from;
2689 2690 2691
				iov_iter_advance(from, offset - saved_offset);
				continue;
			}
2692 2693 2694
			break;
		}

2695
		list_add_tail(&wdata->list, wdata_list);
2696 2697
		offset += cur_len;
		len -= cur_len;
2698 2699
	} while (len > 0);

2700 2701 2702
	return rc;
}

2703
static void collect_uncached_write_data(struct cifs_aio_ctx *ctx)
2704
{
2705
	struct cifs_writedata *wdata, *tmp;
2706 2707
	struct cifs_tcon *tcon;
	struct cifs_sb_info *cifs_sb;
2708 2709
	struct dentry *dentry = ctx->cfile->dentry;
	unsigned int i;
2710 2711
	int rc;

2712 2713
	tcon = tlink_tcon(ctx->cfile->tlink);
	cifs_sb = CIFS_SB(dentry->d_sb);
2714

2715
	mutex_lock(&ctx->aio_mutex);
2716

2717 2718 2719 2720
	if (list_empty(&ctx->list)) {
		mutex_unlock(&ctx->aio_mutex);
		return;
	}
2721

2722
	rc = ctx->rc;
2723 2724
	/*
	 * Wait for and collect replies for any successful sends in order of
2725 2726
	 * increasing offset. Once an error is hit, then return without waiting
	 * for any more replies.
2727 2728
	 */
restart_loop:
2729
	list_for_each_entry_safe(wdata, tmp, &ctx->list, list) {
2730
		if (!rc) {
2731 2732 2733 2734 2735 2736
			if (!try_wait_for_completion(&wdata->done)) {
				mutex_unlock(&ctx->aio_mutex);
				return;
			}

			if (wdata->result)
2737 2738
				rc = wdata->result;
			else
2739
				ctx->total_len += wdata->bytes;
2740 2741 2742

			/* resend call if it's a retryable error */
			if (rc == -EAGAIN) {
2743
				struct list_head tmp_list;
2744
				struct iov_iter tmp_from = ctx->iter;
2745 2746 2747 2748 2749

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

				iov_iter_advance(&tmp_from,
2750
						 wdata->offset - ctx->pos);
2751 2752 2753

				rc = cifs_write_from_iter(wdata->offset,
						wdata->bytes, &tmp_from,
2754 2755
						ctx->cfile, cifs_sb, &tmp_list,
						ctx);
2756

2757
				list_splice(&tmp_list, &ctx->list);
2758 2759 2760

				kref_put(&wdata->refcount,
					 cifs_uncached_writedata_release);
2761 2762 2763 2764
				goto restart_loop;
			}
		}
		list_del_init(&wdata->list);
2765
		kref_put(&wdata->refcount, cifs_uncached_writedata_release);
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 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868
	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);

2869 2870
	if (unlikely(!total_written))
		return rc;
2871

2872 2873
	iocb->ki_pos += total_written;
	return total_written;
2874 2875
}

2876
static ssize_t
A
Al Viro 已提交
2877
cifs_writev(struct kiocb *iocb, struct iov_iter *from)
2878
{
2879 2880 2881 2882 2883
	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;
2884
	ssize_t rc;
2885

2886
	inode_lock(inode);
2887 2888 2889 2890 2891
	/*
	 * We need to hold the sem to be sure nobody modifies lock list
	 * with a brlock that prevents writing.
	 */
	down_read(&cinode->lock_sem);
2892

2893 2894
	rc = generic_write_checks(iocb, from);
	if (rc <= 0)
2895 2896 2897
		goto out;

	if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
2898
				     server->vals->exclusive_lock_type, NULL,
2899
				     CIFS_WRITE_OP))
A
Al Viro 已提交
2900
		rc = __generic_file_write_iter(iocb, from);
2901 2902 2903
	else
		rc = -EACCES;
out:
2904
	up_read(&cinode->lock_sem);
A
Al Viro 已提交
2905
	inode_unlock(inode);
A
Al Viro 已提交
2906

2907 2908
	if (rc > 0)
		rc = generic_write_sync(iocb, rc);
2909 2910 2911 2912
	return rc;
}

ssize_t
A
Al Viro 已提交
2913
cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
2914
{
A
Al Viro 已提交
2915
	struct inode *inode = file_inode(iocb->ki_filp);
2916 2917 2918 2919 2920
	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);
2921
	ssize_t written;
2922

2923 2924 2925 2926
	written = cifs_get_writer(cinode);
	if (written)
		return written;

2927
	if (CIFS_CACHE_WRITE(cinode)) {
2928 2929
		if (cap_unix(tcon->ses) &&
		(CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
2930
		  && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
A
Al Viro 已提交
2931
			written = generic_file_write_iter(iocb, from);
2932 2933
			goto out;
		}
A
Al Viro 已提交
2934
		written = cifs_writev(iocb, from);
2935
		goto out;
2936 2937
	}
	/*
2938 2939 2940 2941
	 * 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.
2942
	 */
A
Al Viro 已提交
2943
	written = cifs_user_writev(iocb, from);
2944
	if (CIFS_CACHE_READ(cinode)) {
2945
		/*
2946 2947 2948 2949 2950
		 * 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.
2951
		 */
2952
		cifs_zap_mapping(inode);
2953
		cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
2954
			 inode);
2955
		cinode->oplock = 0;
2956
	}
2957 2958
out:
	cifs_put_writer(cinode);
2959
	return written;
2960 2961
}

2962
static struct cifs_readdata *
2963
cifs_readdata_direct_alloc(struct page **pages, work_func_t complete)
2964 2965
{
	struct cifs_readdata *rdata;
2966

2967
	rdata = kzalloc(sizeof(*rdata), GFP_KERNEL);
2968
	if (rdata != NULL) {
2969
		rdata->pages = pages;
2970
		kref_init(&rdata->refcount);
2971 2972
		INIT_LIST_HEAD(&rdata->list);
		init_completion(&rdata->done);
2973 2974
		INIT_WORK(&rdata->work, complete);
	}
2975

2976 2977 2978
	return rdata;
}

2979 2980 2981 2982
static struct cifs_readdata *
cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
{
	struct page **pages =
K
Kees Cook 已提交
2983
		kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994
	struct cifs_readdata *ret = NULL;

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

	return ret;
}

2995 2996
void
cifs_readdata_release(struct kref *refcount)
2997
{
2998 2999
	struct cifs_readdata *rdata = container_of(refcount,
					struct cifs_readdata, refcount);
3000 3001 3002 3003 3004 3005
#ifdef CONFIG_CIFS_SMB_DIRECT
	if (rdata->mr) {
		smbd_deregister_mr(rdata->mr);
		rdata->mr = NULL;
	}
#endif
3006 3007 3008
	if (rdata->cfile)
		cifsFileInfo_put(rdata->cfile);

3009
	kvfree(rdata->pages);
3010 3011 3012
	kfree(rdata);
}

3013
static int
3014
cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
3015 3016
{
	int rc = 0;
3017
	struct page *page;
3018 3019
	unsigned int i;

3020
	for (i = 0; i < nr_pages; i++) {
3021 3022 3023 3024 3025
		page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
		if (!page) {
			rc = -ENOMEM;
			break;
		}
3026
		rdata->pages[i] = page;
3027 3028 3029
	}

	if (rc) {
3030 3031 3032
		unsigned int nr_page_failed = i;

		for (i = 0; i < nr_page_failed; i++) {
3033 3034
			put_page(rdata->pages[i]);
			rdata->pages[i] = NULL;
3035 3036 3037 3038 3039 3040 3041 3042 3043 3044
		}
	}
	return rc;
}

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

3047
	kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
3048 3049 3050
	for (i = 0; i < rdata->nr_pages; i++) {
		put_page(rdata->pages[i]);
		rdata->pages[i] = NULL;
3051 3052 3053 3054 3055 3056 3057
	}
	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
3058
 * @iter:	destination for our data
3059 3060 3061 3062 3063
 *
 * 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.
 */
3064 3065
static int
cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
3066
{
3067
	size_t remaining = rdata->got_bytes;
3068
	unsigned int i;
3069

3070 3071
	for (i = 0; i < rdata->nr_pages; i++) {
		struct page *page = rdata->pages[i];
3072
		size_t copy = min_t(size_t, remaining, PAGE_SIZE);
3073 3074 3075 3076 3077 3078 3079 3080 3081
		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);
3082 3083 3084
		remaining -= written;
		if (written < copy && iov_iter_count(iter) > 0)
			break;
3085
	}
3086
	return remaining ? -EFAULT : 0;
3087 3088
}

3089 3090
static void collect_uncached_read_data(struct cifs_aio_ctx *ctx);

3091 3092 3093 3094 3095 3096 3097
static void
cifs_uncached_readv_complete(struct work_struct *work)
{
	struct cifs_readdata *rdata = container_of(work,
						struct cifs_readdata, work);

	complete(&rdata->done);
3098 3099
	collect_uncached_read_data(rdata->ctx);
	/* the below call can possibly free the last ref to aio ctx */
3100 3101 3102 3103
	kref_put(&rdata->refcount, cifs_uncached_readdata_release);
}

static int
3104 3105 3106
uncached_fill_pages(struct TCP_Server_Info *server,
		    struct cifs_readdata *rdata, struct iov_iter *iter,
		    unsigned int len)
3107
{
3108
	int result = 0;
3109 3110
	unsigned int i;
	unsigned int nr_pages = rdata->nr_pages;
L
Long Li 已提交
3111
	unsigned int page_offset = rdata->page_offset;
3112

3113
	rdata->got_bytes = 0;
3114
	rdata->tailsz = PAGE_SIZE;
3115 3116
	for (i = 0; i < nr_pages; i++) {
		struct page *page = rdata->pages[i];
3117
		size_t n;
L
Long Li 已提交
3118 3119 3120 3121 3122 3123 3124
		unsigned int segment_size = rdata->pagesz;

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

3125

3126
		if (len <= 0) {
3127
			/* no need to hold page hostage */
3128 3129
			rdata->pages[i] = NULL;
			rdata->nr_pages--;
3130
			put_page(page);
3131
			continue;
3132
		}
L
Long Li 已提交
3133

3134
		n = len;
L
Long Li 已提交
3135
		if (len >= segment_size)
3136
			/* enough data to fill the page */
L
Long Li 已提交
3137 3138
			n = segment_size;
		else
3139
			rdata->tailsz = len;
L
Long Li 已提交
3140 3141
		len -= n;

3142
		if (iter)
L
Long Li 已提交
3143 3144
			result = copy_page_from_iter(
					page, page_offset, n, iter);
3145 3146 3147 3148
#ifdef CONFIG_CIFS_SMB_DIRECT
		else if (rdata->mr)
			result = n;
#endif
3149
		else
L
Long Li 已提交
3150 3151
			result = cifs_read_page_from_socket(
					server, page, page_offset, n);
3152 3153 3154
		if (result < 0)
			break;

3155
		rdata->got_bytes += result;
3156 3157
	}

3158 3159
	return rdata->got_bytes > 0 && result != -ECONNABORTED ?
						rdata->got_bytes : result;
3160 3161
}

3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176
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);
}

3177 3178
static int
cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
3179 3180
		     struct cifs_sb_info *cifs_sb, struct list_head *rdata_list,
		     struct cifs_aio_ctx *ctx)
L
Linus Torvalds 已提交
3181
{
3182
	struct cifs_readdata *rdata;
3183
	unsigned int npages, rsize, credits;
3184 3185
	size_t cur_len;
	int rc;
3186
	pid_t pid;
3187
	struct TCP_Server_Info *server;
3188

3189
	server = tlink_tcon(open_file->tlink)->ses->server;
3190

3191 3192 3193 3194 3195
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

3196
	do {
3197 3198 3199 3200 3201 3202
		rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
						   &rsize, &credits);
		if (rc)
			break;

		cur_len = min_t(const size_t, len, rsize);
3203
		npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
3204

3205 3206 3207 3208
		/* allocate a readdata struct */
		rdata = cifs_readdata_alloc(npages,
					    cifs_uncached_readv_complete);
		if (!rdata) {
3209
			add_credits_and_wake_if(server, credits, 0);
3210
			rc = -ENOMEM;
3211
			break;
L
Linus Torvalds 已提交
3212
		}
3213

3214
		rc = cifs_read_allocate_pages(rdata, npages);
3215 3216 3217 3218
		if (rc)
			goto error;

		rdata->cfile = cifsFileInfo_get(open_file);
3219
		rdata->nr_pages = npages;
3220 3221 3222
		rdata->offset = offset;
		rdata->bytes = cur_len;
		rdata->pid = pid;
3223
		rdata->pagesz = PAGE_SIZE;
L
Long Li 已提交
3224
		rdata->tailsz = PAGE_SIZE;
3225
		rdata->read_into_pages = cifs_uncached_read_into_pages;
3226
		rdata->copy_into_pages = cifs_uncached_copy_into_pages;
3227
		rdata->credits = credits;
3228 3229
		rdata->ctx = ctx;
		kref_get(&ctx->refcount);
3230

3231
		if (!rdata->cfile->invalidHandle ||
3232
		    !(rc = cifs_reopen_file(rdata->cfile, true)))
3233
			rc = server->ops->async_readv(rdata);
3234 3235
error:
		if (rc) {
3236
			add_credits_and_wake_if(server, rdata->credits, 0);
3237 3238
			kref_put(&rdata->refcount,
				 cifs_uncached_readdata_release);
3239 3240
			if (rc == -EAGAIN)
				continue;
3241 3242 3243
			break;
		}

3244
		list_add_tail(&rdata->list, rdata_list);
3245 3246 3247 3248
		offset += cur_len;
		len -= cur_len;
	} while (len > 0);

3249 3250 3251
	return rc;
}

3252 3253
static void
collect_uncached_read_data(struct cifs_aio_ctx *ctx)
3254
{
3255 3256
	struct cifs_readdata *rdata, *tmp;
	struct iov_iter *to = &ctx->iter;
3257 3258
	struct cifs_sb_info *cifs_sb;
	struct cifs_tcon *tcon;
3259 3260
	unsigned int i;
	int rc;
3261

3262 3263
	tcon = tlink_tcon(ctx->cfile->tlink);
	cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb);
3264

3265
	mutex_lock(&ctx->aio_mutex);
3266

3267 3268 3269 3270
	if (list_empty(&ctx->list)) {
		mutex_unlock(&ctx->aio_mutex);
		return;
	}
3271

3272
	rc = ctx->rc;
3273
	/* the loop below should proceed in the order of increasing offsets */
3274
again:
3275
	list_for_each_entry_safe(rdata, tmp, &ctx->list, list) {
3276
		if (!rc) {
3277 3278 3279 3280 3281 3282
			if (!try_wait_for_completion(&rdata->done)) {
				mutex_unlock(&ctx->aio_mutex);
				return;
			}

			if (rdata->result == -EAGAIN) {
3283
				/* resend call if it's a retryable error */
3284
				struct list_head tmp_list;
3285
				unsigned int got_bytes = rdata->got_bytes;
3286

3287 3288
				list_del_init(&rdata->list);
				INIT_LIST_HEAD(&tmp_list);
3289

3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301
				/*
				 * 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;
					}
3302
				}
3303 3304 3305 3306 3307

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

3310
				list_splice(&tmp_list, &ctx->list);
3311

3312 3313 3314 3315 3316 3317
				kref_put(&rdata->refcount,
					 cifs_uncached_readdata_release);
				goto again;
			} else if (rdata->result)
				rc = rdata->result;
			else
A
Al Viro 已提交
3318
				rc = cifs_readdata_to_iov(rdata, to);
3319

3320 3321 3322
			/* if there was a short read -- discard anything left */
			if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
				rc = -ENODATA;
L
Linus Torvalds 已提交
3323
		}
3324 3325
		list_del_init(&rdata->list);
		kref_put(&rdata->refcount, cifs_uncached_readdata_release);
L
Linus Torvalds 已提交
3326
	}
3327

3328 3329 3330 3331 3332
	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);
	}
3333

3334 3335 3336
	ctx->total_len = ctx->len - iov_iter_count(to);

	cifs_stats_bytes_read(tcon, ctx->total_len);
3337

3338 3339 3340 3341
	/* mask nodata case */
	if (rc == -ENODATA)
		rc = 0;

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 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386
	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;

3387
	if (to->type == ITER_IOVEC)
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 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431
		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);

3432
	if (total_read) {
A
Al Viro 已提交
3433
		iocb->ki_pos += total_read;
3434 3435 3436
		return total_read;
	}
	return rc;
3437 3438
}

3439
ssize_t
A
Al Viro 已提交
3440
cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3441
{
A
Al Viro 已提交
3442
	struct inode *inode = file_inode(iocb->ki_filp);
3443 3444 3445 3446 3447 3448
	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;
3449 3450 3451 3452 3453 3454 3455 3456 3457

	/*
	 * 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.
	 */
3458
	if (!CIFS_CACHE_READ(cinode))
A
Al Viro 已提交
3459
		return cifs_user_readv(iocb, to);
3460

3461 3462 3463
	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 已提交
3464
		return generic_file_read_iter(iocb, to);
3465 3466 3467 3468 3469 3470

	/*
	 * 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 已提交
3471
	if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3472
				     tcon->ses->server->vals->shared_lock_type,
3473
				     NULL, CIFS_READ_OP))
A
Al Viro 已提交
3474
		rc = generic_file_read_iter(iocb, to);
3475 3476
	up_read(&cinode->lock_sem);
	return rc;
3477
}
L
Linus Torvalds 已提交
3478

3479 3480
static ssize_t
cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
L
Linus Torvalds 已提交
3481 3482 3483 3484 3485
{
	int rc = -EACCES;
	unsigned int bytes_read = 0;
	unsigned int total_read;
	unsigned int current_read_size;
3486
	unsigned int rsize;
L
Linus Torvalds 已提交
3487
	struct cifs_sb_info *cifs_sb;
3488
	struct cifs_tcon *tcon;
3489
	struct TCP_Server_Info *server;
3490
	unsigned int xid;
3491
	char *cur_offset;
L
Linus Torvalds 已提交
3492
	struct cifsFileInfo *open_file;
3493
	struct cifs_io_parms io_parms;
3494
	int buf_type = CIFS_NO_BUFFER;
3495
	__u32 pid;
L
Linus Torvalds 已提交
3496

3497
	xid = get_xid();
3498
	cifs_sb = CIFS_FILE_SB(file);
L
Linus Torvalds 已提交
3499

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

L
Linus Torvalds 已提交
3503
	if (file->private_data == NULL) {
3504
		rc = -EBADF;
3505
		free_xid(xid);
3506
		return rc;
L
Linus Torvalds 已提交
3507
	}
3508
	open_file = file->private_data;
3509
	tcon = tlink_tcon(open_file->tlink);
3510 3511 3512 3513 3514 3515
	server = tcon->ses->server;

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

3517 3518 3519 3520 3521
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

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

3525 3526
	for (total_read = 0, cur_offset = read_data; read_size > total_read;
	     total_read += bytes_read, cur_offset += bytes_read) {
3527 3528 3529 3530 3531 3532 3533 3534 3535
		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 &
3536
				tcon->ses->server->vals->cap_large_files)) {
3537 3538 3539
				current_read_size = min_t(uint,
					current_read_size, CIFSMaxBufSize);
			}
3540
			if (open_file->invalidHandle) {
J
Jeff Layton 已提交
3541
				rc = cifs_reopen_file(open_file, true);
L
Linus Torvalds 已提交
3542 3543 3544
				if (rc != 0)
					break;
			}
3545
			io_parms.pid = pid;
3546
			io_parms.tcon = tcon;
3547
			io_parms.offset = *offset;
3548
			io_parms.length = current_read_size;
3549
			rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
3550 3551
						    &bytes_read, &cur_offset,
						    &buf_type);
3552 3553
		} while (rc == -EAGAIN);

L
Linus Torvalds 已提交
3554 3555 3556 3557
		if (rc || (bytes_read == 0)) {
			if (total_read) {
				break;
			} else {
3558
				free_xid(xid);
L
Linus Torvalds 已提交
3559 3560 3561
				return rc;
			}
		} else {
3562
			cifs_stats_bytes_read(tcon, total_read);
3563
			*offset += bytes_read;
L
Linus Torvalds 已提交
3564 3565
		}
	}
3566
	free_xid(xid);
L
Linus Torvalds 已提交
3567 3568 3569
	return total_read;
}

3570 3571 3572 3573
/*
 * 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.
 */
3574
static vm_fault_t
3575
cifs_page_mkwrite(struct vm_fault *vmf)
3576 3577 3578 3579 3580 3581 3582
{
	struct page *page = vmf->page;

	lock_page(page);
	return VM_FAULT_LOCKED;
}

3583
static const struct vm_operations_struct cifs_file_vm_ops = {
3584
	.fault = filemap_fault,
3585
	.map_pages = filemap_map_pages,
3586 3587 3588
	.page_mkwrite = cifs_page_mkwrite,
};

3589 3590
int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
{
3591
	int xid, rc = 0;
A
Al Viro 已提交
3592
	struct inode *inode = file_inode(file);
3593

3594
	xid = get_xid();
3595

3596
	if (!CIFS_CACHE_READ(CIFS_I(inode)))
3597
		rc = cifs_zap_mapping(inode);
3598 3599 3600
	if (!rc)
		rc = generic_file_mmap(file, vma);
	if (!rc)
3601
		vma->vm_ops = &cifs_file_vm_ops;
3602

3603
	free_xid(xid);
3604 3605 3606
	return rc;
}

L
Linus Torvalds 已提交
3607 3608 3609 3610
int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
{
	int rc, xid;

3611
	xid = get_xid();
3612

J
Jeff Layton 已提交
3613
	rc = cifs_revalidate_file(file);
3614
	if (rc)
3615 3616
		cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
			 rc);
3617 3618 3619
	if (!rc)
		rc = generic_file_mmap(file, vma);
	if (!rc)
3620
		vma->vm_ops = &cifs_file_vm_ops;
3621

3622
	free_xid(xid);
L
Linus Torvalds 已提交
3623 3624 3625
	return rc;
}

3626 3627 3628
static void
cifs_readv_complete(struct work_struct *work)
{
3629
	unsigned int i, got_bytes;
3630 3631 3632
	struct cifs_readdata *rdata = container_of(work,
						struct cifs_readdata, work);

3633
	got_bytes = rdata->got_bytes;
3634 3635 3636
	for (i = 0; i < rdata->nr_pages; i++) {
		struct page *page = rdata->pages[i];

3637 3638
		lru_cache_add_file(page);

3639 3640
		if (rdata->result == 0 ||
		    (rdata->result == -EAGAIN && got_bytes)) {
3641 3642 3643 3644 3645 3646
			flush_dcache_page(page);
			SetPageUptodate(page);
		}

		unlock_page(page);

3647 3648
		if (rdata->result == 0 ||
		    (rdata->result == -EAGAIN && got_bytes))
3649 3650
			cifs_readpage_to_fscache(rdata->mapping->host, page);

3651
		got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
3652

3653
		put_page(page);
3654
		rdata->pages[i] = NULL;
3655
	}
3656
	kref_put(&rdata->refcount, cifs_readdata_release);
3657 3658
}

3659
static int
3660 3661 3662
readpages_fill_pages(struct TCP_Server_Info *server,
		     struct cifs_readdata *rdata, struct iov_iter *iter,
		     unsigned int len)
3663
{
3664
	int result = 0;
3665
	unsigned int i;
3666 3667
	u64 eof;
	pgoff_t eof_index;
3668
	unsigned int nr_pages = rdata->nr_pages;
L
Long Li 已提交
3669
	unsigned int page_offset = rdata->page_offset;
3670 3671 3672

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

3676
	rdata->got_bytes = 0;
3677
	rdata->tailsz = PAGE_SIZE;
3678 3679
	for (i = 0; i < nr_pages; i++) {
		struct page *page = rdata->pages[i];
L
Long Li 已提交
3680 3681 3682 3683 3684 3685 3686 3687 3688
		unsigned int to_read = rdata->pagesz;
		size_t n;

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

		n = to_read;
3689

L
Long Li 已提交
3690 3691
		if (len >= to_read) {
			len -= to_read;
3692
		} else if (len > 0) {
3693
			/* enough for partial page, fill and zero the rest */
L
Long Li 已提交
3694
			zero_user(page, len + page_offset, to_read - len);
3695
			n = rdata->tailsz = len;
3696
			len = 0;
3697 3698 3699 3700 3701 3702 3703 3704 3705
		} 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.
			 */
3706
			zero_user(page, 0, PAGE_SIZE);
3707 3708 3709 3710
			lru_cache_add_file(page);
			flush_dcache_page(page);
			SetPageUptodate(page);
			unlock_page(page);
3711
			put_page(page);
3712 3713
			rdata->pages[i] = NULL;
			rdata->nr_pages--;
3714
			continue;
3715 3716 3717 3718
		} else {
			/* no need to hold page hostage */
			lru_cache_add_file(page);
			unlock_page(page);
3719
			put_page(page);
3720 3721
			rdata->pages[i] = NULL;
			rdata->nr_pages--;
3722
			continue;
3723
		}
3724

3725
		if (iter)
L
Long Li 已提交
3726 3727
			result = copy_page_from_iter(
					page, page_offset, n, iter);
3728 3729 3730 3731
#ifdef CONFIG_CIFS_SMB_DIRECT
		else if (rdata->mr)
			result = n;
#endif
3732
		else
L
Long Li 已提交
3733 3734
			result = cifs_read_page_from_socket(
					server, page, page_offset, n);
3735 3736 3737
		if (result < 0)
			break;

3738
		rdata->got_bytes += result;
3739 3740
	}

3741 3742
	return rdata->got_bytes > 0 && result != -ECONNABORTED ?
						rdata->got_bytes : result;
3743 3744
}

3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759
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);
}

3760 3761 3762 3763 3764 3765 3766 3767
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;
3768
	gfp_t gfp = readahead_gfp_mask(mapping);
3769

3770 3771
	INIT_LIST_HEAD(tmplist);

3772 3773 3774 3775 3776 3777 3778
	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.
	 */
3779
	__SetPageLocked(page);
3780
	rc = add_to_page_cache_locked(page, mapping,
3781
				      page->index, gfp);
3782 3783 3784

	/* give up if we can't stick it in the cache */
	if (rc) {
3785
		__ClearPageLocked(page);
3786 3787 3788 3789
		return rc;
	}

	/* move first page to the tmplist */
3790 3791
	*offset = (loff_t)page->index << PAGE_SHIFT;
	*bytes = PAGE_SIZE;
3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802
	*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? */
3803
		if (*bytes + PAGE_SIZE > rsize)
3804 3805
			break;

3806
		__SetPageLocked(page);
3807
		if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
3808
			__ClearPageLocked(page);
3809 3810 3811
			break;
		}
		list_move_tail(&page->lru, tmplist);
3812
		(*bytes) += PAGE_SIZE;
3813 3814 3815 3816
		expected_index++;
		(*nr_pages)++;
	}
	return rc;
3817 3818
}

L
Linus Torvalds 已提交
3819 3820 3821
static int cifs_readpages(struct file *file, struct address_space *mapping,
	struct list_head *page_list, unsigned num_pages)
{
3822 3823 3824
	int rc;
	struct list_head tmplist;
	struct cifsFileInfo *open_file = file->private_data;
3825
	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
3826
	struct TCP_Server_Info *server;
3827
	pid_t pid;
L
Linus Torvalds 已提交
3828

3829 3830 3831
	/*
	 * Reads as many pages as possible from fscache. Returns -ENOBUFS
	 * immediately if the cookie is negative
3832 3833 3834
	 *
	 * 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.
3835 3836 3837 3838
	 */
	rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
					 &num_pages);
	if (rc == 0)
3839
		return rc;
3840

3841 3842 3843 3844 3845
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

3846
	rc = 0;
3847
	server = tlink_tcon(open_file->tlink)->ses->server;
L
Linus Torvalds 已提交
3848

3849 3850
	cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
		 __func__, file, mapping, num_pages);
3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863

	/*
	 * 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)) {
3864
		unsigned int i, nr_pages, bytes, rsize;
3865 3866 3867
		loff_t offset;
		struct page *page, *tpage;
		struct cifs_readdata *rdata;
3868
		unsigned credits;
L
Linus Torvalds 已提交
3869

3870 3871 3872 3873
		rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
						   &rsize, &credits);
		if (rc)
			break;
3874 3875

		/*
3876 3877 3878 3879
		 * 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.
3880
		 */
3881
		if (unlikely(rsize < PAGE_SIZE)) {
3882
			add_credits_and_wake_if(server, credits, 0);
3883
			return 0;
3884
		}
3885

3886 3887
		rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
					 &nr_pages, &offset, &bytes);
3888
		if (rc) {
3889
			add_credits_and_wake_if(server, credits, 0);
3890 3891 3892
			break;
		}

3893
		rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3894 3895 3896 3897 3898 3899
		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);
3900
				put_page(page);
3901 3902
			}
			rc = -ENOMEM;
3903
			add_credits_and_wake_if(server, credits, 0);
3904 3905 3906
			break;
		}

3907
		rdata->cfile = cifsFileInfo_get(open_file);
3908 3909 3910 3911
		rdata->mapping = mapping;
		rdata->offset = offset;
		rdata->bytes = bytes;
		rdata->pid = pid;
3912
		rdata->pagesz = PAGE_SIZE;
L
Long Li 已提交
3913
		rdata->tailsz = PAGE_SIZE;
3914
		rdata->read_into_pages = cifs_readpages_read_into_pages;
3915
		rdata->copy_into_pages = cifs_readpages_copy_into_pages;
3916
		rdata->credits = credits;
3917 3918 3919 3920 3921

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

3923
		if (!rdata->cfile->invalidHandle ||
3924
		    !(rc = cifs_reopen_file(rdata->cfile, true)))
3925 3926
			rc = server->ops->async_readv(rdata);
		if (rc) {
3927
			add_credits_and_wake_if(server, rdata->credits, 0);
3928 3929
			for (i = 0; i < rdata->nr_pages; i++) {
				page = rdata->pages[i];
3930 3931
				lru_cache_add_file(page);
				unlock_page(page);
3932
				put_page(page);
L
Linus Torvalds 已提交
3933
			}
3934
			/* Fallback to the readpage in error/reconnect cases */
3935
			kref_put(&rdata->refcount, cifs_readdata_release);
L
Linus Torvalds 已提交
3936 3937
			break;
		}
3938 3939

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

3942 3943 3944 3945 3946
	/* 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 已提交
3947 3948 3949
	return rc;
}

3950 3951 3952
/*
 * cifs_readpage_worker must be called with the page pinned
 */
L
Linus Torvalds 已提交
3953 3954 3955 3956 3957 3958
static int cifs_readpage_worker(struct file *file, struct page *page,
	loff_t *poffset)
{
	char *read_data;
	int rc;

3959
	/* Is the page cached? */
A
Al Viro 已提交
3960
	rc = cifs_readpage_from_fscache(file_inode(file), page);
3961 3962 3963
	if (rc == 0)
		goto read_complete;

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

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

L
Linus Torvalds 已提交
3969 3970 3971
	if (rc < 0)
		goto io_error;
	else
3972
		cifs_dbg(FYI, "Bytes read %d\n", rc);
S
Steve French 已提交
3973

A
Al Viro 已提交
3974
	file_inode(file)->i_atime =
3975
		current_time(file_inode(file));
S
Steve French 已提交
3976

3977 3978
	if (PAGE_SIZE > rc)
		memset(read_data + rc, 0, PAGE_SIZE - rc);
L
Linus Torvalds 已提交
3979 3980 3981

	flush_dcache_page(page);
	SetPageUptodate(page);
3982 3983

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

L
Linus Torvalds 已提交
3986
	rc = 0;
S
Steve French 已提交
3987

L
Linus Torvalds 已提交
3988
io_error:
S
Steve French 已提交
3989
	kunmap(page);
3990
	unlock_page(page);
3991 3992

read_complete:
L
Linus Torvalds 已提交
3993 3994 3995 3996 3997
	return rc;
}

static int cifs_readpage(struct file *file, struct page *page)
{
3998
	loff_t offset = (loff_t)page->index << PAGE_SHIFT;
L
Linus Torvalds 已提交
3999
	int rc = -EACCES;
4000
	unsigned int xid;
L
Linus Torvalds 已提交
4001

4002
	xid = get_xid();
L
Linus Torvalds 已提交
4003 4004

	if (file->private_data == NULL) {
4005
		rc = -EBADF;
4006
		free_xid(xid);
4007
		return rc;
L
Linus Torvalds 已提交
4008 4009
	}

4010
	cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
4011
		 page, (int)offset, (int)offset);
L
Linus Torvalds 已提交
4012 4013 4014

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

4015
	free_xid(xid);
L
Linus Torvalds 已提交
4016 4017 4018
	return rc;
}

4019 4020 4021 4022
static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
{
	struct cifsFileInfo *open_file;

4023
	spin_lock(&cifs_inode->open_file_lock);
4024
	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
4025
		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
4026
			spin_unlock(&cifs_inode->open_file_lock);
4027 4028 4029
			return 1;
		}
	}
4030
	spin_unlock(&cifs_inode->open_file_lock);
4031 4032 4033
	return 0;
}

L
Linus Torvalds 已提交
4034 4035 4036
/* 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 已提交
4037
   refreshing the inode only on increases in the file size
L
Linus Torvalds 已提交
4038 4039
   but this is tricky to do without racing with writebehind
   page caching in the current Linux kernel design */
4040
bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
L
Linus Torvalds 已提交
4041
{
4042
	if (!cifsInode)
4043
		return true;
4044

4045 4046
	if (is_inode_writable(cifsInode)) {
		/* This inode is open for write at least once */
4047 4048 4049
		struct cifs_sb_info *cifs_sb;

		cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
S
Steve French 已提交
4050
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
S
Steve French 已提交
4051
			/* since no page cache to corrupt on directio
4052
			we can change size safely */
4053
			return true;
4054 4055
		}

S
Steve French 已提交
4056
		if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
4057
			return true;
4058

4059
		return false;
4060
	} else
4061
		return true;
L
Linus Torvalds 已提交
4062 4063
}

N
Nick Piggin 已提交
4064 4065 4066
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 已提交
4067
{
4068
	int oncethru = 0;
4069 4070
	pgoff_t index = pos >> PAGE_SHIFT;
	loff_t offset = pos & (PAGE_SIZE - 1);
4071 4072 4073 4074
	loff_t page_start = pos & PAGE_MASK;
	loff_t i_size;
	struct page *page;
	int rc = 0;
N
Nick Piggin 已提交
4075

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

4078
start:
4079
	page = grab_cache_page_write_begin(mapping, index, flags);
4080 4081 4082 4083
	if (!page) {
		rc = -ENOMEM;
		goto out;
	}
4084

4085 4086
	if (PageUptodate(page))
		goto out;
4087

4088 4089 4090 4091 4092
	/*
	 * 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.
	 */
4093
	if (len == PAGE_SIZE)
4094
		goto out;
4095

4096 4097 4098 4099 4100 4101
	/*
	 * 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.
	 */
4102
	if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
4103 4104 4105 4106 4107
		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,
4108
					   PAGE_SIZE);
4109 4110 4111 4112 4113 4114 4115 4116 4117 4118
			/*
			 * 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 已提交
4119

4120
	if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
4121 4122 4123 4124 4125 4126
		/*
		 * 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);
4127
		put_page(page);
4128 4129
		oncethru = 1;
		goto start;
4130 4131 4132 4133
	} 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 已提交
4134
		   this will be written out by write_end so is fine */
L
Linus Torvalds 已提交
4135
	}
4136 4137 4138
out:
	*pagep = page;
	return rc;
L
Linus Torvalds 已提交
4139 4140
}

4141 4142 4143 4144 4145 4146 4147 4148
static int cifs_release_page(struct page *page, gfp_t gfp)
{
	if (PagePrivate(page))
		return 0;

	return cifs_fscache_release_page(page, gfp);
}

4149 4150
static void cifs_invalidate_page(struct page *page, unsigned int offset,
				 unsigned int length)
4151 4152 4153
{
	struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);

4154
	if (offset == 0 && length == PAGE_SIZE)
4155 4156 4157
		cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
}

4158 4159 4160 4161
static int cifs_launder_page(struct page *page)
{
	int rc = 0;
	loff_t range_start = page_offset(page);
4162
	loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
4163 4164 4165 4166 4167 4168 4169
	struct writeback_control wbc = {
		.sync_mode = WB_SYNC_ALL,
		.nr_to_write = 0,
		.range_start = range_start,
		.range_end = range_end,
	};

4170
	cifs_dbg(FYI, "Launder page: %p\n", page);
4171 4172 4173 4174 4175 4176 4177 4178

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

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

4179
void cifs_oplock_break(struct work_struct *work)
4180 4181 4182
{
	struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
						  oplock_break);
4183
	struct inode *inode = d_inode(cfile->dentry);
4184
	struct cifsInodeInfo *cinode = CIFS_I(inode);
4185
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4186
	struct TCP_Server_Info *server = tcon->ses->server;
4187
	int rc = 0;
4188

4189
	wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
4190
			TASK_UNINTERRUPTIBLE);
4191 4192 4193 4194

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

4195
	if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
4196
						cifs_has_mand_locks(cinode)) {
4197 4198
		cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
			 inode);
4199
		cinode->oplock = 0;
4200 4201
	}

4202
	if (inode && S_ISREG(inode->i_mode)) {
4203
		if (CIFS_CACHE_READ(cinode))
4204
			break_lease(inode, O_RDONLY);
S
Steve French 已提交
4205
		else
4206
			break_lease(inode, O_WRONLY);
4207
		rc = filemap_fdatawrite(inode->i_mapping);
4208
		if (!CIFS_CACHE_READ(cinode)) {
4209 4210
			rc = filemap_fdatawait(inode->i_mapping);
			mapping_set_error(inode->i_mapping, rc);
4211
			cifs_zap_mapping(inode);
4212
		}
4213
		cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
4214 4215
	}

4216 4217
	rc = cifs_push_locks(cfile);
	if (rc)
4218
		cifs_dbg(VFS, "Push locks rc = %d\n", rc);
4219

4220 4221 4222 4223 4224 4225
	/*
	 * 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
	 */
4226
	if (!cfile->oplock_break_cancelled) {
4227 4228
		rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
							     cinode);
4229
		cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
4230
	}
4231
	_cifsFileInfo_put(cfile, false /* do not wait for ourself */);
4232
	cifs_done_oplock_break(cinode);
4233 4234
}

4235 4236 4237 4238 4239 4240 4241 4242 4243 4244
/*
 * 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
4245
cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
4246 4247 4248 4249 4250 4251 4252 4253 4254
{
        /*
         * FIXME
         * Eventually need to support direct IO for non forcedirectio mounts
         */
        return -EINVAL;
}


4255
const struct address_space_operations cifs_addr_ops = {
L
Linus Torvalds 已提交
4256 4257 4258
	.readpage = cifs_readpage,
	.readpages = cifs_readpages,
	.writepage = cifs_writepage,
4259
	.writepages = cifs_writepages,
N
Nick Piggin 已提交
4260 4261
	.write_begin = cifs_write_begin,
	.write_end = cifs_write_end,
L
Linus Torvalds 已提交
4262
	.set_page_dirty = __set_page_dirty_nobuffers,
4263
	.releasepage = cifs_release_page,
4264
	.direct_IO = cifs_direct_io,
4265
	.invalidatepage = cifs_invalidate_page,
4266
	.launder_page = cifs_launder_page,
L
Linus Torvalds 已提交
4267
};
D
Dave Kleikamp 已提交
4268 4269 4270 4271 4272 4273

/*
 * 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.
 */
4274
const struct address_space_operations cifs_addr_ops_smallbuf = {
D
Dave Kleikamp 已提交
4275 4276 4277
	.readpage = cifs_readpage,
	.writepage = cifs_writepage,
	.writepages = cifs_writepages,
N
Nick Piggin 已提交
4278 4279
	.write_begin = cifs_write_begin,
	.write_end = cifs_write_end,
D
Dave Kleikamp 已提交
4280
	.set_page_dirty = __set_page_dirty_nobuffers,
4281 4282
	.releasepage = cifs_release_page,
	.invalidatepage = cifs_invalidate_page,
4283
	.launder_page = cifs_launder_page,
D
Dave Kleikamp 已提交
4284
};