// include/linux/ipc_namespace.h:18-30
struct ipc_ids {
    int in_use;         /* 当前对象数 */
    unsigned short seq;     /* 全局序号种子 */
    struct rw_semaphore rwsem;  /* 注册/查找的写侧锁 */
    struct idr ipcs_idr;        /* id → 对象 的 radix 索引 */
    int max_idx;
    int last_idx;   /* For wrap around detection */
#ifdef CONFIG_CHECKPOINT_RESTORE
    int next_id;
#endif
    struct rhashtable key_ht;   /* key → 对象 的哈希索引 */
};

struct ipc_namespace {
    struct ipc_ids  ids[3];     /* [SEM] [MSG] [SHM] 三套 */
    int     sem_ctls[4];
    ...
    unsigned int    msg_ctlmax; /* 单条消息上限 */
    unsigned int    msg_ctlmnb; /* 队列总字节上限 */
    unsigned int    msg_ctlmni;
    ...
    size_t      shm_ctlmax; /* 单段上限 */
    size_t      shm_ctlall; /* 全部段总和上限 */
    unsigned long   shm_tot;
    ...
};

// include/linux/ipc.h:12-30
struct kern_ipc_perm {
    spinlock_t  lock;       /* 对象自旋锁 */
    bool        deleted;    /* RMID 后的墓碑标记 */
    int     id;     /* 完整 id (序号+槽位) */
    key_t       key;
    kuid_t      uid;        /* 属主 (可经 IPC_SET 改) */
    kgid_t      gid;
    kuid_t      cuid;       /* 创建者 (不可改) */
    kgid_t      cgid;
    umode_t     mode;       /* rwx 权限位 */
    unsigned long   seq;        /* 序号 */
    void        *security;  /* LSM 挂点 (52 章) */

    struct rhash_head khtnode;  /* key_ht 的哈希节点 */
    struct rcu_head rcu;        /* RCU 释放头 */
    refcount_t refcount;        /* 对象引用 */
} ____cacheline_aligned_in_smp __randomize_layout;

// ipc/util.c:278-330（要点）
int ipc_addid(struct ipc_ids *ids, struct kern_ipc_perm *new, int limit)
{
    ...
    if (ids->in_use >= limit)
        return -ENOSPC;         /* namespace 限额 (mni/mni/mni) */

    id = idr_alloc(&ids->ids->ipcs_idr, ..., &new->id); /* 分配槽位 */
    ...
    ids->in_use++;
    ...
    new->cuid = new->uid = current_euid();  /* 创建者=属主 */
    new->gid = new->egid = current_egid();
    new->seq = ids->seq++;          /* 序号种子递增 */
    ...
    /* 全新 id = (seq << 位宽) | 槽位 */
}

id 的构成与重用防御:

  id = seq (高位) | 槽位号 (低位)
        ▲               ▲
        │               └ idr 分配, 对象删除后槽位可复用
        └ 全局种子, 每次新建 +1, 环绕周期 = 槽位总数 × 65536

 防御场景: 客户端 A 拿到 id=5, 服务端删了该对象又建了新对象,
 槽位号恰巧也是 5 —— 但 seq 已变, A 手里的旧 id 高位不匹配
 → idr 查找校验 seq 失败 → -EINVAL 而不是操作到别人的对象

 序号只在"新建"时递增 (seq++), 删除不动 —— 序号单调性
 与 seqlock (18.2.3 节) 的思想同源: 用"版本变了吗"判别
 "对象还是原来那个吗"

// ipc/util.c:397-430（要点）
static int ipcget_public(struct ipc_namespace *ns, struct ipc_ids *ids,
        struct ipc_ops *ops, struct ipc_params *params)
{
    ...
    if (key == IPC_PRIVATE)  {
        /* 匿名键: 必建新对象, key 仅作标签 */
        new = ops->getnew(ns, params);
        ...
    } else {
        ...
        ipcp = ipc_findkey(ids, params->key);   /* key 查找 */
        if (ipcp) {
            /* 已存在: 检查 flag 兼容性 */
            if (!ipc_check_perms(ns, ipcp, ops, params)) {
                /* IPC_CREAT|IPC_EXCL 且已存在 → -EEXIST */
                ...
            }
        } else {
            /* 不存在: 必须 IPC_CREAT 才建, 否则 -ENOENT */
            ...
        }
    }
    ...
}

// ipc/sem.c:95-112
struct sem {
    int semval;     /* current value */
    /*
     * PID of the process that last modified the semaphore...
     *  - semop
     *  - semctl, via SETVAL and SETALL.
     *  - at task exit when performing undo adjustments (see exit_sem).
     */
    struct pid *sempid;
    spinlock_t  lock;   /* spinlock for fine-grained semtimedop */
    struct list_head pending_alter; /* pending single-sop operations that alter */
    struct list_head pending_const; /* pending single-sop operations that don't alter */
    time64_t     sem_otime; /* candidate for sem_otime */
} ____cacheline_aligned_in_smp;

// ipc/sem.c:114-129
struct sem_array {
    struct kern_ipc_perm    sem_perm;   /* permissions .. see ipc.h */
    time64_t        sem_ctime;
    struct list_head    pending_alter;  /* pending operations that alter the array */
    struct list_head    pending_const;  /* pending complex operations */
    struct list_head    list_id;    /* undo requests on this array */
    int         sem_nsems;  /* no. of semaphores in array */
    int         complex_count;  /* pending complex operations */
    unsigned int        use_global_lock;/* >0: global lock required */
    struct sem      sems[];     /* 柔性数组: 成员紧跟其后 */
} __randomize_layout;

结构全景:

 sem_array (IPC 对象, 1 个信号量集)
   ├─ sems[0..nsems): 每 sem 一个自旋锁+双等待链
   ├─ pending_alter/pending_const (数组级)
   └─ list_id (本集全部 undo 记录)

 sem_queue (一次 semop 调用, 睡眠时存在)
   ├─ sops/nsops: 待执行的 sembuf 数组
   ├─ blocking: 卡住的那个操作
   ├─ alter: 是否有 SEM_UNDO/修改值 (决定挂哪个链)
   └─ sleeper: 睡眠的 task

 sem_undo (进程退出时的自动补偿记录)
   └─ 挂 task->sysvsem.undo_list + sem_array->list_id 双链

// ipc/sem.c:2256（入口）
long ksys_semtimedop(int semid, struct sembuf __user *tsops,
             unsigned int nsops, const struct timespec64 __user *timeout)

 semop(sops[nsops]) 的执行协议:

 [1] 排序: 按 sem_num 升序排列 sops (固定加锁顺序 → 防死锁)
 [2] 快检: 全部操作逐一试算 (semval ± sem_op)
     全部通过 → 原子提交, 唤醒因值变化而满足的等待者, 返回
 [3] 部分通过: 找到第一个卡住的 op (blocking)
     - SEM_UNDO 标记的 op 记入 undo 结构
     - 建 sem_queue 挂入对应链 (alter → pending_alter)
     - 睡眠 (含 timeout → semtimedop)
 [4] 被唤醒 (他人 semop 改变了值):
     重新快检 → 通过则提交; 仍不满足 → 再睡
 [5] 唤醒他人: 值变化后遍历 pending_alter 链,
     逐个试算其 sop 数组, 满足者出队完成

 原子性保证: "数组全部满足才整体生效" — 任一 op 卡住
 则整个数组等待, 无部分提交 (这就是"同时锁 N 个资源"语义)

// include/linux/msg.h:9-16
struct msg_msg {
    struct list_head m_list;
    long m_type;        /* 消息类型 (msgrcv 的选择依据) */
    size_t m_ts;        /* message text size */
    struct msg_msgseg *next;    /* 大消息的续页链 */
    void *security;
    /* the actual message follows immediately */    /* 数据内联在头部后 */
};

// ipc/msg.c:49-69
struct msg_queue {
    struct kern_ipc_perm q_perm;
    time64_t q_stime;       /* last msgsnd time */
    time64_t q_rtime;       /* last msgrcv time */
    time64_t q_ctime;
    unsigned long q_cbytes;     /* current bytes on queue */
    unsigned long q_qnum;       /* number of messages */
    unsigned long q_qbytes;     /* max bytes (msg_ctlmnb) */
    struct pid *q_lspid;        /* last msgsnd */
    struct pid *q_lrpid;
    struct list_head q_messages;    /* 消息链 */
    struct list_head q_receivers;   /* 睡眠的接收者 */
    struct list_head q_senders; /* 睡眠的发送者 (队列满时) */
} __randomize_layout;

// ipc/msg.c:961（入口）
long ksys_msgsnd(int msqid, struct msgbuf __user *msgp, size_t msgsz,
         int msgflg)

msgsnd 协议:

 [1] 权限检查 (q_perm.mode 的 WRITE 位) + 大小校验 (msgsz ≤ msg_ctlmax)
 [2] 分配 msg_msg + 拷贝用户数据
 [3] 持 q_perm.lock:
     若有等待中的接收者 (q_receivers 非空) 且类型匹配:
        → 直接移交! 消息不进 q_messages, 填 r_msg,
          smp_store_release 发布 (见 MSG_BARRIER), 唤醒
     否则: 挂 q_messages 尾
 [4] 队列满 (q_cbytes+msgsz > q_qbytes):
     IPC_NOWAIT → -EAGAIN; 否则挂 q_senders 睡眠

// ipc/msg.c:1264（入口）
long ksys_msgrcv(int msqid, struct msgbuf __user *msgp, size_t msgsz,
         long msgtyp, int msgflg)

无锁返回路径 (注释归纳):

 唤醒链: msgsnd 满足某接收者 → r_msg = 消息指针
          (smp_store_release 发布) → wake_q_add_safe 唤醒

 接收者醒来后 (syscall 返回路径):
   不重新拿锁! 直接 READ_ONCE(r_msg):
   - 是消息指针 → smp_acquire__after_ctrl_dep 后直接拷贝返回
   - 是 -EIDRM/-EAGAIN 常量 → 按错误返回
   锁只在"需要重睡/出队清理"时才拿

 前提: 挂起链上每个接收者只可能被"恰好属于它的移交"
 触发一次, r_msg 的 release/acquire 配对替代了锁
 (与 15.2 节 RELEASE 语义、26.2.1 节 pipe head 的
  acquire 读同族 — 无锁快路径的通用配方)

限额体系 (ipc_namespace 字段, /proc/sys/kernel/ 系列可调):
 msg_ctlmax   单条消息上限 (默认 8KB)
 msg_ctlmnb   单队列字节上限 (默认 16KB)
 msg_ctlmni   系统队列总数上限 (默认 32K)
 percpu_msg_bytes/msgs_hdrs  全局用量 per-CPU 计数器 (18 章口径)

 回收模型: 无自动回收!
 - 队列随 namespace 存活, 进程全退出也不删
 - IPC_RMID: 标记 deleted, 唤醒全部等待者报 -EIDRM
 - 未删队列的消息内存永久占用 → 泄漏型事故的高发区
   ("谁创建了队列谁负责删"是应用纪律)

// ipc/shm.c:54-79
struct shmid_kernel /* private to the kernel */
{
    struct kern_ipc_perm    shm_perm;   /* 28.1 节通用头 */
    struct file     *shm_file;  /* 真身: shmem 文件! */
    unsigned long       shm_nattch; /* attach 计数 */
    unsigned long       shm_segsz;
    time64_t        shm_atim;   /* 最后 shmat 时间 */
    time64_t        shm_dtim;   /* 最后 shmdt 时间 */
    time64_t        shm_ctim;
    struct pid      *shm_cprid;
    struct pid      *shm_lprid;
    struct ucounts      *mlock_ucounts; /* SHM_LOCK 记账 */
    /*
     * The task created the shm object, for
     * task_lock(shp->shm_creator)
     */
    struct task_struct  *shm_creator;
    /*
     * List by creator. task_lock(->shm_creator) required...
     * If list_empty(), then the creator is dead already.
     */
    struct list_head    shm_clist;  /* 挂创建者的回收链 */
    struct ipc_namespace    *ns;
} __randomize_layout;

// ipc/shm.c:702-740（节选）
static int newseg(struct ipc_namespace *ns, struct ipc_params *params)
{
    ...
    if (size < SHMMIN || size > ns->shm_ctlmax)     /* 单段限额 */
        return -EINVAL;
    ...
    if (ns->shm_tot + numpages < ns->shm_tot ||
            ns->shm_tot + numpages > ns->shm_ctlall)
        return -ENOSPC;                 /* 总量限额 */

    shp = kmalloc_obj(*shp, GFP_KERNEL_ACCOUNT);
    ...
    shp->shm_perm.key = key;
    shp->shm_perm.mode = (shmflg & S_IRWXUGO);
    ...
    file = shmem_file_setup(name, size, acctflag);      /* 建真身文件 */
    ...
    shp->shm_file = file;
    ...
}

// ipc/shm.c:1519-1660（节选）
long do_shmat(int shmid, char __user *shmaddr, int shmflg,
          ulong *raddr, unsigned long shmlba)
{
    ...
    if (shmflg & SHM_RDONLY) {
        prot = PROT_READ;
        ...
    } else {
        prot = PROT_READ | PROT_WRITE;
        ...
    }
    if (shmflg & SHM_EXEC) {
        prot |= PROT_EXEC;          /* 显式申请执行位 */
        ...
    }
    ...
    /*
     * We need to take a reference to the real shm file to prevent the
     * pointer from becoming stale in cases where the lifetime of the
     * outer file extends beyond that of the shm segment...
     */
    base = get_file(shp->shm_file);
    shp->shm_nattch++;
    size = i_size_read(file_inode(base));
    ...
    file = alloc_file_clone(base, f_flags,
              is_file_hugepages(base) ?
                &shm_file_operations_huge :
                &shm_file_operations);      /* clone 外壳文件 */
    ...
    sfd->id = shp->shm_perm.id;     /* shm_file_data 填充 */
    sfd->ns = get_ipc_ns(ns);
    ...
    /* 最终: do_mmap(file, addr, size, prot, flags, ...) */
}

shmat 的分层结构:

 shmid (id) ──查──> shmid_kernel ──> shm_file (shmem 文件, 真身)
                                        │
                    alloc_file_clone ──>│ 外壳 file (每进程一份,
                                        │  private_data = shm_file_data)
                                        v
                    do_mmap(file, ...) ──> 进程地址空间 VMA
                                        (22.3 节全流程复用!)

 关键设计: 外壳 file 隔离"每进程状态" (f_mode/权限/f_pos)
 与"共享数据"(页缓存) — 与 26.3 节 FIFO 嫁接 inode 同思想
 is_file_hugepages 分支: 段以 hugetlbfs 建立时
 (SHM_HUGETLB 标志) 走大页版 fops (23.2 节联动)

生命周期状态机:

 shmget ──> [ACTIVE] ──shmat──> [ATTACHED] nattch++
                │                    │
                │ IPC_RMID           │ shmdt: nattch--
                v                    v
            [MARKED deleted]    nattch==0?
                │                    │ 是 + 已 MARKED
                │  新 shmat → -EIDRM │ → shm_destroy: 文件页回收
                └────────────────────┘
                 否则存活到 namespace 退出

 特殊保障 (shm_clist 链): 创建者进程死亡时,
 exit 代码遍历其 shm_clist 把孤儿段标记删除
 —— 防止"建段进程死了, 段与页永久驻留"