completed lec 20,21,22 -- still need lec 23
[kspaans/CS350] / lec12-0616.tex
1 \documentclass{article}
2 \usepackage{fullpage}
3 \usepackage{amsmath}
4 \author{Kyle Spaans}
5 \date{June 16, 2009}
6 \title{Operating Systems Lecture Notes}
7 \begin{document}
8 \maketitle 
9
10 \section*{Lecture 12 -- Address Space}
11 Midterms were handed back today. Models solutions are on the course website.
12 The A2 tutorials will be held this afternoon.
13
14 A quick address translation exercise: given the size and location of the code
15 and data segments of an address space (vbase1=\texttt{0x400000}, 
16 pbase1=\texttt{0x10000}, npages1=\texttt{0x2B}, vbase2=\texttt{0x10000000}, 
17 vbase2=\texttt{0x40000}, npages2=\texttt{0x200}) and recalling that the page
18 size is $2^{12}$ bytes (4KB, \texttt{0x1000}) what is the page number and frame
19 number when we get a TLB fault on this virtual address: \texttt{0x00411608}?
20 First, note that the address is valid, it falls within the code segment (vbase1,
21 npages1). The offset is the 3 least significant hexits, \texttt{0x608}, meaning
22 the page number can be found in \texttt{0x411}. Since \texttt{0x400000} maps to
23 \texttt{0x10000} then \texttt{0x4110000} maps to \texttt{0x21000} meaning the
24 frame number is \texttt{0x21}. We need to be able to do this for tests.
25
26 \subsection*{Segmenting the Address Space}
27 OSes, or \emph{OS161} at least treats the address space as 3 segments, code
28 (aka text), data, and stack. If the MMU can't find the requested virtual
29 address in the TLB, it causes a ``address exception'' trap. This lets the OS
30 deal the fault by generating the necessary translation and placing it in the
31 TLB before execution returns to the program that requested the address.
32
33 \subsection*{Address Space for the Kernel}
34 Where does the kernel live? It's a program too, so it needs some kind of
35 address space. Consider sharing memory between two processes. Since they have
36 seperate address spaces, the kernel needs to do something special. It could
37 map parts of the two address spaces to the same frame of physical memory. The
38 processes would need to know about this which is why memory sharing is usually
39 requested by processes. Shared memory can also be used to save space. This is
40 easy to do if, for example, multiple processes are executing the same program.
41 Then the program's read-only, executable code can be shared by each process
42 rather than needing to be replicated for each process (wasteful if the program
43 is large, or if there is not very much physical memory to go around). Units of
44 sharing can be pages or whole segments.
45
46 Returning to where the kernel should go in memory, consider the
47 \texttt{write()} system call which will get a pointer and two integers in its
48 argument registers. We could put the kernel in a set physical memory area, and
49 disable address translation while in priviledged mode. This is the oldschool
50 way that OSes would do things. If this were the case, then to figure out the
51 ``buf'' argument to \texttt{write()}, the kernel would have to translate that
52 virtual address, probably by looking in the process' page table (by hand).
53
54 Alternatively, we could have the kernel in its own address space. This would
55 keep it safe from user programs. But now in order to understand the ``buf''
56 argument, it would have to do two translations. One to turn the virtual
57 address (from the process' address space) into a physical one, then a second
58 translation, turning the physical address into a virtual address in the
59 kernel's address space.
60
61 The more elegant solution, used in \emph{OS161}, Linux, and others, is to place
62 the kernel in a certain part of the virtual address space of every process.
63 This way, the kernel can use process' virtual address space (and the TLB
64 implicitly) to figure out ``buf''. The kernel's memory is protected from reads
65 or writes by the hardware, which will trap if the program tries to access
66 memory that it isn't supposed to. The specific virtual addresses are
67 \texttt{0x80000000} - \texttt{0xA0000000}, and these are always mapped by
68 the hardware to physical addresses \texttt{0x00000000} and up (taking up the
69 first 512MB of space). Since it is always mapped directly like this, entries
70 need not be placed in the TLB.
71
72 \subsection*{A2 \texttt{copyinout.c} Notes}
73 These functions can be used to copy data from user space into kernel space.
74 This is handy if the data needs to be copied anyway (e.g. into a special buffer
75 for a device, like a hard drive), but they are also very nice because they
76 gracefully handle error conditions. If the user tries to call \texttt{write()}
77 and gives a value for ``buf'' that's not valid, or in kernel space, etc, then
78 this should be caught, and an appropriate error returned from \texttt{write()}.
79 The functions in \texttt{copyinout.c} will handle this for us. Remember,
80 \texttt{write()} should not make the system panic if it's passed an invalid
81 parameter.
82 \end{document}