Lines Matching defs:xprt
65 * but it involves locking (master's xprt->xp_thread_lock).
81 * an `xprt-ready' queue and a creator thread (see below). Threads in
120 * If there is none we take a hint from the pool's `xprt-ready' queue.
135 * The `xprt-ready' queue.
138 * this search more efficient each pool has an `xprt-ready' queue.
140 * inserts a pointer to the transport into the `xprt-ready' queue. A
144 * case we try the next hint. The `xprt-ready' queue has fixed size (by
149 * Both the svc_poll() loop and the `xprt-ready' queue are optimized
233 * Size of the `xprt-ready' queue.
264 * A node for the `xprt-ready' queue.
315 #define RELE_PROC(xprt) \
316 ((xprt)->xp_type == T_RDMA ? rdma_rele : \
317 (((xprt)->xp_type == T_CLTS) ? rpc_rele : mir_rele))
325 #define version_keepquiet(xprt) (FALSE)
411 /* Destroy `xprt-ready' queue */
620 /* Allocate and initialize the `xprt-ready' queue */
623 /* Initialize doubly-linked xprt list */
784 svc_xprt_register(SVCMASTERXPRT *xprt, int id)
816 xprt->xp_pool = pool;
823 pool->p_lhead = xprt->xp_prev = xprt->xp_next = xprt;
828 xprt->xp_next = next;
829 xprt->xp_prev = prev;
831 pool->p_lhead = prev->xp_next = next->xp_prev = xprt;
847 svc_xprt_unregister(SVCMASTERXPRT *xprt)
849 SVCPOOL *pool = xprt->xp_pool;
852 * Unlink xprt from the list.
853 * If the list head points to this xprt then move it
854 * to the next xprt or reset to NULL if this is the last
855 * xprt in the list.
859 if (xprt == xprt->xp_next)
862 SVCMASTERXPRT *next = xprt->xp_next;
863 SVCMASTERXPRT *prev = xprt->xp_prev;
868 if (pool->p_lhead == xprt)
872 xprt->xp_next = xprt->xp_prev = NULL;
888 * Initialize an `xprt-ready' queue for a given pool.
912 * - insert a pointer to xprt into the xprt-ready queue (FIFO)
913 * - if the xprt-ready queue is full turn the overflow flag on.
919 svc_xprt_qput(SVCPOOL *pool, SVCMASTERXPRT *xprt)
939 pool->p_qtop->q_xprt = xprt;
946 * `xprt-ready' queue is empty.
956 SVCMASTERXPRT *xprt;
973 xprt = pool->p_qend->q_xprt;
977 } while (xprt == NULL);
980 return (xprt);
985 * is being destroyed from the xprt-ready queue.
989 svc_xprt_qdelete(SVCPOOL *pool, SVCMASTERXPRT *xprt)
995 if (q->q_xprt == xprt)
1008 * a) remove references to this transport from the xprt-ready queue
1016 svc_xprt_cleanup(SVCMASTERXPRT *xprt, bool_t detached)
1018 ASSERT(MUTEX_HELD(&xprt->xp_thread_lock));
1019 ASSERT(xprt->xp_wq == NULL);
1025 if (!detached && xprt->xp_threads == 0 && xprt->xp_closeproc) {
1026 (*(xprt->xp_closeproc)) (xprt);
1029 if (xprt->xp_threads + xprt->xp_detached_threads > 0)
1030 mutex_exit(&xprt->xp_thread_lock);
1032 /* Remove references to xprt from the `xprt-ready' queue */
1033 svc_xprt_qdelete(xprt->xp_pool, xprt);
1035 /* Unregister xprt from the pool's transport list */
1036 svc_xprt_unregister(xprt);
1037 svc_callout_free(xprt);
1038 SVC_DESTROY(xprt);
1053 svc_callout_find(SVCXPRT *xprt, rpcprog_t prog, rpcvers_t vers,
1056 SVC_CALLOUT_TABLE *sct = xprt->xp_sct;
1084 svc_callout_free(SVCMASTERXPRT *xprt)
1086 SVC_CALLOUT_TABLE *sct = xprt->xp_sct;
1277 * Note: the xprt's xp_svc_lock is not held while the service's dispatch
1467 svc_clone_link(SVCMASTERXPRT *xprt, SVCXPRT *clone_xprt, SVCXPRT *clone_xprt2)
1478 mutex_enter(&xprt->xp_thread_lock);
1479 xprt->xp_threads++;
1480 mutex_exit(&xprt->xp_thread_lock);
1486 clone_xprt->xp_master = xprt;
1489 clone_xprt->xp_xpc = xprt->xp_xpc;
1510 SVCMASTERXPRT *xprt = clone_xprt->xp_master;
1514 ASSERT(xprt->xp_threads > 0);
1517 mutex_enter(&xprt->xp_thread_lock);
1518 xprt->xp_threads--;
1520 /* svc_xprt_cleanup() unlocks xp_thread_lock or destroys xprt */
1521 if (xprt->xp_wq)
1522 mutex_exit(&xprt->xp_thread_lock);
1524 svc_xprt_cleanup(xprt, FALSE);
1545 SVCMASTERXPRT *xprt = clone_xprt->xp_master;
1549 ASSERT(xprt->xp_detached_threads > 0);
1550 ASSERT(xprt->xp_threads + xprt->xp_detached_threads > 0);
1552 /* Grab xprt->xp_thread_lock and decrement link counts */
1553 mutex_enter(&xprt->xp_thread_lock);
1554 xprt->xp_detached_threads--;
1556 /* svc_xprt_cleanup() unlocks xp_thread_lock or destroys xprt */
1557 if (xprt->xp_wq)
1558 mutex_exit(&xprt->xp_thread_lock);
1560 svc_xprt_cleanup(xprt, TRUE);
1840 svc_poll(SVCPOOL *pool, SVCMASTERXPRT *xprt, SVCXPRT *clone_xprt)
1866 * and then take a hint from the xprt-ready queue or walk
1869 if (xprt && xprt->xp_req_head && (!pool->p_qoverflow ||
1871 mutex_enter(&xprt->xp_req_lock);
1872 if (xprt->xp_req_head)
1873 return (xprt);
1874 mutex_exit(&xprt->xp_req_lock);
1897 * Get the next transport from the xprt-ready queue.
1924 * If there was no hint in the xprt-ready queue then
1928 * xprt-ready queue; if so, then we need to break
1945 * If there was an overflow in the xprt-ready queue then we
1950 * switch svc_poll() back to taking hints from the xprt-ready
1955 if (xprt == NULL && pool->p_lhead == NULL) {
1965 next = xprt ? xprt->xp_next : pool->p_lhead;
2061 if (xprt && xprt->xp_wq == NULL)
2091 * On input the xprt->xp_full determines whether the flow control is currently
2156 svc_flowcontrol(SVCMASTERXPRT *xprt)
2158 SVCPOOL *pool = xprt->xp_pool;
2162 ASSERT(MUTEX_HELD(&xprt->xp_req_lock));
2165 if (xprt->xp_full == FALSE) {
2171 if (xprt->xp_reqs >= enough_reqs * 2) {
2172 xprt->xp_full = TRUE;
2181 xprt->xp_size >= totalmem / 5 / pool->p_lcount)
2182 xprt->xp_full = TRUE;
2190 if (xprt->xp_reqs > enough_reqs)
2198 xprt->xp_size >= totalmem / 5 / pool->p_lcount / 2)
2202 xprt->xp_full = FALSE;
2203 xprt->xp_enable = TRUE;
2218 SVCMASTERXPRT *xprt = NULL; /* master transport handle */
2248 next = svc_poll(pool, xprt, clone_xprt);
2265 xprt = NULL;
2317 if (next != xprt) {
2318 if (xprt)
2321 xprt = next;
2385 mutex_enter(&xprt->xp_req_lock);
2386 enable = xprt->xp_enable;
2388 xprt->xp_enable = FALSE;
2389 mutex_exit(&xprt->xp_req_lock);
2390 (*RELE_PROC(xprt)) (clone_xprt->xp_wq, NULL, enable);
2402 SVCMASTERXPRT *xprt = ((void **) q->q_ptr)[0];
2409 mutex_enter(&xprt->xp_req_lock);
2410 pool = xprt->xp_pool;
2411 while ((mp = xprt->xp_req_head) != NULL) {
2413 xprt->xp_req_head = mp->b_next;
2415 (*RELE_PROC(xprt)) (xprt->xp_wq, mp, FALSE);
2419 pool->p_reqs -= xprt->xp_reqs;
2420 pool->p_size -= xprt->xp_size;
2423 xprt->xp_reqs = 0;
2424 xprt->xp_size = 0;
2425 xprt->xp_full = FALSE;
2426 xprt->xp_enable = FALSE;
2427 mutex_exit(&xprt->xp_req_lock);
2445 SVCMASTERXPRT *xprt = ((void **) q->q_ptr)[0];
2447 if (xprt == NULL) {
2449 * If there is no master xprt associated with this stream,
2457 mutex_enter(&xprt->xp_thread_lock);
2459 ASSERT(xprt->xp_req_head == NULL);
2460 ASSERT(xprt->xp_wq != NULL);
2462 xprt->xp_wq = NULL;
2464 if (xprt->xp_threads == 0) {
2465 SVCPOOL *pool = xprt->xp_pool;
2471 svc_xprt_cleanup(xprt, FALSE);
2502 mutex_exit(&xprt->xp_thread_lock);
2509 * - insert a hint for svc_poll() into the xprt-ready queue
2518 SVCMASTERXPRT *xprt = ((void **) q->q_ptr)[0];
2519 SVCPOOL *pool = xprt->xp_pool;
2533 * the xprt ready queue and increment the
2536 mutex_enter(&xprt->xp_req_lock);
2537 if (flowcontrol && xprt->xp_full) {
2538 mutex_exit(&xprt->xp_req_lock);
2542 ASSERT(xprt->xp_full == FALSE);
2544 if (xprt->xp_req_head == NULL)
2545 xprt->xp_req_head = mp;
2547 xprt->xp_req_tail->b_next = mp;
2548 xprt->xp_req_tail = mp;
2552 * Insert a hint into the xprt-ready queue, increment
2557 /* Insert pointer to this transport into the xprt-ready queue */
2558 svc_xprt_qput(pool, xprt);
2562 xprt->xp_reqs++;
2565 xprt->xp_size += size;
2570 svc_flowcontrol(xprt);
2596 mutex_exit(&xprt->xp_req_lock);
2705 SVCMASTERXPRT *xprt = clone_xprt->xp_master;
2706 SVCPOOL *pool = xprt->xp_pool;
2714 mutex_enter(&xprt->xp_thread_lock);
2715 xprt->xp_threads--;
2716 xprt->xp_detached_threads++;
2717 mutex_exit(&xprt->xp_thread_lock);
2727 mutex_enter(&xprt->xp_req_lock);
2728 enable = xprt->xp_enable;
2730 xprt->xp_enable = FALSE;
2731 mutex_exit(&xprt->xp_req_lock);
2732 (*RELE_PROC(xprt)) (clone_xprt->xp_wq, NULL, enable);
2748 * to cleanup the pool and destroy the xprt in svc_queueclose()
2753 SVCMASTERXPRT *xprt;
2770 xprt = curr_rec->rtr_xprt_ptr;
2771 q = xprt->xp_wq;
2772 svc_rdma_kstop(xprt);
2774 mutex_enter(&xprt->xp_req_lock);
2775 pool = xprt->xp_pool;
2776 while ((mp = xprt->xp_req_head) != NULL) {
2780 xprt->xp_req_head = mp->b_next;
2788 pool->p_reqs -= xprt->xp_reqs;
2789 pool->p_size -= xprt->xp_size;
2791 xprt->xp_reqs = 0;
2792 xprt->xp_size = 0;
2793 xprt->xp_full = FALSE;
2794 xprt->xp_enable = FALSE;
2795 mutex_exit(&xprt->xp_req_lock);