file.c 107.5 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

out:
	kfree(buf);
	return rc;
}

260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
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;
}

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

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

293 294 295 296 297 298 299 300 301
	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;
302
	down_write(&cinode->lock_sem);
303
	list_add(&fdlocks->llist, &cinode->llist);
304
	up_write(&cinode->lock_sem);
305

306 307 308 309 310 311 312 313
	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);
314
	mutex_init(&cfile->fh_mutex);
315
	spin_lock_init(&cfile->file_info_lock);
316

317 318
	cifs_sb_active(inode->i_sb);

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

328
	spin_lock(&tcon->open_file_lock);
329
	if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
330 331 332
		oplock = fid->pending_open->oplock;
	list_del(&fid->pending_open->olist);

333
	fid->purge_cache = false;
334
	server->ops->set_fid(cfile, fid, oplock);
335 336

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

338 339
	/* if readable file instance put first in list*/
	if (file->f_mode & FMODE_READ)
340
		list_add(&cfile->flist, &cinode->openFileList);
341
	else
342
		list_add_tail(&cfile->flist, &cinode->openFileList);
343
	spin_unlock(&tcon->open_file_lock);
344

345
	if (fid->purge_cache)
346
		cifs_zap_mapping(inode);
347

348 349
	file->private_data = cfile;
	return cfile;
350 351
}

352 353 354
struct cifsFileInfo *
cifsFileInfo_get(struct cifsFileInfo *cifs_file)
{
355
	spin_lock(&cifs_file->file_info_lock);
356
	cifsFileInfo_get_locked(cifs_file);
357
	spin_unlock(&cifs_file->file_info_lock);
358 359 360
	return cifs_file;
}

361 362
/*
 * Release a reference on the file private data. This may involve closing
363
 * the filehandle out on the server. Must be called without holding
364
 * tcon->open_file_lock and cifs_file->file_info_lock.
365
 */
366 367
void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
{
368
	struct inode *inode = d_inode(cifs_file->dentry);
369
	struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
370
	struct TCP_Server_Info *server = tcon->ses->server;
P
Pavel Shilovsky 已提交
371
	struct cifsInodeInfo *cifsi = CIFS_I(inode);
372 373
	struct super_block *sb = inode->i_sb;
	struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
374
	struct cifsLockInfo *li, *tmp;
375 376
	struct cifs_fid fid;
	struct cifs_pending_open open;
377
	bool oplock_break_cancelled;
378

379 380 381
	spin_lock(&tcon->open_file_lock);

	spin_lock(&cifs_file->file_info_lock);
382
	if (--cifs_file->count > 0) {
383 384
		spin_unlock(&cifs_file->file_info_lock);
		spin_unlock(&tcon->open_file_lock);
385 386
		return;
	}
387
	spin_unlock(&cifs_file->file_info_lock);
388

389 390 391 392 393 394
	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);

395 396 397 398 399
	/* remove it from the lists */
	list_del(&cifs_file->flist);
	list_del(&cifs_file->tlist);

	if (list_empty(&cifsi->openFileList)) {
400
		cifs_dbg(FYI, "closing last open instance for inode %p\n",
401
			 d_inode(cifs_file->dentry));
402 403 404 405 406
		/*
		 * 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.
		 */
407
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
408
			set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
409
		cifs_set_oplock_level(cifsi, 0);
410
	}
411 412

	spin_unlock(&tcon->open_file_lock);
413

414
	oplock_break_cancelled = cancel_work_sync(&cifs_file->oplock_break);
415

416
	if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
417
		struct TCP_Server_Info *server = tcon->ses->server;
418
		unsigned int xid;
419

420
		xid = get_xid();
421
		if (server->ops->close)
422 423
			server->ops->close(xid, tcon, &cifs_file->fid);
		_free_xid(xid);
424 425
	}

426 427 428
	if (oplock_break_cancelled)
		cifs_done_oplock_break(cifsi);

429 430
	cifs_del_pending_open(&open);

431 432
	/*
	 * Delete any outstanding lock records. We'll lose them when the file
433 434
	 * is closed anyway.
	 */
435
	down_write(&cifsi->lock_sem);
436
	list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
437
		list_del(&li->llist);
438
		cifs_del_lock_waiters(li);
439
		kfree(li);
440
	}
441 442
	list_del(&cifs_file->llist->llist);
	kfree(cifs_file->llist);
443
	up_write(&cifsi->lock_sem);
444 445 446

	cifs_put_tlink(cifs_file->tlink);
	dput(cifs_file->dentry);
447
	cifs_sb_deactive(sb);
448
	kfree(cifs_file);
449 450
}

L
Linus Torvalds 已提交
451
int cifs_open(struct inode *inode, struct file *file)
452

L
Linus Torvalds 已提交
453 454
{
	int rc = -EACCES;
455
	unsigned int xid;
456
	__u32 oplock;
L
Linus Torvalds 已提交
457
	struct cifs_sb_info *cifs_sb;
P
Pavel Shilovsky 已提交
458
	struct TCP_Server_Info *server;
459
	struct cifs_tcon *tcon;
460
	struct tcon_link *tlink;
461
	struct cifsFileInfo *cfile = NULL;
L
Linus Torvalds 已提交
462
	char *full_path = NULL;
P
Pavel Shilovsky 已提交
463
	bool posix_open_ok = false;
464
	struct cifs_fid fid;
465
	struct cifs_pending_open open;
L
Linus Torvalds 已提交
466

467
	xid = get_xid();
L
Linus Torvalds 已提交
468 469

	cifs_sb = CIFS_SB(inode->i_sb);
470 471
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink)) {
472
		free_xid(xid);
473 474 475
		return PTR_ERR(tlink);
	}
	tcon = tlink_tcon(tlink);
P
Pavel Shilovsky 已提交
476
	server = tcon->ses->server;
L
Linus Torvalds 已提交
477

G
Goldwyn Rodrigues 已提交
478
	full_path = build_path_from_dentry(file_dentry(file));
L
Linus Torvalds 已提交
479
	if (full_path == NULL) {
480
		rc = -ENOMEM;
481
		goto out;
L
Linus Torvalds 已提交
482 483
	}

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

487 488 489 490 491 492 493 494
	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;
	}

495
	if (server->oplocks)
496 497 498 499
		oplock = REQ_OPLOCK;
	else
		oplock = 0;

500
	if (!tcon->broken_posix_open && tcon->unix_ext &&
501 502
	    cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
503
		/* can not refresh inode info since size could be stale */
504
		rc = cifs_posix_open(full_path, &inode, inode->i_sb,
505
				cifs_sb->mnt_file_mode /* ignored */,
506
				file->f_flags, &oplock, &fid.netfid, xid);
507
		if (rc == 0) {
508
			cifs_dbg(FYI, "posix open succeeded\n");
P
Pavel Shilovsky 已提交
509
			posix_open_ok = true;
510 511
		} else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
			if (tcon->ses->serverNOS)
512 513 514
				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);
515
			tcon->broken_posix_open = true;
516 517 518
		} else if ((rc != -EIO) && (rc != -EREMOTE) &&
			 (rc != -EOPNOTSUPP)) /* path not found or net err */
			goto out;
519 520 521 522
		/*
		 * Else fallthrough to retry open the old way on network i/o
		 * or DFS errors.
		 */
523 524
	}

525 526 527 528 529
	if (server->ops->get_lease_key)
		server->ops->get_lease_key(inode, &fid);

	cifs_add_pending_open(&fid, tlink, &open);

P
Pavel Shilovsky 已提交
530
	if (!posix_open_ok) {
P
Pavel Shilovsky 已提交
531 532 533
		if (server->ops->get_lease_key)
			server->ops->get_lease_key(inode, &fid);

P
Pavel Shilovsky 已提交
534
		rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
535
				  file->f_flags, &oplock, &fid, xid);
536 537
		if (rc) {
			cifs_del_pending_open(&open);
P
Pavel Shilovsky 已提交
538
			goto out;
539
		}
P
Pavel Shilovsky 已提交
540
	}
541

542 543
	cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
	if (cfile == NULL) {
P
Pavel Shilovsky 已提交
544 545
		if (server->ops->close)
			server->ops->close(xid, tcon, &fid);
546
		cifs_del_pending_open(&open);
L
Linus Torvalds 已提交
547 548 549 550
		rc = -ENOMEM;
		goto out;
	}

551 552
	cifs_fscache_set_inode_cookie(inode, file);

P
Pavel Shilovsky 已提交
553
	if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
554 555 556 557
		/*
		 * Time to set mode which we can not set earlier due to
		 * problems creating new read-only files.
		 */
P
Pavel Shilovsky 已提交
558 559
		struct cifs_unix_set_info_args args = {
			.mode	= inode->i_mode,
560 561
			.uid	= INVALID_UID, /* no change */
			.gid	= INVALID_GID, /* no change */
P
Pavel Shilovsky 已提交
562 563 564 565 566
			.ctime	= NO_CHANGE_64,
			.atime	= NO_CHANGE_64,
			.mtime	= NO_CHANGE_64,
			.device	= 0,
		};
567 568
		CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
				       cfile->pid);
L
Linus Torvalds 已提交
569 570 571 572
	}

out:
	kfree(full_path);
573
	free_xid(xid);
574
	cifs_put_tlink(tlink);
L
Linus Torvalds 已提交
575 576 577
	return rc;
}

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

580 581
/*
 * Try to reacquire byte range locks that were released when session
P
Pavel Shilovsky 已提交
582
 * to server was lost.
583
 */
P
Pavel Shilovsky 已提交
584 585
static int
cifs_relock_file(struct cifsFileInfo *cfile)
L
Linus Torvalds 已提交
586
{
P
Pavel Shilovsky 已提交
587
	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
588
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
P
Pavel Shilovsky 已提交
589
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
L
Linus Torvalds 已提交
590 591
	int rc = 0;

592
	down_read_nested(&cinode->lock_sem, SINGLE_DEPTH_NESTING);
P
Pavel Shilovsky 已提交
593
	if (cinode->can_cache_brlcks) {
594 595
		/* can cache locks - no need to relock */
		up_read(&cinode->lock_sem);
P
Pavel Shilovsky 已提交
596 597 598 599 600 601 602 603 604
		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 已提交
605

606
	up_read(&cinode->lock_sem);
L
Linus Torvalds 已提交
607 608 609
	return rc;
}

610 611
static int
cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
L
Linus Torvalds 已提交
612 613
{
	int rc = -EACCES;
614
	unsigned int xid;
615
	__u32 oplock;
L
Linus Torvalds 已提交
616
	struct cifs_sb_info *cifs_sb;
617
	struct cifs_tcon *tcon;
618 619
	struct TCP_Server_Info *server;
	struct cifsInodeInfo *cinode;
S
Steve French 已提交
620
	struct inode *inode;
L
Linus Torvalds 已提交
621
	char *full_path = NULL;
622
	int desired_access;
L
Linus Torvalds 已提交
623
	int disposition = FILE_OPEN;
624
	int create_options = CREATE_NOT_DIR;
625
	struct cifs_open_parms oparms;
L
Linus Torvalds 已提交
626

627
	xid = get_xid();
628 629 630
	mutex_lock(&cfile->fh_mutex);
	if (!cfile->invalidHandle) {
		mutex_unlock(&cfile->fh_mutex);
631
		rc = 0;
632
		free_xid(xid);
633
		return rc;
L
Linus Torvalds 已提交
634 635
	}

636
	inode = d_inode(cfile->dentry);
L
Linus Torvalds 已提交
637
	cifs_sb = CIFS_SB(inode->i_sb);
638 639 640 641 642 643 644 645 646 647
	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 已提交
648
	if (full_path == NULL) {
649
		rc = -ENOMEM;
650
		mutex_unlock(&cfile->fh_mutex);
651
		free_xid(xid);
652
		return rc;
L
Linus Torvalds 已提交
653 654
	}

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

658
	if (tcon->ses->server->oplocks)
L
Linus Torvalds 已提交
659 660
		oplock = REQ_OPLOCK;
	else
661
		oplock = 0;
L
Linus Torvalds 已提交
662

663
	if (tcon->unix_ext && cap_unix(tcon->ses) &&
664
	    (CIFS_UNIX_POSIX_PATH_OPS_CAP &
665
				le64_to_cpu(tcon->fsUnixInfo.Capability))) {
666 667 668 669
		/*
		 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
		 * original open. Must mask them off for a reopen.
		 */
670
		unsigned int oflags = cfile->f_flags &
J
Jeff Layton 已提交
671
						~(O_CREAT | O_EXCL | O_TRUNC);
672

673
		rc = cifs_posix_open(full_path, NULL, inode->i_sb,
674
				     cifs_sb->mnt_file_mode /* ignored */,
675
				     oflags, &oplock, &cfile->fid.netfid, xid);
676
		if (rc == 0) {
677
			cifs_dbg(FYI, "posix reopen succeeded\n");
678
			oparms.reconnect = true;
679 680
			goto reopen_success;
		}
681 682 683 684
		/*
		 * fallthrough to retry open the old way on errors, especially
		 * in the reconnect path it is important to retry hard
		 */
685 686
	}

687
	desired_access = cifs_convert_flags(cfile->f_flags);
688

689 690 691
	if (backup_cred(cifs_sb))
		create_options |= CREATE_OPEN_BACKUP_INTENT;

P
Pavel Shilovsky 已提交
692
	if (server->ops->get_lease_key)
693
		server->ops->get_lease_key(inode, &cfile->fid);
P
Pavel Shilovsky 已提交
694

695 696 697 698 699 700
	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;
701 702
	oparms.fid = &cfile->fid;
	oparms.reconnect = true;
703

704 705
	/*
	 * Can not refresh inode by passing in file_info buf to be returned by
706
	 * ops->open and then calling get_inode_info with returned buf since
707 708 709 710
	 * 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.
	 */
711
	rc = server->ops->open(xid, &oparms, &oplock, NULL);
712 713 714 715 716 717 718
	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 已提交
719
	if (rc) {
720
		mutex_unlock(&cfile->fh_mutex);
721 722
		cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
		cifs_dbg(FYI, "oplock: %d\n", oplock);
J
Jeff Layton 已提交
723 724 725
		goto reopen_error_exit;
	}

726
reopen_success:
727 728 729
	cfile->invalidHandle = false;
	mutex_unlock(&cfile->fh_mutex);
	cinode = CIFS_I(inode);
J
Jeff Layton 已提交
730 731 732

	if (can_flush) {
		rc = filemap_write_and_wait(inode->i_mapping);
733
		mapping_set_error(inode->i_mapping, rc);
J
Jeff Layton 已提交
734 735

		if (tcon->unix_ext)
736 737
			rc = cifs_get_inode_info_unix(&inode, full_path,
						      inode->i_sb, xid);
J
Jeff Layton 已提交
738
		else
739 740 741 742 743 744 745 746 747 748
			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.
	 */

749 750 751 752 753 754 755 756 757
	/*
	 * 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;
	}

758 759 760
	server->ops->set_fid(cfile, &cfile->fid, oplock);
	if (oparms.reconnect)
		cifs_relock_file(cfile);
J
Jeff Layton 已提交
761 762

reopen_error_exit:
L
Linus Torvalds 已提交
763
	kfree(full_path);
764
	free_xid(xid);
L
Linus Torvalds 已提交
765 766 767 768 769
	return rc;
}

int cifs_close(struct inode *inode, struct file *file)
{
770 771 772 773
	if (file->private_data != NULL) {
		cifsFileInfo_put(file->private_data);
		file->private_data = NULL;
	}
J
[CIFS]  
Jeremy Allison 已提交
774

775 776
	/* return code from the ->release op is always ignored */
	return 0;
L
Linus Torvalds 已提交
777 778
}

779 780 781
void
cifs_reopen_persistent_handles(struct cifs_tcon *tcon)
{
782
	struct cifsFileInfo *open_file;
783 784
	struct list_head *tmp;
	struct list_head *tmp1;
785 786
	struct list_head tmp_list;

787 788 789 790 791
	if (!tcon->use_persistent || !tcon->need_reopen_files)
		return;

	tcon->need_reopen_files = false;

792 793
	cifs_dbg(FYI, "Reopen persistent handles");
	INIT_LIST_HEAD(&tmp_list);
794 795 796

	/* list all files open on tree connection, reopen resilient handles  */
	spin_lock(&tcon->open_file_lock);
797
	list_for_each(tmp, &tcon->openFileList) {
798
		open_file = list_entry(tmp, struct cifsFileInfo, tlist);
799 800 801 802
		if (!open_file->invalidHandle)
			continue;
		cifsFileInfo_get(open_file);
		list_add_tail(&open_file->rlist, &tmp_list);
803 804
	}
	spin_unlock(&tcon->open_file_lock);
805 806 807

	list_for_each_safe(tmp, tmp1, &tmp_list) {
		open_file = list_entry(tmp, struct cifsFileInfo, rlist);
808 809
		if (cifs_reopen_file(open_file, false /* do not flush */))
			tcon->need_reopen_files = true;
810 811 812
		list_del_init(&open_file->rlist);
		cifsFileInfo_put(open_file);
	}
813 814
}

L
Linus Torvalds 已提交
815 816 817
int cifs_closedir(struct inode *inode, struct file *file)
{
	int rc = 0;
818
	unsigned int xid;
819
	struct cifsFileInfo *cfile = file->private_data;
820 821 822
	struct cifs_tcon *tcon;
	struct TCP_Server_Info *server;
	char *buf;
L
Linus Torvalds 已提交
823

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

826 827 828
	if (cfile == NULL)
		return rc;

829
	xid = get_xid();
830 831
	tcon = tlink_tcon(cfile->tlink);
	server = tcon->ses->server;
L
Linus Torvalds 已提交
832

833
	cifs_dbg(FYI, "Freeing private data in close dir\n");
834
	spin_lock(&cfile->file_info_lock);
835
	if (server->ops->dir_needs_close(cfile)) {
836
		cfile->invalidHandle = true;
837
		spin_unlock(&cfile->file_info_lock);
838 839 840 841
		if (server->ops->close_dir)
			rc = server->ops->close_dir(xid, tcon, &cfile->fid);
		else
			rc = -ENOSYS;
842
		cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
843 844 845
		/* not much we can do if it fails anyway, ignore rc */
		rc = 0;
	} else
846
		spin_unlock(&cfile->file_info_lock);
847 848 849

	buf = cfile->srch_inf.ntwrk_buf_start;
	if (buf) {
850
		cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
851 852 853 854 855
		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 已提交
856
	}
857 858 859 860

	cifs_put_tlink(cfile->tlink);
	kfree(file->private_data);
	file->private_data = NULL;
L
Linus Torvalds 已提交
861
	/* BB can we lock the filestruct while this is going on? */
862
	free_xid(xid);
L
Linus Torvalds 已提交
863 864 865
	return rc;
}

866
static struct cifsLockInfo *
867
cifs_lock_init(__u64 offset, __u64 length, __u8 type)
J
[CIFS]  
Jeremy Allison 已提交
868
{
869
	struct cifsLockInfo *lock =
S
Steve French 已提交
870
		kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
871 872 873 874 875 876 877 878 879
	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;
880 881
}

882
void
883 884 885 886 887 888 889 890 891
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);
	}
}

892 893 894 895 896
#define CIFS_LOCK_OP	0
#define CIFS_READ_OP	1
#define CIFS_WRITE_OP	2

/* @rw_check : 0 - no op, 1 - read, 2 - write */
897
static bool
898 899
cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
			    __u64 length, __u8 type, struct cifsFileInfo *cfile,
900
			    struct cifsLockInfo **conf_lock, int rw_check)
901
{
902
	struct cifsLockInfo *li;
903
	struct cifsFileInfo *cur_cfile = fdlocks->cfile;
904
	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
905

906
	list_for_each_entry(li, &fdlocks->locks, llist) {
907 908 909
		if (offset + length <= li->offset ||
		    offset >= li->offset + li->length)
			continue;
910 911 912 913 914 915 916
		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;
		}
917 918 919
		if ((type & server->vals->shared_lock_type) &&
		    ((server->ops->compare_fids(cfile, cur_cfile) &&
		     current->tgid == li->pid) || type == li->type))
920
			continue;
921 922
		if (conf_lock)
			*conf_lock = li;
923
		return true;
924 925 926 927
	}
	return false;
}

928
bool
929
cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
930
			__u8 type, struct cifsLockInfo **conf_lock,
931
			int rw_check)
932
{
933
	bool rc = false;
934
	struct cifs_fid_locks *cur;
935
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
936

937 938
	list_for_each_entry(cur, &cinode->llist, llist) {
		rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
939
						 cfile, conf_lock, rw_check);
940 941 942 943 944
		if (rc)
			break;
	}

	return rc;
945 946
}

947 948 949 950 951 952 953
/*
 * 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.
 */
954
static int
955 956
cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
	       __u8 type, struct file_lock *flock)
957 958 959
{
	int rc = 0;
	struct cifsLockInfo *conf_lock;
960
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
961
	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
962 963
	bool exist;

964
	down_read(&cinode->lock_sem);
965

966
	exist = cifs_find_lock_conflict(cfile, offset, length, type,
967
					&conf_lock, CIFS_LOCK_OP);
968 969 970 971
	if (exist) {
		flock->fl_start = conf_lock->offset;
		flock->fl_end = conf_lock->offset + conf_lock->length - 1;
		flock->fl_pid = conf_lock->pid;
972
		if (conf_lock->type & server->vals->shared_lock_type)
973 974 975 976 977 978 979 980
			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;

981
	up_read(&cinode->lock_sem);
982 983 984
	return rc;
}

985
static void
986
cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
987
{
988
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
989
	down_write(&cinode->lock_sem);
990
	list_add_tail(&lock->llist, &cfile->llist->locks);
991
	up_write(&cinode->lock_sem);
J
[CIFS]  
Jeremy Allison 已提交
992 993
}

994 995 996 997 998 999
/*
 * 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.
 */
1000
static int
1001
cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
1002
		 bool wait)
1003
{
1004
	struct cifsLockInfo *conf_lock;
1005
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1006 1007 1008 1009 1010
	bool exist;
	int rc = 0;

try_again:
	exist = false;
1011
	down_write(&cinode->lock_sem);
1012

1013
	exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
1014
					lock->type, &conf_lock, CIFS_LOCK_OP);
1015
	if (!exist && cinode->can_cache_brlcks) {
1016
		list_add_tail(&lock->llist, &cfile->llist->locks);
1017
		up_write(&cinode->lock_sem);
1018 1019 1020 1021 1022 1023 1024 1025 1026
		return rc;
	}

	if (!exist)
		rc = 1;
	else if (!wait)
		rc = -EACCES;
	else {
		list_add_tail(&lock->blist, &conf_lock->blist);
1027
		up_write(&cinode->lock_sem);
1028 1029 1030 1031 1032
		rc = wait_event_interruptible(lock->block_q,
					(lock->blist.prev == &lock->blist) &&
					(lock->blist.next == &lock->blist));
		if (!rc)
			goto try_again;
1033
		down_write(&cinode->lock_sem);
1034
		list_del_init(&lock->blist);
1035 1036
	}

1037
	up_write(&cinode->lock_sem);
1038 1039 1040
	return rc;
}

1041 1042 1043 1044 1045 1046 1047
/*
 * 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.
 */
1048
static int
1049 1050 1051
cifs_posix_lock_test(struct file *file, struct file_lock *flock)
{
	int rc = 0;
A
Al Viro 已提交
1052
	struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1053 1054
	unsigned char saved_type = flock->fl_type;

1055 1056 1057
	if ((flock->fl_flags & FL_POSIX) == 0)
		return 1;

1058
	down_read(&cinode->lock_sem);
1059 1060 1061 1062 1063 1064 1065
	posix_test_lock(file, flock);

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

1066
	up_read(&cinode->lock_sem);
1067 1068 1069
	return rc;
}

1070 1071 1072 1073 1074 1075
/*
 * 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.
 */
1076 1077 1078
static int
cifs_posix_lock_set(struct file *file, struct file_lock *flock)
{
A
Al Viro 已提交
1079
	struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1080 1081 1082 1083
	int rc = 1;

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

1085
try_again:
1086
	down_write(&cinode->lock_sem);
1087
	if (!cinode->can_cache_brlcks) {
1088
		up_write(&cinode->lock_sem);
1089
		return rc;
1090
	}
1091 1092

	rc = posix_lock_file(file, flock, NULL);
1093
	up_write(&cinode->lock_sem);
1094 1095 1096 1097
	if (rc == FILE_LOCK_DEFERRED) {
		rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
		if (!rc)
			goto try_again;
1098
		posix_unblock_lock(flock);
1099
	}
1100
	return rc;
1101 1102
}

1103
int
1104
cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1105
{
1106 1107
	unsigned int xid;
	int rc = 0, stored_rc;
1108 1109
	struct cifsLockInfo *li, *tmp;
	struct cifs_tcon *tcon;
1110
	unsigned int num, max_num, max_buf;
1111
	LOCKING_ANDX_RANGE *buf, *cur;
1112 1113 1114 1115
	static const int types[] = {
		LOCKING_ANDX_LARGE_FILES,
		LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
	};
1116
	int i;
1117

1118
	xid = get_xid();
1119 1120
	tcon = tlink_tcon(cfile->tlink);

1121 1122
	/*
	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1123
	 * and check it before using.
1124 1125
	 */
	max_buf = tcon->ses->server->maxBuf;
1126
	if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) {
1127
		free_xid(xid);
1128 1129 1130
		return -EINVAL;
	}

1131 1132 1133 1134
	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);
1135 1136
	max_num = (max_buf - sizeof(struct smb_hdr)) /
						sizeof(LOCKING_ANDX_RANGE);
1137
	buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1138
	if (!buf) {
1139
		free_xid(xid);
1140
		return -ENOMEM;
1141 1142 1143 1144 1145
	}

	for (i = 0; i < 2; i++) {
		cur = buf;
		num = 0;
1146
		list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1147 1148 1149 1150 1151 1152 1153 1154
			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) {
1155 1156
				stored_rc = cifs_lockv(xid, tcon,
						       cfile->fid.netfid,
1157 1158
						       (__u8)li->type, 0, num,
						       buf);
1159 1160 1161 1162 1163 1164 1165 1166 1167
				if (stored_rc)
					rc = stored_rc;
				cur = buf;
				num = 0;
			} else
				cur++;
		}

		if (num) {
1168
			stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1169
					       (__u8)types[i], 0, num, buf);
1170 1171 1172
			if (stored_rc)
				rc = stored_rc;
		}
1173 1174
	}

1175
	kfree(buf);
1176
	free_xid(xid);
1177 1178 1179
	return rc;
}

1180 1181 1182 1183 1184 1185
static __u32
hash_lockowner(fl_owner_t owner)
{
	return cifs_lock_secret ^ hash32_ptr((const void *)owner);
}

1186 1187 1188 1189 1190 1191 1192 1193 1194
struct lock_to_push {
	struct list_head llist;
	__u64 offset;
	__u64 length;
	__u32 pid;
	__u16 netfid;
	__u8 type;
};

1195
static int
1196
cifs_push_posix_locks(struct cifsFileInfo *cfile)
1197
{
1198
	struct inode *inode = d_inode(cfile->dentry);
1199
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1200 1201
	struct file_lock *flock;
	struct file_lock_context *flctx = inode->i_flctx;
1202
	unsigned int count = 0, i;
1203
	int rc = 0, xid, type;
1204 1205
	struct list_head locks_to_send, *el;
	struct lock_to_push *lck, *tmp;
1206 1207
	__u64 length;

1208
	xid = get_xid();
1209

1210 1211
	if (!flctx)
		goto out;
1212

1213 1214 1215 1216 1217 1218
	spin_lock(&flctx->flc_lock);
	list_for_each(el, &flctx->flc_posix) {
		count++;
	}
	spin_unlock(&flctx->flc_lock);

1219 1220
	INIT_LIST_HEAD(&locks_to_send);

1221
	/*
1222 1223
	 * Allocating count locks is enough because no FL_POSIX locks can be
	 * added to the list while we are holding cinode->lock_sem that
1224
	 * protects locking operations of this inode.
1225
	 */
1226
	for (i = 0; i < count; i++) {
1227 1228 1229 1230 1231 1232 1233 1234 1235
		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;
1236
	spin_lock(&flctx->flc_lock);
1237
	list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
1238
		if (el == &locks_to_send) {
1239 1240 1241 1242
			/*
			 * The list ended. We don't have enough allocated
			 * structures - something is really wrong.
			 */
1243
			cifs_dbg(VFS, "Can't push all brlocks!\n");
1244 1245
			break;
		}
1246 1247 1248 1249 1250
		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;
1251
		lck = list_entry(el, struct lock_to_push, llist);
1252
		lck->pid = hash_lockowner(flock->fl_owner);
1253
		lck->netfid = cfile->fid.netfid;
1254 1255 1256
		lck->length = length;
		lck->type = type;
		lck->offset = flock->fl_start;
1257
	}
1258
	spin_unlock(&flctx->flc_lock);
1259 1260 1261 1262 1263

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

		stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1264
					     lck->offset, lck->length, NULL,
1265 1266 1267 1268 1269 1270 1271
					     lck->type, 0);
		if (stored_rc)
			rc = stored_rc;
		list_del(&lck->llist);
		kfree(lck);
	}

1272
out:
1273
	free_xid(xid);
1274
	return rc;
1275 1276 1277 1278 1279 1280
err_out:
	list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
		list_del(&lck->llist);
		kfree(lck);
	}
	goto out;
1281 1282
}

1283
static int
1284
cifs_push_locks(struct cifsFileInfo *cfile)
1285
{
1286
	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1287
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1288
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1289 1290 1291 1292 1293 1294 1295 1296
	int rc = 0;

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

1298
	if (cap_unix(tcon->ses) &&
1299 1300
	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1301 1302 1303
		rc = cifs_push_posix_locks(cfile);
	else
		rc = tcon->ses->server->ops->push_mand_locks(cfile);
1304

1305 1306 1307
	cinode->can_cache_brlcks = false;
	up_write(&cinode->lock_sem);
	return rc;
1308 1309
}

1310
static void
1311
cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1312
		bool *wait_flag, struct TCP_Server_Info *server)
L
Linus Torvalds 已提交
1313
{
1314
	if (flock->fl_flags & FL_POSIX)
1315
		cifs_dbg(FYI, "Posix\n");
1316
	if (flock->fl_flags & FL_FLOCK)
1317
		cifs_dbg(FYI, "Flock\n");
1318
	if (flock->fl_flags & FL_SLEEP) {
1319
		cifs_dbg(FYI, "Blocking lock\n");
1320
		*wait_flag = true;
L
Linus Torvalds 已提交
1321
	}
1322
	if (flock->fl_flags & FL_ACCESS)
1323
		cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1324
	if (flock->fl_flags & FL_LEASE)
1325
		cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1326
	if (flock->fl_flags &
1327 1328
	    (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
	       FL_ACCESS | FL_LEASE | FL_CLOSE)))
1329
		cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
L
Linus Torvalds 已提交
1330

1331
	*type = server->vals->large_lock_type;
1332
	if (flock->fl_type == F_WRLCK) {
1333
		cifs_dbg(FYI, "F_WRLCK\n");
1334
		*type |= server->vals->exclusive_lock_type;
1335 1336
		*lock = 1;
	} else if (flock->fl_type == F_UNLCK) {
1337
		cifs_dbg(FYI, "F_UNLCK\n");
1338
		*type |= server->vals->unlock_lock_type;
1339 1340 1341
		*unlock = 1;
		/* Check if unlock includes more than one lock range */
	} else if (flock->fl_type == F_RDLCK) {
1342
		cifs_dbg(FYI, "F_RDLCK\n");
1343
		*type |= server->vals->shared_lock_type;
1344 1345
		*lock = 1;
	} else if (flock->fl_type == F_EXLCK) {
1346
		cifs_dbg(FYI, "F_EXLCK\n");
1347
		*type |= server->vals->exclusive_lock_type;
1348 1349
		*lock = 1;
	} else if (flock->fl_type == F_SHLCK) {
1350
		cifs_dbg(FYI, "F_SHLCK\n");
1351
		*type |= server->vals->shared_lock_type;
1352
		*lock = 1;
L
Linus Torvalds 已提交
1353
	} else
1354
		cifs_dbg(FYI, "Unknown type of lock\n");
1355
}
L
Linus Torvalds 已提交
1356

1357
static int
1358
cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1359
	   bool wait_flag, bool posix_lck, unsigned int xid)
1360 1361 1362
{
	int rc = 0;
	__u64 length = 1 + flock->fl_end - flock->fl_start;
1363 1364
	struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1365
	struct TCP_Server_Info *server = tcon->ses->server;
1366
	__u16 netfid = cfile->fid.netfid;
1367

1368 1369
	if (posix_lck) {
		int posix_lock_type;
1370 1371 1372 1373 1374

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

1375
		if (type & server->vals->shared_lock_type)
1376 1377 1378
			posix_lock_type = CIFS_RDLCK;
		else
			posix_lock_type = CIFS_WRLCK;
1379 1380
		rc = CIFSSMBPosixLock(xid, tcon, netfid,
				      hash_lockowner(flock->fl_owner),
1381
				      flock->fl_start, length, flock,
1382
				      posix_lock_type, wait_flag);
1383 1384
		return rc;
	}
L
Linus Torvalds 已提交
1385

1386
	rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1387 1388 1389
	if (!rc)
		return rc;

1390
	/* BB we could chain these into one lock request BB */
1391 1392
	rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
				    1, 0, false);
1393
	if (rc == 0) {
1394 1395
		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
					    type, 0, 1, false);
1396 1397
		flock->fl_type = F_UNLCK;
		if (rc != 0)
1398 1399
			cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
				 rc);
1400
		return 0;
L
Linus Torvalds 已提交
1401
	}
J
[CIFS]  
Jeremy Allison 已提交
1402

1403
	if (type & server->vals->shared_lock_type) {
1404
		flock->fl_type = F_WRLCK;
1405
		return 0;
J
[CIFS]  
Jeremy Allison 已提交
1406 1407
	}

1408 1409 1410 1411 1412
	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);
1413
	if (rc == 0) {
1414 1415
		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
			type | server->vals->shared_lock_type, 0, 1, false);
1416 1417
		flock->fl_type = F_RDLCK;
		if (rc != 0)
1418 1419
			cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
				 rc);
1420 1421 1422
	} else
		flock->fl_type = F_WRLCK;

1423
	return 0;
1424 1425
}

1426
void
1427 1428 1429 1430 1431 1432 1433
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);
}

1434
void
1435 1436 1437 1438 1439 1440 1441 1442 1443 1444
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);
	}
}

1445
int
1446 1447
cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
		  unsigned int xid)
1448 1449
{
	int rc = 0, stored_rc;
1450 1451 1452 1453
	static const int types[] = {
		LOCKING_ANDX_LARGE_FILES,
		LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
	};
1454
	unsigned int i;
1455
	unsigned int max_num, num, max_buf;
1456 1457
	LOCKING_ANDX_RANGE *buf, *cur;
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1458
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1459 1460 1461 1462 1463 1464
	struct cifsLockInfo *li, *tmp;
	__u64 length = 1 + flock->fl_end - flock->fl_start;
	struct list_head tmp_llist;

	INIT_LIST_HEAD(&tmp_llist);

1465 1466
	/*
	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1467
	 * and check it before using.
1468 1469
	 */
	max_buf = tcon->ses->server->maxBuf;
1470
	if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE)))
1471 1472
		return -EINVAL;

1473 1474 1475 1476
	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);
1477 1478
	max_num = (max_buf - sizeof(struct smb_hdr)) /
						sizeof(LOCKING_ANDX_RANGE);
1479
	buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1480 1481 1482
	if (!buf)
		return -ENOMEM;

1483
	down_write(&cinode->lock_sem);
1484 1485 1486
	for (i = 0; i < 2; i++) {
		cur = buf;
		num = 0;
1487
		list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1488 1489 1490 1491 1492 1493 1494 1495
			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;
1496
			if (cinode->can_cache_brlcks) {
1497 1498
				/*
				 * We can cache brlock requests - simply remove
1499
				 * a lock from the file's list.
1500 1501 1502 1503
				 */
				list_del(&li->llist);
				cifs_del_lock_waiters(li);
				kfree(li);
1504
				continue;
1505
			}
1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517
			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) {
1518 1519
				stored_rc = cifs_lockv(xid, tcon,
						       cfile->fid.netfid,
1520 1521 1522 1523 1524 1525 1526 1527
						       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,
1528
							&cfile->llist->locks);
1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539
					rc = stored_rc;
				} else
					/*
					 * The unlock range request succeed -
					 * free the tmp list.
					 */
					cifs_free_llist(&tmp_llist);
				cur = buf;
				num = 0;
			} else
				cur++;
1540 1541
		}
		if (num) {
1542
			stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1543 1544
					       types[i], num, 0, buf);
			if (stored_rc) {
1545 1546
				cifs_move_llist(&tmp_llist,
						&cfile->llist->locks);
1547 1548 1549 1550 1551 1552
				rc = stored_rc;
			} else
				cifs_free_llist(&tmp_llist);
		}
	}

1553
	up_write(&cinode->lock_sem);
1554 1555 1556 1557
	kfree(buf);
	return rc;
}

1558
static int
1559
cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1560 1561
	   bool wait_flag, bool posix_lck, int lock, int unlock,
	   unsigned int xid)
1562 1563 1564 1565 1566
{
	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);
1567
	struct TCP_Server_Info *server = tcon->ses->server;
1568
	struct inode *inode = d_inode(cfile->dentry);
1569 1570

	if (posix_lck) {
1571
		int posix_lock_type;
1572 1573 1574 1575 1576

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

1577
		if (type & server->vals->shared_lock_type)
1578 1579 1580
			posix_lock_type = CIFS_RDLCK;
		else
			posix_lock_type = CIFS_WRLCK;
1581

1582
		if (unlock == 1)
1583
			posix_lock_type = CIFS_UNLCK;
J
[CIFS]  
Jeremy Allison 已提交
1584

1585
		rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1586 1587
				      hash_lockowner(flock->fl_owner),
				      flock->fl_start, length,
1588
				      NULL, posix_lock_type, wait_flag);
1589 1590
		goto out;
	}
J
[CIFS]  
Jeremy Allison 已提交
1591

1592
	if (lock) {
1593 1594
		struct cifsLockInfo *lock;

1595
		lock = cifs_lock_init(flock->fl_start, length, type);
1596 1597 1598
		if (!lock)
			return -ENOMEM;

1599
		rc = cifs_lock_add_if(cfile, lock, wait_flag);
1600
		if (rc < 0) {
1601
			kfree(lock);
1602 1603 1604
			return rc;
		}
		if (!rc)
1605 1606
			goto out;

1607 1608 1609 1610 1611 1612 1613
		/*
		 * 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.
		 */
1614 1615
		if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
					CIFS_CACHE_READ(CIFS_I(inode))) {
1616
			cifs_zap_mapping(inode);
1617 1618
			cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
				 inode);
1619
			CIFS_I(inode)->oplock = 0;
1620 1621
		}

1622 1623
		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
					    type, 1, 0, wait_flag);
1624 1625
		if (rc) {
			kfree(lock);
1626
			return rc;
1627
		}
1628

1629
		cifs_lock_add(cfile, lock);
1630
	} else if (unlock)
1631
		rc = server->ops->mand_unlock_range(cfile, flock, xid);
1632 1633

out:
1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645
	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;
		}
1646
		rc = locks_lock_file_wait(file, flock);
1647
	}
1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661
	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;
1662
	__u32 type;
1663 1664

	rc = -EACCES;
1665
	xid = get_xid();
1666

1667 1668 1669
	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);
1670 1671 1672

	cfile = (struct cifsFileInfo *)file->private_data;
	tcon = tlink_tcon(cfile->tlink);
1673 1674 1675 1676

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

1677
	cifs_sb = CIFS_FILE_SB(file);
1678
	netfid = cfile->fid.netfid;
A
Al Viro 已提交
1679
	cinode = CIFS_I(file_inode(file));
1680

1681
	if (cap_unix(tcon->ses) &&
1682 1683 1684 1685 1686 1687 1688 1689
	    (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)) {
1690
		rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1691
		free_xid(xid);
1692 1693 1694 1695 1696 1697 1698 1699
		return rc;
	}

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

1704 1705
	rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
			xid);
1706
	free_xid(xid);
L
Linus Torvalds 已提交
1707 1708 1709
	return rc;
}

1710 1711 1712 1713
/*
 * update the file size (if needed) after a write. Should be called with
 * the inode->i_lock held
 */
1714
void
1715 1716 1717 1718 1719 1720 1721 1722 1723
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;
}

1724 1725 1726
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 已提交
1727 1728 1729 1730 1731
{
	int rc = 0;
	unsigned int bytes_written = 0;
	unsigned int total_written;
	struct cifs_sb_info *cifs_sb;
1732 1733
	struct cifs_tcon *tcon;
	struct TCP_Server_Info *server;
1734
	unsigned int xid;
1735
	struct dentry *dentry = open_file->dentry;
1736
	struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
1737
	struct cifs_io_parms io_parms;
L
Linus Torvalds 已提交
1738

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

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

1744 1745 1746 1747 1748
	tcon = tlink_tcon(open_file->tlink);
	server = tcon->ses->server;

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

1750
	xid = get_xid();
L
Linus Torvalds 已提交
1751 1752 1753 1754 1755

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

L
Linus Torvalds 已提交
1759 1760 1761
			if (open_file->invalidHandle) {
				/* we could deadlock if we called
				   filemap_fdatawait from here so tell
S
Steve French 已提交
1762
				   reopen_file not to flush data to
L
Linus Torvalds 已提交
1763
				   server now */
J
Jeff Layton 已提交
1764
				rc = cifs_reopen_file(open_file, false);
L
Linus Torvalds 已提交
1765 1766 1767
				if (rc != 0)
					break;
			}
1768

1769
			len = min(server->ops->wp_retry_size(d_inode(dentry)),
1770
				  (unsigned int)write_size - total_written);
1771 1772 1773
			/* iov[0] is reserved for smb header */
			iov[1].iov_base = (char *)write_data + total_written;
			iov[1].iov_len = len;
1774
			io_parms.pid = pid;
1775 1776
			io_parms.tcon = tcon;
			io_parms.offset = *offset;
1777
			io_parms.length = len;
1778 1779
			rc = server->ops->sync_write(xid, &open_file->fid,
					&io_parms, &bytes_written, iov, 1);
L
Linus Torvalds 已提交
1780 1781 1782 1783 1784
		}
		if (rc || (bytes_written == 0)) {
			if (total_written)
				break;
			else {
1785
				free_xid(xid);
L
Linus Torvalds 已提交
1786 1787
				return rc;
			}
1788
		} else {
1789
			spin_lock(&d_inode(dentry)->i_lock);
1790
			cifs_update_eof(cifsi, *offset, bytes_written);
1791
			spin_unlock(&d_inode(dentry)->i_lock);
1792
			*offset += bytes_written;
1793
		}
L
Linus Torvalds 已提交
1794 1795
	}

1796
	cifs_stats_bytes_written(tcon, total_written);
L
Linus Torvalds 已提交
1797

1798
	if (total_written > 0) {
1799 1800 1801 1802
		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 已提交
1803
	}
1804
	mark_inode_dirty_sync(d_inode(dentry));
1805
	free_xid(xid);
L
Linus Torvalds 已提交
1806 1807 1808
	return total_written;
}

1809 1810
struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
					bool fsuid_only)
S
Steve French 已提交
1811 1812
{
	struct cifsFileInfo *open_file = NULL;
1813
	struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1814
	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1815 1816 1817 1818

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

1820
	spin_lock(&tcon->open_file_lock);
S
Steve French 已提交
1821 1822 1823 1824
	/* 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) {
1825
		if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1826
			continue;
1827
		if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
S
Steve French 已提交
1828 1829 1830
			if (!open_file->invalidHandle) {
				/* found a good file */
				/* lock it so it will not be closed on us */
1831 1832
				cifsFileInfo_get(open_file);
				spin_unlock(&tcon->open_file_lock);
S
Steve French 已提交
1833 1834 1835 1836 1837 1838 1839
				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 */
	}
1840
	spin_unlock(&tcon->open_file_lock);
S
Steve French 已提交
1841 1842 1843
	return NULL;
}

1844 1845
struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
					bool fsuid_only)
1846
{
1847
	struct cifsFileInfo *open_file, *inv_file = NULL;
1848
	struct cifs_sb_info *cifs_sb;
1849
	struct cifs_tcon *tcon;
1850
	bool any_available = false;
1851
	int rc;
1852
	unsigned int refind = 0;
1853

1854 1855 1856 1857
	/* 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 已提交
1858
	if (cifs_inode == NULL) {
1859
		cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1860 1861 1862 1863
		dump_stack();
		return NULL;
	}

1864
	cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1865
	tcon = cifs_sb_master_tcon(cifs_sb);
1866

1867 1868 1869 1870
	/* only filter by fsuid on multiuser mounts */
	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
		fsuid_only = false;

1871
	spin_lock(&tcon->open_file_lock);
1872
refind_writable:
1873
	if (refind > MAX_REOPEN_ATT) {
1874
		spin_unlock(&tcon->open_file_lock);
1875 1876
		return NULL;
	}
1877
	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1878 1879
		if (!any_available && open_file->pid != current->tgid)
			continue;
1880
		if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1881
			continue;
1882
		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1883 1884
			if (!open_file->invalidHandle) {
				/* found a good writable file */
1885 1886
				cifsFileInfo_get(open_file);
				spin_unlock(&tcon->open_file_lock);
1887
				return open_file;
1888 1889 1890
			} else {
				if (!inv_file)
					inv_file = open_file;
1891
			}
1892 1893
		}
	}
1894 1895 1896 1897 1898
	/* couldn't find useable FH with same pid, try any available */
	if (!any_available) {
		any_available = true;
		goto refind_writable;
	}
1899 1900 1901

	if (inv_file) {
		any_available = false;
1902
		cifsFileInfo_get(inv_file);
1903 1904
	}

1905
	spin_unlock(&tcon->open_file_lock);
1906 1907 1908 1909 1910 1911

	if (inv_file) {
		rc = cifs_reopen_file(inv_file, false);
		if (!rc)
			return inv_file;
		else {
1912
			spin_lock(&tcon->open_file_lock);
1913 1914
			list_move_tail(&inv_file->flist,
					&cifs_inode->openFileList);
1915
			spin_unlock(&tcon->open_file_lock);
1916 1917
			cifsFileInfo_put(inv_file);
			++refind;
1918
			inv_file = NULL;
1919
			spin_lock(&tcon->open_file_lock);
1920 1921 1922 1923
			goto refind_writable;
		}
	}

1924 1925 1926
	return NULL;
}

L
Linus Torvalds 已提交
1927 1928 1929
static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
{
	struct address_space *mapping = page->mapping;
1930
	loff_t offset = (loff_t)page->index << PAGE_SHIFT;
L
Linus Torvalds 已提交
1931 1932 1933 1934
	char *write_data;
	int rc = -EFAULT;
	int bytes_written = 0;
	struct inode *inode;
1935
	struct cifsFileInfo *open_file;
L
Linus Torvalds 已提交
1936 1937 1938 1939 1940 1941 1942 1943 1944 1945

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

	inode = page->mapping->host;

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

1946
	if ((to > PAGE_SIZE) || (from > to)) {
L
Linus Torvalds 已提交
1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958
		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 已提交
1959
		to = (unsigned)(mapping->host->i_size - offset);
L
Linus Torvalds 已提交
1960

1961
	open_file = find_writable_file(CIFS_I(mapping->host), false);
1962
	if (open_file) {
1963 1964
		bytes_written = cifs_write(open_file, open_file->pid,
					   write_data, to - from, &offset);
1965
		cifsFileInfo_put(open_file);
L
Linus Torvalds 已提交
1966
		/* Does mm or vfs already set times? */
1967
		inode->i_atime = inode->i_mtime = current_time(inode);
1968
		if ((bytes_written > 0) && (offset))
1969
			rc = 0;
1970 1971
		else if (bytes_written < 0)
			rc = bytes_written;
1972
	} else {
1973
		cifs_dbg(FYI, "No writeable filehandles for inode\n");
L
Linus Torvalds 已提交
1974 1975 1976 1977 1978 1979 1980
		rc = -EIO;
	}

	kunmap(page);
	return rc;
}

1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992
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 已提交
1993 1994
	*found_pages = find_get_pages_range_tag(mapping, index, end,
				PAGECACHE_TAG_DIRTY, tofind, wdata->pages);
1995 1996 1997
	return wdata;
}

1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009
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 已提交
2010 2011 2012 2013
		 * 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
2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069
		 */

		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++) {
2070
		put_page(wdata->pages[i]);
2071 2072 2073 2074 2075 2076
		wdata->pages[i] = NULL;
	}

	return nr_pages;
}

2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087
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]);
2088
	wdata->pagesz = PAGE_SIZE;
2089 2090
	wdata->tailsz = min(i_size_read(mapping->host) -
			page_offset(wdata->pages[nr_pages - 1]),
2091 2092
			(loff_t)PAGE_SIZE);
	wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2093

2094 2095 2096 2097 2098 2099 2100
	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 {
2101 2102 2103
		wdata->pid = wdata->cfile->pid;
		server = tlink_tcon(wdata->cfile->tlink)->ses->server;
		rc = server->ops->async_writev(wdata, cifs_writedata_release);
2104
	}
2105 2106 2107 2108 2109 2110 2111

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

	return rc;
}

L
Linus Torvalds 已提交
2112
static int cifs_writepages(struct address_space *mapping,
2113
			   struct writeback_control *wbc)
L
Linus Torvalds 已提交
2114
{
2115
	struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
2116
	struct TCP_Server_Info *server;
2117 2118 2119
	bool done = false, scanned = false, range_whole = false;
	pgoff_t end, index;
	struct cifs_writedata *wdata;
2120
	int rc = 0;
2121

2122
	/*
2123
	 * If wsize is smaller than the page cache size, default to writing
2124 2125
	 * one page at a time via cifs_writepage
	 */
2126
	if (cifs_sb->wsize < PAGE_SIZE)
2127 2128
		return generic_writepages(mapping, wbc);

2129
	if (wbc->range_cyclic) {
2130
		index = mapping->writeback_index; /* Start from prev offset */
2131 2132
		end = -1;
	} else {
2133 2134
		index = wbc->range_start >> PAGE_SHIFT;
		end = wbc->range_end >> PAGE_SHIFT;
2135
		if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2136 2137
			range_whole = true;
		scanned = true;
2138
	}
2139
	server = cifs_sb_master_tcon(cifs_sb)->ses->server;
2140
retry:
2141
	while (!done && index <= end) {
2142
		unsigned int i, nr_pages, found_pages, wsize, credits;
2143
		pgoff_t next = 0, tofind, saved_index = index;
2144

2145 2146 2147 2148
		rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
						   &wsize, &credits);
		if (rc)
			break;
2149

2150
		tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2151

2152 2153
		wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
						  &found_pages);
2154 2155
		if (!wdata) {
			rc = -ENOMEM;
2156
			add_credits_and_wake_if(server, credits, 0);
2157 2158 2159 2160 2161
			break;
		}

		if (found_pages == 0) {
			kref_put(&wdata->refcount, cifs_writedata_release);
2162
			add_credits_and_wake_if(server, credits, 0);
2163 2164 2165
			break;
		}

2166 2167
		nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
					       end, &index, &next, &done);
2168

2169 2170 2171
		/* nothing to write? */
		if (nr_pages == 0) {
			kref_put(&wdata->refcount, cifs_writedata_release);
2172
			add_credits_and_wake_if(server, credits, 0);
2173
			continue;
2174
		}
2175

2176
		wdata->credits = credits;
2177

2178
		rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2179

2180 2181
		/* send failure -- clean up the mess */
		if (rc != 0) {
2182
			add_credits_and_wake_if(server, wdata->credits, 0);
2183
			for (i = 0; i < nr_pages; ++i) {
2184
				if (rc == -EAGAIN)
2185 2186 2187 2188 2189
					redirty_page_for_writepage(wbc,
							   wdata->pages[i]);
				else
					SetPageError(wdata->pages[i]);
				end_page_writeback(wdata->pages[i]);
2190
				put_page(wdata->pages[i]);
2191
			}
2192 2193
			if (rc != -EAGAIN)
				mapping_set_error(mapping, rc);
2194 2195
		}
		kref_put(&wdata->refcount, cifs_writedata_release);
2196

2197 2198 2199 2200 2201
		if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
			index = saved_index;
			continue;
		}

2202 2203 2204
		wbc->nr_to_write -= nr_pages;
		if (wbc->nr_to_write <= 0)
			done = true;
2205

2206
		index = next;
2207
	}
2208

2209 2210 2211 2212 2213
	if (!scanned && !done) {
		/*
		 * We hit the last page and there is more work to be done: wrap
		 * back to the start of the file
		 */
2214
		scanned = true;
2215 2216 2217
		index = 0;
		goto retry;
	}
2218

2219
	if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2220 2221
		mapping->writeback_index = index;

L
Linus Torvalds 已提交
2222 2223 2224
	return rc;
}

2225 2226
static int
cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
L
Linus Torvalds 已提交
2227
{
2228
	int rc;
2229
	unsigned int xid;
L
Linus Torvalds 已提交
2230

2231
	xid = get_xid();
L
Linus Torvalds 已提交
2232
/* BB add check for wbc flags */
2233
	get_page(page);
S
Steve French 已提交
2234
	if (!PageUptodate(page))
2235
		cifs_dbg(FYI, "ppw - page not up to date\n");
2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246

	/*
	 * 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 已提交
2247
	set_page_writeback(page);
2248
retry_write:
2249
	rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2250 2251 2252
	if (rc == -EAGAIN) {
		if (wbc->sync_mode == WB_SYNC_ALL)
			goto retry_write;
2253
		redirty_page_for_writepage(wbc, page);
2254
	} else if (rc != 0) {
2255
		SetPageError(page);
2256 2257
		mapping_set_error(page->mapping, rc);
	} else {
2258
		SetPageUptodate(page);
2259
	}
2260
	end_page_writeback(page);
2261
	put_page(page);
2262
	free_xid(xid);
L
Linus Torvalds 已提交
2263 2264 2265
	return rc;
}

2266 2267 2268 2269 2270 2271 2272
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 已提交
2273 2274 2275
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 已提交
2276
{
N
Nick Piggin 已提交
2277 2278
	int rc;
	struct inode *inode = mapping->host;
2279 2280 2281 2282 2283 2284 2285 2286
	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 已提交
2287

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

2291 2292 2293 2294
	if (PageChecked(page)) {
		if (copied == len)
			SetPageUptodate(page);
		ClearPageChecked(page);
2295
	} else if (!PageUptodate(page) && copied == PAGE_SIZE)
N
Nick Piggin 已提交
2296
		SetPageUptodate(page);
S
Steve French 已提交
2297

L
Linus Torvalds 已提交
2298
	if (!PageUptodate(page)) {
N
Nick Piggin 已提交
2299
		char *page_data;
2300
		unsigned offset = pos & (PAGE_SIZE - 1);
2301
		unsigned int xid;
N
Nick Piggin 已提交
2302

2303
		xid = get_xid();
L
Linus Torvalds 已提交
2304 2305 2306 2307 2308 2309
		/* 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);
2310
		rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
N
Nick Piggin 已提交
2311
		/* if (rc < 0) should we set writebehind rc? */
L
Linus Torvalds 已提交
2312
		kunmap(page);
N
Nick Piggin 已提交
2313

2314
		free_xid(xid);
S
Steve French 已提交
2315
	} else {
N
Nick Piggin 已提交
2316 2317
		rc = copied;
		pos += copied;
2318
		set_page_dirty(page);
L
Linus Torvalds 已提交
2319 2320
	}

N
Nick Piggin 已提交
2321 2322 2323 2324 2325 2326 2327 2328
	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);
2329
	put_page(page);
N
Nick Piggin 已提交
2330

L
Linus Torvalds 已提交
2331 2332 2333
	return rc;
}

2334 2335
int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
		      int datasync)
L
Linus Torvalds 已提交
2336
{
2337
	unsigned int xid;
L
Linus Torvalds 已提交
2338
	int rc = 0;
2339
	struct cifs_tcon *tcon;
2340
	struct TCP_Server_Info *server;
2341
	struct cifsFileInfo *smbfile = file->private_data;
A
Al Viro 已提交
2342
	struct inode *inode = file_inode(file);
2343
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
L
Linus Torvalds 已提交
2344

2345
	rc = file_write_and_wait_range(file, start, end);
2346 2347
	if (rc)
		return rc;
A
Al Viro 已提交
2348
	inode_lock(inode);
2349

2350
	xid = get_xid();
L
Linus Torvalds 已提交
2351

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

2355
	if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2356
		rc = cifs_zap_mapping(inode);
2357
		if (rc) {
2358
			cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2359 2360 2361
			rc = 0; /* don't care about it in fsync */
		}
	}
2362

2363
	tcon = tlink_tcon(smbfile->tlink);
2364 2365 2366 2367 2368 2369 2370
	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;
	}
2371

2372
	free_xid(xid);
A
Al Viro 已提交
2373
	inode_unlock(inode);
2374 2375 2376
	return rc;
}

2377
int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2378
{
2379
	unsigned int xid;
2380
	int rc = 0;
2381
	struct cifs_tcon *tcon;
2382
	struct TCP_Server_Info *server;
2383
	struct cifsFileInfo *smbfile = file->private_data;
2384
	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2385 2386
	struct inode *inode = file->f_mapping->host;

2387
	rc = file_write_and_wait_range(file, start, end);
2388 2389
	if (rc)
		return rc;
A
Al Viro 已提交
2390
	inode_lock(inode);
2391

2392
	xid = get_xid();
2393

A
Al Viro 已提交
2394 2395
	cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
		 file, datasync);
2396 2397

	tcon = tlink_tcon(smbfile->tlink);
2398 2399 2400 2401 2402 2403 2404
	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;
	}
2405

2406
	free_xid(xid);
A
Al Viro 已提交
2407
	inode_unlock(inode);
L
Linus Torvalds 已提交
2408 2409 2410 2411 2412 2413 2414
	return rc;
}

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

2420
	if (file->f_mode & FMODE_WRITE)
2421
		rc = filemap_write_and_wait(inode->i_mapping);
2422

2423
	cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
L
Linus Torvalds 已提交
2424 2425 2426 2427

	return rc;
}

2428 2429 2430 2431 2432 2433 2434
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++) {
2435
		pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2436 2437 2438 2439 2440 2441 2442
		if (!pages[i]) {
			/*
			 * save number of pages we have already allocated and
			 * return with ENOMEM error
			 */
			num_pages = i;
			rc = -ENOMEM;
2443
			break;
2444 2445 2446
		}
	}

2447 2448 2449 2450
	if (rc) {
		for (i = 0; i < num_pages; i++)
			put_page(pages[i]);
	}
2451 2452 2453 2454 2455 2456 2457 2458 2459 2460
	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 已提交
2461
	num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2462 2463 2464 2465 2466 2467 2468

	if (cur_len)
		*cur_len = clen;

	return num_pages;
}

2469
static void
2470
cifs_uncached_writedata_release(struct kref *refcount)
2471 2472
{
	int i;
2473 2474 2475
	struct cifs_writedata *wdata = container_of(refcount,
					struct cifs_writedata, refcount);

2476
	kref_put(&wdata->ctx->refcount, cifs_aio_ctx_release);
2477 2478 2479 2480 2481
	for (i = 0; i < wdata->nr_pages; i++)
		put_page(wdata->pages[i]);
	cifs_writedata_release(refcount);
}

2482 2483
static void collect_uncached_write_data(struct cifs_aio_ctx *ctx);

2484 2485 2486
static void
cifs_uncached_writev_complete(struct work_struct *work)
{
2487 2488
	struct cifs_writedata *wdata = container_of(work,
					struct cifs_writedata, work);
2489
	struct inode *inode = d_inode(wdata->cfile->dentry);
2490 2491 2492 2493 2494 2495 2496 2497 2498
	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);
2499 2500
	collect_uncached_write_data(wdata->ctx);
	/* the below call can possibly free the last ref to aio ctx */
2501
	kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2502 2503 2504
}

static int
2505 2506
wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
		      size_t *len, unsigned long *num_pages)
2507
{
2508 2509
	size_t save_len, copied, bytes, cur_len = *len;
	unsigned long i, nr_pages = *num_pages;
2510

2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527
	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;
2528

2529 2530 2531 2532 2533 2534 2535 2536
	/*
	 * 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;
2537

2538 2539 2540 2541 2542 2543
	/*
	 * i + 1 now represents the number of pages we actually used in
	 * the copy phase above.
	 */
	*num_pages = i + 1;
	return 0;
2544 2545
}

2546 2547 2548
static int
cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
		     struct cifsFileInfo *open_file,
2549 2550
		     struct cifs_sb_info *cifs_sb, struct list_head *wdata_list,
		     struct cifs_aio_ctx *ctx)
2551
{
2552 2553
	int rc = 0;
	size_t cur_len;
2554
	unsigned long nr_pages, num_pages, i;
2555
	struct cifs_writedata *wdata;
2556
	struct iov_iter saved_from = *from;
2557
	loff_t saved_offset = offset;
2558
	pid_t pid;
2559
	struct TCP_Server_Info *server;
2560 2561 2562 2563 2564 2565

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

2566 2567
	server = tlink_tcon(open_file->tlink)->ses->server;

2568
	do {
2569 2570 2571 2572 2573 2574
		unsigned int wsize, credits;

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

2576
		nr_pages = get_numpages(wsize, len, &cur_len);
2577 2578 2579 2580
		wdata = cifs_writedata_alloc(nr_pages,
					     cifs_uncached_writev_complete);
		if (!wdata) {
			rc = -ENOMEM;
2581
			add_credits_and_wake_if(server, credits, 0);
2582 2583 2584 2585 2586 2587
			break;
		}

		rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
		if (rc) {
			kfree(wdata);
2588
			add_credits_and_wake_if(server, credits, 0);
2589 2590 2591
			break;
		}

2592 2593 2594
		num_pages = nr_pages;
		rc = wdata_fill_from_iovec(wdata, from, &cur_len, &num_pages);
		if (rc) {
2595 2596 2597
			for (i = 0; i < nr_pages; i++)
				put_page(wdata->pages[i]);
			kfree(wdata);
2598
			add_credits_and_wake_if(server, credits, 0);
2599 2600 2601 2602
			break;
		}

		/*
2603 2604
		 * Bring nr_pages down to the number of pages we actually used,
		 * and free any pages that we didn't use.
2605
		 */
2606
		for ( ; nr_pages > num_pages; nr_pages--)
2607 2608
			put_page(wdata->pages[nr_pages - 1]);

2609 2610 2611 2612 2613 2614
		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;
2615 2616
		wdata->pagesz = PAGE_SIZE;
		wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2617
		wdata->credits = credits;
2618 2619
		wdata->ctx = ctx;
		kref_get(&ctx->refcount);
2620 2621

		if (!wdata->cfile->invalidHandle ||
2622
		    !(rc = cifs_reopen_file(wdata->cfile, false)))
2623 2624
			rc = server->ops->async_writev(wdata,
					cifs_uncached_writedata_release);
2625
		if (rc) {
2626
			add_credits_and_wake_if(server, wdata->credits, 0);
2627 2628
			kref_put(&wdata->refcount,
				 cifs_uncached_writedata_release);
2629
			if (rc == -EAGAIN) {
2630
				*from = saved_from;
2631 2632 2633
				iov_iter_advance(from, offset - saved_offset);
				continue;
			}
2634 2635 2636
			break;
		}

2637
		list_add_tail(&wdata->list, wdata_list);
2638 2639
		offset += cur_len;
		len -= cur_len;
2640 2641
	} while (len > 0);

2642 2643 2644
	return rc;
}

2645
static void collect_uncached_write_data(struct cifs_aio_ctx *ctx)
2646
{
2647
	struct cifs_writedata *wdata, *tmp;
2648 2649
	struct cifs_tcon *tcon;
	struct cifs_sb_info *cifs_sb;
2650 2651
	struct dentry *dentry = ctx->cfile->dentry;
	unsigned int i;
2652 2653
	int rc;

2654 2655
	tcon = tlink_tcon(ctx->cfile->tlink);
	cifs_sb = CIFS_SB(dentry->d_sb);
2656

2657
	mutex_lock(&ctx->aio_mutex);
2658

2659 2660 2661 2662
	if (list_empty(&ctx->list)) {
		mutex_unlock(&ctx->aio_mutex);
		return;
	}
2663

2664
	rc = ctx->rc;
2665 2666
	/*
	 * Wait for and collect replies for any successful sends in order of
2667 2668
	 * increasing offset. Once an error is hit, then return without waiting
	 * for any more replies.
2669 2670
	 */
restart_loop:
2671
	list_for_each_entry_safe(wdata, tmp, &ctx->list, list) {
2672
		if (!rc) {
2673 2674 2675 2676 2677 2678
			if (!try_wait_for_completion(&wdata->done)) {
				mutex_unlock(&ctx->aio_mutex);
				return;
			}

			if (wdata->result)
2679 2680
				rc = wdata->result;
			else
2681
				ctx->total_len += wdata->bytes;
2682 2683 2684

			/* resend call if it's a retryable error */
			if (rc == -EAGAIN) {
2685
				struct list_head tmp_list;
2686
				struct iov_iter tmp_from = ctx->iter;
2687 2688 2689 2690 2691

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

				iov_iter_advance(&tmp_from,
2692
						 wdata->offset - ctx->pos);
2693 2694 2695

				rc = cifs_write_from_iter(wdata->offset,
						wdata->bytes, &tmp_from,
2696 2697
						ctx->cfile, cifs_sb, &tmp_list,
						ctx);
2698

2699
				list_splice(&tmp_list, &ctx->list);
2700 2701 2702

				kref_put(&wdata->refcount,
					 cifs_uncached_writedata_release);
2703 2704 2705 2706
				goto restart_loop;
			}
		}
		list_del_init(&wdata->list);
2707
		kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2708 2709
	}

2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810
	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);

2811 2812
	if (unlikely(!total_written))
		return rc;
2813

2814 2815
	iocb->ki_pos += total_written;
	return total_written;
2816 2817
}

2818
static ssize_t
A
Al Viro 已提交
2819
cifs_writev(struct kiocb *iocb, struct iov_iter *from)
2820
{
2821 2822 2823 2824 2825
	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;
2826
	ssize_t rc;
2827

2828
	inode_lock(inode);
2829 2830 2831 2832 2833
	/*
	 * We need to hold the sem to be sure nobody modifies lock list
	 * with a brlock that prevents writing.
	 */
	down_read(&cinode->lock_sem);
2834

2835 2836
	rc = generic_write_checks(iocb, from);
	if (rc <= 0)
2837 2838 2839
		goto out;

	if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
2840
				     server->vals->exclusive_lock_type, NULL,
2841
				     CIFS_WRITE_OP))
A
Al Viro 已提交
2842
		rc = __generic_file_write_iter(iocb, from);
2843 2844 2845
	else
		rc = -EACCES;
out:
2846
	up_read(&cinode->lock_sem);
A
Al Viro 已提交
2847
	inode_unlock(inode);
A
Al Viro 已提交
2848

2849 2850
	if (rc > 0)
		rc = generic_write_sync(iocb, rc);
2851 2852 2853 2854
	return rc;
}

ssize_t
A
Al Viro 已提交
2855
cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
2856
{
A
Al Viro 已提交
2857
	struct inode *inode = file_inode(iocb->ki_filp);
2858 2859 2860 2861 2862
	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);
2863
	ssize_t written;
2864

2865 2866 2867 2868
	written = cifs_get_writer(cinode);
	if (written)
		return written;

2869
	if (CIFS_CACHE_WRITE(cinode)) {
2870 2871
		if (cap_unix(tcon->ses) &&
		(CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
2872
		  && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
A
Al Viro 已提交
2873
			written = generic_file_write_iter(iocb, from);
2874 2875
			goto out;
		}
A
Al Viro 已提交
2876
		written = cifs_writev(iocb, from);
2877
		goto out;
2878 2879
	}
	/*
2880 2881 2882 2883
	 * 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.
2884
	 */
A
Al Viro 已提交
2885
	written = cifs_user_writev(iocb, from);
2886
	if (CIFS_CACHE_READ(cinode)) {
2887
		/*
2888 2889 2890 2891 2892
		 * 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.
2893
		 */
2894
		cifs_zap_mapping(inode);
2895
		cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
2896
			 inode);
2897
		cinode->oplock = 0;
2898
	}
2899 2900
out:
	cifs_put_writer(cinode);
2901
	return written;
2902 2903
}

2904
static struct cifs_readdata *
2905
cifs_readdata_direct_alloc(struct page **pages, work_func_t complete)
2906 2907
{
	struct cifs_readdata *rdata;
2908

2909
	rdata = kzalloc(sizeof(*rdata), GFP_KERNEL);
2910
	if (rdata != NULL) {
2911
		rdata->pages = pages;
2912
		kref_init(&rdata->refcount);
2913 2914
		INIT_LIST_HEAD(&rdata->list);
		init_completion(&rdata->done);
2915 2916
		INIT_WORK(&rdata->work, complete);
	}
2917

2918 2919 2920
	return rdata;
}

2921 2922 2923 2924
static struct cifs_readdata *
cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
{
	struct page **pages =
K
Kees Cook 已提交
2925
		kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936
	struct cifs_readdata *ret = NULL;

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

	return ret;
}

2937 2938
void
cifs_readdata_release(struct kref *refcount)
2939
{
2940 2941
	struct cifs_readdata *rdata = container_of(refcount,
					struct cifs_readdata, refcount);
2942 2943 2944 2945 2946 2947
#ifdef CONFIG_CIFS_SMB_DIRECT
	if (rdata->mr) {
		smbd_deregister_mr(rdata->mr);
		rdata->mr = NULL;
	}
#endif
2948 2949 2950
	if (rdata->cfile)
		cifsFileInfo_put(rdata->cfile);

2951
	kvfree(rdata->pages);
2952 2953 2954
	kfree(rdata);
}

2955
static int
2956
cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
2957 2958
{
	int rc = 0;
2959
	struct page *page;
2960 2961
	unsigned int i;

2962
	for (i = 0; i < nr_pages; i++) {
2963 2964 2965 2966 2967
		page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
		if (!page) {
			rc = -ENOMEM;
			break;
		}
2968
		rdata->pages[i] = page;
2969 2970 2971
	}

	if (rc) {
2972 2973 2974
		for (i = 0; i < nr_pages; i++) {
			put_page(rdata->pages[i]);
			rdata->pages[i] = NULL;
2975 2976 2977 2978 2979 2980 2981 2982 2983 2984
		}
	}
	return rc;
}

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

2987
	kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
2988 2989 2990
	for (i = 0; i < rdata->nr_pages; i++) {
		put_page(rdata->pages[i]);
		rdata->pages[i] = NULL;
2991 2992 2993 2994 2995 2996 2997
	}
	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
2998
 * @iter:	destination for our data
2999 3000 3001 3002 3003
 *
 * 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.
 */
3004 3005
static int
cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
3006
{
3007
	size_t remaining = rdata->got_bytes;
3008
	unsigned int i;
3009

3010 3011
	for (i = 0; i < rdata->nr_pages; i++) {
		struct page *page = rdata->pages[i];
3012
		size_t copy = min_t(size_t, remaining, PAGE_SIZE);
3013 3014 3015 3016 3017 3018 3019 3020 3021
		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);
3022 3023 3024
		remaining -= written;
		if (written < copy && iov_iter_count(iter) > 0)
			break;
3025
	}
3026
	return remaining ? -EFAULT : 0;
3027 3028
}

3029 3030
static void collect_uncached_read_data(struct cifs_aio_ctx *ctx);

3031 3032 3033 3034 3035 3036 3037
static void
cifs_uncached_readv_complete(struct work_struct *work)
{
	struct cifs_readdata *rdata = container_of(work,
						struct cifs_readdata, work);

	complete(&rdata->done);
3038 3039
	collect_uncached_read_data(rdata->ctx);
	/* the below call can possibly free the last ref to aio ctx */
3040 3041 3042 3043
	kref_put(&rdata->refcount, cifs_uncached_readdata_release);
}

static int
3044 3045 3046
uncached_fill_pages(struct TCP_Server_Info *server,
		    struct cifs_readdata *rdata, struct iov_iter *iter,
		    unsigned int len)
3047
{
3048
	int result = 0;
3049 3050
	unsigned int i;
	unsigned int nr_pages = rdata->nr_pages;
L
Long Li 已提交
3051
	unsigned int page_offset = rdata->page_offset;
3052

3053
	rdata->got_bytes = 0;
3054
	rdata->tailsz = PAGE_SIZE;
3055 3056
	for (i = 0; i < nr_pages; i++) {
		struct page *page = rdata->pages[i];
3057
		size_t n;
L
Long Li 已提交
3058 3059 3060 3061 3062 3063 3064
		unsigned int segment_size = rdata->pagesz;

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

3065

3066
		if (len <= 0) {
3067
			/* no need to hold page hostage */
3068 3069
			rdata->pages[i] = NULL;
			rdata->nr_pages--;
3070
			put_page(page);
3071
			continue;
3072
		}
L
Long Li 已提交
3073

3074
		n = len;
L
Long Li 已提交
3075
		if (len >= segment_size)
3076
			/* enough data to fill the page */
L
Long Li 已提交
3077 3078
			n = segment_size;
		else
3079
			rdata->tailsz = len;
L
Long Li 已提交
3080 3081
		len -= n;

3082
		if (iter)
L
Long Li 已提交
3083 3084
			result = copy_page_from_iter(
					page, page_offset, n, iter);
3085 3086 3087 3088
#ifdef CONFIG_CIFS_SMB_DIRECT
		else if (rdata->mr)
			result = n;
#endif
3089
		else
L
Long Li 已提交
3090 3091
			result = cifs_read_page_from_socket(
					server, page, page_offset, n);
3092 3093 3094
		if (result < 0)
			break;

3095
		rdata->got_bytes += result;
3096 3097
	}

3098 3099
	return rdata->got_bytes > 0 && result != -ECONNABORTED ?
						rdata->got_bytes : result;
3100 3101
}

3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116
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);
}

3117 3118
static int
cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
3119 3120
		     struct cifs_sb_info *cifs_sb, struct list_head *rdata_list,
		     struct cifs_aio_ctx *ctx)
L
Linus Torvalds 已提交
3121
{
3122
	struct cifs_readdata *rdata;
3123
	unsigned int npages, rsize, credits;
3124 3125
	size_t cur_len;
	int rc;
3126
	pid_t pid;
3127
	struct TCP_Server_Info *server;
3128

3129
	server = tlink_tcon(open_file->tlink)->ses->server;
3130

3131 3132 3133 3134 3135
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

3136
	do {
3137 3138 3139 3140 3141 3142
		rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
						   &rsize, &credits);
		if (rc)
			break;

		cur_len = min_t(const size_t, len, rsize);
3143
		npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
3144

3145 3146 3147 3148
		/* allocate a readdata struct */
		rdata = cifs_readdata_alloc(npages,
					    cifs_uncached_readv_complete);
		if (!rdata) {
3149
			add_credits_and_wake_if(server, credits, 0);
3150
			rc = -ENOMEM;
3151
			break;
L
Linus Torvalds 已提交
3152
		}
3153

3154
		rc = cifs_read_allocate_pages(rdata, npages);
3155 3156 3157 3158
		if (rc)
			goto error;

		rdata->cfile = cifsFileInfo_get(open_file);
3159
		rdata->nr_pages = npages;
3160 3161 3162
		rdata->offset = offset;
		rdata->bytes = cur_len;
		rdata->pid = pid;
3163
		rdata->pagesz = PAGE_SIZE;
L
Long Li 已提交
3164
		rdata->tailsz = PAGE_SIZE;
3165
		rdata->read_into_pages = cifs_uncached_read_into_pages;
3166
		rdata->copy_into_pages = cifs_uncached_copy_into_pages;
3167
		rdata->credits = credits;
3168 3169
		rdata->ctx = ctx;
		kref_get(&ctx->refcount);
3170

3171
		if (!rdata->cfile->invalidHandle ||
3172
		    !(rc = cifs_reopen_file(rdata->cfile, true)))
3173
			rc = server->ops->async_readv(rdata);
3174 3175
error:
		if (rc) {
3176
			add_credits_and_wake_if(server, rdata->credits, 0);
3177 3178
			kref_put(&rdata->refcount,
				 cifs_uncached_readdata_release);
3179 3180
			if (rc == -EAGAIN)
				continue;
3181 3182 3183
			break;
		}

3184
		list_add_tail(&rdata->list, rdata_list);
3185 3186 3187 3188
		offset += cur_len;
		len -= cur_len;
	} while (len > 0);

3189 3190 3191
	return rc;
}

3192 3193
static void
collect_uncached_read_data(struct cifs_aio_ctx *ctx)
3194
{
3195 3196
	struct cifs_readdata *rdata, *tmp;
	struct iov_iter *to = &ctx->iter;
3197 3198
	struct cifs_sb_info *cifs_sb;
	struct cifs_tcon *tcon;
3199 3200
	unsigned int i;
	int rc;
3201

3202 3203
	tcon = tlink_tcon(ctx->cfile->tlink);
	cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb);
3204

3205
	mutex_lock(&ctx->aio_mutex);
3206

3207 3208 3209 3210
	if (list_empty(&ctx->list)) {
		mutex_unlock(&ctx->aio_mutex);
		return;
	}
3211

3212
	rc = ctx->rc;
3213
	/* the loop below should proceed in the order of increasing offsets */
3214
again:
3215
	list_for_each_entry_safe(rdata, tmp, &ctx->list, list) {
3216
		if (!rc) {
3217 3218 3219 3220 3221 3222
			if (!try_wait_for_completion(&rdata->done)) {
				mutex_unlock(&ctx->aio_mutex);
				return;
			}

			if (rdata->result == -EAGAIN) {
3223
				/* resend call if it's a retryable error */
3224
				struct list_head tmp_list;
3225
				unsigned int got_bytes = rdata->got_bytes;
3226

3227 3228
				list_del_init(&rdata->list);
				INIT_LIST_HEAD(&tmp_list);
3229

3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241
				/*
				 * 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;
					}
3242
				}
3243 3244 3245 3246 3247

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

3250
				list_splice(&tmp_list, &ctx->list);
3251

3252 3253 3254 3255 3256 3257
				kref_put(&rdata->refcount,
					 cifs_uncached_readdata_release);
				goto again;
			} else if (rdata->result)
				rc = rdata->result;
			else
A
Al Viro 已提交
3258
				rc = cifs_readdata_to_iov(rdata, to);
3259

3260 3261 3262
			/* if there was a short read -- discard anything left */
			if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
				rc = -ENODATA;
L
Linus Torvalds 已提交
3263
		}
3264 3265
		list_del_init(&rdata->list);
		kref_put(&rdata->refcount, cifs_uncached_readdata_release);
L
Linus Torvalds 已提交
3266
	}
3267

3268 3269 3270 3271 3272
	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);
	}
3273

3274 3275 3276
	ctx->total_len = ctx->len - iov_iter_count(to);

	cifs_stats_bytes_read(tcon, ctx->total_len);
3277

3278 3279 3280 3281
	/* mask nodata case */
	if (rc == -ENODATA)
		rc = 0;

3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326
	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;

3327
	if (to->type == ITER_IOVEC)
3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371
		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);

3372
	if (total_read) {
A
Al Viro 已提交
3373
		iocb->ki_pos += total_read;
3374 3375 3376
		return total_read;
	}
	return rc;
3377 3378
}

3379
ssize_t
A
Al Viro 已提交
3380
cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3381
{
A
Al Viro 已提交
3382
	struct inode *inode = file_inode(iocb->ki_filp);
3383 3384 3385 3386 3387 3388
	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;
3389 3390 3391 3392 3393 3394 3395 3396 3397

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

3401 3402 3403
	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 已提交
3404
		return generic_file_read_iter(iocb, to);
3405 3406 3407 3408 3409 3410

	/*
	 * 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 已提交
3411
	if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3412
				     tcon->ses->server->vals->shared_lock_type,
3413
				     NULL, CIFS_READ_OP))
A
Al Viro 已提交
3414
		rc = generic_file_read_iter(iocb, to);
3415 3416
	up_read(&cinode->lock_sem);
	return rc;
3417
}
L
Linus Torvalds 已提交
3418

3419 3420
static ssize_t
cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
L
Linus Torvalds 已提交
3421 3422 3423 3424 3425
{
	int rc = -EACCES;
	unsigned int bytes_read = 0;
	unsigned int total_read;
	unsigned int current_read_size;
3426
	unsigned int rsize;
L
Linus Torvalds 已提交
3427
	struct cifs_sb_info *cifs_sb;
3428
	struct cifs_tcon *tcon;
3429
	struct TCP_Server_Info *server;
3430
	unsigned int xid;
3431
	char *cur_offset;
L
Linus Torvalds 已提交
3432
	struct cifsFileInfo *open_file;
3433
	struct cifs_io_parms io_parms;
3434
	int buf_type = CIFS_NO_BUFFER;
3435
	__u32 pid;
L
Linus Torvalds 已提交
3436

3437
	xid = get_xid();
3438
	cifs_sb = CIFS_FILE_SB(file);
L
Linus Torvalds 已提交
3439

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

L
Linus Torvalds 已提交
3443
	if (file->private_data == NULL) {
3444
		rc = -EBADF;
3445
		free_xid(xid);
3446
		return rc;
L
Linus Torvalds 已提交
3447
	}
3448
	open_file = file->private_data;
3449
	tcon = tlink_tcon(open_file->tlink);
3450 3451 3452 3453 3454 3455
	server = tcon->ses->server;

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

3457 3458 3459 3460 3461
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

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

3465 3466
	for (total_read = 0, cur_offset = read_data; read_size > total_read;
	     total_read += bytes_read, cur_offset += bytes_read) {
3467 3468 3469 3470 3471 3472 3473 3474 3475
		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 &
3476
				tcon->ses->server->vals->cap_large_files)) {
3477 3478 3479
				current_read_size = min_t(uint,
					current_read_size, CIFSMaxBufSize);
			}
3480
			if (open_file->invalidHandle) {
J
Jeff Layton 已提交
3481
				rc = cifs_reopen_file(open_file, true);
L
Linus Torvalds 已提交
3482 3483 3484
				if (rc != 0)
					break;
			}
3485
			io_parms.pid = pid;
3486
			io_parms.tcon = tcon;
3487
			io_parms.offset = *offset;
3488
			io_parms.length = current_read_size;
3489
			rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
3490 3491
						    &bytes_read, &cur_offset,
						    &buf_type);
3492 3493
		} while (rc == -EAGAIN);

L
Linus Torvalds 已提交
3494 3495 3496 3497
		if (rc || (bytes_read == 0)) {
			if (total_read) {
				break;
			} else {
3498
				free_xid(xid);
L
Linus Torvalds 已提交
3499 3500 3501
				return rc;
			}
		} else {
3502
			cifs_stats_bytes_read(tcon, total_read);
3503
			*offset += bytes_read;
L
Linus Torvalds 已提交
3504 3505
		}
	}
3506
	free_xid(xid);
L
Linus Torvalds 已提交
3507 3508 3509
	return total_read;
}

3510 3511 3512 3513
/*
 * 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.
 */
3514
static vm_fault_t
3515
cifs_page_mkwrite(struct vm_fault *vmf)
3516 3517 3518 3519 3520 3521 3522
{
	struct page *page = vmf->page;

	lock_page(page);
	return VM_FAULT_LOCKED;
}

3523
static const struct vm_operations_struct cifs_file_vm_ops = {
3524
	.fault = filemap_fault,
3525
	.map_pages = filemap_map_pages,
3526 3527 3528
	.page_mkwrite = cifs_page_mkwrite,
};

3529 3530
int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
{
3531
	int xid, rc = 0;
A
Al Viro 已提交
3532
	struct inode *inode = file_inode(file);
3533

3534
	xid = get_xid();
3535

3536
	if (!CIFS_CACHE_READ(CIFS_I(inode)))
3537
		rc = cifs_zap_mapping(inode);
3538 3539 3540
	if (!rc)
		rc = generic_file_mmap(file, vma);
	if (!rc)
3541
		vma->vm_ops = &cifs_file_vm_ops;
3542

3543
	free_xid(xid);
3544 3545 3546
	return rc;
}

L
Linus Torvalds 已提交
3547 3548 3549 3550
int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
{
	int rc, xid;

3551
	xid = get_xid();
3552

J
Jeff Layton 已提交
3553
	rc = cifs_revalidate_file(file);
3554
	if (rc)
3555 3556
		cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
			 rc);
3557 3558 3559
	if (!rc)
		rc = generic_file_mmap(file, vma);
	if (!rc)
3560
		vma->vm_ops = &cifs_file_vm_ops;
3561

3562
	free_xid(xid);
L
Linus Torvalds 已提交
3563 3564 3565
	return rc;
}

3566 3567 3568
static void
cifs_readv_complete(struct work_struct *work)
{
3569
	unsigned int i, got_bytes;
3570 3571 3572
	struct cifs_readdata *rdata = container_of(work,
						struct cifs_readdata, work);

3573
	got_bytes = rdata->got_bytes;
3574 3575 3576
	for (i = 0; i < rdata->nr_pages; i++) {
		struct page *page = rdata->pages[i];

3577 3578
		lru_cache_add_file(page);

3579 3580
		if (rdata->result == 0 ||
		    (rdata->result == -EAGAIN && got_bytes)) {
3581 3582 3583 3584 3585 3586
			flush_dcache_page(page);
			SetPageUptodate(page);
		}

		unlock_page(page);

3587 3588
		if (rdata->result == 0 ||
		    (rdata->result == -EAGAIN && got_bytes))
3589 3590
			cifs_readpage_to_fscache(rdata->mapping->host, page);

3591
		got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
3592

3593
		put_page(page);
3594
		rdata->pages[i] = NULL;
3595
	}
3596
	kref_put(&rdata->refcount, cifs_readdata_release);
3597 3598
}

3599
static int
3600 3601 3602
readpages_fill_pages(struct TCP_Server_Info *server,
		     struct cifs_readdata *rdata, struct iov_iter *iter,
		     unsigned int len)
3603
{
3604
	int result = 0;
3605
	unsigned int i;
3606 3607
	u64 eof;
	pgoff_t eof_index;
3608
	unsigned int nr_pages = rdata->nr_pages;
L
Long Li 已提交
3609
	unsigned int page_offset = rdata->page_offset;
3610 3611 3612

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

3616
	rdata->got_bytes = 0;
3617
	rdata->tailsz = PAGE_SIZE;
3618 3619
	for (i = 0; i < nr_pages; i++) {
		struct page *page = rdata->pages[i];
L
Long Li 已提交
3620 3621 3622 3623 3624 3625 3626 3627 3628
		unsigned int to_read = rdata->pagesz;
		size_t n;

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

		n = to_read;
3629

L
Long Li 已提交
3630 3631
		if (len >= to_read) {
			len -= to_read;
3632
		} else if (len > 0) {
3633
			/* enough for partial page, fill and zero the rest */
L
Long Li 已提交
3634
			zero_user(page, len + page_offset, to_read - len);
3635
			n = rdata->tailsz = len;
3636
			len = 0;
3637 3638 3639 3640 3641 3642 3643 3644 3645
		} 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.
			 */
3646
			zero_user(page, 0, PAGE_SIZE);
3647 3648 3649 3650
			lru_cache_add_file(page);
			flush_dcache_page(page);
			SetPageUptodate(page);
			unlock_page(page);
3651
			put_page(page);
3652 3653
			rdata->pages[i] = NULL;
			rdata->nr_pages--;
3654
			continue;
3655 3656 3657 3658
		} else {
			/* no need to hold page hostage */
			lru_cache_add_file(page);
			unlock_page(page);
3659
			put_page(page);
3660 3661
			rdata->pages[i] = NULL;
			rdata->nr_pages--;
3662
			continue;
3663
		}
3664

3665
		if (iter)
L
Long Li 已提交
3666 3667
			result = copy_page_from_iter(
					page, page_offset, n, iter);
3668 3669 3670 3671
#ifdef CONFIG_CIFS_SMB_DIRECT
		else if (rdata->mr)
			result = n;
#endif
3672
		else
L
Long Li 已提交
3673 3674
			result = cifs_read_page_from_socket(
					server, page, page_offset, n);
3675 3676 3677
		if (result < 0)
			break;

3678
		rdata->got_bytes += result;
3679 3680
	}

3681 3682
	return rdata->got_bytes > 0 && result != -ECONNABORTED ?
						rdata->got_bytes : result;
3683 3684
}

3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699
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);
}

3700 3701 3702 3703 3704 3705 3706 3707
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;
3708
	gfp_t gfp = readahead_gfp_mask(mapping);
3709

3710 3711
	INIT_LIST_HEAD(tmplist);

3712 3713 3714 3715 3716 3717 3718
	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.
	 */
3719
	__SetPageLocked(page);
3720
	rc = add_to_page_cache_locked(page, mapping,
3721
				      page->index, gfp);
3722 3723 3724

	/* give up if we can't stick it in the cache */
	if (rc) {
3725
		__ClearPageLocked(page);
3726 3727 3728 3729
		return rc;
	}

	/* move first page to the tmplist */
3730 3731
	*offset = (loff_t)page->index << PAGE_SHIFT;
	*bytes = PAGE_SIZE;
3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742
	*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? */
3743
		if (*bytes + PAGE_SIZE > rsize)
3744 3745
			break;

3746
		__SetPageLocked(page);
3747
		if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
3748
			__ClearPageLocked(page);
3749 3750 3751
			break;
		}
		list_move_tail(&page->lru, tmplist);
3752
		(*bytes) += PAGE_SIZE;
3753 3754 3755 3756
		expected_index++;
		(*nr_pages)++;
	}
	return rc;
3757 3758
}

L
Linus Torvalds 已提交
3759 3760 3761
static int cifs_readpages(struct file *file, struct address_space *mapping,
	struct list_head *page_list, unsigned num_pages)
{
3762 3763 3764
	int rc;
	struct list_head tmplist;
	struct cifsFileInfo *open_file = file->private_data;
3765
	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
3766
	struct TCP_Server_Info *server;
3767
	pid_t pid;
L
Linus Torvalds 已提交
3768

3769 3770 3771
	/*
	 * Reads as many pages as possible from fscache. Returns -ENOBUFS
	 * immediately if the cookie is negative
3772 3773 3774
	 *
	 * 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.
3775 3776 3777 3778
	 */
	rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
					 &num_pages);
	if (rc == 0)
3779
		return rc;
3780

3781 3782 3783 3784 3785
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

3786
	rc = 0;
3787
	server = tlink_tcon(open_file->tlink)->ses->server;
L
Linus Torvalds 已提交
3788

3789 3790
	cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
		 __func__, file, mapping, num_pages);
3791 3792 3793 3794 3795 3796 3797 3798 3799 3800 3801 3802 3803

	/*
	 * 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)) {
3804
		unsigned int i, nr_pages, bytes, rsize;
3805 3806 3807
		loff_t offset;
		struct page *page, *tpage;
		struct cifs_readdata *rdata;
3808
		unsigned credits;
L
Linus Torvalds 已提交
3809

3810 3811 3812 3813
		rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
						   &rsize, &credits);
		if (rc)
			break;
3814 3815

		/*
3816 3817 3818 3819
		 * 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.
3820
		 */
3821
		if (unlikely(rsize < PAGE_SIZE)) {
3822
			add_credits_and_wake_if(server, credits, 0);
3823
			return 0;
3824
		}
3825

3826 3827
		rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
					 &nr_pages, &offset, &bytes);
3828
		if (rc) {
3829
			add_credits_and_wake_if(server, credits, 0);
3830 3831 3832
			break;
		}

3833
		rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3834 3835 3836 3837 3838 3839
		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);
3840
				put_page(page);
3841 3842
			}
			rc = -ENOMEM;
3843
			add_credits_and_wake_if(server, credits, 0);
3844 3845 3846
			break;
		}

3847
		rdata->cfile = cifsFileInfo_get(open_file);
3848 3849 3850 3851
		rdata->mapping = mapping;
		rdata->offset = offset;
		rdata->bytes = bytes;
		rdata->pid = pid;
3852
		rdata->pagesz = PAGE_SIZE;
L
Long Li 已提交
3853
		rdata->tailsz = PAGE_SIZE;
3854
		rdata->read_into_pages = cifs_readpages_read_into_pages;
3855
		rdata->copy_into_pages = cifs_readpages_copy_into_pages;
3856
		rdata->credits = credits;
3857 3858 3859 3860 3861

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

3863
		if (!rdata->cfile->invalidHandle ||
3864
		    !(rc = cifs_reopen_file(rdata->cfile, true)))
3865 3866
			rc = server->ops->async_readv(rdata);
		if (rc) {
3867
			add_credits_and_wake_if(server, rdata->credits, 0);
3868 3869
			for (i = 0; i < rdata->nr_pages; i++) {
				page = rdata->pages[i];
3870 3871
				lru_cache_add_file(page);
				unlock_page(page);
3872
				put_page(page);
L
Linus Torvalds 已提交
3873
			}
3874
			/* Fallback to the readpage in error/reconnect cases */
3875
			kref_put(&rdata->refcount, cifs_readdata_release);
L
Linus Torvalds 已提交
3876 3877
			break;
		}
3878 3879

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

3882 3883 3884 3885 3886
	/* 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 已提交
3887 3888 3889
	return rc;
}

3890 3891 3892
/*
 * cifs_readpage_worker must be called with the page pinned
 */
L
Linus Torvalds 已提交
3893 3894 3895 3896 3897 3898
static int cifs_readpage_worker(struct file *file, struct page *page,
	loff_t *poffset)
{
	char *read_data;
	int rc;

3899
	/* Is the page cached? */
A
Al Viro 已提交
3900
	rc = cifs_readpage_from_fscache(file_inode(file), page);
3901 3902 3903
	if (rc == 0)
		goto read_complete;

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

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

L
Linus Torvalds 已提交
3909 3910 3911
	if (rc < 0)
		goto io_error;
	else
3912
		cifs_dbg(FYI, "Bytes read %d\n", rc);
S
Steve French 已提交
3913

A
Al Viro 已提交
3914
	file_inode(file)->i_atime =
3915
		current_time(file_inode(file));
S
Steve French 已提交
3916

3917 3918
	if (PAGE_SIZE > rc)
		memset(read_data + rc, 0, PAGE_SIZE - rc);
L
Linus Torvalds 已提交
3919 3920 3921

	flush_dcache_page(page);
	SetPageUptodate(page);
3922 3923

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

L
Linus Torvalds 已提交
3926
	rc = 0;
S
Steve French 已提交
3927

L
Linus Torvalds 已提交
3928
io_error:
S
Steve French 已提交
3929
	kunmap(page);
3930
	unlock_page(page);
3931 3932

read_complete:
L
Linus Torvalds 已提交
3933 3934 3935 3936 3937
	return rc;
}

static int cifs_readpage(struct file *file, struct page *page)
{
3938
	loff_t offset = (loff_t)page->index << PAGE_SHIFT;
L
Linus Torvalds 已提交
3939
	int rc = -EACCES;
3940
	unsigned int xid;
L
Linus Torvalds 已提交
3941

3942
	xid = get_xid();
L
Linus Torvalds 已提交
3943 3944

	if (file->private_data == NULL) {
3945
		rc = -EBADF;
3946
		free_xid(xid);
3947
		return rc;
L
Linus Torvalds 已提交
3948 3949
	}

3950
	cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
3951
		 page, (int)offset, (int)offset);
L
Linus Torvalds 已提交
3952 3953 3954

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

3955
	free_xid(xid);
L
Linus Torvalds 已提交
3956 3957 3958
	return rc;
}

3959 3960 3961
static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
{
	struct cifsFileInfo *open_file;
3962 3963
	struct cifs_tcon *tcon =
		cifs_sb_master_tcon(CIFS_SB(cifs_inode->vfs_inode.i_sb));
3964

3965
	spin_lock(&tcon->open_file_lock);
3966
	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
3967
		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
3968
			spin_unlock(&tcon->open_file_lock);
3969 3970 3971
			return 1;
		}
	}
3972
	spin_unlock(&tcon->open_file_lock);
3973 3974 3975
	return 0;
}

L
Linus Torvalds 已提交
3976 3977 3978
/* 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 已提交
3979
   refreshing the inode only on increases in the file size
L
Linus Torvalds 已提交
3980 3981
   but this is tricky to do without racing with writebehind
   page caching in the current Linux kernel design */
3982
bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
L
Linus Torvalds 已提交
3983
{
3984
	if (!cifsInode)
3985
		return true;
3986

3987 3988
	if (is_inode_writable(cifsInode)) {
		/* This inode is open for write at least once */
3989 3990 3991
		struct cifs_sb_info *cifs_sb;

		cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
S
Steve French 已提交
3992
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
S
Steve French 已提交
3993
			/* since no page cache to corrupt on directio
3994
			we can change size safely */
3995
			return true;
3996 3997
		}

S
Steve French 已提交
3998
		if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
3999
			return true;
4000

4001
		return false;
4002
	} else
4003
		return true;
L
Linus Torvalds 已提交
4004 4005
}

N
Nick Piggin 已提交
4006 4007 4008
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 已提交
4009
{
4010
	int oncethru = 0;
4011 4012
	pgoff_t index = pos >> PAGE_SHIFT;
	loff_t offset = pos & (PAGE_SIZE - 1);
4013 4014 4015 4016
	loff_t page_start = pos & PAGE_MASK;
	loff_t i_size;
	struct page *page;
	int rc = 0;
N
Nick Piggin 已提交
4017

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

4020
start:
4021
	page = grab_cache_page_write_begin(mapping, index, flags);
4022 4023 4024 4025
	if (!page) {
		rc = -ENOMEM;
		goto out;
	}
4026

4027 4028
	if (PageUptodate(page))
		goto out;
4029

4030 4031 4032 4033 4034
	/*
	 * 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.
	 */
4035
	if (len == PAGE_SIZE)
4036
		goto out;
4037

4038 4039 4040 4041 4042 4043
	/*
	 * 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.
	 */
4044
	if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
4045 4046 4047 4048 4049
		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,
4050
					   PAGE_SIZE);
4051 4052 4053 4054 4055 4056 4057 4058 4059 4060
			/*
			 * 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 已提交
4061

4062
	if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
4063 4064 4065 4066 4067 4068
		/*
		 * 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);
4069
		put_page(page);
4070 4071
		oncethru = 1;
		goto start;
4072 4073 4074 4075
	} 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 已提交
4076
		   this will be written out by write_end so is fine */
L
Linus Torvalds 已提交
4077
	}
4078 4079 4080
out:
	*pagep = page;
	return rc;
L
Linus Torvalds 已提交
4081 4082
}

4083 4084 4085 4086 4087 4088 4089 4090
static int cifs_release_page(struct page *page, gfp_t gfp)
{
	if (PagePrivate(page))
		return 0;

	return cifs_fscache_release_page(page, gfp);
}

4091 4092
static void cifs_invalidate_page(struct page *page, unsigned int offset,
				 unsigned int length)
4093 4094 4095
{
	struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);

4096
	if (offset == 0 && length == PAGE_SIZE)
4097 4098 4099
		cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
}

4100 4101 4102 4103
static int cifs_launder_page(struct page *page)
{
	int rc = 0;
	loff_t range_start = page_offset(page);
4104
	loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
4105 4106 4107 4108 4109 4110 4111
	struct writeback_control wbc = {
		.sync_mode = WB_SYNC_ALL,
		.nr_to_write = 0,
		.range_start = range_start,
		.range_end = range_end,
	};

4112
	cifs_dbg(FYI, "Launder page: %p\n", page);
4113 4114 4115 4116 4117 4118 4119 4120

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

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

4121
void cifs_oplock_break(struct work_struct *work)
4122 4123 4124
{
	struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
						  oplock_break);
4125
	struct inode *inode = d_inode(cfile->dentry);
4126
	struct cifsInodeInfo *cinode = CIFS_I(inode);
4127
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4128
	struct TCP_Server_Info *server = tcon->ses->server;
4129
	int rc = 0;
4130

4131
	wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
4132
			TASK_UNINTERRUPTIBLE);
4133 4134 4135 4136

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

4137
	if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
4138
						cifs_has_mand_locks(cinode)) {
4139 4140
		cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
			 inode);
4141
		cinode->oplock = 0;
4142 4143
	}

4144
	if (inode && S_ISREG(inode->i_mode)) {
4145
		if (CIFS_CACHE_READ(cinode))
4146
			break_lease(inode, O_RDONLY);
S
Steve French 已提交
4147
		else
4148
			break_lease(inode, O_WRONLY);
4149
		rc = filemap_fdatawrite(inode->i_mapping);
4150
		if (!CIFS_CACHE_READ(cinode)) {
4151 4152
			rc = filemap_fdatawait(inode->i_mapping);
			mapping_set_error(inode->i_mapping, rc);
4153
			cifs_zap_mapping(inode);
4154
		}
4155
		cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
4156 4157
	}

4158 4159
	rc = cifs_push_locks(cfile);
	if (rc)
4160
		cifs_dbg(VFS, "Push locks rc = %d\n", rc);
4161

4162 4163 4164 4165 4166 4167
	/*
	 * 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
	 */
4168
	if (!cfile->oplock_break_cancelled) {
4169 4170
		rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
							     cinode);
4171
		cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
4172
	}
4173
	cifs_done_oplock_break(cinode);
4174 4175
}

4176 4177 4178 4179 4180 4181 4182 4183 4184 4185
/*
 * 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
4186
cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
4187 4188 4189 4190 4191 4192 4193 4194 4195
{
        /*
         * FIXME
         * Eventually need to support direct IO for non forcedirectio mounts
         */
        return -EINVAL;
}


4196
const struct address_space_operations cifs_addr_ops = {
L
Linus Torvalds 已提交
4197 4198 4199
	.readpage = cifs_readpage,
	.readpages = cifs_readpages,
	.writepage = cifs_writepage,
4200
	.writepages = cifs_writepages,
N
Nick Piggin 已提交
4201 4202
	.write_begin = cifs_write_begin,
	.write_end = cifs_write_end,
L
Linus Torvalds 已提交
4203
	.set_page_dirty = __set_page_dirty_nobuffers,
4204
	.releasepage = cifs_release_page,
4205
	.direct_IO = cifs_direct_io,
4206
	.invalidatepage = cifs_invalidate_page,
4207
	.launder_page = cifs_launder_page,
L
Linus Torvalds 已提交
4208
};
D
Dave Kleikamp 已提交
4209 4210 4211 4212 4213 4214

/*
 * 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.
 */
4215
const struct address_space_operations cifs_addr_ops_smallbuf = {
D
Dave Kleikamp 已提交
4216 4217 4218
	.readpage = cifs_readpage,
	.writepage = cifs_writepage,
	.writepages = cifs_writepages,
N
Nick Piggin 已提交
4219 4220
	.write_begin = cifs_write_begin,
	.write_end = cifs_write_end,
D
Dave Kleikamp 已提交
4221
	.set_page_dirty = __set_page_dirty_nobuffers,
4222 4223
	.releasepage = cifs_release_page,
	.invalidatepage = cifs_invalidate_page,
4224
	.launder_page = cifs_launder_page,
D
Dave Kleikamp 已提交
4225
};