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