nfsd: split up nfsd_setattr
[linux-3.10.git] / fs / nfsd / vfs.c
1 /*
2  * File operations used by nfsd. Some of these have been ripped from
3  * other parts of the kernel because they weren't exported, others
4  * are partial duplicates with added or changed functionality.
5  *
6  * Note that several functions dget() the dentry upon which they want
7  * to act, most notably those that create directory entries. Response
8  * dentry's are dput()'d if necessary in the release callback.
9  * So if you notice code paths that apparently fail to dput() the
10  * dentry, don't worry--they have been taken care of.
11  *
12  * Copyright (C) 1995-1999 Olaf Kirch <okir@monad.swb.de>
13  * Zerocpy NFS support (C) 2002 Hirokazu Takahashi <taka@valinux.co.jp>
14  */
15
16 #include <linux/fs.h>
17 #include <linux/file.h>
18 #include <linux/splice.h>
19 #include <linux/fcntl.h>
20 #include <linux/namei.h>
21 #include <linux/delay.h>
22 #include <linux/fsnotify.h>
23 #include <linux/posix_acl_xattr.h>
24 #include <linux/xattr.h>
25 #include <linux/jhash.h>
26 #include <linux/ima.h>
27 #include <linux/slab.h>
28 #include <asm/uaccess.h>
29 #include <linux/exportfs.h>
30 #include <linux/writeback.h>
31
32 #ifdef CONFIG_NFSD_V3
33 #include "xdr3.h"
34 #endif /* CONFIG_NFSD_V3 */
35
36 #ifdef CONFIG_NFSD_V4
37 #include "acl.h"
38 #include "idmap.h"
39 #endif /* CONFIG_NFSD_V4 */
40
41 #include "nfsd.h"
42 #include "vfs.h"
43
44 #define NFSDDBG_FACILITY                NFSDDBG_FILEOP
45
46
47 /*
48  * This is a cache of readahead params that help us choose the proper
49  * readahead strategy. Initially, we set all readahead parameters to 0
50  * and let the VFS handle things.
51  * If you increase the number of cached files very much, you'll need to
52  * add a hash table here.
53  */
54 struct raparms {
55         struct raparms          *p_next;
56         unsigned int            p_count;
57         ino_t                   p_ino;
58         dev_t                   p_dev;
59         int                     p_set;
60         struct file_ra_state    p_ra;
61         unsigned int            p_hindex;
62 };
63
64 struct raparm_hbucket {
65         struct raparms          *pb_head;
66         spinlock_t              pb_lock;
67 } ____cacheline_aligned_in_smp;
68
69 #define RAPARM_HASH_BITS        4
70 #define RAPARM_HASH_SIZE        (1<<RAPARM_HASH_BITS)
71 #define RAPARM_HASH_MASK        (RAPARM_HASH_SIZE-1)
72 static struct raparm_hbucket    raparm_hash[RAPARM_HASH_SIZE];
73
74 /* 
75  * Called from nfsd_lookup and encode_dirent. Check if we have crossed 
76  * a mount point.
77  * Returns -EAGAIN or -ETIMEDOUT leaving *dpp and *expp unchanged,
78  *  or nfs_ok having possibly changed *dpp and *expp
79  */
80 int
81 nfsd_cross_mnt(struct svc_rqst *rqstp, struct dentry **dpp, 
82                         struct svc_export **expp)
83 {
84         struct svc_export *exp = *expp, *exp2 = NULL;
85         struct dentry *dentry = *dpp;
86         struct path path = {.mnt = mntget(exp->ex_path.mnt),
87                             .dentry = dget(dentry)};
88         int err = 0;
89
90         err = follow_down(&path);
91         if (err < 0)
92                 goto out;
93
94         exp2 = rqst_exp_get_by_name(rqstp, &path);
95         if (IS_ERR(exp2)) {
96                 err = PTR_ERR(exp2);
97                 /*
98                  * We normally allow NFS clients to continue
99                  * "underneath" a mountpoint that is not exported.
100                  * The exception is V4ROOT, where no traversal is ever
101                  * allowed without an explicit export of the new
102                  * directory.
103                  */
104                 if (err == -ENOENT && !(exp->ex_flags & NFSEXP_V4ROOT))
105                         err = 0;
106                 path_put(&path);
107                 goto out;
108         }
109         if (nfsd_v4client(rqstp) ||
110                 (exp->ex_flags & NFSEXP_CROSSMOUNT) || EX_NOHIDE(exp2)) {
111                 /* successfully crossed mount point */
112                 /*
113                  * This is subtle: path.dentry is *not* on path.mnt
114                  * at this point.  The only reason we are safe is that
115                  * original mnt is pinned down by exp, so we should
116                  * put path *before* putting exp
117                  */
118                 *dpp = path.dentry;
119                 path.dentry = dentry;
120                 *expp = exp2;
121                 exp2 = exp;
122         }
123         path_put(&path);
124         exp_put(exp2);
125 out:
126         return err;
127 }
128
129 static void follow_to_parent(struct path *path)
130 {
131         struct dentry *dp;
132
133         while (path->dentry == path->mnt->mnt_root && follow_up(path))
134                 ;
135         dp = dget_parent(path->dentry);
136         dput(path->dentry);
137         path->dentry = dp;
138 }
139
140 static int nfsd_lookup_parent(struct svc_rqst *rqstp, struct dentry *dparent, struct svc_export **exp, struct dentry **dentryp)
141 {
142         struct svc_export *exp2;
143         struct path path = {.mnt = mntget((*exp)->ex_path.mnt),
144                             .dentry = dget(dparent)};
145
146         follow_to_parent(&path);
147
148         exp2 = rqst_exp_parent(rqstp, &path);
149         if (PTR_ERR(exp2) == -ENOENT) {
150                 *dentryp = dget(dparent);
151         } else if (IS_ERR(exp2)) {
152                 path_put(&path);
153                 return PTR_ERR(exp2);
154         } else {
155                 *dentryp = dget(path.dentry);
156                 exp_put(*exp);
157                 *exp = exp2;
158         }
159         path_put(&path);
160         return 0;
161 }
162
163 /*
164  * For nfsd purposes, we treat V4ROOT exports as though there was an
165  * export at *every* directory.
166  */
167 int nfsd_mountpoint(struct dentry *dentry, struct svc_export *exp)
168 {
169         if (d_mountpoint(dentry))
170                 return 1;
171         if (nfsd4_is_junction(dentry))
172                 return 1;
173         if (!(exp->ex_flags & NFSEXP_V4ROOT))
174                 return 0;
175         return dentry->d_inode != NULL;
176 }
177
178 __be32
179 nfsd_lookup_dentry(struct svc_rqst *rqstp, struct svc_fh *fhp,
180                    const char *name, unsigned int len,
181                    struct svc_export **exp_ret, struct dentry **dentry_ret)
182 {
183         struct svc_export       *exp;
184         struct dentry           *dparent;
185         struct dentry           *dentry;
186         int                     host_err;
187
188         dprintk("nfsd: nfsd_lookup(fh %s, %.*s)\n", SVCFH_fmt(fhp), len,name);
189
190         dparent = fhp->fh_dentry;
191         exp  = fhp->fh_export;
192         exp_get(exp);
193
194         /* Lookup the name, but don't follow links */
195         if (isdotent(name, len)) {
196                 if (len==1)
197                         dentry = dget(dparent);
198                 else if (dparent != exp->ex_path.dentry)
199                         dentry = dget_parent(dparent);
200                 else if (!EX_NOHIDE(exp) && !nfsd_v4client(rqstp))
201                         dentry = dget(dparent); /* .. == . just like at / */
202                 else {
203                         /* checking mountpoint crossing is very different when stepping up */
204                         host_err = nfsd_lookup_parent(rqstp, dparent, &exp, &dentry);
205                         if (host_err)
206                                 goto out_nfserr;
207                 }
208         } else {
209                 fh_lock(fhp);
210                 dentry = lookup_one_len(name, dparent, len);
211                 host_err = PTR_ERR(dentry);
212                 if (IS_ERR(dentry))
213                         goto out_nfserr;
214                 /*
215                  * check if we have crossed a mount point ...
216                  */
217                 if (nfsd_mountpoint(dentry, exp)) {
218                         if ((host_err = nfsd_cross_mnt(rqstp, &dentry, &exp))) {
219                                 dput(dentry);
220                                 goto out_nfserr;
221                         }
222                 }
223         }
224         *dentry_ret = dentry;
225         *exp_ret = exp;
226         return 0;
227
228 out_nfserr:
229         exp_put(exp);
230         return nfserrno(host_err);
231 }
232
233 /*
234  * Look up one component of a pathname.
235  * N.B. After this call _both_ fhp and resfh need an fh_put
236  *
237  * If the lookup would cross a mountpoint, and the mounted filesystem
238  * is exported to the client with NFSEXP_NOHIDE, then the lookup is
239  * accepted as it stands and the mounted directory is
240  * returned. Otherwise the covered directory is returned.
241  * NOTE: this mountpoint crossing is not supported properly by all
242  *   clients and is explicitly disallowed for NFSv3
243  *      NeilBrown <neilb@cse.unsw.edu.au>
244  */
245 __be32
246 nfsd_lookup(struct svc_rqst *rqstp, struct svc_fh *fhp, const char *name,
247                                 unsigned int len, struct svc_fh *resfh)
248 {
249         struct svc_export       *exp;
250         struct dentry           *dentry;
251         __be32 err;
252
253         err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC);
254         if (err)
255                 return err;
256         err = nfsd_lookup_dentry(rqstp, fhp, name, len, &exp, &dentry);
257         if (err)
258                 return err;
259         err = check_nfsd_access(exp, rqstp);
260         if (err)
261                 goto out;
262         /*
263          * Note: we compose the file handle now, but as the
264          * dentry may be negative, it may need to be updated.
265          */
266         err = fh_compose(resfh, exp, dentry, fhp);
267         if (!err && !dentry->d_inode)
268                 err = nfserr_noent;
269 out:
270         dput(dentry);
271         exp_put(exp);
272         return err;
273 }
274
275 static int nfsd_break_lease(struct inode *inode)
276 {
277         if (!S_ISREG(inode->i_mode))
278                 return 0;
279         return break_lease(inode, O_WRONLY | O_NONBLOCK);
280 }
281
282 /*
283  * Commit metadata changes to stable storage.
284  */
285 static int
286 commit_metadata(struct svc_fh *fhp)
287 {
288         struct inode *inode = fhp->fh_dentry->d_inode;
289         const struct export_operations *export_ops = inode->i_sb->s_export_op;
290
291         if (!EX_ISSYNC(fhp->fh_export))
292                 return 0;
293
294         if (export_ops->commit_metadata)
295                 return export_ops->commit_metadata(inode);
296         return sync_inode_metadata(inode, 1);
297 }
298
299 /*
300  * Go over the attributes and take care of the small differences between
301  * NFS semantics and what Linux expects.
302  */
303 static void
304 nfsd_sanitize_attrs(struct inode *inode, struct iattr *iap)
305 {
306         /*
307          * NFSv2 does not differentiate between "set-[ac]time-to-now"
308          * which only requires access, and "set-[ac]time-to-X" which
309          * requires ownership.
310          * So if it looks like it might be "set both to the same time which
311          * is close to now", and if inode_change_ok fails, then we
312          * convert to "set to now" instead of "set to explicit time"
313          *
314          * We only call inode_change_ok as the last test as technically
315          * it is not an interface that we should be using.
316          */
317 #define BOTH_TIME_SET (ATTR_ATIME_SET | ATTR_MTIME_SET)
318 #define MAX_TOUCH_TIME_ERROR (30*60)
319         if ((iap->ia_valid & BOTH_TIME_SET) == BOTH_TIME_SET &&
320             iap->ia_mtime.tv_sec == iap->ia_atime.tv_sec) {
321                 /*
322                  * Looks probable.
323                  *
324                  * Now just make sure time is in the right ballpark.
325                  * Solaris, at least, doesn't seem to care what the time
326                  * request is.  We require it be within 30 minutes of now.
327                  */
328                 time_t delta = iap->ia_atime.tv_sec - get_seconds();
329                 if (delta < 0)
330                         delta = -delta;
331                 if (delta < MAX_TOUCH_TIME_ERROR &&
332                     inode_change_ok(inode, iap) != 0) {
333                         /*
334                          * Turn off ATTR_[AM]TIME_SET but leave ATTR_[AM]TIME.
335                          * This will cause notify_change to set these times
336                          * to "now"
337                          */
338                         iap->ia_valid &= ~BOTH_TIME_SET;
339                 }
340         }
341
342         /* sanitize the mode change */
343         if (iap->ia_valid & ATTR_MODE) {
344                 iap->ia_mode &= S_IALLUGO;
345                 iap->ia_mode |= (inode->i_mode & ~S_IALLUGO);
346         }
347
348         /* Revoke setuid/setgid on chown */
349         if (!S_ISDIR(inode->i_mode) &&
350             (((iap->ia_valid & ATTR_UID) && !uid_eq(iap->ia_uid, inode->i_uid)) ||
351              ((iap->ia_valid & ATTR_GID) && !gid_eq(iap->ia_gid, inode->i_gid)))) {
352                 iap->ia_valid |= ATTR_KILL_PRIV;
353                 if (iap->ia_valid & ATTR_MODE) {
354                         /* we're setting mode too, just clear the s*id bits */
355                         iap->ia_mode &= ~S_ISUID;
356                         if (iap->ia_mode & S_IXGRP)
357                                 iap->ia_mode &= ~S_ISGID;
358                 } else {
359                         /* set ATTR_KILL_* bits and let VFS handle it */
360                         iap->ia_valid |= (ATTR_KILL_SUID | ATTR_KILL_SGID);
361                 }
362         }
363 }
364
365 static __be32
366 nfsd_get_write_access(struct svc_rqst *rqstp, struct svc_fh *fhp,
367                 struct iattr *iap)
368 {
369         struct inode *inode = fhp->fh_dentry->d_inode;
370         int host_err;
371
372         if (iap->ia_size < inode->i_size) {
373                 __be32 err;
374
375                 err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
376                                 NFSD_MAY_TRUNC | NFSD_MAY_OWNER_OVERRIDE);
377                 if (err)
378                         return err;
379         }
380
381         host_err = get_write_access(inode);
382         if (host_err)
383                 goto out_nfserrno;
384
385         host_err = locks_verify_truncate(inode, NULL, iap->ia_size);
386         if (host_err)
387                 goto out_put_write_access;
388         return 0;
389
390 out_put_write_access:
391         put_write_access(inode);
392 out_nfserrno:
393         return nfserrno(host_err);
394 }
395
396 /*
397  * Set various file attributes.  After this call fhp needs an fh_put.
398  */
399 __be32
400 nfsd_setattr(struct svc_rqst *rqstp, struct svc_fh *fhp, struct iattr *iap,
401              int check_guard, time_t guardtime)
402 {
403         struct dentry   *dentry;
404         struct inode    *inode;
405         int             accmode = NFSD_MAY_SATTR;
406         umode_t         ftype = 0;
407         __be32          err;
408         int             host_err;
409         int             size_change = 0;
410
411         if (iap->ia_valid & (ATTR_ATIME | ATTR_MTIME | ATTR_SIZE))
412                 accmode |= NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE;
413         if (iap->ia_valid & ATTR_SIZE)
414                 ftype = S_IFREG;
415
416         /* Get inode */
417         err = fh_verify(rqstp, fhp, ftype, accmode);
418         if (err)
419                 goto out;
420
421         dentry = fhp->fh_dentry;
422         inode = dentry->d_inode;
423
424         /* Ignore any mode updates on symlinks */
425         if (S_ISLNK(inode->i_mode))
426                 iap->ia_valid &= ~ATTR_MODE;
427
428         if (!iap->ia_valid)
429                 goto out;
430
431         nfsd_sanitize_attrs(inode, iap);
432
433         /*
434          * The size case is special, it changes the file in addition to the
435          * attributes.
436          */
437         if (iap->ia_valid & ATTR_SIZE) {
438                 err = nfsd_get_write_access(rqstp, fhp, iap);
439                 if (err)
440                         goto out;
441                 size_change = 1;
442         }
443
444         iap->ia_valid |= ATTR_CTIME;
445
446         err = nfserr_notsync;
447         if (!check_guard || guardtime == inode->i_ctime.tv_sec) {
448                 host_err = nfsd_break_lease(inode);
449                 if (host_err)
450                         goto out_nfserr;
451                 fh_lock(fhp);
452
453                 host_err = notify_change(dentry, iap);
454                 err = nfserrno(host_err);
455                 fh_unlock(fhp);
456         }
457         if (size_change)
458                 put_write_access(inode);
459         if (!err)
460                 commit_metadata(fhp);
461 out:
462         return err;
463
464 out_nfserr:
465         err = nfserrno(host_err);
466         goto out;
467 }
468
469 #if defined(CONFIG_NFSD_V2_ACL) || \
470     defined(CONFIG_NFSD_V3_ACL) || \
471     defined(CONFIG_NFSD_V4)
472 static ssize_t nfsd_getxattr(struct dentry *dentry, char *key, void **buf)
473 {
474         ssize_t buflen;
475         ssize_t ret;
476
477         buflen = vfs_getxattr(dentry, key, NULL, 0);
478         if (buflen <= 0)
479                 return buflen;
480
481         *buf = kmalloc(buflen, GFP_KERNEL);
482         if (!*buf)
483                 return -ENOMEM;
484
485         ret = vfs_getxattr(dentry, key, *buf, buflen);
486         if (ret < 0)
487                 kfree(*buf);
488         return ret;
489 }
490 #endif
491
492 #if defined(CONFIG_NFSD_V4)
493 static int
494 set_nfsv4_acl_one(struct dentry *dentry, struct posix_acl *pacl, char *key)
495 {
496         int len;
497         size_t buflen;
498         char *buf = NULL;
499         int error = 0;
500
501         buflen = posix_acl_xattr_size(pacl->a_count);
502         buf = kmalloc(buflen, GFP_KERNEL);
503         error = -ENOMEM;
504         if (buf == NULL)
505                 goto out;
506
507         len = posix_acl_to_xattr(&init_user_ns, pacl, buf, buflen);
508         if (len < 0) {
509                 error = len;
510                 goto out;
511         }
512
513         error = vfs_setxattr(dentry, key, buf, len, 0);
514 out:
515         kfree(buf);
516         return error;
517 }
518
519 __be32
520 nfsd4_set_nfs4_acl(struct svc_rqst *rqstp, struct svc_fh *fhp,
521     struct nfs4_acl *acl)
522 {
523         __be32 error;
524         int host_error;
525         struct dentry *dentry;
526         struct inode *inode;
527         struct posix_acl *pacl = NULL, *dpacl = NULL;
528         unsigned int flags = 0;
529
530         /* Get inode */
531         error = fh_verify(rqstp, fhp, 0, NFSD_MAY_SATTR);
532         if (error)
533                 return error;
534
535         dentry = fhp->fh_dentry;
536         inode = dentry->d_inode;
537         if (S_ISDIR(inode->i_mode))
538                 flags = NFS4_ACL_DIR;
539
540         host_error = nfs4_acl_nfsv4_to_posix(acl, &pacl, &dpacl, flags);
541         if (host_error == -EINVAL) {
542                 return nfserr_attrnotsupp;
543         } else if (host_error < 0)
544                 goto out_nfserr;
545
546         host_error = set_nfsv4_acl_one(dentry, pacl, POSIX_ACL_XATTR_ACCESS);
547         if (host_error < 0)
548                 goto out_release;
549
550         if (S_ISDIR(inode->i_mode))
551                 host_error = set_nfsv4_acl_one(dentry, dpacl, POSIX_ACL_XATTR_DEFAULT);
552
553 out_release:
554         posix_acl_release(pacl);
555         posix_acl_release(dpacl);
556 out_nfserr:
557         if (host_error == -EOPNOTSUPP)
558                 return nfserr_attrnotsupp;
559         else
560                 return nfserrno(host_error);
561 }
562
563 static struct posix_acl *
564 _get_posix_acl(struct dentry *dentry, char *key)
565 {
566         void *buf = NULL;
567         struct posix_acl *pacl = NULL;
568         int buflen;
569
570         buflen = nfsd_getxattr(dentry, key, &buf);
571         if (!buflen)
572                 buflen = -ENODATA;
573         if (buflen <= 0)
574                 return ERR_PTR(buflen);
575
576         pacl = posix_acl_from_xattr(&init_user_ns, buf, buflen);
577         kfree(buf);
578         return pacl;
579 }
580
581 int
582 nfsd4_get_nfs4_acl(struct svc_rqst *rqstp, struct dentry *dentry, struct nfs4_acl **acl)
583 {
584         struct inode *inode = dentry->d_inode;
585         int error = 0;
586         struct posix_acl *pacl = NULL, *dpacl = NULL;
587         unsigned int flags = 0;
588
589         pacl = _get_posix_acl(dentry, POSIX_ACL_XATTR_ACCESS);
590         if (IS_ERR(pacl) && PTR_ERR(pacl) == -ENODATA)
591                 pacl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
592         if (IS_ERR(pacl)) {
593                 error = PTR_ERR(pacl);
594                 pacl = NULL;
595                 goto out;
596         }
597
598         if (S_ISDIR(inode->i_mode)) {
599                 dpacl = _get_posix_acl(dentry, POSIX_ACL_XATTR_DEFAULT);
600                 if (IS_ERR(dpacl) && PTR_ERR(dpacl) == -ENODATA)
601                         dpacl = NULL;
602                 else if (IS_ERR(dpacl)) {
603                         error = PTR_ERR(dpacl);
604                         dpacl = NULL;
605                         goto out;
606                 }
607                 flags = NFS4_ACL_DIR;
608         }
609
610         *acl = nfs4_acl_posix_to_nfsv4(pacl, dpacl, flags);
611         if (IS_ERR(*acl)) {
612                 error = PTR_ERR(*acl);
613                 *acl = NULL;
614         }
615  out:
616         posix_acl_release(pacl);
617         posix_acl_release(dpacl);
618         return error;
619 }
620
621 /*
622  * NFS junction information is stored in an extended attribute.
623  */
624 #define NFSD_JUNCTION_XATTR_NAME        XATTR_TRUSTED_PREFIX "junction.nfs"
625
626 /**
627  * nfsd4_is_junction - Test if an object could be an NFS junction
628  *
629  * @dentry: object to test
630  *
631  * Returns 1 if "dentry" appears to contain NFS junction information.
632  * Otherwise 0 is returned.
633  */
634 int nfsd4_is_junction(struct dentry *dentry)
635 {
636         struct inode *inode = dentry->d_inode;
637
638         if (inode == NULL)
639                 return 0;
640         if (inode->i_mode & S_IXUGO)
641                 return 0;
642         if (!(inode->i_mode & S_ISVTX))
643                 return 0;
644         if (vfs_getxattr(dentry, NFSD_JUNCTION_XATTR_NAME, NULL, 0) <= 0)
645                 return 0;
646         return 1;
647 }
648 #endif /* defined(CONFIG_NFSD_V4) */
649
650 #ifdef CONFIG_NFSD_V3
651 /*
652  * Check server access rights to a file system object
653  */
654 struct accessmap {
655         u32             access;
656         int             how;
657 };
658 static struct accessmap nfs3_regaccess[] = {
659     {   NFS3_ACCESS_READ,       NFSD_MAY_READ                   },
660     {   NFS3_ACCESS_EXECUTE,    NFSD_MAY_EXEC                   },
661     {   NFS3_ACCESS_MODIFY,     NFSD_MAY_WRITE|NFSD_MAY_TRUNC   },
662     {   NFS3_ACCESS_EXTEND,     NFSD_MAY_WRITE                  },
663
664     {   0,                      0                               }
665 };
666
667 static struct accessmap nfs3_diraccess[] = {
668     {   NFS3_ACCESS_READ,       NFSD_MAY_READ                   },
669     {   NFS3_ACCESS_LOOKUP,     NFSD_MAY_EXEC                   },
670     {   NFS3_ACCESS_MODIFY,     NFSD_MAY_EXEC|NFSD_MAY_WRITE|NFSD_MAY_TRUNC},
671     {   NFS3_ACCESS_EXTEND,     NFSD_MAY_EXEC|NFSD_MAY_WRITE    },
672     {   NFS3_ACCESS_DELETE,     NFSD_MAY_REMOVE                 },
673
674     {   0,                      0                               }
675 };
676
677 static struct accessmap nfs3_anyaccess[] = {
678         /* Some clients - Solaris 2.6 at least, make an access call
679          * to the server to check for access for things like /dev/null
680          * (which really, the server doesn't care about).  So
681          * We provide simple access checking for them, looking
682          * mainly at mode bits, and we make sure to ignore read-only
683          * filesystem checks
684          */
685     {   NFS3_ACCESS_READ,       NFSD_MAY_READ                   },
686     {   NFS3_ACCESS_EXECUTE,    NFSD_MAY_EXEC                   },
687     {   NFS3_ACCESS_MODIFY,     NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS    },
688     {   NFS3_ACCESS_EXTEND,     NFSD_MAY_WRITE|NFSD_MAY_LOCAL_ACCESS    },
689
690     {   0,                      0                               }
691 };
692
693 __be32
694 nfsd_access(struct svc_rqst *rqstp, struct svc_fh *fhp, u32 *access, u32 *supported)
695 {
696         struct accessmap        *map;
697         struct svc_export       *export;
698         struct dentry           *dentry;
699         u32                     query, result = 0, sresult = 0;
700         __be32                  error;
701
702         error = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP);
703         if (error)
704                 goto out;
705
706         export = fhp->fh_export;
707         dentry = fhp->fh_dentry;
708
709         if (S_ISREG(dentry->d_inode->i_mode))
710                 map = nfs3_regaccess;
711         else if (S_ISDIR(dentry->d_inode->i_mode))
712                 map = nfs3_diraccess;
713         else
714                 map = nfs3_anyaccess;
715
716
717         query = *access;
718         for  (; map->access; map++) {
719                 if (map->access & query) {
720                         __be32 err2;
721
722                         sresult |= map->access;
723
724                         err2 = nfsd_permission(rqstp, export, dentry, map->how);
725                         switch (err2) {
726                         case nfs_ok:
727                                 result |= map->access;
728                                 break;
729                                 
730                         /* the following error codes just mean the access was not allowed,
731                          * rather than an error occurred */
732                         case nfserr_rofs:
733                         case nfserr_acces:
734                         case nfserr_perm:
735                                 /* simply don't "or" in the access bit. */
736                                 break;
737                         default:
738                                 error = err2;
739                                 goto out;
740                         }
741                 }
742         }
743         *access = result;
744         if (supported)
745                 *supported = sresult;
746
747  out:
748         return error;
749 }
750 #endif /* CONFIG_NFSD_V3 */
751
752 static int nfsd_open_break_lease(struct inode *inode, int access)
753 {
754         unsigned int mode;
755
756         if (access & NFSD_MAY_NOT_BREAK_LEASE)
757                 return 0;
758         mode = (access & NFSD_MAY_WRITE) ? O_WRONLY : O_RDONLY;
759         return break_lease(inode, mode | O_NONBLOCK);
760 }
761
762 /*
763  * Open an existing file or directory.
764  * The may_flags argument indicates the type of open (read/write/lock)
765  * and additional flags.
766  * N.B. After this call fhp needs an fh_put
767  */
768 __be32
769 nfsd_open(struct svc_rqst *rqstp, struct svc_fh *fhp, umode_t type,
770                         int may_flags, struct file **filp)
771 {
772         struct path     path;
773         struct inode    *inode;
774         int             flags = O_RDONLY|O_LARGEFILE;
775         __be32          err;
776         int             host_err = 0;
777
778         validate_process_creds();
779
780         /*
781          * If we get here, then the client has already done an "open",
782          * and (hopefully) checked permission - so allow OWNER_OVERRIDE
783          * in case a chmod has now revoked permission.
784          *
785          * Arguably we should also allow the owner override for
786          * directories, but we never have and it doesn't seem to have
787          * caused anyone a problem.  If we were to change this, note
788          * also that our filldir callbacks would need a variant of
789          * lookup_one_len that doesn't check permissions.
790          */
791         if (type == S_IFREG)
792                 may_flags |= NFSD_MAY_OWNER_OVERRIDE;
793         err = fh_verify(rqstp, fhp, type, may_flags);
794         if (err)
795                 goto out;
796
797         path.mnt = fhp->fh_export->ex_path.mnt;
798         path.dentry = fhp->fh_dentry;
799         inode = path.dentry->d_inode;
800
801         /* Disallow write access to files with the append-only bit set
802          * or any access when mandatory locking enabled
803          */
804         err = nfserr_perm;
805         if (IS_APPEND(inode) && (may_flags & NFSD_MAY_WRITE))
806                 goto out;
807         /*
808          * We must ignore files (but only files) which might have mandatory
809          * locks on them because there is no way to know if the accesser has
810          * the lock.
811          */
812         if (S_ISREG((inode)->i_mode) && mandatory_lock(inode))
813                 goto out;
814
815         if (!inode->i_fop)
816                 goto out;
817
818         host_err = nfsd_open_break_lease(inode, may_flags);
819         if (host_err) /* NOMEM or WOULDBLOCK */
820                 goto out_nfserr;
821
822         if (may_flags & NFSD_MAY_WRITE) {
823                 if (may_flags & NFSD_MAY_READ)
824                         flags = O_RDWR|O_LARGEFILE;
825                 else
826                         flags = O_WRONLY|O_LARGEFILE;
827         }
828         *filp = dentry_open(&path, flags, current_cred());
829         if (IS_ERR(*filp)) {
830                 host_err = PTR_ERR(*filp);
831                 *filp = NULL;
832         } else {
833                 host_err = ima_file_check(*filp, may_flags);
834
835                 if (may_flags & NFSD_MAY_64BIT_COOKIE)
836                         (*filp)->f_mode |= FMODE_64BITHASH;
837                 else
838                         (*filp)->f_mode |= FMODE_32BITHASH;
839         }
840
841 out_nfserr:
842         err = nfserrno(host_err);
843 out:
844         validate_process_creds();
845         return err;
846 }
847
848 /*
849  * Close a file.
850  */
851 void
852 nfsd_close(struct file *filp)
853 {
854         fput(filp);
855 }
856
857 /*
858  * Obtain the readahead parameters for the file
859  * specified by (dev, ino).
860  */
861
862 static inline struct raparms *
863 nfsd_get_raparms(dev_t dev, ino_t ino)
864 {
865         struct raparms  *ra, **rap, **frap = NULL;
866         int depth = 0;
867         unsigned int hash;
868         struct raparm_hbucket *rab;
869
870         hash = jhash_2words(dev, ino, 0xfeedbeef) & RAPARM_HASH_MASK;
871         rab = &raparm_hash[hash];
872
873         spin_lock(&rab->pb_lock);
874         for (rap = &rab->pb_head; (ra = *rap); rap = &ra->p_next) {
875                 if (ra->p_ino == ino && ra->p_dev == dev)
876                         goto found;
877                 depth++;
878                 if (ra->p_count == 0)
879                         frap = rap;
880         }
881         depth = nfsdstats.ra_size;
882         if (!frap) {    
883                 spin_unlock(&rab->pb_lock);
884                 return NULL;
885         }
886         rap = frap;
887         ra = *frap;
888         ra->p_dev = dev;
889         ra->p_ino = ino;
890         ra->p_set = 0;
891         ra->p_hindex = hash;
892 found:
893         if (rap != &rab->pb_head) {
894                 *rap = ra->p_next;
895                 ra->p_next   = rab->pb_head;
896                 rab->pb_head = ra;
897         }
898         ra->p_count++;
899         nfsdstats.ra_depth[depth*10/nfsdstats.ra_size]++;
900         spin_unlock(&rab->pb_lock);
901         return ra;
902 }
903
904 /*
905  * Grab and keep cached pages associated with a file in the svc_rqst
906  * so that they can be passed to the network sendmsg/sendpage routines
907  * directly. They will be released after the sending has completed.
908  */
909 static int
910 nfsd_splice_actor(struct pipe_inode_info *pipe, struct pipe_buffer *buf,
911                   struct splice_desc *sd)
912 {
913         struct svc_rqst *rqstp = sd->u.data;
914         struct page **pp = rqstp->rq_next_page;
915         struct page *page = buf->page;
916         size_t size;
917
918         size = sd->len;
919
920         if (rqstp->rq_res.page_len == 0) {
921                 get_page(page);
922                 put_page(*rqstp->rq_next_page);
923                 *(rqstp->rq_next_page++) = page;
924                 rqstp->rq_res.page_base = buf->offset;
925                 rqstp->rq_res.page_len = size;
926         } else if (page != pp[-1]) {
927                 get_page(page);
928                 if (*rqstp->rq_next_page)
929                         put_page(*rqstp->rq_next_page);
930                 *(rqstp->rq_next_page++) = page;
931                 rqstp->rq_res.page_len += size;
932         } else
933                 rqstp->rq_res.page_len += size;
934
935         return size;
936 }
937
938 static int nfsd_direct_splice_actor(struct pipe_inode_info *pipe,
939                                     struct splice_desc *sd)
940 {
941         return __splice_from_pipe(pipe, sd, nfsd_splice_actor);
942 }
943
944 static __be32
945 nfsd_vfs_read(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
946               loff_t offset, struct kvec *vec, int vlen, unsigned long *count)
947 {
948         mm_segment_t    oldfs;
949         __be32          err;
950         int             host_err;
951
952         err = nfserr_perm;
953
954         if (file->f_op->splice_read && rqstp->rq_splice_ok) {
955                 struct splice_desc sd = {
956                         .len            = 0,
957                         .total_len      = *count,
958                         .pos            = offset,
959                         .u.data         = rqstp,
960                 };
961
962                 rqstp->rq_next_page = rqstp->rq_respages + 1;
963                 host_err = splice_direct_to_actor(file, &sd, nfsd_direct_splice_actor);
964         } else {
965                 oldfs = get_fs();
966                 set_fs(KERNEL_DS);
967                 host_err = vfs_readv(file, (struct iovec __user *)vec, vlen, &offset);
968                 set_fs(oldfs);
969         }
970
971         if (host_err >= 0) {
972                 nfsdstats.io_read += host_err;
973                 *count = host_err;
974                 err = 0;
975                 fsnotify_access(file);
976         } else 
977                 err = nfserrno(host_err);
978         return err;
979 }
980
981 static void kill_suid(struct dentry *dentry)
982 {
983         struct iattr    ia;
984         ia.ia_valid = ATTR_KILL_SUID | ATTR_KILL_SGID | ATTR_KILL_PRIV;
985
986         mutex_lock(&dentry->d_inode->i_mutex);
987         notify_change(dentry, &ia);
988         mutex_unlock(&dentry->d_inode->i_mutex);
989 }
990
991 /*
992  * Gathered writes: If another process is currently writing to the file,
993  * there's a high chance this is another nfsd (triggered by a bulk write
994  * from a client's biod). Rather than syncing the file with each write
995  * request, we sleep for 10 msec.
996  *
997  * I don't know if this roughly approximates C. Juszak's idea of
998  * gathered writes, but it's a nice and simple solution (IMHO), and it
999  * seems to work:-)
1000  *
1001  * Note: we do this only in the NFSv2 case, since v3 and higher have a
1002  * better tool (separate unstable writes and commits) for solving this
1003  * problem.
1004  */
1005 static int wait_for_concurrent_writes(struct file *file)
1006 {
1007         struct inode *inode = file_inode(file);
1008         static ino_t last_ino;
1009         static dev_t last_dev;
1010         int err = 0;
1011
1012         if (atomic_read(&inode->i_writecount) > 1
1013             || (last_ino == inode->i_ino && last_dev == inode->i_sb->s_dev)) {
1014                 dprintk("nfsd: write defer %d\n", task_pid_nr(current));
1015                 msleep(10);
1016                 dprintk("nfsd: write resume %d\n", task_pid_nr(current));
1017         }
1018
1019         if (inode->i_state & I_DIRTY) {
1020                 dprintk("nfsd: write sync %d\n", task_pid_nr(current));
1021                 err = vfs_fsync(file, 0);
1022         }
1023         last_ino = inode->i_ino;
1024         last_dev = inode->i_sb->s_dev;
1025         return err;
1026 }
1027
1028 static __be32
1029 nfsd_vfs_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
1030                                 loff_t offset, struct kvec *vec, int vlen,
1031                                 unsigned long *cnt, int *stablep)
1032 {
1033         struct svc_export       *exp;
1034         struct dentry           *dentry;
1035         struct inode            *inode;
1036         mm_segment_t            oldfs;
1037         __be32                  err = 0;
1038         int                     host_err;
1039         int                     stable = *stablep;
1040         int                     use_wgather;
1041         loff_t                  pos = offset;
1042
1043         dentry = file->f_path.dentry;
1044         inode = dentry->d_inode;
1045         exp   = fhp->fh_export;
1046
1047         use_wgather = (rqstp->rq_vers == 2) && EX_WGATHER(exp);
1048
1049         if (!EX_ISSYNC(exp))
1050                 stable = 0;
1051
1052         /* Write the data. */
1053         oldfs = get_fs(); set_fs(KERNEL_DS);
1054         host_err = vfs_writev(file, (struct iovec __user *)vec, vlen, &pos);
1055         set_fs(oldfs);
1056         if (host_err < 0)
1057                 goto out_nfserr;
1058         *cnt = host_err;
1059         nfsdstats.io_write += host_err;
1060         fsnotify_modify(file);
1061
1062         /* clear setuid/setgid flag after write */
1063         if (inode->i_mode & (S_ISUID | S_ISGID))
1064                 kill_suid(dentry);
1065
1066         if (stable) {
1067                 if (use_wgather)
1068                         host_err = wait_for_concurrent_writes(file);
1069                 else
1070                         host_err = vfs_fsync_range(file, offset, offset+*cnt, 0);
1071         }
1072
1073 out_nfserr:
1074         dprintk("nfsd: write complete host_err=%d\n", host_err);
1075         if (host_err >= 0)
1076                 err = 0;
1077         else
1078                 err = nfserrno(host_err);
1079         return err;
1080 }
1081
1082 /*
1083  * Read data from a file. count must contain the requested read count
1084  * on entry. On return, *count contains the number of bytes actually read.
1085  * N.B. After this call fhp needs an fh_put
1086  */
1087 __be32 nfsd_read(struct svc_rqst *rqstp, struct svc_fh *fhp,
1088         loff_t offset, struct kvec *vec, int vlen, unsigned long *count)
1089 {
1090         struct file *file;
1091         struct inode *inode;
1092         struct raparms  *ra;
1093         __be32 err;
1094
1095         err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_READ, &file);
1096         if (err)
1097                 return err;
1098
1099         inode = file_inode(file);
1100
1101         /* Get readahead parameters */
1102         ra = nfsd_get_raparms(inode->i_sb->s_dev, inode->i_ino);
1103
1104         if (ra && ra->p_set)
1105                 file->f_ra = ra->p_ra;
1106
1107         err = nfsd_vfs_read(rqstp, fhp, file, offset, vec, vlen, count);
1108
1109         /* Write back readahead params */
1110         if (ra) {
1111                 struct raparm_hbucket *rab = &raparm_hash[ra->p_hindex];
1112                 spin_lock(&rab->pb_lock);
1113                 ra->p_ra = file->f_ra;
1114                 ra->p_set = 1;
1115                 ra->p_count--;
1116                 spin_unlock(&rab->pb_lock);
1117         }
1118
1119         nfsd_close(file);
1120         return err;
1121 }
1122
1123 /* As above, but use the provided file descriptor. */
1124 __be32
1125 nfsd_read_file(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
1126                 loff_t offset, struct kvec *vec, int vlen,
1127                 unsigned long *count)
1128 {
1129         __be32          err;
1130
1131         if (file) {
1132                 err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
1133                                 NFSD_MAY_READ|NFSD_MAY_OWNER_OVERRIDE);
1134                 if (err)
1135                         goto out;
1136                 err = nfsd_vfs_read(rqstp, fhp, file, offset, vec, vlen, count);
1137         } else /* Note file may still be NULL in NFSv4 special stateid case: */
1138                 err = nfsd_read(rqstp, fhp, offset, vec, vlen, count);
1139 out:
1140         return err;
1141 }
1142
1143 /*
1144  * Write data to a file.
1145  * The stable flag requests synchronous writes.
1146  * N.B. After this call fhp needs an fh_put
1147  */
1148 __be32
1149 nfsd_write(struct svc_rqst *rqstp, struct svc_fh *fhp, struct file *file,
1150                 loff_t offset, struct kvec *vec, int vlen, unsigned long *cnt,
1151                 int *stablep)
1152 {
1153         __be32                  err = 0;
1154
1155         if (file) {
1156                 err = nfsd_permission(rqstp, fhp->fh_export, fhp->fh_dentry,
1157                                 NFSD_MAY_WRITE|NFSD_MAY_OWNER_OVERRIDE);
1158                 if (err)
1159                         goto out;
1160                 err = nfsd_vfs_write(rqstp, fhp, file, offset, vec, vlen, cnt,
1161                                 stablep);
1162         } else {
1163                 err = nfsd_open(rqstp, fhp, S_IFREG, NFSD_MAY_WRITE, &file);
1164                 if (err)
1165                         goto out;
1166
1167                 if (cnt)
1168                         err = nfsd_vfs_write(rqstp, fhp, file, offset, vec, vlen,
1169                                              cnt, stablep);
1170                 nfsd_close(file);
1171         }
1172 out:
1173         return err;
1174 }
1175
1176 #ifdef CONFIG_NFSD_V3
1177 /*
1178  * Commit all pending writes to stable storage.
1179  *
1180  * Note: we only guarantee that data that lies within the range specified
1181  * by the 'offset' and 'count' parameters will be synced.
1182  *
1183  * Unfortunately we cannot lock the file to make sure we return full WCC
1184  * data to the client, as locking happens lower down in the filesystem.
1185  */
1186 __be32
1187 nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp,
1188                loff_t offset, unsigned long count)
1189 {
1190         struct file     *file;
1191         loff_t          end = LLONG_MAX;
1192         __be32          err = nfserr_inval;
1193
1194         if (offset < 0)
1195                 goto out;
1196         if (count != 0) {
1197                 end = offset + (loff_t)count - 1;
1198                 if (end < offset)
1199                         goto out;
1200         }
1201
1202         err = nfsd_open(rqstp, fhp, S_IFREG,
1203                         NFSD_MAY_WRITE|NFSD_MAY_NOT_BREAK_LEASE, &file);
1204         if (err)
1205                 goto out;
1206         if (EX_ISSYNC(fhp->fh_export)) {
1207                 int err2 = vfs_fsync_range(file, offset, end, 0);
1208
1209                 if (err2 != -EINVAL)
1210                         err = nfserrno(err2);
1211                 else
1212                         err = nfserr_notsupp;
1213         }
1214
1215         nfsd_close(file);
1216 out:
1217         return err;
1218 }
1219 #endif /* CONFIG_NFSD_V3 */
1220
1221 static __be32
1222 nfsd_create_setattr(struct svc_rqst *rqstp, struct svc_fh *resfhp,
1223                         struct iattr *iap)
1224 {
1225         /*
1226          * Mode has already been set earlier in create:
1227          */
1228         iap->ia_valid &= ~ATTR_MODE;
1229         /*
1230          * Setting uid/gid works only for root.  Irix appears to
1231          * send along the gid on create when it tries to implement
1232          * setgid directories via NFS:
1233          */
1234         if (!uid_eq(current_fsuid(), GLOBAL_ROOT_UID))
1235                 iap->ia_valid &= ~(ATTR_UID|ATTR_GID);
1236         if (iap->ia_valid)
1237                 return nfsd_setattr(rqstp, resfhp, iap, 0, (time_t)0);
1238         return 0;
1239 }
1240
1241 /* HPUX client sometimes creates a file in mode 000, and sets size to 0.
1242  * setting size to 0 may fail for some specific file systems by the permission
1243  * checking which requires WRITE permission but the mode is 000.
1244  * we ignore the resizing(to 0) on the just new created file, since the size is
1245  * 0 after file created.
1246  *
1247  * call this only after vfs_create() is called.
1248  * */
1249 static void
1250 nfsd_check_ignore_resizing(struct iattr *iap)
1251 {
1252         if ((iap->ia_valid & ATTR_SIZE) && (iap->ia_size == 0))
1253                 iap->ia_valid &= ~ATTR_SIZE;
1254 }
1255
1256 /*
1257  * Create a file (regular, directory, device, fifo); UNIX sockets 
1258  * not yet implemented.
1259  * If the response fh has been verified, the parent directory should
1260  * already be locked. Note that the parent directory is left locked.
1261  *
1262  * N.B. Every call to nfsd_create needs an fh_put for _both_ fhp and resfhp
1263  */
1264 __be32
1265 nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
1266                 char *fname, int flen, struct iattr *iap,
1267                 int type, dev_t rdev, struct svc_fh *resfhp)
1268 {
1269         struct dentry   *dentry, *dchild = NULL;
1270         struct inode    *dirp;
1271         __be32          err;
1272         __be32          err2;
1273         int             host_err;
1274
1275         err = nfserr_perm;
1276         if (!flen)
1277                 goto out;
1278         err = nfserr_exist;
1279         if (isdotent(fname, flen))
1280                 goto out;
1281
1282         err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
1283         if (err)
1284                 goto out;
1285
1286         dentry = fhp->fh_dentry;
1287         dirp = dentry->d_inode;
1288
1289         err = nfserr_notdir;
1290         if (!dirp->i_op->lookup)
1291                 goto out;
1292         /*
1293          * Check whether the response file handle has been verified yet.
1294          * If it has, the parent directory should already be locked.
1295          */
1296         if (!resfhp->fh_dentry) {
1297                 host_err = fh_want_write(fhp);
1298                 if (host_err)
1299                         goto out_nfserr;
1300
1301                 /* called from nfsd_proc_mkdir, or possibly nfsd3_proc_create */
1302                 fh_lock_nested(fhp, I_MUTEX_PARENT);
1303                 dchild = lookup_one_len(fname, dentry, flen);
1304                 host_err = PTR_ERR(dchild);
1305                 if (IS_ERR(dchild))
1306                         goto out_nfserr;
1307                 err = fh_compose(resfhp, fhp->fh_export, dchild, fhp);
1308                 if (err)
1309                         goto out;
1310         } else {
1311                 /* called from nfsd_proc_create */
1312                 dchild = dget(resfhp->fh_dentry);
1313                 if (!fhp->fh_locked) {
1314                         /* not actually possible */
1315                         printk(KERN_ERR
1316                                 "nfsd_create: parent %s/%s not locked!\n",
1317                                 dentry->d_parent->d_name.name,
1318                                 dentry->d_name.name);
1319                         err = nfserr_io;
1320                         goto out;
1321                 }
1322         }
1323         /*
1324          * Make sure the child dentry is still negative ...
1325          */
1326         err = nfserr_exist;
1327         if (dchild->d_inode) {
1328                 dprintk("nfsd_create: dentry %s/%s not negative!\n",
1329                         dentry->d_name.name, dchild->d_name.name);
1330                 goto out; 
1331         }
1332
1333         if (!(iap->ia_valid & ATTR_MODE))
1334                 iap->ia_mode = 0;
1335         iap->ia_mode = (iap->ia_mode & S_IALLUGO) | type;
1336
1337         err = nfserr_inval;
1338         if (!S_ISREG(type) && !S_ISDIR(type) && !special_file(type)) {
1339                 printk(KERN_WARNING "nfsd: bad file type %o in nfsd_create\n",
1340                        type);
1341                 goto out;
1342         }
1343
1344         /*
1345          * Get the dir op function pointer.
1346          */
1347         err = 0;
1348         host_err = 0;
1349         switch (type) {
1350         case S_IFREG:
1351                 host_err = vfs_create(dirp, dchild, iap->ia_mode, true);
1352                 if (!host_err)
1353                         nfsd_check_ignore_resizing(iap);
1354                 break;
1355         case S_IFDIR:
1356                 host_err = vfs_mkdir(dirp, dchild, iap->ia_mode);
1357                 break;
1358         case S_IFCHR:
1359         case S_IFBLK:
1360         case S_IFIFO:
1361         case S_IFSOCK:
1362                 host_err = vfs_mknod(dirp, dchild, iap->ia_mode, rdev);
1363                 break;
1364         }
1365         if (host_err < 0)
1366                 goto out_nfserr;
1367
1368         err = nfsd_create_setattr(rqstp, resfhp, iap);
1369
1370         /*
1371          * nfsd_setattr already committed the child.  Transactional filesystems
1372          * had a chance to commit changes for both parent and child
1373          * simultaneously making the following commit_metadata a noop.
1374          */
1375         err2 = nfserrno(commit_metadata(fhp));
1376         if (err2)
1377                 err = err2;
1378         /*
1379          * Update the file handle to get the new inode info.
1380          */
1381         if (!err)
1382                 err = fh_update(resfhp);
1383 out:
1384         if (dchild && !IS_ERR(dchild))
1385                 dput(dchild);
1386         return err;
1387
1388 out_nfserr:
1389         err = nfserrno(host_err);
1390         goto out;
1391 }
1392
1393 #ifdef CONFIG_NFSD_V3
1394
1395 static inline int nfsd_create_is_exclusive(int createmode)
1396 {
1397         return createmode == NFS3_CREATE_EXCLUSIVE
1398                || createmode == NFS4_CREATE_EXCLUSIVE4_1;
1399 }
1400
1401 /*
1402  * NFSv3 and NFSv4 version of nfsd_create
1403  */
1404 __be32
1405 do_nfsd_create(struct svc_rqst *rqstp, struct svc_fh *fhp,
1406                 char *fname, int flen, struct iattr *iap,
1407                 struct svc_fh *resfhp, int createmode, u32 *verifier,
1408                 bool *truncp, bool *created)
1409 {
1410         struct dentry   *dentry, *dchild = NULL;
1411         struct inode    *dirp;
1412         __be32          err;
1413         int             host_err;
1414         __u32           v_mtime=0, v_atime=0;
1415
1416         err = nfserr_perm;
1417         if (!flen)
1418                 goto out;
1419         err = nfserr_exist;
1420         if (isdotent(fname, flen))
1421                 goto out;
1422         if (!(iap->ia_valid & ATTR_MODE))
1423                 iap->ia_mode = 0;
1424         err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_EXEC);
1425         if (err)
1426                 goto out;
1427
1428         dentry = fhp->fh_dentry;
1429         dirp = dentry->d_inode;
1430
1431         /* Get all the sanity checks out of the way before
1432          * we lock the parent. */
1433         err = nfserr_notdir;
1434         if (!dirp->i_op->lookup)
1435                 goto out;
1436
1437         host_err = fh_want_write(fhp);
1438         if (host_err)
1439                 goto out_nfserr;
1440
1441         fh_lock_nested(fhp, I_MUTEX_PARENT);
1442
1443         /*
1444          * Compose the response file handle.
1445          */
1446         dchild = lookup_one_len(fname, dentry, flen);
1447         host_err = PTR_ERR(dchild);
1448         if (IS_ERR(dchild))
1449                 goto out_nfserr;
1450
1451         /* If file doesn't exist, check for permissions to create one */
1452         if (!dchild->d_inode) {
1453                 err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
1454                 if (err)
1455                         goto out;
1456         }
1457
1458         err = fh_compose(resfhp, fhp->fh_export, dchild, fhp);
1459         if (err)
1460                 goto out;
1461
1462         if (nfsd_create_is_exclusive(createmode)) {
1463                 /* solaris7 gets confused (bugid 4218508) if these have
1464                  * the high bit set, so just clear the high bits. If this is
1465                  * ever changed to use different attrs for storing the
1466                  * verifier, then do_open_lookup() will also need to be fixed
1467                  * accordingly.
1468                  */
1469                 v_mtime = verifier[0]&0x7fffffff;
1470                 v_atime = verifier[1]&0x7fffffff;
1471         }
1472         
1473         if (dchild->d_inode) {
1474                 err = 0;
1475
1476                 switch (createmode) {
1477                 case NFS3_CREATE_UNCHECKED:
1478                         if (! S_ISREG(dchild->d_inode->i_mode))
1479                                 goto out;
1480                         else if (truncp) {
1481                                 /* in nfsv4, we need to treat this case a little
1482                                  * differently.  we don't want to truncate the
1483                                  * file now; this would be wrong if the OPEN
1484                                  * fails for some other reason.  furthermore,
1485                                  * if the size is nonzero, we should ignore it
1486                                  * according to spec!
1487                                  */
1488                                 *truncp = (iap->ia_valid & ATTR_SIZE) && !iap->ia_size;
1489                         }
1490                         else {
1491                                 iap->ia_valid &= ATTR_SIZE;
1492                                 goto set_attr;
1493                         }
1494                         break;
1495                 case NFS3_CREATE_EXCLUSIVE:
1496                         if (   dchild->d_inode->i_mtime.tv_sec == v_mtime
1497                             && dchild->d_inode->i_atime.tv_sec == v_atime
1498                             && dchild->d_inode->i_size  == 0 ) {
1499                                 if (created)
1500                                         *created = 1;
1501                                 break;
1502                         }
1503                 case NFS4_CREATE_EXCLUSIVE4_1:
1504                         if (   dchild->d_inode->i_mtime.tv_sec == v_mtime
1505                             && dchild->d_inode->i_atime.tv_sec == v_atime
1506                             && dchild->d_inode->i_size  == 0 ) {
1507                                 if (created)
1508                                         *created = 1;
1509                                 goto set_attr;
1510                         }
1511                          /* fallthru */
1512                 case NFS3_CREATE_GUARDED:
1513                         err = nfserr_exist;
1514                 }
1515                 fh_drop_write(fhp);
1516                 goto out;
1517         }
1518
1519         host_err = vfs_create(dirp, dchild, iap->ia_mode, true);
1520         if (host_err < 0) {
1521                 fh_drop_write(fhp);
1522                 goto out_nfserr;
1523         }
1524         if (created)
1525                 *created = 1;
1526
1527         nfsd_check_ignore_resizing(iap);
1528
1529         if (nfsd_create_is_exclusive(createmode)) {
1530                 /* Cram the verifier into atime/mtime */
1531                 iap->ia_valid = ATTR_MTIME|ATTR_ATIME
1532                         | ATTR_MTIME_SET|ATTR_ATIME_SET;
1533                 /* XXX someone who knows this better please fix it for nsec */ 
1534                 iap->ia_mtime.tv_sec = v_mtime;
1535                 iap->ia_atime.tv_sec = v_atime;
1536                 iap->ia_mtime.tv_nsec = 0;
1537                 iap->ia_atime.tv_nsec = 0;
1538         }
1539
1540  set_attr:
1541         err = nfsd_create_setattr(rqstp, resfhp, iap);
1542
1543         /*
1544          * nfsd_setattr already committed the child (and possibly also the parent).
1545          */
1546         if (!err)
1547                 err = nfserrno(commit_metadata(fhp));
1548
1549         /*
1550          * Update the filehandle to get the new inode info.
1551          */
1552         if (!err)
1553                 err = fh_update(resfhp);
1554
1555  out:
1556         fh_unlock(fhp);
1557         if (dchild && !IS_ERR(dchild))
1558                 dput(dchild);
1559         fh_drop_write(fhp);
1560         return err;
1561  
1562  out_nfserr:
1563         err = nfserrno(host_err);
1564         goto out;
1565 }
1566 #endif /* CONFIG_NFSD_V3 */
1567
1568 /*
1569  * Read a symlink. On entry, *lenp must contain the maximum path length that
1570  * fits into the buffer. On return, it contains the true length.
1571  * N.B. After this call fhp needs an fh_put
1572  */
1573 __be32
1574 nfsd_readlink(struct svc_rqst *rqstp, struct svc_fh *fhp, char *buf, int *lenp)
1575 {
1576         struct inode    *inode;
1577         mm_segment_t    oldfs;
1578         __be32          err;
1579         int             host_err;
1580         struct path path;
1581
1582         err = fh_verify(rqstp, fhp, S_IFLNK, NFSD_MAY_NOP);
1583         if (err)
1584                 goto out;
1585
1586         path.mnt = fhp->fh_export->ex_path.mnt;
1587         path.dentry = fhp->fh_dentry;
1588         inode = path.dentry->d_inode;
1589
1590         err = nfserr_inval;
1591         if (!inode->i_op->readlink)
1592                 goto out;
1593
1594         touch_atime(&path);
1595         /* N.B. Why does this call need a get_fs()??
1596          * Remove the set_fs and watch the fireworks:-) --okir
1597          */
1598
1599         oldfs = get_fs(); set_fs(KERNEL_DS);
1600         host_err = inode->i_op->readlink(path.dentry, (char __user *)buf, *lenp);
1601         set_fs(oldfs);
1602
1603         if (host_err < 0)
1604                 goto out_nfserr;
1605         *lenp = host_err;
1606         err = 0;
1607 out:
1608         return err;
1609
1610 out_nfserr:
1611         err = nfserrno(host_err);
1612         goto out;
1613 }
1614
1615 /*
1616  * Create a symlink and look up its inode
1617  * N.B. After this call _both_ fhp and resfhp need an fh_put
1618  */
1619 __be32
1620 nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,
1621                                 char *fname, int flen,
1622                                 char *path,  int plen,
1623                                 struct svc_fh *resfhp,
1624                                 struct iattr *iap)
1625 {
1626         struct dentry   *dentry, *dnew;
1627         __be32          err, cerr;
1628         int             host_err;
1629
1630         err = nfserr_noent;
1631         if (!flen || !plen)
1632                 goto out;
1633         err = nfserr_exist;
1634         if (isdotent(fname, flen))
1635                 goto out;
1636
1637         err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_CREATE);
1638         if (err)
1639                 goto out;
1640
1641         host_err = fh_want_write(fhp);
1642         if (host_err)
1643                 goto out_nfserr;
1644
1645         fh_lock(fhp);
1646         dentry = fhp->fh_dentry;
1647         dnew = lookup_one_len(fname, dentry, flen);
1648         host_err = PTR_ERR(dnew);
1649         if (IS_ERR(dnew))
1650                 goto out_nfserr;
1651
1652         if (unlikely(path[plen] != 0)) {
1653                 char *path_alloced = kmalloc(plen+1, GFP_KERNEL);
1654                 if (path_alloced == NULL)
1655                         host_err = -ENOMEM;
1656                 else {
1657                         strncpy(path_alloced, path, plen);
1658                         path_alloced[plen] = 0;
1659                         host_err = vfs_symlink(dentry->d_inode, dnew, path_alloced);
1660                         kfree(path_alloced);
1661                 }
1662         } else
1663                 host_err = vfs_symlink(dentry->d_inode, dnew, path);
1664         err = nfserrno(host_err);
1665         if (!err)
1666                 err = nfserrno(commit_metadata(fhp));
1667         fh_unlock(fhp);
1668
1669         fh_drop_write(fhp);
1670
1671         cerr = fh_compose(resfhp, fhp->fh_export, dnew, fhp);
1672         dput(dnew);
1673         if (err==0) err = cerr;
1674 out:
1675         return err;
1676
1677 out_nfserr:
1678         err = nfserrno(host_err);
1679         goto out;
1680 }
1681
1682 /*
1683  * Create a hardlink
1684  * N.B. After this call _both_ ffhp and tfhp need an fh_put
1685  */
1686 __be32
1687 nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,
1688                                 char *name, int len, struct svc_fh *tfhp)
1689 {
1690         struct dentry   *ddir, *dnew, *dold;
1691         struct inode    *dirp;
1692         __be32          err;
1693         int             host_err;
1694
1695         err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_CREATE);
1696         if (err)
1697                 goto out;
1698         err = fh_verify(rqstp, tfhp, 0, NFSD_MAY_NOP);
1699         if (err)
1700                 goto out;
1701         err = nfserr_isdir;
1702         if (S_ISDIR(tfhp->fh_dentry->d_inode->i_mode))
1703                 goto out;
1704         err = nfserr_perm;
1705         if (!len)
1706                 goto out;
1707         err = nfserr_exist;
1708         if (isdotent(name, len))
1709                 goto out;
1710
1711         host_err = fh_want_write(tfhp);
1712         if (host_err) {
1713                 err = nfserrno(host_err);
1714                 goto out;
1715         }
1716
1717         fh_lock_nested(ffhp, I_MUTEX_PARENT);
1718         ddir = ffhp->fh_dentry;
1719         dirp = ddir->d_inode;
1720
1721         dnew = lookup_one_len(name, ddir, len);
1722         host_err = PTR_ERR(dnew);
1723         if (IS_ERR(dnew))
1724                 goto out_nfserr;
1725
1726         dold = tfhp->fh_dentry;
1727
1728         err = nfserr_noent;
1729         if (!dold->d_inode)
1730                 goto out_dput;
1731         host_err = nfsd_break_lease(dold->d_inode);
1732         if (host_err) {
1733                 err = nfserrno(host_err);
1734                 goto out_dput;
1735         }
1736         host_err = vfs_link(dold, dirp, dnew);
1737         if (!host_err) {
1738                 err = nfserrno(commit_metadata(ffhp));
1739                 if (!err)
1740                         err = nfserrno(commit_metadata(tfhp));
1741         } else {
1742                 if (host_err == -EXDEV && rqstp->rq_vers == 2)
1743                         err = nfserr_acces;
1744                 else
1745                         err = nfserrno(host_err);
1746         }
1747 out_dput:
1748         dput(dnew);
1749 out_unlock:
1750         fh_unlock(ffhp);
1751         fh_drop_write(tfhp);
1752 out:
1753         return err;
1754
1755 out_nfserr:
1756         err = nfserrno(host_err);
1757         goto out_unlock;
1758 }
1759
1760 /*
1761  * Rename a file
1762  * N.B. After this call _both_ ffhp and tfhp need an fh_put
1763  */
1764 __be32
1765 nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,
1766                             struct svc_fh *tfhp, char *tname, int tlen)
1767 {
1768         struct dentry   *fdentry, *tdentry, *odentry, *ndentry, *trap;
1769         struct inode    *fdir, *tdir;
1770         __be32          err;
1771         int             host_err;
1772
1773         err = fh_verify(rqstp, ffhp, S_IFDIR, NFSD_MAY_REMOVE);
1774         if (err)
1775                 goto out;
1776         err = fh_verify(rqstp, tfhp, S_IFDIR, NFSD_MAY_CREATE);
1777         if (err)
1778                 goto out;
1779
1780         fdentry = ffhp->fh_dentry;
1781         fdir = fdentry->d_inode;
1782
1783         tdentry = tfhp->fh_dentry;
1784         tdir = tdentry->d_inode;
1785
1786         err = nfserr_perm;
1787         if (!flen || isdotent(fname, flen) || !tlen || isdotent(tname, tlen))
1788                 goto out;
1789
1790         host_err = fh_want_write(ffhp);
1791         if (host_err) {
1792                 err = nfserrno(host_err);
1793                 goto out;
1794         }
1795
1796         /* cannot use fh_lock as we need deadlock protective ordering
1797          * so do it by hand */
1798         trap = lock_rename(tdentry, fdentry);
1799         ffhp->fh_locked = tfhp->fh_locked = 1;
1800         fill_pre_wcc(ffhp);
1801         fill_pre_wcc(tfhp);
1802
1803         odentry = lookup_one_len(fname, fdentry, flen);
1804         host_err = PTR_ERR(odentry);
1805         if (IS_ERR(odentry))
1806                 goto out_nfserr;
1807
1808         host_err = -ENOENT;
1809         if (!odentry->d_inode)
1810                 goto out_dput_old;
1811         host_err = -EINVAL;
1812         if (odentry == trap)
1813                 goto out_dput_old;
1814
1815         ndentry = lookup_one_len(tname, tdentry, tlen);
1816         host_err = PTR_ERR(ndentry);
1817         if (IS_ERR(ndentry))
1818                 goto out_dput_old;
1819         host_err = -ENOTEMPTY;
1820         if (ndentry == trap)
1821                 goto out_dput_new;
1822
1823         host_err = -EXDEV;
1824         if (ffhp->fh_export->ex_path.mnt != tfhp->fh_export->ex_path.mnt)
1825                 goto out_dput_new;
1826         if (ffhp->fh_export->ex_path.dentry != tfhp->fh_export->ex_path.dentry)
1827                 goto out_dput_new;
1828
1829         host_err = nfsd_break_lease(odentry->d_inode);
1830         if (host_err)
1831                 goto out_dput_new;
1832         if (ndentry->d_inode) {
1833                 host_err = nfsd_break_lease(ndentry->d_inode);
1834                 if (host_err)
1835                         goto out_dput_new;
1836         }
1837         host_err = vfs_rename(fdir, odentry, tdir, ndentry);
1838         if (!host_err) {
1839                 host_err = commit_metadata(tfhp);
1840                 if (!host_err)
1841                         host_err = commit_metadata(ffhp);
1842         }
1843  out_dput_new:
1844         dput(ndentry);
1845  out_dput_old:
1846         dput(odentry);
1847  out_nfserr:
1848         err = nfserrno(host_err);
1849
1850         /* we cannot reply on fh_unlock on the two filehandles,
1851          * as that would do the wrong thing if the two directories
1852          * were the same, so again we do it by hand
1853          */
1854         fill_post_wcc(ffhp);
1855         fill_post_wcc(tfhp);
1856         unlock_rename(tdentry, fdentry);
1857         ffhp->fh_locked = tfhp->fh_locked = 0;
1858         fh_drop_write(ffhp);
1859
1860 out:
1861         return err;
1862 }
1863
1864 /*
1865  * Unlink a file or directory
1866  * N.B. After this call fhp needs an fh_put
1867  */
1868 __be32
1869 nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
1870                                 char *fname, int flen)
1871 {
1872         struct dentry   *dentry, *rdentry;
1873         struct inode    *dirp;
1874         __be32          err;
1875         int             host_err;
1876
1877         err = nfserr_acces;
1878         if (!flen || isdotent(fname, flen))
1879                 goto out;
1880         err = fh_verify(rqstp, fhp, S_IFDIR, NFSD_MAY_REMOVE);
1881         if (err)
1882                 goto out;
1883
1884         host_err = fh_want_write(fhp);
1885         if (host_err)
1886                 goto out_nfserr;
1887
1888         fh_lock_nested(fhp, I_MUTEX_PARENT);
1889         dentry = fhp->fh_dentry;
1890         dirp = dentry->d_inode;
1891
1892         rdentry = lookup_one_len(fname, dentry, flen);
1893         host_err = PTR_ERR(rdentry);
1894         if (IS_ERR(rdentry))
1895                 goto out_nfserr;
1896
1897         if (!rdentry->d_inode) {
1898                 dput(rdentry);
1899                 err = nfserr_noent;
1900                 goto out;
1901         }
1902
1903         if (!type)
1904                 type = rdentry->d_inode->i_mode & S_IFMT;
1905
1906         host_err = nfsd_break_lease(rdentry->d_inode);
1907         if (host_err)
1908                 goto out_put;
1909         if (type != S_IFDIR)
1910                 host_err = vfs_unlink(dirp, rdentry);
1911         else
1912                 host_err = vfs_rmdir(dirp, rdentry);
1913         if (!host_err)
1914                 host_err = commit_metadata(fhp);
1915 out_put:
1916         dput(rdentry);
1917
1918 out_nfserr:
1919         err = nfserrno(host_err);
1920 out:
1921         return err;
1922 }
1923
1924 /*
1925  * We do this buffering because we must not call back into the file
1926  * system's ->lookup() method from the filldir callback. That may well
1927  * deadlock a number of file systems.
1928  *
1929  * This is based heavily on the implementation of same in XFS.
1930  */
1931 struct buffered_dirent {
1932         u64             ino;
1933         loff_t          offset;
1934         int             namlen;
1935         unsigned int    d_type;
1936         char            name[];
1937 };
1938
1939 struct readdir_data {
1940         char            *dirent;
1941         size_t          used;
1942         int             full;
1943 };
1944
1945 static int nfsd_buffered_filldir(void *__buf, const char *name, int namlen,
1946                                  loff_t offset, u64 ino, unsigned int d_type)
1947 {
1948         struct readdir_data *buf = __buf;
1949         struct buffered_dirent *de = (void *)(buf->dirent + buf->used);
1950         unsigned int reclen;
1951
1952         reclen = ALIGN(sizeof(struct buffered_dirent) + namlen, sizeof(u64));
1953         if (buf->used + reclen > PAGE_SIZE) {
1954                 buf->full = 1;
1955                 return -EINVAL;
1956         }
1957
1958         de->namlen = namlen;
1959         de->offset = offset;
1960         de->ino = ino;
1961         de->d_type = d_type;
1962         memcpy(de->name, name, namlen);
1963         buf->used += reclen;
1964
1965         return 0;
1966 }
1967
1968 static __be32 nfsd_buffered_readdir(struct file *file, filldir_t func,
1969                                     struct readdir_cd *cdp, loff_t *offsetp)
1970 {
1971         struct readdir_data buf;
1972         struct buffered_dirent *de;
1973         int host_err;
1974         int size;
1975         loff_t offset;
1976
1977         buf.dirent = (void *)__get_free_page(GFP_KERNEL);
1978         if (!buf.dirent)
1979                 return nfserrno(-ENOMEM);
1980
1981         offset = *offsetp;
1982
1983         while (1) {
1984                 struct inode *dir_inode = file_inode(file);
1985                 unsigned int reclen;
1986
1987                 cdp->err = nfserr_eof; /* will be cleared on successful read */
1988                 buf.used = 0;
1989                 buf.full = 0;
1990
1991                 host_err = vfs_readdir(file, nfsd_buffered_filldir, &buf);
1992                 if (buf.full)
1993                         host_err = 0;
1994
1995                 if (host_err < 0)
1996                         break;
1997
1998                 size = buf.used;
1999
2000                 if (!size)
2001                         break;
2002
2003                 /*
2004                  * Various filldir functions may end up calling back into
2005                  * lookup_one_len() and the file system's ->lookup() method.
2006                  * These expect i_mutex to be held, as it would within readdir.
2007                  */
2008                 host_err = mutex_lock_killable(&dir_inode->i_mutex);
2009                 if (host_err)
2010                         break;
2011
2012                 de = (struct buffered_dirent *)buf.dirent;
2013                 while (size > 0) {
2014                         offset = de->offset;
2015
2016                         if (func(cdp, de->name, de->namlen, de->offset,
2017                                  de->ino, de->d_type))
2018                                 break;
2019
2020                         if (cdp->err != nfs_ok)
2021                                 break;
2022
2023                         reclen = ALIGN(sizeof(*de) + de->namlen,
2024                                        sizeof(u64));
2025                         size -= reclen;
2026                         de = (struct buffered_dirent *)((char *)de + reclen);
2027                 }
2028                 mutex_unlock(&dir_inode->i_mutex);
2029                 if (size > 0) /* We bailed out early */
2030                         break;
2031
2032                 offset = vfs_llseek(file, 0, SEEK_CUR);
2033         }
2034
2035         free_page((unsigned long)(buf.dirent));
2036
2037         if (host_err)
2038                 return nfserrno(host_err);
2039
2040         *offsetp = offset;
2041         return cdp->err;
2042 }
2043
2044 /*
2045  * Read entries from a directory.
2046  * The  NFSv3/4 verifier we ignore for now.
2047  */
2048 __be32
2049 nfsd_readdir(struct svc_rqst *rqstp, struct svc_fh *fhp, loff_t *offsetp, 
2050              struct readdir_cd *cdp, filldir_t func)
2051 {
2052         __be32          err;
2053         struct file     *file;
2054         loff_t          offset = *offsetp;
2055         int             may_flags = NFSD_MAY_READ;
2056
2057         /* NFSv2 only supports 32 bit cookies */
2058         if (rqstp->rq_vers > 2)
2059                 may_flags |= NFSD_MAY_64BIT_COOKIE;
2060
2061         err = nfsd_open(rqstp, fhp, S_IFDIR, may_flags, &file);
2062         if (err)
2063                 goto out;
2064
2065         offset = vfs_llseek(file, offset, SEEK_SET);
2066         if (offset < 0) {
2067                 err = nfserrno((int)offset);
2068                 goto out_close;
2069         }
2070
2071         err = nfsd_buffered_readdir(file, func, cdp, offsetp);
2072
2073         if (err == nfserr_eof || err == nfserr_toosmall)
2074                 err = nfs_ok; /* can still be found in ->err */
2075 out_close:
2076         nfsd_close(file);
2077 out:
2078         return err;
2079 }
2080
2081 /*
2082  * Get file system stats
2083  * N.B. After this call fhp needs an fh_put
2084  */
2085 __be32
2086 nfsd_statfs(struct svc_rqst *rqstp, struct svc_fh *fhp, struct kstatfs *stat, int access)
2087 {
2088         __be32 err;
2089
2090         err = fh_verify(rqstp, fhp, 0, NFSD_MAY_NOP | access);
2091         if (!err) {
2092                 struct path path = {
2093                         .mnt    = fhp->fh_export->ex_path.mnt,
2094                         .dentry = fhp->fh_dentry,
2095                 };
2096                 if (vfs_statfs(&path, stat))
2097                         err = nfserr_io;
2098         }
2099         return err;
2100 }
2101
2102 static int exp_rdonly(struct svc_rqst *rqstp, struct svc_export *exp)
2103 {
2104         return nfsexp_flags(rqstp, exp) & NFSEXP_READONLY;
2105 }
2106
2107 /*
2108  * Check for a user's access permissions to this inode.
2109  */
2110 __be32
2111 nfsd_permission(struct svc_rqst *rqstp, struct svc_export *exp,
2112                                         struct dentry *dentry, int acc)
2113 {
2114         struct inode    *inode = dentry->d_inode;
2115         int             err;
2116
2117         if ((acc & NFSD_MAY_MASK) == NFSD_MAY_NOP)
2118                 return 0;
2119 #if 0
2120         dprintk("nfsd: permission 0x%x%s%s%s%s%s%s%s mode 0%o%s%s%s\n",
2121                 acc,
2122                 (acc & NFSD_MAY_READ)?  " read"  : "",
2123                 (acc & NFSD_MAY_WRITE)? " write" : "",
2124                 (acc & NFSD_MAY_EXEC)?  " exec"  : "",
2125                 (acc & NFSD_MAY_SATTR)? " sattr" : "",
2126                 (acc & NFSD_MAY_TRUNC)? " trunc" : "",
2127                 (acc & NFSD_MAY_LOCK)?  " lock"  : "",
2128                 (acc & NFSD_MAY_OWNER_OVERRIDE)? " owneroverride" : "",
2129                 inode->i_mode,
2130                 IS_IMMUTABLE(inode)?    " immut" : "",
2131                 IS_APPEND(inode)?       " append" : "",
2132                 __mnt_is_readonly(exp->ex_path.mnt)?    " ro" : "");
2133         dprintk("      owner %d/%d user %d/%d\n",
2134                 inode->i_uid, inode->i_gid, current_fsuid(), current_fsgid());
2135 #endif
2136
2137         /* Normally we reject any write/sattr etc access on a read-only file
2138          * system.  But if it is IRIX doing check on write-access for a 
2139          * device special file, we ignore rofs.
2140          */
2141         if (!(acc & NFSD_MAY_LOCAL_ACCESS))
2142                 if (acc & (NFSD_MAY_WRITE | NFSD_MAY_SATTR | NFSD_MAY_TRUNC)) {
2143                         if (exp_rdonly(rqstp, exp) ||
2144                             __mnt_is_readonly(exp->ex_path.mnt))
2145                                 return nfserr_rofs;
2146                         if (/* (acc & NFSD_MAY_WRITE) && */ IS_IMMUTABLE(inode))
2147                                 return nfserr_perm;
2148                 }
2149         if ((acc & NFSD_MAY_TRUNC) && IS_APPEND(inode))
2150                 return nfserr_perm;
2151
2152         if (acc & NFSD_MAY_LOCK) {
2153                 /* If we cannot rely on authentication in NLM requests,
2154                  * just allow locks, otherwise require read permission, or
2155                  * ownership
2156                  */
2157                 if (exp->ex_flags & NFSEXP_NOAUTHNLM)
2158                         return 0;
2159                 else
2160                         acc = NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE;
2161         }
2162         /*
2163          * The file owner always gets access permission for accesses that
2164          * would normally be checked at open time. This is to make
2165          * file access work even when the client has done a fchmod(fd, 0).
2166          *
2167          * However, `cp foo bar' should fail nevertheless when bar is
2168          * readonly. A sensible way to do this might be to reject all
2169          * attempts to truncate a read-only file, because a creat() call
2170          * always implies file truncation.
2171          * ... but this isn't really fair.  A process may reasonably call
2172          * ftruncate on an open file descriptor on a file with perm 000.
2173          * We must trust the client to do permission checking - using "ACCESS"
2174          * with NFSv3.
2175          */
2176         if ((acc & NFSD_MAY_OWNER_OVERRIDE) &&
2177             uid_eq(inode->i_uid, current_fsuid()))
2178                 return 0;
2179
2180         /* This assumes  NFSD_MAY_{READ,WRITE,EXEC} == MAY_{READ,WRITE,EXEC} */
2181         err = inode_permission(inode, acc & (MAY_READ|MAY_WRITE|MAY_EXEC));
2182
2183         /* Allow read access to binaries even when mode 111 */
2184         if (err == -EACCES && S_ISREG(inode->i_mode) &&
2185              (acc == (NFSD_MAY_READ | NFSD_MAY_OWNER_OVERRIDE) ||
2186               acc == (NFSD_MAY_READ | NFSD_MAY_READ_IF_EXEC)))
2187                 err = inode_permission(inode, MAY_EXEC);
2188
2189         return err? nfserrno(err) : 0;
2190 }
2191
2192 void
2193 nfsd_racache_shutdown(void)
2194 {
2195         struct raparms *raparm, *last_raparm;
2196         unsigned int i;
2197
2198         dprintk("nfsd: freeing readahead buffers.\n");
2199
2200         for (i = 0; i < RAPARM_HASH_SIZE; i++) {
2201                 raparm = raparm_hash[i].pb_head;
2202                 while(raparm) {
2203                         last_raparm = raparm;
2204                         raparm = raparm->p_next;
2205                         kfree(last_raparm);
2206                 }
2207                 raparm_hash[i].pb_head = NULL;
2208         }
2209 }
2210 /*
2211  * Initialize readahead param cache
2212  */
2213 int
2214 nfsd_racache_init(int cache_size)
2215 {
2216         int     i;
2217         int     j = 0;
2218         int     nperbucket;
2219         struct raparms **raparm = NULL;
2220
2221
2222         if (raparm_hash[0].pb_head)
2223                 return 0;
2224         nperbucket = DIV_ROUND_UP(cache_size, RAPARM_HASH_SIZE);
2225         if (nperbucket < 2)
2226                 nperbucket = 2;
2227         cache_size = nperbucket * RAPARM_HASH_SIZE;
2228
2229         dprintk("nfsd: allocating %d readahead buffers.\n", cache_size);
2230
2231         for (i = 0; i < RAPARM_HASH_SIZE; i++) {
2232                 spin_lock_init(&raparm_hash[i].pb_lock);
2233
2234                 raparm = &raparm_hash[i].pb_head;
2235                 for (j = 0; j < nperbucket; j++) {
2236                         *raparm = kzalloc(sizeof(struct raparms), GFP_KERNEL);
2237                         if (!*raparm)
2238                                 goto out_nomem;
2239                         raparm = &(*raparm)->p_next;
2240                 }
2241                 *raparm = NULL;
2242         }
2243
2244         nfsdstats.ra_size = cache_size;
2245         return 0;
2246
2247 out_nomem:
2248         dprintk("nfsd: kmalloc failed, freeing readahead buffers\n");
2249         nfsd_racache_shutdown();
2250         return -ENOMEM;
2251 }
2252
2253 #if defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL)
2254 struct posix_acl *
2255 nfsd_get_posix_acl(struct svc_fh *fhp, int type)
2256 {
2257         struct inode *inode = fhp->fh_dentry->d_inode;
2258         char *name;
2259         void *value = NULL;
2260         ssize_t size;
2261         struct posix_acl *acl;
2262
2263         if (!IS_POSIXACL(inode))
2264                 return ERR_PTR(-EOPNOTSUPP);
2265
2266         switch (type) {
2267         case ACL_TYPE_ACCESS:
2268                 name = POSIX_ACL_XATTR_ACCESS;
2269                 break;
2270         case ACL_TYPE_DEFAULT:
2271                 name = POSIX_ACL_XATTR_DEFAULT;
2272                 break;
2273         default:
2274                 return ERR_PTR(-EOPNOTSUPP);
2275         }
2276
2277         size = nfsd_getxattr(fhp->fh_dentry, name, &value);
2278         if (size < 0)
2279                 return ERR_PTR(size);
2280
2281         acl = posix_acl_from_xattr(&init_user_ns, value, size);
2282         kfree(value);
2283         return acl;
2284 }
2285
2286 int
2287 nfsd_set_posix_acl(struct svc_fh *fhp, int type, struct posix_acl *acl)
2288 {
2289         struct inode *inode = fhp->fh_dentry->d_inode;
2290         char *name;
2291         void *value = NULL;
2292         size_t size;
2293         int error;
2294
2295         if (!IS_POSIXACL(inode) ||
2296             !inode->i_op->setxattr || !inode->i_op->removexattr)
2297                 return -EOPNOTSUPP;
2298         switch(type) {
2299                 case ACL_TYPE_ACCESS:
2300                         name = POSIX_ACL_XATTR_ACCESS;
2301                         break;
2302                 case ACL_TYPE_DEFAULT:
2303                         name = POSIX_ACL_XATTR_DEFAULT;
2304                         break;
2305                 default:
2306                         return -EOPNOTSUPP;
2307         }
2308
2309         if (acl && acl->a_count) {
2310                 size = posix_acl_xattr_size(acl->a_count);
2311                 value = kmalloc(size, GFP_KERNEL);
2312                 if (!value)
2313                         return -ENOMEM;
2314                 error = posix_acl_to_xattr(&init_user_ns, acl, value, size);
2315                 if (error < 0)
2316                         goto getout;
2317                 size = error;
2318         } else
2319                 size = 0;
2320
2321         error = fh_want_write(fhp);
2322         if (error)
2323                 goto getout;
2324         if (size)
2325                 error = vfs_setxattr(fhp->fh_dentry, name, value, size, 0);
2326         else {
2327                 if (!S_ISDIR(inode->i_mode) && type == ACL_TYPE_DEFAULT)
2328                         error = 0;
2329                 else {
2330                         error = vfs_removexattr(fhp->fh_dentry, name);
2331                         if (error == -ENODATA)
2332                                 error = 0;
2333                 }
2334         }
2335         fh_drop_write(fhp);
2336
2337 getout:
2338         kfree(value);
2339         return error;
2340 }
2341 #endif  /* defined(CONFIG_NFSD_V2_ACL) || defined(CONFIG_NFSD_V3_ACL) */