|
|
Inter-process communication and data sharing under Windows
There are many ways to implement inter-process communication under Windows, such as using socket, pipe (Pipe), mailbox (Mailslot), and so on. But the most basic and direct is to use memory sharing. Other methods will eventually detour here.
It is conceivable that if there is only one copy of physical memory, and this memory is mapped to their respective virtual address spaces in different processes, each process can read the same data, which is the most efficient data exchange. method. Below we discuss how to implement it.
Shared memory is implemented by FileMapping in Windows. We can use CreateFileMapping to create a memory file mapping object. CreateFileMapping API will create a kernel object for mapping files to memory. Here, we don't need an actual file, so there is no need to call CreateFile to create a file. The parameter of hFile can be filled in INVALID_HANDLE_VALUE. However, the file length needs to be filled. Windows supports files up to 64bit, but here, our demand must not exceed 4G, dwMaximumSizeHigh must be 0, and the length should be filled in dwMaximumSizeLow. Then call MapViewOfFile to map to the virtual address of the current process. Once the shared memory is used up, call UnmapViewOfFile to reclaim the memory address space.
It makes sense for Windows to separate the CreateFileMapping and MapViewOfFile APIs. This is because it is allowed to map a file exceeding 4G, and the address space is only 4G at most (in fact, the general user's program can only use 2G), MapViewOfFile can specify the offset of the file and only map a part.
Fill in a name in the last parameter pszName of CreateFileMapping, then other processes can use this name to call OpenFileMapping to open the FileMapping object and map it in the new process. However, the method of passing agreed strings seems not very elegant.
An elegant method is to use DuplicateHandle to copy a FileMapping object in the new process, and then find a way to notify the new process of the Handle, such as passing it in a message.
If the two processes that need to share memory have a parent-child relationship, then we can notify the Handle of FileMapping without message passing. The parent process can directly pass the Handle of FileMapping to the child process by inheriting Handle. Of course, properties that can be inherited should be set when CreateFileMapping.
It looks like this:
SECURITY_ATTRIBUTES sa;
sa.nLength=sizeof(sa);
sa.lpSecurityDescriptor=NULL;
sa.bInheritHandle=TRUE;
handle=CreateFileMapping(INVALID_HANDLE_VALUE,&sa,PAGE_READWRITE,0,size,NULL);
In this way, during CreateProcess, if the bInheritHandles parameter is TRUE, all kernel objects with inheritable properties will be copied to the child process.
Note: The inheritance of kernel objects is to create a child process in CreateProcess, but before the main thread of the child process is not active, the kernel scans all kernel objects in the current process, checks out those with inheritable attributes, and then uses DuplicateHandle to copy to the child process . Since it is a kernel object, there is essentially only one copy in the kernel, all is just the reference count plus one, the Handle of the same kernel object of the parent process and the child process must be the same.
The process of copying the kernel object is done internally by CreateProcess, and we can safely pass the object Handle (same as the child process) to the child process through the command line. Or, it can be passed with environment variables.
It is worth noting that after the child process runs out of this FileMapping object, it also needs CloseHandle minus the reference count.
Remarks:
When CreateProcess is called, pszCommandLine cannot be directly filled with an unmodifiable string. E.g:
CreateProcess("test.exe","test argument",...);
This is wrong, because the "test argument" will be compiled by the compiler into the unmodifiable data segment. The correct way is:
char cmdline[]="test argument";
CreateProcess("test.exe",cmdline,...);
In this way, the string of the command line is placed on the stack and can be read and written.
The penultimate parameter of CreateProcess needs to be filled in a STARTUPINFOW structure, which is very complicated and usually very troublesome to fill. We can copy the structure of the parent process and modify it as appropriate. the way is:
STARTUPINFO si={sizeof(si)};
PROCESS_INFORMATION pi;
GetStartupInfo(&si);
CreateProcess(...,&si,&pi);
Here, the first length information of the STARTUPINFO structure should usually be filled in to ensure the correct execution of GetStartupInfo(&si);. |
|
|
|
China
Post time: 2020-12-17 15:00:01
Author