Lab: xv6

Boot xv6

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 0

sleep

Implement the UNIX program sleep, which sleeps for a user-specified number of ticks.

Some hints:

• Look at some of the other programs in user/ to see how you can obtain the arguments passed to a program. If the user forgets to pass an argument, sleep should print an error message.
• The argument is passed as a string; you can convert it to an integer using atoi (see user/ulib.c).
• Use the system call sleep (see user/usys.S and kernel/sysproc.c).
• Make sure main calls exit() in order to exit your program.
• Add the program to UPROGS in Makefile and compile user programs by typing make fs.img.

Run the program from the xv6 shell:

      $ make qemu
      ...
      init: starting sh
      $ sleep 5
      (waits for a little while)
      $
    

Optional: write an uptime program that prints the uptime in terms of ticks using the uptime system call.

pingpong

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:

• Use pipe to create a pipe.
• Use fork to create a child.
• Use read to read from the pipe, and write to write to the pipe.

primes

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:

• Be careful to close file descriptors that a process doesn't need, because otherwise your program will run xv6 out of resources before the first process reaches 35.
• Once the first process reach 35, you should arrange that the pipeline terminates cleanly (Hint: read will return an end-of-file when the write-side of the pipe is closed).

find

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:

• Look at user/ls.c to see how to read directories.
• Use recursion to run find in sub-directories.
• Don't recurse into "." and "..".

Optional: modify the shell

Modify the shell to support wait.

Modify the shell to support lists of commands, separated by ";"

Modify the shell to support sub-shells by implementing "(" and ")"

Modify the shell to allow users to edit the command line