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 if (argp->minorversion == 0) in nfsd4_decode_putpubfh()
1259 struct nfsd4_read *read = &u->read; in nfsd4_decode_read()
1263 status = nfsd4_decode_stateid4(argp, &read->rd_stateid); in nfsd4_decode_read()
1266 if (xdr_stream_decode_u64(argp->xdr, &read->rd_offset) < 0) in nfsd4_decode_read()
1268 if (xdr_stream_decode_u32(argp->xdr, &read->rd_length) < 0) in nfsd4_decode_read()
1277 struct nfsd4_readdir *readdir = &u->readdir; in nfsd4_decode_readdir()
1281 if (xdr_stream_decode_u64(argp->xdr, &readdir->rd_cookie) < 0) in nfsd4_decode_readdir()
1283 status = nfsd4_decode_verifier4(argp, &readdir->rd_verf); in nfsd4_decode_readdir()
1286 if (xdr_stream_decode_u32(argp->xdr, &readdir->rd_dircount) < 0) in nfsd4_decode_readdir()
1288 if (xdr_stream_decode_u32(argp->xdr, &readdir->rd_maxcount) < 0) in nfsd4_decode_readdir()
1290 if (xdr_stream_decode_uint32_array(argp->xdr, readdir->rd_bmval, in nfsd4_decode_readdir()
1291 ARRAY_SIZE(readdir->rd_bmval)) < 0) in nfsd4_decode_readdir()
1300 struct nfsd4_remove *remove = &u->remove; in nfsd4_decode_remove()
1301 memset(&remove->rm_cinfo, 0, sizeof(remove->rm_cinfo)); in nfsd4_decode_remove()
1302 return nfsd4_decode_component4(argp, &remove->rm_name, &remove->rm_namelen); in nfsd4_decode_remove()
1308 struct nfsd4_rename *rename = &u->rename; in nfsd4_decode_rename()
1312 status = nfsd4_decode_component4(argp, &rename->rn_sname, &rename->rn_snamelen); in nfsd4_decode_rename()
1315 return nfsd4_decode_component4(argp, &rename->rn_tname, &rename->rn_tnamelen); in nfsd4_decode_rename()
1321 clientid_t *clientid = &u->renew; in nfsd4_decode_renew()
1329 struct nfsd4_secinfo *secinfo = &u->secinfo; in nfsd4_decode_secinfo()
1330 secinfo->si_exp = NULL; in nfsd4_decode_secinfo()
1331 return nfsd4_decode_component4(argp, &secinfo->si_name, &secinfo->si_namelen); in nfsd4_decode_secinfo()
1337 struct nfsd4_setattr *setattr = &u->setattr; in nfsd4_decode_setattr()
1341 status = nfsd4_decode_stateid4(argp, &setattr->sa_stateid); in nfsd4_decode_setattr()
1344 return nfsd4_decode_fattr4(argp, setattr->sa_bmval, in nfsd4_decode_setattr()
1345 ARRAY_SIZE(setattr->sa_bmval), in nfsd4_decode_setattr()
1346 &setattr->sa_iattr, &setattr->sa_acl, in nfsd4_decode_setattr()
1347 &setattr->sa_label, NULL); in nfsd4_decode_setattr()
1353 struct nfsd4_setclientid *setclientid = &u->setclientid; in nfsd4_decode_setclientid()
1358 if (argp->minorversion >= 1) in nfsd4_decode_setclientid()
1361 status = nfsd4_decode_verifier4(argp, &setclientid->se_verf); in nfsd4_decode_setclientid()
1364 status = nfsd4_decode_opaque(argp, &setclientid->se_name); in nfsd4_decode_setclientid()
1367 if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_prog) < 0) in nfsd4_decode_setclientid()
1369 if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_netid_len) < 0) in nfsd4_decode_setclientid()
1371 p = xdr_inline_decode(argp->xdr, setclientid->se_callback_netid_len); in nfsd4_decode_setclientid()
1374 setclientid->se_callback_netid_val = svcxdr_savemem(argp, p, in nfsd4_decode_setclientid()
1375 setclientid->se_callback_netid_len); in nfsd4_decode_setclientid()
1376 if (!setclientid->se_callback_netid_val) in nfsd4_decode_setclientid()
1379 if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_addr_len) < 0) in nfsd4_decode_setclientid()
1381 p = xdr_inline_decode(argp->xdr, setclientid->se_callback_addr_len); in nfsd4_decode_setclientid()
1384 setclientid->se_callback_addr_val = svcxdr_savemem(argp, p, in nfsd4_decode_setclientid()
1385 setclientid->se_callback_addr_len); in nfsd4_decode_setclientid()
1386 if (!setclientid->se_callback_addr_val) in nfsd4_decode_setclientid()
1388 if (xdr_stream_decode_u32(argp->xdr, &setclientid->se_callback_ident) < 0) in nfsd4_decode_setclientid()
1398 struct nfsd4_setclientid_confirm *scd_c = &u->setclientid_confirm; in nfsd4_decode_setclientid_confirm()
1401 if (argp->minorversion >= 1) in nfsd4_decode_setclientid_confirm()
1404 status = nfsd4_decode_clientid4(argp, &scd_c->sc_clientid); in nfsd4_decode_setclientid_confirm()
1407 return nfsd4_decode_verifier4(argp, &scd_c->sc_confirm); in nfsd4_decode_setclientid_confirm()
1414 struct nfsd4_verify *verify = &u->verify; in nfsd4_decode_verify()
1419 status = nfsd4_decode_bitmap4(argp, verify->ve_bmval, in nfsd4_decode_verify()
1420 ARRAY_SIZE(verify->ve_bmval)); in nfsd4_decode_verify()
1427 if (xdr_stream_decode_u32(argp->xdr, &verify->ve_attrlen) < 0) in nfsd4_decode_verify()
1429 p = xdr_inline_decode(argp->xdr, verify->ve_attrlen); in nfsd4_decode_verify()
1432 verify->ve_attrval = svcxdr_savemem(argp, p, verify->ve_attrlen); in nfsd4_decode_verify()
1433 if (!verify->ve_attrval) in nfsd4_decode_verify()
1442 struct nfsd4_write *write = &u->write; in nfsd4_decode_write()
1445 status = nfsd4_decode_stateid4(argp, &write->wr_stateid); in nfsd4_decode_write()
1448 if (xdr_stream_decode_u64(argp->xdr, &write->wr_offset) < 0) in nfsd4_decode_write()
1450 if (xdr_stream_decode_u32(argp->xdr, &write->wr_stable_how) < 0) in nfsd4_decode_write()
1452 if (write->wr_stable_how > NFS_FILE_SYNC) in nfsd4_decode_write()
1454 if (xdr_stream_decode_u32(argp->xdr, &write->wr_buflen) < 0) in nfsd4_decode_write()
1456 if (!xdr_stream_subsegment(argp->xdr, &write->wr_payload, write->wr_buflen)) in nfsd4_decode_write()
1459 write->wr_bytes_written = 0; in nfsd4_decode_write()
1460 write->wr_how_written = 0; in nfsd4_decode_write()
1461 memset(&write->wr_verifier, 0, sizeof(write->wr_verifier)); in nfsd4_decode_write()
1469 struct nfsd4_release_lockowner *rlockowner = &u->release_lockowner; in nfsd4_decode_release_lockowner()
1472 if (argp->minorversion >= 1) in nfsd4_decode_release_lockowner()
1475 status = nfsd4_decode_state_owner4(argp, &rlockowner->rl_clientid, in nfsd4_decode_release_lockowner()
1476 &rlockowner->rl_owner); in nfsd4_decode_release_lockowner()
1480 if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid)) in nfsd4_decode_release_lockowner()
1489 struct nfsd4_backchannel_ctl *bc = &u->backchannel_ctl; in nfsd4_decode_backchannel_ctl()
1491 if (xdr_stream_decode_u32(argp->xdr, &bc->bc_cb_program) < 0) in nfsd4_decode_backchannel_ctl()
1493 return nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec); in nfsd4_decode_backchannel_ctl()
1499 struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session; in nfsd4_decode_bind_conn_to_session()
1504 status = nfsd4_decode_sessionid4(argp, &bcts->sessionid); in nfsd4_decode_bind_conn_to_session()
1507 if (xdr_stream_decode_u32(argp->xdr, &bcts->dir) < 0) in nfsd4_decode_bind_conn_to_session()
1509 if (xdr_stream_decode_u32(argp->xdr, &use_conn_in_rdma_mode) < 0) in nfsd4_decode_bind_conn_to_session()
1521 status = nfsd4_decode_bitmap4(argp, exid->spo_must_enforce, in nfsd4_decode_state_protect_ops()
1522 ARRAY_SIZE(exid->spo_must_enforce)); in nfsd4_decode_state_protect_ops()
1525 status = nfsd4_decode_bitmap4(argp, exid->spo_must_allow, in nfsd4_decode_state_protect_ops()
1526 ARRAY_SIZE(exid->spo_must_allow)); in nfsd4_decode_state_protect_ops()
1550 if (xdr_stream_decode_u32(argp->xdr, &count) < 0) in nfsd4_decode_ssv_sp_parms()
1552 while (count--) { in nfsd4_decode_ssv_sp_parms()
1559 if (xdr_stream_decode_u32(argp->xdr, &count) < 0) in nfsd4_decode_ssv_sp_parms()
1561 while (count--) { in nfsd4_decode_ssv_sp_parms()
1567 if (xdr_stream_decode_u32(argp->xdr, &window) < 0) in nfsd4_decode_ssv_sp_parms()
1569 if (xdr_stream_decode_u32(argp->xdr, &num_gss_handles) < 0) in nfsd4_decode_ssv_sp_parms()
1581 if (xdr_stream_decode_u32(argp->xdr, &exid->spa_how) < 0) in nfsd4_decode_state_protect4_a()
1583 switch (exid->spa_how) { in nfsd4_decode_state_protect4_a()
1610 if (xdr_stream_decode_u32(argp->xdr, &count) < 0) in nfsd4_decode_nfs_impl_id4()
1619 status = nfsd4_decode_opaque(argp, &exid->nii_domain); in nfsd4_decode_nfs_impl_id4()
1625 status = nfsd4_decode_opaque(argp, &exid->nii_name); in nfsd4_decode_nfs_impl_id4()
1628 status = nfsd4_decode_nfstime4(argp, &exid->nii_time); in nfsd4_decode_nfs_impl_id4()
1643 struct nfsd4_exchange_id *exid = &u->exchange_id; in nfsd4_decode_exchange_id()
1647 status = nfsd4_decode_verifier4(argp, &exid->verifier); in nfsd4_decode_exchange_id()
1650 status = nfsd4_decode_opaque(argp, &exid->clname); in nfsd4_decode_exchange_id()
1653 if (xdr_stream_decode_u32(argp->xdr, &exid->flags) < 0) in nfsd4_decode_exchange_id()
1667 p = xdr_inline_decode(argp->xdr, XDR_UNIT * 7); in nfsd4_decode_channel_attrs4()
1673 ca->maxreq_sz = be32_to_cpup(p++); in nfsd4_decode_channel_attrs4()
1674 ca->maxresp_sz = be32_to_cpup(p++); in nfsd4_decode_channel_attrs4()
1675 ca->maxresp_cached = be32_to_cpup(p++); in nfsd4_decode_channel_attrs4()
1676 ca->maxops = be32_to_cpup(p++); in nfsd4_decode_channel_attrs4()
1677 ca->maxreqs = be32_to_cpup(p++); in nfsd4_decode_channel_attrs4()
1678 ca->nr_rdma_attrs = be32_to_cpup(p); in nfsd4_decode_channel_attrs4()
1679 switch (ca->nr_rdma_attrs) { in nfsd4_decode_channel_attrs4()
1683 if (xdr_stream_decode_u32(argp->xdr, &ca->rdma_attrs) < 0) in nfsd4_decode_channel_attrs4()
1697 struct nfsd4_create_session *sess = &u->create_session; in nfsd4_decode_create_session()
1701 status = nfsd4_decode_clientid4(argp, &sess->clientid); in nfsd4_decode_create_session()
1704 if (xdr_stream_decode_u32(argp->xdr, &sess->seqid) < 0) in nfsd4_decode_create_session()
1706 if (xdr_stream_decode_u32(argp->xdr, &sess->flags) < 0) in nfsd4_decode_create_session()
1708 status = nfsd4_decode_channel_attrs4(argp, &sess->fore_channel); in nfsd4_decode_create_session()
1711 status = nfsd4_decode_channel_attrs4(argp, &sess->back_channel); in nfsd4_decode_create_session()
1714 if (xdr_stream_decode_u32(argp->xdr, &sess->callback_prog) < 0) in nfsd4_decode_create_session()
1716 return nfsd4_decode_cb_sec(argp, &sess->cb_sec); in nfsd4_decode_create_session()
1723 struct nfsd4_destroy_session *destroy_session = &u->destroy_session; in nfsd4_decode_destroy_session()
1724 return nfsd4_decode_sessionid4(argp, &destroy_session->sessionid); in nfsd4_decode_destroy_session()
1731 struct nfsd4_free_stateid *free_stateid = &u->free_stateid; in nfsd4_decode_free_stateid()
1732 return nfsd4_decode_stateid4(argp, &free_stateid->fr_stateid); in nfsd4_decode_free_stateid()
1740 struct nfsd4_getdeviceinfo *gdev = &u->getdeviceinfo; in nfsd4_decode_getdeviceinfo()
1744 status = nfsd4_decode_deviceid4(argp, &gdev->gd_devid); in nfsd4_decode_getdeviceinfo()
1747 if (xdr_stream_decode_u32(argp->xdr, &gdev->gd_layout_type) < 0) in nfsd4_decode_getdeviceinfo()
1749 if (xdr_stream_decode_u32(argp->xdr, &gdev->gd_maxcount) < 0) in nfsd4_decode_getdeviceinfo()
1751 if (xdr_stream_decode_uint32_array(argp->xdr, in nfsd4_decode_getdeviceinfo()
1752 &gdev->gd_notify_types, 1) < 0) in nfsd4_decode_getdeviceinfo()
1762 struct nfsd4_layoutcommit *lcp = &u->layoutcommit; in nfsd4_decode_layoutcommit()
1766 if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_seg.offset) < 0) in nfsd4_decode_layoutcommit()
1768 if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_seg.length) < 0) in nfsd4_decode_layoutcommit()
1770 if (xdr_stream_decode_bool(argp->xdr, &lcp->lc_reclaim) < 0) in nfsd4_decode_layoutcommit()
1772 status = nfsd4_decode_stateid4(argp, &lcp->lc_sid); in nfsd4_decode_layoutcommit()
1775 if (xdr_stream_decode_u32(argp->xdr, &lcp->lc_newoffset) < 0) in nfsd4_decode_layoutcommit()
1777 if (lcp->lc_newoffset) { in nfsd4_decode_layoutcommit()
1778 if (xdr_stream_decode_u64(argp->xdr, &lcp->lc_last_wr) < 0) in nfsd4_decode_layoutcommit()
1781 lcp->lc_last_wr = 0; in nfsd4_decode_layoutcommit()
1782 p = xdr_inline_decode(argp->xdr, XDR_UNIT); in nfsd4_decode_layoutcommit()
1786 status = nfsd4_decode_nfstime4(argp, &lcp->lc_mtime); in nfsd4_decode_layoutcommit()
1790 lcp->lc_mtime.tv_nsec = UTIME_NOW; in nfsd4_decode_layoutcommit()
1799 struct nfsd4_layoutget *lgp = &u->layoutget; in nfsd4_decode_layoutget()
1803 if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_signal) < 0) in nfsd4_decode_layoutget()
1805 if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_layout_type) < 0) in nfsd4_decode_layoutget()
1807 if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_seg.iomode) < 0) in nfsd4_decode_layoutget()
1809 if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_seg.offset) < 0) in nfsd4_decode_layoutget()
1811 if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_seg.length) < 0) in nfsd4_decode_layoutget()
1813 if (xdr_stream_decode_u64(argp->xdr, &lgp->lg_minlength) < 0) in nfsd4_decode_layoutget()
1815 status = nfsd4_decode_stateid4(argp, &lgp->lg_sid); in nfsd4_decode_layoutget()
1818 if (xdr_stream_decode_u32(argp->xdr, &lgp->lg_maxcount) < 0) in nfsd4_decode_layoutget()
1828 struct nfsd4_layoutreturn *lrp = &u->layoutreturn; in nfsd4_decode_layoutreturn()
1830 if (xdr_stream_decode_bool(argp->xdr, &lrp->lr_reclaim) < 0) in nfsd4_decode_layoutreturn()
1832 if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_layout_type) < 0) in nfsd4_decode_layoutreturn()
1834 if (xdr_stream_decode_u32(argp->xdr, &lrp->lr_seg.iomode) < 0) in nfsd4_decode_layoutreturn()
1843 struct nfsd4_secinfo_no_name *sin = &u->secinfo_no_name; in nfsd4_decode_secinfo_no_name()
1844 if (xdr_stream_decode_u32(argp->xdr, &sin->sin_style) < 0) in nfsd4_decode_secinfo_no_name()
1847 sin->sin_exp = NULL; in nfsd4_decode_secinfo_no_name()
1855 struct nfsd4_sequence *seq = &u->sequence; in nfsd4_decode_sequence()
1858 status = nfsd4_decode_sessionid4(argp, &seq->sessionid); in nfsd4_decode_sequence()
1861 p = xdr_inline_decode(argp->xdr, XDR_UNIT * 4); in nfsd4_decode_sequence()
1864 seq->seqid = be32_to_cpup(p++); in nfsd4_decode_sequence()
1865 seq->slotid = be32_to_cpup(p++); in nfsd4_decode_sequence()
1866 seq->maxslots = be32_to_cpup(p++); in nfsd4_decode_sequence()
1867 seq->cachethis = be32_to_cpup(p); in nfsd4_decode_sequence()
1869 seq->status_flags = 0; in nfsd4_decode_sequence()
1877 struct nfsd4_test_stateid *test_stateid = &u->test_stateid; in nfsd4_decode_test_stateid()
1883 if (xdr_stream_decode_u32(argp->xdr, &test_stateid->ts_num_ids) < 0) in nfsd4_decode_test_stateid()
1886 INIT_LIST_HEAD(&test_stateid->ts_stateid_list); in nfsd4_decode_test_stateid()
1887 for (i = 0; i < test_stateid->ts_num_ids; i++) { in nfsd4_decode_test_stateid()
1891 INIT_LIST_HEAD(&stateid->ts_id_list); in nfsd4_decode_test_stateid()
1892 list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list); in nfsd4_decode_test_stateid()
1893 status = nfsd4_decode_stateid4(argp, &stateid->ts_id_stateid); in nfsd4_decode_test_stateid()
1904 struct nfsd4_destroy_clientid *dc = &u->destroy_clientid; in nfsd4_decode_destroy_clientid()
1905 return nfsd4_decode_clientid4(argp, &dc->clientid); in nfsd4_decode_destroy_clientid()
1911 struct nfsd4_reclaim_complete *rc = &u->reclaim_complete; in nfsd4_decode_reclaim_complete()
1912 if (xdr_stream_decode_bool(argp->xdr, &rc->rca_one_fs) < 0) in nfsd4_decode_reclaim_complete()
1921 struct nfsd4_fallocate *fallocate = &u->allocate; in nfsd4_decode_fallocate()
1924 status = nfsd4_decode_stateid4(argp, &fallocate->falloc_stateid); in nfsd4_decode_fallocate()
1927 if (xdr_stream_decode_u64(argp->xdr, &fallocate->falloc_offset) < 0) in nfsd4_decode_fallocate()
1929 if (xdr_stream_decode_u64(argp->xdr, &fallocate->falloc_length) < 0) in nfsd4_decode_fallocate()
1941 if (xdr_stream_decode_u32(argp->xdr, &ns->nl4_type) < 0) in nfsd4_decode_nl4_server()
1944 /* currently support for 1 inter-server source server */ in nfsd4_decode_nl4_server()
1945 switch (ns->nl4_type) { in nfsd4_decode_nl4_server()
1947 naddr = &ns->u.nl4_addr; in nfsd4_decode_nl4_server()
1949 if (xdr_stream_decode_u32(argp->xdr, &naddr->netid_len) < 0) in nfsd4_decode_nl4_server()
1951 if (naddr->netid_len > RPCBIND_MAXNETIDLEN) in nfsd4_decode_nl4_server()
1954 p = xdr_inline_decode(argp->xdr, naddr->netid_len); in nfsd4_decode_nl4_server()
1957 memcpy(naddr->netid, p, naddr->netid_len); in nfsd4_decode_nl4_server()
1959 if (xdr_stream_decode_u32(argp->xdr, &naddr->addr_len) < 0) in nfsd4_decode_nl4_server()
1961 if (naddr->addr_len > RPCBIND_MAXUADDRLEN) in nfsd4_decode_nl4_server()
1964 p = xdr_inline_decode(argp->xdr, naddr->addr_len); in nfsd4_decode_nl4_server()
1967 memcpy(naddr->addr, p, naddr->addr_len); in nfsd4_decode_nl4_server()
1979 struct nfsd4_copy *copy = &u->copy; in nfsd4_decode_copy()
1985 status = nfsd4_decode_stateid4(argp, ©->cp_src_stateid); in nfsd4_decode_copy()
1988 status = nfsd4_decode_stateid4(argp, ©->cp_dst_stateid); in nfsd4_decode_copy()
1991 if (xdr_stream_decode_u64(argp->xdr, ©->cp_src_pos) < 0) in nfsd4_decode_copy()
1993 if (xdr_stream_decode_u64(argp->xdr, ©->cp_dst_pos) < 0) in nfsd4_decode_copy()
1995 if (xdr_stream_decode_u64(argp->xdr, ©->cp_count) < 0) in nfsd4_decode_copy()
1998 if (xdr_stream_decode_u32(argp->xdr, &consecutive) < 0) in nfsd4_decode_copy()
2000 if (xdr_stream_decode_bool(argp->xdr, &sync) < 0) in nfsd4_decode_copy()
2004 if (xdr_stream_decode_u32(argp->xdr, &count) < 0) in nfsd4_decode_copy()
2006 copy->cp_src = svcxdr_tmpalloc(argp, sizeof(*copy->cp_src)); in nfsd4_decode_copy()
2007 if (copy->cp_src == NULL) in nfsd4_decode_copy()
2009 if (count == 0) { /* intra-server copy */ in nfsd4_decode_copy()
2010 __set_bit(NFSD4_COPY_F_INTRA, ©->cp_flags); in nfsd4_decode_copy()
2015 status = nfsd4_decode_nl4_server(argp, copy->cp_src); in nfsd4_decode_copy()
2022 for (i = 0; i < count - 1; i++) { in nfsd4_decode_copy()
2038 struct nfsd4_copy_notify *cn = &u->copy_notify; in nfsd4_decode_copy_notify()
2042 cn->cpn_src = svcxdr_tmpalloc(argp, sizeof(*cn->cpn_src)); in nfsd4_decode_copy_notify()
2043 if (cn->cpn_src == NULL) in nfsd4_decode_copy_notify()
2045 cn->cpn_dst = svcxdr_tmpalloc(argp, sizeof(*cn->cpn_dst)); in nfsd4_decode_copy_notify()
2046 if (cn->cpn_dst == NULL) in nfsd4_decode_copy_notify()
2049 status = nfsd4_decode_stateid4(argp, &cn->cpn_src_stateid); in nfsd4_decode_copy_notify()
2052 return nfsd4_decode_nl4_server(argp, cn->cpn_dst); in nfsd4_decode_copy_notify()
2059 struct nfsd4_offload_status *os = &u->offload_status; in nfsd4_decode_offload_status()
2060 os->count = 0; in nfsd4_decode_offload_status()
2061 os->status = 0; in nfsd4_decode_offload_status()
2062 return nfsd4_decode_stateid4(argp, &os->stateid); in nfsd4_decode_offload_status()
2068 struct nfsd4_seek *seek = &u->seek; in nfsd4_decode_seek()
2071 status = nfsd4_decode_stateid4(argp, &seek->seek_stateid); in nfsd4_decode_seek()
2074 if (xdr_stream_decode_u64(argp->xdr, &seek->seek_offset) < 0) in nfsd4_decode_seek()
2076 if (xdr_stream_decode_u32(argp->xdr, &seek->seek_whence) < 0) in nfsd4_decode_seek()
2079 seek->seek_eof = 0; in nfsd4_decode_seek()
2080 seek->seek_pos = 0; in nfsd4_decode_seek()
2087 struct nfsd4_clone *clone = &u->clone; in nfsd4_decode_clone()
2090 status = nfsd4_decode_stateid4(argp, &clone->cl_src_stateid); in nfsd4_decode_clone()
2093 status = nfsd4_decode_stateid4(argp, &clone->cl_dst_stateid); in nfsd4_decode_clone()
2096 if (xdr_stream_decode_u64(argp->xdr, &clone->cl_src_pos) < 0) in nfsd4_decode_clone()
2098 if (xdr_stream_decode_u64(argp->xdr, &clone->cl_dst_pos) < 0) in nfsd4_decode_clone()
2100 if (xdr_stream_decode_u64(argp->xdr, &clone->cl_count) < 0) in nfsd4_decode_clone()
2111 * is 64k). Since there is no kvec- or page-based interface to xattrs,
2122 struct page **pages = xdr->pages; in nfsd4_vbuf_from_vector()
2123 struct kvec *head = xdr->head; in nfsd4_vbuf_from_vector()
2127 if (buflen <= head->iov_len) { in nfsd4_vbuf_from_vector()
2132 *bufp = head->iov_base; in nfsd4_vbuf_from_vector()
2141 memcpy(dp, head->iov_base, head->iov_len); in nfsd4_vbuf_from_vector()
2142 buflen -= head->iov_len; in nfsd4_vbuf_from_vector()
2143 dp += head->iov_len; in nfsd4_vbuf_from_vector()
2149 buflen -= len; in nfsd4_vbuf_from_vector()
2170 if (xdr_stream_decode_u32(argp->xdr, &namelen) < 0) in nfsd4_decode_xattr_name()
2172 if (namelen > (XATTR_NAME_MAX - XATTR_USER_PREFIX_LEN)) in nfsd4_decode_xattr_name()
2176 p = xdr_inline_decode(argp->xdr, namelen); in nfsd4_decode_xattr_name()
2192 while (cnt-- > 0) { in nfsd4_decode_xattr_name()
2205 * A GETXATTR op request comes without a length specifier. We just set the
2214 struct nfsd4_getxattr *getxattr = &u->getxattr; in nfsd4_decode_getxattr()
2219 status = nfsd4_decode_xattr_name(argp, &getxattr->getxa_name); in nfsd4_decode_getxattr()
2223 maxcount = svc_max_payload(argp->rqstp); in nfsd4_decode_getxattr()
2226 getxattr->getxa_len = maxcount; in nfsd4_decode_getxattr()
2234 struct nfsd4_setxattr *setxattr = &u->setxattr; in nfsd4_decode_setxattr()
2240 if (xdr_stream_decode_u32(argp->xdr, &flags) < 0) in nfsd4_decode_setxattr()
2245 setxattr->setxa_flags = flags; in nfsd4_decode_setxattr()
2247 status = nfsd4_decode_xattr_name(argp, &setxattr->setxa_name); in nfsd4_decode_setxattr()
2251 maxcount = svc_max_payload(argp->rqstp); in nfsd4_decode_setxattr()
2254 if (xdr_stream_decode_u32(argp->xdr, &size) < 0) in nfsd4_decode_setxattr()
2259 setxattr->setxa_len = size; in nfsd4_decode_setxattr()
2263 if (!xdr_stream_subsegment(argp->xdr, &payload, size)) in nfsd4_decode_setxattr()
2266 &setxattr->setxa_buf, size); in nfsd4_decode_setxattr()
2276 struct nfsd4_listxattrs *listxattrs = &u->listxattrs; in nfsd4_decode_listxattrs()
2281 if (xdr_stream_decode_u64(argp->xdr, &listxattrs->lsxa_cookie) < 0) in nfsd4_decode_listxattrs()
2288 if (listxattrs->lsxa_cookie >= in nfsd4_decode_listxattrs()
2292 if (xdr_stream_decode_u32(argp->xdr, &maxcount) < 0) in nfsd4_decode_listxattrs()
2298 maxcount = min(maxcount, svc_max_payload(argp->rqstp)); in nfsd4_decode_listxattrs()
2299 listxattrs->lsxa_maxcount = maxcount; in nfsd4_decode_listxattrs()
2308 struct nfsd4_removexattr *removexattr = &u->removexattr; in nfsd4_decode_removexattr()
2310 return nfsd4_decode_xattr_name(argp, &removexattr->rmxa_name); in nfsd4_decode_removexattr()
2419 if (op->opnum < FIRST_NFS4_OP) in nfsd4_opnum_in_range()
2421 else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP) in nfsd4_opnum_in_range()
2423 else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP) in nfsd4_opnum_in_range()
2425 else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP) in nfsd4_opnum_in_range()
2435 int auth_slack= argp->rqstp->rq_auth_slack; in nfsd4_decode_compound()
2442 if (xdr_stream_decode_u32(argp->xdr, &argp->taglen) < 0) in nfsd4_decode_compound()
2445 argp->tag = NULL; in nfsd4_decode_compound()
2446 if (unlikely(argp->taglen)) { in nfsd4_decode_compound()
2447 if (argp->taglen > NFSD4_MAX_TAGLEN) in nfsd4_decode_compound()
2449 p = xdr_inline_decode(argp->xdr, argp->taglen); in nfsd4_decode_compound()
2452 argp->tag = svcxdr_savemem(argp, p, argp->taglen); in nfsd4_decode_compound()
2453 if (!argp->tag) in nfsd4_decode_compound()
2455 max_reply += xdr_align_size(argp->taglen); in nfsd4_decode_compound()
2458 if (xdr_stream_decode_u32(argp->xdr, &argp->minorversion) < 0) in nfsd4_decode_compound()
2460 if (xdr_stream_decode_u32(argp->xdr, &argp->client_opcnt) < 0) in nfsd4_decode_compound()
2462 argp->opcnt = min_t(u32, argp->client_opcnt, in nfsd4_decode_compound()
2465 if (argp->opcnt > ARRAY_SIZE(argp->iops)) { in nfsd4_decode_compound()
2466 argp->ops = vcalloc(argp->opcnt, sizeof(*argp->ops)); in nfsd4_decode_compound()
2467 if (!argp->ops) { in nfsd4_decode_compound()
2468 argp->ops = argp->iops; in nfsd4_decode_compound()
2473 if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION) in nfsd4_decode_compound()
2474 argp->opcnt = 0; in nfsd4_decode_compound()
2476 for (i = 0; i < argp->opcnt; i++) { in nfsd4_decode_compound()
2477 op = &argp->ops[i]; in nfsd4_decode_compound()
2478 op->replay = NULL; in nfsd4_decode_compound()
2479 op->opdesc = NULL; in nfsd4_decode_compound()
2481 if (xdr_stream_decode_u32(argp->xdr, &op->opnum) < 0) in nfsd4_decode_compound()
2484 op->opdesc = OPDESC(op); in nfsd4_decode_compound()
2485 op->status = nfsd4_dec_ops[op->opnum](argp, &op->u); in nfsd4_decode_compound()
2486 if (op->status != nfs_ok) in nfsd4_decode_compound()
2487 trace_nfsd_compound_decode_err(argp->rqstp, in nfsd4_decode_compound()
2488 argp->opcnt, i, in nfsd4_decode_compound()
2489 op->opnum, in nfsd4_decode_compound()
2490 op->status); in nfsd4_decode_compound()
2492 op->opnum = OP_ILLEGAL; in nfsd4_decode_compound()
2493 op->status = nfserr_op_illegal; in nfsd4_decode_compound()
2502 if (op->opnum == OP_READ || op->opnum == OP_READ_PLUS) { in nfsd4_decode_compound()
2504 readbytes += nfsd4_max_reply(argp->rqstp, op); in nfsd4_decode_compound()
2506 max_reply += nfsd4_max_reply(argp->rqstp, op); in nfsd4_decode_compound()
2513 if (op->opnum == OP_LOCK || op->opnum == OP_LOCKT) in nfsd4_decode_compound()
2516 if (op->status) { in nfsd4_decode_compound()
2517 argp->opcnt = i+1; in nfsd4_decode_compound()
2522 if (argp->minorversion) in nfsd4_decode_compound()
2524 svc_reserve(argp->rqstp, max_reply + readbytes); in nfsd4_decode_compound()
2525 argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE; in nfsd4_decode_compound()
2527 if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack) in nfsd4_decode_compound()
2528 clear_bit(RQ_SPLICE_OK, &argp->rqstp->rq_flags); in nfsd4_decode_compound()
2536 if (exp->ex_flags & NFSEXP_V4ROOT) { in encode_change()
2537 *p++ = cpu_to_be32(convert_to_wallclock(exp->cd->flush_time)); in encode_change()
2553 p = xdr_encode_hyper(p, (s64)tv->tv_sec); in nfsd4_encode_nfstime4()
2554 *p = cpu_to_be32(tv->tv_nsec); in nfsd4_encode_nfstime4()
2574 ns = max_t(u32, NSEC_PER_SEC/HZ, inode->i_sb->s_time_gran); in encode_time_delta()
2586 if (xdr_stream_encode_bool(xdr, c->atomic) < 0) in nfsd4_encode_change_info4()
2588 if (xdr_stream_encode_u64(xdr, c->before_change) < 0) in nfsd4_encode_change_info4()
2590 if (xdr_stream_encode_u64(xdr, c->after_change) < 0) in nfsd4_encode_change_info4()
2610 pathlen_offset = xdr->buf->len; in nfsd4_encode_components_esc()
2635 strlen = end - str; in nfsd4_encode_components_esc()
2651 write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4); in nfsd4_encode_components_esc()
2672 status = nfsd4_encode_components_esc(xdr, ':', location->hosts, in nfsd4_encode_fs_location4()
2676 status = nfsd4_encode_components(xdr, '/', location->path); in nfsd4_encode_fs_location4()
2704 if (cur.dentry == cur.mnt->mnt_root) { in nfsd4_encode_path()
2728 struct dentry *dentry = components[ncomponents - 1]; in nfsd4_encode_path()
2731 spin_lock(&dentry->d_lock); in nfsd4_encode_path()
2732 len = dentry->d_name.len; in nfsd4_encode_path()
2735 spin_unlock(&dentry->d_lock); in nfsd4_encode_path()
2738 p = xdr_encode_opaque(p, dentry->d_name.name, len); in nfsd4_encode_path()
2740 spin_unlock(&dentry->d_lock); in nfsd4_encode_path()
2742 ncomponents--; in nfsd4_encode_path()
2749 dput(components[--ncomponents]); in nfsd4_encode_path()
2764 res = nfsd4_encode_path(xdr, &exp_ps->ex_path, path); in nfsd4_encode_fsloc_fsroot()
2778 struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs; in nfsd4_encode_fs_locations()
2780 status = nfsd4_encode_fsloc_fsroot(xdr, rqstp, &exp->ex_path); in nfsd4_encode_fs_locations()
2786 *p++ = cpu_to_be32(fslocs->locations_count); in nfsd4_encode_fs_locations()
2787 for (i=0; i<fslocs->locations_count; i++) { in nfsd4_encode_fs_locations()
2788 status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]); in nfsd4_encode_fs_locations()
2813 if (ace->whotype != NFS4_ACL_WHO_NAMED) in nfsd4_encode_aclname()
2814 return nfs4_acl_write_who(xdr, ace->whotype); in nfsd4_encode_aclname()
2815 else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP) in nfsd4_encode_aclname()
2816 return nfsd4_encode_group(xdr, rqstp, ace->who_gid); in nfsd4_encode_aclname()
2818 return nfsd4_encode_user(xdr, rqstp, ace->who_uid); in nfsd4_encode_aclname()
2892 struct path path = exp->ex_path; in nfsd4_get_mounted_on_ino()
2898 if (path.dentry != path.mnt->mnt_root) in nfsd4_get_mounted_on_ino()
2958 int starting_len = xdr->buf->len; in nfsd4_encode_fattr()
2971 struct nfsd4_compoundres *resp = rqstp->rq_resp; in nfsd4_encode_fattr()
2972 u32 minorversion = resp->cstate.minorversion; in nfsd4_encode_fattr()
2974 .mnt = exp->ex_path.mnt, in nfsd4_encode_fattr()
2982 if (exp->ex_fslocs.migrated) { in nfsd4_encode_fattr()
3022 if (err == -EOPNOTSUPP) in nfsd4_encode_fattr()
3024 else if (err == -EINVAL) { in nfsd4_encode_fattr()
3034 if (exp->ex_flags & NFSEXP_SECURITY_LABEL) in nfsd4_encode_fattr()
3038 err = -EOPNOTSUPP; in nfsd4_encode_fattr()
3041 if (err == -EOPNOTSUPP) in nfsd4_encode_fattr()
3053 attrlen_offset = xdr->buf->len; in nfsd4_encode_fattr()
3063 if (!IS_POSIXACL(dentry->d_inode)) in nfsd4_encode_fattr()
3099 if (exp->ex_flags & NFSEXP_NOSUBTREECHECK) in nfsd4_encode_fattr()
3139 if (exp->ex_fslocs.migrated) { in nfsd4_encode_fattr()
3144 p = xdr_encode_hyper(p, (u64)exp->ex_fsid); in nfsd4_encode_fattr()
3154 p = xdr_encode_opaque_fixed(p, exp->ex_uuid, in nfsd4_encode_fattr()
3169 *p++ = cpu_to_be32(nn->nfsd4_lease); in nfsd4_encode_fattr()
3191 *p++ = cpu_to_be32(acl->naces); in nfsd4_encode_fattr()
3193 for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) { in nfsd4_encode_fattr()
3197 *p++ = cpu_to_be32(ace->type); in nfsd4_encode_fattr()
3198 *p++ = cpu_to_be32(ace->flag); in nfsd4_encode_fattr()
3199 *p++ = cpu_to_be32(ace->access_mask & in nfsd4_encode_fattr()
3211 *p++ = cpu_to_be32(IS_POSIXACL(dentry->d_inode) ? in nfsd4_encode_fattr()
3239 p = xdr_reserve_space(xdr, fhp->fh_handle.fh_size + 4); in nfsd4_encode_fattr()
3242 p = xdr_encode_opaque(p, &fhp->fh_handle.fh_raw, in nfsd4_encode_fattr()
3243 fhp->fh_handle.fh_size); in nfsd4_encode_fattr()
3284 p = xdr_encode_hyper(p, exp->ex_path.mnt->mnt_sb->s_maxbytes); in nfsd4_encode_fattr()
3407 * crossmount and this is the root of a cross-mounted in nfsd4_encode_fattr()
3411 dentry == exp->ex_path.mnt->mnt_root) { in nfsd4_encode_fattr()
3420 status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types); in nfsd4_encode_fattr()
3426 status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types); in nfsd4_encode_fattr()
3468 *attrlen_p = cpu_to_be32(xdr->buf->len - attrlen_offset - XDR_UNIT); in nfsd4_encode_fattr()
3495 xdr->scratch.iov_len = 0; in svcxdr_init_encode_from_buffer()
3497 buf->head[0].iov_base = p; in svcxdr_init_encode_from_buffer()
3498 buf->head[0].iov_len = 0; in svcxdr_init_encode_from_buffer()
3499 buf->len = 0; in svcxdr_init_encode_from_buffer()
3500 xdr->buf = buf; in svcxdr_init_encode_from_buffer()
3501 xdr->iov = buf->head; in svcxdr_init_encode_from_buffer()
3502 xdr->p = p; in svcxdr_init_encode_from_buffer()
3503 xdr->end = (void *)p + bytes; in svcxdr_init_encode_from_buffer()
3504 buf->buflen = bytes; in svcxdr_init_encode_from_buffer()
3536 struct svc_export *exp = cd->rd_fhp->fh_export; in nfsd4_encode_dirent_fattr()
3541 dentry = lookup_positive_unlocked(name, cd->rd_fhp->fh_dentry, namlen); in nfsd4_encode_dirent_fattr()
3549 * as opposed to the cross-mounted file system. In such a case, in nfsd4_encode_dirent_fattr()
3556 if (!(exp->ex_flags & NFSEXP_V4ROOT) in nfsd4_encode_dirent_fattr()
3557 && !attributes_need_mount(cd->rd_bmval)) { in nfsd4_encode_dirent_fattr()
3566 err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp); in nfsd4_encode_dirent_fattr()
3571 nfserr = check_nfsd_access(exp, cd->rd_rqstp); in nfsd4_encode_dirent_fattr()
3577 nfserr = nfsd4_encode_fattr(xdr, NULL, exp, dentry, cd->rd_bmval, in nfsd4_encode_dirent_fattr()
3578 cd->rd_rqstp, ignore_crossmnt); in nfsd4_encode_dirent_fattr()
3608 struct xdr_stream *xdr = cd->xdr; in nfsd4_encode_dirent()
3609 int start_offset = xdr->buf->len; in nfsd4_encode_dirent()
3619 cd->common.err = nfs_ok; in nfsd4_encode_dirent()
3623 if (cd->cookie_offset) { in nfsd4_encode_dirent()
3625 write_bytes_to_xdr_buf(xdr->buf, cd->cookie_offset, in nfsd4_encode_dirent()
3633 cookie_offset = xdr->buf->len; in nfsd4_encode_dirent()
3658 if (cd->rd_fhp->fh_export->ex_flags & NFSEXP_V4ROOT) in nfsd4_encode_dirent()
3669 if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)) in nfsd4_encode_dirent()
3678 entry_bytes = xdr->buf->len - start_offset; in nfsd4_encode_dirent()
3679 if (entry_bytes > cd->rd_maxcount) in nfsd4_encode_dirent()
3681 cd->rd_maxcount -= entry_bytes; in nfsd4_encode_dirent()
3687 if (cd->rd_dircount) { in nfsd4_encode_dirent()
3689 if (name_and_cookie > cd->rd_dircount && cd->cookie_offset) in nfsd4_encode_dirent()
3691 cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie); in nfsd4_encode_dirent()
3692 if (!cd->rd_dircount) in nfsd4_encode_dirent()
3693 cd->rd_maxcount = 0; in nfsd4_encode_dirent()
3696 cd->cookie_offset = cookie_offset; in nfsd4_encode_dirent()
3698 cd->common.err = nfs_ok; in nfsd4_encode_dirent()
3702 cd->common.err = nfserr; in nfsd4_encode_dirent()
3703 return -EINVAL; in nfsd4_encode_dirent()
3714 memcpy(p, verf->data, sizeof(verf->data)); in nfsd4_encode_verifier4()
3738 *p++ = cpu_to_be32(sid->si_generation); in nfsd4_encode_stateid()
3739 p = xdr_encode_opaque_fixed(p, &sid->si_opaque, in nfsd4_encode_stateid()
3748 struct nfsd4_access *access = &u->access; in nfsd4_encode_access()
3749 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_access()
3755 *p++ = cpu_to_be32(access->ac_supported); in nfsd4_encode_access()
3756 *p++ = cpu_to_be32(access->ac_resp_access); in nfsd4_encode_access()
3763 struct nfsd4_bind_conn_to_session *bcts = &u->bind_conn_to_session; in nfsd4_encode_bind_conn_to_session()
3764 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_bind_conn_to_session()
3770 p = xdr_encode_opaque_fixed(p, bcts->sessionid.data, in nfsd4_encode_bind_conn_to_session()
3772 *p++ = cpu_to_be32(bcts->dir); in nfsd4_encode_bind_conn_to_session()
3782 struct nfsd4_close *close = &u->close; in nfsd4_encode_close()
3783 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_close()
3785 return nfsd4_encode_stateid(xdr, &close->cl_stateid); in nfsd4_encode_close()
3793 struct nfsd4_commit *commit = &u->commit; in nfsd4_encode_commit()
3795 return nfsd4_encode_verifier4(resp->xdr, &commit->co_verf); in nfsd4_encode_commit()
3802 struct nfsd4_create *create = &u->create; in nfsd4_encode_create()
3803 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_create()
3805 nfserr = nfsd4_encode_change_info4(xdr, &create->cr_cinfo); in nfsd4_encode_create()
3808 return nfsd4_encode_bitmap(xdr, create->cr_bmval[0], in nfsd4_encode_create()
3809 create->cr_bmval[1], create->cr_bmval[2]); in nfsd4_encode_create()
3816 struct nfsd4_getattr *getattr = &u->getattr; in nfsd4_encode_getattr()
3817 struct svc_fh *fhp = getattr->ga_fhp; in nfsd4_encode_getattr()
3818 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_getattr()
3820 return nfsd4_encode_fattr(xdr, fhp, fhp->fh_export, fhp->fh_dentry, in nfsd4_encode_getattr()
3821 getattr->ga_bmval, resp->rqstp, 0); in nfsd4_encode_getattr()
3828 struct svc_fh **fhpp = &u->getfh; in nfsd4_encode_getfh()
3829 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_getfh()
3834 len = fhp->fh_handle.fh_size; in nfsd4_encode_getfh()
3838 p = xdr_encode_opaque(p, &fhp->fh_handle.fh_raw, len); in nfsd4_encode_getfh()
3849 struct xdr_netobj *conf = &ld->ld_owner; in nfsd4_encode_lock_denied()
3853 p = xdr_reserve_space(xdr, 32 + XDR_LEN(conf->len)); in nfsd4_encode_lock_denied()
3859 if (conf->len) { in nfsd4_encode_lock_denied()
3860 kfree(conf->data); in nfsd4_encode_lock_denied()
3861 conf->len = 0; in nfsd4_encode_lock_denied()
3862 conf->data = NULL; in nfsd4_encode_lock_denied()
3867 p = xdr_encode_hyper(p, ld->ld_start); in nfsd4_encode_lock_denied()
3868 p = xdr_encode_hyper(p, ld->ld_length); in nfsd4_encode_lock_denied()
3869 *p++ = cpu_to_be32(ld->ld_type); in nfsd4_encode_lock_denied()
3870 if (conf->len) { in nfsd4_encode_lock_denied()
3871 p = xdr_encode_opaque_fixed(p, &ld->ld_clientid, 8); in nfsd4_encode_lock_denied()
3872 p = xdr_encode_opaque(p, conf->data, conf->len); in nfsd4_encode_lock_denied()
3873 kfree(conf->data); in nfsd4_encode_lock_denied()
3874 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */ in nfsd4_encode_lock_denied()
3885 struct nfsd4_lock *lock = &u->lock; in nfsd4_encode_lock()
3886 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_lock()
3889 nfserr = nfsd4_encode_stateid(xdr, &lock->lk_resp_stateid); in nfsd4_encode_lock()
3891 nfserr = nfsd4_encode_lock_denied(xdr, &lock->lk_denied); in nfsd4_encode_lock()
3900 struct nfsd4_lockt *lockt = &u->lockt; in nfsd4_encode_lockt()
3901 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_lockt()
3904 nfsd4_encode_lock_denied(xdr, &lockt->lt_denied); in nfsd4_encode_lockt()
3912 struct nfsd4_locku *locku = &u->locku; in nfsd4_encode_locku()
3913 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_locku()
3915 return nfsd4_encode_stateid(xdr, &locku->lu_stateid); in nfsd4_encode_locku()
3923 struct nfsd4_link *link = &u->link; in nfsd4_encode_link()
3924 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_link()
3926 return nfsd4_encode_change_info4(xdr, &link->li_cinfo); in nfsd4_encode_link()
3934 struct nfsd4_open *open = &u->open; in nfsd4_encode_open()
3935 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_open()
3938 nfserr = nfsd4_encode_stateid(xdr, &open->op_stateid); in nfsd4_encode_open()
3941 nfserr = nfsd4_encode_change_info4(xdr, &open->op_cinfo); in nfsd4_encode_open()
3944 if (xdr_stream_encode_u32(xdr, open->op_rflags) < 0) in nfsd4_encode_open()
3947 nfserr = nfsd4_encode_bitmap(xdr, open->op_bmval[0], open->op_bmval[1], in nfsd4_encode_open()
3948 open->op_bmval[2]); in nfsd4_encode_open()
3956 *p++ = cpu_to_be32(open->op_delegate_type); in nfsd4_encode_open()
3957 switch (open->op_delegate_type) { in nfsd4_encode_open()
3961 nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid); in nfsd4_encode_open()
3967 *p++ = cpu_to_be32(open->op_recall); in nfsd4_encode_open()
3978 nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid); in nfsd4_encode_open()
3985 *p++ = cpu_to_be32(open->op_recall); in nfsd4_encode_open()
4005 switch (open->op_why_no_deleg) { in nfsd4_encode_open()
4011 *p++ = cpu_to_be32(open->op_why_no_deleg); in nfsd4_encode_open()
4019 *p++ = cpu_to_be32(open->op_why_no_deleg); in nfsd4_encode_open()
4033 struct nfsd4_open_confirm *oc = &u->open_confirm; in nfsd4_encode_open_confirm()
4034 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_open_confirm()
4036 return nfsd4_encode_stateid(xdr, &oc->oc_resp_stateid); in nfsd4_encode_open_confirm()
4043 struct nfsd4_open_downgrade *od = &u->open_downgrade; in nfsd4_encode_open_downgrade()
4044 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_open_downgrade()
4046 return nfsd4_encode_stateid(xdr, &od->od_stateid); in nfsd4_encode_open_downgrade()
4059 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_splice_read()
4060 struct xdr_buf *buf = xdr->buf; in nfsd4_encode_splice_read()
4065 * Make sure there is room at the end of buf->head for in nfsd4_encode_splice_read()
4067 * to XDR-pad the payload. in nfsd4_encode_splice_read()
4069 if (xdr->iov != xdr->buf->head || xdr->end - xdr->p < 1) in nfsd4_encode_splice_read()
4072 nfserr = nfsd_splice_read(read->rd_rqstp, read->rd_fhp, in nfsd4_encode_splice_read()
4073 file, read->rd_offset, &maxcount, in nfsd4_encode_splice_read()
4074 &read->rd_eof); in nfsd4_encode_splice_read()
4075 read->rd_length = maxcount; in nfsd4_encode_splice_read()
4078 svcxdr_encode_opaque_pages(read->rd_rqstp, xdr, buf->pages, in nfsd4_encode_splice_read()
4079 buf->page_base, maxcount); in nfsd4_encode_splice_read()
4080 status = svc_encode_result_payload(read->rd_rqstp, in nfsd4_encode_splice_read()
4081 buf->head[0].iov_len, maxcount); in nfsd4_encode_splice_read()
4092 * manipulations are open-coded. in nfsd4_encode_splice_read()
4094 space_left = min_t(int, (void *)xdr->end - (void *)xdr->p, in nfsd4_encode_splice_read()
4095 buf->buflen - buf->len); in nfsd4_encode_splice_read()
4096 buf->buflen = buf->len + space_left; in nfsd4_encode_splice_read()
4097 xdr->end = (__be32 *)((void *)xdr->end + space_left); in nfsd4_encode_splice_read()
4107 buf->page_len = 0; in nfsd4_encode_splice_read()
4115 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_readv()
4116 unsigned int base = xdr->buf->page_len & ~PAGE_MASK; in nfsd4_encode_readv()
4117 unsigned int starting_len = xdr->buf->len; in nfsd4_encode_readv()
4124 nfserr = nfsd_iter_read(resp->rqstp, read->rd_fhp, file, in nfsd4_encode_readv()
4125 read->rd_offset, &maxcount, base, in nfsd4_encode_readv()
4126 &read->rd_eof); in nfsd4_encode_readv()
4127 read->rd_length = maxcount; in nfsd4_encode_readv()
4130 if (svc_encode_result_payload(resp->rqstp, starting_len, maxcount)) in nfsd4_encode_readv()
4134 write_bytes_to_xdr_buf(xdr->buf, starting_len + maxcount, &zero, in nfsd4_encode_readv()
4143 struct nfsd4_read *read = &u->read; in nfsd4_encode_read()
4144 bool splice_ok = test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags); in nfsd4_encode_read()
4146 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_read()
4148 int starting_len = xdr->buf->len; in nfsd4_encode_read()
4153 file = read->rd_nf->nf_file; in nfsd4_encode_read()
4160 if (resp->xdr->buf->page_len && splice_ok) { in nfsd4_encode_read()
4166 maxcount = min_t(unsigned long, read->rd_length, in nfsd4_encode_read()
4167 (xdr->buf->buflen - xdr->buf->len)); in nfsd4_encode_read()
4169 if (file->f_op->splice_read && splice_ok) in nfsd4_encode_read()
4178 p = xdr_encode_bool(p, read->rd_eof); in nfsd4_encode_read()
4179 *p = cpu_to_be32(read->rd_length); in nfsd4_encode_read()
4187 struct nfsd4_readlink *readlink = &u->readlink; in nfsd4_encode_readlink()
4189 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_readlink()
4190 int length_offset = xdr->buf->len; in nfsd4_encode_readlink()
4207 nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp, in nfsd4_encode_readlink()
4213 status = svc_encode_result_payload(readlink->rl_rqstp, length_offset, in nfsd4_encode_readlink()
4221 write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount, &zero, in nfsd4_encode_readlink()
4234 struct nfsd4_readdir *readdir = &u->readdir; in nfsd4_encode_readdir()
4239 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_readdir()
4240 int starting_len = xdr->buf->len; in nfsd4_encode_readdir()
4243 nfserr = nfsd4_encode_verifier4(xdr, &readdir->rd_verf); in nfsd4_encode_readdir()
4251 bytes_left = xdr->buf->buflen - xdr->buf->len in nfsd4_encode_readdir()
4252 - COMPOUND_ERR_SLACK_SPACE - 8; in nfsd4_encode_readdir()
4257 maxcount = svc_max_payload(resp->rqstp); in nfsd4_encode_readdir()
4258 maxcount = min_t(u32, readdir->rd_maxcount, maxcount); in nfsd4_encode_readdir()
4268 maxcount = min_t(int, maxcount-16, bytes_left); in nfsd4_encode_readdir()
4271 if (!readdir->rd_dircount) in nfsd4_encode_readdir()
4272 readdir->rd_dircount = svc_max_payload(resp->rqstp); in nfsd4_encode_readdir()
4274 readdir->xdr = xdr; in nfsd4_encode_readdir()
4275 readdir->rd_maxcount = maxcount; in nfsd4_encode_readdir()
4276 readdir->common.err = 0; in nfsd4_encode_readdir()
4277 readdir->cookie_offset = 0; in nfsd4_encode_readdir()
4279 offset = readdir->rd_cookie; in nfsd4_encode_readdir()
4280 nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp, in nfsd4_encode_readdir()
4282 &readdir->common, nfsd4_encode_dirent); in nfsd4_encode_readdir()
4284 readdir->common.err == nfserr_toosmall && in nfsd4_encode_readdir()
4285 xdr->buf->len == starting_len + 8) { in nfsd4_encode_readdir()
4287 if (maxcount - 16 < bytes_left) in nfsd4_encode_readdir()
4297 if (readdir->cookie_offset) { in nfsd4_encode_readdir()
4299 write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset, in nfsd4_encode_readdir()
4309 *p++ = htonl(readdir->common.err == nfserr_eof); in nfsd4_encode_readdir()
4321 struct nfsd4_remove *remove = &u->remove; in nfsd4_encode_remove()
4322 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_remove()
4324 return nfsd4_encode_change_info4(xdr, &remove->rm_cinfo); in nfsd4_encode_remove()
4331 struct nfsd4_rename *rename = &u->rename; in nfsd4_encode_rename()
4332 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_rename()
4334 nfserr = nfsd4_encode_change_info4(xdr, &rename->rn_sinfo); in nfsd4_encode_rename()
4337 return nfsd4_encode_change_info4(xdr, &rename->rn_tinfo); in nfsd4_encode_rename()
4349 if (exp->ex_nflavors) { in nfsd4_do_encode_secinfo()
4350 flavs = exp->ex_flavors; in nfsd4_do_encode_secinfo()
4351 nflavs = exp->ex_nflavors; in nfsd4_do_encode_secinfo()
4354 if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) { in nfsd4_do_encode_secinfo()
4358 } else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) { in nfsd4_do_encode_secinfo()
4361 = svcauth_gss_flavor(exp->ex_client); in nfsd4_do_encode_secinfo()
4365 = exp->ex_client->flavour->flavour; in nfsd4_do_encode_secinfo()
4412 struct nfsd4_secinfo *secinfo = &u->secinfo; in nfsd4_encode_secinfo()
4413 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_secinfo()
4415 return nfsd4_do_encode_secinfo(xdr, secinfo->si_exp); in nfsd4_encode_secinfo()
4422 struct nfsd4_secinfo_no_name *secinfo = &u->secinfo_no_name; in nfsd4_encode_secinfo_no_name()
4423 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_secinfo_no_name()
4425 return nfsd4_do_encode_secinfo(xdr, secinfo->sin_exp); in nfsd4_encode_secinfo_no_name()
4429 * The SETATTR encode routine is special -- it always encodes a bitmap,
4436 struct nfsd4_setattr *setattr = &u->setattr; in nfsd4_encode_setattr()
4437 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_setattr()
4451 *p++ = cpu_to_be32(setattr->sa_bmval[0]); in nfsd4_encode_setattr()
4452 *p++ = cpu_to_be32(setattr->sa_bmval[1]); in nfsd4_encode_setattr()
4453 *p++ = cpu_to_be32(setattr->sa_bmval[2]); in nfsd4_encode_setattr()
4462 struct nfsd4_setclientid *scd = &u->setclientid; in nfsd4_encode_setclientid()
4463 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_setclientid()
4466 nfserr = nfsd4_encode_clientid4(xdr, &scd->se_clientid); in nfsd4_encode_setclientid()
4469 nfserr = nfsd4_encode_verifier4(xdr, &scd->se_confirm); in nfsd4_encode_setclientid()
4490 struct nfsd4_write *write = &u->write; in nfsd4_encode_write()
4492 if (xdr_stream_encode_u32(resp->xdr, write->wr_bytes_written) < 0) in nfsd4_encode_write()
4494 if (xdr_stream_encode_u32(resp->xdr, write->wr_how_written) < 0) in nfsd4_encode_write()
4496 return nfsd4_encode_verifier4(resp->xdr, &write->wr_verifier); in nfsd4_encode_write()
4503 struct nfsd4_exchange_id *exid = &u->exchange_id; in nfsd4_encode_exchange_id()
4504 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_exchange_id()
4511 struct nfsd_net *nn = net_generic(SVC_NET(resp->rqstp), nfsd_net_id); in nfsd4_encode_exchange_id()
4513 major_id = nn->nfsd_name; in nfsd4_encode_exchange_id()
4514 major_id_sz = strlen(nn->nfsd_name); in nfsd4_encode_exchange_id()
4515 server_scope = nn->nfsd_name; in nfsd4_encode_exchange_id()
4516 server_scope_sz = strlen(nn->nfsd_name); in nfsd4_encode_exchange_id()
4518 if (nfsd4_encode_clientid4(xdr, &exid->clientid) != nfs_ok) in nfsd4_encode_exchange_id()
4520 if (xdr_stream_encode_u32(xdr, exid->seqid) < 0) in nfsd4_encode_exchange_id()
4522 if (xdr_stream_encode_u32(xdr, exid->flags) < 0) in nfsd4_encode_exchange_id()
4525 if (xdr_stream_encode_u32(xdr, exid->spa_how) < 0) in nfsd4_encode_exchange_id()
4527 switch (exid->spa_how) { in nfsd4_encode_exchange_id()
4533 exid->spo_must_enforce[0], in nfsd4_encode_exchange_id()
4534 exid->spo_must_enforce[1], in nfsd4_encode_exchange_id()
4535 exid->spo_must_enforce[2]); in nfsd4_encode_exchange_id()
4540 exid->spo_must_allow[0], in nfsd4_encode_exchange_id()
4541 exid->spo_must_allow[1], in nfsd4_encode_exchange_id()
4542 exid->spo_must_allow[2]); in nfsd4_encode_exchange_id()
4577 struct nfsd4_create_session *sess = &u->create_session; in nfsd4_encode_create_session()
4578 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_create_session()
4584 p = xdr_encode_opaque_fixed(p, sess->sessionid.data, in nfsd4_encode_create_session()
4586 *p++ = cpu_to_be32(sess->seqid); in nfsd4_encode_create_session()
4587 *p++ = cpu_to_be32(sess->flags); in nfsd4_encode_create_session()
4593 *p++ = cpu_to_be32(sess->fore_channel.maxreq_sz); in nfsd4_encode_create_session()
4594 *p++ = cpu_to_be32(sess->fore_channel.maxresp_sz); in nfsd4_encode_create_session()
4595 *p++ = cpu_to_be32(sess->fore_channel.maxresp_cached); in nfsd4_encode_create_session()
4596 *p++ = cpu_to_be32(sess->fore_channel.maxops); in nfsd4_encode_create_session()
4597 *p++ = cpu_to_be32(sess->fore_channel.maxreqs); in nfsd4_encode_create_session()
4598 *p++ = cpu_to_be32(sess->fore_channel.nr_rdma_attrs); in nfsd4_encode_create_session()
4600 if (sess->fore_channel.nr_rdma_attrs) { in nfsd4_encode_create_session()
4604 *p++ = cpu_to_be32(sess->fore_channel.rdma_attrs); in nfsd4_encode_create_session()
4611 *p++ = cpu_to_be32(sess->back_channel.maxreq_sz); in nfsd4_encode_create_session()
4612 *p++ = cpu_to_be32(sess->back_channel.maxresp_sz); in nfsd4_encode_create_session()
4613 *p++ = cpu_to_be32(sess->back_channel.maxresp_cached); in nfsd4_encode_create_session()
4614 *p++ = cpu_to_be32(sess->back_channel.maxops); in nfsd4_encode_create_session()
4615 *p++ = cpu_to_be32(sess->back_channel.maxreqs); in nfsd4_encode_create_session()
4616 *p++ = cpu_to_be32(sess->back_channel.nr_rdma_attrs); in nfsd4_encode_create_session()
4618 if (sess->back_channel.nr_rdma_attrs) { in nfsd4_encode_create_session()
4622 *p++ = cpu_to_be32(sess->back_channel.rdma_attrs); in nfsd4_encode_create_session()
4631 struct nfsd4_sequence *seq = &u->sequence; in nfsd4_encode_sequence()
4632 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_sequence()
4638 p = xdr_encode_opaque_fixed(p, seq->sessionid.data, in nfsd4_encode_sequence()
4640 *p++ = cpu_to_be32(seq->seqid); in nfsd4_encode_sequence()
4641 *p++ = cpu_to_be32(seq->slotid); in nfsd4_encode_sequence()
4643 *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_highest_slotid */ in nfsd4_encode_sequence()
4644 *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_target_highest_slotid */ in nfsd4_encode_sequence()
4645 *p++ = cpu_to_be32(seq->status_flags); in nfsd4_encode_sequence()
4647 resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */ in nfsd4_encode_sequence()
4655 struct nfsd4_test_stateid *test_stateid = &u->test_stateid; in nfsd4_encode_test_stateid()
4656 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_test_stateid()
4660 p = xdr_reserve_space(xdr, 4 + (4 * test_stateid->ts_num_ids)); in nfsd4_encode_test_stateid()
4663 *p++ = htonl(test_stateid->ts_num_ids); in nfsd4_encode_test_stateid()
4665 list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) { in nfsd4_encode_test_stateid()
4666 *p++ = stateid->ts_id_status; in nfsd4_encode_test_stateid()
4677 struct nfsd4_getdeviceinfo *gdev = &u->getdeviceinfo; in nfsd4_encode_getdeviceinfo()
4678 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_getdeviceinfo()
4680 u32 starting_len = xdr->buf->len, needed_len; in nfsd4_encode_getdeviceinfo()
4687 *p++ = cpu_to_be32(gdev->gd_layout_type); in nfsd4_encode_getdeviceinfo()
4689 ops = nfsd4_layout_ops[gdev->gd_layout_type]; in nfsd4_encode_getdeviceinfo()
4690 nfserr = ops->encode_getdeviceinfo(xdr, gdev); in nfsd4_encode_getdeviceinfo()
4697 if (xdr->buf->len + 4 > gdev->gd_maxcount) in nfsd4_encode_getdeviceinfo()
4702 if (gdev->gd_notify_types) { in nfsd4_encode_getdeviceinfo()
4707 *p++ = cpu_to_be32(gdev->gd_notify_types); in nfsd4_encode_getdeviceinfo()
4718 needed_len = xdr->buf->len + 4 /* notifications */; in nfsd4_encode_getdeviceinfo()
4731 struct nfsd4_layoutget *lgp = &u->layoutget; in nfsd4_encode_layoutget()
4732 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_layoutget()
4740 *p++ = cpu_to_be32(1); /* we always set return-on-close */ in nfsd4_encode_layoutget()
4741 *p++ = cpu_to_be32(lgp->lg_sid.si_generation); in nfsd4_encode_layoutget()
4742 p = xdr_encode_opaque_fixed(p, &lgp->lg_sid.si_opaque, in nfsd4_encode_layoutget()
4746 p = xdr_encode_hyper(p, lgp->lg_seg.offset); in nfsd4_encode_layoutget()
4747 p = xdr_encode_hyper(p, lgp->lg_seg.length); in nfsd4_encode_layoutget()
4748 *p++ = cpu_to_be32(lgp->lg_seg.iomode); in nfsd4_encode_layoutget()
4749 *p++ = cpu_to_be32(lgp->lg_layout_type); in nfsd4_encode_layoutget()
4751 ops = nfsd4_layout_ops[lgp->lg_layout_type]; in nfsd4_encode_layoutget()
4752 return ops->encode_layoutget(xdr, lgp); in nfsd4_encode_layoutget()
4759 struct nfsd4_layoutcommit *lcp = &u->layoutcommit; in nfsd4_encode_layoutcommit()
4760 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_layoutcommit()
4766 *p++ = cpu_to_be32(lcp->lc_size_chg); in nfsd4_encode_layoutcommit()
4767 if (lcp->lc_size_chg) { in nfsd4_encode_layoutcommit()
4771 p = xdr_encode_hyper(p, lcp->lc_newsize); in nfsd4_encode_layoutcommit()
4781 struct nfsd4_layoutreturn *lrp = &u->layoutreturn; in nfsd4_encode_layoutreturn()
4782 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_layoutreturn()
4788 *p++ = cpu_to_be32(lrp->lrs_present); in nfsd4_encode_layoutreturn()
4789 if (lrp->lrs_present) in nfsd4_encode_layoutreturn()
4790 return nfsd4_encode_stateid(xdr, &lrp->lr_sid); in nfsd4_encode_layoutreturn()
4800 p = xdr_reserve_space(resp->xdr, 4); in nfsd42_encode_write_res()
4809 nfserr = nfsd4_encode_stateid(resp->xdr, &write->cb_stateid); in nfsd42_encode_write_res()
4813 p = xdr_reserve_space(resp->xdr, 8 + 4 + NFS4_VERIFIER_SIZE); in nfsd42_encode_write_res()
4817 p = xdr_encode_hyper(p, write->wr_bytes_written); in nfsd42_encode_write_res()
4818 *p++ = cpu_to_be32(write->wr_stable_how); in nfsd42_encode_write_res()
4819 p = xdr_encode_opaque_fixed(p, write->wr_verifier.data, in nfsd42_encode_write_res()
4827 struct xdr_stream *xdr = resp->xdr; in nfsd42_encode_nl4_server()
4832 *p++ = cpu_to_be32(ns->nl4_type); in nfsd42_encode_nl4_server()
4834 switch (ns->nl4_type) { in nfsd42_encode_nl4_server()
4836 addr = &ns->u.nl4_addr; in nfsd42_encode_nl4_server()
4843 (XDR_QUADLEN(addr->netid_len) * 4) + in nfsd42_encode_nl4_server()
4845 (XDR_QUADLEN(addr->addr_len) * 4)); in nfsd42_encode_nl4_server()
4849 *p++ = cpu_to_be32(addr->netid_len); in nfsd42_encode_nl4_server()
4850 p = xdr_encode_opaque_fixed(p, addr->netid, in nfsd42_encode_nl4_server()
4851 addr->netid_len); in nfsd42_encode_nl4_server()
4852 *p++ = cpu_to_be32(addr->addr_len); in nfsd42_encode_nl4_server()
4853 p = xdr_encode_opaque_fixed(p, addr->addr, in nfsd42_encode_nl4_server()
4854 addr->addr_len); in nfsd42_encode_nl4_server()
4857 WARN_ON_ONCE(ns->nl4_type != NL4_NETADDR); in nfsd42_encode_nl4_server()
4868 struct nfsd4_copy *copy = &u->copy; in nfsd4_encode_copy()
4871 nfserr = nfsd42_encode_write_res(resp, ©->cp_res, in nfsd4_encode_copy()
4876 p = xdr_reserve_space(resp->xdr, 4 + 4); in nfsd4_encode_copy()
4886 struct nfsd4_offload_status *os = &u->offload_status; in nfsd4_encode_offload_status()
4887 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_offload_status()
4893 p = xdr_encode_hyper(p, os->count); in nfsd4_encode_offload_status()
4902 bool splice_ok = test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags); in nfsd4_encode_read_plus_data()
4903 struct file *file = read->rd_nf->nf_file; in nfsd4_encode_read_plus_data()
4904 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_read_plus_data()
4912 if (resp->xdr->buf->page_len && splice_ok) { in nfsd4_encode_read_plus_data()
4917 maxcount = min_t(unsigned long, read->rd_length, in nfsd4_encode_read_plus_data()
4918 (xdr->buf->buflen - xdr->buf->len)); in nfsd4_encode_read_plus_data()
4920 if (file->f_op->splice_read && splice_ok) in nfsd4_encode_read_plus_data()
4928 p = xdr_encode_hyper(p, read->rd_offset); in nfsd4_encode_read_plus_data()
4929 *p = cpu_to_be32(read->rd_length); in nfsd4_encode_read_plus_data()
4938 struct nfsd4_read *read = &u->read; in nfsd4_encode_read_plus()
4939 struct file *file = read->rd_nf->nf_file; in nfsd4_encode_read_plus()
4940 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_read_plus()
4941 int starting_len = xdr->buf->len; in nfsd4_encode_read_plus()
4954 read->rd_eof = read->rd_offset >= i_size_read(file_inode(file)); in nfsd4_encode_read_plus()
4955 if (read->rd_eof) in nfsd4_encode_read_plus()
4967 p = xdr_encode_bool(p, read->rd_eof); in nfsd4_encode_read_plus()
4976 struct nfsd4_copy_notify *cn = &u->copy_notify; in nfsd4_encode_copy_notify()
4977 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_copy_notify()
4989 p = xdr_encode_hyper(p, cn->cpn_sec); in nfsd4_encode_copy_notify()
4990 *p++ = cpu_to_be32(cn->cpn_nsec); in nfsd4_encode_copy_notify()
4993 nfserr = nfsd4_encode_stateid(xdr, &cn->cpn_cnr_stateid); in nfsd4_encode_copy_notify()
5004 nfserr = nfsd42_encode_nl4_server(resp, cn->cpn_src); in nfsd4_encode_copy_notify()
5012 struct nfsd4_seek *seek = &u->seek; in nfsd4_encode_seek()
5015 p = xdr_reserve_space(resp->xdr, 4 + 8); in nfsd4_encode_seek()
5016 *p++ = cpu_to_be32(seek->seek_eof); in nfsd4_encode_seek()
5017 p = xdr_encode_hyper(p, seek->seek_pos); in nfsd4_encode_seek()
5030 * Encode kmalloc-ed buffer in to XDR stream.
5039 ((void *)xdr->end - (void *)xdr->p)); in nfsd4_vbuf_to_stream()
5046 buflen -= cplen; in nfsd4_vbuf_to_stream()
5066 buflen -= PAGE_SIZE; in nfsd4_vbuf_to_stream()
5077 struct nfsd4_getxattr *getxattr = &u->getxattr; in nfsd4_encode_getxattr()
5078 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_getxattr()
5085 *p = cpu_to_be32(getxattr->getxa_len); in nfsd4_encode_getxattr()
5087 if (getxattr->getxa_len == 0) in nfsd4_encode_getxattr()
5090 err = nfsd4_vbuf_to_stream(xdr, getxattr->getxa_buf, in nfsd4_encode_getxattr()
5091 getxattr->getxa_len); in nfsd4_encode_getxattr()
5093 kvfree(getxattr->getxa_buf); in nfsd4_encode_getxattr()
5102 struct nfsd4_setxattr *setxattr = &u->setxattr; in nfsd4_encode_setxattr()
5103 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_setxattr()
5105 return nfsd4_encode_change_info4(xdr, &setxattr->setxa_cinfo); in nfsd4_encode_setxattr()
5115 u64 cookie = listxattrs->lsxa_cookie; in nfsd4_listxattr_validate_cookie()
5120 * XDR-encoded, in the return buffer, it's invalid. in nfsd4_listxattr_validate_cookie()
5122 if (cookie > (listxattrs->lsxa_len) / (XATTR_USER_PREFIX_LEN + 2)) in nfsd4_listxattr_validate_cookie()
5125 if (cookie > (listxattrs->lsxa_maxcount / in nfsd4_listxattr_validate_cookie()
5137 struct nfsd4_listxattrs *listxattrs = &u->listxattrs; in nfsd4_encode_listxattrs()
5138 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_listxattrs()
5158 cookie_offset = xdr->buf->len; in nfsd4_encode_listxattrs()
5167 left = listxattrs->lsxa_len; in nfsd4_encode_listxattrs()
5168 sp = listxattrs->lsxa_buf; in nfsd4_encode_listxattrs()
5171 xdrleft = listxattrs->lsxa_maxcount; in nfsd4_encode_listxattrs()
5182 slen -= XATTR_USER_PREFIX_LEN; in nfsd4_encode_listxattrs()
5196 left -= XATTR_USER_PREFIX_LEN; in nfsd4_encode_listxattrs()
5210 xdrleft -= xdrlen; in nfsd4_encode_listxattrs()
5214 left -= slen + 1; in nfsd4_encode_listxattrs()
5236 write_bytes_to_xdr_buf(xdr->buf, cookie_offset, &cookie, 8); in nfsd4_encode_listxattrs()
5238 write_bytes_to_xdr_buf(xdr->buf, count_offset, &tmp, 4); in nfsd4_encode_listxattrs()
5240 if (listxattrs->lsxa_len) in nfsd4_encode_listxattrs()
5241 kvfree(listxattrs->lsxa_buf); in nfsd4_encode_listxattrs()
5249 struct nfsd4_removexattr *removexattr = &u->removexattr; in nfsd4_encode_removexattr()
5250 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_removexattr()
5252 return nfsd4_encode_change_info4(xdr, &removexattr->rmxa_cinfo); in nfsd4_encode_removexattr()
5355 * - For NFS versions >=4.1, the size of the reply must stay within
5357 * - For all NFS versions, we must stay within limited preallocated
5367 struct xdr_buf *buf = &resp->rqstp->rq_res; in nfsd4_check_resp_size()
5368 struct nfsd4_slot *slot = resp->cstate.slot; in nfsd4_check_resp_size()
5370 if (buf->len + respsize <= buf->buflen) in nfsd4_check_resp_size()
5372 if (!nfsd4_has_session(&resp->cstate)) in nfsd4_check_resp_size()
5374 if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) { in nfsd4_check_resp_size()
5384 struct xdr_stream *xdr = resp->xdr; in nfsd4_encode_operation()
5385 struct nfs4_stateowner *so = resp->cstate.replay_owner; in nfsd4_encode_operation()
5386 struct svc_rqst *rqstp = resp->rqstp; in nfsd4_encode_operation()
5387 const struct nfsd4_operation *opdesc = op->opdesc; in nfsd4_encode_operation()
5395 *p++ = cpu_to_be32(op->opnum); in nfsd4_encode_operation()
5396 post_err_offset = xdr->buf->len; in nfsd4_encode_operation()
5398 if (op->opnum == OP_ILLEGAL) in nfsd4_encode_operation()
5400 if (op->status && opdesc && in nfsd4_encode_operation()
5401 !(opdesc->op_flags & OP_NONTRIVIAL_ERROR_ENCODE)) in nfsd4_encode_operation()
5403 BUG_ON(op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) || in nfsd4_encode_operation()
5404 !nfsd4_enc_ops[op->opnum]); in nfsd4_encode_operation()
5405 encoder = nfsd4_enc_ops[op->opnum]; in nfsd4_encode_operation()
5406 op->status = encoder(resp, op->status, &op->u); in nfsd4_encode_operation()
5407 if (op->status) in nfsd4_encode_operation()
5408 trace_nfsd_compound_encode_err(rqstp, op->opnum, op->status); in nfsd4_encode_operation()
5412 if (!op->status) { in nfsd4_encode_operation()
5416 op->status = nfsd4_check_resp_size(resp, space_needed); in nfsd4_encode_operation()
5418 if (op->status == nfserr_resource && nfsd4_has_session(&resp->cstate)) { in nfsd4_encode_operation()
5419 struct nfsd4_slot *slot = resp->cstate.slot; in nfsd4_encode_operation()
5421 if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) in nfsd4_encode_operation()
5422 op->status = nfserr_rep_too_big_to_cache; in nfsd4_encode_operation()
5424 op->status = nfserr_rep_too_big; in nfsd4_encode_operation()
5426 if (op->status == nfserr_resource || in nfsd4_encode_operation()
5427 op->status == nfserr_rep_too_big || in nfsd4_encode_operation()
5428 op->status == nfserr_rep_too_big_to_cache) { in nfsd4_encode_operation()
5434 * bug if we had to do this on a non-idempotent op: in nfsd4_encode_operation()
5440 int len = xdr->buf->len - post_err_offset; in nfsd4_encode_operation()
5442 so->so_replay.rp_status = op->status; in nfsd4_encode_operation()
5443 so->so_replay.rp_buflen = len; in nfsd4_encode_operation()
5444 read_bytes_from_xdr_buf(xdr->buf, post_err_offset, in nfsd4_encode_operation()
5445 so->so_replay.rp_buf, len); in nfsd4_encode_operation()
5448 *p = op->status; in nfsd4_encode_operation()
5450 if (opdesc && opdesc->op_release) in nfsd4_encode_operation()
5451 opdesc->op_release(&op->u); in nfsd4_encode_operation()
5457 rqstp->rq_next_page = xdr->page_ptr + 1; in nfsd4_encode_operation()
5463 * XDR note: do not encode rp->rp_buflen: the buffer contains the
5470 struct nfs4_replay *rp = op->replay; in nfsd4_encode_replay()
5472 p = xdr_reserve_space(xdr, 8 + rp->rp_buflen); in nfsd4_encode_replay()
5477 *p++ = cpu_to_be32(op->opnum); in nfsd4_encode_replay()
5478 *p++ = rp->rp_status; /* already xdr'ed */ in nfsd4_encode_replay()
5480 p = xdr_encode_opaque_fixed(p, rp->rp_buf, rp->rp_buflen); in nfsd4_encode_replay()
5485 struct nfsd4_compoundargs *args = rqstp->rq_argp; in nfsd4_release_compoundargs()
5487 if (args->ops != args->iops) { in nfsd4_release_compoundargs()
5488 vfree(args->ops); in nfsd4_release_compoundargs()
5489 args->ops = args->iops; in nfsd4_release_compoundargs()
5491 while (args->to_free) { in nfsd4_release_compoundargs()
5492 struct svcxdr_tmpbuf *tb = args->to_free; in nfsd4_release_compoundargs()
5493 args->to_free = tb->next; in nfsd4_release_compoundargs()
5501 struct nfsd4_compoundargs *args = rqstp->rq_argp; in nfs4svc_decode_compoundargs()
5504 args->to_free = NULL; in nfs4svc_decode_compoundargs()
5506 args->xdr = xdr; in nfs4svc_decode_compoundargs()
5507 args->ops = args->iops; in nfs4svc_decode_compoundargs()
5508 args->rqstp = rqstp; in nfs4svc_decode_compoundargs()
5516 struct nfsd4_compoundres *resp = rqstp->rq_resp; in nfs4svc_encode_compoundres()
5523 p = resp->statusp; in nfs4svc_encode_compoundres()
5525 *p++ = resp->cstate.status; in nfs4svc_encode_compoundres()
5526 *p++ = htonl(resp->taglen); in nfs4svc_encode_compoundres()
5527 memcpy(p, resp->tag, resp->taglen); in nfs4svc_encode_compoundres()
5528 p += XDR_QUADLEN(resp->taglen); in nfs4svc_encode_compoundres()
5529 *p++ = htonl(resp->opcnt); in nfs4svc_encode_compoundres()