Linux inter-process communication - Shared Memory

A shared memory Introduction

Shared memory can be understood literally, put out a logical shared memory, so that different processes to access it, modify it. For sharing memory is shared and passed between the two processes are running the data is very efficient manner. Shared between different processes of memory is usually scheduled for the same period of physical memory. A process can be connected to the same period of shared memory address space of their own, all processes can access shared memory address, as if they were a memory allocation in C language functions malloc same. And if a process writes data to the shared memory, the changes made will immediately affect any other process can access the same period of shared memory.

But one thing particular attention: shared memory does not provide a synchronization mechanism. That is, before the end of the first process writes to the shared memory, there is no automatic mechanism prevents a second process began reading it. So we often need to use other mechanisms to synchronize access to shared memory, such as semaphores.

Two shared memory usage

◆ create a shared memory

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

◇ a first parameter associated with a return key shared memory identifier (nonnegative integer) named shared memory segment, shmget function succeeds, the shared memory for a subsequent function. Call failed to return -1.

☆ other processes can return value of the function to access the same shared memory, a resource, a program which represents the process may be used to access all shared memory are indirect, the first program by calling shmget function and provide a key, then generate a corresponding shared memory identifier (shmget function return value), direct use only shmget semaphore function keys, a function of the amount of all other signals used by the semaphore identifier returned by the function semget system.

◇ The second parameter, size in bytes specified shared memory capacity required.

◇ The third parameter, shmflg permissions sign, its role and function in the same mode parameters open, if it is to identify the key in the shared memory does not exist, create it, you can do or operation IPC_CREAT. Shared memory read and write permissions to the file permission flags, like, for example, 0644, which represents a process allows the creation of shared memory owned by the creator of process memory to the shared memory read and write data, while others created the process can only read the shared memory.

◆ Start the shared memory access

void *shmat(int shm_id, const void *shm_addr, int shmflg);

When finished ◇ first create a shared memory, it can not be accessed by any process, the role of shmat function is used to start access to the shared memory and shared memory connected to the address space of the current process.

◇ The first parameter, shm_id shmget is returned by the function of identifying the shared memory.

◇ The second parameter, shm_addr specify shared memory connected to the address location of the current process, usually empty, to tell the system to select the shared memory address.

◇ The third parameter, shm_flg is a group of bits, typically 0.

Returns a pointer to the first byte of the shared memory pointer ◇ call is successful, returns -1 if the call fails.

◆ shared memory separate from the current process

int shmdt(const void *shmaddr);

◇ This function is used shared memory separate from the current process. Note that shared memory is not isolated to remove it, just that the current process of shared memory is no longer available.

◇ parameter is shmaddr shmat address pointer returned by the function, returns 0 when the call is successful, -1 on failure.

◆ shared memory control

int shmctl(int shm_id, int command, struct shmid_ds *buf);

◇ The first parameter, shm_id shmget function returns a shared memory identifier.

◇ The second parameter, command operation is to be taken, it may take the following three values:

IPC_STAT: shmid_ds the data structure associated with the current set value of the shared memory, i.e. shmid_ds coverage value with the current value of the associated shared memory.

IPC_SET: If the process has sufficient authority to put the shared memory associated with the current value is set to a value structure given shmid_ds

IPC_RMID: Delete the shared memory segment

◇ The third parameter, buf structure is a pointer to the shared memory access patterns and structures.

struct shmid_ds
{
uid_t shm_perm.uid;
uid_t shm_perm.gid;
mode_t shm_perm.mode;
｝

Three examples

shmdata.h source:

#ifndef _SHMDATA_H_HEADER
#define _SHMDATA_H_HEADER
#define TEXT_SZ 2048
struct shared_use_st
{
int written;/* 作为一个标志，非0：表示可读，0表示可写 */
char text[TEXT_SZ];/* 记录写入和读取的文本 */
};
#endif

shmread.c source

#include<unistd.h>
#include<stdlib.h>
#include<stdio.h>
#include<sys/shm.h>
#include"shmdata.h"

#define MEM_KEY (1234)
int main()
{
int running =1; //程序是否继续运行的标志
void*shm = NULL; //分配的共享内存的原始首地址
struct shared_use_st *shared;//指向shm
int shmid; //共享内存标识符
//创建共享内存
shmid = shmget((key_t)MEM_KEY,sizeof(struct shared_use_st),0666|IPC_CREAT);
if(shmid ==-1)
{
fprintf(stderr,"shmget failed\n");
exit(EXIT_FAILURE);
}
//将共享内存连接到当前进程的地址空间
shm = shmat(shmid,0,0);
if(shm ==(void*)-1)
{
fprintf(stderr,"shmat failed\n");
exit(EXIT_FAILURE);
}
printf("\nMemory attached at %X\n",(int)shm);
//设置共享内存
shared =(struct shared_use_st*)shm;
shared->written =0;
while(running)//读取共享内存中的数据
{
//没有进程向共享内存定数据有数据可读取
if(shared->written !=0)
{
printf("You wrote: %s", shared->text);
sleep(rand()%3);
//读取完数据，设置written使共享内存段可写
shared->written =0;
//输入了end，退出循环（程序）
if(strncmp(shared->text,"end",3)==0)
running =0;
}
else//有其他进程在写数据，不能读取数据
sleep(1);
}
//把共享内存从当前进程中分离
if(shmdt(shm)==-1)
{
fprintf(stderr,"shmdt failed\n");
exit(EXIT_FAILURE);
}
//删除共享内存
if(shmctl(shmid, IPC_RMID,0)==-1)
{
fprintf(stderr,"shmctl(IPC_RMID) failed\n");
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}

shmwrite.c source

#include<unistd.h>
#include<stdlib.h>
#include<stdio.h>
#include<string.h>
#include<sys/shm.h>
#include"shmdata.h"
#define MEM_KEY (1234)
int main()
{
int running =1;
void*shm = NULL;
struct shared_use_st *shared = NULL;
char buffer[BUFSIZ +1];//用于保存输入的文本
int shmid;
//创建共享内存
shmid = shmget((key_t)MEM_KEY,sizeof(struct shared_use_st),0666|IPC_CREAT);
if(shmid ==-1)
{
fprintf(stderr,"shmget failed\n");
exit(EXIT_FAILURE);
}
//将共享内存连接到当前进程的地址空间
shm = shmat(shmid,(void*)0,0);
if(shm ==(void*)-1)
{
fprintf(stderr,"shmat failed\n");
exit(EXIT_FAILURE);
}
printf("Memory attached at %X\n",(int)shm);
//设置共享内存
shared =(struct shared_use_st*)shm;
while(running)//向共享内存中写数据
{
//数据还没有被读取，则等待数据被读取,不能向共享内存中写入文本
while(shared->written ==1)
{
sleep(1);
printf("Waiting...\n");
}
//向共享内存中写入数据
printf("Enter some text: ");
fgets(buffer, BUFSIZ, stdin);
strncpy(shared->text, buffer, TEXT_SZ);
//写完数据，设置written使共享内存段可读
shared->written =1;
//输入了end，退出循环（程序）
if(strncmp(buffer,"end",3)==0)
running =0;
}
//把共享内存从当前进程中分离
if(shmdt(shm)==-1)
{
fprintf(stderr,"shmdt failed\n");
exit(EXIT_FAILURE);
}
sleep(2);
exit(EXIT_SUCCESS);
}

◆ code analysis:

◇ program shmread create a shared memory, and then connect it to their own address space. Use a structure struct_use_st at the beginning of shared memory. The structure has a flag written, when there are other processes in the shared memory to write data to it, written in the shared memory is set to 0, the program waits. When it is not 0, the process indicates no shared memory to write data, the program reads data from the shared memory and output and then reset the settings written in the shared memory to 0, i.e. allowed to be written to process shmwrite data.

◇ program shmwrite get shared memory and connect to its own address space. Check the shared memory written, it is 0, if not, represent the data in shared memory has not been finished, then wait for the other to complete the process of reading and prompts the user to wait. If the shared memory is written to zero, indicating that no other processes to share memory read, the user is prompted to enter text, and set up again shared memory written to 1, indicating the completion of writing, other processes can be read on the shared memory.

◆ security discussion about the previous example

This program is unsafe, when there are multiple programs simultaneously read and write data to the shared memory, problems will arise. You might think, can be written to change the use, for example, only when written to 0 process can write data to the shared memory, and when a process is not only written to be read 0:00, the same time the written are incremented, decremented after the read operation. It's a bit like a read-write lock file lock function. First glance, it seems to work. But this is not an atomic operation, so this practice is not in line. Imagine when written is 0, if there are two processes simultaneously access the shared memory, they will find written as a 0, so both processes which are written, apparently not. When 1 is written, there are two processes simultaneously shared memory such as a read operation is more, when the two processes are complete is read, written becomes -1.

To get the program carried out safely, there should be a process whereby binary synchronous, into the operation to ensure that the critical region is an atomic operation. For example, the amount of signal earlier spoken to the synchronization process. Since all atomic semaphore operation.

3 advantages and disadvantages of using shared memory

◇ advantage: we can see the use of shared memory communication really is very convenient between processes, but also simple interface functions, data sharing also allows data transfer between processes do not, but direct access to memory, also accelerated program s efficiency. It also is not as requested anonymity pipeline process communication have some father-son relationship.

◇ Disadvantages: shared memory does not provide a mechanism to synchronize, which makes us in the use of shared memory for inter-process communication, often to synchronize work between processes by means of other means.

Four better example

1、server.c

/*server.c:向共享内存中写入People*/
#include<stdio.h>
#include<sys/types.h>
#include<sys/ipc.h>
#include<sys/sem.h>
#include<string.h>
#include"credis.h"
int semid;
int shmid;
/*信号量的P操作*/
void p()
{
struct sembuf sem_p;
sem_p.sem_num=0;/*设置哪个信号量*/
sem_p.sem_op=-1;/*定义操作*/
if(semop(semid,&sem_p,1)==-1)
printf("p operation is fail\n");
/*semop函数自动执行信号量集合上的操作数组。
　　 int semop(int semid, struct sembuf semoparray[], size_t nops);
　　 semoparray是一个指针，它指向一个信号量操作数组。nops规定该数组中操作的数量。*/
}
/*信号量的V操作*/
void v()
{
struct sembuf sem_v;
sem_v.sem_num=0;
sem_v.sem_op=1;
if(semop(semid,&sem_v,1)==-1)
printf("v operation is fail\n");
}
int main()
{
structPeople{
char name[10];
int age;
};
key_t semkey;
key_t shmkey;
semkey=ftok("../test/VenusDB.cbp",0);//用来产生唯一的标志符，便于区分信号量及共享内存
shmkey=ftok("../test/main.c",0);
/*创建信号量的XSI IPC*/
semid=semget(semkey,1,0666|IPC_CREAT);//参数nsems,此时为中间值1，指定信号灯集包含信号灯的数目
//0666|IPC_CREAT用来表示对信号灯的读写权限
/*
从左向右:
第一位:0表示这是一个8进制数
第二位:当前用户的经权限:6=110(二进制),每一位分别对就可读,可写,可执行,6说明当前用户可读可写不可执行
第三位:group组用户,6的意义同上
第四位:其它用户,每一位的意义同上,0表示不可读不可写也不可执行
*/
if(semid==-1)
printf("creat sem is fail\n");
//创建共享内存
shmid=shmget(shmkey,1024,0666|IPC_CREAT);//对共享内存
if(shmid==-1)
printf("creat shm is fail\n");
/*设置信号量的初始值，就是资源个数*/
union semun{
int val;
struct semid_ds *buf;
unsignedshort*array;
}sem_u;
sem_u.val=1;/*设置变量值*/
semctl(semid,0,SETVAL,sem_u);//初始化信号量，设置第0个信号量，p()操作为非阻塞的
/*将共享内存映射到当前进程的地址中，之后直接对进程中的地址addr操作就是对共享内存操作*/
structPeople*addr;
addr=(structPeople*)shmat(shmid,0,0);//将共享内存映射到调用此函数的内存段
if(addr==(structPeople*)-1)
printf("shm shmat is fail\n");
/*向共享内存写入数据*/
p();
strcpy((*addr).name,"xiaoming");
/*注意：①此处只能给指针指向的地址直接赋值，不能在定义一个 struct People people_1;addr=&people_1;因为addr在addr=(struct People*)shmat(shmid,0,0);时,已经由系统自动分配了一个地址，这个地址与共享内存相关联，所以不能改变这个指针的指向，否则他将不指向共享内存，无法完成通信了。
注意：②给字符数组赋值的方法。刚才太虎了。。*/
(*addr).age=10;
v();
/*将共享内存与当前进程断开*/
if(shmdt(addr)==-1)
printf("shmdt is fail\n");
}