In 'nix, you can easily do that. For 'nix, all pointers are offsets
from some base register set by the operating system. For i all
pointers are absolute pointers into virtual memory; those pointers
are also capabilities which limit the offsets that can be derived
from that pointer. For i, you can't run off the end of the memory
space allocated for the job or by any ALLOC/MALOC type operation.
In the Unixes I've worked in, each process has it's own address space.
Thus, if one process is pointing to address 12345 and another process is
also pointing to 12345, there's no conflict -- they're referring to
different places in memory, because each process has it's own address space.
If, somehow (usually due to memory corruption) you end up with an offset
the goes outside of what's been allocated to your address space, you end
up with a SIGSEGV (segmentation violation).
The only way to get memory that's shared across processes is to
specifically ask the kernel for a shared memory segment by calling the
appropriate API.
By contrast, on i, there's only one address space for everything
(including both disk and memory) across all jobs.
So, it's actually HARDER for one process to interfere with another's
memory in the Unixes I've worked in. Granted, there are many, many
different flavors of Unix, and they're all different.
However, a pointer on i (provided we're talking about traditional SLS
pointers, not teraspace) is much different from on other platforms. It's
more like a data structure containing various bits of information.
Space pointers contain both the space they point to, and the offset
within that space. When you add/subtract from the address, you only
modify the offset, you don't modify the space. Therefore, you can never
use addition/subtraction on a pointer to access a different space.
Also, different types of pointers are used to execute program code vs.
modify memory. That makes it difficult (although, not impossible -- at
least, it's still possible in V5R3) to modify code in memory and then
execute it.
By contrast, Unix uses the same sort of pointer (which is just an
offset) for both code and data -- so you can potentially add/subtract
from a data field to get into the executable code's memory, and them
modify it... A common source of security holes.
So there are pros and cons -- but the worst model is that of Windows. I
strongly recommend that you avoid Windows at any cost.
midrange.com
