Lines Matching defs:res
75 struct nfs4_layoutget_res *res);
1006 __u32 *res, size_t len)
1015 res[i] = tmp;
3392 static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3396 *res = 0;
3403 *res = be32_to_cpup(p);
3406 dprintk("%s: link support=%s\n", __func__, *res == 0 ? "false" : "true");
3410 static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3414 *res = 0;
3421 *res = be32_to_cpup(p);
3424 dprintk("%s: symlink support=%s\n", __func__, *res == 0 ? "false" : "true");
3452 static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3456 *res = 60;
3463 *res = be32_to_cpup(p);
3466 dprintk("%s: lease time=%u\n", __func__, (unsigned int)*res);
3470 static int decode_attr_error(struct xdr_stream *xdr, uint32_t *bitmap, int32_t *res)
3481 *res = -be32_to_cpup(p);
3534 static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3538 *res = 0;
3545 *res = be32_to_cpup(p);
3548 dprintk("%s: ACLs supported=%u\n", __func__, (unsigned int)*res);
3552 static int decode_attr_case_insensitive(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3556 *res = 0;
3563 *res = be32_to_cpup(p);
3566 dprintk("%s: case_insensitive=%s\n", __func__, *res == 0 ? "false" : "true");
3570 static int decode_attr_case_preserving(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3574 *res = 0;
3581 *res = be32_to_cpup(p);
3584 dprintk("%s: case_preserving=%s\n", __func__, *res == 0 ? "false" : "true");
3628 static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3633 *res = 0;
3640 xdr_decode_hyper(p, res);
3643 dprintk("%s: files avail=%Lu\n", __func__, (unsigned long long)*res);
3647 static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3652 *res = 0;
3659 xdr_decode_hyper(p, res);
3662 dprintk("%s: files free=%Lu\n", __func__, (unsigned long long)*res);
3666 static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3671 *res = 0;
3678 xdr_decode_hyper(p, res);
3681 dprintk("%s: files total=%Lu\n", __func__, (unsigned long long)*res);
3727 static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs4_fs_locations *res)
3741 if (unlikely(res == NULL))
3744 status = decode_pathname(xdr, &res->fs_path);
3751 for (res->nlocations = 0; res->nlocations < n; res->nlocations++) {
3755 if (res->nlocations == NFS4_FS_LOCATIONS_MAXENTRIES)
3757 loc = &res->locations[res->nlocations];
3773 m, res->nlocations);
3793 if (res->nlocations != 0)
3803 static int decode_attr_maxfilesize(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
3808 *res = 0;
3815 xdr_decode_hyper(p, res);
3818 dprintk("%s: maxfilesize=%Lu\n", __func__, (unsigned long long)*res);
3860 static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3865 *res = 1024;
3876 *res = (uint32_t)maxread;
3879 dprintk("%s: maxread=%lu\n", __func__, (unsigned long)*res);
3883 static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *res)
3888 *res = 1024;
3899 *res = (uint32_t)maxwrite;
3902 dprintk("%s: maxwrite=%lu\n", __func__, (unsigned long)*res);
4056 static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
4061 *res = 0;
4068 xdr_decode_hyper(p, res);
4071 dprintk("%s: space avail=%Lu\n", __func__, (unsigned long long)*res);
4075 static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
4080 *res = 0;
4087 xdr_decode_hyper(p, res);
4090 dprintk("%s: space free=%Lu\n", __func__, (unsigned long long)*res);
4094 static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *res)
4099 *res = 0;
4106 xdr_decode_hyper(p, res);
4109 dprintk("%s: space total=%Lu\n", __func__, (unsigned long long)*res);
4278 uint32_t *res)
4282 *res = 0;
4289 *res = be32_to_cpup(p);
4293 *res == 0 ? "false" : "true");
4385 static int decode_close(struct xdr_stream *xdr, struct nfs_closeres *res)
4391 nfs_increment_open_seqid(status, res->seqid);
4393 status = decode_invalid_stateid(xdr, &res->stateid);
4407 static int decode_commit(struct xdr_stream *xdr, struct nfs_commitres *res)
4409 struct nfs_writeverf *verf = res->verf;
4441 static int decode_server_caps(struct xdr_stream *xdr, struct nfs4_server_caps_res *res)
4453 if ((status = decode_attr_supported(xdr, bitmap, res->attr_bitmask)) != 0)
4456 &res->fh_expire_type)) != 0)
4458 if ((status = decode_attr_link_support(xdr, bitmap, &res->has_links)) != 0)
4460 if ((status = decode_attr_symlink_support(xdr, bitmap, &res->has_symlinks)) != 0)
4462 if ((status = decode_attr_aclsupport(xdr, bitmap, &res->acl_bitmask)) != 0)
4464 if ((status = decode_attr_case_insensitive(xdr, bitmap, &res->case_insensitive)) != 0)
4466 if ((status = decode_attr_case_preserving(xdr, bitmap, &res->case_preserving)) != 0)
4469 res->exclcreat_bitmask)) != 0)
4540 uint64_t *res,
4545 *res = 0;
4550 xdr_decode_hyper(p, res);
4556 struct nfs4_threshold *res)
4567 res->l_type = be32_to_cpup(p);
4579 status = decode_threshold_hint(xdr, bitmap, &res->rd_sz, THRESHOLD_RD);
4582 status = decode_threshold_hint(xdr, bitmap, &res->wr_sz, THRESHOLD_WR);
4585 status = decode_threshold_hint(xdr, bitmap, &res->rd_io_sz,
4589 status = decode_threshold_hint(xdr, bitmap, &res->wr_io_sz,
4595 res->bm = bitmap[0];
4598 __func__, res->bm, res->rd_sz, res->wr_sz, res->rd_io_sz,
4599 res->wr_io_sz);
4610 struct nfs4_threshold *res)
4620 if (unlikely(res == NULL))
4633 status = decode_first_threshold_item4(xdr, res);
4861 uint32_t *res)
4866 *res = 0;
4871 *res = be32_to_cpup(p);
4881 uint32_t *res)
4886 *res = 0;
4891 *res = be32_to_cpup(p);
4899 enum nfs4_change_attr_type *res)
4915 *res = tmp;
4918 *res = NFS4_CHANGE_TYPE_IS_UNDEFINED;
5059 static int decode_lock(struct xdr_stream *xdr, struct nfs_lock_res *res)
5067 status = decode_lock_stateid(xdr, &res->stateid);
5072 if (res->open_seqid != NULL)
5073 nfs_increment_open_seqid(status, res->open_seqid);
5074 nfs_increment_lock_seqid(status, res->lock_seqid);
5079 static int decode_lockt(struct xdr_stream *xdr, struct nfs_lockt_res *res)
5084 return decode_lock_denied(xdr, res->denied);
5088 static int decode_locku(struct xdr_stream *xdr, struct nfs_locku_res *res)
5094 nfs_increment_lock_seqid(status, res->seqid);
5096 status = decode_lock_stateid(xdr, &res->stateid);
5143 struct nfs_openres *res)
5148 status = decode_delegation_stateid(xdr, &res->delegation);
5154 res->do_recall = be32_to_cpup(p);
5158 res->delegation_type = FMODE_READ;
5161 res->delegation_type = FMODE_WRITE|FMODE_READ;
5162 if (decode_space_limit(xdr, &res->pagemod_limit) < 0)
5168 static int decode_no_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
5186 static int decode_delegation(struct xdr_stream *xdr, struct nfs_openres *res)
5195 res->delegation_type = 0;
5201 return decode_rw_delegation(xdr, delegation_type, res);
5203 return decode_no_delegation(xdr, res);
5208 static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
5216 nfs_increment_open_seqid(status, res->seqid);
5219 status = decode_open_stateid(xdr, &res->stateid);
5223 decode_change_info(xdr, &res->cinfo);
5228 res->rflags = be32_to_cpup(p++);
5238 res->attrset[i] = be32_to_cpup(p++);
5240 res->attrset[i] = 0;
5242 return decode_delegation(xdr, res);
5248 static int decode_open_confirm(struct xdr_stream *xdr, struct nfs_open_confirmres *res)
5254 nfs_increment_open_seqid(status, res->seqid);
5256 status = decode_open_stateid(xdr, &res->stateid);
5260 static int decode_open_downgrade(struct xdr_stream *xdr, struct nfs_closeres *res)
5266 nfs_increment_open_seqid(status, res->seqid);
5268 status = decode_open_stateid(xdr, &res->stateid);
5283 struct nfs_pgio_res *res)
5304 res->eof = eof;
5305 res->count = count;
5401 struct nfs_getaclres *res, enum nfs4_acl_type type)
5408 res->acl_len = 0;
5442 res->acl_data_offset = xdr_page_pos(xdr);
5443 res->acl_len = attrlen;
5446 if (res->acl_len > xdr_stream_remaining(xdr) ||
5447 res->acl_len + res->acl_data_offset > xdr->buf->page_len) {
5448 res->acl_flags |= NFS4_ACL_TRUNC;
5474 static int decode_setclientid(struct xdr_stream *xdr, struct nfs4_setclientid_res *res)
5494 p = xdr_decode_hyper(p, &res->clientid);
5495 memcpy(res->confirm.data, p, NFS4_VERIFIER_SIZE);
5528 static int decode_write(struct xdr_stream *xdr, struct nfs_pgio_res *res)
5540 res->count = be32_to_cpup(p++);
5541 res->verf->committed = be32_to_cpup(p++);
5542 return decode_write_verifier(xdr, &res->verf->verifier);
5578 static int decode_secinfo_common(struct xdr_stream *xdr, struct nfs4_secinfo_res *res)
5589 res->flavors->num_flavors = 0;
5593 sec_flavor = &res->flavors->flavors[i];
5594 if ((char *)&sec_flavor[1] - (char *)res->flavors > PAGE_SIZE)
5607 res->flavors->num_flavors++;
5615 static int decode_secinfo(struct xdr_stream *xdr, struct nfs4_secinfo_res *res)
5620 return decode_secinfo_common(xdr, res);
5624 static int decode_secinfo_no_name(struct xdr_stream *xdr, struct nfs4_secinfo_res *res)
5629 return decode_secinfo_common(xdr, res);
5641 struct nfs41_exchange_id_res *res)
5656 xdr_decode_hyper(p, &res->clientid);
5660 res->seqid = be32_to_cpup(p++);
5661 res->flags = be32_to_cpup(p++);
5663 res->state_protect.how = be32_to_cpup(p);
5664 switch (res->state_protect.how) {
5668 status = decode_op_map(xdr, &res->state_protect.enforce);
5671 status = decode_op_map(xdr, &res->state_protect.allow);
5684 p = xdr_decode_hyper(p, &res->server_owner->minor_id);
5690 memcpy(res->server_owner->major_id, dummy_str, dummy);
5691 res->server_owner->major_id_sz = dummy;
5697 memcpy(res->server_scope->server_scope, dummy_str, dummy);
5698 res->server_scope->server_scope_sz = dummy;
5711 memcpy(res->impl_id->domain, dummy_str, dummy);
5717 memcpy(res->impl_id->name, dummy_str, dummy);
5723 p = xdr_decode_hyper(p, &res->impl_id->date.seconds);
5724 res->impl_id->date.nseconds = be32_to_cpup(p);
5768 struct nfs41_bind_conn_to_session_res *res)
5775 status = decode_sessionid(xdr, &res->sessionid);
5784 res->dir = be32_to_cpup(p++);
5785 if (res->dir == 0 || res->dir > NFS4_CDFS4_BOTH)
5788 res->use_conn_in_rdma_mode = false;
5790 res->use_conn_in_rdma_mode = true;
5796 struct nfs41_create_session_res *res)
5803 status = decode_sessionid(xdr, &res->sessionid);
5811 res->seqid = be32_to_cpup(p++);
5812 res->flags = be32_to_cpup(p);
5815 status = decode_chan_attrs(xdr, &res->fc_attrs);
5817 status = decode_chan_attrs(xdr, &res->bc_attrs);
5838 struct nfs4_sequence_res *res,
5848 if (res->sr_slot == NULL)
5850 if (!res->sr_slot->table->session)
5864 session = res->sr_slot->table->session;
5878 if (dummy != res->sr_slot->seq_nr) {
5884 if (dummy != res->sr_slot->slot_nr) {
5889 res->sr_highest_slotid = be32_to_cpup(p++);
5891 res->sr_target_highest_slotid = be32_to_cpup(p++);
5893 res->sr_status_flags = be32_to_cpup(p);
5896 res->sr_status = status;
5914 struct nfs4_getdeviceinfo_res *res)
5916 struct pnfs_device *pdev = res->pdev;
5964 res->notification = be32_to_cpup(p++);
5977 struct nfs4_layoutget_res *res)
5990 res->return_on_close = be32_to_cpup(p);
5991 decode_layout_stateid(xdr, &res->stateid);
6006 p = xdr_decode_hyper(p, &res->range.offset);
6007 p = xdr_decode_hyper(p, &res->range.length);
6008 res->range.iomode = be32_to_cpup(p++);
6009 res->type = be32_to_cpup(p++);
6010 res->layoutp->len = be32_to_cpup(p);
6014 (unsigned long)res->range.offset,
6015 (unsigned long)res->range.length,
6016 res->range.iomode,
6017 res->type,
6018 res->layoutp->len);
6020 recvd = xdr_read_pages(xdr, res->layoutp->len);
6021 if (res->layoutp->len > recvd) {
6024 res->layoutp->len, recvd);
6040 res->status = status;
6048 struct nfs4_layoutreturn_res *res)
6059 res->lrs_present = be32_to_cpup(p);
6060 if (res->lrs_present)
6061 status = decode_layout_stateid(xdr, &res->stateid);
6063 nfs4_stateid_copy(&res->stateid, &invalid_stateid);
6069 struct nfs4_layoutcommit_res *res)
6076 res->status = status;
6095 struct nfs41_test_stateid_res *res)
6115 res->status = be32_to_cpup(p++);
6121 struct nfs41_free_stateid_res *res)
6123 res->status = decode_op_hdr(xdr, OP_FREE_STATEID);
6124 return res->status;
6129 struct nfs4_layoutreturn_res *res)
6135 struct nfs4_layoutget_res *res)
6153 struct nfs_closeres *res = data;
6160 status = decode_sequence(xdr, &res->seq_res, rqstp);
6166 if (res->lr_res) {
6167 status = decode_layoutreturn(xdr, res->lr_res);
6168 res->lr_ret = status;
6172 status = decode_open_downgrade(xdr, res);
6183 struct nfs4_accessres *res = data;
6190 status = decode_sequence(xdr, &res->seq_res, rqstp);
6196 status = decode_access(xdr, &res->supported, &res->access);
6199 if (res->fattr)
6200 decode_getfattr(xdr, res->fattr, res->server);
6211 struct nfs4_lookup_res *res = data;
6218 status = decode_sequence(xdr, &res->seq_res, rqstp);
6227 status = decode_getfh(xdr, res->fh);
6230 status = decode_getfattr(xdr, res->fattr, res->server);
6241 struct nfs4_lookupp_res *res = data;
6248 status = decode_sequence(xdr, &res->seq_res, rqstp);
6257 status = decode_getfh(xdr, res->fh);
6260 status = decode_getfattr(xdr, res->fattr, res->server);
6272 struct nfs4_lookup_res *res = data;
6279 status = decode_sequence(xdr, &res->seq_res, rqstp);
6285 status = decode_getfh(xdr, res->fh);
6287 status = decode_getfattr(xdr, res->fattr, res->server);
6298 struct nfs_removeres *res = data;
6305 status = decode_sequence(xdr, &res->seq_res, rqstp);
6311 status = decode_remove(xdr, &res->cinfo);
6322 struct nfs_renameres *res = data;
6329 status = decode_sequence(xdr, &res->seq_res, rqstp);
6341 status = decode_rename(xdr, &res->old_cinfo, &res->new_cinfo);
6352 struct nfs4_link_res *res = data;
6359 status = decode_sequence(xdr, &res->seq_res, rqstp);
6371 status = decode_link(xdr, &res->cinfo);
6381 decode_getfattr(xdr, res->fattr, res->server);
6392 struct nfs4_create_res *res = data;
6399 status = decode_sequence(xdr, &res->seq_res, rqstp);
6405 status = decode_create(xdr, &res->dir_cinfo);
6408 status = decode_getfh(xdr, res->fh);
6411 decode_getfattr(xdr, res->fattr, res->server);
6420 void *res)
6422 return nfs4_xdr_dec_create(rqstp, xdr, res);
6431 struct nfs4_getattr_res *res = data;
6438 status = decode_sequence(xdr, &res->seq_res, rqstp);
6444 status = decode_getfattr(xdr, res->fattr, res->server);
6474 struct nfs_setaclres *res = data;
6481 status = decode_sequence(xdr, &res->seq_res, rqstp);
6499 struct nfs_getaclres *res = data;
6503 if (res->acl_scratch != NULL)
6504 xdr_set_scratch_page(xdr, res->acl_scratch);
6508 status = decode_sequence(xdr, &res->seq_res, rqstp);
6514 status = decode_getacl(xdr, rqstp, res, res->acl_type);
6526 struct nfs_closeres *res = data;
6533 status = decode_sequence(xdr, &res->seq_res, rqstp);
6539 if (res->lr_res) {
6540 status = decode_layoutreturn(xdr, res->lr_res);
6541 res->lr_ret = status;
6545 if (res->fattr != NULL) {
6546 status = decode_getfattr(xdr, res->fattr, res->server);
6550 status = decode_close(xdr, res);
6561 struct nfs_openres *res = data;
6568 status = decode_sequence(xdr, &res->seq_res, rqstp);
6574 status = decode_open(xdr, res);
6577 status = decode_getfh(xdr, &res->fh);
6580 if (res->access_request)
6581 decode_access(xdr, &res->access_supported, &res->access_result);
6582 decode_getfattr(xdr, res->f_attr, res->server);
6583 if (res->lg_res)
6584 decode_layoutget(xdr, rqstp, res->lg_res);
6596 struct nfs_open_confirmres *res = data;
6606 status = decode_open_confirm(xdr, res);
6618 struct nfs_openres *res = data;
6625 status = decode_sequence(xdr, &res->seq_res, rqstp);
6631 status = decode_open(xdr, res);
6634 if (res->access_request)
6635 decode_access(xdr, &res->access_supported, &res->access_result);
6636 decode_getfattr(xdr, res->f_attr, res->server);
6637 if (res->lg_res)
6638 decode_layoutget(xdr, rqstp, res->lg_res);
6650 struct nfs_setattrres *res = data;
6657 status = decode_sequence(xdr, &res->seq_res, rqstp);
6666 decode_getfattr(xdr, res->fattr, res->server);
6677 struct nfs_lock_res *res = data;
6684 status = decode_sequence(xdr, &res->seq_res, rqstp);
6690 status = decode_lock(xdr, res);
6701 struct nfs_lockt_res *res = data;
6708 status = decode_sequence(xdr, &res->seq_res, rqstp);
6714 status = decode_lockt(xdr, res);
6725 struct nfs_locku_res *res = data;
6732 status = decode_sequence(xdr, &res->seq_res, rqstp);
6738 status = decode_locku(xdr, res);
6762 struct nfs4_readlink_res *res = data;
6769 status = decode_sequence(xdr, &res->seq_res, rqstp);
6786 struct nfs4_readdir_res *res = data;
6793 status = decode_sequence(xdr, &res->seq_res, rqstp);
6799 status = decode_readdir(xdr, rqstp, res);
6810 struct nfs_pgio_res *res = data;
6815 res->op_status = hdr.status;
6818 status = decode_sequence(xdr, &res->seq_res, rqstp);
6824 status = decode_read(xdr, rqstp, res);
6826 status = res->count;
6837 struct nfs_pgio_res *res = data;
6842 res->op_status = hdr.status;
6845 status = decode_sequence(xdr, &res->seq_res, rqstp);
6851 status = decode_write(xdr, res);
6854 if (res->fattr)
6855 decode_getfattr(xdr, res->fattr, res->server);
6857 status = res->count;
6868 struct nfs_commitres *res = data;
6873 res->op_status = hdr.status;
6876 status = decode_sequence(xdr, &res->seq_res, rqstp);
6882 status = decode_commit(xdr, res);
6893 struct nfs4_fsinfo_res *res = data;
6899 status = decode_sequence(xdr, &res->seq_res, req);
6903 status = decode_fsinfo(xdr, res->fsinfo);
6913 struct nfs4_pathconf_res *res = data;
6919 status = decode_sequence(xdr, &res->seq_res, req);
6923 status = decode_pathconf(xdr, res->pathconf);
6933 struct nfs4_statfs_res *res = data;
6939 status = decode_sequence(xdr, &res->seq_res, req);
6943 status = decode_statfs(xdr, res->fsstat);
6954 struct nfs4_server_caps_res *res = data;
6961 status = decode_sequence(xdr, &res->seq_res, req);
6967 status = decode_server_caps(xdr, res);
6994 struct nfs4_setclientid_res *res = data;
7000 status = decode_setclientid(xdr, res);
7027 struct nfs4_delegreturnres *res = data;
7034 status = decode_sequence(xdr, &res->seq_res, rqstp);
7040 if (res->lr_res) {
7041 status = decode_layoutreturn(xdr, res->lr_res);
7042 res->lr_ret = status;
7046 if (res->fattr) {
7047 status = decode_getfattr(xdr, res->fattr, res->server);
7063 struct nfs4_fs_locations_res *res = data;
7070 status = decode_sequence(xdr, &res->seq_res, req);
7076 if (res->migration) {
7079 res->fs_locations->fattr,
7080 NULL, res->fs_locations,
7081 res->fs_locations->server);
7084 if (res->renew)
7092 res->fs_locations->fattr,
7093 NULL, res->fs_locations,
7094 res->fs_locations->server);
7107 struct nfs4_secinfo_res *res = data;
7114 status = decode_sequence(xdr, &res->seq_res, rqstp);
7120 status = decode_secinfo(xdr, res);
7132 struct nfs4_fsid_present_res *res = data;
7139 status = decode_sequence(xdr, &res->seq_res, rqstp);
7145 status = decode_getfh(xdr, res->fh);
7148 if (res->renew)
7160 void *res)
7167 status = decode_bind_conn_to_session(xdr, res);
7176 void *res)
7183 status = decode_exchange_id(xdr, res);
7192 void *res)
7199 status = decode_create_session(xdr, res);
7208 void *res)
7215 status = decode_destroy_session(xdr, res);
7224 void *res)
7231 status = decode_destroy_clientid(xdr, res);
7240 void *res)
7247 status = decode_sequence(xdr, res, rqstp);
7260 struct nfs4_get_lease_time_res *res = data;
7266 status = decode_sequence(xdr, &res->lr_seq_res, rqstp);
7270 status = decode_fsinfo(xdr, res->lr_fsinfo);
7283 struct nfs41_reclaim_complete_res *res = data;
7289 status = decode_sequence(xdr, &res->seq_res, rqstp);
7302 struct nfs4_getdeviceinfo_res *res = data;
7309 status = decode_sequence(xdr, &res->seq_res, rqstp);
7312 status = decode_getdeviceinfo(xdr, res);
7324 struct nfs4_layoutget_res *res = data;
7331 status = decode_sequence(xdr, &res->seq_res, rqstp);
7337 status = decode_layoutget(xdr, rqstp, res);
7349 struct nfs4_layoutreturn_res *res = data;
7356 status = decode_sequence(xdr, &res->seq_res, rqstp);
7362 status = decode_layoutreturn(xdr, res);
7374 struct nfs4_layoutcommit_res *res = data;
7381 status = decode_sequence(xdr, &res->seq_res, rqstp);
7387 status = decode_layoutcommit(xdr, rqstp, res);
7390 decode_getfattr(xdr, res->fattr, res->server);
7402 struct nfs4_secinfo_res *res = data;
7409 status = decode_sequence(xdr, &res->seq_res, rqstp);
7415 status = decode_secinfo_no_name(xdr, res);
7427 struct nfs41_test_stateid_res *res = data;
7434 status = decode_sequence(xdr, &res->seq_res, rqstp);
7437 status = decode_test_stateid(xdr, res);
7449 struct nfs41_free_stateid_res *res = data;
7456 status = decode_sequence(xdr, &res->seq_res, rqstp);
7459 status = decode_free_stateid(xdr, res);