2  *  Server-side XDR for NFSv4
109 	return (clid->cl_boot == 0) && (clid->cl_id == 0);  in zero_clientid()
113  * svcxdr_tmpalloc - allocate memory to be freed after compound processing
128 	tb->next = argp->to_free;  in svcxdr_tmpalloc()
129 	argp->to_free = tb;  in svcxdr_tmpalloc()
130 	return tb->buf;  in svcxdr_tmpalloc()
135  * as null-terminated strings.
137  * Note null-terminating in place usually isn't safe since the
161 	if (p != argp->xdr->scratch.iov_base)  in svcxdr_savemem()
176  * This helper handles variable-length opaques which belong to protocol
184 	if (xdr_stream_decode_u32(argp->xdr, &len) < 0)  in nfsd4_decode_ignored_string()
188 	if (!xdr_inline_decode(argp->xdr, len))  in nfsd4_decode_ignored_string()
200 	if (xdr_stream_decode_u32(argp->xdr, &len) < 0)  in nfsd4_decode_opaque()
204 	p = xdr_inline_decode(argp->xdr, len);  in nfsd4_decode_opaque()
207 	o->data = svcxdr_savemem(argp, p, len);  in nfsd4_decode_opaque()
208 	if (!o->data)  in nfsd4_decode_opaque()
210 	o->len = len;  in nfsd4_decode_opaque()
220 	if (xdr_stream_decode_u32(argp->xdr, lenp) < 0)  in nfsd4_decode_component4()
222 	p = xdr_inline_decode(argp->xdr, *lenp);  in nfsd4_decode_component4()
240 	p = xdr_inline_decode(argp->xdr, XDR_UNIT * 3);  in nfsd4_decode_nfstime4()
243 	p = xdr_decode_hyper(p, &tv->tv_sec);  in nfsd4_decode_nfstime4()
244 	tv->tv_nsec = be32_to_cpup(p++);  in nfsd4_decode_nfstime4()
245 	if (tv->tv_nsec >= (u32)1000000000)  in nfsd4_decode_nfstime4()
255 	p = xdr_inline_decode(argp->xdr, NFS4_VERIFIER_SIZE);  in nfsd4_decode_verifier4()
258 	memcpy(verf->data, p, sizeof(verf->data));  in nfsd4_decode_verifier4()
263  * nfsd4_decode_bitmap4 - Decode an NFSv4 bitmap4
284 	status = xdr_stream_decode_uint32_array(argp->xdr, bmval, bmlen);  in nfsd4_decode_bitmap4()
285 	return status == -EBADMSG ? nfserr_bad_xdr : nfs_ok;  in nfsd4_decode_bitmap4()
294 	if (xdr_stream_decode_u32(argp->xdr, &ace->type) < 0)  in nfsd4_decode_nfsace4()
296 	if (xdr_stream_decode_u32(argp->xdr, &ace->flag) < 0)  in nfsd4_decode_nfsace4()
298 	if (xdr_stream_decode_u32(argp->xdr, &ace->access_mask) < 0)  in nfsd4_decode_nfsace4()
301 	if (xdr_stream_decode_u32(argp->xdr, &length) < 0)  in nfsd4_decode_nfsace4()
303 	p = xdr_inline_decode(argp->xdr, length);  in nfsd4_decode_nfsace4()
306 	ace->whotype = nfs4_acl_get_whotype((char *)p, length);  in nfsd4_decode_nfsace4()
307 	if (ace->whotype != NFS4_ACL_WHO_NAMED)  in nfsd4_decode_nfsace4()
309 	else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)  in nfsd4_decode_nfsace4()
310 		status = nfsd_map_name_to_gid(argp->rqstp,  in nfsd4_decode_nfsace4()
311 				(char *)p, length, &ace->who_gid);  in nfsd4_decode_nfsace4()
313 		status = nfsd_map_name_to_uid(argp->rqstp,  in nfsd4_decode_nfsace4()
314 				(char *)p, length, &ace->who_uid);  in nfsd4_decode_nfsace4()
327 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)  in nfsd4_decode_acl()
330 	if (count > xdr_stream_remaining(argp->xdr) / 20)  in nfsd4_decode_acl()
332 		 * Even with 4-byte names there wouldn't be  in nfsd4_decode_acl()
333 		 * space for that many aces; something fishy is  in nfsd4_decode_acl()
342 	(*acl)->naces = count;  in nfsd4_decode_acl()
343 	for (ace = (*acl)->aces; ace < (*acl)->aces + count; ace++) {  in nfsd4_decode_acl()
359 	if (xdr_stream_decode_u32(argp->xdr, &lfs) < 0)  in nfsd4_decode_security_label()
361 	if (xdr_stream_decode_u32(argp->xdr, &pi) < 0)  in nfsd4_decode_security_label()
364 	if (xdr_stream_decode_u32(argp->xdr, &length) < 0)  in nfsd4_decode_security_label()
368 	p = xdr_inline_decode(argp->xdr, length);  in nfsd4_decode_security_label()
371 	label->len = length;  in nfsd4_decode_security_label()
372 	label->data = svcxdr_dupstr(argp, p, length);  in nfsd4_decode_security_label()
373 	if (!label->data)  in nfsd4_decode_security_label()
388 	iattr->ia_valid = 0;  in nfsd4_decode_fattr4()
396 		if (nfsd_attrs_supported(argp->minorversion, bmval))  in nfsd4_decode_fattr4()
401 	if (xdr_stream_decode_u32(argp->xdr, &attrlist4_count) < 0)  in nfsd4_decode_fattr4()
403 	starting_pos = xdr_stream_pos(argp->xdr);  in nfsd4_decode_fattr4()
408 		if (xdr_stream_decode_u64(argp->xdr, &size) < 0)  in nfsd4_decode_fattr4()
410 		iattr->ia_size = size;  in nfsd4_decode_fattr4()
411 		iattr->ia_valid |= ATTR_SIZE;  in nfsd4_decode_fattr4()
422 		if (xdr_stream_decode_u32(argp->xdr, &mode) < 0)  in nfsd4_decode_fattr4()
424 		iattr->ia_mode = mode;  in nfsd4_decode_fattr4()
425 		iattr->ia_mode &= (S_IFMT | S_IALLUGO);  in nfsd4_decode_fattr4()
426 		iattr->ia_valid |= ATTR_MODE;  in nfsd4_decode_fattr4()
431 		if (xdr_stream_decode_u32(argp->xdr, &length) < 0)  in nfsd4_decode_fattr4()
433 		p = xdr_inline_decode(argp->xdr, length);  in nfsd4_decode_fattr4()
436 		status = nfsd_map_name_to_uid(argp->rqstp, (char *)p, length,  in nfsd4_decode_fattr4()
437 					      &iattr->ia_uid);  in nfsd4_decode_fattr4()
440 		iattr->ia_valid |= ATTR_UID;  in nfsd4_decode_fattr4()
445 		if (xdr_stream_decode_u32(argp->xdr, &length) < 0)  in nfsd4_decode_fattr4()
447 		p = xdr_inline_decode(argp->xdr, length);  in nfsd4_decode_fattr4()
450 		status = nfsd_map_name_to_gid(argp->rqstp, (char *)p, length,  in nfsd4_decode_fattr4()
451 					      &iattr->ia_gid);  in nfsd4_decode_fattr4()
454 		iattr->ia_valid |= ATTR_GID;  in nfsd4_decode_fattr4()
459 		if (xdr_stream_decode_u32(argp->xdr, &set_it) < 0)  in nfsd4_decode_fattr4()
463 			status = nfsd4_decode_nfstime4(argp, &iattr->ia_atime);  in nfsd4_decode_fattr4()
466 			iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET);  in nfsd4_decode_fattr4()
469 			iattr->ia_valid |= ATTR_ATIME;  in nfsd4_decode_fattr4()
487 		if (xdr_stream_decode_u32(argp->xdr, &set_it) < 0)  in nfsd4_decode_fattr4()
491 			status = nfsd4_decode_nfstime4(argp, &iattr->ia_mtime);  in nfsd4_decode_fattr4()
494 			iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET);  in nfsd4_decode_fattr4()
497 			iattr->ia_valid |= ATTR_MTIME;  in nfsd4_decode_fattr4()
503 	label->len = 0;  in nfsd4_decode_fattr4()
515 		if (xdr_stream_decode_u32(argp->xdr, &mode) < 0)  in nfsd4_decode_fattr4()
517 		iattr->ia_mode = mode & (S_IFMT | S_IALLUGO);  in nfsd4_decode_fattr4()
518 		if (xdr_stream_decode_u32(argp->xdr, &mask) < 0)  in nfsd4_decode_fattr4()
521 		iattr->ia_valid |= ATTR_MODE;  in nfsd4_decode_fattr4()
525 	if (attrlist4_count != xdr_stream_pos(argp->xdr) - starting_pos)  in nfsd4_decode_fattr4()
536 	p = xdr_inline_decode(argp->xdr, NFS4_STATEID_SIZE);  in nfsd4_decode_stateid4()
539 	sid->si_generation = be32_to_cpup(p++);  in nfsd4_decode_stateid4()
540 	memcpy(&sid->si_opaque, p, sizeof(sid->si_opaque));  in nfsd4_decode_stateid4()
549 	p = xdr_inline_decode(argp->xdr, sizeof(__be64));  in nfsd4_decode_clientid4()
575 	p = xdr_inline_decode(argp->xdr, NFS4_DEVICEID4_SIZE);  in nfsd4_decode_deviceid4()
586 	if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_layout_type) < 0)  in nfsd4_decode_layoutupdate4()
588 	if (lcp->lc_layout_type < LAYOUT_NFSV4_1_FILES)  in nfsd4_decode_layoutupdate4()
590 	if (lcp->lc_layout_type >= LAYOUT_TYPE_MAX)  in nfsd4_decode_layoutupdate4()
593 	if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_up_len) < 0)  in nfsd4_decode_layoutupdate4()
595 	if (lcp->lc_up_len > 0) {  in nfsd4_decode_layoutupdate4()
596 		lcp->lc_up_layout = xdr_inline_decode(argp->xdr, lcp->lc_up_len);  in nfsd4_decode_layoutupdate4()
597 		if (!lcp->lc_up_layout)  in nfsd4_decode_layoutupdate4()
610 	if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_return_type) < 0)  in nfsd4_decode_layoutreturn4()
612 	switch (lrp->lr_return_type) {  in nfsd4_decode_layoutreturn4()
614 		if (xdr_stream_decode_u64(argp->xdr, &lrp->lr_seg.offset) < 0)  in nfsd4_decode_layoutreturn4()
616 		if (xdr_stream_decode_u64(argp->xdr, &lrp->lr_seg.length) < 0)  in nfsd4_decode_layoutreturn4()
618 		status = nfsd4_decode_stateid4(argp, &lrp->lr_sid);  in nfsd4_decode_layoutreturn4()
621 		if (xdr_stream_decode_u32(argp->xdr, &lrp->lrf_body_len) < 0)  in nfsd4_decode_layoutreturn4()
623 		if (lrp->lrf_body_len > 0) {  in nfsd4_decode_layoutreturn4()
624 			lrp->lrf_body = xdr_inline_decode(argp->xdr, lrp->lrf_body_len);  in nfsd4_decode_layoutreturn4()
625 			if (!lrp->lrf_body)  in nfsd4_decode_layoutreturn4()
631 		lrp->lr_seg.offset = 0;  in nfsd4_decode_layoutreturn4()
632 		lrp->lr_seg.length = NFS4_MAX_UINT64;  in nfsd4_decode_layoutreturn4()
649 	p = xdr_inline_decode(argp->xdr, NFS4_MAX_SESSIONID_LEN);  in nfsd4_decode_sessionid4()
652 	memcpy(sessionid->data, p, sizeof(sessionid->data));  in nfsd4_decode_sessionid4()
664 	if (xdr_stream_decode_u32(argp->xdr, &stamp) < 0)  in nfsd4_decode_authsys_parms()
670 	if (xdr_stream_decode_u32(argp->xdr, &uid) < 0)  in nfsd4_decode_authsys_parms()
672 	if (xdr_stream_decode_u32(argp->xdr, &gid) < 0)  in nfsd4_decode_authsys_parms()
674 	if (xdr_stream_decode_u32(argp->xdr, &gidcount) < 0)  in nfsd4_decode_authsys_parms()
678 	p = xdr_inline_decode(argp->xdr, gidcount << 2);  in nfsd4_decode_authsys_parms()
681 	if (cbs->flavor == (u32)(-1)) {  in nfsd4_decode_authsys_parms()
682 		struct user_namespace *userns = nfsd_user_namespace(argp->rqstp);  in nfsd4_decode_authsys_parms()
687 			cbs->uid = kuid;  in nfsd4_decode_authsys_parms()
688 			cbs->gid = kgid;  in nfsd4_decode_authsys_parms()
689 			cbs->flavor = RPC_AUTH_UNIX;  in nfsd4_decode_authsys_parms()
707 	if (xdr_stream_decode_u32(argp->xdr, &service) < 0)  in nfsd4_decode_gss_cb_handles4()
731 	if (xdr_stream_decode_u32(argp->xdr, &nr_secflavs) < 0)  in nfsd4_decode_cb_sec()
734 		cbs->flavor = (u32)(-1);  in nfsd4_decode_cb_sec()
737 		cbs->flavor = 0;  in nfsd4_decode_cb_sec()
740 		if (xdr_stream_decode_u32(argp->xdr, &secflavor) < 0)  in nfsd4_decode_cb_sec()
745 			if (cbs->flavor == (u32)(-1))  in nfsd4_decode_cb_sec()
746 				cbs->flavor = RPC_AUTH_NULL;  in nfsd4_decode_cb_sec()
775 	struct nfsd4_access *access = &u->access;  in nfsd4_decode_access()
776 	if (xdr_stream_decode_u32(argp->xdr, &access->ac_req_access) < 0)  in nfsd4_decode_access()
784 	struct nfsd4_close *close = &u->close;  in nfsd4_decode_close()
785 	if (xdr_stream_decode_u32(argp->xdr, &close->cl_seqid) < 0)  in nfsd4_decode_close()
787 	return nfsd4_decode_stateid4(argp, &close->cl_stateid);  in nfsd4_decode_close()
794 	struct nfsd4_commit *commit = &u->commit;  in nfsd4_decode_commit()
795 	if (xdr_stream_decode_u64(argp->xdr, &commit->co_offset) < 0)  in nfsd4_decode_commit()
797 	if (xdr_stream_decode_u32(argp->xdr, &commit->co_count) < 0)  in nfsd4_decode_commit()
799 	memset(&commit->co_verf, 0, sizeof(commit->co_verf));  in nfsd4_decode_commit()
806 	struct nfsd4_create *create = &u->create;  in nfsd4_decode_create()
810 	if (xdr_stream_decode_u32(argp->xdr, &create->cr_type) < 0)  in nfsd4_decode_create()
812 	switch (create->cr_type) {  in nfsd4_decode_create()
814 		if (xdr_stream_decode_u32(argp->xdr, &create->cr_datalen) < 0)  in nfsd4_decode_create()
816 		p = xdr_inline_decode(argp->xdr, create->cr_datalen);  in nfsd4_decode_create()
819 		create->cr_data = svcxdr_dupstr(argp, p, create->cr_datalen);  in nfsd4_decode_create()
820 		if (!create->cr_data)  in nfsd4_decode_create()
825 		if (xdr_stream_decode_u32(argp->xdr, &create->cr_specdata1) < 0)  in nfsd4_decode_create()
827 		if (xdr_stream_decode_u32(argp->xdr, &create->cr_specdata2) < 0)  in nfsd4_decode_create()
836 	status = nfsd4_decode_component4(argp, &create->cr_name,  in nfsd4_decode_create()
837 					 &create->cr_namelen);  in nfsd4_decode_create()
840 	status = nfsd4_decode_fattr4(argp, create->cr_bmval,  in nfsd4_decode_create()
841 				    ARRAY_SIZE(create->cr_bmval),  in nfsd4_decode_create()
842 				    &create->cr_iattr, &create->cr_acl,  in nfsd4_decode_create()
843 				    &create->cr_label, &create->cr_umask);  in nfsd4_decode_create()
853 	struct nfsd4_delegreturn *dr = &u->delegreturn;  in nfsd4_decode_delegreturn()
854 	return nfsd4_decode_stateid4(argp, &dr->dr_stateid);  in nfsd4_decode_delegreturn()
860 	struct nfsd4_getattr *getattr = &u->getattr;  in nfsd4_decode_getattr()
862 	return nfsd4_decode_bitmap4(argp, getattr->ga_bmval,  in nfsd4_decode_getattr()
863 				    ARRAY_SIZE(getattr->ga_bmval));  in nfsd4_decode_getattr()
869 	struct nfsd4_link *link = &u->link;  in nfsd4_decode_link()
871 	return nfsd4_decode_component4(argp, &link->li_name, &link->li_namelen);  in nfsd4_decode_link()
880 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_new_open_seqid) < 0)  in nfsd4_decode_open_to_lock_owner4()
882 	status = nfsd4_decode_stateid4(argp, &lock->lk_new_open_stateid);  in nfsd4_decode_open_to_lock_owner4()
885 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_new_lock_seqid) < 0)  in nfsd4_decode_open_to_lock_owner4()
887 	return nfsd4_decode_state_owner4(argp, &lock->lk_new_clientid,  in nfsd4_decode_open_to_lock_owner4()
888 					 &lock->lk_new_owner);  in nfsd4_decode_open_to_lock_owner4()
897 	status = nfsd4_decode_stateid4(argp, &lock->lk_old_lock_stateid);  in nfsd4_decode_exist_lock_owner4()
900 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_old_lock_seqid) < 0)  in nfsd4_decode_exist_lock_owner4()
909 	if (xdr_stream_decode_bool(argp->xdr, &lock->lk_is_new) < 0)  in nfsd4_decode_locker4()
911 	if (lock->lk_is_new)  in nfsd4_decode_locker4()
919 	struct nfsd4_lock *lock = &u->lock;  in nfsd4_decode_lock()
921 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_type) < 0)  in nfsd4_decode_lock()
923 	if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT))  in nfsd4_decode_lock()
925 	if (xdr_stream_decode_bool(argp->xdr, &lock->lk_reclaim) < 0)  in nfsd4_decode_lock()
927 	if (xdr_stream_decode_u64(argp->xdr, &lock->lk_offset) < 0)  in nfsd4_decode_lock()
929 	if (xdr_stream_decode_u64(argp->xdr, &lock->lk_length) < 0)  in nfsd4_decode_lock()
937 	struct nfsd4_lockt *lockt = &u->lockt;  in nfsd4_decode_lockt()
939 	if (xdr_stream_decode_u32(argp->xdr, &lockt->lt_type) < 0)  in nfsd4_decode_lockt()
941 	if ((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT))  in nfsd4_decode_lockt()
943 	if (xdr_stream_decode_u64(argp->xdr, &lockt->lt_offset) < 0)  in nfsd4_decode_lockt()
945 	if (xdr_stream_decode_u64(argp->xdr, &lockt->lt_length) < 0)  in nfsd4_decode_lockt()
947 	return nfsd4_decode_state_owner4(argp, &lockt->lt_clientid,  in nfsd4_decode_lockt()
948 					 &lockt->lt_owner);  in nfsd4_decode_lockt()
954 	struct nfsd4_locku *locku = &u->locku;  in nfsd4_decode_locku()
957 	if (xdr_stream_decode_u32(argp->xdr, &locku->lu_type) < 0)  in nfsd4_decode_locku()
959 	if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT))  in nfsd4_decode_locku()
961 	if (xdr_stream_decode_u32(argp->xdr, &locku->lu_seqid) < 0)  in nfsd4_decode_locku()
963 	status = nfsd4_decode_stateid4(argp, &locku->lu_stateid);  in nfsd4_decode_locku()
966 	if (xdr_stream_decode_u64(argp->xdr, &locku->lu_offset) < 0)  in nfsd4_decode_locku()
968 	if (xdr_stream_decode_u64(argp->xdr, &locku->lu_length) < 0)  in nfsd4_decode_locku()
977 	struct nfsd4_lookup *lookup = &u->lookup;  in nfsd4_decode_lookup()
978 	return nfsd4_decode_component4(argp, &lookup->lo_name, &lookup->lo_len);  in nfsd4_decode_lookup()
986 	if (xdr_stream_decode_u32(argp->xdr, &open->op_createmode) < 0)  in nfsd4_decode_createhow4()
988 	switch (open->op_createmode) {  in nfsd4_decode_createhow4()
991 		status = nfsd4_decode_fattr4(argp, open->op_bmval,  in nfsd4_decode_createhow4()
992 					     ARRAY_SIZE(open->op_bmval),  in nfsd4_decode_createhow4()
993 					     &open->op_iattr, &open->op_acl,  in nfsd4_decode_createhow4()
994 					     &open->op_label, &open->op_umask);  in nfsd4_decode_createhow4()
999 		status = nfsd4_decode_verifier4(argp, &open->op_verf);  in nfsd4_decode_createhow4()
1004 		if (argp->minorversion < 1)  in nfsd4_decode_createhow4()
1006 		status = nfsd4_decode_verifier4(argp, &open->op_verf);  in nfsd4_decode_createhow4()
1009 		status = nfsd4_decode_fattr4(argp, open->op_bmval,  in nfsd4_decode_createhow4()
1010 					     ARRAY_SIZE(open->op_bmval),  in nfsd4_decode_createhow4()
1011 					     &open->op_iattr, &open->op_acl,  in nfsd4_decode_createhow4()
1012 					     &open->op_label, &open->op_umask);  in nfsd4_decode_createhow4()
1028 	if (xdr_stream_decode_u32(argp->xdr, &open->op_create) < 0)  in nfsd4_decode_openflag4()
1030 	switch (open->op_create) {  in nfsd4_decode_openflag4()
1049 	if (xdr_stream_decode_u32(argp->xdr, &w) < 0)  in nfsd4_decode_share_access()
1067 	if (!argp->minorversion)  in nfsd4_decode_share_access()
1098 	if (xdr_stream_decode_u32(argp->xdr, x) < 0)  in nfsd4_decode_share_deny()
1113 	if (xdr_stream_decode_u32(argp->xdr, &open->op_claim_type) < 0)  in nfsd4_decode_open_claim4()
1115 	switch (open->op_claim_type) {  in nfsd4_decode_open_claim4()
1118 		status = nfsd4_decode_component4(argp, &open->op_fname,  in nfsd4_decode_open_claim4()
1119 						 &open->op_fnamelen);  in nfsd4_decode_open_claim4()
1124 		if (xdr_stream_decode_u32(argp->xdr, &open->op_delegate_type) < 0)  in nfsd4_decode_open_claim4()
1128 		status = nfsd4_decode_stateid4(argp, &open->op_delegate_stateid);  in nfsd4_decode_open_claim4()
1131 		status = nfsd4_decode_component4(argp, &open->op_fname,  in nfsd4_decode_open_claim4()
1132 						 &open->op_fnamelen);  in nfsd4_decode_open_claim4()
1138 		if (argp->minorversion < 1)  in nfsd4_decode_open_claim4()
1143 		if (argp->minorversion < 1)  in nfsd4_decode_open_claim4()
1145 		status = nfsd4_decode_stateid4(argp, &open->op_delegate_stateid);  in nfsd4_decode_open_claim4()
1159 	struct nfsd4_open *open = &u->open;  in nfsd4_decode_open()
1165 	if (xdr_stream_decode_u32(argp->xdr, &open->op_seqid) < 0)  in nfsd4_decode_open()
1168 	status = nfsd4_decode_share_access(argp, &open->op_share_access,  in nfsd4_decode_open()
1169 					   &open->op_deleg_want, &dummy);  in nfsd4_decode_open()
1172 	status = nfsd4_decode_share_deny(argp, &open->op_share_deny);  in nfsd4_decode_open()
1175 	status = nfsd4_decode_state_owner4(argp, &open->op_clientid,  in nfsd4_decode_open()
1176 					   &open->op_owner);  in nfsd4_decode_open()
1189 	struct nfsd4_open_confirm *open_conf = &u->open_confirm;  in nfsd4_decode_open_confirm()
1192 	if (argp->minorversion >= 1)  in nfsd4_decode_open_confirm()
1195 	status = nfsd4_decode_stateid4(argp, &open_conf->oc_req_stateid);  in nfsd4_decode_open_confirm()
1198 	if (xdr_stream_decode_u32(argp->xdr, &open_conf->oc_seqid) < 0)  in nfsd4_decode_open_confirm()
1201 	memset(&open_conf->oc_resp_stateid, 0,  in nfsd4_decode_open_confirm()
1202 	       sizeof(open_conf->oc_resp_stateid));  in nfsd4_decode_open_confirm()
1210 	struct nfsd4_open_downgrade *open_down = &u->open_downgrade;  in nfsd4_decode_open_downgrade()
1214 	status = nfsd4_decode_stateid4(argp, &open_down->od_stateid);  in nfsd4_decode_open_downgrade()
1217 	if (xdr_stream_decode_u32(argp->xdr, &open_down->od_seqid) < 0)  in nfsd4_decode_open_downgrade()
1220 	status = nfsd4_decode_share_access(argp, &open_down->od_share_access,  in nfsd4_decode_open_downgrade()
1221 					   &open_down->od_deleg_want, NULL);  in nfsd4_decode_open_downgrade()
1224 	return nfsd4_decode_share_deny(argp, &open_down->od_share_deny);  in nfsd4_decode_open_downgrade()
1230 	struct nfsd4_putfh *putfh = &u->putfh;  in nfsd4_decode_putfh()
1233 	if (xdr_stream_decode_u32(argp->xdr, &putfh->pf_fhlen) < 0)  in nfsd4_decode_putfh()
1235 	if (putfh->pf_fhlen > NFS4_FHSIZE)  in nfsd4_decode_putfh()
1237 	p = xdr_inline_decode(argp->xdr, putfh->pf_fhlen);  in nfsd4_decode_putfh()
1240 	putfh->pf_fhval = svcxdr_savemem(argp, p, putfh->pf_fhlen);  in nfsd4_decode_putfh()
1241 	if (!putfh->pf_fhval)  in nfsd4_decode_putfh()
1244 	putfh->no_verify = false;  in nfsd4_decode_putfh()
1251 	struct nfsd4_read *read = &u->read;  in nfsd4_decode_read()
1255 	status = nfsd4_decode_stateid4(argp, &read->rd_stateid);  in nfsd4_decode_read()
1258 	if (xdr_stream_decode_u64(argp->xdr, &read->rd_offset) < 0)  in nfsd4_decode_read()
1260 	if (xdr_stream_decode_u32(argp->xdr, &read->rd_length) < 0)  in nfsd4_decode_read()
1269 	struct nfsd4_readdir *readdir = &u->readdir;  in nfsd4_decode_readdir()
1273 	if (xdr_stream_decode_u64(argp->xdr, &readdir->rd_cookie) < 0)  in nfsd4_decode_readdir()
1275 	status = nfsd4_decode_verifier4(argp, &readdir->rd_verf);  in nfsd4_decode_readdir()
1278 	if (xdr_stream_decode_u32(argp->xdr, &readdir->rd_dircount) < 0)  in nfsd4_decode_readdir()
1280 	if (xdr_stream_decode_u32(argp->xdr, &readdir->rd_maxcount) < 0)  in nfsd4_decode_readdir()
1282 	if (xdr_stream_decode_uint32_array(argp->xdr, readdir->rd_bmval,  in nfsd4_decode_readdir()
1283 					   ARRAY_SIZE(readdir->rd_bmval)) < 0)  in nfsd4_decode_readdir()
1292 	struct nfsd4_remove *remove = &u->remove;  in nfsd4_decode_remove()
1293 	memset(&remove->rm_cinfo, 0, sizeof(remove->rm_cinfo));  in nfsd4_decode_remove()
1294 	return nfsd4_decode_component4(argp, &remove->rm_name, &remove->rm_namelen);  in nfsd4_decode_remove()
1300 	struct nfsd4_rename *rename = &u->rename;  in nfsd4_decode_rename()
1304 	status = nfsd4_decode_component4(argp, &rename->rn_sname, &rename->rn_snamelen);  in nfsd4_decode_rename()
1307 	return nfsd4_decode_component4(argp, &rename->rn_tname, &rename->rn_tnamelen);  in nfsd4_decode_rename()
1313 	clientid_t *clientid = &u->renew;  in nfsd4_decode_renew()
1321 	struct nfsd4_secinfo *secinfo = &u->secinfo;  in nfsd4_decode_secinfo()
1322 	secinfo->si_exp = NULL;  in nfsd4_decode_secinfo()
1323 	return nfsd4_decode_component4(argp, &secinfo->si_name, &secinfo->si_namelen);  in nfsd4_decode_secinfo()
1329 	struct nfsd4_setattr *setattr = &u->setattr;  in nfsd4_decode_setattr()
1333 	status = nfsd4_decode_stateid4(argp, &setattr->sa_stateid);  in nfsd4_decode_setattr()
1336 	return nfsd4_decode_fattr4(argp, setattr->sa_bmval,  in nfsd4_decode_setattr()
1337 				   ARRAY_SIZE(setattr->sa_bmval),  in nfsd4_decode_setattr()
1338 				   &setattr->sa_iattr, &setattr->sa_acl,  in nfsd4_decode_setattr()
1339 				   &setattr->sa_label, NULL);  in nfsd4_decode_setattr()
1345 	struct nfsd4_setclientid *setclientid = &u->setclientid;  in nfsd4_decode_setclientid()
1350 	if (argp->minorversion >= 1)  in nfsd4_decode_setclientid()
1353 	status = nfsd4_decode_verifier4(argp, &setclientid->se_verf);  in nfsd4_decode_setclientid()
1356 	status = nfsd4_decode_opaque(argp, &setclientid->se_name);  in nfsd4_decode_setclientid()
1359 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_prog) < 0)  in nfsd4_decode_setclientid()
1361 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_netid_len) < 0)  in nfsd4_decode_setclientid()
1363 	p = xdr_inline_decode(argp->xdr, setclientid->se_callback_netid_len);  in nfsd4_decode_setclientid()
1366 	setclientid->se_callback_netid_val = svcxdr_savemem(argp, p,  in nfsd4_decode_setclientid()
1367 						setclientid->se_callback_netid_len);  in nfsd4_decode_setclientid()
1368 	if (!setclientid->se_callback_netid_val)  in nfsd4_decode_setclientid()
1371 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_addr_len) < 0)  in nfsd4_decode_setclientid()
1373 	p = xdr_inline_decode(argp->xdr, setclientid->se_callback_addr_len);  in nfsd4_decode_setclientid()
1376 	setclientid->se_callback_addr_val = svcxdr_savemem(argp, p,  in nfsd4_decode_setclientid()
1377 						setclientid->se_callback_addr_len);  in nfsd4_decode_setclientid()
1378 	if (!setclientid->se_callback_addr_val)  in nfsd4_decode_setclientid()
1380 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_ident) < 0)  in nfsd4_decode_setclientid()
1390 	struct nfsd4_setclientid_confirm *scd_c = &u->setclientid_confirm;  in nfsd4_decode_setclientid_confirm()
1393 	if (argp->minorversion >= 1)  in nfsd4_decode_setclientid_confirm()
1396 	status = nfsd4_decode_clientid4(argp, &scd_c->sc_clientid);  in nfsd4_decode_setclientid_confirm()
1399 	return nfsd4_decode_verifier4(argp, &scd_c->sc_confirm);  in nfsd4_decode_setclientid_confirm()
1406 	struct nfsd4_verify *verify = &u->verify;  in nfsd4_decode_verify()
1411 	status = nfsd4_decode_bitmap4(argp, verify->ve_bmval,  in nfsd4_decode_verify()
1412 				      ARRAY_SIZE(verify->ve_bmval));  in nfsd4_decode_verify()
1419 	if (xdr_stream_decode_u32(argp->xdr, &verify->ve_attrlen) < 0)  in nfsd4_decode_verify()
1421 	p = xdr_inline_decode(argp->xdr, verify->ve_attrlen);  in nfsd4_decode_verify()
1424 	verify->ve_attrval = svcxdr_savemem(argp, p, verify->ve_attrlen);  in nfsd4_decode_verify()
1425 	if (!verify->ve_attrval)  in nfsd4_decode_verify()
1434 	struct nfsd4_write *write = &u->write;  in nfsd4_decode_write()
1437 	status = nfsd4_decode_stateid4(argp, &write->wr_stateid);  in nfsd4_decode_write()
1440 	if (xdr_stream_decode_u64(argp->xdr, &write->wr_offset) < 0)  in nfsd4_decode_write()
1442 	if (xdr_stream_decode_u32(argp->xdr, &write->wr_stable_how) < 0)  in nfsd4_decode_write()
1444 	if (write->wr_stable_how > NFS_FILE_SYNC)  in nfsd4_decode_write()
1446 	if (xdr_stream_decode_u32(argp->xdr, &write->wr_buflen) < 0)  in nfsd4_decode_write()
1448 	if (!xdr_stream_subsegment(argp->xdr, &write->wr_payload, write->wr_buflen))  in nfsd4_decode_write()
1451 	write->wr_bytes_written = 0;  in nfsd4_decode_write()
1452 	write->wr_how_written = 0;  in nfsd4_decode_write()
1453 	memset(&write->wr_verifier, 0, sizeof(write->wr_verifier));  in nfsd4_decode_write()
1461 	struct nfsd4_release_lockowner *rlockowner = &u->release_lockowner;  in nfsd4_decode_release_lockowner()
1464 	if (argp->minorversion >= 1)  in nfsd4_decode_release_lockowner()
1467 	status = nfsd4_decode_state_owner4(argp, &rlockowner->rl_clientid,  in nfsd4_decode_release_lockowner()
1468 					   &rlockowner->rl_owner);  in nfsd4_decode_release_lockowner()
1472 	if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid))  in nfsd4_decode_release_lockowner()
1481 	struct nfsd4_backchannel_ctl *bc = &u->backchannel_ctl;  in nfsd4_decode_backchannel_ctl()
1483 	if (xdr_stream_decode_u32(argp->xdr, &bc->bc_cb_program) < 0)  in nfsd4_decode_backchannel_ctl()
1485 	return nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec);  in nfsd4_decode_backchannel_ctl()
1491 	struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session;  in nfsd4_decode_bind_conn_to_session()
1496 	status = nfsd4_decode_sessionid4(argp, &bcts->sessionid);  in nfsd4_decode_bind_conn_to_session()
1499 	if (xdr_stream_decode_u32(argp->xdr, &bcts->dir) < 0)  in nfsd4_decode_bind_conn_to_session()
1501 	if (xdr_stream_decode_u32(argp->xdr, &use_conn_in_rdma_mode) < 0)  in nfsd4_decode_bind_conn_to_session()
1513 	status = nfsd4_decode_bitmap4(argp, exid->spo_must_enforce,  in nfsd4_decode_state_protect_ops()
1514 				      ARRAY_SIZE(exid->spo_must_enforce));  in nfsd4_decode_state_protect_ops()
1517 	status = nfsd4_decode_bitmap4(argp, exid->spo_must_allow,  in nfsd4_decode_state_protect_ops()
1518 				      ARRAY_SIZE(exid->spo_must_allow));  in nfsd4_decode_state_protect_ops()
1542 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)  in nfsd4_decode_ssv_sp_parms()
1544 	while (count--) {  in nfsd4_decode_ssv_sp_parms()
1551 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)  in nfsd4_decode_ssv_sp_parms()
1553 	while (count--) {  in nfsd4_decode_ssv_sp_parms()
1559 	if (xdr_stream_decode_u32(argp->xdr, &window) < 0)  in nfsd4_decode_ssv_sp_parms()
1561 	if (xdr_stream_decode_u32(argp->xdr, &num_gss_handles) < 0)  in nfsd4_decode_ssv_sp_parms()
1573 	if (xdr_stream_decode_u32(argp->xdr, &exid->spa_how) < 0)  in nfsd4_decode_state_protect4_a()
1575 	switch (exid->spa_how) {  in nfsd4_decode_state_protect4_a()
1602 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)  in nfsd4_decode_nfs_impl_id4()
1611 		status = nfsd4_decode_opaque(argp, &exid->nii_domain);  in nfsd4_decode_nfs_impl_id4()
1617 		status = nfsd4_decode_opaque(argp, &exid->nii_name);  in nfsd4_decode_nfs_impl_id4()
1620 		status = nfsd4_decode_nfstime4(argp, &exid->nii_time);  in nfsd4_decode_nfs_impl_id4()
1635 	struct nfsd4_exchange_id *exid = &u->exchange_id;  in nfsd4_decode_exchange_id()
1639 	status = nfsd4_decode_verifier4(argp, &exid->verifier);  in nfsd4_decode_exchange_id()
1642 	status = nfsd4_decode_opaque(argp, &exid->clname);  in nfsd4_decode_exchange_id()
1645 	if (xdr_stream_decode_u32(argp->xdr, &exid->flags) < 0)  in nfsd4_decode_exchange_id()
1659 	p = xdr_inline_decode(argp->xdr, XDR_UNIT * 7);  in nfsd4_decode_channel_attrs4()
1665 	ca->maxreq_sz = be32_to_cpup(p++);  in nfsd4_decode_channel_attrs4()
1666 	ca->maxresp_sz = be32_to_cpup(p++);  in nfsd4_decode_channel_attrs4()
1667 	ca->maxresp_cached = be32_to_cpup(p++);  in nfsd4_decode_channel_attrs4()
1668 	ca->maxops = be32_to_cpup(p++);  in nfsd4_decode_channel_attrs4()
1669 	ca->maxreqs = be32_to_cpup(p++);  in nfsd4_decode_channel_attrs4()
1670 	ca->nr_rdma_attrs = be32_to_cpup(p);  in nfsd4_decode_channel_attrs4()
1671 	switch (ca->nr_rdma_attrs) {  in nfsd4_decode_channel_attrs4()
1675 		if (xdr_stream_decode_u32(argp->xdr, &ca->rdma_attrs) < 0)  in nfsd4_decode_channel_attrs4()
1689 	struct nfsd4_create_session *sess = &u->create_session;  in nfsd4_decode_create_session()
1693 	status = nfsd4_decode_clientid4(argp, &sess->clientid);  in nfsd4_decode_create_session()
1696 	if (xdr_stream_decode_u32(argp->xdr, &sess->seqid) < 0)  in nfsd4_decode_create_session()
1698 	if (xdr_stream_decode_u32(argp->xdr, &sess->flags) < 0)  in nfsd4_decode_create_session()
1700 	status = nfsd4_decode_channel_attrs4(argp, &sess->fore_channel);  in nfsd4_decode_create_session()
1703 	status = nfsd4_decode_channel_attrs4(argp, &sess->back_channel);  in nfsd4_decode_create_session()
1706 	if (xdr_stream_decode_u32(argp->xdr, &sess->callback_prog) < 0)  in nfsd4_decode_create_session()
1708 	return nfsd4_decode_cb_sec(argp, &sess->cb_sec);  in nfsd4_decode_create_session()
1715 	struct nfsd4_destroy_session *destroy_session = &u->destroy_session;  in nfsd4_decode_destroy_session()
1716 	return nfsd4_decode_sessionid4(argp, &destroy_session->sessionid);  in nfsd4_decode_destroy_session()
1723 	struct nfsd4_free_stateid *free_stateid = &u->free_stateid;  in nfsd4_decode_free_stateid()
1724 	return nfsd4_decode_stateid4(argp, &free_stateid->fr_stateid);  in nfsd4_decode_free_stateid()
1731 	struct nfsd4_get_dir_delegation *gdd = &u->get_dir_delegation;  in nfsd4_decode_get_dir_delegation()
1736 	if (xdr_stream_decode_bool(argp->xdr, &gdd->gdda_signal_deleg_avail) < 0)  in nfsd4_decode_get_dir_delegation()
1738 	status = nfsd4_decode_bitmap4(argp, gdd->gdda_notification_types,  in nfsd4_decode_get_dir_delegation()
1739 				      ARRAY_SIZE(gdd->gdda_notification_types));  in nfsd4_decode_get_dir_delegation()
1742 	status = nfsd4_decode_nfstime4(argp, &gdd->gdda_child_attr_delay);  in nfsd4_decode_get_dir_delegation()
1745 	status = nfsd4_decode_nfstime4(argp, &gdd->gdda_dir_attr_delay);  in nfsd4_decode_get_dir_delegation()
1748 	status = nfsd4_decode_bitmap4(argp, gdd->gdda_child_attributes,  in nfsd4_decode_get_dir_delegation()
1749 					ARRAY_SIZE(gdd->gdda_child_attributes));  in nfsd4_decode_get_dir_delegation()
1752 	return nfsd4_decode_bitmap4(argp, gdd->gdda_dir_attributes,  in nfsd4_decode_get_dir_delegation()
1753 					ARRAY_SIZE(gdd->gdda_dir_attributes));  in nfsd4_decode_get_dir_delegation()
1761 	struct nfsd4_getdeviceinfo *gdev = &u->getdeviceinfo;  in nfsd4_decode_getdeviceinfo()
1765 	status = nfsd4_decode_deviceid4(argp, &gdev->gd_devid);  in nfsd4_decode_getdeviceinfo()
1768 	if (xdr_stream_decode_u32(argp->xdr, &gdev->gd_layout_type) < 0)  in nfsd4_decode_getdeviceinfo()
1770 	if (xdr_stream_decode_u32(argp->xdr, &gdev->gd_maxcount) < 0)  in nfsd4_decode_getdeviceinfo()
1772 	if (xdr_stream_decode_uint32_array(argp->xdr,  in nfsd4_decode_getdeviceinfo()
1773 					   &gdev->gd_notify_types, 1) < 0)  in nfsd4_decode_getdeviceinfo()
1783 	struct nfsd4_layoutcommit *lcp = &u->layoutcommit;  in nfsd4_decode_layoutcommit()
1787 	if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_seg.offset) < 0)  in nfsd4_decode_layoutcommit()
1789 	if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_seg.length) < 0)  in nfsd4_decode_layoutcommit()
1791 	if (xdr_stream_decode_bool(argp->xdr, &lcp->lc_reclaim) < 0)  in nfsd4_decode_layoutcommit()
1793 	status = nfsd4_decode_stateid4(argp, &lcp->lc_sid);  in nfsd4_decode_layoutcommit()
1796 	if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_newoffset) < 0)  in nfsd4_decode_layoutcommit()
1798 	if (lcp->lc_newoffset) {  in nfsd4_decode_layoutcommit()
1799 		if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_last_wr) < 0)  in nfsd4_decode_layoutcommit()
1802 		lcp->lc_last_wr = 0;  in nfsd4_decode_layoutcommit()
1803 	p = xdr_inline_decode(argp->xdr, XDR_UNIT);  in nfsd4_decode_layoutcommit()
1807 		status = nfsd4_decode_nfstime4(argp, &lcp->lc_mtime);  in nfsd4_decode_layoutcommit()
1811 		lcp->lc_mtime.tv_nsec = UTIME_NOW;  in nfsd4_decode_layoutcommit()
1820 	struct nfsd4_layoutget *lgp = &u->layoutget;  in nfsd4_decode_layoutget()
1824 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_signal) < 0)  in nfsd4_decode_layoutget()
1826 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_layout_type) < 0)  in nfsd4_decode_layoutget()
1828 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_seg.iomode) < 0)  in nfsd4_decode_layoutget()
1830 	if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_seg.offset) < 0)  in nfsd4_decode_layoutget()
1832 	if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_seg.length) < 0)  in nfsd4_decode_layoutget()
1834 	if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_minlength) < 0)  in nfsd4_decode_layoutget()
1836 	status = nfsd4_decode_stateid4(argp, &lgp->lg_sid);  in nfsd4_decode_layoutget()
1839 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_maxcount) < 0)  in nfsd4_decode_layoutget()
1849 	struct nfsd4_layoutreturn *lrp = &u->layoutreturn;  in nfsd4_decode_layoutreturn()
1851 	if (xdr_stream_decode_bool(argp->xdr, &lrp->lr_reclaim) < 0)  in nfsd4_decode_layoutreturn()
1853 	if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_layout_type) < 0)  in nfsd4_decode_layoutreturn()
1855 	if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_seg.iomode) < 0)  in nfsd4_decode_layoutreturn()
1864 	struct nfsd4_secinfo_no_name *sin = &u->secinfo_no_name;  in nfsd4_decode_secinfo_no_name()
1865 	if (xdr_stream_decode_u32(argp->xdr, &sin->sin_style) < 0)  in nfsd4_decode_secinfo_no_name()
1868 	sin->sin_exp = NULL;  in nfsd4_decode_secinfo_no_name()
1876 	struct nfsd4_sequence *seq = &u->sequence;  in nfsd4_decode_sequence()
1879 	status = nfsd4_decode_sessionid4(argp, &seq->sessionid);  in nfsd4_decode_sequence()
1882 	p = xdr_inline_decode(argp->xdr, XDR_UNIT * 4);  in nfsd4_decode_sequence()
1885 	seq->seqid = be32_to_cpup(p++);  in nfsd4_decode_sequence()
1886 	seq->slotid = be32_to_cpup(p++);  in nfsd4_decode_sequence()
1887 	seq->maxslots = be32_to_cpup(p++);  in nfsd4_decode_sequence()
1888 	seq->cachethis = be32_to_cpup(p);  in nfsd4_decode_sequence()
1890 	seq->status_flags = 0;  in nfsd4_decode_sequence()
1898 	struct nfsd4_test_stateid *test_stateid = &u->test_stateid;  in nfsd4_decode_test_stateid()
1904 	if (xdr_stream_decode_u32(argp->xdr, &test_stateid->ts_num_ids) < 0)  in nfsd4_decode_test_stateid()
1907 	INIT_LIST_HEAD(&test_stateid->ts_stateid_list);  in nfsd4_decode_test_stateid()
1908 	for (i = 0; i < test_stateid->ts_num_ids; i++) {  in nfsd4_decode_test_stateid()
1912 		INIT_LIST_HEAD(&stateid->ts_id_list);  in nfsd4_decode_test_stateid()
1913 		list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list);  in nfsd4_decode_test_stateid()
1914 		status = nfsd4_decode_stateid4(argp, &stateid->ts_id_stateid);  in nfsd4_decode_test_stateid()
1925 	struct nfsd4_destroy_clientid *dc = &u->destroy_clientid;  in nfsd4_decode_destroy_clientid()
1926 	return nfsd4_decode_clientid4(argp, &dc->clientid);  in nfsd4_decode_destroy_clientid()
1932 	struct nfsd4_reclaim_complete *rc = &u->reclaim_complete;  in nfsd4_decode_reclaim_complete()
1933 	if (xdr_stream_decode_bool(argp->xdr, &rc->rca_one_fs) < 0)  in nfsd4_decode_reclaim_complete()
1942 	struct nfsd4_fallocate *fallocate = &u->allocate;  in nfsd4_decode_fallocate()
1945 	status = nfsd4_decode_stateid4(argp, &fallocate->falloc_stateid);  in nfsd4_decode_fallocate()
1948 	if (xdr_stream_decode_u64(argp->xdr, &fallocate->falloc_offset) < 0)  in nfsd4_decode_fallocate()
1950 	if (xdr_stream_decode_u64(argp->xdr, &fallocate->falloc_length) < 0)  in nfsd4_decode_fallocate()
1962 	if (xdr_stream_decode_u32(argp->xdr, &ns->nl4_type) < 0)  in nfsd4_decode_nl4_server()
1965 	/* currently support for 1 inter-server source server */  in nfsd4_decode_nl4_server()
1966 	switch (ns->nl4_type) {  in nfsd4_decode_nl4_server()
1968 		naddr = &ns->u.nl4_addr;  in nfsd4_decode_nl4_server()
1970 		if (xdr_stream_decode_u32(argp->xdr, &naddr->netid_len) < 0)  in nfsd4_decode_nl4_server()
1972 		if (naddr->netid_len > RPCBIND_MAXNETIDLEN)  in nfsd4_decode_nl4_server()
1975 		p = xdr_inline_decode(argp->xdr, naddr->netid_len);  in nfsd4_decode_nl4_server()
1978 		memcpy(naddr->netid, p, naddr->netid_len);  in nfsd4_decode_nl4_server()
1980 		if (xdr_stream_decode_u32(argp->xdr, &naddr->addr_len) < 0)  in nfsd4_decode_nl4_server()
1982 		if (naddr->addr_len > RPCBIND_MAXUADDRLEN)  in nfsd4_decode_nl4_server()
1985 		p = xdr_inline_decode(argp->xdr, naddr->addr_len);  in nfsd4_decode_nl4_server()
1988 		memcpy(naddr->addr, p, naddr->addr_len);  in nfsd4_decode_nl4_server()
2000 	struct nfsd4_copy *copy = &u->copy;  in nfsd4_decode_copy()
2006 	status = nfsd4_decode_stateid4(argp, &copy->cp_src_stateid);  in nfsd4_decode_copy()
2009 	status = nfsd4_decode_stateid4(argp, &copy->cp_dst_stateid);  in nfsd4_decode_copy()
2012 	if (xdr_stream_decode_u64(argp->xdr, &copy->cp_src_pos) < 0)  in nfsd4_decode_copy()
2014 	if (xdr_stream_decode_u64(argp->xdr, &copy->cp_dst_pos) < 0)  in nfsd4_decode_copy()
2016 	if (xdr_stream_decode_u64(argp->xdr, &copy->cp_count) < 0)  in nfsd4_decode_copy()
2019 	if (xdr_stream_decode_u32(argp->xdr, &consecutive) < 0)  in nfsd4_decode_copy()
2021 	if (xdr_stream_decode_bool(argp->xdr, &sync) < 0)  in nfsd4_decode_copy()
2025 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)  in nfsd4_decode_copy()
2027 	copy->cp_src = svcxdr_tmpalloc(argp, sizeof(*copy->cp_src));  in nfsd4_decode_copy()
2028 	if (copy->cp_src == NULL)  in nfsd4_decode_copy()
2030 	if (count == 0) { /* intra-server copy */  in nfsd4_decode_copy()
2031 		__set_bit(NFSD4_COPY_F_INTRA, &copy->cp_flags);  in nfsd4_decode_copy()
2036 	status = nfsd4_decode_nl4_server(argp, copy->cp_src);  in nfsd4_decode_copy()
2043 	for (i = 0; i < count - 1; i++) {  in nfsd4_decode_copy()
2059 	struct nfsd4_copy_notify *cn = &u->copy_notify;  in nfsd4_decode_copy_notify()
2063 	cn->cpn_src = svcxdr_tmpalloc(argp, sizeof(*cn->cpn_src));  in nfsd4_decode_copy_notify()
2064 	if (cn->cpn_src == NULL)  in nfsd4_decode_copy_notify()
2066 	cn->cpn_dst = svcxdr_tmpalloc(argp, sizeof(*cn->cpn_dst));  in nfsd4_decode_copy_notify()
2067 	if (cn->cpn_dst == NULL)  in nfsd4_decode_copy_notify()
2070 	status = nfsd4_decode_stateid4(argp, &cn->cpn_src_stateid);  in nfsd4_decode_copy_notify()
2073 	return nfsd4_decode_nl4_server(argp, cn->cpn_dst);  in nfsd4_decode_copy_notify()
2080 	struct nfsd4_offload_status *os = &u->offload_status;  in nfsd4_decode_offload_status()
2081 	os->count = 0;  in nfsd4_decode_offload_status()
2082 	os->status = 0;  in nfsd4_decode_offload_status()
2083 	return nfsd4_decode_stateid4(argp, &os->stateid);  in nfsd4_decode_offload_status()
2089 	struct nfsd4_seek *seek = &u->seek;  in nfsd4_decode_seek()
2092 	status = nfsd4_decode_stateid4(argp, &seek->seek_stateid);  in nfsd4_decode_seek()
2095 	if (xdr_stream_decode_u64(argp->xdr, &seek->seek_offset) < 0)  in nfsd4_decode_seek()
2097 	if (xdr_stream_decode_u32(argp->xdr, &seek->seek_whence) < 0)  in nfsd4_decode_seek()
2100 	seek->seek_eof = 0;  in nfsd4_decode_seek()
2101 	seek->seek_pos = 0;  in nfsd4_decode_seek()
2108 	struct nfsd4_clone *clone = &u->clone;  in nfsd4_decode_clone()
2111 	status = nfsd4_decode_stateid4(argp, &clone->cl_src_stateid);  in nfsd4_decode_clone()
2114 	status = nfsd4_decode_stateid4(argp, &clone->cl_dst_stateid);  in nfsd4_decode_clone()
2117 	if (xdr_stream_decode_u64(argp->xdr, &clone->cl_src_pos) < 0)  in nfsd4_decode_clone()
2119 	if (xdr_stream_decode_u64(argp->xdr, &clone->cl_dst_pos) < 0)  in nfsd4_decode_clone()
2121 	if (xdr_stream_decode_u64(argp->xdr, &clone->cl_count) < 0)  in nfsd4_decode_clone()
2132  * is 64k). Since there is no kvec- or page-based interface to xattrs,
2143 	struct page **pages = xdr->pages;  in nfsd4_vbuf_from_vector()
2144 	struct kvec *head = xdr->head;  in nfsd4_vbuf_from_vector()
2148 	if (buflen <= head->iov_len) {  in nfsd4_vbuf_from_vector()
2153 		*bufp = head->iov_base;  in nfsd4_vbuf_from_vector()
2162 	memcpy(dp, head->iov_base, head->iov_len);  in nfsd4_vbuf_from_vector()
2163 	buflen -= head->iov_len;  in nfsd4_vbuf_from_vector()
2164 	dp += head->iov_len;  in nfsd4_vbuf_from_vector()
2170 		buflen -= len;  in nfsd4_vbuf_from_vector()
2191 	if (xdr_stream_decode_u32(argp->xdr, &namelen) < 0)  in nfsd4_decode_xattr_name()
2193 	if (namelen > (XATTR_NAME_MAX - XATTR_USER_PREFIX_LEN))  in nfsd4_decode_xattr_name()
2197 	p = xdr_inline_decode(argp->xdr, namelen);  in nfsd4_decode_xattr_name()
2213 	while (cnt-- > 0) {  in nfsd4_decode_xattr_name()
2226  * A GETXATTR op request comes without a length specifier. We just set the
2235 	struct nfsd4_getxattr *getxattr = &u->getxattr;  in nfsd4_decode_getxattr()
2240 	status = nfsd4_decode_xattr_name(argp, &getxattr->getxa_name);  in nfsd4_decode_getxattr()
2244 	maxcount = svc_max_payload(argp->rqstp);  in nfsd4_decode_getxattr()
2247 	getxattr->getxa_len = maxcount;  in nfsd4_decode_getxattr()
2255 	struct nfsd4_setxattr *setxattr = &u->setxattr;  in nfsd4_decode_setxattr()
2261 	if (xdr_stream_decode_u32(argp->xdr, &flags) < 0)  in nfsd4_decode_setxattr()
2266 	setxattr->setxa_flags = flags;  in nfsd4_decode_setxattr()
2268 	status = nfsd4_decode_xattr_name(argp, &setxattr->setxa_name);  in nfsd4_decode_setxattr()
2272 	maxcount = svc_max_payload(argp->rqstp);  in nfsd4_decode_setxattr()
2275 	if (xdr_stream_decode_u32(argp->xdr, &size) < 0)  in nfsd4_decode_setxattr()
2280 	setxattr->setxa_len = size;  in nfsd4_decode_setxattr()
2284 		if (!xdr_stream_subsegment(argp->xdr, &payload, size))  in nfsd4_decode_setxattr()
2287 						&setxattr->setxa_buf, size);  in nfsd4_decode_setxattr()
2297 	struct nfsd4_listxattrs *listxattrs = &u->listxattrs;  in nfsd4_decode_listxattrs()
2302 	if (xdr_stream_decode_u64(argp->xdr, &listxattrs->lsxa_cookie) < 0)  in nfsd4_decode_listxattrs()
2309 	if (listxattrs->lsxa_cookie >=  in nfsd4_decode_listxattrs()
2313 	if (xdr_stream_decode_u32(argp->xdr, &maxcount) < 0)  in nfsd4_decode_listxattrs()
2319 	maxcount = min(maxcount, svc_max_payload(argp->rqstp));  in nfsd4_decode_listxattrs()
2320 	listxattrs->lsxa_maxcount = maxcount;  in nfsd4_decode_listxattrs()
2329 	struct nfsd4_removexattr *removexattr = &u->removexattr;  in nfsd4_decode_removexattr()
2331 	return nfsd4_decode_xattr_name(argp, &removexattr->rmxa_name);  in nfsd4_decode_removexattr()
2440 	if (op->opnum < FIRST_NFS4_OP)  in nfsd4_opnum_in_range()
2442 	else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP)  in nfsd4_opnum_in_range()
2444 	else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP)  in nfsd4_opnum_in_range()
2446 	else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP)  in nfsd4_opnum_in_range()
2456 	int auth_slack= argp->rqstp->rq_auth_slack;  in nfsd4_decode_compound()
2463 	if (xdr_stream_decode_u32(argp->xdr, &argp->taglen) < 0)  in nfsd4_decode_compound()
2466 	argp->tag = NULL;  in nfsd4_decode_compound()
2467 	if (unlikely(argp->taglen)) {  in nfsd4_decode_compound()
2468 		if (argp->taglen > NFSD4_MAX_TAGLEN)  in nfsd4_decode_compound()
2470 		p = xdr_inline_decode(argp->xdr, argp->taglen);  in nfsd4_decode_compound()
2473 		argp->tag = svcxdr_savemem(argp, p, argp->taglen);  in nfsd4_decode_compound()
2474 		if (!argp->tag)  in nfsd4_decode_compound()
2476 		max_reply += xdr_align_size(argp->taglen);  in nfsd4_decode_compound()
2479 	if (xdr_stream_decode_u32(argp->xdr, &argp->minorversion) < 0)  in nfsd4_decode_compound()
2481 	if (xdr_stream_decode_u32(argp->xdr, &argp->client_opcnt) < 0)  in nfsd4_decode_compound()
2483 	argp->opcnt = min_t(u32, argp->client_opcnt,  in nfsd4_decode_compound()
2486 	if (argp->opcnt > ARRAY_SIZE(argp->iops)) {  in nfsd4_decode_compound()
2487 		argp->ops = vcalloc(argp->opcnt, sizeof(*argp->ops));  in nfsd4_decode_compound()
2488 		if (!argp->ops) {  in nfsd4_decode_compound()
2489 			argp->ops = argp->iops;  in nfsd4_decode_compound()
2494 	if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION)  in nfsd4_decode_compound()
2495 		argp->opcnt = 0;  in nfsd4_decode_compound()
2497 	for (i = 0; i < argp->opcnt; i++) {  in nfsd4_decode_compound()
2498 		op = &argp->ops[i];  in nfsd4_decode_compound()
2499 		op->replay = NULL;  in nfsd4_decode_compound()
2500 		op->opdesc = NULL;  in nfsd4_decode_compound()
2502 		if (xdr_stream_decode_u32(argp->xdr, &op->opnum) < 0)  in nfsd4_decode_compound()
2505 			op->opdesc = OPDESC(op);  in nfsd4_decode_compound()
2506 			op->status = nfsd4_dec_ops[op->opnum](argp, &op->u);  in nfsd4_decode_compound()
2507 			if (op->status != nfs_ok)  in nfsd4_decode_compound()
2508 				trace_nfsd_compound_decode_err(argp->rqstp,  in nfsd4_decode_compound()
2509 							       argp->opcnt, i,  in nfsd4_decode_compound()
2510 							       op->opnum,  in nfsd4_decode_compound()
2511 							       op->status);  in nfsd4_decode_compound()
2513 			op->opnum = OP_ILLEGAL;  in nfsd4_decode_compound()
2514 			op->status = nfserr_op_illegal;  in nfsd4_decode_compound()
2523 		if (op->opnum == OP_READ || op->opnum == OP_READ_PLUS) {  in nfsd4_decode_compound()
2525 			readbytes += nfsd4_max_reply(argp->rqstp, op);  in nfsd4_decode_compound()
2527 			max_reply += nfsd4_max_reply(argp->rqstp, op);  in nfsd4_decode_compound()
2534 		if (op->opnum == OP_LOCK || op->opnum == OP_LOCKT)  in nfsd4_decode_compound()
2537 		if (op->status) {  in nfsd4_decode_compound()
2538 			argp->opcnt = i+1;  in nfsd4_decode_compound()
2543 	if (argp->minorversion)  in nfsd4_decode_compound()
2545 	svc_reserve(argp->rqstp, max_reply + readbytes);  in nfsd4_decode_compound()
2546 	argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE;  in nfsd4_decode_compound()
2548 	argp->splice_ok = nfsd_read_splice_ok(argp->rqstp);  in nfsd4_decode_compound()
2549 	if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack)  in nfsd4_decode_compound()
2550 		argp->splice_ok = false;  in nfsd4_decode_compound()
2558 	return nfsd4_encode_opaque(xdr, fh_handle->fh_raw, fh_handle->fh_size);  in nfsd4_encode_nfs_fh4()
2561 /* This is a frequently-encoded type; open-coded for speed */
2570 	p = xdr_encode_hyper(p, tv->tv_sec);  in nfsd4_encode_nfstime4()
2571 	*p = cpu_to_be32(tv->tv_nsec);  in nfsd4_encode_nfstime4()
2591 	status = nfsd4_encode_bool(xdr, c->atomic);  in nfsd4_encode_change_info4()
2594 	status = nfsd4_encode_changeid4(xdr, c->before_change);  in nfsd4_encode_change_info4()
2597 	return nfsd4_encode_changeid4(xdr, c->after_change);  in nfsd4_encode_change_info4()
2606 	status = nfsd4_encode_opaque(xdr, addr->netid, addr->netid_len);  in nfsd4_encode_netaddr4()
2610 	return nfsd4_encode_opaque(xdr, addr->addr, addr->addr_len);  in nfsd4_encode_netaddr4()
2628 	pathlen_offset = xdr->buf->len;  in nfsd4_encode_components_esc()
2653 		strlen = end - str;  in nfsd4_encode_components_esc()
2669 	write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4);  in nfsd4_encode_components_esc()
2687 	status = nfsd4_encode_components_esc(xdr, ':', location->hosts,  in nfsd4_encode_fs_location4()
2691 	status = nfsd4_encode_components(xdr, '/', location->path);  in nfsd4_encode_fs_location4()
2716 		if (cur.dentry == cur.mnt->mnt_root) {  in nfsd4_encode_pathname4()
2740 		struct dentry *dentry = components[ncomponents - 1];  in nfsd4_encode_pathname4()
2743 		spin_lock(&dentry->d_lock);  in nfsd4_encode_pathname4()
2744 		len = dentry->d_name.len;  in nfsd4_encode_pathname4()
2747 			spin_unlock(&dentry->d_lock);  in nfsd4_encode_pathname4()
2750 		p = xdr_encode_opaque(p, dentry->d_name.name, len);  in nfsd4_encode_pathname4()
2752 		spin_unlock(&dentry->d_lock);  in nfsd4_encode_pathname4()
2754 		ncomponents--;  in nfsd4_encode_pathname4()
2761 		dput(components[--ncomponents]);  in nfsd4_encode_pathname4()
2771 	struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs;  in nfsd4_encode_fs_locations4()
2780 	status = nfsd4_encode_pathname4(xdr, &exp_ps->ex_path, &exp->ex_path);  in nfsd4_encode_fs_locations4()
2786 	if (xdr_stream_encode_u32(xdr, fslocs->locations_count) != XDR_UNIT)  in nfsd4_encode_fs_locations4()
2788 	for (i = 0; i < fslocs->locations_count; i++) {  in nfsd4_encode_fs_locations4()
2789 		status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]);  in nfsd4_encode_fs_locations4()
2803 	status = nfsd4_encode_acetype4(xdr, ace->type);  in nfsd4_encode_nfsace4()
2807 	status = nfsd4_encode_aceflag4(xdr, ace->flag);  in nfsd4_encode_nfsace4()
2811 	status = nfsd4_encode_acemask4(xdr, ace->access_mask & NFS4_ACE_MASK_ALL);  in nfsd4_encode_nfsace4()
2815 	if (ace->whotype != NFS4_ACL_WHO_NAMED)  in nfsd4_encode_nfsace4()
2816 		return nfs4_acl_write_who(xdr, ace->whotype);  in nfsd4_encode_nfsace4()
2817 	if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)  in nfsd4_encode_nfsace4()
2818 		return nfsd4_encode_group(xdr, rqstp, ace->who_gid);  in nfsd4_encode_nfsace4()
2819 	return nfsd4_encode_user(xdr, rqstp, ace->who_uid);  in nfsd4_encode_nfsace4()
2874 	struct path path = exp->ex_path;  in nfsd4_get_mounted_on_ino()
2880 		if (path.dentry != path.mnt->mnt_root)  in nfsd4_get_mounted_on_ino()
2965 	struct nfsd4_compoundres *resp = args->rqstp->rq_resp;  in nfsd4_encode_fattr4_supported_attrs()
2966 	u32 minorversion = resp->cstate.minorversion;  in nfsd4_encode_fattr4_supported_attrs()
2970 	if (!IS_POSIXACL(d_inode(args->dentry)))  in nfsd4_encode_fattr4_supported_attrs()
2972 	if (!args->contextsupport)  in nfsd4_encode_fattr4_supported_attrs()
2987 	switch (args->stat.mode & S_IFMT) {  in nfsd4_encode_fattr4_type()
3022 	if (!(args->exp->ex_flags & NFSEXP_NOSUBTREECHECK))  in nfsd4_encode_fattr4_fh_expire_type()
3030 	const struct svc_export *exp = args->exp;  in nfsd4_encode_fattr4_change()
3033 	if (unlikely(exp->ex_flags & NFSEXP_V4ROOT)) {  in nfsd4_encode_fattr4_change()
3034 		u32 flush_time = convert_to_wallclock(exp->cd->flush_time);  in nfsd4_encode_fattr4_change()
3043 	c = nfsd4_change_attribute(&args->stat, d_inode(args->dentry));  in nfsd4_encode_fattr4_change()
3050 	return nfsd4_encode_uint64_t(xdr, args->size);  in nfsd4_encode_fattr4_size()
3062 	if (unlikely(args->exp->ex_fslocs.migrated)) {  in nfsd4_encode_fattr4_fsid()
3067 	switch (fsid_source(args->fhp)) {  in nfsd4_encode_fattr4_fsid()
3069 		p = xdr_encode_hyper(p, (u64)args->exp->ex_fsid);  in nfsd4_encode_fattr4_fsid()
3074 		*p++ = cpu_to_be32(MAJOR(args->stat.dev));  in nfsd4_encode_fattr4_fsid()
3076 		*p   = cpu_to_be32(MINOR(args->stat.dev));  in nfsd4_encode_fattr4_fsid()
3079 		xdr_encode_opaque_fixed(p, args->exp->ex_uuid, EX_UUID_LEN);  in nfsd4_encode_fattr4_fsid()
3089 	struct nfsd_net *nn = net_generic(SVC_NET(args->rqstp), nfsd_net_id);  in nfsd4_encode_fattr4_lease_time()
3091 	return nfsd4_encode_nfs_lease4(xdr, nn->nfsd4_lease);  in nfsd4_encode_fattr4_lease_time()
3097 	return nfsd4_encode_uint32_t(xdr, args->rdattr_err);  in nfsd4_encode_fattr4_rdattr_error()
3106 	if (IS_POSIXACL(d_inode(args->dentry)))  in nfsd4_encode_fattr4_aclsupport()
3114 	struct nfs4_acl *acl = args->acl;  in nfsd4_encode_fattr4_acl()
3123 		if (xdr_stream_encode_u32(xdr, acl->naces) != XDR_UNIT)  in nfsd4_encode_fattr4_acl()
3125 		for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) {  in nfsd4_encode_fattr4_acl()
3126 			status = nfsd4_encode_nfsace4(xdr, args->rqstp, ace);  in nfsd4_encode_fattr4_acl()
3137 	return nfsd4_encode_nfs_fh4(xdr, &args->fhp->fh_handle);  in nfsd4_encode_fattr4_filehandle()
3143 	return nfsd4_encode_uint64_t(xdr, args->stat.ino);  in nfsd4_encode_fattr4_fileid()
3149 	return nfsd4_encode_uint64_t(xdr, args->statfs.f_ffree);  in nfsd4_encode_fattr4_files_avail()
3155 	return nfsd4_encode_uint64_t(xdr, args->statfs.f_ffree);  in nfsd4_encode_fattr4_files_free()
3161 	return nfsd4_encode_uint64_t(xdr, args->statfs.f_files);  in nfsd4_encode_fattr4_files_total()
3167 	return nfsd4_encode_fs_locations4(xdr, args->rqstp, args->exp);  in nfsd4_encode_fattr4_fs_locations()
3173 	struct super_block *sb = args->exp->ex_path.mnt->mnt_sb;  in nfsd4_encode_fattr4_maxfilesize()
3175 	return nfsd4_encode_uint64_t(xdr, sb->s_maxbytes);  in nfsd4_encode_fattr4_maxfilesize()
3187 	return nfsd4_encode_uint32_t(xdr, args->statfs.f_namelen);  in nfsd4_encode_fattr4_maxname()
3193 	return nfsd4_encode_uint64_t(xdr, svc_max_payload(args->rqstp));  in nfsd4_encode_fattr4_maxread()
3199 	return nfsd4_encode_uint64_t(xdr, svc_max_payload(args->rqstp));  in nfsd4_encode_fattr4_maxwrite()
3205 	return nfsd4_encode_mode4(xdr, args->stat.mode & S_IALLUGO);  in nfsd4_encode_fattr4_mode()
3211 	return nfsd4_encode_uint32_t(xdr, args->stat.nlink);  in nfsd4_encode_fattr4_numlinks()
3217 	return nfsd4_encode_user(xdr, args->rqstp, args->stat.uid);  in nfsd4_encode_fattr4_owner()
3223 	return nfsd4_encode_group(xdr, args->rqstp, args->stat.gid);  in nfsd4_encode_fattr4_owner_group()
3229 	return nfsd4_encode_specdata4(xdr, MAJOR(args->stat.rdev),  in nfsd4_encode_fattr4_rawdev()
3230 				      MINOR(args->stat.rdev));  in nfsd4_encode_fattr4_rawdev()
3236 	u64 avail = (u64)args->statfs.f_bavail * (u64)args->statfs.f_bsize;  in nfsd4_encode_fattr4_space_avail()
3244 	u64 free = (u64)args->statfs.f_bfree * (u64)args->statfs.f_bsize;  in nfsd4_encode_fattr4_space_free()
3252 	u64 total = (u64)args->statfs.f_blocks * (u64)args->statfs.f_bsize;  in nfsd4_encode_fattr4_space_total()
3260 	return nfsd4_encode_uint64_t(xdr, (u64)args->stat.blocks << 9);  in nfsd4_encode_fattr4_space_used()
3266 	return nfsd4_encode_nfstime4(xdr, &args->stat.atime);  in nfsd4_encode_fattr4_time_access()
3272 	return nfsd4_encode_nfstime4(xdr, &args->stat.btime);  in nfsd4_encode_fattr4_time_create()
3289 	const struct inode *inode = d_inode(args->dentry);  in nfsd4_encode_fattr4_time_delta()
3290 	u32 ns = max_t(u32, NSEC_PER_SEC/HZ, inode->i_sb->s_time_gran);  in nfsd4_encode_fattr4_time_delta()
3299 	return nfsd4_encode_nfstime4(xdr, &args->stat.ctime);  in nfsd4_encode_fattr4_time_metadata()
3305 	return nfsd4_encode_nfstime4(xdr, &args->stat.mtime);  in nfsd4_encode_fattr4_time_modify()
3314 	if (!args->ignore_crossmnt &&  in nfsd4_encode_fattr4_mounted_on_fileid()
3315 	    args->dentry == args->exp->ex_path.mnt->mnt_root) {  in nfsd4_encode_fattr4_mounted_on_fileid()
3316 		err = nfsd4_get_mounted_on_ino(args->exp, &ino);  in nfsd4_encode_fattr4_mounted_on_fileid()
3320 		ino = args->stat.ino;  in nfsd4_encode_fattr4_mounted_on_fileid()
3330 	unsigned long mask = args->exp->ex_layout_types;  in nfsd4_encode_fattr4_fs_layout_types()
3348 	unsigned long mask = args->exp->ex_layout_types;  in nfsd4_encode_fattr4_layout_types()
3366 	return nfsd4_encode_uint32_t(xdr, args->stat.blksize);  in nfsd4_encode_fattr4_layout_blksize()
3374 	struct nfsd4_compoundres *resp = args->rqstp->rq_resp;  in nfsd4_encode_fattr4_suppattr_exclcreat()
3377 	memcpy(supp, nfsd_suppattrs[resp->cstate.minorversion], sizeof(supp));  in nfsd4_encode_fattr4_suppattr_exclcreat()
3389 	return nfsd4_encode_security_label(xdr, args->rqstp,  in nfsd4_encode_fattr4_sec_label()
3390 					   args->context, args->contextlen);  in nfsd4_encode_fattr4_sec_label()
3397 	int err = xattr_supports_user_prefix(d_inode(args->dentry));  in nfsd4_encode_fattr4_xattr_support()
3517 	int starting_len = xdr->buf->len;  in nfsd4_encode_fattr4()
3522 	struct nfsd4_compoundres *resp = rqstp->rq_resp;  in nfsd4_encode_fattr4()
3523 	u32 minorversion = resp->cstate.minorversion;  in nfsd4_encode_fattr4()
3525 		.mnt	= exp->ex_path.mnt,  in nfsd4_encode_fattr4()
3552 	if (exp->ex_fslocs.migrated) {  in nfsd4_encode_fattr4()
3603 		if (err == -EOPNOTSUPP)  in nfsd4_encode_fattr4()
3605 		else if (err == -EINVAL) {  in nfsd4_encode_fattr4()
3617 		if (exp->ex_flags & NFSEXP_SECURITY_LABEL)  in nfsd4_encode_fattr4()
3621 			err = -EOPNOTSUPP;  in nfsd4_encode_fattr4()
3624 			if (err == -EOPNOTSUPP)  in nfsd4_encode_fattr4()
3639 	attrlen_offset = xdr->buf->len;  in nfsd4_encode_fattr4()
3651 	*attrlen_p = cpu_to_be32(xdr->buf->len - attrlen_offset - XDR_UNIT);  in nfsd4_encode_fattr4()
3678 	xdr->scratch.iov_len = 0;  in svcxdr_init_encode_from_buffer()
3680 	buf->head[0].iov_base = p;  in svcxdr_init_encode_from_buffer()
3681 	buf->head[0].iov_len = 0;  in svcxdr_init_encode_from_buffer()
3682 	buf->len = 0;  in svcxdr_init_encode_from_buffer()
3683 	xdr->buf = buf;  in svcxdr_init_encode_from_buffer()
3684 	xdr->iov = buf->head;  in svcxdr_init_encode_from_buffer()
3685 	xdr->p = p;  in svcxdr_init_encode_from_buffer()
3686 	xdr->end = (void *)p + bytes;  in svcxdr_init_encode_from_buffer()
3687 	buf->buflen = bytes;  in svcxdr_init_encode_from_buffer()
3714 	struct xdr_stream *xdr = readdir->xdr;  in nfsd4_encode_entry4_nfs_cookie4()
3716 	if (!readdir->cookie_offset)  in nfsd4_encode_entry4_nfs_cookie4()
3718 	write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset, &cookie,  in nfsd4_encode_entry4_nfs_cookie4()
3735 	struct svc_export *exp = cd->rd_fhp->fh_export;  in nfsd4_encode_entry4_fattr()
3740 	dentry = lookup_positive_unlocked(name, cd->rd_fhp->fh_dentry, namlen);  in nfsd4_encode_entry4_fattr()
3748 	 * as opposed to the cross-mounted file system. In such a case,  in nfsd4_encode_entry4_fattr()
3755 		if (!(exp->ex_flags & NFSEXP_V4ROOT)  in nfsd4_encode_entry4_fattr()
3756 				&& !attributes_need_mount(cd->rd_bmval)) {  in nfsd4_encode_entry4_fattr()
3765 		err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp);  in nfsd4_encode_entry4_fattr()
3770 		nfserr = check_nfsd_access(exp, cd->rd_rqstp);  in nfsd4_encode_entry4_fattr()
3776 	nfserr = nfsd4_encode_fattr4(cd->rd_rqstp, cd->xdr, NULL, exp, dentry,  in nfsd4_encode_entry4_fattr()
3777 				     cd->rd_bmval, ignore_crossmnt);  in nfsd4_encode_entry4_fattr()
3808 	struct xdr_stream *xdr = cd->xdr;  in nfsd4_encode_entry4()
3809 	int start_offset = xdr->buf->len;  in nfsd4_encode_entry4()
3817 		cd->common.err = nfs_ok;  in nfsd4_encode_entry4()
3828 	cookie_offset = xdr->buf->len;  in nfsd4_encode_entry4()
3851 		if (cd->rd_fhp->fh_export->ex_flags & NFSEXP_V4ROOT)  in nfsd4_encode_entry4()
3862 		if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR))  in nfsd4_encode_entry4()
3870 	entry_bytes = xdr->buf->len - start_offset;  in nfsd4_encode_entry4()
3871 	if (entry_bytes > cd->rd_maxcount)  in nfsd4_encode_entry4()
3873 	cd->rd_maxcount -= entry_bytes;  in nfsd4_encode_entry4()
3879 	if (cd->rd_dircount) {  in nfsd4_encode_entry4()
3881 		if (name_and_cookie > cd->rd_dircount && cd->cookie_offset)  in nfsd4_encode_entry4()
3883 		cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie);  in nfsd4_encode_entry4()
3884 		if (!cd->rd_dircount)  in nfsd4_encode_entry4()
3885 			cd->rd_maxcount = 0;  in nfsd4_encode_entry4()
3888 	cd->cookie_offset = cookie_offset;  in nfsd4_encode_entry4()
3890 	cd->common.err = nfs_ok;  in nfsd4_encode_entry4()
3894 	cd->common.err = nfserr;  in nfsd4_encode_entry4()
3895 	return -EINVAL;  in nfsd4_encode_entry4()
3906 	memcpy(p, verf->data, sizeof(verf->data));  in nfsd4_encode_verifier4()
3922 /* This is a frequently-encoded item; open-coded for speed */
3931 	*p++ = cpu_to_be32(sid->si_generation);  in nfsd4_encode_stateid4()
3932 	memcpy(p, &sid->si_opaque, sizeof(sid->si_opaque));  in nfsd4_encode_stateid4()
3940 	return nfsd4_encode_opaque_fixed(xdr, sessionid->data,  in nfsd4_encode_sessionid4()
3948 	struct nfsd4_access *access = &u->access;  in nfsd4_encode_access()
3949 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_access()
3953 	status = nfsd4_encode_uint32_t(xdr, access->ac_supported);  in nfsd4_encode_access()
3957 	return nfsd4_encode_uint32_t(xdr, access->ac_resp_access);  in nfsd4_encode_access()
3963 	struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session;  in nfsd4_encode_bind_conn_to_session()
3964 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_bind_conn_to_session()
3967 	nfserr = nfsd4_encode_sessionid4(xdr, &bcts->sessionid);  in nfsd4_encode_bind_conn_to_session()
3971 	if (xdr_stream_encode_u32(xdr, bcts->dir) != XDR_UNIT)  in nfsd4_encode_bind_conn_to_session()
3981 	struct nfsd4_close *close = &u->close;  in nfsd4_encode_close()
3982 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_close()
3985 	return nfsd4_encode_stateid4(xdr, &close->cl_stateid);  in nfsd4_encode_close()
3993 	struct nfsd4_commit *commit = &u->commit;  in nfsd4_encode_commit()
3995 	return nfsd4_encode_verifier4(resp->xdr, &commit->co_verf);  in nfsd4_encode_commit()
4002 	struct nfsd4_create *create = &u->create;  in nfsd4_encode_create()
4003 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_create()
4006 	nfserr = nfsd4_encode_change_info4(xdr, &create->cr_cinfo);  in nfsd4_encode_create()
4010 	return nfsd4_encode_bitmap4(xdr, create->cr_bmval[0],  in nfsd4_encode_create()
4011 				    create->cr_bmval[1], create->cr_bmval[2]);  in nfsd4_encode_create()
4018 	struct nfsd4_getattr *getattr = &u->getattr;  in nfsd4_encode_getattr()
4019 	struct svc_fh *fhp = getattr->ga_fhp;  in nfsd4_encode_getattr()
4020 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_getattr()
4023 	return nfsd4_encode_fattr4(resp->rqstp, xdr, fhp, fhp->fh_export,  in nfsd4_encode_getattr()
4024 				   fhp->fh_dentry, getattr->ga_bmval, 0);  in nfsd4_encode_getattr()
4031 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_getfh()
4032 	struct svc_fh *fhp = u->getfh;  in nfsd4_encode_getfh()
4035 	return nfsd4_encode_nfs_fh4(xdr, &fhp->fh_handle);  in nfsd4_encode_getfh()
4049 	return nfsd4_encode_opaque(xdr, owner->data, owner->len);  in nfsd4_encode_lock_owner4()
4059 	status = nfsd4_encode_offset4(xdr, ld->ld_start);  in nfsd4_encode_lock4denied()
4063 	status = nfsd4_encode_length4(xdr, ld->ld_length);  in nfsd4_encode_lock4denied()
4067 	if (xdr_stream_encode_u32(xdr, ld->ld_type) != XDR_UNIT)  in nfsd4_encode_lock4denied()
4070 	return nfsd4_encode_lock_owner4(xdr, &ld->ld_clientid,  in nfsd4_encode_lock4denied()
4071 					&ld->ld_owner);  in nfsd4_encode_lock4denied()
4078 	struct nfsd4_lock *lock = &u->lock;  in nfsd4_encode_lock()
4079 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_lock()
4085 		status = nfsd4_encode_stateid4(xdr, &lock->lk_resp_stateid);  in nfsd4_encode_lock()
4089 		status = nfsd4_encode_lock4denied(xdr, &lock->lk_denied);  in nfsd4_encode_lock()
4101 	struct nfsd4_lockt *lockt = &u->lockt;  in nfsd4_encode_lockt()
4102 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_lockt()
4107 		status = nfsd4_encode_lock4denied(xdr, &lockt->lt_denied);  in nfsd4_encode_lockt()
4118 	struct nfsd4_locku *locku = &u->locku;  in nfsd4_encode_locku()
4119 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_locku()
4122 	return nfsd4_encode_stateid4(xdr, &locku->lu_stateid);  in nfsd4_encode_locku()
4130 	struct nfsd4_link *link = &u->link;  in nfsd4_encode_link()
4131 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_link()
4133 	return nfsd4_encode_change_info4(xdr, &link->li_cinfo);  in nfsd4_encode_link()
4157 	/* who - empty for now */  in nfsd4_encode_open_nfsace4()
4169 	status = nfsd4_encode_stateid4(xdr, &open->op_delegate_stateid);  in nfsd4_encode_open_read_delegation4()
4173 	status = nfsd4_encode_bool(xdr, open->op_recall);  in nfsd4_encode_open_read_delegation4()
4197 	status = nfsd4_encode_stateid4(xdr, &open->op_delegate_stateid);  in nfsd4_encode_open_write_delegation4()
4201 	status = nfsd4_encode_bool(xdr, open->op_recall);  in nfsd4_encode_open_write_delegation4()
4218 	if (xdr_stream_encode_u32(xdr, open->op_why_no_deleg) != XDR_UNIT)  in nfsd4_encode_open_none_delegation4()
4220 	switch (open->op_why_no_deleg) {  in nfsd4_encode_open_none_delegation4()
4238 	if (xdr_stream_encode_u32(xdr, open->op_delegate_type) != XDR_UNIT)  in nfsd4_encode_open_delegation4()
4240 	switch (open->op_delegate_type) {  in nfsd4_encode_open_delegation4()
4267 	struct nfsd4_open *open = &u->open;  in nfsd4_encode_open()
4268 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_open()
4271 	nfserr = nfsd4_encode_stateid4(xdr, &open->op_stateid);  in nfsd4_encode_open()
4275 	nfserr = nfsd4_encode_change_info4(xdr, &open->op_cinfo);  in nfsd4_encode_open()
4279 	nfserr = nfsd4_encode_uint32_t(xdr, open->op_rflags);  in nfsd4_encode_open()
4283 	nfserr = nfsd4_encode_bitmap4(xdr, open->op_bmval[0],  in nfsd4_encode_open()
4284 				      open->op_bmval[1], open->op_bmval[2]);  in nfsd4_encode_open()
4295 	struct nfsd4_open_confirm *oc = &u->open_confirm;  in nfsd4_encode_open_confirm()
4296 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_open_confirm()
4299 	return nfsd4_encode_stateid4(xdr, &oc->oc_resp_stateid);  in nfsd4_encode_open_confirm()
4306 	struct nfsd4_open_downgrade *od = &u->open_downgrade;  in nfsd4_encode_open_downgrade()
4307 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_open_downgrade()
4310 	return nfsd4_encode_stateid4(xdr, &od->od_stateid);  in nfsd4_encode_open_downgrade()
4323 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_splice_read()
4324 	struct xdr_buf *buf = xdr->buf;  in nfsd4_encode_splice_read()
4329 	 * Make sure there is room at the end of buf->head for  in nfsd4_encode_splice_read()
4331 	 * to XDR-pad the payload.  in nfsd4_encode_splice_read()
4333 	if (xdr->iov != xdr->buf->head || xdr->end - xdr->p < 1)  in nfsd4_encode_splice_read()
4336 	nfserr = nfsd_splice_read(read->rd_rqstp, read->rd_fhp,  in nfsd4_encode_splice_read()
4337 				  file, read->rd_offset, &maxcount,  in nfsd4_encode_splice_read()
4338 				  &read->rd_eof);  in nfsd4_encode_splice_read()
4339 	read->rd_length = maxcount;  in nfsd4_encode_splice_read()
4342 	svcxdr_encode_opaque_pages(read->rd_rqstp, xdr, buf->pages,  in nfsd4_encode_splice_read()
4343 				   buf->page_base, maxcount);  in nfsd4_encode_splice_read()
4344 	status = svc_encode_result_payload(read->rd_rqstp,  in nfsd4_encode_splice_read()
4345 					   buf->head[0].iov_len, maxcount);  in nfsd4_encode_splice_read()
4356 	 * manipulations are open-coded.  in nfsd4_encode_splice_read()
4358 	space_left = min_t(int, (void *)xdr->end - (void *)xdr->p,  in nfsd4_encode_splice_read()
4359 				buf->buflen - buf->len);  in nfsd4_encode_splice_read()
4360 	buf->buflen = buf->len + space_left;  in nfsd4_encode_splice_read()
4361 	xdr->end = (__be32 *)((void *)xdr->end + space_left);  in nfsd4_encode_splice_read()
4371 	buf->page_len = 0;  in nfsd4_encode_splice_read()
4379 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_readv()
4380 	unsigned int base = xdr->buf->page_len & ~PAGE_MASK;  in nfsd4_encode_readv()
4381 	unsigned int starting_len = xdr->buf->len;  in nfsd4_encode_readv()
4388 	nfserr = nfsd_iter_read(resp->rqstp, read->rd_fhp, file,  in nfsd4_encode_readv()
4389 				read->rd_offset, &maxcount, base,  in nfsd4_encode_readv()
4390 				&read->rd_eof);  in nfsd4_encode_readv()
4391 	read->rd_length = maxcount;  in nfsd4_encode_readv()
4394 	if (svc_encode_result_payload(resp->rqstp, starting_len, maxcount))  in nfsd4_encode_readv()
4398 	write_bytes_to_xdr_buf(xdr->buf, starting_len + maxcount, &zero,  in nfsd4_encode_readv()
4407 	struct nfsd4_compoundargs *argp = resp->rqstp->rq_argp;  in nfsd4_encode_read()
4408 	struct nfsd4_read *read = &u->read;  in nfsd4_encode_read()
4409 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_read()
4410 	int starting_len = xdr->buf->len;  in nfsd4_encode_read()
4411 	bool splice_ok = argp->splice_ok;  in nfsd4_encode_read()
4418 	file = read->rd_nf->nf_file;  in nfsd4_encode_read()
4425 	if (resp->xdr->buf->page_len && splice_ok) {  in nfsd4_encode_read()
4431 	maxcount = min_t(unsigned long, read->rd_length,  in nfsd4_encode_read()
4432 			 (xdr->buf->buflen - xdr->buf->len));  in nfsd4_encode_read()
4434 	if (file->f_op->splice_read && splice_ok)  in nfsd4_encode_read()
4443 	p = xdr_encode_bool(p, read->rd_eof);  in nfsd4_encode_read()
4444 	*p = cpu_to_be32(read->rd_length);  in nfsd4_encode_read()
4452 	struct nfsd4_readlink *readlink = &u->readlink;  in nfsd4_encode_readlink()
4454 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_readlink()
4455 	int length_offset = xdr->buf->len;  in nfsd4_encode_readlink()
4472 	nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp,  in nfsd4_encode_readlink()
4478 	status = svc_encode_result_payload(readlink->rl_rqstp, length_offset,  in nfsd4_encode_readlink()
4486 	write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount, &zero,  in nfsd4_encode_readlink()
4499 	int bytes_left, maxcount, starting_len = xdr->buf->len;  in nfsd4_encode_dirlist4()
4507 	bytes_left = xdr->buf->buflen - xdr->buf->len -  in nfsd4_encode_dirlist4()
4508 		COMPOUND_ERR_SLACK_SPACE - XDR_UNIT * 2;  in nfsd4_encode_dirlist4()
4511 	maxcount = min_t(u32, readdir->rd_maxcount, max_payload);  in nfsd4_encode_dirlist4()
4520 	maxcount = min_t(int, maxcount - XDR_UNIT * 4, bytes_left);  in nfsd4_encode_dirlist4()
4523 	if (!readdir->rd_dircount)  in nfsd4_encode_dirlist4()
4524 		readdir->rd_dircount = max_payload;  in nfsd4_encode_dirlist4()
4527 	readdir->xdr = xdr;  in nfsd4_encode_dirlist4()
4528 	readdir->rd_maxcount = maxcount;  in nfsd4_encode_dirlist4()
4529 	readdir->common.err = 0;  in nfsd4_encode_dirlist4()
4530 	readdir->cookie_offset = 0;  in nfsd4_encode_dirlist4()
4531 	offset = readdir->rd_cookie;  in nfsd4_encode_dirlist4()
4532 	status = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp, &offset,  in nfsd4_encode_dirlist4()
4533 			      &readdir->common, nfsd4_encode_entry4);  in nfsd4_encode_dirlist4()
4536 	if (readdir->common.err == nfserr_toosmall &&  in nfsd4_encode_dirlist4()
4537 	    xdr->buf->len == starting_len) {  in nfsd4_encode_dirlist4()
4539 		if (maxcount - XDR_UNIT * 4 < bytes_left)  in nfsd4_encode_dirlist4()
4552 	return nfsd4_encode_bool(xdr, readdir->common.err == nfserr_eof);  in nfsd4_encode_dirlist4()
4559 	struct nfsd4_readdir *readdir = &u->readdir;  in nfsd4_encode_readdir()
4560 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_readdir()
4561 	int starting_len = xdr->buf->len;  in nfsd4_encode_readdir()
4564 	nfserr = nfsd4_encode_verifier4(xdr, &readdir->rd_verf);  in nfsd4_encode_readdir()
4569 	nfserr = nfsd4_encode_dirlist4(xdr, readdir, svc_max_payload(resp->rqstp));  in nfsd4_encode_readdir()
4579 	struct nfsd4_remove *remove = &u->remove;  in nfsd4_encode_remove()
4580 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_remove()
4582 	return nfsd4_encode_change_info4(xdr, &remove->rm_cinfo);  in nfsd4_encode_remove()
4589 	struct nfsd4_rename *rename = &u->rename;  in nfsd4_encode_rename()
4590 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_rename()
4592 	nfserr = nfsd4_encode_change_info4(xdr, &rename->rn_sinfo);  in nfsd4_encode_rename()
4595 	return nfsd4_encode_change_info4(xdr, &rename->rn_tinfo);  in nfsd4_encode_rename()
4605 	if (xdr_stream_encode_opaque(xdr, info->oid.data, info->oid.len) < 0)  in nfsd4_encode_rpcsec_gss_info()
4608 	status = nfsd4_encode_qop4(xdr, info->qop);  in nfsd4_encode_rpcsec_gss_info()
4612 	if (xdr_stream_encode_u32(xdr, info->service) != XDR_UNIT)  in nfsd4_encode_rpcsec_gss_info()
4628 	if (exp->ex_nflavors) {  in nfsd4_do_encode_secinfo()
4629 		flavs = exp->ex_flavors;  in nfsd4_do_encode_secinfo()
4630 		nflavs = exp->ex_nflavors;  in nfsd4_do_encode_secinfo()
4633 		if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) {  in nfsd4_do_encode_secinfo()
4637 		} else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) {  in nfsd4_do_encode_secinfo()
4640 					= svcauth_gss_flavor(exp->ex_client);  in nfsd4_do_encode_secinfo()
4644 					= exp->ex_client->flavour->flavour;  in nfsd4_do_encode_secinfo()
4692 	struct nfsd4_secinfo *secinfo = &u->secinfo;  in nfsd4_encode_secinfo()
4693 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_secinfo()
4695 	return nfsd4_do_encode_secinfo(xdr, secinfo->si_exp);  in nfsd4_encode_secinfo()
4702 	struct nfsd4_secinfo_no_name *secinfo = &u->secinfo_no_name;  in nfsd4_encode_secinfo_no_name()
4703 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_secinfo_no_name()
4705 	return nfsd4_do_encode_secinfo(xdr, secinfo->sin_exp);  in nfsd4_encode_secinfo_no_name()
4712 	struct nfsd4_setattr *setattr = &u->setattr;  in nfsd4_encode_setattr()
4718 		status = nfsd4_encode_bitmap4(resp->xdr, setattr->sa_bmval[0],  in nfsd4_encode_setattr()
4719 					      setattr->sa_bmval[1],  in nfsd4_encode_setattr()
4720 					      setattr->sa_bmval[2]);  in nfsd4_encode_setattr()
4724 		status = nfsd4_encode_bitmap4(resp->xdr, 0, 0, 0);  in nfsd4_encode_setattr()
4733 	struct nfsd4_setclientid *scd = &u->setclientid;  in nfsd4_encode_setclientid()
4734 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_setclientid()
4737 		nfserr = nfsd4_encode_clientid4(xdr, &scd->se_clientid);  in nfsd4_encode_setclientid()
4740 		nfserr = nfsd4_encode_verifier4(xdr, &scd->se_confirm);  in nfsd4_encode_setclientid()
4761 	struct nfsd4_write *write = &u->write;  in nfsd4_encode_write()
4762 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_write()
4765 	nfserr = nfsd4_encode_count4(xdr, write->wr_bytes_written);  in nfsd4_encode_write()
4769 	if (xdr_stream_encode_u32(xdr, write->wr_how_written) != XDR_UNIT)  in nfsd4_encode_write()
4772 	return nfsd4_encode_verifier4(xdr, &write->wr_verifier);  in nfsd4_encode_write()
4782 	status = nfsd4_encode_bitmap4(xdr, exid->spo_must_enforce[0],  in nfsd4_encode_state_protect_ops4()
4783 				      exid->spo_must_enforce[1],  in nfsd4_encode_state_protect_ops4()
4784 				      exid->spo_must_enforce[2]);  in nfsd4_encode_state_protect_ops4()
4788 	return nfsd4_encode_bitmap4(xdr, exid->spo_must_allow[0],  in nfsd4_encode_state_protect_ops4()
4789 				    exid->spo_must_allow[1],  in nfsd4_encode_state_protect_ops4()
4790 				    exid->spo_must_allow[2]);  in nfsd4_encode_state_protect_ops4()
4798 	if (xdr_stream_encode_u32(xdr, exid->spa_how) != XDR_UNIT)  in nfsd4_encode_state_protect4_r()
4800 	switch (exid->spa_how) {  in nfsd4_encode_state_protect4_r()
4825 	return nfsd4_encode_opaque(xdr, nn->nfsd_name, strlen(nn->nfsd_name));  in nfsd4_encode_server_owner4()
4832 	struct nfsd_net *nn = net_generic(SVC_NET(resp->rqstp), nfsd_net_id);  in nfsd4_encode_exchange_id()
4833 	struct nfsd4_exchange_id *exid = &u->exchange_id;  in nfsd4_encode_exchange_id()
4834 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_exchange_id()
4837 	nfserr = nfsd4_encode_clientid4(xdr, &exid->clientid);  in nfsd4_encode_exchange_id()
4841 	nfserr = nfsd4_encode_sequenceid4(xdr, exid->seqid);  in nfsd4_encode_exchange_id()
4845 	nfserr = nfsd4_encode_uint32_t(xdr, exid->flags);  in nfsd4_encode_exchange_id()
4853 	nfserr = nfsd4_encode_server_owner4(xdr, resp->rqstp);  in nfsd4_encode_exchange_id()
4857 	nfserr = nfsd4_encode_opaque(xdr, nn->nfsd_name,  in nfsd4_encode_exchange_id()
4858 				     strlen(nn->nfsd_name));  in nfsd4_encode_exchange_id()
4879 	status = nfsd4_encode_count4(xdr, attrs->maxreq_sz);  in nfsd4_encode_channel_attrs4()
4883 	status = nfsd4_encode_count4(xdr, attrs->maxresp_sz);  in nfsd4_encode_channel_attrs4()
4887 	status = nfsd4_encode_count4(xdr, attrs->maxresp_cached);  in nfsd4_encode_channel_attrs4()
4891 	status = nfsd4_encode_count4(xdr, attrs->maxops);  in nfsd4_encode_channel_attrs4()
4895 	status = nfsd4_encode_count4(xdr, attrs->maxreqs);  in nfsd4_encode_channel_attrs4()
4899 	if (xdr_stream_encode_u32(xdr, attrs->nr_rdma_attrs) != XDR_UNIT)  in nfsd4_encode_channel_attrs4()
4901 	if (attrs->nr_rdma_attrs)  in nfsd4_encode_channel_attrs4()
4902 		return nfsd4_encode_uint32_t(xdr, attrs->rdma_attrs);  in nfsd4_encode_channel_attrs4()
4910 	struct nfsd4_create_session *sess = &u->create_session;  in nfsd4_encode_create_session()
4911 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_create_session()
4914 	nfserr = nfsd4_encode_sessionid4(xdr, &sess->sessionid);  in nfsd4_encode_create_session()
4918 	nfserr = nfsd4_encode_sequenceid4(xdr, sess->seqid);  in nfsd4_encode_create_session()
4922 	nfserr = nfsd4_encode_uint32_t(xdr, sess->flags);  in nfsd4_encode_create_session()
4926 	nfserr = nfsd4_encode_channel_attrs4(xdr, &sess->fore_channel);  in nfsd4_encode_create_session()
4930 	return nfsd4_encode_channel_attrs4(xdr, &sess->back_channel);  in nfsd4_encode_create_session()
4937 	struct nfsd4_sequence *seq = &u->sequence;  in nfsd4_encode_sequence()
4938 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_sequence()
4941 	nfserr = nfsd4_encode_sessionid4(xdr, &seq->sessionid);  in nfsd4_encode_sequence()
4945 	nfserr = nfsd4_encode_sequenceid4(xdr, seq->seqid);  in nfsd4_encode_sequence()
4949 	nfserr = nfsd4_encode_slotid4(xdr, seq->slotid);  in nfsd4_encode_sequence()
4954 	nfserr = nfsd4_encode_slotid4(xdr, seq->maxslots - 1);  in nfsd4_encode_sequence()
4958 	nfserr = nfsd4_encode_slotid4(xdr, seq->maxslots - 1);  in nfsd4_encode_sequence()
4962 	nfserr = nfsd4_encode_uint32_t(xdr, seq->status_flags);  in nfsd4_encode_sequence()
4966 	resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */  in nfsd4_encode_sequence()
4974 	struct nfsd4_test_stateid *test_stateid = &u->test_stateid;  in nfsd4_encode_test_stateid()
4976 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_test_stateid()
4979 	if (xdr_stream_encode_u32(xdr, test_stateid->ts_num_ids) != XDR_UNIT)  in nfsd4_encode_test_stateid()
4982 				 &test_stateid->ts_stateid_list, ts_id_list) {  in nfsd4_encode_test_stateid()
4983 		if (xdr_stream_encode_be32(xdr, stateid->ts_id_status) != XDR_UNIT)  in nfsd4_encode_test_stateid()
4993 	struct nfsd4_get_dir_delegation *gdd = &u->get_dir_delegation;  in nfsd4_encode_get_dir_delegation()
4994 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_get_dir_delegation()
4997 	switch(gdd->gddrnf_status) {  in nfsd4_encode_get_dir_delegation()
5001 		status = nfsd4_encode_verifier4(xdr, &gdd->gddr_cookieverf);  in nfsd4_encode_get_dir_delegation()
5004 		status = nfsd4_encode_stateid4(xdr, &gdd->gddr_stateid);  in nfsd4_encode_get_dir_delegation()
5007 		status = nfsd4_encode_bitmap4(xdr, gdd->gddr_notification[0], 0, 0);  in nfsd4_encode_get_dir_delegation()
5010 		status = nfsd4_encode_bitmap4(xdr, gdd->gddr_child_attributes[0],  in nfsd4_encode_get_dir_delegation()
5011 						   gdd->gddr_child_attributes[1],  in nfsd4_encode_get_dir_delegation()
5012 						   gdd->gddr_child_attributes[2]);  in nfsd4_encode_get_dir_delegation()
5015 		status = nfsd4_encode_bitmap4(xdr, gdd->gddr_dir_attributes[0],  in nfsd4_encode_get_dir_delegation()
5016 						   gdd->gddr_dir_attributes[1],  in nfsd4_encode_get_dir_delegation()
5017 						   gdd->gddr_dir_attributes[2]);  in nfsd4_encode_get_dir_delegation()
5020 		pr_warn("nfsd: bad gddrnf_status (%u)\n", gdd->gddrnf_status);  in nfsd4_encode_get_dir_delegation()
5021 		gdd->gddrnf_will_signal_deleg_avail = 0;  in nfsd4_encode_get_dir_delegation()
5026 		status = nfsd4_encode_bool(xdr, gdd->gddrnf_will_signal_deleg_avail);  in nfsd4_encode_get_dir_delegation()
5037 	u32 needed_len, starting_len = xdr->buf->len;  in nfsd4_encode_device_addr4()
5042 	if (xdr_stream_encode_u32(xdr, gdev->gd_layout_type) != XDR_UNIT)  in nfsd4_encode_device_addr4()
5045 	ops = nfsd4_layout_ops[gdev->gd_layout_type];  in nfsd4_encode_device_addr4()
5046 	status = ops->encode_getdeviceinfo(xdr, gdev);  in nfsd4_encode_device_addr4()
5053 		if (xdr->buf->len + XDR_UNIT > gdev->gd_maxcount)  in nfsd4_encode_device_addr4()
5061 	needed_len = xdr->buf->len + XDR_UNIT;	/* notifications */  in nfsd4_encode_device_addr4()
5074 	struct nfsd4_getdeviceinfo *gdev = &u->getdeviceinfo;  in nfsd4_encode_getdeviceinfo()
5075 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_getdeviceinfo()
5082 	return nfsd4_encode_bitmap4(xdr, gdev->gd_notify_types, 0, 0);  in nfsd4_encode_getdeviceinfo()
5088 	const struct nfsd4_layout_ops *ops = nfsd4_layout_ops[lgp->lg_layout_type];  in nfsd4_encode_layout4()
5092 	status = nfsd4_encode_offset4(xdr, lgp->lg_seg.offset);  in nfsd4_encode_layout4()
5096 	status = nfsd4_encode_length4(xdr, lgp->lg_seg.length);  in nfsd4_encode_layout4()
5100 	if (xdr_stream_encode_u32(xdr, lgp->lg_seg.iomode) != XDR_UNIT)  in nfsd4_encode_layout4()
5103 	if (xdr_stream_encode_u32(xdr, lgp->lg_layout_type) != XDR_UNIT)  in nfsd4_encode_layout4()
5105 	return ops->encode_layoutget(xdr, lgp);  in nfsd4_encode_layout4()
5112 	struct nfsd4_layoutget *lgp = &u->layoutget;  in nfsd4_encode_layoutget()
5113 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_layoutget()
5120 	nfserr = nfsd4_encode_stateid4(xdr, &lgp->lg_sid);  in nfsd4_encode_layoutget()
5133 	struct nfsd4_layoutcommit *lcp = &u->layoutcommit;  in nfsd4_encode_layoutcommit()
5134 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_layoutcommit()
5137 	nfserr = nfsd4_encode_bool(xdr, lcp->lc_size_chg);  in nfsd4_encode_layoutcommit()
5140 	if (lcp->lc_size_chg)  in nfsd4_encode_layoutcommit()
5142 		return nfsd4_encode_length4(xdr, lcp->lc_newsize);  in nfsd4_encode_layoutcommit()
5150 	struct nfsd4_layoutreturn *lrp = &u->layoutreturn;  in nfsd4_encode_layoutreturn()
5151 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_layoutreturn()
5154 	nfserr = nfsd4_encode_bool(xdr, lrp->lrs_present);  in nfsd4_encode_layoutreturn()
5157 	if (lrp->lrs_present)  in nfsd4_encode_layoutreturn()
5159 		return nfsd4_encode_stateid4(xdr, &lrp->lr_sid);  in nfsd4_encode_layoutreturn()
5168 	const struct nfsd42_write_res *write = &copy->cp_res;  in nfsd4_encode_write_response4()
5176 		status = nfsd4_encode_stateid4(xdr, &write->cb_stateid);  in nfsd4_encode_write_response4()
5182 	status = nfsd4_encode_length4(xdr, write->wr_bytes_written);  in nfsd4_encode_write_response4()
5186 	if (xdr_stream_encode_u32(xdr, write->wr_stable_how) != XDR_UNIT)  in nfsd4_encode_write_response4()
5189 	return nfsd4_encode_verifier4(xdr, &write->wr_verifier);  in nfsd4_encode_write_response4()
5209 	struct nfsd4_copy *copy = &u->copy;  in nfsd4_encode_copy()
5211 	nfserr = nfsd4_encode_write_response4(resp->xdr, copy);  in nfsd4_encode_copy()
5214 	return nfsd4_encode_copy_requirements4(resp->xdr, copy);  in nfsd4_encode_copy()
5222 	if (xdr_stream_encode_u32(xdr, ns->nl4_type) != XDR_UNIT)  in nfsd4_encode_netloc4()
5224 	switch (ns->nl4_type) {  in nfsd4_encode_netloc4()
5227 		status = nfsd4_encode_netaddr4(xdr, &ns->u.nl4_addr);  in nfsd4_encode_netloc4()
5239 	struct nfsd4_copy_notify *cn = &u->copy_notify;  in nfsd4_encode_copy_notify()
5240 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_copy_notify()
5243 	nfserr = nfsd4_encode_nfstime4(xdr, &cn->cpn_lease_time);  in nfsd4_encode_copy_notify()
5247 	nfserr = nfsd4_encode_stateid4(xdr, &cn->cpn_cnr_stateid);  in nfsd4_encode_copy_notify()
5253 	return nfsd4_encode_netloc4(xdr, cn->cpn_src);  in nfsd4_encode_copy_notify()
5260 	struct nfsd4_offload_status *os = &u->offload_status;  in nfsd4_encode_offload_status()
5261 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_offload_status()
5264 	nfserr = nfsd4_encode_length4(xdr, os->count);  in nfsd4_encode_offload_status()
5268 	if (os->completed) {  in nfsd4_encode_offload_status()
5271 		if (xdr_stream_encode_be32(xdr, os->status) != XDR_UNIT)  in nfsd4_encode_offload_status()
5282 	struct nfsd4_compoundargs *argp = resp->rqstp->rq_argp;  in nfsd4_encode_read_plus_data()
5283 	struct file *file = read->rd_nf->nf_file;  in nfsd4_encode_read_plus_data()
5284 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_read_plus_data()
5285 	bool splice_ok = argp->splice_ok;  in nfsd4_encode_read_plus_data()
5293 	if (resp->xdr->buf->page_len && splice_ok) {  in nfsd4_encode_read_plus_data()
5298 	maxcount = min_t(unsigned long, read->rd_length,  in nfsd4_encode_read_plus_data()
5299 			 (xdr->buf->buflen - xdr->buf->len));  in nfsd4_encode_read_plus_data()
5301 	if (file->f_op->splice_read && splice_ok)  in nfsd4_encode_read_plus_data()
5309 	p = xdr_encode_hyper(p, read->rd_offset);  in nfsd4_encode_read_plus_data()
5310 	*p = cpu_to_be32(read->rd_length);  in nfsd4_encode_read_plus_data()
5319 	struct nfsd4_read *read = &u->read;  in nfsd4_encode_read_plus()
5320 	struct file *file = read->rd_nf->nf_file;  in nfsd4_encode_read_plus()
5321 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_read_plus()
5322 	int starting_len = xdr->buf->len;  in nfsd4_encode_read_plus()
5335 	read->rd_eof = read->rd_offset >= i_size_read(file_inode(file));  in nfsd4_encode_read_plus()
5336 	if (read->rd_eof)  in nfsd4_encode_read_plus()
5348 	p = xdr_encode_bool(p, read->rd_eof);  in nfsd4_encode_read_plus()
5357 	struct nfsd4_seek *seek = &u->seek;  in nfsd4_encode_seek()
5358 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_seek()
5361 	nfserr = nfsd4_encode_bool(xdr, seek->seek_eof);  in nfsd4_encode_seek()
5365 	return nfsd4_encode_offset4(xdr, seek->seek_pos);  in nfsd4_encode_seek()
5376  * Encode kmalloc-ed buffer in to XDR stream.
5385 		      ((void *)xdr->end - (void *)xdr->p));  in nfsd4_vbuf_to_stream()
5392 	buflen -= cplen;  in nfsd4_vbuf_to_stream()
5412 		buflen -= PAGE_SIZE;  in nfsd4_vbuf_to_stream()
5423 	struct nfsd4_getxattr *getxattr = &u->getxattr;  in nfsd4_encode_getxattr()
5424 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_getxattr()
5431 	*p = cpu_to_be32(getxattr->getxa_len);  in nfsd4_encode_getxattr()
5433 	if (getxattr->getxa_len == 0)  in nfsd4_encode_getxattr()
5436 	err = nfsd4_vbuf_to_stream(xdr, getxattr->getxa_buf,  in nfsd4_encode_getxattr()
5437 				    getxattr->getxa_len);  in nfsd4_encode_getxattr()
5439 	kvfree(getxattr->getxa_buf);  in nfsd4_encode_getxattr()
5448 	struct nfsd4_setxattr *setxattr = &u->setxattr;  in nfsd4_encode_setxattr()
5449 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_setxattr()
5451 	return nfsd4_encode_change_info4(xdr, &setxattr->setxa_cinfo);  in nfsd4_encode_setxattr()
5461 	u64 cookie = listxattrs->lsxa_cookie;  in nfsd4_listxattr_validate_cookie()
5467 	if (cookie > (listxattrs->lsxa_len) / (XATTR_USER_PREFIX_LEN + 2))  in nfsd4_listxattr_validate_cookie()
5478 	struct nfsd4_listxattrs *listxattrs = &u->listxattrs;  in nfsd4_encode_listxattrs()
5479 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_listxattrs()
5500 	cookie_offset = xdr->buf->len;  in nfsd4_encode_listxattrs()
5509 	left = listxattrs->lsxa_len;  in nfsd4_encode_listxattrs()
5510 	sp = listxattrs->lsxa_buf;  in nfsd4_encode_listxattrs()
5513 	/* Bytes left is maxcount - 8 (cookie) - 4 (array count) */  in nfsd4_encode_listxattrs()
5514 	xdrleft = listxattrs->lsxa_maxcount - XDR_UNIT * 3;  in nfsd4_encode_listxattrs()
5525 		slen -= XATTR_USER_PREFIX_LEN;  in nfsd4_encode_listxattrs()
5540 		left -= XATTR_USER_PREFIX_LEN;  in nfsd4_encode_listxattrs()
5554 		xdrleft -= xdrlen;  in nfsd4_encode_listxattrs()
5558 		left -= slen + 1;  in nfsd4_encode_listxattrs()
5581 	write_bytes_to_xdr_buf(xdr->buf, cookie_offset, &wire_cookie, 8);  in nfsd4_encode_listxattrs()
5583 	write_bytes_to_xdr_buf(xdr->buf, count_offset, &tmp, 4);  in nfsd4_encode_listxattrs()
5585 	if (listxattrs->lsxa_len)  in nfsd4_encode_listxattrs()
5586 		kvfree(listxattrs->lsxa_buf);  in nfsd4_encode_listxattrs()
5594 	struct nfsd4_removexattr *removexattr = &u->removexattr;  in nfsd4_encode_removexattr()
5595 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_removexattr()
5597 	return nfsd4_encode_change_info4(xdr, &removexattr->rmxa_cinfo);  in nfsd4_encode_removexattr()
5700  *     - For NFS versions >=4.1, the size of the reply must stay within
5702  *     - For all NFS versions, we must stay within limited preallocated
5712 	struct xdr_buf *buf = &resp->rqstp->rq_res;  in nfsd4_check_resp_size()
5713 	struct nfsd4_slot *slot = resp->cstate.slot;  in nfsd4_check_resp_size()
5715 	if (buf->len + respsize <= buf->buflen)  in nfsd4_check_resp_size()
5717 	if (!nfsd4_has_session(&resp->cstate))  in nfsd4_check_resp_size()
5719 	if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) {  in nfsd4_check_resp_size()
5732 		/* RFC 8881 - 15.1.2.9 */  in nfsd4_map_status()
5746 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_operation()
5747 	struct nfs4_stateowner *so = resp->cstate.replay_owner;  in nfsd4_encode_operation()
5748 	struct svc_rqst *rqstp = resp->rqstp;  in nfsd4_encode_operation()
5749 	const struct nfsd4_operation *opdesc = op->opdesc;  in nfsd4_encode_operation()
5757 	*p++ = cpu_to_be32(op->opnum);  in nfsd4_encode_operation()
5758 	post_err_offset = xdr->buf->len;  in nfsd4_encode_operation()
5760 	if (op->opnum == OP_ILLEGAL)  in nfsd4_encode_operation()
5762 	if (op->status && opdesc &&  in nfsd4_encode_operation()
5763 			!(opdesc->op_flags & OP_NONTRIVIAL_ERROR_ENCODE))  in nfsd4_encode_operation()
5765 	BUG_ON(op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||  in nfsd4_encode_operation()
5766 	       !nfsd4_enc_ops[op->opnum]);  in nfsd4_encode_operation()
5767 	encoder = nfsd4_enc_ops[op->opnum];  in nfsd4_encode_operation()
5768 	op->status = encoder(resp, op->status, &op->u);  in nfsd4_encode_operation()
5769 	if (op->status)  in nfsd4_encode_operation()
5770 		trace_nfsd_compound_encode_err(rqstp, op->opnum, op->status);  in nfsd4_encode_operation()
5774 	if (!op->status) {  in nfsd4_encode_operation()
5778 		op->status = nfsd4_check_resp_size(resp, space_needed);  in nfsd4_encode_operation()
5780 	if (op->status == nfserr_resource && nfsd4_has_session(&resp->cstate)) {  in nfsd4_encode_operation()
5781 		struct nfsd4_slot *slot = resp->cstate.slot;  in nfsd4_encode_operation()
5783 		if (slot->sl_flags & NFSD4_SLOT_CACHETHIS)  in nfsd4_encode_operation()
5784 			op->status = nfserr_rep_too_big_to_cache;  in nfsd4_encode_operation()
5786 			op->status = nfserr_rep_too_big;  in nfsd4_encode_operation()
5788 	if (op->status == nfserr_resource ||  in nfsd4_encode_operation()
5789 	    op->status == nfserr_rep_too_big ||  in nfsd4_encode_operation()
5790 	    op->status == nfserr_rep_too_big_to_cache) {  in nfsd4_encode_operation()
5796 		 * bug if we had to do this on a non-idempotent op:  in nfsd4_encode_operation()
5802 		int len = xdr->buf->len - post_err_offset;  in nfsd4_encode_operation()
5804 		so->so_replay.rp_status = op->status;  in nfsd4_encode_operation()
5805 		so->so_replay.rp_buflen = len;  in nfsd4_encode_operation()
5806 		read_bytes_from_xdr_buf(xdr->buf, post_err_offset,  in nfsd4_encode_operation()
5807 						so->so_replay.rp_buf, len);  in nfsd4_encode_operation()
5810 	op->status = nfsd4_map_status(op->status,  in nfsd4_encode_operation()
5811 				      resp->cstate.minorversion);  in nfsd4_encode_operation()
5812 	*p = op->status;  in nfsd4_encode_operation()
5814 	if (opdesc && opdesc->op_release)  in nfsd4_encode_operation()
5815 		opdesc->op_release(&op->u);  in nfsd4_encode_operation()
5821 	rqstp->rq_next_page = xdr->page_ptr + 1;  in nfsd4_encode_operation()
5825  * nfsd4_encode_replay - encode a result stored in the stateowner reply cache
5829  * @op->replay->rp_buf contains the previously-sent already-encoded result.
5833 	struct nfs4_replay *rp = op->replay;  in nfsd4_encode_replay()
5835 	trace_nfsd_stateowner_replay(op->opnum, rp);  in nfsd4_encode_replay()
5837 	if (xdr_stream_encode_u32(xdr, op->opnum) != XDR_UNIT)  in nfsd4_encode_replay()
5839 	if (xdr_stream_encode_be32(xdr, rp->rp_status) != XDR_UNIT)  in nfsd4_encode_replay()
5841 	xdr_stream_encode_opaque_fixed(xdr, rp->rp_buf, rp->rp_buflen);  in nfsd4_encode_replay()
5846 	struct nfsd4_compoundargs *args = rqstp->rq_argp;  in nfsd4_release_compoundargs()
5848 	if (args->ops != args->iops) {  in nfsd4_release_compoundargs()
5849 		vfree(args->ops);  in nfsd4_release_compoundargs()
5850 		args->ops = args->iops;  in nfsd4_release_compoundargs()
5852 	while (args->to_free) {  in nfsd4_release_compoundargs()
5853 		struct svcxdr_tmpbuf *tb = args->to_free;  in nfsd4_release_compoundargs()
5854 		args->to_free = tb->next;  in nfsd4_release_compoundargs()
5862 	struct nfsd4_compoundargs *args = rqstp->rq_argp;  in nfs4svc_decode_compoundargs()
5865 	args->to_free = NULL;  in nfs4svc_decode_compoundargs()
5867 	args->xdr = xdr;  in nfs4svc_decode_compoundargs()
5868 	args->ops = args->iops;  in nfs4svc_decode_compoundargs()
5869 	args->rqstp = rqstp;  in nfs4svc_decode_compoundargs()
5877 	struct nfsd4_compoundres *resp = rqstp->rq_resp;  in nfs4svc_encode_compoundres()
5884 	p = resp->statusp;  in nfs4svc_encode_compoundres()
5886 	*p++ = resp->cstate.status;  in nfs4svc_encode_compoundres()
5887 	*p++ = htonl(resp->taglen);  in nfs4svc_encode_compoundres()
5888 	memcpy(p, resp->tag, resp->taglen);  in nfs4svc_encode_compoundres()
5889 	p += XDR_QUADLEN(resp->taglen);  in nfs4svc_encode_compoundres()
5890 	*p++ = htonl(resp->opcnt);  in nfs4svc_encode_compoundres()