blob: 1e6bfdbc1aff4403a194798d3c3928993948710d [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Bryan Schumakerddda8e02012-07-30 16:05:23 -040019#include <linux/module.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070020#include <linux/time.h>
21#include <linux/kernel.h>
22#include <linux/errno.h>
23#include <linux/fcntl.h>
24#include <linux/stat.h>
25#include <linux/nfs_fs.h>
26#include <linux/nfs_mount.h>
27#include <linux/mm.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/pagemap.h>
Alexey Dobriyane8edc6e2007-05-21 01:22:52 +040029#include <linux/aio.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090030#include <linux/gfp.h>
Trond Myklebustb608b282010-07-30 15:31:54 -040031#include <linux/swap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032
33#include <asm/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
35#include "delegation.h"
Trond Myklebust94387fb2007-07-22 17:09:05 -040036#include "internal.h"
Chuck Lever91d5b472006-03-20 13:44:14 -050037#include "iostat.h"
David Howells545db452009-04-03 16:42:44 +010038#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070039
Trond Myklebustf4ce1292013-08-19 18:59:33 -040040#include "nfstrace.h"
41
Linus Torvalds1da177e2005-04-16 15:20:36 -070042#define NFSDBG_FACILITY NFSDBG_FILE
43
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +040044static const struct vm_operations_struct nfs_file_vm_ops;
Trond Myklebust94387fb2007-07-22 17:09:05 -040045
Linus Torvalds1da177e2005-04-16 15:20:36 -070046/* Hack for future NFS swap support */
47#ifndef IS_SWAPFILE
48# define IS_SWAPFILE(inode) (0)
49#endif
50
Bryan Schumakerce4ef7c2012-07-16 16:39:15 -040051int nfs_check_flags(int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -070052{
53 if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT))
54 return -EINVAL;
55
56 return 0;
57}
Bryan Schumaker89d77c82012-07-30 16:05:25 -040058EXPORT_SYMBOL_GPL(nfs_check_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -070059
60/*
61 * Open file
62 */
63static int
64nfs_file_open(struct inode *inode, struct file *filp)
65{
Linus Torvalds1da177e2005-04-16 15:20:36 -070066 int res;
67
Chuck Lever6da24bc2008-06-11 17:55:58 -040068 dprintk("NFS: open file(%s/%s)\n",
Chuck Levercc0dd2d2008-06-11 17:55:42 -040069 filp->f_path.dentry->d_parent->d_name.name,
70 filp->f_path.dentry->d_name.name);
71
Chuck Leverc2459dc2010-02-01 14:17:14 -050072 nfs_inc_stats(inode, NFSIOS_VFSOPEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073 res = nfs_check_flags(filp->f_flags);
74 if (res)
75 return res;
76
Trond Myklebust46cb6502008-06-11 16:32:46 -040077 res = nfs_open(inode, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 return res;
79}
80
Bryan Schumakerce4ef7c2012-07-16 16:39:15 -040081int
Linus Torvalds1da177e2005-04-16 15:20:36 -070082nfs_file_release(struct inode *inode, struct file *filp)
83{
Chuck Lever6da24bc2008-06-11 17:55:58 -040084 dprintk("NFS: release(%s/%s)\n",
Rakib Mullick6f276e42011-11-01 12:16:15 +060085 filp->f_path.dentry->d_parent->d_name.name,
86 filp->f_path.dentry->d_name.name);
Chuck Lever6da24bc2008-06-11 17:55:58 -040087
Chuck Lever91d5b472006-03-20 13:44:14 -050088 nfs_inc_stats(inode, NFSIOS_VFSRELEASE);
Trond Myklebust46cb6502008-06-11 16:32:46 -040089 return nfs_release(inode, filp);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090}
Bryan Schumaker89d77c82012-07-30 16:05:25 -040091EXPORT_SYMBOL_GPL(nfs_file_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092
Trond Myklebust980802e2005-06-13 11:14:01 -040093/**
94 * nfs_revalidate_size - Revalidate the file size
95 * @inode - pointer to inode struct
96 * @file - pointer to struct file
97 *
98 * Revalidates the file length. This is basically a wrapper around
99 * nfs_revalidate_inode() that takes into account the fact that we may
100 * have cached writes (in which case we don't care about the server's
101 * idea of what the file length is), or O_DIRECT (in which case we
102 * shouldn't trust the cache).
103 */
104static int nfs_revalidate_file_size(struct inode *inode, struct file *filp)
105{
106 struct nfs_server *server = NFS_SERVER(inode);
107 struct nfs_inode *nfsi = NFS_I(inode);
108
Trond Myklebustd7cf8dd2010-04-16 16:42:46 -0400109 if (nfs_have_delegated_attributes(inode))
110 goto out_noreval;
111
Trond Myklebust980802e2005-06-13 11:14:01 -0400112 if (filp->f_flags & O_DIRECT)
113 goto force_reval;
Trond Myklebustd7cf8dd2010-04-16 16:42:46 -0400114 if (nfsi->cache_validity & NFS_INO_REVAL_PAGECACHE)
115 goto force_reval;
116 if (nfs_attribute_timeout(inode))
117 goto force_reval;
118out_noreval:
119 return 0;
Trond Myklebust980802e2005-06-13 11:14:01 -0400120force_reval:
121 return __nfs_revalidate_inode(server, inode);
122}
123
Andrew Morton965c8e52012-12-17 15:59:39 -0800124loff_t nfs_file_llseek(struct file *filp, loff_t offset, int whence)
Trond Myklebust980802e2005-06-13 11:14:01 -0400125{
Chuck Lever6da24bc2008-06-11 17:55:58 -0400126 dprintk("NFS: llseek file(%s/%s, %lld, %d)\n",
Chuck Leverb84e06c2008-06-11 17:55:34 -0400127 filp->f_path.dentry->d_parent->d_name.name,
128 filp->f_path.dentry->d_name.name,
Andrew Morton965c8e52012-12-17 15:59:39 -0800129 offset, whence);
Chuck Leverb84e06c2008-06-11 17:55:34 -0400130
Josef Bacik06222e42011-07-18 13:21:38 -0400131 /*
Andrew Morton965c8e52012-12-17 15:59:39 -0800132 * whence == SEEK_END || SEEK_DATA || SEEK_HOLE => we must revalidate
Josef Bacik06222e42011-07-18 13:21:38 -0400133 * the cached file length
134 */
Andrew Morton965c8e52012-12-17 15:59:39 -0800135 if (whence != SEEK_SET && whence != SEEK_CUR) {
Trond Myklebust980802e2005-06-13 11:14:01 -0400136 struct inode *inode = filp->f_mapping->host;
Trond Myklebustd5e66342008-09-23 17:28:35 -0400137
Trond Myklebust980802e2005-06-13 11:14:01 -0400138 int retval = nfs_revalidate_file_size(inode, filp);
139 if (retval < 0)
140 return (loff_t)retval;
Andi Kleen79835a712011-09-15 16:06:52 -0700141 }
Trond Myklebustd5e66342008-09-23 17:28:35 -0400142
Andrew Morton965c8e52012-12-17 15:59:39 -0800143 return generic_file_llseek(filp, offset, whence);
Trond Myklebust980802e2005-06-13 11:14:01 -0400144}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400145EXPORT_SYMBOL_GPL(nfs_file_llseek);
Trond Myklebust980802e2005-06-13 11:14:01 -0400146
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147/*
148 * Flush all dirty pages, and check for write errors.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 */
Bryan Schumakerce4ef7c2012-07-16 16:39:15 -0400150int
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -0700151nfs_file_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152{
Chuck Lever6da24bc2008-06-11 17:55:58 -0400153 struct dentry *dentry = file->f_path.dentry;
154 struct inode *inode = dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
Chuck Lever6da24bc2008-06-11 17:55:58 -0400156 dprintk("NFS: flush(%s/%s)\n",
157 dentry->d_parent->d_name.name,
158 dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
Chuck Leverc2459dc2010-02-01 14:17:14 -0500160 nfs_inc_stats(inode, NFSIOS_VFSFLUSH);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161 if ((file->f_mode & FMODE_WRITE) == 0)
162 return 0;
Trond Myklebust7b159fc2007-07-25 14:09:54 -0400163
Trond Myklebust14546c32012-05-06 19:10:59 -0400164 /*
165 * If we're holding a write delegation, then just start the i/o
166 * but don't wait for completion (or send a commit).
167 */
Bryan Schumaker011e2a72012-06-20 15:53:43 -0400168 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_WRITE))
Trond Myklebust14546c32012-05-06 19:10:59 -0400169 return filemap_fdatawrite(file->f_mapping);
170
Trond Myklebust7fe5c392009-03-19 15:35:50 -0400171 /* Flush writes to the server and return any errors */
Trond Myklebustaf7fa162010-07-31 14:29:06 -0400172 return vfs_fsync(file, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400174EXPORT_SYMBOL_GPL(nfs_file_flush);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175
Bryan Schumakerce4ef7c2012-07-16 16:39:15 -0400176ssize_t
Badari Pulavarty027445c2006-09-30 23:28:46 -0700177nfs_file_read(struct kiocb *iocb, const struct iovec *iov,
178 unsigned long nr_segs, loff_t pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179{
Josef "Jeff" Sipek01cce932006-12-08 02:36:40 -0800180 struct dentry * dentry = iocb->ki_filp->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181 struct inode * inode = dentry->d_inode;
182 ssize_t result;
183
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 if (iocb->ki_filp->f_flags & O_DIRECT)
Mel Gormana564b8f2012-07-31 16:45:12 -0700185 return nfs_file_direct_read(iocb, iov, nr_segs, pos, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186
Chuck Lever6da24bc2008-06-11 17:55:58 -0400187 dprintk("NFS: read(%s/%s, %lu@%lu)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 dentry->d_parent->d_name.name, dentry->d_name.name,
Rakib Mullick6f276e42011-11-01 12:16:15 +0600189 (unsigned long) iov_length(iov, nr_segs), (unsigned long) pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190
Trond Myklebust44b11872006-05-25 01:40:59 -0400191 result = nfs_revalidate_mapping(inode, iocb->ki_filp->f_mapping);
Chuck Lever4184dcf2010-02-01 14:17:23 -0500192 if (!result) {
Badari Pulavarty027445c2006-09-30 23:28:46 -0700193 result = generic_file_aio_read(iocb, iov, nr_segs, pos);
Chuck Lever4184dcf2010-02-01 14:17:23 -0500194 if (result > 0)
195 nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, result);
196 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197 return result;
198}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400199EXPORT_SYMBOL_GPL(nfs_file_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200
Bryan Schumakerce4ef7c2012-07-16 16:39:15 -0400201ssize_t
Jens Axboef0930ff2007-06-01 11:51:43 +0200202nfs_file_splice_read(struct file *filp, loff_t *ppos,
203 struct pipe_inode_info *pipe, size_t count,
204 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205{
Josef "Jeff" Sipek01cce932006-12-08 02:36:40 -0800206 struct dentry *dentry = filp->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 struct inode *inode = dentry->d_inode;
208 ssize_t res;
209
Chuck Lever6da24bc2008-06-11 17:55:58 -0400210 dprintk("NFS: splice_read(%s/%s, %lu@%Lu)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 dentry->d_parent->d_name.name, dentry->d_name.name,
212 (unsigned long) count, (unsigned long long) *ppos);
213
Trond Myklebust44b11872006-05-25 01:40:59 -0400214 res = nfs_revalidate_mapping(inode, filp->f_mapping);
Chuck Leveraa2f1ef2010-02-01 14:17:32 -0500215 if (!res) {
Jens Axboef0930ff2007-06-01 11:51:43 +0200216 res = generic_file_splice_read(filp, ppos, pipe, count, flags);
Chuck Leveraa2f1ef2010-02-01 14:17:32 -0500217 if (res > 0)
218 nfs_add_stats(inode, NFSIOS_NORMALREADBYTES, res);
219 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 return res;
221}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400222EXPORT_SYMBOL_GPL(nfs_file_splice_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223
Bryan Schumakerce4ef7c2012-07-16 16:39:15 -0400224int
Linus Torvalds1da177e2005-04-16 15:20:36 -0700225nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
226{
Josef "Jeff" Sipek01cce932006-12-08 02:36:40 -0800227 struct dentry *dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 struct inode *inode = dentry->d_inode;
229 int status;
230
Chuck Lever6da24bc2008-06-11 17:55:58 -0400231 dprintk("NFS: mmap(%s/%s)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 dentry->d_parent->d_name.name, dentry->d_name.name);
233
Trond Myklebuste1ebfd32009-03-11 14:37:54 -0400234 /* Note: generic_file_mmap() returns ENOSYS on nommu systems
235 * so we call that before revalidating the mapping
236 */
237 status = generic_file_mmap(file, vma);
Trond Myklebust94387fb2007-07-22 17:09:05 -0400238 if (!status) {
239 vma->vm_ops = &nfs_file_vm_ops;
Trond Myklebuste1ebfd32009-03-11 14:37:54 -0400240 status = nfs_revalidate_mapping(inode, file->f_mapping);
Trond Myklebust94387fb2007-07-22 17:09:05 -0400241 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242 return status;
243}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400244EXPORT_SYMBOL_GPL(nfs_file_mmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245
246/*
247 * Flush any dirty pages for this process, and check for write errors.
248 * The return status from this call provides a reliable indication of
249 * whether any write errors occurred for this process.
Trond Myklebustaf7fa162010-07-31 14:29:06 -0400250 *
251 * Notice that it clears the NFS_CONTEXT_ERROR_WRITE before synching to
252 * disk, but it retrieves and clears ctx->error after synching, despite
253 * the two being set at the same time in nfs_context_set_write_error().
254 * This is because the former is used to notify the _next_ call to
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300255 * nfs_file_write() that a write error occurred, and hence cause it to
Trond Myklebustaf7fa162010-07-31 14:29:06 -0400256 * fall back to doing a synchronous write.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 */
Bryan Schumakerce4ef7c2012-07-16 16:39:15 -0400258int
Bryan Schumakera5c58892012-06-20 15:53:42 -0400259nfs_file_fsync_commit(struct file *file, loff_t start, loff_t end, int datasync)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260{
Christoph Hellwig7ea80852010-05-26 17:53:25 +0200261 struct dentry *dentry = file->f_path.dentry;
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400262 struct nfs_open_context *ctx = nfs_file_open_context(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 struct inode *inode = dentry->d_inode;
Trond Myklebust05990d12012-09-11 16:01:22 -0400264 int have_error, do_resend, status;
Trond Myklebustaf7fa162010-07-31 14:29:06 -0400265 int ret = 0;
266
Chuck Lever6da24bc2008-06-11 17:55:58 -0400267 dprintk("NFS: fsync file(%s/%s) datasync %d\n",
Chuck Lever54917782008-05-27 16:29:07 -0400268 dentry->d_parent->d_name.name, dentry->d_name.name,
269 datasync);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270
Chuck Lever91d5b472006-03-20 13:44:14 -0500271 nfs_inc_stats(inode, NFSIOS_VFSFSYNC);
Trond Myklebust05990d12012-09-11 16:01:22 -0400272 do_resend = test_and_clear_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags);
Trond Myklebustaf7fa162010-07-31 14:29:06 -0400273 have_error = test_and_clear_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
274 status = nfs_commit_inode(inode, FLUSH_SYNC);
275 have_error |= test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags);
Trond Myklebust05990d12012-09-11 16:01:22 -0400276 if (have_error) {
Trond Myklebustaf7fa162010-07-31 14:29:06 -0400277 ret = xchg(&ctx->error, 0);
Trond Myklebust05990d12012-09-11 16:01:22 -0400278 if (ret)
279 goto out;
280 }
281 if (status < 0) {
Trond Myklebustaf7fa162010-07-31 14:29:06 -0400282 ret = status;
Trond Myklebust05990d12012-09-11 16:01:22 -0400283 goto out;
284 }
285 do_resend |= test_bit(NFS_CONTEXT_RESEND_WRITES, &ctx->flags);
286 if (do_resend)
287 ret = -EAGAIN;
288out:
Bryan Schumakera5c58892012-06-20 15:53:42 -0400289 return ret;
290}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400291EXPORT_SYMBOL_GPL(nfs_file_fsync_commit);
Bryan Schumakera5c58892012-06-20 15:53:42 -0400292
293static int
294nfs_file_fsync(struct file *file, loff_t start, loff_t end, int datasync)
295{
296 int ret;
Al Viro496ad9a2013-01-23 17:07:38 -0500297 struct inode *inode = file_inode(file);
Bryan Schumakera5c58892012-06-20 15:53:42 -0400298
Trond Myklebustf4ce1292013-08-19 18:59:33 -0400299 trace_nfs_fsync_enter(inode);
300
Trond Myklebust05990d12012-09-11 16:01:22 -0400301 do {
302 ret = filemap_write_and_wait_range(inode->i_mapping, start, end);
303 if (ret != 0)
304 break;
305 mutex_lock(&inode->i_mutex);
306 ret = nfs_file_fsync_commit(file, start, end, datasync);
307 mutex_unlock(&inode->i_mutex);
Trond Myklebustdcfc4f22012-09-11 16:19:38 -0400308 /*
309 * If nfs_file_fsync_commit detected a server reboot, then
310 * resend all dirty pages that might have been covered by
311 * the NFS_CONTEXT_RESEND_WRITES flag
312 */
313 start = 0;
314 end = LLONG_MAX;
Trond Myklebust05990d12012-09-11 16:01:22 -0400315 } while (ret == -EAGAIN);
316
Trond Myklebustf4ce1292013-08-19 18:59:33 -0400317 trace_nfs_fsync_exit(inode, ret);
Trond Myklebustaf7fa162010-07-31 14:29:06 -0400318 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319}
320
321/*
Peter Staubach38c73042009-08-10 08:54:16 -0400322 * Decide whether a read/modify/write cycle may be more efficient
323 * then a modify/write/read cycle when writing to a page in the
324 * page cache.
325 *
326 * The modify/write/read cycle may occur if a page is read before
327 * being completely filled by the writer. In this situation, the
328 * page must be completely written to stable storage on the server
329 * before it can be refilled by reading in the page from the server.
330 * This can lead to expensive, small, FILE_SYNC mode writes being
331 * done.
332 *
333 * It may be more efficient to read the page first if the file is
334 * open for reading in addition to writing, the page is not marked
335 * as Uptodate, it is not dirty or waiting to be committed,
336 * indicating that it was previously allocated and then modified,
337 * that there were valid bytes of data in that range of the file,
338 * and that the new data won't completely replace the old data in
339 * that range of the file.
340 */
341static int nfs_want_read_modify_write(struct file *file, struct page *page,
342 loff_t pos, unsigned len)
343{
344 unsigned int pglen = nfs_page_length(page);
345 unsigned int offset = pos & (PAGE_CACHE_SIZE - 1);
346 unsigned int end = offset + len;
347
348 if ((file->f_mode & FMODE_READ) && /* open for read? */
349 !PageUptodate(page) && /* Uptodate? */
350 !PagePrivate(page) && /* i/o request already? */
351 pglen && /* valid bytes of file? */
352 (end < pglen || offset)) /* replace all valid bytes? */
353 return 1;
354 return 0;
355}
356
357/*
Nick Piggin4899f9c2007-10-16 01:25:16 -0700358 * This does the "real" work of the write. We must allocate and lock the
359 * page to be sent back to the generic routine, which then copies the
360 * data from user space.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 *
362 * If the writer ends up delaying the write, the writer needs to
363 * increment the page use counts until he is done with the page.
364 */
Nick Piggin4899f9c2007-10-16 01:25:16 -0700365static int nfs_write_begin(struct file *file, struct address_space *mapping,
366 loff_t pos, unsigned len, unsigned flags,
367 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700368{
Nick Piggin4899f9c2007-10-16 01:25:16 -0700369 int ret;
Peter Staubach38c73042009-08-10 08:54:16 -0400370 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
Nick Piggin4899f9c2007-10-16 01:25:16 -0700371 struct page *page;
Peter Staubach38c73042009-08-10 08:54:16 -0400372 int once_thru = 0;
Nick Piggin4899f9c2007-10-16 01:25:16 -0700373
Chuck Leverb7eaefa2008-06-11 17:55:50 -0400374 dfprintk(PAGECACHE, "NFS: write_begin(%s/%s(%ld), %u@%lld)\n",
375 file->f_path.dentry->d_parent->d_name.name,
376 file->f_path.dentry->d_name.name,
377 mapping->host->i_ino, len, (long long) pos);
378
Peter Staubach38c73042009-08-10 08:54:16 -0400379start:
Trond Myklebust72cb77f2009-03-11 14:10:30 -0400380 /*
381 * Prevent starvation issues if someone is doing a consistency
382 * sync-to-disk
383 */
384 ret = wait_on_bit(&NFS_I(mapping->host)->flags, NFS_INO_FLUSHING,
385 nfs_wait_bit_killable, TASK_KILLABLE);
386 if (ret)
387 return ret;
388
Nick Piggin54566b22009-01-04 12:00:53 -0800389 page = grab_cache_page_write_begin(mapping, index, flags);
Nick Piggin4899f9c2007-10-16 01:25:16 -0700390 if (!page)
391 return -ENOMEM;
392 *pagep = page;
393
394 ret = nfs_flush_incompatible(file, page);
395 if (ret) {
396 unlock_page(page);
397 page_cache_release(page);
Peter Staubach38c73042009-08-10 08:54:16 -0400398 } else if (!once_thru &&
399 nfs_want_read_modify_write(file, page, pos, len)) {
400 once_thru = 1;
401 ret = nfs_readpage(file, page);
402 page_cache_release(page);
403 if (!ret)
404 goto start;
Nick Piggin4899f9c2007-10-16 01:25:16 -0700405 }
406 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407}
408
Nick Piggin4899f9c2007-10-16 01:25:16 -0700409static int nfs_write_end(struct file *file, struct address_space *mapping,
410 loff_t pos, unsigned len, unsigned copied,
411 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412{
Nick Piggin4899f9c2007-10-16 01:25:16 -0700413 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
Andy Adamsondc248262013-08-14 11:59:16 -0400414 struct nfs_open_context *ctx = nfs_file_open_context(file);
Nick Piggin4899f9c2007-10-16 01:25:16 -0700415 int status;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700416
Chuck Leverb7eaefa2008-06-11 17:55:50 -0400417 dfprintk(PAGECACHE, "NFS: write_end(%s/%s(%ld), %u@%lld)\n",
418 file->f_path.dentry->d_parent->d_name.name,
419 file->f_path.dentry->d_name.name,
420 mapping->host->i_ino, len, (long long) pos);
421
Trond Myklebustefc91ed2008-06-10 18:31:00 -0400422 /*
423 * Zero any uninitialised parts of the page, and then mark the page
424 * as up to date if it turns out that we're extending the file.
425 */
426 if (!PageUptodate(page)) {
427 unsigned pglen = nfs_page_length(page);
428 unsigned end = offset + len;
429
430 if (pglen == 0) {
431 zero_user_segments(page, 0, offset,
432 end, PAGE_CACHE_SIZE);
433 SetPageUptodate(page);
434 } else if (end >= pglen) {
435 zero_user_segment(page, end, PAGE_CACHE_SIZE);
436 if (offset == 0)
437 SetPageUptodate(page);
438 } else
439 zero_user_segment(page, pglen, PAGE_CACHE_SIZE);
440 }
441
Nick Piggin4899f9c2007-10-16 01:25:16 -0700442 status = nfs_updatepage(file, page, offset, copied);
Nick Piggin4899f9c2007-10-16 01:25:16 -0700443
444 unlock_page(page);
445 page_cache_release(page);
446
Chuck Lever3d509e52007-12-20 14:55:04 -0500447 if (status < 0)
448 return status;
Andy Adamson2701d082012-05-24 13:13:24 -0400449 NFS_I(mapping->host)->write_io += copied;
Andy Adamsondc248262013-08-14 11:59:16 -0400450
451 if (nfs_ctx_key_to_expire(ctx)) {
452 status = nfs_wb_all(mapping->host);
453 if (status < 0)
454 return status;
455 }
456
Chuck Lever3d509e52007-12-20 14:55:04 -0500457 return copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458}
459
David Howells6b9b3512009-04-03 16:42:41 +0100460/*
461 * Partially or wholly invalidate a page
462 * - Release the private state associated with a page if undergoing complete
463 * page invalidation
David Howells545db452009-04-03 16:42:44 +0100464 * - Called if either PG_private or PG_fscache is set on the page
David Howells6b9b3512009-04-03 16:42:41 +0100465 * - Caller holds page lock
466 */
Lukas Czernerd47992f2013-05-21 23:17:23 -0400467static void nfs_invalidate_page(struct page *page, unsigned int offset,
468 unsigned int length)
Trond Myklebustcd52ed32006-03-20 13:44:04 -0500469{
Lukas Czernerd47992f2013-05-21 23:17:23 -0400470 dfprintk(PAGECACHE, "NFS: invalidate_page(%p, %u, %u)\n",
471 page, offset, length);
Chuck Leverb7eaefa2008-06-11 17:55:50 -0400472
Lukas Czernerd47992f2013-05-21 23:17:23 -0400473 if (offset != 0 || length < PAGE_CACHE_SIZE)
Trond Myklebust1c759502006-10-09 16:18:38 -0400474 return;
Trond Myklebustd2ccddf2006-05-31 01:13:38 -0400475 /* Cancel any unstarted writes on this page */
Mel Gormand56b4dd2012-07-31 16:45:06 -0700476 nfs_wb_page_cancel(page_file_mapping(page)->host, page);
David Howells545db452009-04-03 16:42:44 +0100477
478 nfs_fscache_invalidate_page(page, page->mapping->host);
Trond Myklebustcd52ed32006-03-20 13:44:04 -0500479}
480
David Howells6b9b3512009-04-03 16:42:41 +0100481/*
482 * Attempt to release the private state associated with a page
David Howells545db452009-04-03 16:42:44 +0100483 * - Called if either PG_private or PG_fscache is set on the page
David Howells6b9b3512009-04-03 16:42:41 +0100484 * - Caller holds page lock
485 * - Return true (may release page) or false (may not)
486 */
Trond Myklebustcd52ed32006-03-20 13:44:04 -0500487static int nfs_release_page(struct page *page, gfp_t gfp)
488{
Trond Myklebustb608b282010-07-30 15:31:54 -0400489 struct address_space *mapping = page->mapping;
490
Chuck Leverb7eaefa2008-06-11 17:55:50 -0400491 dfprintk(PAGECACHE, "NFS: release_page(%p)\n", page);
492
Jeff Layton5cf02d02012-07-23 13:58:51 -0400493 /* Only do I/O if gfp is a superset of GFP_KERNEL, and we're not
494 * doing this memory reclaim for a fs-related allocation.
495 */
496 if (mapping && (gfp & GFP_KERNEL) == GFP_KERNEL &&
497 !(current->flags & PF_FSTRANS)) {
Trond Myklebustb608b282010-07-30 15:31:54 -0400498 int how = FLUSH_SYNC;
499
500 /* Don't let kswapd deadlock waiting for OOM RPC calls */
501 if (current_is_kswapd())
502 how = 0;
503 nfs_commit_inode(mapping->host, how);
504 }
Trond Myklebuste3db7692007-01-10 23:15:39 -0800505 /* If PagePrivate() is set, then the page is not freeable */
David Howells545db452009-04-03 16:42:44 +0100506 if (PagePrivate(page))
507 return 0;
508 return nfs_fscache_release_page(page, gfp);
Trond Myklebuste3db7692007-01-10 23:15:39 -0800509}
510
Mel Gormanf919b192013-07-03 15:02:06 -0700511static void nfs_check_dirty_writeback(struct page *page,
512 bool *dirty, bool *writeback)
513{
514 struct nfs_inode *nfsi;
515 struct address_space *mapping = page_file_mapping(page);
516
517 if (!mapping || PageSwapCache(page))
518 return;
519
520 /*
521 * Check if an unstable page is currently being committed and
522 * if so, have the VM treat it as if the page is under writeback
523 * so it will not block due to pages that will shortly be freeable.
524 */
525 nfsi = NFS_I(mapping->host);
526 if (test_bit(NFS_INO_COMMIT, &nfsi->flags)) {
527 *writeback = true;
528 return;
529 }
530
531 /*
532 * If PagePrivate() is set, then the page is not freeable and as the
533 * inode is not being committed, it's not going to be cleaned in the
534 * near future so treat it as dirty
535 */
536 if (PagePrivate(page))
537 *dirty = true;
538}
539
David Howells6b9b3512009-04-03 16:42:41 +0100540/*
541 * Attempt to clear the private state associated with a page when an error
542 * occurs that requires the cached contents of an inode to be written back or
543 * destroyed
David Howells545db452009-04-03 16:42:44 +0100544 * - Called if either PG_private or fscache is set on the page
David Howells6b9b3512009-04-03 16:42:41 +0100545 * - Caller holds page lock
546 * - Return 0 if successful, -error otherwise
547 */
Trond Myklebuste3db7692007-01-10 23:15:39 -0800548static int nfs_launder_page(struct page *page)
549{
Mel Gormand56b4dd2012-07-31 16:45:06 -0700550 struct inode *inode = page_file_mapping(page)->host;
David Howells545db452009-04-03 16:42:44 +0100551 struct nfs_inode *nfsi = NFS_I(inode);
Chuck Leverb7eaefa2008-06-11 17:55:50 -0400552
553 dfprintk(PAGECACHE, "NFS: launder_page(%ld, %llu)\n",
554 inode->i_ino, (long long)page_offset(page));
555
David Howells545db452009-04-03 16:42:44 +0100556 nfs_fscache_wait_on_page_write(nfsi, page);
Chuck Leverb7eaefa2008-06-11 17:55:50 -0400557 return nfs_wb_page(inode, page);
Trond Myklebustcd52ed32006-03-20 13:44:04 -0500558}
559
Mel Gormana564b8f2012-07-31 16:45:12 -0700560#ifdef CONFIG_NFS_SWAP
561static int nfs_swap_activate(struct swap_info_struct *sis, struct file *file,
562 sector_t *span)
563{
564 *span = sis->pages;
565 return xs_swapper(NFS_CLIENT(file->f_mapping->host)->cl_xprt, 1);
566}
567
568static void nfs_swap_deactivate(struct file *file)
569{
570 xs_swapper(NFS_CLIENT(file->f_mapping->host)->cl_xprt, 0);
571}
572#endif
573
Christoph Hellwigf5e54d62006-06-28 04:26:44 -0700574const struct address_space_operations nfs_file_aops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 .readpage = nfs_readpage,
576 .readpages = nfs_readpages,
Trond Myklebust9cccef92007-07-22 17:09:05 -0400577 .set_page_dirty = __set_page_dirty_nobuffers,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700578 .writepage = nfs_writepage,
579 .writepages = nfs_writepages,
Nick Piggin4899f9c2007-10-16 01:25:16 -0700580 .write_begin = nfs_write_begin,
581 .write_end = nfs_write_end,
Trond Myklebustcd52ed32006-03-20 13:44:04 -0500582 .invalidatepage = nfs_invalidate_page,
583 .releasepage = nfs_release_page,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584 .direct_IO = nfs_direct_IO,
Trond Myklebust074cc1d2009-08-10 08:54:13 -0400585 .migratepage = nfs_migrate_page,
Trond Myklebuste3db7692007-01-10 23:15:39 -0800586 .launder_page = nfs_launder_page,
Mel Gormanf919b192013-07-03 15:02:06 -0700587 .is_dirty_writeback = nfs_check_dirty_writeback,
Andi Kleenf590f332009-09-16 11:50:17 +0200588 .error_remove_page = generic_error_remove_page,
Mel Gormana564b8f2012-07-31 16:45:12 -0700589#ifdef CONFIG_NFS_SWAP
590 .swap_activate = nfs_swap_activate,
591 .swap_deactivate = nfs_swap_deactivate,
592#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593};
594
David Howells6b9b3512009-04-03 16:42:41 +0100595/*
596 * Notification that a PTE pointing to an NFS page is about to be made
597 * writable, implying that someone is about to modify the page through a
598 * shared-writable mapping
599 */
Nick Pigginc2ec1752009-03-31 15:23:21 -0700600static int nfs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
Trond Myklebust94387fb2007-07-22 17:09:05 -0400601{
Nick Pigginc2ec1752009-03-31 15:23:21 -0700602 struct page *page = vmf->page;
Trond Myklebust94387fb2007-07-22 17:09:05 -0400603 struct file *filp = vma->vm_file;
Chuck Leverb7eaefa2008-06-11 17:55:50 -0400604 struct dentry *dentry = filp->f_path.dentry;
Trond Myklebust94387fb2007-07-22 17:09:05 -0400605 unsigned pagelen;
Trond Myklebustbc4866b2010-10-04 17:59:08 -0400606 int ret = VM_FAULT_NOPAGE;
Nick Piggin4899f9c2007-10-16 01:25:16 -0700607 struct address_space *mapping;
Trond Myklebust94387fb2007-07-22 17:09:05 -0400608
Chuck Leverb7eaefa2008-06-11 17:55:50 -0400609 dfprintk(PAGECACHE, "NFS: vm_page_mkwrite(%s/%s(%ld), offset %lld)\n",
610 dentry->d_parent->d_name.name, dentry->d_name.name,
611 filp->f_mapping->host->i_ino,
612 (long long)page_offset(page));
613
David Howells545db452009-04-03 16:42:44 +0100614 /* make sure the cache has finished storing the page */
615 nfs_fscache_wait_on_page_write(NFS_I(dentry->d_inode), page);
616
Trond Myklebust94387fb2007-07-22 17:09:05 -0400617 lock_page(page);
Mel Gormand56b4dd2012-07-31 16:45:06 -0700618 mapping = page_file_mapping(page);
Chuck Leverb7eaefa2008-06-11 17:55:50 -0400619 if (mapping != dentry->d_inode->i_mapping)
Trond Myklebust8b1f9ee2008-01-22 17:13:06 -0500620 goto out_unlock;
621
Trond Myklebust2aeb98f2012-01-17 22:04:26 -0500622 wait_on_page_writeback(page);
623
Trond Myklebust94387fb2007-07-22 17:09:05 -0400624 pagelen = nfs_page_length(page);
Trond Myklebust8b1f9ee2008-01-22 17:13:06 -0500625 if (pagelen == 0)
626 goto out_unlock;
627
Trond Myklebustbc4866b2010-10-04 17:59:08 -0400628 ret = VM_FAULT_LOCKED;
629 if (nfs_flush_incompatible(filp, page) == 0 &&
630 nfs_updatepage(filp, page, 0, pagelen) == 0)
631 goto out;
Trond Myklebust8b1f9ee2008-01-22 17:13:06 -0500632
Trond Myklebustbc4866b2010-10-04 17:59:08 -0400633 ret = VM_FAULT_SIGBUS;
Trond Myklebust8b1f9ee2008-01-22 17:13:06 -0500634out_unlock:
Trond Myklebust94387fb2007-07-22 17:09:05 -0400635 unlock_page(page);
Trond Myklebustbc4866b2010-10-04 17:59:08 -0400636out:
637 return ret;
Trond Myklebust94387fb2007-07-22 17:09:05 -0400638}
639
Alexey Dobriyanf0f37e22009-09-27 22:29:37 +0400640static const struct vm_operations_struct nfs_file_vm_ops = {
Trond Myklebust94387fb2007-07-22 17:09:05 -0400641 .fault = filemap_fault,
642 .page_mkwrite = nfs_vm_page_mkwrite,
Konstantin Khlebnikov0b173bc2012-10-08 16:28:46 -0700643 .remap_pages = generic_file_remap_pages,
Trond Myklebust94387fb2007-07-22 17:09:05 -0400644};
645
Trond Myklebust7b159fc2007-07-25 14:09:54 -0400646static int nfs_need_sync_write(struct file *filp, struct inode *inode)
647{
648 struct nfs_open_context *ctx;
649
Christoph Hellwig6b2f3d12009-10-27 11:05:28 +0100650 if (IS_SYNC(inode) || (filp->f_flags & O_DSYNC))
Trond Myklebust7b159fc2007-07-25 14:09:54 -0400651 return 1;
Trond Myklebustcd3758e2007-08-10 17:44:32 -0400652 ctx = nfs_file_open_context(filp);
Andy Adamsondc248262013-08-14 11:59:16 -0400653 if (test_bit(NFS_CONTEXT_ERROR_WRITE, &ctx->flags) ||
654 nfs_ctx_key_to_expire(ctx))
Trond Myklebust7b159fc2007-07-25 14:09:54 -0400655 return 1;
656 return 0;
657}
658
Bryan Schumakerce4ef7c2012-07-16 16:39:15 -0400659ssize_t nfs_file_write(struct kiocb *iocb, const struct iovec *iov,
660 unsigned long nr_segs, loff_t pos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700661{
Josef "Jeff" Sipek01cce932006-12-08 02:36:40 -0800662 struct dentry * dentry = iocb->ki_filp->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 struct inode * inode = dentry->d_inode;
Chuck Lever7e381172010-02-01 14:17:41 -0500664 unsigned long written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 ssize_t result;
Badari Pulavarty027445c2006-09-30 23:28:46 -0700666 size_t count = iov_length(iov, nr_segs);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667
Andy Adamsondc248262013-08-14 11:59:16 -0400668 result = nfs_key_timeout_notify(iocb->ki_filp, inode);
669 if (result)
670 return result;
671
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 if (iocb->ki_filp->f_flags & O_DIRECT)
Mel Gormana564b8f2012-07-31 16:45:12 -0700673 return nfs_file_direct_write(iocb, iov, nr_segs, pos, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674
Chuck Lever6da24bc2008-06-11 17:55:58 -0400675 dprintk("NFS: write(%s/%s, %lu@%Ld)\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 dentry->d_parent->d_name.name, dentry->d_name.name,
Chuck Lever6da24bc2008-06-11 17:55:58 -0400677 (unsigned long) count, (long long) pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678
679 result = -EBUSY;
680 if (IS_SWAPFILE(inode))
681 goto out_swapfile;
Trond Myklebust7d52e862005-06-22 17:16:30 +0000682 /*
683 * O_APPEND implies that we must revalidate the file length.
684 */
685 if (iocb->ki_filp->f_flags & O_APPEND) {
686 result = nfs_revalidate_file_size(inode, iocb->ki_filp);
687 if (result)
688 goto out;
Trond Myklebustfe51beec2005-06-22 17:16:30 +0000689 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700690
691 result = count;
692 if (!count)
693 goto out;
694
Badari Pulavarty027445c2006-09-30 23:28:46 -0700695 result = generic_file_aio_write(iocb, iov, nr_segs, pos);
Chuck Lever7e381172010-02-01 14:17:41 -0500696 if (result > 0)
697 written = result;
698
Christoph Hellwig6b2f3d12009-10-27 11:05:28 +0100699 /* Return error values for O_DSYNC and IS_SYNC() */
Trond Myklebust7b159fc2007-07-25 14:09:54 -0400700 if (result >= 0 && nfs_need_sync_write(iocb->ki_filp, inode)) {
Trond Myklebustaf7fa162010-07-31 14:29:06 -0400701 int err = vfs_fsync(iocb->ki_filp, 0);
Trond Myklebust200baa22006-12-05 00:35:40 -0500702 if (err < 0)
703 result = err;
704 }
Chuck Lever7e381172010-02-01 14:17:41 -0500705 if (result > 0)
706 nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707out:
708 return result;
709
710out_swapfile:
711 printk(KERN_INFO "NFS: attempt to write to active swap file!\n");
712 goto out;
713}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400714EXPORT_SYMBOL_GPL(nfs_file_write);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
Bryan Schumakerce4ef7c2012-07-16 16:39:15 -0400716ssize_t nfs_file_splice_write(struct pipe_inode_info *pipe,
717 struct file *filp, loff_t *ppos,
718 size_t count, unsigned int flags)
Suresh Jayaramanbf40d342009-06-17 18:02:09 -0700719{
720 struct dentry *dentry = filp->f_path.dentry;
721 struct inode *inode = dentry->d_inode;
Chuck Lever7e381172010-02-01 14:17:41 -0500722 unsigned long written = 0;
Suresh Jayaramanbf40d342009-06-17 18:02:09 -0700723 ssize_t ret;
724
725 dprintk("NFS splice_write(%s/%s, %lu@%llu)\n",
726 dentry->d_parent->d_name.name, dentry->d_name.name,
727 (unsigned long) count, (unsigned long long) *ppos);
728
729 /*
730 * The combination of splice and an O_APPEND destination is disallowed.
731 */
732
Suresh Jayaramanbf40d342009-06-17 18:02:09 -0700733 ret = generic_file_splice_write(pipe, filp, ppos, count, flags);
Chuck Lever7e381172010-02-01 14:17:41 -0500734 if (ret > 0)
735 written = ret;
736
Suresh Jayaramanbf40d342009-06-17 18:02:09 -0700737 if (ret >= 0 && nfs_need_sync_write(filp, inode)) {
Trond Myklebustaf7fa162010-07-31 14:29:06 -0400738 int err = vfs_fsync(filp, 0);
Suresh Jayaramanbf40d342009-06-17 18:02:09 -0700739 if (err < 0)
740 ret = err;
741 }
Chuck Lever7e381172010-02-01 14:17:41 -0500742 if (ret > 0)
743 nfs_add_stats(inode, NFSIOS_NORMALWRITTENBYTES, written);
Suresh Jayaramanbf40d342009-06-17 18:02:09 -0700744 return ret;
745}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400746EXPORT_SYMBOL_GPL(nfs_file_splice_write);
Suresh Jayaramanbf40d342009-06-17 18:02:09 -0700747
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400748static int
749do_getlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750{
751 struct inode *inode = filp->f_mapping->host;
752 int status = 0;
Sergey Vlasov21ac19d2010-11-28 21:04:05 +0000753 unsigned int saved_type = fl->fl_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754
Trond Myklebust039c4d72005-10-18 14:20:16 -0700755 /* Try local locking first */
J. Bruce Fields6d34ac12007-05-11 16:09:32 -0400756 posix_test_lock(filp, fl);
757 if (fl->fl_type != F_UNLCK) {
758 /* found a conflict */
Trond Myklebust039c4d72005-10-18 14:20:16 -0700759 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 }
Sergey Vlasov21ac19d2010-11-28 21:04:05 +0000761 fl->fl_type = saved_type;
Trond Myklebust039c4d72005-10-18 14:20:16 -0700762
Bryan Schumaker011e2a72012-06-20 15:53:43 -0400763 if (NFS_PROTO(inode)->have_delegation(inode, FMODE_READ))
Trond Myklebust039c4d72005-10-18 14:20:16 -0700764 goto out_noconflict;
765
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400766 if (is_local)
Trond Myklebust039c4d72005-10-18 14:20:16 -0700767 goto out_noconflict;
768
769 status = NFS_PROTO(inode)->lock(filp, cmd, fl);
770out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 return status;
Trond Myklebust039c4d72005-10-18 14:20:16 -0700772out_noconflict:
773 fl->fl_type = F_UNLCK;
774 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775}
776
777static int do_vfs_lock(struct file *file, struct file_lock *fl)
778{
779 int res = 0;
780 switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
781 case FL_POSIX:
782 res = posix_lock_file_wait(file, fl);
783 break;
784 case FL_FLOCK:
785 res = flock_lock_file_wait(file, fl);
786 break;
787 default:
788 BUG();
789 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 return res;
791}
792
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400793static int
794do_unlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795{
796 struct inode *inode = filp->f_mapping->host;
Trond Myklebust7a8203d2013-04-08 21:49:53 -0400797 struct nfs_lock_context *l_ctx;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 int status;
799
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800 /*
801 * Flush all pending writes before doing anything
802 * with locks..
803 */
Trond Myklebust29884df2005-12-13 16:13:54 -0500804 nfs_sync_mapping(filp->f_mapping);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805
Trond Myklebust7a8203d2013-04-08 21:49:53 -0400806 l_ctx = nfs_get_lock_context(nfs_file_open_context(filp));
807 if (!IS_ERR(l_ctx)) {
808 status = nfs_iocounter_wait(&l_ctx->io_count);
809 nfs_put_lock_context(l_ctx);
810 if (status < 0)
811 return status;
812 }
813
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814 /* NOTE: special case
815 * If we're signalled while cleaning up locks on process exit, we
816 * still need to complete the unlock.
817 */
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400818 /*
819 * Use local locking if mounted with "-onolock" or with appropriate
820 * "-olocal_lock="
821 */
822 if (!is_local)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 status = NFS_PROTO(inode)->lock(filp, cmd, fl);
824 else
825 status = do_vfs_lock(filp, fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 return status;
827}
828
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400829static int
Ricardo Labiaga6b967242010-10-12 16:30:05 -0700830is_time_granular(struct timespec *ts) {
831 return ((ts->tv_sec == 0) && (ts->tv_nsec <= 1000));
832}
833
834static int
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400835do_setlk(struct file *filp, int cmd, struct file_lock *fl, int is_local)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836{
837 struct inode *inode = filp->f_mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 int status;
839
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 /*
841 * Flush all pending writes before doing anything
842 * with locks..
843 */
Trond Myklebust29884df2005-12-13 16:13:54 -0500844 status = nfs_sync_mapping(filp->f_mapping);
845 if (status != 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 goto out;
847
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400848 /*
849 * Use local locking if mounted with "-onolock" or with appropriate
850 * "-olocal_lock="
851 */
852 if (!is_local)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853 status = NFS_PROTO(inode)->lock(filp, cmd, fl);
Trond Myklebustc4d7c402008-04-01 20:26:52 -0400854 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 status = do_vfs_lock(filp, fl);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 if (status < 0)
857 goto out;
Ricardo Labiaga6b967242010-10-12 16:30:05 -0700858
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 /*
Ricardo Labiaga6b967242010-10-12 16:30:05 -0700860 * Revalidate the cache if the server has time stamps granular
861 * enough to detect subsecond changes. Otherwise, clear the
862 * cache to prevent missing any changes.
863 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 * This makes locking act as a cache coherency point.
865 */
Trond Myklebust29884df2005-12-13 16:13:54 -0500866 nfs_sync_mapping(filp->f_mapping);
Bryan Schumaker011e2a72012-06-20 15:53:43 -0400867 if (!NFS_PROTO(inode)->have_delegation(inode, FMODE_READ)) {
Ricardo Labiaga6b967242010-10-12 16:30:05 -0700868 if (is_time_granular(&NFS_SERVER(inode)->time_delta))
869 __nfs_revalidate_inode(NFS_SERVER(inode), inode);
870 else
871 nfs_zap_caches(inode);
872 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 return status;
875}
876
877/*
878 * Lock a (portion of) a file
879 */
Bryan Schumakerce4ef7c2012-07-16 16:39:15 -0400880int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881{
Chuck Lever6da24bc2008-06-11 17:55:58 -0400882 struct inode *inode = filp->f_mapping->host;
Trond Myklebust21162712008-05-20 19:34:39 -0400883 int ret = -ENOLCK;
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400884 int is_local = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885
Chuck Lever6da24bc2008-06-11 17:55:58 -0400886 dprintk("NFS: lock(%s/%s, t=%x, fl=%x, r=%lld:%lld)\n",
887 filp->f_path.dentry->d_parent->d_name.name,
888 filp->f_path.dentry->d_name.name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 fl->fl_type, fl->fl_flags,
890 (long long)fl->fl_start, (long long)fl->fl_end);
Chuck Lever6da24bc2008-06-11 17:55:58 -0400891
Chuck Lever91d5b472006-03-20 13:44:14 -0500892 nfs_inc_stats(inode, NFSIOS_VFSLOCK);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893
894 /* No mandatory locks over NFS */
Pavel Emelyanovdfad9442007-10-01 14:41:15 -0700895 if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
Trond Myklebust21162712008-05-20 19:34:39 -0400896 goto out_err;
897
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400898 if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FCNTL)
899 is_local = 1;
900
Trond Myklebust21162712008-05-20 19:34:39 -0400901 if (NFS_PROTO(inode)->lock_check_bounds != NULL) {
902 ret = NFS_PROTO(inode)->lock_check_bounds(fl);
903 if (ret < 0)
904 goto out_err;
905 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906
907 if (IS_GETLK(cmd))
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400908 ret = do_getlk(filp, cmd, fl, is_local);
Trond Myklebust21162712008-05-20 19:34:39 -0400909 else if (fl->fl_type == F_UNLCK)
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400910 ret = do_unlk(filp, cmd, fl, is_local);
Trond Myklebust21162712008-05-20 19:34:39 -0400911 else
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400912 ret = do_setlk(filp, cmd, fl, is_local);
Trond Myklebust21162712008-05-20 19:34:39 -0400913out_err:
914 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400916EXPORT_SYMBOL_GPL(nfs_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917
918/*
919 * Lock a (portion of) a file
920 */
Bryan Schumakerce4ef7c2012-07-16 16:39:15 -0400921int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922{
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400923 struct inode *inode = filp->f_mapping->host;
924 int is_local = 0;
925
Chuck Lever6da24bc2008-06-11 17:55:58 -0400926 dprintk("NFS: flock(%s/%s, t=%x, fl=%x)\n",
927 filp->f_path.dentry->d_parent->d_name.name,
928 filp->f_path.dentry->d_name.name,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700929 fl->fl_type, fl->fl_flags);
930
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 if (!(fl->fl_flags & FL_FLOCK))
932 return -ENOLCK;
933
Jeff Laytonad0fcd42012-07-23 15:46:23 -0400934 /*
935 * The NFSv4 protocol doesn't support LOCK_MAND, which is not part of
936 * any standard. In principle we might be able to support LOCK_MAND
937 * on NFSv2/3 since NLMv3/4 support DOS share modes, but for now the
938 * NFS code is not set up for it.
939 */
940 if (fl->fl_type & LOCK_MAND)
941 return -EINVAL;
942
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400943 if (NFS_SERVER(inode)->flags & NFS_MOUNT_LOCAL_FLOCK)
944 is_local = 1;
945
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 /* We're simulating flock() locks using posix locks on the server */
947 fl->fl_owner = (fl_owner_t)filp;
948 fl->fl_start = 0;
949 fl->fl_end = OFFSET_MAX;
950
951 if (fl->fl_type == F_UNLCK)
Suresh Jayaraman5eebde22010-09-23 08:55:58 -0400952 return do_unlk(filp, cmd, fl, is_local);
953 return do_setlk(filp, cmd, fl, is_local);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700954}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400955EXPORT_SYMBOL_GPL(nfs_flock);
J. Bruce Fields370f6592007-06-08 15:23:34 -0400956
Chuck Lever6da24bc2008-06-11 17:55:58 -0400957/*
958 * There is no protocol support for leases, so we have no way to implement
959 * them correctly in the face of opens by other clients.
960 */
Bryan Schumakerce4ef7c2012-07-16 16:39:15 -0400961int nfs_setlease(struct file *file, long arg, struct file_lock **fl)
J. Bruce Fields370f6592007-06-08 15:23:34 -0400962{
Chuck Lever6da24bc2008-06-11 17:55:58 -0400963 dprintk("NFS: setlease(%s/%s, arg=%ld)\n",
964 file->f_path.dentry->d_parent->d_name.name,
965 file->f_path.dentry->d_name.name, arg);
J. Bruce Fields370f6592007-06-08 15:23:34 -0400966 return -EINVAL;
967}
Bryan Schumaker89d77c82012-07-30 16:05:25 -0400968EXPORT_SYMBOL_GPL(nfs_setlease);
Jeff Layton1788ea62011-11-04 13:31:21 -0400969
Jeff Layton04869582011-11-04 13:31:22 -0400970const struct file_operations nfs_file_operations = {
971 .llseek = nfs_file_llseek,
972 .read = do_sync_read,
973 .write = do_sync_write,
974 .aio_read = nfs_file_read,
975 .aio_write = nfs_file_write,
976 .mmap = nfs_file_mmap,
977 .open = nfs_file_open,
978 .flush = nfs_file_flush,
979 .release = nfs_file_release,
980 .fsync = nfs_file_fsync,
981 .lock = nfs_lock,
982 .flock = nfs_flock,
983 .splice_read = nfs_file_splice_read,
984 .splice_write = nfs_file_splice_write,
985 .check_flags = nfs_check_flags,
986 .setlease = nfs_setlease,
987};
Bryan Schumakerddda8e02012-07-30 16:05:23 -0400988EXPORT_SYMBOL_GPL(nfs_file_operations);