C语言 从信号处理程序调用的函数中的参数值如何与传入的值不同？

siv3szwd  于 2023-01-25  发布在  其他
关注(0)|答案(1)|浏览(117)
    • 更新的问题-以下第一版**

我已经设置了一个定制的信号处理程序来缓冲从CAN接口移除的帧，在这个处理程序中，我使用pthread_sigmask()首先阻塞信号，最后再解除阻塞。
在bufferMessageDirect()中，将检查接口ID iface_id，如果出现错误，则调用assert(0)，因为这通常只能是我的错误。
我的程序运行了一段时间后，随着CAN帧流的到达，assert()被触发，执行结束。当我检查信号处理程序堆栈帧时，iface_id是0，这是有效的，但传入bufferMessageDirect()的参数can_interface_id是-1。
我有一个传入CAN帧的转储，它们没有任何异常。信号处理程序的堆栈帧指示转换后的CAN消息符合预期，接口ID为0。在bufferMessageDirect()的堆栈帧中，接口ID为-1。
请您就可能导致此问题的原因提供建议？
我添加了对pthread_sigmask()的调用，因为我认为，可能是在信号的处理程序已经在运行时触发了它。

/************************************************************** EXTERNAL DATA */
extern can_metadata_t  can_metadata;
extern internal_time_t otherthing_heartbeat[THING_QUANTITY];
extern internal_time_t something_heartbeat[THING_QUANTITY];

/************************************************************** INTERNAL DATA */
STATIC volatile ssize_t          bytes_read  = 0;
STATIC volatile int              socket_desc = 0;
STATIC volatile struct can_frame frame       = {0};
STATIC volatile uint32_t         receiver_id = 0u;
STATIC volatile uint32_t         command_id  = 0u;
STATIC volatile uint32_t         function_id = 0u;
STATIC volatile int32_t          iface_id    = 0;
STATIC volatile cand_result_t    d_result    = CAND_RESULT_OK;
STATIC volatile canh_result_t    h_result    = CANH_RESULT_OK;

STATIC volatile internal_time_t *const heartbeats[2] =
{
    otherthing_heartbeat,
    something_heartbeat,
};

// ============================================================================
void
myHandler(int       const        signal_number,
          siginfo_t       *const p_signal_info,
          void            *const p_ucontext)
{
    uint8_t       ii           = 0u;
    uint8_t       thing_id     = 0u;
    bool          is_something = 0u;
    can_message_t message      = {0};
    int           std_result = 0;

    /* Mark as unwanted */
    (void) p_ucontext;

    if ((HANDLERS_SIGNUM_CAN_RX != signal_number) ||
        (NULL                   == p_signal_info))
    {
        /* No penalty for these conditions */
        return;
    }

    else
    {
        /* Block this signal */
        std_result = pthread_sigmask(SIG_BLOCK, &signal_set_can, NULL);

        /* This result is asserted because the only failure is if the SIG_BLOCK
         * action is invalid
         */
        assert(0 == std_result);

        socket_desc = p_signal_info->si_fd;
        bytes_read = read(socket_desc, &frame, sizeof(frame));

        if (bytes_read != sizeof(frame))
        {
            // ...
            goto unblock_signal;
        }
    }

    /* Is this an error frame? */
    if ((frame.can_id & CAN_ERR_FLAG) != 0u)
    {
        // ...
        goto unblock_signal;
    }

    /* Is this a frame with an 11-bit ID? */
    else if ((frame.can_id & CAN_EFF_FLAG) == 0u)
    {
        // ...
        goto unblock_signal;
    }

    /* Is this a frame with a 29-bit ID? */
    else
    {
        function_id = frame.can_id & CAN_EFF_MASK;
        command_id  = function_id;
        receiver_id = function_id;

        function_id &= MASK_FUNCTION_ID;
        function_id >>= POSITION_FUNCTION_ID;

        command_id &= MASK_COMMAND_ID;
        command_id >>= POSITION_COMMAND_ID;

        receiver_id &= MASK_RECEIVER_ID;

        thing_id = (frame.can_id & MASK_THING_ID) - 1u;
        is_something  = frame.can_id & MASK_RECEIVER_IS_SOMETHING;

        /* Update the housekeeping stats */
        if (function_id < FUNCTIONCODE_QUANTITY)
        {
            delivered_for_function_id[function_id]++;
        }
        else
        {
            delivered_for_function_id[FUNCTIONCODE_QUANTITY]++;
        }
    }

    /* Handle emergency messages */
    if (FUNCTIONCODE_EMGC == function_id)
    {
        // ...
        goto unblock_signal;
    }

    /* Handle heartbeats */
    if (FUNCTIONCODE_HB == function_id)
    {
        // Gets time from CLOCK_MONOTONIC_RAW and converts to microseconds
        (void) getRawTimeFormatInternal(&(heartbeats[is_something][thing_id]));

        goto unblock_signal;
    }

    /* Discard anything but Responses */
    if (FUNCTIONCODE_RESPONSE != function_id)
    {
        // ...
        goto unblock_signal;
    }

    /* Make the busy something available again */
    if (true == is_something)
    {
        something_busy_bits &= ~(1 << thing_id);
    }

    /* Otherwise, find the interface ID and push to the buffer */
    iface_id = -1;

    /* Find buffer first */
    for (ii = 0u; ii < CAN_INTERFACE_QUANTITY; ii++)
    {
        if (can_metadata.socket[ii] == socket_desc)
        {
            iface_id = (int32_t) ii;
            break;
        }
    }

    if (-1 == iface_id)
    {
        goto unblock_signal;
    }

    /* Otherwise convert and buffer */
    h_result = canFrameToMessage(&message, &frame);

    if (CAN_RESULT_OK != h_result)
    {
        // ...
        goto unblock_signal;
    }

    d_result = bufferMessageDirect((can_interface_id_t) iface_id, &message);

    if (CAN_RESULT_OK != d_result)
    {
        // ...
        assert(0);
    }

    // ........................................................................
    unblock_signal:

    /* Unblock this signal */
    std_result = pthread_sigmask(SIG_UNBLOCK, &signal_set_can, NULL);

    /* This result is asserted because the only failure is if the SIG_BLOCK
     * action is invalid
     */
    assert(0 == std_result);
}

// ============================================================================
cand_result_t
bufferMessageDirect(
    can_interface_id_t const        can_interface_id,
    can_message_t      const *const p_message)
{
    canh_result_t h_result = CANH_RESULT_OK;
    cand_result_t result   = CAND_RESULT_OK;

    h_result = validateInterfaceId(can_interface_id);

    if (CANH_RESULT_OK != h_result)
    {
        result = CAND_RESULT_INTERNAL_ERROR;
        assert(0); // This is tripped, because can_interface_id is -1
    }

    // ...
    // Push into buffer (call to buffer utility)

    return result;
}
    • 老问题**

我已经设置了一个定制的信号处理程序来缓冲从CAN接口移除的帧，在这个处理程序中，我使用pthread_sigmask()首先阻塞信号，最后再解除阻塞。
基本配方是：

void
myHandler(
    int       const        signal_number,
    siginfo_t       *const p_signal_info,
    void            *const p_ucontext)
{
  check_signal_info();
  pthread_sigmask(SIG_BLOCK, set_of_this_signal_only);
  read(socket, &can_frame, sizeof(can_frame));
  derive_can_iface_id(&iface_id);

  buffer_push((iface_enum_type) iface_id, can_frame);

  pthread_sigmask(SIG_UNBLOCK, set_of_this_signal_only);
}

在buffer_push()中，将检查接口ID iface_id，如果出现错误，则调用assert(0)，因为这通常只能是我的错误。
我的程序运行了一段时间后，确切的时间会随着CAN帧流的到达而变化，assert()被触发，执行结束。当我检查信号处理程序堆栈帧时，iface_id是0，这是有效的，但传入buffer_push()的参数是-1。
我添加了对pthread_sigmask()的调用，因为我认为，可能是在信号的处理程序已经在运行时触发了它。
buffer_push()的原型是：

result_enum_type
buffer_push(
    iface_enum_type const        can_interface_id,
    can_frame_type  const *const p_message)

iface_id在函数外部声明，如下所示：

static volatile uint32_t iface_id = 0;

为了避免疑问，在buffer_push()的调用下面都是我自己的代码---没有外部调用。另外，我有一个传入CAN帧的转储，这个信号处理程序正确地解析每个帧。
请您就可能导致此问题的原因提供建议？

c

1条答案

按热度按时间
6qqygrtg

6qqygrtg1#

从信号处理程序调用的函数中的参数值如何与传入的值不同？
这怎么可能呢？因为C标准说它可以：
当抽象机的处理由于接收到信号而中断时，既不是无锁原子对象也不是volatile sig_atomic_t类型的对象的值是未指定的，浮点环境的状态也是未指定的。当处理程序退出时，由处理程序修改的既不是无锁原子对象也不是volatile sig_atomic_t类型的任何对象的值变为不确定的。如果浮点环境的状态被处理程序修改且未恢复到其原始状态，则浮点环境的状态也是如此。
下列物体都不是"无锁原子物体"或"volatile sig_atomic_t型"：

STATIC volatile ssize_t          bytes_read  = 0;
STATIC volatile int              socket_desc = 0;
STATIC volatile struct can_frame frame       = {0};
STATIC volatile uint32_t         receiver_id = 0u;
STATIC volatile uint32_t         command_id  = 0u;
STATIC volatile uint32_t         function_id = 0u;
STATIC volatile int32_t          iface_id    = 0;
STATIC volatile cand_result_t    d_result    = CAND_RESULT_OK;
STATIC volatile canh_result_t    h_result    = CANH_RESULT_OK;

STATIC volatile internal_time_t *const heartbeats[2] =
{
    otherthing_heartbeat,
    something_heartbeat,
};

当你的信号处理程序被调用时，这些变量中的每一个都有不确定的值，当你的信号处理程序返回时，如果它们在信号处理程序中被修改了，这些变量中的每一个都将变成不确定的。
另请注意C11标准（草案）脚注188：
因此，信号处理程序通常不能调用标准库函数。
基本上，你不能在信号处理程序中安全地做任何事情。严格符合的C代码只能修改上面提到的对象。POSIX扩展了信号处理程序可以安全地做的事情，只调用异步信号安全的函数--一个非常有限的集合。Windows也有类似的规定。Linux signal-safety man page提供了Linux上异步信号安全的函数的Linux特定列表。
可能发生的情况是，正常处理和信号处理之间存在争用条件。大部分时间都能正常工作，但偶尔会出现其中一种争用条件，导致值损坏。

赞(0）分享  回复(0）举报  2023-01-25
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备2022004421号-2 NULL123 https://www.null123.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com