Lecture 13 starts here

So far

• OS illusion: virtualization
  • focus on the CPU

• What is left unanswered:
  • memory handling

In the next few lectures

• We extend limited direct execution to include memory
  • create a PRIVATE ADDRESS SPACE for every running program
• This is complex and challenging

First steps

• dynamic relocation
• segmentation

OS in the good old days

• One proc in memory
• OS is a library

Sharing memory in a caring OS

A real view

• leave processes in memory while switching \(\Rightarrow\) efficient
• Protection

Address space abstraction

• Running program has code, heap, stack
• OS abstracts

A virtual view

Every address you see is virtual

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) {
    printf("location of code : %p\n", main);
    printf("location of heap : %p\n", malloc(100e6));
    int x = 3;
    printf("location of stack: %p\n", &x);
    return 0;
}

• code comes first
• then the heap
• the stack is at the other end

• All addresses virtual, OS translates

Address translation

• Need hardware support
• OS sets things up

A simple example

void func()
    int x;
...
x = x + 3; // this is the line of code we are interested in

If you dissemble

Dynamic relocation

Base and bounds

Hardware provide two registers: Base and Bounds

\[physical\ addr = virtual\ addr + base \]

\[virtual\ addr \le bounds\]

128: movl 0x0(%ebx), %eax

• Set \(PC = 128\)
• Physical addr \(= 32768 + 128 = 32896\)
• hardware fetches the instruction at this physical address and executes.
• At some point, the process issues the load from virtual address \(15KB\), which translates to the physical addr of \(47KB\)
• If physical addr out of bounds, then raise an exception

Hardware requirements

OS duties

• What is the free list?
  • Need to find space for new proc

OS duties at boot time

Lecture 14 starts here

OS duties at boot time

OS designer language

• Isolation: If two entities are properly isolated from one another, then one can fail without affecting the other.
  • OS isolates processes
• Transparency: a program shouldn’t be aware of the fact that memory is virtualized; OS does all the work
• Efficiency: time \(\rightarrow\) programs run fast; space \(\rightarrow\) memory usage is low for OS duties
• Protection: One process does not affect the memory of another process and/or OS

Relocation

• Base and bounds is an approach for dynamic relocation

What is static relocation?

• A loader takes an executable and rewrites its addresses to the desired offset in physical memory

movl 1000, %eax
becomes
movl 4000, %eax

• Problems with static relocation? (Poll)

• No protection (bad addresses lead to illegal mem access)
• Difficult to move programs around in memory
• Bottomline: Need hardware support