Lines Matching defs:xprt
2 * linux/net/sunrpc/xprt.c
79 #define RPC_MAXCWND(xprt) ((xprt)->max_reqs << RPC_CWNDSHIFT)
81 #define RPCXPRT_CONGESTED(xprt) ((xprt)->cong >= (xprt)->cwnd)
93 struct rpc_xprt *xprt = task->tk_xprt;
96 if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) {
97 if (task == xprt->snd_task)
103 xprt->snd_task = task;
112 task->tk_pid, xprt);
116 rpc_sleep_on(&xprt->resend, task, NULL, NULL);
118 rpc_sleep_on(&xprt->sending, task, NULL, NULL);
122 static void xprt_clear_locked(struct rpc_xprt *xprt)
124 xprt->snd_task = NULL;
125 if (!test_bit(XPRT_CLOSE_WAIT, &xprt->state) || xprt->shutdown) {
127 clear_bit(XPRT_LOCKED, &xprt->state);
130 schedule_work(&xprt->task_cleanup);
143 struct rpc_xprt *xprt = task->tk_xprt;
146 if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) {
147 if (task == xprt->snd_task)
151 if (__xprt_get_cong(xprt, task)) {
152 xprt->snd_task = task;
159 xprt_clear_locked(xprt);
161 dprintk("RPC: %5u failed to lock transport %p\n", task->tk_pid, xprt);
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)
175 spin_lock_bh(&xprt->transport_lock);
176 retval = xprt->ops->reserve_xprt(task);
177 spin_unlock_bh(&xprt->transport_lock);
181 static void __xprt_lock_write_next(struct rpc_xprt *xprt)
186 if (test_and_set_bit(XPRT_LOCKED, &xprt->state))
189 task = rpc_wake_up_next(&xprt->resend);
191 task = rpc_wake_up_next(&xprt->sending);
197 xprt->snd_task = task;
205 xprt_clear_locked(xprt);
208 static void __xprt_lock_write_next_cong(struct rpc_xprt *xprt)
212 if (test_and_set_bit(XPRT_LOCKED, &xprt->state))
214 if (RPCXPRT_CONGESTED(xprt))
216 task = rpc_wake_up_next(&xprt->resend);
218 task = rpc_wake_up_next(&xprt->sending);
222 if (__xprt_get_cong(xprt, task)) {
224 xprt->snd_task = task;
232 xprt_clear_locked(xprt);
237 * @xprt: transport with other tasks potentially waiting
242 void xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
244 if (xprt->snd_task == task) {
245 xprt_clear_locked(xprt);
246 __xprt_lock_write_next(xprt);
252 * @xprt: transport with other tasks potentially waiting
258 void xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task)
260 if (xprt->snd_task == task) {
261 xprt_clear_locked(xprt);
262 __xprt_lock_write_next_cong(xprt);
266 static inline void xprt_release_write(struct rpc_xprt *xprt, struct rpc_task *task)
268 spin_lock_bh(&xprt->transport_lock);
269 xprt->ops->release_xprt(xprt, task);
270 spin_unlock_bh(&xprt->transport_lock);
278 __xprt_get_cong(struct rpc_xprt *xprt, struct rpc_task *task)
285 task->tk_pid, xprt->cong, xprt->cwnd);
286 if (RPCXPRT_CONGESTED(xprt))
289 xprt->cong += RPC_CWNDSCALE;
298 __xprt_put_cong(struct rpc_xprt *xprt, struct rpc_rqst *req)
303 xprt->cong -= RPC_CWNDSCALE;
304 __xprt_lock_write_next_cong(xprt);
328 struct rpc_xprt *xprt = task->tk_xprt;
329 unsigned long cwnd = xprt->cwnd;
331 if (result >= 0 && cwnd <= xprt->cong) {
335 if (cwnd > RPC_MAXCWND(xprt))
336 cwnd = RPC_MAXCWND(xprt);
337 __xprt_lock_write_next_cong(xprt);
344 xprt->cong, xprt->cwnd, cwnd);
345 xprt->cwnd = cwnd;
346 __xprt_put_cong(xprt, req);
351 * @xprt: transport with waiting tasks
355 void xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status)
358 rpc_wake_up_status(&xprt->pending, status);
360 rpc_wake_up(&xprt->pending);
371 struct rpc_xprt *xprt = req->rq_xprt;
374 rpc_sleep_on(&xprt->pending, task, NULL, NULL);
379 * @xprt: transport with waiting tasks
383 void xprt_write_space(struct rpc_xprt *xprt)
385 if (unlikely(xprt->shutdown))
388 spin_lock_bh(&xprt->transport_lock);
389 if (xprt->snd_task) {
391 "xprt %p\n", xprt);
392 rpc_wake_up_task(xprt->snd_task);
394 spin_unlock_bh(&xprt->transport_lock);
450 struct rpc_xprt *xprt = req->rq_xprt;
451 struct rpc_timeout *to = &xprt->timeout;
467 spin_lock_bh(&xprt->transport_lock);
469 spin_unlock_bh(&xprt->transport_lock);
482 struct rpc_xprt *xprt =
485 xprt_disconnect(xprt);
486 xprt->ops->close(xprt);
487 xprt_release_write(xprt, NULL);
492 * @xprt: transport to flag for disconnect
495 void xprt_disconnect(struct rpc_xprt *xprt)
497 dprintk("RPC: disconnected transport %p\n", xprt);
498 spin_lock_bh(&xprt->transport_lock);
499 xprt_clear_connected(xprt);
500 xprt_wake_pending_tasks(xprt, -ENOTCONN);
501 spin_unlock_bh(&xprt->transport_lock);
507 struct rpc_xprt *xprt = (struct rpc_xprt *)data;
509 spin_lock(&xprt->transport_lock);
510 if (!list_empty(&xprt->recv) || xprt->shutdown)
512 if (test_and_set_bit(XPRT_LOCKED, &xprt->state))
514 spin_unlock(&xprt->transport_lock);
515 if (xprt_connecting(xprt))
516 xprt_release_write(xprt, NULL);
518 schedule_work(&xprt->task_cleanup);
521 spin_unlock(&xprt->transport_lock);
531 struct rpc_xprt *xprt = task->tk_xprt;
533 dprintk("RPC: %5u xprt_connect xprt %p %s connected\n", task->tk_pid,
534 xprt, (xprt_connected(xprt) ? "is" : "is not"));
536 if (!xprt_bound(xprt)) {
540 if (!xprt_lock_write(xprt, task))
542 if (xprt_connected(xprt))
543 xprt_release_write(xprt, task);
548 task->tk_timeout = xprt->connect_timeout;
549 rpc_sleep_on(&xprt->pending, task, xprt_connect_status, NULL);
550 xprt->stat.connect_start = jiffies;
551 xprt->ops->connect(task);
558 struct rpc_xprt *xprt = task->tk_xprt;
561 xprt->stat.connect_count++;
562 xprt->stat.connect_time += (long)jiffies - xprt->stat.connect_start;
587 xprt_release_write(xprt, task);
594 * @xprt: transport on which the original request was transmitted
598 struct rpc_rqst *xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid)
602 list_for_each(pos, &xprt->recv) {
610 xprt->stat.bad_xids++;
660 struct rpc_xprt *xprt = req->rq_xprt;
664 spin_lock(&xprt->transport_lock);
666 if (xprt->ops->timer)
667 xprt->ops->timer(task);
672 spin_unlock(&xprt->transport_lock);
683 struct rpc_xprt *xprt = req->rq_xprt;
688 spin_lock_bh(&xprt->transport_lock);
693 if (!xprt->ops->reserve_xprt(task)) {
698 if (!xprt_connected(xprt)) {
703 spin_unlock_bh(&xprt->transport_lock);
721 struct rpc_xprt *xprt = req->rq_xprt;
728 spin_lock_bh(&xprt->transport_lock);
733 list_add_tail(&req->rq_list, &xprt->recv);
734 spin_unlock_bh(&xprt->transport_lock);
737 del_singleshot_timer_sync(&xprt->timer);
742 status = xprt->ops->send_request(task);
745 spin_lock_bh(&xprt->transport_lock);
747 xprt->ops->set_retrans_timeout(task);
749 xprt->stat.sends++;
750 xprt->stat.req_u += xprt->stat.sends - xprt->stat.recvs;
751 xprt->stat.bklog_u += xprt->backlog.qlen;
754 if (!xprt_connected(xprt))
757 rpc_sleep_on(&xprt->pending, task, NULL, xprt_timer);
758 spin_unlock_bh(&xprt->transport_lock);
768 rpc_sleep_on(&xprt->sending, task, NULL, NULL);
773 struct rpc_xprt *xprt = task->tk_xprt;
778 if (!list_empty(&xprt->free)) {
779 struct rpc_rqst *req = list_entry(xprt->free.next, struct rpc_rqst, rq_list);
782 xprt_request_init(task, xprt);
788 rpc_sleep_on(&xprt->backlog, task, NULL, NULL);
800 struct rpc_xprt *xprt = task->tk_xprt;
803 spin_lock(&xprt->reserve_lock);
805 spin_unlock(&xprt->reserve_lock);
808 static inline __be32 xprt_alloc_xid(struct rpc_xprt *xprt)
810 return xprt->xid++;
813 static inline void xprt_init_xid(struct rpc_xprt *xprt)
815 xprt->xid = net_random();
818 static void xprt_request_init(struct rpc_task *task, struct rpc_xprt *xprt)
822 req->rq_timeout = xprt->timeout.to_initval;
824 req->rq_xprt = xprt;
826 req->rq_xid = xprt_alloc_xid(xprt);
840 struct rpc_xprt *xprt = task->tk_xprt;
846 spin_lock_bh(&xprt->transport_lock);
847 xprt->ops->release_xprt(xprt, task);
848 if (xprt->ops->release_request)
849 xprt->ops->release_request(task);
852 xprt->last_used = jiffies;
853 if (list_empty(&xprt->recv))
854 mod_timer(&xprt->timer,
855 xprt->last_used + xprt->idle_timeout);
856 spin_unlock_bh(&xprt->transport_lock);
857 xprt->ops->buf_free(req->rq_buffer);
865 spin_lock(&xprt->reserve_lock);
866 list_add(&req->rq_list, &xprt->free);
867 rpc_wake_up_next(&xprt->backlog);
868 spin_unlock(&xprt->reserve_lock);
897 struct rpc_xprt *xprt;
902 xprt = xs_setup_udp(ap, size, to);
905 xprt = xs_setup_tcp(ap, size, to);
912 if (IS_ERR(xprt)) {
914 -PTR_ERR(xprt));
915 return xprt;
918 kref_init(&xprt->kref);
919 spin_lock_init(&xprt->transport_lock);
920 spin_lock_init(&xprt->reserve_lock);
922 INIT_LIST_HEAD(&xprt->free);
923 INIT_LIST_HEAD(&xprt->recv);
924 INIT_WORK(&xprt->task_cleanup, xprt_autoclose);
925 init_timer(&xprt->timer);
926 xprt->timer.function = xprt_init_autodisconnect;
927 xprt->timer.data = (unsigned long) xprt;
928 xprt->last_used = jiffies;
929 xprt->cwnd = RPC_INITCWND;
930 xprt->bind_index = 0;
932 rpc_init_wait_queue(&xprt->binding, "xprt_binding");
933 rpc_init_wait_queue(&xprt->pending, "xprt_pending");
934 rpc_init_wait_queue(&xprt->sending, "xprt_sending");
935 rpc_init_wait_queue(&xprt->resend, "xprt_resend");
936 rpc_init_priority_wait_queue(&xprt->backlog, "xprt_backlog");
939 for (req = &xprt->slot[xprt->max_reqs-1]; req >= &xprt->slot[0]; req--)
940 list_add(&req->rq_list, &xprt->free);
942 xprt_init_xid(xprt);
944 dprintk("RPC: created transport %p with %u slots\n", xprt,
945 xprt->max_reqs);
947 return xprt;
957 struct rpc_xprt *xprt = container_of(kref, struct rpc_xprt, kref);
959 dprintk("RPC: destroying transport %p\n", xprt);
960 xprt->shutdown = 1;
961 del_timer_sync(&xprt->timer);
966 xprt->ops->destroy(xprt);
971 * @xprt: pointer to the transport
974 void xprt_put(struct rpc_xprt *xprt)
976 kref_put(&xprt->kref, xprt_destroy);
981 * @xprt: pointer to the transport
984 struct rpc_xprt *xprt_get(struct rpc_xprt *xprt)
986 kref_get(&xprt->kref);
987 return xprt;