Lines Matching +full:set +full:- +full:aces
2 * Server-side XDR for NFSv4
109 return (clid->cl_boot == 0) && (clid->cl_id == 0); in zero_clientid()
113 * svcxdr_tmpalloc - allocate memory to be freed after compound processing
128 tb->next = argp->to_free; in svcxdr_tmpalloc()
129 argp->to_free = tb; in svcxdr_tmpalloc()
130 return tb->buf; in svcxdr_tmpalloc()
135 * as null-terminated strings.
137 * Note null-terminating in place usually isn't safe since the
161 if (p != argp->xdr->scratch.iov_base) in svcxdr_savemem()
176 * This helper handles variable-length opaques which belong to protocol
184 if (xdr_stream_decode_u32(argp->xdr, &len) < 0) in nfsd4_decode_ignored_string()
188 if (!xdr_inline_decode(argp->xdr, len)) in nfsd4_decode_ignored_string()
200 if (xdr_stream_decode_u32(argp->xdr, &len) < 0) in nfsd4_decode_opaque()
204 p = xdr_inline_decode(argp->xdr, len); in nfsd4_decode_opaque()
207 o->data = svcxdr_savemem(argp, p, len); in nfsd4_decode_opaque()
208 if (!o->data) in nfsd4_decode_opaque()
210 o->len = len; in nfsd4_decode_opaque()
220 if (xdr_stream_decode_u32(argp->xdr, lenp) < 0) in nfsd4_decode_component4()
222 p = xdr_inline_decode(argp->xdr, *lenp); in nfsd4_decode_component4()
240 p = xdr_inline_decode(argp->xdr, XDR_UNIT * 3); in nfsd4_decode_nfstime4()
243 p = xdr_decode_hyper(p, &tv->tv_sec); in nfsd4_decode_nfstime4()
244 tv->tv_nsec = be32_to_cpup(p++); in nfsd4_decode_nfstime4()
245 if (tv->tv_nsec >= (u32)1000000000) in nfsd4_decode_nfstime4()
255 p = xdr_inline_decode(argp->xdr, NFS4_VERIFIER_SIZE); in nfsd4_decode_verifier4()
258 memcpy(verf->data, p, sizeof(verf->data)); in nfsd4_decode_verifier4()
263 * nfsd4_decode_bitmap4 - Decode an NFSv4 bitmap4
284 status = xdr_stream_decode_uint32_array(argp->xdr, bmval, bmlen); in nfsd4_decode_bitmap4()
285 return status == -EBADMSG ? nfserr_bad_xdr : nfs_ok; in nfsd4_decode_bitmap4()
294 if (xdr_stream_decode_u32(argp->xdr, &ace->type) < 0) in nfsd4_decode_nfsace4()
296 if (xdr_stream_decode_u32(argp->xdr, &ace->flag) < 0) in nfsd4_decode_nfsace4()
298 if (xdr_stream_decode_u32(argp->xdr, &ace->access_mask) < 0) in nfsd4_decode_nfsace4()
301 if (xdr_stream_decode_u32(argp->xdr, &length) < 0) in nfsd4_decode_nfsace4()
303 p = xdr_inline_decode(argp->xdr, length); in nfsd4_decode_nfsace4()
306 ace->whotype = nfs4_acl_get_whotype((char *)p, length); in nfsd4_decode_nfsace4()
307 if (ace->whotype != NFS4_ACL_WHO_NAMED) in nfsd4_decode_nfsace4()
309 else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP) in nfsd4_decode_nfsace4()
310 status = nfsd_map_name_to_gid(argp->rqstp, in nfsd4_decode_nfsace4()
311 (char *)p, length, &ace->who_gid); in nfsd4_decode_nfsace4()
313 status = nfsd_map_name_to_uid(argp->rqstp, in nfsd4_decode_nfsace4()
314 (char *)p, length, &ace->who_uid); in nfsd4_decode_nfsace4()
327 if (xdr_stream_decode_u32(argp->xdr, &count) < 0) in nfsd4_decode_acl()
330 if (count > xdr_stream_remaining(argp->xdr) / 20) in nfsd4_decode_acl()
332 * Even with 4-byte names there wouldn't be in nfsd4_decode_acl()
333 * space for that many aces; something fishy is in nfsd4_decode_acl()
342 (*acl)->naces = count; in nfsd4_decode_acl()
343 for (ace = (*acl)->aces; ace < (*acl)->aces + count; ace++) { in nfsd4_decode_acl()
359 if (xdr_stream_decode_u32(argp->xdr, &lfs) < 0) in nfsd4_decode_security_label()
361 if (xdr_stream_decode_u32(argp->xdr, &pi) < 0) in nfsd4_decode_security_label()
364 if (xdr_stream_decode_u32(argp->xdr, &length) < 0) in nfsd4_decode_security_label()
368 p = xdr_inline_decode(argp->xdr, length); in nfsd4_decode_security_label()
371 label->len = length; in nfsd4_decode_security_label()
372 label->data = svcxdr_dupstr(argp, p, length); in nfsd4_decode_security_label()
373 if (!label->data) in nfsd4_decode_security_label()
388 iattr->ia_valid = 0; in nfsd4_decode_fattr4()
396 if (nfsd_attrs_supported(argp->minorversion, bmval)) in nfsd4_decode_fattr4()
401 if (xdr_stream_decode_u32(argp->xdr, &attrlist4_count) < 0) in nfsd4_decode_fattr4()
403 starting_pos = xdr_stream_pos(argp->xdr); in nfsd4_decode_fattr4()
408 if (xdr_stream_decode_u64(argp->xdr, &size) < 0) in nfsd4_decode_fattr4()
410 iattr->ia_size = size; in nfsd4_decode_fattr4()
411 iattr->ia_valid |= ATTR_SIZE; in nfsd4_decode_fattr4()
422 if (xdr_stream_decode_u32(argp->xdr, &mode) < 0) in nfsd4_decode_fattr4()
424 iattr->ia_mode = mode; in nfsd4_decode_fattr4()
425 iattr->ia_mode &= (S_IFMT | S_IALLUGO); in nfsd4_decode_fattr4()
426 iattr->ia_valid |= ATTR_MODE; in nfsd4_decode_fattr4()
431 if (xdr_stream_decode_u32(argp->xdr, &length) < 0) in nfsd4_decode_fattr4()
433 p = xdr_inline_decode(argp->xdr, length); in nfsd4_decode_fattr4()
436 status = nfsd_map_name_to_uid(argp->rqstp, (char *)p, length, in nfsd4_decode_fattr4()
437 &iattr->ia_uid); in nfsd4_decode_fattr4()
440 iattr->ia_valid |= ATTR_UID; in nfsd4_decode_fattr4()
445 if (xdr_stream_decode_u32(argp->xdr, &length) < 0) in nfsd4_decode_fattr4()
447 p = xdr_inline_decode(argp->xdr, length); in nfsd4_decode_fattr4()
450 status = nfsd_map_name_to_gid(argp->rqstp, (char *)p, length, in nfsd4_decode_fattr4()
451 &iattr->ia_gid); in nfsd4_decode_fattr4()
454 iattr->ia_valid |= ATTR_GID; in nfsd4_decode_fattr4()
459 if (xdr_stream_decode_u32(argp->xdr, &set_it) < 0) in nfsd4_decode_fattr4()
463 status = nfsd4_decode_nfstime4(argp, &iattr->ia_atime); in nfsd4_decode_fattr4()
466 iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET); in nfsd4_decode_fattr4()
469 iattr->ia_valid |= ATTR_ATIME; in nfsd4_decode_fattr4()
487 if (xdr_stream_decode_u32(argp->xdr, &set_it) < 0) in nfsd4_decode_fattr4()
491 status = nfsd4_decode_nfstime4(argp, &iattr->ia_mtime); in nfsd4_decode_fattr4()
494 iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET); in nfsd4_decode_fattr4()
497 iattr->ia_valid |= ATTR_MTIME; in nfsd4_decode_fattr4()
503 label->len = 0; in nfsd4_decode_fattr4()
515 if (xdr_stream_decode_u32(argp->xdr, &mode) < 0) in nfsd4_decode_fattr4()
517 iattr->ia_mode = mode & (S_IFMT | S_IALLUGO); in nfsd4_decode_fattr4()
518 if (xdr_stream_decode_u32(argp->xdr, &mask) < 0) in nfsd4_decode_fattr4()
521 iattr->ia_valid |= ATTR_MODE; in nfsd4_decode_fattr4()
525 if (attrlist4_count != xdr_stream_pos(argp->xdr) - starting_pos) in nfsd4_decode_fattr4()
536 p = xdr_inline_decode(argp->xdr, NFS4_STATEID_SIZE); in nfsd4_decode_stateid4()
539 sid->si_generation = be32_to_cpup(p++); in nfsd4_decode_stateid4()
540 memcpy(&sid->si_opaque, p, sizeof(sid->si_opaque)); in nfsd4_decode_stateid4()
549 p = xdr_inline_decode(argp->xdr, sizeof(__be64)); in nfsd4_decode_clientid4()
575 p = xdr_inline_decode(argp->xdr, NFS4_DEVICEID4_SIZE); in nfsd4_decode_deviceid4()
586 if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_layout_type) < 0) in nfsd4_decode_layoutupdate4()
588 if (lcp->lc_layout_type < LAYOUT_NFSV4_1_FILES) in nfsd4_decode_layoutupdate4()
590 if (lcp->lc_layout_type >= LAYOUT_TYPE_MAX) in nfsd4_decode_layoutupdate4()
593 if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_up_len) < 0) in nfsd4_decode_layoutupdate4()
595 if (lcp->lc_up_len > 0) { in nfsd4_decode_layoutupdate4()
596 lcp->lc_up_layout = xdr_inline_decode(argp->xdr, lcp->lc_up_len); in nfsd4_decode_layoutupdate4()
597 if (!lcp->lc_up_layout) in nfsd4_decode_layoutupdate4()
610 if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_return_type) < 0) in nfsd4_decode_layoutreturn4()
612 switch (lrp->lr_return_type) { in nfsd4_decode_layoutreturn4()
614 if (xdr_stream_decode_u64(argp->xdr, &lrp->lr_seg.offset) < 0) in nfsd4_decode_layoutreturn4()
616 if (xdr_stream_decode_u64(argp->xdr, &lrp->lr_seg.length) < 0) in nfsd4_decode_layoutreturn4()
618 status = nfsd4_decode_stateid4(argp, &lrp->lr_sid); in nfsd4_decode_layoutreturn4()
621 if (xdr_stream_decode_u32(argp->xdr, &lrp->lrf_body_len) < 0) in nfsd4_decode_layoutreturn4()
623 if (lrp->lrf_body_len > 0) { in nfsd4_decode_layoutreturn4()
624 lrp->lrf_body = xdr_inline_decode(argp->xdr, lrp->lrf_body_len); in nfsd4_decode_layoutreturn4()
625 if (!lrp->lrf_body) in nfsd4_decode_layoutreturn4()
631 lrp->lr_seg.offset = 0; in nfsd4_decode_layoutreturn4()
632 lrp->lr_seg.length = NFS4_MAX_UINT64; in nfsd4_decode_layoutreturn4()
649 p = xdr_inline_decode(argp->xdr, NFS4_MAX_SESSIONID_LEN); in nfsd4_decode_sessionid4()
652 memcpy(sessionid->data, p, sizeof(sessionid->data)); in nfsd4_decode_sessionid4()
664 if (xdr_stream_decode_u32(argp->xdr, &stamp) < 0) in nfsd4_decode_authsys_parms()
670 if (xdr_stream_decode_u32(argp->xdr, &uid) < 0) in nfsd4_decode_authsys_parms()
672 if (xdr_stream_decode_u32(argp->xdr, &gid) < 0) in nfsd4_decode_authsys_parms()
674 if (xdr_stream_decode_u32(argp->xdr, &gidcount) < 0) in nfsd4_decode_authsys_parms()
678 p = xdr_inline_decode(argp->xdr, gidcount << 2); in nfsd4_decode_authsys_parms()
681 if (cbs->flavor == (u32)(-1)) { in nfsd4_decode_authsys_parms()
682 struct user_namespace *userns = nfsd_user_namespace(argp->rqstp); in nfsd4_decode_authsys_parms()
687 cbs->uid = kuid; in nfsd4_decode_authsys_parms()
688 cbs->gid = kgid; in nfsd4_decode_authsys_parms()
689 cbs->flavor = RPC_AUTH_UNIX; in nfsd4_decode_authsys_parms()
707 if (xdr_stream_decode_u32(argp->xdr, &service) < 0) in nfsd4_decode_gss_cb_handles4()
731 if (xdr_stream_decode_u32(argp->xdr, &nr_secflavs) < 0) in nfsd4_decode_cb_sec()
734 cbs->flavor = (u32)(-1); in nfsd4_decode_cb_sec()
737 cbs->flavor = 0; in nfsd4_decode_cb_sec()
740 if (xdr_stream_decode_u32(argp->xdr, &secflavor) < 0) in nfsd4_decode_cb_sec()
745 if (cbs->flavor == (u32)(-1)) in nfsd4_decode_cb_sec()
746 cbs->flavor = RPC_AUTH_NULL; in nfsd4_decode_cb_sec()
775 struct nfsd4_access *access = &u->access; in nfsd4_decode_access()
776 if (xdr_stream_decode_u32(argp->xdr, &access->ac_req_access) < 0) in nfsd4_decode_access()
784 struct nfsd4_close *close = &u->close; in nfsd4_decode_close()
785 if (xdr_stream_decode_u32(argp->xdr, &close->cl_seqid) < 0) in nfsd4_decode_close()
787 return nfsd4_decode_stateid4(argp, &close->cl_stateid); in nfsd4_decode_close()
794 struct nfsd4_commit *commit = &u->commit; in nfsd4_decode_commit()
795 if (xdr_stream_decode_u64(argp->xdr, &commit->co_offset) < 0) in nfsd4_decode_commit()
797 if (xdr_stream_decode_u32(argp->xdr, &commit->co_count) < 0) in nfsd4_decode_commit()
799 memset(&commit->co_verf, 0, sizeof(commit->co_verf)); in nfsd4_decode_commit()
806 struct nfsd4_create *create = &u->create; in nfsd4_decode_create()
810 if (xdr_stream_decode_u32(argp->xdr, &create->cr_type) < 0) in nfsd4_decode_create()
812 switch (create->cr_type) { in nfsd4_decode_create()
814 if (xdr_stream_decode_u32(argp->xdr, &create->cr_datalen) < 0) in nfsd4_decode_create()
816 p = xdr_inline_decode(argp->xdr, create->cr_datalen); in nfsd4_decode_create()
819 create->cr_data = svcxdr_dupstr(argp, p, create->cr_datalen); in nfsd4_decode_create()
820 if (!create->cr_data) in nfsd4_decode_create()
825 if (xdr_stream_decode_u32(argp->xdr, &create->cr_specdata1) < 0) in nfsd4_decode_create()
827 if (xdr_stream_decode_u32(argp->xdr, &create->cr_specdata2) < 0) in nfsd4_decode_create()
836 status = nfsd4_decode_component4(argp, &create->cr_name, in nfsd4_decode_create()
837 &create->cr_namelen); in nfsd4_decode_create()
840 status = nfsd4_decode_fattr4(argp, create->cr_bmval, in nfsd4_decode_create()
841 ARRAY_SIZE(create->cr_bmval), in nfsd4_decode_create()
842 &create->cr_iattr, &create->cr_acl, in nfsd4_decode_create()
843 &create->cr_label, &create->cr_umask); in nfsd4_decode_create()
853 struct nfsd4_delegreturn *dr = &u->delegreturn; in nfsd4_decode_delegreturn()
854 return nfsd4_decode_stateid4(argp, &dr->dr_stateid); in nfsd4_decode_delegreturn()
860 struct nfsd4_getattr *getattr = &u->getattr; in nfsd4_decode_getattr()
862 return nfsd4_decode_bitmap4(argp, getattr->ga_bmval, in nfsd4_decode_getattr()
863 ARRAY_SIZE(getattr->ga_bmval)); in nfsd4_decode_getattr()
869 struct nfsd4_link *link = &u->link; in nfsd4_decode_link()
871 return nfsd4_decode_component4(argp, &link->li_name, &link->li_namelen); in nfsd4_decode_link()
880 if (xdr_stream_decode_u32(argp->xdr, &lock->lk_new_open_seqid) < 0) in nfsd4_decode_open_to_lock_owner4()
882 status = nfsd4_decode_stateid4(argp, &lock->lk_new_open_stateid); in nfsd4_decode_open_to_lock_owner4()
885 if (xdr_stream_decode_u32(argp->xdr, &lock->lk_new_lock_seqid) < 0) in nfsd4_decode_open_to_lock_owner4()
887 return nfsd4_decode_state_owner4(argp, &lock->lk_new_clientid, in nfsd4_decode_open_to_lock_owner4()
888 &lock->lk_new_owner); in nfsd4_decode_open_to_lock_owner4()
897 status = nfsd4_decode_stateid4(argp, &lock->lk_old_lock_stateid); in nfsd4_decode_exist_lock_owner4()
900 if (xdr_stream_decode_u32(argp->xdr, &lock->lk_old_lock_seqid) < 0) in nfsd4_decode_exist_lock_owner4()
909 if (xdr_stream_decode_bool(argp->xdr, &lock->lk_is_new) < 0) in nfsd4_decode_locker4()
911 if (lock->lk_is_new) in nfsd4_decode_locker4()
919 struct nfsd4_lock *lock = &u->lock; in nfsd4_decode_lock()
921 if (xdr_stream_decode_u32(argp->xdr, &lock->lk_type) < 0) in nfsd4_decode_lock()
923 if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT)) in nfsd4_decode_lock()
925 if (xdr_stream_decode_bool(argp->xdr, &lock->lk_reclaim) < 0) in nfsd4_decode_lock()
927 if (xdr_stream_decode_u64(argp->xdr, &lock->lk_offset) < 0) in nfsd4_decode_lock()
929 if (xdr_stream_decode_u64(argp->xdr, &lock->lk_length) < 0) in nfsd4_decode_lock()
937 struct nfsd4_lockt *lockt = &u->lockt; in nfsd4_decode_lockt()
939 if (xdr_stream_decode_u32(argp->xdr, &lockt->lt_type) < 0) in nfsd4_decode_lockt()
941 if ((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT)) in nfsd4_decode_lockt()
943 if (xdr_stream_decode_u64(argp->xdr, &lockt->lt_offset) < 0) in nfsd4_decode_lockt()
945 if (xdr_stream_decode_u64(argp->xdr, &lockt->lt_length) < 0) in nfsd4_decode_lockt()
947 return nfsd4_decode_state_owner4(argp, &lockt->lt_clientid, in nfsd4_decode_lockt()
948 &lockt->lt_owner); in nfsd4_decode_lockt()
954 struct nfsd4_locku *locku = &u->locku; in nfsd4_decode_locku()
957 if (xdr_stream_decode_u32(argp->xdr, &locku->lu_type) < 0) in nfsd4_decode_locku()
959 if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT)) in nfsd4_decode_locku()
961 if (xdr_stream_decode_u32(argp->xdr, &locku->lu_seqid) < 0) in nfsd4_decode_locku()
963 status = nfsd4_decode_stateid4(argp, &locku->lu_stateid); in nfsd4_decode_locku()
966 if (xdr_stream_decode_u64(argp->xdr, &locku->lu_offset) < 0) in nfsd4_decode_locku()
968 if (xdr_stream_decode_u64(argp->xdr, &locku->lu_length) < 0) in nfsd4_decode_locku()
977 struct nfsd4_lookup *lookup = &u->lookup; in nfsd4_decode_lookup()
978 return nfsd4_decode_component4(argp, &lookup->lo_name, &lookup->lo_len); in nfsd4_decode_lookup()
986 if (xdr_stream_decode_u32(argp->xdr, &open->op_createmode) < 0) in nfsd4_decode_createhow4()
988 switch (open->op_createmode) { in nfsd4_decode_createhow4()
991 status = nfsd4_decode_fattr4(argp, open->op_bmval, in nfsd4_decode_createhow4()
992 ARRAY_SIZE(open->op_bmval), in nfsd4_decode_createhow4()
993 &open->op_iattr, &open->op_acl, in nfsd4_decode_createhow4()
994 &open->op_label, &open->op_umask); in nfsd4_decode_createhow4()
999 status = nfsd4_decode_verifier4(argp, &open->op_verf); in nfsd4_decode_createhow4()
1004 if (argp->minorversion < 1) in nfsd4_decode_createhow4()
1006 status = nfsd4_decode_verifier4(argp, &open->op_verf); in nfsd4_decode_createhow4()
1009 status = nfsd4_decode_fattr4(argp, open->op_bmval, in nfsd4_decode_createhow4()
1010 ARRAY_SIZE(open->op_bmval), in nfsd4_decode_createhow4()
1011 &open->op_iattr, &open->op_acl, in nfsd4_decode_createhow4()
1012 &open->op_label, &open->op_umask); in nfsd4_decode_createhow4()
1028 if (xdr_stream_decode_u32(argp->xdr, &open->op_create) < 0) in nfsd4_decode_openflag4()
1030 switch (open->op_create) { in nfsd4_decode_openflag4()
1049 if (xdr_stream_decode_u32(argp->xdr, &w) < 0) in nfsd4_decode_share_access()
1067 if (!argp->minorversion) in nfsd4_decode_share_access()
1098 if (xdr_stream_decode_u32(argp->xdr, x) < 0) in nfsd4_decode_share_deny()
1113 if (xdr_stream_decode_u32(argp->xdr, &open->op_claim_type) < 0) in nfsd4_decode_open_claim4()
1115 switch (open->op_claim_type) { in nfsd4_decode_open_claim4()
1118 status = nfsd4_decode_component4(argp, &open->op_fname, in nfsd4_decode_open_claim4()
1119 &open->op_fnamelen); in nfsd4_decode_open_claim4()
1124 if (xdr_stream_decode_u32(argp->xdr, &open->op_delegate_type) < 0) in nfsd4_decode_open_claim4()
1128 status = nfsd4_decode_stateid4(argp, &open->op_delegate_stateid); in nfsd4_decode_open_claim4()
1131 status = nfsd4_decode_component4(argp, &open->op_fname, in nfsd4_decode_open_claim4()
1132 &open->op_fnamelen); in nfsd4_decode_open_claim4()
1138 if (argp->minorversion < 1) in nfsd4_decode_open_claim4()
1143 if (argp->minorversion < 1) in nfsd4_decode_open_claim4()
1145 status = nfsd4_decode_stateid4(argp, &open->op_delegate_stateid); in nfsd4_decode_open_claim4()
1159 struct nfsd4_open *open = &u->open; in nfsd4_decode_open()
1165 if (xdr_stream_decode_u32(argp->xdr, &open->op_seqid) < 0) in nfsd4_decode_open()
1168 status = nfsd4_decode_share_access(argp, &open->op_share_access, in nfsd4_decode_open()
1169 &open->op_deleg_want, &dummy); in nfsd4_decode_open()
1172 status = nfsd4_decode_share_deny(argp, &open->op_share_deny); in nfsd4_decode_open()
1175 status = nfsd4_decode_state_owner4(argp, &open->op_clientid, in nfsd4_decode_open()
1176 &open->op_owner); in nfsd4_decode_open()
1189 struct nfsd4_open_confirm *open_conf = &u->open_confirm; in nfsd4_decode_open_confirm()
1192 if (argp->minorversion >= 1) in nfsd4_decode_open_confirm()
1195 status = nfsd4_decode_stateid4(argp, &open_conf->oc_req_stateid); in nfsd4_decode_open_confirm()
1198 if (xdr_stream_decode_u32(argp->xdr, &open_conf->oc_seqid) < 0) in nfsd4_decode_open_confirm()
1201 memset(&open_conf->oc_resp_stateid, 0, in nfsd4_decode_open_confirm()
1202 sizeof(open_conf->oc_resp_stateid)); in nfsd4_decode_open_confirm()
1210 struct nfsd4_open_downgrade *open_down = &u->open_downgrade; in nfsd4_decode_open_downgrade()
1214 status = nfsd4_decode_stateid4(argp, &open_down->od_stateid); in nfsd4_decode_open_downgrade()
1217 if (xdr_stream_decode_u32(argp->xdr, &open_down->od_seqid) < 0) in nfsd4_decode_open_downgrade()
1220 status = nfsd4_decode_share_access(argp, &open_down->od_share_access, in nfsd4_decode_open_downgrade()
1221 &open_down->od_deleg_want, NULL); in nfsd4_decode_open_downgrade()
1224 return nfsd4_decode_share_deny(argp, &open_down->od_share_deny); in nfsd4_decode_open_downgrade()
1230 struct nfsd4_putfh *putfh = &u->putfh; in nfsd4_decode_putfh()
1233 if (xdr_stream_decode_u32(argp->xdr, &putfh->pf_fhlen) < 0) in nfsd4_decode_putfh()
1235 if (putfh->pf_fhlen > NFS4_FHSIZE) in nfsd4_decode_putfh()
1237 p = xdr_inline_decode(argp->xdr, putfh->pf_fhlen); in nfsd4_decode_putfh()
1240 putfh->pf_fhval = svcxdr_savemem(argp, p, putfh->pf_fhlen); in nfsd4_decode_putfh()
1241 if (!putfh->pf_fhval) in nfsd4_decode_putfh()
1244 putfh->no_verify = false; in nfsd4_decode_putfh()
1251 struct nfsd4_read *read = &u->read; in nfsd4_decode_read()
1255 status = nfsd4_decode_stateid4(argp, &read->rd_stateid); in nfsd4_decode_read()
1258 if (xdr_stream_decode_u64(argp->xdr, &read->rd_offset) < 0) in nfsd4_decode_read()
1260 if (xdr_stream_decode_u32(argp->xdr, &read->rd_length) < 0) in nfsd4_decode_read()
1269 struct nfsd4_readdir *readdir = &u->readdir; in nfsd4_decode_readdir()
1273 if (xdr_stream_decode_u64(argp->xdr, &readdir->rd_cookie) < 0) in nfsd4_decode_readdir()
1275 status = nfsd4_decode_verifier4(argp, &readdir->rd_verf); in nfsd4_decode_readdir()
1278 if (xdr_stream_decode_u32(argp->xdr, &readdir->rd_dircount) < 0) in nfsd4_decode_readdir()
1280 if (xdr_stream_decode_u32(argp->xdr, &readdir->rd_maxcount) < 0) in nfsd4_decode_readdir()
1282 if (xdr_stream_decode_uint32_array(argp->xdr, readdir->rd_bmval, in nfsd4_decode_readdir()
1283 ARRAY_SIZE(readdir->rd_bmval)) < 0) in nfsd4_decode_readdir()
1292 struct nfsd4_remove *remove = &u->remove; in nfsd4_decode_remove()
1293 memset(&remove->rm_cinfo, 0, sizeof(remove->rm_cinfo)); in nfsd4_decode_remove()
1294 return nfsd4_decode_component4(argp, &remove->rm_name, &remove->rm_namelen); in nfsd4_decode_remove()
1300 struct nfsd4_rename *rename = &u->rename; in nfsd4_decode_rename()
1304 status = nfsd4_decode_component4(argp, &rename->rn_sname, &rename->rn_snamelen); in nfsd4_decode_rename()
1307 return nfsd4_decode_component4(argp, &rename->rn_tname, &rename->rn_tnamelen); in nfsd4_decode_rename()
1313 clientid_t *clientid = &u->renew; in nfsd4_decode_renew()
1321 struct nfsd4_secinfo *secinfo = &u->secinfo; in nfsd4_decode_secinfo()
1322 secinfo->si_exp = NULL; in nfsd4_decode_secinfo()
1323 return nfsd4_decode_component4(argp, &secinfo->si_name, &secinfo->si_namelen); in nfsd4_decode_secinfo()
1329 struct nfsd4_setattr *setattr = &u->setattr; in nfsd4_decode_setattr()
1333 status = nfsd4_decode_stateid4(argp, &setattr->sa_stateid); in nfsd4_decode_setattr()
1336 return nfsd4_decode_fattr4(argp, setattr->sa_bmval, in nfsd4_decode_setattr()
1337 ARRAY_SIZE(setattr->sa_bmval), in nfsd4_decode_setattr()
1338 &setattr->sa_iattr, &setattr->sa_acl, in nfsd4_decode_setattr()
1339 &setattr->sa_label, NULL); in nfsd4_decode_setattr()
1345 struct nfsd4_setclientid *setclientid = &u->setclientid; in nfsd4_decode_setclientid()
1350 if (argp->minorversion >= 1) in nfsd4_decode_setclientid()
1353 status = nfsd4_decode_verifier4(argp, &setclientid->se_verf); in nfsd4_decode_setclientid()
1356 status = nfsd4_decode_opaque(argp, &setclientid->se_name); in nfsd4_decode_setclientid()
1359 if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_prog) < 0) in nfsd4_decode_setclientid()
1361 if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_netid_len) < 0) in nfsd4_decode_setclientid()
1363 p = xdr_inline_decode(argp->xdr, setclientid->se_callback_netid_len); in nfsd4_decode_setclientid()
1366 setclientid->se_callback_netid_val = svcxdr_savemem(argp, p, in nfsd4_decode_setclientid()
1367 setclientid->se_callback_netid_len); in nfsd4_decode_setclientid()
1368 if (!setclientid->se_callback_netid_val) in nfsd4_decode_setclientid()
1371 if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_addr_len) < 0) in nfsd4_decode_setclientid()
1373 p = xdr_inline_decode(argp->xdr, setclientid->se_callback_addr_len); in nfsd4_decode_setclientid()
1376 setclientid->se_callback_addr_val = svcxdr_savemem(argp, p, in nfsd4_decode_setclientid()
1377 setclientid->se_callback_addr_len); in nfsd4_decode_setclientid()
1378 if (!setclientid->se_callback_addr_val) in nfsd4_decode_setclientid()
1380 if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_ident) < 0) in nfsd4_decode_setclientid()
1390 struct nfsd4_setclientid_confirm *scd_c = &u->setclientid_confirm; in nfsd4_decode_setclientid_confirm()
1393 if (argp->minorversion >= 1) in nfsd4_decode_setclientid_confirm()
1396 status = nfsd4_decode_clientid4(argp, &scd_c->sc_clientid); in nfsd4_decode_setclientid_confirm()
1399 return nfsd4_decode_verifier4(argp, &scd_c->sc_confirm); in nfsd4_decode_setclientid_confirm()
1406 struct nfsd4_verify *verify = &u->verify; in nfsd4_decode_verify()
1411 status = nfsd4_decode_bitmap4(argp, verify->ve_bmval, in nfsd4_decode_verify()
1412 ARRAY_SIZE(verify->ve_bmval)); in nfsd4_decode_verify()
1419 if (xdr_stream_decode_u32(argp->xdr, &verify->ve_attrlen) < 0) in nfsd4_decode_verify()
1421 p = xdr_inline_decode(argp->xdr, verify->ve_attrlen); in nfsd4_decode_verify()
1424 verify->ve_attrval = svcxdr_savemem(argp, p, verify->ve_attrlen); in nfsd4_decode_verify()
1425 if (!verify->ve_attrval) in nfsd4_decode_verify()
1434 struct nfsd4_write *write = &u->write; in nfsd4_decode_write()
1437 status = nfsd4_decode_stateid4(argp, &write->wr_stateid); in nfsd4_decode_write()
1440 if (xdr_stream_decode_u64(argp->xdr, &write->wr_offset) < 0) in nfsd4_decode_write()
1442 if (xdr_stream_decode_u32(argp->xdr, &write->wr_stable_how) < 0) in nfsd4_decode_write()
1444 if (write->wr_stable_how > NFS_FILE_SYNC) in nfsd4_decode_write()
1446 if (xdr_stream_decode_u32(argp->xdr, &write->wr_buflen) < 0) in nfsd4_decode_write()
1448 if (!xdr_stream_subsegment(argp->xdr, &write->wr_payload, write->wr_buflen)) in nfsd4_decode_write()
1451 write->wr_bytes_written = 0; in nfsd4_decode_write()
1452 write->wr_how_written = 0; in nfsd4_decode_write()
1453 memset(&write->wr_verifier, 0, sizeof(write->wr_verifier)); in nfsd4_decode_write()
1461 struct nfsd4_release_lockowner *rlockowner = &u->release_lockowner; in nfsd4_decode_release_lockowner()
1464 if (argp->minorversion >= 1) in nfsd4_decode_release_lockowner()
1467 status = nfsd4_decode_state_owner4(argp, &rlockowner->rl_clientid, in nfsd4_decode_release_lockowner()
1468 &rlockowner->rl_owner); in nfsd4_decode_release_lockowner()
1472 if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid)) in nfsd4_decode_release_lockowner()
1481 struct nfsd4_backchannel_ctl *bc = &u->backchannel_ctl; in nfsd4_decode_backchannel_ctl()
1483 if (xdr_stream_decode_u32(argp->xdr, &bc->bc_cb_program) < 0) in nfsd4_decode_backchannel_ctl()
1485 return nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec); in nfsd4_decode_backchannel_ctl()
1491 struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session; in nfsd4_decode_bind_conn_to_session()
1496 status = nfsd4_decode_sessionid4(argp, &bcts->sessionid); in nfsd4_decode_bind_conn_to_session()
1499 if (xdr_stream_decode_u32(argp->xdr, &bcts->dir) < 0) in nfsd4_decode_bind_conn_to_session()
1501 if (xdr_stream_decode_u32(argp->xdr, &use_conn_in_rdma_mode) < 0) in nfsd4_decode_bind_conn_to_session()
1513 status = nfsd4_decode_bitmap4(argp, exid->spo_must_enforce, in nfsd4_decode_state_protect_ops()
1514 ARRAY_SIZE(exid->spo_must_enforce)); in nfsd4_decode_state_protect_ops()
1517 status = nfsd4_decode_bitmap4(argp, exid->spo_must_allow, in nfsd4_decode_state_protect_ops()
1518 ARRAY_SIZE(exid->spo_must_allow)); in nfsd4_decode_state_protect_ops()
1542 if (xdr_stream_decode_u32(argp->xdr, &count) < 0) in nfsd4_decode_ssv_sp_parms()
1544 while (count--) { in nfsd4_decode_ssv_sp_parms()
1551 if (xdr_stream_decode_u32(argp->xdr, &count) < 0) in nfsd4_decode_ssv_sp_parms()
1553 while (count--) { in nfsd4_decode_ssv_sp_parms()
1559 if (xdr_stream_decode_u32(argp->xdr, &window) < 0) in nfsd4_decode_ssv_sp_parms()
1561 if (xdr_stream_decode_u32(argp->xdr, &num_gss_handles) < 0) in nfsd4_decode_ssv_sp_parms()
1573 if (xdr_stream_decode_u32(argp->xdr, &exid->spa_how) < 0) in nfsd4_decode_state_protect4_a()
1575 switch (exid->spa_how) { in nfsd4_decode_state_protect4_a()
1602 if (xdr_stream_decode_u32(argp->xdr, &count) < 0) in nfsd4_decode_nfs_impl_id4()
1611 status = nfsd4_decode_opaque(argp, &exid->nii_domain); in nfsd4_decode_nfs_impl_id4()
1617 status = nfsd4_decode_opaque(argp, &exid->nii_name); in nfsd4_decode_nfs_impl_id4()
1620 status = nfsd4_decode_nfstime4(argp, &exid->nii_time); in nfsd4_decode_nfs_impl_id4()
1635 struct nfsd4_exchange_id *exid = &u->exchange_id; in nfsd4_decode_exchange_id()
1639 status = nfsd4_decode_verifier4(argp, &exid->verifier); in nfsd4_decode_exchange_id()
1642 status = nfsd4_decode_opaque(argp, &exid->clname); in nfsd4_decode_exchange_id()
1645 if (xdr_stream_decode_u32(argp->xdr, &exid->flags) < 0) in nfsd4_decode_exchange_id()
1659 p = xdr_inline_decode(argp->xdr, XDR_UNIT * 7); in nfsd4_decode_channel_attrs4()
1665 ca->maxreq_sz = be32_to_cpup(p++); in nfsd4_decode_channel_attrs4()
1666 ca->maxresp_sz = be32_to_cpup(p++); in nfsd4_decode_channel_attrs4()
1667 ca->maxresp_cached = be32_to_cpup(p++); in nfsd4_decode_channel_attrs4()
1668 ca->maxops = be32_to_cpup(p++); in nfsd4_decode_channel_attrs4()
1669 ca->maxreqs = be32_to_cpup(p++); in nfsd4_decode_channel_attrs4()
1670 ca->nr_rdma_attrs = be32_to_cpup(p); in nfsd4_decode_channel_attrs4()
1671 switch (ca->nr_rdma_attrs) { in nfsd4_decode_channel_attrs4()
1675 if (xdr_stream_decode_u32(argp->xdr, &ca->rdma_attrs) < 0) in nfsd4_decode_channel_attrs4()
1689 struct nfsd4_create_session *sess = &u->create_session; in nfsd4_decode_create_session()
1693 status = nfsd4_decode_clientid4(argp, &sess->clientid); in nfsd4_decode_create_session()
1696 if (xdr_stream_decode_u32(argp->xdr, &sess->seqid) < 0) in nfsd4_decode_create_session()
1698 if (xdr_stream_decode_u32(argp->xdr, &sess->flags) < 0) in nfsd4_decode_create_session()
1700 status = nfsd4_decode_channel_attrs4(argp, &sess->fore_channel); in nfsd4_decode_create_session()
1703 status = nfsd4_decode_channel_attrs4(argp, &sess->back_channel); in nfsd4_decode_create_session()
1706 if (xdr_stream_decode_u32(argp->xdr, &sess->callback_prog) < 0) in nfsd4_decode_create_session()
1708 return nfsd4_decode_cb_sec(argp, &sess->cb_sec); in nfsd4_decode_create_session()
1715 struct nfsd4_destroy_session *destroy_session = &u->destroy_session; in nfsd4_decode_destroy_session()
1716 return nfsd4_decode_sessionid4(argp, &destroy_session->sessionid); in nfsd4_decode_destroy_session()
1723 struct nfsd4_free_stateid *free_stateid = &u->free_stateid; in nfsd4_decode_free_stateid()
1724 return nfsd4_decode_stateid4(argp, &free_stateid->fr_stateid); in nfsd4_decode_free_stateid()
1732 struct nfsd4_getdeviceinfo *gdev = &u->getdeviceinfo; in nfsd4_decode_getdeviceinfo()
1736 status = nfsd4_decode_deviceid4(argp, &gdev->gd_devid); in nfsd4_decode_getdeviceinfo()
1739 if (xdr_stream_decode_u32(argp->xdr, &gdev->gd_layout_type) < 0) in nfsd4_decode_getdeviceinfo()
1741 if (xdr_stream_decode_u32(argp->xdr, &gdev->gd_maxcount) < 0) in nfsd4_decode_getdeviceinfo()
1743 if (xdr_stream_decode_uint32_array(argp->xdr, in nfsd4_decode_getdeviceinfo()
1744 &gdev->gd_notify_types, 1) < 0) in nfsd4_decode_getdeviceinfo()
1754 struct nfsd4_layoutcommit *lcp = &u->layoutcommit; in nfsd4_decode_layoutcommit()
1758 if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_seg.offset) < 0) in nfsd4_decode_layoutcommit()
1760 if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_seg.length) < 0) in nfsd4_decode_layoutcommit()
1762 if (xdr_stream_decode_bool(argp->xdr, &lcp->lc_reclaim) < 0) in nfsd4_decode_layoutcommit()
1764 status = nfsd4_decode_stateid4(argp, &lcp->lc_sid); in nfsd4_decode_layoutcommit()
1767 if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_newoffset) < 0) in nfsd4_decode_layoutcommit()
1769 if (lcp->lc_newoffset) { in nfsd4_decode_layoutcommit()
1770 if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_last_wr) < 0) in nfsd4_decode_layoutcommit()
1773 lcp->lc_last_wr = 0; in nfsd4_decode_layoutcommit()
1774 p = xdr_inline_decode(argp->xdr, XDR_UNIT); in nfsd4_decode_layoutcommit()
1778 status = nfsd4_decode_nfstime4(argp, &lcp->lc_mtime); in nfsd4_decode_layoutcommit()
1782 lcp->lc_mtime.tv_nsec = UTIME_NOW; in nfsd4_decode_layoutcommit()
1791 struct nfsd4_layoutget *lgp = &u->layoutget; in nfsd4_decode_layoutget()
1795 if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_signal) < 0) in nfsd4_decode_layoutget()
1797 if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_layout_type) < 0) in nfsd4_decode_layoutget()
1799 if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_seg.iomode) < 0) in nfsd4_decode_layoutget()
1801 if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_seg.offset) < 0) in nfsd4_decode_layoutget()
1803 if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_seg.length) < 0) in nfsd4_decode_layoutget()
1805 if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_minlength) < 0) in nfsd4_decode_layoutget()
1807 status = nfsd4_decode_stateid4(argp, &lgp->lg_sid); in nfsd4_decode_layoutget()
1810 if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_maxcount) < 0) in nfsd4_decode_layoutget()
1820 struct nfsd4_layoutreturn *lrp = &u->layoutreturn; in nfsd4_decode_layoutreturn()
1822 if (xdr_stream_decode_bool(argp->xdr, &lrp->lr_reclaim) < 0) in nfsd4_decode_layoutreturn()
1824 if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_layout_type) < 0) in nfsd4_decode_layoutreturn()
1826 if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_seg.iomode) < 0) in nfsd4_decode_layoutreturn()
1835 struct nfsd4_secinfo_no_name *sin = &u->secinfo_no_name; in nfsd4_decode_secinfo_no_name()
1836 if (xdr_stream_decode_u32(argp->xdr, &sin->sin_style) < 0) in nfsd4_decode_secinfo_no_name()
1839 sin->sin_exp = NULL; in nfsd4_decode_secinfo_no_name()
1847 struct nfsd4_sequence *seq = &u->sequence; in nfsd4_decode_sequence()
1850 status = nfsd4_decode_sessionid4(argp, &seq->sessionid); in nfsd4_decode_sequence()
1853 p = xdr_inline_decode(argp->xdr, XDR_UNIT * 4); in nfsd4_decode_sequence()
1856 seq->seqid = be32_to_cpup(p++); in nfsd4_decode_sequence()
1857 seq->slotid = be32_to_cpup(p++); in nfsd4_decode_sequence()
1858 seq->maxslots = be32_to_cpup(p++); in nfsd4_decode_sequence()
1859 seq->cachethis = be32_to_cpup(p); in nfsd4_decode_sequence()
1861 seq->status_flags = 0; in nfsd4_decode_sequence()
1869 struct nfsd4_test_stateid *test_stateid = &u->test_stateid; in nfsd4_decode_test_stateid()
1875 if (xdr_stream_decode_u32(argp->xdr, &test_stateid->ts_num_ids) < 0) in nfsd4_decode_test_stateid()
1878 INIT_LIST_HEAD(&test_stateid->ts_stateid_list); in nfsd4_decode_test_stateid()
1879 for (i = 0; i < test_stateid->ts_num_ids; i++) { in nfsd4_decode_test_stateid()
1883 INIT_LIST_HEAD(&stateid->ts_id_list); in nfsd4_decode_test_stateid()
1884 list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list); in nfsd4_decode_test_stateid()
1885 status = nfsd4_decode_stateid4(argp, &stateid->ts_id_stateid); in nfsd4_decode_test_stateid()
1896 struct nfsd4_destroy_clientid *dc = &u->destroy_clientid; in nfsd4_decode_destroy_clientid()
1897 return nfsd4_decode_clientid4(argp, &dc->clientid); in nfsd4_decode_destroy_clientid()
1903 struct nfsd4_reclaim_complete *rc = &u->reclaim_complete; in nfsd4_decode_reclaim_complete()
1904 if (xdr_stream_decode_bool(argp->xdr, &rc->rca_one_fs) < 0) in nfsd4_decode_reclaim_complete()
1913 struct nfsd4_fallocate *fallocate = &u->allocate; in nfsd4_decode_fallocate()
1916 status = nfsd4_decode_stateid4(argp, &fallocate->falloc_stateid); in nfsd4_decode_fallocate()
1919 if (xdr_stream_decode_u64(argp->xdr, &fallocate->falloc_offset) < 0) in nfsd4_decode_fallocate()
1921 if (xdr_stream_decode_u64(argp->xdr, &fallocate->falloc_length) < 0) in nfsd4_decode_fallocate()
1933 if (xdr_stream_decode_u32(argp->xdr, &ns->nl4_type) < 0) in nfsd4_decode_nl4_server()
1936 /* currently support for 1 inter-server source server */ in nfsd4_decode_nl4_server()
1937 switch (ns->nl4_type) { in nfsd4_decode_nl4_server()
1939 naddr = &ns->u.nl4_addr; in nfsd4_decode_nl4_server()
1941 if (xdr_stream_decode_u32(argp->xdr, &naddr->netid_len) < 0) in nfsd4_decode_nl4_server()
1943 if (naddr->netid_len > RPCBIND_MAXNETIDLEN) in nfsd4_decode_nl4_server()
1946 p = xdr_inline_decode(argp->xdr, naddr->netid_len); in nfsd4_decode_nl4_server()
1949 memcpy(naddr->netid, p, naddr->netid_len); in nfsd4_decode_nl4_server()
1951 if (xdr_stream_decode_u32(argp->xdr, &naddr->addr_len) < 0) in nfsd4_decode_nl4_server()
1953 if (naddr->addr_len > RPCBIND_MAXUADDRLEN) in nfsd4_decode_nl4_server()
1956 p = xdr_inline_decode(argp->xdr, naddr->addr_len); in nfsd4_decode_nl4_server()
1959 memcpy(naddr->addr, p, naddr->addr_len); in nfsd4_decode_nl4_server()
1971 struct nfsd4_copy *copy = &u->copy; in nfsd4_decode_copy()
1977 status = nfsd4_decode_stateid4(argp, ©->cp_src_stateid); in nfsd4_decode_copy()
1980 status = nfsd4_decode_stateid4(argp, ©->cp_dst_stateid); in nfsd4_decode_copy()
1983 if (xdr_stream_decode_u64(argp->xdr, ©->cp_src_pos) < 0) in nfsd4_decode_copy()
1985 if (xdr_stream_decode_u64(argp->xdr, ©->cp_dst_pos) < 0) in nfsd4_decode_copy()
1987 if (xdr_stream_decode_u64(argp->xdr, ©->cp_count) < 0) in nfsd4_decode_copy()
1990 if (xdr_stream_decode_u32(argp->xdr, &consecutive) < 0) in nfsd4_decode_copy()
1992 if (xdr_stream_decode_bool(argp->xdr, &sync) < 0) in nfsd4_decode_copy()
1996 if (xdr_stream_decode_u32(argp->xdr, &count) < 0) in nfsd4_decode_copy()
1998 copy->cp_src = svcxdr_tmpalloc(argp, sizeof(*copy->cp_src)); in nfsd4_decode_copy()
1999 if (copy->cp_src == NULL) in nfsd4_decode_copy()
2001 if (count == 0) { /* intra-server copy */ in nfsd4_decode_copy()
2002 __set_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); in nfsd4_decode_copy()
2007 status = nfsd4_decode_nl4_server(argp, copy->cp_src); in nfsd4_decode_copy()
2014 for (i = 0; i < count - 1; i++) { in nfsd4_decode_copy()
2030 struct nfsd4_copy_notify *cn = &u->copy_notify; in nfsd4_decode_copy_notify()
2034 cn->cpn_src = svcxdr_tmpalloc(argp, sizeof(*cn->cpn_src)); in nfsd4_decode_copy_notify()
2035 if (cn->cpn_src == NULL) in nfsd4_decode_copy_notify()
2037 cn->cpn_dst = svcxdr_tmpalloc(argp, sizeof(*cn->cpn_dst)); in nfsd4_decode_copy_notify()
2038 if (cn->cpn_dst == NULL) in nfsd4_decode_copy_notify()
2041 status = nfsd4_decode_stateid4(argp, &cn->cpn_src_stateid); in nfsd4_decode_copy_notify()
2044 return nfsd4_decode_nl4_server(argp, cn->cpn_dst); in nfsd4_decode_copy_notify()
2051 struct nfsd4_offload_status *os = &u->offload_status; in nfsd4_decode_offload_status()
2052 os->count = 0; in nfsd4_decode_offload_status()
2053 os->status = 0; in nfsd4_decode_offload_status()
2054 return nfsd4_decode_stateid4(argp, &os->stateid); in nfsd4_decode_offload_status()
2060 struct nfsd4_seek *seek = &u->seek; in nfsd4_decode_seek()
2063 status = nfsd4_decode_stateid4(argp, &seek->seek_stateid); in nfsd4_decode_seek()
2066 if (xdr_stream_decode_u64(argp->xdr, &seek->seek_offset) < 0) in nfsd4_decode_seek()
2068 if (xdr_stream_decode_u32(argp->xdr, &seek->seek_whence) < 0) in nfsd4_decode_seek()
2071 seek->seek_eof = 0; in nfsd4_decode_seek()
2072 seek->seek_pos = 0; in nfsd4_decode_seek()
2079 struct nfsd4_clone *clone = &u->clone; in nfsd4_decode_clone()
2082 status = nfsd4_decode_stateid4(argp, &clone->cl_src_stateid); in nfsd4_decode_clone()
2085 status = nfsd4_decode_stateid4(argp, &clone->cl_dst_stateid); in nfsd4_decode_clone()
2088 if (xdr_stream_decode_u64(argp->xdr, &clone->cl_src_pos) < 0) in nfsd4_decode_clone()
2090 if (xdr_stream_decode_u64(argp->xdr, &clone->cl_dst_pos) < 0) in nfsd4_decode_clone()
2092 if (xdr_stream_decode_u64(argp->xdr, &clone->cl_count) < 0) in nfsd4_decode_clone()
2103 * is 64k). Since there is no kvec- or page-based interface to xattrs,
2114 struct page **pages = xdr->pages; in nfsd4_vbuf_from_vector()
2115 struct kvec *head = xdr->head; in nfsd4_vbuf_from_vector()
2119 if (buflen <= head->iov_len) { in nfsd4_vbuf_from_vector()
2124 *bufp = head->iov_base; in nfsd4_vbuf_from_vector()
2133 memcpy(dp, head->iov_base, head->iov_len); in nfsd4_vbuf_from_vector()
2134 buflen -= head->iov_len; in nfsd4_vbuf_from_vector()
2135 dp += head->iov_len; in nfsd4_vbuf_from_vector()
2141 buflen -= len; in nfsd4_vbuf_from_vector()
2162 if (xdr_stream_decode_u32(argp->xdr, &namelen) < 0) in nfsd4_decode_xattr_name()
2164 if (namelen > (XATTR_NAME_MAX - XATTR_USER_PREFIX_LEN)) in nfsd4_decode_xattr_name()
2168 p = xdr_inline_decode(argp->xdr, namelen); in nfsd4_decode_xattr_name()
2184 while (cnt-- > 0) { in nfsd4_decode_xattr_name()
2197 * A GETXATTR op request comes without a length specifier. We just set the
2206 struct nfsd4_getxattr *getxattr = &u->getxattr; in nfsd4_decode_getxattr()
2211 status = nfsd4_decode_xattr_name(argp, &getxattr->getxa_name); in nfsd4_decode_getxattr()
2215 maxcount = svc_max_payload(argp->rqstp); in nfsd4_decode_getxattr()
2218 getxattr->getxa_len = maxcount; in nfsd4_decode_getxattr()
2226 struct nfsd4_setxattr *setxattr = &u->setxattr; in nfsd4_decode_setxattr()
2232 if (xdr_stream_decode_u32(argp->xdr, &flags) < 0) in nfsd4_decode_setxattr()
2237 setxattr->setxa_flags = flags; in nfsd4_decode_setxattr()
2239 status = nfsd4_decode_xattr_name(argp, &setxattr->setxa_name); in nfsd4_decode_setxattr()
2243 maxcount = svc_max_payload(argp->rqstp); in nfsd4_decode_setxattr()
2246 if (xdr_stream_decode_u32(argp->xdr, &size) < 0) in nfsd4_decode_setxattr()
2251 setxattr->setxa_len = size; in nfsd4_decode_setxattr()
2255 if (!xdr_stream_subsegment(argp->xdr, &payload, size)) in nfsd4_decode_setxattr()
2258 &setxattr->setxa_buf, size); in nfsd4_decode_setxattr()
2268 struct nfsd4_listxattrs *listxattrs = &u->listxattrs; in nfsd4_decode_listxattrs()
2273 if (xdr_stream_decode_u64(argp->xdr, &listxattrs->lsxa_cookie) < 0) in nfsd4_decode_listxattrs()
2280 if (listxattrs->lsxa_cookie >= in nfsd4_decode_listxattrs()
2284 if (xdr_stream_decode_u32(argp->xdr, &maxcount) < 0) in nfsd4_decode_listxattrs()
2290 maxcount = min(maxcount, svc_max_payload(argp->rqstp)); in nfsd4_decode_listxattrs()
2291 listxattrs->lsxa_maxcount = maxcount; in nfsd4_decode_listxattrs()
2300 struct nfsd4_removexattr *removexattr = &u->removexattr; in nfsd4_decode_removexattr()
2302 return nfsd4_decode_xattr_name(argp, &removexattr->rmxa_name); in nfsd4_decode_removexattr()
2411 if (op->opnum < FIRST_NFS4_OP) in nfsd4_opnum_in_range()
2413 else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP) in nfsd4_opnum_in_range()
2415 else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP) in nfsd4_opnum_in_range()
2417 else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP) in nfsd4_opnum_in_range()
2427 int auth_slack= argp->rqstp->rq_auth_slack; in nfsd4_decode_compound()
2434 if (xdr_stream_decode_u32(argp->xdr, &argp->taglen) < 0) in nfsd4_decode_compound()
2437 argp->tag = NULL; in nfsd4_decode_compound()
2438 if (unlikely(argp->taglen)) { in nfsd4_decode_compound()
2439 if (argp->taglen > NFSD4_MAX_TAGLEN) in nfsd4_decode_compound()
2441 p = xdr_inline_decode(argp->xdr, argp->taglen); in nfsd4_decode_compound()
2444 argp->tag = svcxdr_savemem(argp, p, argp->taglen); in nfsd4_decode_compound()
2445 if (!argp->tag) in nfsd4_decode_compound()
2447 max_reply += xdr_align_size(argp->taglen); in nfsd4_decode_compound()
2450 if (xdr_stream_decode_u32(argp->xdr, &argp->minorversion) < 0) in nfsd4_decode_compound()
2452 if (xdr_stream_decode_u32(argp->xdr, &argp->client_opcnt) < 0) in nfsd4_decode_compound()
2454 argp->opcnt = min_t(u32, argp->client_opcnt, in nfsd4_decode_compound()
2457 if (argp->opcnt > ARRAY_SIZE(argp->iops)) { in nfsd4_decode_compound()
2458 argp->ops = vcalloc(argp->opcnt, sizeof(*argp->ops)); in nfsd4_decode_compound()
2459 if (!argp->ops) { in nfsd4_decode_compound()
2460 argp->ops = argp->iops; in nfsd4_decode_compound()
2465 if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION) in nfsd4_decode_compound()
2466 argp->opcnt = 0; in nfsd4_decode_compound()
2468 for (i = 0; i < argp->opcnt; i++) { in nfsd4_decode_compound()
2469 op = &argp->ops[i]; in nfsd4_decode_compound()
2470 op->replay = NULL; in nfsd4_decode_compound()
2471 op->opdesc = NULL; in nfsd4_decode_compound()
2473 if (xdr_stream_decode_u32(argp->xdr, &op->opnum) < 0) in nfsd4_decode_compound()
2476 op->opdesc = OPDESC(op); in nfsd4_decode_compound()
2477 op->status = nfsd4_dec_ops[op->opnum](argp, &op->u); in nfsd4_decode_compound()
2478 if (op->status != nfs_ok) in nfsd4_decode_compound()
2479 trace_nfsd_compound_decode_err(argp->rqstp, in nfsd4_decode_compound()
2480 argp->opcnt, i, in nfsd4_decode_compound()
2481 op->opnum, in nfsd4_decode_compound()
2482 op->status); in nfsd4_decode_compound()
2484 op->opnum = OP_ILLEGAL; in nfsd4_decode_compound()
2485 op->status = nfserr_op_illegal; in nfsd4_decode_compound()
2494 if (op->opnum == OP_READ || op->opnum == OP_READ_PLUS) { in nfsd4_decode_compound()
2496 readbytes += nfsd4_max_reply(argp->rqstp, op); in nfsd4_decode_compound()
2498 max_reply += nfsd4_max_reply(argp->rqstp, op); in nfsd4_decode_compound()
2505 if (op->opnum == OP_LOCK || op->opnum == OP_LOCKT) in nfsd4_decode_compound()
2508 if (op->status) { in nfsd4_decode_compound()
2509 argp->opcnt = i+1; in nfsd4_decode_compound()
2514 if (argp->minorversion) in nfsd4_decode_compound()
2516 svc_reserve(argp->rqstp, max_reply + readbytes); in nfsd4_decode_compound()
2517 argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE; in nfsd4_decode_compound()
2519 if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack) in nfsd4_decode_compound()
2520 clear_bit(RQ_SPLICE_OK, &argp->rqstp->rq_flags); in nfsd4_decode_compound()
2528 if (exp->ex_flags & NFSEXP_V4ROOT) { in encode_change()
2529 *p++ = cpu_to_be32(convert_to_wallclock(exp->cd->flush_time)); in encode_change()
2545 p = xdr_encode_hyper(p, (s64)tv->tv_sec); in nfsd4_encode_nfstime4()
2546 *p = cpu_to_be32(tv->tv_nsec); in nfsd4_encode_nfstime4()
2566 ns = max_t(u32, NSEC_PER_SEC/HZ, inode->i_sb->s_time_gran); in encode_time_delta()
2578 if (xdr_stream_encode_bool(xdr, c->atomic) < 0) in nfsd4_encode_change_info4()
2580 if (xdr_stream_encode_u64(xdr, c->before_change) < 0) in nfsd4_encode_change_info4()
2582 if (xdr_stream_encode_u64(xdr, c->after_change) < 0) in nfsd4_encode_change_info4()
2602 pathlen_offset = xdr->buf->len; in nfsd4_encode_components_esc()
2627 strlen = end - str; in nfsd4_encode_components_esc()
2643 write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4); in nfsd4_encode_components_esc()
2664 status = nfsd4_encode_components_esc(xdr, ':', location->hosts, in nfsd4_encode_fs_location4()
2668 status = nfsd4_encode_components(xdr, '/', location->path); in nfsd4_encode_fs_location4()
2696 if (cur.dentry == cur.mnt->mnt_root) { in nfsd4_encode_path()
2720 struct dentry *dentry = components[ncomponents - 1]; in nfsd4_encode_path()
2723 spin_lock(&dentry->d_lock); in nfsd4_encode_path()
2724 len = dentry->d_name.len; in nfsd4_encode_path()
2727 spin_unlock(&dentry->d_lock); in nfsd4_encode_path()
2730 p = xdr_encode_opaque(p, dentry->d_name.name, len); in nfsd4_encode_path()
2732 spin_unlock(&dentry->d_lock); in nfsd4_encode_path()
2734 ncomponents--; in nfsd4_encode_path()
2741 dput(components[--ncomponents]); in nfsd4_encode_path()
2756 res = nfsd4_encode_path(xdr, &exp_ps->ex_path, path); in nfsd4_encode_fsloc_fsroot()
2770 struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs; in nfsd4_encode_fs_locations()
2772 status = nfsd4_encode_fsloc_fsroot(xdr, rqstp, &exp->ex_path); in nfsd4_encode_fs_locations()
2778 *p++ = cpu_to_be32(fslocs->locations_count); in nfsd4_encode_fs_locations()
2779 for (i=0; i<fslocs->locations_count; i++) { in nfsd4_encode_fs_locations()
2780 status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]); in nfsd4_encode_fs_locations()
2805 if (ace->whotype != NFS4_ACL_WHO_NAMED) in nfsd4_encode_aclname()
2806 return nfs4_acl_write_who(xdr, ace->whotype); in nfsd4_encode_aclname()
2807 else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP) in nfsd4_encode_aclname()
2808 return nfsd4_encode_group(xdr, rqstp, ace->who_gid); in nfsd4_encode_aclname()
2810 return nfsd4_encode_user(xdr, rqstp, ace->who_uid); in nfsd4_encode_aclname()
2884 struct path path = exp->ex_path; in nfsd4_get_mounted_on_ino()
2890 if (path.dentry != path.mnt->mnt_root) in nfsd4_get_mounted_on_ino()
2950 int starting_len = xdr->buf->len; in nfsd4_encode_fattr()
2963 struct nfsd4_compoundres *resp = rqstp->rq_resp; in nfsd4_encode_fattr()
2964 u32 minorversion = resp->cstate.minorversion; in nfsd4_encode_fattr()
2966 .mnt = exp->ex_path.mnt, in nfsd4_encode_fattr()
2974 if (exp->ex_fslocs.migrated) { in nfsd4_encode_fattr()
3014 if (err == -EOPNOTSUPP) in nfsd4_encode_fattr()
3016 else if (err == -EINVAL) { in nfsd4_encode_fattr()
3026 if (exp->ex_flags & NFSEXP_SECURITY_LABEL) in nfsd4_encode_fattr()
3030 err = -EOPNOTSUPP; in nfsd4_encode_fattr()
3033 if (err == -EOPNOTSUPP) in nfsd4_encode_fattr()
3045 attrlen_offset = xdr->buf->len; in nfsd4_encode_fattr()
3055 if (!IS_POSIXACL(dentry->d_inode)) in nfsd4_encode_fattr()
3091 if (exp->ex_flags & NFSEXP_NOSUBTREECHECK) in nfsd4_encode_fattr()
3131 if (exp->ex_fslocs.migrated) { in nfsd4_encode_fattr()
3136 p = xdr_encode_hyper(p, (u64)exp->ex_fsid); in nfsd4_encode_fattr()
3146 p = xdr_encode_opaque_fixed(p, exp->ex_uuid, in nfsd4_encode_fattr()
3161 *p++ = cpu_to_be32(nn->nfsd4_lease); in nfsd4_encode_fattr()
3183 *p++ = cpu_to_be32(acl->naces); in nfsd4_encode_fattr()
3185 for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) { in nfsd4_encode_fattr()
3189 *p++ = cpu_to_be32(ace->type); in nfsd4_encode_fattr()
3190 *p++ = cpu_to_be32(ace->flag); in nfsd4_encode_fattr()
3191 *p++ = cpu_to_be32(ace->access_mask & in nfsd4_encode_fattr()
3203 *p++ = cpu_to_be32(IS_POSIXACL(dentry->d_inode) ? in nfsd4_encode_fattr()
3231 p = xdr_reserve_space(xdr, fhp->fh_handle.fh_size + 4); in nfsd4_encode_fattr()
3234 p = xdr_encode_opaque(p, &fhp->fh_handle.fh_raw, in nfsd4_encode_fattr()
3235 fhp->fh_handle.fh_size); in nfsd4_encode_fattr()
3276 p = xdr_encode_hyper(p, exp->ex_path.mnt->mnt_sb->s_maxbytes); in nfsd4_encode_fattr()
3399 * crossmount and this is the root of a cross-mounted in nfsd4_encode_fattr()
3403 dentry == exp->ex_path.mnt->mnt_root) { in nfsd4_encode_fattr()
3412 status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types); in nfsd4_encode_fattr()
3418 status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types); in nfsd4_encode_fattr()
3460 *attrlen_p = cpu_to_be32(xdr->buf->len - attrlen_offset - XDR_UNIT); in nfsd4_encode_fattr()
3487 xdr->scratch.iov_len = 0; in svcxdr_init_encode_from_buffer()
3489 buf->head[0].iov_base = p; in svcxdr_init_encode_from_buffer()
3490 buf->head[0].iov_len = 0; in svcxdr_init_encode_from_buffer()
3491 buf->len = 0; in svcxdr_init_encode_from_buffer()
3492 xdr->buf = buf; in svcxdr_init_encode_from_buffer()
3493 xdr->iov = buf->head; in svcxdr_init_encode_from_buffer()
3494 xdr->p = p; in svcxdr_init_encode_from_buffer()
3495 xdr->end = (void *)p + bytes; in svcxdr_init_encode_from_buffer()
3496 buf->buflen = bytes; in svcxdr_init_encode_from_buffer()
3528 struct svc_export *exp = cd->rd_fhp->fh_export; in nfsd4_encode_dirent_fattr()
3533 dentry = lookup_positive_unlocked(name, cd->rd_fhp->fh_dentry, namlen); in nfsd4_encode_dirent_fattr()
3541 * as opposed to the cross-mounted file system. In such a case, in nfsd4_encode_dirent_fattr()
3548 if (!(exp->ex_flags & NFSEXP_V4ROOT) in nfsd4_encode_dirent_fattr()
3549 && !attributes_need_mount(cd->rd_bmval)) { in nfsd4_encode_dirent_fattr()
3558 err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp); in nfsd4_encode_dirent_fattr()
3563 nfserr = check_nfsd_access(exp, cd->rd_rqstp); in nfsd4_encode_dirent_fattr()
3569 nfserr = nfsd4_encode_fattr(xdr, NULL, exp, dentry, cd->rd_bmval, in nfsd4_encode_dirent_fattr()
3570 cd->rd_rqstp, ignore_crossmnt); in nfsd4_encode_dirent_fattr()
3600 struct xdr_stream *xdr = cd->xdr; in nfsd4_encode_dirent()
3601 int start_offset = xdr->buf->len; in nfsd4_encode_dirent()
3611 cd->common.err = nfs_ok; in nfsd4_encode_dirent()
3615 if (cd->cookie_offset) { in nfsd4_encode_dirent()
3617 write_bytes_to_xdr_buf(xdr->buf, cd->cookie_offset, in nfsd4_encode_dirent()
3625 cookie_offset = xdr->buf->len; in nfsd4_encode_dirent()
3650 if (cd->rd_fhp->fh_export->ex_flags & NFSEXP_V4ROOT) in nfsd4_encode_dirent()
3661 if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)) in nfsd4_encode_dirent()
3670 entry_bytes = xdr->buf->len - start_offset; in nfsd4_encode_dirent()
3671 if (entry_bytes > cd->rd_maxcount) in nfsd4_encode_dirent()
3673 cd->rd_maxcount -= entry_bytes; in nfsd4_encode_dirent()
3679 if (cd->rd_dircount) { in nfsd4_encode_dirent()
3681 if (name_and_cookie > cd->rd_dircount && cd->cookie_offset) in nfsd4_encode_dirent()
3683 cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie); in nfsd4_encode_dirent()
3684 if (!cd->rd_dircount) in nfsd4_encode_dirent()
3685 cd->rd_maxcount = 0; in nfsd4_encode_dirent()
3688 cd->cookie_offset = cookie_offset; in nfsd4_encode_dirent()
3690 cd->common.err = nfs_ok; in nfsd4_encode_dirent()
3694 cd->common.err = nfserr; in nfsd4_encode_dirent()
3695 return -EINVAL; in nfsd4_encode_dirent()
3706 memcpy(p, verf->data, sizeof(verf->data)); in nfsd4_encode_verifier4()
3730 *p++ = cpu_to_be32(sid->si_generation); in nfsd4_encode_stateid()
3731 p = xdr_encode_opaque_fixed(p, &sid->si_opaque, in nfsd4_encode_stateid()
3740 struct nfsd4_access *access = &u->access; in nfsd4_encode_access()
3741 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_access()
3747 *p++ = cpu_to_be32(access->ac_supported); in nfsd4_encode_access()
3748 *p++ = cpu_to_be32(access->ac_resp_access); in nfsd4_encode_access()
3755 struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session; in nfsd4_encode_bind_conn_to_session()
3756 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_bind_conn_to_session()
3762 p = xdr_encode_opaque_fixed(p, bcts->sessionid.data, in nfsd4_encode_bind_conn_to_session()
3764 *p++ = cpu_to_be32(bcts->dir); in nfsd4_encode_bind_conn_to_session()
3774 struct nfsd4_close *close = &u->close; in nfsd4_encode_close()
3775 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_close()
3777 return nfsd4_encode_stateid(xdr, &close->cl_stateid); in nfsd4_encode_close()
3785 struct nfsd4_commit *commit = &u->commit; in nfsd4_encode_commit()
3787 return nfsd4_encode_verifier4(resp->xdr, &commit->co_verf); in nfsd4_encode_commit()
3794 struct nfsd4_create *create = &u->create; in nfsd4_encode_create()
3795 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_create()
3797 nfserr = nfsd4_encode_change_info4(xdr, &create->cr_cinfo); in nfsd4_encode_create()
3800 return nfsd4_encode_bitmap(xdr, create->cr_bmval[0], in nfsd4_encode_create()
3801 create->cr_bmval[1], create->cr_bmval[2]); in nfsd4_encode_create()
3808 struct nfsd4_getattr *getattr = &u->getattr; in nfsd4_encode_getattr()
3809 struct svc_fh *fhp = getattr->ga_fhp; in nfsd4_encode_getattr()
3810 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_getattr()
3812 return nfsd4_encode_fattr(xdr, fhp, fhp->fh_export, fhp->fh_dentry, in nfsd4_encode_getattr()
3813 getattr->ga_bmval, resp->rqstp, 0); in nfsd4_encode_getattr()
3820 struct svc_fh **fhpp = &u->getfh; in nfsd4_encode_getfh()
3821 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_getfh()
3826 len = fhp->fh_handle.fh_size; in nfsd4_encode_getfh()
3830 p = xdr_encode_opaque(p, &fhp->fh_handle.fh_raw, len); in nfsd4_encode_getfh()
3841 struct xdr_netobj *conf = &ld->ld_owner; in nfsd4_encode_lock_denied()
3845 p = xdr_reserve_space(xdr, 32 + XDR_LEN(conf->len)); in nfsd4_encode_lock_denied()
3851 if (conf->len) { in nfsd4_encode_lock_denied()
3852 kfree(conf->data); in nfsd4_encode_lock_denied()
3853 conf->len = 0; in nfsd4_encode_lock_denied()
3854 conf->data = NULL; in nfsd4_encode_lock_denied()
3859 p = xdr_encode_hyper(p, ld->ld_start); in nfsd4_encode_lock_denied()
3860 p = xdr_encode_hyper(p, ld->ld_length); in nfsd4_encode_lock_denied()
3861 *p++ = cpu_to_be32(ld->ld_type); in nfsd4_encode_lock_denied()
3862 if (conf->len) { in nfsd4_encode_lock_denied()
3863 p = xdr_encode_opaque_fixed(p, &ld->ld_clientid, 8); in nfsd4_encode_lock_denied()
3864 p = xdr_encode_opaque(p, conf->data, conf->len); in nfsd4_encode_lock_denied()
3865 kfree(conf->data); in nfsd4_encode_lock_denied()
3866 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */ in nfsd4_encode_lock_denied()
3877 struct nfsd4_lock *lock = &u->lock; in nfsd4_encode_lock()
3878 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_lock()
3881 nfserr = nfsd4_encode_stateid(xdr, &lock->lk_resp_stateid); in nfsd4_encode_lock()
3883 nfserr = nfsd4_encode_lock_denied(xdr, &lock->lk_denied); in nfsd4_encode_lock()
3892 struct nfsd4_lockt *lockt = &u->lockt; in nfsd4_encode_lockt()
3893 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_lockt()
3896 nfsd4_encode_lock_denied(xdr, &lockt->lt_denied); in nfsd4_encode_lockt()
3904 struct nfsd4_locku *locku = &u->locku; in nfsd4_encode_locku()
3905 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_locku()
3907 return nfsd4_encode_stateid(xdr, &locku->lu_stateid); in nfsd4_encode_locku()
3915 struct nfsd4_link *link = &u->link; in nfsd4_encode_link()
3916 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_link()
3918 return nfsd4_encode_change_info4(xdr, &link->li_cinfo); in nfsd4_encode_link()
3926 struct nfsd4_open *open = &u->open; in nfsd4_encode_open()
3927 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_open()
3930 nfserr = nfsd4_encode_stateid(xdr, &open->op_stateid); in nfsd4_encode_open()
3933 nfserr = nfsd4_encode_change_info4(xdr, &open->op_cinfo); in nfsd4_encode_open()
3936 if (xdr_stream_encode_u32(xdr, open->op_rflags) < 0) in nfsd4_encode_open()
3939 nfserr = nfsd4_encode_bitmap(xdr, open->op_bmval[0], open->op_bmval[1], in nfsd4_encode_open()
3940 open->op_bmval[2]); in nfsd4_encode_open()
3948 *p++ = cpu_to_be32(open->op_delegate_type); in nfsd4_encode_open()
3949 switch (open->op_delegate_type) { in nfsd4_encode_open()
3953 nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid); in nfsd4_encode_open()
3959 *p++ = cpu_to_be32(open->op_recall); in nfsd4_encode_open()
3970 nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid); in nfsd4_encode_open()
3977 *p++ = cpu_to_be32(open->op_recall); in nfsd4_encode_open()
3997 switch (open->op_why_no_deleg) { in nfsd4_encode_open()
4003 *p++ = cpu_to_be32(open->op_why_no_deleg); in nfsd4_encode_open()
4011 *p++ = cpu_to_be32(open->op_why_no_deleg); in nfsd4_encode_open()
4025 struct nfsd4_open_confirm *oc = &u->open_confirm; in nfsd4_encode_open_confirm()
4026 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_open_confirm()
4028 return nfsd4_encode_stateid(xdr, &oc->oc_resp_stateid); in nfsd4_encode_open_confirm()
4035 struct nfsd4_open_downgrade *od = &u->open_downgrade; in nfsd4_encode_open_downgrade()
4036 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_open_downgrade()
4038 return nfsd4_encode_stateid(xdr, &od->od_stateid); in nfsd4_encode_open_downgrade()
4051 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_splice_read()
4052 struct xdr_buf *buf = xdr->buf; in nfsd4_encode_splice_read()
4057 * Make sure there is room at the end of buf->head for in nfsd4_encode_splice_read()
4059 * to XDR-pad the payload. in nfsd4_encode_splice_read()
4061 if (xdr->iov != xdr->buf->head || xdr->end - xdr->p < 1) in nfsd4_encode_splice_read()
4064 nfserr = nfsd_splice_read(read->rd_rqstp, read->rd_fhp, in nfsd4_encode_splice_read()
4065 file, read->rd_offset, &maxcount, in nfsd4_encode_splice_read()
4066 &read->rd_eof); in nfsd4_encode_splice_read()
4067 read->rd_length = maxcount; in nfsd4_encode_splice_read()
4070 svcxdr_encode_opaque_pages(read->rd_rqstp, xdr, buf->pages, in nfsd4_encode_splice_read()
4071 buf->page_base, maxcount); in nfsd4_encode_splice_read()
4072 status = svc_encode_result_payload(read->rd_rqstp, in nfsd4_encode_splice_read()
4073 buf->head[0].iov_len, maxcount); in nfsd4_encode_splice_read()
4084 * manipulations are open-coded. in nfsd4_encode_splice_read()
4086 space_left = min_t(int, (void *)xdr->end - (void *)xdr->p, in nfsd4_encode_splice_read()
4087 buf->buflen - buf->len); in nfsd4_encode_splice_read()
4088 buf->buflen = buf->len + space_left; in nfsd4_encode_splice_read()
4089 xdr->end = (__be32 *)((void *)xdr->end + space_left); in nfsd4_encode_splice_read()
4099 buf->page_len = 0; in nfsd4_encode_splice_read()
4107 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_readv()
4108 unsigned int base = xdr->buf->page_len & ~PAGE_MASK; in nfsd4_encode_readv()
4109 unsigned int starting_len = xdr->buf->len; in nfsd4_encode_readv()
4116 nfserr = nfsd_iter_read(resp->rqstp, read->rd_fhp, file, in nfsd4_encode_readv()
4117 read->rd_offset, &maxcount, base, in nfsd4_encode_readv()
4118 &read->rd_eof); in nfsd4_encode_readv()
4119 read->rd_length = maxcount; in nfsd4_encode_readv()
4122 if (svc_encode_result_payload(resp->rqstp, starting_len, maxcount)) in nfsd4_encode_readv()
4126 write_bytes_to_xdr_buf(xdr->buf, starting_len + maxcount, &zero, in nfsd4_encode_readv()
4135 struct nfsd4_read *read = &u->read; in nfsd4_encode_read()
4136 bool splice_ok = test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags); in nfsd4_encode_read()
4138 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_read()
4140 int starting_len = xdr->buf->len; in nfsd4_encode_read()
4145 file = read->rd_nf->nf_file; in nfsd4_encode_read()
4152 if (resp->xdr->buf->page_len && splice_ok) { in nfsd4_encode_read()
4158 maxcount = min_t(unsigned long, read->rd_length, in nfsd4_encode_read()
4159 (xdr->buf->buflen - xdr->buf->len)); in nfsd4_encode_read()
4161 if (file->f_op->splice_read && splice_ok) in nfsd4_encode_read()
4170 p = xdr_encode_bool(p, read->rd_eof); in nfsd4_encode_read()
4171 *p = cpu_to_be32(read->rd_length); in nfsd4_encode_read()
4179 struct nfsd4_readlink *readlink = &u->readlink; in nfsd4_encode_readlink()
4181 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_readlink()
4182 int length_offset = xdr->buf->len; in nfsd4_encode_readlink()
4199 nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp, in nfsd4_encode_readlink()
4205 status = svc_encode_result_payload(readlink->rl_rqstp, length_offset, in nfsd4_encode_readlink()
4213 write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount, &zero, in nfsd4_encode_readlink()
4226 struct nfsd4_readdir *readdir = &u->readdir; in nfsd4_encode_readdir()
4231 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_readdir()
4232 int starting_len = xdr->buf->len; in nfsd4_encode_readdir()
4235 nfserr = nfsd4_encode_verifier4(xdr, &readdir->rd_verf); in nfsd4_encode_readdir()
4243 bytes_left = xdr->buf->buflen - xdr->buf->len in nfsd4_encode_readdir()
4244 - COMPOUND_ERR_SLACK_SPACE - 8; in nfsd4_encode_readdir()
4249 maxcount = svc_max_payload(resp->rqstp); in nfsd4_encode_readdir()
4250 maxcount = min_t(u32, readdir->rd_maxcount, maxcount); in nfsd4_encode_readdir()
4260 maxcount = min_t(int, maxcount-16, bytes_left); in nfsd4_encode_readdir()
4263 if (!readdir->rd_dircount) in nfsd4_encode_readdir()
4264 readdir->rd_dircount = svc_max_payload(resp->rqstp); in nfsd4_encode_readdir()
4266 readdir->xdr = xdr; in nfsd4_encode_readdir()
4267 readdir->rd_maxcount = maxcount; in nfsd4_encode_readdir()
4268 readdir->common.err = 0; in nfsd4_encode_readdir()
4269 readdir->cookie_offset = 0; in nfsd4_encode_readdir()
4271 offset = readdir->rd_cookie; in nfsd4_encode_readdir()
4272 nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp, in nfsd4_encode_readdir()
4274 &readdir->common, nfsd4_encode_dirent); in nfsd4_encode_readdir()
4276 readdir->common.err == nfserr_toosmall && in nfsd4_encode_readdir()
4277 xdr->buf->len == starting_len + 8) { in nfsd4_encode_readdir()
4279 if (maxcount - 16 < bytes_left) in nfsd4_encode_readdir()
4289 if (readdir->cookie_offset) { in nfsd4_encode_readdir()
4291 write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset, in nfsd4_encode_readdir()
4301 *p++ = htonl(readdir->common.err == nfserr_eof); in nfsd4_encode_readdir()
4313 struct nfsd4_remove *remove = &u->remove; in nfsd4_encode_remove()
4314 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_remove()
4316 return nfsd4_encode_change_info4(xdr, &remove->rm_cinfo); in nfsd4_encode_remove()
4323 struct nfsd4_rename *rename = &u->rename; in nfsd4_encode_rename()
4324 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_rename()
4326 nfserr = nfsd4_encode_change_info4(xdr, &rename->rn_sinfo); in nfsd4_encode_rename()
4329 return nfsd4_encode_change_info4(xdr, &rename->rn_tinfo); in nfsd4_encode_rename()
4341 if (exp->ex_nflavors) { in nfsd4_do_encode_secinfo()
4342 flavs = exp->ex_flavors; in nfsd4_do_encode_secinfo()
4343 nflavs = exp->ex_nflavors; in nfsd4_do_encode_secinfo()
4346 if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) { in nfsd4_do_encode_secinfo()
4350 } else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) { in nfsd4_do_encode_secinfo()
4353 = svcauth_gss_flavor(exp->ex_client); in nfsd4_do_encode_secinfo()
4357 = exp->ex_client->flavour->flavour; in nfsd4_do_encode_secinfo()
4404 struct nfsd4_secinfo *secinfo = &u->secinfo; in nfsd4_encode_secinfo()
4405 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_secinfo()
4407 return nfsd4_do_encode_secinfo(xdr, secinfo->si_exp); in nfsd4_encode_secinfo()
4414 struct nfsd4_secinfo_no_name *secinfo = &u->secinfo_no_name; in nfsd4_encode_secinfo_no_name()
4415 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_secinfo_no_name()
4417 return nfsd4_do_encode_secinfo(xdr, secinfo->sin_exp); in nfsd4_encode_secinfo_no_name()
4421 * The SETATTR encode routine is special -- it always encodes a bitmap,
4428 struct nfsd4_setattr *setattr = &u->setattr; in nfsd4_encode_setattr()
4429 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_setattr()
4443 *p++ = cpu_to_be32(setattr->sa_bmval[0]); in nfsd4_encode_setattr()
4444 *p++ = cpu_to_be32(setattr->sa_bmval[1]); in nfsd4_encode_setattr()
4445 *p++ = cpu_to_be32(setattr->sa_bmval[2]); in nfsd4_encode_setattr()
4454 struct nfsd4_setclientid *scd = &u->setclientid; in nfsd4_encode_setclientid()
4455 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_setclientid()
4458 nfserr = nfsd4_encode_clientid4(xdr, &scd->se_clientid); in nfsd4_encode_setclientid()
4461 nfserr = nfsd4_encode_verifier4(xdr, &scd->se_confirm); in nfsd4_encode_setclientid()
4482 struct nfsd4_write *write = &u->write; in nfsd4_encode_write()
4484 if (xdr_stream_encode_u32(resp->xdr, write->wr_bytes_written) < 0) in nfsd4_encode_write()
4486 if (xdr_stream_encode_u32(resp->xdr, write->wr_how_written) < 0) in nfsd4_encode_write()
4488 return nfsd4_encode_verifier4(resp->xdr, &write->wr_verifier); in nfsd4_encode_write()
4495 struct nfsd4_exchange_id *exid = &u->exchange_id; in nfsd4_encode_exchange_id()
4496 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_exchange_id()
4503 struct nfsd_net *nn = net_generic(SVC_NET(resp->rqstp), nfsd_net_id); in nfsd4_encode_exchange_id()
4505 major_id = nn->nfsd_name; in nfsd4_encode_exchange_id()
4506 major_id_sz = strlen(nn->nfsd_name); in nfsd4_encode_exchange_id()
4507 server_scope = nn->nfsd_name; in nfsd4_encode_exchange_id()
4508 server_scope_sz = strlen(nn->nfsd_name); in nfsd4_encode_exchange_id()
4510 if (nfsd4_encode_clientid4(xdr, &exid->clientid) != nfs_ok) in nfsd4_encode_exchange_id()
4512 if (xdr_stream_encode_u32(xdr, exid->seqid) < 0) in nfsd4_encode_exchange_id()
4514 if (xdr_stream_encode_u32(xdr, exid->flags) < 0) in nfsd4_encode_exchange_id()
4517 if (xdr_stream_encode_u32(xdr, exid->spa_how) < 0) in nfsd4_encode_exchange_id()
4519 switch (exid->spa_how) { in nfsd4_encode_exchange_id()
4525 exid->spo_must_enforce[0], in nfsd4_encode_exchange_id()
4526 exid->spo_must_enforce[1], in nfsd4_encode_exchange_id()
4527 exid->spo_must_enforce[2]); in nfsd4_encode_exchange_id()
4532 exid->spo_must_allow[0], in nfsd4_encode_exchange_id()
4533 exid->spo_must_allow[1], in nfsd4_encode_exchange_id()
4534 exid->spo_must_allow[2]); in nfsd4_encode_exchange_id()
4569 struct nfsd4_create_session *sess = &u->create_session; in nfsd4_encode_create_session()
4570 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_create_session()
4576 p = xdr_encode_opaque_fixed(p, sess->sessionid.data, in nfsd4_encode_create_session()
4578 *p++ = cpu_to_be32(sess->seqid); in nfsd4_encode_create_session()
4579 *p++ = cpu_to_be32(sess->flags); in nfsd4_encode_create_session()
4585 *p++ = cpu_to_be32(sess->fore_channel.maxreq_sz); in nfsd4_encode_create_session()
4586 *p++ = cpu_to_be32(sess->fore_channel.maxresp_sz); in nfsd4_encode_create_session()
4587 *p++ = cpu_to_be32(sess->fore_channel.maxresp_cached); in nfsd4_encode_create_session()
4588 *p++ = cpu_to_be32(sess->fore_channel.maxops); in nfsd4_encode_create_session()
4589 *p++ = cpu_to_be32(sess->fore_channel.maxreqs); in nfsd4_encode_create_session()
4590 *p++ = cpu_to_be32(sess->fore_channel.nr_rdma_attrs); in nfsd4_encode_create_session()
4592 if (sess->fore_channel.nr_rdma_attrs) { in nfsd4_encode_create_session()
4596 *p++ = cpu_to_be32(sess->fore_channel.rdma_attrs); in nfsd4_encode_create_session()
4603 *p++ = cpu_to_be32(sess->back_channel.maxreq_sz); in nfsd4_encode_create_session()
4604 *p++ = cpu_to_be32(sess->back_channel.maxresp_sz); in nfsd4_encode_create_session()
4605 *p++ = cpu_to_be32(sess->back_channel.maxresp_cached); in nfsd4_encode_create_session()
4606 *p++ = cpu_to_be32(sess->back_channel.maxops); in nfsd4_encode_create_session()
4607 *p++ = cpu_to_be32(sess->back_channel.maxreqs); in nfsd4_encode_create_session()
4608 *p++ = cpu_to_be32(sess->back_channel.nr_rdma_attrs); in nfsd4_encode_create_session()
4610 if (sess->back_channel.nr_rdma_attrs) { in nfsd4_encode_create_session()
4614 *p++ = cpu_to_be32(sess->back_channel.rdma_attrs); in nfsd4_encode_create_session()
4623 struct nfsd4_sequence *seq = &u->sequence; in nfsd4_encode_sequence()
4624 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_sequence()
4630 p = xdr_encode_opaque_fixed(p, seq->sessionid.data, in nfsd4_encode_sequence()
4632 *p++ = cpu_to_be32(seq->seqid); in nfsd4_encode_sequence()
4633 *p++ = cpu_to_be32(seq->slotid); in nfsd4_encode_sequence()
4635 *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_highest_slotid */ in nfsd4_encode_sequence()
4636 *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_target_highest_slotid */ in nfsd4_encode_sequence()
4637 *p++ = cpu_to_be32(seq->status_flags); in nfsd4_encode_sequence()
4639 resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */ in nfsd4_encode_sequence()
4647 struct nfsd4_test_stateid *test_stateid = &u->test_stateid; in nfsd4_encode_test_stateid()
4648 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_test_stateid()
4652 p = xdr_reserve_space(xdr, 4 + (4 * test_stateid->ts_num_ids)); in nfsd4_encode_test_stateid()
4655 *p++ = htonl(test_stateid->ts_num_ids); in nfsd4_encode_test_stateid()
4657 list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) { in nfsd4_encode_test_stateid()
4658 *p++ = stateid->ts_id_status; in nfsd4_encode_test_stateid()
4669 struct nfsd4_getdeviceinfo *gdev = &u->getdeviceinfo; in nfsd4_encode_getdeviceinfo()
4670 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_getdeviceinfo()
4672 u32 starting_len = xdr->buf->len, needed_len; in nfsd4_encode_getdeviceinfo()
4679 *p++ = cpu_to_be32(gdev->gd_layout_type); in nfsd4_encode_getdeviceinfo()
4681 ops = nfsd4_layout_ops[gdev->gd_layout_type]; in nfsd4_encode_getdeviceinfo()
4682 nfserr = ops->encode_getdeviceinfo(xdr, gdev); in nfsd4_encode_getdeviceinfo()
4689 if (xdr->buf->len + 4 > gdev->gd_maxcount) in nfsd4_encode_getdeviceinfo()
4694 if (gdev->gd_notify_types) { in nfsd4_encode_getdeviceinfo()
4699 *p++ = cpu_to_be32(gdev->gd_notify_types); in nfsd4_encode_getdeviceinfo()
4710 needed_len = xdr->buf->len + 4 /* notifications */; in nfsd4_encode_getdeviceinfo()
4723 struct nfsd4_layoutget *lgp = &u->layoutget; in nfsd4_encode_layoutget()
4724 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_layoutget()
4732 *p++ = cpu_to_be32(1); /* we always set return-on-close */ in nfsd4_encode_layoutget()
4733 *p++ = cpu_to_be32(lgp->lg_sid.si_generation); in nfsd4_encode_layoutget()
4734 p = xdr_encode_opaque_fixed(p, &lgp->lg_sid.si_opaque, in nfsd4_encode_layoutget()
4738 p = xdr_encode_hyper(p, lgp->lg_seg.offset); in nfsd4_encode_layoutget()
4739 p = xdr_encode_hyper(p, lgp->lg_seg.length); in nfsd4_encode_layoutget()
4740 *p++ = cpu_to_be32(lgp->lg_seg.iomode); in nfsd4_encode_layoutget()
4741 *p++ = cpu_to_be32(lgp->lg_layout_type); in nfsd4_encode_layoutget()
4743 ops = nfsd4_layout_ops[lgp->lg_layout_type]; in nfsd4_encode_layoutget()
4744 return ops->encode_layoutget(xdr, lgp); in nfsd4_encode_layoutget()
4751 struct nfsd4_layoutcommit *lcp = &u->layoutcommit; in nfsd4_encode_layoutcommit()
4752 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_layoutcommit()
4758 *p++ = cpu_to_be32(lcp->lc_size_chg); in nfsd4_encode_layoutcommit()
4759 if (lcp->lc_size_chg) { in nfsd4_encode_layoutcommit()
4763 p = xdr_encode_hyper(p, lcp->lc_newsize); in nfsd4_encode_layoutcommit()
4773 struct nfsd4_layoutreturn *lrp = &u->layoutreturn; in nfsd4_encode_layoutreturn()
4774 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_layoutreturn()
4780 *p++ = cpu_to_be32(lrp->lrs_present); in nfsd4_encode_layoutreturn()
4781 if (lrp->lrs_present) in nfsd4_encode_layoutreturn()
4782 return nfsd4_encode_stateid(xdr, &lrp->lr_sid); in nfsd4_encode_layoutreturn()
4792 p = xdr_reserve_space(resp->xdr, 4); in nfsd42_encode_write_res()
4801 nfserr = nfsd4_encode_stateid(resp->xdr, &write->cb_stateid); in nfsd42_encode_write_res()
4805 p = xdr_reserve_space(resp->xdr, 8 + 4 + NFS4_VERIFIER_SIZE); in nfsd42_encode_write_res()
4809 p = xdr_encode_hyper(p, write->wr_bytes_written); in nfsd42_encode_write_res()
4810 *p++ = cpu_to_be32(write->wr_stable_how); in nfsd42_encode_write_res()
4811 p = xdr_encode_opaque_fixed(p, write->wr_verifier.data, in nfsd42_encode_write_res()
4819 struct xdr_stream *xdr = resp->xdr; in nfsd42_encode_nl4_server()
4824 *p++ = cpu_to_be32(ns->nl4_type); in nfsd42_encode_nl4_server()
4826 switch (ns->nl4_type) { in nfsd42_encode_nl4_server()
4828 addr = &ns->u.nl4_addr; in nfsd42_encode_nl4_server()
4835 (XDR_QUADLEN(addr->netid_len) * 4) + in nfsd42_encode_nl4_server()
4837 (XDR_QUADLEN(addr->addr_len) * 4)); in nfsd42_encode_nl4_server()
4841 *p++ = cpu_to_be32(addr->netid_len); in nfsd42_encode_nl4_server()
4842 p = xdr_encode_opaque_fixed(p, addr->netid, in nfsd42_encode_nl4_server()
4843 addr->netid_len); in nfsd42_encode_nl4_server()
4844 *p++ = cpu_to_be32(addr->addr_len); in nfsd42_encode_nl4_server()
4845 p = xdr_encode_opaque_fixed(p, addr->addr, in nfsd42_encode_nl4_server()
4846 addr->addr_len); in nfsd42_encode_nl4_server()
4849 WARN_ON_ONCE(ns->nl4_type != NL4_NETADDR); in nfsd42_encode_nl4_server()
4860 struct nfsd4_copy *copy = &u->copy; in nfsd4_encode_copy()
4863 nfserr = nfsd42_encode_write_res(resp, ©->cp_res, in nfsd4_encode_copy()
4868 p = xdr_reserve_space(resp->xdr, 4 + 4); in nfsd4_encode_copy()
4878 struct nfsd4_offload_status *os = &u->offload_status; in nfsd4_encode_offload_status()
4879 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_offload_status()
4885 p = xdr_encode_hyper(p, os->count); in nfsd4_encode_offload_status()
4894 bool splice_ok = test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags); in nfsd4_encode_read_plus_data()
4895 struct file *file = read->rd_nf->nf_file; in nfsd4_encode_read_plus_data()
4896 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_read_plus_data()
4904 if (resp->xdr->buf->page_len && splice_ok) { in nfsd4_encode_read_plus_data()
4909 maxcount = min_t(unsigned long, read->rd_length, in nfsd4_encode_read_plus_data()
4910 (xdr->buf->buflen - xdr->buf->len)); in nfsd4_encode_read_plus_data()
4912 if (file->f_op->splice_read && splice_ok) in nfsd4_encode_read_plus_data()
4920 p = xdr_encode_hyper(p, read->rd_offset); in nfsd4_encode_read_plus_data()
4921 *p = cpu_to_be32(read->rd_length); in nfsd4_encode_read_plus_data()
4930 struct nfsd4_read *read = &u->read; in nfsd4_encode_read_plus()
4931 struct file *file = read->rd_nf->nf_file; in nfsd4_encode_read_plus()
4932 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_read_plus()
4933 int starting_len = xdr->buf->len; in nfsd4_encode_read_plus()
4946 read->rd_eof = read->rd_offset >= i_size_read(file_inode(file)); in nfsd4_encode_read_plus()
4947 if (read->rd_eof) in nfsd4_encode_read_plus()
4959 p = xdr_encode_bool(p, read->rd_eof); in nfsd4_encode_read_plus()
4968 struct nfsd4_copy_notify *cn = &u->copy_notify; in nfsd4_encode_copy_notify()
4969 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_copy_notify()
4981 p = xdr_encode_hyper(p, cn->cpn_sec); in nfsd4_encode_copy_notify()
4982 *p++ = cpu_to_be32(cn->cpn_nsec); in nfsd4_encode_copy_notify()
4985 nfserr = nfsd4_encode_stateid(xdr, &cn->cpn_cnr_stateid); in nfsd4_encode_copy_notify()
4996 nfserr = nfsd42_encode_nl4_server(resp, cn->cpn_src); in nfsd4_encode_copy_notify()
5004 struct nfsd4_seek *seek = &u->seek; in nfsd4_encode_seek()
5007 p = xdr_reserve_space(resp->xdr, 4 + 8); in nfsd4_encode_seek()
5008 *p++ = cpu_to_be32(seek->seek_eof); in nfsd4_encode_seek()
5009 p = xdr_encode_hyper(p, seek->seek_pos); in nfsd4_encode_seek()
5022 * Encode kmalloc-ed buffer in to XDR stream.
5031 ((void *)xdr->end - (void *)xdr->p)); in nfsd4_vbuf_to_stream()
5038 buflen -= cplen; in nfsd4_vbuf_to_stream()
5058 buflen -= PAGE_SIZE; in nfsd4_vbuf_to_stream()
5069 struct nfsd4_getxattr *getxattr = &u->getxattr; in nfsd4_encode_getxattr()
5070 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_getxattr()
5077 *p = cpu_to_be32(getxattr->getxa_len); in nfsd4_encode_getxattr()
5079 if (getxattr->getxa_len == 0) in nfsd4_encode_getxattr()
5082 err = nfsd4_vbuf_to_stream(xdr, getxattr->getxa_buf, in nfsd4_encode_getxattr()
5083 getxattr->getxa_len); in nfsd4_encode_getxattr()
5085 kvfree(getxattr->getxa_buf); in nfsd4_encode_getxattr()
5094 struct nfsd4_setxattr *setxattr = &u->setxattr; in nfsd4_encode_setxattr()
5095 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_setxattr()
5097 return nfsd4_encode_change_info4(xdr, &setxattr->setxa_cinfo); in nfsd4_encode_setxattr()
5107 u64 cookie = listxattrs->lsxa_cookie; in nfsd4_listxattr_validate_cookie()
5112 * XDR-encoded, in the return buffer, it's invalid. in nfsd4_listxattr_validate_cookie()
5114 if (cookie > (listxattrs->lsxa_len) / (XATTR_USER_PREFIX_LEN + 2)) in nfsd4_listxattr_validate_cookie()
5117 if (cookie > (listxattrs->lsxa_maxcount / in nfsd4_listxattr_validate_cookie()
5129 struct nfsd4_listxattrs *listxattrs = &u->listxattrs; in nfsd4_encode_listxattrs()
5130 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_listxattrs()
5150 cookie_offset = xdr->buf->len; in nfsd4_encode_listxattrs()
5159 left = listxattrs->lsxa_len; in nfsd4_encode_listxattrs()
5160 sp = listxattrs->lsxa_buf; in nfsd4_encode_listxattrs()
5163 xdrleft = listxattrs->lsxa_maxcount; in nfsd4_encode_listxattrs()
5174 slen -= XATTR_USER_PREFIX_LEN; in nfsd4_encode_listxattrs()
5188 left -= XATTR_USER_PREFIX_LEN; in nfsd4_encode_listxattrs()
5202 xdrleft -= xdrlen; in nfsd4_encode_listxattrs()
5206 left -= slen + 1; in nfsd4_encode_listxattrs()
5228 write_bytes_to_xdr_buf(xdr->buf, cookie_offset, &cookie, 8); in nfsd4_encode_listxattrs()
5230 write_bytes_to_xdr_buf(xdr->buf, count_offset, &tmp, 4); in nfsd4_encode_listxattrs()
5232 if (listxattrs->lsxa_len) in nfsd4_encode_listxattrs()
5233 kvfree(listxattrs->lsxa_buf); in nfsd4_encode_listxattrs()
5241 struct nfsd4_removexattr *removexattr = &u->removexattr; in nfsd4_encode_removexattr()
5242 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_removexattr()
5244 return nfsd4_encode_change_info4(xdr, &removexattr->rmxa_cinfo); in nfsd4_encode_removexattr()
5347 * - For NFS versions >=4.1, the size of the reply must stay within
5349 * - For all NFS versions, we must stay within limited preallocated
5359 struct xdr_buf *buf = &resp->rqstp->rq_res; in nfsd4_check_resp_size()
5360 struct nfsd4_slot *slot = resp->cstate.slot; in nfsd4_check_resp_size()
5362 if (buf->len + respsize <= buf->buflen) in nfsd4_check_resp_size()
5364 if (!nfsd4_has_session(&resp->cstate)) in nfsd4_check_resp_size()
5366 if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) { in nfsd4_check_resp_size()
5376 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_operation()
5377 struct nfs4_stateowner *so = resp->cstate.replay_owner; in nfsd4_encode_operation()
5378 struct svc_rqst *rqstp = resp->rqstp; in nfsd4_encode_operation()
5379 const struct nfsd4_operation *opdesc = op->opdesc; in nfsd4_encode_operation()
5387 *p++ = cpu_to_be32(op->opnum); in nfsd4_encode_operation()
5388 post_err_offset = xdr->buf->len; in nfsd4_encode_operation()
5390 if (op->opnum == OP_ILLEGAL) in nfsd4_encode_operation()
5392 if (op->status && opdesc && in nfsd4_encode_operation()
5393 !(opdesc->op_flags & OP_NONTRIVIAL_ERROR_ENCODE)) in nfsd4_encode_operation()
5395 BUG_ON(op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) || in nfsd4_encode_operation()
5396 !nfsd4_enc_ops[op->opnum]); in nfsd4_encode_operation()
5397 encoder = nfsd4_enc_ops[op->opnum]; in nfsd4_encode_operation()
5398 op->status = encoder(resp, op->status, &op->u); in nfsd4_encode_operation()
5399 if (op->status) in nfsd4_encode_operation()
5400 trace_nfsd_compound_encode_err(rqstp, op->opnum, op->status); in nfsd4_encode_operation()
5404 if (!op->status) { in nfsd4_encode_operation()
5408 op->status = nfsd4_check_resp_size(resp, space_needed); in nfsd4_encode_operation()
5410 if (op->status == nfserr_resource && nfsd4_has_session(&resp->cstate)) { in nfsd4_encode_operation()
5411 struct nfsd4_slot *slot = resp->cstate.slot; in nfsd4_encode_operation()
5413 if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) in nfsd4_encode_operation()
5414 op->status = nfserr_rep_too_big_to_cache; in nfsd4_encode_operation()
5416 op->status = nfserr_rep_too_big; in nfsd4_encode_operation()
5418 if (op->status == nfserr_resource || in nfsd4_encode_operation()
5419 op->status == nfserr_rep_too_big || in nfsd4_encode_operation()
5420 op->status == nfserr_rep_too_big_to_cache) { in nfsd4_encode_operation()
5426 * bug if we had to do this on a non-idempotent op: in nfsd4_encode_operation()
5432 int len = xdr->buf->len - post_err_offset; in nfsd4_encode_operation()
5434 so->so_replay.rp_status = op->status; in nfsd4_encode_operation()
5435 so->so_replay.rp_buflen = len; in nfsd4_encode_operation()
5436 read_bytes_from_xdr_buf(xdr->buf, post_err_offset, in nfsd4_encode_operation()
5437 so->so_replay.rp_buf, len); in nfsd4_encode_operation()
5440 *p = op->status; in nfsd4_encode_operation()
5442 if (opdesc && opdesc->op_release) in nfsd4_encode_operation()
5443 opdesc->op_release(&op->u); in nfsd4_encode_operation()
5449 rqstp->rq_next_page = xdr->page_ptr + 1; in nfsd4_encode_operation()
5455 * XDR note: do not encode rp->rp_buflen: the buffer contains the
5462 struct nfs4_replay *rp = op->replay; in nfsd4_encode_replay()
5464 p = xdr_reserve_space(xdr, 8 + rp->rp_buflen); in nfsd4_encode_replay()
5469 *p++ = cpu_to_be32(op->opnum); in nfsd4_encode_replay()
5470 *p++ = rp->rp_status; /* already xdr'ed */ in nfsd4_encode_replay()
5472 p = xdr_encode_opaque_fixed(p, rp->rp_buf, rp->rp_buflen); in nfsd4_encode_replay()
5477 struct nfsd4_compoundargs *args = rqstp->rq_argp; in nfsd4_release_compoundargs()
5479 if (args->ops != args->iops) { in nfsd4_release_compoundargs()
5480 vfree(args->ops); in nfsd4_release_compoundargs()
5481 args->ops = args->iops; in nfsd4_release_compoundargs()
5483 while (args->to_free) { in nfsd4_release_compoundargs()
5484 struct svcxdr_tmpbuf *tb = args->to_free; in nfsd4_release_compoundargs()
5485 args->to_free = tb->next; in nfsd4_release_compoundargs()
5493 struct nfsd4_compoundargs *args = rqstp->rq_argp; in nfs4svc_decode_compoundargs()
5496 args->to_free = NULL; in nfs4svc_decode_compoundargs()
5498 args->xdr = xdr; in nfs4svc_decode_compoundargs()
5499 args->ops = args->iops; in nfs4svc_decode_compoundargs()
5500 args->rqstp = rqstp; in nfs4svc_decode_compoundargs()
5508 struct nfsd4_compoundres *resp = rqstp->rq_resp; in nfs4svc_encode_compoundres()
5515 p = resp->statusp; in nfs4svc_encode_compoundres()
5517 *p++ = resp->cstate.status; in nfs4svc_encode_compoundres()
5518 *p++ = htonl(resp->taglen); in nfs4svc_encode_compoundres()
5519 memcpy(p, resp->tag, resp->taglen); in nfs4svc_encode_compoundres()
5520 p += XDR_QUADLEN(resp->taglen); in nfs4svc_encode_compoundres()
5521 *p++ = htonl(resp->opcnt); in nfs4svc_encode_compoundres()