Lines Matching defs:ccall
109 * ccall specific com_timeout controllable parameters...
120 rpc_dg_ccall_p_t /*ccall*/,
144 INTERNAL void xmit_ping ( rpc_dg_ccall_p_t /*ccall*/);
146 INTERNAL void xmit_orphan_quit ( rpc_dg_ccall_p_t /*ccall*/);
148 INTERNAL void recv_state_timer (rpc_dg_ccall_p_t /*ccall*/);
150 INTERNAL void ccall_orphan_timer (rpc_dg_ccall_p_t /*ccall*/);
152 INTERNAL void ccall_cancel_timer (rpc_dg_ccall_p_t /*ccall*/);
154 INTERNAL void ccall_uncache (rpc_dg_ccall_p_t /*ccall*/);
165 rpc_dg_ccall_p_t /*ccall*/,
171 rpc_dg_ccall_p_t /*ccall*/
179 * Return the connection's locked scall. For callbacks, the ccall is
182 * Since the ccall->c.high_seq field is being overloaded to be both the
190 rpc_dg_ccall_p_t ccall,
194 RPC_DG_CALL_LOCK_ASSERT(&ccall->c);
196 if (ccall->c.is_cbk)
200 *scallp = ccall->cbk_scall;
204 if ((*scallp)->c.call_seq != ccall->c.high_seq)
217 * ccall is the connection's logical SCT.
226 rpc_dg_ccall_p_t ccall,
232 RPC_DG_CALL_LOCK_ASSERT(&ccall->c);
233 assert(ccall->c.is_cbk == false);
235 *scallp = ccall->cbk_scall;
240 *scallp = rpc__dg_scall_cbk_alloc(ccall, si, rqe);
244 if (RPC_DG_SEQ_IS_LT(rqe->hdrp->seq, ccall->c.high_seq))
258 ccall->c.high_seq = rqe->hdrp->seq;
265 * Common ccall initialization done by ccall_alloc and ccall_reinit.
271 rpc_dg_ccall_p_t ccall,
278 boolean doing_callback = ccall->c.is_cbk;
281 RPC_DG_CALL_LOCK_ASSERT(&ccall->c);
284 RPC_DG_CALL_LOCK_ASSERT(&ccall->cbk_scall->c);
294 ccall->c.call_opnum = opnum;
295 ccall->c.xq.base_flags = 0;
296 ccall->c.xq.base_flags2 = 0;
297 ccall->response_info_updated = false;
298 ccall->cbk_start = false;
299 ccall->reject_status = 0;
301 ccall->cancel.next_time = 0;
302 ccall->cancel.server_is_accepting = true;
303 ccall->cancel.server_had_pending = false;
304 ccall->cancel.local_count = 0;
305 ccall->cancel.server_count = 0;
306 ccall->cancel.timeout_time = 0;
308 ccall->quit.quack_rcvd = false;
310 ccall->auth_way_info = NULL;
311 ccall->auth_way_info_len = 0;
321 ccall->c.com_timeout_knob = h->c.c.timeout;
325 ccall->timeout_stamp = 0;
329 ccall->timeout_stamp = rpc__clock_stamp() + h->c.c.call_timeout_time;
334 ccall->c.xq.base_flags |= RPC_C_DG_PF_BROADCAST | RPC_C_DG_PF_IDEMPOTENT;
339 ccall->c.xq.base_flags |= RPC_C_DG_PF_IDEMPOTENT;
341 ccall->c.xq.base_flags |= RPC_C_DG_PF_MAYBE | RPC_C_DG_PF_IDEMPOTENT;
350 if (ccall->c.sock_ref->is_private)
351 ccall->c.thread_id = dcethread_self();
357 ccall->server_bound = h->c.c.bound_server_instance;
365 if (ccall->server_bound == false && h->c.c.addr_has_endpoint == false)
367 rpc__if_set_wk_endpoint(ifspec, &ccall->c.addr, st);
372 ((rpc_if_rep_p_t) ept_v3_0_c_ifspec, &ccall->c.addr, st);
386 ccall->c.high_seq = ccall->c.call_seq = ++ccall->cbk_scall->c.high_seq;
399 ccall->c.rq.high_rcv_frag_size =
400 ccall->cbk_scall->c.rq.high_rcv_frag_size;
402 if (ccall->c.rq.high_rcv_frag_size > ccall->cbk_scall->c.xq.snd_frag_size)
404 ccall->c.xq.snd_frag_size = MIN(ccall->c.rq.high_rcv_frag_size,
405 ccall->c.xq.max_snd_tsdu);
409 ccall->c.xq.snd_frag_size &= ~ 0x7;
415 ccall->c.xq.first_fack_seen = true;
418 ccall->c.xq.snd_frag_size = ccall->cbk_scall->c.xq.snd_frag_size;
424 ccall->c.n_resvs = ccall->cbk_scall->c.n_resvs;
428 ccall->c.high_seq = ccall->c.call_seq = ccall->ccte_ref.ccte->seq++;
436 ccall->c.rq.high_rcv_frag_size = RPC_C_DG_INITIAL_MAX_PKT_SIZE;
437 ccall->c.xq.snd_frag_size = MIN(RPC_C_DG_MUST_RECV_FRAG_SIZE,
438 ccall->c.xq.snd_frag_size);
440 else if (ccall->c.rq.high_rcv_frag_size > ccall->c.xq.snd_frag_size)
455 ccall->c.xq.snd_frag_size = MIN(ccall->c.rq.high_rcv_frag_size,
456 ccall->c.xq.max_snd_tsdu);
460 ccall->c.xq.snd_frag_size &= ~ 0x7;
466 ccall->c.xq.first_fack_seen = true;
472 ccall->c.xq.snd_frag_size, ccall->c.rq.high_rcv_frag_size));
480 * Allocate and initialize a ccall for the input binding handle.
494 rpc_dg_ccall_p_t ccall;
522 RPC_MEM_ALLOC(ccall, rpc_dg_ccall_p_t, sizeof *ccall,
529 rpc__dg_call_init(&ccall->c);
531 RPC_DG_CALL_LOCK(&ccall->c);
532 RPC_DG_CALL_REFERENCE(&ccall->c); /* For the ref we're going to return */
534 RPC_DG_CCTE_REF_INIT(&ccall->ccte_ref);
539 ccall->c.sock_ref = sp;
547 sp->ccall = ccall;
556 rpc__dg_cct_get(h->c.c.auth_info, ccall);
558 ccall->c.is_cbk = false;
559 ccall->cbk_scall = NULL;
577 ccall->c.key_info = 0;
578 ccall->c.auth_epv = 0;
579 ccall->c.call_actid = scall->c.call_actid;
580 ccall->c.actid_hash = scall->c.actid_hash;
581 ccall->c.rq.window_size = scall->c.rq.window_size;
582 ccall->c.is_cbk = true;
589 ccall->cbk_scall = scall;
590 RPC_DG_CALL_REFERENCE(&ccall->c);
591 scall->cbk_ccall = ccall;
593 ccall->c.xq.max_rcv_tsdu = scall->c.xq.max_rcv_tsdu;
594 ccall->c.xq.max_snd_tsdu = scall->c.xq.max_snd_tsdu;
595 ccall->c.xq.max_frag_size = scall->c.xq.max_frag_size;
596 ccall->c.max_resvs = scall->c.max_resvs;
599 ccall->c.c.is_server = false;
601 rpc__naf_addr_copy(h->c.c.rpc_addr, &ccall->c.addr, st);
608 ccall->c.call_object = h->c.c.obj;
609 ccall->c.call_if_id = ifspec->id;
610 ccall->c.call_if_vers = ifspec->vers;
611 ccall->c.call_ihint = RPC_C_DG_NO_HINT;
617 hdrp = &ccall->c.xq.hdr;
630 ccall->h = (struct rpc_dg_binding_client_t *) h;
631 ccall->server_bound = false;
632 ccall->fault_rqe = NULL;
642 rpc__naf_inq_max_tsdu(ccall->c.addr->rpc_protseq_id,
643 &ccall->c.xq.max_rcv_tsdu, st);
644 ccall->c.xq.max_snd_tsdu = ccall->c.xq.max_rcv_tsdu;
645 ccall->c.xq.max_rcv_tsdu = MIN(ccall->c.xq.max_rcv_tsdu,
646 ccall->c.sock_ref->rcvbuf);
647 ccall->c.xq.max_snd_tsdu = MIN(ccall->c.xq.max_snd_tsdu,
648 ccall->c.sock_ref->sndbuf);
652 ccall->c.xq.max_rcv_tsdu, ccall->c.xq.max_snd_tsdu));
669 RPC_DG_CALL_SET_MAX_FRAG_SIZE(&ccall->c, st);
672 ccall->c.xq.max_frag_size));
680 ccall->c.xq.max_frag_size,
681 ccall->c.rq.window_size);
684 ccall->c.rq.window_size, sp->rcvbuf, ccall->c.xq.max_frag_size));
687 ccall_common_init(h, ccall, options, ifspec, opnum, st);
690 RPC_DG_CCALL_RELEASE(&ccall);
701 RPC_DG_CALL_SET_TIMER(&ccall->c, rpc__dg_ccall_timer, RPC_CLOCK_SEC(1));
703 return (ccall);
709 * Re-initialize the input binding handle's ccall. Return true iff
710 * the ccall needs to be re-inserted in the CCALLT.
724 rpc_dg_ccall_p_t ccall;
737 ccall = h->ccall;
738 h->ccall = NULL;
745 RPC_DG_CALL_LOCK(&ccall->c);
747 RPC_DG_CALL_REINIT(&ccall->c);
754 if (ccall->c.state != rpc_e_dg_cs_final)
756 assert(ccall->c.state == rpc_e_dg_cs_idle);
760 rpc__dg_cct_get(h->c.c.auth_info, ccall);
764 prev_state = ccall->c.state;
766 RPC_DG_CALL_SET_STATE(&ccall->c, rpc_e_dg_cs_init);
773 if (ifspec->vers != ccall->c.call_if_vers
774 || ! UUID_EQ(ifspec->id, ccall->c.call_if_id, st))
776 ccall->c.call_ihint = RPC_C_DG_NO_HINT;
777 ccall->c.call_if_id = ifspec->id;
778 ccall->c.call_if_vers = ifspec->vers;
784 if (ccall->auth_way_info != NULL)
786 RPC_MEM_FREE(ccall->auth_way_info, RPC_C_MEM_DG_EPAC);
789 ccall_common_init(h, ccall, options, ifspec, opnum, st);
792 RPC_DG_CALL_UNLOCK(&ccall->c);
803 return (ccall);
932 * cancel detection code in call_wait(), setup the call now. A ccall
939 rpc_dg_ccall_p_t ccall,
948 if (ccall == NULL)
958 RPC_DG_CALL_LOCK_ASSERT(&ccall->c);
960 ccall->cancel.timeout_time = cancel_timeout_time;
961 ccall->cancel.local_count = cancel_cnt;
971 PRIVATE void rpc__dg_ccall_setup_cancel_tmo(ccall)
972 rpc_dg_ccall_p_t ccall;
983 if (ccall->cancel.timeout_time == 0)
992 ccall->cancel.timeout_time = rpc__clock_stamp() +
1015 rpc_dg_ccall_p_t ccall;
1088 ccall = h->ccall;
1089 if (ccall != NULL)
1091 rpc_key_info_p_t key_info = ccall->c.key_info;
1094 if (RPC_DG_SOCK_IS_DISABLED(ccall->c.sock_ref) ||
1099 RPC_DG_CALL_LOCK(&ccall->c);
1100 RPC_DG_CCALL_RELEASE(&h->ccall)
1108 * pairing is: scall, is_cbk ccall (see dg.h).
1119 if (h->ccall == NULL)
1121 ccall = ccall_alloc(h, options, ifspec, opnum, st);
1130 rpc__dg_ccallt_insert(ccall);
1136 ccall = ccall_reinit(h, options, ifspec, opnum, &insert_in_ccallt, st);
1147 rpc__dg_ccallt_insert(ccall);
1161 ccall_initial_cancel_setup(ccall, cancel_cnt, cancel_timeout_time);
1180 rpc__dg_pkt_adjust_reservation(&ccall->c,
1185 rpc__dg_pkt_adjust_reservation(&ccall->c, ccall->c.max_resvs, true);
1196 RPC_DG_CALL_UNLOCK(&ccall->c);
1207 ccall->c.key_info != NULL)
1209 rpc_dg_auth_epv_p_t epv = ccall->c.auth_epv;
1212 (*epv->pre_call) (ccall->c.key_info, (handle_t)h, &xst);
1215 RPC_DG_CALL_LOCK(&ccall->c);
1216 rpc__dg_call_signal_failure(&ccall->c, xst);
1217 RPC_DG_CALL_UNLOCK(&ccall->c);
1222 return ((rpc_call_rep_p_t) ccall);
1239 rpc_dg_ccall_p_t ccall;
1244 ccall = (rpc_dg_ccall_p_t) *call_;
1247 assert(RPC_DG_CALL_IS_CLIENT(&ccall->c));
1250 RPC_DG_CALL_LOCK(&ccall->c);
1252 h = (rpc_dg_binding_client_p_t) ccall->h;
1260 rpc__dg_pkt_cancel_reservation(&ccall->c);
1263 * Perform the callback / non-callback ccall specific bookkeeping.
1268 if (ccall->c.is_cbk)
1270 rpc_dg_scall_p_t scall = ccall->cbk_scall;
1273 * This is a server side callback ccall.
1278 * pairing is: scall, is_cbk ccall (see dg.h).
1281 RPC_DG_CALL_UNLOCK(&ccall->c);
1283 RPC_DG_CALL_LOCK(&ccall->c);
1290 if (ccall->response_info_updated && ccall->cbk_scall != NULL)
1291 ccall->cbk_scall->c.high_seq = ccall->c.high_seq;
1298 if (ccall->cbk_scall != NULL)
1300 ccall->cbk_scall->c.rq.high_rcv_frag_size =
1301 ccall->c.rq.high_rcv_frag_size;
1302 ccall->cbk_scall->c.xq.snd_frag_size = ccall->c.xq.snd_frag_size;
1310 * This is a normal (client side) ccall.
1320 if (RPC_DG_SEQ_IS_LT(ccall->c.call_seq, ccall->c.high_seq))
1321 ccall->ccte_ref.ccte->seq = ccall->c.high_seq + 1;
1336 if (ccall->cbk_scall != NULL)
1338 rpc_dg_scall_p_t scall = ccall->cbk_scall;
1341 assert(scall->cbk_ccall == ccall);
1343 ccall->cbk_start = false;
1347 * pairing is: ccall, is_cbk scall (see dg.h).
1361 if (RPC_DG_SEQ_IS_LT(ccall->c.high_seq, scall->c.call_seq))
1362 ccall->c.high_seq = scall->c.call_seq;
1366 RPC_DG_SCALL_RELEASE(&ccall->cbk_scall);
1370 RPC_DG_CALL_LOCK_ASSERT(&ccall->c);
1374 * (this does not release the ccall's reference to the handle).
1384 if (ccall->fault_rqe != NULL)
1386 rpc__dg_pkt_free_rqe(ccall->fault_rqe, &ccall->c);
1387 ccall->fault_rqe = NULL;
1394 if (ccall->cancel.server_had_pending
1395 || (ccall->cancel.local_count > ccall->cancel.server_count))
1415 if ((ccall->c.rq.all_pkts_recvd == true)
1416 && (ccall->c.status == rpc_s_ok)
1417 && ((ccall->c.xq.base_flags & RPC_C_DG_PF_IDEMPOTENT) == 0
1418 || ccall->c.rq.recving_frags))
1420 RPC_DG_CALL_SET_STATE(&ccall->c, rpc_e_dg_cs_final);
1433 if (ccall->c.rq.all_pkts_recvd == false)
1435 ccall->quit.next_time = rpc__clock_stamp() + RPC_CLOCK_SEC(1);
1437 RPC_DG_CALL_SET_STATE(&ccall->c, rpc_e_dg_cs_orphan);
1440 xmit_orphan_quit(ccall);
1444 while (ccall->quit.quack_rcvd != true)
1454 RPC_DG_CALL_COND_WAIT(&ccall->c);
1464 RPC_DG_CALL_UNLOCK(&ccall->c);
1466 RPC_DG_CALL_LOCK(&ccall->c);
1473 if (ccall->cancel.local_count > 0)
1477 RPC_DG_CCALL_SET_STATE_IDLE(ccall);
1486 if (h->ccall != NULL)
1488 rpc__dg_ccall_free_prep(ccall);
1492 RPC_DG_CALL_REFERENCE(&ccall->c); /* For the following assignment */
1493 h->ccall = ccall;
1496 RPC_DG_CCALL_RELEASE(&ccall); /* Because our caller's reference is now invalid */
1509 rpc_dg_ccall_p_t ccall
1512 rpc_dg_xmitq_p_t xq = &ccall->c.xq;
1514 RPC_DG_CALL_LOCK_ASSERT(&ccall->c);
1525 rpc__dg_xmit_hdr_only_pkt(ccall->c.sock_ref->sock, ccall->c.addr,
1537 rpc_dg_ccall_p_t ccall
1540 RPC_DG_CALL_LOCK_ASSERT(&ccall->c);
1542 assert(ccall->c.state == rpc_e_dg_cs_final);
1546 rpc__dg_xmit_hdr_only_pkt(ccall->c.sock_ref->sock, ccall->c.addr,
1547 &ccall->c.xq.hdr,
1559 rpc_dg_ccall_p_t ccall
1562 RPC_DG_CALL_LOCK_ASSERT(&ccall->c);
1564 rpc__dg_xmit_hdr_only_pkt(ccall->c.sock_ref->sock, ccall->c.addr,
1565 &ccall->c.xq.hdr,
1579 rpc_dg_ccall_p_t ccall,
1596 hdr = ccall->c.xq.hdr;
1625 rpc__dg_xmit_pkt(ccall->c.sock_ref->sock, ccall->c.addr, iov, 2, &b);
1637 rpc_dg_ccall_p_t ccall
1649 if (ccall->cancel.local_count == 0)
1655 if (ccall->c.status != rpc_s_ok)
1670 if (ccall->cancel.timeout_time != 0
1671 && now >= ccall->cancel.timeout_time)
1674 rpc__dg_act_seq_string(&ccall->c.xq.hdr)));
1676 ccall->cancel.server_is_accepting = false;
1677 ccall->cancel.server_had_pending = true;
1679 rpc__dg_call_signal_failure(&ccall->c, rpc_s_cancel_timeout);
1692 if (ccall->cancel.local_count > ccall->cancel.server_count
1693 && ccall->cancel.server_is_accepting
1694 && now >= ccall->cancel.next_time)
1698 ccall->cancel.local_count,
1699 rpc__dg_act_seq_string(&ccall->c.xq.hdr)));
1701 ccall->cancel.next_time = now + inter_cancel_time;
1703 rpc__dg_ccall_xmit_cancel_quit(ccall, ccall->cancel.local_count);
1719 rpc_dg_ccall_p_t ccall
1722 rpc_dg_ping_info_t *ping = &ccall->ping;
1724 rpc_dg_xmitq_p_t xq = &ccall->c.xq;
1725 rpc_dg_recvq_p_t rq = &ccall->c.rq;
1747 RPC_DG_CALL_LOCK_ASSERT(&ccall->c);
1756 if (ccall->c.status != rpc_s_ok || rq->all_pkts_recvd)
1764 ccall_cancel_timer(ccall);
1773 if (rpc__clock_aged(ccall->c.start_time, broadcast_wait_time))
1777 rpc__dg_call_signal_failure(&ccall->c, rpc_s_comm_failure);
1797 ccall->c.rq.next_fragnum,
1805 if (rpc__dg_xmitq_awaiting_ack_tmo(xq, ccall->c.com_timeout_knob))
1807 rpc__dg_call_signal_failure(&ccall->c, rpc_s_comm_failure);
1815 xmit_ping(ccall);
1827 ccall_com_timeout_params[ccall->c.com_timeout_knob].max_ping_time)
1828 && ccall->c.com_timeout_knob != rpc_c_binding_infinite_timeout)
1832 rpc__dg_call_signal_failure(&ccall->c, rpc_s_comm_failure);
1841 ccall->c.rq.next_fragnum,
1844 xmit_ping(ccall);
1858 rpc_dg_ccall_p_t ccall
1861 struct rpc_dg_quit_info_t *quit = &ccall->quit;
1873 rpc__dg_act_seq_string(&ccall->c.xq.hdr)));
1875 xmit_orphan_quit(ccall);
1886 rpc_dg_ccall_p_t ccall
1891 if (ccall->timeout_stamp == 0)
1895 if (now >= ccall->timeout_stamp)
1898 rpc__dg_call_signal_failure(&ccall->c, rpc_s_call_timeout);
1913 rpc_dg_ccall_p_t ccall
1916 RPC_DG_CALL_LOCK_ASSERT(&ccall->c);
1918 assert(ccall->c.refcnt == 0);
1924 if (ccall->c.state == rpc_e_dg_cs_final)
1926 rpc__dg_ccall_ack(ccall);
1929 assert(ccall->cbk_scall == NULL);
1935 if (ccall->auth_way_info != NULL)
1937 RPC_MEM_FREE(ccall->auth_way_info, RPC_C_MEM_DG_EPAC);
1945 rpc__dg_call_free(&ccall->c);
1947 RPC_MEM_FREE(ccall, RPC_C_MEM_DG_CCALL);
1948 /* ccall may no longer be referenced */
1955 * of a ccall. Shut down the ccall's timer and transition to the idle
1961 rpc_dg_ccall_p_t ccall
1964 RPC_DG_CALL_LOCK_ASSERT(&ccall->c);
1966 RPC_DG_CALL_STOP_TIMER(&ccall->c);
1967 if (ccall->c.state != rpc_e_dg_cs_idle)
1968 RPC_DG_CCALL_SET_STATE_IDLE(ccall);
1980 rpc_dg_ccall_p_t ccall
1985 RPC_DG_CALL_LOCK_ASSERT(&ccall->c);
1987 assert(ccall->c.state == rpc_e_dg_cs_idle);
1993 if (ccall->h != NULL && ccall->h->ccall == ccall)
1995 RPC_DG_CCALL_RELEASE_NO_UNLOCK(&ccall->h->ccall);
1998 rpc__timer_clear(&ccall->c.timer);
1999 RPC_DG_CCALL_RELEASE(&ccall);
2013 rpc_dg_ccall_p_t ccall = (rpc_dg_ccall_p_t) p;
2024 RPC_DG_CALL_LOCK(&ccall->c);
2026 if (ccall->c.stop_timer)
2028 rpc__timer_clear(&ccall->c.timer);
2029 RPC_DG_CCALL_RELEASE(&ccall);
2034 switch (ccall->c.state)
2037 ccall_cancel_timer(ccall);
2038 ccall_timeout_timer(ccall);
2049 if (! ccall->c.is_cbk)
2051 if (rpc__clock_aged(ccall->c.state_timestamp,
2054 ccall_uncache(ccall);
2065 rpc__dg_call_xmitq_timer(&ccall->c);
2066 ccall_cancel_timer(ccall);
2067 ccall_timeout_timer(ccall);
2071 recv_state_timer(ccall);
2072 ccall_timeout_timer(ccall);
2079 if (rpc__clock_aged(ccall->c.state_timestamp, max_final_time))
2081 RPC_DG_CCALL_SET_STATE_IDLE(ccall);
2092 if (rpc__clock_aged(ccall->c.state_timestamp, max_orphan_time))
2095 ccall->quit.quack_rcvd = true;
2096 rpc__dg_call_signal_failure(&ccall->c, rpc_s_comm_failure);
2100 ccall_orphan_timer(ccall);
2105 RPC_DG_CALL_UNLOCK(&ccall->c);