/*
* worker_idle_timer_fired()
*
* The parent starts this timer when the last pending response has been
* received from the child, making it idle, and clears the timer when a
* request is dispatched to the child. Once the timer expires, the
* child is sent packing.
*
* This is called when worker_idle_timer is nonzero and less than or
* equal to current_time.
*/
void
worker_idle_timer_fired(void)
{
u_int idx;
blocking_child * c;
DEBUG_REQUIRE(0 == intres_req_pending);
intres_timeout_req(0);
for (idx = 0; idx < blocking_children_alloc; idx++) {
c = blocking_children[idx];
if (NULL == c)
continue;
req_child_exit(c);
}
}
/*
* blocking_child_common runs as a forked child or a thread
*/
int
blocking_child_common(
blocking_child *c
)
{
int say_bye;
blocking_pipe_header *req;
say_bye = FALSE;
while (!say_bye) {
req = receive_blocking_req_internal(c);
if (NULL == req) {
say_bye = TRUE;
continue;
}
DEBUG_REQUIRE(BLOCKING_REQ_MAGIC == req->magic_sig);
switch (req->rtype) {
case BLOCKING_GETADDRINFO:
if (blocking_getaddrinfo(c, req))
say_bye = TRUE;
break;
case BLOCKING_GETNAMEINFO:
if (blocking_getnameinfo(c, req))
say_bye = TRUE;
break;
default:
msyslog(LOG_ERR, "unknown req %d to blocking worker", req->rtype);
say_bye = TRUE;
}
free(req);
}
return 0;
}
void
process_blocking_resp(
blocking_child * c
)
{
blocking_pipe_header * resp;
void * data;
/*
* On Windows send_blocking_resp_internal() may signal the
* blocking_response_ready event multiple times while we're
* processing a response, so always consume all available
* responses before returning to test the event again.
*/
#ifdef WORK_THREAD
do {
#endif
resp = receive_blocking_resp_internal(c);
if (NULL != resp) {
DEBUG_REQUIRE(BLOCKING_RESP_MAGIC ==
resp->magic_sig);
data = (char *)resp + sizeof(*resp);
intres_req_pending--;
(*resp->done_func)(resp->rtype, resp->context,
resp->octets - sizeof(*resp),
data);
free(resp);
}
#ifdef WORK_THREAD
} while (NULL != resp);
#endif
if (!worker_per_query && 0 == intres_req_pending)
intres_timeout_req(CHILD_MAX_IDLE);
else if (worker_per_query)
req_child_exit(c);
}
/*
* get_systime - return system time in NTP timestamp format.
*/
void
get_systime(
l_fp *now /* system time */
)
{
static struct timespec ts_prev; /* prior os time */
static l_fp lfp_prev; /* prior result */
static double dfuzz_prev; /* prior fuzz */
struct timespec ts; /* seconds and nanoseconds */
struct timespec ts_min; /* earliest permissible */
struct timespec ts_lam; /* lamport fictional increment */
struct timespec ts_prev_log; /* for msyslog only */
double dfuzz;
double ddelta;
l_fp result;
l_fp lfpfuzz;
l_fp lfpdelta;
get_ostime(&ts);
DEBUG_REQUIRE(systime_init_done);
ENTER_GET_SYSTIME_CRITSEC();
/*
* After default_get_precision() has set a nonzero sys_fuzz,
* ensure every reading of the OS clock advances by at least
* sys_fuzz over the prior reading, thereby assuring each
* fuzzed result is strictly later than the prior. Limit the
* necessary fiction to 1 second.
*/
if (!USING_SIGIO()) {
ts_min = add_tspec_ns(ts_prev, sys_fuzz_nsec);
if (cmp_tspec(ts, ts_min) < 0) {
ts_lam = sub_tspec(ts_min, ts);
if (ts_lam.tv_sec > 0 && !lamport_violated) {
msyslog(LOG_ERR,
"get_systime Lamport advance exceeds one second (%.9f)",
ts_lam.tv_sec +
1e-9 * ts_lam.tv_nsec);
exit(1);
}
if (!lamport_violated)
ts = ts_min;
}
ts_prev_log = ts_prev;
ts_prev = ts;
} else {
/*
* Quiet "ts_prev_log.tv_sec may be used uninitialized"
* warning from x86 gcc 4.5.2.
*/
ZERO(ts_prev_log);
}
/* convert from timespec to l_fp fixed-point */
result = tspec_stamp_to_lfp(ts);
/*
* Add in the fuzz.
*/
dfuzz = ntp_random() * 2. / FRAC * sys_fuzz;
DTOLFP(dfuzz, &lfpfuzz);
L_ADD(&result, &lfpfuzz);
/*
* Ensure result is strictly greater than prior result (ignoring
* sys_residual's effect for now) once sys_fuzz has been
* determined.
*/
if (!USING_SIGIO()) {
if (!L_ISZERO(&lfp_prev) && !lamport_violated) {
if (!L_ISGTU(&result, &lfp_prev) &&
sys_fuzz > 0.) {
msyslog(LOG_ERR, "ts_prev %s ts_min %s",
tspectoa(ts_prev_log),
tspectoa(ts_min));
msyslog(LOG_ERR, "ts %s", tspectoa(ts));
msyslog(LOG_ERR, "sys_fuzz %ld nsec, prior fuzz %.9f",
sys_fuzz_nsec, dfuzz_prev);
msyslog(LOG_ERR, "this fuzz %.9f",
dfuzz);
lfpdelta = lfp_prev;
L_SUB(&lfpdelta, &result);
LFPTOD(&lfpdelta, ddelta);
msyslog(LOG_ERR,
"prev get_systime 0x%x.%08x is %.9f later than 0x%x.%08x",
lfp_prev.l_ui, lfp_prev.l_uf,
ddelta, result.l_ui, result.l_uf);
}
}
lfp_prev = result;
dfuzz_prev = dfuzz;
if (lamport_violated)
lamport_violated = FALSE;
}
LEAVE_GET_SYSTIME_CRITSEC();
*now = result;
}
