Linux(十四)System V IPC核心机制全解析

前置总览

System V IPC 诞生于 AT&T System V Release 2，包含三类独立内核对象：共享内存(shm)、消息队列(msg)、信号量(sem)，统一核心特征：

1. 内核持久对象 ：进程全部退出后，IPC 对象仍然驻留内核，不自动销毁；必须手动调用 *ctl(IPC_RMID) 或 ipcrm 删除，系统重启才会自动清空。
2. 统一设计范式 ：全部遵循 get -> 操作 -> ctl 删除 三步流程，依赖 key_t 键值寻址，独立文件描述符体系，无法直接用 select/poll/epoll 监听。
3. 独立内核资源池 ：Linux 内核通过 /proc/sysvipc/ 导出全部 System V IPC 状态，同时提供 sysctl 配置全局资源上限。
4. 权限模型统一：创建时指定八进制权限（如 0660），内核存储 uid/gid、creator id，读写操作校验权限。

通用基础模块（三类 IPC 共用）

1. key_t 键值：进程间打通 IPC 对象

1.1 ftok() 生成公有 key（多进程共享同一个 IPC 对象）

key_t ftok(const char *pathname, int proj_id);

• 参数说明：
  • pathname：必须是系统存在的可读文件路径（常用程序文件、配置文件），内核取文件设备号+inode 参与哈希；文件删除重建后 key 会变化。
  • proj_id：仅低8位有效，取值范围 0~255，区分同一文件下多个 IPC 对象。
• 底层原理：key = (主设备号 << 16) | (proj_id << 8) | (inode 低8位)
• 缺陷：不同文件 inode 低8位+同proj_id 会产生key冲突，大型项目建议直接使用自定义固定数字 key。

1.2 IPC_PRIVATE 私有对象（父子进程专用）

调用 shmget/msgget/semget 时 key = IPC_PRIVATE，内核永远创建全新 IPC 对象，返回唯一 id；仅 fork 出来的子进程可继承 id，无关进程无法通过 key 获取，多用于单进程 fork 多子进程场景。

1.3 创建标志位 shmflg/msgflg/semflg（统一规则）

标志	作用
IPC_CREAT	不存在则新建，存在直接返回已有对象 id
IPC_EXCL	配合 IPC_CREAT，对象已存在时直接返回 -1，防止重复创建
0600/0660/0666	八进制读写权限，同文件权限，仅影响读写操作，不影响删除

示例：0660 | IPC_CREAT | IPC_EXCL 新建私有可读写对象，重复创建报错。

2. Linux 内核查看与管控工具

2.1 ipcs 查看所有 System V IPC

ipcs -m    # 共享内存列表（shmid、权限、大小、连接进程数、pid）
ipcs -q    # 消息队列列表（msqid、消息总数、总字节、最大容量）
ipcs -s    # 信号量集合（semid、信号量个数、操作pid）
ipcs -a    # 全部详细信息
ipcs -t    # 附加/发送/操作时间
ipcs -u    # 系统全局资源统计（总上限、已使用数量）

2.2 ipcrm 手动删除残留 IPC 对象

ipcrm -m shmid    # 删除共享内存段
ipcrm -q msqid    # 删除消息队列
ipcrm -s semid    # 删除信号量集合
ipcrm -M key      # 通过 key 删除共享内存
ipcrm -Q key      # 通过 key 删除消息队列
ipcrm -S key      # 通过 key 删除信号量

2.3 /proc 内核可视化节点（Linux 特有）

/proc/sysvipc/shm   # 全部共享内存内核元数据（对应 struct shmid_kernel）
/proc/sysvipc/msg   # 全部消息队列元数据（struct msg_queue）
/proc/sysvipc/sem   # 全部信号量集合元数据（struct sem_array）

可直接 cat 查看每个对象的 key、id、权限、大小、创建进程 PID。

2.4 sysctl 全局资源限制（Linux 可调）

配置文件 /etc/sysctl.conf，修改后 sysctl -p 生效

# 共享内存全局限制
kernel.shmmax = 68719476736  # 单个共享内存段最大字节
kernel.shmall = 4294967296   # 系统所有共享内存总页数
kernel.shmmni = 4096         # 系统最大共享内存段数量

# 消息队列全局限制
kernel.msgmax = 8192         # 单条消息最大字节
kernel.msgmnb = 16384        # 单个队列最大总字节
kernel.msgmni = 32000        # 系统最大消息队列数量

# 信号量全局限制
kernel.sem = 250 32000 100 128  # SEMMSL SEMMNS SEMOPM SEMMNI
# 释义：单集合最大信号量数、系统总信号量上限、单次semop最大操作数、最大集合数

3. 通用生命周期完整流程（三类 IPC 通用）

1. 调用 ftok() 生成公有 key 或使用 IPC_PRIVATE；
2. xxxget(key, ... , IPC_CREAT|权限) 创建/获取 IPC 对象 ID；
3. 业务读写操作：shmat/shm 读写、msgsnd/msgrcv、semop；
4. 进程退出前可选：shmdt 分离共享内存；
5. 不再使用时调用 xxxctl(id, IPC_RMID, NULL) 标记内核删除；
6. 全部进程释放资源后，内核真正回收内存；
7. 异常场景：进程崩溃未执行删除，IPC 对象永久残留内核，需 ipcrm 清理。

4. 内核统一管理架构：三类IPC的共同数据结构基座

System V 三类IPC并非独立实现，而是复用了同一套内核管理框架，所有IPC对象共享相同的权限头、ID映射、命名空间隔离与生命周期逻辑，这是三类IPC最核心的底层联系。

4.1 统一权限头：struct kern_ipc_perm

这是三类IPC对象共有的第一个成员 ，相当于面向对象中的基类，通过C语言结构体首地址重合实现了多态复用。内核可以用 struct kern_ipc_perm * 通用指针操作任意类型的IPC对象。

struct kern_ipc_perm {
    spinlock_t lock;        // 单个IPC对象的自旋锁，保护并发访问
    bool deleted;           // 是否已标记为删除（对应IPC_RMID标记）
    int id;                 // 内核全局唯一ID，即用户态获取的shmid/msqid/semid
    key_t key;              // 用户态传入的key键值
    kuid_t uid;             // 所有者用户ID
    kgid_t gid;             // 所有者用户组ID
    kuid_t cuid;            // 创建者用户ID
    kgid_t cgid;            // 创建者用户组ID
    umode_t mode;           // 八进制权限掩码
    unsigned long seq;      // 序列号，避免ID复用导致的误访问
    void *security;         // 安全模块扩展指针（SELinux/AppArmor）
};

• 结构关联：struct shmid_kernel、struct msg_queue、struct sem_array 均将该结构体作为第一个成员，内存地址完全重合，因此可直接强制类型转换。
• 统一逻辑：权限校验、IPC_STAT/IPC_SET属性读写、删除标记等通用操作，全部由内核 ipc/util.c 中的通用函数实现，三类IPC无需重复开发。

4.2 ID映射机制：struct ipc_ids 与 IDR 树

内核为每一类IPC维护一个独立的 ipc_ids 实例，负责将用户态的整数ID映射到内核对象指针，同时管理全局资源上限。

struct ipc_ids {
    struct idr ipcs_idr;    // IDR基数树，id -> 内核对象指针的快速映射
    int in_use;             // 当前已创建的IPC对象总数
    unsigned int seq;       // 全局序列号
    struct mutex mutex;     // 保护IDR树的互斥锁
    int max_idx;            // 最大ID索引（对应sysctl资源上限）
};

• 三类IPC各有一套独立的 ipc_ids：shm_ids、msg_ids、sem_ids，彼此资源隔离、计数独立；
• 查找效率：IDR树保证O(logN)时间复杂度完成ID到内核对象的查找，远优于链表遍历；
• ID复用防护：通过seq序列号拼接成最终ID，避免短时间内对象销毁重建后，旧ID误访问新对象。

4.3 命名空间隔离：struct ipc_namespace

Linux 内核通过IPC命名空间实现资源隔离，是容器 --ipc 参数的底层基础。

struct ipc_namespace {
    struct ipc_ids shm_ids;     // 该命名空间下的共享内存池
    struct ipc_ids msg_ids;     // 该命名空间下的消息队列池
    struct ipc_ids sem_ids;     // 该命名空间下的信号量池
    // 对应sysctl资源限制：shmmax、shmmni、msgmnb等
    unsigned long shm_ctlmax;
    unsigned long shm_ctlall;
    unsigned short shm_ctlmni;
    int msg_ctlmax;
    int msg_ctlmnb;
    int msg_ctlmni;
    int sem_ctls[4];
    // ... 引用计数、销毁逻辑
};

• 每个进程属于一个IPC命名空间，默认共享初始命名空间；
• 不同命名空间下的key、ID完全隔离，无法跨命名空间访问对方的IPC对象；
• sysctl 配置的资源上限按命名空间独立生效，容器内修改不影响宿主机。

4.4 统一系统调用链路

所有 xxxget / xxxctl 类系统调用，都遵循「命名空间查找 → IDR索引 → 权限校验 → 类型专属逻辑」的统一流程：

1. 从当前进程 task_struct 中获取所属 ipc_namespace；
2. 根据ID在对应 ipc_ids 的IDR树中查找 kern_ipc_perm 指针；
3. 调用通用 ipcperms() 校验进程是否有读写/管理权限；
4. 强制转换为对应类型的结构体指针，执行类型专属的业务逻辑。

---

一、共享内存 Shared Memory（shm）

核心原理

内核开辟一段物理内存，多个进程通过 shmat 将同一片物理页映射到各自独立的虚拟地址空间；数据仅一次拷贝 （用户空间 ↔ 物理内存，无内核缓冲区中转），是 Linux 速度最快 IPC。

无内置同步机制，多进程并发读写必然产生竞态，必须搭配 System V 信号量/文件锁/POSIX 互斥锁使用。

1. 完整内核数据结构（Linux 源码）

顶层管理结构 struct shmid_kernel（内核每个共享内存段唯一实例）

struct shmid_kernel {
    struct kern_ipc_perm shm_perm;  // IPC统一权限结构体（key、uid、gid、mode）
    struct file *shm_file;          // 内核匿名文件，承载共享内存物理页
    unsigned long shm_nattch;       // 当前附加该段的进程数量（attach计数）
    unsigned long shm_segsz;        // 共享内存段总字节大小
    time_t shm_atim;                // 最后一次shmat附加时间
    time_t shm_dtim;                // 最后一次shmdt分离时间
    time_t shm_ctim;                // 创建/最后一次IPC_SET修改时间
    pid_t shm_cpid;                 // 创建该段的进程PID
    pid_t shm_lpid;                 // 最后一次shmat/shmdt操作的PID
    struct vm_area_struct *attach_list; // 所有进程映射该段的VMA链表
};

• kern_ipc_perm：三类 System V IPC 共用权限头部，存储 key、权限掩码、所有者ID。
• vm_area_struct(VMA)：每个进程虚拟地址区间描述符，shmat 会在进程 mm_struct 地址空间插入一条 VMA，标记为 VM_SHARED，指向 shmid_kernel 的物理页。

1.1 底层文件系统关联：基于 tmpfs 的实现

Linux 中 System V 共享内存并非独立的内存管理模块，而是完全基于 tmpfs 临时文件系统实现，这是它和内核内存管理子系统的核心联系：

• shmid_kernel->shm_file 指向 tmpfs 中的一个匿名文件，无磁盘路径，所有物理页由 tmpfs 的地址空间管理；
• POSIX 共享内存（挂载于 /dev/shm）同样基于 tmpfs 实现，二者底层物理页分配、swap换出逻辑完全一致；
• 内存紧张时，共享内存的物理页可由 tmpfs 换出到 swap 分区，不占用内核常驻内存。

1.2 与进程地址空间的映射链路

共享内存和进程虚拟地址空间的绑定，完全复用内核的 VMA（虚拟内存区域）管理框架：

1. shmat 系统调用在进程 mm_struct 中分配一条 vm_area_struct，设置 VM_SHARED | VM_MAYSHARE 标志；
2. VMA 的 vm_file 指针指向 shmid_kernel->shm_file，所有 attach 该段的进程 VMA 都指向同一个 tmpfs 文件；
3. 首次访问触发缺页中断时，内核通过 tmpfs 的 address_space 查找物理页，若不存在则分配新页，直接建立页表映射；
4. 多进程访问同一段时，页表指向同一物理页框，真正实现零拷贝共享。

与 fork 的联动：子进程会继承父进程的共享内存 VMA，无需重新调用 shmat 即可直接访问；由于 VMA 标记为共享，写时复制（COW）机制对其不生效，父子进程写入直接修改同一物理页。

用户态可见结构体 struct shmid_ds

shmctl(IPC_STAT) 读取的对外封装，字段和 shmid_kernel 一一对应，供应用层获取元数据。

2. 全套 API 分步详解 + 完整使用流程

2.1 shmget 创建/获取共享内存 ID

int shmget(key_t key, size_t size, int shmflg);

• size 规则：内核会自动向上对齐到系统页大小（4K/2M）；size=0 获取已有段时无限制；新建段 size 不能超过 shmmax。
• 返回值：成功返回非负 shmid，失败 -1（EEXIST、ENOENT、ENOSPC 资源耗尽）。

2.2 shmat 将共享内存映射到进程虚拟地址

void *shmat(int shmid, const void *shmaddr, int shmflg);

参数详解：

1. shmaddr=NULL：推荐，内核自动分配空闲虚拟地址；
2. shmaddr != NULL：强制映射到指定虚拟地址，极易地址冲突，极少使用；
3. shmflg 标志：
   • SHM_RDONLY：只读映射，无法写数据；
   • 0：可读可写。
     返回：映射起始虚拟地址指针，失败返回 (void*)-1。
     内核行为：分配 VMA、建立页表映射，shm_nattch 计数+1。

2.3 直接读写映射地址（业务逻辑）

拿到 shmat 返回指针后，直接像堆内存一样数组/指针读写；无系统调用开销，是性能核心优势。

2.4 shmdt 分离映射（仅解除当前进程绑定）

int shmdt(const void *shmaddr);

• 仅删除当前进程 VMA，shm_nattch 计数-1；不会销毁内核共享内存段；
• 进程正常/异常退出时，内核自动执行 shmdt，无需手动兜底；
• 返回 0 成功，-1 失败（传入地址不是合法shmat映射地址）。

2.5 shmctl 控制/删除共享内存

int shmctl(int shmid, int cmd, struct shmid_ds *buf);

cmd 核心命令：

1. IPC_STAT：读取内核段信息存入 buf；
2. IPC_SET：修改权限、uid/gid；
3. IPC_RMID：标记删除 ，内核仅设置 shm_perm.deleted = true，不会立刻释放内存；等待 shm_nattch == 0（所有进程shmdt）后，内核才会释放tmpfs文件与物理页。

3. 完整可运行示例（生产者-消费者模型，搭配信号量同步）

// shm_write.c 写进程
#include <stdio.h>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <sys/sem.h>
#include <string.h>

#define SHM_KEY 0x123456
#define SEM_KEY 0x123457
#define SHM_SIZE 1024

// 信号量操作封装
union semun {
    int val;
    struct semid_ds *buf;
    unsigned short *array;
};
void sem_p(int semid) {
    struct sembuf op = {0, -1, 0};
    semop(semid, &op, 1);
}
void sem_v(int semid) {
    struct sembuf op = {0, 1, 0};
    semop(semid, &op, 1);
}

int main() {
    // 1. 创建共享内存
    int shmid = shmget(SHM_KEY, SHM_SIZE, 0660 | IPC_CREAT);
    if(shmid == -1) { perror("shmget"); return -1; }
    // 2. 创建信号量(同步锁)
    int semid = semget(SEM_KEY, 1, 0660 | IPC_CREAT);
    union semun su; su.val = 1;
    semctl(semid, 0, SETVAL, su);
    // 3. 映射地址
    char *shm_addr = shmat(shmid, NULL, 0);
    if(shm_addr == (void*)-1) { perror("shmat"); return -1; }

    // 4. 写数据（P锁加锁）
    sem_p(semid);
    strcpy(shm_addr, "Hello System V Shared Memory");
    printf("写入共享内存: %s\n", shm_addr);
    sem_v(semid);

    sleep(10); // 等待读进程读取
    // 5. 分离映射
    shmdt(shm_addr);
    // 标记删除
    shmctl(shmid, IPC_RMID, NULL);
    semctl(semid, 0, IPC_RMID, NULL);
    return 0;
}

读进程仅调整逻辑：shmat 后 P锁读取数据，V锁释放。

4. 共享内存关键注意事项（Linux 特有坑）

1. 同步强制要求：无内置锁，多进程并发读写必然脏数据，必须搭配信号量；
2. 生命周期陷阱：调用 IPC_RMID 后，只要还有进程 attach，内存不会释放；程序崩溃会永久残留 shm，需 ipcrm -m 清理；
3. 大小对齐：shmget 设置 size 小于一页，内核依然分配完整一页，浪费内存；
4. 地址冲突：shmat 指定自定义 shmaddr 极易和栈、堆、动态库地址重叠，一律传 NULL；
5. 权限限制：普通用户创建超大共享内存会触发 shmmax 限制，root 可修改 sysctl；
6. 孤儿段：fork 子进程会继承 shmid，父子进程都 attach，进程退出不会删除段；
7. 不支持 IO 多路复用：无法用 select/poll 等待共享内存数据更新，必须手动轮询或信号通知。

5. Linux 内核行为补充

• 共享内存使用内核匿名页，不占用磁盘 swap（内存充足时）；
• 进程 OOM 杀死时，仅自动 shmdt，不会删除内核 shm 对象；
• 内核重启瞬间，所有 shm 资源全部回收。

---

二、消息队列 Message Queue（msg）

核心原理

内核为每个消息队列维护一条双向链表，每条消息固定携带 long mtype 类型标识；发送方将数据拷贝至内核缓冲区，接收方按消息类型筛选读取 ，天然自带消息边界，不会发生 TCP 粘包问题。

存在两次数据拷贝：用户态 → 内核缓冲区 → 用户态，性能低于共享内存；适合结构化异步消息分发、多进程分类通信场景。

1. Linux 内核数据结构

队列主体 struct msg_queue

struct msg_queue {
    struct kern_ipc_perm q_perm;    // 权限key、uid、mode
    time_t q_stime;                 // 最后msgsnd发送时间
    time_t q_rtime;                 // 最后msgrcv接收时间
    time_t q_ctime;                 // 创建/修改时间
    unsigned long q_cbytes;         // 当前队列所有消息总字节
    unsigned long q_qnum;           // 当前队列消息总条数
    unsigned long q_qbytes;         // 队列最大容量(msgmnb)
    pid_t q_lspid;                  // 最后发送进程PID
    pid_t q_lrpid;                  // 最后接收进程PID
    struct list_head q_messages;    // 消息链表头
    struct list_head q_receivers;  // 阻塞等待读的进程链表
    struct list_head q_senders;    // 阻塞等待写的进程链表
};

1.1 与进程调度的关联：等待队列机制

消息队列的阻塞收发能力，完全基于内核等待队列（wait queue）实现，是和进程调度子系统的核心联系：

• q_receivers 和 q_senders 本质是等待队列头 wait_queue_head_t，挂载阻塞进程的任务结构体；
• 当队列满（发送）或无匹配消息（接收）且未设置 IPC_NOWAIT 时，内核将当前进程的 task_struct 加入对应等待队列，设置为 TASK_INTERRUPTIBLE 状态，调用调度器让出CPU；
• 当有新消息入队或消息被读取时，内核遍历对应等待队列，唤醒所有阻塞进程，重新检查条件并执行操作。

1.2 内核内存分配特性

• 每条 struct msg_msg 由内核 slab 分配器从内核地址空间分配，独立于任何用户进程的地址空间；
• 单条消息大小、队列总字节限制（msgmax/msgmnb）本质是限制单个队列占用的内核内存上限，避免耗尽内核低内存；
• 消息读取后，内核立即释放 msg_msg 结构体占用的内核内存，无需等待队列销毁。

单条消息内核结构 struct msg_msg

struct msg_msg {
    struct list_head m_list;
    long m_type;        // 消息类型
    size_t m_ts;        // 消息数据长度
    char m_text[];      // 柔性数组存储消息正文
};

所有消息按发送顺序挂载 q_messages 链表，接收时根据 msgtyp 遍历筛选。

2. 全套 API 完整流程

2.1 msgget 创建/获取消息队列 ID

int msgget(key_t key, int msgflg);

返回 msqid，新建队列时内核初始化 msg_queue，默认 q_qbytes = sysctl msgmnb。

2.2 msgsnd 发送消息到内核队列

int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg);

1. msgp 必须以 long mtype 开头，自定义结构体示例：

   struct msgbuf {
       long mtype;    // > 0，禁止等于0/负数
       char data[256];
   };

2. msgsz：仅 data 数据长度，不包含 mtype 8字节；

3. msgflg：

   • 0：队列满时阻塞，直到有进程读取腾出空间；
   • IPC_NOWAIT：队列满直接返回 -1，不阻塞；
     内核行为：分配 msg_msg 节点，拷贝用户数据到内核，插入链表尾部，唤醒阻塞读进程。

2.3 msgrcv 按类型接收消息

ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg);

msgtyp 三种读取策略（核心特色）：

1. msgtyp = 0：读取链表第一条消息（先进先出）；
2. msgtyp > 0：读取第一条 mtype == msgtyp 的消息，跳过其他类型；
3. msgtyp < 0：读取 mtype ≤ abs(msgtyp) 中数值最小 的消息，实现优先级队列；
   msgflg 补充：

• IPC_NOWAIT：无匹配消息立即返回；
• MSG_NOERROR：消息正文长度超过 msgsz 时截断，不报错。
  内核行为：找到匹配 msg_msg，拷贝数据到用户缓冲区，从链表删除节点，释放内核内存，唤醒阻塞写进程。

2.4 msgctl 队列控制与删除

int msgctl(int msqid, int cmd, struct msqid_ds *buf);

• IPC_STAT：获取队列消息数量、总字节；
• IPC_SET：修改队列最大容量 q_qbytes；
• IPC_RMID：立即销毁整个队列 ，设置 q_perm.deleted = true 后直接释放所有消息内存，所有阻塞读写进程立刻唤醒并返回EIDRM错误，无等待流程（和共享内存删除逻辑完全不同）。

3. 消息队列完整示例（多类型消息分发）

// msg_send.c 发送端
#include <stdio.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <string.h>

#define MSG_KEY 0x6688
struct msgbuf {
    long mtype;
    char text[128];
};

int main() {
    int msqid = msgget(MSG_KEY, 0660 | IPC_CREAT);
    if(msqid == -1) { perror("msgget"); return -1; }

    struct msgbuf buf1 = {1, "普通业务消息"};
    struct msgbuf buf2 = {2, "高优先级消息"};
    msgsnd(msqid, &buf1, strlen(buf1.text), 0);
    msgsnd(msqid, &buf2, strlen(buf2.text), 0);
    printf("发送完成\n");
    sleep(10);
    msgctl(msqid, IPC_RMID, NULL);
    return 0;
}

接收端设置 msgtyp=2 只会读取高优先级消息，跳过类型1。

4. 消息队列核心注意事项

1. mtype 必须 > 0，传0/负数会触发 EINVAL 参数错误；
2. 拷贝开销大：高频大数据传输不推荐，优先共享内存；
3. IPC_RMID 立即销毁：和shm标记删除逻辑不同，删除瞬间清空所有未读消息；
4. 内核容量硬限制：单消息长度不超过 msgmax，队列总字节不超过 msgmnb；队列打满后写进程默认永久阻塞；
5. 无法多路复用：不能用 select 监听队列是否有新消息；
6. 进程崩溃残留：队列不会随进程退出销毁，未读消息永久占用内核内存，必须手动删除；
7. 无消息超时原生支持：阻塞读写无超时参数，如需超时必须配合信号中断。

---

三、信号量 Semaphore（sem）

核心原理

System V 信号量不是单个计数器，而是信号量集合（数组） ，一次 semop 可原子操作集合内多个信号量；核心用于进程互斥、同步、生产者消费者资源计数。

自带 SEM_UNDO 容错机制，进程异常崩溃时自动回滚信号量数值，规避死锁残留。仅同步，不传输任何业务数据。

1. Linux 内核数据结构

信号量集合 struct sem_array

struct sem_array {
    struct kern_ipc_perm sem_perm;
    time_t sem_otime;       // 最后一次semop操作时间
    time_t sem_ctime;       // 创建/修改时间
    struct sem *sem_base;   // 信号量数组首地址
    int sem_nsems;          // 集合内信号量个数
    struct list_head sem_pending; // 阻塞等待该集合的进程链表
};

单个信号量单元 struct sem

struct sem {
    int semval;     // 当前信号量计数值（资源剩余数量）
    pid_t sempid;   // 最后操作该信号量的进程PID
};

1.1 SEM_UNDO 与进程生命周期的深度绑定

SEM_UNDO 机制的底层依赖进程结构体的链表挂载，是信号量独有的容错特性，也是和进程管理子系统的核心联系：

• 每个进程的 task_struct 中维护一个 struct sem_undo 链表头，记录该进程所有带 SEM_UNDO 标志的操作记录；
• 每执行一次带 SEM_UNDO 的 semop，内核在当前进程的链表中追加一条记录，保存「信号量ID + 操作差值 + 集合序列号」；
• 进程正常退出、异常终止（含 kill -9）时，内核自动遍历该链表，对每个信号量反向修正 semval，归还进程持有的资源；
• 若信号量集合已被删除，对应记录会自动失效，进程退出时跳过修正，避免野指针访问。

1.2 原子操作的内核保证

批量操作的原子性由内核锁机制严格保障：

1. 执行 semop 前，先获取整个信号量集合的 sem_perm.lock 自旋锁；
2. 遍历所有操作项，校验全部操作是否可同时满足（资源足够、不会越界）；
3. 全部满足则一次性修改所有信号量的 semval，然后释放锁，操作成功；
4. 任意一项不满足：若设置 IPC_NOWAIT 则直接返回错误；否则将进程加入 sem_pending 等待队列，释放锁并进入阻塞。

全程只有一次加解锁，不会出现部分操作成功、部分失败的情况，从根源避免了多资源抢占的死锁问题。

2. 全套 API 完整流程

2.1 semget 创建/获取信号量集合

int semget(key_t key, int nsems, int semflg);

• nsems：创建时必须指定集合内信号量数量；获取已有集合时 nsems 可小于等于原值；
• 返回 semid，内核分配 sem_array + sem 数组，初始所有 semval = 0。

2.2 semctl 初始化/读取/删除集合

int semctl(int semid, int semnum, int cmd, ...);

可变参数依赖 cmd，共用联合体 union semun：

union semun {
    int val;                    // SETVAL 使用
    struct semid_ds *buf;       // IPC_STAT / IPC_SET
    unsigned short *array;      // GETALL / SETALL 批量操作
};

核心 cmd：

1. SETVAL：单独设置 semnum 对应信号量初始值（互斥锁初始化为1）；
2. GETVAL：读取单个信号量值；
3. SETALL：批量设置集合所有信号量；
4. IPC_RMID：立即删除整个信号量集合，所有阻塞进程返回EIDRM。

2.3 semop 原子批量操作（核心API）

int semop(int semid, struct sembuf *sops, unsigned nsops);

操作数组单元 struct sembuf：

struct sembuf {
    unsigned short sem_num; // 集合内信号量下标
    short sem_op;           // 操作值
    short sem_flg;          // 标志位
};

sem_op 三种行为

1. sem_op > 0：V操作，释放资源，semval += sem_op，唤醒等待资源的进程；
2. sem_op < 0：P操作，申请资源，semval -= abs(sem_op)；若剩余资源不足，进程阻塞；
3. sem_op = 0：等待信号量变为0，常用于等待资源完全释放。

sem_flg 关键标志

1. IPC_NOWAIT：资源不足不阻塞，直接返回；
2. SEM_UNDO：进程退出时自动撤销本次sem_op操作，防止崩溃死锁。

原子性保证

nsops 条操作全部成功执行 或 全部不执行，不会出现部分操作完成，天然规避多资源抢占死锁。

3. 互斥锁标准使用模板

// P加锁
void sem_lock(int semid) {
    struct sembuf op = {0, -1, SEM_UNDO};
    semop(semid, &op, 1);
}
// V解锁
void sem_unlock(int semid) {
    struct sembuf op = {0, 1, SEM_UNDO};
    semop(semid, &op, 1);
}

4. 信号量重点注意事项

1. 集合不可扩容：创建时 nsems 固定，无法后期新增信号量；
2. SEM_UNDO 推荐强制开启：进程崩溃、kill -9 时自动归还锁，避免永久死锁；
3. 原子批量操作优势：同时占用多把锁不会出现部分持有，解决哲学家就餐死锁；
4. 删除风险：semctl(IPC_RMID) 直接销毁集合，正在操作 semop 的进程会立刻报错；
5. 初始值必须手动设置：semget 创建后 semval 默认0，互斥锁必须调用 SETVAL 设为1；
6. 资源限制：sysctl semopm 限制单次 semop 最大操作数量，大批量原子操作会报错；
7. 无超时阻塞：原生 semop 不支持超时，需信号实现超时逻辑。

---

四、三类IPC底层协同与内核子系统映射总览

1. 三类IPC的底层结构关联图谱

内核子系统	共享内存 shm	消息队列 msg	信号量 sem	共用基座
通用IPC框架	✅ 继承kern_ipc_perm	✅ 继承kern_ipc_perm	✅ 继承kern_ipc_perm	ipc_ids、ipc_namespace
内存管理子系统	深度绑定VMA、tmpfs、页表	仅内核slab分配消息体	仅内核slab分配集合结构	通用内存分配器
进程调度子系统	无原生阻塞	等待队列阻塞唤醒	等待队列阻塞唤醒	通用等待队列机制
VFS文件系统	基于tmpfs匿名文件	无文件关联	无文件关联	无
生命周期管理	标记删除，计数归零释放	立即删除，直接释放	立即删除，直接释放	kern_ipc_perm.deleted标记

2. 典型协同场景的内核完整链路：共享内存+信号量

生产环境中共享内存几乎都搭配信号量做同步，二者在内核层面的完整交互流程如下：

1. 初始化阶段：分别创建shm和sem对象，内核在当前IPC命名空间的shm_ids、sem_ids中各注册一个对象，分配内核内存；
2. 写进程加锁 ：调用 semop 执行P操作，内核持有sem集合锁，校验资源充足后修改semval，释放锁；若资源不足则进入等待队列阻塞；
3. 写进程写入：获得锁后，进程访问共享内存虚拟地址，若缺页则由tmpfs分配物理页并建立页表映射，直接写入物理内存；
4. 写进程解锁 ：调用 semop 执行V操作，内核持有sem集合锁，增加semval，同时唤醒等待队列中阻塞的读进程；
5. 读进程被唤醒：调度器将读进程置为运行态，重新执行P操作获取锁，然后读取共享内存的物理页数据；
6. 销毁阶段：分别调用IPC_RMID，信号量立即销毁；共享内存标记删除，待所有进程shmdt后由tmpfs回收物理页。

3. 与POSIX IPC的底层同源性

Linux 下 System V IPC 与 POSIX IPC 并非完全独立的两套实现，底层存在大量复用：

• POSIX 共享内存与 System V 共享内存底层均基于 tmpfs，物理页管理、swap逻辑完全一致；
• POSIX 消息队列底层也由内核维护链表与等待队列，阻塞机制与 System V 同源；
• 核心差异仅在于：POSIX 暴露文件描述符、支持多路复用，而 System V 使用独立ID体系。

---

五、System V IPC 完整横向对比 & Linux 专属特性汇总

1. 三类 IPC 核心特性对照表

维度	共享内存 shm	消息队列 msg	信号量 sem
数据传输	支持，零拷贝最快	支持，两次内核拷贝	不传输数据，仅同步
同步能力	无，需搭配信号量	自带消息隔离，无锁	原生同步互斥工具
消息边界	无，纯内存流	有，mtype区分消息	无数据
删除逻辑	IPC_RMID仅标记，全部分离后释放	IPC_RMID立刻清空队列销毁	IPC_RMID立刻销毁集合
阻塞场景	无阻塞API	队列满/无匹配消息阻塞	资源不足/等待0阻塞
进程崩溃残留	shm对象留存，内存不释放	队列+未读消息留存	集合留存，SEM_UNDO自动回滚数值
典型场景	大数据高速传输	多进程分类异步消息	临界区互斥、资源计数同步

2. System V IPC vs POSIX IPC 深度补充（Linux）

对比项	System V IPC	POSIX IPC (Linux /dev/shm)
命名方式	key_t 整数key，无文件节点	文件路径字符串，挂载在/dev/shm
操作句柄	独立整数id，非文件描述符	fd 文件描述符，统一IO模型
IO多路复用	完全不支持 select/poll/epoll	POSIX消息队列支持 poll/mq_notify
生命周期	内核持久，必须手动删除	支持进程持久+文件持久，unlink后最后关闭自动销毁
资源限制	sysctl 全局硬限制	遵循文件系统磁盘/内存配额
接口复杂度	老旧繁琐，参数多	统一open/read/write，贴近文件IO
可移植性	老旧Unix兼容，嵌入式大量遗留	POSIX标准，跨平台新程序推荐
信号量特性	信号量集合、原子批量操作、SEM_UNDO	单个信号量，无批量原子操作，无undo

3. Linux 开发通用避坑总清单

1. 全部 System V 对象内核持久：程序正常退出、崩溃、kill 都不会自动删除，必须调用 IPC_RMID 或 ipcrm，长期运行服务必须做清理逻辑；
2. 多进程公用 key 冲突：ftok 存在哈希碰撞，商用项目建议使用固定自定义数字key；
3. 权限掩码遗漏：创建时不指定权限默认0000，其他进程无法读写；标准搭配 0660 | IPC_CREAT；
4. 信号量忘记初始化：semget 创建 semval=0，互斥锁必须 SETVAL=1；
5. 共享内存未同步：多进程并发读写不加信号量一定会出现脏数据；
6. 系统资源耗尽：并发大量创建 IPC 对象会达到 shmmni/msgmni/semmni 上限，新建直接失败；可定时清理无用对象；
7. 无法配合异步IO：所有 System V IPC 不能集成到事件驱动框架（epoll），高并发事件驱动程序优先 POSIX IPC / unix domain socket；
8. 容器环境限制：Docker 默认隔离 System V IPC，多容器共享 shm/msg/sem 需要启动参数 --ipc=shareable。

4. 生产环境选型建议

1. 超大块高速数据传输：共享内存 + System V 信号量；
2. 结构化、分类异步消息、简单多进程通信：消息队列；
3. 多进程临界区互斥、资源池计数同步：System V 信号量；
4. 新开发跨平台、事件驱动、需要多路复用监听：放弃 System V，选用 POSIX IPC / unix domain socket；
5. 遗留老项目维护：必须掌握 System V IPC，大量工业、嵌入式、服务器历史代码依赖这套接口。