completed lec 20,21,22 -- still need lec 23
[kspaans/CS350] / lec13-0618.tex
1 \documentclass{article}
2 \usepackage{fullpage}
3 \usepackage{amsmath}
4 \author{Kyle Spaans}
5 \date{June 18, 2009}
6 \title{Operating Systems Lecture Notes}
7 \begin{document}
8 \maketitle 
9
10 \section*{Lecture 13 -- Loading Programs into Address Spaces}
11 First, some quick notes relevant to the assignment:
12 \begin{itemize}
13 \item The VFS abstracts common ``file'' (files are like arrays of bytes, sort
14       of like an address space) operations into a FS-independant interface.
15 \item The UIO structure describes the read/write operation plus location,
16       length, etc and needs to be passed as a reference to \texttt{VOP\_read()}
17       or \texttt{VOP\_write()}. It is useful because it keeps track or how much
18       work yet remains to be done. This is useful if we need to transfer say
19       2000 bytes of data, but the device we are transfering to takes data in
20       100 bytes chunks. The UIO structure can be given a userspace or
21       kernelspace pointer, and do the transfer for us. This saves us some work
22       for A2 for the \texttt{write()} system call.
23 \item For implementing \texttt{fork()}, notice that there is a
24       \texttt{as\_copy()} function that we can write, but should come in handy.
25       And recall that the new thread/process created by \texttt{fork()} will
26       never has been in usermode before, so we need to put it there by having
27       it run the \texttt{md\_forkentry()} function.
28 \end{itemize}
29
30 \subsection*{\texttt{execv()}}
31 When the new address space is initialized, remember that we only need to touch
32 addresses in the rance \texttt{0x00000000} to \texttt{0x7FFFFFFF}. The
33 information that will describe the new address space comes from an ELF
34 (Executable, Linking Format) file. ELF files have a magic header (with magic
35 ELF bytes) and then some meta data to describe symbols, sections, and segments
36 that they contain and then ``images'' of those segments. The metadata will
37 describe the size of the section or segment, it's properties, and where it can
38 be found inside the file. The image can then be directly copied into the
39 process' address space. This is what the functions in \texttt{loadelf.c} do.
40 If a segment described in the ELF file is larger than the amount of data in
41 the ELF file, then the rest of the segment (in memory) can be filled with null
42 bytes. In \emph{OS161} we only care about the text and data segments. Note
43 that the stack is not described, but it only needs to be worried about at
44 run time, not compile or link time. Some tools for poking at elf files are
45 \texttt{cs350-readelf}, \texttt{cs350-objdump}, \texttt{cs350-nm}.
46
47 \subsection*{Segment-Program Relations}
48 (The kernel doesn't care about this stuff!) Programs are made up code and
49 variables. When compiled, these get divided into sections, and the sections
50 are put into segments. There are sections for text, data, read-only data,
51 uninitialized and initialized global variables. See the notes for an example
52 of which variables a C program will be put in which sections. The space for
53 global variables, since they can't go in the stack, are given space in the
54 program's data segment. Alignment can be tricky, look at what
55 \texttt{loadelf.c} does currently -- notice how variables in the ELF file
56 are word-aligned.
57
58 \subsection*{Argument Passing}
59 It's not entirely necessary, so we should work on this last. The two
60 parameters to \texttt{main(int argc, char **argv)} must be manually placed
61 in the process' registers. The first is just a count, and is easy to do.
62 The second is a pointer, but it can't be a pointer to kernel space, so the
63 kernel will have to copy those strings into \emph{some part} of the user's
64 address space. Where is up to us. We could find an unused part of the data
65 segment, or enlarge the data segment (by performing the correct calls and
66 modifying the address space structure) and place it there, or we can
67 create a third ``argument'' segment. Or perhaps put the strings at the
68 bottom of the stack. We need to copy the strings, then create an array of
69 pointers to the strings, then set \texttt{argv} to point to the array. As
70 long as doing any of this doesn't clobber existing data in the process'
71 address space.
72
73 \subsection*{Memory Related System Calls}
74 Systems usually have system calls for allocating memory to a process,
75 \texttt{brk()} (break) or some such. Malloc usually deals with this, and
76 poritions out the large chunk of memory that it gets from the kernel to
77 user programs who call \texttt{malloc()}. We don't have to worry about
78 this. There can be calls for created shared memory areas between
79 processes as well.
80 \end{document}