POSIX shared memory usage and code examples for Linux interprocess communication

POSIX shared memory has two ways of sharing memory between non-affinity processes:
1). Use a memory-mapped file, opened by the Open function, and the MMAP function maps the returned file descriptor to a file in the current process space.

2). Using the Shared Memory Area object, a Posix IPC name is opened by Shm_open. The returned descriptor is then mapped by mmap to the address space of the current process.

POSIX shared memory-related function header files and prototypes:
#include <sys/mman.h>
int Shm_open (const char *name, int oflag, mode_t mode);
Function: Open a shared memory object, get the descriptor
Return value: Successfully returned non-negative descriptor, error returned-1
Parameters: Name is the POSIX IPC name, the Oflag parameter is o_rdonly or O_RDWR, and it can be o_creat,o_excl,o_trunc when the specified O_RDWR and o_trunc are truncated to length 0 when the shared memory object already exists; Mode is the specified permission bit, which is used when o_creat is specified, and must be set to 0 without o_creat.


int Shm_unlink (const char *name);
Function: Deletes the name of a shared memory area object.
Return value: Successfully returned 0, error returned-1.


void *mmap (void *addr, size_t len, int prot, int flags, int fd, off_t offset);
Function: Maps a shared Memory object opened by Shm_open to the process address space.
Return value: Returns the start address of the mapping area if successful, and returns an error map_failed.
Parameters: addr Specifies the starting address of the process space to be mapped to, which is generally set to null pointer nulls, which is automatically assigned, and Len is the number of bytes mapped to the address space, starting with the first offset byte of the file header, and general offset set to 0;prot can be prot_read ( readable), prot_write (writable), prot_exec (executable), Prot_none (inaccessible), flags can be map_shared,map_private,map_fixed, where map_shared or MAP_ Private must specify one, map_fixed is not generally specified, and addr is a null pointer, which indicates that the address is automatically assigned to facilitate portability.

int Munmap (void *addr, size_t len);
Function: Delete the mapping relationship of the process address space
Return value: Successfully returned 0, error returned-1


int Msync (void *addr, size_t len, int flags);
Function: The content of the file is consistent with the content in the memory map area.
Return value: Successfully returned 0, error returned-1.
Parameters: Flags have 3 types, Ms_async (asynchronous Write), Ms_sync (synchronous write), ms_invalidate (invalidates cached data).

code example SHM_TEST.C, parent-child process operation shared memory area variable count plus 1, and signal volume SEM do synchronization

2. #include <stdlib.h>
4. #include <stdio.h>
6. #include <sys/mman.h>
8. #include <semaphore.h>
10. #include <fcntl.h>
14. #define MYFILE "./shm_test_file"
18. #define SEM_NAME "/mysem"
22. #define MYSHM "/myshm"
26. #define TIMES 5
30. #define USE_SHM_OPEN 0
34. #define Sem_in_sharememory 0
38. #if sem_in_sharememory
40. struct shared
42. {
44. Sem_t Mutex;
46. int count;
48. }shared;
50. #endif
54. int main (void)
56. {
58. int fd,i,zero=0;
62. #if sem_in_sharememory
64. struct shared *ptr;
66. #if Use_shm_open
68. Fd=shm_open (myshm,o_rdwr| o_creat,0666);
70. #else
72. Fd=open (myfile,o_rdwr| o_creat,0666);
74. #endif
76. Write (fd,&shared,sizeof (struct shared));
78. Ptr=mmap (null,sizeof (struct shared), prot_read| prot_write,map_shared,fd,0);
80. Sem_init (&ptr->mutex,1,1);
82. #else
84. int *ptr;
86. Sem_t *mutex;
88. #if Use_shm_open
90. Fd=shm_open (myshm,o_rdwr| o_creat,0666);
92. #else
94. Fd=open (myfile,o_rdwr| o_creat,0666);
96. #endif
98. Write (fd,&zero,sizeof (int));
100. Ptr=mmap (null,sizeof (int), prot_read| prot_write,map_shared,fd,0);
102. Mutex=sem_open (sem_name,o_creat| o_excl,0666,1);
104. Sem_unlink (Sem_name);
106. #endif
112. Close (FD);
114. Setbuf (stdout,null);//stdout is unbuffered
116. if (0==fork ())
118. {
120. for (i=0;i<times;i++)
122. {
124. #if sem_in_sharememory
126. Sem_wait (&ptr->mutex);
128. printf ("Child:%d\n", ptr->count++);
130. Sem_post (&ptr->mutex);
132. #else
134. Sem_wait (mutex);
136. printf ("Child:%d\n", (*ptr) + +);
138. Sem_post (mutex);
140. #endif
142. }
144. Exit (0);
146. }
150. for (i=0;i<times;i++)
152. {
154. #if sem_in_sharememory
156. Sem_wait (&ptr->mutex);
158. printf ("Parent:%d\n", ptr->count++);
160. Sem_post (&ptr->mutex);
162. #else
164. Sem_wait (mutex);
166. printf ("Parent:%d\n", (*ptr) + +);
168. Sem_post (mutex);
170. #endif
172. }
174. Exit (0);
176. }

Copy Code

Operation Result:

./a.out
parent:0
Parent:1
Parent:2
Parent:3
Parent:4
Child:5
Child:6
Child:7
Child:8
Child:9


Using a shared memory object mapping by setting "#define Use_shm_open 1", "#define USE_SHM_OPEN 0" uses different file system mappings.
Set "#define Sem_in_sharememory 1" so that the semaphore SEM is also placed in the shared memory area, "#define Sem_in_sharememory 0" so that the semaphore SEM is not in the shared memory area

POSIX shared memory usage and code examples for Linux interprocess communication