[PATCH] NFS: Add support for NFSv3 ACLs
[linux-2.6.git] / fs / nfs / file.c
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>
27 #include <linux/slab.h>
28 #include <linux/pagemap.h>
29 #include <linux/smp_lock.h>
30
31 #include <asm/uaccess.h>
32 #include <asm/system.h>
33
34 #include "delegation.h"
35
36 #define NFSDBG_FACILITY         NFSDBG_FILE
37
38 static int nfs_file_open(struct inode *, struct file *);
39 static int nfs_file_release(struct inode *, struct file *);
40 static loff_t nfs_file_llseek(struct file *file, loff_t offset, int origin);
41 static int  nfs_file_mmap(struct file *, struct vm_area_struct *);
42 static ssize_t nfs_file_sendfile(struct file *, loff_t *, size_t, read_actor_t, void *);
43 static ssize_t nfs_file_read(struct kiocb *, char __user *, size_t, loff_t);
44 static ssize_t nfs_file_write(struct kiocb *, const char __user *, size_t, loff_t);
45 static int  nfs_file_flush(struct file *);
46 static int  nfs_fsync(struct file *, struct dentry *dentry, int datasync);
47 static int nfs_check_flags(int flags);
48 static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl);
49 static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl);
50
51 struct file_operations nfs_file_operations = {
52         .llseek         = nfs_file_llseek,
53         .read           = do_sync_read,
54         .write          = do_sync_write,
55         .aio_read               = nfs_file_read,
56         .aio_write              = nfs_file_write,
57         .mmap           = nfs_file_mmap,
58         .open           = nfs_file_open,
59         .flush          = nfs_file_flush,
60         .release        = nfs_file_release,
61         .fsync          = nfs_fsync,
62         .lock           = nfs_lock,
63         .flock          = nfs_flock,
64         .sendfile       = nfs_file_sendfile,
65         .check_flags    = nfs_check_flags,
66 };
67
68 struct inode_operations nfs_file_inode_operations = {
69         .permission     = nfs_permission,
70         .getattr        = nfs_getattr,
71         .setattr        = nfs_setattr,
72 };
73
74 #ifdef CONFIG_NFS_V3
75 struct inode_operations nfs3_file_inode_operations = {
76         .permission     = nfs_permission,
77         .getattr        = nfs_getattr,
78         .setattr        = nfs_setattr,
79         .listxattr      = nfs3_listxattr,
80         .getxattr       = nfs3_getxattr,
81         .setxattr       = nfs3_setxattr,
82         .removexattr    = nfs3_removexattr,
83 };
84 #endif  /* CONFIG_NFS_v3 */
85
86 /* Hack for future NFS swap support */
87 #ifndef IS_SWAPFILE
88 # define IS_SWAPFILE(inode)     (0)
89 #endif
90
91 static int nfs_check_flags(int flags)
92 {
93         if ((flags & (O_APPEND | O_DIRECT)) == (O_APPEND | O_DIRECT))
94                 return -EINVAL;
95
96         return 0;
97 }
98
99 /*
100  * Open file
101  */
102 static int
103 nfs_file_open(struct inode *inode, struct file *filp)
104 {
105         struct nfs_server *server = NFS_SERVER(inode);
106         int (*open)(struct inode *, struct file *);
107         int res;
108
109         res = nfs_check_flags(filp->f_flags);
110         if (res)
111                 return res;
112
113         lock_kernel();
114         /* Do NFSv4 open() call */
115         if ((open = server->rpc_ops->file_open) != NULL)
116                 res = open(inode, filp);
117         unlock_kernel();
118         return res;
119 }
120
121 static int
122 nfs_file_release(struct inode *inode, struct file *filp)
123 {
124         /* Ensure that dirty pages are flushed out with the right creds */
125         if (filp->f_mode & FMODE_WRITE)
126                 filemap_fdatawrite(filp->f_mapping);
127         return NFS_PROTO(inode)->file_release(inode, filp);
128 }
129
130 /**
131  * nfs_revalidate_size - Revalidate the file size
132  * @inode - pointer to inode struct
133  * @file - pointer to struct file
134  *
135  * Revalidates the file length. This is basically a wrapper around
136  * nfs_revalidate_inode() that takes into account the fact that we may
137  * have cached writes (in which case we don't care about the server's
138  * idea of what the file length is), or O_DIRECT (in which case we
139  * shouldn't trust the cache).
140  */
141 static int nfs_revalidate_file_size(struct inode *inode, struct file *filp)
142 {
143         struct nfs_server *server = NFS_SERVER(inode);
144         struct nfs_inode *nfsi = NFS_I(inode);
145
146         if (server->flags & NFS_MOUNT_NOAC)
147                 goto force_reval;
148         if (filp->f_flags & O_DIRECT)
149                 goto force_reval;
150         if (nfsi->npages != 0)
151                 return 0;
152         return nfs_revalidate_inode(server, inode);
153 force_reval:
154         return __nfs_revalidate_inode(server, inode);
155 }
156
157 static loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin)
158 {
159         /* origin == SEEK_END => we must revalidate the cached file length */
160         if (origin == 2) {
161                 struct inode *inode = filp->f_mapping->host;
162                 int retval = nfs_revalidate_file_size(inode, filp);
163                 if (retval < 0)
164                         return (loff_t)retval;
165         }
166         return remote_llseek(filp, offset, origin);
167 }
168
169 /*
170  * Flush all dirty pages, and check for write errors.
171  *
172  */
173 static int
174 nfs_file_flush(struct file *file)
175 {
176         struct nfs_open_context *ctx = (struct nfs_open_context *)file->private_data;
177         struct inode    *inode = file->f_dentry->d_inode;
178         int             status;
179
180         dfprintk(VFS, "nfs: flush(%s/%ld)\n", inode->i_sb->s_id, inode->i_ino);
181
182         if ((file->f_mode & FMODE_WRITE) == 0)
183                 return 0;
184         lock_kernel();
185         /* Ensure that data+attribute caches are up to date after close() */
186         status = nfs_wb_all(inode);
187         if (!status) {
188                 status = ctx->error;
189                 ctx->error = 0;
190                 if (!status && !nfs_have_delegation(inode, FMODE_READ))
191                         __nfs_revalidate_inode(NFS_SERVER(inode), inode);
192         }
193         unlock_kernel();
194         return status;
195 }
196
197 static ssize_t
198 nfs_file_read(struct kiocb *iocb, char __user * buf, size_t count, loff_t pos)
199 {
200         struct dentry * dentry = iocb->ki_filp->f_dentry;
201         struct inode * inode = dentry->d_inode;
202         ssize_t result;
203
204 #ifdef CONFIG_NFS_DIRECTIO
205         if (iocb->ki_filp->f_flags & O_DIRECT)
206                 return nfs_file_direct_read(iocb, buf, count, pos);
207 #endif
208
209         dfprintk(VFS, "nfs: read(%s/%s, %lu@%lu)\n",
210                 dentry->d_parent->d_name.name, dentry->d_name.name,
211                 (unsigned long) count, (unsigned long) pos);
212
213         result = nfs_revalidate_inode(NFS_SERVER(inode), inode);
214         if (!result)
215                 result = generic_file_aio_read(iocb, buf, count, pos);
216         return result;
217 }
218
219 static ssize_t
220 nfs_file_sendfile(struct file *filp, loff_t *ppos, size_t count,
221                 read_actor_t actor, void *target)
222 {
223         struct dentry *dentry = filp->f_dentry;
224         struct inode *inode = dentry->d_inode;
225         ssize_t res;
226
227         dfprintk(VFS, "nfs: sendfile(%s/%s, %lu@%Lu)\n",
228                 dentry->d_parent->d_name.name, dentry->d_name.name,
229                 (unsigned long) count, (unsigned long long) *ppos);
230
231         res = nfs_revalidate_inode(NFS_SERVER(inode), inode);
232         if (!res)
233                 res = generic_file_sendfile(filp, ppos, count, actor, target);
234         return res;
235 }
236
237 static int
238 nfs_file_mmap(struct file * file, struct vm_area_struct * vma)
239 {
240         struct dentry *dentry = file->f_dentry;
241         struct inode *inode = dentry->d_inode;
242         int     status;
243
244         dfprintk(VFS, "nfs: mmap(%s/%s)\n",
245                 dentry->d_parent->d_name.name, dentry->d_name.name);
246
247         status = nfs_revalidate_inode(NFS_SERVER(inode), inode);
248         if (!status)
249                 status = generic_file_mmap(file, vma);
250         return status;
251 }
252
253 /*
254  * Flush any dirty pages for this process, and check for write errors.
255  * The return status from this call provides a reliable indication of
256  * whether any write errors occurred for this process.
257  */
258 static int
259 nfs_fsync(struct file *file, struct dentry *dentry, int datasync)
260 {
261         struct nfs_open_context *ctx = (struct nfs_open_context *)file->private_data;
262         struct inode *inode = dentry->d_inode;
263         int status;
264
265         dfprintk(VFS, "nfs: fsync(%s/%ld)\n", inode->i_sb->s_id, inode->i_ino);
266
267         lock_kernel();
268         status = nfs_wb_all(inode);
269         if (!status) {
270                 status = ctx->error;
271                 ctx->error = 0;
272         }
273         unlock_kernel();
274         return status;
275 }
276
277 /*
278  * This does the "real" work of the write. The generic routine has
279  * allocated the page, locked it, done all the page alignment stuff
280  * calculations etc. Now we should just copy the data from user
281  * space and write it back to the real medium..
282  *
283  * If the writer ends up delaying the write, the writer needs to
284  * increment the page use counts until he is done with the page.
285  */
286 static int nfs_prepare_write(struct file *file, struct page *page, unsigned offset, unsigned to)
287 {
288         return nfs_flush_incompatible(file, page);
289 }
290
291 static int nfs_commit_write(struct file *file, struct page *page, unsigned offset, unsigned to)
292 {
293         long status;
294
295         lock_kernel();
296         status = nfs_updatepage(file, page, offset, to-offset);
297         unlock_kernel();
298         return status;
299 }
300
301 struct address_space_operations nfs_file_aops = {
302         .readpage = nfs_readpage,
303         .readpages = nfs_readpages,
304         .set_page_dirty = __set_page_dirty_nobuffers,
305         .writepage = nfs_writepage,
306         .writepages = nfs_writepages,
307         .prepare_write = nfs_prepare_write,
308         .commit_write = nfs_commit_write,
309 #ifdef CONFIG_NFS_DIRECTIO
310         .direct_IO = nfs_direct_IO,
311 #endif
312 };
313
314 /* 
315  * Write to a file (through the page cache).
316  */
317 static ssize_t
318 nfs_file_write(struct kiocb *iocb, const char __user *buf, size_t count, loff_t pos)
319 {
320         struct dentry * dentry = iocb->ki_filp->f_dentry;
321         struct inode * inode = dentry->d_inode;
322         ssize_t result;
323
324 #ifdef CONFIG_NFS_DIRECTIO
325         if (iocb->ki_filp->f_flags & O_DIRECT)
326                 return nfs_file_direct_write(iocb, buf, count, pos);
327 #endif
328
329         dfprintk(VFS, "nfs: write(%s/%s(%ld), %lu@%lu)\n",
330                 dentry->d_parent->d_name.name, dentry->d_name.name,
331                 inode->i_ino, (unsigned long) count, (unsigned long) pos);
332
333         result = -EBUSY;
334         if (IS_SWAPFILE(inode))
335                 goto out_swapfile;
336         result = nfs_revalidate_inode(NFS_SERVER(inode), inode);
337         if (result)
338                 goto out;
339
340         result = count;
341         if (!count)
342                 goto out;
343
344         result = generic_file_aio_write(iocb, buf, count, pos);
345 out:
346         return result;
347
348 out_swapfile:
349         printk(KERN_INFO "NFS: attempt to write to active swap file!\n");
350         goto out;
351 }
352
353 static int do_getlk(struct file *filp, int cmd, struct file_lock *fl)
354 {
355         struct inode *inode = filp->f_mapping->host;
356         int status = 0;
357
358         lock_kernel();
359         /* Use local locking if mounted with "-onolock" */
360         if (!(NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM))
361                 status = NFS_PROTO(inode)->lock(filp, cmd, fl);
362         else {
363                 struct file_lock *cfl = posix_test_lock(filp, fl);
364
365                 fl->fl_type = F_UNLCK;
366                 if (cfl != NULL)
367                         memcpy(fl, cfl, sizeof(*fl));
368         }
369         unlock_kernel();
370         return status;
371 }
372
373 static int do_vfs_lock(struct file *file, struct file_lock *fl)
374 {
375         int res = 0;
376         switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
377                 case FL_POSIX:
378                         res = posix_lock_file_wait(file, fl);
379                         break;
380                 case FL_FLOCK:
381                         res = flock_lock_file_wait(file, fl);
382                         break;
383                 default:
384                         BUG();
385         }
386         if (res < 0)
387                 printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n",
388                                 __FUNCTION__);
389         return res;
390 }
391
392 static int do_unlk(struct file *filp, int cmd, struct file_lock *fl)
393 {
394         struct inode *inode = filp->f_mapping->host;
395         sigset_t oldset;
396         int status;
397
398         rpc_clnt_sigmask(NFS_CLIENT(inode), &oldset);
399         /*
400          * Flush all pending writes before doing anything
401          * with locks..
402          */
403         filemap_fdatawrite(filp->f_mapping);
404         down(&inode->i_sem);
405         nfs_wb_all(inode);
406         up(&inode->i_sem);
407         filemap_fdatawait(filp->f_mapping);
408
409         /* NOTE: special case
410          *      If we're signalled while cleaning up locks on process exit, we
411          *      still need to complete the unlock.
412          */
413         lock_kernel();
414         /* Use local locking if mounted with "-onolock" */
415         if (!(NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM))
416                 status = NFS_PROTO(inode)->lock(filp, cmd, fl);
417         else
418                 status = do_vfs_lock(filp, fl);
419         unlock_kernel();
420         rpc_clnt_sigunmask(NFS_CLIENT(inode), &oldset);
421         return status;
422 }
423
424 static int do_setlk(struct file *filp, int cmd, struct file_lock *fl)
425 {
426         struct inode *inode = filp->f_mapping->host;
427         sigset_t oldset;
428         int status;
429
430         rpc_clnt_sigmask(NFS_CLIENT(inode), &oldset);
431         /*
432          * Flush all pending writes before doing anything
433          * with locks..
434          */
435         status = filemap_fdatawrite(filp->f_mapping);
436         if (status == 0) {
437                 down(&inode->i_sem);
438                 status = nfs_wb_all(inode);
439                 up(&inode->i_sem);
440                 if (status == 0)
441                         status = filemap_fdatawait(filp->f_mapping);
442         }
443         if (status < 0)
444                 goto out;
445
446         lock_kernel();
447         /* Use local locking if mounted with "-onolock" */
448         if (!(NFS_SERVER(inode)->flags & NFS_MOUNT_NONLM)) {
449                 status = NFS_PROTO(inode)->lock(filp, cmd, fl);
450                 /* If we were signalled we still need to ensure that
451                  * we clean up any state on the server. We therefore
452                  * record the lock call as having succeeded in order to
453                  * ensure that locks_remove_posix() cleans it out when
454                  * the process exits.
455                  */
456                 if (status == -EINTR || status == -ERESTARTSYS)
457                         do_vfs_lock(filp, fl);
458         } else
459                 status = do_vfs_lock(filp, fl);
460         unlock_kernel();
461         if (status < 0)
462                 goto out;
463         /*
464          * Make sure we clear the cache whenever we try to get the lock.
465          * This makes locking act as a cache coherency point.
466          */
467         filemap_fdatawrite(filp->f_mapping);
468         down(&inode->i_sem);
469         nfs_wb_all(inode);      /* we may have slept */
470         up(&inode->i_sem);
471         filemap_fdatawait(filp->f_mapping);
472         nfs_zap_caches(inode);
473 out:
474         rpc_clnt_sigunmask(NFS_CLIENT(inode), &oldset);
475         return status;
476 }
477
478 /*
479  * Lock a (portion of) a file
480  */
481 static int nfs_lock(struct file *filp, int cmd, struct file_lock *fl)
482 {
483         struct inode * inode = filp->f_mapping->host;
484
485         dprintk("NFS: nfs_lock(f=%s/%ld, t=%x, fl=%x, r=%Ld:%Ld)\n",
486                         inode->i_sb->s_id, inode->i_ino,
487                         fl->fl_type, fl->fl_flags,
488                         (long long)fl->fl_start, (long long)fl->fl_end);
489
490         if (!inode)
491                 return -EINVAL;
492
493         /* No mandatory locks over NFS */
494         if ((inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
495                 return -ENOLCK;
496
497         if (IS_GETLK(cmd))
498                 return do_getlk(filp, cmd, fl);
499         if (fl->fl_type == F_UNLCK)
500                 return do_unlk(filp, cmd, fl);
501         return do_setlk(filp, cmd, fl);
502 }
503
504 /*
505  * Lock a (portion of) a file
506  */
507 static int nfs_flock(struct file *filp, int cmd, struct file_lock *fl)
508 {
509         struct inode * inode = filp->f_mapping->host;
510
511         dprintk("NFS: nfs_flock(f=%s/%ld, t=%x, fl=%x)\n",
512                         inode->i_sb->s_id, inode->i_ino,
513                         fl->fl_type, fl->fl_flags);
514
515         if (!inode)
516                 return -EINVAL;
517
518         /*
519          * No BSD flocks over NFS allowed.
520          * Note: we could try to fake a POSIX lock request here by
521          * using ((u32) filp | 0x80000000) or some such as the pid.
522          * Not sure whether that would be unique, though, or whether
523          * that would break in other places.
524          */
525         if (!(fl->fl_flags & FL_FLOCK))
526                 return -ENOLCK;
527
528         /* We're simulating flock() locks using posix locks on the server */
529         fl->fl_owner = (fl_owner_t)filp;
530         fl->fl_start = 0;
531         fl->fl_end = OFFSET_MAX;
532
533         if (fl->fl_type == F_UNLCK)
534                 return do_unlk(filp, cmd, fl);
535         return do_setlk(filp, cmd, fl);
536 }