深入Linux信号(Signal)机制：从内核到用户态#

1
#include <signal.h>
2
#include <stdio.h>
3
#include <stdlib.h>
4
#include <string.h>
5
#include <unistd.h>
6

7
// 使用 volatile sig_atomic_t 来确保原子访问和防止编译器过度优化
8
volatile sig_atomic_t shutdown_flag = 0;
9

10
void signal_handler(int signum) {
11
    printf("target received %d (%s)\n", signum, strsignal(signum));
12
    if (signum == SIGINT || signum == SIGTERM) {
13
        shutdown_flag = 1;
14
    }
15
}
16

17
int main() {
18
    if (signal(SIGINT, signal_handler) == SIG_ERR) {
19
        perror("Failed to register SIGINT handler");
20
        exit(EXIT_FAILURE);
21
    }
22
    if (signal(SIGTERM, signal_handler) == SIG_ERR) {
23
        perror("Failed to register SIGTERM handler");
24
        exit(EXIT_FAILURE);
25
    }
26
    int i = 0;
27
    while (!shutdown_flag) {
28
        // printf("Working...\n");
29
        ++i;
30
        // sleep(1);
31
    }
32
    // printf("i=%d\n", i);
33
    printf("Shutdown signal received. exiting...\n");
34
    return 0;
35
}

1
Disassembly of section .text:
2

3
0000000000001100 <main>:
4
    1100:  f3 0f 1e fa            endbr64                  ; 启用 CET 安全特性
5
    1104:  55                     push   %rbp
6
    1105:  48 8d 2d 64 01 00 00   lea    0x164(%rip),%rbp        # 1270 <_Z14signal_handleri>
7
    110c:  bf 02 00 00 00         mov    $0x2,%edi         ; $edi=2(SIGINT)
8
    1111:  48 89 ee               mov    %rbp,%rsi         ; $rsi=signal_handler 地址
9
    1114:  e8 97 ff ff ff         call   10b0 <signal@plt> ; 注册 SIGINT handler
10
    1119:  48 83 f8 ff            cmp    $0xffffffffffffffff,%rax  ; 检查返回值
11
    111d:  74 33                  je     1152 <main+0x52>  ; 失败则跳转到错误处理
12
    ...
13
    1132:  66 0f 1f 44 00 00      nopw   0x0(%rax,%rax,1)  ; 对齐填充
14
    ; 这里是 while (!shutdown_flag) 循环
15
    1138:  8b 05 d6 2e 00 00      mov    0x2ed6(%rip),%eax        # 4014 <shutdown_flag>
16
    113e:  85 c0                  test   %eax,%eax
17
    1140:  74 f6                  je     1138 <main+0x38>
18
    ;
19
    1142:  48 8d 3d 27 0f 00 00   lea    0xf27(%rip),%rdi        # 2070 <_IO_stdin_used+0x70>
20
    1149:  e8 52 ff ff ff         call   10a0 <puts@plt>
21
    114e:  31 c0                  xor    %eax,%eax         ; return 0 的三步走
22
    1150:  5d                     pop    %rbp              ; 恢复基指针 rbp
23
    1151:  c3                     ret                      ; 从函数调用中返回
24
    ; 下面是​错误处理部分 `1152 <main+0x52>` (省略)
25
    1152:  48 8d 3d c7 0e 00 00   lea    0xec7(%rip),%rdi        # 2020 <_IO_stdin_used+0x20>
26
    1159: e8 82 ff ff ff        call   10e0 <perror@plt> ; 打印错误
27
    115e: bf 01 00 00 00        mov    $0x1,%edi       ; 退出码 1
28
    1163: e8 88 ff ff ff        call   10f0 <exit@plt> ; 退出程序
29
    ...
30

31
0000000000001270 <_Z14signal_handleri>:
32
    1270: f3 0f 1e fa           endbr64          ; 启用 CET
33
    1274: 53                    push   %rbx      ; 保存 rbx
34
    1275: 89 fb                 mov    %edi,%ebx ; 保存信号编号到 ebx
35
    1277: e8 44 fe ff ff        call   10c0 <strsignal@plt> ; 获取信号描述的字符串
36
    127c: 89 da                 mov    %ebx,%edx ; edx=signo
37
    127e: bf 01 00 00 00        mov    $0x1,%edi ; edi=1 (stdout)
38
    1283: 48 8d 35 7a 0d 00 00  lea    0xd7a(%rip),%rsi        # 2004 <_IO_stdin_used+0x4>
39
    128a: 48 89 c1              mov    %rax,%rcx ; rcx=信号描述的字符串指针
40
    128d: 31 c0                 xor    %eax,%eax ; 清空 eax (用于浮点参数)
41
    128f: e8 3c fe ff ff        call   10d0 <__printf_chk@plt> ; 打印消息
42
    1294: 83 fb 02              cmp    $0x2,%ebx  ; 检查是否为 SIGINT(2)
43
    1297: 74 07                 je     12a0       ; 是则跳转
44
    1299: 83 fb 0f              cmp    $0xf,%ebx  ; 检查是否为 SIGTERM(15)
45
    129c: 74 02                 je     12a0       ; 是则跳转
46
    129e: 5b                    pop    %rbx       ; 恢复 rbx
47
    129f: c3                    ret               ; 从函数调用中返回
48
    12a0:  c7 05 6a 2d 00 00 01   movl   $0x1,0x2d6a(%rip)        # 4014 <shutdown_flag>

1
#[derive(Debug, Copy, Clone)]
2
pub struct Sigaction {
3
    action: SigactionType,
4
    flags: SigFlags,
5
    mask: SigSet,
6
    /// 信号处理函数执行结束后，将会跳转到这个函数内进行执行，然后执行 sigreturn 系统调用
7
    restorer: Option<VirtAddr>,
8
}

1
#include <chrono>
2
#include <csignal>
3
#include <iostream>
4
#include <mutex>
5
#include <thread>
6

7
using namespace std;
8

9
// 信号处理器函数
10
void signal_handler(int sig) {
11
    cerr << "Signal handler: attempting malloc\n";
12
    void* ptr = malloc(1 << 30); // 尝试获取 malloc 内部锁
13
    if (ptr)
14
        free(ptr);
15
    cerr << "Signal handler: malloc succeeded (never reached)\n";
16
}
17

18
// 工作线程函数
19
void worker_thread() {
20
    cout << "Worker thread started\n";
21
    // 调用 malloc 获取其内部锁
22
    cout << "Worker thread start malloc\n";
23
    void* ptr = malloc(1 << 30);
24
    ptr = malloc(1 << 30);
25
    ptr = malloc(1 << 30);
26
    ptr = malloc(1 << 30);
27
    ptr = malloc(1 << 30);
28
    cout << "Worker thread malloc end\n";
29
    // 如果出现 Working ，根据输出调整睡眠的时间，直到有机会在malloc触发的中断时，处理信号（笑）
30
    for (int i = 0; i < 2; ++i) {
31
        cout << "Working " << i + 1 << "/2...\n";
32
        this_thread::sleep_for(chrono::seconds(1));
33
    }
34
    free(ptr);
35
}
36

37
int main() {
38
    // 设置信号处理器
39
    struct sigaction sa {};
40
    sa.sa_handler = signal_handler;
41
    sigaction(SIGUSR1, &sa, nullptr);
42

43
    thread worker(worker_thread);
44
    // 等待线程进入临界区
45
    this_thread::sleep_for(chrono::nanoseconds(90)); // 需要根据你的实际情况调整sleep的时间
46
    pthread_kill(worker.native_handle(), SIGUSR1);
47
    cout << "\nMain: signal sent to worker thread\n";
48

49
    worker.join();
50
    cout << "Main: thread finished (never reached)\n";
51
    return 0;
52
}