Release 4.12 include/linux/nfs_xdr.h

#ifndef _LINUX_NFS_XDR_H

#define _LINUX_NFS_XDR_H

#include <linux/nfsacl.h>
#include <linux/sunrpc/gss_api.h>

/*
 * To change the maximum rsize and wsize supported by the NFS client, adjust
 * NFS_MAX_FILE_IO_SIZE.  64KB is a typical maximum, but some servers can
 * support a megabyte or more.  The default is left at 4096 bytes, which is
 * reasonable for NFS over UDP.
 */

#define NFS_MAX_FILE_IO_SIZE	(1048576U)

#define NFS_DEF_FILE_IO_SIZE	(4096U)

#define NFS_MIN_FILE_IO_SIZE	(1024U)


struct nfs4_string {
	
unsigned int len;
	
char *data;
};


struct nfs_fsid {
	
uint64_t		major;
	
uint64_t		minor;
};

/*
 * Helper for checking equality between 2 fsids.
 */


static inline int nfs_fsid_equal(const struct nfs_fsid *a, const struct nfs_fsid *b)
{
	return a->major == b->major && a->minor == b->minor;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Trond Myklebust
36
100.00%
1
100.00%
Total
36
100.00%
1
100.00%


struct nfs4_threshold {
	
__u32	bm;
	
__u32	l_type;
	
__u64	rd_sz;
	
__u64	wr_sz;
	
__u64	rd_io_sz;
	
__u64	wr_io_sz;
};


struct nfs_fattr {
	
unsigned int		valid;		/* which fields are valid */
	
umode_t			mode;
	
__u32			nlink;
	
kuid_t			uid;
	
kgid_t			gid;
	
dev_t			rdev;
	
__u64			size;
	union {
		struct {
			
__u32	blocksize;
			
__u32	blocks;
		
} nfs2;
		struct {
			
__u64	used;
		
} nfs3;
	
} du;
	
struct nfs_fsid		fsid;
	
__u64			fileid;
	
__u64			mounted_on_fileid;
	
struct timespec		atime;
	
struct timespec		mtime;
	
struct timespec		ctime;
	
__u64			change_attr;	/* NFSv4 change attribute */
	
__u64			pre_change_attr;/* pre-op NFSv4 change attribute */
	
__u64			pre_size;	/* pre_op_attr.size       */
	
struct timespec		pre_mtime;	/* pre_op_attr.mtime      */
	
struct timespec		pre_ctime;	/* pre_op_attr.ctime      */
	
unsigned long		time_start;
	
unsigned long		gencount;
	
struct nfs4_string	*owner_name;
	
struct nfs4_string	*group_name;
	
struct nfs4_threshold	*mdsthreshold;	/* pNFS threshold hints */
};


#define NFS_ATTR_FATTR_TYPE		(1U << 0)

#define NFS_ATTR_FATTR_MODE		(1U << 1)

#define NFS_ATTR_FATTR_NLINK		(1U << 2)

#define NFS_ATTR_FATTR_OWNER		(1U << 3)

#define NFS_ATTR_FATTR_GROUP		(1U << 4)

#define NFS_ATTR_FATTR_RDEV		(1U << 5)

#define NFS_ATTR_FATTR_SIZE		(1U << 6)

#define NFS_ATTR_FATTR_PRESIZE		(1U << 7)

#define NFS_ATTR_FATTR_BLOCKS_USED	(1U << 8)

#define NFS_ATTR_FATTR_SPACE_USED	(1U << 9)

#define NFS_ATTR_FATTR_FSID		(1U << 10)

#define NFS_ATTR_FATTR_FILEID		(1U << 11)

#define NFS_ATTR_FATTR_ATIME		(1U << 12)

#define NFS_ATTR_FATTR_MTIME		(1U << 13)

#define NFS_ATTR_FATTR_CTIME		(1U << 14)

#define NFS_ATTR_FATTR_PREMTIME		(1U << 15)

#define NFS_ATTR_FATTR_PRECTIME		(1U << 16)

#define NFS_ATTR_FATTR_CHANGE		(1U << 17)

#define NFS_ATTR_FATTR_PRECHANGE	(1U << 18)

#define NFS_ATTR_FATTR_V4_LOCATIONS	(1U << 19)

#define NFS_ATTR_FATTR_V4_REFERRAL	(1U << 20)

#define NFS_ATTR_FATTR_MOUNTPOINT	(1U << 21)

#define NFS_ATTR_FATTR_MOUNTED_ON_FILEID (1U << 22)

#define NFS_ATTR_FATTR_OWNER_NAME	(1U << 23)

#define NFS_ATTR_FATTR_GROUP_NAME	(1U << 24)

#define NFS_ATTR_FATTR_V4_SECURITY_LABEL (1U << 25)


#define NFS_ATTR_FATTR (NFS_ATTR_FATTR_TYPE \
                | NFS_ATTR_FATTR_MODE \
                | NFS_ATTR_FATTR_NLINK \
                | NFS_ATTR_FATTR_OWNER \
                | NFS_ATTR_FATTR_GROUP \
                | NFS_ATTR_FATTR_RDEV \
                | NFS_ATTR_FATTR_SIZE \
                | NFS_ATTR_FATTR_FSID \
                | NFS_ATTR_FATTR_FILEID \
                | NFS_ATTR_FATTR_ATIME \
                | NFS_ATTR_FATTR_MTIME \
                | NFS_ATTR_FATTR_CTIME \
                | NFS_ATTR_FATTR_CHANGE)

#define NFS_ATTR_FATTR_V2 (NFS_ATTR_FATTR \
                | NFS_ATTR_FATTR_BLOCKS_USED)

#define NFS_ATTR_FATTR_V3 (NFS_ATTR_FATTR \
                | NFS_ATTR_FATTR_SPACE_USED)

#define NFS_ATTR_FATTR_V4 (NFS_ATTR_FATTR \
                | NFS_ATTR_FATTR_SPACE_USED \
                | NFS_ATTR_FATTR_V4_SECURITY_LABEL)

/*
 * Maximal number of supported layout drivers.
 */

#define NFS_MAX_LAYOUT_TYPES 8

/*
 * Info on the file system
 */

struct nfs_fsinfo {
	
struct nfs_fattr	*fattr; /* Post-op attributes */
	
__u32			rtmax;	/* max.  read transfer size */
	
__u32			rtpref;	/* pref. read transfer size */
	
__u32			rtmult;	/* reads should be multiple of this */
	
__u32			wtmax;	/* max.  write transfer size */
	
__u32			wtpref;	/* pref. write transfer size */
	
__u32			wtmult;	/* writes should be multiple of this */
	
__u32			dtpref;	/* pref. readdir transfer size */
	
__u64			maxfilesize;
	
struct timespec		time_delta; /* server time granularity */
	
__u32			lease_time; /* in seconds */
	
__u32			nlayouttypes; /* number of layouttypes */
	
__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 */
};


struct nfs_fsstat {
	
struct nfs_fattr	*fattr; /* Post-op attributes */
	
__u64			tbytes;	/* total size in bytes */
	
__u64			fbytes;	/* # of free bytes */
	
__u64			abytes;	/* # of bytes available to user */
	
__u64			tfiles;	/* # of files */
	
__u64			ffiles;	/* # of free files */
	
__u64			afiles;	/* # of files available to user */
};


struct nfs2_fsstat {
	
__u32			tsize;  /* Server transfer size */
	
__u32			bsize;  /* Filesystem block size */
	
__u32			blocks; /* No. of "bsize" blocks on filesystem */
	
__u32			bfree;  /* No. of free "bsize" blocks */
	
__u32			bavail; /* No. of available "bsize" blocks */
};


struct nfs_pathconf {
	
struct nfs_fattr	*fattr; /* Post-op attributes */
	
__u32			max_link; /* max # of hard links */
	
__u32			max_namelen; /* max name length */
};


struct nfs4_change_info {
	
u32			atomic;
	
u64			before;
	
u64			after;
};

struct nfs_seqid;

/* nfs41 sessions channel attributes */

struct nfs4_channel_attrs {
	
u32			max_rqst_sz;
	
u32			max_resp_sz;
	
u32			max_resp_sz_cached;
	
u32			max_ops;
	
u32			max_reqs;
};

struct nfs4_slot;

struct nfs4_sequence_args {
	
struct nfs4_slot	*sa_slot;
	
u8			sa_cache_this : 1,
				
sa_privileged : 1;
};


struct nfs4_sequence_res {
	
struct nfs4_slot	*sr_slot;	/* slot used to send request */
	
unsigned long		sr_timestamp;
	
int			sr_status;	/* sequence operation status */
	
u32			sr_status_flags;
	
u32			sr_highest_slotid;
	
u32			sr_target_highest_slotid;
};


struct nfs4_get_lease_time_args {
	
struct nfs4_sequence_args	la_seq_args;
};


struct nfs4_get_lease_time_res {
	
struct nfs4_sequence_res	lr_seq_res;
	
struct nfs_fsinfo	       *lr_fsinfo;
};

struct xdr_stream;
struct nfs4_xdr_opaque_data;


struct nfs4_xdr_opaque_ops {
	
void (*encode)(struct xdr_stream *, const void *args,
			const struct nfs4_xdr_opaque_data *);
	
void (*free)(struct nfs4_xdr_opaque_data *);
};


struct nfs4_xdr_opaque_data {
	
const struct nfs4_xdr_opaque_ops *ops;
	
void *data;
};


#define PNFS_LAYOUT_MAXSIZE 4096


struct nfs4_layoutdriver_data {
	
struct page **pages;
	
__u32 pglen;
	
__u32 len;
};


struct pnfs_layout_range {
	
u32 iomode;
	
u64 offset;
	
u64 length;
};


struct nfs4_layoutget_args {
	
struct nfs4_sequence_args seq_args;
	
__u32 type;
	
struct pnfs_layout_range range;
	
__u64 minlength;
	
__u32 maxcount;
	
struct inode *inode;
	
struct nfs_open_context *ctx;
	
nfs4_stateid stateid;
	
struct nfs4_layoutdriver_data layout;
};


struct nfs4_layoutget_res {
	
struct nfs4_sequence_res seq_res;
	
__u32 return_on_close;
	
struct pnfs_layout_range range;
	
__u32 type;
	
nfs4_stateid stateid;
	
struct nfs4_layoutdriver_data *layoutp;
};


struct nfs4_layoutget {
	
struct nfs4_layoutget_args args;
	
struct nfs4_layoutget_res res;
	
struct rpc_cred *cred;
	
gfp_t gfp_flags;
};


struct nfs4_getdeviceinfo_args {
	
struct nfs4_sequence_args seq_args;
	
struct pnfs_device *pdev;
	
__u32 notify_types;
};


struct nfs4_getdeviceinfo_res {
	
struct nfs4_sequence_res seq_res;
	
struct pnfs_device *pdev;
	
__u32 notification;
};


struct nfs4_layoutcommit_args {
	
struct nfs4_sequence_args seq_args;
	
nfs4_stateid stateid;
	
__u64 lastbytewritten;
	
struct inode *inode;
	
const u32 *bitmask;
	
size_t layoutupdate_len;
	
struct page *layoutupdate_page;
	
struct page **layoutupdate_pages;
	
__be32 *start_p;
};


struct nfs4_layoutcommit_res {
	
struct nfs4_sequence_res seq_res;
	
struct nfs_fattr *fattr;
	
const struct nfs_server *server;
	
int status;
};


struct nfs4_layoutcommit_data {
	
struct rpc_task task;
	
struct nfs_fattr fattr;
	
struct list_head lseg_list;
	
struct rpc_cred *cred;
	
struct inode *inode;
	
struct nfs4_layoutcommit_args args;
	
struct nfs4_layoutcommit_res res;
};


struct nfs4_layoutreturn_args {
	
struct nfs4_sequence_args seq_args;
	
struct pnfs_layout_hdr *layout;
	
struct inode *inode;
	
struct pnfs_layout_range range;
	
nfs4_stateid stateid;
	
__u32   layout_type;
	
struct nfs4_xdr_opaque_data *ld_private;
};


struct nfs4_layoutreturn_res {
	
struct nfs4_sequence_res seq_res;
	
u32 lrs_present;
	
nfs4_stateid stateid;
};


struct nfs4_layoutreturn {
	
struct nfs4_layoutreturn_args args;
	
struct nfs4_layoutreturn_res res;
	
struct rpc_cred *cred;
	
struct nfs_client *clp;
	
struct inode *inode;
	
int rpc_status;
	
struct nfs4_xdr_opaque_data ld_private;
};


#define PNFS_LAYOUTSTATS_MAXSIZE 256

struct nfs42_layoutstat_args;
struct nfs42_layoutstat_devinfo;

typedef	void (*layoutstats_encode_t)(struct xdr_stream *,
		struct nfs42_layoutstat_args *,
		struct nfs42_layoutstat_devinfo *);

/* Per file per deviceid layoutstats */

struct nfs42_layoutstat_devinfo {
	
struct nfs4_deviceid dev_id;
	
__u64 offset;
	
__u64 length;
	
__u64 read_count;
	
__u64 read_bytes;
	
__u64 write_count;
	
__u64 write_bytes;
	
__u32 layout_type;
	
struct nfs4_xdr_opaque_data ld_private;
};


struct nfs42_layoutstat_args {
	
struct nfs4_sequence_args seq_args;
	
struct nfs_fh *fh;
	
struct inode *inode;
	
nfs4_stateid stateid;
	
int num_dev;
	
struct nfs42_layoutstat_devinfo *devinfo;
};


struct nfs42_layoutstat_res {
	
struct nfs4_sequence_res seq_res;
	
int num_dev;
	
int rpc_status;
};


struct nfs42_layoutstat_data {
	
struct inode *inode;
	
struct nfs42_layoutstat_args args;
	
struct nfs42_layoutstat_res res;
};


struct nfs42_clone_args {
	
struct nfs4_sequence_args	seq_args;
	
struct nfs_fh			*src_fh;
	
struct nfs_fh			*dst_fh;
	
nfs4_stateid			src_stateid;
	
nfs4_stateid			dst_stateid;
	
__u64				src_offset;
	
__u64				dst_offset;
	
__u64				count;
	
const u32			*dst_bitmask;
};


struct nfs42_clone_res {
	
struct nfs4_sequence_res	seq_res;
	
unsigned int			rpc_status;
	
struct nfs_fattr		*dst_fattr;
	
const struct nfs_server		*server;
};


struct stateowner_id {
	
__u64	create_time;
	
__u32	uniquifier;
};

/*
 * Arguments to the open call.
 */

struct nfs_openargs {
	
struct nfs4_sequence_args	seq_args;
	
const struct nfs_fh *	fh;
	
struct nfs_seqid *	seqid;
	
int			open_flags;
	
fmode_t			fmode;
	
u32			share_access;
	
u32			access;
	
__u64                   clientid;
	
struct stateowner_id	id;
	union {
		struct {
			
struct iattr *  attrs;    /* UNCHECKED, GUARDED, EXCLUSIVE4_1 */
			
nfs4_verifier   verifier; /* EXCLUSIVE */
		};
		
nfs4_stateid	delegation;		/* CLAIM_DELEGATE_CUR */
		
fmode_t		delegation_type;	/* CLAIM_PREVIOUS */
	
} u;
	
const struct qstr *	name;
	
const struct nfs_server *server;	 /* Needed for ID mapping */
	
const u32 *		bitmask;
	
const u32 *		open_bitmap;
	
enum open_claim_type4	claim;
	
enum createmode4	createmode;
	
const struct nfs4_label *label;
	
umode_t			umask;
};


struct nfs_openres {
	
struct nfs4_sequence_res	seq_res;
	
nfs4_stateid            stateid;
	
struct nfs_fh           fh;
	
struct nfs4_change_info	cinfo;
	
__u32                   rflags;
	
struct nfs_fattr *      f_attr;
	
struct nfs4_label	*f_label;
	
struct nfs_seqid *	seqid;
	
const struct nfs_server *server;
	
fmode_t			delegation_type;
	
nfs4_stateid		delegation;
	
unsigned long		pagemod_limit;
	
__u32			do_recall;
	
__u32			attrset[NFS4_BITMAP_SIZE];
	
struct nfs4_string	*owner;
	
struct nfs4_string	*group_owner;
	
__u32			access_request;
	
__u32			access_supported;
	
__u32			access_result;
};

/*
 * Arguments to the open_confirm call.
 */

struct nfs_open_confirmargs {
	
struct nfs4_sequence_args	seq_args;
	
const struct nfs_fh *	fh;
	
nfs4_stateid *		stateid;
	
struct nfs_seqid *	seqid;
};


struct nfs_open_confirmres {
	
struct nfs4_sequence_res	seq_res;
	
nfs4_stateid            stateid;
	
struct nfs_seqid *	seqid;
};

/*
 * Arguments to the close call.
 */

struct nfs_closeargs {
	
struct nfs4_sequence_args	seq_args;
	
struct nfs_fh *         fh;
	
nfs4_stateid 		stateid;
	
struct nfs_seqid *	seqid;
	
fmode_t			fmode;
	
u32			share_access;
	
const u32 *		bitmask;
	
struct nfs4_layoutreturn_args *lr_args;
};


struct nfs_closeres {
	
struct nfs4_sequence_res	seq_res;
	
nfs4_stateid            stateid;
	
struct nfs_fattr *	fattr;
	
struct nfs_seqid *	seqid;
	
const struct nfs_server *server;
	
struct nfs4_layoutreturn_res *lr_res;
	
int lr_ret;
};
/*
 *  * Arguments to the lock,lockt, and locku call.
 *   */

struct nfs_lowner {
	
__u64			clientid;
	
__u64			id;
	
dev_t			s_dev;
};


struct nfs_lock_args {
	
struct nfs4_sequence_args	seq_args;
	
struct nfs_fh *		fh;
	
struct file_lock *	fl;
	
struct nfs_seqid *	lock_seqid;
	
nfs4_stateid		lock_stateid;
	
struct nfs_seqid *	open_seqid;
	
nfs4_stateid		open_stateid;
	
struct nfs_lowner	lock_owner;
	
unsigned char		block : 1;
	
unsigned char		reclaim : 1;
	
unsigned char		new_lock : 1;
	
unsigned char		new_lock_owner : 1;
};


struct nfs_lock_res {
	
struct nfs4_sequence_res	seq_res;
	
nfs4_stateid		stateid;
	
struct nfs_seqid *	lock_seqid;
	
struct nfs_seqid *	open_seqid;
};


struct nfs_locku_args {
	
struct nfs4_sequence_args	seq_args;
	
struct nfs_fh *		fh;
	
struct file_lock *	fl;
	
struct nfs_seqid *	seqid;
	
nfs4_stateid 		stateid;
};


struct nfs_locku_res {
	
struct nfs4_sequence_res	seq_res;
	
nfs4_stateid		stateid;
	
struct nfs_seqid *	seqid;
};


struct nfs_lockt_args {
	
struct nfs4_sequence_args	seq_args;
	
struct nfs_fh *		fh;
	
struct file_lock *	fl;
	
struct nfs_lowner	lock_owner;
};


struct nfs_lockt_res {
	
struct nfs4_sequence_res	seq_res;
	
struct file_lock *	denied; /* LOCK, LOCKT failed */
};


struct nfs_release_lockowner_args {
	
struct nfs4_sequence_args	seq_args;
	
struct nfs_lowner	lock_owner;
};


struct nfs_release_lockowner_res {
	
struct nfs4_sequence_res	seq_res;
};


struct nfs4_delegreturnargs {
	
struct nfs4_sequence_args	seq_args;
	
const struct nfs_fh *fhandle;
	
const nfs4_stateid *stateid;
	
const u32 * bitmask;
	
struct nfs4_layoutreturn_args *lr_args;
};


struct nfs4_delegreturnres {
	
struct nfs4_sequence_res	seq_res;
	
struct nfs_fattr * fattr;
	
struct nfs_server *server;
	
struct nfs4_layoutreturn_res *lr_res;
	
int lr_ret;
};

/*
 * Arguments to the write call.
 */

struct nfs_write_verifier {
	
char			data[8];
};


struct nfs_writeverf {
	
struct nfs_write_verifier verifier;
	
enum nfs3_stable_how	committed;
};

/*
 * Arguments shared by the read and write call.
 */

struct nfs_pgio_args {
	
struct nfs4_sequence_args	seq_args;
	
struct nfs_fh *		fh;
	
struct nfs_open_context *context;
	
struct nfs_lock_context *lock_context;
	
nfs4_stateid		stateid;
	
__u64			offset;
	
__u32			count;
	
unsigned int		pgbase;
	
struct page **		pages;
	
const u32 *		bitmask;	/* used by write */
	
enum nfs3_stable_how	stable;		/* used by write */
};


struct nfs_pgio_res {
	
struct nfs4_sequence_res	seq_res;
	
struct nfs_fattr *	fattr;
	
__u32			count;
	
__u32			op_status;
	
int			eof;		/* used by read */
	
struct nfs_writeverf *	verf;		/* used by write */
	
const struct nfs_server *server;	/* used by write */

};

/*
 * Arguments to the commit call.
 */

struct nfs_commitargs {
	
struct nfs4_sequence_args	seq_args;
	
struct nfs_fh		*fh;
	
__u64			offset;
	
__u32			count;
	
const u32		*bitmask;
};


struct nfs_commitres {
	
struct nfs4_sequence_res	seq_res;
	
__u32			op_status;
	
struct nfs_fattr	*fattr;
	
struct nfs_writeverf	*verf;
	
const struct nfs_server *server;
};

/*
 * Common arguments to the unlink call
 */

struct nfs_removeargs {
	
struct nfs4_sequence_args	seq_args;
	
const struct nfs_fh	*fh;
	
struct qstr		name;
};


struct nfs_removeres {
	
struct nfs4_sequence_res 	seq_res;
	
struct nfs_server *server;
	
struct nfs_fattr	*dir_attr;
	
struct nfs4_change_info	cinfo;
};

/*
 * Common arguments to the rename call
 */

struct nfs_renameargs {
	
struct nfs4_sequence_args	seq_args;
	
const struct nfs_fh		*old_dir;
	
const struct nfs_fh		*new_dir;
	
const struct qstr		*old_name;
	
const struct qstr		*new_name;
};


struct nfs_renameres {
	
struct nfs4_sequence_res	seq_res;
	
struct nfs_server		*server;
	
struct nfs4_change_info		old_cinfo;
	
struct nfs_fattr		*old_fattr;
	
struct nfs4_change_info		new_cinfo;
	
struct nfs_fattr		*new_fattr;
};

/* parsed sec= options */

#define NFS_AUTH_INFO_MAX_FLAVORS 12 
/* see fs/nfs/super.c */

struct nfs_auth_info {
	
unsigned int            flavor_len;
	
rpc_authflavor_t        flavors[NFS_AUTH_INFO_MAX_FLAVORS];
};

/*
 * Argument struct for decode_entry function
 */

struct nfs_entry {
	
__u64			ino;
	
__u64			cookie,
				
prev_cookie;
	
const char *		name;
	
unsigned int		len;
	
int			eof;
	
struct nfs_fh *		fh;
	
struct nfs_fattr *	fattr;
	
struct nfs4_label  *label;
	
unsigned char		d_type;
	
struct nfs_server *	server;
};

/*
 * The following types are for NFSv2 only.
 */

struct nfs_sattrargs {
	
struct nfs_fh *		fh;
	
struct iattr *		sattr;
};


struct nfs_diropargs {
	
struct nfs_fh *		fh;
	
const char *		name;
	
unsigned int		len;
};


struct nfs_createargs {
	
struct nfs_fh *		fh;
	
const char *		name;
	
unsigned int		len;
	
struct iattr *		sattr;
};


struct nfs_setattrargs {
	
struct nfs4_sequence_args 	seq_args;
	
struct nfs_fh *                 fh;
	
nfs4_stateid                    stateid;
	
struct iattr *                  iap;
	
const struct nfs_server *	server; /* Needed for name mapping */
	
const u32 *			bitmask;
	
const struct nfs4_label		*label;
};


struct nfs_setaclargs {
	
struct nfs4_sequence_args	seq_args;
	
struct nfs_fh *			fh;
	
size_t				acl_len;
	
struct page **			acl_pages;
};


struct nfs_setaclres {
	
struct nfs4_sequence_res	seq_res;
};


struct nfs_getaclargs {
	
struct nfs4_sequence_args 	seq_args;
	
struct nfs_fh *			fh;
	
size_t				acl_len;
	
struct page **			acl_pages;
};

/* getxattr ACL interface flags */

#define NFS4_ACL_TRUNC		0x0001	
/* ACL was truncated */

struct nfs_getaclres {
	
struct nfs4_sequence_res	seq_res;
	
size_t				acl_len;
	
size_t				acl_data_offset;
	
int				acl_flags;
	
struct page *			acl_scratch;
};


struct nfs_setattrres {
	
struct nfs4_sequence_res	seq_res;
	
struct nfs_fattr *              fattr;
	
struct nfs4_label		*label;
	
const struct nfs_server *	server;
};


struct nfs_linkargs {
	
struct nfs_fh *		fromfh;
	
struct nfs_fh *		tofh;
	
const char *		toname;
	
unsigned int		tolen;
};


struct nfs_symlinkargs {
	
struct nfs_fh *		fromfh;
	
const char *		fromname;
	
unsigned int		fromlen;
	
struct page **		pages;
	
unsigned int		pathlen;
	
struct iattr *		sattr;
};


struct nfs_readdirargs {
	
struct nfs_fh *		fh;
	
__u32			cookie;
	
unsigned int		count;
	
struct page **		pages;
};


struct nfs3_getaclargs {
	
struct nfs_fh *		fh;