1. Lab 2: Hello, xv6! Advanced Operating Systems Zubair Nabi
[email protected] February 6, 2013
2. V6 Sixth Edition Unix a.k.a. Version 6 Unix First public
release of Unix out of Bell Labs Designed for DEC PDP-11* Original
source code still available:
http://minnie.tuhs.org/cgi-bin/utree.pl Bible: Commentary on UNIX
6th Edition by John Lions (http:
//www.lemis.com/grog/Documentation/Lions/)
3. xv6 Reimplementation of V6 in ANSI C out of MIT for x86
systems The entire source code can be converted to a PDF via make
print Textbook/commentary: xv6: a simple, Unix-like teaching
operating system Online: http://pdos.csail.mit.edu/6.828/2012/
xv6/book-rev7.pdf
4. Installation 1 Install packages sudo apt-get install
zlib1g-dev glib2.0-dev mpage 2 Install QEMU git clone
http://pdos.csail.mit.edu/6.828/qemu.git -b 6.828-0.152 ./configure
--disable-kvm --target-list=i386-softmmu x86_64-softmmu make sudo
make install 3 Setup xv6 git clone
git://pdos.csail.mit.edu/xv6/xv6.git make make qemu
5. OS in a nutshell 1 Manages low-level hardware; 2 Multiplexes
the hardware; 3 Provides controlled ways for process
interaction.
6. xv6 structure Monolithic kernel which provides services to
running programs, called processes Processes use system calls to
access kernel services A system call is a procedure call in the OS
interface System calls enter kernel space, force the kernel to
perform a service, and then return A process alternates between
user and kernel space User-space P1 System Call Kernel-space P2
System Call
7. OS protection CPUs hardware protection mechanisms enable the
kernel to sandbox each process within its own memory Kernel
executes with hardware privileges while processes do not On a
system call, the hardware raises the privilege level and executes a
specic function in the kernel
8. xv6 system calls System call fork() exit() wait() kill(pid)
getpid() sleep(n) exec(filename, *argv) sbrk(n) open(filename,
flags) Description Create process Terminate current process Wait
for a child process to exit Terminate process pid Return current
processs id Sleep for n seconds Load a le and execute it Grow
processs memory by n bytes Open a le; ags indicate read/write
9. xv6 system calls (2) System call read(fd, buf, n) write(fd,
buf, n) close(fd) dup(fd) pipe(p) chdir(dirname) mkdir(dirname)
mknod(name, major, minor) fstat(fd) link(f1, f2) unlink(filename)
Description Read n bytes from an open le into buf Write n bytes to
an open le Release open le fd Duplicate fd Create a pipe and return
fds in p Change the current directory Create a new directory Create
a device le Return info about an open le Create another name (f2)
for the le f1 Remove a le
10. Shell Program for executing user commands Not a part of the
kernel only uses system calls to interact with it Replaceable!
11. Process A combination of user-space memory (instructions,
data, and stack) and per-process kernel state xv6 takes care of
register management Each process can be identied through its pid, a
positive integer
12. Process creation fork system call to create a new (child)
process Same memory contents as the parent Fork returns the child
pid in the parent and zero in the child
14. Process replacement exec system call replaces the processs
memory with a new memory image exec starts executing instructions
from the new memory image sbrk(n) to grow data memory on the y
16. File descriptor A small integer to index a kernel-managed
object with read/write semantics Obtained by opening a le (le,
directory, device, pipe, existing le descriptor) Each process has a
le descriptor table indexed by le descriptors Standard input: File
descriptor 0 Standard output: File descriptor 1 Standard error:
File descriptor 2 The shell always has these open
17. File descriptor (2) read(fd, buf, n) Reads at most n bytes
from the fd; Copies them into buf; 3 Returns the number of bytes
read and advances the offset. 1 2 write(fd, buf, n) 1 2 Writes n
bytes from the buf to the fd; Returns the number of bytes written
and advances the offset. close(fd) 1 Closes the fd dup(fd) 1
Duplicates the fd
20. Pipe A small kernel buffer Exposed to processes as a pair
of le descriptors One fd for reading, the other for writing pipe(p)
creates a pipe and puts read/write le decriptors in the array
p
22. Filesystem Implemented as a tree-like structure Files:
uninterpreted byte arrays Directories: references to other les and
directories Paths are either absolute or relative
23. Filesystem (2) fstat(fd) system call retrieves information
about the object that the fd maps to Fills up the following struct:
#define T_DIR 1 // Directory #define T_FILE 2 // File #define T_DEV
3 // Device struct stat { short type; // Type of file int dev; //
File systems disk device uint ino; // Inode number short nlink; //
Number of links to file uint size; // Size of file in bytes };
24. Todays Task Write C code that replaces steps 3 to 5 from
your last task For simplicity, you can perform steps 1 and 2
manually C code extension: .c To compile: gcc test.c -o test.exe To
run: ./test.exe System calls/methods (possibly) needed: printf
(stdio.h), exit() (stdlib.h), execv(), dup(), close(), pipe()
25. Reading Chapter 0 from xv6: a simple, Unix-like teaching
operating system