Lines Matching defs:task
620 nfs4_async_handle_exception(struct rpc_task *task, struct nfs_server *server,
628 rpc_delay(task, nfs4_update_delay(&exception->timeout));
634 rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL);
636 rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task);
650 rpc_task_release_transport(task);
656 nfs4_async_handle_error(struct rpc_task *task, struct nfs_server *server,
663 if (task->tk_status >= 0)
667 task->tk_status = nfs4_async_handle_exception(task, server,
668 task->tk_status,
734 static int nfs40_sequence_done(struct rpc_task *task,
804 struct rpc_task *task = _nfs41_proc_sequence(client, cred, slot, true);
805 if (!IS_ERR(task))
806 rpc_put_task_async(task);
809 static int nfs41_sequence_process(struct rpc_task *task,
820 /* don't increment the sequence number if the task wasn't sent */
821 if (!RPC_WAS_SENT(task) || slot->seq_done)
830 if (task->tk_status == -NFS4ERR_DEADSESSION)
894 if (task->tk_msg.rpc_proc != &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE]) {
895 nfs4_probe_sequence(clp, task->tk_msg.rpc_cred, slot);
934 if (rpc_restart_call_prepare(task)) {
936 task->tk_status = 0;
941 if (!rpc_restart_call(task))
943 rpc_delay(task, NFS4_POLL_RETRY_MAX);
947 int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
949 if (!nfs41_sequence_process(task, res))
958 static int nfs4_sequence_process(struct rpc_task *task, struct nfs4_sequence_res *res)
963 return nfs41_sequence_process(task, res);
964 return nfs40_sequence_done(task, res);
977 int nfs4_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
982 return nfs40_sequence_done(task, res);
983 return nfs41_sequence_done(task, res);
987 static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata)
994 data->seq_args, data->seq_res, task);
997 static void nfs41_call_sync_done(struct rpc_task *task, void *calldata)
1001 nfs41_sequence_done(task, data->seq_res);
1011 static int nfs4_sequence_process(struct rpc_task *task, struct nfs4_sequence_res *res)
1013 return nfs40_sequence_done(task, res);
1022 int nfs4_sequence_done(struct rpc_task *task,
1025 return nfs40_sequence_done(task, res);
1054 struct rpc_task *task)
1085 rpc_call_start(task);
1090 rpc_sleep_on_priority_timeout(&tbl->slot_tbl_waitq, task,
1093 rpc_sleep_on_timeout(&tbl->slot_tbl_waitq, task,
1099 rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task,
1102 rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
1108 static void nfs40_call_sync_prepare(struct rpc_task *task, void *calldata)
1112 data->seq_args, data->seq_res, task);
1115 static void nfs40_call_sync_done(struct rpc_task *task, void *calldata)
1118 nfs4_sequence_done(task, data->seq_res);
1129 struct rpc_task *task;
1131 task = rpc_run_task(task_setup);
1132 if (IS_ERR(task))
1133 return PTR_ERR(task);
1135 ret = task->tk_status;
1136 rpc_put_task(task);
2338 static void nfs4_open_confirm_prepare(struct rpc_task *task, void *calldata)
2343 &data->c_arg.seq_args, &data->c_res.seq_res, task);
2346 static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
2350 nfs40_sequence_done(task, &data->c_res.seq_res);
2352 data->rpc_status = task->tk_status;
2391 struct rpc_task *task;
2414 task = rpc_run_task(&task_setup_data);
2415 if (IS_ERR(task))
2416 return PTR_ERR(task);
2417 status = rpc_wait_for_completion_task(task);
2423 rpc_put_task(task);
2427 static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
2434 if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
2463 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
2469 task) != 0)
2490 task->tk_action = NULL;
2492 nfs4_sequence_done(task, &data->o_res.seq_res);
2495 static void nfs4_open_done(struct rpc_task *task, void *calldata)
2499 data->rpc_status = task->tk_status;
2501 if (!nfs4_sequence_process(task, &data->o_res.seq_res))
2504 if (task->tk_status == 0) {
2560 struct rpc_task *task;
2593 task = rpc_run_task(&task_setup_data);
2594 if (IS_ERR(task))
2595 return PTR_ERR(task);
2596 status = rpc_wait_for_completion_task(task);
2602 rpc_put_task(task);
3413 nfs4_wait_on_layoutreturn(struct inode *inode, struct rpc_task *task)
3418 return pnfs_wait_on_layoutreturn(inode, task);
3549 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: 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)
3633 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
3636 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
3667 if (!calldata->lr.roc && nfs4_wait_on_layoutreturn(inode, task)) {
3679 task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE];
3704 task) != 0)
3708 task->tk_action = NULL;
3710 nfs4_sequence_done(task, &calldata->res.seq_res);
3736 struct rpc_task *task;
3788 task = rpc_run_task(&task_setup_data);
3789 if (IS_ERR(task))
3790 return PTR_ERR(task);
3793 status = rpc_wait_for_completion_task(task);
3794 rpc_put_task(task);
4811 static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
4816 task);
4819 static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
4821 struct nfs_unlinkdata *data = task->tk_calldata;
4824 if (!nfs4_sequence_done(task, &res->seq_res))
4826 if (nfs4_async_handle_error(task, res->server, NULL,
4829 if (task->tk_status == 0)
4854 static void nfs4_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
4859 task);
4862 static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
4865 struct nfs_renamedata *data = task->tk_calldata;
4868 if (!nfs4_sequence_done(task, &res->seq_res))
4870 if (nfs4_async_handle_error(task, res->server, NULL, &data->timeout) == -EAGAIN)
4873 if (task->tk_status == 0) {
5393 static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_pgio_header *hdr)
5397 trace_nfs4_read(hdr, task->tk_status);
5398 if (task->tk_status < 0) {
5404 task->tk_status = nfs4_async_handle_exception(task,
5405 server, task->tk_status, &exception);
5407 rpc_restart_call_prepare(task);
5412 if (task->tk_status > 0)
5417 static bool nfs4_read_stateid_changed(struct rpc_task *task,
5421 if (!nfs4_error_stateid_expired(task->tk_status) ||
5427 rpc_restart_call_prepare(task);
5431 static bool nfs4_read_plus_not_supported(struct rpc_task *task,
5435 struct rpc_message *msg = &task->tk_msg;
5438 server->caps & NFS_CAP_READ_PLUS && task->tk_status == -ENOTSUPP) {
5441 rpc_restart_call_prepare(task);
5447 static int nfs4_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
5449 if (!nfs4_sequence_done(task, &hdr->res.seq_res))
5451 if (nfs4_read_stateid_changed(task, &hdr->args))
5453 if (nfs4_read_plus_not_supported(task, hdr))
5455 if (task->tk_status > 0)
5457 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) :
5458 nfs4_read_done_cb(task, hdr);
5491 static int nfs4_proc_pgio_rpc_prepare(struct rpc_task *task,
5497 task))
5508 static int nfs4_write_done_cb(struct rpc_task *task,
5513 trace_nfs4_write(hdr, task->tk_status);
5514 if (task->tk_status < 0) {
5520 task->tk_status = nfs4_async_handle_exception(task,
5521 NFS_SERVER(inode), task->tk_status,
5524 rpc_restart_call_prepare(task);
5528 if (task->tk_status >= 0) {
5535 static bool nfs4_write_stateid_changed(struct rpc_task *task,
5539 if (!nfs4_error_stateid_expired(task->tk_status) ||
5545 rpc_restart_call_prepare(task);
5549 static int nfs4_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
5551 if (!nfs4_sequence_done(task, &hdr->res.seq_res))
5553 if (nfs4_write_stateid_changed(task, &hdr->args))
5555 return hdr->pgio_done_cb ? hdr->pgio_done_cb(task, hdr) :
5556 nfs4_write_done_cb(task, hdr);
5630 static void nfs4_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
5635 task);
5638 static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_commit_data *data)
5642 trace_nfs4_commit(data, task->tk_status);
5643 if (nfs4_async_handle_error(task, NFS_SERVER(inode),
5645 rpc_restart_call_prepare(task);
5651 static int nfs4_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
5653 if (!nfs4_sequence_done(task, &data->res.seq_res))
5655 return data->commit_done_cb(task, data);
5726 static void nfs4_renew_done(struct rpc_task *task, void *calldata)
5732 trace_nfs4_renew_async(clp, task->tk_status);
5733 switch (task->tk_status) {
5743 if (task->tk_status != NFS4ERR_CB_PATH_DOWN) {
6406 static void nfs4_setclientid_done(struct rpc_task *task, void *calldata)
6410 if (task->tk_status == 0)
6411 sc->sc_cred = get_rpccred(task->tk_rqstp->rq_cred);
6540 static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
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,
6559 switch (task->tk_status) {
6568 task->tk_msg.rpc_cred);
6573 task->tk_status = 0;
6591 task->tk_status = nfs4_async_handle_exception(task,
6592 data->res.server, task->tk_status,
6598 data->rpc_status = task->tk_status;
6601 task->tk_status = 0;
6602 rpc_restart_call_prepare(task);
6622 static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data)
6629 if (!d_data->lr.roc && nfs4_wait_on_layoutreturn(d_data->inode, task)) {
6630 nfs4_sequence_done(task, &d_data->res.seq_res);
6643 task);
6656 struct rpc_task *task;
6713 task = rpc_run_task(&task_setup_data);
6714 if (IS_ERR(task))
6715 return PTR_ERR(task);
6718 status = rpc_wait_for_completion_task(task);
6723 rpc_put_task(task);
6890 static void nfs4_locku_done(struct rpc_task *task, void *data)
6898 if (!nfs4_sequence_done(task, &calldata->res.seq_res))
6900 switch (task->tk_status) {
6912 task->tk_msg.rpc_cred);
6918 rpc_restart_call_prepare(task);
6923 rpc_restart_call_prepare(task);
6926 task->tk_status = nfs4_async_handle_exception(task,
6927 calldata->server, task->tk_status,
6930 rpc_restart_call_prepare(task);
6935 static void nfs4_locku_prepare(struct rpc_task *task, void *data)
6940 nfs_async_iocounter_wait(task, calldata->l_ctx))
6943 if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
6953 task) != 0)
6957 task->tk_action = NULL;
6959 nfs4_sequence_done(task, &calldata->res.seq_res);
7019 struct rpc_task *task;
7050 task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);
7051 status = PTR_ERR(task);
7052 if (IS_ERR(task))
7054 status = rpc_wait_for_completion_task(task);
7055 rpc_put_task(task);
7113 static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
7118 if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
7122 if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) {
7136 task->tk_action = NULL;
7143 task) == 0)
7150 nfs4_sequence_done(task, &data->res.seq_res);
7154 static void nfs4_lock_done(struct rpc_task *task, void *calldata)
7159 if (!nfs4_sequence_done(task, &data->res.seq_res))
7162 data->rpc_status = task->tk_status;
7163 switch (task->tk_status) {
7203 rpc_restart_call_prepare(task);
7213 struct rpc_task *task;
7214 task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
7216 if (!IS_ERR(task))
7217 rpc_put_task_async(task);
7252 struct rpc_task *task;
7285 task = rpc_run_task(&task_setup_data);
7286 if (IS_ERR(task))
7287 return PTR_ERR(task);
7288 ret = rpc_wait_for_completion_task(task);
7297 rpc_put_task(task);
7635 static void nfs4_release_lockowner_prepare(struct rpc_task *task, void *calldata)
7640 &data->res.seq_res, task);
7645 static void nfs4_release_lockowner_done(struct rpc_task *task, void *calldata)
7650 nfs40_sequence_done(task, &data->res.seq_res);
7652 switch (task->tk_status) {
7662 if (nfs4_async_handle_error(task, server,
7664 rpc_restart_call_prepare(task);
8448 nfs4_bind_one_conn_to_session_done(struct rpc_task *task, void *calldata)
8450 struct nfs41_bind_conn_to_session_args *args = task->tk_msg.rpc_argp;
8451 struct nfs41_bind_conn_to_session_res *res = task->tk_msg.rpc_resp;
8454 switch (task->tk_status) {
8458 task->tk_status);
8463 rpc_task_close_connection(task);
8465 rpc_restart_call(task);
8506 struct rpc_task *task;
8516 task = rpc_run_task(&task_setup_data);
8517 if (!IS_ERR(task)) {
8518 status = task->tk_status;
8519 rpc_put_task(task);
8521 status = PTR_ERR(task);
8826 struct rpc_task *task;
8832 task = nfs4_run_exchange_id(clp, cred, sp4_how, NULL);
8833 if (IS_ERR(task))
8834 return PTR_ERR(task);
8836 argp = task->tk_msg.rpc_argp;
8837 resp = task->tk_msg.rpc_resp;
8838 status = task->tk_status;
8878 rpc_put_task(task);
8930 struct rpc_task *task;
8942 task = nfs4_run_exchange_id(adata->clp, adata->cred, sp4_how, xprt);
8943 if (IS_ERR(task))
8946 status = task->tk_status;
8949 task->tk_msg.rpc_resp, xprt);
8957 rpc_put_task(task);
9035 static void nfs4_get_lease_time_prepare(struct rpc_task *task,
9046 task);
9053 static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata)
9058 if (!nfs4_sequence_done(task, &data->res->lr_seq_res))
9060 switch (task->tk_status) {
9063 rpc_delay(task, NFS4_POLL_RETRY_MIN);
9064 task->tk_status = 0;
9067 rpc_restart_call_prepare(task);
9361 static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp)
9363 switch(task->tk_status) {
9365 rpc_delay(task, NFS4_POLL_RETRY_MAX);
9373 static void nfs41_sequence_call_done(struct rpc_task *task, void *data)
9378 if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp))
9381 trace_nfs4_sequence(clp, task->tk_status);
9382 if (task->tk_status < 0 && !task->tk_client->cl_shutdown) {
9383 dprintk("%s ERROR %d\n", __func__, task->tk_status);
9387 if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) {
9388 rpc_restart_call_prepare(task);
9392 dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred);
9395 static void nfs41_sequence_prepare(struct rpc_task *task, void *data)
9402 args = task->tk_msg.rpc_argp;
9403 res = task->tk_msg.rpc_resp;
9405 nfs4_setup_sequence(clp, args, res, task);
9460 struct rpc_task *task;
9465 task = _nfs41_proc_sequence(clp, cred, NULL, false);
9466 if (IS_ERR(task))
9467 ret = PTR_ERR(task);
9469 rpc_put_task_async(task);
9476 struct rpc_task *task;
9479 task = _nfs41_proc_sequence(clp, cred, NULL, true);
9480 if (IS_ERR(task)) {
9481 ret = PTR_ERR(task);
9484 ret = rpc_wait_for_completion_task(task);
9486 ret = task->tk_status;
9487 rpc_put_task(task);
9499 static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data)
9506 task);
9509 static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp)
9511 switch(task->tk_status) {
9519 rpc_delay(task, NFS4_POLL_RETRY_MAX);
9524 __func__, task->tk_status, clp->cl_hostname);
9536 static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data)
9542 if (!nfs41_sequence_done(task, res))
9545 trace_nfs4_reclaim_complete(clp, task->tk_status);
9546 if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) {
9547 rpc_restart_call_prepare(task);
9601 nfs4_layoutget_prepare(struct rpc_task *task, void *calldata)
9607 &lgp->res.seq_res, task);
9610 static void nfs4_layoutget_done(struct rpc_task *task, void *calldata)
9614 nfs41_sequence_process(task, &lgp->res.seq_res);
9618 nfs4_layoutget_handle_exception(struct rpc_task *task,
9624 int nfs4err = task->tk_status;
9628 dprintk("--> %s tk_status => %d\n", __func__, -task->tk_status);
9732 struct rpc_task *task;
9756 task = rpc_run_task(&task_setup_data);
9757 if (IS_ERR(task))
9758 return ERR_CAST(task);
9760 status = rpc_wait_for_completion_task(task);
9764 if (task->tk_status < 0) {
9765 status = nfs4_layoutget_handle_exception(task, lgp, &exception);
9779 rpc_put_task(task);
9787 nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)
9794 task);
9796 rpc_exit(task, 0);
9799 static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)
9804 if (!nfs41_sequence_process(task, &lrp->res.seq_res))
9811 if (task->tk_rpc_status != 0 && RPC_WAS_SENT(task)) {
9817 switch (task->tk_status) {
9825 task->tk_status = 0;
9830 if (nfs4_async_handle_error(task, server, NULL, NULL) != -EAGAIN)
9836 task->tk_status = 0;
9838 rpc_restart_call_prepare(task);
9865 struct rpc_task *task;
9899 task = rpc_run_task(&task_setup_data);
9900 if (IS_ERR(task))
9901 return PTR_ERR(task);
9903 status = task->tk_status;
9906 rpc_put_task(task);
9960 static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata)
9968 task);
9972 nfs4_layoutcommit_done(struct rpc_task *task, void *calldata)
9977 if (!nfs41_sequence_done(task, &data->res.seq_res))
9980 switch (task->tk_status) { /* Just ignore these failures */
9985 task->tk_status = 0;
9990 if (nfs4_async_handle_error(task, server, NULL, NULL) == -EAGAIN) {
9991 rpc_restart_call_prepare(task);
10025 .task = &data->task,
10032 struct rpc_task *task;
10049 task = rpc_run_task(&task_setup_data);
10050 if (IS_ERR(task))
10051 return PTR_ERR(task);
10053 status = task->tk_status;
10056 rpc_put_task(task);
10301 static void nfs41_free_stateid_prepare(struct rpc_task *task, void *calldata)
10307 task);
10310 static void nfs41_free_stateid_done(struct rpc_task *task, void *calldata)
10314 nfs41_sequence_done(task, &data->res.seq_res);
10316 switch (task->tk_status) {
10318 if (nfs4_async_handle_error(task, data->server, NULL, NULL) == -EAGAIN)
10319 rpc_restart_call_prepare(task);
10364 struct rpc_task *task;
10385 task = rpc_run_task(&task_setup);
10386 if (IS_ERR(task))
10387 return PTR_ERR(task);
10388 rpc_put_task(task);