1 #![allow(non_camel_case_types)]
2 // 这是signal暴露给其他模块的公有的接口文件
3
4 use core::ffi::c_void;
5 use core::fmt::Debug;
6
7 use alloc::vec::Vec;
8
9 use crate::include::bindings::bindings::NULL;
10 // todo: 将这里更换为手动编写的ffi绑定
11 use crate::include::bindings::bindings::atomic_t;
12 use crate::include::bindings::bindings::pt_regs;
13 use crate::include::bindings::bindings::spinlock_t;
14 use crate::kerror;
15 use crate::libs::ffi_convert::FFIBind2Rust;
16 use crate::libs::ffi_convert::__convert_mut;
17 use crate::libs::ffi_convert::__convert_ref;
18 use crate::libs::refcount::RefCount;
19
20 /// 请注意，sigset_t这个bitmap, 第0位表示sig=1的信号。也就是说，SignalNumber-1才是sigset_t中对应的位
21 pub type sigset_t = u64;
22 /// 存储信号处理函数的地址(来自用户态)
23 pub type __signalfn_t = u64;
24 pub type __sighandler_t = __signalfn_t;
25 /// 存储信号处理恢复函数的地址(来自用户态)
26 pub type __sigrestorer_fn_t = u64;
27 pub type __sigrestorer_t = __sigrestorer_fn_t;
28
29 /// 最大的信号数量（改动这个值的时候请同步到signal.h)
30 pub const MAX_SIG_NUM: i32 = 64;
31 /// sigset所占用的u64的数量（改动这个值的时候请同步到signal.h)
32 pub const _NSIG_U64_CNT: i32 = MAX_SIG_NUM / 64;
33 /// 信号处理的栈的栈指针的最小对齐数量
34 pub const STACK_ALIGN: u64 = 16;
35
36 /// 由于signal_struct总是和sighand_struct一起使用，并且信号处理的过程中必定会对sighand加锁
37 /// 因此signal_struct不用加锁
38 /// **请将该结构体与`include/DragonOS/signal.h`中的保持同步**
39 #[repr(C)]
40 #[derive(Debug, Copy, Clone)]
41 pub struct signal_struct {
42 pub sig_cnt: atomic_t,
43 }
44
45 impl Default for signal_struct {
default() -> Self46 fn default() -> Self {
47 Self {
48 sig_cnt: Default::default(),
49 }
50 }
51 }
52
53 /**
54 * sigaction中的信号处理函数结构体
55 * 分为两种处理函数
56 */
57 #[repr(C)]
58 #[derive(Copy, Clone)]
59 pub union sigaction__union_u {
60 pub _sa_handler: __sighandler_t, // 传统处理函数
61 pub _sa_sigaction: ::core::option::Option<
62 unsafe extern "C" fn(
63 sig: ::core::ffi::c_int,
64 sinfo: *mut siginfo,
65 arg1: *mut ::core::ffi::c_void,
66 ),
67 >,
68 }
69
70 impl core::fmt::Debug for sigaction__union_u {
fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result71 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
72 f.write_str("sigaction__union_u")
73 }
74 }
75
76 impl Default for sigaction__union_u {
default() -> Self77 fn default() -> Self {
78 Self {
79 _sa_handler: NULL as u64,
80 }
81 }
82 }
83
84 // ============ sigaction结构体中的的sa_flags的可选值 begin ===========
85 pub const SA_FLAG_DFL: u64 = 1u64 << 0; // 当前sigaction表示系统默认的动作
86 pub const SA_FLAG_IGN: u64 = 1u64 << 1; // 当前sigaction表示忽略信号的动作
87 pub const SA_FLAG_RESTORER: u64 = 1u64 << 2; // 当前sigaction具有用户指定的restorer
88 pub const SA_FLAG_IMMUTABLE: u64 = 1u64 << 3; // 当前sigaction不可被更改
89
90 /// 所有的sa_flags的mask。（用于去除那些不存在的sa_flags位)
91 pub const SA_ALL_FLAGS: u64 = SA_FLAG_IGN | SA_FLAG_DFL | SA_FLAG_RESTORER | SA_FLAG_IMMUTABLE;
92
93 // ============ sigaction结构体中的的sa_flags的可选值 end ===========
94
95 /// 用户态程序传入的SIG_DFL的值
96 pub const USER_SIG_DFL: u64 = 0;
97 /// 用户态程序传入的SIG_IGN的值
98 pub const USER_SIG_IGN: u64 = 1;
99
100 /**
101 * @brief 信号处理结构体
102 */
103 #[repr(C)]
104 #[derive(Debug, Copy, Clone)]
105 pub struct sigaction {
106 pub _u: sigaction__union_u,
107 pub sa_flags: u64,
108 pub sa_mask: sigset_t, // 为了可扩展性而设置的sa_mask
109 /// 信号处理函数执行结束后，将会跳转到这个函数内进行执行，然后执行sigreturn系统调用
110 pub sa_restorer: __sigrestorer_t,
111 }
112
113 impl Default for sigaction {
default() -> Self114 fn default() -> Self {
115 Self {
116 _u: Default::default(),
117 sa_flags: Default::default(),
118 sa_mask: Default::default(),
119 sa_restorer: Default::default(),
120 }
121 }
122 }
123
124 impl sigaction {
125 /// @brief 判断这个sigaction是否被忽略
ignored(&self, _sig: SignalNumber) -> bool126 pub fn ignored(&self, _sig: SignalNumber) -> bool {
127 if (self.sa_flags & SA_FLAG_IGN) != 0 {
128 return true;
129 }
130 // todo: 增加对sa_flags为SA_FLAG_DFL,但是默认处理函数为忽略的情况的判断
131
132 return false;
133 }
134 }
135
136 /// @brief 用户态传入的sigaction结构体（符合posix规范）
137 /// 请注意，我们会在sys_sigaction函数里面将其转换成内核使用的sigaction结构体
138 #[repr(C)]
139 #[derive(Debug)]
140 pub struct user_sigaction {
141 pub sa_handler: *mut core::ffi::c_void,
142 pub sa_sigaction: *mut core::ffi::c_void,
143 pub sa_mask: sigset_t,
144 pub sa_flags: u64,
145 pub sa_restorer: *mut core::ffi::c_void,
146 }
147
148 /**
149 * 信号消息的结构体，作为参数传入sigaction结构体中指向的处理函数
150 */
151 #[repr(C)]
152 #[derive(Copy, Clone)]
153 pub struct siginfo {
154 pub _sinfo: __siginfo_union,
155 }
156 #[repr(C)]
157 #[derive(Copy, Clone)]
158 pub union __siginfo_union {
159 pub data: __siginfo_union_data,
160 pub padding: [u64; 4usize],
161 }
162
163 #[repr(C)]
164 #[derive(Copy, Clone)]
165 pub struct __siginfo_union_data {
166 pub si_signo: i32,
167 pub si_code: i32,
168 pub si_errno: i32,
169 pub reserved: u32,
170 pub _sifields: __sifields,
171 }
172
173 /**
174 * siginfo中，根据signal的来源不同，该union中对应了不同的数据./=
175 * 请注意，该union最大占用16字节
176 */
177 #[repr(C)]
178 #[derive(Copy, Clone)]
179 pub union __sifields {
180 pub _kill: __sifields__kill,
181 }
182
183 /**
184 * 来自kill命令的signal
185 */
186 #[repr(C)]
187 #[derive(Debug, Copy, Clone)]
188 pub struct __sifields__kill {
189 pub _pid: i64, /* 发起kill的进程的pid */
190 }
191
192 impl siginfo {
new(sig: SignalNumber, _si_errno: i32, _si_code: si_code_val) -> Self193 pub fn new(sig: SignalNumber, _si_errno: i32, _si_code: si_code_val) -> Self {
194 siginfo {
195 _sinfo: __siginfo_union {
196 data: __siginfo_union_data {
197 si_signo: sig as i32,
198 si_code: _si_code as i32,
199 si_errno: _si_errno,
200 reserved: 0,
201 _sifields: super::signal_types::__sifields {
202 _kill: super::signal_types::__sifields__kill { _pid: 0 },
203 },
204 },
205 },
206 }
207 }
208 }
209
210 impl Debug for siginfo {
fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result211 fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
212 unsafe {
213 f.write_fmt(format_args!(
214 "si_signo:{}, si_code:{}, si_errno:{}, _pid:{}",
215 self._sinfo.data.si_signo,
216 self._sinfo.data.si_code,
217 self._sinfo.data.si_errno,
218 self._sinfo.data._sifields._kill._pid
219 ))
220 }
221 }
222 }
223
224 /**
225 * @brief 信号处理结构体，位于pcb之中
226 */
227 #[repr(C)]
228 #[derive(Debug, Copy, Clone)]
229 pub struct sighand_struct {
230 pub siglock: spinlock_t,
231 pub count: RefCount,
232 pub action: [sigaction; MAX_SIG_NUM as usize],
233 }
234
235 impl Default for sighand_struct {
default() -> Self236 fn default() -> Self {
237 Self {
238 siglock: Default::default(),
239 count: Default::default(),
240 action: [Default::default(); MAX_SIG_NUM as usize],
241 }
242 }
243 }
244
245 /**
246 * @brief 正在等待的信号的标志位
247 */
248 #[repr(C)]
249 #[derive(Debug, Copy, Clone)]
250 pub struct sigpending {
251 pub signal: sigset_t,
252 /// 信号队列
253 pub queue: *mut SigQueue,
254 }
255
256 /// siginfo中的si_code的可选值
257 /// 请注意，当这个值小于0时，表示siginfo来自用户态，否则来自内核态
258 #[allow(dead_code)]
259 #[repr(i32)]
260 pub enum si_code_val {
261 /// sent by kill, sigsend, raise
262 SI_USER = 0,
263 /// sent by kernel from somewhere
264 SI_KERNEL = 0x80,
265 /// 通过sigqueue发送
266 SI_QUEUE = -1,
267 /// 定时器过期时发送
268 SI_TIMER = -2,
269 /// 当实时消息队列的状态发生改变时发送
270 SI_MESGQ = -3,
271 /// 当异步IO完成时发送
272 SI_ASYNCIO = -4,
273 /// sent by queued SIGIO
274 SI_SIGIO = -5,
275 }
276
277 impl si_code_val {
278 /// 为si_code_val这个枚举类型实现从i32转换到枚举类型的转换函数
279 #[allow(dead_code)]
from_i32(x: i32) -> si_code_val280 pub fn from_i32(x: i32) -> si_code_val {
281 match x {
282 0 => Self::SI_USER,
283 0x80 => Self::SI_KERNEL,
284 -1 => Self::SI_QUEUE,
285 -2 => Self::SI_TIMER,
286 -3 => Self::SI_MESGQ,
287 -4 => Self::SI_ASYNCIO,
288 -5 => Self::SI_SIGIO,
289 _ => panic!("si code not valid"),
290 }
291 }
292 }
293
294 #[allow(dead_code)]
295 #[derive(Debug, Clone, Copy)]
296 #[repr(i32)]
297 pub enum SignalNumber {
298 INVALID = 0,
299 SIGHUP = 1,
300 SIGINT,
301 SIGQUIT,
302 SIGILL,
303 SIGTRAP,
304 /// SIGABRT和SIGIOT共用这个号码
305 SIGABRT_OR_IOT,
306 SIGBUS,
307 SIGFPE,
308 SIGKILL,
309 SIGUSR1,
310
311 SIGSEGV = 11,
312 SIGUSR2,
313 SIGPIPE,
314 SIGALRM,
315 SIGTERM,
316 SIGSTKFLT,
317 SIGCHLD,
318 SIGCONT,
319 SIGSTOP,
320 SIGTSTP,
321
322 SIGTTIN = 21,
323 SIGTTOU,
324 SIGURG,
325 SIGXCPU,
326 SIGXFSZ,
327 SIGVTALRM,
328 SIGPROF,
329 SIGWINCH,
330 /// SIGIO和SIGPOLL共用这个号码
331 SIGIO_OR_POLL,
332 SIGPWR,
333
334 SIGSYS = 31,
335 }
336
337 /// 为SignalNumber实现判断相等的trait
338 impl PartialEq for SignalNumber {
eq(&self, other: &SignalNumber) -> bool339 fn eq(&self, other: &SignalNumber) -> bool {
340 *self as i32 == *other as i32
341 }
342 }
343
344 impl From<i32> for SignalNumber {
from(value: i32) -> Self345 fn from(value: i32) -> Self {
346 if Self::valid_signal_number(value) {
347 let ret: SignalNumber = unsafe { core::mem::transmute(value) };
348 return ret;
349 } else {
350 kerror!("Try to convert an invalid number to SignalNumber");
351 return SignalNumber::INVALID;
352 }
353 }
354 }
355 impl SignalNumber {
356 /// 判断一个数字是否为可用的信号
valid_signal_number(x: i32) -> bool357 fn valid_signal_number(x: i32) -> bool {
358 if x > 0 && x < MAX_SIG_NUM {
359 return true;
360 } else {
361 return false;
362 }
363 }
364 }
365
366 #[allow(dead_code)]
367 pub const SIGRTMIN: i32 = 32;
368 #[allow(dead_code)]
369 pub const SIGRTMAX: i32 = MAX_SIG_NUM;
370
371 /// @brief 将给定的signal_struct解析为Rust的signal.rs中定义的signal_struct的引用
372 ///
373 /// 这么做的主要原因在于，由于PCB是通过bindgen生成的FFI，因此pcb中的结构体类型都是bindgen自动生成的
374 impl FFIBind2Rust<crate::include::bindings::bindings::signal_struct> for signal_struct {
convert_mut( src: *mut crate::include::bindings::bindings::signal_struct, ) -> Option<&'static mut Self>375 fn convert_mut(
376 src: *mut crate::include::bindings::bindings::signal_struct,
377 ) -> Option<&'static mut Self> {
378 return __convert_mut(src);
379 }
convert_ref( src: *const crate::include::bindings::bindings::signal_struct, ) -> Option<&'static Self>380 fn convert_ref(
381 src: *const crate::include::bindings::bindings::signal_struct,
382 ) -> Option<&'static Self> {
383 return __convert_ref(src);
384 }
385 }
386
387 /// @brief 将给定的siginfo解析为Rust的signal.rs中定义的siginfo的引用
388 ///
389 /// 这么做的主要原因在于，由于PCB是通过bindgen生成的FFI，因此pcb中的结构体类型都是bindgen自动生成的
390 impl FFIBind2Rust<crate::include::bindings::bindings::siginfo> for siginfo {
convert_mut( src: *mut crate::include::bindings::bindings::siginfo, ) -> Option<&'static mut Self>391 fn convert_mut(
392 src: *mut crate::include::bindings::bindings::siginfo,
393 ) -> Option<&'static mut Self> {
394 return __convert_mut(src);
395 }
convert_ref( src: *const crate::include::bindings::bindings::siginfo, ) -> Option<&'static Self>396 fn convert_ref(
397 src: *const crate::include::bindings::bindings::siginfo,
398 ) -> Option<&'static Self> {
399 return __convert_ref(src);
400 }
401 }
402
403 /// @brief 将给定的sigset_t解析为Rust的signal.rs中定义的sigset_t的引用
404 ///
405 /// 这么做的主要原因在于，由于PCB是通过bindgen生成的FFI，因此pcb中的结构体类型都是bindgen自动生成的
406 impl FFIBind2Rust<crate::include::bindings::bindings::sigset_t> for sigset_t {
convert_mut( src: *mut crate::include::bindings::bindings::sigset_t, ) -> Option<&'static mut Self>407 fn convert_mut(
408 src: *mut crate::include::bindings::bindings::sigset_t,
409 ) -> Option<&'static mut Self> {
410 return __convert_mut(src);
411 }
convert_ref( src: *const crate::include::bindings::bindings::sigset_t, ) -> Option<&'static Self>412 fn convert_ref(
413 src: *const crate::include::bindings::bindings::sigset_t,
414 ) -> Option<&'static Self> {
415 return __convert_ref(src);
416 }
417 }
418
419 /// @brief 将给定的sigpending解析为Rust的signal.rs中定义的sigpending的引用
420 ///
421 /// 这么做的主要原因在于，由于PCB是通过bindgen生成的FFI，因此pcb中的结构体类型都是bindgen自动生成的
422 impl FFIBind2Rust<crate::include::bindings::bindings::sigpending> for sigpending {
convert_mut( src: *mut crate::include::bindings::bindings::sigpending, ) -> Option<&'static mut Self>423 fn convert_mut(
424 src: *mut crate::include::bindings::bindings::sigpending,
425 ) -> Option<&'static mut Self> {
426 return __convert_mut(src);
427 }
convert_ref( src: *const crate::include::bindings::bindings::sigpending, ) -> Option<&'static Self>428 fn convert_ref(
429 src: *const crate::include::bindings::bindings::sigpending,
430 ) -> Option<&'static Self> {
431 return __convert_ref(src);
432 }
433 }
434
435 /// @brief 将给定的来自bindgen的sighand_struct解析为Rust的signal.rs中定义的sighand_struct的引用
436 ///
437 /// 这么做的主要原因在于，由于PCB是通过bindgen生成的FFI，因此pcb中的结构体类型都是bindgen自动生成的，会导致无法自定义功能的问题。
438 impl FFIBind2Rust<crate::include::bindings::bindings::sighand_struct> for sighand_struct {
convert_mut( src: *mut crate::include::bindings::bindings::sighand_struct, ) -> Option<&'static mut Self>439 fn convert_mut(
440 src: *mut crate::include::bindings::bindings::sighand_struct,
441 ) -> Option<&'static mut Self> {
442 return __convert_mut(src);
443 }
convert_ref( src: *const crate::include::bindings::bindings::sighand_struct, ) -> Option<&'static Self>444 fn convert_ref(
445 src: *const crate::include::bindings::bindings::sighand_struct,
446 ) -> Option<&'static Self> {
447 return __convert_ref(src);
448 }
449 }
450
451 /// @brief 将给定的来自bindgen的sigaction解析为Rust的signal.rs中定义的sigaction的引用
452 impl FFIBind2Rust<crate::include::bindings::bindings::sigaction> for sigaction {
convert_mut( src: *mut crate::include::bindings::bindings::sigaction, ) -> Option<&'static mut Self>453 fn convert_mut(
454 src: *mut crate::include::bindings::bindings::sigaction,
455 ) -> Option<&'static mut Self> {
456 return __convert_mut(src);
457 }
convert_ref( src: *const crate::include::bindings::bindings::sigaction, ) -> Option<&'static Self>458 fn convert_ref(
459 src: *const crate::include::bindings::bindings::sigaction,
460 ) -> Option<&'static Self> {
461 return __convert_ref(src);
462 }
463 }
464
465 /// @brief 进程接收到的信号的队列
466 pub struct SigQueue {
467 pub q: Vec<siginfo>,
468 }
469
470 #[allow(dead_code)]
471 impl SigQueue {
472 /// @brief 初始化一个新的信号队列
new(capacity: usize) -> Self473 pub fn new(capacity: usize) -> Self {
474 SigQueue {
475 q: Vec::with_capacity(capacity),
476 }
477 }
478
479 /// @brief 在信号队列中寻找第一个满足要求的siginfo, 并返回它的引用
480 ///
481 /// @return (第一个满足要求的siginfo的引用; 是否有多个满足条件的siginfo)
find(&self, sig: SignalNumber) -> (Option<&siginfo>, bool)482 pub fn find(&self, sig: SignalNumber) -> (Option<&siginfo>, bool) {
483 // 是否存在多个满足条件的siginfo
484 let mut still_pending = false;
485 let mut info: Option<&siginfo> = None;
486
487 for x in self.q.iter() {
488 if unsafe { x._sinfo.data.si_signo } == sig as i32 {
489 if info.is_some() {
490 still_pending = true;
491 break;
492 } else {
493 info = Some(x);
494 }
495 }
496 }
497 return (info, still_pending);
498 }
499
500 /// @brief 在信号队列中寻找第一个满足要求的siginfo, 并将其从队列中删除，然后返回这个siginfo
501 ///
502 /// @return (第一个满足要求的siginfo; 从队列中删除前是否有多个满足条件的siginfo)
find_and_delete(&mut self, sig: SignalNumber) -> (Option<siginfo>, bool)503 pub fn find_and_delete(&mut self, sig: SignalNumber) -> (Option<siginfo>, bool) {
504 // 是否存在多个满足条件的siginfo
505 let mut still_pending = false;
506 let mut first = true; // 标记变量，记录当前是否已经筛选出了一个元素
507
508 let filter = |x: &mut siginfo| {
509 if unsafe { x._sinfo.data.si_signo } == sig as i32 {
510 if !first {
511 // 如果之前已经筛选出了一个元素，则不把当前元素删除
512 still_pending = true;
513 return false;
514 } else {
515 // 当前是第一个被筛选出来的元素
516 first = false;
517 return true;
518 }
519 } else {
520 return false;
521 }
522 };
523 // 从sigqueue中过滤出结果
524 let mut filter_result: Vec<siginfo> = self.q.drain_filter(filter).collect();
525 // 筛选出的结果不能大于1个
526 assert!(filter_result.len() <= 1);
527
528 return (filter_result.pop(), still_pending);
529 }
530
531 /// @brief 从sigqueue中删除mask中被置位的信号。也就是说，比如mask的第1位被置为1,那么就从sigqueue中删除所有signum为2的信号的信息。
flush_by_mask(&mut self, mask: &sigset_t)532 pub fn flush_by_mask(&mut self, mask: &sigset_t) {
533 // 定义过滤器，从sigqueue中删除mask中被置位的信号
534 let filter = |x: &mut siginfo| {
535 if sig_is_member(mask, SignalNumber::from(unsafe { x._sinfo.data.si_signo })) {
536 true
537 } else {
538 false
539 }
540 };
541 let filter_result: Vec<siginfo> = self.q.drain_filter(filter).collect();
542 // 回收这些siginfo
543 for x in filter_result {
544 drop(x)
545 }
546 }
547
548 /// @brief 从C的void*指针转换为static生命周期的可变引用
from_c_void(p: *mut c_void) -> &'static mut SigQueue549 pub fn from_c_void(p: *mut c_void) -> &'static mut SigQueue {
550 let sq = p as *mut SigQueue;
551 let sq = unsafe { sq.as_mut::<'static>() }.unwrap();
552 return sq;
553 }
554 }
555
556 impl Default for SigQueue {
default() -> Self557 fn default() -> Self {
558 Self {
559 q: Default::default(),
560 }
561 }
562 }
563
564 /// @brief 清除sigset中，某个信号对应的标志位
565 #[inline]
sigset_del(set: &mut sigset_t, sig: SignalNumber)566 pub fn sigset_del(set: &mut sigset_t, sig: SignalNumber) {
567 let sig = sig as i32 - 1;
568 if _NSIG_U64_CNT == 1 {
569 *set &= !(1 << sig);
570 } else {
571 // 暂时不支持超过64个信号
572 panic!("Unsupported signal number: {:?}", sig);
573 }
574 }
575
576 /// @brief 将指定的信号在sigset中的对应bit进行置位
577 #[inline]
sigset_add(set: &mut sigset_t, sig: SignalNumber)578 pub fn sigset_add(set: &mut sigset_t, sig: SignalNumber) {
579 *set |= 1 << ((sig as u32) - 1);
580 }
581
582 /// @brief 将sigset清零
583 #[inline]
sigset_clear(set: &mut sigset_t)584 pub fn sigset_clear(set: &mut sigset_t) {
585 *set = 0;
586 }
587
588 /// @brief 将mask中置为1的位，在sigset中清零
589 #[inline]
sigset_delmask(set: &mut sigset_t, mask: u64)590 pub fn sigset_delmask(set: &mut sigset_t, mask: u64) {
591 *set &= !mask;
592 }
593
594 /// @brief 判断两个sigset是否相等
595 #[inline]
sigset_equal(a: &sigset_t, b: &sigset_t) -> bool596 pub fn sigset_equal(a: &sigset_t, b: &sigset_t) -> bool {
597 if _NSIG_U64_CNT == 1 {
598 return *a == *b;
599 }
600 return false;
601 }
602
603 /// @brief 使用指定的值，初始化sigset（为支持将来超过64个signal留下接口）
604 #[inline]
sigset_init(new_set: &mut sigset_t, mask: u64)605 pub fn sigset_init(new_set: &mut sigset_t, mask: u64) {
606 *new_set = mask;
607 match _NSIG_U64_CNT {
608 1 => {}
609 _ => {
610 // 暂时不支持大于64个信号
611 todo!();
612 }
613 };
614 }
615
616 /// @brief 判断指定的信号在sigset中的对应位是否被置位
617 /// @return true: 给定的信号在sigset中被置位
618 /// @return false: 给定的信号在sigset中没有被置位
619 #[inline]
sig_is_member(set: &sigset_t, _sig: SignalNumber) -> bool620 pub fn sig_is_member(set: &sigset_t, _sig: SignalNumber) -> bool {
621 return if 1 & (set >> ((_sig as u32) - 1)) != 0 {
622 true
623 } else {
624 false
625 };
626 }
627
628 #[repr(C)]
629 #[derive(Debug, Clone, Copy)]
630 pub struct sigframe {
631 /// 指向restorer的地址的指针。（该变量必须放在sigframe的第一位，因为这样才能在handler返回的时候，跳转到对应的代码，执行sigreturn)
632 pub ret_code_ptr: *mut core::ffi::c_void,
633 /// signum
634 pub arg0: u64,
635 /// siginfo pointer
636 pub arg1: usize,
637 /// sigcontext pointer
638 pub arg2: usize,
639
640 pub handler: *mut c_void,
641 pub info: siginfo,
642 pub context: sigcontext,
643 }
644
645 #[derive(Debug, Clone, Copy)]
646 pub struct sigcontext {
647 /// sigcontext的标志位
648 pub sc_flags: u64,
649 pub sc_stack: signal_stack, // 信号处理程序备用栈信息
650
651 pub regs: pt_regs, // 暂存的系统调用/中断返回时，原本要弹出的内核栈帧
652 pub trap_num: u64, // 用来保存线程结构体中的trap_num字段
653 pub oldmask: u64, // 暂存的执行信号处理函数之前的，被设置block的信号
654 pub cr2: u64, // 用来保存线程结构体中的cr2字段
655 pub err_code: u64, // 用来保存线程结构体中的err_code字段
656 // todo: 支持x87浮点处理器后，在这里增加浮点处理器的状态结构体指针
657 pub reserved_for_x87_state: u64,
658 pub reserved: [u64; 8],
659 }
660
661 /// @brief 信号处理备用栈的信息
662 #[derive(Debug, Clone, Copy)]
663 pub struct signal_stack {
664 pub sp: *mut c_void,
665 pub flags: u32,
666 pub size: u32,
667 }
668