Lines Matching defs:task
58 static void call_start(struct rpc_task *task);
59 static void call_reserve(struct rpc_task *task);
60 static void call_reserveresult(struct rpc_task *task);
61 static void call_allocate(struct rpc_task *task);
62 static void call_encode(struct rpc_task *task);
63 static void call_decode(struct rpc_task *task);
64 static void call_bind(struct rpc_task *task);
65 static void call_bind_status(struct rpc_task *task);
66 static void call_transmit(struct rpc_task *task);
67 static void call_status(struct rpc_task *task);
68 static void call_transmit_status(struct rpc_task *task);
69 static void call_refresh(struct rpc_task *task);
70 static void call_refreshresult(struct rpc_task *task);
71 static void call_connect(struct rpc_task *task);
72 static void call_connect_status(struct rpc_task *task);
74 static int rpc_encode_header(struct rpc_task *task,
76 static int rpc_decode_header(struct rpc_task *task,
80 static void rpc_check_timeout(struct rpc_task *task);
891 * @error: RPC task error value to set
903 struct rpc_task *task;
912 list_for_each_entry(task, &clnt->cl_tasks, tk_task) {
913 if (!RPC_IS_ACTIVATED(task))
915 if (!fnmatch(task, data))
917 rpc_task_try_cancel(task, error);
1103 void rpc_task_release_transport(struct rpc_task *task)
1105 struct rpc_xprt *xprt = task->tk_xprt;
1108 task->tk_xprt = NULL;
1109 if (task->tk_client)
1110 rpc_task_release_xprt(task->tk_client, xprt);
1117 void rpc_task_release_client(struct rpc_task *task)
1119 struct rpc_clnt *clnt = task->tk_client;
1121 rpc_task_release_transport(task);
1123 /* Remove from client task list */
1125 list_del(&task->tk_task);
1127 task->tk_client = NULL;
1151 void rpc_task_set_transport(struct rpc_task *task, struct rpc_clnt *clnt)
1153 if (task->tk_xprt) {
1154 if (!(test_bit(XPRT_OFFLINE, &task->tk_xprt->state) &&
1155 (task->tk_flags & RPC_TASK_MOVEABLE)))
1157 xprt_release(task);
1158 xprt_put(task->tk_xprt);
1160 if (task->tk_flags & RPC_TASK_NO_ROUND_ROBIN)
1161 task->tk_xprt = rpc_task_get_first_xprt(clnt);
1163 task->tk_xprt = rpc_task_get_next_xprt(clnt);
1167 void rpc_task_set_client(struct rpc_task *task, struct rpc_clnt *clnt)
1169 rpc_task_set_transport(task, clnt);
1170 task->tk_client = clnt;
1173 task->tk_flags |= RPC_TASK_SOFT;
1175 task->tk_flags |= RPC_TASK_TIMEOUT;
1177 task->tk_flags |= RPC_TASK_NO_RETRANS_TIMEOUT;
1180 list_add_tail(&task->tk_task, &clnt->cl_tasks);
1185 rpc_task_set_rpc_message(struct rpc_task *task, const struct rpc_message *msg)
1188 task->tk_msg.rpc_proc = msg->rpc_proc;
1189 task->tk_msg.rpc_argp = msg->rpc_argp;
1190 task->tk_msg.rpc_resp = msg->rpc_resp;
1191 task->tk_msg.rpc_cred = msg->rpc_cred;
1192 if (!(task->tk_flags & RPC_TASK_CRED_NOREF))
1193 get_cred(task->tk_msg.rpc_cred);
1201 rpc_default_callback(struct rpc_task *task, void *data)
1210 * rpc_run_task - Allocate a new RPC task, then run rpc_execute against it
1211 * @task_setup_data: pointer to task initialisation data
1215 struct rpc_task *task;
1217 task = rpc_new_task(task_setup_data);
1218 if (IS_ERR(task))
1219 return task;
1221 if (!RPC_IS_ASYNC(task))
1222 task->tk_flags |= RPC_TASK_CRED_NOREF;
1224 rpc_task_set_client(task, task_setup_data->rpc_client);
1225 rpc_task_set_rpc_message(task, task_setup_data->rpc_message);
1227 if (task->tk_action == NULL)
1228 rpc_call_start(task);
1230 atomic_inc(&task->tk_count);
1231 rpc_execute(task);
1232 return task;
1244 struct rpc_task *task;
1260 task = rpc_run_task(&task_setup_data);
1261 if (IS_ERR(task))
1262 return PTR_ERR(task);
1263 status = task->tk_status;
1264 rpc_put_task(task);
1281 struct rpc_task *task;
1290 task = rpc_run_task(&task_setup_data);
1291 if (IS_ERR(task))
1292 return PTR_ERR(task);
1293 rpc_put_task(task);
1299 static void call_bc_encode(struct rpc_task *task);
1302 * rpc_run_bc_task - Allocate a new RPC task for backchannel use, then run
1308 struct rpc_task *task;
1319 task = rpc_new_task(&task_setup_data);
1320 if (IS_ERR(task)) {
1322 return task;
1325 xprt_init_bc_request(req, task);
1327 task->tk_action = call_bc_encode;
1328 atomic_inc(&task->tk_count);
1329 WARN_ON_ONCE(atomic_read(&task->tk_count) != 2);
1330 rpc_execute(task);
1332 dprintk("RPC: rpc_run_bc_task: task= %p\n", task);
1333 return task;
1358 rpc_call_start(struct rpc_task *task)
1360 task->tk_action = call_start;
1658 __rpc_restart_call(struct rpc_task *task, void (*action)(struct rpc_task *))
1660 task->tk_status = 0;
1661 task->tk_rpc_status = 0;
1662 task->tk_action = action;
1671 rpc_restart_call(struct rpc_task *task)
1673 return __rpc_restart_call(task, call_start);
1682 rpc_restart_call_prepare(struct rpc_task *task)
1684 if (task->tk_ops->rpc_call_prepare != NULL)
1685 return __rpc_restart_call(task, rpc_prepare_task);
1686 return rpc_restart_call(task);
1691 *rpc_proc_name(const struct rpc_task *task)
1693 const struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
1705 __rpc_call_rpcerror(struct rpc_task *task, int tk_status, int rpc_status)
1707 trace_rpc_call_rpcerror(task, tk_status, rpc_status);
1708 rpc_task_set_rpc_status(task, rpc_status);
1709 rpc_exit(task, tk_status);
1713 rpc_call_rpcerror(struct rpc_task *task, int status)
1715 __rpc_call_rpcerror(task, status, status);
1725 call_start(struct rpc_task *task)
1727 struct rpc_clnt *clnt = task->tk_client;
1728 int idx = task->tk_msg.rpc_proc->p_statidx;
1730 trace_rpc_request(task);
1732 if (task->tk_client->cl_shutdown) {
1733 rpc_call_rpcerror(task, -EIO);
1741 task->tk_action = call_reserve;
1742 rpc_task_set_transport(task, clnt);
1749 call_reserve(struct rpc_task *task)
1751 task->tk_status = 0;
1752 task->tk_action = call_reserveresult;
1753 xprt_reserve(task);
1756 static void call_retry_reserve(struct rpc_task *task);
1762 call_reserveresult(struct rpc_task *task)
1764 int status = task->tk_status;
1770 task->tk_status = 0;
1772 if (task->tk_rqstp) {
1773 task->tk_action = call_refresh;
1777 rpc_call_rpcerror(task, -EIO);
1783 rpc_delay(task, HZ >> 2);
1786 task->tk_action = call_retry_reserve;
1789 rpc_call_rpcerror(task, status);
1797 call_retry_reserve(struct rpc_task *task)
1799 task->tk_status = 0;
1800 task->tk_action = call_reserveresult;
1801 xprt_retry_reserve(task);
1808 call_refresh(struct rpc_task *task)
1810 task->tk_action = call_refreshresult;
1811 task->tk_status = 0;
1812 task->tk_client->cl_stats->rpcauthrefresh++;
1813 rpcauth_refreshcred(task);
1820 call_refreshresult(struct rpc_task *task)
1822 int status = task->tk_status;
1824 task->tk_status = 0;
1825 task->tk_action = call_refresh;
1828 if (rpcauth_uptodatecred(task)) {
1829 task->tk_action = call_allocate;
1837 rpc_delay(task, 3*HZ);
1843 if (!task->tk_cred_retry)
1845 task->tk_cred_retry--;
1846 trace_rpc_retry_refresh_status(task);
1849 rpc_delay(task, HZ >> 4);
1852 trace_rpc_refresh_status(task);
1853 rpc_call_rpcerror(task, status);
1861 call_allocate(struct rpc_task *task)
1863 const struct rpc_auth *auth = task->tk_rqstp->rq_cred->cr_auth;
1864 struct rpc_rqst *req = task->tk_rqstp;
1866 const struct rpc_procinfo *proc = task->tk_msg.rpc_proc;
1869 task->tk_status = 0;
1870 task->tk_action = call_encode;
1897 status = xprt->ops->buf_alloc(task);
1898 trace_rpc_buf_alloc(task, status);
1902 rpc_call_rpcerror(task, status);
1906 if (RPC_IS_ASYNC(task) || !fatal_signal_pending(current)) {
1907 task->tk_action = call_allocate;
1908 rpc_delay(task, HZ>>4);
1912 rpc_call_rpcerror(task, -ERESTARTSYS);
1916 rpc_task_need_encode(struct rpc_task *task)
1918 return test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate) == 0 &&
1919 (!(task->tk_flags & RPC_TASK_SENT) ||
1920 !(task->tk_flags & RPC_TASK_NO_RETRANS_TIMEOUT) ||
1921 xprt_request_need_retransmit(task));
1925 rpc_xdr_encode(struct rpc_task *task)
1927 struct rpc_rqst *req = task->tk_rqstp;
1941 if (rpc_encode_header(task, &xdr))
1944 task->tk_status = rpcauth_wrap_req(task, &xdr);
1951 call_encode(struct rpc_task *task)
1953 if (!rpc_task_need_encode(task))
1956 /* Dequeue task from the receive queue while we're encoding */
1957 xprt_request_dequeue_xprt(task);
1959 rpc_xdr_encode(task);
1960 /* Add task to reply queue before transmission to avoid races */
1961 if (task->tk_status == 0 && rpc_reply_expected(task))
1962 task->tk_status = xprt_request_enqueue_receive(task);
1964 if (task->tk_status != 0) {
1966 switch (task->tk_status) {
1969 rpc_delay(task, HZ >> 4);
1972 if (!task->tk_cred_retry) {
1973 rpc_call_rpcerror(task, task->tk_status);
1975 task->tk_action = call_refresh;
1976 task->tk_cred_retry--;
1977 trace_rpc_retry_refresh_status(task);
1981 rpc_call_rpcerror(task, task->tk_status);
1986 xprt_request_enqueue_transmit(task);
1988 task->tk_action = call_transmit;
1990 if (!xprt_bound(task->tk_xprt))
1991 task->tk_action = call_bind;
1992 else if (!xprt_connected(task->tk_xprt))
1993 task->tk_action = call_connect;
1997 * Helpers to check if the task was already transmitted, and
2001 rpc_task_transmitted(struct rpc_task *task)
2003 return !test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate);
2007 rpc_task_handle_transmitted(struct rpc_task *task)
2009 xprt_end_transmit(task);
2010 task->tk_action = call_transmit_status;
2017 call_bind(struct rpc_task *task)
2019 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
2021 if (rpc_task_transmitted(task)) {
2022 rpc_task_handle_transmitted(task);
2027 task->tk_action = call_connect;
2031 task->tk_action = call_bind_status;
2032 if (!xprt_prepare_transmit(task))
2035 xprt->ops->rpcbind(task);
2042 call_bind_status(struct rpc_task *task)
2044 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
2047 if (rpc_task_transmitted(task)) {
2048 rpc_task_handle_transmitted(task);
2052 if (task->tk_status >= 0)
2055 task->tk_status = 0;
2059 switch (task->tk_status) {
2061 rpc_delay(task, HZ >> 2);
2064 trace_rpcb_prog_unavail_err(task);
2066 if (task->tk_msg.rpc_proc->p_proc == 0) {
2070 rpc_delay(task, 3*HZ);
2073 rpc_delay(task, HZ >> 2);
2078 trace_rpcb_timeout_err(task);
2082 trace_rpcb_bind_version_err(task);
2085 trace_rpcb_bind_version_err(task);
2096 trace_rpcb_unreachable_err(task);
2097 if (!RPC_IS_SOFTCONN(task)) {
2098 rpc_delay(task, 5*HZ);
2101 status = task->tk_status;
2104 trace_rpcb_unrecognized_err(task);
2107 rpc_call_rpcerror(task, status);
2110 task->tk_action = call_connect;
2113 task->tk_status = 0;
2114 task->tk_action = call_bind;
2115 rpc_check_timeout(task);
2122 call_connect(struct rpc_task *task)
2124 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
2126 if (rpc_task_transmitted(task)) {
2127 rpc_task_handle_transmitted(task);
2132 task->tk_action = call_transmit;
2136 task->tk_action = call_connect_status;
2137 if (task->tk_status < 0)
2139 if (task->tk_flags & RPC_TASK_NOCONNECT) {
2140 rpc_call_rpcerror(task, -ENOTCONN);
2143 if (!xprt_prepare_transmit(task))
2145 xprt_connect(task);
2152 call_connect_status(struct rpc_task *task)
2154 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
2155 struct rpc_clnt *clnt = task->tk_client;
2156 int status = task->tk_status;
2158 if (rpc_task_transmitted(task)) {
2159 rpc_task_handle_transmitted(task);
2163 trace_rpc_connect_status(task);
2165 if (task->tk_status == 0) {
2170 task->tk_status = 0;
2174 task->tk_status = 0;
2179 if (RPC_IS_SOFTCONN(task))
2192 xprt_conditional_disconnect(task->tk_rqstp->rq_xprt,
2193 task->tk_rqstp->rq_connect_cookie);
2194 if (RPC_IS_SOFTCONN(task))
2197 rpc_delay(task, 3*HZ);
2203 if (!(task->tk_flags & RPC_TASK_NO_ROUND_ROBIN) &&
2204 (task->tk_flags & RPC_TASK_MOVEABLE) &&
2206 struct rpc_xprt *saved = task->tk_xprt;
2215 xprt_release(task);
2221 task->tk_xprt = NULL;
2222 task->tk_action = call_start;
2225 if (!task->tk_xprt)
2230 rpc_delay(task, HZ >> 2);
2233 rpc_call_rpcerror(task, status);
2236 task->tk_action = call_transmit;
2240 task->tk_action = call_bind;
2241 rpc_check_timeout(task);
2248 call_transmit(struct rpc_task *task)
2250 if (rpc_task_transmitted(task)) {
2251 rpc_task_handle_transmitted(task);
2255 task->tk_action = call_transmit_status;
2256 if (!xprt_prepare_transmit(task))
2258 task->tk_status = 0;
2259 if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) {
2260 if (!xprt_connected(task->tk_xprt)) {
2261 task->tk_status = -ENOTCONN;
2264 xprt_transmit(task);
2266 xprt_end_transmit(task);
2273 call_transmit_status(struct rpc_task *task)
2275 task->tk_action = call_status;
2281 if (rpc_task_transmitted(task)) {
2282 task->tk_status = 0;
2283 xprt_request_wait_receive(task);
2287 switch (task->tk_status) {
2291 task->tk_status = 0;
2292 task->tk_action = call_encode;
2302 rpc_delay(task, HZ>>2);
2306 task->tk_action = call_transmit;
2307 task->tk_status = 0;
2315 if (RPC_IS_SOFTCONN(task)) {
2316 if (!task->tk_msg.rpc_proc->p_proc)
2317 trace_xprt_ping(task->tk_xprt,
2318 task->tk_status);
2319 rpc_call_rpcerror(task, task->tk_status);
2328 task->tk_action = call_bind;
2329 task->tk_status = 0;
2332 rpc_check_timeout(task);
2336 static void call_bc_transmit(struct rpc_task *task);
2337 static void call_bc_transmit_status(struct rpc_task *task);
2340 call_bc_encode(struct rpc_task *task)
2342 xprt_request_enqueue_transmit(task);
2343 task->tk_action = call_bc_transmit;
2351 call_bc_transmit(struct rpc_task *task)
2353 task->tk_action = call_bc_transmit_status;
2354 if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) {
2355 if (!xprt_prepare_transmit(task))
2357 task->tk_status = 0;
2358 xprt_transmit(task);
2360 xprt_end_transmit(task);
2364 call_bc_transmit_status(struct rpc_task *task)
2366 struct rpc_rqst *req = task->tk_rqstp;
2368 if (rpc_task_transmitted(task))
2369 task->tk_status = 0;
2371 switch (task->tk_status) {
2386 rpc_delay(task, HZ>>2);
2390 task->tk_status = 0;
2391 task->tk_action = call_bc_transmit;
2402 "error: %d\n", task->tk_status);
2412 "error: %d\n", task->tk_status);
2415 task->tk_action = rpc_exit_task;
2423 call_status(struct rpc_task *task)
2425 struct rpc_clnt *clnt = task->tk_client;
2428 if (!task->tk_msg.rpc_proc->p_proc)
2429 trace_xprt_ping(task->tk_xprt, task->tk_status);
2431 status = task->tk_status;
2433 task->tk_action = call_decode;
2437 trace_rpc_call_status(task);
2438 task->tk_status = 0;
2445 if (RPC_IS_SOFTCONN(task))
2451 rpc_delay(task, 3*HZ);
2462 rpc_delay(task, 3*HZ);
2470 rpc_delay(task, HZ>>2);
2481 task->tk_action = call_encode;
2482 rpc_check_timeout(task);
2485 rpc_call_rpcerror(task, status);
2498 rpc_check_timeout(struct rpc_task *task)
2500 struct rpc_clnt *clnt = task->tk_client;
2502 if (RPC_SIGNALLED(task))
2505 if (xprt_adjust_timeout(task->tk_rqstp) == 0)
2508 trace_rpc_timeout_status(task);
2509 task->tk_timeouts++;
2511 if (RPC_IS_SOFTCONN(task) && !rpc_check_connected(task->tk_rqstp)) {
2512 rpc_call_rpcerror(task, -ETIMEDOUT);
2516 if (RPC_IS_SOFT(task)) {
2522 if ((task->tk_flags & RPC_TASK_NO_RETRANS_TIMEOUT) &&
2523 rpc_check_connected(task->tk_rqstp))
2530 task->tk_xprt->servername);
2532 if (task->tk_flags & RPC_TASK_TIMEOUT)
2533 rpc_call_rpcerror(task, -ETIMEDOUT);
2535 __rpc_call_rpcerror(task, -EIO, -ETIMEDOUT);
2539 if (!(task->tk_flags & RPC_CALL_MAJORSEEN)) {
2540 task->tk_flags |= RPC_CALL_MAJORSEEN;
2545 task->tk_xprt->servername);
2553 rpcauth_invalcred(task);
2560 call_decode(struct rpc_task *task)
2562 struct rpc_clnt *clnt = task->tk_client;
2563 struct rpc_rqst *req = task->tk_rqstp;
2567 if (!task->tk_msg.rpc_proc->p_decode) {
2568 task->tk_action = rpc_exit_task;
2572 if (task->tk_flags & RPC_CALL_MAJORSEEN) {
2576 task->tk_xprt->servername);
2578 task->tk_flags &= ~RPC_CALL_MAJORSEEN;
2595 trace_rpc_xdr_recvfrom(task, &req->rq_rcv_buf);
2603 err = rpc_decode_header(task, &xdr);
2607 task->tk_action = rpc_exit_task;
2608 task->tk_status = rpcauth_unwrap_resp(task, &xdr);
2612 task->tk_status = 0;
2613 if (task->tk_client->cl_discrtry)
2616 task->tk_action = call_encode;
2617 rpc_check_timeout(task);
2620 task->tk_action = call_reserve;
2621 rpc_check_timeout(task);
2622 rpcauth_invalcred(task);
2624 xprt_release(task);
2629 rpc_encode_header(struct rpc_task *task, struct xdr_stream *xdr)
2631 struct rpc_clnt *clnt = task->tk_client;
2632 struct rpc_rqst *req = task->tk_rqstp;
2645 *p = cpu_to_be32(task->tk_msg.rpc_proc->p_proc);
2647 error = rpcauth_marshcred(task, xdr);
2652 trace_rpc_bad_callhdr(task);
2653 rpc_call_rpcerror(task, error);
2658 rpc_decode_header(struct rpc_task *task, struct xdr_stream *xdr)
2660 struct rpc_clnt *clnt = task->tk_client;
2669 if (task->tk_rqstp->rq_rcv_buf.len & 3)
2681 error = rpcauth_checkverf(task, xdr);
2692 trace_rpc__prog_unavail(task);
2696 trace_rpc__prog_mismatch(task);
2700 trace_rpc__proc_unavail(task);
2705 trace_rpc__garbage_args(task);
2714 if (task->tk_garb_retry) {
2715 task->tk_garb_retry--;
2716 task->tk_action = call_encode;
2720 rpc_call_rpcerror(task, error);
2724 trace_rpc__unparsable(task);
2729 trace_rpc_bad_verifier(task);
2749 trace_rpc__mismatch(task);
2764 rpcauth_invalcred(task);
2765 if (!task->tk_cred_retry)
2767 task->tk_cred_retry--;
2768 trace_rpc__stale_creds(task);
2773 if (!task->tk_garb_retry)
2775 task->tk_garb_retry--;
2776 trace_rpc__bad_creds(task);
2777 task->tk_action = call_encode;
2780 trace_rpc__auth_tooweak(task);
2782 task->tk_xprt->servername);
2811 rpc_null_call_prepare(struct rpc_task *task, void *data)
2813 task->tk_flags &= ~RPC_TASK_NO_RETRANS_TIMEOUT;
2814 rpc_call_start(task);
2852 struct rpc_task *task;
2858 task = rpc_call_null_helper(clnt, NULL, NULL, 0, NULL, NULL);
2859 if (IS_ERR(task))
2860 return PTR_ERR(task);
2861 status = task->tk_status;
2862 rpc_put_task(task);
2877 struct rpc_task *task;
2880 task = rpc_run_task(&task_setup_data);
2881 if (IS_ERR(task))
2882 return PTR_ERR(task);
2883 status = task->tk_status;
2884 rpc_put_task(task);
2893 static void rpc_cb_add_xprt_done(struct rpc_task *task, void *calldata)
2897 if (task->tk_status == 0)
2928 struct rpc_task *task;
2952 task = rpc_call_null_helper(clnt, xprt, NULL, RPC_TASK_ASYNC,
2954 if (IS_ERR(task))
2955 return PTR_ERR(task);
2958 rpc_put_task(task);
2968 struct rpc_task *task;
2972 task = rpc_call_null_helper(clnt, xprt, NULL, 0, NULL, NULL);
2973 if (IS_ERR(task))
2974 return PTR_ERR(task);
2976 status = task->tk_status;
2977 rpc_put_task(task);
3318 const struct rpc_task *task)
3322 if (RPC_IS_QUEUED(task))
3323 rpc_waitq = rpc_qname(task->tk_waitqueue);
3326 task->tk_pid, task->tk_flags, task->tk_status,
3327 clnt, task->tk_rqstp, rpc_task_timeout(task), task->tk_ops,
3328 clnt->cl_program->name, clnt->cl_vers, rpc_proc_name(task),
3329 task->tk_action, rpc_waitq);
3335 struct rpc_task *task;
3342 list_for_each_entry(task, &clnt->cl_tasks, tk_task) {
3347 rpc_show_task(clnt, task);