plexus (plek'sus) n.
an exceedingly complex organization
or network syn: web, tapestry, jungle, labyrinth.
Plexus is a networking architecture that enables applications to
achieve high performance with customized protocols.
Application-specific protocols are written in
Modula-3 as extensions to the SPIN operating system.
Extensions are then dynamically installed into the operating system
kernel, where they can access the network interface and other
operating system services with low overhead.
The spin/user/net directory contains a set of subdirectories that
implement various protocols. Extensible communication protocols are
in a protocol directory and they only define protocol headers
and SPIN events; clients of these protocols implement the protocol
processing functions in separate directories. Currently the following
standard communication protocols are defined:
Ethernet,
IP,
UDP,
ICMP,
TCP.
It is simple to create a new
protocol within Plexus.
The protocolClient directories implement the processing
functions of the extensible protocol. It is simple to create a protocolClient. The following
clients have been created that implement the basic processing
functions of a protocol and provide a few other servers.
- etherClient: provides
functionality to send and receive ethernet packets. It raises the
IP.PacketArrived event and implements both ARP resolution and responds
to ARP requests.
- ipClient: provides functionality to
send and receive IP packets, has support for both packet fragmentation
and reassembly, and raises the Icmp.PacketArrived, Udp.PacketArrived,
and Tcp.PacketArrived event. It also implements the IP routing
support.
- icmpClient: provides functionality
to send and receive Icmp packets. Handles icmp echo request packets
(i.e., it responds to ping packets).
- tcpClient: provides functionality
to send and receive TCP packets. It implements TCP packet
redirection, which can be used to forward TCP packets without going
through the full TCP processing. For example, it could be used to
build a low overhead firewall that filters connections on a per TCP
port basis.
- udpClient: provides functionality
to send and receive UDP packets. It implements UDP packet
redirection, which can be used to forward UDP. This has also been
used to build a firewall benchmark
- osfClient: this is a special client
that interfaces with the DEC UNIX networking code. It provides
specialized send functions for both UDP and TCP, and installs handlers
on the Udp.PacketArrived and Tcp.PacketArrived based on the local port
a socket is bound to. The osfClient calls into URT's OsfNet
module to register special TCP and UDP send functions that should be
used by the Digital Unix networking code.
Abstractly, a protocol stack is structured as a graph of event raisers
and event handlers. Nodes in the graph represent protocols for which
protocol events are raised to announce or request the passage of a
packet through the node. The protocol processing functions are
implemented by event handlers that are attached to the protocol
event name.
HERE WILL BE A BIG FIGURE THAT ILLUSTRATES THE PROTOCOL GRAPH
Each incoming packet is pushed through the protocol graph by
events and pulled by handlers. We have describe the
motivation and implementation of Plexus in a
Usenix
paper which should provide more detail.
Marc Fiuczynski
DAY/MONTH/YEAR