2  *  Server-side XDR for NFSv4
110 	return (clid->cl_boot == 0) && (clid->cl_id == 0);  in zero_clientid()
114  * svcxdr_tmpalloc - allocate memory to be freed after compound processing
129 	tb->next = argp->to_free;  in svcxdr_tmpalloc()
130 	argp->to_free = tb;  in svcxdr_tmpalloc()
131 	return tb->buf;  in svcxdr_tmpalloc()
136  * as null-terminated strings.
138  * Note null-terminating in place usually isn't safe since the
162 	if (p != argp->xdr->scratch.iov_base)  in svcxdr_savemem()
177  * This helper handles variable-length opaques which belong to protocol
185 	if (xdr_stream_decode_u32(argp->xdr, &len) < 0)  in nfsd4_decode_ignored_string()
189 	if (!xdr_inline_decode(argp->xdr, len))  in nfsd4_decode_ignored_string()
201 	if (xdr_stream_decode_u32(argp->xdr, &len) < 0)  in nfsd4_decode_opaque()
205 	p = xdr_inline_decode(argp->xdr, len);  in nfsd4_decode_opaque()
208 	o->data = svcxdr_savemem(argp, p, len);  in nfsd4_decode_opaque()
209 	if (!o->data)  in nfsd4_decode_opaque()
211 	o->len = len;  in nfsd4_decode_opaque()
221 	if (xdr_stream_decode_u32(argp->xdr, lenp) < 0)  in nfsd4_decode_component4()
223 	p = xdr_inline_decode(argp->xdr, *lenp);  in nfsd4_decode_component4()
241 	p = xdr_inline_decode(argp->xdr, XDR_UNIT * 3);  in nfsd4_decode_nfstime4()
244 	p = xdr_decode_hyper(p, &tv->tv_sec);  in nfsd4_decode_nfstime4()
245 	tv->tv_nsec = be32_to_cpup(p++);  in nfsd4_decode_nfstime4()
246 	if (tv->tv_nsec >= (u32)1000000000)  in nfsd4_decode_nfstime4()
256 	p = xdr_inline_decode(argp->xdr, NFS4_VERIFIER_SIZE);  in nfsd4_decode_verifier4()
259 	memcpy(verf->data, p, sizeof(verf->data));  in nfsd4_decode_verifier4()
264  * nfsd4_decode_bitmap4 - Decode an NFSv4 bitmap4
285 	status = xdr_stream_decode_uint32_array(argp->xdr, bmval, bmlen);  in nfsd4_decode_bitmap4()
286 	return status == -EBADMSG ? nfserr_bad_xdr : nfs_ok;  in nfsd4_decode_bitmap4()
295 	if (xdr_stream_decode_u32(argp->xdr, &ace->type) < 0)  in nfsd4_decode_nfsace4()
297 	if (xdr_stream_decode_u32(argp->xdr, &ace->flag) < 0)  in nfsd4_decode_nfsace4()
299 	if (xdr_stream_decode_u32(argp->xdr, &ace->access_mask) < 0)  in nfsd4_decode_nfsace4()
302 	if (xdr_stream_decode_u32(argp->xdr, &length) < 0)  in nfsd4_decode_nfsace4()
304 	p = xdr_inline_decode(argp->xdr, length);  in nfsd4_decode_nfsace4()
307 	ace->whotype = nfs4_acl_get_whotype((char *)p, length);  in nfsd4_decode_nfsace4()
308 	if (ace->whotype != NFS4_ACL_WHO_NAMED)  in nfsd4_decode_nfsace4()
310 	else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)  in nfsd4_decode_nfsace4()
311 		status = nfsd_map_name_to_gid(argp->rqstp,  in nfsd4_decode_nfsace4()
312 				(char *)p, length, &ace->who_gid);  in nfsd4_decode_nfsace4()
314 		status = nfsd_map_name_to_uid(argp->rqstp,  in nfsd4_decode_nfsace4()
315 				(char *)p, length, &ace->who_uid);  in nfsd4_decode_nfsace4()
328 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)  in nfsd4_decode_acl()
331 	if (count > xdr_stream_remaining(argp->xdr) / 20)  in nfsd4_decode_acl()
333 		 * Even with 4-byte names there wouldn't be  in nfsd4_decode_acl()
343 	(*acl)->naces = count;  in nfsd4_decode_acl()
344 	for (ace = (*acl)->aces; ace < (*acl)->aces + count; ace++) {  in nfsd4_decode_acl()
360 	if (xdr_stream_decode_u32(argp->xdr, &lfs) < 0)  in nfsd4_decode_security_label()
362 	if (xdr_stream_decode_u32(argp->xdr, &pi) < 0)  in nfsd4_decode_security_label()
365 	if (xdr_stream_decode_u32(argp->xdr, &length) < 0)  in nfsd4_decode_security_label()
369 	p = xdr_inline_decode(argp->xdr, length);  in nfsd4_decode_security_label()
372 	label->len = length;  in nfsd4_decode_security_label()
373 	label->data = svcxdr_dupstr(argp, p, length);  in nfsd4_decode_security_label()
374 	if (!label->data)  in nfsd4_decode_security_label()
389 	iattr->ia_valid = 0;  in nfsd4_decode_fattr4()
397 		if (nfsd_attrs_supported(argp->minorversion, bmval))  in nfsd4_decode_fattr4()
402 	if (xdr_stream_decode_u32(argp->xdr, &attrlist4_count) < 0)  in nfsd4_decode_fattr4()
404 	starting_pos = xdr_stream_pos(argp->xdr);  in nfsd4_decode_fattr4()
409 		if (xdr_stream_decode_u64(argp->xdr, &size) < 0)  in nfsd4_decode_fattr4()
411 		iattr->ia_size = size;  in nfsd4_decode_fattr4()
412 		iattr->ia_valid |= ATTR_SIZE;  in nfsd4_decode_fattr4()
423 		if (xdr_stream_decode_u32(argp->xdr, &mode) < 0)  in nfsd4_decode_fattr4()
425 		iattr->ia_mode = mode;  in nfsd4_decode_fattr4()
426 		iattr->ia_mode &= (S_IFMT | S_IALLUGO);  in nfsd4_decode_fattr4()
427 		iattr->ia_valid |= ATTR_MODE;  in nfsd4_decode_fattr4()
432 		if (xdr_stream_decode_u32(argp->xdr, &length) < 0)  in nfsd4_decode_fattr4()
434 		p = xdr_inline_decode(argp->xdr, length);  in nfsd4_decode_fattr4()
437 		status = nfsd_map_name_to_uid(argp->rqstp, (char *)p, length,  in nfsd4_decode_fattr4()
438 					      &iattr->ia_uid);  in nfsd4_decode_fattr4()
441 		iattr->ia_valid |= ATTR_UID;  in nfsd4_decode_fattr4()
446 		if (xdr_stream_decode_u32(argp->xdr, &length) < 0)  in nfsd4_decode_fattr4()
448 		p = xdr_inline_decode(argp->xdr, length);  in nfsd4_decode_fattr4()
451 		status = nfsd_map_name_to_gid(argp->rqstp, (char *)p, length,  in nfsd4_decode_fattr4()
452 					      &iattr->ia_gid);  in nfsd4_decode_fattr4()
455 		iattr->ia_valid |= ATTR_GID;  in nfsd4_decode_fattr4()
460 		if (xdr_stream_decode_u32(argp->xdr, &set_it) < 0)  in nfsd4_decode_fattr4()
464 			status = nfsd4_decode_nfstime4(argp, &iattr->ia_atime);  in nfsd4_decode_fattr4()
467 			iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET);  in nfsd4_decode_fattr4()
470 			iattr->ia_valid |= ATTR_ATIME;  in nfsd4_decode_fattr4()
488 		if (xdr_stream_decode_u32(argp->xdr, &set_it) < 0)  in nfsd4_decode_fattr4()
492 			status = nfsd4_decode_nfstime4(argp, &iattr->ia_mtime);  in nfsd4_decode_fattr4()
495 			iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET);  in nfsd4_decode_fattr4()
498 			iattr->ia_valid |= ATTR_MTIME;  in nfsd4_decode_fattr4()
504 	label->len = 0;  in nfsd4_decode_fattr4()
516 		if (xdr_stream_decode_u32(argp->xdr, &mode) < 0)  in nfsd4_decode_fattr4()
518 		iattr->ia_mode = mode & (S_IFMT | S_IALLUGO);  in nfsd4_decode_fattr4()
519 		if (xdr_stream_decode_u32(argp->xdr, &mask) < 0)  in nfsd4_decode_fattr4()
522 		iattr->ia_valid |= ATTR_MODE;  in nfsd4_decode_fattr4()
527 		if (!xdrgen_decode_fattr4_time_deleg_access(argp->xdr, &access))  in nfsd4_decode_fattr4()
529 		iattr->ia_atime.tv_sec = access.seconds;  in nfsd4_decode_fattr4()
530 		iattr->ia_atime.tv_nsec = access.nseconds;  in nfsd4_decode_fattr4()
531 		iattr->ia_valid |= ATTR_ATIME | ATTR_ATIME_SET | ATTR_DELEG;  in nfsd4_decode_fattr4()
536 		if (!xdrgen_decode_fattr4_time_deleg_modify(argp->xdr, &modify))  in nfsd4_decode_fattr4()
538 		iattr->ia_mtime.tv_sec = modify.seconds;  in nfsd4_decode_fattr4()
539 		iattr->ia_mtime.tv_nsec = modify.nseconds;  in nfsd4_decode_fattr4()
540 		iattr->ia_ctime.tv_sec = modify.seconds;  in nfsd4_decode_fattr4()
541 		iattr->ia_ctime.tv_nsec = modify.nseconds;  in nfsd4_decode_fattr4()
542 		iattr->ia_valid |= ATTR_CTIME | ATTR_CTIME_SET |  in nfsd4_decode_fattr4()
547 	if (attrlist4_count != xdr_stream_pos(argp->xdr) - starting_pos)  in nfsd4_decode_fattr4()
558 	p = xdr_inline_decode(argp->xdr, NFS4_STATEID_SIZE);  in nfsd4_decode_stateid4()
561 	sid->si_generation = be32_to_cpup(p++);  in nfsd4_decode_stateid4()
562 	memcpy(&sid->si_opaque, p, sizeof(sid->si_opaque));  in nfsd4_decode_stateid4()
571 	p = xdr_inline_decode(argp->xdr, sizeof(__be64));  in nfsd4_decode_clientid4()
598 	if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_layout_type) < 0)  in nfsd4_decode_layoutupdate4()
600 	if (lcp->lc_layout_type < LAYOUT_NFSV4_1_FILES)  in nfsd4_decode_layoutupdate4()
602 	if (lcp->lc_layout_type >= LAYOUT_TYPE_MAX)  in nfsd4_decode_layoutupdate4()
605 	if (xdr_stream_decode_u32(argp->xdr, &len) < 0)  in nfsd4_decode_layoutupdate4()
607 	if (!xdr_stream_subsegment(argp->xdr, &lcp->lc_up_layout, len))  in nfsd4_decode_layoutupdate4()
619 	if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_return_type) < 0)  in nfsd4_decode_layoutreturn4()
621 	switch (lrp->lr_return_type) {  in nfsd4_decode_layoutreturn4()
623 		if (xdr_stream_decode_u64(argp->xdr, &lrp->lr_seg.offset) < 0)  in nfsd4_decode_layoutreturn4()
625 		if (xdr_stream_decode_u64(argp->xdr, &lrp->lr_seg.length) < 0)  in nfsd4_decode_layoutreturn4()
627 		status = nfsd4_decode_stateid4(argp, &lrp->lr_sid);  in nfsd4_decode_layoutreturn4()
630 		if (xdr_stream_decode_u32(argp->xdr, &lrp->lrf_body_len) < 0)  in nfsd4_decode_layoutreturn4()
632 		if (lrp->lrf_body_len > 0) {  in nfsd4_decode_layoutreturn4()
633 			lrp->lrf_body = xdr_inline_decode(argp->xdr, lrp->lrf_body_len);  in nfsd4_decode_layoutreturn4()
634 			if (!lrp->lrf_body)  in nfsd4_decode_layoutreturn4()
640 		lrp->lr_seg.offset = 0;  in nfsd4_decode_layoutreturn4()
641 		lrp->lr_seg.length = NFS4_MAX_UINT64;  in nfsd4_decode_layoutreturn4()
658 	p = xdr_inline_decode(argp->xdr, NFS4_MAX_SESSIONID_LEN);  in nfsd4_decode_sessionid4()
661 	memcpy(sessionid->data, p, sizeof(sessionid->data));  in nfsd4_decode_sessionid4()
673 	if (xdr_stream_decode_u32(argp->xdr, &stamp) < 0)  in nfsd4_decode_authsys_parms()
679 	if (xdr_stream_decode_u32(argp->xdr, &uid) < 0)  in nfsd4_decode_authsys_parms()
681 	if (xdr_stream_decode_u32(argp->xdr, &gid) < 0)  in nfsd4_decode_authsys_parms()
683 	if (xdr_stream_decode_u32(argp->xdr, &gidcount) < 0)  in nfsd4_decode_authsys_parms()
687 	p = xdr_inline_decode(argp->xdr, gidcount << 2);  in nfsd4_decode_authsys_parms()
690 	if (cbs->flavor == (u32)(-1)) {  in nfsd4_decode_authsys_parms()
691 		struct user_namespace *userns = nfsd_user_namespace(argp->rqstp);  in nfsd4_decode_authsys_parms()
696 			cbs->uid = kuid;  in nfsd4_decode_authsys_parms()
697 			cbs->gid = kgid;  in nfsd4_decode_authsys_parms()
698 			cbs->flavor = RPC_AUTH_UNIX;  in nfsd4_decode_authsys_parms()
716 	if (xdr_stream_decode_u32(argp->xdr, &service) < 0)  in nfsd4_decode_gss_cb_handles4()
740 	if (xdr_stream_decode_u32(argp->xdr, &nr_secflavs) < 0)  in nfsd4_decode_cb_sec()
743 		cbs->flavor = (u32)(-1);  in nfsd4_decode_cb_sec()
746 		cbs->flavor = 0;  in nfsd4_decode_cb_sec()
749 		if (xdr_stream_decode_u32(argp->xdr, &secflavor) < 0)  in nfsd4_decode_cb_sec()
754 			if (cbs->flavor == (u32)(-1))  in nfsd4_decode_cb_sec()
755 				cbs->flavor = RPC_AUTH_NULL;  in nfsd4_decode_cb_sec()
784 	struct nfsd4_access *access = &u->access;  in nfsd4_decode_access()
785 	if (xdr_stream_decode_u32(argp->xdr, &access->ac_req_access) < 0)  in nfsd4_decode_access()
793 	struct nfsd4_close *close = &u->close;  in nfsd4_decode_close()
794 	if (xdr_stream_decode_u32(argp->xdr, &close->cl_seqid) < 0)  in nfsd4_decode_close()
796 	return nfsd4_decode_stateid4(argp, &close->cl_stateid);  in nfsd4_decode_close()
803 	struct nfsd4_commit *commit = &u->commit;  in nfsd4_decode_commit()
804 	if (xdr_stream_decode_u64(argp->xdr, &commit->co_offset) < 0)  in nfsd4_decode_commit()
806 	if (xdr_stream_decode_u32(argp->xdr, &commit->co_count) < 0)  in nfsd4_decode_commit()
808 	memset(&commit->co_verf, 0, sizeof(commit->co_verf));  in nfsd4_decode_commit()
815 	struct nfsd4_create *create = &u->create;  in nfsd4_decode_create()
819 	if (xdr_stream_decode_u32(argp->xdr, &create->cr_type) < 0)  in nfsd4_decode_create()
821 	switch (create->cr_type) {  in nfsd4_decode_create()
823 		if (xdr_stream_decode_u32(argp->xdr, &create->cr_datalen) < 0)  in nfsd4_decode_create()
825 		p = xdr_inline_decode(argp->xdr, create->cr_datalen);  in nfsd4_decode_create()
828 		create->cr_data = svcxdr_dupstr(argp, p, create->cr_datalen);  in nfsd4_decode_create()
829 		if (!create->cr_data)  in nfsd4_decode_create()
834 		if (xdr_stream_decode_u32(argp->xdr, &create->cr_specdata1) < 0)  in nfsd4_decode_create()
836 		if (xdr_stream_decode_u32(argp->xdr, &create->cr_specdata2) < 0)  in nfsd4_decode_create()
845 	status = nfsd4_decode_component4(argp, &create->cr_name,  in nfsd4_decode_create()
846 					 &create->cr_namelen);  in nfsd4_decode_create()
849 	status = nfsd4_decode_fattr4(argp, create->cr_bmval,  in nfsd4_decode_create()
850 				    ARRAY_SIZE(create->cr_bmval),  in nfsd4_decode_create()
851 				    &create->cr_iattr, &create->cr_acl,  in nfsd4_decode_create()
852 				    &create->cr_label, &create->cr_umask);  in nfsd4_decode_create()
862 	struct nfsd4_delegreturn *dr = &u->delegreturn;  in nfsd4_decode_delegreturn()
863 	return nfsd4_decode_stateid4(argp, &dr->dr_stateid);  in nfsd4_decode_delegreturn()
869 	struct nfsd4_getattr *getattr = &u->getattr;  in nfsd4_decode_getattr()
871 	return nfsd4_decode_bitmap4(argp, getattr->ga_bmval,  in nfsd4_decode_getattr()
872 				    ARRAY_SIZE(getattr->ga_bmval));  in nfsd4_decode_getattr()
878 	struct nfsd4_link *link = &u->link;  in nfsd4_decode_link()
880 	return nfsd4_decode_component4(argp, &link->li_name, &link->li_namelen);  in nfsd4_decode_link()
889 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_new_open_seqid) < 0)  in nfsd4_decode_open_to_lock_owner4()
891 	status = nfsd4_decode_stateid4(argp, &lock->lk_new_open_stateid);  in nfsd4_decode_open_to_lock_owner4()
894 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_new_lock_seqid) < 0)  in nfsd4_decode_open_to_lock_owner4()
896 	return nfsd4_decode_state_owner4(argp, &lock->lk_new_clientid,  in nfsd4_decode_open_to_lock_owner4()
897 					 &lock->lk_new_owner);  in nfsd4_decode_open_to_lock_owner4()
906 	status = nfsd4_decode_stateid4(argp, &lock->lk_old_lock_stateid);  in nfsd4_decode_exist_lock_owner4()
909 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_old_lock_seqid) < 0)  in nfsd4_decode_exist_lock_owner4()
918 	if (xdr_stream_decode_bool(argp->xdr, &lock->lk_is_new) < 0)  in nfsd4_decode_locker4()
920 	if (lock->lk_is_new)  in nfsd4_decode_locker4()
928 	struct nfsd4_lock *lock = &u->lock;  in nfsd4_decode_lock()
930 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_type) < 0)  in nfsd4_decode_lock()
932 	if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT))  in nfsd4_decode_lock()
934 	if (xdr_stream_decode_bool(argp->xdr, &lock->lk_reclaim) < 0)  in nfsd4_decode_lock()
936 	if (xdr_stream_decode_u64(argp->xdr, &lock->lk_offset) < 0)  in nfsd4_decode_lock()
938 	if (xdr_stream_decode_u64(argp->xdr, &lock->lk_length) < 0)  in nfsd4_decode_lock()
946 	struct nfsd4_lockt *lockt = &u->lockt;  in nfsd4_decode_lockt()
948 	if (xdr_stream_decode_u32(argp->xdr, &lockt->lt_type) < 0)  in nfsd4_decode_lockt()
950 	if ((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT))  in nfsd4_decode_lockt()
952 	if (xdr_stream_decode_u64(argp->xdr, &lockt->lt_offset) < 0)  in nfsd4_decode_lockt()
954 	if (xdr_stream_decode_u64(argp->xdr, &lockt->lt_length) < 0)  in nfsd4_decode_lockt()
956 	return nfsd4_decode_state_owner4(argp, &lockt->lt_clientid,  in nfsd4_decode_lockt()
957 					 &lockt->lt_owner);  in nfsd4_decode_lockt()
963 	struct nfsd4_locku *locku = &u->locku;  in nfsd4_decode_locku()
966 	if (xdr_stream_decode_u32(argp->xdr, &locku->lu_type) < 0)  in nfsd4_decode_locku()
968 	if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT))  in nfsd4_decode_locku()
970 	if (xdr_stream_decode_u32(argp->xdr, &locku->lu_seqid) < 0)  in nfsd4_decode_locku()
972 	status = nfsd4_decode_stateid4(argp, &locku->lu_stateid);  in nfsd4_decode_locku()
975 	if (xdr_stream_decode_u64(argp->xdr, &locku->lu_offset) < 0)  in nfsd4_decode_locku()
977 	if (xdr_stream_decode_u64(argp->xdr, &locku->lu_length) < 0)  in nfsd4_decode_locku()
986 	struct nfsd4_lookup *lookup = &u->lookup;  in nfsd4_decode_lookup()
987 	return nfsd4_decode_component4(argp, &lookup->lo_name, &lookup->lo_len);  in nfsd4_decode_lookup()
995 	if (xdr_stream_decode_u32(argp->xdr, &open->op_createmode) < 0)  in nfsd4_decode_createhow4()
997 	switch (open->op_createmode) {  in nfsd4_decode_createhow4()
1000 		status = nfsd4_decode_fattr4(argp, open->op_bmval,  in nfsd4_decode_createhow4()
1001 					     ARRAY_SIZE(open->op_bmval),  in nfsd4_decode_createhow4()
1002 					     &open->op_iattr, &open->op_acl,  in nfsd4_decode_createhow4()
1003 					     &open->op_label, &open->op_umask);  in nfsd4_decode_createhow4()
1008 		status = nfsd4_decode_verifier4(argp, &open->op_verf);  in nfsd4_decode_createhow4()
1013 		if (argp->minorversion < 1)  in nfsd4_decode_createhow4()
1015 		status = nfsd4_decode_verifier4(argp, &open->op_verf);  in nfsd4_decode_createhow4()
1018 		status = nfsd4_decode_fattr4(argp, open->op_bmval,  in nfsd4_decode_createhow4()
1019 					     ARRAY_SIZE(open->op_bmval),  in nfsd4_decode_createhow4()
1020 					     &open->op_iattr, &open->op_acl,  in nfsd4_decode_createhow4()
1021 					     &open->op_label, &open->op_umask);  in nfsd4_decode_createhow4()
1037 	if (xdr_stream_decode_u32(argp->xdr, &open->op_create) < 0)  in nfsd4_decode_openflag4()
1039 	switch (open->op_create) {  in nfsd4_decode_openflag4()
1058 	if (xdr_stream_decode_u32(argp->xdr, &w) < 0)  in nfsd4_decode_share_access()
1076 	if (!argp->minorversion)  in nfsd4_decode_share_access()
1107 	if (xdr_stream_decode_u32(argp->xdr, x) < 0)  in nfsd4_decode_share_deny()
1122 	if (xdr_stream_decode_u32(argp->xdr, &open->op_claim_type) < 0)  in nfsd4_decode_open_claim4()
1124 	switch (open->op_claim_type) {  in nfsd4_decode_open_claim4()
1127 		status = nfsd4_decode_component4(argp, &open->op_fname,  in nfsd4_decode_open_claim4()
1128 						 &open->op_fnamelen);  in nfsd4_decode_open_claim4()
1133 		if (xdr_stream_decode_u32(argp->xdr, &open->op_delegate_type) < 0)  in nfsd4_decode_open_claim4()
1137 		status = nfsd4_decode_stateid4(argp, &open->op_delegate_stateid);  in nfsd4_decode_open_claim4()
1140 		status = nfsd4_decode_component4(argp, &open->op_fname,  in nfsd4_decode_open_claim4()
1141 						 &open->op_fnamelen);  in nfsd4_decode_open_claim4()
1147 		if (argp->minorversion < 1)  in nfsd4_decode_open_claim4()
1152 		if (argp->minorversion < 1)  in nfsd4_decode_open_claim4()
1154 		status = nfsd4_decode_stateid4(argp, &open->op_delegate_stateid);  in nfsd4_decode_open_claim4()
1168 	struct nfsd4_open *open = &u->open;  in nfsd4_decode_open()
1174 	if (xdr_stream_decode_u32(argp->xdr, &open->op_seqid) < 0)  in nfsd4_decode_open()
1177 	status = nfsd4_decode_share_access(argp, &open->op_share_access,  in nfsd4_decode_open()
1178 					   &open->op_deleg_want, &dummy);  in nfsd4_decode_open()
1181 	status = nfsd4_decode_share_deny(argp, &open->op_share_deny);  in nfsd4_decode_open()
1184 	status = nfsd4_decode_state_owner4(argp, &open->op_clientid,  in nfsd4_decode_open()
1185 					   &open->op_owner);  in nfsd4_decode_open()
1198 	struct nfsd4_open_confirm *open_conf = &u->open_confirm;  in nfsd4_decode_open_confirm()
1201 	if (argp->minorversion >= 1)  in nfsd4_decode_open_confirm()
1204 	status = nfsd4_decode_stateid4(argp, &open_conf->oc_req_stateid);  in nfsd4_decode_open_confirm()
1207 	if (xdr_stream_decode_u32(argp->xdr, &open_conf->oc_seqid) < 0)  in nfsd4_decode_open_confirm()
1210 	memset(&open_conf->oc_resp_stateid, 0,  in nfsd4_decode_open_confirm()
1211 	       sizeof(open_conf->oc_resp_stateid));  in nfsd4_decode_open_confirm()
1219 	struct nfsd4_open_downgrade *open_down = &u->open_downgrade;  in nfsd4_decode_open_downgrade()
1223 	status = nfsd4_decode_stateid4(argp, &open_down->od_stateid);  in nfsd4_decode_open_downgrade()
1226 	if (xdr_stream_decode_u32(argp->xdr, &open_down->od_seqid) < 0)  in nfsd4_decode_open_downgrade()
1229 	status = nfsd4_decode_share_access(argp, &open_down->od_share_access,  in nfsd4_decode_open_downgrade()
1230 					   &open_down->od_deleg_want, NULL);  in nfsd4_decode_open_downgrade()
1233 	return nfsd4_decode_share_deny(argp, &open_down->od_share_deny);  in nfsd4_decode_open_downgrade()
1239 	struct nfsd4_putfh *putfh = &u->putfh;  in nfsd4_decode_putfh()
1242 	if (xdr_stream_decode_u32(argp->xdr, &putfh->pf_fhlen) < 0)  in nfsd4_decode_putfh()
1244 	if (putfh->pf_fhlen > NFS4_FHSIZE)  in nfsd4_decode_putfh()
1246 	p = xdr_inline_decode(argp->xdr, putfh->pf_fhlen);  in nfsd4_decode_putfh()
1249 	putfh->pf_fhval = svcxdr_savemem(argp, p, putfh->pf_fhlen);  in nfsd4_decode_putfh()
1250 	if (!putfh->pf_fhval)  in nfsd4_decode_putfh()
1253 	putfh->no_verify = false;  in nfsd4_decode_putfh()
1260 	struct nfsd4_read *read = &u->read;  in nfsd4_decode_read()
1264 	status = nfsd4_decode_stateid4(argp, &read->rd_stateid);  in nfsd4_decode_read()
1267 	if (xdr_stream_decode_u64(argp->xdr, &read->rd_offset) < 0)  in nfsd4_decode_read()
1269 	if (xdr_stream_decode_u32(argp->xdr, &read->rd_length) < 0)  in nfsd4_decode_read()
1278 	struct nfsd4_readdir *readdir = &u->readdir;  in nfsd4_decode_readdir()
1282 	if (xdr_stream_decode_u64(argp->xdr, &readdir->rd_cookie) < 0)  in nfsd4_decode_readdir()
1284 	status = nfsd4_decode_verifier4(argp, &readdir->rd_verf);  in nfsd4_decode_readdir()
1287 	if (xdr_stream_decode_u32(argp->xdr, &readdir->rd_dircount) < 0)  in nfsd4_decode_readdir()
1289 	if (xdr_stream_decode_u32(argp->xdr, &readdir->rd_maxcount) < 0)  in nfsd4_decode_readdir()
1291 	if (xdr_stream_decode_uint32_array(argp->xdr, readdir->rd_bmval,  in nfsd4_decode_readdir()
1292 					   ARRAY_SIZE(readdir->rd_bmval)) < 0)  in nfsd4_decode_readdir()
1301 	struct nfsd4_remove *remove = &u->remove;  in nfsd4_decode_remove()
1302 	memset(&remove->rm_cinfo, 0, sizeof(remove->rm_cinfo));  in nfsd4_decode_remove()
1303 	return nfsd4_decode_component4(argp, &remove->rm_name, &remove->rm_namelen);  in nfsd4_decode_remove()
1309 	struct nfsd4_rename *rename = &u->rename;  in nfsd4_decode_rename()
1313 	status = nfsd4_decode_component4(argp, &rename->rn_sname, &rename->rn_snamelen);  in nfsd4_decode_rename()
1316 	return nfsd4_decode_component4(argp, &rename->rn_tname, &rename->rn_tnamelen);  in nfsd4_decode_rename()
1322 	clientid_t *clientid = &u->renew;  in nfsd4_decode_renew()
1330 	struct nfsd4_secinfo *secinfo = &u->secinfo;  in nfsd4_decode_secinfo()
1331 	secinfo->si_exp = NULL;  in nfsd4_decode_secinfo()
1332 	return nfsd4_decode_component4(argp, &secinfo->si_name, &secinfo->si_namelen);  in nfsd4_decode_secinfo()
1338 	struct nfsd4_setattr *setattr = &u->setattr;  in nfsd4_decode_setattr()
1342 	status = nfsd4_decode_stateid4(argp, &setattr->sa_stateid);  in nfsd4_decode_setattr()
1345 	return nfsd4_decode_fattr4(argp, setattr->sa_bmval,  in nfsd4_decode_setattr()
1346 				   ARRAY_SIZE(setattr->sa_bmval),  in nfsd4_decode_setattr()
1347 				   &setattr->sa_iattr, &setattr->sa_acl,  in nfsd4_decode_setattr()
1348 				   &setattr->sa_label, NULL);  in nfsd4_decode_setattr()
1354 	struct nfsd4_setclientid *setclientid = &u->setclientid;  in nfsd4_decode_setclientid()
1359 	if (argp->minorversion >= 1)  in nfsd4_decode_setclientid()
1362 	status = nfsd4_decode_verifier4(argp, &setclientid->se_verf);  in nfsd4_decode_setclientid()
1365 	status = nfsd4_decode_opaque(argp, &setclientid->se_name);  in nfsd4_decode_setclientid()
1368 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_prog) < 0)  in nfsd4_decode_setclientid()
1370 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_netid_len) < 0)  in nfsd4_decode_setclientid()
1372 	p = xdr_inline_decode(argp->xdr, setclientid->se_callback_netid_len);  in nfsd4_decode_setclientid()
1375 	setclientid->se_callback_netid_val = svcxdr_savemem(argp, p,  in nfsd4_decode_setclientid()
1376 						setclientid->se_callback_netid_len);  in nfsd4_decode_setclientid()
1377 	if (!setclientid->se_callback_netid_val)  in nfsd4_decode_setclientid()
1380 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_addr_len) < 0)  in nfsd4_decode_setclientid()
1382 	p = xdr_inline_decode(argp->xdr, setclientid->se_callback_addr_len);  in nfsd4_decode_setclientid()
1385 	setclientid->se_callback_addr_val = svcxdr_savemem(argp, p,  in nfsd4_decode_setclientid()
1386 						setclientid->se_callback_addr_len);  in nfsd4_decode_setclientid()
1387 	if (!setclientid->se_callback_addr_val)  in nfsd4_decode_setclientid()
1389 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_ident) < 0)  in nfsd4_decode_setclientid()
1399 	struct nfsd4_setclientid_confirm *scd_c = &u->setclientid_confirm;  in nfsd4_decode_setclientid_confirm()
1402 	if (argp->minorversion >= 1)  in nfsd4_decode_setclientid_confirm()
1405 	status = nfsd4_decode_clientid4(argp, &scd_c->sc_clientid);  in nfsd4_decode_setclientid_confirm()
1408 	return nfsd4_decode_verifier4(argp, &scd_c->sc_confirm);  in nfsd4_decode_setclientid_confirm()
1415 	struct nfsd4_verify *verify = &u->verify;  in nfsd4_decode_verify()
1420 	status = nfsd4_decode_bitmap4(argp, verify->ve_bmval,  in nfsd4_decode_verify()
1421 				      ARRAY_SIZE(verify->ve_bmval));  in nfsd4_decode_verify()
1428 	if (xdr_stream_decode_u32(argp->xdr, &verify->ve_attrlen) < 0)  in nfsd4_decode_verify()
1430 	p = xdr_inline_decode(argp->xdr, verify->ve_attrlen);  in nfsd4_decode_verify()
1433 	verify->ve_attrval = svcxdr_savemem(argp, p, verify->ve_attrlen);  in nfsd4_decode_verify()
1434 	if (!verify->ve_attrval)  in nfsd4_decode_verify()
1443 	struct nfsd4_write *write = &u->write;  in nfsd4_decode_write()
1446 	status = nfsd4_decode_stateid4(argp, &write->wr_stateid);  in nfsd4_decode_write()
1449 	if (xdr_stream_decode_u64(argp->xdr, &write->wr_offset) < 0)  in nfsd4_decode_write()
1451 	if (xdr_stream_decode_u32(argp->xdr, &write->wr_stable_how) < 0)  in nfsd4_decode_write()
1453 	if (write->wr_stable_how > NFS_FILE_SYNC)  in nfsd4_decode_write()
1455 	if (xdr_stream_decode_u32(argp->xdr, &write->wr_buflen) < 0)  in nfsd4_decode_write()
1457 	if (!xdr_stream_subsegment(argp->xdr, &write->wr_payload, write->wr_buflen))  in nfsd4_decode_write()
1460 	write->wr_bytes_written = 0;  in nfsd4_decode_write()
1461 	write->wr_how_written = 0;  in nfsd4_decode_write()
1462 	memset(&write->wr_verifier, 0, sizeof(write->wr_verifier));  in nfsd4_decode_write()
1470 	struct nfsd4_release_lockowner *rlockowner = &u->release_lockowner;  in nfsd4_decode_release_lockowner()
1473 	if (argp->minorversion >= 1)  in nfsd4_decode_release_lockowner()
1476 	status = nfsd4_decode_state_owner4(argp, &rlockowner->rl_clientid,  in nfsd4_decode_release_lockowner()
1477 					   &rlockowner->rl_owner);  in nfsd4_decode_release_lockowner()
1481 	if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid))  in nfsd4_decode_release_lockowner()
1490 	struct nfsd4_backchannel_ctl *bc = &u->backchannel_ctl;  in nfsd4_decode_backchannel_ctl()
1492 	if (xdr_stream_decode_u32(argp->xdr, &bc->bc_cb_program) < 0)  in nfsd4_decode_backchannel_ctl()
1494 	return nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec);  in nfsd4_decode_backchannel_ctl()
1500 	struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session;  in nfsd4_decode_bind_conn_to_session()
1505 	status = nfsd4_decode_sessionid4(argp, &bcts->sessionid);  in nfsd4_decode_bind_conn_to_session()
1508 	if (xdr_stream_decode_u32(argp->xdr, &bcts->dir) < 0)  in nfsd4_decode_bind_conn_to_session()
1510 	if (xdr_stream_decode_u32(argp->xdr, &use_conn_in_rdma_mode) < 0)  in nfsd4_decode_bind_conn_to_session()
1522 	status = nfsd4_decode_bitmap4(argp, exid->spo_must_enforce,  in nfsd4_decode_state_protect_ops()
1523 				      ARRAY_SIZE(exid->spo_must_enforce));  in nfsd4_decode_state_protect_ops()
1526 	status = nfsd4_decode_bitmap4(argp, exid->spo_must_allow,  in nfsd4_decode_state_protect_ops()
1527 				      ARRAY_SIZE(exid->spo_must_allow));  in nfsd4_decode_state_protect_ops()
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()
1560 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)  in nfsd4_decode_ssv_sp_parms()
1562 	while (count--) {  in nfsd4_decode_ssv_sp_parms()
1568 	if (xdr_stream_decode_u32(argp->xdr, &window) < 0)  in nfsd4_decode_ssv_sp_parms()
1570 	if (xdr_stream_decode_u32(argp->xdr, &num_gss_handles) < 0)  in nfsd4_decode_ssv_sp_parms()
1582 	if (xdr_stream_decode_u32(argp->xdr, &exid->spa_how) < 0)  in nfsd4_decode_state_protect4_a()
1584 	switch (exid->spa_how) {  in nfsd4_decode_state_protect4_a()
1611 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)  in nfsd4_decode_nfs_impl_id4()
1620 		status = nfsd4_decode_opaque(argp, &exid->nii_domain);  in nfsd4_decode_nfs_impl_id4()
1626 		status = nfsd4_decode_opaque(argp, &exid->nii_name);  in nfsd4_decode_nfs_impl_id4()
1629 		status = nfsd4_decode_nfstime4(argp, &exid->nii_time);  in nfsd4_decode_nfs_impl_id4()
1644 	struct nfsd4_exchange_id *exid = &u->exchange_id;  in nfsd4_decode_exchange_id()
1648 	status = nfsd4_decode_verifier4(argp, &exid->verifier);  in nfsd4_decode_exchange_id()
1651 	status = nfsd4_decode_opaque(argp, &exid->clname);  in nfsd4_decode_exchange_id()
1654 	if (xdr_stream_decode_u32(argp->xdr, &exid->flags) < 0)  in nfsd4_decode_exchange_id()
1668 	p = xdr_inline_decode(argp->xdr, XDR_UNIT * 7);  in nfsd4_decode_channel_attrs4()
1674 	ca->maxreq_sz = be32_to_cpup(p++);  in nfsd4_decode_channel_attrs4()
1675 	ca->maxresp_sz = be32_to_cpup(p++);  in nfsd4_decode_channel_attrs4()
1676 	ca->maxresp_cached = be32_to_cpup(p++);  in nfsd4_decode_channel_attrs4()
1677 	ca->maxops = be32_to_cpup(p++);  in nfsd4_decode_channel_attrs4()
1678 	ca->maxreqs = be32_to_cpup(p++);  in nfsd4_decode_channel_attrs4()
1679 	ca->nr_rdma_attrs = be32_to_cpup(p);  in nfsd4_decode_channel_attrs4()
1680 	switch (ca->nr_rdma_attrs) {  in nfsd4_decode_channel_attrs4()
1684 		if (xdr_stream_decode_u32(argp->xdr, &ca->rdma_attrs) < 0)  in nfsd4_decode_channel_attrs4()
1698 	struct nfsd4_create_session *sess = &u->create_session;  in nfsd4_decode_create_session()
1702 	status = nfsd4_decode_clientid4(argp, &sess->clientid);  in nfsd4_decode_create_session()
1705 	if (xdr_stream_decode_u32(argp->xdr, &sess->seqid) < 0)  in nfsd4_decode_create_session()
1707 	if (xdr_stream_decode_u32(argp->xdr, &sess->flags) < 0)  in nfsd4_decode_create_session()
1709 	status = nfsd4_decode_channel_attrs4(argp, &sess->fore_channel);  in nfsd4_decode_create_session()
1712 	status = nfsd4_decode_channel_attrs4(argp, &sess->back_channel);  in nfsd4_decode_create_session()
1715 	if (xdr_stream_decode_u32(argp->xdr, &sess->callback_prog) < 0)  in nfsd4_decode_create_session()
1717 	return nfsd4_decode_cb_sec(argp, &sess->cb_sec);  in nfsd4_decode_create_session()
1724 	struct nfsd4_destroy_session *destroy_session = &u->destroy_session;  in nfsd4_decode_destroy_session()
1725 	return nfsd4_decode_sessionid4(argp, &destroy_session->sessionid);  in nfsd4_decode_destroy_session()
1732 	struct nfsd4_free_stateid *free_stateid = &u->free_stateid;  in nfsd4_decode_free_stateid()
1733 	return nfsd4_decode_stateid4(argp, &free_stateid->fr_stateid);  in nfsd4_decode_free_stateid()
1740 	struct nfsd4_get_dir_delegation *gdd = &u->get_dir_delegation;  in nfsd4_decode_get_dir_delegation()
1745 	if (xdr_stream_decode_bool(argp->xdr, &gdd->gdda_signal_deleg_avail) < 0)  in nfsd4_decode_get_dir_delegation()
1747 	status = nfsd4_decode_bitmap4(argp, gdd->gdda_notification_types,  in nfsd4_decode_get_dir_delegation()
1748 				      ARRAY_SIZE(gdd->gdda_notification_types));  in nfsd4_decode_get_dir_delegation()
1751 	status = nfsd4_decode_nfstime4(argp, &gdd->gdda_child_attr_delay);  in nfsd4_decode_get_dir_delegation()
1754 	status = nfsd4_decode_nfstime4(argp, &gdd->gdda_dir_attr_delay);  in nfsd4_decode_get_dir_delegation()
1757 	status = nfsd4_decode_bitmap4(argp, gdd->gdda_child_attributes,  in nfsd4_decode_get_dir_delegation()
1758 					ARRAY_SIZE(gdd->gdda_child_attributes));  in nfsd4_decode_get_dir_delegation()
1761 	return nfsd4_decode_bitmap4(argp, gdd->gdda_dir_attributes,  in nfsd4_decode_get_dir_delegation()
1762 					ARRAY_SIZE(gdd->gdda_dir_attributes));  in nfsd4_decode_get_dir_delegation()
1770 	struct nfsd4_getdeviceinfo *gdev = &u->getdeviceinfo;  in nfsd4_decode_getdeviceinfo()
1774 	status = nfsd4_decode_deviceid4(argp->xdr, &gdev->gd_devid);  in nfsd4_decode_getdeviceinfo()
1777 	if (xdr_stream_decode_u32(argp->xdr, &gdev->gd_layout_type) < 0)  in nfsd4_decode_getdeviceinfo()
1779 	if (xdr_stream_decode_u32(argp->xdr, &gdev->gd_maxcount) < 0)  in nfsd4_decode_getdeviceinfo()
1781 	if (xdr_stream_decode_uint32_array(argp->xdr,  in nfsd4_decode_getdeviceinfo()
1782 					   &gdev->gd_notify_types, 1) < 0)  in nfsd4_decode_getdeviceinfo()
1792 	struct nfsd4_layoutcommit *lcp = &u->layoutcommit;  in nfsd4_decode_layoutcommit()
1796 	if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_seg.offset) < 0)  in nfsd4_decode_layoutcommit()
1798 	if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_seg.length) < 0)  in nfsd4_decode_layoutcommit()
1800 	if (xdr_stream_decode_bool(argp->xdr, &lcp->lc_reclaim) < 0)  in nfsd4_decode_layoutcommit()
1802 	status = nfsd4_decode_stateid4(argp, &lcp->lc_sid);  in nfsd4_decode_layoutcommit()
1805 	if (xdr_stream_decode_bool(argp->xdr, &lcp->lc_newoffset) < 0)  in nfsd4_decode_layoutcommit()
1807 	if (lcp->lc_newoffset) {  in nfsd4_decode_layoutcommit()
1808 		if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_last_wr) < 0)  in nfsd4_decode_layoutcommit()
1811 		lcp->lc_last_wr = 0;  in nfsd4_decode_layoutcommit()
1812 	p = xdr_inline_decode(argp->xdr, XDR_UNIT);  in nfsd4_decode_layoutcommit()
1816 		status = nfsd4_decode_nfstime4(argp, &lcp->lc_mtime);  in nfsd4_decode_layoutcommit()
1820 		lcp->lc_mtime.tv_nsec = UTIME_NOW;  in nfsd4_decode_layoutcommit()
1829 	struct nfsd4_layoutget *lgp = &u->layoutget;  in nfsd4_decode_layoutget()
1833 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_signal) < 0)  in nfsd4_decode_layoutget()
1835 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_layout_type) < 0)  in nfsd4_decode_layoutget()
1837 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_seg.iomode) < 0)  in nfsd4_decode_layoutget()
1839 	if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_seg.offset) < 0)  in nfsd4_decode_layoutget()
1841 	if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_seg.length) < 0)  in nfsd4_decode_layoutget()
1843 	if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_minlength) < 0)  in nfsd4_decode_layoutget()
1845 	status = nfsd4_decode_stateid4(argp, &lgp->lg_sid);  in nfsd4_decode_layoutget()
1848 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_maxcount) < 0)  in nfsd4_decode_layoutget()
1858 	struct nfsd4_layoutreturn *lrp = &u->layoutreturn;  in nfsd4_decode_layoutreturn()
1860 	if (xdr_stream_decode_bool(argp->xdr, &lrp->lr_reclaim) < 0)  in nfsd4_decode_layoutreturn()
1862 	if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_layout_type) < 0)  in nfsd4_decode_layoutreturn()
1864 	if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_seg.iomode) < 0)  in nfsd4_decode_layoutreturn()
1873 	struct nfsd4_secinfo_no_name *sin = &u->secinfo_no_name;  in nfsd4_decode_secinfo_no_name()
1874 	if (xdr_stream_decode_u32(argp->xdr, &sin->sin_style) < 0)  in nfsd4_decode_secinfo_no_name()
1877 	sin->sin_exp = NULL;  in nfsd4_decode_secinfo_no_name()
1885 	struct nfsd4_sequence *seq = &u->sequence;  in nfsd4_decode_sequence()
1888 	status = nfsd4_decode_sessionid4(argp, &seq->sessionid);  in nfsd4_decode_sequence()
1891 	p = xdr_inline_decode(argp->xdr, XDR_UNIT * 4);  in nfsd4_decode_sequence()
1894 	seq->seqid = be32_to_cpup(p++);  in nfsd4_decode_sequence()
1895 	seq->slotid = be32_to_cpup(p++);  in nfsd4_decode_sequence()
1897 	seq->maxslots = be32_to_cpup(p++) + 1;  in nfsd4_decode_sequence()
1898 	seq->cachethis = be32_to_cpup(p);  in nfsd4_decode_sequence()
1900 	seq->status_flags = 0;  in nfsd4_decode_sequence()
1908 	struct nfsd4_test_stateid *test_stateid = &u->test_stateid;  in nfsd4_decode_test_stateid()
1914 	if (xdr_stream_decode_u32(argp->xdr, &test_stateid->ts_num_ids) < 0)  in nfsd4_decode_test_stateid()
1917 	INIT_LIST_HEAD(&test_stateid->ts_stateid_list);  in nfsd4_decode_test_stateid()
1918 	for (i = 0; i < test_stateid->ts_num_ids; i++) {  in nfsd4_decode_test_stateid()
1922 		INIT_LIST_HEAD(&stateid->ts_id_list);  in nfsd4_decode_test_stateid()
1923 		list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list);  in nfsd4_decode_test_stateid()
1924 		status = nfsd4_decode_stateid4(argp, &stateid->ts_id_stateid);  in nfsd4_decode_test_stateid()
1935 	struct nfsd4_destroy_clientid *dc = &u->destroy_clientid;  in nfsd4_decode_destroy_clientid()
1936 	return nfsd4_decode_clientid4(argp, &dc->clientid);  in nfsd4_decode_destroy_clientid()
1942 	struct nfsd4_reclaim_complete *rc = &u->reclaim_complete;  in nfsd4_decode_reclaim_complete()
1943 	if (xdr_stream_decode_bool(argp->xdr, &rc->rca_one_fs) < 0)  in nfsd4_decode_reclaim_complete()
1952 	struct nfsd4_fallocate *fallocate = &u->allocate;  in nfsd4_decode_fallocate()
1955 	status = nfsd4_decode_stateid4(argp, &fallocate->falloc_stateid);  in nfsd4_decode_fallocate()
1958 	if (xdr_stream_decode_u64(argp->xdr, &fallocate->falloc_offset) < 0)  in nfsd4_decode_fallocate()
1960 	if (xdr_stream_decode_u64(argp->xdr, &fallocate->falloc_length) < 0)  in nfsd4_decode_fallocate()
1972 	if (xdr_stream_decode_u32(argp->xdr, &ns->nl4_type) < 0)  in nfsd4_decode_nl4_server()
1975 	/* currently support for 1 inter-server source server */  in nfsd4_decode_nl4_server()
1976 	switch (ns->nl4_type) {  in nfsd4_decode_nl4_server()
1978 		naddr = &ns->u.nl4_addr;  in nfsd4_decode_nl4_server()
1980 		if (xdr_stream_decode_u32(argp->xdr, &naddr->netid_len) < 0)  in nfsd4_decode_nl4_server()
1982 		if (naddr->netid_len > RPCBIND_MAXNETIDLEN)  in nfsd4_decode_nl4_server()
1985 		p = xdr_inline_decode(argp->xdr, naddr->netid_len);  in nfsd4_decode_nl4_server()
1988 		memcpy(naddr->netid, p, naddr->netid_len);  in nfsd4_decode_nl4_server()
1990 		if (xdr_stream_decode_u32(argp->xdr, &naddr->addr_len) < 0)  in nfsd4_decode_nl4_server()
1992 		if (naddr->addr_len > RPCBIND_MAXUADDRLEN)  in nfsd4_decode_nl4_server()
1995 		p = xdr_inline_decode(argp->xdr, naddr->addr_len);  in nfsd4_decode_nl4_server()
1998 		memcpy(naddr->addr, p, naddr->addr_len);  in nfsd4_decode_nl4_server()
2010 	struct nfsd4_copy *copy = &u->copy;  in nfsd4_decode_copy()
2016 	status = nfsd4_decode_stateid4(argp, &copy->cp_src_stateid);  in nfsd4_decode_copy()
2019 	status = nfsd4_decode_stateid4(argp, &copy->cp_dst_stateid);  in nfsd4_decode_copy()
2022 	if (xdr_stream_decode_u64(argp->xdr, &copy->cp_src_pos) < 0)  in nfsd4_decode_copy()
2024 	if (xdr_stream_decode_u64(argp->xdr, &copy->cp_dst_pos) < 0)  in nfsd4_decode_copy()
2026 	if (xdr_stream_decode_u64(argp->xdr, &copy->cp_count) < 0)  in nfsd4_decode_copy()
2029 	if (xdr_stream_decode_u32(argp->xdr, &consecutive) < 0)  in nfsd4_decode_copy()
2031 	if (xdr_stream_decode_bool(argp->xdr, &sync) < 0)  in nfsd4_decode_copy()
2035 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)  in nfsd4_decode_copy()
2037 	copy->cp_src = svcxdr_tmpalloc(argp, sizeof(*copy->cp_src));  in nfsd4_decode_copy()
2038 	if (copy->cp_src == NULL)  in nfsd4_decode_copy()
2040 	if (count == 0) { /* intra-server copy */  in nfsd4_decode_copy()
2041 		__set_bit(NFSD4_COPY_F_INTRA, &copy->cp_flags);  in nfsd4_decode_copy()
2046 	status = nfsd4_decode_nl4_server(argp, copy->cp_src);  in nfsd4_decode_copy()
2053 	for (i = 0; i < count - 1; i++) {  in nfsd4_decode_copy()
2069 	struct nfsd4_copy_notify *cn = &u->copy_notify;  in nfsd4_decode_copy_notify()
2073 	cn->cpn_src = svcxdr_tmpalloc(argp, sizeof(*cn->cpn_src));  in nfsd4_decode_copy_notify()
2074 	if (cn->cpn_src == NULL)  in nfsd4_decode_copy_notify()
2076 	cn->cpn_dst = svcxdr_tmpalloc(argp, sizeof(*cn->cpn_dst));  in nfsd4_decode_copy_notify()
2077 	if (cn->cpn_dst == NULL)  in nfsd4_decode_copy_notify()
2080 	status = nfsd4_decode_stateid4(argp, &cn->cpn_src_stateid);  in nfsd4_decode_copy_notify()
2083 	return nfsd4_decode_nl4_server(argp, cn->cpn_dst);  in nfsd4_decode_copy_notify()
2090 	struct nfsd4_offload_status *os = &u->offload_status;  in nfsd4_decode_offload_status()
2091 	os->count = 0;  in nfsd4_decode_offload_status()
2092 	os->status = 0;  in nfsd4_decode_offload_status()
2093 	return nfsd4_decode_stateid4(argp, &os->stateid);  in nfsd4_decode_offload_status()
2099 	struct nfsd4_seek *seek = &u->seek;  in nfsd4_decode_seek()
2102 	status = nfsd4_decode_stateid4(argp, &seek->seek_stateid);  in nfsd4_decode_seek()
2105 	if (xdr_stream_decode_u64(argp->xdr, &seek->seek_offset) < 0)  in nfsd4_decode_seek()
2107 	if (xdr_stream_decode_u32(argp->xdr, &seek->seek_whence) < 0)  in nfsd4_decode_seek()
2110 	seek->seek_eof = 0;  in nfsd4_decode_seek()
2111 	seek->seek_pos = 0;  in nfsd4_decode_seek()
2118 	struct nfsd4_clone *clone = &u->clone;  in nfsd4_decode_clone()
2121 	status = nfsd4_decode_stateid4(argp, &clone->cl_src_stateid);  in nfsd4_decode_clone()
2124 	status = nfsd4_decode_stateid4(argp, &clone->cl_dst_stateid);  in nfsd4_decode_clone()
2127 	if (xdr_stream_decode_u64(argp->xdr, &clone->cl_src_pos) < 0)  in nfsd4_decode_clone()
2129 	if (xdr_stream_decode_u64(argp->xdr, &clone->cl_dst_pos) < 0)  in nfsd4_decode_clone()
2131 	if (xdr_stream_decode_u64(argp->xdr, &clone->cl_count) < 0)  in nfsd4_decode_clone()
2142  * is 64k). Since there is no kvec- or page-based interface to xattrs,
2153 	struct page **pages = xdr->pages;  in nfsd4_vbuf_from_vector()
2154 	struct kvec *head = xdr->head;  in nfsd4_vbuf_from_vector()
2158 	if (buflen <= head->iov_len) {  in nfsd4_vbuf_from_vector()
2163 		*bufp = head->iov_base;  in nfsd4_vbuf_from_vector()
2172 	memcpy(dp, head->iov_base, head->iov_len);  in nfsd4_vbuf_from_vector()
2173 	buflen -= head->iov_len;  in nfsd4_vbuf_from_vector()
2174 	dp += head->iov_len;  in nfsd4_vbuf_from_vector()
2180 		buflen -= len;  in nfsd4_vbuf_from_vector()
2201 	if (xdr_stream_decode_u32(argp->xdr, &namelen) < 0)  in nfsd4_decode_xattr_name()
2203 	if (namelen > (XATTR_NAME_MAX - XATTR_USER_PREFIX_LEN))  in nfsd4_decode_xattr_name()
2207 	p = xdr_inline_decode(argp->xdr, namelen);  in nfsd4_decode_xattr_name()
2223 	while (cnt-- > 0) {  in nfsd4_decode_xattr_name()
2245 	struct nfsd4_getxattr *getxattr = &u->getxattr;  in nfsd4_decode_getxattr()
2250 	status = nfsd4_decode_xattr_name(argp, &getxattr->getxa_name);  in nfsd4_decode_getxattr()
2254 	maxcount = svc_max_payload(argp->rqstp);  in nfsd4_decode_getxattr()
2257 	getxattr->getxa_len = maxcount;  in nfsd4_decode_getxattr()
2265 	struct nfsd4_setxattr *setxattr = &u->setxattr;  in nfsd4_decode_setxattr()
2271 	if (xdr_stream_decode_u32(argp->xdr, &flags) < 0)  in nfsd4_decode_setxattr()
2276 	setxattr->setxa_flags = flags;  in nfsd4_decode_setxattr()
2278 	status = nfsd4_decode_xattr_name(argp, &setxattr->setxa_name);  in nfsd4_decode_setxattr()
2282 	maxcount = svc_max_payload(argp->rqstp);  in nfsd4_decode_setxattr()
2285 	if (xdr_stream_decode_u32(argp->xdr, &size) < 0)  in nfsd4_decode_setxattr()
2290 	setxattr->setxa_len = size;  in nfsd4_decode_setxattr()
2294 		if (!xdr_stream_subsegment(argp->xdr, &payload, size))  in nfsd4_decode_setxattr()
2297 						&setxattr->setxa_buf, size);  in nfsd4_decode_setxattr()
2307 	struct nfsd4_listxattrs *listxattrs = &u->listxattrs;  in nfsd4_decode_listxattrs()
2312 	if (xdr_stream_decode_u64(argp->xdr, &listxattrs->lsxa_cookie) < 0)  in nfsd4_decode_listxattrs()
2319 	if (listxattrs->lsxa_cookie >=  in nfsd4_decode_listxattrs()
2323 	if (xdr_stream_decode_u32(argp->xdr, &maxcount) < 0)  in nfsd4_decode_listxattrs()
2329 	maxcount = min(maxcount, svc_max_payload(argp->rqstp));  in nfsd4_decode_listxattrs()
2330 	listxattrs->lsxa_maxcount = maxcount;  in nfsd4_decode_listxattrs()
2339 	struct nfsd4_removexattr *removexattr = &u->removexattr;  in nfsd4_decode_removexattr()
2341 	return nfsd4_decode_xattr_name(argp, &removexattr->rmxa_name);  in nfsd4_decode_removexattr()
2450 	if (op->opnum < FIRST_NFS4_OP)  in nfsd4_opnum_in_range()
2452 	else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP)  in nfsd4_opnum_in_range()
2454 	else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP)  in nfsd4_opnum_in_range()
2456 	else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP)  in nfsd4_opnum_in_range()
2466 	int auth_slack= argp->rqstp->rq_auth_slack;  in nfsd4_decode_compound()
2473 	if (xdr_stream_decode_u32(argp->xdr, &argp->taglen) < 0)  in nfsd4_decode_compound()
2476 	argp->tag = NULL;  in nfsd4_decode_compound()
2477 	if (unlikely(argp->taglen)) {  in nfsd4_decode_compound()
2478 		if (argp->taglen > NFSD4_MAX_TAGLEN)  in nfsd4_decode_compound()
2480 		p = xdr_inline_decode(argp->xdr, argp->taglen);  in nfsd4_decode_compound()
2483 		argp->tag = svcxdr_savemem(argp, p, argp->taglen);  in nfsd4_decode_compound()
2484 		if (!argp->tag)  in nfsd4_decode_compound()
2486 		max_reply += xdr_align_size(argp->taglen);  in nfsd4_decode_compound()
2489 	if (xdr_stream_decode_u32(argp->xdr, &argp->minorversion) < 0)  in nfsd4_decode_compound()
2491 	if (xdr_stream_decode_u32(argp->xdr, &argp->client_opcnt) < 0)  in nfsd4_decode_compound()
2493 	argp->opcnt = min_t(u32, argp->client_opcnt,  in nfsd4_decode_compound()
2496 	if (argp->opcnt > ARRAY_SIZE(argp->iops)) {  in nfsd4_decode_compound()
2497 		argp->ops = vcalloc(argp->opcnt, sizeof(*argp->ops));  in nfsd4_decode_compound()
2498 		if (!argp->ops) {  in nfsd4_decode_compound()
2499 			argp->ops = argp->iops;  in nfsd4_decode_compound()
2504 	if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION)  in nfsd4_decode_compound()
2505 		argp->opcnt = 0;  in nfsd4_decode_compound()
2507 	for (i = 0; i < argp->opcnt; i++) {  in nfsd4_decode_compound()
2508 		op = &argp->ops[i];  in nfsd4_decode_compound()
2509 		op->replay = NULL;  in nfsd4_decode_compound()
2510 		op->opdesc = NULL;  in nfsd4_decode_compound()
2512 		if (xdr_stream_decode_u32(argp->xdr, &op->opnum) < 0)  in nfsd4_decode_compound()
2515 			op->opdesc = OPDESC(op);  in nfsd4_decode_compound()
2516 			op->status = nfsd4_dec_ops[op->opnum](argp, &op->u);  in nfsd4_decode_compound()
2517 			if (op->status != nfs_ok)  in nfsd4_decode_compound()
2518 				trace_nfsd_compound_decode_err(argp->rqstp,  in nfsd4_decode_compound()
2519 							       argp->opcnt, i,  in nfsd4_decode_compound()
2520 							       op->opnum,  in nfsd4_decode_compound()
2521 							       op->status);  in nfsd4_decode_compound()
2523 			op->opnum = OP_ILLEGAL;  in nfsd4_decode_compound()
2524 			op->status = nfserr_op_illegal;  in nfsd4_decode_compound()
2533 		if (op->opnum == OP_READ || op->opnum == OP_READ_PLUS) {  in nfsd4_decode_compound()
2535 			readbytes += nfsd4_max_reply(argp->rqstp, op);  in nfsd4_decode_compound()
2537 			max_reply += nfsd4_max_reply(argp->rqstp, op);  in nfsd4_decode_compound()
2540 		 * (Special case because it will just skip encoding this  in nfsd4_decode_compound()
2544 		if (op->opnum == OP_LOCK || op->opnum == OP_LOCKT)  in nfsd4_decode_compound()
2547 		if (op->status) {  in nfsd4_decode_compound()
2548 			argp->opcnt = i+1;  in nfsd4_decode_compound()
2553 	if (argp->minorversion)  in nfsd4_decode_compound()
2555 	svc_reserve_auth(argp->rqstp, max_reply + readbytes);  in nfsd4_decode_compound()
2556 	argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE;  in nfsd4_decode_compound()
2558 	argp->splice_ok = nfsd_read_splice_ok(argp->rqstp);  in nfsd4_decode_compound()
2559 	if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack)  in nfsd4_decode_compound()
2560 		argp->splice_ok = false;  in nfsd4_decode_compound()
2568 	return nfsd4_encode_opaque(xdr, fh_handle->fh_raw, fh_handle->fh_size);  in nfsd4_encode_nfs_fh4()
2571 /* This is a frequently-encoded type; open-coded for speed */
2580 	p = xdr_encode_hyper(p, tv->tv_sec);  in nfsd4_encode_nfstime4()
2581 	*p = cpu_to_be32(tv->tv_nsec);  in nfsd4_encode_nfstime4()
2601 	status = nfsd4_encode_bool(xdr, c->atomic);  in nfsd4_encode_change_info4()
2604 	status = nfsd4_encode_changeid4(xdr, c->before_change);  in nfsd4_encode_change_info4()
2607 	return nfsd4_encode_changeid4(xdr, c->after_change);  in nfsd4_encode_change_info4()
2616 	status = nfsd4_encode_opaque(xdr, addr->netid, addr->netid_len);  in nfsd4_encode_netaddr4()
2620 	return nfsd4_encode_opaque(xdr, addr->addr, addr->addr_len);  in nfsd4_encode_netaddr4()
2636 	pathlen_offset = xdr->buf->len;  in nfsd4_encode_components_esc()
2662 			if (xdr_stream_encode_opaque(xdr, str, end - str) < 0)  in nfsd4_encode_components_esc()
2673 	write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4);  in nfsd4_encode_components_esc()
2691 	status = nfsd4_encode_components_esc(xdr, ':', location->hosts,  in nfsd4_encode_fs_location4()
2695 	status = nfsd4_encode_components(xdr, '/', location->path);  in nfsd4_encode_fs_location4()
2719 		if (cur.dentry == cur.mnt->mnt_root) {  in nfsd4_encode_pathname4()
2741 		struct dentry *dentry = components[ncomponents - 1];  in nfsd4_encode_pathname4()
2743 		spin_lock(&dentry->d_lock);  in nfsd4_encode_pathname4()
2744 		if (xdr_stream_encode_opaque(xdr, dentry->d_name.name,  in nfsd4_encode_pathname4()
2745 					     dentry->d_name.len) < 0) {  in nfsd4_encode_pathname4()
2746 			spin_unlock(&dentry->d_lock);  in nfsd4_encode_pathname4()
2750 		spin_unlock(&dentry->d_lock);  in nfsd4_encode_pathname4()
2752 		ncomponents--;  in nfsd4_encode_pathname4()
2759 		dput(components[--ncomponents]);  in nfsd4_encode_pathname4()
2769 	struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs;  in nfsd4_encode_fs_locations4()
2778 	status = nfsd4_encode_pathname4(xdr, &exp_ps->ex_path, &exp->ex_path);  in nfsd4_encode_fs_locations4()
2784 	if (xdr_stream_encode_u32(xdr, fslocs->locations_count) != XDR_UNIT)  in nfsd4_encode_fs_locations4()
2786 	for (i = 0; i < fslocs->locations_count; i++) {  in nfsd4_encode_fs_locations4()
2787 		status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]);  in nfsd4_encode_fs_locations4()
2801 	status = nfsd4_encode_acetype4(xdr, ace->type);  in nfsd4_encode_nfsace4()
2805 	status = nfsd4_encode_aceflag4(xdr, ace->flag);  in nfsd4_encode_nfsace4()
2809 	status = nfsd4_encode_acemask4(xdr, ace->access_mask & NFS4_ACE_MASK_ALL);  in nfsd4_encode_nfsace4()
2813 	if (ace->whotype != NFS4_ACL_WHO_NAMED)  in nfsd4_encode_nfsace4()
2814 		return nfs4_acl_write_who(xdr, ace->whotype);  in nfsd4_encode_nfsace4()
2815 	if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)  in nfsd4_encode_nfsace4()
2816 		return nfsd4_encode_group(xdr, rqstp, ace->who_gid);  in nfsd4_encode_nfsace4()
2817 	return nfsd4_encode_user(xdr, rqstp, ace->who_uid);  in nfsd4_encode_nfsace4()
2832 	p = xdr_reserve_space(xdr, context->len + 4 + 4 + 4);  in nfsd4_encode_security_label()
2842 	p = xdr_encode_opaque(p, context->context, context->len);  in nfsd4_encode_security_label()
2872 	struct path path = exp->ex_path;  in nfsd4_get_mounted_on_ino()
2878 		if (path.dentry != path.mnt->mnt_root)  in nfsd4_get_mounted_on_ino()
2968 	struct nfsd4_compoundres *resp = args->rqstp->rq_resp;  in nfsd4_encode_fattr4_supported_attrs()
2969 	u32 minorversion = resp->cstate.minorversion;  in nfsd4_encode_fattr4_supported_attrs()
2973 	if (!IS_POSIXACL(d_inode(args->dentry)))  in nfsd4_encode_fattr4_supported_attrs()
2975 	if (!args->contextsupport)  in nfsd4_encode_fattr4_supported_attrs()
2990 	switch (args->stat.mode & S_IFMT) {  in nfsd4_encode_fattr4_type()
3025 	if (!(args->exp->ex_flags & NFSEXP_NOSUBTREECHECK))  in nfsd4_encode_fattr4_fh_expire_type()
3033 	const struct svc_export *exp = args->exp;  in nfsd4_encode_fattr4_change()
3035 	if (unlikely(exp->ex_flags & NFSEXP_V4ROOT)) {  in nfsd4_encode_fattr4_change()
3036 		u32 flush_time = convert_to_wallclock(exp->cd->flush_time);  in nfsd4_encode_fattr4_change()
3044 	return nfsd4_encode_changeid4(xdr, args->change_attr);  in nfsd4_encode_fattr4_change()
3050 	return nfsd4_encode_uint64_t(xdr, args->stat.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()
3397 	struct inode *inode = d_inode(args->dentry);  in nfsd4_encode_fattr4_clone_blksize()
3399 	return nfsd4_encode_uint32_t(xdr, inode->i_sb->s_blocksize);  in nfsd4_encode_fattr4_clone_blksize()
3406 	return nfsd4_encode_security_label(xdr, args->rqstp, &args->context);  in nfsd4_encode_fattr4_sec_label()
3413 	int err = xattr_supports_user_prefix(d_inode(args->dentry));  in nfsd4_encode_fattr4_xattr_support()
3587 	int starting_len = xdr->buf->len;  in nfsd4_encode_fattr4()
3592 	struct nfsd4_compoundres *resp = rqstp->rq_resp;  in nfsd4_encode_fattr4()
3593 	u32 minorversion = resp->cstate.minorversion;  in nfsd4_encode_fattr4()
3595 		.mnt	= exp->ex_path.mnt,  in nfsd4_encode_fattr4()
3620 	if (exp->ex_fslocs.migrated) {  in nfsd4_encode_fattr4()
3640 		struct nfs4_cb_fattr *ncf = &dp->dl_cb_fattr;  in nfsd4_encode_fattr4()
3642 		if (ncf->ncf_file_modified) {  in nfsd4_encode_fattr4()
3643 			++ncf->ncf_initial_cinfo;  in nfsd4_encode_fattr4()
3644 			args.stat.size = ncf->ncf_cur_fsize;  in nfsd4_encode_fattr4()
3645 			if (!timespec64_is_epoch(&ncf->ncf_cb_mtime))  in nfsd4_encode_fattr4()
3646 				args.stat.mtime = ncf->ncf_cb_mtime;  in nfsd4_encode_fattr4()
3648 		args.change_attr = ncf->ncf_initial_cinfo;  in nfsd4_encode_fattr4()
3650 		if (!timespec64_is_epoch(&ncf->ncf_cb_atime))  in nfsd4_encode_fattr4()
3651 			args.stat.atime = ncf->ncf_cb_atime;  in nfsd4_encode_fattr4()
3653 		nfs4_put_stid(&dp->dl_stid);  in nfsd4_encode_fattr4()
3688 		if (err == -EOPNOTSUPP)  in nfsd4_encode_fattr4()
3690 		else if (err == -EINVAL) {  in nfsd4_encode_fattr4()
3702 		if (exp->ex_flags & NFSEXP_SECURITY_LABEL)  in nfsd4_encode_fattr4()
3706 			err = -EOPNOTSUPP;  in nfsd4_encode_fattr4()
3709 			if (err == -EOPNOTSUPP)  in nfsd4_encode_fattr4()
3724 	attrlen_offset = xdr->buf->len;  in nfsd4_encode_fattr4()
3735 	attrlen = cpu_to_be32(xdr->buf->len - attrlen_offset - XDR_UNIT);  in nfsd4_encode_fattr4()
3736 	write_bytes_to_xdr_buf(xdr->buf, attrlen_offset, &attrlen, XDR_UNIT);  in nfsd4_encode_fattr4()
3763 	xdr->scratch.iov_len = 0;  in svcxdr_init_encode_from_buffer()
3765 	buf->head[0].iov_base = p;  in svcxdr_init_encode_from_buffer()
3766 	buf->head[0].iov_len = 0;  in svcxdr_init_encode_from_buffer()
3767 	buf->len = 0;  in svcxdr_init_encode_from_buffer()
3768 	xdr->buf = buf;  in svcxdr_init_encode_from_buffer()
3769 	xdr->iov = buf->head;  in svcxdr_init_encode_from_buffer()
3770 	xdr->p = p;  in svcxdr_init_encode_from_buffer()
3771 	xdr->end = (void *)p + bytes;  in svcxdr_init_encode_from_buffer()
3772 	buf->buflen = bytes;  in svcxdr_init_encode_from_buffer()
3799 	struct xdr_stream *xdr = readdir->xdr;  in nfsd4_encode_entry4_nfs_cookie4()
3801 	if (!readdir->cookie_offset)  in nfsd4_encode_entry4_nfs_cookie4()
3803 	write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset, &cookie,  in nfsd4_encode_entry4_nfs_cookie4()
3820 	struct svc_export *exp = cd->rd_fhp->fh_export;  in nfsd4_encode_entry4_fattr()
3827 					      cd->rd_fhp->fh_dentry);  in nfsd4_encode_entry4_fattr()
3835 	 * as opposed to the cross-mounted file system. In such a case,  in nfsd4_encode_entry4_fattr()
3842 		if (!(exp->ex_flags & NFSEXP_V4ROOT)  in nfsd4_encode_entry4_fattr()
3843 				&& !attributes_need_mount(cd->rd_bmval)) {  in nfsd4_encode_entry4_fattr()
3852 		err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp);  in nfsd4_encode_entry4_fattr()
3857 		nfserr = check_nfsd_access(exp, cd->rd_rqstp, false);  in nfsd4_encode_entry4_fattr()
3863 	nfserr = nfsd4_encode_fattr4(cd->rd_rqstp, cd->xdr, NULL, exp, dentry,  in nfsd4_encode_entry4_fattr()
3864 				     cd->rd_bmval, ignore_crossmnt);  in nfsd4_encode_entry4_fattr()
3895 	struct xdr_stream *xdr = cd->xdr;  in nfsd4_encode_entry4()
3896 	int start_offset = xdr->buf->len;  in nfsd4_encode_entry4()
3904 		cd->common.err = nfs_ok;  in nfsd4_encode_entry4()
3915 	cookie_offset = xdr->buf->len;  in nfsd4_encode_entry4()
3938 		if (cd->rd_fhp->fh_export->ex_flags & NFSEXP_V4ROOT)  in nfsd4_encode_entry4()
3949 		if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR))  in nfsd4_encode_entry4()
3957 	entry_bytes = xdr->buf->len - start_offset;  in nfsd4_encode_entry4()
3958 	if (entry_bytes > cd->rd_maxcount)  in nfsd4_encode_entry4()
3960 	cd->rd_maxcount -= entry_bytes;  in nfsd4_encode_entry4()
3966 	if (cd->rd_dircount) {  in nfsd4_encode_entry4()
3968 		if (name_and_cookie > cd->rd_dircount && cd->cookie_offset)  in nfsd4_encode_entry4()
3970 		cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie);  in nfsd4_encode_entry4()
3971 		if (!cd->rd_dircount)  in nfsd4_encode_entry4()
3972 			cd->rd_maxcount = 0;  in nfsd4_encode_entry4()
3975 	cd->cookie_offset = cookie_offset;  in nfsd4_encode_entry4()
3977 	cd->common.err = nfs_ok;  in nfsd4_encode_entry4()
3981 	cd->common.err = nfserr;  in nfsd4_encode_entry4()
3982 	return -EINVAL;  in nfsd4_encode_entry4()
3993 	memcpy(p, verf->data, sizeof(verf->data));  in nfsd4_encode_verifier4()
4009 /* This is a frequently-encoded item; open-coded for speed */
4018 	*p++ = cpu_to_be32(sid->si_generation);  in nfsd4_encode_stateid4()
4019 	memcpy(p, &sid->si_opaque, sizeof(sid->si_opaque));  in nfsd4_encode_stateid4()
4027 	return nfsd4_encode_opaque_fixed(xdr, sessionid->data,  in nfsd4_encode_sessionid4()
4035 	struct nfsd4_access *access = &u->access;  in nfsd4_encode_access()
4036 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_access()
4040 	status = nfsd4_encode_uint32_t(xdr, access->ac_supported);  in nfsd4_encode_access()
4044 	return nfsd4_encode_uint32_t(xdr, access->ac_resp_access);  in nfsd4_encode_access()
4050 	struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session;  in nfsd4_encode_bind_conn_to_session()
4051 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_bind_conn_to_session()
4054 	nfserr = nfsd4_encode_sessionid4(xdr, &bcts->sessionid);  in nfsd4_encode_bind_conn_to_session()
4058 	if (xdr_stream_encode_u32(xdr, bcts->dir) != XDR_UNIT)  in nfsd4_encode_bind_conn_to_session()
4068 	struct nfsd4_close *close = &u->close;  in nfsd4_encode_close()
4069 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_close()
4072 	return nfsd4_encode_stateid4(xdr, &close->cl_stateid);  in nfsd4_encode_close()
4080 	struct nfsd4_commit *commit = &u->commit;  in nfsd4_encode_commit()
4082 	return nfsd4_encode_verifier4(resp->xdr, &commit->co_verf);  in nfsd4_encode_commit()
4089 	struct nfsd4_create *create = &u->create;  in nfsd4_encode_create()
4090 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_create()
4093 	nfserr = nfsd4_encode_change_info4(xdr, &create->cr_cinfo);  in nfsd4_encode_create()
4097 	return nfsd4_encode_bitmap4(xdr, create->cr_bmval[0],  in nfsd4_encode_create()
4098 				    create->cr_bmval[1], create->cr_bmval[2]);  in nfsd4_encode_create()
4105 	struct nfsd4_getattr *getattr = &u->getattr;  in nfsd4_encode_getattr()
4106 	struct svc_fh *fhp = getattr->ga_fhp;  in nfsd4_encode_getattr()
4107 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_getattr()
4110 	return nfsd4_encode_fattr4(resp->rqstp, xdr, fhp, fhp->fh_export,  in nfsd4_encode_getattr()
4111 				   fhp->fh_dentry, getattr->ga_bmval, 0);  in nfsd4_encode_getattr()
4118 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_getfh()
4119 	struct svc_fh *fhp = u->getfh;  in nfsd4_encode_getfh()
4122 	return nfsd4_encode_nfs_fh4(xdr, &fhp->fh_handle);  in nfsd4_encode_getfh()
4136 	return nfsd4_encode_opaque(xdr, owner->data, owner->len);  in nfsd4_encode_lock_owner4()
4146 	status = nfsd4_encode_offset4(xdr, ld->ld_start);  in nfsd4_encode_lock4denied()
4150 	status = nfsd4_encode_length4(xdr, ld->ld_length);  in nfsd4_encode_lock4denied()
4154 	if (xdr_stream_encode_u32(xdr, ld->ld_type) != XDR_UNIT)  in nfsd4_encode_lock4denied()
4157 	return nfsd4_encode_lock_owner4(xdr, &ld->ld_clientid,  in nfsd4_encode_lock4denied()
4158 					&ld->ld_owner);  in nfsd4_encode_lock4denied()
4165 	struct nfsd4_lock *lock = &u->lock;  in nfsd4_encode_lock()
4166 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_lock()
4172 		status = nfsd4_encode_stateid4(xdr, &lock->lk_resp_stateid);  in nfsd4_encode_lock()
4176 		status = nfsd4_encode_lock4denied(xdr, &lock->lk_denied);  in nfsd4_encode_lock()
4188 	struct nfsd4_lockt *lockt = &u->lockt;  in nfsd4_encode_lockt()
4189 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_lockt()
4194 		status = nfsd4_encode_lock4denied(xdr, &lockt->lt_denied);  in nfsd4_encode_lockt()
4205 	struct nfsd4_locku *locku = &u->locku;  in nfsd4_encode_locku()
4206 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_locku()
4209 	return nfsd4_encode_stateid4(xdr, &locku->lu_stateid);  in nfsd4_encode_locku()
4217 	struct nfsd4_link *link = &u->link;  in nfsd4_encode_link()
4218 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_link()
4220 	return nfsd4_encode_change_info4(xdr, &link->li_cinfo);  in nfsd4_encode_link()
4244 	/* who - empty for now */  in nfsd4_encode_open_nfsace4()
4256 	status = nfsd4_encode_stateid4(xdr, &open->op_delegate_stateid);  in nfsd4_encode_open_read_delegation4()
4259 	/* recall */  in nfsd4_encode_open_read_delegation4()
4260 	status = nfsd4_encode_bool(xdr, open->op_recall);  in nfsd4_encode_open_read_delegation4()
4284 	status = nfsd4_encode_stateid4(xdr, &open->op_delegate_stateid);  in nfsd4_encode_open_write_delegation4()
4287 	/* recall */  in nfsd4_encode_open_write_delegation4()
4288 	status = nfsd4_encode_bool(xdr, open->op_recall);  in nfsd4_encode_open_write_delegation4()
4305 	if (xdr_stream_encode_u32(xdr, open->op_why_no_deleg) != XDR_UNIT)  in nfsd4_encode_open_none_delegation4()
4307 	switch (open->op_why_no_deleg) {  in nfsd4_encode_open_none_delegation4()
4325 	if (xdr_stream_encode_u32(xdr, open->op_delegate_type) != XDR_UNIT)  in nfsd4_encode_open_delegation4()
4327 	switch (open->op_delegate_type) {  in nfsd4_encode_open_delegation4()
4356 	struct nfsd4_open *open = &u->open;  in nfsd4_encode_open()
4357 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_open()
4360 	nfserr = nfsd4_encode_stateid4(xdr, &open->op_stateid);  in nfsd4_encode_open()
4364 	nfserr = nfsd4_encode_change_info4(xdr, &open->op_cinfo);  in nfsd4_encode_open()
4368 	nfserr = nfsd4_encode_uint32_t(xdr, open->op_rflags);  in nfsd4_encode_open()
4372 	nfserr = nfsd4_encode_bitmap4(xdr, open->op_bmval[0],  in nfsd4_encode_open()
4373 				      open->op_bmval[1], open->op_bmval[2]);  in nfsd4_encode_open()
4384 	struct nfsd4_open_confirm *oc = &u->open_confirm;  in nfsd4_encode_open_confirm()
4385 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_open_confirm()
4388 	return nfsd4_encode_stateid4(xdr, &oc->oc_resp_stateid);  in nfsd4_encode_open_confirm()
4395 	struct nfsd4_open_downgrade *od = &u->open_downgrade;  in nfsd4_encode_open_downgrade()
4396 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_open_downgrade()
4399 	return nfsd4_encode_stateid4(xdr, &od->od_stateid);  in nfsd4_encode_open_downgrade()
4412 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_splice_read()
4413 	struct xdr_buf *buf = xdr->buf;  in nfsd4_encode_splice_read()
4421 	if (unlikely(xdr->buf->page_len)) {  in nfsd4_encode_splice_read()
4427 	 * Make sure there is room at the end of buf->head for  in nfsd4_encode_splice_read()
4429 	 * to XDR-pad the payload.  in nfsd4_encode_splice_read()
4431 	if (xdr->iov != xdr->buf->head || xdr->end - xdr->p < 1)  in nfsd4_encode_splice_read()
4434 	nfserr = nfsd_splice_read(read->rd_rqstp, read->rd_fhp,  in nfsd4_encode_splice_read()
4435 				  file, read->rd_offset, &maxcount,  in nfsd4_encode_splice_read()
4436 				  &read->rd_eof);  in nfsd4_encode_splice_read()
4437 	read->rd_length = maxcount;  in nfsd4_encode_splice_read()
4440 	svcxdr_encode_opaque_pages(read->rd_rqstp, xdr, buf->pages,  in nfsd4_encode_splice_read()
4441 				   buf->page_base, maxcount);  in nfsd4_encode_splice_read()
4442 	status = svc_encode_result_payload(read->rd_rqstp,  in nfsd4_encode_splice_read()
4443 					   buf->head[0].iov_len, maxcount);  in nfsd4_encode_splice_read()
4454 	 * manipulations are open-coded.  in nfsd4_encode_splice_read()
4456 	space_left = min_t(int, (void *)xdr->end - (void *)xdr->p,  in nfsd4_encode_splice_read()
4457 				buf->buflen - buf->len);  in nfsd4_encode_splice_read()
4458 	buf->buflen = buf->len + space_left;  in nfsd4_encode_splice_read()
4459 	xdr->end = (__be32 *)((void *)xdr->end + space_left);  in nfsd4_encode_splice_read()
4469 	buf->page_len = 0;  in nfsd4_encode_splice_read()
4477 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_readv()
4478 	unsigned int base = xdr->buf->page_len & ~PAGE_MASK;  in nfsd4_encode_readv()
4479 	unsigned int starting_len = xdr->buf->len;  in nfsd4_encode_readv()
4486 	nfserr = nfsd_iter_read(resp->rqstp, read->rd_fhp, file,  in nfsd4_encode_readv()
4487 				read->rd_offset, &maxcount, base,  in nfsd4_encode_readv()
4488 				&read->rd_eof);  in nfsd4_encode_readv()
4489 	read->rd_length = maxcount;  in nfsd4_encode_readv()
4492 	if (svc_encode_result_payload(resp->rqstp, starting_len, maxcount))  in nfsd4_encode_readv()
4496 	write_bytes_to_xdr_buf(xdr->buf, starting_len + maxcount, &zero,  in nfsd4_encode_readv()
4505 	struct nfsd4_compoundargs *argp = resp->rqstp->rq_argp;  in nfsd4_encode_read()
4506 	struct nfsd4_read *read = &u->read;  in nfsd4_encode_read()
4507 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_read()
4508 	bool splice_ok = argp->splice_ok;  in nfsd4_encode_read()
4517 	eof_offset = xdr->buf->len;  in nfsd4_encode_read()
4518 	file = read->rd_nf->nf_file;  in nfsd4_encode_read()
4527 	maxcount = min_t(unsigned long, read->rd_length,  in nfsd4_encode_read()
4528 			 (xdr->buf->buflen - xdr->buf->len));  in nfsd4_encode_read()
4530 	if (file->f_op->splice_read && splice_ok)  in nfsd4_encode_read()
4539 	wire_data[0] = read->rd_eof ? xdr_one : xdr_zero;  in nfsd4_encode_read()
4540 	wire_data[1] = cpu_to_be32(read->rd_length);  in nfsd4_encode_read()
4541 	write_bytes_to_xdr_buf(xdr->buf, eof_offset, &wire_data, XDR_UNIT * 2);  in nfsd4_encode_read()
4549 	struct nfsd4_readlink *readlink = &u->readlink;  in nfsd4_encode_readlink()
4551 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_readlink()
4556 	length_offset = xdr->buf->len;  in nfsd4_encode_readlink()
4565 	nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp,  in nfsd4_encode_readlink()
4571 	status = svc_encode_result_payload(readlink->rl_rqstp, length_offset,  in nfsd4_encode_readlink()
4579 	write_bytes_to_xdr_buf(xdr->buf, length_offset, &wire_count, XDR_UNIT);  in nfsd4_encode_readlink()
4581 	write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount, &zero,  in nfsd4_encode_readlink()
4594 	int bytes_left, maxcount, starting_len = xdr->buf->len;  in nfsd4_encode_dirlist4()
4602 	bytes_left = xdr->buf->buflen - xdr->buf->len -  in nfsd4_encode_dirlist4()
4603 		COMPOUND_ERR_SLACK_SPACE - XDR_UNIT * 2;  in nfsd4_encode_dirlist4()
4606 	maxcount = min_t(u32, readdir->rd_maxcount, max_payload);  in nfsd4_encode_dirlist4()
4615 	maxcount = min_t(int, maxcount - XDR_UNIT * 4, bytes_left);  in nfsd4_encode_dirlist4()
4618 	if (!readdir->rd_dircount)  in nfsd4_encode_dirlist4()
4619 		readdir->rd_dircount = max_payload;  in nfsd4_encode_dirlist4()
4622 	readdir->xdr = xdr;  in nfsd4_encode_dirlist4()
4623 	readdir->rd_maxcount = maxcount;  in nfsd4_encode_dirlist4()
4624 	readdir->common.err = 0;  in nfsd4_encode_dirlist4()
4625 	readdir->cookie_offset = 0;  in nfsd4_encode_dirlist4()
4626 	offset = readdir->rd_cookie;  in nfsd4_encode_dirlist4()
4627 	status = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp, &offset,  in nfsd4_encode_dirlist4()
4628 			      &readdir->common, nfsd4_encode_entry4);  in nfsd4_encode_dirlist4()
4631 	if (readdir->common.err == nfserr_toosmall &&  in nfsd4_encode_dirlist4()
4632 	    xdr->buf->len == starting_len) {  in nfsd4_encode_dirlist4()
4634 		if (maxcount - XDR_UNIT * 4 < bytes_left)  in nfsd4_encode_dirlist4()
4647 	return nfsd4_encode_bool(xdr, readdir->common.err == nfserr_eof);  in nfsd4_encode_dirlist4()
4654 	struct nfsd4_readdir *readdir = &u->readdir;  in nfsd4_encode_readdir()
4655 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_readdir()
4656 	int starting_len = xdr->buf->len;  in nfsd4_encode_readdir()
4659 	nfserr = nfsd4_encode_verifier4(xdr, &readdir->rd_verf);  in nfsd4_encode_readdir()
4664 	nfserr = nfsd4_encode_dirlist4(xdr, readdir, svc_max_payload(resp->rqstp));  in nfsd4_encode_readdir()
4674 	struct nfsd4_remove *remove = &u->remove;  in nfsd4_encode_remove()
4675 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_remove()
4677 	return nfsd4_encode_change_info4(xdr, &remove->rm_cinfo);  in nfsd4_encode_remove()
4684 	struct nfsd4_rename *rename = &u->rename;  in nfsd4_encode_rename()
4685 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_rename()
4687 	nfserr = nfsd4_encode_change_info4(xdr, &rename->rn_sinfo);  in nfsd4_encode_rename()
4690 	return nfsd4_encode_change_info4(xdr, &rename->rn_tinfo);  in nfsd4_encode_rename()
4700 	if (xdr_stream_encode_opaque(xdr, info->oid.data, info->oid.len) < 0)  in nfsd4_encode_rpcsec_gss_info()
4703 	status = nfsd4_encode_qop4(xdr, info->qop);  in nfsd4_encode_rpcsec_gss_info()
4707 	if (xdr_stream_encode_u32(xdr, info->service) != XDR_UNIT)  in nfsd4_encode_rpcsec_gss_info()
4751 	if (exp->ex_nflavors) {  in nfsd4_encode_SECINFO4resok()
4752 		flavs = exp->ex_flavors;  in nfsd4_encode_SECINFO4resok()
4753 		nflavs = exp->ex_nflavors;  in nfsd4_encode_SECINFO4resok()
4756 		if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) {  in nfsd4_encode_SECINFO4resok()
4760 		} else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) {  in nfsd4_encode_SECINFO4resok()
4763 					= svcauth_gss_flavor(exp->ex_client);  in nfsd4_encode_SECINFO4resok()
4767 					= exp->ex_client->flavour->flavour;  in nfsd4_encode_SECINFO4resok()
4771 	count_offset = xdr->buf->len;  in nfsd4_encode_SECINFO4resok()
4783 	write_bytes_to_xdr_buf(xdr->buf, count_offset, &wire_count,  in nfsd4_encode_SECINFO4resok()
4792 	struct nfsd4_secinfo *secinfo = &u->secinfo;  in nfsd4_encode_secinfo()
4793 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_secinfo()
4795 	return nfsd4_encode_SECINFO4resok(xdr, secinfo->si_exp);  in nfsd4_encode_secinfo()
4802 	struct nfsd4_secinfo_no_name *secinfo = &u->secinfo_no_name;  in nfsd4_encode_secinfo_no_name()
4803 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_secinfo_no_name()
4805 	return nfsd4_encode_SECINFO4resok(xdr, secinfo->sin_exp);  in nfsd4_encode_secinfo_no_name()
4812 	struct nfsd4_setattr *setattr = &u->setattr;  in nfsd4_encode_setattr()
4818 		status = nfsd4_encode_bitmap4(resp->xdr, setattr->sa_bmval[0],  in nfsd4_encode_setattr()
4819 					      setattr->sa_bmval[1],  in nfsd4_encode_setattr()
4820 					      setattr->sa_bmval[2]);  in nfsd4_encode_setattr()
4824 		status = nfsd4_encode_bitmap4(resp->xdr, 0, 0, 0);  in nfsd4_encode_setattr()
4833 	struct nfsd4_setclientid *scd = &u->setclientid;  in nfsd4_encode_setclientid()
4834 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_setclientid()
4837 		nfserr = nfsd4_encode_clientid4(xdr, &scd->se_clientid);  in nfsd4_encode_setclientid()
4840 		nfserr = nfsd4_encode_verifier4(xdr, &scd->se_confirm);  in nfsd4_encode_setclientid()
4861 	struct nfsd4_write *write = &u->write;  in nfsd4_encode_write()
4862 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_write()
4865 	nfserr = nfsd4_encode_count4(xdr, write->wr_bytes_written);  in nfsd4_encode_write()
4869 	if (xdr_stream_encode_u32(xdr, write->wr_how_written) != XDR_UNIT)  in nfsd4_encode_write()
4872 	return nfsd4_encode_verifier4(xdr, &write->wr_verifier);  in nfsd4_encode_write()
4882 	status = nfsd4_encode_bitmap4(xdr, exid->spo_must_enforce[0],  in nfsd4_encode_state_protect_ops4()
4883 				      exid->spo_must_enforce[1],  in nfsd4_encode_state_protect_ops4()
4884 				      exid->spo_must_enforce[2]);  in nfsd4_encode_state_protect_ops4()
4888 	return nfsd4_encode_bitmap4(xdr, exid->spo_must_allow[0],  in nfsd4_encode_state_protect_ops4()
4889 				    exid->spo_must_allow[1],  in nfsd4_encode_state_protect_ops4()
4890 				    exid->spo_must_allow[2]);  in nfsd4_encode_state_protect_ops4()
4898 	if (xdr_stream_encode_u32(xdr, exid->spa_how) != XDR_UNIT)  in nfsd4_encode_state_protect4_r()
4900 	switch (exid->spa_how) {  in nfsd4_encode_state_protect4_r()
4925 	return nfsd4_encode_opaque(xdr, nn->nfsd_name, strlen(nn->nfsd_name));  in nfsd4_encode_server_owner4()
4934 	status = nfsd4_encode_opaque(xdr, exid->nii_domain.data,  in nfsd4_encode_nfs_impl_id4()
4935 				     exid->nii_domain.len);  in nfsd4_encode_nfs_impl_id4()
4939 	status = nfsd4_encode_opaque(xdr, exid->nii_name.data,  in nfsd4_encode_nfs_impl_id4()
4940 				     exid->nii_name.len);  in nfsd4_encode_nfs_impl_id4()
4944 	return nfsd4_encode_nfstime4(xdr, &exid->nii_time);  in nfsd4_encode_nfs_impl_id4()
4951 	struct nfsd_net *nn = net_generic(SVC_NET(resp->rqstp), nfsd_net_id);  in nfsd4_encode_exchange_id()
4952 	struct nfsd4_exchange_id *exid = &u->exchange_id;  in nfsd4_encode_exchange_id()
4953 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_exchange_id()
4956 	nfserr = nfsd4_encode_clientid4(xdr, &exid->clientid);  in nfsd4_encode_exchange_id()
4960 	nfserr = nfsd4_encode_sequenceid4(xdr, exid->seqid);  in nfsd4_encode_exchange_id()
4964 	nfserr = nfsd4_encode_uint32_t(xdr, exid->flags);  in nfsd4_encode_exchange_id()
4972 	nfserr = nfsd4_encode_server_owner4(xdr, resp->rqstp);  in nfsd4_encode_exchange_id()
4976 	nfserr = nfsd4_encode_opaque(xdr, nn->nfsd_name,  in nfsd4_encode_exchange_id()
4977 				     strlen(nn->nfsd_name));  in nfsd4_encode_exchange_id()
5001 	status = nfsd4_encode_count4(xdr, attrs->maxreq_sz);  in nfsd4_encode_channel_attrs4()
5005 	status = nfsd4_encode_count4(xdr, attrs->maxresp_sz);  in nfsd4_encode_channel_attrs4()
5009 	status = nfsd4_encode_count4(xdr, attrs->maxresp_cached);  in nfsd4_encode_channel_attrs4()
5013 	status = nfsd4_encode_count4(xdr, attrs->maxops);  in nfsd4_encode_channel_attrs4()
5017 	status = nfsd4_encode_count4(xdr, attrs->maxreqs);  in nfsd4_encode_channel_attrs4()
5021 	if (xdr_stream_encode_u32(xdr, attrs->nr_rdma_attrs) != XDR_UNIT)  in nfsd4_encode_channel_attrs4()
5023 	if (attrs->nr_rdma_attrs)  in nfsd4_encode_channel_attrs4()
5024 		return nfsd4_encode_uint32_t(xdr, attrs->rdma_attrs);  in nfsd4_encode_channel_attrs4()
5032 	struct nfsd4_create_session *sess = &u->create_session;  in nfsd4_encode_create_session()
5033 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_create_session()
5036 	nfserr = nfsd4_encode_sessionid4(xdr, &sess->sessionid);  in nfsd4_encode_create_session()
5040 	nfserr = nfsd4_encode_sequenceid4(xdr, sess->seqid);  in nfsd4_encode_create_session()
5044 	nfserr = nfsd4_encode_uint32_t(xdr, sess->flags);  in nfsd4_encode_create_session()
5048 	nfserr = nfsd4_encode_channel_attrs4(xdr, &sess->fore_channel);  in nfsd4_encode_create_session()
5052 	return nfsd4_encode_channel_attrs4(xdr, &sess->back_channel);  in nfsd4_encode_create_session()
5059 	struct nfsd4_sequence *seq = &u->sequence;  in nfsd4_encode_sequence()
5060 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_sequence()
5063 	nfserr = nfsd4_encode_sessionid4(xdr, &seq->sessionid);  in nfsd4_encode_sequence()
5067 	nfserr = nfsd4_encode_sequenceid4(xdr, seq->seqid);  in nfsd4_encode_sequence()
5071 	nfserr = nfsd4_encode_slotid4(xdr, seq->slotid);  in nfsd4_encode_sequence()
5076 	nfserr = nfsd4_encode_slotid4(xdr, seq->maxslots - 1);  in nfsd4_encode_sequence()
5080 	nfserr = nfsd4_encode_slotid4(xdr, seq->target_maxslots - 1);  in nfsd4_encode_sequence()
5084 	nfserr = nfsd4_encode_uint32_t(xdr, seq->status_flags);  in nfsd4_encode_sequence()
5088 	resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */  in nfsd4_encode_sequence()
5096 	struct nfsd4_test_stateid *test_stateid = &u->test_stateid;  in nfsd4_encode_test_stateid()
5098 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_test_stateid()
5101 	if (xdr_stream_encode_u32(xdr, test_stateid->ts_num_ids) != XDR_UNIT)  in nfsd4_encode_test_stateid()
5104 				 &test_stateid->ts_stateid_list, ts_id_list) {  in nfsd4_encode_test_stateid()
5105 		if (xdr_stream_encode_be32(xdr, stateid->ts_id_status) != XDR_UNIT)  in nfsd4_encode_test_stateid()
5115 	struct nfsd4_get_dir_delegation *gdd = &u->get_dir_delegation;  in nfsd4_encode_get_dir_delegation()
5116 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_get_dir_delegation()
5119 	switch(gdd->gddrnf_status) {  in nfsd4_encode_get_dir_delegation()
5123 		status = nfsd4_encode_verifier4(xdr, &gdd->gddr_cookieverf);  in nfsd4_encode_get_dir_delegation()
5126 		status = nfsd4_encode_stateid4(xdr, &gdd->gddr_stateid);  in nfsd4_encode_get_dir_delegation()
5129 		status = nfsd4_encode_bitmap4(xdr, gdd->gddr_notification[0], 0, 0);  in nfsd4_encode_get_dir_delegation()
5132 		status = nfsd4_encode_bitmap4(xdr, gdd->gddr_child_attributes[0],  in nfsd4_encode_get_dir_delegation()
5133 						   gdd->gddr_child_attributes[1],  in nfsd4_encode_get_dir_delegation()
5134 						   gdd->gddr_child_attributes[2]);  in nfsd4_encode_get_dir_delegation()
5137 		status = nfsd4_encode_bitmap4(xdr, gdd->gddr_dir_attributes[0],  in nfsd4_encode_get_dir_delegation()
5138 						   gdd->gddr_dir_attributes[1],  in nfsd4_encode_get_dir_delegation()
5139 						   gdd->gddr_dir_attributes[2]);  in nfsd4_encode_get_dir_delegation()
5142 		pr_warn("nfsd: bad gddrnf_status (%u)\n", gdd->gddrnf_status);  in nfsd4_encode_get_dir_delegation()
5143 		gdd->gddrnf_will_signal_deleg_avail = 0;  in nfsd4_encode_get_dir_delegation()
5148 		status = nfsd4_encode_bool(xdr, gdd->gddrnf_will_signal_deleg_avail);  in nfsd4_encode_get_dir_delegation()
5159 	u32 needed_len, starting_len = xdr->buf->len;  in nfsd4_encode_device_addr4()
5164 	if (xdr_stream_encode_u32(xdr, gdev->gd_layout_type) != XDR_UNIT)  in nfsd4_encode_device_addr4()
5167 	ops = nfsd4_layout_ops[gdev->gd_layout_type];  in nfsd4_encode_device_addr4()
5168 	status = ops->encode_getdeviceinfo(xdr, gdev);  in nfsd4_encode_device_addr4()
5175 		if (xdr->buf->len + XDR_UNIT > gdev->gd_maxcount)  in nfsd4_encode_device_addr4()
5183 	needed_len = xdr->buf->len + XDR_UNIT;	/* notifications */  in nfsd4_encode_device_addr4()
5196 	struct nfsd4_getdeviceinfo *gdev = &u->getdeviceinfo;  in nfsd4_encode_getdeviceinfo()
5197 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_getdeviceinfo()
5204 	return nfsd4_encode_bitmap4(xdr, gdev->gd_notify_types, 0, 0);  in nfsd4_encode_getdeviceinfo()
5210 	const struct nfsd4_layout_ops *ops = nfsd4_layout_ops[lgp->lg_layout_type];  in nfsd4_encode_layout4()
5214 	status = nfsd4_encode_offset4(xdr, lgp->lg_seg.offset);  in nfsd4_encode_layout4()
5218 	status = nfsd4_encode_length4(xdr, lgp->lg_seg.length);  in nfsd4_encode_layout4()
5222 	if (xdr_stream_encode_u32(xdr, lgp->lg_seg.iomode) != XDR_UNIT)  in nfsd4_encode_layout4()
5225 	if (xdr_stream_encode_u32(xdr, lgp->lg_layout_type) != XDR_UNIT)  in nfsd4_encode_layout4()
5227 	return ops->encode_layoutget(xdr, lgp);  in nfsd4_encode_layout4()
5234 	struct nfsd4_layoutget *lgp = &u->layoutget;  in nfsd4_encode_layoutget()
5235 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_layoutget()
5242 	nfserr = nfsd4_encode_stateid4(xdr, &lgp->lg_sid);  in nfsd4_encode_layoutget()
5255 	struct nfsd4_layoutcommit *lcp = &u->layoutcommit;  in nfsd4_encode_layoutcommit()
5256 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_layoutcommit()
5259 	nfserr = nfsd4_encode_bool(xdr, lcp->lc_size_chg);  in nfsd4_encode_layoutcommit()
5262 	if (lcp->lc_size_chg)  in nfsd4_encode_layoutcommit()
5264 		return nfsd4_encode_length4(xdr, lcp->lc_newsize);  in nfsd4_encode_layoutcommit()
5272 	struct nfsd4_layoutreturn *lrp = &u->layoutreturn;  in nfsd4_encode_layoutreturn()
5273 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_layoutreturn()
5276 	nfserr = nfsd4_encode_bool(xdr, lrp->lrs_present);  in nfsd4_encode_layoutreturn()
5279 	if (lrp->lrs_present)  in nfsd4_encode_layoutreturn()
5281 		return nfsd4_encode_stateid4(xdr, &lrp->lr_sid);  in nfsd4_encode_layoutreturn()
5290 	const struct nfsd42_write_res *write = &copy->cp_res;  in nfsd4_encode_write_response4()
5298 		status = nfsd4_encode_stateid4(xdr, &write->cb_stateid);  in nfsd4_encode_write_response4()
5304 	status = nfsd4_encode_length4(xdr, write->wr_bytes_written);  in nfsd4_encode_write_response4()
5308 	if (xdr_stream_encode_u32(xdr, write->wr_stable_how) != XDR_UNIT)  in nfsd4_encode_write_response4()
5311 	return nfsd4_encode_verifier4(xdr, &write->wr_verifier);  in nfsd4_encode_write_response4()
5331 	struct nfsd4_copy *copy = &u->copy;  in nfsd4_encode_copy()
5333 	nfserr = nfsd4_encode_write_response4(resp->xdr, copy);  in nfsd4_encode_copy()
5336 	return nfsd4_encode_copy_requirements4(resp->xdr, copy);  in nfsd4_encode_copy()
5344 	if (xdr_stream_encode_u32(xdr, ns->nl4_type) != XDR_UNIT)  in nfsd4_encode_netloc4()
5346 	switch (ns->nl4_type) {  in nfsd4_encode_netloc4()
5349 		status = nfsd4_encode_netaddr4(xdr, &ns->u.nl4_addr);  in nfsd4_encode_netloc4()
5361 	struct nfsd4_copy_notify *cn = &u->copy_notify;  in nfsd4_encode_copy_notify()
5362 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_copy_notify()
5365 	nfserr = nfsd4_encode_nfstime4(xdr, &cn->cpn_lease_time);  in nfsd4_encode_copy_notify()
5369 	nfserr = nfsd4_encode_stateid4(xdr, &cn->cpn_cnr_stateid);  in nfsd4_encode_copy_notify()
5375 	return nfsd4_encode_netloc4(xdr, cn->cpn_src);  in nfsd4_encode_copy_notify()
5382 	struct nfsd4_offload_status *os = &u->offload_status;  in nfsd4_encode_offload_status()
5383 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_offload_status()
5386 	nfserr = nfsd4_encode_length4(xdr, os->count);  in nfsd4_encode_offload_status()
5390 	if (os->completed) {  in nfsd4_encode_offload_status()
5393 		if (xdr_stream_encode_be32(xdr, os->status) != XDR_UNIT)  in nfsd4_encode_offload_status()
5404 	struct nfsd4_compoundargs *argp = resp->rqstp->rq_argp;  in nfsd4_encode_read_plus_data()
5405 	struct file *file = read->rd_nf->nf_file;  in nfsd4_encode_read_plus_data()
5406 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_read_plus_data()
5407 	bool splice_ok = argp->splice_ok;  in nfsd4_encode_read_plus_data()
5416 	offset_offset = xdr->buf->len;  in nfsd4_encode_read_plus_data()
5423 	maxcount = min_t(unsigned long, read->rd_length,  in nfsd4_encode_read_plus_data()
5424 			 (xdr->buf->buflen - xdr->buf->len));  in nfsd4_encode_read_plus_data()
5426 	if (file->f_op->splice_read && splice_ok)  in nfsd4_encode_read_plus_data()
5433 	wire_offset = cpu_to_be64(read->rd_offset);  in nfsd4_encode_read_plus_data()
5434 	write_bytes_to_xdr_buf(xdr->buf, offset_offset, &wire_offset,  in nfsd4_encode_read_plus_data()
5436 	wire_count = cpu_to_be32(read->rd_length);  in nfsd4_encode_read_plus_data()
5437 	write_bytes_to_xdr_buf(xdr->buf, offset_offset + XDR_UNIT * 2,  in nfsd4_encode_read_plus_data()
5446 	struct nfsd4_read *read = &u->read;  in nfsd4_encode_read_plus()
5447 	struct file *file = read->rd_nf->nf_file;  in nfsd4_encode_read_plus()
5448 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_read_plus()
5456 	eof_offset = xdr->buf->len;  in nfsd4_encode_read_plus()
5463 	read->rd_eof = read->rd_offset >= i_size_read(file_inode(file));  in nfsd4_encode_read_plus()
5464 	if (read->rd_eof)  in nfsd4_encode_read_plus()
5476 	wire_data[0] = read->rd_eof ? xdr_one : xdr_zero;  in nfsd4_encode_read_plus()
5478 	write_bytes_to_xdr_buf(xdr->buf, eof_offset, &wire_data, XDR_UNIT * 2);  in nfsd4_encode_read_plus()
5486 	struct nfsd4_seek *seek = &u->seek;  in nfsd4_encode_seek()
5487 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_seek()
5490 	nfserr = nfsd4_encode_bool(xdr, seek->seek_eof);  in nfsd4_encode_seek()
5494 	return nfsd4_encode_offset4(xdr, seek->seek_pos);  in nfsd4_encode_seek()
5505  * Encode kmalloc-ed buffer in to XDR stream.
5514 		      ((void *)xdr->end - (void *)xdr->p));  in nfsd4_vbuf_to_stream()
5521 	buflen -= cplen;  in nfsd4_vbuf_to_stream()
5541 		buflen -= PAGE_SIZE;  in nfsd4_vbuf_to_stream()
5552 	struct nfsd4_getxattr *getxattr = &u->getxattr;  in nfsd4_encode_getxattr()
5553 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_getxattr()
5560 	*p = cpu_to_be32(getxattr->getxa_len);  in nfsd4_encode_getxattr()
5562 	if (getxattr->getxa_len == 0)  in nfsd4_encode_getxattr()
5565 	err = nfsd4_vbuf_to_stream(xdr, getxattr->getxa_buf,  in nfsd4_encode_getxattr()
5566 				    getxattr->getxa_len);  in nfsd4_encode_getxattr()
5568 	kvfree(getxattr->getxa_buf);  in nfsd4_encode_getxattr()
5577 	struct nfsd4_setxattr *setxattr = &u->setxattr;  in nfsd4_encode_setxattr()
5578 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_setxattr()
5580 	return nfsd4_encode_change_info4(xdr, &setxattr->setxa_cinfo);  in nfsd4_encode_setxattr()
5590 	u64 cookie = listxattrs->lsxa_cookie;  in nfsd4_listxattr_validate_cookie()
5596 	if (cookie > (listxattrs->lsxa_len) / (XATTR_USER_PREFIX_LEN + 2))  in nfsd4_listxattr_validate_cookie()
5607 	struct nfsd4_listxattrs *listxattrs = &u->listxattrs;  in nfsd4_encode_listxattrs()
5608 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_listxattrs()
5629 	cookie_offset = xdr->buf->len;  in nfsd4_encode_listxattrs()
5638 	left = listxattrs->lsxa_len;  in nfsd4_encode_listxattrs()
5639 	sp = listxattrs->lsxa_buf;  in nfsd4_encode_listxattrs()
5642 	/* Bytes left is maxcount - 8 (cookie) - 4 (array count) */  in nfsd4_encode_listxattrs()
5643 	xdrleft = listxattrs->lsxa_maxcount - XDR_UNIT * 3;  in nfsd4_encode_listxattrs()
5649 		 * Check if this is a "user." attribute, skip it if not.  in nfsd4_encode_listxattrs()
5654 		slen -= XATTR_USER_PREFIX_LEN;  in nfsd4_encode_listxattrs()
5669 		left -= XATTR_USER_PREFIX_LEN;  in nfsd4_encode_listxattrs()
5683 		xdrleft -= xdrlen;  in nfsd4_encode_listxattrs()
5687 		left -= slen + 1;  in nfsd4_encode_listxattrs()
5710 	write_bytes_to_xdr_buf(xdr->buf, cookie_offset, &wire_cookie, 8);  in nfsd4_encode_listxattrs()
5712 	write_bytes_to_xdr_buf(xdr->buf, count_offset, &tmp, 4);  in nfsd4_encode_listxattrs()
5714 	if (listxattrs->lsxa_len)  in nfsd4_encode_listxattrs()
5715 		kvfree(listxattrs->lsxa_buf);  in nfsd4_encode_listxattrs()
5723 	struct nfsd4_removexattr *removexattr = &u->removexattr;  in nfsd4_encode_removexattr()
5724 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_removexattr()
5726 	return nfsd4_encode_change_info4(xdr, &removexattr->rmxa_cinfo);  in nfsd4_encode_removexattr()
5829  *     - For NFS versions >=4.1, the size of the reply must stay within
5831  *     - For all NFS versions, we must stay within limited preallocated
5841 	struct xdr_buf *buf = &resp->rqstp->rq_res;  in nfsd4_check_resp_size()
5842 	struct nfsd4_slot *slot = resp->cstate.slot;  in nfsd4_check_resp_size()
5844 	if (buf->len + respsize <= buf->buflen)  in nfsd4_check_resp_size()
5846 	if (!nfsd4_has_session(&resp->cstate))  in nfsd4_check_resp_size()
5848 	if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) {  in nfsd4_check_resp_size()
5861 		/* RFC 8881 - 15.1.2.9 */  in nfsd4_map_status()
5875 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_operation()
5876 	struct nfs4_stateowner *so = resp->cstate.replay_owner;  in nfsd4_encode_operation()
5877 	struct svc_rqst *rqstp = resp->rqstp;  in nfsd4_encode_operation()
5878 	const struct nfsd4_operation *opdesc = op->opdesc;  in nfsd4_encode_operation()
5882 	if (xdr_stream_encode_u32(xdr, op->opnum) != XDR_UNIT)  in nfsd4_encode_operation()
5884 	op_status_offset = xdr->buf->len;  in nfsd4_encode_operation()
5888 	if (op->opnum == OP_ILLEGAL)  in nfsd4_encode_operation()
5890 	if (op->status && opdesc &&  in nfsd4_encode_operation()
5891 			!(opdesc->op_flags & OP_NONTRIVIAL_ERROR_ENCODE))  in nfsd4_encode_operation()
5893 	BUG_ON(op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||  in nfsd4_encode_operation()
5894 	       !nfsd4_enc_ops[op->opnum]);  in nfsd4_encode_operation()
5895 	encoder = nfsd4_enc_ops[op->opnum];  in nfsd4_encode_operation()
5896 	op->status = encoder(resp, op->status, &op->u);  in nfsd4_encode_operation()
5897 	if (op->status)  in nfsd4_encode_operation()
5898 		trace_nfsd_compound_encode_err(rqstp, op->opnum, op->status);  in nfsd4_encode_operation()
5902 	if (!op->status) {  in nfsd4_encode_operation()
5906 		op->status = nfsd4_check_resp_size(resp, space_needed);  in nfsd4_encode_operation()
5908 	if (op->status == nfserr_resource && nfsd4_has_session(&resp->cstate)) {  in nfsd4_encode_operation()
5909 		struct nfsd4_slot *slot = resp->cstate.slot;  in nfsd4_encode_operation()
5911 		if (slot->sl_flags & NFSD4_SLOT_CACHETHIS)  in nfsd4_encode_operation()
5912 			op->status = nfserr_rep_too_big_to_cache;  in nfsd4_encode_operation()
5914 			op->status = nfserr_rep_too_big;  in nfsd4_encode_operation()
5916 	if (op->status == nfserr_resource ||  in nfsd4_encode_operation()
5917 	    op->status == nfserr_rep_too_big ||  in nfsd4_encode_operation()
5918 	    op->status == nfserr_rep_too_big_to_cache) {  in nfsd4_encode_operation()
5924 		 * bug if we had to do this on a non-idempotent op:  in nfsd4_encode_operation()
5930 		int len = xdr->buf->len - (op_status_offset + XDR_UNIT);  in nfsd4_encode_operation()
5932 		so->so_replay.rp_status = op->status;  in nfsd4_encode_operation()
5933 		so->so_replay.rp_buflen = len;  in nfsd4_encode_operation()
5934 		read_bytes_from_xdr_buf(xdr->buf, op_status_offset + XDR_UNIT,  in nfsd4_encode_operation()
5935 						so->so_replay.rp_buf, len);  in nfsd4_encode_operation()
5938 	op->status = nfsd4_map_status(op->status,  in nfsd4_encode_operation()
5939 				      resp->cstate.minorversion);  in nfsd4_encode_operation()
5940 	write_bytes_to_xdr_buf(xdr->buf, op_status_offset,  in nfsd4_encode_operation()
5941 			       &op->status, XDR_UNIT);  in nfsd4_encode_operation()
5943 	if (opdesc && opdesc->op_release)  in nfsd4_encode_operation()
5944 		opdesc->op_release(&op->u);  in nfsd4_encode_operation()
5950 	rqstp->rq_next_page = xdr->page_ptr + 1;  in nfsd4_encode_operation()
5954  * nfsd4_encode_replay - encode a result stored in the stateowner reply cache
5958  * @op->replay->rp_buf contains the previously-sent already-encoded result.
5962 	struct nfs4_replay *rp = op->replay;  in nfsd4_encode_replay()
5964 	trace_nfsd_stateowner_replay(op->opnum, rp);  in nfsd4_encode_replay()
5966 	if (xdr_stream_encode_u32(xdr, op->opnum) != XDR_UNIT)  in nfsd4_encode_replay()
5968 	if (xdr_stream_encode_be32(xdr, rp->rp_status) != XDR_UNIT)  in nfsd4_encode_replay()
5970 	xdr_stream_encode_opaque_fixed(xdr, rp->rp_buf, rp->rp_buflen);  in nfsd4_encode_replay()
5975 	struct nfsd4_compoundargs *args = rqstp->rq_argp;  in nfsd4_release_compoundargs()
5977 	if (args->ops != args->iops) {  in nfsd4_release_compoundargs()
5978 		vfree(args->ops);  in nfsd4_release_compoundargs()
5979 		args->ops = args->iops;  in nfsd4_release_compoundargs()
5981 	while (args->to_free) {  in nfsd4_release_compoundargs()
5982 		struct svcxdr_tmpbuf *tb = args->to_free;  in nfsd4_release_compoundargs()
5983 		args->to_free = tb->next;  in nfsd4_release_compoundargs()
5991 	struct nfsd4_compoundargs *args = rqstp->rq_argp;  in nfs4svc_decode_compoundargs()
5994 	args->to_free = NULL;  in nfs4svc_decode_compoundargs()
5996 	args->xdr = xdr;  in nfs4svc_decode_compoundargs()
5997 	args->ops = args->iops;  in nfs4svc_decode_compoundargs()
5998 	args->rqstp = rqstp;  in nfs4svc_decode_compoundargs()
6006 	struct nfsd4_compoundres *resp = rqstp->rq_resp;  in nfs4svc_encode_compoundres()
6013 	p = resp->statusp;  in nfs4svc_encode_compoundres()
6015 	*p++ = resp->cstate.status;  in nfs4svc_encode_compoundres()
6016 	*p++ = htonl(resp->taglen);  in nfs4svc_encode_compoundres()
6017 	memcpy(p, resp->tag, resp->taglen);  in nfs4svc_encode_compoundres()
6018 	p += XDR_QUADLEN(resp->taglen);  in nfs4svc_encode_compoundres()
6019 	*p++ = htonl(resp->opcnt);  in nfs4svc_encode_compoundres()