completed lec 20,21,22 -- still need lec 23
[kspaans/CS350] / lec20-0716.tex
1 \documentclass{article}
2 \usepackage{fullpage}
3 \usepackage{amsmath}
4 \author{Kyle Spaans}
5 \date{July 16, 2009}
6 \title{Operating Systems Lecture Notes}
7 \begin{document}
8 \maketitle 
9
10 \section*{Lecture 20 -- File Systems}
11 What's the point? What does it provide to applications? To applications, a file
12 is an array of bytes. It has a name, size, and attributes like owner,
13 permissions, types, and timestamps. It's almost like virtual memory, if you
14 ignore the names. The important part is that files are \textbf{persistent}.
15 They are also shared by the whole system, belonging to more than just their
16 owner or any single process.
17
18 \subsection*{File System to the OS}
19 The FS is a system that collects many files under a single namespace and gives
20 the OS the ability to explicitly create, modify, open, close, and destry files.
21 Opening a file will return a file descriptor that can be used later to refer to
22 the open file, and can be used to explicitly close it. There is a lot of
23 overhead inherent in opening a file. The kernel has the check that the file
24 exists, check it's permissions against the process requesting the open,
25 translating the file position to a block on disk, etc. It would be slow to do
26 this every time a read or write was requested.  Therefore, ot is the kernel's
27 job to keep track of the open files for each process, and perform the
28 operations that those processes request on the files. The \texttt{fstat()}
29 system call can be used to get or set attributes from files.
30
31 \subsubsection*{File Positioning}
32 Every open file has a ``current position''. Read and write operations implicity
33 position themselves in the file, making sequential I/O very easy. That is, when
34 a read of 50 bytes is requested, the position in the file gets moved ahead by 50
35 bytes as well. If a specific position in the file is required, then the
36 \texttt{lseek()} syscall can be used (I.E. for random access). Each open file
37 as a position attribute. So if the same file is opened multiple times, even by
38 the same process, each file descriptor will have a different position. The file
39 descriptor is associated with each process, so another process can't just guess
40 an FD and intrude upon an existing open file.
41
42 \subsubsection*{Read/Write Copy Semantics}
43 Think of transfering blocks of data to and from a process's address space and
44 to and from the file in the file system. (In POSIX, \texttt{read()} will return
45 the number of bytes read, indicating EOF when reached.)
46
47 \paragraph*{Memory Mapped Files}
48 are even closer to virtual memory. Instead of copying the data from the file, a
49 portion of the file is mapped directly into the process's address space. Load
50 store instructions become read/write. The kernel has to manage this mapping.
51 Each process will need it's own mapping for reading from the file.
52
53 \subsection*{Update Semantics}
54 What happens when a memory-mapped file is written to? It can have a read-only
55 mapping, writes can simply be ignored (not propogated to the file), or finally
56 writes can be eagerly or lazily updated. Eager updates are inefficient (imagine
57 a large sequence of store operations, and calling write to write a word for
58 each one).  Lazy updates can be performed at the request of the process, or
59 when the file is unmapped.
60
61 \subsubsection*{Concurrent Updates}
62 What if multiple processes have memory mapped the same file? Lazy updates can't
63 guarantee updates to the file, but eager updates can. The kernel would have to
64 invalidate the page table entries of other process if their mapping gets
65 written to by another process.
66
67 \subsection*{File Names}
68 A file name consists of a full path (absolute path), or any unique ID in a name
69 space. Often a hierarchical structure is given to the name space, E.G.
70 directories in a tree (Directed Acyclic Graph). This can be done by splitting
71 the filename into directories and then a name (seperated by ``/'' in Unix).
72 The file system manages this structure, translating a file name to a location
73 on disk of the data and meta-data. One way to this can be to distribute file
74 information in nodes of the tree, E.G. directory files. Then name translation
75 becomes a recursive process of identifying the first directory in the path,
76 opening it, finding the next directory, and then proceeding to open it in turn.
77 \end{document}