Lines Matching full:task
73 static void xprt_request_init(struct rpc_task *task);
229 * @task: task that is requesting access to the transport
236 int xprt_reserve_xprt(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_reserve_xprt() argument
238 struct rpc_rqst *req = task->tk_rqstp; in xprt_reserve_xprt()
241 if (task == xprt->snd_task) in xprt_reserve_xprt()
247 xprt->snd_task = task; in xprt_reserve_xprt()
250 trace_xprt_reserve_xprt(xprt, task); in xprt_reserve_xprt()
256 task->tk_status = -EAGAIN; in xprt_reserve_xprt()
257 if (RPC_IS_SOFT(task)) in xprt_reserve_xprt()
258 rpc_sleep_on_timeout(&xprt->sending, task, NULL, in xprt_reserve_xprt()
261 rpc_sleep_on(&xprt->sending, task, NULL); in xprt_reserve_xprt()
293 * @task: task that is requesting access to the transport
300 int xprt_reserve_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_reserve_xprt_cong() argument
302 struct rpc_rqst *req = task->tk_rqstp; in xprt_reserve_xprt_cong()
305 if (task == xprt->snd_task) in xprt_reserve_xprt_cong()
310 xprt->snd_task = task; in xprt_reserve_xprt_cong()
316 xprt->snd_task = task; in xprt_reserve_xprt_cong()
322 task->tk_status = -EAGAIN; in xprt_reserve_xprt_cong()
323 if (RPC_IS_SOFT(task)) in xprt_reserve_xprt_cong()
324 rpc_sleep_on_timeout(&xprt->sending, task, NULL, in xprt_reserve_xprt_cong()
327 rpc_sleep_on(&xprt->sending, task, NULL); in xprt_reserve_xprt_cong()
330 trace_xprt_reserve_cong(xprt, task); in xprt_reserve_xprt_cong()
335 static inline int xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_lock_write() argument
339 if (test_bit(XPRT_LOCKED, &xprt->state) && xprt->snd_task == task) in xprt_lock_write()
342 retval = xprt->ops->reserve_xprt(xprt, task); in xprt_lock_write()
347 static bool __xprt_lock_write_func(struct rpc_task *task, void *data) in __xprt_lock_write_func() argument
351 xprt->snd_task = task; in __xprt_lock_write_func()
386 * @task: task that is releasing access to the transport
388 * Note that "task" can be NULL. No congestion control is provided.
390 void xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_release_xprt() argument
392 if (xprt->snd_task == task) { in xprt_release_xprt()
396 trace_xprt_release_xprt(xprt, task); in xprt_release_xprt()
403 * @task: task that is releasing access to the transport
405 * Note that "task" can be NULL. Another task is awoken to use the
408 void xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_release_xprt_cong() argument
410 if (xprt->snd_task == task) { in xprt_release_xprt_cong()
414 trace_xprt_release_cong(xprt, task); in xprt_release_xprt_cong()
418 static inline void xprt_release_write(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_release_write() argument
420 if (xprt->snd_task != task) in xprt_release_write()
423 xprt->ops->release_xprt(xprt, task); in xprt_release_write()
429 * overflowed. Put the task to sleep if this is the case.
447 * Adjust the congestion window, and wake up the next task
485 * @task: RPC request that recently completed
489 void xprt_release_rqst_cong(struct rpc_task *task) in xprt_release_rqst_cong() argument
491 struct rpc_rqst *req = task->tk_rqstp; in xprt_release_rqst_cong()
520 * @task: recently completed RPC request used to adjust window
533 void xprt_adjust_cwnd(struct rpc_xprt *xprt, struct rpc_task *task, int result) in xprt_adjust_cwnd() argument
535 struct rpc_rqst *req = task->tk_rqstp; in xprt_adjust_cwnd()
560 * @status: result code to plant in each task before waking it
591 dprintk("RPC: write space: waking waiting task on " in xprt_clear_write_space_locked()
599 * xprt_write_space - wake the task waiting for transport output buffer space
649 static void xprt_init_majortimeo(struct rpc_task *task, struct rpc_rqst *req) in xprt_init_majortimeo() argument
657 time_init = xprt_abs_ktime_to_jiffies(task->tk_start); in xprt_init_majortimeo()
658 req->rq_timeout = task->tk_client->cl_timeout->to_initval; in xprt_init_majortimeo()
763 xprt_request_retransmit_after_disconnect(struct rpc_task *task) in xprt_request_retransmit_after_disconnect() argument
765 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_retransmit_after_disconnect()
830 struct rpc_task *task, in xprt_lock_connect() argument
838 if (xprt->snd_task != task) in xprt_lock_connect()
868 * @task: RPC task that is requesting the connect
871 void xprt_connect(struct rpc_task *task) in xprt_connect() argument
873 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt; in xprt_connect()
878 task->tk_status = -EAGAIN; in xprt_connect()
881 if (!xprt_lock_write(xprt, task)) in xprt_connect()
885 task->tk_rqstp->rq_connect_cookie = xprt->connect_cookie; in xprt_connect()
886 rpc_sleep_on_timeout(&xprt->pending, task, NULL, in xprt_connect()
887 xprt_request_timeout(task->tk_rqstp)); in xprt_connect()
896 xprt->ops->connect(xprt, task); in xprt_connect()
899 task->tk_status = 0; in xprt_connect()
900 rpc_wake_up_queued_task(&xprt->pending, task); in xprt_connect()
903 xprt_release_write(xprt, task); in xprt_connect()
1075 xprt_request_data_received(struct rpc_task *task) in xprt_request_data_received() argument
1077 return !test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) && in xprt_request_data_received()
1078 READ_ONCE(task->tk_rqstp->rq_reply_bytes_recvd) != 0; in xprt_request_data_received()
1082 xprt_request_need_enqueue_receive(struct rpc_task *task, struct rpc_rqst *req) in xprt_request_need_enqueue_receive() argument
1084 return !test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) && in xprt_request_need_enqueue_receive()
1085 READ_ONCE(task->tk_rqstp->rq_reply_bytes_recvd) == 0; in xprt_request_need_enqueue_receive()
1090 * @task: RPC task
1094 xprt_request_enqueue_receive(struct rpc_task *task) in xprt_request_enqueue_receive() argument
1096 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_enqueue_receive()
1099 if (!xprt_request_need_enqueue_receive(task, req)) in xprt_request_enqueue_receive()
1102 xprt_request_prepare(task->tk_rqstp); in xprt_request_enqueue_receive()
1111 set_bit(RPC_TASK_NEED_RECV, &task->tk_runstate); in xprt_request_enqueue_receive()
1120 * @task: RPC task
1125 xprt_request_dequeue_receive_locked(struct rpc_task *task) in xprt_request_dequeue_receive_locked() argument
1127 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_dequeue_receive_locked()
1129 if (test_and_clear_bit(RPC_TASK_NEED_RECV, &task->tk_runstate)) in xprt_request_dequeue_receive_locked()
1135 * @task: RPC request that recently completed
1139 void xprt_update_rtt(struct rpc_task *task) in xprt_update_rtt() argument
1141 struct rpc_rqst *req = task->tk_rqstp; in xprt_update_rtt()
1142 struct rpc_rtt *rtt = task->tk_client->cl_rtt; in xprt_update_rtt()
1143 unsigned int timer = task->tk_msg.rpc_proc->p_timer; in xprt_update_rtt()
1156 * @task: RPC request that recently completed
1161 void xprt_complete_rqst(struct rpc_task *task, int copied) in xprt_complete_rqst() argument
1163 struct rpc_rqst *req = task->tk_rqstp; in xprt_complete_rqst()
1173 xprt_request_dequeue_receive_locked(task); in xprt_complete_rqst()
1174 rpc_wake_up_queued_task(&xprt->pending, task); in xprt_complete_rqst()
1178 static void xprt_timer(struct rpc_task *task) in xprt_timer() argument
1180 struct rpc_rqst *req = task->tk_rqstp; in xprt_timer()
1183 if (task->tk_status != -ETIMEDOUT) in xprt_timer()
1186 trace_xprt_timer(xprt, req->rq_xid, task->tk_status); in xprt_timer()
1189 xprt->ops->timer(xprt, task); in xprt_timer()
1191 task->tk_status = 0; in xprt_timer()
1196 * @task: pointer to rpc_task
1201 * and put the task to sleep on the pending queue.
1203 void xprt_wait_for_reply_request_def(struct rpc_task *task) in xprt_wait_for_reply_request_def() argument
1205 struct rpc_rqst *req = task->tk_rqstp; in xprt_wait_for_reply_request_def()
1207 rpc_sleep_on_timeout(&req->rq_xprt->pending, task, xprt_timer, in xprt_wait_for_reply_request_def()
1214 * @task: pointer to rpc_task
1217 * and put the task to sleep on the pending queue.
1219 void xprt_wait_for_reply_request_rtt(struct rpc_task *task) in xprt_wait_for_reply_request_rtt() argument
1221 int timer = task->tk_msg.rpc_proc->p_timer; in xprt_wait_for_reply_request_rtt()
1222 struct rpc_clnt *clnt = task->tk_client; in xprt_wait_for_reply_request_rtt()
1224 struct rpc_rqst *req = task->tk_rqstp; in xprt_wait_for_reply_request_rtt()
1232 rpc_sleep_on_timeout(&req->rq_xprt->pending, task, xprt_timer, in xprt_wait_for_reply_request_rtt()
1239 * @task: RPC task about to send a request
1242 void xprt_request_wait_receive(struct rpc_task *task) in xprt_request_wait_receive() argument
1244 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_wait_receive()
1247 if (!test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate)) in xprt_request_wait_receive()
1255 if (test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate)) { in xprt_request_wait_receive()
1256 xprt->ops->wait_for_reply_request(task); in xprt_request_wait_receive()
1262 if (xprt_request_retransmit_after_disconnect(task)) in xprt_request_wait_receive()
1264 task, -ENOTCONN); in xprt_request_wait_receive()
1270 xprt_request_need_enqueue_transmit(struct rpc_task *task, struct rpc_rqst *req) in xprt_request_need_enqueue_transmit() argument
1272 return !test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate); in xprt_request_need_enqueue_transmit()
1276 * xprt_request_enqueue_transmit - queue a task for transmission
1277 * @task: pointer to rpc_task
1279 * Add a task to the transmission queue.
1282 xprt_request_enqueue_transmit(struct rpc_task *task) in xprt_request_enqueue_transmit() argument
1284 struct rpc_rqst *pos, *req = task->tk_rqstp; in xprt_request_enqueue_transmit()
1287 if (xprt_request_need_enqueue_transmit(task, req)) { in xprt_request_enqueue_transmit()
1304 } else if (RPC_IS_SWAPPER(task)) { in xprt_request_enqueue_transmit()
1317 if (pos->rq_task->tk_owner != task->tk_owner) in xprt_request_enqueue_transmit()
1327 set_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate); in xprt_request_enqueue_transmit()
1333 * xprt_request_dequeue_transmit_locked - remove a task from the transmission queue
1334 * @task: pointer to rpc_task
1336 * Remove a task from the transmission queue
1340 xprt_request_dequeue_transmit_locked(struct rpc_task *task) in xprt_request_dequeue_transmit_locked() argument
1342 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_dequeue_transmit_locked()
1344 if (!test_and_clear_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) in xprt_request_dequeue_transmit_locked()
1359 * xprt_request_dequeue_transmit - remove a task from the transmission queue
1360 * @task: pointer to rpc_task
1362 * Remove a task from the transmission queue
1365 xprt_request_dequeue_transmit(struct rpc_task *task) in xprt_request_dequeue_transmit() argument
1367 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_dequeue_transmit()
1371 xprt_request_dequeue_transmit_locked(task); in xprt_request_dequeue_transmit()
1376 * xprt_request_dequeue_xprt - remove a task from the transmit+receive queue
1377 * @task: pointer to rpc_task
1379 * Remove a task from the transmit and receive queues, and ensure that
1383 xprt_request_dequeue_xprt(struct rpc_task *task) in xprt_request_dequeue_xprt() argument
1385 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_dequeue_xprt()
1388 if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate) || in xprt_request_dequeue_xprt()
1389 test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) || in xprt_request_dequeue_xprt()
1392 xprt_request_dequeue_transmit_locked(task); in xprt_request_dequeue_xprt()
1393 xprt_request_dequeue_receive_locked(task); in xprt_request_dequeue_xprt()
1395 set_bit(RPC_TASK_MSG_PIN_WAIT, &task->tk_runstate); in xprt_request_dequeue_xprt()
1399 clear_bit(RPC_TASK_MSG_PIN_WAIT, &task->tk_runstate); in xprt_request_dequeue_xprt()
1422 * xprt_request_need_retransmit - Test if a task needs retransmission
1423 * @task: pointer to rpc_task
1425 * Test for whether a connection breakage requires the task to retransmit
1428 xprt_request_need_retransmit(struct rpc_task *task) in xprt_request_need_retransmit() argument
1430 return xprt_request_retransmit_after_disconnect(task); in xprt_request_need_retransmit()
1435 * @task: RPC task about to send a request
1438 bool xprt_prepare_transmit(struct rpc_task *task) in xprt_prepare_transmit() argument
1440 struct rpc_rqst *req = task->tk_rqstp; in xprt_prepare_transmit()
1443 if (!xprt_lock_write(xprt, task)) { in xprt_prepare_transmit()
1445 if (!test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) in xprt_prepare_transmit()
1447 task, 0); in xprt_prepare_transmit()
1454 void xprt_end_transmit(struct rpc_task *task) in xprt_end_transmit() argument
1456 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt; in xprt_end_transmit()
1459 xprt_release_write(xprt, task); in xprt_end_transmit()
1465 * @snd_task: RPC task that owns the transport lock
1476 struct rpc_task *task = req->rq_task; in xprt_request_transmit() local
1478 int is_retrans = RPC_WAS_SENT(task); in xprt_request_transmit()
1482 if (xprt_request_data_received(task)) { in xprt_request_transmit()
1487 if (rpcauth_xmit_need_reencode(task)) { in xprt_request_transmit()
1491 if (RPC_SIGNALLED(task)) { in xprt_request_transmit()
1504 trace_rpc_xdr_sendto(task, &req->rq_snd_buf); in xprt_request_transmit()
1514 task->tk_client->cl_stats->rpcretrans++; in xprt_request_transmit()
1518 task->tk_flags |= RPC_TASK_SENT; in xprt_request_transmit()
1531 xprt_request_dequeue_transmit(task); in xprt_request_transmit()
1532 rpc_wake_up_queued_task_set_status(&xprt->sending, task, status); in xprt_request_transmit()
1538 * @task: controlling RPC task
1542 * resume, or @task finished transmitting, and detected that it already
1546 xprt_transmit(struct rpc_task *task) in xprt_transmit() argument
1548 struct rpc_rqst *next, *req = task->tk_rqstp; in xprt_transmit()
1560 status = xprt_request_transmit(next, task); in xprt_transmit()
1566 if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) in xprt_transmit()
1567 task->tk_status = status; in xprt_transmit()
1570 /* Was @task transmitted, and has it received a reply? */ in xprt_transmit()
1571 if (xprt_request_data_received(task) && in xprt_transmit()
1572 !test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) in xprt_transmit()
1579 static void xprt_complete_request_init(struct rpc_task *task) in xprt_complete_request_init() argument
1581 if (task->tk_rqstp) in xprt_complete_request_init()
1582 xprt_request_init(task); in xprt_complete_request_init()
1585 void xprt_add_backlog(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_add_backlog() argument
1588 rpc_sleep_on(&xprt->backlog, task, xprt_complete_request_init); in xprt_add_backlog()
1592 static bool __xprt_set_rq(struct rpc_task *task, void *data) in __xprt_set_rq() argument
1596 if (task->tk_rqstp == NULL) { in __xprt_set_rq()
1598 task->tk_rqstp = req; in __xprt_set_rq()
1614 static bool xprt_throttle_congested(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_throttle_congested() argument
1622 xprt_add_backlog(xprt, task); in xprt_throttle_congested()
1658 void xprt_alloc_slot(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_alloc_slot() argument
1675 task->tk_status = -ENOMEM; in xprt_alloc_slot()
1678 xprt_add_backlog(xprt, task); in xprt_alloc_slot()
1682 task->tk_status = -EAGAIN; in xprt_alloc_slot()
1691 task->tk_status = 0; in xprt_alloc_slot()
1692 task->tk_rqstp = req; in xprt_alloc_slot()
1786 xprt_request_init(struct rpc_task *task) in xprt_request_init() argument
1788 struct rpc_xprt *xprt = task->tk_xprt; in xprt_request_init()
1789 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_init()
1791 req->rq_task = task; in xprt_request_init()
1803 xprt_init_majortimeo(task, req); in xprt_request_init()
1809 xprt_do_reserve(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_do_reserve() argument
1811 xprt->ops->alloc_slot(xprt, task); in xprt_do_reserve()
1812 if (task->tk_rqstp != NULL) in xprt_do_reserve()
1813 xprt_request_init(task); in xprt_do_reserve()
1818 * @task: RPC task requesting a slot allocation
1821 * slots are available, place the task on the transport's
1824 void xprt_reserve(struct rpc_task *task) in xprt_reserve() argument
1826 struct rpc_xprt *xprt = task->tk_xprt; in xprt_reserve()
1828 task->tk_status = 0; in xprt_reserve()
1829 if (task->tk_rqstp != NULL) in xprt_reserve()
1832 task->tk_status = -EAGAIN; in xprt_reserve()
1833 if (!xprt_throttle_congested(xprt, task)) in xprt_reserve()
1834 xprt_do_reserve(xprt, task); in xprt_reserve()
1839 * @task: RPC task requesting a slot allocation
1841 * If no more slots are available, place the task on the transport's
1846 void xprt_retry_reserve(struct rpc_task *task) in xprt_retry_reserve() argument
1848 struct rpc_xprt *xprt = task->tk_xprt; in xprt_retry_reserve()
1850 task->tk_status = 0; in xprt_retry_reserve()
1851 if (task->tk_rqstp != NULL) in xprt_retry_reserve()
1854 task->tk_status = -EAGAIN; in xprt_retry_reserve()
1855 xprt_do_reserve(xprt, task); in xprt_retry_reserve()
1860 * @task: task which is finished with the slot
1863 void xprt_release(struct rpc_task *task) in xprt_release() argument
1866 struct rpc_rqst *req = task->tk_rqstp; in xprt_release()
1869 if (task->tk_client) { in xprt_release()
1870 xprt = task->tk_xprt; in xprt_release()
1871 xprt_release_write(xprt, task); in xprt_release()
1877 xprt_request_dequeue_xprt(task); in xprt_release()
1879 xprt->ops->release_xprt(xprt, task); in xprt_release()
1881 xprt->ops->release_request(task); in xprt_release()
1885 xprt->ops->buf_free(task); in xprt_release()
1893 task->tk_rqstp = NULL; in xprt_release()
1902 xprt_init_bc_request(struct rpc_rqst *req, struct rpc_task *task) in xprt_init_bc_request() argument
1906 task->tk_rqstp = req; in xprt_init_bc_request()
1907 req->rq_task = task; in xprt_init_bc_request()