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

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
	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;
234
	oparms.reconnect = false;
235 236

	rc = server->ops->open(xid, &oparms, oplock, buf);
237 238 239 240 241 242 243 244 245

	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,
246
					 xid, fid);
247 248 249 250 251 252

out:
	kfree(buf);
	return rc;
}

253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269
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;
}

270
struct cifsFileInfo *
271
cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
272 273
		  struct tcon_link *tlink, __u32 oplock)
{
G
Goldwyn Rodrigues 已提交
274
	struct dentry *dentry = file_dentry(file);
275
	struct inode *inode = d_inode(dentry);
276 277
	struct cifsInodeInfo *cinode = CIFS_I(inode);
	struct cifsFileInfo *cfile;
278
	struct cifs_fid_locks *fdlocks;
279
	struct cifs_tcon *tcon = tlink_tcon(tlink);
280
	struct TCP_Server_Info *server = tcon->ses->server;
281 282 283 284 285

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

286 287 288 289 290 291 292 293 294
	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;
295
	down_write(&cinode->lock_sem);
296
	list_add(&fdlocks->llist, &cinode->llist);
297
	up_write(&cinode->lock_sem);
298

299 300 301 302 303 304 305 306
	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);
307
	mutex_init(&cfile->fh_mutex);
308
	spin_lock_init(&cfile->file_info_lock);
309

310 311
	cifs_sb_active(inode->i_sb);

312 313 314 315
	/*
	 * If the server returned a read oplock and we have mandatory brlocks,
	 * set oplock level to None.
	 */
316
	if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
317
		cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
318 319 320
		oplock = 0;
	}

321
	spin_lock(&tcon->open_file_lock);
322
	if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
323 324 325
		oplock = fid->pending_open->oplock;
	list_del(&fid->pending_open->olist);

326
	fid->purge_cache = false;
327
	server->ops->set_fid(cfile, fid, oplock);
328 329

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

331 332
	/* if readable file instance put first in list*/
	if (file->f_mode & FMODE_READ)
333
		list_add(&cfile->flist, &cinode->openFileList);
334
	else
335
		list_add_tail(&cfile->flist, &cinode->openFileList);
336
	spin_unlock(&tcon->open_file_lock);
337

338
	if (fid->purge_cache)
339
		cifs_zap_mapping(inode);
340

341 342
	file->private_data = cfile;
	return cfile;
343 344
}

345 346 347
struct cifsFileInfo *
cifsFileInfo_get(struct cifsFileInfo *cifs_file)
{
348
	spin_lock(&cifs_file->file_info_lock);
349
	cifsFileInfo_get_locked(cifs_file);
350
	spin_unlock(&cifs_file->file_info_lock);
351 352 353
	return cifs_file;
}

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

372 373 374
	spin_lock(&tcon->open_file_lock);

	spin_lock(&cifs_file->file_info_lock);
375
	if (--cifs_file->count > 0) {
376 377
		spin_unlock(&cifs_file->file_info_lock);
		spin_unlock(&tcon->open_file_lock);
378 379
		return;
	}
380
	spin_unlock(&cifs_file->file_info_lock);
381

382 383 384 385 386 387
	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);

388 389 390 391 392
	/* remove it from the lists */
	list_del(&cifs_file->flist);
	list_del(&cifs_file->tlist);

	if (list_empty(&cifsi->openFileList)) {
393
		cifs_dbg(FYI, "closing last open instance for inode %p\n",
394
			 d_inode(cifs_file->dentry));
395 396 397 398 399
		/*
		 * 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.
		 */
400
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
401
			set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
402
		cifs_set_oplock_level(cifsi, 0);
403
	}
404 405

	spin_unlock(&tcon->open_file_lock);
406

407
	oplock_break_cancelled = cancel_work_sync(&cifs_file->oplock_break);
408

409
	if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
410
		struct TCP_Server_Info *server = tcon->ses->server;
411
		unsigned int xid;
412

413
		xid = get_xid();
414
		if (server->ops->close)
415 416
			server->ops->close(xid, tcon, &cifs_file->fid);
		_free_xid(xid);
417 418
	}

419 420 421
	if (oplock_break_cancelled)
		cifs_done_oplock_break(cifsi);

422 423
	cifs_del_pending_open(&open);

424 425
	/*
	 * Delete any outstanding lock records. We'll lose them when the file
426 427
	 * is closed anyway.
	 */
428
	down_write(&cifsi->lock_sem);
429
	list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
430
		list_del(&li->llist);
431
		cifs_del_lock_waiters(li);
432
		kfree(li);
433
	}
434 435
	list_del(&cifs_file->llist->llist);
	kfree(cifs_file->llist);
436
	up_write(&cifsi->lock_sem);
437 438 439

	cifs_put_tlink(cifs_file->tlink);
	dput(cifs_file->dentry);
440
	cifs_sb_deactive(sb);
441
	kfree(cifs_file);
442 443
}

L
Linus Torvalds 已提交
444
int cifs_open(struct inode *inode, struct file *file)
445

L
Linus Torvalds 已提交
446 447
{
	int rc = -EACCES;
448
	unsigned int xid;
449
	__u32 oplock;
L
Linus Torvalds 已提交
450
	struct cifs_sb_info *cifs_sb;
P
Pavel Shilovsky 已提交
451
	struct TCP_Server_Info *server;
452
	struct cifs_tcon *tcon;
453
	struct tcon_link *tlink;
454
	struct cifsFileInfo *cfile = NULL;
L
Linus Torvalds 已提交
455
	char *full_path = NULL;
P
Pavel Shilovsky 已提交
456
	bool posix_open_ok = false;
457
	struct cifs_fid fid;
458
	struct cifs_pending_open open;
L
Linus Torvalds 已提交
459

460
	xid = get_xid();
L
Linus Torvalds 已提交
461 462

	cifs_sb = CIFS_SB(inode->i_sb);
463 464
	tlink = cifs_sb_tlink(cifs_sb);
	if (IS_ERR(tlink)) {
465
		free_xid(xid);
466 467 468
		return PTR_ERR(tlink);
	}
	tcon = tlink_tcon(tlink);
P
Pavel Shilovsky 已提交
469
	server = tcon->ses->server;
L
Linus Torvalds 已提交
470

G
Goldwyn Rodrigues 已提交
471
	full_path = build_path_from_dentry(file_dentry(file));
L
Linus Torvalds 已提交
472
	if (full_path == NULL) {
473
		rc = -ENOMEM;
474
		goto out;
L
Linus Torvalds 已提交
475 476
	}

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

480 481 482 483 484 485 486 487
	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;
	}

488
	if (server->oplocks)
489 490 491 492
		oplock = REQ_OPLOCK;
	else
		oplock = 0;

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

518 519 520 521 522
	if (server->ops->get_lease_key)
		server->ops->get_lease_key(inode, &fid);

	cifs_add_pending_open(&fid, tlink, &open);

P
Pavel Shilovsky 已提交
523
	if (!posix_open_ok) {
P
Pavel Shilovsky 已提交
524 525 526
		if (server->ops->get_lease_key)
			server->ops->get_lease_key(inode, &fid);

P
Pavel Shilovsky 已提交
527
		rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
528
				  file->f_flags, &oplock, &fid, xid);
529 530
		if (rc) {
			cifs_del_pending_open(&open);
P
Pavel Shilovsky 已提交
531
			goto out;
532
		}
P
Pavel Shilovsky 已提交
533
	}
534

535 536
	cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
	if (cfile == NULL) {
P
Pavel Shilovsky 已提交
537 538
		if (server->ops->close)
			server->ops->close(xid, tcon, &fid);
539
		cifs_del_pending_open(&open);
L
Linus Torvalds 已提交
540 541 542 543
		rc = -ENOMEM;
		goto out;
	}

544 545
	cifs_fscache_set_inode_cookie(inode, file);

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

out:
	kfree(full_path);
566
	free_xid(xid);
567
	cifs_put_tlink(tlink);
L
Linus Torvalds 已提交
568 569 570
	return rc;
}

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

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

585
	down_read(&cinode->lock_sem);
P
Pavel Shilovsky 已提交
586
	if (cinode->can_cache_brlcks) {
587 588
		/* can cache locks - no need to relock */
		up_read(&cinode->lock_sem);
P
Pavel Shilovsky 已提交
589 590 591 592 593 594 595 596 597
		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 已提交
598

599
	up_read(&cinode->lock_sem);
L
Linus Torvalds 已提交
600 601 602
	return rc;
}

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

620
	xid = get_xid();
621 622 623
	mutex_lock(&cfile->fh_mutex);
	if (!cfile->invalidHandle) {
		mutex_unlock(&cfile->fh_mutex);
624
		rc = 0;
625
		free_xid(xid);
626
		return rc;
L
Linus Torvalds 已提交
627 628
	}

629
	inode = d_inode(cfile->dentry);
L
Linus Torvalds 已提交
630
	cifs_sb = CIFS_SB(inode->i_sb);
631 632 633 634 635 636 637 638 639 640
	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 已提交
641
	if (full_path == NULL) {
642
		rc = -ENOMEM;
643
		mutex_unlock(&cfile->fh_mutex);
644
		free_xid(xid);
645
		return rc;
L
Linus Torvalds 已提交
646 647
	}

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

651
	if (tcon->ses->server->oplocks)
L
Linus Torvalds 已提交
652 653
		oplock = REQ_OPLOCK;
	else
654
		oplock = 0;
L
Linus Torvalds 已提交
655

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

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

680
	desired_access = cifs_convert_flags(cfile->f_flags);
681

682 683 684
	if (backup_cred(cifs_sb))
		create_options |= CREATE_OPEN_BACKUP_INTENT;

P
Pavel Shilovsky 已提交
685
	if (server->ops->get_lease_key)
686
		server->ops->get_lease_key(inode, &cfile->fid);
P
Pavel Shilovsky 已提交
687

688 689 690 691 692 693
	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;
694 695
	oparms.fid = &cfile->fid;
	oparms.reconnect = true;
696

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

719
reopen_success:
720 721 722
	cfile->invalidHandle = false;
	mutex_unlock(&cfile->fh_mutex);
	cinode = CIFS_I(inode);
J
Jeff Layton 已提交
723 724 725

	if (can_flush) {
		rc = filemap_write_and_wait(inode->i_mapping);
726
		mapping_set_error(inode->i_mapping, rc);
J
Jeff Layton 已提交
727 728

		if (tcon->unix_ext)
729 730
			rc = cifs_get_inode_info_unix(&inode, full_path,
						      inode->i_sb, xid);
J
Jeff Layton 已提交
731
		else
732 733 734 735 736 737 738 739 740 741
			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.
	 */

742 743 744 745 746 747 748 749 750
	/*
	 * 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;
	}

751 752 753
	server->ops->set_fid(cfile, &cfile->fid, oplock);
	if (oparms.reconnect)
		cifs_relock_file(cfile);
J
Jeff Layton 已提交
754 755

reopen_error_exit:
L
Linus Torvalds 已提交
756
	kfree(full_path);
757
	free_xid(xid);
L
Linus Torvalds 已提交
758 759 760 761 762
	return rc;
}

int cifs_close(struct inode *inode, struct file *file)
{
763 764 765 766
	if (file->private_data != NULL) {
		cifsFileInfo_put(file->private_data);
		file->private_data = NULL;
	}
J
[CIFS]  
Jeremy Allison 已提交
767

768 769
	/* return code from the ->release op is always ignored */
	return 0;
L
Linus Torvalds 已提交
770 771
}

772 773 774
void
cifs_reopen_persistent_handles(struct cifs_tcon *tcon)
{
775
	struct cifsFileInfo *open_file;
776 777
	struct list_head *tmp;
	struct list_head *tmp1;
778 779
	struct list_head tmp_list;

780 781 782 783 784
	if (!tcon->use_persistent || !tcon->need_reopen_files)
		return;

	tcon->need_reopen_files = false;

785 786
	cifs_dbg(FYI, "Reopen persistent handles");
	INIT_LIST_HEAD(&tmp_list);
787 788 789

	/* list all files open on tree connection, reopen resilient handles  */
	spin_lock(&tcon->open_file_lock);
790
	list_for_each(tmp, &tcon->openFileList) {
791
		open_file = list_entry(tmp, struct cifsFileInfo, tlist);
792 793 794 795
		if (!open_file->invalidHandle)
			continue;
		cifsFileInfo_get(open_file);
		list_add_tail(&open_file->rlist, &tmp_list);
796 797
	}
	spin_unlock(&tcon->open_file_lock);
798 799 800

	list_for_each_safe(tmp, tmp1, &tmp_list) {
		open_file = list_entry(tmp, struct cifsFileInfo, rlist);
801 802
		if (cifs_reopen_file(open_file, false /* do not flush */))
			tcon->need_reopen_files = true;
803 804 805
		list_del_init(&open_file->rlist);
		cifsFileInfo_put(open_file);
	}
806 807
}

L
Linus Torvalds 已提交
808 809 810
int cifs_closedir(struct inode *inode, struct file *file)
{
	int rc = 0;
811
	unsigned int xid;
812
	struct cifsFileInfo *cfile = file->private_data;
813 814 815
	struct cifs_tcon *tcon;
	struct TCP_Server_Info *server;
	char *buf;
L
Linus Torvalds 已提交
816

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

819 820 821
	if (cfile == NULL)
		return rc;

822
	xid = get_xid();
823 824
	tcon = tlink_tcon(cfile->tlink);
	server = tcon->ses->server;
L
Linus Torvalds 已提交
825

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

	buf = cfile->srch_inf.ntwrk_buf_start;
	if (buf) {
843
		cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
844 845 846 847 848
		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 已提交
849
	}
850 851 852 853

	cifs_put_tlink(cfile->tlink);
	kfree(file->private_data);
	file->private_data = NULL;
L
Linus Torvalds 已提交
854
	/* BB can we lock the filestruct while this is going on? */
855
	free_xid(xid);
L
Linus Torvalds 已提交
856 857 858
	return rc;
}

859
static struct cifsLockInfo *
860
cifs_lock_init(__u64 offset, __u64 length, __u8 type)
J
[CIFS]  
Jeremy Allison 已提交
861
{
862
	struct cifsLockInfo *lock =
S
Steve French 已提交
863
		kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
864 865 866 867 868 869 870 871 872
	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;
873 874
}

875
void
876 877 878 879 880 881 882 883 884
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);
	}
}

885 886 887 888 889
#define CIFS_LOCK_OP	0
#define CIFS_READ_OP	1
#define CIFS_WRITE_OP	2

/* @rw_check : 0 - no op, 1 - read, 2 - write */
890
static bool
891 892
cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
			    __u64 length, __u8 type, struct cifsFileInfo *cfile,
893
			    struct cifsLockInfo **conf_lock, int rw_check)
894
{
895
	struct cifsLockInfo *li;
896
	struct cifsFileInfo *cur_cfile = fdlocks->cfile;
897
	struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
898

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

921
bool
922
cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
923
			__u8 type, struct cifsLockInfo **conf_lock,
924
			int rw_check)
925
{
926
	bool rc = false;
927
	struct cifs_fid_locks *cur;
928
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
929

930 931
	list_for_each_entry(cur, &cinode->llist, llist) {
		rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
932
						 cfile, conf_lock, rw_check);
933 934 935 936 937
		if (rc)
			break;
	}

	return rc;
938 939
}

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

957
	down_read(&cinode->lock_sem);
958

959
	exist = cifs_find_lock_conflict(cfile, offset, length, type,
960
					&conf_lock, CIFS_LOCK_OP);
961 962 963 964
	if (exist) {
		flock->fl_start = conf_lock->offset;
		flock->fl_end = conf_lock->offset + conf_lock->length - 1;
		flock->fl_pid = conf_lock->pid;
965
		if (conf_lock->type & server->vals->shared_lock_type)
966 967 968 969 970 971 972 973
			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;

974
	up_read(&cinode->lock_sem);
975 976 977
	return rc;
}

978
static void
979
cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
980
{
981
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
982
	down_write(&cinode->lock_sem);
983
	list_add_tail(&lock->llist, &cfile->llist->locks);
984
	up_write(&cinode->lock_sem);
J
[CIFS]  
Jeremy Allison 已提交
985 986
}

987 988 989 990 991 992
/*
 * 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.
 */
993
static int
994
cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
995
		 bool wait)
996
{
997
	struct cifsLockInfo *conf_lock;
998
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
999 1000 1001 1002 1003
	bool exist;
	int rc = 0;

try_again:
	exist = false;
1004
	down_write(&cinode->lock_sem);
1005

1006
	exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
1007
					lock->type, &conf_lock, CIFS_LOCK_OP);
1008
	if (!exist && cinode->can_cache_brlcks) {
1009
		list_add_tail(&lock->llist, &cfile->llist->locks);
1010
		up_write(&cinode->lock_sem);
1011 1012 1013 1014 1015 1016 1017 1018 1019
		return rc;
	}

	if (!exist)
		rc = 1;
	else if (!wait)
		rc = -EACCES;
	else {
		list_add_tail(&lock->blist, &conf_lock->blist);
1020
		up_write(&cinode->lock_sem);
1021 1022 1023 1024 1025
		rc = wait_event_interruptible(lock->block_q,
					(lock->blist.prev == &lock->blist) &&
					(lock->blist.next == &lock->blist));
		if (!rc)
			goto try_again;
1026
		down_write(&cinode->lock_sem);
1027
		list_del_init(&lock->blist);
1028 1029
	}

1030
	up_write(&cinode->lock_sem);
1031 1032 1033
	return rc;
}

1034 1035 1036 1037 1038 1039 1040
/*
 * 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.
 */
1041
static int
1042 1043 1044
cifs_posix_lock_test(struct file *file, struct file_lock *flock)
{
	int rc = 0;
A
Al Viro 已提交
1045
	struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1046 1047
	unsigned char saved_type = flock->fl_type;

1048 1049 1050
	if ((flock->fl_flags & FL_POSIX) == 0)
		return 1;

1051
	down_read(&cinode->lock_sem);
1052 1053 1054 1055 1056 1057 1058
	posix_test_lock(file, flock);

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

1059
	up_read(&cinode->lock_sem);
1060 1061 1062
	return rc;
}

1063 1064 1065 1066 1067 1068
/*
 * 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.
 */
1069 1070 1071
static int
cifs_posix_lock_set(struct file *file, struct file_lock *flock)
{
A
Al Viro 已提交
1072
	struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1073 1074 1075 1076
	int rc = 1;

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

1078
try_again:
1079
	down_write(&cinode->lock_sem);
1080
	if (!cinode->can_cache_brlcks) {
1081
		up_write(&cinode->lock_sem);
1082
		return rc;
1083
	}
1084 1085

	rc = posix_lock_file(file, flock, NULL);
1086
	up_write(&cinode->lock_sem);
1087 1088 1089 1090
	if (rc == FILE_LOCK_DEFERRED) {
		rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
		if (!rc)
			goto try_again;
1091
		posix_unblock_lock(flock);
1092
	}
1093
	return rc;
1094 1095
}

1096
int
1097
cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1098
{
1099 1100
	unsigned int xid;
	int rc = 0, stored_rc;
1101 1102
	struct cifsLockInfo *li, *tmp;
	struct cifs_tcon *tcon;
1103
	unsigned int num, max_num, max_buf;
1104 1105 1106 1107
	LOCKING_ANDX_RANGE *buf, *cur;
	int types[] = {LOCKING_ANDX_LARGE_FILES,
		       LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
	int i;
1108

1109
	xid = get_xid();
1110 1111
	tcon = tlink_tcon(cfile->tlink);

1112 1113 1114 1115 1116 1117
	/*
	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
	 * and check it for zero before using.
	 */
	max_buf = tcon->ses->server->maxBuf;
	if (!max_buf) {
1118
		free_xid(xid);
1119 1120 1121 1122 1123
		return -EINVAL;
	}

	max_num = (max_buf - sizeof(struct smb_hdr)) /
						sizeof(LOCKING_ANDX_RANGE);
1124
	buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1125
	if (!buf) {
1126
		free_xid(xid);
1127
		return -ENOMEM;
1128 1129 1130 1131 1132
	}

	for (i = 0; i < 2; i++) {
		cur = buf;
		num = 0;
1133
		list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1134 1135 1136 1137 1138 1139 1140 1141
			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) {
1142 1143
				stored_rc = cifs_lockv(xid, tcon,
						       cfile->fid.netfid,
1144 1145
						       (__u8)li->type, 0, num,
						       buf);
1146 1147 1148 1149 1150 1151 1152 1153 1154
				if (stored_rc)
					rc = stored_rc;
				cur = buf;
				num = 0;
			} else
				cur++;
		}

		if (num) {
1155
			stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1156
					       (__u8)types[i], 0, num, buf);
1157 1158 1159
			if (stored_rc)
				rc = stored_rc;
		}
1160 1161
	}

1162
	kfree(buf);
1163
	free_xid(xid);
1164 1165 1166
	return rc;
}

1167 1168 1169 1170 1171 1172
static __u32
hash_lockowner(fl_owner_t owner)
{
	return cifs_lock_secret ^ hash32_ptr((const void *)owner);
}

1173 1174 1175 1176 1177 1178 1179 1180 1181
struct lock_to_push {
	struct list_head llist;
	__u64 offset;
	__u64 length;
	__u32 pid;
	__u16 netfid;
	__u8 type;
};

1182
static int
1183
cifs_push_posix_locks(struct cifsFileInfo *cfile)
1184
{
1185
	struct inode *inode = d_inode(cfile->dentry);
1186
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1187 1188
	struct file_lock *flock;
	struct file_lock_context *flctx = inode->i_flctx;
1189
	unsigned int count = 0, i;
1190
	int rc = 0, xid, type;
1191 1192
	struct list_head locks_to_send, *el;
	struct lock_to_push *lck, *tmp;
1193 1194
	__u64 length;

1195
	xid = get_xid();
1196

1197 1198
	if (!flctx)
		goto out;
1199

1200 1201 1202 1203 1204 1205
	spin_lock(&flctx->flc_lock);
	list_for_each(el, &flctx->flc_posix) {
		count++;
	}
	spin_unlock(&flctx->flc_lock);

1206 1207
	INIT_LIST_HEAD(&locks_to_send);

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

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

		stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1251
					     lck->offset, lck->length, NULL,
1252 1253 1254 1255 1256 1257 1258
					     lck->type, 0);
		if (stored_rc)
			rc = stored_rc;
		list_del(&lck->llist);
		kfree(lck);
	}

1259
out:
1260
	free_xid(xid);
1261
	return rc;
1262 1263 1264 1265 1266 1267
err_out:
	list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
		list_del(&lck->llist);
		kfree(lck);
	}
	goto out;
1268 1269
}

1270
static int
1271
cifs_push_locks(struct cifsFileInfo *cfile)
1272
{
1273
	struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1274
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1275
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1276 1277 1278 1279 1280 1281 1282 1283
	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;
	}
1284

1285
	if (cap_unix(tcon->ses) &&
1286 1287
	    (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
	    ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1288 1289 1290
		rc = cifs_push_posix_locks(cfile);
	else
		rc = tcon->ses->server->ops->push_mand_locks(cfile);
1291

1292 1293 1294
	cinode->can_cache_brlcks = false;
	up_write(&cinode->lock_sem);
	return rc;
1295 1296
}

1297
static void
1298
cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1299
		bool *wait_flag, struct TCP_Server_Info *server)
L
Linus Torvalds 已提交
1300
{
1301
	if (flock->fl_flags & FL_POSIX)
1302
		cifs_dbg(FYI, "Posix\n");
1303
	if (flock->fl_flags & FL_FLOCK)
1304
		cifs_dbg(FYI, "Flock\n");
1305
	if (flock->fl_flags & FL_SLEEP) {
1306
		cifs_dbg(FYI, "Blocking lock\n");
1307
		*wait_flag = true;
L
Linus Torvalds 已提交
1308
	}
1309
	if (flock->fl_flags & FL_ACCESS)
1310
		cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1311
	if (flock->fl_flags & FL_LEASE)
1312
		cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1313
	if (flock->fl_flags &
1314 1315
	    (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
	       FL_ACCESS | FL_LEASE | FL_CLOSE)))
1316
		cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
L
Linus Torvalds 已提交
1317

1318
	*type = server->vals->large_lock_type;
1319
	if (flock->fl_type == F_WRLCK) {
1320
		cifs_dbg(FYI, "F_WRLCK\n");
1321
		*type |= server->vals->exclusive_lock_type;
1322 1323
		*lock = 1;
	} else if (flock->fl_type == F_UNLCK) {
1324
		cifs_dbg(FYI, "F_UNLCK\n");
1325
		*type |= server->vals->unlock_lock_type;
1326 1327 1328
		*unlock = 1;
		/* Check if unlock includes more than one lock range */
	} else if (flock->fl_type == F_RDLCK) {
1329
		cifs_dbg(FYI, "F_RDLCK\n");
1330
		*type |= server->vals->shared_lock_type;
1331 1332
		*lock = 1;
	} else if (flock->fl_type == F_EXLCK) {
1333
		cifs_dbg(FYI, "F_EXLCK\n");
1334
		*type |= server->vals->exclusive_lock_type;
1335 1336
		*lock = 1;
	} else if (flock->fl_type == F_SHLCK) {
1337
		cifs_dbg(FYI, "F_SHLCK\n");
1338
		*type |= server->vals->shared_lock_type;
1339
		*lock = 1;
L
Linus Torvalds 已提交
1340
	} else
1341
		cifs_dbg(FYI, "Unknown type of lock\n");
1342
}
L
Linus Torvalds 已提交
1343

1344
static int
1345
cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1346
	   bool wait_flag, bool posix_lck, unsigned int xid)
1347 1348 1349
{
	int rc = 0;
	__u64 length = 1 + flock->fl_end - flock->fl_start;
1350 1351
	struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1352
	struct TCP_Server_Info *server = tcon->ses->server;
1353
	__u16 netfid = cfile->fid.netfid;
1354

1355 1356
	if (posix_lck) {
		int posix_lock_type;
1357 1358 1359 1360 1361

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

1362
		if (type & server->vals->shared_lock_type)
1363 1364 1365
			posix_lock_type = CIFS_RDLCK;
		else
			posix_lock_type = CIFS_WRLCK;
1366 1367
		rc = CIFSSMBPosixLock(xid, tcon, netfid,
				      hash_lockowner(flock->fl_owner),
1368
				      flock->fl_start, length, flock,
1369
				      posix_lock_type, wait_flag);
1370 1371
		return rc;
	}
L
Linus Torvalds 已提交
1372

1373
	rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1374 1375 1376
	if (!rc)
		return rc;

1377
	/* BB we could chain these into one lock request BB */
1378 1379
	rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
				    1, 0, false);
1380
	if (rc == 0) {
1381 1382
		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
					    type, 0, 1, false);
1383 1384
		flock->fl_type = F_UNLCK;
		if (rc != 0)
1385 1386
			cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
				 rc);
1387
		return 0;
L
Linus Torvalds 已提交
1388
	}
J
[CIFS]  
Jeremy Allison 已提交
1389

1390
	if (type & server->vals->shared_lock_type) {
1391
		flock->fl_type = F_WRLCK;
1392
		return 0;
J
[CIFS]  
Jeremy Allison 已提交
1393 1394
	}

1395 1396 1397 1398 1399
	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);
1400
	if (rc == 0) {
1401 1402
		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
			type | server->vals->shared_lock_type, 0, 1, false);
1403 1404
		flock->fl_type = F_RDLCK;
		if (rc != 0)
1405 1406
			cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
				 rc);
1407 1408 1409
	} else
		flock->fl_type = F_WRLCK;

1410
	return 0;
1411 1412
}

1413
void
1414 1415 1416 1417 1418 1419 1420
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);
}

1421
void
1422 1423 1424 1425 1426 1427 1428 1429 1430 1431
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);
	}
}

1432
int
1433 1434
cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
		  unsigned int xid)
1435 1436 1437 1438 1439
{
	int rc = 0, stored_rc;
	int types[] = {LOCKING_ANDX_LARGE_FILES,
		       LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
	unsigned int i;
1440
	unsigned int max_num, num, max_buf;
1441 1442
	LOCKING_ANDX_RANGE *buf, *cur;
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1443
	struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1444 1445 1446 1447 1448 1449
	struct cifsLockInfo *li, *tmp;
	__u64 length = 1 + flock->fl_end - flock->fl_start;
	struct list_head tmp_llist;

	INIT_LIST_HEAD(&tmp_llist);

1450 1451 1452 1453 1454 1455 1456 1457 1458 1459
	/*
	 * Accessing maxBuf is racy with cifs_reconnect - need to store value
	 * and check it for zero before using.
	 */
	max_buf = tcon->ses->server->maxBuf;
	if (!max_buf)
		return -EINVAL;

	max_num = (max_buf - sizeof(struct smb_hdr)) /
						sizeof(LOCKING_ANDX_RANGE);
1460
	buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1461 1462 1463
	if (!buf)
		return -ENOMEM;

1464
	down_write(&cinode->lock_sem);
1465 1466 1467
	for (i = 0; i < 2; i++) {
		cur = buf;
		num = 0;
1468
		list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1469 1470 1471 1472 1473 1474 1475 1476
			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;
1477
			if (cinode->can_cache_brlcks) {
1478 1479
				/*
				 * We can cache brlock requests - simply remove
1480
				 * a lock from the file's list.
1481 1482 1483 1484
				 */
				list_del(&li->llist);
				cifs_del_lock_waiters(li);
				kfree(li);
1485
				continue;
1486
			}
1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498
			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) {
1499 1500
				stored_rc = cifs_lockv(xid, tcon,
						       cfile->fid.netfid,
1501 1502 1503 1504 1505 1506 1507 1508
						       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,
1509
							&cfile->llist->locks);
1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520
					rc = stored_rc;
				} else
					/*
					 * The unlock range request succeed -
					 * free the tmp list.
					 */
					cifs_free_llist(&tmp_llist);
				cur = buf;
				num = 0;
			} else
				cur++;
1521 1522
		}
		if (num) {
1523
			stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1524 1525
					       types[i], num, 0, buf);
			if (stored_rc) {
1526 1527
				cifs_move_llist(&tmp_llist,
						&cfile->llist->locks);
1528 1529 1530 1531 1532 1533
				rc = stored_rc;
			} else
				cifs_free_llist(&tmp_llist);
		}
	}

1534
	up_write(&cinode->lock_sem);
1535 1536 1537 1538
	kfree(buf);
	return rc;
}

1539
static int
1540
cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1541 1542
	   bool wait_flag, bool posix_lck, int lock, int unlock,
	   unsigned int xid)
1543 1544 1545 1546 1547
{
	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);
1548
	struct TCP_Server_Info *server = tcon->ses->server;
1549
	struct inode *inode = d_inode(cfile->dentry);
1550 1551

	if (posix_lck) {
1552
		int posix_lock_type;
1553 1554 1555 1556 1557

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

1558
		if (type & server->vals->shared_lock_type)
1559 1560 1561
			posix_lock_type = CIFS_RDLCK;
		else
			posix_lock_type = CIFS_WRLCK;
1562

1563
		if (unlock == 1)
1564
			posix_lock_type = CIFS_UNLCK;
J
[CIFS]  
Jeremy Allison 已提交
1565

1566
		rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1567 1568
				      hash_lockowner(flock->fl_owner),
				      flock->fl_start, length,
1569
				      NULL, posix_lock_type, wait_flag);
1570 1571
		goto out;
	}
J
[CIFS]  
Jeremy Allison 已提交
1572

1573
	if (lock) {
1574 1575
		struct cifsLockInfo *lock;

1576
		lock = cifs_lock_init(flock->fl_start, length, type);
1577 1578 1579
		if (!lock)
			return -ENOMEM;

1580
		rc = cifs_lock_add_if(cfile, lock, wait_flag);
1581
		if (rc < 0) {
1582
			kfree(lock);
1583 1584 1585
			return rc;
		}
		if (!rc)
1586 1587
			goto out;

1588 1589 1590 1591 1592 1593 1594
		/*
		 * 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.
		 */
1595 1596
		if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
					CIFS_CACHE_READ(CIFS_I(inode))) {
1597
			cifs_zap_mapping(inode);
1598 1599
			cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
				 inode);
1600
			CIFS_I(inode)->oplock = 0;
1601 1602
		}

1603 1604
		rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
					    type, 1, 0, wait_flag);
1605 1606
		if (rc) {
			kfree(lock);
1607
			return rc;
1608
		}
1609

1610
		cifs_lock_add(cfile, lock);
1611
	} else if (unlock)
1612
		rc = server->ops->mand_unlock_range(cfile, flock, xid);
1613 1614

out:
1615
	if (flock->fl_flags & FL_POSIX && !rc)
1616
		rc = locks_lock_file_wait(file, flock);
1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630
	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;
1631
	__u32 type;
1632 1633

	rc = -EACCES;
1634
	xid = get_xid();
1635

1636 1637 1638
	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);
1639 1640 1641

	cfile = (struct cifsFileInfo *)file->private_data;
	tcon = tlink_tcon(cfile->tlink);
1642 1643 1644 1645

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

1646
	cifs_sb = CIFS_FILE_SB(file);
1647
	netfid = cfile->fid.netfid;
A
Al Viro 已提交
1648
	cinode = CIFS_I(file_inode(file));
1649

1650
	if (cap_unix(tcon->ses) &&
1651 1652 1653 1654 1655 1656 1657 1658
	    (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)) {
1659
		rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1660
		free_xid(xid);
1661 1662 1663 1664 1665 1666 1667 1668
		return rc;
	}

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

1673 1674
	rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
			xid);
1675
	free_xid(xid);
L
Linus Torvalds 已提交
1676 1677 1678
	return rc;
}

1679 1680 1681 1682
/*
 * update the file size (if needed) after a write. Should be called with
 * the inode->i_lock held
 */
1683
void
1684 1685 1686 1687 1688 1689 1690 1691 1692
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;
}

1693 1694 1695
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 已提交
1696 1697 1698 1699 1700
{
	int rc = 0;
	unsigned int bytes_written = 0;
	unsigned int total_written;
	struct cifs_sb_info *cifs_sb;
1701 1702
	struct cifs_tcon *tcon;
	struct TCP_Server_Info *server;
1703
	unsigned int xid;
1704
	struct dentry *dentry = open_file->dentry;
1705
	struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
1706
	struct cifs_io_parms io_parms;
L
Linus Torvalds 已提交
1707

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

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

1713 1714 1715 1716 1717
	tcon = tlink_tcon(open_file->tlink);
	server = tcon->ses->server;

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

1719
	xid = get_xid();
L
Linus Torvalds 已提交
1720 1721 1722 1723 1724

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

L
Linus Torvalds 已提交
1728 1729 1730
			if (open_file->invalidHandle) {
				/* we could deadlock if we called
				   filemap_fdatawait from here so tell
S
Steve French 已提交
1731
				   reopen_file not to flush data to
L
Linus Torvalds 已提交
1732
				   server now */
J
Jeff Layton 已提交
1733
				rc = cifs_reopen_file(open_file, false);
L
Linus Torvalds 已提交
1734 1735 1736
				if (rc != 0)
					break;
			}
1737

1738
			len = min(server->ops->wp_retry_size(d_inode(dentry)),
1739
				  (unsigned int)write_size - total_written);
1740 1741 1742
			/* iov[0] is reserved for smb header */
			iov[1].iov_base = (char *)write_data + total_written;
			iov[1].iov_len = len;
1743
			io_parms.pid = pid;
1744 1745
			io_parms.tcon = tcon;
			io_parms.offset = *offset;
1746
			io_parms.length = len;
1747 1748
			rc = server->ops->sync_write(xid, &open_file->fid,
					&io_parms, &bytes_written, iov, 1);
L
Linus Torvalds 已提交
1749 1750 1751 1752 1753
		}
		if (rc || (bytes_written == 0)) {
			if (total_written)
				break;
			else {
1754
				free_xid(xid);
L
Linus Torvalds 已提交
1755 1756
				return rc;
			}
1757
		} else {
1758
			spin_lock(&d_inode(dentry)->i_lock);
1759
			cifs_update_eof(cifsi, *offset, bytes_written);
1760
			spin_unlock(&d_inode(dentry)->i_lock);
1761
			*offset += bytes_written;
1762
		}
L
Linus Torvalds 已提交
1763 1764
	}

1765
	cifs_stats_bytes_written(tcon, total_written);
L
Linus Torvalds 已提交
1766

1767
	if (total_written > 0) {
1768 1769 1770 1771
		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 已提交
1772
	}
1773
	mark_inode_dirty_sync(d_inode(dentry));
1774
	free_xid(xid);
L
Linus Torvalds 已提交
1775 1776 1777
	return total_written;
}

1778 1779
struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
					bool fsuid_only)
S
Steve French 已提交
1780 1781
{
	struct cifsFileInfo *open_file = NULL;
1782
	struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1783
	struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1784 1785 1786 1787

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

1789
	spin_lock(&tcon->open_file_lock);
S
Steve French 已提交
1790 1791 1792 1793
	/* 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) {
1794
		if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1795
			continue;
1796
		if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
S
Steve French 已提交
1797 1798 1799
			if (!open_file->invalidHandle) {
				/* found a good file */
				/* lock it so it will not be closed on us */
1800 1801
				cifsFileInfo_get(open_file);
				spin_unlock(&tcon->open_file_lock);
S
Steve French 已提交
1802 1803 1804 1805 1806 1807 1808
				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 */
	}
1809
	spin_unlock(&tcon->open_file_lock);
S
Steve French 已提交
1810 1811 1812
	return NULL;
}

1813 1814
struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
					bool fsuid_only)
1815
{
1816
	struct cifsFileInfo *open_file, *inv_file = NULL;
1817
	struct cifs_sb_info *cifs_sb;
1818
	struct cifs_tcon *tcon;
1819
	bool any_available = false;
1820
	int rc;
1821
	unsigned int refind = 0;
1822

1823 1824 1825 1826
	/* 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 已提交
1827
	if (cifs_inode == NULL) {
1828
		cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1829 1830 1831 1832
		dump_stack();
		return NULL;
	}

1833
	cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1834
	tcon = cifs_sb_master_tcon(cifs_sb);
1835

1836 1837 1838 1839
	/* only filter by fsuid on multiuser mounts */
	if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
		fsuid_only = false;

1840
	spin_lock(&tcon->open_file_lock);
1841
refind_writable:
1842
	if (refind > MAX_REOPEN_ATT) {
1843
		spin_unlock(&tcon->open_file_lock);
1844 1845
		return NULL;
	}
1846
	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1847 1848
		if (!any_available && open_file->pid != current->tgid)
			continue;
1849
		if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1850
			continue;
1851
		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1852 1853
			if (!open_file->invalidHandle) {
				/* found a good writable file */
1854 1855
				cifsFileInfo_get(open_file);
				spin_unlock(&tcon->open_file_lock);
1856
				return open_file;
1857 1858 1859
			} else {
				if (!inv_file)
					inv_file = open_file;
1860
			}
1861 1862
		}
	}
1863 1864 1865 1866 1867
	/* couldn't find useable FH with same pid, try any available */
	if (!any_available) {
		any_available = true;
		goto refind_writable;
	}
1868 1869 1870

	if (inv_file) {
		any_available = false;
1871
		cifsFileInfo_get(inv_file);
1872 1873
	}

1874
	spin_unlock(&tcon->open_file_lock);
1875 1876 1877 1878 1879 1880

	if (inv_file) {
		rc = cifs_reopen_file(inv_file, false);
		if (!rc)
			return inv_file;
		else {
1881
			spin_lock(&tcon->open_file_lock);
1882 1883
			list_move_tail(&inv_file->flist,
					&cifs_inode->openFileList);
1884
			spin_unlock(&tcon->open_file_lock);
1885 1886
			cifsFileInfo_put(inv_file);
			++refind;
1887
			inv_file = NULL;
1888
			spin_lock(&tcon->open_file_lock);
1889 1890 1891 1892
			goto refind_writable;
		}
	}

1893 1894 1895
	return NULL;
}

L
Linus Torvalds 已提交
1896 1897 1898
static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
{
	struct address_space *mapping = page->mapping;
1899
	loff_t offset = (loff_t)page->index << PAGE_SHIFT;
L
Linus Torvalds 已提交
1900 1901 1902 1903
	char *write_data;
	int rc = -EFAULT;
	int bytes_written = 0;
	struct inode *inode;
1904
	struct cifsFileInfo *open_file;
L
Linus Torvalds 已提交
1905 1906 1907 1908 1909 1910 1911 1912 1913 1914

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

	inode = page->mapping->host;

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

1915
	if ((to > PAGE_SIZE) || (from > to)) {
L
Linus Torvalds 已提交
1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927
		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 已提交
1928
		to = (unsigned)(mapping->host->i_size - offset);
L
Linus Torvalds 已提交
1929

1930
	open_file = find_writable_file(CIFS_I(mapping->host), false);
1931
	if (open_file) {
1932 1933
		bytes_written = cifs_write(open_file, open_file->pid,
					   write_data, to - from, &offset);
1934
		cifsFileInfo_put(open_file);
L
Linus Torvalds 已提交
1935
		/* Does mm or vfs already set times? */
1936
		inode->i_atime = inode->i_mtime = current_time(inode);
1937
		if ((bytes_written > 0) && (offset))
1938
			rc = 0;
1939 1940
		else if (bytes_written < 0)
			rc = bytes_written;
1941
	} else {
1942
		cifs_dbg(FYI, "No writeable filehandles for inode\n");
L
Linus Torvalds 已提交
1943 1944 1945 1946 1947 1948 1949
		rc = -EIO;
	}

	kunmap(page);
	return rc;
}

1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967
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)
{
	unsigned int nr_pages;
	struct page **pages;
	struct cifs_writedata *wdata;

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

	/*
	 * find_get_pages_tag seems to return a max of 256 on each
	 * iteration, so we must call it several times in order to
	 * fill the array or the wsize is effectively limited to
1968
	 * 256 * PAGE_SIZE.
1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983
	 */
	*found_pages = 0;
	pages = wdata->pages;
	do {
		nr_pages = find_get_pages_tag(mapping, index,
					      PAGECACHE_TAG_DIRTY, tofind,
					      pages);
		*found_pages += nr_pages;
		tofind -= nr_pages;
		pages += nr_pages;
	} while (nr_pages && tofind && *index <= end);

	return wdata;
}

1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 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
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];
		/*
		 * At this point we hold neither mapping->tree_lock nor
		 * lock on the page itself: the page may be truncated or
		 * invalidated (changing page->mapping to NULL), or even
		 * swizzled back from swapper_space to tmpfs file
		 * mapping
		 */

		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++) {
2057
		put_page(wdata->pages[i]);
2058 2059 2060 2061 2062 2063
		wdata->pages[i] = NULL;
	}

	return nr_pages;
}

2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074
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]);
2075
	wdata->pagesz = PAGE_SIZE;
2076 2077
	wdata->tailsz = min(i_size_read(mapping->host) -
			page_offset(wdata->pages[nr_pages - 1]),
2078 2079
			(loff_t)PAGE_SIZE);
	wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2080

2081 2082 2083 2084 2085 2086 2087
	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 {
2088 2089 2090
		wdata->pid = wdata->cfile->pid;
		server = tlink_tcon(wdata->cfile->tlink)->ses->server;
		rc = server->ops->async_writev(wdata, cifs_writedata_release);
2091
	}
2092 2093 2094 2095 2096 2097 2098

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

	return rc;
}

L
Linus Torvalds 已提交
2099
static int cifs_writepages(struct address_space *mapping,
2100
			   struct writeback_control *wbc)
L
Linus Torvalds 已提交
2101
{
2102
	struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
2103
	struct TCP_Server_Info *server;
2104 2105 2106
	bool done = false, scanned = false, range_whole = false;
	pgoff_t end, index;
	struct cifs_writedata *wdata;
2107
	int rc = 0;
2108

2109
	/*
2110
	 * If wsize is smaller than the page cache size, default to writing
2111 2112
	 * one page at a time via cifs_writepage
	 */
2113
	if (cifs_sb->wsize < PAGE_SIZE)
2114 2115
		return generic_writepages(mapping, wbc);

2116
	if (wbc->range_cyclic) {
2117
		index = mapping->writeback_index; /* Start from prev offset */
2118 2119
		end = -1;
	} else {
2120 2121
		index = wbc->range_start >> PAGE_SHIFT;
		end = wbc->range_end >> PAGE_SHIFT;
2122
		if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2123 2124
			range_whole = true;
		scanned = true;
2125
	}
2126
	server = cifs_sb_master_tcon(cifs_sb)->ses->server;
2127
retry:
2128
	while (!done && index <= end) {
2129
		unsigned int i, nr_pages, found_pages, wsize, credits;
2130
		pgoff_t next = 0, tofind, saved_index = index;
2131

2132 2133 2134 2135
		rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
						   &wsize, &credits);
		if (rc)
			break;
2136

2137
		tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2138

2139 2140
		wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
						  &found_pages);
2141 2142
		if (!wdata) {
			rc = -ENOMEM;
2143
			add_credits_and_wake_if(server, credits, 0);
2144 2145 2146 2147 2148
			break;
		}

		if (found_pages == 0) {
			kref_put(&wdata->refcount, cifs_writedata_release);
2149
			add_credits_and_wake_if(server, credits, 0);
2150 2151 2152
			break;
		}

2153 2154
		nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
					       end, &index, &next, &done);
2155

2156 2157 2158
		/* nothing to write? */
		if (nr_pages == 0) {
			kref_put(&wdata->refcount, cifs_writedata_release);
2159
			add_credits_and_wake_if(server, credits, 0);
2160
			continue;
2161
		}
2162

2163
		wdata->credits = credits;
2164

2165
		rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2166

2167 2168
		/* send failure -- clean up the mess */
		if (rc != 0) {
2169
			add_credits_and_wake_if(server, wdata->credits, 0);
2170
			for (i = 0; i < nr_pages; ++i) {
2171
				if (rc == -EAGAIN)
2172 2173 2174 2175 2176
					redirty_page_for_writepage(wbc,
							   wdata->pages[i]);
				else
					SetPageError(wdata->pages[i]);
				end_page_writeback(wdata->pages[i]);
2177
				put_page(wdata->pages[i]);
2178
			}
2179 2180
			if (rc != -EAGAIN)
				mapping_set_error(mapping, rc);
2181 2182
		}
		kref_put(&wdata->refcount, cifs_writedata_release);
2183

2184 2185 2186 2187 2188
		if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
			index = saved_index;
			continue;
		}

2189 2190 2191
		wbc->nr_to_write -= nr_pages;
		if (wbc->nr_to_write <= 0)
			done = true;
2192

2193
		index = next;
2194
	}
2195

2196 2197 2198 2199 2200
	if (!scanned && !done) {
		/*
		 * We hit the last page and there is more work to be done: wrap
		 * back to the start of the file
		 */
2201
		scanned = true;
2202 2203 2204
		index = 0;
		goto retry;
	}
2205

2206
	if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2207 2208
		mapping->writeback_index = index;

L
Linus Torvalds 已提交
2209 2210 2211
	return rc;
}

2212 2213
static int
cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
L
Linus Torvalds 已提交
2214
{
2215
	int rc;
2216
	unsigned int xid;
L
Linus Torvalds 已提交
2217

2218
	xid = get_xid();
L
Linus Torvalds 已提交
2219
/* BB add check for wbc flags */
2220
	get_page(page);
S
Steve French 已提交
2221
	if (!PageUptodate(page))
2222
		cifs_dbg(FYI, "ppw - page not up to date\n");
2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233

	/*
	 * 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 已提交
2234
	set_page_writeback(page);
2235
retry_write:
2236
	rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2237 2238 2239 2240 2241 2242 2243 2244
	if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
		goto retry_write;
	else if (rc == -EAGAIN)
		redirty_page_for_writepage(wbc, page);
	else if (rc != 0)
		SetPageError(page);
	else
		SetPageUptodate(page);
2245
	end_page_writeback(page);
2246
	put_page(page);
2247
	free_xid(xid);
L
Linus Torvalds 已提交
2248 2249 2250
	return rc;
}

2251 2252 2253 2254 2255 2256 2257
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 已提交
2258 2259 2260
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 已提交
2261
{
N
Nick Piggin 已提交
2262 2263
	int rc;
	struct inode *inode = mapping->host;
2264 2265 2266 2267 2268 2269 2270 2271
	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 已提交
2272

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

2276 2277 2278 2279
	if (PageChecked(page)) {
		if (copied == len)
			SetPageUptodate(page);
		ClearPageChecked(page);
2280
	} else if (!PageUptodate(page) && copied == PAGE_SIZE)
N
Nick Piggin 已提交
2281
		SetPageUptodate(page);
S
Steve French 已提交
2282

L
Linus Torvalds 已提交
2283
	if (!PageUptodate(page)) {
N
Nick Piggin 已提交
2284
		char *page_data;
2285
		unsigned offset = pos & (PAGE_SIZE - 1);
2286
		unsigned int xid;
N
Nick Piggin 已提交
2287

2288
		xid = get_xid();
L
Linus Torvalds 已提交
2289 2290 2291 2292 2293 2294
		/* 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);
2295
		rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
N
Nick Piggin 已提交
2296
		/* if (rc < 0) should we set writebehind rc? */
L
Linus Torvalds 已提交
2297
		kunmap(page);
N
Nick Piggin 已提交
2298

2299
		free_xid(xid);
S
Steve French 已提交
2300
	} else {
N
Nick Piggin 已提交
2301 2302
		rc = copied;
		pos += copied;
2303
		set_page_dirty(page);
L
Linus Torvalds 已提交
2304 2305
	}

N
Nick Piggin 已提交
2306 2307 2308 2309 2310 2311 2312 2313
	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);
2314
	put_page(page);
N
Nick Piggin 已提交
2315

L
Linus Torvalds 已提交
2316 2317 2318
	return rc;
}

2319 2320
int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
		      int datasync)
L
Linus Torvalds 已提交
2321
{
2322
	unsigned int xid;
L
Linus Torvalds 已提交
2323
	int rc = 0;
2324
	struct cifs_tcon *tcon;
2325
	struct TCP_Server_Info *server;
2326
	struct cifsFileInfo *smbfile = file->private_data;
A
Al Viro 已提交
2327
	struct inode *inode = file_inode(file);
2328
	struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
L
Linus Torvalds 已提交
2329

2330 2331 2332
	rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
	if (rc)
		return rc;
A
Al Viro 已提交
2333
	inode_lock(inode);
2334

2335
	xid = get_xid();
L
Linus Torvalds 已提交
2336

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

2340
	if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2341
		rc = cifs_zap_mapping(inode);
2342
		if (rc) {
2343
			cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2344 2345 2346
			rc = 0; /* don't care about it in fsync */
		}
	}
2347

2348
	tcon = tlink_tcon(smbfile->tlink);
2349 2350 2351 2352 2353 2354 2355
	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;
	}
2356

2357
	free_xid(xid);
A
Al Viro 已提交
2358
	inode_unlock(inode);
2359 2360 2361
	return rc;
}

2362
int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2363
{
2364
	unsigned int xid;
2365
	int rc = 0;
2366
	struct cifs_tcon *tcon;
2367
	struct TCP_Server_Info *server;
2368
	struct cifsFileInfo *smbfile = file->private_data;
2369
	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2370 2371 2372 2373 2374
	struct inode *inode = file->f_mapping->host;

	rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
	if (rc)
		return rc;
A
Al Viro 已提交
2375
	inode_lock(inode);
2376

2377
	xid = get_xid();
2378

A
Al Viro 已提交
2379 2380
	cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
		 file, datasync);
2381 2382

	tcon = tlink_tcon(smbfile->tlink);
2383 2384 2385 2386 2387 2388 2389
	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;
	}
2390

2391
	free_xid(xid);
A
Al Viro 已提交
2392
	inode_unlock(inode);
L
Linus Torvalds 已提交
2393 2394 2395 2396 2397 2398 2399
	return rc;
}

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

2405
	if (file->f_mode & FMODE_WRITE)
2406
		rc = filemap_write_and_wait(inode->i_mapping);
2407

2408
	cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
L
Linus Torvalds 已提交
2409 2410 2411 2412

	return rc;
}

2413 2414 2415 2416 2417 2418 2419
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++) {
2420
		pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2421 2422 2423 2424 2425 2426 2427
		if (!pages[i]) {
			/*
			 * save number of pages we have already allocated and
			 * return with ENOMEM error
			 */
			num_pages = i;
			rc = -ENOMEM;
2428
			break;
2429 2430 2431
		}
	}

2432 2433 2434 2435
	if (rc) {
		for (i = 0; i < num_pages; i++)
			put_page(pages[i]);
	}
2436 2437 2438 2439 2440 2441 2442 2443 2444 2445
	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 已提交
2446
	num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2447 2448 2449 2450 2451 2452 2453

	if (cur_len)
		*cur_len = clen;

	return num_pages;
}

2454
static void
2455
cifs_uncached_writedata_release(struct kref *refcount)
2456 2457
{
	int i;
2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468
	struct cifs_writedata *wdata = container_of(refcount,
					struct cifs_writedata, refcount);

	for (i = 0; i < wdata->nr_pages; i++)
		put_page(wdata->pages[i]);
	cifs_writedata_release(refcount);
}

static void
cifs_uncached_writev_complete(struct work_struct *work)
{
2469 2470
	struct cifs_writedata *wdata = container_of(work,
					struct cifs_writedata, work);
2471
	struct inode *inode = d_inode(wdata->cfile->dentry);
2472 2473 2474 2475 2476 2477 2478 2479 2480 2481
	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);

2482
	kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2483 2484 2485
}

static int
2486 2487
wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
		      size_t *len, unsigned long *num_pages)
2488
{
2489 2490
	size_t save_len, copied, bytes, cur_len = *len;
	unsigned long i, nr_pages = *num_pages;
2491

2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508
	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;
2509

2510 2511 2512 2513 2514 2515 2516 2517
	/*
	 * 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;
2518

2519 2520 2521 2522 2523 2524
	/*
	 * i + 1 now represents the number of pages we actually used in
	 * the copy phase above.
	 */
	*num_pages = i + 1;
	return 0;
2525 2526
}

2527 2528 2529 2530
static int
cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
		     struct cifsFileInfo *open_file,
		     struct cifs_sb_info *cifs_sb, struct list_head *wdata_list)
2531
{
2532 2533
	int rc = 0;
	size_t cur_len;
2534
	unsigned long nr_pages, num_pages, i;
2535
	struct cifs_writedata *wdata;
2536
	struct iov_iter saved_from = *from;
2537
	loff_t saved_offset = offset;
2538
	pid_t pid;
2539
	struct TCP_Server_Info *server;
2540 2541 2542 2543 2544 2545

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

2546 2547
	server = tlink_tcon(open_file->tlink)->ses->server;

2548
	do {
2549 2550 2551 2552 2553 2554
		unsigned int wsize, credits;

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

2556
		nr_pages = get_numpages(wsize, len, &cur_len);
2557 2558 2559 2560
		wdata = cifs_writedata_alloc(nr_pages,
					     cifs_uncached_writev_complete);
		if (!wdata) {
			rc = -ENOMEM;
2561
			add_credits_and_wake_if(server, credits, 0);
2562 2563 2564 2565 2566 2567
			break;
		}

		rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
		if (rc) {
			kfree(wdata);
2568
			add_credits_and_wake_if(server, credits, 0);
2569 2570 2571
			break;
		}

2572 2573 2574
		num_pages = nr_pages;
		rc = wdata_fill_from_iovec(wdata, from, &cur_len, &num_pages);
		if (rc) {
2575 2576 2577
			for (i = 0; i < nr_pages; i++)
				put_page(wdata->pages[i]);
			kfree(wdata);
2578
			add_credits_and_wake_if(server, credits, 0);
2579 2580 2581 2582
			break;
		}

		/*
2583 2584
		 * Bring nr_pages down to the number of pages we actually used,
		 * and free any pages that we didn't use.
2585
		 */
2586
		for ( ; nr_pages > num_pages; nr_pages--)
2587 2588
			put_page(wdata->pages[nr_pages - 1]);

2589 2590 2591 2592 2593 2594
		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;
2595 2596
		wdata->pagesz = PAGE_SIZE;
		wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2597
		wdata->credits = credits;
2598 2599 2600 2601 2602

		if (!wdata->cfile->invalidHandle ||
		    !cifs_reopen_file(wdata->cfile, false))
			rc = server->ops->async_writev(wdata,
					cifs_uncached_writedata_release);
2603
		if (rc) {
2604
			add_credits_and_wake_if(server, wdata->credits, 0);
2605 2606
			kref_put(&wdata->refcount,
				 cifs_uncached_writedata_release);
2607
			if (rc == -EAGAIN) {
2608
				*from = saved_from;
2609 2610 2611
				iov_iter_advance(from, offset - saved_offset);
				continue;
			}
2612 2613 2614
			break;
		}

2615
		list_add_tail(&wdata->list, wdata_list);
2616 2617
		offset += cur_len;
		len -= cur_len;
2618 2619
	} while (len > 0);

2620 2621 2622
	return rc;
}

2623
ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
2624
{
2625
	struct file *file = iocb->ki_filp;
2626 2627 2628 2629 2630 2631
	ssize_t total_written = 0;
	struct cifsFileInfo *open_file;
	struct cifs_tcon *tcon;
	struct cifs_sb_info *cifs_sb;
	struct cifs_writedata *wdata, *tmp;
	struct list_head wdata_list;
2632
	struct iov_iter saved_from = *from;
2633 2634
	int rc;

2635 2636 2637 2638 2639 2640
	/*
	 * 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.
	 */

2641 2642
	rc = generic_write_checks(iocb, from);
	if (rc <= 0)
2643 2644 2645
		return rc;

	INIT_LIST_HEAD(&wdata_list);
2646
	cifs_sb = CIFS_FILE_SB(file);
2647 2648 2649 2650 2651 2652
	open_file = file->private_data;
	tcon = tlink_tcon(open_file->tlink);

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

2653 2654
	rc = cifs_write_from_iter(iocb->ki_pos, iov_iter_count(from), from,
				  open_file, cifs_sb, &wdata_list);
2655

2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683
	/*
	 * 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(&wdata_list))
		rc = 0;

	/*
	 * Wait for and collect replies for any successful sends in order of
	 * increasing offset. Once an error is hit or we get a fatal signal
	 * while waiting, then return without waiting for any more replies.
	 */
restart_loop:
	list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
		if (!rc) {
			/* FIXME: freezable too? */
			rc = wait_for_completion_killable(&wdata->done);
			if (rc)
				rc = -EINTR;
			else if (wdata->result)
				rc = wdata->result;
			else
				total_written += wdata->bytes;

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

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

				iov_iter_advance(&tmp_from,
2691
						 wdata->offset - iocb->ki_pos);
2692 2693 2694 2695 2696 2697 2698 2699 2700

				rc = cifs_write_from_iter(wdata->offset,
						wdata->bytes, &tmp_from,
						open_file, cifs_sb, &tmp_list);

				list_splice(&tmp_list, &wdata_list);

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

2708 2709
	if (unlikely(!total_written))
		return rc;
2710

2711 2712
	iocb->ki_pos += total_written;
	set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(file_inode(file))->flags);
2713
	cifs_stats_bytes_written(tcon, total_written);
2714
	return total_written;
2715 2716
}

2717
static ssize_t
A
Al Viro 已提交
2718
cifs_writev(struct kiocb *iocb, struct iov_iter *from)
2719
{
2720 2721 2722 2723 2724
	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;
2725
	ssize_t rc;
2726

2727 2728 2729 2730 2731
	/*
	 * We need to hold the sem to be sure nobody modifies lock list
	 * with a brlock that prevents writing.
	 */
	down_read(&cinode->lock_sem);
A
Al Viro 已提交
2732
	inode_lock(inode);
2733

2734 2735
	rc = generic_write_checks(iocb, from);
	if (rc <= 0)
2736 2737 2738
		goto out;

	if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
2739
				     server->vals->exclusive_lock_type, NULL,
2740
				     CIFS_WRITE_OP))
A
Al Viro 已提交
2741
		rc = __generic_file_write_iter(iocb, from);
2742 2743 2744
	else
		rc = -EACCES;
out:
A
Al Viro 已提交
2745
	inode_unlock(inode);
A
Al Viro 已提交
2746

2747 2748
	if (rc > 0)
		rc = generic_write_sync(iocb, rc);
2749 2750 2751 2752 2753
	up_read(&cinode->lock_sem);
	return rc;
}

ssize_t
A
Al Viro 已提交
2754
cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
2755
{
A
Al Viro 已提交
2756
	struct inode *inode = file_inode(iocb->ki_filp);
2757 2758 2759 2760 2761
	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);
2762
	ssize_t written;
2763

2764 2765 2766 2767
	written = cifs_get_writer(cinode);
	if (written)
		return written;

2768
	if (CIFS_CACHE_WRITE(cinode)) {
2769 2770
		if (cap_unix(tcon->ses) &&
		(CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
2771
		  && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
A
Al Viro 已提交
2772
			written = generic_file_write_iter(iocb, from);
2773 2774
			goto out;
		}
A
Al Viro 已提交
2775
		written = cifs_writev(iocb, from);
2776
		goto out;
2777 2778
	}
	/*
2779 2780 2781 2782
	 * 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.
2783
	 */
A
Al Viro 已提交
2784
	written = cifs_user_writev(iocb, from);
2785
	if (written > 0 && CIFS_CACHE_READ(cinode)) {
2786 2787 2788 2789 2790
		/*
		 * Windows 7 server can delay breaking level2 oplock if a write
		 * request comes - break it on the client to prevent reading
		 * an old data.
		 */
2791
		cifs_zap_mapping(inode);
2792 2793
		cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
			 inode);
2794
		cinode->oplock = 0;
2795
	}
2796 2797
out:
	cifs_put_writer(cinode);
2798
	return written;
2799 2800
}

2801
static struct cifs_readdata *
2802
cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
2803 2804
{
	struct cifs_readdata *rdata;
2805

2806 2807
	rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
			GFP_KERNEL);
2808
	if (rdata != NULL) {
2809
		kref_init(&rdata->refcount);
2810 2811
		INIT_LIST_HEAD(&rdata->list);
		init_completion(&rdata->done);
2812 2813
		INIT_WORK(&rdata->work, complete);
	}
2814

2815 2816 2817
	return rdata;
}

2818 2819
void
cifs_readdata_release(struct kref *refcount)
2820
{
2821 2822 2823 2824 2825 2826
	struct cifs_readdata *rdata = container_of(refcount,
					struct cifs_readdata, refcount);

	if (rdata->cfile)
		cifsFileInfo_put(rdata->cfile);

2827 2828 2829
	kfree(rdata);
}

2830
static int
2831
cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
2832 2833
{
	int rc = 0;
2834
	struct page *page;
2835 2836
	unsigned int i;

2837
	for (i = 0; i < nr_pages; i++) {
2838 2839 2840 2841 2842
		page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
		if (!page) {
			rc = -ENOMEM;
			break;
		}
2843
		rdata->pages[i] = page;
2844 2845 2846
	}

	if (rc) {
2847 2848 2849
		for (i = 0; i < nr_pages; i++) {
			put_page(rdata->pages[i]);
			rdata->pages[i] = NULL;
2850 2851 2852 2853 2854 2855 2856 2857 2858 2859
		}
	}
	return rc;
}

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

2862 2863 2864
	for (i = 0; i < rdata->nr_pages; i++) {
		put_page(rdata->pages[i]);
		rdata->pages[i] = NULL;
2865 2866 2867 2868 2869 2870 2871
	}
	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
2872
 * @iter:	destination for our data
2873 2874 2875 2876 2877
 *
 * 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.
 */
2878 2879
static int
cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
2880
{
2881
	size_t remaining = rdata->got_bytes;
2882
	unsigned int i;
2883

2884 2885
	for (i = 0; i < rdata->nr_pages; i++) {
		struct page *page = rdata->pages[i];
2886
		size_t copy = min_t(size_t, remaining, PAGE_SIZE);
2887 2888 2889 2890
		size_t written = copy_page_to_iter(page, 0, copy, iter);
		remaining -= written;
		if (written < copy && iov_iter_count(iter) > 0)
			break;
2891
	}
2892
	return remaining ? -EFAULT : 0;
2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905
}

static void
cifs_uncached_readv_complete(struct work_struct *work)
{
	struct cifs_readdata *rdata = container_of(work,
						struct cifs_readdata, work);

	complete(&rdata->done);
	kref_put(&rdata->refcount, cifs_uncached_readdata_release);
}

static int
2906 2907
cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
			struct cifs_readdata *rdata, unsigned int len)
2908
{
2909
	int result = 0;
2910 2911
	unsigned int i;
	unsigned int nr_pages = rdata->nr_pages;
2912

2913
	rdata->got_bytes = 0;
2914
	rdata->tailsz = PAGE_SIZE;
2915 2916
	for (i = 0; i < nr_pages; i++) {
		struct page *page = rdata->pages[i];
2917
		size_t n;
2918

2919
		if (len <= 0) {
2920
			/* no need to hold page hostage */
2921 2922
			rdata->pages[i] = NULL;
			rdata->nr_pages--;
2923
			put_page(page);
2924
			continue;
2925
		}
2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936
		n = len;
		if (len >= PAGE_SIZE) {
			/* enough data to fill the page */
			n = PAGE_SIZE;
			len -= n;
		} else {
			zero_user(page, len, PAGE_SIZE - len);
			rdata->tailsz = len;
			len = 0;
		}
		result = cifs_read_page_from_socket(server, page, n);
2937 2938 2939
		if (result < 0)
			break;

2940
		rdata->got_bytes += result;
2941 2942
	}

2943 2944
	return rdata->got_bytes > 0 && result != -ECONNABORTED ?
						rdata->got_bytes : result;
2945 2946
}

2947 2948 2949
static int
cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
		     struct cifs_sb_info *cifs_sb, struct list_head *rdata_list)
L
Linus Torvalds 已提交
2950
{
2951
	struct cifs_readdata *rdata;
2952
	unsigned int npages, rsize, credits;
2953 2954
	size_t cur_len;
	int rc;
2955
	pid_t pid;
2956
	struct TCP_Server_Info *server;
2957

2958
	server = tlink_tcon(open_file->tlink)->ses->server;
2959

2960 2961 2962 2963 2964
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

2965
	do {
2966 2967 2968 2969 2970 2971
		rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
						   &rsize, &credits);
		if (rc)
			break;

		cur_len = min_t(const size_t, len, rsize);
2972
		npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
2973

2974 2975 2976 2977
		/* allocate a readdata struct */
		rdata = cifs_readdata_alloc(npages,
					    cifs_uncached_readv_complete);
		if (!rdata) {
2978
			add_credits_and_wake_if(server, credits, 0);
2979
			rc = -ENOMEM;
2980
			break;
L
Linus Torvalds 已提交
2981
		}
2982

2983
		rc = cifs_read_allocate_pages(rdata, npages);
2984 2985 2986 2987
		if (rc)
			goto error;

		rdata->cfile = cifsFileInfo_get(open_file);
2988
		rdata->nr_pages = npages;
2989 2990 2991
		rdata->offset = offset;
		rdata->bytes = cur_len;
		rdata->pid = pid;
2992 2993
		rdata->pagesz = PAGE_SIZE;
		rdata->read_into_pages = cifs_uncached_read_into_pages;
2994
		rdata->credits = credits;
2995

2996 2997 2998
		if (!rdata->cfile->invalidHandle ||
		    !cifs_reopen_file(rdata->cfile, true))
			rc = server->ops->async_readv(rdata);
2999 3000
error:
		if (rc) {
3001
			add_credits_and_wake_if(server, rdata->credits, 0);
3002 3003
			kref_put(&rdata->refcount,
				 cifs_uncached_readdata_release);
3004 3005
			if (rc == -EAGAIN)
				continue;
3006 3007 3008
			break;
		}

3009
		list_add_tail(&rdata->list, rdata_list);
3010 3011 3012 3013
		offset += cur_len;
		len -= cur_len;
	} while (len > 0);

3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034
	return rc;
}

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 *open_file;
	struct cifs_readdata *rdata, *tmp;
	struct list_head rdata_list;

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

	INIT_LIST_HEAD(&rdata_list);
3035
	cifs_sb = CIFS_FILE_SB(file);
3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046
	open_file = file->private_data;
	tcon = tlink_tcon(open_file->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");

	rc = cifs_send_async_read(offset, len, open_file, cifs_sb, &rdata_list);

3047 3048 3049 3050
	/* if at least one read request send succeeded, then reset rc */
	if (!list_empty(&rdata_list))
		rc = 0;

A
Al Viro 已提交
3051
	len = iov_iter_count(to);
3052
	/* the loop below should proceed in the order of increasing offsets */
3053
again:
3054 3055 3056 3057 3058 3059
	list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
		if (!rc) {
			/* FIXME: freezable sleep too? */
			rc = wait_for_completion_killable(&rdata->done);
			if (rc)
				rc = -EINTR;
3060
			else if (rdata->result == -EAGAIN) {
3061
				/* resend call if it's a retryable error */
3062
				struct list_head tmp_list;
3063
				unsigned int got_bytes = rdata->got_bytes;
3064

3065 3066
				list_del_init(&rdata->list);
				INIT_LIST_HEAD(&tmp_list);
3067

3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079
				/*
				 * 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;
					}
3080
				}
3081 3082 3083 3084 3085 3086

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

3088
				list_splice(&tmp_list, &rdata_list);
3089

3090 3091 3092 3093 3094 3095
				kref_put(&rdata->refcount,
					 cifs_uncached_readdata_release);
				goto again;
			} else if (rdata->result)
				rc = rdata->result;
			else
A
Al Viro 已提交
3096
				rc = cifs_readdata_to_iov(rdata, to);
3097

3098 3099 3100
			/* if there was a short read -- discard anything left */
			if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
				rc = -ENODATA;
L
Linus Torvalds 已提交
3101
		}
3102 3103
		list_del_init(&rdata->list);
		kref_put(&rdata->refcount, cifs_uncached_readdata_release);
L
Linus Torvalds 已提交
3104
	}
3105

A
Al Viro 已提交
3106
	total_read = len - iov_iter_count(to);
3107

3108 3109
	cifs_stats_bytes_read(tcon, total_read);

3110 3111 3112 3113
	/* mask nodata case */
	if (rc == -ENODATA)
		rc = 0;

3114
	if (total_read) {
A
Al Viro 已提交
3115
		iocb->ki_pos += total_read;
3116 3117 3118
		return total_read;
	}
	return rc;
3119 3120
}

3121
ssize_t
A
Al Viro 已提交
3122
cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3123
{
A
Al Viro 已提交
3124
	struct inode *inode = file_inode(iocb->ki_filp);
3125 3126 3127 3128 3129 3130
	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;
3131 3132 3133 3134 3135 3136 3137 3138 3139

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

3143 3144 3145
	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 已提交
3146
		return generic_file_read_iter(iocb, to);
3147 3148 3149 3150 3151 3152

	/*
	 * 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 已提交
3153
	if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3154
				     tcon->ses->server->vals->shared_lock_type,
3155
				     NULL, CIFS_READ_OP))
A
Al Viro 已提交
3156
		rc = generic_file_read_iter(iocb, to);
3157 3158
	up_read(&cinode->lock_sem);
	return rc;
3159
}
L
Linus Torvalds 已提交
3160

3161 3162
static ssize_t
cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
L
Linus Torvalds 已提交
3163 3164 3165 3166 3167
{
	int rc = -EACCES;
	unsigned int bytes_read = 0;
	unsigned int total_read;
	unsigned int current_read_size;
3168
	unsigned int rsize;
L
Linus Torvalds 已提交
3169
	struct cifs_sb_info *cifs_sb;
3170
	struct cifs_tcon *tcon;
3171
	struct TCP_Server_Info *server;
3172
	unsigned int xid;
3173
	char *cur_offset;
L
Linus Torvalds 已提交
3174
	struct cifsFileInfo *open_file;
3175
	struct cifs_io_parms io_parms;
3176
	int buf_type = CIFS_NO_BUFFER;
3177
	__u32 pid;
L
Linus Torvalds 已提交
3178

3179
	xid = get_xid();
3180
	cifs_sb = CIFS_FILE_SB(file);
L
Linus Torvalds 已提交
3181

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

L
Linus Torvalds 已提交
3185
	if (file->private_data == NULL) {
3186
		rc = -EBADF;
3187
		free_xid(xid);
3188
		return rc;
L
Linus Torvalds 已提交
3189
	}
3190
	open_file = file->private_data;
3191
	tcon = tlink_tcon(open_file->tlink);
3192 3193 3194 3195 3196 3197
	server = tcon->ses->server;

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

3199 3200 3201 3202 3203
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

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

3207 3208
	for (total_read = 0, cur_offset = read_data; read_size > total_read;
	     total_read += bytes_read, cur_offset += bytes_read) {
3209 3210 3211 3212 3213 3214 3215 3216 3217
		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 &
3218
				tcon->ses->server->vals->cap_large_files)) {
3219 3220 3221
				current_read_size = min_t(uint,
					current_read_size, CIFSMaxBufSize);
			}
3222
			if (open_file->invalidHandle) {
J
Jeff Layton 已提交
3223
				rc = cifs_reopen_file(open_file, true);
L
Linus Torvalds 已提交
3224 3225 3226
				if (rc != 0)
					break;
			}
3227
			io_parms.pid = pid;
3228
			io_parms.tcon = tcon;
3229
			io_parms.offset = *offset;
3230
			io_parms.length = current_read_size;
3231
			rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
3232 3233
						    &bytes_read, &cur_offset,
						    &buf_type);
3234 3235
		} while (rc == -EAGAIN);

L
Linus Torvalds 已提交
3236 3237 3238 3239
		if (rc || (bytes_read == 0)) {
			if (total_read) {
				break;
			} else {
3240
				free_xid(xid);
L
Linus Torvalds 已提交
3241 3242 3243
				return rc;
			}
		} else {
3244
			cifs_stats_bytes_read(tcon, total_read);
3245
			*offset += bytes_read;
L
Linus Torvalds 已提交
3246 3247
		}
	}
3248
	free_xid(xid);
L
Linus Torvalds 已提交
3249 3250 3251
	return total_read;
}

3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264
/*
 * 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.
 */
static int
cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
{
	struct page *page = vmf->page;

	lock_page(page);
	return VM_FAULT_LOCKED;
}

3265
static const struct vm_operations_struct cifs_file_vm_ops = {
3266
	.fault = filemap_fault,
3267
	.map_pages = filemap_map_pages,
3268 3269 3270
	.page_mkwrite = cifs_page_mkwrite,
};

3271 3272 3273
int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
{
	int rc, xid;
A
Al Viro 已提交
3274
	struct inode *inode = file_inode(file);
3275

3276
	xid = get_xid();
3277

3278
	if (!CIFS_CACHE_READ(CIFS_I(inode))) {
3279
		rc = cifs_zap_mapping(inode);
3280 3281 3282
		if (rc)
			return rc;
	}
3283 3284

	rc = generic_file_mmap(file, vma);
3285 3286
	if (rc == 0)
		vma->vm_ops = &cifs_file_vm_ops;
3287
	free_xid(xid);
3288 3289 3290
	return rc;
}

L
Linus Torvalds 已提交
3291 3292 3293 3294
int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
{
	int rc, xid;

3295
	xid = get_xid();
J
Jeff Layton 已提交
3296
	rc = cifs_revalidate_file(file);
L
Linus Torvalds 已提交
3297
	if (rc) {
3298 3299
		cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
			 rc);
3300
		free_xid(xid);
L
Linus Torvalds 已提交
3301 3302 3303
		return rc;
	}
	rc = generic_file_mmap(file, vma);
3304 3305
	if (rc == 0)
		vma->vm_ops = &cifs_file_vm_ops;
3306
	free_xid(xid);
L
Linus Torvalds 已提交
3307 3308 3309
	return rc;
}

3310 3311 3312
static void
cifs_readv_complete(struct work_struct *work)
{
3313
	unsigned int i, got_bytes;
3314 3315 3316
	struct cifs_readdata *rdata = container_of(work,
						struct cifs_readdata, work);

3317
	got_bytes = rdata->got_bytes;
3318 3319 3320
	for (i = 0; i < rdata->nr_pages; i++) {
		struct page *page = rdata->pages[i];

3321 3322
		lru_cache_add_file(page);

3323 3324
		if (rdata->result == 0 ||
		    (rdata->result == -EAGAIN && got_bytes)) {
3325 3326 3327 3328 3329 3330
			flush_dcache_page(page);
			SetPageUptodate(page);
		}

		unlock_page(page);

3331 3332
		if (rdata->result == 0 ||
		    (rdata->result == -EAGAIN && got_bytes))
3333 3334
			cifs_readpage_to_fscache(rdata->mapping->host, page);

3335
		got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
3336

3337
		put_page(page);
3338
		rdata->pages[i] = NULL;
3339
	}
3340
	kref_put(&rdata->refcount, cifs_readdata_release);
3341 3342
}

3343
static int
3344 3345
cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
			struct cifs_readdata *rdata, unsigned int len)
3346
{
3347
	int result = 0;
3348
	unsigned int i;
3349 3350
	u64 eof;
	pgoff_t eof_index;
3351
	unsigned int nr_pages = rdata->nr_pages;
3352 3353 3354

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

3358
	rdata->got_bytes = 0;
3359
	rdata->tailsz = PAGE_SIZE;
3360 3361
	for (i = 0; i < nr_pages; i++) {
		struct page *page = rdata->pages[i];
3362
		size_t n = PAGE_SIZE;
3363

3364 3365
		if (len >= PAGE_SIZE) {
			len -= PAGE_SIZE;
3366
		} else if (len > 0) {
3367
			/* enough for partial page, fill and zero the rest */
3368
			zero_user(page, len, PAGE_SIZE - len);
3369
			n = rdata->tailsz = len;
3370
			len = 0;
3371 3372 3373 3374 3375 3376 3377 3378 3379
		} 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.
			 */
3380
			zero_user(page, 0, PAGE_SIZE);
3381 3382 3383 3384
			lru_cache_add_file(page);
			flush_dcache_page(page);
			SetPageUptodate(page);
			unlock_page(page);
3385
			put_page(page);
3386 3387
			rdata->pages[i] = NULL;
			rdata->nr_pages--;
3388
			continue;
3389 3390 3391 3392
		} else {
			/* no need to hold page hostage */
			lru_cache_add_file(page);
			unlock_page(page);
3393
			put_page(page);
3394 3395
			rdata->pages[i] = NULL;
			rdata->nr_pages--;
3396
			continue;
3397
		}
3398

3399
		result = cifs_read_page_from_socket(server, page, n);
3400 3401 3402
		if (result < 0)
			break;

3403
		rdata->got_bytes += result;
3404 3405
	}

3406 3407
	return rdata->got_bytes > 0 && result != -ECONNABORTED ?
						rdata->got_bytes : result;
3408 3409
}

3410 3411 3412 3413 3414 3415 3416 3417
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;
3418
	gfp_t gfp = readahead_gfp_mask(mapping);
3419

3420 3421
	INIT_LIST_HEAD(tmplist);

3422 3423 3424 3425 3426 3427 3428
	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.
	 */
3429
	__SetPageLocked(page);
3430
	rc = add_to_page_cache_locked(page, mapping,
3431
				      page->index, gfp);
3432 3433 3434

	/* give up if we can't stick it in the cache */
	if (rc) {
3435
		__ClearPageLocked(page);
3436 3437 3438 3439
		return rc;
	}

	/* move first page to the tmplist */
3440 3441
	*offset = (loff_t)page->index << PAGE_SHIFT;
	*bytes = PAGE_SIZE;
3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452
	*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? */
3453
		if (*bytes + PAGE_SIZE > rsize)
3454 3455
			break;

3456
		__SetPageLocked(page);
3457
		if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
3458
			__ClearPageLocked(page);
3459 3460 3461
			break;
		}
		list_move_tail(&page->lru, tmplist);
3462
		(*bytes) += PAGE_SIZE;
3463 3464 3465 3466
		expected_index++;
		(*nr_pages)++;
	}
	return rc;
3467 3468
}

L
Linus Torvalds 已提交
3469 3470 3471
static int cifs_readpages(struct file *file, struct address_space *mapping,
	struct list_head *page_list, unsigned num_pages)
{
3472 3473 3474
	int rc;
	struct list_head tmplist;
	struct cifsFileInfo *open_file = file->private_data;
3475
	struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
3476
	struct TCP_Server_Info *server;
3477
	pid_t pid;
L
Linus Torvalds 已提交
3478

3479 3480 3481
	/*
	 * Reads as many pages as possible from fscache. Returns -ENOBUFS
	 * immediately if the cookie is negative
3482 3483 3484
	 *
	 * 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.
3485 3486 3487 3488
	 */
	rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
					 &num_pages);
	if (rc == 0)
3489
		return rc;
3490

3491 3492 3493 3494 3495
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

3496
	rc = 0;
3497
	server = tlink_tcon(open_file->tlink)->ses->server;
L
Linus Torvalds 已提交
3498

3499 3500
	cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
		 __func__, file, mapping, num_pages);
3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513

	/*
	 * 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)) {
3514
		unsigned int i, nr_pages, bytes, rsize;
3515 3516 3517
		loff_t offset;
		struct page *page, *tpage;
		struct cifs_readdata *rdata;
3518
		unsigned credits;
L
Linus Torvalds 已提交
3519

3520 3521 3522 3523
		rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
						   &rsize, &credits);
		if (rc)
			break;
3524 3525

		/*
3526 3527 3528 3529
		 * 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.
3530
		 */
3531
		if (unlikely(rsize < PAGE_SIZE)) {
3532
			add_credits_and_wake_if(server, credits, 0);
3533
			return 0;
3534
		}
3535

3536 3537
		rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
					 &nr_pages, &offset, &bytes);
3538
		if (rc) {
3539
			add_credits_and_wake_if(server, credits, 0);
3540 3541 3542
			break;
		}

3543
		rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3544 3545 3546 3547 3548 3549
		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);
3550
				put_page(page);
3551 3552
			}
			rc = -ENOMEM;
3553
			add_credits_and_wake_if(server, credits, 0);
3554 3555 3556
			break;
		}

3557
		rdata->cfile = cifsFileInfo_get(open_file);
3558 3559 3560 3561
		rdata->mapping = mapping;
		rdata->offset = offset;
		rdata->bytes = bytes;
		rdata->pid = pid;
3562
		rdata->pagesz = PAGE_SIZE;
3563
		rdata->read_into_pages = cifs_readpages_read_into_pages;
3564
		rdata->credits = credits;
3565 3566 3567 3568 3569

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

3571 3572 3573 3574
		if (!rdata->cfile->invalidHandle ||
		    !cifs_reopen_file(rdata->cfile, true))
			rc = server->ops->async_readv(rdata);
		if (rc) {
3575
			add_credits_and_wake_if(server, rdata->credits, 0);
3576 3577
			for (i = 0; i < rdata->nr_pages; i++) {
				page = rdata->pages[i];
3578 3579
				lru_cache_add_file(page);
				unlock_page(page);
3580
				put_page(page);
L
Linus Torvalds 已提交
3581
			}
3582
			/* Fallback to the readpage in error/reconnect cases */
3583
			kref_put(&rdata->refcount, cifs_readdata_release);
L
Linus Torvalds 已提交
3584 3585
			break;
		}
3586 3587

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

3590 3591 3592 3593 3594
	/* 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 已提交
3595 3596 3597
	return rc;
}

3598 3599 3600
/*
 * cifs_readpage_worker must be called with the page pinned
 */
L
Linus Torvalds 已提交
3601 3602 3603 3604 3605 3606
static int cifs_readpage_worker(struct file *file, struct page *page,
	loff_t *poffset)
{
	char *read_data;
	int rc;

3607
	/* Is the page cached? */
A
Al Viro 已提交
3608
	rc = cifs_readpage_from_fscache(file_inode(file), page);
3609 3610 3611
	if (rc == 0)
		goto read_complete;

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

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

L
Linus Torvalds 已提交
3617 3618 3619
	if (rc < 0)
		goto io_error;
	else
3620
		cifs_dbg(FYI, "Bytes read %d\n", rc);
S
Steve French 已提交
3621

A
Al Viro 已提交
3622
	file_inode(file)->i_atime =
3623
		current_time(file_inode(file));
S
Steve French 已提交
3624

3625 3626
	if (PAGE_SIZE > rc)
		memset(read_data + rc, 0, PAGE_SIZE - rc);
L
Linus Torvalds 已提交
3627 3628 3629

	flush_dcache_page(page);
	SetPageUptodate(page);
3630 3631

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

L
Linus Torvalds 已提交
3634
	rc = 0;
S
Steve French 已提交
3635

L
Linus Torvalds 已提交
3636
io_error:
S
Steve French 已提交
3637
	kunmap(page);
3638
	unlock_page(page);
3639 3640

read_complete:
L
Linus Torvalds 已提交
3641 3642 3643 3644 3645
	return rc;
}

static int cifs_readpage(struct file *file, struct page *page)
{
3646
	loff_t offset = (loff_t)page->index << PAGE_SHIFT;
L
Linus Torvalds 已提交
3647
	int rc = -EACCES;
3648
	unsigned int xid;
L
Linus Torvalds 已提交
3649

3650
	xid = get_xid();
L
Linus Torvalds 已提交
3651 3652

	if (file->private_data == NULL) {
3653
		rc = -EBADF;
3654
		free_xid(xid);
3655
		return rc;
L
Linus Torvalds 已提交
3656 3657
	}

3658
	cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
3659
		 page, (int)offset, (int)offset);
L
Linus Torvalds 已提交
3660 3661 3662

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

3663
	free_xid(xid);
L
Linus Torvalds 已提交
3664 3665 3666
	return rc;
}

3667 3668 3669
static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
{
	struct cifsFileInfo *open_file;
3670 3671
	struct cifs_tcon *tcon =
		cifs_sb_master_tcon(CIFS_SB(cifs_inode->vfs_inode.i_sb));
3672

3673
	spin_lock(&tcon->open_file_lock);
3674
	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
3675
		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
3676
			spin_unlock(&tcon->open_file_lock);
3677 3678 3679
			return 1;
		}
	}
3680
	spin_unlock(&tcon->open_file_lock);
3681 3682 3683
	return 0;
}

L
Linus Torvalds 已提交
3684 3685 3686
/* 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 已提交
3687
   refreshing the inode only on increases in the file size
L
Linus Torvalds 已提交
3688 3689
   but this is tricky to do without racing with writebehind
   page caching in the current Linux kernel design */
3690
bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
L
Linus Torvalds 已提交
3691
{
3692
	if (!cifsInode)
3693
		return true;
3694

3695 3696
	if (is_inode_writable(cifsInode)) {
		/* This inode is open for write at least once */
3697 3698 3699
		struct cifs_sb_info *cifs_sb;

		cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
S
Steve French 已提交
3700
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
S
Steve French 已提交
3701
			/* since no page cache to corrupt on directio
3702
			we can change size safely */
3703
			return true;
3704 3705
		}

S
Steve French 已提交
3706
		if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
3707
			return true;
3708

3709
		return false;
3710
	} else
3711
		return true;
L
Linus Torvalds 已提交
3712 3713
}

N
Nick Piggin 已提交
3714 3715 3716
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 已提交
3717
{
3718
	int oncethru = 0;
3719 3720
	pgoff_t index = pos >> PAGE_SHIFT;
	loff_t offset = pos & (PAGE_SIZE - 1);
3721 3722 3723 3724
	loff_t page_start = pos & PAGE_MASK;
	loff_t i_size;
	struct page *page;
	int rc = 0;
N
Nick Piggin 已提交
3725

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

3728
start:
3729
	page = grab_cache_page_write_begin(mapping, index, flags);
3730 3731 3732 3733
	if (!page) {
		rc = -ENOMEM;
		goto out;
	}
3734

3735 3736
	if (PageUptodate(page))
		goto out;
3737

3738 3739 3740 3741 3742
	/*
	 * 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.
	 */
3743
	if (len == PAGE_SIZE)
3744
		goto out;
3745

3746 3747 3748 3749 3750 3751
	/*
	 * 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.
	 */
3752
	if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
3753 3754 3755 3756 3757
		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,
3758
					   PAGE_SIZE);
3759 3760 3761 3762 3763 3764 3765 3766 3767 3768
			/*
			 * 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 已提交
3769

3770
	if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
3771 3772 3773 3774 3775 3776
		/*
		 * 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);
3777
		put_page(page);
3778 3779
		oncethru = 1;
		goto start;
3780 3781 3782 3783
	} 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 已提交
3784
		   this will be written out by write_end so is fine */
L
Linus Torvalds 已提交
3785
	}
3786 3787 3788
out:
	*pagep = page;
	return rc;
L
Linus Torvalds 已提交
3789 3790
}

3791 3792 3793 3794 3795 3796 3797 3798
static int cifs_release_page(struct page *page, gfp_t gfp)
{
	if (PagePrivate(page))
		return 0;

	return cifs_fscache_release_page(page, gfp);
}

3799 3800
static void cifs_invalidate_page(struct page *page, unsigned int offset,
				 unsigned int length)
3801 3802 3803
{
	struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);

3804
	if (offset == 0 && length == PAGE_SIZE)
3805 3806 3807
		cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
}

3808 3809 3810 3811
static int cifs_launder_page(struct page *page)
{
	int rc = 0;
	loff_t range_start = page_offset(page);
3812
	loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
3813 3814 3815 3816 3817 3818 3819
	struct writeback_control wbc = {
		.sync_mode = WB_SYNC_ALL,
		.nr_to_write = 0,
		.range_start = range_start,
		.range_end = range_end,
	};

3820
	cifs_dbg(FYI, "Launder page: %p\n", page);
3821 3822 3823 3824 3825 3826 3827 3828

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

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

3829
void cifs_oplock_break(struct work_struct *work)
3830 3831 3832
{
	struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
						  oplock_break);
3833
	struct inode *inode = d_inode(cfile->dentry);
3834
	struct cifsInodeInfo *cinode = CIFS_I(inode);
3835
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3836
	struct TCP_Server_Info *server = tcon->ses->server;
3837
	int rc = 0;
3838

3839
	wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
3840
			TASK_UNINTERRUPTIBLE);
3841 3842 3843 3844

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

3845
	if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
3846
						cifs_has_mand_locks(cinode)) {
3847 3848
		cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
			 inode);
3849
		cinode->oplock = 0;
3850 3851
	}

3852
	if (inode && S_ISREG(inode->i_mode)) {
3853
		if (CIFS_CACHE_READ(cinode))
3854
			break_lease(inode, O_RDONLY);
S
Steve French 已提交
3855
		else
3856
			break_lease(inode, O_WRONLY);
3857
		rc = filemap_fdatawrite(inode->i_mapping);
3858
		if (!CIFS_CACHE_READ(cinode)) {
3859 3860
			rc = filemap_fdatawait(inode->i_mapping);
			mapping_set_error(inode->i_mapping, rc);
3861
			cifs_zap_mapping(inode);
3862
		}
3863
		cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
3864 3865
	}

3866 3867
	rc = cifs_push_locks(cfile);
	if (rc)
3868
		cifs_dbg(VFS, "Push locks rc = %d\n", rc);
3869

3870 3871 3872 3873 3874 3875
	/*
	 * 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
	 */
3876
	if (!cfile->oplock_break_cancelled) {
3877 3878
		rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
							     cinode);
3879
		cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
3880
	}
3881
	cifs_done_oplock_break(cinode);
3882 3883
}

3884 3885 3886 3887 3888 3889 3890 3891 3892 3893
/*
 * 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
3894
cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
3895 3896 3897 3898 3899 3900 3901 3902 3903
{
        /*
         * FIXME
         * Eventually need to support direct IO for non forcedirectio mounts
         */
        return -EINVAL;
}


3904
const struct address_space_operations cifs_addr_ops = {
L
Linus Torvalds 已提交
3905 3906 3907
	.readpage = cifs_readpage,
	.readpages = cifs_readpages,
	.writepage = cifs_writepage,
3908
	.writepages = cifs_writepages,
N
Nick Piggin 已提交
3909 3910
	.write_begin = cifs_write_begin,
	.write_end = cifs_write_end,
L
Linus Torvalds 已提交
3911
	.set_page_dirty = __set_page_dirty_nobuffers,
3912
	.releasepage = cifs_release_page,
3913
	.direct_IO = cifs_direct_io,
3914
	.invalidatepage = cifs_invalidate_page,
3915
	.launder_page = cifs_launder_page,
L
Linus Torvalds 已提交
3916
};
D
Dave Kleikamp 已提交
3917 3918 3919 3920 3921 3922

/*
 * 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.
 */
3923
const struct address_space_operations cifs_addr_ops_smallbuf = {
D
Dave Kleikamp 已提交
3924 3925 3926
	.readpage = cifs_readpage,
	.writepage = cifs_writepage,
	.writepages = cifs_writepages,
N
Nick Piggin 已提交
3927 3928
	.write_begin = cifs_write_begin,
	.write_end = cifs_write_end,
D
Dave Kleikamp 已提交
3929
	.set_page_dirty = __set_page_dirty_nobuffers,
3930 3931
	.releasepage = cifs_release_page,
	.invalidatepage = cifs_invalidate_page,
3932
	.launder_page = cifs_launder_page,
D
Dave Kleikamp 已提交
3933
};