Lines Matching defs: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)
238 struct rpc_rqst *req = task->tk_rqstp;
241 if (task == xprt->snd_task)
247 xprt->snd_task = task;
250 trace_xprt_reserve_xprt(xprt, task);
256 task->tk_status = -EAGAIN;
257 if (RPC_IS_SOFT(task))
258 rpc_sleep_on_timeout(&xprt->sending, task, NULL,
261 rpc_sleep_on(&xprt->sending, task, NULL);
293 * @task: task that is requesting access to the transport
300 int xprt_reserve_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task)
302 struct rpc_rqst *req = task->tk_rqstp;
305 if (task == xprt->snd_task)
310 xprt->snd_task = task;
316 xprt->snd_task = task;
322 task->tk_status = -EAGAIN;
323 if (RPC_IS_SOFT(task))
324 rpc_sleep_on_timeout(&xprt->sending, task, NULL,
327 rpc_sleep_on(&xprt->sending, task, NULL);
330 trace_xprt_reserve_cong(xprt, task);
335 static inline int xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task)
339 if (test_bit(XPRT_LOCKED, &xprt->state) && xprt->snd_task == task)
342 retval = xprt->ops->reserve_xprt(xprt, task);
347 static bool __xprt_lock_write_func(struct rpc_task *task, void *data)
351 xprt->snd_task = task;
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)
392 if (xprt->snd_task == task) {
396 trace_xprt_release_xprt(xprt, task);
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)
410 if (xprt->snd_task == task) {
414 trace_xprt_release_cong(xprt, task);
418 static inline void xprt_release_write(struct rpc_xprt *xprt, struct rpc_task *task)
420 if (xprt->snd_task != task)
423 xprt->ops->release_xprt(xprt, task);
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)
491 struct rpc_rqst *req = task->tk_rqstp;
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)
535 struct rpc_rqst *req = task->tk_rqstp;
560 * @status: result code to plant in each task before waking it
591 dprintk("RPC: write space: waking waiting task on "
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)
657 time_init = xprt_abs_ktime_to_jiffies(task->tk_start);
658 req->rq_timeout = task->tk_client->cl_timeout->to_initval;
772 xprt_request_retransmit_after_disconnect(struct rpc_task *task)
774 struct rpc_rqst *req = task->tk_rqstp;
835 struct rpc_task *task,
843 if (xprt->snd_task != task)
873 * @task: RPC task that is requesting the connect
876 void xprt_connect(struct rpc_task *task)
878 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
883 task->tk_status = -EAGAIN;
886 if (!xprt_lock_write(xprt, task))
890 task->tk_rqstp->rq_connect_cookie = xprt->connect_cookie;
891 rpc_sleep_on_timeout(&xprt->pending, task, NULL,
892 xprt_request_timeout(task->tk_rqstp));
901 xprt->ops->connect(xprt, task);
904 task->tk_status = 0;
905 rpc_wake_up_queued_task(&xprt->pending, task);
908 xprt_release_write(xprt, task);
1080 xprt_request_data_received(struct rpc_task *task)
1082 return !test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) &&
1083 READ_ONCE(task->tk_rqstp->rq_reply_bytes_recvd) != 0;
1087 xprt_request_need_enqueue_receive(struct rpc_task *task, struct rpc_rqst *req)
1089 return !test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) &&
1090 READ_ONCE(task->tk_rqstp->rq_reply_bytes_recvd) == 0;
1095 * @task: RPC task
1099 xprt_request_enqueue_receive(struct rpc_task *task)
1101 struct rpc_rqst *req = task->tk_rqstp;
1104 if (!xprt_request_need_enqueue_receive(task, req))
1107 xprt_request_prepare(task->tk_rqstp);
1116 set_bit(RPC_TASK_NEED_RECV, &task->tk_runstate);
1125 * @task: RPC task
1130 xprt_request_dequeue_receive_locked(struct rpc_task *task)
1132 struct rpc_rqst *req = task->tk_rqstp;
1134 if (test_and_clear_bit(RPC_TASK_NEED_RECV, &task->tk_runstate))
1140 * @task: RPC request that recently completed
1144 void xprt_update_rtt(struct rpc_task *task)
1146 struct rpc_rqst *req = task->tk_rqstp;
1147 struct rpc_rtt *rtt = task->tk_client->cl_rtt;
1148 unsigned int timer = task->tk_msg.rpc_proc->p_timer;
1161 * @task: RPC request that recently completed
1166 void xprt_complete_rqst(struct rpc_task *task, int copied)
1168 struct rpc_rqst *req = task->tk_rqstp;
1178 xprt_request_dequeue_receive_locked(task);
1179 rpc_wake_up_queued_task(&xprt->pending, task);
1183 static void xprt_timer(struct rpc_task *task)
1185 struct rpc_rqst *req = task->tk_rqstp;
1188 if (task->tk_status != -ETIMEDOUT)
1191 trace_xprt_timer(xprt, req->rq_xid, task->tk_status);
1194 xprt->ops->timer(xprt, task);
1196 task->tk_status = 0;
1201 * @task: pointer to rpc_task
1206 * and put the task to sleep on the pending queue.
1208 void xprt_wait_for_reply_request_def(struct rpc_task *task)
1210 struct rpc_rqst *req = task->tk_rqstp;
1212 rpc_sleep_on_timeout(&req->rq_xprt->pending, task, xprt_timer,
1219 * @task: pointer to rpc_task
1222 * and put the task to sleep on the pending queue.
1224 void xprt_wait_for_reply_request_rtt(struct rpc_task *task)
1226 int timer = task->tk_msg.rpc_proc->p_timer;
1227 struct rpc_clnt *clnt = task->tk_client;
1229 struct rpc_rqst *req = task->tk_rqstp;
1237 rpc_sleep_on_timeout(&req->rq_xprt->pending, task, xprt_timer,
1244 * @task: RPC task about to send a request
1247 void xprt_request_wait_receive(struct rpc_task *task)
1249 struct rpc_rqst *req = task->tk_rqstp;
1252 if (!test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate))
1260 if (test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate)) {
1261 xprt->ops->wait_for_reply_request(task);
1267 if (xprt_request_retransmit_after_disconnect(task))
1269 task, -ENOTCONN);
1275 xprt_request_need_enqueue_transmit(struct rpc_task *task, struct rpc_rqst *req)
1277 return !test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate);
1281 * xprt_request_enqueue_transmit - queue a task for transmission
1282 * @task: pointer to rpc_task
1284 * Add a task to the transmission queue.
1287 xprt_request_enqueue_transmit(struct rpc_task *task)
1289 struct rpc_rqst *pos, *req = task->tk_rqstp;
1292 if (xprt_request_need_enqueue_transmit(task, req)) {
1311 if (pos->rq_task->tk_owner != task->tk_owner)
1321 set_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate);
1327 * xprt_request_dequeue_transmit_locked - remove a task from the transmission queue
1328 * @task: pointer to rpc_task
1330 * Remove a task from the transmission queue
1334 xprt_request_dequeue_transmit_locked(struct rpc_task *task)
1336 struct rpc_rqst *req = task->tk_rqstp;
1338 if (!test_and_clear_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate))
1353 * xprt_request_dequeue_transmit - remove a task from the transmission queue
1354 * @task: pointer to rpc_task
1356 * Remove a task from the transmission queue
1359 xprt_request_dequeue_transmit(struct rpc_task *task)
1361 struct rpc_rqst *req = task->tk_rqstp;
1365 xprt_request_dequeue_transmit_locked(task);
1370 * xprt_request_dequeue_xprt - remove a task from the transmit+receive queue
1371 * @task: pointer to rpc_task
1373 * Remove a task from the transmit and receive queues, and ensure that
1377 xprt_request_dequeue_xprt(struct rpc_task *task)
1379 struct rpc_rqst *req = task->tk_rqstp;
1382 if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate) ||
1383 test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) ||
1386 xprt_request_dequeue_transmit_locked(task);
1387 xprt_request_dequeue_receive_locked(task);
1389 set_bit(RPC_TASK_MSG_PIN_WAIT, &task->tk_runstate);
1393 clear_bit(RPC_TASK_MSG_PIN_WAIT, &task->tk_runstate);
1416 * xprt_request_need_retransmit - Test if a task needs retransmission
1417 * @task: pointer to rpc_task
1419 * Test for whether a connection breakage requires the task to retransmit
1422 xprt_request_need_retransmit(struct rpc_task *task)
1424 return xprt_request_retransmit_after_disconnect(task);
1429 * @task: RPC task about to send a request
1432 bool xprt_prepare_transmit(struct rpc_task *task)
1434 struct rpc_rqst *req = task->tk_rqstp;
1437 if (!xprt_lock_write(xprt, task)) {
1439 if (!test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate))
1441 task, 0);
1448 void xprt_end_transmit(struct rpc_task *task)
1450 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
1453 xprt_release_write(xprt, task);
1459 * @snd_task: RPC task that owns the transport lock
1470 struct rpc_task *task = req->rq_task;
1472 int is_retrans = RPC_WAS_SENT(task);
1476 if (xprt_request_data_received(task)) {
1481 if (rpcauth_xmit_need_reencode(task)) {
1485 if (RPC_SIGNALLED(task)) {
1498 trace_rpc_xdr_sendto(task, &req->rq_snd_buf);
1508 task->tk_client->cl_stats->rpcretrans++;
1512 task->tk_flags |= RPC_TASK_SENT;
1525 xprt_request_dequeue_transmit(task);
1526 rpc_wake_up_queued_task_set_status(&xprt->sending, task, status);
1532 * @task: controlling RPC task
1536 * resume, or @task finished transmitting, and detected that it already
1540 xprt_transmit(struct rpc_task *task)
1542 struct rpc_rqst *next, *req = task->tk_rqstp;
1554 status = xprt_request_transmit(next, task);
1560 if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate))
1561 task->tk_status = status;
1564 /* Was @task transmitted, and has it received a reply? */
1565 if (xprt_request_data_received(task) &&
1566 !test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate))
1573 static void xprt_complete_request_init(struct rpc_task *task)
1575 if (task->tk_rqstp)
1576 xprt_request_init(task);
1579 void xprt_add_backlog(struct rpc_xprt *xprt, struct rpc_task *task)
1582 rpc_sleep_on(&xprt->backlog, task, xprt_complete_request_init);
1586 static bool __xprt_set_rq(struct rpc_task *task, void *data)
1590 if (task->tk_rqstp == NULL) {
1592 task->tk_rqstp = req;
1608 static bool xprt_throttle_congested(struct rpc_xprt *xprt, struct rpc_task *task)
1616 xprt_add_backlog(xprt, task);
1655 void xprt_alloc_slot(struct rpc_xprt *xprt, struct rpc_task *task)
1672 task->tk_status = -ENOMEM;
1675 xprt_add_backlog(xprt, task);
1679 task->tk_status = -EAGAIN;
1688 task->tk_status = 0;
1689 task->tk_rqstp = req;
1783 xprt_request_init(struct rpc_task *task)
1785 struct rpc_xprt *xprt = task->tk_xprt;
1786 struct rpc_rqst *req = task->tk_rqstp;
1788 req->rq_task = task;
1800 xprt_init_majortimeo(task, req);
1806 xprt_do_reserve(struct rpc_xprt *xprt, struct rpc_task *task)
1808 xprt->ops->alloc_slot(xprt, task);
1809 if (task->tk_rqstp != NULL)
1810 xprt_request_init(task);
1815 * @task: RPC task requesting a slot allocation
1818 * slots are available, place the task on the transport's
1821 void xprt_reserve(struct rpc_task *task)
1823 struct rpc_xprt *xprt = task->tk_xprt;
1825 task->tk_status = 0;
1826 if (task->tk_rqstp != NULL)
1829 task->tk_status = -EAGAIN;
1830 if (!xprt_throttle_congested(xprt, task))
1831 xprt_do_reserve(xprt, task);
1836 * @task: RPC task requesting a slot allocation
1838 * If no more slots are available, place the task on the transport's
1843 void xprt_retry_reserve(struct rpc_task *task)
1845 struct rpc_xprt *xprt = task->tk_xprt;
1847 task->tk_status = 0;
1848 if (task->tk_rqstp != NULL)
1851 task->tk_status = -EAGAIN;
1852 xprt_do_reserve(xprt, task);
1857 * @task: task which is finished with the slot
1860 void xprt_release(struct rpc_task *task)
1863 struct rpc_rqst *req = task->tk_rqstp;
1866 if (task->tk_client) {
1867 xprt = task->tk_xprt;
1868 xprt_release_write(xprt, task);
1874 xprt_request_dequeue_xprt(task);
1876 xprt->ops->release_xprt(xprt, task);
1878 xprt->ops->release_request(task);
1882 xprt->ops->buf_free(task);
1890 task->tk_rqstp = NULL;
1899 xprt_init_bc_request(struct rpc_rqst *req, struct rpc_task *task)
1903 task->tk_rqstp = req;
1904 req->rq_task = task;