Avoid returning NFS4ERR_FILE_OPEN when not appropriate
Subsystems (2)
[email protected]
maintainercover Avoid returning NFS4ERR_FILE_OPEN when not appropriate
From: Chuck Lever <[email protected]>
This short series aims to prevent NFSD from returning NFS4ERR_FILE_OPEN when an NFSv4 LINK, RENAME, or REMOVE operation targets a directory. The only time the protocol spec permits a server to return FILE_OPEN is when the target of the operation is a file that is open and cannot be closed immediately to satisfy the request.
I would have preferred these fixes go into NFSv4-specific sections of NFSD, but the current structure of the code prevents doing that while maintaining operational efficiency. Plus, these small patches should be able to apply cleanly to LTS kernels.
We can defer deeper restructuring for later. For example, fh_verify() could be made to return an errno instead of a generic NFS status code; then the VFS utility functions in fs/nfsd/vfs.c could be made to do the same, making their callers responsible for the proper NFS version-specific translation of the errno into a status code.
This series has been only compile tested. I'm posting early for review and comment about this approach, but please do test these if you have the ability to trigger -EBUSY easily.
Amir notes that NFSv4 OPEN is also affected. nfsd4_open() is a pretty deep stack of code. If there are stack traces available, we should be able to see where to start digging for errno leaks in that operation.
Chuck Lever (4):
NFSD: nfsd_unlink() clobbers non-zero status returned from
fh_fill_pre_attrs()
NFSD: Never return NFS4ERR_FILE_OPEN when removing a directory
NFSD: Return NFS4ERR_FILE_OPEN only when renaming over an open file
NFSD: Return NFS4ERR_FILE_OPEN only when linking an open file
fs/nfsd/vfs.c | 102 +++++++++++++++++++++++++++++++++++++------------- 1 file changed, 76 insertions(+), 26 deletions(-)
Signature · 1 line
2.47.0
[email protected]
maintainerRFC PATCH 1/4 NFSD: nfsd_unlink() clobbers non-zero status returned from fh_fill_pre_attrs()
From: Chuck Lever <[email protected]>
If fh_fill_pre_attrs() returns a non-zero status, the error flow takes it through out_unlock, which then overwrites the returned status code with
err = nfserrno(host_err);
--- fs/nfsd/vfs.c | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
fs/nfsd/vfs.c +1 -3
@@ -2011,11 +2011,9 @@ nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,* error status. */ err = nfserr_file_open; - }else { - err =nfserrno (host_err); } out: -return err; +return err != nfs_ok ? err :nfserrno (host_err); out_unlock:inode_unlock (dirp); goto out_drop_write;
Signature · 1 line
2.47.0
[email protected]
maintainerRFC PATCH 2/4 NFSD: Never return NFS4ERR_FILE_OPEN when removing a directory
In reply to [email protected]From: Chuck Lever <[email protected]>
RFC 8881 Section 18.25.4 paragraph 5 tells us that the server should return NFS4ERR_FILE_OPEN only if the target object is an opened file. This suggests that returning this status when removing a directory will confuse NFS clients.
This is a version-specific issue; nfsd_proc_remove/rmdir() and nfsd3_proc_remove/rmdir() already return nfserr_access as appropriate.
Unfortunately there is no quick way for nfsd4_remove() to determine whether the target object is a file or not, so the check is done in to nfsd_unlink() for now.
--- fs/nfsd/vfs.c | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-)
fs/nfsd/vfs.c +18 -6
@@ -1931,9 +1931,17 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,return err; } -/* -* Unlink a file or directory -* N.B. After this call fhp needs an fh_put +/** +* nfsd_unlink - remove a directory entry +* @rqstp: RPC transaction context +* @fhp: the file handle of the parent directory to be modified +* @type: enforced file type of the object to be removed +* @fname: the name of directory entry to be removed +* @flen: length of @fname in octets +* +* After this call fhp needs an fh_put. +* +* Returns a generic NFS status code in network byte-order. */ __be32 nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,
@@ -2007,10 +2015,14 @@ nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,fh_drop_write (fhp); out_nfserr:if (host_err == -EBUSY ) { -/* name is mounted-on. There is no perfect -* error status. +/* +* See RFC 8881 Section 18.25.4 para 4: NFSv4 REMOVE +* distinguishes between reg file and dir. */ - err = nfserr_file_open; +if (type !=S_IFDIR ) + err = nfserr_file_open; +else + err = nfserr_acces; } out:return err != nfs_ok ? err :nfserrno (host_err);
Signature · 1 line
2.47.0
[email protected]
maintainerRFC PATCH 3/4 NFSD: Return NFS4ERR_FILE_OPEN only when renaming over an open file
In reply to [email protected]From: Chuck Lever <[email protected]>
RFC 8881 Section 18.26.4 paragraphs 1 - 3 tell us that RENAME should return NFS4ERR_FILE_OPEN only when the target object is a file that is currently open. If the target is a directory, some other status must be returned.
Generally I expect that a delegation recall will be triggered in some of these circumstances. In other cases, the VFS might return -EBUSY for other reasons, and NFSD has to ensure that errno does not leak to clients as a status code that is not permitted by spec.
There are some error flows where the target dentry hasn't been found yet. The default value for @type therefore is S_IFDIR to return an alternate status code in those cases.
--- fs/nfsd/vfs.c | 30 ++++++++++++++++++++++++++---- 1 file changed, 26 insertions(+), 4 deletions(-)
fs/nfsd/vfs.c +26 -4
@@ -1795,9 +1795,19 @@ nfsd_has_cached_files(struct dentry *dentry)return ret; } -/* -* Rename a file -* N.B. After this call _both_ ffhp and tfhp need an fh_put +/** +* nfsd_rename - rename a directory entry +* @rqstp: RPC transaction context +* @ffhp: the file handle of parent directory containing the entry to be renamed +* @fname: the filename of directory entry to be renamed +* @flen: the length of @fname in octets +* @tfhp: the file handle of parent directory to contain the renamed entry +* @tname: the filename of the new entry +* @tlen: the length of @tlen in octets +* +* After this call _both_ ffhp and tfhp need an fh_put. +* +* Returns a generic NFS status code in network byte-order. */ __be32 nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,
@@ -1805,6 +1815,7 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen, {struct dentry *fdentry, *tdentry, *odentry, *ndentry, *trap;struct inode *fdir, *tdir; +int type =S_IFDIR ;__be32 err;int host_err;bool close_cached = false;
@@ -1867,6 +1878,7 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen, host_err =PTR_ERR (ndentry);if (IS_ERR (ndentry)) goto out_dput_old; + type =d_inode (ndentry)->i_mode &S_IFMT ; host_err = -ENOTEMPTY ;if (ndentry == trap) goto out_dput_new;
@@ -1904,7 +1916,17 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen, out_dput_old:dput (odentry); out_nfserr: - err =nfserrno (host_err); +if (host_err == -EBUSY ) { +/* +* See RFC 8881 Section 18.26.4 para 1-3: NFSv4 RENAME +* status distinguishes between reg file and dir. +*/ +if (type !=S_IFDIR ) + err = nfserr_file_open; +else + err = nfserr_acces; + }else + err =nfserrno (host_err);if (!close_cached) {fh_fill_post_attrs (ffhp);
Signature · 1 line
2.47.0
[email protected]
maintainerRFC PATCH 4/4 NFSD: Return NFS4ERR_FILE_OPEN only when linking an open file
In reply to [email protected]From: Chuck Lever <[email protected]>
RFC 8881 Section 18.9.4 paragraphs 1 - 2 tell us that RENAME should return NFS4ERR_FILE_OPEN only when the target object is a file that is currently open. If the target is a directory, some other status must be returned.
Generally I expect that a delegation recall will be triggered in some of these circumstances. In other cases, the VFS might return -EBUSY for other reasons, and NFSD has to ensure that errno does not leak to clients as a status code that is not permitted by spec.
--- fs/nfsd/vfs.c | 44 +++++++++++++++++++++++++++++++------------- 1 file changed, 31 insertions(+), 13 deletions(-)
fs/nfsd/vfs.c +31 -13
@@ -1699,9 +1699,17 @@ nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,return err; } -/* -* Create a hardlink -* N.B. After this call _both_ ffhp and tfhp need an fh_put +/** +* nfsd_link - create a link +* @rqstp: RPC transaction context +* @ffhp: the file handle of the directory where the new link is to be created +* @name: the filename of the new link +* @len: the length of @name in octets +* @tfhp: the file handle of an existing file object +* +* After this call _both_ ffhp and tfhp need an fh_put. +* +* Returns a generic NFS status code in network byte-order. */ __be32 nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,
@@ -1709,6 +1717,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, {struct dentry *ddir, *dnew, *dold;struct inode *dirp; +int type;__be32 err;int host_err;
@@ -1728,11 +1737,11 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,if (isdotent (name, len)) goto out; + err = nfs_ok; + type =d_inode (tfhp->fh_dentry)->i_mode &S_IFMT ; host_err =fh_want_write (tfhp); -if (host_err) { - err =nfserrno (host_err); +if (host_err) goto out; - } ddir = ffhp->fh_dentry; dirp =d_inode (ddir);
@@ -1740,7 +1749,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, dnew =lookup_one_len (name, ddir, len);if (IS_ERR (dnew)) { - err =nfserrno (PTR_ERR (dnew)); + host_err =PTR_ERR (dnew); goto out_unlock; }
@@ -1756,17 +1765,26 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,fh_fill_post_attrs (ffhp);inode_unlock (dirp);if (!host_err) { - err =nfserrno (commit_metadata (ffhp)); -if (!err) - err =nfserrno (commit_metadata (tfhp)); - }else { - err =nfserrno (host_err); + host_err =commit_metadata (ffhp); +if (!host_err) + host_err =commit_metadata (tfhp); } +dput (dnew); out_drop_write:fh_drop_write (tfhp); +if (host_err == -EBUSY ) { +/* +* See RFC 8881 Section 18.9.4 para 1-2: NFSv4 LINK +* status distinguishes between reg file and dir. +*/ +if (type !=S_IFDIR ) + err = nfserr_file_open; +else + err = nfserr_acces; + } out: -return err; +return err != nfs_ok ? err :nfserrno (host_err); out_dput:dput (dnew);
Signature · 1 line
2.47.0
Jeff Layton
maintainerRe: [RFC PATCH 2/4] NFSD: Never return NFS4ERR_FILE_OPEN when removing a directory
In reply to [email protected]Quoted 49 lines · On Thu, 2025-01-23 at 14:52 -0500, [email protected] wrote:
From: Chuck Lever <[email protected]>
RFC 8881 Section 18.25.4 paragraph 5 tells us that the server should return
NFS4ERR_FILE_OPENonly if the target object is an opened file. This suggests that returning this status when removing a directory will confuse NFS clients.This is a version-specific issue; nfsd_proc_remove/rmdir() and nfsd3_proc_remove/rmdir() already return
nfserr_accessas appropriate.Unfortunately there is no quick way for
nfsd4_remove()to determine whether the target object is a file or not, so the check is done in tonfsd_unlink()for now.Reported-by Trond Myklebust <[email protected]>Fixes 466e16f0920f ("nfsd: check for EBUSY from vfs_rmdir/vfs_unink.")Signed-off-by Chuck Lever <[email protected]>--- fs/nfsd/vfs.c | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-)fs/nfsd/vfs.c +11
-3@@ -1931,9 +1931,17 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,return err; } -/* -* Unlink a file or directory -* N.B. After this call fhp needs an fh_put +/** +* nfsd_unlink - remove a directory entry +* @rqstp: RPC transaction context +* @fhp: the file handle of the parent directory to be modified +* @type: enforced file type of the object to be removed +* @fname: the name of directory entry to be removed +* @flen: length of @fname in octets +* +* After this call fhp needs an fh_put. +* +* Returns a generic NFS status code in network byte-order. */ __be32 nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,@@ -2007,10 +2015,14 @@ nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,fh_drop_write (fhp);
fs/nfsd/vfs.c nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, · line 2022
Quoted 10 lines
fs/nfsd/vfs.c +4
-3out_nfserr:if (host_err == -EBUSY ) { -/* name is mounted-on. There is no perfect -* error status. +/* +* See RFC 8881 Section 18.25.4 para 4: NFSv4 REMOVE +* distinguishes between reg file and dir. */ - err = nfserr_file_open; +if (type !=S_IFDIR )
Should that be "if (type == S_ISREG)" instead? What if the inode is a named pipe or device file? I'm not sure you can ever get EBUSY with those, but in case you can, what's the right error in those cases?
Quoted 6 lines
fs/nfsd/vfs.c +3
-0+ err = nfserr_file_open; + else + err = nfserr_acces; } out:return err != nfs_ok ? err :nfserrno (host_err);
Signature · 1 line
Jeff Layton <[email protected]>
Jeff Layton
maintainerRe: [RFC PATCH 4/4] NFSD: Return NFS4ERR_FILE_OPEN only when linking an open file
In reply to [email protected]Quoted 90 lines · On Thu, 2025-01-23 at 14:52 -0500, [email protected] wrote:
From: Chuck Lever <[email protected]>
RFC 8881 Section 18.9.4 paragraphs 1 - 2 tell us that RENAME should return
NFS4ERR_FILE_OPENonly when the target object is a file that is currently open. If the target is a directory, some other status must be returned.Generally I expect that a delegation recall will be triggered in some of these circumstances. In other cases, the VFS might return
-EBUSYfor other reasons, and NFSD has to ensure that errno does not leak to clients as a status code that is not permitted by spec.Signed-off-by Chuck Lever <[email protected]>--- fs/nfsd/vfs.c | 44 +++++++++++++++++++++++++++++++------------- 1 file changed, 31 insertions(+), 13 deletions(-)fs/nfsd/vfs.c +20
-12@@ -1699,9 +1699,17 @@ nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,return err; } -/* -* Create a hardlink -* N.B. After this call _both_ ffhp and tfhp need an fh_put +/** +* nfsd_link - create a link +* @rqstp: RPC transaction context +* @ffhp: the file handle of the directory where the new link is to be created +* @name: the filename of the new link +* @len: the length of @name in octets +* @tfhp: the file handle of an existing file object +* +* After this call _both_ ffhp and tfhp need an fh_put. +* +* Returns a generic NFS status code in network byte-order. */ __be32 nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,@@ -1709,6 +1717,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, {struct dentry *ddir, *dnew, *dold;struct inode *dirp; +int type;__be32 err;int host_err;@@ -1728,11 +1737,11 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,if (isdotent (name, len)) goto out; + err = nfs_ok; + type =d_inode (tfhp->fh_dentry)->i_mode &S_IFMT ; host_err =fh_want_write (tfhp); -if (host_err) { - err =nfserrno (host_err); +if (host_err) goto out; - } ddir = ffhp->fh_dentry; dirp =d_inode (ddir);@@ -1740,7 +1749,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, dnew =lookup_one_len (name, ddir, len);if (IS_ERR (dnew)) { - err =nfserrno (PTR_ERR (dnew)); + host_err =PTR_ERR (dnew); goto out_unlock; }@@ -1756,17 +1765,26 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,fh_fill_post_attrs (ffhp);inode_unlock (dirp);if (!host_err) { - err =nfserrno (commit_metadata (ffhp)); -if (!err) - err =nfserrno (commit_metadata (tfhp)); - }else { - err =nfserrno (host_err); + host_err =commit_metadata (ffhp); +if (!host_err) + host_err =commit_metadata (tfhp); } +dput (dnew); out_drop_write:
fs/nfsd/vfs.c nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, · line 1784
Quoted 10 lines
fs/nfsd/vfs.c +9
-0fh_drop_write (tfhp); +if (host_err == -EBUSY ) { +/* +* See RFC 8881 Section 18.9.4 para 1-2: NFSv4 LINK +* status distinguishes between reg file and dir. +*/ +if (type !=S_IFDIR ) + err = nfserr_file_open; +else + err = nfserr_acces;
I guess nothing in NFS protocol spec prohibits you from hardlinking a directory, but hopefully any Linux filesystem will be returning -EPERM when someone tries it! IOW, I suspect the above will probably be dead code, but I don't think it'll hurt anything.
Quoted 7 lines
fs/nfsd/vfs.c +2
-1+ } out: -return err; +return err != nfs_ok ? err :nfserrno (host_err); out_dput:dput (dnew);
Signature · 1 line
Jeff Layton <[email protected]>
Re: [RFC PATCH 2/4] NFSD: Never return NFS4ERR_FILE_OPEN when removing a directory
In reply to Jeff LaytonQuoted 56 lines · Jeff Layton
Quoted 55 lines · On Thu, 2025-01-23 at 14:52 -0500, [email protected] wrote:
From: Chuck Lever <[email protected]>
RFC 8881 Section 18.25.4 paragraph 5 tells us that the server should return
NFS4ERR_FILE_OPENonly if the target object is an opened file. This suggests that returning this status when removing a directory will confuse NFS clients.This is a version-specific issue; nfsd_proc_remove/rmdir() and nfsd3_proc_remove/rmdir() already return
nfserr_accessas appropriate.Unfortunately there is no quick way for
nfsd4_remove()to determine whether the target object is a file or not, so the check is done in tonfsd_unlink()for now.Reported-by Trond Myklebust <[email protected]>Fixes 466e16f0920f ("nfsd: check for EBUSY from vfs_rmdir/vfs_unink.")Signed-off-by Chuck Lever <[email protected]>--- fs/nfsd/vfs.c | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-)fs/nfsd/vfs.c +13
-5@@ -1931,9 +1931,17 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,return err; } -/* -* Unlink a file or directory -* N.B. After this call fhp needs an fh_put +/** +* nfsd_unlink - remove a directory entry +* @rqstp: RPC transaction context +* @fhp: the file handle of the parent directory to be modified +* @type: enforced file type of the object to be removed +* @fname: the name of directory entry to be removed +* @flen: length of @fname in octets +* +* After this call fhp needs an fh_put. +* +* Returns a generic NFS status code in network byte-order. */ __be32 nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,@@ -2007,10 +2015,14 @@ nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,fh_drop_write (fhp); out_nfserr:if (host_err == -EBUSY ) { -/* name is mounted-on. There is no perfect -* error status. +/* +* See RFC 8881 Section 18.25.4 para 4: NFSv4 REMOVE
Quoted 8 lines
fs/nfsd/vfs.c nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, · line 2022
Quoted 4 lines
fs/nfsd/vfs.c +2
-1+* distinguishes between reg file and dir. */ - err = nfserr_file_open; +if (type !=S_IFDIR )Should that be "if (type ==
S_ISREG)" instead? What if the inode is a named pipe or device file? I'm not sure you can ever get EBUSY with those, but in case you can, what's the right error in those cases?
Check out nfsd_unlink()'s callers to see what they pass as the type parameter. Unfortunately we have to compare against S_IFDIR here.
Quoted 7 lines
Quoted 6 lines
fs/nfsd/vfs.c +3
-0+ err = nfserr_file_open; + else + err = nfserr_acces; } out:return err != nfs_ok ? err :nfserrno (host_err);
Signature · 1 line
Chuck Lever
Re: [RFC PATCH 2/4] NFSD: Never return NFS4ERR_FILE_OPEN when removing a directory
Quoted 67 lines · Chuck Lever
Quoted 56 lines · Jeff Layton
Quoted 55 lines · On Thu, 2025-01-23 at 14:52 -0500, [email protected] wrote:
From: Chuck Lever <[email protected]>
RFC 8881 Section 18.25.4 paragraph 5 tells us that the server should return
NFS4ERR_FILE_OPENonly if the target object is an opened file. This suggests that returning this status when removing a directory will confuse NFS clients.This is a version-specific issue; nfsd_proc_remove/rmdir() and nfsd3_proc_remove/rmdir() already return
nfserr_accessas appropriate.Unfortunately there is no quick way for
nfsd4_remove()to determine whether the target object is a file or not, so the check is done in tonfsd_unlink()for now.Reported-by Trond Myklebust <[email protected]>Fixes 466e16f0920f ("nfsd: check for EBUSY from vfs_rmdir/vfs_unink.")Signed-off-by Chuck Lever <[email protected]>--- fs/nfsd/vfs.c | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-)fs/nfsd/vfs.c +13
-5@@ -1931,9 +1931,17 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,return err; } -/* -* Unlink a file or directory -* N.B. After this call fhp needs an fh_put +/** +* nfsd_unlink - remove a directory entry +* @rqstp: RPC transaction context +* @fhp: the file handle of the parent directory to be modified +* @type: enforced file type of the object to be removed +* @fname: the name of directory entry to be removed +* @flen: length of @fname in octets +* +* After this call fhp needs an fh_put. +* +* Returns a generic NFS status code in network byte-order. */ __be32 nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,@@ -2007,10 +2015,14 @@ nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,fh_drop_write (fhp); out_nfserr:if (host_err == -EBUSY ) { -/* name is mounted-on. There is no perfect -* error status. +/* +* See RFC 8881 Section 18.25.4 para 4: NFSv4 REMOVE Quoted 8 lines
fs/nfsd/vfs.c nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, · line 2022
Quoted 4 lines
fs/nfsd/vfs.c +2
-1+* distinguishes between reg file and dir. */ - err = nfserr_file_open; +if (type !=S_IFDIR )Should that be "if (type ==
S_ISREG)" instead? What if the inode is a named pipe or device file? I'm not sure you can ever get EBUSY with those, but in case you can, what's the right error in those cases?
Quoted 3 lines
Check out nfsd_unlink()'s callers to see what they pass as the type parameter. Unfortunately we have to compare against
S_IFDIRhere.
Not exactly. nfsd4_remove() is the only caller that needs to get nfserr_file_open and this caller calls with type = 0, so type here is going to be the actual type of the inode and (type == S_ISREG) would be correct. No?
Thanks,
Amir.
Re: [RFC PATCH 3/4] NFSD: Return NFS4ERR_FILE_OPEN only when renaming over an open file
In reply to [email protected]Quoted 66 lines · On Thu, Jan 23, 2025 at 8:52 PM <[email protected]> wrote:
From: Chuck Lever <[email protected]>
RFC 8881 Section 18.26.4 paragraphs 1 - 3 tell us that RENAME should return
NFS4ERR_FILE_OPENonly when the target object is a file that is currently open. If the target is a directory, some other status must be returned.Generally I expect that a delegation recall will be triggered in some of these circumstances. In other cases, the VFS might return
-EBUSYfor other reasons, and NFSD has to ensure that errno does not leak to clients as a status code that is not permitted by spec.There are some error flows where the target dentry hasn't been found yet. The default value for @type therefore is
S_IFDIRto return an alternate status code in those cases.Signed-off-by Chuck Lever <[email protected]>--- fs/nfsd/vfs.c | 30 ++++++++++++++++++++++++++---- 1 file changed, 26 insertions(+), 4 deletions(-)fs/nfsd/vfs.c +15
-3@@ -1795,9 +1795,19 @@ nfsd_has_cached_files(struct dentry *dentry)return ret; } -/* -* Rename a file -* N.B. After this call _both_ ffhp and tfhp need an fh_put +/** +* nfsd_rename - rename a directory entry +* @rqstp: RPC transaction context +* @ffhp: the file handle of parent directory containing the entry to be renamed +* @fname: the filename of directory entry to be renamed +* @flen: the length of @fname in octets +* @tfhp: the file handle of parent directory to contain the renamed entry +* @tname: the filename of the new entry +* @tlen: the length of @tlen in octets +* +* After this call _both_ ffhp and tfhp need an fh_put. +* +* Returns a generic NFS status code in network byte-order. */ __be32 nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,@@ -1805,6 +1815,7 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen, {struct dentry *fdentry, *tdentry, *odentry, *ndentry, *trap;struct inode *fdir, *tdir; +int type =S_IFDIR ;__be32 err;int host_err;bool close_cached = false;@@ -1867,6 +1878,7 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen, host_err =PTR_ERR (ndentry);if (IS_ERR (ndentry)) goto out_dput_old; + type =d_inode (ndentry)->i_mode &S_IFMT ; host_err = -ENOTEMPTY ;if (ndentry == trap) goto out_dput_new;
fs/nfsd/vfs.c nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen, · line 1924
Quoted 10 lines
fs/nfsd/vfs.c +6
-1@@ -1904,7 +1916,17 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen, out_dput_old:dput (odentry); out_nfserr: - err =nfserrno (host_err); +if (host_err == -EBUSY ) { +/* +* See RFC 8881 Section 18.26.4 para 1-3: NFSv4 RENAME +* status distinguishes between reg file and dir. +*/ +if (type !=S_IFDIR )
Maybe (type == S_IFREG) here as well?
fs/nfsd/vfs.c nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen, · line 1930
Quoted 6 lines
fs/nfsd/vfs.c +5
-0+ err = nfserr_file_open; + else + err = nfserr_acces; + }else + err =nfserrno (host_err);
if {} else ; is a code smell with high potential for human misreading of code.
Thanks,
Amir.
Re: [RFC PATCH 4/4] NFSD: Return NFS4ERR_FILE_OPEN only when linking an open file
In reply to Jeff LaytonQuoted 99 lines · Jeff Layton
Quoted 97 lines · On Thu, 2025-01-23 at 14:52 -0500, [email protected] wrote:
From: Chuck Lever <[email protected]>
RFC 8881 Section 18.9.4 paragraphs 1 - 2 tell us that RENAME should return
NFS4ERR_FILE_OPENonly when the target object is a file that is currently open. If the target is a directory, some other status must be returned.Generally I expect that a delegation recall will be triggered in some of these circumstances. In other cases, the VFS might return
-EBUSYfor other reasons, and NFSD has to ensure that errno does not leak to clients as a status code that is not permitted by spec.Signed-off-by Chuck Lever <[email protected]>--- fs/nfsd/vfs.c | 44 +++++++++++++++++++++++++++++++------------- 1 file changed, 31 insertions(+), 13 deletions(-)fs/nfsd/vfs.c +26
-12@@ -1699,9 +1699,17 @@ nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,return err; } -/* -* Create a hardlink -* N.B. After this call _both_ ffhp and tfhp need an fh_put +/** +* nfsd_link - create a link +* @rqstp: RPC transaction context +* @ffhp: the file handle of the directory where the new link is to be created +* @name: the filename of the new link +* @len: the length of @name in octets +* @tfhp: the file handle of an existing file object +* +* After this call _both_ ffhp and tfhp need an fh_put. +* +* Returns a generic NFS status code in network byte-order. */ __be32 nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,@@ -1709,6 +1717,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, {struct dentry *ddir, *dnew, *dold;struct inode *dirp; +int type;__be32 err;int host_err;@@ -1728,11 +1737,11 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,if (isdotent (name, len)) goto out; + err = nfs_ok; + type =d_inode (tfhp->fh_dentry)->i_mode &S_IFMT ; host_err =fh_want_write (tfhp); -if (host_err) { - err =nfserrno (host_err); +if (host_err) goto out; - } ddir = ffhp->fh_dentry; dirp =d_inode (ddir);@@ -1740,7 +1749,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, dnew =lookup_one_len (name, ddir, len);if (IS_ERR (dnew)) { - err =nfserrno (PTR_ERR (dnew)); + host_err =PTR_ERR (dnew); goto out_unlock; }@@ -1756,17 +1765,26 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,fh_fill_post_attrs (ffhp);inode_unlock (dirp);if (!host_err) { - err =nfserrno (commit_metadata (ffhp)); -if (!err) - err =nfserrno (commit_metadata (tfhp)); - }else { - err =nfserrno (host_err); + host_err =commit_metadata (ffhp); +if (!host_err) + host_err =commit_metadata (tfhp); } +dput (dnew); out_drop_write:fh_drop_write (tfhp); +if (host_err == -EBUSY ) { +/* +* See RFC 8881 Section 18.9.4 para 1-2: NFSv4 LINK +* status distinguishes between reg file and dir. +*/ +if (type !=S_IFDIR )
Quoted 9 lines
fs/nfsd/vfs.c nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, · line 1784
Quoted 3 lines
fs/nfsd/vfs.c +3
-0+ err = nfserr_file_open; + else + err = nfserr_acces;I guess nothing in NFS protocol spec prohibits you from hardlinking a directory, but hopefully any Linux filesystem will be returning
-EPERMwhen someone tries it! IOW, I suspect the above will probably be dead code, but I don't think it'll hurt anything.
Not to mention that unlike rmdir() and rename(), vfs does not return EBUSY for link(), so this code is not really testable as is, is it?
I would drop this patch if I were you, but as you wish.
Thanks,
Amir.
Re: [RFC PATCH 4/4] NFSD: Return NFS4ERR_FILE_OPEN only when linking an open file
Quoted 110 lines · Amir Goldstein
Quoted 99 lines · Jeff Layton
Quoted 97 lines · On Thu, 2025-01-23 at 14:52 -0500, [email protected] wrote:
From: Chuck Lever <[email protected]>
RFC 8881 Section 18.9.4 paragraphs 1 - 2 tell us that RENAME should return
NFS4ERR_FILE_OPENonly when the target object is a file that is currently open. If the target is a directory, some other status must be returned.Generally I expect that a delegation recall will be triggered in some of these circumstances. In other cases, the VFS might return
-EBUSYfor other reasons, and NFSD has to ensure that errno does not leak to clients as a status code that is not permitted by spec.Signed-off-by Chuck Lever <[email protected]>--- fs/nfsd/vfs.c | 44 +++++++++++++++++++++++++++++++------------- 1 file changed, 31 insertions(+), 13 deletions(-)fs/nfsd/vfs.c +26
-12@@ -1699,9 +1699,17 @@ nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,return err; } -/* -* Create a hardlink -* N.B. After this call _both_ ffhp and tfhp need an fh_put +/** +* nfsd_link - create a link +* @rqstp: RPC transaction context +* @ffhp: the file handle of the directory where the new link is to be created +* @name: the filename of the new link +* @len: the length of @name in octets +* @tfhp: the file handle of an existing file object +* +* After this call _both_ ffhp and tfhp need an fh_put. +* +* Returns a generic NFS status code in network byte-order. */ __be32 nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,@@ -1709,6 +1717,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, {struct dentry *ddir, *dnew, *dold;struct inode *dirp; +int type;__be32 err;int host_err;@@ -1728,11 +1737,11 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,if (isdotent (name, len)) goto out; + err = nfs_ok; + type =d_inode (tfhp->fh_dentry)->i_mode &S_IFMT ; host_err =fh_want_write (tfhp); -if (host_err) { - err =nfserrno (host_err); +if (host_err) goto out; - } ddir = ffhp->fh_dentry; dirp =d_inode (ddir);@@ -1740,7 +1749,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, dnew =lookup_one_len (name, ddir, len);if (IS_ERR (dnew)) { - err =nfserrno (PTR_ERR (dnew)); + host_err =PTR_ERR (dnew); goto out_unlock; }@@ -1756,17 +1765,26 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,fh_fill_post_attrs (ffhp);inode_unlock (dirp);if (!host_err) { - err =nfserrno (commit_metadata (ffhp)); -if (!err) - err =nfserrno (commit_metadata (tfhp)); - }else { - err =nfserrno (host_err); + host_err =commit_metadata (ffhp); +if (!host_err) + host_err =commit_metadata (tfhp); } +dput (dnew); out_drop_write:fh_drop_write (tfhp); +if (host_err == -EBUSY ) { +/* +* See RFC 8881 Section 18.9.4 para 1-2: NFSv4 LINK +* status distinguishes between reg file and dir. +*/ +if (type !=S_IFDIR )Quoted 9 lines
fs/nfsd/vfs.c nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, · line 1784
Quoted 3 lines
fs/nfsd/vfs.c +3
-0+ err = nfserr_file_open; + else + err = nfserr_acces;I guess nothing in NFS protocol spec prohibits you from hardlinking a directory, but hopefully any Linux filesystem will be returning
-EPERMwhen someone tries it! IOW, I suspect the above will probably be dead code, but I don't think it'll hurt anything.
Quoted 2 lines
Not to mention that unlike
rmdir()andrename(), vfs does not return EBUSY forlink(), so this code is not really testable as is, is it?
You suggested that the VFS could return -EBUSY for just about anything for FuSE.
Quoted 1 line
I would drop this patch if I were you, but as you wish.
I can, but how do we know we'll never get -EBUSY here?
Signature · 1 line
Chuck Lever
Re: [RFC PATCH 2/4] NFSD: Never return NFS4ERR_FILE_OPEN when removing a directory
In reply to Amir GoldsteinQuoted 59 lines · Amir Goldstein
Quoted 58 lines · Chuck Lever
Quoted 56 lines · Jeff Layton
Quoted 55 lines · On Thu, 2025-01-23 at 14:52 -0500, [email protected] wrote:
From: Chuck Lever <[email protected]>
RFC 8881 Section 18.25.4 paragraph 5 tells us that the server should return
NFS4ERR_FILE_OPENonly if the target object is an opened file. This suggests that returning this status when removing a directory will confuse NFS clients.This is a version-specific issue; nfsd_proc_remove/rmdir() and nfsd3_proc_remove/rmdir() already return
nfserr_accessas appropriate.Unfortunately there is no quick way for
nfsd4_remove()to determine whether the target object is a file or not, so the check is done in tonfsd_unlink()for now.Reported-by Trond Myklebust <[email protected]>Fixes 466e16f0920f ("nfsd: check for EBUSY from vfs_rmdir/vfs_unink.")Signed-off-by Chuck Lever <[email protected]>--- fs/nfsd/vfs.c | 24 ++++++++++++++++++------ 1 file changed, 18 insertions(+), 6 deletions(-)fs/nfsd/vfs.c +13
-5@@ -1931,9 +1931,17 @@ nfsd_rename(struct svc_rqst *rqstp, struct svc_fh *ffhp, char *fname, int flen,return err; } -/* -* Unlink a file or directory -* N.B. After this call fhp needs an fh_put +/** +* nfsd_unlink - remove a directory entry +* @rqstp: RPC transaction context +* @fhp: the file handle of the parent directory to be modified +* @type: enforced file type of the object to be removed +* @fname: the name of directory entry to be removed +* @flen: length of @fname in octets +* +* After this call fhp needs an fh_put. +* +* Returns a generic NFS status code in network byte-order. */ __be32 nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,@@ -2007,10 +2015,14 @@ nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type,fh_drop_write (fhp); out_nfserr:if (host_err == -EBUSY ) { -/* name is mounted-on. There is no perfect -* error status. +/* +* See RFC 8881 Section 18.25.4 para 4: NFSv4 REMOVE
Quoted 8 lines
Quoted 8 lines
Quoted 8 lines
fs/nfsd/vfs.c nfsd_unlink(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, · line 2022
Quoted 4 lines
fs/nfsd/vfs.c +2
-1+* distinguishes between reg file and dir. */ - err = nfserr_file_open; +if (type !=S_IFDIR )Should that be "if (type ==
S_ISREG)" instead? What if the inode is a named pipe or device file? I'm not sure you can ever get EBUSY with those, but in case you can, what's the right error in those cases?
Another way to put this:
If a client can acquire an OPEN state ID for those types of objects, then NFS4ERR_FILE_OPEN is the correct status code in those cases.
But in practice, it depends on what existing client implementations expect.
Quoted 8 lines
Quoted 3 lines
Check out nfsd_unlink()'s callers to see what they pass as the type parameter. Unfortunately we have to compare against
S_IFDIRhere.Not exactly.
nfsd4_remove()is the only caller that needs to getnfserr_file_openand this caller calls with type = 0, so type here is going to be the actual type of the inode and (type ==S_ISREG) would be correct. No?
Signature · 1 line
Chuck Lever
Re: [RFC PATCH 4/4] NFSD: Return NFS4ERR_FILE_OPEN only when linking an open file
In reply to Chuck LeverQuoted 112 lines · Chuck Lever
Quoted 110 lines · Amir Goldstein
Quoted 108 lines · Jeff Layton
Quoted 90 lines · On Thu, 2025-01-23 at 14:52 -0500, [email protected] wrote:
From: Chuck Lever <[email protected]>
RFC 8881 Section 18.9.4 paragraphs 1 - 2 tell us that RENAME should return
NFS4ERR_FILE_OPENonly when the target object is a file that is currently open. If the target is a directory, some other status must be returned.Generally I expect that a delegation recall will be triggered in some of these circumstances. In other cases, the VFS might return
-EBUSYfor other reasons, and NFSD has to ensure that errno does not leak to clients as a status code that is not permitted by spec.Signed-off-by Chuck Lever <[email protected]>--- fs/nfsd/vfs.c | 44 +++++++++++++++++++++++++++++++------------- 1 file changed, 31 insertions(+), 13 deletions(-)fs/nfsd/vfs.c +20
-12@@ -1699,9 +1699,17 @@ nfsd_symlink(struct svc_rqst *rqstp, struct svc_fh *fhp,return err; } -/* -* Create a hardlink -* N.B. After this call _both_ ffhp and tfhp need an fh_put +/** +* nfsd_link - create a link +* @rqstp: RPC transaction context +* @ffhp: the file handle of the directory where the new link is to be created +* @name: the filename of the new link +* @len: the length of @name in octets +* @tfhp: the file handle of an existing file object +* +* After this call _both_ ffhp and tfhp need an fh_put. +* +* Returns a generic NFS status code in network byte-order. */ __be32 nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,@@ -1709,6 +1717,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, {struct dentry *ddir, *dnew, *dold;struct inode *dirp; +int type;__be32 err;int host_err;@@ -1728,11 +1737,11 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,if (isdotent (name, len)) goto out; + err = nfs_ok; + type =d_inode (tfhp->fh_dentry)->i_mode &S_IFMT ; host_err =fh_want_write (tfhp); -if (host_err) { - err =nfserrno (host_err); +if (host_err) goto out; - } ddir = ffhp->fh_dentry; dirp =d_inode (ddir);@@ -1740,7 +1749,7 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, dnew =lookup_one_len (name, ddir, len);if (IS_ERR (dnew)) { - err =nfserrno (PTR_ERR (dnew)); + host_err =PTR_ERR (dnew); goto out_unlock; }@@ -1756,17 +1765,26 @@ nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp,fh_fill_post_attrs (ffhp);inode_unlock (dirp);if (!host_err) { - err =nfserrno (commit_metadata (ffhp)); -if (!err) - err =nfserrno (commit_metadata (tfhp)); - }else { - err =nfserrno (host_err); + host_err =commit_metadata (ffhp); +if (!host_err) + host_err =commit_metadata (tfhp); } +dput (dnew); out_drop_write:fs/nfsd/vfs.c nfsd_link(struct svc_rqst *rqstp, struct svc_fh *ffhp, · line 1784
Quoted 10 lines
fs/nfsd/vfs.c +9
-0fh_drop_write (tfhp); +if (host_err == -EBUSY ) { +/* +* See RFC 8881 Section 18.9.4 para 1-2: NFSv4 LINK +* status distinguishes between reg file and dir. +*/ +if (type !=S_IFDIR ) + err = nfserr_file_open; +else + err = nfserr_acces;I guess nothing in NFS protocol spec prohibits you from hardlinking a directory, but hopefully any Linux filesystem will be returning
-EPERMwhen someone tries it! IOW, I suspect the above will probably be dead code, but I don't think it'll hurt anything.
Quoted 6 lines
Quoted 2 lines
Not to mention that unlike
rmdir()andrename(), vfs does not return EBUSY forlink(), so this code is not really testable as is, is it?You suggested that the VFS could return
-EBUSYfor just about anything for FuSE.
Yes, it is possible.
Quoted 5 lines
Quoted 2 lines
I would drop this patch if I were you, but as you wish.
I can, but how do we know we'll never get
-EBUSYhere?
You are right.
Thanks,
Amir.