NFS client user xattr (RFC8276) support
Subsystems (2)
v2 cover NFS client user xattr (RFC8276) support
v1 is here: https://www.spinics.net/lists/linux-nfs/msg76740.html
v2:
* Move nfs4 specific definitions to nfs_fs4.h
* Squash some patches together to avoid unused function warnings when bisecting.
* Made determining server support a two-step process. First, the extended attribute FATTR is verified to be supported, then the value of the attributed is queried in fsinfo to determine support.
* Fixed up Makefile to remove an unneeded extra line.
This was tested as before (using my own stress tests), but also with xfstests-dev. No issues were found, but xfstests needs some fixes to correctly run the applicable xattr tests on NFS. I have those changes, but need to send them out.
I also tested stress-ng-xattr with 1000 workers on the client side, running for 8 hours without problems (except for noting that the session tbl_lock can become quite hot when doing NFS operations by 1000 threads, but that's a separate issue).
Frank van der Linden (13):
nfs,nfsd: NFSv4.2 extended attribute protocol definitions
nfs: add client side only definitions for user xattrs NFSv4.2: define limits and sizes for user xattr handling NFSv4.2: query the server for extended attribute support NFSv4.2: add client side XDR handling for extended attributes
nfs: define nfs_access_get_cached function
NFSv4.2: query the extended attribute access bits
nfs: modify update_changeattr to deal with regular files
nfs: define and use the NFS_INO_INVALID_XATTR flag
nfs: make the buf_to_pages_noslab function available to the nfs code NFSv4.2: add the extended attribute proc functions. NFSv4.2: hook in the user extended attribute handlers NFSv4.2: add client side xattr caching.
fs/nfs/Makefile | 2 +- fs/nfs/client.c | 22 +- fs/nfs/dir.c | 24 +- fs/nfs/inode.c | 16 +- fs/nfs/nfs42.h | 24 + fs/nfs/nfs42proc.c | 248 ++++++++ fs/nfs/nfs42xattr.c | 1083 +++++++++++++++++++++++++++++++++++ fs/nfs/nfs42xdr.c | 438 ++++++++++++++ fs/nfs/nfs4_fs.h | 35 ++ fs/nfs/nfs4client.c | 31 + fs/nfs/nfs4proc.c | 237 +++++++- fs/nfs/nfs4super.c | 10 + fs/nfs/nfs4xdr.c | 31 + fs/nfs/nfstrace.h | 3 +- include/linux/nfs4.h | 25 + include/linux/nfs_fs.h | 12 + include/linux/nfs_fs_sb.h | 6 + include/linux/nfs_xdr.h | 60 +- include/uapi/linux/nfs4.h | 3 + include/uapi/linux/nfs_fs.h | 1 + 20 files changed, 2269 insertions(+), 42 deletions(-) create mode 100644 fs/nfs/nfs42xattr.c
Signature · 1 line
2.17.2
PATCH v2 1/13 nfs,nfsd: NFSv4.2 extended attribute protocol definitions
Add 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 2/13 nfs: add client side only definitions for user xattrs
In reply to Frank van der LindenAdd client-side only definitions for user extended attributes (RFC8276). These are the access bits as used by the client code, and the CLNT procedure number definition.
--- include/linux/nfs4.h | 5 +++++ include/linux/nfs_fs.h | 3 +++ 2 files changed, 8 insertions(+)
include/linux/nfs4.h +5 -0
@@ -553,6 +553,11 @@ enum {NFSPROC4_CLNT_LAYOUTERROR ,NFSPROC4_CLNT_COPY_NOTIFY , + +NFSPROC4_CLNT_GETXATTR , +NFSPROC4_CLNT_SETXATTR , +NFSPROC4_CLNT_LISTXATTRS , + NFSPROC4_CLNT_REMOVEXATTR, };/* nfs41 types */
include/linux/nfs_fs.h +3 -0
@@ -212,6 +212,9 @@ struct nfs4_copy_state {#define NFS_ACCESS_EXTEND 0x0008#define NFS_ACCESS_DELETE 0x0010#define NFS_ACCESS_EXECUTE 0x0020 +#define NFS_ACCESS_XAREAD 0x0040 +#define NFS_ACCESS_XAWRITE 0x0080 +#define NFS_ACCESS_XALIST 0x0100/* * Cache validity bit flags
Signature · 1 line
2.17.2
PATCH v2 3/13 NFSv4.2: define limits and sizes for user xattr handling
In reply to Frank van der LindenSet limits for extended attributes (attribute value size and listxattr buffer size), based on the fs-independent limits (XATTR_*_MAX).
Define the maximum XDR sizes for the RFC 8276 XATTR operations. In the case of operations that carry a larger payload (SETXATTR, GETXATTR, LISTXATTR), these exclude that payload, which is added as separate pages, like other operations do.
Define, much like for read and write operations, the maximum overhead sizes for get/set/listxattr, and use them to limit the maximum payload size for those operations, in combination with the channel attributes.
--- fs/nfs/client.c | 19 ++++++++-- fs/nfs/nfs42.h | 16 +++++++++ fs/nfs/nfs42xdr.c | 74 +++++++++++++++++++++++++++++++++++++++ fs/nfs/nfs4_fs.h | 6 ++++ fs/nfs/nfs4client.c | 31 ++++++++++++++++ include/linux/nfs_fs_sb.h | 5 +++ 6 files changed, 149 insertions(+), 2 deletions(-)
fs/nfs/client.c +17 -2
@@ -50,6 +50,7 @@#include "nfs.h" #include "netns.h" #include "sysfs.h" +#include "nfs42.h" #define NFSDBG_FACILITY NFSDBG_CLIENT
@@ -748,7 +749,7 @@ static int nfs_init_server(struct nfs_server *server,static void nfs_server_set_fsinfo (struct nfs_server *server,struct nfs_fsinfo *fsinfo) { -unsigned long max_rpc_payload; +unsigned long max_rpc_payload, raw_max_rpc_payload;/* Work out a lot of parameters */ if (server->rsize ==0 )
@@ -761,7 +762,9 @@ static void nfs_server_set_fsinfo(struct nfs_server *server,if (fsinfo->wtmax >=512 && server->wsize > fsinfo->wtmax) server->wsize =nfs_block_size (fsinfo->wtmax,NULL ); - max_rpc_payload =nfs_block_size (rpc_max_payload (server->client),NULL ); + raw_max_rpc_payload =rpc_max_payload (server->client); + max_rpc_payload =nfs_block_size (raw_max_rpc_payload,NULL ); +if (server->rsize > max_rpc_payload) server->rsize = max_rpc_payload;if (server->rsize >NFS_MAX_FILE_IO_SIZE )
@@ -794,6 +797,18 @@ static void nfs_server_set_fsinfo(struct nfs_server *server, server->clone_blksize = fsinfo->clone_blksize;/* We're airborne Set socket buffersize */ rpc_setbufsize (server->client, server->wsize +100 , server->rsize +100 ); + +#ifdef CONFIG_NFS_V4_2 +/* +* Defaults until limited by the session parameters. +*/ + server->gxasize = min_t(unsigned int, raw_max_rpc_payload, +XATTR_SIZE_MAX ); + server->sxasize = min_t(unsigned int, raw_max_rpc_payload, +XATTR_SIZE_MAX ); + server->lxasize = min_t(unsigned int, raw_max_rpc_payload, +nfs42_listxattr_xdrsize (XATTR_LIST_MAX )); +#endif }/*
fs/nfs/nfs42.h +16 -0
@@ -6,6 +6,8 @@#ifndef __LINUX_FS_NFS_NFS4_2_H#define __LINUX_FS_NFS_NFS4_2_H +#include <linux/xattr.h> +/* * FIXME: four LAYOUTSTATS calls per compound at most! Do we need to support * more? Need to consider not to pre-alloc too much for a compound.
@@ -36,5 +38,19 @@ static inline bool nfs42_files_from_same_server(struct file *in,return nfs4_check_serverowner_major_id (c_in->cl_serverowner, c_out->cl_serverowner); } + +/* +* Maximum XDR buffer size needed for a listxattr buffer of buflen size. +* +* The upper boundary is a buffer with all 1-byte sized attribute names. +* They would be 7 bytes long in the eventual buffer ("user.x\0"), and +* 8 bytes long XDR-encoded. +* +* Include the trailing eof word as well. +*/ +static inline u32 nfs42_listxattr_xdrsize (u32 buflen) +{ +return ((buflen / (XATTR_USER_PREFIX_LEN +2 )) *8 ) +4 ; +}#endif /* CONFIG_NFS_V4_2 */ #endif /* __LINUX_FS_NFS_NFS4_2_H */
fs/nfs/nfs42xdr.c +74 -0
80 lines not on this page · raw message
fs/nfs/nfs4_fs.h +6 -0
@@ -555,6 +555,12 @@ static inline void nfs4_unregister_sysctl(void)/* nfs4xdr.c */ extern const struct rpc_procinfo nfs4_procedures[]; +#ifdef CONFIG_NFS_V4_2 +extern const u32 nfs42_maxsetxattr_overhead; +extern const u32 nfs42_maxgetxattr_overhead; +extern const u32 nfs42_maxlistxattrs_overhead; +#endif +struct nfs4_mount_data ;/* callback_xdr.c */
fs/nfs/nfs4client.c +31 -0
@@ -993,6 +993,36 @@ static void nfs4_session_limit_rwsize(struct nfs_server *server)#endif /* CONFIG_NFS_V4_1 */ } +/* +* Limit xattr sizes using the channel attributes. +*/ +static void nfs4_session_limit_xasize (struct nfs_server *server) +{ +#ifdef CONFIG_NFS_V4_2 +struct nfs4_session *sess; +u32 server_gxa_sz; +u32 server_sxa_sz; +u32 server_lxa_sz; + +if (!nfs4_has_session (server->nfs_client)) +return ; + + sess = server->nfs_client->cl_session; + + server_gxa_sz = sess->fc_attrs.max_resp_sz - nfs42_maxgetxattr_overhead; + server_sxa_sz = sess->fc_attrs.max_rqst_sz - nfs42_maxsetxattr_overhead; + server_lxa_sz = sess->fc_attrs.max_resp_sz - + nfs42_maxlistxattrs_overhead; + +if (server->gxasize > server_gxa_sz) + server->gxasize = server_gxa_sz; +if (server->sxasize > server_sxa_sz) + server->sxasize = server_sxa_sz; +if (server->lxasize > server_lxa_sz) + server->lxasize = server_lxa_sz; +#endif +} +static int nfs4_server_common_setup (struct nfs_server *server,struct nfs_fh *mntfh,bool auth_probe) {
@@ -1040,6 +1070,7 @@ static int nfs4_server_common_setup(struct nfs_server *server, goto out;nfs4_session_limit_rwsize (server); +nfs4_session_limit_xasize (server);if (server->namelen ==0 || server->namelen >NFS4_MAXNAMLEN ) server->namelen =NFS4_MAXNAMLEN ;
include/linux/nfs_fs_sb.h +5 -0
@@ -163,6 +163,11 @@ struct nfs_server {unsigned int dtsize;/* readdir size */ unsigned short port;/* "port=" setting */ unsigned int bsize;/* server block size */ +#ifdef CONFIG_NFS_V4_2 +unsigned int gxasize;/* getxattr size */ +unsigned int sxasize;/* setxattr size */ +unsigned int lxasize;/* listxattr size */ +#endif unsigned int acregmin;/* attr cache timeouts */ unsigned int acregmax;unsigned int acdirmin;
Signature · 1 line
2.17.2
PATCH v2 4/13 NFSv4.2: query the server for extended attribute support
In reply to Frank van der LindenQuery the server for extended attribute support, and record it as the NFS_CAP_XATTR flag in the server capabilities.
--- fs/nfs/client.c | 3 +++ fs/nfs/nfs4proc.c | 3 ++- fs/nfs/nfs4xdr.c | 25 +++++++++++++++++++++++++ include/linux/nfs_fs_sb.h | 1 + include/linux/nfs_xdr.h | 1 + 5 files changed, 32 insertions(+), 1 deletion(-)
fs/nfs/client.c +3 -0
@@ -808,6 +808,9 @@ static void nfs_server_set_fsinfo(struct nfs_server *server, XATTR_SIZE_MAX); server->lxasize = min_t(unsigned int, raw_max_rpc_payload,nfs42_listxattr_xdrsize (XATTR_LIST_MAX )); + +if (fsinfo->xattr_support) + server->caps |=NFS_CAP_XATTR ;#endif }
fs/nfs/nfs4proc.c +2 -1
@@ -256,6 +256,7 @@ const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE | FATTR4_WORD1_FS_LAYOUT_TYPES, FATTR4_WORD2_LAYOUT_BLKSIZE | FATTR4_WORD2_CLONE_BLKSIZE + | FATTR4_WORD2_XATTR_SUPPORT };const u32 nfs4_fs_locations_bitmap[3 ] = {
@@ -3737,7 +3738,7 @@ static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)#define FATTR4_WORD1_NFS40_MASK (2*FATTR4_WORD1_MOUNTED_ON_FILEID - 1UL)#define FATTR4_WORD2_NFS41_MASK (2*FATTR4_WORD2_SUPPATTR_EXCLCREAT - 1UL) -#define FATTR4_WORD2_NFS42_MASK (2*FATTR4_WORD2_MODE_UMASK - 1UL) +#define FATTR4_WORD2_NFS42_MASK (2*FATTR4_WORD2_XATTR_SUPPORT - 1UL)static int _nfs4_server_capabilities (struct nfs_server *server,struct nfs_fh *fhandle) {
fs/nfs/nfs4xdr.c +25 -0
@@ -4201,6 +4201,26 @@ static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, strreturn status; } +static int decode_attr_xattrsupport (struct xdr_stream *xdr,uint32_t *bitmap, +uint32_t *res) +{ +__be32 *p; + + *res =0 ; +if (unlikely (bitmap[2 ] & (FATTR4_WORD2_XATTR_SUPPORT -1U ))) +return -EIO ; +if (likely (bitmap[2 ] &FATTR4_WORD2_XATTR_SUPPORT )) { + p =xdr_inline_decode (xdr,4 ); +if (unlikely (!p)) +return -EIO ; + *res =be32_to_cpup (p); + bitmap[2 ] &= ~FATTR4_WORD2_XATTR_SUPPORT ; + } +dprintk ("%s: XATTR support=%s\n" , __func__, + *res ==0 ?"false" :"true" ); +return 0 ; +} +static int verify_attr_len (struct xdr_stream *xdr,unsigned int savep,uint32_t attrlen) {unsigned int attrwords =XDR_QUADLEN (attrlen);
@@ -4855,6 +4875,11 @@ static int decode_fsinfo(struct xdr_stream *xdr, struct nfs_fsinfo *fsinfo)if (status) goto xdr_error; + status =decode_attr_xattrsupport (xdr, bitmap, + &fsinfo->xattr_support); +if (status) + goto xdr_error; + status =verify_attr_len (xdr, savep, attrlen); xdr_error:dprintk ("%s: xdr returned %d!\n" , __func__, -status);
include/linux/nfs_fs_sb.h +1 -0
@@ -286,5 +286,6 @@ struct nfs_server {#define NFS_CAP_OFFLOAD_CANCEL (1U << 25)#define NFS_CAP_LAYOUTERROR (1U << 26)#define NFS_CAP_COPY_NOTIFY (1U << 27) +#define NFS_CAP_XATTR (1U << 28)#endif
include/linux/nfs_xdr.h +1 -0
@@ -149,6 +149,7 @@ struct nfs_fsinfo {__u32 layouttype[NFS_MAX_LAYOUT_TYPES ];/* supported pnfs layout driver */ __u32 blksize;/* preferred pnfs io block size */ __u32 clone_blksize;/* granularity of a CLONE operation */ +__u32 xattr_support;/* User xattrs supported */ };struct nfs_fsstat {
Signature · 1 line
2.17.2
PATCH v2 5/13 NFSv4.2: add client side XDR handling for extended attributes
In reply to Frank van der LindenDefine the argument and response structures that will be used for RFC 8276 extended attribute RPC calls, and implement the necessary functions to encode/decode the extended attribute operations.
--- fs/nfs/nfs42xdr.c | 368 +++++++++++++++++++++++++++++++++++++++- fs/nfs/nfs4xdr.c | 6 + include/linux/nfs_xdr.h | 59 ++++++- 3 files changed, 430 insertions(+), 3 deletions(-)
fs/nfs/nfs42xdr.c +366 -2
@@ -169,7 +169,6 @@ decode_clone_maxsz + \ decode_getattr_maxsz) -#ifdef CONFIG_NFS_V4_2 /* Not limited by NFS itself, limited by the generic xattr code */ #define nfs4_xattr_name_maxsz XDR_QUADLEN(XATTR_NAME_MAX)
@@ -241,7 +240,6 @@ const u32 nfs42_maxlistxattrs_overhead = ((RPC_MAX_HEADER_WITH_AUTH + compound_decode_hdr_maxsz + decode_sequence_maxsz + decode_putfh_maxsz + 3) * XDR_UNIT); -#endif static void encode_fallocate (struct xdr_stream *xdr,const struct nfs42_falloc_args *args)
@@ -407,6 +405,210 @@ static void encode_layouterror(struct xdr_stream *xdr,encode_device_error (xdr, &args->errors[0 ]); } +static void encode_setxattr (struct xdr_stream *xdr, +const struct nfs42_setxattrargs *arg, +struct compound_hdr *hdr) +{ +__be32 *p; + +BUILD_BUG_ON (XATTR_CREATE !=SETXATTR4_CREATE ); +BUILD_BUG_ON (XATTR_REPLACE !=SETXATTR4_REPLACE ); + +encode_op_hdr (xdr,OP_SETXATTR , decode_setxattr_maxsz, hdr); + p =reserve_space (xdr,4 ); + *p =cpu_to_be32 (arg->xattr_flags); +encode_string (xdr,strlen (arg->xattr_name), arg->xattr_name); + p =reserve_space (xdr,4 ); + *p =cpu_to_be32 (arg->xattr_len); +if (arg->xattr_len) +xdr_write_pages (xdr, arg->xattr_pages,0 , arg->xattr_len); +} + +static int decode_setxattr (struct xdr_stream *xdr, +struct nfs4_change_info *cinfo) +{ +int status; + + status =decode_op_hdr (xdr,OP_SETXATTR ); +if (status) + goto out; + status =decode_change_info (xdr, cinfo); +out: +return status; +} + + +static void encode_getxattr (struct xdr_stream *xdr,const char *name, +struct compound_hdr *hdr) +{ +encode_op_hdr (xdr,OP_GETXATTR , decode_getxattr_maxsz, hdr); +encode_string (xdr,strlen (name), name); +} + +static int decode_getxattr (struct xdr_stream *xdr, +struct nfs42_getxattrres *res, +struct rpc_rqst *req) +{ +int status; +__be32 *p; +u32 len, rdlen; + + status =decode_op_hdr (xdr,OP_GETXATTR ); +if (status) +return status; + + p =xdr_inline_decode (xdr,4 ); +if (unlikely (!p)) +return -EIO ; + + len =be32_to_cpup (p); +if (len > req->rq_rcv_buf.page_len) +return -ERANGE ; + + res->xattr_len = len; + +if (len >0 ) { + rdlen =xdr_read_pages (xdr, len); +if (rdlen < len) +return -EIO ; + } + +return 0 ; +} + +static void encode_removexattr (struct xdr_stream *xdr,const char *name, +struct compound_hdr *hdr) +{ +encode_op_hdr (xdr,OP_REMOVEXATTR , decode_removexattr_maxsz, hdr); +encode_string (xdr,strlen (name), name); +} + + +static int decode_removexattr (struct xdr_stream *xdr, +struct nfs4_change_info *cinfo) +{ +int status; + + status =decode_op_hdr (xdr,OP_REMOVEXATTR ); +if (status) + goto out; + + status =decode_change_info (xdr, cinfo); +out: +return status; +} + +static void encode_listxattrs (struct xdr_stream *xdr, +const struct nfs42_listxattrsargs *arg, +struct compound_hdr *hdr) +{ +__be32 *p; + +encode_op_hdr (xdr,OP_LISTXATTRS , decode_listxattrs_maxsz +1 , hdr); + + p =reserve_space (xdr,12 ); +if (unlikely (!p)) +return ; + + p =xdr_encode_hyper (p, arg->cookie); +/* +* RFC 8276 says to specify the full max length of the LISTXATTRS +* XDR reply. Count is set to the XDR length of the names array +* plus the EOF marker. So, add the cookie and the names count. +*/ + *p =cpu_to_be32 (arg->count +8 +4 ); +} + +static int decode_listxattrs (struct xdr_stream *xdr, +struct nfs42_listxattrsres *res) +{ +int status; +__be32 *p; +u32 count, len, ulen; +size_t left, copied; +char *buf; + + status =decode_op_hdr (xdr,OP_LISTXATTRS ); +if (status) { +/* +* Special case: for LISTXATTRS, NFS4ERR_TOOSMALL +* should be translated to ERANGE. +*/ +if (status == -ETOOSMALL ) + status = -ERANGE ; + goto out; + } + + p =xdr_inline_decode (xdr,8 ); +if (unlikely (!p)) +return -EIO ; + +xdr_decode_hyper (p, &res->cookie); + + p =xdr_inline_decode (xdr,4 ); +if (unlikely (!p)) +return -EIO ; + + left = res->xattr_len; + buf = res->xattr_buf; + + count =be32_to_cpup (p); + copied =0 ; + +/* +* We have asked for enough room to encode the maximum number +* of possible attribute names, so everything should fit. +* +* But, don't rely on that assumption. Just decode entries +* until they don't fit anymore, just in case the server did +* something odd. +*/ +while (count--) { + p =xdr_inline_decode (xdr,4 ); +if (unlikely (!p)) +return -EIO ; + + len =be32_to_cpup (p); +if (len > (XATTR_NAME_MAX -XATTR_USER_PREFIX_LEN )) { + status = -ERANGE ; + goto out; + } + + p =xdr_inline_decode (xdr, len); +if (unlikely (!p)) +return -EIO ; + + ulen = len +XATTR_USER_PREFIX_LEN +1 ; +if (buf) { +if (ulen > left) { + status = -ERANGE ; + goto out; + } + +memcpy (buf,XATTR_USER_PREFIX ,XATTR_USER_PREFIX_LEN ); +memcpy (buf +XATTR_USER_PREFIX_LEN , p, len); + + buf[ulen -1 ] =0 ; + buf += ulen; + left -= ulen; + } + copied += ulen; + } + + p =xdr_inline_decode (xdr,4 ); +if (unlikely (!p)) +return -EIO ; + + res->eof =be32_to_cpup (p); + res->copied = copied; + +out: +if (status == -ERANGE && res->xattr_len ==XATTR_LIST_MAX ) + status = -E2BIG ; + +return status; +} +/* * Encode ALLOCATE request */
@@ -1062,4 +1264,166 @@ static int nfs4_xdr_dec_layouterror(struct rpc_rqst *rqstp,return status; } +#ifdef CONFIG_NFS_V4_2 +static void nfs4_xdr_enc_setxattr (struct rpc_rqst *req,struct xdr_stream *xdr, +const void *data) +{ +const struct nfs42_setxattrargs *args = data; +struct compound_hdr hdr = { + .minorversion =nfs4_xdr_minorversion (&args->seq_args), + }; + +encode_compound_hdr (xdr, req, &hdr); +encode_sequence (xdr, &args->seq_args, &hdr); +encode_putfh (xdr, args->fh, &hdr); +encode_setxattr (xdr, args, &hdr); +encode_nops (&hdr); +} + +static int nfs4_xdr_dec_setxattr (struct rpc_rqst *req,struct xdr_stream *xdr, +void *data) +{ +struct nfs42_setxattrres *res = data; +struct compound_hdr hdr; +int status; + + status =decode_compound_hdr (xdr, &hdr); +if (status) + goto out; + status =decode_sequence (xdr, &res->seq_res, req); +if (status) + goto out; + status =decode_putfh (xdr); +if (status) + goto out; + + status =decode_setxattr (xdr, &res->cinfo); +out: +return status; +} + +static void nfs4_xdr_enc_getxattr (struct rpc_rqst *req,struct xdr_stream *xdr, +const void *data) +{ +const struct nfs42_getxattrargs *args = data; +struct compound_hdr hdr = { + .minorversion =nfs4_xdr_minorversion (&args->seq_args), + }; +size_t plen; + +encode_compound_hdr (xdr, req, &hdr); +encode_sequence (xdr, &args->seq_args, &hdr); +encode_putfh (xdr, args->fh, &hdr); +encode_getxattr (xdr, args->xattr_name, &hdr); + + plen = args->xattr_len ? args->xattr_len :XATTR_SIZE_MAX ; + +rpc_prepare_reply_pages (req, args->xattr_pages,0 , plen, + hdr.replen); + req->rq_rcv_buf.flags |=XDRBUF_SPARSE_PAGES ; + +encode_nops (&hdr); +} + +static int nfs4_xdr_dec_getxattr (struct rpc_rqst *rqstp, +struct xdr_stream *xdr,void *data) +{ +struct nfs42_getxattrres *res = data; +struct compound_hdr hdr; +int status; + + status =decode_compound_hdr (xdr, &hdr); +if (status) + goto out; + status =decode_sequence (xdr, &res->seq_res, rqstp); +if (status) + goto out; + status =decode_putfh (xdr); +if (status) + goto out; + status =decode_getxattr (xdr, res, rqstp); +out: +return status; +} + +static void nfs4_xdr_enc_listxattrs (struct rpc_rqst *req, +struct xdr_stream *xdr,const void *data) +{ +const struct nfs42_listxattrsargs *args = data; +struct compound_hdr hdr = { + .minorversion =nfs4_xdr_minorversion (&args->seq_args), + }; + +encode_compound_hdr (xdr, req, &hdr); +encode_sequence (xdr, &args->seq_args, &hdr); +encode_putfh (xdr, args->fh, &hdr); +encode_listxattrs (xdr, args, &hdr); + +rpc_prepare_reply_pages (req, args->xattr_pages,0 , args->count, + hdr.replen); + req->rq_rcv_buf.flags |=XDRBUF_SPARSE_PAGES ; + +encode_nops (&hdr); +} + +static int nfs4_xdr_dec_listxattrs (struct rpc_rqst *rqstp, +struct xdr_stream *xdr,void *data) +{ +struct nfs42_listxattrsres *res = data; +struct compound_hdr hdr; +int status; + +xdr_set_scratch_buffer (xdr,page_address (res->scratch),PAGE_SIZE ); + + status =decode_compound_hdr (xdr, &hdr); +if (status) + goto out; + status =decode_sequence (xdr, &res->seq_res, rqstp); +if (status) + goto out; + status =decode_putfh (xdr); +if (status) + goto out; + status =decode_listxattrs (xdr, res); +out: +return status; +} + +static void nfs4_xdr_enc_removexattr (struct rpc_rqst *req, +struct xdr_stream *xdr,const void *data) +{ +const struct nfs42_removexattrargs *args = data; +struct compound_hdr hdr = { + .minorversion =nfs4_xdr_minorversion (&args->seq_args), + }; + +encode_compound_hdr (xdr, req, &hdr); +encode_sequence (xdr, &args->seq_args, &hdr); +encode_putfh (xdr, args->fh, &hdr); +encode_removexattr (xdr, args->xattr_name, &hdr); +encode_nops (&hdr); +} + +static int nfs4_xdr_dec_removexattr (struct rpc_rqst *req, +struct xdr_stream *xdr,void *data) +{ +struct nfs42_removexattrres *res = data; +struct compound_hdr hdr; +int status; + + status =decode_compound_hdr (xdr, &hdr); +if (status) + goto out; + status =decode_sequence (xdr, &res->seq_res, req); +if (status) + goto out; + status =decode_putfh (xdr); +if (status) + goto out; + + status =decode_removexattr (xdr, &res->cinfo); +out: +return status; +} +#endif #endif /* __LINUX_FS_NFS_NFS4_2XDR_H */
fs/nfs/nfs4xdr.c +6 -0
@@ -7481,6 +7481,8 @@ static struct { { NFS4ERR_SYMLINK, -ELOOP }, { NFS4ERR_OP_ILLEGAL, -EOPNOTSUPP }, { NFS4ERR_DEADLOCK, -EDEADLK }, + { NFS4ERR_NOXATTR, -ENODATA }, + { NFS4ERR_XATTR2BIG, -E2BIG }, { -1, -EIO } };
@@ -7609,6 +7611,10 @@ const struct rpc_procinfo nfs4_procedures[] = {PROC42 (COPY_NOTIFY , enc_copy_notify, dec_copy_notify),PROC (LOOKUPP , enc_lookupp, dec_lookupp),PROC42 (LAYOUTERROR , enc_layouterror, dec_layouterror), +PROC42 (GETXATTR , enc_getxattr, dec_getxattr), +PROC42 (SETXATTR , enc_setxattr, dec_setxattr), +PROC42 (LISTXATTRS , enc_listxattrs, dec_listxattrs), + PROC42(REMOVEXATTR, enc_removexattr, dec_removexattr), };static unsigned int nfs_version4_counts[ARRAY_SIZE (nfs4_procedures)];
include/linux/nfs_xdr.h +58 -1
65 lines not on this page · raw message
Signature · 1 line
2.17.2
PATCH v2 6/13 nfs: define nfs_access_get_cached function
In reply to Frank van der LindenThe only consumer of nfs_access_get_cached_rcu and nfs_access_cached calls these static functions in order to first try RCU access, and then locked access.
Combine them in to a single function, and call that. Make this function available to the rest of the NFS code.
--- fs/nfs/dir.c | 20 ++++++++++++++++---- include/linux/nfs_fs.h | 2 ++ 2 files changed, 18 insertions(+), 4 deletions(-)
fs/nfs/dir.c +16 -4
@@ -2433,7 +2433,7 @@ static struct nfs_access_entry *nfs_access_search_rbtree(struct inode *inode, coreturn NULL ; } -static int nfs_access_get_cached (struct inode *inode,const struct cred *cred,struct nfs_access_entry *res,bool may_block) +static int nfs_access_get_cached_locked (struct inode *inode,const struct cred *cred,struct nfs_access_entry *res,bool may_block) {struct nfs_inode *nfsi =NFS_I (inode);struct nfs_access_entry *cache;
@@ -2506,6 +2506,20 @@ static int nfs_access_get_cached_rcu(struct inode *inode, const struct cred *crereturn err; } +int nfs_access_get_cached (struct inode *inode,const struct cred *cred,struct +nfs_access_entry *res,bool may_block) +{ +int status; + + status =nfs_access_get_cached_rcu (inode, cred, res); +if (status !=0 ) + status =nfs_access_get_cached_locked (inode, cred, res, + may_block); + +return status; +} +EXPORT_SYMBOL_GPL (nfs_access_get_cached); +static void nfs_access_add_rbtree (struct inode *inode,struct nfs_access_entry *set) {struct nfs_inode *nfsi =NFS_I (inode);
@@ -2620,9 +2634,7 @@ static int nfs_do_access(struct inode *inode, const struct cred *cred, int mask)trace_nfs_access_enter (inode); - status =nfs_access_get_cached_rcu (inode, cred, &cache); -if (status !=0 ) - status =nfs_access_get_cached (inode, cred, &cache, may_block); + status =nfs_access_get_cached (inode, cred, &cache, may_block);if (status ==0 ) goto out_cached;
include/linux/nfs_fs.h +2 -0
@@ -491,6 +491,8 @@ extern int nfs_instantiate(struct dentry *dentry, struct nfs_fh *fh, struct nfs_fattr *fattr, struct nfs4_label *label);extern int nfs_may_open (struct inode *inode,const struct cred *cred,int openflags);extern void nfs_access_zap_cache (struct inode *inode); +extern int nfs_access_get_cached (struct inode *inode,const struct cred *cred,struct nfs_access_entry *res, +bool may_block);/* * linux/fs/nfs/symlink.c
Signature · 1 line
2.17.2
PATCH v2 7/13 NFSv4.2: query the extended attribute access bits
In reply to Frank van der LindenRFC 8276 defines separate ACCESS bits for extended attribute checking. Query them in nfs_do_access and opendata.
--- fs/nfs/dir.c | 4 ++++ fs/nfs/nfs4proc.c | 6 ++++++ 2 files changed, 10 insertions(+)
fs/nfs/dir.c +4 -0
@@ -2646,6 +2646,10 @@ static int nfs_do_access(struct inode *inode, const struct cred *cred, int mask)* Determine which access bits we want to ask for... */ cache.mask =NFS_ACCESS_READ |NFS_ACCESS_MODIFY |NFS_ACCESS_EXTEND ; +if (nfs_server_capable (inode,NFS_CAP_XATTR )) { + cache.mask |=NFS_ACCESS_XAREAD |NFS_ACCESS_XAWRITE | +NFS_ACCESS_XALIST ; + }if (S_ISDIR (inode->i_mode)) cache.mask |=NFS_ACCESS_DELETE |NFS_ACCESS_LOOKUP ;else
fs/nfs/nfs4proc.c +6 -0
@@ -1341,6 +1341,12 @@ static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,NFS4_ACCESS_MODIFY |NFS4_ACCESS_EXTEND |NFS4_ACCESS_EXECUTE ; +#ifdef CONFIG_NFS_V4_2 +if (server->caps &NFS_CAP_XATTR ) + p->o_arg.access |=NFS4_ACCESS_XAREAD | +NFS4_ACCESS_XAWRITE | +NFS4_ACCESS_XALIST ; +#endif } } p->o_arg.clientid = server->nfs_client->cl_clientid;
Signature · 1 line
2.17.2
PATCH v2 8/13 nfs: modify update_changeattr to deal with regular files
In reply to Frank van der LindenUntil now, change attributes in change_info form were only returned by directory operations. However, they are also used for the RFC 8276 extended attribute operations, which work on both directories and regular files. Modify update_changeattr to deal:
* Rename it to nfs4_update_changeattr and make it non-static.
* Don't always use INO_INVALID_DATA, this isn't needed for a directory that only had its extended attributes changed by us.
* Existing callers now always pass in INO_INVALID_DATA.
For the current callers of this function, behavior is unchanged.
--- fs/nfs/nfs4_fs.h | 5 ++++ fs/nfs/nfs4proc.c | 70 +++++++++++++++++++++++++++++------------------ 2 files changed, 49 insertions(+), 26 deletions(-)
fs/nfs/nfs4_fs.h +5 -0
@@ -322,6 +322,11 @@ extern int update_open_stateid(struct nfs4_state *state,extern int nfs4_proc_get_lease_time (struct nfs_client *clp,struct nfs_fsinfo *fsinfo); +extern void nfs4_update_changeattr (struct inode *dir, +struct nfs4_change_info *cinfo, +unsigned long timestamp, +unsigned long cache_validity); +#if defined(CONFIG_NFS_V4_1 )extern int nfs41_sequence_done (struct rpc_task *,struct nfs4_sequence_res *);extern int nfs4_proc_create_session (struct nfs_client *,const struct cred *);
fs/nfs/nfs4proc.c +44 -26
135 lines not on this page · raw message
Signature · 1 line
2.17.2
PATCH v2 9/13 nfs: define and use the NFS_INO_INVALID_XATTR flag
In reply to Frank van der LindenDefine the NFS_INO_INVALID_XATTR flag, to be used for the NFSv4.2 xattr cache, and use it where appropriate.
No functional change as yet.
--- fs/nfs/inode.c | 7 ++++++- fs/nfs/nfs4proc.c | 3 ++- fs/nfs/nfstrace.h | 3 ++- include/linux/nfs_fs.h | 1 + 4 files changed, 11 insertions(+), 3 deletions(-)
fs/nfs/inode.c +6 -1
@@ -205,7 +205,8 @@ static void nfs_set_cache_invalid(struct inode *inode, unsigned long flags) flags &= ~NFS_INO_INVALID_OTHER ; flags &= ~(NFS_INO_INVALID_CHANGE |NFS_INO_INVALID_SIZE - |NFS_INO_REVAL_PAGECACHE ); + |NFS_INO_REVAL_PAGECACHE + |NFS_INO_INVALID_XATTR ); }if (inode->i_mapping->nrpages ==0 )
@@ -535,6 +536,8 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr, st inode->i_gid = fattr->gid; else if (nfs_server_capable(inode, NFS_CAP_OWNER_GROUP)) nfs_set_cache_invalid(inode, NFS_INO_INVALID_OTHER); + if (nfs_server_capable(inode, NFS_CAP_XATTR)) + nfs_set_cache_invalid(inode, NFS_INO_INVALID_XATTR);if (fattr->valid &NFS_ATTR_FATTR_BLOCKS_USED ) inode->i_blocks = fattr->du.nfs2.blocks;if (fattr->valid &NFS_ATTR_FATTR_SPACE_USED ) {
@@ -1365,6 +1368,8 @@ static void nfs_wcc_update_inode(struct inode *inode, struct nfs_fattr *fattr)inode_set_iversion_raw (inode, fattr->change_attr);if (S_ISDIR (inode->i_mode))nfs_set_cache_invalid (inode,NFS_INO_INVALID_DATA ); +else if (nfs_server_capable (inode,NFS_CAP_XATTR )) +nfs_set_cache_invalid (inode,NFS_INO_INVALID_XATTR ); }/* If we have atomic WCC data, we may update some attributes */ ts = inode->i_ctime;
fs/nfs/nfs4proc.c +2 -1
@@ -1183,7 +1183,8 @@ nfs4_update_changeattr_locked(struct inode *inode,if (cinfo->before !=inode_peek_iversion_raw (inode)) nfsi->cache_validity |=NFS_INO_INVALID_ACCESS | -NFS_INO_INVALID_ACL ; +NFS_INO_INVALID_ACL | +NFS_INO_INVALID_XATTR ; }inode_set_iversion_raw (inode, cinfo->after); nfsi->read_cache_jiffies = timestamp;
fs/nfs/nfstrace.h +2 -1
@@ -59,7 +59,8 @@ TRACE_DEFINE_ENUM(NFS_INO_INVALID_OTHER); { NFS_INO_INVALID_CTIME, "INVALID_CTIME" }, \ { NFS_INO_INVALID_MTIME, "INVALID_MTIME" }, \ { NFS_INO_INVALID_SIZE, "INVALID_SIZE" }, \ - { NFS_INO_INVALID_OTHER, "INVALID_OTHER" }) + { NFS_INO_INVALID_OTHER, "INVALID_OTHER" }, \ + { NFS_INO_INVALID_XATTR, "INVALID_XATTR" })TRACE_DEFINE_ENUM (NFS_INO_ADVISE_RDPLUS );TRACE_DEFINE_ENUM (NFS_INO_STALE );
include/linux/nfs_fs.h +1 -0
@@ -233,6 +233,7 @@ struct nfs4_copy_state {#define NFS_INO_INVALID_OTHER BIT(12)/* other attrs are invalid */ #define NFS_INO_DATA_INVAL_DEFER \ BIT(13)/* Deferred cache invalidation */ +#define NFS_INO_INVALID_XATTR BIT(14)/* xattrs are invalid */ #define NFS_INO_INVALID_ATTR (NFS_INO_INVALID_CHANGE \ | NFS_INO_INVALID_CTIME \
Signature · 1 line
2.17.2
PATCH v2 10/13 nfs: make the buf_to_pages_noslab function available to the nfs code
In reply to Frank van der LindenMake the buf_to_pages_noslab function available to the rest of the NFS code. Rename it to nfs4_buf_to_pages_noslab to be consistent.
This will be used later in the NFSv4.2 xattr code.
--- fs/nfs/nfs4_fs.h | 2 ++ fs/nfs/nfs4proc.c | 4 ++-- 2 files changed, 4 insertions(+), 2 deletions(-)
fs/nfs/nfs4_fs.h +2 -0
@@ -326,6 +326,8 @@ extern void nfs4_update_changeattr(struct inode *dir,struct nfs4_change_info *cinfo, unsigned long timestamp, unsigned long cache_validity); +extern int nfs4_buf_to_pages_noslab (const void *buf,size_t buflen, +struct page **pages);#if defined(CONFIG_NFS_V4_1 )extern int nfs41_sequence_done (struct rpc_task *,struct nfs4_sequence_res *);
fs/nfs/nfs4proc.c +2 -2
@@ -5544,7 +5544,7 @@ static inline int nfs4_server_supports_acls(struct nfs_server *server)*/ #define NFS4ACL_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE) -static int buf_to_pages_noslab (const void *buf,size_t buflen, +int nfs4_buf_to_pages_noslab (const void *buf,size_t buflen,struct page **pages) {struct page *newpage, **spages;
@@ -5786,7 +5786,7 @@ static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflreturn -EOPNOTSUPP ;if (npages >ARRAY_SIZE (pages))return -ERANGE ; - i =buf_to_pages_noslab (buf, buflen, arg.acl_pages); + i =nfs4_buf_to_pages_noslab (buf, buflen, arg.acl_pages);if (i <0 )return i;nfs4_inode_make_writeable (inode);
Signature · 1 line
2.17.2
PATCH v2 11/13 NFSv4.2: add the extended attribute proc functions.
In reply to Frank van der LindenImplement the extended attribute procedures for NFSv4.2 extended attribute support (RFC 8276).
--- fs/nfs/nfs42.h | 8 ++ fs/nfs/nfs42proc.c | 236 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 244 insertions(+)
fs/nfs/nfs42.h +8 -0
@@ -39,6 +39,14 @@ static inline bool nfs42_files_from_same_server(struct file *in, c_out->cl_serverowner); } +ssize_t nfs42_proc_getxattr (struct inode *inode,const char *name, +void *buf,size_t buflen); +int nfs42_proc_setxattr (struct inode *inode,const char *name, +const void *buf,size_t buflen,int flags); +ssize_t nfs42_proc_listxattrs (struct inode *inode,void *buf, +size_t buflen,u64 *cookiep,bool *eofp); +int nfs42_proc_removexattr (struct inode *inode,const char *name); +/* * Maximum XDR buffer size needed for a listxattr buffer of buflen size. *
fs/nfs/nfs42proc.c +236 -0
239 lines not on this page · raw message
Signature · 1 line
2.17.2
PATCH v2 12/13 NFSv4.2: hook in the user extended attribute handlers
In reply to Frank van der LindenNow that all the lower level code is there to make the RPC calls, hook it in to the xattr handlers and the listxattr entry point, to make them available.
--- fs/nfs/nfs4proc.c | 123 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 121 insertions(+), 2 deletions(-)
fs/nfs/nfs4proc.c +121 -2
@@ -66,6 +66,7 @@#include "nfs4idmap.h" #include "nfs4session.h" #include "fscache.h" +#include "nfs42.h" #include "nfs4trace.h"
@@ -7442,6 +7443,103 @@ nfs4_listxattr_nfs4_label(struct inode *inode, char *list, size_t list_len)#endif +#ifdef CONFIG_NFS_V4_2 +static int nfs4_xattr_set_nfs4_user (const struct xattr_handler *handler, +struct dentry *unused,struct inode *inode, +const char *key,const void *buf, +size_t buflen,int flags) +{ +struct nfs_access_entry cache; + +if (!nfs_server_capable (inode,NFS_CAP_XATTR )) +return -EOPNOTSUPP ; + +/* +* There is no mapping from the MAY_* flags to the NFS_ACCESS_XA* +* flags right now. Handling of xattr operations use the normal +* file read/write permissions. +* +* Just in case the server has other ideas (which RFC 8276 allows), +* do a cached access check for the XA* flags to possibly avoid +* doing an RPC and getting EACCES back. +*/ +if (!nfs_access_get_cached (inode,current_cred (), &cache, true)) { +if (!(cache.mask &NFS_ACCESS_XAWRITE )) +return -EACCES ; + } + +if (buf ==NULL ) +return nfs42_proc_removexattr (inode, key); +else +return nfs42_proc_setxattr (inode, key, buf, buflen, flags); +} + +static int nfs4_xattr_get_nfs4_user (const struct xattr_handler *handler, +struct dentry *unused,struct inode *inode, +const char *key,void *buf,size_t buflen) +{ +struct nfs_access_entry cache; + +if (!nfs_server_capable (inode,NFS_CAP_XATTR )) +return -EOPNOTSUPP ; + +if (!nfs_access_get_cached (inode,current_cred (), &cache, true)) { +if (!(cache.mask &NFS_ACCESS_XAREAD )) +return -EACCES ; + } + +return nfs42_proc_getxattr (inode, key, buf, buflen); +} + +static ssize_t +nfs4_listxattr_nfs4_user (struct inode *inode,char *list,size_t list_len) +{ +u64 cookie; +bool eof; +int ret, size; +char *buf; +size_t buflen; +struct nfs_access_entry cache; + +if (!nfs_server_capable (inode,NFS_CAP_XATTR )) +return 0 ; + +if (!nfs_access_get_cached (inode,current_cred (), &cache, true)) { +if (!(cache.mask &NFS_ACCESS_XALIST )) +return 0 ; + } + + cookie =0 ; + eof = false; + buflen = list_len ? list_len :XATTR_LIST_MAX ; + buf = list_len ? list :NULL ; + size =0 ; + +while (!eof) { + ret =nfs42_proc_listxattrs (inode, buf, buflen, + &cookie, &eof); +if (ret <0 ) +return ret; + +if (list_len) { + buf += ret; + buflen -= ret; + } + size += ret; + } + +return size; +} + +#else + +static ssize_t +nfs4_listxattr_nfs4_user (struct inode *inode,char *list,size_t list_len) +{ +return 0 ; +} +#endif /* CONFIG_NFS_V4_2 */ +/* * nfs_fhget will use either the mounted_on_fileid or the fileid */
@@ -10039,7 +10137,7 @@ const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {static ssize_t nfs4_listxattr (struct dentry *dentry,char *list,size_t size) { -ssize_t error, error2; +ssize_t error, error2, error3; error =generic_listxattr (dentry, list, size);if (error <0 )
@@ -10052,7 +10150,17 @@ static ssize_t nfs4_listxattr(struct dentry *dentry, char *list, size_t size) error2 =nfs4_listxattr_nfs4_label (d_inode (dentry), list, size);if (error2 <0 )return error2; -return error + error2; + +if (list) { + list += error2; + size -= error2; + } + + error3 =nfs4_listxattr_nfs4_user (d_inode (dentry), list, size); +if (error3 <0 ) +return error3; + +return error + error2 + error3; }static const struct inode_operations nfs4_dir_inode_operations = {
@@ -10140,10 +10248,21 @@ static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = { .set = nfs4_xattr_set_nfs4_acl, }; +#ifdef CONFIG_NFS_V4_2 +static const struct xattr_handler nfs4_xattr_nfs4_user_handler = { + .prefix =XATTR_USER_PREFIX , + .get = nfs4_xattr_get_nfs4_user, + .set = nfs4_xattr_set_nfs4_user, +}; +#endif +const struct xattr_handler *nfs4_xattr_handlers[] = { &nfs4_xattr_nfs4_acl_handler, #ifdef CONFIG_NFS_V4_SECURITY_LABEL &nfs4_xattr_nfs4_label_handler, +#endif +#ifdef CONFIG_NFS_V4_2 + &nfs4_xattr_nfs4_user_handler, #endifNULL };
Signature · 1 line
2.17.2
PATCH v2 13/13 NFSv4.2: add client side xattr caching.
In reply to Frank van der LindenImplement client side caching for NFSv4.2 extended attributes. The cache is a per-inode hashtable, with name/value entries. There is one special entry for the listxattr cache.
NFS inodes have a pointer to a cache structure. The cache structure is allocated on demand, freed when the cache is invalidated.
Memory shrinkers keep the size in check. Large entries (> PAGE_SIZE) are collected by a separate shrinker, and freed more aggressively than others.
--- fs/nfs/Makefile | 2 +- fs/nfs/inode.c | 9 +- fs/nfs/nfs42proc.c | 12 + fs/nfs/nfs42xattr.c | 1083 +++++++++++++++++++++++++++++++++++ fs/nfs/nfs4_fs.h | 22 + fs/nfs/nfs4proc.c | 42 +- fs/nfs/nfs4super.c | 10 + include/linux/nfs_fs.h | 6 + include/uapi/linux/nfs_fs.h | 1 + 9 files changed, 1179 insertions(+), 8 deletions(-) create mode 100644 fs/nfs/nfs42xattr.c
fs/nfs/Makefile +1 -1
@@ -30,7 +30,7 @@ nfsv4-y := nfs4proc.o nfs4xdr.o nfs4state.o nfs4renewd.o nfs4super.o nfs4file.o nfsv4-$(CONFIG_NFS_USE_LEGACY_DNS) += cache_lib.o nfsv4-$(CONFIG_SYSCTL) += nfs4sysctl.o nfsv4-$(CONFIG_NFS_V4_1) += pnfs.o pnfs_dev.o pnfs_nfs.o -nfsv4-$(CONFIG_NFS_V4_2) += nfs42proc.o +nfsv4-$(CONFIG_NFS_V4_2) += nfs42proc.o nfs42xattr.o obj-$(CONFIG_PNFS_FILE_LAYOUT) += filelayout/ obj-$(CONFIG_PNFS_BLOCK) += blocklayout/
fs/nfs/inode.c +8 -1
@@ -194,6 +194,7 @@ bool nfs_check_cache_invalid(struct inode *inode, unsigned long flags)return nfs_check_cache_invalid_not_delegated (inode, flags); } +EXPORT_SYMBOL_GPL (nfs_check_cache_invalid);static void nfs_set_cache_invalid (struct inode *inode,unsigned long flags) {
@@ -235,11 +236,13 @@ static void nfs_zap_caches_locked(struct inode *inode) | NFS_INO_INVALID_DATA |NFS_INO_INVALID_ACCESS |NFS_INO_INVALID_ACL + |NFS_INO_INVALID_XATTR | NFS_INO_REVAL_PAGECACHE); }else nfs_set_cache_invalid (inode,NFS_INO_INVALID_ATTR |NFS_INO_INVALID_ACCESS |NFS_INO_INVALID_ACL + |NFS_INO_INVALID_XATTR |NFS_INO_REVAL_PAGECACHE );nfs_zap_label_cache_locked (nfsi); }
@@ -1885,7 +1888,8 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)if (!(have_writers || have_delegation)) { invalid |=NFS_INO_INVALID_DATA |NFS_INO_INVALID_ACCESS - |NFS_INO_INVALID_ACL ; + |NFS_INO_INVALID_ACL + |NFS_INO_INVALID_XATTR ;/* Force revalidate of all attributes */ save_cache_validity |=NFS_INO_INVALID_CTIME |NFS_INO_INVALID_MTIME
@@ -2084,6 +2088,9 @@ struct inode *nfs_alloc_inode(struct super_block *sb)#if IS_ENABLED (CONFIG_NFS_V4 ) nfsi->nfs4_acl =NULL ;#endif /* CONFIG_NFS_V4 */ +#ifdef CONFIG_NFS_V4_2 + nfsi->xattr_cache =NULL ; +#endif return &nfsi->vfs_inode; }EXPORT_SYMBOL_GPL (nfs_alloc_inode);
fs/nfs/nfs42proc.c +12 -0
@@ -1182,6 +1182,18 @@ static ssize_t _nfs42_proc_getxattr(struct inode *inode, const char *name,if (ret <0 )return ret; +/* +* Normally, the caching is done one layer up, but for successful +* RPCS, always cache the result here, even if the caller was +* just querying the length, or if the reply was too big for +* the caller. This avoids a second RPC in the case of the +* common query-alloc-retrieve cycle for xattrs. +* +* Note that xattr_len is always capped to XATTR_SIZE_MAX. +*/ + +nfs4_xattr_cache_add (inode, name,NULL , pages, res.xattr_len); +if (buflen) {if (res.xattr_len > buflen)return -ERANGE ;
fs/nfs/nfs42xattr.c new file +1083 -0
1,083 lines not on this page · raw message
fs/nfs/nfs4_fs.h +22 -0
@@ -624,12 +624,34 @@ static inline bool nfs4_state_match_open_stateid_other(const struct nfs4_state *nfs4_stateid_match_other (&state->open_stateid, stateid); } +/* nfs42xattr.c */ +#ifdef CONFIG_NFS_V4_2 +extern int __init nfs4_xattr_cache_init (void ); +extern void nfs4_xattr_cache_exit (void ); +extern void nfs4_xattr_cache_add (struct inode *inode,const char *name, +const char *buf,struct page **pages, +ssize_t buflen); +extern void nfs4_xattr_cache_remove (struct inode *inode,const char *name); +extern ssize_t nfs4_xattr_cache_get (struct inode *inode,const char *name, +char *buf,ssize_t buflen); +extern void nfs4_xattr_cache_set_list (struct inode *inode,const char *buf, +ssize_t buflen); +extern ssize_t nfs4_xattr_cache_list (struct inode *inode,char *buf, +ssize_t buflen); +extern void nfs4_xattr_cache_zap (struct inode *inode);#else +static inline void nfs4_xattr_cache_zap (struct inode *inode) +{ +} +#endif /* CONFIG_NFS_V4_2 */ + +#else /* CONFIG_NFS_V4 */ #define nfs4_close_state (a, b) do { } while (0)#define nfs4_close_sync (a, b) do { } while (0)#define nfs4_state_protect (a, b, c, d) do { } while (0)#define nfs4_state_protect_write (a, b, c, d) do { } while (0) +#endif /* CONFIG_NFS_V4 */ #endif /* __LINUX_FS_NFS_NFS4_FS.H */
fs/nfs/nfs4proc.c +36 -6
84 lines not on this page · raw message
fs/nfs/nfs4super.c +10 -0
@@ -69,6 +69,7 @@ static void nfs4_evict_inode(struct inode *inode)pnfs_destroy_layout (NFS_I (inode));/* First call standard NFS clear_inode() code */ nfs_clear_inode (inode); +nfs4_xattr_cache_zap (inode); }struct nfs_referral_count {
@@ -268,6 +269,12 @@ static int __init init_nfs_v4(void)if (err) goto out1; +#ifdef CONFIG_NFS_V4_2 + err =nfs4_xattr_cache_init (); +if (err) + goto out2; +#endif + err =nfs4_register_sysctl ();if (err) goto out2;
@@ -288,6 +295,9 @@ static void __exit exit_nfs_v4(void)nfs4_pnfs_v3_ds_connect_unload ();unregister_nfs_version (&nfs_v4); +#ifdef CONFIG_NFS_V4_2 +nfs4_xattr_cache_exit (); +#endif nfs4_unregister_sysctl ();nfs_idmap_quit ();nfs_dns_resolver_destroy ();
include/linux/nfs_fs.h +6 -0
@@ -102,6 +102,8 @@ struct nfs_delegation;struct posix_acl ; +struct nfs4_xattr_cache ; +/* * nfs fs inode data in memory */
@@ -188,6 +190,10 @@ struct nfs_inode {struct fscache_cookie *fscache;#endif struct inode vfs_inode; + +#ifdef CONFIG_NFS_V4_2 +struct nfs4_xattr_cache *xattr_cache; +#endif };struct nfs4_copy_state {
include/uapi/linux/nfs_fs.h +1 -0
@@ -56,6 +56,7 @@#define NFSDBG_PNFS 0x1000#define NFSDBG_PNFS_LD 0x2000#define NFSDBG_STATE 0x4000 +#define NFSDBG_XATTRCACHE 0x8000#define NFSDBG_ALL 0xFFFF
Signature · 1 line
2.17.2
Hi Frank.
----- Original Message -----
Quoted 11 lines
From: "Frank van der Linden" <[email protected]>
To: "linux-nfs" <[email protected]>, "Anna Schumaker" <[email protected]>, "Trond Myklebust" <[email protected]>
Cc: "Frank van der Linden" <[email protected]>
Sent: Thursday, March 26, 2020 12:10:38 AM
Subject: [PATCH v2 00/13] NFS client user xattr (RFC8276) supportv1 is here: https://www.spinics.net/lists/linux-nfs/msg76740.html
v2:
Quoted 7 lines
* Move nfs4 specific definitions to
nfs_fs4.h
* Squash some patches together to avoid unused function warnings when bisecting.
* Made determining server support a two-step process. First, the extended attribute FATTR is verified to be supported, then the value of the attributed is queried in fsinfo to determine support.
The new patchset looks broken to me.
Client quiryes for supported attributes and gets xattr_support bit set:
Mar 26 11:27:07 ani.desy.de kernel: decode_attr_supported: bitmask=fcffbfff:40fdbe3e:00040800
However, the attribute never queries, but client makes is decision:
Mar 26 11:27:07 ani.desy.de kernel: decode_attr_xattrsupport: XATTR support=false
The packets can be found here: https://sas.desy.de/index.php/s/GEPiBxPg3eR4aGA
Can you provide packets of your mount/umount round.
Regards,
Tigran.
Quoted 53 lines
* Fixed up
Makefileto remove an unneeded extra line.This was tested as before (using my own stress tests), but also with xfstests-dev. No issues were found, but xfstests needs some fixes to correctly run the applicable xattr tests on NFS. I have those changes, but need to send them out.
I also tested stress-ng-xattr with 1000 workers on the client side, running for 8 hours without problems (except for noting that the session
tbl_lockcan become quite hot when doing NFS operations by 1000 threads, but that's a separate issue).Frank van der Linden (13):
nfs,nfsd: NFSv4.2 extended attribute protocol definitions
nfs: add client side only definitions for user xattrs NFSv4.2: define limits and sizes for user xattr handling NFSv4.2: query the server for extended attribute support NFSv4.2: add client side XDR handling for extended attributes
nfs: definenfs_access_get_cachedfunction
NFSv4.2: query the extended attribute access bits
nfs: modifyupdate_changeattrto deal with regular files
nfs: define and use theNFS_INO_INVALID_XATTRflag
nfs: make thebuf_to_pages_noslabfunction available to the nfs code NFSv4.2: add the extended attribute proc functions. NFSv4.2: hook in the user extended attribute handlers NFSv4.2: add client side xattr caching.fs/nfs/Makefile | 2 +- fs/nfs/client.c | 22 +- fs/nfs/dir.c | 24 +- fs/nfs/inode.c | 16 +- fs/nfs/nfs42.h | 24 + fs/nfs/nfs42proc.c | 248 ++++++++ fs/nfs/nfs42xattr.c | 1083 +++++++++++++++++++++++++++++++++++ fs/nfs/nfs42xdr.c | 438 ++++++++++++++ fs/nfs/nfs4_fs.h | 35 ++ fs/nfs/nfs4client.c | 31 + fs/nfs/nfs4proc.c | 237 +++++++- fs/nfs/nfs4super.c | 10 + fs/nfs/nfs4xdr.c | 31 + fs/nfs/nfstrace.h | 3 +- include/linux/nfs4.h | 25 + include/linux/nfs_fs.h | 12 + include/linux/nfs_fs_sb.h | 6 + include/linux/nfs_xdr.h | 60 +- include/uapi/linux/nfs4.h | 3 + include/uapi/linux/nfs_fs.h | 1 + 20 files changed, 2269 insertions(+), 42 deletions(-)create mode 100644
fs/nfs/nfs42xattr.c--
2.17.2
Quoted 10 lines · Tigran
Hi Frank.
The new patchset looks broken to me.
Client quiryes for supported attributes and gets
xattr_supportbit set:Mar 26 11:27:07 ani.desy.de kernel: decode_attr_supported: bitmask=fcffbfff:40fdbe3e:00040800However, the attribute never queries, but client makes is decision:
Quoted 8 lines
Mar 26 11:27:07 ani.desy.de kernel: decode_attr_xattrsupport: XATTR support=falseThe packets can be found here: https://sas.desy.de/index.php/s/GEPiBxPg3eR4aGA
Can you provide packets of your mount/umount round.
Regards,
Tigran.
Hi Tigran,
This patchset works against the server side patches, and also works against a FreeBSD-current server.
Is this failure happening with your Java server?
Let me look at your packet dump and compare it with a working scenario.
- Frank
Quoted 6 lines · Tigran
The new patchset looks broken to me.
Client quiryes for supported attributes and gets
xattr_supportbit set:Mar 26 11:27:07 ani.desy.de kernel: decode_attr_supported: bitmask=fcffbfff:40fdbe3e:00040800
Quoted 7 lines
However, the attribute never queries, but client makes is decision:
Mar 26 11:27:07 ani.desy.de kernel: decode_attr_xattrsupport: XATTR support=falseThe packets can be found here: https://sas.desy.de/index.php/s/GEPiBxPg3eR4aGA
Can you provide packets of your mount/umount round.
Hi Tigran,
I looked at your packet dump. It seems like your server only supports 4.1, not 4.2. xattr support builds on 4.2 (within the rules laid out in RFC 8178).
So, the fsinfo client call, which is just a GETATTR, masks out the 4.2 fattr bits from server->attr_mask, and just uses the 4.1 bits. Meaning that xattr_support is not included, and defaults to false.
The packet dump also indicates that your server advertises the xattr_support fattr as supported, even though it's in a 4.1 session, which would not be correct.
- Frank
----- Original Message -----
Quoted 22 lines
From: "Frank van der Linden" <[email protected]>
To: "Tigran Mkrtchyan" <[email protected]>
Cc: "linux-nfs" <[email protected]>, "Anna Schumaker" <[email protected]>, "Trond Myklebust" <[email protected]>
Sent: Friday, March 27, 2020 12:16:02 AM
Subject: Re: [PATCH v2 00/13] NFS client user xattr (RFC8276) supportQuoted 14 lines · Tigran
The new patchset looks broken to me.
Client quiryes for supported attributes and gets
xattr_supportbit set:Mar 26 11:27:07 ani.desy.de kernel: decode_attr_supported:bitmask=fcffbfff:40fdbe3e:00040800
However, the attribute never queries, but client makes is decision:
Mar 26 11:27:07 ani.desy.de kernel: decode_attr_xattrsupport: XATTRsupport=false
The packets can be found here: https://sas.desy.de/index.php/s/GEPiBxPg3eR4aGA
Quoted 7 lines
Quoted 1 line
Can you provide packets of your mount/umount round.
Hi Tigran,
I looked at your packet dump. It seems like your server only supports 4.1, not 4.2. xattr support builds on 4.2 (within the rules laid out in RFC 8178).
That's right, this is what rfc8276 says:
Note that the XDR code contained in this document depends on types from the NFSv4.2 nfs4_prot.x file [RFC7863]. This includes both nfs types that end with a 4, such as nfs_cookie4, count4, etc., as well as more-generic types, such as opaque and bool.
However, xattr support doesn't relays on any functionality provided by v4.2. Moreover, all used data structures (nfs_cookie4, component4, change_info4) defined in nfsv4.0. Thus there are no reasons why even v4.0 server can't support xattrs.
Quoted 4 lines
So, the fsinfo client call, which is just a GETATTR, masks out the 4.2 fattr bits from
server->attr_mask, and just uses the 4.1 bits. Meaning thatxattr_supportis not included, and defaults to false.
I was expecting something like this, but was unable to find the place where this masking is happening.
Tigran.
Quoted 6 lines
The packet dump also indicates that your server advertises the
xattr_supportfattr as supported, even though it's in a 4.1 session, which would not be correct.- Frank
A message that is not in the archive (sent off-list or not yet received): v2aze7-yqvuvfuc4i30-1xxisr-dr39sbpkxym7-2nbcltx37gs3ezoql-qoc5f45hvih45iurdv-lqtdu9ppbm6i-upakk-2awl3v-em4ktl4ip5gchvuicg-vgnve1-wbqe5p-fw96bj-ct2sjj-wlbpk7.1586002736523@email.android.com
Dear maintainers,
are those changes considered for 5.8?
Thanks,
Tigran.
----- Original Message -----
Quoted 81 lines
From: "Tigran Mkrtchyan" <[email protected]>
To: "Frank van der Linden" <[email protected]>
Cc: "linux-nfs" <[email protected]>, "Anna Schumaker" <[email protected]>, "Trond Myklebust" <[email protected]>
Sent: Saturday, April 4, 2020 2:18:54 PM
Subject: Re:[PATCH v2 00/13] NFS client user xattr (RFC8276) supportAfter adding 'minimal' 4.2 implementation to our server, the patchset works as expected.
Thanks, Tigran.-------- Original message --------
From: "Mkrtchyan, Tigran" <[email protected]>
Date: Fri, Mar 27, 2020, 08:51
To: Frank van der Linden <[email protected]>
Cc: linux-nfs <[email protected]>, Anna Schumaker <[email protected]>, Trond Myklebust <[email protected]>
Subject: Re: [PATCH v2 00/13] NFS client user xattr (RFC8276) support----- Original Message -----
Quoted 23 lines
From: "Frank van der Linden" <[email protected]>
To: "Tigran Mkrtchyan" <[email protected]>
Cc: "linux-nfs" <[email protected]>, "Anna Schumaker" <[email protected]>, "Trond Myklebust" <[email protected]>
Sent: Friday, March 27, 2020 12:16:02 AM
Subject: Re: [PATCH v2 00/13] NFS client user xattr (RFC8276) supportQuoted 14 lines · Tigran
The new patchset looks broken to me.
Client quiryes for supported attributes and gets
xattr_supportbit set:Mar 26 11:27:07 ani.desy.de kernel: decode_attr_supported:bitmask=fcffbfff:40fdbe3e:00040800
However, the attribute never queries, but client makes is decision:
Mar 26 11:27:07 ani.desy.de kernel: decode_attr_xattrsupport: XATTRsupport=false
The packets can be found here: https://sas.desy.de/index.php/s/GEPiBxPg3eR4aGA
Quoted 7 lines
Quoted 1 line
Can you provide packets of your mount/umount round.
Hi Tigran,
I looked at your packet dump. It seems like your server only supports 4.1, not 4.2. xattr support builds on 4.2 (within the rules laid out in RFC 8178).
That's right, this is what rfc8276 says:
Note that the XDR code contained in this document depends on types from the NFSv4.2 nfs4_prot.x file [RFC7863]. This includes both nfs types that end with a 4, such as
nfs_cookie4, count4, etc., as well as more-generic types, such as opaque and bool.However, xattr support doesn't relays on any functionality provided by v4.2. Moreover,
all used data structures (nfs_cookie4, component4,change_info4) defined in nfsv4.0.
Thus there are no reasons why even v4.0 server can't support xattrs.Quoted 4 lines
So, the fsinfo client call, which is just a GETATTR, masks out the 4.2 fattr bits from
server->attr_mask, and just uses the 4.1 bits. Meaning thatxattr_supportis not included, and defaults to false.I was expecting something like this, but was unable to find the place where this masking is happening.
Tigran.
Quoted 6 lines
The packet dump also indicates that your server advertises the
xattr_supportfattr as supported, even though it's in a 4.1 session, which would not be correct.- Frank
Hi Tigran,
Quoted 5 lines · Tigran
Dear maintainers,
are those changes considered for 5.8?
My understanding is that these patches will be targeting 5.9.
Anna
Quoted 86 lines
Thanks,
Tigran.----- Original Message -----
Quoted 81 lines
From: "Tigran Mkrtchyan" <[email protected]>
To: "Frank van der Linden" <[email protected]>
Cc: "linux-nfs" <[email protected]>, "Anna Schumaker" <[email protected]>, "Trond Myklebust" <[email protected]>
Sent: Saturday, April 4, 2020 2:18:54 PM
Subject: Re:[PATCH v2 00/13] NFS client user xattr (RFC8276) supportAfter adding 'minimal' 4.2 implementation to our server, the patchset works as expected.
Thanks, Tigran.-------- Original message --------
From: "Mkrtchyan, Tigran" <[email protected]>
Date: Fri, Mar 27, 2020, 08:51
To: Frank van der Linden <[email protected]>
Cc: linux-nfs <[email protected]>, Anna Schumaker <[email protected]>, Trond Myklebust <[email protected]>
Subject: Re: [PATCH v2 00/13] NFS client user xattr (RFC8276) support----- Original Message -----
Quoted 23 lines
From: "Frank van der Linden" <[email protected]>
To: "Tigran Mkrtchyan" <[email protected]>
Cc: "linux-nfs" <[email protected]>, "Anna Schumaker" <[email protected]>, "Trond Myklebust" <[email protected]>
Sent: Friday, March 27, 2020 12:16:02 AM
Subject: Re: [PATCH v2 00/13] NFS client user xattr (RFC8276) supportQuoted 14 lines · Tigran
The new patchset looks broken to me.
Client quiryes for supported attributes and gets
xattr_supportbit set:Mar 26 11:27:07 ani.desy.de kernel: decode_attr_supported:bitmask=fcffbfff:40fdbe3e:00040800
However, the attribute never queries, but client makes is decision:
Mar 26 11:27:07 ani.desy.de kernel: decode_attr_xattrsupport: XATTRsupport=false
The packets can be found here: https://sas.desy.de/index.php/s/GEPiBxPg3eR4aGA
Quoted 7 lines
Quoted 1 line
Can you provide packets of your mount/umount round.
Hi Tigran,
I looked at your packet dump. It seems like your server only supports 4.1, not 4.2. xattr support builds on 4.2 (within the rules laid out in RFC 8178).
That's right, this is what rfc8276 says:
Note that the XDR code contained in this document depends on types from the NFSv4.2 nfs4_prot.x file [RFC7863]. This includes both nfs types that end with a 4, such as
nfs_cookie4, count4, etc., as well as more-generic types, such as opaque and bool.However, xattr support doesn't relays on any functionality provided by v4.2. Moreover,
all used data structures (nfs_cookie4, component4,change_info4) defined in nfsv4.0.
Thus there are no reasons why even v4.0 server can't support xattrs.Quoted 4 lines
So, the fsinfo client call, which is just a GETATTR, masks out the 4.2 fattr bits from
server->attr_mask, and just uses the 4.1 bits. Meaning thatxattr_supportis not included, and defaults to false.I was expecting something like this, but was unable to find the place where this masking is happening.
Tigran.
Quoted 6 lines
The packet dump also indicates that your server advertises the
xattr_supportfattr as supported, even though it's in a 4.1 session, which would not be correct.- Frank
Thanks for clarification.
Tigran.
----- Original Message -----
Quoted 108 lines
From: "Anna Schumaker" <[email protected]>
To: "Tigran Mkrtchyan" <[email protected]>
Cc: "linux-nfs" <[email protected]>, "Trond Myklebust" <[email protected]>, "Frank van der Linden" <[email protected]>
Sent: Monday, June 8, 2020 6:15:06 PM
Subject: Re: [PATCH v2 00/13] NFS client user xattr (RFC8276) supportHi Tigran,
Quoted 5 lines · Tigran
Dear maintainers,
are those changes considered for 5.8?
My understanding is that these patches will be targeting 5.9.
Anna
Quoted 87 lines
Thanks,
Tigran.----- Original Message -----
Quoted 82 lines
From: "Tigran Mkrtchyan" <[email protected]>
To: "Frank van der Linden" <[email protected]>
Cc: "linux-nfs" <[email protected]>, "Anna Schumaker" <[email protected]>, "Trond Myklebust" <[email protected]>
Sent: Saturday, April 4, 2020 2:18:54 PM
Subject: Re:[PATCH v2 00/13] NFS client user xattr (RFC8276) supportAfter adding 'minimal' 4.2 implementation to our server, the patchset works as expected.
Thanks, Tigran.-------- Original message --------
From: "Mkrtchyan, Tigran" <[email protected]>
Date: Fri, Mar 27, 2020, 08:51
To: Frank van der Linden <[email protected]>
Cc: linux-nfs <[email protected]>, Anna Schumaker <[email protected]>, Trond Myklebust <[email protected]>
Subject: Re: [PATCH v2 00/13] NFS client user xattr (RFC8276) support----- Original Message -----
Quoted 23 lines
From: "Frank van der Linden" <[email protected]>
To: "Tigran Mkrtchyan" <[email protected]>
Cc: "linux-nfs" <[email protected]>, "Anna Schumaker" <[email protected]>, "Trond Myklebust" <[email protected]>
Sent: Friday, March 27, 2020 12:16:02 AM
Subject: Re: [PATCH v2 00/13] NFS client user xattr (RFC8276) supportQuoted 14 lines · Tigran
The new patchset looks broken to me.
Client quiryes for supported attributes and gets
xattr_supportbit set:Mar 26 11:27:07 ani.desy.de kernel: decode_attr_supported:bitmask=fcffbfff:40fdbe3e:00040800
However, the attribute never queries, but client makes is decision:
Mar 26 11:27:07 ani.desy.de kernel: decode_attr_xattrsupport: XATTRsupport=false
The packets can be found here: https://sas.desy.de/index.php/s/GEPiBxPg3eR4aGA
Quoted 7 lines
Quoted 1 line
Can you provide packets of your mount/umount round.
Hi Tigran,
I looked at your packet dump. It seems like your server only supports 4.1, not 4.2. xattr support builds on 4.2 (within the rules laid out in RFC 8178).
That's right, this is what rfc8276 says:
Note that the XDR code contained in this document depends on types from the NFSv4.2 nfs4_prot.x file [RFC7863]. This includes both nfs types that end with a 4, such as
nfs_cookie4, count4, etc., as well as more-generic types, such as opaque and bool.However, xattr support doesn't relays on any functionality provided by v4.2. Moreover,
all used data structures (nfs_cookie4, component4,change_info4) defined in nfsv4.0.
Thus there are no reasons why even v4.0 server can't support xattrs.Quoted 4 lines
So, the fsinfo client call, which is just a GETATTR, masks out the 4.2 fattr bits from
server->attr_mask, and just uses the 4.1 bits. Meaning thatxattr_supportis not included, and defaults to false.I was expecting something like this, but was unable to find the place where this masking is happening.
Tigran.
Quoted 6 lines
The packet dump also indicates that your server advertises the
xattr_supportfattr as supported, even though it's in a 4.1 session, which would not be correct.- Frank
Quoted 26 lines · Tigran
Thanks for clarification.
Tigran.
----- Original Message -----
Quoted 21 lines
From: "Anna Schumaker" <[email protected]>
To: "Tigran Mkrtchyan" <[email protected]>
Cc: "linux-nfs" <[email protected]>, "Trond Myklebust" <[email protected]>, "Frank van der Linden" <[email protected]>
Sent: Monday, June 8, 2020 6:15:06 PM
Subject: Re: [PATCH v2 00/13] NFS client user xattr (RFC8276) supportHi Tigran,
Quoted 5 lines · Tigran
Dear maintainers,
are those changes considered for 5.8?
My understanding is that these patches will be targeting 5.9.
Anna
Hi Tigran,
Since there is one remaining open issue on the server side changes that needs signoff from the general fs maintainers, I agreed with Bruce & Chuck to target 5.9, as the 5.8 merge window is currently already open, and all the activity is centered around it.
For the client side, there are no open issues that were flagged, so from my side it's all ready to go - except for me to post a v3 rebased to the latest tree, which is easy to do.
In other words, I think it's ok for the client side to go in to 5.8, but it probably makes more sense to have it go in to the same version as the server side, so that's what I proposed to Anna & Trond.
- Frank
Hi Frank,
----- Original Message -----
Quoted 43 lines
From: "Frank van der Linden" <[email protected]>
To: "Tigran Mkrtchyan" <[email protected]>
Cc: "Anna Schumaker" <[email protected]>, "linux-nfs" <[email protected]>, "Trond Myklebust" <[email protected]>
Sent: Monday, June 8, 2020 6:47:42 PM
Subject: Re: [PATCH v2 00/13] NFS client user xattr (RFC8276) supportQuoted 27 lines · Tigran
Thanks for clarification.
Tigran.
----- Original Message -----
Quoted 22 lines
From: "Anna Schumaker" <[email protected]>
To: "Tigran Mkrtchyan" <[email protected]>
Cc: "linux-nfs" <[email protected]>, "Trond Myklebust" <[email protected]>, "Frank van der Linden" <[email protected]>
Sent: Monday, June 8, 2020 6:15:06 PM
Subject: Re: [PATCH v2 00/13] NFS client user xattr (RFC8276) supportHi Tigran,
Quoted 5 lines · Tigran
Dear maintainers,
are those changes considered for 5.8?
My understanding is that these patches will be targeting 5.9.
Anna
Hi Tigran,
Since there is one remaining open issue on the server side changes that needs signoff from the general fs maintainers, I agreed with Bruce & Chuck to target 5.9, as the 5.8 merge window is currently already open, and all the activity is centered around it.
Quoted 7 lines
For the client side, there are no open issues that were flagged, so from my side it's all ready to go - except for me to post a v3 rebased to the latest tree, which is easy to do.
In other words, I think it's ok for the client side to go in to 5.8, but it probably makes more sense to have it go in to the same version as the server side, so that's what I proposed to Anna & Trond.
Makes sense.
Thanks,
Tigran.
Quoted 2 lines
- Frank