Linux进程间通信之共享内存实现篇

原创 已于 2025-12-12 15:35:15 修改 · 757 阅读 · 13 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#linux #服务器 #运维
于 2025-12-12 15:32:57 首次发布

Linux 内核中共享内存的实现（基于 2.6.12）

核心文件与路径

  • ipc/shm.c: System V 共享内存系统调用与核心逻辑
  • include/linux/shm.h: 结构体与常量定义（shmid_kernel 在 #ifdef __KERNEL__ 块内, 仅内核可见）
  • ipc/util.c: IPC 公共 ID/权限/锁管理
  • mm/: 通用内存管理接口（页分配、映射）

核心数据结构

shmid_kernel（位于 include/linux/shm.h）

// include/linux/shm.h (在 #ifdef __KERNEL__ 块内, 仅内核可见)
struct shmid_kernel /* private to the kernel */
{
    struct kern_ipc_perm shm_perm;  // IPC 权限/键值/锁
    struct file *shm_file;          // 关联的 shmem 文件, 承载页缓存
    int id;                         // 内部 ID (用于 IPC 表索引)
    unsigned long shm_nattch;       // 当前附加次数(映射该段的进程数)
    unsigned long shm_segsz;        // 段大小(字节)
    time_t shm_atim;                // 最后 attach 时间
    time_t shm_dtim;                // 最后 detach 时间
    time_t shm_ctim;                // 最后变更时间
    pid_t shm_cprid;                // 创建者 PID
    pid_t shm_lprid;                // 最后操作 PID
    struct user_struct *mlock_user; // 锁定内存的用户结构(用于 SHM_LOCK)
};

shmem_inode_info

  • 来自 tmpfs/shmem，作为 shm_file 的支撑，负责页缓存与换入换出（除非 SHM_LOCK 锁定）。

系统调用路径（x86_64 类推）

  • sys_shmget → ipc/shm.c:sys_shmget → newseg() 创建段（分配 shmid_kernel + shmem 文件）并通过 ipc_addid 安装到 IPC 表
  • sys_shmat → ipc/shm.c:sys_shmat → do_shmat() 检查权限/地址 → 通过 do_mmap_pgoff() 把 shm_file 映射到进程用户空间
  • sys_shmdt → ipc/shm.c:sys_shmdt → do_shmdt() 卸载映射，递减 shm_nattch
  • sys_shmctl → ipc/shm.c:sys_shmctl 处理 IPC_RMID/IPC_SET/IPC_STAT/SHM_LOCK/SHM_UNLOCK

关键流程

创建段（shmget → newseg）

  1. 校验大小不超过 shm_ctlmax，对齐页（向上按页或 SHMLBA）。
  2. 分配 shmid_kernel（ipc_rcu_alloc），初始化 shm_perm、大小、时间戳、计数。
  3. 创建支撑文件：调用 shmem_file_setup() 创建匿名 shmem 文件，关联到 shm_file，用于后续映射与页缓存管理。
  4. 通过 ipc_addid(&shm_ids, …) 安装到 IPC ID 表，返回 shmid（序号+序列）。

简要实现（ipc/shm.c:sys_shmget/newseg）

asmlinkage long sys_shmget(key_t key, size_t size, int shmflg)
{
    struct shmid_kernel *shp;
    int err, id;

    // 尺寸检查: 不得超过 shm_ctlmax
    if (size > shm_ctlmax)
        return -EINVAL;

    // 对齐到页面/SHMLBA (VIPT/TLB 需求)
    size = ALIGN(size, SHMLBA);

    // 如果指定 IPC_PRIVATE 或不存在且 IPC_CREAT，则创建
    id = newseg(key, shmflg, size);
    return id; // 返回 shmid (序号+序列)
}

static int newseg(key_t key, int shmflg, size_t size)
{
    struct shmid_kernel *shp;
    int id, err;

    // 分配内核描述符
    shp = ipc_rcu_alloc(sizeof(*shp));
    if (!shp)
        return -ENOMEM;

    shp->shm_perm.key  = key;
    shp->shm_perm.mode = (shmflg & S_IRWXUGO);
    shp->shm_perm.security = NULL;
    shp->shm_segsz = size;
    shp->shm_atim = shp->shm_dtim = 0; // 初始未映射/未解绑
    shp->shm_ctim = get_seconds();     // 创建时间
    shp->shm_cprid = shp->shm_lprid = current->pid;
    shp->shm_nattch = 0;               // 尚无进程映射

    // 创建支撑文件 (基于 shmem)
    shp->shm_file = shmem_file_setup("SYSV0000", size, 0);
    if (IS_ERR(shp->shm_file)) {
        err = PTR_ERR(shp->shm_file);
        ipc_rcu_putref(shp);
        return err;
    }

    // 安装到 IPC ID 表
    id = ipc_addid(&shm_ids, &shp->shm_perm, shmmni);
    if (id == -1) {
        fput(shp->shm_file);
        ipc_rcu_putref(shp);
        return -ENOSPC;
    }

    return shm_buildid(id, shp->shm_perm.seq); // 返回 shmid
}

映射（shmat → do_shmat）

  1. 权限检查与 ID 校验 (ipc_lock/ipc_checkid/ipcperms)。
  2. 解析 shmaddr / shmflg：
    • SHM_RDONLY 只读映射
    • SHM_RND 地址向下按 SHMLBA 对齐
    • 若指定地址且违反对齐/冲突，返回 EINVAL
  3. 增加 shm_nattch，更新时间 shm_atim、shm_lprid。
  4. 通过 do_mmap_pgoff() 将 shm_file 映射到进程用户空间（用户态虚拟地址因进程不同而异，但指向同一物理页集合）。

简要实现（ipc/shm.c:sys_shmat/do_shmat）

asmlinkage long sys_shmat(int shmid, char __user *shmaddr, int shmflg)
{
    unsigned long addr;
    int err;

    // do_shmat 负责权限/地址检查与实际映射
    err = do_shmat(shmid, shmaddr, shmflg, &addr);
    if (err)
        return err;
    return addr; // 用户态虚拟地址
}

static int do_shmat(int shmid, char __user *shmaddr, int shmflg,
                    unsigned long *raddr)
{
    struct shmid_kernel *shp;
    struct file *file;
    unsigned long addr, flags;

    // 获取并锁定段
    shp = shm_lock(shmid);
    if (!shp)
        return -EINVAL;
    if (ipc_checkid(&shp->shm_perm, shmid)) {
        shm_unlock(shmid);
        return -EIDRM;
    }
    if (ipcperms(&shp->shm_perm, (shmflg & SHM_RDONLY) ? S_IRUGO : S_IRUGO|S_IWUGO)) {
        shm_unlock(shmid);
        return -EACCES;
    }

    file = shp->shm_file;
    get_file(file); // 引用计数+1, 防止映射期间文件被释放

    // 处理地址/对齐
    addr = (unsigned long)shmaddr;
    if (shmflg & SHM_RND)
        addr &= ~(SHMLBA - 1);

    flags = MAP_SHARED;
    if (shmflg & SHM_RDONLY)
        flags |= PROT_READ;
    else
        flags |= PROT_READ | PROT_WRITE;

    // 实际映射: do_mmap_pgoff 返回用户态虚拟地址
    addr = do_mmap_pgoff(file, addr, shp->shm_segsz, flags, 0, 0);
    if (IS_ERR_VALUE(addr)) {
        fput(file);
        shm_unlock(shmid);
        return addr;
    }

    // 更新状态
    shp->shm_nattch++;              // 映射计数+1
    shp->shm_atim = get_seconds();  // 记录最后 attach 时间
    shp->shm_lprid = current->pid;  // 记录最后操作 PID

    shm_unlock(shmid);
    *raddr = addr;
    return 0;
}

解除映射（shmdt → do_shmdt）

  1. 查找并拆除进程中对应的 VMA 区域（按基地址与长度）。
  2. 递减 shm_nattch，更新时间 shm_dtim、shm_lprid。
  3. 如果段已被标记删除且 shm_nattch==0，释放资源。

简要实现（ipc/shm.c:sys_shmdt/do_shmdt）

asmlinkage long sys_shmdt(char __user *shmaddr)
{
    return do_shmdt((unsigned long)shmaddr);
}

static int do_shmdt(unsigned long addr)
{
    struct shmid_kernel *shp;
    int retval;

    // 通过 VMA 找到对应的 shm 段, 执行 unmap
    retval = shm_unmap(addr); // 内部执行 find_vma + do_munmap
    if (retval)
        return retval;

    // shm_unmap 中会递减 shm_nattch，并在必要时触发销毁
    return 0;
}

控制（shmctl）

  • IPC_RMID: 标记段删除，若 shm_nattch==0 立即释放（shm_destroy），否则等待最后一个 detach 后释放。
  • IPC_SET: 更新权限和 shm_perm.uid/gid/mode，更新时间戳。
  • IPC_STAT: 填充 shmid_ds 返回用户态。
  • SHM_LOCK/SHM_UNLOCK: 锁定/解锁页以防换出（需要 CAP_IPC_LOCK），内部通过 shm_lock/shm_unlock 配合 shmem。

简要实现（ipc/shm.c:sys_shmctl，聚焦 IPC_RMID）

asmlinkage long sys_shmctl(int shmid, int cmd, struct shmid_ds __user *buf)
{
    struct shmid_kernel *shp;
    int err;

    down(&shm_ids.sem);              // IPC 表级锁
    shp = shm_lock(shmid);           // 对象锁 + 获取
    if (!shp) {
        err = -EINVAL;
        goto out_up;
    }
    if (ipc_checkid(&shp->shm_perm, shmid)) {
        err = -EIDRM;
        goto out_unlock_up;
    }

    switch (cmd) {
    case IPC_RMID:
        // 从 IPC 表移除，标记删除
        shm_destroy(shp);
        err = 0;
        break;
    case IPC_SET:
        // 更新权限/属主/模式
        err = shmctl_down(shp, cmd, buf);
        break;
    case IPC_STAT:
        // 拷贝状态给用户
        err = shmctl_stat(shp, buf);
        break;
    case SHM_LOCK:
    case SHM_UNLOCK:
        err = shmctl_do_lock(shp, cmd);
        break;
    default:
        err = -EINVAL;
        break;
    }

out_unlock_up:
    shm_unlock(shmid);
out_up:
    up(&shm_ids.sem);
    return err;
}

释放与回收

  • shm_destroy：从 IPC 表移除 (ipc_rmid)，关闭 shm_file，释放 shmid_kernel。
  • 如果段被 IPC_RMID 标记，最后一个 shmdt 完成后触发真正释放。

删除与回收（ipc/shm.c:shm_destroy）

static void shm_destroy(struct shmid_kernel *shp)
{
    // 从 IPC ID 表移除并标记删除
    ipc_rmid(&shm_ids, &shp->shm_perm);

    // 关闭支撑文件，释放引用
    fput(shp->shm_file);

    // 释放描述符 (RCU)
    ipc_rcu_putref(shp);
}

并发与锁

  • IPC 表锁：shm_ids.sem 序列化添加/删除。
  • 对象锁：ipc_lock 保护单个段的元数据（权限、计数、状态）。
  • RCU/引用计数：ipc_rcu_alloc/putref 管理对象生命周期；shm_nattch 计数配合删除判定。

相关限制（2.6.12）

  • shmmax：单段最大字节数 (/proc/sys/kernel/shmmax)
  • shmmni：系统最大段数 (/proc/sys/kernel/shmmni)
  • shmall：可用页框总数上限 (/proc/sys/kernel/shmall)
  • SHMLBA：映射对齐粒度（通常为页或更大，对齐到大页边界以兼容 VIPT/TLB 需求）

重要特性/行为

  • 段由 shmem（tmpfs）文件承载页缓存，支持按需分配与换出（除非 SHM_LOCK）。
  • shmat 映射地址位于用户态虚拟地址空间，各进程地址可不同但物理页共享。
  • shmdt 仅拆映射并递减计数，不一定释放物理页；IPC_RMID + shm_nattch==0 才真正销毁。
  • SEM_UNDO 不涉及共享内存；共享内存的同步需用户态自管（信号量/互斥锁等）。

参考函数/符号（2.6.12）

  • sys_shmget / sys_shmat / sys_shmdt / sys_shmctl
  • newseg / do_shmat / do_shmdt / shm_destroy
  • shmem_file_setup（支撑文件）/ do_mmap_pgoff（映射）
  • ipc_addid / ipc_rmid / ipc_lock / ipc_checkid
操作系统：共享内存进程间通信实验
m0_56339391的博客
11-25 815
利用Linux进程通信（PIC）的共享内存函数，实践操作系统的共享内存进程间通信的相关知识。共享内存函数由shmget、shmat、shmdt、shmctl四个函数组成。
Linux进程间通信之共享内存（POSIX）实现篇
最新发布
荒坡_KingRumn
12-21 743
基于 2.6.12 内核, 说明 POSIX 共享内存的核心数据结构、系统调用路径及关键实现. POSIX 共享内存通过 shmem(tmpfs) 文件系统实现, 主要文件:mm/shmem.cipc/shm.c(部分)、fs/namei.c(路径解析).
linux rsh通信实现_linux进程间通信----IPC篇(二)----共享内存实现进程间通信
weixin_42117224的博客
01-08 102
先给自己打个广告，本人的微信公众号正式上线了，搜索:张笑生的地盘，主要关注嵌入式软件开发，足球等等，希望大家多多关注，有问题可以直接留言给我，一定尽心尽力回答大家的问题一 what在《linux进程间通信----IPC篇(一)----共享内存初识篇》文章中，我们知道了共享内存是什么，通过几个常用的函数shmget、ftok、shmat、shmdt、shmctl，了解了如何创建共享内存，但是创建好的...
linux进程间通信(五)----IPC篇----共享内存实现进程间通信
myselfzhangji的博客
12-08 373
先给自己打个广告，本人的微信公众号正式上线了，搜索:张笑生的地盘，主要关注嵌入式软件开发，股票基金定投，足球等等，希望大家多多关注，有问题可以直接留言给我，一定尽心尽力回答大家的问题 一 what 在《linux进程间通信(四)----IPC篇----共享内存初识篇》文章中，我们知道了共享内存是什么，通过几个常用的函数shmget、ftok、shmat、shmdt、shmctl，了解了如何创建共...
contentprovider实现跨进程通信_linux进程间通信----IPC篇(二)----共享内存实现进程间通信...
weixin_39995943的博客
11-30 184
先给自己打个广告，本人的微信公众号正式上线了，搜索:张笑生的地盘，主要关注嵌入式软件开发，足球等等，希望大家多多关注，有问题可以直接留言给我，一定尽心尽力回答大家的问题一 what在《linux进程间通信----IPC篇(一)----共享内存初识篇》文章中，我们知道了共享内存是什么，通过几个常用的函数shmget、ftok、shmat、shmdt、shmctl，了解了如何创建共享内存，但是创建好的...
共享内存
wind_waves的博客
11-16 209
在内存上开辟一块空间作为共享内存，多个进程可以对它进行访问。 写两个进程，一个对程序进行写操作，一个进行读操作 写进程： #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <string.h> #include <assert.h> #include...
Linux--信号量共享内存
m0_59052131的博客
11-25 1623
信号量接口、信号量共享内存
Linux笔记--共享内存
中华田园巨龙
12-22 135
介绍 共享内存是一段物理数据区域，可以被映射到多个进程进行直接读写访问。十分方便。 使用方式是 创建–映射–直接使用–取消映射–删除共享内存 函数 //创建并获取共享内存区 int shmget(key_t key, size_t size, int shmflg)； //映射内存 void *shmat(int shmid, const void *shmaddr, int shmflg); //取消映射 int shmdt(const void *shmaddr); //共享内存控制--用于删除共享内存
Linux进程间通信——使用共享内存
热门推荐
ljianhui的专栏
08-24 24万+
下面将讲解进程间通信的另一种方式，使用共享内存。 一、什么是共享内存 顾名思义，共享内存就是允许两个不相关的进程访问同一个逻辑内存。共享内存是在两个正在运行的进程之间共享和传递数据的一种非常有效的方式。不同进程之间共享的内存通常安排为同一段物理内存。进程可以将同一段共享内存连接到它们自己的地址空间中，所有进程都可以访问共享内存中的地址，就好像它们是由用C语言函数malloc分配的内存一
【Linux】进程间通信——共享内存
2301_79969994的博客
02-27 4916
共享内存（Shared Memory）是一种进程间通信（IPC）机制，允许多个进程共享同一块物理内存，从而提高数据交换效率。相比其他 IPC 方式（如管道、消息队列等），共享内存具有速度快、低开销的优势，因为数据直接存储在内存中，而无需通过内核进行数据拷贝。共享内存作为一种高效的进程间通信机制，因其直接在内存中操作数据，避免了数据拷贝，提供了快速的数据传输方式。通过shmgetshmatshmctl等函数，Linux 系统为我们提供了灵活的共享内存操作接口。
linux进程间通信之共享内存篇
m0_74282605的博客
02-03 1125
首先打开一个或者创建一个文件，并把文件长度设置为5个people结构大小，然后使用mmap函数，把该文件映射到进程空间，len设置为10个people结构的大小，请注意此时文件大小和映射到进程空间的地址并不一样，这是被允许的，进程空间设置的大小受文件大小的影响但不一定要等于文件的大小，以指定的格式向该映射内存中写入10个people的数据；由于父子进程特殊的亲缘关系，在父进程中先调用mmap()，然后调用fork，那么在fork之后，子进程继承父进程匿名映射后的地址空间，同样也继承mmap返回的地址；
Linux进程间通信——共享内存
strive_mianyang的博客
09-18 2369
linux进程间通信——共享内存
【Linux】进程间通信——System V共享内存
Renswc的博客
12-08 2377
System V是一种在Linux系统中用于进程间通信（IPC）的机制。它提供了几种不同的通信方式，包括共享内存、消息队列和信号量。System V共享内存是一种高效的进程间通信（IPC）机制，它允许多个进程共享一块物理内存区域，从而避免了数据的复制，显著提高了数据传输速率。
【Linux】Linux 共享内存：高效的进程间通信
2403_86785171的博客
09-07 1956
共享内存是一块可以被多个进程同时访问的内存区域，允许不同进程读取和写入同一份数据。每个进程都可以直接访问这块内存，不需要通过管道、套接字或消息队列进行数据传输。这种直接访问的特点使得共享内存成为最为高效的进程间通信机制之一，适用于需要频繁交换大量数据的场景。
Linux进程间通信【共享内存】
北 海的博客
06-09 9970
共享内存出自System V标准，是众多IPC解决方案中最快的一种，使用共享内存进行通信时，不需要借助函数进入内核传递数据，而是直接对同一块空间进行数据访问，至于共享内存是如何使用的、通信原理是怎么实现的、以及共享内存+命名管道的组合通信程序该如何实现，都将在本文中解答
【Linux-进程间通信】共享内存
2202_75331338的博客
11-04 2025
ipcs是一个用于查看 POSIX 系统中进程间通信 (IPC) 资源信息的命令行工具。使用-m选项可以专门查看共享内存 (shared memory) 的相关信息。常用选项描述-m显示共享内存段的信息-q显示消息队列的信息（不与-m一起使用）-s显示信号量的信息（不与-m一起使用-t显示创建时间-p显示创建者的 PID-c显示核心映像的创建者-l显示更详细的列表字段含义key用于访问共享内存段的键值。这个键是由ftok。
【Linux笔记】进程间通信——system v 共享内存
GGDxianv的博客
03-30 1084
共享内存是Linux系统中进程间通信（IPC）的一种方式，允许多个进程直接访问同一块物理内存区域。它的核心特点是零拷贝——数据直接在内存中共享，无需通过内核缓冲区中转，因此成为速度最快的IPC机制。共享内存是system v的一种标准，Linux内核支持这种标准，专门设计了这个模块。两个进程访问同一块物理内存，如上图共享内存通过页表映射到两个进程的地址空间，两个进程就可以看到同一块资源，进而实现进程间的通信。
进程间通信--共享内存详解【Linux】
Mclecak的博客
04-30 3955
本文详细讲解了共享内存的原理和使用，并且通过实例代码角度来深度理解共享内存，下面就让我们开始吧。
Ubuntu桌面图标快捷方式以root用户启动
荒坡_KingRumn
06-03 8603
Title: Ubuntu桌面图标快捷方式以root用户启动(16.04) 与桌面图标相关的几个文件夹 /usr/share/icons 系统图标文件夹 /usr/share/applications 系统快捷方式文件夹 ~/.local/share/applications 用户菜单文件夹 ~/.local/share/icons 用户图标文件夹 点击图标以root用户运行程序 很多应用程序在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值