~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfsd/vfs.c

Version: ~ [ linux-5.15-rc1 ] ~ [ linux-5.14.5 ] ~ [ linux-5.13.18 ] ~ [ linux-5.12.19 ] ~ [ linux-5.11.22 ] ~ [ linux-5.10.66 ] ~ [ linux-5.9.16 ] ~ [ linux-5.8.18 ] ~ [ linux-5.7.19 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.147 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.206 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.246 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.282 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.283 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.18.140 ] ~ [ linux-3.16.85 ] ~ [ linux-3.14.79 ] ~ [ linux-3.12.74 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp