# VS Code Installation
1. Open VS Code
2. Search "Codeium" in Extension Marketplace
3. Click Install
4. Restart VS Code
5. Start using AI programming

# JetBrains Installation
1. Open IDE
2. File → Settings → Plugins
3. Search "Codeium"
4. Install and restart

# VS Code 安装
1. 打开 VS Code
2. 扩展市场搜索 "Codeium"
3. 点击安装
4. 重启 VS Code
5. 开始使用 AI 编程

# JetBrains 安装
1. 打开 IDE
2. File → Settings → Plugins
3. 搜索 "Codeium"
4. 安装并重启

# VS Code 安装
1. 打开 VS Code
2. 扩展市场搜索 "Codeium"
3. 点击安装
4. 重启 VS Code
5. 开始使用 AI 编程

# JetBrains 安装
1. 打开 IDE
2. File → Settings → Plugins
3. 搜索 "Codeium"
4. 安装并重启

#include <signal.h>

int sigpending(sigset_t *set);

#define _GNU_SOURCE // 启用 GNU 扩展
#include <stdio.h>
#include <stdlib.h>  // 包含 exit
#include <unistd.h>  // 包含 sleep
#include <signal.h>  // 包含信号处理相关函数
#include <string.h>  // 包含 memset

// 一个简单的信号处理函数
void signal_handler(int sig) {
    printf("Caught signal %d\n", sig);
    // 在实际应用中，信号处理函数应尽量简短，并只调用异步信号安全函数
}

int main() {
    sigset_t block_set;      // 用于设置要阻塞的信号
    sigset_t pending_set;    // 用于接收待处理的信号集

    printf("My PID is: %d\n", getpid());

    // 1. 设置 SIGUSR1 和 SIGUSR2 的处理函数
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = signal_handler; // 使用上面定义的处理函数
    sigemptyset(&sa.sa_mask);       // 处理函数执行时不额外阻塞信号
    sa.sa_flags = 0;                // 没有特殊标志

    if (sigaction(SIGUSR1, &sa, NULL) == -1) { // 设置 SIGUSR1 的处理
        perror("sigaction SIGUSR1");
        exit(EXIT_FAILURE);
    }
    if (sigaction(SIGUSR2, &sa, NULL) == -1) { // 设置 SIGUSR2 的处理
        perror("sigaction SIGUSR2");
        exit(EXIT_FAILURE);
    }

    // 2. 创建一个信号集，并添加要阻塞的信号 (SIGUSR1 和 SIGUSR2)
    sigemptyset(&block_set);          // 初始化为空集
    sigaddset(&block_set, SIGUSR1);   // 添加 SIGUSR1
    sigaddset(&block_set, SIGUSR2);   // 添加 SIGUSR2

    // 3. 使用 sigprocmask 阻塞 SIGUSR1 和 SIGUSR2
    printf("Blocking SIGUSR1 and SIGUSR2...\n");
    printf("Try sending them now:\n");
    printf("  In another terminal, run: 'kill -USR1 %d'\n", getpid());
    printf("  In another terminal, run: 'kill -USR2 %d'\n", getpid());
    printf("Sleeping for 10 seconds...\n");

    if (sigprocmask(SIG_BLOCK, &block_set, NULL) == -1) {
        perror("sigprocmask BLOCK");
        exit(EXIT_FAILURE);
    }

    // 4. 在阻塞期间睡眠，等待信号发送
    sleep(10);
    printf("10 seconds passed. Signals should be pending now.\n");

    // 5. 调用 sigpending 检查哪些信号在等待
    if (sigpending(&pending_set) == -1) {
        perror("sigpending");
        exit(EXIT_FAILURE);
    }

    // 6. 检查并打印待处理的信号
    printf("Checking pending signals:\n");
    if (sigismember(&pending_set, SIGUSR1)) {
        printf("  SIGUSR1 is pending.\n");
    } else {
        printf("  SIGUSR1 is NOT pending.\n");
    }

    if (sigismember(&pending_set, SIGUSR2)) {
        printf("  SIGUSR2 is pending.\n");
    } else {
        printf("  SIGUSR2 is NOT pending.\n");
    }

    // 7. 解除对 SIGUSR1 和 SIGUSR2 的阻塞
    printf("Unblocking SIGUSR1 and SIGUSR2...\n");
    if (sigprocmask(SIG_UNBLOCK, &block_set, NULL) == -1) {
        perror("sigprocmask UNBLOCK");
        exit(EXIT_FAILURE);
    }

    printf("Unblocked. Any pending signals should be delivered now.\n");
    printf("Sleeping for 1 second to allow signal handlers to run...\n");
    sleep(1);

    printf("Program exiting.\n");
    return 0;
}

# 假设代码保存在 sigpending_example.c 中
gcc -o sigpending_example sigpending_example.c

# 终端 1: 运行程序
./sigpending_example
# 程序会输出 PID，例如 My PID is: 12345
# 然后提示你发送信号

# 终端 2: 发送信号 (在程序提示的 10 秒内执行)
kill -USR1 12345
kill -USR2 12345

# 观察终端 1 的输出，你会看到程序报告哪些信号是 pending 的，
# 以及在解除阻塞后信号被处理。

/**
 * kfifo的核心数据结构
 * 为什么这样设计？
 */
struct __kfifo {
    unsigned int    in;     // 入队索引
    unsigned int    out;    // 出队索引  
    unsigned int    mask;   // 掩码，用于快速取模运算
    unsigned int    esize;  // 元素大小
    void        *data;      // 数据缓冲区指针
};

// 为什么要求缓冲区大小是2的幂次方？
// 因为可以使用位运算代替取模运算，提高性能

// 普通取模运算
index = position % size;  // 除法运算，较慢

// 2的幂次方优化
mask = size - 1;          // 例如：size=8, mask=7 (0111)
index = position & mask;  // 位运算，非常快

// 示例：
// position = 10, size = 8
// 普通方法：10 % 8 = 2
// 优化方法：10 & 7 = 0x0A & 0x07 = 0x02 = 2

// 为什么使用分离的in/out索引而不是head/tail？
// 这样可以避免复杂的边界检查和锁机制

struct __kfifo {
    unsigned int in;   // 累计入队元素数
    unsigned int out;  // 累计出队元素数
    // 实际索引通过 in & mask 和 out & mask 计算
};

// 当前缓冲区中元素数量
unsigned int len = fifo->in - fifo->out;

// 实际写入位置
unsigned int write_index = fifo->in & fifo->mask;

// 实际读取位置  
unsigned int read_index = fifo->out & fifo->mask;

/**
 * 确保缓冲区大小是2的幂次方的算法
 */
static int __init kfifo_alloc_common(struct __kfifo *fifo, 
                                    unsigned int size,
                                    size_t esize,
                                    gfp_t gfp_mask)
{
    /*
     * Round up to the next power of 2, as vaddr_t is a power of 2,
     * and the FIFO size and cache line size are both powers of 2.
     */
    size = roundup_pow_of_two(size);
    
    fifo->in = 0;
    fifo->out = 0;
    fifo->esize = esize;
    
    if (size < 2) {
        fifo->data = NULL;
        fifo->mask = 0;
        return -EINVAL;
    }
    
    fifo->data = kmalloc(size * esize, gfp_mask);
    if (!fifo->data) {
        fifo->mask = 0;
        return -ENOMEM;
    }
    
    fifo->mask = size - 1;  // 关键：掩码用于快速取模
    
    return 0;
}

/**
 * 位运算优化示例
 */
// 传统方法：使用取模运算
int traditional_index(int position, int size) {
    return position % size;  // 涉及除法运算，较慢
}

// kfifo方法：使用位运算
int optimized_index(int position, int mask) {
    return position & mask;  // 位运算，非常快
}

// 示例对比：
// size = 8 (2^3), mask = 7 (0111)
// position = 0..15 的索引计算：
// 位置 0: 0 & 7 = 0    0 % 8 = 0
// 位置 1: 1 & 7 = 1    1 % 8 = 1  
// 位置 7: 7 & 7 = 7    7 % 8 = 7
// 位置 8: 8 & 7 = 0    8 % 8 = 0  (循环回到开始)
// 位置 9: 9 & 7 = 1    9 % 8 = 1  (循环)

/**
 * 无锁kfifo的核心：单生产者单消费者场景
 * 在这种场景下，in和out变量分别只被一个线程修改，无需锁保护
 */

// 生产者线程（只能修改in变量）
unsigned int kfifo_in(struct __kfifo *fifo,
                      const void *buf, unsigned int len)
{
    unsigned int l;
    
    // 计算可用空间
    len = min(len, fifo->mask + 1 - fifo->in + fifo->out);
    
    /* first put the data starting from fifo->in to buffer end */
    l = min(len, fifo->mask + 1 - (fifo->in & fifo->mask));
    memcpy(fifo->data + (fifo->in & fifo->mask) * fifo->esize, buf, l * fifo->esize);
    
    /* then put the rest (if any) at the beginning of the buffer */
    memcpy(fifo->data, (char *)buf + l * fifo->esize,
           (len - l) * fifo->esize);
    
    /*
     * Ensure that we add the bytes to the kfifo -before-
     * we update the fifo->in index.
     */
    smp_wmb();  // 内存屏障，确保数据写入完成
    
    fifo->in += len;  // 原子更新in索引
    
    return len;
}

// 消费者线程（只能修改out变量）  
unsigned int kfifo_out(struct __kfifo *fifo,
                       void *buf, unsigned int len)
{
    unsigned int l;
    
    // 计算可用数据
    len = min(len, fifo->in - fifo->out);
    
    /* first get the data from fifo->out until the end of the buffer */
    l = min(len, fifo->mask + 1 - (fifo->out & fifo->mask));
    memcpy(buf, fifo->data + (fifo->out & fifo->mask) * fifo->esize, l * fifo->esize);
    
    /* then get the rest (if any) from the beginning of the buffer */
    memcpy((char *)buf + l * fifo->esize, fifo->data,
           (len - l) * fifo->esize);
    
    /*
     * Ensure that we remove the bytes from the kfifo -before-
     * we update the fifo->out index.
     */
    smp_mb();  // 内存屏障
    
    fifo->out += len;  // 原子更新out索引
    
    return len;
}

/**
 * 内存屏障的重要性
 * 防止编译器和CPU重排序导致的数据不一致
 */

// 生产者端
smp_wmb();  // write memory barrier
// 确保数据写入缓冲区的操作在更新in索引之前完成
fifo->in += len;

// 消费者端  
smp_mb();   // memory barrier
// 确保读取数据的操作在更新out索引之前完成
fifo->out += len;

/**
 * 环形缓冲区的挑战：数据可能跨越缓冲区边界
 * 需要分两段复制
 */

// 示例：缓冲区大小为8，当前状态
// [0][1][2][3][4][5][6][7]
//        ^out      ^in
// 数据在位置[3][4][5][6][7]

// 当要写入大量数据时，可能需要分两段：
// 第一段：从in位置到缓冲区末尾
// 第二段：从缓冲区开始到剩余数据

unsigned int kfifo_in(struct __kfifo *fifo,
                      const void *buf, unsigned int len)
{
    unsigned int l;
    
    // 计算第一段可以写入的数据量
    l = min(len, fifo->mask + 1 - (fifo->in & fifo->mask));
    
    // 第一段复制：从当前in位置到缓冲区末尾
    memcpy(fifo->data + (fifo->in & fifo->mask) * fifo->esize, 
           buf, 
           l * fifo->esize);
    
    // 第二段复制：如果还有剩余数据，从缓冲区开始处继续
    memcpy(fifo->data,
           (char *)buf + l * fifo->esize,
           (len - l) * fifo->esize);
    
    fifo->in += len;
    return len;
}

/**
 * 空/满状态判断的巧妙设计
 */

// 判断是否为空
#define kfifo_is_empty(fifo) \
({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    __kfifo->in == __kfifo->out; \
})

// 判断是否为满
#define kfifo_is_full(fifo) \
({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    kfifo_len(__tmp) == __kfifo->mask + 1; \
})

// 计算当前元素数量
#define kfifo_len(fifo) \
({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    __kfifo->in - __kfifo->out; \
})

// 为什么满状态是 len == mask + 1？
// 因为需要保留一个空位来区分空和满状态
// 如果in == out，表示空
// 如果in == out + size，表示满（但这样in和out会相等）
// 所以实际容量是 size - 1

/**
 * kfifo的类型安全设计
 */

// 类型安全的宏定义
#define DECLARE_KFIFO(name, size) \
    struct { \
        struct __kfifo kfifo; \
        typeof(name) *rectype; \
    } name

// 类型安全的入队操作
#define kfifo_put(fifo, val) \
({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    typeof(*val) __val = (val); \
    unsigned int __ret; \
    size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    __ret = __kfifo_uint32s_put(__kfifo, __val, __recsize); \
    __ret; \
})

// 类型安全的出队操作
#define kfifo_get(fifo, val) \
({ \
    typeof((fifo) + 1) __tmp = (fifo); \
    typeof(val) __val = (val); \
    unsigned int __ret; \
    const size_t __recsize = sizeof(*__tmp->rectype); \
    struct __kfifo *__kfifo = &__tmp->kfifo; \
    __ret = __kfifo_uint32s_out(__kfifo, __val, __recsize); \
    __ret; \
})

// 使用示例：
DECLARE_KFIFO(my_fifo, 32);  // 声明一个可以存储32个int的kfifo
int value = 42;
kfifo_put(&my_fifo, &value); // 类型安全的入队
kfifo_get(&my_fifo, &value); // 类型安全的出队

/**
 * 编译时类型检查
 */
#define __KFIFO_PEEK(data, out, mask) \
    ((data)[(out) & (mask)])

#define __KFIFO_POKE(data, in, mask, val) \
    ( (data)[(in) & (mask)] = (val) )

// 这些宏确保在编译时就能发现类型错误

/**
 * 缓存友好的数据布局
 */

struct __kfifo {
    unsigned int    in;     // 控制信息集中存储
    unsigned int    out;    // 提高缓存命中率
    unsigned int    mask;
    unsigned int    esize;
    void        *data;      // 数据指针单独存储
};

// 为什么这样布局？
// 1. 控制信息连续存储，提高缓存局部性
// 2. 频繁访问的in/out字段相邻，减少缓存行加载
// 3. data指针单独存储，避免数据移动时的拷贝

/**
 * 利用编译器优化
 */

// 内联函数减少函数调用开销
static inline unsigned int kfifo_len(struct __kfifo *fifo)
{
    return fifo->in - fifo->out;
}

// 编译时常量传播
#define KFIFO_SIZE 1024
// 编译器可以将 mask = KFIFO_SIZE - 1 优化为常量

// 分支预测提示
#define likely(x)   __builtin_expect(!!(x), 1)
#define unlikely(x) __builtin_expect(!!(x), 0)

/**
 * Linux内核中的kfifo应用示例
 */

// 1. 网络数据包缓冲
struct sk_buff_head {
    struct __kfifo  skb_queue;
    // ...
};

// 2. 工作队列
struct workqueue_struct {
    struct __kfifo  work_list;
    // ...
};

// 3. 字符设备缓冲
struct tty_port {
    struct __kfifo  buf;
    // ...
};

// 4. 中断处理
struct irq_desc {
    struct __kfifo  pending_mask;
    // ...
};

/**
 * 用户空间kfifo实现要点
 */

// 1. 替换内核内存分配函数
// kmalloc -> malloc
// kfree -> free

// 2. 替换内核同步原语
// spin_lock -> pthread_mutex_lock
// smp_mb -> __sync_synchronize 或者使用互斥锁

// 3. 替换内核特定宏
// likely/unlikely -> 保持或移除
// container_of -> 自定义实现

// 4. 错误处理
// 内核返回负数错误码 -> 用户空间返回-1并设置errno

#include <signal.h>

int sigprocmask(int how, const sigset_t *set, sigset_t *oldset);

#define _GNU_SOURCE // 启用 GNU 扩展
#include <stdio.h>
#include <stdlib.h>  // 包含 exit
#include <unistd.h>  // 包含 sleep
#include <signal.h>  // 包含信号处理相关函数
#include <string.h>  // 包含 memset

// 一个简单的信号处理函数
void signal_handler(int sig) {
    printf("\nCaught signal %d\n", sig);
    // 在实际应用中，信号处理函数应尽量简短，并只调用异步信号安全函数
}

int main() {
    sigset_t block_set;       // 用于设置要阻塞的信号
    sigset_t prev_set;        // 用于保存之前的信号屏蔽字 (可选)
    sigset_t current_set;     // 用于检查当前的信号屏蔽字 (可选)

    printf("My PID is: %d\n", getpid());

    // 1. 设置 SIGUSR1 和 SIGINT (Ctrl+C) 的处理函数
    struct sigaction sa;
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = signal_handler;
    sigemptyset(&sa.sa_mask); // 处理函数执行时不额外阻塞信号
    sa.sa_flags = 0;

    if (sigaction(SIGUSR1, &sa, NULL) == -1) {
        perror("sigaction SIGUSR1");
        exit(EXIT_FAILURE);
    }
    if (sigaction(SIGINT, &sa, NULL) == -1) {
        perror("sigaction SIGINT");
        exit(EXIT_FAILURE);
    }

    // 2. 创建一个信号集，并添加要阻塞的信号 (SIGUSR1)
    sigemptyset(&block_set);
    sigaddset(&block_set, SIGUSR1);
    // 注意：我们没有阻塞 SIGINT，所以 Ctrl+C 仍然有效

    // 3. 使用 sigprocmask 阻塞 SIGUSR1，并保存旧的屏蔽字
    printf("Blocking SIGUSR1...\n");
    printf("Try sending SIGUSR1 now: 'kill -USR1 %d'\n", getpid());
    printf("Try pressing Ctrl+C (SIGINT) now - it should still work.\n");
    printf("Sleeping for 10 seconds (signals are blocked/unblocked accordingly)...\n");

    if (sigprocmask(SIG_BLOCK, &block_set, &prev_set) == -1) { // 阻塞并保存旧设置
        perror("sigprocmask BLOCK");
        exit(EXIT_FAILURE);
    }

    printf("SIGUSR1 is now blocked. Sleeping for 5 seconds...\n");
    sleep(5); // 在这5秒内，SIGUSR1会被阻塞，SIGINT不会

    // 4. 演示 SIG_SETMASK: 只阻塞 SIGINT，解除对 SIGUSR1 的阻塞
    sigemptyset(&block_set);
    sigaddset(&block_set, SIGINT); // 现在只阻塞 SIGINT
    printf("5 seconds passed. Now blocking only SIGINT (Ctrl+C) using SIG_SETMASK.\n");
    printf("Try sending SIGUSR1 now: 'kill -USR1 %d' - it should be caught immediately.\n");
    printf("Try pressing Ctrl+C (SIGINT) now - it should be blocked.\n");
    if (sigprocmask(SIG_SETMASK, &block_set, NULL) == -1) { // 设置新的屏蔽字
        perror("sigprocmask SETMASK");
        exit(EXIT_FAILURE);
    }

    printf("SIGINT is now blocked. Sleeping for 5 more seconds...\n");
    sleep(5); // 在这5秒内，SIGINT会被阻塞，SIGUSR1不会

    // 5. 演示 SIG_UNBLOCK: 解除对 SIGINT 的阻塞
    // 我们解除阻塞的集合就是当前阻塞的集合 (block_set)
    printf("5 seconds passed. Now unblocking SIGINT (Ctrl+C) using SIG_UNBLOCK.\n");
    printf("Try pressing Ctrl+C (SIGINT) now - it should work and terminate the program.\n");
    if (sigprocmask(SIG_UNBLOCK, &block_set, NULL) == -1) { // 解除阻塞
        perror("sigprocmask UNBLOCK");
        exit(EXIT_FAILURE);
    }

    printf("SIGINT is now unblocked. Sleeping for 10 more seconds...\n");
    printf("The program will end if you press Ctrl+C.\n");
    sleep(10); // 最后10秒，所有信号都按正常处理

    printf("Program exiting normally after sleep.\n");
    return 0;
}

# 假设代码保存在 sigprocmask_example.c 中
gcc -o sigprocmask_example sigprocmask_example.c

# 终端 1: 运行程序
./sigprocmask_example
# 程序会输出 PID，例如 My PID is: 12345

# 终端 2 (在程序的不同睡眠阶段执行以下命令):
# 阶段 1 (前5秒): SIGUSR1 被阻塞
# kill -USR1 12345
# (观察终端 1，信号处理函数不会立即触发)

# 阶段 2 (中间5秒): SIGINT 被阻塞, SIGUSR1 正常
# kill -USR1 12345
# (观察终端 1，信号处理函数应该立即触发)
# kill -INT 12345 或按 Ctrl+C 在终端 1
# (观察终端 1，Ctrl+C 应该无效)

# 阶段 3 (最后10秒): SIGINT 解除阻塞
# 按 Ctrl+C 在终端 1
# (程序应该退出)
# 或者
# kill -INT 12345
# (程序应该退出)

// 这是底层系统调用，直接在用户空间调用比较复杂且需要特殊权限
#include <sys/syscall.h>   // 包含系统调用号
#include <unistd.h>        // 包含 syscall 函数
#include <signal.h>        // 包含 siginfo_t 定义

long syscall(SYS_rt_sigqueueinfo, pid_t pid, int sig, siginfo_t *uinfo);
// 注意：用户空间标准 C 库通常不直接提供 rt_sigqueueinfo 的包装函数

#include <signal.h>

int sigqueue(pid_t pid, int sig, const union sigval value);

#define _GNU_SOURCE // 启用 GNU 扩展
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <sys/syscall.h> // 包含 syscall 和 SYS_rt_sigqueueinfo
#include <errno.h>
#include <sys/types.h> // 包含 pid_t

// 用于接收信号的处理函数 (使用 SA_SIGINFO 获取详细信息)
void signal_handler(int sig, siginfo_t *info, void *context) {
    printf("Received signal %d\n", sig);
    printf("  si_signo: %d\n", info->si_signo);
    printf("  si_code:  %d", info->si_code);
    switch(info->si_code) {
        case SI_USER: printf(" (SI_USER: kill, sigsend or raise)\n"); break;
        case SI_QUEUE: printf(" (SI_QUEUE: sigqueue)\n"); break;
        case SI_KERNEL: printf(" (SI_KERNEL: sent by kernel)\n"); break;
        case SI_TKILL: printf(" (SI_TKILL: tkill or tgkill)\n"); break;
        default: printf(" (Other code)\n"); break;
    }
    printf("  si_pid:   %d\n", info->si_pid);
    printf("  si_uid:   %d\n", info->si_uid);
    if (info->si_code == SI_QUEUE) {
        printf("  si_value.sival_int: %d\n", info->si_value.sival_int);
        printf("  si_value.sival_ptr: %p\n", info->si_value.sival_ptr);
    }
    // 注意：这里为了演示打印了信息，但实际信号处理函数应只调用异步信号安全函数
}

int main() {
    pid_t my_pid = getpid();
    struct sigaction sa;
    siginfo_t si_to_send;
    union sigval data_to_send = {.sival_int = 999};

    printf("My PID is: %d\n", my_pid);

    // 1. 设置 SIGUSR1 的处理函数，使用 SA_SIGINFO 获取详细信息
    memset(&sa, 0, sizeof(sa));
    sa.sa_sigaction = signal_handler; // 注意是 sa_sigaction
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_SIGINFO; // 必须设置此标志
    if (sigaction(SIGUSR1, &sa, NULL) == -1) {
        perror("sigaction");
        exit(EXIT_FAILURE);
    }

    // --- 方法 1: 使用标准的 sigqueue (推荐) ---
    printf("\n--- Using sigqueue (Recommended) ---\n");
    printf("Sending SIGUSR1 with data %d using sigqueue()...\n", data_to_send.sival_int);
    if (sigqueue(my_pid, SIGUSR1, data_to_send) == -1) {
        perror("sigqueue");
        // sigqueue 失败通常是因为资源限制或信号无效
    }
    sleep(1); // 给点时间处理信号

    // --- 方法 2: 使用 rt_sigqueueinfo (不推荐，仅供演示) ---
    printf("\n--- Using rt_sigqueueinfo (Not Recommended) ---\n");
    // 2. 准备 siginfo_t 结构体
    memset(&si_to_send, 0, sizeof(si_to_send));
    si_to_send.si_signo = SIGUSR1;  // 信号号
    si_to_send.si_code = SI_QUEUE;  // 伪造为 sigqueue 发送的
    si_to_send.si_pid = my_pid;     // 伪造 PID
    si_to_send.si_uid = getuid();   // 伪造 UID
    si_to_send.si_value = data_to_send; // 附带数据

    printf("Attempting to send SIGUSR1 with forged info using rt_sigqueueinfo()...\n");
    printf("(This will likely fail with EPERM unless run with special privileges)\n");
    // 3. 调用底层系统调用
    long result = syscall(SYS_rt_sigqueueinfo, my_pid, SIGUSR1, &si_to_send);

    if (result == -1) {
        perror("rt_sigqueueinfo");
        printf("Error: rt_sigqueueinfo failed. This is expected for unprivileged processes.\n");
        printf("Errno: %d\n", errno);
        if (errno == EPERM) {
            printf("Reason: EPERM - Operation not permitted (insufficient privileges to forge signal info).\n");
        }
    } else {
        printf("rt_sigqueueinfo succeeded (unexpected for unprivileged user).\n");
    }

    sleep(1); // 给点时间处理可能的信号

    // --- 方法 3: 使用 rt_sigqueueinfo 伪造为内核发送 (非常不推荐) ---
    printf("\n--- Forging signal as from Kernel (Highly Not Recommended) ---\n");
    si_to_send.si_code = SI_KERNEL; // 尝试伪造为内核发送
    printf("Attempting to forge signal as sent by the KERNEL...\n");
    result = syscall(SYS_rt_sigqueueinfo, my_pid, SIGUSR1, &si_to_send);

    if (result == -1) {
        perror("rt_sigqueueinfo (forged as kernel)");
        printf("Error: Forging kernel signal failed (as expected).\n");
    } else {
        printf("rt_sigqueueinfo (forged as kernel) succeeded (highly unexpected!).\n");
    }

    sleep(1);

    printf("\nProgram finished.\n");
    return 0;
}

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>

void signal_handler(int sig, siginfo_t *info, void *context) {
    if (info->si_code == SI_QUEUE) {
        printf("Received signal %d with value: %d\n", sig, info->si_value.sival_int);
    } else {
        printf("Received signal %d (not from sigqueue)\n", sig);
    }
}

int main() {
    pid_t pid;
    struct sigaction sa;
    union sigval value1 = {.sival_int = 100};
    union sigval value2 = {.sival_int = 200};

    // 设置信号处理函数
    memset(&sa, 0, sizeof(sa));
    sa.sa_sigaction = signal_handler;
    sigemptyset(&sa.sa_mask);
    sa.sa_flags = SA_SIGINFO;
    if (sigaction(SIGUSR1, &sa, NULL) == -1) {
        perror("sigaction");
        exit(EXIT_FAILURE);
    }

    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {
        // Child: 发送信号给父进程
        sleep(1);
        printf("Child: Sending SIGUSR1 with value %d\n", value1.sival_int);
        if (sigqueue(getppid(), SIGUSR1, value1) == -1) {
            perror("sigqueue 1");
        }

        sleep(1);
        printf("Child: Sending SIGUSR1 with value %d\n", value2.sival_int);
        if (sigqueue(getppid(), SIGUSR1, value2) == -1) {
            perror("sigqueue 2");
        }

        exit(EXIT_SUCCESS);
    } else {
        // Parent: 等待信号
        printf("Parent: Waiting for signals...\n");
        sleep(5); // 等待子进程发送信号并处理
        wait(NULL); // 等待子进程结束
        printf("Parent: Finished.\n");
    }

    return 0;
}

# 假设代码保存在 rt_sigqueueinfo_example.c 和 sigqueue_example.c 中
gcc -o rt_sigqueueinfo_example rt_sigqueueinfo_example.c
gcc -o sigqueue_example sigqueue_example.c

# 运行第一个示例 (会展示 rt_sigqueueinfo 的权限限制)
./rt_sigqueueinfo_example

# 运行第二个示例 (推荐的 sigqueue 用法)
./sigqueue_example

// 这是内核系统调用，用户空间程序不会直接调用它。
// 它的原型在内核源码中类似这样 (概念性)：
asmlinkage long sys_rt_sigreturn(void);

#define _GNU_SOURCE // 启用 GNU 扩展
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <sys/time.h> // 包含 setitimer

// 全局变量，用于在主程序和信号处理函数间通信
volatile sig_atomic_t alarm_received = 0;

// 信号处理函数
void alarm_handler(int sig) {
    // 注意：在信号处理函数中应只使用异步信号安全的函数
    // printf 通常不安全，但为了演示我们简化使用
    printf("  >>> Alarm signal (%d) received! <<<\n", sig);
    alarm_received = 1; // 设置标志

    // 模拟在信号处理函数中做一些工作
    for (int i = 0; i < 3; ++i) {
        printf("  >>> Working in signal handler... %d <<<\n", i+1);
        sleep(1); // 暂停1秒
    }
    printf("  >>> Signal handler finished. <<<\n");
    // 当这个函数执行 return 时，
    // 运行时库会安排调用 rt_sigreturn 系统调用
    // 来恢复主程序的执行状态
}

int main() {
    struct sigaction sa;
    struct itimerval timer;

    printf("Main program starting...\n");
    printf("PID: %d\n", getpid());

    // 1. 设置 SIGALRM 的处理函数
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = alarm_handler;
    sigemptyset(&sa.sa_mask);
    // 不设置 SA_RESTART，这样被中断的系统调用会返回 EINTR
    sa.sa_flags = 0;
    if (sigaction(SIGALRM, &sa, NULL) == -1) {
        perror("sigaction");
        exit(EXIT_FAILURE);
    }

    // 2. 设置定时器，在 3 秒后产生 SIGALRM 信号
    memset(&timer, 0, sizeof(timer));
    timer.it_value.tv_sec = 3;    // 3秒后启动
    timer.it_value.tv_usec = 0;
    timer.it_interval.tv_sec = 0; // 不重复
    timer.it_interval.tv_usec = 0;
    printf("Setting alarm for 3 seconds...\n");
    if (setitimer(ITIMER_REAL, &timer, NULL) == -1) {
        perror("setitimer");
        exit(EXIT_FAILURE);
    }

    printf("Entering main loop. Will be interrupted by alarm in 3 seconds.\n");

    int counter = 0;
    while (counter < 10) {
        printf("Main loop iteration %d\n", counter);
        counter++;

        // 调用一个可能被信号中断的系统调用
        printf("Calling sleep(2)...\n");
        int sleep_result = sleep(2);

        // 如果 sleep 被信号中断，它会提前返回剩余的睡眠时间
        if (sleep_result > 0) {
            printf("Sleep was interrupted with %d seconds remaining.\n", sleep_result);
            // 检查我们的标志是否被信号处理函数设置
            if (alarm_received) {
                printf("Confirmed: Alarm was received and handled.\n");
                printf("Now continuing main loop execution.\n");
                // 重置标志
                alarm_received = 0;
            }
        } else {
            printf("Sleep completed normally.\n");
        }

        printf("---\n");
    }

    printf("Main program finished.\n");
    return 0;
}

# 假设代码保存在 sigreturn_example.c 中
gcc -o sigreturn_example sigreturn_example.c

# 运行程序
./sigreturn_example

Main program starting...
PID: 12345
Setting alarm for 3 seconds...
Entering main loop. Will be interrupted by alarm in 3 seconds.
Main loop iteration 0
Calling sleep(2)...
  >>> Alarm signal (14) received! <<<
  >>> Working in signal handler... 1 <<<
  >>> Working in signal handler... 2 <<<
  >>> Working in signal handler... 3 <<<
  >>> Signal handler finished. <<<
Sleep was interrupted with 1 seconds remaining.
Confirmed: Alarm was received and handled.
Now continuing main loop execution.
---
Main loop iteration 1
Calling sleep(2)...
Sleep completed normally.
---
... (后续循环) ...

#include <signal.h>

// 带超时时间的版本
int sigtimedwait(const sigset_t *set, siginfo_t *info, const struct timespec *timeout);

// 不带超时时间的版本 (无限期等待)
int sigwaitinfo(const sigset_t *set, siginfo_t *info);
// sigwaitinfo(set, info) 实际上等价于 sigtimedwait(set, info, NULL);

#define _GNU_SOURCE // 启用 GNU 扩展以使用 sigqueue 等
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <sys/types.h> // 包含 pid_t
#include <sys/wait.h>  // 包含 wait
#include <errno.h>     // 包含 errno, EAGAIN
#include <time.h>      // 包含 timespec

int main() {
    pid_t pid;
    sigset_t wait_set;  // 定义要等待的信号集
    siginfo_t info;     // 用于接收信号信息
    struct timespec timeout; // 超时时间
    int sig_received;   // 存储接收到的信号号
    union sigval value; // 用于发送数据

    printf("Main (Parent) process PID: %d\n", getpid());

    // 1. 创建要等待的信号集：SIGUSR1 和 SIGRTMIN (一个实时信号)
    sigemptyset(&wait_set);        // 初始化为空集
    sigaddset(&wait_set, SIGUSR1); // 添加 SIGUSR1
    sigaddset(&wait_set, SIGRTMIN); // 添加 SIGRTMIN
    printf("Configured to wait for SIGUSR1 (%d) and SIGRTMIN (%d)\n", SIGUSR1, SIGRTMIN);

    // 2. 非常重要：在调用 sigtimedwait/sigwaitinfo 之前，
    // 必须先阻塞掉你打算等待的信号。
    // 这样可以确保这些信号在发送和等待之间不会被意外地异步处理掉。
    if (sigprocmask(SIG_BLOCK, &wait_set, NULL) == -1) {
        perror("sigprocmask BLOCK");
        exit(EXIT_FAILURE);
    }
    printf("Blocked SIGUSR1 and SIGRTMIN to queue them for synchronous waiting.\n");

    // 3. Fork 一个子进程来发送信号
    pid = fork();
    if (pid == -1) {
        perror("fork");
        exit(EXIT_FAILURE);
    }

    if (pid == 0) {
        // --- Child Process ---
        printf("\nChild process (PID: %d) started.\n", getpid());

        sleep(2); // 等待 2 秒，让父进程先进入等待状态
        printf("Child: Sending SIGUSR1 to parent (PID: %d) using kill()...\n", getppid());
        if (kill(getppid(), SIGUSR1) == -1) { // 使用 kill 发送简单信号
            perror("kill SIGUSR1");
            exit(EXIT_FAILURE);
        }

        sleep(3); // 再等待 3 秒
        // 使用 sigqueue 发送实时信号和数据
        value.sival_int = 12345;
        printf("Child: Sending SIGRTMIN with value %d to parent using sigqueue()...\n", value.sival_int);
        if (sigqueue(getppid(), SIGRTMIN, value) == -1) {
            perror("sigqueue SIGRTMIN");
            exit(EXIT_FAILURE);
        }

        sleep(3); // 再等待 3 秒
        printf("Child: Sending SIGUSR1 again to parent using kill()...\n");
        if (kill(getppid(), SIGUSR1) == -1) {
            perror("kill SIGUSR1 (again)");
            exit(EXIT_FAILURE);
        }

        printf("Child process finished.\n");
        exit(EXIT_SUCCESS);

    } else {
        // --- Parent Process ---
        printf("\nParent process now waiting for signals synchronously...\n");

        // 4. 使用 sigwaitinfo 无限期等待第一个信号
        printf("\n--- Parent: Calling sigwaitinfo (will wait indefinitely) ---\n");
        printf("Parent: Waiting for either SIGUSR1 or SIGRTMIN...\n");
        // sigwaitinfo 会解除对 wait_set 中信号的阻塞，并等待其中一个到来
        sig_received = sigwaitinfo(&wait_set, &info); // 等待 set 中任意一个信号
        if (sig_received == -1) {
            perror("sigwaitinfo"); // 通常不会发生，除非被其他未阻塞的信号中断
        } else {
            printf("Parent: sigwaitinfo successfully returned.\n");
            printf("  Parent: Received signal number: %d\n", sig_received);
            if (sig_received == SIGUSR1) {
                printf("  Parent: It was SIGUSR1.\n");
                printf("  Parent: Sender PID: %d\n", info.si_pid);
                // SIGUSR1 通过 kill 发送，通常 si_code 是 SI_USER
                printf("  Parent: si_code: %d (SI_USER=%d)\n", info.si_code, SI_USER);
            }
        }

        // 5. 使用 sigtimedwait 等待下一个信号，设置 5 秒超时
        printf("\n--- Parent: Calling sigtimedwait (with 5s timeout) ---\n");
        timeout.tv_sec = 5;  // 5 秒
        timeout.tv_nsec = 0; // 0 纳秒
        printf("Parent: Waiting for next signal (timeout set to 5 seconds)...\n");
        sig_received = sigtimedwait(&wait_set, &info, &timeout);
        if (sig_received == -1) {
            if (errno == EAGAIN) {
                printf("Parent: sigtimedwait timed out. No signal arrived within 5 seconds.\n");
            } else {
                perror("Parent: sigtimedwait"); // 其他错误，如被其他信号中断 (EINTR)
            }
        } else {
            printf("Parent: sigtimedwait successfully returned before timeout.\n");
            printf("  Parent: Received signal number: %d\n", sig_received);
            if (sig_received == SIGRTMIN) {
                // SIGRTMIN 通过 sigqueue 发送，si_code 是 SI_QUEUE
                if (info.si_code == SI_QUEUE) {
                    printf("  Parent: It was SIGRTMIN sent via sigqueue().\n");
                    printf("  Parent: Sender PID: %d\n", info.si_pid);
                    printf("  Parent: Attached integer value: %d\n", info.si_value.sival_int);
                }
            }
        }

        // 6. 再次使用 sigwaitinfo 等待信号 (应该很快收到之前发送的 SIGUSR1)
        printf("\n--- Parent: Calling sigwaitinfo again ---\n");
        printf("Parent: Waiting for any of {SIGUSR1, SIGRTMIN} again...\n");
        sig_received = sigwaitinfo(&wait_set, &info);
        if (sig_received != -1) {
             printf("Parent: sigwaitinfo successfully returned.\n");
             printf("  Parent: Received signal number: %d\n", sig_received);
             if (sig_received == SIGUSR1) {
                 printf("  Parent: It was SIGUSR1.\n");
                 printf("  Parent: Sender PID: %d\n", info.si_pid);
             }
        } else {
            perror("Parent: sigwaitinfo (second call)");
        }

        // 7. 等待子进程结束
        if (wait(NULL) == -1) {
            perror("wait");
        }
        printf("\nParent: Confirmed child process (PID %d) has finished. Parent exiting.\n", pid);
    }

    return 0;
}

# 假设代码保存在 sigtimedwait_example.c 中
gcc -o sigtimedwait_example sigtimedwait_example.c

# 运行程序
./sigtimedwait_example

Main (Parent) process PID: 12345
Configured to wait for SIGUSR1 (10) and SIGRTMIN (34)
Blocked SIGUSR1 and SIGRTMIN to queue them for synchronous waiting.

Parent process now waiting for signals synchronously...

--- Parent: Calling sigwaitinfo (will wait indefinitely) ---
Parent: Waiting for either SIGUSR1 or SIGRTMIN...
Child process (PID: 12346) started.
Child: Sending SIGUSR1 to parent (PID: 12345) using kill()...
Parent: sigwaitinfo successfully returned.
  Parent: Received signal number: 10
  Parent: It was SIGUSR1.
  Parent: Sender PID: 12346
  Parent: si_code: 0 (SI_USER=0) # SI_USER 的值在不同系统上可能不同，通常是 0

--- Parent: Calling sigtimedwait (with 5s timeout) ---
Parent: Waiting for next signal (timeout set to 5 seconds)...
Child: Sending SIGRTMIN with value 12345 to parent using sigqueue()...
Parent: sigtimedwait successfully returned before timeout.
  Parent: Received signal number: 34
  Parent: It was SIGRTMIN sent via sigqueue().
  Parent: Sender PID: 12346
  Parent: Attached integer value: 12345

--- Parent: Calling sigwaitinfo again ---
Parent: Waiting for any of {SIGUSR1, SIGRTMIN} again...
Child: Sending SIGUSR1 again to parent using kill()...
Child process finished.
Parent: sigwaitinfo successfully returned.
  Parent: Received signal number: 10
  Parent: It was SIGUSR1.
  Parent: Sender PID: 12346

Parent: Confirmed child process (PID 12346) has finished. Parent exiting.

#include <signal.h>

int sigsuspend(const sigset_t *mask);

#define _GNU_SOURCE // 启用 GNU 扩展
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <errno.h> // 包含 errno 和 EINTR

// 使用 volatile sig_atomic_t 类型的全局变量在主程序和信号处理函数间通信
// sig_atomic_t 类型保证了对它的读写是原子的
volatile sig_atomic_t sigusr1_flag = 0;

// SIGUSR1 信号的处理函数
void handle_sigusr1(int sig) {
    // 在信号处理函数中，只应使用异步信号安全的函数
    // write 是安全的，printf 通常不安全
    write(STDOUT_FILENO, "Caught SIGUSR1!\n", 17);
    // 设置标志，通知主程序信号已收到
    sigusr1_flag = 1;
}

int main() {
    struct sigaction sa;
    sigset_t block_most_signals;  // 用于阻塞大部分信号
    sigset_t orig_mask;           // 用于保存原始信号掩码
    sigset_t suspend_mask;        // 用于 sigsuspend 的临时掩码

    printf("My PID is: %d\n", getpid());
    printf("Run 'kill -USR1 %d' in another terminal to wake me up.\n", getpid());

    // 1. 设置 SIGUSR1 的处理函数
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = handle_sigusr1;
    sigemptyset(&sa.sa_mask); // 在处理 SIGUSR1 时，不额外阻塞其他信号
    sa.sa_flags = 0;          // 没有特殊标志
    if (sigaction(SIGUSR1, &sa, NULL) == -1) {
        perror("sigaction SIGUSR1");
        exit(EXIT_FAILURE);
    }

    // 2. 创建一个信号集，包含几乎所有信号
    if (sigfillset(&block_most_signals) == -1) {
        perror("sigfillset");
        exit(EXIT_FAILURE);
    }
    // 从这个集合中移除 SIGUSR1，允许它被接收
    if (sigdelset(&block_most_signals, SIGUSR1) == -1) {
        perror("sigdelset SIGUSR1");
        exit(EXIT_FAILURE);
    }
    // 也可以移除 SIGINT (Ctrl+C) 和 SIGTERM，以便能正常终止程序
    if (sigdelset(&block_most_signals, SIGINT) == -1) {
        perror("sigdelset SIGINT");
        // 不 exit，继续尝试
    }
    if (sigdelset(&block_most_signals, SIGTERM) == -1) {
        perror("sigdelset SIGTERM");
        // 不 exit，继续尝试
    }

    // 3. 使用 sigprocmask 应用这个“阻塞大部分信号”的掩码
    // 同时保存当前（原始）的信号掩码到 orig_mask
    printf("Blocking most signals, only allowing SIGUSR1, SIGINT, SIGTERM.\n");
    if (sigprocmask(SIG_SETMASK, &block_most_signals, &orig_mask) == -1) {
        perror("sigprocmask SETMASK");
        exit(EXIT_FAILURE);
    }

    // 4. 创建 sigsuspend 使用的临时掩码
    // 这个掩码定义了在 sigsuspend 挂起期间，哪些信号是被阻塞的
    // 我们希望在等待 SIGUSR1 时，SIGUSR1 是**唯一不被阻塞**的信号
    // 所以 suspend_mask 应该阻塞所有信号，包括 SIGUSR1
    // 但是 sigsuspend 会临时将掩码设置为 suspend_mask，
    // 这意味着它会阻塞 suspend_mask 中的信号。
    // 这里有个逻辑陷阱：
    // sigsuspend 临时设置的掩码是它参数指向的掩码。
    // 如果我们想让 SIGUSR1 能唤醒 sigsuspend，
    // 那么 suspend_mask 就应该是 "除了 SIGUSR1 之外所有要阻塞的信号"。
    // 但我们之前已经用 sigprocmask 设置了 block_most_signals，
    // 它只允许 SIGUSR1, SIGINT, SIGTERM。
    // 所以，为了让 sigsuspend 期间只允许 SIGUSR1 (忽略 SIGINT/SIGTERM 的唤醒能力)，
    // suspend_mask 应该是 block_most_signals + 阻塞 SIGINT 和 SIGTERM
    // 或者更简单地，创建一个只阻塞 SIGUSR1 的掩码。
    // 但是，如果原始掩码 block_most_signals 已经阻塞了其他信号，
    // sigsuspend 不会改变那些信号的状态，除非我们明确在 suspend_mask 中处理。
    // 最清晰的方式是：suspend_mask = 原始掩码 + 额外阻塞的信号
    // 或者，重新定义逻辑。
    // 让我们简化：sigsuspend 期间，只阻塞 SIGUSR1，这样它就能被唤醒。
    // 但这与我们用 sigprocmask 设置的相反。
    // 正确的理解是：
    // sigsuspend 的 mask 参数是它调用期间**生效**的 mask。
    // 如果 mask 中包含 SIGUSR1，那么 SIGUSR1 就被阻塞。
    // 如果 mask 中不包含 SIGUSR1，那么 SIGUSR1 就不被阻塞，可以唤醒进程。
    //
    // 我们的目标是：在 sigsuspend 期间，只允许 SIGUSR1 唤醒我们。
    // 假设当前 mask (由 sigprocmask 设置) 是 block_most_signals (阻塞了除 SIGUSR1/INT/TERM 外的所有)。
    // 那么为了只让 SIGUSR1 唤醒，suspend_mask 应该是 "当前 mask 交集 (除了 SIGUSR1)"。
    // 但这很复杂。
    // 更简单的做法是：
    // 1. 用 sigprocmask 设置一个基础掩码 (比如阻塞 SIGUSR1)。
    // 2. sigsuspend 的 mask 是解除阻塞 SIGUSR1 的掩码。
    // 让我们重新组织示例逻辑，使其更清晰。

    // --- 重新设计示例逻辑 ---
    printf("\n--- Revised Logic ---\n");

    // 重置信号处理
    sigemptyset(&sa.sa_mask);
    sigaction(SIGUSR1, &sa, NULL);

    // 1. 先阻塞 SIGUSR1 (以及其他你不想在主循环中处理的信号)
    sigset_t block_sigusr1;
    sigemptyset(&block_sigusr1);
    sigaddset(&block_sigusr1, SIGUSR1);
    printf("Initially blocking SIGUSR1.\n");
    if (sigprocmask(SIG_BLOCK, &block_sigusr1, &orig_mask) == -1) { // 保存原始掩码
        perror("sigprocmask BLOCK SIGUSR1");
        exit(EXIT_FAILURE);
    }

    // 2. 创建 sigsuspend 的 mask：这个 mask 是 sigsuspend 期间**生效**的。
    // 我们希望在 sigsuspend 期间，SIGUSR1 **不**被阻塞，以便能唤醒进程。
    // 所以，suspend_mask 应该是 “当前所有被阻塞的信号，但不包括 SIGUSR1”。
    // 最简单的方法是：创建一个空的掩码，或者复制当前掩码然后删除 SIGUSR1。
    // 但由于我们只阻塞了 SIGUSR1，所以 suspend_mask 应该是空的。
    sigset_t suspend_wait_mask;
    sigemptyset(&suspend_wait_mask); // 空集意味着不阻塞任何额外信号
                                     // (但原先被 sigprocmask 阻塞的信号状态不变吗？不，sigsuspend 会临时替换)
                                     // sigsuspend 会临时将掩码设置为 suspend_wait_mask。
                                     // 因为我们之前用 sigprocmask 阻塞了 SIGUSR1，
                                     // 现在 sigsuspend 临时设置掩码为空，那么 SIGUSR1 就不被阻塞了。

    printf("Entering sigsuspend loop. Waiting for SIGUSR1...\n");

    // 3. 主循环：等待信号
    while (!sigusr1_flag) {
        printf("  Calling sigsuspend()... (temporarily unblocking SIGUSR1)\n");
        // sigsuspend 会:
        // a. 临时将进程的信号掩码设置为 suspend_wait_mask (这里是空集，即不额外阻塞)
        //    结合上一步，这意味着 SIGUSR1 现在是 unblocked。
        // b. 挂起进程。
        // c. 如果收到 SIGUSR1:
        //    i.  内核调用 handle_sigusr1。
        //    ii. handle_sigusr1 执行完毕。
        //    iii.sigsuspend 返回 -1, errno=EINTR。
        // d. 恢复 sigprocmask 调用前的掩码 (orig_mask，即阻塞 SIGUSR1)。
        int result = sigsuspend(&suspend_wait_mask);

        // 因为 sigsuspend 只有被信号中断才会返回，所以检查 errno 是标准做法
        if (result == -1 && errno == EINTR) {
            printf("  sigsuspend() returned (interrupted by signal).\n");
            // 检查是哪个信号触发的（通过全局标志）
            if (sigusr1_flag) {
                 printf("  Confirmed: SIGUSR1 was received and handled.\n");
            } else {
                 printf("  Interrupted by a different signal (e.g., SIGINT?).\n");
                 // 如果是 SIGINT 或 SIGTERM，程序通常应该退出
                 // 但因为我们没有在 sigsuspend mask 中明确阻塞它们，
                 // 它们也可能唤醒 sigsuspend。
                 // 为了精确等待 SIGUSR1，我们应该在 suspend_wait_mask 中阻塞它们。
                 // 让我们再修正一次。
                 break; // 简单地退出循环
            }
        } else {
            // 这不太可能发生，除非有其他严重错误
            perror("sigsuspend");
            break;
        }
    }

    // 4. 循环结束，说明收到了 SIGUSR1 或者被其他信号中断
    if (sigusr1_flag) {
        printf("\nMain loop exited because SIGUSR1 was received.\n");
    } else {
        printf("\nMain loop exited because of another signal (e.g., SIGINT).\n");
    }

    // 5. 程序结束
    printf("Program exiting.\n");
    return 0;
}

#define _GNU_SOURCE
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include <string.h>
#include <errno.h>

volatile sig_atomic_t usr1_flag = 0;

void handle_usr1(int sig) {
    write(STDOUT_FILENO, "Caught SIGUSR1\n", 15);
    usr1_flag = 1;
}

int main() {
    struct sigaction sa;
    sigset_t block_usr1;
    sigset_t orig_mask;
    sigset_t allow_only_usr1; // sigsuspend 使用的掩码

    printf("PID: %d\n", getpid());
    printf("Run 'kill -USR1 %d' to proceed.\n", getpid());
    printf("Run 'kill -INT %d' (Ctrl+C) to exit.\n", getpid());

    // 1. 设置 SIGUSR1 处理函数
    memset(&sa, 0, sizeof(sa));
    sa.sa_handler = handle_usr1;
    sigemptyset(&sa.sa_mask);
    if (sigaction(SIGUSR1, &sa, NULL) == -1) {
        perror("sigaction SIGUSR1");
        exit(EXIT_FAILURE);
    }

    // 2. 初始状态：阻塞 SIGUSR1
    // 这样可以确保在设置好 sigsuspend 之前的准备期间，SIGUSR1 不会意外到达
    sigemptyset(&block_usr1);
    sigaddset(&block_usr1, SIGUSR1);
    printf("Initially blocking SIGUSR1.\n");
    if (sigprocmask(SIG_BLOCK, &block_usr1, &orig_mask) == -1) {
        perror("sigprocmask BLOCK");
        exit(EXIT_FAILURE);
    }

    // 3. 创建 sigsuspend 期间使用的掩码
    // 目标：在 sigsuspend 期间，只允许 SIGUSR1 到达（唤醒进程）
    // 方法：让 sigsuspend 临时设置的掩码为 "阻塞除 SIGUSR1 外所有我们关心的信号"
    // 但更简单的理解是：sigsuspend 的参数 mask 是它生效期间的掩码。
    // 我们希望 SIGUSR1 能通过，所以 SIGUSR1 不应在此 mask 中。
    // 我们希望其他信号（如 SIGINT）不能唤醒（或被阻塞），所以它们应在此 mask 中。
    // 为了简单，我们创建一个阻塞 SIGUSR1 的掩码。
    // 但是！sigsuspend 是临时 *设置* 掩码为 mask。
    // 如果 mask 包含 SIGUSR1，那么 SIGUSR1 就被阻塞。
    // 如果 mask 不包含 SIGUSR1，那么 SIGUSR1 就不被阻塞。
    // 我们的目标是让 SIGUSR1 不被阻塞 -> mask 中不包含 SIGUSR1。
    // 为了让其他信号不干扰，我们也希望它们被阻塞 -> mask 中包含它们。
    // 但因为我们不知道 "其他所有信号"，我们换个思路。
    // 初始状态：SIGUSR1 被阻塞 (通过 sigprocmask)。
    // sigsuspend 临时掩码：不阻塞 SIGUSR1。
    // 这样 SIGUSR1 就能到达并唤醒。
    sigemptyset(&allow_only_usr1); // 空集，不添加 SIGUSR1
                                   // 这意味着在 sigsuspend 期间，SIGUSR1 不被这个掩码阻塞。
                                   // (但原先被 sigprocmask 阻塞的信号呢？sigsuspend 会临时替换整个掩码)

    // 关键理解：
    // sigprocmask 设置的掩码是 "基础" 掩码。
    // sigsuspend 的 mask 是 "临时" 掩码，它会完全替换掉基础掩码。
    // 所以，sigsuspend(&allow_only_usr1) 会临时将掩码设为空集。
    // 结合之前 sigprocmask 阻塞了 SIGUSR1，现在临时设为空集，
    // 那么所有信号（包括 SIGUSR1）都不被临时掩码阻塞。
    // 这不是我们想要的精确等待 SIGUSR1。
    // 我们想要的是：临时掩码只阻塞 SIGUSR1 之外的信号。
    // 但列出 "所有其他信号" 很难。
    // 最佳实践通常是：
    // 1. 在程序启动时，使用 sigprocmask 设置一个合理的默认掩码。
    // 2. 在需要精确等待时，用 sigsuspend 传入一个精心构造的掩码。

    // 让我们假设我们只关心 SIGUSR1 和 SIGINT。
    // 默认掩码：阻塞 SIGUSR1
    // sigsuspend 掩码：阻塞 SIGUSR1。 这样还是不对。
    // 默认掩码：不阻塞任何信号
    // sigsuspend 掩码：阻塞所有信号，除了 SIGUSR1。 这需要知道所有信号。
    // 折中方案：
    // 默认掩码：阻塞 SIGUSR1
    // sigsuspend 掩码：空集 (不阻塞任何信号)。 这意味着 SIGUSR1 和其他所有信号都不被临时掩码阻塞。
    // 但由于之前阻塞了 SIGUSR1，临时不阻塞，就只有 SIGUSR1 能唤醒？不对，其他信号也能。
    // 看起来我之前的理解有偏差。
    // 再查文档和权威资料：
    // sigsuspend 原子地将信号掩码替换为 mask 指向的掩码，然后挂起进程。
    // 它等待的是任何**未被该 mask 阻塞**的信号。
    // 返回后恢复为调用 sigsuspend 之前的掩码。

    // 正确做法：
    // 1. 确定你平时想阻塞哪些信号 (例如，除了 SIGUSR1 和 SIGINT)。
    // 2. 在准备阶段，用 sigprocmask 设置这个 "平时" 的掩码。
    // 3. 构造 sigsuspend 的 mask：这个 mask 应该只阻塞那些你不想让它唤醒的信号。
    //    通常，这意味着 mask 应该阻塞除你正在等待的那个信号之外的所有信号。
    //    但这需要构造一个包含几乎所有信号的集合，只排除一个，很麻烦。
    // 4. 一个常见的简化方法是：
    //    a. 平时阻塞你关心的所有信号 (SIGUSR1, SIGUSR2, ...)。
    //    b. sigsuspend 的 mask 是 "平时掩码" 减去你当前想等待的那个信号。
    //    c. 这样，sigsuspend 期间，只有那个特定信号能唤醒进程。

    // 实施简化方法：
    printf("\n--- Corrected Example ---\n");
    sigset_t block_sigusr1_and_sigint; // 平时的掩码
    sigset_t wait_for_sigusr1_mask;    // sigsuspend 的掩码

    // 重置信号处理 (可选，因为没变)
    // sigaction(SIGUSR1, &sa, NULL);

    // 1. 设置平时阻塞的信号：SIGUSR1 和 SIGINT
    sigemptyset(&block_sigusr1_and_sigint);
    sigaddset(&block_sigusr1_and_sigint, SIGUSR1);
    sigaddset(&block_sigusr1_and_sigint, SIGINT); // 也阻塞 SIGINT，防止意外唤醒
    printf("Setting normal mask to block SIGUSR1 and SIGINT.\n");
    if (sigprocmask(SIG_SETMASK, &block_sigusr1_and_sigint, &orig_mask) == -1) {
        perror("sigprocmask SETMASK normal");
        exit(EXIT_FAILURE);
    }

    // 2. 构造 sigsuspend 的掩码：只阻塞 SIGINT (允许 SIGUSR1 唤醒)
    sigemptyset(&wait_for_sigusr1_mask);
    sigaddset(&wait_for_sigusr1_mask, SIGINT); // 阻塞 SIGINT
    // SIGUSR1 没有被加入，所以它不被 wait_for_sigusr1_mask 阻塞

    printf("Entering loop to wait for SIGUSR1 using sigsuspend...\n");
    while (!usr1_flag) {
        printf("  About to call sigsuspend()... waiting for SIGUSR1.\n");
        // sigsuspend 会:
        // 1. 临时将掩码设置为 wait_for_sigusr1_mask (只阻塞 SIGINT)。
        // 2. 挂起进程。
        // 3. 如果收到 SIGUSR1 (未被阻塞)，handle_usr1 被调用，然后 sigsuspend 返回 -1 (EINTR)。
        // 4. 如果收到 SIGINT (被阻塞)，行为取决于系统和信号是否排队，但通常会被延迟。
        // 5. 返回后，掩码恢复为 orig_mask (即 block_sigusr1_and_sigint)。
        int result = sigsuspend(&wait_for_sigusr1_mask);

        if (result == -1 && errno == EINTR) {
            printf("  sigsuspend() returned (interrupted).\n");
            if (usr1_flag) {
                printf("  -> It was SIGUSR1.\n");
            } else {
                printf("  -> It was a different unblocked signal (unlikely in this setup) or SIGINT was delivered.\n");
                // 在这个设置下，SIGINT 被阻塞，不太可能唤醒。但如果它以某种方式发生（例如，在设置掩码的间隙），
                // 程序的行为可能不符合预期。更健壮的方法是处理 SIGINT 在主循环条件中。
            }
        } else {
            perror("sigsuspend");
            break; // 错误退出
        }
    }

    if (usr1_flag) {
        printf("\nLoop exited successfully after receiving SIGUSR1.\n");
    } else {
        printf("\nLoop exited, possibly due to an unexpected signal.\n");
    }

    printf("Restoring original signal mask (if needed, though sigsuspend should have done it).\n");
    // sigsuspend 应该已经恢复了，但显式恢复是个好习惯
    if (sigprocmask(SIG_SETMASK, &orig_mask, NULL) == -1) {
        perror("sigprocmask RESTORE");
    }

    printf("Program ending.\n");
    return 0;
}

# 假设代码保存在 sigsuspend_example.c 中
gcc -o sigsuspend_example sigsuspend_example.c

# 终端 1: 运行程序
./sigsuspend_example
# 程序会输出 PID

# 终端 2:
# 发送 SIGUSR1 唤醒程序
# kill -USR1 <PID>

# 或者在终端 1 按 Ctrl+C 发送 SIGINT (根据最终示例的逻辑，这可能不会唤醒，但会终止程序)