PRIVATE void rpc__dg_plog_pkt
(
rpc_dg_raw_pkt_hdr_p_t hdrp,
rpc_dg_pkt_body_p_t bodyp,
boolean32 recv,
unsigned32 lossy_action /* (0)drop, (1)?, (2)rexmit, (3)normal */
)
{
pktlog_elt_p_t pp;
if (rpc_g_dg_pkt_log == NULL)
{
rpc_g_dg_pkt_log_bytes = RPC_C_DG_PKT_LOG_SIZE * sizeof(pktlog_elt_t);
#ifdef STATIC_DG_PKTLOG
rpc_g_dg_pkt_log = _pkt_log;
#else
RPC_MEM_ALLOC(rpc_g_dg_pkt_log, pktlog_elt_p_t,
rpc_g_dg_pkt_log_bytes,
RPC_C_MEM_DG_PKTLOG, RPC_C_MEM_NOWAIT);
if (rpc_g_dg_pkt_log == NULL)
return;
/* b_z_e_r_o_(rpc_g_dg_pkt_log, rpc_g_dg_pkt_log_bytes);*/
memset(rpc_g_dg_pkt_log, 0, rpc_g_dg_pkt_log_bytes);
#endif
}
pp = &rpc_g_dg_pkt_log[pkt_log_index];
pkt_log_index = (pkt_log_index + 1) % RPC_C_DG_PKT_LOG_SIZE;
pp->timestamp = rpc__clock_stamp();
pp->lossy_action = lossy_action;
/*b_c_o_p_y_(hdrp, &pp->hdr, sizeof(rpc_dg_raw_pkt_hdr_t));*/
memmove( &pp->hdr, hdrp, sizeof(rpc_dg_raw_pkt_hdr_t));
#ifndef MISPACKED_HDR
/* b_c_o_p_y_ (bodyp, ((char *) pp->body),
MIN(MAX_LOGGED_PKT_BODY_LEN, ((rpc_dg_pkt_hdr_p_t) hdrp)->len));*/
memmove( pp->body, bodyp,
MIN(MAX_LOGGED_PKT_BODY_LEN, ((rpc_dg_pkt_hdr_p_t) hdrp)->len)) ;
#else
/* b_c_o_p_y(bodyp, ((char *) pp->body),
MIN(MAX_LOGGED_PKT_BODY_LEN, ...extracted from raw hdr... hdrp->len));*/
memmove( pp->body, bodyp,
MIN(MAX_LOGGED_PKT_BODY_LEN, ...extracted from raw hdr... hdrp->len));
#endif
if (recv)
#ifndef MISPACKED_HDR
((rpc_dg_pkt_hdr_p_t)(&pp->hdr))->_rpc_vers |= 0x80;
#else
set bit in raw hdr
#endif
}
PRIVATE void rpc__dg_convc_indy
(
dce_uuid_t *cas_uuid
)
{
rpc_dg_client_rep_p_t client;
RPC_MUTEX_LOCK(monitor_mutex);
client = find_client(cas_uuid);
if (client != NULL)
{
client->last_update = rpc__clock_stamp();
}
RPC_MUTEX_UNLOCK(monitor_mutex);
}
INTERNAL void network_monitor_liveness(void)
{
rpc_dg_client_rep_p_t client;
unsigned32 i;
struct timespec next_ts;
RPC_DBG_PRINTF(rpc_e_dbg_conv_thread, 1,
("(network_monitor_liveness) starting up...\n"));
RPC_MUTEX_LOCK(monitor_mutex);
while (stop_monitor == false)
{
/*
* Awake every 60 seconds.
*/
rpc__clock_timespec(rpc__clock_stamp()+60, &next_ts);
RPC_COND_TIMED_WAIT(monitor_cond, monitor_mutex, &next_ts);
if (stop_monitor == true)
break;
for (i = 0; i < CLIENT_TABLE_SIZE; i++)
{
client = client_table[i];
while (client != NULL && active_monitors != 0)
{
if (client->rundown != NULL &&
rpc__clock_aged(client->last_update,
RPC_CLOCK_SEC(LIVE_TIMEOUT_INTERVAL)))
{
/*
* If the timer has expired, call the rundown routine.
* Stop monitoring the client handle by setting its rundown
* routine pointer to NULL.
*/
RPC_DBG_PRINTF(rpc_e_dbg_general, 3,
("(network_monitor_liveness_timer) Calling rundown function\n"));
RPC_MUTEX_UNLOCK(monitor_mutex);
(*client->rundown)((rpc_client_handle_t)client);
RPC_MUTEX_LOCK(monitor_mutex);
/*
* The monitor is no longer active.
*/
client->rundown = NULL;
active_monitors--;
}
client = client->next;
}
if (active_monitors == 0)
{
/*
* While we were executing the rundown function and opened the
* mutex, the fork handler might try to stop us.
*/
if (stop_monitor == true)
break;
/*
* Nothing left to monitor, so terminate the thread.
*/
dcethread_detach_throw(monitor_task);
monitor_running = false;
RPC_DBG_PRINTF(rpc_e_dbg_conv_thread, 1,
("(network_monitor_liveness) shutting down (no active)...\n"));
RPC_MUTEX_UNLOCK(monitor_mutex);
return;
}
}
}
RPC_DBG_PRINTF(rpc_e_dbg_conv_thread, 1,
("(network_monitor_liveness) shutting down...\n"));
RPC_MUTEX_UNLOCK(monitor_mutex);
}
PRIVATE void rpc__dg_network_mon
(
rpc_binding_rep_p_t binding_r ATTRIBUTE_UNUSED,
rpc_client_handle_t client_h,
rpc_network_rundown_fn_t rundown,
unsigned32 *st
)
{
rpc_dg_client_rep_p_t ptr, client = (rpc_dg_client_rep_p_t) client_h;
unsigned16 probe;
dce_uuid_p_t cas_uuid = (dce_uuid_p_t) &client->cas_uuid;
RPC_MUTEX_LOCK(monitor_mutex);
/*
* Hash into the client rep table based on the handle's UUID.
* Scan the chain to find the client handle.
*/
probe = CLIENT_HASH_PROBE(cas_uuid, st);
ptr = client_table[probe];
while (ptr != NULL)
{
if (ptr == client)
break;
ptr = ptr->next;
}
/*
* If the handle passed in is not in the table, it must be bogus.
* Also, make sure that we are not already monitoring this client,
* indicated by a non-NULL rundown routine pointer.
*/
if (ptr == NULL || ptr->rundown != NULL)
{
*st = -1; /* !!! Need a real error value */
RPC_MUTEX_UNLOCK(monitor_mutex);
return;
}
/*
* (Re)initialize the table entry, and bump the count of active monitors.
*/
client->rundown = rundown;
client->last_update = rpc__clock_stamp();
active_monitors++;
/*
* Last, make sure that the monitor timer routine is running.
*/
if (! monitor_running)
{
monitor_running = true;
dcethread_create_throw(&monitor_task, NULL,
(dcethread_startroutine) network_monitor_liveness,
NULL);
}
*st = rpc_s_ok;
RPC_MUTEX_UNLOCK(monitor_mutex);
}
