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()
334 		 * space for that many aces; something fishy is  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.seconds;  in nfsd4_decode_fattr4()
542 		iattr->ia_valid |= ATTR_CTIME | ATTR_MTIME | ATTR_MTIME_SET | ATTR_DELEG;  in nfsd4_decode_fattr4()
546 	if (attrlist4_count != xdr_stream_pos(argp->xdr) - starting_pos)  in nfsd4_decode_fattr4()
557 	p = xdr_inline_decode(argp->xdr, NFS4_STATEID_SIZE);  in nfsd4_decode_stateid4()
560 	sid->si_generation = be32_to_cpup(p++);  in nfsd4_decode_stateid4()
561 	memcpy(&sid->si_opaque, p, sizeof(sid->si_opaque));  in nfsd4_decode_stateid4()
570 	p = xdr_inline_decode(argp->xdr, sizeof(__be64));  in nfsd4_decode_clientid4()
596 	p = xdr_inline_decode(argp->xdr, NFS4_DEVICEID4_SIZE);  in nfsd4_decode_deviceid4()
607 	if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_layout_type) < 0)  in nfsd4_decode_layoutupdate4()
609 	if (lcp->lc_layout_type < LAYOUT_NFSV4_1_FILES)  in nfsd4_decode_layoutupdate4()
611 	if (lcp->lc_layout_type >= LAYOUT_TYPE_MAX)  in nfsd4_decode_layoutupdate4()
614 	if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_up_len) < 0)  in nfsd4_decode_layoutupdate4()
616 	if (lcp->lc_up_len > 0) {  in nfsd4_decode_layoutupdate4()
617 		lcp->lc_up_layout = xdr_inline_decode(argp->xdr, lcp->lc_up_len);  in nfsd4_decode_layoutupdate4()
618 		if (!lcp->lc_up_layout)  in nfsd4_decode_layoutupdate4()
631 	if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_return_type) < 0)  in nfsd4_decode_layoutreturn4()
633 	switch (lrp->lr_return_type) {  in nfsd4_decode_layoutreturn4()
635 		if (xdr_stream_decode_u64(argp->xdr, &lrp->lr_seg.offset) < 0)  in nfsd4_decode_layoutreturn4()
637 		if (xdr_stream_decode_u64(argp->xdr, &lrp->lr_seg.length) < 0)  in nfsd4_decode_layoutreturn4()
639 		status = nfsd4_decode_stateid4(argp, &lrp->lr_sid);  in nfsd4_decode_layoutreturn4()
642 		if (xdr_stream_decode_u32(argp->xdr, &lrp->lrf_body_len) < 0)  in nfsd4_decode_layoutreturn4()
644 		if (lrp->lrf_body_len > 0) {  in nfsd4_decode_layoutreturn4()
645 			lrp->lrf_body = xdr_inline_decode(argp->xdr, lrp->lrf_body_len);  in nfsd4_decode_layoutreturn4()
646 			if (!lrp->lrf_body)  in nfsd4_decode_layoutreturn4()
652 		lrp->lr_seg.offset = 0;  in nfsd4_decode_layoutreturn4()
653 		lrp->lr_seg.length = NFS4_MAX_UINT64;  in nfsd4_decode_layoutreturn4()
670 	p = xdr_inline_decode(argp->xdr, NFS4_MAX_SESSIONID_LEN);  in nfsd4_decode_sessionid4()
673 	memcpy(sessionid->data, p, sizeof(sessionid->data));  in nfsd4_decode_sessionid4()
685 	if (xdr_stream_decode_u32(argp->xdr, &stamp) < 0)  in nfsd4_decode_authsys_parms()
691 	if (xdr_stream_decode_u32(argp->xdr, &uid) < 0)  in nfsd4_decode_authsys_parms()
693 	if (xdr_stream_decode_u32(argp->xdr, &gid) < 0)  in nfsd4_decode_authsys_parms()
695 	if (xdr_stream_decode_u32(argp->xdr, &gidcount) < 0)  in nfsd4_decode_authsys_parms()
699 	p = xdr_inline_decode(argp->xdr, gidcount << 2);  in nfsd4_decode_authsys_parms()
702 	if (cbs->flavor == (u32)(-1)) {  in nfsd4_decode_authsys_parms()
703 		struct user_namespace *userns = nfsd_user_namespace(argp->rqstp);  in nfsd4_decode_authsys_parms()
708 			cbs->uid = kuid;  in nfsd4_decode_authsys_parms()
709 			cbs->gid = kgid;  in nfsd4_decode_authsys_parms()
710 			cbs->flavor = RPC_AUTH_UNIX;  in nfsd4_decode_authsys_parms()
728 	if (xdr_stream_decode_u32(argp->xdr, &service) < 0)  in nfsd4_decode_gss_cb_handles4()
752 	if (xdr_stream_decode_u32(argp->xdr, &nr_secflavs) < 0)  in nfsd4_decode_cb_sec()
755 		cbs->flavor = (u32)(-1);  in nfsd4_decode_cb_sec()
758 		cbs->flavor = 0;  in nfsd4_decode_cb_sec()
761 		if (xdr_stream_decode_u32(argp->xdr, &secflavor) < 0)  in nfsd4_decode_cb_sec()
766 			if (cbs->flavor == (u32)(-1))  in nfsd4_decode_cb_sec()
767 				cbs->flavor = RPC_AUTH_NULL;  in nfsd4_decode_cb_sec()
796 	struct nfsd4_access *access = &u->access;  in nfsd4_decode_access()
797 	if (xdr_stream_decode_u32(argp->xdr, &access->ac_req_access) < 0)  in nfsd4_decode_access()
805 	struct nfsd4_close *close = &u->close;  in nfsd4_decode_close()
806 	if (xdr_stream_decode_u32(argp->xdr, &close->cl_seqid) < 0)  in nfsd4_decode_close()
808 	return nfsd4_decode_stateid4(argp, &close->cl_stateid);  in nfsd4_decode_close()
815 	struct nfsd4_commit *commit = &u->commit;  in nfsd4_decode_commit()
816 	if (xdr_stream_decode_u64(argp->xdr, &commit->co_offset) < 0)  in nfsd4_decode_commit()
818 	if (xdr_stream_decode_u32(argp->xdr, &commit->co_count) < 0)  in nfsd4_decode_commit()
820 	memset(&commit->co_verf, 0, sizeof(commit->co_verf));  in nfsd4_decode_commit()
827 	struct nfsd4_create *create = &u->create;  in nfsd4_decode_create()
831 	if (xdr_stream_decode_u32(argp->xdr, &create->cr_type) < 0)  in nfsd4_decode_create()
833 	switch (create->cr_type) {  in nfsd4_decode_create()
835 		if (xdr_stream_decode_u32(argp->xdr, &create->cr_datalen) < 0)  in nfsd4_decode_create()
837 		p = xdr_inline_decode(argp->xdr, create->cr_datalen);  in nfsd4_decode_create()
840 		create->cr_data = svcxdr_dupstr(argp, p, create->cr_datalen);  in nfsd4_decode_create()
841 		if (!create->cr_data)  in nfsd4_decode_create()
846 		if (xdr_stream_decode_u32(argp->xdr, &create->cr_specdata1) < 0)  in nfsd4_decode_create()
848 		if (xdr_stream_decode_u32(argp->xdr, &create->cr_specdata2) < 0)  in nfsd4_decode_create()
857 	status = nfsd4_decode_component4(argp, &create->cr_name,  in nfsd4_decode_create()
858 					 &create->cr_namelen);  in nfsd4_decode_create()
861 	status = nfsd4_decode_fattr4(argp, create->cr_bmval,  in nfsd4_decode_create()
862 				    ARRAY_SIZE(create->cr_bmval),  in nfsd4_decode_create()
863 				    &create->cr_iattr, &create->cr_acl,  in nfsd4_decode_create()
864 				    &create->cr_label, &create->cr_umask);  in nfsd4_decode_create()
874 	struct nfsd4_delegreturn *dr = &u->delegreturn;  in nfsd4_decode_delegreturn()
875 	return nfsd4_decode_stateid4(argp, &dr->dr_stateid);  in nfsd4_decode_delegreturn()
881 	struct nfsd4_getattr *getattr = &u->getattr;  in nfsd4_decode_getattr()
883 	return nfsd4_decode_bitmap4(argp, getattr->ga_bmval,  in nfsd4_decode_getattr()
884 				    ARRAY_SIZE(getattr->ga_bmval));  in nfsd4_decode_getattr()
890 	struct nfsd4_link *link = &u->link;  in nfsd4_decode_link()
892 	return nfsd4_decode_component4(argp, &link->li_name, &link->li_namelen);  in nfsd4_decode_link()
901 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_new_open_seqid) < 0)  in nfsd4_decode_open_to_lock_owner4()
903 	status = nfsd4_decode_stateid4(argp, &lock->lk_new_open_stateid);  in nfsd4_decode_open_to_lock_owner4()
906 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_new_lock_seqid) < 0)  in nfsd4_decode_open_to_lock_owner4()
908 	return nfsd4_decode_state_owner4(argp, &lock->lk_new_clientid,  in nfsd4_decode_open_to_lock_owner4()
909 					 &lock->lk_new_owner);  in nfsd4_decode_open_to_lock_owner4()
918 	status = nfsd4_decode_stateid4(argp, &lock->lk_old_lock_stateid);  in nfsd4_decode_exist_lock_owner4()
921 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_old_lock_seqid) < 0)  in nfsd4_decode_exist_lock_owner4()
930 	if (xdr_stream_decode_bool(argp->xdr, &lock->lk_is_new) < 0)  in nfsd4_decode_locker4()
932 	if (lock->lk_is_new)  in nfsd4_decode_locker4()
940 	struct nfsd4_lock *lock = &u->lock;  in nfsd4_decode_lock()
942 	if (xdr_stream_decode_u32(argp->xdr, &lock->lk_type) < 0)  in nfsd4_decode_lock()
944 	if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT))  in nfsd4_decode_lock()
946 	if (xdr_stream_decode_bool(argp->xdr, &lock->lk_reclaim) < 0)  in nfsd4_decode_lock()
948 	if (xdr_stream_decode_u64(argp->xdr, &lock->lk_offset) < 0)  in nfsd4_decode_lock()
950 	if (xdr_stream_decode_u64(argp->xdr, &lock->lk_length) < 0)  in nfsd4_decode_lock()
958 	struct nfsd4_lockt *lockt = &u->lockt;  in nfsd4_decode_lockt()
960 	if (xdr_stream_decode_u32(argp->xdr, &lockt->lt_type) < 0)  in nfsd4_decode_lockt()
962 	if ((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT))  in nfsd4_decode_lockt()
964 	if (xdr_stream_decode_u64(argp->xdr, &lockt->lt_offset) < 0)  in nfsd4_decode_lockt()
966 	if (xdr_stream_decode_u64(argp->xdr, &lockt->lt_length) < 0)  in nfsd4_decode_lockt()
968 	return nfsd4_decode_state_owner4(argp, &lockt->lt_clientid,  in nfsd4_decode_lockt()
969 					 &lockt->lt_owner);  in nfsd4_decode_lockt()
975 	struct nfsd4_locku *locku = &u->locku;  in nfsd4_decode_locku()
978 	if (xdr_stream_decode_u32(argp->xdr, &locku->lu_type) < 0)  in nfsd4_decode_locku()
980 	if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT))  in nfsd4_decode_locku()
982 	if (xdr_stream_decode_u32(argp->xdr, &locku->lu_seqid) < 0)  in nfsd4_decode_locku()
984 	status = nfsd4_decode_stateid4(argp, &locku->lu_stateid);  in nfsd4_decode_locku()
987 	if (xdr_stream_decode_u64(argp->xdr, &locku->lu_offset) < 0)  in nfsd4_decode_locku()
989 	if (xdr_stream_decode_u64(argp->xdr, &locku->lu_length) < 0)  in nfsd4_decode_locku()
998 	struct nfsd4_lookup *lookup = &u->lookup;  in nfsd4_decode_lookup()
999 	return nfsd4_decode_component4(argp, &lookup->lo_name, &lookup->lo_len);  in nfsd4_decode_lookup()
1007 	if (xdr_stream_decode_u32(argp->xdr, &open->op_createmode) < 0)  in nfsd4_decode_createhow4()
1009 	switch (open->op_createmode) {  in nfsd4_decode_createhow4()
1012 		status = nfsd4_decode_fattr4(argp, open->op_bmval,  in nfsd4_decode_createhow4()
1013 					     ARRAY_SIZE(open->op_bmval),  in nfsd4_decode_createhow4()
1014 					     &open->op_iattr, &open->op_acl,  in nfsd4_decode_createhow4()
1015 					     &open->op_label, &open->op_umask);  in nfsd4_decode_createhow4()
1020 		status = nfsd4_decode_verifier4(argp, &open->op_verf);  in nfsd4_decode_createhow4()
1025 		if (argp->minorversion < 1)  in nfsd4_decode_createhow4()
1027 		status = nfsd4_decode_verifier4(argp, &open->op_verf);  in nfsd4_decode_createhow4()
1030 		status = nfsd4_decode_fattr4(argp, open->op_bmval,  in nfsd4_decode_createhow4()
1031 					     ARRAY_SIZE(open->op_bmval),  in nfsd4_decode_createhow4()
1032 					     &open->op_iattr, &open->op_acl,  in nfsd4_decode_createhow4()
1033 					     &open->op_label, &open->op_umask);  in nfsd4_decode_createhow4()
1049 	if (xdr_stream_decode_u32(argp->xdr, &open->op_create) < 0)  in nfsd4_decode_openflag4()
1051 	switch (open->op_create) {  in nfsd4_decode_openflag4()
1070 	if (xdr_stream_decode_u32(argp->xdr, &w) < 0)  in nfsd4_decode_share_access()
1088 	if (!argp->minorversion)  in nfsd4_decode_share_access()
1119 	if (xdr_stream_decode_u32(argp->xdr, x) < 0)  in nfsd4_decode_share_deny()
1134 	if (xdr_stream_decode_u32(argp->xdr, &open->op_claim_type) < 0)  in nfsd4_decode_open_claim4()
1136 	switch (open->op_claim_type) {  in nfsd4_decode_open_claim4()
1139 		status = nfsd4_decode_component4(argp, &open->op_fname,  in nfsd4_decode_open_claim4()
1140 						 &open->op_fnamelen);  in nfsd4_decode_open_claim4()
1145 		if (xdr_stream_decode_u32(argp->xdr, &open->op_delegate_type) < 0)  in nfsd4_decode_open_claim4()
1149 		status = nfsd4_decode_stateid4(argp, &open->op_delegate_stateid);  in nfsd4_decode_open_claim4()
1152 		status = nfsd4_decode_component4(argp, &open->op_fname,  in nfsd4_decode_open_claim4()
1153 						 &open->op_fnamelen);  in nfsd4_decode_open_claim4()
1159 		if (argp->minorversion < 1)  in nfsd4_decode_open_claim4()
1164 		if (argp->minorversion < 1)  in nfsd4_decode_open_claim4()
1166 		status = nfsd4_decode_stateid4(argp, &open->op_delegate_stateid);  in nfsd4_decode_open_claim4()
1180 	struct nfsd4_open *open = &u->open;  in nfsd4_decode_open()
1186 	if (xdr_stream_decode_u32(argp->xdr, &open->op_seqid) < 0)  in nfsd4_decode_open()
1189 	status = nfsd4_decode_share_access(argp, &open->op_share_access,  in nfsd4_decode_open()
1190 					   &open->op_deleg_want, &dummy);  in nfsd4_decode_open()
1193 	status = nfsd4_decode_share_deny(argp, &open->op_share_deny);  in nfsd4_decode_open()
1196 	status = nfsd4_decode_state_owner4(argp, &open->op_clientid,  in nfsd4_decode_open()
1197 					   &open->op_owner);  in nfsd4_decode_open()
1210 	struct nfsd4_open_confirm *open_conf = &u->open_confirm;  in nfsd4_decode_open_confirm()
1213 	if (argp->minorversion >= 1)  in nfsd4_decode_open_confirm()
1216 	status = nfsd4_decode_stateid4(argp, &open_conf->oc_req_stateid);  in nfsd4_decode_open_confirm()
1219 	if (xdr_stream_decode_u32(argp->xdr, &open_conf->oc_seqid) < 0)  in nfsd4_decode_open_confirm()
1222 	memset(&open_conf->oc_resp_stateid, 0,  in nfsd4_decode_open_confirm()
1223 	       sizeof(open_conf->oc_resp_stateid));  in nfsd4_decode_open_confirm()
1231 	struct nfsd4_open_downgrade *open_down = &u->open_downgrade;  in nfsd4_decode_open_downgrade()
1235 	status = nfsd4_decode_stateid4(argp, &open_down->od_stateid);  in nfsd4_decode_open_downgrade()
1238 	if (xdr_stream_decode_u32(argp->xdr, &open_down->od_seqid) < 0)  in nfsd4_decode_open_downgrade()
1241 	status = nfsd4_decode_share_access(argp, &open_down->od_share_access,  in nfsd4_decode_open_downgrade()
1242 					   &open_down->od_deleg_want, NULL);  in nfsd4_decode_open_downgrade()
1245 	return nfsd4_decode_share_deny(argp, &open_down->od_share_deny);  in nfsd4_decode_open_downgrade()
1251 	struct nfsd4_putfh *putfh = &u->putfh;  in nfsd4_decode_putfh()
1254 	if (xdr_stream_decode_u32(argp->xdr, &putfh->pf_fhlen) < 0)  in nfsd4_decode_putfh()
1256 	if (putfh->pf_fhlen > NFS4_FHSIZE)  in nfsd4_decode_putfh()
1258 	p = xdr_inline_decode(argp->xdr, putfh->pf_fhlen);  in nfsd4_decode_putfh()
1261 	putfh->pf_fhval = svcxdr_savemem(argp, p, putfh->pf_fhlen);  in nfsd4_decode_putfh()
1262 	if (!putfh->pf_fhval)  in nfsd4_decode_putfh()
1265 	putfh->no_verify = false;  in nfsd4_decode_putfh()
1272 	struct nfsd4_read *read = &u->read;  in nfsd4_decode_read()
1276 	status = nfsd4_decode_stateid4(argp, &read->rd_stateid);  in nfsd4_decode_read()
1279 	if (xdr_stream_decode_u64(argp->xdr, &read->rd_offset) < 0)  in nfsd4_decode_read()
1281 	if (xdr_stream_decode_u32(argp->xdr, &read->rd_length) < 0)  in nfsd4_decode_read()
1290 	struct nfsd4_readdir *readdir = &u->readdir;  in nfsd4_decode_readdir()
1294 	if (xdr_stream_decode_u64(argp->xdr, &readdir->rd_cookie) < 0)  in nfsd4_decode_readdir()
1296 	status = nfsd4_decode_verifier4(argp, &readdir->rd_verf);  in nfsd4_decode_readdir()
1299 	if (xdr_stream_decode_u32(argp->xdr, &readdir->rd_dircount) < 0)  in nfsd4_decode_readdir()
1301 	if (xdr_stream_decode_u32(argp->xdr, &readdir->rd_maxcount) < 0)  in nfsd4_decode_readdir()
1303 	if (xdr_stream_decode_uint32_array(argp->xdr, readdir->rd_bmval,  in nfsd4_decode_readdir()
1304 					   ARRAY_SIZE(readdir->rd_bmval)) < 0)  in nfsd4_decode_readdir()
1313 	struct nfsd4_remove *remove = &u->remove;  in nfsd4_decode_remove()
1314 	memset(&remove->rm_cinfo, 0, sizeof(remove->rm_cinfo));  in nfsd4_decode_remove()
1315 	return nfsd4_decode_component4(argp, &remove->rm_name, &remove->rm_namelen);  in nfsd4_decode_remove()
1321 	struct nfsd4_rename *rename = &u->rename;  in nfsd4_decode_rename()
1325 	status = nfsd4_decode_component4(argp, &rename->rn_sname, &rename->rn_snamelen);  in nfsd4_decode_rename()
1328 	return nfsd4_decode_component4(argp, &rename->rn_tname, &rename->rn_tnamelen);  in nfsd4_decode_rename()
1334 	clientid_t *clientid = &u->renew;  in nfsd4_decode_renew()
1342 	struct nfsd4_secinfo *secinfo = &u->secinfo;  in nfsd4_decode_secinfo()
1343 	secinfo->si_exp = NULL;  in nfsd4_decode_secinfo()
1344 	return nfsd4_decode_component4(argp, &secinfo->si_name, &secinfo->si_namelen);  in nfsd4_decode_secinfo()
1350 	struct nfsd4_setattr *setattr = &u->setattr;  in nfsd4_decode_setattr()
1354 	status = nfsd4_decode_stateid4(argp, &setattr->sa_stateid);  in nfsd4_decode_setattr()
1357 	return nfsd4_decode_fattr4(argp, setattr->sa_bmval,  in nfsd4_decode_setattr()
1358 				   ARRAY_SIZE(setattr->sa_bmval),  in nfsd4_decode_setattr()
1359 				   &setattr->sa_iattr, &setattr->sa_acl,  in nfsd4_decode_setattr()
1360 				   &setattr->sa_label, NULL);  in nfsd4_decode_setattr()
1366 	struct nfsd4_setclientid *setclientid = &u->setclientid;  in nfsd4_decode_setclientid()
1371 	if (argp->minorversion >= 1)  in nfsd4_decode_setclientid()
1374 	status = nfsd4_decode_verifier4(argp, &setclientid->se_verf);  in nfsd4_decode_setclientid()
1377 	status = nfsd4_decode_opaque(argp, &setclientid->se_name);  in nfsd4_decode_setclientid()
1380 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_prog) < 0)  in nfsd4_decode_setclientid()
1382 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_netid_len) < 0)  in nfsd4_decode_setclientid()
1384 	p = xdr_inline_decode(argp->xdr, setclientid->se_callback_netid_len);  in nfsd4_decode_setclientid()
1387 	setclientid->se_callback_netid_val = svcxdr_savemem(argp, p,  in nfsd4_decode_setclientid()
1388 						setclientid->se_callback_netid_len);  in nfsd4_decode_setclientid()
1389 	if (!setclientid->se_callback_netid_val)  in nfsd4_decode_setclientid()
1392 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_addr_len) < 0)  in nfsd4_decode_setclientid()
1394 	p = xdr_inline_decode(argp->xdr, setclientid->se_callback_addr_len);  in nfsd4_decode_setclientid()
1397 	setclientid->se_callback_addr_val = svcxdr_savemem(argp, p,  in nfsd4_decode_setclientid()
1398 						setclientid->se_callback_addr_len);  in nfsd4_decode_setclientid()
1399 	if (!setclientid->se_callback_addr_val)  in nfsd4_decode_setclientid()
1401 	if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_ident) < 0)  in nfsd4_decode_setclientid()
1411 	struct nfsd4_setclientid_confirm *scd_c = &u->setclientid_confirm;  in nfsd4_decode_setclientid_confirm()
1414 	if (argp->minorversion >= 1)  in nfsd4_decode_setclientid_confirm()
1417 	status = nfsd4_decode_clientid4(argp, &scd_c->sc_clientid);  in nfsd4_decode_setclientid_confirm()
1420 	return nfsd4_decode_verifier4(argp, &scd_c->sc_confirm);  in nfsd4_decode_setclientid_confirm()
1427 	struct nfsd4_verify *verify = &u->verify;  in nfsd4_decode_verify()
1432 	status = nfsd4_decode_bitmap4(argp, verify->ve_bmval,  in nfsd4_decode_verify()
1433 				      ARRAY_SIZE(verify->ve_bmval));  in nfsd4_decode_verify()
1440 	if (xdr_stream_decode_u32(argp->xdr, &verify->ve_attrlen) < 0)  in nfsd4_decode_verify()
1442 	p = xdr_inline_decode(argp->xdr, verify->ve_attrlen);  in nfsd4_decode_verify()
1445 	verify->ve_attrval = svcxdr_savemem(argp, p, verify->ve_attrlen);  in nfsd4_decode_verify()
1446 	if (!verify->ve_attrval)  in nfsd4_decode_verify()
1455 	struct nfsd4_write *write = &u->write;  in nfsd4_decode_write()
1458 	status = nfsd4_decode_stateid4(argp, &write->wr_stateid);  in nfsd4_decode_write()
1461 	if (xdr_stream_decode_u64(argp->xdr, &write->wr_offset) < 0)  in nfsd4_decode_write()
1463 	if (xdr_stream_decode_u32(argp->xdr, &write->wr_stable_how) < 0)  in nfsd4_decode_write()
1465 	if (write->wr_stable_how > NFS_FILE_SYNC)  in nfsd4_decode_write()
1467 	if (xdr_stream_decode_u32(argp->xdr, &write->wr_buflen) < 0)  in nfsd4_decode_write()
1469 	if (!xdr_stream_subsegment(argp->xdr, &write->wr_payload, write->wr_buflen))  in nfsd4_decode_write()
1472 	write->wr_bytes_written = 0;  in nfsd4_decode_write()
1473 	write->wr_how_written = 0;  in nfsd4_decode_write()
1474 	memset(&write->wr_verifier, 0, sizeof(write->wr_verifier));  in nfsd4_decode_write()
1482 	struct nfsd4_release_lockowner *rlockowner = &u->release_lockowner;  in nfsd4_decode_release_lockowner()
1485 	if (argp->minorversion >= 1)  in nfsd4_decode_release_lockowner()
1488 	status = nfsd4_decode_state_owner4(argp, &rlockowner->rl_clientid,  in nfsd4_decode_release_lockowner()
1489 					   &rlockowner->rl_owner);  in nfsd4_decode_release_lockowner()
1493 	if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid))  in nfsd4_decode_release_lockowner()
1502 	struct nfsd4_backchannel_ctl *bc = &u->backchannel_ctl;  in nfsd4_decode_backchannel_ctl()
1504 	if (xdr_stream_decode_u32(argp->xdr, &bc->bc_cb_program) < 0)  in nfsd4_decode_backchannel_ctl()
1506 	return nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec);  in nfsd4_decode_backchannel_ctl()
1512 	struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session;  in nfsd4_decode_bind_conn_to_session()
1517 	status = nfsd4_decode_sessionid4(argp, &bcts->sessionid);  in nfsd4_decode_bind_conn_to_session()
1520 	if (xdr_stream_decode_u32(argp->xdr, &bcts->dir) < 0)  in nfsd4_decode_bind_conn_to_session()
1522 	if (xdr_stream_decode_u32(argp->xdr, &use_conn_in_rdma_mode) < 0)  in nfsd4_decode_bind_conn_to_session()
1534 	status = nfsd4_decode_bitmap4(argp, exid->spo_must_enforce,  in nfsd4_decode_state_protect_ops()
1535 				      ARRAY_SIZE(exid->spo_must_enforce));  in nfsd4_decode_state_protect_ops()
1538 	status = nfsd4_decode_bitmap4(argp, exid->spo_must_allow,  in nfsd4_decode_state_protect_ops()
1539 				      ARRAY_SIZE(exid->spo_must_allow));  in nfsd4_decode_state_protect_ops()
1563 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)  in nfsd4_decode_ssv_sp_parms()
1565 	while (count--) {  in nfsd4_decode_ssv_sp_parms()
1572 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)  in nfsd4_decode_ssv_sp_parms()
1574 	while (count--) {  in nfsd4_decode_ssv_sp_parms()
1580 	if (xdr_stream_decode_u32(argp->xdr, &window) < 0)  in nfsd4_decode_ssv_sp_parms()
1582 	if (xdr_stream_decode_u32(argp->xdr, &num_gss_handles) < 0)  in nfsd4_decode_ssv_sp_parms()
1594 	if (xdr_stream_decode_u32(argp->xdr, &exid->spa_how) < 0)  in nfsd4_decode_state_protect4_a()
1596 	switch (exid->spa_how) {  in nfsd4_decode_state_protect4_a()
1623 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)  in nfsd4_decode_nfs_impl_id4()
1632 		status = nfsd4_decode_opaque(argp, &exid->nii_domain);  in nfsd4_decode_nfs_impl_id4()
1638 		status = nfsd4_decode_opaque(argp, &exid->nii_name);  in nfsd4_decode_nfs_impl_id4()
1641 		status = nfsd4_decode_nfstime4(argp, &exid->nii_time);  in nfsd4_decode_nfs_impl_id4()
1656 	struct nfsd4_exchange_id *exid = &u->exchange_id;  in nfsd4_decode_exchange_id()
1660 	status = nfsd4_decode_verifier4(argp, &exid->verifier);  in nfsd4_decode_exchange_id()
1663 	status = nfsd4_decode_opaque(argp, &exid->clname);  in nfsd4_decode_exchange_id()
1666 	if (xdr_stream_decode_u32(argp->xdr, &exid->flags) < 0)  in nfsd4_decode_exchange_id()
1680 	p = xdr_inline_decode(argp->xdr, XDR_UNIT * 7);  in nfsd4_decode_channel_attrs4()
1686 	ca->maxreq_sz = be32_to_cpup(p++);  in nfsd4_decode_channel_attrs4()
1687 	ca->maxresp_sz = be32_to_cpup(p++);  in nfsd4_decode_channel_attrs4()
1688 	ca->maxresp_cached = be32_to_cpup(p++);  in nfsd4_decode_channel_attrs4()
1689 	ca->maxops = be32_to_cpup(p++);  in nfsd4_decode_channel_attrs4()
1690 	ca->maxreqs = be32_to_cpup(p++);  in nfsd4_decode_channel_attrs4()
1691 	ca->nr_rdma_attrs = be32_to_cpup(p);  in nfsd4_decode_channel_attrs4()
1692 	switch (ca->nr_rdma_attrs) {  in nfsd4_decode_channel_attrs4()
1696 		if (xdr_stream_decode_u32(argp->xdr, &ca->rdma_attrs) < 0)  in nfsd4_decode_channel_attrs4()
1710 	struct nfsd4_create_session *sess = &u->create_session;  in nfsd4_decode_create_session()
1714 	status = nfsd4_decode_clientid4(argp, &sess->clientid);  in nfsd4_decode_create_session()
1717 	if (xdr_stream_decode_u32(argp->xdr, &sess->seqid) < 0)  in nfsd4_decode_create_session()
1719 	if (xdr_stream_decode_u32(argp->xdr, &sess->flags) < 0)  in nfsd4_decode_create_session()
1721 	status = nfsd4_decode_channel_attrs4(argp, &sess->fore_channel);  in nfsd4_decode_create_session()
1724 	status = nfsd4_decode_channel_attrs4(argp, &sess->back_channel);  in nfsd4_decode_create_session()
1727 	if (xdr_stream_decode_u32(argp->xdr, &sess->callback_prog) < 0)  in nfsd4_decode_create_session()
1729 	return nfsd4_decode_cb_sec(argp, &sess->cb_sec);  in nfsd4_decode_create_session()
1736 	struct nfsd4_destroy_session *destroy_session = &u->destroy_session;  in nfsd4_decode_destroy_session()
1737 	return nfsd4_decode_sessionid4(argp, &destroy_session->sessionid);  in nfsd4_decode_destroy_session()
1744 	struct nfsd4_free_stateid *free_stateid = &u->free_stateid;  in nfsd4_decode_free_stateid()
1745 	return nfsd4_decode_stateid4(argp, &free_stateid->fr_stateid);  in nfsd4_decode_free_stateid()
1752 	struct nfsd4_get_dir_delegation *gdd = &u->get_dir_delegation;  in nfsd4_decode_get_dir_delegation()
1757 	if (xdr_stream_decode_bool(argp->xdr, &gdd->gdda_signal_deleg_avail) < 0)  in nfsd4_decode_get_dir_delegation()
1759 	status = nfsd4_decode_bitmap4(argp, gdd->gdda_notification_types,  in nfsd4_decode_get_dir_delegation()
1760 				      ARRAY_SIZE(gdd->gdda_notification_types));  in nfsd4_decode_get_dir_delegation()
1763 	status = nfsd4_decode_nfstime4(argp, &gdd->gdda_child_attr_delay);  in nfsd4_decode_get_dir_delegation()
1766 	status = nfsd4_decode_nfstime4(argp, &gdd->gdda_dir_attr_delay);  in nfsd4_decode_get_dir_delegation()
1769 	status = nfsd4_decode_bitmap4(argp, gdd->gdda_child_attributes,  in nfsd4_decode_get_dir_delegation()
1770 					ARRAY_SIZE(gdd->gdda_child_attributes));  in nfsd4_decode_get_dir_delegation()
1773 	return nfsd4_decode_bitmap4(argp, gdd->gdda_dir_attributes,  in nfsd4_decode_get_dir_delegation()
1774 					ARRAY_SIZE(gdd->gdda_dir_attributes));  in nfsd4_decode_get_dir_delegation()
1782 	struct nfsd4_getdeviceinfo *gdev = &u->getdeviceinfo;  in nfsd4_decode_getdeviceinfo()
1786 	status = nfsd4_decode_deviceid4(argp, &gdev->gd_devid);  in nfsd4_decode_getdeviceinfo()
1789 	if (xdr_stream_decode_u32(argp->xdr, &gdev->gd_layout_type) < 0)  in nfsd4_decode_getdeviceinfo()
1791 	if (xdr_stream_decode_u32(argp->xdr, &gdev->gd_maxcount) < 0)  in nfsd4_decode_getdeviceinfo()
1793 	if (xdr_stream_decode_uint32_array(argp->xdr,  in nfsd4_decode_getdeviceinfo()
1794 					   &gdev->gd_notify_types, 1) < 0)  in nfsd4_decode_getdeviceinfo()
1804 	struct nfsd4_layoutcommit *lcp = &u->layoutcommit;  in nfsd4_decode_layoutcommit()
1808 	if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_seg.offset) < 0)  in nfsd4_decode_layoutcommit()
1810 	if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_seg.length) < 0)  in nfsd4_decode_layoutcommit()
1812 	if (xdr_stream_decode_bool(argp->xdr, &lcp->lc_reclaim) < 0)  in nfsd4_decode_layoutcommit()
1814 	status = nfsd4_decode_stateid4(argp, &lcp->lc_sid);  in nfsd4_decode_layoutcommit()
1817 	if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_newoffset) < 0)  in nfsd4_decode_layoutcommit()
1819 	if (lcp->lc_newoffset) {  in nfsd4_decode_layoutcommit()
1820 		if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_last_wr) < 0)  in nfsd4_decode_layoutcommit()
1823 		lcp->lc_last_wr = 0;  in nfsd4_decode_layoutcommit()
1824 	p = xdr_inline_decode(argp->xdr, XDR_UNIT);  in nfsd4_decode_layoutcommit()
1828 		status = nfsd4_decode_nfstime4(argp, &lcp->lc_mtime);  in nfsd4_decode_layoutcommit()
1832 		lcp->lc_mtime.tv_nsec = UTIME_NOW;  in nfsd4_decode_layoutcommit()
1841 	struct nfsd4_layoutget *lgp = &u->layoutget;  in nfsd4_decode_layoutget()
1845 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_signal) < 0)  in nfsd4_decode_layoutget()
1847 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_layout_type) < 0)  in nfsd4_decode_layoutget()
1849 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_seg.iomode) < 0)  in nfsd4_decode_layoutget()
1851 	if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_seg.offset) < 0)  in nfsd4_decode_layoutget()
1853 	if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_seg.length) < 0)  in nfsd4_decode_layoutget()
1855 	if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_minlength) < 0)  in nfsd4_decode_layoutget()
1857 	status = nfsd4_decode_stateid4(argp, &lgp->lg_sid);  in nfsd4_decode_layoutget()
1860 	if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_maxcount) < 0)  in nfsd4_decode_layoutget()
1870 	struct nfsd4_layoutreturn *lrp = &u->layoutreturn;  in nfsd4_decode_layoutreturn()
1872 	if (xdr_stream_decode_bool(argp->xdr, &lrp->lr_reclaim) < 0)  in nfsd4_decode_layoutreturn()
1874 	if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_layout_type) < 0)  in nfsd4_decode_layoutreturn()
1876 	if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_seg.iomode) < 0)  in nfsd4_decode_layoutreturn()
1885 	struct nfsd4_secinfo_no_name *sin = &u->secinfo_no_name;  in nfsd4_decode_secinfo_no_name()
1886 	if (xdr_stream_decode_u32(argp->xdr, &sin->sin_style) < 0)  in nfsd4_decode_secinfo_no_name()
1889 	sin->sin_exp = NULL;  in nfsd4_decode_secinfo_no_name()
1897 	struct nfsd4_sequence *seq = &u->sequence;  in nfsd4_decode_sequence()
1900 	status = nfsd4_decode_sessionid4(argp, &seq->sessionid);  in nfsd4_decode_sequence()
1903 	p = xdr_inline_decode(argp->xdr, XDR_UNIT * 4);  in nfsd4_decode_sequence()
1906 	seq->seqid = be32_to_cpup(p++);  in nfsd4_decode_sequence()
1907 	seq->slotid = be32_to_cpup(p++);  in nfsd4_decode_sequence()
1909 	seq->maxslots = be32_to_cpup(p++) + 1;  in nfsd4_decode_sequence()
1910 	seq->cachethis = be32_to_cpup(p);  in nfsd4_decode_sequence()
1912 	seq->status_flags = 0;  in nfsd4_decode_sequence()
1920 	struct nfsd4_test_stateid *test_stateid = &u->test_stateid;  in nfsd4_decode_test_stateid()
1926 	if (xdr_stream_decode_u32(argp->xdr, &test_stateid->ts_num_ids) < 0)  in nfsd4_decode_test_stateid()
1929 	INIT_LIST_HEAD(&test_stateid->ts_stateid_list);  in nfsd4_decode_test_stateid()
1930 	for (i = 0; i < test_stateid->ts_num_ids; i++) {  in nfsd4_decode_test_stateid()
1934 		INIT_LIST_HEAD(&stateid->ts_id_list);  in nfsd4_decode_test_stateid()
1935 		list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list);  in nfsd4_decode_test_stateid()
1936 		status = nfsd4_decode_stateid4(argp, &stateid->ts_id_stateid);  in nfsd4_decode_test_stateid()
1947 	struct nfsd4_destroy_clientid *dc = &u->destroy_clientid;  in nfsd4_decode_destroy_clientid()
1948 	return nfsd4_decode_clientid4(argp, &dc->clientid);  in nfsd4_decode_destroy_clientid()
1954 	struct nfsd4_reclaim_complete *rc = &u->reclaim_complete;  in nfsd4_decode_reclaim_complete()
1955 	if (xdr_stream_decode_bool(argp->xdr, &rc->rca_one_fs) < 0)  in nfsd4_decode_reclaim_complete()
1964 	struct nfsd4_fallocate *fallocate = &u->allocate;  in nfsd4_decode_fallocate()
1967 	status = nfsd4_decode_stateid4(argp, &fallocate->falloc_stateid);  in nfsd4_decode_fallocate()
1970 	if (xdr_stream_decode_u64(argp->xdr, &fallocate->falloc_offset) < 0)  in nfsd4_decode_fallocate()
1972 	if (xdr_stream_decode_u64(argp->xdr, &fallocate->falloc_length) < 0)  in nfsd4_decode_fallocate()
1984 	if (xdr_stream_decode_u32(argp->xdr, &ns->nl4_type) < 0)  in nfsd4_decode_nl4_server()
1987 	/* currently support for 1 inter-server source server */  in nfsd4_decode_nl4_server()
1988 	switch (ns->nl4_type) {  in nfsd4_decode_nl4_server()
1990 		naddr = &ns->u.nl4_addr;  in nfsd4_decode_nl4_server()
1992 		if (xdr_stream_decode_u32(argp->xdr, &naddr->netid_len) < 0)  in nfsd4_decode_nl4_server()
1994 		if (naddr->netid_len > RPCBIND_MAXNETIDLEN)  in nfsd4_decode_nl4_server()
1997 		p = xdr_inline_decode(argp->xdr, naddr->netid_len);  in nfsd4_decode_nl4_server()
2000 		memcpy(naddr->netid, p, naddr->netid_len);  in nfsd4_decode_nl4_server()
2002 		if (xdr_stream_decode_u32(argp->xdr, &naddr->addr_len) < 0)  in nfsd4_decode_nl4_server()
2004 		if (naddr->addr_len > RPCBIND_MAXUADDRLEN)  in nfsd4_decode_nl4_server()
2007 		p = xdr_inline_decode(argp->xdr, naddr->addr_len);  in nfsd4_decode_nl4_server()
2010 		memcpy(naddr->addr, p, naddr->addr_len);  in nfsd4_decode_nl4_server()
2022 	struct nfsd4_copy *copy = &u->copy;  in nfsd4_decode_copy()
2028 	status = nfsd4_decode_stateid4(argp, &copy->cp_src_stateid);  in nfsd4_decode_copy()
2031 	status = nfsd4_decode_stateid4(argp, &copy->cp_dst_stateid);  in nfsd4_decode_copy()
2034 	if (xdr_stream_decode_u64(argp->xdr, &copy->cp_src_pos) < 0)  in nfsd4_decode_copy()
2036 	if (xdr_stream_decode_u64(argp->xdr, &copy->cp_dst_pos) < 0)  in nfsd4_decode_copy()
2038 	if (xdr_stream_decode_u64(argp->xdr, &copy->cp_count) < 0)  in nfsd4_decode_copy()
2041 	if (xdr_stream_decode_u32(argp->xdr, &consecutive) < 0)  in nfsd4_decode_copy()
2043 	if (xdr_stream_decode_bool(argp->xdr, &sync) < 0)  in nfsd4_decode_copy()
2047 	if (xdr_stream_decode_u32(argp->xdr, &count) < 0)  in nfsd4_decode_copy()
2049 	copy->cp_src = svcxdr_tmpalloc(argp, sizeof(*copy->cp_src));  in nfsd4_decode_copy()
2050 	if (copy->cp_src == NULL)  in nfsd4_decode_copy()
2052 	if (count == 0) { /* intra-server copy */  in nfsd4_decode_copy()
2053 		__set_bit(NFSD4_COPY_F_INTRA, &copy->cp_flags);  in nfsd4_decode_copy()
2058 	status = nfsd4_decode_nl4_server(argp, copy->cp_src);  in nfsd4_decode_copy()
2065 	for (i = 0; i < count - 1; i++) {  in nfsd4_decode_copy()
2081 	struct nfsd4_copy_notify *cn = &u->copy_notify;  in nfsd4_decode_copy_notify()
2085 	cn->cpn_src = svcxdr_tmpalloc(argp, sizeof(*cn->cpn_src));  in nfsd4_decode_copy_notify()
2086 	if (cn->cpn_src == NULL)  in nfsd4_decode_copy_notify()
2088 	cn->cpn_dst = svcxdr_tmpalloc(argp, sizeof(*cn->cpn_dst));  in nfsd4_decode_copy_notify()
2089 	if (cn->cpn_dst == NULL)  in nfsd4_decode_copy_notify()
2092 	status = nfsd4_decode_stateid4(argp, &cn->cpn_src_stateid);  in nfsd4_decode_copy_notify()
2095 	return nfsd4_decode_nl4_server(argp, cn->cpn_dst);  in nfsd4_decode_copy_notify()
2102 	struct nfsd4_offload_status *os = &u->offload_status;  in nfsd4_decode_offload_status()
2103 	os->count = 0;  in nfsd4_decode_offload_status()
2104 	os->status = 0;  in nfsd4_decode_offload_status()
2105 	return nfsd4_decode_stateid4(argp, &os->stateid);  in nfsd4_decode_offload_status()
2111 	struct nfsd4_seek *seek = &u->seek;  in nfsd4_decode_seek()
2114 	status = nfsd4_decode_stateid4(argp, &seek->seek_stateid);  in nfsd4_decode_seek()
2117 	if (xdr_stream_decode_u64(argp->xdr, &seek->seek_offset) < 0)  in nfsd4_decode_seek()
2119 	if (xdr_stream_decode_u32(argp->xdr, &seek->seek_whence) < 0)  in nfsd4_decode_seek()
2122 	seek->seek_eof = 0;  in nfsd4_decode_seek()
2123 	seek->seek_pos = 0;  in nfsd4_decode_seek()
2130 	struct nfsd4_clone *clone = &u->clone;  in nfsd4_decode_clone()
2133 	status = nfsd4_decode_stateid4(argp, &clone->cl_src_stateid);  in nfsd4_decode_clone()
2136 	status = nfsd4_decode_stateid4(argp, &clone->cl_dst_stateid);  in nfsd4_decode_clone()
2139 	if (xdr_stream_decode_u64(argp->xdr, &clone->cl_src_pos) < 0)  in nfsd4_decode_clone()
2141 	if (xdr_stream_decode_u64(argp->xdr, &clone->cl_dst_pos) < 0)  in nfsd4_decode_clone()
2143 	if (xdr_stream_decode_u64(argp->xdr, &clone->cl_count) < 0)  in nfsd4_decode_clone()
2154  * is 64k). Since there is no kvec- or page-based interface to xattrs,
2165 	struct page **pages = xdr->pages;  in nfsd4_vbuf_from_vector()
2166 	struct kvec *head = xdr->head;  in nfsd4_vbuf_from_vector()
2170 	if (buflen <= head->iov_len) {  in nfsd4_vbuf_from_vector()
2175 		*bufp = head->iov_base;  in nfsd4_vbuf_from_vector()
2184 	memcpy(dp, head->iov_base, head->iov_len);  in nfsd4_vbuf_from_vector()
2185 	buflen -= head->iov_len;  in nfsd4_vbuf_from_vector()
2186 	dp += head->iov_len;  in nfsd4_vbuf_from_vector()
2192 		buflen -= len;  in nfsd4_vbuf_from_vector()
2213 	if (xdr_stream_decode_u32(argp->xdr, &namelen) < 0)  in nfsd4_decode_xattr_name()
2215 	if (namelen > (XATTR_NAME_MAX - XATTR_USER_PREFIX_LEN))  in nfsd4_decode_xattr_name()
2219 	p = xdr_inline_decode(argp->xdr, namelen);  in nfsd4_decode_xattr_name()
2235 	while (cnt-- > 0) {  in nfsd4_decode_xattr_name()
2248  * A GETXATTR op request comes without a length specifier. We just set the
2257 	struct nfsd4_getxattr *getxattr = &u->getxattr;  in nfsd4_decode_getxattr()
2262 	status = nfsd4_decode_xattr_name(argp, &getxattr->getxa_name);  in nfsd4_decode_getxattr()
2266 	maxcount = svc_max_payload(argp->rqstp);  in nfsd4_decode_getxattr()
2269 	getxattr->getxa_len = maxcount;  in nfsd4_decode_getxattr()
2277 	struct nfsd4_setxattr *setxattr = &u->setxattr;  in nfsd4_decode_setxattr()
2283 	if (xdr_stream_decode_u32(argp->xdr, &flags) < 0)  in nfsd4_decode_setxattr()
2288 	setxattr->setxa_flags = flags;  in nfsd4_decode_setxattr()
2290 	status = nfsd4_decode_xattr_name(argp, &setxattr->setxa_name);  in nfsd4_decode_setxattr()
2294 	maxcount = svc_max_payload(argp->rqstp);  in nfsd4_decode_setxattr()
2297 	if (xdr_stream_decode_u32(argp->xdr, &size) < 0)  in nfsd4_decode_setxattr()
2302 	setxattr->setxa_len = size;  in nfsd4_decode_setxattr()
2306 		if (!xdr_stream_subsegment(argp->xdr, &payload, size))  in nfsd4_decode_setxattr()
2309 						&setxattr->setxa_buf, size);  in nfsd4_decode_setxattr()
2319 	struct nfsd4_listxattrs *listxattrs = &u->listxattrs;  in nfsd4_decode_listxattrs()
2324 	if (xdr_stream_decode_u64(argp->xdr, &listxattrs->lsxa_cookie) < 0)  in nfsd4_decode_listxattrs()
2331 	if (listxattrs->lsxa_cookie >=  in nfsd4_decode_listxattrs()
2335 	if (xdr_stream_decode_u32(argp->xdr, &maxcount) < 0)  in nfsd4_decode_listxattrs()
2341 	maxcount = min(maxcount, svc_max_payload(argp->rqstp));  in nfsd4_decode_listxattrs()
2342 	listxattrs->lsxa_maxcount = maxcount;  in nfsd4_decode_listxattrs()
2351 	struct nfsd4_removexattr *removexattr = &u->removexattr;  in nfsd4_decode_removexattr()
2353 	return nfsd4_decode_xattr_name(argp, &removexattr->rmxa_name);  in nfsd4_decode_removexattr()
2462 	if (op->opnum < FIRST_NFS4_OP)  in nfsd4_opnum_in_range()
2464 	else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP)  in nfsd4_opnum_in_range()
2466 	else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP)  in nfsd4_opnum_in_range()
2468 	else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP)  in nfsd4_opnum_in_range()
2478 	int auth_slack= argp->rqstp->rq_auth_slack;  in nfsd4_decode_compound()
2485 	if (xdr_stream_decode_u32(argp->xdr, &argp->taglen) < 0)  in nfsd4_decode_compound()
2488 	argp->tag = NULL;  in nfsd4_decode_compound()
2489 	if (unlikely(argp->taglen)) {  in nfsd4_decode_compound()
2490 		if (argp->taglen > NFSD4_MAX_TAGLEN)  in nfsd4_decode_compound()
2492 		p = xdr_inline_decode(argp->xdr, argp->taglen);  in nfsd4_decode_compound()
2495 		argp->tag = svcxdr_savemem(argp, p, argp->taglen);  in nfsd4_decode_compound()
2496 		if (!argp->tag)  in nfsd4_decode_compound()
2498 		max_reply += xdr_align_size(argp->taglen);  in nfsd4_decode_compound()
2501 	if (xdr_stream_decode_u32(argp->xdr, &argp->minorversion) < 0)  in nfsd4_decode_compound()
2503 	if (xdr_stream_decode_u32(argp->xdr, &argp->client_opcnt) < 0)  in nfsd4_decode_compound()
2505 	argp->opcnt = min_t(u32, argp->client_opcnt,  in nfsd4_decode_compound()
2508 	if (argp->opcnt > ARRAY_SIZE(argp->iops)) {  in nfsd4_decode_compound()
2509 		argp->ops = vcalloc(argp->opcnt, sizeof(*argp->ops));  in nfsd4_decode_compound()
2510 		if (!argp->ops) {  in nfsd4_decode_compound()
2511 			argp->ops = argp->iops;  in nfsd4_decode_compound()
2516 	if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION)  in nfsd4_decode_compound()
2517 		argp->opcnt = 0;  in nfsd4_decode_compound()
2519 	for (i = 0; i < argp->opcnt; i++) {  in nfsd4_decode_compound()
2520 		op = &argp->ops[i];  in nfsd4_decode_compound()
2521 		op->replay = NULL;  in nfsd4_decode_compound()
2522 		op->opdesc = NULL;  in nfsd4_decode_compound()
2524 		if (xdr_stream_decode_u32(argp->xdr, &op->opnum) < 0)  in nfsd4_decode_compound()
2527 			op->opdesc = OPDESC(op);  in nfsd4_decode_compound()
2528 			op->status = nfsd4_dec_ops[op->opnum](argp, &op->u);  in nfsd4_decode_compound()
2529 			if (op->status != nfs_ok)  in nfsd4_decode_compound()
2530 				trace_nfsd_compound_decode_err(argp->rqstp,  in nfsd4_decode_compound()
2531 							       argp->opcnt, i,  in nfsd4_decode_compound()
2532 							       op->opnum,  in nfsd4_decode_compound()
2533 							       op->status);  in nfsd4_decode_compound()
2535 			op->opnum = OP_ILLEGAL;  in nfsd4_decode_compound()
2536 			op->status = nfserr_op_illegal;  in nfsd4_decode_compound()
2545 		if (op->opnum == OP_READ || op->opnum == OP_READ_PLUS) {  in nfsd4_decode_compound()
2547 			readbytes += nfsd4_max_reply(argp->rqstp, op);  in nfsd4_decode_compound()
2549 			max_reply += nfsd4_max_reply(argp->rqstp, op);  in nfsd4_decode_compound()
2556 		if (op->opnum == OP_LOCK || op->opnum == OP_LOCKT)  in nfsd4_decode_compound()
2559 		if (op->status) {  in nfsd4_decode_compound()
2560 			argp->opcnt = i+1;  in nfsd4_decode_compound()
2565 	if (argp->minorversion)  in nfsd4_decode_compound()
2567 	svc_reserve(argp->rqstp, max_reply + readbytes);  in nfsd4_decode_compound()
2568 	argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE;  in nfsd4_decode_compound()
2570 	argp->splice_ok = nfsd_read_splice_ok(argp->rqstp);  in nfsd4_decode_compound()
2571 	if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack)  in nfsd4_decode_compound()
2572 		argp->splice_ok = false;  in nfsd4_decode_compound()
2580 	return nfsd4_encode_opaque(xdr, fh_handle->fh_raw, fh_handle->fh_size);  in nfsd4_encode_nfs_fh4()
2583 /* This is a frequently-encoded type; open-coded for speed */
2592 	p = xdr_encode_hyper(p, tv->tv_sec);  in nfsd4_encode_nfstime4()
2593 	*p = cpu_to_be32(tv->tv_nsec);  in nfsd4_encode_nfstime4()
2613 	status = nfsd4_encode_bool(xdr, c->atomic);  in nfsd4_encode_change_info4()
2616 	status = nfsd4_encode_changeid4(xdr, c->before_change);  in nfsd4_encode_change_info4()
2619 	return nfsd4_encode_changeid4(xdr, c->after_change);  in nfsd4_encode_change_info4()
2628 	status = nfsd4_encode_opaque(xdr, addr->netid, addr->netid_len);  in nfsd4_encode_netaddr4()
2632 	return nfsd4_encode_opaque(xdr, addr->addr, addr->addr_len);  in nfsd4_encode_netaddr4()
2650 	pathlen_offset = xdr->buf->len;  in nfsd4_encode_components_esc()
2675 		strlen = end - str;  in nfsd4_encode_components_esc()
2688 	write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4);  in nfsd4_encode_components_esc()
2706 	status = nfsd4_encode_components_esc(xdr, ':', location->hosts,  in nfsd4_encode_fs_location4()
2710 	status = nfsd4_encode_components(xdr, '/', location->path);  in nfsd4_encode_fs_location4()
2734 		if (cur.dentry == cur.mnt->mnt_root) {  in nfsd4_encode_pathname4()
2756 		struct dentry *dentry = components[ncomponents - 1];  in nfsd4_encode_pathname4()
2758 		spin_lock(&dentry->d_lock);  in nfsd4_encode_pathname4()
2759 		if (xdr_stream_encode_opaque(xdr, dentry->d_name.name,  in nfsd4_encode_pathname4()
2760 					     dentry->d_name.len) < 0) {  in nfsd4_encode_pathname4()
2761 			spin_unlock(&dentry->d_lock);  in nfsd4_encode_pathname4()
2765 		spin_unlock(&dentry->d_lock);  in nfsd4_encode_pathname4()
2767 		ncomponents--;  in nfsd4_encode_pathname4()
2774 		dput(components[--ncomponents]);  in nfsd4_encode_pathname4()
2784 	struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs;  in nfsd4_encode_fs_locations4()
2793 	status = nfsd4_encode_pathname4(xdr, &exp_ps->ex_path, &exp->ex_path);  in nfsd4_encode_fs_locations4()
2799 	if (xdr_stream_encode_u32(xdr, fslocs->locations_count) != XDR_UNIT)  in nfsd4_encode_fs_locations4()
2801 	for (i = 0; i < fslocs->locations_count; i++) {  in nfsd4_encode_fs_locations4()
2802 		status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]);  in nfsd4_encode_fs_locations4()
2816 	status = nfsd4_encode_acetype4(xdr, ace->type);  in nfsd4_encode_nfsace4()
2820 	status = nfsd4_encode_aceflag4(xdr, ace->flag);  in nfsd4_encode_nfsace4()
2824 	status = nfsd4_encode_acemask4(xdr, ace->access_mask & NFS4_ACE_MASK_ALL);  in nfsd4_encode_nfsace4()
2828 	if (ace->whotype != NFS4_ACL_WHO_NAMED)  in nfsd4_encode_nfsace4()
2829 		return nfs4_acl_write_who(xdr, ace->whotype);  in nfsd4_encode_nfsace4()
2830 	if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP)  in nfsd4_encode_nfsace4()
2831 		return nfsd4_encode_group(xdr, rqstp, ace->who_gid);  in nfsd4_encode_nfsace4()
2832 	return nfsd4_encode_user(xdr, rqstp, ace->who_uid);  in nfsd4_encode_nfsace4()
2847 	p = xdr_reserve_space(xdr, context->len + 4 + 4 + 4);  in nfsd4_encode_security_label()
2857 	p = xdr_encode_opaque(p, context->context, context->len);  in nfsd4_encode_security_label()
2887 	struct path path = exp->ex_path;  in nfsd4_get_mounted_on_ino()
2893 		if (path.dentry != path.mnt->mnt_root)  in nfsd4_get_mounted_on_ino()
2977 	struct nfsd4_compoundres *resp = args->rqstp->rq_resp;  in nfsd4_encode_fattr4_supported_attrs()
2978 	u32 minorversion = resp->cstate.minorversion;  in nfsd4_encode_fattr4_supported_attrs()
2982 	if (!IS_POSIXACL(d_inode(args->dentry)))  in nfsd4_encode_fattr4_supported_attrs()
2984 	if (!args->contextsupport)  in nfsd4_encode_fattr4_supported_attrs()
2999 	switch (args->stat.mode & S_IFMT) {  in nfsd4_encode_fattr4_type()
3034 	if (!(args->exp->ex_flags & NFSEXP_NOSUBTREECHECK))  in nfsd4_encode_fattr4_fh_expire_type()
3042 	const struct svc_export *exp = args->exp;  in nfsd4_encode_fattr4_change()
3044 	if (unlikely(exp->ex_flags & NFSEXP_V4ROOT)) {  in nfsd4_encode_fattr4_change()
3045 		u32 flush_time = convert_to_wallclock(exp->cd->flush_time);  in nfsd4_encode_fattr4_change()
3053 	return nfsd4_encode_changeid4(xdr, args->change_attr);  in nfsd4_encode_fattr4_change()
3059 	return nfsd4_encode_uint64_t(xdr, args->stat.size);  in nfsd4_encode_fattr4_size()
3071 	if (unlikely(args->exp->ex_fslocs.migrated)) {  in nfsd4_encode_fattr4_fsid()
3076 	switch (fsid_source(args->fhp)) {  in nfsd4_encode_fattr4_fsid()
3078 		p = xdr_encode_hyper(p, (u64)args->exp->ex_fsid);  in nfsd4_encode_fattr4_fsid()
3083 		*p++ = cpu_to_be32(MAJOR(args->stat.dev));  in nfsd4_encode_fattr4_fsid()
3085 		*p   = cpu_to_be32(MINOR(args->stat.dev));  in nfsd4_encode_fattr4_fsid()
3088 		xdr_encode_opaque_fixed(p, args->exp->ex_uuid, EX_UUID_LEN);  in nfsd4_encode_fattr4_fsid()
3098 	struct nfsd_net *nn = net_generic(SVC_NET(args->rqstp), nfsd_net_id);  in nfsd4_encode_fattr4_lease_time()
3100 	return nfsd4_encode_nfs_lease4(xdr, nn->nfsd4_lease);  in nfsd4_encode_fattr4_lease_time()
3106 	return nfsd4_encode_uint32_t(xdr, args->rdattr_err);  in nfsd4_encode_fattr4_rdattr_error()
3115 	if (IS_POSIXACL(d_inode(args->dentry)))  in nfsd4_encode_fattr4_aclsupport()
3123 	struct nfs4_acl *acl = args->acl;  in nfsd4_encode_fattr4_acl()
3132 		if (xdr_stream_encode_u32(xdr, acl->naces) != XDR_UNIT)  in nfsd4_encode_fattr4_acl()
3134 		for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) {  in nfsd4_encode_fattr4_acl()
3135 			status = nfsd4_encode_nfsace4(xdr, args->rqstp, ace);  in nfsd4_encode_fattr4_acl()
3146 	return nfsd4_encode_nfs_fh4(xdr, &args->fhp->fh_handle);  in nfsd4_encode_fattr4_filehandle()
3152 	return nfsd4_encode_uint64_t(xdr, args->stat.ino);  in nfsd4_encode_fattr4_fileid()
3158 	return nfsd4_encode_uint64_t(xdr, args->statfs.f_ffree);  in nfsd4_encode_fattr4_files_avail()
3164 	return nfsd4_encode_uint64_t(xdr, args->statfs.f_ffree);  in nfsd4_encode_fattr4_files_free()
3170 	return nfsd4_encode_uint64_t(xdr, args->statfs.f_files);  in nfsd4_encode_fattr4_files_total()
3176 	return nfsd4_encode_fs_locations4(xdr, args->rqstp, args->exp);  in nfsd4_encode_fattr4_fs_locations()
3182 	struct super_block *sb = args->exp->ex_path.mnt->mnt_sb;  in nfsd4_encode_fattr4_maxfilesize()
3184 	return nfsd4_encode_uint64_t(xdr, sb->s_maxbytes);  in nfsd4_encode_fattr4_maxfilesize()
3196 	return nfsd4_encode_uint32_t(xdr, args->statfs.f_namelen);  in nfsd4_encode_fattr4_maxname()
3202 	return nfsd4_encode_uint64_t(xdr, svc_max_payload(args->rqstp));  in nfsd4_encode_fattr4_maxread()
3208 	return nfsd4_encode_uint64_t(xdr, svc_max_payload(args->rqstp));  in nfsd4_encode_fattr4_maxwrite()
3214 	return nfsd4_encode_mode4(xdr, args->stat.mode & S_IALLUGO);  in nfsd4_encode_fattr4_mode()
3220 	return nfsd4_encode_uint32_t(xdr, args->stat.nlink);  in nfsd4_encode_fattr4_numlinks()
3226 	return nfsd4_encode_user(xdr, args->rqstp, args->stat.uid);  in nfsd4_encode_fattr4_owner()
3232 	return nfsd4_encode_group(xdr, args->rqstp, args->stat.gid);  in nfsd4_encode_fattr4_owner_group()
3238 	return nfsd4_encode_specdata4(xdr, MAJOR(args->stat.rdev),  in nfsd4_encode_fattr4_rawdev()
3239 				      MINOR(args->stat.rdev));  in nfsd4_encode_fattr4_rawdev()
3245 	u64 avail = (u64)args->statfs.f_bavail * (u64)args->statfs.f_bsize;  in nfsd4_encode_fattr4_space_avail()
3253 	u64 free = (u64)args->statfs.f_bfree * (u64)args->statfs.f_bsize;  in nfsd4_encode_fattr4_space_free()
3261 	u64 total = (u64)args->statfs.f_blocks * (u64)args->statfs.f_bsize;  in nfsd4_encode_fattr4_space_total()
3269 	return nfsd4_encode_uint64_t(xdr, (u64)args->stat.blocks << 9);  in nfsd4_encode_fattr4_space_used()
3275 	return nfsd4_encode_nfstime4(xdr, &args->stat.atime);  in nfsd4_encode_fattr4_time_access()
3281 	return nfsd4_encode_nfstime4(xdr, &args->stat.btime);  in nfsd4_encode_fattr4_time_create()
3298 	const struct inode *inode = d_inode(args->dentry);  in nfsd4_encode_fattr4_time_delta()
3299 	u32 ns = max_t(u32, NSEC_PER_SEC/HZ, inode->i_sb->s_time_gran);  in nfsd4_encode_fattr4_time_delta()
3308 	return nfsd4_encode_nfstime4(xdr, &args->stat.ctime);  in nfsd4_encode_fattr4_time_metadata()
3314 	return nfsd4_encode_nfstime4(xdr, &args->stat.mtime);  in nfsd4_encode_fattr4_time_modify()
3323 	if (!args->ignore_crossmnt &&  in nfsd4_encode_fattr4_mounted_on_fileid()
3324 	    args->dentry == args->exp->ex_path.mnt->mnt_root) {  in nfsd4_encode_fattr4_mounted_on_fileid()
3325 		err = nfsd4_get_mounted_on_ino(args->exp, &ino);  in nfsd4_encode_fattr4_mounted_on_fileid()
3329 		ino = args->stat.ino;  in nfsd4_encode_fattr4_mounted_on_fileid()
3339 	unsigned long mask = args->exp->ex_layout_types;  in nfsd4_encode_fattr4_fs_layout_types()
3357 	unsigned long mask = args->exp->ex_layout_types;  in nfsd4_encode_fattr4_layout_types()
3375 	return nfsd4_encode_uint32_t(xdr, args->stat.blksize);  in nfsd4_encode_fattr4_layout_blksize()
3383 	struct nfsd4_compoundres *resp = args->rqstp->rq_resp;  in nfsd4_encode_fattr4_suppattr_exclcreat()
3386 	memcpy(supp, nfsd_suppattrs[resp->cstate.minorversion], sizeof(supp));  in nfsd4_encode_fattr4_suppattr_exclcreat()
3398 	return nfsd4_encode_security_label(xdr, args->rqstp, &args->context);  in nfsd4_encode_fattr4_sec_label()
3405 	int err = xattr_supports_user_prefix(d_inode(args->dentry));  in nfsd4_encode_fattr4_xattr_support()
3577 	int starting_len = xdr->buf->len;  in nfsd4_encode_fattr4()
3582 	struct nfsd4_compoundres *resp = rqstp->rq_resp;  in nfsd4_encode_fattr4()
3583 	u32 minorversion = resp->cstate.minorversion;  in nfsd4_encode_fattr4()
3585 		.mnt	= exp->ex_path.mnt,  in nfsd4_encode_fattr4()
3610 	if (exp->ex_fslocs.migrated) {  in nfsd4_encode_fattr4()
3630 		struct nfs4_cb_fattr *ncf = &dp->dl_cb_fattr;  in nfsd4_encode_fattr4()
3632 		if (ncf->ncf_file_modified) {  in nfsd4_encode_fattr4()
3633 			++ncf->ncf_initial_cinfo;  in nfsd4_encode_fattr4()
3634 			args.stat.size = ncf->ncf_cur_fsize;  in nfsd4_encode_fattr4()
3635 			if (!timespec64_is_epoch(&ncf->ncf_cb_mtime))  in nfsd4_encode_fattr4()
3636 				args.stat.mtime = ncf->ncf_cb_mtime;  in nfsd4_encode_fattr4()
3638 		args.change_attr = ncf->ncf_initial_cinfo;  in nfsd4_encode_fattr4()
3640 		if (!timespec64_is_epoch(&ncf->ncf_cb_atime))  in nfsd4_encode_fattr4()
3641 			args.stat.atime = ncf->ncf_cb_atime;  in nfsd4_encode_fattr4()
3643 		nfs4_put_stid(&dp->dl_stid);  in nfsd4_encode_fattr4()
3678 		if (err == -EOPNOTSUPP)  in nfsd4_encode_fattr4()
3680 		else if (err == -EINVAL) {  in nfsd4_encode_fattr4()
3692 		if (exp->ex_flags & NFSEXP_SECURITY_LABEL)  in nfsd4_encode_fattr4()
3696 			err = -EOPNOTSUPP;  in nfsd4_encode_fattr4()
3699 			if (err == -EOPNOTSUPP)  in nfsd4_encode_fattr4()
3714 	attrlen_offset = xdr->buf->len;  in nfsd4_encode_fattr4()
3725 	attrlen = cpu_to_be32(xdr->buf->len - attrlen_offset - XDR_UNIT);  in nfsd4_encode_fattr4()
3726 	write_bytes_to_xdr_buf(xdr->buf, attrlen_offset, &attrlen, XDR_UNIT);  in nfsd4_encode_fattr4()
3753 	xdr->scratch.iov_len = 0;  in svcxdr_init_encode_from_buffer()
3755 	buf->head[0].iov_base = p;  in svcxdr_init_encode_from_buffer()
3756 	buf->head[0].iov_len = 0;  in svcxdr_init_encode_from_buffer()
3757 	buf->len = 0;  in svcxdr_init_encode_from_buffer()
3758 	xdr->buf = buf;  in svcxdr_init_encode_from_buffer()
3759 	xdr->iov = buf->head;  in svcxdr_init_encode_from_buffer()
3760 	xdr->p = p;  in svcxdr_init_encode_from_buffer()
3761 	xdr->end = (void *)p + bytes;  in svcxdr_init_encode_from_buffer()
3762 	buf->buflen = bytes;  in svcxdr_init_encode_from_buffer()
3789 	struct xdr_stream *xdr = readdir->xdr;  in nfsd4_encode_entry4_nfs_cookie4()
3791 	if (!readdir->cookie_offset)  in nfsd4_encode_entry4_nfs_cookie4()
3793 	write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset, &cookie,  in nfsd4_encode_entry4_nfs_cookie4()
3810 	struct svc_export *exp = cd->rd_fhp->fh_export;  in nfsd4_encode_entry4_fattr()
3815 	dentry = lookup_positive_unlocked(name, cd->rd_fhp->fh_dentry, namlen);  in nfsd4_encode_entry4_fattr()
3823 	 * as opposed to the cross-mounted file system. In such a case,  in nfsd4_encode_entry4_fattr()
3830 		if (!(exp->ex_flags & NFSEXP_V4ROOT)  in nfsd4_encode_entry4_fattr()
3831 				&& !attributes_need_mount(cd->rd_bmval)) {  in nfsd4_encode_entry4_fattr()
3840 		err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp);  in nfsd4_encode_entry4_fattr()
3845 		nfserr = check_nfsd_access(exp, cd->rd_rqstp, false);  in nfsd4_encode_entry4_fattr()
3851 	nfserr = nfsd4_encode_fattr4(cd->rd_rqstp, cd->xdr, NULL, exp, dentry,  in nfsd4_encode_entry4_fattr()
3852 				     cd->rd_bmval, ignore_crossmnt);  in nfsd4_encode_entry4_fattr()
3883 	struct xdr_stream *xdr = cd->xdr;  in nfsd4_encode_entry4()
3884 	int start_offset = xdr->buf->len;  in nfsd4_encode_entry4()
3892 		cd->common.err = nfs_ok;  in nfsd4_encode_entry4()
3903 	cookie_offset = xdr->buf->len;  in nfsd4_encode_entry4()
3926 		if (cd->rd_fhp->fh_export->ex_flags & NFSEXP_V4ROOT)  in nfsd4_encode_entry4()
3937 		if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR))  in nfsd4_encode_entry4()
3945 	entry_bytes = xdr->buf->len - start_offset;  in nfsd4_encode_entry4()
3946 	if (entry_bytes > cd->rd_maxcount)  in nfsd4_encode_entry4()
3948 	cd->rd_maxcount -= entry_bytes;  in nfsd4_encode_entry4()
3954 	if (cd->rd_dircount) {  in nfsd4_encode_entry4()
3956 		if (name_and_cookie > cd->rd_dircount && cd->cookie_offset)  in nfsd4_encode_entry4()
3958 		cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie);  in nfsd4_encode_entry4()
3959 		if (!cd->rd_dircount)  in nfsd4_encode_entry4()
3960 			cd->rd_maxcount = 0;  in nfsd4_encode_entry4()
3963 	cd->cookie_offset = cookie_offset;  in nfsd4_encode_entry4()
3965 	cd->common.err = nfs_ok;  in nfsd4_encode_entry4()
3969 	cd->common.err = nfserr;  in nfsd4_encode_entry4()
3970 	return -EINVAL;  in nfsd4_encode_entry4()
3981 	memcpy(p, verf->data, sizeof(verf->data));  in nfsd4_encode_verifier4()
3997 /* This is a frequently-encoded item; open-coded for speed */
4006 	*p++ = cpu_to_be32(sid->si_generation);  in nfsd4_encode_stateid4()
4007 	memcpy(p, &sid->si_opaque, sizeof(sid->si_opaque));  in nfsd4_encode_stateid4()
4015 	return nfsd4_encode_opaque_fixed(xdr, sessionid->data,  in nfsd4_encode_sessionid4()
4023 	struct nfsd4_access *access = &u->access;  in nfsd4_encode_access()
4024 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_access()
4028 	status = nfsd4_encode_uint32_t(xdr, access->ac_supported);  in nfsd4_encode_access()
4032 	return nfsd4_encode_uint32_t(xdr, access->ac_resp_access);  in nfsd4_encode_access()
4038 	struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session;  in nfsd4_encode_bind_conn_to_session()
4039 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_bind_conn_to_session()
4042 	nfserr = nfsd4_encode_sessionid4(xdr, &bcts->sessionid);  in nfsd4_encode_bind_conn_to_session()
4046 	if (xdr_stream_encode_u32(xdr, bcts->dir) != XDR_UNIT)  in nfsd4_encode_bind_conn_to_session()
4056 	struct nfsd4_close *close = &u->close;  in nfsd4_encode_close()
4057 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_close()
4060 	return nfsd4_encode_stateid4(xdr, &close->cl_stateid);  in nfsd4_encode_close()
4068 	struct nfsd4_commit *commit = &u->commit;  in nfsd4_encode_commit()
4070 	return nfsd4_encode_verifier4(resp->xdr, &commit->co_verf);  in nfsd4_encode_commit()
4077 	struct nfsd4_create *create = &u->create;  in nfsd4_encode_create()
4078 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_create()
4081 	nfserr = nfsd4_encode_change_info4(xdr, &create->cr_cinfo);  in nfsd4_encode_create()
4085 	return nfsd4_encode_bitmap4(xdr, create->cr_bmval[0],  in nfsd4_encode_create()
4086 				    create->cr_bmval[1], create->cr_bmval[2]);  in nfsd4_encode_create()
4093 	struct nfsd4_getattr *getattr = &u->getattr;  in nfsd4_encode_getattr()
4094 	struct svc_fh *fhp = getattr->ga_fhp;  in nfsd4_encode_getattr()
4095 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_getattr()
4098 	return nfsd4_encode_fattr4(resp->rqstp, xdr, fhp, fhp->fh_export,  in nfsd4_encode_getattr()
4099 				   fhp->fh_dentry, getattr->ga_bmval, 0);  in nfsd4_encode_getattr()
4106 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_getfh()
4107 	struct svc_fh *fhp = u->getfh;  in nfsd4_encode_getfh()
4110 	return nfsd4_encode_nfs_fh4(xdr, &fhp->fh_handle);  in nfsd4_encode_getfh()
4124 	return nfsd4_encode_opaque(xdr, owner->data, owner->len);  in nfsd4_encode_lock_owner4()
4134 	status = nfsd4_encode_offset4(xdr, ld->ld_start);  in nfsd4_encode_lock4denied()
4138 	status = nfsd4_encode_length4(xdr, ld->ld_length);  in nfsd4_encode_lock4denied()
4142 	if (xdr_stream_encode_u32(xdr, ld->ld_type) != XDR_UNIT)  in nfsd4_encode_lock4denied()
4145 	return nfsd4_encode_lock_owner4(xdr, &ld->ld_clientid,  in nfsd4_encode_lock4denied()
4146 					&ld->ld_owner);  in nfsd4_encode_lock4denied()
4153 	struct nfsd4_lock *lock = &u->lock;  in nfsd4_encode_lock()
4154 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_lock()
4160 		status = nfsd4_encode_stateid4(xdr, &lock->lk_resp_stateid);  in nfsd4_encode_lock()
4164 		status = nfsd4_encode_lock4denied(xdr, &lock->lk_denied);  in nfsd4_encode_lock()
4176 	struct nfsd4_lockt *lockt = &u->lockt;  in nfsd4_encode_lockt()
4177 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_lockt()
4182 		status = nfsd4_encode_lock4denied(xdr, &lockt->lt_denied);  in nfsd4_encode_lockt()
4193 	struct nfsd4_locku *locku = &u->locku;  in nfsd4_encode_locku()
4194 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_locku()
4197 	return nfsd4_encode_stateid4(xdr, &locku->lu_stateid);  in nfsd4_encode_locku()
4205 	struct nfsd4_link *link = &u->link;  in nfsd4_encode_link()
4206 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_link()
4208 	return nfsd4_encode_change_info4(xdr, &link->li_cinfo);  in nfsd4_encode_link()
4232 	/* who - empty for now */  in nfsd4_encode_open_nfsace4()
4244 	status = nfsd4_encode_stateid4(xdr, &open->op_delegate_stateid);  in nfsd4_encode_open_read_delegation4()
4248 	status = nfsd4_encode_bool(xdr, open->op_recall);  in nfsd4_encode_open_read_delegation4()
4272 	status = nfsd4_encode_stateid4(xdr, &open->op_delegate_stateid);  in nfsd4_encode_open_write_delegation4()
4276 	status = nfsd4_encode_bool(xdr, open->op_recall);  in nfsd4_encode_open_write_delegation4()
4293 	if (xdr_stream_encode_u32(xdr, open->op_why_no_deleg) != XDR_UNIT)  in nfsd4_encode_open_none_delegation4()
4295 	switch (open->op_why_no_deleg) {  in nfsd4_encode_open_none_delegation4()
4313 	if (xdr_stream_encode_u32(xdr, open->op_delegate_type) != XDR_UNIT)  in nfsd4_encode_open_delegation4()
4315 	switch (open->op_delegate_type) {  in nfsd4_encode_open_delegation4()
4344 	struct nfsd4_open *open = &u->open;  in nfsd4_encode_open()
4345 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_open()
4348 	nfserr = nfsd4_encode_stateid4(xdr, &open->op_stateid);  in nfsd4_encode_open()
4352 	nfserr = nfsd4_encode_change_info4(xdr, &open->op_cinfo);  in nfsd4_encode_open()
4356 	nfserr = nfsd4_encode_uint32_t(xdr, open->op_rflags);  in nfsd4_encode_open()
4360 	nfserr = nfsd4_encode_bitmap4(xdr, open->op_bmval[0],  in nfsd4_encode_open()
4361 				      open->op_bmval[1], open->op_bmval[2]);  in nfsd4_encode_open()
4372 	struct nfsd4_open_confirm *oc = &u->open_confirm;  in nfsd4_encode_open_confirm()
4373 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_open_confirm()
4376 	return nfsd4_encode_stateid4(xdr, &oc->oc_resp_stateid);  in nfsd4_encode_open_confirm()
4383 	struct nfsd4_open_downgrade *od = &u->open_downgrade;  in nfsd4_encode_open_downgrade()
4384 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_open_downgrade()
4387 	return nfsd4_encode_stateid4(xdr, &od->od_stateid);  in nfsd4_encode_open_downgrade()
4400 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_splice_read()
4401 	struct xdr_buf *buf = xdr->buf;  in nfsd4_encode_splice_read()
4409 	if (unlikely(xdr->buf->page_len)) {  in nfsd4_encode_splice_read()
4415 	 * Make sure there is room at the end of buf->head for  in nfsd4_encode_splice_read()
4417 	 * to XDR-pad the payload.  in nfsd4_encode_splice_read()
4419 	if (xdr->iov != xdr->buf->head || xdr->end - xdr->p < 1)  in nfsd4_encode_splice_read()
4422 	nfserr = nfsd_splice_read(read->rd_rqstp, read->rd_fhp,  in nfsd4_encode_splice_read()
4423 				  file, read->rd_offset, &maxcount,  in nfsd4_encode_splice_read()
4424 				  &read->rd_eof);  in nfsd4_encode_splice_read()
4425 	read->rd_length = maxcount;  in nfsd4_encode_splice_read()
4428 	svcxdr_encode_opaque_pages(read->rd_rqstp, xdr, buf->pages,  in nfsd4_encode_splice_read()
4429 				   buf->page_base, maxcount);  in nfsd4_encode_splice_read()
4430 	status = svc_encode_result_payload(read->rd_rqstp,  in nfsd4_encode_splice_read()
4431 					   buf->head[0].iov_len, maxcount);  in nfsd4_encode_splice_read()
4442 	 * manipulations are open-coded.  in nfsd4_encode_splice_read()
4444 	space_left = min_t(int, (void *)xdr->end - (void *)xdr->p,  in nfsd4_encode_splice_read()
4445 				buf->buflen - buf->len);  in nfsd4_encode_splice_read()
4446 	buf->buflen = buf->len + space_left;  in nfsd4_encode_splice_read()
4447 	xdr->end = (__be32 *)((void *)xdr->end + space_left);  in nfsd4_encode_splice_read()
4457 	buf->page_len = 0;  in nfsd4_encode_splice_read()
4465 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_readv()
4466 	unsigned int base = xdr->buf->page_len & ~PAGE_MASK;  in nfsd4_encode_readv()
4467 	unsigned int starting_len = xdr->buf->len;  in nfsd4_encode_readv()
4474 	nfserr = nfsd_iter_read(resp->rqstp, read->rd_fhp, file,  in nfsd4_encode_readv()
4475 				read->rd_offset, &maxcount, base,  in nfsd4_encode_readv()
4476 				&read->rd_eof);  in nfsd4_encode_readv()
4477 	read->rd_length = maxcount;  in nfsd4_encode_readv()
4480 	if (svc_encode_result_payload(resp->rqstp, starting_len, maxcount))  in nfsd4_encode_readv()
4484 	write_bytes_to_xdr_buf(xdr->buf, starting_len + maxcount, &zero,  in nfsd4_encode_readv()
4493 	struct nfsd4_compoundargs *argp = resp->rqstp->rq_argp;  in nfsd4_encode_read()
4494 	struct nfsd4_read *read = &u->read;  in nfsd4_encode_read()
4495 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_read()
4496 	bool splice_ok = argp->splice_ok;  in nfsd4_encode_read()
4505 	eof_offset = xdr->buf->len;  in nfsd4_encode_read()
4506 	file = read->rd_nf->nf_file;  in nfsd4_encode_read()
4515 	maxcount = min_t(unsigned long, read->rd_length,  in nfsd4_encode_read()
4516 			 (xdr->buf->buflen - xdr->buf->len));  in nfsd4_encode_read()
4518 	if (file->f_op->splice_read && splice_ok)  in nfsd4_encode_read()
4527 	wire_data[0] = read->rd_eof ? xdr_one : xdr_zero;  in nfsd4_encode_read()
4528 	wire_data[1] = cpu_to_be32(read->rd_length);  in nfsd4_encode_read()
4529 	write_bytes_to_xdr_buf(xdr->buf, eof_offset, &wire_data, XDR_UNIT * 2);  in nfsd4_encode_read()
4537 	struct nfsd4_readlink *readlink = &u->readlink;  in nfsd4_encode_readlink()
4539 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_readlink()
4544 	length_offset = xdr->buf->len;  in nfsd4_encode_readlink()
4553 	nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp,  in nfsd4_encode_readlink()
4559 	status = svc_encode_result_payload(readlink->rl_rqstp, length_offset,  in nfsd4_encode_readlink()
4567 	write_bytes_to_xdr_buf(xdr->buf, length_offset, &wire_count, XDR_UNIT);  in nfsd4_encode_readlink()
4569 	write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount, &zero,  in nfsd4_encode_readlink()
4582 	int bytes_left, maxcount, starting_len = xdr->buf->len;  in nfsd4_encode_dirlist4()
4590 	bytes_left = xdr->buf->buflen - xdr->buf->len -  in nfsd4_encode_dirlist4()
4591 		COMPOUND_ERR_SLACK_SPACE - XDR_UNIT * 2;  in nfsd4_encode_dirlist4()
4594 	maxcount = min_t(u32, readdir->rd_maxcount, max_payload);  in nfsd4_encode_dirlist4()
4603 	maxcount = min_t(int, maxcount - XDR_UNIT * 4, bytes_left);  in nfsd4_encode_dirlist4()
4606 	if (!readdir->rd_dircount)  in nfsd4_encode_dirlist4()
4607 		readdir->rd_dircount = max_payload;  in nfsd4_encode_dirlist4()
4610 	readdir->xdr = xdr;  in nfsd4_encode_dirlist4()
4611 	readdir->rd_maxcount = maxcount;  in nfsd4_encode_dirlist4()
4612 	readdir->common.err = 0;  in nfsd4_encode_dirlist4()
4613 	readdir->cookie_offset = 0;  in nfsd4_encode_dirlist4()
4614 	offset = readdir->rd_cookie;  in nfsd4_encode_dirlist4()
4615 	status = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp, &offset,  in nfsd4_encode_dirlist4()
4616 			      &readdir->common, nfsd4_encode_entry4);  in nfsd4_encode_dirlist4()
4619 	if (readdir->common.err == nfserr_toosmall &&  in nfsd4_encode_dirlist4()
4620 	    xdr->buf->len == starting_len) {  in nfsd4_encode_dirlist4()
4622 		if (maxcount - XDR_UNIT * 4 < bytes_left)  in nfsd4_encode_dirlist4()
4635 	return nfsd4_encode_bool(xdr, readdir->common.err == nfserr_eof);  in nfsd4_encode_dirlist4()
4642 	struct nfsd4_readdir *readdir = &u->readdir;  in nfsd4_encode_readdir()
4643 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_readdir()
4644 	int starting_len = xdr->buf->len;  in nfsd4_encode_readdir()
4647 	nfserr = nfsd4_encode_verifier4(xdr, &readdir->rd_verf);  in nfsd4_encode_readdir()
4652 	nfserr = nfsd4_encode_dirlist4(xdr, readdir, svc_max_payload(resp->rqstp));  in nfsd4_encode_readdir()
4662 	struct nfsd4_remove *remove = &u->remove;  in nfsd4_encode_remove()
4663 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_remove()
4665 	return nfsd4_encode_change_info4(xdr, &remove->rm_cinfo);  in nfsd4_encode_remove()
4672 	struct nfsd4_rename *rename = &u->rename;  in nfsd4_encode_rename()
4673 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_rename()
4675 	nfserr = nfsd4_encode_change_info4(xdr, &rename->rn_sinfo);  in nfsd4_encode_rename()
4678 	return nfsd4_encode_change_info4(xdr, &rename->rn_tinfo);  in nfsd4_encode_rename()
4688 	if (xdr_stream_encode_opaque(xdr, info->oid.data, info->oid.len) < 0)  in nfsd4_encode_rpcsec_gss_info()
4691 	status = nfsd4_encode_qop4(xdr, info->qop);  in nfsd4_encode_rpcsec_gss_info()
4695 	if (xdr_stream_encode_u32(xdr, info->service) != XDR_UNIT)  in nfsd4_encode_rpcsec_gss_info()
4739 	if (exp->ex_nflavors) {  in nfsd4_encode_SECINFO4resok()
4740 		flavs = exp->ex_flavors;  in nfsd4_encode_SECINFO4resok()
4741 		nflavs = exp->ex_nflavors;  in nfsd4_encode_SECINFO4resok()
4744 		if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) {  in nfsd4_encode_SECINFO4resok()
4748 		} else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) {  in nfsd4_encode_SECINFO4resok()
4751 					= svcauth_gss_flavor(exp->ex_client);  in nfsd4_encode_SECINFO4resok()
4755 					= exp->ex_client->flavour->flavour;  in nfsd4_encode_SECINFO4resok()
4759 	count_offset = xdr->buf->len;  in nfsd4_encode_SECINFO4resok()
4771 	write_bytes_to_xdr_buf(xdr->buf, count_offset, &wire_count,  in nfsd4_encode_SECINFO4resok()
4780 	struct nfsd4_secinfo *secinfo = &u->secinfo;  in nfsd4_encode_secinfo()
4781 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_secinfo()
4783 	return nfsd4_encode_SECINFO4resok(xdr, secinfo->si_exp);  in nfsd4_encode_secinfo()
4790 	struct nfsd4_secinfo_no_name *secinfo = &u->secinfo_no_name;  in nfsd4_encode_secinfo_no_name()
4791 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_secinfo_no_name()
4793 	return nfsd4_encode_SECINFO4resok(xdr, secinfo->sin_exp);  in nfsd4_encode_secinfo_no_name()
4800 	struct nfsd4_setattr *setattr = &u->setattr;  in nfsd4_encode_setattr()
4806 		status = nfsd4_encode_bitmap4(resp->xdr, setattr->sa_bmval[0],  in nfsd4_encode_setattr()
4807 					      setattr->sa_bmval[1],  in nfsd4_encode_setattr()
4808 					      setattr->sa_bmval[2]);  in nfsd4_encode_setattr()
4812 		status = nfsd4_encode_bitmap4(resp->xdr, 0, 0, 0);  in nfsd4_encode_setattr()
4821 	struct nfsd4_setclientid *scd = &u->setclientid;  in nfsd4_encode_setclientid()
4822 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_setclientid()
4825 		nfserr = nfsd4_encode_clientid4(xdr, &scd->se_clientid);  in nfsd4_encode_setclientid()
4828 		nfserr = nfsd4_encode_verifier4(xdr, &scd->se_confirm);  in nfsd4_encode_setclientid()
4849 	struct nfsd4_write *write = &u->write;  in nfsd4_encode_write()
4850 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_write()
4853 	nfserr = nfsd4_encode_count4(xdr, write->wr_bytes_written);  in nfsd4_encode_write()
4857 	if (xdr_stream_encode_u32(xdr, write->wr_how_written) != XDR_UNIT)  in nfsd4_encode_write()
4860 	return nfsd4_encode_verifier4(xdr, &write->wr_verifier);  in nfsd4_encode_write()
4870 	status = nfsd4_encode_bitmap4(xdr, exid->spo_must_enforce[0],  in nfsd4_encode_state_protect_ops4()
4871 				      exid->spo_must_enforce[1],  in nfsd4_encode_state_protect_ops4()
4872 				      exid->spo_must_enforce[2]);  in nfsd4_encode_state_protect_ops4()
4876 	return nfsd4_encode_bitmap4(xdr, exid->spo_must_allow[0],  in nfsd4_encode_state_protect_ops4()
4877 				    exid->spo_must_allow[1],  in nfsd4_encode_state_protect_ops4()
4878 				    exid->spo_must_allow[2]);  in nfsd4_encode_state_protect_ops4()
4886 	if (xdr_stream_encode_u32(xdr, exid->spa_how) != XDR_UNIT)  in nfsd4_encode_state_protect4_r()
4888 	switch (exid->spa_how) {  in nfsd4_encode_state_protect4_r()
4913 	return nfsd4_encode_opaque(xdr, nn->nfsd_name, strlen(nn->nfsd_name));  in nfsd4_encode_server_owner4()
4922 	status = nfsd4_encode_opaque(xdr, exid->nii_domain.data,  in nfsd4_encode_nfs_impl_id4()
4923 				     exid->nii_domain.len);  in nfsd4_encode_nfs_impl_id4()
4927 	status = nfsd4_encode_opaque(xdr, exid->nii_name.data,  in nfsd4_encode_nfs_impl_id4()
4928 				     exid->nii_name.len);  in nfsd4_encode_nfs_impl_id4()
4932 	return nfsd4_encode_nfstime4(xdr, &exid->nii_time);  in nfsd4_encode_nfs_impl_id4()
4939 	struct nfsd_net *nn = net_generic(SVC_NET(resp->rqstp), nfsd_net_id);  in nfsd4_encode_exchange_id()
4940 	struct nfsd4_exchange_id *exid = &u->exchange_id;  in nfsd4_encode_exchange_id()
4941 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_exchange_id()
4944 	nfserr = nfsd4_encode_clientid4(xdr, &exid->clientid);  in nfsd4_encode_exchange_id()
4948 	nfserr = nfsd4_encode_sequenceid4(xdr, exid->seqid);  in nfsd4_encode_exchange_id()
4952 	nfserr = nfsd4_encode_uint32_t(xdr, exid->flags);  in nfsd4_encode_exchange_id()
4960 	nfserr = nfsd4_encode_server_owner4(xdr, resp->rqstp);  in nfsd4_encode_exchange_id()
4964 	nfserr = nfsd4_encode_opaque(xdr, nn->nfsd_name,  in nfsd4_encode_exchange_id()
4965 				     strlen(nn->nfsd_name));  in nfsd4_encode_exchange_id()
4989 	status = nfsd4_encode_count4(xdr, attrs->maxreq_sz);  in nfsd4_encode_channel_attrs4()
4993 	status = nfsd4_encode_count4(xdr, attrs->maxresp_sz);  in nfsd4_encode_channel_attrs4()
4997 	status = nfsd4_encode_count4(xdr, attrs->maxresp_cached);  in nfsd4_encode_channel_attrs4()
5001 	status = nfsd4_encode_count4(xdr, attrs->maxops);  in nfsd4_encode_channel_attrs4()
5005 	status = nfsd4_encode_count4(xdr, attrs->maxreqs);  in nfsd4_encode_channel_attrs4()
5009 	if (xdr_stream_encode_u32(xdr, attrs->nr_rdma_attrs) != XDR_UNIT)  in nfsd4_encode_channel_attrs4()
5011 	if (attrs->nr_rdma_attrs)  in nfsd4_encode_channel_attrs4()
5012 		return nfsd4_encode_uint32_t(xdr, attrs->rdma_attrs);  in nfsd4_encode_channel_attrs4()
5020 	struct nfsd4_create_session *sess = &u->create_session;  in nfsd4_encode_create_session()
5021 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_create_session()
5024 	nfserr = nfsd4_encode_sessionid4(xdr, &sess->sessionid);  in nfsd4_encode_create_session()
5028 	nfserr = nfsd4_encode_sequenceid4(xdr, sess->seqid);  in nfsd4_encode_create_session()
5032 	nfserr = nfsd4_encode_uint32_t(xdr, sess->flags);  in nfsd4_encode_create_session()
5036 	nfserr = nfsd4_encode_channel_attrs4(xdr, &sess->fore_channel);  in nfsd4_encode_create_session()
5040 	return nfsd4_encode_channel_attrs4(xdr, &sess->back_channel);  in nfsd4_encode_create_session()
5047 	struct nfsd4_sequence *seq = &u->sequence;  in nfsd4_encode_sequence()
5048 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_sequence()
5051 	nfserr = nfsd4_encode_sessionid4(xdr, &seq->sessionid);  in nfsd4_encode_sequence()
5055 	nfserr = nfsd4_encode_sequenceid4(xdr, seq->seqid);  in nfsd4_encode_sequence()
5059 	nfserr = nfsd4_encode_slotid4(xdr, seq->slotid);  in nfsd4_encode_sequence()
5064 	nfserr = nfsd4_encode_slotid4(xdr, seq->maxslots - 1);  in nfsd4_encode_sequence()
5068 	nfserr = nfsd4_encode_slotid4(xdr, seq->target_maxslots - 1);  in nfsd4_encode_sequence()
5072 	nfserr = nfsd4_encode_uint32_t(xdr, seq->status_flags);  in nfsd4_encode_sequence()
5076 	resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */  in nfsd4_encode_sequence()
5084 	struct nfsd4_test_stateid *test_stateid = &u->test_stateid;  in nfsd4_encode_test_stateid()
5086 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_test_stateid()
5089 	if (xdr_stream_encode_u32(xdr, test_stateid->ts_num_ids) != XDR_UNIT)  in nfsd4_encode_test_stateid()
5092 				 &test_stateid->ts_stateid_list, ts_id_list) {  in nfsd4_encode_test_stateid()
5093 		if (xdr_stream_encode_be32(xdr, stateid->ts_id_status) != XDR_UNIT)  in nfsd4_encode_test_stateid()
5103 	struct nfsd4_get_dir_delegation *gdd = &u->get_dir_delegation;  in nfsd4_encode_get_dir_delegation()
5104 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_get_dir_delegation()
5107 	switch(gdd->gddrnf_status) {  in nfsd4_encode_get_dir_delegation()
5111 		status = nfsd4_encode_verifier4(xdr, &gdd->gddr_cookieverf);  in nfsd4_encode_get_dir_delegation()
5114 		status = nfsd4_encode_stateid4(xdr, &gdd->gddr_stateid);  in nfsd4_encode_get_dir_delegation()
5117 		status = nfsd4_encode_bitmap4(xdr, gdd->gddr_notification[0], 0, 0);  in nfsd4_encode_get_dir_delegation()
5120 		status = nfsd4_encode_bitmap4(xdr, gdd->gddr_child_attributes[0],  in nfsd4_encode_get_dir_delegation()
5121 						   gdd->gddr_child_attributes[1],  in nfsd4_encode_get_dir_delegation()
5122 						   gdd->gddr_child_attributes[2]);  in nfsd4_encode_get_dir_delegation()
5125 		status = nfsd4_encode_bitmap4(xdr, gdd->gddr_dir_attributes[0],  in nfsd4_encode_get_dir_delegation()
5126 						   gdd->gddr_dir_attributes[1],  in nfsd4_encode_get_dir_delegation()
5127 						   gdd->gddr_dir_attributes[2]);  in nfsd4_encode_get_dir_delegation()
5130 		pr_warn("nfsd: bad gddrnf_status (%u)\n", gdd->gddrnf_status);  in nfsd4_encode_get_dir_delegation()
5131 		gdd->gddrnf_will_signal_deleg_avail = 0;  in nfsd4_encode_get_dir_delegation()
5136 		status = nfsd4_encode_bool(xdr, gdd->gddrnf_will_signal_deleg_avail);  in nfsd4_encode_get_dir_delegation()
5147 	u32 needed_len, starting_len = xdr->buf->len;  in nfsd4_encode_device_addr4()
5152 	if (xdr_stream_encode_u32(xdr, gdev->gd_layout_type) != XDR_UNIT)  in nfsd4_encode_device_addr4()
5155 	ops = nfsd4_layout_ops[gdev->gd_layout_type];  in nfsd4_encode_device_addr4()
5156 	status = ops->encode_getdeviceinfo(xdr, gdev);  in nfsd4_encode_device_addr4()
5163 		if (xdr->buf->len + XDR_UNIT > gdev->gd_maxcount)  in nfsd4_encode_device_addr4()
5171 	needed_len = xdr->buf->len + XDR_UNIT;	/* notifications */  in nfsd4_encode_device_addr4()
5184 	struct nfsd4_getdeviceinfo *gdev = &u->getdeviceinfo;  in nfsd4_encode_getdeviceinfo()
5185 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_getdeviceinfo()
5192 	return nfsd4_encode_bitmap4(xdr, gdev->gd_notify_types, 0, 0);  in nfsd4_encode_getdeviceinfo()
5198 	const struct nfsd4_layout_ops *ops = nfsd4_layout_ops[lgp->lg_layout_type];  in nfsd4_encode_layout4()
5202 	status = nfsd4_encode_offset4(xdr, lgp->lg_seg.offset);  in nfsd4_encode_layout4()
5206 	status = nfsd4_encode_length4(xdr, lgp->lg_seg.length);  in nfsd4_encode_layout4()
5210 	if (xdr_stream_encode_u32(xdr, lgp->lg_seg.iomode) != XDR_UNIT)  in nfsd4_encode_layout4()
5213 	if (xdr_stream_encode_u32(xdr, lgp->lg_layout_type) != XDR_UNIT)  in nfsd4_encode_layout4()
5215 	return ops->encode_layoutget(xdr, lgp);  in nfsd4_encode_layout4()
5222 	struct nfsd4_layoutget *lgp = &u->layoutget;  in nfsd4_encode_layoutget()
5223 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_layoutget()
5230 	nfserr = nfsd4_encode_stateid4(xdr, &lgp->lg_sid);  in nfsd4_encode_layoutget()
5243 	struct nfsd4_layoutcommit *lcp = &u->layoutcommit;  in nfsd4_encode_layoutcommit()
5244 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_layoutcommit()
5247 	nfserr = nfsd4_encode_bool(xdr, lcp->lc_size_chg);  in nfsd4_encode_layoutcommit()
5250 	if (lcp->lc_size_chg)  in nfsd4_encode_layoutcommit()
5252 		return nfsd4_encode_length4(xdr, lcp->lc_newsize);  in nfsd4_encode_layoutcommit()
5260 	struct nfsd4_layoutreturn *lrp = &u->layoutreturn;  in nfsd4_encode_layoutreturn()
5261 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_layoutreturn()
5264 	nfserr = nfsd4_encode_bool(xdr, lrp->lrs_present);  in nfsd4_encode_layoutreturn()
5267 	if (lrp->lrs_present)  in nfsd4_encode_layoutreturn()
5269 		return nfsd4_encode_stateid4(xdr, &lrp->lr_sid);  in nfsd4_encode_layoutreturn()
5278 	const struct nfsd42_write_res *write = &copy->cp_res;  in nfsd4_encode_write_response4()
5286 		status = nfsd4_encode_stateid4(xdr, &write->cb_stateid);  in nfsd4_encode_write_response4()
5292 	status = nfsd4_encode_length4(xdr, write->wr_bytes_written);  in nfsd4_encode_write_response4()
5296 	if (xdr_stream_encode_u32(xdr, write->wr_stable_how) != XDR_UNIT)  in nfsd4_encode_write_response4()
5299 	return nfsd4_encode_verifier4(xdr, &write->wr_verifier);  in nfsd4_encode_write_response4()
5319 	struct nfsd4_copy *copy = &u->copy;  in nfsd4_encode_copy()
5321 	nfserr = nfsd4_encode_write_response4(resp->xdr, copy);  in nfsd4_encode_copy()
5324 	return nfsd4_encode_copy_requirements4(resp->xdr, copy);  in nfsd4_encode_copy()
5332 	if (xdr_stream_encode_u32(xdr, ns->nl4_type) != XDR_UNIT)  in nfsd4_encode_netloc4()
5334 	switch (ns->nl4_type) {  in nfsd4_encode_netloc4()
5337 		status = nfsd4_encode_netaddr4(xdr, &ns->u.nl4_addr);  in nfsd4_encode_netloc4()
5349 	struct nfsd4_copy_notify *cn = &u->copy_notify;  in nfsd4_encode_copy_notify()
5350 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_copy_notify()
5353 	nfserr = nfsd4_encode_nfstime4(xdr, &cn->cpn_lease_time);  in nfsd4_encode_copy_notify()
5357 	nfserr = nfsd4_encode_stateid4(xdr, &cn->cpn_cnr_stateid);  in nfsd4_encode_copy_notify()
5363 	return nfsd4_encode_netloc4(xdr, cn->cpn_src);  in nfsd4_encode_copy_notify()
5370 	struct nfsd4_offload_status *os = &u->offload_status;  in nfsd4_encode_offload_status()
5371 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_offload_status()
5374 	nfserr = nfsd4_encode_length4(xdr, os->count);  in nfsd4_encode_offload_status()
5378 	if (os->completed) {  in nfsd4_encode_offload_status()
5381 		if (xdr_stream_encode_be32(xdr, os->status) != XDR_UNIT)  in nfsd4_encode_offload_status()
5392 	struct nfsd4_compoundargs *argp = resp->rqstp->rq_argp;  in nfsd4_encode_read_plus_data()
5393 	struct file *file = read->rd_nf->nf_file;  in nfsd4_encode_read_plus_data()
5394 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_read_plus_data()
5395 	bool splice_ok = argp->splice_ok;  in nfsd4_encode_read_plus_data()
5404 	offset_offset = xdr->buf->len;  in nfsd4_encode_read_plus_data()
5411 	maxcount = min_t(unsigned long, read->rd_length,  in nfsd4_encode_read_plus_data()
5412 			 (xdr->buf->buflen - xdr->buf->len));  in nfsd4_encode_read_plus_data()
5414 	if (file->f_op->splice_read && splice_ok)  in nfsd4_encode_read_plus_data()
5421 	wire_offset = cpu_to_be64(read->rd_offset);  in nfsd4_encode_read_plus_data()
5422 	write_bytes_to_xdr_buf(xdr->buf, offset_offset, &wire_offset,  in nfsd4_encode_read_plus_data()
5424 	wire_count = cpu_to_be32(read->rd_length);  in nfsd4_encode_read_plus_data()
5425 	write_bytes_to_xdr_buf(xdr->buf, offset_offset + XDR_UNIT * 2,  in nfsd4_encode_read_plus_data()
5434 	struct nfsd4_read *read = &u->read;  in nfsd4_encode_read_plus()
5435 	struct file *file = read->rd_nf->nf_file;  in nfsd4_encode_read_plus()
5436 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_read_plus()
5444 	eof_offset = xdr->buf->len;  in nfsd4_encode_read_plus()
5451 	read->rd_eof = read->rd_offset >= i_size_read(file_inode(file));  in nfsd4_encode_read_plus()
5452 	if (read->rd_eof)  in nfsd4_encode_read_plus()
5464 	wire_data[0] = read->rd_eof ? xdr_one : xdr_zero;  in nfsd4_encode_read_plus()
5466 	write_bytes_to_xdr_buf(xdr->buf, eof_offset, &wire_data, XDR_UNIT * 2);  in nfsd4_encode_read_plus()
5474 	struct nfsd4_seek *seek = &u->seek;  in nfsd4_encode_seek()
5475 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_seek()
5478 	nfserr = nfsd4_encode_bool(xdr, seek->seek_eof);  in nfsd4_encode_seek()
5482 	return nfsd4_encode_offset4(xdr, seek->seek_pos);  in nfsd4_encode_seek()
5493  * Encode kmalloc-ed buffer in to XDR stream.
5502 		      ((void *)xdr->end - (void *)xdr->p));  in nfsd4_vbuf_to_stream()
5509 	buflen -= cplen;  in nfsd4_vbuf_to_stream()
5529 		buflen -= PAGE_SIZE;  in nfsd4_vbuf_to_stream()
5540 	struct nfsd4_getxattr *getxattr = &u->getxattr;  in nfsd4_encode_getxattr()
5541 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_getxattr()
5548 	*p = cpu_to_be32(getxattr->getxa_len);  in nfsd4_encode_getxattr()
5550 	if (getxattr->getxa_len == 0)  in nfsd4_encode_getxattr()
5553 	err = nfsd4_vbuf_to_stream(xdr, getxattr->getxa_buf,  in nfsd4_encode_getxattr()
5554 				    getxattr->getxa_len);  in nfsd4_encode_getxattr()
5556 	kvfree(getxattr->getxa_buf);  in nfsd4_encode_getxattr()
5565 	struct nfsd4_setxattr *setxattr = &u->setxattr;  in nfsd4_encode_setxattr()
5566 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_setxattr()
5568 	return nfsd4_encode_change_info4(xdr, &setxattr->setxa_cinfo);  in nfsd4_encode_setxattr()
5578 	u64 cookie = listxattrs->lsxa_cookie;  in nfsd4_listxattr_validate_cookie()
5584 	if (cookie > (listxattrs->lsxa_len) / (XATTR_USER_PREFIX_LEN + 2))  in nfsd4_listxattr_validate_cookie()
5595 	struct nfsd4_listxattrs *listxattrs = &u->listxattrs;  in nfsd4_encode_listxattrs()
5596 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_listxattrs()
5617 	cookie_offset = xdr->buf->len;  in nfsd4_encode_listxattrs()
5626 	left = listxattrs->lsxa_len;  in nfsd4_encode_listxattrs()
5627 	sp = listxattrs->lsxa_buf;  in nfsd4_encode_listxattrs()
5630 	/* Bytes left is maxcount - 8 (cookie) - 4 (array count) */  in nfsd4_encode_listxattrs()
5631 	xdrleft = listxattrs->lsxa_maxcount - XDR_UNIT * 3;  in nfsd4_encode_listxattrs()
5642 		slen -= XATTR_USER_PREFIX_LEN;  in nfsd4_encode_listxattrs()
5657 		left -= XATTR_USER_PREFIX_LEN;  in nfsd4_encode_listxattrs()
5671 		xdrleft -= xdrlen;  in nfsd4_encode_listxattrs()
5675 		left -= slen + 1;  in nfsd4_encode_listxattrs()
5698 	write_bytes_to_xdr_buf(xdr->buf, cookie_offset, &wire_cookie, 8);  in nfsd4_encode_listxattrs()
5700 	write_bytes_to_xdr_buf(xdr->buf, count_offset, &tmp, 4);  in nfsd4_encode_listxattrs()
5702 	if (listxattrs->lsxa_len)  in nfsd4_encode_listxattrs()
5703 		kvfree(listxattrs->lsxa_buf);  in nfsd4_encode_listxattrs()
5711 	struct nfsd4_removexattr *removexattr = &u->removexattr;  in nfsd4_encode_removexattr()
5712 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_removexattr()
5714 	return nfsd4_encode_change_info4(xdr, &removexattr->rmxa_cinfo);  in nfsd4_encode_removexattr()
5817  *     - For NFS versions >=4.1, the size of the reply must stay within
5819  *     - For all NFS versions, we must stay within limited preallocated
5829 	struct xdr_buf *buf = &resp->rqstp->rq_res;  in nfsd4_check_resp_size()
5830 	struct nfsd4_slot *slot = resp->cstate.slot;  in nfsd4_check_resp_size()
5832 	if (buf->len + respsize <= buf->buflen)  in nfsd4_check_resp_size()
5834 	if (!nfsd4_has_session(&resp->cstate))  in nfsd4_check_resp_size()
5836 	if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) {  in nfsd4_check_resp_size()
5849 		/* RFC 8881 - 15.1.2.9 */  in nfsd4_map_status()
5863 	struct xdr_stream *xdr = resp->xdr;  in nfsd4_encode_operation()
5864 	struct nfs4_stateowner *so = resp->cstate.replay_owner;  in nfsd4_encode_operation()
5865 	struct svc_rqst *rqstp = resp->rqstp;  in nfsd4_encode_operation()
5866 	const struct nfsd4_operation *opdesc = op->opdesc;  in nfsd4_encode_operation()
5870 	if (xdr_stream_encode_u32(xdr, op->opnum) != XDR_UNIT)  in nfsd4_encode_operation()
5872 	op_status_offset = xdr->buf->len;  in nfsd4_encode_operation()
5876 	if (op->opnum == OP_ILLEGAL)  in nfsd4_encode_operation()
5878 	if (op->status && opdesc &&  in nfsd4_encode_operation()
5879 			!(opdesc->op_flags & OP_NONTRIVIAL_ERROR_ENCODE))  in nfsd4_encode_operation()
5881 	BUG_ON(op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) ||  in nfsd4_encode_operation()
5882 	       !nfsd4_enc_ops[op->opnum]);  in nfsd4_encode_operation()
5883 	encoder = nfsd4_enc_ops[op->opnum];  in nfsd4_encode_operation()
5884 	op->status = encoder(resp, op->status, &op->u);  in nfsd4_encode_operation()
5885 	if (op->status)  in nfsd4_encode_operation()
5886 		trace_nfsd_compound_encode_err(rqstp, op->opnum, op->status);  in nfsd4_encode_operation()
5890 	if (!op->status) {  in nfsd4_encode_operation()
5894 		op->status = nfsd4_check_resp_size(resp, space_needed);  in nfsd4_encode_operation()
5896 	if (op->status == nfserr_resource && nfsd4_has_session(&resp->cstate)) {  in nfsd4_encode_operation()
5897 		struct nfsd4_slot *slot = resp->cstate.slot;  in nfsd4_encode_operation()
5899 		if (slot->sl_flags & NFSD4_SLOT_CACHETHIS)  in nfsd4_encode_operation()
5900 			op->status = nfserr_rep_too_big_to_cache;  in nfsd4_encode_operation()
5902 			op->status = nfserr_rep_too_big;  in nfsd4_encode_operation()
5904 	if (op->status == nfserr_resource ||  in nfsd4_encode_operation()
5905 	    op->status == nfserr_rep_too_big ||  in nfsd4_encode_operation()
5906 	    op->status == nfserr_rep_too_big_to_cache) {  in nfsd4_encode_operation()
5912 		 * bug if we had to do this on a non-idempotent op:  in nfsd4_encode_operation()
5918 		int len = xdr->buf->len - (op_status_offset + XDR_UNIT);  in nfsd4_encode_operation()
5920 		so->so_replay.rp_status = op->status;  in nfsd4_encode_operation()
5921 		so->so_replay.rp_buflen = len;  in nfsd4_encode_operation()
5922 		read_bytes_from_xdr_buf(xdr->buf, op_status_offset + XDR_UNIT,  in nfsd4_encode_operation()
5923 						so->so_replay.rp_buf, len);  in nfsd4_encode_operation()
5926 	op->status = nfsd4_map_status(op->status,  in nfsd4_encode_operation()
5927 				      resp->cstate.minorversion);  in nfsd4_encode_operation()
5928 	write_bytes_to_xdr_buf(xdr->buf, op_status_offset,  in nfsd4_encode_operation()
5929 			       &op->status, XDR_UNIT);  in nfsd4_encode_operation()
5931 	if (opdesc && opdesc->op_release)  in nfsd4_encode_operation()
5932 		opdesc->op_release(&op->u);  in nfsd4_encode_operation()
5938 	rqstp->rq_next_page = xdr->page_ptr + 1;  in nfsd4_encode_operation()
5942  * nfsd4_encode_replay - encode a result stored in the stateowner reply cache
5946  * @op->replay->rp_buf contains the previously-sent already-encoded result.
5950 	struct nfs4_replay *rp = op->replay;  in nfsd4_encode_replay()
5952 	trace_nfsd_stateowner_replay(op->opnum, rp);  in nfsd4_encode_replay()
5954 	if (xdr_stream_encode_u32(xdr, op->opnum) != XDR_UNIT)  in nfsd4_encode_replay()
5956 	if (xdr_stream_encode_be32(xdr, rp->rp_status) != XDR_UNIT)  in nfsd4_encode_replay()
5958 	xdr_stream_encode_opaque_fixed(xdr, rp->rp_buf, rp->rp_buflen);  in nfsd4_encode_replay()
5963 	struct nfsd4_compoundargs *args = rqstp->rq_argp;  in nfsd4_release_compoundargs()
5965 	if (args->ops != args->iops) {  in nfsd4_release_compoundargs()
5966 		vfree(args->ops);  in nfsd4_release_compoundargs()
5967 		args->ops = args->iops;  in nfsd4_release_compoundargs()
5969 	while (args->to_free) {  in nfsd4_release_compoundargs()
5970 		struct svcxdr_tmpbuf *tb = args->to_free;  in nfsd4_release_compoundargs()
5971 		args->to_free = tb->next;  in nfsd4_release_compoundargs()
5979 	struct nfsd4_compoundargs *args = rqstp->rq_argp;  in nfs4svc_decode_compoundargs()
5982 	args->to_free = NULL;  in nfs4svc_decode_compoundargs()
5984 	args->xdr = xdr;  in nfs4svc_decode_compoundargs()
5985 	args->ops = args->iops;  in nfs4svc_decode_compoundargs()
5986 	args->rqstp = rqstp;  in nfs4svc_decode_compoundargs()
5994 	struct nfsd4_compoundres *resp = rqstp->rq_resp;  in nfs4svc_encode_compoundres()
6001 	p = resp->statusp;  in nfs4svc_encode_compoundres()
6003 	*p++ = resp->cstate.status;  in nfs4svc_encode_compoundres()
6004 	*p++ = htonl(resp->taglen);  in nfs4svc_encode_compoundres()
6005 	memcpy(p, resp->tag, resp->taglen);  in nfs4svc_encode_compoundres()
6006 	p += XDR_QUADLEN(resp->taglen);  in nfs4svc_encode_compoundres()
6007 	*p++ = htonl(resp->opcnt);  in nfs4svc_encode_compoundres()