Nachos: Installation and Getting Started
The best way to get started with Nachos is to install it
in your account, build it, and try it out.
This document describes the installation procedure, and gives
a brief overview of the structure of the Nachos code.
Setting Up Your Account
The Nachos software is built using the GNU make program.
You will need to modify your PATH environment variable
so that when you run make, GNU make, and
not some other make, will be executed.
Your PATH should also include /u/cs350/bin,
since there are a number of useful Nachos-related programs there.
Your PATH is normally set by a command in your
.cshrc file, in your home directory, each time
you log in.
(If you are using some shell other than csh, it
should have its own startup file, which you can modify.)
In the CSCF standard
.cshrc file, you can do this by changing the line
- setenv PATH `/bin/showpath standard`
Note the backquotes that are used in the above commands. They
are important, and they must be backquotes and not regular forward
Note also that the gnu argument must come before
standard in order for GNU make to become the default.
- setenv PATH `/bin/showpath gnu /u/cs350/bin standard`
This change will take effect the next time you log in.
If you would like the change to take effect immediately, you need
to get your shell to re-load the initialization file you just
Assuming you are using csh, you can do that
by typing source ~/.cshrc.
Create a directory that will contain the nachos installation (ie ~/cs350).
To install Nachos, use
the script /u/cs350/bin/install_nachos.
This script takes one parameter, which is the name
of the directory into which Nachos should be installed.
Assuming that your PATH has been set up as
described above, you should be able to type
where cs350 is the name of the directory.
- install_nachos cs350
Once Nachos is installed, you should try compiling it.
There are actually three separate chunks of code that get installed
in your account when you run install_nachos.
One is the code for the nachos program itself.
This program is written in C++ and
implements the machine simulation and the
operating system for the simulated machine.
The second is a set of test programs.
These programs are written in C.
They run on the simulated machine, and are used
to test its operating system.
The third is the coff2noff program for converning a
COFF (Common Object File Format) file to
a NOFF file (Nachos Object File Format).
The first chunk is by far the largest of the three.
These three chunks of code must be built separately.
First build the coff2noff program in the directory
(All relative pathnames are assumed to be relative to
the main Nachos directory, which is cs350_XX/nachos
if you installed nachos in cs350_XX.)
To build coff2noff, change into the coff2noff
directory and type
The test programs live in, and are built in, the
(They require the use of coff2noff, so you must compile
In the directory code/test ,
you will find a Makefile, which can
be used to build the test programs.
The Makefile contains instructions on how to do the build.
The source code for the nachos program itself lives
in several directories:
code/lib, code/machine, code/threads, code/filesys,
code/userprog, and code/network.
The program is built using the Makefile in one of the
You need to choose a build directory depending on the
type of machine you are currently logged in to.
As of January 2003, all of the CPU servers in the CSCF
undergraduate environment are running Solaris, so you
should work in the build.solaris directory.
Once you are in the appropriate build directory, read the
Makefile carefully, and follow the instructions in it.
It explains how to build the nachos program.
Once you have built nachos, you should be able
to run it by simply typing
in the build directory.
The command line argument -u will give you a list
of the available command line options.
Using these options, you can control what nachos
does when it runs.
For starters, you may wish to try the -K and
-C flags, which run some simple self-tests.
You can also try asking Nachos to run a very simple test program
called halt, which is found in the code/test
To try this, type
The -d ca turns on the address space (a)
and system call (c) related debugging output.
The halt program simply makes the "Halt" system
call, which causes the machine simulator to halt and print
out some statistics.
Have a look at the halt program.
It is in code/test/halt.c.
- ./nachos -d ca -x ../test/halt
For more details, you can look in the file code/threads/main.cc.
In fact, this is the best place to start reading the Nachos code,
since this is where it all begins.
Nachos Directory Structure
The main nachos directory contains three sub-directories:
The source code and Makefiles for coff2noff, which is a program for converting
COFF (Common Object File Format) files
to NOFF (Nachos Object File Format) files.
Note that noff.h in this directory is a link to the file noff.h in
- The Nachos operating system is written in a subset of C++.
This directory contains an excellent primer on C++.
This primer is good reading for those who need a refresher,
and even for those of you who are experienced C++ programmers.
In particular, it explains why some of the "features" of
C++ are not used at all in Nachos.
- All of the source code for the Nachos operating system, the machine
simulation, and the test programs can be found here.
This code is organized into several sub-directories:
- utilities used by the rest of the Nachos code
- The machine simulation. Except as noted in machine.h,
you may not modify the code in this directory.
- Nachos is a multi-threaded program. Thread support is found
here. This directory also contains the main() routine
of the nachos program, in main.cc.
- Nachos operating system code to support the creation of
address spaces, loading of user (test) programs,
and execution of test programs on the simulated machine.
The exception handling code is here, in exception.cc.
- Two different file system implementations are here.
The "real" file system uses the simulated workstation's simulated
disk to hold files.
A "stub" file system translates Nachos file system calls into
UNIX file system calls.
This is useful initially, so that files can be used (e.g., to
hold user programs) before you have had a chance to fix up
the "real" file system.
By default, the "stub" file system is build into the nachos
program and the "real" file system is not. This can be changed
by setting a flag in the Nachos makefile.
- Nachos operating system support for networking, which
implements a simple "post office" facility.
simulated Nachos machines can talk to each other through a
Unix sockets are used to simulate network connections among the
- User test programs to run on the simulated machine.
As indicated earlier, these are separate from the source for
the Nachos operating system and workstation simulation.
This directory contains its own Makefile.
The test programs are very simple and are
written in C rather than C++.