xref: /openbmc/linux/fs/nfsd/xdr4.h (revision 6abeae2a) 
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 struct nfsd4_compound_state {
54 	struct svc_fh		current_fh;
55 	struct svc_fh		save_fh;
56 	struct nfs4_stateowner	*replay_owner;
57 	struct nfs4_client	*clp;
58 	/* For sessions DRC */
59 	struct nfsd4_session	*session;
60 	struct nfsd4_slot	*slot;
61 	int			data_offset;
62 	bool                    spo_must_allowed;
63 	size_t			iovlen;
64 	u32			minorversion;
65 	__be32			status;
66 	stateid_t	current_stateid;
67 	stateid_t	save_stateid;
68 	/* to indicate current and saved state id presents */
69 	u32		sid_flags;
70 };
71 
72 static inline bool nfsd4_has_session(struct nfsd4_compound_state *cs)
73 {
74 	return cs->slot != NULL;
75 }
76 
77 struct nfsd4_change_info {
78 	u32		atomic;
79 	u64		before_change;
80 	u64		after_change;
81 };
82 
83 struct nfsd4_access {
84 	u32		ac_req_access;      /* request */
85 	u32		ac_supported;       /* response */
86 	u32		ac_resp_access;     /* response */
87 };
88 
89 struct nfsd4_close {
90 	u32		cl_seqid;           /* request */
91 	stateid_t	cl_stateid;         /* request+response */
92 };
93 
94 struct nfsd4_commit {
95 	u64		co_offset;          /* request */
96 	u32		co_count;           /* request */
97 	nfs4_verifier	co_verf;            /* response */
98 };
99 
100 struct nfsd4_create {
101 	u32		cr_namelen;         /* request */
102 	char *		cr_name;            /* request */
103 	u32		cr_type;            /* request */
104 	union {                             /* request */
105 		struct {
106 			u32 datalen;
107 			char *data;
108 			struct kvec first;
109 		} link;   /* NF4LNK */
110 		struct {
111 			u32 specdata1;
112 			u32 specdata2;
113 		} dev;    /* NF4BLK, NF4CHR */
114 	} u;
115 	u32		cr_bmval[3];        /* request */
116 	struct iattr	cr_iattr;           /* request */
117 	int		cr_umask;           /* request */
118 	struct nfsd4_change_info  cr_cinfo; /* response */
119 	struct nfs4_acl *cr_acl;
120 	struct xdr_netobj cr_label;
121 };
122 #define cr_datalen	u.link.datalen
123 #define cr_data		u.link.data
124 #define cr_first	u.link.first
125 #define cr_specdata1	u.dev.specdata1
126 #define cr_specdata2	u.dev.specdata2
127 
128 struct nfsd4_delegreturn {
129 	stateid_t	dr_stateid;
130 };
131 
132 struct nfsd4_getattr {
133 	u32		ga_bmval[3];        /* request */
134 	struct svc_fh	*ga_fhp;            /* response */
135 };
136 
137 struct nfsd4_link {
138 	u32		li_namelen;         /* request */
139 	char *		li_name;            /* request */
140 	struct nfsd4_change_info  li_cinfo; /* response */
141 };
142 
143 struct nfsd4_lock_denied {
144 	clientid_t	ld_clientid;
145 	struct xdr_netobj	ld_owner;
146 	u64             ld_start;
147 	u64             ld_length;
148 	u32             ld_type;
149 };
150 
151 struct nfsd4_lock {
152 	/* request */
153 	u32             lk_type;
154 	u32             lk_reclaim;         /* boolean */
155 	u64             lk_offset;
156 	u64             lk_length;
157 	u32             lk_is_new;
158 	union {
159 		struct {
160 			u32             open_seqid;
161 			stateid_t       open_stateid;
162 			u32             lock_seqid;
163 			clientid_t      clientid;
164 			struct xdr_netobj owner;
165 		} new;
166 		struct {
167 			stateid_t       lock_stateid;
168 			u32             lock_seqid;
169 		} old;
170 	} v;
171 
172 	/* response */
173 	union {
174 		struct {
175 			stateid_t               stateid;
176 		} ok;
177 		struct nfsd4_lock_denied        denied;
178 	} u;
179 };
180 #define lk_new_open_seqid       v.new.open_seqid
181 #define lk_new_open_stateid     v.new.open_stateid
182 #define lk_new_lock_seqid       v.new.lock_seqid
183 #define lk_new_clientid         v.new.clientid
184 #define lk_new_owner            v.new.owner
185 #define lk_old_lock_stateid     v.old.lock_stateid
186 #define lk_old_lock_seqid       v.old.lock_seqid
187 
188 #define lk_resp_stateid u.ok.stateid
189 #define lk_denied       u.denied
190 
191 
192 struct nfsd4_lockt {
193 	u32				lt_type;
194 	clientid_t			lt_clientid;
195 	struct xdr_netobj		lt_owner;
196 	u64				lt_offset;
197 	u64				lt_length;
198 	struct nfsd4_lock_denied  	lt_denied;
199 };
200 
201 
202 struct nfsd4_locku {
203 	u32             lu_type;
204 	u32             lu_seqid;
205 	stateid_t       lu_stateid;
206 	u64             lu_offset;
207 	u64             lu_length;
208 };
209 
210 
211 struct nfsd4_lookup {
212 	u32		lo_len;             /* request */
213 	char *		lo_name;            /* request */
214 };
215 
216 struct nfsd4_putfh {
217 	u32		pf_fhlen;           /* request */
218 	char		*pf_fhval;          /* request */
219 	bool		no_verify;	    /* represents foreigh fh */
220 };
221 
222 struct nfsd4_getxattr {
223 	char		*getxa_name;		/* request */
224 	u32		getxa_len;		/* request */
225 	void		*getxa_buf;
226 };
227 
228 struct nfsd4_setxattr {
229 	u32		setxa_flags;		/* request */
230 	char		*setxa_name;		/* request */
231 	char		*setxa_buf;		/* request */
232 	u32		setxa_len;		/* request */
233 	struct nfsd4_change_info  setxa_cinfo;	/* response */
234 };
235 
236 struct nfsd4_removexattr {
237 	char		*rmxa_name;		/* request */
238 	struct nfsd4_change_info  rmxa_cinfo;	/* response */
239 };
240 
241 struct nfsd4_listxattrs {
242 	u64		lsxa_cookie;		/* request */
243 	u32		lsxa_maxcount;		/* request */
244 	char		*lsxa_buf;		/* unfiltered buffer (reply) */
245 	u32		lsxa_len;		/* unfiltered len (reply) */
246 };
247 
248 struct nfsd4_open {
249 	u32		op_claim_type;      /* request */
250 	u32		op_fnamelen;
251 	char *		op_fname;	    /* request - everything but CLAIM_PREV */
252 	u32		op_delegate_type;   /* request - CLAIM_PREV only */
253 	stateid_t       op_delegate_stateid; /* request - response */
254 	u32		op_why_no_deleg;    /* response - DELEG_NONE_EXT only */
255 	u32		op_create;     	    /* request */
256 	u32		op_createmode;      /* request */
257 	int		op_umask;           /* request */
258 	u32		op_bmval[3];        /* request */
259 	struct iattr	op_iattr;           /* UNCHECKED4, GUARDED4, EXCLUSIVE4_1 */
260 	nfs4_verifier	op_verf __attribute__((aligned(32)));
261 					    /* EXCLUSIVE4 */
262 	clientid_t	op_clientid;        /* request */
263 	struct xdr_netobj op_owner;           /* request */
264 	u32		op_seqid;           /* request */
265 	u32		op_share_access;    /* request */
266 	u32		op_share_deny;      /* request */
267 	u32		op_deleg_want;      /* request */
268 	stateid_t	op_stateid;         /* response */
269 	__be32		op_xdr_error;       /* see nfsd4_open_omfg() */
270 	u32		op_recall;          /* recall */
271 	struct nfsd4_change_info  op_cinfo; /* response */
272 	u32		op_rflags;          /* response */
273 	bool		op_truncate;        /* used during processing */
274 	bool		op_created;         /* used during processing */
275 	struct nfs4_openowner *op_openowner; /* used during processing */
276 	struct nfs4_file *op_file;          /* used during processing */
277 	struct nfs4_ol_stateid *op_stp;	    /* used during processing */
278 	struct nfs4_clnt_odstate *op_odstate; /* used during processing */
279 	struct nfs4_acl *op_acl;
280 	struct xdr_netobj op_label;
281 };
282 
283 struct nfsd4_open_confirm {
284 	stateid_t	oc_req_stateid		/* request */;
285 	u32		oc_seqid    		/* request */;
286 	stateid_t	oc_resp_stateid		/* response */;
287 };
288 
289 struct nfsd4_open_downgrade {
290 	stateid_t       od_stateid;
291 	u32             od_seqid;
292 	u32             od_share_access;	/* request */
293 	u32		od_deleg_want;		/* request */
294 	u32             od_share_deny;		/* request */
295 };
296 
297 
298 struct nfsd4_read {
299 	stateid_t		rd_stateid;         /* request */
300 	u64			rd_offset;          /* request */
301 	u32			rd_length;          /* request */
302 	int			rd_vlen;
303 	struct nfsd_file	*rd_nf;
304 
305 	struct svc_rqst		*rd_rqstp;          /* response */
306 	struct svc_fh		*rd_fhp;             /* response */
307 };
308 
309 struct nfsd4_readdir {
310 	u64		rd_cookie;          /* request */
311 	nfs4_verifier	rd_verf;            /* request */
312 	u32		rd_dircount;        /* request */
313 	u32		rd_maxcount;        /* request */
314 	u32		rd_bmval[3];        /* request */
315 	struct svc_rqst *rd_rqstp;          /* response */
316 	struct svc_fh * rd_fhp;             /* response */
317 
318 	struct readdir_cd	common;
319 	struct xdr_stream	*xdr;
320 	int			cookie_offset;
321 };
322 
323 struct nfsd4_release_lockowner {
324 	clientid_t        rl_clientid;
325 	struct xdr_netobj rl_owner;
326 };
327 struct nfsd4_readlink {
328 	struct svc_rqst *rl_rqstp;          /* request */
329 	struct svc_fh *	rl_fhp;             /* request */
330 };
331 
332 struct nfsd4_remove {
333 	u32		rm_namelen;         /* request */
334 	char *		rm_name;            /* request */
335 	struct nfsd4_change_info  rm_cinfo; /* response */
336 };
337 
338 struct nfsd4_rename {
339 	u32		rn_snamelen;        /* request */
340 	char *		rn_sname;           /* request */
341 	u32		rn_tnamelen;        /* request */
342 	char *		rn_tname;           /* request */
343 	struct nfsd4_change_info  rn_sinfo; /* response */
344 	struct nfsd4_change_info  rn_tinfo; /* response */
345 };
346 
347 struct nfsd4_secinfo {
348 	u32 si_namelen;					/* request */
349 	char *si_name;					/* request */
350 	struct svc_export *si_exp;			/* response */
351 };
352 
353 struct nfsd4_secinfo_no_name {
354 	u32 sin_style;					/* request */
355 	struct svc_export *sin_exp;			/* response */
356 };
357 
358 struct nfsd4_setattr {
359 	stateid_t	sa_stateid;         /* request */
360 	u32		sa_bmval[3];        /* request */
361 	struct iattr	sa_iattr;           /* request */
362 	struct nfs4_acl *sa_acl;
363 	struct xdr_netobj sa_label;
364 };
365 
366 struct nfsd4_setclientid {
367 	nfs4_verifier	se_verf;            /* request */
368 	struct xdr_netobj se_name;
369 	u32		se_callback_prog;   /* request */
370 	u32		se_callback_netid_len;  /* request */
371 	char *		se_callback_netid_val;  /* request */
372 	u32		se_callback_addr_len;   /* request */
373 	char *		se_callback_addr_val;   /* request */
374 	u32		se_callback_ident;  /* request */
375 	clientid_t	se_clientid;        /* response */
376 	nfs4_verifier	se_confirm;         /* response */
377 };
378 
379 struct nfsd4_setclientid_confirm {
380 	clientid_t	sc_clientid;
381 	nfs4_verifier	sc_confirm;
382 };
383 
384 struct nfsd4_test_stateid_id {
385 	__be32			ts_id_status;
386 	stateid_t		ts_id_stateid;
387 	struct list_head	ts_id_list;
388 };
389 
390 struct nfsd4_test_stateid {
391 	u32		ts_num_ids;
392 	struct list_head ts_stateid_list;
393 };
394 
395 struct nfsd4_free_stateid {
396 	stateid_t	fr_stateid;         /* request */
397 };
398 
399 /* also used for NVERIFY */
400 struct nfsd4_verify {
401 	u32		ve_bmval[3];        /* request */
402 	u32		ve_attrlen;         /* request */
403 	char *		ve_attrval;         /* request */
404 };
405 
406 struct nfsd4_write {
407 	stateid_t	wr_stateid;         /* request */
408 	u64		wr_offset;          /* request */
409 	u32		wr_stable_how;      /* request */
410 	u32		wr_buflen;          /* request */
411 	struct xdr_buf	wr_payload;         /* request */
412 
413 	u32		wr_bytes_written;   /* response */
414 	u32		wr_how_written;     /* response */
415 	nfs4_verifier	wr_verifier;        /* response */
416 };
417 
418 struct nfsd4_exchange_id {
419 	nfs4_verifier	verifier;
420 	struct xdr_netobj clname;
421 	u32		flags;
422 	clientid_t	clientid;
423 	u32		seqid;
424 	u32		spa_how;
425 	u32             spo_must_enforce[3];
426 	u32             spo_must_allow[3];
427 	struct xdr_netobj nii_domain;
428 	struct xdr_netobj nii_name;
429 	struct timespec64 nii_time;
430 };
431 
432 struct nfsd4_sequence {
433 	struct nfs4_sessionid	sessionid;		/* request/response */
434 	u32			seqid;			/* request/response */
435 	u32			slotid;			/* request/response */
436 	u32			maxslots;		/* request/response */
437 	u32			cachethis;		/* request */
438 #if 0
439 	u32			target_maxslots;	/* response */
440 #endif /* not yet */
441 	u32			status_flags;		/* response */
442 };
443 
444 struct nfsd4_destroy_session {
445 	struct nfs4_sessionid	sessionid;
446 };
447 
448 struct nfsd4_destroy_clientid {
449 	clientid_t clientid;
450 };
451 
452 struct nfsd4_reclaim_complete {
453 	u32 rca_one_fs;
454 };
455 
456 struct nfsd4_deviceid {
457 	u64			fsid_idx;
458 	u32			generation;
459 	u32			pad;
460 };
461 
462 struct nfsd4_layout_seg {
463 	u32			iomode;
464 	u64			offset;
465 	u64			length;
466 };
467 
468 struct nfsd4_getdeviceinfo {
469 	struct nfsd4_deviceid	gd_devid;	/* request */
470 	u32			gd_layout_type;	/* request */
471 	u32			gd_maxcount;	/* request */
472 	u32			gd_notify_types;/* request - response */
473 	void			*gd_device;	/* response */
474 };
475 
476 struct nfsd4_layoutget {
477 	u64			lg_minlength;	/* request */
478 	u32			lg_signal;	/* request */
479 	u32			lg_layout_type;	/* request */
480 	u32			lg_maxcount;	/* request */
481 	stateid_t		lg_sid;		/* request/response */
482 	struct nfsd4_layout_seg	lg_seg;		/* request/response */
483 	void			*lg_content;	/* response */
484 };
485 
486 struct nfsd4_layoutcommit {
487 	stateid_t		lc_sid;		/* request */
488 	struct nfsd4_layout_seg	lc_seg;		/* request */
489 	u32			lc_reclaim;	/* request */
490 	u32			lc_newoffset;	/* request */
491 	u64			lc_last_wr;	/* request */
492 	struct timespec64	lc_mtime;	/* request */
493 	u32			lc_layout_type;	/* request */
494 	u32			lc_up_len;	/* layout length */
495 	void			*lc_up_layout;	/* decoded by callback */
496 	u32			lc_size_chg;	/* boolean for response */
497 	u64			lc_newsize;	/* response */
498 };
499 
500 struct nfsd4_layoutreturn {
501 	u32			lr_return_type;	/* request */
502 	u32			lr_layout_type;	/* request */
503 	struct nfsd4_layout_seg	lr_seg;		/* request */
504 	u32			lr_reclaim;	/* request */
505 	u32			lrf_body_len;	/* request */
506 	void			*lrf_body;	/* request */
507 	stateid_t		lr_sid;		/* request/response */
508 	u32			lrs_present;	/* response */
509 };
510 
511 struct nfsd4_fallocate {
512 	/* request */
513 	stateid_t	falloc_stateid;
514 	loff_t		falloc_offset;
515 	u64		falloc_length;
516 };
517 
518 struct nfsd4_clone {
519 	/* request */
520 	stateid_t	cl_src_stateid;
521 	stateid_t	cl_dst_stateid;
522 	u64		cl_src_pos;
523 	u64		cl_dst_pos;
524 	u64		cl_count;
525 };
526 
527 struct nfsd42_write_res {
528 	u64			wr_bytes_written;
529 	u32			wr_stable_how;
530 	nfs4_verifier		wr_verifier;
531 	stateid_t		cb_stateid;
532 };
533 
534 struct nfsd4_copy {
535 	/* request */
536 	stateid_t		cp_src_stateid;
537 	stateid_t		cp_dst_stateid;
538 	u64			cp_src_pos;
539 	u64			cp_dst_pos;
540 	u64			cp_count;
541 	struct nl4_server	cp_src;
542 	bool			cp_intra;
543 
544 	/* both */
545 	u32			cp_synchronous;
546 
547 	/* response */
548 	struct nfsd42_write_res	cp_res;
549 
550 	/* for cb_offload */
551 	struct nfsd4_callback	cp_cb;
552 	__be32			nfserr;
553 	struct knfsd_fh		fh;
554 
555 	struct nfs4_client      *cp_clp;
556 
557 	struct nfsd_file        *nf_src;
558 	struct nfsd_file        *nf_dst;
559 
560 	copy_stateid_t		cp_stateid;
561 
562 	struct list_head	copies;
563 	struct task_struct	*copy_task;
564 	refcount_t		refcount;
565 	bool			stopped;
566 
567 	struct vfsmount		*ss_mnt;
568 	struct nfs_fh		c_fh;
569 	nfs4_stateid		stateid;
570 };
571 extern bool inter_copy_offload_enable;
572 
573 struct nfsd4_seek {
574 	/* request */
575 	stateid_t	seek_stateid;
576 	loff_t		seek_offset;
577 	u32		seek_whence;
578 
579 	/* response */
580 	u32		seek_eof;
581 	loff_t		seek_pos;
582 };
583 
584 struct nfsd4_offload_status {
585 	/* request */
586 	stateid_t	stateid;
587 
588 	/* response */
589 	u64		count;
590 	u32		status;
591 };
592 
593 struct nfsd4_copy_notify {
594 	/* request */
595 	stateid_t		cpn_src_stateid;
596 	struct nl4_server	cpn_dst;
597 
598 	/* response */
599 	stateid_t		cpn_cnr_stateid;
600 	u64			cpn_sec;
601 	u32			cpn_nsec;
602 	struct nl4_server	cpn_src;
603 };
604 
605 struct nfsd4_op {
606 	u32					opnum;
607 	const struct nfsd4_operation *		opdesc;
608 	__be32					status;
609 	union nfsd4_op_u {
610 		struct nfsd4_access		access;
611 		struct nfsd4_close		close;
612 		struct nfsd4_commit		commit;
613 		struct nfsd4_create		create;
614 		struct nfsd4_delegreturn	delegreturn;
615 		struct nfsd4_getattr		getattr;
616 		struct svc_fh *			getfh;
617 		struct nfsd4_link		link;
618 		struct nfsd4_lock		lock;
619 		struct nfsd4_lockt		lockt;
620 		struct nfsd4_locku		locku;
621 		struct nfsd4_lookup		lookup;
622 		struct nfsd4_verify		nverify;
623 		struct nfsd4_open		open;
624 		struct nfsd4_open_confirm	open_confirm;
625 		struct nfsd4_open_downgrade	open_downgrade;
626 		struct nfsd4_putfh		putfh;
627 		struct nfsd4_read		read;
628 		struct nfsd4_readdir		readdir;
629 		struct nfsd4_readlink		readlink;
630 		struct nfsd4_remove		remove;
631 		struct nfsd4_rename		rename;
632 		clientid_t			renew;
633 		struct nfsd4_secinfo		secinfo;
634 		struct nfsd4_setattr		setattr;
635 		struct nfsd4_setclientid	setclientid;
636 		struct nfsd4_setclientid_confirm setclientid_confirm;
637 		struct nfsd4_verify		verify;
638 		struct nfsd4_write		write;
639 		struct nfsd4_release_lockowner	release_lockowner;
640 
641 		/* NFSv4.1 */
642 		struct nfsd4_exchange_id	exchange_id;
643 		struct nfsd4_backchannel_ctl	backchannel_ctl;
644 		struct nfsd4_bind_conn_to_session bind_conn_to_session;
645 		struct nfsd4_create_session	create_session;
646 		struct nfsd4_destroy_session	destroy_session;
647 		struct nfsd4_destroy_clientid	destroy_clientid;
648 		struct nfsd4_sequence		sequence;
649 		struct nfsd4_reclaim_complete	reclaim_complete;
650 		struct nfsd4_test_stateid	test_stateid;
651 		struct nfsd4_free_stateid	free_stateid;
652 		struct nfsd4_getdeviceinfo	getdeviceinfo;
653 		struct nfsd4_layoutget		layoutget;
654 		struct nfsd4_layoutcommit	layoutcommit;
655 		struct nfsd4_layoutreturn	layoutreturn;
656 		struct nfsd4_secinfo_no_name	secinfo_no_name;
657 
658 		/* NFSv4.2 */
659 		struct nfsd4_fallocate		allocate;
660 		struct nfsd4_fallocate		deallocate;
661 		struct nfsd4_clone		clone;
662 		struct nfsd4_copy		copy;
663 		struct nfsd4_offload_status	offload_status;
664 		struct nfsd4_copy_notify	copy_notify;
665 		struct nfsd4_seek		seek;
666 
667 		struct nfsd4_getxattr		getxattr;
668 		struct nfsd4_setxattr		setxattr;
669 		struct nfsd4_listxattrs		listxattrs;
670 		struct nfsd4_removexattr	removexattr;
671 	} u;
672 	struct nfs4_replay *			replay;
673 };
674 
675 bool nfsd4_cache_this_op(struct nfsd4_op *);
676 
677 /*
678  * Memory needed just for the duration of processing one compound:
679  */
680 struct svcxdr_tmpbuf {
681 	struct svcxdr_tmpbuf *next;
682 	char buf[];
683 };
684 
685 struct nfsd4_compoundargs {
686 	/* scratch variables for XDR decode */
687 	struct xdr_stream		*xdr;
688 	struct svcxdr_tmpbuf		*to_free;
689 	struct svc_rqst			*rqstp;
690 
691 	u32				taglen;
692 	char *				tag;
693 	u32				minorversion;
694 	u32				opcnt;
695 	struct nfsd4_op			*ops;
696 	struct nfsd4_op			iops[8];
697 	int				cachetype;
698 };
699 
700 struct nfsd4_compoundres {
701 	/* scratch variables for XDR encode */
702 	struct xdr_stream		xdr;
703 	struct svc_rqst *		rqstp;
704 
705 	u32				taglen;
706 	char *				tag;
707 	u32				opcnt;
708 	__be32 *			tagp; /* tag, opcount encode location */
709 	struct nfsd4_compound_state	cstate;
710 };
711 
712 static inline bool nfsd4_is_solo_sequence(struct nfsd4_compoundres *resp)
713 {
714 	struct nfsd4_compoundargs *args = resp->rqstp->rq_argp;
715 	return resp->opcnt == 1 && args->ops[0].opnum == OP_SEQUENCE;
716 }
717 
718 /*
719  * The session reply cache only needs to cache replies that the client
720  * actually asked us to.  But it's almost free for us to cache compounds
721  * consisting of only a SEQUENCE op, so we may as well cache those too.
722  * Also, the protocol doesn't give us a convenient response in the case
723  * of a replay of a solo SEQUENCE op that wasn't cached
724  * (RETRY_UNCACHED_REP can only be returned in the second op of a
725  * compound).
726  */
727 static inline bool nfsd4_cache_this(struct nfsd4_compoundres *resp)
728 {
729 	return (resp->cstate.slot->sl_flags & NFSD4_SLOT_CACHETHIS)
730 		|| nfsd4_is_solo_sequence(resp);
731 }
732 
733 static inline bool nfsd4_last_compound_op(struct svc_rqst *rqstp)
734 {
735 	struct nfsd4_compoundres *resp = rqstp->rq_resp;
736 	struct nfsd4_compoundargs *argp = rqstp->rq_argp;
737 
738 	return argp->opcnt == resp->opcnt;
739 }
740 
741 const struct nfsd4_operation *OPDESC(struct nfsd4_op *op);
742 int nfsd4_max_reply(struct svc_rqst *rqstp, struct nfsd4_op *op);
743 void warn_on_nonidempotent_op(struct nfsd4_op *op);
744 
745 #define NFS4_SVC_XDRSIZE		sizeof(struct nfsd4_compoundargs)
746 
747 static inline void
748 set_change_info(struct nfsd4_change_info *cinfo, struct svc_fh *fhp)
749 {
750 	BUG_ON(!fhp->fh_pre_saved);
751 	cinfo->atomic = (u32)(fhp->fh_post_saved && !fhp->fh_no_atomic_attr);
752 
753 	cinfo->before_change = fhp->fh_pre_change;
754 	cinfo->after_change = fhp->fh_post_change;
755 }
756 
757 
758 bool nfsd4_mach_creds_match(struct nfs4_client *cl, struct svc_rqst *rqstp);
759 int nfs4svc_decode_compoundargs(struct svc_rqst *, __be32 *);
760 int nfs4svc_encode_compoundres(struct svc_rqst *, __be32 *);
761 __be32 nfsd4_check_resp_size(struct nfsd4_compoundres *, u32);
762 void nfsd4_encode_operation(struct nfsd4_compoundres *, struct nfsd4_op *);
763 void nfsd4_encode_replay(struct xdr_stream *xdr, struct nfsd4_op *op);
764 __be32 nfsd4_encode_fattr_to_buf(__be32 **p, int words,
765 		struct svc_fh *fhp, struct svc_export *exp,
766 		struct dentry *dentry,
767 		u32 *bmval, struct svc_rqst *, int ignore_crossmnt);
768 extern __be32 nfsd4_setclientid(struct svc_rqst *rqstp,
769 		struct nfsd4_compound_state *, union nfsd4_op_u *u);
770 extern __be32 nfsd4_setclientid_confirm(struct svc_rqst *rqstp,
771 		struct nfsd4_compound_state *, union nfsd4_op_u *u);
772 extern __be32 nfsd4_exchange_id(struct svc_rqst *rqstp,
773 		struct nfsd4_compound_state *, union nfsd4_op_u *u);
774 extern __be32 nfsd4_backchannel_ctl(struct svc_rqst *,
775 		struct nfsd4_compound_state *, union nfsd4_op_u *u);
776 extern __be32 nfsd4_bind_conn_to_session(struct svc_rqst *,
777 		struct nfsd4_compound_state *, union nfsd4_op_u *u);
778 extern __be32 nfsd4_create_session(struct svc_rqst *,
779 		struct nfsd4_compound_state *, union nfsd4_op_u *u);
780 extern __be32 nfsd4_sequence(struct svc_rqst *,
781 		struct nfsd4_compound_state *, union nfsd4_op_u *u);
782 extern void nfsd4_sequence_done(struct nfsd4_compoundres *resp);
783 extern __be32 nfsd4_destroy_session(struct svc_rqst *,
784 		struct nfsd4_compound_state *, union nfsd4_op_u *u);
785 extern __be32 nfsd4_destroy_clientid(struct svc_rqst *, struct nfsd4_compound_state *,
786 		union nfsd4_op_u *u);
787 __be32 nfsd4_reclaim_complete(struct svc_rqst *, struct nfsd4_compound_state *,
788 		union nfsd4_op_u *u);
789 extern __be32 nfsd4_process_open1(struct nfsd4_compound_state *,
790 		struct nfsd4_open *open, struct nfsd_net *nn);
791 extern __be32 nfsd4_process_open2(struct svc_rqst *rqstp,
792 		struct svc_fh *current_fh, struct nfsd4_open *open);
793 extern void nfsd4_cstate_clear_replay(struct nfsd4_compound_state *cstate);
794 extern void nfsd4_cleanup_open_state(struct nfsd4_compound_state *cstate,
795 		struct nfsd4_open *open);
796 extern __be32 nfsd4_open_confirm(struct svc_rqst *rqstp,
797 		struct nfsd4_compound_state *, union nfsd4_op_u *u);
798 extern __be32 nfsd4_close(struct svc_rqst *rqstp, struct nfsd4_compound_state *,
799 		union nfsd4_op_u *u);
800 extern __be32 nfsd4_open_downgrade(struct svc_rqst *rqstp,
801 		struct nfsd4_compound_state *, union nfsd4_op_u *u);
802 extern __be32 nfsd4_lock(struct svc_rqst *rqstp, struct nfsd4_compound_state *,
803 		union nfsd4_op_u *u);
804 extern __be32 nfsd4_lockt(struct svc_rqst *rqstp, struct nfsd4_compound_state *,
805 		union nfsd4_op_u *u);
806 extern __be32 nfsd4_locku(struct svc_rqst *rqstp, struct nfsd4_compound_state *,
807 		union nfsd4_op_u *u);
808 extern __be32
809 nfsd4_release_lockowner(struct svc_rqst *rqstp,
810 		struct nfsd4_compound_state *, union nfsd4_op_u *u);
811 extern void nfsd4_release_compoundargs(struct svc_rqst *rqstp);
812 extern __be32 nfsd4_delegreturn(struct svc_rqst *rqstp,
813 		struct nfsd4_compound_state *, union nfsd4_op_u *u);
814 extern __be32 nfsd4_renew(struct svc_rqst *rqstp, struct nfsd4_compound_state *,
815 		union nfsd4_op_u *u);
816 extern __be32 nfsd4_test_stateid(struct svc_rqst *rqstp,
817 		struct nfsd4_compound_state *, union nfsd4_op_u *);
818 extern __be32 nfsd4_free_stateid(struct svc_rqst *rqstp,
819 		struct nfsd4_compound_state *, union nfsd4_op_u *);
820 extern void nfsd4_bump_seqid(struct nfsd4_compound_state *, __be32 nfserr);
821 
822 enum nfsd4_op_flags {
823 	ALLOWED_WITHOUT_FH = 1 << 0,    /* No current filehandle required */
824 	ALLOWED_ON_ABSENT_FS = 1 << 1,  /* ops processed on absent fs */
825 	ALLOWED_AS_FIRST_OP = 1 << 2,   /* ops reqired first in compound */
826 	/* For rfc 5661 section 2.6.3.1.1: */
827 	OP_HANDLES_WRONGSEC = 1 << 3,
828 	OP_IS_PUTFH_LIKE = 1 << 4,
829 	/*
830 	 * These are the ops whose result size we estimate before
831 	 * encoding, to avoid performing an op then not being able to
832 	 * respond or cache a response.  This includes writes and setattrs
833 	 * as well as the operations usually called "nonidempotent":
834 	 */
835 	OP_MODIFIES_SOMETHING = 1 << 5,
836 	/*
837 	 * Cache compounds containing these ops in the xid-based drc:
838 	 * We use the DRC for compounds containing non-idempotent
839 	 * operations, *except* those that are 4.1-specific (since
840 	 * sessions provide their own EOS), and except for stateful
841 	 * operations other than setclientid and setclientid_confirm
842 	 * (since sequence numbers provide EOS for open, lock, etc in
843 	 * the v4.0 case).
844 	 */
845 	OP_CACHEME = 1 << 6,
846 	/*
847 	 * These are ops which clear current state id.
848 	 */
849 	OP_CLEAR_STATEID = 1 << 7,
850 	/* Most ops return only an error on failure; some may do more: */
851 	OP_NONTRIVIAL_ERROR_ENCODE = 1 << 8,
852 };
853 
854 struct nfsd4_operation {
855 	__be32 (*op_func)(struct svc_rqst *, struct nfsd4_compound_state *,
856 			union nfsd4_op_u *);
857 	void (*op_release)(union nfsd4_op_u *);
858 	u32 op_flags;
859 	char *op_name;
860 	/* Try to get response size before operation */
861 	u32 (*op_rsize_bop)(struct svc_rqst *, struct nfsd4_op *);
862 	void (*op_get_currentstateid)(struct nfsd4_compound_state *,
863 			union nfsd4_op_u *);
864 	void (*op_set_currentstateid)(struct nfsd4_compound_state *,
865 			union nfsd4_op_u *);
866 };
867 
868 
869 #endif
870 
871 /*
872  * Local variables:
873  *  c-basic-offset: 8
874  * End:
875  */
876