1 // SPDX-License-Identifier: GPL-2.0
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.
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.
13 * Copyright (C) 1995-1999 Olaf Kirch <okir@monad.swb.de>
14 * Zerocpy NFS support (C) 2002 Hirokazu Takahashi <taka@valinux.co.jp>
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>
37 #endif /* CONFIG_NFSD_V3 */
40 #include "../internal.h"
43 #endif /* CONFIG_NFSD_V4 */
47 #include "filecache.h"
50 #define NFSDDBG_FACILITY NFSDDBG_FILEOP
53 * Called from nfsd_lookup and encode_dirent. Check if we have crossed
55 * Returns -EAGAIN or -ETIMEDOUT leaving *dpp and *expp unchanged,
56 * or nfs_ok having possibly changed *dpp and *expp
59 nfsd_cross_mnt(struct svc_rqst
*rqstp
, struct dentry
**dpp
,
60 struct svc_export
**expp
)
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
)};
68 err
= follow_down(&path
);
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 */
78 exp2
= rqst_exp_get_by_name(rqstp
, &path
);
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
88 if (err
== -ENOENT
&& !(exp
->ex_flags
& NFSEXP_V4ROOT
))
93 if (nfsd_v4client(rqstp
) ||
94 (exp
->ex_flags
& NFSEXP_CROSSMOUNT
) || EX_NOHIDE(exp2
)) {
95 /* successfully crossed mount point */
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
103 path
.dentry
= dentry
;
113 static void follow_to_parent(struct path
*path
)
117 while (path
->dentry
== path
->mnt
->mnt_root
&& follow_up(path
))
119 dp
= dget_parent(path
->dentry
);
124 static int nfsd_lookup_parent(struct svc_rqst
*rqstp
, struct dentry
*dparent
, struct svc_export
**exp
, struct dentry
**dentryp
)
126 struct svc_export
*exp2
;
127 struct path path
= {.mnt
= mntget((*exp
)->ex_path
.mnt
),
128 .dentry
= dget(dparent
)};
130 follow_to_parent(&path
);
132 exp2
= rqst_exp_parent(rqstp
, &path
);
133 if (PTR_ERR(exp2
) == -ENOENT
) {
134 *dentryp
= dget(dparent
);
135 } else if (IS_ERR(exp2
)) {
137 return PTR_ERR(exp2
);
139 *dentryp
= dget(path
.dentry
);
148 * For nfsd purposes, we treat V4ROOT exports as though there was an
149 * export at *every* directory.
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 * '0' if there is no chance of an export point here.
155 int nfsd_mountpoint(struct dentry
*dentry
, struct svc_export
*exp
)
157 if (!d_inode(dentry
))
159 if (exp
->ex_flags
& NFSEXP_V4ROOT
)
161 if (nfsd4_is_junction(dentry
))
163 if (d_mountpoint(dentry
))
165 * Might only be a mountpoint in a different namespace,
166 * but we need to check.
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
)
177 struct svc_export
*exp
;
178 struct dentry
*dparent
;
179 struct dentry
*dentry
;
182 dprintk("nfsd: nfsd_lookup(fh %s, %.*s)\n", SVCFH_fmt(fhp
), len
,name
);
184 dparent
= fhp
->fh_dentry
;
185 exp
= exp_get(fhp
->fh_export
);
187 /* Lookup the name, but don't follow links */
188 if (isdotent(name
, len
)) {
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 / */
196 /* checking mountpoint crossing is very different when stepping up */
197 host_err
= nfsd_lookup_parent(rqstp
, dparent
, &exp
, &dentry
);
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:
207 fh_lock_nested(fhp
, I_MUTEX_PARENT
);
208 dentry
= lookup_one_len(name
, dparent
, len
);
209 host_err
= PTR_ERR(dentry
);
212 if (nfsd_mountpoint(dentry
, exp
)) {
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:
222 if ((host_err
= nfsd_cross_mnt(rqstp
, &dentry
, &exp
))) {
228 *dentry_ret
= dentry
;
234 return nfserrno(host_err
);
238 * Look up one component of a pathname.
239 * N.B. After this call _both_ fhp and resfh need an fh_put
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>
250 nfsd_lookup(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, const char *name
,
251 unsigned int len
, struct svc_fh
*resfh
)
253 struct svc_export
*exp
;
254 struct dentry
*dentry
;
257 err
= fh_verify(rqstp
, fhp
, S_IFDIR
, NFSD_MAY_EXEC
);
260 err
= nfsd_lookup_dentry(rqstp
, fhp
, name
, len
, &exp
, &dentry
);
263 err
= check_nfsd_access(exp
, rqstp
);
267 * Note: we compose the file handle now, but as the
268 * dentry may be negative, it may need to be updated.
270 err
= fh_compose(resfh
, exp
, dentry
, fhp
);
271 if (!err
&& d_really_is_negative(dentry
))
280 * Commit metadata changes to stable storage.
283 commit_inode_metadata(struct inode
*inode
)
285 const struct export_operations
*export_ops
= inode
->i_sb
->s_export_op
;
287 if (export_ops
->commit_metadata
)
288 return export_ops
->commit_metadata(inode
);
289 return sync_inode_metadata(inode
, 1);
293 commit_metadata(struct svc_fh
*fhp
)
295 struct inode
*inode
= d_inode(fhp
->fh_dentry
);
297 if (!EX_ISSYNC(fhp
->fh_export
))
299 return commit_inode_metadata(inode
);
303 * Go over the attributes and take care of the small differences between
304 * NFS semantics and what Linux expects.
307 nfsd_sanitize_attrs(struct inode
*inode
, struct iattr
*iap
)
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
);
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
;
325 /* set ATTR_KILL_* bits and let VFS handle it */
326 iap
->ia_valid
|= (ATTR_KILL_SUID
| ATTR_KILL_SGID
);
332 nfsd_get_write_access(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
,
335 struct inode
*inode
= d_inode(fhp
->fh_dentry
);
338 if (iap
->ia_size
< inode
->i_size
) {
341 err
= nfsd_permission(rqstp
, fhp
->fh_export
, fhp
->fh_dentry
,
342 NFSD_MAY_TRUNC
| NFSD_MAY_OWNER_OVERRIDE
);
347 host_err
= get_write_access(inode
);
351 host_err
= locks_verify_truncate(inode
, NULL
, iap
->ia_size
);
353 goto out_put_write_access
;
356 out_put_write_access
:
357 put_write_access(inode
);
359 return nfserrno(host_err
);
363 * Set various file attributes. After this call fhp needs an fh_put.
366 nfsd_setattr(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, struct iattr
*iap
,
367 int check_guard
, time64_t guardtime
)
369 struct dentry
*dentry
;
371 int accmode
= NFSD_MAY_SATTR
;
375 bool get_write_count
;
376 bool size_change
= (iap
->ia_valid
& ATTR_SIZE
);
378 if (iap
->ia_valid
& ATTR_SIZE
) {
379 accmode
|= NFSD_MAY_WRITE
|NFSD_MAY_OWNER_OVERRIDE
;
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).
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
;
396 /* Callers that do fh_verify should do the fh_want_write: */
397 get_write_count
= !fhp
->fh_dentry
;
400 err
= fh_verify(rqstp
, fhp
, ftype
, accmode
);
403 if (get_write_count
) {
404 host_err
= fh_want_write(fhp
);
409 dentry
= fhp
->fh_dentry
;
410 inode
= d_inode(dentry
);
412 /* Ignore any mode updates on symlinks */
413 if (S_ISLNK(inode
->i_mode
))
414 iap
->ia_valid
&= ~ATTR_MODE
;
419 nfsd_sanitize_attrs(inode
, iap
);
421 if (check_guard
&& guardtime
!= inode
->i_ctime
.tv_sec
)
422 return nfserr_notsync
;
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
432 err
= nfsd_get_write_access(rqstp
, fhp
, iap
);
440 * RFC5661, Section 18.30.4:
441 * Changing the size of a file with SETATTR indirectly
442 * changes the time_modify and change attributes.
444 * (and similar for the older RFCs)
446 struct iattr size_attr
= {
447 .ia_valid
= ATTR_SIZE
| ATTR_CTIME
| ATTR_MTIME
,
448 .ia_size
= iap
->ia_size
,
451 host_err
= notify_change(&init_user_ns
, dentry
, &size_attr
, NULL
);
454 iap
->ia_valid
&= ~ATTR_SIZE
;
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.
461 if ((iap
->ia_valid
& ~ATTR_MTIME
) == 0)
465 iap
->ia_valid
|= ATTR_CTIME
;
466 host_err
= notify_change(&init_user_ns
, dentry
, iap
, NULL
);
471 put_write_access(inode
);
474 host_err
= commit_metadata(fhp
);
475 return nfserrno(host_err
);
478 #if defined(CONFIG_NFSD_V4)
480 * NFS junction information is stored in an extended attribute.
482 #define NFSD_JUNCTION_XATTR_NAME XATTR_TRUSTED_PREFIX "junction.nfs"
485 * nfsd4_is_junction - Test if an object could be an NFS junction
487 * @dentry: object to test
489 * Returns 1 if "dentry" appears to contain NFS junction information.
490 * Otherwise 0 is returned.
492 int nfsd4_is_junction(struct dentry
*dentry
)
494 struct inode
*inode
= d_inode(dentry
);
498 if (inode
->i_mode
& S_IXUGO
)
500 if (!(inode
->i_mode
& S_ISVTX
))
502 if (vfs_getxattr(&init_user_ns
, dentry
, NFSD_JUNCTION_XATTR_NAME
,
507 #ifdef CONFIG_NFSD_V4_SECURITY_LABEL
508 __be32
nfsd4_set_nfs4_label(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
,
509 struct xdr_netobj
*label
)
513 struct dentry
*dentry
;
515 error
= fh_verify(rqstp
, fhp
, 0 /* S_IFREG */, NFSD_MAY_SATTR
);
519 dentry
= fhp
->fh_dentry
;
521 inode_lock(d_inode(dentry
));
522 host_error
= security_inode_setsecctx(dentry
, label
->data
, label
->len
);
523 inode_unlock(d_inode(dentry
));
524 return nfserrno(host_error
);
527 __be32
nfsd4_set_nfs4_label(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
,
528 struct xdr_netobj
*label
)
530 return nfserr_notsupp
;
534 __be32
nfsd4_clone_file_range(struct nfsd_file
*nf_src
, u64 src_pos
,
535 struct nfsd_file
*nf_dst
, u64 dst_pos
, u64 count
, bool sync
)
537 struct file
*src
= nf_src
->nf_file
;
538 struct file
*dst
= nf_dst
->nf_file
;
542 down_write(&nf_dst
->nf_rwsem
);
543 cloned
= vfs_clone_file_range(src
, src_pos
, dst
, dst_pos
, count
, 0);
545 ret
= nfserrno(cloned
);
548 if (count
&& cloned
!= count
) {
549 ret
= nfserrno(-EINVAL
);
553 loff_t dst_end
= count
? dst_pos
+ count
- 1 : LLONG_MAX
;
554 int status
= vfs_fsync_range(dst
, dst_pos
, dst_end
, 0);
557 status
= commit_inode_metadata(file_inode(src
));
559 nfsd_reset_boot_verifier(net_generic(nf_dst
->nf_net
,
561 ret
= nfserrno(status
);
565 up_write(&nf_dst
->nf_rwsem
);
569 ssize_t
nfsd_copy_file_range(struct file
*src
, u64 src_pos
, struct file
*dst
,
570 u64 dst_pos
, u64 count
)
574 * Limit copy to 4MB to prevent indefinitely blocking an nfsd
575 * thread and client rpc slot. The choice of 4MB is somewhat
576 * arbitrary. We might instead base this on r/wsize, or make it
577 * tunable, or use a time instead of a byte limit, or implement
578 * asynchronous copy. In theory a client could also recognize a
579 * limit like this and pipeline multiple COPY requests.
581 count
= min_t(u64
, count
, 1 << 22);
582 return vfs_copy_file_range(src
, src_pos
, dst
, dst_pos
, count
, 0);
585 __be32
nfsd4_vfs_fallocate(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
,
586 struct file
*file
, loff_t offset
, loff_t len
,
591 if (!S_ISREG(file_inode(file
)->i_mode
))
594 error
= vfs_fallocate(file
, flags
, offset
, len
);
596 error
= commit_metadata(fhp
);
598 return nfserrno(error
);
600 #endif /* defined(CONFIG_NFSD_V4) */
602 #ifdef CONFIG_NFSD_V3
604 * Check server access rights to a file system object
610 static struct accessmap nfs3_regaccess
[] = {
611 { NFS3_ACCESS_READ
, NFSD_MAY_READ
},
612 { NFS3_ACCESS_EXECUTE
, NFSD_MAY_EXEC
},
613 { NFS3_ACCESS_MODIFY
, NFSD_MAY_WRITE
|NFSD_MAY_TRUNC
},
614 { NFS3_ACCESS_EXTEND
, NFSD_MAY_WRITE
},
616 #ifdef CONFIG_NFSD_V4
617 { NFS4_ACCESS_XAREAD
, NFSD_MAY_READ
},
618 { NFS4_ACCESS_XAWRITE
, NFSD_MAY_WRITE
},
619 { NFS4_ACCESS_XALIST
, NFSD_MAY_READ
},
625 static struct accessmap nfs3_diraccess
[] = {
626 { NFS3_ACCESS_READ
, NFSD_MAY_READ
},
627 { NFS3_ACCESS_LOOKUP
, NFSD_MAY_EXEC
},
628 { NFS3_ACCESS_MODIFY
, NFSD_MAY_EXEC
|NFSD_MAY_WRITE
|NFSD_MAY_TRUNC
},
629 { NFS3_ACCESS_EXTEND
, NFSD_MAY_EXEC
|NFSD_MAY_WRITE
},
630 { NFS3_ACCESS_DELETE
, NFSD_MAY_REMOVE
},
632 #ifdef CONFIG_NFSD_V4
633 { NFS4_ACCESS_XAREAD
, NFSD_MAY_READ
},
634 { NFS4_ACCESS_XAWRITE
, NFSD_MAY_WRITE
},
635 { NFS4_ACCESS_XALIST
, NFSD_MAY_READ
},
641 static struct accessmap nfs3_anyaccess
[] = {
642 /* Some clients - Solaris 2.6 at least, make an access call
643 * to the server to check for access for things like /dev/null
644 * (which really, the server doesn't care about). So
645 * We provide simple access checking for them, looking
646 * mainly at mode bits, and we make sure to ignore read-only
649 { NFS3_ACCESS_READ
, NFSD_MAY_READ
},
650 { NFS3_ACCESS_EXECUTE
, NFSD_MAY_EXEC
},
651 { NFS3_ACCESS_MODIFY
, NFSD_MAY_WRITE
|NFSD_MAY_LOCAL_ACCESS
},
652 { NFS3_ACCESS_EXTEND
, NFSD_MAY_WRITE
|NFSD_MAY_LOCAL_ACCESS
},
658 nfsd_access(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, u32
*access
, u32
*supported
)
660 struct accessmap
*map
;
661 struct svc_export
*export
;
662 struct dentry
*dentry
;
663 u32 query
, result
= 0, sresult
= 0;
666 error
= fh_verify(rqstp
, fhp
, 0, NFSD_MAY_NOP
);
670 export
= fhp
->fh_export
;
671 dentry
= fhp
->fh_dentry
;
673 if (d_is_reg(dentry
))
674 map
= nfs3_regaccess
;
675 else if (d_is_dir(dentry
))
676 map
= nfs3_diraccess
;
678 map
= nfs3_anyaccess
;
682 for (; map
->access
; map
++) {
683 if (map
->access
& query
) {
686 sresult
|= map
->access
;
688 err2
= nfsd_permission(rqstp
, export
, dentry
, map
->how
);
691 result
|= map
->access
;
694 /* the following error codes just mean the access was not allowed,
695 * rather than an error occurred */
699 /* simply don't "or" in the access bit. */
709 *supported
= sresult
;
714 #endif /* CONFIG_NFSD_V3 */
716 int nfsd_open_break_lease(struct inode
*inode
, int access
)
720 if (access
& NFSD_MAY_NOT_BREAK_LEASE
)
722 mode
= (access
& NFSD_MAY_WRITE
) ? O_WRONLY
: O_RDONLY
;
723 return break_lease(inode
, mode
| O_NONBLOCK
);
727 * Open an existing file or directory.
728 * The may_flags argument indicates the type of open (read/write/lock)
729 * and additional flags.
730 * N.B. After this call fhp needs an fh_put
733 __nfsd_open(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, umode_t type
,
734 int may_flags
, struct file
**filp
)
739 int flags
= O_RDONLY
|O_LARGEFILE
;
743 path
.mnt
= fhp
->fh_export
->ex_path
.mnt
;
744 path
.dentry
= fhp
->fh_dentry
;
745 inode
= d_inode(path
.dentry
);
747 /* Disallow write access to files with the append-only bit set
748 * or any access when mandatory locking enabled
751 if (IS_APPEND(inode
) && (may_flags
& NFSD_MAY_WRITE
))
754 * We must ignore files (but only files) which might have mandatory
755 * locks on them because there is no way to know if the accesser has
758 if (S_ISREG((inode
)->i_mode
) && mandatory_lock(inode
))
764 host_err
= nfsd_open_break_lease(inode
, may_flags
);
765 if (host_err
) /* NOMEM or WOULDBLOCK */
768 if (may_flags
& NFSD_MAY_WRITE
) {
769 if (may_flags
& NFSD_MAY_READ
)
770 flags
= O_RDWR
|O_LARGEFILE
;
772 flags
= O_WRONLY
|O_LARGEFILE
;
775 file
= dentry_open(&path
, flags
, current_cred());
777 host_err
= PTR_ERR(file
);
781 host_err
= ima_file_check(file
, may_flags
);
787 if (may_flags
& NFSD_MAY_64BIT_COOKIE
)
788 file
->f_mode
|= FMODE_64BITHASH
;
790 file
->f_mode
|= FMODE_32BITHASH
;
794 err
= nfserrno(host_err
);
800 nfsd_open(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, umode_t type
,
801 int may_flags
, struct file
**filp
)
805 validate_process_creds();
807 * If we get here, then the client has already done an "open",
808 * and (hopefully) checked permission - so allow OWNER_OVERRIDE
809 * in case a chmod has now revoked permission.
811 * Arguably we should also allow the owner override for
812 * directories, but we never have and it doesn't seem to have
813 * caused anyone a problem. If we were to change this, note
814 * also that our filldir callbacks would need a variant of
815 * lookup_one_len that doesn't check permissions.
818 may_flags
|= NFSD_MAY_OWNER_OVERRIDE
;
819 err
= fh_verify(rqstp
, fhp
, type
, may_flags
);
821 err
= __nfsd_open(rqstp
, fhp
, type
, may_flags
, filp
);
822 validate_process_creds();
827 nfsd_open_verified(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, umode_t type
,
828 int may_flags
, struct file
**filp
)
832 validate_process_creds();
833 err
= __nfsd_open(rqstp
, fhp
, type
, may_flags
, filp
);
834 validate_process_creds();
839 * Grab and keep cached pages associated with a file in the svc_rqst
840 * so that they can be passed to the network sendmsg/sendpage routines
841 * directly. They will be released after the sending has completed.
844 nfsd_splice_actor(struct pipe_inode_info
*pipe
, struct pipe_buffer
*buf
,
845 struct splice_desc
*sd
)
847 struct svc_rqst
*rqstp
= sd
->u
.data
;
848 struct page
**pp
= rqstp
->rq_next_page
;
849 struct page
*page
= buf
->page
;
854 if (rqstp
->rq_res
.page_len
== 0) {
856 put_page(*rqstp
->rq_next_page
);
857 *(rqstp
->rq_next_page
++) = page
;
858 rqstp
->rq_res
.page_base
= buf
->offset
;
859 rqstp
->rq_res
.page_len
= size
;
860 } else if (page
!= pp
[-1]) {
862 if (*rqstp
->rq_next_page
)
863 put_page(*rqstp
->rq_next_page
);
864 *(rqstp
->rq_next_page
++) = page
;
865 rqstp
->rq_res
.page_len
+= size
;
867 rqstp
->rq_res
.page_len
+= size
;
872 static int nfsd_direct_splice_actor(struct pipe_inode_info
*pipe
,
873 struct splice_desc
*sd
)
875 return __splice_from_pipe(pipe
, sd
, nfsd_splice_actor
);
878 static u32
nfsd_eof_on_read(struct file
*file
, loff_t offset
, ssize_t len
,
881 if (expected
!= 0 && len
== 0)
883 if (offset
+len
>= i_size_read(file_inode(file
)))
888 static __be32
nfsd_finish_read(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
,
889 struct file
*file
, loff_t offset
,
890 unsigned long *count
, u32
*eof
, ssize_t host_err
)
893 nfsd_stats_io_read_add(fhp
->fh_export
, host_err
);
894 *eof
= nfsd_eof_on_read(file
, offset
, host_err
, *count
);
896 fsnotify_access(file
);
897 trace_nfsd_read_io_done(rqstp
, fhp
, offset
, *count
);
900 trace_nfsd_read_err(rqstp
, fhp
, offset
, host_err
);
901 return nfserrno(host_err
);
905 __be32
nfsd_splice_read(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
,
906 struct file
*file
, loff_t offset
, unsigned long *count
,
909 struct splice_desc sd
= {
917 trace_nfsd_read_splice(rqstp
, fhp
, offset
, *count
);
918 rqstp
->rq_next_page
= rqstp
->rq_respages
+ 1;
919 host_err
= splice_direct_to_actor(file
, &sd
, nfsd_direct_splice_actor
);
920 return nfsd_finish_read(rqstp
, fhp
, file
, offset
, count
, eof
, host_err
);
923 __be32
nfsd_readv(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
,
924 struct file
*file
, loff_t offset
,
925 struct kvec
*vec
, int vlen
, unsigned long *count
,
928 struct iov_iter iter
;
929 loff_t ppos
= offset
;
932 trace_nfsd_read_vector(rqstp
, fhp
, offset
, *count
);
933 iov_iter_kvec(&iter
, READ
, vec
, vlen
, *count
);
934 host_err
= vfs_iter_read(file
, &iter
, &ppos
, 0);
935 return nfsd_finish_read(rqstp
, fhp
, file
, offset
, count
, eof
, host_err
);
939 * Gathered writes: If another process is currently writing to the file,
940 * there's a high chance this is another nfsd (triggered by a bulk write
941 * from a client's biod). Rather than syncing the file with each write
942 * request, we sleep for 10 msec.
944 * I don't know if this roughly approximates C. Juszak's idea of
945 * gathered writes, but it's a nice and simple solution (IMHO), and it
948 * Note: we do this only in the NFSv2 case, since v3 and higher have a
949 * better tool (separate unstable writes and commits) for solving this
952 static int wait_for_concurrent_writes(struct file
*file
)
954 struct inode
*inode
= file_inode(file
);
955 static ino_t last_ino
;
956 static dev_t last_dev
;
959 if (atomic_read(&inode
->i_writecount
) > 1
960 || (last_ino
== inode
->i_ino
&& last_dev
== inode
->i_sb
->s_dev
)) {
961 dprintk("nfsd: write defer %d\n", task_pid_nr(current
));
963 dprintk("nfsd: write resume %d\n", task_pid_nr(current
));
966 if (inode
->i_state
& I_DIRTY
) {
967 dprintk("nfsd: write sync %d\n", task_pid_nr(current
));
968 err
= vfs_fsync(file
, 0);
970 last_ino
= inode
->i_ino
;
971 last_dev
= inode
->i_sb
->s_dev
;
976 nfsd_vfs_write(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, struct nfsd_file
*nf
,
977 loff_t offset
, struct kvec
*vec
, int vlen
,
978 unsigned long *cnt
, int stable
,
981 struct file
*file
= nf
->nf_file
;
982 struct super_block
*sb
= file_inode(file
)->i_sb
;
983 struct svc_export
*exp
;
984 struct iov_iter iter
;
989 unsigned long exp_op_flags
= 0;
990 unsigned int pflags
= current
->flags
;
992 bool restore_flags
= false;
994 trace_nfsd_write_opened(rqstp
, fhp
, offset
, *cnt
);
997 exp_op_flags
= sb
->s_export_op
->flags
;
999 if (test_bit(RQ_LOCAL
, &rqstp
->rq_flags
) &&
1000 !(exp_op_flags
& EXPORT_OP_REMOTE_FS
)) {
1002 * We want throttling in balance_dirty_pages()
1003 * and shrink_inactive_list() to only consider
1004 * the backingdev we are writing to, so that nfs to
1005 * localhost doesn't cause nfsd to lock up due to all
1006 * the client's dirty pages or its congested queue.
1008 current
->flags
|= PF_LOCAL_THROTTLE
;
1009 restore_flags
= true;
1012 exp
= fhp
->fh_export
;
1013 use_wgather
= (rqstp
->rq_vers
== 2) && EX_WGATHER(exp
);
1015 if (!EX_ISSYNC(exp
))
1016 stable
= NFS_UNSTABLE
;
1018 if (stable
&& !use_wgather
)
1021 iov_iter_kvec(&iter
, WRITE
, vec
, vlen
, *cnt
);
1022 if (flags
& RWF_SYNC
) {
1023 down_write(&nf
->nf_rwsem
);
1024 host_err
= vfs_iter_write(file
, &iter
, &pos
, flags
);
1026 nfsd_reset_boot_verifier(net_generic(SVC_NET(rqstp
),
1028 up_write(&nf
->nf_rwsem
);
1030 down_read(&nf
->nf_rwsem
);
1032 nfsd_copy_boot_verifier(verf
,
1033 net_generic(SVC_NET(rqstp
),
1035 host_err
= vfs_iter_write(file
, &iter
, &pos
, flags
);
1036 up_read(&nf
->nf_rwsem
);
1039 nfsd_reset_boot_verifier(net_generic(SVC_NET(rqstp
),
1044 nfsd_stats_io_write_add(exp
, *cnt
);
1045 fsnotify_modify(file
);
1047 if (stable
&& use_wgather
) {
1048 host_err
= wait_for_concurrent_writes(file
);
1050 nfsd_reset_boot_verifier(net_generic(SVC_NET(rqstp
),
1055 if (host_err
>= 0) {
1056 trace_nfsd_write_io_done(rqstp
, fhp
, offset
, *cnt
);
1059 trace_nfsd_write_err(rqstp
, fhp
, offset
, host_err
);
1060 nfserr
= nfserrno(host_err
);
1063 current_restore_flags(pflags
, PF_LOCAL_THROTTLE
);
1068 * Read data from a file. count must contain the requested read count
1069 * on entry. On return, *count contains the number of bytes actually read.
1070 * N.B. After this call fhp needs an fh_put
1072 __be32
nfsd_read(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
,
1073 loff_t offset
, struct kvec
*vec
, int vlen
, unsigned long *count
,
1076 struct nfsd_file
*nf
;
1080 trace_nfsd_read_start(rqstp
, fhp
, offset
, *count
);
1081 err
= nfsd_file_acquire(rqstp
, fhp
, NFSD_MAY_READ
, &nf
);
1086 if (file
->f_op
->splice_read
&& test_bit(RQ_SPLICE_OK
, &rqstp
->rq_flags
))
1087 err
= nfsd_splice_read(rqstp
, fhp
, file
, offset
, count
, eof
);
1089 err
= nfsd_readv(rqstp
, fhp
, file
, offset
, vec
, vlen
, count
, eof
);
1093 trace_nfsd_read_done(rqstp
, fhp
, offset
, *count
);
1099 * Write data to a file.
1100 * The stable flag requests synchronous writes.
1101 * N.B. After this call fhp needs an fh_put
1104 nfsd_write(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, loff_t offset
,
1105 struct kvec
*vec
, int vlen
, unsigned long *cnt
, int stable
,
1108 struct nfsd_file
*nf
;
1111 trace_nfsd_write_start(rqstp
, fhp
, offset
, *cnt
);
1113 err
= nfsd_file_acquire(rqstp
, fhp
, NFSD_MAY_WRITE
, &nf
);
1117 err
= nfsd_vfs_write(rqstp
, fhp
, nf
, offset
, vec
,
1118 vlen
, cnt
, stable
, verf
);
1121 trace_nfsd_write_done(rqstp
, fhp
, offset
, *cnt
);
1125 #ifdef CONFIG_NFSD_V3
1127 * Commit all pending writes to stable storage.
1129 * Note: we only guarantee that data that lies within the range specified
1130 * by the 'offset' and 'count' parameters will be synced.
1132 * Unfortunately we cannot lock the file to make sure we return full WCC
1133 * data to the client, as locking happens lower down in the filesystem.
1136 nfsd_commit(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
,
1137 loff_t offset
, unsigned long count
, __be32
*verf
)
1139 struct nfsd_file
*nf
;
1140 loff_t end
= LLONG_MAX
;
1141 __be32 err
= nfserr_inval
;
1146 end
= offset
+ (loff_t
)count
- 1;
1151 err
= nfsd_file_acquire(rqstp
, fhp
,
1152 NFSD_MAY_WRITE
|NFSD_MAY_NOT_BREAK_LEASE
, &nf
);
1155 if (EX_ISSYNC(fhp
->fh_export
)) {
1158 down_write(&nf
->nf_rwsem
);
1159 err2
= vfs_fsync_range(nf
->nf_file
, offset
, end
, 0);
1162 nfsd_copy_boot_verifier(verf
, net_generic(nf
->nf_net
,
1166 err
= nfserr_notsupp
;
1169 err
= nfserrno(err2
);
1170 nfsd_reset_boot_verifier(net_generic(nf
->nf_net
,
1173 up_write(&nf
->nf_rwsem
);
1175 nfsd_copy_boot_verifier(verf
, net_generic(nf
->nf_net
,
1182 #endif /* CONFIG_NFSD_V3 */
1185 nfsd_create_setattr(struct svc_rqst
*rqstp
, struct svc_fh
*resfhp
,
1189 * Mode has already been set earlier in create:
1191 iap
->ia_valid
&= ~ATTR_MODE
;
1193 * Setting uid/gid works only for root. Irix appears to
1194 * send along the gid on create when it tries to implement
1195 * setgid directories via NFS:
1197 if (!uid_eq(current_fsuid(), GLOBAL_ROOT_UID
))
1198 iap
->ia_valid
&= ~(ATTR_UID
|ATTR_GID
);
1200 return nfsd_setattr(rqstp
, resfhp
, iap
, 0, (time64_t
)0);
1201 /* Callers expect file metadata to be committed here */
1202 return nfserrno(commit_metadata(resfhp
));
1205 /* HPUX client sometimes creates a file in mode 000, and sets size to 0.
1206 * setting size to 0 may fail for some specific file systems by the permission
1207 * checking which requires WRITE permission but the mode is 000.
1208 * we ignore the resizing(to 0) on the just new created file, since the size is
1209 * 0 after file created.
1211 * call this only after vfs_create() is called.
1214 nfsd_check_ignore_resizing(struct iattr
*iap
)
1216 if ((iap
->ia_valid
& ATTR_SIZE
) && (iap
->ia_size
== 0))
1217 iap
->ia_valid
&= ~ATTR_SIZE
;
1220 /* The parent directory should already be locked: */
1222 nfsd_create_locked(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
,
1223 char *fname
, int flen
, struct iattr
*iap
,
1224 int type
, dev_t rdev
, struct svc_fh
*resfhp
)
1226 struct dentry
*dentry
, *dchild
;
1232 dentry
= fhp
->fh_dentry
;
1233 dirp
= d_inode(dentry
);
1235 dchild
= dget(resfhp
->fh_dentry
);
1236 if (!fhp
->fh_locked
) {
1237 WARN_ONCE(1, "nfsd_create: parent %pd2 not locked!\n",
1243 err
= nfsd_permission(rqstp
, fhp
->fh_export
, dentry
, NFSD_MAY_CREATE
);
1247 if (!(iap
->ia_valid
& ATTR_MODE
))
1249 iap
->ia_mode
= (iap
->ia_mode
& S_IALLUGO
) | type
;
1251 if (!IS_POSIXACL(dirp
))
1252 iap
->ia_mode
&= ~current_umask();
1258 host_err
= vfs_create(&init_user_ns
, dirp
, dchild
, iap
->ia_mode
, true);
1260 nfsd_check_ignore_resizing(iap
);
1263 host_err
= vfs_mkdir(&init_user_ns
, dirp
, dchild
, iap
->ia_mode
);
1264 if (!host_err
&& unlikely(d_unhashed(dchild
))) {
1266 d
= lookup_one_len(dchild
->d_name
.name
,
1268 dchild
->d_name
.len
);
1270 host_err
= PTR_ERR(d
);
1273 if (unlikely(d_is_negative(d
))) {
1275 err
= nfserr_serverfault
;
1278 dput(resfhp
->fh_dentry
);
1279 resfhp
->fh_dentry
= dget(d
);
1280 err
= fh_update(resfhp
);
1291 host_err
= vfs_mknod(&init_user_ns
, dirp
, dchild
,
1292 iap
->ia_mode
, rdev
);
1295 printk(KERN_WARNING
"nfsd: bad file type %o in nfsd_create\n",
1302 err
= nfsd_create_setattr(rqstp
, resfhp
, iap
);
1305 * nfsd_create_setattr already committed the child. Transactional
1306 * filesystems had a chance to commit changes for both parent and
1307 * child simultaneously making the following commit_metadata a
1310 err2
= nfserrno(commit_metadata(fhp
));
1314 * Update the file handle to get the new inode info.
1317 err
= fh_update(resfhp
);
1323 err
= nfserrno(host_err
);
1328 * Create a filesystem object (regular, directory, special).
1329 * Note that the parent directory is left locked.
1331 * N.B. Every call to nfsd_create needs an fh_put for _both_ fhp and resfhp
1334 nfsd_create(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
,
1335 char *fname
, int flen
, struct iattr
*iap
,
1336 int type
, dev_t rdev
, struct svc_fh
*resfhp
)
1338 struct dentry
*dentry
, *dchild
= NULL
;
1342 if (isdotent(fname
, flen
))
1343 return nfserr_exist
;
1345 err
= fh_verify(rqstp
, fhp
, S_IFDIR
, NFSD_MAY_NOP
);
1349 dentry
= fhp
->fh_dentry
;
1351 host_err
= fh_want_write(fhp
);
1353 return nfserrno(host_err
);
1355 fh_lock_nested(fhp
, I_MUTEX_PARENT
);
1356 dchild
= lookup_one_len(fname
, dentry
, flen
);
1357 host_err
= PTR_ERR(dchild
);
1359 return nfserrno(host_err
);
1360 err
= fh_compose(resfhp
, fhp
->fh_export
, dchild
, fhp
);
1362 * We unconditionally drop our ref to dchild as fh_compose will have
1363 * already grabbed its own ref for it.
1368 return nfsd_create_locked(rqstp
, fhp
, fname
, flen
, iap
, type
,
1372 #ifdef CONFIG_NFSD_V3
1375 * NFSv3 and NFSv4 version of nfsd_create
1378 do_nfsd_create(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
,
1379 char *fname
, int flen
, struct iattr
*iap
,
1380 struct svc_fh
*resfhp
, int createmode
, u32
*verifier
,
1381 bool *truncp
, bool *created
)
1383 struct dentry
*dentry
, *dchild
= NULL
;
1387 __u32 v_mtime
=0, v_atime
=0;
1393 if (isdotent(fname
, flen
))
1395 if (!(iap
->ia_valid
& ATTR_MODE
))
1397 err
= fh_verify(rqstp
, fhp
, S_IFDIR
, NFSD_MAY_EXEC
);
1401 dentry
= fhp
->fh_dentry
;
1402 dirp
= d_inode(dentry
);
1404 host_err
= fh_want_write(fhp
);
1408 fh_lock_nested(fhp
, I_MUTEX_PARENT
);
1411 * Compose the response file handle.
1413 dchild
= lookup_one_len(fname
, dentry
, flen
);
1414 host_err
= PTR_ERR(dchild
);
1418 /* If file doesn't exist, check for permissions to create one */
1419 if (d_really_is_negative(dchild
)) {
1420 err
= fh_verify(rqstp
, fhp
, S_IFDIR
, NFSD_MAY_CREATE
);
1425 err
= fh_compose(resfhp
, fhp
->fh_export
, dchild
, fhp
);
1429 if (nfsd_create_is_exclusive(createmode
)) {
1430 /* solaris7 gets confused (bugid 4218508) if these have
1431 * the high bit set, so just clear the high bits. If this is
1432 * ever changed to use different attrs for storing the
1433 * verifier, then do_open_lookup() will also need to be fixed
1436 v_mtime
= verifier
[0]&0x7fffffff;
1437 v_atime
= verifier
[1]&0x7fffffff;
1440 if (d_really_is_positive(dchild
)) {
1443 switch (createmode
) {
1444 case NFS3_CREATE_UNCHECKED
:
1445 if (! d_is_reg(dchild
))
1448 /* in nfsv4, we need to treat this case a little
1449 * differently. we don't want to truncate the
1450 * file now; this would be wrong if the OPEN
1451 * fails for some other reason. furthermore,
1452 * if the size is nonzero, we should ignore it
1453 * according to spec!
1455 *truncp
= (iap
->ia_valid
& ATTR_SIZE
) && !iap
->ia_size
;
1458 iap
->ia_valid
&= ATTR_SIZE
;
1462 case NFS3_CREATE_EXCLUSIVE
:
1463 if ( d_inode(dchild
)->i_mtime
.tv_sec
== v_mtime
1464 && d_inode(dchild
)->i_atime
.tv_sec
== v_atime
1465 && d_inode(dchild
)->i_size
== 0 ) {
1471 case NFS4_CREATE_EXCLUSIVE4_1
:
1472 if ( d_inode(dchild
)->i_mtime
.tv_sec
== v_mtime
1473 && d_inode(dchild
)->i_atime
.tv_sec
== v_atime
1474 && d_inode(dchild
)->i_size
== 0 ) {
1480 case NFS3_CREATE_GUARDED
:
1487 if (!IS_POSIXACL(dirp
))
1488 iap
->ia_mode
&= ~current_umask();
1490 host_err
= vfs_create(&init_user_ns
, dirp
, dchild
, iap
->ia_mode
, true);
1498 nfsd_check_ignore_resizing(iap
);
1500 if (nfsd_create_is_exclusive(createmode
)) {
1501 /* Cram the verifier into atime/mtime */
1502 iap
->ia_valid
= ATTR_MTIME
|ATTR_ATIME
1503 | ATTR_MTIME_SET
|ATTR_ATIME_SET
;
1504 /* XXX someone who knows this better please fix it for nsec */
1505 iap
->ia_mtime
.tv_sec
= v_mtime
;
1506 iap
->ia_atime
.tv_sec
= v_atime
;
1507 iap
->ia_mtime
.tv_nsec
= 0;
1508 iap
->ia_atime
.tv_nsec
= 0;
1512 err
= nfsd_create_setattr(rqstp
, resfhp
, iap
);
1515 * nfsd_create_setattr already committed the child
1516 * (and possibly also the parent).
1519 err
= nfserrno(commit_metadata(fhp
));
1522 * Update the filehandle to get the new inode info.
1525 err
= fh_update(resfhp
);
1529 if (dchild
&& !IS_ERR(dchild
))
1535 err
= nfserrno(host_err
);
1538 #endif /* CONFIG_NFSD_V3 */
1541 * Read a symlink. On entry, *lenp must contain the maximum path length that
1542 * fits into the buffer. On return, it contains the true length.
1543 * N.B. After this call fhp needs an fh_put
1546 nfsd_readlink(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, char *buf
, int *lenp
)
1551 DEFINE_DELAYED_CALL(done
);
1554 err
= fh_verify(rqstp
, fhp
, S_IFLNK
, NFSD_MAY_NOP
);
1558 path
.mnt
= fhp
->fh_export
->ex_path
.mnt
;
1559 path
.dentry
= fhp
->fh_dentry
;
1561 if (unlikely(!d_is_symlink(path
.dentry
)))
1562 return nfserr_inval
;
1566 link
= vfs_get_link(path
.dentry
, &done
);
1568 return nfserrno(PTR_ERR(link
));
1573 memcpy(buf
, link
, *lenp
);
1574 do_delayed_call(&done
);
1579 * Create a symlink and look up its inode
1580 * N.B. After this call _both_ fhp and resfhp need an fh_put
1583 nfsd_symlink(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
,
1584 char *fname
, int flen
,
1586 struct svc_fh
*resfhp
)
1588 struct dentry
*dentry
, *dnew
;
1593 if (!flen
|| path
[0] == '\0')
1596 if (isdotent(fname
, flen
))
1599 err
= fh_verify(rqstp
, fhp
, S_IFDIR
, NFSD_MAY_CREATE
);
1603 host_err
= fh_want_write(fhp
);
1608 dentry
= fhp
->fh_dentry
;
1609 dnew
= lookup_one_len(fname
, dentry
, flen
);
1610 host_err
= PTR_ERR(dnew
);
1614 host_err
= vfs_symlink(&init_user_ns
, d_inode(dentry
), dnew
, path
);
1615 err
= nfserrno(host_err
);
1617 err
= nfserrno(commit_metadata(fhp
));
1622 cerr
= fh_compose(resfhp
, fhp
->fh_export
, dnew
, fhp
);
1624 if (err
==0) err
= cerr
;
1629 err
= nfserrno(host_err
);
1635 * N.B. After this call _both_ ffhp and tfhp need an fh_put
1638 nfsd_link(struct svc_rqst
*rqstp
, struct svc_fh
*ffhp
,
1639 char *name
, int len
, struct svc_fh
*tfhp
)
1641 struct dentry
*ddir
, *dnew
, *dold
;
1646 err
= fh_verify(rqstp
, ffhp
, S_IFDIR
, NFSD_MAY_CREATE
);
1649 err
= fh_verify(rqstp
, tfhp
, 0, NFSD_MAY_NOP
);
1653 if (d_is_dir(tfhp
->fh_dentry
))
1659 if (isdotent(name
, len
))
1662 host_err
= fh_want_write(tfhp
);
1664 err
= nfserrno(host_err
);
1668 fh_lock_nested(ffhp
, I_MUTEX_PARENT
);
1669 ddir
= ffhp
->fh_dentry
;
1670 dirp
= d_inode(ddir
);
1672 dnew
= lookup_one_len(name
, ddir
, len
);
1673 host_err
= PTR_ERR(dnew
);
1677 dold
= tfhp
->fh_dentry
;
1680 if (d_really_is_negative(dold
))
1682 host_err
= vfs_link(dold
, &init_user_ns
, dirp
, dnew
, NULL
);
1684 err
= nfserrno(commit_metadata(ffhp
));
1686 err
= nfserrno(commit_metadata(tfhp
));
1688 if (host_err
== -EXDEV
&& rqstp
->rq_vers
== 2)
1691 err
= nfserrno(host_err
);
1697 fh_drop_write(tfhp
);
1702 err
= nfserrno(host_err
);
1707 nfsd_close_cached_files(struct dentry
*dentry
)
1709 struct inode
*inode
= d_inode(dentry
);
1711 if (inode
&& S_ISREG(inode
->i_mode
))
1712 nfsd_file_close_inode_sync(inode
);
1716 nfsd_has_cached_files(struct dentry
*dentry
)
1719 struct inode
*inode
= d_inode(dentry
);
1721 if (inode
&& S_ISREG(inode
->i_mode
))
1722 ret
= nfsd_file_is_cached(inode
);
1728 * N.B. After this call _both_ ffhp and tfhp need an fh_put
1731 nfsd_rename(struct svc_rqst
*rqstp
, struct svc_fh
*ffhp
, char *fname
, int flen
,
1732 struct svc_fh
*tfhp
, char *tname
, int tlen
)
1734 struct dentry
*fdentry
, *tdentry
, *odentry
, *ndentry
, *trap
;
1735 struct inode
*fdir
, *tdir
;
1738 bool close_cached
= false;
1740 err
= fh_verify(rqstp
, ffhp
, S_IFDIR
, NFSD_MAY_REMOVE
);
1743 err
= fh_verify(rqstp
, tfhp
, S_IFDIR
, NFSD_MAY_CREATE
);
1747 fdentry
= ffhp
->fh_dentry
;
1748 fdir
= d_inode(fdentry
);
1750 tdentry
= tfhp
->fh_dentry
;
1751 tdir
= d_inode(tdentry
);
1754 if (!flen
|| isdotent(fname
, flen
) || !tlen
|| isdotent(tname
, tlen
))
1758 host_err
= fh_want_write(ffhp
);
1760 err
= nfserrno(host_err
);
1764 /* cannot use fh_lock as we need deadlock protective ordering
1765 * so do it by hand */
1766 trap
= lock_rename(tdentry
, fdentry
);
1767 ffhp
->fh_locked
= tfhp
->fh_locked
= true;
1771 odentry
= lookup_one_len(fname
, fdentry
, flen
);
1772 host_err
= PTR_ERR(odentry
);
1773 if (IS_ERR(odentry
))
1777 if (d_really_is_negative(odentry
))
1780 if (odentry
== trap
)
1783 ndentry
= lookup_one_len(tname
, tdentry
, tlen
);
1784 host_err
= PTR_ERR(ndentry
);
1785 if (IS_ERR(ndentry
))
1787 host_err
= -ENOTEMPTY
;
1788 if (ndentry
== trap
)
1792 if (ffhp
->fh_export
->ex_path
.mnt
!= tfhp
->fh_export
->ex_path
.mnt
)
1794 if (ffhp
->fh_export
->ex_path
.dentry
!= tfhp
->fh_export
->ex_path
.dentry
)
1797 if ((ndentry
->d_sb
->s_export_op
->flags
& EXPORT_OP_CLOSE_BEFORE_UNLINK
) &&
1798 nfsd_has_cached_files(ndentry
)) {
1799 close_cached
= true;
1802 struct renamedata rd
= {
1803 .old_mnt_userns
= &init_user_ns
,
1805 .old_dentry
= odentry
,
1806 .new_mnt_userns
= &init_user_ns
,
1808 .new_dentry
= ndentry
,
1810 host_err
= vfs_rename(&rd
);
1812 host_err
= commit_metadata(tfhp
);
1814 host_err
= commit_metadata(ffhp
);
1822 err
= nfserrno(host_err
);
1824 * We cannot rely on fh_unlock on the two filehandles,
1825 * as that would do the wrong thing if the two directories
1826 * were the same, so again we do it by hand.
1828 if (!close_cached
) {
1829 fill_post_wcc(ffhp
);
1830 fill_post_wcc(tfhp
);
1832 unlock_rename(tdentry
, fdentry
);
1833 ffhp
->fh_locked
= tfhp
->fh_locked
= false;
1834 fh_drop_write(ffhp
);
1837 * If the target dentry has cached open files, then we need to try to
1838 * close them prior to doing the rename. Flushing delayed fput
1839 * shouldn't be done with locks held however, so we delay it until this
1840 * point and then reattempt the whole shebang.
1843 close_cached
= false;
1844 nfsd_close_cached_files(ndentry
);
1853 * Unlink a file or directory
1854 * N.B. After this call fhp needs an fh_put
1857 nfsd_unlink(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, int type
,
1858 char *fname
, int flen
)
1860 struct dentry
*dentry
, *rdentry
;
1866 if (!flen
|| isdotent(fname
, flen
))
1868 err
= fh_verify(rqstp
, fhp
, S_IFDIR
, NFSD_MAY_REMOVE
);
1872 host_err
= fh_want_write(fhp
);
1876 fh_lock_nested(fhp
, I_MUTEX_PARENT
);
1877 dentry
= fhp
->fh_dentry
;
1878 dirp
= d_inode(dentry
);
1880 rdentry
= lookup_one_len(fname
, dentry
, flen
);
1881 host_err
= PTR_ERR(rdentry
);
1882 if (IS_ERR(rdentry
))
1883 goto out_drop_write
;
1885 if (d_really_is_negative(rdentry
)) {
1888 goto out_drop_write
;
1892 type
= d_inode(rdentry
)->i_mode
& S_IFMT
;
1894 if (type
!= S_IFDIR
) {
1895 if (rdentry
->d_sb
->s_export_op
->flags
& EXPORT_OP_CLOSE_BEFORE_UNLINK
)
1896 nfsd_close_cached_files(rdentry
);
1897 host_err
= vfs_unlink(&init_user_ns
, dirp
, rdentry
, NULL
);
1899 host_err
= vfs_rmdir(&init_user_ns
, dirp
, rdentry
);
1903 host_err
= commit_metadata(fhp
);
1909 if (host_err
== -EBUSY
) {
1910 /* name is mounted-on. There is no perfect
1913 if (nfsd_v4client(rqstp
))
1914 err
= nfserr_file_open
;
1918 err
= nfserrno(host_err
);
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.
1929 * This is based heavily on the implementation of same in XFS.
1931 struct buffered_dirent
{
1935 unsigned int d_type
;
1939 struct readdir_data
{
1940 struct dir_context ctx
;
1946 static int nfsd_buffered_filldir(struct dir_context
*ctx
, const char *name
,
1947 int namlen
, loff_t offset
, u64 ino
,
1948 unsigned int d_type
)
1950 struct readdir_data
*buf
=
1951 container_of(ctx
, struct readdir_data
, ctx
);
1952 struct buffered_dirent
*de
= (void *)(buf
->dirent
+ buf
->used
);
1953 unsigned int reclen
;
1955 reclen
= ALIGN(sizeof(struct buffered_dirent
) + namlen
, sizeof(u64
));
1956 if (buf
->used
+ reclen
> PAGE_SIZE
) {
1961 de
->namlen
= namlen
;
1962 de
->offset
= offset
;
1964 de
->d_type
= d_type
;
1965 memcpy(de
->name
, name
, namlen
);
1966 buf
->used
+= reclen
;
1971 static __be32
nfsd_buffered_readdir(struct file
*file
, struct svc_fh
*fhp
,
1972 nfsd_filldir_t func
, struct readdir_cd
*cdp
,
1975 struct buffered_dirent
*de
;
1979 struct readdir_data buf
= {
1980 .ctx
.actor
= nfsd_buffered_filldir
,
1981 .dirent
= (void *)__get_free_page(GFP_KERNEL
)
1985 return nfserrno(-ENOMEM
);
1990 unsigned int reclen
;
1992 cdp
->err
= nfserr_eof
; /* will be cleared on successful read */
1996 host_err
= iterate_dir(file
, &buf
.ctx
);
2008 de
= (struct buffered_dirent
*)buf
.dirent
;
2010 offset
= de
->offset
;
2012 if (func(cdp
, de
->name
, de
->namlen
, de
->offset
,
2013 de
->ino
, de
->d_type
))
2016 if (cdp
->err
!= nfs_ok
)
2019 trace_nfsd_dirent(fhp
, de
->ino
, de
->name
, de
->namlen
);
2021 reclen
= ALIGN(sizeof(*de
) + de
->namlen
,
2024 de
= (struct buffered_dirent
*)((char *)de
+ reclen
);
2026 if (size
> 0) /* We bailed out early */
2029 offset
= vfs_llseek(file
, 0, SEEK_CUR
);
2032 free_page((unsigned long)(buf
.dirent
));
2035 return nfserrno(host_err
);
2042 * Read entries from a directory.
2043 * The NFSv3/4 verifier we ignore for now.
2046 nfsd_readdir(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, loff_t
*offsetp
,
2047 struct readdir_cd
*cdp
, nfsd_filldir_t func
)
2051 loff_t offset
= *offsetp
;
2052 int may_flags
= NFSD_MAY_READ
;
2054 /* NFSv2 only supports 32 bit cookies */
2055 if (rqstp
->rq_vers
> 2)
2056 may_flags
|= NFSD_MAY_64BIT_COOKIE
;
2058 err
= nfsd_open(rqstp
, fhp
, S_IFDIR
, may_flags
, &file
);
2062 offset
= vfs_llseek(file
, offset
, SEEK_SET
);
2064 err
= nfserrno((int)offset
);
2068 err
= nfsd_buffered_readdir(file
, fhp
, func
, cdp
, offsetp
);
2070 if (err
== nfserr_eof
|| err
== nfserr_toosmall
)
2071 err
= nfs_ok
; /* can still be found in ->err */
2079 * Get file system stats
2080 * N.B. After this call fhp needs an fh_put
2083 nfsd_statfs(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, struct kstatfs
*stat
, int access
)
2087 err
= fh_verify(rqstp
, fhp
, 0, NFSD_MAY_NOP
| access
);
2089 struct path path
= {
2090 .mnt
= fhp
->fh_export
->ex_path
.mnt
,
2091 .dentry
= fhp
->fh_dentry
,
2093 if (vfs_statfs(&path
, stat
))
2099 static int exp_rdonly(struct svc_rqst
*rqstp
, struct svc_export
*exp
)
2101 return nfsexp_flags(rqstp
, exp
) & NFSEXP_READONLY
;
2104 #ifdef CONFIG_NFSD_V4
2106 * Helper function to translate error numbers. In the case of xattr operations,
2107 * some error codes need to be translated outside of the standard translations.
2109 * ENODATA needs to be translated to nfserr_noxattr.
2110 * E2BIG to nfserr_xattr2big.
2112 * Additionally, vfs_listxattr can return -ERANGE. This means that the
2113 * file has too many extended attributes to retrieve inside an
2114 * XATTR_LIST_MAX sized buffer. This is a bug in the xattr implementation:
2115 * filesystems will allow the adding of extended attributes until they hit
2116 * their own internal limit. This limit may be larger than XATTR_LIST_MAX.
2117 * So, at that point, the attributes are present and valid, but can't
2118 * be retrieved using listxattr, since the upper level xattr code enforces
2119 * the XATTR_LIST_MAX limit.
2121 * This bug means that we need to deal with listxattr returning -ERANGE. The
2122 * best mapping is to return TOOSMALL.
2125 nfsd_xattr_errno(int err
)
2129 return nfserr_noxattr
;
2131 return nfserr_xattr2big
;
2133 return nfserr_toosmall
;
2135 return nfserrno(err
);
2139 * Retrieve the specified user extended attribute. To avoid always
2140 * having to allocate the maximum size (since we are not getting
2141 * a maximum size from the RPC), do a probe + alloc. Hold a reader
2142 * lock on i_rwsem to prevent the extended attribute from changing
2143 * size while we're doing this.
2146 nfsd_getxattr(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, char *name
,
2147 void **bufp
, int *lenp
)
2152 struct inode
*inode
;
2153 struct dentry
*dentry
;
2155 err
= fh_verify(rqstp
, fhp
, 0, NFSD_MAY_READ
);
2160 dentry
= fhp
->fh_dentry
;
2161 inode
= d_inode(dentry
);
2163 inode_lock_shared(inode
);
2165 len
= vfs_getxattr(&init_user_ns
, dentry
, name
, NULL
, 0);
2168 * Zero-length attribute, just return.
2177 err
= nfsd_xattr_errno(len
);
2182 err
= nfserr_toosmall
;
2186 buf
= kvmalloc(len
, GFP_KERNEL
| GFP_NOFS
);
2188 err
= nfserr_jukebox
;
2192 len
= vfs_getxattr(&init_user_ns
, dentry
, name
, buf
, len
);
2196 err
= nfsd_xattr_errno(len
);
2203 inode_unlock_shared(inode
);
2209 * Retrieve the xattr names. Since we can't know how many are
2210 * user extended attributes, we must get all attributes here,
2211 * and have the XDR encode filter out the "user." ones.
2213 * While this could always just allocate an XATTR_LIST_MAX
2214 * buffer, that's a waste, so do a probe + allocate. To
2215 * avoid any changes between the probe and allocate, wrap
2216 * this in inode_lock.
2219 nfsd_listxattr(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, char **bufp
,
2225 struct inode
*inode
;
2226 struct dentry
*dentry
;
2228 err
= fh_verify(rqstp
, fhp
, 0, NFSD_MAY_READ
);
2232 dentry
= fhp
->fh_dentry
;
2233 inode
= d_inode(dentry
);
2236 inode_lock_shared(inode
);
2238 len
= vfs_listxattr(dentry
, NULL
, 0);
2240 err
= nfsd_xattr_errno(len
);
2244 if (len
> XATTR_LIST_MAX
) {
2245 err
= nfserr_xattr2big
;
2250 * We're holding i_rwsem - use GFP_NOFS.
2252 buf
= kvmalloc(len
, GFP_KERNEL
| GFP_NOFS
);
2254 err
= nfserr_jukebox
;
2258 len
= vfs_listxattr(dentry
, buf
, len
);
2261 err
= nfsd_xattr_errno(len
);
2270 inode_unlock_shared(inode
);
2276 * Removexattr and setxattr need to call fh_lock to both lock the inode
2277 * and set the change attribute. Since the top-level vfs_removexattr
2278 * and vfs_setxattr calls already do their own inode_lock calls, call
2279 * the _locked variant. Pass in a NULL pointer for delegated_inode,
2280 * and let the client deal with NFS4ERR_DELAY (same as with e.g.
2281 * setattr and remove).
2284 nfsd_removexattr(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, char *name
)
2289 err
= fh_verify(rqstp
, fhp
, 0, NFSD_MAY_WRITE
);
2293 ret
= fh_want_write(fhp
);
2295 return nfserrno(ret
);
2299 ret
= __vfs_removexattr_locked(&init_user_ns
, fhp
->fh_dentry
,
2305 return nfsd_xattr_errno(ret
);
2309 nfsd_setxattr(struct svc_rqst
*rqstp
, struct svc_fh
*fhp
, char *name
,
2310 void *buf
, u32 len
, u32 flags
)
2315 err
= fh_verify(rqstp
, fhp
, 0, NFSD_MAY_WRITE
);
2319 ret
= fh_want_write(fhp
);
2321 return nfserrno(ret
);
2324 ret
= __vfs_setxattr_locked(&init_user_ns
, fhp
->fh_dentry
, name
, buf
,
2330 return nfsd_xattr_errno(ret
);
2335 * Check for a user's access permissions to this inode.
2338 nfsd_permission(struct svc_rqst
*rqstp
, struct svc_export
*exp
,
2339 struct dentry
*dentry
, int acc
)
2341 struct inode
*inode
= d_inode(dentry
);
2344 if ((acc
& NFSD_MAY_MASK
) == NFSD_MAY_NOP
)
2347 dprintk("nfsd: permission 0x%x%s%s%s%s%s%s%s mode 0%o%s%s%s\n",
2349 (acc
& NFSD_MAY_READ
)? " read" : "",
2350 (acc
& NFSD_MAY_WRITE
)? " write" : "",
2351 (acc
& NFSD_MAY_EXEC
)? " exec" : "",
2352 (acc
& NFSD_MAY_SATTR
)? " sattr" : "",
2353 (acc
& NFSD_MAY_TRUNC
)? " trunc" : "",
2354 (acc
& NFSD_MAY_LOCK
)? " lock" : "",
2355 (acc
& NFSD_MAY_OWNER_OVERRIDE
)? " owneroverride" : "",
2357 IS_IMMUTABLE(inode
)? " immut" : "",
2358 IS_APPEND(inode
)? " append" : "",
2359 __mnt_is_readonly(exp
->ex_path
.mnt
)? " ro" : "");
2360 dprintk(" owner %d/%d user %d/%d\n",
2361 inode
->i_uid
, inode
->i_gid
, current_fsuid(), current_fsgid());
2364 /* Normally we reject any write/sattr etc access on a read-only file
2365 * system. But if it is IRIX doing check on write-access for a
2366 * device special file, we ignore rofs.
2368 if (!(acc
& NFSD_MAY_LOCAL_ACCESS
))
2369 if (acc
& (NFSD_MAY_WRITE
| NFSD_MAY_SATTR
| NFSD_MAY_TRUNC
)) {
2370 if (exp_rdonly(rqstp
, exp
) ||
2371 __mnt_is_readonly(exp
->ex_path
.mnt
))
2373 if (/* (acc & NFSD_MAY_WRITE) && */ IS_IMMUTABLE(inode
))
2376 if ((acc
& NFSD_MAY_TRUNC
) && IS_APPEND(inode
))
2379 if (acc
& NFSD_MAY_LOCK
) {
2380 /* If we cannot rely on authentication in NLM requests,
2381 * just allow locks, otherwise require read permission, or
2384 if (exp
->ex_flags
& NFSEXP_NOAUTHNLM
)
2387 acc
= NFSD_MAY_READ
| NFSD_MAY_OWNER_OVERRIDE
;
2390 * The file owner always gets access permission for accesses that
2391 * would normally be checked at open time. This is to make
2392 * file access work even when the client has done a fchmod(fd, 0).
2394 * However, `cp foo bar' should fail nevertheless when bar is
2395 * readonly. A sensible way to do this might be to reject all
2396 * attempts to truncate a read-only file, because a creat() call
2397 * always implies file truncation.
2398 * ... but this isn't really fair. A process may reasonably call
2399 * ftruncate on an open file descriptor on a file with perm 000.
2400 * We must trust the client to do permission checking - using "ACCESS"
2403 if ((acc
& NFSD_MAY_OWNER_OVERRIDE
) &&
2404 uid_eq(inode
->i_uid
, current_fsuid()))
2407 /* This assumes NFSD_MAY_{READ,WRITE,EXEC} == MAY_{READ,WRITE,EXEC} */
2408 err
= inode_permission(&init_user_ns
, inode
,
2409 acc
& (MAY_READ
| MAY_WRITE
| MAY_EXEC
));
2411 /* Allow read access to binaries even when mode 111 */
2412 if (err
== -EACCES
&& S_ISREG(inode
->i_mode
) &&
2413 (acc
== (NFSD_MAY_READ
| NFSD_MAY_OWNER_OVERRIDE
) ||
2414 acc
== (NFSD_MAY_READ
| NFSD_MAY_READ_IF_EXEC
)))
2415 err
= inode_permission(&init_user_ns
, inode
, MAY_EXEC
);
2417 return err
? nfserrno(err
) : 0;