1#ifndef _LINUX_NFS_XDR_H
2#define _LINUX_NFS_XDR_H
3
4#include <linux/nfsacl.h>
5#include <linux/sunrpc/gss_api.h>
6
7/*
8 * To change the maximum rsize and wsize supported by the NFS client, adjust
9 * NFS_MAX_FILE_IO_SIZE.  64KB is a typical maximum, but some servers can
10 * support a megabyte or more.  The default is left at 4096 bytes, which is
11 * reasonable for NFS over UDP.
12 */
13#define NFS_MAX_FILE_IO_SIZE	(1048576U)
14#define NFS_DEF_FILE_IO_SIZE	(4096U)
15#define NFS_MIN_FILE_IO_SIZE	(1024U)
16
17struct nfs4_string {
18	unsigned int len;
19	char *data;
20};
21
22struct nfs_fsid {
23	uint64_t		major;
24	uint64_t		minor;
25};
26
27/*
28 * Helper for checking equality between 2 fsids.
29 */
30static inline int nfs_fsid_equal(const struct nfs_fsid *a, const struct nfs_fsid *b)
31{
32	return a->major == b->major && a->minor == b->minor;
33}
34
35struct nfs4_threshold {
36	__u32	bm;
37	__u32	l_type;
38	__u64	rd_sz;
39	__u64	wr_sz;
40	__u64	rd_io_sz;
41	__u64	wr_io_sz;
42};
43
44struct nfs_fattr {
45	unsigned int		valid;		/* which fields are valid */
46	umode_t			mode;
47	__u32			nlink;
48	kuid_t			uid;
49	kgid_t			gid;
50	dev_t			rdev;
51	__u64			size;
52	union {
53		struct {
54			__u32	blocksize;
55			__u32	blocks;
56		} nfs2;
57		struct {
58			__u64	used;
59		} nfs3;
60	} du;
61	struct nfs_fsid		fsid;
62	__u64			fileid;
63	__u64			mounted_on_fileid;
64	struct timespec		atime;
65	struct timespec		mtime;
66	struct timespec		ctime;
67	__u64			change_attr;	/* NFSv4 change attribute */
68	__u64			pre_change_attr;/* pre-op NFSv4 change attribute */
69	__u64			pre_size;	/* pre_op_attr.size	  */
70	struct timespec		pre_mtime;	/* pre_op_attr.mtime	  */
71	struct timespec		pre_ctime;	/* pre_op_attr.ctime	  */
72	unsigned long		time_start;
73	unsigned long		gencount;
74	struct nfs4_string	*owner_name;
75	struct nfs4_string	*group_name;
76	struct nfs4_threshold	*mdsthreshold;	/* pNFS threshold hints */
77};
78
79#define NFS_ATTR_FATTR_TYPE		(1U << 0)
80#define NFS_ATTR_FATTR_MODE		(1U << 1)
81#define NFS_ATTR_FATTR_NLINK		(1U << 2)
82#define NFS_ATTR_FATTR_OWNER		(1U << 3)
83#define NFS_ATTR_FATTR_GROUP		(1U << 4)
84#define NFS_ATTR_FATTR_RDEV		(1U << 5)
85#define NFS_ATTR_FATTR_SIZE		(1U << 6)
86#define NFS_ATTR_FATTR_PRESIZE		(1U << 7)
87#define NFS_ATTR_FATTR_BLOCKS_USED	(1U << 8)
88#define NFS_ATTR_FATTR_SPACE_USED	(1U << 9)
89#define NFS_ATTR_FATTR_FSID		(1U << 10)
90#define NFS_ATTR_FATTR_FILEID		(1U << 11)
91#define NFS_ATTR_FATTR_ATIME		(1U << 12)
92#define NFS_ATTR_FATTR_MTIME		(1U << 13)
93#define NFS_ATTR_FATTR_CTIME		(1U << 14)
94#define NFS_ATTR_FATTR_PREMTIME		(1U << 15)
95#define NFS_ATTR_FATTR_PRECTIME		(1U << 16)
96#define NFS_ATTR_FATTR_CHANGE		(1U << 17)
97#define NFS_ATTR_FATTR_PRECHANGE	(1U << 18)
98#define NFS_ATTR_FATTR_V4_LOCATIONS	(1U << 19)
99#define NFS_ATTR_FATTR_V4_REFERRAL	(1U << 20)
100#define NFS_ATTR_FATTR_MOUNTPOINT	(1U << 21)
101#define NFS_ATTR_FATTR_MOUNTED_ON_FILEID (1U << 22)
102#define NFS_ATTR_FATTR_OWNER_NAME	(1U << 23)
103#define NFS_ATTR_FATTR_GROUP_NAME	(1U << 24)
104#define NFS_ATTR_FATTR_V4_SECURITY_LABEL (1U << 25)
105
106#define NFS_ATTR_FATTR (NFS_ATTR_FATTR_TYPE \
107		| NFS_ATTR_FATTR_MODE \
108		| NFS_ATTR_FATTR_NLINK \
109		| NFS_ATTR_FATTR_OWNER \
110		| NFS_ATTR_FATTR_GROUP \
111		| NFS_ATTR_FATTR_RDEV \
112		| NFS_ATTR_FATTR_SIZE \
113		| NFS_ATTR_FATTR_FSID \
114		| NFS_ATTR_FATTR_FILEID \
115		| NFS_ATTR_FATTR_ATIME \
116		| NFS_ATTR_FATTR_MTIME \
117		| NFS_ATTR_FATTR_CTIME \
118		| NFS_ATTR_FATTR_CHANGE)
119#define NFS_ATTR_FATTR_V2 (NFS_ATTR_FATTR \
120		| NFS_ATTR_FATTR_BLOCKS_USED)
121#define NFS_ATTR_FATTR_V3 (NFS_ATTR_FATTR \
122		| NFS_ATTR_FATTR_SPACE_USED)
123#define NFS_ATTR_FATTR_V4 (NFS_ATTR_FATTR \
124		| NFS_ATTR_FATTR_SPACE_USED \
125		| NFS_ATTR_FATTR_V4_SECURITY_LABEL)
126
127/*
128 * Info on the file system
129 */
130struct nfs_fsinfo {
131	struct nfs_fattr	*fattr; /* Post-op attributes */
132	__u32			rtmax;	/* max.  read transfer size */
133	__u32			rtpref;	/* pref. read transfer size */
134	__u32			rtmult;	/* reads should be multiple of this */
135	__u32			wtmax;	/* max.  write transfer size */
136	__u32			wtpref;	/* pref. write transfer size */
137	__u32			wtmult;	/* writes should be multiple of this */
138	__u32			dtpref;	/* pref. readdir transfer size */
139	__u64			maxfilesize;
140	struct timespec		time_delta; /* server time granularity */
141	__u32			lease_time; /* in seconds */
142	__u32			layouttype; /* supported pnfs layout driver */
143	__u32			blksize; /* preferred pnfs io block size */
144};
145
146struct nfs_fsstat {
147	struct nfs_fattr	*fattr; /* Post-op attributes */
148	__u64			tbytes;	/* total size in bytes */
149	__u64			fbytes;	/* # of free bytes */
150	__u64			abytes;	/* # of bytes available to user */
151	__u64			tfiles;	/* # of files */
152	__u64			ffiles;	/* # of free files */
153	__u64			afiles;	/* # of files available to user */
154};
155
156struct nfs2_fsstat {
157	__u32			tsize;  /* Server transfer size */
158	__u32			bsize;  /* Filesystem block size */
159	__u32			blocks; /* No. of "bsize" blocks on filesystem */
160	__u32			bfree;  /* No. of free "bsize" blocks */
161	__u32			bavail; /* No. of available "bsize" blocks */
162};
163
164struct nfs_pathconf {
165	struct nfs_fattr	*fattr; /* Post-op attributes */
166	__u32			max_link; /* max # of hard links */
167	__u32			max_namelen; /* max name length */
168};
169
170struct nfs4_change_info {
171	u32			atomic;
172	u64			before;
173	u64			after;
174};
175
176struct nfs_seqid;
177
178/* nfs41 sessions channel attributes */
179struct nfs4_channel_attrs {
180	u32			max_rqst_sz;
181	u32			max_resp_sz;
182	u32			max_resp_sz_cached;
183	u32			max_ops;
184	u32			max_reqs;
185};
186
187struct nfs4_slot;
188struct nfs4_sequence_args {
189	struct nfs4_slot	*sa_slot;
190	u8			sa_cache_this : 1,
191				sa_privileged : 1;
192};
193
194struct nfs4_sequence_res {
195	struct nfs4_slot	*sr_slot;	/* slot used to send request */
196	unsigned long		sr_timestamp;
197	int			sr_status;	/* sequence operation status */
198	u32			sr_status_flags;
199	u32			sr_highest_slotid;
200	u32			sr_target_highest_slotid;
201};
202
203struct nfs4_get_lease_time_args {
204	struct nfs4_sequence_args	la_seq_args;
205};
206
207struct nfs4_get_lease_time_res {
208	struct nfs4_sequence_res	lr_seq_res;
209	struct nfs_fsinfo	       *lr_fsinfo;
210};
211
212#define PNFS_LAYOUT_MAXSIZE 4096
213
214struct nfs4_layoutdriver_data {
215	struct page **pages;
216	__u32 pglen;
217	__u32 len;
218};
219
220struct pnfs_layout_range {
221	u32 iomode;
222	u64 offset;
223	u64 length;
224};
225
226struct nfs4_layoutget_args {
227	struct nfs4_sequence_args seq_args;
228	__u32 type;
229	struct pnfs_layout_range range;
230	__u64 minlength;
231	__u32 maxcount;
232	struct inode *inode;
233	struct nfs_open_context *ctx;
234	nfs4_stateid stateid;
235	unsigned long timestamp;
236	struct nfs4_layoutdriver_data layout;
237};
238
239struct nfs4_layoutget_res {
240	struct nfs4_sequence_res seq_res;
241	__u32 return_on_close;
242	struct pnfs_layout_range range;
243	__u32 type;
244	nfs4_stateid stateid;
245	struct nfs4_layoutdriver_data *layoutp;
246};
247
248struct nfs4_layoutget {
249	struct nfs4_layoutget_args args;
250	struct nfs4_layoutget_res res;
251	struct rpc_cred *cred;
252	gfp_t gfp_flags;
253};
254
255struct nfs4_getdeviceinfo_args {
256	struct nfs4_sequence_args seq_args;
257	struct pnfs_device *pdev;
258	__u32 notify_types;
259};
260
261struct nfs4_getdeviceinfo_res {
262	struct nfs4_sequence_res seq_res;
263	struct pnfs_device *pdev;
264	__u32 notification;
265};
266
267struct nfs4_layoutcommit_args {
268	struct nfs4_sequence_args seq_args;
269	nfs4_stateid stateid;
270	__u64 lastbytewritten;
271	struct inode *inode;
272	const u32 *bitmask;
273	size_t layoutupdate_len;
274	struct page *layoutupdate_page;
275	struct page **layoutupdate_pages;
276};
277
278struct nfs4_layoutcommit_res {
279	struct nfs4_sequence_res seq_res;
280	struct nfs_fattr *fattr;
281	const struct nfs_server *server;
282	int status;
283};
284
285struct nfs4_layoutcommit_data {
286	struct rpc_task task;
287	struct nfs_fattr fattr;
288	struct list_head lseg_list;
289	struct rpc_cred *cred;
290	struct inode *inode;
291	struct nfs4_layoutcommit_args args;
292	struct nfs4_layoutcommit_res res;
293};
294
295struct nfs4_layoutreturn_args {
296	struct nfs4_sequence_args seq_args;
297	struct pnfs_layout_hdr *layout;
298	struct inode *inode;
299	struct pnfs_layout_range range;
300	nfs4_stateid stateid;
301	__u32   layout_type;
302};
303
304struct nfs4_layoutreturn_res {
305	struct nfs4_sequence_res seq_res;
306	u32 lrs_present;
307	nfs4_stateid stateid;
308};
309
310struct nfs4_layoutreturn {
311	struct nfs4_layoutreturn_args args;
312	struct nfs4_layoutreturn_res res;
313	struct rpc_cred *cred;
314	struct nfs_client *clp;
315	struct inode *inode;
316	int rpc_status;
317};
318
319struct stateowner_id {
320	__u64	create_time;
321	__u32	uniquifier;
322};
323
324/*
325 * Arguments to the open call.
326 */
327struct nfs_openargs {
328	struct nfs4_sequence_args	seq_args;
329	const struct nfs_fh *	fh;
330	struct nfs_seqid *	seqid;
331	int			open_flags;
332	fmode_t			fmode;
333	u32			share_access;
334	u32			access;
335	__u64                   clientid;
336	struct stateowner_id	id;
337	union {
338		struct {
339			struct iattr *  attrs;    /* UNCHECKED, GUARDED */
340			nfs4_verifier   verifier; /* EXCLUSIVE */
341		};
342		nfs4_stateid	delegation;		/* CLAIM_DELEGATE_CUR */
343		fmode_t		delegation_type;	/* CLAIM_PREVIOUS */
344	} u;
345	const struct qstr *	name;
346	const struct nfs_server *server;	 /* Needed for ID mapping */
347	const u32 *		bitmask;
348	const u32 *		open_bitmap;
349	__u32			claim;
350	enum createmode4	createmode;
351	const struct nfs4_label *label;
352};
353
354struct nfs_openres {
355	struct nfs4_sequence_res	seq_res;
356	nfs4_stateid            stateid;
357	struct nfs_fh           fh;
358	struct nfs4_change_info	cinfo;
359	__u32                   rflags;
360	struct nfs_fattr *      f_attr;
361	struct nfs4_label	*f_label;
362	struct nfs_seqid *	seqid;
363	const struct nfs_server *server;
364	fmode_t			delegation_type;
365	nfs4_stateid		delegation;
366	__u32			do_recall;
367	__u64			maxsize;
368	__u32			attrset[NFS4_BITMAP_SIZE];
369	struct nfs4_string	*owner;
370	struct nfs4_string	*group_owner;
371	__u32			access_request;
372	__u32			access_supported;
373	__u32			access_result;
374};
375
376/*
377 * Arguments to the open_confirm call.
378 */
379struct nfs_open_confirmargs {
380	struct nfs4_sequence_args	seq_args;
381	const struct nfs_fh *	fh;
382	nfs4_stateid *		stateid;
383	struct nfs_seqid *	seqid;
384};
385
386struct nfs_open_confirmres {
387	struct nfs4_sequence_res	seq_res;
388	nfs4_stateid            stateid;
389	struct nfs_seqid *	seqid;
390};
391
392/*
393 * Arguments to the close call.
394 */
395struct nfs_closeargs {
396	struct nfs4_sequence_args	seq_args;
397	struct nfs_fh *         fh;
398	nfs4_stateid 		stateid;
399	struct nfs_seqid *	seqid;
400	fmode_t			fmode;
401	u32			share_access;
402	const u32 *		bitmask;
403};
404
405struct nfs_closeres {
406	struct nfs4_sequence_res	seq_res;
407	nfs4_stateid            stateid;
408	struct nfs_fattr *	fattr;
409	struct nfs_seqid *	seqid;
410	const struct nfs_server *server;
411};
412/*
413 *  * Arguments to the lock,lockt, and locku call.
414 *   */
415struct nfs_lowner {
416	__u64			clientid;
417	__u64			id;
418	dev_t			s_dev;
419};
420
421struct nfs_lock_args {
422	struct nfs4_sequence_args	seq_args;
423	struct nfs_fh *		fh;
424	struct file_lock *	fl;
425	struct nfs_seqid *	lock_seqid;
426	nfs4_stateid		lock_stateid;
427	struct nfs_seqid *	open_seqid;
428	nfs4_stateid		open_stateid;
429	struct nfs_lowner	lock_owner;
430	unsigned char		block : 1;
431	unsigned char		reclaim : 1;
432	unsigned char		new_lock : 1;
433	unsigned char		new_lock_owner : 1;
434};
435
436struct nfs_lock_res {
437	struct nfs4_sequence_res	seq_res;
438	nfs4_stateid		stateid;
439	struct nfs_seqid *	lock_seqid;
440	struct nfs_seqid *	open_seqid;
441};
442
443struct nfs_locku_args {
444	struct nfs4_sequence_args	seq_args;
445	struct nfs_fh *		fh;
446	struct file_lock *	fl;
447	struct nfs_seqid *	seqid;
448	nfs4_stateid 		stateid;
449};
450
451struct nfs_locku_res {
452	struct nfs4_sequence_res	seq_res;
453	nfs4_stateid		stateid;
454	struct nfs_seqid *	seqid;
455};
456
457struct nfs_lockt_args {
458	struct nfs4_sequence_args	seq_args;
459	struct nfs_fh *		fh;
460	struct file_lock *	fl;
461	struct nfs_lowner	lock_owner;
462};
463
464struct nfs_lockt_res {
465	struct nfs4_sequence_res	seq_res;
466	struct file_lock *	denied; /* LOCK, LOCKT failed */
467};
468
469struct nfs_release_lockowner_args {
470	struct nfs4_sequence_args	seq_args;
471	struct nfs_lowner	lock_owner;
472};
473
474struct nfs_release_lockowner_res {
475	struct nfs4_sequence_res	seq_res;
476};
477
478struct nfs4_delegreturnargs {
479	struct nfs4_sequence_args	seq_args;
480	const struct nfs_fh *fhandle;
481	const nfs4_stateid *stateid;
482	const u32 * bitmask;
483};
484
485struct nfs4_delegreturnres {
486	struct nfs4_sequence_res	seq_res;
487	struct nfs_fattr * fattr;
488	const struct nfs_server *server;
489};
490
491/*
492 * Arguments to the write call.
493 */
494struct nfs_write_verifier {
495	char			data[8];
496};
497
498struct nfs_writeverf {
499	struct nfs_write_verifier verifier;
500	enum nfs3_stable_how	committed;
501};
502
503/*
504 * Arguments shared by the read and write call.
505 */
506struct nfs_pgio_args {
507	struct nfs4_sequence_args	seq_args;
508	struct nfs_fh *		fh;
509	struct nfs_open_context *context;
510	struct nfs_lock_context *lock_context;
511	nfs4_stateid		stateid;
512	__u64			offset;
513	__u32			count;
514	unsigned int		pgbase;
515	struct page **		pages;
516	const u32 *		bitmask;	/* used by write */
517	enum nfs3_stable_how	stable;		/* used by write */
518};
519
520struct nfs_pgio_res {
521	struct nfs4_sequence_res	seq_res;
522	struct nfs_fattr *	fattr;
523	__u32			count;
524	__u32			op_status;
525	int			eof;		/* used by read */
526	struct nfs_writeverf *	verf;		/* used by write */
527	const struct nfs_server *server;	/* used by write */
528
529};
530
531/*
532 * Arguments to the commit call.
533 */
534struct nfs_commitargs {
535	struct nfs4_sequence_args	seq_args;
536	struct nfs_fh		*fh;
537	__u64			offset;
538	__u32			count;
539	const u32		*bitmask;
540};
541
542struct nfs_commitres {
543	struct nfs4_sequence_res	seq_res;
544	__u32			op_status;
545	struct nfs_fattr	*fattr;
546	struct nfs_writeverf	*verf;
547	const struct nfs_server *server;
548};
549
550/*
551 * Common arguments to the unlink call
552 */
553struct nfs_removeargs {
554	struct nfs4_sequence_args	seq_args;
555	const struct nfs_fh	*fh;
556	struct qstr		name;
557};
558
559struct nfs_removeres {
560	struct nfs4_sequence_res 	seq_res;
561	const struct nfs_server *server;
562	struct nfs_fattr	*dir_attr;
563	struct nfs4_change_info	cinfo;
564};
565
566/*
567 * Common arguments to the rename call
568 */
569struct nfs_renameargs {
570	struct nfs4_sequence_args	seq_args;
571	const struct nfs_fh		*old_dir;
572	const struct nfs_fh		*new_dir;
573	const struct qstr		*old_name;
574	const struct qstr		*new_name;
575};
576
577struct nfs_renameres {
578	struct nfs4_sequence_res	seq_res;
579	const struct nfs_server		*server;
580	struct nfs4_change_info		old_cinfo;
581	struct nfs_fattr		*old_fattr;
582	struct nfs4_change_info		new_cinfo;
583	struct nfs_fattr		*new_fattr;
584};
585
586/* parsed sec= options */
587#define NFS_AUTH_INFO_MAX_FLAVORS 12 /* see fs/nfs/super.c */
588struct nfs_auth_info {
589	unsigned int            flavor_len;
590	rpc_authflavor_t        flavors[NFS_AUTH_INFO_MAX_FLAVORS];
591};
592
593/*
594 * Argument struct for decode_entry function
595 */
596struct nfs_entry {
597	__u64			ino;
598	__u64			cookie,
599				prev_cookie;
600	const char *		name;
601	unsigned int		len;
602	int			eof;
603	struct nfs_fh *		fh;
604	struct nfs_fattr *	fattr;
605	struct nfs4_label  *label;
606	unsigned char		d_type;
607	struct nfs_server *	server;
608};
609
610/*
611 * The following types are for NFSv2 only.
612 */
613struct nfs_sattrargs {
614	struct nfs_fh *		fh;
615	struct iattr *		sattr;
616};
617
618struct nfs_diropargs {
619	struct nfs_fh *		fh;
620	const char *		name;
621	unsigned int		len;
622};
623
624struct nfs_createargs {
625	struct nfs_fh *		fh;
626	const char *		name;
627	unsigned int		len;
628	struct iattr *		sattr;
629};
630
631struct nfs_setattrargs {
632	struct nfs4_sequence_args 	seq_args;
633	struct nfs_fh *                 fh;
634	nfs4_stateid                    stateid;
635	struct iattr *                  iap;
636	const struct nfs_server *	server; /* Needed for name mapping */
637	const u32 *			bitmask;
638	const struct nfs4_label		*label;
639};
640
641struct nfs_setaclargs {
642	struct nfs4_sequence_args	seq_args;
643	struct nfs_fh *			fh;
644	size_t				acl_len;
645	unsigned int			acl_pgbase;
646	struct page **			acl_pages;
647};
648
649struct nfs_setaclres {
650	struct nfs4_sequence_res	seq_res;
651};
652
653struct nfs_getaclargs {
654	struct nfs4_sequence_args 	seq_args;
655	struct nfs_fh *			fh;
656	size_t				acl_len;
657	unsigned int			acl_pgbase;
658	struct page **			acl_pages;
659};
660
661/* getxattr ACL interface flags */
662#define NFS4_ACL_TRUNC		0x0001	/* ACL was truncated */
663struct nfs_getaclres {
664	struct nfs4_sequence_res	seq_res;
665	size_t				acl_len;
666	size_t				acl_data_offset;
667	int				acl_flags;
668	struct page *			acl_scratch;
669};
670
671struct nfs_setattrres {
672	struct nfs4_sequence_res	seq_res;
673	struct nfs_fattr *              fattr;
674	struct nfs4_label		*label;
675	const struct nfs_server *	server;
676};
677
678struct nfs_linkargs {
679	struct nfs_fh *		fromfh;
680	struct nfs_fh *		tofh;
681	const char *		toname;
682	unsigned int		tolen;
683};
684
685struct nfs_symlinkargs {
686	struct nfs_fh *		fromfh;
687	const char *		fromname;
688	unsigned int		fromlen;
689	struct page **		pages;
690	unsigned int		pathlen;
691	struct iattr *		sattr;
692};
693
694struct nfs_readdirargs {
695	struct nfs_fh *		fh;
696	__u32			cookie;
697	unsigned int		count;
698	struct page **		pages;
699};
700
701struct nfs3_getaclargs {
702	struct nfs_fh *		fh;
703	int			mask;
704	struct page **		pages;
705};
706
707struct nfs3_setaclargs {
708	struct inode *		inode;
709	int			mask;
710	struct posix_acl *	acl_access;
711	struct posix_acl *	acl_default;
712	size_t			len;
713	unsigned int		npages;
714	struct page **		pages;
715};
716
717struct nfs_diropok {
718	struct nfs_fh *		fh;
719	struct nfs_fattr *	fattr;
720};
721
722struct nfs_readlinkargs {
723	struct nfs_fh *		fh;
724	unsigned int		pgbase;
725	unsigned int		pglen;
726	struct page **		pages;
727};
728
729struct nfs3_sattrargs {
730	struct nfs_fh *		fh;
731	struct iattr *		sattr;
732	unsigned int		guard;
733	struct timespec		guardtime;
734};
735
736struct nfs3_diropargs {
737	struct nfs_fh *		fh;
738	const char *		name;
739	unsigned int		len;
740};
741
742struct nfs3_accessargs {
743	struct nfs_fh *		fh;
744	__u32			access;
745};
746
747struct nfs3_createargs {
748	struct nfs_fh *		fh;
749	const char *		name;
750	unsigned int		len;
751	struct iattr *		sattr;
752	enum nfs3_createmode	createmode;
753	__be32			verifier[2];
754};
755
756struct nfs3_mkdirargs {
757	struct nfs_fh *		fh;
758	const char *		name;
759	unsigned int		len;
760	struct iattr *		sattr;
761};
762
763struct nfs3_symlinkargs {
764	struct nfs_fh *		fromfh;
765	const char *		fromname;
766	unsigned int		fromlen;
767	struct page **		pages;
768	unsigned int		pathlen;
769	struct iattr *		sattr;
770};
771
772struct nfs3_mknodargs {
773	struct nfs_fh *		fh;
774	const char *		name;
775	unsigned int		len;
776	enum nfs3_ftype		type;
777	struct iattr *		sattr;
778	dev_t			rdev;
779};
780
781struct nfs3_linkargs {
782	struct nfs_fh *		fromfh;
783	struct nfs_fh *		tofh;
784	const char *		toname;
785	unsigned int		tolen;
786};
787
788struct nfs3_readdirargs {
789	struct nfs_fh *		fh;
790	__u64			cookie;
791	__be32			verf[2];
792	int			plus;
793	unsigned int            count;
794	struct page **		pages;
795};
796
797struct nfs3_diropres {
798	struct nfs_fattr *	dir_attr;
799	struct nfs_fh *		fh;
800	struct nfs_fattr *	fattr;
801};
802
803struct nfs3_accessres {
804	struct nfs_fattr *	fattr;
805	__u32			access;
806};
807
808struct nfs3_readlinkargs {
809	struct nfs_fh *		fh;
810	unsigned int		pgbase;
811	unsigned int		pglen;
812	struct page **		pages;
813};
814
815struct nfs3_linkres {
816	struct nfs_fattr *	dir_attr;
817	struct nfs_fattr *	fattr;
818};
819
820struct nfs3_readdirres {
821	struct nfs_fattr *	dir_attr;
822	__be32 *		verf;
823	int			plus;
824};
825
826struct nfs3_getaclres {
827	struct nfs_fattr *	fattr;
828	int			mask;
829	unsigned int		acl_access_count;
830	unsigned int		acl_default_count;
831	struct posix_acl *	acl_access;
832	struct posix_acl *	acl_default;
833};
834
835#if IS_ENABLED(CONFIG_NFS_V4)
836
837typedef u64 clientid4;
838
839struct nfs4_accessargs {
840	struct nfs4_sequence_args	seq_args;
841	const struct nfs_fh *		fh;
842	const u32 *			bitmask;
843	u32				access;
844};
845
846struct nfs4_accessres {
847	struct nfs4_sequence_res	seq_res;
848	const struct nfs_server *	server;
849	struct nfs_fattr *		fattr;
850	u32				supported;
851	u32				access;
852};
853
854struct nfs4_create_arg {
855	struct nfs4_sequence_args 	seq_args;
856	u32				ftype;
857	union {
858		struct {
859			struct page **	pages;
860			unsigned int	len;
861		} symlink;   /* NF4LNK */
862		struct {
863			u32		specdata1;
864			u32		specdata2;
865		} device;    /* NF4BLK, NF4CHR */
866	} u;
867	const struct qstr *		name;
868	const struct nfs_server *	server;
869	const struct iattr *		attrs;
870	const struct nfs_fh *		dir_fh;
871	const u32 *			bitmask;
872	const struct nfs4_label		*label;
873};
874
875struct nfs4_create_res {
876	struct nfs4_sequence_res	seq_res;
877	const struct nfs_server *	server;
878	struct nfs_fh *			fh;
879	struct nfs_fattr *		fattr;
880	struct nfs4_label		*label;
881	struct nfs4_change_info		dir_cinfo;
882};
883
884struct nfs4_fsinfo_arg {
885	struct nfs4_sequence_args	seq_args;
886	const struct nfs_fh *		fh;
887	const u32 *			bitmask;
888};
889
890struct nfs4_fsinfo_res {
891	struct nfs4_sequence_res	seq_res;
892	struct nfs_fsinfo	       *fsinfo;
893};
894
895struct nfs4_getattr_arg {
896	struct nfs4_sequence_args	seq_args;
897	const struct nfs_fh *		fh;
898	const u32 *			bitmask;
899};
900
901struct nfs4_getattr_res {
902	struct nfs4_sequence_res	seq_res;
903	const struct nfs_server *	server;
904	struct nfs_fattr *		fattr;
905	struct nfs4_label		*label;
906};
907
908struct nfs4_link_arg {
909	struct nfs4_sequence_args 	seq_args;
910	const struct nfs_fh *		fh;
911	const struct nfs_fh *		dir_fh;
912	const struct qstr *		name;
913	const u32 *			bitmask;
914};
915
916struct nfs4_link_res {
917	struct nfs4_sequence_res	seq_res;
918	const struct nfs_server *	server;
919	struct nfs_fattr *		fattr;
920	struct nfs4_label		*label;
921	struct nfs4_change_info		cinfo;
922	struct nfs_fattr *		dir_attr;
923};
924
925
926struct nfs4_lookup_arg {
927	struct nfs4_sequence_args	seq_args;
928	const struct nfs_fh *		dir_fh;
929	const struct qstr *		name;
930	const u32 *			bitmask;
931};
932
933struct nfs4_lookup_res {
934	struct nfs4_sequence_res	seq_res;
935	const struct nfs_server *	server;
936	struct nfs_fattr *		fattr;
937	struct nfs_fh *			fh;
938	struct nfs4_label		*label;
939};
940
941struct nfs4_lookup_root_arg {
942	struct nfs4_sequence_args	seq_args;
943	const u32 *			bitmask;
944};
945
946struct nfs4_pathconf_arg {
947	struct nfs4_sequence_args	seq_args;
948	const struct nfs_fh *		fh;
949	const u32 *			bitmask;
950};
951
952struct nfs4_pathconf_res {
953	struct nfs4_sequence_res	seq_res;
954	struct nfs_pathconf	       *pathconf;
955};
956
957struct nfs4_readdir_arg {
958	struct nfs4_sequence_args	seq_args;
959	const struct nfs_fh *		fh;
960	u64				cookie;
961	nfs4_verifier			verifier;
962	u32				count;
963	struct page **			pages;	/* zero-copy data */
964	unsigned int			pgbase;	/* zero-copy data */
965	const u32 *			bitmask;
966	int				plus;
967};
968
969struct nfs4_readdir_res {
970	struct nfs4_sequence_res	seq_res;
971	nfs4_verifier			verifier;
972	unsigned int			pgbase;
973};
974
975struct nfs4_readlink {
976	struct nfs4_sequence_args	seq_args;
977	const struct nfs_fh *		fh;
978	unsigned int			pgbase;
979	unsigned int			pglen;   /* zero-copy data */
980	struct page **			pages;   /* zero-copy data */
981};
982
983struct nfs4_readlink_res {
984	struct nfs4_sequence_res	seq_res;
985};
986
987#define NFS4_SETCLIENTID_NAMELEN	(127)
988struct nfs4_setclientid {
989	const nfs4_verifier *		sc_verifier;
990	unsigned int			sc_name_len;
991	char				sc_name[NFS4_SETCLIENTID_NAMELEN + 1];
992	u32				sc_prog;
993	unsigned int			sc_netid_len;
994	char				sc_netid[RPCBIND_MAXNETIDLEN + 1];
995	unsigned int			sc_uaddr_len;
996	char				sc_uaddr[RPCBIND_MAXUADDRLEN + 1];
997	u32				sc_cb_ident;
998	struct rpc_cred			*sc_cred;
999};
1000
1001struct nfs4_setclientid_res {
1002	u64				clientid;
1003	nfs4_verifier			confirm;
1004};
1005
1006struct nfs4_statfs_arg {
1007	struct nfs4_sequence_args	seq_args;
1008	const struct nfs_fh *		fh;
1009	const u32 *			bitmask;
1010};
1011
1012struct nfs4_statfs_res {
1013	struct nfs4_sequence_res	seq_res;
1014	struct nfs_fsstat	       *fsstat;
1015};
1016
1017struct nfs4_server_caps_arg {
1018	struct nfs4_sequence_args	seq_args;
1019	struct nfs_fh		       *fhandle;
1020};
1021
1022struct nfs4_server_caps_res {
1023	struct nfs4_sequence_res	seq_res;
1024	u32				attr_bitmask[3];
1025	u32				acl_bitmask;
1026	u32				has_links;
1027	u32				has_symlinks;
1028	u32				fh_expire_type;
1029};
1030
1031#define NFS4_PATHNAME_MAXCOMPONENTS 512
1032struct nfs4_pathname {
1033	unsigned int ncomponents;
1034	struct nfs4_string components[NFS4_PATHNAME_MAXCOMPONENTS];
1035};
1036
1037#define NFS4_FS_LOCATION_MAXSERVERS 10
1038struct nfs4_fs_location {
1039	unsigned int nservers;
1040	struct nfs4_string servers[NFS4_FS_LOCATION_MAXSERVERS];
1041	struct nfs4_pathname rootpath;
1042};
1043
1044#define NFS4_FS_LOCATIONS_MAXENTRIES 10
1045struct nfs4_fs_locations {
1046	struct nfs_fattr fattr;
1047	const struct nfs_server *server;
1048	struct nfs4_pathname fs_path;
1049	int nlocations;
1050	struct nfs4_fs_location locations[NFS4_FS_LOCATIONS_MAXENTRIES];
1051};
1052
1053struct nfs4_fs_locations_arg {
1054	struct nfs4_sequence_args	seq_args;
1055	const struct nfs_fh *dir_fh;
1056	const struct nfs_fh *fh;
1057	const struct qstr *name;
1058	struct page *page;
1059	const u32 *bitmask;
1060	clientid4 clientid;
1061	unsigned char migration:1, renew:1;
1062};
1063
1064struct nfs4_fs_locations_res {
1065	struct nfs4_sequence_res	seq_res;
1066	struct nfs4_fs_locations       *fs_locations;
1067	unsigned char			migration:1, renew:1;
1068};
1069
1070struct nfs4_secinfo4 {
1071	u32			flavor;
1072	struct rpcsec_gss_info	flavor_info;
1073};
1074
1075struct nfs4_secinfo_flavors {
1076	unsigned int		num_flavors;
1077	struct nfs4_secinfo4	flavors[0];
1078};
1079
1080struct nfs4_secinfo_arg {
1081	struct nfs4_sequence_args	seq_args;
1082	const struct nfs_fh		*dir_fh;
1083	const struct qstr		*name;
1084};
1085
1086struct nfs4_secinfo_res {
1087	struct nfs4_sequence_res	seq_res;
1088	struct nfs4_secinfo_flavors	*flavors;
1089};
1090
1091struct nfs4_fsid_present_arg {
1092	struct nfs4_sequence_args	seq_args;
1093	const struct nfs_fh		*fh;
1094	clientid4			clientid;
1095	unsigned char			renew:1;
1096};
1097
1098struct nfs4_fsid_present_res {
1099	struct nfs4_sequence_res	seq_res;
1100	struct nfs_fh			*fh;
1101	unsigned char			renew:1;
1102};
1103
1104#endif /* CONFIG_NFS_V4 */
1105
1106struct nfstime4 {
1107	u64	seconds;
1108	u32	nseconds;
1109};
1110
1111#ifdef CONFIG_NFS_V4_1
1112
1113struct pnfs_commit_bucket {
1114	struct list_head written;
1115	struct list_head committing;
1116	struct pnfs_layout_segment *wlseg;
1117	struct pnfs_layout_segment *clseg;
1118	struct nfs_writeverf direct_verf;
1119};
1120
1121struct pnfs_ds_commit_info {
1122	int nwritten;
1123	int ncommitting;
1124	int nbuckets;
1125	struct pnfs_commit_bucket *buckets;
1126};
1127
1128#define NFS4_OP_MAP_NUM_LONGS \
1129	DIV_ROUND_UP(LAST_NFS4_OP, 8 * sizeof(unsigned long))
1130#define NFS4_OP_MAP_NUM_WORDS \
1131	(NFS4_OP_MAP_NUM_LONGS * sizeof(unsigned long) / sizeof(u32))
1132struct nfs4_op_map {
1133	union {
1134		unsigned long longs[NFS4_OP_MAP_NUM_LONGS];
1135		u32 words[NFS4_OP_MAP_NUM_WORDS];
1136	} u;
1137};
1138
1139struct nfs41_state_protection {
1140	u32 how;
1141	struct nfs4_op_map enforce;
1142	struct nfs4_op_map allow;
1143};
1144
1145#define NFS4_EXCHANGE_ID_LEN	(127)
1146struct nfs41_exchange_id_args {
1147	struct nfs_client		*client;
1148	nfs4_verifier			*verifier;
1149	unsigned int 			id_len;
1150	char 				id[NFS4_EXCHANGE_ID_LEN];
1151	u32				flags;
1152	struct nfs41_state_protection	state_protect;
1153};
1154
1155struct nfs41_server_owner {
1156	uint64_t			minor_id;
1157	uint32_t			major_id_sz;
1158	char				major_id[NFS4_OPAQUE_LIMIT];
1159};
1160
1161struct nfs41_server_scope {
1162	uint32_t			server_scope_sz;
1163	char 				server_scope[NFS4_OPAQUE_LIMIT];
1164};
1165
1166struct nfs41_impl_id {
1167	char				domain[NFS4_OPAQUE_LIMIT + 1];
1168	char				name[NFS4_OPAQUE_LIMIT + 1];
1169	struct nfstime4			date;
1170};
1171
1172struct nfs41_bind_conn_to_session_args {
1173	struct nfs_client		*client;
1174	struct nfs4_sessionid		sessionid;
1175	u32				dir;
1176	bool				use_conn_in_rdma_mode;
1177};
1178
1179struct nfs41_bind_conn_to_session_res {
1180	struct nfs4_sessionid		sessionid;
1181	u32				dir;
1182	bool				use_conn_in_rdma_mode;
1183};
1184
1185struct nfs41_exchange_id_res {
1186	u64				clientid;
1187	u32				seqid;
1188	u32				flags;
1189	struct nfs41_server_owner	*server_owner;
1190	struct nfs41_server_scope	*server_scope;
1191	struct nfs41_impl_id		*impl_id;
1192	struct nfs41_state_protection	state_protect;
1193};
1194
1195struct nfs41_create_session_args {
1196	struct nfs_client	       *client;
1197	u64				clientid;
1198	uint32_t			seqid;
1199	uint32_t			flags;
1200	uint32_t			cb_program;
1201	struct nfs4_channel_attrs	fc_attrs;	/* Fore Channel */
1202	struct nfs4_channel_attrs	bc_attrs;	/* Back Channel */
1203};
1204
1205struct nfs41_create_session_res {
1206	struct nfs4_sessionid		sessionid;
1207	uint32_t			seqid;
1208	uint32_t			flags;
1209	struct nfs4_channel_attrs	fc_attrs;	/* Fore Channel */
1210	struct nfs4_channel_attrs	bc_attrs;	/* Back Channel */
1211};
1212
1213struct nfs41_reclaim_complete_args {
1214	struct nfs4_sequence_args	seq_args;
1215	/* In the future extend to include curr_fh for use with migration */
1216	unsigned char			one_fs:1;
1217};
1218
1219struct nfs41_reclaim_complete_res {
1220	struct nfs4_sequence_res	seq_res;
1221};
1222
1223#define SECINFO_STYLE_CURRENT_FH 0
1224#define SECINFO_STYLE_PARENT 1
1225struct nfs41_secinfo_no_name_args {
1226	struct nfs4_sequence_args	seq_args;
1227	int				style;
1228};
1229
1230struct nfs41_test_stateid_args {
1231	struct nfs4_sequence_args	seq_args;
1232	nfs4_stateid			*stateid;
1233};
1234
1235struct nfs41_test_stateid_res {
1236	struct nfs4_sequence_res	seq_res;
1237	unsigned int			status;
1238};
1239
1240struct nfs41_free_stateid_args {
1241	struct nfs4_sequence_args	seq_args;
1242	nfs4_stateid			stateid;
1243};
1244
1245struct nfs41_free_stateid_res {
1246	struct nfs4_sequence_res	seq_res;
1247	unsigned int			status;
1248};
1249
1250static inline void
1251nfs_free_pnfs_ds_cinfo(struct pnfs_ds_commit_info *cinfo)
1252{
1253	kfree(cinfo->buckets);
1254}
1255
1256#else
1257
1258struct pnfs_ds_commit_info {
1259};
1260
1261static inline void
1262nfs_free_pnfs_ds_cinfo(struct pnfs_ds_commit_info *cinfo)
1263{
1264}
1265
1266#endif /* CONFIG_NFS_V4_1 */
1267
1268#ifdef CONFIG_NFS_V4_2
1269struct nfs42_falloc_args {
1270	struct nfs4_sequence_args	seq_args;
1271
1272	struct nfs_fh			*falloc_fh;
1273	nfs4_stateid			 falloc_stateid;
1274	u64				 falloc_offset;
1275	u64				 falloc_length;
1276	const u32			*falloc_bitmask;
1277};
1278
1279struct nfs42_falloc_res {
1280	struct nfs4_sequence_res	seq_res;
1281	unsigned int			status;
1282
1283	struct nfs_fattr		*falloc_fattr;
1284	const struct nfs_server		*falloc_server;
1285};
1286
1287struct nfs42_seek_args {
1288	struct nfs4_sequence_args	seq_args;
1289
1290	struct nfs_fh			*sa_fh;
1291	nfs4_stateid			sa_stateid;
1292	u64				sa_offset;
1293	u32				sa_what;
1294};
1295
1296struct nfs42_seek_res {
1297	struct nfs4_sequence_res	seq_res;
1298	unsigned int			status;
1299
1300	u32	sr_eof;
1301	u64	sr_offset;
1302};
1303#endif
1304
1305struct nfs_page;
1306
1307#define NFS_PAGEVEC_SIZE	(8U)
1308
1309struct nfs_page_array {
1310	struct page		**pagevec;
1311	unsigned int		npages;		/* Max length of pagevec */
1312	struct page		*page_array[NFS_PAGEVEC_SIZE];
1313};
1314
1315/* used as flag bits in nfs_pgio_header */
1316enum {
1317	NFS_IOHDR_ERROR = 0,
1318	NFS_IOHDR_EOF,
1319	NFS_IOHDR_REDO,
1320};
1321
1322struct nfs_pgio_header {
1323	struct inode		*inode;
1324	struct rpc_cred		*cred;
1325	struct list_head	pages;
1326	struct nfs_page		*req;
1327	struct nfs_writeverf	verf;		/* Used for writes */
1328	struct pnfs_layout_segment *lseg;
1329	loff_t			io_start;
1330	const struct rpc_call_ops *mds_ops;
1331	void (*release) (struct nfs_pgio_header *hdr);
1332	const struct nfs_pgio_completion_ops *completion_ops;
1333	const struct nfs_rw_ops	*rw_ops;
1334	struct nfs_direct_req	*dreq;
1335	void			*layout_private;
1336	spinlock_t		lock;
1337	/* fields protected by lock */
1338	int			pnfs_error;
1339	int			error;		/* merge with pnfs_error */
1340	unsigned long		good_bytes;	/* boundary of good data */
1341	unsigned long		flags;
1342
1343	/*
1344	 * rpc data
1345	 */
1346	struct rpc_task		task;
1347	struct nfs_fattr	fattr;
1348	struct nfs_pgio_args	args;		/* argument struct */
1349	struct nfs_pgio_res	res;		/* result struct */
1350	unsigned long		timestamp;	/* For lease renewal */
1351	int (*pgio_done_cb)(struct rpc_task *, struct nfs_pgio_header *);
1352	__u64			mds_offset;	/* Filelayout dense stripe */
1353	struct nfs_page_array	page_array;
1354	struct nfs_client	*ds_clp;	/* pNFS data server */
1355	int			ds_commit_idx;	/* ds index if ds_clp is set */
1356	int			pgio_mirror_idx;/* mirror index in pgio layer */
1357};
1358
1359struct nfs_mds_commit_info {
1360	atomic_t rpcs_out;
1361	unsigned long		ncommit;
1362	struct list_head	list;
1363};
1364
1365struct nfs_commit_data;
1366struct nfs_inode;
1367struct nfs_commit_completion_ops {
1368	void (*error_cleanup) (struct nfs_inode *nfsi);
1369	void (*completion) (struct nfs_commit_data *data);
1370};
1371
1372struct nfs_commit_info {
1373	spinlock_t			*lock;	/* inode->i_lock */
1374	struct nfs_mds_commit_info	*mds;
1375	struct pnfs_ds_commit_info	*ds;
1376	struct nfs_direct_req		*dreq;	/* O_DIRECT request */
1377	const struct nfs_commit_completion_ops *completion_ops;
1378};
1379
1380struct nfs_commit_data {
1381	struct rpc_task		task;
1382	struct inode		*inode;
1383	struct rpc_cred		*cred;
1384	struct nfs_fattr	fattr;
1385	struct nfs_writeverf	verf;
1386	struct list_head	pages;		/* Coalesced requests we wish to flush */
1387	struct list_head	list;		/* lists of struct nfs_write_data */
1388	struct nfs_direct_req	*dreq;		/* O_DIRECT request */
1389	struct nfs_commitargs	args;		/* argument struct */
1390	struct nfs_commitres	res;		/* result struct */
1391	struct nfs_open_context *context;
1392	struct pnfs_layout_segment *lseg;
1393	struct nfs_client	*ds_clp;	/* pNFS data server */
1394	int			ds_commit_index;
1395	loff_t			lwb;
1396	const struct rpc_call_ops *mds_ops;
1397	const struct nfs_commit_completion_ops *completion_ops;
1398	int (*commit_done_cb) (struct rpc_task *task, struct nfs_commit_data *data);
1399};
1400
1401struct nfs_pgio_completion_ops {
1402	void	(*error_cleanup)(struct list_head *head);
1403	void	(*init_hdr)(struct nfs_pgio_header *hdr);
1404	void	(*completion)(struct nfs_pgio_header *hdr);
1405};
1406
1407struct nfs_unlinkdata {
1408	struct hlist_node list;
1409	struct nfs_removeargs args;
1410	struct nfs_removeres res;
1411	struct inode *dir;
1412	struct rpc_cred	*cred;
1413	struct nfs_fattr dir_attr;
1414	long timeout;
1415};
1416
1417struct nfs_renamedata {
1418	struct nfs_renameargs	args;
1419	struct nfs_renameres	res;
1420	struct rpc_cred		*cred;
1421	struct inode		*old_dir;
1422	struct dentry		*old_dentry;
1423	struct nfs_fattr	old_fattr;
1424	struct inode		*new_dir;
1425	struct dentry		*new_dentry;
1426	struct nfs_fattr	new_fattr;
1427	void (*complete)(struct rpc_task *, struct nfs_renamedata *);
1428	long timeout;
1429};
1430
1431struct nfs_access_entry;
1432struct nfs_client;
1433struct rpc_timeout;
1434struct nfs_subversion;
1435struct nfs_mount_info;
1436struct nfs_client_initdata;
1437struct nfs_pageio_descriptor;
1438
1439/*
1440 * RPC procedure vector for NFSv2/NFSv3 demuxing
1441 */
1442struct nfs_rpc_ops {
1443	u32	version;		/* Protocol version */
1444	const struct dentry_operations *dentry_ops;
1445	const struct inode_operations *dir_inode_ops;
1446	const struct inode_operations *file_inode_ops;
1447	const struct file_operations *file_ops;
1448
1449	int	(*getroot) (struct nfs_server *, struct nfs_fh *,
1450			    struct nfs_fsinfo *);
1451	struct vfsmount *(*submount) (struct nfs_server *, struct dentry *,
1452				      struct nfs_fh *, struct nfs_fattr *);
1453	struct dentry *(*try_mount) (int, const char *, struct nfs_mount_info *,
1454				     struct nfs_subversion *);
1455	int	(*getattr) (struct nfs_server *, struct nfs_fh *,
1456			    struct nfs_fattr *, struct nfs4_label *);
1457	int	(*setattr) (struct dentry *, struct nfs_fattr *,
1458			    struct iattr *);
1459	int	(*lookup)  (struct inode *, struct qstr *,
1460			    struct nfs_fh *, struct nfs_fattr *,
1461			    struct nfs4_label *);
1462	int	(*access)  (struct inode *, struct nfs_access_entry *);
1463	int	(*readlink)(struct inode *, struct page *, unsigned int,
1464			    unsigned int);
1465	int	(*create)  (struct inode *, struct dentry *,
1466			    struct iattr *, int);
1467	int	(*remove)  (struct inode *, struct qstr *);
1468	void	(*unlink_setup)  (struct rpc_message *, struct inode *dir);
1469	void	(*unlink_rpc_prepare) (struct rpc_task *, struct nfs_unlinkdata *);
1470	int	(*unlink_done) (struct rpc_task *, struct inode *);
1471	void	(*rename_setup)  (struct rpc_message *msg, struct inode *dir);
1472	void	(*rename_rpc_prepare)(struct rpc_task *task, struct nfs_renamedata *);
1473	int	(*rename_done) (struct rpc_task *task, struct inode *old_dir, struct inode *new_dir);
1474	int	(*link)    (struct inode *, struct inode *, struct qstr *);
1475	int	(*symlink) (struct inode *, struct dentry *, struct page *,
1476			    unsigned int, struct iattr *);
1477	int	(*mkdir)   (struct inode *, struct dentry *, struct iattr *);
1478	int	(*rmdir)   (struct inode *, struct qstr *);
1479	int	(*readdir) (struct dentry *, struct rpc_cred *,
1480			    u64, struct page **, unsigned int, int);
1481	int	(*mknod)   (struct inode *, struct dentry *, struct iattr *,
1482			    dev_t);
1483	int	(*statfs)  (struct nfs_server *, struct nfs_fh *,
1484			    struct nfs_fsstat *);
1485	int	(*fsinfo)  (struct nfs_server *, struct nfs_fh *,
1486			    struct nfs_fsinfo *);
1487	int	(*pathconf) (struct nfs_server *, struct nfs_fh *,
1488			     struct nfs_pathconf *);
1489	int	(*set_capabilities)(struct nfs_server *, struct nfs_fh *);
1490	int	(*decode_dirent)(struct xdr_stream *, struct nfs_entry *, int);
1491	int	(*pgio_rpc_prepare)(struct rpc_task *,
1492				    struct nfs_pgio_header *);
1493	void	(*read_setup)(struct nfs_pgio_header *, struct rpc_message *);
1494	int	(*read_done)(struct rpc_task *, struct nfs_pgio_header *);
1495	void	(*write_setup)(struct nfs_pgio_header *, struct rpc_message *);
1496	int	(*write_done)(struct rpc_task *, struct nfs_pgio_header *);
1497	void	(*commit_setup) (struct nfs_commit_data *, struct rpc_message *);
1498	void	(*commit_rpc_prepare)(struct rpc_task *, struct nfs_commit_data *);
1499	int	(*commit_done) (struct rpc_task *, struct nfs_commit_data *);
1500	int	(*lock)(struct file *, int, struct file_lock *);
1501	int	(*lock_check_bounds)(const struct file_lock *);
1502	void	(*clear_acl_cache)(struct inode *);
1503	void	(*close_context)(struct nfs_open_context *ctx, int);
1504	struct inode * (*open_context) (struct inode *dir,
1505				struct nfs_open_context *ctx,
1506				int open_flags,
1507				struct iattr *iattr,
1508				int *);
1509	int (*have_delegation)(struct inode *, fmode_t);
1510	int (*return_delegation)(struct inode *);
1511	struct nfs_client *(*alloc_client) (const struct nfs_client_initdata *);
1512	struct nfs_client *
1513		(*init_client) (struct nfs_client *, const struct rpc_timeout *,
1514				const char *);
1515	void	(*free_client) (struct nfs_client *);
1516	struct nfs_server *(*create_server)(struct nfs_mount_info *, struct nfs_subversion *);
1517	struct nfs_server *(*clone_server)(struct nfs_server *, struct nfs_fh *,
1518					   struct nfs_fattr *, rpc_authflavor_t);
1519};
1520
1521/*
1522 * 	NFS_CALL(getattr, inode, (fattr));
1523 * into
1524 *	NFS_PROTO(inode)->getattr(fattr);
1525 */
1526#define NFS_CALL(op, inode, args)	NFS_PROTO(inode)->op args
1527
1528/*
1529 * Function vectors etc. for the NFS client
1530 */
1531extern const struct nfs_rpc_ops	nfs_v2_clientops;
1532extern const struct nfs_rpc_ops	nfs_v3_clientops;
1533extern const struct nfs_rpc_ops	nfs_v4_clientops;
1534extern const struct rpc_version nfs_version2;
1535extern const struct rpc_version nfs_version3;
1536extern const struct rpc_version nfs_version4;
1537
1538extern const struct rpc_version nfsacl_version3;
1539extern const struct rpc_program nfsacl_program;
1540
1541#endif
1542