信号处理函数中未阻塞POSIX定时器信号。

Question

我正在设置一个POSIX计时器，以在给定速率下调用函数。我设置了信号处理程序并初始化了计时器等等...一切都正常工作。然而，根据我所读到的所有文档，在信号处理程序中我不应该收到来自计时器的信号（它应该自动被阻止）。更进一步地说，我甚至将sigaction的sa_mask设置为阻止所有信号...但我仍然会多次调用信号处理程序...

设置处理程序：

    // establish the signal handler
    sigset_t blockMask;
    struct sigaction sigact;

    sigfillset(&blockMask);
    //sigemptyset(&blockMask);
    sigact.sa_flags = SA_SIGINFO;
    sigact.sa_sigaction = callbackIn;
    sigact.sa_mask = blockMask;
    if( sigaction(ElmoSynchronizer::NEXT_RT_SIGNAL_NUMBER, &sigact, NULL) == -1 )
    {
        return CanStatus( CanStatus::SYSTEM_ERROR, __FUNCTION__, "Couldn't establish signal handler for timer" );   
    }

    // create the timer
    struct sigevent sev;
    sev.sigev_notify = SIGEV_SIGNAL;
    sev.sigev_signo = ElmoSynchronizer::NEXT_RT_SIGNAL_NUMBER;
    sev.sigev_value.sival_ptr = this;
    if( timer_create(CLOCK_REALTIME, &sev, timerIn) == -1 )
    {
        return CanStatus( CanStatus::SYSTEM_ERROR, __FUNCTION__, "Couldn't create POSIX timer for timer" );
    }

    // start the timer
    struct itimerspec timerSpec;
    timerSpec.it_value = firstExecTime;
    timerSpec.it_interval = ElmoSynchronizer::getTimespecFromDouble(1.0/rate_hz);
    if( timer_settime(*timerIn, TIMER_ABSTIME, &timerSpec, NULL) == -1 )
    {
        return CanStatus( CanStatus::SYSTEM_ERROR, __FUNCTION__, "Couldn't start timer for timer" );
    }

回调函数（是的，我知道在信号处理程序中使用printf是不好的）：

 void ElmoSynchronizer::rootPvtCallback(int sig, siginfo_t *si, void *uc)
{

    // get a pointer to the ElmoSynchronizer calling this
    ElmoSynchronizer *elmoSync = (ElmoSynchronizer*)si->si_value.sival_ptr;

    struct timespec startTime;
    clock_gettime(CLOCK_REALTIME, &startTime);
    uint32_t expectedTime_us = elmoSync->getMasterClockTimeFromTimespec_us(elmoSync->m_pvtSupplyStartTime) + ((elmoSync->m_updateIteration * elmoSync->m_elmoUpdatePeriod_ms) * 1000);
    uint32_t actualTime_us = elmoSync->getMasterClockTimeFromTimespec_us(startTime);
    uint32_t currIter = elmoSync->m_updateIteration+1;

    printf("---> PVT update - iteration %u @ %u\n", currIter, elmoSync->getMasterClockTimeFromTimespec_us(startTime));
    fflush(stdout);

    // iterate through all of our callbacks and call them!
    for( unsigned int i = 0; i < elmoSync->m_elmos.size(); i++ )
    {
        // get the position/velocity pair
        posVelPair_t pv = elmoSync->m_elmos[i].callback(elmoSync->m_elmos[i].elmo);

        // now add the point to the elmo
        elmoSync->m_elmos[i].elmo->addPvtPoints( pv.position_cnts, pv.velocity_cps, elmoSync->m_elmoUpdatePeriod_ms );

    }
    elmoSync->m_updateIteration++;

    if( elmoSync->m_updateIteration == 250 )
    {
        usleep(elmoSync->m_elmoUpdatePeriod_ms*4000);
    }

    // make sure we executed fast enough   
    struct timespec endTime;
    clock_gettime(CLOCK_REALTIME, &endTime);
    double totalCallbackTime_s = getSecondsFromTimespec(ElmoSynchronizer::ts_subtract(endTime, startTime));
    if( totalCallbackTime_s > (elmoSync->m_elmoUpdatePeriod_ms * 1.0E-3) )
    {
        //ROS_WARN("PVT update - Callback execution took longer than update period! %lfs actual / %lfs period", totalCallbackTime_s, (elmoSync->m_elmoUpdatePeriod_ms * 1.0E-3));
        //overflowedRootPvtCallbackPeriod = true;
    }

    printf("<--- PVT update - iteration %u @ %u\n", currIter, elmoSync->getMasterClockTimeFromTimespec_us(endTime));
    fflush(stdout);

    /*
    printf("PVT update - iteration: %u actual: %u expected: %u diff: %u cbTime: %u\n",
        elmoSync->m_updateIteration, actualTime_us, expectedTime_us, actualTime_us-expectedTime_us, (uint32_t)(totalCallbackTime_s * 1.0E6));
    fflush(stdout);
    */
}

输出：

---> PVT update - iteration 248 @ 13315103
<--- PVT update - iteration 248 @ 13315219
---> PVT update - iteration 249 @ 13346107
<--- PVT update - iteration 249 @ 13346199
---> PVT update - iteration 250 @ 13377104    // two entrances
---> PVT update - iteration 251 @ 13408109    // second entrance
<--- PVT update - iteration 251 @ 13408197
---> PVT update - iteration 252 @ 13439109
<--- PVT update - iteration 252 @ 13439254
---> PVT update - iteration 253 @ 13470120
<--- PVT update - iteration 253 @ 13470216
---> PVT update - iteration 254 @ 13501122
<--- PVT update - iteration 254 @ 13501213
<--- PVT update - iteration 250 @ 13501317    // exit for iteration 250
---> PVT update - iteration 255 @ 13532078
<--- PVT update - iteration 255 @ 13532170
---> PVT update - iteration 256 @ 13563109
<--- PVT update - iteration 256 @ 13563242

- Arsinio

---

不用管printf; usleep 不是异步信号安全的。请参阅IEEE Std 1003.1-2001 Signal Concepts："当一个信号中断了一个不安全的函数并且信号处理函数调用了一个不安全的函数时，行为是未定义的。" - ephemient

很可能其中所有的代码都会干扰ElmoSynchronizer，从外观上看它远非异步安全，这听起来像是一个等待引爆的竞态条件炸弹。 - nos

Answer 1

不要设置定期计时器，而是在信号处理程序结束时再次触发它。

创建计时器时，请执行以下操作

// start the timer
//struct itimerspec timerSpec;
this->timerSpec_.it_value = firstExecTime;
this->timerSpec_.it_interval = 0; //one-shot 
if( timer_settime(*timerIn, TIMER_ABSTIME, &this->timerSpec_, NULL) == -1 )
{
    return CanStatus( CanStatus::SYSTEM_ERROR, __FUNCTION__, "Couldn't start timer for timer" );
}

// from now we will shoot the timer with this value
this->timerSpec_.it_value = ElmoSynchronizer::getTimespecFromDouble(1.0/rate_hz);

// store *timerIn in also in ElmoSynchronizer
this->timerId_ = *timerIn;

然后将此内容附加到ElmoSynchronizer :: rootPvtCallback 函数的末尾

//shoot our the timer again
if( timer_settime(elmoSync->timerId_, 0, &elmoSync->timerSpec_, NULL) == -1 )
{
    return CanStatus( CanStatus::SYSTEM_ERROR, __FUNCTION__, "Couldn't restart timer" );
}

顺便说一下，我会使用线程和信号量来完成整个过程，这样同步器就可以在定义的时间内简单地检查PVT更新过程是否已结束。POSIX提供了它们，而且实现起来并不比定时器更难。

- ch0kee

Answer 2

当我需要调试信号处理程序时，我会创建一个数组来存储调试信息（而不是使用printf）。收集一定数量的信号处理程序调用的数据，然后将数组内容转储出来以查看发生了什么。

你可能会看到输出的顺序不同。

- Brenda J. Butler