LW_NTSTATUS
LwRtlSetTaskUnixSignal(
LW_IN PLW_TASK pTask,
LW_IN int Sig,
LW_IN LW_BOOLEAN bSubscribe
)
{
NTSTATUS status = STATUS_SUCCESS;
if (bSubscribe && !pTask->pUnixSignal)
{
status = LW_RTL_ALLOCATE_AUTO(&pTask->pUnixSignal);
GOTO_ERROR_ON_STATUS(status);
}
status = RegisterTaskUnixSignal(pTask, Sig, bSubscribe);
GOTO_ERROR_ON_STATUS(status);
error:
return status;
}
static
NTSTATUS
ProcessRunnable(
PEPOLL_THREAD pThread,
PRING pRunnable,
PRING pTimed,
PRING pWaiting,
LONG64 llNow
)
{
NTSTATUS status = STATUS_SUCCESS;
ULONG ulTicks = MAX_TICKS;
PLW_TASK pTask = NULL;
PLW_TASK_GROUP pGroup = NULL;
PRING pRing = NULL;
PRING pNext = NULL;
/* We are guaranteed to run each task at least once. If tasks remain
on the runnable list by yielding, we will continue to run them
all in a round robin until our ticks are depleted. */
while (ulTicks && !RingIsEmpty(pRunnable))
{
for (pRing = pRunnable->pNext; pRing != pRunnable; pRing = pNext)
{
pNext = pRing->pNext;
pTask = LW_STRUCT_FROM_FIELD(pRing, EPOLL_TASK, QueueRing);
RunTask(pTask, llNow);
if (ulTicks)
{
ulTicks--;
}
if (pTask->EventWait != LW_TASK_EVENT_COMPLETE)
{
/* Task is still waiting to be runnable, update events in epoll set */
status = UpdateEventWait(
pTask,
pThread->EpollFd
);
GOTO_ERROR_ON_STATUS(status);
if (pTask->EventWait & LW_TASK_EVENT_YIELD)
{
/* Task is yielding. Set YIELD in its trigger arguments and
and leave it on the runnable list for the next iteration */
pTask->EventArgs |= LW_TASK_EVENT_YIELD;
}
else if (pTask->EventWait & LW_TASK_EVENT_TIME)
{
/* If the task is waiting for a timeout, insert it into the timed queue */
RingRemove(&pTask->QueueRing);
InsertTimedQueue(pTimed, pTask);
}
else
{
/* Otherwise, put it in the generic waiting queue */
RingRemove(&pTask->QueueRing);
RingEnqueue(pWaiting, &pTask->QueueRing);
}
}
else
{
/* Task is complete */
RingRemove(&pTask->QueueRing);
/* Turn off any fd in the epoll set */
if (pTask->Fd >= 0)
{
status = LwRtlSetTaskFd(pTask, pTask->Fd, 0);
GOTO_ERROR_ON_STATUS(status);
}
/* Unsubscribe task from any UNIX signals */
if (pTask->pUnixSignal)
{
RegisterTaskUnixSignal(pTask, 0, FALSE);
}
LOCK_POOL(pThread->pPool);
pThread->ulLoad--;
UNLOCK_POOL(pThread->pPool);
pGroup = pTask->pGroup;
/* If task was in a task group, remove it and notify anyone waiting
on the group */
if (pGroup)
{
LOCK_GROUP(pGroup);
pTask->pGroup = NULL;
RingRemove(&pTask->GroupRing);
pthread_cond_broadcast(&pGroup->Event);
UNLOCK_GROUP(pGroup);
}
LOCK_THREAD(pThread);
if (--pTask->ulRefCount)
{
/* The task still has a reference, so mark it as completed
and notify anyone waiting on it */
pTask->EventSignal = TASK_COMPLETE_MASK;
pthread_cond_broadcast(&pThread->Event);
UNLOCK_THREAD(pThread);
}
else
{
/* We held the last reference to the task, so delete it */
RingRemove(&pTask->SignalRing);
UNLOCK_THREAD(pThread);
TaskDelete(pTask);
}
}
}
}
error:
return status;
}
static
VOID
ProcessRunnable(
PKQUEUE_THREAD pThread,
PKQUEUE_COMMANDS pCommands,
PRING pRunnable,
PRING pTimed,
PRING pWaiting,
LONG64 llNow
)
{
ULONG ulTicks = MAX_TICKS;
PLW_TASK pTask = NULL;
PLW_TASK_GROUP pGroup = NULL;
PRING pRing = NULL;
PRING pNext = NULL;
/* We are guaranteed to run each task at least once. If tasks remain
on the runnable list by yielding, we will continue to run them
all in a round robin until our ticks are depleted. */
while (ulTicks && !RingIsEmpty(pRunnable))
{
for (pRing = pRunnable->pNext; pRing != pRunnable; pRing = pNext)
{
pNext = pRing->pNext;
pTask = LW_STRUCT_FROM_FIELD(pRing, KQUEUE_TASK, QueueRing);
RunTask(pTask, llNow);
if (ulTicks)
{
ulTicks--;
}
if (pTask->EventWait != LW_TASK_EVENT_COMPLETE)
{
if (pTask->EventWait & LW_TASK_EVENT_YIELD)
{
/* Task is yielding. Set the YIELD flag and
leave it on the runnable list for the next iteration. */
pTask->EventArgs |= LW_TASK_EVENT_YIELD;
}
else
{
/* Task is still waiting on events, update kqueue */
UpdateEventWait(pCommands, pTask);
if (pTask->EventWait & LW_TASK_EVENT_TIME)
{
/* If the task is waiting for a timeout,
insert it into the timed queue */
RingRemove(&pTask->QueueRing);
InsertTimedQueue(pTimed, pTask);
}
else
{
/* Otherwise, put it in the generic waiting queue */
RingRemove(&pTask->QueueRing);
RingEnqueue(pWaiting, &pTask->QueueRing);
}
}
}
else
{
/* Task is complete */
RingRemove(&pTask->QueueRing);
/* Remove any associated events from the kqueue */
if (pTask->Fd >= 0)
{
(void) LwRtlSetTaskFd(pTask, pTask->Fd, 0);
}
/* Unsubscribe task from any UNIX signals */
if (pTask->pUnixSignal)
{
RegisterTaskUnixSignal(pTask, 0, FALSE);
}
LOCK_POOL(pThread->pPool);
pThread->ulLoad--;
UNLOCK_POOL(pThread->pPool);
pGroup = pTask->pGroup;
/* If task was in a task group, remove it and notify anyone waiting
on the group */
if (pGroup)
{
LOCK_GROUP(pGroup);
pTask->pGroup = NULL;
RingRemove(&pTask->GroupRing);
pthread_cond_broadcast(&pGroup->Event);
UNLOCK_GROUP(pGroup);
}
LOCK_THREAD(pThread);
if (--pTask->ulRefCount)
{
/* The task still has a reference, so mark it as completed
and notify anyone waiting on it */
pTask->EventSignal = TASK_COMPLETE_MASK;
pthread_cond_broadcast(&pThread->Event);
UNLOCK_THREAD(pThread);
}
else
{
/* We held the last reference to the task, so delete it */
RingRemove(&pTask->SignalRing);
UNLOCK_THREAD(pThread);
TaskDelete(pTask);
}
}
}
}
/* Update kevent commands for yielding tasks */
for (pRing = pRunnable->pNext; pRing != pRunnable; pRing = pRing->pNext)
{
pTask = LW_STRUCT_FROM_FIELD(pRing, KQUEUE_TASK, QueueRing);
if (pTask->EventArgs & LW_TASK_EVENT_YIELD)
{
UpdateEventWait(pCommands, pTask);
}
}
}
static
NTSTATUS
EventLoop(
PSELECT_THREAD pThread
)
{
NTSTATUS status = STATUS_SUCCESS;
RING tasks;
RING runnable;
PRING pRing = NULL;
PRING pNext = NULL;
PSELECT_TASK pTask = NULL;
CLOCK clock = {0};
LONG64 llNow;
LONG64 llNextDeadline;
fd_set readSet;
fd_set writeSet;
fd_set exceptSet;
int ready = 0;
int nfds = 0;
char c = 0;
int res = 0;
BOOLEAN bShutdown = FALSE;
PLW_TASK_GROUP pGroup = NULL;
BOOLEAN bYielding = FALSE;
RingInit(&tasks);
RingInit(&runnable);
FD_ZERO(&readSet);
FD_ZERO(&writeSet);
FD_ZERO(&exceptSet);
LOCK_THREAD(pThread);
while (!bShutdown || !RingIsEmpty(&tasks))
{
/* Reset variables */
llNextDeadline = 0;
nfds = 0;
bYielding = FALSE;
/* Get current time for this iteration */
GOTO_ERROR_ON_STATUS(status = ClockGetMonotonicTime(&clock, &llNow));
/* Figure out which tasks are runnable */
for (pRing = tasks.pNext; pRing != &tasks; pRing = pNext)
{
pNext = pRing->pNext;
pTask = LW_STRUCT_FROM_FIELD(pRing, SELECT_TASK, EventRing);
/* Update trigger set with results from select() */
UpdateTriggerSet(
pTask,
&readSet,
&writeSet,
&exceptSet,
llNow);
/* Schedule tasks to run if they have been triggered or were yielding */
if ((pTask->TriggerWait & LW_TASK_EVENT_YIELD) ||
((pTask->TriggerWait | LW_TASK_EVENT_EXPLICIT) & pTask->TriggerSet))
{
/* Put task on a separate list to run its trigger function */
RingRemove(&pTask->EventRing);
RingInsertBefore(&runnable, &pTask->EventRing);
/* Update the trigger args with the trigger set */
pTask->TriggerArgs |= pTask->TriggerSet;
/* Turn off bits (except cancel) now that we have copied them */
pTask->TriggerSet &= (LW_TASK_EVENT_CANCEL);
}
else
{
/* Update select parameters to wait for task to trigger */
UpdateTriggerWait(
pTask,
&nfds,
&readSet,
&writeSet,
&exceptSet,
&llNextDeadline);
}
}
UNLOCK_THREAD(pThread);
for (pRing = runnable.pNext; pRing != &runnable; pRing = pNext)
{
pNext = pRing->pNext;
pTask = LW_STRUCT_FROM_FIELD(pRing, SELECT_TASK, EventRing);
GOTO_ERROR_ON_STATUS(status = TaskProcessTrigger(pTask, llNow));
if (pTask->TriggerWait != 0)
{
/* Task is still waiting to be runnable, update select parameters
and put it back in the task list */
UpdateTriggerWait(
pTask,
&nfds,
&readSet,
&writeSet,
&exceptSet,
&llNextDeadline);
if (pTask->TriggerWait & LW_TASK_EVENT_YIELD)
{
/* Task is yielding temporarily. Set the yield flag on
its trigger arguments. Leave it on the runnable list */
pTask->TriggerArgs |= LW_TASK_EVENT_YIELD;
}
else
{
RingRemove(&pTask->EventRing);
RingInsertBefore(&tasks, &pTask->EventRing);
}
}
else
{
/* Task is complete, notify and remove from task group
if it is in one */
RingRemove(&pTask->EventRing);
/* Unregister task from global signal loop */
if (pTask->pUnixSignal)
{
RegisterTaskUnixSignal(pTask, 0, FALSE);
}
pGroup = pTask->pGroup;
if (pGroup)
{
LOCK_GROUP(pGroup);
pTask->pGroup = NULL;
RingRemove(&pTask->GroupRing);
pthread_cond_broadcast(&pGroup->Event);
UNLOCK_GROUP(pGroup);
}
LOCK_THREAD(pThread);
if (--pTask->ulRefCount)
{
pTask->TriggerSet = TASK_COMPLETE_MASK;
pthread_cond_broadcast(&pThread->Event);
UNLOCK_THREAD(pThread);
}
else
{
UNLOCK_THREAD(pThread);
TaskDelete(pTask);
}
}
}
if (!RingIsEmpty(&runnable))
{
/* We have runnable tasks that are yielding. Move them
back to the event list and note the fact. */
bYielding = TRUE;
RingMove(&runnable, &tasks);
}
if (!bShutdown)
{
/* Also wait for a poke on the thread's signal fd */
FD_SET(pThread->SignalFds[0], &readSet);
if (pThread->SignalFds[0] >= nfds)
{
nfds = pThread->SignalFds[0] + 1;
}
}
if (nfds)
{
/* If there are still runnable tasks due to
LW_TASK_EVENT_YIELD, set the next deadline
to now so we wake immediately. This gives other
tasks the chance to become runnable before we
proceed */
if (bYielding)
{
llNextDeadline = llNow;
}
/* Wait for a task to be runnable */
GOTO_ERROR_ON_STATUS(status = Sleep(
&clock,
&llNow,
nfds,
&readSet,
&writeSet,
&exceptSet,
llNextDeadline,
&ready));
}
LOCK_THREAD(pThread);
/* Check for a signal to the thread */
if (FD_ISSET(pThread->SignalFds[0], &readSet))
{
FD_CLR(pThread->SignalFds[0], &readSet);
pThread->bSignalled = FALSE;
res = read(pThread->SignalFds[0], &c, sizeof(c));
assert(res == sizeof(c));
/* Move all tasks in queue into local task list */
RingMove(&pThread->Tasks, &tasks);
if (pThread->bShutdown && !bShutdown)
{
bShutdown = pThread->bShutdown;
/* Cancel all outstanding tasks */
for (pRing = tasks.pNext; pRing != &tasks; pRing = pRing->pNext)
{
pTask = LW_STRUCT_FROM_FIELD(pRing, SELECT_TASK, EventRing);
pTask->TriggerSet |= LW_TASK_EVENT_CANCEL | LW_TASK_EVENT_EXPLICIT;
}
}
}
}
error:
UNLOCK_THREAD(pThread);
return status;
}
NTSTATUS
RegisterTaskUnixSignal(
LW_IN PLW_TASK pTask,
LW_IN int Sig,
LW_IN LW_BOOLEAN bSubscribe
)
{
NTSTATUS status = STATUS_SUCCESS;
size_t i = 0;
PRING pBase = NULL;
PRING pRing = NULL;
PLW_SIGNAL_SUBSCRIPTION pExisting = NULL;
PLW_SIGNAL_SUBSCRIPTION pSub = NULL;
struct sigaction action;
#ifdef SIGRTMAX
int maxSig = SIGRTMAX;
#else
int maxSig = SIGUSR2;
#endif
if (Sig == 0)
{
for (i = 1; i < maxSig + 1; i++)
{
status = RegisterTaskUnixSignal(pTask, (int) i, bSubscribe);
if (status)
{
return status;
}
}
return STATUS_SUCCESS;
}
LOCK_SIGNAL();
if (Sig > maxSig || Sig < 0)
{
status = STATUS_INVALID_PARAMETER;
GOTO_ERROR_ON_STATUS(status);
}
if (!gSignal.pSubscribers)
{
status = LW_RTL_ALLOCATE_ARRAY_AUTO(&gSignal.pSubscribers, maxSig + 1);
GOTO_ERROR_ON_STATUS(status);
for (i = 0; i < maxSig + 1; i++)
{
RingInit(&gSignal.pSubscribers[i]);
}
gSignal.maxSig = maxSig;
}
pBase = &gSignal.pSubscribers[Sig];
for (pRing = pBase->pNext; pRing != pBase; pRing = pRing->pNext)
{
pSub = LW_STRUCT_FROM_FIELD(pRing, LW_SIGNAL_SUBSCRIPTION, Ring);
if (pSub->pTask == pTask)
{
pExisting = pSub;
break;
}
}
if (bSubscribe && !pExisting)
{
if (Sig != SIGINT)
{
memset(&action, 0, sizeof(action));
/* Make sure there is a dummy handler for the signal
so it is actually delivered to the process */
action.sa_handler = DummyHandler;
action.sa_flags = 0;
if (sigaction(Sig, &action, NULL) < 0)
{
status = LwErrnoToNtStatus(errno);
GOTO_ERROR_ON_STATUS(status);
}
}
status = LW_RTL_ALLOCATE_AUTO(&pSub);
GOTO_ERROR_ON_STATUS(status);
pSub->pTask = pTask;
pSub->ucRefCount = 1;
RingInit(&pSub->Ring);
RingInit(&pSub->DispatchRing);
RingEnqueue(pBase, &pSub->Ring);
RetainTask(pTask);
}
else if (!bSubscribe && pExisting)
{
RingRemove(&pExisting->Ring);
if (--pExisting->ucRefCount == 0)
{
LwRtlReleaseTask(&pExisting->pTask);
LwRtlMemoryFree(pExisting);
}
}
error:
UNLOCK_SIGNAL();
return status;
}