1/*
2 *  Server-side types for NFSv4.
3 *
4 *  Copyright (c) 2002 The Regents of the University of Michigan.
5 *  All rights reserved.
6 *
7 *  Kendrick Smith <kmsmith@umich.edu>
8 *  Andy Adamson   <andros@umich.edu>
9 *
10 *  Redistribution and use in source and binary forms, with or without
11 *  modification, are permitted provided that the following conditions
12 *  are met:
13 *
14 *  1. Redistributions of source code must retain the above copyright
15 *     notice, this list of conditions and the following disclaimer.
16 *  2. Redistributions in binary form must reproduce the above copyright
17 *     notice, this list of conditions and the following disclaimer in the
18 *     documentation and/or other materials provided with the distribution.
19 *  3. Neither the name of the University nor the names of its
20 *     contributors may be used to endorse or promote products derived
21 *     from this software without specific prior written permission.
22 *
23 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
24 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
25 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
26 *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
28 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
29 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
30 *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
31 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
32 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
33 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
34 *
35 */
36
37#ifndef _LINUX_NFSD_XDR4_H
38#define _LINUX_NFSD_XDR4_H
39
40#include "state.h"
41#include "nfsd.h"
42
43#define NFSD4_MAX_TAGLEN	128
44#define XDR_LEN(n)                     (((n) + 3) & ~3)
45
46#define CURRENT_STATE_ID_FLAG (1<<0)
47#define SAVED_STATE_ID_FLAG (1<<1)
48
49#define SET_CSTATE_FLAG(c, f) ((c)->sid_flags |= (f))
50#define HAS_CSTATE_FLAG(c, f) ((c)->sid_flags & (f))
51#define CLEAR_CSTATE_FLAG(c, f) ((c)->sid_flags &= ~(f))
52
53/**
54 * nfsd4_encode_bool - Encode an XDR bool type result
55 * @xdr: target XDR stream
56 * @val: boolean value to encode
57 *
58 * Return values:
59 *    %nfs_ok: @val encoded; @xdr advanced to next position
60 *    %nfserr_resource: stream buffer space exhausted
61 */
62static __always_inline __be32
63nfsd4_encode_bool(struct xdr_stream *xdr, bool val)
64{
65	__be32 *p = xdr_reserve_space(xdr, XDR_UNIT);
66
67	if (unlikely(p == NULL))
68		return nfserr_resource;
69	*p = val ? xdr_one : xdr_zero;
70	return nfs_ok;
71}
72
73/**
74 * nfsd4_encode_uint32_t - Encode an XDR uint32_t type result
75 * @xdr: target XDR stream
76 * @val: integer value to encode
77 *
78 * Return values:
79 *    %nfs_ok: @val encoded; @xdr advanced to next position
80 *    %nfserr_resource: stream buffer space exhausted
81 */
82static __always_inline __be32
83nfsd4_encode_uint32_t(struct xdr_stream *xdr, u32 val)
84{
85	__be32 *p = xdr_reserve_space(xdr, XDR_UNIT);
86
87	if (unlikely(p == NULL))
88		return nfserr_resource;
89	*p = cpu_to_be32(val);
90	return nfs_ok;
91}
92
93#define nfsd4_encode_aceflag4(x, v)	nfsd4_encode_uint32_t(x, v)
94#define nfsd4_encode_acemask4(x, v)	nfsd4_encode_uint32_t(x, v)
95#define nfsd4_encode_acetype4(x, v)	nfsd4_encode_uint32_t(x, v)
96#define nfsd4_encode_count4(x, v)	nfsd4_encode_uint32_t(x, v)
97#define nfsd4_encode_mode4(x, v)	nfsd4_encode_uint32_t(x, v)
98#define nfsd4_encode_nfs_lease4(x, v)	nfsd4_encode_uint32_t(x, v)
99#define nfsd4_encode_qop4(x, v)		nfsd4_encode_uint32_t(x, v)
100#define nfsd4_encode_sequenceid4(x, v)	nfsd4_encode_uint32_t(x, v)
101#define nfsd4_encode_slotid4(x, v)	nfsd4_encode_uint32_t(x, v)
102
103/**
104 * nfsd4_encode_uint64_t - Encode an XDR uint64_t type result
105 * @xdr: target XDR stream
106 * @val: integer value to encode
107 *
108 * Return values:
109 *    %nfs_ok: @val encoded; @xdr advanced to next position
110 *    %nfserr_resource: stream buffer space exhausted
111 */
112static __always_inline __be32
113nfsd4_encode_uint64_t(struct xdr_stream *xdr, u64 val)
114{
115	__be32 *p = xdr_reserve_space(xdr, XDR_UNIT * 2);
116
117	if (unlikely(p == NULL))
118		return nfserr_resource;
119	put_unaligned_be64(val, p);
120	return nfs_ok;
121}
122
123#define nfsd4_encode_changeid4(x, v)	nfsd4_encode_uint64_t(x, v)
124#define nfsd4_encode_nfs_cookie4(x, v)	nfsd4_encode_uint64_t(x, v)
125#define nfsd4_encode_length4(x, v)	nfsd4_encode_uint64_t(x, v)
126#define nfsd4_encode_offset4(x, v)	nfsd4_encode_uint64_t(x, v)
127
128/**
129 * nfsd4_encode_opaque_fixed - Encode a fixed-length XDR opaque type result
130 * @xdr: target XDR stream
131 * @data: pointer to data
132 * @size: length of data in bytes
133 *
134 * Return values:
135 *    %nfs_ok: @data encoded; @xdr advanced to next position
136 *    %nfserr_resource: stream buffer space exhausted
137 */
138static __always_inline __be32
139nfsd4_encode_opaque_fixed(struct xdr_stream *xdr, const void *data,
140			  size_t size)
141{
142	__be32 *p = xdr_reserve_space(xdr, xdr_align_size(size));
143	size_t pad = xdr_pad_size(size);
144
145	if (unlikely(p == NULL))
146		return nfserr_resource;
147	memcpy(p, data, size);
148	if (pad)
149		memset((char *)p + size, 0, pad);
150	return nfs_ok;
151}
152
153/**
154 * nfsd4_encode_opaque - Encode a variable-length XDR opaque type result
155 * @xdr: target XDR stream
156 * @data: pointer to data
157 * @size: length of data in bytes
158 *
159 * Return values:
160 *    %nfs_ok: @data encoded; @xdr advanced to next position
161 *    %nfserr_resource: stream buffer space exhausted
162 */
163static __always_inline __be32
164nfsd4_encode_opaque(struct xdr_stream *xdr, const void *data, size_t size)
165{
166	size_t pad = xdr_pad_size(size);
167	__be32 *p;
168
169	p = xdr_reserve_space(xdr, XDR_UNIT + xdr_align_size(size));
170	if (unlikely(p == NULL))
171		return nfserr_resource;
172	*p++ = cpu_to_be32(size);
173	memcpy(p, data, size);
174	if (pad)
175		memset((char *)p + size, 0, pad);
176	return nfs_ok;
177}
178
179#define nfsd4_encode_component4(x, d, s)	nfsd4_encode_opaque(x, d, s)
180
181struct nfsd4_compound_state {
182	struct svc_fh		current_fh;
183	struct svc_fh		save_fh;
184	struct nfs4_stateowner	*replay_owner;
185	struct nfs4_client	*clp;
186	/* For sessions DRC */
187	struct nfsd4_session	*session;
188	struct nfsd4_slot	*slot;
189	int			data_offset;
190	bool                    spo_must_allowed;
191	size_t			iovlen;
192	u32			minorversion;
193	__be32			status;
194	stateid_t	current_stateid;
195	stateid_t	save_stateid;
196	/* to indicate current and saved state id presents */
197	u32		sid_flags;
198};
199
200static inline bool nfsd4_has_session(struct nfsd4_compound_state *cs)
201{
202	return cs->slot != NULL;
203}
204
205struct nfsd4_change_info {
206	u32		atomic;
207	u64		before_change;
208	u64		after_change;
209};
210
211struct nfsd4_access {
212	u32		ac_req_access;      /* request */
213	u32		ac_supported;       /* response */
214	u32		ac_resp_access;     /* response */
215};
216
217struct nfsd4_close {
218	u32		cl_seqid;           /* request */
219	stateid_t	cl_stateid;         /* request+response */
220};
221
222struct nfsd4_commit {
223	u64		co_offset;          /* request */
224	u32		co_count;           /* request */
225	nfs4_verifier	co_verf;            /* response */
226};
227
228struct nfsd4_create {
229	u32		cr_namelen;         /* request */
230	char *		cr_name;            /* request */
231	u32		cr_type;            /* request */
232	union {                             /* request */
233		struct {
234			u32 datalen;
235			char *data;
236			struct kvec first;
237		} link;   /* NF4LNK */
238		struct {
239			u32 specdata1;
240			u32 specdata2;
241		} dev;    /* NF4BLK, NF4CHR */
242	} u;
243	u32		cr_bmval[3];        /* request */
244	struct iattr	cr_iattr;           /* request */
245	int		cr_umask;           /* request */
246	struct nfsd4_change_info  cr_cinfo; /* response */
247	struct nfs4_acl *cr_acl;
248	struct xdr_netobj cr_label;
249};
250#define cr_datalen	u.link.datalen
251#define cr_data		u.link.data
252#define cr_first	u.link.first
253#define cr_specdata1	u.dev.specdata1
254#define cr_specdata2	u.dev.specdata2
255
256struct nfsd4_delegreturn {
257	stateid_t	dr_stateid;
258};
259
260struct nfsd4_getattr {
261	u32		ga_bmval[3];        /* request */
262	struct svc_fh	*ga_fhp;            /* response */
263};
264
265struct nfsd4_link {
266	u32		li_namelen;         /* request */
267	char *		li_name;            /* request */
268	struct nfsd4_change_info  li_cinfo; /* response */
269};
270
271struct nfsd4_lock_denied {
272	clientid_t	ld_clientid;
273	struct xdr_netobj	ld_owner;
274	u64             ld_start;
275	u64             ld_length;
276	u32             ld_type;
277};
278
279struct nfsd4_lock {
280	/* request */
281	u32             lk_type;
282	u32             lk_reclaim;         /* boolean */
283	u64             lk_offset;
284	u64             lk_length;
285	u32             lk_is_new;
286	union {
287		struct {
288			u32             open_seqid;
289			stateid_t       open_stateid;
290			u32             lock_seqid;
291			clientid_t      clientid;
292			struct xdr_netobj owner;
293		} new;
294		struct {
295			stateid_t       lock_stateid;
296			u32             lock_seqid;
297		} old;
298	} v;
299
300	/* response */
301	stateid_t			lk_resp_stateid;
302	struct nfsd4_lock_denied        lk_denied;
303};
304#define lk_new_open_seqid       v.new.open_seqid
305#define lk_new_open_stateid     v.new.open_stateid
306#define lk_new_lock_seqid       v.new.lock_seqid
307#define lk_new_clientid         v.new.clientid
308#define lk_new_owner            v.new.owner
309#define lk_old_lock_stateid     v.old.lock_stateid
310#define lk_old_lock_seqid       v.old.lock_seqid
311
312struct nfsd4_lockt {
313	u32				lt_type;
314	clientid_t			lt_clientid;
315	struct xdr_netobj		lt_owner;
316	u64				lt_offset;
317	u64				lt_length;
318	struct nfsd4_lock_denied	lt_denied;
319};
320
321struct nfsd4_locku {
322	u32             lu_type;
323	u32             lu_seqid;
324	stateid_t       lu_stateid;
325	u64             lu_offset;
326	u64             lu_length;
327};
328
329
330struct nfsd4_lookup {
331	u32		lo_len;             /* request */
332	char *		lo_name;            /* request */
333};
334
335struct nfsd4_putfh {
336	u32		pf_fhlen;           /* request */
337	char		*pf_fhval;          /* request */
338	bool		no_verify;	    /* represents foreigh fh */
339};
340
341struct nfsd4_getxattr {
342	char		*getxa_name;		/* request */
343	u32		getxa_len;		/* request */
344	void		*getxa_buf;
345};
346
347struct nfsd4_setxattr {
348	u32		setxa_flags;		/* request */
349	char		*setxa_name;		/* request */
350	char		*setxa_buf;		/* request */
351	u32		setxa_len;		/* request */
352	struct nfsd4_change_info  setxa_cinfo;	/* response */
353};
354
355struct nfsd4_removexattr {
356	char		*rmxa_name;		/* request */
357	struct nfsd4_change_info  rmxa_cinfo;	/* response */
358};
359
360struct nfsd4_listxattrs {
361	u64		lsxa_cookie;		/* request */
362	u32		lsxa_maxcount;		/* request */
363	char		*lsxa_buf;		/* unfiltered buffer (reply) */
364	u32		lsxa_len;		/* unfiltered len (reply) */
365};
366
367struct nfsd4_open {
368	u32		op_claim_type;      /* request */
369	u32		op_fnamelen;
370	char *		op_fname;	    /* request - everything but CLAIM_PREV */
371	u32		op_delegate_type;   /* request - CLAIM_PREV only */
372	stateid_t       op_delegate_stateid; /* request - response */
373	u32		op_why_no_deleg;    /* response - DELEG_NONE_EXT only */
374	u32		op_create;     	    /* request */
375	u32		op_createmode;      /* request */
376	int		op_umask;           /* request */
377	u32		op_bmval[3];        /* request */
378	struct iattr	op_iattr;           /* UNCHECKED4, GUARDED4, EXCLUSIVE4_1 */
379	nfs4_verifier	op_verf __attribute__((aligned(32)));
380					    /* EXCLUSIVE4 */
381	clientid_t	op_clientid;        /* request */
382	struct xdr_netobj op_owner;           /* request */
383	u32		op_seqid;           /* request */
384	u32		op_share_access;    /* request */
385	u32		op_share_deny;      /* request */
386	u32		op_deleg_want;      /* request */
387	stateid_t	op_stateid;         /* response */
388	__be32		op_xdr_error;       /* see nfsd4_open_omfg() */
389	struct nfsd4_change_info  op_cinfo; /* response */
390	u32		op_rflags;          /* response */
391	bool		op_recall;          /* response */
392	bool		op_truncate;        /* used during processing */
393	bool		op_created;         /* used during processing */
394	struct nfs4_openowner *op_openowner; /* used during processing */
395	struct file	*op_filp;           /* used during processing */
396	struct nfs4_file *op_file;          /* used during processing */
397	struct nfs4_ol_stateid *op_stp;	    /* used during processing */
398	struct nfs4_clnt_odstate *op_odstate; /* used during processing */
399	struct nfs4_acl *op_acl;
400	struct xdr_netobj op_label;
401	struct svc_rqst *op_rqstp;
402};
403
404struct nfsd4_open_confirm {
405	stateid_t	oc_req_stateid		/* request */;
406	u32		oc_seqid    		/* request */;
407	stateid_t	oc_resp_stateid		/* response */;
408};
409
410struct nfsd4_open_downgrade {
411	stateid_t       od_stateid;
412	u32             od_seqid;
413	u32             od_share_access;	/* request */
414	u32		od_deleg_want;		/* request */
415	u32             od_share_deny;		/* request */
416};
417
418
419struct nfsd4_read {
420	stateid_t		rd_stateid;         /* request */
421	u64			rd_offset;          /* request */
422	u32			rd_length;          /* request */
423	int			rd_vlen;
424	struct nfsd_file	*rd_nf;
425
426	struct svc_rqst		*rd_rqstp;          /* response */
427	struct svc_fh		*rd_fhp;            /* response */
428	u32			rd_eof;             /* response */
429};
430
431struct nfsd4_readdir {
432	u64		rd_cookie;          /* request */
433	nfs4_verifier	rd_verf;            /* request */
434	u32		rd_dircount;        /* request */
435	u32		rd_maxcount;        /* request */
436	u32		rd_bmval[3];        /* request */
437	struct svc_rqst *rd_rqstp;          /* response */
438	struct svc_fh * rd_fhp;             /* response */
439
440	struct readdir_cd	common;
441	struct xdr_stream	*xdr;
442	int			cookie_offset;
443};
444
445struct nfsd4_release_lockowner {
446	clientid_t        rl_clientid;
447	struct xdr_netobj rl_owner;
448};
449struct nfsd4_readlink {
450	struct svc_rqst *rl_rqstp;          /* request */
451	struct svc_fh *	rl_fhp;             /* request */
452};
453
454struct nfsd4_remove {
455	u32		rm_namelen;         /* request */
456	char *		rm_name;            /* request */
457	struct nfsd4_change_info  rm_cinfo; /* response */
458};
459
460struct nfsd4_rename {
461	u32		rn_snamelen;        /* request */
462	char *		rn_sname;           /* request */
463	u32		rn_tnamelen;        /* request */
464	char *		rn_tname;           /* request */
465	struct nfsd4_change_info  rn_sinfo; /* response */
466	struct nfsd4_change_info  rn_tinfo; /* response */
467};
468
469struct nfsd4_secinfo {
470	u32 si_namelen;					/* request */
471	char *si_name;					/* request */
472	struct svc_export *si_exp;			/* response */
473};
474
475struct nfsd4_secinfo_no_name {
476	u32 sin_style;					/* request */
477	struct svc_export *sin_exp;			/* response */
478};
479
480struct nfsd4_setattr {
481	stateid_t	sa_stateid;         /* request */
482	u32		sa_bmval[3];        /* request */
483	struct iattr	sa_iattr;           /* request */
484	struct nfs4_acl *sa_acl;
485	struct xdr_netobj sa_label;
486};
487
488struct nfsd4_setclientid {
489	nfs4_verifier	se_verf;            /* request */
490	struct xdr_netobj se_name;
491	u32		se_callback_prog;   /* request */
492	u32		se_callback_netid_len;  /* request */
493	char *		se_callback_netid_val;  /* request */
494	u32		se_callback_addr_len;   /* request */
495	char *		se_callback_addr_val;   /* request */
496	u32		se_callback_ident;  /* request */
497	clientid_t	se_clientid;        /* response */
498	nfs4_verifier	se_confirm;         /* response */
499};
500
501struct nfsd4_setclientid_confirm {
502	clientid_t	sc_clientid;
503	nfs4_verifier	sc_confirm;
504};
505
506struct nfsd4_test_stateid_id {
507	__be32			ts_id_status;
508	stateid_t		ts_id_stateid;
509	struct list_head	ts_id_list;
510};
511
512struct nfsd4_test_stateid {
513	u32		ts_num_ids;
514	struct list_head ts_stateid_list;
515};
516
517struct nfsd4_free_stateid {
518	stateid_t	fr_stateid;         /* request */
519};
520
521/* also used for NVERIFY */
522struct nfsd4_verify {
523	u32		ve_bmval[3];        /* request */
524	u32		ve_attrlen;         /* request */
525	char *		ve_attrval;         /* request */
526};
527
528struct nfsd4_write {
529	stateid_t	wr_stateid;         /* request */
530	u64		wr_offset;          /* request */
531	u32		wr_stable_how;      /* request */
532	u32		wr_buflen;          /* request */
533	struct xdr_buf	wr_payload;         /* request */
534
535	u32		wr_bytes_written;   /* response */
536	u32		wr_how_written;     /* response */
537	nfs4_verifier	wr_verifier;        /* response */
538};
539
540struct nfsd4_exchange_id {
541	nfs4_verifier	verifier;
542	struct xdr_netobj clname;
543	u32		flags;
544	clientid_t	clientid;
545	u32		seqid;
546	u32		spa_how;
547	u32             spo_must_enforce[3];
548	u32             spo_must_allow[3];
549	struct xdr_netobj nii_domain;
550	struct xdr_netobj nii_name;
551	struct timespec64 nii_time;
552};
553
554struct nfsd4_sequence {
555	struct nfs4_sessionid	sessionid;		/* request/response */
556	u32			seqid;			/* request/response */
557	u32			slotid;			/* request/response */
558	u32			maxslots;		/* request/response */
559	u32			cachethis;		/* request */
560#if 0
561	u32			target_maxslots;	/* response */
562#endif /* not yet */
563	u32			status_flags;		/* response */
564};
565
566struct nfsd4_destroy_session {
567	struct nfs4_sessionid	sessionid;
568};
569
570struct nfsd4_destroy_clientid {
571	clientid_t clientid;
572};
573
574struct nfsd4_reclaim_complete {
575	u32 rca_one_fs;
576};
577
578struct nfsd4_deviceid {
579	u64			fsid_idx;
580	u32			generation;
581	u32			pad;
582};
583
584struct nfsd4_layout_seg {
585	u32			iomode;
586	u64			offset;
587	u64			length;
588};
589
590struct nfsd4_getdeviceinfo {
591	struct nfsd4_deviceid	gd_devid;	/* request */
592	u32			gd_layout_type;	/* request */
593	u32			gd_maxcount;	/* request */
594	u32			gd_notify_types;/* request - response */
595	void			*gd_device;	/* response */
596};
597
598struct nfsd4_layoutget {
599	u64			lg_minlength;	/* request */
600	u32			lg_signal;	/* request */
601	u32			lg_layout_type;	/* request */
602	u32			lg_maxcount;	/* request */
603	stateid_t		lg_sid;		/* request/response */
604	struct nfsd4_layout_seg	lg_seg;		/* request/response */
605	void			*lg_content;	/* response */
606};
607
608struct nfsd4_layoutcommit {
609	stateid_t		lc_sid;		/* request */
610	struct nfsd4_layout_seg	lc_seg;		/* request */
611	u32			lc_reclaim;	/* request */
612	u32			lc_newoffset;	/* request */
613	u64			lc_last_wr;	/* request */
614	struct timespec64	lc_mtime;	/* request */
615	u32			lc_layout_type;	/* request */
616	u32			lc_up_len;	/* layout length */
617	void			*lc_up_layout;	/* decoded by callback */
618	bool			lc_size_chg;	/* response */
619	u64			lc_newsize;	/* response */
620};
621
622struct nfsd4_layoutreturn {
623	u32			lr_return_type;	/* request */
624	u32			lr_layout_type;	/* request */
625	struct nfsd4_layout_seg	lr_seg;		/* request */
626	u32			lr_reclaim;	/* request */
627	u32			lrf_body_len;	/* request */
628	void			*lrf_body;	/* request */
629	stateid_t		lr_sid;		/* request/response */
630	bool			lrs_present;	/* response */
631};
632
633struct nfsd4_fallocate {
634	/* request */
635	stateid_t	falloc_stateid;
636	loff_t		falloc_offset;
637	u64		falloc_length;
638};
639
640struct nfsd4_clone {
641	/* request */
642	stateid_t	cl_src_stateid;
643	stateid_t	cl_dst_stateid;
644	u64		cl_src_pos;
645	u64		cl_dst_pos;
646	u64		cl_count;
647};
648
649struct nfsd42_write_res {
650	u64			wr_bytes_written;
651	u32			wr_stable_how;
652	nfs4_verifier		wr_verifier;
653	stateid_t		cb_stateid;
654};
655
656struct nfsd4_cb_offload {
657	struct nfsd4_callback	co_cb;
658	struct nfsd42_write_res	co_res;
659	__be32			co_nfserr;
660	struct knfsd_fh		co_fh;
661};
662
663struct nfsd4_copy {
664	/* request */
665	stateid_t		cp_src_stateid;
666	stateid_t		cp_dst_stateid;
667	u64			cp_src_pos;
668	u64			cp_dst_pos;
669	u64			cp_count;
670	struct nl4_server	*cp_src;
671
672	unsigned long		cp_flags;
673#define NFSD4_COPY_F_STOPPED		(0)
674#define NFSD4_COPY_F_INTRA		(1)
675#define NFSD4_COPY_F_SYNCHRONOUS	(2)
676#define NFSD4_COPY_F_COMMITTED		(3)
677
678	/* response */
679	struct nfsd42_write_res	cp_res;
680	struct knfsd_fh		fh;
681
682	struct nfs4_client      *cp_clp;
683
684	struct nfsd_file        *nf_src;
685	struct nfsd_file        *nf_dst;
686
687	copy_stateid_t		cp_stateid;
688
689	struct list_head	copies;
690	struct task_struct	*copy_task;
691	refcount_t		refcount;
692
693	struct nfsd4_ssc_umount_item *ss_nsui;
694	struct nfs_fh		c_fh;
695	nfs4_stateid		stateid;
696};
697
698static inline void nfsd4_copy_set_sync(struct nfsd4_copy *copy, bool sync)
699{
700	if (sync)
701		set_bit(NFSD4_COPY_F_SYNCHRONOUS, &copy->cp_flags);
702	else
703		clear_bit(NFSD4_COPY_F_SYNCHRONOUS, &copy->cp_flags);
704}
705
706static inline bool nfsd4_copy_is_sync(const struct nfsd4_copy *copy)
707{
708	return test_bit(NFSD4_COPY_F_SYNCHRONOUS, &copy->cp_flags);
709}
710
711static inline bool nfsd4_copy_is_async(const struct nfsd4_copy *copy)
712{
713	return !test_bit(NFSD4_COPY_F_SYNCHRONOUS, &copy->cp_flags);
714}
715
716static inline bool nfsd4_ssc_is_inter(const struct nfsd4_copy *copy)
717{
718	return !test_bit(NFSD4_COPY_F_INTRA, &copy->cp_flags);
719}
720
721struct nfsd4_seek {
722	/* request */
723	stateid_t	seek_stateid;
724	loff_t		seek_offset;
725	u32		seek_whence;
726
727	/* response */
728	u32		seek_eof;
729	loff_t		seek_pos;
730};
731
732struct nfsd4_offload_status {
733	/* request */
734	stateid_t	stateid;
735
736	/* response */
737	u64		count;
738	u32		status;
739};
740
741struct nfsd4_copy_notify {
742	/* request */
743	stateid_t		cpn_src_stateid;
744	struct nl4_server	*cpn_dst;
745
746	/* response */
747	stateid_t		cpn_cnr_stateid;
748	struct timespec64	cpn_lease_time;
749	struct nl4_server	*cpn_src;
750};
751
752struct nfsd4_op {
753	u32					opnum;
754	__be32					status;
755	const struct nfsd4_operation		*opdesc;
756	struct nfs4_replay			*replay;
757	union nfsd4_op_u {
758		struct nfsd4_access		access;
759		struct nfsd4_close		close;
760		struct nfsd4_commit		commit;
761		struct nfsd4_create		create;
762		struct nfsd4_delegreturn	delegreturn;
763		struct nfsd4_getattr		getattr;
764		struct svc_fh *			getfh;
765		struct nfsd4_link		link;
766		struct nfsd4_lock		lock;
767		struct nfsd4_lockt		lockt;
768		struct nfsd4_locku		locku;
769		struct nfsd4_lookup		lookup;
770		struct nfsd4_verify		nverify;
771		struct nfsd4_open		open;
772		struct nfsd4_open_confirm	open_confirm;
773		struct nfsd4_open_downgrade	open_downgrade;
774		struct nfsd4_putfh		putfh;
775		struct nfsd4_read		read;
776		struct nfsd4_readdir		readdir;
777		struct nfsd4_readlink		readlink;
778		struct nfsd4_remove		remove;
779		struct nfsd4_rename		rename;
780		clientid_t			renew;
781		struct nfsd4_secinfo		secinfo;
782		struct nfsd4_setattr		setattr;
783		struct nfsd4_setclientid	setclientid;
784		struct nfsd4_setclientid_confirm setclientid_confirm;
785		struct nfsd4_verify		verify;
786		struct nfsd4_write		write;
787		struct nfsd4_release_lockowner	release_lockowner;
788
789		/* NFSv4.1 */
790		struct nfsd4_exchange_id	exchange_id;
791		struct nfsd4_backchannel_ctl	backchannel_ctl;
792		struct nfsd4_bind_conn_to_session bind_conn_to_session;
793		struct nfsd4_create_session	create_session;
794		struct nfsd4_destroy_session	destroy_session;
795		struct nfsd4_destroy_clientid	destroy_clientid;
796		struct nfsd4_sequence		sequence;
797		struct nfsd4_reclaim_complete	reclaim_complete;
798		struct nfsd4_test_stateid	test_stateid;
799		struct nfsd4_free_stateid	free_stateid;
800		struct nfsd4_getdeviceinfo	getdeviceinfo;
801		struct nfsd4_layoutget		layoutget;
802		struct nfsd4_layoutcommit	layoutcommit;
803		struct nfsd4_layoutreturn	layoutreturn;
804		struct nfsd4_secinfo_no_name	secinfo_no_name;
805
806		/* NFSv4.2 */
807		struct nfsd4_fallocate		allocate;
808		struct nfsd4_fallocate		deallocate;
809		struct nfsd4_clone		clone;
810		struct nfsd4_copy		copy;
811		struct nfsd4_offload_status	offload_status;
812		struct nfsd4_copy_notify	copy_notify;
813		struct nfsd4_seek		seek;
814
815		struct nfsd4_getxattr		getxattr;
816		struct nfsd4_setxattr		setxattr;
817		struct nfsd4_listxattrs		listxattrs;
818		struct nfsd4_removexattr	removexattr;
819	} u;
820};
821
822bool nfsd4_cache_this_op(struct nfsd4_op *);
823
824/*
825 * Memory needed just for the duration of processing one compound:
826 */
827struct svcxdr_tmpbuf {
828	struct svcxdr_tmpbuf *next;
829	char buf[];
830};
831
832struct nfsd4_compoundargs {
833	/* scratch variables for XDR decode */
834	struct xdr_stream		*xdr;
835	struct svcxdr_tmpbuf		*to_free;
836	struct svc_rqst			*rqstp;
837
838	char *				tag;
839	u32				taglen;
840	u32				minorversion;
841	u32				client_opcnt;
842	u32				opcnt;
843	bool				splice_ok;
844	struct nfsd4_op			*ops;
845	struct nfsd4_op			iops[8];
846};
847
848struct nfsd4_compoundres {
849	/* scratch variables for XDR encode */
850	struct xdr_stream		*xdr;
851	struct svc_rqst *		rqstp;
852
853	__be32				*statusp;
854	char *				tag;
855	u32				taglen;
856	u32				opcnt;
857
858	struct nfsd4_compound_state	cstate;
859};
860
861static inline bool nfsd4_is_solo_sequence(struct nfsd4_compoundres *resp)
862{
863	struct nfsd4_compoundargs *args = resp->rqstp->rq_argp;
864	return resp->opcnt == 1 && args->ops[0].opnum == OP_SEQUENCE;
865}
866
867/*
868 * The session reply cache only needs to cache replies that the client
869 * actually asked us to.  But it's almost free for us to cache compounds
870 * consisting of only a SEQUENCE op, so we may as well cache those too.
871 * Also, the protocol doesn't give us a convenient response in the case
872 * of a replay of a solo SEQUENCE op that wasn't cached
873 * (RETRY_UNCACHED_REP can only be returned in the second op of a
874 * compound).
875 */
876static inline bool nfsd4_cache_this(struct nfsd4_compoundres *resp)
877{
878	return (resp->cstate.slot->sl_flags & NFSD4_SLOT_CACHETHIS)
879		|| nfsd4_is_solo_sequence(resp);
880}
881
882static inline bool nfsd4_last_compound_op(struct svc_rqst *rqstp)
883{
884	struct nfsd4_compoundres *resp = rqstp->rq_resp;
885	struct nfsd4_compoundargs *argp = rqstp->rq_argp;
886
887	return argp->opcnt == resp->opcnt;
888}
889
890const struct nfsd4_operation *OPDESC(struct nfsd4_op *op);
891int nfsd4_max_reply(struct svc_rqst *rqstp, struct nfsd4_op *op);
892void warn_on_nonidempotent_op(struct nfsd4_op *op);
893
894#define NFS4_SVC_XDRSIZE		sizeof(struct nfsd4_compoundargs)
895
896bool nfsd4_mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp);
897bool nfs4svc_decode_compoundargs(struct svc_rqst *rqstp, struct xdr_stream *xdr);
898bool nfs4svc_encode_compoundres(struct svc_rqst *rqstp, struct xdr_stream *xdr);
899__be32 nfsd4_check_resp_size(struct nfsd4_compoundres *, u32);
900void nfsd4_encode_operation(struct nfsd4_compoundres *, struct nfsd4_op *);
901void nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op);
902__be32 nfsd4_encode_fattr_to_buf(__be32 **p, int words,
903		struct svc_fh *fhp, struct svc_export *exp,
904		struct dentry *dentry,
905		u32 *bmval, struct svc_rqst *, int ignore_crossmnt);
906extern __be32 nfsd4_setclientid(struct svc_rqst *rqstp,
907		struct nfsd4_compound_state *, union nfsd4_op_u *u);
908extern __be32 nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
909		struct nfsd4_compound_state *, union nfsd4_op_u *u);
910extern __be32 nfsd4_exchange_id(struct svc_rqst *rqstp,
911		struct nfsd4_compound_state *, union nfsd4_op_u *u);
912extern __be32 nfsd4_backchannel_ctl(struct svc_rqst *,
913		struct nfsd4_compound_state *, union nfsd4_op_u *u);
914extern __be32 nfsd4_bind_conn_to_session(struct svc_rqst *,
915		struct nfsd4_compound_state *, union nfsd4_op_u *u);
916extern __be32 nfsd4_create_session(struct svc_rqst *,
917		struct nfsd4_compound_state *, union nfsd4_op_u *u);
918extern __be32 nfsd4_sequence(struct svc_rqst *,
919		struct nfsd4_compound_state *, union nfsd4_op_u *u);
920extern void nfsd4_sequence_done(struct nfsd4_compoundres *resp);
921extern __be32 nfsd4_destroy_session(struct svc_rqst *,
922		struct nfsd4_compound_state *, union nfsd4_op_u *u);
923extern __be32 nfsd4_destroy_clientid(struct svc_rqst *, struct nfsd4_compound_state *,
924		union nfsd4_op_u *u);
925__be32 nfsd4_reclaim_complete(struct svc_rqst *, struct nfsd4_compound_state *,
926		union nfsd4_op_u *u);
927extern __be32 nfsd4_process_open1(struct nfsd4_compound_state *,
928		struct nfsd4_open *open, struct nfsd_net *nn);
929extern __be32 nfsd4_process_open2(struct svc_rqst *rqstp,
930		struct svc_fh *current_fh, struct nfsd4_open *open);
931extern void nfsd4_cstate_clear_replay(struct nfsd4_compound_state *cstate);
932extern void nfsd4_cleanup_open_state(struct nfsd4_compound_state *cstate,
933		struct nfsd4_open *open);
934extern __be32 nfsd4_open_confirm(struct svc_rqst *rqstp,
935		struct nfsd4_compound_state *, union nfsd4_op_u *u);
936extern __be32 nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *,
937		union nfsd4_op_u *u);
938extern __be32 nfsd4_open_downgrade(struct svc_rqst *rqstp,
939		struct nfsd4_compound_state *, union nfsd4_op_u *u);
940extern __be32 nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *,
941		union nfsd4_op_u *u);
942extern void nfsd4_lock_release(union nfsd4_op_u *u);
943extern __be32 nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *,
944		union nfsd4_op_u *u);
945extern void nfsd4_lockt_release(union nfsd4_op_u *u);
946extern __be32 nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *,
947		union nfsd4_op_u *u);
948extern __be32
949nfsd4_release_lockowner(struct svc_rqst *rqstp,
950		struct nfsd4_compound_state *, union nfsd4_op_u *u);
951extern void nfsd4_release_compoundargs(struct svc_rqst *rqstp);
952extern __be32 nfsd4_delegreturn(struct svc_rqst *rqstp,
953		struct nfsd4_compound_state *, union nfsd4_op_u *u);
954extern __be32 nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *,
955		union nfsd4_op_u *u);
956extern __be32 nfsd4_test_stateid(struct svc_rqst *rqstp,
957		struct nfsd4_compound_state *, union nfsd4_op_u *);
958extern __be32 nfsd4_free_stateid(struct svc_rqst *rqstp,
959		struct nfsd4_compound_state *, union nfsd4_op_u *);
960extern void nfsd4_bump_seqid(struct nfsd4_compound_state *, __be32 nfserr);
961
962enum nfsd4_op_flags {
963	ALLOWED_WITHOUT_FH = 1 << 0,    /* No current filehandle required */
964	ALLOWED_ON_ABSENT_FS = 1 << 1,  /* ops processed on absent fs */
965	ALLOWED_AS_FIRST_OP = 1 << 2,   /* ops reqired first in compound */
966	/* For rfc 5661 section 2.6.3.1.1: */
967	OP_HANDLES_WRONGSEC = 1 << 3,
968	OP_IS_PUTFH_LIKE = 1 << 4,
969	/*
970	 * These are the ops whose result size we estimate before
971	 * encoding, to avoid performing an op then not being able to
972	 * respond or cache a response.  This includes writes and setattrs
973	 * as well as the operations usually called "nonidempotent":
974	 */
975	OP_MODIFIES_SOMETHING = 1 << 5,
976	/*
977	 * Cache compounds containing these ops in the xid-based drc:
978	 * We use the DRC for compounds containing non-idempotent
979	 * operations, *except* those that are 4.1-specific (since
980	 * sessions provide their own EOS), and except for stateful
981	 * operations other than setclientid and setclientid_confirm
982	 * (since sequence numbers provide EOS for open, lock, etc in
983	 * the v4.0 case).
984	 */
985	OP_CACHEME = 1 << 6,
986	/*
987	 * These are ops which clear current state id.
988	 */
989	OP_CLEAR_STATEID = 1 << 7,
990	/* Most ops return only an error on failure; some may do more: */
991	OP_NONTRIVIAL_ERROR_ENCODE = 1 << 8,
992};
993
994struct nfsd4_operation {
995	__be32 (*op_func)(struct svc_rqst *, struct nfsd4_compound_state *,
996			union nfsd4_op_u *);
997	void (*op_release)(union nfsd4_op_u *);
998	u32 op_flags;
999	char *op_name;
1000	/* Try to get response size before operation */
1001	u32 (*op_rsize_bop)(const struct svc_rqst *rqstp,
1002			const struct nfsd4_op *op);
1003	void (*op_get_currentstateid)(struct nfsd4_compound_state *,
1004			union nfsd4_op_u *);
1005	void (*op_set_currentstateid)(struct nfsd4_compound_state *,
1006			union nfsd4_op_u *);
1007};
1008
1009struct nfsd4_cb_recall_any {
1010	struct nfsd4_callback	ra_cb;
1011	u32			ra_keep;
1012	u32			ra_bmval[1];
1013};
1014
1015#endif
1016