void traceCapsetEvent_ (EventTypeNum tag,
CapsetID capset,
StgWord info)
{
#ifdef DEBUG
if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) {
ACQUIRE_LOCK(&trace_utx);
tracePreface();
switch (tag) {
case EVENT_CAPSET_CREATE: // (capset, capset_type)
debugBelch("created capset %lu of type %d\n", (lnat)capset, (int)info);
break;
case EVENT_CAPSET_DELETE: // (capset)
debugBelch("deleted capset %lu\n", (lnat)capset);
break;
case EVENT_CAPSET_ASSIGN_CAP: // (capset, capno)
debugBelch("assigned cap %lu to capset %lu\n",
(lnat)info, (lnat)capset);
break;
case EVENT_CAPSET_REMOVE_CAP: // (capset, capno)
debugBelch("removed cap %lu from capset %lu\n",
(lnat)info, (lnat)capset);
break;
}
RELEASE_LOCK(&trace_utx);
} else
#endif
{
if (eventlog_enabled) {
postCapsetEvent(tag, capset, info);
}
}
}
void traceCapEvent_ (Capability *cap,
EventTypeNum tag)
{
#ifdef DEBUG
if (RtsFlags.TraceFlags.tracing == TRACE_STDERR) {
ACQUIRE_LOCK(&trace_utx);
tracePreface();
switch (tag) {
case EVENT_CAP_CREATE: // (cap)
debugBelch("cap %d: initialised\n", cap->no);
break;
case EVENT_CAP_DELETE: // (cap)
debugBelch("cap %d: shutting down\n", cap->no);
break;
case EVENT_CAP_ENABLE: // (cap)
debugBelch("cap %d: enabling capability\n", cap->no);
break;
case EVENT_CAP_DISABLE: // (cap)
debugBelch("cap %d: disabling capability\n", cap->no);
break;
}
RELEASE_LOCK(&trace_utx);
} else
#endif
{
if (eventlog_enabled) {
postCapEvent(tag, (EventCapNo)cap->no);
}
}
}
static void traceGcEvent_stderr (Capability *cap, EventTypeNum tag)
{
ACQUIRE_LOCK(&trace_utx);
tracePreface();
switch (tag) {
case EVENT_REQUEST_SEQ_GC: // (cap)
debugBelch("cap %d: requesting sequential GC\n", cap->no);
break;
case EVENT_REQUEST_PAR_GC: // (cap)
debugBelch("cap %d: requesting parallel GC\n", cap->no);
break;
case EVENT_GC_START: // (cap)
debugBelch("cap %d: starting GC\n", cap->no);
break;
case EVENT_GC_END: // (cap)
debugBelch("cap %d: finished GC\n", cap->no);
break;
case EVENT_GC_IDLE: // (cap)
debugBelch("cap %d: GC idle\n", cap->no);
break;
case EVENT_GC_WORK: // (cap)
debugBelch("cap %d: GC working\n", cap->no);
break;
case EVENT_GC_DONE: // (cap)
debugBelch("cap %d: GC done\n", cap->no);
break;
default:
barf("traceGcEvent: unknown event tag %d", tag);
break;
}
RELEASE_LOCK(&trace_utx);
}
VOID
HvlLock(
_In_ PHVL pHvl
)
{
ACQUIRE_LOCK(pHvl, FALSE);
}
void sendMessage(Capability *from_cap, Capability *to_cap, Message *msg)
{
ACQUIRE_LOCK(&to_cap->lock);
#ifdef DEBUG
{
const StgInfoTable *i = msg->header.info;
if (i != &stg_MSG_THROWTO_info &&
i != &stg_MSG_BLACKHOLE_info &&
i != &stg_MSG_TRY_WAKEUP_info &&
i != &stg_IND_info && // can happen if a MSG_BLACKHOLE is revoked
i != &stg_WHITEHOLE_info) {
barf("sendMessage: %p", i);
}
}
#endif
msg->link = to_cap->inbox;
to_cap->inbox = msg;
recordClosureMutated(from_cap,(StgClosure*)msg);
if (to_cap->running_task == NULL) {
to_cap->running_task = myTask();
// precond for releaseCapability_()
releaseCapability_(to_cap,rtsFalse);
} else {
interruptCapability(to_cap);
}
RELEASE_LOCK(&to_cap->lock);
}
nat
freeTaskManager (void)
{
Task *task, *next;
nat tasksRunning = 0;
ACQUIRE_LOCK(&all_tasks_mutex);
for (task = all_tasks; task != NULL; task = next) {
next = task->all_next;
if (task->stopped) {
freeTask(task);
} else {
tasksRunning++;
}
}
debugTrace(DEBUG_sched, "freeing task manager, %d tasks still running",
tasksRunning);
all_tasks = NULL;
RELEASE_LOCK(&all_tasks_mutex);
#if defined(THREADED_RTS)
closeMutex(&all_tasks_mutex);
#if !defined(MYTASK_USE_TLV)
freeThreadLocalKey(¤tTaskKey);
#endif
#endif
tasksInitialized = 0;
return tasksRunning;
}
/* There may be at most one additional tick fired after a call to this */
void
stopTicker(void)
{
ACQUIRE_LOCK(&mutex);
stopped = 1;
RELEASE_LOCK(&mutex);
}
void
workerTaskStop (Task *task)
{
DEBUG_ONLY( OSThreadId id );
DEBUG_ONLY( id = osThreadId() );
ASSERT(task->id == id);
ASSERT(myTask() == task);
ACQUIRE_LOCK(&all_tasks_mutex);
if (task->all_prev) {
task->all_prev->all_next = task->all_next;
} else {
all_tasks = task->all_next;
}
if (task->all_next) {
task->all_next->all_prev = task->all_prev;
}
currentWorkerCount--;
RELEASE_LOCK(&all_tasks_mutex);
freeTask(task);
}
HsWord32
readIOManagerEvent (void)
{
// This function must exist even in non-THREADED_RTS,
// see getIOManagerEvent() above.
#if defined(THREADED_RTS)
HsWord32 res;
ACQUIRE_LOCK(&event_buf_mutex);
if (io_manager_event != INVALID_HANDLE_VALUE) {
if (next_event == 0) {
res = 0; // no event to return
} else {
res = (HsWord32)(event_buf[--next_event]);
if (next_event == 0) {
if (!ResetEvent(io_manager_event)) {
sysErrorBelch("readIOManagerEvent");
stg_exit(EXIT_FAILURE);
}
}
}
} else {
res = 0;
}
RELEASE_LOCK(&event_buf_mutex);
// debugBelch("readIOManagerEvent: %d\n", res);
return res;
#else
return 0;
#endif
}
HANDLE
getIOManagerEvent (void)
{
// This function has to exist even in the non-THREADED_RTS,
// because code in GHC.Conc refers to it. It won't ever be called
// unless we're in the threaded RTS, however.
#ifdef THREADED_RTS
HANDLE hRes;
ACQUIRE_LOCK(&event_buf_mutex);
if (io_manager_event == INVALID_HANDLE_VALUE) {
hRes = CreateEvent ( NULL, // no security attrs
true, // manual reset
false, // initial state,
NULL ); // event name: NULL for private events
if (hRes == NULL) {
sysErrorBelch("getIOManagerEvent");
stg_exit(EXIT_FAILURE);
}
io_manager_event = hRes;
} else {
hRes = io_manager_event;
}
RELEASE_LOCK(&event_buf_mutex);
return hRes;
#else
return NULL;
#endif
}
/*
* Function: startSignalHandlers()
*
* Run the handlers associated with the stacked up console events. Console
* event delivery is blocked for the duration of this call.
*/
void startSignalHandlers(Capability *cap)
{
StgStablePtr handler;
if (console_handler < 0) {
return;
}
blockUserSignals();
ACQUIRE_LOCK(&sched_mutex);
handler = deRefStablePtr((StgStablePtr)console_handler);
while (stg_pending_events > 0) {
stg_pending_events--;
scheduleThread(cap,
createIOThread(cap,
RtsFlags.GcFlags.initialStkSize,
rts_apply(cap,
(StgClosure *)handler,
rts_mkInt(cap,
stg_pending_buf[stg_pending_events]))));
}
RELEASE_LOCK(&sched_mutex);
unblockUserSignals();
}
NET_API_STATUS
Parse(
IN DWORD argc,
IN LPTSTR argv[]
)
/*++
Routine Description :
Wrapper function of the real worker Parse2 function.
Arguments :
argc : argument count
argv : argument string array pointer.
Return Value :
return NO_ERROR if successfully parse parameter
ERROR_INVALID_PARAMETER, otherwise
--*/
{
NET_API_STATUS ApiStatus;
LPNET_CONFIG_HANDLE ConfigHandle;
// Get read-write lock for config data. (The lock is for the in-memory
// version of the data, which we're going to set.)
ACQUIRE_LOCK( ReplGlobalConfigLock );
// Open the config file (nt.cfg)
ApiStatus = NetpOpenConfigData(
& ConfigHandle,
NULL, // local machine
SECT_NT_REPLICATOR, // section name
TRUE); // read-only
if (ApiStatus != NO_ERROR) {
NetpKdPrint(( "[REPL] Parse() can't open config section.\n" ));
ReplFinish(
SERVICE_UIC_CODE(
SERVICE_UIC_SYSTEM,
ApiStatus),
NULL);
RELEASE_LOCK( ReplGlobalConfigLock );
return( ApiStatus );
}
ApiStatus = Parse2(argc, argv, ConfigHandle);
// close config file ..
(void) NetpCloseConfigData( ConfigHandle );
RELEASE_LOCK( ReplGlobalConfigLock );
return( ApiStatus );
}
void
startTicker(void)
{
ACQUIRE_LOCK(&mutex);
stopped = 0;
signalCondition(&start_cond);
RELEASE_LOCK(&mutex);
}
static void *itimer_thread_func(void *_handle_tick)
{
TickProc handle_tick = _handle_tick;
uint64_t nticks;
int timerfd = -1;
#if defined(USE_TIMERFD_FOR_ITIMER) && USE_TIMERFD_FOR_ITIMER
struct itimerspec it;
it.it_value.tv_sec = TimeToSeconds(itimer_interval);
it.it_value.tv_nsec = TimeToNS(itimer_interval) % 1000000000;
it.it_interval = it.it_value;
timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_CLOEXEC);
if (timerfd == -1) {
sysErrorBelch("timerfd_create");
stg_exit(EXIT_FAILURE);
}
if (!TFD_CLOEXEC) {
fcntl(timerfd, F_SETFD, FD_CLOEXEC);
}
if (timerfd_settime(timerfd, 0, &it, NULL)) {
sysErrorBelch("timerfd_settime");
stg_exit(EXIT_FAILURE);
}
#endif
while (!exited) {
if (USE_TIMERFD_FOR_ITIMER) {
if (read(timerfd, &nticks, sizeof(nticks)) != sizeof(nticks)) {
if (errno != EINTR) {
sysErrorBelch("Itimer: read(timerfd) failed");
}
}
} else {
if (usleep(TimeToUS(itimer_interval)) != 0 && errno != EINTR) {
sysErrorBelch("usleep(TimeToUS(itimer_interval) failed");
}
}
// first try a cheap test
if (stopped) {
ACQUIRE_LOCK(&mutex);
// should we really stop?
if (stopped) {
waitCondition(&start_cond, &mutex);
}
RELEASE_LOCK(&mutex);
} else {
handle_tick(0);
}
}
if (USE_TIMERFD_FOR_ITIMER)
close(timerfd);
closeMutex(&mutex);
closeCondition(&start_cond);
return NULL;
}
bool
waitCondition ( Condition* pCond, Mutex* pMut )
{
RELEASE_LOCK(pMut);
WaitForSingleObject(*pCond, INFINITE);
/* Hmm..use WaitForMultipleObjects() ? */
ACQUIRE_LOCK(pMut);
return true;
}
int hs_spt_keys(StgPtr keys[], int szKeys) {
if (spt) {
ACQUIRE_LOCK(&spt_lock);
const int ret = keysHashTable(spt, (StgWord*)keys, szKeys);
RELEASE_LOCK(&spt_lock);
return ret;
} else
return 0;
}
void hs_spt_remove(StgWord64 key[2]) {
if (spt) {
ACQUIRE_LOCK(&spt_lock);
StgStablePtr* entry = removeHashTable(spt, (StgWord)key, NULL);
RELEASE_LOCK(&spt_lock);
if (entry)
freeSptEntry(entry);
}
}
StgPtr hs_spt_lookup(StgWord64 key[2]) {
if (spt) {
ACQUIRE_LOCK(&spt_lock);
const StgStablePtr * entry = lookupHashTable(spt, (StgWord)key);
RELEASE_LOCK(&spt_lock);
const StgPtr ret = entry ? deRefStablePtr(*entry) : NULL;
return ret;
} else
return NULL;
}
static void vtrace_stderr(char *msg, va_list ap)
{
ACQUIRE_LOCK(&trace_utx);
tracePreface();
vdebugBelch(msg,ap);
debugBelch("\n");
RELEASE_LOCK(&trace_utx);
}
static void
updateThreadLabel(StgWord key, void *data)
{
removeThreadLabel(key);
ACQUIRE_LOCK(&threadLabels_mutex);
insertHashTable(threadLabels,key,data);
RELEASE_LOCK(&threadLabels_mutex);
}
StgWord
lookupStableName(StgPtr p)
{
StgWord res;
initStablePtrTable();
ACQUIRE_LOCK(&stable_mutex);
res = lookupStableName_(p);
RELEASE_LOCK(&stable_mutex);
return res;
}
static void vtraceCap_stderr(Capability *cap, char *msg, va_list ap)
{
ACQUIRE_LOCK(&trace_utx);
tracePreface();
debugBelch("cap %d: ", cap->no);
vdebugBelch(msg,ap);
debugBelch("\n");
RELEASE_LOCK(&trace_utx);
}
BOOLEAN SRVFASTCALL
SrvCheckAndReferenceEndpoint (
PENDPOINT Endpoint
)
/*++
Routine Description:
This function atomically verifies that an endpoint is active and
increments the reference count on the endpoint if it is.
Arguments:
Endpoint - Address of endpoint
Return Value:
BOOLEAN - Returns TRUE if the endpoint is active, FALSE otherwise.
--*/
{
PAGED_CODE( );
//
// Acquire the lock that guards the endpoint's state field.
//
ACQUIRE_LOCK( &SrvEndpointLock );
//
// If the endpoint is active, reference it and return TRUE.
//
if ( GET_BLOCK_STATE(Endpoint) == BlockStateActive ) {
SrvReferenceEndpoint( Endpoint );
RELEASE_LOCK( &SrvEndpointLock );
return TRUE;
}
//
// The endpoint isn't active. Return FALSE.
//
RELEASE_LOCK( &SrvEndpointLock );
return FALSE;
} // SrvCheckAndReferenceEndpoint
void
freeThreadLabelTable(void)
{
ACQUIRE_LOCK(&threadLabels_mutex);
if (threadLabels != NULL) {
freeHashTable(threadLabels, stgFree);
threadLabels = NULL;
}
RELEASE_LOCK(&threadLabels_mutex);
}
void *
lookupThreadLabel(StgWord key)
{
void * result;
ACQUIRE_LOCK(&threadLabels_mutex);
result = lookupHashTable(threadLabels,key);
RELEASE_LOCK(&threadLabels_mutex);
return result;
}
StgStablePtr
getStablePtr(StgPtr p)
{
StgWord sn;
initStablePtrTable();
ACQUIRE_LOCK(&stable_mutex);
sn = lookupStableName_(p);
stable_ptr_table[sn].ref++;
RELEASE_LOCK(&stable_mutex);
return (StgStablePtr)(sn);
}
void
ioManagerDie (void)
{
sendIOManagerEvent(IO_MANAGER_DIE);
// IO_MANAGER_DIE must be idempotent, as it is called
// repeatedly by shutdownCapability(). Try conc059(threaded1) to
// illustrate the problem.
ACQUIRE_LOCK(&event_buf_mutex);
io_manager_event = INVALID_HANDLE_VALUE;
RELEASE_LOCK(&event_buf_mutex);
// ToDo: wait for the IO manager to pick up the event, and
// then release the Event and Mutex objects we've allocated.
}
void
removeThreadLabel(StgWord key)
{
ACQUIRE_LOCK(&threadLabels_mutex);
void * old = NULL;
if ((old = lookupHashTable(threadLabels,key))) {
removeHashTable(threadLabels,key,old);
stgFree(old);
}
RELEASE_LOCK(&threadLabels_mutex);
}
void RESET_EVENT( EVENT_HNDL* pEvent )
{
DWORD LockFlag;
// clear the event flag
ACQUIRE_LOCK( &pEvent->FlagLock, LockFlag );
pEvent->SetFlag = FALSE;
// empty out the queue
while ( waitqueue_active( &pEvent->WaitQue ) )
interruptible_sleep_on( &pEvent->WaitQue );
RELEASE_LOCK( &pEvent->FlagLock, LockFlag );
}
static void traceSchedEvent_stderr (Capability *cap, EventTypeNum tag,
StgTSO *tso,
StgWord info1 STG_UNUSED,
StgWord info2 STG_UNUSED)
{
ACQUIRE_LOCK(&trace_utx);
tracePreface();
switch (tag) {
case EVENT_CREATE_THREAD: // (cap, thread)
debugBelch("cap %d: created thread %lu\n",
cap->no, (lnat)tso->id);
break;
case EVENT_RUN_THREAD: // (cap, thread)
debugBelch("cap %d: running thread %lu (%s)\n",
cap->no, (lnat)tso->id, what_next_strs[tso->what_next]);
break;
case EVENT_THREAD_RUNNABLE: // (cap, thread)
debugBelch("cap %d: thread %lu appended to run queue\n",
cap->no, (lnat)tso->id);
break;
case EVENT_MIGRATE_THREAD: // (cap, thread, new_cap)
debugBelch("cap %d: thread %lu migrating to cap %d\n",
cap->no, (lnat)tso->id, (int)info1);
break;
case EVENT_THREAD_WAKEUP: // (cap, thread, info1_cap)
debugBelch("cap %d: waking up thread %lu on cap %d\n",
cap->no, (lnat)tso->id, (int)info1);
break;
case EVENT_STOP_THREAD: // (cap, thread, status)
if (info1 == 6 + BlockedOnBlackHole) {
debugBelch("cap %d: thread %lu stopped (blocked on black hole owned by thread %lu)\n",
cap->no, (lnat)tso->id, (long)info2);
} else {
debugBelch("cap %d: thread %lu stopped (%s)\n",
cap->no, (lnat)tso->id, thread_stop_reasons[info1]);
}
break;
case EVENT_SHUTDOWN: // (cap)
debugBelch("cap %d: shutting down\n", cap->no);
break;
default:
debugBelch("cap %d: thread %lu: event %d\n\n",
cap->no, (lnat)tso->id, tag);
break;
}
RELEASE_LOCK(&trace_utx);
}
