Lines Matching refs:ct
134 struct ct_data *ct = NULL; /* client handle */
147 ct = (struct ct_data *)mem_alloc(sizeof (*ct));
149 mtx_init(&ct->ct_lock, "ct->ct_lock", NULL, MTX_DEF);
150 ct->ct_threads = 0;
151 ct->ct_closing = FALSE;
152 ct->ct_closed = FALSE;
153 ct->ct_upcallrefs = 0;
154 ct->ct_rcvstate = RPCRCVSTATE_NORMAL;
211 ct->ct_closeit = FALSE;
216 ct->ct_socket = so;
217 ct->ct_wait.tv_sec = -1;
218 ct->ct_wait.tv_usec = -1;
219 memcpy(&ct->ct_addr, raddr, raddr->sa_len);
225 ct->ct_xid = ((uint32_t)++disrupt) ^ __RPC_GETXID(&now);
226 call_msg.rm_xid = ct->ct_xid;
235 xdrmem_create(&xdrs, ct->ct_mcallc, MCALL_MSG_SIZE,
238 if (ct->ct_closeit) {
239 soclose(ct->ct_socket);
243 ct->ct_mpos = XDR_GETPOS(&xdrs);
245 ct->ct_waitchan = "rpcrecv";
246 ct->ct_waitflag = 0;
254 error = soreserve(ct->ct_socket, sendsz, recvsz);
256 if (ct->ct_closeit) {
257 soclose(ct->ct_socket);
263 cl->cl_private = ct;
266 SOCK_RECVBUF_LOCK(ct->ct_socket);
267 soupcall_set(ct->ct_socket, SO_RCV, clnt_vc_soupcall, ct);
268 SOCK_RECVBUF_UNLOCK(ct->ct_socket);
270 ct->ct_raw = NULL;
271 ct->ct_record = NULL;
272 ct->ct_record_resid = 0;
273 ct->ct_sslrefno = 0;
274 TAILQ_INIT(&ct->ct_pending);
278 mtx_destroy(&ct->ct_lock);
279 mem_free(ct, sizeof (struct ct_data));
294 struct ct_data *ct = (struct ct_data *) cl->cl_private;
313 mtx_lock(&ct->ct_lock);
315 if (ct->ct_closing || ct->ct_closed) {
316 mtx_unlock(&ct->ct_lock);
320 ct->ct_threads++;
327 errp = &ct->ct_error;
333 if (ct->ct_wait.tv_usec == -1) {
336 timeout = ct->ct_wait; /* use default timeout */
345 mtx_assert(&ct->ct_lock, MA_OWNED);
346 if (ct->ct_closing || ct->ct_closed) {
347 ct->ct_threads--;
348 wakeup(ct);
349 mtx_unlock(&ct->ct_lock);
354 ct->ct_xid++;
355 xid = ct->ct_xid;
357 mtx_unlock(&ct->ct_lock);
364 KASSERT(ct->ct_mpos + sizeof(uint32_t) <= MHLEN,
366 bcopy(ct->ct_mcallc, mreq->m_data, ct->ct_mpos);
367 mreq->m_len = ct->ct_mpos;
382 mtx_lock(&ct->ct_lock);
395 mtx_lock(&ct->ct_lock);
404 if (ct->ct_error.re_status == RPC_CANTRECV) {
405 if (errp != &ct->ct_error) {
406 errp->re_errno = ct->ct_error.re_errno;
414 while ((ct->ct_rcvstate & (RPCRCVSTATE_NORMAL |
416 msleep(&ct->ct_rcvstate, &ct->ct_lock, 0, "rpcrcvst", hz);
418 TAILQ_INSERT_TAIL(&ct->ct_pending, cr, cr_link);
419 mtx_unlock(&ct->ct_lock);
421 if (ct->ct_sslrefno != 0) {
436 error = sosend(ct->ct_socket, NULL, NULL, mreq, NULL, 0, curthread);
439 (ct->ct_waitflag & PCATCH) == 0 && trycnt-- > 0)) {
440 SOCK_SENDBUF_LOCK(ct->ct_socket);
441 sbwait(ct->ct_socket, SO_SND);
442 SOCK_SENDBUF_UNLOCK(ct->ct_socket);
444 mtx_lock(&ct->ct_lock);
445 TAILQ_REMOVE(&ct->ct_pending, cr, cr_link);
447 mtx_unlock(&ct->ct_lock);
449 mtx_lock(&ct->ct_lock);
459 mtx_lock(&ct->ct_lock);
461 TAILQ_REMOVE(&ct->ct_pending, cr, cr_link);
470 * from ct->ct_pending.
473 TAILQ_REMOVE(&ct->ct_pending, cr, cr_link);
479 TAILQ_REMOVE(&ct->ct_pending, cr, cr_link);
487 TAILQ_REMOVE(&ct->ct_pending, cr, cr_link);
492 error = msleep(cr, &ct->ct_lock, ct->ct_waitflag, ct->ct_waitchan,
495 TAILQ_REMOVE(&ct->ct_pending, cr, cr_link);
534 mtx_unlock(&ct->ct_lock);
573 mtx_lock(&ct->ct_lock);
582 mtx_lock(&ct->ct_lock);
584 mtx_assert(&ct->ct_lock, MA_OWNED);
594 ct->ct_threads--;
595 if (ct->ct_closing)
596 wakeup(ct);
598 mtx_unlock(&ct->ct_lock);
611 struct ct_data *ct = (struct ct_data *) cl->cl_private;
613 *errp = ct->ct_error;
637 struct ct_data *ct = (struct ct_data *)cl->cl_private;
644 mtx_lock(&ct->ct_lock);
648 ct->ct_closeit = TRUE;
649 mtx_unlock(&ct->ct_lock);
652 ct->ct_closeit = FALSE;
653 mtx_unlock(&ct->ct_lock);
661 mtx_unlock(&ct->ct_lock);
667 mtx_unlock(&ct->ct_lock);
670 ct->ct_wait = *(struct timeval *)infop;
673 *(struct timeval *)infop = ct->ct_wait;
676 (void) memcpy(info, &ct->ct_addr, (size_t)ct->ct_addr.ss_len);
683 memcpy(info, &ct->ct_addr, ct->ct_addr.ss_len);
686 mtx_unlock(&ct->ct_lock);
689 *(uint32_t *)info = ct->ct_xid;
694 ct->ct_xid = *(uint32_t *)info - 1;
704 ntohl(*(uint32_t *)(void *)(ct->ct_mcallc +
709 *(uint32_t *)(void *)(ct->ct_mcallc +
722 ntohl(*(uint32_t *)(void *)(ct->ct_mcallc +
727 *(uint32_t *)(void *)(ct->ct_mcallc +
733 ct->ct_waitchan = (const char *)info;
737 *(const char **) info = ct->ct_waitchan;
742 ct->ct_waitflag = PCATCH;
744 ct->ct_waitflag = 0;
748 if (ct->ct_waitflag)
756 if (ct->ct_backchannelxprt == NULL) {
758 xprt->xp_p2 = ct;
759 if (ct->ct_sslrefno != 0)
761 ct->ct_backchannelxprt = xprt;
767 ct->ct_sslsec = *p++;
768 ct->ct_sslusec = *p++;
769 ct->ct_sslrefno = *p;
770 if (ct->ct_sslrefno != RPCTLS_REFNO_HANDSHAKE) {
773 mtx_unlock(&ct->ct_lock);
780 mtx_unlock(&ct->ct_lock);
785 ct->ct_rcvstate &= ~RPCRCVSTATE_NORMAL;
786 ct->ct_rcvstate |= RPCRCVSTATE_TLSHANDSHAKE;
788 ct->ct_rcvstate &= ~RPCRCVSTATE_TLSHANDSHAKE;
789 ct->ct_rcvstate |= RPCRCVSTATE_NORMAL;
794 mtx_unlock(&ct->ct_lock);
798 mtx_unlock(&ct->ct_lock);
805 struct ct_data *ct = (struct ct_data *) cl->cl_private;
808 mtx_lock(&ct->ct_lock);
810 if (ct->ct_closed) {
811 mtx_unlock(&ct->ct_lock);
815 if (ct->ct_closing) {
816 while (ct->ct_closing)
817 msleep(ct, &ct->ct_lock, 0, "rpcclose", 0);
818 KASSERT(ct->ct_closed, ("client should be closed"));
819 mtx_unlock(&ct->ct_lock);
823 if (ct->ct_socket) {
824 ct->ct_closing = TRUE;
825 mtx_unlock(&ct->ct_lock);
827 SOCK_RECVBUF_LOCK(ct->ct_socket);
828 if (ct->ct_socket->so_rcv.sb_upcall != NULL) {
829 soupcall_clear(ct->ct_socket, SO_RCV);
830 clnt_vc_upcallsdone(ct);
832 SOCK_RECVBUF_UNLOCK(ct->ct_socket);
838 mtx_lock(&ct->ct_lock);
839 TAILQ_FOREACH(cr, &ct->ct_pending, cr_link) {
845 while (ct->ct_threads)
846 msleep(ct, &ct->ct_lock, 0, "rpcclose", 0);
849 ct->ct_closing = FALSE;
850 ct->ct_closed = TRUE;
851 wakeup(&ct->ct_sslrefno);
852 mtx_unlock(&ct->ct_lock);
853 wakeup(ct);
859 struct ct_data *ct = (struct ct_data *) cl->cl_private;
866 mtx_lock(&ct->ct_lock);
867 xprt = ct->ct_backchannelxprt;
868 ct->ct_backchannelxprt = NULL;
870 mtx_unlock(&ct->ct_lock); /* To avoid a LOR. */
872 mtx_lock(&ct->ct_lock);
878 if (ct->ct_socket) {
879 if (ct->ct_closeit) {
880 so = ct->ct_socket;
885 while ((ct->ct_rcvstate & RPCRCVSTATE_UPCALLTHREAD) != 0)
886 msleep(&ct->ct_sslrefno, &ct->ct_lock, 0,
888 mtx_unlock(&ct->ct_lock);
890 mtx_destroy(&ct->ct_lock);
892 if (ct->ct_sslrefno != 0) {
898 if (ct->ct_sslrefno != RPCTLS_REFNO_HANDSHAKE) {
905 rpctls_cl_disconnect(ct->ct_sslsec,
906 ct->ct_sslusec, ct->ct_sslrefno,
918 m_freem(ct->ct_record);
919 m_freem(ct->ct_raw);
920 mem_free(ct, sizeof(struct ct_data));
942 struct ct_data *ct = (struct ct_data *) arg;
959 mtx_lock(&ct->ct_lock);
960 if ((ct->ct_rcvstate & (RPCRCVSTATE_NORMAL |
963 if ((ct->ct_rcvstate & (RPCRCVSTATE_UPCALLNEEDED |
965 ct->ct_rcvstate |= RPCRCVSTATE_SOUPCALLNEEDED;
966 mtx_unlock(&ct->ct_lock);
969 mtx_unlock(&ct->ct_lock);
978 if (ct->ct_upcallrefs > 0)
980 ct->ct_upcallrefs++;
991 if (ct->ct_sslrefno != 0 && (ct->ct_rcvstate &
1026 if (ct->ct_sslrefno != 0 && error == ENXIO) {
1028 mtx_lock(&ct->ct_lock);
1029 ct->ct_rcvstate |= RPCRCVSTATE_UPCALLNEEDED;
1034 wakeup(&ct->ct_sslrefno);
1035 mtx_unlock(&ct->ct_lock);
1056 mtx_lock(&ct->ct_lock);
1057 ct->ct_rcvstate &=
1059 ct->ct_rcvstate |= RPCRCVSTATE_NORMAL;
1060 mtx_unlock(&ct->ct_lock);
1067 if (ct->ct_raw != NULL)
1068 m_last(ct->ct_raw)->m_next = m;
1070 ct->ct_raw = m;
1072 rawlen = m_length(ct->ct_raw, NULL);
1080 if (ct->ct_record_resid == 0) {
1083 m_copydata(ct->ct_raw, 0, sizeof(uint32_t),
1086 ct->ct_record_resid = header & 0x7fffffff;
1087 ct->ct_record_eor = ((header & 0x80000000) != 0);
1088 m_adj(ct->ct_raw, sizeof(uint32_t));
1097 if (rawlen <= ct->ct_record_resid) {
1098 if (ct->ct_record != NULL)
1099 m_last(ct->ct_record)->m_next =
1100 ct->ct_raw;
1102 ct->ct_record = ct->ct_raw;
1103 ct->ct_raw = NULL;
1104 ct->ct_record_resid -= rawlen;
1107 m = m_split(ct->ct_raw, ct->ct_record_resid,
1111 if (ct->ct_record != NULL)
1112 m_last(ct->ct_record)->m_next =
1113 ct->ct_raw;
1115 ct->ct_record = ct->ct_raw;
1116 rawlen -= ct->ct_record_resid;
1117 ct->ct_record_resid = 0;
1118 ct->ct_raw = m;
1120 if (ct->ct_record_resid > 0)
1127 if (ct->ct_record_eor) {
1133 if (ct->ct_record->m_len <
1135 m_length(ct->ct_record, NULL) <
1152 m_copydata(ct->ct_record, 0,
1162 mtx_lock(&ct->ct_lock);
1163 xprt = ct->ct_backchannelxprt;
1165 mtx_unlock(&ct->ct_lock);
1167 m_freem(ct->ct_record);
1168 ct->ct_record = NULL;
1183 ct->ct_record;
1186 ct->ct_record;
1187 ct->ct_record->m_nextpkt =
1189 ct->ct_record = NULL;
1191 mtx_unlock(&ct->ct_lock);
1194 mtx_lock(&ct->ct_lock);
1196 TAILQ_FOREACH(cr, &ct->ct_pending,
1212 ct->ct_record;
1219 mtx_unlock(&ct->ct_lock);
1222 m_freem(ct->ct_record);
1223 ct->ct_record = NULL;
1237 mtx_lock(&ct->ct_lock);
1238 ct->ct_error.re_status = RPC_CANTRECV;
1239 ct->ct_error.re_errno = error;
1240 TAILQ_FOREACH(cr, &ct->ct_pending, cr_link) {
1244 mtx_unlock(&ct->ct_lock);
1247 ct->ct_upcallrefs--;
1248 if (ct->ct_upcallrefs < 0)
1250 if (ct->ct_upcallrefs == 0)
1251 wakeup(&ct->ct_upcallrefs);
1259 clnt_vc_upcallsdone(struct ct_data *ct)
1262 SOCK_RECVBUF_LOCK_ASSERT(ct->ct_socket);
1264 while (ct->ct_upcallrefs > 0)
1265 (void) msleep(&ct->ct_upcallrefs,
1266 SOCKBUF_MTX(&ct->ct_socket->so_rcv), 0, "rpcvcup", 0);
1277 struct ct_data *ct = (struct ct_data *)cl->cl_private;
1281 mtx_lock(&ct->ct_lock);
1282 ct->ct_rcvstate |= RPCRCVSTATE_UPCALLTHREAD;
1283 while (!ct->ct_closed) {
1284 if ((ct->ct_rcvstate & RPCRCVSTATE_UPCALLNEEDED) != 0) {
1285 ct->ct_rcvstate &= ~RPCRCVSTATE_UPCALLNEEDED;
1286 ct->ct_rcvstate |= RPCRCVSTATE_UPCALLINPROG;
1287 if (ct->ct_sslrefno != 0 && ct->ct_sslrefno !=
1289 mtx_unlock(&ct->ct_lock);
1290 ret = rpctls_cl_handlerecord(ct->ct_sslsec,
1291 ct->ct_sslusec, ct->ct_sslrefno, &reterr);
1292 mtx_lock(&ct->ct_lock);
1294 ct->ct_rcvstate &= ~RPCRCVSTATE_UPCALLINPROG;
1296 ct->ct_rcvstate |= RPCRCVSTATE_NORMAL;
1298 ct->ct_rcvstate |= RPCRCVSTATE_NONAPPDATA;
1299 wakeup(&ct->ct_rcvstate);
1301 if ((ct->ct_rcvstate & RPCRCVSTATE_SOUPCALLNEEDED) != 0) {
1302 ct->ct_rcvstate &= ~RPCRCVSTATE_SOUPCALLNEEDED;
1303 mtx_unlock(&ct->ct_lock);
1304 SOCK_RECVBUF_LOCK(ct->ct_socket);
1305 clnt_vc_soupcall(ct->ct_socket, ct, M_NOWAIT);
1306 SOCK_RECVBUF_UNLOCK(ct->ct_socket);
1307 mtx_lock(&ct->ct_lock);
1309 msleep(&ct->ct_sslrefno, &ct->ct_lock, 0, "clntvcdu", hz);
1311 ct->ct_rcvstate &= ~RPCRCVSTATE_UPCALLTHREAD;
1312 wakeup(&ct->ct_sslrefno);
1313 mtx_unlock(&ct->ct_lock);