lecture 13 notes
[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 
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.
29 \subsection*{\texttt{execv()}}
30 When the new address space is initialized, remember that we only need to touch
31 addresses in the rance \texttt{0x00000000} to \texttt{0x7FFFFFFF}. The
32 information that will describe the new address space comes from an ELF
33 (Executable, Linking Format) file. ELF files have a magic header (with magic
34 ELF bytes) and then some meta data to describe symbols, sections, and segments
35 that they contain and then ``images'' of those segments. The metadata will
36 describe the size of the section or segment, it's properties, and where it can
37 be found inside the file. The image can then be directly copied into the
38 process' address space. This is what the functions in \texttt{loadelf.c} do.
39 If a segment described in the ELF file is larger than the amount of data in
40 the ELF file, then the rest of the segment (in memory) can be filled with null
41 bytes. In \emph{OS161} we only care about the text and data segments. Note
42 that the stack is not described, but it only needs to be worried about at
43 run time, not compile or link time. Some tools for poking at elf files are
44 \texttt{cs350-readelf}, \texttt{cs350-objdump}, \texttt{cs350-nm}.
46 \subsection*{Segment-Program Relations}
47 (The kernel doesn't care about this stuff!) Programs are made up code and
48 variables. When compiled, these get divided into sections, and the sections
49 are put into segments. There are sections for text, data, read-only data,
50 uninitialized and initialized global variables. See the notes for an example
51 of which variables a C program will be put in which sections. The space for
52 global variables, since they can't go in the stack, are given space in the
53 program's data segment. Alignment can be tricky, look at what
54 \texttt{loadelf.c} does currently -- notice how variables in the ELF file
55 are word-aligned.
57 \subsection*{Argument Passing}
58 It's not entirely necessary, so we should work on this last. The two
59 parameters to \texttt{main(int argc, char **argv)} must be manually placed
60 in the process' registers. The first is just a count, and is easy to do.
61 The second is a pointer, but it can't be a pointer to kernel space, so the
62 kernel will have to copy those strings into \emph{some part} of the user's
63 address space. Where is up to us. We could find an unused part of the data
64 segment, or enlarge the data segment (by performing the correct calls and
65 modifying the address space structure) and place it there, or we can
66 create a third ``argument'' segment. Or perhaps put the strings at the
67 bottom of the stack. We need to copy the strings, then create an array of
68 pointers to the strings, then set \texttt{argv} to point to the array. As
69 long as doing any of this doesn't clobber existing data in the process'
70 address space.
72 \subsection*{Memory Related System Calls}
73 Systems usually have system calls for allocating memory to a process,
74 \texttt{brk()} (break) or some such. Malloc usually deals with this, and
75 poritions out the large chunk of memory that it gets from the kernel to
76 user programs who call \texttt{malloc()}. We don't have to worry about
77 this. There can be calls for created shared memory areas between
78 processes as well.
79 \end{document}