client side user xattr (RFC8276) support
Subsystems (2)
v3 cover client side user xattr (RFC8276) support
v3:
* Rebase to v5.8-rc2
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.
v1:
* Client side caching is now included in this patch set.
* As per the discussion, user extended attributes are enabled if the client and server support them (e.g. they support 4.2 and advertise the user extended attribute FATTR). There are no longer options to switch them off on either the client or the server.
* The code is no longer conditioned on a config option.
* The number of patches has been reduced somewhat by merging smaller, related ones.
Original combined client/server RFC:
https://patchwork.kernel.org/cover/11143565/
In general, these patches were, both server and client, tested as follows:
* stress-ng-xattr with 1000 workers
* Test all corner cases (XATTR_SIZE_*)
* Test all failure cases (no xattr, setxattr with different or invalid flags, etc).
* Verify the content of xattrs across several operations.
* Use KASAN and KMEMLEAK for a longer mix of testruns to verify that there were no leaks (after unmounting the filesystem).
* Interop run against FreeBSD server/client implementation.
* Ran xfstests-dev, with no unexpected/new failures as compared to an unpatched kernel. To fully use xfstests-dev, it needed some modifications, as it expects to either use all xattr namespaces, or none. Whereas NFS only suppors the "user." namespace (+ optional ACLs). I will send the changes in seperately.
* Test the memory shrinker for the client side cache by running the client inside a 1G KVM VM, filling up the cache by running an agressive multi-threaded xattr workload, and tracing the shrinker when it kicked in. No memory allocation problems were seen.
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 v3 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 v3 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 v3 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
@@ -749,7 +750,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 )
@@ -762,7 +763,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 )
@@ -795,6 +798,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
@@ -557,6 +557,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
@@ -992,6 +992,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) {
@@ -1039,6 +1069,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 v3 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
@@ -809,6 +809,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 ] = {
@@ -3740,7 +3741,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
@@ -150,6 +150,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 v3 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 v3 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
@@ -2460,7 +2460,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;
@@ -2533,6 +2533,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);
@@ -2647,9 +2661,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
@@ -493,6 +493,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 v3 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
@@ -2673,6 +2673,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 v3 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
@@ -324,6 +324,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 v3 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
@@ -204,7 +204,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 )
@@ -542,6 +543,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 ) {
@@ -1375,6 +1378,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
@@ -234,6 +234,7 @@ struct nfs4_copy_state {#define NFS_INO_DATA_INVAL_DEFER \ BIT(13)/* Deferred cache invalidation */ #define NFS_INO_INVALID_BLOCKS BIT(14)/* cached blocks are invalid */ +#define NFS_INO_INVALID_XATTR BIT(15)/* xattrs are invalid */ #define NFS_INO_INVALID_ATTR (NFS_INO_INVALID_CHANGE \ | NFS_INO_INVALID_CTIME \
Signature · 1 line
2.17.2
PATCH v3 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
@@ -328,6 +328,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
@@ -5541,7 +5541,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;
@@ -5783,7 +5783,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 v3 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 v3 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"
@@ -7440,6 +7441,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 */
@@ -10045,7 +10143,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 )
@@ -10058,7 +10156,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 = {
@@ -10146,10 +10254,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
Re: [PATCH v3 12/13] NFSv4.2: hook in the user extended attribute handlers
Hi,
Quoted 156 lines · Frank van der Linden
Now 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.
Signed-off-by Frank van der Linden <[email protected]>--- fs/nfs/nfs4proc.c | 123 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 121 insertions(+), 2 deletions(-)fs/nfs/nfs4proc.c +110
-2@@ -66,6 +66,7 @@#include "nfs4idmap.h" #include "nfs4session.h" #include "fscache.h" +#include "nfs42.h" #include "nfs4trace.h" @@ -7440,6 +7441,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 */ @@ -10045,7 +10143,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 )@@ -10058,7 +10156,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 = {@@ -10146,10 +10254,21 @@ static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = { .set = nfs4_xattr_set_nfs4_acl,
fs/nfs/nfs4proc.c static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = { · line 10264
Quoted 10 lines
fs/nfs/nfs4proc.c +8
-0}; +#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 +
Any plan to support XATTR_TRUSTED_PREFIX ?
Thanks.
Quoted 13 lines
fs/nfs/nfs4proc.c +3
-1const 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 }; --2.17.2
Re: [PATCH v3 12/13] NFSv4.2: hook in the user extended attribute handlers
Quoted 4 lines · Murphy Zhou
Hi,
On Wed, Jun 24, 2020 at 6:51 AM Frank van der Linden <[email protected]> wrote:
[...]
Quoted 16 lines
fs/nfs/nfs4proc.c static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = { · line 10264
Quoted 13 lines
static const struct
inode_operationsnfs4_dir_inode_operations= {fs/nfs/nfs4proc.c +8
-0@@ -10146,10 +10254,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 +Any plan to support
XATTR_TRUSTED_PREFIX?
Quoted 1 line
Thanks.
This is an implementation of RFC 8276, which explicitly restricts itself to the "user" namespace.
There is currently no portable way to implement the "trusted" namespace within the boundaries of the NFS specification(s), so it's not supported.
- Frank
Re: [PATCH v3 12/13] NFSv4.2: hook in the user extended attribute handlers
Quoted 27 lines · Frank van der Linden
Quoted 4 lines · Murphy Zhou
Hi,
On Wed, Jun 24, 2020 at 6:51 AM Frank van der Linden <[email protected]> wrote:
[...]
Quoted 19 lines
Quoted 6 lines
static const struct
inode_operationsnfs4_dir_inode_operations=
{fs/nfs/nfs4proc.c +0
-0@@ -10146,10 +10254,21 @@ static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = { .set = nfs4_xattr_set_nfs4_acl, };fs/nfs/nfs4proc.c static const struct xattr_handler · line 10266
Quoted 10 lines
fs/nfs/nfs4proc.c +8
-0+#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 +Any plan to support
XATTR_TRUSTED_PREFIX?Quoted 1 line
Thanks.
Quoted 9 lines
This is an implementation of RFC 8276, which explicitly restricts itself
to the "user" namespace.There is currently no portable way to implement the "trusted" namespace
within the boundaries of the NFS specification(s), so it's not supported.
Correct. 'trusted' is just another way to implement private protocols. Those are unacceptable in a shared filesystem environment.
Signature · 3 lines
Trond Myklebust Linux NFS client maintainer, Hammerspace [email protected]
Re: [PATCH v3 12/13] NFSv4.2: hook in the user extended attribute handlers
Quoted 32 lines · Trond Myklebust
Quoted 31 lines · Frank van der Linden
Quoted 4 lines · Murphy Zhou
Hi,
On Wed, Jun 24, 2020 at 6:51 AM Frank van der Linden <[email protected]> wrote:
[...]
Quoted 19 lines
Quoted 6 lines
static const struct
inode_operationsnfs4_dir_inode_operations=
{fs/nfs/nfs4proc.c +0
-0@@ -10146,10 +10254,21 @@ static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = { .set = nfs4_xattr_set_nfs4_acl, };fs/nfs/nfs4proc.c static const struct xattr_handler · line 10266
Quoted 10 lines
fs/nfs/nfs4proc.c +8
-0+#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 +Any plan to support
XATTR_TRUSTED_PREFIX?Quoted 1 line
Thanks.
This is an implementation of RFC 8276, which explicitly restricts itself
to the "user" namespace.
Quoted 8 lines
Quoted 5 lines
There is currently no portable way to implement the "trusted" namespace
within the boundaries of the NFS specification(s), so it's not supported.Correct. 'trusted' is just another way to implement private protocols. Those are unacceptable in a shared filesystem environment.
Thank you guys explanation!
I'm asking because after NFSv4.2 xattr update, there are some xfstests new failures about 'trusted' xattr. Now they can be surely marked as expected.
Quoted 7 lines
Signature · 4 lines
-- Trond Myklebust Linux NFS client maintainer, Hammerspace [email protected]
Signature · 1 line
Murphy
Re: [PATCH v3 12/13] NFSv4.2: hook in the user extended attribute handlers
Quoted 5 lines · Murphy Zhou
Thank you guys explanation!
I'm asking because after NFSv4.2 xattr update, there are some xfstests new failures about 'trusted' xattr. Now they can be surely marked as expected.
I have some patches to xfstests that, amongst other things, split the xfstests xattr requirement checks in to individual namespace checks, so that tests that use "user" xattrs will be run on NFS, but others, e.g. "trusted" do not.
I should clean them off and send them in.
- Frank
Re: [PATCH v3 12/13] NFSv4.2: hook in the user extended attribute handlers
Quoted 7 lines · Frank van der Linden
Quoted 5 lines · Murphy Zhou
Thank you guys explanation!
I'm asking because after NFSv4.2 xattr update, there are some xfstests new failures about 'trusted' xattr. Now they can be surely marked as expected.
Quoted 6 lines
I have some patches to xfstests that, amongst other things, split the xfstests xattr requirement checks in to individual namespace checks, so that tests that use "user" xattrs will be run on NFS, but others, e.g. "trusted" do not.
I should clean them off and send them in.
That's perfect. Thanks!
Quoted 2 lines
- Frank
Signature · 1 line
Murphy
PATCH v3 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
@@ -193,6 +193,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) {
@@ -234,11 +235,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); }
@@ -1897,7 +1900,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
@@ -2100,6 +2104,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
@@ -626,12 +626,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 Trond, Anna
Any comments on this series? Do you think it can be included for 5.9?
The server side patches are looking pretty good for 5.9.
Let me know if there's anything you want me to do/test.
Thanks,
- Frank
On 6/23/20, 3:39 PM, "Frank van der Linden" <[email protected]> wrote:
v3:
* Rebase to v5.8-rc2
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.
v1:
* Client side caching is now included in this patch set.
* As per the discussion, user extended attributes are enabled if the client and server support them (e.g. they support 4.2 and advertise the user extended attribute FATTR). There are no longer options to switch them off on either the client or the server.
* The code is no longer conditioned on a config option.
* The number of patches has been reduced somewhat by merging smaller, related ones.
Original combined client/server RFC:
https://patchwork.kernel.org/cover/11143565/
In general, these patches were, both server and client, tested as follows:
* stress-ng-xattr with 1000 workers
* Test all corner cases (XATTR_SIZE_*)
* Test all failure cases (no xattr, setxattr with different or invalid flags, etc).
* Verify the content of xattrs across several operations.
* Use KASAN and KMEMLEAK for a longer mix of testruns to verify that there were no leaks (after unmounting the filesystem).
* Interop run against FreeBSD server/client implementation.
* Ran xfstests-dev, with no unexpected/new failures as compared to an unpatched kernel. To fully use xfstests-dev, it needed some modifications, as it expects to either use all xattr namespaces, or none. Whereas NFS only suppors the "user." namespace (+ optional ACLs). I will send the changes in seperately.
* Test the memory shrinker for the client side cache by running the client inside a 1G KVM VM, filling up the cache by running an agressive multi-threaded xattr workload, and tracing the shrinker when it kicked in. No memory allocation problems were seen.
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