file.c 23.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 19 20 21 22 23 24 25 26 27
/*
 *  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
 */

#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 已提交
28
#include <linux/aio.h>
29
#include <linux/gfp.h>
30
#include <linux/swap.h>
L
Linus Torvalds 已提交
31 32 33 34

#include <asm/uaccess.h>

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

#define NFSDBG_FACILITY		NFSDBG_FILE

42
static const struct vm_operations_struct nfs_file_vm_ops;
43

44
const struct inode_operations nfs_file_inode_operations = {
L
Linus Torvalds 已提交
45 46 47 48 49
	.permission	= nfs_permission,
	.getattr	= nfs_getattr,
	.setattr	= nfs_setattr,
};

50
#ifdef CONFIG_NFS_V3
51
const struct inode_operations nfs3_file_inode_operations = {
52 53 54 55 56 57 58 59 60 61
	.permission	= nfs_permission,
	.getattr	= nfs_getattr,
	.setattr	= nfs_setattr,
	.listxattr	= nfs3_listxattr,
	.getxattr	= nfs3_getxattr,
	.setxattr	= nfs3_setxattr,
	.removexattr	= nfs3_removexattr,
};
#endif  /* CONFIG_NFS_v3 */

L
Linus Torvalds 已提交
62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82
/* Hack for future NFS swap support */
#ifndef IS_SWAPFILE
# define IS_SWAPFILE(inode)	(0)
#endif

static int nfs_check_flags(int flags)
{
	if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT))
		return -EINVAL;

	return 0;
}

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

C
Chuck Lever 已提交
83
	dprintk("NFS: open file(%s/%s)\n",
84 85 86
			filp->f_path.dentry->d_parent->d_name.name,
			filp->f_path.dentry->d_name.name);

87
	nfs_inc_stats(inode, NFSIOS_VFSOPEN);
L
Linus Torvalds 已提交
88 89 90 91
	res = nfs_check_flags(filp->f_flags);
	if (res)
		return res;

92
	res = nfs_open(inode, filp);
L
Linus Torvalds 已提交
93 94 95 96 97 98
	return res;
}

static int
nfs_file_release(struct inode *inode, struct file *filp)
{
C
Chuck Lever 已提交
99
	dprintk("NFS: release(%s/%s)\n",
100 101
			filp->f_path.dentry->d_parent->d_name.name,
			filp->f_path.dentry->d_name.name);
C
Chuck Lever 已提交
102

C
Chuck Lever 已提交
103
	nfs_inc_stats(inode, NFSIOS_VFSRELEASE);
104
	return nfs_release(inode, filp);
L
Linus Torvalds 已提交
105 106
}

107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122
/**
 * 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);

123 124 125
	if (nfs_have_delegated_attributes(inode))
		goto out_noreval;

126 127
	if (filp->f_flags & O_DIRECT)
		goto force_reval;
128 129 130 131 132 133
	if (nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
		goto force_reval;
	if (nfs_attribute_timeout(inode))
		goto force_reval;
out_noreval:
	return 0;
134 135 136 137 138 139
force_reval:
	return __nfs_revalidate_inode(server, inode);
}

static loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin)
{
C
Chuck Lever 已提交
140
	dprintk("NFS: llseek file(%s/%s, %lld, %d)\n",
141 142 143 144
			filp->f_path.dentry->d_parent->d_name.name,
			filp->f_path.dentry->d_name.name,
			offset, origin);

145 146 147 148
	/*
	 * origin == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
	 * the cached file length
	 */
149
	if (origin != SEEK_SET && origin != SEEK_CUR) {
150
		struct inode *inode = filp->f_mapping->host;
T
Trond Myklebust 已提交
151

152 153 154
		int retval = nfs_revalidate_file_size(inode, filp);
		if (retval < 0)
			return (loff_t)retval;
155
	}
T
Trond Myklebust 已提交
156

157
	return generic_file_llseek(filp, offset, origin);
158 159
}

L
Linus Torvalds 已提交
160 161 162 163
/*
 * Flush all dirty pages, and check for write errors.
 */
static int
164
nfs_file_flush(struct file *file, fl_owner_t id)
L
Linus Torvalds 已提交
165
{
C
Chuck Lever 已提交
166 167
	struct dentry	*dentry = file->f_path.dentry;
	struct inode	*inode = dentry->d_inode;
L
Linus Torvalds 已提交
168

C
Chuck Lever 已提交
169 170 171
	dprintk("NFS: flush(%s/%s)\n",
			dentry->d_parent->d_name.name,
			dentry->d_name.name);
L
Linus Torvalds 已提交
172

173
	nfs_inc_stats(inode, NFSIOS_VFSFLUSH);
L
Linus Torvalds 已提交
174 175
	if ((file->f_mode & FMODE_WRITE) == 0)
		return 0;
176

T
Trond Myklebust 已提交
177
	/* Flush writes to the server and return any errors */
T
Trond Myklebust 已提交
178
	return vfs_fsync(file, 0);
L
Linus Torvalds 已提交
179 180 181
}

static ssize_t
182 183
nfs_file_read(struct kiocb *iocb, const struct iovec *iov,
		unsigned long nr_segs, loff_t pos)
L
Linus Torvalds 已提交
184
{
185
	struct dentry * dentry = iocb->ki_filp->f_path.dentry;
L
Linus Torvalds 已提交
186 187 188 189
	struct inode * inode = dentry->d_inode;
	ssize_t result;

	if (iocb->ki_filp->f_flags & O_DIRECT)
190
		return nfs_file_direct_read(iocb, iov, nr_segs, pos);
L
Linus Torvalds 已提交
191

C
Chuck Lever 已提交
192
	dprintk("NFS: read(%s/%s, %lu@%lu)\n",
L
Linus Torvalds 已提交
193
		dentry->d_parent->d_name.name, dentry->d_name.name,
194
		(unsigned long) iov_length(iov, nr_segs), (unsigned long) pos);
L
Linus Torvalds 已提交
195

196
	result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping);
197
	if (!result) {
198
		result = generic_file_aio_read(iocb, iov, nr_segs, pos);
199 200 201
		if (result > 0)
			nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, result);
	}
L
Linus Torvalds 已提交
202 203 204 205
	return result;
}

static ssize_t
206 207 208
nfs_file_splice_read(struct file *filp, loff_t *ppos,
		     struct pipe_inode_info *pipe, size_t count,
		     unsigned int flags)
L
Linus Torvalds 已提交
209
{
210
	struct dentry *dentry = filp->f_path.dentry;
L
Linus Torvalds 已提交
211 212 213
	struct inode *inode = dentry->d_inode;
	ssize_t res;

C
Chuck Lever 已提交
214
	dprintk("NFS: splice_read(%s/%s, %lu@%Lu)\n",
L
Linus Torvalds 已提交
215 216 217
		dentry->d_parent->d_name.name, dentry->d_name.name,
		(unsigned long) count, (unsigned long long) *ppos);

218
	res = nfs_revalidate_mapping(inode, filp->f_mapping);
219
	if (!res) {
220
		res = generic_file_splice_read(filp, ppos, pipe, count, flags);
221 222 223
		if (res > 0)
			nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, res);
	}
L
Linus Torvalds 已提交
224 225 226 227 228 229
	return res;
}

static int
nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
{
230
	struct dentry *dentry = file->f_path.dentry;
L
Linus Torvalds 已提交
231 232 233
	struct inode *inode = dentry->d_inode;
	int	status;

C
Chuck Lever 已提交
234
	dprintk("NFS: mmap(%s/%s)\n",
L
Linus Torvalds 已提交
235 236
		dentry->d_parent->d_name.name, dentry->d_name.name);

237 238 239 240
	/* Note: generic_file_mmap() returns ENOSYS on nommu systems
	 *       so we call that before revalidating the mapping
	 */
	status = generic_file_mmap(file, vma);
241 242
	if (!status) {
		vma->vm_ops = &nfs_file_vm_ops;
243
		status = nfs_revalidate_mapping(inode, file->f_mapping);
244
	}
L
Linus Torvalds 已提交
245 246 247 248 249 250 251
	return status;
}

/*
 * 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 已提交
252 253 254 255 256
 *
 * 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 已提交
257
 * nfs_file_write() that a write error occurred, and hence cause it to
T
Trond Myklebust 已提交
258
 * fall back to doing a synchronous write.
L
Linus Torvalds 已提交
259 260
 */
static int
261
nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
L
Linus Torvalds 已提交
262
{
263
	struct dentry *dentry = file->f_path.dentry;
264
	struct nfs_open_context *ctx = nfs_file_open_context(file);
L
Linus Torvalds 已提交
265
	struct inode *inode = dentry->d_inode;
T
Trond Myklebust 已提交
266 267 268
	int have_error, status;
	int ret = 0;

C
Chuck Lever 已提交
269
	dprintk("NFS: fsync file(%s/%s) datasync %d\n",
270 271
			dentry->d_parent->d_name.name, dentry->d_name.name,
			datasync);
L
Linus Torvalds 已提交
272

273 274 275
	ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
	mutex_lock(&inode->i_mutex);

C
Chuck Lever 已提交
276
	nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
T
Trond Myklebust 已提交
277 278
	have_error = test_and_clear_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
	status = nfs_commit_inode(inode, FLUSH_SYNC);
279 280
	if (status >= 0 && ret < 0)
		status = ret;
T
Trond Myklebust 已提交
281 282 283
	have_error |= test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
	if (have_error)
		ret = xchg(&ctx->error, 0);
284
	if (!ret && status < 0)
T
Trond Myklebust 已提交
285
		ret = status;
A
Andy Adamson 已提交
286 287
	if (!ret && !datasync)
		/* application has asked for meta-data sync */
288
		ret = pnfs_layoutcommit_inode(inode, true);
289
	mutex_unlock(&inode->i_mutex);
T
Trond Myklebust 已提交
290
	return ret;
L
Linus Torvalds 已提交
291 292
}

293 294 295 296 297 298 299 300 301 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
/*
 * 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 已提交
329
/*
N
Nick Piggin 已提交
330 331 332
 * 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 已提交
333 334 335 336
 *
 * 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 已提交
337 338 339
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 已提交
340
{
N
Nick Piggin 已提交
341
	int ret;
342
	pgoff_t index = pos >> PAGE_CACHE_SHIFT;
N
Nick Piggin 已提交
343
	struct page *page;
344
	int once_thru = 0;
N
Nick Piggin 已提交
345

346 347 348 349 350
	dfprintk(PAGECACHE, "NFS: write_begin(%s/%s(%ld), %u@%lld)\n",
		file->f_path.dentry->d_parent->d_name.name,
		file->f_path.dentry->d_name.name,
		mapping->host->i_ino, len, (long long) pos);

351
start:
352 353 354 355 356 357 358 359 360
	/*
	 * 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;

361
	page = grab_cache_page_write_begin(mapping, index, flags);
N
Nick Piggin 已提交
362 363 364 365 366 367 368 369
	if (!page)
		return -ENOMEM;
	*pagep = page;

	ret = nfs_flush_incompatible(file, page);
	if (ret) {
		unlock_page(page);
		page_cache_release(page);
370 371 372 373 374 375 376
	} 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 已提交
377 378
	}
	return ret;
L
Linus Torvalds 已提交
379 380
}

N
Nick Piggin 已提交
381 382 383
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 已提交
384
{
N
Nick Piggin 已提交
385 386
	unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
	int status;
L
Linus Torvalds 已提交
387

388 389 390 391 392
	dfprintk(PAGECACHE, "NFS: write_end(%s/%s(%ld), %u@%lld)\n",
		file->f_path.dentry->d_parent->d_name.name,
		file->f_path.dentry->d_name.name,
		mapping->host->i_ino, len, (long long) pos);

393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412
	/*
	 * 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 已提交
413 414 415 416 417
	status = nfs_updatepage(file, page, offset, copied);

	unlock_page(page);
	page_cache_release(page);

C
Chuck Lever 已提交
418 419 420
	if (status < 0)
		return status;
	return copied;
L
Linus Torvalds 已提交
421 422
}

423 424 425 426
/*
 * Partially or wholly invalidate a page
 * - Release the private state associated with a page if undergoing complete
 *   page invalidation
D
David Howells 已提交
427
 * - Called if either PG_private or PG_fscache is set on the page
428 429
 * - Caller holds page lock
 */
430
static void nfs_invalidate_page(struct page *page, unsigned long offset)
431
{
432 433
	dfprintk(PAGECACHE, "NFS: invalidate_page(%p, %lu)\n", page, offset);

434 435
	if (offset != 0)
		return;
436
	/* Cancel any unstarted writes on this page */
437
	nfs_wb_page_cancel(page->mapping->host, page);
D
David Howells 已提交
438 439

	nfs_fscache_invalidate_page(page, page->mapping->host);
440 441
}

442 443
/*
 * Attempt to release the private state associated with a page
D
David Howells 已提交
444
 * - Called if either PG_private or PG_fscache is set on the page
445 446 447
 * - Caller holds page lock
 * - Return true (may release page) or false (may not)
 */
448 449
static int nfs_release_page(struct page *page, gfp_t gfp)
{
450 451
	struct address_space *mapping = page->mapping;

452 453
	dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page);

454
	/* Only do I/O if gfp is a superset of GFP_KERNEL */
455 456 457 458 459 460 461 462
	if (mapping && (gfp & GFP_KERNEL) == GFP_KERNEL) {
		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);
	}
463
	/* If PagePrivate() is set, then the page is not freeable */
D
David Howells 已提交
464 465 466
	if (PagePrivate(page))
		return 0;
	return nfs_fscache_release_page(page, gfp);
467 468
}

469 470 471 472
/*
 * 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 已提交
473
 * - Called if either PG_private or fscache is set on the page
474 475 476
 * - Caller holds page lock
 * - Return 0 if successful, -error otherwise
 */
477 478
static int nfs_launder_page(struct page *page)
{
479
	struct inode *inode = page->mapping->host;
D
David Howells 已提交
480
	struct nfs_inode *nfsi = NFS_I(inode);
481 482 483 484

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

D
David Howells 已提交
485
	nfs_fscache_wait_on_page_write(nfsi, page);
486
	return nfs_wb_page(inode, page);
487 488
}

489
const struct address_space_operations nfs_file_aops = {
L
Linus Torvalds 已提交
490 491
	.readpage = nfs_readpage,
	.readpages = nfs_readpages,
T
Trond Myklebust 已提交
492
	.set_page_dirty = __set_page_dirty_nobuffers,
L
Linus Torvalds 已提交
493 494
	.writepage = nfs_writepage,
	.writepages = nfs_writepages,
N
Nick Piggin 已提交
495 496
	.write_begin = nfs_write_begin,
	.write_end = nfs_write_end,
497 498
	.invalidatepage = nfs_invalidate_page,
	.releasepage = nfs_release_page,
L
Linus Torvalds 已提交
499
	.direct_IO = nfs_direct_IO,
500
	.migratepage = nfs_migrate_page,
501
	.launder_page = nfs_launder_page,
502
	.error_remove_page = generic_error_remove_page,
L
Linus Torvalds 已提交
503 504
};

505 506 507 508 509
/*
 * 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
 */
510
static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
511
{
512
	struct page *page = vmf->page;
513
	struct file *filp = vma->vm_file;
514
	struct dentry *dentry = filp->f_path.dentry;
515
	unsigned pagelen;
516
	int ret = VM_FAULT_NOPAGE;
N
Nick Piggin 已提交
517
	struct address_space *mapping;
518

519 520 521 522 523
	dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%s/%s(%ld), offset %lld)\n",
		dentry->d_parent->d_name.name, dentry->d_name.name,
		filp->f_mapping->host->i_ino,
		(long long)page_offset(page));

D
David Howells 已提交
524 525 526
	/* make sure the cache has finished storing the page */
	nfs_fscache_wait_on_page_write(NFS_I(dentry->d_inode), page);

527
	lock_page(page);
N
Nick Piggin 已提交
528
	mapping = page->mapping;
529
	if (mapping != dentry->d_inode->i_mapping)
530 531
		goto out_unlock;

532 533
	wait_on_page_writeback(page);

534
	pagelen = nfs_page_length(page);
535 536
	if (pagelen == 0)
		goto out_unlock;
N
Nick Piggin 已提交
537

538 539 540 541
	ret = VM_FAULT_LOCKED;
	if (nfs_flush_incompatible(filp, page) == 0 &&
	    nfs_updatepage(filp, page, 0, pagelen) == 0)
		goto out;
542

543
	ret = VM_FAULT_SIGBUS;
544 545
out_unlock:
	unlock_page(page);
546 547
out:
	return ret;
548 549
}

550
static const struct vm_operations_struct nfs_file_vm_ops = {
551 552 553 554
	.fault = filemap_fault,
	.page_mkwrite = nfs_vm_page_mkwrite,
};

555 556 557 558
static int nfs_need_sync_write(struct file *filp, struct inode *inode)
{
	struct nfs_open_context *ctx;

559
	if (IS_SYNC(inode) || (filp->f_flags & O_DSYNC))
560
		return 1;
561
	ctx = nfs_file_open_context(filp);
562 563 564 565 566
	if (test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags))
		return 1;
	return 0;
}

567 568
static ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov,
				unsigned long nr_segs, loff_t pos)
L
Linus Torvalds 已提交
569
{
570
	struct dentry * dentry = iocb->ki_filp->f_path.dentry;
L
Linus Torvalds 已提交
571
	struct inode * inode = dentry->d_inode;
572
	unsigned long written = 0;
L
Linus Torvalds 已提交
573
	ssize_t result;
574
	size_t count = iov_length(iov, nr_segs);
L
Linus Torvalds 已提交
575 576

	if (iocb->ki_filp->f_flags & O_DIRECT)
577
		return nfs_file_direct_write(iocb, iov, nr_segs, pos);
L
Linus Torvalds 已提交
578

C
Chuck Lever 已提交
579
	dprintk("NFS: write(%s/%s, %lu@%Ld)\n",
L
Linus Torvalds 已提交
580
		dentry->d_parent->d_name.name, dentry->d_name.name,
C
Chuck Lever 已提交
581
		(unsigned long) count, (long long) pos);
L
Linus Torvalds 已提交
582 583 584 585

	result = -EBUSY;
	if (IS_SWAPFILE(inode))
		goto out_swapfile;
586 587 588 589 590 591 592
	/*
	 * O_APPEND implies that we must revalidate the file length.
	 */
	if (iocb->ki_filp->f_flags & O_APPEND) {
		result = nfs_revalidate_file_size(inode, iocb->ki_filp);
		if (result)
			goto out;
593
	}
L
Linus Torvalds 已提交
594 595 596 597 598

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

599
	result = generic_file_aio_write(iocb, iov, nr_segs, pos);
600 601 602
	if (result > 0)
		written = result;

603
	/* Return error values for O_DSYNC and IS_SYNC() */
604
	if (result >= 0 && nfs_need_sync_write(iocb->ki_filp, inode)) {
T
Trond Myklebust 已提交
605
		int err = vfs_fsync(iocb->ki_filp, 0);
T
Trond Myklebust 已提交
606 607 608
		if (err < 0)
			result = err;
	}
609 610
	if (result > 0)
		nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
L
Linus Torvalds 已提交
611 612 613 614 615 616 617 618
out:
	return result;

out_swapfile:
	printk(KERN_INFO "NFS: attempt to write to active swap file!\n");
	goto out;
}

619 620 621 622 623 624
static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
				     struct file *filp, loff_t *ppos,
				     size_t count, unsigned int flags)
{
	struct dentry *dentry = filp->f_path.dentry;
	struct inode *inode = dentry->d_inode;
625
	unsigned long written = 0;
626 627 628 629 630 631 632 633 634 635 636
	ssize_t ret;

	dprintk("NFS splice_write(%s/%s, %lu@%llu)\n",
		dentry->d_parent->d_name.name, dentry->d_name.name,
		(unsigned long) count, (unsigned long long) *ppos);

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

	ret = generic_file_splice_write(pipe, filp, ppos, count, flags);
637 638 639
	if (ret > 0)
		written = ret;

640
	if (ret >= 0 && nfs_need_sync_write(filp, inode)) {
T
Trond Myklebust 已提交
641
		int err = vfs_fsync(filp, 0);
642 643 644
		if (err < 0)
			ret = err;
	}
645 646
	if (ret > 0)
		nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
647 648 649
	return ret;
}

650 651
static int
do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
L
Linus Torvalds 已提交
652 653 654
{
	struct inode *inode = filp->f_mapping->host;
	int status = 0;
655
	unsigned int saved_type = fl->fl_type;
L
Linus Torvalds 已提交
656

657
	/* Try local locking first */
658 659 660
	posix_test_lock(filp, fl);
	if (fl->fl_type != F_UNLCK) {
		/* found a conflict */
661
		goto out;
L
Linus Torvalds 已提交
662
	}
663
	fl->fl_type = saved_type;
664 665 666 667

	if (nfs_have_delegation(inode, FMODE_READ))
		goto out_noconflict;

668
	if (is_local)
669 670 671 672
		goto out_noconflict;

	status = NFS_PROTO(inode)->lock(filp, cmd, fl);
out:
L
Linus Torvalds 已提交
673
	return status;
674 675 676
out_noconflict:
	fl->fl_type = F_UNLCK;
	goto out;
L
Linus Torvalds 已提交
677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694
}

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;
}

695 696
static int
do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
L
Linus Torvalds 已提交
697 698 699 700 701 702 703 704
{
	struct inode *inode = filp->f_mapping->host;
	int status;

	/*
	 * Flush all pending writes before doing anything
	 * with locks..
	 */
T
Trond Myklebust 已提交
705
	nfs_sync_mapping(filp->f_mapping);
L
Linus Torvalds 已提交
706 707 708 709 710

	/* NOTE: special case
	 * 	If we're signalled while cleaning up locks on process exit, we
	 * 	still need to complete the unlock.
	 */
711 712 713 714 715
	/*
	 * Use local locking if mounted with "-onolock" or with appropriate
	 * "-olocal_lock="
	 */
	if (!is_local)
L
Linus Torvalds 已提交
716 717 718 719 720 721
		status = NFS_PROTO(inode)->lock(filp, cmd, fl);
	else
		status = do_vfs_lock(filp, fl);
	return status;
}

R
Ricardo Labiaga 已提交
722 723 724 725 726
static int
is_time_granular(struct timespec *ts) {
	return ((ts->tv_sec == 0) && (ts->tv_nsec <= 1000));
}

727 728
static int
do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
L
Linus Torvalds 已提交
729 730 731 732 733 734 735 736
{
	struct inode *inode = filp->f_mapping->host;
	int status;

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

741 742 743 744 745
	/*
	 * Use local locking if mounted with "-onolock" or with appropriate
	 * "-olocal_lock="
	 */
	if (!is_local)
L
Linus Torvalds 已提交
746
		status = NFS_PROTO(inode)->lock(filp, cmd, fl);
747
	else
L
Linus Torvalds 已提交
748 749 750
		status = do_vfs_lock(filp, fl);
	if (status < 0)
		goto out;
R
Ricardo Labiaga 已提交
751

L
Linus Torvalds 已提交
752
	/*
R
Ricardo Labiaga 已提交
753 754 755 756
	 * 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 已提交
757 758
	 * This makes locking act as a cache coherency point.
	 */
T
Trond Myklebust 已提交
759
	nfs_sync_mapping(filp->f_mapping);
R
Ricardo Labiaga 已提交
760 761 762 763 764 765
	if (!nfs_have_delegation(inode, FMODE_READ)) {
		if (is_time_granular(&NFS_SERVER(inode)->time_delta))
			__nfs_revalidate_inode(NFS_SERVER(inode), inode);
		else
			nfs_zap_caches(inode);
	}
L
Linus Torvalds 已提交
766 767 768 769 770 771 772 773 774
out:
	return status;
}

/*
 * Lock a (portion of) a file
 */
static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
{
C
Chuck Lever 已提交
775
	struct inode *inode = filp->f_mapping->host;
776
	int ret = -ENOLCK;
777
	int is_local = 0;
L
Linus Torvalds 已提交
778

C
Chuck Lever 已提交
779 780 781
	dprintk("NFS: lock(%s/%s, t=%x, fl=%x, r=%lld:%lld)\n",
			filp->f_path.dentry->d_parent->d_name.name,
			filp->f_path.dentry->d_name.name,
L
Linus Torvalds 已提交
782 783
			fl->fl_type, fl->fl_flags,
			(long long)fl->fl_start, (long long)fl->fl_end);
C
Chuck Lever 已提交
784

C
Chuck Lever 已提交
785
	nfs_inc_stats(inode, NFSIOS_VFSLOCK);
L
Linus Torvalds 已提交
786 787

	/* No mandatory locks over NFS */
788
	if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
789 790
		goto out_err;

791 792 793
	if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL)
		is_local = 1;

794 795 796 797 798
	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 已提交
799 800

	if (IS_GETLK(cmd))
801
		ret = do_getlk(filp, cmd, fl, is_local);
802
	else if (fl->fl_type == F_UNLCK)
803
		ret = do_unlk(filp, cmd, fl, is_local);
804
	else
805
		ret = do_setlk(filp, cmd, fl, is_local);
806 807
out_err:
	return ret;
L
Linus Torvalds 已提交
808 809 810 811 812 813 814
}

/*
 * Lock a (portion of) a file
 */
static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
{
815 816 817
	struct inode *inode = filp->f_mapping->host;
	int is_local = 0;

C
Chuck Lever 已提交
818 819 820
	dprintk("NFS: flock(%s/%s, t=%x, fl=%x)\n",
			filp->f_path.dentry->d_parent->d_name.name,
			filp->f_path.dentry->d_name.name,
L
Linus Torvalds 已提交
821 822 823 824 825
			fl->fl_type, fl->fl_flags);

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

826 827 828
	if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK)
		is_local = 1;

L
Linus Torvalds 已提交
829 830 831 832 833 834
	/* We're simulating flock() locks using posix locks on the server */
	fl->fl_owner = (fl_owner_t)filp;
	fl->fl_start = 0;
	fl->fl_end = OFFSET_MAX;

	if (fl->fl_type == F_UNLCK)
835 836
		return do_unlk(filp, cmd, fl, is_local);
	return do_setlk(filp, cmd, fl, is_local);
L
Linus Torvalds 已提交
837
}
J
J. Bruce Fields 已提交
838

C
Chuck Lever 已提交
839 840 841 842
/*
 * There is no protocol support for leases, so we have no way to implement
 * them correctly in the face of opens by other clients.
 */
J
J. Bruce Fields 已提交
843 844
static int nfs_setlease(struct file *file, long arg, struct file_lock **fl)
{
C
Chuck Lever 已提交
845 846 847
	dprintk("NFS: setlease(%s/%s, arg=%ld)\n",
			file->f_path.dentry->d_parent->d_name.name,
			file->f_path.dentry->d_name.name, arg);
J
J. Bruce Fields 已提交
848 849
	return -EINVAL;
}
850

851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869
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,
};

870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900
#ifdef CONFIG_NFS_V4
static int
nfs4_file_open(struct inode *inode, struct file *filp)
{
	/*
	 * NFSv4 opens are handled in d_lookup and d_revalidate. If we get to
	 * this point, then something is very wrong
	 */
	dprintk("NFS: %s called! inode=%p filp=%p\n", __func__, inode, filp);
	return -ENOTDIR;
}

const struct file_operations nfs4_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		= nfs4_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,
};
#endif /* CONFIG_NFS_V4 */