[an error occurred while processing this directive]

Advanced Systems Teaching (ASysT) Lab

The ASysT lab is organised around 64-bit computers (``U4600'') based on a 100 MHz MIPS R4700 processor. The U4600 was developed by Kevin Elphinstone (former UNSW PhD student) and Dave Johnson. It is especially designed to allow experimentation with operating systems code. Presently, these machines run the L4 microkernel.

L4 & ASysT Lab FAQ

Errata for documentation

Technical details:

The nodes are based on a locally designed and manufactured ATX form factor motherboard. The motherboard features:-

The nodes are hosted on UNIX computers, presently PC's running Solaris. These contain a development environment which allows you to compile code, link it with the L4 microkernel, and download it to the U4600 via ethernet. The hosts also interface to the serial port on the U4600 for console I/O.

How to use:

Make sure that ~cs9242/bin is in your PATH, and that the environment ARCH is set to pc.i86.linux. The former is normally achieved by using the newclass command, the latter is set up automatically by the default shell initialisation files. Also make sure that you are using GNU make (this is also ensured by the default initialisation files).

Use the Makefiles supplied with the examples (like the one in ~cs9242/public_html/src/hello_world/). Typing

make
will compile and link your code, create a boot image, and copy this into the boot directory /tftpboot on your workstation. Your U4600 should then be able to download this image and boot the kernel contained in it.
Note: make must be done locally on the host machine connected to your U4600, or the boot image will end up in the wrong boot directory.

You also need to run a terminal emulator on the host to be able to talk to the U4600. Use the command

u4600 &
to start up a properly configured emulator. It should produce a greeting message ending with ``Modem ``/dev/term/b is Available.''
Turn on the U4600, you should get another greeting message and a
mipsXX> 
prompt, where XX is the number of the machine, from the resident boot monitor. If the U4600 was already running, hit <CR> in the emulator window and you should also get to see the boot monitor prompt.
If you do not get the prompt, some program is actually executing on the U4600. Press the INTERRUPT button (the smaller of the two buttons on the box) for about 1/2 second, and you should get a ``KDBG>'' prompt. Type
rbt
and you should get the mipsXX> prompt.

If you type

boot kernel.img
to the mipsXX prompt, it should boot the machine from the kernel image you have compiled above. (``kernel.img'' is the default boot image name, if you use the standard Makefile and your U4600 is set up correctly you do not need to specify this.) If booting fails your boot image is probably not readable, check the permissions (the standard Makefile sets them correctly). The boot should end with a message stating the ``entry address'' of the kernel image.
Type
g
(for go) and your kernel should start executing.
Note that you are running an operating system, which is not expected to terminate. To stop execution, hit the INTERRRUPT key (reset button) on the U4600. This will get you into the L4 kernel debugger, which is unlikely to be of much help for you (but if you want to try, it is documented in Appendix C of the L4 Reference Manual). However, you can then type
rbt
(reboot) to return to PMON, from where you can reboot your kernel.

Alternatively you can hit Control-D when in the kernel debugger. This will exit the debugger and resume the execution of the interrupted code.

A failed assertion (assert(0)) has the same effect as hitting the interrupt key. Alternatively, you can send a BREAK from the terminal emulator (Misc->Break).

If you INTERRUPT the U4600 but it doesn't get into the kernel debugger, you may have found a bug in our L4 microkernel. Please report it to us.
Last modified: 27 Jul 2005. [an error occurred while processing this directive]