Lines Matching refs:call
113 * structure. A call handle is an example of an object.
196 * this model no one directly calls a "free" function; they call a "release"
387 * (or used to set up outgoing packets). We call machines that have
507 #define RPC_C_DG_PF2_CANCEL_PENDING 0x02 /* (server -> client) Cancel was pending at call end */
736 * determined values (in the receiver's call xmitq) and, if
867 * a function to call should contact be lost with the client.
878 * by registering a rundown function pointer through a call to the
884 * call back is required for each activity ID. However the address space
894 rpc_network_rundown_fn_t rundown; /* routine to call if client dies */
1075 * This is fine when the send is being done from a client/call thread, since
1082 * one exception in the case where the last packet(s) of a call's OUTS
1084 * to detain the server call thread while waiting for an ack from the
1086 * an ACK, and the server call thread would be hung up for 30 seconds
1090 * from the listener/timer thread in cases where the call has transitioned
1101 #define RPC_DG_START_XMIT(call) \
1102 if ((call)->state == rpc_e_dg_cs_final) \
1103 rpc__dg_call_xmit(call, false); \
1105 rpc__dg_call_signal(call);
1108 * And here's a macro to help decide if you should call the macro above.
1110 #define RPC_DG_CALL_READY_TO_SEND(call) ((call)->xq.blast_size > 0)
1214 * A client wanting to make a call picks a connection to use by looking
1217 * and sequence number in its call. The client increments the sequence
1219 * the client's call. If the client finds no matching entry, it creates
1234 * next field are "owned" by the call that is using this connection.
1237 * The relationship between the CCTEs, activity ids, auth-infos, call
1274 * before making a call. Doing so ensures that the server does a WAY
1282 * using the same actid as in previous call.
1285 * it does NOT call back and the new binding doesn't acquire the server's
1288 * executed our call once). (See "conv_who_are_you" in "conv.c" for
1305 * Another fallout from this approach is that when a first call on a
1307 * we can KNOW that the server didn't execute the call (i.e., in case
1308 * the call was to a non-idem procedure and the boot time in the binding
1309 * is zero--i.e., the server didn't call us back). This turns out to
1313 * the call more than once). We expect this to be a common occurrence
1325 unsigned32 seq; /* seq # to use in next call to server */
1326 rpc_clock_t timestamp; /* last time connection used in a call */
1352 * CCT soft refs are used by call handles to refer to CCTEs that are
1372 * For both client and server call handles, the only time that a handle
1373 * isn't actively performing or associated with a specific call is when
1381 * created transmit() call call
1394 * | | end call() +------+ end call() | |
1395 * | | maybe call | ^ idempotent call | |
1398 * | start call() ack sent |
1400 * start_call() - new call
1408 * created being called transmit() call
1414 * | | | call / | +------+(*) | \ | |
1422 * | | | maybe call ^ | ^ idempotent call | |
1425 * | new call rcvd |
1427 * new call rcvd
1432 rpc_e_dg_cs_init, /* call initialized and in use */
1433 rpc_e_dg_cs_xmit, /* call in use; currently sending data */
1434 rpc_e_dg_cs_recv, /* call in use; awaiting data */
1435 rpc_e_dg_cs_final, /* call in use; delayed ack pending */
1436 rpc_e_dg_cs_idle, /* call NOT in use */
1437 rpc_e_dg_cs_orphan /* call orphaned; waiting to exit */
1445 * Defines data that is common to client and server call handles
1447 * packet header as the repository for various per-call state (e.g. seq
1450 * The mutex (".mutex") protects fields in the composite call handles
1451 * (i.e., CCALLs and SCALLs). The call handle mutex is a level 2 lock.
1454 * call handle (typically, changes to the transmit and receive queues)
1463 * call; in this case, we will still begin a new call with the appropriate
1467 * call handle. For client call handles, references can be from:
1469 * - Client binding handles (cached client call handles).
1471 * - The application thread (via the return from "start call").
1472 * - The call handle's timer.
1474 * Almost all fields are protected by the call handle's lock. Two
1476 * protected by the data structure upon which the call handle is chained
1481 * All call handle lock, condition wait and signalling operations should
1486 rpc_call_rep_t c; /* call handle common header */
1488 rpc_dg_call_state_t state; /* call state */
1489 unsigned32 status; /* call's error status indicator / value */
1500 rpc_clock_t last_rcv_timestamp; /* last time we rcv'd some packets for this call */
1501 rpc_clock_t start_time; /* time call started */
1502 unsigned32 high_seq; /* seq # from response packets or callback-generated call handles */
1506 unsigned8 refcnt; /* # of references to the call */
1511 unsigned priv_cond_signal: 1; /* T => call is being woken from recvfrom */
1513 unsigned is_cbk: 1; /* T => this call handle was created specifically for a callback */
1535 * The various operations on the call handle mutex and condition variables.
1538 #define RPC_DG_CALL_LOCK_INIT(call) RPC_CALL_LOCK_INIT(&(call)->c)
1539 #define RPC_DG_CALL_LOCK(call) RPC_CALL_LOCK(&(call)->c)
1540 #define RPC_DG_CALL_UNLOCK(call) RPC_CALL_UNLOCK(&(call)->c)
1541 #define RPC_DG_CALL_TRY_LOCK(call,bp) RPC_CALL_TRY_LOCK(&(call)->c,(bp))
1542 #define RPC_DG_CALL_LOCK_DELETE(call) RPC_CALL_LOCK_DELETE(&(call)->c)
1543 #define RPC_DG_CALL_LOCK_ASSERT(call) RPC_CALL_LOCK_ASSERT(&(call)->c)
1544 #define RPC_DG_CALL_UNLOCK_ASSERT(call) RPC_CALL_UNLOCKED_ASSERT(&(call)->c)
1546 #define RPC_DG_CALL_COND_INIT(call) RPC_COND_INIT((call)->cv, (call)->c.m)
1547 #define RPC_DG_CALL_COND_DELETE(call) RPC_COND_DELETE((call)->cv, (call)->c.m)
1548 #define RPC_DG_CALL_COND_WAIT(call) RPC_COND_WAIT((call)->cv, (call)->c.m)
1549 #define RPC_DG_CALL_COND_SIGNAL(call) RPC_COND_SIGNAL((call)->cv, (call)->c.m)
1551 #define RPC_DG_CALL_IS_SERVER(call) RPC_CALL_IS_SERVER(&(call)->c)
1552 #define RPC_DG_CALL_IS_CLIENT(call) RPC_CALL_IS_CLIENT(&(call)->c)
1555 * A common function for changing the call handle state.
1558 #define RPC_DG_CALL_SET_STATE(call, s) { \
1559 if ((call)->state != (s)) { \
1560 RPC_DBG_PRINTF(rpc_e_dbg_dg_state, 2, ("(RPC_DG_CALL_SET_STATE) " #call "=%p, old state=%u, new state=%u\n", \
1561 (call), (int) (call)->state, (int) (s))); \
1562 (call)->state = (s); \
1563 (call)->state_timestamp = rpc__clock_stamp(); \
1570 * Server call handle (SCALL).
1581 * performed until the call executor processing has completed.
1593 * of the {s,c}call fields in this picture and how the differ from the
1621 * All fields are protected by the common call handle lock.
1625 rpc_dg_call_t c; /* call handle common header */
1629 struct rpc_dg_binding_server_t *h; /* binding handle associated with this call */
1631 unsigned call_is_setup: 1; /* T => "call executor" has been established */
1632 unsigned has_call_executor_ref: 1; /* T => "call executor" has ref */
1633 unsigned call_is_queued: 1; /* T => call has been queued */
1639 * Client call handle (CCALL).
1646 * A call handle is associated with both a single binding handle and
1648 * in-progress call, a call handle provides a inter-RPC cache of useful
1651 * require that the call handle be appropriatly updated. On every call,
1652 * the call handle's per call state (e.g. interface id, ihint, opn) must
1655 * An in-progress call increments its associated CCTE's reference count
1656 * for the duration of the call (thereby reserving the CCTE's actid).
1657 * The reference count should not be decremented until the call no longer
1660 * A call handle may be re-associated with a new CCTE (if the last one
1661 * it used happens to be "inuse" or has been freed and a call is starting
1663 * the call handle (e.g., the actid and the ahint) need to be reinitialized.
1668 * The server call handle (".cbk_scall") refers to the handle of a callback
1672 * by the client making the call. (Requests packets with non-matching
1681 * ack. The callback SCALL is freed when the original call completes.
1686 * values of the {s,c}call fields in this picture and how the differ
1722 * an "originating" call that are performed using the client's activity
1728 * When the original call completes, the value of the response sequence
1731 * All fields are protected by the common call handle lock.
1734 * The only occasion where more than one call handle may require locking
1737 * really means which call of the pair has been tagged ".is_cbk == true").
1802 rpc_dg_call_t c; /* call handle common header */
1803 rpc_dg_recvq_elt_p_t fault_rqe; /* received call fault rqe */
1810 struct rpc_dg_binding_client_t *h; /* binding handle that started this call */
1814 rpc_clock_t timeout_stamp; /* max call execution time */
1822 * Client call handle table (CCALLT).
1827 * connection sockets to the appropriate call. The CCALLT is a hash
1848 * connection sockets to the appropriate server call handle. Additionally
1849 * the SCT holds "inter-call history" about remote clients (seq and
1854 * to call handles based on the packet's activity ID. It's like the
1855 * CCT in that it maintains inter-call history. We maintain this
1873 * on each succesive call).
1881 * (inducing_request_seq - 1); logically the highest previous call that
1884 * A call may be tentatively accepted as long as it's sequence number
1894 * call's sequence number to be greater that the SCTE ".high_seq", since
1895 * the call's request packet could have been (legally) reordered wrt a
1896 * packet from a subsequent call; in this case the maybe call will not
1900 * field is used both to locate the SCALL for an in-progress call and
1903 * is for the connection's current (or just completed) call; otherwise
1937 rpc_dg_scall_p_t scall; /* -> server call handle being used in call */
1940 rpc_clock_t timestamp; /* last time connection used in a call */
2164 * even involve a subroutine call). Note that even if RPC_DG_PLOG is
2272 * The operations are invoked at the "right time" during call processing.
2305 * invoked before each call
2446 * Prototypes of routines used in the DG RPC Protocol Service (call)
2458 rpc_call_rep_p_t /*call*/,
2463 rpc_call_rep_p_t /*call*/,
2470 rpc_call_rep_p_t /*call*/,
2475 rpc_call_rep_p_t * /*call*/,
2479 rpc_call_rep_p_t /*call*/,
2483 rpc_call_rep_p_t /*call*/,
2487 rpc_call_rep_p_t /*call*/,
2492 rpc_call_rep_p_t /*call*/,
2498 rpc_call_rep_p_t /*call*/,
2582 rpc_dg_call_p_t /*call*/,
2588 rpc_dg_call_p_t /*call*/,
2633 rpc_dg_call_p_t /*call*/,