static void seedRandomInsecureNumber(void)
{
struct timespec t;
timeoutComp(&t, 0);
long long x = t.tv_sec * 3 + t.tv_nsec * 2;
srandom((unsigned int) x);
}
/* terminate a thread via the non-cancel interface
* This is a separate function as it involves a bit more of code.
* rgerhads, 2009-10-15
*/
static inline rsRetVal
thrdTerminateNonCancel(thrdInfo_t *pThis)
{
struct timespec tTimeout;
int ret;
DEFiRet;
assert(pThis != NULL);
DBGPRINTF("request term via SIGTTIN for input thread 0x%x\n", (unsigned) pThis->thrdID);
pThis->bShallStop = TRUE;
do {
d_pthread_mutex_lock(&pThis->mutThrd);
pthread_kill(pThis->thrdID, SIGTTIN);
timeoutComp(&tTimeout, 10); /* a fixed 10ms timeout, do after lock (may take long!) */
ret = d_pthread_cond_timedwait(&pThis->condThrdTerm, &pThis->mutThrd, &tTimeout);
d_pthread_mutex_unlock(&pThis->mutThrd);
if(Debug) {
if(ret == ETIMEDOUT) {
dbgprintf("input thread term: had a timeout waiting on thread termination\n");
} else if(ret == 0) {
dbgprintf("input thread term: thread returned normally and is terminated\n");
} else {
char errStr[1024];
int err = errno;
rs_strerror_r(err, errStr, sizeof(errStr));
dbgprintf("input thread term: cond_wait returned with error %d: %s\n",
err, errStr);
}
}
} while(pThis->bIsActive);
DBGPRINTF("non-cancel input thread termination succeeded for thread 0x%x\n", (unsigned) pThis->thrdID);
RETiRet;
}
static rsRetVal
dynstats_resetBucket(dynstats_bucket_t *b, uint8_t do_purge) {
size_t htab_sz;
DEFiRet;
htab_sz = (size_t) (DYNSTATS_HASHTABLE_SIZE_OVERPROVISIONING * b->maxCardinality + 1);
pthread_rwlock_wrlock(&b->lock);
if (do_purge) {
dynstats_destroyCounters(b);
}
ATOMIC_STORE_0_TO_INT(&b->metricCount, &b->mutMetricCount);
STATSCOUNTER_INC(b->ctrPurgeTriggered, b->mutCtrPurgeTriggered);
b->ctrs = NULL;
if ((b->table = create_hashtable(htab_sz, hash_from_string, key_equals_string, no_op_free)) == NULL) {
errmsg.LogError(errno, RS_RET_INTERNAL_ERROR, "error trying to initialize hash-table for dyn-stats bucket named: %s", b->name);
ABORT_FINALIZE(RS_RET_INTERNAL_ERROR);
}
timeoutComp(&b->metricCleanupTimeout, b->unusedMetricLife);
finalize_it:
pthread_rwlock_unlock(&b->lock);
if (iRet != RS_RET_OK) {
statsobj.Destruct(&b->stats);
}
RETiRet;
}
static rsRetVal
dynstats_resetBucket(dynstats_bucket_t *b) {
DEFiRet;
pthread_rwlock_wrlock(&b->lock);
CHKiRet(dynstats_rebuildSurvivorTable(b));
STATSCOUNTER_INC(b->ctrPurgeTriggered, b->mutCtrPurgeTriggered);
timeoutComp(&b->metricCleanupTimeout, b->unusedMetricLife);
finalize_it:
pthread_rwlock_unlock(&b->lock);
RETiRet;
}
/* terminate a thread via the non-cancel interface
* This is a separate function as it involves a bit more of code.
* rgerhads, 2009-10-15
*/
static inline rsRetVal
thrdTerminateNonCancel(thrdInfo_t *pThis)
{
struct timespec tTimeout;
int ret;
int was_active;
DEFiRet;
assert(pThis != NULL);
DBGPRINTF("request term via SIGTTIN for input thread '%s' 0x%x\n",
pThis->name, (unsigned) pThis->thrdID);
pThis->bShallStop = RSTRUE;
timeoutComp(&tTimeout, 1000); /* a fixed 1sec timeout */
d_pthread_mutex_lock(&pThis->mutThrd);
was_active = pThis->bIsActive;
while(was_active) {
pthread_kill(pThis->thrdID, SIGTTIN);
ret = d_pthread_cond_timedwait(&pThis->condThrdTerm, &pThis->mutThrd, &tTimeout);
if(ret == ETIMEDOUT) {
DBGPRINTF("input thread term: timeout expired waiting on thread %s termination - canceling\n",
pThis->name);
pthread_cancel(pThis->thrdID);
break;
} else if(ret != 0) {
char errStr[1024];
int err = errno;
rs_strerror_r(err, errStr, sizeof(errStr));
DBGPRINTF("input thread term: cond_wait returned with error %d: %s\n",
err, errStr);
}
was_active = pThis->bIsActive;
}
d_pthread_mutex_unlock(&pThis->mutThrd);
if(was_active) {
DBGPRINTF("non-cancel input thread termination FAILED for thread %s 0x%x\n",
pThis->name, (unsigned) pThis->thrdID);
} else {
DBGPRINTF("non-cancel input thread termination succeeded for thread %s 0x%x\n",
pThis->name, (unsigned) pThis->thrdID);
}
RETiRet;
}
/* wait for queue to become non-empty or timeout
* helper to wtiWorker. Note the the predicate is
* re-tested by the caller, so it is OK to NOT do it here.
* rgerhards, 2009-05-20
*/
static void
doIdleProcessing(wti_t *pThis, wtp_t *pWtp, int *pbInactivityTOOccured)
{
struct timespec t;
BEGINfunc
DBGPRINTF("%s: worker IDLE, waiting for work.\n", wtiGetDbgHdr(pThis));
if(pThis->bAlwaysRunning) {
/* never shut down any started worker */
d_pthread_cond_wait(&pThis->pcondBusy, pWtp->pmutUsr);
} else {
timeoutComp(&t, pWtp->toWrkShutdown);/* get absolute timeout */
if(d_pthread_cond_timedwait(&pThis->pcondBusy, pWtp->pmutUsr, &t) != 0) {
DBGPRINTF("%s: inactivity timeout, worker terminating...\n", wtiGetDbgHdr(pThis));
*pbInactivityTOOccured = 1; /* indicate we had a timeout */
}
}
DBGOPRINT((obj_t*) pThis, "worker awoke from idle processing\n");
ENDfunc
}