[Linux] Process (vii)--Process communication

Inter-process communication
One, pipe,
Limitations of Pipelines:
(1) Half-duplex, data can only flow in one Direction
(2) Pipelines are generally used only between processes that have a common ancestor, typically a pipeline is created by a process, and then the process calls the fork () function, which can then be used by the parent-child process
Pipeline creation:

[CPP]View Plaincopy

1. #include <unistd.h>
2. int pipe (int fileds[2]); //filedes[0] Open for reading, filedes[1] open for writing

Writing data to a pipeline that is not associated with a read process produces sigpipe, and the kernel's default action for Sigpipe is to exit the process, which is usually not what we expect to see, so we need to overload this signal processing method, signal (sigpipe,sig_ign);


Second, FIFO
FIFO is called a named pipe, unlike a pipe, a process that is not related to a FIFO can also exchange data
The FIFO is created in the following way

[CPP]View Plaincopy

1. int Mkfifo (const char*pathname,mode_t mode);

After the FIFO is created, the general operation function of the file can be used for it, open close read Write, etc.
FIFO is used by multiple processes for write is common, so the synchronization between processes should be considered, and the data written by multiple write processes will not be interspersed. A: pipe_buf Specifies the size of the pipe buffer in the kernel, and the size of all write processes must be less than the size of pipe_buf
FIFO can be used for communication between client process and service process, how to ensure synchronization?
A: The service process creates a well-known FIFO to receive requests from the client process, then creates a response message for each client process to send a service process to the client process, based on the customer process ID, and the question is how the service process knows that the client process has exited?
The drawback of FIFO is that random access is not supported because both pipe and FIFO are first-in, first-out features


Three, Message Queuing
To view the Linux system shared memory and Message Queuing scenarios:

IPCs [-m|-q|-s]
-m outputs information about shared memory (GKFX)
-Q Output Information about information queue (message queue)
IPCRM command

Shared memory used to manually de-use Linux ~


Four, shared memory
The following shared memory is mostly from the following URLs click the Open link
Shared memory is suitable for larger datasets because it uses memory, supports fast random access, and is the fastest form of IPC shared memory is not partitioned in memory owned by a process; the memory of the process is always private.
Shm_open (): Creates a shared memory segment or connects to an existing named memory segment. This system call returns a file descriptor.
Shm_unlink (): Deletes a shared memory segment based on the file descriptor (Shm_open () returned). In fact, this memory segment is accessed until
It is deleted when all of its processes are exited, similar to deleting files in UNIX. However, after calling Shm_unlink () (usually called by the process that originally created the shared memory segment), the memory segment cannot be accessed by other processes.
Mmap (): Maps the shared memory segment to the memory of the process. This system call requires the file descriptor returned by Shm_open (), which returns a pointer to memory. (In some cases, you can also map the file descriptor of a generic file or another device to memory.) The implementation of Mmap is also based on the above principle, when using Mmap to map a file (or part of a file) to the address space of the process, and does not load the file data, but only in the process of the virtual address space to divide a block, marking the area for mapping to the file data region, The operation of the mmap is complete.
void* mmap (void * addr, size_t len, int prot, int flags, int fd, off_t offset)
Munmap (): The effect is opposite to mmap ().
Msync (): Used to synchronize shared memory segments with the file system-this technique is useful when mapping files to memory.
Steps to use shared memory:
The process of using shared memory is to create a memory segment with Shm_open (), set its size with write () or ftruncate (), map it to process memory with mmap (), and perform the actions required by other actors. When it is finished, the original process calls Munmap () and Shm_unlink (), and then exits.

Sample Program

[CPP]View Plaincopy

2. #include <stdio.h>
4. #include <string.h>
6. #include <stdlib.h>
8. #include <unistd.h>
10. #include <sys/file.h>
12. #include <sys/mman.h>
14. #include <sys/wait.h>
16. void Error_and_die (const char *msg) {
18. Perror (msg);
20. Exit (Exit_failure);
22. }
26. int main (int argc, char *argv[]) {
28. int R;
32. const Char *memname = "Sample";
34. Const size_t region_size = sysconf (_sc_page_size);
38. int fd = Shm_open (MemName, O_creat | O_trunc |  O_rdwr, 0666);
40. if (fd = =-1)
42. Error_and_die ("Shm_open");
46. r = Ftruncate (FD, region_size);
48. if (r! = 0)
50. Error_and_die ("ftruncate");
54. void *ptr = mmap (0, region_size, Prot_read |  Prot_write, map_shared, FD, 0);
56. if (ptr = = map_failed)
58. Error_and_die ("mmap");
60. Close (FD);
64. pid_t pid = fork ();
68. if (pid = = 0) {
70. U_long *d = (U_long *) ptr;
72. *d = 0xdbeebee;
74. Exit (0);
76. }
78. else {
80. int status;
82. Waitpid (PID, &status, 0);
84. printf ("child wrote% #lx \ n", * (U_long *) ptr);
86. }
88. r = Munmap (PTR, region_size);
90. if (r! = 0)
92. Error_and_die ("Munmap");
94. R = Shm_unlink (MemName);
96. if (r! = 0)
98. Error_and_die ("Shm_unlink");
100. return 0;
102. }

Here is another example program

Click to open link

[CPP]View Plaincopy

2. /*-------------map_normalfile1.c-----------*/
4. #include <sys/mman.h>
6. #include <sys/types.h>
8. #include <fcntl.h>
10. #include <unistd.h>
12. typedef struct{
14. Char name[4];
16. int age;
18. }people;
20. Main (int argc, char** argv) //Map a normal file as shared mem:
22. {
24. int fd,i;
26. People *p_map;
28. Char temp;
32. Fd=open (argv[1],o_creat| o_rdwr| o_trunc,00777);
34. Lseek (FD,sizeof (people) *5-1,seek_set);
36. Write (FD,"", 1);
40. P_map = (people*) mmap (NULL,sizeof (people) *10,prot_read| Prot_write,
42. map_shared,fd,0);
44. Close (FD);
46. temp = ' a ';
48. For (i=0; i<10; i++)
50. {
52. temp + = 1;
54. memcpy ((* (P_map+i)). Name, &temp,2);
56. (* (P_map+i)). Age = 20+i;
58. }
60. printf ("Initialize over \ n");
62. Sleep (10);
64. Munmap (P_map, sizeof (people) *10);
66. printf ( "Umap OK \ n");
68. }
70. /*-------------map_normalfile2.c-----------*/
72. #include <sys/mman.h>
74. #include <sys/types.h>
76. #include <fcntl.h>
78. #include <unistd.h>
80. typedef struct{
82. Char name[4];
84. int age;
86. }people;
88. Main (int argc, char** argv) //Map a normal file as shared mem:
90. {
92. int fd,i;
94. People *p_map;
96. Fd=open (argv[1],o_creat| o_rdwr,00777);
98. P_map = (people*) mmap (NULL,sizeof (people) *10,prot_read| Prot_write,
100. map_shared,fd,0);
102. For (i = 0;i<10;i++)
104. {
106. printf ( "name:%s Age%d;\n", (* (P_map+i)). Name, (* (P_map+i)). Age);
108. }
110. Munmap (P_map,sizeof (people) *10);
112. }

Limitations of Shared Memory:

Click to open link

Normal size is 32M, can be changed by Shmmax ~

/proc/sys/kernel/shmmax

Five, signal
A soft interrupt signal (signal, also referred to as a signal) is used to notify the process that an asynchronous event has occurred. Processes can send soft interrupt signals to each other through system call kill.
A signal is simply used to notify a process of what has happened and does not pass any data to the process.
There is a soft interrupt signal field in the table entry for the process table, where each bit of the field corresponds to a signal that corresponds to the position bit when a signal is sent to the process. As you can see, the process can keep the different signals at the same time, but for the same signal, the process does not know how many have come before processing.
The signal processing functions are as follows

[CPP]View Plaincopy

1. void (*signal (int signo,Void (*func) (int)))(int )

Examples such as the following

[CPP]View Plaincopy

1. if (signal (SIGUSR1,SIG_USR) ==sig_err)
2. printf ("Can not catch sig_usr1");

The Kill function is used to send a signal to a process or process group, and the Raise function allows the process to send a signal to itself

[CPP]View Plaincopy

1. int Kill (pid_t pid,int signo);
2. int raise (int signo);

The disadvantage of a signal is that it cannot be used to transmit data and is typically used to notify exceptions between processes

Six: Socket communication



Seven, file

A bit is can share a large amount of data, the disadvantage is that the share is slow, because it involves the disk read and write, disk speed than memory, and the file itself is not secure, some privileged users can delete files.

[Linux] Process (vii)--Process communication