completed lec 20,21,22 -- still need lec 23
[kspaans/CS350] / lec08-0528.tex
1 \documentclass{article}
2 \usepackage{fullpage}
3 \usepackage{amsmath}
4 \author{Kyle Spaans}
5 \date{May 28, 2009}
6 \title{Operating Systems Lecture Notes}
7 \begin{document}
8 \maketitle
9
10 \section*{Lecture 8 -- System Calls, Exceptions, Interrupts}
11 In userspace, system calls look just like procedure calls This allows them to
12 be portable. Otherwise our programs would have to include machine-specific
13 instructions, like \texttt{syscall} in MIPS. The library just provides wrappers
14 around the system calls for our convenience. See \texttt{lib/libc/syscalls.S}.
15
16 \subsection*{\texttt{syscall}}
17 The system call instruction jumps directly to the addressa where the exception
18 handler waits. It also does some special things for us, such as turning off
19 interrupts so that a trap frame can be saved to the kernel stack, etc. This is
20 doable thanks to the \texttt{k0} and \texttt{k1} special registers. By
21 convention, user programs are not allowed to assume these will be preserved
22 by system calls. The trap frame saves all of the state of the CPU from the
23 application thread's execution. Later, \texttt{mips\_trap()} turns interrupts
24 back on, and the kernel starts doing its work. The kernel may be running, but
25 it can still be preempted at any time. The trap frame is used to
26 restore state for the application thread when the system call is done. The
27 special \texttt{ref} instruction is the complement of \texttt{syscall} and
28 turns interrupts back on, among other things. Notice that the kernel places
29 the return values directly into memory where the trap frame was saved -- it
30 can't set registers, because the current register state belongs to the
31 kernel, not the application thread.
32
33 Also note that this means each thread has two stacks, one for application code
34 that runs without special privileges, and one for when the kernel is executing
35 privileged code on behalf of the thread. One of the benefits of this is for
36 protecting sensitive data from snooping application (e.g. things that may be
37 saved into stack frames but not zeroed out), and to simplify memory management.
38 So there is a kernel stack for each thread, you can find a pointer to it in
39 \texttt{struct thread}.
40 Stacks can overflow, so if an application stack is nearly full and calls a
41 large system call, then the kernel's stack frames may overflow that stack. By
42 maintaining and managing it's own stack, the kernel doesn't have to worry about
43 overflowing the application thread's stack.
44
45 \subsection*{Exceptions}
46 The whole process of servicing an exception is almost identical to that of a
47 system call. The difference is that exceptions are unintentional, mistakes that
48 the program makes, such as accessing the wrong part of memory or dividing by
49 zero. Each kind of exception has a unique code, see
50 \texttt{arch/mips/include/trapframe.h} for the meaning of each one. The kernel
51 looks at this value to see what to do next. It'll decide what to do based on
52 what generated the exception, or whether it was a system call that jumped into
53 the exception handler, or perhaps a hardware interrupt. 
54
55 \subsection*{Interrupts}
56 Hardware causes interrupts. They can happen inside of the kernel. There is no
57 problem with this though, the exception handler will save a trap frame of the
58 kernel's state, and then go about business as usual. We can see in the
59 exception handler that it checks to see if it was already in the kernel.
60
61 \end{document}