posix_signal.c
2.94 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
/*
* Copyright (c) 2006-2021, RT-Thread Development Team
*
* SPDX-License-Identifier: Apache-2.0
*
* Change Logs:
* Date Author Notes
* 2017/10/1 Bernard The first version
*/
#include <rthw.h>
#include <rtthread.h>
#include <sys/time.h>
#include <sys/errno.h>
#include "posix_signal.h"
#define sig_valid(sig_no) (sig_no >= 0 && sig_no < RT_SIG_MAX)
void (*signal(int sig, void (*func)(int))) (int)
{
return rt_signal_install(sig, func);
}
int sigprocmask (int how, const sigset_t *set, sigset_t *oset)
{
rt_base_t level;
rt_thread_t tid;
tid = rt_thread_self();
level = rt_hw_interrupt_disable();
if (oset) *oset = tid->sig_mask;
if (set)
{
switch(how)
{
case SIG_BLOCK:
tid->sig_mask |= *set;
break;
case SIG_UNBLOCK:
tid->sig_mask &= ~*set;
break;
case SIG_SETMASK:
tid->sig_mask = *set;
break;
default:
break;
}
}
rt_hw_interrupt_enable(level);
return 0;
}
int sigpending (sigset_t *set)
{
sigprocmask(SIG_SETMASK, RT_NULL, set);
return 0;
}
int sigsuspend (const sigset_t *set)
{
int ret = 0;
sigset_t origin_set;
sigset_t suspend_set;
siginfo_t info; /* unless paremeter */
/* get the origin signal information */
sigpending(&origin_set);
/* set the new signal information */
sigprocmask(SIG_BLOCK, set, RT_NULL);
sigpending(&suspend_set);
ret = rt_signal_wait(&suspend_set, &info, RT_WAITING_FOREVER);
/* restore the original sigprocmask */
sigprocmask(SIG_UNBLOCK, (sigset_t *)0xffffUL, RT_NULL);
sigprocmask(SIG_BLOCK, &origin_set, RT_NULL);
return ret;
}
int sigaction(int signum, const struct sigaction *act, struct sigaction *oldact)
{
rt_sighandler_t old = RT_NULL;
if (!sig_valid(signum)) return -RT_ERROR;
if (act)
old = rt_signal_install(signum, act->sa_handler);
else
{
old = rt_signal_install(signum, RT_NULL);
rt_signal_install(signum, old);
}
if (oldact)
oldact->sa_handler = old;
return 0;
}
int sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout)
{
int ret = 0;
int tick = RT_WAITING_FOREVER;
if (timeout)
{
tick = rt_timespec_to_tick(timeout);
}
ret = rt_signal_wait(set, info, tick);
if (ret == 0) return 0;
errno = ret;
return -1;
}
int sigwait(const sigset_t *set, int *sig)
{
siginfo_t si;
if (sigtimedwait(set, &si, 0) < 0)
return -1;
*sig = si.si_signo;
return 0;
}
int sigwaitinfo(const sigset_t *set, siginfo_t *info)
{
return sigtimedwait(set, info, NULL);
}
int raise(int sig)
{
rt_thread_kill(rt_thread_self(), sig);
return 0;
}
#include <sys/types.h>
int sigqueue (pid_t pid, int signo, const union sigval value)
{
/* no support, signal queue */
return -1;
}