Signals not being masked/becoming unmasked during a critical section (POSIX pthreads)? - c

Question

Preface - i use "task" and "thread" interchangeably here even though i know they are different. In my program a task is wrapped in a thread - the latter constantly waiting for an cond event to awaken the task.
During a context switch, the ContextSwitchHandler checks the incoming task for invalid info. However, it is returning a failure for tasks even when they have valid data.
By putting an infinite loop inside the task-data check, and then placing another in the signal handler, i can see that signals are interrupting this execution - even though i have supposedly masked signals before entering the ContextSwitchHandler.
This where the context switch starts:
void vPortYieldWithinAPI( void )
{
portUnsignedBaseType xInterruptsAlreadyMasked;
portcompatASSERT_PRIVILEGED_MODE(); // currently defined as nothing
xInterruptsAlreadyMasked = uxPortSetInterruptMaskFromISR();
vPortSwitchContext();
vPortClearInterruptMaskFromISR( xInterruptsAlreadyMasked );
}
and here is the implementation of the signal mask function - xPortIsrNormalSignalMask is a full signal mask except SIGINT being unblocked, as is shown further down.
portUnsignedBaseType uxPortSetInterruptMaskFromISR( void )
{
sigset_t xOriginalMask;
portUnsignedBaseType uxOriginalPriority;
pthread_sigmask( SIG_BLOCK, &xPortIsrNormalSignalMask, &xOriginalMask );
if( sigismember( &xOriginalMask, configPORT_SIGNAL_FOR_IRQ ) )
{
uxOriginalPriority = 1U; /* interrupts were originally masked */
}
else
{
uxOriginalPriority = 0U; /* interrupts were originally unmasked */
}
return uxOriginalPriority;
}
During the context switch, the task validity check is performed (signals should still be masked at this point).
KERNEL_FUNCTION portBaseType xPortIsTaskHandleValid( portTaskHandleType xTaskToCheck )
{
portBaseType xReturn;
const xTCB *pxTCB;
static portUInt32Type ulFailCount = 0;
/* THIS FUNCTION MUST ONLY BE CALLED FROM WITHIN A CRITICAL SECTION. */
/* First, ensure we've not been given a NULL pointer to check. */
if( NULL == xTaskToCheck )
{
xReturn = pdFALSE;
}
else
{
/* Set a pointer to the TCB buffer. */
pxTCB = ( const xTCB * ) xTaskToCheck;
if( ( portDataAddressType )( pxTCB->pxStackLimit ) != ~( pxTCB->uxStackLimitMirror ) )
{
/* The stack limit mirror is not as expected. */
xReturn = pdFALSE;
}
else if( ( portDataAddressType )( pxTCB->pxTopOfStack ) != ~( pxTCB->uxTopOfStackMirror ) )
{
/* The top of stack mirror is not as expected. */
xReturn = pdFALSE;
/* I have tried adding another signal mask here before i enter the while
* loop, but this also doesn't seem to prevent the SIGALARM from firing. */
sigset_t set;
sigemptyset(&set); /* initialize the signal set */
sigaddset(&set, SIGALRM); /* add SIGALRM to the set */
pthread_sigmask( SIG_BLOCK, &set, NULL );
/* */
while( 1 )
{
/* put a breakpoint here... to check if we are getting interrupts */
xReturn++;
xReturn--;
}
}
...
return xReturn;
}
What im finding is the incoming task fails this second check, even though when i inspect the data the mirror is indeed correct for the stack address. So my belief is that interrupts are occurring and messing with the statement.
As i said, if i place a breakpoint in this while loop, run to that point and the put another in the signal handler, i can still see signals occurring.
My configuration of the signals and signal handlers is as follows:
portBaseType iPortIsrSetupDefaultThreadSignalMask( void )
{
portBaseType xReturn;
/* Disable all signals except SIGINT. From main thread, other threads
* should inherit this. We leave SIGINT so we can stop it. */
xReturn = ( portBaseType )sigfillset( &xPortIsrNormalSignalMask );
if( 0 == xReturn )
{
xReturn = ( portBaseType )sigdelset( &xPortIsrNormalSignalMask, SIGINT );
}
if( 0 == xReturn )
{
xReturn = ( portBaseType )pthread_sigmask( SIG_SETMASK, &xPortIsrNormalSignalMask, &xPortOriginalSignalMask );
}
return xReturn;
}
/*---------------------------------------------------------------------------*/
void vPortInitialiseINTC( void )
{
struct sigaction xSigActIRQ, xTestSigActIRQ;
if( iPortIsrSetupDefaultThreadSignalMask() != 0 )
{
portERRORHOOKSTR( NULL, "Failed to set up default signal mask", errINVALID_PARAMETERS );
}
xSigActIRQ.sa_flags = SA_SIGINFO;
xSigActIRQ.sa_sigaction = vPortIsrIRQHandler;
// we set two sigmasks, one here and one in iPortIsrSetupDefaultThreadSignalMask(), which one is actually masking irq's?
sigemptyset( &xSigActIRQ.sa_mask );
if( sigaction( configPORT_SIGNAL_FOR_IRQ, &xSigActIRQ, NULL ) )
{
portERRORHOOKSTR( NULL, "Failed to set up simulated interrupt system", errINVALID_PARAMETERS );
}
}
/*---------------------------------------------------------------------------*/
portWEAK_FUNCTION void vApplicationSetupTickInterruptHook( portUInt32Type ulClockHz, portUInt32Type ulRateHz )
{
struct sigevent xTimerEv;
struct itimerspec xSysTickTimerSpec;
int iSysRet;
long lNanosecondsPerTick;
( void )ulClockHz; /* Unused in this port */
portcompatASSERT_PRIVILEGED_MODE();
lNanosecondsPerTick = ( long ) PORT_ONE_SECOND_IN_NS / ( long ) ulRateHz;
vPortDisableInterrupts();
xTimerEv.sigev_notify = SIGEV_SIGNAL;
xTimerEv.sigev_signo = configPORT_SIGNAL_FOR_IRQ;
xTimerEv.sigev_value.sival_int = configPORT_SYSTICK_INTERRUPT_NUM; // defined as 14, same as SIGALARM
xTimerEv.sigev_notify_function = NULL;
iSysRet = timer_create( CLOCK_MONOTONIC, &xTimerEv, &xPortSysTickTimer );
if(iSysRet)
{
portERRORHOOKSTR( NULL, "Failed to create tick timer", errINVALID_PARAMETERS );
}
xSysTickTimerSpec.it_interval.tv_sec = 0;
xSysTickTimerSpec.it_interval.tv_nsec = lNanosecondsPerTick;
xSysTickTimerSpec.it_value.tv_sec = 0;
xSysTickTimerSpec.it_value.tv_nsec = lNanosecondsPerTick;
iSysRet = timer_settime( xPortSysTickTimer, 0, &xSysTickTimerSpec, NULL );
if(iSysRet)
{
portERRORHOOKSTR( NULL, "failed to set & start tick timer", errINVALID_PARAMETERS );
}
}
Is there some point in my configuration that isnt setting up the signal masks properly? Signals and threads are quite new to me so please feel free to ask for extra info or clarification if required.
Thank you