The Composite directory hierarchy:
----------------------------------

The root of the directory structure includes only doc/ and src/.
Within doc/ is general documentation and within src/ is the entire
source tree.


Within src/:

1) components/ which includes all code pertaining to component
implementation. 

2) kernel/ which includes the files specific to the Composite kernel
that aren't dependent on the platform on which it is executed (bare
hardware, or using hijack in Linux).

3) platform/ include all code that is specific to the platform or
execution environment in which the kernel and components will be
executed.  Currently we only support execution in Linux by hijacking
the Linux kernel.  


Within src/components/:

1) interface/ includes a directory for every component interface in
Composite.  If you wish to implement a new component interface, this
is the place to do it.

2) implementation/ which includes specific component implementations.
Subdirectories exist, one per component interface (in interface/) and
subdirectories are each individual implementation of that interface.
If a component implements multiple interfaces, that is specified in
its Makefile, and the main one it implements is the subdirectory it's
source is under.  The Makefiles are important here and will be
discussed in the documentation files explaining how to create a
component or interface.

With src/components/implementation/other/* is a set of components that
do not have an interface.  They are never invoked by other components,
and instead just invoke components themselves.

3) include/ and lib/ have a number of include files and libraries that
implement generic functionality that is not specific to any one
component, but might be required by many (think libc).  Notably, both
dietlibc and lwip exist in lib/


Within platform/

Subdirectories for each platform.  Only linux/ currently exists.

Within platform/linux/:

1) link_load/ which includes the linker/loader for the system that
links each of the components into the correct virtual address
locations and connects them with the communication stubs, and loads
them into the address space.  This relies on binutils (and libbfd, the
binary file descriptor library) being installed.

2) module/ is the source code for the module that hijacks the Linux OS
by redirecting specific hardware traps (such as system call entry) to
Composite instead of to Linux.  See the hijack paper for some
details.  This compiles the src/kernel/ code as well.

3) net/ is the networking driver for Linux that allows us to redirect
ip packets that arrive at the host to a specific ip address to
Composite.  It is based on the tun/tap virtual networking device and
implements a virtual NIC (complete with ring-buffer) that interfaces
with the net_if component in Composite.

4) patch/ is the small Linux patch that must be applied to the Linux
kernel before we can insert the module in (2).  All the patch does
currently is export a couple of functions used by hijack.c in
module/.  Given a small amount of time, these could be side-stepped to
allow unmodified kernels to run Composite.

5) util/ includes the Makefile and the run script to execute Composite
and the components.
