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

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

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

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

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

76
	if (flags & O_CREAT) {
77
		posix_flags |= SMB_O_CREAT;
78 79 80
		if (flags & O_EXCL)
			posix_flags |= SMB_O_EXCL;
	} else if (flags & O_EXCL)
81 82
		cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
			 current->comm, current->tgid);
83

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

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

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

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

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

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

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

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

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

	if (rc)
		goto posix_open_ret;

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

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

	cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);

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

posix_open_ret:
	kfree(presp_data);
	return rc;
}

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

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

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

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

	disposition = cifs_get_disposition(f_flags);

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

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

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

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

	if (f_flags & O_DIRECT)
		create_options |= CREATE_NO_BUFFER;

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

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

	if (rc)
		goto out;

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

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

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

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

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

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

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

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

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

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

323 324
	cifs_sb_active(inode->i_sb);

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

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

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

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

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

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

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

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

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

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

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

416 417 418 419 420 421
	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);

422 423 424 425 426
	/* remove it from the lists */
	list_del(&cifs_file->flist);
	list_del(&cifs_file->tlist);

	if (list_empty(&cifsi->openFileList)) {
427
		cifs_dbg(FYI, "closing last open instance for inode %p\n",
428
			 d_inode(cifs_file->dentry));
429 430 431 432 433
		/*
		 * 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.
		 */
434
		if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
435
			set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
436
		cifs_set_oplock_level(cifsi, 0);
437
	}
438

439
	spin_unlock(&cifsi->open_file_lock);
440
	spin_unlock(&tcon->open_file_lock);
441

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

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

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

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

458 459
	cifs_del_pending_open(&open);

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

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

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

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

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

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

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

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

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

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

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

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

	cifs_add_pending_open(&fid, tlink, &open);

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

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

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

580 581
	cifs_fscache_set_inode_cookie(inode, file);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	tcon->need_reopen_files = false;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return rc;
975 976
}

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

994
	down_read(&cinode->lock_sem);
995

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1238
	xid = get_xid();
1239

1240 1241
	if (!flctx)
		goto out;
1242

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

1249 1250
	INIT_LIST_HEAD(&locks_to_send);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1453
	return 0;
1454 1455
}

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

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

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

	INIT_LIST_HEAD(&tmp_llist);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

1849
	spin_lock(&cifs_inode->open_file_lock);
S
Steve French 已提交
1850 1851 1852 1853
	/* 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) {
1854
		if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1855
			continue;
1856
		if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
S
Steve French 已提交
1857 1858 1859
			if (!open_file->invalidHandle) {
				/* found a good file */
				/* lock it so it will not be closed on us */
1860
				cifsFileInfo_get(open_file);
1861
				spin_unlock(&cifs_inode->open_file_lock);
S
Steve French 已提交
1862 1863 1864 1865 1866 1867 1868
				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 */
	}
1869
	spin_unlock(&cifs_inode->open_file_lock);
S
Steve French 已提交
1870 1871 1872
	return NULL;
}

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

1882 1883 1884 1885
	/* 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 已提交
1886
	if (cifs_inode == NULL) {
1887
		cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1888 1889 1890 1891
		dump_stack();
		return NULL;
	}

1892 1893
	cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);

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

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

	if (inv_file) {
		any_available = false;
1929
		cifsFileInfo_get(inv_file);
1930 1931
	}

1932
	spin_unlock(&cifs_inode->open_file_lock);
1933 1934 1935 1936 1937 1938

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

1951 1952 1953
	return NULL;
}

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

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

	inode = page->mapping->host;

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

1973
	if ((to > PAGE_SIZE) || (from > to)) {
L
Linus Torvalds 已提交
1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985
		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 已提交
1986
		to = (unsigned)(mapping->host->i_size - offset);
L
Linus Torvalds 已提交
1987

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

	kunmap(page);
	return rc;
}

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

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

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

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

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

		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++) {
2097
		put_page(wdata->pages[i]);
2098 2099 2100 2101 2102 2103
		wdata->pages[i] = NULL;
	}

	return nr_pages;
}

2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114
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]);
2115
	wdata->pagesz = PAGE_SIZE;
2116 2117
	wdata->tailsz = min(i_size_read(mapping->host) -
			page_offset(wdata->pages[nr_pages - 1]),
2118 2119
			(loff_t)PAGE_SIZE);
	wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2120

2121 2122 2123 2124 2125 2126 2127
	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 {
2128 2129 2130
		wdata->pid = wdata->cfile->pid;
		server = tlink_tcon(wdata->cfile->tlink)->ses->server;
		rc = server->ops->async_writev(wdata, cifs_writedata_release);
2131
	}
2132 2133 2134 2135 2136 2137 2138

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

	return rc;
}

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

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

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

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

2180
		tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2181

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

		if (found_pages == 0) {
			kref_put(&wdata->refcount, cifs_writedata_release);
2193
			add_credits_and_wake_if(server, credits, 0);
2194 2195 2196
			break;
		}

2197 2198
		nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
					       end, &index, &next, &done);
2199

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

2207
		wdata->credits = credits;
2208

2209
		rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2210

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

2228 2229 2230 2231 2232
		if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
			index = saved_index;
			continue;
		}

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

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

2242 2243 2244
		wbc->nr_to_write -= nr_pages;
		if (wbc->nr_to_write <= 0)
			done = true;
2245

2246
		index = next;
2247
	}
2248

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

2259 2260 2261
	if (saved_rc != 0)
		rc = saved_rc;

2262
	if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2263 2264
		mapping->writeback_index = index;

L
Linus Torvalds 已提交
2265 2266 2267
	return rc;
}

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

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

	/*
	 * 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 已提交
2290
	set_page_writeback(page);
2291
retry_write:
2292
	rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2293 2294
	if (is_retryable_error(rc)) {
		if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN)
2295
			goto retry_write;
2296
		redirty_page_for_writepage(wbc, page);
2297
	} else if (rc != 0) {
2298
		SetPageError(page);
2299 2300
		mapping_set_error(page->mapping, rc);
	} else {
2301
		SetPageUptodate(page);
2302
	}
2303
	end_page_writeback(page);
2304
	put_page(page);
2305
	free_xid(xid);
L
Linus Torvalds 已提交
2306 2307 2308
	return rc;
}

2309 2310 2311 2312 2313 2314 2315
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 已提交
2316 2317 2318
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 已提交
2319
{
N
Nick Piggin 已提交
2320 2321
	int rc;
	struct inode *inode = mapping->host;
2322 2323 2324 2325 2326 2327 2328 2329
	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 已提交
2330

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

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

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

2346
		xid = get_xid();
L
Linus Torvalds 已提交
2347 2348 2349 2350 2351 2352
		/* 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);
2353
		rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
N
Nick Piggin 已提交
2354
		/* if (rc < 0) should we set writebehind rc? */
L
Linus Torvalds 已提交
2355
		kunmap(page);
N
Nick Piggin 已提交
2356

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

N
Nick Piggin 已提交
2364 2365 2366 2367 2368 2369 2370 2371
	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);
2372
	put_page(page);
N
Nick Piggin 已提交
2373

L
Linus Torvalds 已提交
2374 2375 2376
	return rc;
}

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

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

2393
	xid = get_xid();
L
Linus Torvalds 已提交
2394

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

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

2406
	tcon = tlink_tcon(smbfile->tlink);
2407 2408 2409 2410 2411 2412 2413
	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;
	}
2414

2415
	free_xid(xid);
A
Al Viro 已提交
2416
	inode_unlock(inode);
2417 2418 2419
	return rc;
}

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

2430
	rc = file_write_and_wait_range(file, start, end);
2431 2432
	if (rc)
		return rc;
A
Al Viro 已提交
2433
	inode_lock(inode);
2434

2435
	xid = get_xid();
2436

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

	tcon = tlink_tcon(smbfile->tlink);
2441 2442 2443 2444 2445 2446 2447
	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;
	}
2448

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

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

2463
	if (file->f_mode & FMODE_WRITE)
2464
		rc = filemap_write_and_wait(inode->i_mapping);
2465

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

	return rc;
}

2471 2472 2473 2474 2475 2476 2477
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++) {
2478
		pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2479 2480 2481 2482 2483 2484 2485
		if (!pages[i]) {
			/*
			 * save number of pages we have already allocated and
			 * return with ENOMEM error
			 */
			num_pages = i;
			rc = -ENOMEM;
2486
			break;
2487 2488 2489
		}
	}

2490 2491 2492 2493
	if (rc) {
		for (i = 0; i < num_pages; i++)
			put_page(pages[i]);
	}
2494 2495 2496 2497 2498 2499 2500 2501 2502 2503
	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 已提交
2504
	num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2505 2506 2507 2508 2509 2510 2511

	if (cur_len)
		*cur_len = clen;

	return num_pages;
}

2512
static void
2513
cifs_uncached_writedata_release(struct kref *refcount)
2514 2515
{
	int i;
2516 2517 2518
	struct cifs_writedata *wdata = container_of(refcount,
					struct cifs_writedata, refcount);

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

2525 2526
static void collect_uncached_write_data(struct cifs_aio_ctx *ctx);

2527 2528 2529
static void
cifs_uncached_writev_complete(struct work_struct *work)
{
2530 2531
	struct cifs_writedata *wdata = container_of(work,
					struct cifs_writedata, work);
2532
	struct inode *inode = d_inode(wdata->cfile->dentry);
2533 2534 2535 2536 2537 2538 2539 2540 2541
	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);
2542 2543
	collect_uncached_write_data(wdata->ctx);
	/* the below call can possibly free the last ref to aio ctx */
2544
	kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2545 2546 2547
}

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

2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570
	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;
2571

2572 2573 2574 2575 2576 2577 2578 2579
	/*
	 * 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;
2580

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

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

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

2609 2610
	server = tlink_tcon(open_file->tlink)->ses->server;

2611
	do {
2612 2613 2614 2615 2616 2617
		unsigned int wsize, credits;

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

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

		rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
		if (rc) {
			kfree(wdata);
2631
			add_credits_and_wake_if(server, credits, 0);
2632 2633 2634
			break;
		}

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

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

2652 2653 2654 2655 2656 2657
		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;
2658 2659
		wdata->pagesz = PAGE_SIZE;
		wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2660
		wdata->credits = credits;
2661 2662
		wdata->ctx = ctx;
		kref_get(&ctx->refcount);
2663 2664

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

2680
		list_add_tail(&wdata->list, wdata_list);
2681 2682
		offset += cur_len;
		len -= cur_len;
2683 2684
	} while (len > 0);

2685 2686 2687
	return rc;
}

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

2697 2698
	tcon = tlink_tcon(ctx->cfile->tlink);
	cifs_sb = CIFS_SB(dentry->d_sb);
2699

2700
	mutex_lock(&ctx->aio_mutex);
2701

2702 2703 2704 2705
	if (list_empty(&ctx->list)) {
		mutex_unlock(&ctx->aio_mutex);
		return;
	}
2706

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

			if (wdata->result)
2722 2723
				rc = wdata->result;
			else
2724
				ctx->total_len += wdata->bytes;
2725 2726 2727

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

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

				iov_iter_advance(&tmp_from,
2735
						 wdata->offset - ctx->pos);
2736 2737 2738

				rc = cifs_write_from_iter(wdata->offset,
						wdata->bytes, &tmp_from,
2739 2740
						ctx->cfile, cifs_sb, &tmp_list,
						ctx);
2741

2742
				list_splice(&tmp_list, &ctx->list);
2743 2744 2745

				kref_put(&wdata->refcount,
					 cifs_uncached_writedata_release);
2746 2747 2748 2749
				goto restart_loop;
			}
		}
		list_del_init(&wdata->list);
2750
		kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2751 2752
	}

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

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

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

	mutex_unlock(&ctx->aio_mutex);

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

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

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

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

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

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

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

	ctx->cfile = cifsFileInfo_get(cfile);

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

	ctx->pos = iocb->ki_pos;

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

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

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

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

	mutex_unlock(&ctx->aio_mutex);

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

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

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

	kref_put(&ctx->refcount, cifs_aio_ctx_release);

2854 2855
	if (unlikely(!total_written))
		return rc;
2856

2857 2858
	iocb->ki_pos += total_written;
	return total_written;
2859 2860
}

2861
static ssize_t
A
Al Viro 已提交
2862
cifs_writev(struct kiocb *iocb, struct iov_iter *from)
2863
{
2864 2865 2866 2867 2868
	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;
2869
	ssize_t rc;
2870

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

2878 2879
	rc = generic_write_checks(iocb, from);
	if (rc <= 0)
2880 2881 2882
		goto out;

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

2892 2893
	if (rc > 0)
		rc = generic_write_sync(iocb, rc);
2894 2895 2896 2897
	return rc;
}

ssize_t
A
Al Viro 已提交
2898
cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
2899
{
A
Al Viro 已提交
2900
	struct inode *inode = file_inode(iocb->ki_filp);
2901 2902 2903 2904 2905
	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);
2906
	ssize_t written;
2907

2908 2909 2910 2911
	written = cifs_get_writer(cinode);
	if (written)
		return written;

2912
	if (CIFS_CACHE_WRITE(cinode)) {
2913 2914
		if (cap_unix(tcon->ses) &&
		(CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
2915
		  && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
A
Al Viro 已提交
2916
			written = generic_file_write_iter(iocb, from);
2917 2918
			goto out;
		}
A
Al Viro 已提交
2919
		written = cifs_writev(iocb, from);
2920
		goto out;
2921 2922
	}
	/*
2923 2924 2925 2926
	 * 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.
2927
	 */
A
Al Viro 已提交
2928
	written = cifs_user_writev(iocb, from);
2929
	if (CIFS_CACHE_READ(cinode)) {
2930
		/*
2931 2932 2933 2934 2935
		 * We have read level caching and we have just sent a write
		 * request to the server thus making data in the cache stale.
		 * Zap the cache and set oplock/lease level to NONE to avoid
		 * reading stale data from the cache. All subsequent read
		 * operations will read new data from the server.
2936
		 */
2937
		cifs_zap_mapping(inode);
2938
		cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
2939
			 inode);
2940
		cinode->oplock = 0;
2941
	}
2942 2943
out:
	cifs_put_writer(cinode);
2944
	return written;
2945 2946
}

2947
static struct cifs_readdata *
2948
cifs_readdata_direct_alloc(struct page **pages, work_func_t complete)
2949 2950
{
	struct cifs_readdata *rdata;
2951

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

2961 2962 2963
	return rdata;
}

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

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

	return ret;
}

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

2994
	kvfree(rdata->pages);
2995 2996 2997
	kfree(rdata);
}

2998
static int
2999
cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
3000 3001
{
	int rc = 0;
3002
	struct page *page;
3003 3004
	unsigned int i;

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

	if (rc) {
3015 3016 3017
		unsigned int nr_page_failed = i;

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

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

3032
	kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
3033 3034 3035
	for (i = 0; i < rdata->nr_pages; i++) {
		put_page(rdata->pages[i]);
		rdata->pages[i] = NULL;
3036 3037 3038 3039 3040 3041 3042
	}
	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
3043
 * @iter:	destination for our data
3044 3045 3046 3047 3048
 *
 * 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.
 */
3049 3050
static int
cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
3051
{
3052
	size_t remaining = rdata->got_bytes;
3053
	unsigned int i;
3054

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

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

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

3074 3075
static void collect_uncached_read_data(struct cifs_aio_ctx *ctx);

3076 3077 3078 3079 3080 3081 3082
static void
cifs_uncached_readv_complete(struct work_struct *work)
{
	struct cifs_readdata *rdata = container_of(work,
						struct cifs_readdata, work);

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

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

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

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

3110

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

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

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

3140
		rdata->got_bytes += result;
3141 3142
	}

3143 3144
	return rdata->got_bytes > 0 && result != -ECONNABORTED ?
						rdata->got_bytes : result;
3145 3146
}

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

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

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

3174
	server = tlink_tcon(open_file->tlink)->ses->server;
3175

3176 3177 3178 3179 3180
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

3181
	do {
3182 3183 3184 3185 3186 3187
		rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
						   &rsize, &credits);
		if (rc)
			break;

		cur_len = min_t(const size_t, len, rsize);
3188
		npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
3189

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

3199
		rc = cifs_read_allocate_pages(rdata, npages);
3200 3201 3202 3203
		if (rc)
			goto error;

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

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

3229
		list_add_tail(&rdata->list, rdata_list);
3230 3231 3232 3233
		offset += cur_len;
		len -= cur_len;
	} while (len > 0);

3234 3235 3236
	return rc;
}

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

3247 3248
	tcon = tlink_tcon(ctx->cfile->tlink);
	cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb);
3249

3250
	mutex_lock(&ctx->aio_mutex);
3251

3252 3253 3254 3255
	if (list_empty(&ctx->list)) {
		mutex_unlock(&ctx->aio_mutex);
		return;
	}
3256

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

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

3272 3273
				list_del_init(&rdata->list);
				INIT_LIST_HEAD(&tmp_list);
3274

3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286
				/*
				 * 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;
					}
3287
				}
3288 3289 3290 3291 3292

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

3295
				list_splice(&tmp_list, &ctx->list);
3296

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

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

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

3319 3320 3321
	ctx->total_len = ctx->len - iov_iter_count(to);

	cifs_stats_bytes_read(tcon, ctx->total_len);
3322

3323 3324 3325 3326
	/* mask nodata case */
	if (rc == -ENODATA)
		rc = 0;

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

	mutex_unlock(&ctx->aio_mutex);

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

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

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

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

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

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

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

	ctx->cfile = cifsFileInfo_get(cfile);

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

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

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

	len = ctx->len;

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

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

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

	mutex_unlock(&ctx->aio_mutex);

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

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

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

	kref_put(&ctx->refcount, cifs_aio_ctx_release);

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

3424
ssize_t
A
Al Viro 已提交
3425
cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3426
{
A
Al Viro 已提交
3427
	struct inode *inode = file_inode(iocb->ki_filp);
3428 3429 3430 3431 3432 3433
	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;
3434 3435 3436 3437 3438 3439 3440 3441 3442

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

3446 3447 3448
	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 已提交
3449
		return generic_file_read_iter(iocb, to);
3450 3451 3452 3453 3454 3455

	/*
	 * 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 已提交
3456
	if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3457
				     tcon->ses->server->vals->shared_lock_type,
3458
				     NULL, CIFS_READ_OP))
A
Al Viro 已提交
3459
		rc = generic_file_read_iter(iocb, to);
3460 3461
	up_read(&cinode->lock_sem);
	return rc;
3462
}
L
Linus Torvalds 已提交
3463

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

3482
	xid = get_xid();
3483
	cifs_sb = CIFS_FILE_SB(file);
L
Linus Torvalds 已提交
3484

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

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

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

3502 3503 3504 3505 3506
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

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

3510 3511
	for (total_read = 0, cur_offset = read_data; read_size > total_read;
	     total_read += bytes_read, cur_offset += bytes_read) {
3512 3513 3514 3515 3516 3517 3518 3519 3520
		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 &
3521
				tcon->ses->server->vals->cap_large_files)) {
3522 3523 3524
				current_read_size = min_t(uint,
					current_read_size, CIFSMaxBufSize);
			}
3525
			if (open_file->invalidHandle) {
J
Jeff Layton 已提交
3526
				rc = cifs_reopen_file(open_file, true);
L
Linus Torvalds 已提交
3527 3528 3529
				if (rc != 0)
					break;
			}
3530
			io_parms.pid = pid;
3531
			io_parms.tcon = tcon;
3532
			io_parms.offset = *offset;
3533
			io_parms.length = current_read_size;
3534
			rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
3535 3536
						    &bytes_read, &cur_offset,
						    &buf_type);
3537 3538
		} while (rc == -EAGAIN);

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

3555 3556 3557 3558
/*
 * 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.
 */
3559
static vm_fault_t
3560
cifs_page_mkwrite(struct vm_fault *vmf)
3561 3562 3563 3564 3565 3566 3567
{
	struct page *page = vmf->page;

	lock_page(page);
	return VM_FAULT_LOCKED;
}

3568
static const struct vm_operations_struct cifs_file_vm_ops = {
3569
	.fault = filemap_fault,
3570
	.map_pages = filemap_map_pages,
3571 3572 3573
	.page_mkwrite = cifs_page_mkwrite,
};

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

3579
	xid = get_xid();
3580

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

3588
	free_xid(xid);
3589 3590 3591
	return rc;
}

L
Linus Torvalds 已提交
3592 3593 3594 3595
int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
{
	int rc, xid;

3596
	xid = get_xid();
3597

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

3607
	free_xid(xid);
L
Linus Torvalds 已提交
3608 3609 3610
	return rc;
}

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

3618
	got_bytes = rdata->got_bytes;
3619 3620 3621
	for (i = 0; i < rdata->nr_pages; i++) {
		struct page *page = rdata->pages[i];

3622 3623
		lru_cache_add_file(page);

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

		unlock_page(page);

3632 3633
		if (rdata->result == 0 ||
		    (rdata->result == -EAGAIN && got_bytes))
3634 3635
			cifs_readpage_to_fscache(rdata->mapping->host, page);

3636
		got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
3637

3638
		put_page(page);
3639
		rdata->pages[i] = NULL;
3640
	}
3641
	kref_put(&rdata->refcount, cifs_readdata_release);
3642 3643
}

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

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

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

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

		n = to_read;
3674

L
Long Li 已提交
3675 3676
		if (len >= to_read) {
			len -= to_read;
3677
		} else if (len > 0) {
3678
			/* enough for partial page, fill and zero the rest */
L
Long Li 已提交
3679
			zero_user(page, len + page_offset, to_read - len);
3680
			n = rdata->tailsz = len;
3681
			len = 0;
3682 3683 3684 3685 3686 3687 3688 3689 3690
		} 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.
			 */
3691
			zero_user(page, 0, PAGE_SIZE);
3692 3693 3694 3695
			lru_cache_add_file(page);
			flush_dcache_page(page);
			SetPageUptodate(page);
			unlock_page(page);
3696
			put_page(page);
3697 3698
			rdata->pages[i] = NULL;
			rdata->nr_pages--;
3699
			continue;
3700 3701 3702 3703
		} else {
			/* no need to hold page hostage */
			lru_cache_add_file(page);
			unlock_page(page);
3704
			put_page(page);
3705 3706
			rdata->pages[i] = NULL;
			rdata->nr_pages--;
3707
			continue;
3708
		}
3709

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

3723
		rdata->got_bytes += result;
3724 3725
	}

3726 3727
	return rdata->got_bytes > 0 && result != -ECONNABORTED ?
						rdata->got_bytes : result;
3728 3729
}

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

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

3745 3746 3747 3748 3749 3750 3751 3752
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;
3753
	gfp_t gfp = readahead_gfp_mask(mapping);
3754

3755 3756
	INIT_LIST_HEAD(tmplist);

3757 3758 3759 3760 3761 3762 3763
	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.
	 */
3764
	__SetPageLocked(page);
3765
	rc = add_to_page_cache_locked(page, mapping,
3766
				      page->index, gfp);
3767 3768 3769

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

	/* move first page to the tmplist */
3775 3776
	*offset = (loff_t)page->index << PAGE_SHIFT;
	*bytes = PAGE_SIZE;
3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787
	*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? */
3788
		if (*bytes + PAGE_SIZE > rsize)
3789 3790
			break;

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

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

3814 3815 3816
	/*
	 * Reads as many pages as possible from fscache. Returns -ENOBUFS
	 * immediately if the cookie is negative
3817 3818 3819
	 *
	 * 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.
3820 3821 3822 3823
	 */
	rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
					 &num_pages);
	if (rc == 0)
3824
		return rc;
3825

3826 3827 3828 3829 3830
	if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
		pid = open_file->pid;
	else
		pid = current->tgid;

3831
	rc = 0;
3832
	server = tlink_tcon(open_file->tlink)->ses->server;
L
Linus Torvalds 已提交
3833

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

	/*
	 * 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)) {
3849
		unsigned int i, nr_pages, bytes, rsize;
3850 3851 3852
		loff_t offset;
		struct page *page, *tpage;
		struct cifs_readdata *rdata;
3853
		unsigned credits;
L
Linus Torvalds 已提交
3854

3855 3856 3857 3858
		rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
						   &rsize, &credits);
		if (rc)
			break;
3859 3860

		/*
3861 3862 3863 3864
		 * 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.
3865
		 */
3866
		if (unlikely(rsize < PAGE_SIZE)) {
3867
			add_credits_and_wake_if(server, credits, 0);
3868
			return 0;
3869
		}
3870

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

3878
		rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3879 3880 3881 3882 3883 3884
		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);
3885
				put_page(page);
3886 3887
			}
			rc = -ENOMEM;
3888
			add_credits_and_wake_if(server, credits, 0);
3889 3890 3891
			break;
		}

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

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

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

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

3927 3928 3929 3930 3931
	/* 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 已提交
3932 3933 3934
	return rc;
}

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

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

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

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

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

A
Al Viro 已提交
3959
	file_inode(file)->i_atime =
3960
		current_time(file_inode(file));
S
Steve French 已提交
3961

3962 3963
	if (PAGE_SIZE > rc)
		memset(read_data + rc, 0, PAGE_SIZE - rc);
L
Linus Torvalds 已提交
3964 3965 3966

	flush_dcache_page(page);
	SetPageUptodate(page);
3967 3968

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

L
Linus Torvalds 已提交
3971
	rc = 0;
S
Steve French 已提交
3972

L
Linus Torvalds 已提交
3973
io_error:
S
Steve French 已提交
3974
	kunmap(page);
3975
	unlock_page(page);
3976 3977

read_complete:
L
Linus Torvalds 已提交
3978 3979 3980 3981 3982
	return rc;
}

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

3987
	xid = get_xid();
L
Linus Torvalds 已提交
3988 3989

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

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

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

4000
	free_xid(xid);
L
Linus Torvalds 已提交
4001 4002 4003
	return rc;
}

4004 4005 4006 4007
static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
{
	struct cifsFileInfo *open_file;

4008
	spin_lock(&cifs_inode->open_file_lock);
4009
	list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
4010
		if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
4011
			spin_unlock(&cifs_inode->open_file_lock);
4012 4013 4014
			return 1;
		}
	}
4015
	spin_unlock(&cifs_inode->open_file_lock);
4016 4017 4018
	return 0;
}

L
Linus Torvalds 已提交
4019 4020 4021
/* 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 已提交
4022
   refreshing the inode only on increases in the file size
L
Linus Torvalds 已提交
4023 4024
   but this is tricky to do without racing with writebehind
   page caching in the current Linux kernel design */
4025
bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
L
Linus Torvalds 已提交
4026
{
4027
	if (!cifsInode)
4028
		return true;
4029

4030 4031
	if (is_inode_writable(cifsInode)) {
		/* This inode is open for write at least once */
4032 4033 4034
		struct cifs_sb_info *cifs_sb;

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

S
Steve French 已提交
4041
		if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
4042
			return true;
4043

4044
		return false;
4045
	} else
4046
		return true;
L
Linus Torvalds 已提交
4047 4048
}

N
Nick Piggin 已提交
4049 4050 4051
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 已提交
4052
{
4053
	int oncethru = 0;
4054 4055
	pgoff_t index = pos >> PAGE_SHIFT;
	loff_t offset = pos & (PAGE_SIZE - 1);
4056 4057 4058 4059
	loff_t page_start = pos & PAGE_MASK;
	loff_t i_size;
	struct page *page;
	int rc = 0;
N
Nick Piggin 已提交
4060

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

4063
start:
4064
	page = grab_cache_page_write_begin(mapping, index, flags);
4065 4066 4067 4068
	if (!page) {
		rc = -ENOMEM;
		goto out;
	}
4069

4070 4071
	if (PageUptodate(page))
		goto out;
4072

4073 4074 4075 4076 4077
	/*
	 * 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.
	 */
4078
	if (len == PAGE_SIZE)
4079
		goto out;
4080

4081 4082 4083 4084 4085 4086
	/*
	 * 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.
	 */
4087
	if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
4088 4089 4090 4091 4092
		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,
4093
					   PAGE_SIZE);
4094 4095 4096 4097 4098 4099 4100 4101 4102 4103
			/*
			 * 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 已提交
4104

4105
	if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
4106 4107 4108 4109 4110 4111
		/*
		 * 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);
4112
		put_page(page);
4113 4114
		oncethru = 1;
		goto start;
4115 4116 4117 4118
	} 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 已提交
4119
		   this will be written out by write_end so is fine */
L
Linus Torvalds 已提交
4120
	}
4121 4122 4123
out:
	*pagep = page;
	return rc;
L
Linus Torvalds 已提交
4124 4125
}

4126 4127 4128 4129 4130 4131 4132 4133
static int cifs_release_page(struct page *page, gfp_t gfp)
{
	if (PagePrivate(page))
		return 0;

	return cifs_fscache_release_page(page, gfp);
}

4134 4135
static void cifs_invalidate_page(struct page *page, unsigned int offset,
				 unsigned int length)
4136 4137 4138
{
	struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);

4139
	if (offset == 0 && length == PAGE_SIZE)
4140 4141 4142
		cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
}

4143 4144 4145 4146
static int cifs_launder_page(struct page *page)
{
	int rc = 0;
	loff_t range_start = page_offset(page);
4147
	loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
4148 4149 4150 4151 4152 4153 4154
	struct writeback_control wbc = {
		.sync_mode = WB_SYNC_ALL,
		.nr_to_write = 0,
		.range_start = range_start,
		.range_end = range_end,
	};

4155
	cifs_dbg(FYI, "Launder page: %p\n", page);
4156 4157 4158 4159 4160 4161 4162 4163

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

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

4164
void cifs_oplock_break(struct work_struct *work)
4165 4166 4167
{
	struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
						  oplock_break);
4168
	struct inode *inode = d_inode(cfile->dentry);
4169
	struct cifsInodeInfo *cinode = CIFS_I(inode);
4170
	struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4171
	struct TCP_Server_Info *server = tcon->ses->server;
4172
	int rc = 0;
4173

4174
	wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
4175
			TASK_UNINTERRUPTIBLE);
4176 4177 4178 4179

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

4180
	if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
4181
						cifs_has_mand_locks(cinode)) {
4182 4183
		cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
			 inode);
4184
		cinode->oplock = 0;
4185 4186
	}

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

4201 4202
	rc = cifs_push_locks(cfile);
	if (rc)
4203
		cifs_dbg(VFS, "Push locks rc = %d\n", rc);
4204

4205 4206 4207 4208 4209 4210
	/*
	 * 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
	 */
4211
	if (!cfile->oplock_break_cancelled) {
4212 4213
		rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
							     cinode);
4214
		cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
4215
	}
4216
	_cifsFileInfo_put(cfile, false /* do not wait for ourself */);
4217
	cifs_done_oplock_break(cinode);
4218 4219
}

4220 4221 4222 4223 4224 4225 4226 4227 4228 4229
/*
 * 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
4230
cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
4231 4232 4233 4234 4235 4236 4237 4238 4239
{
        /*
         * FIXME
         * Eventually need to support direct IO for non forcedirectio mounts
         */
        return -EINVAL;
}


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

/*
 * 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.
 */
4259
const struct address_space_operations cifs_addr_ops_smallbuf = {
D
Dave Kleikamp 已提交
4260 4261 4262
	.readpage = cifs_readpage,
	.writepage = cifs_writepage,
	.writepages = cifs_writepages,
N
Nick Piggin 已提交
4263 4264
	.write_begin = cifs_write_begin,
	.write_end = cifs_write_end,
D
Dave Kleikamp 已提交
4265
	.set_page_dirty = __set_page_dirty_nobuffers,
4266 4267
	.releasepage = cifs_release_page,
	.invalidatepage = cifs_invalidate_page,
4268
	.launder_page = cifs_launder_page,
D
Dave Kleikamp 已提交
4269
};