file.c 24.7 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/*
 *  linux/fs/nfs/file.c
 *
 *  Copyright (C) 1992  Rick Sladkey
 *
 *  Changes Copyright (C) 1994 by Florian La Roche
 *   - Do not copy data too often around in the kernel.
 *   - In nfs_file_read the return value of kmalloc wasn't checked.
 *   - Put in a better version of read look-ahead buffering. Original idea
 *     and implementation by Wai S Kok elekokws@ee.nus.sg.
 *
 *  Expire cache on write to a file by Wai S Kok (Oct 1994).
 *
 *  Total rewrite of read side for new NFS buffer cache.. Linus.
 *
 *  nfs regular file handling functions
 */

B
Bryan Schumaker 已提交
19
#include <linux/module.h>
L
Linus Torvalds 已提交
20 21 22 23 24 25 26 27 28
#include <linux/time.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/fcntl.h>
#include <linux/stat.h>
#include <linux/nfs_fs.h>
#include <linux/nfs_mount.h>
#include <linux/mm.h>
#include <linux/pagemap.h>
A
Alexey Dobriyan 已提交
29
#include <linux/aio.h>
30
#include <linux/gfp.h>
31
#include <linux/swap.h>
L
Linus Torvalds 已提交
32 33 34 35

#include <asm/uaccess.h>

#include "delegation.h"
36
#include "internal.h"
C
Chuck Lever 已提交
37
#include "iostat.h"
D
David Howells 已提交
38
#include "fscache.h"
L
Linus Torvalds 已提交
39

40 41
#include "nfstrace.h"

L
Linus Torvalds 已提交
42 43
#define NFSDBG_FACILITY		NFSDBG_FILE

44
static const struct vm_operations_struct nfs_file_vm_ops;
45

L
Linus Torvalds 已提交
46 47 48 49 50
/* Hack for future NFS swap support */
#ifndef IS_SWAPFILE
# define IS_SWAPFILE(inode)	(0)
#endif

51
int nfs_check_flags(int flags)
L
Linus Torvalds 已提交
52 53 54 55 56 57
{
	if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT))
		return -EINVAL;

	return 0;
}
B
Bryan Schumaker 已提交
58
EXPORT_SYMBOL_GPL(nfs_check_flags);
L
Linus Torvalds 已提交
59 60 61 62 63 64 65 66 67

/*
 * Open file
 */
static int
nfs_file_open(struct inode *inode, struct file *filp)
{
	int res;

68
	dprintk("NFS: open file(%pD2)\n", filp);
69

70
	nfs_inc_stats(inode, NFSIOS_VFSOPEN);
L
Linus Torvalds 已提交
71 72 73 74
	res = nfs_check_flags(filp->f_flags);
	if (res)
		return res;

75
	res = nfs_open(inode, filp);
L
Linus Torvalds 已提交
76 77 78
	return res;
}

79
int
L
Linus Torvalds 已提交
80 81
nfs_file_release(struct inode *inode, struct file *filp)
{
82
	dprintk("NFS: release(%pD2)\n", filp);
C
Chuck Lever 已提交
83

C
Chuck Lever 已提交
84
	nfs_inc_stats(inode, NFSIOS_VFSRELEASE);
85
	return nfs_release(inode, filp);
L
Linus Torvalds 已提交
86
}
B
Bryan Schumaker 已提交
87
EXPORT_SYMBOL_GPL(nfs_file_release);
L
Linus Torvalds 已提交
88

89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104
/**
 * nfs_revalidate_size - Revalidate the file size
 * @inode - pointer to inode struct
 * @file - pointer to struct file
 *
 * Revalidates the file length. This is basically a wrapper around
 * nfs_revalidate_inode() that takes into account the fact that we may
 * have cached writes (in which case we don't care about the server's
 * idea of what the file length is), or O_DIRECT (in which case we
 * shouldn't trust the cache).
 */
static int nfs_revalidate_file_size(struct inode *inode, struct file *filp)
{
	struct nfs_server *server = NFS_SERVER(inode);
	struct nfs_inode *nfsi = NFS_I(inode);

105 106 107
	if (nfs_have_delegated_attributes(inode))
		goto out_noreval;

108 109
	if (filp->f_flags & O_DIRECT)
		goto force_reval;
110 111 112 113 114 115
	if (nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
		goto force_reval;
	if (nfs_attribute_timeout(inode))
		goto force_reval;
out_noreval:
	return 0;
116 117 118 119
force_reval:
	return __nfs_revalidate_inode(server, inode);
}

120
loff_t nfs_file_llseek(struct file *filp, loff_t offset, int whence)
121
{
122 123
	dprintk("NFS: llseek file(%pD2, %lld, %d)\n",
			filp, offset, whence);
124

125
	/*
126
	 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
127 128
	 * the cached file length
	 */
129
	if (whence != SEEK_SET && whence != SEEK_CUR) {
130
		struct inode *inode = filp->f_mapping->host;
T
Trond Myklebust 已提交
131

132 133 134
		int retval = nfs_revalidate_file_size(inode, filp);
		if (retval < 0)
			return (loff_t)retval;
135
	}
T
Trond Myklebust 已提交
136

137
	return generic_file_llseek(filp, offset, whence);
138
}
B
Bryan Schumaker 已提交
139
EXPORT_SYMBOL_GPL(nfs_file_llseek);
140

L
Linus Torvalds 已提交
141 142 143
/*
 * Flush all dirty pages, and check for write errors.
 */
144
int
145
nfs_file_flush(struct file *file, fl_owner_t id)
L
Linus Torvalds 已提交
146
{
147
	struct inode	*inode = file_inode(file);
L
Linus Torvalds 已提交
148

149
	dprintk("NFS: flush(%pD2)\n", file);
L
Linus Torvalds 已提交
150

151
	nfs_inc_stats(inode, NFSIOS_VFSFLUSH);
L
Linus Torvalds 已提交
152 153
	if ((file->f_mode & FMODE_WRITE) == 0)
		return 0;
154

155 156 157 158
	/*
	 * If we're holding a write delegation, then just start the i/o
	 * but don't wait for completion (or send a commit).
	 */
159
	if (NFS_PROTO(inode)->have_delegation(inode, FMODE_WRITE))
160 161
		return filemap_fdatawrite(file->f_mapping);

T
Trond Myklebust 已提交
162
	/* Flush writes to the server and return any errors */
T
Trond Myklebust 已提交
163
	return vfs_fsync(file, 0);
L
Linus Torvalds 已提交
164
}
B
Bryan Schumaker 已提交
165
EXPORT_SYMBOL_GPL(nfs_file_flush);
L
Linus Torvalds 已提交
166

167
ssize_t
168 169
nfs_file_read(struct kiocb *iocb, const struct iovec *iov,
		unsigned long nr_segs, loff_t pos)
L
Linus Torvalds 已提交
170
{
171
	struct inode *inode = file_inode(iocb->ki_filp);
L
Linus Torvalds 已提交
172 173 174
	ssize_t result;

	if (iocb->ki_filp->f_flags & O_DIRECT)
M
Mel Gorman 已提交
175
		return nfs_file_direct_read(iocb, iov, nr_segs, pos, true);
L
Linus Torvalds 已提交
176

177 178
	dprintk("NFS: read(%pD2, %lu@%lu)\n",
		iocb->ki_filp,
179
		(unsigned long) iov_length(iov, nr_segs), (unsigned long) pos);
L
Linus Torvalds 已提交
180

181
	result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping);
182
	if (!result) {
183
		result = generic_file_aio_read(iocb, iov, nr_segs, pos);
184 185 186
		if (result > 0)
			nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, result);
	}
L
Linus Torvalds 已提交
187 188
	return result;
}
B
Bryan Schumaker 已提交
189
EXPORT_SYMBOL_GPL(nfs_file_read);
L
Linus Torvalds 已提交
190

191
ssize_t
192 193 194
nfs_file_splice_read(struct file *filp, loff_t *ppos,
		     struct pipe_inode_info *pipe, size_t count,
		     unsigned int flags)
L
Linus Torvalds 已提交
195
{
196
	struct inode *inode = file_inode(filp);
L
Linus Torvalds 已提交
197 198
	ssize_t res;

199 200
	dprintk("NFS: splice_read(%pD2, %lu@%Lu)\n",
		filp, (unsigned long) count, (unsigned long long) *ppos);
L
Linus Torvalds 已提交
201

202
	res = nfs_revalidate_mapping(inode, filp->f_mapping);
203
	if (!res) {
204
		res = generic_file_splice_read(filp, ppos, pipe, count, flags);
205 206 207
		if (res > 0)
			nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, res);
	}
L
Linus Torvalds 已提交
208 209
	return res;
}
B
Bryan Schumaker 已提交
210
EXPORT_SYMBOL_GPL(nfs_file_splice_read);
L
Linus Torvalds 已提交
211

212
int
L
Linus Torvalds 已提交
213 214
nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
{
215
	struct inode *inode = file_inode(file);
L
Linus Torvalds 已提交
216 217
	int	status;

218
	dprintk("NFS: mmap(%pD2)\n", file);
L
Linus Torvalds 已提交
219

220 221 222 223
	/* Note: generic_file_mmap() returns ENOSYS on nommu systems
	 *       so we call that before revalidating the mapping
	 */
	status = generic_file_mmap(file, vma);
224 225
	if (!status) {
		vma->vm_ops = &nfs_file_vm_ops;
226
		status = nfs_revalidate_mapping(inode, file->f_mapping);
227
	}
L
Linus Torvalds 已提交
228 229
	return status;
}
B
Bryan Schumaker 已提交
230
EXPORT_SYMBOL_GPL(nfs_file_mmap);
L
Linus Torvalds 已提交
231 232 233 234 235

/*
 * Flush any dirty pages for this process, and check for write errors.
 * The return status from this call provides a reliable indication of
 * whether any write errors occurred for this process.
T
Trond Myklebust 已提交
236 237 238 239 240
 *
 * Notice that it clears the NFS_CONTEXT_ERROR_WRITE before synching to
 * disk, but it retrieves and clears ctx->error after synching, despite
 * the two being set at the same time in nfs_context_set_write_error().
 * This is because the former is used to notify the _next_ call to
L
Lucas De Marchi 已提交
241
 * nfs_file_write() that a write error occurred, and hence cause it to
T
Trond Myklebust 已提交
242
 * fall back to doing a synchronous write.
L
Linus Torvalds 已提交
243
 */
244
int
245
nfs_file_fsync_commit(struct file *file, loff_t start, loff_t end, int datasync)
L
Linus Torvalds 已提交
246
{
247
	struct nfs_open_context *ctx = nfs_file_open_context(file);
248
	struct inode *inode = file_inode(file);
249
	int have_error, do_resend, status;
T
Trond Myklebust 已提交
250 251
	int ret = 0;

252
	dprintk("NFS: fsync file(%pD2) datasync %d\n", file, datasync);
L
Linus Torvalds 已提交
253

C
Chuck Lever 已提交
254
	nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
255
	do_resend = test_and_clear_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags);
T
Trond Myklebust 已提交
256 257 258
	have_error = test_and_clear_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
	status = nfs_commit_inode(inode, FLUSH_SYNC);
	have_error |= test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
259
	if (have_error) {
T
Trond Myklebust 已提交
260
		ret = xchg(&ctx->error, 0);
261 262 263 264
		if (ret)
			goto out;
	}
	if (status < 0) {
T
Trond Myklebust 已提交
265
		ret = status;
266 267 268 269 270 271
		goto out;
	}
	do_resend |= test_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags);
	if (do_resend)
		ret = -EAGAIN;
out:
272 273
	return ret;
}
B
Bryan Schumaker 已提交
274
EXPORT_SYMBOL_GPL(nfs_file_fsync_commit);
275 276 277 278 279

static int
nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
{
	int ret;
A
Al Viro 已提交
280
	struct inode *inode = file_inode(file);
281

282 283
	trace_nfs_fsync_enter(inode);

284 285 286 287 288 289 290
	do {
		ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
		if (ret != 0)
			break;
		mutex_lock(&inode->i_mutex);
		ret = nfs_file_fsync_commit(file, start, end, datasync);
		mutex_unlock(&inode->i_mutex);
291 292 293 294 295 296 297
		/*
		 * If nfs_file_fsync_commit detected a server reboot, then
		 * resend all dirty pages that might have been covered by
		 * the NFS_CONTEXT_RESEND_WRITES flag
		 */
		start = 0;
		end = LLONG_MAX;
298 299
	} while (ret == -EAGAIN);

300
	trace_nfs_fsync_exit(inode, ret);
T
Trond Myklebust 已提交
301
	return ret;
L
Linus Torvalds 已提交
302 303
}

304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339
/*
 * Decide whether a read/modify/write cycle may be more efficient
 * then a modify/write/read cycle when writing to a page in the
 * page cache.
 *
 * The modify/write/read cycle may occur if a page is read before
 * being completely filled by the writer.  In this situation, the
 * page must be completely written to stable storage on the server
 * before it can be refilled by reading in the page from the server.
 * This can lead to expensive, small, FILE_SYNC mode writes being
 * done.
 *
 * It may be more efficient to read the page first if the file is
 * open for reading in addition to writing, the page is not marked
 * as Uptodate, it is not dirty or waiting to be committed,
 * indicating that it was previously allocated and then modified,
 * that there were valid bytes of data in that range of the file,
 * and that the new data won't completely replace the old data in
 * that range of the file.
 */
static int nfs_want_read_modify_write(struct file *file, struct page *page,
			loff_t pos, unsigned len)
{
	unsigned int pglen = nfs_page_length(page);
	unsigned int offset = pos & (PAGE_CACHE_SIZE - 1);
	unsigned int end = offset + len;

	if ((file->f_mode & FMODE_READ) &&	/* open for read? */
	    !PageUptodate(page) &&		/* Uptodate? */
	    !PagePrivate(page) &&		/* i/o request already? */
	    pglen &&				/* valid bytes of file? */
	    (end < pglen || offset))		/* replace all valid bytes? */
		return 1;
	return 0;
}

L
Linus Torvalds 已提交
340
/*
N
Nick Piggin 已提交
341 342 343
 * This does the "real" work of the write. We must allocate and lock the
 * page to be sent back to the generic routine, which then copies the
 * data from user space.
L
Linus Torvalds 已提交
344 345 346 347
 *
 * If the writer ends up delaying the write, the writer needs to
 * increment the page use counts until he is done with the page.
 */
N
Nick Piggin 已提交
348 349 350
static int nfs_write_begin(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned flags,
			struct page **pagep, void **fsdata)
L
Linus Torvalds 已提交
351
{
N
Nick Piggin 已提交
352
	int ret;
353
	pgoff_t index = pos >> PAGE_CACHE_SHIFT;
N
Nick Piggin 已提交
354
	struct page *page;
355
	int once_thru = 0;
N
Nick Piggin 已提交
356

357
	dfprintk(PAGECACHE, "NFS: write_begin(%pD2(%lu), %u@%lld)\n",
358
		file, mapping->host->i_ino, len, (long long) pos);
359

360
start:
361 362 363 364 365 366 367 368 369
	/*
	 * Prevent starvation issues if someone is doing a consistency
	 * sync-to-disk
	 */
	ret = wait_on_bit(&NFS_I(mapping->host)->flags, NFS_INO_FLUSHING,
			nfs_wait_bit_killable, TASK_KILLABLE);
	if (ret)
		return ret;

370
	page = grab_cache_page_write_begin(mapping, index, flags);
N
Nick Piggin 已提交
371 372 373 374 375 376 377 378
	if (!page)
		return -ENOMEM;
	*pagep = page;

	ret = nfs_flush_incompatible(file, page);
	if (ret) {
		unlock_page(page);
		page_cache_release(page);
379 380 381 382 383 384 385
	} else if (!once_thru &&
		   nfs_want_read_modify_write(file, page, pos, len)) {
		once_thru = 1;
		ret = nfs_readpage(file, page);
		page_cache_release(page);
		if (!ret)
			goto start;
N
Nick Piggin 已提交
386 387
	}
	return ret;
L
Linus Torvalds 已提交
388 389
}

N
Nick Piggin 已提交
390 391 392
static int nfs_write_end(struct file *file, struct address_space *mapping,
			loff_t pos, unsigned len, unsigned copied,
			struct page *page, void *fsdata)
L
Linus Torvalds 已提交
393
{
N
Nick Piggin 已提交
394
	unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
395
	struct nfs_open_context *ctx = nfs_file_open_context(file);
N
Nick Piggin 已提交
396
	int status;
L
Linus Torvalds 已提交
397

398
	dfprintk(PAGECACHE, "NFS: write_end(%pD2(%lu), %u@%lld)\n",
399
		file, mapping->host->i_ino, len, (long long) pos);
400

401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
	/*
	 * Zero any uninitialised parts of the page, and then mark the page
	 * as up to date if it turns out that we're extending the file.
	 */
	if (!PageUptodate(page)) {
		unsigned pglen = nfs_page_length(page);
		unsigned end = offset + len;

		if (pglen == 0) {
			zero_user_segments(page, 0, offset,
					end, PAGE_CACHE_SIZE);
			SetPageUptodate(page);
		} else if (end >= pglen) {
			zero_user_segment(page, end, PAGE_CACHE_SIZE);
			if (offset == 0)
				SetPageUptodate(page);
		} else
			zero_user_segment(page, pglen, PAGE_CACHE_SIZE);
	}

N
Nick Piggin 已提交
421 422 423 424 425
	status = nfs_updatepage(file, page, offset, copied);

	unlock_page(page);
	page_cache_release(page);

C
Chuck Lever 已提交
426 427
	if (status < 0)
		return status;
428
	NFS_I(mapping->host)->write_io += copied;
429 430 431 432 433 434 435

	if (nfs_ctx_key_to_expire(ctx)) {
		status = nfs_wb_all(mapping->host);
		if (status < 0)
			return status;
	}

C
Chuck Lever 已提交
436
	return copied;
L
Linus Torvalds 已提交
437 438
}

439 440 441 442
/*
 * Partially or wholly invalidate a page
 * - Release the private state associated with a page if undergoing complete
 *   page invalidation
D
David Howells 已提交
443
 * - Called if either PG_private or PG_fscache is set on the page
444 445
 * - Caller holds page lock
 */
446 447
static void nfs_invalidate_page(struct page *page, unsigned int offset,
				unsigned int length)
448
{
449 450
	dfprintk(PAGECACHE, "NFS: invalidate_page(%p, %u, %u)\n",
		 page, offset, length);
451

452
	if (offset != 0 || length < PAGE_CACHE_SIZE)
453
		return;
454
	/* Cancel any unstarted writes on this page */
455
	nfs_wb_page_cancel(page_file_mapping(page)->host, page);
D
David Howells 已提交
456 457

	nfs_fscache_invalidate_page(page, page->mapping->host);
458 459
}

460 461
/*
 * Attempt to release the private state associated with a page
D
David Howells 已提交
462
 * - Called if either PG_private or PG_fscache is set on the page
463 464 465
 * - Caller holds page lock
 * - Return true (may release page) or false (may not)
 */
466 467
static int nfs_release_page(struct page *page, gfp_t gfp)
{
468 469
	struct address_space *mapping = page->mapping;

470 471
	dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page);

472 473 474 475 476
	/* Only do I/O if gfp is a superset of GFP_KERNEL, and we're not
	 * doing this memory reclaim for a fs-related allocation.
	 */
	if (mapping && (gfp & GFP_KERNEL) == GFP_KERNEL &&
	    !(current->flags & PF_FSTRANS)) {
477 478 479 480 481 482 483
		int how = FLUSH_SYNC;

		/* Don't let kswapd deadlock waiting for OOM RPC calls */
		if (current_is_kswapd())
			how = 0;
		nfs_commit_inode(mapping->host, how);
	}
484
	/* If PagePrivate() is set, then the page is not freeable */
D
David Howells 已提交
485 486 487
	if (PagePrivate(page))
		return 0;
	return nfs_fscache_release_page(page, gfp);
488 489
}

490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518
static void nfs_check_dirty_writeback(struct page *page,
				bool *dirty, bool *writeback)
{
	struct nfs_inode *nfsi;
	struct address_space *mapping = page_file_mapping(page);

	if (!mapping || PageSwapCache(page))
		return;

	/*
	 * Check if an unstable page is currently being committed and
	 * if so, have the VM treat it as if the page is under writeback
	 * so it will not block due to pages that will shortly be freeable.
	 */
	nfsi = NFS_I(mapping->host);
	if (test_bit(NFS_INO_COMMIT, &nfsi->flags)) {
		*writeback = true;
		return;
	}

	/*
	 * If PagePrivate() is set, then the page is not freeable and as the
	 * inode is not being committed, it's not going to be cleaned in the
	 * near future so treat it as dirty
	 */
	if (PagePrivate(page))
		*dirty = true;
}

519 520 521 522
/*
 * Attempt to clear the private state associated with a page when an error
 * occurs that requires the cached contents of an inode to be written back or
 * destroyed
D
David Howells 已提交
523
 * - Called if either PG_private or fscache is set on the page
524 525 526
 * - Caller holds page lock
 * - Return 0 if successful, -error otherwise
 */
527 528
static int nfs_launder_page(struct page *page)
{
529
	struct inode *inode = page_file_mapping(page)->host;
D
David Howells 已提交
530
	struct nfs_inode *nfsi = NFS_I(inode);
531 532 533 534

	dfprintk(PAGECACHE, "NFS: launder_page(%ld, %llu)\n",
		inode->i_ino, (long long)page_offset(page));

D
David Howells 已提交
535
	nfs_fscache_wait_on_page_write(nfsi, page);
536
	return nfs_wb_page(inode, page);
537 538
}

M
Mel Gorman 已提交
539 540 541 542 543 544 545 546 547 548 549 550 551 552
#ifdef CONFIG_NFS_SWAP
static int nfs_swap_activate(struct swap_info_struct *sis, struct file *file,
						sector_t *span)
{
	*span = sis->pages;
	return xs_swapper(NFS_CLIENT(file->f_mapping->host)->cl_xprt, 1);
}

static void nfs_swap_deactivate(struct file *file)
{
	xs_swapper(NFS_CLIENT(file->f_mapping->host)->cl_xprt, 0);
}
#endif

553
const struct address_space_operations nfs_file_aops = {
L
Linus Torvalds 已提交
554 555
	.readpage = nfs_readpage,
	.readpages = nfs_readpages,
T
Trond Myklebust 已提交
556
	.set_page_dirty = __set_page_dirty_nobuffers,
L
Linus Torvalds 已提交
557 558
	.writepage = nfs_writepage,
	.writepages = nfs_writepages,
N
Nick Piggin 已提交
559 560
	.write_begin = nfs_write_begin,
	.write_end = nfs_write_end,
561 562
	.invalidatepage = nfs_invalidate_page,
	.releasepage = nfs_release_page,
L
Linus Torvalds 已提交
563
	.direct_IO = nfs_direct_IO,
564
	.migratepage = nfs_migrate_page,
565
	.launder_page = nfs_launder_page,
566
	.is_dirty_writeback = nfs_check_dirty_writeback,
567
	.error_remove_page = generic_error_remove_page,
M
Mel Gorman 已提交
568 569 570 571
#ifdef CONFIG_NFS_SWAP
	.swap_activate = nfs_swap_activate,
	.swap_deactivate = nfs_swap_deactivate,
#endif
L
Linus Torvalds 已提交
572 573
};

574 575 576 577 578
/*
 * Notification that a PTE pointing to an NFS page is about to be made
 * writable, implying that someone is about to modify the page through a
 * shared-writable mapping
 */
579
static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
580
{
581
	struct page *page = vmf->page;
582
	struct file *filp = vma->vm_file;
583
	struct inode *inode = file_inode(filp);
584
	unsigned pagelen;
585
	int ret = VM_FAULT_NOPAGE;
N
Nick Piggin 已提交
586
	struct address_space *mapping;
587

588
	dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%pD2(%lu), offset %lld)\n",
589
		filp, filp->f_mapping->host->i_ino,
590 591
		(long long)page_offset(page));

D
David Howells 已提交
592
	/* make sure the cache has finished storing the page */
593
	nfs_fscache_wait_on_page_write(NFS_I(inode), page);
D
David Howells 已提交
594

595
	lock_page(page);
596
	mapping = page_file_mapping(page);
597
	if (mapping != inode->i_mapping)
598 599
		goto out_unlock;

600 601
	wait_on_page_writeback(page);

602
	pagelen = nfs_page_length(page);
603 604
	if (pagelen == 0)
		goto out_unlock;
N
Nick Piggin 已提交
605

606 607 608 609
	ret = VM_FAULT_LOCKED;
	if (nfs_flush_incompatible(filp, page) == 0 &&
	    nfs_updatepage(filp, page, 0, pagelen) == 0)
		goto out;
610

611
	ret = VM_FAULT_SIGBUS;
612 613
out_unlock:
	unlock_page(page);
614 615
out:
	return ret;
616 617
}

618
static const struct vm_operations_struct nfs_file_vm_ops = {
619
	.fault = filemap_fault,
620
	.map_pages = filemap_map_pages,
621
	.page_mkwrite = nfs_vm_page_mkwrite,
622
	.remap_pages = generic_file_remap_pages,
623 624
};

625 626 627 628
static int nfs_need_sync_write(struct file *filp, struct inode *inode)
{
	struct nfs_open_context *ctx;

629
	if (IS_SYNC(inode) || (filp->f_flags & O_DSYNC))
630
		return 1;
631
	ctx = nfs_file_open_context(filp);
632 633
	if (test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags) ||
	    nfs_ctx_key_to_expire(ctx))
634 635 636 637
		return 1;
	return 0;
}

638 639
ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov,
		       unsigned long nr_segs, loff_t pos)
L
Linus Torvalds 已提交
640
{
641 642
	struct file *file = iocb->ki_filp;
	struct inode *inode = file_inode(file);
643
	unsigned long written = 0;
L
Linus Torvalds 已提交
644
	ssize_t result;
645
	size_t count = iov_length(iov, nr_segs);
L
Linus Torvalds 已提交
646

647
	result = nfs_key_timeout_notify(file, inode);
648 649 650
	if (result)
		return result;

651
	if (file->f_flags & O_DIRECT)
M
Mel Gorman 已提交
652
		return nfs_file_direct_write(iocb, iov, nr_segs, pos, true);
L
Linus Torvalds 已提交
653

654 655
	dprintk("NFS: write(%pD2, %lu@%Ld)\n",
		file, (unsigned long) count, (long long) pos);
L
Linus Torvalds 已提交
656 657 658 659

	result = -EBUSY;
	if (IS_SWAPFILE(inode))
		goto out_swapfile;
660 661 662
	/*
	 * O_APPEND implies that we must revalidate the file length.
	 */
663 664
	if (file->f_flags & O_APPEND) {
		result = nfs_revalidate_file_size(inode, file);
665 666
		if (result)
			goto out;
667
	}
L
Linus Torvalds 已提交
668 669 670 671 672

	result = count;
	if (!count)
		goto out;

673
	result = generic_file_aio_write(iocb, iov, nr_segs, pos);
674 675 676
	if (result > 0)
		written = result;

677
	/* Return error values for O_DSYNC and IS_SYNC() */
678 679
	if (result >= 0 && nfs_need_sync_write(file, inode)) {
		int err = vfs_fsync(file, 0);
T
Trond Myklebust 已提交
680 681 682
		if (err < 0)
			result = err;
	}
683 684
	if (result > 0)
		nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
L
Linus Torvalds 已提交
685 686 687 688 689 690 691
out:
	return result;

out_swapfile:
	printk(KERN_INFO "NFS: attempt to write to active swap file!\n");
	goto out;
}
B
Bryan Schumaker 已提交
692
EXPORT_SYMBOL_GPL(nfs_file_write);
L
Linus Torvalds 已提交
693

694 695 696
ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
			      struct file *filp, loff_t *ppos,
			      size_t count, unsigned int flags)
697
{
698
	struct inode *inode = file_inode(filp);
699
	unsigned long written = 0;
700 701
	ssize_t ret;

702 703
	dprintk("NFS splice_write(%pD2, %lu@%llu)\n",
		filp, (unsigned long) count, (unsigned long long) *ppos);
704 705 706 707 708 709

	/*
	 * The combination of splice and an O_APPEND destination is disallowed.
	 */

	ret = generic_file_splice_write(pipe, filp, ppos, count, flags);
710 711 712
	if (ret > 0)
		written = ret;

713
	if (ret >= 0 && nfs_need_sync_write(filp, inode)) {
T
Trond Myklebust 已提交
714
		int err = vfs_fsync(filp, 0);
715 716 717
		if (err < 0)
			ret = err;
	}
718 719
	if (ret > 0)
		nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
720 721
	return ret;
}
B
Bryan Schumaker 已提交
722
EXPORT_SYMBOL_GPL(nfs_file_splice_write);
723

724 725
static int
do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
L
Linus Torvalds 已提交
726 727 728
{
	struct inode *inode = filp->f_mapping->host;
	int status = 0;
729
	unsigned int saved_type = fl->fl_type;
L
Linus Torvalds 已提交
730

731
	/* Try local locking first */
732 733 734
	posix_test_lock(filp, fl);
	if (fl->fl_type != F_UNLCK) {
		/* found a conflict */
735
		goto out;
L
Linus Torvalds 已提交
736
	}
737
	fl->fl_type = saved_type;
738

739
	if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
740 741
		goto out_noconflict;

742
	if (is_local)
743 744 745 746
		goto out_noconflict;

	status = NFS_PROTO(inode)->lock(filp, cmd, fl);
out:
L
Linus Torvalds 已提交
747
	return status;
748 749 750
out_noconflict:
	fl->fl_type = F_UNLCK;
	goto out;
L
Linus Torvalds 已提交
751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768
}

static int do_vfs_lock(struct file *file, struct file_lock *fl)
{
	int res = 0;
	switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
		case FL_POSIX:
			res = posix_lock_file_wait(file, fl);
			break;
		case FL_FLOCK:
			res = flock_lock_file_wait(file, fl);
			break;
		default:
			BUG();
	}
	return res;
}

769 770
static int
do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
L
Linus Torvalds 已提交
771 772
{
	struct inode *inode = filp->f_mapping->host;
773
	struct nfs_lock_context *l_ctx;
L
Linus Torvalds 已提交
774 775 776 777 778 779
	int status;

	/*
	 * Flush all pending writes before doing anything
	 * with locks..
	 */
T
Trond Myklebust 已提交
780
	nfs_sync_mapping(filp->f_mapping);
L
Linus Torvalds 已提交
781

782 783 784 785 786 787 788 789
	l_ctx = nfs_get_lock_context(nfs_file_open_context(filp));
	if (!IS_ERR(l_ctx)) {
		status = nfs_iocounter_wait(&l_ctx->io_count);
		nfs_put_lock_context(l_ctx);
		if (status < 0)
			return status;
	}

L
Linus Torvalds 已提交
790 791 792 793
	/* NOTE: special case
	 * 	If we're signalled while cleaning up locks on process exit, we
	 * 	still need to complete the unlock.
	 */
794 795 796 797 798
	/*
	 * Use local locking if mounted with "-onolock" or with appropriate
	 * "-olocal_lock="
	 */
	if (!is_local)
L
Linus Torvalds 已提交
799 800 801 802 803 804
		status = NFS_PROTO(inode)->lock(filp, cmd, fl);
	else
		status = do_vfs_lock(filp, fl);
	return status;
}

R
Ricardo Labiaga 已提交
805 806 807 808 809
static int
is_time_granular(struct timespec *ts) {
	return ((ts->tv_sec == 0) && (ts->tv_nsec <= 1000));
}

810 811
static int
do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
L
Linus Torvalds 已提交
812 813 814 815 816 817 818 819
{
	struct inode *inode = filp->f_mapping->host;
	int status;

	/*
	 * Flush all pending writes before doing anything
	 * with locks..
	 */
T
Trond Myklebust 已提交
820 821
	status = nfs_sync_mapping(filp->f_mapping);
	if (status != 0)
L
Linus Torvalds 已提交
822 823
		goto out;

824 825 826 827 828
	/*
	 * Use local locking if mounted with "-onolock" or with appropriate
	 * "-olocal_lock="
	 */
	if (!is_local)
L
Linus Torvalds 已提交
829
		status = NFS_PROTO(inode)->lock(filp, cmd, fl);
830
	else
L
Linus Torvalds 已提交
831 832 833
		status = do_vfs_lock(filp, fl);
	if (status < 0)
		goto out;
R
Ricardo Labiaga 已提交
834

L
Linus Torvalds 已提交
835
	/*
R
Ricardo Labiaga 已提交
836 837 838 839
	 * Revalidate the cache if the server has time stamps granular
	 * enough to detect subsecond changes.  Otherwise, clear the
	 * cache to prevent missing any changes.
	 *
L
Linus Torvalds 已提交
840 841
	 * This makes locking act as a cache coherency point.
	 */
T
Trond Myklebust 已提交
842
	nfs_sync_mapping(filp->f_mapping);
843
	if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) {
R
Ricardo Labiaga 已提交
844 845 846 847 848
		if (is_time_granular(&NFS_SERVER(inode)->time_delta))
			__nfs_revalidate_inode(NFS_SERVER(inode), inode);
		else
			nfs_zap_caches(inode);
	}
L
Linus Torvalds 已提交
849 850 851 852 853 854 855
out:
	return status;
}

/*
 * Lock a (portion of) a file
 */
856
int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
L
Linus Torvalds 已提交
857
{
C
Chuck Lever 已提交
858
	struct inode *inode = filp->f_mapping->host;
859
	int ret = -ENOLCK;
860
	int is_local = 0;
L
Linus Torvalds 已提交
861

862 863
	dprintk("NFS: lock(%pD2, t=%x, fl=%x, r=%lld:%lld)\n",
			filp, fl->fl_type, fl->fl_flags,
L
Linus Torvalds 已提交
864
			(long long)fl->fl_start, (long long)fl->fl_end);
C
Chuck Lever 已提交
865

C
Chuck Lever 已提交
866
	nfs_inc_stats(inode, NFSIOS_VFSLOCK);
L
Linus Torvalds 已提交
867 868

	/* No mandatory locks over NFS */
869
	if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
870 871
		goto out_err;

872 873 874
	if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL)
		is_local = 1;

875 876 877 878 879
	if (NFS_PROTO(inode)->lock_check_bounds != NULL) {
		ret = NFS_PROTO(inode)->lock_check_bounds(fl);
		if (ret < 0)
			goto out_err;
	}
L
Linus Torvalds 已提交
880 881

	if (IS_GETLK(cmd))
882
		ret = do_getlk(filp, cmd, fl, is_local);
883
	else if (fl->fl_type == F_UNLCK)
884
		ret = do_unlk(filp, cmd, fl, is_local);
885
	else
886
		ret = do_setlk(filp, cmd, fl, is_local);
887 888
out_err:
	return ret;
L
Linus Torvalds 已提交
889
}
B
Bryan Schumaker 已提交
890
EXPORT_SYMBOL_GPL(nfs_lock);
L
Linus Torvalds 已提交
891 892 893 894

/*
 * Lock a (portion of) a file
 */
895
int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
L
Linus Torvalds 已提交
896
{
897 898 899
	struct inode *inode = filp->f_mapping->host;
	int is_local = 0;

900 901
	dprintk("NFS: flock(%pD2, t=%x, fl=%x)\n",
			filp, fl->fl_type, fl->fl_flags);
L
Linus Torvalds 已提交
902 903 904 905

	if (!(fl->fl_flags & FL_FLOCK))
		return -ENOLCK;

906 907 908 909 910 911 912 913 914
	/*
	 * The NFSv4 protocol doesn't support LOCK_MAND, which is not part of
	 * any standard. In principle we might be able to support LOCK_MAND
	 * on NFSv2/3 since NLMv3/4 support DOS share modes, but for now the
	 * NFS code is not set up for it.
	 */
	if (fl->fl_type & LOCK_MAND)
		return -EINVAL;

915 916 917
	if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK)
		is_local = 1;

L
Linus Torvalds 已提交
918 919
	/* We're simulating flock() locks using posix locks on the server */
	if (fl->fl_type == F_UNLCK)
920 921
		return do_unlk(filp, cmd, fl, is_local);
	return do_setlk(filp, cmd, fl, is_local);
L
Linus Torvalds 已提交
922
}
B
Bryan Schumaker 已提交
923
EXPORT_SYMBOL_GPL(nfs_flock);
J
J. Bruce Fields 已提交
924

C
Chuck Lever 已提交
925 926 927 928
/*
 * There is no protocol support for leases, so we have no way to implement
 * them correctly in the face of opens by other clients.
 */
929
int nfs_setlease(struct file *file, long arg, struct file_lock **fl)
J
J. Bruce Fields 已提交
930
{
931
	dprintk("NFS: setlease(%pD2, arg=%ld)\n", file, arg);
J
J. Bruce Fields 已提交
932 933
	return -EINVAL;
}
B
Bryan Schumaker 已提交
934
EXPORT_SYMBOL_GPL(nfs_setlease);
935

936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953
const struct file_operations nfs_file_operations = {
	.llseek		= nfs_file_llseek,
	.read		= do_sync_read,
	.write		= do_sync_write,
	.aio_read	= nfs_file_read,
	.aio_write	= nfs_file_write,
	.mmap		= nfs_file_mmap,
	.open		= nfs_file_open,
	.flush		= nfs_file_flush,
	.release	= nfs_file_release,
	.fsync		= nfs_file_fsync,
	.lock		= nfs_lock,
	.flock		= nfs_flock,
	.splice_read	= nfs_file_splice_read,
	.splice_write	= nfs_file_splice_write,
	.check_flags	= nfs_check_flags,
	.setlease	= nfs_setlease,
};
B
Bryan Schumaker 已提交
954
EXPORT_SYMBOL_GPL(nfs_file_operations);