]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - fs/nfs/file.c
NFS: Create a v4-specific fsync function
[mirror_ubuntu-zesty-kernel.git] / fs / nfs / file.c
CommitLineData
1da177e4
LT
1/*
2 * linux/fs/nfs/file.c
3 *
4 * Copyright (C) 1992 Rick Sladkey
5 *
6 * Changes Copyright (C) 1994 by Florian La Roche
7 * - Do not copy data too often around in the kernel.
8 * - In nfs_file_read the return value of kmalloc wasn't checked.
9 * - Put in a better version of read look-ahead buffering. Original idea
10 * and implementation by Wai S Kok elekokws@ee.nus.sg.
11 *
12 * Expire cache on write to a file by Wai S Kok (Oct 1994).
13 *
14 * Total rewrite of read side for new NFS buffer cache.. Linus.
15 *
16 * nfs regular file handling functions
17 */
18
19#include <linux/time.h>
20#include <linux/kernel.h>
21#include <linux/errno.h>
22#include <linux/fcntl.h>
23#include <linux/stat.h>
24#include <linux/nfs_fs.h>
25#include <linux/nfs_mount.h>
26#include <linux/mm.h>
1da177e4 27#include <linux/pagemap.h>
e8edc6e0 28#include <linux/aio.h>
5a0e3ad6 29#include <linux/gfp.h>
b608b283 30#include <linux/swap.h>
1da177e4
LT
31
32#include <asm/uaccess.h>
1da177e4
LT
33
34#include "delegation.h"
94387fb1 35#include "internal.h"
91d5b470 36#include "iostat.h"
545db45f 37#include "fscache.h"
e5e94017 38#include "pnfs.h"
1da177e4
LT
39
40#define NFSDBG_FACILITY NFSDBG_FILE
41
f0f37e2f 42static const struct vm_operations_struct nfs_file_vm_ops;
94387fb1 43
92e1d5be 44const struct inode_operations nfs_file_inode_operations = {
1da177e4
LT
45 .permission = nfs_permission,
46 .getattr = nfs_getattr,
47 .setattr = nfs_setattr,
48};
49
b7fa0554 50#ifdef CONFIG_NFS_V3
92e1d5be 51const struct inode_operations nfs3_file_inode_operations = {
b7fa0554
AG
52 .permission = nfs_permission,
53 .getattr = nfs_getattr,
54 .setattr = nfs_setattr,
55 .listxattr = nfs3_listxattr,
56 .getxattr = nfs3_getxattr,
57 .setxattr = nfs3_setxattr,
58 .removexattr = nfs3_removexattr,
59};
60#endif /* CONFIG_NFS_v3 */
61
1da177e4
LT
62/* Hack for future NFS swap support */
63#ifndef IS_SWAPFILE
64# define IS_SWAPFILE(inode) (0)
65#endif
66
67static int nfs_check_flags(int flags)
68{
69 if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT))
70 return -EINVAL;
71
72 return 0;
73}
74
75/*
76 * Open file
77 */
78static int
79nfs_file_open(struct inode *inode, struct file *filp)
80{
1da177e4
LT
81 int res;
82
6da24bc9 83 dprintk("NFS: open file(%s/%s)\n",
cc0dd2d1
CL
84 filp->f_path.dentry->d_parent->d_name.name,
85 filp->f_path.dentry->d_name.name);
86
c2459dc4 87 nfs_inc_stats(inode, NFSIOS_VFSOPEN);
1da177e4
LT
88 res = nfs_check_flags(filp->f_flags);
89 if (res)
90 return res;
91
46cb650c 92 res = nfs_open(inode, filp);
1da177e4
LT
93 return res;
94}
95
96static int
97nfs_file_release(struct inode *inode, struct file *filp)
98{
6da24bc9 99 dprintk("NFS: release(%s/%s)\n",
6f276e49
RM
100 filp->f_path.dentry->d_parent->d_name.name,
101 filp->f_path.dentry->d_name.name);
6da24bc9 102
91d5b470 103 nfs_inc_stats(inode, NFSIOS_VFSRELEASE);
46cb650c 104 return nfs_release(inode, filp);
1da177e4
LT
105}
106
980802e3
TM
107/**
108 * nfs_revalidate_size - Revalidate the file size
109 * @inode - pointer to inode struct
110 * @file - pointer to struct file
111 *
112 * Revalidates the file length. This is basically a wrapper around
113 * nfs_revalidate_inode() that takes into account the fact that we may
114 * have cached writes (in which case we don't care about the server's
115 * idea of what the file length is), or O_DIRECT (in which case we
116 * shouldn't trust the cache).
117 */
118static int nfs_revalidate_file_size(struct inode *inode, struct file *filp)
119{
120 struct nfs_server *server = NFS_SERVER(inode);
121 struct nfs_inode *nfsi = NFS_I(inode);
122
d7cf8dd0
TM
123 if (nfs_have_delegated_attributes(inode))
124 goto out_noreval;
125
980802e3
TM
126 if (filp->f_flags & O_DIRECT)
127 goto force_reval;
d7cf8dd0
TM
128 if (nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
129 goto force_reval;
130 if (nfs_attribute_timeout(inode))
131 goto force_reval;
132out_noreval:
133 return 0;
980802e3
TM
134force_reval:
135 return __nfs_revalidate_inode(server, inode);
136}
137
138static loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin)
139{
6da24bc9 140 dprintk("NFS: llseek file(%s/%s, %lld, %d)\n",
b84e06c5
CL
141 filp->f_path.dentry->d_parent->d_name.name,
142 filp->f_path.dentry->d_name.name,
143 offset, origin);
144
06222e49
JB
145 /*
146 * origin == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
147 * the cached file length
148 */
6c529617 149 if (origin != SEEK_SET && origin != SEEK_CUR) {
980802e3 150 struct inode *inode = filp->f_mapping->host;
d5e66348 151
980802e3
TM
152 int retval = nfs_revalidate_file_size(inode, filp);
153 if (retval < 0)
154 return (loff_t)retval;
79835a71 155 }
d5e66348 156
79835a71 157 return generic_file_llseek(filp, offset, origin);
980802e3
TM
158}
159
1da177e4
LT
160/*
161 * Flush all dirty pages, and check for write errors.
1da177e4
LT
162 */
163static int
75e1fcc0 164nfs_file_flush(struct file *file, fl_owner_t id)
1da177e4 165{
6da24bc9
CL
166 struct dentry *dentry = file->f_path.dentry;
167 struct inode *inode = dentry->d_inode;
1da177e4 168
6da24bc9
CL
169 dprintk("NFS: flush(%s/%s)\n",
170 dentry->d_parent->d_name.name,
171 dentry->d_name.name);
1da177e4 172
c2459dc4 173 nfs_inc_stats(inode, NFSIOS_VFSFLUSH);
1da177e4
LT
174 if ((file->f_mode & FMODE_WRITE) == 0)
175 return 0;
7b159fc1 176
14546c33
TM
177 /*
178 * If we're holding a write delegation, then just start the i/o
179 * but don't wait for completion (or send a commit).
180 */
181 if (nfs_have_delegation(inode, FMODE_WRITE))
182 return filemap_fdatawrite(file->f_mapping);
183
7fe5c398 184 /* Flush writes to the server and return any errors */
af7fa165 185 return vfs_fsync(file, 0);
1da177e4
LT
186}
187
188static ssize_t
027445c3
BP
189nfs_file_read(struct kiocb *iocb, const struct iovec *iov,
190 unsigned long nr_segs, loff_t pos)
1da177e4 191{
01cce933 192 struct dentry * dentry = iocb->ki_filp->f_path.dentry;
1da177e4
LT
193 struct inode * inode = dentry->d_inode;
194 ssize_t result;
195
1da177e4 196 if (iocb->ki_filp->f_flags & O_DIRECT)
027445c3 197 return nfs_file_direct_read(iocb, iov, nr_segs, pos);
1da177e4 198
6da24bc9 199 dprintk("NFS: read(%s/%s, %lu@%lu)\n",
1da177e4 200 dentry->d_parent->d_name.name, dentry->d_name.name,
6f276e49 201 (unsigned long) iov_length(iov, nr_segs), (unsigned long) pos);
1da177e4 202
44b11874 203 result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping);
4184dcf2 204 if (!result) {
027445c3 205 result = generic_file_aio_read(iocb, iov, nr_segs, pos);
4184dcf2
CL
206 if (result > 0)
207 nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, result);
208 }
1da177e4
LT
209 return result;
210}
211
212static ssize_t
f0930fff
JA
213nfs_file_splice_read(struct file *filp, loff_t *ppos,
214 struct pipe_inode_info *pipe, size_t count,
215 unsigned int flags)
1da177e4 216{
01cce933 217 struct dentry *dentry = filp->f_path.dentry;
1da177e4
LT
218 struct inode *inode = dentry->d_inode;
219 ssize_t res;
220
6da24bc9 221 dprintk("NFS: splice_read(%s/%s, %lu@%Lu)\n",
1da177e4
LT
222 dentry->d_parent->d_name.name, dentry->d_name.name,
223 (unsigned long) count, (unsigned long long) *ppos);
224
44b11874 225 res = nfs_revalidate_mapping(inode, filp->f_mapping);
aa2f1ef1 226 if (!res) {
f0930fff 227 res = generic_file_splice_read(filp, ppos, pipe, count, flags);
aa2f1ef1
CL
228 if (res > 0)
229 nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, res);
230 }
1da177e4
LT
231 return res;
232}
233
234static int
235nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
236{
01cce933 237 struct dentry *dentry = file->f_path.dentry;
1da177e4
LT
238 struct inode *inode = dentry->d_inode;
239 int status;
240
6da24bc9 241 dprintk("NFS: mmap(%s/%s)\n",
1da177e4
LT
242 dentry->d_parent->d_name.name, dentry->d_name.name);
243
e1ebfd33
TM
244 /* Note: generic_file_mmap() returns ENOSYS on nommu systems
245 * so we call that before revalidating the mapping
246 */
247 status = generic_file_mmap(file, vma);
94387fb1
TM
248 if (!status) {
249 vma->vm_ops = &nfs_file_vm_ops;
e1ebfd33 250 status = nfs_revalidate_mapping(inode, file->f_mapping);
94387fb1 251 }
1da177e4
LT
252 return status;
253}
254
255/*
256 * Flush any dirty pages for this process, and check for write errors.
257 * The return status from this call provides a reliable indication of
258 * whether any write errors occurred for this process.
af7fa165
TM
259 *
260 * Notice that it clears the NFS_CONTEXT_ERROR_WRITE before synching to
261 * disk, but it retrieves and clears ctx->error after synching, despite
262 * the two being set at the same time in nfs_context_set_write_error().
263 * This is because the former is used to notify the _next_ call to
25985edc 264 * nfs_file_write() that a write error occurred, and hence cause it to
af7fa165 265 * fall back to doing a synchronous write.
1da177e4
LT
266 */
267static int
a5c58892 268nfs_file_fsync_commit(struct file *file, loff_t start, loff_t end, int datasync)
1da177e4 269{
7ea80859 270 struct dentry *dentry = file->f_path.dentry;
cd3758e3 271 struct nfs_open_context *ctx = nfs_file_open_context(file);
1da177e4 272 struct inode *inode = dentry->d_inode;
af7fa165
TM
273 int have_error, status;
274 int ret = 0;
275
6da24bc9 276 dprintk("NFS: fsync file(%s/%s) datasync %d\n",
54917786
CL
277 dentry->d_parent->d_name.name, dentry->d_name.name,
278 datasync);
1da177e4 279
91d5b470 280 nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
af7fa165
TM
281 have_error = test_and_clear_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
282 status = nfs_commit_inode(inode, FLUSH_SYNC);
2edb6bc3
N
283 if (status >= 0 && ret < 0)
284 status = ret;
af7fa165
TM
285 have_error |= test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
286 if (have_error)
287 ret = xchg(&ctx->error, 0);
0702099b 288 if (!ret && status < 0)
af7fa165 289 ret = status;
a5c58892
BS
290 return ret;
291}
292
293static int
294nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
295{
296 int ret;
297 struct inode *inode = file->f_path.dentry->d_inode;
298
299 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
300 mutex_lock(&inode->i_mutex);
301 ret = nfs_file_fsync_commit(file, start, end, datasync);
02c24a82 302 mutex_unlock(&inode->i_mutex);
a5c58892 303
af7fa165 304 return ret;
1da177e4
LT
305}
306
38c73044
PS
307/*
308 * Decide whether a read/modify/write cycle may be more efficient
309 * then a modify/write/read cycle when writing to a page in the
310 * page cache.
311 *
312 * The modify/write/read cycle may occur if a page is read before
313 * being completely filled by the writer. In this situation, the
314 * page must be completely written to stable storage on the server
315 * before it can be refilled by reading in the page from the server.
316 * This can lead to expensive, small, FILE_SYNC mode writes being
317 * done.
318 *
319 * It may be more efficient to read the page first if the file is
320 * open for reading in addition to writing, the page is not marked
321 * as Uptodate, it is not dirty or waiting to be committed,
322 * indicating that it was previously allocated and then modified,
323 * that there were valid bytes of data in that range of the file,
324 * and that the new data won't completely replace the old data in
325 * that range of the file.
326 */
327static int nfs_want_read_modify_write(struct file *file, struct page *page,
328 loff_t pos, unsigned len)
329{
330 unsigned int pglen = nfs_page_length(page);
331 unsigned int offset = pos & (PAGE_CACHE_SIZE - 1);
332 unsigned int end = offset + len;
333
334 if ((file->f_mode & FMODE_READ) && /* open for read? */
335 !PageUptodate(page) && /* Uptodate? */
336 !PagePrivate(page) && /* i/o request already? */
337 pglen && /* valid bytes of file? */
338 (end < pglen || offset)) /* replace all valid bytes? */
339 return 1;
340 return 0;
341}
342
1da177e4 343/*
4899f9c8
NP
344 * This does the "real" work of the write. We must allocate and lock the
345 * page to be sent back to the generic routine, which then copies the
346 * data from user space.
1da177e4
LT
347 *
348 * If the writer ends up delaying the write, the writer needs to
349 * increment the page use counts until he is done with the page.
350 */
4899f9c8
NP
351static int nfs_write_begin(struct file *file, struct address_space *mapping,
352 loff_t pos, unsigned len, unsigned flags,
353 struct page **pagep, void **fsdata)
1da177e4 354{
4899f9c8 355 int ret;
38c73044 356 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
4899f9c8 357 struct page *page;
38c73044 358 int once_thru = 0;
4899f9c8 359
b7eaefaa
CL
360 dfprintk(PAGECACHE, "NFS: write_begin(%s/%s(%ld), %u@%lld)\n",
361 file->f_path.dentry->d_parent->d_name.name,
362 file->f_path.dentry->d_name.name,
363 mapping->host->i_ino, len, (long long) pos);
364
38c73044 365start:
72cb77f4
TM
366 /*
367 * Prevent starvation issues if someone is doing a consistency
368 * sync-to-disk
369 */
370 ret = wait_on_bit(&NFS_I(mapping->host)->flags, NFS_INO_FLUSHING,
371 nfs_wait_bit_killable, TASK_KILLABLE);
372 if (ret)
373 return ret;
374
54566b2c 375 page = grab_cache_page_write_begin(mapping, index, flags);
4899f9c8
NP
376 if (!page)
377 return -ENOMEM;
378 *pagep = page;
379
380 ret = nfs_flush_incompatible(file, page);
381 if (ret) {
382 unlock_page(page);
383 page_cache_release(page);
38c73044
PS
384 } else if (!once_thru &&
385 nfs_want_read_modify_write(file, page, pos, len)) {
386 once_thru = 1;
387 ret = nfs_readpage(file, page);
388 page_cache_release(page);
389 if (!ret)
390 goto start;
4899f9c8
NP
391 }
392 return ret;
1da177e4
LT
393}
394
4899f9c8
NP
395static int nfs_write_end(struct file *file, struct address_space *mapping,
396 loff_t pos, unsigned len, unsigned copied,
397 struct page *page, void *fsdata)
1da177e4 398{
4899f9c8
NP
399 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
400 int status;
1da177e4 401
b7eaefaa
CL
402 dfprintk(PAGECACHE, "NFS: write_end(%s/%s(%ld), %u@%lld)\n",
403 file->f_path.dentry->d_parent->d_name.name,
404 file->f_path.dentry->d_name.name,
405 mapping->host->i_ino, len, (long long) pos);
406
efc91ed0
TM
407 /*
408 * Zero any uninitialised parts of the page, and then mark the page
409 * as up to date if it turns out that we're extending the file.
410 */
411 if (!PageUptodate(page)) {
412 unsigned pglen = nfs_page_length(page);
413 unsigned end = offset + len;
414
415 if (pglen == 0) {
416 zero_user_segments(page, 0, offset,
417 end, PAGE_CACHE_SIZE);
418 SetPageUptodate(page);
419 } else if (end >= pglen) {
420 zero_user_segment(page, end, PAGE_CACHE_SIZE);
421 if (offset == 0)
422 SetPageUptodate(page);
423 } else
424 zero_user_segment(page, pglen, PAGE_CACHE_SIZE);
425 }
426
4899f9c8 427 status = nfs_updatepage(file, page, offset, copied);
4899f9c8
NP
428
429 unlock_page(page);
430 page_cache_release(page);
431
3d509e54
CL
432 if (status < 0)
433 return status;
2701d086 434 NFS_I(mapping->host)->write_io += copied;
3d509e54 435 return copied;
1da177e4
LT
436}
437
6b9b3514
DH
438/*
439 * Partially or wholly invalidate a page
440 * - Release the private state associated with a page if undergoing complete
441 * page invalidation
545db45f 442 * - Called if either PG_private or PG_fscache is set on the page
6b9b3514
DH
443 * - Caller holds page lock
444 */
2ff28e22 445static void nfs_invalidate_page(struct page *page, unsigned long offset)
cd52ed35 446{
b7eaefaa
CL
447 dfprintk(PAGECACHE, "NFS: invalidate_page(%p, %lu)\n", page, offset);
448
1c75950b
TM
449 if (offset != 0)
450 return;
d2ccddf0 451 /* Cancel any unstarted writes on this page */
1b3b4a1a 452 nfs_wb_page_cancel(page->mapping->host, page);
545db45f
DH
453
454 nfs_fscache_invalidate_page(page, page->mapping->host);
cd52ed35
TM
455}
456
6b9b3514
DH
457/*
458 * Attempt to release the private state associated with a page
545db45f 459 * - Called if either PG_private or PG_fscache is set on the page
6b9b3514
DH
460 * - Caller holds page lock
461 * - Return true (may release page) or false (may not)
462 */
cd52ed35
TM
463static int nfs_release_page(struct page *page, gfp_t gfp)
464{
b608b283
TM
465 struct address_space *mapping = page->mapping;
466
b7eaefaa
CL
467 dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page);
468
d812e575 469 /* Only do I/O if gfp is a superset of GFP_KERNEL */
b608b283
TM
470 if (mapping && (gfp & GFP_KERNEL) == GFP_KERNEL) {
471 int how = FLUSH_SYNC;
472
473 /* Don't let kswapd deadlock waiting for OOM RPC calls */
474 if (current_is_kswapd())
475 how = 0;
476 nfs_commit_inode(mapping->host, how);
477 }
e3db7691 478 /* If PagePrivate() is set, then the page is not freeable */
545db45f
DH
479 if (PagePrivate(page))
480 return 0;
481 return nfs_fscache_release_page(page, gfp);
e3db7691
TM
482}
483
6b9b3514
DH
484/*
485 * Attempt to clear the private state associated with a page when an error
486 * occurs that requires the cached contents of an inode to be written back or
487 * destroyed
545db45f 488 * - Called if either PG_private or fscache is set on the page
6b9b3514
DH
489 * - Caller holds page lock
490 * - Return 0 if successful, -error otherwise
491 */
e3db7691
TM
492static int nfs_launder_page(struct page *page)
493{
b7eaefaa 494 struct inode *inode = page->mapping->host;
545db45f 495 struct nfs_inode *nfsi = NFS_I(inode);
b7eaefaa
CL
496
497 dfprintk(PAGECACHE, "NFS: launder_page(%ld, %llu)\n",
498 inode->i_ino, (long long)page_offset(page));
499
545db45f 500 nfs_fscache_wait_on_page_write(nfsi, page);
b7eaefaa 501 return nfs_wb_page(inode, page);
cd52ed35
TM
502}
503
f5e54d6e 504const struct address_space_operations nfs_file_aops = {
1da177e4
LT
505 .readpage = nfs_readpage,
506 .readpages = nfs_readpages,
9cccef95 507 .set_page_dirty = __set_page_dirty_nobuffers,
1da177e4
LT
508 .writepage = nfs_writepage,
509 .writepages = nfs_writepages,
4899f9c8
NP
510 .write_begin = nfs_write_begin,
511 .write_end = nfs_write_end,
cd52ed35
TM
512 .invalidatepage = nfs_invalidate_page,
513 .releasepage = nfs_release_page,
1da177e4 514 .direct_IO = nfs_direct_IO,
074cc1de 515 .migratepage = nfs_migrate_page,
e3db7691 516 .launder_page = nfs_launder_page,
f590f333 517 .error_remove_page = generic_error_remove_page,
1da177e4
LT
518};
519
6b9b3514
DH
520/*
521 * Notification that a PTE pointing to an NFS page is about to be made
522 * writable, implying that someone is about to modify the page through a
523 * shared-writable mapping
524 */
c2ec175c 525static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
94387fb1 526{
c2ec175c 527 struct page *page = vmf->page;
94387fb1 528 struct file *filp = vma->vm_file;
b7eaefaa 529 struct dentry *dentry = filp->f_path.dentry;
94387fb1 530 unsigned pagelen;
bc4866b6 531 int ret = VM_FAULT_NOPAGE;
4899f9c8 532 struct address_space *mapping;
94387fb1 533
b7eaefaa
CL
534 dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%s/%s(%ld), offset %lld)\n",
535 dentry->d_parent->d_name.name, dentry->d_name.name,
536 filp->f_mapping->host->i_ino,
537 (long long)page_offset(page));
538
545db45f
DH
539 /* make sure the cache has finished storing the page */
540 nfs_fscache_wait_on_page_write(NFS_I(dentry->d_inode), page);
541
94387fb1 542 lock_page(page);
4899f9c8 543 mapping = page->mapping;
b7eaefaa 544 if (mapping != dentry->d_inode->i_mapping)
8b1f9ee5
TM
545 goto out_unlock;
546
2aeb98f4
TM
547 wait_on_page_writeback(page);
548
94387fb1 549 pagelen = nfs_page_length(page);
8b1f9ee5
TM
550 if (pagelen == 0)
551 goto out_unlock;
4899f9c8 552
bc4866b6
TM
553 ret = VM_FAULT_LOCKED;
554 if (nfs_flush_incompatible(filp, page) == 0 &&
555 nfs_updatepage(filp, page, 0, pagelen) == 0)
556 goto out;
8b1f9ee5 557
bc4866b6 558 ret = VM_FAULT_SIGBUS;
8b1f9ee5
TM
559out_unlock:
560 unlock_page(page);
bc4866b6
TM
561out:
562 return ret;
94387fb1
TM
563}
564
f0f37e2f 565static const struct vm_operations_struct nfs_file_vm_ops = {
94387fb1
TM
566 .fault = filemap_fault,
567 .page_mkwrite = nfs_vm_page_mkwrite,
568};
569
7b159fc1
TM
570static int nfs_need_sync_write(struct file *filp, struct inode *inode)
571{
572 struct nfs_open_context *ctx;
573
6b2f3d1f 574 if (IS_SYNC(inode) || (filp->f_flags & O_DSYNC))
7b159fc1 575 return 1;
cd3758e3 576 ctx = nfs_file_open_context(filp);
7b159fc1
TM
577 if (test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags))
578 return 1;
579 return 0;
580}
581
027445c3
BP
582static ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov,
583 unsigned long nr_segs, loff_t pos)
1da177e4 584{
01cce933 585 struct dentry * dentry = iocb->ki_filp->f_path.dentry;
1da177e4 586 struct inode * inode = dentry->d_inode;
7e381172 587 unsigned long written = 0;
1da177e4 588 ssize_t result;
027445c3 589 size_t count = iov_length(iov, nr_segs);
1da177e4 590
1da177e4 591 if (iocb->ki_filp->f_flags & O_DIRECT)
027445c3 592 return nfs_file_direct_write(iocb, iov, nr_segs, pos);
1da177e4 593
6da24bc9 594 dprintk("NFS: write(%s/%s, %lu@%Ld)\n",
1da177e4 595 dentry->d_parent->d_name.name, dentry->d_name.name,
6da24bc9 596 (unsigned long) count, (long long) pos);
1da177e4
LT
597
598 result = -EBUSY;
599 if (IS_SWAPFILE(inode))
600 goto out_swapfile;
7d52e862
TM
601 /*
602 * O_APPEND implies that we must revalidate the file length.
603 */
604 if (iocb->ki_filp->f_flags & O_APPEND) {
605 result = nfs_revalidate_file_size(inode, iocb->ki_filp);
606 if (result)
607 goto out;
fe51beec 608 }
1da177e4
LT
609
610 result = count;
611 if (!count)
612 goto out;
613
027445c3 614 result = generic_file_aio_write(iocb, iov, nr_segs, pos);
7e381172
CL
615 if (result > 0)
616 written = result;
617
6b2f3d1f 618 /* Return error values for O_DSYNC and IS_SYNC() */
7b159fc1 619 if (result >= 0 && nfs_need_sync_write(iocb->ki_filp, inode)) {
af7fa165 620 int err = vfs_fsync(iocb->ki_filp, 0);
200baa21
TM
621 if (err < 0)
622 result = err;
623 }
7e381172
CL
624 if (result > 0)
625 nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
1da177e4
LT
626out:
627 return result;
628
629out_swapfile:
630 printk(KERN_INFO "NFS: attempt to write to active swap file!\n");
631 goto out;
632}
633
bf40d343
SJ
634static ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
635 struct file *filp, loff_t *ppos,
636 size_t count, unsigned int flags)
637{
638 struct dentry *dentry = filp->f_path.dentry;
639 struct inode *inode = dentry->d_inode;
7e381172 640 unsigned long written = 0;
bf40d343
SJ
641 ssize_t ret;
642
643 dprintk("NFS splice_write(%s/%s, %lu@%llu)\n",
644 dentry->d_parent->d_name.name, dentry->d_name.name,
645 (unsigned long) count, (unsigned long long) *ppos);
646
647 /*
648 * The combination of splice and an O_APPEND destination is disallowed.
649 */
650
bf40d343 651 ret = generic_file_splice_write(pipe, filp, ppos, count, flags);
7e381172
CL
652 if (ret > 0)
653 written = ret;
654
bf40d343 655 if (ret >= 0 && nfs_need_sync_write(filp, inode)) {
af7fa165 656 int err = vfs_fsync(filp, 0);
bf40d343
SJ
657 if (err < 0)
658 ret = err;
659 }
7e381172
CL
660 if (ret > 0)
661 nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
bf40d343
SJ
662 return ret;
663}
664
5eebde23
SJ
665static int
666do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
1da177e4
LT
667{
668 struct inode *inode = filp->f_mapping->host;
669 int status = 0;
21ac19d4 670 unsigned int saved_type = fl->fl_type;
1da177e4 671
039c4d7a 672 /* Try local locking first */
6d34ac19
BF
673 posix_test_lock(filp, fl);
674 if (fl->fl_type != F_UNLCK) {
675 /* found a conflict */
039c4d7a 676 goto out;
1da177e4 677 }
21ac19d4 678 fl->fl_type = saved_type;
039c4d7a
TM
679
680 if (nfs_have_delegation(inode, FMODE_READ))
681 goto out_noconflict;
682
5eebde23 683 if (is_local)
039c4d7a
TM
684 goto out_noconflict;
685
686 status = NFS_PROTO(inode)->lock(filp, cmd, fl);
687out:
1da177e4 688 return status;
039c4d7a
TM
689out_noconflict:
690 fl->fl_type = F_UNLCK;
691 goto out;
1da177e4
LT
692}
693
694static int do_vfs_lock(struct file *file, struct file_lock *fl)
695{
696 int res = 0;
697 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
698 case FL_POSIX:
699 res = posix_lock_file_wait(file, fl);
700 break;
701 case FL_FLOCK:
702 res = flock_lock_file_wait(file, fl);
703 break;
704 default:
705 BUG();
706 }
1da177e4
LT
707 return res;
708}
709
5eebde23
SJ
710static int
711do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
1da177e4
LT
712{
713 struct inode *inode = filp->f_mapping->host;
1da177e4
LT
714 int status;
715
1da177e4
LT
716 /*
717 * Flush all pending writes before doing anything
718 * with locks..
719 */
29884df0 720 nfs_sync_mapping(filp->f_mapping);
1da177e4
LT
721
722 /* NOTE: special case
723 * If we're signalled while cleaning up locks on process exit, we
724 * still need to complete the unlock.
725 */
5eebde23
SJ
726 /*
727 * Use local locking if mounted with "-onolock" or with appropriate
728 * "-olocal_lock="
729 */
730 if (!is_local)
1da177e4
LT
731 status = NFS_PROTO(inode)->lock(filp, cmd, fl);
732 else
733 status = do_vfs_lock(filp, fl);
1da177e4
LT
734 return status;
735}
736
6b96724e
RL
737static int
738is_time_granular(struct timespec *ts) {
739 return ((ts->tv_sec == 0) && (ts->tv_nsec <= 1000));
740}
741
5eebde23
SJ
742static int
743do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
1da177e4
LT
744{
745 struct inode *inode = filp->f_mapping->host;
1da177e4
LT
746 int status;
747
1da177e4
LT
748 /*
749 * Flush all pending writes before doing anything
750 * with locks..
751 */
29884df0
TM
752 status = nfs_sync_mapping(filp->f_mapping);
753 if (status != 0)
1da177e4
LT
754 goto out;
755
5eebde23
SJ
756 /*
757 * Use local locking if mounted with "-onolock" or with appropriate
758 * "-olocal_lock="
759 */
760 if (!is_local)
1da177e4 761 status = NFS_PROTO(inode)->lock(filp, cmd, fl);
c4d7c402 762 else
1da177e4 763 status = do_vfs_lock(filp, fl);
1da177e4
LT
764 if (status < 0)
765 goto out;
6b96724e 766
1da177e4 767 /*
6b96724e
RL
768 * Revalidate the cache if the server has time stamps granular
769 * enough to detect subsecond changes. Otherwise, clear the
770 * cache to prevent missing any changes.
771 *
1da177e4
LT
772 * This makes locking act as a cache coherency point.
773 */
29884df0 774 nfs_sync_mapping(filp->f_mapping);
6b96724e
RL
775 if (!nfs_have_delegation(inode, FMODE_READ)) {
776 if (is_time_granular(&NFS_SERVER(inode)->time_delta))
777 __nfs_revalidate_inode(NFS_SERVER(inode), inode);
778 else
779 nfs_zap_caches(inode);
780 }
1da177e4 781out:
1da177e4
LT
782 return status;
783}
784
785/*
786 * Lock a (portion of) a file
787 */
788static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
789{
6da24bc9 790 struct inode *inode = filp->f_mapping->host;
2116271a 791 int ret = -ENOLCK;
5eebde23 792 int is_local = 0;
1da177e4 793
6da24bc9
CL
794 dprintk("NFS: lock(%s/%s, t=%x, fl=%x, r=%lld:%lld)\n",
795 filp->f_path.dentry->d_parent->d_name.name,
796 filp->f_path.dentry->d_name.name,
1da177e4
LT
797 fl->fl_type, fl->fl_flags,
798 (long long)fl->fl_start, (long long)fl->fl_end);
6da24bc9 799
91d5b470 800 nfs_inc_stats(inode, NFSIOS_VFSLOCK);
1da177e4
LT
801
802 /* No mandatory locks over NFS */
dfad9441 803 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
2116271a
TM
804 goto out_err;
805
5eebde23
SJ
806 if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL)
807 is_local = 1;
808
2116271a
TM
809 if (NFS_PROTO(inode)->lock_check_bounds != NULL) {
810 ret = NFS_PROTO(inode)->lock_check_bounds(fl);
811 if (ret < 0)
812 goto out_err;
813 }
1da177e4
LT
814
815 if (IS_GETLK(cmd))
5eebde23 816 ret = do_getlk(filp, cmd, fl, is_local);
2116271a 817 else if (fl->fl_type == F_UNLCK)
5eebde23 818 ret = do_unlk(filp, cmd, fl, is_local);
2116271a 819 else
5eebde23 820 ret = do_setlk(filp, cmd, fl, is_local);
2116271a
TM
821out_err:
822 return ret;
1da177e4
LT
823}
824
825/*
826 * Lock a (portion of) a file
827 */
828static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
829{
5eebde23
SJ
830 struct inode *inode = filp->f_mapping->host;
831 int is_local = 0;
832
6da24bc9
CL
833 dprintk("NFS: flock(%s/%s, t=%x, fl=%x)\n",
834 filp->f_path.dentry->d_parent->d_name.name,
835 filp->f_path.dentry->d_name.name,
1da177e4
LT
836 fl->fl_type, fl->fl_flags);
837
1da177e4
LT
838 if (!(fl->fl_flags & FL_FLOCK))
839 return -ENOLCK;
840
5eebde23
SJ
841 if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK)
842 is_local = 1;
843
1da177e4
LT
844 /* We're simulating flock() locks using posix locks on the server */
845 fl->fl_owner = (fl_owner_t)filp;
846 fl->fl_start = 0;
847 fl->fl_end = OFFSET_MAX;
848
849 if (fl->fl_type == F_UNLCK)
5eebde23
SJ
850 return do_unlk(filp, cmd, fl, is_local);
851 return do_setlk(filp, cmd, fl, is_local);
1da177e4 852}
370f6599 853
6da24bc9
CL
854/*
855 * There is no protocol support for leases, so we have no way to implement
856 * them correctly in the face of opens by other clients.
857 */
370f6599
BF
858static int nfs_setlease(struct file *file, long arg, struct file_lock **fl)
859{
6da24bc9
CL
860 dprintk("NFS: setlease(%s/%s, arg=%ld)\n",
861 file->f_path.dentry->d_parent->d_name.name,
862 file->f_path.dentry->d_name.name, arg);
370f6599
BF
863 return -EINVAL;
864}
1788ea6e 865
0486958f
JL
866const struct file_operations nfs_file_operations = {
867 .llseek = nfs_file_llseek,
868 .read = do_sync_read,
869 .write = do_sync_write,
870 .aio_read = nfs_file_read,
871 .aio_write = nfs_file_write,
872 .mmap = nfs_file_mmap,
873 .open = nfs_file_open,
874 .flush = nfs_file_flush,
875 .release = nfs_file_release,
876 .fsync = nfs_file_fsync,
877 .lock = nfs_lock,
878 .flock = nfs_flock,
879 .splice_read = nfs_file_splice_read,
880 .splice_write = nfs_file_splice_write,
881 .check_flags = nfs_check_flags,
882 .setlease = nfs_setlease,
883};
884
1788ea6e
JL
885#ifdef CONFIG_NFS_V4
886static int
887nfs4_file_open(struct inode *inode, struct file *filp)
888{
0ef97dcf
MS
889 struct nfs_open_context *ctx;
890 struct dentry *dentry = filp->f_path.dentry;
891 struct dentry *parent = NULL;
892 struct inode *dir;
893 unsigned openflags = filp->f_flags;
894 struct iattr attr;
895 int err;
896
897 BUG_ON(inode != dentry->d_inode);
1788ea6e 898 /*
0ef97dcf
MS
899 * If no cached dentry exists or if it's negative, NFSv4 handled the
900 * opens in ->lookup() or ->create().
901 *
902 * We only get this far for a cached positive dentry. We skipped
903 * revalidation, so handle it here by dropping the dentry and returning
904 * -EOPENSTALE. The VFS will retry the lookup/create/open.
1788ea6e 905 */
0ef97dcf
MS
906
907 dprintk("NFS: open file(%s/%s)\n",
908 dentry->d_parent->d_name.name,
909 dentry->d_name.name);
910
911 if ((openflags & O_ACCMODE) == 3)
912 openflags--;
913
914 /* We can't create new files here */
915 openflags &= ~(O_CREAT|O_EXCL);
916
917 parent = dget_parent(dentry);
918 dir = parent->d_inode;
919
920 ctx = alloc_nfs_open_context(filp->f_path.dentry, filp->f_mode);
921 err = PTR_ERR(ctx);
922 if (IS_ERR(ctx))
923 goto out;
924
925 attr.ia_valid = ATTR_OPEN;
926 if (openflags & O_TRUNC) {
927 attr.ia_valid |= ATTR_SIZE;
928 attr.ia_size = 0;
929 nfs_wb_all(inode);
930 }
931
932 inode = NFS_PROTO(dir)->open_context(dir, ctx, openflags, &attr);
933 if (IS_ERR(inode)) {
934 err = PTR_ERR(inode);
935 switch (err) {
936 case -EPERM:
937 case -EACCES:
938 case -EDQUOT:
939 case -ENOSPC:
940 case -EROFS:
941 goto out_put_ctx;
942 default:
943 goto out_drop;
944 }
945 }
946 iput(inode);
947 if (inode != dentry->d_inode)
948 goto out_drop;
949
950 nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
951 nfs_file_set_open_context(filp, ctx);
952 err = 0;
953
954out_put_ctx:
955 put_nfs_open_context(ctx);
956out:
957 dput(parent);
958 return err;
959
960out_drop:
961 d_drop(dentry);
962 err = -EOPENSTALE;
963 goto out_put_ctx;
1788ea6e
JL
964}
965
a5c58892
BS
966static int
967nfs4_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
968{
969 int ret;
970 struct inode *inode = file->f_path.dentry->d_inode;
971
972 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
973 mutex_lock(&inode->i_mutex);
974 ret = nfs_file_fsync_commit(file, start, end, datasync);
975 if (!ret && !datasync)
976 /* application has asked for meta-data sync */
977 ret = pnfs_layoutcommit_inode(inode, true);
978 mutex_unlock(&inode->i_mutex);
979
980 return ret;
981}
982
1788ea6e
JL
983const struct file_operations nfs4_file_operations = {
984 .llseek = nfs_file_llseek,
985 .read = do_sync_read,
986 .write = do_sync_write,
987 .aio_read = nfs_file_read,
988 .aio_write = nfs_file_write,
989 .mmap = nfs_file_mmap,
990 .open = nfs4_file_open,
991 .flush = nfs_file_flush,
992 .release = nfs_file_release,
a5c58892 993 .fsync = nfs4_file_fsync,
1788ea6e
JL
994 .lock = nfs_lock,
995 .flock = nfs_flock,
996 .splice_read = nfs_file_splice_read,
997 .splice_write = nfs_file_splice_write,
998 .check_flags = nfs_check_flags,
999 .setlease = nfs_setlease,
1000};
1001#endif /* CONFIG_NFS_V4 */