5

Consider the following CPU instruction which takes the memory at address 16777386 (decimal) and stores it in Register 1:

Move &0x010000AA, R1

Traditionally programs are translated to assembly (machine code) at compile time. (Let's ignore more complex modern systems like jitting).

However, if this address allocation is completed statically at compile time, how does the OS ensure that two processes do not use the same memory? (eg if you ran the same compiled program twice concurrently).

Question:

How, and when, does a program get its memory addresses assigned?

Virtual Memory:

I understand most (if not all) modern systems use Memory Management Units in hardware to allow for the use of virtual memory. The first few octets of an address space being used to reference which page. This would allow for memory protection if each process used different pages. However, if this is how memory protection is enforced, the original question still persists, only this time with how page numbers are assigned?

EDIT:

CPU:

One possibility is the CPU can handle memory protection by enforcing that a process id be assigned by the OS before executing memory based instructions. However, this is only speculation, and requires support in hardware by the CPU architecture, something I'm not sure RISC ISAs would be designed to do.

James
  • 2,445
  • 2
  • 25
  • 35

2 Answers2

1

With virtual memory each process has separate address space, so 0x010000AA in one process will refer to different value than in another process.

Address spaces are implemented with kernel-controlled page tables that processor uses to translate virtual page addresses to physical ones. Having two processes using the same address page number is not an issue, since the processes have separate page tables and physical memory mapped can be different.

Usually executable code and global variables will be mapped statically, stack will be mapped at random address (some exploits are more difficult that way) and dynamic allocation routines will use syscalls to map more pages.

zch
  • 14,931
  • 2
  • 41
  • 49
  • Its my understanding that page look-ups use hardware in order to reduce the time cost of look-up (yes kernel takes over on page faults, but that should be the exception condition). So does the MMU track which process is running? How does it know to map 0x010000AA to physical address X one time, but map 0x010000AA to physical address Y at a later time? – James Nov 24 '14 at 16:58
  • @James, processor needs a register pointing to page table (for example CR3 in x86 http://en.wikipedia.org/wiki/Control_register#CR3 ). – zch Nov 24 '14 at 17:16
  • Expanding on @zch's comment, each process has its own page table, so on a context switch, the kernel changes the CR3 register with the page table base address for the process it's swapping in. – Melandru's Square Jul 12 '19 at 14:48
1

(ignoring the Unix fork) The initial state of a processes memory is set up by the executable loader. The linker defines the initial memory state and the loader creates it. That state usually includes memory to static data, executable code, writeable data, and the stack.

In most systems a process can modify the address space by adding pages (possibly removing them as well).

[Ignoring system addresses] In virtual (logical) memory systems each process has an address space starting at zero (usually the first page is not mapped). The address space is divided into pages. The operating system maps (and remaps) logical pages to physical pages.

Address 0x010000AA in one process is then a difference physical memory address in each process.

user3344003
  • 20,574
  • 3
  • 26
  • 62