Lines Matching refs:task
62 static void xprt_connect_status(struct rpc_task *task);
85 * @task: task that is requesting access to the transport
91 int xprt_reserve_xprt(struct rpc_task *task)
93 struct rpc_xprt *xprt = task->tk_xprt;
94 struct rpc_rqst *req = task->tk_rqstp;
97 if (task == xprt->snd_task)
99 if (task == NULL)
103 xprt->snd_task = task;
112 task->tk_pid, xprt);
113 task->tk_timeout = 0;
114 task->tk_status = -EAGAIN;
116 rpc_sleep_on(&xprt->resend, task, NULL, NULL);
118 rpc_sleep_on(&xprt->sending, task, NULL, NULL);
135 * @task: task that is requesting access to the transport
141 int xprt_reserve_xprt_cong(struct rpc_task *task)
143 struct rpc_xprt *xprt = task->tk_xprt;
144 struct rpc_rqst *req = task->tk_rqstp;
147 if (task == xprt->snd_task)
151 if (__xprt_get_cong(xprt, task)) {
152 xprt->snd_task = task;
161 dprintk("RPC: %5u failed to lock transport %p\n", task->tk_pid, xprt);
162 task->tk_timeout = 0;
163 task->tk_status = -EAGAIN;
165 rpc_sleep_on(&xprt->resend, task, NULL, NULL);
167 rpc_sleep_on(&xprt->sending, task, NULL, NULL);
171 static inline int xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task)
176 retval = xprt->ops->reserve_xprt(task);
183 struct rpc_task *task;
189 task = rpc_wake_up_next(&xprt->resend);
190 if (!task) {
191 task = rpc_wake_up_next(&xprt->sending);
192 if (!task)
196 req = task->tk_rqstp;
197 xprt->snd_task = task;
210 struct rpc_task *task;
216 task = rpc_wake_up_next(&xprt->resend);
217 if (!task) {
218 task = rpc_wake_up_next(&xprt->sending);
219 if (!task)
222 if (__xprt_get_cong(xprt, task)) {
223 struct rpc_rqst *req = task->tk_rqstp;
224 xprt->snd_task = task;
238 * @task: task that is releasing access to the transport
240 * Note that "task" can be NULL. No congestion control is provided.
242 void xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
244 if (xprt->snd_task == task) {
253 * @task: task that is releasing access to the transport
255 * Note that "task" can be NULL. Another task is awoken to use the
258 void xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task)
260 if (xprt->snd_task == task) {
266 static inline void xprt_release_write(struct rpc_xprt *xprt, struct rpc_task *task)
269 xprt->ops->release_xprt(xprt, task);
275 * overflowed. Put the task to sleep if this is the case.
278 __xprt_get_cong(struct rpc_xprt *xprt, struct rpc_task *task)
280 struct rpc_rqst *req = task->tk_rqstp;
285 task->tk_pid, xprt->cong, xprt->cwnd);
294 * Adjust the congestion window, and wake up the next task
309 * @task: RPC request that recently completed
313 void xprt_release_rqst_cong(struct rpc_task *task)
315 __xprt_put_cong(task->tk_xprt, task->tk_rqstp);
320 * @task: recently completed RPC request used to adjust window
325 void xprt_adjust_cwnd(struct rpc_task *task, int result)
327 struct rpc_rqst *req = task->tk_rqstp;
328 struct rpc_xprt *xprt = task->tk_xprt;
352 * @status: result code to plant in each task before waking it
365 * @task: task to be put to sleep
368 void xprt_wait_for_buffer_space(struct rpc_task *task)
370 struct rpc_rqst *req = task->tk_rqstp;
373 task->tk_timeout = req->rq_timeout;
374 rpc_sleep_on(&xprt->pending, task, NULL, NULL);
378 * xprt_write_space - wake the task waiting for transport output buffer space
390 dprintk("RPC: write space: waking waiting task on "
399 * @task: task whose timeout is to be set
405 void xprt_set_retrans_timeout_def(struct rpc_task *task)
407 task->tk_timeout = task->tk_rqstp->rq_timeout;
412 * @task: task whose timeout is to be set
416 void xprt_set_retrans_timeout_rtt(struct rpc_task *task)
418 int timer = task->tk_msg.rpc_proc->p_timer;
419 struct rpc_rtt *rtt = task->tk_client->cl_rtt;
420 struct rpc_rqst *req = task->tk_rqstp;
423 task->tk_timeout = rpc_calc_rto(rtt, timer);
424 task->tk_timeout <<= rpc_ntimeo(rtt, timer) + req->rq_retries;
425 if (task->tk_timeout > max_timeout || task->tk_timeout == 0)
426 task->tk_timeout = max_timeout;
526 * @task: RPC task that is requesting the connect
529 void xprt_connect(struct rpc_task *task)
531 struct rpc_xprt *xprt = task->tk_xprt;
533 dprintk("RPC: %5u xprt_connect xprt %p %s connected\n", task->tk_pid,
537 task->tk_status = -EIO;
540 if (!xprt_lock_write(xprt, task))
543 xprt_release_write(xprt, task);
545 if (task->tk_rqstp)
546 task->tk_rqstp->rq_bytes_sent = 0;
548 task->tk_timeout = xprt->connect_timeout;
549 rpc_sleep_on(&xprt->pending, task, xprt_connect_status, NULL);
551 xprt->ops->connect(task);
556 static void xprt_connect_status(struct rpc_task *task)
558 struct rpc_xprt *xprt = task->tk_xprt;
560 if (task->tk_status >= 0) {
564 task->tk_pid);
568 switch (task->tk_status) {
572 "connection\n", task->tk_pid,
573 task->tk_client->cl_server);
577 task->tk_pid);
581 "out\n", task->tk_pid);
585 "server %s\n", task->tk_pid, -task->tk_status,
586 task->tk_client->cl_server);
587 xprt_release_write(xprt, task);
588 task->tk_status = -EIO;
616 * @task: RPC request that recently completed
619 void xprt_update_rtt(struct rpc_task *task)
621 struct rpc_rqst *req = task->tk_rqstp;
622 struct rpc_rtt *rtt = task->tk_client->cl_rtt;
623 unsigned timer = task->tk_msg.rpc_proc->p_timer;
635 * @task: RPC request that recently completed
640 void xprt_complete_rqst(struct rpc_task *task, int copied)
642 struct rpc_rqst *req = task->tk_rqstp;
645 task->tk_pid, ntohl(req->rq_xid), copied);
647 task->tk_xprt->stat.recvs++;
648 task->tk_rtt = (long)jiffies - req->rq_xtime;
654 rpc_wake_up_task(task);
657 static void xprt_timer(struct rpc_task *task)
659 struct rpc_rqst *req = task->tk_rqstp;
662 dprintk("RPC: %5u xprt_timer\n", task->tk_pid);
667 xprt->ops->timer(task);
668 task->tk_status = -ETIMEDOUT;
670 task->tk_timeout = 0;
671 rpc_wake_up_task(task);
677 * @task: RPC task about to send a request
680 int xprt_prepare_transmit(struct rpc_task *task)
682 struct rpc_rqst *req = task->tk_rqstp;
686 dprintk("RPC: %5u xprt_prepare_transmit\n", task->tk_pid);
693 if (!xprt->ops->reserve_xprt(task)) {
707 void xprt_end_transmit(struct rpc_task *task)
709 xprt_release_write(task->tk_xprt, task);
714 * @task: controlling RPC task
718 void xprt_transmit(struct rpc_task *task)
720 struct rpc_rqst *req = task->tk_rqstp;
724 dprintk("RPC: %5u xprt_transmit(%u)\n", task->tk_pid, req->rq_slen);
742 status = xprt->ops->send_request(task);
744 dprintk("RPC: %5u xmit complete\n", task->tk_pid);
747 xprt->ops->set_retrans_timeout(task);
755 task->tk_status = -ENOTCONN;
757 rpc_sleep_on(&xprt->pending, task, NULL, xprt_timer);
762 /* Note: at this point, task->tk_sleeping has not yet been set,
763 * hence there is no danger of the waking up task being put on
766 task->tk_status = status;
768 rpc_sleep_on(&xprt->sending, task, NULL, NULL);
771 static inline void do_xprt_reserve(struct rpc_task *task)
773 struct rpc_xprt *xprt = task->tk_xprt;
775 task->tk_status = 0;
776 if (task->tk_rqstp)
781 task->tk_rqstp = req;
782 xprt_request_init(task, xprt);
786 task->tk_status = -EAGAIN;
787 task->tk_timeout = 0;
788 rpc_sleep_on(&xprt->backlog, task, NULL, NULL);
793 * @task: RPC task requesting a slot allocation
795 * If no more slots are available, place the task on the transport's
798 void xprt_reserve(struct rpc_task *task)
800 struct rpc_xprt *xprt = task->tk_xprt;
802 task->tk_status = -EIO;
804 do_xprt_reserve(task);
818 static void xprt_request_init(struct rpc_task *task, struct rpc_xprt *xprt)
820 struct rpc_rqst *req = task->tk_rqstp;
823 req->rq_task = task;
829 dprintk("RPC: %5u reserved req %p xid %08x\n", task->tk_pid,
835 * @task: task which is finished with the slot
838 void xprt_release(struct rpc_task *task)
840 struct rpc_xprt *xprt = task->tk_xprt;
843 if (!(req = task->tk_rqstp))
845 rpc_count_iostats(task);
847 xprt->ops->release_xprt(xprt, task);
849 xprt->ops->release_request(task);
858 task->tk_rqstp = NULL;
863 dprintk("RPC: %5u release request %p\n", task->tk_pid, req);