Linux系列：聊一聊 SystemV 下的进程间共享内存

最新推荐文章于 2025-07-10 20:41:49 发布

大G哥

最新推荐文章于 2025-07-10 20:41:49 发布

阅读量917

点赞数 9

CC 4.0 BY-SA版权

文章标签： linux 运维服务器

本文链接：https://blog.csdn.net/Java_fenxiang/article/details/149149047

一：背景

1. 讲故事

昨天在分析一个 linux 的 dump 时，看到了这么一话警告，参考如下：

对，就是上面的 SYSV10cf21d1，拆分一下为 System V + 10cf21d1 ，前者的System V表示共享内存机制，后面的 10cf21d1 表示共享内存中用到的唯一键key，所以这表示当前的 .net 程序直接或者间接的使用了 System V的进程间共享内存，我对 Linux 不是特别熟悉，所以稍微研究了下就有了这篇文章。

二：System V 研究

1. 什么是进程间通信

其实在 Linux 中有很多中方式进行 IPC(进程间通信)，我用大模型帮我做了一下汇总，截图如下：

Linux系列：聊一聊 SystemV 下的进程间共享内存_linux

现如今Linux使用最多的还是 POSIX 标准，而 System V 相对来说比较老，为了研究我们写一个小例子观察下基本实现。

2. System V 的一个小例子

为了能够实现进程间通信，开启两个进程(writer，reader)端，一个是往共享内存写入，一个从共享内存中读取，画个简图如下：

Linux系列：聊一聊 SystemV 下的进程间共享内存_ubuntu_02

接下来在内存段的首位置设置控制flag，后面跟着传输的 content 内容，然后创建一个key与申请的内存段进行绑定，参考代码如下：

1)writer.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>

#define SHM_SIZE 1024 // 共享内存段大小

int main()
{
    key_t key;
    int shmid;
    char *shm_ptr;

    // 生成key值 - 使用当前目录和项目ID
    if ((key = ftok(".", 'x')) == -1)
    {
        perror("ftok");
        exit(1);
    }

    // 创建共享内存段
    if ((shmid = shmget(key, SHM_SIZE, IPC_CREAT | 0666)) == -1)
    {
        perror("shmget");
        exit(1);
    }

    // 附加到共享内存
    if ((shm_ptr = shmat(shmid, NULL, 0)) == (void *)-1)
    {
        perror("shmat");
        exit(1);
    }

    printf("Writer: 连接到共享内存段 %d\n", shmid);

    // 第一个字节作为标志位，其余部分存储数据
    char *flag_ptr = shm_ptr;
    char *data_ptr = shm_ptr + 1;

    // 初始化标志位
    *flag_ptr = 0;

    // 写入数据到共享内存
    char message[] = "Hello from writer process!";
    strncpy(data_ptr, message, sizeof(message));

    // 设置标志位表示数据已准备好
    *flag_ptr = 1;

    printf("Writer: 已写入消息: \"%s\"\n", message);

    // 等待读取进程完成
    printf("Writer: 等待读取进程确认...\n");
    while (*flag_ptr != 2)
    {
        sleep(1);
    }

    // 分离共享内存
    if (shmdt(shm_ptr) == -1)
    {
        perror("shmdt");
        exit(1);
    }

    // 删除共享内存段
    if (shmctl(shmid, IPC_RMID, NULL) == -1)
    {
        perror("shmctl");
        exit(1);
    }

    printf("Writer: 完成\n");

    return 0;
}

接下来就是 gcc 编译并运行，参考如下：

root@ubuntu2404:/data2# gcc -g writer.c -o writer
root@ubuntu2404:/data2# ls   
writer  writer.c
root@ubuntu2404:/data2# ./writer
Writer: 连接到共享内存段 2
Writer: 已写入消息: "Hello from writer process!"
Writer: 等待读取进程确认...

从输出看已经将 "Hello from writer process!" 写到了共享内存，接下来可以用 ipcs -m 观察共享内存段列表，以及虚拟地址段。

root@ubuntu2404:/proc# ipcs -m  

------ Shared Memory Segments --------
key        shmid      owner      perms      bytes      nattch     status      
0x78030002 3          root       666        1024       1         

root@ubuntu2404:/proc# ps -ef | grep writer 
root        7711    7593  0 10:41 pts/1    00:00:00 ./writer
root        7714    7618  0 10:41 pts/2    00:00:00 grep --color=auto writer              

root@ubuntu2404:/proc# cat /proc/7711/maps
5b412c9bc000-5b412c9bd000 r--p 00000000 08:03 1966088                    /data2/writer
5b412c9bd000-5b412c9be000 r-xp 00001000 08:03 1966088                    /data2/writer
5b412c9be000-5b412c9bf000 r--p 00002000 08:03 1966088                    /data2/writer
5b412c9bf000-5b412c9c0000 r--p 00002000 08:03 1966088                    /data2/writer
5b412c9c0000-5b412c9c1000 rw-p 00003000 08:03 1966088                    /data2/writer
5b415ad13000-5b415ad34000 rw-p 00000000 00:00 0                          [heap]
...
7c755ce80000-7c755ce81000 rw-s 00000000 00:01 3                          /SYSV78030002 (deleted)
...
ffffffffff600000-ffffffffff601000 --xp 00000000 00:00 0                  [vsyscall]
root@ubuntu2404:/proc#

上面输出的 /SYSV78030002 (deleted) 便是，哈哈，现在回头看这句 WARNING: Unable to verify timestamp for SYSV10cf21d1 (deleted) 是不是豁然开朗啦。。。

接下来继续聊，另一个进程要想读取共享内存，需要通过同名的key寻找，即下面的 shmget 方法。

2)reader.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <unistd.h>

#define SHM_SIZE 1024 // 共享内存段大小

int main()
{
    key_t key;
    int shmid;
    char *shm_ptr;

    // 生成相同的key值
    if ((key = ftok(".", 'x')) == -1)
    {
        perror("ftok");
        exit(1);
    }

    // 获取共享内存段
    if ((shmid = shmget(key, SHM_SIZE, 0666)) == -1)
    {
        perror("shmget");
        exit(1);
    }

    // 附加到共享内存
    if ((shm_ptr = shmat(shmid, NULL, 0)) == (void *)-1)
    {
        perror("shmat");
        exit(1);
    }

    printf("Reader: 连接到共享内存段 %d\n", shmid);

    // 第一个字节是标志位，其余是数据
    char *flag_ptr = shm_ptr;
    char *data_ptr = shm_ptr + 1;

    // 等待数据准备好
    printf("Reader: 等待数据...\n");
    while (*flag_ptr != 1)
    {
        sleep(1);
    }

    // 读取数据
    printf("Reader: 接收到消息: \"%s\"\n", data_ptr);

    // 通知写入进程已完成读取
    *flag_ptr = 2;

    // 分离共享内存
    if (shmdt(shm_ptr) == -1)
    {
        perror("shmdt");
        exit(1);
    }

    printf("Reader: 完成\n");

    return 0;
}

如果有朋友对绑定逻辑(shmget)的底层感兴趣，可以观察 Linux 中的 ipcget_public 方法，其中的 rhashtable_lookup_fast 便是。

static int ipcget_public(struct ipc_namespace *ns, struct ipc_ids *ids,
		const struct ipc_ops *ops, struct ipc_params *params)
{
	struct kern_ipc_perm *ipcp;
	int flg = params->flg;
	int err;

	/*
	 * Take the lock as a writer since we are potentially going to add
	 * a new entry + read locks are not "upgradable"
	 */
	down_write(&ids->rwsem);
	ipcp = ipc_findkey(ids, params->key);
    ...
}

static struct kern_ipc_perm *ipc_findkey(struct ipc_ids *ids, key_t key)
{
	struct kern_ipc_perm *ipcp;

	ipcp = rhashtable_lookup_fast(&ids->key_ht, &key,
					      ipc_kht_params);
	if (!ipcp)
		return NULL;

	rcu_read_lock();
	ipc_lock_object(ipcp);
	return ipcp;
}