NFS server user xattr support (RFC8276)
Subsystems (4)
v2 cover NFS server user xattr support (RFC8276)
v1 is here: https://www.spinics.net/lists/linux-nfs/msg76740.html
v2:
* Moved the xattr changes upfront, and Cc-ed them to the appropriate recipients.
* Added doxygen comments to the new exported functions (xattr)
* Squashed a number of patches together to avoid unused function warnings.
* Renamed nfs4_vbuf_from_stream to nfs4_vbuf_from_vector
fs/nfsd/nfs4proc.c | 140 +++++++++- fs/nfsd/nfs4xdr.c | 535 +++++++++++++++++++++++++++++++++++--- fs/nfsd/nfsd.h | 5 +- fs/nfsd/vfs.c | 142 ++++++++++ fs/nfsd/vfs.h | 10 + fs/nfsd/xdr4.h | 31 +++ fs/xattr.c | 111 +++++++- include/linux/nfs4.h | 22 +- include/linux/xattr.h | 4 + include/uapi/linux/nfs4.h | 3 + 10 files changed, 961 insertions(+), 42 deletions(-)
Signature · 1 line
2.17.2
PATCH v2 1/11 xattr: break delegations in {set,remove}xattr and add _locked versions
set/removexattr on an exported filesystem should break NFS delegations. This is true in general, but also for the upcoming support for RFC 8726 (NFSv4 extended attribute support). Make sure that they do.
Additonally, they need to grow a _locked variant, since the NFS server code will call this with i_rwsem held. It needs to do that in fh_lock to be able to atomically provide the before and after change attributes.
--- fs/xattr.c | 84 +++++++++++++++++++++++++++++++++++++++---- include/linux/xattr.h | 2 ++ 2 files changed, 79 insertions(+), 7 deletions(-)
fs/xattr.c +77 -7
@@ -204,10 +204,22 @@ int __vfs_setxattr_noperm(struct dentry *dentry, const char *name,return error; } - +/** +* __vfs_setxattr_locked: set an extended attribute while holding the inode +* lock +* +* @dentry - object to perform setxattr on +* @name - xattr name to set +* @value - value to set @name to +* @size - size of @value +* @flags - flags to pass into filesystem operations +* @delegated_inode - on return, will contain an inode pointer that +* a delegation was broken on, NULL if none. +*/ int -vfs_setxattr (struct dentry *dentry,const char *name,const void *value, -size_t size,int flags) +__vfs_setxattr_locked (struct dentry *dentry,const char *name, +const void *value,size_t size,int flags, +struct inode **delegated_inode) {struct inode *inode = dentry->d_inode;int error;
@@ -216,15 +228,40 @@ vfs_setxattr(struct dentry *dentry, const char *name, const void *value,if (error)return error; -inode_lock (inode); error =security_inode_setxattr (dentry, name, value, size, flags);if (error) goto out; + error =try_break_deleg (inode, delegated_inode); +if (error) + goto out; + error =__vfs_setxattr_noperm (dentry, name, value, size, flags); out: +return error; +} +EXPORT_SYMBOL_GPL (__vfs_setxattr_locked); + +int +vfs_setxattr (struct dentry *dentry,const char *name,const void *value, +size_t size,int flags) +{ +struct inode *inode = dentry->d_inode; +struct inode *delegated_inode =NULL ; +int error; + +retry_deleg: +inode_lock (inode); + error =__vfs_setxattr_locked (dentry, name, value, size, flags, + &delegated_inode);inode_unlock (inode); + +if (delegated_inode) { + error =break_deleg_wait (&delegated_inode); +if (!error) + goto retry_deleg; + }return error; }EXPORT_SYMBOL_GPL (vfs_setxattr);
@@ -378,8 +415,18 @@ __vfs_removexattr(struct dentry *dentry, const char *name) }EXPORT_SYMBOL (__vfs_removexattr); +/** +* __vfs_removexattr_locked: set an extended attribute while holding the inode +* lock +* +* @dentry - object to perform setxattr on +* @name - name of xattr to remove +* @delegated_inode - on return, will contain an inode pointer that +* a delegation was broken on, NULL if none. +*/ int -vfs_removexattr (struct dentry *dentry,const char *name) +__vfs_removexattr_locked (struct dentry *dentry,const char *name, +struct inode **delegated_inode) {struct inode *inode = dentry->d_inode;int error;
@@ -388,11 +435,14 @@ vfs_removexattr(struct dentry *dentry, const char *name)if (error)return error; -inode_lock (inode); error =security_inode_removexattr (dentry, name);if (error) goto out; + error =try_break_deleg (inode, delegated_inode); +if (error) + goto out; + error =__vfs_removexattr (dentry, name);if (!error) {
@@ -401,12 +451,32 @@ vfs_removexattr(struct dentry *dentry, const char *name) } out: +return error; +} +EXPORT_SYMBOL_GPL (__vfs_removexattr_locked); + +int +vfs_removexattr (struct dentry *dentry,const char *name) +{ +struct inode *inode = dentry->d_inode; +struct inode *delegated_inode =NULL ; +int error; + +retry_deleg: +inode_lock (inode); + error =__vfs_removexattr_locked (dentry, name, &delegated_inode);inode_unlock (inode); + +if (delegated_inode) { + error =break_deleg_wait (&delegated_inode); +if (!error) + goto retry_deleg; + } +return error; }EXPORT_SYMBOL_GPL (vfs_removexattr); -/* * Extended attribute SET operations */
include/linux/xattr.h +2 -0
@@ -51,8 +51,10 @@ ssize_t vfs_getxattr(struct dentry *, const char *, void *, size_t);ssize_t vfs_listxattr (struct dentry *d,char *list,size_t size);int __vfs_setxattr (struct dentry *,struct inode *,const char *,const void *,size_t ,int );int __vfs_setxattr_noperm (struct dentry *,const char *,const void *,size_t ,int ); +int __vfs_setxattr_locked (struct dentry *,const char *,const void *,size_t ,int ,struct inode **);int vfs_setxattr (struct dentry *,const char *,const void *,size_t ,int );int __vfs_removexattr (struct dentry *,const char *); +int __vfs_removexattr_locked (struct dentry *,const char *,struct inode **);int vfs_removexattr (struct dentry *,const char *);ssize_t generic_listxattr (struct dentry *dentry,char *buffer,size_t buffer_size);
Signature · 1 line
2.17.2
Sasha Levin
maintainerRe: [PATCH v2 01/11] xattr: break delegations in {set,remove}xattr and add _locked versions
Hi
[This is an automated email]
This commit has been processed because it contains a -stable tag. The stable tag indicates that it's relevant for the following trees: all
The bot has tested the following trees: v5.5.13, v5.4.28, v4.19.113, v4.14.174, v4.9.217, v4.4.217.
v5.5.13: Build OK!
v5.4.28: Build OK!
v4.19.113: Build OK!
v4.14.174: Build OK!
v4.9.217: Build OK!
v4.4.217: Failed to apply! Possible dependencies:
5d6c31910bc0 ("xattr: Add __vfs_{get,set,remove}xattr helpers")
6b2553918d8b ("replace ->follow_link() with new method that could stay in RCU mode")
aa80deab33a8 ("namei: page_getlink() and page_follow_link_light() are the same thing")
cd3417c8fc95 ("kill free_page_put_link()")
ce23e6401334 ("->getxattr(): pass dentry and inode as separate arguments")
fceef393a538 ("switch ->get_link() to delayed_call, kill ->put_link()")NOTE: The patch will not be queued to stable trees until it is upstream.
How should we proceed with this patch?
Signature · 2 lines
Thanks Sasha
PATCH v2 2/11 xattr: add a function to check if a namespace is supported
In reply to Frank van der LindenAdd a function that checks is an extended attribute namespace is supported for an inode.
To be used by the nfs server code when being queried for extended attributes support.
--- fs/xattr.c | 27 +++++++++++++++++++++++++++ include/linux/xattr.h | 2 ++ 2 files changed, 29 insertions(+)
fs/xattr.c +27 -0
@@ -134,6 +134,33 @@ xattr_permission(struct inode *inode, const char *name, int mask)return inode_permission (inode, mask); } +/* +* Look for any handler that deals with the specified namespace. +*/ +int +xattr_supported_namespace (struct inode *inode,const char *prefix) +{ +const struct xattr_handler **handlers = inode->i_sb->s_xattr; +const struct xattr_handler *handler; +size_t preflen; + +if (!(inode->i_opflags &IOP_XATTR )) { +if (unlikely (is_bad_inode (inode))) +return -EIO ; +return -EOPNOTSUPP ; + } + + preflen =strlen (prefix); + +for_each_xattr_handler (handlers, handler) { +if (!strncmp (xattr_prefix (handler), prefix, preflen)) +return 0 ; + } + +return -EOPNOTSUPP ; +} +EXPORT_SYMBOL (xattr_supported_namespace); +int __vfs_setxattr (struct dentry *dentry,struct inode *inode,const char *name,const void *value,size_t size,int flags)
include/linux/xattr.h +2 -0
@@ -61,6 +61,8 @@ ssize_t generic_listxattr(struct dentry *dentry, char *buffer, size_t buffer_sizssize_t vfs_getxattr_alloc (struct dentry *dentry,const char *name,char **xattr_value,size_t size,gfp_t flags); +int xattr_supported_namespace (struct inode *inode,const char *prefix); +static inline const char *xattr_prefix (const struct xattr_handler *handler) {return handler->prefix ?: handler->name;
Signature · 1 line
2.17.2
PATCH v2 3/11 nfs,nfsd: NFSv4.2 extended attribute protocol definitions
In reply to Frank van der LindenAdd definitions for the new operations, errors and flags as defined in RFC 8276 (File System Extended Attributes in NFSv4).
--- include/linux/nfs4.h | 20 ++++++++++++++++++++ include/uapi/linux/nfs4.h | 3 +++ 2 files changed, 23 insertions(+)
include/linux/nfs4.h +20 -0
@@ -150,6 +150,12 @@ enum nfs_opnum4 {OP_WRITE_SAME =70 ,OP_CLONE =71 , +/* xattr support (RFC8726) */ +OP_GETXATTR =72 , +OP_SETXATTR =73 , +OP_LISTXATTRS =74 , +OP_REMOVEXATTR =75 , + OP_ILLEGAL = 10044, };
@@ -280,6 +286,10 @@ enum nfsstat4 {NFS4ERR_WRONG_LFS =10092 ,NFS4ERR_BADLABEL =10093 ,NFS4ERR_OFFLOAD_NO_REQS =10094 , + +/* xattr (RFC8276) */ +NFS4ERR_NOXATTR =10095 , + NFS4ERR_XATTR2BIG = 10096, };static inline bool seqid_mutating_err (u32 err)
@@ -452,6 +462,7 @@ enum change_attr_type4 {#define FATTR4_WORD2_CHANGE_ATTR_TYPE (1UL << 15)#define FATTR4_WORD2_SECURITY_LABEL (1UL << 16)#define FATTR4_WORD2_MODE_UMASK (1UL << 17) +#define FATTR4_WORD2_XATTR_SUPPORT (1UL << 18)/* MDS threshold bitmap bits */ #define THRESHOLD_RD (1UL << 0)
@@ -700,4 +711,13 @@ struct nl4_server { struct nfs42_netaddr nl4_addr; /* NL4_NETADDR */ } u; }; + +/* +* Options for setxattr. These match the flags for setxattr(2). +*/ +enum nfs4_setxattr_options { +SETXATTR4_EITHER =0 , +SETXATTR4_CREATE =1 , +SETXATTR4_REPLACE =2 , +};#endif
include/uapi/linux/nfs4.h +3 -0
@@ -33,6 +33,9 @@#define NFS4_ACCESS_EXTEND 0x0008#define NFS4_ACCESS_DELETE 0x0010#define NFS4_ACCESS_EXECUTE 0x0020 +#define NFS4_ACCESS_XAREAD 0x0040 +#define NFS4_ACCESS_XAWRITE 0x0080 +#define NFS4_ACCESS_XALIST 0x0100#define NFS4_FH_PERSISTENT 0x0000#define NFS4_FH_NOEXPIRE_WITH_OPEN 0x0001
Signature · 1 line
2.17.2
PATCH v2 4/11 nfsd: split off the write decode code in to a separate function
In reply to Frank van der Lindennfs4_decode_write has code to parse incoming XDR write data in to a kvec head, and a list of pages.
Put this code in to a separate function, so that it can be used later by the xattr code, for setxattr. No functional change.
--- fs/nfsd/nfs4xdr.c | 72 +++++++++++++++++++++++++++-------------------- 1 file changed, 42 insertions(+), 30 deletions(-)
fs/nfsd/nfs4xdr.c +42 -30
@@ -257,6 +257,44 @@ svcxdr_dupstr(struct nfsd4_compoundargs *argp, void *buf, u32 len)return p; } +static __be32 +svcxdr_construct_vector (struct nfsd4_compoundargs *argp,struct kvec *head, +struct page ***pagelist,u32 buflen) +{ +int avail; +int len; +int pages; + +/* Sorry .. no magic macros for this.. * +* READ_BUF(write->wr_buflen); +* SAVEMEM(write->wr_buf, write->wr_buflen); +*/ + avail = (char *)argp->end - (char *)argp->p; +if (avail + argp->pagelen < buflen) { +dprintk ("NFSD: xdr error (%s:%d)\n" , + __FILE__, __LINE__); +return nfserr_bad_xdr; + } + head->iov_base = argp->p; + head->iov_len = avail; + *pagelist = argp->pagelist; + + len =XDR_QUADLEN (buflen) <<2 ; +if (len >= avail) { + len -= avail; + + pages = len >>PAGE_SHIFT ; + argp->pagelist += pages; + argp->pagelen -= pages *PAGE_SIZE ; + len -= pages *PAGE_SIZE ; + +next_decode_page (argp); + } + argp->p +=XDR_QUADLEN (len); + +return 0 ; +} +/** * savemem - duplicate a chunk of memory for later processing * @argp: NFSv4 compound argument structure to be freed with
@@ -1265,8 +1303,6 @@ nfsd4_decode_verify(struct nfsd4_compoundargs *argp, struct nfsd4_verify *verifystatic __be32 nfsd4_decode_write (struct nfsd4_compoundargs *argp,struct nfsd4_write *write) { -int avail; -int len;DECODE_HEAD ; status =nfsd4_decode_stateid (argp, &write->wr_stateid);
@@ -1279,34 +1315,10 @@ nfsd4_decode_write(struct nfsd4_compoundargs *argp, struct nfsd4_write *write) goto xdr_error; write->wr_buflen =be32_to_cpup (p++); -/* Sorry .. no magic macros for this.. * -* READ_BUF(write->wr_buflen); -* SAVEMEM(write->wr_buf, write->wr_buflen); -*/ - avail = (char *)argp->end - (char *)argp->p; -if (avail + argp->pagelen < write->wr_buflen) { -dprintk ("NFSD: xdr error (%s:%d)\n" , - __FILE__, __LINE__); - goto xdr_error; - } - write->wr_head.iov_base = p; - write->wr_head.iov_len = avail; - write->wr_pagelist = argp->pagelist; - - len =XDR_QUADLEN (write->wr_buflen) <<2 ; -if (len >= avail) { -int pages; - - len -= avail; - - pages = len >>PAGE_SHIFT ; - argp->pagelist += pages; - argp->pagelen -= pages *PAGE_SIZE ; - len -= pages *PAGE_SIZE ; - -next_decode_page (argp); - } - argp->p +=XDR_QUADLEN (len); + status =svcxdr_construct_vector (argp, &write->wr_head, + &write->wr_pagelist, write->wr_buflen); +if (status) +return status;DECODE_TAIL ; }
Signature · 1 line
2.17.2
PATCH v2 5/11 nfsd: add defines for NFSv4.2 extended attribute support
In reply to Frank van der LindenAdd defines for server-side extended attribute support. Most have already been added as part of client support, but these are the network order error codes for the noxattr and xattr2big errors, and the addition of the xattr support to the supported file attributes (if configured).
--- fs/nfsd/nfsd.h | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-)
fs/nfsd/nfsd.h +4 -1
@@ -281,6 +281,8 @@ void nfsd_lockd_shutdown(void);#define nfserr_wrong_lfs cpu_to_be32(NFS4ERR_WRONG_LFS)#define nfserr_badlabel cpu_to_be32(NFS4ERR_BADLABEL)#define nfserr_file_open cpu_to_be32(NFS4ERR_FILE_OPEN) +#define nfserr_xattr2big cpu_to_be32(NFS4ERR_XATTR2BIG) +#define nfserr_noxattr cpu_to_be32(NFS4ERR_NOXATTR)/* error codes for internal use */ /* if a request fails due to kmalloc failure, it gets dropped.
@@ -382,7 +384,8 @@ void nfsd_lockd_shutdown(void); (NFSD4_1_SUPPORTED_ATTRS_WORD2 | \FATTR4_WORD2_CHANGE_ATTR_TYPE | \FATTR4_WORD2_MODE_UMASK | \ - NFSD4_2_SECURITY_ATTRS) +NFSD4_2_SECURITY_ATTRS | \ + FATTR4_WORD2_XATTR_SUPPORT)extern const u32 nfsd_suppattrs[3 ][3 ];
Signature · 1 line
2.17.2
PATCH v2 6/11 nfsd: define xattr functions to call in to their vfs counterparts
In reply to Frank van der LindenThis adds the filehandle based functions for the xattr operations that call in to the vfs layer to do the actual work.
--- fs/nfsd/vfs.c | 130 ++++++++++++++++++++++++++++++++++++++++++++++++++ fs/nfsd/vfs.h | 10 ++++ 2 files changed, 140 insertions(+)
fs/nfsd/vfs.c +130 -0
@@ -2058,6 +2058,136 @@ static int exp_rdonly(struct svc_rqst *rqstp, struct svc_export *exp)return nfsexp_flags (rqstp, exp) &NFSEXP_READONLY ; } +#ifdef CONFIG_NFSD_V4 +/* +* Helper function to translate error numbers. In the case of xattr operations, +* some error codes need to be translated outside of the standard translations. +* +* ENODATA needs to be translated to nfserr_noxattr. +* E2BIG to nfserr_xattr2big. +* +* Additionally, vfs_listxattr can return -ERANGE. This means that the +* file has too many extended attributes to retrieve inside an +* XATTR_LIST_MAX sized buffer. This is a bug in the xattr implementation: +* filesystems will allow the adding of extended attributes until they hit +* their own internal limit. This limit may be larger than XATTR_LIST_MAX. +* So, at that point, the attributes are present and valid, but can't +* be retrieved using listxattr, since the upper level xattr code enforces +* the XATTR_LIST_MAX limit. +* +* This bug means that we need to deal with listxattr returning -ERANGE. The +* best mapping is to return TOOSMALL. +*/ +static __be32 +nfsd_xattr_errno (int err) +{ +switch (err) { +case -ENODATA : +return nfserr_noxattr; +case -E2BIG : +return nfserr_xattr2big; +case -ERANGE : +return nfserr_toosmall; + } +return nfserrno (err); +} + +__be32 +nfsd_getxattr (struct svc_rqst *rqstp,struct svc_fh *fhp,char *name, +void *buf,int *lenp) +{ +ssize_t lerr; +int err; + + err =fh_verify (rqstp, fhp,0 ,NFSD_MAY_READ ); +if (err) +return err; + + lerr =vfs_getxattr (fhp->fh_dentry, name, buf, *lenp); +if (lerr <0 ) + err =nfsd_xattr_errno (lerr); +else + *lenp = lerr; + +return err; +} + +__be32 +nfsd_listxattr (struct svc_rqst *rqstp,struct svc_fh *fhp,void *buf,int *lenp) +{ +ssize_t lerr; +int err; + + err =fh_verify (rqstp, fhp,0 ,NFSD_MAY_READ ); +if (err) +return err; + + lerr =vfs_listxattr (fhp->fh_dentry, buf, *lenp); + +if (lerr <0 ) + err =nfsd_xattr_errno (lerr); +else + *lenp = lerr; + +return err; +} + +/* +* Removexattr and setxattr need to call fh_lock to both lock the inode +* and set the change attribute. Since the top-level vfs_removexattr +* and vfs_setxattr calls already do their own inode_lock calls, call +* the _locked variant. Pass in a NULL pointer for delegated_inode, +* and let the client deal with NFS4ERR_DELAY (same as with e.g. +* setattr and remove). +*/ +__be32 +nfsd_removexattr (struct svc_rqst *rqstp,struct svc_fh *fhp,char *name) +{ +int err, ret; + + err =fh_verify (rqstp, fhp,0 ,NFSD_MAY_WRITE ); +if (err) +return err; + + ret =fh_want_write (fhp); +if (ret) +return nfserrno (ret); + +fh_lock (fhp); + + ret =__vfs_removexattr_locked (fhp->fh_dentry, name,NULL ); + +fh_unlock (fhp); +fh_drop_write (fhp); + +return nfsd_xattr_errno (ret); +} + +__be32 +nfsd_setxattr (struct svc_rqst *rqstp,struct svc_fh *fhp,char *name, +void *buf,u32 len,u32 flags) +{ +int err, ret; + + err =fh_verify (rqstp, fhp,0 ,NFSD_MAY_WRITE ); +if (err) +return err; + + ret =fh_want_write (fhp); +if (ret) +return nfserrno (ret); +fh_lock (fhp); + + ret =__vfs_setxattr_locked (fhp->fh_dentry, name, buf, len, flags, +NULL ); + +fh_unlock (fhp); +fh_drop_write (fhp); + +return nfsd_xattr_errno (ret); +} +#endif +/* * Check for a user's access permissions to this inode. */
fs/nfsd/vfs.h +10 -0
@@ -76,6 +76,16 @@ __be32 do_nfsd_create(struct svc_rqst *, struct svc_fh *,__be32 nfsd_commit (struct svc_rqst *,struct svc_fh *,loff_t ,unsigned long ,__be32 *verf);#endif /* CONFIG_NFSD_V3 */ +#ifdef CONFIG_NFSD_V4 +__be32 nfsd_getxattr (struct svc_rqst *rqstp,struct svc_fh *fhp, +char *name,void *buf,int *lenp); +__be32 nfsd_listxattr (struct svc_rqst *rqstp,struct svc_fh *fhp, +void *buf,int *lenp); +__be32 nfsd_removexattr (struct svc_rqst *rqstp,struct svc_fh *fhp, +char *name); +__be32 nfsd_setxattr (struct svc_rqst *rqstp,struct svc_fh *fhp, +char *name,void *buf,u32 len,u32 flags); +#endif int nfsd_open_break_lease (struct inode *,int );__be32 nfsd_open (struct svc_rqst *,struct svc_fh *,umode_t ,int ,struct file **);
Signature · 1 line
2.17.2
PATCH v2 7/11 nfsd: take xattr bits in to account for permission checks
In reply to Frank van der LindenSince the NFSv4.2 extended attributes extension defines 3 new access bits for xattr operations, take them in to account when validating what the client is asking for, and when checking permissions.
--- fs/nfsd/nfs4proc.c | 8 +++++++- fs/nfsd/vfs.c | 12 ++++++++++++ 2 files changed, 19 insertions(+), 1 deletion(-)
fs/nfsd/nfs4proc.c +7 -1
@@ -566,8 +566,14 @@ nfsd4_access(struct svc_rqst *rqstp, struct nfsd4_compound_state *cstate, union nfsd4_op_u *u) {struct nfsd4_access *access = &u->access; +u32 access_full; -if (access->ac_req_access & ~NFS3_ACCESS_FULL ) + access_full =NFS3_ACCESS_FULL ; +if (cstate->minorversion >=2 ) + access_full |=NFS4_ACCESS_XALIST |NFS4_ACCESS_XAREAD | +NFS4_ACCESS_XAWRITE ; + +if (access->ac_req_access & ~access_full)return nfserr_inval; access->ac_resp_access = access->ac_req_access;
fs/nfsd/vfs.c +12 -0
@@ -612,6 +612,12 @@ static struct accessmap nfs3_regaccess[] = { { NFS3_ACCESS_MODIFY, NFSD_MAY_WRITE|NFSD_MAY_TRUNC }, { NFS3_ACCESS_EXTEND, NFSD_MAY_WRITE }, +#ifdef CONFIG_NFSD_V4 + { NFS4_ACCESS_XAREAD, NFSD_MAY_READ }, + { NFS4_ACCESS_XAWRITE, NFSD_MAY_WRITE }, + { NFS4_ACCESS_XALIST, NFSD_MAY_READ }, +#endif + { 0, 0 } };
@@ -622,6 +628,12 @@ static struct accessmap nfs3_diraccess[] = { { NFS3_ACCESS_EXTEND, NFSD_MAY_EXEC|NFSD_MAY_WRITE }, { NFS3_ACCESS_DELETE, NFSD_MAY_REMOVE }, +#ifdef CONFIG_NFSD_V4 + { NFS4_ACCESS_XAREAD, NFSD_MAY_READ }, + { NFS4_ACCESS_XAWRITE, NFSD_MAY_WRITE }, + { NFS4_ACCESS_XALIST, NFSD_MAY_READ }, +#endif + { 0, 0 } };
Signature · 1 line
2.17.2
PATCH v2 8/11 nfsd: add structure definitions for xattr requests / responses
In reply to Frank van der LindenAdd the structures used in extended attribute request / response handling.
--- fs/nfsd/xdr4.h | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+)
fs/nfsd/xdr4.h +31 -0
@@ -224,6 +224,32 @@ struct nfsd4_putfh {bool no_verify;/* represents foreigh fh */ }; +struct nfsd4_getxattr { +char *getxa_name;/* request */ +u32 getxa_len;/* request */ +void *getxa_buf; +}; + +struct nfsd4_setxattr { +u32 setxa_flags;/* request */ +char *setxa_name;/* request */ +char *setxa_buf;/* request */ +u32 setxa_len;/* request */ +struct nfsd4_change_info setxa_cinfo;/* response */ +}; + +struct nfsd4_removexattr { +char *rmxa_name;/* request */ +struct nfsd4_change_info rmxa_cinfo;/* response */ +}; + +struct nfsd4_listxattrs { +u64 lsxa_cookie;/* request */ +u32 lsxa_maxcount;/* request */ +char *lsxa_buf;/* unfiltered buffer (reply) */ +u32 lsxa_len;/* unfiltered len (reply) */ +}; +struct nfsd4_open {u32 op_claim_type;/* request */ struct xdr_netobj op_fname;/* request - everything but CLAIM_PREV */
@@ -649,6 +675,11 @@ struct nfsd4_op {struct nfsd4_offload_status offload_status;struct nfsd4_copy_notify copy_notify;struct nfsd4_seek seek; + +struct nfsd4_getxattr getxattr; +struct nfsd4_setxattr setxattr; +struct nfsd4_listxattrs listxattrs; +struct nfsd4_removexattr removexattr; } u;struct nfs4_replay * replay; };
Signature · 1 line
2.17.2
PATCH v2 9/11 nfsd: use kvmalloc in svcxdr_tmpalloc
In reply to Frank van der LindenFor user extended attributes, temp allocations larger than one page might be needed.
Use kvmalloc/kvfree to accommodate these larger allocations, while not affecting the performance of the smaller ones.
--- fs/nfsd/nfs4xdr.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
fs/nfsd/nfs4xdr.c +2 -2
@@ -230,7 +230,7 @@ svcxdr_tmpalloc(struct nfsd4_compoundargs *argp, u32 len) {struct svcxdr_tmpbuf *tb; - tb =kmalloc (sizeof (*tb) + len,GFP_KERNEL ); + tb =kvmalloc (sizeof (*tb) + len,GFP_KERNEL );if (!tb)return NULL ; tb->next = argp->to_free;
@@ -4691,7 +4691,7 @@ void nfsd4_release_compoundargs(struct svc_rqst *rqstp)while (args->to_free) {struct svcxdr_tmpbuf *tb = args->to_free; args->to_free = tb->next; -kfree (tb); +kvfree (tb); } }
Signature · 1 line
2.17.2
PATCH v2 10/11 nfsd: implement the xattr functions and en/decode logic
In reply to Frank van der LindenImplement the main entry points for the *XATTR operations.
Add functions to calculate the reply size for the user extended attribute operations, and implement the XDR encode / decode logic for these operations.
Add the user extended attributes operations to nfsd4_ops.
--- fs/nfsd/nfs4proc.c | 132 +++++++++++++ fs/nfsd/nfs4xdr.c | 450 +++++++++++++++++++++++++++++++++++++++++++ include/linux/nfs4.h | 2 +- 3 files changed, 583 insertions(+), 1 deletion(-)
fs/nfsd/nfs4proc.c +132 -0
@@ -2098,6 +2098,80 @@ nfsd4_layoutreturn(struct svc_rqst *rqstp, }#endif /* CONFIG_NFSD_PNFS */ +static __be32 +nfsd4_getxattr (struct svc_rqst *rqstp,struct nfsd4_compound_state *cstate, +union nfsd4_op_u *u) +{ +struct nfsd4_getxattr *getxattr = &u->getxattr; + +return nfsd_getxattr (rqstp, &cstate->current_fh, + getxattr->getxa_name, getxattr->getxa_buf, + &getxattr->getxa_len); +} + +static __be32 +nfsd4_setxattr (struct svc_rqst *rqstp,struct nfsd4_compound_state *cstate, +union nfsd4_op_u *u) +{ +struct nfsd4_setxattr *setxattr = &u->setxattr; +__be32 ret; + +if (opens_in_grace (SVC_NET (rqstp))) +return nfserr_grace; + + ret =nfsd_setxattr (rqstp, &cstate->current_fh, setxattr->setxa_name, + setxattr->setxa_buf, setxattr->setxa_len, + setxattr->setxa_flags); + +if (!ret) +set_change_info (&setxattr->setxa_cinfo, &cstate->current_fh); + +return ret; +} + +static __be32 +nfsd4_listxattrs (struct svc_rqst *rqstp,struct nfsd4_compound_state *cstate, +union nfsd4_op_u *u) +{ +int len; +__be32 ret; + +/* +* Get the entire list, then copy out only the user attributes +* in the encode function. lsxa_buf was previously allocated as +* tmp svc space, and will be automatically freed later. +*/ + len =XATTR_LIST_MAX ; + + ret =nfsd_listxattr (rqstp, &cstate->current_fh, u->listxattrs.lsxa_buf, + &len); +if (ret) +return ret; + + u->listxattrs.lsxa_len = len; + +return nfs_ok; +} + +static __be32 +nfsd4_removexattr (struct svc_rqst *rqstp,struct nfsd4_compound_state *cstate, +union nfsd4_op_u *u) +{ +struct nfsd4_removexattr *removexattr = &u->removexattr; +__be32 ret; + +if (opens_in_grace (SVC_NET (rqstp))) +return nfserr_grace; + + ret =nfsd_removexattr (rqstp, &cstate->current_fh, + removexattr->rmxa_name); + +if (!ret) +set_change_info (&removexattr->rmxa_cinfo, &cstate->current_fh); + +return ret; +} +/* * NULL call. */
@@ -2705,6 +2779,42 @@ static inline u32 nfsd4_seek_rsize(struct svc_rqst *rqstp, struct nfsd4_op *op)return (op_encode_hdr_size +3 ) *sizeof (__be32); } +static inline u32 nfsd4_getxattr_rsize (struct svc_rqst *rqstp, +struct nfsd4_op *op) +{ +u32 maxcount, rlen; + + maxcount =svc_max_payload (rqstp); + rlen =min_t (u32,XATTR_SIZE_MAX , maxcount); + +return (op_encode_hdr_size +1 +XDR_QUADLEN (rlen)) *sizeof (__be32); +} + +static inline u32 nfsd4_setxattr_rsize (struct svc_rqst *rqstp, +struct nfsd4_op *op) +{ +return (op_encode_hdr_size + op_encode_change_info_maxsz) + *sizeof (__be32); +} +static inline u32 nfsd4_listxattrs_rsize (struct svc_rqst *rqstp, +struct nfsd4_op *op) +{ +u32 maxcount, rlen; + + maxcount =svc_max_payload (rqstp); + rlen =min (op->u.listxattrs.lsxa_maxcount, maxcount); + +return (op_encode_hdr_size +4 +XDR_QUADLEN (rlen)) *sizeof (__be32); +} + +static inline u32 nfsd4_removexattr_rsize (struct svc_rqst *rqstp, +struct nfsd4_op *op) +{ +return (op_encode_hdr_size + op_encode_change_info_maxsz) + *sizeof (__be32); +} + +static const struct nfsd4_operation nfsd4_ops[] = { [OP_ACCESS ] = { .op_func = nfsd4_access,
@@ -3086,6 +3196,28 @@ static const struct nfsd4_operation nfsd4_ops[] = { .op_name = "OP_COPY_NOTIFY", .op_rsize_bop = nfsd4_copy_notify_rsize, }, + [OP_GETXATTR] = { + .op_func = nfsd4_getxattr, + .op_name = "OP_GETXATTR", + .op_rsize_bop = nfsd4_getxattr_rsize, + }, + [OP_SETXATTR] = { + .op_func = nfsd4_setxattr, + .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, + .op_name = "OP_SETXATTR", + .op_rsize_bop = nfsd4_setxattr_rsize, + }, + [OP_LISTXATTRS] = { + .op_func = nfsd4_listxattrs, + .op_name = "OP_LISTXATTRS", + .op_rsize_bop = nfsd4_listxattrs_rsize, + }, + [OP_REMOVEXATTR] = { + .op_func = nfsd4_removexattr, + .op_flags = OP_MODIFIES_SOMETHING | OP_CACHEME, + .op_name = "OP_REMOVEXATTR", + .op_rsize_bop = nfsd4_removexattr_rsize, + }, };/**
fs/nfsd/nfs4xdr.c +450 -0
480 lines not on this page · raw message
include/linux/nfs4.h +1 -1
@@ -165,7 +165,7 @@ Needs to be updated if more operations are defined in future.*/#define FIRST_NFS4_OP OP_ACCESS#define LAST_NFS40_OP OP_RELEASE_LOCKOWNER#define LAST_NFS41_OP OP_RECLAIM_COMPLETE -#define LAST_NFS42_OP OP_CLONE +#define LAST_NFS42_OP OP_REMOVEXATTR#define LAST_NFS4_OP LAST_NFS42_OPenum nfsstat4 {
Signature · 1 line
2.17.2
vfs_listxattr and the NFS server: namespaces
Quoted 7 lines · Frank van der Linden
Implement the main entry points for the *XATTR operations.
Add functions to calculate the reply size for the user extended attribute operations, and implement the XDR encode / decode logic for these operations.
Add the user extended attributes operations to
nfsd4_ops.
The reason I Cc-ed this one to linux-fsdevel, is the following piece of code:
Quoted 5 lines
fs/nfsd/nfs4xdr.c +5
-0+/* +* Unfortunately, there is no interface to only list xattrs for +* one prefix. So there is no good way to convert maxcount to +* a maximum value to pass to vfs_listxattr, as we don't know +* how many of the returned attributes will be user attributes.
fs/nfsd/nfs4xdr.c nfsd4_decode_seek(struct nfsd4_compoundargs *argp, struct nfsd4_seek *seek) · line 2091
Quoted 10 lines
fs/nfsd/nfs4xdr.c +10
-0+* +* So, always ask vfs_listxattr for the maximum size, and encode +* as many as possible. +*/ + listxattrs->lsxa_buf =svcxdr_tmpalloc (argp,XATTR_LIST_MAX ); +if (!listxattrs->lsxa_buf) + status = nfserr_jukebox; + +DECODE_TAIL ; +}
Naturally, it is a waste to always (temporarily) allocate XATTR_LIST_MAX (currently 64k) bytes for every listxattr request, when in reality you probably won't need anywhere near that.
The reason for doing that is that, while the NFS request comes with a maximum size, you can't translate that in to a maximum size to pass to vfs_listxattr, since you are specifying the max size for "user." extended attributes only, since that is the namespace that the NFS implementation is restricted to. But vfs_listxattr always retrieves all extended attributes.
The question is then: how to avoid doing that? It might be a good idea to be able to specify a namespace to vfs_listxattr. This isn't terribly hard to implement, and can be phased in. E.g:
* Add a "const char *namespace" argument to the listxattr inode op
* For the normal use case it will be NULL, meaning all xattrs. This includes use in the system call path (a new system call that includes a namespace argument could be added).
* A filesystem that does not support only returning xattrs for one namespace will return a specified error if @namespace != NULL, after which the fs-indepdent code in fs/xattr.c falls back to pre-allocating an XATTR_LIST_MAX buffer and then filtering out all attributes that are not in the specified namespace.
* Since the initial use is from the NFS code, converting XFS and ext4 to support the @namespace argument should catch most use cases of the @namespace argument, the rest can be converted over time.
Does this sound reasonable? Or is it overkill?
Another way to do it is to add a vfs_listxattr_alloc variant, and have the NFS server code filter out the user. xattrs as now. There is one problem with that: it's possible for the size of listxattr result to increase between the first null (length probe) call and the second call, in which case the NFS server would return a spurious error. A small chance, but it's there nonetheless. And it would be hard to distinguish from other errors. So I think I still would prefer using an extra namespace argument.
Alternatively, we could decide that the temporarily allocation of 64k is no big deal.
Thoughts?
- Frank
Re: vfs_listxattr and the NFS server: namespaces
Quoted 70 lines · Frank van der Linden
Quoted 7 lines · Frank van der Linden
Implement the main entry points for the *XATTR operations.
Add functions to calculate the reply size for the user extended attribute operations, and implement the XDR encode / decode logic for these operations.
Add the user extended attributes operations to
nfsd4_ops.The reason I Cc-ed this one to linux-fsdevel, is the following piece of code:
Quoted 5 lines
fs/nfsd/nfs4xdr.c +5
-0+/* +* Unfortunately, there is no interface to only list xattrs for +* one prefix. So there is no good way to convert maxcount to +* a maximum value to pass to vfs_listxattr, as we don't know +* how many of the returned attributes will be user attributes. fs/nfsd/nfs4xdr.c nfsd4_decode_seek(struct nfsd4_compoundargs *argp, struct nfsd4_seek *seek) · line 2091
Quoted 10 lines
fs/nfsd/nfs4xdr.c +10
-0+* +* So, always ask vfs_listxattr for the maximum size, and encode +* as many as possible. +*/ + listxattrs->lsxa_buf =svcxdr_tmpalloc (argp,XATTR_LIST_MAX ); +if (!listxattrs->lsxa_buf) + status = nfserr_jukebox; + +DECODE_TAIL ; +}Naturally, it is a waste to always (temporarily) allocate
XATTR_LIST_MAX(currently 64k) bytes for every listxattr request, when in reality you probably won't need anywhere near that.The reason for doing that is that, while the NFS request comes with a maximum size, you can't translate that in to a maximum size to pass to
vfs_listxattr, since you are specifying the max size for "user." extended attributes only, since that is the namespace that the NFS implementation is restricted to. Butvfs_listxattralways retrieves all extended attributes.The question is then: how to avoid doing that? It might be a good idea to be able to specify a namespace to
vfs_listxattr. This isn't terribly hard to implement, and can be phased in. E.g:* Add a "const char *namespace" argument to the listxattr inode op
* For the normal use case it will be NULL, meaning all xattrs. This includes use in the system call path (a new system call that includes a namespace argument could be added).
* A filesystem that does not support only returning xattrs for one namespace will return a specified error if @namespace != NULL, after which the fs-indepdent code infs/xattr.cfalls back to pre-allocating anXATTR_LIST_MAXbuffer and then filtering out all attributes that are not in the specified namespace.
* Since the initial use is from the NFS code, converting XFS and ext4 to support the @namespace argument should catch most use cases of the @namespace argument, the rest can be converted over time.Does this sound reasonable? Or is it overkill?
Another way to do it is to add a
vfs_listxattr_allocvariant, and have the NFS server code filter out the user. xattrs as now. There is one problem with that: it's possible for the size of listxattr result to increase between the first null (length probe) call and the second call, in which case the NFS server would return a spurious error. A small chance, but it's there nonetheless. And it would be hard to distinguish from other errors. So I think I still would prefer using an extra namespace argument.
Quoted 2 lines
Alternatively, we could decide that the temporarily allocation of 64k is no big deal.
An order-4 allocation is not something that can be relied upon. I would rather find a way to avoid the need for it if at all possible.
--
Chuck Lever
Re: vfs_listxattr and the NFS server: namespaces
Quoted 5 lines · Chuck Lever
Quoted 2 lines
Alternatively, we could decide that the temporarily allocation of 64k is no big deal.
An order-4 allocation is not something that can be relied upon. I would rather find a way to avoid the need for it if at all possible.
It's not strictly an order-4 allocation anymore, as I changed svcxdr_tmpalloc to use kvmalloc.
But sure, it's best to avoid it, it's a waste.
- Frank
PATCH v2 11/11 nfsd: add fattr support for user extended attributes
In reply to Frank van der LindenCheck if user extended attributes are supported for an inode, and return the answer when being queried for file attributes.
An exported filesystem can now signal its RFC8276 user extended attributes capability.
--- fs/nfsd/nfs4xdr.c | 9 +++++++++ 1 file changed, 9 insertions(+)
fs/nfsd/nfs4xdr.c +9 -0
@@ -3229,6 +3229,15 @@ nfsd4_encode_fattr(struct xdr_stream *xdr, struct svc_fh *fhp, }#endif +if (bmval2 &FATTR4_WORD2_XATTR_SUPPORT ) { + p =xdr_reserve_space (xdr,4 ); +if (!p) + goto out_resource; + err =xattr_supported_namespace (d_inode (dentry), +XATTR_USER_PREFIX ); + *p++ =cpu_to_be32 (err ==0 ); + } + attrlen =htonl (xdr->buf->len - attrlen_offset -4 );write_bytes_to_xdr_buf (xdr->buf, attrlen_offset, &attrlen,4 ); status = nfs_ok;
Signature · 1 line
2.17.2