Lines Matching defs:task
625 nfs4_async_handle_exception(struct rpc_task *task, struct nfs_server *server,
633 rpc_delay(task, nfs4_update_delay(&exception->timeout));
639 rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL);
641 rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task);
655 rpc_task_release_transport(task);
661 nfs4_async_handle_error(struct rpc_task *task, struct nfs_server *server,
668 if (task->tk_status >= 0)
672 task->tk_status = nfs4_async_handle_exception(task, server,
673 task->tk_status,
739 static int nfs40_sequence_done(struct rpc_task *task,
809 struct rpc_task *task = _nfs41_proc_sequence(client, cred, slot, true);
810 if (!IS_ERR(task))
811 rpc_put_task_async(task);
814 static int nfs41_sequence_process(struct rpc_task *task,
825 /* don't increment the sequence number if the task wasn't sent */
826 if (!RPC_WAS_SENT(task) || slot->seq_done)
835 if (task->tk_status == -NFS4ERR_DEADSESSION)
899 if (task->tk_msg.rpc_proc != &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE]) {
900 nfs4_probe_sequence(clp, task->tk_msg.rpc_cred, slot);
939 if (rpc_restart_call_prepare(task)) {
941 task->tk_status = 0;
946 if (!rpc_restart_call(task))
948 rpc_delay(task, NFS4_POLL_RETRY_MAX);
952 int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
954 if (!nfs41_sequence_process(task, res))
963 static int nfs4_sequence_process(struct rpc_task *task, struct nfs4_sequence_res *res)
968 return nfs41_sequence_process(task, res);
969 return nfs40_sequence_done(task, res);
982 int nfs4_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
987 return nfs40_sequence_done(task, res);
988 return nfs41_sequence_done(task, res);
992 static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata)
999 data->seq_args, data->seq_res, task);
1002 static void nfs41_call_sync_done(struct rpc_task *task, void *calldata)
1006 nfs41_sequence_done(task, data->seq_res);
1016 static int nfs4_sequence_process(struct rpc_task *task, struct nfs4_sequence_res *res)
1018 return nfs40_sequence_done(task, res);
1027 int nfs4_sequence_done(struct rpc_task *task,
1030 return nfs40_sequence_done(task, res);
1059 struct rpc_task *task)
1090 rpc_call_start(task);
1095 rpc_sleep_on_priority_timeout(&tbl->slot_tbl_waitq, task,
1098 rpc_sleep_on_timeout(&tbl->slot_tbl_waitq, task,
1104 rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task,
1107 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
1113 static void nfs40_call_sync_prepare(struct rpc_task *task, void *calldata)
1117 data->seq_args, data->seq_res, task);
1120 static void nfs40_call_sync_done(struct rpc_task *task, void *calldata)
1123 nfs4_sequence_done(task, data->seq_res);
1134 struct rpc_task *task;
1136 task = rpc_run_task(task_setup);
1137 if (IS_ERR(task))
1138 return PTR_ERR(task);
1140 ret = task->tk_status;
1141 rpc_put_task(task);
2332 static void nfs4_open_confirm_prepare(struct rpc_task *task, void *calldata)
2337 &data->c_arg.seq_args, &data->c_res.seq_res, task);
2340 static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
2344 nfs40_sequence_done(task, &data->c_res.seq_res);
2346 data->rpc_status = task->tk_status;
2385 struct rpc_task *task;
2408 task = rpc_run_task(&task_setup_data);
2409 if (IS_ERR(task))
2410 return PTR_ERR(task);
2411 status = rpc_wait_for_completion_task(task);
2417 rpc_put_task(task);
2421 static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
2428 if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
2457 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
2463 task) != 0)
2480 task->tk_action = NULL;
2482 nfs4_sequence_done(task, &data->o_res.seq_res);
2485 static void nfs4_open_done(struct rpc_task *task, void *calldata)
2489 data->rpc_status = task->tk_status;
2491 if (!nfs4_sequence_process(task, &data->o_res.seq_res))
2494 if (task->tk_status == 0) {
2550 struct rpc_task *task;
2580 task = rpc_run_task(&task_setup_data);
2581 if (IS_ERR(task))
2582 return PTR_ERR(task);
2583 status = rpc_wait_for_completion_task(task);
2589 rpc_put_task(task);
3412 nfs4_wait_on_layoutreturn(struct inode *inode, struct rpc_task *task)
3417 return pnfs_wait_on_layoutreturn(inode, task);
3548 static void nfs4_close_done(struct rpc_task *task, void *data)
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,
3573 switch (task->tk_status) {
3597 task->tk_msg.rpc_cred);
3604 task->tk_status = nfs4_async_handle_exception(task,
3605 server, task->tk_status, &exception);
3612 task->tk_status = 0;
3615 dprintk("%s: done, ret = %d!\n", __func__, task->tk_status);
3618 task->tk_status = 0;
3619 rpc_restart_call_prepare(task);
3623 static void nfs4_close_prepare(struct rpc_task *task, void *data)
3634 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
3637 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
3668 if (!calldata->lr.roc && nfs4_wait_on_layoutreturn(inode, task)) {
3680 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE];
3705 task) != 0)
3710 task->tk_action = NULL;
3712 nfs4_sequence_done(task, &calldata->res.seq_res);
3738 struct rpc_task *task;
3787 task = rpc_run_task(&task_setup_data);
3788 if (IS_ERR(task))
3789 return PTR_ERR(task);
3792 status = rpc_wait_for_completion_task(task);
3793 rpc_put_task(task);
4684 static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
4689 task);
4692 static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
4694 struct nfs_unlinkdata *data = task->tk_calldata;
4697 if (!nfs4_sequence_done(task, &res->seq_res))
4699 if (nfs4_async_handle_error(task, res->server, NULL,
4702 if (task->tk_status == 0)
4727 static void nfs4_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
4732 task);
4735 static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
4738 struct nfs_renamedata *data = task->tk_calldata;
4741 if (!nfs4_sequence_done(task, &res->seq_res))
4743 if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN)
4746 if (task->tk_status == 0) {
5278 static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_pgio_header *hdr)
5282 trace_nfs4_read(hdr, task->tk_status);
5283 if (task->tk_status < 0) {
5289 task->tk_status = nfs4_async_handle_exception(task,
5290 server, task->tk_status, &exception);
5292 rpc_restart_call_prepare(task);
5297 if (task->tk_status > 0)
5302 static bool nfs4_read_stateid_changed(struct rpc_task *task,
5306 if (!nfs4_error_stateid_expired(task->tk_status) ||
5312 rpc_restart_call_prepare(task);
5316 static bool nfs4_read_plus_not_supported(struct rpc_task *task,
5320 struct rpc_message *msg = &task->tk_msg;
5323 server->caps & NFS_CAP_READ_PLUS && task->tk_status == -ENOTSUPP) {
5326 rpc_restart_call_prepare(task);
5332 static int nfs4_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
5336 if (!nfs4_sequence_done(task, &hdr->res.seq_res))
5338 if (nfs4_read_stateid_changed(task, &hdr->args))
5340 if (nfs4_read_plus_not_supported(task, hdr))
5342 if (task->tk_status > 0)
5344 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) :
5345 nfs4_read_done_cb(task, hdr);
5373 static int nfs4_proc_pgio_rpc_prepare(struct rpc_task *task,
5379 task))
5390 static int nfs4_write_done_cb(struct rpc_task *task,
5395 trace_nfs4_write(hdr, task->tk_status);
5396 if (task->tk_status < 0) {
5402 task->tk_status = nfs4_async_handle_exception(task,
5403 NFS_SERVER(inode), task->tk_status,
5406 rpc_restart_call_prepare(task);
5410 if (task->tk_status >= 0) {
5417 static bool nfs4_write_stateid_changed(struct rpc_task *task,
5421 if (!nfs4_error_stateid_expired(task->tk_status) ||
5427 rpc_restart_call_prepare(task);
5431 static int nfs4_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
5433 if (!nfs4_sequence_done(task, &hdr->res.seq_res))
5435 if (nfs4_write_stateid_changed(task, &hdr->args))
5437 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) :
5438 nfs4_write_done_cb(task, hdr);
5516 static void nfs4_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
5521 task);
5524 static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_commit_data *data)
5528 trace_nfs4_commit(data, task->tk_status);
5529 if (nfs4_async_handle_error(task, NFS_SERVER(inode),
5531 rpc_restart_call_prepare(task);
5537 static int nfs4_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
5539 if (!nfs4_sequence_done(task, &data->res.seq_res))
5541 return data->commit_done_cb(task, data);
5612 static void nfs4_renew_done(struct rpc_task *task, void *calldata)
5618 trace_nfs4_renew_async(clp, task->tk_status);
5619 switch (task->tk_status) {
5629 if (task->tk_status != NFS4ERR_CB_PATH_DOWN) {
6282 static void nfs4_setclientid_done(struct rpc_task *task, void *calldata)
6286 if (task->tk_status == 0)
6287 sc->sc_cred = get_rpccred(task->tk_rqstp->rq_cred);
6416 static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
6425 if (!nfs4_sequence_done(task, &data->res.seq_res))
6428 trace_nfs4_delegreturn_exit(&data->args, &data->res, task->tk_status);
6431 if (pnfs_roc_done(task, &data->args.lr_args, &data->res.lr_res,
6435 switch (task->tk_status) {
6444 task->tk_msg.rpc_cred);
6449 task->tk_status = 0;
6467 task->tk_status = nfs4_async_handle_exception(task,
6468 data->res.server, task->tk_status,
6474 data->rpc_status = task->tk_status;
6477 task->tk_status = 0;
6478 rpc_restart_call_prepare(task);
6498 static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data)
6505 if (!d_data->lr.roc && nfs4_wait_on_layoutreturn(d_data->inode, task)) {
6506 nfs4_sequence_done(task, &d_data->res.seq_res);
6519 task);
6532 struct rpc_task *task;
6587 task = rpc_run_task(&task_setup_data);
6588 if (IS_ERR(task))
6589 return PTR_ERR(task);
6592 status = rpc_wait_for_completion_task(task);
6597 rpc_put_task(task);
6764 static void nfs4_locku_done(struct rpc_task *task, void *data)
6772 if (!nfs4_sequence_done(task, &calldata->res.seq_res))
6774 switch (task->tk_status) {
6786 task->tk_msg.rpc_cred);
6792 rpc_restart_call_prepare(task);
6797 rpc_restart_call_prepare(task);
6800 task->tk_status = nfs4_async_handle_exception(task,
6801 calldata->server, task->tk_status,
6804 rpc_restart_call_prepare(task);
6809 static void nfs4_locku_prepare(struct rpc_task *task, void *data)
6814 nfs_async_iocounter_wait(task, calldata->l_ctx))
6817 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
6827 task) != 0)
6831 task->tk_action = NULL;
6833 nfs4_sequence_done(task, &calldata->res.seq_res);
6890 struct rpc_task *task;
6920 task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);
6921 status = PTR_ERR(task);
6922 if (IS_ERR(task))
6924 status = rpc_wait_for_completion_task(task);
6925 rpc_put_task(task);
6983 static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
6989 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
6993 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) {
7007 task->tk_action = NULL;
7014 task) == 0)
7021 nfs4_sequence_done(task, &data->res.seq_res);
7025 static void nfs4_lock_done(struct rpc_task *task, void *calldata)
7033 if (!nfs4_sequence_done(task, &data->res.seq_res))
7036 data->rpc_status = task->tk_status;
7037 switch (task->tk_status) {
7067 else if (nfs4_async_handle_error(task, server, lsp->ls_state, NULL) == -EAGAIN)
7078 rpc_restart_call_prepare(task);
7089 struct rpc_task *task;
7090 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
7092 if (!IS_ERR(task))
7093 rpc_put_task_async(task);
7129 struct rpc_task *task;
7161 task = rpc_run_task(&task_setup_data);
7162 if (IS_ERR(task))
7163 return PTR_ERR(task);
7164 ret = rpc_wait_for_completion_task(task);
7173 rpc_put_task(task);
7320 struct task_struct *task;
7347 wait->private = waiter->task;
7366 struct nfs4_lock_waiter waiter = { .task = current,
7483 static void nfs4_release_lockowner_prepare(struct rpc_task *task, void *calldata)
7488 &data->res.seq_res, task);
7493 static void nfs4_release_lockowner_done(struct rpc_task *task, void *calldata)
7498 nfs40_sequence_done(task, &data->res.seq_res);
7500 switch (task->tk_status) {
7510 if (nfs4_async_handle_error(task, server,
7512 rpc_restart_call_prepare(task);
8231 nfs4_bind_one_conn_to_session_done(struct rpc_task *task, void *calldata)
8233 struct nfs41_bind_conn_to_session_args *args = task->tk_msg.rpc_argp;
8234 struct nfs41_bind_conn_to_session_res *res = task->tk_msg.rpc_resp;
8237 switch (task->tk_status) {
8241 task->tk_status);
8246 rpc_task_close_connection(task);
8248 rpc_restart_call(task);
8289 struct rpc_task *task;
8299 task = rpc_run_task(&task_setup_data);
8300 if (!IS_ERR(task)) {
8301 status = task->tk_status;
8302 rpc_put_task(task);
8304 status = PTR_ERR(task);
8607 struct rpc_task *task;
8613 task = nfs4_run_exchange_id(clp, cred, sp4_how, NULL);
8614 if (IS_ERR(task))
8615 return PTR_ERR(task);
8617 argp = task->tk_msg.rpc_argp;
8618 resp = task->tk_msg.rpc_resp;
8619 status = task->tk_status;
8659 rpc_put_task(task);
8711 struct rpc_task *task;
8722 task = nfs4_run_exchange_id(adata->clp, adata->cred, sp4_how, xprt);
8723 if (IS_ERR(task))
8726 status = task->tk_status;
8729 task->tk_msg.rpc_resp, xprt);
8734 rpc_put_task(task);
8808 static void nfs4_get_lease_time_prepare(struct rpc_task *task,
8820 task);
8828 static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata)
8834 if (!nfs4_sequence_done(task, &data->res->lr_seq_res))
8836 switch (task->tk_status) {
8839 dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status);
8840 rpc_delay(task, NFS4_POLL_RETRY_MIN);
8841 task->tk_status = 0;
8844 rpc_restart_call_prepare(task);
9135 static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp)
9137 switch(task->tk_status) {
9139 rpc_delay(task, NFS4_POLL_RETRY_MAX);
9147 static void nfs41_sequence_call_done(struct rpc_task *task, void *data)
9152 if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp))
9155 trace_nfs4_sequence(clp, task->tk_status);
9156 if (task->tk_status < 0) {
9157 dprintk("%s ERROR %d\n", __func__, task->tk_status);
9161 if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) {
9162 rpc_restart_call_prepare(task);
9166 dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred);
9171 static void nfs41_sequence_prepare(struct rpc_task *task, void *data)
9178 args = task->tk_msg.rpc_argp;
9179 res = task->tk_msg.rpc_resp;
9181 nfs4_setup_sequence(clp, args, res, task);
9236 struct rpc_task *task;
9241 task = _nfs41_proc_sequence(clp, cred, NULL, false);
9242 if (IS_ERR(task))
9243 ret = PTR_ERR(task);
9245 rpc_put_task_async(task);
9252 struct rpc_task *task;
9255 task = _nfs41_proc_sequence(clp, cred, NULL, true);
9256 if (IS_ERR(task)) {
9257 ret = PTR_ERR(task);
9260 ret = rpc_wait_for_completion_task(task);
9262 ret = task->tk_status;
9263 rpc_put_task(task);
9275 static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data)
9282 task);
9285 static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp)
9287 switch(task->tk_status) {
9295 rpc_delay(task, NFS4_POLL_RETRY_MAX);
9300 __func__, task->tk_status, clp->cl_hostname);
9312 static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data)
9319 if (!nfs41_sequence_done(task, res))
9322 trace_nfs4_reclaim_complete(clp, task->tk_status);
9323 if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) {
9324 rpc_restart_call_prepare(task);
9380 nfs4_layoutget_prepare(struct rpc_task *task, void *calldata)
9387 &lgp->res.seq_res, task);
9391 static void nfs4_layoutget_done(struct rpc_task *task, void *calldata)
9396 nfs41_sequence_process(task, &lgp->res.seq_res);
9401 nfs4_layoutget_handle_exception(struct rpc_task *task,
9407 int nfs4err = task->tk_status;
9411 dprintk("--> %s tk_status => %d\n", __func__, -task->tk_status);
9519 struct rpc_task *task;
9547 task = rpc_run_task(&task_setup_data);
9549 status = rpc_wait_for_completion_task(task);
9553 if (task->tk_status < 0) {
9554 status = nfs4_layoutget_handle_exception(task, lgp, &exception);
9568 rpc_put_task(task);
9576 nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)
9584 task);
9586 rpc_exit(task, 0);
9589 static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)
9596 if (!nfs41_sequence_process(task, &lrp->res.seq_res))
9603 if (task->tk_rpc_status != 0 && RPC_WAS_SENT(task)) {
9609 switch (task->tk_status) {
9617 task->tk_status = 0;
9622 if (nfs4_async_handle_error(task, server, NULL, NULL) != -EAGAIN)
9629 task->tk_status = 0;
9631 rpc_restart_call_prepare(task);
9660 struct rpc_task *task;
9694 task = rpc_run_task(&task_setup_data);
9695 if (IS_ERR(task))
9696 return PTR_ERR(task);
9698 status = task->tk_status;
9701 rpc_put_task(task);
9754 static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata)
9762 task);
9766 nfs4_layoutcommit_done(struct rpc_task *task, void *calldata)
9771 if (!nfs41_sequence_done(task, &data->res.seq_res))
9774 switch (task->tk_status) { /* Just ignore these failures */
9779 task->tk_status = 0;
9783 if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) {
9784 rpc_restart_call_prepare(task);
9818 .task = &data->task,
9824 struct rpc_task *task;
9841 task = rpc_run_task(&task_setup_data);
9842 if (IS_ERR(task))
9843 return PTR_ERR(task);
9845 status = task->tk_status;
9848 rpc_put_task(task);
10094 static void nfs41_free_stateid_prepare(struct rpc_task *task, void *calldata)
10100 task);
10103 static void nfs41_free_stateid_done(struct rpc_task *task, void *calldata)
10107 nfs41_sequence_done(task, &data->res.seq_res);
10109 switch (task->tk_status) {
10111 if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN)
10112 rpc_restart_call_prepare(task);
10153 struct rpc_task *task;
10170 task = rpc_run_task(&task_setup);
10171 if (IS_ERR(task))
10172 return PTR_ERR(task);
10173 rpc_put_task(task);