About Linux IPC (v): System V Shared memory

System V shared memory is similar to POSIX shared memory, and System V shared memory is called the Shmget function and the Shamat function.
The Shmget function creates a shared memory area, or accesses an existing memory area, similar to the system calling the open and POSIX shared memory shm_open functions of shared memory. The Shmget function prototype is:

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

Key: Function Ftok return value, or ipc_private, when using ipc_private, preferably two process space is shared, such as parent-child process, otherwise the current process generated shared memory identifier (return value), in another process is not easy to obtain;
The Ftok function prototype is: key_t ftok (const char *pathname, int proj_id); The parameter pathname is the file absolute pathname, and proj_id is an integer identifier that converts an existing pathname and an integer identifier into a key_t value (the return value), called the IPC key.
Size: Creates a new shared memory size, which is a parameter that is not 0 when a new piece of shared memory is created. If you are reading a piece of shared memory, the value can be 0.
SHMFLG: Combination of Read and write permission values. Ipc_creat (Create new shared memory) or ipc_creat| IPC_EXCL (when the shared memory that will be created already exists, the attempt to create will return eexist). In fact, the combination of ipc_creat and IPC_EXCL is similar to the o_creat and o_excl combinations of the open function.
The function returns the identity of the shared memory area. The SHMXXX function operation shared memory will use this function to return a value. This function is similar to the POSIX shared memory Shm_open function function.


When Shmget creates or opens a shared memory area, it is necessary to use the function Shmat to connect the slice of shared memory to the current process space, and when a process has finished using shared memory, use the function SHMDT to disconnect and share the memory link.

1. #include <sys/types.h>
2. #include <sys/shm.h>
4. void *shmat (int shmid, const void *shmaddr, int shmflg);
6. int SHMDT (const void *shmaddr);

Shmid: Is the shared memory identifier returned by the function Shmget function.
SHMADDR: Connect to the address of the calling process address space, if the parameter is NULL, the system chooses an appropriate address, if SHMADDR is not null and SHMFLG specifies the option shm_rnd, the phase The shared memory should be linked to a Shmlab constant that is rounded down by the address specified by the SHMADDR parameter. If SHMADDR is not empty and SHMFLG does not specify SHM_RND, the shared memory address is linked to the address specified by the SHMADDR parameter.
SHMFLG: You can specify SHM_RND and shm_rdonly (read-only), and if you specify the SHM_RDONLY option, the calling process has read access to that slice of shared memory, otherwise the process will have read and write access to that slice of memory.


The function shmdt does not delete the specified shared memory, it just disconnects from the slice's shared memory. When a process terminates, the shared memory linked by the process is automatically disconnected.
The Shmat function successfully returned the current process shared memory address, failed to return (void *) -1;SHMDT successfully returned 0, failed to return 1;
Removing shared memory requires the function Shmctl call the Ipc_rmid command to complete.

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

Shmid: Shared memory area identification;
CMD: Operation command for Shared memory, command Ipc_rmid destroy (destroy) a piece of shared memory, destroy all shmat,shmdt,shmctl to the memory operation will be invalidated, destroy the shared memory to wait until the shared memory reference count becomes 0; ipc_ The SET command sets the SHMID_DS structure member, IPC_STAT returns the current shared memory structure, and the remaining commands view the man manual.
BUF: For pointing to shmid_ds data structure;


Example of system V shared memory:
Server process:

2. int Sln_shm_get (char *shm_file, void **mem, int mem_len)
4. {
6. int shmid;
8. key_t key;
14. if (NULL = = fopen (shm_file, "w+")) {
16. printf ("fopen:%s\n", Strerror (errno));
18. return-1;
20. }
24. Key = Ftok (shm_file, 0);
26. if (Key < 0) {
28. printf ("Ftok:%s\n", Strerror (errno));
30. return-1;
32. }
36. Shmid = Shmget (key, Mem_len, ipc_creat);
38. if (Shmid < 0) {
40. printf ("Shmget:%s\n", Strerror (errno));
42. return-1;
44. }
48. *mem = (void *) Shmat (shmid, NULL, 0);
50. if (void *)-1 = = *mem) {
52. printf ("Shmat:%s\n", Strerror (errno));
54. return-1;
56. }
60. return shmid;
62. }
66. int main (int argc, const Char *argv[])
68. {
70. char *shm_file = NULL;
72. char *shm_buf = NULL;
74. int shmid;
80. Shmid = Sln_shm_get (Shm_ipc_filename, (void * *) &shm_buf, Shm_ipc_max_len);
82. if (Shmid < 0) {
84. return-1;
86. }
90. snprintf (Shm_buf, Shm_ipc_max_len, "Hello system V Shaare memory ipc! This was write by server. ");
94. Sleep (15);
98. printf ("System V server Delete share memory segment!\n");
100. //SHMDT (SHM_BUF);
104. Shmctl (Shmid, Ipc_rmid, NULL); //server after 15 seconds destroy the slice to share memory, at which point the client process will not get the contents of the shared memory
108. return 0;
110. }

Client process:

2. int Sln_shm_get (char *shm_file, void **mem, int mem_len)
4. {
6. int shmid;
8. key_t key;
14. Key = Ftok (shm_file, 0);
16. if (Key < 0) {
18. printf ("Ftok:%s\n", Strerror (errno));
20. return-1;
22. }
26. Shmid = Shmget (key, Mem_len, ipc_creat);
28. if (Shmid < 0) {
30. printf ("Shmget:%s\n", Strerror (errno));
32. return-1;
34. }
38. *mem = (void *) Shmat (shmid, NULL, 0);
40. if (void *)-1 = = *mem) {
42. printf ("Shmat:%s\n", Strerror (errno));
44. return-1;
46. }
50. return shmid;
52. }
58. int main (int argc, const Char *argv[])
60. {
62. char *shm_buf = NULL;
64. int i;
68. if (Sln_shm_get (Shm_ipc_filename, (void * *) &shm_buf, Shm_ipc_max_len) < 0) {
70. return-1;
72. }
78. printf ("IPC client get:%s\n", shm_buf);
84. return 0;
86. }

At run time, the server process is executed first, and the current system shared memory can be viewed using command IPCS:

1. # IPCS
2. ------Message Queues--------
3. Key Msqid owner perms used-bytes messages
6. ------Shared Memory Segments--------
7. Key shmid owner perms bytes nattch Status
8. 0x0010a797 131072 Root 0 4096 1
11. ------Semaphore Arrays--------
12. Key Semid owner Perms Nsems

You can see that there is a shared memory area where key is: 0x0010a797, and the shared memory ID is: 131072

1. #./client
2. IPC Client Get:hello System V Shaare memory ipc!   This is the write by server.
3. #

After the server process destroy shared memory, repeat the steps above,

2. # IPCS
8. ------Message Queues--------
10. Key Msqid owner perms used-bytes messages
16. ------Shared Memory Segments--------
18. Key shmid owner perms bytes nattch Status
24. ------Semaphore Arrays--------
26. Key Semid owner Perms Nsems
28. The shared memory is no longer present, but the file still exists.
34. #./client
36. IPC Client Get:
38. #

At this point the client cannot get the previously shared memory content.
In addition, the IPCRM command can delete the specified shared memory area on the command line.
By reading the file/proc/sys/kernel/shmmax you can get the maximum amount of shared memory supported by the system.

1. # Cat/proc/sys/kernel/shmmax
2. 33554432
3. #

Can see my current system support maximum shared memory value is: 32M.


The example above can see that System V shared memory is similar to POSIX shared memory, but the size of the POSIX shared memory can be changed at any time by Ftruncate, while the shared memory size of System V is determined at shmget.
Similarly, System V shared memory needs to be synchronized between multiple processes most of the time, and System V can be implemented with its own semaphore, and details will be explained later in the relevant column.
Download the source code in this section:

http://download.csdn.net/detail/gentleliu/8140887

• Related articles recommended:
• About Linux IPC (i): socket-based interprocess communication (I.)
• About Linux IPC (ii): socket-based interprocess communication (bottom)
• About Linux IPC (iii): MMAP system calls shared memory
• This article is from: Hobby Technology Network
• This article link: http://www.ahlinux.com/c/9590.html

About Linux IPC (v): System V Shared memory