Ten Step Process

1. Create directory /usr/xkernel and copy the compressed tar file from ftp://ftp.cs.arizona.edu/xkernel/xkernel.tar.Z into this directory. Then type:

   cd /usr/xkernel
   uncompress xkernel.tar.Z
   tar xf xkernel.tar

   This will create several subdirectories in /usr/xkernel. A description of the x-kernel directory hierarchy can be found in /usr/xkernel/README. Note that you can skip this step if the x-kernel has already been installed at your site.

2. Create a directory in which you will build an instance of the x-kernel . This is called your build directory, and in general, each different configuration of the x-kernel has its own build directory.

   cd /usr/xkernel/user_level/build
   mkdir solaris

   If directory /usr/xkernel/user_level/build/solaris already exists---because someone else has already followed this procedure---then you have two choices.
   1. Select another name for your build directory (e.g., mydir) and create a directory with this name in directory /usr/xkernel/user_level/build. The catch to this option is that you have to either have write permission in directory /usr/xkernel/user_level/build, or you have to have someone that has write permission create your build directory for you.

   2. Create a build directory in your own home directory; e.g., /usr/llp/xk_build/solaris. This is the preferred approach if a lot of different people are going to be building the x-kernel .

   Substitute the name of your build directory, as appropriate, in the rest of the steps.

3. Copy configuration files into your build directory.

   cd /usr/xkernel/user_level/build/solaris
   cp ../Template/Makefile.solaris Makefile
   cp ../Template/graph.comp .
   mkdir client server
   cp ../Template/rom.client client/rom
   cp ../Template/rom.server server/rom
   chmod 664 Makefile graph.comp client/rom server/rom

   Note that if your build directory is not in /usr/xkernel/user_level/build, then you will have to use the full path names for these various files (e.g., /usr/xkernel/user_level/build/Template/graph.comp) rather than the relative path names (e.g., ../Template/graph.comp) given above.

4. Edit the ``XRT ='' line of the Makefile you just copied into your build directory to reflect the root of your x-kernel source tree. Assuming your tree is at /usr/xkernel, this means changing

   XRT = ../../..

   to

   XRT = /usr/xkernel

   Note that this step is necessary only if your build directory is underneath your home directory. It is not necessary if your build directory is in /usr/xkernel/user_level/build since from there, ../../.. already points to the root of the x-kernel source tree.

5. Edit the last line of the graph.comp file you just copied into your build directory to reflect the root of your x-kernel tree. Assuming your tree is at /usr/kernel, this means changing

   prottbl=/cs/x33/etc/prottbl.std;

   to

   prottbl=/usr/xkernel/etc/prottbl.std;

6. Edit the two rom files you just copied to reflect the addresses of the two machines on which you will be running the x-kernel . This will involve editing the Real IP address field of the two lines that begin with arp. Specifically, edit client/rom by changing 192.12.69.186 in the first arp line to the IP address of machine A, and by changing 192.12.69.35 in the second arp line to the IP address of machine B. Edit server/rom in exactly the same way.

   Note that A and B can be the same machine, in this case, the same IP address is used in the rom file for both machines.

7. Put /usr/xkernel/bin/solaris-sparc and /usr/xkernel/bin in your search path. They should appear before /bin and /usr/bin in order to pick up GNU make before the standard Unix make. If you are building the x-kernel on a platform other than Solaris, then substitute sunos-sparc, osf1-alpha, irix-mips, linux-alpha, or linux-x86 for solaris-sparc, as appropriate. Also, make sure the GNU C compiler (gcc) is in your search path. (At Arizona, gcc can be found in directory /usr/local/bin.)

8. Build libraries necessary for your x-kernel . This could take quite a while.

   cd /usr/xkernel/user_level/build/solaris
   make system

   Note that you can skip this step if you are not the first person to build an x-kernel for this platform.

9. You are now ready to build the x-kernel .

   cd /usr/xkernel/user_level/build/solaris
   make compose
   make depend
   make

   This sequence should result in the creation of the binary file xkernel in your build directory. Note that you may see what appear to be error messages about missing files (e.g., Makefile.local and DEPS/Makedep.*) when you run make compose. These warnings can be ignored.

10. You are now ready to run the x-kernel . This will involve being logged onto both machines A and B. This is easiest to do by using a window-based interface and opening a separate terminal (shell) window on both A and B. First, on machine A type:

    cd /usr/xkernel/user_level/build/solaris/server
    ../xkernel -s

    This starts a version of the x-kernel on machine A that will act as a server for this run. Second, on machine B type:

    cd /usr/xkernel/user_level/build/solaris/client
    ../xkernel -c128.1.2.3

    This starts a version of the x-kernel on machine B that will act as a client for this run. Note that you have to start the server before the client. When the run is over, you can kill the x-kernel by typing Control-C on both A and B.

    The run involves the client establishing a TCP connection to the server, with a sequence of different-sized messages then sent back and forth between the client and the server. The time it takes to exchange 100 messages of each size between the client and the server will be printed out. For example, the output on the client will consist of a sequence of lines that look something like this:

    Protocol: TCP
    Time: Fri Jun  6 16:16:11 1997
    Host: cicada.CS.Arizona.EDU
    Participant: client
    Round Trips: 100 
    
    Message Length (bytes): 1
    Times (sec):
    select: Interrupted system call
         0.061818
         0.060986
         0.063218
    

    This means it took 0.061818 seconds (or 61ms) to send 100, 1-byte messages between the client and server machines, for an average of .61ms per round-trip.