1
# 键盘组合键产生信号
2
Ctrl+C   → SIGINT (2)    # 中断前台进程
3
Ctrl+\   → SIGQUIT (3)   # 退出并生成 core dump
4
Ctrl+Z   → SIGTSTP (20)  # 暂停前台进程
5

6
# 通过 kill 命令发送信号
7
kill -SIGTERM 1234       # 向 PID 1234 发送 SIGTERM
8
kill -9 1234             # 向 PID 1234 发送 SIGKILL
9
kill -SIGCHLD 1234       # 向 PID 1234 发送 SIGCHLD

1
// 以下操作会触发内核产生信号
2
int *p = NULL;
3
*p = 42;           // 访问空指针 → SIGSEGV (11)
4

5
char buf[10];
6
buf[100000] = 'x'; // 越界写入 → SIGSEGV (11)
7

8
int x = 1 / 0;     // 整数除零 → SIGFPE (8)
9

10
raise(SIGALRM);     // 进程主动向自己发信号

1
alarm(5);           // 5秒后产生 SIGALRM
2
// 管道读端已关闭，写端继续写 → SIGPIPE
3
// 子进程退出 → 父进程收到 SIGCHLD

1
// 简化版，展示核心字段
2
// 源码: include/linux/sched.h, include/linux/signal_types.h
3

4
struct task_struct {
5
    // 信号处理方式（共享，同一线程组的线程共享）
6
    struct sighand_struct __rcu *sighand;
7

8
    // 待决信号（私有，每个线程独立）
9
    struct sigpending pending;
10

11
    // 信号阻塞掩码
12
    sigset_t blocked;
13

14
    // ...
15
};
16

17
struct sighand_struct {
18
    // 每个信号的处理方式
19
    struct sigaction action[_NSIG];  // _NSIG = 64
20
    refcount_t count;                // 引用计数（fork时共享）
21
};
22

23
struct sigpending {
24
    struct list_head list;  // 待决信号链表
25
    sigset_t signal;        // 待决信号位图
26
};

1
// sigset_t 的简化表示
2
// 实际实现可能是一个 long 数组
3
typedef struct {
4
    unsigned long sig[1];  // 标准信号位图
5
} sigset_t;
6

7
// 位图操作
8
sigset_t pending;          // 待决信号位图
9
sigaddset(&pending, 2);   // 第2位置1 → SIGINT 待决
10
sigismember(&pending, 2); // 检查 SIGINT 是否待决

1
// 假设进程阻塞了 SIGINT
2
// 发送 3 次 SIGINT
3
kill(pid, SIGINT);  // 第1次：pending 位图置位
4
kill(pid, SIGINT);  // 第2次：位图已置位，无操作 → 信号丢失！
5
kill(pid, SIGINT);  // 第3次：位图已置位，无操作 → 信号丢失！
6
// 解除阻塞后，进程只会收到 1 次 SIGINT

1
// 发送 3 次 SIGRTMIN
2
sigqueue(pid, SIGRTMIN, value1);  // 排入队列
3
sigqueue(pid, SIGRTMIN, value2);  // 排入队列
4
sigqueue(pid, SIGRTMIN, value3);  // 排入队列
5
// 解除阻塞后，进程会收到 3 次 SIGRTMIN，按 FIFO 顺序

1
// 极简化的信号投递调用链
2
// 源码: arch/x86/kernel/signal.c, kernel/signal.c
3

4
// 从内核返回用户态时
5
exit_to_usermode_loop(regs) {
6
    if (ti_work & _TIF_SIGPENDING)   // 检查标志
7
        do_signal(regs);              // 处理信号
8
}
9

10
do_signal(struct pt_regs *regs) {
11
    struct ksignal ksig;
12

13
    if (get_signal(&ksig)) {          // 获取待决信号
14
        handle_signal(&ksig, regs);   // 处理信号
15
    }
16
}
17

18
handle_signal(struct ksignal *ksig, struct pt_regs *regs) {
19
    // 1. 在用户态栈上设置信号帧
20
    setup_rt_frame(ksig, regs);
21

22
    // 2. 修改返回地址为信号处理函数
23
    regs->ip = (unsigned long)ksig->ka.sa.sa_handler;
24

25
    // 3. 信号处理函数返回后执行 sigreturn
26
}

1
// 典型的被信号中断的系统调用处理模式
2
ssize_t ret;
3
do {
4
    ret = read(fd, buf, sizeof(buf));
5
} while (ret == -1 && errno == EINTR);  // 被信号中断则重试
6

7
// 或者使用 sigaction 的 SA_RESTART 标志自动重启
8
struct sigaction sa;
9
sa.sa_flags = SA_RESTART;  // 内核自动重启被中断的系统调用

1
#include <unistd.h>
2
#include <stdio.h>
3
#include <string.h>
4

5
int main(void) {
6
    int pipefd[2];
7
    pid_t pid;
8
    char buf[128];
9

10
    // 创建管道：pipefd[0] 为读端，pipefd[1] 为写端
11
    if (pipe(pipefd) == -1) {
12
        perror("pipe");
13
        return 1;
14
    }
15

16
    pid = fork();
17
    if (pid == 0) {
18
        // 子进程：关闭写端，从管道读取
19
        close(pipefd[1]);
20
        ssize_t n = read(pipefd[0], buf, sizeof(buf));
21
        printf("子进程收到: %.*s\n", (int)n, buf);
22
        close(pipefd[0]);
23
    } else {
24
        // 父进程：关闭读端，向管道写入
25
        close(pipefd[0]);
26
        const char *msg = "Hello from parent!";
27
        write(pipefd[1], msg, strlen(msg));
28
        close(pipefd[1]);  // 关闭写端，子进程的 read 才会返回 0
29
    }
30

31
    return 0;
32
}

1
// 源码: fs/pipe.c, include/linux/pipe_fs_i.h
2

3
struct pipe_inode_info {
4
    struct mutex mutex;           // 互斥锁保护管道操作
5
    wait_queue_head_t rd_wait;    // 读等待队列
6
    wait_queue_head_t wr_wait;    // 写等待队列
7
    unsigned int head;            // 环形缓冲区头指针
8
    unsigned int tail;            // 环形缓冲区尾指针
9
    unsigned int ring_size;       // 环形缓冲区大小
10
    struct pipe_buffer *bufs;     // 环形缓冲区数组
11
    // ...
12
};
13

14
struct pipe_buffer {
15
    struct page *page;            // 指向实际数据页
16
    unsigned int offset;          // 页内偏移
17
    unsigned int len;             // 数据长度
18
    const struct pipe_buf_operations *ops;  // 操作函数表
19
    // ...
20
};

1
# 创建 FIFO
2
mkfifo /tmp/myfifo
3

4
# 或者通过 C 函数
5
# mkfifo("/tmp/myfifo", 0666);

1
#include <fcntl.h>
2
#include <sys/stat.h>
3
#include <unistd.h>
4
#include <stdio.h>
5

6
// 进程 A：写入端
7
int writer(void) {
8
    int fd = open("/tmp/myfifo", O_WRONLY);
9
    const char *msg = "Hello via FIFO!";
10
    write(fd, msg, strlen(msg));
11
    close(fd);
12
    return 0;
13
}
14

15
// 进程 B：读取端
16
int reader(void) {
17
    char buf[128];
18
    int fd = open("/tmp/myfifo", O_RDONLY);
19
    ssize_t n = read(fd, buf, sizeof(buf));
20
    printf("收到: %.*s\n", (int)n, buf);
21
    close(fd);
22
    return 0;
23
}

1
#include <sys/msg.h>
2
#include <stdio.h>
3
#include <string.h>
4

5
// 消息结构：第一个成员必须是 long 类型的 mtype
6
struct my_msg {
7
    long mtype;          // 消息类型（必须 > 0）
8
    char mtext[256];     // 消息正文
9
};
10

11
int main(void) {
12
    key_t key = ftok("/tmp", 'A');     // 生成唯一 key
13
    int msqid = msgget(key, 0666 | IPC_CREAT);
14

15
    // 发送消息
16
    struct my_msg snd_msg = {
17
        .mtype = 1,                     // 类型 1
18
    };
19
    strncpy(snd_msg.mtext, "Hello, msgq!", sizeof(snd_msg.mtext));
20
    msgsnd(msqid, &snd_msg, strlen(snd_msg.mtext) + 1, 0);
21

22
    // 按类型接收消息
23
    struct my_msg rcv_msg;
24
    // 最后一个参数: 0=接收第一个, >0=接收指定类型, <0=接收类型≤|mtype|的最小值
25
    msgrcv(msqid, &rcv_msg, sizeof(rcv_msg.mtext), 1, 0);
26
    printf("收到: %s\n", rcv_msg.mtext);
27

28
    // 删除消息队列
29
    msgctl(msqid, IPC_RMID, NULL);
30
    return 0;
31
}

1
// 简化版
2
struct msg_queue {
3
    struct kern_ipc_perm q_perm;     // 权限与标识
4
    struct list_head q_messages;     // 消息链表
5
    struct list_head q_senders;      // 等待发送的进程
6
    struct list_head q_receivers;    // 等待接收的进程
7
    unsigned long q_cbytes;          // 当前字节数
8
    unsigned long q_qnum;            // 当前消息数
9
    unsigned long q_qbytes;          // 最大字节数限制
10
    // ...
11
};

1
#include <mqueue.h>
2
#include <stdio.h>
3
#include <string.h>
4

5
int main(void) {
6
    struct mq_attr attr = {
7
        .mq_flags = 0,
8
        .mq_maxmsg = 10,       // 最大消息数
9
        .mq_msgsize = 256,     // 每条消息最大大小
10
        .mq_curmsgs = 0,
11
    };
12

13
    // 创建/打开消息队列
14
    mqd_t mqd = mq_open("/my_queue", O_CREAT | O_RDWR, 0666, &attr);
15

16
    // 发送消息（可指定优先级）
17
    unsigned int prio = 1;
18
    mq_send(mqd, "Hello, POSIX mq!", 16, prio);
19

20
    // 接收消息（按优先级降序接收）
21
    char buf[256];
22
    unsigned int recv_prio;
23
    ssize_t n = mq_receive(mqd, buf, sizeof(buf), &recv_prio);
24
    printf("收到(优先级 %u): %.*s\n", recv_prio, (int)n, buf);
25

26
    mq_close(mqd);
27
    mq_unlink("/my_queue");
28
    return 0;
29
}

1
普通 IPC（两次拷贝）：
2
进程A 用户空间 ──拷贝──▶ 内核缓冲区 ──拷贝──▶ 进程B 用户空间
3

4
共享内存（零拷贝）：
5
进程A 用户空间 ──映射──▶ 物理内存 ◀──映射── 进程B 用户空间

1
#include <sys/shm.h>
2
#include <sys/ipc.h>
3
#include <stdio.h>
4
#include <string.h>
5

6
int main(void) {
7
    key_t key = ftok("/tmp", 'S');
8

9
    // 1. 创建共享内存段
10
    int shmid = shmget(key, 4096, IPC_CREAT | 0666);
11

12
    // 2. 连接到进程地址空间
13
    void *addr = shmat(shmid, NULL, 0);
14

15
    // 3. 使用共享内存
16
    strncpy((char *)addr, "Hello, shared memory!", 4096);
17
    printf("共享内存内容: %s\n", (char *)addr);
18

19
    // 4. 断开连接
20
    shmdt(addr);
21

22
    // 5. 删除共享内存
23
    shmctl(shmid, IPC_RMID, NULL);
24
    return 0;
25
}

1
// 简化版
2
struct shmid_kernel {
3
    struct kern_ipc_perm shm_perm;    // 权限
4
    struct file *shm_file;            // 底层文件（tmpfs）
5
    unsigned long shm_nattch;         // 连接计数
6
    unsigned long shm_segsz;          // 段大小
7
    // ...
8
};

1
#include <sys/mman.h>
2
#include <sys/stat.h>
3
#include <fcntl.h>
4
#include <stdio.h>
5
#include <string.h>
6
#include <unistd.h>
7

8
int main(void) {
9
    const size_t SIZE = 4096;
10

11
    // 1. 创建共享内存对象
12
    int fd = shm_open("/my_shm", O_CREAT | O_RDWR, 0666);
13

14
    // 2. 设置大小
15
    ftruncate(fd, SIZE);
16

17
    // 3. 映射到地址空间
18
    void *addr = mmap(NULL, SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
19

20
    // 4. 使用
21
    strncpy((char *)addr, "Hello, POSIX shm!", SIZE);
22
    printf("内容: %s\n", (char *)addr);
23

24
    // 5. 清理
25
    munmap(addr, SIZE);
26
    close(fd);
27
    shm_unlink("/my_shm");
28
    return 0;
29
}

1
// 典型模式：共享内存 + 信号量
2
struct shared_data {
3
    sem_t mutex;        // POSIX 命名信号量或进程间信号量
4
    int count;
5
    char message[256];
6
};
7

8
// 写入方
9
sem_wait(&data->mutex);     // 加锁
10
data->count++;
11
strncpy(data->message, "updated", sizeof(data->message));
12
sem_post(&data->mutex);     // 解锁
13

14
// 读取方
15
sem_wait(&data->mutex);     // 加锁
16
printf("count=%d, msg=%s\n", data->count, data->message);
17
sem_post(&data->mutex);     // 解锁

1
#include <sys/sem.h>
2
#include <stdio.h>
3
#include <unistd.h>
4

5
// 联合体，用于 semctl 的 SETVAL/IPC_RMID 操作
6
union semun {
7
    int val;
8
    struct semid_ds *buf;
9
    unsigned short *array;
10
};
11

12
int main(void) {
13
    key_t key = ftok("/tmp", 'E');
14

15
    // 1. 创建信号量集（包含1个信号量）
16
    int semid = semget(key, 1, IPC_CREAT | 0666);
17

18
    // 2. 初始化信号量值为 1（二值信号量/互斥锁）
19
    union semun arg = { .val = 1 };
20
    semctl(semid, 0, SETVAL, arg);
21

22
    // 3. P 操作（等待/减1）
23
    struct sembuf sop_p = {
24
        .sem_num = 0,       // 信号量索引
25
        .sem_op  = -1,      // P 操作：-1
26
        .sem_flg = 0,       // 阻塞等待
27
    };
28
    semop(semid, &sop_p, 1);
29
    printf("获取锁，进入临界区\n");
30

31
    // ... 临界区操作 ...
32
    sleep(1);
33

34
    // 4. V 操作（释放/加1）
35
    struct sembuf sop_v = {
36
        .sem_num = 0,
37
        .sem_op  = 1,       // V 操作：+1
38
        .sem_flg = 0,
39
    };
40
    semop(semid, &sop_v, 1);
41
    printf("释放锁，退出临界区\n");
42

43
    // 5. 删除信号量
44
    semctl(semid, 0, IPC_RMID);
45
    return 0;
46
}

1
struct sem_array {
2
    struct kern_ipc_perm sem_perm;    // 权限
3
    int sem_nsems;                     // 信号量数量
4
    struct list_head pending_alter;    // 待决的修改操作
5
    struct list_head pending_const;    // 待决的恒等操作
6
    struct sem *sem_base;              // 信号量数组
7
    // ...
8
};
9

10
struct sem {
11
    int semval;     // 信号量当前值
12
    int sempid;     // 最后一次操作的 PID
13
    // ...
14
};

1
// ===== 命名信号量 =====
2
#include <fcntl.h>
3
#include <sys/stat.h>
4
#include <semaphore.h>
5

6
sem_t *sem = sem_open("/my_sem", O_CREAT, 0666, 1);  // 初始值1
7
sem_wait(sem);       // P 操作
8
// ... 临界区 ...
9
sem_post(sem);       // V 操作
10
sem_close(sem);
11
sem_unlink("/my_sem");
12

13

14
// ===== 无名信号量（可放在共享内存中） =====
15
sem_t sem;
16
sem_init(&sem, 1, 1);   // 第二个参数1=进程间共享，初始值1
17
sem_wait(&sem);
18
// ... 临界区 ...
19
sem_post(&sem);
20
sem_destroy(&sem);

1
#include <sys/socket.h>
2
#include <sys/un.h>
3
#include <stdio.h>
4
#include <string.h>
5
#include <unistd.h>
6

7
#define SOCK_PATH "/tmp/unix_sock"
8

9
int main(void) {
10
    int server_fd, client_fd;
11
    struct sockaddr_un addr;
12
    char buf[128];
13

14
    // ===== 服务端 =====
15
    server_fd = socket(AF_UNIX, SOCK_STREAM, 0);
16
    memset(&addr, 0, sizeof(addr));
17
    addr.sun_family = AF_UNIX;
18
    strncpy(addr.sun_path, SOCK_PATH, sizeof(addr.sun_path) - 1);
19
    bind(server_fd, (struct sockaddr *)&addr, sizeof(addr));
20
    listen(server_fd, 5);
21

22
    // ===== 客户端 =====
23
    client_fd = socket(AF_UNIX, SOCK_STREAM, 0);
24
    connect(client_fd, (struct sockaddr *)&addr, sizeof(addr));
25
    write(client_fd, "Hello, UDS!", 11);
26

27
    // ===== 服务端接收 =====
28
    int conn_fd = accept(server_fd, NULL, NULL);
29
    ssize_t n = read(conn_fd, buf, sizeof(buf));
30
    printf("收到: %.*s\n", (int)n, buf);
31

32
    close(conn_fd);
33
    close(client_fd);
34
    close(server_fd);
35
    unlink(SOCK_PATH);
36
    return 0;
37
}

1
// 发送文件描述符
2
struct msghdr msg = {0};
3
struct cmsghdr *cmsg;
4
int fd_to_send = open("/tmp/data.txt", O_RDONLY);
5
char cmsgbuf[CMSG_SPACE(sizeof(int))];
6

7
msg.msg_control = cmsgbuf;
8
msg.msg_controllen = sizeof(cmsgbuf);
9
cmsg = CMSG_FIRSTHDR(&msg);
10
cmsg->cmsg_level = SOL_SOCKET;
11
cmsg->cmsg_type = SCM_RIGHTS;
12
cmsg->cmsg_len = CMSG_LEN(sizeof(int));
13
*(int *)CMSG_DATA(cmsg) = fd_to_send;
14

15
sendmsg(sock_fd, &msg, 0);

1
TCP 套接字数据路径：
2
用户空间 → 系统调用 → TCP → IP → 链路层 → ... → 对端
3

4
Unix 域套接字数据路径：
5
用户空间 → 系统调用 → unix_stream_sendmsg() → 对端缓冲区

1
# 列出所有信号
2
kill -l
3

4
# 查看特定信号的默认行为
5
man 7 signal
6

7
# 查看进程的信号掩码
8
cat /proc/self/status | grep -i sig
9

10
# 使用 strace 观察信号投递
11
strace -e signal ./your_program

1
// signal_demo.c — 信号处理综合演示
2
#include <signal.h>
3
#include <stdio.h>
4
#include <unistd.h>
5
#include <string.h>
6
#include <stdlib.h>
7

8
volatile sig_atomic_t got_sigusr1 = 0;
9
volatile sig_atomic_t got_sigusr2 = 0;
10

11
void handler(int signo, siginfo_t *info, void *context) {
12
    if (signo == SIGUSR1) {
13
        got_sigusr1 = 1;
14
        write(STDOUT_FILENO, "SIGUSR1 received\n", 17);
15
    } else if (signo == SIGUSR2) {
16
        got_sigusr2 = 1;
17
        write(STDOUT_FILENO, "SIGUSR2 received\n", 17);
18
    }
19
}
20

21
int main(void) {
22
    struct sigaction sa;
23
    sa.sa_sigaction = handler;
24
    sigemptyset(&sa.sa_mask);
25
    sa.sa_flags = SA_SIGINFO | SA_RESTART;
26

27
    sigaction(SIGUSR1, &sa, NULL);
28
    sigaction(SIGUSR2, &sa, NULL);
29

30
    printf("PID: %d\n", getpid());
31
    printf("发送信号测试: kill -USR1 %d\n", getpid());
32
    printf("             kill -USR2 %d\n", getpid());
33

34
    while (!got_sigusr1 || !got_sigusr2) {
35
        pause();
36
    }
37

38
    printf("两个信号均已收到，程序退出\n");
39
    return 0;
40
}

1
# 编译运行
2
gcc -o signal_demo signal_demo.c
3
./signal_demo &
4
# 在另一个终端
5
kill -USR1 <PID>
6
kill -USR2 <PID>

1
# 创建 FIFO
2
mkfifo /tmp/test_fifo
3

4
# 终端1：读取端
5
cat /tmp/test_fifo
6

7
# 终端2：写入端
8
echo "Hello through FIFO" > /tmp/test_fifo
9

10
# 清理
11
rm /tmp/test_fifo

1
# 查看所有 System V IPC 资源
2
ipcs        # 综合查看
3
ipcs -q     # 消息队列
4
ipcs -m     # 共享内存
5
ipcs -s     # 信号量
6

7
# 查看 POSIX 消息队列
8
ls -la /dev/mqueue/
9

10
# 查看进程的映射（包含共享内存段）
11
cat /proc/self/maps | grep -i shm
12

13
# 手动删除残留的 IPC 资源
14
ipcrm -q <msqid>    # 删除消息队列
15
ipcrm -m <shmid>    # 删除共享内存
16
ipcrm -s <semid>    # 删除信号量

1
// prodcons.c — 共享内存 + 信号量实现生产者-消费者模型
2
#include <stdio.h>
3
#include <stdlib.h>
4
#include <string.h>
5
#include <unistd.h>
6
#include <sys/wait.h>
7
#include <sys/mman.h>
8
#include <sys/stat.h>
9
#include <fcntl.h>
10
#include <semaphore.h>
11

12
#define SHM_NAME "/pc_shm"
13
#define SEM_MUTEX "/pc_mutex"
14
#define SEM_EMPTY "/pc_empty"
15
#define SEM_FULL  "/pc_full"
16
#define BUF_SIZE  10
17
#define ITEM_COUNT 20
18

19
typedef struct {
20
    int buffer[BUF_SIZE];
21
    int in;
22
    int out;
23
} shared_buffer_t;
24

25
int main(void) {
26
    // 创建共享内存
27
    int shm_fd = shm_open(SHM_NAME, O_CREAT | O_RDWR, 0666);
28
    ftruncate(shm_fd, sizeof(shared_buffer_t));
29
    shared_buffer_t *shm = mmap(NULL, sizeof(shared_buffer_t),
30
                                 PROT_READ | PROT_WRITE, MAP_SHARED, shm_fd, 0);
31
    memset(shm, 0, sizeof(shared_buffer_t));
32

33
    // 创建信号量
34
    sem_t *mutex = sem_open(SEM_MUTEX, O_CREAT, 0666, 1);
35
    sem_t *empty = sem_open(SEM_EMPTY, O_CREAT, 0666, BUF_SIZE);
36
    sem_t *full  = sem_open(SEM_FULL,  O_CREAT, 0666, 0);
37

38
    pid_t pid = fork();
39
    if (pid == 0) {
40
        // ===== 消费者子进程 =====
41
        for (int i = 0; i < ITEM_COUNT; i++) {
42
            sem_wait(full);
43
            sem_wait(mutex);
44

45
            int item = shm->buffer[shm->out];
46
            shm->out = (shm->out + 1) % BUF_SIZE;
47
            printf("  消费: %d (槽位 %d)\n", item, shm->out);
48

49
            sem_post(mutex);
50
            sem_post(empty);
51
            usleep(100000);  // 模拟消费耗时
52
        }
53
        exit(0);
54
    } else {
55
        // ===== 生产者父进程 =====
56
        for (int i = 0; i < ITEM_COUNT; i++) {
57
            sem_wait(empty);
58
            sem_wait(mutex);
59

60
            shm->buffer[shm->in] = i + 1;
61
            shm->in = (shm->in + 1) % BUF_SIZE;
62
            printf("生产: %d (槽位 %d)\n", i + 1, shm->in);
63

64
            sem_post(mutex);
65
            sem_post(full);
66
            usleep(50000);  // 模拟生产耗时
67
        }
68
        wait(NULL);
69
    }
70

71
    // 清理
72
    munmap(shm, sizeof(shared_buffer_t));
73
    close(shm_fd);
74
    shm_unlink(SHM_NAME);
75
    sem_close(mutex); sem_unlink(SEM_MUTEX);
76
    sem_close(empty); sem_unlink(SEM_EMPTY);
77
    sem_close(full);  sem_unlink(SEM_FULL);
78
    return 0;
79
}

1
# 编译运行（需要链接 rt 和 pthread 库）
2
gcc -o prodcons prodcons.c -lrt -lpthread
3
./prodcons