一个进程可以覆盖另一个进程的内存吗？

Question

My project is composed of 3 processes. Process 1 is a "server" of process 2 and 3 and implements shared memory. Process 2 randomly crashes with application errors, trying to access it's own memory, that has been corrupted somehow.

Error is: Invalid instruction at some address at memory location some not good address.

Where would I start looking and what type of things would I look for in process 1, to see if it is overwriting process 2's memory?

Thank You.

Answer 1

Accidentally overwrite the memory of another process (without its cooperation)? No*, because you have to "accidentally" do a lot of things correctly. (You have to "accidentally" open a handle to the process, and also "accidentally" call WriteProcessMemory .)

Intentionally? Yes, using the WriteProcessMemory function.

* If you're sharing memory, the likelihood of an error skyrockets.

Answer 2

A process can only overwrite another process' memory if it actively tries to. Debugging is one example, shared memory is another. Accidental writing to either code or data area of another process is very unlikely.

So the problem is, most likely, a bug withing process 2. I mean, process 2 is not even sharing its memory, right? So process 1 cannot possibly overwrite it.

Answer 3

The OS will prevent a process from overwriting another process's memory, unless you are running as part of the kernel. Use a memory debugger like valgrind to track down the cause of any memory access errors.

Edit: you can also include the possibility of using OS calls to access another process's memory, but as everyone has said, you most likely aren't doing that. Passing pointers in the shared memory is the most likely error here, but I still suggest using a tool like valgrind.

Answer 4

Do the data structures in the shared memory include any absolute pointers? Not only is this a bad idea, because absolute pointers aren't meaningful in other processes, but one process could convince the other process to write wildly through its memory.

In general, the memory management unit prevents any process from directly overwriting/corrupting another process's memory. Shared memory (including file mappings) and the WriteProcessMemory function are exceptions to the general rule.