Lines Matching +full:set +full:- +full:aces
2 * Server-side XDR for NFSv4
119 if (!(x = (p==argp->tmp || p == argp->tmpp) ? \
135 if (nbytes <= (u32)((char *)argp->end - (char *)argp->p)) { \
136 p = argp->p; \
137 argp->p += XDR_QUADLEN(nbytes); \
147 argp->p = page_address(argp->pagelist[0]); in next_decode_page()
148 argp->pagelist++; in next_decode_page()
149 if (argp->pagelen < PAGE_SIZE) { in next_decode_page()
150 argp->end = argp->p + XDR_QUADLEN(argp->pagelen); in next_decode_page()
151 argp->pagelen = 0; in next_decode_page()
153 argp->end = argp->p + (PAGE_SIZE>>2); in next_decode_page()
154 argp->pagelen -= PAGE_SIZE; in next_decode_page()
163 unsigned int avail = (char *)argp->end - (char *)argp->p; in read_buf()
166 if (argp->pagelen == 0) { in read_buf()
167 struct kvec *vec = &argp->rqstp->rq_arg.tail[0]; in read_buf()
169 if (!argp->tail) { in read_buf()
170 argp->tail = true; in read_buf()
171 avail = vec->iov_len; in read_buf()
172 argp->p = vec->iov_base; in read_buf()
173 argp->end = vec->iov_base + avail; in read_buf()
179 p = argp->p; in read_buf()
180 argp->p += XDR_QUADLEN(nbytes); in read_buf()
184 if (avail + argp->pagelen < nbytes) in read_buf()
189 if (nbytes <= sizeof(argp->tmp)) in read_buf()
190 p = argp->tmp; in read_buf()
192 kfree(argp->tmpp); in read_buf()
193 p = argp->tmpp = kmalloc(nbytes, GFP_KERNEL); in read_buf()
203 memcpy(p, argp->p, avail); in read_buf()
205 memcpy(((char*)p)+avail, argp->p, (nbytes - avail)); in read_buf()
206 argp->p += XDR_QUADLEN(nbytes - avail); in read_buf()
212 unsigned int this = (char *)argp->end - (char *)argp->p; in compoundargs_bytes_left()
214 return this + argp->pagelen; in compoundargs_bytes_left()
219 return (clid->cl_boot == 0) && (clid->cl_id == 0); in zero_clientid()
223 * svcxdr_tmpalloc - allocate memory to be freed after compound processing
238 tb->next = argp->to_free; in svcxdr_tmpalloc()
239 argp->to_free = tb; in svcxdr_tmpalloc()
240 return tb->buf; in svcxdr_tmpalloc()
245 * as null-terminated strings.
247 * Note null-terminating in place usually isn't safe since the
271 * READ_BUF(write->wr_buflen); in svcxdr_construct_vector()
272 * SAVEMEM(write->wr_buf, write->wr_buflen); in svcxdr_construct_vector()
274 avail = (char *)argp->end - (char *)argp->p; in svcxdr_construct_vector()
275 if (avail + argp->pagelen < buflen) { in svcxdr_construct_vector()
280 head->iov_base = argp->p; in svcxdr_construct_vector()
281 head->iov_len = avail; in svcxdr_construct_vector()
282 *pagelist = argp->pagelist; in svcxdr_construct_vector()
286 len -= avail; in svcxdr_construct_vector()
289 argp->pagelist += pages; in svcxdr_construct_vector()
290 argp->pagelen -= pages * PAGE_SIZE; in svcxdr_construct_vector()
291 len -= pages * PAGE_SIZE; in svcxdr_construct_vector()
295 argp->p += XDR_QUADLEN(len); in svcxdr_construct_vector()
301 * savemem - duplicate a chunk of memory for later processing
327 p = xdr_decode_hyper(p, &tv->tv_sec); in nfsd4_decode_time()
328 tv->tv_nsec = be32_to_cpup(p++); in nfsd4_decode_time()
329 if (tv->tv_nsec >= (u32)1000000000) in nfsd4_decode_time()
371 iattr->ia_valid = 0; in nfsd4_decode_fattr()
378 if (nfsd_attrs_supported(argp->minorversion, bmval)) in nfsd4_decode_fattr()
389 p = xdr_decode_hyper(p, &iattr->ia_size); in nfsd4_decode_fattr()
390 iattr->ia_valid |= ATTR_SIZE; in nfsd4_decode_fattr()
401 * Even with 4-byte names there wouldn't be in nfsd4_decode_fattr()
402 * space for that many aces; something fishy is in nfsd4_decode_fattr()
411 (*acl)->naces = nace; in nfsd4_decode_fattr()
412 for (ace = (*acl)->aces; ace < (*acl)->aces + nace; ace++) { in nfsd4_decode_fattr()
414 ace->type = be32_to_cpup(p++); in nfsd4_decode_fattr()
415 ace->flag = be32_to_cpup(p++); in nfsd4_decode_fattr()
416 ace->access_mask = be32_to_cpup(p++); in nfsd4_decode_fattr()
421 ace->whotype = nfs4_acl_get_whotype(buf, dummy32); in nfsd4_decode_fattr()
423 if (ace->whotype != NFS4_ACL_WHO_NAMED) in nfsd4_decode_fattr()
425 else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP) in nfsd4_decode_fattr()
426 status = nfsd_map_name_to_gid(argp->rqstp, in nfsd4_decode_fattr()
427 buf, dummy32, &ace->who_gid); in nfsd4_decode_fattr()
429 status = nfsd_map_name_to_uid(argp->rqstp, in nfsd4_decode_fattr()
430 buf, dummy32, &ace->who_uid); in nfsd4_decode_fattr()
439 iattr->ia_mode = be32_to_cpup(p++); in nfsd4_decode_fattr()
440 iattr->ia_mode &= (S_IFMT | S_IALLUGO); in nfsd4_decode_fattr()
441 iattr->ia_valid |= ATTR_MODE; in nfsd4_decode_fattr()
450 if ((status = nfsd_map_name_to_uid(argp->rqstp, buf, dummy32, &iattr->ia_uid))) in nfsd4_decode_fattr()
452 iattr->ia_valid |= ATTR_UID; in nfsd4_decode_fattr()
461 if ((status = nfsd_map_name_to_gid(argp->rqstp, buf, dummy32, &iattr->ia_gid))) in nfsd4_decode_fattr()
463 iattr->ia_valid |= ATTR_GID; in nfsd4_decode_fattr()
472 status = nfsd4_decode_time(argp, &iattr->ia_atime); in nfsd4_decode_fattr()
475 iattr->ia_valid |= (ATTR_ATIME | ATTR_ATIME_SET); in nfsd4_decode_fattr()
478 iattr->ia_valid |= ATTR_ATIME; in nfsd4_decode_fattr()
491 status = nfsd4_decode_time(argp, &iattr->ia_mtime); in nfsd4_decode_fattr()
494 iattr->ia_valid |= (ATTR_MTIME | ATTR_MTIME_SET); in nfsd4_decode_fattr()
497 iattr->ia_valid |= ATTR_MTIME; in nfsd4_decode_fattr()
504 label->len = 0; in nfsd4_decode_fattr()
521 label->len = dummy32; in nfsd4_decode_fattr()
522 label->data = svcxdr_dupstr(argp, buf, dummy32); in nfsd4_decode_fattr()
523 if (!label->data) in nfsd4_decode_fattr()
532 iattr->ia_mode = dummy32 & (S_IFMT | S_IALLUGO); in nfsd4_decode_fattr()
535 iattr->ia_valid |= ATTR_MODE; in nfsd4_decode_fattr()
549 sid->si_generation = be32_to_cpup(p++); in nfsd4_decode_stateid()
550 COPYMEM(&sid->si_opaque, sizeof(stateid_opaque_t)); in nfsd4_decode_stateid()
561 access->ac_req_access = be32_to_cpup(p++); in nfsd4_decode_access()
569 struct user_namespace *userns = nfsd_user_namespace(argp->rqstp); in nfsd4_decode_cb_sec()
579 cbs->flavor = (u32)(-1); in nfsd4_decode_cb_sec()
582 cbs->flavor = 0; in nfsd4_decode_cb_sec()
589 if (cbs->flavor == (u32)(-1)) in nfsd4_decode_cb_sec()
590 cbs->flavor = RPC_AUTH_NULL; in nfsd4_decode_cb_sec()
611 if (cbs->flavor == (u32)(-1)) { in nfsd4_decode_cb_sec()
615 cbs->uid = kuid; in nfsd4_decode_cb_sec()
616 cbs->gid = kgid; in nfsd4_decode_cb_sec()
617 cbs->flavor = RPC_AUTH_UNIX; in nfsd4_decode_cb_sec()
652 bc->bc_cb_program = be32_to_cpup(p++); in nfsd4_decode_backchannel_ctl()
653 nfsd4_decode_cb_sec(argp, &bc->bc_cb_sec); in nfsd4_decode_backchannel_ctl()
663 COPYMEM(bcts->sessionid.data, NFS4_MAX_SESSIONID_LEN); in nfsd4_decode_bind_conn_to_session()
664 bcts->dir = be32_to_cpup(p++); in nfsd4_decode_bind_conn_to_session()
676 close->cl_seqid = be32_to_cpup(p++); in nfsd4_decode_close()
677 return nfsd4_decode_stateid(argp, &close->cl_stateid); in nfsd4_decode_close()
689 p = xdr_decode_hyper(p, &commit->co_offset); in nfsd4_decode_commit()
690 commit->co_count = be32_to_cpup(p++); in nfsd4_decode_commit()
701 create->cr_type = be32_to_cpup(p++); in nfsd4_decode_create()
702 switch (create->cr_type) { in nfsd4_decode_create()
705 create->cr_datalen = be32_to_cpup(p++); in nfsd4_decode_create()
706 READ_BUF(create->cr_datalen); in nfsd4_decode_create()
707 create->cr_data = svcxdr_dupstr(argp, p, create->cr_datalen); in nfsd4_decode_create()
708 if (!create->cr_data) in nfsd4_decode_create()
714 create->cr_specdata1 = be32_to_cpup(p++); in nfsd4_decode_create()
715 create->cr_specdata2 = be32_to_cpup(p++); in nfsd4_decode_create()
725 create->cr_namelen = be32_to_cpup(p++); in nfsd4_decode_create()
726 READ_BUF(create->cr_namelen); in nfsd4_decode_create()
727 SAVEMEM(create->cr_name, create->cr_namelen); in nfsd4_decode_create()
728 if ((status = check_filename(create->cr_name, create->cr_namelen))) in nfsd4_decode_create()
731 status = nfsd4_decode_fattr(argp, create->cr_bmval, &create->cr_iattr, in nfsd4_decode_create()
732 &create->cr_acl, &create->cr_label, in nfsd4_decode_create()
733 &create->cr_umask); in nfsd4_decode_create()
743 return nfsd4_decode_stateid(argp, &dr->dr_stateid); in nfsd4_decode_delegreturn()
749 return nfsd4_decode_bitmap(argp, getattr->ga_bmval); in nfsd4_decode_getattr()
758 link->li_namelen = be32_to_cpup(p++); in nfsd4_decode_link()
759 READ_BUF(link->li_namelen); in nfsd4_decode_link()
760 SAVEMEM(link->li_name, link->li_namelen); in nfsd4_decode_link()
761 if ((status = check_filename(link->li_name, link->li_namelen))) in nfsd4_decode_link()
776 lock->lk_type = be32_to_cpup(p++); in nfsd4_decode_lock()
777 if ((lock->lk_type < NFS4_READ_LT) || (lock->lk_type > NFS4_WRITEW_LT)) in nfsd4_decode_lock()
779 lock->lk_reclaim = be32_to_cpup(p++); in nfsd4_decode_lock()
780 p = xdr_decode_hyper(p, &lock->lk_offset); in nfsd4_decode_lock()
781 p = xdr_decode_hyper(p, &lock->lk_length); in nfsd4_decode_lock()
782 lock->lk_is_new = be32_to_cpup(p++); in nfsd4_decode_lock()
784 if (lock->lk_is_new) { in nfsd4_decode_lock()
786 lock->lk_new_open_seqid = be32_to_cpup(p++); in nfsd4_decode_lock()
787 status = nfsd4_decode_stateid(argp, &lock->lk_new_open_stateid); in nfsd4_decode_lock()
791 lock->lk_new_lock_seqid = be32_to_cpup(p++); in nfsd4_decode_lock()
792 COPYMEM(&lock->lk_new_clientid, sizeof(clientid_t)); in nfsd4_decode_lock()
793 lock->lk_new_owner.len = be32_to_cpup(p++); in nfsd4_decode_lock()
794 READ_BUF(lock->lk_new_owner.len); in nfsd4_decode_lock()
795 READMEM(lock->lk_new_owner.data, lock->lk_new_owner.len); in nfsd4_decode_lock()
797 status = nfsd4_decode_stateid(argp, &lock->lk_old_lock_stateid); in nfsd4_decode_lock()
801 lock->lk_old_lock_seqid = be32_to_cpup(p++); in nfsd4_decode_lock()
813 lockt->lt_type = be32_to_cpup(p++); in nfsd4_decode_lockt()
814 if((lockt->lt_type < NFS4_READ_LT) || (lockt->lt_type > NFS4_WRITEW_LT)) in nfsd4_decode_lockt()
816 p = xdr_decode_hyper(p, &lockt->lt_offset); in nfsd4_decode_lockt()
817 p = xdr_decode_hyper(p, &lockt->lt_length); in nfsd4_decode_lockt()
818 COPYMEM(&lockt->lt_clientid, 8); in nfsd4_decode_lockt()
819 lockt->lt_owner.len = be32_to_cpup(p++); in nfsd4_decode_lockt()
820 READ_BUF(lockt->lt_owner.len); in nfsd4_decode_lockt()
821 READMEM(lockt->lt_owner.data, lockt->lt_owner.len); in nfsd4_decode_lockt()
832 locku->lu_type = be32_to_cpup(p++); in nfsd4_decode_locku()
833 if ((locku->lu_type < NFS4_READ_LT) || (locku->lu_type > NFS4_WRITEW_LT)) in nfsd4_decode_locku()
835 locku->lu_seqid = be32_to_cpup(p++); in nfsd4_decode_locku()
836 status = nfsd4_decode_stateid(argp, &locku->lu_stateid); in nfsd4_decode_locku()
840 p = xdr_decode_hyper(p, &locku->lu_offset); in nfsd4_decode_locku()
841 p = xdr_decode_hyper(p, &locku->lu_length); in nfsd4_decode_locku()
852 lookup->lo_len = be32_to_cpup(p++); in nfsd4_decode_lookup()
853 READ_BUF(lookup->lo_len); in nfsd4_decode_lookup()
854 SAVEMEM(lookup->lo_name, lookup->lo_len); in nfsd4_decode_lookup()
855 if ((status = check_filename(lookup->lo_name, lookup->lo_len))) in nfsd4_decode_lookup()
884 if (!argp->minorversion) in nfsd4_decode_share_access()
933 o->len = be32_to_cpup(p++); in nfsd4_decode_opaque()
935 if (o->len == 0 || o->len > NFS4_OPAQUE_LIMIT) in nfsd4_decode_opaque()
938 READ_BUF(o->len); in nfsd4_decode_opaque()
939 SAVEMEM(o->data, o->len); in nfsd4_decode_opaque()
951 memset(open->op_bmval, 0, sizeof(open->op_bmval)); in nfsd4_decode_open()
952 open->op_iattr.ia_valid = 0; in nfsd4_decode_open()
953 open->op_openowner = NULL; in nfsd4_decode_open()
955 open->op_xdr_error = 0; in nfsd4_decode_open()
958 open->op_seqid = be32_to_cpup(p++); in nfsd4_decode_open()
960 status = nfsd4_decode_share_access(argp, &open->op_share_access, in nfsd4_decode_open()
961 &open->op_deleg_want, &dummy); in nfsd4_decode_open()
964 status = nfsd4_decode_share_deny(argp, &open->op_share_deny); in nfsd4_decode_open()
968 COPYMEM(&open->op_clientid, sizeof(clientid_t)); in nfsd4_decode_open()
969 status = nfsd4_decode_opaque(argp, &open->op_owner); in nfsd4_decode_open()
973 open->op_create = be32_to_cpup(p++); in nfsd4_decode_open()
974 switch (open->op_create) { in nfsd4_decode_open()
979 open->op_createmode = be32_to_cpup(p++); in nfsd4_decode_open()
980 switch (open->op_createmode) { in nfsd4_decode_open()
983 status = nfsd4_decode_fattr(argp, open->op_bmval, in nfsd4_decode_open()
984 &open->op_iattr, &open->op_acl, &open->op_label, in nfsd4_decode_open()
985 &open->op_umask); in nfsd4_decode_open()
991 COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE); in nfsd4_decode_open()
994 if (argp->minorversion < 1) in nfsd4_decode_open()
997 COPYMEM(open->op_verf.data, NFS4_VERIFIER_SIZE); in nfsd4_decode_open()
998 status = nfsd4_decode_fattr(argp, open->op_bmval, in nfsd4_decode_open()
999 &open->op_iattr, &open->op_acl, &open->op_label, in nfsd4_decode_open()
1000 &open->op_umask); in nfsd4_decode_open()
1014 open->op_claim_type = be32_to_cpup(p++); in nfsd4_decode_open()
1015 switch (open->op_claim_type) { in nfsd4_decode_open()
1019 open->op_fname.len = be32_to_cpup(p++); in nfsd4_decode_open()
1020 READ_BUF(open->op_fname.len); in nfsd4_decode_open()
1021 SAVEMEM(open->op_fname.data, open->op_fname.len); in nfsd4_decode_open()
1022 if ((status = check_filename(open->op_fname.data, open->op_fname.len))) in nfsd4_decode_open()
1027 open->op_delegate_type = be32_to_cpup(p++); in nfsd4_decode_open()
1030 status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid); in nfsd4_decode_open()
1034 open->op_fname.len = be32_to_cpup(p++); in nfsd4_decode_open()
1035 READ_BUF(open->op_fname.len); in nfsd4_decode_open()
1036 SAVEMEM(open->op_fname.data, open->op_fname.len); in nfsd4_decode_open()
1037 if ((status = check_filename(open->op_fname.data, open->op_fname.len))) in nfsd4_decode_open()
1042 if (argp->minorversion < 1) in nfsd4_decode_open()
1047 if (argp->minorversion < 1) in nfsd4_decode_open()
1049 status = nfsd4_decode_stateid(argp, &open->op_delegate_stateid); in nfsd4_decode_open()
1065 if (argp->minorversion >= 1) in nfsd4_decode_open_confirm()
1068 status = nfsd4_decode_stateid(argp, &open_conf->oc_req_stateid); in nfsd4_decode_open_confirm()
1072 open_conf->oc_seqid = be32_to_cpup(p++); in nfsd4_decode_open_confirm()
1082 status = nfsd4_decode_stateid(argp, &open_down->od_stateid); in nfsd4_decode_open_downgrade()
1086 open_down->od_seqid = be32_to_cpup(p++); in nfsd4_decode_open_downgrade()
1087 status = nfsd4_decode_share_access(argp, &open_down->od_share_access, in nfsd4_decode_open_downgrade()
1088 &open_down->od_deleg_want, NULL); in nfsd4_decode_open_downgrade()
1091 status = nfsd4_decode_share_deny(argp, &open_down->od_share_deny); in nfsd4_decode_open_downgrade()
1103 putfh->pf_fhlen = be32_to_cpup(p++); in nfsd4_decode_putfh()
1104 if (putfh->pf_fhlen > NFS4_FHSIZE) in nfsd4_decode_putfh()
1106 READ_BUF(putfh->pf_fhlen); in nfsd4_decode_putfh()
1107 SAVEMEM(putfh->pf_fhval, putfh->pf_fhlen); in nfsd4_decode_putfh()
1115 if (argp->minorversion == 0) in nfsd4_decode_putpubfh()
1125 status = nfsd4_decode_stateid(argp, &read->rd_stateid); in nfsd4_decode_read()
1129 p = xdr_decode_hyper(p, &read->rd_offset); in nfsd4_decode_read()
1130 read->rd_length = be32_to_cpup(p++); in nfsd4_decode_read()
1141 p = xdr_decode_hyper(p, &readdir->rd_cookie); in nfsd4_decode_readdir()
1142 COPYMEM(readdir->rd_verf.data, sizeof(readdir->rd_verf.data)); in nfsd4_decode_readdir()
1143 readdir->rd_dircount = be32_to_cpup(p++); in nfsd4_decode_readdir()
1144 readdir->rd_maxcount = be32_to_cpup(p++); in nfsd4_decode_readdir()
1145 if ((status = nfsd4_decode_bitmap(argp, readdir->rd_bmval))) in nfsd4_decode_readdir()
1157 remove->rm_namelen = be32_to_cpup(p++); in nfsd4_decode_remove()
1158 READ_BUF(remove->rm_namelen); in nfsd4_decode_remove()
1159 SAVEMEM(remove->rm_name, remove->rm_namelen); in nfsd4_decode_remove()
1160 if ((status = check_filename(remove->rm_name, remove->rm_namelen))) in nfsd4_decode_remove()
1172 rename->rn_snamelen = be32_to_cpup(p++); in nfsd4_decode_rename()
1173 READ_BUF(rename->rn_snamelen); in nfsd4_decode_rename()
1174 SAVEMEM(rename->rn_sname, rename->rn_snamelen); in nfsd4_decode_rename()
1176 rename->rn_tnamelen = be32_to_cpup(p++); in nfsd4_decode_rename()
1177 READ_BUF(rename->rn_tnamelen); in nfsd4_decode_rename()
1178 SAVEMEM(rename->rn_tname, rename->rn_tnamelen); in nfsd4_decode_rename()
1179 if ((status = check_filename(rename->rn_sname, rename->rn_snamelen))) in nfsd4_decode_rename()
1181 if ((status = check_filename(rename->rn_tname, rename->rn_tnamelen))) in nfsd4_decode_rename()
1192 if (argp->minorversion >= 1) in nfsd4_decode_renew()
1208 secinfo->si_namelen = be32_to_cpup(p++); in nfsd4_decode_secinfo()
1209 READ_BUF(secinfo->si_namelen); in nfsd4_decode_secinfo()
1210 SAVEMEM(secinfo->si_name, secinfo->si_namelen); in nfsd4_decode_secinfo()
1211 status = check_filename(secinfo->si_name, secinfo->si_namelen); in nfsd4_decode_secinfo()
1224 sin->sin_style = be32_to_cpup(p++); in nfsd4_decode_secinfo_no_name()
1233 status = nfsd4_decode_stateid(argp, &setattr->sa_stateid); in nfsd4_decode_setattr()
1236 return nfsd4_decode_fattr(argp, setattr->sa_bmval, &setattr->sa_iattr, in nfsd4_decode_setattr()
1237 &setattr->sa_acl, &setattr->sa_label, NULL); in nfsd4_decode_setattr()
1245 if (argp->minorversion >= 1) in nfsd4_decode_setclientid()
1249 COPYMEM(setclientid->se_verf.data, NFS4_VERIFIER_SIZE); in nfsd4_decode_setclientid()
1251 status = nfsd4_decode_opaque(argp, &setclientid->se_name); in nfsd4_decode_setclientid()
1255 setclientid->se_callback_prog = be32_to_cpup(p++); in nfsd4_decode_setclientid()
1256 setclientid->se_callback_netid_len = be32_to_cpup(p++); in nfsd4_decode_setclientid()
1257 READ_BUF(setclientid->se_callback_netid_len); in nfsd4_decode_setclientid()
1258 SAVEMEM(setclientid->se_callback_netid_val, setclientid->se_callback_netid_len); in nfsd4_decode_setclientid()
1260 setclientid->se_callback_addr_len = be32_to_cpup(p++); in nfsd4_decode_setclientid()
1262 READ_BUF(setclientid->se_callback_addr_len); in nfsd4_decode_setclientid()
1263 SAVEMEM(setclientid->se_callback_addr_val, setclientid->se_callback_addr_len); in nfsd4_decode_setclientid()
1265 setclientid->se_callback_ident = be32_to_cpup(p++); in nfsd4_decode_setclientid()
1275 if (argp->minorversion >= 1) in nfsd4_decode_setclientid_confirm()
1279 COPYMEM(&scd_c->sc_clientid, 8); in nfsd4_decode_setclientid_confirm()
1280 COPYMEM(&scd_c->sc_confirm, NFS4_VERIFIER_SIZE); in nfsd4_decode_setclientid_confirm()
1291 if ((status = nfsd4_decode_bitmap(argp, verify->ve_bmval))) in nfsd4_decode_verify()
1298 verify->ve_attrlen = be32_to_cpup(p++); in nfsd4_decode_verify()
1299 READ_BUF(verify->ve_attrlen); in nfsd4_decode_verify()
1300 SAVEMEM(verify->ve_attrval, verify->ve_attrlen); in nfsd4_decode_verify()
1310 status = nfsd4_decode_stateid(argp, &write->wr_stateid); in nfsd4_decode_write()
1314 p = xdr_decode_hyper(p, &write->wr_offset); in nfsd4_decode_write()
1315 write->wr_stable_how = be32_to_cpup(p++); in nfsd4_decode_write()
1316 if (write->wr_stable_how > NFS_FILE_SYNC) in nfsd4_decode_write()
1318 write->wr_buflen = be32_to_cpup(p++); in nfsd4_decode_write()
1320 status = svcxdr_construct_vector(argp, &write->wr_head, in nfsd4_decode_write()
1321 &write->wr_pagelist, write->wr_buflen); in nfsd4_decode_write()
1333 if (argp->minorversion >= 1) in nfsd4_decode_release_lockowner()
1337 COPYMEM(&rlockowner->rl_clientid, sizeof(clientid_t)); in nfsd4_decode_release_lockowner()
1338 rlockowner->rl_owner.len = be32_to_cpup(p++); in nfsd4_decode_release_lockowner()
1339 READ_BUF(rlockowner->rl_owner.len); in nfsd4_decode_release_lockowner()
1340 READMEM(rlockowner->rl_owner.data, rlockowner->rl_owner.len); in nfsd4_decode_release_lockowner()
1342 if (argp->minorversion && !zero_clientid(&rlockowner->rl_clientid)) in nfsd4_decode_release_lockowner()
1355 COPYMEM(exid->verifier.data, NFS4_VERIFIER_SIZE); in nfsd4_decode_exchange_id()
1357 status = nfsd4_decode_opaque(argp, &exid->clname); in nfsd4_decode_exchange_id()
1362 exid->flags = be32_to_cpup(p++); in nfsd4_decode_exchange_id()
1366 exid->spa_how = be32_to_cpup(p++); in nfsd4_decode_exchange_id()
1367 switch (exid->spa_how) { in nfsd4_decode_exchange_id()
1373 exid->spo_must_enforce); in nfsd4_decode_exchange_id()
1377 status = nfsd4_decode_bitmap(argp, exid->spo_must_allow); in nfsd4_decode_exchange_id()
1396 while (tmp--) { in nfsd4_decode_exchange_id()
1406 while (tmp--) { in nfsd4_decode_exchange_id()
1427 status = nfsd4_decode_opaque(argp, &exid->nii_domain); in nfsd4_decode_exchange_id()
1432 status = nfsd4_decode_opaque(argp, &exid->nii_name); in nfsd4_decode_exchange_id()
1437 status = nfsd4_decode_time(argp, &exid->nii_time); in nfsd4_decode_exchange_id()
1451 COPYMEM(&sess->clientid, 8); in nfsd4_decode_create_session()
1452 sess->seqid = be32_to_cpup(p++); in nfsd4_decode_create_session()
1453 sess->flags = be32_to_cpup(p++); in nfsd4_decode_create_session()
1458 sess->fore_channel.maxreq_sz = be32_to_cpup(p++); in nfsd4_decode_create_session()
1459 sess->fore_channel.maxresp_sz = be32_to_cpup(p++); in nfsd4_decode_create_session()
1460 sess->fore_channel.maxresp_cached = be32_to_cpup(p++); in nfsd4_decode_create_session()
1461 sess->fore_channel.maxops = be32_to_cpup(p++); in nfsd4_decode_create_session()
1462 sess->fore_channel.maxreqs = be32_to_cpup(p++); in nfsd4_decode_create_session()
1463 sess->fore_channel.nr_rdma_attrs = be32_to_cpup(p++); in nfsd4_decode_create_session()
1464 if (sess->fore_channel.nr_rdma_attrs == 1) { in nfsd4_decode_create_session()
1466 sess->fore_channel.rdma_attrs = be32_to_cpup(p++); in nfsd4_decode_create_session()
1467 } else if (sess->fore_channel.nr_rdma_attrs > 1) { in nfsd4_decode_create_session()
1475 sess->back_channel.maxreq_sz = be32_to_cpup(p++); in nfsd4_decode_create_session()
1476 sess->back_channel.maxresp_sz = be32_to_cpup(p++); in nfsd4_decode_create_session()
1477 sess->back_channel.maxresp_cached = be32_to_cpup(p++); in nfsd4_decode_create_session()
1478 sess->back_channel.maxops = be32_to_cpup(p++); in nfsd4_decode_create_session()
1479 sess->back_channel.maxreqs = be32_to_cpup(p++); in nfsd4_decode_create_session()
1480 sess->back_channel.nr_rdma_attrs = be32_to_cpup(p++); in nfsd4_decode_create_session()
1481 if (sess->back_channel.nr_rdma_attrs == 1) { in nfsd4_decode_create_session()
1483 sess->back_channel.rdma_attrs = be32_to_cpup(p++); in nfsd4_decode_create_session()
1484 } else if (sess->back_channel.nr_rdma_attrs > 1) { in nfsd4_decode_create_session()
1490 sess->callback_prog = be32_to_cpup(p++); in nfsd4_decode_create_session()
1491 nfsd4_decode_cb_sec(argp, &sess->cb_sec); in nfsd4_decode_create_session()
1501 COPYMEM(destroy_session->sessionid.data, NFS4_MAX_SESSIONID_LEN); in nfsd4_decode_destroy_session()
1513 free_stateid->fr_stateid.si_generation = be32_to_cpup(p++); in nfsd4_decode_free_stateid()
1514 COPYMEM(&free_stateid->fr_stateid.si_opaque, sizeof(stateid_opaque_t)); in nfsd4_decode_free_stateid()
1526 COPYMEM(seq->sessionid.data, NFS4_MAX_SESSIONID_LEN); in nfsd4_decode_sequence()
1527 seq->seqid = be32_to_cpup(p++); in nfsd4_decode_sequence()
1528 seq->slotid = be32_to_cpup(p++); in nfsd4_decode_sequence()
1529 seq->maxslots = be32_to_cpup(p++); in nfsd4_decode_sequence()
1530 seq->cachethis = be32_to_cpup(p++); in nfsd4_decode_sequence()
1543 test_stateid->ts_num_ids = ntohl(*p++); in nfsd4_decode_test_stateid()
1545 INIT_LIST_HEAD(&test_stateid->ts_stateid_list); in nfsd4_decode_test_stateid()
1547 for (i = 0; i < test_stateid->ts_num_ids; i++) { in nfsd4_decode_test_stateid()
1550 status = nfserrno(-ENOMEM); in nfsd4_decode_test_stateid()
1554 INIT_LIST_HEAD(&stateid->ts_id_list); in nfsd4_decode_test_stateid()
1555 list_add_tail(&stateid->ts_id_list, &test_stateid->ts_stateid_list); in nfsd4_decode_test_stateid()
1557 status = nfsd4_decode_stateid(argp, &stateid->ts_id_stateid); in nfsd4_decode_test_stateid()
1576 COPYMEM(&dc->clientid, 8); in nfsd4_decode_destroy_clientid()
1586 rc->rca_one_fs = be32_to_cpup(p++); in nfsd4_decode_reclaim_complete()
1600 COPYMEM(&gdev->gd_devid, sizeof(struct nfsd4_deviceid)); in nfsd4_decode_getdeviceinfo()
1601 gdev->gd_layout_type = be32_to_cpup(p++); in nfsd4_decode_getdeviceinfo()
1602 gdev->gd_maxcount = be32_to_cpup(p++); in nfsd4_decode_getdeviceinfo()
1608 gdev->gd_notify_types = be32_to_cpup(p++); in nfsd4_decode_getdeviceinfo()
1626 lgp->lg_signal = be32_to_cpup(p++); in nfsd4_decode_layoutget()
1627 lgp->lg_layout_type = be32_to_cpup(p++); in nfsd4_decode_layoutget()
1628 lgp->lg_seg.iomode = be32_to_cpup(p++); in nfsd4_decode_layoutget()
1629 p = xdr_decode_hyper(p, &lgp->lg_seg.offset); in nfsd4_decode_layoutget()
1630 p = xdr_decode_hyper(p, &lgp->lg_seg.length); in nfsd4_decode_layoutget()
1631 p = xdr_decode_hyper(p, &lgp->lg_minlength); in nfsd4_decode_layoutget()
1633 status = nfsd4_decode_stateid(argp, &lgp->lg_sid); in nfsd4_decode_layoutget()
1638 lgp->lg_maxcount = be32_to_cpup(p++); in nfsd4_decode_layoutget()
1651 p = xdr_decode_hyper(p, &lcp->lc_seg.offset); in nfsd4_decode_layoutcommit()
1652 p = xdr_decode_hyper(p, &lcp->lc_seg.length); in nfsd4_decode_layoutcommit()
1653 lcp->lc_reclaim = be32_to_cpup(p++); in nfsd4_decode_layoutcommit()
1655 status = nfsd4_decode_stateid(argp, &lcp->lc_sid); in nfsd4_decode_layoutcommit()
1660 lcp->lc_newoffset = be32_to_cpup(p++); in nfsd4_decode_layoutcommit()
1661 if (lcp->lc_newoffset) { in nfsd4_decode_layoutcommit()
1663 p = xdr_decode_hyper(p, &lcp->lc_last_wr); in nfsd4_decode_layoutcommit()
1665 lcp->lc_last_wr = 0; in nfsd4_decode_layoutcommit()
1669 status = nfsd4_decode_time(argp, &lcp->lc_mtime); in nfsd4_decode_layoutcommit()
1673 lcp->lc_mtime.tv_nsec = UTIME_NOW; in nfsd4_decode_layoutcommit()
1676 lcp->lc_layout_type = be32_to_cpup(p++); in nfsd4_decode_layoutcommit()
1682 lcp->lc_up_len = be32_to_cpup(p++); in nfsd4_decode_layoutcommit()
1683 if (lcp->lc_up_len > 0) { in nfsd4_decode_layoutcommit()
1684 READ_BUF(lcp->lc_up_len); in nfsd4_decode_layoutcommit()
1685 READMEM(lcp->lc_up_layout, lcp->lc_up_len); in nfsd4_decode_layoutcommit()
1698 lrp->lr_reclaim = be32_to_cpup(p++); in nfsd4_decode_layoutreturn()
1699 lrp->lr_layout_type = be32_to_cpup(p++); in nfsd4_decode_layoutreturn()
1700 lrp->lr_seg.iomode = be32_to_cpup(p++); in nfsd4_decode_layoutreturn()
1701 lrp->lr_return_type = be32_to_cpup(p++); in nfsd4_decode_layoutreturn()
1702 if (lrp->lr_return_type == RETURN_FILE) { in nfsd4_decode_layoutreturn()
1704 p = xdr_decode_hyper(p, &lrp->lr_seg.offset); in nfsd4_decode_layoutreturn()
1705 p = xdr_decode_hyper(p, &lrp->lr_seg.length); in nfsd4_decode_layoutreturn()
1707 status = nfsd4_decode_stateid(argp, &lrp->lr_sid); in nfsd4_decode_layoutreturn()
1712 lrp->lrf_body_len = be32_to_cpup(p++); in nfsd4_decode_layoutreturn()
1713 if (lrp->lrf_body_len > 0) { in nfsd4_decode_layoutreturn()
1714 READ_BUF(lrp->lrf_body_len); in nfsd4_decode_layoutreturn()
1715 READMEM(lrp->lrf_body, lrp->lrf_body_len); in nfsd4_decode_layoutreturn()
1718 lrp->lr_seg.offset = 0; in nfsd4_decode_layoutreturn()
1719 lrp->lr_seg.length = NFS4_MAX_UINT64; in nfsd4_decode_layoutreturn()
1732 status = nfsd4_decode_stateid(argp, &fallocate->falloc_stateid); in nfsd4_decode_fallocate()
1737 p = xdr_decode_hyper(p, &fallocate->falloc_offset); in nfsd4_decode_fallocate()
1738 xdr_decode_hyper(p, &fallocate->falloc_length); in nfsd4_decode_fallocate()
1748 status = nfsd4_decode_stateid(argp, &clone->cl_src_stateid); in nfsd4_decode_clone()
1751 status = nfsd4_decode_stateid(argp, &clone->cl_dst_stateid); in nfsd4_decode_clone()
1756 p = xdr_decode_hyper(p, &clone->cl_src_pos); in nfsd4_decode_clone()
1757 p = xdr_decode_hyper(p, &clone->cl_dst_pos); in nfsd4_decode_clone()
1758 p = xdr_decode_hyper(p, &clone->cl_count); in nfsd4_decode_clone()
1769 ns->nl4_type = be32_to_cpup(p++); in nfsd4_decode_nl4_server()
1771 /* currently support for 1 inter-server source server */ in nfsd4_decode_nl4_server()
1772 switch (ns->nl4_type) { in nfsd4_decode_nl4_server()
1774 naddr = &ns->u.nl4_addr; in nfsd4_decode_nl4_server()
1777 naddr->netid_len = be32_to_cpup(p++); in nfsd4_decode_nl4_server()
1778 if (naddr->netid_len > RPCBIND_MAXNETIDLEN) in nfsd4_decode_nl4_server()
1781 READ_BUF(naddr->netid_len + 4); /* 4 for uaddr len */ in nfsd4_decode_nl4_server()
1782 COPYMEM(naddr->netid, naddr->netid_len); in nfsd4_decode_nl4_server()
1784 naddr->addr_len = be32_to_cpup(p++); in nfsd4_decode_nl4_server()
1785 if (naddr->addr_len > RPCBIND_MAXUADDRLEN) in nfsd4_decode_nl4_server()
1788 READ_BUF(naddr->addr_len); in nfsd4_decode_nl4_server()
1789 COPYMEM(naddr->addr, naddr->addr_len); in nfsd4_decode_nl4_server()
1804 status = nfsd4_decode_stateid(argp, ©->cp_src_stateid); in nfsd4_decode_copy()
1807 status = nfsd4_decode_stateid(argp, ©->cp_dst_stateid); in nfsd4_decode_copy()
1812 p = xdr_decode_hyper(p, ©->cp_src_pos); in nfsd4_decode_copy()
1813 p = xdr_decode_hyper(p, ©->cp_dst_pos); in nfsd4_decode_copy()
1814 p = xdr_decode_hyper(p, ©->cp_count); in nfsd4_decode_copy()
1816 copy->cp_synchronous = be32_to_cpup(p++); in nfsd4_decode_copy()
1820 copy->cp_intra = false; in nfsd4_decode_copy()
1821 if (count == 0) { /* intra-server copy */ in nfsd4_decode_copy()
1822 copy->cp_intra = true; in nfsd4_decode_copy()
1827 status = nfsd4_decode_nl4_server(argp, ©->cp_src); in nfsd4_decode_copy()
1833 return nfserrno(-ENOMEM); in nfsd4_decode_copy()
1834 for (i = 0; i < count - 1; i++) { in nfsd4_decode_copy()
1851 return nfsd4_decode_stateid(argp, &os->stateid); in nfsd4_decode_offload_status()
1860 status = nfsd4_decode_stateid(argp, &cn->cpn_src_stateid); in nfsd4_decode_copy_notify()
1863 return nfsd4_decode_nl4_server(argp, &cn->cpn_dst); in nfsd4_decode_copy_notify()
1871 status = nfsd4_decode_stateid(argp, &seek->seek_stateid); in nfsd4_decode_seek()
1876 p = xdr_decode_hyper(p, &seek->seek_offset); in nfsd4_decode_seek()
1877 seek->seek_whence = be32_to_cpup(p); in nfsd4_decode_seek()
1887 * is 64k). Since there is no kvec- or page-based interface to xattrs,
1902 if (buflen <= head->iov_len) { in nfsd4_vbuf_from_vector()
1907 *bufp = head->iov_base; in nfsd4_vbuf_from_vector()
1916 memcpy(dp, head->iov_base, head->iov_len); in nfsd4_vbuf_from_vector()
1917 buflen -= head->iov_len; in nfsd4_vbuf_from_vector()
1918 dp += head->iov_len; in nfsd4_vbuf_from_vector()
1924 buflen -= len; in nfsd4_vbuf_from_vector()
1948 if (namelen > (XATTR_NAME_MAX - XATTR_USER_PREFIX_LEN)) in nfsd4_decode_xattr_name()
1970 while (cnt-- > 0) { in nfsd4_decode_xattr_name()
1983 * A GETXATTR op request comes without a length specifier. We just set the
1995 status = nfsd4_decode_xattr_name(argp, &getxattr->getxa_name); in nfsd4_decode_getxattr()
1999 maxcount = svc_max_payload(argp->rqstp); in nfsd4_decode_getxattr()
2002 getxattr->getxa_len = maxcount; in nfsd4_decode_getxattr()
2021 setxattr->setxa_flags = flags; in nfsd4_decode_setxattr()
2023 status = nfsd4_decode_xattr_name(argp, &setxattr->setxa_name); in nfsd4_decode_setxattr()
2027 maxcount = svc_max_payload(argp->rqstp); in nfsd4_decode_setxattr()
2035 setxattr->setxa_len = size; in nfsd4_decode_setxattr()
2042 &setxattr->setxa_buf, size); in nfsd4_decode_setxattr()
2056 p = xdr_decode_hyper(p, &listxattrs->lsxa_cookie); in nfsd4_decode_listxattrs()
2062 if (listxattrs->lsxa_cookie >= in nfsd4_decode_listxattrs()
2071 maxcount = min(maxcount, svc_max_payload(argp->rqstp)); in nfsd4_decode_listxattrs()
2072 listxattrs->lsxa_maxcount = maxcount; in nfsd4_decode_listxattrs()
2081 return nfsd4_decode_xattr_name(argp, &removexattr->rmxa_name); in nfsd4_decode_removexattr()
2190 if (op->opnum < FIRST_NFS4_OP) in nfsd4_opnum_in_range()
2192 else if (argp->minorversion == 0 && op->opnum > LAST_NFS40_OP) in nfsd4_opnum_in_range()
2194 else if (argp->minorversion == 1 && op->opnum > LAST_NFS41_OP) in nfsd4_opnum_in_range()
2196 else if (argp->minorversion == 2 && op->opnum > LAST_NFS42_OP) in nfsd4_opnum_in_range()
2207 int auth_slack= argp->rqstp->rq_auth_slack; in nfsd4_decode_compound()
2214 argp->taglen = be32_to_cpup(p++); in nfsd4_decode_compound()
2215 READ_BUF(argp->taglen); in nfsd4_decode_compound()
2216 SAVEMEM(argp->tag, argp->taglen); in nfsd4_decode_compound()
2218 argp->minorversion = be32_to_cpup(p++); in nfsd4_decode_compound()
2219 argp->opcnt = be32_to_cpup(p++); in nfsd4_decode_compound()
2220 max_reply += 4 + (XDR_QUADLEN(argp->taglen) << 2); in nfsd4_decode_compound()
2222 if (argp->taglen > NFSD4_MAX_TAGLEN) in nfsd4_decode_compound()
2227 * nfsd4_proc can handle this is an NFS-level error. in nfsd4_decode_compound()
2229 if (argp->opcnt > NFSD_MAX_OPS_PER_COMPOUND) in nfsd4_decode_compound()
2232 if (argp->opcnt > ARRAY_SIZE(argp->iops)) { in nfsd4_decode_compound()
2233 argp->ops = kzalloc(argp->opcnt * sizeof(*argp->ops), GFP_KERNEL); in nfsd4_decode_compound()
2234 if (!argp->ops) { in nfsd4_decode_compound()
2235 argp->ops = argp->iops; in nfsd4_decode_compound()
2241 if (argp->minorversion > NFSD_SUPPORTED_MINOR_VERSION) in nfsd4_decode_compound()
2242 argp->opcnt = 0; in nfsd4_decode_compound()
2244 for (i = 0; i < argp->opcnt; i++) { in nfsd4_decode_compound()
2245 op = &argp->ops[i]; in nfsd4_decode_compound()
2246 op->replay = NULL; in nfsd4_decode_compound()
2249 op->opnum = be32_to_cpup(p++); in nfsd4_decode_compound()
2252 op->status = nfsd4_dec_ops[op->opnum](argp, &op->u); in nfsd4_decode_compound()
2254 op->opnum = OP_ILLEGAL; in nfsd4_decode_compound()
2255 op->status = nfserr_op_illegal; in nfsd4_decode_compound()
2257 op->opdesc = OPDESC(op); in nfsd4_decode_compound()
2264 if (op->opnum == OP_READ || op->opnum == OP_READ_PLUS) { in nfsd4_decode_compound()
2266 readbytes += nfsd4_max_reply(argp->rqstp, op); in nfsd4_decode_compound()
2268 max_reply += nfsd4_max_reply(argp->rqstp, op); in nfsd4_decode_compound()
2275 if (op->opnum == OP_LOCK || op->opnum == OP_LOCKT) in nfsd4_decode_compound()
2278 if (op->status) { in nfsd4_decode_compound()
2279 argp->opcnt = i+1; in nfsd4_decode_compound()
2284 if (argp->minorversion) in nfsd4_decode_compound()
2286 svc_reserve(argp->rqstp, max_reply + readbytes); in nfsd4_decode_compound()
2287 argp->rqstp->rq_cachetype = cachethis ? RC_REPLBUFF : RC_NOCACHE; in nfsd4_decode_compound()
2289 if (readcount > 1 || max_reply > PAGE_SIZE - auth_slack) in nfsd4_decode_compound()
2290 clear_bit(RQ_SPLICE_OK, &argp->rqstp->rq_flags); in nfsd4_decode_compound()
2298 if (exp->ex_flags & NFSEXP_V4ROOT) { in encode_change()
2299 *p++ = cpu_to_be32(convert_to_wallclock(exp->cd->flush_time)); in encode_change()
2304 *p++ = cpu_to_be32(stat->ctime.tv_sec); in encode_change()
2305 *p++ = cpu_to_be32(stat->ctime.tv_nsec); in encode_change()
2326 ns = max_t(u32, NSEC_PER_SEC/HZ, inode->i_sb->s_time_gran); in encode_time_delta()
2337 *p++ = cpu_to_be32(c->atomic); in encode_cinfo()
2338 if (c->change_supported) { in encode_cinfo()
2339 p = xdr_encode_hyper(p, c->before_change); in encode_cinfo()
2340 p = xdr_encode_hyper(p, c->after_change); in encode_cinfo()
2342 *p++ = cpu_to_be32(c->before_ctime_sec); in encode_cinfo()
2343 *p++ = cpu_to_be32(c->before_ctime_nsec); in encode_cinfo()
2344 *p++ = cpu_to_be32(c->after_ctime_sec); in encode_cinfo()
2345 *p++ = cpu_to_be32(c->after_ctime_nsec); in encode_cinfo()
2365 pathlen_offset = xdr->buf->len; in nfsd4_encode_components_esc()
2390 strlen = end - str; in nfsd4_encode_components_esc()
2406 write_bytes_to_xdr_buf(xdr->buf, pathlen_offset, &pathlen, 4); in nfsd4_encode_components_esc()
2427 status = nfsd4_encode_components_esc(xdr, ':', location->hosts, in nfsd4_encode_fs_location4()
2431 status = nfsd4_encode_components(xdr, '/', location->path); in nfsd4_encode_fs_location4()
2459 if (cur.dentry == cur.mnt->mnt_root) { in nfsd4_encode_path()
2483 struct dentry *dentry = components[ncomponents - 1]; in nfsd4_encode_path()
2486 spin_lock(&dentry->d_lock); in nfsd4_encode_path()
2487 len = dentry->d_name.len; in nfsd4_encode_path()
2490 spin_unlock(&dentry->d_lock); in nfsd4_encode_path()
2493 p = xdr_encode_opaque(p, dentry->d_name.name, len); in nfsd4_encode_path()
2495 spin_unlock(&dentry->d_lock); in nfsd4_encode_path()
2497 ncomponents--; in nfsd4_encode_path()
2504 dput(components[--ncomponents]); in nfsd4_encode_path()
2519 res = nfsd4_encode_path(xdr, &exp_ps->ex_path, path); in nfsd4_encode_fsloc_fsroot()
2533 struct nfsd4_fs_locations *fslocs = &exp->ex_fslocs; in nfsd4_encode_fs_locations()
2535 status = nfsd4_encode_fsloc_fsroot(xdr, rqstp, &exp->ex_path); in nfsd4_encode_fs_locations()
2541 *p++ = cpu_to_be32(fslocs->locations_count); in nfsd4_encode_fs_locations()
2542 for (i=0; i<fslocs->locations_count; i++) { in nfsd4_encode_fs_locations()
2543 status = nfsd4_encode_fs_location4(xdr, &fslocs->locations[i]); in nfsd4_encode_fs_locations()
2568 if (ace->whotype != NFS4_ACL_WHO_NAMED) in nfsd4_encode_aclname()
2569 return nfs4_acl_write_who(xdr, ace->whotype); in nfsd4_encode_aclname()
2570 else if (ace->flag & NFS4_ACE_IDENTIFIER_GROUP) in nfsd4_encode_aclname()
2571 return nfsd4_encode_group(xdr, rqstp, ace->who_gid); in nfsd4_encode_aclname()
2573 return nfsd4_encode_user(xdr, rqstp, ace->who_uid); in nfsd4_encode_aclname()
2647 struct path path = exp->ex_path; in get_parent_attributes()
2652 if (path.dentry != path.mnt->mnt_root) in get_parent_attributes()
2710 int starting_len = xdr->buf->len; in nfsd4_encode_fattr()
2724 struct nfsd4_compoundres *resp = rqstp->rq_resp; in nfsd4_encode_fattr()
2725 u32 minorversion = resp->cstate.minorversion; in nfsd4_encode_fattr()
2727 .mnt = exp->ex_path.mnt, in nfsd4_encode_fattr()
2735 if (exp->ex_fslocs.migrated) { in nfsd4_encode_fattr()
2765 if (err == -EOPNOTSUPP) in nfsd4_encode_fattr()
2767 else if (err == -EINVAL) { in nfsd4_encode_fattr()
2777 if (exp->ex_flags & NFSEXP_SECURITY_LABEL) in nfsd4_encode_fattr()
2781 err = -EOPNOTSUPP; in nfsd4_encode_fattr()
2784 if (err == -EOPNOTSUPP) in nfsd4_encode_fattr()
2796 attrlen_offset = xdr->buf->len; in nfsd4_encode_fattr()
2807 if (!IS_POSIXACL(dentry->d_inode)) in nfsd4_encode_fattr()
2843 if (exp->ex_flags & NFSEXP_NOSUBTREECHECK) in nfsd4_encode_fattr()
2883 if (exp->ex_fslocs.migrated) { in nfsd4_encode_fattr()
2888 p = xdr_encode_hyper(p, (u64)exp->ex_fsid); in nfsd4_encode_fattr()
2898 p = xdr_encode_opaque_fixed(p, exp->ex_uuid, in nfsd4_encode_fattr()
2913 *p++ = cpu_to_be32(nn->nfsd4_lease); in nfsd4_encode_fattr()
2935 *p++ = cpu_to_be32(acl->naces); in nfsd4_encode_fattr()
2937 for (ace = acl->aces; ace < acl->aces + acl->naces; ace++) { in nfsd4_encode_fattr()
2941 *p++ = cpu_to_be32(ace->type); in nfsd4_encode_fattr()
2942 *p++ = cpu_to_be32(ace->flag); in nfsd4_encode_fattr()
2943 *p++ = cpu_to_be32(ace->access_mask & in nfsd4_encode_fattr()
2955 *p++ = cpu_to_be32(IS_POSIXACL(dentry->d_inode) ? in nfsd4_encode_fattr()
2983 p = xdr_reserve_space(xdr, fhp->fh_handle.fh_size + 4); in nfsd4_encode_fattr()
2986 p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base, in nfsd4_encode_fattr()
2987 fhp->fh_handle.fh_size); in nfsd4_encode_fattr()
3028 p = xdr_encode_hyper(p, exp->ex_path.mnt->mnt_sb->s_maxbytes); in nfsd4_encode_fattr()
3153 * and this is the root of a cross-mounted filesystem. in nfsd4_encode_fattr()
3156 dentry == exp->ex_path.mnt->mnt_root) { in nfsd4_encode_fattr()
3166 status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types); in nfsd4_encode_fattr()
3172 status = nfsd4_encode_layout_types(xdr, exp->ex_layout_types); in nfsd4_encode_fattr()
3225 attrlen = htonl(xdr->buf->len - attrlen_offset - 4); in nfsd4_encode_fattr()
3226 write_bytes_to_xdr_buf(xdr->buf, attrlen_offset, &attrlen, 4); in nfsd4_encode_fattr()
3253 xdr->scratch.iov_len = 0; in svcxdr_init_encode_from_buffer()
3255 buf->head[0].iov_base = p; in svcxdr_init_encode_from_buffer()
3256 buf->head[0].iov_len = 0; in svcxdr_init_encode_from_buffer()
3257 buf->len = 0; in svcxdr_init_encode_from_buffer()
3258 xdr->buf = buf; in svcxdr_init_encode_from_buffer()
3259 xdr->iov = buf->head; in svcxdr_init_encode_from_buffer()
3260 xdr->p = p; in svcxdr_init_encode_from_buffer()
3261 xdr->end = (void *)p + bytes; in svcxdr_init_encode_from_buffer()
3262 buf->buflen = bytes; in svcxdr_init_encode_from_buffer()
3294 struct svc_export *exp = cd->rd_fhp->fh_export; in nfsd4_encode_dirent_fattr()
3299 dentry = lookup_positive_unlocked(name, cd->rd_fhp->fh_dentry, namlen); in nfsd4_encode_dirent_fattr()
3307 * as opposed to the cross-mounted file system. In such a case, in nfsd4_encode_dirent_fattr()
3314 if (!(exp->ex_flags & NFSEXP_V4ROOT) in nfsd4_encode_dirent_fattr()
3315 && !attributes_need_mount(cd->rd_bmval)) { in nfsd4_encode_dirent_fattr()
3324 err = nfsd_cross_mnt(cd->rd_rqstp, &dentry, &exp); in nfsd4_encode_dirent_fattr()
3329 nfserr = check_nfsd_access(exp, cd->rd_rqstp); in nfsd4_encode_dirent_fattr()
3335 nfserr = nfsd4_encode_fattr(xdr, NULL, exp, dentry, cd->rd_bmval, in nfsd4_encode_dirent_fattr()
3336 cd->rd_rqstp, ignore_crossmnt); in nfsd4_encode_dirent_fattr()
3366 struct xdr_stream *xdr = cd->xdr; in nfsd4_encode_dirent()
3367 int start_offset = xdr->buf->len; in nfsd4_encode_dirent()
3377 cd->common.err = nfs_ok; in nfsd4_encode_dirent()
3381 if (cd->cookie_offset) { in nfsd4_encode_dirent()
3383 write_bytes_to_xdr_buf(xdr->buf, cd->cookie_offset, in nfsd4_encode_dirent()
3391 cookie_offset = xdr->buf->len; in nfsd4_encode_dirent()
3416 if (cd->rd_fhp->fh_export->ex_flags & NFSEXP_V4ROOT) in nfsd4_encode_dirent()
3427 if (!(cd->rd_bmval[0] & FATTR4_WORD0_RDATTR_ERROR)) in nfsd4_encode_dirent()
3436 entry_bytes = xdr->buf->len - start_offset; in nfsd4_encode_dirent()
3437 if (entry_bytes > cd->rd_maxcount) in nfsd4_encode_dirent()
3439 cd->rd_maxcount -= entry_bytes; in nfsd4_encode_dirent()
3445 if (cd->rd_dircount) { in nfsd4_encode_dirent()
3447 if (name_and_cookie > cd->rd_dircount && cd->cookie_offset) in nfsd4_encode_dirent()
3449 cd->rd_dircount -= min(cd->rd_dircount, name_and_cookie); in nfsd4_encode_dirent()
3450 if (!cd->rd_dircount) in nfsd4_encode_dirent()
3451 cd->rd_maxcount = 0; in nfsd4_encode_dirent()
3454 cd->cookie_offset = cookie_offset; in nfsd4_encode_dirent()
3456 cd->common.err = nfs_ok; in nfsd4_encode_dirent()
3460 cd->common.err = nfserr; in nfsd4_encode_dirent()
3461 return -EINVAL; in nfsd4_encode_dirent()
3472 *p++ = cpu_to_be32(sid->si_generation); in nfsd4_encode_stateid()
3473 p = xdr_encode_opaque_fixed(p, &sid->si_opaque, in nfsd4_encode_stateid()
3481 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_access()
3487 *p++ = cpu_to_be32(access->ac_supported); in nfsd4_encode_access()
3488 *p++ = cpu_to_be32(access->ac_resp_access); in nfsd4_encode_access()
3494 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_bind_conn_to_session()
3500 p = xdr_encode_opaque_fixed(p, bcts->sessionid.data, in nfsd4_encode_bind_conn_to_session()
3502 *p++ = cpu_to_be32(bcts->dir); in nfsd4_encode_bind_conn_to_session()
3511 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_close()
3513 return nfsd4_encode_stateid(xdr, &close->cl_stateid); in nfsd4_encode_close()
3520 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_commit()
3526 p = xdr_encode_opaque_fixed(p, commit->co_verf.data, in nfsd4_encode_commit()
3534 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_create()
3540 encode_cinfo(p, &create->cr_cinfo); in nfsd4_encode_create()
3541 return nfsd4_encode_bitmap(xdr, create->cr_bmval[0], in nfsd4_encode_create()
3542 create->cr_bmval[1], create->cr_bmval[2]); in nfsd4_encode_create()
3548 struct svc_fh *fhp = getattr->ga_fhp; in nfsd4_encode_getattr()
3549 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_getattr()
3551 return nfsd4_encode_fattr(xdr, fhp, fhp->fh_export, fhp->fh_dentry, in nfsd4_encode_getattr()
3552 getattr->ga_bmval, resp->rqstp, 0); in nfsd4_encode_getattr()
3558 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_getfh()
3563 len = fhp->fh_handle.fh_size; in nfsd4_encode_getfh()
3567 p = xdr_encode_opaque(p, &fhp->fh_handle.fh_base, len); in nfsd4_encode_getfh()
3578 struct xdr_netobj *conf = &ld->ld_owner; in nfsd4_encode_lock_denied()
3582 p = xdr_reserve_space(xdr, 32 + XDR_LEN(conf->len)); in nfsd4_encode_lock_denied()
3588 if (conf->len) { in nfsd4_encode_lock_denied()
3589 kfree(conf->data); in nfsd4_encode_lock_denied()
3590 conf->len = 0; in nfsd4_encode_lock_denied()
3591 conf->data = NULL; in nfsd4_encode_lock_denied()
3596 p = xdr_encode_hyper(p, ld->ld_start); in nfsd4_encode_lock_denied()
3597 p = xdr_encode_hyper(p, ld->ld_length); in nfsd4_encode_lock_denied()
3598 *p++ = cpu_to_be32(ld->ld_type); in nfsd4_encode_lock_denied()
3599 if (conf->len) { in nfsd4_encode_lock_denied()
3600 p = xdr_encode_opaque_fixed(p, &ld->ld_clientid, 8); in nfsd4_encode_lock_denied()
3601 p = xdr_encode_opaque(p, conf->data, conf->len); in nfsd4_encode_lock_denied()
3602 kfree(conf->data); in nfsd4_encode_lock_denied()
3603 } else { /* non - nfsv4 lock in conflict, no clientid nor owner */ in nfsd4_encode_lock_denied()
3613 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_lock()
3616 nfserr = nfsd4_encode_stateid(xdr, &lock->lk_resp_stateid); in nfsd4_encode_lock()
3618 nfserr = nfsd4_encode_lock_denied(xdr, &lock->lk_denied); in nfsd4_encode_lock()
3626 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_lockt()
3629 nfsd4_encode_lock_denied(xdr, &lockt->lt_denied); in nfsd4_encode_lockt()
3636 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_locku()
3638 return nfsd4_encode_stateid(xdr, &locku->lu_stateid); in nfsd4_encode_locku()
3645 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_link()
3651 p = encode_cinfo(p, &link->li_cinfo); in nfsd4_encode_link()
3659 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_open()
3662 nfserr = nfsd4_encode_stateid(xdr, &open->op_stateid); in nfsd4_encode_open()
3668 p = encode_cinfo(p, &open->op_cinfo); in nfsd4_encode_open()
3669 *p++ = cpu_to_be32(open->op_rflags); in nfsd4_encode_open()
3671 nfserr = nfsd4_encode_bitmap(xdr, open->op_bmval[0], open->op_bmval[1], in nfsd4_encode_open()
3672 open->op_bmval[2]); in nfsd4_encode_open()
3680 *p++ = cpu_to_be32(open->op_delegate_type); in nfsd4_encode_open()
3681 switch (open->op_delegate_type) { in nfsd4_encode_open()
3685 nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid); in nfsd4_encode_open()
3691 *p++ = cpu_to_be32(open->op_recall); in nfsd4_encode_open()
3702 nfserr = nfsd4_encode_stateid(xdr, &open->op_delegate_stateid); in nfsd4_encode_open()
3708 *p++ = cpu_to_be32(open->op_recall); in nfsd4_encode_open()
3726 switch (open->op_why_no_deleg) { in nfsd4_encode_open()
3732 *p++ = cpu_to_be32(open->op_why_no_deleg); in nfsd4_encode_open()
3740 *p++ = cpu_to_be32(open->op_why_no_deleg); in nfsd4_encode_open()
3753 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_open_confirm()
3755 return nfsd4_encode_stateid(xdr, &oc->oc_resp_stateid); in nfsd4_encode_open_confirm()
3761 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_open_downgrade()
3763 return nfsd4_encode_stateid(xdr, &od->od_stateid); in nfsd4_encode_open_downgrade()
3771 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_splice_read()
3772 struct xdr_buf *buf = xdr->buf; in nfsd4_encode_splice_read()
3776 __be32 *p = xdr->p - 2; in nfsd4_encode_splice_read()
3779 if (xdr->end - xdr->p < 1) in nfsd4_encode_splice_read()
3782 nfserr = nfsd_splice_read(read->rd_rqstp, read->rd_fhp, in nfsd4_encode_splice_read()
3783 file, read->rd_offset, &maxcount, &eof); in nfsd4_encode_splice_read()
3784 read->rd_length = maxcount; in nfsd4_encode_splice_read()
3791 buf->page_len = 0; in nfsd4_encode_splice_read()
3798 buf->page_len = maxcount; in nfsd4_encode_splice_read()
3799 buf->len += maxcount; in nfsd4_encode_splice_read()
3800 xdr->page_ptr += (buf->page_base + maxcount + PAGE_SIZE - 1) in nfsd4_encode_splice_read()
3804 buf->tail[0].iov_base = xdr->p; in nfsd4_encode_splice_read()
3805 buf->tail[0].iov_len = 0; in nfsd4_encode_splice_read()
3806 xdr->iov = buf->tail; in nfsd4_encode_splice_read()
3808 int pad = 4 - (maxcount&3); in nfsd4_encode_splice_read()
3810 *(xdr->p++) = 0; in nfsd4_encode_splice_read()
3812 buf->tail[0].iov_base += maxcount&3; in nfsd4_encode_splice_read()
3813 buf->tail[0].iov_len = pad; in nfsd4_encode_splice_read()
3814 buf->len += pad; in nfsd4_encode_splice_read()
3817 space_left = min_t(int, (void *)xdr->end - (void *)xdr->p, in nfsd4_encode_splice_read()
3818 buf->buflen - buf->len); in nfsd4_encode_splice_read()
3819 buf->buflen = buf->len + space_left; in nfsd4_encode_splice_read()
3820 xdr->end = (__be32 *)((void *)xdr->end + space_left); in nfsd4_encode_splice_read()
3829 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_readv()
3831 int starting_len = xdr->buf->len - 8; in nfsd4_encode_readv()
3836 read->rd_vlen = xdr_reserve_space_vec(xdr, resp->rqstp->rq_vec, maxcount); in nfsd4_encode_readv()
3837 if (read->rd_vlen < 0) in nfsd4_encode_readv()
3840 nfserr = nfsd_readv(resp->rqstp, read->rd_fhp, file, read->rd_offset, in nfsd4_encode_readv()
3841 resp->rqstp->rq_vec, read->rd_vlen, &maxcount, in nfsd4_encode_readv()
3843 read->rd_length = maxcount; in nfsd4_encode_readv()
3846 if (svc_encode_read_payload(resp->rqstp, starting_len + 8, maxcount)) in nfsd4_encode_readv()
3851 write_bytes_to_xdr_buf(xdr->buf, starting_len , &tmp, 4); in nfsd4_encode_readv()
3853 write_bytes_to_xdr_buf(xdr->buf, starting_len + 4, &tmp, 4); in nfsd4_encode_readv()
3856 pad = (maxcount&3) ? 4 - (maxcount&3) : 0; in nfsd4_encode_readv()
3857 write_bytes_to_xdr_buf(xdr->buf, starting_len + 8 + maxcount, in nfsd4_encode_readv()
3868 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_read()
3870 int starting_len = xdr->buf->len; in nfsd4_encode_read()
3875 file = read->rd_nf->nf_file; in nfsd4_encode_read()
3879 WARN_ON_ONCE(test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags)); in nfsd4_encode_read()
3882 if (resp->xdr.buf->page_len && in nfsd4_encode_read()
3883 test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags)) { in nfsd4_encode_read()
3889 maxcount = svc_max_payload(resp->rqstp); in nfsd4_encode_read()
3891 (xdr->buf->buflen - xdr->buf->len)); in nfsd4_encode_read()
3892 maxcount = min_t(unsigned long, maxcount, read->rd_length); in nfsd4_encode_read()
3894 if (file->f_op->splice_read && in nfsd4_encode_read()
3895 test_bit(RQ_SPLICE_OK, &resp->rqstp->rq_flags)) in nfsd4_encode_read()
3912 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_readlink()
3913 int length_offset = xdr->buf->len; in nfsd4_encode_readlink()
3930 nfserr = nfsd_readlink(readlink->rl_rqstp, readlink->rl_fhp, in nfsd4_encode_readlink()
3940 write_bytes_to_xdr_buf(xdr->buf, length_offset, &wire_count, 4); in nfsd4_encode_readlink()
3943 write_bytes_to_xdr_buf(xdr->buf, length_offset + 4 + maxcount, in nfsd4_encode_readlink()
3944 &zero, 4 - (maxcount&3)); in nfsd4_encode_readlink()
3955 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_readdir()
3956 int starting_len = xdr->buf->len; in nfsd4_encode_readdir()
3966 resp->xdr.buf->head[0].iov_len = ((char *)resp->xdr.p) in nfsd4_encode_readdir()
3967 - (char *)resp->xdr.buf->head[0].iov_base; in nfsd4_encode_readdir()
3973 bytes_left = xdr->buf->buflen - xdr->buf->len in nfsd4_encode_readdir()
3974 - COMPOUND_ERR_SLACK_SPACE - 8; in nfsd4_encode_readdir()
3979 maxcount = svc_max_payload(resp->rqstp); in nfsd4_encode_readdir()
3980 maxcount = min_t(u32, readdir->rd_maxcount, maxcount); in nfsd4_encode_readdir()
3990 maxcount = min_t(int, maxcount-16, bytes_left); in nfsd4_encode_readdir()
3993 if (!readdir->rd_dircount) in nfsd4_encode_readdir()
3994 readdir->rd_dircount = svc_max_payload(resp->rqstp); in nfsd4_encode_readdir()
3996 readdir->xdr = xdr; in nfsd4_encode_readdir()
3997 readdir->rd_maxcount = maxcount; in nfsd4_encode_readdir()
3998 readdir->common.err = 0; in nfsd4_encode_readdir()
3999 readdir->cookie_offset = 0; in nfsd4_encode_readdir()
4001 offset = readdir->rd_cookie; in nfsd4_encode_readdir()
4002 nfserr = nfsd_readdir(readdir->rd_rqstp, readdir->rd_fhp, in nfsd4_encode_readdir()
4004 &readdir->common, nfsd4_encode_dirent); in nfsd4_encode_readdir()
4006 readdir->common.err == nfserr_toosmall && in nfsd4_encode_readdir()
4007 xdr->buf->len == starting_len + 8) { in nfsd4_encode_readdir()
4009 if (maxcount - 16 < bytes_left) in nfsd4_encode_readdir()
4019 if (readdir->cookie_offset) { in nfsd4_encode_readdir()
4021 write_bytes_to_xdr_buf(xdr->buf, readdir->cookie_offset, in nfsd4_encode_readdir()
4031 *p++ = htonl(readdir->common.err == nfserr_eof); in nfsd4_encode_readdir()
4042 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_remove()
4048 p = encode_cinfo(p, &remove->rm_cinfo); in nfsd4_encode_remove()
4055 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_rename()
4061 p = encode_cinfo(p, &rename->rn_sinfo); in nfsd4_encode_rename()
4062 p = encode_cinfo(p, &rename->rn_tinfo); in nfsd4_encode_rename()
4075 if (exp->ex_nflavors) { in nfsd4_do_encode_secinfo()
4076 flavs = exp->ex_flavors; in nfsd4_do_encode_secinfo()
4077 nflavs = exp->ex_nflavors; in nfsd4_do_encode_secinfo()
4080 if (exp->ex_client->flavour->flavour == RPC_AUTH_UNIX) { in nfsd4_do_encode_secinfo()
4084 } else if (exp->ex_client->flavour->flavour == RPC_AUTH_GSS) { in nfsd4_do_encode_secinfo()
4087 = svcauth_gss_flavor(exp->ex_client); in nfsd4_do_encode_secinfo()
4091 = exp->ex_client->flavour->flavour; in nfsd4_do_encode_secinfo()
4138 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_secinfo()
4140 return nfsd4_do_encode_secinfo(xdr, secinfo->si_exp); in nfsd4_encode_secinfo()
4147 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_secinfo_no_name()
4149 return nfsd4_do_encode_secinfo(xdr, secinfo->sin_exp); in nfsd4_encode_secinfo_no_name()
4153 * The SETATTR encode routine is special -- it always encodes a bitmap,
4159 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_setattr()
4173 *p++ = cpu_to_be32(setattr->sa_bmval[0]); in nfsd4_encode_setattr()
4174 *p++ = cpu_to_be32(setattr->sa_bmval[1]); in nfsd4_encode_setattr()
4175 *p++ = cpu_to_be32(setattr->sa_bmval[2]); in nfsd4_encode_setattr()
4183 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_setclientid()
4190 p = xdr_encode_opaque_fixed(p, &scd->se_clientid, 8); in nfsd4_encode_setclientid()
4191 p = xdr_encode_opaque_fixed(p, &scd->se_confirm, in nfsd4_encode_setclientid()
4207 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_write()
4213 *p++ = cpu_to_be32(write->wr_bytes_written); in nfsd4_encode_write()
4214 *p++ = cpu_to_be32(write->wr_how_written); in nfsd4_encode_write()
4215 p = xdr_encode_opaque_fixed(p, write->wr_verifier.data, in nfsd4_encode_write()
4224 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_exchange_id()
4231 struct nfsd_net *nn = net_generic(SVC_NET(resp->rqstp), nfsd_net_id); in nfsd4_encode_exchange_id()
4233 major_id = nn->nfsd_name; in nfsd4_encode_exchange_id()
4234 major_id_sz = strlen(nn->nfsd_name); in nfsd4_encode_exchange_id()
4235 server_scope = nn->nfsd_name; in nfsd4_encode_exchange_id()
4236 server_scope_sz = strlen(nn->nfsd_name); in nfsd4_encode_exchange_id()
4246 p = xdr_encode_opaque_fixed(p, &exid->clientid, 8); in nfsd4_encode_exchange_id()
4247 *p++ = cpu_to_be32(exid->seqid); in nfsd4_encode_exchange_id()
4248 *p++ = cpu_to_be32(exid->flags); in nfsd4_encode_exchange_id()
4250 *p++ = cpu_to_be32(exid->spa_how); in nfsd4_encode_exchange_id()
4252 switch (exid->spa_how) { in nfsd4_encode_exchange_id()
4258 exid->spo_must_enforce[0], in nfsd4_encode_exchange_id()
4259 exid->spo_must_enforce[1], in nfsd4_encode_exchange_id()
4260 exid->spo_must_enforce[2]); in nfsd4_encode_exchange_id()
4265 exid->spo_must_allow[0], in nfsd4_encode_exchange_id()
4266 exid->spo_must_allow[1], in nfsd4_encode_exchange_id()
4267 exid->spo_must_allow[2]); in nfsd4_encode_exchange_id()
4302 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_create_session()
4308 p = xdr_encode_opaque_fixed(p, sess->sessionid.data, in nfsd4_encode_create_session()
4310 *p++ = cpu_to_be32(sess->seqid); in nfsd4_encode_create_session()
4311 *p++ = cpu_to_be32(sess->flags); in nfsd4_encode_create_session()
4317 *p++ = cpu_to_be32(sess->fore_channel.maxreq_sz); in nfsd4_encode_create_session()
4318 *p++ = cpu_to_be32(sess->fore_channel.maxresp_sz); in nfsd4_encode_create_session()
4319 *p++ = cpu_to_be32(sess->fore_channel.maxresp_cached); in nfsd4_encode_create_session()
4320 *p++ = cpu_to_be32(sess->fore_channel.maxops); in nfsd4_encode_create_session()
4321 *p++ = cpu_to_be32(sess->fore_channel.maxreqs); in nfsd4_encode_create_session()
4322 *p++ = cpu_to_be32(sess->fore_channel.nr_rdma_attrs); in nfsd4_encode_create_session()
4324 if (sess->fore_channel.nr_rdma_attrs) { in nfsd4_encode_create_session()
4328 *p++ = cpu_to_be32(sess->fore_channel.rdma_attrs); in nfsd4_encode_create_session()
4335 *p++ = cpu_to_be32(sess->back_channel.maxreq_sz); in nfsd4_encode_create_session()
4336 *p++ = cpu_to_be32(sess->back_channel.maxresp_sz); in nfsd4_encode_create_session()
4337 *p++ = cpu_to_be32(sess->back_channel.maxresp_cached); in nfsd4_encode_create_session()
4338 *p++ = cpu_to_be32(sess->back_channel.maxops); in nfsd4_encode_create_session()
4339 *p++ = cpu_to_be32(sess->back_channel.maxreqs); in nfsd4_encode_create_session()
4340 *p++ = cpu_to_be32(sess->back_channel.nr_rdma_attrs); in nfsd4_encode_create_session()
4342 if (sess->back_channel.nr_rdma_attrs) { in nfsd4_encode_create_session()
4346 *p++ = cpu_to_be32(sess->back_channel.rdma_attrs); in nfsd4_encode_create_session()
4355 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_sequence()
4361 p = xdr_encode_opaque_fixed(p, seq->sessionid.data, in nfsd4_encode_sequence()
4363 *p++ = cpu_to_be32(seq->seqid); in nfsd4_encode_sequence()
4364 *p++ = cpu_to_be32(seq->slotid); in nfsd4_encode_sequence()
4366 *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_highest_slotid */ in nfsd4_encode_sequence()
4367 *p++ = cpu_to_be32(seq->maxslots - 1); /* sr_target_highest_slotid */ in nfsd4_encode_sequence()
4368 *p++ = cpu_to_be32(seq->status_flags); in nfsd4_encode_sequence()
4370 resp->cstate.data_offset = xdr->buf->len; /* DRC cache data pointer */ in nfsd4_encode_sequence()
4378 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_test_stateid()
4382 p = xdr_reserve_space(xdr, 4 + (4 * test_stateid->ts_num_ids)); in nfsd4_encode_test_stateid()
4385 *p++ = htonl(test_stateid->ts_num_ids); in nfsd4_encode_test_stateid()
4387 list_for_each_entry_safe(stateid, next, &test_stateid->ts_stateid_list, ts_id_list) { in nfsd4_encode_test_stateid()
4388 *p++ = stateid->ts_id_status; in nfsd4_encode_test_stateid()
4399 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_getdeviceinfo()
4401 u32 starting_len = xdr->buf->len, needed_len; in nfsd4_encode_getdeviceinfo()
4408 *p++ = cpu_to_be32(gdev->gd_layout_type); in nfsd4_encode_getdeviceinfo()
4410 ops = nfsd4_layout_ops[gdev->gd_layout_type]; in nfsd4_encode_getdeviceinfo()
4411 nfserr = ops->encode_getdeviceinfo(xdr, gdev); in nfsd4_encode_getdeviceinfo()
4418 if (xdr->buf->len + 4 > gdev->gd_maxcount) in nfsd4_encode_getdeviceinfo()
4423 if (gdev->gd_notify_types) { in nfsd4_encode_getdeviceinfo()
4428 *p++ = cpu_to_be32(gdev->gd_notify_types); in nfsd4_encode_getdeviceinfo()
4439 needed_len = xdr->buf->len + 4 /* notifications */; in nfsd4_encode_getdeviceinfo()
4452 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_layoutget()
4460 *p++ = cpu_to_be32(1); /* we always set return-on-close */ in nfsd4_encode_layoutget()
4461 *p++ = cpu_to_be32(lgp->lg_sid.si_generation); in nfsd4_encode_layoutget()
4462 p = xdr_encode_opaque_fixed(p, &lgp->lg_sid.si_opaque, in nfsd4_encode_layoutget()
4466 p = xdr_encode_hyper(p, lgp->lg_seg.offset); in nfsd4_encode_layoutget()
4467 p = xdr_encode_hyper(p, lgp->lg_seg.length); in nfsd4_encode_layoutget()
4468 *p++ = cpu_to_be32(lgp->lg_seg.iomode); in nfsd4_encode_layoutget()
4469 *p++ = cpu_to_be32(lgp->lg_layout_type); in nfsd4_encode_layoutget()
4471 ops = nfsd4_layout_ops[lgp->lg_layout_type]; in nfsd4_encode_layoutget()
4472 return ops->encode_layoutget(xdr, lgp); in nfsd4_encode_layoutget()
4479 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_layoutcommit()
4485 *p++ = cpu_to_be32(lcp->lc_size_chg); in nfsd4_encode_layoutcommit()
4486 if (lcp->lc_size_chg) { in nfsd4_encode_layoutcommit()
4490 p = xdr_encode_hyper(p, lcp->lc_newsize); in nfsd4_encode_layoutcommit()
4500 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_layoutreturn()
4506 *p++ = cpu_to_be32(lrp->lrs_present); in nfsd4_encode_layoutreturn()
4507 if (lrp->lrs_present) in nfsd4_encode_layoutreturn()
4508 return nfsd4_encode_stateid(xdr, &lrp->lr_sid); in nfsd4_encode_layoutreturn()
4518 p = xdr_reserve_space(&resp->xdr, 4); in nfsd42_encode_write_res()
4527 nfserr = nfsd4_encode_stateid(&resp->xdr, &write->cb_stateid); in nfsd42_encode_write_res()
4531 p = xdr_reserve_space(&resp->xdr, 8 + 4 + NFS4_VERIFIER_SIZE); in nfsd42_encode_write_res()
4535 p = xdr_encode_hyper(p, write->wr_bytes_written); in nfsd42_encode_write_res()
4536 *p++ = cpu_to_be32(write->wr_stable_how); in nfsd42_encode_write_res()
4537 p = xdr_encode_opaque_fixed(p, write->wr_verifier.data, in nfsd42_encode_write_res()
4545 struct xdr_stream *xdr = &resp->xdr; in nfsd42_encode_nl4_server()
4550 *p++ = cpu_to_be32(ns->nl4_type); in nfsd42_encode_nl4_server()
4552 switch (ns->nl4_type) { in nfsd42_encode_nl4_server()
4554 addr = &ns->u.nl4_addr; in nfsd42_encode_nl4_server()
4561 (XDR_QUADLEN(addr->netid_len) * 4) + in nfsd42_encode_nl4_server()
4563 (XDR_QUADLEN(addr->addr_len) * 4)); in nfsd42_encode_nl4_server()
4567 *p++ = cpu_to_be32(addr->netid_len); in nfsd42_encode_nl4_server()
4568 p = xdr_encode_opaque_fixed(p, addr->netid, in nfsd42_encode_nl4_server()
4569 addr->netid_len); in nfsd42_encode_nl4_server()
4570 *p++ = cpu_to_be32(addr->addr_len); in nfsd42_encode_nl4_server()
4571 p = xdr_encode_opaque_fixed(p, addr->addr, in nfsd42_encode_nl4_server()
4572 addr->addr_len); in nfsd42_encode_nl4_server()
4575 WARN_ON_ONCE(ns->nl4_type != NL4_NETADDR); in nfsd42_encode_nl4_server()
4588 nfserr = nfsd42_encode_write_res(resp, ©->cp_res, in nfsd4_encode_copy()
4589 copy->cp_synchronous); in nfsd4_encode_copy()
4593 p = xdr_reserve_space(&resp->xdr, 4 + 4); in nfsd4_encode_copy()
4595 *p++ = cpu_to_be32(copy->cp_synchronous); in nfsd4_encode_copy()
4603 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_offload_status()
4609 p = xdr_encode_hyper(p, os->count); in nfsd4_encode_offload_status()
4620 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_read_plus_data()
4621 struct file *file = read->rd_nf->nf_file; in nfsd4_encode_read_plus_data()
4622 int starting_len = xdr->buf->len; in nfsd4_encode_read_plus_data()
4628 hole_pos = pos ? *pos : vfs_llseek(file, read->rd_offset, SEEK_HOLE); in nfsd4_encode_read_plus_data()
4629 if (hole_pos > read->rd_offset) in nfsd4_encode_read_plus_data()
4630 *maxcount = min_t(unsigned long, *maxcount, hole_pos - read->rd_offset); in nfsd4_encode_read_plus_data()
4631 *maxcount = min_t(unsigned long, *maxcount, (xdr->buf->buflen - xdr->buf->len)); in nfsd4_encode_read_plus_data()
4638 read->rd_vlen = xdr_reserve_space_vec(xdr, resp->rqstp->rq_vec, *maxcount); in nfsd4_encode_read_plus_data()
4639 if (read->rd_vlen < 0) in nfsd4_encode_read_plus_data()
4642 nfserr = nfsd_readv(resp->rqstp, read->rd_fhp, file, read->rd_offset, in nfsd4_encode_read_plus_data()
4643 resp->rqstp->rq_vec, read->rd_vlen, maxcount, eof); in nfsd4_encode_read_plus_data()
4649 write_bytes_to_xdr_buf(xdr->buf, starting_len, &tmp, 4); in nfsd4_encode_read_plus_data()
4650 tmp64 = cpu_to_be64(read->rd_offset); in nfsd4_encode_read_plus_data()
4651 write_bytes_to_xdr_buf(xdr->buf, starting_len + 4, &tmp64, 8); in nfsd4_encode_read_plus_data()
4653 write_bytes_to_xdr_buf(xdr->buf, starting_len + 12, &tmp, 4); in nfsd4_encode_read_plus_data()
4656 write_bytes_to_xdr_buf(xdr->buf, starting_len + 16 + *maxcount, &tmp, in nfsd4_encode_read_plus_data()
4666 struct file *file = read->rd_nf->nf_file; in nfsd4_encode_read_plus_hole()
4667 loff_t data_pos = vfs_llseek(file, read->rd_offset, SEEK_DATA); in nfsd4_encode_read_plus_hole()
4672 if (data_pos == -ENXIO) in nfsd4_encode_read_plus_hole()
4674 else if (data_pos <= read->rd_offset || (data_pos < f_size && data_pos % PAGE_SIZE)) in nfsd4_encode_read_plus_hole()
4676 count = data_pos - read->rd_offset; in nfsd4_encode_read_plus_hole()
4679 p = xdr_reserve_space(&resp->xdr, 4 + 8 + 8); in nfsd4_encode_read_plus_hole()
4684 p = xdr_encode_hyper(p, read->rd_offset); in nfsd4_encode_read_plus_hole()
4687 *eof = (read->rd_offset + count) >= f_size; in nfsd4_encode_read_plus_hole()
4697 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_read_plus()
4699 int starting_len = xdr->buf->len; in nfsd4_encode_read_plus()
4700 int last_segment = xdr->buf->len; in nfsd4_encode_read_plus()
4709 file = read->rd_nf->nf_file; in nfsd4_encode_read_plus()
4717 maxcount = svc_max_payload(resp->rqstp); in nfsd4_encode_read_plus()
4719 (xdr->buf->buflen - xdr->buf->len)); in nfsd4_encode_read_plus()
4720 maxcount = min_t(unsigned long, maxcount, read->rd_length); in nfsd4_encode_read_plus()
4723 eof = read->rd_offset >= i_size_read(file_inode(file)); in nfsd4_encode_read_plus()
4727 pos = vfs_llseek(file, read->rd_offset, SEEK_HOLE); in nfsd4_encode_read_plus()
4728 is_data = pos > read->rd_offset; in nfsd4_encode_read_plus()
4739 count -= maxcount; in nfsd4_encode_read_plus()
4740 read->rd_offset += maxcount; in nfsd4_encode_read_plus()
4742 last_segment = xdr->buf->len; in nfsd4_encode_read_plus()
4756 write_bytes_to_xdr_buf(xdr->buf, starting_len, &tmp, 4); in nfsd4_encode_read_plus()
4758 write_bytes_to_xdr_buf(xdr->buf, starting_len + 4, &tmp, 4); in nfsd4_encode_read_plus()
4768 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_copy_notify()
4780 p = xdr_encode_hyper(p, cn->cpn_sec); in nfsd4_encode_copy_notify()
4781 *p++ = cpu_to_be32(cn->cpn_nsec); in nfsd4_encode_copy_notify()
4784 nfserr = nfsd4_encode_stateid(xdr, &cn->cpn_cnr_stateid); in nfsd4_encode_copy_notify()
4795 return nfsd42_encode_nl4_server(resp, &cn->cpn_src); in nfsd4_encode_copy_notify()
4804 p = xdr_reserve_space(&resp->xdr, 4 + 8); in nfsd4_encode_seek()
4805 *p++ = cpu_to_be32(seek->seek_eof); in nfsd4_encode_seek()
4806 p = xdr_encode_hyper(p, seek->seek_pos); in nfsd4_encode_seek()
4818 * Encode kmalloc-ed buffer in to XDR stream.
4827 ((void *)xdr->end - (void *)xdr->p)); in nfsd4_vbuf_to_stream()
4834 buflen -= cplen; in nfsd4_vbuf_to_stream()
4854 buflen -= PAGE_SIZE; in nfsd4_vbuf_to_stream()
4865 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_getxattr()
4872 *p = cpu_to_be32(getxattr->getxa_len); in nfsd4_encode_getxattr()
4874 if (getxattr->getxa_len == 0) in nfsd4_encode_getxattr()
4877 err = nfsd4_vbuf_to_stream(xdr, getxattr->getxa_buf, in nfsd4_encode_getxattr()
4878 getxattr->getxa_len); in nfsd4_encode_getxattr()
4880 kvfree(getxattr->getxa_buf); in nfsd4_encode_getxattr()
4889 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_setxattr()
4896 encode_cinfo(p, &setxattr->setxa_cinfo); in nfsd4_encode_setxattr()
4908 u64 cookie = listxattrs->lsxa_cookie; in nfsd4_listxattr_validate_cookie()
4913 * XDR-encoded, in the return buffer, it's invalid. in nfsd4_listxattr_validate_cookie()
4915 if (cookie > (listxattrs->lsxa_len) / (XATTR_USER_PREFIX_LEN + 2)) in nfsd4_listxattr_validate_cookie()
4918 if (cookie > (listxattrs->lsxa_maxcount / in nfsd4_listxattr_validate_cookie()
4930 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_listxattrs()
4950 cookie_offset = xdr->buf->len; in nfsd4_encode_listxattrs()
4959 left = listxattrs->lsxa_len; in nfsd4_encode_listxattrs()
4960 sp = listxattrs->lsxa_buf; in nfsd4_encode_listxattrs()
4963 xdrleft = listxattrs->lsxa_maxcount; in nfsd4_encode_listxattrs()
4974 slen -= XATTR_USER_PREFIX_LEN; in nfsd4_encode_listxattrs()
4988 left -= XATTR_USER_PREFIX_LEN; in nfsd4_encode_listxattrs()
5002 xdrleft -= xdrlen; in nfsd4_encode_listxattrs()
5006 left -= slen + 1; in nfsd4_encode_listxattrs()
5028 write_bytes_to_xdr_buf(xdr->buf, cookie_offset, &cookie, 8); in nfsd4_encode_listxattrs()
5030 write_bytes_to_xdr_buf(xdr->buf, count_offset, &tmp, 4); in nfsd4_encode_listxattrs()
5032 if (listxattrs->lsxa_len) in nfsd4_encode_listxattrs()
5033 kvfree(listxattrs->lsxa_buf); in nfsd4_encode_listxattrs()
5041 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_removexattr()
5048 p = encode_cinfo(p, &removexattr->rmxa_cinfo); in nfsd4_encode_removexattr()
5152 * - For NFS versions >=4.1, the size of the reply must stay within
5154 * - For all NFS versions, we must stay within limited preallocated
5164 struct xdr_buf *buf = &resp->rqstp->rq_res; in nfsd4_check_resp_size()
5165 struct nfsd4_slot *slot = resp->cstate.slot; in nfsd4_check_resp_size()
5167 if (buf->len + respsize <= buf->buflen) in nfsd4_check_resp_size()
5169 if (!nfsd4_has_session(&resp->cstate)) in nfsd4_check_resp_size()
5171 if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) { in nfsd4_check_resp_size()
5181 struct xdr_stream *xdr = &resp->xdr; in nfsd4_encode_operation()
5182 struct nfs4_stateowner *so = resp->cstate.replay_owner; in nfsd4_encode_operation()
5183 struct svc_rqst *rqstp = resp->rqstp; in nfsd4_encode_operation()
5184 const struct nfsd4_operation *opdesc = op->opdesc; in nfsd4_encode_operation()
5194 *p++ = cpu_to_be32(op->opnum); in nfsd4_encode_operation()
5195 post_err_offset = xdr->buf->len; in nfsd4_encode_operation()
5197 if (op->opnum == OP_ILLEGAL) in nfsd4_encode_operation()
5199 if (op->status && opdesc && in nfsd4_encode_operation()
5200 !(opdesc->op_flags & OP_NONTRIVIAL_ERROR_ENCODE)) in nfsd4_encode_operation()
5202 BUG_ON(op->opnum < 0 || op->opnum >= ARRAY_SIZE(nfsd4_enc_ops) || in nfsd4_encode_operation()
5203 !nfsd4_enc_ops[op->opnum]); in nfsd4_encode_operation()
5204 encoder = nfsd4_enc_ops[op->opnum]; in nfsd4_encode_operation()
5205 op->status = encoder(resp, op->status, &op->u); in nfsd4_encode_operation()
5206 if (opdesc && opdesc->op_release) in nfsd4_encode_operation()
5207 opdesc->op_release(&op->u); in nfsd4_encode_operation()
5211 if (!op->status) { in nfsd4_encode_operation()
5215 op->status = nfsd4_check_resp_size(resp, space_needed); in nfsd4_encode_operation()
5217 if (op->status == nfserr_resource && nfsd4_has_session(&resp->cstate)) { in nfsd4_encode_operation()
5218 struct nfsd4_slot *slot = resp->cstate.slot; in nfsd4_encode_operation()
5220 if (slot->sl_flags & NFSD4_SLOT_CACHETHIS) in nfsd4_encode_operation()
5221 op->status = nfserr_rep_too_big_to_cache; in nfsd4_encode_operation()
5223 op->status = nfserr_rep_too_big; in nfsd4_encode_operation()
5225 if (op->status == nfserr_resource || in nfsd4_encode_operation()
5226 op->status == nfserr_rep_too_big || in nfsd4_encode_operation()
5227 op->status == nfserr_rep_too_big_to_cache) { in nfsd4_encode_operation()
5233 * bug if we had to do this on a non-idempotent op: in nfsd4_encode_operation()
5239 int len = xdr->buf->len - post_err_offset; in nfsd4_encode_operation()
5241 so->so_replay.rp_status = op->status; in nfsd4_encode_operation()
5242 so->so_replay.rp_buflen = len; in nfsd4_encode_operation()
5243 read_bytes_from_xdr_buf(xdr->buf, post_err_offset, in nfsd4_encode_operation()
5244 so->so_replay.rp_buf, len); in nfsd4_encode_operation()
5247 /* Note that op->status is already in network byte order: */ in nfsd4_encode_operation()
5248 write_bytes_to_xdr_buf(xdr->buf, post_err_offset - 4, &op->status, 4); in nfsd4_encode_operation()
5254 * XDR note: do not encode rp->rp_buflen: the buffer contains the
5261 struct nfs4_replay *rp = op->replay; in nfsd4_encode_replay()
5263 p = xdr_reserve_space(xdr, 8 + rp->rp_buflen); in nfsd4_encode_replay()
5268 *p++ = cpu_to_be32(op->opnum); in nfsd4_encode_replay()
5269 *p++ = rp->rp_status; /* already xdr'ed */ in nfsd4_encode_replay()
5271 p = xdr_encode_opaque_fixed(p, rp->rp_buf, rp->rp_buflen); in nfsd4_encode_replay()
5282 struct nfsd4_compoundargs *args = rqstp->rq_argp; in nfsd4_release_compoundargs()
5284 if (args->ops != args->iops) { in nfsd4_release_compoundargs()
5285 kfree(args->ops); in nfsd4_release_compoundargs()
5286 args->ops = args->iops; in nfsd4_release_compoundargs()
5288 kfree(args->tmpp); in nfsd4_release_compoundargs()
5289 args->tmpp = NULL; in nfsd4_release_compoundargs()
5290 while (args->to_free) { in nfsd4_release_compoundargs()
5291 struct svcxdr_tmpbuf *tb = args->to_free; in nfsd4_release_compoundargs()
5292 args->to_free = tb->next; in nfsd4_release_compoundargs()
5306 struct nfsd4_compoundargs *args = rqstp->rq_argp; in nfs4svc_decode_compoundargs()
5308 if (rqstp->rq_arg.head[0].iov_len % 4) { in nfs4svc_decode_compoundargs()
5311 __func__, svc_addr(rqstp), be32_to_cpu(rqstp->rq_xid)); in nfs4svc_decode_compoundargs()
5314 args->p = p; in nfs4svc_decode_compoundargs()
5315 args->end = rqstp->rq_arg.head[0].iov_base + rqstp->rq_arg.head[0].iov_len; in nfs4svc_decode_compoundargs()
5316 args->pagelist = rqstp->rq_arg.pages; in nfs4svc_decode_compoundargs()
5317 args->pagelen = rqstp->rq_arg.page_len; in nfs4svc_decode_compoundargs()
5318 args->tail = false; in nfs4svc_decode_compoundargs()
5319 args->tmpp = NULL; in nfs4svc_decode_compoundargs()
5320 args->to_free = NULL; in nfs4svc_decode_compoundargs()
5321 args->ops = args->iops; in nfs4svc_decode_compoundargs()
5322 args->rqstp = rqstp; in nfs4svc_decode_compoundargs()
5330 struct nfsd4_compoundres *resp = rqstp->rq_resp; in nfs4svc_encode_compoundres()
5331 struct xdr_buf *buf = resp->xdr.buf; in nfs4svc_encode_compoundres()
5333 WARN_ON_ONCE(buf->len != buf->head[0].iov_len + buf->page_len + in nfs4svc_encode_compoundres()
5334 buf->tail[0].iov_len); in nfs4svc_encode_compoundres()
5336 *p = resp->cstate.status; in nfs4svc_encode_compoundres()
5338 rqstp->rq_next_page = resp->xdr.page_ptr + 1; in nfs4svc_encode_compoundres()
5340 p = resp->tagp; in nfs4svc_encode_compoundres()
5341 *p++ = htonl(resp->taglen); in nfs4svc_encode_compoundres()
5342 memcpy(p, resp->tag, resp->taglen); in nfs4svc_encode_compoundres()
5343 p += XDR_QUADLEN(resp->taglen); in nfs4svc_encode_compoundres()
5344 *p++ = htonl(resp->opcnt); in nfs4svc_encode_compoundres()
5352 * c-basic-offset: 8