Kernel and OS structure

Required reading: Chapter 7 of Lion's

Overview

OS: kernel address space plus user address spaces
- each program (including kernel) consists of the binary representation for the text of the program, the data part part of the program, and the stack area.
- the kernel address space runs the kernel program, which manages all hardware and provides an API to user programs. In v6, this program is called the scheduler (proc[0]).
- each user address space contains a program. In v6, each each program has a user and a kernel stack; when the user program switches to the kernel, it switches to its kernel stack. The kernel stack is stored in process's u structure.
Example: see accompanying picture of how v6 layout out of the kernel address space and user address space, and how they are mapped to physical memory.
Switching from one program to another involves:
- Switch address spaces; ask the MMU to point to new the address space. On the PDP-11, this means loading the segment registers, and perhaps PSW.
- Unload the current program's state from processor and reload it with the new program's state. On the PDP-11, this means switching sp (pointing it to the new program's stack) and pc (pointing it to the new program's point of execution).

Case study (Lion's book)

C calling conventions. The compiler generates the following line at the beginning of every body of a C function:
- conceptually stack layout:
```
	   args
	   ra (return address)
           saved r5  <--- r5
	   saved r4
	   saved r3
	   saved r2  <--- sp
```
- with what instruction can a C function reference its first of n arguments? (be careful: arguments pushed in reverse order)
- the more precise layout is more complicated, because that the calling and saving is done by csv, and cret:
```
	   args
	   ra (return address of where to return when C-func completes)
           saved r5  <--- r5
	   saved r4
	   saved r3
	   saved r2 
	   ra (cret) <---- sp
	   
```
- Is it important that cret directly follows csv in m40.s?

lets resume at 649 (lec notes document the stacks, and nothing else). We simplify the stack layout a bit and ignore the precise layout as described above and ignore the allocation of local variables.

612: where is sp pointing to?
646: what is the address in the sp? what is the content?
664: what is the content now?
669: what is the content of stack after this instruction completes?
```
	      | pc |   <- sp
```

1551: the stack is:

	      | pc (=670)|  
	      | r5 (=0) |  <- r5 (=usize+64. - 2)
	      | r4 |
	      | r3 |
	      | r2 |  <- sp

1827: the stack is:

	      | pc (=670)|  
	      | r5 (=0) |  <- r5 (=usize+64. - 2)
	      | r4 |
	      | r3 |
	      | r2 |  <- sp
	      | pc (=1627)|
	      | r5 (=usize+64. -2) | <- r5
	      | r4 |
	      | r3 |
	      | r2 |  <- sp

sp, and r5 are saved in u_rsave in uarea for proc[0]

1917: what is the stack in u for proc[1]? an identical copy of the one above (thus, we have two copies now)

1637: proc[0]'s stack is:

	      | pc (=670)|  
	      | r5 (=0) |  <- r5 (=usize+64. - 2)
	      | r4 |
	      | r3 |
	      | r2 |  <- sp

2189: proc[0]'s stack is:

	      | pc (=670)|  
	      | r5 (=0) |  <- r5 (=usize+64. - 2)
	      | r4 |
	      | r3 |
	      | r2 |  <- sp
	      | pc (=1638)|
	      | r5 (=usize+64. -2) | <- r5
	      | r4 |
	      | r3 |
	      | r2 |
	      | pc (=1969)|
	      | r5 (=prev r5) | <- r5
	      | r4 |
	      | r3 |
	      | r2 |
	      | pc (=2094)|
	      | r5 (=prev r5) | <- r5
	      | r4 |
	      | r3 |
	      | r2 |  <- sp

what is saved in u_rsave?

what is restored in 2193?

2228: what stack are we pointing too? (proc[1]'s!) what is its stack? (the copy we made earlier of proc[0]'s):

	      | pc (=670)|  
	      | r5 (=0) |  <- r5 (=usize+64. - 2)
	      | r4 |
	      | r3 |
	      | r2 |  <- sp
	      | pc (=1627)|
	      | r5 (=usize+64. -2) | <- r5
	      | r4 |
	      | r3 |
	      | r2 |  <- sp

2248: the stack is:

	      | pc (=670)|  
	      | r5 (=0) |  <- r5 (=usize+64. - 2)
	      | r4 |
	      | r3 |
	      | r2 |  <- sp

and proc[1] is about to return to 1627 (the if branch)

1634: what proc[1]'s stack at the end of 1635? empty! and pc is 670?
0672: what is proc[1]'s stack:
```
	      | 0170000) |
	      | 0 | <- sp
```
0672 (end): proc[1]'s:
- PSW: current mode is user, previous mode is kernel
- sp is the user mode stack point: 0 (probably cleared when starting machine) h
- pc is 0 (instruction @ address zero 0 traps back into kernel; see first word of icode, 1518)