Lines Matching defs:task
75 static void xprt_request_init(struct rpc_task *task);
258 * @task: task that is requesting access to the transport
265 int xprt_reserve_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
267 struct rpc_rqst *req = task->tk_rqstp;
270 if (task == xprt->snd_task)
276 xprt->snd_task = task;
279 trace_xprt_reserve_xprt(xprt, task);
285 task->tk_status = -EAGAIN;
286 if (RPC_IS_SOFT(task))
287 rpc_sleep_on_timeout(&xprt->sending, task, NULL,
290 rpc_sleep_on(&xprt->sending, task, NULL);
322 * @task: task that is requesting access to the transport
329 int xprt_reserve_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task)
331 struct rpc_rqst *req = task->tk_rqstp;
334 if (task == xprt->snd_task)
339 xprt->snd_task = task;
345 xprt->snd_task = task;
351 task->tk_status = -EAGAIN;
352 if (RPC_IS_SOFT(task))
353 rpc_sleep_on_timeout(&xprt->sending, task, NULL,
356 rpc_sleep_on(&xprt->sending, task, NULL);
359 trace_xprt_reserve_cong(xprt, task);
364 static inline int xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task)
368 if (test_bit(XPRT_LOCKED, &xprt->state) && xprt->snd_task == task)
371 retval = xprt->ops->reserve_xprt(xprt, task);
376 static bool __xprt_lock_write_func(struct rpc_task *task, void *data)
380 xprt->snd_task = task;
415 * @task: task that is releasing access to the transport
417 * Note that "task" can be NULL. No congestion control is provided.
419 void xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
421 if (xprt->snd_task == task) {
425 trace_xprt_release_xprt(xprt, task);
432 * @task: task that is releasing access to the transport
434 * Note that "task" can be NULL. Another task is awoken to use the
437 void xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task)
439 if (xprt->snd_task == task) {
443 trace_xprt_release_cong(xprt, task);
447 void xprt_release_write(struct rpc_xprt *xprt, struct rpc_task *task)
449 if (xprt->snd_task != task)
452 xprt->ops->release_xprt(xprt, task);
458 * overflowed. Put the task to sleep if this is the case.
476 * Adjust the congestion window, and wake up the next task
514 * @task: RPC request that recently completed
518 void xprt_release_rqst_cong(struct rpc_task *task)
520 struct rpc_rqst *req = task->tk_rqstp;
549 * @task: recently completed RPC request used to adjust window
562 void xprt_adjust_cwnd(struct rpc_xprt *xprt, struct rpc_task *task, int result)
564 struct rpc_rqst *req = task->tk_rqstp;
589 * @status: result code to plant in each task before waking it
620 dprintk("RPC: write space: waking waiting task on "
628 * xprt_write_space - wake the task waiting for transport output buffer space
678 static void xprt_init_majortimeo(struct rpc_task *task, struct rpc_rqst *req)
686 time_init = xprt_abs_ktime_to_jiffies(task->tk_start);
687 req->rq_timeout = task->tk_client->cl_timeout->to_initval;
803 xprt_request_retransmit_after_disconnect(struct rpc_task *task)
805 struct rpc_rqst *req = task->tk_rqstp;
879 struct rpc_task *task,
887 if (xprt->snd_task != task)
917 * @task: RPC task that is requesting the connect
920 void xprt_connect(struct rpc_task *task)
922 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
927 task->tk_status = -EAGAIN;
930 if (!xprt_lock_write(xprt, task))
934 task->tk_rqstp->rq_connect_cookie = xprt->connect_cookie;
935 rpc_sleep_on_timeout(&xprt->pending, task, NULL,
936 xprt_request_timeout(task->tk_rqstp));
945 xprt->ops->connect(xprt, task);
948 task->tk_status = 0;
949 rpc_wake_up_queued_task(&xprt->pending, task);
952 xprt_release_write(xprt, task);
1124 xprt_request_data_received(struct rpc_task *task)
1126 return !test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) &&
1127 READ_ONCE(task->tk_rqstp->rq_reply_bytes_recvd) != 0;
1131 xprt_request_need_enqueue_receive(struct rpc_task *task, struct rpc_rqst *req)
1133 return !test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) &&
1134 READ_ONCE(task->tk_rqstp->rq_reply_bytes_recvd) == 0;
1139 * @task: RPC task
1143 xprt_request_enqueue_receive(struct rpc_task *task)
1145 struct rpc_rqst *req = task->tk_rqstp;
1149 if (!xprt_request_need_enqueue_receive(task, req))
1152 ret = xprt_request_prepare(task->tk_rqstp, &req->rq_rcv_buf);
1163 set_bit(RPC_TASK_NEED_RECV, &task->tk_runstate);
1173 * @task: RPC task
1178 xprt_request_dequeue_receive_locked(struct rpc_task *task)
1180 struct rpc_rqst *req = task->tk_rqstp;
1182 if (test_and_clear_bit(RPC_TASK_NEED_RECV, &task->tk_runstate))
1188 * @task: RPC request that recently completed
1192 void xprt_update_rtt(struct rpc_task *task)
1194 struct rpc_rqst *req = task->tk_rqstp;
1195 struct rpc_rtt *rtt = task->tk_client->cl_rtt;
1196 unsigned int timer = task->tk_msg.rpc_proc->p_timer;
1209 * @task: RPC request that recently completed
1214 void xprt_complete_rqst(struct rpc_task *task, int copied)
1216 struct rpc_rqst *req = task->tk_rqstp;
1228 xprt_request_dequeue_receive_locked(task);
1229 rpc_wake_up_queued_task(&xprt->pending, task);
1233 static void xprt_timer(struct rpc_task *task)
1235 struct rpc_rqst *req = task->tk_rqstp;
1238 if (task->tk_status != -ETIMEDOUT)
1241 trace_xprt_timer(xprt, req->rq_xid, task->tk_status);
1244 xprt->ops->timer(xprt, task);
1246 task->tk_status = 0;
1251 * @task: pointer to rpc_task
1256 * and put the task to sleep on the pending queue.
1258 void xprt_wait_for_reply_request_def(struct rpc_task *task)
1260 struct rpc_rqst *req = task->tk_rqstp;
1262 rpc_sleep_on_timeout(&req->rq_xprt->pending, task, xprt_timer,
1269 * @task: pointer to rpc_task
1272 * and put the task to sleep on the pending queue.
1274 void xprt_wait_for_reply_request_rtt(struct rpc_task *task)
1276 int timer = task->tk_msg.rpc_proc->p_timer;
1277 struct rpc_clnt *clnt = task->tk_client;
1279 struct rpc_rqst *req = task->tk_rqstp;
1287 rpc_sleep_on_timeout(&req->rq_xprt->pending, task, xprt_timer,
1294 * @task: RPC task about to send a request
1297 void xprt_request_wait_receive(struct rpc_task *task)
1299 struct rpc_rqst *req = task->tk_rqstp;
1302 if (!test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate))
1310 if (test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate)) {
1311 xprt->ops->wait_for_reply_request(task);
1317 if (xprt_request_retransmit_after_disconnect(task))
1319 task, -ENOTCONN);
1325 xprt_request_need_enqueue_transmit(struct rpc_task *task, struct rpc_rqst *req)
1327 return !test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate);
1331 * xprt_request_enqueue_transmit - queue a task for transmission
1332 * @task: pointer to rpc_task
1334 * Add a task to the transmission queue.
1337 xprt_request_enqueue_transmit(struct rpc_task *task)
1339 struct rpc_rqst *pos, *req = task->tk_rqstp;
1343 if (xprt_request_need_enqueue_transmit(task, req)) {
1344 ret = xprt_request_prepare(task->tk_rqstp, &req->rq_snd_buf);
1346 task->tk_status = ret;
1367 if (pos->rq_task->tk_owner != task->tk_owner)
1378 set_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate);
1384 * xprt_request_dequeue_transmit_locked - remove a task from the transmission queue
1385 * @task: pointer to rpc_task
1387 * Remove a task from the transmission queue
1391 xprt_request_dequeue_transmit_locked(struct rpc_task *task)
1393 struct rpc_rqst *req = task->tk_rqstp;
1395 if (!test_and_clear_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate))
1412 * xprt_request_dequeue_transmit - remove a task from the transmission queue
1413 * @task: pointer to rpc_task
1415 * Remove a task from the transmission queue
1418 xprt_request_dequeue_transmit(struct rpc_task *task)
1420 struct rpc_rqst *req = task->tk_rqstp;
1424 xprt_request_dequeue_transmit_locked(task);
1429 * xprt_request_dequeue_xprt - remove a task from the transmit+receive queue
1430 * @task: pointer to rpc_task
1432 * Remove a task from the transmit and receive queues, and ensure that
1436 xprt_request_dequeue_xprt(struct rpc_task *task)
1438 struct rpc_rqst *req = task->tk_rqstp;
1441 if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate) ||
1442 test_bit(RPC_TASK_NEED_RECV, &task->tk_runstate) ||
1446 set_bit(RPC_TASK_MSG_PIN_WAIT, &task->tk_runstate);
1450 clear_bit(RPC_TASK_MSG_PIN_WAIT, &task->tk_runstate);
1452 xprt_request_dequeue_transmit_locked(task);
1453 xprt_request_dequeue_receive_locked(task);
1479 * xprt_request_need_retransmit - Test if a task needs retransmission
1480 * @task: pointer to rpc_task
1482 * Test for whether a connection breakage requires the task to retransmit
1485 xprt_request_need_retransmit(struct rpc_task *task)
1487 return xprt_request_retransmit_after_disconnect(task);
1492 * @task: RPC task about to send a request
1495 bool xprt_prepare_transmit(struct rpc_task *task)
1497 struct rpc_rqst *req = task->tk_rqstp;
1500 if (!xprt_lock_write(xprt, task)) {
1502 if (!test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate))
1504 task, 0);
1514 void xprt_end_transmit(struct rpc_task *task)
1516 struct rpc_xprt *xprt = task->tk_rqstp->rq_xprt;
1519 xprt_release_write(xprt, task);
1525 * @snd_task: RPC task that owns the transport lock
1536 struct rpc_task *task = req->rq_task;
1538 int is_retrans = RPC_WAS_SENT(task);
1542 if (xprt_request_data_received(task)) {
1547 if (rpcauth_xmit_need_reencode(task)) {
1551 if (RPC_SIGNALLED(task)) {
1564 trace_rpc_xdr_sendto(task, &req->rq_snd_buf);
1574 task->tk_client->cl_stats->rpcretrans++;
1580 task->tk_flags |= RPC_TASK_SENT;
1593 xprt_request_dequeue_transmit(task);
1594 rpc_wake_up_queued_task_set_status(&xprt->sending, task, status);
1600 * @task: controlling RPC task
1604 * resume, or @task finished transmitting, and detected that it already
1608 xprt_transmit(struct rpc_task *task)
1610 struct rpc_rqst *next, *req = task->tk_rqstp;
1622 status = xprt_request_transmit(next, task);
1628 if (test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate))
1629 task->tk_status = status;
1632 /* Was @task transmitted, and has it received a reply? */
1633 if (xprt_request_data_received(task) &&
1634 !test_bit(RPC_TASK_NEED_XMIT, &task->tk_runstate))
1641 static void xprt_complete_request_init(struct rpc_task *task)
1643 if (task->tk_rqstp)
1644 xprt_request_init(task);
1647 void xprt_add_backlog(struct rpc_xprt *xprt, struct rpc_task *task)
1650 rpc_sleep_on(&xprt->backlog, task, xprt_complete_request_init);
1654 static bool __xprt_set_rq(struct rpc_task *task, void *data)
1658 if (task->tk_rqstp == NULL) {
1660 task->tk_rqstp = req;
1676 static bool xprt_throttle_congested(struct rpc_xprt *xprt, struct rpc_task *task)
1684 xprt_add_backlog(xprt, task);
1720 void xprt_alloc_slot(struct rpc_xprt *xprt, struct rpc_task *task)
1737 task->tk_status = -ENOMEM;
1740 xprt_add_backlog(xprt, task);
1744 task->tk_status = -EAGAIN;
1753 task->tk_status = 0;
1754 task->tk_rqstp = req;
1872 xprt_request_init(struct rpc_task *task)
1874 struct rpc_xprt *xprt = task->tk_xprt;
1875 struct rpc_rqst *req = task->tk_rqstp;
1877 req->rq_task = task;
1889 xprt_init_majortimeo(task, req);
1895 xprt_do_reserve(struct rpc_xprt *xprt, struct rpc_task *task)
1897 xprt->ops->alloc_slot(xprt, task);
1898 if (task->tk_rqstp != NULL)
1899 xprt_request_init(task);
1904 * @task: RPC task requesting a slot allocation
1907 * slots are available, place the task on the transport's
1910 void xprt_reserve(struct rpc_task *task)
1912 struct rpc_xprt *xprt = task->tk_xprt;
1914 task->tk_status = 0;
1915 if (task->tk_rqstp != NULL)
1918 task->tk_status = -EAGAIN;
1919 if (!xprt_throttle_congested(xprt, task))
1920 xprt_do_reserve(xprt, task);
1925 * @task: RPC task requesting a slot allocation
1927 * If no more slots are available, place the task on the transport's
1932 void xprt_retry_reserve(struct rpc_task *task)
1934 struct rpc_xprt *xprt = task->tk_xprt;
1936 task->tk_status = 0;
1937 if (task->tk_rqstp != NULL)
1940 task->tk_status = -EAGAIN;
1941 xprt_do_reserve(xprt, task);
1946 * @task: task which is finished with the slot
1949 void xprt_release(struct rpc_task *task)
1952 struct rpc_rqst *req = task->tk_rqstp;
1955 if (task->tk_client) {
1956 xprt = task->tk_xprt;
1957 xprt_release_write(xprt, task);
1963 xprt_request_dequeue_xprt(task);
1965 xprt->ops->release_xprt(xprt, task);
1967 xprt->ops->release_request(task);
1971 xprt->ops->buf_free(task);
1977 task->tk_rqstp = NULL;
1986 xprt_init_bc_request(struct rpc_rqst *req, struct rpc_task *task)
1990 task->tk_rqstp = req;
1991 req->rq_task = task;