Lines Matching refs:res
710 struct nfs4_sequence_res *res, int cache_reply,
717 res->sr_slot = NULL;
720 static void nfs40_sequence_free_slot(struct nfs4_sequence_res *res)
722 struct nfs4_slot *slot = res->sr_slot;
731 res->sr_slot = NULL;
735 struct nfs4_sequence_res *res)
737 if (res->sr_slot != NULL)
738 nfs40_sequence_free_slot(res);
783 static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res)
785 nfs41_release_slot(res->sr_slot);
786 res->sr_slot = NULL;
810 struct nfs4_sequence_res *res)
813 struct nfs4_slot *slot = res->sr_slot;
827 trace_nfs4_sequence_done(session, res);
829 status = res->sr_status;
840 do_renew_lease(clp, res->sr_timestamp);
842 nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags,
844 nfs41_update_target_slotid(slot->table, slot, res);
896 res->sr_slot = NULL;
922 dprintk("%s: Error %d free the slot \n", __func__, res->sr_status);
929 nfs41_sequence_free_slot(res);
935 nfs41_sequence_free_slot(res);
947 int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
949 if (!nfs41_sequence_process(task, res))
951 if (res->sr_slot != NULL)
952 nfs41_sequence_free_slot(res);
958 static int nfs4_sequence_process(struct rpc_task *task, struct nfs4_sequence_res *res)
960 if (res->sr_slot == NULL)
962 if (res->sr_slot->table->session != NULL)
963 return nfs41_sequence_process(task, res);
964 return nfs40_sequence_done(task, res);
967 static void nfs4_sequence_free_slot(struct nfs4_sequence_res *res)
969 if (res->sr_slot != NULL) {
970 if (res->sr_slot->table->session != NULL)
971 nfs41_sequence_free_slot(res);
973 nfs40_sequence_free_slot(res);
977 int nfs4_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
979 if (res->sr_slot == NULL)
981 if (!res->sr_slot->table->session)
982 return nfs40_sequence_done(task, res);
983 return nfs41_sequence_done(task, res);
1011 static int nfs4_sequence_process(struct rpc_task *task, struct nfs4_sequence_res *res)
1013 return nfs40_sequence_done(task, res);
1016 static void nfs4_sequence_free_slot(struct nfs4_sequence_res *res)
1018 if (res->sr_slot != NULL)
1019 nfs40_sequence_free_slot(res);
1023 struct nfs4_sequence_res *res)
1025 return nfs40_sequence_done(task, res);
1031 static void nfs41_sequence_res_init(struct nfs4_sequence_res *res)
1033 res->sr_timestamp = jiffies;
1034 res->sr_status_flags = 0;
1035 res->sr_status = 1;
1040 struct nfs4_sequence_res *res,
1048 res->sr_slot = slot;
1053 struct nfs4_sequence_res *res,
1061 if (res->sr_slot != NULL)
1080 nfs4_sequence_attach_slot(args, res, slot);
1084 nfs41_sequence_res_init(res);
1144 struct nfs4_sequence_res *res,
1151 .seq_res = res,
1168 struct nfs4_sequence_res *res)
1174 return nfs4_do_call_sync(clnt, server, msg, args, res, task_flags);
1182 struct nfs4_sequence_res *res,
1185 nfs4_init_sequence(args, res, cache_reply, 0);
1186 return nfs4_call_sync_sequence(clnt, server, msg, args, res);
1301 u32 res = 0;
1305 res = NFS4_SHARE_ACCESS_READ;
1308 res = NFS4_SHARE_ACCESS_WRITE;
1311 res = NFS4_SHARE_ACCESS_BOTH;
1317 res |= NFS4_SHARE_WANT_NO_DELEG;
1319 return res;
3232 struct nfs4_state *res;
3245 res = ctx->state;
3289 res = ERR_PTR(nfs4_handle_exception(server,
3292 return res;
3297 struct nfs_setattrres *res,
3305 .rpc_resp = res,
3313 nfs_fattr_init(res->fattr);
3345 status = nfs4_call_sync(server->client, server, &msg, &arg->seq_args, &res->seq_res, 1);
3368 struct nfs_setattrres res = {
3389 err = _nfs4_do_setattr(inode, &arg, &res, cred, ctx);
3521 struct nfs_closeres res;
3524 struct nfs4_layoutreturn_res res;
3540 pnfs_roc_release(&calldata->lr.arg, &calldata->lr.res,
3541 calldata->res.lr_ret);
3561 if (!nfs4_sequence_done(task, &calldata->res.seq_res))
3563 trace_nfs4_close(state, &calldata->arg, &calldata->res, task->tk_status);
3566 if (pnfs_roc_done(task, &calldata->arg.lr_args, &calldata->res.lr_res,
3567 &calldata->res.lr_ret) == -EAGAIN)
3575 res_stateid = &calldata->res.stateid;
3581 calldata->res.fattr = NULL;
3675 calldata->res.lr_res = NULL;
3696 if (calldata->res.fattr == NULL)
3699 calldata->res.fattr = NULL;
3703 &calldata->res.seq_res,
3710 nfs4_sequence_done(task, &calldata->res.seq_res);
3759 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 1, 0);
3773 calldata->res.fattr = &calldata->fattr;
3774 calldata->res.seqid = calldata->arg.seqid;
3775 calldata->res.server = server;
3776 calldata->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
3778 &calldata->lr.arg, &calldata->lr.res, msg.rpc_cred);
3781 calldata->res.lr_res = &calldata->lr.res;
3786 msg.rpc_resp = &calldata->res;
3844 struct nfs4_server_caps_res res = {};
3848 .rpc_resp = &res,
3863 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
3868 res.attr_bitmask[1] &= FATTR4_WORD1_NFS40_MASK;
3869 res.attr_bitmask[2] = 0;
3872 res.attr_bitmask[2] &= FATTR4_WORD2_NFS41_MASK;
3875 res.attr_bitmask[2] &= FATTR4_WORD2_NFS42_MASK;
3877 memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
3881 if (res.attr_bitmask[0] & FATTR4_WORD0_ACL &&
3882 res.acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)
3884 if (res.has_links != 0)
3886 if (res.has_symlinks != 0)
3888 if (res.case_insensitive)
3890 if (res.case_preserving)
3893 if (res.attr_bitmask[2] & FATTR4_WORD2_SECURITY_LABEL)
3896 if (res.attr_bitmask[0] & FATTR4_WORD0_FS_LOCATIONS)
3898 if (!(res.attr_bitmask[0] & FATTR4_WORD0_FILEID))
3900 if (!(res.attr_bitmask[1] & FATTR4_WORD1_MODE))
3902 if (!(res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS))
3904 if (!(res.attr_bitmask[1] & FATTR4_WORD1_OWNER))
3907 if (!(res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP))
3910 if (!(res.attr_bitmask[1] & FATTR4_WORD1_SPACE_USED))
3912 if (!(res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS))
3914 if (!(res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA))
3916 if (!(res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY))
3918 memcpy(server->attr_bitmask_nl, res.attr_bitmask,
3922 memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
3928 for (i = 0; i < ARRAY_SIZE(res.exclcreat_bitmask); i++)
3929 res.exclcreat_bitmask[i] &= res.attr_bitmask[i];
3930 memcpy(server->exclcreat_bitmask, res.exclcreat_bitmask,
3933 server->acl_bitmask = res.acl_bitmask;
3934 server->fh_expire_type = res.fh_expire_type;
4080 struct nfs4_lookup_res res = {
4088 .rpc_resp = &res,
4099 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4304 struct nfs4_getattr_res res = {
4311 .rpc_resp = &res,
4324 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0, 0);
4326 &args.seq_args, &res.seq_res, task_flags);
4417 struct nfs4_lookup_res res = {
4425 .rpc_resp = &res,
4441 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0, 0);
4443 &args.seq_args, &res.seq_res, task_flags);
4539 struct nfs4_lookupp_res res = {
4547 .rpc_resp = &res,
4560 &res.seq_res, task_flags);
4589 struct nfs4_accessres res = {
4595 .rpc_resp = &res,
4601 res.fattr = nfs_alloc_fattr();
4602 if (res.fattr == NULL)
4606 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
4608 nfs_access_set_mask(entry, res.access);
4609 if (res.fattr)
4610 nfs_refresh_inode(inode, res.fattr);
4612 nfs_free_fattr(res.fattr);
4663 struct nfs4_readlink_res res;
4667 .rpc_resp = &res,
4670 return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0);
4729 struct nfs_removeres res = {
4735 .rpc_resp = &res,
4740 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
4746 nfs4_update_changeattr_locked(dir, &res.cinfo, timestamp,
4797 struct nfs_removeres *res = msg->rpc_resp;
4799 res->server = NFS_SB(dentry->d_sb);
4801 nfs4_init_sequence(&args->seq_args, &res->seq_res, 1, 0);
4803 nfs_fattr_init(res->dir_attr);
4815 &data->res.seq_res,
4822 struct nfs_removeres *res = &data->res;
4824 if (!nfs4_sequence_done(task, &res->seq_res))
4826 if (nfs4_async_handle_error(task, res->server, NULL,
4830 nfs4_update_changeattr(dir, &res->cinfo,
4831 res->dir_attr->time_start,
4841 struct nfs_renameres *res = msg->rpc_resp;
4850 res->server = NFS_SB(old_dentry->d_sb);
4851 nfs4_init_sequence(&arg->seq_args, &res->seq_res, 1, 0);
4858 &data->res.seq_res,
4866 struct nfs_renameres *res = &data->res;
4868 if (!nfs4_sequence_done(task, &res->seq_res))
4870 if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN)
4877 nfs4_update_changeattr(old_dir, &res->old_cinfo,
4878 res->old_fattr->time_start,
4881 nfs4_update_changeattr(new_dir, &res->new_cinfo,
4882 res->new_fattr->time_start,
4886 nfs4_update_changeattr(old_dir, &res->old_cinfo,
4887 res->old_fattr->time_start,
4903 struct nfs4_link_res res = {
4909 .rpc_resp = &res,
4913 res.fattr = nfs_alloc_fattr_with_label(server);
4914 if (res.fattr == NULL)
4918 nfs4_bitmap_copy_adjust(bitmask, nfs4_bitmask(server, res.fattr->label), inode,
4920 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
4922 nfs4_update_changeattr(dir, &res.cinfo, res.fattr->time_start,
4925 status = nfs_post_op_update_inode(inode, res.fattr);
4927 nfs_setsecurity(inode, res.fattr);
4931 nfs_free_fattr(res.fattr);
4952 struct nfs4_create_res res;
4972 data->msg.rpc_resp = &data->res;
4980 data->res.server = server;
4981 data->res.fh = &data->fh;
4982 data->res.fattr = &data->fattr;
4983 nfs_fattr_init(data->res.fattr);
4994 &data->arg.seq_args, &data->res.seq_res, 1);
5000 nfs4_update_changeattr_locked(dir, &data->res.dir_cinfo,
5001 data->res.fattr->time_start,
5004 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
5119 struct nfs4_readdir_res res;
5123 .rpc_resp = &res,
5136 res.pgbase = args.pgbase;
5138 &res.seq_res, 0);
5140 memcpy(nr_res->verf, res.verifier.data, NFS4_VERIFIER_SIZE);
5151 struct nfs_readdir_res *res)
5158 err = _nfs4_proc_readdir(arg, res);
5234 struct nfs4_statfs_res res = {
5240 .rpc_resp = &res,
5244 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
5268 struct nfs4_fsinfo_res res = {
5274 .rpc_resp = &res,
5277 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
5321 struct nfs4_pathconf_res res = {
5327 .rpc_resp = &res,
5337 return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
5449 if (!nfs4_sequence_done(task, &hdr->res.seq_res))
5488 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 0, 0);
5496 &hdr->res.seq_res,
5551 if (!nfs4_sequence_done(task, &hdr->res.seq_res))
5612 hdr->res.fattr = NULL;
5622 hdr->res.server = server;
5626 nfs4_init_sequence(&hdr->args.seq_args, &hdr->res.seq_res, 0, 0);
5634 &data->res.seq_res,
5653 if (!nfs4_sequence_done(task, &data->res.seq_res))
5665 data->res.server = server;
5667 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, 0);
5673 struct nfs_commitres *res)
5680 .rpc_resp = res,
5685 &args->seq_args, &res->seq_res, 1);
5688 int nfs4_proc_commit(struct file *dst, __u64 offset, __u32 count, struct nfs_commitres *res)
5699 status = _nfs4_proc_commit(dst, &args, res);
5940 struct nfs_getaclres res = {
5947 .rpc_resp = &res,
5970 res.acl_scratch = alloc_page(GFP_KERNEL);
5971 if (!res.acl_scratch)
5979 &msg, &args.seq_args, &res.seq_res, 0);
5984 if (res.acl_flags & NFS4_ACL_TRUNC) {
5991 nfs4_write_cached_acl(inode, pages, res.acl_data_offset, res.acl_len,
5994 if (res.acl_len > buflen) {
5998 _copy_from_pages(buf, pages, res.acl_data_offset, res.acl_len);
6001 ret = res.acl_len;
6005 if (res.acl_scratch)
6006 __free_page(res.acl_scratch);
6060 struct nfs_setaclres res;
6064 .rpc_resp = &res,
6080 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
6140 struct nfs4_getattr_res res = {
6147 .rpc_resp = &res,
6153 ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 0);
6196 struct nfs_setattrres res = {
6203 .rpc_resp = &res,
6209 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
6424 * @res: where to place the result
6430 struct nfs4_setclientid_res *res)
6441 .rpc_resp = res,
6524 struct nfs4_delegreturnres res;
6530 struct nfs4_layoutreturn_res res;
6549 if (!nfs4_sequence_done(task, &data->res.seq_res))
6552 trace_nfs4_delegreturn_exit(&data->args, &data->res, task->tk_status);
6555 if (pnfs_roc_done(task, &data->args.lr_args, &data->res.lr_res,
6556 &data->res.lr_ret) == -EAGAIN)
6561 renew_lease(data->res.server, data->timestamp);
6566 nfs4_free_revoked_stateid(data->res.server,
6580 data->res.fattr = NULL;
6586 data->res.fattr = NULL;
6592 data->res.server, task->tk_status,
6611 pnfs_roc_release(&data->lr.arg, &data->lr.res,
6612 data->res.lr_ret);
6630 nfs4_sequence_done(task, &d_data->res.seq_res);
6637 d_data->res.lr_res = NULL;
6640 nfs4_setup_sequence(d_data->res.server->nfs_client,
6642 &d_data->res.seq_res,
6687 data->res.fattr = &data->fattr;
6688 data->res.server = server;
6689 data->res.lr_ret = -NFS4ERR_NOMATCHING_LAYOUT;
6691 nfs_fattr_init(data->res.fattr);
6696 data->lr.roc = pnfs_roc(inode, &data->lr.arg, &data->lr.res,
6700 data->res.lr_res = &data->lr.res;
6705 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1,
6708 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1,
6712 msg.rpc_resp = &data->res;
6755 struct nfs_lockt_res res = {
6761 .rpc_resp = &res,
6774 status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
6842 struct nfs_locku_res res;
6866 p->res.seqid = seqid;
6898 if (!nfs4_sequence_done(task, &calldata->res.seq_res))
6905 &calldata->res.stateid))
6952 &calldata->res.seq_res,
6959 nfs4_sequence_done(task, &calldata->res.seq_res);
7005 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1, 0);
7007 msg.rpc_resp = &data->res;
7064 struct nfs_lock_res res;
7099 p->res.lock_seqid = p->arg.lock_seqid;
7128 data->res.open_seqid = data->arg.open_seqid;
7142 &data->res.seq_res,
7150 nfs4_sequence_done(task, &data->res.seq_res);
7159 if (!nfs4_sequence_done(task, &data->res.seq_res))
7174 nfs4_stateid_copy(&lsp->ls_stateid, &data->res.stateid);
7176 } else if (!nfs4_update_lock_stateid(lsp, &data->res.stateid))
7275 nfs4_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1,
7278 msg.rpc_resp = &data->res;
7296 trace_nfs4_set_lock(fl, state, &data->res.stateid, cmd, ret);
7631 struct nfs_release_lockowner_res res;
7640 &data->res.seq_res, task);
7650 nfs40_sequence_done(task, &data->res.seq_res);
7702 msg.rpc_resp = &data->res;
7703 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 0, 0);
7989 struct nfs4_fs_locations_res res = {
7995 .rpc_resp = &res,
8014 status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0);
8062 struct nfs4_fs_locations_res res = {
8070 .rpc_resp = &res,
8080 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0, 1);
8082 &args.seq_args, &res.seq_res);
8117 struct nfs4_fs_locations_res res = {
8124 .rpc_resp = &res,
8130 .seq_res = &res.seq_res,
8145 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0, 1);
8148 res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED)
8219 struct nfs4_fsid_present_res res = {
8225 .rpc_resp = &res,
8231 res.fh = nfs_alloc_fhandle();
8232 if (res.fh == NULL)
8235 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0, 1);
8237 &args.seq_args, &res.seq_res);
8238 nfs_free_fhandle(res.fh);
8262 struct nfs4_fsid_present_res res = {
8267 .rpc_resp = &res,
8272 res.fh = nfs_alloc_fhandle();
8273 if (res.fh == NULL)
8276 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0, 1);
8278 &args.seq_args, &res.seq_res);
8279 nfs_free_fhandle(res.fh);
8281 res.seq_res.sr_status_flags & SEQ4_STATUS_LEASE_MOVED)
8344 struct nfs4_secinfo_res res = {
8350 .rpc_resp = &res,
8355 .seq_res = &res.seq_res,
8377 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0, 0);
8451 struct nfs41_bind_conn_to_session_res *res = task->tk_msg.rpc_resp;
8462 res->dir != NFS4_CDFS4_BOTH) {
8491 struct nfs41_bind_conn_to_session_res res;
8496 .rpc_resp = &res,
8524 if (memcmp(res.sessionid.data,
8529 if ((res.dir & args.dir) != res.dir || res.dir == 0) {
8534 if (res.use_conn_in_rdma_mode != args.use_conn_in_rdma_mode) {
8699 struct nfs41_exchange_id_res res;
8709 kfree(cdata->res.impl_id);
8710 kfree(cdata->res.server_scope);
8711 kfree(cdata->res.server_owner);
8755 calldata->res.server_owner = kzalloc(sizeof(struct nfs41_server_owner),
8758 if (unlikely(calldata->res.server_owner == NULL))
8761 calldata->res.server_scope = kzalloc(sizeof(struct nfs41_server_scope),
8763 if (unlikely(calldata->res.server_scope == NULL))
8766 calldata->res.impl_id = kzalloc(sizeof(struct nfs41_impl_id), GFP_NOFS);
8767 if (unlikely(calldata->res.impl_id == NULL))
8800 msg.rpc_resp = &calldata->res;
8806 kfree(calldata->res.impl_id);
8808 kfree(calldata->res.server_scope);
8810 kfree(calldata->res.server_owner);
9031 struct nfs4_get_lease_time_res *res;
9045 &data->res->lr_seq_res,
9058 if (!nfs4_sequence_done(task, &data->res->lr_seq_res))
9080 struct nfs4_get_lease_time_res res = {
9085 .res = &res,
9091 .rpc_resp = &res,
9101 nfs4_init_sequence(&args.la_seq_args, &res.lr_seq_res, 0, 1);
9156 struct nfs41_create_session_res *res)
9159 struct nfs4_channel_attrs *rcvd = &res->fc_attrs;
9179 struct nfs41_create_session_res *res)
9182 struct nfs4_channel_attrs *rcvd = &res->bc_attrs;
9184 if (!(res->flags & SESSION4_BACK_CHAN))
9201 struct nfs41_create_session_res *res)
9205 ret = nfs4_verify_fore_channel_attrs(args, res);
9208 return nfs4_verify_back_channel_attrs(args, res);
9212 struct nfs41_create_session_res *res)
9214 nfs4_copy_sessionid(&session->sess_id, &res->sessionid);
9218 session->flags = res->flags;
9219 memcpy(&session->fc_attrs, &res->fc_attrs, sizeof(session->fc_attrs));
9220 if (res->flags & SESSION4_BACK_CHAN)
9221 memcpy(&session->bc_attrs, &res->bc_attrs,
9235 struct nfs41_create_session_res res;
9240 .rpc_resp = &res,
9264 status = nfs4_verify_channel_attrs(&args, &res);
9268 nfs4_update_session(session, &res);
9347 struct nfs4_sequence_res res;
9400 struct nfs4_sequence_res *res;
9403 res = task->tk_msg.rpc_resp;
9405 nfs4_setup_sequence(clp, args, res, task);
9440 nfs4_init_sequence(&calldata->args, &calldata->res, 0, is_privileged);
9441 nfs4_sequence_attach_slot(&calldata->args, &calldata->res, slot);
9443 msg.rpc_resp = &calldata->res;
9496 struct nfs41_reclaim_complete_res res;
9505 &calldata->res.seq_res,
9540 struct nfs4_sequence_res *res = &calldata->res.seq_res;
9542 if (!nfs41_sequence_done(task, res))
9590 nfs4_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 0, 1);
9592 msg.rpc_resp = &calldata->res;
9607 &lgp->res.seq_res, task);
9614 nfs41_sequence_process(task, &lgp->res.seq_res);
9630 nfs4_sequence_free_slot(&lgp->res.seq_res);
9717 nfs4_sequence_free_slot(&lgp->res.seq_res);
9736 .rpc_resp = &lgp->res,
9754 nfs4_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0, 0);
9767 } else if (lgp->res.layoutp->len == 0) {
9775 &lgp->res.range,
9776 &lgp->res.stateid,
9793 &lrp->res.seq_res,
9804 if (!nfs41_sequence_process(task, &lrp->res.seq_res))
9812 lrp->res.lrs_present = 0;
9837 nfs4_sequence_free_slot(&lrp->res.seq_res);
9847 lrp->res.lrs_present ? &lrp->res.stateid : NULL);
9848 nfs4_sequence_free_slot(&lrp->res.seq_res);
9869 .rpc_resp = &lrp->res,
9894 nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1,
9897 nfs4_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1,
9920 struct nfs4_getdeviceinfo_res res = {
9926 .rpc_resp = &res,
9931 status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
9932 if (res.notification & ~args.notify_types)
9934 if (res.notification != args.notify_types)
9967 &data->res.seq_res,
9977 if (!nfs41_sequence_done(task, &data->res.seq_res))
10003 data->res.fattr);
10021 .rpc_resp = &data->res,
10048 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, 0);
10072 struct nfs4_secinfo_res res = {
10078 .rpc_resp = &res,
10083 .seq_res = &res.seq_res,
10102 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0, 0);
10227 struct nfs41_test_stateid_res res;
10231 .rpc_resp = &res,
10240 nfs4_init_sequence(&args.seq_args, &res.seq_res, 0, 1);
10242 &args.seq_args, &res.seq_res);
10247 dprintk("NFS reply test_stateid: succeeded, %d\n", -res.status);
10248 return -res.status;
10298 struct nfs41_free_stateid_res res;
10306 &data->res.seq_res,
10314 nfs41_sequence_done(task, &data->res.seq_res);
10383 msg.rpc_resp = &data->res;
10384 nfs4_init_sequence(&data->args.seq_args, &data->res.seq_res, 1, privileged);