Lines Matching defs:xprt
2 * linux/net/sunrpc/xprt.c
86 #define RPC_MAXCWND(xprt) ((xprt)->max_reqs << RPC_CWNDSHIFT)
88 #define RPCXPRT_CONGESTED(xprt) ((xprt)->cong >= (xprt)->cwnd)
180 result = request_module("xprt%s", transport_name);
197 struct rpc_xprt *xprt = req->rq_xprt;
199 if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) {
200 if (task == xprt->snd_task)
206 xprt->snd_task = task;
215 task->tk_pid, xprt);
219 rpc_sleep_on(&xprt->resend, task, NULL);
221 rpc_sleep_on(&xprt->sending, task, NULL);
226 static void xprt_clear_locked(struct rpc_xprt *xprt)
228 xprt->snd_task = NULL;
229 if (!test_bit(XPRT_CLOSE_WAIT, &xprt->state) || xprt->shutdown) {
231 clear_bit(XPRT_LOCKED, &xprt->state);
234 queue_work(rpciod_workqueue, &xprt->task_cleanup);
247 struct rpc_xprt *xprt = task->tk_xprt;
250 if (test_and_set_bit(XPRT_LOCKED, &xprt->state)) {
251 if (task == xprt->snd_task)
255 if (__xprt_get_cong(xprt, task)) {
256 xprt->snd_task = task;
263 xprt_clear_locked(xprt);
265 dprintk("RPC: %5u failed to lock transport %p\n", task->tk_pid, xprt);
269 rpc_sleep_on(&xprt->resend, task, NULL);
271 rpc_sleep_on(&xprt->sending, task, NULL);
276 static inline int xprt_lock_write(struct rpc_xprt *xprt, struct rpc_task *task)
280 spin_lock_bh(&xprt->transport_lock);
281 retval = xprt->ops->reserve_xprt(task);
282 spin_unlock_bh(&xprt->transport_lock);
286 static void __xprt_lock_write_next(struct rpc_xprt *xprt)
291 if (test_and_set_bit(XPRT_LOCKED, &xprt->state))
294 task = rpc_wake_up_next(&xprt->resend);
296 task = rpc_wake_up_next(&xprt->sending);
302 xprt->snd_task = task;
310 xprt_clear_locked(xprt);
313 static void __xprt_lock_write_next_cong(struct rpc_xprt *xprt)
317 if (test_and_set_bit(XPRT_LOCKED, &xprt->state))
319 if (RPCXPRT_CONGESTED(xprt))
321 task = rpc_wake_up_next(&xprt->resend);
323 task = rpc_wake_up_next(&xprt->sending);
327 if (__xprt_get_cong(xprt, task)) {
329 xprt->snd_task = task;
337 xprt_clear_locked(xprt);
342 * @xprt: transport with other tasks potentially waiting
347 void xprt_release_xprt(struct rpc_xprt *xprt, struct rpc_task *task)
349 if (xprt->snd_task == task) {
350 xprt_clear_locked(xprt);
351 __xprt_lock_write_next(xprt);
358 * @xprt: transport with other tasks potentially waiting
364 void xprt_release_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task)
366 if (xprt->snd_task == task) {
367 xprt_clear_locked(xprt);
368 __xprt_lock_write_next_cong(xprt);
373 static inline void xprt_release_write(struct rpc_xprt *xprt, struct rpc_task *task)
375 spin_lock_bh(&xprt->transport_lock);
376 xprt->ops->release_xprt(xprt, task);
377 spin_unlock_bh(&xprt->transport_lock);
385 __xprt_get_cong(struct rpc_xprt *xprt, struct rpc_task *task)
392 task->tk_pid, xprt->cong, xprt->cwnd);
393 if (RPCXPRT_CONGESTED(xprt))
396 xprt->cong += RPC_CWNDSCALE;
405 __xprt_put_cong(struct rpc_xprt *xprt, struct rpc_rqst *req)
410 xprt->cong -= RPC_CWNDSCALE;
411 __xprt_lock_write_next_cong(xprt);
436 struct rpc_xprt *xprt = task->tk_xprt;
437 unsigned long cwnd = xprt->cwnd;
439 if (result >= 0 && cwnd <= xprt->cong) {
443 if (cwnd > RPC_MAXCWND(xprt))
444 cwnd = RPC_MAXCWND(xprt);
445 __xprt_lock_write_next_cong(xprt);
452 xprt->cong, xprt->cwnd, cwnd);
453 xprt->cwnd = cwnd;
454 __xprt_put_cong(xprt, req);
460 * @xprt: transport with waiting tasks
464 void xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status)
467 rpc_wake_up_status(&xprt->pending, status);
469 rpc_wake_up(&xprt->pending);
481 struct rpc_xprt *xprt = req->rq_xprt;
484 rpc_sleep_on(&xprt->pending, task, action);
490 * @xprt: transport with waiting tasks
494 void xprt_write_space(struct rpc_xprt *xprt)
496 if (unlikely(xprt->shutdown))
499 spin_lock_bh(&xprt->transport_lock);
500 if (xprt->snd_task) {
502 "xprt %p\n", xprt);
503 rpc_wake_up_queued_task(&xprt->pending, xprt->snd_task);
505 spin_unlock_bh(&xprt->transport_lock);
565 struct rpc_xprt *xprt = req->rq_xprt;
582 spin_lock_bh(&xprt->transport_lock);
584 spin_unlock_bh(&xprt->transport_lock);
597 struct rpc_xprt *xprt =
600 xprt->ops->close(xprt);
601 clear_bit(XPRT_CLOSE_WAIT, &xprt->state);
602 xprt_release_write(xprt, NULL);
607 * @xprt: transport to flag for disconnect
610 void xprt_disconnect_done(struct rpc_xprt *xprt)
612 dprintk("RPC: disconnected transport %p\n", xprt);
613 spin_lock_bh(&xprt->transport_lock);
614 xprt_clear_connected(xprt);
615 xprt_wake_pending_tasks(xprt, -EAGAIN);
616 spin_unlock_bh(&xprt->transport_lock);
622 * @xprt: transport to disconnect
625 void xprt_force_disconnect(struct rpc_xprt *xprt)
628 spin_lock_bh(&xprt->transport_lock);
629 set_bit(XPRT_CLOSE_WAIT, &xprt->state);
631 if (test_and_set_bit(XPRT_LOCKED, &xprt->state) == 0)
632 queue_work(rpciod_workqueue, &xprt->task_cleanup);
633 xprt_wake_pending_tasks(xprt, -EAGAIN);
634 spin_unlock_bh(&xprt->transport_lock);
639 * @xprt: transport to disconnect
648 void xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie)
651 spin_lock_bh(&xprt->transport_lock);
652 if (cookie != xprt->connect_cookie)
654 if (test_bit(XPRT_CLOSING, &xprt->state) || !xprt_connected(xprt))
656 set_bit(XPRT_CLOSE_WAIT, &xprt->state);
658 if (test_and_set_bit(XPRT_LOCKED, &xprt->state) == 0)
659 queue_work(rpciod_workqueue, &xprt->task_cleanup);
660 xprt_wake_pending_tasks(xprt, -EAGAIN);
662 spin_unlock_bh(&xprt->transport_lock);
668 struct rpc_xprt *xprt = (struct rpc_xprt *)data;
670 spin_lock(&xprt->transport_lock);
671 if (!list_empty(&xprt->recv) || xprt->shutdown)
673 if (test_and_set_bit(XPRT_LOCKED, &xprt->state))
675 spin_unlock(&xprt->transport_lock);
676 set_bit(XPRT_CONNECTION_CLOSE, &xprt->state);
677 queue_work(rpciod_workqueue, &xprt->task_cleanup);
680 spin_unlock(&xprt->transport_lock);
690 struct rpc_xprt *xprt = task->tk_xprt;
692 dprintk("RPC: %5u xprt_connect xprt %p %s connected\n", task->tk_pid,
693 xprt, (xprt_connected(xprt) ? "is" : "is not"));
695 if (!xprt_bound(xprt)) {
699 if (!xprt_lock_write(xprt, task))
702 if (test_and_clear_bit(XPRT_CLOSE_WAIT, &xprt->state))
703 xprt->ops->close(xprt);
705 if (xprt_connected(xprt))
706 xprt_release_write(xprt, task);
712 rpc_sleep_on(&xprt->pending, task, xprt_connect_status);
714 if (test_bit(XPRT_CLOSING, &xprt->state))
716 if (xprt_test_and_set_connecting(xprt))
718 xprt->stat.connect_start = jiffies;
719 xprt->ops->connect(task);
725 struct rpc_xprt *xprt = task->tk_xprt;
728 xprt->stat.connect_count++;
729 xprt->stat.connect_time += (long)jiffies - xprt->stat.connect_start;
747 xprt_release_write(xprt, task);
754 * @xprt: transport on which the original request was transmitted
758 struct rpc_rqst *xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid)
762 list_for_each(pos, &xprt->recv) {
770 xprt->stat.bad_xids++;
799 struct rpc_xprt *xprt = req->rq_xprt;
804 xprt->stat.recvs++;
806 if (xprt->ops->timer != NULL)
815 rpc_wake_up_queued_task(&xprt->pending, task);
822 struct rpc_xprt *xprt = req->rq_xprt;
828 spin_lock_bh(&xprt->transport_lock);
830 if (xprt->ops->timer)
831 xprt->ops->timer(task);
834 spin_unlock_bh(&xprt->transport_lock);
837 static inline int xprt_has_timer(struct rpc_xprt *xprt)
839 return xprt->idle_timeout != 0;
850 struct rpc_xprt *xprt = req->rq_xprt;
855 spin_lock_bh(&xprt->transport_lock);
860 if (!xprt->ops->reserve_xprt(task))
863 spin_unlock_bh(&xprt->transport_lock);
881 struct rpc_xprt *xprt = req->rq_xprt;
891 spin_lock_bh(&xprt->transport_lock);
896 list_add_tail(&req->rq_list, &xprt->recv);
897 spin_unlock_bh(&xprt->transport_lock);
900 del_singleshot_timer_sync(&xprt->timer);
905 req->rq_connect_cookie = xprt->connect_cookie;
907 status = xprt->ops->send_request(task);
914 spin_lock_bh(&xprt->transport_lock);
916 xprt->ops->set_retrans_timeout(task);
918 xprt->stat.sends++;
919 xprt->stat.req_u += xprt->stat.sends - xprt->stat.recvs;
920 xprt->stat.bklog_u += xprt->backlog.qlen;
923 if (!xprt_connected(xprt))
930 rpc_sleep_on(&xprt->pending, task, xprt_timer);
932 spin_unlock_bh(&xprt->transport_lock);
937 struct rpc_xprt *xprt = task->tk_xprt;
942 if (!list_empty(&xprt->free)) {
943 struct rpc_rqst *req = list_entry(xprt->free.next, struct rpc_rqst, rq_list);
946 xprt_request_init(task, xprt);
952 rpc_sleep_on(&xprt->backlog, task, NULL);
955 static void xprt_free_slot(struct rpc_xprt *xprt, struct rpc_rqst *req)
959 spin_lock(&xprt->reserve_lock);
960 list_add(&req->rq_list, &xprt->free);
961 rpc_wake_up_next(&xprt->backlog);
962 spin_unlock(&xprt->reserve_lock);
974 struct rpc_xprt *xprt = task->tk_xprt;
977 spin_lock(&xprt->reserve_lock);
979 spin_unlock(&xprt->reserve_lock);
982 static inline __be32 xprt_alloc_xid(struct rpc_xprt *xprt)
984 return (__force __be32)xprt->xid++;
987 static inline void xprt_init_xid(struct rpc_xprt *xprt)
989 xprt->xid = net_random();
992 static void xprt_request_init(struct rpc_task *task, struct rpc_xprt *xprt)
998 req->rq_xprt = xprt;
1000 req->rq_xid = xprt_alloc_xid(xprt);
1014 struct rpc_xprt *xprt;
1020 xprt = req->rq_xprt;
1022 spin_lock_bh(&xprt->transport_lock);
1023 xprt->ops->release_xprt(xprt, task);
1024 if (xprt->ops->release_request)
1025 xprt->ops->release_request(task);
1028 xprt->last_used = jiffies;
1029 if (list_empty(&xprt->recv) && xprt_has_timer(xprt))
1030 mod_timer(&xprt->timer,
1031 xprt->last_used + xprt->idle_timeout);
1032 spin_unlock_bh(&xprt->transport_lock);
1034 xprt->ops->buf_free(req->rq_buffer);
1043 xprt_free_slot(xprt, req);
1055 struct rpc_xprt *xprt;
1071 xprt = t->setup(args);
1072 if (IS_ERR(xprt)) {
1074 -PTR_ERR(xprt));
1075 return xprt;
1078 kref_init(&xprt->kref);
1079 spin_lock_init(&xprt->transport_lock);
1080 spin_lock_init(&xprt->reserve_lock);
1082 INIT_LIST_HEAD(&xprt->free);
1083 INIT_LIST_HEAD(&xprt->recv);
1085 spin_lock_init(&xprt->bc_pa_lock);
1086 INIT_LIST_HEAD(&xprt->bc_pa_list);
1089 INIT_WORK(&xprt->task_cleanup, xprt_autoclose);
1090 if (xprt_has_timer(xprt))
1091 setup_timer(&xprt->timer, xprt_init_autodisconnect,
1092 (unsigned long)xprt);
1094 init_timer(&xprt->timer);
1095 xprt->last_used = jiffies;
1096 xprt->cwnd = RPC_INITCWND;
1097 xprt->bind_index = 0;
1099 rpc_init_wait_queue(&xprt->binding, "xprt_binding");
1100 rpc_init_wait_queue(&xprt->pending, "xprt_pending");
1101 rpc_init_wait_queue(&xprt->sending, "xprt_sending");
1102 rpc_init_wait_queue(&xprt->resend, "xprt_resend");
1103 rpc_init_priority_wait_queue(&xprt->backlog, "xprt_backlog");
1106 for (req = &xprt->slot[xprt->max_reqs-1]; req >= &xprt->slot[0]; req--)
1107 list_add(&req->rq_list, &xprt->free);
1109 xprt_init_xid(xprt);
1111 dprintk("RPC: created transport %p with %u slots\n", xprt,
1112 xprt->max_reqs);
1113 return xprt;
1123 struct rpc_xprt *xprt = container_of(kref, struct rpc_xprt, kref);
1125 dprintk("RPC: destroying transport %p\n", xprt);
1126 xprt->shutdown = 1;
1127 del_timer_sync(&xprt->timer);
1129 rpc_destroy_wait_queue(&xprt->binding);
1130 rpc_destroy_wait_queue(&xprt->pending);
1131 rpc_destroy_wait_queue(&xprt->sending);
1132 rpc_destroy_wait_queue(&xprt->resend);
1133 rpc_destroy_wait_queue(&xprt->backlog);
1134 cancel_work_sync(&xprt->task_cleanup);
1138 xprt->ops->destroy(xprt);
1143 * @xprt: pointer to the transport
1146 void xprt_put(struct rpc_xprt *xprt)
1148 kref_put(&xprt->kref, xprt_destroy);
1153 * @xprt: pointer to the transport
1156 struct rpc_xprt *xprt_get(struct rpc_xprt *xprt)
1158 kref_get(&xprt->kref);
1159 return xprt;