Login to Athena (e.g., ssh -X athena.dialup.mit.edu) and attach the course locker: (You must run this command every time you log in; or add it to your ~/.environment file.)
$ add -f 6.828
Fetch the xv6 source:
$ mkdir 6.828 $ cd 6.828 $ git clone git://github.com/mit-pdos/xv6-riscv.git Cloning into 'xv6-riscv'... ... $
XXX pointer to an update tools page
Build xv6 on Athena:
$ cd xv6-public $ makeriscv64-linux-gnu-gcc -c -o kernel/entry.o kernel/entry.S riscv64-linux-gnu-gcc -Wall -Werror -O -fno-omit-frame-pointer -ggdb -MD -mcmodel=medany -ffreestanding -fno-common -nostdlib -mno-relax -I. -fno-stack-protector -fno-pie -no-pie -c -o kernel/start.o kernel/start.c ... $ make qemu ... mkfs/mkfs fs.img README user/_cat user/_echo user/_forktest user/_grep user/_init user/_kill user/_ln user/_ls user/_mkdir user/_rm user/_sh user/_stressfs user/_usertests user/_wc user/_zombie user/_cow nmeta 46 (boot, super, log blocks 30 inode blocks 13, bitmap blocks 1) blocks 954 total 1000 balloc: first 497 blocks have been allocated balloc: write bitmap block at sector 45 qemu-system-riscv64 -machine virt -kernel kernel/kernel -m 3G -smp 3 -nographic -drive file=fs.img,if=none,format=raw,id=x0 -device virtio-blk-device,drive=x0,bus=virtio-mmio-bus.0 hart 0 starting hart 2 starting hart 1 starting init: starting sh $
If you type ls at the prompt, you should output similar to the following:
$ ls . 1 1 1024 .. 1 1 1024 README 2 2 2181 cat 2 3 21024 echo 2 4 19776 forktest 2 5 11456 grep 2 6 24512 init 2 7 20656 kill 2 8 19856 ln 2 9 19832 ls 2 10 23280 mkdir 2 11 19952 rm 2 12 19936 sh 2 13 38632 stressfs 2 14 20912 usertests 2 15 106264 wc 2 16 22160 zombie 2 17 19376 cow 2 18 27152 console 3 19 0These are the programs/files that mkfs includes in the initial file system. You just ran one of them: ls.
Implement the UNIX program sleep, which sleeps for a user-specified number of ticks.
Some hints:
Run the program from the xv6 shell:
$ make qemu
...
init: starting sh
$ sleep 10
(waits for a little while)
$
Optional: write an uptime program that prints the uptime in terms of ticks using the uptime system call.
Write a program that uses UNIX system calls to ``ping-pong'' a byte between two processes over a pair of pipes, one for each direction. The parent sends by writing a byte to fd[1] and the child receives it by reading from fd[0]. After receiving a byte from parent, the child responds with its own byte by writing to fd[1], which the parent then reads.
Some hints:
Write a concurrent version of prime sieve using pipes. This idea is due to Doug McIlroy, inventor of Unix pipes. The picture halfway down the page and the text surrounding it explain how to do it.
Your goal is to use pipe and fork to set up the pipeline. The first process feeds the numbers 2 through 35 into the pipeline. For each prime number, you will arrange to create one process that reads from its left neighbor over a pipe and writes to its right neighbor over another pipe. Since xv6 has limited number of file descriptors and processes, the first process can stop at 35.
Some hints:
Write a simple version of the UNIX find program: find all the files in a directory tree whose name matches a string. For example if the file system contains a file a/b, then running find as follows should produce:
$ find . b
./a/b
$
Some hints:
Optional: support regular expressions in name matching. Grep has some primitive support for regular expressions.
Write a simple version of the UNIX xargs program: read lines from standard in and run a command for each line, supplying the line as arguments to the command. The following example illustrates xarg's behavior:
$ xargs echo bye
hello too
bye hello too
$
Note that the command here is "echo bye" and the additional
arguments are "hello too", making the command "echo bye hello too",
which outputs "bye hello too".
xargs and find combine well:
find . b | xargs grep hello
will run "grep hello" on each file named b in the directories below ".".
Some hints:
In this exercise you will modify the xv6 kernel to print out a line for each system call invocation. It is enough to print the name of the system call and the return value; you don't need to print the system call arguments.
When you're done, you should see output like this when booting xv6:
... fork -> 2 exec -> 0 open -> 3 close -> 0 $write -> 1 write -> 1
That's init forking and execing sh, sh making sure only two file descriptors are open, and sh writing the $ prompt. (Note: the output of the shell and the system call trace are intermixed, because the shell uses the write syscall to print its output.)
Hint: modify the syscall() function in kernel/syscall.c.
Run the programs you wrote in the previous exercises and inspect the system call trace. Are there many system calls? Which systems calls correspond to code in the applications you wrote above?
Optional: print the system call arguments.