【Linux进程通信】四、System V IPC

struct shmid_kernel
{ 
    struct shmid_ds u;
    
    /* the following are private */
    unsigned long shm_npages; /* size of segment (pages) */          // 表示共享内存使用了多少个内存页
    pte_t *shm_pages; /* array of ptrs to frames -> SHMMAX */        // 指向了共享内存映射的虚拟内存页表项数组
    struct vm_area_struct *attaches; /* descriptors for attaches */  // 
};

static struct shmid_kernel *shm_segs[SHMMNI]; // SHMMNI等于128

struct shmid_ds {
    struct ipc_perm shm_perm; /* operation perms */           // 该空间的所有权等属性，其中包括了用来唯一标识的key
    int shm_segsz; /* size of segment (bytes) */              // 共享空间的大小（字节为单位）
    __kernel_time_t shm_atime; /* last attach time */         // 最后关联时间
    __kernel_time_t shm_dtime; /* last detach time */         // 最后去除关联时间
    __kernel_time_t shm_ctime; /* last change time */         // 属性最后修改时间
    __kernel_ipc_pid_t shm_cpid; /* pid of creator */         // 创建该空间的进程pid
    __kernel_ipc_pid_t shm_lpid; /* pid of last operator */   // 最后一个关联或者挂接该空间的进程pid
    unsigned short shm_nattch; /* no. of current attaches */  // 当前空间的挂接数
    ......
};

struct ipc_perm {
    key_t __key; /* Key supplied to shmget(2) */         // 这个就是用来标识shmid唯一性的key
    uid_t uid;   /* Effective UID of owner */
    gid_t gid;	 /* Effevtive GID of owner */
    uid_t cuid;	 /* Effective UID of creator */
    gid_t cgid;  /* Effective GID of creator */
    unsigned short mode;  /* Permissions + SHM_DEST and SHM_LOCKED flags */
    unsigned short __seq;  /* Sequence number */
}

ipcrm -m shmid编号

#include <sys/ipc.h>
#include <sys/shm.h>
int shmget(key_t key, size_t size, int shmflg);

// 作用：得到一个共享内存标识符，或者创建一个共享内存对象并返回共享内存标识符
// 返回值：获取成功则返回一个非负数，即共享内存标识符，取决于shmflg的参数（不同操作系统返回值不同）；获取失败则返回-1，并且设置错误码errno

#include <sys/types.h>
#include <sys/ipc.h>
key_t ftok(const char *pathname, int proj_id);

// 作用：这个函数会根据传的路径名和id值，通过算法形成一个key值
// 返回值：成功的话返回这个得到的key值（key_t其实就是int），失败的话返回-1，并设置错误码errno
// 参数：
//    pathname：自定义路径，但是必须是一个存在的路径，不一定是当前文件的路径
//    proj_id：自定义id，但是必须是非0

#include <sys/type.h>
#include <sys/shm.h>
int shmctl(int shmid, int cmd, struct shmid_ds *buf);

// 作用：对共享内存进行控制，如删除共享内存、得到或修改共享内存的状态
// 返回值：执行成功则返回0，失败返回-1，并且设置错误码errno

#include <sys/ipc.h>
#include <sys/shm.h>
void *shmat(int shmid, const void *shmaddr, int shmflg);

// 作用：把共享内存区对象映射到调用进程的地址空间
// 返回值：成功的话则返回关联好的共享内存的地址，失败的话返回-1，并设置错误码errno

#include <sys/types.h>
#include <sys/shm.h>
int shmdt(const void *shmaddr);

// 作用：与对应shmaddr位置处的共享内存去关联
// 返回值：成功去关联则返回0，失败则返回-1，并且设置错误码errno
// 参数：shmaddr表示关联的共享内存的起始地址

#ifndef _COMM_HPP_
#define _COMM_HPP_

#include <iostream>
#include <cerrno>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <unistd.h>
#include <sys/ipc.h>
#include <sys/types.h>
#include <sys/shm.h>
using namespace std;

// 设置两个常量pathname和proj_id，用来获取key值
const char* PATHNAME = ".";
const int PROJ_ID = 0x66;

const int MAX_SIZE = 4096; // 共享内存的大小

// 调用ftok函数获得key
key_t getKey()
{
    key_t k = ftok(PATHNAME, PROJ_ID);
    if(k == -1)
    {
        cerr << errno << " : " << strerror(errno) << endl;
        exit(1);
    }
    return k;
}

// 创建或者获取共享内存标识符的函数
int getShmHelper(key_t k, int flags)
{
    int shmid = shmget(k, MAX_SIZE, flags);
    if(shmid == -1)
    {
        cerr << errno << " : " << strerror(errno) << endl;
        exit(2);
    }
    return shmid;
}

// 为client提供获取共享内存标识符的函数
int getShm(key_t k)
{
    return getShmHelper(k, IPC_CREAT);
}

// 为server提供创建共享内存标识符的函数
int createShm(key_t k)
{
    // 注意这里是创建shm，所以必须也得给共享内存带上访问权限
    return getShmHelper(k, IPC_CREAT | IPC_EXCL | 0600);
}

// 关联共享内存
void* attachShm(int shmid)
{
    // 注意当前是64位机，所以指针大小为8字节，所以不能强转为int
    void* start = shmat(shmid, nullptr, 0);
    if((long long)start == -1L)
    {
        cerr << errno << " : " << strerror(errno) << endl;
        exit(4);
    }
    return start;
}

// 去关联
void detachShm(const void* shmaddr)
{
    if(shmdt(shmaddr) == -1)
    {
        cerr << errno << " : " << strerror(errno) << endl;
        exit(5);
    }
}

// 删除共享内存
void delShm(int shmid)
{
    if(shmctl(shmid, IPC_RMID, nullptr) == -1)
    {
        cerr << errno << " : " << strerror(errno) << endl;
        exit(3);
    }
}

#endif

#include "comm.hpp"
int main()
{
    key_t k = getKey();
    printf("0x%x\n", k);

    int shmid = createShm(k);
    printf("shmid: %d\n", shmid);

    // 关联该共享内存
    char* start = (char*)attachShm(shmid);
    printf("attach success, address start: %p\n", start);
    sleep(5);

    // 使用
    while(true)
    {
        sleep(1);
        // 不需要读取到数组中，因为可以直接通过共享内存地址start打印出来
        printf("client say: %s\n", start);

        // 调用shmctl获取共享内存的属性
        struct shmid_ds ds;
        shmctl(shmid, IPC_STAT, &ds);
        printf("获取属性: size: %d, pid: %d, myself: %d, key: 0x%x\n",\
                ds.shm_segsz, ds.shm_cpid, getpid(), ds.shm_perm.__key);
    }

    // 去关联
    detachShm(start);
    sleep(5);

    // 一般谁创建shm，谁删除shm！
    delShm(shmid);
    return 0;
}

#include "comm.hpp"
int main()
{
    key_t k = getKey();
    printf("key: 0x%x\n", k);

    int shmid = getShm(k);
    printf("shmid: %d\n", shmid);

    // 关联该共享内存
    char* start = (char*)attachShm(shmid);
    printf("attach success, address start: %p\n", start);
    sleep(3);

    // 使用
    pid_t id = getpid();
    int cnt = 1;
    const char* str = "i am client! i am talking with you!";
    while(true)
    {
        sleep(1);
        // 不需要先加载到字符数组中，直接可以通过共享内存地址写入即可
        snprintf(start, MAX_SIZE, "%s : [pid: %d][cnt: %d]", str, id, cnt++);
    }

    // 去关联
    detachShm(start);
    sleep(3);
    return 0;
}

.PHONY : all
all : shm_client shm_server

shm_client : client.cpp
	g++ -o $@ $^ -std=c++11
shm_server : server.cpp
	g++ -o $@ $^ -std=c++11

.PHONY : clean
clean : 
	rm -f shm_client shm_server

// come from /usr/include/msg.h
struct msqid_ds
{
    struct ipc_perm msq_perm; // 对应于该消息队列的ipc_perm结构指针，就是权限
    struct msg *msg_first;    // msg结构指针（msg结构用于表示一个消息），此指针指向消息队列中的第一个消息
    struct msg *msg_last;     // msg结构指针，指向消息队列中的最后一个消息
    ulong msg_ctypes;         // 记录消息队列中当前的总字节数
    ulong msg_qnum;           // 记录消息队列中当前的总消息数
    ulong msg_qbytes;         // 记录消息队列中最大可容纳的字节数
    pid_t msg_lspid;          // 最近一个执行 msgsnd 函数的进程的 PID
    pid_t msg_lrpid;          // 最近一个执行 msgrcv 函数的进程的 PID
    time_t msg_stime;         // 最近一次执行 msgsnd 函数的时间
    time_t msg_rtime;         // 最近一次执行 msgrcv 函数的时间
    time_t msg_ctime;         // 最近一次改变该消息队列的时间
}

// come from /usr/include/bits/ipc.h
/* Data structure used to pass permission information to IPC operations. */
struct ipc_perm
{
    __key_t __key;               // IPC对象的key值，用于唯一标识该IPC对象
    __uid_t uid;                 // 拥有者ID
    __gid_t gid;                 // 拥有者组ID
    __uid_t cuid;                // 创建者ID
    __gid_t cgid;                // 创建者组ID
    unsigned short int mode;     // 读写权限
    unsigned short int __pad1;   // 填充字段，保证ipc_perm结构体的大小为32字节
    unsigned short int __seq;    // IPC对象的序列号，用于区分不同的IPC对象
    unsigned short int __pad2;   // 填充字段，保证ipc_perm结构体的大小为32字节
    unsigned long int __unused1; // 未使用的字段，保证ipc_perm结构体的大小为64字节
    unsigned long int __unused2; // 未使用的字段，保证ipc_perm结构体的大小为64字节
};

// come from /usr/src/kernels/'uname –r'/include/linux/msg.h
/* one msg_msg structure for each message */
struct msg_msg 
{
    struct list_head m_list; // 用于将消息加入到消息队列中的链表中，实现FIFO的队列访问方式。
    long m_type;             // 消息的类型，用于区分不同的消息。
    int m_ts;                // 消息大小，以字节为单位。
    struct msg_msgseg* next; // 下一个消息位置
    void *security;          // 真正消息位置
    /* the actual message follows immediately */
};

struct msgbuf
{
    long msgtype;
    char msgtext[1024];
}

int msgget(key_t key, int msgflg); // 消息队列的创建与打开
int msgsnd(int msqid, const void *msgp, size_t msgsz, int msgflg); // 向消息队列中发送消息
ssize_t msgrcv(int msqid, void *msgp, size_t msgsz, long msgtyp, int msgflg); // 从消息队列中接收消息
int msgctl(int msqid, int cmd, struct msqid_ds *buf); // 消息队列的控制

// come from /usr/include/linux/sem.h
struct semid_ds
{
    struct ipc_perm sem_perm; 			 // 对应于该信号量集的ipc_perm结构，也就是权限
    struct sem *sem_base;     			 // sem结构指针，指向信号量集中第一个信号量的sem结构
    ushort sem_nsems;         			 // 信号量集中信号量的个数
    time_t sem_otime;         			 // 最近一次调用semop函数的时间
    time_t sem_ctime;         			 // 最近一次改变该信号量集的时间
    struct sem_queue *sem_pending;       // 阻塞在该信号量集上的进程队列
 	struct sem_queue **sem_pending_last; // 指向最后一个阻塞在该信号量集上的进程的指针
 	struct sem_undo *undo;               // 用于实现撤销操作的undo队列
 	unsigned short sem_nsems;            // 当前信号量集中已经分配的信号量的数量
};

struct sem
{
    ushort semval;  // 信号量的值 
    pid_t sempid;   // 最后一次返回该信号量的进程ID
    ushort semncnt; // 等待可利用资源出现的进程数
    ushort semzcnt; // 等待全部资源可被独占的进程数
};

int semget(key_t key, int nsems, int semflg); // 信号量集的创建与打开
int semop(int semid, struct sembuf *sops, size_t nsops); // 对信号量集的操作
int semctl(int semid, int semnum, int cmd, union semun arg); // 信号量的控制

// 用于表示Linux系统中对信号量进行操作时的参数
struct sembuf
{
    short sem_num;  // 要操作的信号量在信号量集里的编号
    short sem_op;   // 进行的操作，可以为负数、零或正数，表示减少、不变或增加信号量的值
    short sem_flag; // 操作的标志，可以为IPC_NOWAIT（非阻塞）或0（阻塞）
};

// 用于在Linux系统中进行信号量操作时的参数传递
union semun
{
    int val;              // 用于设置信号量的初始值，或者用于获取信号量的当前值
    struct semid_ds *buf; // 指向semid_ds结构体的指针，用于获取或设置信号量集的属性
    ushort *array;        // 指向ushort类型数组的指针，用于获取或设置信号量集中多个信号量的值
};