RT_thread（九）线程间通信之信号

最新推荐文章于 2024-04-27 09:50:32 发布

L加号

最新推荐文章于 2024-04-27 09:50:32 发布

阅读量981

点赞数 1

分类专栏： RT_Thread学习之路文章标签：算法

本文链接：https://blog.csdn.net/ljh5930/article/details/125211529

版权

RT_Thread学习之路专栏收录该内容

9 篇文章 4 订阅

订阅专栏

文章目录

信号
信号的工作机制
信号的管理

信号

信号（又称为软中断信号），在软件层次上是对中断机制的一种模拟，在原理上，一个线程收到一个信号与处理器收到一个中断请求可以说是类似的

信号的工作机制

信号在 RT-Thread 中用作异步通信，POSIX 标准定义了 sigset_t 类型来定义一个信号集，然而 sigset_t 类型在不同的系统可能有不同的定义方式，在 RT-Thread 中，将 sigset_t 定义成了 unsigned long 型，并命名为 rt_sigset_t，应用程序能够使用的信号为 SIGUSR1（10）和 SIGUSR2（12）。

typedef unsigned long rt_sigset_t;

信号本质是软中断，用来通知线程发生了异步事件，用做线程之间的异常通知、应急处理。一个线程不必通过任何操作来等待信号的到达，事实上，线程也不知道信号到底什么时候到达，线程之间可以互相通过调用 rt_thread_kill() 发送软中断信号

一个线程不需要任何操作来就可以等待信号的到达。线程对信号的处理分为三类：

类似中断处理，设定信号处理函数。
忽略信号，不进行处理
默认处理，采用系统默认的处理方式

线程接收到信号时，可能处于两种状态：

正在处于挂起状态，此时线程进入就绪状态去处理对应的信号
处于运行状态，系统会创建新的栈空间去处理对应的信号

信号的管理

信号的设置是在线程句柄中

#if defined(RT_USING_SIGNALS)
    rt_sigset_t     sig_pending;                        //挂起的信号
    rt_sigset_t     sig_mask;                           //信号的掩码位

    void            *sig_ret;                           //signa返回堆栈指针
    rt_sighandler_t *sig_vectors;                       //信号处理器向量(对应信号的处理方式）
    //tid->sig_vectors[signo] = _signal_default_handler sig_vectors的signo位存储处理方式 _signal_default_handler
    void            *si_list;                           //信号信息列表

在这里插入图片描述

安装信号

如果线程要处理某一信号，那么就要在线程中安装该信号。安装信号主要用来确定信号值及线程针对该信号值的动作之间的映射关系，即线程将要处理哪个信号，该信号被传递给线程时，将执行何种操作。

前置知识
(可以直接看rt_sighandler_t rt_signal_install(int signo, rt_sighandler_t handler)
看到不懂的或要跳转的再看这

rt_sighandler_t是什么

点击rt_sighandler_t跳转到 typedef void (*rt_sighandler_t)(int signo);
盖住typedef不看
rt_sighandler_t 就是一个函数指针，接收整型（int）的名为signo的参数，返回一个无类型指针
加上typedef，sighandler_t就是一个新的类型，可以像int去使用，不一样的是这是个函数指针，接收一个整型返回一个无类型指针,下面函数指针指向的是输入的第二个参数rt_sighandler_t handler
例子：

rt_signal_install(SIGUSR1, thread1_signal_handler);//安装信号
//输入的第二个参数是个函数
void thread1_signal_handler(int sig)
{
    rt_kprintf("thread1 received signal %d\n", sig);
}

void rt_thread_alloc_sig(rt_thread_t tid)的使用

void rt_thread_alloc_sig(rt_thread_t tid)
{
    int index;
    rt_base_t level;
    rt_sighandler_t *vectors;

    vectors = (rt_sighandler_t *)RT_KERNEL_MALLOC(sizeof(rt_sighandler_t) * RT_SIG_MAX);
    //分配大小为sizeof(rt_sighandler_t) * RT_SIG_MAX的内存给vectors
    RT_ASSERT(vectors != RT_NULL);

    for (index = 0; index < RT_SIG_MAX; index ++)
    {
        vectors[index] = _signal_default_handler;
    }

    level = rt_hw_interrupt_disable();
    tid->sig_vectors = vectors;
    rt_hw_interrupt_enable(level);
}

正文代码

rt_sighandler_t rt_signal_install(int signo, rt_sighandler_t handler)
{
    rt_sighandler_t old = RT_NULL;
    rt_thread_t tid = rt_thread_self();//获取当前线程

    if (!sig_valid(signo)) return SIG_ERR;
    //#define sig_valid(sig_no)   (sig_no >= 0 && sig_no < RT_SIG_MAX)
    //掩码位数是否无错误

    rt_enter_critical();//调度锁上锁
    if (tid->sig_vectors == RT_NULL)
    {
        rt_thread_alloc_sig(tid);//当前线程的vector成员赋值
    }

    if (tid->sig_vectors)//判断信号的处理模式
    {
        old = tid->sig_vectors[signo];

        if (handler == SIG_IGN) tid->sig_vectors[signo] = RT_NULL;
        //参数为SIG_IGN,忽略某个信号，对该信号不做处理
        else if (handler == SIG_DFL) tid->sig_vectors[signo] = _signal_default_handler;
        //参数为SIG_DFL,系统调用默认的处理方式
        else tid->sig_vectors[signo] = handler;
        //类似中断的处理方式，参数指向当信号发生时用户自己设置的处理函数，即调用自己设置的处理函数
    }
    rt_exit_critical();//调度锁开锁

    return old;
}

阻塞信号

信号阻塞，也就是信号被屏蔽，信号发送时，设置了信号的线程接收不到信号，也不会引发信号的作用：软中断

signo取值
/* Signal numbers 10 and 11 are available for the user */
#define SIGUSR1 10
#define SIGUSR2 11

void rt_signal_mask(int signo)
{
    rt_base_t level;
    rt_thread_t tid = rt_thread_self();

    level = rt_hw_interrupt_disable();

    tid->sig_mask &= ~sig_mask(signo);//对应掩码位置0

    rt_hw_interrupt_enable(level);
}

解除信号阻塞

解除信号阻塞，就是信号发送时，被设置了信号的线程可以接收到信号，触发软中断

void rt_signal_unmask(int signo)
{
    rt_base_t level;
    rt_thread_t tid = rt_thread_self();//获取当前线程

    level = rt_hw_interrupt_disable();//开中断

    tid->sig_mask |= sig_mask(signo);//相对应的掩码置1

    /* let thread handle pended signals */
    if (tid->sig_mask & tid->sig_pending)//让线程处理挂起信号
    {
        rt_hw_interrupt_enable(level);
        _signal_deliver(tid);//下方代码分析。给线程发送信号
    }
    else
    {
        rt_hw_interrupt_enable(level);
    }
}

_signal_deliver(tid);代码分析

static void _signal_deliver(rt_thread_t tid)
{
    rt_ubase_t level;

    /* thread is not interested in pended signals */
    if (!(tid->sig_pending & tid->sig_mask)) return;
    //线程没设置这个信号接收，没有这个信号操作个锤子

    level = rt_hw_interrupt_disable();//开中断
    if ((tid->stat & RT_THREAD_STAT_MASK) == RT_THREAD_SUSPEND)//当线程挂起
    {
        /* resume thread to handle signal */
        rt_thread_resume(tid);//唤醒当前线程
        /* add signal state */
        tid->stat |= RT_THREAD_STAT_SIGNAL;

        rt_hw_interrupt_enable(level);

        /* re-schedule */
        rt_schedule();
    }
    else//线程有设置这个信号
    {
        if (tid == rt_thread_self())//是在当前线程操作
        {
            /* add signal state */
            tid->stat |= RT_THREAD_STAT_SIGNAL;//线程信号状态增加

            rt_hw_interrupt_enable(level);//开中断

            /* do signal action in self thread context */
            rt_thread_handle_sig(RT_TRUE);
        }
        else if (!((tid->stat & RT_THREAD_STAT_MASK) & RT_THREAD_STAT_SIGNAL))
        {
            /* add signal state */
            tid->stat |= RT_THREAD_STAT_SIGNAL;

            /* point to the signal handle entry */
            tid->sig_ret = tid->sp;
            tid->sp = rt_hw_stack_init((void *)_signal_entry, RT_NULL,
                                       (void *)((char *)tid->sig_ret - 32), RT_NULL);

            rt_hw_interrupt_enable(level);
            dbg_log(DBG_LOG, "signal stack pointer @ 0x%08x\n", tid->sp);

            /* re-schedule */
            rt_schedule();
        }
        else
        {
            rt_hw_interrupt_enable(level);
        }
    }
}

发送信号

发生了异常，给处理异常的线程发送信号

信号信息

struct siginfo
{
    rt_uint16_t si_signo;//信号掩码位数
    rt_uint16_t si_code;//发送信号来源：下面5个定义
#define SI_USER     0x01    /* Signal sent by kill(). */
#define SI_QUEUE    0x02    /* Signal sent by sigqueue(). */
#define SI_TIMER    0x03    /* Signal generated by expiration of a 
                               timer set by timer_settime(). */
#define SI_ASYNCIO  0x04    /* Signal generated by completion of an 
                               asynchronous I/O request. */
#define SI_MESGQ    0x05    /* Signal generated by arrival of a 
                               message on an empty message queue. */

    union sigval si_value;
/*union sigval 
{
    int    sival_int;    // 整型信号值
    void  *sival_ptr;    // 指针信号值
};  
*/    
};
typedef struct siginfo siginfo_t;

信号节点

struct siginfo_node
{
    siginfo_t si;
    struct rt_slist_node list;
};

发送代码


int rt_thread_kill(rt_thread_t tid, int sig)
{
    siginfo_t si;
    rt_base_t level;
    struct siginfo_node *si_node;

    RT_ASSERT(tid != RT_NULL);
    if (!sig_valid(sig)) return -RT_EINVAL;//判断是否存在，不存在返回参数错误

    dbg_log(DBG_INFO, "send signal: %d\n", sig);
    si.si_signo = sig;//存掩码值
    si.si_code  = SI_USER;//记录发送者
    si.si_value.sival_ptr = RT_NULL;//指针信号值为空

    level = rt_hw_interrupt_disable();//开中断
    if (tid->sig_pending & sig_mask(sig))//这个线程已经设置接收该信号
    {
        /* whether already emits this signal? */
        struct rt_slist_node *node;//信号队列
        struct siginfo_node  *entry;//信号数据存储节点

        node = (struct rt_slist_node *)tid->si_list;//node赋值线程中的信号信息节点
        rt_hw_interrupt_enable(level);//开中断

        /* update sig info */
        rt_enter_critical();//调度锁上锁
        for (; (node) != RT_NULL; node = node->next)//找到线程的信号对应的信号信息节点，更新信息
        {
            entry = rt_slist_entry(node, struct siginfo_node, list);
            if (entry->si.si_signo == sig)
            {
                memcpy(&(entry->si), &si, sizeof(siginfo_t));
                rt_exit_critical();
                return 0;
            }
        }
        rt_exit_critical();//打开调度锁

        /* disable interrupt to protect tcb */
        level = rt_hw_interrupt_disable();//关中断
    }
    else
    {//接收到一个信号，该线程第一次接收，所以这是个新信号
        /* a new signal */
        tid->sig_pending |= sig_mask(sig);//线程中信号接收掩码对应位置1
    }
    rt_hw_interrupt_enable(level);//开中断

    si_node = (struct siginfo_node *) rt_mp_alloc(_rt_siginfo_pool, 0);//信号信息节点分配空间
    if (si_node)//对该节点操作
    {
        rt_slist_init(&(si_node->list));//初始化
        memcpy(&(si_node->si), &si, sizeof(siginfo_t));//初始化后的参数赋值

        level = rt_hw_interrupt_disable();//关中断
        if (!tid->si_list) tid->si_list = si_node;//tid->si_list不存在附si_node的值
        else  //tid->si_list存在，si_node加到信号信息队列最后
        {
            struct siginfo_node *si_list;

            si_list = (struct siginfo_node *)tid->si_list;
            rt_slist_append(&(si_list->list), &(si_node->list));//把该节点附加到队列尾部
        }
        rt_hw_interrupt_enable(level);//开中断
    }
    else
    {
        dbg_log(DBG_ERROR, "The allocation of signal info node failed.\n");
    }

    /* deliver signal to this thread */
    _signal_deliver(tid);

    return RT_EOK;
}

L加号

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
RT_thread（九）线程间通信之信号

信号在 RT-Thread 中用作异步通信，POSIX 标准定义了 sigset_t 类型来定义一个信号集，然而 sigset_t 类型在不同的系统可能有不同的定义方式，在 RT-Thread 中，将 sigset_t 定义成了 unsigned long 型，并命名为 rt_sigset_t，应用程序能够使用的信号为 SIGUSR1（10）和 SIGUSR2（12）。信号阻塞，也就是信号被屏蔽，信号发送时，设置了信号的线程接收不到信号，也不会引发信号的作用：软中断。发生了异常，给处理异常的线程发送信号。.
复制链接

扫一扫