Lines Matching full:task
195 * @task: task that is requesting access to the transport
202 int xprt_reserve_xprt(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_reserve_xprt() argument
204 struct rpc_rqst *req = task->tk_rqstp; in xprt_reserve_xprt()
207 if (task == xprt->snd_task) in xprt_reserve_xprt()
213 xprt->snd_task = task; in xprt_reserve_xprt()
216 trace_xprt_reserve_xprt(xprt, task); in xprt_reserve_xprt()
222 task->tk_status = -EAGAIN; in xprt_reserve_xprt()
223 if (RPC_IS_SOFT(task)) in xprt_reserve_xprt()
224 rpc_sleep_on_timeout(&xprt->sending, task, NULL, in xprt_reserve_xprt()
227 rpc_sleep_on(&xprt->sending, task, NULL); in xprt_reserve_xprt()
259 * @task: task that is requesting access to the transport
266 int xprt_reserve_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_reserve_xprt_cong() argument
268 struct rpc_rqst *req = task->tk_rqstp; in xprt_reserve_xprt_cong()
271 if (task == xprt->snd_task) in xprt_reserve_xprt_cong()
276 xprt->snd_task = task; in xprt_reserve_xprt_cong()
282 xprt->snd_task = task; in xprt_reserve_xprt_cong()
288 task->tk_status = -EAGAIN; in xprt_reserve_xprt_cong()
289 if (RPC_IS_SOFT(task)) in xprt_reserve_xprt_cong()
290 rpc_sleep_on_timeout(&xprt->sending, task, NULL, in xprt_reserve_xprt_cong()
293 rpc_sleep_on(&xprt->sending, task, NULL); in xprt_reserve_xprt_cong()
296 trace_xprt_reserve_cong(xprt, task); in xprt_reserve_xprt_cong()
301 static inline int xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_lock_write() argument
305 if (test_bit(XPRT_LOCKED, &xprt->state) && xprt->snd_task == task) in xprt_lock_write()
308 retval = xprt->ops->reserve_xprt(xprt, task); in xprt_lock_write()
313 static bool __xprt_lock_write_func(struct rpc_task *task, void *data) in __xprt_lock_write_func() argument
317 xprt->snd_task = task; in __xprt_lock_write_func()
352 * @task: task that is releasing access to the transport
354 * Note that "task" can be NULL. No congestion control is provided.
356 void xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_release_xprt() argument
358 if (xprt->snd_task == task) { in xprt_release_xprt()
362 trace_xprt_release_xprt(xprt, task); in xprt_release_xprt()
369 * @task: task that is releasing access to the transport
371 * Note that "task" can be NULL. Another task is awoken to use the
374 void xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_release_xprt_cong() argument
376 if (xprt->snd_task == task) { in xprt_release_xprt_cong()
380 trace_xprt_release_cong(xprt, task); in xprt_release_xprt_cong()
384 static inline void xprt_release_write(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_release_write() argument
386 if (xprt->snd_task != task) in xprt_release_write()
389 xprt->ops->release_xprt(xprt, task); in xprt_release_write()
395 * overflowed. Put the task to sleep if this is the case.
413 * Adjust the congestion window, and wake up the next task
451 * @task: RPC request that recently completed
455 void xprt_release_rqst_cong(struct rpc_task *task) in xprt_release_rqst_cong() argument
457 struct rpc_rqst *req = task->tk_rqstp; in xprt_release_rqst_cong()
486 * @task: recently completed RPC request used to adjust window
499 void xprt_adjust_cwnd(struct rpc_xprt *xprt, struct rpc_task *task, int result) in xprt_adjust_cwnd() argument
501 struct rpc_rqst *req = task->tk_rqstp; in xprt_adjust_cwnd()
526 * @status: result code to plant in each task before waking it
557 dprintk("RPC: write space: waking waiting task on " in xprt_clear_write_space_locked()
565 * xprt_write_space - wake the task waiting for transport output buffer space
615 static void xprt_init_majortimeo(struct rpc_task *task, struct rpc_rqst *req) in xprt_init_majortimeo() argument
623 time_init = xprt_abs_ktime_to_jiffies(task->tk_start); in xprt_init_majortimeo()
624 req->rq_timeout = task->tk_client->cl_timeout->to_initval; in xprt_init_majortimeo()
729 xprt_request_retransmit_after_disconnect(struct rpc_task *task) in xprt_request_retransmit_after_disconnect() argument
731 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_retransmit_after_disconnect()
796 struct rpc_task *task, in xprt_lock_connect() argument
804 if (xprt->snd_task != task) in xprt_lock_connect()
830 * @task: RPC task that is requesting the connect
833 void xprt_connect(struct rpc_task *task) in xprt_connect() argument
835 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt; in xprt_connect()
840 task->tk_status = -EAGAIN; in xprt_connect()
843 if (!xprt_lock_write(xprt, task)) in xprt_connect()
852 task->tk_rqstp->rq_connect_cookie = xprt->connect_cookie; in xprt_connect()
853 rpc_sleep_on_timeout(&xprt->pending, task, NULL, in xprt_connect()
854 xprt_request_timeout(task->tk_rqstp)); in xprt_connect()
863 xprt->ops->connect(xprt, task); in xprt_connect()
866 task->tk_status = 0; in xprt_connect()
867 rpc_wake_up_queued_task(&xprt->pending, task); in xprt_connect()
870 xprt_release_write(xprt, task); in xprt_connect()
1042 xprt_request_data_received(struct rpc_task *task) in xprt_request_data_received() argument
1044 return !test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) && in xprt_request_data_received()
1045 READ_ONCE(task->tk_rqstp->rq_reply_bytes_recvd) != 0; in xprt_request_data_received()
1049 xprt_request_need_enqueue_receive(struct rpc_task *task, struct rpc_rqst *req) in xprt_request_need_enqueue_receive() argument
1051 return !test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) && in xprt_request_need_enqueue_receive()
1052 READ_ONCE(task->tk_rqstp->rq_reply_bytes_recvd) == 0; in xprt_request_need_enqueue_receive()
1057 * @task: RPC task
1061 xprt_request_enqueue_receive(struct rpc_task *task) in xprt_request_enqueue_receive() argument
1063 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_enqueue_receive()
1066 if (!xprt_request_need_enqueue_receive(task, req)) in xprt_request_enqueue_receive()
1069 xprt_request_prepare(task->tk_rqstp); in xprt_request_enqueue_receive()
1078 set_bit(RPC_TASK_NEED_RECV, &task->tk_runstate); in xprt_request_enqueue_receive()
1087 * @task: RPC task
1092 xprt_request_dequeue_receive_locked(struct rpc_task *task) in xprt_request_dequeue_receive_locked() argument
1094 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_dequeue_receive_locked()
1096 if (test_and_clear_bit(RPC_TASK_NEED_RECV, &task->tk_runstate)) in xprt_request_dequeue_receive_locked()
1102 * @task: RPC request that recently completed
1106 void xprt_update_rtt(struct rpc_task *task) in xprt_update_rtt() argument
1108 struct rpc_rqst *req = task->tk_rqstp; in xprt_update_rtt()
1109 struct rpc_rtt *rtt = task->tk_client->cl_rtt; in xprt_update_rtt()
1110 unsigned int timer = task->tk_msg.rpc_proc->p_timer; in xprt_update_rtt()
1123 * @task: RPC request that recently completed
1128 void xprt_complete_rqst(struct rpc_task *task, int copied) in xprt_complete_rqst() argument
1130 struct rpc_rqst *req = task->tk_rqstp; in xprt_complete_rqst()
1140 xprt_request_dequeue_receive_locked(task); in xprt_complete_rqst()
1141 rpc_wake_up_queued_task(&xprt->pending, task); in xprt_complete_rqst()
1145 static void xprt_timer(struct rpc_task *task) in xprt_timer() argument
1147 struct rpc_rqst *req = task->tk_rqstp; in xprt_timer()
1150 if (task->tk_status != -ETIMEDOUT) in xprt_timer()
1153 trace_xprt_timer(xprt, req->rq_xid, task->tk_status); in xprt_timer()
1156 xprt->ops->timer(xprt, task); in xprt_timer()
1158 task->tk_status = 0; in xprt_timer()
1163 * @task: pointer to rpc_task
1168 * and put the task to sleep on the pending queue.
1170 void xprt_wait_for_reply_request_def(struct rpc_task *task) in xprt_wait_for_reply_request_def() argument
1172 struct rpc_rqst *req = task->tk_rqstp; in xprt_wait_for_reply_request_def()
1174 rpc_sleep_on_timeout(&req->rq_xprt->pending, task, xprt_timer, in xprt_wait_for_reply_request_def()
1181 * @task: pointer to rpc_task
1184 * and put the task to sleep on the pending queue.
1186 void xprt_wait_for_reply_request_rtt(struct rpc_task *task) in xprt_wait_for_reply_request_rtt() argument
1188 int timer = task->tk_msg.rpc_proc->p_timer; in xprt_wait_for_reply_request_rtt()
1189 struct rpc_clnt *clnt = task->tk_client; in xprt_wait_for_reply_request_rtt()
1191 struct rpc_rqst *req = task->tk_rqstp; in xprt_wait_for_reply_request_rtt()
1199 rpc_sleep_on_timeout(&req->rq_xprt->pending, task, xprt_timer, in xprt_wait_for_reply_request_rtt()
1206 * @task: RPC task about to send a request
1209 void xprt_request_wait_receive(struct rpc_task *task) in xprt_request_wait_receive() argument
1211 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_wait_receive()
1214 if (!test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate)) in xprt_request_wait_receive()
1222 if (test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate)) { in xprt_request_wait_receive()
1223 xprt->ops->wait_for_reply_request(task); in xprt_request_wait_receive()
1229 if (xprt_request_retransmit_after_disconnect(task)) in xprt_request_wait_receive()
1231 task, -ENOTCONN); in xprt_request_wait_receive()
1237 xprt_request_need_enqueue_transmit(struct rpc_task *task, struct rpc_rqst *req) in xprt_request_need_enqueue_transmit() argument
1239 return !test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate); in xprt_request_need_enqueue_transmit()
1243 * xprt_request_enqueue_transmit - queue a task for transmission
1244 * @task: pointer to rpc_task
1246 * Add a task to the transmission queue.
1249 xprt_request_enqueue_transmit(struct rpc_task *task) in xprt_request_enqueue_transmit() argument
1251 struct rpc_rqst *pos, *req = task->tk_rqstp; in xprt_request_enqueue_transmit()
1254 if (xprt_request_need_enqueue_transmit(task, req)) { in xprt_request_enqueue_transmit()
1271 } else if (RPC_IS_SWAPPER(task)) { in xprt_request_enqueue_transmit()
1284 if (pos->rq_task->tk_owner != task->tk_owner) in xprt_request_enqueue_transmit()
1294 set_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate); in xprt_request_enqueue_transmit()
1300 * xprt_request_dequeue_transmit_locked - remove a task from the transmission queue
1301 * @task: pointer to rpc_task
1303 * Remove a task from the transmission queue
1307 xprt_request_dequeue_transmit_locked(struct rpc_task *task) in xprt_request_dequeue_transmit_locked() argument
1309 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_dequeue_transmit_locked()
1311 if (!test_and_clear_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) in xprt_request_dequeue_transmit_locked()
1326 * xprt_request_dequeue_transmit - remove a task from the transmission queue
1327 * @task: pointer to rpc_task
1329 * Remove a task from the transmission queue
1332 xprt_request_dequeue_transmit(struct rpc_task *task) in xprt_request_dequeue_transmit() argument
1334 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_dequeue_transmit()
1338 xprt_request_dequeue_transmit_locked(task); in xprt_request_dequeue_transmit()
1343 * xprt_request_dequeue_xprt - remove a task from the transmit+receive queue
1344 * @task: pointer to rpc_task
1346 * Remove a task from the transmit and receive queues, and ensure that
1350 xprt_request_dequeue_xprt(struct rpc_task *task) in xprt_request_dequeue_xprt() argument
1352 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_dequeue_xprt()
1355 if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate) || in xprt_request_dequeue_xprt()
1356 test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) || in xprt_request_dequeue_xprt()
1359 xprt_request_dequeue_transmit_locked(task); in xprt_request_dequeue_xprt()
1360 xprt_request_dequeue_receive_locked(task); in xprt_request_dequeue_xprt()
1362 set_bit(RPC_TASK_MSG_PIN_WAIT, &task->tk_runstate); in xprt_request_dequeue_xprt()
1366 clear_bit(RPC_TASK_MSG_PIN_WAIT, &task->tk_runstate); in xprt_request_dequeue_xprt()
1389 * xprt_request_need_retransmit - Test if a task needs retransmission
1390 * @task: pointer to rpc_task
1392 * Test for whether a connection breakage requires the task to retransmit
1395 xprt_request_need_retransmit(struct rpc_task *task) in xprt_request_need_retransmit() argument
1397 return xprt_request_retransmit_after_disconnect(task); in xprt_request_need_retransmit()
1402 * @task: RPC task about to send a request
1405 bool xprt_prepare_transmit(struct rpc_task *task) in xprt_prepare_transmit() argument
1407 struct rpc_rqst *req = task->tk_rqstp; in xprt_prepare_transmit()
1410 if (!xprt_lock_write(xprt, task)) { in xprt_prepare_transmit()
1411 trace_xprt_transmit_queued(xprt, task); in xprt_prepare_transmit()
1414 if (!test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) in xprt_prepare_transmit()
1416 task, 0); in xprt_prepare_transmit()
1423 void xprt_end_transmit(struct rpc_task *task) in xprt_end_transmit() argument
1425 xprt_release_write(task->tk_rqstp->rq_xprt, task); in xprt_end_transmit()
1431 * @snd_task: RPC task that owns the transport lock
1442 struct rpc_task *task = req->rq_task; in xprt_request_transmit() local
1444 int is_retrans = RPC_WAS_SENT(task); in xprt_request_transmit()
1448 if (xprt_request_data_received(task)) { in xprt_request_transmit()
1453 if (rpcauth_xmit_need_reencode(task)) { in xprt_request_transmit()
1457 if (RPC_SIGNALLED(task)) { in xprt_request_transmit()
1470 trace_rpc_xdr_sendto(task, &req->rq_snd_buf); in xprt_request_transmit()
1480 task->tk_client->cl_stats->rpcretrans++; in xprt_request_transmit()
1484 task->tk_flags |= RPC_TASK_SENT; in xprt_request_transmit()
1497 xprt_request_dequeue_transmit(task); in xprt_request_transmit()
1498 rpc_wake_up_queued_task_set_status(&xprt->sending, task, status); in xprt_request_transmit()
1504 * @task: controlling RPC task
1508 * resume, or @task finished transmitting, and detected that it already
1512 xprt_transmit(struct rpc_task *task) in xprt_transmit() argument
1514 struct rpc_rqst *next, *req = task->tk_rqstp; in xprt_transmit()
1527 status = xprt_request_transmit(next, task); in xprt_transmit()
1533 if (!xprt_request_data_received(task) || in xprt_transmit()
1534 test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) in xprt_transmit()
1536 } else if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate)) in xprt_transmit()
1537 task->tk_status = status; in xprt_transmit()
1543 static void xprt_add_backlog(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_add_backlog() argument
1546 rpc_sleep_on(&xprt->backlog, task, NULL); in xprt_add_backlog()
1555 static bool xprt_throttle_congested(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_throttle_congested() argument
1563 rpc_sleep_on(&xprt->backlog, task, NULL); in xprt_throttle_congested()
1599 void xprt_alloc_slot(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_alloc_slot() argument
1616 task->tk_status = -ENOMEM; in xprt_alloc_slot()
1619 xprt_add_backlog(xprt, task); in xprt_alloc_slot()
1623 task->tk_status = -EAGAIN; in xprt_alloc_slot()
1632 task->tk_status = 0; in xprt_alloc_slot()
1633 task->tk_rqstp = req; in xprt_alloc_slot()
1727 xprt_request_init(struct rpc_task *task) in xprt_request_init() argument
1729 struct rpc_xprt *xprt = task->tk_xprt; in xprt_request_init()
1730 struct rpc_rqst *req = task->tk_rqstp; in xprt_request_init()
1732 req->rq_task = task; in xprt_request_init()
1744 xprt_init_majortimeo(task, req); in xprt_request_init()
1750 xprt_do_reserve(struct rpc_xprt *xprt, struct rpc_task *task) in xprt_do_reserve() argument
1752 xprt->ops->alloc_slot(xprt, task); in xprt_do_reserve()
1753 if (task->tk_rqstp != NULL) in xprt_do_reserve()
1754 xprt_request_init(task); in xprt_do_reserve()
1759 * @task: RPC task requesting a slot allocation
1762 * slots are available, place the task on the transport's
1765 void xprt_reserve(struct rpc_task *task) in xprt_reserve() argument
1767 struct rpc_xprt *xprt = task->tk_xprt; in xprt_reserve()
1769 task->tk_status = 0; in xprt_reserve()
1770 if (task->tk_rqstp != NULL) in xprt_reserve()
1773 task->tk_status = -EAGAIN; in xprt_reserve()
1774 if (!xprt_throttle_congested(xprt, task)) in xprt_reserve()
1775 xprt_do_reserve(xprt, task); in xprt_reserve()
1780 * @task: RPC task requesting a slot allocation
1782 * If no more slots are available, place the task on the transport's
1787 void xprt_retry_reserve(struct rpc_task *task) in xprt_retry_reserve() argument
1789 struct rpc_xprt *xprt = task->tk_xprt; in xprt_retry_reserve()
1791 task->tk_status = 0; in xprt_retry_reserve()
1792 if (task->tk_rqstp != NULL) in xprt_retry_reserve()
1795 task->tk_status = -EAGAIN; in xprt_retry_reserve()
1796 xprt_do_reserve(xprt, task); in xprt_retry_reserve()
1801 * @task: task which is finished with the slot
1804 void xprt_release(struct rpc_task *task) in xprt_release() argument
1807 struct rpc_rqst *req = task->tk_rqstp; in xprt_release()
1810 if (task->tk_client) { in xprt_release()
1811 xprt = task->tk_xprt; in xprt_release()
1812 xprt_release_write(xprt, task); in xprt_release()
1818 xprt_request_dequeue_xprt(task); in xprt_release()
1820 xprt->ops->release_xprt(xprt, task); in xprt_release()
1822 xprt->ops->release_request(task); in xprt_release()
1826 xprt->ops->buf_free(task); in xprt_release()
1832 task->tk_rqstp = NULL; in xprt_release()
1844 xprt_init_bc_request(struct rpc_rqst *req, struct rpc_task *task) in xprt_init_bc_request() argument
1848 task->tk_rqstp = req; in xprt_init_bc_request()
1849 req->rq_task = task; in xprt_init_bc_request()