Linux inter-process communication-shared memory

Shared memory is the fastest way to communicate between processes running on the same machine, because data does not need to be copied between different processes. A shared memory area is usually created by a process, and other processes read and write this memory area. Shared Memory is often used in conjunction with other communication mechanisms, such as semaphores, to achieve synchronization and mutual exclusion between processes.
The first function to use is shmget, which obtains a shared storage identifier.

# I nclude <sys/types. h>
# I nclude <sys/IPC. h>
# I nclude <sys/SHM. h>
Int shmget (key_t key, int size, int flag );

This function is similar to the familiar malloc function. The system allocates the size of memory as the shared memory according to the request. In the Linux kernel, each IPC structure has a non-negative integer identifier, So that you only need to reference the identifier when sending a message to a message queue. This identifier is obtained by the key word of the IPC structure in the kernel. This keyword is the key of the first function above. The data type key_t is defined in the header file SYS/types. H. It is a long integer data. In our subsequent chapters, we will also encounter this keyword.

After the shared memory is created, other processes can call shmat () to connect it to their own address space.

Void * shmat (INT shmid, void * ADDR, int flag );

Shmid is the shared storage identifier returned by the shmget function. The ADDR and flag parameters determine how to determine the connection address. the return value of the function is the actual address connected to the Data Segment of the process, A process can perform read/write operations on the process.

When using shared storage to implement inter-process communication, note the synchronization of data access. Make sure that the desired data has been written when a process reads data. Generally, semaphores are used to synchronize access to shared storage data. In addition, you can use the shmctl function to set some flags of shared storage memory, such as shm_lock and shm_unlock.

The shared memory mechanism allows two unrelated processes to read and modify the same memory segment for data sharing. Main Function Definition:

# Include <sys/SHM. h>

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

Int shmctl (INT shm_id, int cmd, struct shmid_ds * BUF );

Int shmdt (const void * shm_addr );

Int shmget (key_t key, size_t size, int shmflag );

C code

1. /* Server. C: write people to the shared memory */
2. # Include <stdio. h>
3. # Include <sys/types. h>
4. # Include <sys/IPC. h>
5. # Include <sys/SEM. h>
7. Int main ()
8. {
9. Struct people {
10. Char name [10];
11. Int age;
12. };
14. Int Semid;
15. Int shmid;
16. Key_t semkey;
17. Key_t shmkey;
18. Semkey = ftok ("server. c", 0 );
19. Shmkey = ftok ("client. c", 0 );
21. /* Create an IPC for shared memory and semaphores */
22. Semid = semget (semkey, 1,0666 | ipc_creat );
23. If (Semid =-1)
24. Printf ("creat SEM is fail \ n ");
25. Shmid = shmget (shmkey, | ipc_creat );
26. If (shmid =-1)
27. Printf ("creat SHM is fail \ n ");
29. /* Set the initial semaphore value, that is, the number of resources */
30. Union semun {
31. Int val;
32. Struct semid_ds * Buf;
33. Ushort * array;
34. } Sem_u;
36. Sem_u.val = 1;
37. Semctl (Semid, 0, setval, sem_u );
39. /* Map the shared memory to the address of the current process, and then directly perform the ADDR operation on the address in the process */
41. Struct people * ADDR;
42. ADDR = (struct people *) shmat (shmid, 0, 0 );
43. If (ADDR = (struct people *)-1)
44. Printf ("SHM shmat is fail \ n ");
46. /* P operations on semaphores */
47. Void P ()
48. {
49. Struct sembuf sem_p;
50. Sem_p.sem_num = 0;
51. Sem_p.sem_op =-1;
52. If (semop (Semid, & sem_p, 1) =-1)
53. Printf ("P operation is fail \ n ");
54. }
56. /* Semaphore v operation */
57. Void V ()
58. {
59. Struct sembuf sem_v;
60. Sem_v.sem_num = 0;
61. Sem_v.sem_op = 1;
62. If (semop (Semid, & sem_v, 1) =-1)
63. Printf ("V operation is fail \ n ");
64. }
66. /* Write data to the shared memory */
67. P ();
68. Strcpy (* ADDR). Name, "Xiaoming ");
69. /* Note: ① A value can only be assigned to the address pointed to by the pointer. You cannot define a struct people people_1; ADDR = & people_1; Because ADDR is at ADDR = (struct people *) shmat (shmid,);, the system has automatically assigned an address, this address is associated with the shared memory, so you cannot change the pointer to this address, otherwise, he will not point to the shared memory and cannot complete the communication.
70. Note: ② assign values to character arrays. Just now, it's so cool .. */
71. (* ADDR). Age = 10;
72. V ();
74. /* Disconnect the shared memory from the current process */
75. If (shmdt (ADDR) =-1)
76. Printf ("shmdt is fail \ n ");
78. }

C code

1. /* Client. C: Read people from the shared memory */
2. # Include <stdio. h>
3. # Include <sys/types. h>
4. # Include <sys/IPC. h>
5. # Include <sys/SEM. h>
7. Int main ()
8. {
9. Int Semid;
10. Int shmid;
11. Key_t semkey;
12. Key_t shmkey;
13. Semkey = ftok ("server. c", 0 );
14. Shmkey = ftok ("client. c", 0 );
16. Struct people {
17. Char name [10];
18. Int age;
19. };
21. /* Read the IPC of the shared memory and semaphore */
22. Semid = semget (semkey, 0, 0666 );
23. If (Semid =-1)
24. Printf ("creat SEM is fail \ n ");
25. Shmid = shmget (shmkey, 0, 0666 );
26. If (shmid =-1)
27. Printf ("creat SHM is fail \ n ");
29. /* Map the shared memory to the address of the current process, and then directly perform the ADDR operation on the address in the process */
30. Struct people * ADDR;
31. ADDR = (struct people *) shmat (shmid, 0, 0 );
32. If (ADDR = (struct people *)-1)
33. Printf ("SHM shmat is fail \ n ");
35. /* P operations on semaphores */
36. Void P ()
37. {
38. Struct sembuf sem_p;
39. Sem_p.sem_num = 0;
40. Sem_p.sem_op =-1;
41. If (semop (Semid, & sem_p, 1) =-1)
42. Printf ("P operation is fail \ n ");
43. }
45. /* Semaphore v operation */
46. Void V ()
47. {
48. Struct sembuf sem_v;
49. Sem_v.sem_num = 0;
50. Sem_v.sem_op = 1;
51. If (semop (Semid, & sem_v, 1) =-1)
52. Printf ("V operation is fail \ n ");
53. }
55. /* Read data from the shared memory */
56. P ();
57. Printf ("Name: % s \ n", ADDR-> name );
58. Printf ("Age: % d \ n", ADDR-> age );
59. V ();
61. /* Disconnect the shared memory from the current process */
62. If (shmdt (ADDR) =-1)
63. Printf ("shmdt is fail \ n ");
65. /* The IPC must be deleted. Otherwise it will remain in the system */
66. If (semctl (Semid, 0, ipc_rmid, 0) =-1)
67. Printf ("semctl delete error \ n ");
68. If (shmctl (shmid, ipc_rmid, null) =-1)
69. Printf ("shmctl delete error \ n ");
70. }